From 650ffc5053cdca4b6ad2e027fa1f4fd90ef64871 Mon Sep 17 00:00:00 2001
From: Nikita Masych <92444221+NikitaMasych@users.noreply.github.com>
Date: Fri, 23 Feb 2024 16:55:17 +0200
Subject: [PATCH 001/416] feat: Add HashMap to the stdlib (#4242)

# Description

This PR shall bring HashMap into the `stdlib` of Noir.

## Problem\*

Resolves #4241

## Summary\*

Implementation of `HashMap` with open addressing and quadratic probing
scheme. Since Noir requires knowing loop bounds (and recursive calls) at
compile time, `HashMap` is of fixed capacity and **no** dynamic resize
is accomplished with regard to load factor.

Furthermore, contribution includes implementation of `PedersenHasher` to
be used for now. One can examine potentially better and less heavy
prehash functions.

I tried to conform with best practices of engineering, however since
Noir is in rapid development, there are certain things which may be
optimized in future, both from the code style and performance point of
view.


## Additional Context

I put the `PedersenHasher` among the `poseidon.nr` and `mimc.nr`, so one
can consider moving declaration of other pedersen-related functionality
there, however that would be a breaking change.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/collections.nr                |   1 +
 noir_stdlib/src/collections/map.nr            | 456 ++++++++++++++++++
 noir_stdlib/src/hash.nr                       |  52 ++
 noir_stdlib/src/hash/pedersen.nr              |  24 +
 .../hashmap_load_factor/Nargo.toml            |   6 +
 .../hashmap_load_factor/Prover.toml           |  26 +
 .../hashmap_load_factor/src/main.nr           |  35 ++
 .../execution_success/hashmap/Nargo.toml      |   6 +
 .../execution_success/hashmap/Prover.toml     |  26 +
 .../execution_success/hashmap/src/main.nr     | 192 ++++++++
 .../execution_success/hashmap/src/utils.nr    |  10 +
 11 files changed, 834 insertions(+)
 create mode 100644 noir_stdlib/src/collections/map.nr
 create mode 100644 noir_stdlib/src/hash/pedersen.nr
 create mode 100644 test_programs/compile_failure/hashmap_load_factor/Nargo.toml
 create mode 100644 test_programs/compile_failure/hashmap_load_factor/Prover.toml
 create mode 100644 test_programs/compile_failure/hashmap_load_factor/src/main.nr
 create mode 100644 test_programs/execution_success/hashmap/Nargo.toml
 create mode 100644 test_programs/execution_success/hashmap/Prover.toml
 create mode 100644 test_programs/execution_success/hashmap/src/main.nr
 create mode 100644 test_programs/execution_success/hashmap/src/utils.nr

diff --git a/noir_stdlib/src/collections.nr b/noir_stdlib/src/collections.nr
index 177ca96816f..2d952f4d6cd 100644
--- a/noir_stdlib/src/collections.nr
+++ b/noir_stdlib/src/collections.nr
@@ -1,2 +1,3 @@
 mod vec;
 mod bounded_vec;
+mod map;
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
new file mode 100644
index 00000000000..d9eb83ff5dc
--- /dev/null
+++ b/noir_stdlib/src/collections/map.nr
@@ -0,0 +1,456 @@
+use crate::cmp::Eq;
+use crate::collections::vec::Vec;
+use crate::option::Option;
+use crate::default::Default;
+use crate::hash::{Hash, Hasher, BuildHasher};
+
+// We use load factor α_max = 0.75. 
+// Upon exceeding it, assert will fail in order to inform the user 
+// about performance degradation, so that he can adjust the capacity.
+global MAX_LOAD_FACTOR_NUMERATOR = 3;
+global MAX_LOAD_FACTOR_DEN0MINATOR = 4;
+
+// Hash table with open addressing and quadratic probing.
+// Size of the underlying table must be known at compile time.
+// It is advised to select capacity N as a power of two, or a prime number 
+// because utilized probing scheme is best tailored for it.
+struct HashMap<K, V, N, B> {
+    _table: [Slot<K, V>; N],
+
+    // Amount of valid elements in the map.
+    _len: u64,
+
+    _build_hasher: B
+}
+
+// Data unit in the HashMap table.
+// In case Noir adds support for enums in the future, this  
+// should be refactored to have three states:
+// 1. (key, value)
+// 2. (empty)
+// 3. (deleted)
+struct Slot<K, V> {
+    _key_value: Option<(K, V)>,
+    _is_deleted: bool,
+}
+
+impl<K, V> Default for Slot<K, V>{
+    fn default() -> Self{
+        Slot{
+            _key_value: Option::none(),
+            _is_deleted: false
+        }
+    }
+}
+
+impl<K, V> Slot<K, V> {
+    fn is_valid(self) -> bool {
+        !self._is_deleted & self._key_value.is_some()
+    }
+
+    fn is_available(self) -> bool {
+        self._is_deleted | self._key_value.is_none()
+    }
+
+    fn key_value(self) -> Option<(K, V)> {
+        self._key_value
+    }
+
+    fn key_value_unchecked(self) -> (K, V) {
+        self._key_value.unwrap_unchecked()
+    }
+
+    fn set(&mut self, key: K, value: V) {
+        self._key_value = Option::some((key, value));
+        self._is_deleted = false;
+    }
+
+    // Shall not override `_key_value` with Option::none(),
+    // because we must be able to differentiate empty 
+    // and deleted slots for lookup.
+    fn mark_deleted(&mut self) {
+        self._is_deleted = true;
+    }
+}
+
+// While conducting lookup, we iterate attempt from 0 to N - 1 due to heuristic,
+// that if we have went that far without finding desired, 
+// it is very unlikely to be after - performance will be heavily degraded.
+impl<K, V, N, B, H> HashMap<K, V, N, B> {
+    // Creates a new instance of HashMap with specified BuildHasher.
+    pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+        let _table = [Slot::default(); N];
+        let _len = 0;
+        Self { _table, _len, _build_hasher }
+    }
+
+    // Clears the map, removing all key-value entries.
+    pub fn clear(&mut self) {
+        self._table = [Slot::default(); N];
+        self._len = 0;
+    }
+
+    // Returns true if the map contains a value for the specified key.
+    pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+        self.get(key).is_some()
+    }
+
+    // Returns true if the map contains no elements.
+    pub fn is_empty(self) -> bool {
+        self._len == 0
+    }
+
+    // Get the Option<(K, V) array of valid entries 
+    // with a length of map capacity. First len() elements 
+    // are safe to unwrap_unchecked(), whilst remaining 
+    // are guaranteed to be Option::none().
+    //
+    // This design is reasoned by compile-time limitations and
+    // temporary nested slices ban. 
+    pub fn entries(self) -> [Option<(K, V)>; N] {
+        let mut entries = [Option::none(); N];
+        let mut valid_amount = 0;
+
+        for slot in self._table {
+            if slot.is_valid() {
+                entries[valid_amount] = slot.key_value();
+                valid_amount += 1;
+            }
+        }
+
+        let msg = f"Amount of valid elements should have been {self._len} times, but got {valid_amount}.";
+        assert(valid_amount == self._len, msg);
+
+        entries
+    }
+
+    // Get the Option<K> array of valid keys 
+    // with a length of map capacity. First len() elements 
+    // are safe to unwrap_unchecked(), whilst remaining 
+    // are guaranteed to be Option::none().
+    //
+    // This design is reasoned by compile-time limitations and
+    // temporary nested slices ban. 
+    pub fn keys(self) -> [Option<K>; N] {
+        let mut keys = [Option::none(); N];
+        let mut valid_amount = 0;
+
+        for slot in self._table {
+            if slot.is_valid() {
+                let (key, _) = slot.key_value_unchecked();
+                keys[valid_amount] = Option::some(key);
+                valid_amount += 1;
+            }
+        }
+
+        let msg = f"Amount of valid elements should have been {self._len} times, but got {valid_amount}.";
+        assert(valid_amount == self._len, msg);
+
+        keys
+    }
+
+    // Get the Option<V> array of valid values 
+    // with a length of map capacity. First len() elements 
+    // are safe to unwrap_unchecked(), whilst remaining 
+    // are guaranteed to be Option::none().
+    //
+    // This design is reasoned by compile-time limitations and
+    // temporary nested slices ban. 
+    pub fn values(self) -> [Option<V>; N] {
+        let mut values = [Option::none(); N];
+        let mut valid_amount = 0;
+
+        for slot in self._table {
+            if slot.is_valid() {
+                let (_, value) = slot.key_value_unchecked();
+                values[valid_amount] = Option::some(value);
+                valid_amount += 1;
+            }
+        }
+
+        let msg = f"Amount of valid elements should have been {self._len} times, but got {valid_amount}.";
+        assert(valid_amount == self._len, msg);
+
+        values
+    }
+
+    // For each key-value entry applies mutator function.
+    pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+        let mut entries = self.entries();
+        let mut new_map = HashMap::with_hasher(self._build_hasher);
+
+        for i in 0..N {
+            if i < self._len {
+                let entry = entries[i].unwrap_unchecked();
+                let (key, value) = f(entry.0, entry.1);
+                new_map.insert(key, value);
+            }
+        }
+
+        self._table = new_map._table;
+    }
+
+    // For each key applies mutator function.
+    pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+        let mut entries = self.entries();
+        let mut new_map = HashMap::with_hasher(self._build_hasher);
+
+        for i in 0..N {
+            if i < self._len {
+                let entry = entries[i].unwrap_unchecked();
+                let (key, value) = (f(entry.0), entry.1);
+                new_map.insert(key, value);
+            }
+        }
+
+        self._table = new_map._table;
+    }
+
+    // For each value applies mutator function.
+    pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+        for i in 0..N {
+            let mut slot = self._table[i];
+            if slot.is_valid() {
+                let (key, value) = slot.key_value_unchecked();
+                slot.set(key, f(value));
+                self._table[i] = slot;
+            }
+        }
+    }
+
+    // Retains only the elements specified by the predicate.
+    pub fn retain(&mut self, f: fn(K, V) -> bool) {
+        for index in 0..N {
+            let mut slot = self._table[index];
+            if slot.is_valid() {
+                let (key, value) = slot.key_value_unchecked();
+                if !f(key, value) {
+                    slot.mark_deleted();
+                    self._len -= 1;
+                    self._table[index] = slot;
+                }
+            }
+        }
+    }
+
+    // Amount of active key-value entries.
+    pub fn len(self) -> u64 {
+        self._len
+    }
+
+    // Get the compile-time map capacity.
+    pub fn capacity(_self: Self) -> u64 {
+        N
+    }
+
+    // Get the value by key. If it does not exist, returns none().
+    pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+        let mut result = Option::none();
+
+        let hash = self.hash(key);
+        let mut break = false;
+
+        for attempt in 0..N {
+            if !break {
+                let index = self.quadratic_probe(hash, attempt as u64);
+                let slot = self._table[index];
+
+                // Not marked as deleted and has key-value.
+                if slot.is_valid() {
+                    let (current_key, value) = slot.key_value_unchecked();
+                    if current_key == key {
+                        result = Option::some(value);
+                        break = true;
+                    }
+                }
+            }
+        }
+
+        result
+    }
+
+    // Insert key-value entry. In case key was already present, value is overridden. 
+    pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+        self.assert_load_factor();
+
+        let hash = self.hash(key);
+        let mut break = false;
+
+        for attempt in 0..N {
+            if !break {
+                let index = self.quadratic_probe(hash, attempt as u64);
+                let mut slot = self._table[index];
+                let mut insert = false;
+
+                // Either marked as deleted or has unset key-value.
+                if slot.is_available() {
+                    insert = true;
+                    self._len += 1;
+                } else {
+                    let (current_key, _) = slot.key_value_unchecked();
+                    if current_key == key {
+                        insert = true;
+                    }
+                }
+
+                if insert {
+                    slot.set(key, value);
+                    self._table[index] = slot;
+                    break = true;
+                }
+            }
+        }
+    }
+
+    // Remove key-value entry. If key is not present, HashMap remains unchanged.
+    pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+        let hash = self.hash(key);
+        let mut break = false;
+
+        for attempt in 0..N {
+            if !break {
+                let index = self.quadratic_probe(hash, attempt as u64);
+                let mut slot = self._table[index];
+
+                // Not marked as deleted and has key-value.
+                if slot.is_valid() {
+                    let (current_key, _) = slot.key_value_unchecked();
+                    if current_key == key {
+                        slot.mark_deleted();
+                        self._table[index] = slot;
+                        self._len -= 1;
+                        break = true;
+                    }
+                }
+            }
+        }
+    }
+
+    // Apply HashMap's hasher onto key to obtain pre-hash for probing.
+    fn hash(
+        self,
+        key: K
+    ) -> u64
+    where
+        K: Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+        let mut hasher = self._build_hasher.build_hasher();
+        key.hash(&mut hasher);
+        hasher.finish() as u64
+    }
+
+    // Probing scheme: quadratic function.
+    // We use 0.5 constant near variadic attempt and attempt^2 monomials.
+    // This ensures good uniformity of distribution for table sizes
+    // equal to prime numbers or powers of two. 
+    fn quadratic_probe(_self: Self, hash: u64, attempt: u64) -> u64 {
+        (hash + (attempt + attempt * attempt) / 2) % N
+    }
+
+    // Amount of elements in the table in relation to available slots exceeds α_max. 
+    // To avoid a comparatively more expensive division operation 
+    // we conduct cross-multiplication instead.
+    // n / m >= MAX_LOAD_FACTOR_NUMERATOR / MAX_LOAD_FACTOR_DEN0MINATOR 
+    // n * MAX_LOAD_FACTOR_DEN0MINATOR >= m * MAX_LOAD_FACTOR_NUMERATOR
+    fn assert_load_factor(self) {
+        let lhs = self._len * MAX_LOAD_FACTOR_DEN0MINATOR;
+        let rhs = self._table.len() as u64 * MAX_LOAD_FACTOR_NUMERATOR;
+        let exceeded = lhs >= rhs;
+        assert(!exceeded, "Load factor is exceeded, consider increasing the capacity.");
+    }
+}
+
+// Equality class on HashMap has to test that they have 
+// equal sets of key-value entries, 
+// thus one is a subset of the other and vice versa.
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool{
+        let mut equal = false;
+
+        if self.len() == other.len(){
+            equal = true;
+            for slot in self._table{
+                // Not marked as deleted and has key-value.
+                if equal & slot.is_valid(){
+                    let (key, value) = slot.key_value_unchecked();
+                    let other_value = other.get(key);
+
+                    if other_value.is_none(){
+                        equal = false;
+                    }else{
+                        let other_value = other_value.unwrap_unchecked();
+                        if value != other_value{
+                            equal = false;
+                        }
+                    }
+                }
+            }
+        }
+
+        equal
+    }
+}
+
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self{
+        let _build_hasher = B::default();
+        let map: HashMap<K, V, N, B> = HashMap::with_hasher(_build_hasher);
+        map
+    }
+}
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index cc864039a90..7a931f7c047 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -1,5 +1,8 @@
 mod poseidon;
 mod mimc;
+mod pedersen;
+
+use crate::default::Default;
 
 #[foreign(sha256)]
 // docs:start:sha256
@@ -74,3 +77,52 @@ pub fn poseidon2_permutation<N>(_input: [u8; N], _state_length: u32) -> [u8; N]
 
 #[foreign(sha256_compression)]
 pub fn sha256_compression(_input: [u32; 16], _state: [u32; 8]) -> [u32; 8] {}
+
+// Generic hashing support. 
+// Partially ported and impacted by rust.
+
+// Hash trait shall be implemented per type.
+trait Hash{
+    fn hash<H>(self, state: &mut H) where H: Hasher;
+}
+
+// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.
+// TODO: consider making the types generic here ([u8], [Field], etc.)
+trait Hasher{
+    fn finish(self) -> Field;
+    
+    fn write(&mut self, input: [Field]);
+}
+
+// BuildHasher is a factory trait, responsible for production of specific Hasher.
+trait BuildHasher<H> where H: Hasher{
+    fn build_hasher(self) -> H;
+}
+
+struct BuildHasherDefault<H>;
+
+impl<H> BuildHasher<H> for BuildHasherDefault<H>
+where 
+    H: Hasher + Default
+{
+    fn build_hasher(_self: Self) -> H{
+        H::default()
+    }
+}
+
+impl<H> Default for BuildHasherDefault<H>
+where 
+    H: Hasher + Default
+{
+    fn default() -> Self{
+        BuildHasherDefault{}
+    }    
+}
+
+// TODO: add implementations for the remainder of primitive types.
+impl Hash for Field{
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        let input: [Field] = [self];
+        H::write(state, input);
+    }
+}
diff --git a/noir_stdlib/src/hash/pedersen.nr b/noir_stdlib/src/hash/pedersen.nr
new file mode 100644
index 00000000000..ace6851099d
--- /dev/null
+++ b/noir_stdlib/src/hash/pedersen.nr
@@ -0,0 +1,24 @@
+use crate::hash::{Hasher, pedersen_hash};
+use crate::default::Default;
+
+struct PedersenHasher{
+    _state: [Field]
+}
+
+impl Hasher for PedersenHasher {
+    fn finish(self) -> Field {
+       pedersen_hash(self._state)
+    }
+
+    fn write(&mut self, input: [Field]){
+        self._state = self._state.append(input);
+    }
+}
+
+impl Default for PedersenHasher{
+    fn default() -> Self{
+        PedersenHasher{
+            _state: []
+        }
+    }
+}
diff --git a/test_programs/compile_failure/hashmap_load_factor/Nargo.toml b/test_programs/compile_failure/hashmap_load_factor/Nargo.toml
new file mode 100644
index 00000000000..92da5a357f4
--- /dev/null
+++ b/test_programs/compile_failure/hashmap_load_factor/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "hashmap_load_factor"
+type = "bin"
+authors = [""]
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/hashmap_load_factor/Prover.toml b/test_programs/compile_failure/hashmap_load_factor/Prover.toml
new file mode 100644
index 00000000000..e54319c61e9
--- /dev/null
+++ b/test_programs/compile_failure/hashmap_load_factor/Prover.toml
@@ -0,0 +1,26 @@
+# Expected 6 key-value entries for hashmap capacity of 8.
+# These must be distinct (both key-to-key, and value-to-value) for correct testing.
+
+[[input]]
+key = 2
+value = 17
+
+[[input]]
+key = 3
+value = 19
+
+[[input]]
+key = 5
+value = 23
+
+[[input]]
+key = 7
+value = 29
+
+[[input]]
+key = 11
+value = 31
+
+[[input]]
+key = 41
+value = 43
\ No newline at end of file
diff --git a/test_programs/compile_failure/hashmap_load_factor/src/main.nr b/test_programs/compile_failure/hashmap_load_factor/src/main.nr
new file mode 100644
index 00000000000..ade43f898e1
--- /dev/null
+++ b/test_programs/compile_failure/hashmap_load_factor/src/main.nr
@@ -0,0 +1,35 @@
+use dep::std::collections::map::HashMap;
+use dep::std::hash::BuildHasherDefault;
+use dep::std::hash::pedersen::PedersenHasher;
+
+struct Entry{
+    key: Field,
+    value: Field
+}
+
+global HASHMAP_CAP = 8;
+global HASHMAP_LEN = 6;
+
+fn allocate_hashmap() -> HashMap<Field, Field, HASHMAP_CAP, BuildHasherDefault<PedersenHasher>> {
+    HashMap::default()
+}
+
+fn main(input: [Entry; HASHMAP_LEN]) {
+    test_load_factor(input);
+}
+
+// In this test we exceed load factor:
+// α_max = 0.75, thus for capacity of 8 and lenght of 6
+// insertion of new unique key (7-th) should throw assertion error.
+fn test_load_factor(input: [Entry; HASHMAP_LEN]) {
+    let mut hashmap = allocate_hashmap();
+
+    for entry in input {
+        hashmap.insert(entry.key, entry.value);
+    }
+
+    // We use prime numbers for testing, 
+    // therefore it is guaranteed that doubling key we get unique value.
+    let key = input[0].key * 2;
+    hashmap.insert(key, input[0].value);
+}
diff --git a/test_programs/execution_success/hashmap/Nargo.toml b/test_programs/execution_success/hashmap/Nargo.toml
new file mode 100644
index 00000000000..c09debc9833
--- /dev/null
+++ b/test_programs/execution_success/hashmap/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "hashmap"
+type = "bin"
+authors = [""]
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/hashmap/Prover.toml b/test_programs/execution_success/hashmap/Prover.toml
new file mode 100644
index 00000000000..84d4c0733e4
--- /dev/null
+++ b/test_programs/execution_success/hashmap/Prover.toml
@@ -0,0 +1,26 @@
+# Input: 6 key-value entries for hashmap capacity of 8.
+# These must be distinct (both key-to-key, and value-to-value) for correct testing.
+
+[[input]]
+key = 2
+value = 17
+
+[[input]]
+key = 3
+value = 19
+
+[[input]]
+key = 5
+value = 23
+
+[[input]]
+key = 7
+value = 29
+
+[[input]]
+key = 11
+value = 31
+
+[[input]]
+key = 41
+value = 43
\ No newline at end of file
diff --git a/test_programs/execution_success/hashmap/src/main.nr b/test_programs/execution_success/hashmap/src/main.nr
new file mode 100644
index 00000000000..597a5c0b7de
--- /dev/null
+++ b/test_programs/execution_success/hashmap/src/main.nr
@@ -0,0 +1,192 @@
+mod utils;
+
+use dep::std::collections::map::HashMap;
+use dep::std::hash::BuildHasherDefault;
+use dep::std::hash::pedersen::PedersenHasher;
+use dep::std::cmp::Eq;
+
+use utils::cut;
+
+type K = Field;
+type V = Field;
+
+// It is more convenient and readable to use structs as input.
+struct Entry{
+    key: Field,
+    value: Field
+}
+
+global HASHMAP_CAP = 8;
+global HASHMAP_LEN = 6;
+
+global FIELD_CMP = |a: Field, b: Field| a.lt(b);
+
+global K_CMP = FIELD_CMP;
+global V_CMP = FIELD_CMP;
+global KV_CMP = |a: (K, V), b: (K, V)| a.0.lt(b.0);
+
+global ALLOCATE_HASHMAP = || -> HashMap<K, V, HASHMAP_CAP, BuildHasherDefault<PedersenHasher>> 
+    HashMap::default();
+
+fn main(input: [Entry; HASHMAP_LEN]) {
+    test_sequential(input[0].key, input[0].value);
+    test_multiple_equal_insert(input[1].key, input[1].value);
+    test_value_override(input[2].key, input[2].value, input[3].value);
+    test_insert_and_methods(input);
+    test_hashmaps_equality(input);
+    test_retain();
+    test_iterators();
+    test_mut_iterators();
+}
+
+// Insert, get, remove.
+fn test_sequential(key: K, value: V) {
+    let mut hashmap = ALLOCATE_HASHMAP();
+    assert(hashmap.is_empty(), "New HashMap should be empty.");
+
+    hashmap.insert(key, value);
+    assert(hashmap.len() == 1, "HashMap after one insert should have a length of 1 element.");
+
+    let got = hashmap.get(key);
+    assert(got.is_some(), "Got none value.");
+    let got = got.unwrap_unchecked();
+    assert(value == got, f"Inserted {value} but got {got} for the same key.");
+
+    hashmap.remove(key);
+    assert(hashmap.is_empty(), "HashMap after one insert and corresponding removal should be empty.");
+    let got = hashmap.get(key);
+    assert(got.is_none(), "Value has been removed, but is still available (not none).");
+}
+
+// Insert same pair several times.
+fn test_multiple_equal_insert(key: K, value: V) {
+    let mut hashmap = ALLOCATE_HASHMAP();
+    assert(hashmap.is_empty(), "New HashMap should be empty.");
+
+    for _ in 0..HASHMAP_LEN {
+        hashmap.insert(key, value);
+    }
+
+    let len = hashmap.len();
+    assert(len == 1, f"HashMap length must be 1, got {len}.");
+
+    let got = hashmap.get(key);
+    assert(got.is_some(), "Got none value.");
+    let got = got.unwrap_unchecked();
+    assert(value == got, f"Inserted {value} but got {got} for the same key.");
+}
+
+// Override value for existing pair.
+fn test_value_override(key: K, value: V, new_value: V) {
+    let mut hashmap = ALLOCATE_HASHMAP();
+    assert(hashmap.is_empty(), "New hashmap should be empty.");
+
+    hashmap.insert(key, value);
+    hashmap.insert(key, new_value);
+    assert(hashmap.len() == 1, "HashMap length is invalid.");
+
+    let got = hashmap.get(key);
+    assert(got.is_some(), "Got none value.");
+    let got = got.unwrap_unchecked();
+    assert(got == new_value, f"Expected {new_value}, but got {got}.");
+}
+
+// Insert several distinct pairs and test auxiliary methods.
+fn test_insert_and_methods(input: [Entry; HASHMAP_LEN]) {
+    let mut hashmap = ALLOCATE_HASHMAP();
+    assert(hashmap.is_empty(), "New HashMap should be empty.");
+
+    for entry in input {
+        hashmap.insert(entry.key, entry.value);
+    }
+
+    assert(hashmap.len() == HASHMAP_LEN, "hashmap.len() does not match input lenght.");
+
+    for entry in input {
+        assert(hashmap.contains_key(entry.key), f"Not found inserted key {entry.key}.");
+    }
+
+    hashmap.clear();
+    assert(hashmap.is_empty(), "HashMap after clear() should be empty.");
+}
+
+// Insert several pairs and test retaining.
+fn test_retain() {
+    let mut hashmap = ALLOCATE_HASHMAP();
+    assert(hashmap.is_empty(), "New HashMap should be empty.");
+
+    let (key, value) = (5, 11);
+    hashmap.insert(key, value);
+    let (key, value) = (2, 13);
+    hashmap.insert(key, value);
+    let (key, value) = (11, 5);
+    hashmap.insert(key, value);
+
+    let predicate = |key: K, value: V| -> bool {key * value == 55};
+    hashmap.retain(predicate);
+
+    assert(hashmap.len() == 2, "HashMap should have retained 2 elements.");
+    assert(hashmap.get(2).is_none(), "Pair should have been removed, since it does not match predicate.");
+}
+
+// Equality trait check.
+fn test_hashmaps_equality(input: [Entry; HASHMAP_LEN]) {
+    let mut hashmap_1 = ALLOCATE_HASHMAP();
+    let mut hashmap_2 = ALLOCATE_HASHMAP();
+
+    for entry in input {
+        hashmap_1.insert(entry.key, entry.value);
+        hashmap_2.insert(entry.key, entry.value);
+    }
+
+    assert(hashmap_1 == hashmap_2, "HashMaps should be equal.");
+
+    hashmap_2.remove(input[0].key);
+
+    assert(hashmap_1 != hashmap_2, "HashMaps should not be equal.");
+}
+
+// Test entries, keys, values.
+fn test_iterators() {
+    let mut hashmap = ALLOCATE_HASHMAP();
+
+    hashmap.insert(2, 3);
+    hashmap.insert(5, 7);
+    hashmap.insert(11, 13);
+
+    let keys: [K; 3] = cut(hashmap.keys()).map(|k: Option<K>| k.unwrap_unchecked()).sort_via(K_CMP);
+    let values: [V; 3] = cut(hashmap.values()).map(|v: Option<V>| v.unwrap_unchecked()).sort_via(V_CMP);
+    let entries: [(K, V); 3] = cut(hashmap.entries()).map(|e: Option<(K, V)>| e.unwrap_unchecked()).sort_via(KV_CMP);
+
+    assert(keys == [2, 5, 11], "Got incorrect iteration of keys.");
+    assert(values == [3, 7, 13], "Got incorrect iteration of values.");
+    assert(entries == [(2, 3), (5, 7), (11, 13)], "Got incorrect iteration of entries.");
+}
+
+// Test mutable iteration over keys, values and entries.
+fn test_mut_iterators() {
+    let mut hashmap = ALLOCATE_HASHMAP();
+
+    hashmap.insert(2, 3);
+    hashmap.insert(5, 7);
+    hashmap.insert(11, 13);
+
+    let f = |k: K| -> K{ k * 3};
+    hashmap.iter_keys_mut(f);
+
+    let f = |v: V| -> V{ v * 5};
+    hashmap.iter_values_mut(f);
+
+    let keys: [K; 3] = cut(hashmap.keys()).map(|k: Option<K>| k.unwrap_unchecked()).sort_via(K_CMP);
+    let values: [V; 3] = cut(hashmap.values()).map(|v: Option<V>| v.unwrap_unchecked()).sort_via(V_CMP);
+
+    assert(keys == [6, 15, 33], f"Got incorrect iteration of keys: {keys}");
+    assert(values == [15, 35, 65], "Got incorrect iteration of values.");
+
+    let f = |k: K, v: V| -> (K, V){(k * 2, v * 2)};
+    hashmap.iter_mut(f);
+
+    let entries: [(K, V); 3] = cut(hashmap.entries()).map(|e: Option<(K, V)>| e.unwrap_unchecked()).sort_via(KV_CMP);
+
+    assert(entries == [(12, 30), (30, 70), (66, 130)], "Got incorrect iteration of entries.");
+}
diff --git a/test_programs/execution_success/hashmap/src/utils.nr b/test_programs/execution_success/hashmap/src/utils.nr
new file mode 100644
index 00000000000..45c9ca9bbf7
--- /dev/null
+++ b/test_programs/execution_success/hashmap/src/utils.nr
@@ -0,0 +1,10 @@
+// Compile-time: cuts the M first elements from the [T; N] array.
+pub(crate) fn cut<T, N, M>(input: [T; N]) -> [T; M] {
+    assert(M as u64 < N as u64, "M should be less than N.");
+
+    let mut new = [dep::std::unsafe::zeroed(); M];
+    for i in 0..M {
+        new[i] = input[i];
+    }
+    new
+}

From 16d5f18c68cc3da1d11c98e101e3942d2437c3a8 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Fri, 23 Feb 2024 15:06:15 +0000
Subject: [PATCH 002/416] chore(ssa): Remove mem2reg run before flattening
 (#4415)

# Description

## Problem\*

Before https://github.com/noir-lang/noir/pull/4240 we needed mem2reg to
be run as to not panic when fetching slice lengths.

## Summary\*

After the linked PR we have an improved startegy for tracking slice
capacities by generating a slice capacities map before merging of
values. This should enable us to remove a mem2reg pass that is run
before flattening.

## Additional Context


## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index d19c4467235..0bb81efe977 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -54,11 +54,6 @@ pub(crate) fn optimize_into_acir(
         .try_run_pass(Ssa::evaluate_assert_constant, "After Assert Constant:")?
         .try_run_pass(Ssa::unroll_loops, "After Unrolling:")?
         .run_pass(Ssa::simplify_cfg, "After Simplifying:")
-        // Run mem2reg before flattening to handle any promotion
-        // of values that can be accessed after loop unrolling.
-        // If there are slice mergers uncovered by loop unrolling
-        // and this pass is missed, slice merging will fail inside of flattening.
-        .run_pass(Ssa::mem2reg, "After Mem2Reg:")
         .run_pass(Ssa::flatten_cfg, "After Flattening:")
         .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
         // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores

From 27c66b3d0741e68ed591ae8a16b47b30bc87175f Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Sat, 24 Feb 2024 14:00:22 +0000
Subject: [PATCH 003/416] fix: remove print from monomorphization pass (#4417)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're currently printing out every expression we're monomorphising.


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 6f59fa13274..d8857f9e599 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -128,7 +128,6 @@ impl<'a> FunctionContext<'a> {
     }
 
     fn codegen_expression(&mut self, expr: &Expression) -> Result<Values, RuntimeError> {
-        eprintln!("Codegen {expr}");
         match expr {
             Expression::Ident(ident) => Ok(self.codegen_ident(ident)),
             Expression::Literal(literal) => self.codegen_literal(literal),

From 33860678a642a76d8251ef42ffbe6d8a5a013528 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Sat, 24 Feb 2024 14:15:25 +0000
Subject: [PATCH 004/416] chore: remove unwanted prints (#4419)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This removes some unwanted prints which were left in from #4376

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index d8857f9e599..d95295ae3c9 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -347,10 +347,8 @@ impl<'a> FunctionContext<'a> {
     }
 
     fn codegen_binary(&mut self, binary: &ast::Binary) -> Result<Values, RuntimeError> {
-        eprintln!("Start binary");
         let lhs = self.codegen_non_tuple_expression(&binary.lhs)?;
         let rhs = self.codegen_non_tuple_expression(&binary.rhs)?;
-        eprintln!("Insert binary");
         Ok(self.insert_binary(lhs, binary.operator, rhs, binary.location))
     }
 

From 29e9b5e5d0f7a00c806639e900f2f8209675ee0e Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 26 Feb 2024 14:54:28 +0100
Subject: [PATCH 005/416] chore: do not panic when dividing by zero (#4424)

# Description

## Problem\*

Resolves #2480

## Summary\*
In BrilligVM, we have now the same behaviour regarding division by 0.
Whether it is a field or integer division, we return 0 when dividing by
zero. Since we have a constraint which checks that the inverse times
itself is 1, this constraint will always fail if we divide by zero
(instead of panic or returning an error).


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/brillig_vm/src/arithmetic.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
index 263a733e3c4..9d7b6fe8f02 100644
--- a/acvm-repo/brillig_vm/src/arithmetic.rs
+++ b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -36,18 +36,20 @@ pub(crate) fn evaluate_binary_bigint_op(
         BinaryIntOp::UnsignedDiv => {
             let b_mod = b % bit_modulo;
             if b_mod.is_zero() {
-                return Err("Division by zero".to_owned());
+                BigUint::zero()
+            } else {
+                (a % bit_modulo) / b_mod
             }
-            (a % bit_modulo) / b_mod
         }
         // Perform signed division by first converting a and b to signed integers and then back to unsigned after the operation.
         BinaryIntOp::SignedDiv => {
             let b_signed = to_big_signed(b, bit_size);
             if b_signed.is_zero() {
-                return Err("Division by zero".to_owned());
+                BigUint::zero()
+            } else {
+                let signed_div = to_big_signed(a, bit_size) / b_signed;
+                to_big_unsigned(signed_div, bit_size)
             }
-            let signed_div = to_big_signed(a, bit_size) / b_signed;
-            to_big_unsigned(signed_div, bit_size)
         }
         // Perform a == operation, returning 0 or 1
         BinaryIntOp::Equals => {

From 7cd5fdb3d2a53475b7c8681231d517cab30f9f9b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 26 Feb 2024 13:56:14 +0000
Subject: [PATCH 006/416] feat: expose separate functions to compile programs
 vs contracts in `noir_wasm` (#4413)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR exposes separate functions to compile contracts vs programs in
the wasm compiler. This allows us to simplify various code paths as we
don't need to deal with the potential for the two artifact types as this
just leads to us asserting types and breaking type safety.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/wasm/src/compile.rs                  | 212 ++++++++++--------
 compiler/wasm/src/compile_new.rs              |  75 +++++--
 compiler/wasm/src/index.cts                   |  77 ++++++-
 compiler/wasm/src/index.mts                   |  77 ++++++-
 compiler/wasm/src/lib.rs                      |   4 +-
 compiler/wasm/src/noir/noir-wasm-compiler.ts  |  61 ++++-
 compiler/wasm/src/types/noir_artifact.ts      |  19 --
 .../test/compiler/browser/compile.test.ts     |   8 +-
 .../wasm/test/compiler/node/compile.test.ts   |   8 +-
 .../wasm/test/compiler/shared/compile.test.ts |  10 +-
 compiler/wasm/test/wasm/browser/index.test.ts |  10 +-
 compiler/wasm/test/wasm/node/index.test.ts    |  10 +-
 12 files changed, 377 insertions(+), 194 deletions(-)

diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index c8b1680bc00..ca6c8efedb1 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -6,8 +6,7 @@ use nargo::artifacts::{
     program::ProgramArtifact,
 };
 use noirc_driver::{
-    add_dep, compile_contract, compile_main, file_manager_with_stdlib, prepare_crate,
-    prepare_dependency, CompileOptions, CompiledContract, CompiledProgram,
+    add_dep, file_manager_with_stdlib, prepare_crate, prepare_dependency, CompileOptions,
     NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_evaluator::errors::SsaReport;
@@ -60,51 +59,64 @@ extern "C" {
     #[derive(Clone, Debug, PartialEq, Eq)]
     pub type JsDependencyGraph;
 
-    #[wasm_bindgen(extends = Object, js_name = "CompileResult", typescript_type = "CompileResult")]
+    #[wasm_bindgen(extends = Object, js_name = "ProgramCompileResult", typescript_type = "ProgramCompileResult")]
     #[derive(Clone, Debug, PartialEq, Eq)]
-    pub type JsCompileResult;
+    pub type JsCompileProgramResult;
 
     #[wasm_bindgen(constructor, js_class = "Object")]
-    fn constructor() -> JsCompileResult;
+    fn constructor() -> JsCompileProgramResult;
+
+    #[wasm_bindgen(extends = Object, js_name = "ContractCompileResult", typescript_type = "ContractCompileResult")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsCompileContractResult;
+
+    #[wasm_bindgen(constructor, js_class = "Object")]
+    fn constructor() -> JsCompileContractResult;
 }
 
-impl JsCompileResult {
-    const CONTRACT_PROP: &'static str = "contract";
+impl JsCompileProgramResult {
     const PROGRAM_PROP: &'static str = "program";
     const WARNINGS_PROP: &'static str = "warnings";
 
-    pub fn new(resp: CompileResult) -> JsCompileResult {
-        let obj = JsCompileResult::constructor();
-        match resp {
-            CompileResult::Contract { contract, warnings } => {
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::CONTRACT_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&contract).unwrap(),
-                )
-                .unwrap();
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::WARNINGS_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
-                )
-                .unwrap();
-            }
-            CompileResult::Program { program, warnings } => {
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::PROGRAM_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&program).unwrap(),
-                )
-                .unwrap();
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::WARNINGS_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
-                )
-                .unwrap();
-            }
-        };
+    pub fn new(program: ProgramArtifact, warnings: Vec<SsaReport>) -> JsCompileProgramResult {
+        let obj = JsCompileProgramResult::constructor();
+
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileProgramResult::PROGRAM_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&program).unwrap(),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileProgramResult::WARNINGS_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
+        )
+        .unwrap();
+
+        obj
+    }
+}
+
+impl JsCompileContractResult {
+    const CONTRACT_PROP: &'static str = "contract";
+    const WARNINGS_PROP: &'static str = "warnings";
+
+    pub fn new(contract: ContractArtifact, warnings: Vec<SsaReport>) -> JsCompileContractResult {
+        let obj = JsCompileContractResult::constructor();
+
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileContractResult::CONTRACT_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&contract).unwrap(),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileContractResult::WARNINGS_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
+        )
+        .unwrap();
 
         obj
     }
@@ -144,73 +156,98 @@ pub(crate) fn parse_all(fm: &FileManager) -> ParsedFiles {
     fm.as_file_map().all_file_ids().map(|&file_id| (file_id, parse_file(fm, file_id))).collect()
 }
 
-pub enum CompileResult {
-    Contract { contract: ContractArtifact, warnings: Vec<SsaReport> },
-    Program { program: ProgramArtifact, warnings: Vec<SsaReport> },
-}
-
 #[wasm_bindgen]
-pub fn compile(
+pub fn compile_program(
     entry_point: String,
-    contracts: Option<bool>,
     dependency_graph: Option<JsDependencyGraph>,
     file_source_map: PathToFileSourceMap,
-) -> Result<JsCompileResult, JsCompileError> {
+) -> Result<JsCompileProgramResult, JsCompileError> {
     console_error_panic_hook::set_once();
-
-    let dependency_graph: DependencyGraph = if let Some(dependency_graph) = dependency_graph {
-        <JsValue as JsValueSerdeExt>::into_serde(&JsValue::from(dependency_graph))
-            .map_err(|err| err.to_string())?
-    } else {
-        DependencyGraph { root_dependencies: vec![], library_dependencies: HashMap::new() }
-    };
-
-    let fm = file_manager_with_source_map(file_source_map);
-    let parsed_files = parse_all(&fm);
-    let mut context = Context::new(fm, parsed_files);
-
-    let path = Path::new(&entry_point);
-    let crate_id = prepare_crate(&mut context, path);
-
-    process_dependency_graph(&mut context, dependency_graph);
+    let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
 
     let compile_options = CompileOptions::default();
-
     // For now we default to a bounded width of 3, though we can add it as a parameter
     let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
 
-    if contracts.unwrap_or_default() {
-        let compiled_contract = compile_contract(&mut context, crate_id, &compile_options)
+    let compiled_program =
+        noirc_driver::compile_main(&mut context, crate_id, &compile_options, None)
             .map_err(|errs| {
                 CompileError::with_file_diagnostics(
-                    "Failed to compile contract",
+                    "Failed to compile program",
                     errs,
                     &context.file_manager,
                 )
             })?
             .0;
 
-        let optimized_contract =
-            nargo::ops::transform_contract(compiled_contract, expression_width);
+    let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let warnings = optimized_program.warnings.clone();
 
-        let compile_output = generate_contract_artifact(optimized_contract);
-        Ok(JsCompileResult::new(compile_output))
-    } else {
-        let compiled_program = compile_main(&mut context, crate_id, &compile_options, None)
+    Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
+}
+
+#[wasm_bindgen]
+pub fn compile_contract(
+    entry_point: String,
+    dependency_graph: Option<JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<JsCompileContractResult, JsCompileError> {
+    console_error_panic_hook::set_once();
+    let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
+
+    let compile_options = CompileOptions::default();
+    // For now we default to a bounded width of 3, though we can add it as a parameter
+    let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
+
+    let compiled_contract =
+        noirc_driver::compile_contract(&mut context, crate_id, &compile_options)
             .map_err(|errs| {
                 CompileError::with_file_diagnostics(
-                    "Failed to compile program",
+                    "Failed to compile contract",
                     errs,
                     &context.file_manager,
                 )
             })?
             .0;
 
-        let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let optimized_contract = nargo::ops::transform_contract(compiled_contract, expression_width);
 
-        let compile_output = generate_program_artifact(optimized_program);
-        Ok(JsCompileResult::new(compile_output))
-    }
+    let functions =
+        optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
+
+    let contract_artifact = ContractArtifact {
+        noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
+        name: optimized_contract.name,
+        functions,
+        events: optimized_contract.events,
+        file_map: optimized_contract.file_map,
+    };
+
+    Ok(JsCompileContractResult::new(contract_artifact, optimized_contract.warnings))
+}
+
+fn prepare_context(
+    entry_point: String,
+    dependency_graph: Option<JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<(CrateId, Context<'static, 'static>), JsCompileError> {
+    let dependency_graph: DependencyGraph = if let Some(dependency_graph) = dependency_graph {
+        <JsValue as JsValueSerdeExt>::into_serde(&JsValue::from(dependency_graph))
+            .map_err(|err| err.to_string())?
+    } else {
+        DependencyGraph { root_dependencies: vec![], library_dependencies: HashMap::new() }
+    };
+
+    let fm = file_manager_with_source_map(file_source_map);
+    let parsed_files = parse_all(&fm);
+    let mut context = Context::new(fm, parsed_files);
+
+    let path = Path::new(&entry_point);
+    let crate_id = prepare_crate(&mut context, path);
+
+    process_dependency_graph(&mut context, dependency_graph);
+
+    Ok((crate_id, context))
 }
 
 // Create a new FileManager with the given source map
@@ -270,25 +307,6 @@ fn add_noir_lib(context: &mut Context, library_name: &CrateName) -> CrateId {
     prepare_dependency(context, &path_to_lib)
 }
 
-pub(crate) fn generate_program_artifact(program: CompiledProgram) -> CompileResult {
-    let warnings = program.warnings.clone();
-    CompileResult::Program { program: program.into(), warnings }
-}
-
-pub(crate) fn generate_contract_artifact(contract: CompiledContract) -> CompileResult {
-    let functions = contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
-
-    let contract_artifact = ContractArtifact {
-        noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
-        name: contract.name,
-        functions,
-        events: contract.events,
-        file_map: contract.file_map,
-    };
-
-    CompileResult::Contract { contract: contract_artifact, warnings: contract.warnings }
-}
-
 #[cfg(test)]
 mod test {
     use noirc_driver::prepare_crate;
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index f8fbed4f470..2a5f7ab6545 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -1,10 +1,12 @@
 use crate::compile::{
-    file_manager_with_source_map, generate_contract_artifact, generate_program_artifact, parse_all,
-    JsCompileResult, PathToFileSourceMap,
+    file_manager_with_source_map, parse_all, JsCompileContractResult, JsCompileProgramResult,
+    PathToFileSourceMap,
 };
 use crate::errors::{CompileError, JsCompileError};
+use nargo::artifacts::contract::{ContractArtifact, ContractFunctionArtifact};
 use noirc_driver::{
     add_dep, compile_contract, compile_main, prepare_crate, prepare_dependency, CompileOptions,
+    NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_frontend::{
     graph::{CrateId, CrateName},
@@ -92,7 +94,7 @@ impl CompilerContext {
     pub fn compile_program(
         mut self,
         program_width: usize,
-    ) -> Result<JsCompileResult, JsCompileError> {
+    ) -> Result<JsCompileProgramResult, JsCompileError> {
         let compile_options = CompileOptions::default();
         let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
 
@@ -110,15 +112,15 @@ impl CompilerContext {
                 .0;
 
         let optimized_program = nargo::ops::transform_program(compiled_program, np_language);
+        let warnings = optimized_program.warnings.clone();
 
-        let compile_output = generate_program_artifact(optimized_program);
-        Ok(JsCompileResult::new(compile_output))
+        Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
     }
 
     pub fn compile_contract(
         mut self,
         program_width: usize,
-    ) -> Result<JsCompileResult, JsCompileError> {
+    ) -> Result<JsCompileContractResult, JsCompileError> {
         let compile_options = CompileOptions::default();
         let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
         let root_crate_id = *self.context.root_crate_id();
@@ -136,24 +138,64 @@ impl CompilerContext {
 
         let optimized_contract = nargo::ops::transform_contract(compiled_contract, np_language);
 
-        let compile_output = generate_contract_artifact(optimized_contract);
-        Ok(JsCompileResult::new(compile_output))
+        let functions =
+            optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
+
+        let contract_artifact = ContractArtifact {
+            noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
+            name: optimized_contract.name,
+            functions,
+            events: optimized_contract.events,
+            file_map: optimized_contract.file_map,
+        };
+
+        Ok(JsCompileContractResult::new(contract_artifact, optimized_contract.warnings))
     }
 }
 
 /// This is a method that exposes the same API as `compile`
 /// But uses the Context based APi internally
 #[wasm_bindgen]
-pub fn compile_(
+pub fn compile_program_(
     entry_point: String,
-    contracts: Option<bool>,
     dependency_graph: Option<crate::compile::JsDependencyGraph>,
     file_source_map: PathToFileSourceMap,
-) -> Result<JsCompileResult, JsCompileError> {
-    use std::collections::HashMap;
+) -> Result<JsCompileProgramResult, JsCompileError> {
+    console_error_panic_hook::set_once();
+
+    let compiler_context =
+        prepare_compiler_context(entry_point, dependency_graph, file_source_map)?;
+    let program_width = 3;
 
+    compiler_context.compile_program(program_width)
+}
+
+/// This is a method that exposes the same API as `compile`
+/// But uses the Context based APi internally
+#[wasm_bindgen]
+pub fn compile_contract_(
+    entry_point: String,
+    dependency_graph: Option<crate::compile::JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<JsCompileContractResult, JsCompileError> {
     console_error_panic_hook::set_once();
 
+    let compiler_context =
+        prepare_compiler_context(entry_point, dependency_graph, file_source_map)?;
+    let program_width = 3;
+
+    compiler_context.compile_contract(program_width)
+}
+
+/// This is a method that exposes the same API as `prepare_context`
+/// But uses the Context based API internally
+fn prepare_compiler_context(
+    entry_point: String,
+    dependency_graph: Option<crate::compile::JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<CompilerContext, JsCompileError> {
+    use std::collections::HashMap;
+
     let dependency_graph: crate::compile::DependencyGraph =
         if let Some(dependency_graph) = dependency_graph {
             <wasm_bindgen::JsValue as gloo_utils::format::JsValueSerdeExt>::into_serde(
@@ -218,14 +260,7 @@ pub fn compile_(
         }
     }
 
-    let is_contract = contracts.unwrap_or(false);
-    let program_width = 3;
-
-    if is_contract {
-        compiler_context.compile_contract(program_width)
-    } else {
-        compiler_context.compile_program(program_width)
-    }
+    Ok(compiler_context)
 }
 
 #[cfg(test)]
diff --git a/compiler/wasm/src/index.cts b/compiler/wasm/src/index.cts
index 7c707e662d8..234bfa7280c 100644
--- a/compiler/wasm/src/index.cts
+++ b/compiler/wasm/src/index.cts
@@ -2,7 +2,7 @@ import { FileManager } from './noir/file-manager/file-manager';
 import { createNodejsFileManager } from './noir/file-manager/nodejs-file-manager';
 import { NoirWasmCompiler } from './noir/noir-wasm-compiler';
 import { LogData, LogFn } from './utils';
-import { CompilationResult } from './types/noir_artifact';
+import { ContractCompilationArtifacts, ProgramCompilationArtifacts } from './types/noir_artifact';
 import { inflateDebugSymbols } from './noir/debug';
 
 /**
@@ -17,36 +17,86 @@ import { inflateDebugSymbols } from './noir/debug';
  * ```typescript
  * // Node.js
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager(myProjectPath);
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  *
  * ```typescript
  * // Browser
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager('/');
  * for (const path of files) {
  *   await fm.writeFile(path, await getFileAsStream(path));
  * }
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  */
-async function compile(
+async function compile_program(
   fileManager: FileManager,
   projectPath?: string,
   logFn?: LogFn,
   debugLogFn?: LogFn,
-): Promise<CompilationResult> {
+): Promise<ProgramCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_program();
+}
+
+/**
+ * Compiles a Noir project
+ *
+ * @param fileManager - The file manager to use
+ * @param projectPath - The path to the project inside the file manager. Defaults to the root of the file manager
+ * @param logFn - A logging function. If not provided, console.log will be used
+ * @param debugLogFn - A debug logging function. If not provided, logFn will be used
+ *
+ * @example
+ * ```typescript
+ * // Node.js
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager(myProjectPath);
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ *
+ * ```typescript
+ * // Browser
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager('/');
+ * for (const path of files) {
+ *   await fm.writeFile(path, await getFileAsStream(path));
+ * }
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ */
+async function compile_contract(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<ContractCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_contract();
+}
+
+async function setup_compiler(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<NoirWasmCompiler> {
   if (logFn && !debugLogFn) {
     debugLogFn = logFn;
   }
 
   const cjs = await require('../build/cjs');
-  const compiler = await NoirWasmCompiler.new(
+  return await NoirWasmCompiler.new(
     fileManager,
     projectPath ?? fileManager.getDataDir(),
     cjs,
@@ -72,9 +122,16 @@ async function compile(
         },
     },
   );
-  return await compiler.compile();
 }
 
 const createFileManager = createNodejsFileManager;
 
-export { compile, createFileManager, inflateDebugSymbols, CompilationResult };
+export {
+  compile_program as compile,
+  compile_program,
+  compile_contract,
+  createFileManager,
+  inflateDebugSymbols,
+  ProgramCompilationArtifacts,
+  ContractCompilationArtifacts,
+};
diff --git a/compiler/wasm/src/index.mts b/compiler/wasm/src/index.mts
index d4ed0beccfc..326a7337117 100644
--- a/compiler/wasm/src/index.mts
+++ b/compiler/wasm/src/index.mts
@@ -2,7 +2,7 @@ import { FileManager } from './noir/file-manager/file-manager';
 import { createNodejsFileManager } from './noir/file-manager/nodejs-file-manager';
 import { NoirWasmCompiler } from './noir/noir-wasm-compiler';
 import { LogData, LogFn } from './utils';
-import { CompilationResult } from './types/noir_artifact';
+import { ContractCompilationArtifacts, ProgramCompilationArtifacts } from './types/noir_artifact';
 import { inflateDebugSymbols } from './noir/debug';
 
 /**
@@ -17,30 +17,80 @@ import { inflateDebugSymbols } from './noir/debug';
  * ```typescript
  * // Node.js
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager(myProjectPath);
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  *
  * ```typescript
  * // Browser
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager('/');
  * for (const path of files) {
  *   await fm.writeFile(path, await getFileAsStream(path));
  * }
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  */
-async function compile(
+async function compile_program(
   fileManager: FileManager,
   projectPath?: string,
   logFn?: LogFn,
   debugLogFn?: LogFn,
-): Promise<CompilationResult> {
+): Promise<ProgramCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_program();
+}
+
+/**
+ * Compiles a Noir project
+ *
+ * @param fileManager - The file manager to use
+ * @param projectPath - The path to the project inside the file manager. Defaults to the root of the file manager
+ * @param logFn - A logging function. If not provided, console.log will be used
+ * @param debugLogFn - A debug logging function. If not provided, logFn will be used
+ *
+ * @example
+ * ```typescript
+ * // Node.js
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager(myProjectPath);
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ *
+ * ```typescript
+ * // Browser
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager('/');
+ * for (const path of files) {
+ *   await fm.writeFile(path, await getFileAsStream(path));
+ * }
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ */
+async function compile_contract(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<ContractCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_contract();
+}
+
+async function setup_compiler(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<NoirWasmCompiler> {
   if (logFn && !debugLogFn) {
     debugLogFn = logFn;
   }
@@ -48,7 +98,7 @@ async function compile(
   const esm = await import(/* webpackMode: "eager" */ '../build/esm');
   await esm.default();
 
-  const compiler = await NoirWasmCompiler.new(
+  return await NoirWasmCompiler.new(
     fileManager,
     projectPath ?? fileManager.getDataDir(),
     esm,
@@ -74,9 +124,16 @@ async function compile(
         },
     },
   );
-  return await compiler.compile();
 }
 
 const createFileManager = createNodejsFileManager;
 
-export { compile, createFileManager, inflateDebugSymbols, CompilationResult };
+export {
+  compile_program as compile,
+  compile_program,
+  compile_contract,
+  createFileManager,
+  inflateDebugSymbols,
+  ProgramCompilationArtifacts,
+  ContractCompilationArtifacts,
+};
diff --git a/compiler/wasm/src/lib.rs b/compiler/wasm/src/lib.rs
index 174d9b9ce9c..6753faf2009 100644
--- a/compiler/wasm/src/lib.rs
+++ b/compiler/wasm/src/lib.rs
@@ -18,10 +18,10 @@ mod compile;
 mod compile_new;
 mod errors;
 
-pub use compile::compile;
+pub use compile::{compile_contract, compile_program};
 
 // Expose the new Context-Centric API
-pub use compile_new::{compile_, CompilerContext, CrateIDWrapper};
+pub use compile_new::{compile_contract_, compile_program_, CompilerContext, CrateIDWrapper};
 use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
 #[derive(Serialize, Deserialize)]
diff --git a/compiler/wasm/src/noir/noir-wasm-compiler.ts b/compiler/wasm/src/noir/noir-wasm-compiler.ts
index 2a0af5d8fee..1ec3af1fd65 100644
--- a/compiler/wasm/src/noir/noir-wasm-compiler.ts
+++ b/compiler/wasm/src/noir/noir-wasm-compiler.ts
@@ -6,7 +6,7 @@ import { LocalDependencyResolver } from './dependencies/local-dependency-resolve
 import { FileManager } from './file-manager/file-manager';
 import { Package } from './package';
 import { LogFn } from '../utils';
-import { CompilationResult } from '../types/noir_artifact';
+import { ContractCompilationArtifacts, ProgramCompilationArtifacts } from '../types/noir_artifact';
 
 /** Compilation options */
 export type NoirWasmCompileOptions = {
@@ -84,21 +84,64 @@ export class NoirWasmCompiler {
   /**
    * Compile EntryPoint
    */
+  public async compile_program(): Promise<ProgramCompilationArtifacts> {
+    console.log(`Compiling at ${this.#package.getEntryPointPath()}`);
+
+    if (this.#package.getType() !== 'bin') {
+      throw new Error(`Expected to find package type "bin" but found ${this.#package.getType()}`);
+    }
+    await this.#dependencyManager.resolveDependencies();
+    this.#debugLog(`Dependencies: ${this.#dependencyManager.getPackageNames().join(', ')}`);
+
+    try {
+      const entrypoint = this.#package.getEntryPointPath();
+      const deps = {
+        /* eslint-disable camelcase */
+        root_dependencies: this.#dependencyManager.getEntrypointDependencies(),
+        library_dependencies: this.#dependencyManager.getLibraryDependencies(),
+        /* eslint-enable camelcase */
+      };
+      const packageSources = await this.#package.getSources(this.#fm);
+      const librarySources = (
+        await Promise.all(
+          this.#dependencyManager
+            .getLibraries()
+            .map(async ([alias, library]) => await library.package.getSources(this.#fm, alias)),
+        )
+      ).flat();
+      [...packageSources, ...librarySources].forEach((sourceFile) => {
+        this.#debugLog(`Adding source ${sourceFile.path}`);
+        this.#sourceMap.add_source_code(sourceFile.path, sourceFile.source);
+      });
+      const result = this.#wasmCompiler.compile_program(entrypoint, deps, this.#sourceMap);
+
+      return result;
+    } catch (err) {
+      if (err instanceof Error && err.name === 'CompileError') {
+        const logs = await this.#processCompileError(err);
+        for (const log of logs) {
+          this.#log(log);
+        }
+        throw new Error(logs.join('\n'));
+      }
+
+      throw err;
+    }
+  }
+
   /**
    * Compile EntryPoint
    */
-  public async compile(): Promise<CompilationResult> {
+  public async compile_contract(): Promise<ContractCompilationArtifacts> {
     console.log(`Compiling at ${this.#package.getEntryPointPath()}`);
 
-    if (!(this.#package.getType() === 'contract' || this.#package.getType() === 'bin')) {
-      throw new Error(`Only supports compiling "contract" and "bin" package types (${this.#package.getType()})`);
+    if (this.#package.getType() !== 'contract') {
+      throw new Error(`Expected to find package type "contract" but found ${this.#package.getType()}`);
     }
     await this.#dependencyManager.resolveDependencies();
     this.#debugLog(`Dependencies: ${this.#dependencyManager.getPackageNames().join(', ')}`);
 
     try {
-      const isContract: boolean = this.#package.getType() === 'contract';
-
       const entrypoint = this.#package.getEntryPointPath();
       const deps = {
         /* eslint-disable camelcase */
@@ -118,11 +161,7 @@ export class NoirWasmCompiler {
         this.#debugLog(`Adding source ${sourceFile.path}`);
         this.#sourceMap.add_source_code(sourceFile.path, sourceFile.source);
       });
-      const result = this.#wasmCompiler.compile(entrypoint, isContract, deps, this.#sourceMap);
-
-      if ((isContract && !('contract' in result)) || (!isContract && !('program' in result))) {
-        throw new Error('Invalid compilation result');
-      }
+      const result = this.#wasmCompiler.compile_contract(entrypoint, deps, this.#sourceMap);
 
       return result;
     } catch (err) {
diff --git a/compiler/wasm/src/types/noir_artifact.ts b/compiler/wasm/src/types/noir_artifact.ts
index e636212a487..832a6ed9bf9 100644
--- a/compiler/wasm/src/types/noir_artifact.ts
+++ b/compiler/wasm/src/types/noir_artifact.ts
@@ -180,22 +180,3 @@ export interface ProgramCompilationArtifacts {
   /** Compilation warnings. */
   warnings: Warning[];
 }
-
-/**
- * output of Noir Wasm compilation, can be for a contract or lib/binary
- */
-export type CompilationResult = ContractCompilationArtifacts | ProgramCompilationArtifacts;
-
-/**
- * Check if it has Contract unique property
- */
-export function isContractCompilationArtifacts(artifact: CompilationResult): artifact is ContractCompilationArtifacts {
-  return (artifact as ContractCompilationArtifacts).contract !== undefined;
-}
-
-/**
- * Check if it has Contract unique property
- */
-export function isProgramCompilationArtifacts(artifact: CompilationResult): artifact is ProgramCompilationArtifacts {
-  return (artifact as ProgramCompilationArtifacts).program !== undefined;
-}
diff --git a/compiler/wasm/test/compiler/browser/compile.test.ts b/compiler/wasm/test/compiler/browser/compile.test.ts
index b7e6c27427f..7d4b3da55aa 100644
--- a/compiler/wasm/test/compiler/browser/compile.test.ts
+++ b/compiler/wasm/test/compiler/browser/compile.test.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 import { getPaths } from '../../shared';
 import { expect } from '@esm-bundle/chai';
-import { compile, createFileManager } from '@noir-lang/noir_wasm';
+import { compile_program, compile_contract, createFileManager } from '@noir-lang/noir_wasm';
 import { ContractArtifact, ProgramArtifact } from '../../../src/types/noir_artifact';
 import { shouldCompileContractIdentically, shouldCompileProgramIdentically } from '../shared/compile.test';
 
@@ -33,7 +33,7 @@ describe('noir-compiler/browser', () => {
         await fm.writeFile(path, (await getFile(path)).body as ReadableStream<Uint8Array>);
       }
       const nargoArtifact = (await getPrecompiledSource(simpleScriptExpectedArtifact)) as ProgramArtifact;
-      const noirWasmArtifact = await compile(fm, '/fixtures/simple');
+      const noirWasmArtifact = await compile_program(fm, '/fixtures/simple');
 
       return { nargoArtifact, noirWasmArtifact };
     },
@@ -51,7 +51,7 @@ describe('noir-compiler/browser', () => {
         await fm.writeFile(path, (await getFile(path)).body as ReadableStream<Uint8Array>);
       }
       const nargoArtifact = (await getPrecompiledSource(depsScriptExpectedArtifact)) as ProgramArtifact;
-      const noirWasmArtifact = await compile(fm, '/fixtures/with-deps');
+      const noirWasmArtifact = await compile_program(fm, '/fixtures/with-deps');
 
       return { nargoArtifact, noirWasmArtifact };
     },
@@ -69,7 +69,7 @@ describe('noir-compiler/browser', () => {
         await fm.writeFile(path, (await getFile(path)).body as ReadableStream<Uint8Array>);
       }
       const nargoArtifact = (await getPrecompiledSource(contractExpectedArtifact)) as ContractArtifact;
-      const noirWasmArtifact = await compile(fm, '/fixtures/noir-contract');
+      const noirWasmArtifact = await compile_contract(fm, '/fixtures/noir-contract');
 
       return { nargoArtifact, noirWasmArtifact };
     },
diff --git a/compiler/wasm/test/compiler/node/compile.test.ts b/compiler/wasm/test/compiler/node/compile.test.ts
index 9af98195825..811dc95ce16 100644
--- a/compiler/wasm/test/compiler/node/compile.test.ts
+++ b/compiler/wasm/test/compiler/node/compile.test.ts
@@ -2,7 +2,7 @@ import { join, resolve } from 'path';
 import { getPaths } from '../../shared';
 
 import { expect } from 'chai';
-import { compile, createFileManager } from '@noir-lang/noir_wasm';
+import { compile_program, compile_contract, createFileManager } from '@noir-lang/noir_wasm';
 import { readFile } from 'fs/promises';
 import { ContractArtifact, ProgramArtifact } from '../../../src/types/noir_artifact';
 import { shouldCompileContractIdentically, shouldCompileProgramIdentically } from '../shared/compile.test';
@@ -15,7 +15,7 @@ describe('noir-compiler/node', () => {
 
     const fm = createFileManager(simpleScriptProjectPath);
     const nargoArtifact = JSON.parse((await readFile(simpleScriptExpectedArtifact)).toString()) as ProgramArtifact;
-    const noirWasmArtifact = await compile(fm);
+    const noirWasmArtifact = await compile_program(fm);
     return { nargoArtifact, noirWasmArtifact };
   }, expect);
 
@@ -24,7 +24,7 @@ describe('noir-compiler/node', () => {
 
     const fm = createFileManager(depsScriptProjectPath);
     const nargoArtifact = JSON.parse((await readFile(depsScriptExpectedArtifact)).toString()) as ProgramArtifact;
-    const noirWasmArtifact = await compile(fm);
+    const noirWasmArtifact = await compile_program(fm);
     return { nargoArtifact, noirWasmArtifact };
   }, expect);
 
@@ -33,7 +33,7 @@ describe('noir-compiler/node', () => {
 
     const fm = createFileManager(contractProjectPath);
     const nargoArtifact = JSON.parse((await readFile(contractExpectedArtifact)).toString()) as ContractArtifact;
-    const noirWasmArtifact = await compile(fm);
+    const noirWasmArtifact = await compile_contract(fm);
     return { nargoArtifact, noirWasmArtifact };
   }, expect);
 });
diff --git a/compiler/wasm/test/compiler/shared/compile.test.ts b/compiler/wasm/test/compiler/shared/compile.test.ts
index 88e8e8c8e5a..52cef14968b 100644
--- a/compiler/wasm/test/compiler/shared/compile.test.ts
+++ b/compiler/wasm/test/compiler/shared/compile.test.ts
@@ -1,4 +1,4 @@
-import { CompilationResult, inflateDebugSymbols } from '@noir-lang/noir_wasm';
+import { inflateDebugSymbols } from '@noir-lang/noir_wasm';
 import { type expect as Expect } from 'chai';
 import {
   ContractArtifact,
@@ -11,7 +11,7 @@ import {
 } from '../../../src/types/noir_artifact';
 
 export function shouldCompileProgramIdentically(
-  compileFn: () => Promise<{ nargoArtifact: ProgramArtifact; noirWasmArtifact: CompilationResult }>,
+  compileFn: () => Promise<{ nargoArtifact: ProgramArtifact; noirWasmArtifact: ProgramCompilationArtifacts }>,
   expect: typeof Expect,
   timeout = 5000,
 ) {
@@ -24,7 +24,7 @@ export function shouldCompileProgramIdentically(
     normalizeVersion(nargoArtifact);
 
     // Prepare noir-wasm artifact
-    const noirWasmProgram = (noirWasmArtifact as unknown as ProgramCompilationArtifacts).program;
+    const noirWasmProgram = noirWasmArtifact.program;
     expect(noirWasmProgram).not.to.be.undefined;
     const [_noirWasmDebugInfos, norWasmFileMap] = deleteProgramDebugMetadata(noirWasmProgram);
     normalizeVersion(noirWasmProgram);
@@ -47,7 +47,7 @@ export function shouldCompileProgramIdentically(
 }
 
 export function shouldCompileContractIdentically(
-  compileFn: () => Promise<{ nargoArtifact: ContractArtifact; noirWasmArtifact: CompilationResult }>,
+  compileFn: () => Promise<{ nargoArtifact: ContractArtifact; noirWasmArtifact: ContractCompilationArtifacts }>,
   expect: typeof Expect,
   timeout = 5000,
 ) {
@@ -60,7 +60,7 @@ export function shouldCompileContractIdentically(
     normalizeVersion(nargoArtifact);
 
     // Prepare noir-wasm artifact
-    const noirWasmContract = (noirWasmArtifact as unknown as ContractCompilationArtifacts).contract;
+    const noirWasmContract = noirWasmArtifact.contract;
     expect(noirWasmContract).not.to.be.undefined;
     const [noirWasmDebugInfos, norWasmFileMap] = deleteContractDebugMetadata(noirWasmContract);
     normalizeVersion(noirWasmContract);
diff --git a/compiler/wasm/test/wasm/browser/index.test.ts b/compiler/wasm/test/wasm/browser/index.test.ts
index 3122fa57945..b59b4ae417a 100644
--- a/compiler/wasm/test/wasm/browser/index.test.ts
+++ b/compiler/wasm/test/wasm/browser/index.test.ts
@@ -2,7 +2,7 @@
 import { getPaths } from '../../shared';
 import { expect } from '@esm-bundle/chai';
 
-import init, { compile, PathToFileSourceMap, compile_, CompilerContext } from '../../../build/esm';
+import init, { compile_program, PathToFileSourceMap, compile_program_, CompilerContext } from '../../../build/esm';
 
 // @ts-ignore
 await init();
@@ -35,7 +35,7 @@ describe('noir wasm compilation', () => {
     it('matching nargos compilation', async () => {
       const sourceMap = new PathToFileSourceMap();
       sourceMap.add_source_code('script/main.nr', await getFileAsString(simpleScriptSourcePath));
-      const wasmCircuit = compile('script/main.nr', undefined, undefined, sourceMap);
+      const wasmCircuit = compile_program('script/main.nr', undefined, sourceMap);
       const cliCircuit = await getPrecompiledSource(simpleScriptExpectedArtifact);
 
       if (!('program' in wasmCircuit)) {
@@ -58,9 +58,8 @@ describe('noir wasm compilation', () => {
     });
 
     it('matching nargos compilation', async () => {
-      const wasmCircuit = compile(
+      const wasmCircuit = compile_program(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {
@@ -132,9 +131,8 @@ describe('noir wasm compilation', () => {
     }).timeout(60 * 20e3);
 
     it('matching nargos compilation - context-implementation-compile-api', async () => {
-      const wasmCircuit = await compile_(
+      const wasmCircuit = await compile_program_(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {
diff --git a/compiler/wasm/test/wasm/node/index.test.ts b/compiler/wasm/test/wasm/node/index.test.ts
index c73ce7477e5..23c87cc059a 100644
--- a/compiler/wasm/test/wasm/node/index.test.ts
+++ b/compiler/wasm/test/wasm/node/index.test.ts
@@ -3,7 +3,7 @@ import { readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { expect } from 'chai';
 
-import { compile, PathToFileSourceMap, compile_, CompilerContext } from '../../../build/cjs';
+import { compile_program, PathToFileSourceMap, compile_program_, CompilerContext } from '../../../build/cjs';
 
 const basePath = resolve(join(__dirname, '../../'));
 const {
@@ -26,7 +26,7 @@ describe('noir wasm compilation', () => {
     it('matching nargos compilation', async () => {
       const sourceMap = new PathToFileSourceMap();
       sourceMap.add_source_code(simpleScriptSourcePath, readFileSync(simpleScriptSourcePath, 'utf-8'));
-      const wasmCircuit = compile(simpleScriptSourcePath, undefined, undefined, sourceMap);
+      const wasmCircuit = compile_program(simpleScriptSourcePath, undefined, sourceMap);
       const cliCircuit = await getPrecompiledSource(simpleScriptExpectedArtifact);
 
       if (!('program' in wasmCircuit)) {
@@ -49,9 +49,8 @@ describe('noir wasm compilation', () => {
     });
 
     it('matching nargos compilation', async () => {
-      const wasmCircuit = compile(
+      const wasmCircuit = compile_program(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {
@@ -123,9 +122,8 @@ describe('noir wasm compilation', () => {
     }).timeout(60 * 20e3);
 
     it('matching nargos compilation - context-implementation-compile-api', async () => {
-      const wasmCircuit = await compile_(
+      const wasmCircuit = await compile_program_(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {

From 176fab42970ff0a9797b7f8c7ce53817e7d85b90 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 26 Feb 2024 14:05:41 +0000
Subject: [PATCH 007/416] chore(ci): prevent msrv checks from blocking PRs
 (#4414)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Current the MSRV check CI runs on every PR so if one of our dependencies
breaks us, all merges halt until we fix this. This is unnecessary as we
only need to stop publishing releases and normal development work can
continue.

This PR switches this workflow to instead run only on master and on a
nightly schedule. If the workflow fails then an issue will be raised.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
---
 .github/ACVM_NOT_PUBLISHABLE.md               | 13 +++++++
 .../workflows/test-rust-workspace-msrv.yml    | 37 +++++++++++++------
 .github/workflows/test-rust-workspace.yml     | 20 +++++-----
 cspell.json                                   |  1 +
 4 files changed, 49 insertions(+), 22 deletions(-)
 create mode 100644 .github/ACVM_NOT_PUBLISHABLE.md

diff --git a/.github/ACVM_NOT_PUBLISHABLE.md b/.github/ACVM_NOT_PUBLISHABLE.md
new file mode 100644
index 00000000000..e7eacb3b523
--- /dev/null
+++ b/.github/ACVM_NOT_PUBLISHABLE.md
@@ -0,0 +1,13 @@
+---
+title: "ACVM crates are not publishable"
+assignees: TomAFrench kevaundray savio-sou
+---
+
+
+The ACVM crates are currently unpublishable, making a release will NOT push our crates to crates.io.
+
+This is likely due to a crate we depend on bumping its MSRV above our own. Our lockfile is not taken into account when publishing to crates.io (as people downloading our crate don't use it) so we need to be able to use the most up to date versions of our dependencies (including transient dependencies) specified. 
+
+Check the [MSRV check]({{env.WORKFLOW_URL}}) workflow for details.
+
+This issue was raised by the workflow `{{env.WORKFLOW_NAME}}`
diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index 061fc65ca8b..0b2855fa834 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -6,8 +6,9 @@ name: Test (MSRV check)
 # We must then always be able to build the workspace using the latest versions of all of our dependencies, so we explicitly update them and build in this workflow. 
 
 on:
-  pull_request:
-  merge_group:
+  schedule:
+    # Run a nightly check at 2 AM UTC
+    - cron: "0 2 * * *"
   push:
     branches:
       - master
@@ -100,13 +101,25 @@ jobs:
       - run-tests
     
     steps:
-        - name: Report overall success
-          run: |
-            if [[ $FAIL == true ]]; then
-                exit 1
-            else
-                exit 0
-            fi
-          env:
-            # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
-            FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
+      - name: Report overall success
+        run: |
+          if [[ $FAIL == true ]]; then
+              exit 1
+          else
+              exit 0
+          fi
+        env:
+          # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
+          FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
+    
+      # Raise an issue if the tests failed
+      - name: Alert on failed publish
+        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/JS_PUBLISH_FAILED.md
\ No newline at end of file
diff --git a/.github/workflows/test-rust-workspace.yml b/.github/workflows/test-rust-workspace.yml
index c12dcaba0ba..22684de3044 100644
--- a/.github/workflows/test-rust-workspace.yml
+++ b/.github/workflows/test-rust-workspace.yml
@@ -88,13 +88,13 @@ jobs:
       - run-tests
     
     steps:
-        - name: Report overall success
-          run: |
-            if [[ $FAIL == true ]]; then
-                exit 1
-            else
-                exit 0
-            fi
-          env:
-            # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
-            FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
+      - name: Report overall success
+        run: |
+          if [[ $FAIL == true ]]; then
+              exit 1
+          else
+              exit 0
+          fi
+        env:
+          # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
+          FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
diff --git a/cspell.json b/cspell.json
index be6b7c5c7e8..23659b39c68 100644
--- a/cspell.json
+++ b/cspell.json
@@ -118,6 +118,7 @@
         "monomorphizes",
         "monomorphizing",
         "montcurve",
+        "MSRV",
         "nand",
         "nargo",
         "neovim",

From ab25b5ed3cd17e3f53c5cc873571fe4c08bad35d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 26 Feb 2024 14:40:31 +0000
Subject: [PATCH 008/416] chore: remove duplicate `parse_all` function in wasm
 compiler (#4411)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This removes a function which exists in `nargo` from being defined again
in `noir_wasm`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/wasm/src/compile.rs     | 20 +++++++++-----------
 compiler/wasm/src/compile_new.rs |  6 ++++--
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index ca6c8efedb1..9e6fca1126e 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -1,9 +1,12 @@
 use fm::FileManager;
 use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{JsString, Object};
-use nargo::artifacts::{
-    contract::{ContractArtifact, ContractFunctionArtifact},
-    program::ProgramArtifact,
+use nargo::{
+    artifacts::{
+        contract::{ContractArtifact, ContractFunctionArtifact},
+        program::ProgramArtifact,
+    },
+    parse_all,
 };
 use noirc_driver::{
     add_dep, file_manager_with_stdlib, prepare_crate, prepare_dependency, CompileOptions,
@@ -12,7 +15,7 @@ use noirc_driver::{
 use noirc_evaluator::errors::SsaReport;
 use noirc_frontend::{
     graph::{CrateId, CrateName},
-    hir::{def_map::parse_file, Context, ParsedFiles},
+    hir::Context,
 };
 use serde::Deserialize;
 use std::{collections::HashMap, path::Path};
@@ -152,10 +155,6 @@ impl PathToFileSourceMap {
     }
 }
 
-pub(crate) fn parse_all(fm: &FileManager) -> ParsedFiles {
-    fm.as_file_map().all_file_ids().map(|&file_id| (file_id, parse_file(fm, file_id))).collect()
-}
-
 #[wasm_bindgen]
 pub fn compile_program(
     entry_point: String,
@@ -309,14 +308,13 @@ fn add_noir_lib(context: &mut Context, library_name: &CrateName) -> CrateId {
 
 #[cfg(test)]
 mod test {
+    use nargo::parse_all;
     use noirc_driver::prepare_crate;
     use noirc_frontend::{graph::CrateName, hir::Context};
 
     use crate::compile::PathToFileSourceMap;
 
-    use super::{
-        file_manager_with_source_map, parse_all, process_dependency_graph, DependencyGraph,
-    };
+    use super::{file_manager_with_source_map, process_dependency_graph, DependencyGraph};
     use std::{collections::HashMap, path::Path};
 
     fn setup_test_context(source_map: PathToFileSourceMap) -> Context<'static, 'static> {
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index 2a5f7ab6545..d6b382f669f 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -1,9 +1,10 @@
 use crate::compile::{
-    file_manager_with_source_map, parse_all, JsCompileContractResult, JsCompileProgramResult,
+    file_manager_with_source_map, JsCompileContractResult, JsCompileProgramResult,
     PathToFileSourceMap,
 };
 use crate::errors::{CompileError, JsCompileError};
 use nargo::artifacts::contract::{ContractArtifact, ContractFunctionArtifact};
+use nargo::parse_all;
 use noirc_driver::{
     add_dep, compile_contract, compile_main, prepare_crate, prepare_dependency, CompileOptions,
     NOIR_ARTIFACT_VERSION_STRING,
@@ -265,10 +266,11 @@ fn prepare_compiler_context(
 
 #[cfg(test)]
 mod test {
+    use nargo::parse_all;
     use noirc_driver::prepare_crate;
     use noirc_frontend::hir::Context;
 
-    use crate::compile::{file_manager_with_source_map, parse_all, PathToFileSourceMap};
+    use crate::compile::{file_manager_with_source_map, PathToFileSourceMap};
 
     use std::path::Path;
 

From cd796dea4937dd1a261f154e5f2e599bbc649165 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 26 Feb 2024 15:22:01 +0000
Subject: [PATCH 009/416] fix: correct formatting for databus visibility types
 (#4423)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR fixes an issue uncovered by #4422 where we're not properly
formatting databus visibility modifiers. I've fixed this and added a new
test case for regressions.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_fmt/src/utils.rs              | 14 +++++++++++++-
 tooling/nargo_fmt/src/visitor/item.rs       | 14 ++++++++++----
 tooling/nargo_fmt/tests/expected/databus.nr |  2 ++
 tooling/nargo_fmt/tests/input/databus.nr    |  2 ++
 4 files changed, 27 insertions(+), 5 deletions(-)
 create mode 100644 tooling/nargo_fmt/tests/expected/databus.nr
 create mode 100644 tooling/nargo_fmt/tests/input/databus.nr

diff --git a/tooling/nargo_fmt/src/utils.rs b/tooling/nargo_fmt/src/utils.rs
index 5874ebdebbc..94969d45e81 100644
--- a/tooling/nargo_fmt/src/utils.rs
+++ b/tooling/nargo_fmt/src/utils.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::items::HasItem;
 use crate::rewrite;
 use crate::visitor::{FmtVisitor, Shape};
@@ -143,7 +145,7 @@ impl HasItem for Param {
     fn format(self, visitor: &FmtVisitor, shape: Shape) -> String {
         let pattern = visitor.slice(self.pattern.span());
         let visibility = match self.visibility {
-            Visibility::Public => "pub ",
+            Visibility::Public => "pub",
             Visibility::Private => "",
             Visibility::DataBus => "call_data",
         };
@@ -152,6 +154,7 @@ impl HasItem for Param {
             pattern.to_string()
         } else {
             let ty = rewrite::typ(visitor, shape, self.typ);
+            let visibility = append_space_if_nonempty(visibility.into());
             format!("{pattern}: {visibility}{ty}")
         }
     }
@@ -183,6 +186,15 @@ pub(crate) fn last_line_contains_single_line_comment(s: &str) -> bool {
     s.lines().last().map_or(false, |line| line.contains("//"))
 }
 
+pub(crate) fn append_space_if_nonempty(mut string: Cow<str>) -> Cow<str> {
+    if !string.is_empty() {
+        let inner = string.to_mut();
+        inner.push(' ');
+    }
+
+    string
+}
+
 pub(crate) fn last_line_used_width(s: &str, offset: usize) -> usize {
     if s.contains('\n') {
         last_line_width(s)
diff --git a/tooling/nargo_fmt/src/visitor/item.rs b/tooling/nargo_fmt/src/visitor/item.rs
index 1825a6e05b0..28aad3c551f 100644
--- a/tooling/nargo_fmt/src/visitor/item.rs
+++ b/tooling/nargo_fmt/src/visitor/item.rs
@@ -7,7 +7,10 @@ use noirc_frontend::{
 
 use crate::{
     rewrite::{self, UseTree},
-    utils::{last_line_contains_single_line_comment, last_line_used_width, FindToken},
+    utils::{
+        append_space_if_nonempty, last_line_contains_single_line_comment, last_line_used_width,
+        FindToken,
+    },
     visitor::expr::{format_seq, NewlineMode},
 };
 
@@ -119,9 +122,12 @@ impl super::FmtVisitor<'_> {
                 result.push_str("distinct ");
             }
 
-            if let Visibility::Public = func.def.return_visibility {
-                result.push_str("pub ");
-            }
+            let visibility = match func.def.return_visibility {
+                Visibility::Public => "pub",
+                Visibility::DataBus => "return_data",
+                Visibility::Private => "",
+            };
+            result.push_str(&append_space_if_nonempty(visibility.into()));
 
             let typ = rewrite::typ(self, self.shape(), func.return_type());
             result.push_str(&typ);
diff --git a/tooling/nargo_fmt/tests/expected/databus.nr b/tooling/nargo_fmt/tests/expected/databus.nr
new file mode 100644
index 00000000000..60934b60b2f
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/databus.nr
@@ -0,0 +1,2 @@
+fn main(x: pub u8, y: call_data u8) -> return_data u32 {}
+
diff --git a/tooling/nargo_fmt/tests/input/databus.nr b/tooling/nargo_fmt/tests/input/databus.nr
new file mode 100644
index 00000000000..60934b60b2f
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/databus.nr
@@ -0,0 +1,2 @@
+fn main(x: pub u8, y: call_data u8) -> return_data u32 {}
+

From 15c5618c6d15af527287d21ac74eb07cd2b98c14 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 26 Feb 2024 17:06:54 +0000
Subject: [PATCH 010/416] chore(ci): enforce formatting of noir code in CI
 (#4422)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We currently format everything in the repository except our noir source
code. If we enforce this internally then we'll uncover issues in the
formatter earlier and provide a good example of what Noir source should
look like.

We then now run `nargo fmt --check` on the stdlib and
`test_programs/execution_success`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/formatting.yml              |  65 +++++++++
 noir_stdlib/src/array.nr                      |  23 ++--
 noir_stdlib/src/bigint.nr                     |  16 +--
 noir_stdlib/src/collections/bounded_vec.nr    |   2 +-
 noir_stdlib/src/collections/vec.nr            |   8 +-
 noir_stdlib/src/ec/montcurve.nr               |  89 ++++++------
 noir_stdlib/src/ec/swcurve.nr                 | 127 +++++++++---------
 noir_stdlib/src/ec/tecurve.nr                 | 122 ++++++++---------
 noir_stdlib/src/ecdsa_secp256k1.nr            |   2 +-
 noir_stdlib/src/ecdsa_secp256r1.nr            |   2 +-
 noir_stdlib/src/field.nr                      |  11 +-
 noir_stdlib/src/option.nr                     |  24 +---
 noir_stdlib/src/scalar_mul.nr                 |   2 +-
 noir_stdlib/src/schnorr.nr                    |   2 +-
 noir_stdlib/src/slice.nr                      |  12 +-
 noir_stdlib/src/string.nr                     |   2 +-
 noir_stdlib/src/test.nr                       |   4 +-
 noir_stdlib/src/uint128.nr                    |  65 ++++-----
 test_programs/.gitignore                      |   3 +-
 .../closure_explicit_types/src/main.nr        |   4 +-
 .../conditional_regression_579/src/main.nr    |   4 +-
 .../reexports/src/main.nr                     |   4 +-
 .../specialization/src/main.nr                |   8 +-
 .../1327_concrete_in_generic/src/main.nr      |  28 ++--
 .../array_dynamic/src/main.nr                 |   4 +-
 .../array_dynamic_blackbox_input/src/main.nr  |   2 +-
 .../array_dynamic_main_output/src/main.nr     |   2 +-
 .../assert_statement_recursive/src/main.nr    |   2 +-
 .../execution_success/bigint/src/main.nr      |  10 +-
 .../execution_success/brillig_cow/src/main.nr |  27 ++--
 .../brillig_cow_regression/src/main.nr        |  74 +++++-----
 .../brillig_fns_as_values/src/main.nr         |   2 +-
 .../conditional_regression_661/src/main.nr    |   4 +-
 .../execution_success/databus/src/main.nr     |   8 +-
 .../execution_success/debug_logs/src/main.nr  |   6 +-
 .../distinct_keyword/src/main.nr              |   2 +-
 .../ecdsa_secp256k1/src/main.nr               |  10 +-
 .../ecdsa_secp256r1/src/main.nr               |   2 +-
 .../main_bool_arg/src/main.nr                 |   2 +-
 .../operator_overloading/src/main.nr          |   6 +-
 .../regression_3394/src/main.nr               |   2 +-
 .../regression_3607/src/main.nr               |   2 +-
 .../regression_3889/src/main.nr               |   1 -
 .../side_effects_constrain_array/src/main.nr  |   4 +-
 .../execution_success/struct/src/main.nr      |   4 +-
 test_programs/format.sh                       |  47 +++++++
 46 files changed, 455 insertions(+), 397 deletions(-)
 create mode 100755 test_programs/format.sh

diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml
index 43fd6daa91d..279e90f5f6f 100644
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@@ -63,3 +63,68 @@ jobs:
 
       - name: Run `yarn lint`
         run: yarn lint
+
+  build-nargo:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout Noir repo
+        uses: actions/checkout@v4
+
+      - name: Setup toolchain
+        uses: dtolnay/rust-toolchain@1.73.0
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: x86_64-unknown-linux-gnu
+          cache-on-failure: true
+          save-if: ${{ github.event_name != 'merge_group' }}
+
+      - name: Build Nargo
+        run: cargo build --package nargo_cli --release
+
+      - name: Package artifacts
+        run: |
+          mkdir dist
+          cp ./target/release/nargo ./dist/nargo
+          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: nargo
+          path: ./dist/*
+          retention-days: 3
+
+  nargo_fmt:
+    needs: [build-nargo]
+    name: Nargo fmt
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+            
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Format stdlib
+        working-directory: ./noir_stdlib
+        run: nargo fmt --check
+
+      - name: Format test suite
+        working-directory: ./test_programs
+        run: ./format.sh check
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index 7871b1a6f9a..3da4b649174 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -17,14 +17,14 @@ impl<T, N> [T; N] {
         for i in 0..N {
             let pos = find_index(sorted_index, i);
             assert(sorted_index[pos] == i);
-         }
+        }
         // Sort the array using the indexes
-         for i in 0..N {
+        for i in 0..N {
             result[i] = self[sorted_index[i]];
-         }
+        }
         // Ensure the array is sorted
-        for i in 0..N-1 {
-            assert(ordering(result[i], result[i+1]));
+        for i in 0..N - 1 {
+            assert(ordering(result[i], result[i + 1]));
         }
 
         result
@@ -32,12 +32,12 @@ impl<T, N> [T; N] {
 
     /// Returns the index of the elements in the array that would sort it, using the provided custom sorting function.
     unconstrained fn get_sorting_index<Env>(self, ordering: fn[Env](T, T) -> bool) -> [u64; N] {
-        let mut result = [0;N];
+        let mut result = [0; N];
         let mut a = self;
         for i in 0..N {
             result[i] = i;
         }
-        for i in 1 .. N {
+        for i in 1..N {
             for j in 0..i {
                 if ordering(a[i], a[j]) {
                     let old_a_j = a[j];
@@ -45,14 +45,13 @@ impl<T, N> [T; N] {
                     a[i] = old_a_j;
                     let old_j = result[j];
                     result[j] = result[i];
-                    result[i] = old_j; 
+                    result[i] = old_j;
                 }
             }
         }
         result
     }
 
-
     // Converts an array into a slice.
     pub fn as_slice(self) -> [T] {
         let mut slice = [];
@@ -68,7 +67,7 @@ impl<T, N> [T; N] {
         let first_elem = f(self[0]);
         let mut ret = [first_elem; N];
 
-        for i in 1 .. self.len() {
+        for i in 1..self.len() {
             ret[i] = f(self[i]);
         }
 
@@ -90,7 +89,7 @@ impl<T, N> [T; N] {
     // element of the given array as its starting accumulator value.
     pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {
         let mut accumulator = self[0];
-        for i in 1 .. self.len() {
+        for i in 1..self.len() {
             accumulator = f(accumulator, self[i]);
         }
         accumulator
@@ -122,7 +121,7 @@ unconstrained fn find_index<N>(a: [u64; N], find: u64) -> u64 {
     for i in 0..a.len() {
         if a[i] == find {
             result = i;
-        }     
+        }
     }
     result
 }
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 11026651207..66e81f05812 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,5 +1,4 @@
-use crate::ops::{Add, Sub, Mul, Div, Rem,};
-
+use crate::ops::{Add, Sub, Mul, Div, Rem};
 
 global bn254_fq = [0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
@@ -13,7 +12,6 @@ global secpr1_fq = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
 global secpr1_fr = [0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3, 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC,
                     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,0xFF, 0xFF, 0xFF, 0xFF];
- 
 
 struct BigInt {
     pointer: u32,
@@ -22,17 +20,13 @@ struct BigInt {
 
 impl BigInt {
     #[builtin(bigint_add)]
-    fn bigint_add(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_add(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_sub)]
-    fn bigint_sub(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_sub(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_mul)]
-    fn bigint_mul(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_mul(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_div)]
-    fn bigint_div(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_div(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_from_le_bytes)]
     fn from_le_bytes(bytes: [u8], modulus: [u8]) -> BigInt {}
     #[builtin(bigint_to_le_bytes)]
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index a4aa4823f38..f78d86de77d 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -29,7 +29,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len
     }
 
-    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64{
+    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
         MaxLen
     }
 
diff --git a/noir_stdlib/src/collections/vec.nr b/noir_stdlib/src/collections/vec.nr
index 2e7945be827..deec98185ff 100644
--- a/noir_stdlib/src/collections/vec.nr
+++ b/noir_stdlib/src/collections/vec.nr
@@ -19,12 +19,12 @@ impl<T> Vec<T> {
     /// points beyond the end of the vector.
     pub fn get(self, index: u64) -> T {
         self.slice[index]
-     }
+    }
 
     /// Push a new element to the end of the vector, returning a
     /// new vector with a length one greater than the
     /// original unmodified vector.
-    pub fn push(&mut self, elem: T) { 
+    pub fn push(&mut self, elem: T) {
         self.slice = self.slice.push_back(elem);
     }
 
@@ -32,7 +32,7 @@ impl<T> Vec<T> {
     /// a new vector with a length of one less than the given vector,
     /// as well as the popped element.
     /// Panics if the given vector's length is zero.
-    pub fn pop(&mut self) -> T { 
+    pub fn pop(&mut self) -> T {
         let (popped_slice, last_elem) = self.slice.pop_back();
         self.slice = popped_slice;
         last_elem
@@ -42,7 +42,7 @@ impl<T> Vec<T> {
     /// after it to the right
     pub fn insert(&mut self, index: u64, elem: T) {
         self.slice = self.slice.insert(index, elem);
-    } 
+    }
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the removed element
diff --git a/noir_stdlib/src/ec/montcurve.nr b/noir_stdlib/src/ec/montcurve.nr
index 83a17bae322..7dc756781c0 100644
--- a/noir_stdlib/src/ec/montcurve.nr
+++ b/noir_stdlib/src/ec/montcurve.nr
@@ -31,7 +31,7 @@ mod affine {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field) -> Self {
-            Self {x, y, infty: false}
+            Self { x, y, infty: false }
         }
 
         // Check if zero
@@ -45,30 +45,30 @@ mod affine {
                 curvegroup::Point::zero()
             } else {
                 let (x,y) = (self.x, self.y);
-                curvegroup::Point::new(x,y,1)
+                curvegroup::Point::new(x, y, 1)
             }
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 0, infty: true}
+            Self { x: 0, y: 0, infty: true }
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, infty} = self;
 
-            Self {x, y: 0-y, infty}
+            Self { x, y: 0 - y, infty }
         }
 
         // Map into equivalent Twisted Edwards curve
         fn into_tecurve(self) -> TEPoint {
             let Self {x, y, infty} = self;
-            
-            if infty | (y*(x+1) == 0) {
+
+            if infty | (y * (x + 1) == 0) {
                 TEPoint::zero()
             } else {
-                TEPoint::new(x/y, (x-1)/(x+1))
+                TEPoint::new(x / y, (x - 1) / (x + 1))
             }
         }
     }
@@ -84,9 +84,9 @@ mod affine {
         pub fn new(j: Field, k: Field, gen: Point) -> Self {
             // Check curve coefficients
             assert(k != 0);
-            assert(j*j != 4);
+            assert(j * j != 4);
 
-            let curve = Self {j, k, gen};
+            let curve = Self { j, k, gen };
 
             // gen should be on the curve
             assert(curve.contains(curve.gen));
@@ -103,8 +103,8 @@ mod affine {
         pub fn contains(self, p: Point) -> bool {
             let Self {j, k, gen: _gen} = self;
             let Point {x, y, infty: infty} = p;
-            
-            infty | (k*y*y == x*(x*x + j*x + 1))
+
+            infty | (k * y * y == x * (x * x + j * x + 1))
         }
 
         // Point addition
@@ -122,7 +122,7 @@ mod affine {
         fn mul(self, n: Field, p: Point) -> Point {
             self.into_tecurve().mul(n, p.into_tecurve()).into_montcurve()
         }
-        
+
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
         fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
@@ -142,15 +142,15 @@ mod affine {
         // Conversion to equivalent Twisted Edwards curve
         fn into_tecurve(self) -> TECurve {
             let Self {j, k, gen} = self;
-            TECurve::new((j+2)/k, (j-2)/k, gen.into_tecurve())
+            TECurve::new((j + 2) / k, (j - 2) / k, gen.into_tecurve())
         }
 
         // Conversion to equivalent Short Weierstraß curve
         pub fn into_swcurve(self) -> SWCurve {
             let j = self.j;
             let k = self.k;
-            let a0 = (3-j*j)/(3*k*k);
-            let b0 = (2*j*j*j - 9*j)/(27*k*k*k);
+            let a0 = (3 - j * j) / (3 * k * k);
+            let b0 = (2 * j * j * j - 9 * j) / (27 * k * k * k);
 
             SWCurve::new(a0, b0, self.map_into_swcurve(self.gen))
         }
@@ -160,8 +160,7 @@ mod affine {
             if p.is_zero() {
                 SWPoint::zero()
             } else {
-                SWPoint::new((3*p.x + self.j)/(3*self.k),
-                             p.y/self.k)
+                SWPoint::new((3 * p.x + self.j) / (3 * self.k), p.y / self.k)
             }
         }
 
@@ -170,8 +169,8 @@ mod affine {
             let SWPoint {x, y, infty} = p;
             let j = self.j;
             let k = self.k;
-            
-            Point {x: (3*k*x - j)/3, y: y*k, infty}
+
+            Point { x: (3 * k * x - j) / 3, y: y * k, infty }
         }
 
         // Elligator 2 map-to-curve method; see <https://datatracker.ietf.org/doc/id/draft-irtf-cfrg-hash-to-curve-06.html#name-elligator-2-method>.
@@ -179,18 +178,18 @@ mod affine {
             let j = self.j;
             let k = self.k;
             let z = ZETA; // Non-square Field element required for map
-            
+
             // Check whether curve is admissible
             assert(j != 0);
-            let l = (j*j - 4)/(k*k);
+            let l = (j * j - 4) / (k * k);
             assert(l != 0);
             assert(is_square(l) == false);
 
-            let x1 = safe_inverse(1+z*u*u)*(0 - (j/k));
-            
-            let gx1 = x1*x1*x1 + (j/k)*x1*x1 + x1/(k*k);
-            let x2 = 0 - x1 - (j/k);
-            let gx2 = x2*x2*x2 + (j/k)*x2*x2 + x2/(k*k);
+            let x1 = safe_inverse(1 + z * u * u) * (0 - (j / k));
+
+            let gx1 = x1 * x1 * x1 + (j / k) * x1 * x1 + x1 / (k * k);
+            let x2 = 0 - x1 - (j / k);
+            let gx2 = x2 * x2 * x2 + (j / k) * x2 * x2 + x2 / (k * k);
 
             let x = if is_square(gx1) { x1 } else { x2 };
 
@@ -202,13 +201,12 @@ mod affine {
                 if y0.sgn0() == 0 { y0 } else { 0 - y0 }
             };
 
-            Point::new(x*k, y*k)
-                
+            Point::new(x * k, y * k)
         }
 
         // SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.map_from_swcurve(self.into_swcurve().swu_map(z,u))
+            self.map_from_swcurve(self.into_swcurve().swu_map(z, u))
         }
     }
 }
@@ -240,7 +238,7 @@ mod curvegroup {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field, z: Field) -> Self {
-            Self {x, y, z}
+            Self { x, y, z }
         }
 
         // Check if zero
@@ -254,20 +252,20 @@ mod curvegroup {
                 affine::Point::zero()
             } else {
                 let (x,y,z) = (self.x, self.y, self.z);
-                affine::Point::new(x/z, y/z)
+                affine::Point::new(x / z, y / z)
             }
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 1,z: 0}
+            Self { x: 0, y: 1, z: 0 }
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, z} = self;
 
-            Point::new(x, 0-y, z)
+            Point::new(x, 0 - y, z)
         }
 
         // Map into equivalent Twisted Edwards curve
@@ -287,9 +285,9 @@ mod curvegroup {
         pub fn new(j: Field, k: Field, gen: Point) -> Self {
             // Check curve coefficients
             assert(k != 0);
-            assert(j*j != 4);
+            assert(j * j != 4);
 
-            let curve = Self {j, k, gen};
+            let curve = Self { j, k, gen };
 
             // gen should be on the curve
             assert(curve.contains(curve.gen));
@@ -306,8 +304,8 @@ mod curvegroup {
         pub fn contains(self, p: Point) -> bool {
             let Self {j, k, gen: _gen} = self;
             let Point {x, y, z} = p;
-            
-            k*y*y*z == x*(x*x + j*x*z + z*z)
+
+            k * y * y * z == x * (x * x + j * x * z + z * z)
         }
 
         // Point addition
@@ -320,12 +318,12 @@ mod curvegroup {
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             self.into_tecurve().bit_mul(bits, p.into_tecurve()).into_montcurve()
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         pub fn mul(self, n: Field, p: Point) -> Point {
             self.into_tecurve().mul(n, p.into_tecurve()).into_montcurve()
         }
-        
+
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
         fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
@@ -345,18 +343,17 @@ mod curvegroup {
         // Conversion to equivalent Twisted Edwards curve
         fn into_tecurve(self) -> TECurve {
             let Self {j, k, gen} = self;
-            TECurve::new((j+2)/k, (j-2)/k, gen.into_tecurve())
+            TECurve::new((j + 2) / k, (j - 2) / k, gen.into_tecurve())
         }
 
         // Conversion to equivalent Short Weierstraß curve
         fn into_swcurve(self) -> SWCurve {
             let j = self.j;
             let k = self.k;
-            let a0 = (3-j*j)/(3*k*k);
-            let b0 = (2*j*j*j - 9*j)/(27*k*k*k);
+            let a0 = (3 - j * j) / (3 * k * k);
+            let b0 = (2 * j * j * j - 9 * j) / (27 * k * k * k);
 
-            SWCurve::new(a0, b0,
-                         self.map_into_swcurve(self.gen))
+            SWCurve::new(a0, b0, self.map_into_swcurve(self.gen))
         }
 
         // Point mapping into equivalent Short Weierstraß curve
@@ -373,10 +370,10 @@ mod curvegroup {
         fn elligator2_map(self, u: Field) -> Point {
             self.into_affine().elligator2_map(u).into_group()
         }
-        
+
         // SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_affine().swu_map(z,u).into_group()
+            self.into_affine().swu_map(z, u).into_group()
         }
     }
 }
diff --git a/noir_stdlib/src/ec/swcurve.nr b/noir_stdlib/src/ec/swcurve.nr
index e64f5a7be02..9dd324f3085 100644
--- a/noir_stdlib/src/ec/swcurve.nr
+++ b/noir_stdlib/src/ec/swcurve.nr
@@ -27,14 +27,14 @@ mod affine {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field) -> Self {
-            Self {x, y, infty: false}
+            Self { x, y, infty: false }
         }
 
         // Check if zero
         pub fn is_zero(self) -> bool {
             self.eq(Point::zero())
         }
-        
+
         // Conversion to CurveGroup coordinates
         fn into_group(self) -> curvegroup::Point {
             let Self {x, y, infty} = self;
@@ -45,16 +45,16 @@ mod affine {
                 curvegroup::Point::new(x, y, 1)
             }
         }
-        
+
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 0, infty: true}
+            Self { x: 0, y: 0, infty: true }
         }
-        
+
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, infty} = self;
-            Self {x, y: 0-y, infty}
+            Self { x, y: 0 - y, infty }
         }
     }
 
@@ -72,8 +72,8 @@ mod affine {
         // Curve constructor
         pub fn new(a: Field, b: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(4*a*a*a + 27*b*b != 0);
-            
+            assert(4 * a * a * a + 27 * b * b != 0);
+
             let curve = Curve { a, b, gen };
 
             // gen should be on the curve
@@ -85,16 +85,16 @@ mod affine {
         // Conversion to CurveGroup coordinates
         fn into_group(self) -> curvegroup::Curve {
             let Curve{a, b, gen} = self;
-            
-            curvegroup::Curve {a, b, gen: gen.into_group()}
+
+            curvegroup::Curve { a, b, gen: gen.into_group() }
         }
 
         // Membership check
         pub fn contains(self, p: Point) -> bool {
             let Point {x, y, infty} = p;
-            infty | (y*y == x*x*x + self.a*x + self.b)
+            infty | (y * y == x * x * x + self.a * x + self.b)
         }
-        
+
         // Point addition, implemented in terms of mixed addition for reasons of efficiency
         pub fn add(self, p1: Point, p2: Point) -> Point {
             self.mixed_add(p1, p2.into_group()).into_affine()
@@ -109,9 +109,9 @@ mod affine {
             } else {
                 let Point {x: x1, y: y1, infty: _inf} = p1;
                 let curvegroup::Point {x: x2, y: y2, z: z2} = p2;
-                let you1 = x1*z2*z2;
+                let you1 = x1 * z2 * z2;
                 let you2 = x2;
-                let s1 = y1*z2*z2*z2;
+                let s1 = y1 * z2 * z2 * z2;
                 let s2 = y2;
 
                 if you1 == you2 {
@@ -120,15 +120,14 @@ mod affine {
                     } else {
                         self.into_group().double(p2)
                     }
-                } else
-                {
+                } else {
                     let h = you2 - you1;
                     let r = s2 - s1;
-                    let x3 = r*r - h*h*h - 2*you1*h*h;
-                    let y3 = r*(you1*h*h - x3) - s1*h*h*h;
-                    let z3 = h*z2;
+                    let x3 = r * r - h * h * h - 2 * you1 * h * h;
+                    let y3 = r * (you1 * h * h - x3) - s1 * h * h * h;
+                    let z3 = h * z2;
 
-                    curvegroup::Point::new(x3,y3,z3)
+                    curvegroup::Point::new(x3, y3, z3)
                 }
             }
         }
@@ -138,7 +137,7 @@ mod affine {
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             self.into_group().bit_mul(bits, p.into_group()).into_affine()
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         pub fn mul(self, n: Field, p: Point) -> Point {
             self.into_group().mul(n, p.into_group()).into_affine()
@@ -165,17 +164,25 @@ mod affine {
         // where g(x) = x^3 + a*x + b. swu_map(c,z,.) then maps a Field element to a point on curve c.
         fn swu_map(self, z: Field, u: Field) -> Point {
             // Check whether curve is admissible
-            assert(self.a*self.b != 0);
-            
+            assert(self.a * self.b != 0);
+
             let Curve {a, b, gen: _gen} = self;
-            
-            let tv1 = safe_inverse(z*z*u*u*u*u + u*u*z);
-            let x1 = if tv1 == 0 {b/(z*a)} else {(0-b/a)*(1 + tv1)};
-            let gx1 = x1*x1*x1 + a*x1 + b;
-            let x2 = z*u*u*x1;
-            let gx2 = x2*x2*x2 + a*x2 + b;
-            let (x,y) = if is_square(gx1) {(x1, sqrt(gx1))} else {(x2, sqrt(gx2))};
-            Point::new(x, if u.sgn0() != y.sgn0() {0-y} else {y})
+
+            let tv1 = safe_inverse(z * z * u * u * u * u + u * u * z);
+            let x1 = if tv1 == 0 {
+                b / (z * a)
+            } else {
+                (0 - b / a) * (1 + tv1)
+            };
+            let gx1 = x1 * x1 * x1 + a * x1 + b;
+            let x2 = z * u * u * x1;
+            let gx2 = x2 * x2 * x2 + a * x2 + b;
+            let (x,y) = if is_square(gx1) {
+                (x1, sqrt(gx1))
+            } else {
+                (x2, sqrt(gx2))
+            };
+            Point::new(x, if u.sgn0() != y.sgn0() { 0 - y } else { y })
         }
     }
 }
@@ -205,14 +212,14 @@ mod curvegroup {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field, z: Field) -> Self {
-            Self {x, y, z}
+            Self { x, y, z }
         }
 
         // Check if zero
         pub fn is_zero(self) -> bool {
             self.eq(Point::zero())
         }
-        
+
         // Conversion to affine coordinates
         pub fn into_affine(self) -> affine::Point {
             let Self {x, y, z} = self;
@@ -220,20 +227,19 @@ mod curvegroup {
             if z == 0 {
                 affine::Point::zero()
             } else {
-                affine::Point::new(x/(z*z), y/(z*z*z))
+                affine::Point::new(x / (z * z), y / (z * z * z))
             }
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 0, z: 0}
+            Self { x: 0, y: 0, z: 0 }
         }
-        
-        
+
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, z} = self;
-            Self {x, y: 0-y, z}
+            Self { x, y: 0 - y, z }
         }
     }
 
@@ -250,8 +256,8 @@ mod curvegroup {
         // Curve constructor
         pub fn new(a: Field, b: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(4*a*a*a + 27*b*b != 0);
-            
+            assert(4 * a * a * a + 27 * b * b != 0);
+
             let curve = Curve { a, b, gen };
 
             // gen should be on the curve
@@ -264,7 +270,7 @@ mod curvegroup {
         pub fn into_affine(self) -> affine::Curve {
             let Curve{a, b, gen} = self;
 
-            affine::Curve {a, b, gen: gen.into_affine()}
+            affine::Curve { a, b, gen: gen.into_affine() }
         }
 
         // Membership check
@@ -273,13 +279,12 @@ mod curvegroup {
             if z == 0 {
                 true
             } else {
-                y*y == x*x*x + self.a*x*z*z*z*z +  self.b*z*z*z*z*z*z
+                y * y == x * x * x + self.a * x * z * z * z * z + self.b * z * z * z * z * z * z
             }
         }
-        
+
         // Addition
         pub fn add(self, p1: Point, p2: Point) -> Point {
-
             if p1.is_zero() {
                 p2
             } else if p2.is_zero() {
@@ -287,10 +292,10 @@ mod curvegroup {
             } else {
                 let Point {x: x1, y: y1, z: z1} = p1;
                 let Point {x: x2, y: y2, z: z2} = p2;
-                let you1 = x1*z2*z2;
-                let you2 = x2*z1*z1;
-                let s1 = y1*z2*z2*z2;
-                let s2 = y2*z1*z1*z1;
+                let you1 = x1 * z2 * z2;
+                let you2 = x2 * z1 * z1;
+                let s1 = y1 * z2 * z2 * z2;
+                let s2 = y2 * z1 * z1 * z1;
 
                 if you1 == you2 {
                     if s1 != s2 {
@@ -301,11 +306,11 @@ mod curvegroup {
                 } else {
                     let h = you2 - you1;
                     let r = s2 - s1;
-                    let x3 = r*r - h*h*h - 2*you1*h*h;
-                    let y3 = r*(you1*h*h - x3) - s1*h*h*h;
-                    let z3 = h*z1*z2;
+                    let x3 = r * r - h * h * h - 2 * you1 * h * h;
+                    let y3 = r * (you1 * h * h - x3) - s1 * h * h * h;
+                    let z3 = h * z1 * z2;
 
-                    Point::new(x3,y3,z3)
+                    Point::new(x3, y3, z3)
                 }
             }
         }
@@ -313,19 +318,19 @@ mod curvegroup {
         // Point doubling
         pub fn double(self, p: Point) -> Point {
             let Point {x, y, z} = p;
-            
+
             if p.is_zero() {
                 p
             } else if y == 0 {
                 Point::zero()
             } else {
-                let s = 4*x*y*y;
-                let m = 3*x*x + self.a*z*z*z*z;
-                let x0 = m*m - 2*s;
-                let y0 = m*(s-x0) - 8*y*y*y*y;
-                let z0 = 2*y*z;
+                let s = 4 * x * y * y;
+                let m = 3 * x * x + self.a * z * z * z * z;
+                let x0 = m * m - 2 * s;
+                let y0 = m * (s - x0) - 8 * y * y * y * y;
+                let z0 = 2 * y * z;
 
-                Point::new(x0,y0,z0)
+                Point::new(x0, y0, z0)
             }
         }
 
@@ -351,7 +356,7 @@ mod curvegroup {
             let mut n_as_bits: [u1; 254] = [0; 254];
             let tmp = n.to_le_bits(N_BITS as u32);
             for i in 0..254 {
-               n_as_bits[i] = tmp[i]; 
+                n_as_bits[i] = tmp[i];
             }
 
             self.bit_mul(n_as_bits, p)
@@ -375,7 +380,7 @@ mod curvegroup {
 
         // Simplified SWU map-to-curve method
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_affine().swu_map(z,u).into_group()
+            self.into_affine().swu_map(z, u).into_group()
         }
     }
 }
diff --git a/noir_stdlib/src/ec/tecurve.nr b/noir_stdlib/src/ec/tecurve.nr
index 5333ece4c4a..506fe89313a 100644
--- a/noir_stdlib/src/ec/tecurve.nr
+++ b/noir_stdlib/src/ec/tecurve.nr
@@ -40,18 +40,18 @@ mod affine {
         fn into_group(self) -> curvegroup::Point {
             let Self {x, y} = self;
 
-            curvegroup::Point::new(x, y, x*y, 1)
+            curvegroup::Point::new(x, y, x * y, 1)
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Point::new(0,1)
+            Point::new(0, 1)
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y} = self;
-            Point::new(0-x, y)
+            Point::new(0 - x, y)
         }
 
         // Map into prime-order subgroup of equivalent Montgomery curve
@@ -60,10 +60,10 @@ mod affine {
                 MPoint::zero()
             } else {
                 let Self {x, y} = self;
-                let x0 = (1+y)/(1-y);
-                let y0 = (1+y)/(x*(1-y));
+                let x0 = (1 + y) / (1 - y);
+                let y0 = (1 + y) / (x * (1 - y));
 
-                MPoint::new(x0,y0)
+                MPoint::new(x0, y0)
             }
         }
     }
@@ -81,9 +81,9 @@ mod affine {
         // Curve constructor
         pub fn new(a: Field, d: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(a*d*(a-d) != 0);
-            
-            let curve = Curve {a, d, gen};
+            assert(a * d * (a - d) != 0);
+
+            let curve = Curve { a, d, gen };
 
             // gen should be on the curve
             assert(curve.contains(curve.gen));
@@ -95,15 +95,15 @@ mod affine {
         fn into_group(self) -> curvegroup::Curve {
             let Curve{a, d, gen} = self;
 
-            curvegroup::Curve {a, d, gen: gen.into_group()}
+            curvegroup::Curve { a, d, gen: gen.into_group() }
         }
-        
+
         // Membership check
         pub fn contains(self, p: Point) -> bool {
             let Point {x, y} = p;
-            self.a*x*x + y*y == 1 + self.d*x*x*y*y
+            self.a * x * x + y * y == 1 + self.d * x * x * y * y
         }
-        
+
         // Point addition, implemented in terms of mixed addition for reasons of efficiency
         pub fn add(self, p1: Point, p2: Point) -> Point {
             self.mixed_add(p1, p2.into_group()).into_affine()
@@ -114,20 +114,20 @@ mod affine {
             let Point{x: x1, y: y1} = p1;
             let curvegroup::Point{x: x2, y: y2, t: t2, z: z2} = p2;
 
-            let a = x1*x2;
-            let b = y1*y2;
-            let c = self.d*x1*y1*t2;
-            let e = (x1 + y1)*(x2 + y2) - a - b;
+            let a = x1 * x2;
+            let b = y1 * y2;
+            let c = self.d * x1 * y1 * t2;
+            let e = (x1 + y1) * (x2 + y2) - a - b;
             let f = z2 - c;
             let g = z2 + c;
-            let h = b - self.a*a;
+            let h = b - self.a * a;
 
-            let x = e*f;
-            let y = g*h;
-            let t = e*h;
-            let z = f*g;
+            let x = e * f;
+            let y = g * h;
+            let t = e * h;
+            let z = f * g;
 
-            curvegroup::Point::new(x,y,t,z)
+            curvegroup::Point::new(x, y, t, z)
         }
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
@@ -135,7 +135,7 @@ mod affine {
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             self.into_group().bit_mul(bits, p.into_group()).into_affine()
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         fn mul(self, n: Field, p: Point) -> Point {
             self.into_group().mul(n, p.into_group()).into_affine()
@@ -159,10 +159,10 @@ mod affine {
 
         // Conversion to equivalent Montgomery curve
         pub fn into_montcurve(self) -> MCurve {
-            let j = 2*(self.a + self.d)/(self.a - self.d);
-            let k = 4/(self.a - self.d);
+            let j = 2 * (self.a + self.d) / (self.a - self.d);
+            let k = 4 / (self.a - self.d);
             let gen_montcurve = self.gen.into_montcurve();
-            
+
             MCurve::new(j, k, gen_montcurve)
         }
 
@@ -188,7 +188,7 @@ mod affine {
 
         // Simplified SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_montcurve().swu_map(z,u).into_tecurve()
+            self.into_montcurve().swu_map(z, u).into_tecurve()
         }
     }
 }
@@ -222,7 +222,7 @@ mod curvegroup {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field, t: Field, z: Field) -> Self {
-            Self {x, y, t, z}
+            Self { x, y, t, z }
         }
 
         // Check if zero
@@ -235,19 +235,19 @@ mod curvegroup {
         pub fn into_affine(self) -> affine::Point {
             let Self {x, y, t: _t, z} = self;
 
-            affine::Point::new(x/z, y/z)
+            affine::Point::new(x / z, y / z)
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Point::new(0,1,0,1)
+            Point::new(0, 1, 0, 1)
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, t, z} = self;
 
-            Point::new(0-x, y, 0-t, z)
+            Point::new(0 - x, y, 0 - t, z)
         }
 
         // Map into prime-order subgroup of equivalent Montgomery curve
@@ -269,8 +269,8 @@ mod curvegroup {
         // Curve constructor
         pub fn new(a: Field, d: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(a*d*(a-d) != 0);
-            
+            assert(a * d * (a - d) != 0);
+
             let curve = Curve { a, d, gen };
 
             // gen should be on the curve
@@ -283,14 +283,16 @@ mod curvegroup {
         pub fn into_affine(self) -> affine::Curve {
             let Curve{a, d, gen} = self;
 
-            affine::Curve {a, d, gen: gen.into_affine()}
+            affine::Curve { a, d, gen: gen.into_affine() }
         }
 
         // Membership check
         pub fn contains(self, p: Point) -> bool {
             let Point {x, y, t, z} = p;
 
-            (z != 0) & (z*t == x*y) & (z*z*(self.a*x*x + y*y) == z*z*z*z + self.d*x*x*y*y)
+            (z != 0)
+                & (z * t == x * y)
+                & (z * z * (self.a * x * x + y * y) == z * z * z * z + self.d * x * x * y * y)
         }
 
         // Point addition
@@ -298,40 +300,40 @@ mod curvegroup {
             let Point{x: x1, y: y1, t: t1, z: z1} = p1;
             let Point{x: x2, y: y2, t: t2, z: z2} = p2;
 
-            let a = x1*x2;
-            let b = y1*y2;
-            let c = self.d*t1*t2;
-            let d = z1*z2;
-            let e = (x1 + y1)*(x2 + y2) - a - b;
+            let a = x1 * x2;
+            let b = y1 * y2;
+            let c = self.d * t1 * t2;
+            let d = z1 * z2;
+            let e = (x1 + y1) * (x2 + y2) - a - b;
             let f = d - c;
             let g = d + c;
-            let h = b - self.a*a;
+            let h = b - self.a * a;
 
-            let x = e*f;
-            let y = g*h;
-            let t = e*h;
-            let z = f*g;
+            let x = e * f;
+            let y = g * h;
+            let t = e * h;
+            let z = f * g;
 
-            Point::new(x,y,t,z)
+            Point::new(x, y, t, z)
         }
 
         // Point doubling, cf. §3.3
         pub fn double(self, p: Point) -> Point {
             let Point{x, y, t: _t, z} = p;
 
-            let a = x*x;
-            let b = y*y;
-            let c = 2*z*z;
-            let d = self.a*a;
-            let e = (x + y)*(x + y) - a - b;
+            let a = x * x;
+            let b = y * y;
+            let c = 2 * z * z;
+            let d = self.a * a;
+            let e = (x + y) * (x + y) - a - b;
             let g = d + b;
             let f = g - c;
             let h = d - b;
 
-            let x0 = e*f;
-            let y0 = g*h;
-            let t0 = e*h;
-            let z0 = f*g;
+            let x0 = e * f;
+            let y0 = g * h;
+            let t0 = e * h;
+            let z0 = f * g;
 
             Point::new(x0, y0, t0, z0)
         }
@@ -340,7 +342,7 @@ mod curvegroup {
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             let mut out = Point::zero();
-            
+
             for i in 0..N {
                 out = self.add(
                     self.add(out, out),
@@ -349,7 +351,7 @@ mod curvegroup {
 
             out
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         pub fn mul(self, n: Field, p: Point) -> Point {
             let N_BITS = crate::field::modulus_num_bits();
@@ -358,7 +360,7 @@ mod curvegroup {
             let mut n_as_bits: [u1; 254] = [0; 254];
             let tmp = n.to_le_bits(N_BITS as u32);
             for i in 0..254 {
-               n_as_bits[i] = tmp[i]; 
+                n_as_bits[i] = tmp[i];
             }
 
             self.bit_mul(n_as_bits, p)
@@ -407,7 +409,7 @@ mod curvegroup {
 
         // Simplified SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_montcurve().swu_map(z,u).into_tecurve()
+            self.into_montcurve().swu_map(z, u).into_tecurve()
         }
     }
 }
diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr
index e8d9af2230f..b72a1acd041 100644
--- a/noir_stdlib/src/ecdsa_secp256k1.nr
+++ b/noir_stdlib/src/ecdsa_secp256k1.nr
@@ -7,4 +7,4 @@ pub fn verify_signature<N>(
     message_hash: [u8; N]
 ) -> bool
 // docs:end:ecdsa_secp256k1
-{}
\ No newline at end of file
+{}
diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr
index 9fe932a2f3d..ef92bf24ae4 100644
--- a/noir_stdlib/src/ecdsa_secp256r1.nr
+++ b/noir_stdlib/src/ecdsa_secp256r1.nr
@@ -7,4 +7,4 @@ pub fn verify_signature<N>(
     message_hash: [u8; N]
 ) -> bool
 // docs:end:ecdsa_secp256r1
-{}
\ No newline at end of file
+{}
diff --git a/noir_stdlib/src/field.nr b/noir_stdlib/src/field.nr
index a7278d85999..0f4c2caffdf 100644
--- a/noir_stdlib/src/field.nr
+++ b/noir_stdlib/src/field.nr
@@ -6,7 +6,7 @@ impl Field {
         crate::assert_constant(bit_size);
         self.__to_le_bits(bit_size)
     }
-    
+
     pub fn to_be_bits(self: Self, bit_size: u32) -> [u1] {
         crate::assert_constant(bit_size);
         self.__to_be_bits(bit_size)
@@ -14,7 +14,7 @@ impl Field {
 
     #[builtin(to_le_bits)]
     fn __to_le_bits(self, _bit_size: u32) -> [u1] {}
-    
+
     #[builtin(to_be_bits)]
     fn __to_be_bits(self, bit_size: u32) -> [u1] {}
 
@@ -35,7 +35,6 @@ impl Field {
         self.to_be_radix(256, byte_size)
     }
 
-
     pub fn to_le_radix(self: Self, radix: u32, result_len: u32) -> [u8] {
         crate::assert_constant(radix);
         crate::assert_constant(result_len);
@@ -48,17 +47,14 @@ impl Field {
         self.__to_be_radix(radix, result_len)
     }
 
-
-
     // decompose `_self` into a `_result_len` vector over the `_radix` basis
     // `_radix` must be less than 256
     #[builtin(to_le_radix)]
     fn __to_le_radix(self, radix: u32, result_len: u32) -> [u8] {}
-    
+
     #[builtin(to_be_radix)]
     fn __to_be_radix(self, radix: u32, result_len: u32) -> [u8] {}
 
-
     // Returns self to the power of the given exponent value.
     // Caution: we assume the exponent fits into 32 bits
     // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits
@@ -85,7 +81,6 @@ impl Field {
             lt_fallback(self, another)
         }
     }
-
 }
 
 #[builtin(modulus_num_bits)]
diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index cab95731d05..1c32f758af7 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -39,11 +39,7 @@ impl<T> Option<T> {
 
     /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
     pub fn unwrap_or(self, default: T) -> T {
-        if self._is_some {
-            self._value
-        } else {
-            default
-        }
+        if self._is_some { self._value } else { default }
     }
 
     /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return
@@ -112,31 +108,19 @@ impl<T> Option<T> {
 
     /// If self is Some, return self. Otherwise, return `other`.
     pub fn or(self, other: Self) -> Self {
-        if self._is_some {
-            self
-        } else {
-            other
-        }
+        if self._is_some { self } else { other }
     }
 
     /// If self is Some, return self. Otherwise, return `default()`.
     pub fn or_else<U, Env>(self, default: fn[Env]() -> Self) -> Self {
-        if self._is_some {
-            self
-        } else {
-            default()
-        }
+        if self._is_some { self } else { default() }
     }
 
     // If only one of the two Options is Some, return that option.
     // Otherwise, if both options are Some or both are None, None is returned.
     pub fn xor(self, other: Self) -> Self {
         if self._is_some {
-            if other._is_some {
-                Option::none()
-            } else {
-                self
-            }
+            if other._is_some { Option::none() } else { self }
         } else if other._is_some {
             other
         } else {
diff --git a/noir_stdlib/src/scalar_mul.nr b/noir_stdlib/src/scalar_mul.nr
index 1a7f1ad707c..eee7aac39f2 100644
--- a/noir_stdlib/src/scalar_mul.nr
+++ b/noir_stdlib/src/scalar_mul.nr
@@ -6,7 +6,7 @@ struct EmbeddedCurvePoint {
 }
 
 impl EmbeddedCurvePoint {
-    fn double(self) -> EmbeddedCurvePoint { 
+    fn double(self) -> EmbeddedCurvePoint {
         embedded_curve_add(self, self)
     }
 }
diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr
index 33656254550..757963d40d7 100644
--- a/noir_stdlib/src/schnorr.nr
+++ b/noir_stdlib/src/schnorr.nr
@@ -7,4 +7,4 @@ pub fn verify_signature<N>(
     message: [u8; N]
 ) -> bool
 // docs:end:schnorr_verify
-{}
\ No newline at end of file
+{}
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index bb5c43e497b..ea8d09d14ce 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -3,34 +3,34 @@ impl<T> [T] {
     /// new slice with a length one greater than the
     /// original unmodified slice.
     #[builtin(slice_push_back)]
-    pub fn push_back(self, elem: T) -> Self { }
+    pub fn push_back(self, elem: T) -> Self {}
 
     /// Push a new element to the front of the slice, returning a
     /// new slice with a length one greater than the 
     /// original unmodified slice. 
     #[builtin(slice_push_front)]
-    pub fn push_front(self, elem: T) -> Self { }
+    pub fn push_front(self, elem: T) -> Self {}
 
     /// Remove the last element of the slice, returning the
     /// popped slice and the element in a tuple
     #[builtin(slice_pop_back)]
-    pub fn pop_back(self) -> (Self, T) { }
+    pub fn pop_back(self) -> (Self, T) {}
 
     /// Remove the first element of the slice, returning the
     /// element and the popped slice in a tuple
     #[builtin(slice_pop_front)]
-    pub fn pop_front(self) -> (T, Self) { }
+    pub fn pop_front(self) -> (T, Self) {}
 
     /// Insert an element at a specified index, shifting all elements 
     /// after it to the right
     #[builtin(slice_insert)]
-    pub fn insert(self, index: u64, elem: T) -> Self { }
+    pub fn insert(self, index: u64, elem: T) -> Self {}
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the altered slice and 
     /// the removed element
     #[builtin(slice_remove)]
-    pub fn remove(self, index: u64) -> (Self, T) { }
+    pub fn remove(self, index: u64) -> (Self, T) {}
 
     // Append each element of the `other` slice to the end of `self`.
     // This returns a new slice and leaves both input slices unchanged.
diff --git a/noir_stdlib/src/string.nr b/noir_stdlib/src/string.nr
index ad6fd19e2de..12b5a1e75ec 100644
--- a/noir_stdlib/src/string.nr
+++ b/noir_stdlib/src/string.nr
@@ -2,7 +2,7 @@ use crate::collections::vec::Vec;
 impl<N> str<N> {
     /// Converts the given string into a byte array
     #[builtin(str_as_bytes)]
-    pub fn as_bytes(self) -> [u8; N] { }
+    pub fn as_bytes(self) -> [u8; N] {}
 
     /// return a byte vector of the str content
     pub fn as_bytes_vec(self: Self) -> Vec<u8> {
diff --git a/noir_stdlib/src/test.nr b/noir_stdlib/src/test.nr
index 560cfde741c..e1c320215de 100644
--- a/noir_stdlib/src/test.nr
+++ b/noir_stdlib/src/test.nr
@@ -19,9 +19,7 @@ struct OracleMock {
 
 impl OracleMock {
     unconstrained pub fn mock<N>(name: str<N>) -> Self {
-        Self {
-            id: create_mock_oracle(name),
-        }
+        Self { id: create_mock_oracle(name) }
     }
 
     unconstrained pub fn with_params<P>(self, params: P) -> Self {
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index c8c6217de90..d6f0b1e2232 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -13,14 +13,11 @@ impl U128 {
     pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {
         // in order to handle multiplication, we need to represent the product of two u64 without overflow
         assert(crate::field::modulus_num_bits() as u32 > 128);
-        U128 {
-            lo: lo as Field,
-            hi: hi as Field,
-        }
+        U128 { lo: lo as Field, hi: hi as Field }
     }
 
     pub fn from_u64s_be(hi: u64, lo: u64) -> U128 {
-        U128::from_u64s_le(lo,hi)
+        U128::from_u64s_le(lo, hi)
     }
 
     pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {
@@ -36,16 +33,13 @@ impl U128 {
             hi += (bytes[i] as Field)*base;
             base *= 256;
         }
-        U128 {
-            lo,
-            hi,
-        }
+        U128 { lo, hi }
     }
 
     pub fn to_be_bytes(self: Self) -> [u8; 16] {
         let lo = self.lo.to_be_bytes(8);
         let hi = self.hi.to_be_bytes(8);
-        let mut bytes = [0;16];
+        let mut bytes = [0; 16];
         for i in 0..8 {
             bytes[i] = hi[i];
             bytes[i+8] = lo[i];
@@ -56,7 +50,7 @@ impl U128 {
     pub fn to_le_bytes(self: Self) -> [u8; 16] {
         let lo = self.lo.to_le_bytes(8);
         let hi = self.hi.to_le_bytes(8);
-        let mut bytes = [0;16];
+        let mut bytes = [0; 16];
         for i in 0..8 {
             bytes[i] = lo[i];
             bytes[i+8] = hi[i];
@@ -73,9 +67,9 @@ impl U128 {
 
         let mut lo = 0;
         let mut hi = 0;
-        let mut base = 1; 
+        let mut base = 1;
         if N <= 18 {
-            for i in 0..N-2 {
+            for i in 0..N - 2 {
                 lo += U128::decode_ascii(bytes[N-i-1])*base;
                 base = base*16;
             }
@@ -85,27 +79,21 @@ impl U128 {
                 base = base*16;
             }
             base = 1;
-            for i in 17..N-1 {           
+            for i in 17..N - 1 {
                 hi += U128::decode_ascii(bytes[N-i])*base;
                 base = base*16;
             }
         }
-        U128 {
-            lo: lo as Field,
-            hi: hi as Field,
-        }
+        U128 { lo: lo as Field, hi: hi as Field }
     }
 
     fn decode_ascii(ascii: u8) -> Field {
         if ascii < 58 {
             ascii - 48
+        } else if ascii < 71 {
+            ascii - 55
         } else {
-            if ascii < 71 {
-                ascii - 55
-            } else {
-                ascii - 87
-            }
-            
+            ascii - 87
         } as Field
     }
 
@@ -114,15 +102,14 @@ impl U128 {
             (U128::from_u64s_le(0, 0), self)
         } else {
             //TODO check if this can overflow?
-            let (q,r) = self.unconstrained_div(b * U128::from_u64s_le(2,0));
-            let q_mul_2 = q * U128::from_u64s_le(2,0);
+            let (q,r) = self.unconstrained_div(b * U128::from_u64s_le(2, 0));
+            let q_mul_2 = q * U128::from_u64s_le(2, 0);
             if r < b {
                 (q_mul_2, r)
             } else {
-                (q_mul_2 + U128::from_u64s_le(1,0), r - b)
+                (q_mul_2 + U128::from_u64s_le(1, 0), r - b)
             }
-
-        }  
+        }
     }
 
     pub fn from_integer<T>(i: T) -> U128 {
@@ -130,31 +117,25 @@ impl U128 {
         // Reject values which would overflow a u128
         f.assert_max_bit_size(128);
         let lo = f as u64 as Field;
-        let hi = (f-lo) / pow64;
-        U128 {
-            lo,
-            hi,
-        }
+        let hi = (f - lo) / pow64;
+        U128 { lo, hi }
     }
 
     pub fn to_integer<T>(self) -> T {
-        crate::from_field(self.lo+self.hi*pow64)
+        crate::from_field(self.lo + self.hi * pow64)
     }
 
     fn wrapping_mul(self: Self, b: U128) -> U128 {
-        let low = self.lo*b.lo;
+        let low = self.lo * b.lo;
         let lo = low as u64 as Field;
         let carry = (low - lo) / pow64;
         let high = if crate::field::modulus_num_bits() as u32 > 196 {
-            (self.lo+self.hi)*(b.lo+b.hi) - low + carry
+            (self.lo + self.hi) * (b.lo + b.hi) - low + carry
         } else {
-            self.lo*b.hi + self.hi*b.lo + carry
+            self.lo * b.hi + self.hi * b.lo + carry
         };
         let hi = high as u64 as Field;
-        U128 {
-            lo,
-            hi,
-        }
+        U128 { lo, hi }
     }
 }
 
diff --git a/test_programs/.gitignore b/test_programs/.gitignore
index a229df6197f..e98a2fb38b6 100644
--- a/test_programs/.gitignore
+++ b/test_programs/.gitignore
@@ -1,2 +1,3 @@
 acir_artifacts
-execution_success/**/crs
\ No newline at end of file
+execution_success/**/crs
+Nargo.toml
diff --git a/test_programs/compile_success_empty/closure_explicit_types/src/main.nr b/test_programs/compile_success_empty/closure_explicit_types/src/main.nr
index eec2b90b5b2..b6c8a6b7b3c 100644
--- a/test_programs/compile_success_empty/closure_explicit_types/src/main.nr
+++ b/test_programs/compile_success_empty/closure_explicit_types/src/main.nr
@@ -7,13 +7,13 @@ fn ret_closure1() -> fn[(Field,)]() -> Field {
     || x + 10
 }
 // return lamda that captures two things
-fn ret_closure2() -> fn[(Field,Field)]() -> Field {
+fn ret_closure2() -> fn[(Field, Field)]() -> Field {
     let x = 20;
     let y = 10;
     || x + y + 10
 }
 // return lamda that captures two things with different types
-fn ret_closure3() -> fn[(u32,u64)]() -> u64 {
+fn ret_closure3() -> fn[(u32, u64)]() -> u64 {
     let x: u32 = 20;
     let y: u64 = 10;
     || x as u64 + y + 10
diff --git a/test_programs/compile_success_empty/conditional_regression_579/src/main.nr b/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
index a479a7a6fbf..a517f4fdb70 100644
--- a/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
+++ b/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
@@ -12,9 +12,7 @@ struct MyStruct579 {
 
 impl MyStruct579 {
     fn new(array_param: [u32; 2]) -> MyStruct579 {
-        MyStruct579 {
-            array_param: array_param
-        }
+        MyStruct579 { array_param }
     }
 }
 
diff --git a/test_programs/compile_success_empty/reexports/src/main.nr b/test_programs/compile_success_empty/reexports/src/main.nr
index bb94b21b221..ed469ff77d0 100644
--- a/test_programs/compile_success_empty/reexports/src/main.nr
+++ b/test_programs/compile_success_empty/reexports/src/main.nr
@@ -1,8 +1,6 @@
 use dep::reexporting_lib::{FooStruct, MyStruct, lib};
 
 fn main() {
-    let x: FooStruct = MyStruct {
-        inner: 0
-    };
+    let x: FooStruct = MyStruct { inner: 0 };
     assert(lib::is_struct_zero(x));
 }
diff --git a/test_programs/compile_success_empty/specialization/src/main.nr b/test_programs/compile_success_empty/specialization/src/main.nr
index 9cd32e0f1eb..30116330a86 100644
--- a/test_programs/compile_success_empty/specialization/src/main.nr
+++ b/test_programs/compile_success_empty/specialization/src/main.nr
@@ -1,11 +1,15 @@
 struct Foo<T> {}
 
 impl Foo<u32> {
-    fn foo(_self: Self) -> Field { 1 }
+    fn foo(_self: Self) -> Field {
+        1
+    }
 }
 
 impl Foo<u64> {
-    fn foo(_self: Self) -> Field { 2 }
+    fn foo(_self: Self) -> Field {
+        2
+    }
 }
 
 fn main() {
diff --git a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
index e1d601b13c9..8250b31789b 100644
--- a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
+++ b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
@@ -10,15 +10,15 @@ struct B<T_C> {
     }
 
 impl<T_C> B<T_C> {
-        fn new(new_concrete_t_c_constructor: fn () -> T_C) -> B<T_C> {
-            B { new_concrete_t_c_constructor }
-        }
+    fn new(new_concrete_t_c_constructor: fn() -> T_C) -> B<T_C> {
+        B { new_concrete_t_c_constructor }
+    }
 
-        fn get_t_c(self) -> T_C {
-            let new_concrete_t_c_constructor = self.new_concrete_t_c_constructor;
-            new_concrete_t_c_constructor()
-        }
+    fn get_t_c(self) -> T_C {
+        let new_concrete_t_c_constructor = self.new_concrete_t_c_constructor;
+        new_concrete_t_c_constructor()
     }
+}
 // ---
 // Set<Note>
 struct C<T_D> {
@@ -26,15 +26,15 @@ struct C<T_D> {
     }
 
 impl<T_D> C<T_D> {
-        fn new (t_d_interface: MethodInterface<T_D>) -> Self {
-            C { t_d_interface }
-        }
+    fn new(t_d_interface: MethodInterface<T_D>) -> Self {
+        C { t_d_interface }
+    }
 
-        fn call_method_of_t_d(self, t_d: T_D) -> Field {
-            let some_method_on_t_d = self.t_d_interface.some_method_on_t_d;
-            some_method_on_t_d(t_d)
-        }
+    fn call_method_of_t_d(self, t_d: T_D) -> Field {
+        let some_method_on_t_d = self.t_d_interface.some_method_on_t_d;
+        some_method_on_t_d(t_d)
     }
+}
 // ---
 struct MethodInterface<T_D> {
         some_method_on_t_d: fn(T_D)->Field,
diff --git a/test_programs/execution_success/array_dynamic/src/main.nr b/test_programs/execution_success/array_dynamic/src/main.nr
index dde7bacc455..6b51095bd8c 100644
--- a/test_programs/execution_success/array_dynamic/src/main.nr
+++ b/test_programs/execution_success/array_dynamic/src/main.nr
@@ -2,8 +2,8 @@ fn main(
     x: [u32; 5],
     mut z: u32,
     t: u32,
-    index: [Field;5],
-    index2: [Field;5],
+    index: [Field; 5],
+    index2: [Field; 5],
     offset: Field,
     sublen: Field
 ) {
diff --git a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
index aabf7fc9d5c..4cbf1bd8e6d 100644
--- a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
+++ b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
@@ -24,4 +24,4 @@ fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {
 
     // Regression for issue #4258
     assert(root == current);
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/array_dynamic_main_output/src/main.nr b/test_programs/execution_success/array_dynamic_main_output/src/main.nr
index ccb7016a190..50feb71f983 100644
--- a/test_programs/execution_success/array_dynamic_main_output/src/main.nr
+++ b/test_programs/execution_success/array_dynamic_main_output/src/main.nr
@@ -1,4 +1,4 @@
 fn main(mut x: [Field; 10], index: u8) -> pub [Field; 10] {
     x[index] = 0;
     x
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/assert_statement_recursive/src/main.nr b/test_programs/execution_success/assert_statement_recursive/src/main.nr
index 687a0d324ba..d89ea3d35bb 100644
--- a/test_programs/execution_success/assert_statement_recursive/src/main.nr
+++ b/test_programs/execution_success/assert_statement_recursive/src/main.nr
@@ -8,4 +8,4 @@
 fn main(x: Field, y: pub Field) {
     assert(x == y, "x and y are not equal");
     assert_eq(x, y, "x and y are not equal");
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 74949a5f785..046d7d07d5e 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -1,8 +1,8 @@
 use dep::std::bigint;
 
-fn main(mut x: [u8;5], y: [u8;5]) {
-    let a = bigint::BigInt::secpk1_fq_from_le_bytes([x[0],x[1],x[2],x[3],x[4]]);
-    let b = bigint::BigInt::secpk1_fq_from_le_bytes([y[0],y[1],y[2],y[3],y[4]]);
+fn main(mut x: [u8; 5], y: [u8; 5]) {
+    let a = bigint::BigInt::secpk1_fq_from_le_bytes([x[0], x[1], x[2], x[3], x[4]]);
+    let b = bigint::BigInt::secpk1_fq_from_le_bytes([y[0], y[1], y[2], y[3], y[4]]);
 
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
@@ -11,11 +11,11 @@ fn main(mut x: [u8;5], y: [u8;5]) {
         assert(b_bytes[i] == y[i]);
     }
 
-    let d = a*b - b;
+    let d = a * b - b;
     let d_bytes = d.to_le_bytes();
     let d1 = bigint::BigInt::secpk1_fq_from_le_bytes(597243850900842442924.to_le_bytes(10));
     let d1_bytes = d1.to_le_bytes();
     for i in 0..32 {
-        assert(d_bytes[i] == d1_bytes[i]);    
+        assert(d_bytes[i] == d1_bytes[i]);
     }
 }
diff --git a/test_programs/execution_success/brillig_cow/src/main.nr b/test_programs/execution_success/brillig_cow/src/main.nr
index 7d847e085fe..52ce8b8be3c 100644
--- a/test_programs/execution_success/brillig_cow/src/main.nr
+++ b/test_programs/execution_success/brillig_cow/src/main.nr
@@ -10,42 +10,37 @@ struct ExecutionResult {
 
 impl ExecutionResult {
     fn is_equal(self, other: ExecutionResult) -> bool {
-        (self.original == other.original) &
-        (self.modified_once == other.modified_once) &
-        (self.modified_twice == other.modified_twice)
+        (self.original == other.original)
+            & (self.modified_once == other.modified_once)
+            & (self.modified_twice == other.modified_twice)
     }
 }
 
 fn modify_in_inlined_constrained(original: [Field; ARRAY_SIZE], index: u64) -> ExecutionResult {
     let mut modified = original;
-    
+
     modified[index] = 27;
 
     let modified_once = modified;
 
     modified[index+1] = 27;
 
-    ExecutionResult {
-        original,
-        modified_once,
-        modified_twice: modified
-    }
+    ExecutionResult { original, modified_once, modified_twice: modified }
 }
 
-unconstrained fn modify_in_unconstrained(original: [Field; ARRAY_SIZE], index: u64) -> ExecutionResult {
+unconstrained fn modify_in_unconstrained(
+    original: [Field; ARRAY_SIZE],
+    index: u64
+) -> ExecutionResult {
     let mut modified = original;
-    
+
     modified[index] = 27;
 
     let modified_once = modified;
 
     modified[index+1] = 27;
 
-    ExecutionResult {
-        original,
-        modified_once,
-        modified_twice: modified
-    }
+    ExecutionResult { original, modified_once, modified_twice: modified }
 }
 
 unconstrained fn main(original: [Field; ARRAY_SIZE], index: u64, expected_result: ExecutionResult) {
diff --git a/test_programs/execution_success/brillig_cow_regression/src/main.nr b/test_programs/execution_success/brillig_cow_regression/src/main.nr
index 74aeda18261..7f3dd766480 100644
--- a/test_programs/execution_success/brillig_cow_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_regression/src/main.nr
@@ -47,54 +47,54 @@ struct U256 {
 }
 
 impl U256 {
-    pub fn from_bytes32(bytes : [u8;32]) -> U256 {
+    pub fn from_bytes32(bytes: [u8; 32]) -> U256 {
         // We use addition rather than a bitwise OR as the bitshifts ensure that none of the bytes overlap each other.
         let high_0 = ((bytes[0] as u64) << 56)
-                + ((bytes[1] as u64) << 48)
-                + ((bytes[2] as u64) << 40)
-                + ((bytes[3] as u64) << 32)
-                + ((bytes[4] as u64) << 24)
-                + ((bytes[5] as u64) << 16)
-                + ((bytes[6] as u64) << 8)
-                +  (bytes[7] as u64);
-        
+            + ((bytes[1] as u64) << 48)
+            + ((bytes[2] as u64) << 40)
+            + ((bytes[3] as u64) << 32)
+            + ((bytes[4] as u64) << 24)
+            + ((bytes[5] as u64) << 16)
+            + ((bytes[6] as u64) << 8)
+            + (bytes[7] as u64);
+
         let high_1 = ((bytes[8] as u64) << 56)
-                + ((bytes[9] as u64) << 48)
-                + ((bytes[10] as u64) << 40)
-                + ((bytes[11] as u64) << 32)
-                + ((bytes[12] as u64) << 24)
-                + ((bytes[13] as u64) << 16)
-                + ((bytes[14] as u64) << 8)
-                +  (bytes[15] as u64);
-        
+            + ((bytes[9] as u64) << 48)
+            + ((bytes[10] as u64) << 40)
+            + ((bytes[11] as u64) << 32)
+            + ((bytes[12] as u64) << 24)
+            + ((bytes[13] as u64) << 16)
+            + ((bytes[14] as u64) << 8)
+            + (bytes[15] as u64);
+
         let low_0 = ((bytes[16] as u64) << 56)
-                + ((bytes[17] as u64) << 48)
-                + ((bytes[18] as u64) << 40)
-                + ((bytes[19] as u64) << 32)
-                + ((bytes[20] as u64) << 24)
-                + ((bytes[21] as u64) << 16)
-                + ((bytes[22] as u64) << 8)
-                +  (bytes[23] as u64);
-        
+            + ((bytes[17] as u64) << 48)
+            + ((bytes[18] as u64) << 40)
+            + ((bytes[19] as u64) << 32)
+            + ((bytes[20] as u64) << 24)
+            + ((bytes[21] as u64) << 16)
+            + ((bytes[22] as u64) << 8)
+            + (bytes[23] as u64);
+
         let low_1 = ((bytes[24] as u64) << 56)
-                + ((bytes[25] as u64) << 48)
-                + ((bytes[26] as u64) << 40)
-                + ((bytes[27] as u64) << 32)
-                + ((bytes[28] as u64) << 24)
-                + ((bytes[29] as u64) << 16)
-                + ((bytes[30] as u64) << 8)
-                +  (bytes[31] as u64);
-
-        U256{inner : [high_0, high_1, low_0, low_1]}
+            + ((bytes[25] as u64) << 48)
+            + ((bytes[26] as u64) << 40)
+            + ((bytes[27] as u64) << 32)
+            + ((bytes[28] as u64) << 24)
+            + ((bytes[29] as u64) << 16)
+            + ((bytes[30] as u64) << 8)
+            + (bytes[31] as u64);
+
+        U256 { inner: [high_0, high_1, low_0, low_1] }
     }
 
-    pub fn to_u128_limbs(self) -> [Field;2] {
+    pub fn to_u128_limbs(self) -> [Field; 2] {
         let two_pow_64 = 2.pow_32(64);
 
         let high = (self.inner[0] as Field) * two_pow_64 + self.inner[1] as Field;
         let low  = (self.inner[2] as Field) * two_pow_64 + self.inner[3] as Field;
-        
-        [high,low]
+
+        [high, low]
     }
 }
 
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index 2f5d14583d5..ea3148915b8 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -14,7 +14,7 @@ fn main(x: u32) {
     assert(increment(x) == x + 1);
 }
 
-unconstrained fn wrapper(func: fn (u32) -> u32, param: u32) -> u32 {
+unconstrained fn wrapper(func: fn(u32) -> u32, param: u32) -> u32 {
     func(param)
 }
 
diff --git a/test_programs/execution_success/conditional_regression_661/src/main.nr b/test_programs/execution_success/conditional_regression_661/src/main.nr
index 03102eb775e..26521a88358 100644
--- a/test_programs/execution_success/conditional_regression_661/src/main.nr
+++ b/test_programs/execution_success/conditional_regression_661/src/main.nr
@@ -16,11 +16,11 @@ fn test5(a: u32) {
     }
 }
 
-fn issue_661_foo(array: [u32;4], b: u32) -> [u32;1] {
+fn issue_661_foo(array: [u32; 4], b: u32) -> [u32; 1] {
     [array[0] + b]
 }
 
-fn issue_661_bar(a: [u32;4]) -> [u32;4] {
+fn issue_661_bar(a: [u32; 4]) -> [u32; 4] {
     let mut b: [u32; 4] = [0; 4];
     b[0]=a[0]+1;
     b
diff --git a/test_programs/execution_success/databus/src/main.nr b/test_programs/execution_success/databus/src/main.nr
index 61a9637f5fe..1cf95be8a22 100644
--- a/test_programs/execution_success/databus/src/main.nr
+++ b/test_programs/execution_success/databus/src/main.nr
@@ -1,12 +1,12 @@
 use dep::std;
 
-fn main(mut x: u32, y: call_data u32, z: call_data [u32;4]) -> return_data u32 {
-  let a = z[x];
-  a+foo(y)
+fn main(mut x: u32, y: call_data u32, z: call_data [u32; 4]) -> return_data u32 {
+    let a = z[x];
+    a + foo(y)
 }
 
 // Use an unconstrained function to force the compiler to avoid inlining
 unconstrained fn foo(x: u32) -> u32 {
-  x+1
+    x + 1
 }
 
diff --git a/test_programs/execution_success/debug_logs/src/main.nr b/test_programs/execution_success/debug_logs/src/main.nr
index c628a9ae6a4..ec24b0cc8e8 100644
--- a/test_programs/execution_success/debug_logs/src/main.nr
+++ b/test_programs/execution_success/debug_logs/src/main.nr
@@ -1,4 +1,4 @@
-fn main(x: Field, y: pub Field) {    
+fn main(x: Field, y: pub Field) {
     let string = "i: {i}, j: {j}";
     println(string);
 
@@ -102,8 +102,8 @@ fn regression_2903() {
     let a = v[0];
     println(a); // will print `1`
 
-    let bytes = [ "aaa", "bbb", "ccc" ];
-    println(bytes);    
+    let bytes = ["aaa", "bbb", "ccc"];
+    println(bytes);
 }
 
 fn regression_2906() {
diff --git a/test_programs/execution_success/distinct_keyword/src/main.nr b/test_programs/execution_success/distinct_keyword/src/main.nr
index 0e55a011a48..8e9b5c008ed 100644
--- a/test_programs/execution_success/distinct_keyword/src/main.nr
+++ b/test_programs/execution_success/distinct_keyword/src/main.nr
@@ -1,4 +1,4 @@
 // Example that uses the distinct keyword
-fn main(x: pub Field) -> distinct pub [Field;2] {
+fn main(x: pub Field) -> distinct pub [Field; 2] {
     [x + 1, x]
 }
diff --git a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
index 2f410755f74..ac0359e4bb8 100644
--- a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
@@ -1,11 +1,11 @@
 use dep::std;
 
 fn main(
-    message: [u8;38],
-    hashed_message: [u8;32],
-    pub_key_x: [u8;32],
-    pub_key_y: [u8;32],
-    signature: [u8;64]
+    message: [u8; 38],
+    hashed_message: [u8; 32],
+    pub_key_x: [u8; 32],
+    pub_key_y: [u8; 32],
+    signature: [u8; 64]
 ) {
     // Hash the message, since secp256k1 expects a hashed_message
     let expected = std::hash::sha256(message);
diff --git a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
index d23573d13a6..c64e390d652 100644
--- a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
@@ -1,6 +1,6 @@
 use dep::std;
 
-fn main(hashed_message: [u8;32], pub_key_x: [u8;32], pub_key_y: [u8;32], signature: [u8;64]) {
+fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
 }
diff --git a/test_programs/execution_success/main_bool_arg/src/main.nr b/test_programs/execution_success/main_bool_arg/src/main.nr
index 111a23ec0c2..2c50d7dee16 100644
--- a/test_programs/execution_success/main_bool_arg/src/main.nr
+++ b/test_programs/execution_success/main_bool_arg/src/main.nr
@@ -1,4 +1,4 @@
-fn main(x: bool, y: [bool;2]) {
+fn main(x: bool, y: [bool; 2]) {
     if x {
         assert(1 != 2);
     }
diff --git a/test_programs/execution_success/operator_overloading/src/main.nr b/test_programs/execution_success/operator_overloading/src/main.nr
index 3867531abca..d61e1da170e 100644
--- a/test_programs/execution_success/operator_overloading/src/main.nr
+++ b/test_programs/execution_success/operator_overloading/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::ops::{ Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr };
+use dep::std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr};
 use dep::std::cmp::Ordering;
 
 // x = 3, y = 9
@@ -126,10 +126,6 @@ impl Ord for Wrapper {
     }
 }
 
-
-
-
-
 struct Pair {
     x: Wrapper,
     y: Wrapper,
diff --git a/test_programs/execution_success/regression_3394/src/main.nr b/test_programs/execution_success/regression_3394/src/main.nr
index cc45487b98b..94b6c818ff2 100644
--- a/test_programs/execution_success/regression_3394/src/main.nr
+++ b/test_programs/execution_success/regression_3394/src/main.nr
@@ -3,4 +3,4 @@ use dep::std;
 fn main() {
     let x : i8 = -128;
     std::println(x);
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/regression_3607/src/main.nr b/test_programs/execution_success/regression_3607/src/main.nr
index c09211c2810..9c7ef243f60 100644
--- a/test_programs/execution_success/regression_3607/src/main.nr
+++ b/test_programs/execution_success/regression_3607/src/main.nr
@@ -5,4 +5,4 @@ fn main(mut x: u32) {
         x = (x+1) / x;
     }
     assert(x != 0);
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/regression_3889/src/main.nr b/test_programs/execution_success/regression_3889/src/main.nr
index 10b8ecabee3..402a69a10da 100644
--- a/test_programs/execution_success/regression_3889/src/main.nr
+++ b/test_programs/execution_success/regression_3889/src/main.nr
@@ -17,7 +17,6 @@ mod Baz {
     use crate::Bar::NewType;
 }
 
-
 fn main(works: Baz::Works, fails: Baz::BarStruct, also_fails: Bar::NewType) -> pub Field {
     works.a + fails.a + also_fails.a
 }
diff --git a/test_programs/execution_success/side_effects_constrain_array/src/main.nr b/test_programs/execution_success/side_effects_constrain_array/src/main.nr
index fb3c346a460..c4a62603bc3 100644
--- a/test_programs/execution_success/side_effects_constrain_array/src/main.nr
+++ b/test_programs/execution_success/side_effects_constrain_array/src/main.nr
@@ -7,11 +7,11 @@ fn main(y: pub u32) {
 
     // The assert inside the if should be hit
     if y < 10 {
-        assert(bar.inner ==  [100, 101, 102]);
+        assert(bar.inner == [100, 101, 102]);
     }
 
     // The assert inside the if should not be hit
     if y > 10 {
         assert(bar.inner == [0, 1, 2]);
     }
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/struct/src/main.nr b/test_programs/execution_success/struct/src/main.nr
index 45c5e347e5a..de08f42f79d 100644
--- a/test_programs/execution_success/struct/src/main.nr
+++ b/test_programs/execution_success/struct/src/main.nr
@@ -9,8 +9,8 @@ struct Pair {
 }
 
 impl Foo {
-    fn default(x: Field,y: Field) -> Self {
-        Self { bar: 0, array: [x,y] }
+    fn default(x: Field, y: Field) -> Self {
+        Self { bar: 0, array: [x, y] }
     }
 }
 
diff --git a/test_programs/format.sh b/test_programs/format.sh
new file mode 100755
index 00000000000..3c679b8689e
--- /dev/null
+++ b/test_programs/format.sh
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -e
+
+# These tests are incompatible with gas reporting
+excluded_dirs=("workspace" "workspace_default_member" "workspace_reexport_bug")
+
+# These tests cause failures in CI with a stack overflow for some reason.
+ci_excluded_dirs=("eddsa")
+
+current_dir=$(pwd)
+
+# We generate a Noir workspace which contains all of the test cases
+# This allows us to generate a gates report using `nargo info` for all of them at once.
+
+
+function collect_dirs {
+  test_dirs=$(ls $current_dir/$1)
+
+  for dir in $test_dirs; do
+    if [[ " ${excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    if [[ ${CI-false} = "true" ]] && [[ " ${ci_excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    echo "  \"$1/$dir\"," >> Nargo.toml
+done
+}
+
+echo "[workspace]" > Nargo.toml
+echo "members = [" >> Nargo.toml
+
+collect_dirs compile_success_empty
+collect_dirs execution_success
+
+echo "]" >> Nargo.toml
+
+if [ "$1" == "check" ]; then
+  nargo fmt --check
+else
+  nargo fmt
+fi
+
+
+rm Nargo.toml

From 00ab3db86b06111d144516e862902b8604284611 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 26 Feb 2024 17:28:28 +0000
Subject: [PATCH 011/416] fix: remove panic when generic array length is not
 resolvable (#4408)

# Description

## Problem\*

Resolves #4407

## Summary\*

We currently have no way to gracefully error during monomorphization and
so must panic if we run into any errors.

This PR then adds the `MonomorphizationError` enum with an example error
type. We've also added a `CompileError` which unifies `RuntimeError` and
`MonomorphizationError` so they can be converted into `FileDiagnostic`s


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |   1 +
 compiler/noirc_driver/Cargo.toml              |   1 +
 compiler/noirc_driver/src/lib.rs              |  27 +-
 compiler/noirc_evaluator/src/errors.rs        |   2 +-
 .../src/monomorphization/debug.rs             |  38 ++-
 .../src/monomorphization/mod.rs               | 286 ++++++++++++------
 compiler/noirc_frontend/src/tests.rs          |   2 +-
 tooling/nargo/src/ops/test.rs                 |  10 +-
 8 files changed, 246 insertions(+), 121 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4d8b12d5379..0f575d9c46e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2947,6 +2947,7 @@ dependencies = [
  "noirc_macros",
  "rust-embed",
  "serde",
+ "thiserror",
  "tracing",
 ]
 
diff --git a/compiler/noirc_driver/Cargo.toml b/compiler/noirc_driver/Cargo.toml
index d9b240101d8..681976735f3 100644
--- a/compiler/noirc_driver/Cargo.toml
+++ b/compiler/noirc_driver/Cargo.toml
@@ -23,6 +23,7 @@ serde.workspace = true
 fxhash.workspace = true
 rust-embed.workspace = true
 tracing.workspace = true
+thiserror.workspace = true
 
 aztec_macros = { path = "../../aztec_macros" }
 noirc_macros = { path = "../../noirc_macros" }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 8b0fc5dc97a..11f53cdb749 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -16,9 +16,10 @@ use noirc_frontend::graph::{CrateId, CrateName};
 use noirc_frontend::hir::def_map::{Contract, CrateDefMap};
 use noirc_frontend::hir::Context;
 use noirc_frontend::macros_api::MacroProcessor;
-use noirc_frontend::monomorphization::{monomorphize, monomorphize_debug};
+use noirc_frontend::monomorphization::{monomorphize, monomorphize_debug, MonomorphizationError};
 use noirc_frontend::node_interner::FuncId;
 use std::path::Path;
+use thiserror::Error;
 use tracing::info;
 
 mod abi_gen;
@@ -107,6 +108,24 @@ fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error
     }
 }
 
+#[derive(Debug, Error)]
+pub enum CompileError {
+    #[error(transparent)]
+    MonomorphizationError(#[from] MonomorphizationError),
+
+    #[error(transparent)]
+    RuntimeError(#[from] RuntimeError),
+}
+
+impl From<CompileError> for FileDiagnostic {
+    fn from(error: CompileError) -> FileDiagnostic {
+        match error {
+            CompileError::RuntimeError(err) => err.into(),
+            CompileError::MonomorphizationError(err) => err.into(),
+        }
+    }
+}
+
 /// Helper type used to signify where only warnings are expected in file diagnostics
 pub type Warnings = Vec<FileDiagnostic>;
 
@@ -436,11 +455,11 @@ pub fn compile_no_check(
     main_function: FuncId,
     cached_program: Option<CompiledProgram>,
     force_compile: bool,
-) -> Result<CompiledProgram, RuntimeError> {
+) -> Result<CompiledProgram, CompileError> {
     let program = if options.instrument_debug {
-        monomorphize_debug(main_function, &mut context.def_interner, &context.debug_instrumenter)
+        monomorphize_debug(main_function, &mut context.def_interner, &context.debug_instrumenter)?
     } else {
-        monomorphize(main_function, &mut context.def_interner)
+        monomorphize(main_function, &mut context.def_interner)?
     };
 
     let hash = fxhash::hash64(&program);
diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index ed94adac28e..40f4336e0b5 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -158,7 +158,7 @@ impl RuntimeError {
             RuntimeError::InternalError(cause) => {
                 Diagnostic::simple_error(
                     "Internal Consistency Evaluators Errors: \n
-                    This is likely a bug. Consider Opening an issue at https://github.com/noir-lang/noir/issues".to_owned(),
+                    This is likely a bug. Consider opening an issue at https://github.com/noir-lang/noir/issues".to_owned(),
                     cause.to_string(),
                     noirc_errors::Span::inclusive(0, 0)
                 )
diff --git a/compiler/noirc_frontend/src/monomorphization/debug.rs b/compiler/noirc_frontend/src/monomorphization/debug.rs
index 5837d67660a..a8ff4399f99 100644
--- a/compiler/noirc_frontend/src/monomorphization/debug.rs
+++ b/compiler/noirc_frontend/src/monomorphization/debug.rs
@@ -8,7 +8,7 @@ use crate::hir_def::expr::*;
 use crate::node_interner::ExprId;
 
 use super::ast::{Expression, Ident};
-use super::Monomorphizer;
+use super::{MonomorphizationError, Monomorphizer};
 
 const DEBUG_MEMBER_ASSIGN_PREFIX: &str = "__debug_member_assign_";
 const DEBUG_VAR_ID_ARG_SLOT: usize = 0;
@@ -39,18 +39,19 @@ impl<'interner> Monomorphizer<'interner> {
         &mut self,
         call: &HirCallExpression,
         arguments: &mut [Expression],
-    ) {
-        let original_func = Box::new(self.expr(call.func));
+    ) -> Result<(), MonomorphizationError> {
+        let original_func = Box::new(self.expr(call.func)?);
         if let Expression::Ident(Ident { name, .. }) = original_func.as_ref() {
             if name == "__debug_var_assign" {
-                self.patch_debug_var_assign(call, arguments);
+                self.patch_debug_var_assign(call, arguments)?;
             } else if name == "__debug_var_drop" {
-                self.patch_debug_var_drop(call, arguments);
+                self.patch_debug_var_drop(call, arguments)?;
             } else if let Some(arity) = name.strip_prefix(DEBUG_MEMBER_ASSIGN_PREFIX) {
                 let arity = arity.parse::<usize>().expect("failed to parse member assign arity");
-                self.patch_debug_member_assign(call, arguments, arity);
+                self.patch_debug_member_assign(call, arguments, arity)?;
             }
         }
+        Ok(())
     }
 
     /// Update instrumentation code inserted on variable assignment. We need to
@@ -59,7 +60,11 @@ impl<'interner> Monomorphizer<'interner> {
     /// variable are possible if using generic functions, hence the temporary ID
     /// created when injecting the instrumentation code can map to multiple IDs
     /// at runtime.
-    fn patch_debug_var_assign(&mut self, call: &HirCallExpression, arguments: &mut [Expression]) {
+    fn patch_debug_var_assign(
+        &mut self,
+        call: &HirCallExpression,
+        arguments: &mut [Expression],
+    ) -> Result<(), MonomorphizationError> {
         let hir_arguments = vecmap(&call.arguments, |id| self.interner.expression(id));
         let var_id_arg = hir_arguments.get(DEBUG_VAR_ID_ARG_SLOT);
         let Some(HirExpression::Literal(HirLiteral::Integer(source_var_id, _))) = var_id_arg else {
@@ -73,13 +78,18 @@ impl<'interner> Monomorphizer<'interner> {
         // then update the ID used for tracking at runtime
         let var_id = self.debug_type_tracker.insert_var(source_var_id, var_type);
         let interned_var_id = self.intern_var_id(var_id, &call.location);
-        arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id);
+        arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id)?;
+        Ok(())
     }
 
     /// Update instrumentation code for a variable being dropped out of scope.
     /// Given the source_var_id we search for the last assigned debug var_id and
     /// replace it instead.
-    fn patch_debug_var_drop(&mut self, call: &HirCallExpression, arguments: &mut [Expression]) {
+    fn patch_debug_var_drop(
+        &mut self,
+        call: &HirCallExpression,
+        arguments: &mut [Expression],
+    ) -> Result<(), MonomorphizationError> {
         let hir_arguments = vecmap(&call.arguments, |id| self.interner.expression(id));
         let var_id_arg = hir_arguments.get(DEBUG_VAR_ID_ARG_SLOT);
         let Some(HirExpression::Literal(HirLiteral::Integer(source_var_id, _))) = var_id_arg else {
@@ -92,7 +102,8 @@ impl<'interner> Monomorphizer<'interner> {
             .get_var_id(source_var_id)
             .unwrap_or_else(|| unreachable!("failed to find debug variable"));
         let interned_var_id = self.intern_var_id(var_id, &call.location);
-        arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id);
+        arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id)?;
+        Ok(())
     }
 
     /// Update instrumentation code inserted when assigning to a member of an
@@ -106,7 +117,7 @@ impl<'interner> Monomorphizer<'interner> {
         call: &HirCallExpression,
         arguments: &mut [Expression],
         arity: usize,
-    ) {
+    ) -> Result<(), MonomorphizationError> {
         let hir_arguments = vecmap(&call.arguments, |id| self.interner.expression(id));
         let var_id_arg = hir_arguments.get(DEBUG_VAR_ID_ARG_SLOT);
         let Some(HirExpression::Literal(HirLiteral::Integer(source_var_id, _))) = var_id_arg else {
@@ -149,7 +160,7 @@ impl<'interner> Monomorphizer<'interner> {
                         call.location.span,
                         call.location.file,
                     );
-                    arguments[DEBUG_MEMBER_FIELD_INDEX_ARG_SLOT + i] = self.expr(index_id);
+                    arguments[DEBUG_MEMBER_FIELD_INDEX_ARG_SLOT + i] = self.expr(index_id)?;
                 } else {
                     // array/string element using constant index
                     cursor_type = element_type_at_index(cursor_type, index as usize);
@@ -165,7 +176,8 @@ impl<'interner> Monomorphizer<'interner> {
             .get_var_id(source_var_id)
             .unwrap_or_else(|| unreachable!("failed to find debug variable"));
         let interned_var_id = self.intern_var_id(var_id, &call.location);
-        arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id);
+        arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id)?;
+        Ok(())
     }
 
     fn intern_var_id(&mut self, var_id: DebugVarId, location: &Location) -> ExprId {
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 2e714da21c6..ce880401d77 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -9,13 +9,14 @@
 //! The entry point to this pass is the `monomorphize` function which, starting from a given
 //! function, will monomorphize the entire reachable program.
 use acvm::FieldElement;
-use iter_extended::{btree_map, vecmap};
-use noirc_errors::Location;
+use iter_extended::{btree_map, try_vecmap, vecmap};
+use noirc_errors::{CustomDiagnostic, FileDiagnostic, Location};
 use noirc_printable_type::PrintableType;
 use std::{
     collections::{BTreeMap, HashMap, VecDeque},
     unreachable,
 };
+use thiserror::Error;
 
 use crate::{
     debug::DebugInstrumenter,
@@ -87,6 +88,40 @@ struct Monomorphizer<'interner> {
 
 type HirType = crate::Type;
 
+#[derive(Debug, Error)]
+pub enum MonomorphizationError {
+    #[error("Length of generic array could not be determined.")]
+    UnknownArrayLength { location: Location },
+}
+
+impl MonomorphizationError {
+    fn call_stack(&self) -> Vec<Location> {
+        match self {
+            MonomorphizationError::UnknownArrayLength { location } => vec![*location],
+        }
+    }
+}
+
+impl From<MonomorphizationError> for FileDiagnostic {
+    fn from(error: MonomorphizationError) -> FileDiagnostic {
+        let call_stack = error.call_stack();
+        let file_id = call_stack.last().map(|location| location.file).unwrap_or_default();
+        let diagnostic = error.into_diagnostic();
+        diagnostic.in_file(file_id).with_call_stack(call_stack)
+    }
+}
+
+impl MonomorphizationError {
+    fn into_diagnostic(self) -> CustomDiagnostic {
+        CustomDiagnostic::simple_error(
+                "Internal Consistency Evaluators Errors: \n
+                This is likely a bug. Consider opening an issue at https://github.com/noir-lang/noir/issues".to_owned(),
+                self.to_string(),
+                noirc_errors::Span::inclusive(0, 0)
+            )
+    }
+}
+
 /// Starting from the given `main` function, monomorphize the entire program,
 /// replacing all references to type variables and NamedGenerics with concrete
 /// types, duplicating definitions as necessary to do so.
@@ -99,7 +134,10 @@ type HirType = crate::Type;
 /// this function. Typically, this is the function named "main" in the source project,
 /// but it can also be, for example, an arbitrary test function for running `nargo test`.
 #[tracing::instrument(level = "trace", skip(main, interner))]
-pub fn monomorphize(main: node_interner::FuncId, interner: &mut NodeInterner) -> Program {
+pub fn monomorphize(
+    main: node_interner::FuncId,
+    interner: &mut NodeInterner,
+) -> Result<Program, MonomorphizationError> {
     monomorphize_debug(main, interner, &DebugInstrumenter::default())
 }
 
@@ -107,10 +145,10 @@ pub fn monomorphize_debug(
     main: node_interner::FuncId,
     interner: &mut NodeInterner,
     debug_instrumenter: &DebugInstrumenter,
-) -> Program {
+) -> Result<Program, MonomorphizationError> {
     let debug_type_tracker = DebugTypeTracker::build_from_debug_instrumenter(debug_instrumenter);
     let mut monomorphizer = Monomorphizer::new(interner, debug_type_tracker);
-    let function_sig = monomorphizer.compile_main(main);
+    let function_sig = monomorphizer.compile_main(main)?;
 
     while !monomorphizer.queue.is_empty() {
         let (next_fn_id, new_id, bindings, trait_method) = monomorphizer.queue.pop_front().unwrap();
@@ -118,7 +156,7 @@ pub fn monomorphize_debug(
 
         perform_instantiation_bindings(&bindings);
         let impl_bindings = monomorphizer.perform_impl_bindings(trait_method, next_fn_id);
-        monomorphizer.function(next_fn_id, new_id);
+        monomorphizer.function(next_fn_id, new_id)?;
         undo_instantiation_bindings(impl_bindings);
         undo_instantiation_bindings(bindings);
     }
@@ -128,7 +166,7 @@ pub fn monomorphize_debug(
         monomorphizer.interner.function_meta(&main);
 
     let (debug_variables, debug_types) = monomorphizer.debug_type_tracker.extract_vars_and_types();
-    Program::new(
+    let program = Program::new(
         functions,
         function_sig,
         *return_distinctness,
@@ -137,7 +175,8 @@ pub fn monomorphize_debug(
         *kind == FunctionKind::Recursive,
         debug_variables,
         debug_types,
-    )
+    );
+    Ok(program)
 }
 
 impl<'interner> Monomorphizer<'interner> {
@@ -233,10 +272,13 @@ impl<'interner> Monomorphizer<'interner> {
         self.globals.entry(id).or_default().insert(typ, new_id);
     }
 
-    fn compile_main(&mut self, main_id: node_interner::FuncId) -> FunctionSignature {
+    fn compile_main(
+        &mut self,
+        main_id: node_interner::FuncId,
+    ) -> Result<FunctionSignature, MonomorphizationError> {
         let new_main_id = self.next_function_id();
         assert_eq!(new_main_id, Program::main_id());
-        self.function(main_id, new_main_id);
+        self.function(main_id, new_main_id)?;
         self.return_location =
             self.interner.function(&main_id).block(self.interner).statements().last().and_then(
                 |x| match self.interner.statement(x) {
@@ -245,10 +287,14 @@ impl<'interner> Monomorphizer<'interner> {
                 },
             );
         let main_meta = self.interner.function_meta(&main_id);
-        main_meta.function_signature()
+        Ok(main_meta.function_signature())
     }
 
-    fn function(&mut self, f: node_interner::FuncId, id: FuncId) {
+    fn function(
+        &mut self,
+        f: node_interner::FuncId,
+        id: FuncId,
+    ) -> Result<(), MonomorphizationError> {
         if let Some((self_type, trait_id)) = self.interner.get_function_trait(&f) {
             let the_trait = self.interner.get_trait(trait_id);
             the_trait.self_type_typevar.force_bind(self_type);
@@ -268,10 +314,11 @@ impl<'interner> Monomorphizer<'interner> {
             || matches!(modifiers.contract_function_type, Some(ContractFunctionType::Open));
 
         let parameters = self.parameters(&meta.parameters);
-        let body = self.expr(body_expr_id);
+        let body = self.expr(body_expr_id)?;
         let function = ast::Function { id, name, parameters, body, return_type, unconstrained };
 
         self.push_function(id, function);
+        Ok(())
     }
 
     fn push_function(&mut self, id: FuncId, function: ast::Function) {
@@ -331,15 +378,18 @@ impl<'interner> Monomorphizer<'interner> {
         }
     }
 
-    fn expr(&mut self, expr: node_interner::ExprId) -> ast::Expression {
+    fn expr(
+        &mut self,
+        expr: node_interner::ExprId,
+    ) -> Result<ast::Expression, MonomorphizationError> {
         use ast::Expression::Literal;
         use ast::Literal::*;
 
-        match self.interner.expression(&expr) {
-            HirExpression::Ident(ident) => self.ident(ident, expr),
+        let expr = match self.interner.expression(&expr) {
+            HirExpression::Ident(ident) => self.ident(ident, expr)?,
             HirExpression::Literal(HirLiteral::Str(contents)) => Literal(Str(contents)),
             HirExpression::Literal(HirLiteral::FmtStr(contents, idents)) => {
-                let fields = vecmap(idents, |ident| self.expr(ident));
+                let fields = try_vecmap(idents, |ident| self.expr(ident))?;
                 Literal(FmtStr(
                     contents,
                     fields.len() as u64,
@@ -367,27 +417,27 @@ impl<'interner> Monomorphizer<'interner> {
                 }
             }
             HirExpression::Literal(HirLiteral::Array(array)) => match array {
-                HirArrayLiteral::Standard(array) => self.standard_array(expr, array),
+                HirArrayLiteral::Standard(array) => self.standard_array(expr, array)?,
                 HirArrayLiteral::Repeated { repeated_element, length } => {
-                    self.repeated_array(expr, repeated_element, length)
+                    self.repeated_array(expr, repeated_element, length)?
                 }
             },
             HirExpression::Literal(HirLiteral::Unit) => ast::Expression::Block(vec![]),
-            HirExpression::Block(block) => self.block(block.0),
+            HirExpression::Block(block) => self.block(block.0)?,
 
             HirExpression::Prefix(prefix) => {
                 let location = self.interner.expr_location(&expr);
                 ast::Expression::Unary(ast::Unary {
                     operator: prefix.operator,
-                    rhs: Box::new(self.expr(prefix.rhs)),
+                    rhs: Box::new(self.expr(prefix.rhs)?),
                     result_type: self.convert_type(&self.interner.id_type(expr)),
                     location,
                 })
             }
 
             HirExpression::Infix(infix) => {
-                let lhs = self.expr(infix.lhs);
-                let rhs = self.expr(infix.rhs);
+                let lhs = self.expr(infix.lhs)?;
+                let rhs = self.expr(infix.rhs)?;
                 let operator = infix.operator.kind;
                 let location = self.interner.expr_location(&expr);
                 if self.interner.get_selected_impl_for_expression(expr).is_some() {
@@ -418,26 +468,27 @@ impl<'interner> Monomorphizer<'interner> {
                 }
             }
 
-            HirExpression::Index(index) => self.index(expr, index),
+            HirExpression::Index(index) => self.index(expr, index)?,
 
             HirExpression::MemberAccess(access) => {
                 let field_index = self.interner.get_field_index(expr);
-                let expr = Box::new(self.expr(access.lhs));
+                let expr = Box::new(self.expr(access.lhs)?);
                 ast::Expression::ExtractTupleField(expr, field_index)
             }
 
-            HirExpression::Call(call) => self.function_call(call, expr),
+            HirExpression::Call(call) => self.function_call(call, expr)?,
 
             HirExpression::Cast(cast) => ast::Expression::Cast(ast::Cast {
-                lhs: Box::new(self.expr(cast.lhs)),
+                lhs: Box::new(self.expr(cast.lhs)?),
                 r#type: self.convert_type(&cast.r#type),
                 location: self.interner.expr_location(&expr),
             }),
 
             HirExpression::If(if_expr) => {
-                let cond = self.expr(if_expr.condition);
-                let then = self.expr(if_expr.consequence);
-                let else_ = if_expr.alternative.map(|alt| Box::new(self.expr(alt)));
+                let cond = self.expr(if_expr.condition)?;
+                let then = self.expr(if_expr.consequence)?;
+                let else_ =
+                    if_expr.alternative.map(|alt| self.expr(alt)).transpose()?.map(Box::new);
                 ast::Expression::If(ast::If {
                     condition: Box::new(cond),
                     consequence: Box::new(then),
@@ -447,28 +498,30 @@ impl<'interner> Monomorphizer<'interner> {
             }
 
             HirExpression::Tuple(fields) => {
-                let fields = vecmap(fields, |id| self.expr(id));
+                let fields = try_vecmap(fields, |id| self.expr(id))?;
                 ast::Expression::Tuple(fields)
             }
-            HirExpression::Constructor(constructor) => self.constructor(constructor, expr),
+            HirExpression::Constructor(constructor) => self.constructor(constructor, expr)?,
 
-            HirExpression::Lambda(lambda) => self.lambda(lambda, expr),
+            HirExpression::Lambda(lambda) => self.lambda(lambda, expr)?,
 
             HirExpression::MethodCall(hir_method_call) => {
                 unreachable!("Encountered HirExpression::MethodCall during monomorphization {hir_method_call:?}")
             }
             HirExpression::Error => unreachable!("Encountered Error node during monomorphization"),
-        }
+        };
+
+        Ok(expr)
     }
 
     fn standard_array(
         &mut self,
         array: node_interner::ExprId,
         array_elements: Vec<node_interner::ExprId>,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.convert_type(&self.interner.id_type(array));
-        let contents = vecmap(array_elements, |id| self.expr(id));
-        ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ }))
+        let contents = try_vecmap(array_elements, |id| self.expr(id))?;
+        Ok(ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })))
     }
 
     fn repeated_array(
@@ -476,48 +529,56 @@ impl<'interner> Monomorphizer<'interner> {
         array: node_interner::ExprId,
         repeated_element: node_interner::ExprId,
         length: HirType,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.convert_type(&self.interner.id_type(array));
 
-        let length = length
-            .evaluate_to_u64()
-            .expect("Length of array is unknown when evaluating numeric generic");
+        let length = length.evaluate_to_u64().ok_or_else(|| {
+            let location = self.interner.expr_location(&array);
+            MonomorphizationError::UnknownArrayLength { location }
+        })?;
 
-        let contents = vecmap(0..length, |_| self.expr(repeated_element));
-        ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ }))
+        let contents = try_vecmap(0..length, |_| self.expr(repeated_element))?;
+        Ok(ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })))
     }
 
-    fn index(&mut self, id: node_interner::ExprId, index: HirIndexExpression) -> ast::Expression {
+    fn index(
+        &mut self,
+        id: node_interner::ExprId,
+        index: HirIndexExpression,
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let element_type = self.convert_type(&self.interner.id_type(id));
 
-        let collection = Box::new(self.expr(index.collection));
-        let index = Box::new(self.expr(index.index));
+        let collection = Box::new(self.expr(index.collection)?);
+        let index = Box::new(self.expr(index.index)?);
         let location = self.interner.expr_location(&id);
-        ast::Expression::Index(ast::Index { collection, index, element_type, location })
+        Ok(ast::Expression::Index(ast::Index { collection, index, element_type, location }))
     }
 
-    fn statement(&mut self, id: StmtId) -> ast::Expression {
+    fn statement(&mut self, id: StmtId) -> Result<ast::Expression, MonomorphizationError> {
         match self.interner.statement(&id) {
             HirStatement::Let(let_statement) => self.let_statement(let_statement),
             HirStatement::Constrain(constrain) => {
-                let expr = self.expr(constrain.0);
+                let expr = self.expr(constrain.0)?;
                 let location = self.interner.expr_location(&constrain.0);
-                let assert_message =
-                    constrain.2.map(|assert_msg_expr| Box::new(self.expr(assert_msg_expr)));
-                ast::Expression::Constrain(Box::new(expr), location, assert_message)
+                let assert_message = constrain
+                    .2
+                    .map(|assert_msg_expr| self.expr(assert_msg_expr))
+                    .transpose()?
+                    .map(Box::new);
+                Ok(ast::Expression::Constrain(Box::new(expr), location, assert_message))
             }
             HirStatement::Assign(assign) => self.assign(assign),
             HirStatement::For(for_loop) => {
                 self.is_range_loop = true;
-                let start = self.expr(for_loop.start_range);
-                let end = self.expr(for_loop.end_range);
+                let start = self.expr(for_loop.start_range)?;
+                let end = self.expr(for_loop.end_range)?;
                 self.is_range_loop = false;
                 let index_variable = self.next_local_id();
                 self.define_local(for_loop.identifier.id, index_variable);
 
-                let block = Box::new(self.expr(for_loop.block));
+                let block = Box::new(self.expr(for_loop.block)?);
 
-                ast::Expression::For(ast::For {
+                Ok(ast::Expression::For(ast::For {
                     index_variable,
                     index_name: self.interner.definition_name(for_loop.identifier.id).to_owned(),
                     index_type: self.convert_type(&self.interner.id_type(for_loop.start_range)),
@@ -526,25 +587,30 @@ impl<'interner> Monomorphizer<'interner> {
                     start_range_location: self.interner.expr_location(&for_loop.start_range),
                     end_range_location: self.interner.expr_location(&for_loop.end_range),
                     block,
-                })
+                }))
             }
             HirStatement::Expression(expr) => self.expr(expr),
-            HirStatement::Semi(expr) => ast::Expression::Semi(Box::new(self.expr(expr))),
+            HirStatement::Semi(expr) => {
+                self.expr(expr).map(|expr| ast::Expression::Semi(Box::new(expr)))
+            }
             HirStatement::Error => unreachable!(),
         }
     }
 
-    fn let_statement(&mut self, let_statement: HirLetStatement) -> ast::Expression {
-        let expr = self.expr(let_statement.expression);
+    fn let_statement(
+        &mut self,
+        let_statement: HirLetStatement,
+    ) -> Result<ast::Expression, MonomorphizationError> {
+        let expr = self.expr(let_statement.expression)?;
         let expected_type = self.interner.id_type(let_statement.expression);
-        self.unpack_pattern(let_statement.pattern, expr, &expected_type)
+        Ok(self.unpack_pattern(let_statement.pattern, expr, &expected_type))
     }
 
     fn constructor(
         &mut self,
         constructor: HirConstructorExpression,
         id: node_interner::ExprId,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.interner.id_type(id);
         let field_types = unwrap_struct_type(&typ);
 
@@ -561,7 +627,7 @@ impl<'interner> Monomorphizer<'interner> {
             let typ = self.convert_type(field_type);
 
             field_vars.insert(field_name.0.contents.clone(), (new_id, typ));
-            let expression = Box::new(self.expr(expr_id));
+            let expression = Box::new(self.expr(expr_id)?);
 
             new_exprs.push(ast::Expression::Let(ast::Let {
                 id: new_id,
@@ -586,11 +652,15 @@ impl<'interner> Monomorphizer<'interner> {
 
         // Finally we can return the created Tuple from the new block
         new_exprs.push(ast::Expression::Tuple(field_idents));
-        ast::Expression::Block(new_exprs)
+        Ok(ast::Expression::Block(new_exprs))
     }
 
-    fn block(&mut self, statement_ids: Vec<StmtId>) -> ast::Expression {
-        ast::Expression::Block(vecmap(statement_ids, |id| self.statement(id)))
+    fn block(
+        &mut self,
+        statement_ids: Vec<StmtId>,
+    ) -> Result<ast::Expression, MonomorphizationError> {
+        let stmts = try_vecmap(statement_ids, |id| self.statement(id));
+        stmts.map(ast::Expression::Block)
     }
 
     fn unpack_pattern(
@@ -701,15 +771,19 @@ impl<'interner> Monomorphizer<'interner> {
         Some(ast::Ident { location: Some(ident.location), mutable, definition, name, typ })
     }
 
-    fn ident(&mut self, ident: HirIdent, expr_id: node_interner::ExprId) -> ast::Expression {
+    fn ident(
+        &mut self,
+        ident: HirIdent,
+        expr_id: node_interner::ExprId,
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.interner.id_type(expr_id);
 
         if let ImplKind::TraitMethod(method, _, _) = ident.impl_kind {
-            return self.resolve_trait_method_reference(expr_id, typ, method);
+            return Ok(self.resolve_trait_method_reference(expr_id, typ, method));
         }
 
         let definition = self.interner.definition(ident.id);
-        match &definition.kind {
+        let ident = match &definition.kind {
             DefinitionKind::Function(func_id) => {
                 let mutable = definition.mutable;
                 let location = Some(ident.location);
@@ -736,7 +810,7 @@ impl<'interner> Monomorphizer<'interner> {
                         "Globals should have a corresponding let statement by monomorphization"
                     )
                 };
-                self.expr(let_.expression)
+                self.expr(let_.expression)?
             }
             DefinitionKind::Local(_) => self.lookup_captured_expr(ident.id).unwrap_or_else(|| {
                 let ident = self.local_ident(&ident).unwrap();
@@ -757,7 +831,9 @@ impl<'interner> Monomorphizer<'interner> {
                 let typ = self.convert_type(&typ);
                 ast::Expression::Literal(ast::Literal::Integer(value, typ, location))
             }
-        }
+        };
+
+        Ok(ident)
     }
 
     /// Convert a non-tuple/struct type to a monomorphized type
@@ -949,12 +1025,12 @@ impl<'interner> Monomorphizer<'interner> {
         &mut self,
         call: HirCallExpression,
         id: node_interner::ExprId,
-    ) -> ast::Expression {
-        let original_func = Box::new(self.expr(call.func));
-        let mut arguments = vecmap(&call.arguments, |id| self.expr(*id));
+    ) -> Result<ast::Expression, MonomorphizationError> {
+        let original_func = Box::new(self.expr(call.func)?);
+        let mut arguments = try_vecmap(&call.arguments, |id| self.expr(*id))?;
         let hir_arguments = vecmap(&call.arguments, |id| self.interner.expression(id));
 
-        self.patch_debug_instrumentation_call(&call, &mut arguments);
+        self.patch_debug_instrumentation_call(&call, &mut arguments)?;
 
         let return_type = self.interner.id_type(id);
         let return_type = self.convert_type(&return_type);
@@ -969,7 +1045,7 @@ impl<'interner> Monomorphizer<'interner> {
                     // The second argument is expected to always be an ident
                     self.append_printable_type_info(&hir_arguments[1], &mut arguments);
                 } else if name.as_str() == "assert_message" {
-                    // The first argument to the `assert_message` oracle is the expression passed as a mesage to an `assert` or `assert_eq` statement
+                    // The first argument to the `assert_message` oracle is the expression passed as a message to an `assert` or `assert_eq` statement
                     self.append_printable_type_info(&hir_arguments[0], &mut arguments);
                 }
             }
@@ -1017,9 +1093,9 @@ impl<'interner> Monomorphizer<'interner> {
 
         if !block_expressions.is_empty() {
             block_expressions.push(call);
-            ast::Expression::Block(block_expressions)
+            Ok(ast::Expression::Block(block_expressions))
         } else {
-            call
+            Ok(call)
         }
     }
 
@@ -1190,47 +1266,59 @@ impl<'interner> Monomorphizer<'interner> {
             .collect()
     }
 
-    fn assign(&mut self, assign: HirAssignStatement) -> ast::Expression {
-        let expression = Box::new(self.expr(assign.expression));
-        let lvalue = self.lvalue(assign.lvalue);
-        ast::Expression::Assign(ast::Assign { expression, lvalue })
+    fn assign(
+        &mut self,
+        assign: HirAssignStatement,
+    ) -> Result<ast::Expression, MonomorphizationError> {
+        let expression = Box::new(self.expr(assign.expression)?);
+        let lvalue = self.lvalue(assign.lvalue)?;
+        Ok(ast::Expression::Assign(ast::Assign { expression, lvalue }))
     }
 
-    fn lvalue(&mut self, lvalue: HirLValue) -> ast::LValue {
-        match lvalue {
+    fn lvalue(&mut self, lvalue: HirLValue) -> Result<ast::LValue, MonomorphizationError> {
+        let value = match lvalue {
             HirLValue::Ident(ident, _) => self
                 .lookup_captured_lvalue(ident.id)
                 .unwrap_or_else(|| ast::LValue::Ident(self.local_ident(&ident).unwrap())),
             HirLValue::MemberAccess { object, field_index, .. } => {
                 let field_index = field_index.unwrap();
-                let object = Box::new(self.lvalue(*object));
+                let object = Box::new(self.lvalue(*object)?);
                 ast::LValue::MemberAccess { object, field_index }
             }
             HirLValue::Index { array, index, typ } => {
                 let location = self.interner.expr_location(&index);
-                let array = Box::new(self.lvalue(*array));
-                let index = Box::new(self.expr(index));
+                let array = Box::new(self.lvalue(*array)?);
+                let index = Box::new(self.expr(index)?);
                 let element_type = self.convert_type(&typ);
                 ast::LValue::Index { array, index, element_type, location }
             }
             HirLValue::Dereference { lvalue, element_type } => {
-                let reference = Box::new(self.lvalue(*lvalue));
+                let reference = Box::new(self.lvalue(*lvalue)?);
                 let element_type = self.convert_type(&element_type);
                 ast::LValue::Dereference { reference, element_type }
             }
-        }
+        };
+
+        Ok(value)
     }
 
-    fn lambda(&mut self, lambda: HirLambda, expr: node_interner::ExprId) -> ast::Expression {
+    fn lambda(
+        &mut self,
+        lambda: HirLambda,
+        expr: node_interner::ExprId,
+    ) -> Result<ast::Expression, MonomorphizationError> {
         if lambda.captures.is_empty() {
             self.lambda_no_capture(lambda)
         } else {
-            let (setup, closure_variable) = self.lambda_with_setup(lambda, expr);
-            ast::Expression::Block(vec![setup, closure_variable])
+            let (setup, closure_variable) = self.lambda_with_setup(lambda, expr)?;
+            Ok(ast::Expression::Block(vec![setup, closure_variable]))
         }
     }
 
-    fn lambda_no_capture(&mut self, lambda: HirLambda) -> ast::Expression {
+    fn lambda_no_capture(
+        &mut self,
+        lambda: HirLambda,
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let ret_type = self.convert_type(&lambda.return_type);
         let lambda_name = "lambda";
         let parameter_types = vecmap(&lambda.parameters, |(_, typ)| self.convert_type(typ));
@@ -1240,7 +1328,7 @@ impl<'interner> Monomorphizer<'interner> {
             vecmap(lambda.parameters, |(pattern, typ)| (pattern, typ, Visibility::Private)).into();
 
         let parameters = self.parameters(&parameters);
-        let body = self.expr(lambda.body);
+        let body = self.expr(lambda.body)?;
 
         let id = self.next_function_id();
         let return_type = ret_type.clone();
@@ -1254,20 +1342,20 @@ impl<'interner> Monomorphizer<'interner> {
             ast::Type::Function(parameter_types, Box::new(ret_type), Box::new(ast::Type::Unit));
 
         let name = lambda_name.to_owned();
-        ast::Expression::Ident(ast::Ident {
+        Ok(ast::Expression::Ident(ast::Ident {
             definition: Definition::Function(id),
             mutable: false,
             location: None,
             name,
             typ,
-        })
+        }))
     }
 
     fn lambda_with_setup(
         &mut self,
         lambda: HirLambda,
         expr: node_interner::ExprId,
-    ) -> (ast::Expression, ast::Expression) {
+    ) -> Result<(ast::Expression, ast::Expression), MonomorphizationError> {
         // returns (<closure setup>, <closure variable>)
         //   which can be used directly in callsites or transformed
         //   directly to a single `Expression`
@@ -1343,7 +1431,7 @@ impl<'interner> Monomorphizer<'interner> {
 
         self.lambda_envs_stack
             .push(LambdaContext { env_ident: env_ident.clone(), captures: lambda.captures });
-        let body = self.expr(lambda.body);
+        let body = self.expr(lambda.body)?;
         self.lambda_envs_stack.pop();
 
         let lambda_fn_typ: ast::Type =
@@ -1385,7 +1473,7 @@ impl<'interner> Monomorphizer<'interner> {
             typ: ast::Type::Tuple(vec![env_typ, lambda_fn_typ]),
         });
 
-        (block_let_stmt, closure_ident)
+        Ok((block_let_stmt, closure_ident))
     }
 
     /// Implements std::unsafe::zeroed by returning an appropriate zeroed
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index c18379f1c26..c661cc92eef 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1130,7 +1130,7 @@ mod test {
     fn check_rewrite(src: &str, expected: &str) {
         let (_program, mut context, _errors) = get_program(src);
         let main_func_id = context.def_interner.find_function("main").unwrap();
-        let program = monomorphize(main_func_id, &mut context.def_interner);
+        let program = monomorphize(main_func_id, &mut context.def_interner).unwrap();
         assert!(format!("{}", program) == expected);
     }
 
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 0929739a6ab..92c09ec889e 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -1,5 +1,5 @@
 use acvm::{acir::native_types::WitnessMap, BlackBoxFunctionSolver};
-use noirc_driver::{compile_no_check, CompileOptions};
+use noirc_driver::{compile_no_check, CompileError, CompileOptions};
 use noirc_errors::{debug_info::DebugInfo, FileDiagnostic};
 use noirc_evaluator::errors::RuntimeError;
 use noirc_frontend::hir::{def_map::TestFunction, Context};
@@ -45,14 +45,18 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
 /// that a constraint was never satisfiable.
 /// An example of this is the program `assert(false)`
 /// In that case, we check if the test function should fail, and if so, we return `TestStatus::Pass`.
-fn test_status_program_compile_fail(err: RuntimeError, test_function: TestFunction) -> TestStatus {
+fn test_status_program_compile_fail(err: CompileError, test_function: TestFunction) -> TestStatus {
     // The test has failed compilation, but it should never fail. Report error.
     if !test_function.should_fail() {
         return TestStatus::CompileError(err.into());
     }
 
     // The test has failed compilation, extract the assertion message if present and check if it's expected.
-    let assert_message = if let RuntimeError::FailedConstraint { assert_message, .. } = &err {
+    let assert_message = if let CompileError::RuntimeError(RuntimeError::FailedConstraint {
+        assert_message,
+        ..
+    }) = &err
+    {
         assert_message.clone()
     } else {
         None

From 10e82920798380f50046e52db4a20ca205191ab7 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 26 Feb 2024 18:36:25 +0100
Subject: [PATCH 012/416] feat: add poseidon2 opcode implementation for
 acvm/brillig, and Noir (#4398)

and poseidon2 noir implementation

# Description

## Problem\*

Resolves #4170

## Summary\*

The PR implements Poseidon2 permutation for ACMV and Brillig, enabling
the use of the opcode.
Then it also includes a Noir implementation of Poseidon2 using the
opcode in the stdlib

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
---
 Cargo.lock                                    |    1 +
 acvm-repo/acvm/src/pwg/blackbox/hash.rs       |   36 +-
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |    8 +-
 .../src/curve_specific_solver.rs              |   12 +
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |    1 +
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |   11 +
 .../bn254_blackbox_solver/src/poseidon2.rs    | 1043 +++++++++++++++++
 acvm-repo/brillig_vm/src/black_box.rs         |   13 +-
 acvm-repo/brillig_vm/src/lib.rs               |    7 +
 .../noirc_evaluator/src/brillig/brillig_ir.rs |    8 +
 .../cryptographic_primitives/hashes.mdx       |   13 +
 noir_stdlib/src/hash.nr                       |    3 +-
 noir_stdlib/src/hash/poseidon2.nr             |  119 ++
 .../poseidon_bn254_hash/Prover.toml           |    5 +
 .../poseidon_bn254_hash/src/main.nr           |    6 +-
 tooling/lsp/src/solver.rs                     |    8 +
 16 files changed, 1288 insertions(+), 6 deletions(-)
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
 create mode 100644 noir_stdlib/src/hash/poseidon2.nr

diff --git a/Cargo.lock b/Cargo.lock
index 0f575d9c46e..714b700119a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -589,6 +589,7 @@ dependencies = [
  "js-sys",
  "noir_grumpkin",
  "num-bigint",
+ "num-traits",
  "pkg-config",
  "reqwest",
  "rust-embed",
diff --git a/acvm-repo/acvm/src/pwg/blackbox/hash.rs b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
index 06489822c92..1bc26f06188 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/hash.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
@@ -3,7 +3,7 @@ use acir::{
     native_types::{Witness, WitnessMap},
     BlackBoxFunc, FieldElement,
 };
-use acvm_blackbox_solver::{sha256compression, BlackBoxResolutionError};
+use acvm_blackbox_solver::{sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 use crate::pwg::{insert_value, witness_to_value};
 use crate::OpcodeResolutionError;
@@ -131,3 +131,37 @@ pub(crate) fn solve_sha_256_permutation_opcode(
 
     Ok(())
 }
+
+pub(crate) fn solve_poseidon2_permutation_opcode(
+    backend: &impl BlackBoxFunctionSolver,
+    initial_witness: &mut WitnessMap,
+    inputs: &[FunctionInput],
+    outputs: &[Witness],
+    len: u32,
+) -> Result<(), OpcodeResolutionError> {
+    if len as usize != inputs.len() {
+        return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
+            acir::BlackBoxFunc::Poseidon2Permutation,
+            format!(
+                "the number of inputs does not match specified length. {} > {}",
+                inputs.len(),
+                len
+            ),
+        ));
+    }
+
+    // Read witness assignments
+    let mut state = Vec::new();
+    for input in inputs.iter() {
+        let witness_assignment = witness_to_value(initial_witness, input.witness)?;
+        state.push(*witness_assignment);
+    }
+
+    let state = backend.poseidon2_permutation(&state, len)?;
+
+    // Write witness assignments
+    for (output_witness, value) in outputs.iter().zip(state.into_iter()) {
+        insert_value(output_witness, value, initial_witness)?;
+    }
+    Ok(())
+}
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 7ae92fd84fc..4309cad1b2e 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -5,7 +5,9 @@ use acir::{
 };
 use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256};
 
-use self::{bigint::BigIntSolver, pedersen::pedersen_hash};
+use self::{
+    bigint::BigIntSolver, hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash,
+};
 
 use super::{insert_value, OpcodeNotSolvable, OpcodeResolutionError};
 use crate::{pwg::witness_to_value, BlackBoxFunctionSolver};
@@ -204,7 +206,6 @@ pub(crate) fn solve(
         BlackBoxFuncCall::BigIntToLeBytes { input, outputs } => {
             bigint_solver.bigint_to_bytes(*input, outputs, initial_witness)
         }
-        BlackBoxFuncCall::Poseidon2Permutation { .. } => todo!(),
         BlackBoxFuncCall::Sha256Compression { inputs, hash_values, outputs } => {
             solve_sha_256_permutation_opcode(
                 initial_witness,
@@ -214,5 +215,8 @@ pub(crate) fn solve(
                 bb_func.get_black_box_func(),
             )
         }
+        BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len } => {
+            solve_poseidon2_permutation_opcode(backend, initial_witness, inputs, outputs, *len)
+        }
     }
 }
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index 2234710dec0..f0ab4561229 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -36,6 +36,11 @@ pub trait BlackBoxFunctionSolver {
         input2_x: &FieldElement,
         input2_y: &FieldElement,
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
+    fn poseidon2_permutation(
+        &self,
+        _inputs: &[FieldElement],
+        _len: u32,
+    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError>;
 }
 
 pub struct StubbedBlackBoxSolver;
@@ -89,4 +94,11 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::EmbeddedCurveAdd))
     }
+    fn poseidon2_permutation(
+        &self,
+        _inputs: &[FieldElement],
+        _len: u32,
+    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+        Err(Self::fail(BlackBoxFunc::Poseidon2Permutation))
+    }
 }
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index ef80e2c1c0f..ea601a6b80f 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -16,6 +16,7 @@ repository.workspace = true
 acir.workspace = true
 acvm_blackbox_solver.workspace = true
 thiserror.workspace = true
+num-traits.workspace = true
 
 rust-embed = { version = "6.6.0", features = [
     "debug-embed",
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 13aa956f9e1..be0e60ada96 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -6,9 +6,11 @@ use acir::{BlackBoxFunc, FieldElement};
 use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 mod fixed_base_scalar_mul;
+mod poseidon2;
 mod wasm;
 
 pub use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
+use poseidon2::Poseidon2;
 use wasm::Barretenberg;
 
 use self::wasm::{Pedersen, SchnorrSig};
@@ -97,4 +99,13 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
         embedded_curve_add(*input1_x, *input1_y, *input2_x, *input2_y)
     }
+
+    fn poseidon2_permutation(
+        &self,
+        inputs: &[FieldElement],
+        len: u32,
+    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+        let poseidon = Poseidon2::new();
+        poseidon.permutation(inputs, len)
+    }
 }
diff --git a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
new file mode 100644
index 00000000000..e0ed5bcd053
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
@@ -0,0 +1,1043 @@
+use acir::FieldElement;
+use acvm_blackbox_solver::BlackBoxResolutionError;
+use num_bigint::BigUint;
+use num_traits::Num;
+
+pub(crate) struct Poseidon2 {
+    t: u32,
+    rounds_f: u32,
+    rounds_p: u32,
+    internal_matrix_diagonal: [FieldElement; 4],
+    round_constant: [[FieldElement; 4]; 64],
+}
+
+impl Poseidon2 {
+    pub(crate) fn new() -> Self {
+        Poseidon2 {
+            t: 4,
+            rounds_f: 8,
+            rounds_p: 56,
+            internal_matrix_diagonal: [
+                Poseidon2::field_from_hex(
+                    "0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7",
+                ),
+                Poseidon2::field_from_hex(
+                    "0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b",
+                ),
+                Poseidon2::field_from_hex(
+                    "0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15",
+                ),
+                Poseidon2::field_from_hex(
+                    "0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b",
+                ),
+            ],
+            round_constant: [
+                [
+                    Poseidon2::field_from_hex(
+                        "0x19b849f69450b06848da1d39bd5e4a4302bb86744edc26238b0878e269ed23e5",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x265ddfe127dd51bd7239347b758f0a1320eb2cc7450acc1dad47f80c8dcf34d6",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x199750ec472f1809e0f66a545e1e51624108ac845015c2aa3dfc36bab497d8aa",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x157ff3fe65ac7208110f06a5f74302b14d743ea25067f0ffd032f787c7f1cdf8",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2e49c43c4569dd9c5fd35ac45fca33f10b15c590692f8beefe18f4896ac94902",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0e35fb89981890520d4aef2b6d6506c3cb2f0b6973c24fa82731345ffa2d1f1e",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x251ad47cb15c4f1105f109ae5e944f1ba9d9e7806d667ffec6fe723002e0b996",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x13da07dc64d428369873e97160234641f8beb56fdd05e5f3563fa39d9c22df4e",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0c009b84e650e6d23dc00c7dccef7483a553939689d350cd46e7b89055fd4738",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x011f16b1c63a854f01992e3956f42d8b04eb650c6d535eb0203dec74befdca06",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0ed69e5e383a688f209d9a561daa79612f3f78d0467ad45485df07093f367549",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x04dba94a7b0ce9e221acad41472b6bbe3aec507f5eb3d33f463672264c9f789b",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0a3f2637d840f3a16eb094271c9d237b6036757d4bb50bf7ce732ff1d4fa28e8",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x259a666f129eea198f8a1c502fdb38fa39b1f075569564b6e54a485d1182323f",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x28bf7459c9b2f4c6d8e7d06a4ee3a47f7745d4271038e5157a32fdf7ede0d6a1",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0a1ca941f057037526ea200f489be8d4c37c85bbcce6a2aeec91bd6941432447",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0c6f8f958be0e93053d7fd4fc54512855535ed1539f051dcb43a26fd926361cf",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x123106a93cd17578d426e8128ac9d90aa9e8a00708e296e084dd57e69caaf811",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x26e1ba52ad9285d97dd3ab52f8e840085e8fa83ff1e8f1877b074867cd2dee75",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1cb55cad7bd133de18a64c5c47b9c97cbe4d8b7bf9e095864471537e6a4ae2c5",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1dcd73e46acd8f8e0e2c7ce04bde7f6d2a53043d5060a41c7143f08e6e9055d0",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x011003e32f6d9c66f5852f05474a4def0cda294a0eb4e9b9b12b9bb4512e5574",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2b1e809ac1d10ab29ad5f20d03a57dfebadfe5903f58bafed7c508dd2287ae8c",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2539de1785b735999fb4dac35ee17ed0ef995d05ab2fc5faeaa69ae87bcec0a5",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0c246c5a2ef8ee0126497f222b3e0a0ef4e1c3d41c86d46e43982cb11d77951d",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x192089c4974f68e95408148f7c0632edbb09e6a6ad1a1c2f3f0305f5d03b527b",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1eae0ad8ab68b2f06a0ee36eeb0d0c058529097d91096b756d8fdc2fb5a60d85",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x179190e5d0e22179e46f8282872abc88db6e2fdc0dee99e69768bd98c5d06bfb",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x29bb9e2c9076732576e9a81c7ac4b83214528f7db00f31bf6cafe794a9b3cd1c",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x225d394e42207599403efd0c2464a90d52652645882aac35b10e590e6e691e08",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x064760623c25c8cf753d238055b444532be13557451c087de09efd454b23fd59",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x10ba3a0e01df92e87f301c4b716d8a394d67f4bf42a75c10922910a78f6b5b87",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0e070bf53f8451b24f9c6e96b0c2a801cb511bc0c242eb9d361b77693f21471c",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1b94cd61b051b04dd39755ff93821a73ccd6cb11d2491d8aa7f921014de252fb",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1d7cb39bafb8c744e148787a2e70230f9d4e917d5713bb050487b5aa7d74070b",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2ec93189bd1ab4f69117d0fe980c80ff8785c2961829f701bb74ac1f303b17db",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2db366bfdd36d277a692bb825b86275beac404a19ae07a9082ea46bd83517926",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x062100eb485db06269655cf186a68532985275428450359adc99cec6960711b8",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0761d33c66614aaa570e7f1e8244ca1120243f92fa59e4f900c567bf41f5a59b",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x20fc411a114d13992c2705aa034e3f315d78608a0f7de4ccf7a72e494855ad0d",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x25b5c004a4bdfcb5add9ec4e9ab219ba102c67e8b3effb5fc3a30f317250bc5a",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x23b1822d278ed632a494e58f6df6f5ed038b186d8474155ad87e7dff62b37f4b",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x22734b4c5c3f9493606c4ba9012499bf0f14d13bfcfcccaa16102a29cc2f69e0",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x26c0c8fe09eb30b7e27a74dc33492347e5bdff409aa3610254413d3fad795ce5",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x070dd0ccb6bd7bbae88eac03fa1fbb26196be3083a809829bbd626df348ccad9",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x12b6595bdb329b6fb043ba78bb28c3bec2c0a6de46d8c5ad6067c4ebfd4250da",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x248d97d7f76283d63bec30e7a5876c11c06fca9b275c671c5e33d95bb7e8d729",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1a306d439d463b0816fc6fd64cc939318b45eb759ddde4aa106d15d9bd9baaaa",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x28a8f8372e3c38daced7c00421cb4621f4f1b54ddc27821b0d62d3d6ec7c56cf",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0094975717f9a8a8bb35152f24d43294071ce320c829f388bc852183e1e2ce7e",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x04d5ee4c3aa78f7d80fde60d716480d3593f74d4f653ae83f4103246db2e8d65",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2a6cf5e9aa03d4336349ad6fb8ed2269c7bef54b8822cc76d08495c12efde187",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2304d31eaab960ba9274da43e19ddeb7f792180808fd6e43baae48d7efcba3f3",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x03fd9ac865a4b2a6d5e7009785817249bff08a7e0726fcb4e1c11d39d199f0b0",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x00b7258ded52bbda2248404d55ee5044798afc3a209193073f7954d4d63b0b64",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x159f81ada0771799ec38fca2d4bf65ebb13d3a74f3298db36272c5ca65e92d9a",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1ef90e67437fbc8550237a75bc28e3bb9000130ea25f0c5471e144cf4264431f",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1e65f838515e5ff0196b49aa41a2d2568df739bc176b08ec95a79ed82932e30d",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2b1b045def3a166cec6ce768d079ba74b18c844e570e1f826575c1068c94c33f",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0832e5753ceb0ff6402543b1109229c165dc2d73bef715e3f1c6e07c168bb173",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x02f614e9cedfb3dc6b762ae0a37d41bab1b841c2e8b6451bc5a8e3c390b6ad16",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0e2427d38bd46a60dd640b8e362cad967370ebb777bedff40f6a0be27e7ed705",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0493630b7c670b6deb7c84d414e7ce79049f0ec098c3c7c50768bbe29214a53a",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x22ead100e8e482674decdab17066c5a26bb1515355d5461a3dc06cc85327cea9",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x25b3e56e655b42cdaae2626ed2554d48583f1ae35626d04de5084e0b6d2a6f16",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1e32752ada8836ef5837a6cde8ff13dbb599c336349e4c584b4fdc0a0cf6f9d0",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2fa2a871c15a387cc50f68f6f3c3455b23c00995f05078f672a9864074d412e5",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x2f569b8a9a4424c9278e1db7311e889f54ccbf10661bab7fcd18e7c7a7d83505",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x044cb455110a8fdd531ade530234c518a7df93f7332ffd2144165374b246b43d",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x227808de93906d5d420246157f2e42b191fe8c90adfe118178ddc723a5319025",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x02fcca2934e046bc623adead873579865d03781ae090ad4a8579d2e7a6800355",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0ef915f0ac120b876abccceb344a1d36bad3f3c5ab91a8ddcbec2e060d8befac",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x1797130f4b7a3e1777eb757bc6f287f6ab0fb85f6be63b09f3b16ef2b1405d38",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0a76225dc04170ae3306c85abab59e608c7f497c20156d4d36c668555decc6e5",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x1fffb9ec1992d66ba1e77a7b93209af6f8fa76d48acb664796174b5326a31a5c",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x25721c4fc15a3f2853b57c338fa538d85f8fbba6c6b9c6090611889b797b9c5f",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0c817fd42d5f7a41215e3d07ba197216adb4c3790705da95eb63b982bfcaf75a",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x13abe3f5239915d39f7e13c2c24970b6df8cf86ce00a22002bc15866e52b5a96",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x2106feea546224ea12ef7f39987a46c85c1bc3dc29bdbd7a92cd60acb4d391ce",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x21ca859468a746b6aaa79474a37dab49f1ca5a28c748bc7157e1b3345bb0f959",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x05ccd6255c1e6f0c5cf1f0df934194c62911d14d0321662a8f1a48999e34185b",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0f0e34a64b70a626e464d846674c4c8816c4fb267fe44fe6ea28678cb09490a4",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x0558531a4e25470c6157794ca36d0e9647dbfcfe350d64838f5b1a8a2de0d4bf",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x09d3dca9173ed2faceea125157683d18924cadad3f655a60b72f5864961f1455",
+                    ),
+                ],
+                [
+                    Poseidon2::field_from_hex(
+                        "0x0328cbd54e8c0913493f866ed03d218bf23f92d68aaec48617d4c722e5bd4335",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x2bf07216e2aff0a223a487b1a7094e07e79e7bcc9798c648ee3347dd5329d34b",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x1daf345a58006b736499c583cb76c316d6f78ed6a6dffc82111e11a63fe412df",
+                    ),
+                    Poseidon2::field_from_hex(
+                        "0x176563472456aaa746b694c60e1823611ef39039b2edc7ff391e6f2293d2c404",
+                    ),
+                ],
+            ],
+        }
+    }
+    fn field_from_hex(hex: &str) -> FieldElement {
+        let bigint = BigUint::from_str_radix(hex.strip_prefix("0x").unwrap(), 16).unwrap();
+        FieldElement::from_be_bytes_reduce(&bigint.to_bytes_be())
+    }
+
+    fn single_box(x: FieldElement) -> FieldElement {
+        let s = x * x;
+        s * s * x
+    }
+
+    fn s_box(input: &mut [FieldElement]) {
+        for i in input {
+            *i = Self::single_box(*i);
+        }
+    }
+
+    fn add_round_constants(&self, state: &mut [FieldElement], round: usize) {
+        for (state_element, constant_element) in state.iter_mut().zip(self.round_constant[round]) {
+            *state_element += constant_element;
+        }
+    }
+
+    /// Algorithm is taken directly from the Poseidon2 implementation in Barretenberg crypto module.
+    fn matrix_multiplication_4x4(input: &mut [FieldElement]) {
+        assert!(input.len() == 4);
+        let t0 = input[0] + input[1]; // A + B
+        let t1 = input[2] + input[3]; // C + D
+        let mut t2 = input[1] + input[1]; // 2B
+        t2 += t1; // 2B + C + D
+        let mut t3 = input[3] + input[3]; // 2D
+        t3 += t0; // 2D + A + B
+        let mut t4 = t1 + t1;
+        t4 += t4;
+        t4 += t3; // A + B + 4C + 6D
+        let mut t5 = t0 + t0;
+        t5 += t5;
+        t5 += t2; // 4A + 6B + C + D
+        let t6 = t3 + t5; // 5A + 7B + C + 3D
+        let t7 = t2 + t4; // A + 3B + 5C + 7D
+        input[0] = t6;
+        input[1] = t5;
+        input[2] = t7;
+        input[3] = t4;
+    }
+
+    fn internal_m_multiplication(&self, input: &mut [FieldElement]) {
+        let mut sum = FieldElement::zero();
+        for i in input.iter() {
+            sum += *i;
+        }
+        for (index, i) in input.iter_mut().enumerate() {
+            *i = *i * self.internal_matrix_diagonal[index];
+            *i += sum;
+        }
+    }
+
+    pub(crate) fn permutation(
+        &self,
+        inputs: &[FieldElement],
+        len: u32,
+    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+        if len as usize != inputs.len() {
+            return Err(BlackBoxResolutionError::Failed(
+                acir::BlackBoxFunc::Poseidon2Permutation,
+                format!(
+                    "the number of inputs does not match specified length. {} > {}",
+                    inputs.len(),
+                    len
+                ),
+            ));
+        }
+        if len != self.t {
+            return Err(BlackBoxResolutionError::Failed(
+                acir::BlackBoxFunc::Poseidon2Permutation,
+                format!("Expected {} values but encountered {}", self.t, len),
+            ));
+        }
+        // Read witness assignments
+        let mut state = [FieldElement::zero(); 4];
+        for (index, input) in inputs.iter().enumerate() {
+            state[index] = *input;
+        }
+        // Apply 1st linear layer
+        Self::matrix_multiplication_4x4(&mut state);
+
+        // First set of external rounds
+        let rf_first = self.rounds_f / 2;
+        for r in 0..rf_first {
+            self.add_round_constants(&mut state, r as usize);
+            Self::s_box(&mut state);
+            Self::matrix_multiplication_4x4(&mut state);
+        }
+        // Internal rounds
+        let p_end = rf_first + self.rounds_p;
+        for r in rf_first..p_end {
+            state[0] += self.round_constant[r as usize][0];
+            state[0] = Self::single_box(state[0]);
+            self.internal_m_multiplication(&mut state);
+        }
+
+        // Remaining external rounds
+        let num_rounds = self.rounds_f + self.rounds_p;
+        for i in p_end..num_rounds {
+            self.add_round_constants(&mut state, i as usize);
+            Self::s_box(&mut state);
+            Self::matrix_multiplication_4x4(&mut state);
+        }
+        Ok(state.into())
+    }
+}
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 5b2680465ab..73b57b907f3 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -184,7 +184,18 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         BlackBoxOp::BigIntDiv { .. } => todo!(),
         BlackBoxOp::BigIntFromLeBytes { .. } => todo!(),
         BlackBoxOp::BigIntToLeBytes { .. } => todo!(),
-        BlackBoxOp::Poseidon2Permutation { .. } => todo!(),
+        BlackBoxOp::Poseidon2Permutation { message, output, len } => {
+            let input = read_heap_vector(memory, message);
+            let input: Vec<FieldElement> = input.iter().map(|x| x.to_field()).collect();
+            let len = memory.read(*len).to_u128() as u32;
+            let result = solver.poseidon2_permutation(&input, len)?;
+            let mut values = Vec::new();
+            for i in result {
+                values.push(Value::from(i));
+            }
+            memory.write_slice(memory.read_ref(output.pointer), &values);
+            Ok(())
+        }
         BlackBoxOp::Sha256Compression { input, hash_values, output } => {
             let mut message = [0; 16];
             let inputs = read_heap_vector(memory, input);
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 13accbeacb3..c7bf014f068 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -568,6 +568,13 @@ impl BlackBoxFunctionSolver for DummyBlackBoxSolver {
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
         Ok((5_u128.into(), 6_u128.into()))
     }
+    fn poseidon2_permutation(
+        &self,
+        _input: &[FieldElement],
+        len: u32,
+    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+        Ok(vec![0_u128.into(); len as usize])
+    }
 }
 
 #[cfg(test)]
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 073b0e6f59f..90608974f98 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -1151,6 +1151,14 @@ pub(crate) mod tests {
         ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
             panic!("Path not trodden by this test")
         }
+
+        fn poseidon2_permutation(
+            &self,
+            _inputs: &[FieldElement],
+            _len: u32,
+        ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+            Ok(vec![0_u128.into(), 1_u128.into(), 2_u128.into(), 3_u128.into()])
+        }
     }
 
     pub(crate) fn create_context() -> BrilligContext {
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
index 85706384eee..b9239f822e8 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -114,6 +114,19 @@ example:
 
 #include_code poseidon test_programs/execution_success/poseidon_bn254_hash/src/main.nr rust
 
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
 ## mimc_bn254 and mimc
 
 `mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 7a931f7c047..fcf21436197 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -1,5 +1,6 @@
 mod poseidon;
 mod mimc;
+mod poseidon2;
 mod pedersen;
 
 use crate::default::Default;
@@ -73,7 +74,7 @@ pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
 {}
 
 #[foreign(poseidon2_permutation)]
-pub fn poseidon2_permutation<N>(_input: [u8; N], _state_length: u32) -> [u8; N] {}
+pub fn poseidon2_permutation<N>(_input: [Field; N], _state_length: u32) -> [Field; N] {}
 
 #[foreign(sha256_compression)]
 pub fn sha256_compression(_input: [u32; 16], _state: [u32; 8]) -> [u32; 8] {}
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
new file mode 100644
index 00000000000..8e0fcc6858e
--- /dev/null
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -0,0 +1,119 @@
+global rate = 3;
+
+struct Poseidon2 {
+    cache: [Field;3],
+    state: [Field;4],
+    cache_size: u32,
+    squeeze_mode: bool, // 0 => absorb, 1 => squeeze
+}
+
+impl Poseidon2 {
+
+    pub fn hash<N>(input: [Field; N], message_size: u32) -> Field {
+        if message_size == N {
+            Poseidon2::hash_internal(input, N, false)
+        } else {
+            Poseidon2::hash_internal(input, message_size, true)
+        }
+    }
+
+    fn new(iv: Field) -> Poseidon2 {
+        let mut result = Poseidon2 {
+            cache: [0;3],
+            state: [0;4],
+            cache_size: 0,
+            squeeze_mode: false,
+        };
+        result.state[rate] = iv;
+        result
+    }
+
+    fn perform_duplex(&mut self) -> [Field; rate] {
+        // zero-pad the cache
+        for i in 0..rate {
+            if i >= self.cache_size {
+                self.cache[i] = 0;
+            }
+        }
+        // add the cache into sponge state
+        for i in 0..rate {
+            self.state[i] += self.cache[i];
+        }
+        self.state = crate::hash::poseidon2_permutation(self.state, 4);
+        // return `rate` number of field elements from the sponge state.
+        let mut result = [0; rate];
+        for i in 0..rate {
+            result[i] = self.state[i];
+        }
+        result
+    }
+
+    fn absorb(&mut self, input: Field) {
+        if (!self.squeeze_mode) & (self.cache_size == rate) {
+            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache
+            let _ = self.perform_duplex();
+            self.cache[0] = input;
+            self.cache_size = 1;
+        } else if (!self.squeeze_mode) & (self.cache_size != rate) {
+            // If we're absorbing, and the cache is not full, add the input into the cache
+            self.cache[self.cache_size] = input;
+            self.cache_size += 1;
+        } else if self.squeeze_mode {
+            // If we're in squeeze mode, switch to absorb mode and add the input into the cache.
+            // N.B. I don't think this code path can be reached?!
+            self.cache[0] = input;
+            self.cache_size = 1;
+            self.squeeze_mode = false;
+        }
+    }
+
+    fn squeeze(&mut self) -> Field
+    {
+        if self.squeeze_mode & (self.cache_size == 0) {
+            // If we're in squeze mode and the cache is empty, there is nothing left to squeeze out of the sponge!
+            // Switch to absorb mode.
+            self.squeeze_mode = false;
+            self.cache_size = 0;
+        }
+        if !self.squeeze_mode {
+            // If we're in absorb mode, apply sponge permutation to compress the cache, populate cache with compressed
+            // state and switch to squeeze mode. Note: this code block will execute if the previous `if` condition was
+            // matched
+            let new_output_elements = self.perform_duplex();
+            self.squeeze_mode = true;
+            for i in 0..rate {
+                self.cache[i] = new_output_elements[i];
+            }
+            self.cache_size = rate;
+        }
+        // By this point, we should have a non-empty cache. Pop one item off the top of the cache and return it.
+        let result = self.cache[0];
+        for i in 1..rate {
+            if i < self.cache_size {
+                self.cache[i - 1] = self.cache[i];
+            }
+        }
+        self.cache_size -= 1;
+        self.cache[self.cache_size] = 0;
+        result
+    }
+
+    fn hash_internal<N>(input:[Field;N], in_len:u32, is_variable_length: bool) -> Field
+    {
+        let iv : Field = (in_len as Field)*18446744073709551616;
+        let mut sponge = Poseidon2::new(iv);
+        for i in 0..input.len() {
+            if i as u32 < in_len {
+                sponge.absorb(input[i]);
+            }
+        }
+
+        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish
+        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures
+        // fixed-length and variable-length hashes do not collide)
+        if is_variable_length {
+            sponge.absorb(1);
+        }
+        sponge.squeeze()
+    }
+}
diff --git a/test_programs/execution_success/poseidon_bn254_hash/Prover.toml b/test_programs/execution_success/poseidon_bn254_hash/Prover.toml
index 8eecf9a3db2..fa6fd05b0a3 100644
--- a/test_programs/execution_success/poseidon_bn254_hash/Prover.toml
+++ b/test_programs/execution_success/poseidon_bn254_hash/Prover.toml
@@ -2,3 +2,8 @@ x1 = [1,2]
 y1 = "0x115cc0f5e7d690413df64c6b9662e9cf2a3617f2743245519e19607a4417189a"
 x2 = [1,2,3,4]
 y2 = "0x299c867db6c1fdd79dcefa40e4510b9837e60ebb1ce0663dbaa525df65250465"
+x3 = ["4218458030232820015255714794613421442512497197372123294583664908262453897094",
+      "4218458030232820015255714794613421442512497197372123294583664908262453897094",
+      "4218458030232820015255714794613421442512497197372123294583664908262453897094",
+      "4218458030232820015255714794613421442512497197372123294583664908262453897094"]
+ y3 = "0x2f43a0f83b51a6f5fc839dea0ecec74947637802a579fa9841930a25a0bcec11"
diff --git a/test_programs/execution_success/poseidon_bn254_hash/src/main.nr b/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
index e742a440d1c..939b99595c7 100644
--- a/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
+++ b/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
@@ -1,11 +1,15 @@
 // docs:start:poseidon
 use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
 
-fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
     let hash1 = poseidon::bn254::hash_2(x1);
     assert(hash1 == y1);
 
     let hash2 = poseidon::bn254::hash_4(x2);
     assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len() as u32);
+    assert(hash3 == y3);
 }
 // docs:end:poseidon
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index f001cebaa4d..d0acbf1aec5 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -49,4 +49,12 @@ impl BlackBoxFunctionSolver for WrapperSolver {
     ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
         self.0.ec_add(input1_x, input1_y, input2_x, input2_y)
     }
+
+    fn poseidon2_permutation(
+        &self,
+        inputs: &[acvm::FieldElement],
+        len: u32,
+    ) -> Result<Vec<acvm::FieldElement>, acvm::BlackBoxResolutionError> {
+        self.0.poseidon2_permutation(inputs, len)
+    }
 }

From 568a7812b6a11cd427ffca38103179c7ec0830db Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 27 Feb 2024 10:19:15 +0000
Subject: [PATCH 013/416] chore: nargo fmt (#4434)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR fixes the formatting CI

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/collections/bounded_vec.nr |  2 +-
 noir_stdlib/src/hash/poseidon2.nr          | 41 +++++++++-------------
 2 files changed, 18 insertions(+), 25 deletions(-)

diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index f78d86de77d..4a14bd16376 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -77,7 +77,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         let mut exceeded_len = false;
         for i in 0..MaxLen {
             exceeded_len |= i == self.len;
-            if (!exceeded_len) {
+            if !exceeded_len {
                 ret |= predicate(self.storage[i]);
             }
         }
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 8e0fcc6858e..64c1876b4e2 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -1,4 +1,4 @@
-global rate = 3;
+global RATE = 3;
 
 struct Poseidon2 {
     cache: [Field;3],
@@ -18,43 +18,38 @@ impl Poseidon2 {
     }
 
     fn new(iv: Field) -> Poseidon2 {
-        let mut result = Poseidon2 {
-            cache: [0;3],
-            state: [0;4],
-            cache_size: 0,
-            squeeze_mode: false,
-        };
-        result.state[rate] = iv;
+        let mut result = Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };
+        result.state[RATE] = iv;
         result
     }
 
-    fn perform_duplex(&mut self) -> [Field; rate] {
+    fn perform_duplex(&mut self) -> [Field; RATE] {
         // zero-pad the cache
-        for i in 0..rate {
+        for i in 0..RATE {
             if i >= self.cache_size {
                 self.cache[i] = 0;
             }
         }
         // add the cache into sponge state
-        for i in 0..rate {
+        for i in 0..RATE {
             self.state[i] += self.cache[i];
         }
         self.state = crate::hash::poseidon2_permutation(self.state, 4);
-        // return `rate` number of field elements from the sponge state.
-        let mut result = [0; rate];
-        for i in 0..rate {
+        // return `RATE` number of field elements from the sponge state.
+        let mut result = [0; RATE];
+        for i in 0..RATE {
             result[i] = self.state[i];
         }
         result
     }
 
     fn absorb(&mut self, input: Field) {
-        if (!self.squeeze_mode) & (self.cache_size == rate) {
+        if (!self.squeeze_mode) & (self.cache_size == RATE) {
             // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache
             let _ = self.perform_duplex();
             self.cache[0] = input;
             self.cache_size = 1;
-        } else if (!self.squeeze_mode) & (self.cache_size != rate) {
+        } else if (!self.squeeze_mode) & (self.cache_size != RATE) {
             // If we're absorbing, and the cache is not full, add the input into the cache
             self.cache[self.cache_size] = input;
             self.cache_size += 1;
@@ -67,8 +62,7 @@ impl Poseidon2 {
         }
     }
 
-    fn squeeze(&mut self) -> Field
-    {
+    fn squeeze(&mut self) -> Field {
         if self.squeeze_mode & (self.cache_size == 0) {
             // If we're in squeze mode and the cache is empty, there is nothing left to squeeze out of the sponge!
             // Switch to absorb mode.
@@ -81,14 +75,14 @@ impl Poseidon2 {
             // matched
             let new_output_elements = self.perform_duplex();
             self.squeeze_mode = true;
-            for i in 0..rate {
+            for i in 0..RATE {
                 self.cache[i] = new_output_elements[i];
             }
-            self.cache_size = rate;
+            self.cache_size = RATE;
         }
         // By this point, we should have a non-empty cache. Pop one item off the top of the cache and return it.
         let result = self.cache[0];
-        for i in 1..rate {
+        for i in 1..RATE {
             if i < self.cache_size {
                 self.cache[i - 1] = self.cache[i];
             }
@@ -98,9 +92,8 @@ impl Poseidon2 {
         result
     }
 
-    fn hash_internal<N>(input:[Field;N], in_len:u32, is_variable_length: bool) -> Field
-    {
-        let iv : Field = (in_len as Field)*18446744073709551616;
+    fn hash_internal<N>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
+        let iv : Field = (in_len as Field) * 18446744073709551616;
         let mut sponge = Poseidon2::new(iv);
         for i in 0..input.len() {
             if i as u32 < in_len {

From b9384fb23abf4ab15e880fb7e03c21509a9fa8a6 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 27 Feb 2024 10:44:23 +0000
Subject: [PATCH 014/416] chore!: Remove empty value from bounded vec (#4431)

# Description

## Problem\*
## Summary\*

Removes the `empty_value` field from the bounded vec. This muddies the
API and shouldn't be needed since we have `crate::unsafe::zeroed()`
instead.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[Exceptional Case]** Documentation to be submitted in a separate
PR.
  - Included in https://github.com/noir-lang/noir/pull/4430

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 noir_stdlib/src/collections/bounded_vec.nr    |  8 ++---
 .../noir_test_success/bounded_vec/src/main.nr | 32 +++++++++----------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 4a14bd16376..752b96d6591 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -1,12 +1,12 @@
 struct BoundedVec<T, MaxLen> {
     storage: [T; MaxLen],
     len: u64,
-    empty_value: T,
 }
 
 impl<T, MaxLen> BoundedVec<T, MaxLen> {
-    pub fn new(initial_value: T) -> Self {
-        BoundedVec { storage: [initial_value; MaxLen], len: 0, empty_value: initial_value }
+    pub fn new() -> Self {
+        let zeroed = crate::unsafe::zeroed();
+        BoundedVec { storage: [zeroed; MaxLen], len: 0 }
     }
 
     pub fn get(mut self: Self, index: u64) -> T {
@@ -68,7 +68,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len -= 1;
 
         let elem = self.storage[self.len];
-        self.storage[self.len] = self.empty_value;
+        self.storage[self.len] = crate::unsafe::zeroed();
         elem
     }
 
diff --git a/test_programs/noir_test_success/bounded_vec/src/main.nr b/test_programs/noir_test_success/bounded_vec/src/main.nr
index d51d2cc3685..0e2c89c9064 100644
--- a/test_programs/noir_test_success/bounded_vec/src/main.nr
+++ b/test_programs/noir_test_success/bounded_vec/src/main.nr
@@ -1,6 +1,6 @@
 #[test]
 fn test_vec_push_pop() {
-    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     assert(vec.len == 0);
     vec.push(2);
     assert(vec.len == 1);
@@ -17,7 +17,7 @@ fn test_vec_push_pop() {
 
 #[test]
 fn test_vec_extend_from_array() {
-    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     vec.extend_from_array([2, 4]);
     assert(vec.len == 2);
     assert(vec.get(0) == 2);
@@ -26,13 +26,13 @@ fn test_vec_extend_from_array() {
 
 #[test(should_fail_with="extend_from_array out of bounds")]
 fn test_vec_extend_from_array_out_of_bound() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([2, 4, 6]);
 }
 
 #[test(should_fail_with="extend_from_array out of bounds")]
 fn test_vec_extend_from_array_twice_out_of_bound() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([2]);
     assert(vec.len == 1);
     vec.extend_from_array([4, 6]);
@@ -40,36 +40,36 @@ fn test_vec_extend_from_array_twice_out_of_bound() {
 
 #[test(should_fail)]
 fn test_vec_get_out_of_bound() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([2, 4]);
     let _x = vec.get(2);
 }
 
 #[test(should_fail)]
 fn test_vec_get_not_declared() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([2]);
     let _x = vec.get(1);
 }
 
 #[test(should_fail)]
 fn test_vec_get_uninitialized() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     let _x = vec.get(0);
 }
 
 #[test(should_fail_with="push out of bounds")]
 fn test_vec_push_out_of_bound() {
-    let mut vec: BoundedVec<Field, 1> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 1> = BoundedVec::new();
     vec.push(1);
     vec.push(2);
 }
 
 #[test(should_fail_with="extend_from_bounded_vec out of bounds")]
 fn test_vec_extend_from_bounded_vec_out_of_bound() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
 
-    let mut another_vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    let mut another_vec: BoundedVec<Field, 3> = BoundedVec::new();
     another_vec.extend_from_array([1, 2, 3]);
 
     vec.extend_from_bounded_vec(another_vec);
@@ -77,10 +77,10 @@ fn test_vec_extend_from_bounded_vec_out_of_bound() {
 
 #[test(should_fail_with="extend_from_bounded_vec out of bounds")]
 fn test_vec_extend_from_bounded_vec_twice_out_of_bound() {
-    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([1, 2]);
 
-    let mut another_vec: BoundedVec<Field, 1> = BoundedVec::new(0);
+    let mut another_vec: BoundedVec<Field, 1> = BoundedVec::new();
     another_vec.push(3);
 
     vec.extend_from_bounded_vec(another_vec);
@@ -88,7 +88,7 @@ fn test_vec_extend_from_bounded_vec_twice_out_of_bound() {
 
 #[test]
 fn test_vec_any() {
-    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     vec.extend_from_array([2, 4, 6]);
     assert(vec.any(|v| v == 2) == true);
     assert(vec.any(|v| v == 4) == true);
@@ -98,8 +98,8 @@ fn test_vec_any() {
 
 #[test]
 fn test_vec_any_not_default() {
-    let default_value = 1;
-    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(default_value);
+    let default_value = 0;
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     vec.extend_from_array([2, 4]);
     assert(vec.any(|v| v == default_value) == false);
-}
\ No newline at end of file
+}

From 8f935af0813c4f012005c8b3eb70441b44db5714 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 27 Feb 2024 11:43:55 +0000
Subject: [PATCH 015/416] chore(docs): fix external contributor force push
 workflow (#4437)

# Description

## Problem\*

Resolves #

## Summary\*

This workflow was failing due to the fact that we're storing the message
in a file but not checking out the repository.

While checking out would be safe in this case, I've just moved the
comment into the workflow for paranoia reasons.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/EXTERNAL_CONTRIBUTOR_PR_COMMENT.md | 5 -----
 .github/workflows/pull-request-title.yml   | 6 +++++-
 2 files changed, 5 insertions(+), 6 deletions(-)
 delete mode 100644 .github/EXTERNAL_CONTRIBUTOR_PR_COMMENT.md

diff --git a/.github/EXTERNAL_CONTRIBUTOR_PR_COMMENT.md b/.github/EXTERNAL_CONTRIBUTOR_PR_COMMENT.md
deleted file mode 100644
index 4031bcdb61c..00000000000
--- a/.github/EXTERNAL_CONTRIBUTOR_PR_COMMENT.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Thank you for your contribution to the Noir language.
-
-Please **do not force push to this branch** after the Noir team have reviewed this PR. Doing so will only delay us merging your PR as we will need to start the review process from scratch.
-
-Thanks for your understanding.
\ No newline at end of file
diff --git a/.github/workflows/pull-request-title.yml b/.github/workflows/pull-request-title.yml
index 8f863160cf1..7e9b729da28 100644
--- a/.github/workflows/pull-request-title.yml
+++ b/.github/workflows/pull-request-title.yml
@@ -39,6 +39,10 @@ jobs:
       - name: Post comment on force pushes
         uses: marocchino/sticky-pull-request-comment@v2
         with:
-          path: ./.github/EXTERNAL_CONTRIBUTOR_PR_COMMENT.md
+          message: |
+            Thank you for your contribution to the Noir language.
 
+            Please **do not force push to this branch** after the Noir team have started review of this PR. Doing so will only delay us merging your PR as we will need to start the review process from scratch.
+
+            Thanks for your understanding.
           
\ No newline at end of file

From 2498115cf197450f33af0b9c158fa2ee4ce3e222 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 27 Feb 2024 06:35:28 -0500
Subject: [PATCH 016/416] feat: Sync from aztec-packages (#4390)

BEGIN_COMMIT_OVERRIDE
chore: bootstrap improvements.
(https://github.com/AztecProtocol/aztec-packages/pull/4711)
chore: Add full recursive verification test
(https://github.com/AztecProtocol/aztec-packages/pull/4658)
chore: add struct for each bigint modulus
(https://github.com/AztecProtocol/aztec-packages/pull/4422)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: sirasistant <sirasistant@gmail.com>
---
 Cargo.lock                                    |   1 +
 Dockerfile                                    |   6 +-
 aztec_macros/Cargo.toml                       |   1 +
 aztec_macros/src/lib.rs                       | 269 ++++++++++++--
 bootstrap.sh                                  |   3 +
 bootstrap_cache.sh                            |   4 +
 .../src/hir/def_collector/dc_crate.rs         |  14 +
 .../noirc_frontend/src/hir/def_map/mod.rs     |   5 +
 compiler/noirc_frontend/src/hir/mod.rs        |   4 +
 compiler/noirc_frontend/src/lib.rs            |  11 +
 compiler/noirc_frontend/src/node_interner.rs  |   2 +-
 noir_stdlib/src/bigint.nr                     | 327 ++++++++++++++++--
 noir_stdlib/src/uint128.nr                    |   2 +-
 noirc_macros/src/lib.rs                       |  12 +
 scripts/test_native.sh                        |   4 +-
 .../1327_concrete_in_generic/src/main.nr      |   4 +-
 .../execution_success/bigint/src/main.nr      |  13 +-
 .../brillig_cow_regression/Prover.toml        |   2 +-
 .../brillig_cow_regression/src/main.nr        |  24 +-
 .../double_verify_nested_proof/Nargo.toml     |   7 +
 .../double_verify_nested_proof/Prover.toml    |   5 +
 .../double_verify_nested_proof/src/main.nr    |  28 ++
 .../double_verify_proof/src/main.nr           |   3 +-
 .../regression_4124/src/main.nr               |   8 +-
 test_programs/gates_report.sh                 |   2 +-
 tooling/debugger/ignored-tests.txt            |   1 +
 tooling/nargo_fmt/tests/expected/contract.nr  |  21 +-
 tooling/nargo_fmt/tests/input/contract.nr     |  37 +-
 28 files changed, 688 insertions(+), 132 deletions(-)
 create mode 100644 test_programs/execution_success/double_verify_nested_proof/Nargo.toml
 create mode 100644 test_programs/execution_success/double_verify_nested_proof/Prover.toml
 create mode 100644 test_programs/execution_success/double_verify_nested_proof/src/main.nr

diff --git a/Cargo.lock b/Cargo.lock
index 714b700119a..c0438eaf81f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -417,6 +417,7 @@ version = "0.24.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
+ "noirc_errors",
  "noirc_frontend",
 ]
 
diff --git a/Dockerfile b/Dockerfile
index 000292e0a47..3a478c3f95a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,12 +1,12 @@
-FROM rust:bookworm
+FROM rust:bullseye
 WORKDIR /usr/src/noir
 COPY . .
 RUN ./scripts/bootstrap_native.sh
 
 # When running the container, mount the users home directory to same location.
-FROM ubuntu:lunar
+FROM ubuntu:focal
 # Install Tini as nargo doesn't handle signals properly.
 # Install git as nargo needs it to clone.
 RUN apt-get update && apt-get install -y git tini && rm -rf /var/lib/apt/lists/* && apt-get clean
 COPY --from=0 /usr/src/noir/target/release/nargo /usr/src/noir/target/release/nargo
-ENTRYPOINT ["/usr/bin/tini", "--", "/usr/src/noir/target/release/nargo"]
\ No newline at end of file
+ENTRYPOINT ["/usr/bin/tini", "--", "/usr/src/noir/target/release/nargo"]
diff --git a/aztec_macros/Cargo.toml b/aztec_macros/Cargo.toml
index 5e908b2e672..ed9821fabcf 100644
--- a/aztec_macros/Cargo.toml
+++ b/aztec_macros/Cargo.toml
@@ -11,5 +11,6 @@ repository.workspace = true
 
 [dependencies]
 noirc_frontend.workspace = true
+noirc_errors.workspace = true
 iter-extended.workspace = true
 convert_case = "0.6.0"
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 0b93dbaa634..0ccc421d3bc 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -3,6 +3,10 @@ use std::vec;
 
 use convert_case::{Case, Casing};
 use iter_extended::vecmap;
+use noirc_errors::Location;
+use noirc_frontend::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
+use noirc_frontend::hir::def_map::{LocalModuleId, ModuleId};
+use noirc_frontend::macros_api::parse_program;
 use noirc_frontend::macros_api::FieldElement;
 use noirc_frontend::macros_api::{
     BlockExpression, CallExpression, CastExpression, Distinctness, Expression, ExpressionKind,
@@ -16,9 +20,8 @@ use noirc_frontend::macros_api::{
 use noirc_frontend::macros_api::{CrateId, FileId};
 use noirc_frontend::macros_api::{MacroError, MacroProcessor};
 use noirc_frontend::macros_api::{ModuleDefId, NodeInterner, SortedModule, StructId};
-use noirc_frontend::node_interner::{TraitId, TraitImplKind};
+use noirc_frontend::node_interner::{FuncId, TraitId, TraitImplId, TraitImplKind};
 use noirc_frontend::Lambda;
-
 pub struct AztecMacro;
 
 impl MacroProcessor for AztecMacro {
@@ -31,6 +34,25 @@ impl MacroProcessor for AztecMacro {
         transform(ast, crate_id, context)
     }
 
+    fn process_unresolved_traits_impls(
+        &self,
+        crate_id: &CrateId,
+        context: &mut HirContext,
+        unresolved_traits_impls: &[UnresolvedTraitImpl],
+        collected_functions: &mut Vec<UnresolvedFunctions>,
+    ) -> Result<(), (MacroError, FileId)> {
+        if has_aztec_dependency(crate_id, context) {
+            inject_compute_note_hash_and_nullifier(
+                crate_id,
+                context,
+                unresolved_traits_impls,
+                collected_functions,
+            )
+        } else {
+            Ok(())
+        }
+    }
+
     fn process_typed_ast(
         &self,
         crate_id: &CrateId,
@@ -46,7 +68,6 @@ const MAX_CONTRACT_FUNCTIONS: usize = 2_usize.pow(FUNCTION_TREE_HEIGHT);
 #[derive(Debug, Clone)]
 pub enum AztecMacroError {
     AztecDepNotFound,
-    ComputeNoteHashAndNullifierNotFound { span: Span },
     ContractHasTooManyFunctions { span: Span },
     ContractConstructorMissing { span: Span },
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
@@ -63,11 +84,6 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: None,
             },
-            AztecMacroError::ComputeNoteHashAndNullifierNotFound { span } => MacroError {
-                primary_message: "compute_note_hash_and_nullifier function not found. Define it in your contract. For more information go to https://docs.aztec.network/developers/debugging/aztecnr-errors#compute_note_hash_and_nullifier-function-not-found-define-it-in-your-contract".to_owned(),
-                secondary_message: None,
-                span: Some(span),
-            },
             AztecMacroError::ContractHasTooManyFunctions { span } => MacroError {
                 primary_message: format!("Contract can only have a maximum of {} functions", MAX_CONTRACT_FUNCTIONS),
                 secondary_message: None,
@@ -313,15 +329,17 @@ fn check_for_aztec_dependency(
     crate_id: &CrateId,
     context: &HirContext,
 ) -> Result<(), (MacroError, FileId)> {
-    let crate_graph = &context.crate_graph[crate_id];
-    let has_aztec_dependency = crate_graph.dependencies.iter().any(|dep| dep.as_name() == "aztec");
-    if has_aztec_dependency {
+    if has_aztec_dependency(crate_id, context) {
         Ok(())
     } else {
-        Err((AztecMacroError::AztecDepNotFound.into(), crate_graph.root_file_id))
+        Err((AztecMacroError::AztecDepNotFound.into(), context.crate_graph[crate_id].root_file_id))
     }
 }
 
+fn has_aztec_dependency(crate_id: &CrateId, context: &HirContext) -> bool {
+    context.crate_graph[crate_id].dependencies.iter().any(|dep| dep.as_name() == "aztec")
+}
+
 // Check to see if the user has defined a storage struct
 fn check_for_storage_definition(module: &SortedModule) -> bool {
     module.types.iter().any(|r#struct| r#struct.name.0.contents == "Storage")
@@ -338,27 +356,30 @@ fn check_for_storage_implementation(module: &SortedModule) -> bool {
 }
 
 // Check if "compute_note_hash_and_nullifier(AztecAddress,Field,Field,Field,[Field; N]) -> [Field; 4]" is defined
-fn check_for_compute_note_hash_and_nullifier_definition(module: &SortedModule) -> bool {
-    module.functions.iter().any(|func| {
-        func.def.name.0.contents == "compute_note_hash_and_nullifier"
-                && func.def.parameters.len() == 5
-                && match &func.def.parameters[0].typ.typ {
+fn check_for_compute_note_hash_and_nullifier_definition(
+    functions_data: &[(LocalModuleId, FuncId, NoirFunction)],
+    module_id: LocalModuleId,
+) -> bool {
+    functions_data.iter().filter(|func_data| func_data.0 == module_id).any(|func_data| {
+        func_data.2.def.name.0.contents == "compute_note_hash_and_nullifier"
+                && func_data.2.def.parameters.len() == 5
+                && match &func_data.2.def.parameters[0].typ.typ {
                     UnresolvedTypeData::Named(path, _, _) => path.segments.last().unwrap().0.contents == "AztecAddress",
                     _ => false,
                 }
-                && func.def.parameters[1].typ.typ == UnresolvedTypeData::FieldElement
-                && func.def.parameters[2].typ.typ == UnresolvedTypeData::FieldElement
-                && func.def.parameters[3].typ.typ == UnresolvedTypeData::FieldElement
+                && func_data.2.def.parameters[1].typ.typ == UnresolvedTypeData::FieldElement
+                && func_data.2.def.parameters[2].typ.typ == UnresolvedTypeData::FieldElement
+                && func_data.2.def.parameters[3].typ.typ == UnresolvedTypeData::FieldElement
                 // checks if the 5th parameter is an array and the Box<UnresolvedType> in
                 // Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>) contains only fields
-                && match &func.def.parameters[4].typ.typ {
+                && match &func_data.2.def.parameters[4].typ.typ {
                     UnresolvedTypeData::Array(_, inner_type) => {
                         matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
                     },
                     _ => false,
                 }
                 // We check the return type the same way as we did the 5th parameter
-                && match &func.def.return_type {
+                && match &func_data.2.def.return_type {
                     FunctionReturnType::Default(_) => false,
                     FunctionReturnType::Ty(unresolved_type) => {
                         match &unresolved_type.typ {
@@ -401,13 +422,6 @@ fn transform_module(
         generate_storage_implementation(module).map_err(|err| (err, crate_graph.root_file_id))?;
     }
 
-    if storage_defined && !check_for_compute_note_hash_and_nullifier_definition(module) {
-        return Err((
-            AztecMacroError::ComputeNoteHashAndNullifierNotFound { span: Span::default() },
-            crate_graph.root_file_id,
-        ));
-    }
-
     for structure in module.types.iter() {
         if structure.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Event)) {
             module.impls.push(generate_selector_impl(structure));
@@ -596,7 +610,7 @@ fn generate_storage_implementation(module: &mut SortedModule) -> Result<(), Azte
 /// If it does, it will insert the following things:
 /// - A new Input that is provided for a kernel app circuit, named: {Public/Private}ContextInputs
 /// - Hashes all of the function input variables
-///     - This instantiates a helper function  
+///     - This instantiates a helper function
 fn transform_function(
     ty: &str,
     func: &mut NoirFunction,
@@ -826,8 +840,8 @@ fn get_serialized_length(
             && !interner.lookup_all_trait_implementations(stored_in_state, trait_id).is_empty()
     });
 
-    // Maps and (private) Notes always occupy a single slot. Someone could store a Note in PublicState for whatever reason though.
-    if struct_name == "Map" || (is_note && struct_name != "PublicState") {
+    // Maps and (private) Notes always occupy a single slot. Someone could store a Note in PublicMutable for whatever reason though.
+    if struct_name == "Map" || (is_note && struct_name != "PublicMutable") {
         return Ok(1);
     }
 
@@ -1601,3 +1615,194 @@ fn event_signature(event: &StructType) -> String {
     let fields = vecmap(event.get_fields(&[]), |(_, typ)| signature_of_type(&typ));
     format!("{}({})", event.name.0.contents, fields.join(","))
 }
+
+fn inject_compute_note_hash_and_nullifier(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+    unresolved_traits_impls: &[UnresolvedTraitImpl],
+    collected_functions: &mut [UnresolvedFunctions],
+) -> Result<(), (MacroError, FileId)> {
+    // We first fetch modules in this crate which correspond to contracts, along with their file id.
+    let contract_module_file_ids: Vec<(LocalModuleId, FileId)> = context
+        .def_map(crate_id)
+        .expect("ICE: Missing crate in def_map")
+        .modules()
+        .iter()
+        .filter(|(_, module)| module.is_contract)
+        .map(|(idx, module)| (LocalModuleId(idx), module.location.file))
+        .collect();
+
+    // If the current crate does not contain a contract module we simply skip it.
+    if contract_module_file_ids.is_empty() {
+        return Ok(());
+    } else if contract_module_file_ids.len() != 1 {
+        panic!("Found multiple contracts in the same crate");
+    }
+
+    let (module_id, file_id) = contract_module_file_ids[0];
+
+    // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
+    // escape hatch for this mechanism.
+    // TODO(#4647): improve this diagnosis and error messaging.
+    if collected_functions.iter().any(|coll_funcs_data| {
+        check_for_compute_note_hash_and_nullifier_definition(&coll_funcs_data.functions, module_id)
+    }) {
+        return Ok(());
+    }
+
+    // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
+    // contract might use. These are the types that implement the NoteInterface trait, which provides the
+    // get_note_type_id function.
+    let note_types = fetch_struct_trait_impls(context, unresolved_traits_impls, "NoteInterface");
+
+    // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
+    let func = generate_compute_note_hash_and_nullifier(&note_types);
+
+    // And inject the newly created function into the contract.
+
+    // TODO(#4373): We don't have a reasonable location for the source code of this autogenerated function, so we simply
+    // pass an empty span. This function should not produce errors anyway so this should not matter.
+    let location = Location::new(Span::empty(0), file_id);
+
+    // These are the same things the ModCollector does when collecting functions: we push the function to the
+    // NodeInterner, declare it in the module (which checks for duplicate definitions), and finally add it to the list
+    // on collected but unresolved functions.
+
+    let func_id = context.def_interner.push_empty_fn();
+    context.def_interner.push_function(
+        func_id,
+        &func.def,
+        ModuleId { krate: *crate_id, local_id: module_id },
+        location,
+    );
+
+    context.def_map_mut(crate_id).unwrap()
+        .modules_mut()[module_id.0]
+        .declare_function(
+            func.name_ident().clone(), func_id
+        ).expect(
+            "Failed to declare the autogenerated compute_note_hash_and_nullifier function, likely due to a duplicate definition. See https://github.com/AztecProtocol/aztec-packages/issues/4647."
+        );
+
+    collected_functions
+        .iter_mut()
+        .find(|fns| fns.file_id == file_id)
+        .expect("ICE: no functions found in contract file")
+        .push_fn(module_id, func_id, func.clone());
+
+    Ok(())
+}
+
+// Fetches the name of all structs that implement trait_name, both in the current crate and all of its dependencies.
+fn fetch_struct_trait_impls(
+    context: &mut HirContext,
+    unresolved_traits_impls: &[UnresolvedTraitImpl],
+    trait_name: &str,
+) -> Vec<String> {
+    let mut struct_typenames: Vec<String> = Vec::new();
+
+    // These structs can be declared in either external crates or the current one. External crates that contain
+    // dependencies have already been processed and resolved, but are available here via the NodeInterner. Note that
+    // crates on which the current crate does not depend on may not have been processed, and will be ignored.
+    for trait_impl_id in 0..context.def_interner.next_trait_impl_id().0 {
+        let trait_impl = &context.def_interner.get_trait_implementation(TraitImplId(trait_impl_id));
+
+        if trait_impl.borrow().ident.0.contents == *trait_name {
+            if let Type::Struct(s, _) = &trait_impl.borrow().typ {
+                struct_typenames.push(s.borrow().name.0.contents.clone());
+            } else {
+                panic!("Found impl for {} on non-Struct", trait_name);
+            }
+        }
+    }
+
+    // This crate's traits and impls have not yet been resolved, so we look for impls in unresolved_trait_impls.
+    struct_typenames.extend(
+        unresolved_traits_impls
+            .iter()
+            .filter(|trait_impl| {
+                trait_impl
+                    .trait_path
+                    .segments
+                    .last()
+                    .expect("ICE: empty trait_impl path")
+                    .0
+                    .contents
+                    == *trait_name
+            })
+            .filter_map(|trait_impl| match &trait_impl.object_type.typ {
+                UnresolvedTypeData::Named(path, _, _) => {
+                    Some(path.segments.last().unwrap().0.contents.clone())
+                }
+                _ => None,
+            }),
+    );
+
+    struct_typenames
+}
+
+fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFunction {
+    let function_source = generate_compute_note_hash_and_nullifier_source(note_types);
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors.clone());
+    }
+    assert_eq!(errors.len(), 0, "Failed to parse Noir macro code. This is either a bug in the compiler or the Noir macro code");
+
+    let mut function_ast = function_ast.into_sorted();
+    function_ast.functions.remove(0)
+}
+
+fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) -> String {
+    // TODO(#4649): The serialized_note parameter is a fixed-size array, but we don't know what length it should have.
+    // For now we hardcode it to 20, which is the same as MAX_NOTE_FIELDS_LENGTH.
+
+    if note_types.is_empty() {
+        // TODO(#4520): Even if the contract does not include any notes, other parts of the stack expect for this
+        // function to exist, so we include a dummy version. We likely should error out here instead.
+        "
+        unconstrained fn compute_note_hash_and_nullifier(
+            contract_address: AztecAddress,
+            nonce: Field,
+            storage_slot: Field,
+            note_type_id: Field,
+            serialized_note: [Field; 20]
+        ) -> pub [Field; 4] {
+            [0, 0, 0, 0]
+        }"
+        .to_string()
+    } else {
+        // For contracts that include notes we do a simple if-else chain comparing note_type_id with the different
+        // get_note_type_id of each of the note types.
+
+        let if_statements: Vec<String> = note_types.iter().map(|note_type| format!(
+            "if (note_type_id == {0}::get_note_type_id()) {{
+                note_utils::compute_note_hash_and_nullifier({0}::deserialize_content, note_header, serialized_note)
+            }}"
+        , note_type)).collect();
+
+        // TODO(#4520): error out on the else instead of returning a zero array
+        let full_if_statement = if_statements.join(" else ")
+            + "
+            else {
+                [0, 0, 0, 0]
+            }";
+
+        format!(
+            "
+            unconstrained fn compute_note_hash_and_nullifier(
+                contract_address: AztecAddress,
+                nonce: Field,
+                storage_slot: Field,
+                note_type_id: Field,
+                serialized_note: [Field; 20]
+            ) -> pub [Field; 4] {{
+                let note_header = NoteHeader::new(contract_address, nonce, storage_slot);
+
+                {}
+            }}",
+            full_if_statement
+        )
+    }
+}
diff --git a/bootstrap.sh b/bootstrap.sh
index 5ebe7ade090..1f9506904a4 100755
--- a/bootstrap.sh
+++ b/bootstrap.sh
@@ -15,5 +15,8 @@ if [ -n "$CMD" ]; then
   fi
 fi
 
+# Attempt to just pull artefacts from CI and exit on success.
+./bootstrap_cache.sh && exit
+
 ./scripts/bootstrap_native.sh
 ./scripts/bootstrap_packages.sh
\ No newline at end of file
diff --git a/bootstrap_cache.sh b/bootstrap_cache.sh
index 672702416bd..d06aa493662 100755
--- a/bootstrap_cache.sh
+++ b/bootstrap_cache.sh
@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 set -eu
 
+[ -z "${NO_CACHE:-}" ] && type docker &> /dev/null && [ -f ~/.aws/credentials ] || exit 1
+
 cd "$(dirname "$0")"
 source ../build-system/scripts/setup_env '' '' mainframe_$USER > /dev/null
 
@@ -9,3 +11,5 @@ extract_repo noir-packages /usr/src/noir/packages ./
 echo -e "\033[1mRetrieving nargo from remote cache...\033[0m"
 extract_repo noir /usr/src/noir/target/release ./target/
 
+remove_old_images noir-packages
+remove_old_images noir
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 0d1dd1b4337..7f36af5b30e 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -256,6 +256,20 @@ impl DefCollector {
         // Add the current crate to the collection of DefMaps
         context.def_maps.insert(crate_id, def_collector.def_map);
 
+        // TODO(#4653): generalize this function
+        for macro_processor in &macro_processors {
+            macro_processor
+                .process_unresolved_traits_impls(
+                    &crate_id,
+                    context,
+                    &def_collector.collected_traits_impls,
+                    &mut def_collector.collected_functions,
+                )
+                .unwrap_or_else(|(macro_err, file_id)| {
+                    errors.push((macro_err.into(), file_id));
+                });
+        }
+
         inject_prelude(crate_id, context, crate_root, &mut def_collector.collected_imports);
         for submodule in submodules {
             inject_prelude(
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 8e0dacc294b..8721bdb6c3c 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -135,6 +135,11 @@ impl CrateDefMap {
     pub fn modules(&self) -> &Arena<ModuleData> {
         &self.modules
     }
+
+    pub fn modules_mut(&mut self) -> &mut Arena<ModuleData> {
+        &mut self.modules
+    }
+
     pub fn krate(&self) -> CrateId {
         self.krate
     }
diff --git a/compiler/noirc_frontend/src/hir/mod.rs b/compiler/noirc_frontend/src/hir/mod.rs
index 4d3800f1a50..00bcb0cdebf 100644
--- a/compiler/noirc_frontend/src/hir/mod.rs
+++ b/compiler/noirc_frontend/src/hir/mod.rs
@@ -91,6 +91,10 @@ impl Context<'_, '_> {
         self.def_maps.get(crate_id)
     }
 
+    pub fn def_map_mut(&mut self, crate_id: &CrateId) -> Option<&mut CrateDefMap> {
+        self.def_maps.get_mut(crate_id)
+    }
+
     /// Return the CrateId for each crate that has been compiled
     /// successfully
     pub fn crates(&self) -> impl Iterator<Item = CrateId> + '_ {
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index eb00a61adf6..be007929fc4 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -45,6 +45,7 @@ pub mod macros_api {
     pub use noirc_errors::Span;
 
     pub use crate::graph::CrateId;
+    use crate::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
     pub use crate::hir::def_collector::errors::MacroError;
     pub use crate::hir_def::expr::{HirExpression, HirLiteral};
     pub use crate::hir_def::stmt::HirStatement;
@@ -74,6 +75,16 @@ pub mod macros_api {
             crate_id: &CrateId,
             context: &HirContext,
         ) -> Result<SortedModule, (MacroError, FileId)>;
+
+        // TODO(#4653): generalize this function
+        fn process_unresolved_traits_impls(
+            &self,
+            _crate_id: &CrateId,
+            _context: &mut HirContext,
+            _unresolved_traits_impls: &[UnresolvedTraitImpl],
+            _collected_functions: &mut Vec<UnresolvedFunctions>,
+        ) -> Result<(), (MacroError, FileId)>;
+
         /// Function to manipulate the AST after type checking has been completed.
         /// The AST after type checking has been done is called the HIR.
         fn process_typed_ast(
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 7d533947f65..5de43e59254 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -367,7 +367,7 @@ impl TraitId {
 }
 
 #[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
-pub struct TraitImplId(usize);
+pub struct TraitImplId(pub usize);
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct TraitMethodId {
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 66e81f05812..98237a54779 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,4 +1,5 @@
-use crate::ops::{Add, Sub, Mul, Div, Rem};
+use crate::ops::{Add, Sub, Mul, Div};
+use crate::cmp::Eq;
 
 global bn254_fq = [0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
@@ -30,46 +31,320 @@ impl BigInt {
     #[builtin(bigint_from_le_bytes)]
     fn from_le_bytes(bytes: [u8], modulus: [u8]) -> BigInt {}
     #[builtin(bigint_to_le_bytes)]
-    pub fn to_le_bytes(self) -> [u8] {}
+    fn to_le_bytes(self) -> [u8] {}
 
-    pub fn bn254_fr_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, bn254_fr)
+    fn check_32_bytes(self: Self, other: BigInt) -> bool {
+        let bytes = self.to_le_bytes();
+        let o_bytes = other.to_le_bytes();
+        let mut result = true;
+        for i in 0..32 {
+            result = result & (bytes[i] == o_bytes[i]);
+        }
+        result
     }
-    pub fn bn254_fq_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, bn254_fq)
+}
+
+trait BigField {
+    fn from_le_bytes(bytes: [u8]) -> Self;
+    fn to_le_bytes(self) -> [u8];
+}
+
+struct Secpk1Fq {
+    inner: BigInt,
+}
+
+impl BigField for Secpk1Fq {
+    fn from_le_bytes(bytes: [u8]) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: BigInt::from_le_bytes(bytes, secpk1_fq)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Secpk1Fq { 
+    fn add(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Secpk1Fq { 
+    fn sub(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Secpk1Fq { 
+    fn mul(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Secpk1Fq { 
+    fn div(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpk1Fq {
+    fn eq(self: Self, other: Secpk1Fq) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Secpk1Fr {
+    inner: BigInt,
+}
+
+impl BigField for Secpk1Fr {
+    fn from_le_bytes(bytes: [u8]) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: BigInt::from_le_bytes(bytes, secpk1_fr)
+        }
     }
-    pub fn secpk1_fq_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, secpk1_fq)
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
     }
-    pub fn secpk1_fr_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, secpk1_fr)
+}
+
+impl Add for Secpk1Fr { 
+    fn add(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Secpk1Fr { 
+    fn sub(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Secpk1Fr { 
+    fn mul(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Secpk1Fr { 
+    fn div(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpk1Fr {
+    fn eq(self: Self, other: Secpk1Fr) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Bn254Fr {
+    inner: BigInt,
+}
+
+impl BigField for Bn254Fr {
+    fn from_le_bytes(bytes: [u8]) -> Bn254Fr {
+        Bn254Fr {
+            inner: BigInt::from_le_bytes(bytes, bn254_fr)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
     }
 }
 
-impl Add for BigInt { 
-    fn add(self: Self, other: BigInt) -> BigInt {
-        self.bigint_add(other)
+impl Add for Bn254Fr { 
+    fn add(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Bn254Fr { 
+    fn sub(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_sub(other.inner)
+        }
     }
 }
-impl Sub for BigInt { 
-    fn sub(self: Self, other: BigInt) -> BigInt {
-        self.bigint_sub(other)
+impl Mul for Bn254Fr { 
+    fn mul(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
     }
 }
-impl Mul for BigInt { 
-    fn mul(self: Self, other: BigInt) -> BigInt {
-        self.bigint_mul(other)
+impl Div for Bn254Fr { 
+    fn div(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_div(other.inner)
+        }
     }
 }
-impl Div for BigInt { 
-    fn div(self: Self, other: BigInt) -> BigInt {
-        self.bigint_div(other)
+impl Eq for Bn254Fr {
+    fn eq(self: Self, other: Bn254Fr) -> bool {
+        self.inner.check_32_bytes(other.inner)
     }
 }
-impl Rem for BigInt { 
-    fn rem(self: Self, other: BigInt) -> BigInt {
-        let quotient = self.bigint_div(other);
-        self.bigint_sub(quotient.bigint_mul(other))
+
+struct Bn254Fq {
+    inner: BigInt,
+}
+
+impl BigField for Bn254Fq {
+    fn from_le_bytes(bytes: [u8]) -> Bn254Fq {
+        Bn254Fq {
+            inner: BigInt::from_le_bytes(bytes, bn254_fq)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
     }
 }
 
+impl Add for Bn254Fq { 
+    fn add(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Bn254Fq { 
+    fn sub(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Bn254Fq { 
+    fn mul(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Bn254Fq { 
+    fn div(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Bn254Fq {
+    fn eq(self: Self, other: Bn254Fq) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Secpr1Fq {
+    inner: BigInt,
+}
+
+impl BigField for Secpr1Fq {
+    fn from_le_bytes(bytes: [u8]) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: BigInt::from_le_bytes(bytes, secpr1_fq)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Secpr1Fq { 
+    fn add(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Secpr1Fq { 
+    fn sub(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Secpr1Fq { 
+    fn mul(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Secpr1Fq { 
+    fn div(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpr1Fq {
+    fn eq(self: Self, other: Secpr1Fq) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Secpr1Fr {
+    inner: BigInt,
+}
+
+impl BigField for Secpr1Fr {
+    fn from_le_bytes(bytes: [u8]) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: BigInt::from_le_bytes(bytes, secpr1_fr)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Secpr1Fr { 
+    fn add(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Secpr1Fr { 
+    fn sub(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Secpr1Fr { 
+    fn mul(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Secpr1Fr { 
+    fn div(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpr1Fr {
+    fn eq(self: Self, other: Secpr1Fr) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index d6f0b1e2232..b91ed5c4cb2 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -161,7 +161,7 @@ impl Sub for U128 {
         let borrow = (low == lo) as Field;
         let high = self.hi - b.hi - borrow;
         let hi = high as u64 as Field;
-        assert(hi == high, "attempt to subtract with overflow");
+        assert(hi == high, "attempt to subtract with underflow");
         U128 {
             lo,
             hi,
diff --git a/noirc_macros/src/lib.rs b/noirc_macros/src/lib.rs
index 4337214d69f..9a916843200 100644
--- a/noirc_macros/src/lib.rs
+++ b/noirc_macros/src/lib.rs
@@ -1,3 +1,5 @@
+use noirc_frontend::hir::def_collector::dc_crate::UnresolvedFunctions;
+use noirc_frontend::hir::def_collector::dc_crate::UnresolvedTraitImpl;
 use noirc_frontend::macros_api::parse_program;
 use noirc_frontend::macros_api::HirContext;
 use noirc_frontend::macros_api::SortedModule;
@@ -16,6 +18,16 @@ impl MacroProcessor for AssertMessageMacro {
         transform(ast, crate_id)
     }
 
+    fn process_unresolved_traits_impls(
+        &self,
+        _crate_id: &CrateId,
+        _context: &mut HirContext,
+        _unresolved_traits_impls: &[UnresolvedTraitImpl],
+        _collected_functions: &mut Vec<UnresolvedFunctions>,
+    ) -> Result<(), (MacroError, FileId)> {
+        Ok(())
+    }
+
     // This macro does not need to process any information after name resolution
     fn process_typed_ast(
         &self,
diff --git a/scripts/test_native.sh b/scripts/test_native.sh
index bc1c47ecf12..9b9aa0ce4d7 100755
--- a/scripts/test_native.sh
+++ b/scripts/test_native.sh
@@ -12,4 +12,6 @@ else
   export GIT_COMMIT=$(git rev-parse --verify HEAD)
 fi
 
-cargo test --workspace --locked --release
\ No newline at end of file
+cargo fmt --all --check
+cargo clippy --workspace --locked --release
+cargo test --workspace --locked --release
diff --git a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
index 8250b31789b..3e476107c29 100644
--- a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
+++ b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
@@ -20,7 +20,7 @@ impl<T_C> B<T_C> {
     }
 }
 // ---
-// Set<Note>
+// PrivateSet<Note>
 struct C<T_D> {
         t_d_interface: MethodInterface<T_D>,
     }
@@ -55,7 +55,7 @@ fn get_d_method_interface() -> MethodInterface<D> {
 // ---
 fn main(input: Field) -> pub Field {
     let b: B<C<D>> = B::new(new_concrete_c_over_d);
-    let c: C<D> = b.get_t_c(); // Singleton<Note>
+    let c: C<D> = b.get_t_c(); // PrivateMutable<Note>
     let d: D = D { d: input }; // Note
     let output = c.call_method_of_t_d(d);
 
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 046d7d07d5e..b93fec370e5 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -1,9 +1,8 @@
 use dep::std::bigint;
 
 fn main(mut x: [u8; 5], y: [u8; 5]) {
-    let a = bigint::BigInt::secpk1_fq_from_le_bytes([x[0], x[1], x[2], x[3], x[4]]);
-    let b = bigint::BigInt::secpk1_fq_from_le_bytes([y[0], y[1], y[2], y[3], y[4]]);
-
+    let a = bigint::Secpk1Fq::from_le_bytes([x[0], x[1], x[2], x[3], x[4]]);
+    let b = bigint::Secpk1Fq::from_le_bytes([y[0], y[1], y[2], y[3], y[4]]);
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
     for i in 0..5 {
@@ -12,10 +11,6 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     }
 
     let d = a * b - b;
-    let d_bytes = d.to_le_bytes();
-    let d1 = bigint::BigInt::secpk1_fq_from_le_bytes(597243850900842442924.to_le_bytes(10));
-    let d1_bytes = d1.to_le_bytes();
-    for i in 0..32 {
-        assert(d_bytes[i] == d1_bytes[i]);
-    }
+    let d1 = bigint::Secpk1Fq::from_le_bytes(597243850900842442924.to_le_bytes(10));
+    assert(d1 == d);
 }
diff --git a/test_programs/execution_success/brillig_cow_regression/Prover.toml b/test_programs/execution_success/brillig_cow_regression/Prover.toml
index f0a4dc2485d..44813823448 100644
--- a/test_programs/execution_success/brillig_cow_regression/Prover.toml
+++ b/test_programs/execution_success/brillig_cow_regression/Prover.toml
@@ -3,7 +3,7 @@ encrypted_logs_hash = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
 ]
-new_commitments = [
+new_note_hashes = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
diff --git a/test_programs/execution_success/brillig_cow_regression/src/main.nr b/test_programs/execution_success/brillig_cow_regression/src/main.nr
index 7f3dd766480..ba51548d9dd 100644
--- a/test_programs/execution_success/brillig_cow_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_regression/src/main.nr
@@ -1,12 +1,12 @@
 // Tests a performance regression found in aztec-packages with brillig cow optimization
 
-global MAX_NEW_COMMITMENTS_PER_TX = 64;
-global MAX_NEW_NULLIFIERS_PER_TX = 64;
-global MAX_NEW_L2_TO_L1_MSGS_PER_TX = 2;
-global MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX = 16;
-global MAX_NEW_CONTRACTS_PER_TX = 1;
-global NUM_ENCRYPTED_LOGS_HASHES_PER_TX = 1;
-global NUM_UNENCRYPTED_LOGS_HASHES_PER_TX = 1;
+global MAX_NEW_NOTE_HASHES_PER_TX: u64 = 64;
+global MAX_NEW_NULLIFIERS_PER_TX: u64 = 64;
+global MAX_NEW_L2_TO_L1_MSGS_PER_TX: u64 = 2;
+global MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX: u64 = 16;
+global MAX_NEW_CONTRACTS_PER_TX: u64 = 1;
+global NUM_ENCRYPTED_LOGS_HASHES_PER_TX: u64 = 1;
+global NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: u64 = 1;
 global NUM_FIELDS_PER_SHA256 = 2;
 global CALLDATA_HASH_INPUT_SIZE = 169;
 global CALL_DATA_HASH_LOG_FIELDS = 4;
@@ -30,7 +30,7 @@ impl NewContractData {
 }
 
 struct DataToHash {
-    new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_TX],
+    new_note_hashes: [Field; MAX_NEW_NOTE_HASHES_PER_TX],
     new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_TX],
     public_data_update_requests: [PublicDataUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX],
     new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_TX],
@@ -101,7 +101,7 @@ impl U256 {
 unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA256] {
     let mut calldata_hash_inputs = [0; CALLDATA_HASH_INPUT_SIZE];
 
-    let new_commitments = kernel_data.new_commitments;
+    let new_note_hashes = kernel_data.new_note_hashes;
     let new_nullifiers = kernel_data.new_nullifiers;
     let public_data_update_requests = kernel_data.public_data_update_requests;
     let newL2ToL1msgs = kernel_data.new_l2_to_l1_msgs;
@@ -110,10 +110,10 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA
 
     let mut offset = 0;
 
-    for j in 0..MAX_NEW_COMMITMENTS_PER_TX {
-        calldata_hash_inputs[offset + j] = new_commitments[j];
+    for j in 0..MAX_NEW_NOTE_HASHES_PER_TX {
+        calldata_hash_inputs[offset + j] = new_note_hashes[j];
     }
-    offset += MAX_NEW_COMMITMENTS_PER_TX ;
+    offset += MAX_NEW_NOTE_HASHES_PER_TX ;
 
     for j in 0..MAX_NEW_NULLIFIERS_PER_TX {
         calldata_hash_inputs[offset + j] = new_nullifiers[j];
diff --git a/test_programs/execution_success/double_verify_nested_proof/Nargo.toml b/test_programs/execution_success/double_verify_nested_proof/Nargo.toml
new file mode 100644
index 00000000000..3ead649c879
--- /dev/null
+++ b/test_programs/execution_success/double_verify_nested_proof/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "double_verify_nested_proof"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.24.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/double_verify_nested_proof/Prover.toml b/test_programs/execution_success/double_verify_nested_proof/Prover.toml
new file mode 100644
index 00000000000..2a2b4b33586
--- /dev/null
+++ b/test_programs/execution_success/double_verify_nested_proof/Prover.toml
@@ -0,0 +1,5 @@
+key_hash = "0x13fd5b632ce9e9d12c9ac56c150ed09413df3edf40d1b7ab8ced9f262ec61b29"
+proof_b = ["0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf","0x00000000000000000000000000000000000000000000000b75c020998797da78","0x0000000000000000000000000000000000000000000000005a107acb64952eca","0x000000000000000000000000000000000000000000000000000031e97a575e9d","0x00000000000000000000000000000000000000000000000b5666547acf8bd5a4","0x00000000000000000000000000000000000000000000000c410db10a01750aeb","0x00000000000000000000000000000000000000000000000d722669117f9758a4","0x000000000000000000000000000000000000000000000000000178cbf4206471","0x000000000000000000000000000000000000000000000000e91b8a11e7842c38","0x000000000000000000000000000000000000000000000007fd51009034b3357f","0x000000000000000000000000000000000000000000000009889939f81e9c7402","0x0000000000000000000000000000000000000000000000000000f94656a2ca48","0x000000000000000000000000000000000000000000000006fb128b46c1ddb67f","0x0000000000000000000000000000000000000000000000093fe27776f50224bd","0x000000000000000000000000000000000000000000000004a0c80c0da527a081","0x0000000000000000000000000000000000000000000000000001b52c2020d746","0x0000000000000000000000000000004bdfb9b586a637ceebd99ff26dcd3af427","0x0000000000000000000000000000000000265c2a5caf8e033e32d192807f5353","0x000000000000000000000000000000c0ab1db6ea40ac087cdc82c4a61ab00c86","0x0000000000000000000000000000000000010800ea8010f4bd3dd432d1cc11ed","0x000000000000000000000000000000eb3db3c41e3e636d686fd2903b1b913a01","0x000000000000000000000000000000000009bbab6b90377114c9e33d2a302226","0x000000000000000000000000000000758726e60ef4b211cf1c965fe08293365b","0x0000000000000000000000000000000000290ec193bc7f4f9006b9cea136bff5","0x0000000000000000000000000000005a2a389cd1702b3aa37f30ed974147d343","0x00000000000000000000000000000000001d83087d6efe0db3f482730b8d5e32","0x000000000000000000000000000000ad015051ed84c11d061e63eddbc3c0417a","0x0000000000000000000000000000000000155011c8b0167ff694740c48d67683","0x00000000000000000000000000000010c638a3b13dba3e77be3f10a3d096927c","0x00000000000000000000000000000000002372b9853214a1f76e5636dc26f146","0x00000000000000000000000000000005d9ca201c07bd4216689677feb9227715","0x000000000000000000000000000000000001dcf09921797dffb8eb21abef187b","0x00000000000000000000000000000070af16c9644b777dcf84d69e820e1ed895","0x00000000000000000000000000000000002d5e8f7eb7a4e20964dd94dc141534","0x0000000000000000000000000000003636871dbe453b366c3351be6e84144683","0x0000000000000000000000000000000000206464e290e4f4764365038ac77edf","0x000000000000000000000000000000175c20da35cc833dd542af57de9b62a2da","0x00000000000000000000000000000000001d2e31de3715e05ff6278f88e5a0db","0x000000000000000000000000000000328610e4eabb48be78d3c75f7c159205c5","0x000000000000000000000000000000000026720634b8076fee0a17b358b04653","0x0000000000000000000000000000000e5f48906892ffbff91e8b58ceabba0949","0x000000000000000000000000000000000013c349df687926ccb712622fc72a36","0x000000000000000000000000000000a4b8c9046c7e7e4cc19bbf9a367668eac7","0x00000000000000000000000000000000002a81128e53672c33bb0dae0ff18f41","0x000000000000000000000000000000edb79df57c4a2303ed1e5c2d7ed1e1bdaf","0x000000000000000000000000000000000018d3cea4ce204eafd70c0ded024650","0x000000000000000000000000000000e5f82856854fe0a2d587f6a9ae8555f321","0x0000000000000000000000000000000000235480ec2adc05f04261054345e568","0x00000000000000000000000000000083607465f60b70b092f606853f4d9e96eb","0x000000000000000000000000000000000006569e3a3174bcb71efe46f7fb7e0f","0x000000000000000000000000000000cb4d5fc546f20f63e3b7cf60341956f36f","0x00000000000000000000000000000000000e14b1932630bf606a637eabb7c80f","0x000000000000000000000000000000786f31c2e082aa7e398e6323bb48a27472","0x00000000000000000000000000000000002dd72746f5e5a4a438def122ae6bba","0x000000000000000000000000000000d007be60a28b744e49279fab277c8bd623","0x00000000000000000000000000000000000e52e2b940b9cd8d001209cc40f7c8","0x000000000000000000000000000000dd4357e24a1bda0b5a6c5eee657cfe9091","0x0000000000000000000000000000000000047bb24b20feb0b66089a96671c901","0x0000000000000000000000000000003fe7f42f34e3360ef0fa8bd9c17e6190a3","0x0000000000000000000000000000000000161d17a3848118e91b435b553d34e9","0x216fa2905e105e0c767687f9b5e81c2e4ce03abe2993ac8dcd9e8d89e088966f","0x1288ba942d41c7f4b048e125454253bc7d7ffc0875365c0b8f75a2bb3ea90b42","0x1ad706f84cffcc62fa030f1bc57cb478a687aa74c1019beeda9bab4e40d35373","0x03050c8016b8041a557a46840ab4166a9c2531eb7c3985a447996a334e0caf5f","0x2b3c485da75bdaef8cec120bd08bc21e3ff717740114d13d3811006215a1fb24","0x008fc8c76c4d8cbba8653bf0919c047d379941be60c7afc7250bc6bfc5f29ad5","0x1993ae2a0da54e5e643533fdefbf54a0df21115b2ee79a63a7f477c2c9c4a5d5","0x22520fa7fde2d72b9776c07c9b897ef7ce48f8a7937ec0cacb01d3e23f72b78a","0x259b7b9c1dbfe88d613102f0e8548f0c770a1c83876b26a5cb4b6790740cb487","0x043006102e519b8011d089f51811337fbdedc856a73842f7c8197be176b08d38","0x2222bd509df909ce38b67b3172b24c8ce1e0e1dd0d811f4fae6957e3418415ac","0x1b1204474652fa85979f0274145680718bed80466f4c91ad58f37df1b4fe2395","0x08d57251b42c0697535617ae239d7f3ef9d1558c1bb71fa01c68e7b5fd266139","0x04ca7f21f1d0ba50ecf00c615d18bf8f7291bb04f513cbef78fb6d03ed9b0cb2","0x070ae1119c80846863a4cd971e535ff87fe34473eb5730b14e5b30212b7b78a1","0x1128027ded5032cc265c96ff81d76e2ce06420702fd4e5bc4e24fda695961651","0x1ef7a9e5885b934eee2b44335157309de2f60519e50a8471e5e24495dff2a9fe","0x2d0dad89e5633da796c0c897804575879bc5dc7ad3805b44260943101ac9609e","0x287edcbd60e9d636ba1cd1c9ff3ec2b71b694112c65876525f5e2f8209cd747f","0x24b1157a1cb5bdbd2829de066b8c5573584f9b8638bf9bad476a1fe1172da4b9","0x1f9825731638cd1c43f7cf035b808a1704f122453318cb88fe3b1164f034e170","0x07003a6552f3a6ab1ad3e0717be0af049767b554ff88986c4e48224632523405","0x288002c2ff29874077b2c216a35cb61ecc97d12750a3a86574d50acd42607095","0x0a12fc37918ce7dcbd0d354a05bdbb409a8e4530d86f3d8ce07231240590f65c","0x2ec631b05fc693b07286eecf6b6ac1aef0d073cdced8e050244ec7cf4e8f6e42","0x107bc98da225efe7749d51b9966c3edd6c245f2e5cf183a924ba982817e4525a","0x2ca603f77ea0ca42b6f38cd43bc3cc09442906373a2f197fdc976533066ac343","0x138ace5653809375aa9d95240fa9b6508860a471aed70bcc8b7dd52ae34809f3","0x21e1eb924951881c3d0ce5657d2e26a3e5150ce8f49c9e4d0476c5fdf1e43a54","0x2e2daec93f5e94f6784ce569883cf285da12244b38fb001b94bfb99bb4de060c","0x186a8d30c973bef6286115865a690a2528adbeea8376e5221fffeb6a135d9904","0x1e0d9d90628be31ebc16ef1d85d5f9e6fb8cb57e6a74e576f958cf21db45042e","0x124ceb5e1d9da6d0fe163e961643bb0423c926ef4e0c583eaba9e32d99ec6c7c","0x2db34cc38a50bfea50750830710c13b4d80f4ec0e8df8f186047ee36f338eeeb","0x0b174aa403b42235d5bdde8e9f5bb6c52ae62fec2884334cbe3e53418bd2463d","0x1571ebd9c3854c2f63418f206c6937495450ab9238a238b9c63fbf5867378c5b","0x24f92d1ab27e5810e5b7f4b31254526822f866602922258135c5eb5a2b21ca04","0x20cc7f5ba8df67d9c95642e2662654eb2305c6a280ce1747aec88a581ee50647","0x24112b99f63bbda7487709396dff22aae89ae809263021b65503ff7f809c7e38","0x06805c80f64efd1fa7f08382c9981aad9cecad78808da670477566674141bc48","0x146d4801d6f5898051ee0d7c95375a65ea0e6deeac6ffee1d9b9cf64da72dc3e","0x000000000000000000000000000000425b99a5c96b22ba0286d9ebeecf8e4559","0x0000000000000000000000000000000000110be4b8fe46a96303c205d3a1d61d","0x000000000000000000000000000000d9ff7ae757f2f0c91d1f1e71fac1b27b74","0x000000000000000000000000000000000009b0c285f6c221f6eba93b1e330ac4","0x0000000000000000000000000000004055cd5738a25ab1860a1e35555962dc19","0x00000000000000000000000000000000001a8726ccf54e17cf1b005e3e04879a","0x0000000000000000000000000000007be4dc343e9c2e0d4a9156f1ef9769f65a","0x00000000000000000000000000000000002b0e96f68f6509615ca0544dfa3107"]
+public_inputs = ["0x0000000000000000000000000000000000000000000000000000000000000003"]
+verification_key = ["0x2260e724844bca5251829353968e4915305258418357473a5c1d597f613f6cbd","0x0000000000000000000000000000000000000000000000000000000000080000","0x0000000000000000000000000000000000000000000000000000000000000005","0x0000000000000000000000000000000000000000000000000000000000080000","0x0000000000000000000000000000000000000000000000000000000000000011","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000003","0x0000000000000000000000000000000000000000000000000000000000000004","0x0000000000000000000000000000000000000000000000000000000000000005","0x0000000000000000000000000000000000000000000000000000000000000006","0x0000000000000000000000000000000000000000000000000000000000000007","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000009","0x000000000000000000000000000000000000000000000000000000000000000a","0x000000000000000000000000000000000000000000000000000000000000000b","0x000000000000000000000000000000000000000000000000000000000000000c","0x000000000000000000000000000000000000000000000000000000000000000d","0x000000000000000000000000000000000000000000000000000000000000000e","0x000000000000000000000000000000000000000000000000000000000000000f","0x0000000000000000000000000000000000000000000000000000000000000010","0x000000000000000000000000000000ba765ed919550454064328e0fd7c51ff4a","0x00000000000000000000000000000000000418b2f4104c289eb20cb95344c850","0x0000000000000000000000000000006defa500aab13c8cf3c00117db573bef2c","0x000000000000000000000000000000000026dea3ea8fb7e77b5bfa8443397dc7","0x0000000000000000000000000000009a5c33c4054817f3402e68aeca4728a405","0x00000000000000000000000000000000002abf5ea67ec384cb2e5998c7a48b3a","0x000000000000000000000000000000ee78817f7d959ea45abb27404e3371c708","0x0000000000000000000000000000000000260a979e8190a83b0bce1351b92d3c","0x000000000000000000000000000000ec447bd83a83883ce4c11573ce24845c74","0x000000000000000000000000000000000005b23c2076f50d10baa061a67b9200","0x00000000000000000000000000000058ffc16cfb64ec06a56a2b1a9047fb8f0c","0x000000000000000000000000000000000011d2f5833d720e1d0a02749471e7ad","0x000000000000000000000000000000416dd6c8c0d1cbb185b3c3197eac767d0b","0x000000000000000000000000000000000023b9c5a4e525926d64247ec92e0baf","0x000000000000000000000000000000a55f5f52ebc8936a58e413a1068d94d376","0x00000000000000000000000000000000000be3f377ccc88a6cb5df6f230da95e","0x00000000000000000000000000000070a162a08d4d4800f450af94888f8f3480","0x0000000000000000000000000000000000085883b02590372a7b36a1c57db4c3","0x00000000000000000000000000000045b0b661ea73930ee3327ccff8a0ca9ce1","0x00000000000000000000000000000000002854cab8629792eb07e9ef81bc46ee","0x00000000000000000000000000000067f365021e0e42117c43a39419d1d9cc73","0x000000000000000000000000000000000022c370b38f0a97eb3d718146f2284b","0x00000000000000000000000000000016de6670aba605233072b8eecfa9069b06","0x000000000000000000000000000000000002c29c49d66457bcbd4fa5bf6096fd","0x000000000000000000000000000000e32e8ce4f18ba30ce53245044d0c60508a","0x00000000000000000000000000000000001170220489121b8eedd58a4b5599df","0x000000000000000000000000000000139ed828b410380d053ec0f056656f5703","0x0000000000000000000000000000000000072aebdce25ba333c86769adec1362","0x000000000000000000000000000000aa352ee565f91fc2b73323fc824bc14636","0x00000000000000000000000000000000001f3e272a192808ec9283ee3bb4df4b","0x00000000000000000000000000000005c72c8c88be0259ae226ccb0488452b4b","0x00000000000000000000000000000000001c68407d694502b929b77cbbab8374","0x0000000000000000000000000000003716bda8267f29931ed0aa811e4607f1c6","0x000000000000000000000000000000000007d888936af2141bb2f6823a587e81","0x0000000000000000000000000000004cf1a4f39c5363f70ecc9e433d751ea529","0x00000000000000000000000000000000002e8a81232ec84e48032178f1ee6edb","0x000000000000000000000000000000388e8265061fa0c92c96fc85d99bac7891","0x00000000000000000000000000000000002e3c516222565332e6e7362400bc5f","0x0000000000000000000000000000003a68d13661a0906e5828fe8271a336bf64","0x00000000000000000000000000000000001412d3e67497c98e5ec2aaee8779f5","0x000000000000000000000000000000b5d123498733b5279d8bcbade0d8345ef7","0x00000000000000000000000000000000000fa572890537089a5fb36953e7a1ca","0x0000000000000000000000000000004d8ff057fc9936a693035266c80c6ea57d","0x00000000000000000000000000000000001907a614968d777fcc506f639799f6","0x00000000000000000000000000000010769533212d3cafbf6ac378c8055c33a2","0x00000000000000000000000000000000000eac32851272327acdc0890792dfb7","0x000000000000000000000000000000e3e32f343643d319a977beb0c2b0ab9b31","0x00000000000000000000000000000000000c10c4c9dce6ff648ef70f54d45ba6","0x00000000000000000000000000000025721304165b9b313b94cf2c77b61dc1ef","0x000000000000000000000000000000000024b8083b0f323c2703a7255caa7078","0x0000000000000000000000000000002b860372c65049c88f6532cbd360917b11","0x000000000000000000000000000000000011ee2ac2bc36cdfdc107eca47369f3","0x0000000000000000000000000000001c1b0233882acb5a78a977642e4dce91d5","0x000000000000000000000000000000000020922a70853993b3516eeb01d7c8a4","0x0000000000000000000000000000001f90b5fade69a55a2da8d2db3c62b62d7c","0x0000000000000000000000000000000000173312bb89c6722b548ff87a7487a2","0x0000000000000000000000000000009d618ffd933cf58a8a0953dc76f97cf108","0x00000000000000000000000000000000000ddc3b6d8e59cf0996ca71ad4132ca","0x000000000000000000000000000000ec4c6a253f431d3f3fc06aa0e5b0448b8c","0x0000000000000000000000000000000000153193287060386695f4f2d0d3525d","0x0000000000000000000000000000004bd25585edb9319128045c005d48491b1e","0x00000000000000000000000000000000001170f0ece62f8c572bca96b141d27f","0x0000000000000000000000000000003dd2e37b8edb1f56b785809d7710bf1c88","0x0000000000000000000000000000000000246cd041690f653f88ed0c56ad282a","0x00000000000000000000000000000034bc8a00ce9d452888e5fc2b5a7e14fed7","0x000000000000000000000000000000000026153c937447356a0c6d6be09d85eb","0x000000000000000000000000000000555388ad9364679246b07992f84b4e91b2","0x0000000000000000000000000000000000189da022421fbd8dfd7973084d978e","0x000000000000000000000000000000e8c0f9753e2a5a35acec051fafe2cecce5","0x0000000000000000000000000000000000285311c5e9a4cbb56a3f04f29d5443","0x00000000000000000000000000000092d2d0ac76a1be7f1fad96cbd997175312","0x00000000000000000000000000000000002436400260c9d3180beedd0bf49fec","0x000000000000000000000000000000887d86d95387bbb29616cc5c41ee4a2669","0x0000000000000000000000000000000000063bf32f8addf7a3e1cf6cd223cb71","0x000000000000000000000000000000d841dc7d9da6cc699e8377b2a04723fea0","0x00000000000000000000000000000000002ce091428268c212a2bcfea0edb338","0x00000000000000000000000000000012fe4771092fa47e4d6050701527133f09","0x00000000000000000000000000000000002f36672865c5ae4976486fdaf2d81d","0x0000000000000000000000000000008e6bced56a3d94dfe9d476da3a424b8eff","0x00000000000000000000000000000000002d6303cf28aa721f4e5348a0d83642","0x0000000000000000000000000000008c5807dace05b2079d200f7f71caffdaf7","0x000000000000000000000000000000000008f7beb50cb16f3b6210aff1bdb05d","0x0000000000000000000000000000004f9ee08a49536eb54a238b982c4dfd5446","0x000000000000000000000000000000000014f55e7065eabacf1a7d6cbf1f6765","0x00000000000000000000000000000021150153ec654b02a66d9bea056185877e","0x00000000000000000000000000000000000e7bf50a142b21057bcfd340a5e77c","0x00000000000000000000000000000038110629263a662f10464b375f988cccda","0x00000000000000000000000000000000001964a0ab814f71282cd159df492710","0x000000000000000000000000000000b9310dd49ea52ba735b9654ebced7bc67b","0x000000000000000000000000000000000019ad72f92554ce44921ca3f420f995","0x000000000000000000000000000000d67d7e81fa6e1cdfae6d84510a8cb7e257","0x00000000000000000000000000000000000a6ec9d85c10a85e8f31eaedb4e459"]
+proof = ["0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf","0x00000000000000000000000000000000000000000000000b75c020998797da78","0x0000000000000000000000000000000000000000000000005a107acb64952eca","0x000000000000000000000000000000000000000000000000000031e97a575e9d","0x00000000000000000000000000000000000000000000000b5666547acf8bd5a4","0x00000000000000000000000000000000000000000000000c410db10a01750aeb","0x00000000000000000000000000000000000000000000000d722669117f9758a4","0x000000000000000000000000000000000000000000000000000178cbf4206471","0x000000000000000000000000000000000000000000000000e91b8a11e7842c38","0x000000000000000000000000000000000000000000000007fd51009034b3357f","0x000000000000000000000000000000000000000000000009889939f81e9c7402","0x0000000000000000000000000000000000000000000000000000f94656a2ca48","0x000000000000000000000000000000000000000000000006fb128b46c1ddb67f","0x0000000000000000000000000000000000000000000000093fe27776f50224bd","0x000000000000000000000000000000000000000000000004a0c80c0da527a081","0x0000000000000000000000000000000000000000000000000001b52c2020d746","0x00000000000000000000000000000063cb03b1d83ae3942e11ca8ec63055898b","0x00000000000000000000000000000000001edaf70d547a857fbed6a9ff8a38c9","0x000000000000000000000000000000097fb881332193ff4489e213f600e6a007","0x00000000000000000000000000000000001f2903742639c3595d22b96d4d9c21","0x000000000000000000000000000000bca7215bb1bcdde52ed9cf845b7e54072d","0x0000000000000000000000000000000000188bd12b19073eb01e8be5bda41b3e","0x0000000000000000000000000000007d1a114656606c391bfb286ea4e14062a5","0x000000000000000000000000000000000026d8a3b8821da41b6b1d6b85872260","0x000000000000000000000000000000c49078b857741b82cba39d8a394c1876c1","0x00000000000000000000000000000000002f9b9f76f80a4ff456e60c024f8d03","0x0000000000000000000000000000004bab3e60680935219213ea32be70ec5100","0x00000000000000000000000000000000002c45bda56f0115cfde2678889694ab","0x0000000000000000000000000000006434e56313172088d5a6b10fdd1b94b4ca","0x000000000000000000000000000000000007ad41e7980534fc2f89e8ad7366ad","0x00000000000000000000000000000023d769c68ef65f0b4f06a01e655fb265e7","0x0000000000000000000000000000000000008d3b5d5b201ed6773c369fe20d10","0x0000000000000000000000000000005eacdd2121ba4b1cf0df09632df6991fcf","0x0000000000000000000000000000000000005e98e857c8c1eb16cef913e44f90","0x0000000000000000000000000000003449da35dc7c0b67b0c3e99ced603ea381","0x000000000000000000000000000000000022347c8daec6739b183413a787fd13","0x000000000000000000000000000000df23d8f1ac4ddfced428737db15e63f603","0x000000000000000000000000000000000015e03670ba72d84269d764d8f8e725","0x000000000000000000000000000000457a7f854dbab545c8c94ccdb8e4b9ad45","0x00000000000000000000000000000000000a268fc41b7031912cec59dc0a7078","0x00000000000000000000000000000022fcb55824b67af33225f8f2e614fbbdb4","0x0000000000000000000000000000000000235f698e6aee7bf8ca94f4a44db006","0x000000000000000000000000000000a327da390bd3e01e4a7b639605fdfd9c42","0x0000000000000000000000000000000000210196c4fb53d660a3824867b2b1c5","0x000000000000000000000000000000728fb44750fa2b956221bd441fa61e32d6","0x0000000000000000000000000000000000073db9e2cafdf0fe22b5090855533e","0x0000000000000000000000000000004fe310e93730876891eebab46db9496dbc","0x000000000000000000000000000000000007d3574fe79c87011abdbd51a46670","0x000000000000000000000000000000adc522f42e085c51403fc50c83f35904b9","0x00000000000000000000000000000000000d2d9ef8fc0031b4568842a99b34eb","0x00000000000000000000000000000098586d928c8abc7cc56d571c8eded52168","0x000000000000000000000000000000000024279c001a40e94d3d149ec01a468a","0x00000000000000000000000000000066122aaf47d9d5060a2ce1d17cc5201be0","0x00000000000000000000000000000000001c21031d83d52e27867a611229d2ca","0x000000000000000000000000000000838dfc066499f7715682f755b42f3a4869","0x00000000000000000000000000000000001f816d2c5b2e903496f1443cb91de3","0x0000000000000000000000000000007ef917b6df805f430f8a0833942a7c3094","0x00000000000000000000000000000000000a9cefe716f31dbe37485179d60f0e","0x00000000000000000000000000000028adb1040bd0c07448de51d5cac9fd0495","0x00000000000000000000000000000000000c66b25a22c8b3ba82ec09ab4bdef3","0x2cc791d253f03f47cc88f7f0aeae481762f4aa6426712772544aaeca72466cb7","0x14197950f448f679eeff75c4e83dac9f0ebd5aa194709ea3875fb4e4b15bc2f2","0x1a92022c2ed8f8a41e3f392e22f1875f6916543bbb22c3aaf50d703de649c381","0x2ee77a26e78d5e1093dabd3612beee4b515a4f159992138e13ecd3f0afcfba18","0x2c280cba627b147142a2d333ee856000298708f9b5df0cc8d23c26d0936d6869","0x1b2569bb6f6b60b6f743ff892a39a490770d4ad40a961a06149d4968b0487a40","0x2f80351e43621d69b7e620338b2822e15dec9e6a2de16e8d04bb559153cd53a3","0x15a78b8ae9b3be431b609250b69c7cb746c6a689b2122150f258c6f7d67409fc","0x1334c47f273be542576813933e89a9130a342846272b39a2eab3ab7fc022d5fe","0x1031bdcafc5c0dad81c8b6c4931c9b442cd0c8a0bb9a729cc2f6bf0a18dc1b82","0x177f92f0cef76c5c45f55d16fa2be426354cdd4af6ac9aaad479c9b47f88656d","0x0064c0e0ec8984d612189e5287d59eedc1a6de52fc78bf72028f744350c27a0e","0x2c06222cf0d415c976e6904f1706b77cf438636ada3222e1c31c4957d6877dac","0x173da534b7001f44f19bb3e3f8601ac94fbf90b2e39b7d4079d8fac2d65102ea","0x012909bcdbd1167010cf0084028e851f3448f58946f4951b1b8d544d86b138c8","0x2975c3987f110c06bd8ced1d8bb0d398ac72c6f196ea639bdde58fa4b899d4a0","0x05c196fb2f6ccfd92a38ae526af85bccc3695ea0e2561e7a211c60360187602d","0x18a288590dd0cbfe5b7652458c9caddc9eac2f08e5822b64141ed1b4e805bda3","0x0cd08c41605b22a7ae31c3961486f645a32bff0ccaef63b6d661ef356db78560","0x05d5e48184693259f722f84ea48f9b84667d1e9db19e1381b2279fe24b01484b","0x2187a6f6a2398e5f0137880a983ff6b682b5a7c2b62e4bdfff6ff6becd0d53ab","0x1d4764ca9346e8ac48675320521e0daba651f480efe932302e8a9673580fc0d8","0x00cfcb920adeb0293acf26e63aeac4489622e4c806b93f1c72f8491cba3d0196","0x1bcd6a556800b8385ba1250afd69999fe2bb5518a6ba2cc461a4afba21ffbedb","0x11a15b3c8ef0e4ac0ff151fba72b922f6c005519151a4f88557352265944aeea","0x063d550a154f2ce80b08fb169d137fa96dcea6a6c489e98e1390aa9a5db18928","0x25da993132041b9f667de044194f5c6b0cdae961cdea5f6dbbda8595f213ac08","0x22fcecc2e3794814bbb84700031cd75ec9817201c8c88df2e86407a14412f902","0x01583d25d2f91d646da02a520d3dbf758b0a0590a533bd1417a717fd0cd18915","0x18ebacffdc81e15547232dfc1a0e31ec2848a1e5b9c8509a92432c2549d93091","0x20a3d15aa70d04a841802fe1d990f56c6b9e6eadc17da2c0dfd2a817e6cf0430","0x0b497cc2e54412ce07c52effdce6c01de2c1a0e1d095a2a37f5351232400c0a1","0x14419bb69d02675b8d58e60ce88a2f4b6a43674461e4015e2e302285a42c5784","0x0c84db03ff77d0729bb68eab2d6d697b7caebd4ea3db781499492a6f0ef67765","0x1a676b1c6b0ab1c85b31af681e05751296c3d0a1a883668f5fe971827ce86fc9","0x08da949bf7603bfe20f3c152abe727051c6306cff322197e8fa56b390f565b5b","0x1fd77e041239f94e907dc3ae3069a70cbff726b9d8b3a368a4910c8a070a9c9a","0x03755d83a4f0fdfbb4fd1b2b465842e1bb707a419c2952a2ca9faba50d4be379","0x0ee90c8166adcb238d85c72a85db2248353610c55390a2ed54e59dd1c35c12d2","0x170bcd78efaa1b19bcfd065c2ec60b48aa1e62465df73e62f3bd291115315144","0x015d60e5cc5c7d67853993261bd9e3c6e56f95dee8724ce79c7601ee10c1a731","0x000000000000000000000000000000f0a8b99d65fc1555bafb688233a6489aea","0x0000000000000000000000000000000000043849f038ec96c8c1c6e242351361","0x0000000000000000000000000000001ad41d3dfebb280623d5b325f0a7aa38f7","0x00000000000000000000000000000000002e5f2119536daa9e6d1f9b82b797dd","0x000000000000000000000000000000e5570c2b6e74d0994e2fc8be1a9dab4160","0x00000000000000000000000000000000002ed426a78ed52d4c13f2c651a6d4ec","0x000000000000000000000000000000aba14637487e4d3ca30dc397416696c85c","0x000000000000000000000000000000000005ae1eb3eee0cdf5e5c7bb0ac9be07"]
diff --git a/test_programs/execution_success/double_verify_nested_proof/src/main.nr b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
new file mode 100644
index 00000000000..0466f2a226d
--- /dev/null
+++ b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
@@ -0,0 +1,28 @@
+use dep::std;
+
+fn main(
+    verification_key: [Field; 114],
+    // This is the proof without public inputs attached.
+    // 
+    // This means: the size of this does not change with the number of public inputs.
+    proof: [Field; 109],
+    public_inputs: pub [Field; 1],
+    // This is currently not public. It is fine given that the vk is a part of the circuit definition.
+    // I believe we want to eventually make it public too though.
+    key_hash: Field,
+    proof_b: [Field; 109]
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
diff --git a/test_programs/execution_success/double_verify_proof/src/main.nr b/test_programs/execution_success/double_verify_proof/src/main.nr
index ce087dc4e61..e4c6926efbc 100644
--- a/test_programs/execution_success/double_verify_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof/src/main.nr
@@ -1,12 +1,13 @@
 use dep::std;
 
+#[recursive]
 fn main(
     verification_key: [Field; 114],
     // This is the proof without public inputs attached.
     // 
     // This means: the size of this does not change with the number of public inputs.
     proof: [Field; 93],
-    public_inputs: [Field; 1],
+    public_inputs: pub [Field; 1],
     // This is currently not public. It is fine given that the vk is a part of the circuit definition.
     // I believe we want to eventually make it public too though.
     key_hash: Field,
diff --git a/test_programs/execution_success/regression_4124/src/main.nr b/test_programs/execution_success/regression_4124/src/main.nr
index b47bf28d461..49ff68ee6ad 100644
--- a/test_programs/execution_success/regression_4124/src/main.nr
+++ b/test_programs/execution_success/regression_4124/src/main.nr
@@ -14,14 +14,14 @@ pub fn storage_read<N>() -> [Field; N] {
     dep::std::unsafe::zeroed()
 }
 
-struct PublicState<T> {
+struct PublicMutable<T> {
     storage_slot: Field,
 }
 
-impl<T> PublicState<T> {
+impl<T> PublicMutable<T> {
     pub fn new(storage_slot: Field) -> Self {
         assert(storage_slot != 0, "Storage slot 0 not allowed. Storage slots must start from 1.");
-        PublicState { storage_slot }
+        PublicMutable { storage_slot }
     }
 
     pub fn read<T_SERIALIZED_LEN>(_self: Self) -> T where T: MyDeserialize<T_SERIALIZED_LEN> {
@@ -32,7 +32,7 @@ impl<T> PublicState<T> {
 }
 
 fn main(value: Field) {
-    let ps: PublicState<Field> = PublicState::new(27);
+    let ps: PublicMutable<Field> = PublicMutable::new(27);
 
     // error here
     assert(ps.read() == value);
diff --git a/test_programs/gates_report.sh b/test_programs/gates_report.sh
index 4192c581376..3b0b4d9e148 100755
--- a/test_programs/gates_report.sh
+++ b/test_programs/gates_report.sh
@@ -2,7 +2,7 @@
 set -e
 
 # These tests are incompatible with gas reporting
-excluded_dirs=("workspace" "workspace_default_member")
+excluded_dirs=("workspace" "workspace_default_member" "double_verify_nested_proof")
 
 # These tests cause failures in CI with a stack overflow for some reason.
 ci_excluded_dirs=("eddsa")
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 7ac440c335b..c472e828739 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -7,6 +7,7 @@ brillig_nested_arrays
 brillig_references
 brillig_to_bytes_integration
 debug_logs
+double_verify_nested_proof
 double_verify_proof
 modulus
 nested_array_dynamic
diff --git a/tooling/nargo_fmt/tests/expected/contract.nr b/tooling/nargo_fmt/tests/expected/contract.nr
index b80efeeb692..a03b8774700 100644
--- a/tooling/nargo_fmt/tests/expected/contract.nr
+++ b/tooling/nargo_fmt/tests/expected/contract.nr
@@ -10,14 +10,14 @@ contract Benchmarking {
     use dep::aztec::{
         context::{Context},
         note::{utils as note_utils, note_getter_options::NoteGetterOptions, note_header::NoteHeader},
-        log::emit_unencrypted_log, state_vars::{map::Map, public_state::PublicState, set::Set},
+        log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
         types::address::{AztecAddress}
     };
 
     struct Storage {
-        notes: Map<AztecAddress, Set<ValueNote, VALUE_NOTE_LEN>>,
-        balances: Map<AztecAddress, PublicState<Field, FIELD_SERIALIZED_LEN>>,
+        notes: Map<AztecAddress, PrivateSet<ValueNote, VALUE_NOTE_LEN>>,
+        balances: Map<AztecAddress, PublicMutable<Field, FIELD_SERIALIZED_LEN>>,
     }
 
     impl Storage {
@@ -26,12 +26,12 @@ contract Benchmarking {
                 notes: Map::new(
                     context,
                     1,
-                    |context, slot| { Set::new(context, slot, ValueNoteMethods) }
+                    |context, slot| { PrivateSet::new(context, slot, ValueNoteMethods) }
                 ),
                 balances: Map::new(
                     context,
                     2,
-                    |context, slot| { PublicState::new(context, slot, FieldSerializationMethods) }
+                    |context, slot| { PublicMutable::new(context, slot, FieldSerializationMethods) }
                 )
             }
         }
@@ -74,17 +74,6 @@ contract Benchmarking {
     fn broadcast(owner: Field) {
         emit_unencrypted_log(&mut context, storage.balances.at(owner).read());
     }
-
-    unconstrained fn compute_note_hash_and_nullifier(
-        contract_address: AztecAddress,
-        nonce: Field,
-        storage_slot: Field,
-        note_type_id: Field,
-        preimage: [Field; VALUE_NOTE_LEN]
-    ) -> [Field; 4] {
-        let note_header = NoteHeader::new(contract_address, nonce, storage_slot);
-        note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage)
-    }
 }
 
 // Uses the token bridge contract, which tells which input token we need to talk to and handles the exit funds to L1 
diff --git a/tooling/nargo_fmt/tests/input/contract.nr b/tooling/nargo_fmt/tests/input/contract.nr
index d10bfb745b6..a03b8774700 100644
--- a/tooling/nargo_fmt/tests/input/contract.nr
+++ b/tooling/nargo_fmt/tests/input/contract.nr
@@ -5,30 +5,34 @@
 contract Benchmarking {
     use dep::aztec::protocol_types::abis::function_selector::FunctionSelector;
 
-    use dep::value_note::{
-        utils::{increment, decrement},
-        value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},
-    };
+    use dep::value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
 
     use dep::aztec::{
         context::{Context},
         note::{utils as note_utils, note_getter_options::NoteGetterOptions, note_header::NoteHeader},
-        log::emit_unencrypted_log,
-        state_vars::{map::Map, public_state::PublicState, set::Set},
+        log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
-        types::address::{AztecAddress},
+        types::address::{AztecAddress}
     };
 
     struct Storage {
-        notes: Map<AztecAddress, Set<ValueNote, VALUE_NOTE_LEN>>,
-        balances: Map<AztecAddress, PublicState<Field, FIELD_SERIALIZED_LEN>>,
+        notes: Map<AztecAddress, PrivateSet<ValueNote, VALUE_NOTE_LEN>>,
+        balances: Map<AztecAddress, PublicMutable<Field, FIELD_SERIALIZED_LEN>>,
     }
 
     impl Storage {
         fn init(context: Context) -> pub Self {
             Storage {
-                notes: Map::new(context, 1, |context, slot| { Set::new(context, slot, ValueNoteMethods) }),
-                balances: Map::new(context, 2, |context, slot| { PublicState::new(context, slot, FieldSerializationMethods) }),
+                notes: Map::new(
+                    context,
+                    1,
+                    |context, slot| { PrivateSet::new(context, slot, ValueNoteMethods) }
+                ),
+                balances: Map::new(
+                    context,
+                    2,
+                    |context, slot| { PublicMutable::new(context, slot, FieldSerializationMethods) }
+                )
             }
         }
     }
@@ -70,17 +74,6 @@ contract Benchmarking {
     fn broadcast(owner: Field) {
         emit_unencrypted_log(&mut context, storage.balances.at(owner).read());
     }
-
-    unconstrained fn compute_note_hash_and_nullifier(
-        contract_address: AztecAddress,
-        nonce: Field,
-        storage_slot: Field,
-        note_type_id: Field,
-        preimage: [Field; VALUE_NOTE_LEN]
-    ) -> [Field; 4] {
-        let note_header = NoteHeader::new(contract_address, nonce, storage_slot);
-        note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage)
-    }
 }
 
 // Uses the token bridge contract, which tells which input token we need to talk to and handles the exit funds to L1 

From e80c5f73a4cdcba3f5cf44576c605ba1e611a2ab Mon Sep 17 00:00:00 2001
From: NaijaCoderGirl <150683513+NaijaCoderGirl@users.noreply.github.com>
Date: Tue, 27 Feb 2024 11:59:22 +0000
Subject: [PATCH 017/416] chore(docs): correct 'Edit this page' URL for dev
 docs (#4433)

# Description

## Problem*

The "Edit this page" button in the generated documentation for the
`noir-lang` project leads to a 404 - Page Not Found error for documents
in the development version. This issue is due to the button's link
containing `/processed-docs` in the path instead of `/docs`. The problem
affects the development version of the documentation, whereas versioned
documentation (e.g., v0.23.0) correctly links to editable markdown files
on GitHub.

| Before | After |
|
--------------------------------------------------------------------------------------------------
|
--------------------------------------------------------------------------------------------------
|
|
![Before](https://github.com/noir-lang/noir/assets/150683513/260f8eb5-4ef9-46db-ba39-ae836d2bb7de)
|
![After](https://github.com/noir-lang/noir/assets/150683513/087e2c8c-b9dc-4c35-b824-2b95742872f6)
|

## Summary*

This pull request fixes the incorrect URL generated for the "Edit this
page" button in the docusaurus configuration. By modifying the `editUrl`
function within `docusaurus.config.ts`, the path now correctly replaces
`processed-docs` with `docs` for the development version of the
documentation. This change guarantees that contributors are directed to
the correct GitHub page to edit the documentation, thus eliminating the
404 error previously encountered.

## Additional Context

The issue was identified when attempting to edit pages from the
development version of the docs. The button's link incorrectly pointed
to a non-existent path due to the inclusion of `processed-docs` in the
URL.

## Documentation*

- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 docs/docusaurus.config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts
index 1b6c65d5139..49566c5c380 100644
--- a/docs/docusaurus.config.ts
+++ b/docs/docusaurus.config.ts
@@ -38,7 +38,7 @@ export default {
             },
           },
           editUrl: ({ versionDocsDirPath, docPath }) =>
-            `https://github.com/noir-lang/noir/edit/master/docs/${versionDocsDirPath}/${docPath}`,
+            `https://github.com/noir-lang/noir/edit/master/docs/${versionDocsDirPath.replace('processed-docs', 'docs')}/${docPath}`,
         },
         blog: false,
         theme: {

From a25d5da32c1eb868fa400c61245edbd3db72ba3b Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 27 Feb 2024 08:33:39 -0500
Subject: [PATCH 018/416] feat: Sync from aztec-packages (#4438)

BEGIN_COMMIT_OVERRIDE
chore: bootstrap improvements.
(https://github.com/AztecProtocol/aztec-packages/pull/4711)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 bootstrap.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bootstrap.sh b/bootstrap.sh
index 1f9506904a4..54129c3d61a 100755
--- a/bootstrap.sh
+++ b/bootstrap.sh
@@ -16,7 +16,7 @@ if [ -n "$CMD" ]; then
 fi
 
 # Attempt to just pull artefacts from CI and exit on success.
-./bootstrap_cache.sh && exit
+[ -n "${USE_CACHE:-}" ] && ./bootstrap_cache.sh && exit
 
 ./scripts/bootstrap_native.sh
-./scripts/bootstrap_packages.sh
\ No newline at end of file
+./scripts/bootstrap_packages.sh

From a112b303650e71db7406011edde92942c571654e Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 27 Feb 2024 09:55:34 -0500
Subject: [PATCH 019/416] feat: Sync from aztec-packages (#4439)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

BEGIN_COMMIT_OVERRIDE
chore(aztec): Change function limit to private function limit
(https://github.com/AztecProtocol/aztec-packages/pull/4785)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Álvaro Rodríguez <sirasistant@gmail.com>
---
 .aztec-sync-commit                            |  1 +
 aztec_macros/src/lib.rs                       | 24 ++++++++++++++-----
 bootstrap_cache.sh                            |  2 --
 noir_stdlib/src/collections/map.nr            |  2 +-
 noir_stdlib/src/sha256.nr                     |  2 +-
 noir_stdlib/src/sha512.nr                     |  2 +-
 .../execution_success/regression/src/main.nr  |  6 ++---
 7 files changed, 25 insertions(+), 14 deletions(-)
 create mode 100644 .aztec-sync-commit

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
new file mode 100644
index 00000000000..9acc65d8b9c
--- /dev/null
+++ b/.aztec-sync-commit
@@ -0,0 +1 @@
+e69b58660ff843350e1e098d8f1a84f4ce3d3c34
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 0ccc421d3bc..156ba1d5b08 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -63,12 +63,12 @@ impl MacroProcessor for AztecMacro {
 }
 
 const FUNCTION_TREE_HEIGHT: u32 = 5;
-const MAX_CONTRACT_FUNCTIONS: usize = 2_usize.pow(FUNCTION_TREE_HEIGHT);
+const MAX_CONTRACT_PRIVATE_FUNCTIONS: usize = 2_usize.pow(FUNCTION_TREE_HEIGHT);
 
 #[derive(Debug, Clone)]
 pub enum AztecMacroError {
     AztecDepNotFound,
-    ContractHasTooManyFunctions { span: Span },
+    ContractHasTooManyPrivateFunctions { span: Span },
     ContractConstructorMissing { span: Span },
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
@@ -84,8 +84,8 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: None,
             },
-            AztecMacroError::ContractHasTooManyFunctions { span } => MacroError {
-                primary_message: format!("Contract can only have a maximum of {} functions", MAX_CONTRACT_FUNCTIONS),
+            AztecMacroError::ContractHasTooManyPrivateFunctions { span } => MacroError {
+                primary_message: format!("Contract can only have a maximum of {} private functions", MAX_CONTRACT_PRIVATE_FUNCTIONS),
                 secondary_message: None,
                 span: Some(span),
             },
@@ -456,10 +456,22 @@ fn transform_module(
     if has_transformed_module {
         // We only want to run these checks if the macro processor has found the module to be an Aztec contract.
 
-        if module.functions.len() > MAX_CONTRACT_FUNCTIONS {
+        let private_functions_count = module
+            .functions
+            .iter()
+            .filter(|func| {
+                func.def
+                    .attributes
+                    .secondary
+                    .iter()
+                    .any(|attr| is_custom_attribute(attr, "aztec(private)"))
+            })
+            .count();
+
+        if private_functions_count > MAX_CONTRACT_PRIVATE_FUNCTIONS {
             let crate_graph = &context.crate_graph[crate_id];
             return Err((
-                AztecMacroError::ContractHasTooManyFunctions { span: Span::default() },
+                AztecMacroError::ContractHasTooManyPrivateFunctions { span: Span::default() },
                 crate_graph.root_file_id,
             ));
         }
diff --git a/bootstrap_cache.sh b/bootstrap_cache.sh
index d06aa493662..1cec6c81d8e 100755
--- a/bootstrap_cache.sh
+++ b/bootstrap_cache.sh
@@ -1,8 +1,6 @@
 #!/usr/bin/env bash
 set -eu
 
-[ -z "${NO_CACHE:-}" ] && type docker &> /dev/null && [ -f ~/.aws/credentials ] || exit 1
-
 cd "$(dirname "$0")"
 source ../build-system/scripts/setup_env '' '' mainframe_$USER > /dev/null
 
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index d9eb83ff5dc..056299b4238 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -400,7 +400,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     // n * MAX_LOAD_FACTOR_DEN0MINATOR >= m * MAX_LOAD_FACTOR_NUMERATOR
     fn assert_load_factor(self) {
         let lhs = self._len * MAX_LOAD_FACTOR_DEN0MINATOR;
-        let rhs = self._table.len() as u64 * MAX_LOAD_FACTOR_NUMERATOR;
+        let rhs = self._table.len() * MAX_LOAD_FACTOR_NUMERATOR;
         let exceeded = lhs >= rhs;
         assert(!exceeded, "Load factor is exceeded, consider increasing the capacity.");
     }
diff --git a/noir_stdlib/src/sha256.nr b/noir_stdlib/src/sha256.nr
index 6bcc5ea74c6..2f686a64165 100644
--- a/noir_stdlib/src/sha256.nr
+++ b/noir_stdlib/src/sha256.nr
@@ -57,7 +57,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
             msg_block[i as Field] = 0;
             i = i + 1;
         } else if i < 64 {
-            let mut len = 8 * msg.len() as u64;
+            let mut len = 8 * msg.len();
             for j in 0..8 {
                 msg_block[63 - j] = len as u8;
                 len >>= 8;
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index 155ba593bba..4dfe78308e2 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -136,7 +136,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
             msg_block[i as Field] = 0;
             i += 1;
         } else if i < 128 {
-            let mut len = 8 * msg.len() as u64; // u128 unsupported
+            let mut len = 8 * msg.len();
             for j in 0..16 {
                 msg_block[127 - j] = len as u8;
                 len >>= 8;
diff --git a/test_programs/execution_success/regression/src/main.nr b/test_programs/execution_success/regression/src/main.nr
index c70e2e75fa8..c56f3ef4190 100644
--- a/test_programs/execution_success/regression/src/main.nr
+++ b/test_programs/execution_success/regression/src/main.nr
@@ -1,4 +1,4 @@
-global NIBBLE_LENGTH: Field = 16;
+global NIBBLE_LENGTH: u64 = 16;
 
 struct U4 {
     inner: u8,
@@ -21,8 +21,8 @@ impl Eq for U4 {
 }
 
 fn compact_decode<N>(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {
-    assert(2 * input.len() as u64 <= NIBBLE_LENGTH as u64);
-    assert(length as u64 <= input.len() as u64);
+    assert(2 * input.len() <= NIBBLE_LENGTH);
+    assert(length as u64 <= input.len());
 
     let mut nibble = [U4::zero(); NIBBLE_LENGTH];
 

From 97bcae2725fc59c7d4ce5212990a40fdcd993e53 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Tue, 27 Feb 2024 18:29:30 +0100
Subject: [PATCH 020/416] chore: address code review comments of PR4398 (#4435)

# Description

## Problem\*

Related to #4170, this PR address comments in PR #4398

## Summary\*

Add a comment and a sanity check.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acvm/src/pwg/blackbox/hash.rs | 12 +++++++++++-
 noir_stdlib/src/hash/poseidon2.nr       |  3 ++-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/acvm-repo/acvm/src/pwg/blackbox/hash.rs b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
index 1bc26f06188..24c835a636a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/hash.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
@@ -143,12 +143,22 @@ pub(crate) fn solve_poseidon2_permutation_opcode(
         return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
             acir::BlackBoxFunc::Poseidon2Permutation,
             format!(
-                "the number of inputs does not match specified length. {} > {}",
+                "the number of inputs does not match specified length. {} != {}",
                 inputs.len(),
                 len
             ),
         ));
     }
+    if len as usize != outputs.len() {
+        return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
+            acir::BlackBoxFunc::Poseidon2Permutation,
+            format!(
+                "the number of outputs does not match specified length. {} != {}",
+                outputs.len(),
+                len
+            ),
+        ));
+    }
 
     // Read witness assignments
     let mut state = Vec::new();
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 64c1876b4e2..40eea029e82 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -93,7 +93,8 @@ impl Poseidon2 {
     }
 
     fn hash_internal<N>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
-        let iv : Field = (in_len as Field) * 18446744073709551616;
+        let two_pow_64 = 18446744073709551616;
+        let iv : Field = (in_len as Field) * two_pow_64;
         let mut sponge = Poseidon2::new(iv);
         for i in 0..input.len() {
             if i as u32 < in_len {

From 9544813fabbd18a87dd88456e6a5b781bd0cf008 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 27 Feb 2024 22:12:59 +0000
Subject: [PATCH 021/416] chore!: reserve `unchecked` keyword (#4432)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

There's a decent chance that we're going to add some form of unchecked
maths in future so I'd like to reserve this keyword in preparation for
that.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/lexer/token.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index fe12132e202..5674ae5a39a 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -673,6 +673,7 @@ pub enum Keyword {
     Struct,
     Trait,
     Type,
+    Unchecked,
     Unconstrained,
     Use,
     Where,
@@ -715,6 +716,7 @@ impl fmt::Display for Keyword {
             Keyword::Struct => write!(f, "struct"),
             Keyword::Trait => write!(f, "trait"),
             Keyword::Type => write!(f, "type"),
+            Keyword::Unchecked => write!(f, "unchecked"),
             Keyword::Unconstrained => write!(f, "unconstrained"),
             Keyword::Use => write!(f, "use"),
             Keyword::Where => write!(f, "where"),
@@ -760,6 +762,7 @@ impl Keyword {
             "struct" => Keyword::Struct,
             "trait" => Keyword::Trait,
             "type" => Keyword::Type,
+            "unchecked" => Keyword::Unchecked,
             "unconstrained" => Keyword::Unconstrained,
             "use" => Keyword::Use,
             "where" => Keyword::Where,

From 9c2053879389af16167143eab2203c91375a249d Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 28 Feb 2024 07:19:24 -0500
Subject: [PATCH 022/416] feat: Sync from aztec-packages (#4444)

BEGIN_COMMIT_OVERRIDE
chore: remove original return from aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/4804)
END_COMMIT_OVERRIDE

---------

Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 .aztec-sync-commit      | 2 +-
 aztec_macros/src/lib.rs | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 9acc65d8b9c..c97738f7226 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-e69b58660ff843350e1e098d8f1a84f4ce3d3c34
+9e246c1289fa40c35c4b28d2f0081dfdc2aa9d19
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 156ba1d5b08..09deb2c9712 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -648,6 +648,10 @@ fn transform_function(
 
     // Abstract return types such that they get added to the kernel's return_values
     if let Some(return_values) = abstract_return_values(func) {
+        // In case we are pushing return values to the context, we remove the statement that originated it
+        // This avoids running duplicate code, since blocks like if/else can be value returning statements
+        func.def.body.0.pop();
+        // Add the new return statement
         func.def.body.0.push(return_values);
     }
 
@@ -1255,13 +1259,11 @@ fn create_avm_context() -> Result<Statement, AztecMacroError> {
 /// Any primitive type that can be cast will be casted to a field and pushed to the context.
 fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
     let current_return_type = func.return_type().typ;
-    let len = func.def.body.len();
-    let last_statement = &func.def.body.0[len - 1];
+    let last_statement = func.def.body.0.last()?;
 
     // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
     // Doesn't need done until we have settled on a kernel size
     // TODO: support tuples here and in inputs -> convert into an issue
-
     // Check if the return type is an expression, if it is, we can handle it
     match last_statement {
         Statement { kind: StatementKind::Expression(expression), .. } => {

From cc298cd6f8de77e3aa4aeaba516e249c4cbd388f Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 28 Feb 2024 16:10:52 +0000
Subject: [PATCH 023/416] chore: split up parser into separate files for code
 organisation (#4420)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I find the parser quite difficult to navigate due to the fact that it's
all in a single file and quite disorganised. For example, `lambda` is
1000 lines below `lambda_parameters` despite it being the only place
where `lambda_parameters` is called. This also makes it much harder to
see where we have test coverage within the parser due to all the tests
being in a single location whereas ideally we'd have these attached to
the parser functions they're testing.

This PR then splits the parser into submodules based on sections of the
grammar which it is responsible for parsing. It's not perfect but is an
improvement and we can modify this further if necessary in future.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
---
 compiler/noirc_frontend/src/parser/parser.rs  | 1145 +----------------
 .../src/parser/parser/assertion.rs            |  219 ++++
 .../src/parser/parser/attributes.rs           |   46 +
 .../src/parser/parser/function.rs             |  224 ++++
 .../src/parser/parser/lambdas.rs              |   42 +
 .../src/parser/parser/literals.rs             |  157 +++
 .../noirc_frontend/src/parser/parser/path.rs  |   78 ++
 .../src/parser/parser/primitives.rs           |  101 ++
 .../src/parser/parser/structs.rs              |   97 ++
 .../src/parser/parser/test_helpers.rs         |  122 ++
 .../src/parser/parser/traits.rs               |  217 ++++
 .../noirc_frontend/src/parser/parser/types.rs |  172 +++
 12 files changed, 1524 insertions(+), 1096 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/parser/parser/assertion.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/attributes.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/function.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/lambdas.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/literals.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/path.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/primitives.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/structs.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/test_helpers.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/traits.rs
 create mode 100644 compiler/noirc_frontend/src/parser/parser/types.rs

diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 1cb81e26a0a..75f4a6359bf 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -23,6 +23,8 @@
 //! prevent other parsers from being tried afterward since there is no longer an error. Thus, they should
 //! be limited to cases like the above `fn` example where it is clear we shouldn't back out of the
 //! current parser to try alternative parsers in a `choice` expression.
+use self::primitives::{keyword, mutable_reference, variable};
+
 use super::{
     foldl_with_span, labels::ParsingRuleLabel, parameter_name_recovery, parameter_recovery,
     parenthesized, then_commit, then_commit_ignore, top_level_statement_recovery, ExprParser,
@@ -35,13 +37,11 @@ use crate::ast::{
 };
 use crate::lexer::Lexer;
 use crate::parser::{force, ignore_then_commit, statement_recovery};
-use crate::token::{Attribute, Attributes, Keyword, SecondaryAttribute, Token, TokenKind};
+use crate::token::{Keyword, Token, TokenKind};
 use crate::{
-    BinaryOp, BinaryOpKind, BlockExpression, ConstrainKind, ConstrainStatement, Distinctness,
-    ForLoopStatement, ForRange, FunctionDefinition, FunctionReturnType, FunctionVisibility, Ident,
-    IfExpression, InfixExpression, LValue, Lambda, Literal, NoirFunction, NoirStruct, NoirTrait,
-    NoirTraitImpl, NoirTypeAlias, Param, Path, PathKind, Pattern, Recoverable, Statement,
-    TraitBound, TraitImplItem, TraitItem, TypeImpl, UnaryOp, UnresolvedTraitConstraint,
+    BinaryOp, BinaryOpKind, BlockExpression, Distinctness, ForLoopStatement, ForRange,
+    FunctionReturnType, Ident, IfExpression, InfixExpression, LValue, Literal, NoirTypeAlias,
+    Param, Path, Pattern, Recoverable, Statement, TraitBound, TypeImpl, UnresolvedTraitConstraint,
     UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
 };
 
@@ -49,6 +49,23 @@ use chumsky::prelude::*;
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
 
+mod assertion;
+mod attributes;
+mod function;
+mod lambdas;
+mod literals;
+mod path;
+mod primitives;
+mod structs;
+mod traits;
+
+#[cfg(test)]
+mod test_helpers;
+
+use literals::literal;
+use path::{maybe_empty_path, path};
+use primitives::{dereference, ident, negation, not, nothing, right_shift_operator, token_kind};
+
 /// Entry function for the parser - also handles lexing internally.
 ///
 /// Given a source_program string, return the ParsedModule Ast representation
@@ -109,10 +126,10 @@ fn top_level_statement(
     module_parser: impl NoirParser<ParsedModule>,
 ) -> impl NoirParser<TopLevelStatement> {
     choice((
-        function_definition(false).map(TopLevelStatement::Function),
-        struct_definition(),
-        trait_definition(),
-        trait_implementation(),
+        function::function_definition(false).map(TopLevelStatement::Function),
+        structs::struct_definition(),
+        traits::trait_definition(),
+        traits::trait_implementation(),
         implementation(),
         type_alias_definition().then_ignore(force(just(Token::Semicolon))),
         submodule(module_parser.clone()),
@@ -124,6 +141,21 @@ fn top_level_statement(
     .recover_via(top_level_statement_recovery())
 }
 
+/// Parses a non-trait implementation, adding a set of methods to a type.
+///
+/// implementation: 'impl' generics type '{' function_definition ... '}'
+fn implementation() -> impl NoirParser<TopLevelStatement> {
+    keyword(Keyword::Impl)
+        .ignore_then(function::generics())
+        .then(parse_type().map_with_span(|typ, span| (typ, span)))
+        .then_ignore(just(Token::LeftBrace))
+        .then(spanned(function::function_definition(true)).repeated())
+        .then_ignore(just(Token::RightBrace))
+        .map(|((generics, (object_type, type_span)), methods)| {
+            TopLevelStatement::Impl(TypeImpl { generics, object_type, type_span, methods })
+        })
+}
+
 /// global_declaration: 'global' ident global_type_annotation '=' literal
 fn global_declaration() -> impl NoirParser<TopLevelStatement> {
     let p = ignore_then_commit(
@@ -160,121 +192,11 @@ fn contract(module_parser: impl NoirParser<ParsedModule>) -> impl NoirParser<Top
         })
 }
 
-/// function_definition: attribute function_modifiers 'fn' ident generics '(' function_parameters ')' function_return_type block
-///                      function_modifiers 'fn' ident generics '(' function_parameters ')' function_return_type block
-fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunction> {
-    attributes()
-        .then(function_modifiers())
-        .then_ignore(keyword(Keyword::Fn))
-        .then(ident())
-        .then(generics())
-        .then(parenthesized(function_parameters(allow_self)))
-        .then(function_return_type())
-        .then(where_clause())
-        .then(spanned(block(fresh_statement())))
-        .validate(|(((args, ret), where_clause), (body, body_span)), span, emit| {
-            let ((((attributes, modifiers), name), generics), parameters) = args;
-
-            // Validate collected attributes, filtering them into function and secondary variants
-            let attributes = validate_attributes(attributes, span, emit);
-            FunctionDefinition {
-                span: body_span,
-                name,
-                attributes,
-                is_unconstrained: modifiers.0,
-                is_open: modifiers.2,
-                is_internal: modifiers.3,
-                visibility: if modifiers.1 {
-                    FunctionVisibility::PublicCrate
-                } else if modifiers.4 {
-                    FunctionVisibility::Public
-                } else {
-                    FunctionVisibility::Private
-                },
-                generics,
-                parameters,
-                body,
-                where_clause,
-                return_type: ret.1,
-                return_visibility: ret.0 .1,
-                return_distinctness: ret.0 .0,
-            }
-            .into()
-        })
-}
-
-/// function_modifiers: 'unconstrained'? 'pub(crate)'? 'pub'? 'open'? 'internal'?
-///
-/// returns (is_unconstrained, is_pub_crate, is_open, is_internal, is_pub) for whether each keyword was present
-fn function_modifiers() -> impl NoirParser<(bool, bool, bool, bool, bool)> {
-    keyword(Keyword::Unconstrained)
-        .or_not()
-        .then(is_pub_crate())
-        .then(keyword(Keyword::Pub).or_not())
-        .then(keyword(Keyword::Open).or_not())
-        .then(keyword(Keyword::Internal).or_not())
-        .map(|((((unconstrained, pub_crate), public), open), internal)| {
-            (
-                unconstrained.is_some(),
-                pub_crate,
-                open.is_some(),
-                internal.is_some(),
-                public.is_some(),
-            )
-        })
-}
-
-fn is_pub_crate() -> impl NoirParser<bool> {
-    (keyword(Keyword::Pub)
-        .then_ignore(just(Token::LeftParen))
-        .then_ignore(keyword(Keyword::Crate))
-        .then_ignore(just(Token::RightParen)))
-    .or_not()
-    .map(|a| a.is_some())
-}
-
-/// non_empty_ident_list: ident ',' non_empty_ident_list
-///                     | ident
-///
-/// generics: '<' non_empty_ident_list '>'
-///         | %empty
-fn generics() -> impl NoirParser<Vec<Ident>> {
-    ident()
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .at_least(1)
-        .delimited_by(just(Token::Less), just(Token::Greater))
-        .or_not()
-        .map(|opt| opt.unwrap_or_default())
-}
-
-fn struct_definition() -> impl NoirParser<TopLevelStatement> {
-    use self::Keyword::Struct;
-    use Token::*;
-
-    let fields = struct_fields()
-        .delimited_by(just(LeftBrace), just(RightBrace))
-        .recover_with(nested_delimiters(
-            LeftBrace,
-            RightBrace,
-            [(LeftParen, RightParen), (LeftBracket, RightBracket)],
-            |_| vec![],
-        ))
-        .or(just(Semicolon).to(Vec::new()));
-
-    attributes().then_ignore(keyword(Struct)).then(ident()).then(generics()).then(fields).validate(
-        |(((raw_attributes, name), generics), fields), span, emit| {
-            let attributes = validate_struct_attributes(raw_attributes, span, emit);
-            TopLevelStatement::Struct(NoirStruct { name, attributes, generics, fields, span })
-        },
-    )
-}
-
 fn type_alias_definition() -> impl NoirParser<TopLevelStatement> {
     use self::Keyword::Type;
 
     let p = ignore_then_commit(keyword(Type), ident());
-    let p = then_commit(p, generics());
+    let p = then_commit(p, function::generics());
     let p = then_commit_ignore(p, just(Token::Assign));
     let p = then_commit(p, parse_type());
 
@@ -283,13 +205,6 @@ fn type_alias_definition() -> impl NoirParser<TopLevelStatement> {
     })
 }
 
-fn lambda_return_type() -> impl NoirParser<UnresolvedType> {
-    just(Token::Arrow)
-        .ignore_then(parse_type())
-        .or_not()
-        .map(|ret| ret.unwrap_or_else(UnresolvedType::unspecified))
-}
-
 fn function_return_type() -> impl NoirParser<((Distinctness, Visibility), FunctionReturnType)> {
     just(Token::Arrow)
         .ignore_then(optional_distinctness())
@@ -305,69 +220,6 @@ fn function_return_type() -> impl NoirParser<((Distinctness, Visibility), Functi
         })
 }
 
-fn attribute() -> impl NoirParser<Attribute> {
-    token_kind(TokenKind::Attribute).map(|token| match token {
-        Token::Attribute(attribute) => attribute,
-        _ => unreachable!("Parser should have already errored due to token not being an attribute"),
-    })
-}
-
-fn attributes() -> impl NoirParser<Vec<Attribute>> {
-    attribute().repeated()
-}
-
-fn struct_fields() -> impl NoirParser<Vec<(Ident, UnresolvedType)>> {
-    ident()
-        .then_ignore(just(Token::Colon))
-        .then(parse_type())
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-}
-
-fn lambda_parameters() -> impl NoirParser<Vec<(Pattern, UnresolvedType)>> {
-    let typ = parse_type().recover_via(parameter_recovery());
-    let typ = just(Token::Colon).ignore_then(typ);
-
-    let parameter = pattern()
-        .recover_via(parameter_name_recovery())
-        .then(typ.or_not().map(|typ| typ.unwrap_or_else(UnresolvedType::unspecified)));
-
-    parameter
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .labelled(ParsingRuleLabel::Parameter)
-}
-
-fn function_parameters<'a>(allow_self: bool) -> impl NoirParser<Vec<Param>> + 'a {
-    let typ = parse_type().recover_via(parameter_recovery());
-
-    let full_parameter = pattern()
-        .recover_via(parameter_name_recovery())
-        .then_ignore(just(Token::Colon))
-        .then(optional_visibility())
-        .then(typ)
-        .map_with_span(|((pattern, visibility), typ), span| Param {
-            visibility,
-            pattern,
-            typ,
-            span,
-        });
-
-    let self_parameter = if allow_self { self_parameter().boxed() } else { nothing().boxed() };
-
-    let parameter = full_parameter.or(self_parameter);
-
-    parameter
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .labelled(ParsingRuleLabel::Parameter)
-}
-
-/// This parser always parses no input and fails
-fn nothing<T>() -> impl NoirParser<T> {
-    one_of([]).map(|_| unreachable!("parser should always error"))
-}
-
 fn self_parameter() -> impl NoirParser<Param> {
     let mut_ref_pattern = just(Token::Ampersand).then_ignore(keyword(Keyword::Mut));
     let mut_pattern = keyword(Keyword::Mut);
@@ -401,111 +253,6 @@ fn self_parameter() -> impl NoirParser<Param> {
         })
 }
 
-fn trait_definition() -> impl NoirParser<TopLevelStatement> {
-    keyword(Keyword::Trait)
-        .ignore_then(ident())
-        .then(generics())
-        .then(where_clause())
-        .then_ignore(just(Token::LeftBrace))
-        .then(trait_body())
-        .then_ignore(just(Token::RightBrace))
-        .map_with_span(|(((name, generics), where_clause), items), span| {
-            TopLevelStatement::Trait(NoirTrait { name, generics, where_clause, span, items })
-        })
-}
-
-fn trait_body() -> impl NoirParser<Vec<TraitItem>> {
-    trait_function_declaration()
-        .or(trait_type_declaration())
-        .or(trait_constant_declaration())
-        .repeated()
-}
-
-fn optional_default_value() -> impl NoirParser<Option<Expression>> {
-    ignore_then_commit(just(Token::Assign), expression()).or_not()
-}
-
-fn trait_constant_declaration() -> impl NoirParser<TraitItem> {
-    keyword(Keyword::Let)
-        .ignore_then(ident())
-        .then_ignore(just(Token::Colon))
-        .then(parse_type())
-        .then(optional_default_value())
-        .then_ignore(just(Token::Semicolon))
-        .validate(|((name, typ), default_value), span, emit| {
-            emit(ParserError::with_reason(
-                ParserErrorReason::ExperimentalFeature("Associated constants"),
-                span,
-            ));
-            TraitItem::Constant { name, typ, default_value }
-        })
-}
-
-/// trait_function_declaration: 'fn' ident generics '(' declaration_parameters ')' function_return_type
-fn trait_function_declaration() -> impl NoirParser<TraitItem> {
-    let trait_function_body_or_semicolon =
-        block(fresh_statement()).map(Option::from).or(just(Token::Semicolon).to(Option::None));
-
-    keyword(Keyword::Fn)
-        .ignore_then(ident())
-        .then(generics())
-        .then(parenthesized(function_declaration_parameters()))
-        .then(function_return_type().map(|(_, typ)| typ))
-        .then(where_clause())
-        .then(trait_function_body_or_semicolon)
-        .map(|(((((name, generics), parameters), return_type), where_clause), body)| {
-            TraitItem::Function { name, generics, parameters, return_type, where_clause, body }
-        })
-}
-
-fn validate_attributes(
-    attributes: Vec<Attribute>,
-    span: Span,
-    emit: &mut dyn FnMut(ParserError),
-) -> Attributes {
-    let mut primary = None;
-    let mut secondary = Vec::new();
-
-    for attribute in attributes {
-        match attribute {
-            Attribute::Function(attr) => {
-                if primary.is_some() {
-                    emit(ParserError::with_reason(
-                        ParserErrorReason::MultipleFunctionAttributesFound,
-                        span,
-                    ));
-                }
-                primary = Some(attr);
-            }
-            Attribute::Secondary(attr) => secondary.push(attr),
-        }
-    }
-
-    Attributes { function: primary, secondary }
-}
-
-fn validate_struct_attributes(
-    attributes: Vec<Attribute>,
-    span: Span,
-    emit: &mut dyn FnMut(ParserError),
-) -> Vec<SecondaryAttribute> {
-    let mut struct_attributes = vec![];
-
-    for attribute in attributes {
-        match attribute {
-            Attribute::Function(..) => {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::NoFunctionAttributesAllowedOnStruct,
-                    span,
-                ));
-            }
-            Attribute::Secondary(attr) => struct_attributes.push(attr),
-        }
-    }
-
-    struct_attributes
-}
-
 /// Function declaration parameters differ from other parameters in that parameter
 /// patterns are not allowed in declarations. All parameters must be identifiers.
 fn function_declaration_parameters() -> impl NoirParser<Vec<(Ident, UnresolvedType)>> {
@@ -536,89 +283,6 @@ fn function_declaration_parameters() -> impl NoirParser<Vec<(Ident, UnresolvedTy
         .labelled(ParsingRuleLabel::Parameter)
 }
 
-/// trait_type_declaration: 'type' ident generics
-fn trait_type_declaration() -> impl NoirParser<TraitItem> {
-    keyword(Keyword::Type).ignore_then(ident()).then_ignore(just(Token::Semicolon)).validate(
-        |name, span, emit| {
-            emit(ParserError::with_reason(
-                ParserErrorReason::ExperimentalFeature("Associated types"),
-                span,
-            ));
-            TraitItem::Type { name }
-        },
-    )
-}
-
-/// Parses a non-trait implementation, adding a set of methods to a type.
-///
-/// implementation: 'impl' generics type '{' function_definition ... '}'
-fn implementation() -> impl NoirParser<TopLevelStatement> {
-    keyword(Keyword::Impl)
-        .ignore_then(generics())
-        .then(parse_type().map_with_span(|typ, span| (typ, span)))
-        .then_ignore(just(Token::LeftBrace))
-        .then(spanned(function_definition(true)).repeated())
-        .then_ignore(just(Token::RightBrace))
-        .map(|((generics, (object_type, type_span)), methods)| {
-            TopLevelStatement::Impl(TypeImpl { generics, object_type, type_span, methods })
-        })
-}
-
-/// Parses a trait implementation, implementing a particular trait for a type.
-/// This has a similar syntax to `implementation`, but the `for type` clause is required,
-/// and an optional `where` clause is also useable.
-///
-/// trait_implementation: 'impl' generics ident generic_args for type '{' trait_implementation_body '}'
-fn trait_implementation() -> impl NoirParser<TopLevelStatement> {
-    keyword(Keyword::Impl)
-        .ignore_then(generics())
-        .then(path())
-        .then(generic_type_args(parse_type()))
-        .then_ignore(keyword(Keyword::For))
-        .then(parse_type())
-        .then(where_clause())
-        .then_ignore(just(Token::LeftBrace))
-        .then(trait_implementation_body())
-        .then_ignore(just(Token::RightBrace))
-        .map(|args| {
-            let ((other_args, where_clause), items) = args;
-            let (((impl_generics, trait_name), trait_generics), object_type) = other_args;
-
-            TopLevelStatement::TraitImpl(NoirTraitImpl {
-                impl_generics,
-                trait_name,
-                trait_generics,
-                object_type,
-                items,
-                where_clause,
-            })
-        })
-}
-
-fn trait_implementation_body() -> impl NoirParser<Vec<TraitImplItem>> {
-    let function = function_definition(true).validate(|mut f, span, emit| {
-        if f.def().is_internal
-            || f.def().is_unconstrained
-            || f.def().is_open
-            || f.def().visibility != FunctionVisibility::Private
-        {
-            emit(ParserError::with_reason(ParserErrorReason::TraitImplFunctionModifiers, span));
-        }
-        // Trait impl functions are always public
-        f.def_mut().visibility = FunctionVisibility::Public;
-        TraitImplItem::Function(f)
-    });
-
-    let alias = keyword(Keyword::Type)
-        .ignore_then(ident())
-        .then_ignore(just(Token::Assign))
-        .then(parse_type())
-        .then_ignore(just(Token::Semicolon))
-        .map(|(name, alias)| TraitImplItem::Type { name, alias });
-
-    function.or(alias).repeated()
-}
-
 fn where_clause() -> impl NoirParser<Vec<UnresolvedTraitConstraint>> {
     struct MultiTraitConstraint {
         typ: UnresolvedType,
@@ -713,45 +377,6 @@ fn use_statement() -> impl NoirParser<TopLevelStatement> {
     keyword(Keyword::Use).ignore_then(use_tree()).map(TopLevelStatement::Import)
 }
 
-fn keyword(keyword: Keyword) -> impl NoirParser<Token> {
-    just(Token::Keyword(keyword))
-}
-
-fn token_kind(token_kind: TokenKind) -> impl NoirParser<Token> {
-    filter_map(move |span, found: Token| {
-        if found.kind() == token_kind {
-            Ok(found)
-        } else {
-            Err(ParserError::expected_label(
-                ParsingRuleLabel::TokenKind(token_kind.clone()),
-                found,
-                span,
-            ))
-        }
-    })
-}
-
-fn path() -> impl NoirParser<Path> {
-    let idents = || ident().separated_by(just(Token::DoubleColon)).at_least(1);
-    let make_path = |kind| move |segments, span| Path { segments, kind, span };
-
-    let prefix = |key| keyword(key).ignore_then(just(Token::DoubleColon));
-    let path_kind = |key, kind| prefix(key).ignore_then(idents()).map_with_span(make_path(kind));
-
-    choice((
-        path_kind(Keyword::Crate, PathKind::Crate),
-        path_kind(Keyword::Dep, PathKind::Dep),
-        idents().map_with_span(make_path(PathKind::Plain)),
-    ))
-}
-
-fn empty_path() -> impl NoirParser<Path> {
-    let make_path = |kind| move |_, span| Path { segments: Vec::new(), kind, span };
-    let path_kind = |key, kind| keyword(key).map_with_span(make_path(kind));
-
-    choice((path_kind(Keyword::Crate, PathKind::Crate), path_kind(Keyword::Dep, PathKind::Dep)))
-}
-
 fn rename() -> impl NoirParser<Option<Ident>> {
     ignore_then_commit(keyword(Keyword::As), ident()).or_not()
 }
@@ -764,7 +389,7 @@ fn use_tree() -> impl NoirParser<UseTree> {
         });
 
         let list = {
-            let prefix = path().or(empty_path()).then_ignore(just(Token::DoubleColon));
+            let prefix = maybe_empty_path().then_ignore(just(Token::DoubleColon));
             let tree = use_tree
                 .separated_by(just(Token::Comma))
                 .allow_trailing()
@@ -778,10 +403,6 @@ fn use_tree() -> impl NoirParser<UseTree> {
     })
 }
 
-fn ident() -> impl NoirParser<Ident> {
-    token_kind(TokenKind::Ident).map_with_span(Ident::from_token)
-}
-
 fn statement<'a, P, P2>(
     expr_parser: P,
     expr_no_constructors: P2,
@@ -792,9 +413,9 @@ where
 {
     recursive(|statement| {
         choice((
-            constrain(expr_parser.clone()),
-            assertion(expr_parser.clone()),
-            assertion_eq(expr_parser.clone()),
+            assertion::constrain(expr_parser.clone()),
+            assertion::assertion(expr_parser.clone()),
+            assertion::assertion_eq(expr_parser.clone()),
             declaration(expr_parser.clone()),
             assignment(expr_parser.clone()),
             for_loop(expr_no_constructors, statement),
@@ -808,64 +429,6 @@ fn fresh_statement() -> impl NoirParser<StatementKind> {
     statement(expression(), expression_no_constructors(expression()))
 }
 
-fn constrain<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    ignore_then_commit(
-        keyword(Keyword::Constrain).labelled(ParsingRuleLabel::Statement),
-        expr_parser,
-    )
-    .map(|expr| StatementKind::Constrain(ConstrainStatement(expr, None, ConstrainKind::Constrain)))
-    .validate(|expr, span, emit| {
-        emit(ParserError::with_reason(ParserErrorReason::ConstrainDeprecated, span));
-        expr
-    })
-}
-
-fn assertion<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    let argument_parser =
-        expr_parser.separated_by(just(Token::Comma)).allow_trailing().at_least(1).at_most(2);
-
-    ignore_then_commit(keyword(Keyword::Assert), parenthesized(argument_parser))
-        .labelled(ParsingRuleLabel::Statement)
-        .validate(|expressions, span, _| {
-            let condition = expressions.first().unwrap_or(&Expression::error(span)).clone();
-            let message = expressions.get(1).cloned();
-            StatementKind::Constrain(ConstrainStatement(condition, message, ConstrainKind::Assert))
-        })
-}
-
-fn assertion_eq<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    let argument_parser =
-        expr_parser.separated_by(just(Token::Comma)).allow_trailing().at_least(2).at_most(3);
-
-    ignore_then_commit(keyword(Keyword::AssertEq), parenthesized(argument_parser))
-        .labelled(ParsingRuleLabel::Statement)
-        .validate(|exprs: Vec<Expression>, span, _| {
-            let predicate = Expression::new(
-                ExpressionKind::Infix(Box::new(InfixExpression {
-                    lhs: exprs.first().unwrap_or(&Expression::error(span)).clone(),
-                    rhs: exprs.get(1).unwrap_or(&Expression::error(span)).clone(),
-                    operator: Spanned::from(span, BinaryOpKind::Equal),
-                })),
-                span,
-            );
-            let message = exprs.get(2).cloned();
-            StatementKind::Constrain(ConstrainStatement(
-                predicate,
-                message,
-                ConstrainKind::AssertEq,
-            ))
-        })
-}
-
 fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
 where
     P: ExprParser + 'a,
@@ -1308,13 +871,6 @@ fn create_infix_expression(lhs: Expression, (operator, rhs): (BinaryOp, Expressi
     Expression { span, kind: ExpressionKind::Infix(infix) }
 }
 
-// Right-shift (>>) is issued as two separate > tokens by the lexer as this makes it easier
-// to parse nested generic types. For normal expressions however, it means we have to manually
-// parse two greater-than tokens as a single right-shift here.
-fn right_shift_operator() -> impl NoirParser<Token> {
-    just(Token::Greater).then(just(Token::Greater)).to(Token::ShiftRight)
-}
-
 fn operator_with_precedence(precedence: Precedence) -> impl NoirParser<Spanned<BinaryOpKind>> {
     right_shift_operator()
         .or(any()) // Parse any single token, we're validating it as an operator next
@@ -1454,18 +1010,6 @@ where
     })
 }
 
-fn lambda<'a>(
-    expr_parser: impl NoirParser<Expression> + 'a,
-) -> impl NoirParser<ExpressionKind> + 'a {
-    lambda_parameters()
-        .delimited_by(just(Token::Pipe), just(Token::Pipe))
-        .then(lambda_return_type())
-        .then(expr_parser)
-        .map(|((parameters, return_type), body)| {
-            ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
-        })
-}
-
 fn for_loop<'a, P, S>(expr_no_constructors: P, statement: S) -> impl NoirParser<StatementKind> + 'a
 where
     P: ExprParser + 'a,
@@ -1530,41 +1074,6 @@ where
     expr_parser.separated_by(just(Token::Comma)).allow_trailing()
 }
 
-fn not<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Bang).ignore_then(term_parser).map(|rhs| ExpressionKind::prefix(UnaryOp::Not, rhs))
-}
-
-fn negation<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Minus)
-        .ignore_then(term_parser)
-        .map(|rhs| ExpressionKind::prefix(UnaryOp::Minus, rhs))
-}
-
-fn mutable_reference<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Ampersand)
-        .ignore_then(keyword(Keyword::Mut))
-        .ignore_then(term_parser)
-        .map(|rhs| ExpressionKind::prefix(UnaryOp::MutableReference, rhs))
-}
-
-fn dereference<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Star)
-        .ignore_then(term_parser)
-        .map(|rhs| ExpressionKind::prefix(UnaryOp::Dereference { implicitly_added: false }, rhs))
-}
-
 /// Atoms are parameterized on whether constructor expressions are allowed or not.
 /// Certain constructs like `if` and `for` disallow constructor expressions when a
 /// block may be expected.
@@ -1587,7 +1096,7 @@ where
         } else {
             nothing().boxed()
         },
-        lambda(expr_parser.clone()),
+        lambdas::lambda(expr_parser.clone()),
         block(statement).map(ExpressionKind::Block),
         variable(),
         literal(),
@@ -1655,167 +1164,12 @@ where
     long_form.or(short_form)
 }
 
-fn variable() -> impl NoirParser<ExpressionKind> {
-    path().map(ExpressionKind::Variable)
-}
-
-fn literal() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::Literal).map(|token| match token {
-        Token::Int(x) => ExpressionKind::integer(x),
-        Token::Bool(b) => ExpressionKind::boolean(b),
-        Token::Str(s) => ExpressionKind::string(s),
-        Token::RawStr(s, hashes) => ExpressionKind::raw_string(s, hashes),
-        Token::FmtStr(s) => ExpressionKind::format_string(s),
-        unexpected => unreachable!("Non-literal {} parsed as a literal", unexpected),
-    })
-}
-
 #[cfg(test)]
 mod test {
-    use noirc_errors::CustomDiagnostic;
-
+    use super::test_helpers::*;
     use super::*;
     use crate::{ArrayLiteral, Literal};
 
-    fn parse_with<P, T>(parser: P, program: &str) -> Result<T, Vec<CustomDiagnostic>>
-    where
-        P: NoirParser<T>,
-    {
-        let (tokens, lexer_errors) = Lexer::lex(program);
-        if !lexer_errors.is_empty() {
-            return Err(vecmap(lexer_errors, Into::into));
-        }
-        parser
-            .then_ignore(just(Token::EOF))
-            .parse(tokens)
-            .map_err(|errors| vecmap(errors, Into::into))
-    }
-
-    fn parse_recover<P, T>(parser: P, program: &str) -> (Option<T>, Vec<CustomDiagnostic>)
-    where
-        P: NoirParser<T>,
-    {
-        let (tokens, lexer_errors) = Lexer::lex(program);
-        let (opt, errs) = parser.then_ignore(force(just(Token::EOF))).parse_recovery(tokens);
-
-        let mut errors = vecmap(lexer_errors, Into::into);
-        errors.extend(errs.into_iter().map(Into::into));
-
-        (opt, errors)
-    }
-
-    fn parse_all<P, T>(parser: P, programs: Vec<&str>) -> Vec<T>
-    where
-        P: NoirParser<T>,
-    {
-        vecmap(programs, move |program| {
-            let message = format!("Failed to parse:\n{program}");
-            let (op_t, diagnostics) = parse_recover(&parser, program);
-            diagnostics.iter().for_each(|diagnostic| {
-                if diagnostic.is_error() {
-                    panic!("{} with error {}", &message, diagnostic);
-                }
-            });
-            op_t.expect(&message)
-        })
-    }
-
-    fn parse_all_failing<P, T>(parser: P, programs: Vec<&str>) -> Vec<CustomDiagnostic>
-    where
-        P: NoirParser<T>,
-        T: std::fmt::Display,
-    {
-        programs
-            .into_iter()
-            .flat_map(|program| match parse_with(&parser, program) {
-                Ok(expr) => {
-                    unreachable!(
-                        "Expected this input to fail:\n{}\nYet it successfully parsed as:\n{}",
-                        program, expr
-                    )
-                }
-                Err(diagnostics) => {
-                    if diagnostics.iter().all(|diagnostic: &CustomDiagnostic| diagnostic.is_warning()) {
-                        unreachable!(
-                            "Expected at least one error when parsing:\n{}\nYet it successfully parsed without errors:\n",
-                            program
-                        )
-                    };
-                    diagnostics
-                }
-            })
-            .collect()
-    }
-
-    #[derive(Copy, Clone)]
-    struct Case {
-        source: &'static str,
-        errors: usize,
-        expect: &'static str,
-    }
-
-    fn check_cases_with_errors<T, P>(cases: &[Case], parser: P)
-    where
-        P: NoirParser<T> + Clone,
-        T: std::fmt::Display,
-    {
-        let show_errors = |v| vecmap(&v, ToString::to_string).join("\n");
-
-        let results = vecmap(cases, |&case| {
-            let (opt, errors) = parse_recover(parser.clone(), case.source);
-            let actual = opt.map(|ast| ast.to_string());
-            let actual = if let Some(s) = &actual { s.to_string() } else { "(none)".to_string() };
-
-            let result = ((errors.len(), actual.clone()), (case.errors, case.expect.to_string()));
-            if result.0 != result.1 {
-                let num_errors = errors.len();
-                let shown_errors = show_errors(errors);
-                eprintln!(
-                    concat!(
-                        "\nExpected {expected_errors} error(s) and got {num_errors}:",
-                        "\n\n{shown_errors}",
-                        "\n\nFrom input:   {src}",
-                        "\nExpected AST: {expected_result}",
-                        "\nActual AST:   {actual}\n",
-                    ),
-                    expected_errors = case.errors,
-                    num_errors = num_errors,
-                    shown_errors = shown_errors,
-                    src = case.source,
-                    expected_result = case.expect,
-                    actual = actual,
-                );
-            }
-            result
-        });
-
-        assert_eq!(vecmap(&results, |t| t.0.clone()), vecmap(&results, |t| t.1.clone()),);
-    }
-
-    #[test]
-    fn regression_skip_comment() {
-        parse_all(
-            function_definition(false),
-            vec![
-                "fn main(
-                // This comment should be skipped
-                x : Field,
-                // And this one
-                y : Field,
-            ) {
-            }",
-                "fn main(x : Field, y : Field,) {
-                foo::bar(
-                    // Comment for x argument
-                    x,
-                    // Comment for y argument
-                    y
-                )
-            }",
-            ],
-        );
-    }
-
     #[test]
     fn parse_infix() {
         let valid = vec!["x + 6", "x - k", "x + (x + a)", " x * (x + a) + (x - 4)"];
@@ -1966,142 +1320,6 @@ mod test {
         }
     }
 
-    /// Deprecated constrain usage test
-    #[test]
-    fn parse_constrain() {
-        let errors = parse_with(constrain(expression()), "constrain x == y").unwrap_err();
-        assert_eq!(errors.len(), 1);
-        assert!(format!("{}", errors.first().unwrap()).contains("deprecated"));
-
-        // Currently we disallow constrain statements where the outer infix operator
-        // produces a value. This would require an implicit `==` which
-        // may not be intuitive to the user.
-        //
-        // If this is deemed useful, one would either apply a transformation
-        // or interpret it with an `==` in the evaluator
-        let disallowed_operators = vec![
-            BinaryOpKind::And,
-            BinaryOpKind::Subtract,
-            BinaryOpKind::Divide,
-            BinaryOpKind::Multiply,
-            BinaryOpKind::Or,
-        ];
-
-        for operator in disallowed_operators {
-            let src = format!("constrain x {} y;", operator.as_string());
-            let errors = parse_with(constrain(expression()), &src).unwrap_err();
-            assert_eq!(errors.len(), 2);
-            assert!(format!("{}", errors.first().unwrap()).contains("deprecated"));
-        }
-
-        // These are general cases which should always work.
-        //
-        // The first case is the most noteworthy. It contains two `==`
-        // The first (inner) `==` is a predicate which returns 0/1
-        // The outer layer is an infix `==` which is
-        // associated with the Constrain statement
-        let errors = parse_all_failing(
-            constrain(expression()),
-            vec![
-                "constrain ((x + y) == k) + z == y",
-                "constrain (x + !y) == y",
-                "constrain (x ^ y) == y",
-                "constrain (x ^ y) == (y + m)",
-                "constrain x + x ^ x == y | m",
-            ],
-        );
-        assert_eq!(errors.len(), 5);
-        assert!(errors
-            .iter()
-            .all(|err| { err.is_error() && err.to_string().contains("deprecated") }));
-    }
-
-    /// This is the standard way to declare an assert statement
-    #[test]
-    fn parse_assert() {
-        parse_with(assertion(expression()), "assert(x == y)").unwrap();
-
-        // Currently we disallow constrain statements where the outer infix operator
-        // produces a value. This would require an implicit `==` which
-        // may not be intuitive to the user.
-        //
-        // If this is deemed useful, one would either apply a transformation
-        // or interpret it with an `==` in the evaluator
-        let disallowed_operators = vec![
-            BinaryOpKind::And,
-            BinaryOpKind::Subtract,
-            BinaryOpKind::Divide,
-            BinaryOpKind::Multiply,
-            BinaryOpKind::Or,
-        ];
-
-        for operator in disallowed_operators {
-            let src = format!("assert(x {} y);", operator.as_string());
-            parse_with(assertion(expression()), &src).unwrap_err();
-        }
-
-        // These are general cases which should always work.
-        //
-        // The first case is the most noteworthy. It contains two `==`
-        // The first (inner) `==` is a predicate which returns 0/1
-        // The outer layer is an infix `==` which is
-        // associated with the Constrain statement
-        parse_all(
-            assertion(expression()),
-            vec![
-                "assert(((x + y) == k) + z == y)",
-                "assert((x + !y) == y)",
-                "assert((x ^ y) == y)",
-                "assert((x ^ y) == (y + m))",
-                "assert(x + x ^ x == y | m)",
-            ],
-        );
-
-        match parse_with(assertion(expression()), "assert(x == y, \"assertion message\")").unwrap()
-        {
-            StatementKind::Constrain(ConstrainStatement(_, message, _)) => {
-                let message = message.unwrap();
-                match message.kind {
-                    ExpressionKind::Literal(Literal::Str(message_string)) => {
-                        assert_eq!(message_string, "assertion message".to_owned());
-                    }
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// This is the standard way to assert that two expressions are equivalent
-    #[test]
-    fn parse_assert_eq() {
-        parse_all(
-            assertion_eq(expression()),
-            vec![
-                "assert_eq(x, y)",
-                "assert_eq(((x + y) == k) + z, y)",
-                "assert_eq(x + !y, y)",
-                "assert_eq(x ^ y, y)",
-                "assert_eq(x ^ y, y + m)",
-                "assert_eq(x + x ^ x, y | m)",
-            ],
-        );
-        match parse_with(assertion_eq(expression()), "assert_eq(x, y, \"assertion message\")")
-            .unwrap()
-        {
-            StatementKind::Constrain(ConstrainStatement(_, message, _)) => {
-                let message = message.unwrap();
-                match message.kind {
-                    ExpressionKind::Literal(Literal::Str(message_string)) => {
-                        assert_eq!(message_string, "assertion message".to_owned());
-                    }
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-
     #[test]
     fn parse_let() {
         // Why is it valid to specify a let declaration as having type u8?
@@ -2135,84 +1353,6 @@ mod test {
         );
     }
 
-    #[test]
-    fn parse_function() {
-        parse_all(
-            function_definition(false),
-            vec![
-                "fn func_name() {}",
-                "fn f(foo: pub u8, y : pub Field) -> u8 { x + a }",
-                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
-                "fn func_name(f: Field, y : pub Field, z : pub [u8;5],) {}",
-                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
-                "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
-                "fn func_name(x: [Field], y : [Field;2],y : pub [Field;2], z : pub [u8;5])  {}",
-                "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }",
-                "fn f(f: pub Field, y : Field, z : comptime Field) -> u8 { x + a }",
-                "fn f<T>(f: pub Field, y : T, z : comptime Field) -> u8 { x + a }",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait, T: SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A> + SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A, B> + SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A, B> + SomeTrait2<C> {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2<C> {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2<C> + TraitY {}",
-                "fn func_name<T>(f: Field, y : T, z : U) where SomeStruct<T>: SomeTrait<U> {}",
-                // 'where u32: SomeTrait' is allowed in Rust.
-                // It will result in compiler error in case SomeTrait isn't implemented for u32.
-                "fn func_name<T>(f: Field, y : T) where u32: SomeTrait {}",
-                // A trailing plus is allowed by Rust, so we support it as well.
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + {}",
-                // The following should produce compile error on later stage. From the parser's perspective it's fine
-                "fn func_name<A>(f: Field, y : Field, z : Field) where T: SomeTrait {}",
-            ],
-        );
-
-        parse_all_failing(
-            function_definition(false),
-            vec![
-                "fn x2( f: []Field,,) {}",
-                "fn ( f: []Field) {}",
-                "fn ( f: []Field) {}",
-                // TODO: Check for more specific error messages
-                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) where T: {}",
-                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) where SomeTrait {}",
-                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) SomeTrait {}",
-                // A leading plus is not allowed.
-                "fn func_name<T>(f: Field, y : T) where T: + SomeTrait {}",
-                "fn func_name<T>(f: Field, y : T) where T: TraitX + <Y> {}",
-            ],
-        );
-    }
-
-    #[test]
-    fn parse_trait() {
-        parse_all(
-            trait_definition(),
-            vec![
-                // Empty traits are legal in Rust and sometimes used as a way to whitelist certain types
-                // for a particular operation. Also known as `tag` or `marker` traits:
-                // https://stackoverflow.com/questions/71895489/what-is-the-purpose-of-defining-empty-impl-in-rust
-                "trait Empty {}",
-                "trait TraitWithDefaultBody { fn foo(self) {} }",
-                "trait TraitAcceptingMutableRef { fn foo(&mut self); }",
-                "trait TraitWithTypeBoundOperation { fn identity() -> Self; }",
-                "trait TraitWithAssociatedType { type Element; fn item(self, index: Field) -> Self::Element; }",
-                "trait TraitWithAssociatedConstant { let Size: Field; }",
-                "trait TraitWithAssociatedConstantWithDefaultValue { let Size: Field = 10; }",
-                "trait GenericTrait<T> { fn elem(&mut self, index: Field) -> T; }",
-                "trait GenericTraitWithConstraints<T> where T: SomeTrait { fn elem(self, index: Field) -> T; }",
-                "trait TraitWithMultipleGenericParams<A, B, C> where A: SomeTrait, B: AnotherTrait<C> { let Size: Field; fn zero() -> Self; }",
-            ],
-        );
-
-        parse_all_failing(
-            trait_definition(),
-            vec!["trait MissingBody", "trait WrongDelimiter { fn foo() -> u8, fn bar() -> u8 }"],
-        );
-    }
-
     #[test]
     fn parse_parenthesized_expression() {
         parse_all(
@@ -2243,104 +1383,12 @@ mod test {
         );
     }
 
-    fn expr_to_lit(expr: ExpressionKind) -> Literal {
-        match expr {
-            ExpressionKind::Literal(literal) => literal,
-            _ => unreachable!("expected a literal"),
-        }
-    }
-
-    #[test]
-    fn parse_int() {
-        let int = parse_with(literal(), "5").unwrap();
-        let hex = parse_with(literal(), "0x05").unwrap();
-
-        match (expr_to_lit(int), expr_to_lit(hex)) {
-            (Literal::Integer(int, false), Literal::Integer(hex, false)) => assert_eq!(int, hex),
-            _ => unreachable!(),
-        }
-    }
-
-    #[test]
-    fn parse_string() {
-        let expr = parse_with(literal(), r#""hello""#).unwrap();
-        match expr_to_lit(expr) {
-            Literal::Str(s) => assert_eq!(s, "hello"),
-            _ => unreachable!(),
-        };
-    }
-
-    #[test]
-    fn parse_bool() {
-        let expr_true = parse_with(literal(), "true").unwrap();
-        let expr_false = parse_with(literal(), "false").unwrap();
-
-        match (expr_to_lit(expr_true), expr_to_lit(expr_false)) {
-            (Literal::Bool(t), Literal::Bool(f)) => {
-                assert!(t);
-                assert!(!f);
-            }
-            _ => unreachable!(),
-        };
-    }
-
     #[test]
     fn parse_module_declaration() {
         parse_with(module_declaration(), "mod foo").unwrap();
         parse_with(module_declaration(), "mod 1").unwrap_err();
     }
 
-    #[test]
-    fn parse_path() {
-        let cases = vec![
-            ("std", vec!["std"]),
-            ("std::hash", vec!["std", "hash"]),
-            ("std::hash::collections", vec!["std", "hash", "collections"]),
-            ("dep::foo::bar", vec!["foo", "bar"]),
-            ("crate::std::hash", vec!["std", "hash"]),
-        ];
-
-        for (src, expected_segments) in cases {
-            let path: Path = parse_with(path(), src).unwrap();
-            for (segment, expected) in path.segments.into_iter().zip(expected_segments) {
-                assert_eq!(segment.0.contents, expected);
-            }
-        }
-
-        parse_all_failing(path(), vec!["std::", "::std", "std::hash::", "foo::1"]);
-    }
-
-    #[test]
-    fn parse_path_kinds() {
-        let cases = vec![
-            ("std", PathKind::Plain),
-            ("dep::hash::collections", PathKind::Dep),
-            ("crate::std::hash", PathKind::Crate),
-        ];
-
-        for (src, expected_path_kind) in cases {
-            let path = parse_with(path(), src).unwrap();
-            assert_eq!(path.kind, expected_path_kind);
-        }
-
-        parse_all_failing(
-            path(),
-            vec!["dep", "crate", "crate::std::crate", "foo::bar::crate", "foo::dep"],
-        );
-    }
-
-    #[test]
-    fn parse_unary() {
-        parse_all(
-            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["!hello", "-hello", "--hello", "-!hello", "!-hello"],
-        );
-        parse_all_failing(
-            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["+hello", "/hello"],
-        );
-    }
-
     #[test]
     fn parse_use() {
         parse_all(
@@ -2372,26 +1420,6 @@ mod test {
         );
     }
 
-    #[test]
-    fn parse_structs() {
-        let cases = vec![
-            "struct Foo;",
-            "struct Foo { }",
-            "struct Bar { ident: Field, }",
-            "struct Baz { ident: Field, other: Field }",
-            "#[attribute] struct Baz { ident: Field, other: Field }",
-        ];
-        parse_all(struct_definition(), cases);
-
-        let failing = vec![
-            "struct {  }",
-            "struct Foo { bar: pub Field }",
-            "struct Foo { bar: pub Field }",
-            "#[oracle(some)] struct Foo { bar: Field }",
-        ];
-        parse_all_failing(struct_definition(), failing);
-    }
-
     #[test]
     fn parse_type_aliases() {
         let cases = vec!["type foo = u8", "type bar = String", "type baz<T> = Vec<T>"];
@@ -2563,79 +1591,4 @@ mod test {
 
         check_cases_with_errors(&cases[..], block(fresh_statement()));
     }
-
-    #[test]
-    fn parse_raw_string_expr() {
-        let cases = vec![
-            Case { source: r#" r"foo" "#, expect: r#"r"foo""#, errors: 0 },
-            Case { source: r##" r#"foo"# "##, expect: r##"r#"foo"#"##, errors: 0 },
-            // backslash
-            Case { source: r#" r"\\" "#, expect: r#"r"\\""#, errors: 0 },
-            Case { source: r##" r#"\"# "##, expect: r##"r#"\"#"##, errors: 0 },
-            Case { source: r##" r#"\\"# "##, expect: r##"r#"\\"#"##, errors: 0 },
-            Case { source: r##" r#"\\\"# "##, expect: r##"r#"\\\"#"##, errors: 0 },
-            // escape sequence
-            Case {
-                source: r##" r#"\t\n\\t\\n\\\t\\\n\\\\"# "##,
-                expect: r##"r#"\t\n\\t\\n\\\t\\\n\\\\"#"##,
-                errors: 0,
-            },
-            Case { source: r##" r#"\\\\\\\\"# "##, expect: r##"r#"\\\\\\\\"#"##, errors: 0 },
-            // mismatch - errors:
-            Case { source: r###" r#"foo"## "###, expect: r##"r#"foo"#"##, errors: 1 },
-            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
-            // mismatch: short:
-            Case { source: r##" r"foo"# "##, expect: r#"r"foo""#, errors: 1 },
-            Case { source: r#" r#"foo" "#, expect: "(none)", errors: 2 },
-            // empty string
-            Case { source: r#"r"""#, expect: r#"r"""#, errors: 0 },
-            Case { source: r####"r###""###"####, expect: r####"r###""###"####, errors: 0 },
-            // miscellaneous
-            Case { source: r##" r#\"foo\"# "##, expect: "plain::r", errors: 2 },
-            Case { source: r#" r\"foo\" "#, expect: "plain::r", errors: 1 },
-            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
-            // missing 'r' letter
-            Case { source: r##" ##"foo"# "##, expect: r#""foo""#, errors: 2 },
-            Case { source: r#" #"foo" "#, expect: "plain::foo", errors: 2 },
-            // whitespace
-            Case { source: r##" r #"foo"# "##, expect: "plain::r", errors: 2 },
-            Case { source: r##" r# "foo"# "##, expect: "plain::r", errors: 3 },
-            Case { source: r#" r#"foo" # "#, expect: "(none)", errors: 2 },
-            // after identifier
-            Case { source: r##" bar#"foo"# "##, expect: "plain::bar", errors: 2 },
-            // nested
-            Case {
-                source: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
-                expect: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
-                errors: 0,
-            },
-        ];
-
-        check_cases_with_errors(&cases[..], expression());
-    }
-
-    #[test]
-    fn parse_raw_string_lit() {
-        let lit_cases = vec![
-            Case { source: r#" r"foo" "#, expect: r#"r"foo""#, errors: 0 },
-            Case { source: r##" r#"foo"# "##, expect: r##"r#"foo"#"##, errors: 0 },
-            // backslash
-            Case { source: r#" r"\\" "#, expect: r#"r"\\""#, errors: 0 },
-            Case { source: r##" r#"\"# "##, expect: r##"r#"\"#"##, errors: 0 },
-            Case { source: r##" r#"\\"# "##, expect: r##"r#"\\"#"##, errors: 0 },
-            Case { source: r##" r#"\\\"# "##, expect: r##"r#"\\\"#"##, errors: 0 },
-            // escape sequence
-            Case {
-                source: r##" r#"\t\n\\t\\n\\\t\\\n\\\\"# "##,
-                expect: r##"r#"\t\n\\t\\n\\\t\\\n\\\\"#"##,
-                errors: 0,
-            },
-            Case { source: r##" r#"\\\\\\\\"# "##, expect: r##"r#"\\\\\\\\"#"##, errors: 0 },
-            // mismatch - errors:
-            Case { source: r###" r#"foo"## "###, expect: r##"r#"foo"#"##, errors: 1 },
-            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
-        ];
-
-        check_cases_with_errors(&lit_cases[..], literal());
-    }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/assertion.rs b/compiler/noirc_frontend/src/parser/parser/assertion.rs
new file mode 100644
index 00000000000..f9c8d7aa46b
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/assertion.rs
@@ -0,0 +1,219 @@
+use crate::ast::{Expression, ExpressionKind, StatementKind};
+use crate::parser::{
+    ignore_then_commit, labels::ParsingRuleLabel, parenthesized, ExprParser, NoirParser,
+    ParserError, ParserErrorReason,
+};
+
+use crate::token::{Keyword, Token};
+use crate::{BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, Recoverable};
+
+use chumsky::prelude::*;
+use noirc_errors::Spanned;
+
+use super::keyword;
+
+pub(super) fn constrain<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
+where
+    P: ExprParser + 'a,
+{
+    ignore_then_commit(
+        keyword(Keyword::Constrain).labelled(ParsingRuleLabel::Statement),
+        expr_parser,
+    )
+    .map(|expr| StatementKind::Constrain(ConstrainStatement(expr, None, ConstrainKind::Constrain)))
+    .validate(|expr, span, emit| {
+        emit(ParserError::with_reason(ParserErrorReason::ConstrainDeprecated, span));
+        expr
+    })
+}
+
+pub(super) fn assertion<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
+where
+    P: ExprParser + 'a,
+{
+    let argument_parser =
+        expr_parser.separated_by(just(Token::Comma)).allow_trailing().at_least(1).at_most(2);
+
+    ignore_then_commit(keyword(Keyword::Assert), parenthesized(argument_parser))
+        .labelled(ParsingRuleLabel::Statement)
+        .validate(|expressions, span, _| {
+            let condition = expressions.first().unwrap_or(&Expression::error(span)).clone();
+            let message = expressions.get(1).cloned();
+            StatementKind::Constrain(ConstrainStatement(condition, message, ConstrainKind::Assert))
+        })
+}
+
+pub(super) fn assertion_eq<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
+where
+    P: ExprParser + 'a,
+{
+    let argument_parser =
+        expr_parser.separated_by(just(Token::Comma)).allow_trailing().at_least(2).at_most(3);
+
+    ignore_then_commit(keyword(Keyword::AssertEq), parenthesized(argument_parser))
+        .labelled(ParsingRuleLabel::Statement)
+        .validate(|exprs: Vec<Expression>, span, _| {
+            let predicate = Expression::new(
+                ExpressionKind::Infix(Box::new(InfixExpression {
+                    lhs: exprs.first().unwrap_or(&Expression::error(span)).clone(),
+                    rhs: exprs.get(1).unwrap_or(&Expression::error(span)).clone(),
+                    operator: Spanned::from(span, BinaryOpKind::Equal),
+                })),
+                span,
+            );
+            let message = exprs.get(2).cloned();
+            StatementKind::Constrain(ConstrainStatement(
+                predicate,
+                message,
+                ConstrainKind::AssertEq,
+            ))
+        })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::{
+        parser::parser::{
+            expression,
+            test_helpers::{parse_all, parse_all_failing, parse_with},
+        },
+        Literal,
+    };
+
+    /// Deprecated constrain usage test
+    #[test]
+    fn parse_constrain() {
+        let errors = parse_with(constrain(expression()), "constrain x == y").unwrap_err();
+        assert_eq!(errors.len(), 1);
+        assert!(format!("{}", errors.first().unwrap()).contains("deprecated"));
+
+        // Currently we disallow constrain statements where the outer infix operator
+        // produces a value. This would require an implicit `==` which
+        // may not be intuitive to the user.
+        //
+        // If this is deemed useful, one would either apply a transformation
+        // or interpret it with an `==` in the evaluator
+        let disallowed_operators = vec![
+            BinaryOpKind::And,
+            BinaryOpKind::Subtract,
+            BinaryOpKind::Divide,
+            BinaryOpKind::Multiply,
+            BinaryOpKind::Or,
+        ];
+
+        for operator in disallowed_operators {
+            let src = format!("constrain x {} y;", operator.as_string());
+            let errors = parse_with(constrain(expression()), &src).unwrap_err();
+            assert_eq!(errors.len(), 2);
+            assert!(format!("{}", errors.first().unwrap()).contains("deprecated"));
+        }
+
+        // These are general cases which should always work.
+        //
+        // The first case is the most noteworthy. It contains two `==`
+        // The first (inner) `==` is a predicate which returns 0/1
+        // The outer layer is an infix `==` which is
+        // associated with the Constrain statement
+        let errors = parse_all_failing(
+            constrain(expression()),
+            vec![
+                "constrain ((x + y) == k) + z == y",
+                "constrain (x + !y) == y",
+                "constrain (x ^ y) == y",
+                "constrain (x ^ y) == (y + m)",
+                "constrain x + x ^ x == y | m",
+            ],
+        );
+        assert_eq!(errors.len(), 5);
+        assert!(errors
+            .iter()
+            .all(|err| { err.is_error() && err.to_string().contains("deprecated") }));
+    }
+
+    /// This is the standard way to declare an assert statement
+    #[test]
+    fn parse_assert() {
+        parse_with(assertion(expression()), "assert(x == y)").unwrap();
+
+        // Currently we disallow constrain statements where the outer infix operator
+        // produces a value. This would require an implicit `==` which
+        // may not be intuitive to the user.
+        //
+        // If this is deemed useful, one would either apply a transformation
+        // or interpret it with an `==` in the evaluator
+        let disallowed_operators = vec![
+            BinaryOpKind::And,
+            BinaryOpKind::Subtract,
+            BinaryOpKind::Divide,
+            BinaryOpKind::Multiply,
+            BinaryOpKind::Or,
+        ];
+
+        for operator in disallowed_operators {
+            let src = format!("assert(x {} y);", operator.as_string());
+            parse_with(assertion(expression()), &src).unwrap_err();
+        }
+
+        // These are general cases which should always work.
+        //
+        // The first case is the most noteworthy. It contains two `==`
+        // The first (inner) `==` is a predicate which returns 0/1
+        // The outer layer is an infix `==` which is
+        // associated with the Constrain statement
+        parse_all(
+            assertion(expression()),
+            vec![
+                "assert(((x + y) == k) + z == y)",
+                "assert((x + !y) == y)",
+                "assert((x ^ y) == y)",
+                "assert((x ^ y) == (y + m))",
+                "assert(x + x ^ x == y | m)",
+            ],
+        );
+
+        match parse_with(assertion(expression()), "assert(x == y, \"assertion message\")").unwrap()
+        {
+            StatementKind::Constrain(ConstrainStatement(_, message, _)) => {
+                let message = message.unwrap();
+                match message.kind {
+                    ExpressionKind::Literal(Literal::Str(message_string)) => {
+                        assert_eq!(message_string, "assertion message".to_owned());
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    /// This is the standard way to assert that two expressions are equivalent
+    #[test]
+    fn parse_assert_eq() {
+        parse_all(
+            assertion_eq(expression()),
+            vec![
+                "assert_eq(x, y)",
+                "assert_eq(((x + y) == k) + z, y)",
+                "assert_eq(x + !y, y)",
+                "assert_eq(x ^ y, y)",
+                "assert_eq(x ^ y, y + m)",
+                "assert_eq(x + x ^ x, y | m)",
+            ],
+        );
+        match parse_with(assertion_eq(expression()), "assert_eq(x, y, \"assertion message\")")
+            .unwrap()
+        {
+            StatementKind::Constrain(ConstrainStatement(_, message, _)) => {
+                let message = message.unwrap();
+                match message.kind {
+                    ExpressionKind::Literal(Literal::Str(message_string)) => {
+                        assert_eq!(message_string, "assertion message".to_owned());
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/attributes.rs b/compiler/noirc_frontend/src/parser/parser/attributes.rs
new file mode 100644
index 00000000000..4b256a95c8b
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/attributes.rs
@@ -0,0 +1,46 @@
+use chumsky::Parser;
+use noirc_errors::Span;
+
+use crate::{
+    parser::{NoirParser, ParserError, ParserErrorReason},
+    token::{Attribute, Attributes, Token, TokenKind},
+};
+
+use super::primitives::token_kind;
+
+fn attribute() -> impl NoirParser<Attribute> {
+    token_kind(TokenKind::Attribute).map(|token| match token {
+        Token::Attribute(attribute) => attribute,
+        _ => unreachable!("Parser should have already errored due to token not being an attribute"),
+    })
+}
+
+pub(super) fn attributes() -> impl NoirParser<Vec<Attribute>> {
+    attribute().repeated()
+}
+
+pub(super) fn validate_attributes(
+    attributes: Vec<Attribute>,
+    span: Span,
+    emit: &mut dyn FnMut(ParserError),
+) -> Attributes {
+    let mut primary = None;
+    let mut secondary = Vec::new();
+
+    for attribute in attributes {
+        match attribute {
+            Attribute::Function(attr) => {
+                if primary.is_some() {
+                    emit(ParserError::with_reason(
+                        ParserErrorReason::MultipleFunctionAttributesFound,
+                        span,
+                    ));
+                }
+                primary = Some(attr);
+            }
+            Attribute::Secondary(attr) => secondary.push(attr),
+        }
+    }
+
+    Attributes { function: primary, secondary }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
new file mode 100644
index 00000000000..0d34c719061
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -0,0 +1,224 @@
+use super::{
+    attributes::{attributes, validate_attributes},
+    block, fresh_statement, ident, keyword, nothing, optional_distinctness, optional_visibility,
+    parameter_name_recovery, parameter_recovery, parenthesized, parse_type, pattern,
+    self_parameter, where_clause, NoirParser,
+};
+use crate::parser::labels::ParsingRuleLabel;
+use crate::parser::spanned;
+use crate::token::{Keyword, Token};
+use crate::{
+    Distinctness, FunctionDefinition, FunctionReturnType, FunctionVisibility, Ident, NoirFunction,
+    Param, Visibility,
+};
+
+use chumsky::prelude::*;
+
+/// function_definition: attribute function_modifiers 'fn' ident generics '(' function_parameters ')' function_return_type block
+///                      function_modifiers 'fn' ident generics '(' function_parameters ')' function_return_type block
+pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunction> {
+    attributes()
+        .then(function_modifiers())
+        .then_ignore(keyword(Keyword::Fn))
+        .then(ident())
+        .then(generics())
+        .then(parenthesized(function_parameters(allow_self)))
+        .then(function_return_type())
+        .then(where_clause())
+        .then(spanned(block(fresh_statement())))
+        .validate(|(((args, ret), where_clause), (body, body_span)), span, emit| {
+            let ((((attributes, modifiers), name), generics), parameters) = args;
+
+            // Validate collected attributes, filtering them into function and secondary variants
+            let attributes = validate_attributes(attributes, span, emit);
+            FunctionDefinition {
+                span: body_span,
+                name,
+                attributes,
+                is_unconstrained: modifiers.0,
+                is_open: modifiers.2,
+                is_internal: modifiers.3,
+                visibility: if modifiers.1 {
+                    FunctionVisibility::PublicCrate
+                } else if modifiers.4 {
+                    FunctionVisibility::Public
+                } else {
+                    FunctionVisibility::Private
+                },
+                generics,
+                parameters,
+                body,
+                where_clause,
+                return_type: ret.1,
+                return_visibility: ret.0 .1,
+                return_distinctness: ret.0 .0,
+            }
+            .into()
+        })
+}
+
+/// function_modifiers: 'unconstrained'? 'pub(crate)'? 'pub'? 'open'? 'internal'?
+///
+/// returns (is_unconstrained, is_pub_crate, is_open, is_internal, is_pub) for whether each keyword was present
+fn function_modifiers() -> impl NoirParser<(bool, bool, bool, bool, bool)> {
+    keyword(Keyword::Unconstrained)
+        .or_not()
+        .then(is_pub_crate())
+        .then(keyword(Keyword::Pub).or_not())
+        .then(keyword(Keyword::Open).or_not())
+        .then(keyword(Keyword::Internal).or_not())
+        .map(|((((unconstrained, pub_crate), public), open), internal)| {
+            (
+                unconstrained.is_some(),
+                pub_crate,
+                open.is_some(),
+                internal.is_some(),
+                public.is_some(),
+            )
+        })
+}
+
+fn is_pub_crate() -> impl NoirParser<bool> {
+    (keyword(Keyword::Pub)
+        .then_ignore(just(Token::LeftParen))
+        .then_ignore(keyword(Keyword::Crate))
+        .then_ignore(just(Token::RightParen)))
+    .or_not()
+    .map(|a| a.is_some())
+}
+
+/// non_empty_ident_list: ident ',' non_empty_ident_list
+///                     | ident
+///
+/// generics: '<' non_empty_ident_list '>'
+///         | %empty
+pub(super) fn generics() -> impl NoirParser<Vec<Ident>> {
+    ident()
+        .separated_by(just(Token::Comma))
+        .allow_trailing()
+        .at_least(1)
+        .delimited_by(just(Token::Less), just(Token::Greater))
+        .or_not()
+        .map(|opt| opt.unwrap_or_default())
+}
+
+fn function_return_type() -> impl NoirParser<((Distinctness, Visibility), FunctionReturnType)> {
+    just(Token::Arrow)
+        .ignore_then(optional_distinctness())
+        .then(optional_visibility())
+        .then(spanned(parse_type()))
+        .or_not()
+        .map_with_span(|ret, span| match ret {
+            Some((head, (ty, _))) => (head, FunctionReturnType::Ty(ty)),
+            None => (
+                (Distinctness::DuplicationAllowed, Visibility::Private),
+                FunctionReturnType::Default(span),
+            ),
+        })
+}
+
+fn function_parameters<'a>(allow_self: bool) -> impl NoirParser<Vec<Param>> + 'a {
+    let typ = parse_type().recover_via(parameter_recovery());
+
+    let full_parameter = pattern()
+        .recover_via(parameter_name_recovery())
+        .then_ignore(just(Token::Colon))
+        .then(optional_visibility())
+        .then(typ)
+        .map_with_span(|((pattern, visibility), typ), span| Param {
+            visibility,
+            pattern,
+            typ,
+            span,
+        });
+
+    let self_parameter = if allow_self { self_parameter().boxed() } else { nothing().boxed() };
+
+    let parameter = full_parameter.or(self_parameter);
+
+    parameter
+        .separated_by(just(Token::Comma))
+        .allow_trailing()
+        .labelled(ParsingRuleLabel::Parameter)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::parser::test_helpers::*;
+
+    #[test]
+    fn regression_skip_comment() {
+        parse_all(
+            function_definition(false),
+            vec![
+                "fn main(
+                // This comment should be skipped
+                x : Field,
+                // And this one
+                y : Field,
+            ) {
+            }",
+                "fn main(x : Field, y : Field,) {
+                foo::bar(
+                    // Comment for x argument
+                    x,
+                    // Comment for y argument
+                    y
+                )
+            }",
+            ],
+        );
+    }
+
+    #[test]
+    fn parse_function() {
+        parse_all(
+            function_definition(false),
+            vec![
+                "fn func_name() {}",
+                "fn f(foo: pub u8, y : pub Field) -> u8 { x + a }",
+                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
+                "fn func_name(f: Field, y : pub Field, z : pub [u8;5],) {}",
+                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
+                "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
+                "fn func_name(x: [Field], y : [Field;2],y : pub [Field;2], z : pub [u8;5])  {}",
+                "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }",
+                "fn f(f: pub Field, y : Field, z : comptime Field) -> u8 { x + a }",
+                "fn f<T>(f: pub Field, y : T, z : comptime Field) -> u8 { x + a }",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2 {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait, T: SomeTrait2 {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A> + SomeTrait2 {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A, B> + SomeTrait2 {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A, B> + SomeTrait2<C> {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2<C> {}",
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2<C> + TraitY {}",
+                "fn func_name<T>(f: Field, y : T, z : U) where SomeStruct<T>: SomeTrait<U> {}",
+                // 'where u32: SomeTrait' is allowed in Rust.
+                // It will result in compiler error in case SomeTrait isn't implemented for u32.
+                "fn func_name<T>(f: Field, y : T) where u32: SomeTrait {}",
+                // A trailing plus is allowed by Rust, so we support it as well.
+                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + {}",
+                // The following should produce compile error on later stage. From the parser's perspective it's fine
+                "fn func_name<A>(f: Field, y : Field, z : Field) where T: SomeTrait {}",
+            ],
+        );
+
+        parse_all_failing(
+            function_definition(false),
+            vec![
+                "fn x2( f: []Field,,) {}",
+                "fn ( f: []Field) {}",
+                "fn ( f: []Field) {}",
+                // TODO: Check for more specific error messages
+                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) where T: {}",
+                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) where SomeTrait {}",
+                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) SomeTrait {}",
+                // A leading plus is not allowed.
+                "fn func_name<T>(f: Field, y : T) where T: + SomeTrait {}",
+                "fn func_name<T>(f: Field, y : T) where T: TraitX + <Y> {}",
+            ],
+        );
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/lambdas.rs b/compiler/noirc_frontend/src/parser/parser/lambdas.rs
new file mode 100644
index 00000000000..48ddd41ab44
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/lambdas.rs
@@ -0,0 +1,42 @@
+use chumsky::{primitive::just, Parser};
+
+use crate::{
+    parser::{labels::ParsingRuleLabel, parameter_name_recovery, parameter_recovery, NoirParser},
+    token::Token,
+    Expression, ExpressionKind, Lambda, Pattern, UnresolvedType,
+};
+
+use super::{parse_type, pattern};
+
+pub(super) fn lambda<'a>(
+    expr_parser: impl NoirParser<Expression> + 'a,
+) -> impl NoirParser<ExpressionKind> + 'a {
+    lambda_parameters()
+        .delimited_by(just(Token::Pipe), just(Token::Pipe))
+        .then(lambda_return_type())
+        .then(expr_parser)
+        .map(|((parameters, return_type), body)| {
+            ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
+        })
+}
+
+fn lambda_parameters() -> impl NoirParser<Vec<(Pattern, UnresolvedType)>> {
+    let typ = parse_type().recover_via(parameter_recovery());
+    let typ = just(Token::Colon).ignore_then(typ);
+
+    let parameter = pattern()
+        .recover_via(parameter_name_recovery())
+        .then(typ.or_not().map(|typ| typ.unwrap_or_else(UnresolvedType::unspecified)));
+
+    parameter
+        .separated_by(just(Token::Comma))
+        .allow_trailing()
+        .labelled(ParsingRuleLabel::Parameter)
+}
+
+fn lambda_return_type() -> impl NoirParser<UnresolvedType> {
+    just(Token::Arrow)
+        .ignore_then(parse_type())
+        .or_not()
+        .map(|ret| ret.unwrap_or_else(UnresolvedType::unspecified))
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/literals.rs b/compiler/noirc_frontend/src/parser/parser/literals.rs
new file mode 100644
index 00000000000..32f4f03de2e
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/literals.rs
@@ -0,0 +1,157 @@
+use chumsky::Parser;
+
+use crate::{
+    parser::NoirParser,
+    token::{Token, TokenKind},
+    ExpressionKind,
+};
+
+use super::primitives::token_kind;
+
+pub(super) fn literal() -> impl NoirParser<ExpressionKind> {
+    token_kind(TokenKind::Literal).map(|token| match token {
+        Token::Int(x) => ExpressionKind::integer(x),
+        Token::Bool(b) => ExpressionKind::boolean(b),
+        Token::Str(s) => ExpressionKind::string(s),
+        Token::RawStr(s, hashes) => ExpressionKind::raw_string(s, hashes),
+        Token::FmtStr(s) => ExpressionKind::format_string(s),
+        unexpected => unreachable!("Non-literal {} parsed as a literal", unexpected),
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::parser::{
+        expression, expression_no_constructors, fresh_statement, term, test_helpers::*,
+    };
+    use crate::Literal;
+
+    fn expr_to_lit(expr: ExpressionKind) -> Literal {
+        match expr {
+            ExpressionKind::Literal(literal) => literal,
+            _ => unreachable!("expected a literal"),
+        }
+    }
+
+    #[test]
+    fn parse_int() {
+        let int = parse_with(literal(), "5").unwrap();
+        let hex = parse_with(literal(), "0x05").unwrap();
+
+        match (expr_to_lit(int), expr_to_lit(hex)) {
+            (Literal::Integer(int, false), Literal::Integer(hex, false)) => assert_eq!(int, hex),
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn parse_string() {
+        let expr = parse_with(literal(), r#""hello""#).unwrap();
+        match expr_to_lit(expr) {
+            Literal::Str(s) => assert_eq!(s, "hello"),
+            _ => unreachable!(),
+        };
+    }
+
+    #[test]
+    fn parse_bool() {
+        let expr_true = parse_with(literal(), "true").unwrap();
+        let expr_false = parse_with(literal(), "false").unwrap();
+
+        match (expr_to_lit(expr_true), expr_to_lit(expr_false)) {
+            (Literal::Bool(t), Literal::Bool(f)) => {
+                assert!(t);
+                assert!(!f);
+            }
+            _ => unreachable!(),
+        };
+    }
+
+    #[test]
+    fn parse_unary() {
+        parse_all(
+            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
+            vec!["!hello", "-hello", "--hello", "-!hello", "!-hello"],
+        );
+        parse_all_failing(
+            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
+            vec!["+hello", "/hello"],
+        );
+    }
+
+    #[test]
+    fn parse_raw_string_expr() {
+        let cases = vec![
+            Case { source: r#" r"foo" "#, expect: r#"r"foo""#, errors: 0 },
+            Case { source: r##" r#"foo"# "##, expect: r##"r#"foo"#"##, errors: 0 },
+            // backslash
+            Case { source: r#" r"\\" "#, expect: r#"r"\\""#, errors: 0 },
+            Case { source: r##" r#"\"# "##, expect: r##"r#"\"#"##, errors: 0 },
+            Case { source: r##" r#"\\"# "##, expect: r##"r#"\\"#"##, errors: 0 },
+            Case { source: r##" r#"\\\"# "##, expect: r##"r#"\\\"#"##, errors: 0 },
+            // escape sequence
+            Case {
+                source: r##" r#"\t\n\\t\\n\\\t\\\n\\\\"# "##,
+                expect: r##"r#"\t\n\\t\\n\\\t\\\n\\\\"#"##,
+                errors: 0,
+            },
+            Case { source: r##" r#"\\\\\\\\"# "##, expect: r##"r#"\\\\\\\\"#"##, errors: 0 },
+            // mismatch - errors:
+            Case { source: r###" r#"foo"## "###, expect: r##"r#"foo"#"##, errors: 1 },
+            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
+            // mismatch: short:
+            Case { source: r##" r"foo"# "##, expect: r#"r"foo""#, errors: 1 },
+            Case { source: r#" r#"foo" "#, expect: "(none)", errors: 2 },
+            // empty string
+            Case { source: r#"r"""#, expect: r#"r"""#, errors: 0 },
+            Case { source: r####"r###""###"####, expect: r####"r###""###"####, errors: 0 },
+            // miscellaneous
+            Case { source: r##" r#\"foo\"# "##, expect: "plain::r", errors: 2 },
+            Case { source: r#" r\"foo\" "#, expect: "plain::r", errors: 1 },
+            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
+            // missing 'r' letter
+            Case { source: r##" ##"foo"# "##, expect: r#""foo""#, errors: 2 },
+            Case { source: r#" #"foo" "#, expect: "plain::foo", errors: 2 },
+            // whitespace
+            Case { source: r##" r #"foo"# "##, expect: "plain::r", errors: 2 },
+            Case { source: r##" r# "foo"# "##, expect: "plain::r", errors: 3 },
+            Case { source: r#" r#"foo" # "#, expect: "(none)", errors: 2 },
+            // after identifier
+            Case { source: r##" bar#"foo"# "##, expect: "plain::bar", errors: 2 },
+            // nested
+            Case {
+                source: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
+                expect: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
+                errors: 0,
+            },
+        ];
+
+        check_cases_with_errors(&cases[..], expression());
+    }
+
+    #[test]
+    fn parse_raw_string_lit() {
+        let lit_cases = vec![
+            Case { source: r#" r"foo" "#, expect: r#"r"foo""#, errors: 0 },
+            Case { source: r##" r#"foo"# "##, expect: r##"r#"foo"#"##, errors: 0 },
+            // backslash
+            Case { source: r#" r"\\" "#, expect: r#"r"\\""#, errors: 0 },
+            Case { source: r##" r#"\"# "##, expect: r##"r#"\"#"##, errors: 0 },
+            Case { source: r##" r#"\\"# "##, expect: r##"r#"\\"#"##, errors: 0 },
+            Case { source: r##" r#"\\\"# "##, expect: r##"r#"\\\"#"##, errors: 0 },
+            // escape sequence
+            Case {
+                source: r##" r#"\t\n\\t\\n\\\t\\\n\\\\"# "##,
+                expect: r##"r#"\t\n\\t\\n\\\t\\\n\\\\"#"##,
+                errors: 0,
+            },
+            Case { source: r##" r#"\\\\\\\\"# "##, expect: r##"r#"\\\\\\\\"#"##, errors: 0 },
+            // mismatch - errors:
+            Case { source: r###" r#"foo"## "###, expect: r##"r#"foo"#"##, errors: 1 },
+            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
+        ];
+
+        check_cases_with_errors(&lit_cases[..], literal());
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/path.rs b/compiler/noirc_frontend/src/parser/parser/path.rs
new file mode 100644
index 00000000000..ab812c07dce
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/path.rs
@@ -0,0 +1,78 @@
+use crate::parser::NoirParser;
+use crate::{Path, PathKind};
+
+use crate::token::{Keyword, Token};
+
+use chumsky::prelude::*;
+
+use super::{ident, keyword};
+
+pub(super) fn path() -> impl NoirParser<Path> {
+    let idents = || ident().separated_by(just(Token::DoubleColon)).at_least(1);
+    let make_path = |kind| move |segments, span| Path { segments, kind, span };
+
+    let prefix = |key| keyword(key).ignore_then(just(Token::DoubleColon));
+    let path_kind = |key, kind| prefix(key).ignore_then(idents()).map_with_span(make_path(kind));
+
+    choice((
+        path_kind(Keyword::Crate, PathKind::Crate),
+        path_kind(Keyword::Dep, PathKind::Dep),
+        idents().map_with_span(make_path(PathKind::Plain)),
+    ))
+}
+
+fn empty_path() -> impl NoirParser<Path> {
+    let make_path = |kind| move |_, span| Path { segments: Vec::new(), kind, span };
+    let path_kind = |key, kind| keyword(key).map_with_span(make_path(kind));
+
+    choice((path_kind(Keyword::Crate, PathKind::Crate), path_kind(Keyword::Dep, PathKind::Dep)))
+}
+
+pub(super) fn maybe_empty_path() -> impl NoirParser<Path> {
+    path().or(empty_path())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::parser::test_helpers::{parse_all_failing, parse_with};
+
+    #[test]
+    fn parse_path() {
+        let cases = vec![
+            ("std", vec!["std"]),
+            ("std::hash", vec!["std", "hash"]),
+            ("std::hash::collections", vec!["std", "hash", "collections"]),
+            ("dep::foo::bar", vec!["foo", "bar"]),
+            ("crate::std::hash", vec!["std", "hash"]),
+        ];
+
+        for (src, expected_segments) in cases {
+            let path: Path = parse_with(path(), src).unwrap();
+            for (segment, expected) in path.segments.into_iter().zip(expected_segments) {
+                assert_eq!(segment.0.contents, expected);
+            }
+        }
+
+        parse_all_failing(path(), vec!["std::", "::std", "std::hash::", "foo::1"]);
+    }
+
+    #[test]
+    fn parse_path_kinds() {
+        let cases = vec![
+            ("std", PathKind::Plain),
+            ("dep::hash::collections", PathKind::Dep),
+            ("crate::std::hash", PathKind::Crate),
+        ];
+
+        for (src, expected_path_kind) in cases {
+            let path = parse_with(path(), src).unwrap();
+            assert_eq!(path.kind, expected_path_kind);
+        }
+
+        parse_all_failing(
+            path(),
+            vec!["dep", "crate", "crate::std::crate", "foo::bar::crate", "foo::dep"],
+        );
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/primitives.rs b/compiler/noirc_frontend/src/parser/parser/primitives.rs
new file mode 100644
index 00000000000..34927278038
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/primitives.rs
@@ -0,0 +1,101 @@
+use chumsky::prelude::*;
+
+use crate::{
+    parser::{labels::ParsingRuleLabel, ExprParser, NoirParser, ParserError},
+    token::{Keyword, Token, TokenKind},
+    ExpressionKind, Ident, UnaryOp,
+};
+
+use super::path;
+
+/// This parser always parses no input and fails
+pub(super) fn nothing<T>() -> impl NoirParser<T> {
+    one_of([]).map(|_| unreachable!("parser should always error"))
+}
+
+pub(super) fn keyword(keyword: Keyword) -> impl NoirParser<Token> {
+    just(Token::Keyword(keyword))
+}
+
+pub(super) fn token_kind(token_kind: TokenKind) -> impl NoirParser<Token> {
+    filter_map(move |span, found: Token| {
+        if found.kind() == token_kind {
+            Ok(found)
+        } else {
+            Err(ParserError::expected_label(
+                ParsingRuleLabel::TokenKind(token_kind.clone()),
+                found,
+                span,
+            ))
+        }
+    })
+}
+
+pub(super) fn ident() -> impl NoirParser<Ident> {
+    token_kind(TokenKind::Ident).map_with_span(Ident::from_token)
+}
+
+// Right-shift (>>) is issued as two separate > tokens by the lexer as this makes it easier
+// to parse nested generic types. For normal expressions however, it means we have to manually
+// parse two greater-than tokens as a single right-shift here.
+pub(super) fn right_shift_operator() -> impl NoirParser<Token> {
+    just(Token::Greater).then(just(Token::Greater)).to(Token::ShiftRight)
+}
+
+pub(super) fn not<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    just(Token::Bang).ignore_then(term_parser).map(|rhs| ExpressionKind::prefix(UnaryOp::Not, rhs))
+}
+
+pub(super) fn negation<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    just(Token::Minus)
+        .ignore_then(term_parser)
+        .map(|rhs| ExpressionKind::prefix(UnaryOp::Minus, rhs))
+}
+
+pub(super) fn mutable_reference<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    just(Token::Ampersand)
+        .ignore_then(keyword(Keyword::Mut))
+        .ignore_then(term_parser)
+        .map(|rhs| ExpressionKind::prefix(UnaryOp::MutableReference, rhs))
+}
+
+pub(super) fn dereference<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    just(Token::Star)
+        .ignore_then(term_parser)
+        .map(|rhs| ExpressionKind::prefix(UnaryOp::Dereference { implicitly_added: false }, rhs))
+}
+
+pub(super) fn variable() -> impl NoirParser<ExpressionKind> {
+    path().map(ExpressionKind::Variable)
+}
+
+#[cfg(test)]
+mod test {
+    use crate::parser::parser::{
+        expression, expression_no_constructors, fresh_statement, term, test_helpers::*,
+    };
+
+    #[test]
+    fn parse_unary() {
+        parse_all(
+            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
+            vec!["!hello", "-hello", "--hello", "-!hello", "!-hello"],
+        );
+        parse_all_failing(
+            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
+            vec!["+hello", "/hello"],
+        );
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/structs.rs b/compiler/noirc_frontend/src/parser/parser/structs.rs
new file mode 100644
index 00000000000..0212f56783f
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/structs.rs
@@ -0,0 +1,97 @@
+use chumsky::prelude::*;
+use noirc_errors::Span;
+
+use crate::{
+    macros_api::SecondaryAttribute,
+    parser::{
+        parser::{
+            attributes::attributes,
+            function, parse_type,
+            primitives::{ident, keyword},
+        },
+        NoirParser, ParserError, ParserErrorReason, TopLevelStatement,
+    },
+    token::{Attribute, Keyword, Token},
+    Ident, NoirStruct, UnresolvedType,
+};
+
+pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatement> {
+    use self::Keyword::Struct;
+    use Token::*;
+
+    let fields = struct_fields()
+        .delimited_by(just(LeftBrace), just(RightBrace))
+        .recover_with(nested_delimiters(
+            LeftBrace,
+            RightBrace,
+            [(LeftParen, RightParen), (LeftBracket, RightBracket)],
+            |_| vec![],
+        ))
+        .or(just(Semicolon).to(Vec::new()));
+
+    attributes()
+        .then_ignore(keyword(Struct))
+        .then(ident())
+        .then(function::generics())
+        .then(fields)
+        .validate(|(((raw_attributes, name), generics), fields), span, emit| {
+            let attributes = validate_struct_attributes(raw_attributes, span, emit);
+            TopLevelStatement::Struct(NoirStruct { name, attributes, generics, fields, span })
+        })
+}
+
+fn struct_fields() -> impl NoirParser<Vec<(Ident, UnresolvedType)>> {
+    ident()
+        .then_ignore(just(Token::Colon))
+        .then(parse_type())
+        .separated_by(just(Token::Comma))
+        .allow_trailing()
+}
+
+fn validate_struct_attributes(
+    attributes: Vec<Attribute>,
+    span: Span,
+    emit: &mut dyn FnMut(ParserError),
+) -> Vec<SecondaryAttribute> {
+    let mut struct_attributes = vec![];
+
+    for attribute in attributes {
+        match attribute {
+            Attribute::Function(..) => {
+                emit(ParserError::with_reason(
+                    ParserErrorReason::NoFunctionAttributesAllowedOnStruct,
+                    span,
+                ));
+            }
+            Attribute::Secondary(attr) => struct_attributes.push(attr),
+        }
+    }
+
+    struct_attributes
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::parser::test_helpers::*;
+
+    #[test]
+    fn parse_structs() {
+        let cases = vec![
+            "struct Foo;",
+            "struct Foo { }",
+            "struct Bar { ident: Field, }",
+            "struct Baz { ident: Field, other: Field }",
+            "#[attribute] struct Baz { ident: Field, other: Field }",
+        ];
+        parse_all(struct_definition(), cases);
+
+        let failing = vec![
+            "struct {  }",
+            "struct Foo { bar: pub Field }",
+            "struct Foo { bar: pub Field }",
+            "#[oracle(some)] struct Foo { bar: Field }",
+        ];
+        parse_all_failing(struct_definition(), failing);
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/test_helpers.rs b/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
new file mode 100644
index 00000000000..6b8cb80a0a0
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
@@ -0,0 +1,122 @@
+use chumsky::primitive::just;
+use chumsky::Parser;
+use iter_extended::vecmap;
+use noirc_errors::CustomDiagnostic;
+
+use crate::{
+    lexer::Lexer,
+    parser::{force, NoirParser},
+    token::Token,
+};
+
+pub(crate) fn parse_with<P, T>(parser: P, program: &str) -> Result<T, Vec<CustomDiagnostic>>
+where
+    P: NoirParser<T>,
+{
+    let (tokens, lexer_errors) = Lexer::lex(program);
+    if !lexer_errors.is_empty() {
+        return Err(vecmap(lexer_errors, Into::into));
+    }
+    parser.then_ignore(just(Token::EOF)).parse(tokens).map_err(|errors| vecmap(errors, Into::into))
+}
+
+pub(crate) fn parse_recover<P, T>(parser: P, program: &str) -> (Option<T>, Vec<CustomDiagnostic>)
+where
+    P: NoirParser<T>,
+{
+    let (tokens, lexer_errors) = Lexer::lex(program);
+    let (opt, errs) = parser.then_ignore(force(just(Token::EOF))).parse_recovery(tokens);
+
+    let mut errors = vecmap(lexer_errors, Into::into);
+    errors.extend(errs.into_iter().map(Into::into));
+
+    (opt, errors)
+}
+
+pub(crate) fn parse_all<P, T>(parser: P, programs: Vec<&str>) -> Vec<T>
+where
+    P: NoirParser<T>,
+{
+    vecmap(programs, move |program| {
+        let message = format!("Failed to parse:\n{program}");
+        let (op_t, diagnostics) = parse_recover(&parser, program);
+        diagnostics.iter().for_each(|diagnostic| {
+            if diagnostic.is_error() {
+                panic!("{} with error {}", &message, diagnostic);
+            }
+        });
+        op_t.expect(&message)
+    })
+}
+
+pub(crate) fn parse_all_failing<P, T>(parser: P, programs: Vec<&str>) -> Vec<CustomDiagnostic>
+where
+    P: NoirParser<T>,
+    T: std::fmt::Display,
+{
+    programs
+            .into_iter()
+            .flat_map(|program| match parse_with(&parser, program) {
+                Ok(expr) => {
+                    unreachable!(
+                        "Expected this input to fail:\n{}\nYet it successfully parsed as:\n{}",
+                        program, expr
+                    )
+                }
+                Err(diagnostics) => {
+                    if diagnostics.iter().all(|diagnostic: &CustomDiagnostic| diagnostic.is_warning()) {
+                        unreachable!(
+                            "Expected at least one error when parsing:\n{}\nYet it successfully parsed without errors:\n",
+                            program
+                        )
+                    };
+                    diagnostics
+                }
+            })
+            .collect()
+}
+
+#[derive(Copy, Clone)]
+pub(crate) struct Case {
+    pub(crate) source: &'static str,
+    pub(crate) errors: usize,
+    pub(crate) expect: &'static str,
+}
+
+pub(crate) fn check_cases_with_errors<T, P>(cases: &[Case], parser: P)
+where
+    P: NoirParser<T> + Clone,
+    T: std::fmt::Display,
+{
+    let show_errors = |v| vecmap(&v, ToString::to_string).join("\n");
+
+    let results = vecmap(cases, |&case| {
+        let (opt, errors) = parse_recover(parser.clone(), case.source);
+        let actual = opt.map(|ast| ast.to_string());
+        let actual = if let Some(s) = &actual { s.to_string() } else { "(none)".to_string() };
+
+        let result = ((errors.len(), actual.clone()), (case.errors, case.expect.to_string()));
+        if result.0 != result.1 {
+            let num_errors = errors.len();
+            let shown_errors = show_errors(errors);
+            eprintln!(
+                concat!(
+                    "\nExpected {expected_errors} error(s) and got {num_errors}:",
+                    "\n\n{shown_errors}",
+                    "\n\nFrom input:   {src}",
+                    "\nExpected AST: {expected_result}",
+                    "\nActual AST:   {actual}\n",
+                ),
+                expected_errors = case.errors,
+                num_errors = num_errors,
+                shown_errors = shown_errors,
+                src = case.source,
+                expected_result = case.expect,
+                actual = actual,
+            );
+        }
+        result
+    });
+
+    assert_eq!(vecmap(&results, |t| t.0.clone()), vecmap(&results, |t| t.1.clone()),);
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
new file mode 100644
index 00000000000..0d72fbd5303
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -0,0 +1,217 @@
+use chumsky::prelude::*;
+
+use super::{
+    block, expression, fresh_statement, function, function_declaration_parameters,
+    function_return_type,
+};
+
+use crate::{
+    parser::{
+        ignore_then_commit, parenthesized, parser::primitives::keyword, NoirParser, ParserError,
+        ParserErrorReason, TopLevelStatement,
+    },
+    token::{Keyword, Token},
+    Expression, FunctionVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem, TraitItem,
+    UnresolvedTraitConstraint, UnresolvedType,
+};
+
+use super::{generic_type_args, parse_type, path, primitives::ident};
+
+pub(super) fn trait_definition() -> impl NoirParser<TopLevelStatement> {
+    keyword(Keyword::Trait)
+        .ignore_then(ident())
+        .then(function::generics())
+        .then(where_clause())
+        .then_ignore(just(Token::LeftBrace))
+        .then(trait_body())
+        .then_ignore(just(Token::RightBrace))
+        .map_with_span(|(((name, generics), where_clause), items), span| {
+            TopLevelStatement::Trait(NoirTrait { name, generics, where_clause, span, items })
+        })
+}
+
+fn trait_body() -> impl NoirParser<Vec<TraitItem>> {
+    trait_function_declaration()
+        .or(trait_type_declaration())
+        .or(trait_constant_declaration())
+        .repeated()
+}
+
+fn optional_default_value() -> impl NoirParser<Option<Expression>> {
+    ignore_then_commit(just(Token::Assign), expression()).or_not()
+}
+
+fn trait_constant_declaration() -> impl NoirParser<TraitItem> {
+    keyword(Keyword::Let)
+        .ignore_then(ident())
+        .then_ignore(just(Token::Colon))
+        .then(parse_type())
+        .then(optional_default_value())
+        .then_ignore(just(Token::Semicolon))
+        .validate(|((name, typ), default_value), span, emit| {
+            emit(ParserError::with_reason(
+                ParserErrorReason::ExperimentalFeature("Associated constants"),
+                span,
+            ));
+            TraitItem::Constant { name, typ, default_value }
+        })
+}
+
+/// trait_function_declaration: 'fn' ident generics '(' declaration_parameters ')' function_return_type
+fn trait_function_declaration() -> impl NoirParser<TraitItem> {
+    let trait_function_body_or_semicolon =
+        block(fresh_statement()).map(Option::from).or(just(Token::Semicolon).to(Option::None));
+
+    keyword(Keyword::Fn)
+        .ignore_then(ident())
+        .then(function::generics())
+        .then(parenthesized(function_declaration_parameters()))
+        .then(function_return_type().map(|(_, typ)| typ))
+        .then(where_clause())
+        .then(trait_function_body_or_semicolon)
+        .map(|(((((name, generics), parameters), return_type), where_clause), body)| {
+            TraitItem::Function { name, generics, parameters, return_type, where_clause, body }
+        })
+}
+
+/// trait_type_declaration: 'type' ident generics
+fn trait_type_declaration() -> impl NoirParser<TraitItem> {
+    keyword(Keyword::Type).ignore_then(ident()).then_ignore(just(Token::Semicolon)).validate(
+        |name, span, emit| {
+            emit(ParserError::with_reason(
+                ParserErrorReason::ExperimentalFeature("Associated types"),
+                span,
+            ));
+            TraitItem::Type { name }
+        },
+    )
+}
+
+/// Parses a trait implementation, implementing a particular trait for a type.
+/// This has a similar syntax to `implementation`, but the `for type` clause is required,
+/// and an optional `where` clause is also useable.
+///
+/// trait_implementation: 'impl' generics ident generic_args for type '{' trait_implementation_body '}'
+pub(super) fn trait_implementation() -> impl NoirParser<TopLevelStatement> {
+    keyword(Keyword::Impl)
+        .ignore_then(function::generics())
+        .then(path())
+        .then(generic_type_args(parse_type()))
+        .then_ignore(keyword(Keyword::For))
+        .then(parse_type())
+        .then(where_clause())
+        .then_ignore(just(Token::LeftBrace))
+        .then(trait_implementation_body())
+        .then_ignore(just(Token::RightBrace))
+        .map(|args| {
+            let ((other_args, where_clause), items) = args;
+            let (((impl_generics, trait_name), trait_generics), object_type) = other_args;
+
+            TopLevelStatement::TraitImpl(NoirTraitImpl {
+                impl_generics,
+                trait_name,
+                trait_generics,
+                object_type,
+                items,
+                where_clause,
+            })
+        })
+}
+
+fn trait_implementation_body() -> impl NoirParser<Vec<TraitImplItem>> {
+    let function = function::function_definition(true).validate(|mut f, span, emit| {
+        if f.def().is_internal
+            || f.def().is_unconstrained
+            || f.def().is_open
+            || f.def().visibility != FunctionVisibility::Private
+        {
+            emit(ParserError::with_reason(ParserErrorReason::TraitImplFunctionModifiers, span));
+        }
+        // Trait impl functions are always public
+        f.def_mut().visibility = FunctionVisibility::Public;
+        TraitImplItem::Function(f)
+    });
+
+    let alias = keyword(Keyword::Type)
+        .ignore_then(ident())
+        .then_ignore(just(Token::Assign))
+        .then(parse_type())
+        .then_ignore(just(Token::Semicolon))
+        .map(|(name, alias)| TraitImplItem::Type { name, alias });
+
+    function.or(alias).repeated()
+}
+
+fn where_clause() -> impl NoirParser<Vec<UnresolvedTraitConstraint>> {
+    struct MultiTraitConstraint {
+        typ: UnresolvedType,
+        trait_bounds: Vec<TraitBound>,
+    }
+
+    let constraints = parse_type()
+        .then_ignore(just(Token::Colon))
+        .then(trait_bounds())
+        .map(|(typ, trait_bounds)| MultiTraitConstraint { typ, trait_bounds });
+
+    keyword(Keyword::Where)
+        .ignore_then(constraints.separated_by(just(Token::Comma)))
+        .or_not()
+        .map(|option| option.unwrap_or_default())
+        .map(|x: Vec<MultiTraitConstraint>| {
+            let mut result: Vec<UnresolvedTraitConstraint> = Vec::new();
+            for constraint in x {
+                for bound in constraint.trait_bounds {
+                    result.push(UnresolvedTraitConstraint {
+                        typ: constraint.typ.clone(),
+                        trait_bound: bound,
+                    });
+                }
+            }
+            result
+        })
+}
+
+fn trait_bounds() -> impl NoirParser<Vec<TraitBound>> {
+    trait_bound().separated_by(just(Token::Plus)).at_least(1).allow_trailing()
+}
+
+fn trait_bound() -> impl NoirParser<TraitBound> {
+    path().then(generic_type_args(parse_type())).map(|(trait_path, trait_generics)| TraitBound {
+        trait_path,
+        trait_generics,
+        trait_id: None,
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::parser::test_helpers::*;
+
+    #[test]
+    fn parse_trait() {
+        parse_all(
+            trait_definition(),
+            vec![
+                // Empty traits are legal in Rust and sometimes used as a way to whitelist certain types
+                // for a particular operation. Also known as `tag` or `marker` traits:
+                // https://stackoverflow.com/questions/71895489/what-is-the-purpose-of-defining-empty-impl-in-rust
+                "trait Empty {}",
+                "trait TraitWithDefaultBody { fn foo(self) {} }",
+                "trait TraitAcceptingMutableRef { fn foo(&mut self); }",
+                "trait TraitWithTypeBoundOperation { fn identity() -> Self; }",
+                "trait TraitWithAssociatedType { type Element; fn item(self, index: Field) -> Self::Element; }",
+                "trait TraitWithAssociatedConstant { let Size: Field; }",
+                "trait TraitWithAssociatedConstantWithDefaultValue { let Size: Field = 10; }",
+                "trait GenericTrait<T> { fn elem(&mut self, index: Field) -> T; }",
+                "trait GenericTraitWithConstraints<T> where T: SomeTrait { fn elem(self, index: Field) -> T; }",
+                "trait TraitWithMultipleGenericParams<A, B, C> where A: SomeTrait, B: AnotherTrait<C> { let Size: Field; fn zero() -> Self; }",
+            ],
+        );
+
+        parse_all_failing(
+            trait_definition(),
+            vec!["trait MissingBody", "trait WrongDelimiter { fn foo() -> u8, fn bar() -> u8 }"],
+        );
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
new file mode 100644
index 00000000000..572397d6527
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -0,0 +1,172 @@
+use super::{
+    expression_with_precedence, keyword, nothing, parenthesized, NoirParser, ParserError,
+    ParserErrorReason, Precedence,
+};
+use crate::ast::{UnresolvedType, UnresolvedTypeData};
+
+use crate::parser::labels::ParsingRuleLabel;
+use crate::token::{Keyword, Token};
+use crate::{Recoverable, UnresolvedTypeExpression};
+
+use chumsky::prelude::*;
+use noirc_errors::Span;
+
+fn maybe_comp_time() -> impl NoirParser<()> {
+    keyword(Keyword::CompTime).or_not().validate(|opt, span, emit| {
+        if opt.is_some() {
+            emit(ParserError::with_reason(ParserErrorReason::ComptimeDeprecated, span));
+        }
+    })
+}
+
+pub(super) fn parenthesized_type(
+    recursive_type_parser: impl NoirParser<UnresolvedType>,
+) -> impl NoirParser<UnresolvedType> {
+    recursive_type_parser
+        .delimited_by(just(Token::LeftParen), just(Token::RightParen))
+        .map_with_span(|typ, span| UnresolvedType {
+            typ: UnresolvedTypeData::Parenthesized(Box::new(typ)),
+            span: span.into(),
+        })
+}
+
+pub(super) fn field_type() -> impl NoirParser<UnresolvedType> {
+    maybe_comp_time()
+        .then_ignore(keyword(Keyword::Field))
+        .map_with_span(|_, span| UnresolvedTypeData::FieldElement.with_span(span))
+}
+
+pub(super) fn bool_type() -> impl NoirParser<UnresolvedType> {
+    maybe_comp_time()
+        .then_ignore(keyword(Keyword::Bool))
+        .map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
+}
+
+pub(super) fn string_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::String)
+        .ignore_then(
+            type_expression().delimited_by(just(Token::Less), just(Token::Greater)).or_not(),
+        )
+        .map_with_span(|expr, span| UnresolvedTypeData::String(expr).with_span(span))
+}
+
+pub(super) fn format_string_type(
+    type_parser: impl NoirParser<UnresolvedType>,
+) -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::FormatString)
+        .ignore_then(
+            type_expression()
+                .then_ignore(just(Token::Comma))
+                .then(type_parser)
+                .delimited_by(just(Token::Less), just(Token::Greater)),
+        )
+        .map_with_span(|(size, fields), span| {
+            UnresolvedTypeData::FormatString(size, Box::new(fields)).with_span(span)
+        })
+}
+
+pub(super) fn int_type() -> impl NoirParser<UnresolvedType> {
+    maybe_comp_time()
+        .then(filter_map(|span, token: Token| match token {
+            Token::IntType(int_type) => Ok(int_type),
+            unexpected => {
+                Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
+            }
+        }))
+        .validate(|(_, token), span, emit| {
+            UnresolvedTypeData::from_int_token(token)
+                .map(|data| data.with_span(span))
+                .unwrap_or_else(|err| {
+                    emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
+                    UnresolvedType::error(span)
+                })
+        })
+}
+
+pub(super) fn array_type(
+    type_parser: impl NoirParser<UnresolvedType>,
+) -> impl NoirParser<UnresolvedType> {
+    just(Token::LeftBracket)
+        .ignore_then(type_parser)
+        .then(just(Token::Semicolon).ignore_then(type_expression()).or_not())
+        .then_ignore(just(Token::RightBracket))
+        .map_with_span(|(element_type, size), span| {
+            UnresolvedTypeData::Array(size, Box::new(element_type)).with_span(span)
+        })
+}
+
+pub(super) fn type_expression() -> impl NoirParser<UnresolvedTypeExpression> {
+    recursive(|expr| {
+        expression_with_precedence(
+            Precedence::lowest_type_precedence(),
+            expr,
+            nothing(),
+            nothing(),
+            true,
+            false,
+        )
+    })
+    .labelled(ParsingRuleLabel::TypeExpression)
+    .try_map(UnresolvedTypeExpression::from_expr)
+}
+
+pub(super) fn tuple_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
+where
+    T: NoirParser<UnresolvedType>,
+{
+    let fields = type_parser.separated_by(just(Token::Comma)).allow_trailing();
+    parenthesized(fields).map_with_span(|fields, span| {
+        if fields.is_empty() {
+            UnresolvedTypeData::Unit.with_span(span)
+        } else {
+            UnresolvedTypeData::Tuple(fields).with_span(span)
+        }
+    })
+}
+
+pub(super) fn function_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
+where
+    T: NoirParser<UnresolvedType>,
+{
+    let args = parenthesized(type_parser.clone().separated_by(just(Token::Comma)).allow_trailing());
+
+    let env = just(Token::LeftBracket)
+        .ignore_then(type_parser.clone())
+        .then_ignore(just(Token::RightBracket))
+        .or_not()
+        .map_with_span(|t, span| {
+            t.unwrap_or_else(|| UnresolvedTypeData::Unit.with_span(Span::empty(span.end())))
+        });
+
+    keyword(Keyword::Fn)
+        .ignore_then(env)
+        .then(args)
+        .then_ignore(just(Token::Arrow))
+        .then(type_parser)
+        .map_with_span(|((env, args), ret), span| {
+            UnresolvedTypeData::Function(args, Box::new(ret), Box::new(env)).with_span(span)
+        })
+}
+
+pub(super) fn mutable_reference_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
+where
+    T: NoirParser<UnresolvedType>,
+{
+    just(Token::Ampersand)
+        .ignore_then(keyword(Keyword::Mut))
+        .ignore_then(type_parser)
+        .map_with_span(|element, span| {
+            UnresolvedTypeData::MutableReference(Box::new(element)).with_span(span)
+        })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::parser::test_helpers::*;
+
+    #[test]
+    fn parse_type_expression() {
+        parse_all(type_expression(), vec!["(123)", "123", "(1 + 1)", "(1 + (1))"]);
+    }
+}

From 261531d096f43844eb12a245a3c1d4ece0a88692 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 28 Feb 2024 10:23:31 -0600
Subject: [PATCH 024/416] chore: Document BoundedVec (#4430)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4348

## Summary\*

Documents `BoundedVec`

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../standard_library/containers/boundedvec.md | 210 ++++++++++++++++++
 .../noir_test_success/bounded_vec/src/main.nr | 154 ++++++++++++-
 2 files changed, 357 insertions(+), 7 deletions(-)
 create mode 100644 docs/docs/noir/standard_library/containers/boundedvec.md

diff --git a/docs/docs/noir/standard_library/containers/boundedvec.md b/docs/docs/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..cd0f725f870
--- /dev/null
+++ b/docs/docs/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,210 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+#include_code new_example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+#include_code get_unchecked_example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+#include_code bounded-vec-push-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+#include_code bounded-vec-pop-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+#include_code bounded-vec-len-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+#include_code bounded-vec-max-len-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+#include_code bounded-vec-storage-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+#include_code bounded-vec-extend-from-array-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+#include_code bounded-vec-extend-from-bounded-vec-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+#include_code bounded-vec-any-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
diff --git a/test_programs/noir_test_success/bounded_vec/src/main.nr b/test_programs/noir_test_success/bounded_vec/src/main.nr
index 0e2c89c9064..22ec291f9d6 100644
--- a/test_programs/noir_test_success/bounded_vec/src/main.nr
+++ b/test_programs/noir_test_success/bounded_vec/src/main.nr
@@ -1,3 +1,31 @@
+#[test]
+fn test_vec_new_foo() {
+    foo();
+}
+
+#[test(should_fail)]
+fn test_vec_new_bad() {
+    bad();
+}
+
+// docs:start:new_example
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+// docs:end:new_example
+
 #[test]
 fn test_vec_push_pop() {
     let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
@@ -15,13 +43,123 @@ fn test_vec_push_pop() {
     assert(vec.get(1) == 4);
 }
 
+#[test]
+fn test_vec_get_unchecked<N>() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2, 3, 4]);
+    let sum = sum_of_first_three(vec);
+    assert_eq(sum, 6);
+}
+
+// docs:start:get_unchecked_example
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+// docs:end:get_unchecked_example
+
+#[test(should_fail_with = "push out of bounds")]
+fn push_docs_example() {
+    // docs:start:bounded-vec-push-example
+    let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+    // docs:end:bounded-vec-push-example
+}
+
+#[test]
+fn pop_docs_example() {
+    // docs:start:bounded-vec-pop-example
+    let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+    // docs:end:bounded-vec-pop-example
+}
+
+#[test]
+fn len_docs_example() {
+    // docs:start:bounded-vec-len-example
+    let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+    // docs:end:bounded-vec-len-example
+}
+
+#[test]
+fn max_len_docs_example() {
+    // docs:start:bounded-vec-max-len-example
+    let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+    // docs:end:bounded-vec-max-len-example
+}
+
+#[test]
+fn storage_docs_example() {
+    // docs:start:bounded-vec-storage-example
+    let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+    // docs:end:bounded-vec-storage-example
+}
+
 #[test]
 fn test_vec_extend_from_array() {
+    // docs:start:bounded-vec-extend-from-array-example
     let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     vec.extend_from_array([2, 4]);
+
     assert(vec.len == 2);
     assert(vec.get(0) == 2);
     assert(vec.get(1) == 4);
+    // docs:end:bounded-vec-extend-from-array-example
+}
+
+#[test]
+fn test_vec_extend_from_bounded_vec() {
+    // docs:start:bounded-vec-extend-from-bounded-vec-example
+    let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+    // docs:end:bounded-vec-extend-from-bounded-vec-example
 }
 
 #[test(should_fail_with="extend_from_array out of bounds")]
@@ -88,12 +226,13 @@ fn test_vec_extend_from_bounded_vec_twice_out_of_bound() {
 
 #[test]
 fn test_vec_any() {
-    let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
-    vec.extend_from_array([2, 4, 6]);
-    assert(vec.any(|v| v == 2) == true);
-    assert(vec.any(|v| v == 4) == true);
-    assert(vec.any(|v| v == 6) == true);
-    assert(vec.any(|v| v == 3) == false);
+    // docs:start:bounded-vec-any-example
+    let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+    // docs:end:bounded-vec-any-example
 }
 
 #[test]
@@ -101,5 +240,6 @@ fn test_vec_any_not_default() {
     let default_value = 0;
     let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     vec.extend_from_array([2, 4]);
-    assert(vec.any(|v| v == default_value) == false);
+    assert(!vec.any(|v| v == default_value));
 }
+

From f2105fed292fc8d3ee6c3722e9dedb8b3b16453d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 28 Feb 2024 20:08:24 +0000
Subject: [PATCH 025/416] chore: create parser specifically for function
 visibility (#4425)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR creates a parser for `'pub(crate)'|'pub'|''` which returns the
`FunctionVisibility`. This allows parsing visibility more reusable for
when we add visibility for imports, structs, etc.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/parser/parser/function.rs             | 51 ++++++++-----------
 1 file changed, 22 insertions(+), 29 deletions(-)

diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 0d34c719061..42ee484bfc9 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -38,13 +38,7 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
                 is_unconstrained: modifiers.0,
                 is_open: modifiers.2,
                 is_internal: modifiers.3,
-                visibility: if modifiers.1 {
-                    FunctionVisibility::PublicCrate
-                } else if modifiers.4 {
-                    FunctionVisibility::Public
-                } else {
-                    FunctionVisibility::Private
-                },
+                visibility: modifiers.1,
                 generics,
                 parameters,
                 body,
@@ -57,36 +51,35 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
         })
 }
 
-/// function_modifiers: 'unconstrained'? 'pub(crate)'? 'pub'? 'open'? 'internal'?
+/// visibility_modifier: 'pub(crate)'? 'pub'? ''
+fn visibility_modifier() -> impl NoirParser<FunctionVisibility> {
+    let is_pub_crate = (keyword(Keyword::Pub)
+        .then_ignore(just(Token::LeftParen))
+        .then_ignore(keyword(Keyword::Crate))
+        .then_ignore(just(Token::RightParen)))
+    .map(|_| FunctionVisibility::PublicCrate);
+
+    let is_pub = keyword(Keyword::Pub).map(|_| FunctionVisibility::Public);
+
+    let is_private = empty().map(|_| FunctionVisibility::Private);
+
+    choice((is_pub_crate, is_pub, is_private))
+}
+
+/// function_modifiers: 'unconstrained'? (visibility)? 'open'? 'internal'?
 ///
-/// returns (is_unconstrained, is_pub_crate, is_open, is_internal, is_pub) for whether each keyword was present
-fn function_modifiers() -> impl NoirParser<(bool, bool, bool, bool, bool)> {
+/// returns (is_unconstrained, visibility, is_open, is_internal) for whether each keyword was present
+fn function_modifiers() -> impl NoirParser<(bool, FunctionVisibility, bool, bool)> {
     keyword(Keyword::Unconstrained)
         .or_not()
-        .then(is_pub_crate())
-        .then(keyword(Keyword::Pub).or_not())
+        .then(visibility_modifier())
         .then(keyword(Keyword::Open).or_not())
         .then(keyword(Keyword::Internal).or_not())
-        .map(|((((unconstrained, pub_crate), public), open), internal)| {
-            (
-                unconstrained.is_some(),
-                pub_crate,
-                open.is_some(),
-                internal.is_some(),
-                public.is_some(),
-            )
+        .map(|(((unconstrained, visibility), open), internal)| {
+            (unconstrained.is_some(), visibility, open.is_some(), internal.is_some())
         })
 }
 
-fn is_pub_crate() -> impl NoirParser<bool> {
-    (keyword(Keyword::Pub)
-        .then_ignore(just(Token::LeftParen))
-        .then_ignore(keyword(Keyword::Crate))
-        .then_ignore(just(Token::RightParen)))
-    .or_not()
-    .map(|a| a.is_some())
-}
-
 /// non_empty_ident_list: ident ',' non_empty_ident_list
 ///                     | ident
 ///

From db9ea8481197286e38b89269aa6e8f14acf1ce93 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 28 Feb 2024 20:24:19 +0000
Subject: [PATCH 026/416] =?UTF-8?q?chore:=20only=20ignore=20Nargo.toml=20i?=
 =?UTF-8?q?n=20`test=5Fprograms`=20directory=20and=20not=20su=E2=80=A6=20(?=
 =?UTF-8?q?#4451)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…bdirectories

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 test_programs/.gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test_programs/.gitignore b/test_programs/.gitignore
index e98a2fb38b6..6da0100814a 100644
--- a/test_programs/.gitignore
+++ b/test_programs/.gitignore
@@ -1,3 +1,3 @@
 acir_artifacts
 execution_success/**/crs
-Nargo.toml
+./Nargo.toml

From cb1ceee58b11b0ce6f8845361af3418d13c506bd Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 29 Feb 2024 11:35:29 +0000
Subject: [PATCH 027/416] fix: build noir_codegen when publishing (#4448)

# Description

## Problem\*

Resolves #4446

## Summary\*

We're currently not building `noir_codegen` before we publish so I've
updated the build script.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index f460b3db711..4987602c709 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
     "build:types": "yarn workspace @noir-lang/types run build",
     "build:backend_barretenberg": "yarn workspace @noir-lang/backend_barretenberg run build",
     "build:noir_js": "yarn workspace @noir-lang/noir_js run build",
-    "build:js:only": "yarn build:types && yarn build:backend_barretenberg && yarn build:noir_js",
+    "build:js:only": "yarn workspaces foreach -vtp --from \"{@noir-lang/types,@noir-lang/backend_barretenberg,@noir-lang/noir_js,@noir-lang/noir_codegen}\" run build",
     "prepare:publish": "yarn clean && yarn install:from:nix && yarn build:js:only",
     "nightly:version": "yarn workspaces foreach run nightly:version",
     "publish:all": "yarn install && yarn workspaces foreach run publish"

From ebaf05ab10834dd10e04c7ea5130f96c6cdf98ed Mon Sep 17 00:00:00 2001
From: Jordan Ellis Coppard <jc+git@wz.ht>
Date: Thu, 29 Feb 2024 21:50:58 +0800
Subject: [PATCH 028/416] fix(flake): stop flake.nix removing ignored-tests.txt
 (#4455)

# Description

Fixes a problem with `flake.nix` that prevented building packages via
said flake.

## Problem\*

Currently `flake.nix` does not keep files ending with `.txt` when
building packages, this means
https://github.com/noir-lang/noir/blob/master/tooling/debugger/build.rs#L44
fails and so does the build.

<details>
<summary>Expand for full error trace.</summary>

```txt
@nix { "action": "setPhase", "phase": "unpackPhase" }
unpacking sources
unpacking source archive /nix/store/s9q28qnr32r9cd62pm3vapvq87ipdpyq-source
source root is source
@nix { "action": "setPhase", "phase": "patchPhase" }
patching sources
Executing configureCargoCommonVars
copying cargo artifacts from /nix/store/21iwpq5w9854ga1mmb8g4r4r2p20202b-nargo-deps-0.24.0/target to target
@nix { "action": "setPhase", "phase": "updateAutotoolsGnuConfigScriptsPhase" }
updateAutotoolsGnuConfigScriptsPhase
@nix { "action": "setPhase", "phase": "configurePhase" }
configuring
will append /private/tmp/nix-build-nargo-0.24.0.drv-0/source/.cargo-home/config.toml with contents of /nix/store/rl1r6p506a4hk57049rsql0cnd9f6236-vendor-cargo-deps/config.toml
default configurePhase, nothing to do
@nix { "action": "setPhase", "phase": "buildPhase" }
building
++ command cargo --version
cargo 1.73.0 (9c4383fb5 2023-08-26)
++ command cargo build --release --message-format json-render-diagnostics
   Compiling acir_field v0.40.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/acvm-repo/acir_field)
   Compiling iter-extended v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/compiler/utils/iter-extended)
   Compiling fm v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/compiler/fm)
   Compiling arena v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/compiler/utils/arena)
   Compiling noirc_driver v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/compiler/noirc_driver)
   Compiling nargo v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/tooling/nargo)
   Compiling bb_abstraction_leaks v0.11.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/tooling/bb_abstraction_leaks)
   Compiling nargo_fmt v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/tooling/nargo_fmt)
   Compiling bn254_blackbox_solver v0.39.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/acvm-repo/bn254_blackbox_solver)
   Compiling noir_debugger v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/tooling/debugger)
   Compiling nargo_cli v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/tooling/nargo_cli)
   Compiling brillig v0.40.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/acvm-repo/brillig)
error: failed to run custom build command for `noir_debugger v0.24.0 (/private/tmp/nix-build-nargo-0.24.0.drv-0/source/tooling/debugger)`
note: To improve backtraces for build dependencies, set the CARGO_PROFILE_RELEASE_BUILD_OVERRIDE_DEBUG=true environment variable to enable debug information generation.

Caused by:
  process didn't exit successfully: `/private/tmp/nix-build-nargo-0.24.0.drv-0/source/target/release/build/noir_debugger-64219c61a62b2d11/build-script-build` (exit status: 101)
  --- stdout
  cargo:rerun-if-changed=tests
  cargo:rerun-if-changed=ignored-tests.txt
  cargo:rerun-if-changed=/private/tmp/nix-build-nargo-0.24.0.drv-0/source/test_programs

  --- stderr
  thread 'main' panicked at tooling/debugger/build.rs:44:74:
  called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }
  stack backtrace:
     0: rust_begin_unwind
               at /rustc/cc66ad468955717ab92600c770da8c1601a4ff33/library/std/src/panicking.rs:595:5
     1: core::panicking::panic_fmt
               at /rustc/cc66ad468955717ab92600c770da8c1601a4ff33/library/core/src/panicking.rs:67:14
     2: core::result::unwrap_failed
               at /rustc/cc66ad468955717ab92600c770da8c1601a4ff33/library/core/src/result.rs:1652:5
     3: core::result::Result<T,E>::unwrap
     4: build_script_build::generate_debugger_tests
     5: build_script_build::main
     6: core::ops::function::FnOnce::call_once
  note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
warning: build failed, waiting for other jobs to finish..
```
</details>

<details>
<summary>Expand for the (probably poorly written) _consuming_
`flake.nix`</summary>

If you use the patched version `noir.url` (this PR) the build now works.

```nix
{
    description = "Tikan -- Fog of War Chess";

    inputs = {
        nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
        flake-parts.url = "github:hercules-ci/flake-parts";
        devshell.url = "github:numtide/devshell";
        noir.url = "github:noir-lang/noir/db9ea8481197286e38b89269aa6e8f14acf1ce93";
        # noir.url = "github:tsujp/noir/0cf043d81e2da7c4b23c4b18e0c3a944dd7ea017";
    };

    outputs = inputs@{ self, nixpkgs, flake-parts, ... }:
        flake-parts.lib.mkFlake { inherit inputs; } {
            imports = [
                inputs.devshell.flakeModule
            ];

            systems = [
                "aarch64-linux"
                "aarch64-darwin"
                "x86_64-linux"
                "x86_64-darwin"
            ];

            perSystem = { pkgs, ... }: rec {
                packages.noir = inputs.noir.packages;

                devshells.default = {
                    packages = with pkgs; [
                        bun
                    ] ++ [ packages.noir.${system}.nargo ];
                };
            };
        };
}
```
</details>

## Documentation\*

Check one:
- [x] No documentation needed.
- ~[ ] Documentation included in this PR.~
- ~[ ] **[Exceptional Case]** Documentation to be submitted in a
separate PR.~

# PR Checklist\*

- [x] I have tested the changes locally.
- ~[ ] I have formatted the changes with
[Prettier](https://prettier.io/) and/or `cargo fmt` on default
settings.~
---
 flake.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/flake.nix b/flake.nix
index 4c5db8bfaae..5125dad06be 100644
--- a/flake.nix
+++ b/flake.nix
@@ -81,7 +81,7 @@
           # Custom filter with various file extensions that we rely upon to build packages
           # Currently: `.nr`, `.sol`, `.sh`, `.json`, `.md` and `.wasm`
           filter = path: type:
-            (builtins.match ".*\.(nr|sol|sh|json|md|wasm)$" path != null) || (craneLib.filterCargoSources path type);
+            (builtins.match ".*\.(nr|sol|sh|json|md|wasm|txt)$" path != null) || (craneLib.filterCargoSources path type);
         };
 
         # TODO(#1198): It'd be nice to include these flags when running `cargo clippy` in a devShell.

From 21fc4b85763dccae6dce0a46a318718c3c913471 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Thu, 29 Feb 2024 17:42:28 +0100
Subject: [PATCH 029/416] feat: Add overflow and underflow checks for unsigned
 integers in brillig (#4445)

# Description

## Problem\*

When overflow checks were added they were only added for ACIR. This adds
add, sub and multiply overflow checks for unsigned operations in
brillig.

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 111 +++++++++++++++---
 .../noirc_evaluator/src/brillig/brillig_ir.rs |  30 +++--
 .../brillig_fns_as_values/Prover.toml         |   2 +-
 .../brillig_fns_as_values/src/main.nr         |   4 +-
 .../brillig_wrapping/Nargo.toml               |   6 +
 .../brillig_wrapping/Prover.toml              |   2 +
 .../brillig_wrapping/src/main.nr              |   8 ++
 .../brillig_overflow_checks/Nargo.toml        |   5 +
 .../brillig_overflow_checks/Prover.toml       |   0
 .../brillig_overflow_checks/src/main.nr       |  23 ++++
 10 files changed, 158 insertions(+), 33 deletions(-)
 create mode 100644 test_programs/execution_success/brillig_wrapping/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_wrapping/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_wrapping/src/main.nr
 create mode 100644 test_programs/noir_test_success/brillig_overflow_checks/Nargo.toml
 create mode 100644 test_programs/noir_test_success/brillig_overflow_checks/Prover.toml
 create mode 100644 test_programs/noir_test_success/brillig_overflow_checks/src/main.nr

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index f01f60252f6..a3ee3e7ca7e 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1,9 +1,7 @@
 use crate::brillig::brillig_ir::brillig_variable::{
     type_to_heap_value_type, BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable,
 };
-use crate::brillig::brillig_ir::{
-    BrilligBinaryOp, BrilligContext, BRILLIG_INTEGER_ARITHMETIC_BIT_SIZE,
-};
+use crate::brillig::brillig_ir::{BrilligBinaryOp, BrilligContext};
 use crate::ssa::ir::dfg::CallStack;
 use crate::ssa::ir::instruction::ConstrainError;
 use crate::ssa::ir::{
@@ -1197,7 +1195,7 @@ impl<'block> BrilligBlock<'block> {
         let left = self.convert_ssa_single_addr_value(binary.lhs, dfg);
         let right = self.convert_ssa_single_addr_value(binary.rhs, dfg);
 
-        let brillig_binary_op =
+        let (brillig_binary_op, is_signed) =
             convert_ssa_binary_op_to_brillig_binary_op(binary.operator, &binary_type);
 
         self.brillig_context.binary_instruction(
@@ -1206,6 +1204,93 @@ impl<'block> BrilligBlock<'block> {
             result_variable.address,
             brillig_binary_op,
         );
+
+        self.add_overflow_check(brillig_binary_op, left, right, result_variable, is_signed);
+    }
+
+    fn add_overflow_check(
+        &mut self,
+        binary_operation: BrilligBinaryOp,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+        result: SingleAddrVariable,
+        is_signed: bool,
+    ) {
+        let (op, bit_size) = if let BrilligBinaryOp::Integer { op, bit_size } = binary_operation {
+            (op, bit_size)
+        } else {
+            return;
+        };
+
+        match (op, is_signed) {
+            (BinaryIntOp::Add, false) => {
+                let condition = self.brillig_context.allocate_register();
+                // Check that lhs <= result
+                self.brillig_context.binary_instruction(
+                    left.address,
+                    result.address,
+                    condition,
+                    BrilligBinaryOp::Integer { op: BinaryIntOp::LessThanEquals, bit_size },
+                );
+                self.brillig_context.constrain_instruction(
+                    condition,
+                    Some("attempt to add with overflow".to_string()),
+                );
+                self.brillig_context.deallocate_register(condition);
+            }
+            (BinaryIntOp::Sub, false) => {
+                let condition = self.brillig_context.allocate_register();
+                // Check that rhs <= lhs
+                self.brillig_context.binary_instruction(
+                    right.address,
+                    left.address,
+                    condition,
+                    BrilligBinaryOp::Integer { op: BinaryIntOp::LessThanEquals, bit_size },
+                );
+                self.brillig_context.constrain_instruction(
+                    condition,
+                    Some("attempt to subtract with overflow".to_string()),
+                );
+                self.brillig_context.deallocate_register(condition);
+            }
+            (BinaryIntOp::Mul, false) => {
+                // Multiplication overflow is only possible for bit sizes > 1
+                if bit_size > 1 {
+                    let is_right_zero = self.brillig_context.allocate_register();
+                    let zero = self.brillig_context.make_constant(0_usize.into(), bit_size);
+                    self.brillig_context.binary_instruction(
+                        zero,
+                        right.address,
+                        is_right_zero,
+                        BrilligBinaryOp::Integer { op: BinaryIntOp::Equals, bit_size },
+                    );
+                    self.brillig_context.if_not_instruction(is_right_zero, |ctx| {
+                        let condition = ctx.allocate_register();
+                        // Check that result / rhs == lhs
+                        ctx.binary_instruction(
+                            result.address,
+                            right.address,
+                            condition,
+                            BrilligBinaryOp::Integer { op: BinaryIntOp::UnsignedDiv, bit_size },
+                        );
+                        ctx.binary_instruction(
+                            condition,
+                            left.address,
+                            condition,
+                            BrilligBinaryOp::Integer { op: BinaryIntOp::Equals, bit_size },
+                        );
+                        ctx.constrain_instruction(
+                            condition,
+                            Some("attempt to multiply with overflow".to_string()),
+                        );
+                        ctx.deallocate_register(condition);
+                    });
+                    self.brillig_context.deallocate_register(is_right_zero);
+                    self.brillig_context.deallocate_register(zero);
+                }
+            }
+            _ => {}
+        }
     }
 
     /// Converts an SSA `ValueId` into a `RegisterOrMemory`. Initializes if necessary.
@@ -1403,8 +1488,6 @@ impl<'block> BrilligBlock<'block> {
 }
 
 /// Returns the type of the operation considering the types of the operands
-/// TODO: SSA issues binary operations between fields and integers.
-/// This probably should be explicitly casted in SSA to avoid having to coerce at this level.
 pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type {
     match (lhs_type, rhs_type) {
         (_, Type::Function) | (Type::Function, _) => {
@@ -1419,10 +1502,6 @@ pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type
         (_, Type::Slice(..)) | (Type::Slice(..), _) => {
             unreachable!("Arrays are invalid in binary operations")
         }
-        // If either side is a Field constant then, we coerce into the type
-        // of the other operand
-        (Type::Numeric(NumericType::NativeField), typ)
-        | (typ, Type::Numeric(NumericType::NativeField)) => typ.clone(),
         // If both sides are numeric type, then we expect their types to be
         // the same.
         (Type::Numeric(lhs_type), Type::Numeric(rhs_type)) => {
@@ -1441,7 +1520,7 @@ pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type
 pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
     ssa_op: BinaryOp,
     typ: &Type,
-) -> BrilligBinaryOp {
+) -> (BrilligBinaryOp, bool) {
     // First get the bit size and whether its a signed integer, if it is a numeric type
     // if it is not,then we return None, indicating that
     // it is a Field.
@@ -1461,10 +1540,6 @@ pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
             BinaryOp::Mul => BrilligBinaryOp::Field { op: BinaryFieldOp::Mul },
             BinaryOp::Div => BrilligBinaryOp::Field { op: BinaryFieldOp::Div },
             BinaryOp::Eq => BrilligBinaryOp::Field { op: BinaryFieldOp::Equals },
-            BinaryOp::Lt => BrilligBinaryOp::Integer {
-                op: BinaryIntOp::LessThan,
-                bit_size: BRILLIG_INTEGER_ARITHMETIC_BIT_SIZE,
-            },
             _ => unreachable!(
                 "Field type cannot be used with {op}. This should have been caught by the frontend"
             ),
@@ -1500,7 +1575,9 @@ pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
 
     // If bit size is available then it is a binary integer operation
     match bit_size_signedness {
-        Some((bit_size, is_signed)) => binary_op_to_int_op(ssa_op, *bit_size, is_signed),
-        None => binary_op_to_field_op(ssa_op),
+        Some((bit_size, is_signed)) => {
+            (binary_op_to_int_op(ssa_op, *bit_size, is_signed), is_signed)
+        }
+        None => (binary_op_to_field_op(ssa_op), false),
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 90608974f98..f1a8f24ed03 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -29,17 +29,6 @@ use acvm::{
 use debug_show::DebugShow;
 use num_bigint::BigUint;
 
-/// Integer arithmetic in Brillig is limited to 127 bit
-/// integers.
-///
-/// We could lift this in the future and have Brillig
-/// do big integer arithmetic when it exceeds the field size
-/// or we could have users re-implement big integer arithmetic
-/// in Brillig.
-/// Since constrained functions do not have this property, it
-/// would mean that unconstrained functions will differ from
-/// constrained functions in terms of syntax compatibility.
-pub(crate) const BRILLIG_INTEGER_ARITHMETIC_BIT_SIZE: u32 = 127;
 /// The Brillig VM does not apply a limit to the memory address space,
 /// As a convention, we take use 64 bits. This means that we assume that
 /// memory has 2^64 memory slots.
@@ -356,6 +345,21 @@ impl BrilligContext {
         self.enter_section(end_section);
     }
 
+    /// This instruction issues a branch that jumps over the code generated by the given function if the condition is truthy
+    pub(crate) fn if_not_instruction(
+        &mut self,
+        condition: MemoryAddress,
+        f: impl FnOnce(&mut BrilligContext),
+    ) {
+        let (end_section, end_label) = self.reserve_next_section_label();
+
+        self.jump_if_instruction(condition, end_label.clone());
+
+        f(self);
+
+        self.enter_section(end_section);
+    }
+
     /// Adds a label to the next opcode
     pub(crate) fn enter_context<T: ToString>(&mut self, label: T) {
         self.debug_show.enter_context(label.to_string());
@@ -533,7 +537,7 @@ impl BrilligContext {
         result: MemoryAddress,
         operation: BrilligBinaryOp,
     ) {
-        self.debug_show.binary_instruction(lhs, rhs, result, operation.clone());
+        self.debug_show.binary_instruction(lhs, rhs, result, operation);
         match operation {
             BrilligBinaryOp::Field { op } => {
                 let opcode = BrilligOpcode::BinaryFieldOp { op, destination: result, lhs, rhs };
@@ -1082,7 +1086,7 @@ impl BrilligContext {
 }
 
 /// Type to encapsulate the binary operation types in Brillig
-#[derive(Clone)]
+#[derive(Clone, Copy)]
 pub(crate) enum BrilligBinaryOp {
     Field { op: BinaryFieldOp },
     Integer { op: BinaryIntOp, bit_size: u32 },
diff --git a/test_programs/execution_success/brillig_fns_as_values/Prover.toml b/test_programs/execution_success/brillig_fns_as_values/Prover.toml
index 11497a473bc..4dd6b405159 100644
--- a/test_programs/execution_success/brillig_fns_as_values/Prover.toml
+++ b/test_programs/execution_success/brillig_fns_as_values/Prover.toml
@@ -1 +1 @@
-x = "0"
+x = "1"
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index ea3148915b8..9248bff2f4c 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -7,9 +7,9 @@ struct MyStruct {
 fn main(x: u32) {
     assert(wrapper(increment, x) == x + 1);
     assert(wrapper(increment_acir, x) == x + 1);
-    assert(wrapper(decrement, x) == std::wrapping_sub(x, 1));
+    assert(wrapper(decrement, x) == x - 1);
     assert(wrapper_with_struct(MyStruct { operation: increment }, x) == x + 1);
-    assert(wrapper_with_struct(MyStruct { operation: decrement }, x) == std::wrapping_sub(x, 1));
+    assert(wrapper_with_struct(MyStruct { operation: decrement }, x) == x - 1);
     // https://github.com/noir-lang/noir/issues/1975
     assert(increment(x) == x + 1);
 }
diff --git a/test_programs/execution_success/brillig_wrapping/Nargo.toml b/test_programs/execution_success/brillig_wrapping/Nargo.toml
new file mode 100644
index 00000000000..a52246ba908
--- /dev/null
+++ b/test_programs/execution_success/brillig_wrapping/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "brillig_wrapping"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_wrapping/Prover.toml b/test_programs/execution_success/brillig_wrapping/Prover.toml
new file mode 100644
index 00000000000..346fd2764a7
--- /dev/null
+++ b/test_programs/execution_success/brillig_wrapping/Prover.toml
@@ -0,0 +1,2 @@
+x = 0
+y = 255
diff --git a/test_programs/execution_success/brillig_wrapping/src/main.nr b/test_programs/execution_success/brillig_wrapping/src/main.nr
new file mode 100644
index 00000000000..4153a466057
--- /dev/null
+++ b/test_programs/execution_success/brillig_wrapping/src/main.nr
@@ -0,0 +1,8 @@
+use dep::std;
+
+unconstrained fn main(x: u8, y: u8) {
+    assert(std::wrapping_sub(x, 1) == y);
+    assert(std::wrapping_add(y, 1) == x);
+    assert(std::wrapping_mul(y, y) == 1);
+}
+
diff --git a/test_programs/noir_test_success/brillig_overflow_checks/Nargo.toml b/test_programs/noir_test_success/brillig_overflow_checks/Nargo.toml
new file mode 100644
index 00000000000..b2d47d258ed
--- /dev/null
+++ b/test_programs/noir_test_success/brillig_overflow_checks/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "brillig_overflow_checks"
+type = "bin"
+authors = [""]
+[dependencies]
diff --git a/test_programs/noir_test_success/brillig_overflow_checks/Prover.toml b/test_programs/noir_test_success/brillig_overflow_checks/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr b/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
new file mode 100644
index 00000000000..5d73ef96d49
--- /dev/null
+++ b/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
@@ -0,0 +1,23 @@
+use dep::std::field::bn254::{TWO_POW_128, assert_gt};
+
+#[test(should_fail_with = "attempt to add with overflow")]
+unconstrained fn test_overflow_add() {
+    let a: u8 = 255;
+    let b: u8 = 1;
+    assert_eq(a + b, 0);
+}
+
+#[test(should_fail_with = "attempt to subtract with overflow")]
+unconstrained fn test_overflow_sub() {
+    let a: u8 = 0;
+    let b: u8 = 1;
+    assert_eq(a - b, 255);
+}
+
+#[test(should_fail_with = "attempt to multiply with overflow")]
+unconstrained fn test_overflow_mul() {
+    let a: u8 = 128;
+    let b: u8 = 2;
+    assert_eq(a * b, 0);
+}
+

From ac60ef5e12fcfb907fbdcff709d7cbad05f2b939 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 1 Mar 2024 04:18:23 -0600
Subject: [PATCH 030/416] fix: Variables from trait constraints being
 permanently bound over when used within a trait impl (#4450)

# Description

## Problem\*

Resolves #4436

## Summary\*

This issue stemmed from calling another trait method within an impl for
the trait. The trait method required a trait constraint of the same
trait to be valid and was using the trait with its original type
variables. These would later be bound over when an impl was searched for
for this trait.

I've added a somewhat hacky solution of avoiding inserting `t = t`
bindings from the trait constraint when checking identifiers. Avoiding
inserting this binding means `t` in this case will later be instantiated
to a fresh type variable later on in the `instantiate_with_bindings`
call.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/hir/type_check/expr.rs |  5 ++-
 compiler/noirc_frontend/src/hir_def/types.rs  |  2 +-
 .../regression_4436/Nargo.toml                |  5 +++
 .../regression_4436/src/main.nr               | 31 +++++++++++++++++++
 4 files changed, 41 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/execution_success/regression_4436/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_4436/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index b78f07c88f2..7b854e58fca 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -326,7 +326,10 @@ impl<'interner> TypeChecker<'interner> {
             assert_eq!(the_trait.generics.len(), constraint.trait_generics.len());
 
             for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics) {
-                bindings.insert(param.id(), (param.clone(), arg.clone()));
+                // Avoid binding t = t
+                if !arg.occurs(param.id()) {
+                    bindings.insert(param.id(), (param.clone(), arg.clone()));
+                }
             }
         }
 
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index e105da1ccf0..b70aa43701c 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -1558,7 +1558,7 @@ impl Type {
     }
 
     /// True if the given TypeVariableId is free anywhere within self
-    fn occurs(&self, target_id: TypeVariableId) -> bool {
+    pub fn occurs(&self, target_id: TypeVariableId) -> bool {
         match self {
             Type::Array(len, elem) => len.occurs(target_id) || elem.occurs(target_id),
             Type::String(len) => len.occurs(target_id),
diff --git a/test_programs/execution_success/regression_4436/Nargo.toml b/test_programs/execution_success/regression_4436/Nargo.toml
new file mode 100644
index 00000000000..0904d858596
--- /dev/null
+++ b/test_programs/execution_success/regression_4436/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "regression_4436"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.22.0"
diff --git a/test_programs/execution_success/regression_4436/src/main.nr b/test_programs/execution_success/regression_4436/src/main.nr
new file mode 100644
index 00000000000..834ea3250cc
--- /dev/null
+++ b/test_programs/execution_success/regression_4436/src/main.nr
@@ -0,0 +1,31 @@
+trait LibTrait<N> {
+    fn broadcast();
+    fn get_constant() -> Field;
+}
+
+global STRUCT_A_LEN: Field = 3;
+global STRUCT_B_LEN: Field = 5;
+
+struct StructA;
+struct StructB;
+
+impl LibTrait<u32> for StructA {
+    fn broadcast() {
+        Self::get_constant();
+    }
+
+    fn get_constant() -> Field {
+        1
+    }
+}
+impl LibTrait<u64> for StructB {
+    fn broadcast() {
+        Self::get_constant();
+    }
+
+    fn get_constant() -> Field {
+        1
+    }
+}
+
+fn main() {}

From cb4c1c5264b95d01f69d99f916ced71ad9cdc9d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Fri, 1 Mar 2024 11:51:00 +0100
Subject: [PATCH 031/416] feat: skip redundant range checks in brillig (#4460)

# Description

## Problem\*

Avoid codegening overhead for no-op range checks generated by
https://github.com/noir-lang/noir/issues/4456

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 59 ++++++++++---------
 1 file changed, 31 insertions(+), 28 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index a3ee3e7ca7e..c04d8475f08 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -624,37 +624,40 @@ impl<'block> BrilligBlock<'block> {
             }
             Instruction::RangeCheck { value, max_bit_size, assert_message } => {
                 let value = self.convert_ssa_single_addr_value(*value, dfg);
-                // Cast original value to field
-                let left = SingleAddrVariable {
-                    address: self.brillig_context.allocate_register(),
-                    bit_size: FieldElement::max_num_bits(),
-                };
-                self.convert_cast(left, value);
+                // SSA generates redundant range checks. A range check with a max bit size >= value.bit_size will always pass.
+                if value.bit_size > *max_bit_size {
+                    // Cast original value to field
+                    let left = SingleAddrVariable {
+                        address: self.brillig_context.allocate_register(),
+                        bit_size: FieldElement::max_num_bits(),
+                    };
+                    self.convert_cast(left, value);
 
-                // Create a field constant with the max
-                let max = BigUint::from(2_u128).pow(*max_bit_size) - BigUint::from(1_u128);
-                let right = self.brillig_context.make_constant(
-                    FieldElement::from_be_bytes_reduce(&max.to_bytes_be()).into(),
-                    FieldElement::max_num_bits(),
-                );
+                    // Create a field constant with the max
+                    let max = BigUint::from(2_u128).pow(*max_bit_size) - BigUint::from(1_u128);
+                    let right = self.brillig_context.make_constant(
+                        FieldElement::from_be_bytes_reduce(&max.to_bytes_be()).into(),
+                        FieldElement::max_num_bits(),
+                    );
 
-                // Check if lte max
-                let brillig_binary_op = BrilligBinaryOp::Integer {
-                    op: BinaryIntOp::LessThanEquals,
-                    bit_size: FieldElement::max_num_bits(),
-                };
-                let condition = self.brillig_context.allocate_register();
-                self.brillig_context.binary_instruction(
-                    left.address,
-                    right,
-                    condition,
-                    brillig_binary_op,
-                );
+                    // Check if lte max
+                    let brillig_binary_op = BrilligBinaryOp::Integer {
+                        op: BinaryIntOp::LessThanEquals,
+                        bit_size: FieldElement::max_num_bits(),
+                    };
+                    let condition = self.brillig_context.allocate_register();
+                    self.brillig_context.binary_instruction(
+                        left.address,
+                        right,
+                        condition,
+                        brillig_binary_op,
+                    );
 
-                self.brillig_context.constrain_instruction(condition, assert_message.clone());
-                self.brillig_context.deallocate_register(condition);
-                self.brillig_context.deallocate_register(left.address);
-                self.brillig_context.deallocate_register(right);
+                    self.brillig_context.constrain_instruction(condition, assert_message.clone());
+                    self.brillig_context.deallocate_register(condition);
+                    self.brillig_context.deallocate_register(left.address);
+                    self.brillig_context.deallocate_register(right);
+                }
             }
             Instruction::IncrementRc { value } => {
                 let rc_register = match self.convert_ssa_value(*value, dfg) {

From aad0da024c69663f42e6913e674682d5864b26ae Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 4 Mar 2024 10:08:39 +0000
Subject: [PATCH 032/416] feat: backpropagate constants in ACIR during
 optimization (#3926)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This is a mildy bruteforce-y optimisation method where we just literally
attempt to execute the circuit backwards. Any witnesses which we can
determine from this can just be written into the circuit directly.

A lot of the complexity here comes from the fact that memory opcodes,
etc. require witnesses to be unassigned at the point at which the opcode
is encountered so we need to "forget" certain witnesses so that we don't
optimise them away.

Draft as I'm just pushing this up to track effects.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .../opcodes/black_box_function_call.rs        |   6 +-
 .../optimizers/constant_backpropagation.rs    | 331 ++++++++++++++++++
 .../acvm/src/compiler/optimizers/general.rs   |  20 +-
 acvm-repo/acvm/src/compiler/optimizers/mod.rs |  21 +-
 acvm-repo/acvm/src/pwg/arithmetic.rs          |  38 +-
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |   2 +-
 acvm-repo/acvm/src/pwg/blackbox/range.rs      |   2 +-
 acvm-repo/acvm/src/pwg/brillig.rs             |   6 +-
 acvm-repo/acvm/src/pwg/directives/mod.rs      |   2 +-
 acvm-repo/acvm/src/pwg/memory_op.rs           |   2 +-
 acvm-repo/acvm/src/pwg/mod.rs                 |   6 +-
 cspell.json                                   |   2 +
 12 files changed, 403 insertions(+), 35 deletions(-)
 create mode 100644 acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs

diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index f73417a4b5b..8a0c4692282 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -217,8 +217,10 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
             | BlackBoxFuncCall::PedersenHash { inputs, .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
-            | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. }
-            | BlackBoxFuncCall::Sha256Compression { inputs, .. } => inputs.to_vec(),
+            | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. } => inputs.to_vec(),
+            BlackBoxFuncCall::Sha256Compression { inputs, hash_values, .. } => {
+                inputs.iter().chain(hash_values).copied().collect()
+            }
             BlackBoxFuncCall::AND { lhs, rhs, .. } | BlackBoxFuncCall::XOR { lhs, rhs, .. } => {
                 vec![*lhs, *rhs]
             }
diff --git a/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs b/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
new file mode 100644
index 00000000000..0e7d28104da
--- /dev/null
+++ b/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
@@ -0,0 +1,331 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+
+use crate::{
+    compiler::optimizers::GeneralOptimizer,
+    pwg::{
+        arithmetic::ExpressionSolver, blackbox::solve_range_opcode, directives::solve_directives,
+        BrilligSolver, BrilligSolverStatus,
+    },
+};
+use acir::{
+    circuit::{
+        brillig::{Brillig, BrilligInputs, BrilligOutputs},
+        directives::Directive,
+        opcodes::BlackBoxFuncCall,
+        Circuit, Opcode,
+    },
+    native_types::{Expression, Witness, WitnessMap},
+};
+use acvm_blackbox_solver::StubbedBlackBoxSolver;
+
+/// `ConstantBackpropagationOptimizer` will attempt to determine any constant witnesses within the program.
+/// It does this by attempting to solve the program without any inputs (i.e. using an empty witness map),
+/// any values which it can determine are then enforced to be constant values.
+///
+/// The optimizer will then replace any witnesses wherever they appear within the circuit with these constant values.
+/// This is repeated until the circuit stabilizes.
+pub(crate) struct ConstantBackpropagationOptimizer {
+    circuit: Circuit,
+}
+
+impl ConstantBackpropagationOptimizer {
+    /// Creates a new `ConstantBackpropagationOptimizer`
+    pub(crate) fn new(circuit: Circuit) -> Self {
+        Self { circuit }
+    }
+
+    fn gather_known_witnesses(&self) -> (WitnessMap, BTreeSet<Witness>) {
+        // We do not want to affect the circuit's interface so avoid optimizing away these witnesses.
+        let mut required_witnesses: BTreeSet<Witness> = self
+            .circuit
+            .private_parameters
+            .union(&self.circuit.public_parameters.0)
+            .chain(&self.circuit.return_values.0)
+            .copied()
+            .collect();
+
+        for opcode in &self.circuit.opcodes {
+            match &opcode {
+                Opcode::BlackBoxFuncCall(func_call) => {
+                    required_witnesses.extend(
+                        func_call.get_inputs_vec().into_iter().map(|func_input| func_input.witness),
+                    );
+                    required_witnesses.extend(func_call.get_outputs_vec());
+                }
+
+                Opcode::MemoryInit { init, .. } => {
+                    required_witnesses.extend(init);
+                }
+
+                Opcode::MemoryOp { op, .. } => {
+                    required_witnesses.insert(op.index.to_witness().unwrap());
+                    required_witnesses.insert(op.value.to_witness().unwrap());
+                }
+
+                _ => (),
+            };
+        }
+
+        let mut known_witnesses = WitnessMap::new();
+        for opcode in self.circuit.opcodes.iter().rev() {
+            if let Opcode::AssertZero(expr) = opcode {
+                let solve_result = ExpressionSolver::solve(&mut known_witnesses, expr);
+                // It doesn't matter what the result is. We expect most opcodes to not be solved successfully so we discard errors.
+                // At the same time, if the expression can be solved then we track this by the updates to `known_witnesses`
+                drop(solve_result);
+            }
+        }
+
+        // We want to retain any references to required witnesses so we "forget" these assignments.
+        let known_witnesses: BTreeMap<_, _> = known_witnesses
+            .into_iter()
+            .filter(|(witness, _)| !required_witnesses.contains(witness))
+            .collect();
+
+        (known_witnesses.into(), required_witnesses)
+    }
+
+    /// Returns a `Circuit` where with any constant witnesses replaced with the constant they resolve to.
+    #[tracing::instrument(level = "trace", skip_all)]
+    pub(crate) fn backpropagate_constants(
+        circuit: Circuit,
+        order_list: Vec<usize>,
+    ) -> (Circuit, Vec<usize>) {
+        let old_circuit_size = circuit.opcodes.len();
+
+        let optimizer = Self::new(circuit);
+        let (circuit, order_list) = optimizer.backpropagate_constants_iteration(order_list);
+
+        let new_circuit_size = circuit.opcodes.len();
+        if new_circuit_size < old_circuit_size {
+            Self::backpropagate_constants(circuit, order_list)
+        } else {
+            (circuit, order_list)
+        }
+    }
+
+    /// Applies a single round of constant backpropagation to a `Circuit`.
+    pub(crate) fn backpropagate_constants_iteration(
+        mut self,
+        order_list: Vec<usize>,
+    ) -> (Circuit, Vec<usize>) {
+        let (mut known_witnesses, required_witnesses) = self.gather_known_witnesses();
+
+        let opcodes = std::mem::take(&mut self.circuit.opcodes);
+
+        fn remap_expression(known_witnesses: &WitnessMap, expression: Expression) -> Expression {
+            GeneralOptimizer::optimize(ExpressionSolver::evaluate(&expression, known_witnesses))
+        }
+
+        let mut new_order_list = Vec::with_capacity(order_list.len());
+        let mut new_opcodes = Vec::with_capacity(opcodes.len());
+        for (idx, opcode) in opcodes.into_iter().enumerate() {
+            let new_opcode = match opcode {
+                Opcode::AssertZero(expression) => {
+                    let new_expr = remap_expression(&known_witnesses, expression);
+                    if new_expr.is_zero() {
+                        continue;
+                    }
+
+                    // Attempt to solve the opcode to see if we can determine the value of any witnesses in the expression.
+                    // We only do this _after_ we apply any simplifications to create the new opcode as we want to
+                    // keep the constraint on the witness which we are solving for here.
+                    let solve_result = ExpressionSolver::solve(&mut known_witnesses, &new_expr);
+                    // It doesn't matter what the result is. We expect most opcodes to not be solved successfully so we discard errors.
+                    // At the same time, if the expression can be solved then we track this by the updates to `known_witnesses`
+                    drop(solve_result);
+
+                    Opcode::AssertZero(new_expr)
+                }
+                Opcode::Brillig(brillig) => {
+                    let remapped_inputs = brillig
+                        .inputs
+                        .into_iter()
+                        .map(|input| match input {
+                            BrilligInputs::Single(expr) => {
+                                BrilligInputs::Single(remap_expression(&known_witnesses, expr))
+                            }
+                            BrilligInputs::Array(expr_array) => {
+                                let new_input: Vec<_> = expr_array
+                                    .into_iter()
+                                    .map(|expr| remap_expression(&known_witnesses, expr))
+                                    .collect();
+
+                                BrilligInputs::Array(new_input)
+                            }
+                            input @ BrilligInputs::MemoryArray(_) => input,
+                        })
+                        .collect();
+
+                    let remapped_predicate = brillig
+                        .predicate
+                        .map(|predicate| remap_expression(&known_witnesses, predicate));
+
+                    let new_brillig = Brillig {
+                        inputs: remapped_inputs,
+                        predicate: remapped_predicate,
+                        ..brillig
+                    };
+
+                    let brillig_output_is_required_witness =
+                        new_brillig.outputs.iter().any(|output| match output {
+                            BrilligOutputs::Simple(witness) => required_witnesses.contains(witness),
+                            BrilligOutputs::Array(witness_array) => witness_array
+                                .iter()
+                                .any(|witness| required_witnesses.contains(witness)),
+                        });
+
+                    if brillig_output_is_required_witness {
+                        // If one of the brillig opcode's outputs is a required witness then we can't remove the opcode. In this case we can't replace
+                        // all of the uses of this witness with the calculated constant so we'll be attempting to use an uninitialized witness.
+                        //
+                        // We then do not attempt execution of this opcode and just simplify the inputs.
+                        Opcode::Brillig(new_brillig)
+                    } else if let Ok(mut solver) = BrilligSolver::new(
+                        &known_witnesses,
+                        &HashMap::new(),
+                        &new_brillig,
+                        &StubbedBlackBoxSolver,
+                        idx,
+                    ) {
+                        match solver.solve() {
+                            Ok(BrilligSolverStatus::Finished) => {
+                                // Write execution outputs
+                                match solver.finalize(&mut known_witnesses, &new_brillig) {
+                                    Ok(()) => {
+                                        // If we've managed to execute the brillig opcode at compile time, we can now just write in the
+                                        // results as constants for the rest of the circuit.
+                                        continue;
+                                    }
+                                    _ => Opcode::Brillig(new_brillig),
+                                }
+                            }
+                            Ok(BrilligSolverStatus::InProgress) => unreachable!(
+                                "Solver should either finish, block on foreign call, or error."
+                            ),
+                            Ok(BrilligSolverStatus::ForeignCallWait(_)) | Err(_) => {
+                                Opcode::Brillig(new_brillig)
+                            }
+                        }
+                    } else {
+                        Opcode::Brillig(new_brillig)
+                    }
+                }
+
+                Opcode::Directive(Directive::ToLeRadix { a, b, radix }) => {
+                    if b.iter().all(|output| known_witnesses.contains_key(output)) {
+                        continue;
+                    } else if b.iter().any(|witness| required_witnesses.contains(witness)) {
+                        // If one of the brillig opcode's outputs is a required witness then we can't remove the opcode. In this case we can't replace
+                        // all of the uses of this witness with the calculated constant so we'll be attempting to use an uninitialized witness.
+                        //
+                        // We then do not attempt execution of this opcode and just simplify the inputs.
+                        Opcode::Directive(Directive::ToLeRadix {
+                            a: remap_expression(&known_witnesses, a),
+                            b,
+                            radix,
+                        })
+                    } else {
+                        let directive = Directive::ToLeRadix {
+                            a: remap_expression(&known_witnesses, a),
+                            b,
+                            radix,
+                        };
+                        let result = solve_directives(&mut known_witnesses, &directive);
+
+                        match result {
+                            Ok(()) => continue,
+                            Err(_) => Opcode::Directive(directive),
+                        }
+                    }
+                }
+
+                Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE { input }) => {
+                    if solve_range_opcode(&known_witnesses, &input).is_ok() {
+                        continue;
+                    } else {
+                        opcode
+                    }
+                }
+
+                Opcode::BlackBoxFuncCall(_)
+                | Opcode::MemoryOp { .. }
+                | Opcode::MemoryInit { .. } => opcode,
+            };
+
+            new_opcodes.push(new_opcode);
+            new_order_list.push(order_list[idx]);
+        }
+
+        self.circuit.opcodes = new_opcodes;
+
+        (self.circuit, new_order_list)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+
+    use crate::compiler::optimizers::constant_backpropagation::ConstantBackpropagationOptimizer;
+    use acir::{
+        brillig::MemoryAddress,
+        circuit::{
+            brillig::{Brillig, BrilligOutputs},
+            opcodes::{BlackBoxFuncCall, FunctionInput},
+            Circuit, ExpressionWidth, Opcode, PublicInputs,
+        },
+        native_types::Witness,
+    };
+    use brillig_vm::brillig::Opcode as BrilligOpcode;
+
+    fn test_circuit(opcodes: Vec<Opcode>) -> Circuit {
+        Circuit {
+            current_witness_index: 1,
+            expression_width: ExpressionWidth::Bounded { width: 3 },
+            opcodes,
+            private_parameters: BTreeSet::new(),
+            public_parameters: PublicInputs::default(),
+            return_values: PublicInputs::default(),
+            assert_messages: Default::default(),
+            recursive: false,
+        }
+    }
+
+    #[test]
+    fn retain_brillig_with_required_witness_outputs() {
+        let brillig_opcode = Opcode::Brillig(Brillig {
+            inputs: Vec::new(),
+            outputs: vec![BrilligOutputs::Simple(Witness(1))],
+            bytecode: vec![
+                BrilligOpcode::Const {
+                    destination: MemoryAddress(0),
+                    bit_size: 32,
+                    value: 1u128.into(),
+                },
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 1 },
+            ],
+            predicate: None,
+        });
+        let blackbox_opcode = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::AND {
+            lhs: FunctionInput { witness: Witness(1), num_bits: 64 },
+            rhs: FunctionInput { witness: Witness(2), num_bits: 64 },
+            output: Witness(3),
+        });
+
+        let opcodes = vec![brillig_opcode, blackbox_opcode];
+        // The optimizer should keep the lowest bit size range constraint
+        let circuit = test_circuit(opcodes);
+        let acir_opcode_positions = circuit.opcodes.iter().enumerate().map(|(i, _)| i).collect();
+        let optimizer = ConstantBackpropagationOptimizer::new(circuit);
+
+        let (optimized_circuit, _) =
+            optimizer.backpropagate_constants_iteration(acir_opcode_positions);
+
+        assert_eq!(
+            optimized_circuit.opcodes.len(),
+            2,
+            "The brillig opcode should not be removed as the output is needed as a witness"
+        );
+    }
+}
diff --git a/acvm-repo/acvm/src/compiler/optimizers/general.rs b/acvm-repo/acvm/src/compiler/optimizers/general.rs
index 2bd781f7bb5..a48a590a05e 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/general.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/general.rs
@@ -13,7 +13,8 @@ impl GeneralOptimizer {
     pub(crate) fn optimize(opcode: Expression) -> Expression {
         // XXX: Perhaps this optimization can be done on the fly
         let opcode = remove_zero_coefficients(opcode);
-        simplify_mul_terms(opcode)
+        let opcode = simplify_mul_terms(opcode);
+        simplify_linear_terms(opcode)
     }
 }
 
@@ -42,3 +43,20 @@ fn simplify_mul_terms(mut gate: Expression) -> Expression {
     gate.mul_terms = hash_map.into_iter().map(|((w_l, w_r), scale)| (scale, w_l, w_r)).collect();
     gate
 }
+
+// Simplifies all linear terms with the same variables
+fn simplify_linear_terms(mut gate: Expression) -> Expression {
+    let mut hash_map: IndexMap<Witness, FieldElement> = IndexMap::new();
+
+    // Canonicalize the ordering of the terms, lets just order by variable name
+    for (scale, witness) in gate.linear_combinations.into_iter() {
+        *hash_map.entry(witness).or_insert_with(FieldElement::zero) += scale;
+    }
+
+    gate.linear_combinations = hash_map
+        .into_iter()
+        .filter(|(_, scale)| scale != &FieldElement::zero())
+        .map(|(witness, scale)| (scale, witness))
+        .collect();
+    gate
+}
diff --git a/acvm-repo/acvm/src/compiler/optimizers/mod.rs b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
index 923756580b3..599bdabd420 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
@@ -1,5 +1,6 @@
 use acir::circuit::{Circuit, Opcode};
 
+mod constant_backpropagation;
 mod general;
 mod redundant_range;
 mod unused_memory;
@@ -8,6 +9,7 @@ pub(crate) use general::GeneralOptimizer;
 pub(crate) use redundant_range::RangeOptimizer;
 use tracing::info;
 
+use self::constant_backpropagation::ConstantBackpropagationOptimizer;
 use self::unused_memory::UnusedMemoryOptimizer;
 
 use super::{transform_assert_messages, AcirTransformationMap};
@@ -26,6 +28,15 @@ pub fn optimize(acir: Circuit) -> (Circuit, AcirTransformationMap) {
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] independent optimizations to a [`Circuit`].
 #[tracing::instrument(level = "trace", name = "optimize_acir" skip(acir))]
 pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
+    // Track original acir opcode positions throughout the transformation passes of the compilation
+    // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
+    let acir_opcode_positions = (0..acir.opcodes.len()).collect();
+
+    if acir.opcodes.len() == 1 && matches!(acir.opcodes[0], Opcode::Brillig(_)) {
+        info!("Program is fully unconstrained, skipping optimization pass");
+        return (acir, acir_opcode_positions);
+    }
+
     info!("Number of opcodes before: {}", acir.opcodes.len());
 
     // General optimizer pass
@@ -42,20 +53,22 @@ pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
         .collect();
     let acir = Circuit { opcodes, ..acir };
 
-    // Track original acir opcode positions throughout the transformation passes of the compilation
-    // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
-    let acir_opcode_positions = (0..acir.opcodes.len()).collect();
-
     // Unused memory optimization pass
     let memory_optimizer = UnusedMemoryOptimizer::new(acir);
     let (acir, acir_opcode_positions) =
         memory_optimizer.remove_unused_memory_initializations(acir_opcode_positions);
 
+    let (acir, acir_opcode_positions) =
+        ConstantBackpropagationOptimizer::backpropagate_constants(acir, acir_opcode_positions);
+
     // Range optimization pass
     let range_optimizer = RangeOptimizer::new(acir);
     let (acir, acir_opcode_positions) =
         range_optimizer.replace_redundant_ranges(acir_opcode_positions);
 
+    let (acir, acir_opcode_positions) =
+        ConstantBackpropagationOptimizer::backpropagate_constants(acir, acir_opcode_positions);
+
     info!("Number of opcodes after: {}", acir.opcodes.len());
 
     (acir, acir_opcode_positions)
diff --git a/acvm-repo/acvm/src/pwg/arithmetic.rs b/acvm-repo/acvm/src/pwg/arithmetic.rs
index 81462ea495e..dc9e13d44b6 100644
--- a/acvm-repo/acvm/src/pwg/arithmetic.rs
+++ b/acvm-repo/acvm/src/pwg/arithmetic.rs
@@ -7,7 +7,7 @@ use super::{insert_value, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionErro
 
 /// An Expression solver will take a Circuit's assert-zero opcodes with witness assignments
 /// and create the other witness variables
-pub(super) struct ExpressionSolver;
+pub(crate) struct ExpressionSolver;
 
 #[allow(clippy::enum_variant_names)]
 pub(super) enum OpcodeStatus {
@@ -24,13 +24,18 @@ pub(crate) enum MulTerm {
 
 impl ExpressionSolver {
     /// Derives the rest of the witness based on the initial low level variables
-    pub(super) fn solve(
+    pub(crate) fn solve(
         initial_witness: &mut WitnessMap,
         opcode: &Expression,
     ) -> Result<(), OpcodeResolutionError> {
         let opcode = &ExpressionSolver::evaluate(opcode, initial_witness);
         // Evaluate multiplication term
-        let mul_result = ExpressionSolver::solve_mul_term(opcode, initial_witness);
+        let mul_result =
+            ExpressionSolver::solve_mul_term(opcode, initial_witness).map_err(|_| {
+                OpcodeResolutionError::OpcodeNotSolvable(
+                    OpcodeNotSolvable::ExpressionHasTooManyUnknowns(opcode.clone()),
+                )
+            })?;
         // Evaluate the fan-in terms
         let opcode_status = ExpressionSolver::solve_fan_in_term(opcode, initial_witness);
 
@@ -54,9 +59,7 @@ impl ExpressionSolver {
                         }
                     } else {
                         let assignment = -total_sum / (q + b);
-                        // Add this into the witness assignments
-                        insert_value(&w1, assignment, initial_witness)?;
-                        Ok(())
+                        insert_value(&w1, assignment, initial_witness)
                     }
                 } else {
                     // TODO: can we be more specific with this error?
@@ -84,9 +87,7 @@ impl ExpressionSolver {
                     }
                 } else {
                     let assignment = -(total_sum / partial_prod);
-                    // Add this into the witness assignments
-                    insert_value(&unknown_var, assignment, initial_witness)?;
-                    Ok(())
+                    insert_value(&unknown_var, assignment, initial_witness)
                 }
             }
             (MulTerm::Solved(a), OpcodeStatus::OpcodeSatisfied(b)) => {
@@ -118,9 +119,7 @@ impl ExpressionSolver {
                     }
                 } else {
                     let assignment = -(total_sum / coeff);
-                    // Add this into the witness assignments
-                    insert_value(&unknown_var, assignment, initial_witness)?;
-                    Ok(())
+                    insert_value(&unknown_var, assignment, initial_witness)
                 }
             }
         }
@@ -130,16 +129,19 @@ impl ExpressionSolver {
     /// If the witness values are not known, then the function returns a None
     /// XXX: Do we need to account for the case where 5xy + 6x = 0 ? We do not know y, but it can be solved given x . But I believe x can be solved with another opcode
     /// XXX: What about making a mul opcode = a constant 5xy + 7 = 0 ? This is the same as the above.
-    fn solve_mul_term(arith_opcode: &Expression, witness_assignments: &WitnessMap) -> MulTerm {
+    fn solve_mul_term(
+        arith_opcode: &Expression,
+        witness_assignments: &WitnessMap,
+    ) -> Result<MulTerm, OpcodeStatus> {
         // First note that the mul term can only contain one/zero term
         // We are assuming it has been optimized.
         match arith_opcode.mul_terms.len() {
-            0 => MulTerm::Solved(FieldElement::zero()),
-            1 => ExpressionSolver::solve_mul_term_helper(
+            0 => Ok(MulTerm::Solved(FieldElement::zero())),
+            1 => Ok(ExpressionSolver::solve_mul_term_helper(
                 &arith_opcode.mul_terms[0],
                 witness_assignments,
-            ),
-            _ => panic!("Mul term in the assert-zero opcode must contain either zero or one term"),
+            )),
+            _ => Err(OpcodeStatus::OpcodeUnsolvable),
         }
     }
 
@@ -209,7 +211,7 @@ impl ExpressionSolver {
     }
 
     // Partially evaluate the opcode using the known witnesses
-    pub(super) fn evaluate(expr: &Expression, initial_witness: &WitnessMap) -> Expression {
+    pub(crate) fn evaluate(expr: &Expression, initial_witness: &WitnessMap) -> Expression {
         let mut result = Expression::default();
         for &(c, w1, w2) in &expr.mul_terms {
             let mul_result = ExpressionSolver::solve_mul_term_helper(&(c, w1, w2), initial_witness);
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 4309cad1b2e..6ee926043cd 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -25,7 +25,7 @@ use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
 use hash::{solve_generic_256_hash_opcode, solve_sha_256_permutation_opcode};
 use logic::{and, xor};
 use pedersen::pedersen;
-use range::solve_range_opcode;
+pub(crate) use range::solve_range_opcode;
 use signature::{
     ecdsa::{secp256k1_prehashed, secp256r1_prehashed},
     schnorr::schnorr_verify,
diff --git a/acvm-repo/acvm/src/pwg/blackbox/range.rs b/acvm-repo/acvm/src/pwg/blackbox/range.rs
index 1b976e30ed5..2afe820b636 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/range.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/range.rs
@@ -4,7 +4,7 @@ use crate::{
 };
 use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
 
-pub(super) fn solve_range_opcode(
+pub(crate) fn solve_range_opcode(
     initial_witness: &WitnessMap,
     input: &FunctionInput,
 ) -> Result<(), OpcodeResolutionError> {
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index b0fb7469fd9..51c7f4c6203 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -65,7 +65,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
 
     /// Constructs a solver for a Brillig block given the bytecode and initial
     /// witness.
-    pub(super) fn new(
+    pub(crate) fn new(
         initial_witness: &WitnessMap,
         memory: &HashMap<BlockId, MemoryOpSolver>,
         brillig: &'b Brillig,
@@ -134,7 +134,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         self.vm.get_call_stack()
     }
 
-    pub(super) fn solve(&mut self) -> Result<BrilligSolverStatus, OpcodeResolutionError> {
+    pub(crate) fn solve(&mut self) -> Result<BrilligSolverStatus, OpcodeResolutionError> {
         let status = self.vm.process_opcodes();
         self.handle_vm_status(status)
     }
@@ -177,7 +177,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         }
     }
 
-    pub(super) fn finalize(
+    pub(crate) fn finalize(
         self,
         witness: &mut WitnessMap,
         brillig: &Brillig,
diff --git a/acvm-repo/acvm/src/pwg/directives/mod.rs b/acvm-repo/acvm/src/pwg/directives/mod.rs
index 07226c85b27..ee544521fc7 100644
--- a/acvm-repo/acvm/src/pwg/directives/mod.rs
+++ b/acvm-repo/acvm/src/pwg/directives/mod.rs
@@ -11,7 +11,7 @@ use super::{get_value, insert_value, ErrorLocation};
 /// Returns `Ok(OpcodeResolution)` to signal whether the directive was successful solved.
 ///
 /// Returns `Err(OpcodeResolutionError)` if a circuit constraint is unsatisfied.
-pub(super) fn solve_directives(
+pub(crate) fn solve_directives(
     initial_witness: &mut WitnessMap,
     directive: &Directive,
 ) -> Result<(), OpcodeResolutionError> {
diff --git a/acvm-repo/acvm/src/pwg/memory_op.rs b/acvm-repo/acvm/src/pwg/memory_op.rs
index 49ec652289e..e51797707a7 100644
--- a/acvm-repo/acvm/src/pwg/memory_op.rs
+++ b/acvm-repo/acvm/src/pwg/memory_op.rs
@@ -13,7 +13,7 @@ type MemoryIndex = u32;
 
 /// Maintains the state for solving [`MemoryInit`][`acir::circuit::Opcode::MemoryInit`] and [`MemoryOp`][`acir::circuit::Opcode::MemoryOp`] opcodes.
 #[derive(Default)]
-pub(super) struct MemoryOpSolver {
+pub(crate) struct MemoryOpSolver {
     pub(super) block_value: HashMap<MemoryIndex, FieldElement>,
     pub(super) block_len: u32,
 }
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index 2ee39a289e7..d8323e5ef5f 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -21,11 +21,11 @@ use thiserror::Error;
 // arithmetic
 pub(crate) mod arithmetic;
 // Brillig bytecode
-mod brillig;
+pub(crate) mod brillig;
 // Directives
-mod directives;
+pub(crate) mod directives;
 // black box functions
-mod blackbox;
+pub(crate) mod blackbox;
 mod memory_op;
 
 pub use self::brillig::{BrilligSolver, BrilligSolverStatus};
diff --git a/cspell.json b/cspell.json
index 23659b39c68..a96e3de901a 100644
--- a/cspell.json
+++ b/cspell.json
@@ -13,6 +13,8 @@
         "arithmetization",
         "arity",
         "arkworks",
+        "backpropagate",
+        "Backpropagation",
         "barebones",
         "barretenberg",
         "bincode",

From 8a6b131402892a570bc2de6f5869de73b0bd979e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Mon, 4 Mar 2024 10:49:31 +0000
Subject: [PATCH 033/416] feat: add option to set max memory for bb.js (#4227)

# Description

Makes `BackendBarretenberg` pass all the options to the `bb.js`
instance.

## Summary\*

Makes `BackendBarretenberg` pass all the options to the `bb.js`
instance, namely min and max memory. Manually setting max memory makes
iOS not immediately kill workers on the browser.

This is already implemented in BB as per [this
PR](https://github.com/AztecProtocol/aztec-packages/pull/3265)

Replicates the change I made in a pinch for `progrcrypto` Istanbul.
[Example usage
here](https://github.com/signorecello/progcrypto23-act/blob/f95f267f2460a423f99865ca30e29f89e8104bc5/packages/user/pages/index.tsx#L31)
---
 compiler/integration-tests/package.json       |  1 +
 compiler/integration-tests/test/mocks/os.js   |  1 +
 .../web-test-runner.config.mjs                | 15 +++++++++++--
 .../noir_js_backend_barretenberg/src/index.ts | 12 +++++++++-
 .../noir_js_backend_barretenberg/src/types.ts |  1 +
 yarn.lock                                     | 22 +++++++++++++++++++
 6 files changed, 49 insertions(+), 3 deletions(-)
 create mode 100644 compiler/integration-tests/test/mocks/os.js

diff --git a/compiler/integration-tests/package.json b/compiler/integration-tests/package.json
index 2e75ebc201e..798b7c55312 100644
--- a/compiler/integration-tests/package.json
+++ b/compiler/integration-tests/package.json
@@ -19,6 +19,7 @@
         "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
         "@nomicfoundation/hardhat-ethers": "^3.0.0",
         "@web/dev-server-esbuild": "^0.3.6",
+        "@web/dev-server-import-maps": "^0.2.0",
         "@web/test-runner": "^0.15.3",
         "@web/test-runner-playwright": "^0.10.0",
         "eslint": "^8.56.0",
diff --git a/compiler/integration-tests/test/mocks/os.js b/compiler/integration-tests/test/mocks/os.js
new file mode 100644
index 00000000000..32333568316
--- /dev/null
+++ b/compiler/integration-tests/test/mocks/os.js
@@ -0,0 +1 @@
+export const os = { cpus: () => new Array(4) };
diff --git a/compiler/integration-tests/web-test-runner.config.mjs b/compiler/integration-tests/web-test-runner.config.mjs
index 665ea262f99..4dfc96dd0a6 100644
--- a/compiler/integration-tests/web-test-runner.config.mjs
+++ b/compiler/integration-tests/web-test-runner.config.mjs
@@ -2,7 +2,8 @@ import { defaultReporter } from '@web/test-runner';
 import { summaryReporter } from '@web/test-runner';
 import { fileURLToPath } from 'url';
 import { esbuildPlugin } from '@web/dev-server-esbuild';
-import { playwrightLauncher } from "@web/test-runner-playwright";
+import { playwrightLauncher } from '@web/test-runner-playwright';
+import { importMapsPlugin } from '@web/dev-server-import-maps';
 
 let reporter = summaryReporter();
 const debugPlugins = [];
@@ -21,7 +22,7 @@ if (process.env.CI !== 'true' || process.env.RUNNER_DEBUG === '1') {
 
 export default {
   browsers: [
-    playwrightLauncher({ product: "chromium" }),
+    playwrightLauncher({ product: 'chromium' }),
     // playwrightLauncher({ product: "webkit" }),
     // playwrightLauncher({ product: "firefox" }),
   ],
@@ -29,6 +30,16 @@ export default {
     esbuildPlugin({
       ts: true,
     }),
+    importMapsPlugin({
+      inject: {
+        importMap: {
+          imports: {
+            // mock os module
+            os: '/test/mocks/os.js',
+          },
+        },
+      },
+    }),
     ...debugPlugins,
   ],
   files: ['test/browser/**/*.test.ts'],
diff --git a/tooling/noir_js_backend_barretenberg/src/index.ts b/tooling/noir_js_backend_barretenberg/src/index.ts
index d79b487c3cf..af03743eb2f 100644
--- a/tooling/noir_js_backend_barretenberg/src/index.ts
+++ b/tooling/noir_js_backend_barretenberg/src/index.ts
@@ -33,8 +33,18 @@ export class BarretenbergBackend implements Backend {
   /** @ignore */
   async instantiate(): Promise<void> {
     if (!this.api) {
+      if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+        this.options.threads = navigator.hardwareConcurrency;
+      } else {
+        try {
+          const os = await import('os');
+          this.options.threads = os.cpus().length;
+        } catch (e) {
+          console.log('Could not detect environment. Falling back to one thread.', e);
+        }
+      }
       const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
-      const api = await Barretenberg.new({ threads: this.options.threads });
+      const api = await Barretenberg.new(this.options);
 
       const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode);
       const crs = await Crs.new(subgroupSize + 1);
diff --git a/tooling/noir_js_backend_barretenberg/src/types.ts b/tooling/noir_js_backend_barretenberg/src/types.ts
index 041e36fdf91..fac23030aad 100644
--- a/tooling/noir_js_backend_barretenberg/src/types.ts
+++ b/tooling/noir_js_backend_barretenberg/src/types.ts
@@ -5,4 +5,5 @@
 export type BackendOptions = {
   /** @description Number of threads */
   threads: number;
+  memory?: { maximum: number };
 };
diff --git a/yarn.lock b/yarn.lock
index ace7959279f..f5f3a29f08a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3951,6 +3951,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@import-maps/resolve@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@import-maps/resolve@npm:1.0.1"
+  checksum: 17ee033e26a0fd82294de87eae76d32b553a130fdbf0fb8c70d39f2087a3e8a4a5908970a99aa32bd175153efe9b7dfee6b7f99df36f41abed08c1911dbdb19c
+  languageName: node
+  linkType: hard
+
 "@isaacs/cliui@npm:^8.0.2":
   version: 8.0.2
   resolution: "@isaacs/cliui@npm:8.0.2"
@@ -6677,6 +6684,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@web/dev-server-import-maps@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "@web/dev-server-import-maps@npm:0.2.0"
+  dependencies:
+    "@import-maps/resolve": ^1.0.1
+    "@types/parse5": ^6.0.1
+    "@web/dev-server-core": ^0.7.0
+    "@web/parse5-utils": ^2.1.0
+    parse5: ^6.0.1
+    picomatch: ^2.2.2
+  checksum: 15dabfa385f023bab70758b80cc09443455830799793c1a404a7230d90ebf60e40984a10d8a6ceea2afb8f057e90a9f7356a76f867d5e5a2eeacbc397e41535a
+  languageName: node
+  linkType: hard
+
 "@web/dev-server-rollup@npm:^0.4.1":
   version: 0.4.1
   resolution: "@web/dev-server-rollup@npm:0.4.1"
@@ -13416,6 +13437,7 @@ __metadata:
     "@nomicfoundation/hardhat-chai-matchers": ^2.0.0
     "@nomicfoundation/hardhat-ethers": ^3.0.0
     "@web/dev-server-esbuild": ^0.3.6
+    "@web/dev-server-import-maps": ^0.2.0
     "@web/test-runner": ^0.15.3
     "@web/test-runner-playwright": ^0.10.0
     eslint: ^8.56.0

From 17f343b3c3bf5792a8358aaeef969ee95d45ed1a Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 4 Mar 2024 13:56:20 +0000
Subject: [PATCH 034/416] chore: export `report_errors` from `nargo` (#4461)

# Description

## Problem\*

Related to #3503

## Summary\*

This PR removes the extra copy of the `report_errors` function.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/lsp/src/requests/profile_run.rs       | 14 +++-
 tooling/nargo/src/ops/compile.rs              | 66 +++++++++------
 tooling/nargo/src/ops/mod.rs                  |  3 +-
 tooling/nargo_cli/src/cli/check_cmd.rs        | 11 +--
 .../nargo_cli/src/cli/codegen_verifier_cmd.rs |  3 +-
 tooling/nargo_cli/src/cli/compile_cmd.rs      | 82 ++++++-------------
 tooling/nargo_cli/src/cli/debug_cmd.rs        |  3 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |  3 +-
 tooling/nargo_cli/src/cli/export_cmd.rs       |  2 +-
 tooling/nargo_cli/src/cli/fmt_cmd.rs          |  4 +-
 tooling/nargo_cli/src/cli/info_cmd.rs         | 11 ++-
 tooling/nargo_cli/src/cli/prove_cmd.rs        |  3 +-
 tooling/nargo_cli/src/cli/verify_cmd.rs       |  3 +-
 13 files changed, 98 insertions(+), 110 deletions(-)

diff --git a/tooling/lsp/src/requests/profile_run.rs b/tooling/lsp/src/requests/profile_run.rs
index 917c247410d..89719947689 100644
--- a/tooling/lsp/src/requests/profile_run.rs
+++ b/tooling/lsp/src/requests/profile_run.rs
@@ -5,7 +5,10 @@ use std::{
 
 use acvm::acir::circuit::ExpressionWidth;
 use async_lsp::{ErrorCode, ResponseError};
-use nargo::{artifacts::debug::DebugArtifact, insert_all_files_for_workspace_into_file_manager};
+use nargo::{
+    artifacts::debug::DebugArtifact, insert_all_files_for_workspace_into_file_manager,
+    ops::report_errors,
+};
 use nargo_toml::{find_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{
     file_manager_with_stdlib, CompileOptions, DebugFile, NOIR_ARTIFACT_VERSION_STRING,
@@ -60,11 +63,18 @@ fn on_profile_run_request_inner(
         Some(_package) => {
             let expression_width = ExpressionWidth::Bounded { width: 3 };
 
-            let (compiled_programs, compiled_contracts) = nargo::ops::compile_workspace(
+            let compiled_workspace = nargo::ops::compile_workspace(
                 &workspace_file_manager,
                 &parsed_files,
                 &workspace,
                 &CompileOptions::default(),
+            );
+
+            let (compiled_programs, compiled_contracts) = report_errors(
+                compiled_workspace,
+                &workspace_file_manager,
+                CompileOptions::default().deny_warnings,
+                CompileOptions::default().silence_warnings,
             )
             .map_err(|err| ResponseError::new(ErrorCode::REQUEST_FAILED, err))?;
 
diff --git a/tooling/nargo/src/ops/compile.rs b/tooling/nargo/src/ops/compile.rs
index bd1850649c4..d7c7cc2c123 100644
--- a/tooling/nargo/src/ops/compile.rs
+++ b/tooling/nargo/src/ops/compile.rs
@@ -21,7 +21,7 @@ pub fn compile_workspace(
     parsed_files: &ParsedFiles,
     workspace: &Workspace,
     compile_options: &CompileOptions,
-) -> Result<(Vec<CompiledProgram>, Vec<CompiledContract>), CompileError> {
+) -> CompilationResult<(Vec<CompiledProgram>, Vec<CompiledContract>)> {
     let (binary_packages, contract_packages): (Vec<_>, Vec<_>) = workspace
         .into_iter()
         .filter(|package| !package.is_library())
@@ -38,31 +38,20 @@ pub fn compile_workspace(
         .map(|package| compile_contract(file_manager, parsed_files, package, compile_options))
         .collect();
 
-    // Report any warnings/errors which were encountered during compilation.
-    let compiled_programs: Vec<CompiledProgram> = program_results
-        .into_iter()
-        .map(|compilation_result| {
-            report_errors(
-                compilation_result,
-                file_manager,
-                compile_options.deny_warnings,
-                compile_options.silence_warnings,
-            )
-        })
-        .collect::<Result<_, _>>()?;
-    let compiled_contracts: Vec<CompiledContract> = contract_results
-        .into_iter()
-        .map(|compilation_result| {
-            report_errors(
-                compilation_result,
-                file_manager,
-                compile_options.deny_warnings,
-                compile_options.silence_warnings,
-            )
-        })
-        .collect::<Result<_, _>>()?;
-
-    Ok((compiled_programs, compiled_contracts))
+    // Collate any warnings/errors which were encountered during compilation.
+    let compiled_programs = collect_errors(program_results);
+    let compiled_contracts = collect_errors(contract_results);
+
+    match (compiled_programs, compiled_contracts) {
+        (Ok((programs, program_warnings)), Ok((contracts, contract_warnings))) => {
+            let warnings = [program_warnings, contract_warnings].concat();
+            Ok(((programs, contracts), warnings))
+        }
+        (Err(program_errors), Err(contract_errors)) => {
+            Err([program_errors, contract_errors].concat())
+        }
+        (Err(errors), _) | (_, Err(errors)) => Err(errors),
+    }
 }
 
 pub fn compile_program(
@@ -107,7 +96,30 @@ pub fn compile_contract(
     noirc_driver::compile_contract(&mut context, crate_id, compile_options)
 }
 
-pub(crate) fn report_errors<T>(
+/// Constructs a single `CompilationResult` for a collection of `CompilationResult`s, merging the set of warnings/errors.
+pub fn collect_errors<T>(results: Vec<CompilationResult<T>>) -> CompilationResult<Vec<T>> {
+    let mut artifacts = Vec::new();
+    let mut warnings = Vec::new();
+    let mut errors = Vec::new();
+
+    for result in results {
+        match result {
+            Ok((new_artifact, new_warnings)) => {
+                artifacts.push(new_artifact);
+                warnings.extend(new_warnings);
+            }
+            Err(new_errors) => errors.extend(new_errors),
+        }
+    }
+
+    if errors.is_empty() {
+        Ok((artifacts, warnings))
+    } else {
+        Err(errors)
+    }
+}
+
+pub fn report_errors<T>(
     result: CompilationResult<T>,
     file_manager: &FileManager,
     deny_warnings: bool,
diff --git a/tooling/nargo/src/ops/mod.rs b/tooling/nargo/src/ops/mod.rs
index 23dd0db15b9..55e9e927800 100644
--- a/tooling/nargo/src/ops/mod.rs
+++ b/tooling/nargo/src/ops/mod.rs
@@ -1,5 +1,6 @@
 pub use self::compile::{
-    compile_contract, compile_program, compile_program_with_debug_instrumenter, compile_workspace,
+    collect_errors, compile_contract, compile_program, compile_program_with_debug_instrumenter,
+    compile_workspace, report_errors,
 };
 pub use self::execute::execute_circuit;
 pub use self::foreign_calls::{
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 4da06d2536a..242a640e484 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -5,8 +5,8 @@ use clap::Args;
 use fm::FileManager;
 use iter_extended::btree_map;
 use nargo::{
-    errors::CompileError, insert_all_files_for_workspace_into_file_manager, package::Package,
-    parse_all, prepare_package,
+    errors::CompileError, insert_all_files_for_workspace_into_file_manager, ops::report_errors,
+    package::Package, parse_all, prepare_package,
 };
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_abi::{AbiParameter, AbiType, MAIN_RETURN_NAME};
@@ -152,12 +152,7 @@ pub(crate) fn check_crate_and_report_errors(
     silence_warnings: bool,
 ) -> Result<(), CompileError> {
     let result = check_crate(context, crate_id, deny_warnings, disable_macros);
-    super::compile_cmd::report_errors(
-        result,
-        &context.file_manager,
-        deny_warnings,
-        silence_warnings,
-    )
+    report_errors(result, &context.file_manager, deny_warnings, silence_warnings)
 }
 
 #[cfg(test)]
diff --git a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
index 63d27e30836..f0fe2e0ea78 100644
--- a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
+++ b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
@@ -1,11 +1,10 @@
 use super::fs::{create_named_dir, write_to_file};
 use super::NargoConfig;
 use crate::backends::Backend;
-use crate::cli::compile_cmd::report_errors;
 use crate::errors::CliError;
 
 use clap::Args;
-use nargo::ops::compile_program;
+use nargo::ops::{compile_program, report_errors};
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{file_manager_with_stdlib, CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 34fb05249b5..4309f0db3ea 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -2,8 +2,7 @@ use std::path::Path;
 
 use fm::FileManager;
 use nargo::artifacts::program::ProgramArtifact;
-use nargo::errors::CompileError;
-use nargo::ops::{compile_contract, compile_program};
+use nargo::ops::{collect_errors, compile_contract, compile_program, report_errors};
 use nargo::package::Package;
 use nargo::workspace::Workspace;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
@@ -65,11 +64,18 @@ pub(crate) fn run(
         .compile_options
         .expression_width
         .unwrap_or_else(|| backend.get_backend_info_or_default());
-    let (compiled_program, compiled_contracts) = compile_workspace(
+    let compiled_workspace = compile_workspace(
         &workspace_file_manager,
         &parsed_files,
         &workspace,
         &args.compile_options,
+    );
+
+    let (compiled_programs, compiled_contracts) = report_errors(
+        compiled_workspace,
+        &workspace_file_manager,
+        args.compile_options.deny_warnings,
+        args.compile_options.silence_warnings,
     )?;
 
     let (binary_packages, contract_packages): (Vec<_>, Vec<_>) = workspace
@@ -80,7 +86,7 @@ pub(crate) fn run(
 
     // Save build artifacts to disk.
     let only_acir = args.compile_options.only_acir;
-    for (package, program) in binary_packages.into_iter().zip(compiled_program) {
+    for (package, program) in binary_packages.into_iter().zip(compiled_programs) {
         let program = nargo::ops::transform_program(program, expression_width);
         save_program(program.clone(), &package, &workspace.target_directory_path(), only_acir);
     }
@@ -97,7 +103,7 @@ pub(super) fn compile_workspace(
     parsed_files: &ParsedFiles,
     workspace: &Workspace,
     compile_options: &CompileOptions,
-) -> Result<(Vec<CompiledProgram>, Vec<CompiledContract>), CliError> {
+) -> CompilationResult<(Vec<CompiledProgram>, Vec<CompiledContract>)> {
     let (binary_packages, contract_packages): (Vec<_>, Vec<_>) = workspace
         .into_iter()
         .filter(|package| !package.is_library())
@@ -123,31 +129,20 @@ pub(super) fn compile_workspace(
         .map(|package| compile_contract(file_manager, parsed_files, package, compile_options))
         .collect();
 
-    // Report any warnings/errors which were encountered during compilation.
-    let compiled_programs: Vec<CompiledProgram> = program_results
-        .into_iter()
-        .map(|compilation_result| {
-            report_errors(
-                compilation_result,
-                file_manager,
-                compile_options.deny_warnings,
-                compile_options.silence_warnings,
-            )
-        })
-        .collect::<Result<_, _>>()?;
-    let compiled_contracts: Vec<CompiledContract> = contract_results
-        .into_iter()
-        .map(|compilation_result| {
-            report_errors(
-                compilation_result,
-                file_manager,
-                compile_options.deny_warnings,
-                compile_options.silence_warnings,
-            )
-        })
-        .collect::<Result<_, _>>()?;
-
-    Ok((compiled_programs, compiled_contracts))
+    // Collate any warnings/errors which were encountered during compilation.
+    let compiled_programs = collect_errors(program_results);
+    let compiled_contracts = collect_errors(contract_results);
+
+    match (compiled_programs, compiled_contracts) {
+        (Ok((programs, program_warnings)), Ok((contracts, contract_warnings))) => {
+            let warnings = [program_warnings, contract_warnings].concat();
+            Ok(((programs, contracts), warnings))
+        }
+        (Err(program_errors), Err(contract_errors)) => {
+            Err([program_errors, contract_errors].concat())
+        }
+        (Err(errors), _) | (_, Err(errors)) => Err(errors),
+    }
 }
 
 pub(super) fn save_program(
@@ -172,30 +167,3 @@ fn save_contract(contract: CompiledContract, package: &Package, circuit_dir: &Pa
         circuit_dir,
     );
 }
-
-/// Helper function for reporting any errors in a `CompilationResult<T>`
-/// structure that is commonly used as a return result in this file.
-pub(crate) fn report_errors<T>(
-    result: CompilationResult<T>,
-    file_manager: &FileManager,
-    deny_warnings: bool,
-    silence_warnings: bool,
-) -> Result<T, CompileError> {
-    let (t, warnings) = result.map_err(|errors| {
-        noirc_errors::reporter::report_all(
-            file_manager.as_file_map(),
-            &errors,
-            deny_warnings,
-            silence_warnings,
-        )
-    })?;
-
-    noirc_errors::reporter::report_all(
-        file_manager.as_file_map(),
-        &warnings,
-        deny_warnings,
-        silence_warnings,
-    );
-
-    Ok(t)
-}
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 130a07b5c90..2c4937b6f16 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -8,7 +8,7 @@ use fm::FileManager;
 use nargo::artifacts::debug::DebugArtifact;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::errors::CompileError;
-use nargo::ops::{compile_program, compile_program_with_debug_instrumenter};
+use nargo::ops::{compile_program, compile_program_with_debug_instrumenter, report_errors};
 use nargo::package::Package;
 use nargo::workspace::Workspace;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
@@ -22,7 +22,6 @@ use noirc_frontend::debug::DebugInstrumenter;
 use noirc_frontend::graph::CrateName;
 use noirc_frontend::hir::ParsedFiles;
 
-use super::compile_cmd::report_errors;
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
 use crate::backends::Backend;
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index a3fcebab94f..85c0a4160a7 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -5,7 +5,7 @@ use clap::Args;
 use nargo::artifacts::debug::DebugArtifact;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::errors::try_to_diagnose_runtime_error;
-use nargo::ops::{compile_program, DefaultForeignCallExecutor};
+use nargo::ops::{compile_program, report_errors, DefaultForeignCallExecutor};
 use nargo::package::Package;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
@@ -19,7 +19,6 @@ use noirc_frontend::graph::CrateName;
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
 use crate::backends::Backend;
-use crate::cli::compile_cmd::report_errors;
 use crate::errors::CliError;
 
 /// Executes a circuit to calculate its return value
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index 96b24796a2b..044c2cb4ebb 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -1,4 +1,5 @@
 use nargo::errors::CompileError;
+use nargo::ops::report_errors;
 use noirc_errors::FileDiagnostic;
 use noirc_frontend::hir::ParsedFiles;
 use rayon::prelude::*;
@@ -24,7 +25,6 @@ use crate::errors::CliError;
 
 use super::check_cmd::check_crate_and_report_errors;
 
-use super::compile_cmd::report_errors;
 use super::fs::program::save_program_to_file;
 use super::NargoConfig;
 
diff --git a/tooling/nargo_cli/src/cli/fmt_cmd.rs b/tooling/nargo_cli/src/cli/fmt_cmd.rs
index 0bd25a3a0ce..2e0ca5632f1 100644
--- a/tooling/nargo_cli/src/cli/fmt_cmd.rs
+++ b/tooling/nargo_cli/src/cli/fmt_cmd.rs
@@ -1,7 +1,7 @@
 use std::{fs::DirEntry, path::Path};
 
 use clap::Args;
-use nargo::insert_all_files_for_workspace_into_file_manager;
+use nargo::{insert_all_files_for_workspace_into_file_manager, ops::report_errors};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{file_manager_with_stdlib, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_errors::CustomDiagnostic;
@@ -53,7 +53,7 @@ pub(crate) fn run(args: FormatCommand, config: NargoConfig) -> Result<(), CliErr
                     })
                     .collect();
 
-                let _ = super::compile_cmd::report_errors::<()>(
+                let _ = report_errors::<()>(
                     Err(errors),
                     &workspace_file_manager,
                     false,
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index ef0df0bf25b..300e1a35be2 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -6,7 +6,7 @@ use clap::Args;
 use iter_extended::vecmap;
 use nargo::{
     artifacts::debug::DebugArtifact, insert_all_files_for_workspace_into_file_manager,
-    package::Package, parse_all,
+    ops::report_errors, package::Package, parse_all,
 };
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{
@@ -73,11 +73,18 @@ pub(crate) fn run(
         .compile_options
         .expression_width
         .unwrap_or_else(|| backend.get_backend_info_or_default());
-    let (compiled_programs, compiled_contracts) = compile_workspace(
+    let compiled_workspace = compile_workspace(
         &workspace_file_manager,
         &parsed_files,
         &workspace,
         &args.compile_options,
+    );
+
+    let (compiled_programs, compiled_contracts) = report_errors(
+        compiled_workspace,
+        &workspace_file_manager,
+        args.compile_options.deny_warnings,
+        args.compile_options.silence_warnings,
     )?;
 
     let compiled_programs = vecmap(compiled_programs, |program| {
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index cc39b0535bc..f0a9b3185b9 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -1,6 +1,6 @@
 use clap::Args;
 use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
-use nargo::ops::compile_program;
+use nargo::ops::{compile_program, report_errors};
 use nargo::package::Package;
 use nargo::workspace::Workspace;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
@@ -11,7 +11,6 @@ use noirc_driver::{
 };
 use noirc_frontend::graph::CrateName;
 
-use super::compile_cmd::report_errors;
 use super::fs::{
     inputs::{read_inputs_from_file, write_inputs_to_file},
     proof::save_proof_to_dir,
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
index 66b88a22f2a..1063b50ab6c 100644
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ b/tooling/nargo_cli/src/cli/verify_cmd.rs
@@ -1,11 +1,10 @@
-use super::compile_cmd::report_errors;
 use super::fs::{inputs::read_inputs_from_file, load_hex_data};
 use super::NargoConfig;
 use crate::{backends::Backend, errors::CliError};
 
 use clap::Args;
 use nargo::constants::{PROOF_EXT, VERIFIER_INPUT_FILE};
-use nargo::ops::compile_program;
+use nargo::ops::{compile_program, report_errors};
 use nargo::package::Package;
 use nargo::workspace::Workspace;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};

From 2ce89587980cf064baecab50ccf4db14b43bf5cd Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 4 Mar 2024 13:08:51 -0600
Subject: [PATCH 035/416] chore: Capitalize containers section in docs (#4471)

# Description

## Problem\*

## Summary\*

The "containers" section of noir's docs was the only section not
capitalized previously

## Additional Context

I checked "Documentation included in this PR." so that docs can be
regenerated for this PR and we can see the section is capitalized.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/noir/standard_library/containers/index.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 docs/docs/noir/standard_library/containers/index.md

diff --git a/docs/docs/noir/standard_library/containers/index.md b/docs/docs/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/docs/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---

From 86a0029b727b74c9ba1157f01c89daa7bfd60788 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Mar 2024 00:44:09 +0000
Subject: [PATCH 036/416] chore(deps): bump mio from 0.8.10 to 0.8.11 (#4478)

Bumps [mio](https://github.com/tokio-rs/mio) from 0.8.10 to 0.8.11.
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a
href="https://github.com/tokio-rs/mio/blob/master/CHANGELOG.md">mio's
changelog</a>.</em></p>
<blockquote>
<h1>0.8.11</h1>
<ul>
<li>Fix receiving IOCP events after deregistering a Windows named pipe
(<a
href="https://redirect.github.com/tokio-rs/mio/pull/1760">tokio-rs/mio#1760</a>,
backport pr:
<a
href="https://redirect.github.com/tokio-rs/mio/pull/1761">tokio-rs/mio#1761</a>).</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/tokio-rs/mio/commit/0328bdef900b6396b8d00d33c825cd8af748553d"><code>0328bde</code></a>
Release v0.8.11</li>
<li><a
href="https://github.com/tokio-rs/mio/commit/708449851283b57eb6f514c8f289b66e982720b3"><code>7084498</code></a>
Fix warnings</li>
<li><a
href="https://github.com/tokio-rs/mio/commit/90d4fe00df870acd3d38f3dc4face9aacab8fbb9"><code>90d4fe0</code></a>
named-pipes: fix receiving IOCP events after deregister</li>
<li><a
href="https://github.com/tokio-rs/mio/commit/c710a307f8627c4d63ac1003252aa45175e08399"><code>c710a30</code></a>
Add v0.8.x to the CI</li>
<li><a
href="https://github.com/tokio-rs/mio/commit/c29e21c244b2b835e8b3e015b92c708c33c7d70a"><code>c29e21c</code></a>
Release v0.8.10</li>
<li>See full diff in <a
href="https://github.com/tokio-rs/mio/compare/v0.8.10...v0.8.11">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=mio&package-manager=cargo&previous-version=0.8.10&new-version=0.8.11)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the
[Security Alerts
page](https://github.com/noir-lang/noir/network/alerts).

</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c0438eaf81f..b2b6f8037bb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2634,9 +2634,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
 dependencies = [
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",

From 00d2c32e58176cc5de3574c8435a54d415c4a5fa Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Tue, 5 Mar 2024 08:06:07 -0500
Subject: [PATCH 037/416] feat: Add eddsa_poseidon_to_pub function to stdlib
 with test + docs (#4473)

# Description

## Problem\*

Gives a source of truth for deriving public keys for EdDSA signatures,
e.g. for testing.

## Summary\*

Adds this function:
```rust
fn eddsa_poseidon_to_pub(secret: Field) -> (Field, Field)
```

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
---
 .../cryptographic_primitives/eddsa.mdx                | 11 +++++++++++
 noir_stdlib/src/eddsa.nr                              |  7 +++++++
 test_programs/execution_success/eddsa/src/main.nr     | 10 ++++++++--
 3 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
index a9c10da6c06..99b7f830a20 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -16,3 +16,14 @@ fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s
 ```
 
 <BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/noir_stdlib/src/eddsa.nr b/noir_stdlib/src/eddsa.nr
index 657e791e9c7..966bc1da2a1 100644
--- a/noir_stdlib/src/eddsa.nr
+++ b/noir_stdlib/src/eddsa.nr
@@ -38,3 +38,10 @@ pub fn eddsa_poseidon_verify(
 
     left.eq(right)
 }
+
+// Returns the public key of the given secret key as (pub_key_x, pub_key_y)
+pub fn eddsa_to_pub(secret: Field) -> (Field, Field) {
+    let bjj = baby_jubjub();
+    let pub_key = bjj.curve.mul(secret, bjj.curve.gen);
+    (pub_key.x, pub_key.y)
+}
diff --git a/test_programs/execution_success/eddsa/src/main.nr b/test_programs/execution_success/eddsa/src/main.nr
index 12e8ea92785..4404ffe75f7 100644
--- a/test_programs/execution_success/eddsa/src/main.nr
+++ b/test_programs/execution_success/eddsa/src/main.nr
@@ -1,14 +1,20 @@
 use dep::std::compat;
 use dep::std::ec::consts::te::baby_jubjub;
+use dep::std::ec::tecurve::affine::Point as TEPoint;
 use dep::std::hash;
-use dep::std::eddsa::eddsa_poseidon_verify;
+use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify};
+
 fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
     // Skip this test for non-bn254 backends
     if compat::is_bn254() {
         let bjj = baby_jubjub();
 
         let pub_key_a = bjj.curve.mul(_priv_key_a, bjj.curve.gen);
-        // let pub_key_b = bjj.curve.mul(_priv_key_b, bjj.curve.gen);
+        let pub_key_b = bjj.curve.mul(_priv_key_b, bjj.curve.gen);
+        let (pub_key_a_x, pub_key_a_y) = eddsa_to_pub(_priv_key_a);
+        let (pub_key_b_x, pub_key_b_y) = eddsa_to_pub(_priv_key_b);
+        assert(TEPoint::new(pub_key_a_x, pub_key_a_y) == pub_key_a);
+        assert(TEPoint::new(pub_key_b_x, pub_key_b_y) == pub_key_b);
         // Manually computed as fields can't use modulo. Importantantly the commitment is within
         // the subgroup order. Note that choice of hash is flexible for this step.
         // let r_a = hash::pedersen_commitment([_priv_key_a, msg])[0] % bjj.suborder; // modulus computed manually

From 5f57ebb7ff4b810802f90699a10f4325ef904f2e Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 5 Mar 2024 09:48:57 -0500
Subject: [PATCH 038/416] feat: Sync from aztec-packages (#4465)

BEGIN_COMMIT_OVERRIDE
feat!: Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
chore: remove import of `dep::aztec` from aztec_macros
(https://github.com/AztecProtocol/aztec-packages/pull/4941)
fix: noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .aztec-sync-commit                            |   2 +-
 .dockerignore                                 |  27 ---
 .gitignore                                    |   3 -
 Dockerfile                                    |  12 -
 Dockerfile.packages                           |  22 --
 .../acvm_js/test/node/build_info.test.ts      |  12 +-
 aztec_macros/src/lib.rs                       | 226 +++++++++++++-----
 bootstrap.sh                                  |  22 --
 bootstrap_cache.sh                            |  13 -
 compiler/noirc_frontend/src/lexer/token.rs    |   3 -
 .../src/parser/parser/function.rs             |  14 +-
 compiler/wasm/scripts/build-fixtures.sh       |   2 +-
 noir_stdlib/src/sha512.nr                     |   2 +-
 package.json                                  |   2 +-
 scripts/bootstrap_native.sh                   |  26 --
 scripts/bootstrap_packages.sh                 |  31 ---
 scripts/test_js_packages.sh                   |  25 --
 scripts/test_native.sh                        |  17 --
 .../simple_contract/src/main.nr               |   4 +-
 .../Prover.toml                               |   0
 .../src/main.nr                               |  11 +
 .../src/cli/noir_template_files/contract.nr   |   2 +-
 tooling/nargo_cli/src/cli/test_cmd.rs         |   6 +-
 tooling/nargo_fmt/tests/expected/contract.nr  |   3 +-
 tooling/nargo_fmt/tests/input/contract.nr     |   3 +-
 25 files changed, 210 insertions(+), 280 deletions(-)
 delete mode 100644 .dockerignore
 delete mode 100644 Dockerfile
 delete mode 100644 Dockerfile.packages
 delete mode 100755 bootstrap.sh
 delete mode 100755 bootstrap_cache.sh
 delete mode 100755 scripts/bootstrap_native.sh
 delete mode 100755 scripts/bootstrap_packages.sh
 delete mode 100755 scripts/test_js_packages.sh
 delete mode 100755 scripts/test_native.sh
 create mode 100644 test_programs/noir_test_failure/should_fail_suite_with_one_failure/Prover.toml
 create mode 100644 test_programs/noir_test_failure/should_fail_suite_with_one_failure/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index c97738f7226..78e53d61647 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-9e246c1289fa40c35c4b28d2f0081dfdc2aa9d19
+73d640a4a033f0c865d45da470ef40c1fb03a844
diff --git a/.dockerignore b/.dockerignore
deleted file mode 100644
index 559b271bf38..00000000000
--- a/.dockerignore
+++ /dev/null
@@ -1,27 +0,0 @@
-Dockerfile*
-.dockerignore
-
-# Yarn
-.pnp.*
-.yarn/*
-!.yarn/patches
-!.yarn/plugins
-!.yarn/releases
-!.yarn/sdks
-!.yarn/versions
-
-packages
-**/package.tgz
-**/target
-**/node_modules
-**/outputs
-
-# Noir.js
-tooling/noir_js/lib
-
-# Wasm build artifacts
-compiler/wasm/nodejs
-compiler/wasm/web
-tooling/noirc_abi_wasm/nodejs
-tooling/noirc_abi_wasm/web
-tooling/noir_js/lib
diff --git a/.gitignore b/.gitignore
index 8d02d34d463..5f41566c94b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,8 +50,5 @@ tooling/noirc_abi_wasm/nodejs
 tooling/noirc_abi_wasm/web
 tooling/noir_js/lib
 
-**/package.tgz
-packages
-
 # docs autogen build
 /docs/docs/noir_js/reference/
diff --git a/Dockerfile b/Dockerfile
deleted file mode 100644
index 3a478c3f95a..00000000000
--- a/Dockerfile
+++ /dev/null
@@ -1,12 +0,0 @@
-FROM rust:bullseye
-WORKDIR /usr/src/noir
-COPY . .
-RUN ./scripts/bootstrap_native.sh
-
-# When running the container, mount the users home directory to same location.
-FROM ubuntu:focal
-# Install Tini as nargo doesn't handle signals properly.
-# Install git as nargo needs it to clone.
-RUN apt-get update && apt-get install -y git tini && rm -rf /var/lib/apt/lists/* && apt-get clean
-COPY --from=0 /usr/src/noir/target/release/nargo /usr/src/noir/target/release/nargo
-ENTRYPOINT ["/usr/bin/tini", "--", "/usr/src/noir/target/release/nargo"]
diff --git a/Dockerfile.packages b/Dockerfile.packages
deleted file mode 100644
index f40670c19e4..00000000000
--- a/Dockerfile.packages
+++ /dev/null
@@ -1,22 +0,0 @@
-FROM rust:alpine3.17
-RUN apk update \
-    && apk upgrade \
-    && apk add --no-cache \
-    build-base \
-    pkgconfig \
-    openssl-dev \
-    npm \
-    yarn \
-    bash \
-    jq \
-    git \
-    curl
-
-WORKDIR /usr/src/noir
-COPY . .
-RUN ./scripts/bootstrap_packages.sh
-
-FROM scratch
-COPY --from=0 /usr/src/noir/packages /usr/src/noir/packages
-# For some unknown reason, on alpine only, we need this to exist.
-COPY --from=0 /usr/src/noir/node_modules/@noir-lang /usr/src/noir/node_modules/@noir-lang
diff --git a/acvm-repo/acvm_js/test/node/build_info.test.ts b/acvm-repo/acvm_js/test/node/build_info.test.ts
index 23100505011..014bb6f422d 100644
--- a/acvm-repo/acvm_js/test/node/build_info.test.ts
+++ b/acvm-repo/acvm_js/test/node/build_info.test.ts
@@ -3,12 +3,20 @@ import { BuildInfo, buildInfo } from '@noir-lang/acvm_js';
 import child_process from 'child_process';
 import pkg from '../../package.json';
 
-it('returns the correct build into', () => {
+it('returns the correct build info', () => {
+  let revision: string;
+
+  try {
+    revision = child_process.execSync('git rev-parse HEAD').toString().trim();
+  } catch (error) {
+    console.log('Failed to get revision, skipping test.');
+    return;
+  }
+
   const info: BuildInfo = buildInfo();
 
   // TODO: enforce that `package.json` and `Cargo.toml` are consistent.
   expect(info.version).to.be.eq(pkg.version);
 
-  const revision = child_process.execSync('git rev-parse HEAD').toString().trim();
   expect(info.gitHash).to.be.eq(revision);
 });
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 09deb2c9712..f860f2c465a 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -3,7 +3,7 @@ use std::vec;
 
 use convert_case::{Case, Casing};
 use iter_extended::vecmap;
-use noirc_errors::Location;
+use noirc_errors::{Location, Spanned};
 use noirc_frontend::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
 use noirc_frontend::hir::def_map::{LocalModuleId, ModuleId};
 use noirc_frontend::macros_api::parse_program;
@@ -11,17 +11,17 @@ use noirc_frontend::macros_api::FieldElement;
 use noirc_frontend::macros_api::{
     BlockExpression, CallExpression, CastExpression, Distinctness, Expression, ExpressionKind,
     ForLoopStatement, ForRange, FunctionDefinition, FunctionReturnType, FunctionVisibility,
-    HirContext, HirExpression, HirLiteral, HirStatement, Ident, ImportStatement, IndexExpression,
-    LetStatement, Literal, MemberAccessExpression, MethodCallExpression, NoirFunction, NoirStruct,
-    Param, Path, PathKind, Pattern, PrefixExpression, SecondaryAttribute, Signedness, Span,
-    Statement, StatementKind, StructType, Type, TypeImpl, UnaryOp, UnresolvedType,
-    UnresolvedTypeData, Visibility,
+    HirContext, HirExpression, HirLiteral, HirStatement, Ident, IndexExpression, LetStatement,
+    Literal, MemberAccessExpression, MethodCallExpression, NoirFunction, NoirStruct, Param, Path,
+    PathKind, Pattern, PrefixExpression, SecondaryAttribute, Signedness, Span, Statement,
+    StatementKind, StructType, Type, TypeImpl, UnaryOp, UnresolvedType, UnresolvedTypeData,
+    Visibility,
 };
 use noirc_frontend::macros_api::{CrateId, FileId};
 use noirc_frontend::macros_api::{MacroError, MacroProcessor};
 use noirc_frontend::macros_api::{ModuleDefId, NodeInterner, SortedModule, StructId};
 use noirc_frontend::node_interner::{FuncId, TraitId, TraitImplId, TraitImplKind};
-use noirc_frontend::Lambda;
+use noirc_frontend::{BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, Lambda};
 pub struct AztecMacro;
 
 impl MacroProcessor for AztecMacro {
@@ -74,6 +74,7 @@ pub enum AztecMacroError {
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
     EventError { span: Span, message: String },
+    UnsupportedAttributes { span: Span, secondary_message: Option<String> },
 }
 
 impl From<AztecMacroError> for MacroError {
@@ -114,6 +115,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: Some(span),
             },
+            AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
+                primary_message: "Unsupported attributes in contract function".to_string(),
+                secondary_message,
+                span: Some(span),
+            },
         }
     }
 }
@@ -215,6 +221,14 @@ fn lambda(parameters: Vec<(Pattern, UnresolvedType)>, body: Expression) -> Expre
     })))
 }
 
+fn make_eq(lhs: Expression, rhs: Expression) -> Expression {
+    expression(ExpressionKind::Infix(Box::new(InfixExpression {
+        lhs,
+        rhs,
+        operator: Spanned::from(Span::default(), BinaryOpKind::Equal),
+    })))
+}
+
 macro_rules! chained_path {
     ( $base:expr ) => {
         {
@@ -267,10 +281,6 @@ fn index_array_variable(array: Expression, index: &str) -> Expression {
     })))
 }
 
-fn import(path: Path) -> ImportStatement {
-    ImportStatement { path, alias: None }
-}
-
 //
 //                    Create AST Nodes for Aztec
 //
@@ -290,7 +300,6 @@ fn transform(
             .map_err(|(err, file_id)| (err.into(), file_id))?
         {
             check_for_aztec_dependency(crate_id, context)?;
-            include_relevant_imports(&mut submodule.contents);
         }
     }
     Ok(ast)
@@ -309,21 +318,6 @@ fn transform_hir(
     assign_storage_slots(crate_id, context)
 }
 
-/// Includes an import to the aztec library if it has not been included yet
-fn include_relevant_imports(ast: &mut SortedModule) {
-    // Create the aztec import path using the assumed chained_dep! macro
-    let aztec_import_path = import(chained_dep!("aztec"));
-
-    // Check if the aztec import already exists
-    let is_aztec_imported =
-        ast.imports.iter().any(|existing_import| existing_import.path == aztec_import_path.path);
-
-    // If aztec is not imported, add the import at the beginning
-    if !is_aztec_imported {
-        ast.imports.insert(0, aztec_import_path);
-    }
-}
-
 /// Creates an error alerting the user that they have not downloaded the Aztec-noir library
 fn check_for_aztec_dependency(
     crate_id: &CrateId,
@@ -429,23 +423,58 @@ fn transform_module(
         }
     }
 
+    let has_initializer = module.functions.iter().any(|func| {
+        func.def
+            .attributes
+            .secondary
+            .iter()
+            .any(|attr| is_custom_attribute(attr, "aztec(initializer)"))
+    });
+
     for func in module.functions.iter_mut() {
+        let mut is_private = false;
+        let mut is_public = false;
+        let mut is_public_vm = false;
+        let mut is_initializer = false;
+        let mut is_internal = false;
+        let mut insert_init_check = has_initializer;
+
         for secondary_attribute in func.def.attributes.secondary.clone() {
-            let crate_graph = &context.crate_graph[crate_id];
             if is_custom_attribute(&secondary_attribute, "aztec(private)") {
-                transform_function("Private", func, storage_defined)
-                    .map_err(|err| (err, crate_graph.root_file_id))?;
-                has_transformed_module = true;
+                is_private = true;
+            } else if is_custom_attribute(&secondary_attribute, "aztec(initializer)") {
+                is_initializer = true;
+                insert_init_check = false;
+            } else if is_custom_attribute(&secondary_attribute, "aztec(noinitcheck)") {
+                insert_init_check = false;
+            } else if is_custom_attribute(&secondary_attribute, "aztec(internal)") {
+                is_internal = true;
             } else if is_custom_attribute(&secondary_attribute, "aztec(public)") {
-                transform_function("Public", func, storage_defined)
-                    .map_err(|err| (err, crate_graph.root_file_id))?;
-                has_transformed_module = true;
+                is_public = true;
+                insert_init_check = false;
             } else if is_custom_attribute(&secondary_attribute, "aztec(public-vm)") {
-                transform_vm_function(func, storage_defined)
-                    .map_err(|err| (err, crate_graph.root_file_id))?;
-                has_transformed_module = true;
+                is_public_vm = true;
             }
         }
+
+        // Apply transformations to the function based on collected attributes
+        if is_private || is_public {
+            transform_function(
+                if is_private { "Private" } else { "Public" },
+                func,
+                storage_defined,
+                is_initializer,
+                insert_init_check,
+                is_internal,
+            )
+            .map_err(|err| (err, crate_graph.root_file_id))?;
+            has_transformed_module = true;
+        } else if is_public_vm {
+            transform_vm_function(func, storage_defined)
+                .map_err(|err| (err, crate_graph.root_file_id))?;
+            has_transformed_module = true;
+        }
+
         // Add the storage struct to the beginning of the function if it is unconstrained in an aztec contract
         if storage_defined && func.def.is_unconstrained {
             transform_unconstrained(func);
@@ -511,7 +540,7 @@ fn generate_storage_field_constructor(
                                 (
                                     pattern("context"),
                                     make_type(UnresolvedTypeData::Named(
-                                        chained_path!("aztec", "context", "Context"),
+                                        chained_dep!("aztec", "context", "Context"),
                                         vec![],
                                         true,
                                     )),
@@ -595,7 +624,7 @@ fn generate_storage_implementation(module: &mut SortedModule) -> Result<(), Azte
         &[(
             ident("context"),
             make_type(UnresolvedTypeData::Named(
-                chained_path!("aztec", "context", "Context"),
+                chained_dep!("aztec", "context", "Context"),
                 vec![],
                 true,
             )),
@@ -627,11 +656,36 @@ fn transform_function(
     ty: &str,
     func: &mut NoirFunction,
     storage_defined: bool,
+    is_initializer: bool,
+    insert_init_check: bool,
+    is_internal: bool,
 ) -> Result<(), AztecMacroError> {
     let context_name = format!("{}Context", ty);
     let inputs_name = format!("{}ContextInputs", ty);
     let return_type_name = format!("{}CircuitPublicInputs", ty);
 
+    // Add check that msg sender equals this address and flag function as internal
+    if is_internal {
+        let is_internal_check = create_internal_check(func.name());
+        func.def.body.0.insert(0, is_internal_check);
+        func.def.is_internal = true;
+    }
+
+    // Add initialization check
+    if insert_init_check {
+        if ty == "Public" {
+            let error = AztecMacroError::UnsupportedAttributes {
+                span: func.def.name.span(),
+                secondary_message: Some(
+                    "public functions do not yet support initialization check".to_owned(),
+                ),
+            };
+            return Err(error);
+        }
+        let init_check = create_init_check();
+        func.def.body.0.insert(0, init_check);
+    }
+
     // Add access to the storage struct
     if storage_defined {
         let storage_def = abstract_storage(&ty.to_lowercase(), false);
@@ -655,6 +709,21 @@ fn transform_function(
         func.def.body.0.push(return_values);
     }
 
+    // Before returning mark the contract as initialized
+    if is_initializer {
+        if ty == "Public" {
+            let error = AztecMacroError::UnsupportedAttributes {
+                span: func.def.name.span(),
+                secondary_message: Some(
+                    "public functions cannot yet be used as initializers".to_owned(),
+                ),
+            };
+            return Err(error);
+        }
+        let mark_initialized = create_mark_as_initialized();
+        func.def.body.0.push(mark_initialized);
+    }
+
     // Push the finish method call to the end of the function
     let finish_def = create_context_finish();
     func.def.body.0.push(finish_def);
@@ -1028,7 +1097,7 @@ fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
         make_type(UnresolvedTypeData::Named(path(structure.name.clone()), vec![], true));
 
     let selector_path =
-        chained_path!("aztec", "protocol_types", "abis", "function_selector", "FunctionSelector");
+        chained_dep!("aztec", "protocol_types", "abis", "function_selector", "FunctionSelector");
     let mut from_signature_path = selector_path.clone();
     from_signature_path.segments.push(ident("from_signature"));
 
@@ -1083,7 +1152,7 @@ fn create_inputs(ty: &str) -> Param {
     let context_pattern = Pattern::Identifier(context_ident);
 
     let path_snippet = ty.to_case(Case::Snake); // e.g. private_context_inputs
-    let type_path = chained_path!("aztec", "context", "inputs", &path_snippet, ty);
+    let type_path = chained_dep!("aztec", "context", "inputs", &path_snippet, ty);
 
     let context_type = make_type(UnresolvedTypeData::Named(type_path, vec![], true));
     let visibility = Visibility::Private;
@@ -1091,6 +1160,51 @@ fn create_inputs(ty: &str) -> Param {
     Param { pattern: context_pattern, typ: context_type, visibility, span: Span::default() }
 }
 
+/// Creates an initialization check to ensure that the contract has been initialized, meant to
+/// be injected as the first statement of any function after the context has been created.
+///
+/// ```noir
+/// assert_is_initialized(&mut context);
+/// ```
+fn create_init_check() -> Statement {
+    make_statement(StatementKind::Expression(call(
+        variable_path(chained_dep!("aztec", "initializer", "assert_is_initialized")),
+        vec![mutable_reference("context")],
+    )))
+}
+
+/// Creates a call to mark_as_initialized which emits the initialization nullifier, meant to
+/// be injected as the last statement before returning in a constructor.
+///
+/// ```noir
+/// mark_as_initialized(&mut context);
+/// ```
+fn create_mark_as_initialized() -> Statement {
+    make_statement(StatementKind::Expression(call(
+        variable_path(chained_dep!("aztec", "initializer", "mark_as_initialized")),
+        vec![mutable_reference("context")],
+    )))
+}
+
+/// Creates a check for internal functions ensuring that the caller is self.
+///
+/// ```noir
+/// assert(context.msg_sender() == context.this_address(), "Function can only be called internally");
+/// ```
+fn create_internal_check(fname: &str) -> Statement {
+    make_statement(StatementKind::Constrain(ConstrainStatement(
+        make_eq(
+            method_call(variable("context"), "msg_sender", vec![]),
+            method_call(variable("context"), "this_address", vec![]),
+        ),
+        Some(expression(ExpressionKind::Literal(Literal::Str(format!(
+            "Function {} can only be called internally",
+            fname
+        ))))),
+        ConstrainKind::Assert,
+    )))
+}
+
 /// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
 /// appended into the args hash object.
 ///
@@ -1123,8 +1237,8 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
     let let_hasher = mutable_assignment(
         "hasher", // Assigned to
         call(
-            variable_path(chained_path!("aztec", "hasher", "Hasher", "new")), // Path
-            vec![],                                                           // args
+            variable_path(chained_dep!("aztec", "hasher", "Hasher", "new")), // Path
+            vec![],                                                          // args
         ),
     );
 
@@ -1192,8 +1306,8 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
     let let_context = mutable_assignment(
         "context", // Assigned to
         call(
-            variable_path(chained_path!("aztec", "context", &path_snippet, ty, "new")), // Path
-            vec![inputs_expression, hash_call],                                         // args
+            variable_path(chained_dep!("aztec", "context", &path_snippet, ty, "new")), // Path
+            vec![inputs_expression, hash_call],                                        // args
         ),
     );
     injected_expressions.push(let_context);
@@ -1223,8 +1337,8 @@ fn create_avm_context() -> Result<Statement, AztecMacroError> {
     let let_context = mutable_assignment(
         "context", // Assigned to
         call(
-            variable_path(chained_path!("aztec", "context", "AVMContext", "new")), // Path
-            vec![],                                                                // args
+            variable_path(chained_dep!("aztec", "context", "AVMContext", "new")), // Path
+            vec![],                                                               // args
         ),
     );
 
@@ -1259,13 +1373,13 @@ fn create_avm_context() -> Result<Statement, AztecMacroError> {
 /// Any primitive type that can be cast will be casted to a field and pushed to the context.
 fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
     let current_return_type = func.return_type().typ;
-    let last_statement = func.def.body.0.last()?;
+    let last_statement = func.def.body.0.last();
 
     // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
     // Doesn't need done until we have settled on a kernel size
     // TODO: support tuples here and in inputs -> convert into an issue
     // Check if the return type is an expression, if it is, we can handle it
-    match last_statement {
+    match last_statement? {
         Statement { kind: StatementKind::Expression(expression), .. } => {
             match current_return_type {
                 // Call serialize on structs, push the whole array, calling push_array
@@ -1309,13 +1423,13 @@ fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
 fn abstract_storage(typ: &str, unconstrained: bool) -> Statement {
     let init_context_call = if unconstrained {
         call(
-            variable_path(chained_path!("aztec", "context", "Context", "none")), // Path
-            vec![],                                                              // args
+            variable_path(chained_dep!("aztec", "context", "Context", "none")), // Path
+            vec![],                                                             // args
         )
     } else {
         call(
-            variable_path(chained_path!("aztec", "context", "Context", typ)), // Path
-            vec![mutable_reference("context")],                               // args
+            variable_path(chained_dep!("aztec", "context", "Context", typ)), // Path
+            vec![mutable_reference("context")],                              // args
         )
     };
 
@@ -1436,7 +1550,7 @@ fn make_castable_return_type(expression: Expression) -> Statement {
 /// }
 fn create_return_type(ty: &str) -> FunctionReturnType {
     let path_snippet = ty.to_case(Case::Snake); // e.g. private_circuit_public_inputs or public_circuit_public_inputs
-    let return_path = chained_path!("aztec", "protocol_types", "abis", &path_snippet, ty);
+    let return_path = chained_dep!("aztec", "protocol_types", "abis", &path_snippet, ty);
     return_type(return_path)
 }
 
@@ -1792,7 +1906,7 @@ fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) ->
 
         let if_statements: Vec<String> = note_types.iter().map(|note_type| format!(
             "if (note_type_id == {0}::get_note_type_id()) {{
-                note_utils::compute_note_hash_and_nullifier({0}::deserialize_content, note_header, serialized_note)
+                dep::aztec::note::utils::compute_note_hash_and_nullifier({0}::deserialize_content, note_header, serialized_note)
             }}"
         , note_type)).collect();
 
@@ -1812,7 +1926,7 @@ fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) ->
                 note_type_id: Field,
                 serialized_note: [Field; 20]
             ) -> pub [Field; 4] {{
-                let note_header = NoteHeader::new(contract_address, nonce, storage_slot);
+                let note_header = dep::aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
 
                 {}
             }}",
diff --git a/bootstrap.sh b/bootstrap.sh
deleted file mode 100755
index 54129c3d61a..00000000000
--- a/bootstrap.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-set -eu
-
-cd $(dirname "$0")
-
-CMD=${1:-}
-
-if [ -n "$CMD" ]; then
-  if [ "$CMD" = "clean" ]; then
-    git clean -fdx
-    exit 0
-  else
-    echo "Unknown command: $CMD"
-    exit 1
-  fi
-fi
-
-# Attempt to just pull artefacts from CI and exit on success.
-[ -n "${USE_CACHE:-}" ] && ./bootstrap_cache.sh && exit
-
-./scripts/bootstrap_native.sh
-./scripts/bootstrap_packages.sh
diff --git a/bootstrap_cache.sh b/bootstrap_cache.sh
deleted file mode 100755
index 1cec6c81d8e..00000000000
--- a/bootstrap_cache.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-set -eu
-
-cd "$(dirname "$0")"
-source ../build-system/scripts/setup_env '' '' mainframe_$USER > /dev/null
-
-echo -e "\033[1mRetrieving noir packages from remote cache...\033[0m"
-extract_repo noir-packages /usr/src/noir/packages ./
-echo -e "\033[1mRetrieving nargo from remote cache...\033[0m"
-extract_repo noir /usr/src/noir/target/release ./target/
-
-remove_old_images noir-packages
-remove_old_images noir
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 5674ae5a39a..f096c220200 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -661,7 +661,6 @@ pub enum Keyword {
     If,
     Impl,
     In,
-    Internal,
     Let,
     Mod,
     Mut,
@@ -704,7 +703,6 @@ impl fmt::Display for Keyword {
             Keyword::If => write!(f, "if"),
             Keyword::Impl => write!(f, "impl"),
             Keyword::In => write!(f, "in"),
-            Keyword::Internal => write!(f, "internal"),
             Keyword::Let => write!(f, "let"),
             Keyword::Mod => write!(f, "mod"),
             Keyword::Mut => write!(f, "mut"),
@@ -750,7 +748,6 @@ impl Keyword {
             "if" => Keyword::If,
             "impl" => Keyword::Impl,
             "in" => Keyword::In,
-            "internal" => Keyword::Internal,
             "let" => Keyword::Let,
             "mod" => Keyword::Mod,
             "mut" => Keyword::Mut,
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 42ee484bfc9..7448d84cfe1 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -37,7 +37,8 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
                 attributes,
                 is_unconstrained: modifiers.0,
                 is_open: modifiers.2,
-                is_internal: modifiers.3,
+                // Whether a function is internal or not is now set through `aztec_macros`
+                is_internal: false,
                 visibility: modifiers.1,
                 generics,
                 parameters,
@@ -66,17 +67,16 @@ fn visibility_modifier() -> impl NoirParser<FunctionVisibility> {
     choice((is_pub_crate, is_pub, is_private))
 }
 
-/// function_modifiers: 'unconstrained'? (visibility)? 'open'? 'internal'?
+/// function_modifiers: 'unconstrained'? (visibility)? 'open'?
 ///
-/// returns (is_unconstrained, visibility, is_open, is_internal) for whether each keyword was present
-fn function_modifiers() -> impl NoirParser<(bool, FunctionVisibility, bool, bool)> {
+/// returns (is_unconstrained, visibility, is_open) for whether each keyword was present
+fn function_modifiers() -> impl NoirParser<(bool, FunctionVisibility, bool)> {
     keyword(Keyword::Unconstrained)
         .or_not()
         .then(visibility_modifier())
         .then(keyword(Keyword::Open).or_not())
-        .then(keyword(Keyword::Internal).or_not())
-        .map(|(((unconstrained, visibility), open), internal)| {
-            (unconstrained.is_some(), visibility, open.is_some(), internal.is_some())
+        .map(|((unconstrained, visibility), open)| {
+            (unconstrained.is_some(), visibility, open.is_some())
         })
 }
 
diff --git a/compiler/wasm/scripts/build-fixtures.sh b/compiler/wasm/scripts/build-fixtures.sh
index 3a2330d4726..4c0505ef519 100755
--- a/compiler/wasm/scripts/build-fixtures.sh
+++ b/compiler/wasm/scripts/build-fixtures.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
 
 nargo compile --program-dir ./test/fixtures/simple
-nargo compile --program-dir ./test/fixtures/with-deps 
+nargo compile --program-dir ./test/fixtures/with-deps
 nargo compile --program-dir ./test/fixtures/noir-contract
\ No newline at end of file
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index 4dfe78308e2..f3155dd7528 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -136,7 +136,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
             msg_block[i as Field] = 0;
             i += 1;
         } else if i < 128 {
-            let mut len = 8 * msg.len();
+            let mut len = 8 * msg.len(); // u128 unsupported
             for j in 0..16 {
                 msg_block[127 - j] = len as u8;
                 len >>= 8;
diff --git a/package.json b/package.json
index 4987602c709..fcf36c9b969 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "build": "yarn workspaces foreach --parallel --topological-dev --verbose run build",
-    "test": "yarn workspaces foreach run test",
+    "test": "yarn workspaces foreach --parallel --verbose run test",
     "test:integration": "yarn workspace integration-tests test",
     "clean:workspaces": "yarn workspaces foreach --exclude @noir-lang/root run clean",
     "clean:root": "rm -rf ./result ./target ./packages",
diff --git a/scripts/bootstrap_native.sh b/scripts/bootstrap_native.sh
deleted file mode 100755
index 974f0edcfec..00000000000
--- a/scripts/bootstrap_native.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-set -eu
-
-cd $(dirname "$0")/..
-
-# If this project has been subrepod into another project, set build data manually.
-export SOURCE_DATE_EPOCH=$(date +%s)
-export GIT_DIRTY=false
-if [ -f ".gitrepo" ]; then
-  export GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo)
-else
-  export GIT_COMMIT=$(git rev-parse --verify HEAD)
-fi
-
-# Check if the 'cargo' command is available in the system
-if ! command -v cargo > /dev/null; then
-    echo "Cargo is not installed. Please install Cargo and the Rust toolchain."
-    exit 1
-fi
-
-# Build native.
-if [ -n "${DEBUG:-}" ]; then
-  cargo build
-else
-  cargo build --release
-fi
diff --git a/scripts/bootstrap_packages.sh b/scripts/bootstrap_packages.sh
deleted file mode 100755
index 47ffe12beec..00000000000
--- a/scripts/bootstrap_packages.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-set -eu
-
-cd $(dirname "$0")/..
-
-./.github/scripts/wasm-bindgen-install.sh
-
-# If this project has been subrepod into another project, set build data manually.
-export SOURCE_DATE_EPOCH=$(date +%s)
-export GIT_DIRTY=false
-if [ -f ".gitrepo" ]; then
-  export GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo)
-else
-  export GIT_COMMIT=$(git rev-parse --verify HEAD)
-fi
-
-yarn --immutable
-yarn build
-
-# We create a folder called packages, that contains each package as it would be published to npm, named correctly.
-# These can be useful for testing, or portaling into other projects.
-yarn workspaces foreach pack
-
-rm -rf packages && mkdir -p packages
-tar zxfv acvm-repo/acvm_js/package.tgz -C packages && mv packages/package packages/acvm_js
-tar zxfv compiler/wasm/package.tgz -C packages && mv packages/package packages/noir_wasm
-tar zxfv tooling/noir_codegen/package.tgz -C packages && mv packages/package packages/noir_codegen
-tar zxfv tooling/noir_js/package.tgz -C packages && mv packages/package packages/noir_js
-tar zxfv tooling/noir_js_backend_barretenberg/package.tgz -C packages && mv packages/package packages/backend_barretenberg
-tar zxfv tooling/noir_js_types/package.tgz -C packages && mv packages/package packages/types
-tar zxfv tooling/noirc_abi_wasm/package.tgz -C packages && mv packages/package packages/noirc_abi
diff --git a/scripts/test_js_packages.sh b/scripts/test_js_packages.sh
deleted file mode 100755
index e1e10c543e0..00000000000
--- a/scripts/test_js_packages.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/bash
-set -eu
-
-cd $(dirname "$0")/..
-
-./.github/scripts/wasm-bindgen-install.sh
-
-# If this project has been subrepod into another project, set build data manually.
-export SOURCE_DATE_EPOCH=$(date +%s)
-export GIT_DIRTY=false
-if [ -f ".gitrepo" ]; then
-  export GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo)
-else
-  export GIT_COMMIT=$(git rev-parse --verify HEAD)
-fi
-
-cargo build --release
-export PATH="${PATH}:/usr/src/noir/target/release/"
-
-yarn --immutable
-yarn build
-./.github/scripts/playwright-install.sh
-
-./scripts/test.sh
-yarn test
diff --git a/scripts/test_native.sh b/scripts/test_native.sh
deleted file mode 100755
index 9b9aa0ce4d7..00000000000
--- a/scripts/test_native.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/bin/bash
-set -eu
-
-cd $(dirname "$0")/..
-
-# If this project has been subrepod into another project, set build data manually.
-export SOURCE_DATE_EPOCH=$(date +%s)
-export GIT_DIRTY=false
-if [ -f ".gitrepo" ]; then
-  export GIT_COMMIT=$(awk '/commit =/ {print $3}' .gitrepo)
-else
-  export GIT_COMMIT=$(git rev-parse --verify HEAD)
-fi
-
-cargo fmt --all --check
-cargo clippy --workspace --locked --release
-cargo test --workspace --locked --release
diff --git a/test_programs/compile_success_contract/simple_contract/src/main.nr b/test_programs/compile_success_contract/simple_contract/src/main.nr
index fea0ae08c22..ed90ac8bd1d 100644
--- a/test_programs/compile_success_contract/simple_contract/src/main.nr
+++ b/test_programs/compile_success_contract/simple_contract/src/main.nr
@@ -5,10 +5,10 @@ contract Foo {
     fn triple(x: Field) -> pub Field {
         x * 3
     }
-    internal fn quadruple(x: Field) -> pub Field {
+    fn quadruple(x: Field) -> pub Field {
         x * 4
     }
-    open internal fn skibbidy(x: Field) -> pub Field {
+    open fn skibbidy(x: Field) -> pub Field {
         x * 5
     }
     // Regression for issue #3344
diff --git a/test_programs/noir_test_failure/should_fail_suite_with_one_failure/Prover.toml b/test_programs/noir_test_failure/should_fail_suite_with_one_failure/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/noir_test_failure/should_fail_suite_with_one_failure/src/main.nr b/test_programs/noir_test_failure/should_fail_suite_with_one_failure/src/main.nr
new file mode 100644
index 00000000000..8ed9003164a
--- /dev/null
+++ b/test_programs/noir_test_failure/should_fail_suite_with_one_failure/src/main.nr
@@ -0,0 +1,11 @@
+/// Test to make sure the entire test suite fails, even if some of the tests pass!
+
+#[test]
+fn this_will_pass() {
+    assert(true);
+}
+
+#[test]
+fn this_will_fail() {
+    assert(false);
+}
diff --git a/tooling/nargo_cli/src/cli/noir_template_files/contract.nr b/tooling/nargo_cli/src/cli/noir_template_files/contract.nr
index e126726393d..3cd3b5b3766 100644
--- a/tooling/nargo_cli/src/cli/noir_template_files/contract.nr
+++ b/tooling/nargo_cli/src/cli/noir_template_files/contract.nr
@@ -1,5 +1,5 @@
 contract Main {
-    internal fn double(x: Field) -> pub Field { x * 2 }
+    fn double(x: Field) -> pub Field { x * 2 }
     fn triple(x: Field) -> pub Field { x * 3 }
     fn quadruple(x: Field) -> pub Field { double(double(x)) }
 }
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 503fd5afdd4..68660d62d23 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -116,10 +116,10 @@ pub(crate) fn run(
         };
     }
 
-    if test_report.iter().any(|(_, status)| !matches!(status, TestStatus::Fail { .. })) {
-        Ok(())
-    } else {
+    if test_report.iter().any(|(_, status)| matches!(status, TestStatus::Fail { .. })) {
         Err(CliError::Generic(String::new()))
+    } else {
+        Ok(())
     }
 }
 
diff --git a/tooling/nargo_fmt/tests/expected/contract.nr b/tooling/nargo_fmt/tests/expected/contract.nr
index a03b8774700..c5b19a686d2 100644
--- a/tooling/nargo_fmt/tests/expected/contract.nr
+++ b/tooling/nargo_fmt/tests/expected/contract.nr
@@ -8,8 +8,7 @@ contract Benchmarking {
     use dep::value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
 
     use dep::aztec::{
-        context::{Context},
-        note::{utils as note_utils, note_getter_options::NoteGetterOptions, note_header::NoteHeader},
+        context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
         log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
         types::address::{AztecAddress}
diff --git a/tooling/nargo_fmt/tests/input/contract.nr b/tooling/nargo_fmt/tests/input/contract.nr
index a03b8774700..c5b19a686d2 100644
--- a/tooling/nargo_fmt/tests/input/contract.nr
+++ b/tooling/nargo_fmt/tests/input/contract.nr
@@ -8,8 +8,7 @@ contract Benchmarking {
     use dep::value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
 
     use dep::aztec::{
-        context::{Context},
-        note::{utils as note_utils, note_getter_options::NoteGetterOptions, note_header::NoteHeader},
+        context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
         log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
         types::address::{AztecAddress}

From fe8f2776ccfde29209a2c3fc162311c99e4f59be Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 5 Mar 2024 13:49:54 -0500
Subject: [PATCH 039/416] feat: Sync from aztec-packages (#4483)

BEGIN_COMMIT_OVERRIDE
feat: Add init check by default to public fns
(https://github.com/AztecProtocol/aztec-packages/pull/4897)
feat: Enable public constructor functions
(https://github.com/AztecProtocol/aztec-packages/pull/4896)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .aztec-sync-commit                            |  2 +-
 acvm-repo/acvm/src/compiler/optimizers/mod.rs | 12 ++++----
 aztec_macros/src/lib.rs                       | 30 ++++---------------
 noir_stdlib/src/sha512.nr                     |  2 +-
 4 files changed, 14 insertions(+), 32 deletions(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 78e53d61647..6841c89b691 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-73d640a4a033f0c865d45da470ef40c1fb03a844
+7ff9b71d8d87fc93ae7dbd8ba63f5176b0cd17be
diff --git a/acvm-repo/acvm/src/compiler/optimizers/mod.rs b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
index 599bdabd420..04d3f99a408 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
@@ -1,6 +1,6 @@
 use acir::circuit::{Circuit, Opcode};
 
-mod constant_backpropagation;
+// mod constant_backpropagation;
 mod general;
 mod redundant_range;
 mod unused_memory;
@@ -9,7 +9,7 @@ pub(crate) use general::GeneralOptimizer;
 pub(crate) use redundant_range::RangeOptimizer;
 use tracing::info;
 
-use self::constant_backpropagation::ConstantBackpropagationOptimizer;
+// use self::constant_backpropagation::ConstantBackpropagationOptimizer;
 use self::unused_memory::UnusedMemoryOptimizer;
 
 use super::{transform_assert_messages, AcirTransformationMap};
@@ -58,16 +58,16 @@ pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
     let (acir, acir_opcode_positions) =
         memory_optimizer.remove_unused_memory_initializations(acir_opcode_positions);
 
-    let (acir, acir_opcode_positions) =
-        ConstantBackpropagationOptimizer::backpropagate_constants(acir, acir_opcode_positions);
+    // let (acir, acir_opcode_positions) =
+    // ConstantBackpropagationOptimizer::backpropagate_constants(acir, acir_opcode_positions);
 
     // Range optimization pass
     let range_optimizer = RangeOptimizer::new(acir);
     let (acir, acir_opcode_positions) =
         range_optimizer.replace_redundant_ranges(acir_opcode_positions);
 
-    let (acir, acir_opcode_positions) =
-        ConstantBackpropagationOptimizer::backpropagate_constants(acir, acir_opcode_positions);
+    // let (acir, acir_opcode_positions) =
+    // ConstantBackpropagationOptimizer::backpropagate_constants(acir, acir_opcode_positions);
 
     info!("Number of opcodes after: {}", acir.opcodes.len());
 
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index f860f2c465a..f9df3f10129 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -451,7 +451,6 @@ fn transform_module(
                 is_internal = true;
             } else if is_custom_attribute(&secondary_attribute, "aztec(public)") {
                 is_public = true;
-                insert_init_check = false;
             } else if is_custom_attribute(&secondary_attribute, "aztec(public-vm)") {
                 is_public_vm = true;
             }
@@ -673,15 +672,6 @@ fn transform_function(
 
     // Add initialization check
     if insert_init_check {
-        if ty == "Public" {
-            let error = AztecMacroError::UnsupportedAttributes {
-                span: func.def.name.span(),
-                secondary_message: Some(
-                    "public functions do not yet support initialization check".to_owned(),
-                ),
-            };
-            return Err(error);
-        }
         let init_check = create_init_check();
         func.def.body.0.insert(0, init_check);
     }
@@ -711,16 +701,7 @@ fn transform_function(
 
     // Before returning mark the contract as initialized
     if is_initializer {
-        if ty == "Public" {
-            let error = AztecMacroError::UnsupportedAttributes {
-                span: func.def.name.span(),
-                secondary_message: Some(
-                    "public functions cannot yet be used as initializers".to_owned(),
-                ),
-            };
-            return Err(error);
-        }
-        let mark_initialized = create_mark_as_initialized();
+        let mark_initialized = create_mark_as_initialized(ty);
         func.def.body.0.push(mark_initialized);
     }
 
@@ -1179,9 +1160,10 @@ fn create_init_check() -> Statement {
 /// ```noir
 /// mark_as_initialized(&mut context);
 /// ```
-fn create_mark_as_initialized() -> Statement {
+fn create_mark_as_initialized(ty: &str) -> Statement {
+    let name = if ty == "Public" { "mark_as_initialized_public" } else { "mark_as_initialized" };
     make_statement(StatementKind::Expression(call(
-        variable_path(chained_dep!("aztec", "initializer", "mark_as_initialized")),
+        variable_path(chained_dep!("aztec", "initializer", name)),
         vec![mutable_reference("context")],
     )))
 }
@@ -1373,13 +1355,13 @@ fn create_avm_context() -> Result<Statement, AztecMacroError> {
 /// Any primitive type that can be cast will be casted to a field and pushed to the context.
 fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
     let current_return_type = func.return_type().typ;
-    let last_statement = func.def.body.0.last();
+    let last_statement = func.def.body.0.last()?;
 
     // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
     // Doesn't need done until we have settled on a kernel size
     // TODO: support tuples here and in inputs -> convert into an issue
     // Check if the return type is an expression, if it is, we can handle it
-    match last_statement? {
+    match last_statement {
         Statement { kind: StatementKind::Expression(expression), .. } => {
             match current_return_type {
                 // Call serialize on structs, push the whole array, calling push_array
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index f3155dd7528..4dfe78308e2 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -136,7 +136,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
             msg_block[i as Field] = 0;
             i += 1;
         } else if i < 128 {
-            let mut len = 8 * msg.len(); // u128 unsupported
+            let mut len = 8 * msg.len();
             for j in 0..16 {
                 msg_block[127 - j] = len as u8;
                 len >>= 8;

From 761734e6cb3ff5911aa85d0cee96ad26092b4905 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 5 Mar 2024 21:12:58 +0000
Subject: [PATCH 040/416] feat: run tests in parallel in `nargo test`  (#4484)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This is a dirty hack to get tests running in parallel. To do this, we've
given up printing the test results in a stream as they're run but we
instead wait for all tests in a package to be run before we print them
out in one go.

This takes the noir-protocol-circuits test suite from taking 1:46s to
27s.

## Additional Context

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/lsp/src/requests/test_run.rs  |   2 +-
 tooling/nargo/src/ops/test.rs         |  14 +++-
 tooling/nargo_cli/src/cli/test_cmd.rs | 114 ++++++++++++++++++--------
 3 files changed, 92 insertions(+), 38 deletions(-)

diff --git a/tooling/lsp/src/requests/test_run.rs b/tooling/lsp/src/requests/test_run.rs
index 0b88d814265..1844a3d9bf0 100644
--- a/tooling/lsp/src/requests/test_run.rs
+++ b/tooling/lsp/src/requests/test_run.rs
@@ -84,7 +84,7 @@ fn on_test_run_request_inner(
             let test_result = run_test(
                 &state.solver,
                 &mut context,
-                test_function,
+                &test_function,
                 false,
                 None,
                 &CompileOptions::default(),
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 92c09ec889e..8ddcb5cf8d2 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -14,10 +14,16 @@ pub enum TestStatus {
     CompileError(FileDiagnostic),
 }
 
+impl TestStatus {
+    pub fn failed(&self) -> bool {
+        !matches!(self, TestStatus::Pass)
+    }
+}
+
 pub fn run_test<B: BlackBoxFunctionSolver>(
     blackbox_solver: &B,
     context: &mut Context,
-    test_function: TestFunction,
+    test_function: &TestFunction,
     show_output: bool,
     foreign_call_resolver_url: Option<&str>,
     config: &CompileOptions,
@@ -45,7 +51,7 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
 /// that a constraint was never satisfiable.
 /// An example of this is the program `assert(false)`
 /// In that case, we check if the test function should fail, and if so, we return `TestStatus::Pass`.
-fn test_status_program_compile_fail(err: CompileError, test_function: TestFunction) -> TestStatus {
+fn test_status_program_compile_fail(err: CompileError, test_function: &TestFunction) -> TestStatus {
     // The test has failed compilation, but it should never fail. Report error.
     if !test_function.should_fail() {
         return TestStatus::CompileError(err.into());
@@ -70,7 +76,7 @@ fn test_status_program_compile_fail(err: CompileError, test_function: TestFuncti
 /// We now check whether execution passed/failed and whether it should have
 /// passed/failed to determine the test status.
 fn test_status_program_compile_pass(
-    test_function: TestFunction,
+    test_function: &TestFunction,
     debug: DebugInfo,
     circuit_execution: Result<WitnessMap, NargoError>,
 ) -> TestStatus {
@@ -109,7 +115,7 @@ fn test_status_program_compile_pass(
 }
 
 fn check_expected_failure_message(
-    test_function: TestFunction,
+    test_function: &TestFunction,
     failed_assertion: Option<String>,
     error_diagnostic: Option<FileDiagnostic>,
 ) -> TestStatus {
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 68660d62d23..47face9943a 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -11,11 +11,14 @@ use nargo::{
     parse_all, prepare_package,
 };
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_driver::{file_manager_with_stdlib, CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
+use noirc_driver::{
+    check_crate, file_manager_with_stdlib, CompileOptions, NOIR_ARTIFACT_VERSION_STRING,
+};
 use noirc_frontend::{
     graph::CrateName,
     hir::{FunctionNameMatch, ParsedFiles},
 };
+use rayon::prelude::{IntoParallelIterator, ParallelIterator};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
 use crate::{backends::Backend, cli::check_cmd::check_crate_and_report_errors, errors::CliError};
@@ -82,15 +85,12 @@ pub(crate) fn run(
         None => FunctionNameMatch::Anything,
     };
 
-    let blackbox_solver = Bn254BlackBoxSolver::new();
-
     let test_reports: Vec<Vec<(String, TestStatus)>> = workspace
         .into_iter()
         .map(|package| {
-            run_tests(
+            run_tests::<Bn254BlackBoxSolver>(
                 &workspace_file_manager,
                 &parsed_files,
-                &blackbox_solver,
                 package,
                 pattern,
                 args.show_output,
@@ -116,24 +116,77 @@ pub(crate) fn run(
         };
     }
 
-    if test_report.iter().any(|(_, status)| matches!(status, TestStatus::Fail { .. })) {
+    if test_report.iter().any(|(_, status)| status.failed()) {
         Err(CliError::Generic(String::new()))
     } else {
         Ok(())
     }
 }
 
-#[allow(clippy::too_many_arguments)]
-fn run_tests<S: BlackBoxFunctionSolver>(
+fn run_tests<S: BlackBoxFunctionSolver + Default>(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
-    blackbox_solver: &S,
     package: &Package,
     fn_name: FunctionNameMatch,
     show_output: bool,
     foreign_call_resolver_url: Option<&str>,
     compile_options: &CompileOptions,
 ) -> Result<Vec<(String, TestStatus)>, CliError> {
+    let test_functions =
+        get_tests_in_package(file_manager, parsed_files, package, fn_name, compile_options)?;
+
+    let count_all = test_functions.len();
+
+    let plural = if count_all == 1 { "" } else { "s" };
+    println!("[{}] Running {count_all} test function{plural}", package.name);
+
+    let test_report: Vec<(String, TestStatus)> = test_functions
+        .into_par_iter()
+        .map(|test_name| {
+            // This is really hacky but we can't share `Context` or `S` across threads.
+            // We then need to construct a separate copy for each test.
+
+            let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
+            check_crate(
+                &mut context,
+                crate_id,
+                compile_options.deny_warnings,
+                compile_options.disable_macros,
+            )
+            .expect("Any errors should have occurred when collecting test functions");
+
+            let test_functions = context.get_all_test_functions_in_crate_matching(
+                &crate_id,
+                FunctionNameMatch::Exact(&test_name),
+            );
+            let (_, test_function) = test_functions.first().expect("Test function should exist");
+
+            let blackbox_solver = S::default();
+
+            let test_output = run_test(
+                &blackbox_solver,
+                &mut context,
+                test_function,
+                show_output,
+                foreign_call_resolver_url,
+                compile_options,
+            );
+
+            (test_name, test_output)
+        })
+        .collect();
+
+    display_test_report(file_manager, package, compile_options, &test_report)?;
+    Ok(test_report)
+}
+
+fn get_tests_in_package(
+    file_manager: &FileManager,
+    parsed_files: &ParsedFiles,
+    package: &Package,
+    fn_name: FunctionNameMatch,
+    compile_options: &CompileOptions,
+) -> Result<Vec<String>, CliError> {
     let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
     check_crate_and_report_errors(
         &mut context,
@@ -143,30 +196,27 @@ fn run_tests<S: BlackBoxFunctionSolver>(
         compile_options.silence_warnings,
     )?;
 
-    let test_functions = context.get_all_test_functions_in_crate_matching(&crate_id, fn_name);
-    let count_all = test_functions.len();
-
-    let plural = if count_all == 1 { "" } else { "s" };
-    println!("[{}] Running {count_all} test function{plural}", package.name);
+    Ok(context
+        .get_all_test_functions_in_crate_matching(&crate_id, fn_name)
+        .into_iter()
+        .map(|(test_name, _)| test_name)
+        .collect())
+}
 
+fn display_test_report(
+    file_manager: &FileManager,
+    package: &Package,
+    compile_options: &CompileOptions,
+    test_report: &[(String, TestStatus)],
+) -> Result<(), CliError> {
     let writer = StandardStream::stderr(ColorChoice::Always);
     let mut writer = writer.lock();
 
-    let mut test_report: Vec<(String, TestStatus)> = Vec::new();
-    for (test_name, test_function) in test_functions {
+    for (test_name, test_status) in test_report {
         write!(writer, "[{}] Testing {test_name}... ", package.name)
             .expect("Failed to write to stderr");
         writer.flush().expect("Failed to flush writer");
 
-        let test_status = run_test(
-            blackbox_solver,
-            &mut context,
-            test_function,
-            show_output,
-            foreign_call_resolver_url,
-            compile_options,
-        );
-
         match &test_status {
             TestStatus::Pass { .. } => {
                 writer
@@ -181,7 +231,7 @@ fn run_tests<S: BlackBoxFunctionSolver>(
                 writeln!(writer, "FAIL\n{message}\n").expect("Failed to write to stderr");
                 if let Some(diag) = error_diagnostic {
                     noirc_errors::reporter::report_all(
-                        context.file_manager.as_file_map(),
+                        file_manager.as_file_map(),
                         &[diag.clone()],
                         compile_options.deny_warnings,
                         compile_options.silence_warnings,
@@ -190,23 +240,21 @@ fn run_tests<S: BlackBoxFunctionSolver>(
             }
             TestStatus::CompileError(err) => {
                 noirc_errors::reporter::report_all(
-                    context.file_manager.as_file_map(),
+                    file_manager.as_file_map(),
                     &[err.clone()],
                     compile_options.deny_warnings,
                     compile_options.silence_warnings,
                 );
             }
         }
-
-        test_report.push((test_name, test_status));
-
         writer.reset().expect("Failed to reset writer");
     }
 
     write!(writer, "[{}] ", package.name).expect("Failed to write to stderr");
 
-    let count_failed =
-        test_report.iter().filter(|(_, status)| !matches!(status, TestStatus::Pass)).count();
+    let count_all = test_report.len();
+    let count_failed = test_report.iter().filter(|(_, status)| status.failed()).count();
+    let plural = if count_all == 1 { "" } else { "s" };
     if count_failed == 0 {
         writer.set_color(ColorSpec::new().set_fg(Some(Color::Green))).expect("Failed to set color");
         write!(writer, "{count_all} test{plural} passed").expect("Failed to write to stderr");
@@ -231,5 +279,5 @@ fn run_tests<S: BlackBoxFunctionSolver>(
         writer.reset().expect("Failed to reset writer");
     }
 
-    Ok(test_report)
+    Ok(())
 }

From 1ed9061d1f2e32603ece34653c0e6d224621e456 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 6 Mar 2024 13:50:22 +0000
Subject: [PATCH 041/416] chore: update cargo deny config (#4486)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

cargo deny is deprecating a bunch of its config file so this PR updates
to the new format.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 deny.toml | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/deny.toml b/deny.toml
index 72150f08a3c..578f8427263 100644
--- a/deny.toml
+++ b/deny.toml
@@ -2,11 +2,13 @@
 # More documentation for the advisories section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
 [advisories]
-vulnerability = "deny"
-unmaintained = "warn"
-unsound = "warn"
+version = 2
 yanked = "warn"
-notice = "warn"
+
+ignore = [
+    "RUSTSEC-2020-0168", # mach unmaintained
+    "RUSTSEC-2020-0016"  # net2 unmaintained
+]
 
 # This section is considered when running `cargo deny check bans`.
 # More documentation about the 'bans' section can be found here:
@@ -32,9 +34,8 @@ skip = []
 skip-tree = []
 
 [licenses]
-unlicensed = "deny"
+version = 2
 confidence-threshold = 0.9
-# copyleft = "deny"
 
 # List of explicitly allowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses

From 18e1fe228f9add11c6f33f889d62d69cf7fec450 Mon Sep 17 00:00:00 2001
From: Tom French <tom@tomfren.ch>
Date: Wed, 6 Mar 2024 14:00:31 +0000
Subject: [PATCH 042/416] chore: pull out separate function for compiling and
 running a test

---
 tooling/nargo_cli/src/cli/test_cmd.rs | 77 ++++++++++++++++-----------
 1 file changed, 47 insertions(+), 30 deletions(-)

diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 47face9943a..2828aaf01eb 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -5,10 +5,8 @@ use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 use fm::FileManager;
 use nargo::{
-    insert_all_files_for_workspace_into_file_manager,
-    ops::{run_test, TestStatus},
-    package::Package,
-    parse_all, prepare_package,
+    insert_all_files_for_workspace_into_file_manager, ops::TestStatus, package::Package, parse_all,
+    prepare_package,
 };
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{
@@ -18,7 +16,7 @@ use noirc_frontend::{
     graph::CrateName,
     hir::{FunctionNameMatch, ParsedFiles},
 };
-use rayon::prelude::{IntoParallelIterator, ParallelIterator};
+use rayon::prelude::{IntoParallelIterator, ParallelBridge, ParallelIterator};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
 use crate::{backends::Backend, cli::check_cmd::check_crate_and_report_errors, errors::CliError};
@@ -87,6 +85,7 @@ pub(crate) fn run(
 
     let test_reports: Vec<Vec<(String, TestStatus)>> = workspace
         .into_iter()
+        .par_bridge()
         .map(|package| {
             run_tests::<Bn254BlackBoxSolver>(
                 &workspace_file_manager,
@@ -143,36 +142,17 @@ fn run_tests<S: BlackBoxFunctionSolver + Default>(
     let test_report: Vec<(String, TestStatus)> = test_functions
         .into_par_iter()
         .map(|test_name| {
-            // This is really hacky but we can't share `Context` or `S` across threads.
-            // We then need to construct a separate copy for each test.
-
-            let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
-            check_crate(
-                &mut context,
-                crate_id,
-                compile_options.deny_warnings,
-                compile_options.disable_macros,
-            )
-            .expect("Any errors should have occurred when collecting test functions");
-
-            let test_functions = context.get_all_test_functions_in_crate_matching(
-                &crate_id,
-                FunctionNameMatch::Exact(&test_name),
-            );
-            let (_, test_function) = test_functions.first().expect("Test function should exist");
-
-            let blackbox_solver = S::default();
-
-            let test_output = run_test(
-                &blackbox_solver,
-                &mut context,
-                test_function,
+            let status = run_test::<S>(
+                file_manager,
+                parsed_files,
+                package,
+                &test_name,
                 show_output,
                 foreign_call_resolver_url,
                 compile_options,
             );
 
-            (test_name, test_output)
+            (test_name, status)
         })
         .collect();
 
@@ -180,6 +160,43 @@ fn run_tests<S: BlackBoxFunctionSolver + Default>(
     Ok(test_report)
 }
 
+fn run_test<S: BlackBoxFunctionSolver + Default>(
+    file_manager: &FileManager,
+    parsed_files: &ParsedFiles,
+    package: &Package,
+    fn_name: &str,
+    show_output: bool,
+    foreign_call_resolver_url: Option<&str>,
+    compile_options: &CompileOptions,
+) -> TestStatus {
+    // This is really hacky but we can't share `Context` or `S` across threads.
+    // We then need to construct a separate copy for each test.
+
+    let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
+    check_crate(
+        &mut context,
+        crate_id,
+        compile_options.deny_warnings,
+        compile_options.disable_macros,
+    )
+    .expect("Any errors should have occurred when collecting test functions");
+
+    let test_functions = context
+        .get_all_test_functions_in_crate_matching(&crate_id, FunctionNameMatch::Exact(fn_name));
+    let (_, test_function) = test_functions.first().expect("Test function should exist");
+
+    let blackbox_solver = S::default();
+
+    nargo::ops::run_test(
+        &blackbox_solver,
+        &mut context,
+        test_function,
+        show_output,
+        foreign_call_resolver_url,
+        compile_options,
+    )
+}
+
 fn get_tests_in_package(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,

From ea9a834ec9ddf6a23d8e0f28b1f7784f484eec05 Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Wed, 6 Mar 2024 14:22:15 +0000
Subject: [PATCH 043/416] chore: Move templated code for assert_message into
 the stdlib (#4475)

# Description

## Problem\*

We currently have a noirc_macros crate which checks for the stdlib and
inserts two functions into the stdlib. The motivation being that we did
not want users to be able to see these functions.

Introducing a new crate for this reason, does not seem to be worth it
since its ~7 lines of noir code.


## Solution\*

This PR removes the noirc_macros crate and copies the noir code that was
being pasted into the stdlib, directly into the stdlib

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 Cargo.lock                                    |  9 ---
 Cargo.toml                                    |  3 +-
 compiler/noirc_driver/Cargo.toml              |  1 -
 compiler/noirc_driver/src/lib.rs              |  7 +-
 .../src/hir/resolution/resolver.rs            |  8 +-
 noir_stdlib/src/internal.nr                   | 12 +++
 noir_stdlib/src/lib.nr                        |  1 +
 noirc_macros/Cargo.toml                       | 14 ----
 noirc_macros/src/lib.rs                       | 73 -------------------
 9 files changed, 22 insertions(+), 106 deletions(-)
 create mode 100644 noir_stdlib/src/internal.nr
 delete mode 100644 noirc_macros/Cargo.toml
 delete mode 100644 noirc_macros/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index b2b6f8037bb..18c1f7ad40e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2946,7 +2946,6 @@ dependencies = [
  "noirc_errors",
  "noirc_evaluator",
  "noirc_frontend",
- "noirc_macros",
  "rust-embed",
  "serde",
  "thiserror",
@@ -3012,14 +3011,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "noirc_macros"
-version = "0.24.0"
-dependencies = [
- "iter-extended",
- "noirc_frontend",
-]
-
 [[package]]
 name = "noirc_printable_type"
 version = "0.24.0"
diff --git a/Cargo.toml b/Cargo.toml
index 7d5da7b00d0..38f39137360 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,8 @@
 [workspace]
 
 members = [
-    # Macros crates for metaprogramming
+    # Aztec Macro crate for metaprogramming
     "aztec_macros",
-    "noirc_macros",
     # Compiler crates
     "compiler/noirc_evaluator",
     "compiler/noirc_frontend",
diff --git a/compiler/noirc_driver/Cargo.toml b/compiler/noirc_driver/Cargo.toml
index 681976735f3..a7fe0b4b610 100644
--- a/compiler/noirc_driver/Cargo.toml
+++ b/compiler/noirc_driver/Cargo.toml
@@ -26,4 +26,3 @@ tracing.workspace = true
 thiserror.workspace = true
 
 aztec_macros = { path = "../../aztec_macros" }
-noirc_macros = { path = "../../noirc_macros" }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 11f53cdb749..97fc66688e1 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -238,12 +238,9 @@ pub fn check_crate(
     disable_macros: bool,
 ) -> CompilationResult<()> {
     let macros: Vec<&dyn MacroProcessor> = if disable_macros {
-        vec![&noirc_macros::AssertMessageMacro as &dyn MacroProcessor]
+        vec![]
     } else {
-        vec![
-            &aztec_macros::AztecMacro as &dyn MacroProcessor,
-            &noirc_macros::AssertMessageMacro as &dyn MacroProcessor,
-        ]
+        vec![&aztec_macros::AztecMacro as &dyn MacroProcessor]
     };
 
     let mut errors = vec![];
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 7f9e48353a7..7789c06ca69 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1256,13 +1256,17 @@ impl<'a> Resolver<'a> {
         let is_in_stdlib = self.path_resolver.module_id().krate.is_stdlib();
         let assert_msg_call_path = if is_in_stdlib {
             ExpressionKind::Variable(Path {
-                segments: vec![Ident::from("resolve_assert_message")],
+                segments: vec![Ident::from("internal"), Ident::from("resolve_assert_message")],
                 kind: PathKind::Crate,
                 span,
             })
         } else {
             ExpressionKind::Variable(Path {
-                segments: vec![Ident::from("std"), Ident::from("resolve_assert_message")],
+                segments: vec![
+                    Ident::from("std"),
+                    Ident::from("internal"),
+                    Ident::from("resolve_assert_message"),
+                ],
                 kind: PathKind::Dep,
                 span,
             })
diff --git a/noir_stdlib/src/internal.nr b/noir_stdlib/src/internal.nr
new file mode 100644
index 00000000000..8d5c01dda7f
--- /dev/null
+++ b/noir_stdlib/src/internal.nr
@@ -0,0 +1,12 @@
+// This file contains functions which should only be used in calls injected by the Noir compiler.
+// These functions should not be called manually in user code.
+//
+// Changes to this file will not be considered breaking.
+
+#[oracle(assert_message)]
+unconstrained fn assert_message_oracle<T>(_input: T) {}
+unconstrained pub fn resolve_assert_message<T>(input: T, condition: bool) {
+    if !condition {
+        assert_message_oracle(input);
+    }
+}
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index ebde4b88858..90c04472066 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -26,6 +26,7 @@ mod default;
 mod prelude;
 mod uint128;
 mod bigint;
+mod internal;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
diff --git a/noirc_macros/Cargo.toml b/noirc_macros/Cargo.toml
deleted file mode 100644
index 699e6b01cae..00000000000
--- a/noirc_macros/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "noirc_macros"
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-noirc_frontend.workspace = true
-iter-extended.workspace = true
\ No newline at end of file
diff --git a/noirc_macros/src/lib.rs b/noirc_macros/src/lib.rs
deleted file mode 100644
index 9a916843200..00000000000
--- a/noirc_macros/src/lib.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use noirc_frontend::hir::def_collector::dc_crate::UnresolvedFunctions;
-use noirc_frontend::hir::def_collector::dc_crate::UnresolvedTraitImpl;
-use noirc_frontend::macros_api::parse_program;
-use noirc_frontend::macros_api::HirContext;
-use noirc_frontend::macros_api::SortedModule;
-use noirc_frontend::macros_api::{CrateId, FileId};
-use noirc_frontend::macros_api::{MacroError, MacroProcessor};
-
-pub struct AssertMessageMacro;
-
-impl MacroProcessor for AssertMessageMacro {
-    fn process_untyped_ast(
-        &self,
-        ast: SortedModule,
-        crate_id: &CrateId,
-        _context: &HirContext,
-    ) -> Result<SortedModule, (MacroError, FileId)> {
-        transform(ast, crate_id)
-    }
-
-    fn process_unresolved_traits_impls(
-        &self,
-        _crate_id: &CrateId,
-        _context: &mut HirContext,
-        _unresolved_traits_impls: &[UnresolvedTraitImpl],
-        _collected_functions: &mut Vec<UnresolvedFunctions>,
-    ) -> Result<(), (MacroError, FileId)> {
-        Ok(())
-    }
-
-    // This macro does not need to process any information after name resolution
-    fn process_typed_ast(
-        &self,
-        _crate_id: &CrateId,
-        _context: &mut HirContext,
-    ) -> Result<(), (MacroError, FileId)> {
-        Ok(())
-    }
-}
-
-fn transform(ast: SortedModule, crate_id: &CrateId) -> Result<SortedModule, (MacroError, FileId)> {
-    let ast = add_resolve_assert_message_funcs(ast, crate_id)?;
-
-    Ok(ast)
-}
-
-fn add_resolve_assert_message_funcs(
-    mut ast: SortedModule,
-    crate_id: &CrateId,
-) -> Result<SortedModule, (MacroError, FileId)> {
-    if !crate_id.is_stdlib() {
-        return Ok(ast);
-    }
-    let assert_message_oracles = "
-    #[oracle(assert_message)]
-    unconstrained fn assert_message_oracle<T>(_input: T) {}
-    unconstrained pub fn resolve_assert_message<T>(input: T, condition: bool) {
-        if !condition {
-            assert_message_oracle(input);
-        }
-    }";
-
-    let (assert_msg_funcs_ast, errors) = parse_program(assert_message_oracles);
-    assert_eq!(errors.len(), 0, "Failed to parse Noir macro code. This is either a bug in the compiler or the Noir macro code");
-
-    let assert_msg_funcs_ast = assert_msg_funcs_ast.into_sorted();
-
-    for func in assert_msg_funcs_ast.functions {
-        ast.functions.push(func)
-    }
-
-    Ok(ast)
-}

From 33c1ef70e7859fdee7babfb5d38191f53e73a0df Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 7 Mar 2024 10:19:50 +0100
Subject: [PATCH 044/416] fix: iterative flattening pass (#4492)

# Description

## Problem\*

Resolves #4449

## Summary\*

The issue is fixed by implementing an iterative version of the
flattening pass.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../src/ssa/opt/flatten_cfg.rs                | 543 ++++++++++--------
 1 file changed, 312 insertions(+), 231 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index 943a57c1bc0..46f1e7a2765 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -199,22 +199,47 @@ struct Context<'f> {
     /// found, the top of this conditions stack is popped since we are no longer under that
     /// condition. If we are under multiple conditions (a nested if), the topmost condition is
     /// the most recent condition combined with all previous conditions via `And` instructions.
-    conditions: Vec<(BasicBlockId, ValueId)>,
+    condition_stack: Vec<ConditionalContext>,
 
     /// Maps SSA array values with a slice type to their size.
     /// This is maintained by appropriate calls to the `SliceCapacityTracker` and is used by the `ValueMerger`.
     slice_sizes: HashMap<ValueId, usize>,
+
+    /// Stack of block arguments
+    /// When processing a block, we pop this stack to get its arguments
+    /// and at the end we push the arguments for his successor
+    arguments_stack: Vec<Vec<ValueId>>,
 }
 
+#[derive(Clone)]
 pub(crate) struct Store {
     old_value: ValueId,
     new_value: ValueId,
 }
 
-struct Branch {
-    condition: ValueId,
+#[derive(Clone)]
+struct ConditionalBranch {
+    // Contains the last processed block during the processing of the branch.
     last_block: BasicBlockId,
+    // The unresolved condition of the branch
+    old_condition: ValueId,
+    // The condition of the branch
+    condition: ValueId,
+    // The store values accumulated when processing the branch
     store_values: HashMap<ValueId, Store>,
+    // The allocations accumulated when processing the branch
+    local_allocations: HashSet<ValueId>,
+}
+
+struct ConditionalContext {
+    // Condition from the conditional statement
+    condition: ValueId,
+    // Block containing the conditional statement
+    entry_block: BasicBlockId,
+    // First block of the then branch
+    then_branch: ConditionalBranch,
+    // First block of the else branch
+    else_branch: Option<ConditionalBranch>,
 }
 
 fn flatten_function_cfg(function: &mut Function) {
@@ -233,90 +258,117 @@ fn flatten_function_cfg(function: &mut Function) {
         store_values: HashMap::default(),
         local_allocations: HashSet::new(),
         branch_ends,
-        conditions: Vec::new(),
         slice_sizes: HashMap::default(),
+        condition_stack: Vec::new(),
+        arguments_stack: Vec::new(),
     };
     context.flatten();
 }
 
 impl<'f> Context<'f> {
     fn flatten(&mut self) {
-        // Start with following the terminator of the entry block since we don't
-        // need to flatten the entry block into itself.
-        self.handle_terminator(self.inserter.function.entry_block());
+        // Flatten the CFG by inlining all instructions from the queued blocks
+        // until all blocks have been flattened.
+        // We follow the terminator of each block to determine which blocks to
+        // process next
+        let mut queue = vec![self.inserter.function.entry_block()];
+        while let Some(block) = queue.pop() {
+            self.inline_block(block);
+            let to_process = self.handle_terminator(block, &queue);
+            for incoming_block in to_process {
+                if !queue.contains(&incoming_block) {
+                    queue.push(incoming_block);
+                }
+            }
+        }
     }
 
-    /// Check the terminator of the given block and recursively inline any blocks reachable from
-    /// it. Since each block from a jmpif terminator is inlined successively, we must handle
-    /// instructions with side effects like constrain and store specially to preserve correctness.
-    /// For these instructions we must keep track of what the current condition is and modify
-    /// the instructions according to the module-level comment at the top of this file. Note that
-    /// the current condition is all the jmpif conditions required to reach the current block,
-    /// combined via `And` instructions.
-    ///
-    /// Returns the last block to be inlined. This is either the return block of the function or,
-    /// if self.conditions is not empty, the end block of the most recent condition.
-    fn handle_terminator(&mut self, block: BasicBlockId) -> BasicBlockId {
-        // As we recursively flatten inner blocks, we need to track the slice information
-        // for the outer block before we start recursively inlining
-        let outer_block_instructions = self.inserter.function.dfg[block].instructions();
-        let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-        for instruction in outer_block_instructions {
-            let results = self.inserter.function.dfg.instruction_results(*instruction);
-            let instruction = &self.inserter.function.dfg[*instruction];
+    /// Returns the updated condition so that
+    /// it is 'AND-ed' with the previous condition (if any)
+    fn link_condition(&mut self, condition: ValueId) -> ValueId {
+        // Retrieve the previous condition
+        if let Some(context) = self.condition_stack.last() {
+            let previous_branch = context.else_branch.as_ref().unwrap_or(&context.then_branch);
+            let and = Instruction::binary(BinaryOp::And, previous_branch.condition, condition);
+            self.insert_instruction(and, CallStack::new())
+        } else {
+            condition
+        }
+    }
+
+    /// Returns the current condition
+    fn get_last_condition(&self) -> Option<ValueId> {
+        self.condition_stack.last().map(|context| match &context.else_branch {
+            Some(else_branch) => else_branch.condition,
+            None => context.then_branch.condition,
+        })
+    }
+
+    // Inline all instructions from the given block into the entry block, and track slice capacities
+    fn inline_block(&mut self, block: BasicBlockId) {
+        if self.inserter.function.entry_block() == block {
+            // we do not inline the entry block into itself
+            // for the outer block before we start inlining
+            let outer_block_instructions = self.inserter.function.dfg[block].instructions();
+            let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
+            for instruction in outer_block_instructions {
+                let results = self.inserter.function.dfg.instruction_results(*instruction);
+                let instruction = &self.inserter.function.dfg[*instruction];
+                capacity_tracker.collect_slice_information(
+                    instruction,
+                    &mut self.slice_sizes,
+                    results.to_vec(),
+                );
+            }
+
+            return;
+        }
+
+        let arguments = self.arguments_stack.pop().unwrap();
+        self.inserter.remember_block_params(block, &arguments);
+
+        // If this is not a separate variable, clippy gets confused and says the to_vec is
+        // unnecessary, when removing it actually causes an aliasing/mutability error.
+        let instructions = self.inserter.function.dfg[block].instructions().to_vec();
+        for instruction in instructions.iter() {
+            let results = self.push_instruction(*instruction);
+            let (instruction, _) = self.inserter.map_instruction(*instruction);
+            let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
             capacity_tracker.collect_slice_information(
-                instruction,
+                &instruction,
                 &mut self.slice_sizes,
-                results.to_vec(),
+                results,
             );
         }
+    }
 
-        match self.inserter.function.dfg[block].unwrap_terminator() {
+    /// Returns the list of blocks that need to be processed after the given block
+    /// For a normal block, it would be its successor
+    /// For blocks related to a conditional statement, we ensure to process
+    /// the 'then-branch', then the 'else-branch' (if it exists), and finally the end block
+    fn handle_terminator(
+        &mut self,
+        block: BasicBlockId,
+        work_list: &[BasicBlockId],
+    ) -> Vec<BasicBlockId> {
+        let terminator = self.inserter.function.dfg[block].unwrap_terminator().clone();
+        match &terminator {
             TerminatorInstruction::JmpIf { condition, then_destination, else_destination } => {
-                let old_condition = *condition;
-                let then_block = *then_destination;
-                let else_block = *else_destination;
-                let then_condition = self.inserter.resolve(old_condition);
-
-                let one = FieldElement::one();
-                let then_branch =
-                    self.inline_branch(block, then_block, old_condition, then_condition, one);
-
-                let else_condition =
-                    self.insert_instruction(Instruction::Not(then_condition), CallStack::new());
-                let zero = FieldElement::zero();
-
-                // Make sure the else branch sees the previous values of each store
-                // rather than any values created in the 'then' branch.
-                self.undo_stores_in_then_branch(&then_branch);
-
-                let else_branch =
-                    self.inline_branch(block, else_block, old_condition, else_condition, zero);
-
-                // We must remember to reset whether side effects are enabled when both branches
-                // end, in addition to resetting the value of old_condition since it is set to
-                // known to be true/false within the then/else branch respectively.
-                self.insert_current_side_effects_enabled();
-
-                // We must map back to `then_condition` here. Mapping `old_condition` to itself would
-                // lose any previous mappings.
-                self.inserter.map_value(old_condition, then_condition);
-
-                // While there is a condition on the stack we don't compile outside the condition
-                // until it is popped. This ensures we inline the full then and else branches
-                // before continuing from the end of the conditional here where they can be merged properly.
-                let end = self.branch_ends[&block];
-                self.inline_branch_end(end, then_branch, else_branch)
+                self.arguments_stack.push(vec![]);
+                self.if_start(condition, then_destination, else_destination, &block)
             }
             TerminatorInstruction::Jmp { destination, arguments, call_stack: _ } => {
-                if let Some((end_block, _)) = self.conditions.last() {
-                    if destination == end_block {
-                        return block;
+                let arguments = vecmap(arguments.clone(), |value| self.inserter.resolve(value));
+                self.arguments_stack.push(arguments);
+                if work_list.contains(destination) {
+                    if work_list.last() == Some(destination) {
+                        self.else_stop(&block)
+                    } else {
+                        self.then_stop(&block)
                     }
+                } else {
+                    vec![*destination]
                 }
-                let destination = *destination;
-                let arguments = vecmap(arguments.clone(), |value| self.inserter.resolve(value));
-                self.inline_block(destination, &arguments)
             }
             TerminatorInstruction::Return { return_values, call_stack } => {
                 let call_stack = call_stack.clone();
@@ -326,133 +378,133 @@ impl<'f> Context<'f> {
                 let entry = self.inserter.function.entry_block();
 
                 self.inserter.function.dfg.set_block_terminator(entry, new_return);
-                block
+                vec![]
             }
         }
     }
 
-    /// Push a condition to the stack of conditions.
-    ///
-    /// This condition should be present while we're inlining each block reachable from the 'then'
-    /// branch of a jmpif instruction, until the branches eventually join back together. Likewise,
-    /// !condition should be present while we're inlining each block reachable from the 'else'
-    /// branch of a jmpif instruction until the join block.
-    fn push_condition(&mut self, start_block: BasicBlockId, condition: ValueId) {
-        let end_block = self.branch_ends[&start_block];
-
-        if let Some((_, previous_condition)) = self.conditions.last() {
-            let and = Instruction::binary(BinaryOp::And, *previous_condition, condition);
-            let new_condition = self.insert_instruction(and, CallStack::new());
-            self.conditions.push((end_block, new_condition));
-        } else {
-            self.conditions.push((end_block, condition));
+    /// Process a conditional statement
+    fn if_start(
+        &mut self,
+        condition: &ValueId,
+        then_destination: &BasicBlockId,
+        else_destination: &BasicBlockId,
+        if_entry: &BasicBlockId,
+    ) -> Vec<BasicBlockId> {
+        // manage conditions
+        let old_condition = *condition;
+        let then_condition = self.inserter.resolve(old_condition);
+
+        let one = FieldElement::one();
+        let old_stores = std::mem::take(&mut self.store_values);
+        let old_allocations = std::mem::take(&mut self.local_allocations);
+        let branch = ConditionalBranch {
+            old_condition,
+            condition: self.link_condition(then_condition),
+            store_values: old_stores,
+            local_allocations: old_allocations,
+            last_block: *then_destination,
+        };
+        let cond_context = ConditionalContext {
+            condition: then_condition,
+            entry_block: *if_entry,
+            then_branch: branch,
+            else_branch: None,
+        };
+        self.condition_stack.push(cond_context);
+        self.insert_current_side_effects_enabled();
+        // Optimization: within the then branch we know the condition to be true, so replace
+        // any references of it within this branch with true. Likewise, do the same with false
+        // with the else branch. We must be careful not to replace the condition if it is a
+        // known constant, otherwise we can end up setting 1 = 0 or vice-versa.
+        if self.inserter.function.dfg.get_numeric_constant(old_condition).is_none() {
+            let known_value = self.inserter.function.dfg.make_constant(one, Type::bool());
+
+            self.inserter.map_value(old_condition, known_value);
         }
+        vec![self.branch_ends[if_entry], *else_destination, *then_destination]
     }
 
-    /// Insert a new instruction into the function's entry block.
-    /// Unlike push_instruction, this function will not map any ValueIds.
-    /// within the given instruction, nor will it modify self.values in any way.
-    fn insert_instruction(&mut self, instruction: Instruction, call_stack: CallStack) -> ValueId {
-        let block = self.inserter.function.entry_block();
-        self.inserter
-            .function
-            .dfg
-            .insert_instruction_and_results(instruction, block, None, call_stack)
-            .first()
+    /// Switch context to the 'else-branch'
+    fn then_stop(&mut self, block: &BasicBlockId) -> Vec<BasicBlockId> {
+        let mut cond_context = self.condition_stack.pop().unwrap();
+        cond_context.then_branch.last_block = *block;
+
+        let else_condition =
+            self.insert_instruction(Instruction::Not(cond_context.condition), CallStack::new());
+        let else_condition = self.link_condition(else_condition);
+
+        let zero = FieldElement::zero();
+        // Make sure the else branch sees the previous values of each store
+        // rather than any values created in the 'then' branch.
+        let old_stores = std::mem::take(&mut cond_context.then_branch.store_values);
+        cond_context.then_branch.store_values = std::mem::take(&mut self.store_values);
+        self.undo_stores_in_then_branch(&cond_context.then_branch.store_values);
+
+        let old_allocations = std::mem::take(&mut self.local_allocations);
+        let else_branch = ConditionalBranch {
+            old_condition: cond_context.then_branch.old_condition,
+            condition: else_condition,
+            store_values: old_stores,
+            local_allocations: old_allocations,
+            last_block: *block,
+        };
+        let old_condition = else_branch.old_condition;
+        cond_context.then_branch.local_allocations.clear();
+        cond_context.else_branch = Some(else_branch);
+        self.condition_stack.push(cond_context);
+
+        self.insert_current_side_effects_enabled();
+        // Optimization: within the then branch we know the condition to be true, so replace
+        // any references of it within this branch with true. Likewise, do the same with false
+        // with the else branch. We must be careful not to replace the condition if it is a
+        // known constant, otherwise we can end up setting 1 = 0 or vice-versa.
+        if self.inserter.function.dfg.get_numeric_constant(old_condition).is_none() {
+            let known_value = self.inserter.function.dfg.make_constant(zero, Type::bool());
+
+            self.inserter.map_value(old_condition, known_value);
+        }
+        assert_eq!(self.cfg.successors(*block).len(), 1);
+        vec![self.cfg.successors(*block).next().unwrap()]
     }
 
-    /// Inserts a new instruction into the function's entry block, using the given
-    /// control type variables to specify result types if needed.
-    /// Unlike push_instruction, this function will not map any ValueIds.
-    /// within the given instruction, nor will it modify self.values in any way.
-    fn insert_instruction_with_typevars(
-        &mut self,
-        instruction: Instruction,
-        ctrl_typevars: Option<Vec<Type>>,
-    ) -> InsertInstructionResult {
-        let block = self.inserter.function.entry_block();
-        self.inserter.function.dfg.insert_instruction_and_results(
-            instruction,
-            block,
-            ctrl_typevars,
-            CallStack::new(),
-        )
-    }
+    /// Process the 'exit' block of a conditional statement
+    fn else_stop(&mut self, block: &BasicBlockId) -> Vec<BasicBlockId> {
+        let mut cond_context = self.condition_stack.pop().unwrap();
+        if cond_context.else_branch.is_none() {
+            // then_stop() has not been called, this means that the conditional statement has no else branch
+            // so we simply do the then_stop() now
+            self.condition_stack.push(cond_context);
+            self.then_stop(block);
+            cond_context = self.condition_stack.pop().unwrap();
+        }
 
-    /// Checks the branch condition on the top of the stack and uses it to build and insert an
-    /// `EnableSideEffects` instruction into the entry block.
-    ///
-    /// If the stack is empty, a "true" u1 constant is taken to be the active condition. This is
-    /// necessary for re-enabling side-effects when re-emerging to a branch depth of 0.
-    fn insert_current_side_effects_enabled(&mut self) {
-        let condition = match self.conditions.last() {
-            Some((_, cond)) => *cond,
-            None => {
-                self.inserter.function.dfg.make_constant(FieldElement::one(), Type::unsigned(1))
-            }
-        };
-        let enable_side_effects = Instruction::EnableSideEffects { condition };
-        self.insert_instruction_with_typevars(enable_side_effects, None);
-    }
+        let mut else_branch = cond_context.else_branch.unwrap();
+        let stores_in_branch = std::mem::replace(&mut self.store_values, else_branch.store_values);
+        self.local_allocations = std::mem::take(&mut else_branch.local_allocations);
+        else_branch.last_block = *block;
+        else_branch.store_values = stores_in_branch;
+        cond_context.else_branch = Some(else_branch);
 
-    /// Inline one branch of a jmpif instruction.
-    ///
-    /// This will continue inlining recursively until the next end block is reached where each branch
-    /// of the jmpif instruction is joined back into a single block.
-    ///
-    /// Within a branch of a jmpif instruction, we can assume the condition of the jmpif to be
-    /// always true or false, depending on which branch we're in.
-    ///
-    /// Returns the ending block / join block of this branch.
-    fn inline_branch(
-        &mut self,
-        jmpif_block: BasicBlockId,
-        destination: BasicBlockId,
-        old_condition: ValueId,
-        new_condition: ValueId,
-        condition_value: FieldElement,
-    ) -> Branch {
-        if destination == self.branch_ends[&jmpif_block] {
-            // If the branch destination is the same as the end of the branch, this must be the
-            // 'else' case of an if with no else - so there is no else branch.
-            Branch {
-                condition: new_condition,
-                // The last block here is somewhat arbitrary. It only matters that it has no Jmp
-                // args that will be merged by inline_branch_end. Since jmpifs don't have
-                // block arguments, it is safe to use the jmpif block here.
-                last_block: jmpif_block,
-                store_values: HashMap::default(),
-            }
-        } else {
-            self.push_condition(jmpif_block, new_condition);
-            self.insert_current_side_effects_enabled();
-            let old_stores = std::mem::take(&mut self.store_values);
-            let old_allocations = std::mem::take(&mut self.local_allocations);
-
-            // Optimization: within the then branch we know the condition to be true, so replace
-            // any references of it within this branch with true. Likewise, do the same with false
-            // with the else branch. We must be careful not to replace the condition if it is a
-            // known constant, otherwise we can end up setting 1 = 0 or vice-versa.
-            if self.inserter.function.dfg.get_numeric_constant(old_condition).is_none() {
-                let known_value =
-                    self.inserter.function.dfg.make_constant(condition_value, Type::bool());
-
-                self.inserter.map_value(old_condition, known_value);
-            }
+        // We must remember to reset whether side effects are enabled when both branches
+        // end, in addition to resetting the value of old_condition since it is set to
+        // known to be true/false within the then/else branch respectively.
+        self.insert_current_side_effects_enabled();
 
-            let final_block = self.inline_block(destination, &[]);
+        // We must map back to `then_condition` here. Mapping `old_condition` to itself would
+        // lose any previous mappings.
+        self.inserter
+            .map_value(cond_context.then_branch.old_condition, cond_context.then_branch.condition);
 
-            self.conditions.pop();
+        // While there is a condition on the stack we don't compile outside the condition
+        // until it is popped. This ensures we inline the full then and else branches
+        // before continuing from the end of the conditional here where they can be merged properly.
+        let end = self.branch_ends[&cond_context.entry_block];
 
-            let stores_in_branch = std::mem::replace(&mut self.store_values, old_stores);
-            self.local_allocations = old_allocations;
+        // Merge arguments and stores from the else/end branches
+        self.inline_branch_end(end, cond_context);
 
-            Branch {
-                condition: new_condition,
-                last_block: final_block,
-                store_values: stores_in_branch,
-            }
-        }
+        vec![self.cfg.successors(*block).next().unwrap()]
     }
 
     /// Inline the ending block of a branch, the point where all blocks from a jmpif instruction
@@ -467,15 +519,17 @@ impl<'f> Context<'f> {
     fn inline_branch_end(
         &mut self,
         destination: BasicBlockId,
-        then_branch: Branch,
-        else_branch: Branch,
+        cond_context: ConditionalContext,
     ) -> BasicBlockId {
         assert_eq!(self.cfg.predecessors(destination).len(), 2);
+        let last_then = cond_context.then_branch.last_block;
+        let mut else_args = Vec::new();
+        if cond_context.else_branch.is_some() {
+            let last_else = cond_context.else_branch.clone().unwrap().last_block;
+            else_args = self.inserter.function.dfg[last_else].terminator_arguments().to_vec();
+        }
 
-        let then_args =
-            self.inserter.function.dfg[then_branch.last_block].terminator_arguments().to_vec();
-        let else_args =
-            self.inserter.function.dfg[else_branch.last_block].terminator_arguments().to_vec();
+        let then_args = self.inserter.function.dfg[last_then].terminator_arguments().to_vec();
 
         let params = self.inserter.function.dfg.block_parameters(destination);
         assert_eq!(params.len(), then_args.len());
@@ -500,17 +554,64 @@ impl<'f> Context<'f> {
         // Cannot include this in the previous vecmap since it requires exclusive access to self
         let args = vecmap(args, |(then_arg, else_arg)| {
             value_merger.merge_values(
-                then_branch.condition,
-                else_branch.condition,
+                cond_context.then_branch.condition,
+                cond_context.else_branch.clone().unwrap().condition,
                 then_arg,
                 else_arg,
             )
         });
 
-        self.merge_stores(then_branch, else_branch);
+        self.merge_stores(cond_context.then_branch, cond_context.else_branch);
+        self.arguments_stack.pop();
+        self.arguments_stack.pop();
+        self.arguments_stack.push(args);
+        destination
+    }
 
-        // insert merge instruction
-        self.inline_block(destination, &args)
+    /// Insert a new instruction into the function's entry block.
+    /// Unlike push_instruction, this function will not map any ValueIds.
+    /// within the given instruction, nor will it modify self.values in any way.
+    fn insert_instruction(&mut self, instruction: Instruction, call_stack: CallStack) -> ValueId {
+        let block = self.inserter.function.entry_block();
+        self.inserter
+            .function
+            .dfg
+            .insert_instruction_and_results(instruction, block, None, call_stack)
+            .first()
+    }
+
+    /// Inserts a new instruction into the function's entry block, using the given
+    /// control type variables to specify result types if needed.
+    /// Unlike push_instruction, this function will not map any ValueIds.
+    /// within the given instruction, nor will it modify self.values in any way.
+    fn insert_instruction_with_typevars(
+        &mut self,
+        instruction: Instruction,
+        ctrl_typevars: Option<Vec<Type>>,
+    ) -> InsertInstructionResult {
+        let block = self.inserter.function.entry_block();
+        self.inserter.function.dfg.insert_instruction_and_results(
+            instruction,
+            block,
+            ctrl_typevars,
+            CallStack::new(),
+        )
+    }
+
+    /// Checks the branch condition on the top of the stack and uses it to build and insert an
+    /// `EnableSideEffects` instruction into the entry block.
+    ///
+    /// If the stack is empty, a "true" u1 constant is taken to be the active condition. This is
+    /// necessary for re-enabling side-effects when re-emerging to a branch depth of 0.
+    fn insert_current_side_effects_enabled(&mut self) {
+        let condition = match self.get_last_condition() {
+            Some(cond) => cond,
+            None => {
+                self.inserter.function.dfg.make_constant(FieldElement::one(), Type::unsigned(1))
+            }
+        };
+        let enable_side_effects = Instruction::EnableSideEffects { condition };
+        self.insert_instruction_with_typevars(enable_side_effects, None);
     }
 
     /// Merge any store instructions found in each branch.
@@ -518,7 +619,11 @@ impl<'f> Context<'f> {
     /// This function relies on the 'then' branch being merged before the 'else' branch of a jmpif
     /// instruction. If this ordering is changed, the ordering that store values are merged within
     /// this function also needs to be changed to reflect that.
-    fn merge_stores(&mut self, then_branch: Branch, else_branch: Branch) {
+    fn merge_stores(
+        &mut self,
+        then_branch: ConditionalBranch,
+        else_branch: Option<ConditionalBranch>,
+    ) {
         // Address -> (then_value, else_value, value_before_the_if)
         let mut new_map = BTreeMap::new();
 
@@ -526,11 +631,13 @@ impl<'f> Context<'f> {
             new_map.insert(address, (store.new_value, store.old_value, store.old_value));
         }
 
-        for (address, store) in else_branch.store_values {
-            if let Some(entry) = new_map.get_mut(&address) {
-                entry.1 = store.new_value;
-            } else {
-                new_map.insert(address, (store.old_value, store.new_value, store.old_value));
+        if else_branch.is_some() {
+            for (address, store) in else_branch.clone().unwrap().store_values {
+                if let Some(entry) = new_map.get_mut(&address) {
+                    entry.1 = store.new_value;
+                } else {
+                    new_map.insert(address, (store.old_value, store.new_value, store.old_value));
+                }
             }
         }
 
@@ -544,8 +651,11 @@ impl<'f> Context<'f> {
         }
 
         let then_condition = then_branch.condition;
-        let else_condition = else_branch.condition;
-
+        let else_condition = if let Some(branch) = else_branch {
+            branch.condition
+        } else {
+            self.inserter.function.dfg.make_constant(FieldElement::zero(), Type::bool())
+        };
         let block = self.inserter.function.entry_block();
 
         let mut value_merger =
@@ -607,35 +717,6 @@ impl<'f> Context<'f> {
         }
     }
 
-    /// Inline all instructions from the given destination block into the entry block.
-    /// Afterwards, check the block's terminator and continue inlining recursively.
-    ///
-    /// Returns the final block that was inlined.
-    ///
-    /// Expects that the `arguments` given are already translated via self.inserter.resolve.
-    /// If they are not, it is possible some values which no longer exist, such as block
-    /// parameters, will be kept in the program.
-    fn inline_block(&mut self, destination: BasicBlockId, arguments: &[ValueId]) -> BasicBlockId {
-        self.inserter.remember_block_params(destination, arguments);
-
-        // If this is not a separate variable, clippy gets confused and says the to_vec is
-        // unnecessary, when removing it actually causes an aliasing/mutability error.
-        let instructions = self.inserter.function.dfg[destination].instructions().to_vec();
-
-        for instruction in instructions.iter() {
-            let results = self.push_instruction(*instruction);
-            let (instruction, _) = self.inserter.map_instruction(*instruction);
-            let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-            capacity_tracker.collect_slice_information(
-                &instruction,
-                &mut self.slice_sizes,
-                results,
-            );
-        }
-
-        self.handle_terminator(destination)
-    }
-
     /// Push the given instruction to the end of the entry block of the current function.
     ///
     /// Note that each ValueId of the instruction will be mapped via self.inserter.resolve.
@@ -666,7 +747,7 @@ impl<'f> Context<'f> {
         instruction: Instruction,
         call_stack: CallStack,
     ) -> Instruction {
-        if let Some((_, condition)) = self.conditions.last().copied() {
+        if let Some(condition) = self.get_last_condition() {
             match instruction {
                 Instruction::Constrain(lhs, rhs, message) => {
                     // Replace constraint `lhs == rhs` with `condition * lhs == condition * rhs`.
@@ -741,8 +822,8 @@ impl<'f> Context<'f> {
         }
     }
 
-    fn undo_stores_in_then_branch(&mut self, then_branch: &Branch) {
-        for (address, store) in &then_branch.store_values {
+    fn undo_stores_in_then_branch(&mut self, store_values: &HashMap<ValueId, Store>) {
+        for (address, store) in store_values {
             let address = *address;
             let value = store.old_value;
             self.insert_instruction_with_typevars(Instruction::Store { address, value }, None);

From 1d653704715bf9999eb6a40ed7500e752e2c73b7 Mon Sep 17 00:00:00 2001
From: Gregorio Juliana <gregojquiros@gmail.com>
Date: Thu, 7 Mar 2024 12:34:12 +0100
Subject: [PATCH 045/416] fix: handling of gh deps in noir_wasm (#4499)

# Description

Github deps are directly added to the file manager, which causes them to
be missing the absolute path to the source file and only include the
extraction directory relative to the fm root directory. This caused the
path to the file to be formatted in an unexpected way and the compiler
to panic.

Resolves: https://github.com/noir-lang/noir/issues/4355

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/wasm/src/noir/package.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/wasm/src/noir/package.ts b/compiler/wasm/src/noir/package.ts
index 81178e6ae96..2856798273a 100644
--- a/compiler/wasm/src/noir/package.ts
+++ b/compiler/wasm/src/noir/package.ts
@@ -105,7 +105,12 @@ export class Package {
       handles
         .filter((handle) => SOURCE_EXTENSIONS.find((ext) => handle.endsWith(ext)))
         .map(async (file) => {
-          const suffix = file.replace(this.#srcPath, '');
+          // Github deps are directly added to the file manager, which causes them to be missing the absolute path to the source file
+          // and only include the extraction directory relative to the fm root directory
+          // This regexp ensures we remove the "real" source path for all dependencies, providing the compiler with what it expects for each source file:
+          // <absoluteSourcePath> -> <sourceAsString> for bin/contract packages
+          // <depAlias/relativePathToSource> -> <sourceAsString> for libs
+          const suffix = file.replace(new RegExp(`.*${this.#srcPath}`), '');
           return {
             path: this.getType() === 'lib' ? `${alias ? alias : this.#config.package.name}${suffix}` : file,
             source: (await fm.readFile(file, 'utf-8')).toString(),

From 2de8fbf3f21aa2e374ac75075fbed711ae502a97 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 7 Mar 2024 14:49:08 +0000
Subject: [PATCH 046/416] chore: bump bb to 0.26.3 (#4488)

# Description

## Problem\*

Resolves #4468

## Summary\*

Throwing this up here so we're ready for when the artifacts are finally
published on GH.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/bb_abstraction_leaks/build.rs             |  2 +-
 tooling/noir_js_backend_barretenberg/package.json |  2 +-
 yarn.lock                                         | 10 +++++-----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index f9effd5d991..0bd2b1c076a 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.24.0";
+const VERSION: &str = "0.26.3";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 28c3609fd14..06c034725e3 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.24.0",
+    "@aztec/bb.js": "0.26.3",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index f5f3a29f08a..49485193532 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.24.0":
-  version: 0.24.0
-  resolution: "@aztec/bb.js@npm:0.24.0"
+"@aztec/bb.js@npm:0.26.3":
+  version: 0.26.3
+  resolution: "@aztec/bb.js@npm:0.26.3"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: a086dabf30084cfa526e512148b9c02f0a0770dcc19b7dca4af9a3e98612b716acc7eaac6b52c0f12d985932e866d1cb9e534ded6ac9d747f3dd021afe25de27
+  checksum: 74c2b7ef5405f56472cf7c41d1c13261df07b1d5019e3ede9b63d218378e0fb73ccf5c52f1cc524505efad5799b347b497349d7c9b6fe82286014b1574f12309
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.24.0
+    "@aztec/bb.js": 0.26.3
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 99c4d27242c27eea9237ab042d85f42de484ac72 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 7 Mar 2024 16:48:23 +0000
Subject: [PATCH 047/416] chore: pass macro processors by reference (#4501)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're cloning unnecessarily here as we can just pass the processors by
reference.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Jake Fecher <jfecher11@gmail.com>
---
 compiler/noirc_driver/src/lib.rs                     |  7 ++-----
 .../noirc_frontend/src/hir/def_collector/dc_crate.rs | 10 +++-------
 compiler/noirc_frontend/src/hir/def_map/mod.rs       | 12 +++---------
 compiler/noirc_frontend/src/tests.rs                 |  2 +-
 4 files changed, 9 insertions(+), 22 deletions(-)

diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 97fc66688e1..fa134f8a0dd 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -237,11 +237,8 @@ pub fn check_crate(
     deny_warnings: bool,
     disable_macros: bool,
 ) -> CompilationResult<()> {
-    let macros: Vec<&dyn MacroProcessor> = if disable_macros {
-        vec![]
-    } else {
-        vec![&aztec_macros::AztecMacro as &dyn MacroProcessor]
-    };
+    let macros: &[&dyn MacroProcessor] =
+        if disable_macros { &[] } else { &[&aztec_macros::AztecMacro as &dyn MacroProcessor] };
 
     let mut errors = vec![];
     let diagnostics = CrateDefMap::collect_defs(crate_id, context, macros);
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 7f36af5b30e..4a6ca5c6993 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -207,7 +207,7 @@ impl DefCollector {
         context: &mut Context,
         ast: SortedModule,
         root_file_id: FileId,
-        macro_processors: Vec<&dyn MacroProcessor>,
+        macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
         let crate_id = def_map.krate;
@@ -220,11 +220,7 @@ impl DefCollector {
         let crate_graph = &context.crate_graph[crate_id];
 
         for dep in crate_graph.dependencies.clone() {
-            errors.extend(CrateDefMap::collect_defs(
-                dep.crate_id,
-                context,
-                macro_processors.clone(),
-            ));
+            errors.extend(CrateDefMap::collect_defs(dep.crate_id, context, macro_processors));
 
             let dep_def_root =
                 context.def_map(&dep.crate_id).expect("ice: def map was just created").root;
@@ -257,7 +253,7 @@ impl DefCollector {
         context.def_maps.insert(crate_id, def_collector.def_map);
 
         // TODO(#4653): generalize this function
-        for macro_processor in &macro_processors {
+        for macro_processor in macro_processors {
             macro_processor
                 .process_unresolved_traits_impls(
                     &crate_id,
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 8721bdb6c3c..1326ffca9f7 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -73,7 +73,7 @@ impl CrateDefMap {
     pub fn collect_defs(
         crate_id: CrateId,
         context: &mut Context,
-        macro_processors: Vec<&dyn MacroProcessor>,
+        macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         // Check if this Crate has already been compiled
         // XXX: There is probably a better alternative for this.
@@ -90,7 +90,7 @@ impl CrateDefMap {
         let (ast, parsing_errors) = context.parsed_file_results(root_file_id);
         let mut ast = ast.into_sorted();
 
-        for macro_processor in &macro_processors {
+        for macro_processor in macro_processors {
             match macro_processor.process_untyped_ast(ast.clone(), &crate_id, context) {
                 Ok(processed_ast) => {
                     ast = processed_ast;
@@ -115,13 +115,7 @@ impl CrateDefMap {
         };
 
         // Now we want to populate the CrateDefMap using the DefCollector
-        errors.extend(DefCollector::collect(
-            def_map,
-            context,
-            ast,
-            root_file_id,
-            macro_processors.clone(),
-        ));
+        errors.extend(DefCollector::collect(def_map, context, ast, root_file_id, macro_processors));
 
         errors.extend(
             parsing_errors.iter().map(|e| (e.clone().into(), root_file_id)).collect::<Vec<_>>(),
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index c661cc92eef..0c8c677d9af 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -81,7 +81,7 @@ mod test {
                 &mut context,
                 program.clone().into_sorted(),
                 root_file_id,
-                Vec::new(), // No macro processors
+                &[], // No macro processors
             ));
         }
         (program, context, errors)

From 2a555a041dbd3e40cbf768ca131f508570f4ba50 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 7 Mar 2024 19:37:17 +0100
Subject: [PATCH 048/416] chore: add regression test for issue 4449 (#4503)

# Description

## Problem\*

Related to issue #4449

## Summary\*
This PR adds a regression test which ensure PR #4492 is able to handle
large CFG.


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X ] I have tested the changes locally.
- [ X] I have formatted the changes with
[Prettier](https://prettier.io/) and/or `cargo fmt` on default settings.
---
 .../execution_success/regression_4449/Nargo.toml   |  6 ++++++
 .../execution_success/regression_4449/Prover.toml  |  3 +++
 .../execution_success/regression_4449/src/main.nr  | 14 ++++++++++++++
 3 files changed, 23 insertions(+)
 create mode 100644 test_programs/execution_success/regression_4449/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_4449/Prover.toml
 create mode 100644 test_programs/execution_success/regression_4449/src/main.nr

diff --git a/test_programs/execution_success/regression_4449/Nargo.toml b/test_programs/execution_success/regression_4449/Nargo.toml
new file mode 100644
index 00000000000..925420a03a8
--- /dev/null
+++ b/test_programs/execution_success/regression_4449/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_4449"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_4449/Prover.toml b/test_programs/execution_success/regression_4449/Prover.toml
new file mode 100644
index 00000000000..81af476bcc9
--- /dev/null
+++ b/test_programs/execution_success/regression_4449/Prover.toml
@@ -0,0 +1,3 @@
+
+x = 0xbd
+result = [204, 59, 83, 197, 18, 1, 128, 43, 247, 28, 104, 225, 106, 13, 20, 187, 42, 26, 67, 150, 48, 75, 238, 168, 121, 247, 142, 160, 71, 222, 97, 188]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_4449/src/main.nr b/test_programs/execution_success/regression_4449/src/main.nr
new file mode 100644
index 00000000000..454a93f5d1a
--- /dev/null
+++ b/test_programs/execution_success/regression_4449/src/main.nr
@@ -0,0 +1,14 @@
+// Regression test for issue #4449
+use dep::std;
+
+fn main(x: u8, result: [u8; 32]) {
+    let x = x % 31;
+    let mut digest = [0; 32];
+    for i in 0..70 {
+        let y = x + i;
+        let a = [y, x, 32, 0, y + 1, y - 1, y - 2, 5];
+        digest = std::sha256::digest(a);
+    }
+
+    assert(digest == result);
+}

From ae1a9d923998177516919bbba6ff4b0584fa1e9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gustavo=20Gir=C3=A1ldez?= <ggiraldez@manas.tech>
Date: Thu, 7 Mar 2024 14:44:34 -0500
Subject: [PATCH 049/416] feat: Track stack frames and their variables in the
 debugger (#4188)

# Description

## Problem\*

Part of #3015

We want to track call frames and observe variables local to the
currently executing frame.

## Summary\*

This PR adds a bit more debugging instrumentation to track when function
call frames are entered and exited, which allows to determine which
variables are "live" at the current point in execution. This new
instrumentation also allows labeling the frames in the call stack from
the names of the functions being executed.

Also, it includes improvements on how source breakpoints are mapped into
opcode breakpoints. Both features combined bring substantial
improvements to the debugger usability.

## Additional Context

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: synthia <sy@nthia.dev>
Co-authored-by: Martin Verzilli <martin.verzilli@gmail.com>
---
 compiler/noirc_errors/src/debug_info.rs       |  14 ++-
 compiler/noirc_evaluator/src/ssa.rs           |   3 +-
 compiler/noirc_frontend/src/debug/mod.rs      | 104 ++++++++++++++--
 compiler/noirc_frontend/src/hir_def/types.rs  |   8 +-
 .../src/monomorphization/ast.rs               |   5 +-
 .../src/monomorphization/debug.rs             |   2 +-
 .../src/monomorphization/debug_types.rs       |  54 +++++----
 .../src/monomorphization/mod.rs               |   4 +-
 compiler/noirc_printable_type/src/lib.rs      |   8 +-
 tooling/debugger/ignored-tests.txt            |  10 +-
 tooling/debugger/src/context.rs               | 107 ++++++++++++++++-
 tooling/debugger/src/dap.rs                   | 111 ++++--------------
 tooling/debugger/src/foreign_calls.rs         |  46 ++++++--
 tooling/debugger/src/repl.rs                  |  14 ++-
 tooling/debugger/src/source_code_printer.rs   |  10 +-
 tooling/debugger/tests/debug.rs               |   2 +-
 tooling/nargo/src/artifacts/debug.rs          |  10 +-
 tooling/nargo/src/artifacts/debug_vars.rs     |  96 ++++++++++-----
 18 files changed, 415 insertions(+), 193 deletions(-)

diff --git a/compiler/noirc_errors/src/debug_info.rs b/compiler/noirc_errors/src/debug_info.rs
index 67ec851d46d..09117bdc3b7 100644
--- a/compiler/noirc_errors/src/debug_info.rs
+++ b/compiler/noirc_errors/src/debug_info.rs
@@ -24,6 +24,9 @@ use serde::{
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
 pub struct DebugVarId(pub u32);
 
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
+pub struct DebugFnId(pub u32);
+
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
 pub struct DebugTypeId(pub u32);
 
@@ -33,7 +36,14 @@ pub struct DebugVariable {
     pub debug_type_id: DebugTypeId,
 }
 
+#[derive(Debug, Clone, Hash, Deserialize, Serialize)]
+pub struct DebugFunction {
+    pub name: String,
+    pub arg_names: Vec<String>,
+}
+
 pub type DebugVariables = BTreeMap<DebugVarId, DebugVariable>;
+pub type DebugFunctions = BTreeMap<DebugFnId, DebugFunction>;
 pub type DebugTypes = BTreeMap<DebugTypeId, PrintableType>;
 
 #[serde_as]
@@ -45,6 +55,7 @@ pub struct DebugInfo {
     #[serde_as(as = "BTreeMap<DisplayFromStr, _>")]
     pub locations: BTreeMap<OpcodeLocation, Vec<Location>>,
     pub variables: DebugVariables,
+    pub functions: DebugFunctions,
     pub types: DebugTypes,
 }
 
@@ -60,9 +71,10 @@ impl DebugInfo {
     pub fn new(
         locations: BTreeMap<OpcodeLocation, Vec<Location>>,
         variables: DebugVariables,
+        functions: DebugFunctions,
         types: DebugTypes,
     ) -> Self {
-        Self { locations, variables, types }
+        Self { locations, variables, functions, types }
     }
 
     /// Updates the locations map when the [`Circuit`][acvm::acir::circuit::Circuit] is modified.
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 0bb81efe977..56cb76adbe4 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -88,6 +88,7 @@ pub fn create_circuit(
 ) -> Result<(Circuit, DebugInfo, Vec<Witness>, Vec<Witness>, Vec<SsaReport>), RuntimeError> {
     let debug_variables = program.debug_variables.clone();
     let debug_types = program.debug_types.clone();
+    let debug_functions = program.debug_functions.clone();
     let func_sig = program.main_function_signature.clone();
     let recursive = program.recursive;
     let mut generated_acir = optimize_into_acir(
@@ -130,7 +131,7 @@ pub fn create_circuit(
         .map(|(index, locations)| (index, locations.into_iter().collect()))
         .collect();
 
-    let mut debug_info = DebugInfo::new(locations, debug_variables, debug_types);
+    let mut debug_info = DebugInfo::new(locations, debug_variables, debug_functions, debug_types);
 
     // Perform any ACIR-level optimizations
     let (optimized_circuit, transformation_map) = acvm::compiler::optimize(circuit);
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index a88567fcaf9..05916502d73 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -4,9 +4,11 @@ use crate::{
     ast::{Path, PathKind},
     parser::{Item, ItemKind},
 };
+use noirc_errors::debug_info::{DebugFnId, DebugFunction};
 use noirc_errors::{Span, Spanned};
 use std::collections::HashMap;
 use std::collections::VecDeque;
+use std::mem::take;
 
 const MAX_MEMBER_ASSIGN_DEPTH: usize = 8;
 
@@ -26,8 +28,12 @@ pub struct DebugInstrumenter {
     // all field names referenced when assigning to a member of a variable
     pub field_names: HashMap<SourceFieldId, String>,
 
+    // all collected function metadata (name + argument names)
+    pub functions: HashMap<DebugFnId, DebugFunction>,
+
     next_var_id: u32,
     next_field_name_id: u32,
+    next_fn_id: u32,
 
     // last seen variable names and their IDs grouped by scope
     scope: Vec<HashMap<String, SourceVarId>>,
@@ -38,9 +44,11 @@ impl Default for DebugInstrumenter {
         Self {
             variables: HashMap::default(),
             field_names: HashMap::default(),
+            functions: HashMap::default(),
             scope: vec![],
             next_var_id: 0,
             next_field_name_id: 1,
+            next_fn_id: 0,
         }
     }
 }
@@ -76,10 +84,22 @@ impl DebugInstrumenter {
         field_name_id
     }
 
+    fn insert_function(&mut self, fn_name: String, arguments: Vec<String>) -> DebugFnId {
+        let fn_id = DebugFnId(self.next_fn_id);
+        self.next_fn_id += 1;
+        self.functions.insert(fn_id, DebugFunction { name: fn_name, arg_names: arguments });
+        fn_id
+    }
+
     fn walk_fn(&mut self, func: &mut ast::FunctionDefinition) {
+        let func_name = func.name.0.contents.clone();
+        let func_args =
+            func.parameters.iter().map(|param| pattern_to_string(&param.pattern)).collect();
+        let fn_id = self.insert_function(func_name, func_args);
+        let enter_stmt = build_debug_call_stmt("enter", fn_id, func.span);
         self.scope.push(HashMap::default());
 
-        let set_fn_params = func
+        let set_fn_params: Vec<_> = func
             .parameters
             .iter()
             .flat_map(|param| {
@@ -93,10 +113,21 @@ impl DebugInstrumenter {
             })
             .collect();
 
-        self.walk_scope(&mut func.body.0, func.span);
+        let func_body = &mut func.body.0;
+        let mut statements = take(func_body);
+
+        self.walk_scope(&mut statements, func.span);
 
-        // prepend fn params:
-        func.body.0 = [set_fn_params, func.body.0.clone()].concat();
+        // walk_scope ensures that the last statement is the return value of the function
+        let last_stmt = statements.pop().expect("at least one statement after walk_scope");
+        let exit_stmt = build_debug_call_stmt("exit", fn_id, last_stmt.span);
+
+        // rebuild function body
+        func_body.push(enter_stmt);
+        func_body.extend(set_fn_params);
+        func_body.extend(statements);
+        func_body.push(exit_stmt);
+        func_body.push(last_stmt);
     }
 
     // Modify a vector of statements in-place, adding instrumentation for sets and drops.
@@ -427,6 +458,8 @@ impl DebugInstrumenter {
             use dep::__debug::{{
                 __debug_var_assign,
                 __debug_var_drop,
+                __debug_fn_enter,
+                __debug_fn_exit,
                 __debug_dereference_assign,
                 {member_assigns},
             }};"#
@@ -451,14 +484,32 @@ pub fn build_debug_crate_file() -> String {
             }
 
             #[oracle(__debug_var_drop)]
-            unconstrained fn __debug_var_drop_oracle<T>(_var_id: u32) {}
-            unconstrained fn __debug_var_drop_inner<T>(var_id: u32) {
+            unconstrained fn __debug_var_drop_oracle(_var_id: u32) {}
+            unconstrained fn __debug_var_drop_inner(var_id: u32) {
                 __debug_var_drop_oracle(var_id);
             }
-            pub fn __debug_var_drop<T>(var_id: u32) {
+            pub fn __debug_var_drop(var_id: u32) {
                 __debug_var_drop_inner(var_id);
             }
 
+            #[oracle(__debug_fn_enter)]
+            unconstrained fn __debug_fn_enter_oracle(_fn_id: u32) {}
+            unconstrained fn __debug_fn_enter_inner(fn_id: u32) {
+                __debug_fn_enter_oracle(fn_id);
+            }
+            pub fn __debug_fn_enter(fn_id: u32) {
+                __debug_fn_enter_inner(fn_id);
+            }
+
+            #[oracle(__debug_fn_exit)]
+            unconstrained fn __debug_fn_exit_oracle(_fn_id: u32) {}
+            unconstrained fn __debug_fn_exit_inner(fn_id: u32) {
+                __debug_fn_exit_oracle(fn_id);
+            }
+            pub fn __debug_fn_exit(fn_id: u32) {
+                __debug_fn_exit_inner(fn_id);
+            }
+
             #[oracle(__debug_dereference_assign)]
             unconstrained fn __debug_dereference_assign_oracle<T>(_var_id: u32, _value: T) {}
             unconstrained fn __debug_dereference_assign_inner<T>(var_id: u32, value: T) {
@@ -561,6 +612,21 @@ fn build_assign_member_stmt(
     ast::Statement { kind: ast::StatementKind::Semi(ast::Expression { kind, span }), span }
 }
 
+fn build_debug_call_stmt(fname: &str, fn_id: DebugFnId, span: Span) -> ast::Statement {
+    let kind = ast::ExpressionKind::Call(Box::new(ast::CallExpression {
+        func: Box::new(ast::Expression {
+            kind: ast::ExpressionKind::Variable(ast::Path {
+                segments: vec![ident(&format!["__debug_fn_{fname}"], span)],
+                kind: PathKind::Plain,
+                span,
+            }),
+            span,
+        }),
+        arguments: vec![uint_expr(fn_id.0 as u128, span)],
+    }));
+    ast::Statement { kind: ast::StatementKind::Semi(ast::Expression { kind, span }), span }
+}
+
 fn pattern_vars(pattern: &ast::Pattern) -> Vec<(ast::Ident, bool)> {
     let mut vars = vec![];
     let mut stack = VecDeque::from([(pattern, false)]);
@@ -585,6 +651,30 @@ fn pattern_vars(pattern: &ast::Pattern) -> Vec<(ast::Ident, bool)> {
     vars
 }
 
+fn pattern_to_string(pattern: &ast::Pattern) -> String {
+    match pattern {
+        ast::Pattern::Identifier(id) => id.0.contents.clone(),
+        ast::Pattern::Mutable(mpat, _, _) => format!("mut {}", pattern_to_string(mpat.as_ref())),
+        ast::Pattern::Tuple(elements, _) => format!(
+            "({})",
+            elements.iter().map(pattern_to_string).collect::<Vec<String>>().join(", ")
+        ),
+        ast::Pattern::Struct(name, fields, _) => {
+            format!(
+                "{} {{ {} }}",
+                name,
+                fields
+                    .iter()
+                    .map(|(field_ident, field_pattern)| {
+                        format!("{}: {}", &field_ident.0.contents, pattern_to_string(field_pattern))
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            )
+        }
+    }
+}
+
 fn ident(s: &str, span: Span) -> ast::Ident {
     ast::Ident(Spanned::from(span, s.to_string()))
 }
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index b70aa43701c..13fa41733cf 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -1768,9 +1768,11 @@ impl From<&Type> for PrintableType {
             Type::TypeVariable(_, _) => unreachable!(),
             Type::NamedGeneric(..) => unreachable!(),
             Type::Forall(..) => unreachable!(),
-            Type::Function(_, _, env) => {
-                PrintableType::Function { env: Box::new(env.as_ref().into()) }
-            }
+            Type::Function(arguments, return_type, env) => PrintableType::Function {
+                arguments: arguments.iter().map(|arg| arg.into()).collect(),
+                return_type: Box::new(return_type.as_ref().into()),
+                env: Box::new(env.as_ref().into()),
+            },
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
             }
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index e4e619d5d92..7fcf8e87792 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -1,7 +1,7 @@
 use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::{
-    debug_info::{DebugTypes, DebugVariables},
+    debug_info::{DebugFunctions, DebugTypes, DebugVariables},
     Location,
 };
 
@@ -253,6 +253,7 @@ pub struct Program {
     /// Indicates to a backend whether a SNARK-friendly prover should be used.  
     pub recursive: bool,
     pub debug_variables: DebugVariables,
+    pub debug_functions: DebugFunctions,
     pub debug_types: DebugTypes,
 }
 
@@ -266,6 +267,7 @@ impl Program {
         return_visibility: Visibility,
         recursive: bool,
         debug_variables: DebugVariables,
+        debug_functions: DebugFunctions,
         debug_types: DebugTypes,
     ) -> Program {
         Program {
@@ -276,6 +278,7 @@ impl Program {
             return_visibility,
             recursive,
             debug_variables,
+            debug_functions,
             debug_types,
         }
     }
diff --git a/compiler/noirc_frontend/src/monomorphization/debug.rs b/compiler/noirc_frontend/src/monomorphization/debug.rs
index a8ff4399f99..cf4e0ab792e 100644
--- a/compiler/noirc_frontend/src/monomorphization/debug.rs
+++ b/compiler/noirc_frontend/src/monomorphization/debug.rs
@@ -76,7 +76,7 @@ impl<'interner> Monomorphizer<'interner> {
         let var_type = self.interner.id_type(call.arguments[DEBUG_VALUE_ARG_SLOT]);
         let source_var_id = source_var_id.to_u128().into();
         // then update the ID used for tracking at runtime
-        let var_id = self.debug_type_tracker.insert_var(source_var_id, var_type);
+        let var_id = self.debug_type_tracker.insert_var(source_var_id, &var_type);
         let interned_var_id = self.intern_var_id(var_id, &call.location);
         arguments[DEBUG_VAR_ID_ARG_SLOT] = self.expr(interned_var_id)?;
         Ok(())
diff --git a/compiler/noirc_frontend/src/monomorphization/debug_types.rs b/compiler/noirc_frontend/src/monomorphization/debug_types.rs
index fea073d394f..16b82d1e7b9 100644
--- a/compiler/noirc_frontend/src/monomorphization/debug_types.rs
+++ b/compiler/noirc_frontend/src/monomorphization/debug_types.rs
@@ -3,7 +3,8 @@ use crate::{
     hir_def::types::Type,
 };
 use noirc_errors::debug_info::{
-    DebugTypeId, DebugTypes, DebugVarId, DebugVariable, DebugVariables,
+    DebugFnId, DebugFunction, DebugFunctions, DebugTypeId, DebugTypes, DebugVarId, DebugVariable,
+    DebugVariables,
 };
 use noirc_printable_type::PrintableType;
 use std::collections::HashMap;
@@ -30,7 +31,10 @@ pub struct DebugTypeTracker {
     // All instances of tracked variables
     variables: HashMap<DebugVarId, (SourceVarId, DebugTypeId)>,
 
-    // Types of tracked variables
+    // Function metadata collected during instrumentation injection
+    functions: HashMap<DebugFnId, DebugFunction>,
+
+    // Types of tracked variables and functions
     types: HashMap<DebugTypeId, PrintableType>,
     types_reverse: HashMap<PrintableType, DebugTypeId>,
 
@@ -43,34 +47,29 @@ impl DebugTypeTracker {
         DebugTypeTracker {
             source_variables: instrumenter.variables.clone(),
             source_field_names: instrumenter.field_names.clone(),
+            functions: instrumenter.functions.clone(),
             ..DebugTypeTracker::default()
         }
     }
 
-    pub fn extract_vars_and_types(&self) -> (DebugVariables, DebugTypes) {
+    pub fn extract_vars_and_types(&self) -> (DebugVariables, DebugFunctions, DebugTypes) {
         let debug_variables = self
             .variables
             .clone()
             .into_iter()
             .map(|(var_id, (source_var_id, type_id))| {
-                (
-                    var_id,
-                    DebugVariable {
-                        name: self.source_variables.get(&source_var_id).cloned().unwrap_or_else(
-                            || {
-                                unreachable!(
-                                    "failed to retrieve variable name for {source_var_id:?}"
-                                );
-                            },
-                        ),
-                        debug_type_id: type_id,
-                    },
-                )
+                let var_name =
+                    self.source_variables.get(&source_var_id).cloned().unwrap_or_else(|| {
+                        unreachable!("failed to retrieve variable name for {source_var_id:?}");
+                    });
+                (var_id, DebugVariable { name: var_name, debug_type_id: type_id })
             })
             .collect();
+
+        let debug_functions = self.functions.clone().into_iter().collect();
         let debug_types = self.types.clone().into_iter().collect();
 
-        (debug_variables, debug_types)
+        (debug_variables, debug_functions, debug_types)
     }
 
     pub fn resolve_field_index(
@@ -83,19 +82,24 @@ impl DebugTypeTracker {
             .and_then(|field_name| get_field(cursor_type, field_name))
     }
 
-    pub fn insert_var(&mut self, source_var_id: SourceVarId, var_type: Type) -> DebugVarId {
-        if !self.source_variables.contains_key(&source_var_id) {
-            unreachable!("cannot find source debug variable {source_var_id:?}");
-        }
-
-        let ptype: PrintableType = var_type.follow_bindings().into();
-        let type_id = self.types_reverse.get(&ptype).copied().unwrap_or_else(|| {
+    fn insert_type(&mut self, the_type: &Type) -> DebugTypeId {
+        let ptype: PrintableType = the_type.follow_bindings().into();
+        self.types_reverse.get(&ptype).copied().unwrap_or_else(|| {
             let type_id = DebugTypeId(self.next_type_id);
             self.next_type_id += 1;
             self.types_reverse.insert(ptype.clone(), type_id);
             self.types.insert(type_id, ptype);
             type_id
-        });
+        })
+    }
+
+    pub fn insert_var(&mut self, source_var_id: SourceVarId, var_type: &Type) -> DebugVarId {
+        if !self.source_variables.contains_key(&source_var_id) {
+            unreachable!("cannot find source debug variable {source_var_id:?}");
+        }
+
+        let type_id = self.insert_type(var_type);
+
         // check if we need to instantiate the var with a new type
         let existing_var_id = self.source_to_debug_vars.get(&source_var_id).and_then(|var_id| {
             let (_, existing_type_id) = self.variables.get(var_id).unwrap();
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index ce880401d77..cfd9a61d13f 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -165,7 +165,8 @@ pub fn monomorphize_debug(
     let FuncMeta { return_distinctness, return_visibility, kind, .. } =
         monomorphizer.interner.function_meta(&main);
 
-    let (debug_variables, debug_types) = monomorphizer.debug_type_tracker.extract_vars_and_types();
+    let (debug_variables, debug_functions, debug_types) =
+        monomorphizer.debug_type_tracker.extract_vars_and_types();
     let program = Program::new(
         functions,
         function_sig,
@@ -174,6 +175,7 @@ pub fn monomorphize_debug(
         *return_visibility,
         *kind == FunctionKind::Recursive,
         debug_variables,
+        debug_functions,
         debug_types,
     );
     Ok(program)
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index 24f4f275a14..60f233cd86d 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -33,6 +33,8 @@ pub enum PrintableType {
         length: u64,
     },
     Function {
+        arguments: Vec<PrintableType>,
+        return_type: Box<PrintableType>,
         env: Box<PrintableType>,
     },
     MutableReference {
@@ -176,8 +178,8 @@ fn to_string(value: &PrintableValue, typ: &PrintableType) -> Option<String> {
                 output.push_str("false");
             }
         }
-        (PrintableValue::Field(_), PrintableType::Function { .. }) => {
-            output.push_str("<<function>>");
+        (PrintableValue::Field(_), PrintableType::Function { arguments, return_type, .. }) => {
+            output.push_str(&format!("<<fn({:?}) -> {:?}>>", arguments, return_type,));
         }
         (_, PrintableType::MutableReference { .. }) => {
             output.push_str("<<mutable ref>>");
@@ -350,7 +352,7 @@ pub fn decode_value(
 
             PrintableValue::Struct(struct_map)
         }
-        PrintableType::Function { env } => {
+        PrintableType::Function { env, .. } => {
             let field_element = field_iterator.next().unwrap();
             let func_ref = PrintableValue::Field(field_element);
             // we want to consume the fields from the environment, but for now they are not actually printed
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index c472e828739..231d4d897a9 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -1,21 +1,13 @@
 array_dynamic_blackbox_input
-array_sort
-assign_ex
+bigint
 bit_shifts_comptime
-brillig_cow
-brillig_nested_arrays
 brillig_references
 brillig_to_bytes_integration
 debug_logs
 double_verify_nested_proof
 double_verify_proof
 modulus
-nested_array_dynamic
-nested_array_in_slice
-nested_arrays_from_brillig
 references
 scalar_mul
 signed_comparison
-simple_2d_array
 to_bytes_integration
-bigint
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 515edf0bb06..a3ee89263a4 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -8,11 +8,14 @@ use acvm::pwg::{
 };
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 
-use nargo::artifacts::debug::DebugArtifact;
+use codespan_reporting::files::{Files, SimpleFile};
+use fm::FileId;
+use nargo::artifacts::debug::{DebugArtifact, StackFrame};
 use nargo::errors::{ExecutionError, Location};
 use nargo::NargoError;
-use noirc_printable_type::{PrintableType, PrintableValue};
+use noirc_driver::DebugFile;
 
+use std::collections::BTreeMap;
 use std::collections::{hash_set::Iter, HashSet};
 
 #[derive(Debug)]
@@ -29,6 +32,7 @@ pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver> {
     foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
     debug_artifact: &'a DebugArtifact,
     breakpoints: HashSet<OpcodeLocation>,
+    source_to_opcodes: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>>,
 }
 
 impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
@@ -39,12 +43,14 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         initial_witness: WitnessMap,
         foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
     ) -> Self {
+        let source_to_opcodes = build_source_to_opcode_debug_mappings(debug_artifact);
         Self {
             acvm: ACVM::new(blackbox_solver, &circuit.opcodes, initial_witness),
             brillig_solver: None,
             foreign_call_executor,
             debug_artifact,
             breakpoints: HashSet::new(),
+            source_to_opcodes,
         }
     }
 
@@ -100,10 +106,50 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         self.debug_artifact
             .file_map
             .get(&location.file)
-            .map(|file| file.path.starts_with("__debug/"))
+            .map(is_debug_file_in_debug_crate)
             .unwrap_or(false)
     }
 
+    /// Find an opcode location matching a source code location
+    // We apply some heuristics here, and there are four possibilities for the
+    // return value of this function:
+    // 1. the source location is not found -> None
+    // 2. an exact unique location is found (very rare) -> Some(opcode_location)
+    // 3. an exact but not unique location is found, ie. a source location may
+    //    be mapped to multiple opcodes, and those may be disjoint, for example for
+    //    functions called multiple times throughout the program
+    //    -> return the first opcode in program order that matches the source location
+    // 4. exact location is not found, so an opcode for a nearby source location
+    //    is returned (this again could actually be more than one opcodes)
+    //    -> return the opcode for the next source line that is mapped
+    pub(super) fn find_opcode_for_source_location(
+        &self,
+        file_id: &FileId,
+        line: i64,
+    ) -> Option<OpcodeLocation> {
+        let line = line as usize;
+        let Some(line_to_opcodes) = self.source_to_opcodes.get(file_id) else {
+            return None;
+        };
+        let found_index = match line_to_opcodes.binary_search_by(|x| x.0.cmp(&line)) {
+            Ok(index) => {
+                // move backwards to find the first opcode which matches the line
+                let mut index = index;
+                while index > 0 && line_to_opcodes[index - 1].0 == line {
+                    index -= 1;
+                }
+                line_to_opcodes[index].1
+            }
+            Err(index) => {
+                if index >= line_to_opcodes.len() {
+                    return None;
+                }
+                line_to_opcodes[index].1
+            }
+        };
+        Some(found_index)
+    }
+
     /// Returns the callstack in source code locations for the currently
     /// executing opcode. This can be `None` if the execution finished (and
     /// `get_current_opcode_location()` returns `None`) or if the opcode is not
@@ -128,6 +174,9 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         &self,
         opcode_location: &OpcodeLocation,
     ) -> Vec<Location> {
+        // TODO: this assumes we're debugging a program (ie. the DebugArtifact
+        // will contain a single DebugInfo), but this assumption doesn't hold
+        // for contracts
         self.debug_artifact.debug_symbols[0]
             .opcode_location(opcode_location)
             .map(|source_locations| {
@@ -467,10 +516,14 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    pub(super) fn get_variables(&self) -> Vec<(&str, &PrintableValue, &PrintableType)> {
+    pub(super) fn get_variables(&self) -> Vec<StackFrame> {
         return self.foreign_call_executor.get_variables();
     }
 
+    pub(super) fn current_stack_frame(&self) -> Option<StackFrame> {
+        return self.foreign_call_executor.current_stack_frame();
+    }
+
     fn breakpoint_reached(&self) -> bool {
         if let Some(location) = self.get_current_opcode_location() {
             self.breakpoints.contains(&location)
@@ -526,6 +579,52 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
     }
 }
 
+fn is_debug_file_in_debug_crate(debug_file: &DebugFile) -> bool {
+    debug_file.path.starts_with("__debug/")
+}
+
+/// Builds a map from FileId to an ordered vector of tuples with line
+/// numbers and opcode locations corresponding to those line numbers
+fn build_source_to_opcode_debug_mappings(
+    debug_artifact: &DebugArtifact,
+) -> BTreeMap<FileId, Vec<(usize, OpcodeLocation)>> {
+    if debug_artifact.debug_symbols.is_empty() {
+        return BTreeMap::new();
+    }
+    let locations = &debug_artifact.debug_symbols[0].locations;
+    let simple_files: BTreeMap<_, _> = debug_artifact
+        .file_map
+        .iter()
+        .filter(|(_, debug_file)| !is_debug_file_in_debug_crate(debug_file))
+        .map(|(file_id, debug_file)| {
+            (
+                file_id,
+                SimpleFile::new(debug_file.path.to_str().unwrap(), debug_file.source.as_str()),
+            )
+        })
+        .collect();
+
+    let mut result: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>> = BTreeMap::new();
+    locations.iter().for_each(|(opcode_location, source_locations)| {
+        source_locations.iter().for_each(|source_location| {
+            let span = source_location.span;
+            let file_id = source_location.file;
+            let Some(file) = simple_files.get(&file_id) else {
+                return;
+            };
+            let Ok(line_index) = file.line_index((), span.start() as usize) else {
+                return;
+            };
+            let line_number = line_index + 1;
+
+            result.entry(file_id).or_default().push((line_number, *opcode_location));
+        });
+    });
+    result.iter_mut().for_each(|(_, file_locations)| file_locations.sort_by_key(|x| (x.0, x.1)));
+
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index 7e67a26b257..7c722ed0a61 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -5,7 +5,6 @@ use std::str::FromStr;
 use acvm::acir::circuit::{Circuit, OpcodeLocation};
 use acvm::acir::native_types::WitnessMap;
 use acvm::BlackBoxFunctionSolver;
-use codespan_reporting::files::{Files, SimpleFile};
 
 use crate::context::DebugCommandResult;
 use crate::context::DebugContext;
@@ -30,15 +29,16 @@ use nargo::artifacts::debug::DebugArtifact;
 use fm::FileId;
 use noirc_driver::CompiledProgram;
 
+type BreakpointId = i64;
+
 pub struct DapSession<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> {
     server: Server<R, W>,
     context: DebugContext<'a, B>,
     debug_artifact: &'a DebugArtifact,
     running: bool,
-    source_to_opcodes: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>>,
-    next_breakpoint_id: i64,
-    instruction_breakpoints: Vec<(OpcodeLocation, i64)>,
-    source_breakpoints: BTreeMap<FileId, Vec<(OpcodeLocation, i64)>>,
+    next_breakpoint_id: BreakpointId,
+    instruction_breakpoints: Vec<(OpcodeLocation, BreakpointId)>,
+    source_breakpoints: BTreeMap<FileId, Vec<(OpcodeLocation, BreakpointId)>>,
 }
 
 enum ScopeReferences {
@@ -57,8 +57,6 @@ impl From<i64> for ScopeReferences {
     }
 }
 
-// BTreeMap<FileId, Vec<(usize, OpcodeLocation)>
-
 impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
     pub fn new(
         server: Server<R, W>,
@@ -67,7 +65,6 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap,
     ) -> Self {
-        let source_to_opcodes = Self::build_source_to_opcode_debug_mappings(debug_artifact);
         let context = DebugContext::new(
             solver,
             circuit,
@@ -79,7 +76,6 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
             server,
             context,
             debug_artifact,
-            source_to_opcodes,
             running: false,
             next_breakpoint_id: 1,
             instruction_breakpoints: vec![],
@@ -87,46 +83,6 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
         }
     }
 
-    /// Builds a map from FileId to an ordered vector of tuples with line
-    /// numbers and opcode locations corresponding to those line numbers
-    fn build_source_to_opcode_debug_mappings(
-        debug_artifact: &'a DebugArtifact,
-    ) -> BTreeMap<FileId, Vec<(usize, OpcodeLocation)>> {
-        if debug_artifact.debug_symbols.is_empty() {
-            return BTreeMap::new();
-        }
-        let locations = &debug_artifact.debug_symbols[0].locations;
-        let simple_files: BTreeMap<_, _> = debug_artifact
-            .file_map
-            .iter()
-            .map(|(file_id, debug_file)| {
-                (
-                    file_id,
-                    SimpleFile::new(debug_file.path.to_str().unwrap(), debug_file.source.as_str()),
-                )
-            })
-            .collect();
-
-        let mut result: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>> = BTreeMap::new();
-        locations.iter().for_each(|(opcode_location, source_locations)| {
-            if source_locations.is_empty() {
-                return;
-            }
-            let source_location = source_locations[0];
-            let span = source_location.span;
-            let file_id = source_location.file;
-            let Ok(line_index) = &simple_files[&file_id].line_index((), span.start() as usize)
-            else {
-                return;
-            };
-            let line_number = line_index + 1;
-
-            result.entry(file_id).or_default().push((line_number, *opcode_location));
-        });
-        result.iter_mut().for_each(|(_, file_locations)| file_locations.sort_by_key(|x| x.0));
-        result
-    }
-
     fn send_stopped_event(&mut self, reason: StoppedEventReason) -> Result<(), ServerError> {
         let description = format!("{:?}", &reason);
         self.server.send_event(Event::Stopped(StoppedEventBody {
@@ -230,6 +186,8 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
     }
 
     fn build_stack_trace(&self) -> Vec<StackFrame> {
+        let stack_frames = self.context.get_variables();
+
         self.context
             .get_source_call_stack()
             .iter()
@@ -239,9 +197,15 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
                     self.debug_artifact.location_line_number(*source_location).unwrap();
                 let column_number =
                     self.debug_artifact.location_column_number(*source_location).unwrap();
+
+                let name = match stack_frames.get(index) {
+                    Some(frame) => format!("{} {}", frame.function_name, index),
+                    None => format!("frame #{index}"),
+                };
+
                 StackFrame {
                     id: index as i64,
-                    name: format!("frame #{index}"),
+                    name,
                     source: Some(Source {
                         path: self.debug_artifact.file_map[&source_location.file]
                             .path
@@ -422,7 +386,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
         Ok(())
     }
 
-    fn get_next_breakpoint_id(&mut self) -> i64 {
+    fn get_next_breakpoint_id(&mut self) -> BreakpointId {
         let id = self.next_breakpoint_id;
         self.next_breakpoint_id += 1;
         id
@@ -493,36 +457,6 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
         found.map(|iter| *iter.0)
     }
 
-    // TODO: there are four possibilities for the return value of this function:
-    // 1. the source location is not found -> None
-    // 2. an exact unique location is found -> Some(opcode_location)
-    // 3. an exact but not unique location is found (ie. a source location may
-    //    be mapped to multiple opcodes, and those may be disjoint, for example for
-    //    functions called multiple times throughout the program)
-    // 4. exact location is not found, so an opcode for a nearby source location
-    //    is returned (this again could actually be more than one opcodes)
-    // Case 3 is not supported yet, and 4 is not correctly handled.
-    fn find_opcode_for_source_location(
-        &self,
-        file_id: &FileId,
-        line: i64,
-    ) -> Option<OpcodeLocation> {
-        let line = line as usize;
-        let Some(line_to_opcodes) = self.source_to_opcodes.get(file_id) else {
-            return None;
-        };
-        let found_index = match line_to_opcodes.binary_search_by(|x| x.0.cmp(&line)) {
-            Ok(index) => line_to_opcodes[index].1,
-            Err(index) => {
-                if index >= line_to_opcodes.len() {
-                    return None;
-                }
-                line_to_opcodes[index].1
-            }
-        };
-        Some(found_index)
-    }
-
     fn map_source_breakpoints(&mut self, args: &SetBreakpointsArguments) -> Vec<Breakpoint> {
         let Some(ref source) = &args.source.path else {
             return vec![];
@@ -539,7 +473,8 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
             .iter()
             .map(|breakpoint| {
                 let line = breakpoint.line;
-                let Some(location) = self.find_opcode_for_source_location(&file_id, line) else {
+                let Some(location) = self.context.find_opcode_for_source_location(&file_id, line)
+                else {
                     return Breakpoint {
                         verified: false,
                         message: Some(String::from(
@@ -608,16 +543,20 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
     }
 
     fn build_local_variables(&self) -> Vec<Variable> {
-        let mut variables: Vec<_> = self
-            .context
-            .get_variables()
+        let Some(current_stack_frame) = self.context.current_stack_frame() else {
+            return vec![];
+        };
+
+        let mut variables = current_stack_frame
+            .variables
             .iter()
             .map(|(name, value, _var_type)| Variable {
                 name: String::from(*name),
                 value: format!("{:?}", *value),
                 ..Variable::default()
             })
-            .collect();
+            .collect::<Vec<Variable>>();
+
         variables.sort_by(|a, b| a.name.partial_cmp(&b.name).unwrap());
         variables
     }
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index 68c4d3947b0..25f126ff490 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -3,17 +3,19 @@ use acvm::{
     pwg::ForeignCallWaitInfo,
 };
 use nargo::{
-    artifacts::debug::{DebugArtifact, DebugVars},
+    artifacts::debug::{DebugArtifact, DebugVars, StackFrame},
     ops::{DefaultForeignCallExecutor, ForeignCallExecutor, NargoForeignCallResult},
 };
-use noirc_errors::debug_info::DebugVarId;
-use noirc_printable_type::{ForeignCallError, PrintableType, PrintableValue};
+use noirc_errors::debug_info::{DebugFnId, DebugVarId};
+use noirc_printable_type::ForeignCallError;
 
 pub(crate) enum DebugForeignCall {
     VarAssign,
     VarDrop,
     MemberAssign(u32),
     DerefAssign,
+    FnEnter,
+    FnExit,
 }
 
 impl DebugForeignCall {
@@ -28,13 +30,16 @@ impl DebugForeignCall {
             "__debug_var_assign" => Some(DebugForeignCall::VarAssign),
             "__debug_var_drop" => Some(DebugForeignCall::VarDrop),
             "__debug_deref_assign" => Some(DebugForeignCall::DerefAssign),
+            "__debug_fn_enter" => Some(DebugForeignCall::FnEnter),
+            "__debug_fn_exit" => Some(DebugForeignCall::FnExit),
             _ => None,
         }
     }
 }
 
 pub trait DebugForeignCallExecutor: ForeignCallExecutor {
-    fn get_variables(&self) -> Vec<(&str, &PrintableValue, &PrintableType)>;
+    fn get_variables(&self) -> Vec<StackFrame>;
+    fn current_stack_frame(&self) -> Option<StackFrame>;
 }
 
 pub struct DefaultDebugForeignCallExecutor {
@@ -57,23 +62,33 @@ impl DefaultDebugForeignCallExecutor {
     }
 
     pub fn load_artifact(&mut self, artifact: &DebugArtifact) {
-        artifact.debug_symbols.iter().for_each(|info| {
-            self.debug_vars.insert_variables(&info.variables);
-            self.debug_vars.insert_types(&info.types);
-        });
+        // TODO: handle loading from the correct DebugInfo when we support
+        // debugging contracts
+        let Some(info) = artifact.debug_symbols.get(0) else {
+            return;
+        };
+        self.debug_vars.insert_debug_info(info);
     }
 }
 
 impl DebugForeignCallExecutor for DefaultDebugForeignCallExecutor {
-    fn get_variables(&self) -> Vec<(&str, &PrintableValue, &PrintableType)> {
+    fn get_variables(&self) -> Vec<StackFrame> {
         self.debug_vars.get_variables()
     }
+
+    fn current_stack_frame(&self) -> Option<StackFrame> {
+        self.debug_vars.current_stack_frame()
+    }
 }
 
 fn debug_var_id(value: &Value) -> DebugVarId {
     DebugVarId(value.to_u128() as u32)
 }
 
+fn debug_fn_id(value: &Value) -> DebugFnId {
+    DebugFnId(value.to_u128() as u32)
+}
+
 impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
     fn execute(
         &mut self,
@@ -136,6 +151,19 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                 }
                 Ok(ForeignCallResult::default().into())
             }
+            Some(DebugForeignCall::FnEnter) => {
+                let fcp_fn_id = &foreign_call.inputs[0];
+                let ForeignCallParam::Single(fn_id_value) = fcp_fn_id else {
+                    panic!("unexpected foreign call parameter in fn enter: {fcp_fn_id:?}")
+                };
+                let fn_id = debug_fn_id(fn_id_value);
+                self.debug_vars.push_fn(fn_id);
+                Ok(ForeignCallResult::default().into())
+            }
+            Some(DebugForeignCall::FnExit) => {
+                self.debug_vars.pop_fn();
+                Ok(ForeignCallResult::default().into())
+            }
             None => self.executor.execute(foreign_call),
         }
     }
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 8441dbde9be..41dbf604f99 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -337,11 +337,13 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
     }
 
     pub fn show_vars(&self) {
-        let vars = self.context.get_variables();
-        for (var_name, value, var_type) in vars.iter() {
-            let printable_value =
-                PrintableValueDisplay::Plain((*value).clone(), (*var_type).clone());
-            println!("{var_name}:{var_type:?} = {}", printable_value);
+        for frame in self.context.get_variables() {
+            println!("{}({})", frame.function_name, frame.function_params.join(", "));
+            for (var_name, value, var_type) in frame.variables.iter() {
+                let printable_value =
+                    PrintableValueDisplay::Plain((*value).clone(), (*var_type).clone());
+                println!("  {var_name}:{var_type:?} = {}", printable_value);
+            }
         }
     }
 
@@ -530,7 +532,7 @@ pub fn run<B: BlackBoxFunctionSolver>(
         .add(
             "vars",
             command! {
-                "show variable values available at this point in execution",
+                "show variables for each function scope available at this point in execution",
                 () => || {
                     ref_context.borrow_mut().show_vars();
                     Ok(CommandStatus::Done)
diff --git a/tooling/debugger/src/source_code_printer.rs b/tooling/debugger/src/source_code_printer.rs
index b5ffdb12d01..e298eb8aadd 100644
--- a/tooling/debugger/src/source_code_printer.rs
+++ b/tooling/debugger/src/source_code_printer.rs
@@ -30,7 +30,7 @@ struct LocationPrintContext {
 // Given a DebugArtifact and an OpcodeLocation, prints all the source code
 // locations the OpcodeLocation maps to, with some surrounding context and
 // visual aids to highlight the location itself.
-pub(crate) fn print_source_code_location(debug_artifact: &DebugArtifact, locations: &[Location]) {
+pub(super) fn print_source_code_location(debug_artifact: &DebugArtifact, locations: &[Location]) {
     let locations = locations.iter();
 
     for loc in locations {
@@ -269,8 +269,12 @@ mod tests {
         let mut opcode_locations = BTreeMap::<OpcodeLocation, Vec<Location>>::new();
         opcode_locations.insert(OpcodeLocation::Acir(42), vec![loc]);
 
-        let debug_symbols =
-            vec![DebugInfo::new(opcode_locations, BTreeMap::default(), BTreeMap::default())];
+        let debug_symbols = vec![DebugInfo::new(
+            opcode_locations,
+            BTreeMap::default(),
+            BTreeMap::default(),
+            BTreeMap::default(),
+        )];
         let debug_artifact = DebugArtifact::new(debug_symbols, &fm);
 
         let location_rendered: Vec<_> = render_location(&debug_artifact, &loc).collect();
diff --git a/tooling/debugger/tests/debug.rs b/tooling/debugger/tests/debug.rs
index 4cb678192b8..143ee7987f8 100644
--- a/tooling/debugger/tests/debug.rs
+++ b/tooling/debugger/tests/debug.rs
@@ -12,7 +12,7 @@ mod tests {
         let nargo_bin =
             cargo_bin("nargo").into_os_string().into_string().expect("Cannot parse nargo path");
 
-        let mut dbg_session = spawn_bash(Some(10000)).expect("Could not start bash session");
+        let mut dbg_session = spawn_bash(Some(15000)).expect("Could not start bash session");
 
         // Set backend to `/dev/null` to force an error if nargo tries to speak to a backend.
         dbg_session
diff --git a/tooling/nargo/src/artifacts/debug.rs b/tooling/nargo/src/artifacts/debug.rs
index a249ecb03ad..fbdf59805c9 100644
--- a/tooling/nargo/src/artifacts/debug.rs
+++ b/tooling/nargo/src/artifacts/debug.rs
@@ -8,7 +8,7 @@ use std::{
     ops::Range,
 };
 
-pub use super::debug_vars::DebugVars;
+pub use super::debug_vars::{DebugVars, StackFrame};
 use fm::{FileId, FileManager, PathString};
 
 /// A Debug Artifact stores, for a given program, the debug info for every function
@@ -231,8 +231,12 @@ mod tests {
         let mut opcode_locations = BTreeMap::<OpcodeLocation, Vec<Location>>::new();
         opcode_locations.insert(OpcodeLocation::Acir(42), vec![loc]);
 
-        let debug_symbols =
-            vec![DebugInfo::new(opcode_locations, BTreeMap::default(), BTreeMap::default())];
+        let debug_symbols = vec![DebugInfo::new(
+            opcode_locations,
+            BTreeMap::default(),
+            BTreeMap::default(),
+            BTreeMap::default(),
+        )];
         let debug_artifact = DebugArtifact::new(debug_symbols, &fm);
 
         let location_in_line = debug_artifact.location_in_line(loc).expect("Expected a range");
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 20f2637f7d6..66568bec833 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -1,54 +1,85 @@
 use acvm::brillig_vm::brillig::Value;
 use noirc_errors::debug_info::{
-    DebugTypeId, DebugTypes, DebugVarId, DebugVariable, DebugVariables,
+    DebugFnId, DebugFunction, DebugInfo, DebugTypeId, DebugVarId, DebugVariable,
 };
 use noirc_printable_type::{decode_value, PrintableType, PrintableValue};
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 #[derive(Debug, Default, Clone)]
 pub struct DebugVars {
     variables: HashMap<DebugVarId, DebugVariable>,
+    functions: HashMap<DebugFnId, DebugFunction>,
     types: HashMap<DebugTypeId, PrintableType>,
-    active: HashSet<DebugVarId>,
-    values: HashMap<DebugVarId, PrintableValue>,
+    frames: Vec<(DebugFnId, HashMap<DebugVarId, PrintableValue>)>,
+}
+
+pub struct StackFrame<'a> {
+    pub function_name: &'a str,
+    pub function_params: Vec<&'a str>,
+    pub variables: Vec<(&'a str, &'a PrintableValue, &'a PrintableType)>,
 }
 
 impl DebugVars {
-    pub fn get_variables(&self) -> Vec<(&str, &PrintableValue, &PrintableType)> {
-        self.active
-            .iter()
-            .filter_map(|var_id| {
-                self.variables.get(var_id).and_then(|debug_var| {
-                    let Some(value) = self.values.get(var_id) else {
-                        return None;
-                    };
-                    let Some(ptype) = self.types.get(&debug_var.debug_type_id) else {
-                        return None;
-                    };
-                    Some((debug_var.name.as_str(), value, ptype))
-                })
-            })
-            .collect()
+    pub fn insert_debug_info(&mut self, info: &DebugInfo) {
+        self.variables.extend(info.variables.clone());
+        self.types.extend(info.types.clone());
+        self.functions.extend(info.functions.clone());
+    }
+
+    pub fn get_variables(&self) -> Vec<StackFrame> {
+        self.frames.iter().map(|(fn_id, frame)| self.build_stack_frame(fn_id, frame)).collect()
     }
 
-    pub fn insert_variables(&mut self, vars: &DebugVariables) {
-        self.variables.extend(vars.clone());
+    pub fn current_stack_frame(&self) -> Option<StackFrame> {
+        self.frames.last().map(|(fn_id, frame)| self.build_stack_frame(fn_id, frame))
     }
 
-    pub fn insert_types(&mut self, types: &DebugTypes) {
-        self.types.extend(types.clone());
+    fn lookup_var(&self, var_id: DebugVarId) -> Option<(&str, &PrintableType)> {
+        self.variables.get(&var_id).and_then(|debug_var| {
+            let Some(ptype) = self.types.get(&debug_var.debug_type_id) else {
+                return None;
+            };
+            Some((debug_var.name.as_str(), ptype))
+        })
+    }
+
+    fn build_stack_frame<'a>(
+        &'a self,
+        fn_id: &DebugFnId,
+        frame: &'a HashMap<DebugVarId, PrintableValue>,
+    ) -> StackFrame {
+        let debug_fn = &self.functions.get(fn_id).expect("failed to find function metadata");
+
+        let params: Vec<&str> =
+            debug_fn.arg_names.iter().map(|arg_name| arg_name.as_str()).collect();
+        let vars: Vec<(&str, &PrintableValue, &PrintableType)> = frame
+            .iter()
+            .filter_map(|(var_id, var_value)| {
+                self.lookup_var(*var_id).map(|(name, typ)| (name, var_value, typ))
+            })
+            .collect();
+
+        StackFrame {
+            function_name: debug_fn.name.as_str(),
+            function_params: params,
+            variables: vars,
+        }
     }
 
     pub fn assign_var(&mut self, var_id: DebugVarId, values: &[Value]) {
-        self.active.insert(var_id);
         let type_id = &self.variables.get(&var_id).unwrap().debug_type_id;
         let ptype = self.types.get(type_id).unwrap();
-        self.values.insert(var_id, decode_value(&mut values.iter().map(|v| v.to_field()), ptype));
+
+        self.frames
+            .last_mut()
+            .expect("unexpected empty stack frames")
+            .1
+            .insert(var_id, decode_value(&mut values.iter().map(|v| v.to_field()), ptype));
     }
 
     pub fn assign_field(&mut self, var_id: DebugVarId, indexes: Vec<u32>, values: &[Value]) {
-        let mut cursor: &mut PrintableValue = self
-            .values
+        let current_frame = &mut self.frames.last_mut().expect("unexpected empty stack frames").1;
+        let mut cursor: &mut PrintableValue = current_frame
             .get_mut(&var_id)
             .unwrap_or_else(|| panic!("value unavailable for var_id {var_id:?}"));
         let cursor_type_id = &self
@@ -102,7 +133,6 @@ impl DebugVars {
             };
         }
         *cursor = decode_value(&mut values.iter().map(|v| v.to_field()), cursor_type);
-        self.active.insert(var_id);
     }
 
     pub fn assign_deref(&mut self, _var_id: DebugVarId, _values: &[Value]) {
@@ -114,6 +144,14 @@ impl DebugVars {
     }
 
     pub fn drop_var(&mut self, var_id: DebugVarId) {
-        self.active.remove(&var_id);
+        self.frames.last_mut().expect("unexpected empty stack frames").1.remove(&var_id);
+    }
+
+    pub fn push_fn(&mut self, fn_id: DebugFnId) {
+        self.frames.push((fn_id, HashMap::default()));
+    }
+
+    pub fn pop_fn(&mut self) {
+        self.frames.pop();
     }
 }

From 1510702305f8c14d49f0096395c264eb641b79d5 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 7 Mar 2024 21:05:36 +0000
Subject: [PATCH 050/416] chore: pass `import_directive` by reference (#4511)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We don't need to pass by value here so we can just pass by reference
instead.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs | 2 +-
 compiler/noirc_frontend/src/hir/resolution/import.rs      | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 4a6ca5c6993..27b1d376f11 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -278,7 +278,7 @@ impl DefCollector {
 
         // Resolve unresolved imports collected from the crate, one by one.
         for collected_import in def_collector.collected_imports {
-            match resolve_import(crate_id, collected_import, &context.def_maps) {
+            match resolve_import(crate_id, &collected_import, &context.def_maps) {
                 Ok(resolved_import) => {
                     // Populate module namespaces according to the imports used
                     let current_def_map = context.def_maps.get_mut(&crate_id).unwrap();
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index e6ac33053a0..9c8418daf80 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -52,7 +52,7 @@ impl From<PathResolutionError> for CustomDiagnostic {
 
 pub fn resolve_import(
     crate_id: CrateId,
-    import_directive: ImportDirective,
+    import_directive: &ImportDirective,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
 ) -> Result<ResolvedImport, (PathResolutionError, LocalModuleId)> {
     let def_map = &def_maps[&crate_id];
@@ -62,10 +62,10 @@ pub fn resolve_import(
 
     let module_scope = import_directive.module_id;
     let resolved_namespace =
-        resolve_path_to_ns(&import_directive, def_map, def_maps, allow_contracts)
+        resolve_path_to_ns(import_directive, def_map, def_maps, allow_contracts)
             .map_err(|error| (error, module_scope))?;
 
-    let name = resolve_path_name(&import_directive);
+    let name = resolve_path_name(import_directive);
     Ok(ResolvedImport {
         name,
         resolved_namespace,

From 169127444e8b16a8aad4acfe29ba812894fd897c Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 7 Mar 2024 15:09:50 -0600
Subject: [PATCH 051/416] fix: Force src impl for == on slices (#4507)

# Description

## Problem\*

Resolves #4506

## Summary\*

`==` on slices previously tried to use the built-in impl we have but
this leads to a panic when evaluating binary operators in SSA. We expect
both sides of the binary to be non-tuples but this isn't true for slice
values. Instead of making this work for tuples I changed the type
checker to force slices to use the stdlib impl we have for `==` rather
than the built in one.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/type_check/expr.rs | 8 +++++++-
 test_programs/execution_success/slices/src/main.nr | 7 +++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 7b854e58fca..c5287d35caf 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -863,7 +863,13 @@ impl<'interner> TypeChecker<'interner> {
                     span: op.location.span,
                 });
 
-                self.comparator_operand_type_rules(x_type, y_type, op, span)
+                let (_, use_impl) = self.comparator_operand_type_rules(x_type, y_type, op, span)?;
+
+                // If the size is not constant, we must fall back to a user-provided impl for
+                // equality on slices.
+                let size = x_size.follow_bindings();
+                let use_impl = use_impl || size.evaluate_to_u64().is_none();
+                Ok((Bool, use_impl))
             }
 
             (String(x_size), String(y_size)) => {
diff --git a/test_programs/execution_success/slices/src/main.nr b/test_programs/execution_success/slices/src/main.nr
index eca42a660c4..6823bf05d96 100644
--- a/test_programs/execution_success/slices/src/main.nr
+++ b/test_programs/execution_success/slices/src/main.nr
@@ -50,6 +50,8 @@ fn main(x: Field, y: pub Field) {
     // The parameters to this function must come from witness values (inputs to main)
     regression_merge_slices(x, y);
     regression_2370();
+
+    regression_4506();
 }
 // Ensure that slices of struct/tuple values work.
 fn regression_2083() {
@@ -297,3 +299,8 @@ fn regression_2370() {
     let mut slice = [];
     slice = [1, 2, 3];
 }
+
+fn regression_4506() {
+    let slice: [Field] = [1, 2, 3];
+    assert(slice == slice);
+}

From 3163d81a357161979ea63ecb9ea09df20502ff0b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 7 Mar 2024 21:42:48 +0000
Subject: [PATCH 052/416] chore: add `ModuleDeclaration` struct (#4512)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This is some groundwork pulled out from
https://github.com/noir-lang/noir/pull/4491

We're going to want to apply visibility modifiers to module declarations
so this PR creates a proper struct for these so it's easier for us to
add an extra field to hold the visibility.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/statement.rs   | 11 +++++++++++
 .../src/hir/def_collector/dc_mod.rs            | 18 +++++++++---------
 compiler/noirc_frontend/src/parser/mod.rs      | 18 +++++++++---------
 compiler/noirc_frontend/src/parser/parser.rs   | 10 ++++++----
 4 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index f39b71405d3..387840b57c4 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -240,6 +240,17 @@ pub trait Recoverable {
     fn error(span: Span) -> Self;
 }
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct ModuleDeclaration {
+    pub ident: Ident,
+}
+
+impl std::fmt::Display for ModuleDeclaration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "mod {}", self.ident)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct ImportStatement {
     pub path: Path,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 77224cc311c..5b2f815d636 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -9,8 +9,8 @@ use crate::{
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
     node_interner::{FunctionModifiers, TraitId, TypeAliasId},
     parser::{SortedModule, SortedSubModule},
-    FunctionDefinition, Ident, LetStatement, NoirFunction, NoirStruct, NoirTrait, NoirTraitImpl,
-    NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
+    FunctionDefinition, Ident, LetStatement, ModuleDeclaration, NoirFunction, NoirStruct,
+    NoirTrait, NoirTraitImpl, NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
 };
 
 use super::{
@@ -522,15 +522,15 @@ impl<'a> ModCollector<'a> {
     fn parse_module_declaration(
         &mut self,
         context: &mut Context,
-        mod_name: &Ident,
+        mod_decl: &ModuleDeclaration,
         crate_id: CrateId,
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
         let child_file_id =
-            match find_module(&context.file_manager, self.file_id, &mod_name.0.contents) {
+            match find_module(&context.file_manager, self.file_id, &mod_decl.ident.0.contents) {
                 Ok(child_file_id) => child_file_id,
                 Err(expected_path) => {
-                    let mod_name = mod_name.clone();
+                    let mod_name = mod_decl.ident.clone();
                     let err =
                         DefCollectorErrorKind::UnresolvedModuleDecl { mod_name, expected_path };
                     errors.push((err.into(), self.file_id));
@@ -538,17 +538,17 @@ impl<'a> ModCollector<'a> {
                 }
             };
 
-        let location = Location { file: self.file_id, span: mod_name.span() };
+        let location = Location { file: self.file_id, span: mod_decl.ident.span() };
 
         if let Some(old_location) = context.visited_files.get(&child_file_id) {
             let error = DefCollectorErrorKind::ModuleAlreadyPartOfCrate {
-                mod_name: mod_name.clone(),
+                mod_name: mod_decl.ident.clone(),
                 span: location.span,
             };
             errors.push((error.into(), location.file));
 
             let error = DefCollectorErrorKind::ModuleOriginallyDefined {
-                mod_name: mod_name.clone(),
+                mod_name: mod_decl.ident.clone(),
                 span: old_location.span,
             };
             errors.push((error.into(), old_location.file));
@@ -566,7 +566,7 @@ impl<'a> ModCollector<'a> {
         );
 
         // Add module into def collector and get a ModuleId
-        match self.push_child_module(mod_name, child_file_id, true, false) {
+        match self.push_child_module(&mod_decl.ident, child_file_id, true, false) {
             Ok(child_mod_id) => {
                 errors.extend(collect_defs(
                     self.def_collector,
diff --git a/compiler/noirc_frontend/src/parser/mod.rs b/compiler/noirc_frontend/src/parser/mod.rs
index 0ff7819c00f..ea96dee8a47 100644
--- a/compiler/noirc_frontend/src/parser/mod.rs
+++ b/compiler/noirc_frontend/src/parser/mod.rs
@@ -14,8 +14,8 @@ mod parser;
 use crate::token::{Keyword, Token};
 use crate::{ast::ImportStatement, Expression, NoirStruct};
 use crate::{
-    Ident, LetStatement, NoirFunction, NoirTrait, NoirTraitImpl, NoirTypeAlias, Recoverable,
-    StatementKind, TypeImpl, UseTree,
+    Ident, LetStatement, ModuleDeclaration, NoirFunction, NoirTrait, NoirTraitImpl, NoirTypeAlias,
+    Recoverable, StatementKind, TypeImpl, UseTree,
 };
 
 use chumsky::prelude::*;
@@ -28,7 +28,7 @@ pub use parser::parse_program;
 #[derive(Debug, Clone)]
 pub(crate) enum TopLevelStatement {
     Function(NoirFunction),
-    Module(Ident),
+    Module(ModuleDeclaration),
     Import(UseTree),
     Struct(NoirStruct),
     Trait(NoirTrait),
@@ -220,7 +220,7 @@ pub struct SortedModule {
     pub globals: Vec<LetStatement>,
 
     /// Module declarations like `mod foo;`
-    pub module_decls: Vec<Ident>,
+    pub module_decls: Vec<ModuleDeclaration>,
 
     /// Full submodules as in `mod foo { ... definitions ... }`
     pub submodules: Vec<SortedSubModule>,
@@ -229,7 +229,7 @@ pub struct SortedModule {
 impl std::fmt::Display for SortedModule {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for decl in &self.module_decls {
-            writeln!(f, "mod {decl};")?;
+            writeln!(f, "{decl};")?;
         }
 
         for import in &self.imports {
@@ -309,7 +309,7 @@ pub enum ItemKind {
     Impl(TypeImpl),
     TypeAlias(NoirTypeAlias),
     Global(LetStatement),
-    ModuleDecl(Ident),
+    ModuleDecl(ModuleDeclaration),
     Submodules(ParsedSubModule),
 }
 
@@ -380,8 +380,8 @@ impl SortedModule {
         self.imports.extend(import_stmt.desugar(None));
     }
 
-    fn push_module_decl(&mut self, mod_name: Ident) {
-        self.module_decls.push(mod_name);
+    fn push_module_decl(&mut self, mod_decl: ModuleDeclaration) {
+        self.module_decls.push(mod_decl);
     }
 
     fn push_submodule(&mut self, submodule: SortedSubModule) {
@@ -474,7 +474,7 @@ impl std::fmt::Display for TopLevelStatement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             TopLevelStatement::Function(fun) => fun.fmt(f),
-            TopLevelStatement::Module(m) => write!(f, "mod {m}"),
+            TopLevelStatement::Module(m) => m.fmt(f),
             TopLevelStatement::Import(tree) => write!(f, "use {tree}"),
             TopLevelStatement::Trait(t) => t.fmt(f),
             TopLevelStatement::TraitImpl(i) => i.fmt(f),
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 75f4a6359bf..383a1ffafc9 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -40,9 +40,9 @@ use crate::parser::{force, ignore_then_commit, statement_recovery};
 use crate::token::{Keyword, Token, TokenKind};
 use crate::{
     BinaryOp, BinaryOpKind, BlockExpression, Distinctness, ForLoopStatement, ForRange,
-    FunctionReturnType, Ident, IfExpression, InfixExpression, LValue, Literal, NoirTypeAlias,
-    Param, Path, Pattern, Recoverable, Statement, TraitBound, TypeImpl, UnresolvedTraitConstraint,
-    UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
+    FunctionReturnType, Ident, IfExpression, InfixExpression, LValue, Literal, ModuleDeclaration,
+    NoirTypeAlias, Param, Path, Pattern, Recoverable, Statement, TraitBound, TypeImpl,
+    UnresolvedTraitConstraint, UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
 };
 
 use chumsky::prelude::*;
@@ -370,7 +370,9 @@ fn optional_type_annotation<'a>() -> impl NoirParser<UnresolvedType> + 'a {
 }
 
 fn module_declaration() -> impl NoirParser<TopLevelStatement> {
-    keyword(Keyword::Mod).ignore_then(ident()).map(TopLevelStatement::Module)
+    keyword(Keyword::Mod)
+        .ignore_then(ident())
+        .map(|ident| TopLevelStatement::Module(ModuleDeclaration { ident }))
 }
 
 fn use_statement() -> impl NoirParser<TopLevelStatement> {

From 8a5359c012579e54c2766de1074482a36ecada32 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 7 Mar 2024 16:01:08 -0600
Subject: [PATCH 053/416] fix: Allow type aliases in main (#4505)

# Description

## Problem\*

Resolves #4500

## Summary\*

This was due to this check
https://github.com/noir-lang/noir/blob/master/compiler/noirc_frontend/src/hir_def/types.rs#L706-L709
which was needed since we checked if types were valid for main during
name resolution - which is before we know type aliases are not cyclic.
I've moved this check to type checking instead.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/resolution/errors.rs              |  5 --
 .../src/hir/resolution/resolver.rs            | 88 +------------------
 .../src/hir/type_check/errors.rs              |  5 ++
 .../noirc_frontend/src/hir/type_check/mod.rs  | 20 ++++-
 .../noirc_frontend/src/hir_def/function.rs    |  4 +
 compiler/noirc_frontend/src/hir_def/types.rs  |  8 +-
 compiler/noirc_frontend/src/tests.rs          |  9 ++
 7 files changed, 42 insertions(+), 97 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index d2fe67da38c..1049599f079 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -80,8 +80,6 @@ pub enum ResolverError {
     PrivateFunctionCalled { name: String, span: Span },
     #[error("{name} is not visible from the current crate")]
     NonCrateFunctionCalled { name: String, span: Span },
-    #[error("Only sized types may be used in the entry point to a program")]
-    InvalidTypeForEntryPoint { span: Span },
     #[error("Nested slices are not supported")]
     NestedSlices { span: Span },
     #[error("#[recursive] attribute is only allowed on entry points to a program")]
@@ -309,9 +307,6 @@ impl From<ResolverError> for Diagnostic {
             ResolverError::NonCrateFunctionCalled { span, name } => Diagnostic::simple_warning(
                     format!("{name} is not visible from the current crate"),
                     format!("{name} is only visible within its crate"), span),
-            ResolverError::InvalidTypeForEntryPoint { span } => Diagnostic::simple_error(
-                "Only sized types may be used in the entry point to a program".to_string(),
-                "Slices, references, or any type containing them may not be used in main or a contract function".to_string(), span),
             ResolverError::NestedSlices { span } => Diagnostic::simple_error(
                 "Nested slices are not supported".into(),
                 "Try to use a constant sized array instead".into(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 7789c06ca69..322891f0ae9 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -911,10 +911,6 @@ impl<'a> Resolver<'a> {
                 });
             }
 
-            if self.is_entry_point_function(func) {
-                self.verify_type_valid_for_program_input(&typ);
-            }
-
             let pattern = self.resolve_pattern(pattern, DefinitionKind::Local(None));
             let typ = self.resolve_type_inner(typ, &mut generics);
 
@@ -991,6 +987,7 @@ impl<'a> Resolver<'a> {
             return_distinctness: func.def.return_distinctness,
             has_body: !func.def.body.is_empty(),
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
+            is_entry_point: self.is_entry_point_function(func),
         }
     }
 
@@ -2003,89 +2000,6 @@ impl<'a> Resolver<'a> {
         }
         HirLiteral::FmtStr(str, fmt_str_idents)
     }
-
-    /// Only sized types are valid to be used as main's parameters or the parameters to a contract
-    /// function. If the given type is not sized (e.g. contains a slice or NamedGeneric type), an
-    /// error is issued.
-    fn verify_type_valid_for_program_input(&mut self, typ: &UnresolvedType) {
-        match &typ.typ {
-            UnresolvedTypeData::FieldElement
-            | UnresolvedTypeData::Integer(_, _)
-            | UnresolvedTypeData::Bool
-            | UnresolvedTypeData::Unit
-            | UnresolvedTypeData::Error => (),
-
-            UnresolvedTypeData::MutableReference(_)
-            | UnresolvedTypeData::Function(_, _, _)
-            | UnresolvedTypeData::FormatString(_, _)
-            | UnresolvedTypeData::TraitAsType(..)
-            | UnresolvedTypeData::Unspecified => {
-                let span = typ.span.expect("Function parameters should always have spans");
-                self.push_err(ResolverError::InvalidTypeForEntryPoint { span });
-            }
-
-            UnresolvedTypeData::Array(length, element) => {
-                if let Some(length) = length {
-                    self.verify_type_expression_valid_for_program_input(length);
-                } else {
-                    let span = typ.span.expect("Function parameters should always have spans");
-                    self.push_err(ResolverError::InvalidTypeForEntryPoint { span });
-                }
-                self.verify_type_valid_for_program_input(element);
-            }
-            UnresolvedTypeData::Expression(expression) => {
-                self.verify_type_expression_valid_for_program_input(expression);
-            }
-            UnresolvedTypeData::String(length) => {
-                if let Some(length) = length {
-                    self.verify_type_expression_valid_for_program_input(length);
-                } else {
-                    let span = typ.span.expect("Function parameters should always have spans");
-                    self.push_err(ResolverError::InvalidTypeForEntryPoint { span });
-                }
-            }
-            UnresolvedTypeData::Named(path, generics, _) => {
-                // Since the type is named, we need to resolve it to see what it actually refers to
-                // in order to check whether it is valid. Since resolving it may lead to a
-                // resolution error, we have to truncate our error count to the previous count just
-                // in case. This is to ensure resolution errors are not issued twice when this type
-                // is later resolved properly.
-                let error_count = self.errors.len();
-                let resolved = self.resolve_named_type(path.clone(), generics.clone(), &mut vec![]);
-                self.errors.truncate(error_count);
-
-                if !resolved.is_valid_for_program_input() {
-                    let span = typ.span.expect("Function parameters should always have spans");
-                    self.push_err(ResolverError::InvalidTypeForEntryPoint { span });
-                }
-            }
-            UnresolvedTypeData::Tuple(elements) => {
-                for element in elements {
-                    self.verify_type_valid_for_program_input(element);
-                }
-            }
-            UnresolvedTypeData::Parenthesized(typ) => self.verify_type_valid_for_program_input(typ),
-        }
-    }
-
-    fn verify_type_expression_valid_for_program_input(&mut self, expr: &UnresolvedTypeExpression) {
-        match expr {
-            UnresolvedTypeExpression::Constant(_, _) => (),
-            UnresolvedTypeExpression::Variable(path) => {
-                let error_count = self.errors.len();
-                let resolved = self.resolve_named_type(path.clone(), vec![], &mut vec![]);
-                self.errors.truncate(error_count);
-
-                if !resolved.is_valid_for_program_input() {
-                    self.push_err(ResolverError::InvalidTypeForEntryPoint { span: path.span() });
-                }
-            }
-            UnresolvedTypeExpression::BinaryOperation(lhs, _, rhs, _) => {
-                self.verify_type_expression_valid_for_program_input(lhs);
-                self.verify_type_expression_valid_for_program_input(rhs);
-            }
-        }
-    }
 }
 
 /// Gives an error if a user tries to create a mutable reference
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 96d30100d8b..cba2400441f 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -122,6 +122,8 @@ pub enum TypeCheckError {
     ConstrainedReferenceToUnconstrained { span: Span },
     #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
     UnconstrainedSliceReturnToConstrained { span: Span },
+    #[error("Only sized types may be used in the entry point to a program")]
+    InvalidTypeForEntryPoint { span: Span },
 }
 
 impl TypeCheckError {
@@ -284,6 +286,9 @@ impl From<TypeCheckError> for Diagnostic {
                 let msg = format!("Constraint for `{typ}: {trait_name}` is not needed, another matching impl is already in scope");
                 Diagnostic::simple_warning(msg, "Unnecessary trait constraint in where clause".into(), span)
             }
+            TypeCheckError::InvalidTypeForEntryPoint { span } => Diagnostic::simple_error(
+                "Only sized types may be used in the entry point to a program".to_string(),
+                "Slices, references, or any type containing them may not be used in main or a contract function".to_string(), span),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 21d1c75a0f2..aab793ec867 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -14,7 +14,7 @@ mod stmt;
 pub use errors::TypeCheckError;
 
 use crate::{
-    hir_def::{expr::HirExpression, stmt::HirStatement, traits::TraitConstraint},
+    hir_def::{expr::HirExpression, function::Param, stmt::HirStatement, traits::TraitConstraint},
     node_interner::{ExprId, FuncId, GlobalId, NodeInterner},
     Type,
 };
@@ -74,6 +74,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     // This is locally obvious, but it must be bound here so that the
     // Definition object of the parameter in the NodeInterner is given the correct type.
     for param in parameters {
+        check_if_type_is_valid_for_program_input(&type_checker, func_id, &param, &mut errors);
         type_checker.bind_pattern(&param.0, param.1);
     }
 
@@ -143,6 +144,22 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     errors
 }
 
+/// Only sized types are valid to be used as main's parameters or the parameters to a contract
+/// function. If the given type is not sized (e.g. contains a slice or NamedGeneric type), an
+/// error is issued.
+fn check_if_type_is_valid_for_program_input(
+    type_checker: &TypeChecker<'_>,
+    func_id: FuncId,
+    param: &Param,
+    errors: &mut Vec<TypeCheckError>,
+) {
+    let meta = type_checker.interner.function_meta(&func_id);
+    if meta.is_entry_point && !param.1.is_valid_for_program_input() {
+        let span = param.0.span();
+        errors.push(TypeCheckError::InvalidTypeForEntryPoint { span });
+    }
+}
+
 fn function_info(interner: &NodeInterner, function_body_id: &ExprId) -> (noirc_errors::Span, bool) {
     let (expr_span, empty_function) =
         if let HirExpression::Block(block) = interner.expression(function_body_id) {
@@ -329,6 +346,7 @@ mod test {
             trait_impl: None,
             return_type: FunctionReturnType::Default(Span::default()),
             trait_constraints: Vec::new(),
+            is_entry_point: true,
         };
         interner.push_fn_meta(func_meta, func_id);
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index d3ab2a9393b..82bbe1aa5b6 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -112,6 +112,10 @@ pub struct FuncMeta {
 
     /// The trait impl this function belongs to, if any
     pub trait_impl: Option<TraitImplId>,
+
+    /// True if this function is an entry point to the program.
+    /// For non-contracts, this means the function is `main`.
+    pub is_entry_point: bool,
 }
 
 impl FuncMeta {
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 13fa41733cf..5ab036eef5b 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -703,10 +703,10 @@ impl Type {
             | Type::TraitAsType(..)
             | Type::NotConstant => false,
 
-            // This function is called during name resolution before we've verified aliases
-            // are not cyclic. As a result, it wouldn't be safe to check this alias' definition
-            // to see if the aliased type is valid.
-            Type::Alias(..) => false,
+            Type::Alias(alias, generics) => {
+                let alias = alias.borrow();
+                alias.get_type(generics).is_valid_for_program_input()
+            }
 
             Type::Array(length, element) => {
                 length.is_valid_for_program_input() && element.is_valid_for_program_input()
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 0c8c677d9af..9be6252b10a 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1206,4 +1206,13 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         "#;
         assert_eq!(get_program_errors(src).len(), 1);
     }
+
+    #[test]
+    fn type_aliases_in_entry_point() {
+        let src = r#"
+            type Foo = u8;
+            fn main(_x: Foo) {}
+        "#;
+        assert_eq!(get_program_errors(src).len(), 0);
+    }
 }

From b60279bd4107cab04d95e0a59caecd4910228eeb Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 7 Mar 2024 22:10:41 +0000
Subject: [PATCH 054/416] chore: update various dependencies (#4513)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                 | 243 ++++++++++-----------
 acvm-repo/bn254_blackbox_solver/Cargo.toml |   4 +-
 2 files changed, 116 insertions(+), 131 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 18c1f7ad40e..317418276b1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -391,7 +391,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138985dd8aefbefeaa66b01b7f5b2b6b4c333fcef1cc5f32c63a2aabe37d6de3"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "lsp-types 0.94.1",
  "pin-project-lite",
  "rustix",
@@ -521,9 +521,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.3.3"
+version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630be753d4e58660abd17930c71b647fe46c27ea6b63cc59e1e3851406972e42"
+checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
 
 [[package]]
 name = "bitmaps"
@@ -947,14 +947,14 @@ checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335"
 
 [[package]]
 name = "console"
-version = "0.15.7"
+version = "0.15.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
 dependencies = [
  "encode_unicode 0.3.6",
  "lazy_static",
  "libc",
- "windows-sys 0.45.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1585,12 +1585,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.5"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1743,9 +1743,9 @@ checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
 
 [[package]]
 name = "futures"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1758,9 +1758,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1768,15 +1768,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1786,15 +1786,15 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1803,21 +1803,21 @@ dependencies = [
 
 [[package]]
 name = "futures-sink"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
 
 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
 
 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
 dependencies = [
  "futures 0.1.31",
  "futures-channel",
@@ -2076,9 +2076,9 @@ checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
 [[package]]
 name = "hyper"
-version = "0.14.27"
+version = "0.14.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468"
+checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -2091,7 +2091,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.4.9",
+ "socket2",
  "tokio",
  "tower-service",
  "tracing",
@@ -2100,9 +2100,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http",
@@ -2343,7 +2343,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2b99d4207e2a04fb4581746903c2bb7eb376f88de9c699d0f3e10feeac0cd3a"
 dependencies = [
  "derive_more",
- "futures 0.3.28",
+ "futures 0.3.30",
  "jsonrpc-core",
  "jsonrpc-pubsub",
  "log",
@@ -2358,7 +2358,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "futures-executor",
  "futures-util",
  "log",
@@ -2373,7 +2373,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b51da17abecbdab3e3d4f26b01c5ec075e88d3abe3ab3b05dc9aa69392764ec0"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "jsonrpc-client-transports",
 ]
 
@@ -2395,7 +2395,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1dea6e07251d9ce6a552abfb5d7ad6bc290a4596c8dcc3d795fae2bbdc1f3ff"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "hyper",
  "jsonrpc-core",
  "jsonrpc-server-utils",
@@ -2411,7 +2411,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240f87695e6c6f62fb37f05c02c04953cf68d6408b8c1c89de85c7a0125b1011"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "jsonrpc-core",
  "lazy_static",
  "log",
@@ -2427,7 +2427,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4fdea130485b572c39a460d50888beb00afb3e35de23ccd7fad8ff19f0e0d4"
 dependencies = [
  "bytes",
- "futures 0.3.28",
+ "futures 0.3.30",
  "globset",
  "jsonrpc-core",
  "lazy_static",
@@ -2485,9 +2485,9 @@ checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.3"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09fc20d2ca12cb9f044c93e3bd6d32d523e6e2ec3db4f7b2939cd99026ecd3f0"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
 
 [[package]]
 name = "lock_api"
@@ -3451,7 +3451,7 @@ checksum = "7c003ac8c77cb07bb74f5f198bce836a689bcd5a42574612bf14d17bfd08c20e"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.3.3",
+ "bitflags 2.4.2",
  "lazy_static",
  "num-traits",
  "rand 0.8.5",
@@ -3913,15 +3913,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.4"
+version = "0.38.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a962918ea88d644592894bc6dc55acc6c0956488adcebbfb6e273506b7fd6e5"
+checksum = "72e572a5e8ca657d7366229cdde4bd14c4eb5499a9573d4d366fe1b599daa316"
 dependencies = [
- "bitflags 2.3.3",
+ "bitflags 2.4.2",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4292,9 +4292,9 @@ dependencies = [
 
 [[package]]
 name = "shared-buffer"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cf61602ee61e2f83dd016b3e6387245291cf728ea071c378b35088125b4d995"
+checksum = "f6c99835bad52957e7aa241d3975ed17c1e5f8c92026377d117a606f36b84b16"
 dependencies = [
  "bytes",
  "memmap2 0.6.2",
@@ -4412,16 +4412,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "socket2"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
-dependencies = [
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "socket2"
 version = "0.5.5"
@@ -4733,7 +4723,7 @@ dependencies = [
  "mio",
  "num_cpus",
  "pin-project-lite",
- "socket2 0.5.5",
+ "socket2",
  "tokio-macros",
  "windows-sys 0.48.0",
 ]
@@ -5249,9 +5239,9 @@ dependencies = [
 
 [[package]]
 name = "wasmer"
-version = "4.2.4"
+version = "4.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce45cc009177ca345a6d041f9062305ad467d15e7d41494f5b81ab46d62d7a58"
+checksum = "5c15724dc25d1ee57962334aea8e41ade2675e5ea2ac6b8d42da6051b0face66"
 dependencies = [
  "bytes",
  "cfg-if 1.0.0",
@@ -5265,23 +5255,23 @@ dependencies = [
  "shared-buffer",
  "target-lexicon",
  "thiserror",
+ "tracing",
  "wasm-bindgen",
  "wasmer-compiler",
  "wasmer-compiler-cranelift",
  "wasmer-derive",
  "wasmer-types",
  "wasmer-vm",
- "wasmparser 0.83.0",
- "wasmparser 0.95.0",
+ "wasmparser",
  "wat",
  "winapi",
 ]
 
 [[package]]
 name = "wasmer-compiler"
-version = "4.2.4"
+version = "4.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e044f6140c844602b920deb4526aea3cc9c0d7cf23f00730bb9b2034669f522a"
+checksum = "55a7f3b3a96f8d844c25e2c032af9572306dd63fa93dc17bcca4c5458ac569bd"
 dependencies = [
  "backtrace",
  "bytes",
@@ -5300,15 +5290,15 @@ dependencies = [
  "thiserror",
  "wasmer-types",
  "wasmer-vm",
- "wasmparser 0.95.0",
+ "wasmparser",
  "winapi",
 ]
 
 [[package]]
 name = "wasmer-compiler-cranelift"
-version = "4.2.4"
+version = "4.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32ce02358eb44a149d791c1d6648fb7f8b2f99cd55e3c4eef0474653ec8cc889"
+checksum = "102e2c5bacac69495c4025767e2fa26797ffb27f242dccb7cf57d9cefd944386"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
@@ -5325,9 +5315,9 @@ dependencies = [
 
 [[package]]
 name = "wasmer-derive"
-version = "4.2.4"
+version = "4.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c782d80401edb08e1eba206733f7859db6c997fc5a7f5fb44edc3ecd801468f6"
+checksum = "0ea737fa08f95d6abc4459f42a70a9833e8974b814e74971d77ef473814f4d4c"
 dependencies = [
  "proc-macro-error",
  "proc-macro2",
@@ -5337,9 +5327,9 @@ dependencies = [
 
 [[package]]
 name = "wasmer-types"
-version = "4.2.4"
+version = "4.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd09e80d4d74bb9fd0ce6c3c106b1ceba1a050f9948db9d9b78ae53c172d6157"
+checksum = "b0689110e291b0f07fc665f2824e5ff81df120848e8a9acfbf1a9bf7990773f9"
 dependencies = [
  "bytecheck",
  "enum-iterator",
@@ -5353,9 +5343,9 @@ dependencies = [
 
 [[package]]
 name = "wasmer-vm"
-version = "4.2.4"
+version = "4.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdcd8a4fd36414a7b6a003dbfbd32393bce3e155d715dd877c05c1b7a41d224d"
+checksum = "4cd41f822a1ac4242d478754e8ceba2806a00ea5072803622e1fe91e8e28b2a1"
 dependencies = [
  "backtrace",
  "cc",
@@ -5381,18 +5371,13 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.83.0"
+version = "0.121.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "718ed7c55c2add6548cca3ddd6383d738cd73b892df400e96b9aa876f0141d7a"
-
-[[package]]
-name = "wasmparser"
-version = "0.95.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ea896273ea99b15132414be1da01ab0d8836415083298ecaffbe308eaac87a"
+checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
 dependencies = [
- "indexmap 1.9.3",
- "url 2.4.0",
+ "bitflags 2.4.2",
+ "indexmap 2.0.0",
+ "semver",
 ]
 
 [[package]]
@@ -5485,15 +5470,6 @@ dependencies = [
  "windows_x86_64_msvc 0.33.0",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
-dependencies = [
- "windows-targets 0.42.2",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -5504,18 +5480,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.42.2"
+name = "windows-sys"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
+ "windows-targets 0.52.4",
 ]
 
 [[package]]
@@ -5534,10 +5504,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
+name = "windows-targets"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
+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",
+]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
@@ -5545,6 +5524,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.33.0"
@@ -5553,15 +5538,15 @@ checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.2"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -5571,15 +5556,15 @@ checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.42.2"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -5589,15 +5574,15 @@ checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.2"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -5607,27 +5592,27 @@ checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.42.2"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -5637,15 +5622,15 @@ checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.42.2"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
 
 [[package]]
 name = "winnow"
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index ea601a6b80f..a0a15409604 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -32,7 +32,7 @@ ark-ff = { version = "^0.4.0", default-features = false }
 num-bigint.workspace = true
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-wasmer = { version = "4.2.3", default-features = false, features = [
+wasmer = { version = "4.2.6", default-features = false, features = [
     "js-default",
 ] }
 
@@ -42,7 +42,7 @@ js-sys.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 getrandom.workspace = true
-wasmer = "4.2.3"
+wasmer = "4.2.6"
 
 [build-dependencies]
 pkg-config = "0.3"

From 9cee413b73298df98a5650bf3d05121213e982e2 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Fri, 8 Mar 2024 17:02:25 +0100
Subject: [PATCH 055/416] chore: custom hash for eddsa (#4440)

# Description

## Problem\*

Resolves #3642

## Summary\*

Eddsa verification takes now a hasher so that it can be used with
anything having the Hasher trait.
I added this trait to the stdlib implementations of mimc, poseidon and
poseidon2.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../cryptographic_primitives/eddsa.mdx        |  8 ++
 noir_stdlib/src/eddsa.nr                      | 31 +++++++-
 noir_stdlib/src/hash/mimc.nr                  | 50 ++++++++++--
 noir_stdlib/src/hash/poseidon.nr              | 76 +++++++++++++++++++
 noir_stdlib/src/hash/poseidon2.nr             | 39 +++++++++-
 .../execution_success/eddsa/src/main.nr       | 10 ++-
 .../poseidon_bn254_hash/src/main.nr           |  2 +-
 7 files changed, 202 insertions(+), 14 deletions(-)

diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
index 99b7f830a20..c2c0624dfad 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -15,6 +15,14 @@ Verifier for EdDSA signatures
 fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
 ```
 
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
 <BlackBoxInfo />
 
 ## eddsa::eddsa_to_pub
diff --git a/noir_stdlib/src/eddsa.nr b/noir_stdlib/src/eddsa.nr
index 966bc1da2a1..3aff6043ffd 100644
--- a/noir_stdlib/src/eddsa.nr
+++ b/noir_stdlib/src/eddsa.nr
@@ -1,6 +1,8 @@
 use crate::hash::poseidon;
 use crate::ec::consts::te::baby_jubjub;
 use crate::ec::tecurve::affine::Point as TEPoint;
+use crate::hash::{Hash, Hasher, BuildHasher, BuildHasherDefault};
+use crate::hash::poseidon::PoseidonHasher;
 
 // Returns true if signature is valid
 pub fn eddsa_poseidon_verify(
@@ -11,6 +13,28 @@ pub fn eddsa_poseidon_verify(
     signature_r8_y: Field,
     message: Field
 ) -> bool {
+    let mut hasher = PoseidonHasher::default();
+    eddsa_verify_with_hasher(
+        pub_key_x,
+        pub_key_y,
+        signature_s,
+        signature_r8_x,
+        signature_r8_y,
+        message,
+        &mut hasher
+    )
+}
+
+pub fn eddsa_verify_with_hasher<H>(
+    pub_key_x: Field,
+    pub_key_y: Field,
+    signature_s: Field,
+    signature_r8_x: Field,
+    signature_r8_y: Field,
+    message: Field,
+    hasher: &mut H
+) -> bool 
+where H: Hasher {
     // Verifies by testing:
     // S * B8 = R8 + H(R8, A, m) * A8
     let bjj = baby_jubjub();
@@ -23,7 +47,12 @@ pub fn eddsa_poseidon_verify(
     // Ensure S < Subgroup Order
     assert(signature_s.lt(bjj.suborder));
     // Calculate the h = H(R, A, msg)
-    let hash: Field = poseidon::bn254::hash_5([signature_r8_x, signature_r8_y, pub_key_x, pub_key_y, message]);
+    signature_r8_x.hash(hasher);
+    signature_r8_y.hash(hasher);
+    pub_key_x.hash(hasher);
+    pub_key_y.hash(hasher);
+    message.hash(hasher);
+    let hash: Field = (*hasher).finish();
     // Calculate second part of the right side:  right2 = h*8*A
     // Multiply by 8 by doubling 3 times. This also ensures that the result is in the subgroup.
     let pub_key_mul_2 = bjj.curve.add(pub_key, pub_key);
diff --git a/noir_stdlib/src/hash/mimc.nr b/noir_stdlib/src/hash/mimc.nr
index 10c0a48917c..db8a32d7909 100644
--- a/noir_stdlib/src/hash/mimc.nr
+++ b/noir_stdlib/src/hash/mimc.nr
@@ -1,3 +1,6 @@
+use crate::hash::Hasher;
+use crate::default::Default;
+
 // mimc-p/p implementation
 // constants are (publicly generated) random numbers, for instance using keccak as a ROM.
 // You must use constants generated for the native field
@@ -16,13 +19,8 @@ fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp: Field) -> Field {
 }
 
 global MIMC_BN254_ROUNDS = 91;
-//mimc implementation with hardcoded parameters for BN254 curve.
-#[field(bn254)]
-pub fn mimc_bn254<N>(array: [Field; N]) -> Field {
-    //mimc parameters
-    let exponent = 7;
-    //generated from seed "mimc" using keccak256 
-    let constants: [Field; MIMC_BN254_ROUNDS] = [
+//generated from seed "mimc" using keccak256 
+global MIMC_BN254_CONSTANTS: [Field; MIMC_BN254_ROUNDS] = [
         0,
         20888961410941983456478427210666206549300505294776164667214940546594746570981,
         15265126113435022738560151911929040668591755459209400716467504685752745317193,
@@ -116,10 +114,46 @@ pub fn mimc_bn254<N>(array: [Field; N]) -> Field {
         13602139229813231349386885113156901793661719180900395818909719758150455500533
     ];
 
+//mimc implementation with hardcoded parameters for BN254 curve.
+#[field(bn254)]
+pub fn mimc_bn254<N>(array: [Field; N]) -> Field {
+    let exponent = 7;
     let mut r = 0;
     for elem in array {
-        let h = mimc(elem, r, constants, exponent);
+        let h = mimc(elem, r, MIMC_BN254_CONSTANTS, exponent);
         r = r + elem + h;
     }
     r
 }
+
+struct MimcHasher{
+    _state: [Field],
+    _len: u64,
+}
+
+impl Hasher for MimcHasher {
+    #[field(bn254)]
+    fn finish(self) -> Field {
+        let exponent = 7;
+        let mut r = 0;
+        for i in 0..self._len {
+            let h = mimc(self._state[i], r, MIMC_BN254_CONSTANTS, exponent);
+            r = r + self._state[i] + h;
+        }
+        r
+    }
+
+    fn write(&mut self, input: [Field]){
+        self._state = self._state.append(input);
+        self._len += input.len();
+    }
+}
+
+impl Default for MimcHasher{
+    fn default() -> Self{
+        MimcHasher{
+            _state: [],
+            _len: 0,
+        }
+    }
+}
diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr
index b1a7c4a2367..7f99ad36316 100644
--- a/noir_stdlib/src/hash/poseidon.nr
+++ b/noir_stdlib/src/hash/poseidon.nr
@@ -1,5 +1,7 @@
 mod bn254; // Instantiations of Poseidon for prime field of the same order as BN254
 use crate::field::modulus_num_bits;
+use crate::hash::Hasher;
+use crate::default::Default;
 
 struct PoseidonConfig<M,N> {
     t: Field, // Width, i.e. state size
@@ -100,3 +102,77 @@ fn apply_matrix<N, M>(a: [Field; M], x: [Field; N]) -> [Field; N] {
 
     y
 }
+
+struct PoseidonHasher{
+    _state: [Field],
+    _len: u64,
+}
+
+impl Hasher for PoseidonHasher {
+    #[field(bn254)]
+    fn finish(self) -> Field {
+        let mut result = 0;
+        assert(self._len < 16);
+        if self._len == 1 {
+            result = bn254::hash_1([self._state[0]]);
+        } 
+        if self._len == 2 {
+            result = bn254::hash_2([self._state[0],self._state[1]]);
+        } 
+        if self._len == 3 {
+            result = bn254::hash_3([self._state[0],self._state[1],self._state[2]]);
+        } 
+        if self._len == 4 {
+            result = bn254::hash_4([self._state[0],self._state[1],self._state[2],self._state[3]]);
+        } 
+        if self._len == 5 {
+            result = bn254::hash_5([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4]]);
+        }
+        if self._len == 6 {
+            result = bn254::hash_6([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5]]);
+        }
+        if self._len == 7 {
+            result = bn254::hash_7([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6]]);
+        }
+        if self._len == 8 {
+            result = bn254::hash_8([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7]]);
+        }
+        if self._len == 9 {
+            result = bn254::hash_9([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8]]);
+        }
+        if self._len == 10 {
+            result = bn254::hash_10([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9]]);
+        }
+        if self._len == 11 {
+            result = bn254::hash_11([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10]]);
+        }
+        if self._len == 12 {
+            result = bn254::hash_12([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11]]);
+        }
+        if self._len == 13 {
+            result = bn254::hash_13([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12]]);
+        }
+        if self._len == 14 {
+            result = bn254::hash_14([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12], self._state[13]]);
+        }
+        if self._len == 15 {
+            result = bn254::hash_15([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12], self._state[13], self._state[14]]);
+        }
+        
+        result
+    }
+
+    fn write(&mut self, input: [Field]){
+        self._state = self._state.append(input);
+        self._len += input.len();
+    }
+}
+
+impl Default for PoseidonHasher{
+    fn default() -> Self{
+        PoseidonHasher{
+            _state: [],
+            _len: 0,
+        }
+    }
+}
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 40eea029e82..52229f18dbd 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -1,3 +1,6 @@
+use crate::hash::Hasher;
+use crate::default::Default;
+
 global RATE = 3;
 
 struct Poseidon2 {
@@ -9,7 +12,7 @@ struct Poseidon2 {
 
 impl Poseidon2 {
 
-    pub fn hash<N>(input: [Field; N], message_size: u32) -> Field {
+    pub fn hash<N>(input: [Field; N], message_size: u64) -> Field {
         if message_size == N {
             Poseidon2::hash_internal(input, N, false)
         } else {
@@ -92,12 +95,12 @@ impl Poseidon2 {
         result
     }
 
-    fn hash_internal<N>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
+    fn hash_internal<N>(input: [Field; N], in_len: u64, is_variable_length: bool) -> Field {
         let two_pow_64 = 18446744073709551616;
         let iv : Field = (in_len as Field) * two_pow_64;
         let mut sponge = Poseidon2::new(iv);
         for i in 0..input.len() {
-            if i as u32 < in_len {
+            if i < in_len {
                 sponge.absorb(input[i]);
             }
         }
@@ -111,3 +114,33 @@ impl Poseidon2 {
         sponge.squeeze()
     }
 }
+
+struct Poseidon2Hasher{
+    _state: [Field],
+    _len: u64,
+}
+
+impl Hasher for Poseidon2Hasher {
+    fn finish(self) -> Field {
+        let iv : Field = (self._state.len() as Field)*18446744073709551616;    // iv = (self._state.len() << 64)
+        let mut sponge = Poseidon2::new(iv);
+        for i in 0..self._len {
+            sponge.absorb(self._state[i]);
+        }
+        sponge.squeeze()
+    }
+
+    fn write(&mut self, input: [Field]){
+        self._state = self._state.append(input);
+        self._len += input.len();
+    }
+}
+
+impl Default for Poseidon2Hasher{
+    fn default() -> Self{
+        Poseidon2Hasher{
+            _state: [],
+            _len: 0,
+        }
+    }
+}
diff --git a/test_programs/execution_success/eddsa/src/main.nr b/test_programs/execution_success/eddsa/src/main.nr
index 4404ffe75f7..fd1a95ee5fb 100644
--- a/test_programs/execution_success/eddsa/src/main.nr
+++ b/test_programs/execution_success/eddsa/src/main.nr
@@ -2,7 +2,9 @@ use dep::std::compat;
 use dep::std::ec::consts::te::baby_jubjub;
 use dep::std::ec::tecurve::affine::Point as TEPoint;
 use dep::std::hash;
-use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify};
+use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify_with_hasher};
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+use dep::std::hash::pedersen::PedersenHasher;
 
 fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
     // Skip this test for non-bn254 backends
@@ -48,5 +50,11 @@ fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
         assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_b, r8_b.x, r8_b.y, msg));
         // User A's signature over the message can't be used with another message
         assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg + 1));
+        // Using a different hash should fail
+        let mut hasher = Poseidon2Hasher::default();
+        assert(!eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher));
+        // Using a different hash should fail
+        let mut hasher = PedersenHasher::default();
+        assert(!eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher));
     }
 }
diff --git a/test_programs/execution_success/poseidon_bn254_hash/src/main.nr b/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
index 939b99595c7..a1607956190 100644
--- a/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
+++ b/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
@@ -9,7 +9,7 @@ fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field
     let hash2 = poseidon::bn254::hash_4(x2);
     assert(hash2 == y2);
 
-    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len() as u32);
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
     assert(hash3 == y3);
 }
 // docs:end:poseidon

From 66f22aab1f0a0e9dc970e32e54c28f12fb39ea8f Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 8 Mar 2024 14:03:13 -0600
Subject: [PATCH 056/416] chore: Add HashMap docs (#4457)

# Description

## Problem\*

## Summary\*

Adds docs for https://github.com/noir-lang/noir/pull/4242

I've also edited the interface for `entries`, `keys`, and `values` to
return `BoundedVec`s instead of arrays with optional elements. This is
much more natural I think. I originally intended this for a separate PR,
but I didn't want to write documentation for the old version of these
functions only to immediately have to edit them afterward.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../standard_library/containers/hashmap.md    | 270 ++++++++++++++++++
 noir_stdlib/src/collections/map.nr            | 112 +++++---
 .../execution_success/hashmap/src/main.nr     | 182 +++++++++++-
 .../execution_success/hashmap/src/utils.nr    |  12 +-
 4 files changed, 517 insertions(+), 59 deletions(-)
 create mode 100644 docs/docs/noir/standard_library/containers/hashmap.md

diff --git a/docs/docs/noir/standard_library/containers/hashmap.md b/docs/docs/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..093b6d38d11
--- /dev/null
+++ b/docs/docs/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,270 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a pedersen hash
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Pedersen>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+#include_code default noir_stdlib/src/collections/map.nr rust
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+#include_code default_example test_programs/execution_success/hashmap/src/main.nr rust
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+#include_code type_alias test_programs/execution_success/hashmap/src/main.nr rust
+
+### with_hasher
+
+#include_code with_hasher noir_stdlib/src/collections/map.nr rust
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+#include_code with_hasher_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### get
+
+#include_code get noir_stdlib/src/collections/map.nr rust
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+#include_code get_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### insert
+
+#include_code insert noir_stdlib/src/collections/map.nr rust
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+#include_code insert_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### remove
+
+#include_code remove noir_stdlib/src/collections/map.nr rust
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+#include_code remove_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### is_empty
+
+#include_code is_empty noir_stdlib/src/collections/map.nr rust
+
+True if the length of the hash map is empty.
+
+Example:
+
+#include_code is_empty_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### len
+
+#include_code len noir_stdlib/src/collections/map.nr rust
+
+Returns the current length of this hash map.
+
+Example:
+
+#include_code len_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### capacity
+
+#include_code capacity noir_stdlib/src/collections/map.nr rust
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+#include_code capacity_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### clear
+
+#include_code clear noir_stdlib/src/collections/map.nr rust
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+#include_code clear_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### contains_key
+
+#include_code contains_key noir_stdlib/src/collections/map.nr rust
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+#include_code contains_key_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### entries
+
+#include_code entries noir_stdlib/src/collections/map.nr rust
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+#include_code entries_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### keys
+
+#include_code keys noir_stdlib/src/collections/map.nr rust
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+#include_code keys_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### values
+
+#include_code values noir_stdlib/src/collections/map.nr rust
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+#include_code values_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### iter_mut
+
+#include_code iter_mut noir_stdlib/src/collections/map.nr rust
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+#include_code iter_mut_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### iter_keys_mut
+
+#include_code iter_keys_mut noir_stdlib/src/collections/map.nr rust
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+#include_code iter_keys_mut_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### iter_values_mut
+
+#include_code iter_values_mut noir_stdlib/src/collections/map.nr rust
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+#include_code iter_values_mut_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### retain
+
+#include_code retain noir_stdlib/src/collections/map.nr rust
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+#include_code retain_example test_programs/execution_success/hashmap/src/main.nr rust
+
+## Trait Implementations
+
+### default
+
+#include_code default noir_stdlib/src/collections/map.nr rust
+
+Constructs an empty HashMap.
+
+Example:
+
+#include_code default_example test_programs/execution_success/hashmap/src/main.nr rust
+
+### eq
+
+#include_code eq noir_stdlib/src/collections/map.nr rust
+
+Checks if two HashMaps are equal.
+
+Example:
+
+#include_code eq_example test_programs/execution_success/hashmap/src/main.nr rust
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index 056299b4238..2d76acf1f3a 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -3,6 +3,7 @@ use crate::collections::vec::Vec;
 use crate::option::Option;
 use crate::default::Default;
 use crate::hash::{Hash, Hasher, BuildHasher};
+use crate::collections::bounded_vec::BoundedVec;
 
 // We use load factor α_max = 0.75. 
 // Upon exceeding it, assert will fail in order to inform the user 
@@ -78,21 +79,26 @@ impl<K, V> Slot<K, V> {
 // it is very unlikely to be after - performance will be heavily degraded.
 impl<K, V, N, B, H> HashMap<K, V, N, B> {
     // Creates a new instance of HashMap with specified BuildHasher.
+    // docs:start:with_hasher
     pub fn with_hasher(_build_hasher: B) -> Self
     where
         B: BuildHasher<H> {
+        // docs:end:with_hasher
         let _table = [Slot::default(); N];
         let _len = 0;
         Self { _table, _len, _build_hasher }
     }
 
     // Clears the map, removing all key-value entries.
+    // docs:start:clear
     pub fn clear(&mut self) {
+        // docs:end:clear
         self._table = [Slot::default(); N];
         self._len = 0;
     }
 
     // Returns true if the map contains a value for the specified key.
+    // docs:start:contains_key
     pub fn contains_key(
         self,
         key: K
@@ -101,89 +107,80 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         K: Hash + Eq,
         B: BuildHasher<H>,
         H: Hasher {
+        // docs:end:contains_key
         self.get(key).is_some()
     }
 
     // Returns true if the map contains no elements.
+    // docs:start:is_empty
     pub fn is_empty(self) -> bool {
+        // docs:end:is_empty
         self._len == 0
     }
 
-    // Get the Option<(K, V) array of valid entries 
-    // with a length of map capacity. First len() elements 
-    // are safe to unwrap_unchecked(), whilst remaining 
-    // are guaranteed to be Option::none().
-    //
-    // This design is reasoned by compile-time limitations and
-    // temporary nested slices ban. 
-    pub fn entries(self) -> [Option<(K, V)>; N] {
-        let mut entries = [Option::none(); N];
-        let mut valid_amount = 0;
+    // Returns a BoundedVec of all valid entries in this HashMap.
+    // The length of the returned vector will always match the length of this HashMap.
+    // docs:start:entries
+    pub fn entries(self) -> BoundedVec<(K, V), N> {
+        // docs:end:entries
+        let mut entries = BoundedVec::new();
 
         for slot in self._table {
             if slot.is_valid() {
-                entries[valid_amount] = slot.key_value();
-                valid_amount += 1;
+                // SAFETY: slot.is_valid() should ensure there is a valid key-value pairing here
+                let key_value = slot.key_value().unwrap_unchecked();
+                entries.push(key_value);
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {valid_amount}.";
-        assert(valid_amount == self._len, msg);
+        let msg = f"Amount of valid elements should have been {self._len} times, but got {entries.len()}.";
+        assert(entries.len() == self._len, msg);
 
         entries
     }
 
-    // Get the Option<K> array of valid keys 
-    // with a length of map capacity. First len() elements 
-    // are safe to unwrap_unchecked(), whilst remaining 
-    // are guaranteed to be Option::none().
-    //
-    // This design is reasoned by compile-time limitations and
-    // temporary nested slices ban. 
-    pub fn keys(self) -> [Option<K>; N] {
-        let mut keys = [Option::none(); N];
-        let mut valid_amount = 0;
+    // Returns a BoundedVec containing all the keys within this HashMap.
+    // The length of the returned vector will always match the length of this HashMap.
+    // docs:start:keys
+    pub fn keys(self) -> BoundedVec<K, N> {
+        // docs:end:keys
+        let mut keys = BoundedVec::new();
 
         for slot in self._table {
             if slot.is_valid() {
                 let (key, _) = slot.key_value_unchecked();
-                keys[valid_amount] = Option::some(key);
-                valid_amount += 1;
+                keys.push(key);
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {valid_amount}.";
-        assert(valid_amount == self._len, msg);
+        let msg = f"Amount of valid elements should have been {self._len} times, but got {keys.len()}.";
+        assert(keys.len() == self._len, msg);
 
         keys
     }
 
-    // Get the Option<V> array of valid values 
-    // with a length of map capacity. First len() elements 
-    // are safe to unwrap_unchecked(), whilst remaining 
-    // are guaranteed to be Option::none().
-    //
-    // This design is reasoned by compile-time limitations and
-    // temporary nested slices ban. 
-    pub fn values(self) -> [Option<V>; N] {
-        let mut values = [Option::none(); N];
-        let mut valid_amount = 0;
+    // Returns a BoundedVec containing all the values within this HashMap.
+    // The length of the returned vector will always match the length of this HashMap.
+    // docs:start:values
+    pub fn values(self) -> BoundedVec<V, N> {
+        // docs:end:values
+        let mut values = BoundedVec::new();
 
         for slot in self._table {
             if slot.is_valid() {
                 let (_, value) = slot.key_value_unchecked();
-                values[valid_amount] = Option::some(value);
-                valid_amount += 1;
+                values.push(value);
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {valid_amount}.";
-        assert(valid_amount == self._len, msg);
+        let msg = f"Amount of valid elements should have been {self._len} times, but got {values.len()}.";
+        assert(values.len() == self._len, msg);
 
         values
     }
 
     // For each key-value entry applies mutator function.
+    // docs:start:iter_mut
     pub fn iter_mut(
         &mut self,
         f: fn(K, V) -> (K, V)
@@ -192,12 +189,13 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         K: Eq + Hash,
         B: BuildHasher<H>,
         H: Hasher {
+        // docs:end:iter_mut
         let mut entries = self.entries();
         let mut new_map = HashMap::with_hasher(self._build_hasher);
 
         for i in 0..N {
             if i < self._len {
-                let entry = entries[i].unwrap_unchecked();
+                let entry = entries.get_unchecked(i);
                 let (key, value) = f(entry.0, entry.1);
                 new_map.insert(key, value);
             }
@@ -207,6 +205,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     }
 
     // For each key applies mutator function.
+    // docs:start:iter_keys_mut
     pub fn iter_keys_mut(
         &mut self,
         f: fn(K) -> K
@@ -215,12 +214,13 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         K: Eq + Hash,
         B: BuildHasher<H>,
         H: Hasher {
+        // docs:end:iter_keys_mut
         let mut entries = self.entries();
         let mut new_map = HashMap::with_hasher(self._build_hasher);
 
         for i in 0..N {
             if i < self._len {
-                let entry = entries[i].unwrap_unchecked();
+                let entry = entries.get_unchecked(i);
                 let (key, value) = (f(entry.0), entry.1);
                 new_map.insert(key, value);
             }
@@ -230,7 +230,9 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     }
 
     // For each value applies mutator function.
+    // docs:start:iter_values_mut
     pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+        // docs:end:iter_values_mut
         for i in 0..N {
             let mut slot = self._table[i];
             if slot.is_valid() {
@@ -242,7 +244,9 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     }
 
     // Retains only the elements specified by the predicate.
+    // docs:start:retain
     pub fn retain(&mut self, f: fn(K, V) -> bool) {
+        // docs:end:retain
         for index in 0..N {
             let mut slot = self._table[index];
             if slot.is_valid() {
@@ -257,16 +261,21 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     }
 
     // Amount of active key-value entries.
+    // docs:start:len
     pub fn len(self) -> u64 {
+        // docs:end:len
         self._len
     }
 
     // Get the compile-time map capacity.
+    // docs:start:capacity
     pub fn capacity(_self: Self) -> u64 {
+        // docs:end:capacity
         N
     }
 
     // Get the value by key. If it does not exist, returns none().
+    // docs:start:get
     pub fn get(
         self,
         key: K
@@ -275,6 +284,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         K: Eq + Hash,
         B: BuildHasher<H>,
         H: Hasher {
+        // docs:end:get
         let mut result = Option::none();
 
         let hash = self.hash(key);
@@ -300,6 +310,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     }
 
     // Insert key-value entry. In case key was already present, value is overridden. 
+    // docs:start:insert
     pub fn insert(
         &mut self,
         key: K,
@@ -309,6 +320,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         K: Eq + Hash,
         B: BuildHasher<H>,
         H: Hasher {
+        // docs:end:insert
         self.assert_load_factor();
 
         let hash = self.hash(key);
@@ -340,7 +352,8 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         }
     }
 
-    // Remove key-value entry. If key is not present, HashMap remains unchanged.
+    // Removes a key-value entry. If key is not present, HashMap remains unchanged.
+    // docs:start:remove
     pub fn remove(
         &mut self,
         key: K
@@ -349,6 +362,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         K: Eq + Hash,
         B: BuildHasher<H>,
         H: Hasher {
+        // docs:end:remove
         let hash = self.hash(key);
         let mut break = false;
 
@@ -409,6 +423,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
 // Equality class on HashMap has to test that they have 
 // equal sets of key-value entries, 
 // thus one is a subset of the other and vice versa.
+// docs:start:eq
 impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
 where
     K: Eq + Hash,
@@ -416,7 +431,8 @@ where
     B: BuildHasher<H>,
     H: Hasher
 {
-    fn eq(self, other: HashMap<K, V, N, B>) -> bool{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+// docs:end:eq
         let mut equal = false;
 
         if self.len() == other.len(){
@@ -443,12 +459,14 @@ where
     }
 }
 
+// docs:start:default
 impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
 where
     B: BuildHasher<H> + Default,
     H: Hasher + Default
 {
-    fn default() -> Self{
+    fn default() -> Self {
+// docs:end:default
         let _build_hasher = B::default();
         let map: HashMap<K, V, N, B> = HashMap::with_hasher(_build_hasher);
         map
diff --git a/test_programs/execution_success/hashmap/src/main.nr b/test_programs/execution_success/hashmap/src/main.nr
index 597a5c0b7de..4d2cbd45993 100644
--- a/test_programs/execution_success/hashmap/src/main.nr
+++ b/test_programs/execution_success/hashmap/src/main.nr
@@ -37,6 +37,8 @@ fn main(input: [Entry; HASHMAP_LEN]) {
     test_retain();
     test_iterators();
     test_mut_iterators();
+
+    doc_tests();
 }
 
 // Insert, get, remove.
@@ -154,9 +156,9 @@ fn test_iterators() {
     hashmap.insert(5, 7);
     hashmap.insert(11, 13);
 
-    let keys: [K; 3] = cut(hashmap.keys()).map(|k: Option<K>| k.unwrap_unchecked()).sort_via(K_CMP);
-    let values: [V; 3] = cut(hashmap.values()).map(|v: Option<V>| v.unwrap_unchecked()).sort_via(V_CMP);
-    let entries: [(K, V); 3] = cut(hashmap.entries()).map(|e: Option<(K, V)>| e.unwrap_unchecked()).sort_via(KV_CMP);
+    let keys: [K; 3] = cut(hashmap.keys()).sort_via(K_CMP);
+    let values: [V; 3] = cut(hashmap.values()).sort_via(V_CMP);
+    let entries: [(K, V); 3] = cut(hashmap.entries()).sort_via(KV_CMP);
 
     assert(keys == [2, 5, 11], "Got incorrect iteration of keys.");
     assert(values == [3, 7, 13], "Got incorrect iteration of values.");
@@ -177,8 +179,8 @@ fn test_mut_iterators() {
     let f = |v: V| -> V{ v * 5};
     hashmap.iter_values_mut(f);
 
-    let keys: [K; 3] = cut(hashmap.keys()).map(|k: Option<K>| k.unwrap_unchecked()).sort_via(K_CMP);
-    let values: [V; 3] = cut(hashmap.values()).map(|v: Option<V>| v.unwrap_unchecked()).sort_via(V_CMP);
+    let keys: [K; 3] = cut(hashmap.keys()).sort_via(K_CMP);
+    let values: [V; 3] = cut(hashmap.values()).sort_via(V_CMP);
 
     assert(keys == [6, 15, 33], f"Got incorrect iteration of keys: {keys}");
     assert(values == [15, 35, 65], "Got incorrect iteration of values.");
@@ -186,7 +188,175 @@ fn test_mut_iterators() {
     let f = |k: K, v: V| -> (K, V){(k * 2, v * 2)};
     hashmap.iter_mut(f);
 
-    let entries: [(K, V); 3] = cut(hashmap.entries()).map(|e: Option<(K, V)>| e.unwrap_unchecked()).sort_via(KV_CMP);
+    let entries: [(K, V); 3] = cut(hashmap.entries()).sort_via(KV_CMP);
 
     assert(entries == [(12, 30), (30, 70), (66, 130)], "Got incorrect iteration of entries.");
 }
+
+// docs:start:type_alias
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>>;
+// docs:end:type_alias
+
+/// Tests examples from the stdlib hashmap documentation
+fn doc_tests() {
+    // docs:start:default_example
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+    // docs:end:default_example
+
+    // docs:start:with_hasher_example
+    let my_hasher: BuildHasherDefault<PedersenHasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+    // docs:end:with_hasher_example
+
+    // docs:start:insert_example
+    let mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+    // docs:end:insert_example
+
+    get_example(map);
+
+    // docs:start:remove_example
+    map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+    // docs:end:remove_example
+
+    // docs:start:is_empty_example
+    assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+    // docs:end:is_empty_example
+
+    // docs:start:len_example
+    // This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+    // docs:end:len_example
+
+    // docs:start:capacity_example
+    let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+    // docs:end:capacity_example
+
+    // docs:start:clear_example
+    assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+    // docs:end:clear_example
+
+    // docs:start:contains_key_example
+    if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+    // docs:end:contains_key_example
+
+    entries_examples(map);
+    iter_examples(map);
+
+    // docs:start:retain_example
+    map.retain(|k, v| (k != 0) & (v != 0));
+    // docs:end:retain_example
+
+    // docs:start:eq_example
+    let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+    // docs:end:eq_example
+}
+
+// docs:start:get_example
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+// docs:end:get_example
+
+fn entries_examples(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+    // docs:start:entries_example
+    let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+    // docs:end:entries_example
+
+    // docs:start:keys_example
+    let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+    // docs:end:keys_example
+
+    // docs:start:values_example
+    let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+    // docs:end:values_example
+}
+
+fn iter_examples(mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+    // docs:start:iter_mut_example
+    // Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+    // docs:end:iter_mut_example
+
+    // docs:start:iter_keys_mut_example
+    // Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+    // docs:end:iter_keys_mut_example
+
+    // docs:start:iter_values_mut_example
+    // Halve each value
+    map.iter_values_mut(|v| v / 2);
+    // docs:end:iter_values_mut_example
+}
diff --git a/test_programs/execution_success/hashmap/src/utils.nr b/test_programs/execution_success/hashmap/src/utils.nr
index 45c9ca9bbf7..ee73245a902 100644
--- a/test_programs/execution_success/hashmap/src/utils.nr
+++ b/test_programs/execution_success/hashmap/src/utils.nr
@@ -1,10 +1,10 @@
-// Compile-time: cuts the M first elements from the [T; N] array.
-pub(crate) fn cut<T, N, M>(input: [T; N]) -> [T; M] {
-    assert(M as u64 < N as u64, "M should be less than N.");
+// Compile-time: cuts the M first elements from the BoundedVec<T, N>.
+pub(crate) fn cut<T, N, M>(input: BoundedVec<T, N>) -> [T; M] {
+    assert(M < N, "M should be less than N.");
 
-    let mut new = [dep::std::unsafe::zeroed(); M];
+    let mut new = BoundedVec::new();
     for i in 0..M {
-        new[i] = input[i];
+        new.push(input.get(i));
     }
-    new
+    new.storage()
 }

From f988d020e43cdf36a38613f2052d4518de39193a Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Fri, 8 Mar 2024 20:03:50 +0000
Subject: [PATCH 057/416] fix(ssa): Handle mergers of slices returned from
 calls (#4496)

# Description

## Problem\*

Resolves #4418

## Summary\*

We need to add handling for slices returned from `ToRadix` and `ToBits`.

~~This PR does two fixes.~~
EDIT: After moving to the iterative flattening appraoch w are now
accurately tracking slice capacities when they are the parameters of
blocks.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../ssa/opt/flatten_cfg/capacity_tracker.rs   | 32 ++++++++++++++++---
 .../execution_success/slices/src/main.nr      | 26 +++++++++++++++
 2 files changed, 53 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
index 7cd0fe3084e..bdfc04f0bbe 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
@@ -5,6 +5,7 @@ use crate::ssa::ir::{
     value::{Value, ValueId},
 };
 
+use acvm::FieldElement;
 use fxhash::FxHashMap as HashMap;
 
 pub(crate) struct SliceCapacityTracker<'a> {
@@ -62,21 +63,27 @@ impl<'a> SliceCapacityTracker<'a> {
                         | Intrinsic::SlicePushFront
                         | Intrinsic::SlicePopBack
                         | Intrinsic::SliceInsert
-                        | Intrinsic::SliceRemove => (1, 1),
+                        | Intrinsic::SliceRemove => (Some(1), 1),
                         // `pop_front` returns the popped element, and then the respective slice.
                         // This means in the case of a slice with structs, the result index of the popped slice
                         // will change depending on the number of elements in the struct.
                         // For example, a slice with four elements will look as such in SSA:
                         // v3, v4, v5, v6, v7, v8 = call slice_pop_front(v1, v2)
                         // where v7 is the slice length and v8 is the popped slice itself.
-                        Intrinsic::SlicePopFront => (1, results.len() - 1),
+                        Intrinsic::SlicePopFront => (Some(1), results.len() - 1),
+                        // The slice capacity of these intrinsics is not determined by the arguments of the function.
+                        Intrinsic::ToBits(_) | Intrinsic::ToRadix(_) => (None, 1),
                         _ => return,
                     };
-                    let slice_contents = arguments[argument_index];
+                    let result_slice = results[result_index];
                     match intrinsic {
                         Intrinsic::SlicePushBack
                         | Intrinsic::SlicePushFront
                         | Intrinsic::SliceInsert => {
+                            let argument_index = argument_index
+                                .expect("ICE: Should have an argument index for slice intrinsics");
+                            let slice_contents = arguments[argument_index];
+
                             for arg in &arguments[(argument_index + 1)..] {
                                 let element_typ = self.dfg.type_of_value(*arg);
                                 if element_typ.contains_slice_element() {
@@ -85,20 +92,35 @@ impl<'a> SliceCapacityTracker<'a> {
                             }
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
                                 let new_capacity = *contents_capacity + 1;
-                                slice_sizes.insert(results[result_index], new_capacity);
+                                slice_sizes.insert(result_slice, new_capacity);
                             }
                         }
                         Intrinsic::SlicePopBack
                         | Intrinsic::SliceRemove
                         | Intrinsic::SlicePopFront => {
+                            let argument_index = argument_index
+                                .expect("ICE: Should have an argument index for slice intrinsics");
+                            let slice_contents = arguments[argument_index];
+
                             // We do not decrement the size on intrinsics that could remove values from a slice.
                             // This is because we could potentially go back to the smaller slice and not fill in dummies.
                             // This pass should be tracking the potential max that a slice ***could be***
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
                                 let new_capacity = *contents_capacity - 1;
-                                slice_sizes.insert(results[result_index], new_capacity);
+                                slice_sizes.insert(result_slice, new_capacity);
                             }
                         }
+                        Intrinsic::ToBits(_) => {
+                            // Compiler sanity check
+                            assert!(matches!(self.dfg.type_of_value(result_slice), Type::Slice(_)));
+                            slice_sizes.insert(result_slice, FieldElement::max_num_bits() as usize);
+                        }
+                        Intrinsic::ToRadix(_) => {
+                            // Compiler sanity check
+                            assert!(matches!(self.dfg.type_of_value(result_slice), Type::Slice(_)));
+                            slice_sizes
+                                .insert(result_slice, FieldElement::max_num_bytes() as usize);
+                        }
                         _ => {}
                     }
                 }
diff --git a/test_programs/execution_success/slices/src/main.nr b/test_programs/execution_success/slices/src/main.nr
index 6823bf05d96..e44edf872a4 100644
--- a/test_programs/execution_success/slices/src/main.nr
+++ b/test_programs/execution_success/slices/src/main.nr
@@ -51,6 +51,8 @@ fn main(x: Field, y: pub Field) {
     regression_merge_slices(x, y);
     regression_2370();
 
+    regression_4418(x);
+    regression_slice_call_result(x, y);
     regression_4506();
 }
 // Ensure that slices of struct/tuple values work.
@@ -300,6 +302,30 @@ fn regression_2370() {
     slice = [1, 2, 3];
 }
 
+fn regression_4418(x: Field) {
+    let mut crash = x.to_be_bytes(32);
+
+    if x != 0 {
+        crash[0] = 10;
+    }
+}
+
+fn regression_slice_call_result(x: Field, y: Field) {
+    let mut slice = merge_slices_return(x, y);
+    if x != 0 {
+        slice = slice.push_back(5);
+        slice = slice.push_back(10);
+    } else {
+        slice = slice.push_back(5);
+    }
+    assert(slice.len() == 5);
+    assert(slice[0] == 0);
+    assert(slice[1] == 0);
+    assert(slice[2] == 10);
+    assert(slice[3] == 5);
+    assert(slice[4] == 10);
+}
+
 fn regression_4506() {
     let slice: [Field] = [1, 2, 3];
     assert(slice == slice);

From 810d1958dcff55deac1867d3484bbc8bbe43d0fe Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 11 Mar 2024 09:45:58 +0000
Subject: [PATCH 058/416] chore(ci): fix JS publishing workflow checking out
 inconsistent commits (#4493)

---
 .github/JS_PUBLISH_FAILED.md              | 2 +-
 .github/workflows/publish-es-packages.yml | 8 ++++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/.github/JS_PUBLISH_FAILED.md b/.github/JS_PUBLISH_FAILED.md
index 5b9f79aac1f..9adba2776c8 100644
--- a/.github/JS_PUBLISH_FAILED.md
+++ b/.github/JS_PUBLISH_FAILED.md
@@ -1,6 +1,6 @@
 ---
 title: "JS packages failed to publish"
-assignees: TomAFrench kevaundray savio-sou
+assignees: TomAFrench kevaundray Savio-Sou
 labels: js
 ---
 
diff --git a/.github/workflows/publish-es-packages.yml b/.github/workflows/publish-es-packages.yml
index f72a97b2684..470db3b78f7 100644
--- a/.github/workflows/publish-es-packages.yml
+++ b/.github/workflows/publish-es-packages.yml
@@ -20,7 +20,9 @@ jobs:
     steps:
       - name: Checkout Noir repo
         uses: actions/checkout@v4
-
+        with:
+          ref: ${{ inputs.noir-ref }}
+      
       - name: Setup toolchain
         uses: dtolnay/rust-toolchain@1.73.0
 
@@ -87,6 +89,8 @@ jobs:
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.noir-ref }}
 
       - name: Setup toolchain
         uses: dtolnay/rust-toolchain@1.73.0
@@ -164,4 +168,4 @@ jobs:
           WORKFLOW_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         with:
           update_existing: true
-          filename: .github/JS_PUBLISH_FAILED.md
\ No newline at end of file
+          filename: .github/JS_PUBLISH_FAILED.md

From 8d6667773db13392a97a610cb5b996bffdf3e405 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 11 Mar 2024 05:30:26 -0500
Subject: [PATCH 059/416] chore: Move `check_method_signatures` to type
 checking phase (#4516)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/3583

## Summary\*

Resolves an old TODO by moving this function to the type checking phase.
I've rewritten the function since it was binding certain type variables
then unbound them afterward. I've changed that to substitute new
variables and only use `try_unify` to avoid accidentally binding
anything.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/def_collector/dc_crate.rs         | 176 +++---------------
 .../src/hir/def_collector/errors.rs           |  20 --
 .../src/hir/resolution/resolver.rs            |  10 +-
 .../src/hir/resolution/traits.rs              |  17 +-
 .../src/hir/type_check/errors.rs              |  32 +++-
 .../noirc_frontend/src/hir/type_check/expr.rs |   4 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  | 159 +++++++++++++++-
 .../noirc_frontend/src/hir_def/function.rs    |  10 +-
 compiler/noirc_frontend/src/tests.rs          |  16 +-
 9 files changed, 239 insertions(+), 205 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 27b1d376f11..62febc89899 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -5,13 +5,14 @@ use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
 
 use crate::hir::resolution::import::{resolve_import, ImportDirective};
-use crate::hir::resolution::resolver::Resolver;
 use crate::hir::resolution::{
     collect_impls, collect_trait_impls, path_resolver, resolve_free_functions, resolve_globals,
     resolve_impls, resolve_structs, resolve_trait_by_path, resolve_trait_impls, resolve_traits,
     resolve_type_aliases,
 };
-use crate::hir::type_check::{type_check_func, TypeCheckError, TypeChecker};
+use crate::hir::type_check::{
+    check_trait_impl_method_matches_declaration, type_check_func, TypeCheckError, TypeChecker,
+};
 use crate::hir::Context;
 
 use crate::macros_api::{MacroError, MacroProcessor};
@@ -20,8 +21,7 @@ use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId, TraitId, Ty
 use crate::parser::{ParserError, SortedModule};
 use crate::{
     ExpressionKind, Ident, LetStatement, Literal, NoirFunction, NoirStruct, NoirTrait,
-    NoirTypeAlias, Path, PathKind, Type, TypeBindings, UnresolvedGenerics,
-    UnresolvedTraitConstraint, UnresolvedType,
+    NoirTypeAlias, Path, PathKind, UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType,
 };
 use fm::FileId;
 use iter_extended::vecmap;
@@ -368,12 +368,12 @@ impl DefCollector {
             &mut errors,
         ));
 
-        functions.extend(resolve_trait_impls(
+        let impl_functions = resolve_trait_impls(
             context,
             def_collector.collected_traits_impls,
             crate_id,
             &mut errors,
-        ));
+        );
 
         for macro_processor in macro_processors {
             macro_processor.process_typed_ast(&crate_id, context).unwrap_or_else(
@@ -387,6 +387,8 @@ impl DefCollector {
 
         errors.extend(type_check_globals(&mut context.def_interner, resolved_globals.globals));
         errors.extend(type_check_functions(&mut context.def_interner, functions));
+        errors.extend(type_check_trait_impl_signatures(&mut context.def_interner, &impl_functions));
+        errors.extend(type_check_functions(&mut context.def_interner, impl_functions));
         errors
     }
 }
@@ -468,158 +470,24 @@ fn type_check_functions(
         .into_iter()
         .flat_map(|(file, func)| {
             type_check_func(interner, func)
-                .iter()
-                .cloned()
+                .into_iter()
                 .map(|e| (e.into(), file))
                 .collect::<Vec<_>>()
         })
         .collect()
 }
 
-// TODO(vitkov): Move this out of here and into type_check
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn check_methods_signatures(
-    resolver: &mut Resolver,
-    impl_methods: &[(FileId, FuncId)],
-    trait_id: TraitId,
-    trait_name_span: Span,
-    // These are the generics on the trait itself from the impl.
-    // E.g. in `impl Foo<A, B> for Bar<B, C>`, this is `vec![A, B]`.
-    trait_generics: Vec<UnresolvedType>,
-    trait_impl_generic_count: usize,
-    file_id: FileId,
-    errors: &mut Vec<(CompilationError, FileId)>,
-) {
-    let self_type = resolver.get_self_type().expect("trait impl must have a Self type").clone();
-    let trait_generics = vecmap(trait_generics, |typ| resolver.resolve_type(typ));
-
-    // Temporarily bind the trait's Self type to self_type so we can type check
-    let the_trait = resolver.interner.get_trait_mut(trait_id);
-    the_trait.self_type_typevar.bind(self_type);
-
-    if trait_generics.len() != the_trait.generics.len() {
-        let error = DefCollectorErrorKind::MismatchGenericCount {
-            actual_generic_count: trait_generics.len(),
-            expected_generic_count: the_trait.generics.len(),
-            // Preferring to use 'here' over a more precise term like 'this reference'
-            // to try to make the error easier to understand for newer users.
-            location: "here it",
-            origin: the_trait.name.to_string(),
-            span: trait_name_span,
-        };
-        errors.push((error.into(), file_id));
-    }
-
-    // We also need to bind the traits generics to the trait's generics on the impl
-    for (generic, binding) in the_trait.generics.iter().zip(trait_generics) {
-        generic.bind(binding);
-    }
-
-    // Temporarily take the trait's methods so we can use both them and a mutable reference
-    // to the interner within the loop.
-    let trait_methods = std::mem::take(&mut the_trait.methods);
-
-    for (file_id, func_id) in impl_methods {
-        let func_name = resolver.interner.function_name(func_id).to_owned();
-
-        // This is None in the case where the impl block has a method that's not part of the trait.
-        // If that's the case, a `MethodNotInTrait` error has already been thrown, and we can ignore
-        // the impl method, since there's nothing in the trait to match its signature against.
-        if let Some(trait_method) =
-            trait_methods.iter().find(|method| method.name.0.contents == func_name)
-        {
-            let impl_method = resolver.interner.function_meta(func_id);
-
-            let impl_method_generic_count =
-                impl_method.typ.generic_count() - trait_impl_generic_count;
-
-            // We subtract 1 here to account for the implicit generic `Self` type that is on all
-            // traits (and thus trait methods) but is not required (or allowed) for users to specify.
-            let the_trait = resolver.interner.get_trait(trait_id);
-            let trait_method_generic_count =
-                trait_method.generics().len() - 1 - the_trait.generics.len();
-
-            if impl_method_generic_count != trait_method_generic_count {
-                let trait_name = resolver.interner.get_trait(trait_id).name.clone();
-
-                let error = DefCollectorErrorKind::MismatchGenericCount {
-                    actual_generic_count: impl_method_generic_count,
-                    expected_generic_count: trait_method_generic_count,
-                    origin: format!("{}::{}", trait_name, func_name),
-                    location: "this method",
-                    span: impl_method.location.span,
-                };
-                errors.push((error.into(), *file_id));
-            }
-
-            // This instantiation is technically not needed. We could bind each generic in the
-            // trait function to the impl's corresponding generic but to do so we'd have to rely
-            // on the trait function's generics being first in the generic list, since the same
-            // list also contains the generic `Self` variable, and any generics on the trait itself.
-            //
-            // Instantiating the impl method's generics here instead is a bit less precise but
-            // doesn't rely on any orderings that may be changed.
-            let impl_function_type = impl_method.typ.instantiate(resolver.interner).0;
-
-            let mut bindings = TypeBindings::new();
-            let mut typecheck_errors = Vec::new();
-
-            if let Type::Function(impl_params, impl_return, _) = impl_function_type.as_monotype() {
-                if trait_method.arguments().len() != impl_params.len() {
-                    let error = DefCollectorErrorKind::MismatchTraitImplementationNumParameters {
-                        actual_num_parameters: impl_method.parameters.0.len(),
-                        expected_num_parameters: trait_method.arguments().len(),
-                        trait_name: resolver.interner.get_trait(trait_id).name.to_string(),
-                        method_name: func_name.to_string(),
-                        span: impl_method.location.span,
-                    };
-                    errors.push((error.into(), *file_id));
-                }
-
-                // Check the parameters of the impl method against the parameters of the trait method
-                let args = trait_method.arguments().iter();
-                let args_and_params = args.zip(impl_params).zip(&impl_method.parameters.0);
-
-                for (parameter_index, ((expected, actual), (hir_pattern, _, _))) in
-                    args_and_params.enumerate()
-                {
-                    if expected.try_unify(actual, &mut bindings).is_err() {
-                        typecheck_errors.push(TypeCheckError::TraitMethodParameterTypeMismatch {
-                            method_name: func_name.to_string(),
-                            expected_typ: expected.to_string(),
-                            actual_typ: actual.to_string(),
-                            parameter_span: hir_pattern.span(),
-                            parameter_index: parameter_index + 1,
-                        });
-                    }
-                }
-
-                if trait_method.return_type().try_unify(impl_return, &mut bindings).is_err() {
-                    let impl_method = resolver.interner.function_meta(func_id);
-                    let ret_type_span = impl_method.return_type.get_type().span;
-                    let expr_span = ret_type_span.expect("return type must always have a span");
-
-                    let expected_typ = trait_method.return_type().to_string();
-                    let expr_typ = impl_method.return_type().to_string();
-                    let error = TypeCheckError::TypeMismatch { expr_typ, expected_typ, expr_span };
-                    typecheck_errors.push(error);
-                }
-            } else {
-                unreachable!(
-                    "impl_function_type is not a function type, it is: {impl_function_type}"
-                );
-            }
-
-            errors.extend(typecheck_errors.iter().cloned().map(|e| (e.into(), *file_id)));
-        }
-    }
-
-    // Now unbind `Self` and the trait's generics
-    let the_trait = resolver.interner.get_trait_mut(trait_id);
-    the_trait.set_methods(trait_methods);
-    the_trait.self_type_typevar.unbind(the_trait.self_type_typevar_id);
-
-    for generic in &the_trait.generics {
-        generic.unbind(generic.id());
-    }
+fn type_check_trait_impl_signatures(
+    interner: &mut NodeInterner,
+    file_func_ids: &[(FileId, FuncId)],
+) -> Vec<(CompilationError, fm::FileId)> {
+    file_func_ids
+        .iter()
+        .flat_map(|(file, func)| {
+            check_trait_impl_method_matches_declaration(interner, *func)
+                .into_iter()
+                .map(|e| (e.into(), *file))
+                .collect::<Vec<_>>()
+        })
+        .collect()
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/errors.rs b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
index de45be48c4e..29daf5d6369 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/errors.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
@@ -41,14 +41,6 @@ pub enum DefCollectorErrorKind {
     OverlappingImplNote { span: Span },
     #[error("Cannot `impl` a type defined outside the current crate")]
     ForeignImpl { span: Span, type_name: String },
-    #[error("Mismatched number of parameters in trait implementation")]
-    MismatchTraitImplementationNumParameters {
-        actual_num_parameters: usize,
-        expected_num_parameters: usize,
-        trait_name: String,
-        method_name: String,
-        span: Span,
-    },
     #[error("Mismatched number of generics in {location}")]
     MismatchGenericCount {
         actual_generic_count: usize,
@@ -176,18 +168,6 @@ impl From<DefCollectorErrorKind> for Diagnostic {
                 "".to_string(),
                 trait_path.span(),
             ),
-            DefCollectorErrorKind::MismatchTraitImplementationNumParameters {
-                expected_num_parameters,
-                actual_num_parameters,
-                trait_name,
-                method_name,
-                span,
-            } => {
-                let plural = if expected_num_parameters == 1 { "" } else { "s" };
-                let primary_message = format!(
-                    "`{trait_name}::{method_name}` expects {expected_num_parameters} parameter{plural}, but this method has {actual_num_parameters}");
-                Diagnostic::simple_error(primary_message, "".to_string(), span)
-            }
             DefCollectorErrorKind::MismatchGenericCount {
                 actual_generic_count,
                 expected_generic_count,
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 322891f0ae9..875d0ceb85e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -217,6 +217,7 @@ impl<'a> Resolver<'a> {
     pub fn resolve_trait_function(
         &mut self,
         name: &Ident,
+        generics: &UnresolvedGenerics,
         parameters: &[(Ident, UnresolvedType)],
         return_type: &FunctionReturnType,
         where_clause: &[UnresolvedTraitConstraint],
@@ -237,7 +238,7 @@ impl<'a> Resolver<'a> {
             is_internal: false,
             is_unconstrained: false,
             visibility: FunctionVisibility::Public, // Trait functions are always public
-            generics: Vec::new(),                   // self.generics should already be set
+            generics: generics.clone(),
             parameters: vecmap(parameters, |(name, typ)| Param {
                 visibility: Visibility::Private,
                 pattern: Pattern::Identifier(name.clone()),
@@ -975,11 +976,18 @@ impl<'a> Resolver<'a> {
         self.handle_function_type(&func_id);
         self.handle_is_function_internal(&func_id);
 
+        let direct_generics = func.def.generics.iter();
+        let direct_generics = direct_generics
+            .filter_map(|generic| self.find_generic(&generic.0.contents))
+            .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
+            .collect();
+
         FuncMeta {
             name: name_ident,
             kind: func.kind,
             location,
             typ,
+            direct_generics,
             trait_impl: self.current_trait_impl,
             parameters: parameters.into(),
             return_type: func.def.return_type.clone(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index 8f966be312b..5d546954f0d 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -8,9 +8,7 @@ use crate::{
     graph::CrateId,
     hir::{
         def_collector::{
-            dc_crate::{
-                check_methods_signatures, CompilationError, UnresolvedTrait, UnresolvedTraitImpl,
-            },
+            dc_crate::{CompilationError, UnresolvedTrait, UnresolvedTraitImpl},
             errors::{DefCollectorErrorKind, DuplicateType},
         },
         def_map::{CrateDefMap, ModuleDefId, ModuleId},
@@ -131,6 +129,7 @@ fn resolve_trait_methods(
             let func_id = unresolved_trait.method_ids[&name.0.contents];
             let (_, func_meta) = resolver.resolve_trait_function(
                 name,
+                generics,
                 parameters,
                 return_type,
                 where_clause,
@@ -365,6 +364,7 @@ pub(crate) fn resolve_trait_by_path(
         Err(_) => Err(DefCollectorErrorKind::TraitNotFound { trait_path: path }),
     }
 }
+
 pub(crate) fn resolve_trait_impls(
     context: &mut Context,
     traits: Vec<UnresolvedTraitImpl>,
@@ -424,17 +424,6 @@ pub(crate) fn resolve_trait_impls(
         new_resolver.set_self_type(Some(self_type.clone()));
 
         if let Some(trait_id) = maybe_trait_id {
-            check_methods_signatures(
-                &mut new_resolver,
-                &impl_methods,
-                trait_id,
-                trait_impl.trait_path.span(),
-                trait_impl.trait_generics,
-                trait_impl.generics.len(),
-                trait_impl.file_id,
-                errors,
-            );
-
             let where_clause = trait_impl
                 .where_clause
                 .into_iter()
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index cba2400441f..7eacc8eb2d1 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -44,7 +44,7 @@ pub enum TypeCheckError {
     #[error("Expected type {expected} is not the same as {actual}")]
     TypeMismatchWithSource { expected: Type, actual: Type, span: Span, source: Source },
     #[error("Expected {expected:?} found {found:?}")]
-    ArityMisMatch { expected: u16, found: u16, span: Span },
+    ArityMisMatch { expected: usize, found: usize, span: Span },
     #[error("Return type in a function cannot be public")]
     PublicReturnType { typ: Type, span: Span },
     #[error("Cannot cast type {from}, 'as' is only for primitive field or integer types")]
@@ -53,8 +53,10 @@ pub enum TypeCheckError {
     ExpectedFunction { found: Type, span: Span },
     #[error("Type {lhs_type} has no member named {field_name}")]
     AccessUnknownMember { lhs_type: Type, field_name: String, span: Span },
-    #[error("Function expects {expected} parameters but {found} given")]
+    #[error("Function expects {expected} parameters but {found} were given")]
     ParameterCountMismatch { expected: usize, found: usize, span: Span },
+    #[error("{item} expects {expected} generics but {found} were given")]
+    GenericCountMismatch { item: String, expected: usize, found: usize, span: Span },
     #[error("Only integer and Field types may be casted to")]
     UnsupportedCast { span: Span },
     #[error("Index {index} is out of bounds for this tuple {lhs_type} of length {length}")]
@@ -124,6 +126,14 @@ pub enum TypeCheckError {
     UnconstrainedSliceReturnToConstrained { span: Span },
     #[error("Only sized types may be used in the entry point to a program")]
     InvalidTypeForEntryPoint { span: Span },
+    #[error("Mismatched number of parameters in trait implementation")]
+    MismatchTraitImplNumParameters {
+        actual_num_parameters: usize,
+        expected_num_parameters: usize,
+        trait_name: String,
+        method_name: String,
+        span: Span,
+    },
 }
 
 impl TypeCheckError {
@@ -193,6 +203,12 @@ impl From<TypeCheckError> for Diagnostic {
                 let msg = format!("Function expects {expected} parameter{empty_or_s} but {found} {was_or_were} given");
                 Diagnostic::simple_error(msg, String::new(), span)
             }
+            TypeCheckError::GenericCountMismatch { item, expected, found, span } => {
+                let empty_or_s = if expected == 1 { "" } else { "s" };
+                let was_or_were = if found == 1 { "was" } else { "were" };
+                let msg = format!("{item} expects {expected} generic{empty_or_s} but {found} {was_or_were} given");
+                Diagnostic::simple_error(msg, String::new(), span)
+            }
             TypeCheckError::InvalidCast { span, .. }
             | TypeCheckError::ExpectedFunction { span, .. }
             | TypeCheckError::AccessUnknownMember { span, .. }
@@ -289,6 +305,18 @@ impl From<TypeCheckError> for Diagnostic {
             TypeCheckError::InvalidTypeForEntryPoint { span } => Diagnostic::simple_error(
                 "Only sized types may be used in the entry point to a program".to_string(),
                 "Slices, references, or any type containing them may not be used in main or a contract function".to_string(), span),
+            TypeCheckError::MismatchTraitImplNumParameters {
+                expected_num_parameters,
+                actual_num_parameters,
+                trait_name,
+                method_name,
+                span,
+            } => {
+                let plural = if expected_num_parameters == 1 { "" } else { "s" };
+                let primary_message = format!(
+                    "`{trait_name}::{method_name}` expects {expected_num_parameters} parameter{plural}, but this method has {actual_num_parameters}");
+                Diagnostic::simple_error(primary_message, "".to_string(), span)
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index c5287d35caf..7219f4d09c6 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -1040,9 +1040,9 @@ impl<'interner> TypeChecker<'interner> {
                 }
                 ret
             }
+            // ignoring env for subtype on purpose
             Type::Function(parameters, ret, _env) => {
-                // ignoring env for subtype on purpose
-                self.bind_function_type_impl(parameters.as_ref(), ret.as_ref(), args.as_ref(), span)
+                self.bind_function_type_impl(&parameters, &ret, &args, span)
             }
             Type::Error => Type::Error,
             found => {
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index aab793ec867..ab759f454e5 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -12,11 +12,17 @@ mod expr;
 mod stmt;
 
 pub use errors::TypeCheckError;
+use noirc_errors::Span;
 
 use crate::{
-    hir_def::{expr::HirExpression, function::Param, stmt::HirStatement, traits::TraitConstraint},
+    hir_def::{
+        expr::HirExpression,
+        function::{Param, Parameters},
+        stmt::HirStatement,
+        traits::TraitConstraint,
+    },
     node_interner::{ExprId, FuncId, GlobalId, NodeInterner},
-    Type,
+    Type, TypeBindings,
 };
 
 use self::errors::Source;
@@ -179,6 +185,154 @@ fn function_info(interner: &NodeInterner, function_body_id: &ExprId) -> (noirc_e
     (expr_span, empty_function)
 }
 
+/// Checks that the type of a function in a trait impl matches the type
+/// of the corresponding function declaration in the trait itself.
+///
+/// To do this, given a trait such as:
+/// `trait Foo<A> { fn foo<B>(...); }`
+///
+/// And an impl such as:
+/// `impl<C> Foo<D> for Bar<E> { fn foo<F>(...); } `
+///
+/// We have to substitute:
+/// - Self for Bar<E>
+/// - A for D
+/// - B for F
+///
+/// Before we can type check. Finally, we must also check that the unification
+/// result does not introduce any new bindings. This can happen if the impl
+/// function's type is more general than that of the trait function. E.g.
+/// `fn baz<A, B>(a: A, b: B)` when the impl required `fn baz<A>(a: A, b: A)`.
+///
+/// This does not type check the body of the impl function.
+pub(crate) fn check_trait_impl_method_matches_declaration(
+    interner: &mut NodeInterner,
+    function: FuncId,
+) -> Vec<TypeCheckError> {
+    let meta = interner.function_meta(&function);
+    let method_name = interner.function_name(&function);
+    let mut errors = Vec::new();
+
+    let definition_type = meta.typ.as_monotype();
+
+    let impl_ =
+        meta.trait_impl.expect("Trait impl function should have a corresponding trait impl");
+    let impl_ = interner.get_trait_implementation(impl_);
+    let impl_ = impl_.borrow();
+    let trait_info = interner.get_trait(impl_.trait_id);
+
+    let mut bindings = TypeBindings::new();
+    bindings.insert(
+        trait_info.self_type_typevar_id,
+        (trait_info.self_type_typevar.clone(), impl_.typ.clone()),
+    );
+
+    if trait_info.generics.len() != impl_.trait_generics.len() {
+        let expected = trait_info.generics.len();
+        let found = impl_.trait_generics.len();
+        let span = impl_.ident.span();
+        let item = trait_info.name.to_string();
+        errors.push(TypeCheckError::GenericCountMismatch { item, expected, found, span });
+    }
+
+    // Substitute each generic on the trait with the corresponding generic on the impl
+    for (generic, arg) in trait_info.generics.iter().zip(&impl_.trait_generics) {
+        bindings.insert(generic.id(), (generic.clone(), arg.clone()));
+    }
+
+    // If this is None, the trait does not have the corresponding function.
+    // This error should have been caught in name resolution already so we don't
+    // issue an error for it here.
+    if let Some(trait_fn_id) = trait_info.method_ids.get(method_name) {
+        let trait_fn_meta = interner.function_meta(trait_fn_id);
+
+        if trait_fn_meta.direct_generics.len() != meta.direct_generics.len() {
+            let expected = trait_fn_meta.direct_generics.len();
+            let found = meta.direct_generics.len();
+            let span = meta.name.location.span;
+            let item = method_name.to_string();
+            errors.push(TypeCheckError::GenericCountMismatch { item, expected, found, span });
+        }
+
+        // Substitute each generic on the trait function with the corresponding generic on the impl function
+        for ((_, trait_fn_generic), (name, impl_fn_generic)) in
+            trait_fn_meta.direct_generics.iter().zip(&meta.direct_generics)
+        {
+            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone());
+            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), arg));
+        }
+
+        let (declaration_type, _) = trait_fn_meta.typ.instantiate_with_bindings(bindings, interner);
+
+        check_function_type_matches_expected_type(
+            &declaration_type,
+            definition_type,
+            method_name,
+            &meta.parameters,
+            meta.name.location.span,
+            &trait_info.name.0.contents,
+            &mut errors,
+        );
+    }
+
+    errors
+}
+
+fn check_function_type_matches_expected_type(
+    expected: &Type,
+    actual: &Type,
+    method_name: &str,
+    actual_parameters: &Parameters,
+    span: Span,
+    trait_name: &str,
+    errors: &mut Vec<TypeCheckError>,
+) {
+    let mut bindings = TypeBindings::new();
+    // Shouldn't need to unify envs, they should always be equal since they're both free functions
+    if let (Type::Function(params_a, ret_a, _env_a), Type::Function(params_b, ret_b, _env_b)) =
+        (expected, actual)
+    {
+        if params_a.len() == params_b.len() {
+            for (i, (a, b)) in params_a.iter().zip(params_b.iter()).enumerate() {
+                if a.try_unify(b, &mut bindings).is_err() {
+                    errors.push(TypeCheckError::TraitMethodParameterTypeMismatch {
+                        method_name: method_name.to_string(),
+                        expected_typ: a.to_string(),
+                        actual_typ: b.to_string(),
+                        parameter_span: actual_parameters.0[i].0.span(),
+                        parameter_index: i + 1,
+                    });
+                }
+            }
+
+            if ret_b.try_unify(ret_a, &mut bindings).is_err() {
+                errors.push(TypeCheckError::TypeMismatch {
+                    expected_typ: ret_a.to_string(),
+                    expr_typ: ret_b.to_string(),
+                    expr_span: span,
+                });
+            }
+        } else {
+            errors.push(TypeCheckError::MismatchTraitImplNumParameters {
+                actual_num_parameters: params_b.len(),
+                expected_num_parameters: params_a.len(),
+                trait_name: trait_name.to_string(),
+                method_name: method_name.to_string(),
+                span,
+            });
+        }
+    }
+
+    // If result bindings is not empty, a type variable was bound which means the two
+    // signatures were not a perfect match. Note that this relies on us already binding
+    // all the expected generics to each other prior to this check.
+    if !bindings.is_empty() {
+        let expected_typ = expected.to_string();
+        let expr_typ = actual.to_string();
+        errors.push(TypeCheckError::TypeMismatch { expected_typ, expr_typ, expr_span: span });
+    }
+}
+
 impl<'interner> TypeChecker<'interner> {
     fn new(interner: &'interner mut NodeInterner) -> Self {
         Self { interner, errors: Vec::new(), trait_constraints: Vec::new(), current_function: None }
@@ -346,6 +500,7 @@ mod test {
             trait_impl: None,
             return_type: FunctionReturnType::Default(Span::default()),
             trait_constraints: Vec::new(),
+            direct_generics: Vec::new(),
             is_entry_point: true,
         };
         interner.push_fn_meta(func_meta, func_id);
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 82bbe1aa5b6..56543e8185c 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -1,12 +1,14 @@
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
+use std::rc::Rc;
+
 use super::expr::{HirBlockExpression, HirExpression, HirIdent};
 use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
 use crate::node_interner::{ExprId, NodeInterner, TraitImplId};
 use crate::FunctionKind;
-use crate::{Distinctness, FunctionReturnType, Type, Visibility};
+use crate::{Distinctness, FunctionReturnType, Type, TypeVariable, Visibility};
 
 /// A Hir function is a block expression
 /// with a list of statements
@@ -103,6 +105,12 @@ pub struct FuncMeta {
     /// or a Type::Forall for generic functions.
     pub typ: Type,
 
+    /// The set of generics that are declared directly on this function in the source code.
+    /// This does not include generics from an outer scope, like those introduced by
+    /// an `impl<T>` block. This also does not include implicit generics added by the compiler
+    /// such as a trait's `Self` type variable.
+    pub direct_generics: Vec<(Rc<String>, TypeVariable)>,
+
     pub location: Location,
 
     // This flag is needed for the attribute check pass
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 9be6252b10a..3f78bd43ba9 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -535,15 +535,13 @@ mod test {
         assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
         for (err, _file_id) in errors {
             match &err {
-                CompilationError::DefinitionError(
-                    DefCollectorErrorKind::MismatchTraitImplementationNumParameters {
-                        actual_num_parameters,
-                        expected_num_parameters,
-                        trait_name,
-                        method_name,
-                        ..
-                    },
-                ) => {
+                CompilationError::TypeError(TypeCheckError::MismatchTraitImplNumParameters {
+                    actual_num_parameters,
+                    expected_num_parameters,
+                    trait_name,
+                    method_name,
+                    ..
+                }) => {
                     assert_eq!(actual_num_parameters, &1_usize);
                     assert_eq!(expected_num_parameters, &2_usize);
                     assert_eq!(method_name, "default");

From 2a53545f4238c9b8535e6bc5b0720fa15f44f946 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 11 Mar 2024 09:11:09 -0500
Subject: [PATCH 060/416] fix: Fix brillig slowdown when assigning arrays in
 loops (#4472)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/3795

## Summary\*

This is an older version of https://github.com/noir-lang/noir/pull/4210
which undoes the change in
https://github.com/noir-lang/noir/pull/4210/commits/d331ee27e63df73e7e294fba7031a4c0ab073294
due to a regression https://github.com/noir-lang/noir/issues/4332.

This PR is not yet confirmed to work since I do not have a test case for
it! @sirasistant, do you mind seeing if this fixes the regression issue?

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/function_builder/mod.rs           | 19 +++++++++++++--
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  5 ++++
 .../brillig_cow_assign/Nargo.toml             |  7 ++++++
 .../brillig_cow_assign/Prover.toml            |  2 ++
 .../brillig_cow_assign/src/main.nr            | 23 +++++++++++++++++++
 5 files changed, 54 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/execution_success/brillig_cow_assign/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_cow_assign/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_cow_assign/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 9d27554dcaa..bf34a47485b 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -393,10 +393,25 @@ impl FunctionBuilder {
                     self.increment_array_reference_count(value);
                 }
             }
-            Type::Array(..) | Type::Slice(..) => {
-                self.insert_instruction(Instruction::IncrementRc { value }, None);
+            typ @ Type::Array(..) | typ @ Type::Slice(..) => {
                 // If there are nested arrays or slices, we wait until ArrayGet
                 // is issued to increment the count of that array.
+                self.insert_instruction(Instruction::IncrementRc { value }, None);
+
+                // This is a bit odd, but in brillig the inc_rc instruction operates on
+                // a copy of the array's metadata, so we need to re-store a loaded array
+                // even if there have been no other changes to it.
+                if let Value::Instruction { instruction, .. } = &self.current_function.dfg[value] {
+                    let instruction = &self.current_function.dfg[*instruction];
+                    if let Instruction::Load { address } = instruction {
+                        // We can't re-use `value` in case the original address was stored
+                        // to again in the meantime. So introduce another load.
+                        let address = *address;
+                        let value = self.insert_load(address, typ);
+                        self.insert_instruction(Instruction::IncrementRc { value }, None);
+                        self.insert_store(address, value);
+                    }
+                }
             }
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index d95295ae3c9..f3fa5d1d2f8 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -722,6 +722,11 @@ impl<'a> FunctionContext<'a> {
         let lhs = self.extract_current_value(&assign.lvalue)?;
         let rhs = self.codegen_expression(&assign.expression)?;
 
+        rhs.clone().for_each(|value| {
+            let value = value.eval(self);
+            self.builder.increment_array_reference_count(value);
+        });
+
         self.assign_new_value(lhs, rhs);
         Ok(Self::unit_value())
     }
diff --git a/test_programs/execution_success/brillig_cow_assign/Nargo.toml b/test_programs/execution_success/brillig_cow_assign/Nargo.toml
new file mode 100644
index 00000000000..a878566a372
--- /dev/null
+++ b/test_programs/execution_success/brillig_cow_assign/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "brillig_cow_assign"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_cow_assign/Prover.toml b/test_programs/execution_success/brillig_cow_assign/Prover.toml
new file mode 100644
index 00000000000..882c73b83f8
--- /dev/null
+++ b/test_programs/execution_success/brillig_cow_assign/Prover.toml
@@ -0,0 +1,2 @@
+items_to_update = 10
+index = 6
diff --git a/test_programs/execution_success/brillig_cow_assign/src/main.nr b/test_programs/execution_success/brillig_cow_assign/src/main.nr
new file mode 100644
index 00000000000..e5c3e2bd2f5
--- /dev/null
+++ b/test_programs/execution_success/brillig_cow_assign/src/main.nr
@@ -0,0 +1,23 @@
+global N = 10;
+
+unconstrained fn main() {
+    let mut arr = [0; N];
+    let mut mid_change = arr;
+
+    for i in 0..N {
+        if i == N / 2 {
+            mid_change = arr;
+        }
+        arr[i] = 27;
+    }
+
+    // Expect:
+    // arr        = [27, 27, 27, 27, 27, 27, 27, 27, 27, 27]
+    // mid_change = [27, 27, 27, 27, 27, 0, 0, 0, 0, 0]
+
+    let modified_i = N / 2 + 1;
+    assert_eq(arr[modified_i], 27);
+
+    // Fail here!
+    assert(mid_change[modified_i] != 27);
+}

From b94adb92657e2b4a51dc7216a88e080aed1cf8b0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 11 Mar 2024 11:55:32 -0500
Subject: [PATCH 061/416] fix: Add `follow_bindings` to follow `Type::Alias`
 links (#4521)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4518

## Summary\*



## Additional Context

A match case for `Type::Alias` was forgotten when that was initially
added.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/monomorphization/mod.rs     | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index cfd9a61d13f..9d11ecd54bc 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -1691,23 +1691,15 @@ impl<'interner> Monomorphizer<'interner> {
 }
 
 fn unwrap_tuple_type(typ: &HirType) -> Vec<HirType> {
-    match typ {
+    match typ.follow_bindings() {
         HirType::Tuple(fields) => fields.clone(),
-        HirType::TypeVariable(binding, TypeVariableKind::Normal) => match &*binding.borrow() {
-            TypeBinding::Bound(binding) => unwrap_tuple_type(binding),
-            TypeBinding::Unbound(_) => unreachable!(),
-        },
         other => unreachable!("unwrap_tuple_type: expected tuple, found {:?}", other),
     }
 }
 
 fn unwrap_struct_type(typ: &HirType) -> Vec<(String, HirType)> {
-    match typ {
-        HirType::Struct(def, args) => def.borrow().get_fields(args),
-        HirType::TypeVariable(binding, TypeVariableKind::Normal) => match &*binding.borrow() {
-            TypeBinding::Bound(binding) => unwrap_struct_type(binding),
-            TypeBinding::Unbound(_) => unreachable!(),
-        },
+    match typ.follow_bindings() {
+        HirType::Struct(def, args) => def.borrow().get_fields(&args),
         other => unreachable!("unwrap_struct_type: expected struct, found {:?}", other),
     }
 }

From c6e6efd5fa314c61055e6cb15565ccbec4c78bbf Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 11 Mar 2024 21:02:54 +0100
Subject: [PATCH 062/416] chore: document big integers (#4487)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves #4205

## Summary\*

Add a section on standard library documentation

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: José Pedro Sousa <outgoing@zpedro.dev>
Co-authored-by: Savio <72797635+Savio-Sou@users.noreply.github.com>
---
 cspell.json                                   |   2 +
 docs/.markdownlint.json                       |   3 +
 docs/docs/noir/standard_library/bigint.md     | 102 ++++++++++++++++++
 noir_stdlib/src/bigint.nr                     |   2 +
 .../execution_success/bigint/src/main.nr      |  12 +++
 5 files changed, 121 insertions(+)
 create mode 100644 docs/.markdownlint.json
 create mode 100644 docs/docs/noir/standard_library/bigint.md

diff --git a/cspell.json b/cspell.json
index a96e3de901a..d961b600f40 100644
--- a/cspell.json
+++ b/cspell.json
@@ -154,6 +154,8 @@
         "sdiv",
         "secp256k1",
         "secp256r1",
+        "Secpk",
+        "Secpr",
         "signedness",
         "signorecello",
         "smol",
diff --git a/docs/.markdownlint.json b/docs/.markdownlint.json
new file mode 100644
index 00000000000..40896b4542f
--- /dev/null
+++ b/docs/.markdownlint.json
@@ -0,0 +1,3 @@
+{
+    "no-missing-space-atx": false
+}
diff --git a/docs/docs/noir/standard_library/bigint.md b/docs/docs/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..7d7931840cf
--- /dev/null
+++ b/docs/docs/noir/standard_library/bigint.md
@@ -0,0 +1,102 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+#include_code curve_order_base noir_stdlib/src/bigint.nr rust
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+#include_code big_int_example test_programs/execution_success/bigint/src/main.nr rust
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ let a = Secpk1Fq::from_le_bytes([x, y, 0, 45, 2]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 98237a54779..e7fc28ba39b 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,6 +1,7 @@
 use crate::ops::{Add, Sub, Mul, Div};
 use crate::cmp::Eq;
 
+// docs:start:curve_order_base
 global bn254_fq = [0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
 global bn254_fr = [0x01, 0x00, 0x00, 0x00, 0x3F, 0x59, 0x1F, 0x43, 0x09, 0x97, 0xB9, 0x79, 0x48, 0xE8, 0x33, 0x28, 
@@ -13,6 +14,7 @@ global secpr1_fq = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
 global secpr1_fr = [0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3, 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC,
                     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,0xFF, 0xFF, 0xFF, 0xFF];
+// docs:end:curve_order_base
 
 struct BigInt {
     pointer: u32,
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index b93fec370e5..b6c23276c15 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -1,4 +1,5 @@
 use dep::std::bigint;
+use dep::std::{bigint::Secpk1Fq, println};
 
 fn main(mut x: [u8; 5], y: [u8; 5]) {
     let a = bigint::Secpk1Fq::from_le_bytes([x[0], x[1], x[2], x[3], x[4]]);
@@ -13,4 +14,15 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let d = a * b - b;
     let d1 = bigint::Secpk1Fq::from_le_bytes(597243850900842442924.to_le_bytes(10));
     assert(d1 == d);
+    // big_int_example(x[0], x[1]);
 }
+
+// docs:start:big_int_example
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes([x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes([y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+// docs:end:big_int_example

From 3f676051a6073d6eabdc7fee68e4b522334344f6 Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Mon, 11 Mar 2024 20:27:40 +0000
Subject: [PATCH 063/416] chore: Release Noir(0.25.0) (#4352)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.25.0</summary>

## [0.25.0](https://github.com/noir-lang/noir/compare/v0.24.0...v0.25.0)
(2024-03-11)


### ⚠ BREAKING CHANGES

* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* reserve `unchecked` keyword
([#4432](https://github.com/noir-lang/noir/issues/4432))
* Remove empty value from bounded vec
([#4431](https://github.com/noir-lang/noir/issues/4431))
* Ban Fields in for loop indices and bitwise ops
([#4376](https://github.com/noir-lang/noir/issues/4376))
* bump msrv to 1.73.0
([#4406](https://github.com/noir-lang/noir/issues/4406))
* **ci:** Bump MSRV to 1.72.1 and enforce that ACVM can be published
using updated lockfile
([#4385](https://github.com/noir-lang/noir/issues/4385))
* Restrict bit sizes
([#4235](https://github.com/noir-lang/noir/issues/4235))
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)

### Features

* Add eddsa_poseidon_to_pub function to stdlib with test + docs
([#4473](https://github.com/noir-lang/noir/issues/4473))
([00d2c32](https://github.com/noir-lang/noir/commit/00d2c32e58176cc5de3574c8435a54d415c4a5fa))
* Add HashMap to the stdlib
([#4242](https://github.com/noir-lang/noir/issues/4242))
([650ffc5](https://github.com/noir-lang/noir/commit/650ffc5053cdca4b6ad2e027fa1f4fd90ef64871))
* Add option to set max memory for bb.js
([#4227](https://github.com/noir-lang/noir/issues/4227))
([8a6b131](https://github.com/noir-lang/noir/commit/8a6b131402892a570bc2de6f5869de73b0bd979e))
* Add overflow and underflow checks for unsigned integers in brillig
([#4445](https://github.com/noir-lang/noir/issues/4445))
([21fc4b8](https://github.com/noir-lang/noir/commit/21fc4b85763dccae6dce0a46a318718c3c913471))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Allow type aliases to reference other aliases
([#4353](https://github.com/noir-lang/noir/issues/4353))
([c44ef14](https://github.com/noir-lang/noir/commit/c44ef14847a436733206b6dd9590a7ab214ecd97))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* **ci:** Use wasm-opt when compiling wasm packages
([#4334](https://github.com/noir-lang/noir/issues/4334))
([e382921](https://github.com/noir-lang/noir/commit/e3829213d8411f84e117a14b43816967925095e0))
* DAP Preflight and debugger compilation options
([#4185](https://github.com/noir-lang/noir/issues/4185))
([e0ad0b2](https://github.com/noir-lang/noir/commit/e0ad0b2b31f6d46be75d23aec6a82850a9c4bd75))
* Expose separate functions to compile programs vs contracts in
`noir_wasm` ([#4413](https://github.com/noir-lang/noir/issues/4413))
([7cd5fdb](https://github.com/noir-lang/noir/commit/7cd5fdb3d2a53475b7c8681231d517cab30f9f9b))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Restrict bit sizes
([#4235](https://github.com/noir-lang/noir/issues/4235))
([1048f81](https://github.com/noir-lang/noir/commit/1048f815abb1f27e9c84ab5b9568a3673c12a50a))
* Run tests in parallel in `nargo test`
([#4484](https://github.com/noir-lang/noir/issues/4484))
([761734e](https://github.com/noir-lang/noir/commit/761734e6cb3ff5911aa85d0cee96ad26092b4905))
* Skip redundant range checks in brillig
([#4460](https://github.com/noir-lang/noir/issues/4460))
([cb4c1c5](https://github.com/noir-lang/noir/commit/cb4c1c5264b95d01f69d99f916ced71ad9cdc9d1))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Track stack frames and their variables in the debugger
([#4188](https://github.com/noir-lang/noir/issues/4188))
([ae1a9d9](https://github.com/noir-lang/noir/commit/ae1a9d923998177516919bbba6ff4b0584fa1e9f))
* TypeVariableKind for just Integers
([#4118](https://github.com/noir-lang/noir/issues/4118))
([c956be8](https://github.com/noir-lang/noir/commit/c956be870fb47403a6da6585fce6bea2d40ee268))
* Update error message when trying to load workspace as dependency
([#4393](https://github.com/noir-lang/noir/issues/4393))
([d2585e7](https://github.com/noir-lang/noir/commit/d2585e738a63208fca3c9e26242e896d7f1df1e4))


### Bug Fixes

* **acir:** Array dynamic flatten
([#4351](https://github.com/noir-lang/noir/issues/4351))
([b2aaeab](https://github.com/noir-lang/noir/commit/b2aaeab319a0c66c431a7db6852f743eccde8e98))
* **acir:** Use types on dynamic arrays
([#4364](https://github.com/noir-lang/noir/issues/4364))
([ba2c541](https://github.com/noir-lang/noir/commit/ba2c541ec45de92bba98de34771b73cbb7865c93))
* Add `follow_bindings` to follow `Type::Alias` links
([#4521](https://github.com/noir-lang/noir/issues/4521))
([b94adb9](https://github.com/noir-lang/noir/commit/b94adb92657e2b4a51dc7216a88e080aed1cf8b0))
* Add handling to `noir_wasm` for projects without dependencies
([#4344](https://github.com/noir-lang/noir/issues/4344))
([4982251](https://github.com/noir-lang/noir/commit/49822511710a7f1c42b8ed343e80456f8e6db2d9))
* Allow type aliases in main
([#4505](https://github.com/noir-lang/noir/issues/4505))
([8a5359c](https://github.com/noir-lang/noir/commit/8a5359c012579e54c2766de1074482a36ecada32))
* Ban Fields in for loop indices and bitwise ops
([#4376](https://github.com/noir-lang/noir/issues/4376))
([601fd9a](https://github.com/noir-lang/noir/commit/601fd9afc502236af1db0c4492698ba2298c7501))
* Brillig range check with consistent bit size
([#4357](https://github.com/noir-lang/noir/issues/4357))
([ea47d4a](https://github.com/noir-lang/noir/commit/ea47d4a67c6a18e4a7d3a49079d9eb24a1026a25))
* Build noir_codegen when publishing
([#4448](https://github.com/noir-lang/noir/issues/4448))
([cb1ceee](https://github.com/noir-lang/noir/commit/cb1ceee58b11b0ce6f8845361af3418d13c506bd))
* Consistent bit size for truncate
([#4370](https://github.com/noir-lang/noir/issues/4370))
([dcd7a1e](https://github.com/noir-lang/noir/commit/dcd7a1e561a68504b9038ffbb3c80f5c981f9f0c))
* Correct formatting for databus visibility types
([#4423](https://github.com/noir-lang/noir/issues/4423))
([cd796de](https://github.com/noir-lang/noir/commit/cd796dea4937dd1a261f154e5f2e599bbc649165))
* Correct invalid brillig codegen for `EmbeddedCurvePoint.add`
([#4382](https://github.com/noir-lang/noir/issues/4382))
([5051ec4](https://github.com/noir-lang/noir/commit/5051ec4d434a9e5cf405c68357faaf213e68de9e))
* **docs:** Update install versions
([#4396](https://github.com/noir-lang/noir/issues/4396))
([b283637](https://github.com/noir-lang/noir/commit/b283637e092038eb296c468168aec2d41e1c2734))
* **docs:** Update noirjs_app for 0.23
([#4378](https://github.com/noir-lang/noir/issues/4378))
([f77f702](https://github.com/noir-lang/noir/commit/f77f702e0cfb81dcce4dd97e274b831e887ba5d2))
* Enforce matching types of binary ops in SSA
([#4391](https://github.com/noir-lang/noir/issues/4391))
([70866ae](https://github.com/noir-lang/noir/commit/70866aea976d59dbcbd4af34067fdd8f46555673))
* Fix brillig slowdown when assigning arrays in loops
([#4472](https://github.com/noir-lang/noir/issues/4472))
([2a53545](https://github.com/noir-lang/noir/commit/2a53545f4238c9b8535e6bc5b0720fa15f44f946))
* **flake:** Stop flake.nix removing ignored-tests.txt
([#4455](https://github.com/noir-lang/noir/issues/4455))
([ebaf05a](https://github.com/noir-lang/noir/commit/ebaf05ab10834dd10e04c7ea5130f96c6cdf98ed))
* Force src impl for == on slices
([#4507](https://github.com/noir-lang/noir/issues/4507))
([1691274](https://github.com/noir-lang/noir/commit/169127444e8b16a8aad4acfe29ba812894fd897c))
* Handling of gh deps in noir_wasm
([#4499](https://github.com/noir-lang/noir/issues/4499))
([1d65370](https://github.com/noir-lang/noir/commit/1d653704715bf9999eb6a40ed7500e752e2c73b7))
* Iterative flattening pass
([#4492](https://github.com/noir-lang/noir/issues/4492))
([33c1ef7](https://github.com/noir-lang/noir/commit/33c1ef70e7859fdee7babfb5d38191f53e73a0df))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Only add `.nr` files to file manager
([#4380](https://github.com/noir-lang/noir/issues/4380))
([8536c7c](https://github.com/noir-lang/noir/commit/8536c7c8ea8fc6b740b2ae6d1aef3bc7e1907b8c))
* Remove panic when generic array length is not resolvable
([#4408](https://github.com/noir-lang/noir/issues/4408))
([00ab3db](https://github.com/noir-lang/noir/commit/00ab3db86b06111d144516e862902b8604284611))
* Remove print from monomorphization pass
([#4417](https://github.com/noir-lang/noir/issues/4417))
([27c66b3](https://github.com/noir-lang/noir/commit/27c66b3d0741e68ed591ae8a16b47b30bc87175f))
* **ssa:** Handle mergers of slices returned from calls
([#4496](https://github.com/noir-lang/noir/issues/4496))
([f988d02](https://github.com/noir-lang/noir/commit/f988d020e43cdf36a38613f2052d4518de39193a))
* Use correct type for numeric generics
([#4386](https://github.com/noir-lang/noir/issues/4386))
([0a1d109](https://github.com/noir-lang/noir/commit/0a1d109f478c997da5c43876fd12464af638bb15))
* Variables from trait constraints being permanently bound over when
used within a trait impl
([#4450](https://github.com/noir-lang/noir/issues/4450))
([ac60ef5](https://github.com/noir-lang/noir/commit/ac60ef5e12fcfb907fbdcff709d7cbad05f2b939))


### Miscellaneous Chores

* Bump msrv to 1.73.0
([#4406](https://github.com/noir-lang/noir/issues/4406))
([b5e5c30](https://github.com/noir-lang/noir/commit/b5e5c30f4db52c79ef556e80660f39db369b1911))
* **ci:** Bump MSRV to 1.72.1 and enforce that ACVM can be published
using updated lockfile
([#4385](https://github.com/noir-lang/noir/issues/4385))
([2fc95d2](https://github.com/noir-lang/noir/commit/2fc95d2d82b3220267ce7d5815e7073e00ef1360))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove empty value from bounded vec
([#4431](https://github.com/noir-lang/noir/issues/4431))
([b9384fb](https://github.com/noir-lang/noir/commit/b9384fb23abf4ab15e880fb7e03c21509a9fa8a6))
* Reserve `unchecked` keyword
([#4432](https://github.com/noir-lang/noir/issues/4432))
([9544813](https://github.com/noir-lang/noir/commit/9544813fabbd18a87dd88456e6a5b781bd0cf008))
</details>

<details><summary>0.41.0</summary>

## [0.41.0](https://github.com/noir-lang/noir/compare/v0.40.0...v0.41.0)
(2024-03-11)


### ⚠ BREAKING CHANGES

* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
* Rename Arithmetic opcode to AssertZero
([#3840](https://github.com/noir-lang/noir/issues/3840))
* Remove unused methods on ACIR opcodes
([#3841](https://github.com/noir-lang/noir/issues/3841))
* Remove partial backend feature
([#3805](https://github.com/noir-lang/noir/issues/3805))

### Features

* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add support for overriding expression width
([#4117](https://github.com/noir-lang/noir/issues/4117))
([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Aztec-packages
([#3754](https://github.com/noir-lang/noir/issues/3754))
([c043265](https://github.com/noir-lang/noir/commit/c043265e550b59bd4296504826fe15d3ce3e9ad2))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove range constraints from witnesses which are constrained to be
constants ([#3928](https://github.com/noir-lang/noir/issues/3928))
([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
* Remove replacement of boolean range opcodes with `AssertZero` opcodes
([#4107](https://github.com/noir-lang/noir/issues/4107))
([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
* Speed up transformation of debug messages
([#3815](https://github.com/noir-lang/noir/issues/3815))
([2a8af1e](https://github.com/noir-lang/noir/commit/2a8af1e4141ffff61547ee1c2837a6392bd5db48))
* Sync `aztec-packages`
([#4011](https://github.com/noir-lang/noir/issues/4011))
([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
* Sync commits from `aztec-packages`
([#4068](https://github.com/noir-lang/noir/issues/4068))
([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))


### Bug Fixes

* Deserialize odd length hex literals
([#3747](https://github.com/noir-lang/noir/issues/3747))
([4000fb2](https://github.com/noir-lang/noir/commit/4000fb279221eb07187d657bfaa7f1c7b311abf2))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Remove panic from `init_log_level` in `acvm_js`
([#4195](https://github.com/noir-lang/noir/issues/4195))
([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
* Return error rather instead of panicking on invalid circuit
([#3976](https://github.com/noir-lang/noir/issues/3976))
([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove partial backend feature
([#3805](https://github.com/noir-lang/noir/issues/3805))
([0383100](https://github.com/noir-lang/noir/commit/0383100853a80a5b28b797cdfeae0d271f1b7805))
* Remove unused methods on ACIR opcodes
([#3841](https://github.com/noir-lang/noir/issues/3841))
([9e5d0e8](https://github.com/noir-lang/noir/commit/9e5d0e813d61a0bfb5ee68174ed287c5a20f1579))
* Rename Arithmetic opcode to AssertZero
([#3840](https://github.com/noir-lang/noir/issues/3840))
([836f171](https://github.com/noir-lang/noir/commit/836f17145c2901060706294461c2d282dd121b3e))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).

---------

Co-authored-by: Savio <72797635+Savio-Sou@users.noreply.github.com>
---
 .release-please-manifest.json                 |   4 +-
 CHANGELOG.md                                  |  77 +++
 Cargo.lock                                    |  50 +-
 Cargo.toml                                    |  14 +-
 acvm-repo/CHANGELOG.md                        |  64 ++
 acvm-repo/acir/Cargo.toml                     |   2 +-
 acvm-repo/acir_field/Cargo.toml               |   2 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm_js/Cargo.toml                  |   2 +-
 acvm-repo/acvm_js/package.json                |   2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   2 +-
 acvm-repo/brillig_vm/Cargo.toml               |   2 +-
 compiler/wasm/package.json                    |   2 +-
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 142 +++++
 .../hello_noir/project_breakdown.md           | 199 ++++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 254 ++++++++
 .../getting_started/tooling/_category_.json   |   6 +
 .../getting_started/tooling/index.mdx         |  38 ++
 .../tooling/language_server.md                |  43 ++
 .../getting_started/tooling/testing.md        |  62 ++
 .../version-v0.25.0/how_to/_category_.json    |   5 +
 .../version-v0.25.0/how_to/how-to-oracles.md  | 280 +++++++++
 .../how_to/how-to-recursion.md                | 179 ++++++
 .../how_to/how-to-solidity-verifier.md        | 231 +++++++
 .../version-v0.25.0/how_to/merkle-proof.mdx   |  48 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.25.0/index.mdx |  67 +++
 .../version-v0.25.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.25.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.25.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  45 ++
 .../version-v0.25.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 251 ++++++++
 .../noir/concepts/data_types/booleans.md      |  31 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 155 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 147 +++++
 .../noir/concepts/data_types/strings.md       |  80 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../version-v0.25.0/noir/concepts/distinct.md |  64 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.25.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.25.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.25.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.25.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.25.0/noir/concepts/oracles.md  |  23 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.25.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  95 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  40 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/black_box_fns.md    |  31 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 326 ++++++++++
 .../standard_library/containers/hashmap.md    | 569 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 151 +++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  60 ++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../cryptographic_primitives/hashes.mdx       | 251 ++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/scalar.mdx       |  33 +
 .../cryptographic_primitives/schnorr.mdx      |  45 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  88 +++
 .../noir/standard_library/traits.md           | 399 ++++++++++++
 .../noir/standard_library/zeroed.md           |  25 +
 .../version-v0.25.0/reference/_category_.json |   5 +
 .../reference/nargo_commands.md               | 380 ++++++++++++
 .../version-v0.25.0/tutorials/noirjs_app.md   | 279 +++++++++
 .../version-v0.25.0-sidebars.json             |  83 +++
 flake.nix                                     |   2 +-
 tooling/noir_codegen/package.json             |   2 +-
 tooling/noir_js/package.json                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noir_js_types/package.json            |   2 +-
 tooling/noirc_abi_wasm/package.json           |   2 +-
 99 files changed, 8358 insertions(+), 49 deletions(-)
 create mode 100644 docs/versioned_docs/version-v0.25.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/tooling/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/getting_started/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/distinct.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/scalar.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.25.0-sidebars.json

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 8916585d7f1..b38234ca0b9 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.24.0",
-  "acvm-repo": "0.40.0"
+  ".": "0.25.0",
+  "acvm-repo": "0.41.0"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e9b2dfb48a5..cdbccf768ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,82 @@
 # Changelog
 
+## [0.25.0](https://github.com/noir-lang/noir/compare/v0.24.0...v0.25.0) (2024-03-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* reserve `unchecked` keyword ([#4432](https://github.com/noir-lang/noir/issues/4432))
+* Remove empty value from bounded vec ([#4431](https://github.com/noir-lang/noir/issues/4431))
+* Ban Fields in for loop indices and bitwise ops ([#4376](https://github.com/noir-lang/noir/issues/4376))
+* bump msrv to 1.73.0 ([#4406](https://github.com/noir-lang/noir/issues/4406))
+* **ci:** Bump MSRV to 1.72.1 and enforce that ACVM can be published using updated lockfile ([#4385](https://github.com/noir-lang/noir/issues/4385))
+* Restrict bit sizes ([#4235](https://github.com/noir-lang/noir/issues/4235))
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+
+### Features
+
+* Add eddsa_poseidon_to_pub function to stdlib with test + docs ([#4473](https://github.com/noir-lang/noir/issues/4473)) ([00d2c32](https://github.com/noir-lang/noir/commit/00d2c32e58176cc5de3574c8435a54d415c4a5fa))
+* Add HashMap to the stdlib ([#4242](https://github.com/noir-lang/noir/issues/4242)) ([650ffc5](https://github.com/noir-lang/noir/commit/650ffc5053cdca4b6ad2e027fa1f4fd90ef64871))
+* Add option to set max memory for bb.js ([#4227](https://github.com/noir-lang/noir/issues/4227)) ([8a6b131](https://github.com/noir-lang/noir/commit/8a6b131402892a570bc2de6f5869de73b0bd979e))
+* Add overflow and underflow checks for unsigned integers in brillig ([#4445](https://github.com/noir-lang/noir/issues/4445)) ([21fc4b8](https://github.com/noir-lang/noir/commit/21fc4b85763dccae6dce0a46a318718c3c913471))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Allow type aliases to reference other aliases ([#4353](https://github.com/noir-lang/noir/issues/4353)) ([c44ef14](https://github.com/noir-lang/noir/commit/c44ef14847a436733206b6dd9590a7ab214ecd97))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* **ci:** Use wasm-opt when compiling wasm packages ([#4334](https://github.com/noir-lang/noir/issues/4334)) ([e382921](https://github.com/noir-lang/noir/commit/e3829213d8411f84e117a14b43816967925095e0))
+* DAP Preflight and debugger compilation options ([#4185](https://github.com/noir-lang/noir/issues/4185)) ([e0ad0b2](https://github.com/noir-lang/noir/commit/e0ad0b2b31f6d46be75d23aec6a82850a9c4bd75))
+* Expose separate functions to compile programs vs contracts in `noir_wasm` ([#4413](https://github.com/noir-lang/noir/issues/4413)) ([7cd5fdb](https://github.com/noir-lang/noir/commit/7cd5fdb3d2a53475b7c8681231d517cab30f9f9b))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Restrict bit sizes ([#4235](https://github.com/noir-lang/noir/issues/4235)) ([1048f81](https://github.com/noir-lang/noir/commit/1048f815abb1f27e9c84ab5b9568a3673c12a50a))
+* Run tests in parallel in `nargo test`  ([#4484](https://github.com/noir-lang/noir/issues/4484)) ([761734e](https://github.com/noir-lang/noir/commit/761734e6cb3ff5911aa85d0cee96ad26092b4905))
+* Skip redundant range checks in brillig ([#4460](https://github.com/noir-lang/noir/issues/4460)) ([cb4c1c5](https://github.com/noir-lang/noir/commit/cb4c1c5264b95d01f69d99f916ced71ad9cdc9d1))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Track stack frames and their variables in the debugger ([#4188](https://github.com/noir-lang/noir/issues/4188)) ([ae1a9d9](https://github.com/noir-lang/noir/commit/ae1a9d923998177516919bbba6ff4b0584fa1e9f))
+* TypeVariableKind for just Integers ([#4118](https://github.com/noir-lang/noir/issues/4118)) ([c956be8](https://github.com/noir-lang/noir/commit/c956be870fb47403a6da6585fce6bea2d40ee268))
+* Update error message when trying to load workspace as dependency ([#4393](https://github.com/noir-lang/noir/issues/4393)) ([d2585e7](https://github.com/noir-lang/noir/commit/d2585e738a63208fca3c9e26242e896d7f1df1e4))
+
+
+### Bug Fixes
+
+* **acir:** Array dynamic flatten ([#4351](https://github.com/noir-lang/noir/issues/4351)) ([b2aaeab](https://github.com/noir-lang/noir/commit/b2aaeab319a0c66c431a7db6852f743eccde8e98))
+* **acir:** Use types on dynamic arrays ([#4364](https://github.com/noir-lang/noir/issues/4364)) ([ba2c541](https://github.com/noir-lang/noir/commit/ba2c541ec45de92bba98de34771b73cbb7865c93))
+* Add `follow_bindings` to follow `Type::Alias` links ([#4521](https://github.com/noir-lang/noir/issues/4521)) ([b94adb9](https://github.com/noir-lang/noir/commit/b94adb92657e2b4a51dc7216a88e080aed1cf8b0))
+* Add handling to `noir_wasm` for projects without dependencies ([#4344](https://github.com/noir-lang/noir/issues/4344)) ([4982251](https://github.com/noir-lang/noir/commit/49822511710a7f1c42b8ed343e80456f8e6db2d9))
+* Allow type aliases in main ([#4505](https://github.com/noir-lang/noir/issues/4505)) ([8a5359c](https://github.com/noir-lang/noir/commit/8a5359c012579e54c2766de1074482a36ecada32))
+* Ban Fields in for loop indices and bitwise ops ([#4376](https://github.com/noir-lang/noir/issues/4376)) ([601fd9a](https://github.com/noir-lang/noir/commit/601fd9afc502236af1db0c4492698ba2298c7501))
+* Brillig range check with consistent bit size ([#4357](https://github.com/noir-lang/noir/issues/4357)) ([ea47d4a](https://github.com/noir-lang/noir/commit/ea47d4a67c6a18e4a7d3a49079d9eb24a1026a25))
+* Build noir_codegen when publishing ([#4448](https://github.com/noir-lang/noir/issues/4448)) ([cb1ceee](https://github.com/noir-lang/noir/commit/cb1ceee58b11b0ce6f8845361af3418d13c506bd))
+* Consistent bit size for truncate ([#4370](https://github.com/noir-lang/noir/issues/4370)) ([dcd7a1e](https://github.com/noir-lang/noir/commit/dcd7a1e561a68504b9038ffbb3c80f5c981f9f0c))
+* Correct formatting for databus visibility types ([#4423](https://github.com/noir-lang/noir/issues/4423)) ([cd796de](https://github.com/noir-lang/noir/commit/cd796dea4937dd1a261f154e5f2e599bbc649165))
+* Correct invalid brillig codegen for `EmbeddedCurvePoint.add` ([#4382](https://github.com/noir-lang/noir/issues/4382)) ([5051ec4](https://github.com/noir-lang/noir/commit/5051ec4d434a9e5cf405c68357faaf213e68de9e))
+* **docs:** Update install versions ([#4396](https://github.com/noir-lang/noir/issues/4396)) ([b283637](https://github.com/noir-lang/noir/commit/b283637e092038eb296c468168aec2d41e1c2734))
+* **docs:** Update noirjs_app for 0.23 ([#4378](https://github.com/noir-lang/noir/issues/4378)) ([f77f702](https://github.com/noir-lang/noir/commit/f77f702e0cfb81dcce4dd97e274b831e887ba5d2))
+* Enforce matching types of binary ops in SSA ([#4391](https://github.com/noir-lang/noir/issues/4391)) ([70866ae](https://github.com/noir-lang/noir/commit/70866aea976d59dbcbd4af34067fdd8f46555673))
+* Fix brillig slowdown when assigning arrays in loops ([#4472](https://github.com/noir-lang/noir/issues/4472)) ([2a53545](https://github.com/noir-lang/noir/commit/2a53545f4238c9b8535e6bc5b0720fa15f44f946))
+* **flake:** Stop flake.nix removing ignored-tests.txt ([#4455](https://github.com/noir-lang/noir/issues/4455)) ([ebaf05a](https://github.com/noir-lang/noir/commit/ebaf05ab10834dd10e04c7ea5130f96c6cdf98ed))
+* Force src impl for == on slices ([#4507](https://github.com/noir-lang/noir/issues/4507)) ([1691274](https://github.com/noir-lang/noir/commit/169127444e8b16a8aad4acfe29ba812894fd897c))
+* Handling of gh deps in noir_wasm ([#4499](https://github.com/noir-lang/noir/issues/4499)) ([1d65370](https://github.com/noir-lang/noir/commit/1d653704715bf9999eb6a40ed7500e752e2c73b7))
+* Iterative flattening pass ([#4492](https://github.com/noir-lang/noir/issues/4492)) ([33c1ef7](https://github.com/noir-lang/noir/commit/33c1ef70e7859fdee7babfb5d38191f53e73a0df))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Only add `.nr` files to file manager ([#4380](https://github.com/noir-lang/noir/issues/4380)) ([8536c7c](https://github.com/noir-lang/noir/commit/8536c7c8ea8fc6b740b2ae6d1aef3bc7e1907b8c))
+* Remove panic when generic array length is not resolvable ([#4408](https://github.com/noir-lang/noir/issues/4408)) ([00ab3db](https://github.com/noir-lang/noir/commit/00ab3db86b06111d144516e862902b8604284611))
+* Remove print from monomorphization pass ([#4417](https://github.com/noir-lang/noir/issues/4417)) ([27c66b3](https://github.com/noir-lang/noir/commit/27c66b3d0741e68ed591ae8a16b47b30bc87175f))
+* **ssa:** Handle mergers of slices returned from calls ([#4496](https://github.com/noir-lang/noir/issues/4496)) ([f988d02](https://github.com/noir-lang/noir/commit/f988d020e43cdf36a38613f2052d4518de39193a))
+* Use correct type for numeric generics ([#4386](https://github.com/noir-lang/noir/issues/4386)) ([0a1d109](https://github.com/noir-lang/noir/commit/0a1d109f478c997da5c43876fd12464af638bb15))
+* Variables from trait constraints being permanently bound over when used within a trait impl ([#4450](https://github.com/noir-lang/noir/issues/4450)) ([ac60ef5](https://github.com/noir-lang/noir/commit/ac60ef5e12fcfb907fbdcff709d7cbad05f2b939))
+
+
+### Miscellaneous Chores
+
+* Bump msrv to 1.73.0 ([#4406](https://github.com/noir-lang/noir/issues/4406)) ([b5e5c30](https://github.com/noir-lang/noir/commit/b5e5c30f4db52c79ef556e80660f39db369b1911))
+* **ci:** Bump MSRV to 1.72.1 and enforce that ACVM can be published using updated lockfile ([#4385](https://github.com/noir-lang/noir/issues/4385)) ([2fc95d2](https://github.com/noir-lang/noir/commit/2fc95d2d82b3220267ce7d5815e7073e00ef1360))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove empty value from bounded vec ([#4431](https://github.com/noir-lang/noir/issues/4431)) ([b9384fb](https://github.com/noir-lang/noir/commit/b9384fb23abf4ab15e880fb7e03c21509a9fa8a6))
+* Reserve `unchecked` keyword ([#4432](https://github.com/noir-lang/noir/issues/4432)) ([9544813](https://github.com/noir-lang/noir/commit/9544813fabbd18a87dd88456e6a5b781bd0cf008))
+
 ## [0.24.0](https://github.com/noir-lang/noir/compare/v0.23.0...v0.24.0) (2024-02-12)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 317418276b1..ad3dce229fc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -23,7 +23,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -37,7 +37,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -53,7 +53,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "acir",
  "blake2",
@@ -68,7 +68,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -212,7 +212,7 @@ checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "arena"
-version = "0.24.0"
+version = "0.25.0"
 
 [[package]]
 name = "ark-bls12-381"
@@ -413,7 +413,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
@@ -602,7 +602,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -610,7 +610,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.40.0"
+version = "0.41.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1706,7 +1706,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2298,7 +2298,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.24.0"
+version = "0.25.0"
 
 [[package]]
 name = "itertools"
@@ -2651,7 +2651,7 @@ checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
 name = "nargo"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2678,7 +2678,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2730,7 +2730,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2742,7 +2742,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2815,7 +2815,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2850,7 +2850,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -2876,7 +2876,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2899,7 +2899,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -2916,7 +2916,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2933,7 +2933,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_driver"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -2954,7 +2954,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -2972,7 +2972,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "fxhash",
@@ -2988,7 +2988,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "arena",
@@ -3013,7 +3013,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index 38f39137360..2ddb9c9e28f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,7 +40,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.24.0"
+version = "0.25.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -51,12 +51,12 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.40.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.40.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.40.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.40.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.40.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.40.0", path = "acvm-repo/blackbox_solver", default-features = false }
+acir_field = { version = "0.41.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.41.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.41.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.41.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.41.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.41.0", path = "acvm-repo/blackbox_solver", default-features = false }
 bn254_blackbox_solver = { version = "0.39.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index acb465e5cc9..4f220d6eeba 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,70 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.41.0](https://github.com/noir-lang/noir/compare/v0.40.0...v0.41.0) (2024-03-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955))
+* Rename Arithmetic opcode to AssertZero ([#3840](https://github.com/noir-lang/noir/issues/3840))
+* Remove unused methods on ACIR opcodes ([#3841](https://github.com/noir-lang/noir/issues/3841))
+* Remove partial backend feature ([#3805](https://github.com/noir-lang/noir/issues/3805))
+
+### Features
+
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add support for overriding expression width ([#4117](https://github.com/noir-lang/noir/issues/4117)) ([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Aztec-packages ([#3754](https://github.com/noir-lang/noir/issues/3754)) ([c043265](https://github.com/noir-lang/noir/commit/c043265e550b59bd4296504826fe15d3ce3e9ad2))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955)) ([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove range constraints from witnesses which are constrained to be constants ([#3928](https://github.com/noir-lang/noir/issues/3928)) ([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
+* Remove replacement of boolean range opcodes with `AssertZero` opcodes ([#4107](https://github.com/noir-lang/noir/issues/4107)) ([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
+* Speed up transformation of debug messages ([#3815](https://github.com/noir-lang/noir/issues/3815)) ([2a8af1e](https://github.com/noir-lang/noir/commit/2a8af1e4141ffff61547ee1c2837a6392bd5db48))
+* Sync `aztec-packages` ([#4011](https://github.com/noir-lang/noir/issues/4011)) ([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
+* Sync commits from `aztec-packages` ([#4068](https://github.com/noir-lang/noir/issues/4068)) ([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144)) ([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+
+
+### Bug Fixes
+
+* Deserialize odd length hex literals ([#3747](https://github.com/noir-lang/noir/issues/3747)) ([4000fb2](https://github.com/noir-lang/noir/commit/4000fb279221eb07187d657bfaa7f1c7b311abf2))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Remove panic from `init_log_level` in `acvm_js` ([#4195](https://github.com/noir-lang/noir/issues/4195)) ([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
+* Return error rather instead of panicking on invalid circuit ([#3976](https://github.com/noir-lang/noir/issues/3976)) ([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove partial backend feature ([#3805](https://github.com/noir-lang/noir/issues/3805)) ([0383100](https://github.com/noir-lang/noir/commit/0383100853a80a5b28b797cdfeae0d271f1b7805))
+* Remove unused methods on ACIR opcodes ([#3841](https://github.com/noir-lang/noir/issues/3841)) ([9e5d0e8](https://github.com/noir-lang/noir/commit/9e5d0e813d61a0bfb5ee68174ed287c5a20f1579))
+* Rename Arithmetic opcode to AssertZero ([#3840](https://github.com/noir-lang/noir/issues/3840)) ([836f171](https://github.com/noir-lang/noir/commit/836f17145c2901060706294461c2d282dd121b3e))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.40.0](https://github.com/noir-lang/noir/compare/v0.39.0...v0.40.0) (2024-02-12)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 7021333486f..be859d7d054 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 6f4971770bd..c2056b73277 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index fce9a8e8e8b..d585850170a 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 7ec814a72e5..63fca2bd32a 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 876db9ccb62..0a9cd7235f5 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 0794b2dbe7e..a783193edba 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 8d91d19e117..57f89e091b4 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 272e8389413..1c7add5cb40 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.40.0"
+version = "0.41.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index 67584a2def1..6dfa3215483 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.24.0",
+  "version": "0.25.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/docs/versioned_docs/version-v0.25.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.25.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.25.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.25.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.25.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..743c4d8d634
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/index.md
@@ -0,0 +1,142 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Two additional files would be generated in your project directory:
+
+_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+
+## Prove Our Noir Program
+
+Now that the project is set up, we can create a proof of correct execution of our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Prove the valid execution of your Noir program:
+
+```sh
+nargo prove
+```
+
+A new folder _proofs_ would then be generated in your project directory, containing the proof file
+`<project-name>.proof`, where the project name is defined in Nargo.toml.
+
+The _Verifier.toml_ file would also be updated with the public values computed from program
+execution (in this case the value of `y`):
+
+```toml
+y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+```
+
+> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the
+proof file.
+
+Verify your proof by running:
+
+```sh
+nargo verify
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the
+corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..6160a102c6c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,199 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
+  files, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Verifier.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Verifier.toml
+
+_Verifier.toml_ contains public in/output values computed when executing the Noir program.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
+prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
+verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
+constrained by the proof of the execution of said program (i.e. if the condition was not met, the
+verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
+public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo prove` is executed, two processes happen:
+
+1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
+   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+
+2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove -p OtherProver
+```
+
+## Verifying a Proof
+
+When the command `nargo verify` is executed, two processes happen:
+
+1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
+
+2. If that file is found, the proof's validity is checked
+
+> **Note:** The validity of the proof is linked to the current Noir program; if the program is
+> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
+> _modified_ Noir program.
+
+In production, the prover and the verifier are usually two separate entities. A prover would
+retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
+verifier. The verifier would then retrieve the public inputs, usually from external sources, and
+verify the validity of the proof against it.
+
+Take a private asset transfer as an example:
+
+A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
+public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
+and submit it to the verifier smart contract.
+
+The verifier contract would then draw the user's encrypted balance directly from the blockchain and
+verify the proof submitted against it. If the verification passes, additional functions in the
+verifier contract could trigger (e.g. approve the asset transfer).
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.25.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.25.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.25.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..a35e34aaf9c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,254 @@
+---
+title: Alternative Install Methods
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains other methods that don't rely on noirup, such as compiling from source, installing from binaries, and using WSL for windows
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Shell & editor experience
+    Building and testing
+    Uninstalling Nargo
+    Noir vs code extension,
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Alternate Installation Methods (No Longer Recommended)
+
+While the following methods are available, they are no longer recommended. We advise using noirup for a more efficient and flexible installation experience.
+
+However, there are other methods for installing Nargo:
+
+- [Binaries](#option-1-installing-from-binaries)
+- [Compiling from Source](#option-2-compile-from-source)
+- [WSL for Windows](#option-3-wsl-for-windows)
+
+### Option 1: Installing from Binaries
+
+See [GitHub Releases](https://github.com/noir-lang/noir/releases) for the latest and previous
+platform specific binaries.
+
+#### Step 1
+
+Paste and run the following in the terminal to extract and install the binary:
+
+> **macOS / Linux:** If you are prompted with `Permission denied` when running commands, prepend
+> `sudo` and re-run it.
+
+##### macOS (Apple Silicon)
+
+```bash
+mkdir -p $HOME/.nargo/bin && \
+curl -o $HOME/.nargo/bin/nargo-aarch64-apple-darwin.tar.gz -L https://github.com/noir-lang/noir/releases/download/v0.24.0/nargo-aarch64-apple-darwin.tar.gz && \
+tar -xvf $HOME/.nargo/bin/nargo-aarch64-apple-darwin.tar.gz -C $HOME/.nargo/bin/ && \
+echo '\nexport PATH=$PATH:$HOME/.nargo/bin' >> ~/.zshrc && \
+source ~/.zshrc
+```
+
+##### macOS (Intel)
+
+```bash
+mkdir -p $HOME/.nargo/bin && \
+curl -o $HOME/.nargo/bin/nargo-x86_64-apple-darwin.tar.gz -L https://github.com/noir-lang/noir/releases/download/v0.24.0/nargo-x86_64-apple-darwin.tar.gz && \
+tar -xvf $HOME/.nargo/bin/nargo-x86_64-apple-darwin.tar.gz -C $HOME/.nargo/bin/ && \
+echo '\nexport PATH=$PATH:$HOME/.nargo/bin' >> ~/.zshrc && \
+source ~/.zshrc
+```
+
+##### Linux (Bash)
+
+```bash
+mkdir -p $HOME/.nargo/bin && \
+curl -o $HOME/.nargo/bin/nargo-x86_64-unknown-linux-gnu.tar.gz -L https://github.com/noir-lang/noir/releases/download/v0.24.0/nargo-x86_64-unknown-linux-gnu.tar.gz && \
+tar -xvf $HOME/.nargo/bin/nargo-x86_64-unknown-linux-gnu.tar.gz -C $HOME/.nargo/bin/ && \
+echo -e '\nexport PATH=$PATH:$HOME/.nargo/bin' >> ~/.bashrc && \
+source ~/.bashrc
+```
+
+#### Step 2
+
+Check if the installation was successful by running `nargo --version`. You should get a version number.
+
+> **macOS:** If you are prompted with an OS alert, right-click and open the _nargo_ executable from
+> Finder. Close the new terminal popped up and `nargo` should now be accessible.
+
+### Option 2: Compile from Source
+
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+
+#### Setting up your environment
+
+For the best experience, please follow these instructions to setup your environment:
+
+1. Install Nix following [their guide](https://nixos.org/download.html) for your operating system.
+2. Create the file `~/.config/nix/nix.conf` with the contents:
+
+```ini
+experimental-features = nix-command
+extra-experimental-features = flakes
+```
+
+3. Install direnv into your Nix profile by running:
+
+```sh
+nix profile install nixpkgs#direnv
+```
+
+4. Add direnv to your shell following [their guide](https://direnv.net/docs/hook.html).
+   1. For bash or zshell, add `eval "$(direnv hook bash)"` or `eval "$(direnv hook zsh)"` to your ~/.bashrc or ~/.zshrc file, respectively.
+5. Restart your shell.
+
+#### Shell & editor experience
+
+Now that your environment is set up, you can get to work on the project.
+
+1. Clone the repository, such as:
+
+```sh
+git clone git@github.com:noir-lang/noir
+```
+
+> Replacing `noir` with whichever repository you want to work on.
+
+2. Navigate to the directory:
+
+```sh
+cd noir
+```
+
+> Replacing `noir` with whichever repository you cloned.
+
+3. You should see a **direnv error** because projects aren't allowed by default. Make sure you've reviewed and trust our `.envrc` file, then you need to run:
+
+```sh
+direnv allow
+```
+
+4. Now, wait awhile for all the native dependencies to be built. This will take some time and direnv will warn you that it is taking a long time, but we just need to let it run.
+
+5. Once you are presented with your prompt again, you can start your editor within the project directory (we recommend [VSCode](https://code.visualstudio.com/)):
+
+```sh
+code .
+```
+
+6. (Recommended) When launching VSCode for the first time, you should be prompted to install our recommended plugins. We highly recommend installing these for the best development experience.
+
+#### Building and testing
+
+Assuming you are using `direnv` to populate your environment, building and testing the project can be done
+with the typical `cargo build`, `cargo test`, and `cargo clippy` commands. You'll notice that the `cargo` version matches the version we specify in `rust-toolchain.toml`, which is 1.73.0 at the time of this writing.
+
+If you want to build the entire project in an isolated sandbox, you can use Nix commands:
+
+1. `nix build .` (or `nix build . -L` for verbose output) to build the project in a Nix sandbox.
+2. `nix flake check` (or `nix flake check -L` for verbose output) to run clippy and tests in a Nix sandbox.
+
+#### Without `direnv`
+
+If you have hesitations with using direnv, you can launch a subshell with `nix develop` and then launch your editor from within the subshell. However, if VSCode was already launched in the project directory, the environment won't be updated.
+
+Advanced: If you aren't using direnv nor launching your editor within the subshell, you can try to install Barretenberg and other global dependencies the package needs. This is an advanced workflow and likely won't receive support!
+
+### Option 3: WSL (for Windows)
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+### Noirup
+
+If you installed Nargo with `noirup` or through directly downloading binaries, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
+
+### Nix
+
+If you installed Nargo with Nix or compiled it from source, you can remove the binary located at `~/.nix-profile/bin/nargo`.
+
+```bash
+rm ~/.nix-profile/bin/nargo
+```
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/tooling/_category_.json b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/_category_.json
new file mode 100644
index 00000000000..55804c03a71
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 2,
+    "label": "Tooling",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx
new file mode 100644
index 00000000000..ac480f3c9f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx
@@ -0,0 +1,38 @@
+---
+title: Tooling
+Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
+---
+
+Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
+
+## Playground
+
+The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
+
+## IDE tools
+
+When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
+
+The easiest way to use these tools is by installing the [Noir VS Code extension](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+## Codespaces
+
+Some Noir repos have leveraged Codespaces in order to ease the development process. You can visit the [noir-starter](https://github.com/noir-lang/noir-starter) for an example.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/codespaces_showcase.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+## GitHub Actions
+
+You can use `noirup` with GitHub Actions for CI/CD and automated testing. It is as simple as
+installing `noirup` and running tests in your GitHub Action `yml` file.
+
+See the
+[config file in the Noir repo](https://github.com/TomAFrench/noir-hashes/blob/master/.github/workflows/noir.yml) for an example usage.
+
+## Community projects
+
+As an open-source project, Noir has received many contributions over time. Some of them are related with developer tooling, and you can see some of them in [Awesome Noir repository](https://github.com/noir-lang/awesome-noir#dev-tools)
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/tooling/language_server.md b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/tooling/testing.md b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/_category_.json b/docs/versioned_docs/version-v0.25.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..0d84d992320
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md
@@ -0,0 +1,280 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("getSqrt", async (params) => {
+  const values = params[0].Array.map(({ inner }) => {
+    return { inner: `${Math.sqrt(parseInt(inner, 16))}` };
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+:::tip
+
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a `inner` property *as a string*. For example:
+
+```json
+{ "values": [{ "Array": [{ "inner": "1" }, { "inner": "2"}]}]}
+{ "values": [{ "Single": { "inner": "1" }}]}
+{ "values": [{ "Single": { "inner": "1" }}, { "Array": [{ "inner": "1", { "inner": "2" }}]}]}
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface Value {
+  inner: string,
+}
+
+interface SingleForeignCallParam {
+  Single: Value,
+}
+
+interface ArrayForeignCallParam {
+  Array: Value[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.generateFinalProof(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => ({ inner: i.toString("hex") })) },
+    ]);
+    return [oracleReturn.values[0].Array.map((x) => x.inner)];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.25.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..4c45bb87ae2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/how_to/how-to-recursion.md
@@ -0,0 +1,179 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit, backend)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.25.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e3c7c1065da
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,231 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo codegen-verifier
+```
+
+A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+
+```
+0x...<proof bytes>... , [0x0000.....02]
+```
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
+Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of
+the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.25.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..34074659ac1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+use dep::std;
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message);
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message);
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.25.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.25.0/index.mdx b/docs/versioned_docs/version-v0.25.0/index.mdx
new file mode 100644
index 00000000000..75086ddcdde
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.25.0/migration_notes.md b/docs/versioned_docs/version-v0.25.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.25.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..4ce65236db3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/control_flow.md
@@ -0,0 +1,45 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+};
+```
+
+The index for loops is of type `u64`.
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..a8bd338e736
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,251 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+```rust
+let slice : [[Field]] = [];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..69826fcd724
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,31 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
+> `false` in _Verifier.toml_.
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow) and
+[Assert Function](../assert) sections.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..99b4aa63549
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits<N>(_x : Field, _bit_size: u32) -> [u1; N]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits<N>(_x : Field, _bit_size: u32) -> [u1; N]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..97b3b2cb094
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](@site/docs/noir/concepts/generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..4d58d96fed5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,155 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo prove
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+use dep::std;
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..4a6ee816aa2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,147 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+use dep::std::slice;
+
+fn main() -> pub Field {
+    let mut slice: [Field] = [0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = [0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = [];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = [1, 2].append([3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..311dfd64416
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,80 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging).
+
+```rust
+use dep::std;
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/distinct.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/distinct.md
new file mode 100644
index 00000000000..6c993b8b5e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/distinct.md
@@ -0,0 +1,64 @@
+---
+title: Distinct Witnesses
+sidebar_position: 11
+---
+
+The `distinct` keyword prevents repetitions of witness indices in the program's ABI. This ensures
+that the witnesses being returned as public inputs are all unique.
+
+The `distinct` keyword is only used for return values on program entry points (usually the `main()`
+function).
+
+When using `distinct` and `pub` simultaneously, `distinct` comes first. See the example below.
+
+You can read more about the problem this solves
+[here](https://github.com/noir-lang/noir/issues/1183).
+
+## Example
+
+Without the `distinct` keyword, the following program
+
+```rust
+fn main(x : pub Field, y : pub Field) -> pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    "return_witnesses": [3, 2, 4, 4]
+  }
+}
+```
+
+Whereas (with the `distinct` keyword)
+
+```rust
+fn main(x : pub Field, y : pub Field) -> distinct pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    //...
+    "return_witnesses": [3, 4, 5, 6]
+  }
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..48aba9cd058
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../getting_started/tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main([1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../getting_started/tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..ddd42bf1f9b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..60425cb8994
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         |                  Types must be integer |
+| >>        |        Right shift an integer by another integer amount        |                  Types must be integer |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..2e6a6818d48
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/oracles.md
@@ -0,0 +1,23 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..ef1445a5907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: dep::some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: dep::some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..89d12c1c971
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/unconstrained.md
@@ -0,0 +1,95 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..04c1703d929
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use dep::ecrecover;
+use dep::lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use dep::std::hash::sha256;
+use dep::std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use dep::phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..67a1dafa372
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,40 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── src
+│           └── main.nr
+├── Nargo.toml
+└── Prover.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.25.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..eae8744abf0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,31 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [SHA256](./cryptographic_primitives/hashes#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr)
+- [Blake2s](./cryptographic_primitives/hashes#blake2s)
+- [Blake3](./cryptographic_primitives/hashes#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes#keccak256)
+- [Recursive proof verification](./recursion)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..ce4529f6e57
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,326 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..91604af765d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,569 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a pedersen hash
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Pedersen>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<PedersenHasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..1954f05bc76
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,151 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let arr: [Field] = [1, 2, 3];
+let vector_from_slice = Vec::from_slice(arr);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice([10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice([10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice([10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice([10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..d2b42d67b7c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4bf09cef178
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,60 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..c2c0624dfad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..119d8ccc70e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,251 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L9-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L9-L11</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::sha256(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L15-L17</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L21-L23</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L46-L48" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L46-L48</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+struct PedersenPoint {
+   x : Field,
+   y : Field,
+}
+
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L26-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L26-L33</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of 32 bytes
+(`[u8; 32]`). Specify a message_size to hash only the first `message_size` bytes
+of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L71-L73</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L22" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L22</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field<N>(_input : [Field; N]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/scalar.mdx b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/scalar.mdx
new file mode 100644
index 00000000000..df411ca5443
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/scalar.mdx
@@ -0,0 +1,33 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplications over a fixed base in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## scalar_mul::fixed_base_embedded_curve
+
+Performs scalar multiplication over the embedded curve whose coordinates are defined by the
+configured noir field. For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+```rust title="fixed_base_embedded_curve" showLineNumbers 
+pub fn fixed_base_embedded_curve(
+    low: Field,
+    high: Field
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/scalar_mul.nr#L27-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/scalar_mul.nr#L27-L32</a></sub></sup>
+
+
+example
+
+```rust
+fn main(x : Field) {
+    let scal = std::scalar_mul::fixed_base_embedded_curve(x);
+    println(scal);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..ae12e6c12dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,45 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..fa488677884
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen([pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path);
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..9337499dac8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md
@@ -0,0 +1,88 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(verify_proof)]
+fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : Field, _key_hash : Field) {}
+```
+
+:::info
+
+This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+
+:::
+
+## Example usage
+
+```rust
+use dep::std;
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..ba9fa2ee841
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/traits.md
@@ -0,0 +1,399 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(input: Self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(input: U) -> T {
+      T::from(input)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L92-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L92-L96</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L17-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L17-L21</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L33-L37" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L33-L37</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L49-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L49-L53</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L65-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L65-L69</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L79-L83" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L79-L83</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L95-L99" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L95-L99</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L111-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L111-L115</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L127-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L127-L131</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L142-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L142-L146</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..97dab02dac2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/zeroed.md
@@ -0,0 +1,25 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.25.0/reference/_category_.json b/docs/versioned_docs/version-v0.25.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.25.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.25.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..8a309ef4e7e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/nargo_commands.md
@@ -0,0 +1,380 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo backend`↴](#nargo-backend)
+* [`nargo backend current`↴](#nargo-backend-current)
+* [`nargo backend ls`↴](#nargo-backend-ls)
+* [`nargo backend use`↴](#nargo-backend-use)
+* [`nargo backend install`↴](#nargo-backend-install)
+* [`nargo backend uninstall`↴](#nargo-backend-uninstall)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo codegen-verifier`↴](#nargo-codegen-verifier)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo prove`↴](#nargo-prove)
+* [`nargo verify`↴](#nargo-verify)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `backend` — Install and select custom backends used to generate and verify proofs
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `codegen-verifier` — Generates a Solidity verifier smart contract for the program
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `prove` — Create proof for this program. The proof is returned as a hex encoded string
+* `verify` — Given a proof and a program, verify whether the proof is valid
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on a circuit
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo backend`
+
+Install and select custom backends used to generate and verify proofs
+
+**Usage:** `nargo backend <COMMAND>`
+
+###### **Subcommands:**
+
+* `current` — Prints the name of the currently active backend
+* `ls` — Prints the list of currently installed backends
+* `use` — Select the backend to use
+* `install` — Install a new backend from a URL
+* `uninstall` — Uninstalls a backend
+
+
+
+## `nargo backend current`
+
+Prints the name of the currently active backend
+
+**Usage:** `nargo backend current`
+
+
+
+## `nargo backend ls`
+
+Prints the list of currently installed backends
+
+**Usage:** `nargo backend ls`
+
+
+
+## `nargo backend use`
+
+Select the backend to use
+
+**Usage:** `nargo backend use <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>`
+
+
+
+## `nargo backend install`
+
+Install a new backend from a URL
+
+**Usage:** `nargo backend install <BACKEND> <URL>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to install
+* `<URL>` — The URL from which to download the backend
+
+
+
+## `nargo backend uninstall`
+
+Uninstalls a backend
+
+**Usage:** `nargo backend uninstall <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to uninstall
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo codegen-verifier`
+
+Generates a Solidity verifier smart contract for the program
+
+**Usage:** `nargo codegen-verifier [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to codegen
+* `--workspace` — Codegen all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo prove`
+
+Create proof for this program. The proof is returned as a hex encoded string
+
+**Usage:** `nargo prove [OPTIONS]`
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--verify` — Verify proof after proving
+* `--package <PACKAGE>` — The name of the package to prove
+* `--workspace` — Prove all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo verify`
+
+Given a proof and a program, verify whether the proof is valid
+
+**Usage:** `nargo verify [OPTIONS]`
+
+###### **Options:**
+
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--package <PACKAGE>` — The name of the package verify
+* `--workspace` — Verify all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on a circuit
+
+Current information provided: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..ad76dd255cc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
@@ -0,0 +1,279 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.19.x matches `noir_js@0.19.x`, etc.
+
+In this guide, we will be pinned to 0.19.4.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to *anyone* is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```nargo new circuit```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```nargo compile```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+You should see `vite-project` appear in your root folder. This seems like a good time to `cd` into it and install our NoirJS packages:
+
+```bash
+npm i @noir-lang/backend_barretenberg@0.19.4 @noir-lang/noir_js@0.19.4
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It *could* be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import("@noir-lang/noirc_abi").then(module => 
+      module.default(new URL("@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm", import.meta.url).toString())
+    ),
+    import("@noir-lang/acvm_js").then(module => 
+      module.default(new URL("@noir-lang/acvm_js/web/acvm_js_bg.wasm", import.meta.url).toString())
+    )
+  ]);
+}
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch(err) {
+    display("logs", "Oh 💔 Wrong guess")
+  }
+});
+
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit, backend);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const proof = await noir.generateFinalProof(input);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verification = await noir.verifyFinalProof(proof);
+if (verification) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.25.0-sidebars.json b/docs/versioned_sidebars/version-v0.25.0-sidebars.json
new file mode 100644
index 00000000000..b16f79cc176
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.25.0-sidebars.json
@@ -0,0 +1,83 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/flake.nix b/flake.nix
index 5125dad06be..785d5aead56 100644
--- a/flake.nix
+++ b/flake.nix
@@ -73,7 +73,7 @@
       # Configuration shared between builds
       config = {
         # x-release-please-start-version
-        version = "0.24.0";
+        version = "0.25.0";
         # x-release-please-end
 
         src = pkgs.lib.cleanSourceWith {
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 6bb9d06f718..68ee7184928 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.24.0",
+  "version": "0.25.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index 6f1899fae52..0a40d300ea4 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.24.0",
+  "version": "0.25.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 06c034725e3..d94999f324b 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.24.0",
+  "version": "0.25.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index a3b5c85897a..d853813303d 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 05fcc270402..8fb9eb314a5 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.24.0",
+  "version": "0.25.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From f93d16e3e89c5df358c982deae4f3c2d4c82b77f Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 11 Mar 2024 22:49:24 +0000
Subject: [PATCH 064/416] fix(acir_gen): More granular element sizes array
 check (#4528)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The `array_typ.contains_slice_element()` check in
`can_omit_element_sizes_array` is incorrect.

This should have been `is_nested_slice()` but we already banned nested
slices so I just removed it. This leads to improvements for slices in
general so I have made it a separate PR.

This was also a blocker for https://github.com/noir-lang/noir/pull/4523.
When working with `AsSlice` we would omit the element sizes array. When
it came time to access a slice created with `as_slice()` we would
attempt to use the element sizes array which was never initialized
correctly and we would go out of bounds.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 8d4d0668534..140ed0b53ff 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -2268,11 +2268,9 @@ impl Context {
 
 // We can omit the element size array for arrays which don't contain arrays or slices.
 fn can_omit_element_sizes_array(array_typ: &Type) -> bool {
-    if array_typ.contains_slice_element() {
-        return false;
-    }
-    let Type::Array(types, _) = array_typ else {
-        panic!("ICE: expected array type");
+    let types = match array_typ {
+        Type::Array(types, _) | Type::Slice(types) => types,
+        _ => panic!("ICE: expected array or slice type"),
     };
 
     !types.iter().any(|typ| typ.contains_an_array())

From b3fd24d77e141c3a6562b6bcfc62d2ecb572e191 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 12 Mar 2024 10:33:51 +0000
Subject: [PATCH 065/416] chore: organize the `blackbox_solver` crate (#4519)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

No material changes, I'm just moving function into different modules to
make testing less messy.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/blackbox_solver/src/ecdsa/mod.rs    |  22 +
 .../blackbox_solver/src/ecdsa/secp256k1.rs    | 137 ++++++
 .../blackbox_solver/src/ecdsa/secp256r1.rs    | 133 ++++++
 acvm-repo/blackbox_solver/src/hash.rs         | 126 +++++
 acvm-repo/blackbox_solver/src/lib.rs          | 446 +-----------------
 5 files changed, 422 insertions(+), 442 deletions(-)
 create mode 100644 acvm-repo/blackbox_solver/src/ecdsa/mod.rs
 create mode 100644 acvm-repo/blackbox_solver/src/ecdsa/secp256k1.rs
 create mode 100644 acvm-repo/blackbox_solver/src/ecdsa/secp256r1.rs
 create mode 100644 acvm-repo/blackbox_solver/src/hash.rs

diff --git a/acvm-repo/blackbox_solver/src/ecdsa/mod.rs b/acvm-repo/blackbox_solver/src/ecdsa/mod.rs
new file mode 100644
index 00000000000..cb3134bf0ab
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/ecdsa/mod.rs
@@ -0,0 +1,22 @@
+use crate::BlackBoxResolutionError;
+
+mod secp256k1;
+mod secp256r1;
+
+pub fn ecdsa_secp256k1_verify(
+    hashed_msg: &[u8],
+    public_key_x: &[u8; 32],
+    public_key_y: &[u8; 32],
+    signature: &[u8; 64],
+) -> Result<bool, BlackBoxResolutionError> {
+    Ok(secp256k1::verify_signature(hashed_msg, public_key_x, public_key_y, signature))
+}
+
+pub fn ecdsa_secp256r1_verify(
+    hashed_msg: &[u8],
+    public_key_x: &[u8; 32],
+    public_key_y: &[u8; 32],
+    signature: &[u8; 64],
+) -> Result<bool, BlackBoxResolutionError> {
+    Ok(secp256r1::verify_signature(hashed_msg, public_key_x, public_key_y, signature))
+}
diff --git a/acvm-repo/blackbox_solver/src/ecdsa/secp256k1.rs b/acvm-repo/blackbox_solver/src/ecdsa/secp256k1.rs
new file mode 100644
index 00000000000..17c51353f7f
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/ecdsa/secp256k1.rs
@@ -0,0 +1,137 @@
+use k256::elliptic_curve::sec1::FromEncodedPoint;
+use k256::elliptic_curve::PrimeField;
+
+use blake2::digest::generic_array::GenericArray;
+use k256::{ecdsa::Signature, Scalar};
+use k256::{
+    elliptic_curve::{
+        sec1::{Coordinates, ToEncodedPoint},
+        IsHigh,
+    },
+    AffinePoint, EncodedPoint, ProjectivePoint, PublicKey,
+};
+
+pub(super) fn verify_signature(
+    hashed_msg: &[u8],
+    public_key_x_bytes: &[u8; 32],
+    public_key_y_bytes: &[u8; 32],
+    signature: &[u8; 64],
+) -> bool {
+    // Convert the inputs into k256 data structures
+    let Ok(signature) = Signature::try_from(signature.as_slice()) else {
+        // Signature `r` and `s` are forbidden from being zero.
+        return false;
+    };
+
+    let point = EncodedPoint::from_affine_coordinates(
+        public_key_x_bytes.into(),
+        public_key_y_bytes.into(),
+        true,
+    );
+
+    let pubkey = PublicKey::from_encoded_point(&point);
+    let pubkey = if pubkey.is_some().into() {
+        pubkey.unwrap()
+    } else {
+        // Public key must sit on the Secp256k1 curve.
+        return false;
+    };
+
+    // Note: This is incorrect as it will panic if `hashed_msg >= k256::Secp256k1::ORDER`.
+    // In this scenario we should just take the leftmost bits from `hashed_msg` up to the group order length.
+    let z = Scalar::from_repr(*GenericArray::from_slice(hashed_msg)).unwrap();
+
+    // Finished converting bytes into data structures
+
+    let r = signature.r();
+    let s = signature.s();
+
+    // Ensure signature is "low S" normalized ala BIP 0062
+    if s.is_high().into() {
+        return false;
+    }
+
+    let s_inv = s.invert().unwrap();
+    let u1 = z * s_inv;
+    let u2 = *r * s_inv;
+
+    #[allow(non_snake_case)]
+    let R: AffinePoint = ((ProjectivePoint::GENERATOR * u1)
+        + (ProjectivePoint::from(*pubkey.as_affine()) * u2))
+        .to_affine();
+
+    match R.to_encoded_point(false).coordinates() {
+        Coordinates::Uncompressed { x, y: _ } => Scalar::from_repr(*x).unwrap().eq(&r),
+        _ => unreachable!("Point is uncompressed"),
+    }
+}
+
+#[cfg(test)]
+mod secp256k1_tests {
+    use super::verify_signature;
+
+    // 0x3a73f4123a5cd2121f21cd7e8d358835476949d035d9c2da6806b4633ac8c1e2,
+    const HASHED_MESSAGE: [u8; 32] = [
+        0x3a, 0x73, 0xf4, 0x12, 0x3a, 0x5c, 0xd2, 0x12, 0x1f, 0x21, 0xcd, 0x7e, 0x8d, 0x35, 0x88,
+        0x35, 0x47, 0x69, 0x49, 0xd0, 0x35, 0xd9, 0xc2, 0xda, 0x68, 0x06, 0xb4, 0x63, 0x3a, 0xc8,
+        0xc1, 0xe2,
+    ];
+    // 0xa0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7
+    const PUB_KEY_X: [u8; 32] = [
+        0xa0, 0x43, 0x4d, 0x9e, 0x47, 0xf3, 0xc8, 0x62, 0x35, 0x47, 0x7c, 0x7b, 0x1a, 0xe6, 0xae,
+        0x5d, 0x34, 0x42, 0xd4, 0x9b, 0x19, 0x43, 0xc2, 0xb7, 0x52, 0xa6, 0x8e, 0x2a, 0x47, 0xe2,
+        0x47, 0xc7,
+    ];
+    // 0x893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7
+    const PUB_KEY_Y: [u8; 32] = [
+        0x89, 0x3a, 0xba, 0x42, 0x54, 0x19, 0xbc, 0x27, 0xa3, 0xb6, 0xc7, 0xe6, 0x93, 0xa2, 0x4c,
+        0x69, 0x6f, 0x79, 0x4c, 0x2e, 0xd8, 0x77, 0xa1, 0x59, 0x3c, 0xbe, 0xe5, 0x3b, 0x03, 0x73,
+        0x68, 0xd7,
+    ];
+    // 0xe5081c80ab427dc370346f4a0e31aa2bad8d9798c38061db9ae55a4e8df454fd28119894344e71b78770cc931d61f480ecbb0b89d6eb69690161e49a715fcd55
+    const SIGNATURE: [u8; 64] = [
+        0xe5, 0x08, 0x1c, 0x80, 0xab, 0x42, 0x7d, 0xc3, 0x70, 0x34, 0x6f, 0x4a, 0x0e, 0x31, 0xaa,
+        0x2b, 0xad, 0x8d, 0x97, 0x98, 0xc3, 0x80, 0x61, 0xdb, 0x9a, 0xe5, 0x5a, 0x4e, 0x8d, 0xf4,
+        0x54, 0xfd, 0x28, 0x11, 0x98, 0x94, 0x34, 0x4e, 0x71, 0xb7, 0x87, 0x70, 0xcc, 0x93, 0x1d,
+        0x61, 0xf4, 0x80, 0xec, 0xbb, 0x0b, 0x89, 0xd6, 0xeb, 0x69, 0x69, 0x01, 0x61, 0xe4, 0x9a,
+        0x71, 0x5f, 0xcd, 0x55,
+    ];
+
+    #[test]
+    fn verifies_valid_signature_with_low_s_value() {
+        let valid = verify_signature(&HASHED_MESSAGE, &PUB_KEY_X, &PUB_KEY_Y, &SIGNATURE);
+
+        assert!(valid);
+    }
+
+    #[test]
+    fn rejects_invalid_signature() {
+        // This signature is invalid as ECDSA specifies that `r` and `s` must be non-zero.
+        let invalid_signature: [u8; 64] = [0x00; 64];
+
+        let valid = verify_signature(&HASHED_MESSAGE, &PUB_KEY_X, &PUB_KEY_Y, &invalid_signature);
+        assert!(!valid);
+    }
+
+    #[test]
+    fn rejects_invalid_public_key() {
+        let invalid_pub_key_x: [u8; 32] = [0xff; 32];
+        let invalid_pub_key_y: [u8; 32] = [0xff; 32];
+
+        let valid =
+            verify_signature(&HASHED_MESSAGE, &invalid_pub_key_x, &invalid_pub_key_y, &SIGNATURE);
+
+        assert!(!valid);
+    }
+
+    #[test]
+    #[ignore = "ECDSA verification does not currently handle long hashes correctly"]
+    fn trims_overly_long_hashes_to_correct_length() {
+        let mut long_hashed_message = HASHED_MESSAGE.to_vec();
+        long_hashed_message.push(0xff);
+
+        let valid = verify_signature(&long_hashed_message, &PUB_KEY_X, &PUB_KEY_Y, &SIGNATURE);
+
+        assert!(valid);
+    }
+}
diff --git a/acvm-repo/blackbox_solver/src/ecdsa/secp256r1.rs b/acvm-repo/blackbox_solver/src/ecdsa/secp256r1.rs
new file mode 100644
index 00000000000..54559d7c774
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/ecdsa/secp256r1.rs
@@ -0,0 +1,133 @@
+use p256::elliptic_curve::sec1::FromEncodedPoint;
+use p256::elliptic_curve::PrimeField;
+
+use blake2::digest::generic_array::GenericArray;
+use p256::{ecdsa::Signature, Scalar};
+use p256::{
+    elliptic_curve::{
+        sec1::{Coordinates, ToEncodedPoint},
+        IsHigh,
+    },
+    AffinePoint, EncodedPoint, ProjectivePoint, PublicKey,
+};
+
+pub(super) fn verify_signature(
+    hashed_msg: &[u8],
+    public_key_x_bytes: &[u8; 32],
+    public_key_y_bytes: &[u8; 32],
+    signature: &[u8; 64],
+) -> bool {
+    // Convert the inputs into k256 data structures
+    let Ok(signature) = Signature::try_from(signature.as_slice()) else {
+        // Signature `r` and `s` are forbidden from being zero.
+        return false;
+    };
+
+    let point = EncodedPoint::from_affine_coordinates(
+        public_key_x_bytes.into(),
+        public_key_y_bytes.into(),
+        true,
+    );
+
+    let pubkey = PublicKey::from_encoded_point(&point);
+    let pubkey = if pubkey.is_some().into() {
+        pubkey.unwrap()
+    } else {
+        // Public key must sit on the Secp256r1 curve.
+        return false;
+    };
+
+    // Note: This is incorrect as it will panic if `hashed_msg >= p256::NistP256::ORDER`.
+    // In this scenario we should just take the leftmost bits from `hashed_msg` up to the group order length.
+    let z = Scalar::from_repr(*GenericArray::from_slice(hashed_msg)).unwrap();
+
+    // Finished converting bytes into data structures
+
+    let r = signature.r();
+    let s = signature.s();
+
+    // Ensure signature is "low S" normalized ala BIP 0062
+    if s.is_high().into() {
+        return false;
+    }
+
+    let s_inv = s.invert().unwrap();
+    let u1 = z * s_inv;
+    let u2 = *r * s_inv;
+
+    #[allow(non_snake_case)]
+    let R: AffinePoint = ((ProjectivePoint::GENERATOR * u1)
+        + (ProjectivePoint::from(*pubkey.as_affine()) * u2))
+        .to_affine();
+
+    match R.to_encoded_point(false).coordinates() {
+        Coordinates::Uncompressed { x, y: _ } => Scalar::from_repr(*x).unwrap().eq(&r),
+        _ => unreachable!("Point is uncompressed"),
+    }
+}
+
+#[cfg(test)]
+mod secp256r1_tests {
+    use super::verify_signature;
+
+    // 0x54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad
+    const HASHED_MESSAGE: [u8; 32] = [
+        84, 112, 91, 163, 186, 175, 219, 223, 186, 140, 95, 154, 112, 247, 168, 155, 238, 152, 217,
+        6, 181, 62, 49, 7, 77, 167, 186, 236, 220, 13, 169, 173,
+    ];
+    // 0x550f471003f3df97c3df506ac797f6721fb1a1fb7b8f6f83d224498a65c88e24
+    const PUB_KEY_X: [u8; 32] = [
+        85, 15, 71, 16, 3, 243, 223, 151, 195, 223, 80, 106, 199, 151, 246, 114, 31, 177, 161, 251,
+        123, 143, 111, 131, 210, 36, 73, 138, 101, 200, 142, 36,
+    ];
+    // 0x136093d7012e509a73715cbd0b00a3cc0ff4b5c01b3ffa196ab1fb327036b8e6
+    const PUB_KEY_Y: [u8; 32] = [
+        19, 96, 147, 215, 1, 46, 80, 154, 115, 113, 92, 189, 11, 0, 163, 204, 15, 244, 181, 192,
+        27, 63, 250, 25, 106, 177, 251, 50, 112, 54, 184, 230,
+    ];
+    // 0x2c70a8d084b62bfc5ce03641caf9f72ad4da8c81bfe6ec9487bb5e1bef62a13218ad9ee29eaf351fdc50f1520c425e9b908a07278b43b0ec7b872778c14e0784
+    const SIGNATURE: [u8; 64] = [
+        44, 112, 168, 208, 132, 182, 43, 252, 92, 224, 54, 65, 202, 249, 247, 42, 212, 218, 140,
+        129, 191, 230, 236, 148, 135, 187, 94, 27, 239, 98, 161, 50, 24, 173, 158, 226, 158, 175,
+        53, 31, 220, 80, 241, 82, 12, 66, 94, 155, 144, 138, 7, 39, 139, 67, 176, 236, 123, 135,
+        39, 120, 193, 78, 7, 132,
+    ];
+
+    #[test]
+    fn verifies_valid_signature_with_low_s_value() {
+        let valid = verify_signature(&HASHED_MESSAGE, &PUB_KEY_X, &PUB_KEY_Y, &SIGNATURE);
+
+        assert!(valid);
+    }
+
+    #[test]
+    fn rejects_invalid_signature() {
+        // This signature is invalid as ECDSA specifies that `r` and `s` must be non-zero.
+        let invalid_signature: [u8; 64] = [0x00; 64];
+
+        let valid = verify_signature(&HASHED_MESSAGE, &PUB_KEY_X, &PUB_KEY_Y, &invalid_signature);
+        assert!(!valid);
+    }
+
+    #[test]
+    fn rejects_invalid_public_key() {
+        let invalid_pub_key_x: [u8; 32] = [0xff; 32];
+        let invalid_pub_key_y: [u8; 32] = [0xff; 32];
+
+        let valid =
+            verify_signature(&HASHED_MESSAGE, &invalid_pub_key_x, &invalid_pub_key_y, &SIGNATURE);
+
+        assert!(!valid);
+    }
+
+    #[test]
+    #[ignore = "ECDSA verification does not currently handle long hashes correctly"]
+    fn trims_overly_long_hashes_to_correct_length() {
+        let mut long_hashed_message = HASHED_MESSAGE.to_vec();
+        long_hashed_message.push(0xff);
+
+        let valid = verify_signature(&long_hashed_message, &PUB_KEY_X, &PUB_KEY_Y, &SIGNATURE);
+
+        assert!(valid);
+    }
+}
diff --git a/acvm-repo/blackbox_solver/src/hash.rs b/acvm-repo/blackbox_solver/src/hash.rs
new file mode 100644
index 00000000000..ac56029b436
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/hash.rs
@@ -0,0 +1,126 @@
+use acir::BlackBoxFunc;
+use blake2::digest::generic_array::GenericArray;
+use blake2::{Blake2s256, Digest};
+use sha2::Sha256;
+use sha3::Keccak256;
+
+use crate::BlackBoxResolutionError;
+
+/// Does a generic hash of the inputs returning the resulting 32 bytes separately.
+fn generic_hash_256<D: Digest>(message: &[u8]) -> Result<[u8; 32], String> {
+    let output_bytes: [u8; 32] =
+        D::digest(message).as_slice().try_into().map_err(|_| "digest should be 256 bits")?;
+
+    Ok(output_bytes)
+}
+
+pub fn sha256(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
+    generic_hash_256::<Sha256>(inputs)
+        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::SHA256, err))
+}
+
+pub fn blake2s(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
+    generic_hash_256::<Blake2s256>(inputs)
+        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::Blake2s, err))
+}
+
+pub fn blake3(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
+    Ok(blake3::hash(inputs).into())
+}
+
+pub fn keccak256(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
+    generic_hash_256::<Keccak256>(inputs)
+        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::Keccak256, err))
+}
+
+pub fn sha256compression(state: &mut [u32; 8], msg_blocks: &[u32; 16]) {
+    let mut blocks = [0_u8; 64];
+    for (i, block) in msg_blocks.iter().enumerate() {
+        let bytes = block.to_be_bytes();
+        blocks[i * 4..i * 4 + 4].copy_from_slice(&bytes);
+    }
+    let blocks: GenericArray<u8, sha2::digest::typenum::U64> = blocks.into();
+    sha2::compress256(state, &[blocks]);
+}
+
+const KECCAK_LANES: usize = 25;
+
+pub fn keccakf1600(
+    mut state: [u64; KECCAK_LANES],
+) -> Result<[u64; KECCAK_LANES], BlackBoxResolutionError> {
+    keccak::f1600(&mut state);
+    Ok(state)
+}
+
+#[cfg(test)]
+mod keccakf1600_tests {
+    use super::keccakf1600;
+
+    #[test]
+    fn sanity_check() {
+        // Test vectors are copied from XKCP (eXtended Keccak Code Package)
+        // https://github.com/XKCP/XKCP/blob/master/tests/TestVectors/KeccakF-1600-IntermediateValues.txt
+        let zero_state = [0u64; 25];
+
+        let expected_state_first = [
+            0xF1258F7940E1DDE7,
+            0x84D5CCF933C0478A,
+            0xD598261EA65AA9EE,
+            0xBD1547306F80494D,
+            0x8B284E056253D057,
+            0xFF97A42D7F8E6FD4,
+            0x90FEE5A0A44647C4,
+            0x8C5BDA0CD6192E76,
+            0xAD30A6F71B19059C,
+            0x30935AB7D08FFC64,
+            0xEB5AA93F2317D635,
+            0xA9A6E6260D712103,
+            0x81A57C16DBCF555F,
+            0x43B831CD0347C826,
+            0x01F22F1A11A5569F,
+            0x05E5635A21D9AE61,
+            0x64BEFEF28CC970F2,
+            0x613670957BC46611,
+            0xB87C5A554FD00ECB,
+            0x8C3EE88A1CCF32C8,
+            0x940C7922AE3A2614,
+            0x1841F924A2C509E4,
+            0x16F53526E70465C2,
+            0x75F644E97F30A13B,
+            0xEAF1FF7B5CECA249,
+        ];
+        let expected_state_second = [
+            0x2D5C954DF96ECB3C,
+            0x6A332CD07057B56D,
+            0x093D8D1270D76B6C,
+            0x8A20D9B25569D094,
+            0x4F9C4F99E5E7F156,
+            0xF957B9A2DA65FB38,
+            0x85773DAE1275AF0D,
+            0xFAF4F247C3D810F7,
+            0x1F1B9EE6F79A8759,
+            0xE4FECC0FEE98B425,
+            0x68CE61B6B9CE68A1,
+            0xDEEA66C4BA8F974F,
+            0x33C43D836EAFB1F5,
+            0xE00654042719DBD9,
+            0x7CF8A9F009831265,
+            0xFD5449A6BF174743,
+            0x97DDAD33D8994B40,
+            0x48EAD5FC5D0BE774,
+            0xE3B8C8EE55B7B03C,
+            0x91A0226E649E42E9,
+            0x900E3129E7BADD7B,
+            0x202A9EC5FAA3CCE8,
+            0x5B3402464E1C3DB6,
+            0x609F4E62A44C1059,
+            0x20D06CD26A8FBF5C,
+        ];
+
+        let state_first = keccakf1600(zero_state).unwrap();
+        let state_second = keccakf1600(state_first).unwrap();
+
+        assert_eq!(state_first, expected_state_first);
+        assert_eq!(state_second, expected_state_second);
+    }
+}
diff --git a/acvm-repo/blackbox_solver/src/lib.rs b/acvm-repo/blackbox_solver/src/lib.rs
index e033344fefa..dc798bdab32 100644
--- a/acvm-repo/blackbox_solver/src/lib.rs
+++ b/acvm-repo/blackbox_solver/src/lib.rs
@@ -8,456 +8,18 @@
 //! For functions that have a reference implementation, such as [keccak256], this crate exports the reference implementation directly.
 
 use acir::BlackBoxFunc;
-use blake2::digest::generic_array::GenericArray;
-use blake2::{Blake2s256, Digest};
-use sha2::Sha256;
-use sha3::Keccak256;
 use thiserror::Error;
 
 mod curve_specific_solver;
+mod ecdsa;
+mod hash;
 
 pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver};
+pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
+pub use hash::{blake2s, blake3, keccak256, keccakf1600, sha256, sha256compression};
 
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
 pub enum BlackBoxResolutionError {
     #[error("failed to solve blackbox function: {0}, reason: {1}")]
     Failed(BlackBoxFunc, String),
 }
-
-pub fn sha256(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
-    generic_hash_256::<Sha256>(inputs)
-        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::SHA256, err))
-}
-
-pub fn blake2s(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
-    generic_hash_256::<Blake2s256>(inputs)
-        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::Blake2s, err))
-}
-
-pub fn blake3(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
-    Ok(blake3::hash(inputs).into())
-}
-
-pub fn keccak256(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
-    generic_hash_256::<Keccak256>(inputs)
-        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::Keccak256, err))
-}
-
-pub fn sha256compression(state: &mut [u32; 8], msg_blocks: &[u32; 16]) {
-    let mut blocks = [0_u8; 64];
-    for (i, block) in msg_blocks.iter().enumerate() {
-        let bytes = block.to_be_bytes();
-        blocks[i * 4..i * 4 + 4].copy_from_slice(&bytes);
-    }
-    let blocks: GenericArray<u8, sha2::digest::typenum::U64> = blocks.into();
-    sha2::compress256(state, &[blocks]);
-}
-
-const KECCAK_LANES: usize = 25;
-
-pub fn keccakf1600(
-    mut state: [u64; KECCAK_LANES],
-) -> Result<[u64; KECCAK_LANES], BlackBoxResolutionError> {
-    keccak::f1600(&mut state);
-    Ok(state)
-}
-
-pub fn ecdsa_secp256k1_verify(
-    hashed_msg: &[u8],
-    public_key_x: &[u8; 32],
-    public_key_y: &[u8; 32],
-    signature: &[u8; 64],
-) -> Result<bool, BlackBoxResolutionError> {
-    Ok(verify_secp256k1_ecdsa_signature(hashed_msg, public_key_x, public_key_y, signature))
-}
-
-pub fn ecdsa_secp256r1_verify(
-    hashed_msg: &[u8],
-    public_key_x: &[u8; 32],
-    public_key_y: &[u8; 32],
-    signature: &[u8; 64],
-) -> Result<bool, BlackBoxResolutionError> {
-    Ok(verify_secp256r1_ecdsa_signature(hashed_msg, public_key_x, public_key_y, signature))
-}
-
-/// Does a generic hash of the inputs returning the resulting 32 bytes separately.
-fn generic_hash_256<D: Digest>(message: &[u8]) -> Result<[u8; 32], String> {
-    let output_bytes: [u8; 32] =
-        D::digest(message).as_slice().try_into().map_err(|_| "digest should be 256 bits")?;
-
-    Ok(output_bytes)
-}
-
-fn verify_secp256k1_ecdsa_signature(
-    hashed_msg: &[u8],
-    public_key_x_bytes: &[u8; 32],
-    public_key_y_bytes: &[u8; 32],
-    signature: &[u8; 64],
-) -> bool {
-    use k256::elliptic_curve::sec1::FromEncodedPoint;
-    use k256::elliptic_curve::PrimeField;
-
-    use k256::{ecdsa::Signature, Scalar};
-    use k256::{
-        elliptic_curve::{
-            sec1::{Coordinates, ToEncodedPoint},
-            IsHigh,
-        },
-        AffinePoint, EncodedPoint, ProjectivePoint, PublicKey,
-    };
-    // Convert the inputs into k256 data structures
-
-    let Ok(signature) = Signature::try_from(signature.as_slice()) else {
-        // Signature `r` and `s` are forbidden from being zero.
-        return false;
-    };
-
-    let point = EncodedPoint::from_affine_coordinates(
-        public_key_x_bytes.into(),
-        public_key_y_bytes.into(),
-        true,
-    );
-
-    let pubkey = PublicKey::from_encoded_point(&point);
-    let pubkey = if pubkey.is_some().into() {
-        pubkey.unwrap()
-    } else {
-        // Public key must sit on the Secp256k1 curve.
-        return false;
-    };
-
-    // Note: This is incorrect as it will panic if `hashed_msg >= k256::Secp256k1::ORDER`.
-    // In this scenario we should just take the leftmost bits from `hashed_msg` up to the group order length.
-    let z = Scalar::from_repr(*GenericArray::from_slice(hashed_msg)).unwrap();
-
-    // Finished converting bytes into data structures
-
-    let r = signature.r();
-    let s = signature.s();
-
-    // Ensure signature is "low S" normalized ala BIP 0062
-    if s.is_high().into() {
-        return false;
-    }
-
-    let s_inv = s.invert().unwrap();
-    let u1 = z * s_inv;
-    let u2 = *r * s_inv;
-
-    #[allow(non_snake_case)]
-    let R: AffinePoint = ((ProjectivePoint::GENERATOR * u1)
-        + (ProjectivePoint::from(*pubkey.as_affine()) * u2))
-        .to_affine();
-
-    match R.to_encoded_point(false).coordinates() {
-        Coordinates::Uncompressed { x, y: _ } => Scalar::from_repr(*x).unwrap().eq(&r),
-        _ => unreachable!("Point is uncompressed"),
-    }
-}
-
-fn verify_secp256r1_ecdsa_signature(
-    hashed_msg: &[u8],
-    public_key_x_bytes: &[u8; 32],
-    public_key_y_bytes: &[u8; 32],
-    signature: &[u8; 64],
-) -> bool {
-    use p256::elliptic_curve::sec1::FromEncodedPoint;
-    use p256::elliptic_curve::PrimeField;
-
-    use p256::{ecdsa::Signature, Scalar};
-    use p256::{
-        elliptic_curve::{
-            sec1::{Coordinates, ToEncodedPoint},
-            IsHigh,
-        },
-        AffinePoint, EncodedPoint, ProjectivePoint, PublicKey,
-    };
-
-    // Convert the inputs into k256 data structures
-
-    let Ok(signature) = Signature::try_from(signature.as_slice()) else {
-        // Signature `r` and `s` are forbidden from being zero.
-        return false;
-    };
-
-    let point = EncodedPoint::from_affine_coordinates(
-        public_key_x_bytes.into(),
-        public_key_y_bytes.into(),
-        true,
-    );
-
-    let pubkey = PublicKey::from_encoded_point(&point);
-    let pubkey = if pubkey.is_some().into() {
-        pubkey.unwrap()
-    } else {
-        // Public key must sit on the Secp256r1 curve.
-        return false;
-    };
-
-    // Note: This is incorrect as it will panic if `hashed_msg >= p256::NistP256::ORDER`.
-    // In this scenario we should just take the leftmost bits from `hashed_msg` up to the group order length.
-    let z = Scalar::from_repr(*GenericArray::from_slice(hashed_msg)).unwrap();
-
-    // Finished converting bytes into data structures
-
-    let r = signature.r();
-    let s = signature.s();
-
-    // Ensure signature is "low S" normalized ala BIP 0062
-    if s.is_high().into() {
-        return false;
-    }
-
-    let s_inv = s.invert().unwrap();
-    let u1 = z * s_inv;
-    let u2 = *r * s_inv;
-
-    #[allow(non_snake_case)]
-    let R: AffinePoint = ((ProjectivePoint::GENERATOR * u1)
-        + (ProjectivePoint::from(*pubkey.as_affine()) * u2))
-        .to_affine();
-
-    match R.to_encoded_point(false).coordinates() {
-        Coordinates::Uncompressed { x, y: _ } => Scalar::from_repr(*x).unwrap().eq(&r),
-        _ => unreachable!("Point is uncompressed"),
-    }
-}
-
-#[cfg(test)]
-mod keccakf1600_tests {
-    use crate::keccakf1600;
-
-    #[test]
-    fn sanity_check() {
-        // Test vectors are copied from XKCP (eXtended Keccak Code Package)
-        // https://github.com/XKCP/XKCP/blob/master/tests/TestVectors/KeccakF-1600-IntermediateValues.txt
-        let zero_state = [0u64; 25];
-
-        let expected_state_first = [
-            0xF1258F7940E1DDE7,
-            0x84D5CCF933C0478A,
-            0xD598261EA65AA9EE,
-            0xBD1547306F80494D,
-            0x8B284E056253D057,
-            0xFF97A42D7F8E6FD4,
-            0x90FEE5A0A44647C4,
-            0x8C5BDA0CD6192E76,
-            0xAD30A6F71B19059C,
-            0x30935AB7D08FFC64,
-            0xEB5AA93F2317D635,
-            0xA9A6E6260D712103,
-            0x81A57C16DBCF555F,
-            0x43B831CD0347C826,
-            0x01F22F1A11A5569F,
-            0x05E5635A21D9AE61,
-            0x64BEFEF28CC970F2,
-            0x613670957BC46611,
-            0xB87C5A554FD00ECB,
-            0x8C3EE88A1CCF32C8,
-            0x940C7922AE3A2614,
-            0x1841F924A2C509E4,
-            0x16F53526E70465C2,
-            0x75F644E97F30A13B,
-            0xEAF1FF7B5CECA249,
-        ];
-        let expected_state_second = [
-            0x2D5C954DF96ECB3C,
-            0x6A332CD07057B56D,
-            0x093D8D1270D76B6C,
-            0x8A20D9B25569D094,
-            0x4F9C4F99E5E7F156,
-            0xF957B9A2DA65FB38,
-            0x85773DAE1275AF0D,
-            0xFAF4F247C3D810F7,
-            0x1F1B9EE6F79A8759,
-            0xE4FECC0FEE98B425,
-            0x68CE61B6B9CE68A1,
-            0xDEEA66C4BA8F974F,
-            0x33C43D836EAFB1F5,
-            0xE00654042719DBD9,
-            0x7CF8A9F009831265,
-            0xFD5449A6BF174743,
-            0x97DDAD33D8994B40,
-            0x48EAD5FC5D0BE774,
-            0xE3B8C8EE55B7B03C,
-            0x91A0226E649E42E9,
-            0x900E3129E7BADD7B,
-            0x202A9EC5FAA3CCE8,
-            0x5B3402464E1C3DB6,
-            0x609F4E62A44C1059,
-            0x20D06CD26A8FBF5C,
-        ];
-
-        let state_first = keccakf1600(zero_state).unwrap();
-        let state_second = keccakf1600(state_first).unwrap();
-
-        assert_eq!(state_first, expected_state_first);
-        assert_eq!(state_second, expected_state_second);
-    }
-}
-
-#[cfg(test)]
-mod secp256k1_tests {
-    use super::verify_secp256k1_ecdsa_signature;
-
-    // 0x3a73f4123a5cd2121f21cd7e8d358835476949d035d9c2da6806b4633ac8c1e2,
-    const HASHED_MESSAGE: [u8; 32] = [
-        0x3a, 0x73, 0xf4, 0x12, 0x3a, 0x5c, 0xd2, 0x12, 0x1f, 0x21, 0xcd, 0x7e, 0x8d, 0x35, 0x88,
-        0x35, 0x47, 0x69, 0x49, 0xd0, 0x35, 0xd9, 0xc2, 0xda, 0x68, 0x06, 0xb4, 0x63, 0x3a, 0xc8,
-        0xc1, 0xe2,
-    ];
-    // 0xa0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7
-    const PUB_KEY_X: [u8; 32] = [
-        0xa0, 0x43, 0x4d, 0x9e, 0x47, 0xf3, 0xc8, 0x62, 0x35, 0x47, 0x7c, 0x7b, 0x1a, 0xe6, 0xae,
-        0x5d, 0x34, 0x42, 0xd4, 0x9b, 0x19, 0x43, 0xc2, 0xb7, 0x52, 0xa6, 0x8e, 0x2a, 0x47, 0xe2,
-        0x47, 0xc7,
-    ];
-    // 0x893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7
-    const PUB_KEY_Y: [u8; 32] = [
-        0x89, 0x3a, 0xba, 0x42, 0x54, 0x19, 0xbc, 0x27, 0xa3, 0xb6, 0xc7, 0xe6, 0x93, 0xa2, 0x4c,
-        0x69, 0x6f, 0x79, 0x4c, 0x2e, 0xd8, 0x77, 0xa1, 0x59, 0x3c, 0xbe, 0xe5, 0x3b, 0x03, 0x73,
-        0x68, 0xd7,
-    ];
-    // 0xe5081c80ab427dc370346f4a0e31aa2bad8d9798c38061db9ae55a4e8df454fd28119894344e71b78770cc931d61f480ecbb0b89d6eb69690161e49a715fcd55
-    const SIGNATURE: [u8; 64] = [
-        0xe5, 0x08, 0x1c, 0x80, 0xab, 0x42, 0x7d, 0xc3, 0x70, 0x34, 0x6f, 0x4a, 0x0e, 0x31, 0xaa,
-        0x2b, 0xad, 0x8d, 0x97, 0x98, 0xc3, 0x80, 0x61, 0xdb, 0x9a, 0xe5, 0x5a, 0x4e, 0x8d, 0xf4,
-        0x54, 0xfd, 0x28, 0x11, 0x98, 0x94, 0x34, 0x4e, 0x71, 0xb7, 0x87, 0x70, 0xcc, 0x93, 0x1d,
-        0x61, 0xf4, 0x80, 0xec, 0xbb, 0x0b, 0x89, 0xd6, 0xeb, 0x69, 0x69, 0x01, 0x61, 0xe4, 0x9a,
-        0x71, 0x5f, 0xcd, 0x55,
-    ];
-
-    #[test]
-    fn verifies_valid_signature_with_low_s_value() {
-        let valid =
-            verify_secp256k1_ecdsa_signature(&HASHED_MESSAGE, &PUB_KEY_X, &PUB_KEY_Y, &SIGNATURE);
-
-        assert!(valid);
-    }
-
-    #[test]
-    fn rejects_invalid_signature() {
-        // This signature is invalid as ECDSA specifies that `r` and `s` must be non-zero.
-        let invalid_signature: [u8; 64] = [0x00; 64];
-
-        let valid = verify_secp256k1_ecdsa_signature(
-            &HASHED_MESSAGE,
-            &PUB_KEY_X,
-            &PUB_KEY_Y,
-            &invalid_signature,
-        );
-        assert!(!valid);
-    }
-
-    #[test]
-    fn rejects_invalid_public_key() {
-        let invalid_pub_key_x: [u8; 32] = [0xff; 32];
-        let invalid_pub_key_y: [u8; 32] = [0xff; 32];
-
-        let valid = verify_secp256k1_ecdsa_signature(
-            &HASHED_MESSAGE,
-            &invalid_pub_key_x,
-            &invalid_pub_key_y,
-            &SIGNATURE,
-        );
-
-        assert!(!valid);
-    }
-
-    #[test]
-    #[ignore = "ECDSA verification does not currently handle long hashes correctly"]
-    fn trims_overly_long_hashes_to_correct_length() {
-        let mut long_hashed_message = HASHED_MESSAGE.to_vec();
-        long_hashed_message.push(0xff);
-
-        let valid = verify_secp256k1_ecdsa_signature(
-            &long_hashed_message,
-            &PUB_KEY_X,
-            &PUB_KEY_Y,
-            &SIGNATURE,
-        );
-
-        assert!(valid);
-    }
-}
-
-#[cfg(test)]
-mod secp256r1_tests {
-    use super::verify_secp256r1_ecdsa_signature;
-
-    // 0x54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad
-    const HASHED_MESSAGE: [u8; 32] = [
-        84, 112, 91, 163, 186, 175, 219, 223, 186, 140, 95, 154, 112, 247, 168, 155, 238, 152, 217,
-        6, 181, 62, 49, 7, 77, 167, 186, 236, 220, 13, 169, 173,
-    ];
-    // 0x550f471003f3df97c3df506ac797f6721fb1a1fb7b8f6f83d224498a65c88e24
-    const PUB_KEY_X: [u8; 32] = [
-        85, 15, 71, 16, 3, 243, 223, 151, 195, 223, 80, 106, 199, 151, 246, 114, 31, 177, 161, 251,
-        123, 143, 111, 131, 210, 36, 73, 138, 101, 200, 142, 36,
-    ];
-    // 0x136093d7012e509a73715cbd0b00a3cc0ff4b5c01b3ffa196ab1fb327036b8e6
-    const PUB_KEY_Y: [u8; 32] = [
-        19, 96, 147, 215, 1, 46, 80, 154, 115, 113, 92, 189, 11, 0, 163, 204, 15, 244, 181, 192,
-        27, 63, 250, 25, 106, 177, 251, 50, 112, 54, 184, 230,
-    ];
-    // 0x2c70a8d084b62bfc5ce03641caf9f72ad4da8c81bfe6ec9487bb5e1bef62a13218ad9ee29eaf351fdc50f1520c425e9b908a07278b43b0ec7b872778c14e0784
-    const SIGNATURE: [u8; 64] = [
-        44, 112, 168, 208, 132, 182, 43, 252, 92, 224, 54, 65, 202, 249, 247, 42, 212, 218, 140,
-        129, 191, 230, 236, 148, 135, 187, 94, 27, 239, 98, 161, 50, 24, 173, 158, 226, 158, 175,
-        53, 31, 220, 80, 241, 82, 12, 66, 94, 155, 144, 138, 7, 39, 139, 67, 176, 236, 123, 135,
-        39, 120, 193, 78, 7, 132,
-    ];
-
-    #[test]
-    fn verifies_valid_signature_with_low_s_value() {
-        let valid =
-            verify_secp256r1_ecdsa_signature(&HASHED_MESSAGE, &PUB_KEY_X, &PUB_KEY_Y, &SIGNATURE);
-
-        assert!(valid);
-    }
-
-    #[test]
-    fn rejects_invalid_signature() {
-        // This signature is invalid as ECDSA specifies that `r` and `s` must be non-zero.
-        let invalid_signature: [u8; 64] = [0x00; 64];
-
-        let valid = verify_secp256r1_ecdsa_signature(
-            &HASHED_MESSAGE,
-            &PUB_KEY_X,
-            &PUB_KEY_Y,
-            &invalid_signature,
-        );
-        assert!(!valid);
-    }
-
-    #[test]
-    fn rejects_invalid_public_key() {
-        let invalid_pub_key_x: [u8; 32] = [0xff; 32];
-        let invalid_pub_key_y: [u8; 32] = [0xff; 32];
-
-        let valid = verify_secp256r1_ecdsa_signature(
-            &HASHED_MESSAGE,
-            &invalid_pub_key_x,
-            &invalid_pub_key_y,
-            &SIGNATURE,
-        );
-
-        assert!(!valid);
-    }
-
-    #[test]
-    #[ignore = "ECDSA verification does not currently handle long hashes correctly"]
-    fn trims_overly_long_hashes_to_correct_length() {
-        let mut long_hashed_message = HASHED_MESSAGE.to_vec();
-        long_hashed_message.push(0xff);
-
-        let valid = verify_secp256r1_ecdsa_signature(
-            &long_hashed_message,
-            &PUB_KEY_X,
-            &PUB_KEY_Y,
-            &SIGNATURE,
-        );
-
-        assert!(valid);
-    }
-}

From e24d3fc5a084610d9511e3c5421275cb9c84a548 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Tue, 12 Mar 2024 12:42:14 +0100
Subject: [PATCH 066/416] fix: Dynamic assert messages in brillig (#4531)

# Description

## Problem\*

Temporary regisers are not conserved when calling and returning from
another function, only alive variables are conserved. The condition in
an assert was computed before the call to the dynamic message handler so
it could be overwritten by the callee. I just compute the condition
after the potential call.

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index c04d8475f08..7330269fb4b 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -248,17 +248,6 @@ impl<'block> BrilligBlock<'block> {
                 self.convert_ssa_binary(binary, dfg, result_var);
             }
             Instruction::Constrain(lhs, rhs, assert_message) => {
-                let condition = SingleAddrVariable {
-                    address: self.brillig_context.allocate_register(),
-                    bit_size: 1,
-                };
-
-                self.convert_ssa_binary(
-                    &Binary { lhs: *lhs, rhs: *rhs, operator: BinaryOp::Eq },
-                    dfg,
-                    condition,
-                );
-
                 let assert_message = if let Some(error) = assert_message {
                     match error.as_ref() {
                         ConstrainError::Static(string) => Some(string.clone()),
@@ -282,6 +271,17 @@ impl<'block> BrilligBlock<'block> {
                     None
                 };
 
+                let condition = SingleAddrVariable {
+                    address: self.brillig_context.allocate_register(),
+                    bit_size: 1,
+                };
+
+                self.convert_ssa_binary(
+                    &Binary { lhs: *lhs, rhs: *rhs, operator: BinaryOp::Eq },
+                    dfg,
+                    condition,
+                );
+
                 self.brillig_context.constrain_instruction(condition.address, assert_message);
                 self.brillig_context.deallocate_register(condition.address);
             }

From 604ee8f2d559d8ac8420c5a449904f2bd6ffe32e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 12 Mar 2024 13:30:40 +0000
Subject: [PATCH 067/416] chore: generalise `FunctionVisibility` to
 `ItemVisibility` (#4495)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This pulls out a renaming from #4491.

We have the concept of `FunctionVisibility` which determines whether a
function can be called from other modules in the same crate/other
crates.

If we're expanding the same concept of visibility to items other than
functions we need a generic name for this which doesn't mention
functions. I've then renamed it to `ModuleVisibility` to reflect that it
shows how this item is visible in other modules but I'm open to
suggestions.


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 aztec_macros/src/lib.rs                        | 17 +++++++++--------
 compiler/noirc_frontend/src/ast/expression.rs  |  6 +++---
 compiler/noirc_frontend/src/ast/mod.rs         |  4 ++--
 .../src/hir/def_collector/dc_mod.rs            |  2 +-
 .../src/hir/def_map/item_scope.rs              | 13 ++++---------
 .../src/hir/def_map/namespace.rs               | 11 ++++++-----
 .../src/hir/resolution/resolver.rs             | 18 ++++++++----------
 compiler/noirc_frontend/src/lib.rs             | 11 +++++------
 compiler/noirc_frontend/src/node_interner.rs   |  8 ++++----
 .../src/parser/parser/function.rs              | 12 ++++++------
 .../noirc_frontend/src/parser/parser/traits.rs |  6 +++---
 11 files changed, 51 insertions(+), 57 deletions(-)

diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index f9df3f10129..c21e26bdcad 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -10,18 +10,19 @@ use noirc_frontend::macros_api::parse_program;
 use noirc_frontend::macros_api::FieldElement;
 use noirc_frontend::macros_api::{
     BlockExpression, CallExpression, CastExpression, Distinctness, Expression, ExpressionKind,
-    ForLoopStatement, ForRange, FunctionDefinition, FunctionReturnType, FunctionVisibility,
-    HirContext, HirExpression, HirLiteral, HirStatement, Ident, IndexExpression, LetStatement,
-    Literal, MemberAccessExpression, MethodCallExpression, NoirFunction, NoirStruct, Param, Path,
-    PathKind, Pattern, PrefixExpression, SecondaryAttribute, Signedness, Span, Statement,
-    StatementKind, StructType, Type, TypeImpl, UnaryOp, UnresolvedType, UnresolvedTypeData,
-    Visibility,
+    ForLoopStatement, ForRange, FunctionDefinition, FunctionReturnType, HirContext, HirExpression,
+    HirLiteral, HirStatement, Ident, IndexExpression, LetStatement, Literal,
+    MemberAccessExpression, MethodCallExpression, NoirFunction, NoirStruct, Param, Path, PathKind,
+    Pattern, PrefixExpression, SecondaryAttribute, Signedness, Span, Statement, StatementKind,
+    StructType, Type, TypeImpl, UnaryOp, UnresolvedType, UnresolvedTypeData, Visibility,
 };
 use noirc_frontend::macros_api::{CrateId, FileId};
 use noirc_frontend::macros_api::{MacroError, MacroProcessor};
 use noirc_frontend::macros_api::{ModuleDefId, NodeInterner, SortedModule, StructId};
 use noirc_frontend::node_interner::{FuncId, TraitId, TraitImplId, TraitImplKind};
-use noirc_frontend::{BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, Lambda};
+use noirc_frontend::{
+    BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, ItemVisibility, Lambda,
+};
 pub struct AztecMacro;
 
 impl MacroProcessor for AztecMacro {
@@ -1100,7 +1101,7 @@ fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
         &return_type,
     );
 
-    selector_fn_def.visibility = FunctionVisibility::Public;
+    selector_fn_def.visibility = ItemVisibility::Public;
 
     // Seems to be necessary on contract modules
     selector_fn_def.return_visibility = Visibility::Public;
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 2a252633a29..def1b082890 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -3,7 +3,7 @@ use std::fmt::Display;
 
 use crate::token::{Attributes, Token};
 use crate::{
-    Distinctness, FunctionVisibility, Ident, Path, Pattern, Recoverable, Statement, StatementKind,
+    Distinctness, Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
 use acvm::FieldElement;
@@ -378,7 +378,7 @@ pub struct FunctionDefinition {
     pub is_unconstrained: bool,
 
     /// Indicate if this function was defined with the 'pub' keyword
-    pub visibility: FunctionVisibility,
+    pub visibility: ItemVisibility,
 
     pub generics: UnresolvedGenerics,
     pub parameters: Vec<Param>,
@@ -677,7 +677,7 @@ impl FunctionDefinition {
             is_open: false,
             is_internal: false,
             is_unconstrained: false,
-            visibility: FunctionVisibility::Private,
+            visibility: ItemVisibility::Private,
             generics: generics.clone(),
             parameters: p,
             body: body.clone(),
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 29edbaca594..8a420c32fb8 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -354,8 +354,8 @@ impl UnresolvedTypeExpression {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-/// Represents whether the function can be called outside its module/crate
-pub enum FunctionVisibility {
+/// Represents whether the definition can be referenced outside its module/crate
+pub enum ItemVisibility {
     Public,
     Private,
     PublicCrate,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 5b2f815d636..6ac263d80be 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -394,7 +394,7 @@ impl<'a> ModCollector<'a> {
 
                         let modifiers = FunctionModifiers {
                             name: name.to_string(),
-                            visibility: crate::FunctionVisibility::Public,
+                            visibility: crate::ItemVisibility::Public,
                             // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629
                             attributes: crate::token::Attributes::empty(),
                             is_unconstrained: false,
diff --git a/compiler/noirc_frontend/src/hir/def_map/item_scope.rs b/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
index 523def89518..178b91e1e84 100644
--- a/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
@@ -1,16 +1,11 @@
 use super::{namespace::PerNs, ModuleDefId, ModuleId};
 use crate::{
     node_interner::{FuncId, TraitId},
-    Ident,
+    Ident, ItemVisibility,
 };
 use std::collections::{hash_map::Entry, HashMap};
 
-type Scope = HashMap<Option<TraitId>, (ModuleDefId, Visibility, bool /*is_prelude*/)>;
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum Visibility {
-    Public,
-}
+type Scope = HashMap<Option<TraitId>, (ModuleDefId, ItemVisibility, bool /*is_prelude*/)>;
 
 #[derive(Default, Debug, PartialEq, Eq)]
 pub struct ItemScope {
@@ -55,12 +50,12 @@ impl ItemScope {
                         Err((old_ident.clone(), name))
                     }
                 } else {
-                    trait_hashmap.insert(trait_id, (mod_def, Visibility::Public, is_prelude));
+                    trait_hashmap.insert(trait_id, (mod_def, ItemVisibility::Public, is_prelude));
                     Ok(())
                 }
             } else {
                 let mut trait_hashmap = HashMap::new();
-                trait_hashmap.insert(trait_id, (mod_def, Visibility::Public, is_prelude));
+                trait_hashmap.insert(trait_id, (mod_def, ItemVisibility::Public, is_prelude));
                 map.insert(name, trait_hashmap);
                 Ok(())
             }
diff --git a/compiler/noirc_frontend/src/hir/def_map/namespace.rs b/compiler/noirc_frontend/src/hir/def_map/namespace.rs
index ca14d9f8617..5e349f46e14 100644
--- a/compiler/noirc_frontend/src/hir/def_map/namespace.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/namespace.rs
@@ -1,15 +1,16 @@
-use super::{item_scope::Visibility, ModuleDefId};
+use super::ModuleDefId;
+use crate::ItemVisibility;
 
 // This works exactly the same as in r-a, just simplified
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct PerNs {
-    pub types: Option<(ModuleDefId, Visibility, bool)>,
-    pub values: Option<(ModuleDefId, Visibility, bool)>,
+    pub types: Option<(ModuleDefId, ItemVisibility, bool)>,
+    pub values: Option<(ModuleDefId, ItemVisibility, bool)>,
 }
 
 impl PerNs {
     pub fn types(t: ModuleDefId) -> PerNs {
-        PerNs { types: Some((t, Visibility::Public, false)), values: None }
+        PerNs { types: Some((t, ItemVisibility::Public, false)), values: None }
     }
 
     pub fn take_types(self) -> Option<ModuleDefId> {
@@ -24,7 +25,7 @@ impl PerNs {
         self.types.map(|it| it.0).into_iter().chain(self.values.map(|it| it.0))
     }
 
-    pub fn iter_items(self) -> impl Iterator<Item = (ModuleDefId, Visibility, bool)> {
+    pub fn iter_items(self) -> impl Iterator<Item = (ModuleDefId, ItemVisibility, bool)> {
         self.types.into_iter().chain(self.values)
     }
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 875d0ceb85e..567cc20f789 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -38,8 +38,8 @@ use crate::{
 };
 use crate::{
     ArrayLiteral, ContractFunctionType, Distinctness, ForRange, FunctionDefinition,
-    FunctionReturnType, FunctionVisibility, Generics, LValue, NoirStruct, NoirTypeAlias, Param,
-    Path, PathKind, Pattern, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind,
+    FunctionReturnType, Generics, ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path,
+    PathKind, Pattern, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind,
     UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData,
     UnresolvedTypeExpression, Visibility, ERROR_IDENT,
 };
@@ -237,7 +237,7 @@ impl<'a> Resolver<'a> {
             is_open: false,
             is_internal: false,
             is_unconstrained: false,
-            visibility: FunctionVisibility::Public, // Trait functions are always public
+            visibility: ItemVisibility::Public, // Trait functions are always public
             generics: generics.clone(),
             parameters: vecmap(parameters, |(name, typ)| Param {
                 visibility: Visibility::Private,
@@ -1320,7 +1320,7 @@ impl<'a> Resolver<'a> {
         &mut self,
         func: FuncId,
         span: Span,
-        visibility: FunctionVisibility,
+        visibility: ItemVisibility,
     ) {
         let function_module = self.interner.function_module(func);
         let current_module = self.path_resolver.module_id();
@@ -1330,8 +1330,8 @@ impl<'a> Resolver<'a> {
         let current_module = current_module.local_id;
         let name = self.interner.function_name(&func).to_string();
         match visibility {
-            FunctionVisibility::Public => (),
-            FunctionVisibility::Private => {
+            ItemVisibility::Public => (),
+            ItemVisibility::Private => {
                 if !same_crate
                     || !self.module_descendent_of_target(
                         krate,
@@ -1342,7 +1342,7 @@ impl<'a> Resolver<'a> {
                     self.errors.push(ResolverError::PrivateFunctionCalled { span, name });
                 }
             }
-            FunctionVisibility::PublicCrate => {
+            ItemVisibility::PublicCrate => {
                 if !same_crate {
                     self.errors.push(ResolverError::NonCrateFunctionCalled { span, name });
                 }
@@ -1451,9 +1451,7 @@ impl<'a> Resolver<'a> {
                                     self.interner.add_function_dependency(current_item, id);
                                 }
 
-                                if self.interner.function_visibility(id)
-                                    != FunctionVisibility::Public
-                                {
+                                if self.interner.function_visibility(id) != ItemVisibility::Public {
                                     let span = hir_ident.location.span;
                                     self.check_can_reference_function(
                                         id,
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index be007929fc4..800d66b0dfb 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -56,14 +56,13 @@ pub mod macros_api {
     pub use crate::hir::def_map::ModuleDefId;
     pub use crate::{
         hir::Context as HirContext, BlockExpression, CallExpression, CastExpression, Distinctness,
-        Expression, ExpressionKind, FunctionReturnType, Ident, IndexExpression, LetStatement,
-        Literal, MemberAccessExpression, MethodCallExpression, NoirFunction, Path, PathKind,
-        Pattern, Statement, UnresolvedType, UnresolvedTypeData, Visibility,
+        Expression, ExpressionKind, FunctionReturnType, Ident, IndexExpression, ItemVisibility,
+        LetStatement, Literal, MemberAccessExpression, MethodCallExpression, NoirFunction, Path,
+        PathKind, Pattern, Statement, UnresolvedType, UnresolvedTypeData, Visibility,
     };
     pub use crate::{
-        ForLoopStatement, ForRange, FunctionDefinition, FunctionVisibility, ImportStatement,
-        NoirStruct, Param, PrefixExpression, Signedness, StatementKind, StructType, Type, TypeImpl,
-        UnaryOp,
+        ForLoopStatement, ForRange, FunctionDefinition, ImportStatement, NoirStruct, Param,
+        PrefixExpression, Signedness, StatementKind, StructType, Type, TypeImpl, UnaryOp,
     };
 
     /// Methods to process the AST before and after type checking
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 5de43e59254..dc632527898 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -28,7 +28,7 @@ use crate::hir_def::{
 };
 use crate::token::{Attributes, SecondaryAttribute};
 use crate::{
-    BinaryOpKind, ContractFunctionType, FunctionDefinition, FunctionVisibility, Generics, Shared,
+    BinaryOpKind, ContractFunctionType, FunctionDefinition, Generics, ItemVisibility, Shared,
     TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind,
 };
 
@@ -236,7 +236,7 @@ pub struct FunctionModifiers {
     pub name: String,
 
     /// Whether the function is `pub` or not.
-    pub visibility: FunctionVisibility,
+    pub visibility: ItemVisibility,
 
     pub attributes: Attributes,
 
@@ -259,7 +259,7 @@ impl FunctionModifiers {
     pub fn new() -> Self {
         Self {
             name: String::new(),
-            visibility: FunctionVisibility::Public,
+            visibility: ItemVisibility::Public,
             attributes: Attributes::empty(),
             is_unconstrained: false,
             is_internal: None,
@@ -799,7 +799,7 @@ impl NodeInterner {
     ///
     /// The underlying function_visibilities map is populated during def collection,
     /// so this function can be called anytime afterward.
-    pub fn function_visibility(&self, func: FuncId) -> FunctionVisibility {
+    pub fn function_visibility(&self, func: FuncId) -> ItemVisibility {
         self.function_modifiers[&func].visibility
     }
 
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 7448d84cfe1..a2a4577a993 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -8,7 +8,7 @@ use crate::parser::labels::ParsingRuleLabel;
 use crate::parser::spanned;
 use crate::token::{Keyword, Token};
 use crate::{
-    Distinctness, FunctionDefinition, FunctionReturnType, FunctionVisibility, Ident, NoirFunction,
+    Distinctness, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction,
     Param, Visibility,
 };
 
@@ -53,16 +53,16 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
 }
 
 /// visibility_modifier: 'pub(crate)'? 'pub'? ''
-fn visibility_modifier() -> impl NoirParser<FunctionVisibility> {
+fn visibility_modifier() -> impl NoirParser<ItemVisibility> {
     let is_pub_crate = (keyword(Keyword::Pub)
         .then_ignore(just(Token::LeftParen))
         .then_ignore(keyword(Keyword::Crate))
         .then_ignore(just(Token::RightParen)))
-    .map(|_| FunctionVisibility::PublicCrate);
+    .map(|_| ItemVisibility::PublicCrate);
 
-    let is_pub = keyword(Keyword::Pub).map(|_| FunctionVisibility::Public);
+    let is_pub = keyword(Keyword::Pub).map(|_| ItemVisibility::Public);
 
-    let is_private = empty().map(|_| FunctionVisibility::Private);
+    let is_private = empty().map(|_| ItemVisibility::Private);
 
     choice((is_pub_crate, is_pub, is_private))
 }
@@ -70,7 +70,7 @@ fn visibility_modifier() -> impl NoirParser<FunctionVisibility> {
 /// function_modifiers: 'unconstrained'? (visibility)? 'open'?
 ///
 /// returns (is_unconstrained, visibility, is_open) for whether each keyword was present
-fn function_modifiers() -> impl NoirParser<(bool, FunctionVisibility, bool)> {
+fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility, bool)> {
     keyword(Keyword::Unconstrained)
         .or_not()
         .then(visibility_modifier())
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
index 0d72fbd5303..df8d50178d5 100644
--- a/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -11,7 +11,7 @@ use crate::{
         ParserErrorReason, TopLevelStatement,
     },
     token::{Keyword, Token},
-    Expression, FunctionVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem, TraitItem,
+    Expression, ItemVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem, TraitItem,
     UnresolvedTraitConstraint, UnresolvedType,
 };
 
@@ -123,12 +123,12 @@ fn trait_implementation_body() -> impl NoirParser<Vec<TraitImplItem>> {
         if f.def().is_internal
             || f.def().is_unconstrained
             || f.def().is_open
-            || f.def().visibility != FunctionVisibility::Private
+            || f.def().visibility != ItemVisibility::Private
         {
             emit(ParserError::with_reason(ParserErrorReason::TraitImplFunctionModifiers, span));
         }
         // Trait impl functions are always public
-        f.def_mut().visibility = FunctionVisibility::Public;
+        f.def_mut().visibility = ItemVisibility::Public;
         TraitImplItem::Function(f)
     });
 

From 00d6494ae70b10e1872d96fb4e57ecb0b5f01787 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 12 Mar 2024 17:41:33 -0500
Subject: [PATCH 068/416] fix: Allow non-integer globals to reference struct
 methods (#4490)

# Description

## Problem\*

Resolves #1440

## Summary\*

This was a fairly simple change - non-integer globals used to be
resolved before struct methods were even collected. I've moved this to
after methods are collected. Now global resolution is the first step of
resolving in general.

Integer globals are still resolved early since structs may refer to them
in numeric generics.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/def_collector/dc_crate.rs           | 10 +++++-----
 .../execution_success/global_consts/src/main.nr | 17 +++++++++++++++++
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 62febc89899..a5dfc738824 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -327,11 +327,6 @@ impl DefCollector {
         // Must resolve structs before we resolve globals.
         errors.extend(resolve_structs(context, def_collector.collected_types, crate_id));
 
-        // We must wait to resolve non-integer globals until after we resolve structs since struct
-        // globals will need to reference the struct type they're initialized to to ensure they are valid.
-        resolved_globals.extend(resolve_globals(context, other_globals, crate_id));
-        errors.extend(resolved_globals.errors);
-
         // Bind trait impls to their trait. Collect trait functions, that have a
         // default implementation, which hasn't been overridden.
         errors.extend(collect_trait_impls(
@@ -349,6 +344,11 @@ impl DefCollector {
         // over trait methods if there are name conflicts.
         errors.extend(collect_impls(context, crate_id, &def_collector.collected_impls));
 
+        // We must wait to resolve non-integer globals until after we resolve structs since struct
+        // globals will need to reference the struct type they're initialized to to ensure they are valid.
+        resolved_globals.extend(resolve_globals(context, other_globals, crate_id));
+        errors.extend(resolved_globals.errors);
+
         // Resolve each function in the crate. This is now possible since imports have been resolved
         let mut functions = Vec::new();
         functions.extend(resolve_free_functions(
diff --git a/test_programs/execution_success/global_consts/src/main.nr b/test_programs/execution_success/global_consts/src/main.nr
index 3c8ecc67a0c..52ffe3e823b 100644
--- a/test_programs/execution_success/global_consts/src/main.nr
+++ b/test_programs/execution_success/global_consts/src/main.nr
@@ -107,3 +107,20 @@ mod my_submodule {
         x
     }
 }
+
+struct Foo {
+  a: Field,
+}
+
+struct Bar {}
+
+impl Bar {
+    fn get_a() -> Field {
+        1
+    }
+}
+
+// Regression for #1440
+global foo = Foo {
+    a: Bar::get_a(),
+};

From f3243b763c0b15ae90beb8e35630df27f3d314c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Wed, 13 Mar 2024 12:53:35 +0100
Subject: [PATCH 069/416] feat: Add checks for bit size consistency on brillig
 gen (#4542)

# Description

## Problem\*

Adds checks for brillig codegen for #4369 (Previously we only had
consistency checks in SSA).

## Summary\*

This checks have caught some inconsistencies in the process, including
those that were caught manually in
https://github.com/AztecProtocol/aztec-packages/pull/5091

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 209 ++++++-------
 .../brillig_gen/brillig_block_variables.rs    |  19 +-
 .../src/brillig/brillig_gen/brillig_fn.rs     |  14 +-
 .../brillig/brillig_gen/brillig_slice_ops.rs  |  88 ++++--
 .../noirc_evaluator/src/brillig/brillig_ir.rs | 285 +++++++++++-------
 .../brillig/brillig_ir/brillig_variable.rs    |  12 +
 .../src/brillig/brillig_ir/debug_show.rs      |  22 +-
 .../src/brillig/brillig_ir/entry_point.rs     |  22 +-
 .../src/ssa/function_builder/data_bus.rs      |   2 +-
 9 files changed, 368 insertions(+), 305 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 7330269fb4b..530b6dc69fc 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1,7 +1,9 @@
 use crate::brillig::brillig_ir::brillig_variable::{
     type_to_heap_value_type, BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable,
 };
-use crate::brillig::brillig_ir::{BrilligBinaryOp, BrilligContext};
+use crate::brillig::brillig_ir::{
+    BrilligBinaryOp, BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+};
 use crate::ssa::ir::dfg::CallStack;
 use crate::ssa::ir::instruction::ConstrainError;
 use crate::ssa::ir::{
@@ -23,7 +25,7 @@ use num_bigint::BigUint;
 
 use super::brillig_black_box::convert_black_box_call;
 use super::brillig_block_variables::BlockVariables;
-use super::brillig_fn::{get_bit_size_from_ssa_type, FunctionContext};
+use super::brillig_fn::FunctionContext;
 
 /// Generate the compilation artifacts for compiling a function into brillig bytecode.
 pub(crate) struct BrilligBlock<'block> {
@@ -282,8 +284,8 @@ impl<'block> BrilligBlock<'block> {
                     condition,
                 );
 
-                self.brillig_context.constrain_instruction(condition.address, assert_message);
-                self.brillig_context.deallocate_register(condition.address);
+                self.brillig_context.constrain_instruction(condition, assert_message);
+                self.brillig_context.deallocate_single_addr(condition);
             }
             Instruction::Allocate => {
                 let result_value = dfg.instruction_results(instruction_id)[0];
@@ -496,10 +498,10 @@ impl<'block> BrilligBlock<'block> {
                     self.brillig_context.mov_instruction(target_len.address, limb_count.address);
 
                     self.brillig_context.radix_instruction(
-                        source.address,
+                        source,
                         target_vector,
-                        radix.address,
-                        limb_count.address,
+                        radix,
+                        limb_count,
                         matches!(endianness, Endian::Big),
                     );
                 }
@@ -530,22 +532,20 @@ impl<'block> BrilligBlock<'block> {
                         BrilligVariable::SingleAddr(..) => unreachable!("ICE: ToBits on non-array"),
                     };
 
-                    let radix = self
-                        .brillig_context
-                        .make_constant(2_usize.into(), FieldElement::max_num_bits());
+                    let radix = self.brillig_context.make_constant(2_usize.into(), 32);
 
                     // Update the user-facing slice length
                     self.brillig_context.mov_instruction(target_len.address, limb_count.address);
 
                     self.brillig_context.radix_instruction(
-                        source.address,
+                        source,
                         target_vector,
                         radix,
-                        limb_count.address,
+                        limb_count,
                         matches!(endianness, Endian::Big),
                     );
 
-                    self.brillig_context.deallocate_register(radix);
+                    self.brillig_context.deallocate_single_addr(radix);
                 }
                 _ => {
                     unreachable!("unsupported function call type {:?}", dfg[*func])
@@ -597,7 +597,7 @@ impl<'block> BrilligBlock<'block> {
                 self.validate_array_index(array_variable, index_variable);
                 self.retrieve_variable_from_array(
                     array_pointer,
-                    index_variable.address,
+                    index_variable,
                     destination_variable,
                 );
             }
@@ -641,22 +641,20 @@ impl<'block> BrilligBlock<'block> {
                     );
 
                     // Check if lte max
-                    let brillig_binary_op = BrilligBinaryOp::Integer {
-                        op: BinaryIntOp::LessThanEquals,
-                        bit_size: FieldElement::max_num_bits(),
-                    };
-                    let condition = self.brillig_context.allocate_register();
+                    let brillig_binary_op = BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals);
+                    let condition =
+                        SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                     self.brillig_context.binary_instruction(
-                        left.address,
+                        left,
                         right,
                         condition,
                         brillig_binary_op,
                     );
 
                     self.brillig_context.constrain_instruction(condition, assert_message.clone());
-                    self.brillig_context.deallocate_register(condition);
-                    self.brillig_context.deallocate_register(left.address);
-                    self.brillig_context.deallocate_register(right);
+                    self.brillig_context.deallocate_single_addr(condition);
+                    self.brillig_context.deallocate_single_addr(left);
+                    self.brillig_context.deallocate_single_addr(right);
                 }
             }
             Instruction::IncrementRc { value } => {
@@ -751,16 +749,18 @@ impl<'block> BrilligBlock<'block> {
             BrilligVariable::BrilligArray(BrilligArray { size, .. }) => {
                 (self.brillig_context.make_usize_constant(size.into()), true)
             }
-            BrilligVariable::BrilligVector(BrilligVector { size, .. }) => (size, false),
+            BrilligVariable::BrilligVector(BrilligVector { size, .. }) => {
+                (SingleAddrVariable::new_usize(size), false)
+            }
             _ => unreachable!("ICE: validate array index on non-array"),
         };
 
-        let condition = self.brillig_context.allocate_register();
+        let condition = SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
 
         self.brillig_context.memory_op(
             index_register.address,
-            size_as_register,
-            condition,
+            size_as_register.address,
+            condition.address,
             BinaryIntOp::LessThan,
         );
 
@@ -768,28 +768,28 @@ impl<'block> BrilligBlock<'block> {
             .constrain_instruction(condition, Some("Array index out of bounds".to_owned()));
 
         if should_deallocate_size {
-            self.brillig_context.deallocate_register(size_as_register);
+            self.brillig_context.deallocate_single_addr(size_as_register);
         }
-        self.brillig_context.deallocate_register(condition);
+        self.brillig_context.deallocate_single_addr(condition);
     }
 
     pub(crate) fn retrieve_variable_from_array(
         &mut self,
         array_pointer: MemoryAddress,
-        index_register: MemoryAddress,
+        index_var: SingleAddrVariable,
         destination_variable: BrilligVariable,
     ) {
         match destination_variable {
             BrilligVariable::SingleAddr(destination_register) => {
                 self.brillig_context.array_get(
                     array_pointer,
-                    index_register,
+                    index_var,
                     destination_register.address,
                 );
             }
             BrilligVariable::BrilligArray(..) | BrilligVariable::BrilligVector(..) => {
                 let reference = self.brillig_context.allocate_register();
-                self.brillig_context.array_get(array_pointer, index_register, reference);
+                self.brillig_context.array_get(array_pointer, index_var, reference);
                 self.brillig_context.load_variable_instruction(destination_variable, reference);
                 self.brillig_context.deallocate_register(reference);
             }
@@ -831,15 +831,9 @@ impl<'block> BrilligBlock<'block> {
             _ => unreachable!("ICE: array set on non-array"),
         };
 
-        let one = self.brillig_context.make_usize_constant(1_usize.into());
         let condition = self.brillig_context.allocate_register();
 
-        self.brillig_context.binary_instruction(
-            reference_count,
-            one,
-            condition,
-            BrilligBinaryOp::Field { op: BinaryFieldOp::Equals },
-        );
+        self.brillig_context.usize_op(reference_count, condition, BinaryIntOp::Equals, 1_usize);
 
         self.brillig_context.branch_instruction(condition, |ctx, cond| {
             if cond {
@@ -852,7 +846,10 @@ impl<'block> BrilligBlock<'block> {
                 ctx.copy_array_instruction(
                     source_pointer,
                     destination_pointer,
-                    source_size_as_register,
+                    SingleAddrVariable::new(
+                        source_size_as_register,
+                        BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+                    ),
                 );
             }
         });
@@ -873,17 +870,20 @@ impl<'block> BrilligBlock<'block> {
         }
 
         // Then set the value in the newly created array
-        self.store_variable_in_array(destination_pointer, index_register, value_variable);
+        self.store_variable_in_array(
+            destination_pointer,
+            SingleAddrVariable::new_usize(index_register),
+            value_variable,
+        );
 
         self.brillig_context.deallocate_register(source_size_as_register);
-        self.brillig_context.deallocate_register(one);
         self.brillig_context.deallocate_register(condition);
     }
 
     pub(crate) fn store_variable_in_array_with_ctx(
         ctx: &mut BrilligContext,
         destination_pointer: MemoryAddress,
-        index_register: MemoryAddress,
+        index_register: SingleAddrVariable,
         value_variable: BrilligVariable,
     ) {
         match value_variable {
@@ -910,13 +910,13 @@ impl<'block> BrilligBlock<'block> {
     pub(crate) fn store_variable_in_array(
         &mut self,
         destination_pointer: MemoryAddress,
-        index_register: MemoryAddress,
+        index_variable: SingleAddrVariable,
         value_variable: BrilligVariable,
     ) {
         Self::store_variable_in_array_with_ctx(
             self.brillig_context,
             destination_pointer,
-            index_register,
+            index_variable,
             value_variable,
         );
     }
@@ -1082,9 +1082,9 @@ impl<'block> BrilligBlock<'block> {
                 let converted_index = self.brillig_context.make_usize_constant(element_size.into());
 
                 self.brillig_context.memory_op(
-                    converted_index,
+                    converted_index.address,
                     user_index.address,
-                    converted_index,
+                    converted_index.address,
                     BinaryIntOp::Mul,
                 );
 
@@ -1095,7 +1095,7 @@ impl<'block> BrilligBlock<'block> {
                 self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Add);
 
                 self.slice_insert_operation(target_vector, source_vector, converted_index, &items);
-                self.brillig_context.deallocate_register(converted_index);
+                self.brillig_context.deallocate_single_addr(converted_index);
             }
             Value::Intrinsic(Intrinsic::SliceRemove) => {
                 let target_len = match self.variables.define_variable(
@@ -1124,9 +1124,9 @@ impl<'block> BrilligBlock<'block> {
 
                 let converted_index = self.brillig_context.make_usize_constant(element_size.into());
                 self.brillig_context.memory_op(
-                    converted_index,
+                    converted_index.address,
                     user_index.address,
-                    converted_index,
+                    converted_index.address,
                     BinaryIntOp::Mul,
                 );
 
@@ -1148,7 +1148,7 @@ impl<'block> BrilligBlock<'block> {
                     &removed_items,
                 );
 
-                self.brillig_context.deallocate_register(converted_index);
+                self.brillig_context.deallocate_single_addr(converted_index);
             }
             _ => unreachable!("ICE: Slice operation not supported"),
         }
@@ -1201,12 +1201,7 @@ impl<'block> BrilligBlock<'block> {
         let (brillig_binary_op, is_signed) =
             convert_ssa_binary_op_to_brillig_binary_op(binary.operator, &binary_type);
 
-        self.brillig_context.binary_instruction(
-            left.address,
-            right.address,
-            result_variable.address,
-            brillig_binary_op,
-        );
+        self.brillig_context.binary_instruction(left, right, result_variable, brillig_binary_op);
 
         self.add_overflow_check(brillig_binary_op, left, right, result_variable, is_signed);
     }
@@ -1219,77 +1214,83 @@ impl<'block> BrilligBlock<'block> {
         result: SingleAddrVariable,
         is_signed: bool,
     ) {
-        let (op, bit_size) = if let BrilligBinaryOp::Integer { op, bit_size } = binary_operation {
-            (op, bit_size)
+        let (op, bit_size) = if let BrilligBinaryOp::Integer(op) = binary_operation {
+            // Bit size is checked at compile time to be equal for left and right
+            (op, left.bit_size)
         } else {
             return;
         };
 
         match (op, is_signed) {
             (BinaryIntOp::Add, false) => {
-                let condition = self.brillig_context.allocate_register();
+                let condition =
+                    SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that lhs <= result
                 self.brillig_context.binary_instruction(
-                    left.address,
-                    result.address,
+                    left,
+                    result,
                     condition,
-                    BrilligBinaryOp::Integer { op: BinaryIntOp::LessThanEquals, bit_size },
+                    BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals),
                 );
                 self.brillig_context.constrain_instruction(
                     condition,
                     Some("attempt to add with overflow".to_string()),
                 );
-                self.brillig_context.deallocate_register(condition);
+                self.brillig_context.deallocate_single_addr(condition);
             }
             (BinaryIntOp::Sub, false) => {
-                let condition = self.brillig_context.allocate_register();
+                let condition =
+                    SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that rhs <= lhs
                 self.brillig_context.binary_instruction(
-                    right.address,
-                    left.address,
+                    right,
+                    left,
                     condition,
-                    BrilligBinaryOp::Integer { op: BinaryIntOp::LessThanEquals, bit_size },
+                    BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals),
                 );
                 self.brillig_context.constrain_instruction(
                     condition,
                     Some("attempt to subtract with overflow".to_string()),
                 );
-                self.brillig_context.deallocate_register(condition);
+                self.brillig_context.deallocate_single_addr(condition);
             }
             (BinaryIntOp::Mul, false) => {
                 // Multiplication overflow is only possible for bit sizes > 1
                 if bit_size > 1 {
-                    let is_right_zero = self.brillig_context.allocate_register();
+                    let is_right_zero =
+                        SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                     let zero = self.brillig_context.make_constant(0_usize.into(), bit_size);
                     self.brillig_context.binary_instruction(
                         zero,
-                        right.address,
+                        right,
                         is_right_zero,
-                        BrilligBinaryOp::Integer { op: BinaryIntOp::Equals, bit_size },
+                        BrilligBinaryOp::Integer(BinaryIntOp::Equals),
                     );
-                    self.brillig_context.if_not_instruction(is_right_zero, |ctx| {
-                        let condition = ctx.allocate_register();
+                    self.brillig_context.if_not_instruction(is_right_zero.address, |ctx| {
+                        let condition = SingleAddrVariable::new(ctx.allocate_register(), 1);
+                        let division = SingleAddrVariable::new(ctx.allocate_register(), bit_size);
                         // Check that result / rhs == lhs
                         ctx.binary_instruction(
-                            result.address,
-                            right.address,
-                            condition,
-                            BrilligBinaryOp::Integer { op: BinaryIntOp::UnsignedDiv, bit_size },
+                            result,
+                            right,
+                            division,
+                            BrilligBinaryOp::Integer(BinaryIntOp::UnsignedDiv),
                         );
                         ctx.binary_instruction(
+                            division,
+                            left,
                             condition,
-                            left.address,
-                            condition,
-                            BrilligBinaryOp::Integer { op: BinaryIntOp::Equals, bit_size },
+                            BrilligBinaryOp::Integer(BinaryIntOp::Equals),
                         );
                         ctx.constrain_instruction(
                             condition,
                             Some("attempt to multiply with overflow".to_string()),
                         );
-                        ctx.deallocate_register(condition);
+                        ctx.deallocate_single_addr(condition);
+                        ctx.deallocate_single_addr(division);
                     });
-                    self.brillig_context.deallocate_register(is_right_zero);
-                    self.brillig_context.deallocate_register(zero);
+                    self.brillig_context.deallocate_single_addr(is_right_zero);
+                    self.brillig_context.deallocate_single_addr(zero);
                 }
             }
             _ => {}
@@ -1307,7 +1308,7 @@ impl<'block> BrilligBlock<'block> {
                 // converted to registers so we fetch from the cache.
                 self.variables.get_allocation(self.function_context, value_id, dfg)
             }
-            Value::NumericConstant { constant, typ } => {
+            Value::NumericConstant { constant, .. } => {
                 // Constants might have been converted previously or not, so we get or create and
                 // (re)initialize the value inside.
                 if let Some(variable) = self.variables.get_constant(value_id, dfg) {
@@ -1315,13 +1316,9 @@ impl<'block> BrilligBlock<'block> {
                 } else {
                     let new_variable =
                         self.variables.allocate_constant(self.brillig_context, value_id, dfg);
-                    let register_index = new_variable.extract_single_addr();
 
-                    self.brillig_context.const_instruction(
-                        register_index.address,
-                        (*constant).into(),
-                        get_bit_size_from_ssa_type(typ),
-                    );
+                    self.brillig_context
+                        .const_instruction(new_variable.extract_single_addr(), (*constant).into());
                     new_variable
                 }
             }
@@ -1366,13 +1363,13 @@ impl<'block> BrilligBlock<'block> {
                         self.store_variable_in_array(pointer, iterator_register, element_variable);
                         // Increment the iterator
                         self.brillig_context.usize_op_in_place(
-                            iterator_register,
+                            iterator_register.address,
                             BinaryIntOp::Add,
                             1,
                         );
                     }
 
-                    self.brillig_context.deallocate_register(iterator_register);
+                    self.brillig_context.deallocate_single_addr(iterator_register);
 
                     new_variable
                 }
@@ -1384,12 +1381,10 @@ impl<'block> BrilligBlock<'block> {
                 // value.
                 let new_variable =
                     self.variables.allocate_constant(self.brillig_context, value_id, dfg);
-                let register_index = new_variable.extract_single_addr();
 
                 self.brillig_context.const_instruction(
-                    register_index.address,
+                    new_variable.extract_single_addr(),
                     value_id.to_usize().into(),
-                    32,
                 );
                 new_variable
             }
@@ -1538,18 +1533,18 @@ pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
 
     fn binary_op_to_field_op(op: BinaryOp) -> BrilligBinaryOp {
         match op {
-            BinaryOp::Add => BrilligBinaryOp::Field { op: BinaryFieldOp::Add },
-            BinaryOp::Sub => BrilligBinaryOp::Field { op: BinaryFieldOp::Sub },
-            BinaryOp::Mul => BrilligBinaryOp::Field { op: BinaryFieldOp::Mul },
-            BinaryOp::Div => BrilligBinaryOp::Field { op: BinaryFieldOp::Div },
-            BinaryOp::Eq => BrilligBinaryOp::Field { op: BinaryFieldOp::Equals },
+            BinaryOp::Add => BrilligBinaryOp::Field(BinaryFieldOp::Add),
+            BinaryOp::Sub => BrilligBinaryOp::Field(BinaryFieldOp::Sub),
+            BinaryOp::Mul => BrilligBinaryOp::Field(BinaryFieldOp::Mul),
+            BinaryOp::Div => BrilligBinaryOp::Field(BinaryFieldOp::Div),
+            BinaryOp::Eq => BrilligBinaryOp::Field(BinaryFieldOp::Equals),
             _ => unreachable!(
                 "Field type cannot be used with {op}. This should have been caught by the frontend"
             ),
         }
     }
 
-    fn binary_op_to_int_op(op: BinaryOp, bit_size: u32, is_signed: bool) -> BrilligBinaryOp {
+    fn binary_op_to_int_op(op: BinaryOp, is_signed: bool) -> BrilligBinaryOp {
         let operation = match op {
             BinaryOp::Add => BinaryIntOp::Add,
             BinaryOp::Sub => BinaryIntOp::Sub,
@@ -1561,9 +1556,7 @@ pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
                     BinaryIntOp::UnsignedDiv
                 }
             }
-            BinaryOp::Mod => {
-                return BrilligBinaryOp::Modulo { is_signed_integer: is_signed, bit_size }
-            }
+            BinaryOp::Mod => return BrilligBinaryOp::Modulo { is_signed_integer: is_signed },
             BinaryOp::Eq => BinaryIntOp::Equals,
             BinaryOp::Lt => BinaryIntOp::LessThan,
             BinaryOp::And => BinaryIntOp::And,
@@ -1573,14 +1566,12 @@ pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
             BinaryOp::Shr => BinaryIntOp::Shr,
         };
 
-        BrilligBinaryOp::Integer { op: operation, bit_size }
+        BrilligBinaryOp::Integer(operation)
     }
 
     // If bit size is available then it is a binary integer operation
     match bit_size_signedness {
-        Some((bit_size, is_signed)) => {
-            (binary_op_to_int_op(ssa_op, *bit_size, is_signed), is_signed)
-        }
+        Some((_, is_signed)) => (binary_op_to_int_op(ssa_op, is_signed), is_signed),
         None => (binary_op_to_field_op(ssa_op), false),
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
index f463bd4de4d..dc9900daee3 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
@@ -3,7 +3,7 @@ use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use crate::{
     brillig::brillig_ir::{
         brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
-        BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+        BrilligContext,
     },
     ssa::ir::{
         basic_block::BasicBlockId,
@@ -13,7 +13,7 @@ use crate::{
     },
 };
 
-use super::brillig_fn::FunctionContext;
+use super::brillig_fn::{get_bit_size_from_ssa_type, FunctionContext};
 
 #[derive(Debug, Default)]
 pub(crate) struct BlockVariables {
@@ -189,21 +189,10 @@ pub(crate) fn allocate_value(
     let typ = dfg.type_of_value(value_id);
 
     match typ {
-        Type::Numeric(numeric_type) => BrilligVariable::SingleAddr(SingleAddrVariable {
-            address: brillig_context.allocate_register(),
-            bit_size: numeric_type.bit_size(),
-        }),
-        Type::Reference(_) => BrilligVariable::SingleAddr(SingleAddrVariable {
-            address: brillig_context.allocate_register(),
-            bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-        }),
-        Type::Function => {
-            // NB. function references are converted to a constant when
-            // translating from SSA to Brillig (to allow for debugger
-            // instrumentation to work properly)
+        Type::Numeric(_) | Type::Reference(_) | Type::Function => {
             BrilligVariable::SingleAddr(SingleAddrVariable {
                 address: brillig_context.allocate_register(),
-                bit_size: 32,
+                bit_size: get_bit_size_from_ssa_type(&typ),
             })
         }
         Type::Array(item_typ, elem_count) => {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index b5da8296ba5..42765d10ce2 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -1,4 +1,3 @@
-use acvm::FieldElement;
 use iter_extended::vecmap;
 
 use crate::{
@@ -11,7 +10,7 @@ use crate::{
         basic_block::BasicBlockId,
         function::{Function, FunctionId},
         post_order::PostOrder,
-        types::{NumericType, Type},
+        types::Type,
         value::ValueId,
     },
 };
@@ -116,11 +115,12 @@ impl FunctionContext {
 
 pub(crate) fn get_bit_size_from_ssa_type(typ: &Type) -> u32 {
     match typ {
-        Type::Numeric(num_type) => match num_type {
-            NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size } => *bit_size,
-            NumericType::NativeField => FieldElement::max_num_bits(),
-        },
+        Type::Numeric(num_type) => num_type.bit_size(),
         Type::Reference(_) => BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-        _ => unreachable!("ICE bitwise not on a non numeric type"),
+        // NB. function references are converted to a constant when
+        // translating from SSA to Brillig (to allow for debugger
+        // instrumentation to work properly)
+        Type::Function => 32,
+        _ => unreachable!("ICE bit size not on a non numeric type"),
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 3fc0e981165..969f95cff20 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -1,6 +1,8 @@
-use acvm::brillig_vm::brillig::{BinaryIntOp, MemoryAddress};
+use acvm::brillig_vm::brillig::BinaryIntOp;
 
-use crate::brillig::brillig_ir::brillig_variable::{BrilligVariable, BrilligVector};
+use crate::brillig::brillig_ir::brillig_variable::{
+    BrilligVariable, BrilligVector, SingleAddrVariable,
+};
 
 use super::brillig_block::BrilligBlock;
 
@@ -26,19 +28,19 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.copy_array_instruction(
             source_vector.pointer,
             target_vector.pointer,
-            source_vector.size,
+            SingleAddrVariable::new_usize(source_vector.size),
         );
 
         for (index, variable) in variables_to_insert.iter().enumerate() {
             let target_index = self.brillig_context.make_usize_constant(index.into());
             self.brillig_context.memory_op(
-                target_index,
+                target_index.address,
                 source_vector.size,
-                target_index,
+                target_index.address,
                 BinaryIntOp::Add,
             );
             self.store_variable_in_array(target_vector.pointer, target_index, *variable);
-            self.brillig_context.deallocate_register(target_index);
+            self.brillig_context.deallocate_single_addr(target_index);
         }
     }
 
@@ -72,14 +74,14 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.copy_array_instruction(
             source_vector.pointer,
             destination_copy_pointer,
-            source_vector.size,
+            SingleAddrVariable::new_usize(source_vector.size),
         );
 
         // Then we write the items to insert at the start
         for (index, variable) in variables_to_insert.iter().enumerate() {
             let target_index = self.brillig_context.make_usize_constant(index.into());
             self.store_variable_in_array(target_vector.pointer, target_index, *variable);
-            self.brillig_context.deallocate_register(target_index);
+            self.brillig_context.deallocate_single_addr(target_index);
         }
 
         self.brillig_context.deallocate_register(destination_copy_pointer);
@@ -115,13 +117,13 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.copy_array_instruction(
             source_copy_pointer,
             target_vector.pointer,
-            target_vector.size,
+            SingleAddrVariable::new_usize(target_vector.size),
         );
 
         for (index, variable) in removed_items.iter().enumerate() {
             let target_index = self.brillig_context.make_usize_constant(index.into());
             self.retrieve_variable_from_array(source_vector.pointer, target_index, *variable);
-            self.brillig_context.deallocate_register(target_index);
+            self.brillig_context.deallocate_single_addr(target_index);
         }
 
         self.brillig_context.deallocate_register(source_copy_pointer);
@@ -148,19 +150,19 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.copy_array_instruction(
             source_vector.pointer,
             target_vector.pointer,
-            target_vector.size,
+            SingleAddrVariable::new_usize(target_vector.size),
         );
 
         for (index, variable) in removed_items.iter().enumerate() {
             let target_index = self.brillig_context.make_usize_constant(index.into());
             self.brillig_context.memory_op(
-                target_index,
+                target_index.address,
                 target_vector.size,
-                target_index,
+                target_index.address,
                 BinaryIntOp::Add,
             );
             self.retrieve_variable_from_array(source_vector.pointer, target_index, *variable);
-            self.brillig_context.deallocate_register(target_index);
+            self.brillig_context.deallocate_single_addr(target_index);
         }
     }
 
@@ -168,7 +170,7 @@ impl<'block> BrilligBlock<'block> {
         &mut self,
         target_vector: BrilligVector,
         source_vector: BrilligVector,
-        index: MemoryAddress,
+        index: SingleAddrVariable,
         items: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector incrementing the size by items.len()
@@ -193,7 +195,7 @@ impl<'block> BrilligBlock<'block> {
         let source_pointer_at_index = self.brillig_context.allocate_register();
         self.brillig_context.memory_op(
             source_vector.pointer,
-            index,
+            index.address,
             source_pointer_at_index,
             BinaryIntOp::Add,
         );
@@ -202,7 +204,7 @@ impl<'block> BrilligBlock<'block> {
         let target_pointer_after_index = self.brillig_context.allocate_register();
         self.brillig_context.memory_op(
             target_vector.pointer,
-            index,
+            index.address,
             target_pointer_after_index,
             BinaryIntOp::Add,
         );
@@ -214,21 +216,31 @@ impl<'block> BrilligBlock<'block> {
 
         // Compute the number of elements to the right of the index
         let item_count = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(source_vector.size, index, item_count, BinaryIntOp::Sub);
+        self.brillig_context.memory_op(
+            source_vector.size,
+            index.address,
+            item_count,
+            BinaryIntOp::Sub,
+        );
 
         // Copy the elements to the right of the index
         self.brillig_context.copy_array_instruction(
             source_pointer_at_index,
             target_pointer_after_index,
-            item_count,
+            SingleAddrVariable::new_usize(item_count),
         );
 
         // Write the items to insert starting at the index
         for (subitem_index, variable) in items.iter().enumerate() {
             let target_index = self.brillig_context.make_usize_constant(subitem_index.into());
-            self.brillig_context.memory_op(target_index, index, target_index, BinaryIntOp::Add);
+            self.brillig_context.memory_op(
+                target_index.address,
+                index.address,
+                target_index.address,
+                BinaryIntOp::Add,
+            );
             self.store_variable_in_array(target_vector.pointer, target_index, *variable);
-            self.brillig_context.deallocate_register(target_index);
+            self.brillig_context.deallocate_single_addr(target_index);
         }
 
         self.brillig_context.deallocate_register(source_pointer_at_index);
@@ -240,7 +252,7 @@ impl<'block> BrilligBlock<'block> {
         &mut self,
         target_vector: BrilligVector,
         source_vector: BrilligVector,
-        index: MemoryAddress,
+        index: SingleAddrVariable,
         removed_items: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector decrementing the size by removed_items.len()
@@ -265,7 +277,7 @@ impl<'block> BrilligBlock<'block> {
         let source_pointer_after_index = self.brillig_context.allocate_register();
         self.brillig_context.memory_op(
             source_vector.pointer,
-            index,
+            index.address,
             source_pointer_after_index,
             BinaryIntOp::Add,
         );
@@ -279,29 +291,39 @@ impl<'block> BrilligBlock<'block> {
         let target_pointer_at_index = self.brillig_context.allocate_register();
         self.brillig_context.memory_op(
             target_vector.pointer,
-            index,
+            index.address,
             target_pointer_at_index,
             BinaryIntOp::Add,
         );
 
         // Compute the number of elements to the right of the index
         let item_count = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(source_vector.size, index, item_count, BinaryIntOp::Sub);
+        self.brillig_context.memory_op(
+            source_vector.size,
+            index.address,
+            item_count,
+            BinaryIntOp::Sub,
+        );
         self.brillig_context.usize_op_in_place(item_count, BinaryIntOp::Sub, removed_items.len());
 
         // Copy the elements to the right of the index
         self.brillig_context.copy_array_instruction(
             source_pointer_after_index,
             target_pointer_at_index,
-            item_count,
+            SingleAddrVariable::new_usize(item_count),
         );
 
         // Get the removed items
         for (subitem_index, variable) in removed_items.iter().enumerate() {
             let target_index = self.brillig_context.make_usize_constant(subitem_index.into());
-            self.brillig_context.memory_op(target_index, index, target_index, BinaryIntOp::Add);
+            self.brillig_context.memory_op(
+                target_index.address,
+                index.address,
+                target_index.address,
+                BinaryIntOp::Add,
+            );
             self.retrieve_variable_from_array(source_vector.pointer, target_index, *variable);
-            self.brillig_context.deallocate_register(target_index);
+            self.brillig_context.deallocate_single_addr(target_index);
         }
 
         self.brillig_context.deallocate_register(source_pointer_after_index);
@@ -592,7 +614,10 @@ mod tests {
                 address: context.allocate_register(),
                 bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
             };
-            let index_to_insert = context.allocate_register();
+            let index_to_insert = SingleAddrVariable::new(
+                context.allocate_register(),
+                BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            );
 
             // Cast the source array to a vector
             let source_vector = context.array_to_vector(&array_variable);
@@ -710,7 +735,10 @@ mod tests {
                 size: array.len(),
                 rc: context.allocate_register(),
             };
-            let index_to_insert = context.allocate_register();
+            let index_to_insert = SingleAddrVariable::new(
+                context.allocate_register(),
+                BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            );
 
             // Cast the source array to a vector
             let source_vector = context.array_to_vector(&array_variable);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index f1a8f24ed03..1e53713dfe0 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -32,7 +32,7 @@ use num_bigint::BigUint;
 /// The Brillig VM does not apply a limit to the memory address space,
 /// As a convention, we take use 64 bits. This means that we assume that
 /// memory has 2^64 memory slots.
-pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 32;
+pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
 
 // Registers reserved in runtime for special purposes.
 pub(crate) enum ReservedRegisters {
@@ -123,8 +123,8 @@ impl BrilligContext {
     ) {
         // debug_show handled by allocate_array_instruction
         let size_register = self.make_usize_constant(size.into());
-        self.allocate_array_instruction(pointer_register, size_register);
-        self.deallocate_register(size_register);
+        self.allocate_array_instruction(pointer_register, size_register.address);
+        self.deallocate_single_addr(size_register);
     }
 
     /// Allocates an array of size contained in size_register and stores the
@@ -172,11 +172,11 @@ impl BrilligContext {
         });
         self.memory_op(
             ReservedRegisters::stack_pointer(),
-            size_register,
+            size_register.address,
             ReservedRegisters::stack_pointer(),
             BinaryIntOp::Add,
         );
-        self.deallocate_register(size_register);
+        self.deallocate_single_addr(size_register);
     }
 
     pub(crate) fn allocate_single_addr_reference_instruction(
@@ -207,18 +207,14 @@ impl BrilligContext {
     pub(crate) fn array_get(
         &mut self,
         array_ptr: MemoryAddress,
-        index: MemoryAddress,
+        index: SingleAddrVariable,
         result: MemoryAddress,
     ) {
-        self.debug_show.array_get(array_ptr, index, result);
+        assert!(index.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        self.debug_show.array_get(array_ptr, index.address, result);
         // Computes array_ptr + index, ie array[index]
         let index_of_element_in_memory = self.allocate_register();
-        self.binary_instruction(
-            array_ptr,
-            index,
-            index_of_element_in_memory,
-            BrilligBinaryOp::Field { op: BinaryFieldOp::Add },
-        );
+        self.memory_op(array_ptr, index.address, index_of_element_in_memory, BinaryIntOp::Add);
 
         self.load_instruction(result, index_of_element_in_memory);
         // Free up temporary register
@@ -229,18 +225,14 @@ impl BrilligContext {
     pub(crate) fn array_set(
         &mut self,
         array_ptr: MemoryAddress,
-        index: MemoryAddress,
+        index: SingleAddrVariable,
         value: MemoryAddress,
     ) {
-        self.debug_show.array_set(array_ptr, index, value);
+        assert!(index.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        self.debug_show.array_set(array_ptr, index.address, value);
         // Computes array_ptr + index, ie array[index]
         let index_of_element_in_memory = self.allocate_register();
-        self.binary_instruction(
-            array_ptr,
-            index,
-            index_of_element_in_memory,
-            BrilligBinaryOp::Field { op: BinaryFieldOp::Add },
-        );
+        self.memory_op(array_ptr, index.address, index_of_element_in_memory, BinaryIntOp::Add);
 
         self.store_instruction(index_of_element_in_memory, value);
         // Free up temporary register
@@ -253,17 +245,18 @@ impl BrilligContext {
         &mut self,
         source_pointer: MemoryAddress,
         destination_pointer: MemoryAddress,
-        num_elements_register: MemoryAddress,
+        num_elements_variable: SingleAddrVariable,
     ) {
+        assert!(num_elements_variable.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
         self.debug_show.copy_array_instruction(
             source_pointer,
             destination_pointer,
-            num_elements_register,
+            num_elements_variable.address,
         );
 
         let value_register = self.allocate_register();
 
-        self.loop_instruction(num_elements_register, |ctx, iterator| {
+        self.loop_instruction(num_elements_variable.address, |ctx, iterator| {
             ctx.array_get(source_pointer, iterator, value_register);
             ctx.array_set(destination_pointer, iterator, value_register);
         });
@@ -275,7 +268,7 @@ impl BrilligContext {
     /// The body of the loop should be issued by the caller in the on_iteration closure.
     pub(crate) fn loop_instruction<F>(&mut self, iteration_count: MemoryAddress, on_iteration: F)
     where
-        F: FnOnce(&mut BrilligContext, MemoryAddress),
+        F: FnOnce(&mut BrilligContext, SingleAddrVariable),
     {
         let iterator_register = self.make_usize_constant(0_u128.into());
 
@@ -289,7 +282,7 @@ impl BrilligContext {
             SingleAddrVariable { address: self.allocate_register(), bit_size: 1 };
 
         self.memory_op(
-            iterator_register,
+            iterator_register.address,
             iteration_count,
             iterator_less_than_iterations.address,
             BinaryIntOp::LessThan,
@@ -305,7 +298,7 @@ impl BrilligContext {
         on_iteration(self, iterator_register);
 
         // Increment the iterator register
-        self.usize_op_in_place(iterator_register, BinaryIntOp::Add, 1);
+        self.usize_op_in_place(iterator_register.address, BinaryIntOp::Add, 1);
 
         self.jump_instruction(loop_label);
 
@@ -313,8 +306,8 @@ impl BrilligContext {
         self.enter_section(exit_loop_section);
 
         // Deallocate our temporary registers
-        self.deallocate_register(iterator_less_than_iterations.address);
-        self.deallocate_register(iterator_register);
+        self.deallocate_single_addr(iterator_less_than_iterations);
+        self.deallocate_single_addr(iterator_register);
     }
 
     /// This instruction will issue an if-then branch that will check if the condition is true
@@ -430,11 +423,14 @@ impl BrilligContext {
     }
 
     /// Push a register to the deallocation list, ready for reuse.
-    /// TODO(AD): currently, register deallocation is only done with immediate values.
-    /// TODO(AD): See https://github.com/noir-lang/noir/issues/1720
     pub(crate) fn deallocate_register(&mut self, register_index: MemoryAddress) {
         self.registers.deallocate_register(register_index);
     }
+
+    /// Deallocates the address where the single address variable is stored
+    pub(crate) fn deallocate_single_addr(&mut self, var: SingleAddrVariable) {
+        self.deallocate_register(var.address);
+    }
 }
 
 impl BrilligContext {
@@ -442,12 +438,16 @@ impl BrilligContext {
     /// is false.
     pub(crate) fn constrain_instruction(
         &mut self,
-        condition: MemoryAddress,
+        condition: SingleAddrVariable,
         assert_message: Option<String>,
     ) {
-        self.debug_show.constrain_instruction(condition);
+        assert!(condition.bit_size == 1);
+        self.debug_show.constrain_instruction(condition.address);
         let (next_section, next_label) = self.reserve_next_section_label();
-        self.add_unresolved_jump(BrilligOpcode::JumpIf { condition, location: 0 }, next_label);
+        self.add_unresolved_jump(
+            BrilligOpcode::JumpIf { condition: condition.address, location: 0 },
+            next_label,
+        );
         self.push_opcode(BrilligOpcode::Trap);
         if let Some(assert_message) = assert_message {
             self.obj.add_assert_message_to_last_opcode(assert_message);
@@ -526,47 +526,81 @@ impl BrilligContext {
         });
     }
 
+    fn binary_result_bit_size(operation: BrilligBinaryOp, arguments_bit_size: u32) -> u32 {
+        match operation {
+            BrilligBinaryOp::Field(BinaryFieldOp::Equals)
+            | BrilligBinaryOp::Integer(BinaryIntOp::Equals)
+            | BrilligBinaryOp::Integer(BinaryIntOp::LessThan)
+            | BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals) => 1,
+            _ => arguments_bit_size,
+        }
+    }
+
     /// Processes a binary instruction according `operation`.
     ///
     /// This method will compute lhs <operation> rhs
     /// and store the result in the `result` register.
     pub(crate) fn binary_instruction(
         &mut self,
-        lhs: MemoryAddress,
-        rhs: MemoryAddress,
-        result: MemoryAddress,
+        lhs: SingleAddrVariable,
+        rhs: SingleAddrVariable,
+        result: SingleAddrVariable,
         operation: BrilligBinaryOp,
     ) {
-        self.debug_show.binary_instruction(lhs, rhs, result, operation);
+        assert!(
+            lhs.bit_size == rhs.bit_size,
+            "Not equal bit size for lhs and rhs: lhs {}, rhs {}",
+            lhs.bit_size,
+            rhs.bit_size
+        );
+        let expected_result_bit_size =
+            BrilligContext::binary_result_bit_size(operation, lhs.bit_size);
+        assert!(
+            result.bit_size == expected_result_bit_size,
+            "Expected result bit size to be {}, got {} for operation {:?}",
+            expected_result_bit_size,
+            result.bit_size,
+            operation
+        );
+        self.debug_show.binary_instruction(lhs.address, rhs.address, result.address, operation);
         match operation {
-            BrilligBinaryOp::Field { op } => {
-                let opcode = BrilligOpcode::BinaryFieldOp { op, destination: result, lhs, rhs };
+            BrilligBinaryOp::Field(op) => {
+                let opcode = BrilligOpcode::BinaryFieldOp {
+                    op,
+                    destination: result.address,
+                    lhs: lhs.address,
+                    rhs: rhs.address,
+                };
                 self.push_opcode(opcode);
             }
-            BrilligBinaryOp::Integer { op, bit_size } => {
-                let opcode =
-                    BrilligOpcode::BinaryIntOp { op, destination: result, bit_size, lhs, rhs };
+            BrilligBinaryOp::Integer(op) => {
+                let opcode = BrilligOpcode::BinaryIntOp {
+                    op,
+                    destination: result.address,
+                    bit_size: lhs.bit_size,
+                    lhs: lhs.address,
+                    rhs: rhs.address,
+                };
                 self.push_opcode(opcode);
             }
-            BrilligBinaryOp::Modulo { is_signed_integer, bit_size } => {
-                self.modulo_instruction(result, lhs, rhs, bit_size, is_signed_integer);
+            BrilligBinaryOp::Modulo { is_signed_integer } => {
+                self.modulo_instruction(result, lhs, rhs, is_signed_integer);
             }
         }
     }
 
     /// Stores the value of `constant` in the `result` register
-    pub(crate) fn const_instruction(
-        &mut self,
-        result: MemoryAddress,
-        constant: Value,
-        bit_size: u32,
-    ) {
-        self.debug_show.const_instruction(result, constant);
-        self.push_opcode(BrilligOpcode::Const { destination: result, value: constant, bit_size });
+    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: Value) {
+        self.debug_show.const_instruction(result.address, constant);
+        self.push_opcode(BrilligOpcode::Const {
+            destination: result.address,
+            value: constant,
+            bit_size: result.bit_size,
+        });
     }
 
     pub(crate) fn usize_const(&mut self, result: MemoryAddress, constant: Value) {
-        self.const_instruction(result, constant, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        self.const_instruction(SingleAddrVariable::new_usize(result), constant);
     }
 
     /// Processes a not instruction.
@@ -583,15 +617,16 @@ impl BrilligContext {
         let u_max = FieldElement::from(2_i128).pow(&FieldElement::from(input.bit_size as i128))
             - FieldElement::one();
         let max = self.make_constant(Value::from(u_max), input.bit_size);
+
         let opcode = BrilligOpcode::BinaryIntOp {
             destination: result.address,
             op: BinaryIntOp::Sub,
             bit_size: input.bit_size,
-            lhs: max,
+            lhs: max.address,
             rhs: input.address,
         };
         self.push_opcode(opcode);
-        self.deallocate_register(max);
+        self.deallocate_single_addr(max);
     }
 
     /// Processes a foreign call instruction.
@@ -750,13 +785,13 @@ impl BrilligContext {
         );
 
         self.binary_instruction(
-            value_to_truncate.address,
+            value_to_truncate,
             mask_constant,
-            destination_of_truncated_value.address,
-            BrilligBinaryOp::Integer { op: BinaryIntOp::And, bit_size: value_to_truncate.bit_size },
+            destination_of_truncated_value,
+            BrilligBinaryOp::Integer(BinaryIntOp::And),
         );
 
-        self.deallocate_register(mask_constant);
+        self.deallocate_single_addr(mask_constant);
     }
 
     /// Emits a stop instruction
@@ -766,17 +801,17 @@ impl BrilligContext {
     }
 
     /// Returns a register which holds the value of a constant
-    pub(crate) fn make_constant(&mut self, constant: Value, bit_size: u32) -> MemoryAddress {
-        let register = self.allocate_register();
-        self.const_instruction(register, constant, bit_size);
-        register
+    pub(crate) fn make_constant(&mut self, constant: Value, bit_size: u32) -> SingleAddrVariable {
+        let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
+        self.const_instruction(var, constant);
+        var
     }
 
     /// Returns a register which holds the value of an usize constant
-    pub(crate) fn make_usize_constant(&mut self, constant: Value) -> MemoryAddress {
+    pub(crate) fn make_usize_constant(&mut self, constant: Value) -> SingleAddrVariable {
         let register = self.allocate_register();
         self.usize_const(register, constant);
-        register
+        SingleAddrVariable::new_usize(register)
     }
 
     /// Computes left % right by emitting the necessary Brillig opcodes.
@@ -790,16 +825,22 @@ impl BrilligContext {
     /// to other binary instructions.
     pub(crate) fn modulo_instruction(
         &mut self,
-        result_register: MemoryAddress,
-        left: MemoryAddress,
-        right: MemoryAddress,
-        bit_size: u32,
+        result: SingleAddrVariable,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
         signed: bool,
     ) {
         // no debug_show, shown in binary instruction
         let scratch_register_i = self.allocate_register();
         let scratch_register_j = self.allocate_register();
 
+        assert!(
+            left.bit_size == right.bit_size,
+            "Not equal bitsize: lhs {}, rhs {}",
+            left.bit_size,
+            right.bit_size
+        );
+        let bit_size = left.bit_size;
         // i = left / right
         self.push_opcode(BrilligOpcode::BinaryIntOp {
             op: match signed {
@@ -808,8 +849,8 @@ impl BrilligContext {
             },
             destination: scratch_register_i,
             bit_size,
-            lhs: left,
-            rhs: right,
+            lhs: left.address,
+            rhs: right.address,
         });
 
         // j = i * right
@@ -818,15 +859,15 @@ impl BrilligContext {
             destination: scratch_register_j,
             bit_size,
             lhs: scratch_register_i,
-            rhs: right,
+            rhs: right.address,
         });
 
         // result_register = left - j
         self.push_opcode(BrilligOpcode::BinaryIntOp {
             op: BinaryIntOp::Sub,
-            destination: result_register,
+            destination: result.address,
             bit_size,
-            lhs: left,
+            lhs: left.address,
             rhs: scratch_register_j,
         });
         // Free scratch registers
@@ -909,9 +950,9 @@ impl BrilligContext {
         constant: usize,
     ) {
         let const_register = self.make_usize_constant(Value::from(constant));
-        self.memory_op(operand, const_register, destination, op);
+        self.memory_op(operand, const_register.address, destination, op);
         // Mark as no longer used for this purpose, frees for reuse
-        self.deallocate_register(const_register);
+        self.deallocate_single_addr(const_register);
     }
 
     /// Utility method to perform a binary instruction with a memory address
@@ -923,10 +964,16 @@ impl BrilligContext {
         op: BinaryIntOp,
     ) {
         self.binary_instruction(
-            lhs,
-            rhs,
-            destination,
-            BrilligBinaryOp::Integer { op, bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE },
+            SingleAddrVariable::new_usize(lhs),
+            SingleAddrVariable::new_usize(rhs),
+            SingleAddrVariable::new(
+                destination,
+                BrilligContext::binary_result_bit_size(
+                    BrilligBinaryOp::Integer(op),
+                    BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+                ),
+            ),
+            BrilligBinaryOp::Integer(op),
         );
     }
 
@@ -983,7 +1030,7 @@ impl BrilligContext {
     /// Utility method to transform a HeapArray to a HeapVector by making a runtime constant with the size.
     pub(crate) fn array_to_vector(&mut self, array: &BrilligArray) -> BrilligVector {
         let size_register = self.make_usize_constant(array.size.into());
-        BrilligVector { size: size_register, pointer: array.pointer, rc: array.rc }
+        BrilligVector { size: size_register.address, pointer: array.pointer, rc: array.rc }
     }
 
     /// Issues a blackbox operation.
@@ -996,47 +1043,48 @@ impl BrilligContext {
     /// And the radix register limb_count times to the target vector.
     pub(crate) fn radix_instruction(
         &mut self,
-        source: MemoryAddress,
+        source_field: SingleAddrVariable,
         target_vector: BrilligVector,
-        radix: MemoryAddress,
-        limb_count: MemoryAddress,
+        radix: SingleAddrVariable,
+        limb_count: SingleAddrVariable,
         big_endian: bool,
     ) {
-        self.mov_instruction(target_vector.size, limb_count);
+        assert!(source_field.bit_size == FieldElement::max_num_bits());
+        assert!(radix.bit_size == 32);
+        assert!(limb_count.bit_size == 32);
+        let radix_as_field =
+            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
+        self.cast_instruction(radix_as_field, radix);
+
+        self.cast_instruction(SingleAddrVariable::new_usize(target_vector.size), limb_count);
         self.usize_const(target_vector.rc, 1_usize.into());
         self.allocate_array_instruction(target_vector.pointer, target_vector.size);
 
-        let shifted_register = self.allocate_register();
-        self.mov_instruction(shifted_register, source);
+        let shifted_field =
+            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
+        self.mov_instruction(shifted_field.address, source_field.address);
 
-        let modulus_register: MemoryAddress = self.allocate_register();
+        let modulus_field =
+            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
 
         self.loop_instruction(target_vector.size, |ctx, iterator_register| {
             // Compute the modulus
-            ctx.modulo_instruction(
-                modulus_register,
-                shifted_register,
-                radix,
-                FieldElement::max_num_bits(),
-                false,
-            );
+            ctx.modulo_instruction(modulus_field, shifted_field, radix_as_field, false);
             // Write it
-            ctx.array_set(target_vector.pointer, iterator_register, modulus_register);
+            ctx.array_set(target_vector.pointer, iterator_register, modulus_field.address);
             // Integer div the field
             ctx.binary_instruction(
-                shifted_register,
-                radix,
-                shifted_register,
-                BrilligBinaryOp::Integer {
-                    op: BinaryIntOp::UnsignedDiv,
-                    bit_size: FieldElement::max_num_bits(),
-                },
+                shifted_field,
+                radix_as_field,
+                shifted_field,
+                BrilligBinaryOp::Integer(BinaryIntOp::UnsignedDiv),
             );
         });
 
         // Deallocate our temporary registers
-        self.deallocate_register(shifted_register);
-        self.deallocate_register(modulus_register);
+        self.deallocate_single_addr(shifted_field);
+        self.deallocate_single_addr(modulus_field);
+        self.deallocate_single_addr(radix_as_field);
 
         if big_endian {
             self.reverse_vector_in_place_instruction(target_vector);
@@ -1061,16 +1109,24 @@ impl BrilligContext {
             ctx.usize_op_in_place(index_at_end_of_array, BinaryIntOp::Sub, 1);
             ctx.memory_op(
                 index_at_end_of_array,
-                iterator_register,
+                iterator_register.address,
                 index_at_end_of_array,
                 BinaryIntOp::Sub,
             );
 
-            ctx.array_get(vector.pointer, index_at_end_of_array, end_value_register);
+            ctx.array_get(
+                vector.pointer,
+                SingleAddrVariable::new_usize(index_at_end_of_array),
+                end_value_register,
+            );
 
             // Write both values
             ctx.array_set(vector.pointer, iterator_register, end_value_register);
-            ctx.array_set(vector.pointer, index_at_end_of_array, start_value_register);
+            ctx.array_set(
+                vector.pointer,
+                SingleAddrVariable::new_usize(index_at_end_of_array),
+                start_value_register,
+            );
         });
 
         self.deallocate_register(iteration_count);
@@ -1086,13 +1142,12 @@ impl BrilligContext {
 }
 
 /// Type to encapsulate the binary operation types in Brillig
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub(crate) enum BrilligBinaryOp {
-    Field { op: BinaryFieldOp },
-    Integer { op: BinaryIntOp, bit_size: u32 },
-    // Modulo operation requires more than one opcode
-    // Brillig.
-    Modulo { is_signed_integer: bool, bit_size: u32 },
+    Field(BinaryFieldOp),
+    Integer(BinaryIntOp),
+    // Modulo operation requires more than one brillig opcode
+    Modulo { is_signed_integer: bool },
 }
 
 #[cfg(test)]
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
index 48ad3c5bae4..b94f8140ddd 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
@@ -5,12 +5,24 @@ use serde::{Deserialize, Serialize};
 
 use crate::ssa::ir::types::Type;
 
+use super::BRILLIG_MEMORY_ADDRESSING_BIT_SIZE;
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy)]
 pub(crate) struct SingleAddrVariable {
     pub(crate) address: MemoryAddress,
     pub(crate) bit_size: u32,
 }
 
+impl SingleAddrVariable {
+    pub(crate) fn new(address: MemoryAddress, bit_size: u32) -> Self {
+        SingleAddrVariable { address, bit_size }
+    }
+
+    pub(crate) fn new_usize(address: MemoryAddress) -> Self {
+        SingleAddrVariable { address, bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE }
+    }
+}
+
 /// The representation of a noir array in the Brillig IR
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy)]
 pub(crate) struct BrilligArray {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index dd57f0c4426..e32ce6f6b92 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -1,7 +1,7 @@
 //! This module contains functions for producing a higher level view disassembler of Brillig.
 
 use super::BrilligBinaryOp;
-use crate::brillig::brillig_ir::{ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE};
+use crate::brillig::brillig_ir::ReservedRegisters;
 use acvm::acir::brillig::{
     BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapArray, HeapVector, MemoryAddress, Value,
     ValueOrArray,
@@ -83,23 +83,11 @@ impl DebugToString for BinaryIntOp {
 impl DebugToString for BrilligBinaryOp {
     fn debug_to_string(&self) -> String {
         match self {
-            BrilligBinaryOp::Field { op } => op.debug_to_string(),
-            BrilligBinaryOp::Integer { op, bit_size } => {
-                // rationale: if there's >= 64 bits, we should not bother with this detail
-                if *bit_size >= BRILLIG_MEMORY_ADDRESSING_BIT_SIZE {
-                    op.debug_to_string()
-                } else {
-                    format!("i{}::{}", bit_size, op.debug_to_string())
-                }
-            }
-            BrilligBinaryOp::Modulo { is_signed_integer, bit_size } => {
+            BrilligBinaryOp::Field(op) => op.debug_to_string(),
+            BrilligBinaryOp::Integer(op) => op.debug_to_string(),
+            BrilligBinaryOp::Modulo { is_signed_integer } => {
                 let op = if *is_signed_integer { "%" } else { "%%" };
-                // rationale: if there's >= 64 bits, we should not bother with this detail
-                if *bit_size >= BRILLIG_MEMORY_ADDRESSING_BIT_SIZE {
-                    op.into()
-                } else {
-                    format!("{op}:{bit_size}")
-                }
+                op.into()
             }
         }
     }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 9d186f9bc60..83440e4a51d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -79,9 +79,9 @@ impl BrilligContext {
                     let rc_register = self.make_usize_constant(1_usize.into());
                     let flattened_size = BrilligContext::flattened_size(argument);
                     let var = BrilligVariable::BrilligArray(BrilligArray {
-                        pointer: pointer_to_the_array_in_calldata,
+                        pointer: pointer_to_the_array_in_calldata.address,
                         size: flattened_size,
-                        rc: rc_register,
+                        rc: rc_register.address,
                     });
 
                     current_calldata_pointer += flattened_size;
@@ -218,7 +218,7 @@ impl BrilligContext {
                             self.mov_instruction(nested_array_pointer, flattened_array_pointer);
                             self.memory_op(
                                 nested_array_pointer,
-                                source_index,
+                                source_index.address,
                                 nested_array_pointer,
                                 acvm::brillig_vm::brillig::BinaryIntOp::Add,
                             );
@@ -253,8 +253,8 @@ impl BrilligContext {
                         BrilligParameter::Slice(..) => unreachable!("ICE: Cannot deflatten slices"),
                     }
 
-                    self.deallocate_register(source_index);
-                    self.deallocate_register(target_index);
+                    self.deallocate_single_addr(source_index);
+                    self.deallocate_single_addr(target_index);
                 }
             }
 
@@ -323,11 +323,11 @@ impl BrilligContext {
                     self.flatten_array(
                         item_type,
                         *item_count,
-                        pointer_to_return_data,
+                        pointer_to_return_data.address,
                         returned_pointer,
                     );
 
-                    self.deallocate_register(pointer_to_return_data);
+                    self.deallocate_single_addr(pointer_to_return_data);
                     return_data_index += BrilligContext::flattened_size(return_param);
                 }
                 BrilligParameter::Slice(..) => {
@@ -412,7 +412,7 @@ impl BrilligContext {
 
                             self.memory_op(
                                 flattened_nested_array_pointer,
-                                target_index,
+                                target_index.address,
                                 flattened_nested_array_pointer,
                                 acvm::brillig_vm::brillig::BinaryIntOp::Add,
                             );
@@ -436,8 +436,8 @@ impl BrilligContext {
                         BrilligParameter::Slice(..) => unreachable!("ICE: Cannot flatten slices"),
                     }
 
-                    self.deallocate_register(source_index);
-                    self.deallocate_register(target_index);
+                    self.deallocate_single_addr(source_index);
+                    self.deallocate_single_addr(target_index);
                 }
             }
 
@@ -449,7 +449,7 @@ impl BrilligContext {
                 flattened_array_pointer,
                 item_count,
             );
-            self.deallocate_register(item_count);
+            self.deallocate_single_addr(item_count);
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs b/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
index cbaeb2477d6..e785212f8d2 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
@@ -92,7 +92,7 @@ impl FunctionBuilder {
                     let index = self
                         .current_function
                         .dfg
-                        .make_constant(FieldElement::from(i as i128), Type::field());
+                        .make_constant(FieldElement::from(i as i128), Type::length_type());
                     let element = self.insert_array_get(value, index, typ[0].clone());
                     self.add_to_data_bus(element, databus);
                 }

From a6016b46abf6da6de4566cf6d35a675d805dd9b5 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 13 Mar 2024 08:30:25 -0400
Subject: [PATCH 070/416] feat: Sync from aztec-packages (#4494)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
chore!: Remove open keyword from Noir
(https://github.com/AztecProtocol/aztec-packages/pull/4967)
chore: aztec-macros refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5127)
feat: make brillig-gen more AVM-friendly
(https://github.com/AztecProtocol/aztec-packages/pull/5091)
feat: Integrated native ACVM
(https://github.com/AztecProtocol/aztec-packages/pull/4903)
END_COMMIT_OVERRIDE

---------

Co-authored-by: sirasistant <sirasistant@gmail.com>
Co-authored-by: Maddiaa <47148561+Maddiaa0@users.noreply.github.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
Co-authored-by: Alex Gherghisan <alexghr@users.noreply.github.com>
---
 .aztec-sync-commit                            |    2 +-
 Cargo.lock                                    |   20 +
 Cargo.toml                                    |    4 +-
 aztec_macros/src/lib.rs                       | 1782 +----------------
 .../compute_note_hash_and_nullifier.rs        |  195 ++
 aztec_macros/src/transforms/events.rs         |  178 ++
 aztec_macros/src/transforms/functions.rs      |  707 +++++++
 aztec_macros/src/transforms/mod.rs            |    4 +
 aztec_macros/src/transforms/storage.rs        |  346 ++++
 aztec_macros/src/utils/ast_utils.rs           |  183 ++
 aztec_macros/src/utils/checks.rs              |   22 +
 aztec_macros/src/utils/constants.rs           |    3 +
 aztec_macros/src/utils/errors.rs              |   69 +
 aztec_macros/src/utils/hir_utils.rs           |  118 ++
 aztec_macros/src/utils/mod.rs                 |    5 +
 compiler/noirc_driver/src/contract.rs         |   31 +-
 compiler/noirc_driver/src/lib.rs              |   20 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |   11 +-
 .../noirc_evaluator/src/brillig/brillig_ir.rs |   32 +-
 compiler/noirc_frontend/src/ast/expression.rs |   19 -
 .../src/hir/def_collector/dc_crate.rs         |    3 +-
 .../src/hir/def_collector/dc_mod.rs           |   37 +-
 .../src/hir/resolution/errors.rs              |   14 -
 .../src/hir/resolution/resolver.rs            |   39 +-
 compiler/noirc_frontend/src/lexer/token.rs    |    3 -
 compiler/noirc_frontend/src/lib.rs            |    6 +-
 .../src/monomorphization/mod.rs               |    7 +-
 compiler/noirc_frontend/src/node_interner.rs  |   21 +-
 .../src/parser/parser/function.rs             |   14 +-
 .../src/parser/parser/traits.rs               |    6 +-
 compiler/wasm/src/types/noir_artifact.ts      |   11 +-
 .../wasm/test/fixtures/deps/lib-c/src/lib.nr  |    2 +-
 .../test/fixtures/deps/lib-c/src/module.nr    |    2 +-
 .../fixtures/deps/lib-c/src/module/foo.nr     |    2 +-
 .../test/fixtures/noir-contract/src/main.nr   |    3 +-
 docs/scripts/codegen_nargo_reference.sh       |    2 +-
 .../assert_msg_runtime/src/main.nr            |    2 +-
 .../brillig_assert_msg_runtime/src/main.nr    |    2 +-
 .../brillig_mut_ref_from_acir/src/main.nr     |    2 +-
 .../contract_with_impl/src/main.nr            |    2 +-
 .../simple_contract/src/main.nr               |    5 +-
 .../brillig_cow_regression/src/main.nr        |   42 +-
 .../double_verify_proof/Nargo.toml            |    4 +-
 .../double_verify_proof/src/main.nr           |    1 -
 .../double_verify_proof_recursive/Nargo.toml  |    5 +
 .../double_verify_proof_recursive/Prover.toml |    5 +
 .../double_verify_proof_recursive/src/main.nr |   29 +
 .../Nargo.toml                                |    5 +
 .../test_libraries/exporting_lib/src/lib.nr   |    1 -
 tooling/acvm_cli/Cargo.toml                   |   38 +
 tooling/acvm_cli/src/cli/execute_cmd.rs       |   78 +
 tooling/acvm_cli/src/cli/fs/inputs.rs         |   54 +
 tooling/acvm_cli/src/cli/fs/mod.rs            |    2 +
 tooling/acvm_cli/src/cli/fs/witness.rs        |   36 +
 tooling/acvm_cli/src/cli/mod.rs               |   41 +
 tooling/acvm_cli/src/errors.rs                |   52 +
 tooling/acvm_cli/src/main.rs                  |   36 +
 tooling/debugger/ignored-tests.txt            |    1 +
 tooling/nargo/src/artifacts/contract.rs       |   10 +-
 59 files changed, 2415 insertions(+), 1961 deletions(-)
 create mode 100644 aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
 create mode 100644 aztec_macros/src/transforms/events.rs
 create mode 100644 aztec_macros/src/transforms/functions.rs
 create mode 100644 aztec_macros/src/transforms/mod.rs
 create mode 100644 aztec_macros/src/transforms/storage.rs
 create mode 100644 aztec_macros/src/utils/ast_utils.rs
 create mode 100644 aztec_macros/src/utils/checks.rs
 create mode 100644 aztec_macros/src/utils/constants.rs
 create mode 100644 aztec_macros/src/utils/errors.rs
 create mode 100644 aztec_macros/src/utils/hir_utils.rs
 create mode 100644 aztec_macros/src/utils/mod.rs
 create mode 100644 test_programs/execution_success/double_verify_proof_recursive/Nargo.toml
 create mode 100644 test_programs/execution_success/double_verify_proof_recursive/Prover.toml
 create mode 100644 test_programs/execution_success/double_verify_proof_recursive/src/main.nr
 create mode 100644 test_programs/noir_test_failure/should_fail_suite_with_one_failure/Nargo.toml
 create mode 100644 tooling/acvm_cli/Cargo.toml
 create mode 100644 tooling/acvm_cli/src/cli/execute_cmd.rs
 create mode 100644 tooling/acvm_cli/src/cli/fs/inputs.rs
 create mode 100644 tooling/acvm_cli/src/cli/fs/mod.rs
 create mode 100644 tooling/acvm_cli/src/cli/fs/witness.rs
 create mode 100644 tooling/acvm_cli/src/cli/mod.rs
 create mode 100644 tooling/acvm_cli/src/errors.rs
 create mode 100644 tooling/acvm_cli/src/main.rs

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 6841c89b691..5a1cd9c70bd 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-7ff9b71d8d87fc93ae7dbd8ba63f5176b0cd17be
+58e15edf7fd3d32267b0aed883fc84f6cee327c9
diff --git a/Cargo.lock b/Cargo.lock
index ad3dce229fc..d5ce8a10509 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -66,6 +66,26 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "acvm_cli"
+version = "0.40.0"
+dependencies = [
+ "acir",
+ "acvm",
+ "bn254_blackbox_solver",
+ "clap",
+ "color-eyre",
+ "const_format",
+ "nargo",
+ "paste",
+ "proptest",
+ "rand 0.8.5",
+ "thiserror",
+ "toml 0.7.6",
+ "tracing-appender",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "acvm_js"
 version = "0.41.0"
diff --git a/Cargo.toml b/Cargo.toml
index 2ddb9c9e28f..b8f9b9ceacc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ members = [
     "tooling/nargo_toml",
     "tooling/noirc_abi",
     "tooling/noirc_abi_wasm",
+    "tooling/acvm_cli",
     # ACVM
     "acvm-repo/acir_field",
     "acvm-repo/acir",
@@ -35,7 +36,7 @@ members = [
     "acvm-repo/blackbox_solver",
     "acvm-repo/bn254_blackbox_solver",
 ]
-default-members = ["tooling/nargo_cli"]
+default-members = ["tooling/nargo_cli", "tooling/acvm_cli"]
 resolver = "2"
 
 [workspace.package]
@@ -77,6 +78,7 @@ noir_lsp = { path = "tooling/lsp" }
 noir_debugger = { path = "tooling/debugger" }
 noirc_abi = { path = "tooling/noirc_abi" }
 bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" }
+acvm_cli = { path = "tooling/acvm_cli" }
 
 # LSP
 async-lsp = { version = "0.1.0", default-features = false }
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index c21e26bdcad..1f3546cbb6a 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -1,28 +1,26 @@
-use std::borrow::{Borrow, BorrowMut};
-use std::vec;
+mod transforms;
+mod utils;
+
+use transforms::{
+    compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
+    events::{generate_selector_impl, transform_events},
+    functions::{transform_function, transform_unconstrained, transform_vm_function},
+    storage::{
+        assign_storage_slots, check_for_storage_definition, check_for_storage_implementation,
+        generate_storage_implementation,
+    },
+};
 
-use convert_case::{Case, Casing};
-use iter_extended::vecmap;
-use noirc_errors::{Location, Spanned};
 use noirc_frontend::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
-use noirc_frontend::hir::def_map::{LocalModuleId, ModuleId};
-use noirc_frontend::macros_api::parse_program;
-use noirc_frontend::macros_api::FieldElement;
-use noirc_frontend::macros_api::{
-    BlockExpression, CallExpression, CastExpression, Distinctness, Expression, ExpressionKind,
-    ForLoopStatement, ForRange, FunctionDefinition, FunctionReturnType, HirContext, HirExpression,
-    HirLiteral, HirStatement, Ident, IndexExpression, LetStatement, Literal,
-    MemberAccessExpression, MethodCallExpression, NoirFunction, NoirStruct, Param, Path, PathKind,
-    Pattern, PrefixExpression, SecondaryAttribute, Signedness, Span, Statement, StatementKind,
-    StructType, Type, TypeImpl, UnaryOp, UnresolvedType, UnresolvedTypeData, Visibility,
-};
-use noirc_frontend::macros_api::{CrateId, FileId};
-use noirc_frontend::macros_api::{MacroError, MacroProcessor};
-use noirc_frontend::macros_api::{ModuleDefId, NodeInterner, SortedModule, StructId};
-use noirc_frontend::node_interner::{FuncId, TraitId, TraitImplId, TraitImplKind};
-use noirc_frontend::{
-    BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, ItemVisibility, Lambda,
-};
+
+use noirc_frontend::macros_api::SortedModule;
+use noirc_frontend::macros_api::{CrateId, MacroError};
+use noirc_frontend::macros_api::{FileId, MacroProcessor};
+use noirc_frontend::macros_api::{HirContext, SecondaryAttribute, Span};
+
+use utils::ast_utils::is_custom_attribute;
+use utils::checks::{check_for_aztec_dependency, has_aztec_dependency};
+use utils::{constants::MAX_CONTRACT_PRIVATE_FUNCTIONS, errors::AztecMacroError};
 pub struct AztecMacro;
 
 impl MacroProcessor for AztecMacro {
@@ -35,23 +33,14 @@ impl MacroProcessor for AztecMacro {
         transform(ast, crate_id, context)
     }
 
-    fn process_unresolved_traits_impls(
+    fn process_collected_defs(
         &self,
         crate_id: &CrateId,
         context: &mut HirContext,
-        unresolved_traits_impls: &[UnresolvedTraitImpl],
-        collected_functions: &mut Vec<UnresolvedFunctions>,
+        collected_trait_impls: &[UnresolvedTraitImpl],
+        collected_functions: &mut [UnresolvedFunctions],
     ) -> Result<(), (MacroError, FileId)> {
-        if has_aztec_dependency(crate_id, context) {
-            inject_compute_note_hash_and_nullifier(
-                crate_id,
-                context,
-                unresolved_traits_impls,
-                collected_functions,
-            )
-        } else {
-            Ok(())
-        }
+        transform_collected_defs(crate_id, context, collected_trait_impls, collected_functions)
     }
 
     fn process_typed_ast(
@@ -63,225 +52,6 @@ impl MacroProcessor for AztecMacro {
     }
 }
 
-const FUNCTION_TREE_HEIGHT: u32 = 5;
-const MAX_CONTRACT_PRIVATE_FUNCTIONS: usize = 2_usize.pow(FUNCTION_TREE_HEIGHT);
-
-#[derive(Debug, Clone)]
-pub enum AztecMacroError {
-    AztecDepNotFound,
-    ContractHasTooManyPrivateFunctions { span: Span },
-    ContractConstructorMissing { span: Span },
-    UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
-    UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
-    CouldNotAssignStorageSlots { secondary_message: Option<String> },
-    EventError { span: Span, message: String },
-    UnsupportedAttributes { span: Span, secondary_message: Option<String> },
-}
-
-impl From<AztecMacroError> for MacroError {
-    fn from(err: AztecMacroError) -> Self {
-        match err {
-            AztecMacroError::AztecDepNotFound {} => MacroError {
-                primary_message: "Aztec dependency not found. Please add aztec as a dependency in your Cargo.toml. For more information go to https://docs.aztec.network/developers/debugging/aztecnr-errors#aztec-dependency-not-found-please-add-aztec-as-a-dependency-in-your-nargotoml".to_owned(),
-                secondary_message: None,
-                span: None,
-            },
-            AztecMacroError::ContractHasTooManyPrivateFunctions { span } => MacroError {
-                primary_message: format!("Contract can only have a maximum of {} private functions", MAX_CONTRACT_PRIVATE_FUNCTIONS),
-                secondary_message: None,
-                span: Some(span),
-            },
-            AztecMacroError::ContractConstructorMissing { span } => MacroError {
-                primary_message: "Contract must have a constructor function".to_owned(),
-                secondary_message: None,
-                span: Some(span),
-            },
-            AztecMacroError::UnsupportedFunctionArgumentType { span, typ } => MacroError {
-                primary_message: format!("Provided parameter type `{typ:?}` is not supported in Aztec contract interface"),
-                secondary_message: None,
-                span: Some(span),
-            },
-            AztecMacroError::UnsupportedStorageType { span, typ } => MacroError {
-                primary_message: format!("Provided storage type `{typ:?}` is not directly supported in Aztec. Please provide a custom storage implementation"),
-                secondary_message: None,
-                span,
-            },
-            AztecMacroError::CouldNotAssignStorageSlots { secondary_message } => MacroError {
-                primary_message: "Could not assign storage slots, please provide a custom storage implementation".to_string(),
-                secondary_message,
-                span: None,
-            },
-            AztecMacroError::EventError { span, message } => MacroError {
-                primary_message: message,
-                secondary_message: None,
-                span: Some(span),
-            },
-            AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
-                primary_message: "Unsupported attributes in contract function".to_string(),
-                secondary_message,
-                span: Some(span),
-            },
-        }
-    }
-}
-
-//
-//             Helper macros for creating noir ast nodes
-//
-fn ident(name: &str) -> Ident {
-    Ident::new(name.to_string(), Span::default())
-}
-
-fn ident_path(name: &str) -> Path {
-    Path::from_ident(ident(name))
-}
-
-fn path(ident: Ident) -> Path {
-    Path::from_ident(ident)
-}
-
-fn expression(kind: ExpressionKind) -> Expression {
-    Expression::new(kind, Span::default())
-}
-
-fn variable(name: &str) -> Expression {
-    expression(ExpressionKind::Variable(ident_path(name)))
-}
-
-fn variable_ident(identifier: Ident) -> Expression {
-    expression(ExpressionKind::Variable(path(identifier)))
-}
-
-fn variable_path(path: Path) -> Expression {
-    expression(ExpressionKind::Variable(path))
-}
-
-fn method_call(object: Expression, method_name: &str, arguments: Vec<Expression>) -> Expression {
-    expression(ExpressionKind::MethodCall(Box::new(MethodCallExpression {
-        object,
-        method_name: ident(method_name),
-        arguments,
-    })))
-}
-
-fn call(func: Expression, arguments: Vec<Expression>) -> Expression {
-    expression(ExpressionKind::Call(Box::new(CallExpression { func: Box::new(func), arguments })))
-}
-
-fn pattern(name: &str) -> Pattern {
-    Pattern::Identifier(ident(name))
-}
-
-fn mutable(name: &str) -> Pattern {
-    Pattern::Mutable(Box::new(pattern(name)), Span::default(), true)
-}
-
-fn mutable_assignment(name: &str, assigned_to: Expression) -> Statement {
-    make_statement(StatementKind::Let(LetStatement {
-        pattern: mutable(name),
-        r#type: make_type(UnresolvedTypeData::Unspecified),
-        expression: assigned_to,
-    }))
-}
-
-fn mutable_reference(variable_name: &str) -> Expression {
-    expression(ExpressionKind::Prefix(Box::new(PrefixExpression {
-        operator: UnaryOp::MutableReference,
-        rhs: variable(variable_name),
-    })))
-}
-
-fn assignment(name: &str, assigned_to: Expression) -> Statement {
-    make_statement(StatementKind::Let(LetStatement {
-        pattern: pattern(name),
-        r#type: make_type(UnresolvedTypeData::Unspecified),
-        expression: assigned_to,
-    }))
-}
-
-fn member_access(lhs: &str, rhs: &str) -> Expression {
-    expression(ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
-        lhs: variable(lhs),
-        rhs: ident(rhs),
-    })))
-}
-
-fn return_type(path: Path) -> FunctionReturnType {
-    let ty = make_type(UnresolvedTypeData::Named(path, vec![], true));
-    FunctionReturnType::Ty(ty)
-}
-
-fn lambda(parameters: Vec<(Pattern, UnresolvedType)>, body: Expression) -> Expression {
-    expression(ExpressionKind::Lambda(Box::new(Lambda {
-        parameters,
-        return_type: UnresolvedType {
-            typ: UnresolvedTypeData::Unspecified,
-            span: Some(Span::default()),
-        },
-        body,
-    })))
-}
-
-fn make_eq(lhs: Expression, rhs: Expression) -> Expression {
-    expression(ExpressionKind::Infix(Box::new(InfixExpression {
-        lhs,
-        rhs,
-        operator: Spanned::from(Span::default(), BinaryOpKind::Equal),
-    })))
-}
-
-macro_rules! chained_path {
-    ( $base:expr ) => {
-        {
-            ident_path($base)
-        }
-    };
-    ( $base:expr $(, $tail:expr)* ) => {
-        {
-            let mut base_path = ident_path($base);
-            $(
-                base_path.segments.push(ident($tail));
-            )*
-            base_path
-        }
-    }
-}
-
-macro_rules! chained_dep {
-    ( $base:expr $(, $tail:expr)* ) => {
-        {
-            let mut base_path = ident_path($base);
-            base_path.kind = PathKind::Dep;
-            $(
-                base_path.segments.push(ident($tail));
-            )*
-            base_path
-        }
-    }
-}
-
-fn cast(lhs: Expression, ty: UnresolvedTypeData) -> Expression {
-    expression(ExpressionKind::Cast(Box::new(CastExpression { lhs, r#type: make_type(ty) })))
-}
-
-fn make_type(typ: UnresolvedTypeData) -> UnresolvedType {
-    UnresolvedType { typ, span: Some(Span::default()) }
-}
-
-fn index_array(array: Ident, index: &str) -> Expression {
-    expression(ExpressionKind::Index(Box::new(IndexExpression {
-        collection: variable_path(path(array)),
-        index: variable(index),
-    })))
-}
-
-fn index_array_variable(array: Expression, index: &str) -> Expression {
-    expression(ExpressionKind::Index(Box::new(IndexExpression {
-        collection: array,
-        index: variable(index),
-    })))
-}
-
 //
 //                    Create AST Nodes for Aztec
 //
@@ -294,7 +64,6 @@ fn transform(
     context: &HirContext,
 ) -> Result<SortedModule, (MacroError, FileId)> {
     // Usage -> mut ast -> aztec_library::transform(&mut ast)
-
     // Covers all functions in the ast
     for submodule in ast.submodules.iter_mut().filter(|submodule| submodule.is_contract) {
         if transform_module(&mut submodule.contents, crate_id, context)
@@ -306,97 +75,6 @@ fn transform(
     Ok(ast)
 }
 
-//
-//                    Transform Hir Nodes for Aztec
-//
-
-/// Completes the Hir with data gathered from type resolution
-fn transform_hir(
-    crate_id: &CrateId,
-    context: &mut HirContext,
-) -> Result<(), (AztecMacroError, FileId)> {
-    transform_events(crate_id, context)?;
-    assign_storage_slots(crate_id, context)
-}
-
-/// Creates an error alerting the user that they have not downloaded the Aztec-noir library
-fn check_for_aztec_dependency(
-    crate_id: &CrateId,
-    context: &HirContext,
-) -> Result<(), (MacroError, FileId)> {
-    if has_aztec_dependency(crate_id, context) {
-        Ok(())
-    } else {
-        Err((AztecMacroError::AztecDepNotFound.into(), context.crate_graph[crate_id].root_file_id))
-    }
-}
-
-fn has_aztec_dependency(crate_id: &CrateId, context: &HirContext) -> bool {
-    context.crate_graph[crate_id].dependencies.iter().any(|dep| dep.as_name() == "aztec")
-}
-
-// Check to see if the user has defined a storage struct
-fn check_for_storage_definition(module: &SortedModule) -> bool {
-    module.types.iter().any(|r#struct| r#struct.name.0.contents == "Storage")
-}
-
-// Check to see if the user has defined a storage struct
-fn check_for_storage_implementation(module: &SortedModule) -> bool {
-    module.impls.iter().any(|r#impl| match &r#impl.object_type.typ {
-        UnresolvedTypeData::Named(path, _, _) => {
-            path.segments.last().is_some_and(|segment| segment.0.contents == "Storage")
-        }
-        _ => false,
-    })
-}
-
-// Check if "compute_note_hash_and_nullifier(AztecAddress,Field,Field,Field,[Field; N]) -> [Field; 4]" is defined
-fn check_for_compute_note_hash_and_nullifier_definition(
-    functions_data: &[(LocalModuleId, FuncId, NoirFunction)],
-    module_id: LocalModuleId,
-) -> bool {
-    functions_data.iter().filter(|func_data| func_data.0 == module_id).any(|func_data| {
-        func_data.2.def.name.0.contents == "compute_note_hash_and_nullifier"
-                && func_data.2.def.parameters.len() == 5
-                && match &func_data.2.def.parameters[0].typ.typ {
-                    UnresolvedTypeData::Named(path, _, _) => path.segments.last().unwrap().0.contents == "AztecAddress",
-                    _ => false,
-                }
-                && func_data.2.def.parameters[1].typ.typ == UnresolvedTypeData::FieldElement
-                && func_data.2.def.parameters[2].typ.typ == UnresolvedTypeData::FieldElement
-                && func_data.2.def.parameters[3].typ.typ == UnresolvedTypeData::FieldElement
-                // checks if the 5th parameter is an array and the Box<UnresolvedType> in
-                // Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>) contains only fields
-                && match &func_data.2.def.parameters[4].typ.typ {
-                    UnresolvedTypeData::Array(_, inner_type) => {
-                        matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
-                    },
-                    _ => false,
-                }
-                // We check the return type the same way as we did the 5th parameter
-                && match &func_data.2.def.return_type {
-                    FunctionReturnType::Default(_) => false,
-                    FunctionReturnType::Ty(unresolved_type) => {
-                        match &unresolved_type.typ {
-                            UnresolvedTypeData::Array(_, inner_type) => {
-                                matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
-                            },
-                            _ => false,
-                        }
-                    }
-                }
-    })
-}
-
-/// Checks if an attribute is a custom attribute with a specific name
-fn is_custom_attribute(attr: &SecondaryAttribute, attribute_name: &str) -> bool {
-    if let SecondaryAttribute::Custom(custom_attr) = attr {
-        custom_attr.as_str() == attribute_name
-    } else {
-        false
-    }
-}
-
 /// Determines if ast nodes are annotated with aztec attributes.
 /// For annotated functions it calls the `transform` function which will perform the required transformations.
 /// Returns true if an annotated node is found, false otherwise
@@ -473,10 +151,7 @@ fn transform_module(
             transform_vm_function(func, storage_defined)
                 .map_err(|err| (err, crate_graph.root_file_id))?;
             has_transformed_module = true;
-        }
-
-        // Add the storage struct to the beginning of the function if it is unconstrained in an aztec contract
-        if storage_defined && func.def.is_unconstrained {
+        } else if storage_defined && func.def.is_unconstrained {
             transform_unconstrained(func);
             has_transformed_module = true;
         }
@@ -518,1402 +193,33 @@ fn transform_module(
     Ok(has_transformed_module)
 }
 
-/// Auxiliary function to generate the storage constructor for a given field, using
-/// the Storage definition as a reference. Supports nesting.
-fn generate_storage_field_constructor(
-    (type_ident, unresolved_type): &(Ident, UnresolvedType),
-    slot: Expression,
-) -> Result<Expression, AztecMacroError> {
-    let typ = &unresolved_type.typ;
-    match typ {
-        UnresolvedTypeData::Named(path, generics, _) => {
-            let mut new_path = path.clone().to_owned();
-            new_path.segments.push(ident("new"));
-            match path.segments.last().unwrap().0.contents.as_str() {
-                "Map" => Ok(call(
-                    variable_path(new_path),
-                    vec![
-                        variable("context"),
-                        slot,
-                        lambda(
-                            vec![
-                                (
-                                    pattern("context"),
-                                    make_type(UnresolvedTypeData::Named(
-                                        chained_dep!("aztec", "context", "Context"),
-                                        vec![],
-                                        true,
-                                    )),
-                                ),
-                                (
-                                    Pattern::Identifier(ident("slot")),
-                                    make_type(UnresolvedTypeData::FieldElement),
-                                ),
-                            ],
-                            generate_storage_field_constructor(
-                                &(type_ident.clone(), generics.iter().last().unwrap().clone()),
-                                variable("slot"),
-                            )?,
-                        ),
-                    ],
-                )),
-                _ => Ok(call(variable_path(new_path), vec![variable("context"), slot])),
-            }
-        }
-        _ => Err(AztecMacroError::UnsupportedStorageType {
-            typ: typ.clone(),
-            span: Some(type_ident.span()),
-        }),
-    }
-}
-
-// Generates the Storage implementation block from the Storage struct definition if it does not exist
-/// From:
-///
-/// struct Storage {
-///     a_map: Map<Field, SomeStoragePrimitive<ASerializableType>>,
-///     a_nested_map: Map<Field, Map<Field, SomeStoragePrimitive<ASerializableType>>>,
-///     a_field: SomeStoragePrimitive<ASerializableType>,
-/// }
-///
-/// To:
-///
-/// impl Storage {
-///    fn init(context: Context) -> Self {
-///        Storage {
-///             a_map: Map::new(context, 0, |context, slot| {
-///                 SomeStoragePrimitive::new(context, slot)
-///             }),
-///             a_nested_map: Map::new(context, 0, |context, slot| {
-///                 Map::new(context, slot, |context, slot| {
-///                     SomeStoragePrimitive::new(context, slot)
-///                })
-///            }),
-///            a_field: SomeStoragePrimitive::new(context, 0),
-///         }
-///    }
-/// }
-///
-/// Storage slots are generated as 0 and will be populated using the information from the HIR
-/// at a later stage.
-fn generate_storage_implementation(module: &mut SortedModule) -> Result<(), AztecMacroError> {
-    let definition =
-        module.types.iter().find(|r#struct| r#struct.name.0.contents == "Storage").unwrap();
-
-    let slot_zero = expression(ExpressionKind::Literal(Literal::Integer(
-        FieldElement::from(i128::from(0)),
-        false,
-    )));
-
-    let field_constructors = definition
-        .fields
-        .iter()
-        .flat_map(|field| {
-            generate_storage_field_constructor(field, slot_zero.clone())
-                .map(|expression| (field.0.clone(), expression))
-        })
-        .collect();
-
-    let storage_constructor_statement = make_statement(StatementKind::Expression(expression(
-        ExpressionKind::constructor((chained_path!("Storage"), field_constructors)),
-    )));
-
-    let init = NoirFunction::normal(FunctionDefinition::normal(
-        &ident("init"),
-        &vec![],
-        &[(
-            ident("context"),
-            make_type(UnresolvedTypeData::Named(
-                chained_dep!("aztec", "context", "Context"),
-                vec![],
-                true,
-            )),
-        )],
-        &BlockExpression(vec![storage_constructor_statement]),
-        &[],
-        &return_type(chained_path!("Self")),
-    ));
-
-    let storage_impl = TypeImpl {
-        object_type: UnresolvedType {
-            typ: UnresolvedTypeData::Named(chained_path!("Storage"), vec![], true),
-            span: Some(Span::default()),
-        },
-        type_span: Span::default(),
-        generics: vec![],
-        methods: vec![(init, Span::default())],
-    };
-    module.impls.push(storage_impl);
-
-    Ok(())
-}
-
-/// If it does, it will insert the following things:
-/// - A new Input that is provided for a kernel app circuit, named: {Public/Private}ContextInputs
-/// - Hashes all of the function input variables
-///     - This instantiates a helper function
-fn transform_function(
-    ty: &str,
-    func: &mut NoirFunction,
-    storage_defined: bool,
-    is_initializer: bool,
-    insert_init_check: bool,
-    is_internal: bool,
-) -> Result<(), AztecMacroError> {
-    let context_name = format!("{}Context", ty);
-    let inputs_name = format!("{}ContextInputs", ty);
-    let return_type_name = format!("{}CircuitPublicInputs", ty);
-
-    // Add check that msg sender equals this address and flag function as internal
-    if is_internal {
-        let is_internal_check = create_internal_check(func.name());
-        func.def.body.0.insert(0, is_internal_check);
-        func.def.is_internal = true;
-    }
-
-    // Add initialization check
-    if insert_init_check {
-        let init_check = create_init_check();
-        func.def.body.0.insert(0, init_check);
-    }
-
-    // Add access to the storage struct
-    if storage_defined {
-        let storage_def = abstract_storage(&ty.to_lowercase(), false);
-        func.def.body.0.insert(0, storage_def);
-    }
-
-    // Insert the context creation as the first action
-    let create_context = create_context(&context_name, &func.def.parameters)?;
-    func.def.body.0.splice(0..0, (create_context).iter().cloned());
-
-    // Add the inputs to the params
-    let input = create_inputs(&inputs_name);
-    func.def.parameters.insert(0, input);
-
-    // Abstract return types such that they get added to the kernel's return_values
-    if let Some(return_values) = abstract_return_values(func) {
-        // In case we are pushing return values to the context, we remove the statement that originated it
-        // This avoids running duplicate code, since blocks like if/else can be value returning statements
-        func.def.body.0.pop();
-        // Add the new return statement
-        func.def.body.0.push(return_values);
-    }
-
-    // Before returning mark the contract as initialized
-    if is_initializer {
-        let mark_initialized = create_mark_as_initialized(ty);
-        func.def.body.0.push(mark_initialized);
-    }
-
-    // Push the finish method call to the end of the function
-    let finish_def = create_context_finish();
-    func.def.body.0.push(finish_def);
-
-    let return_type = create_return_type(&return_type_name);
-    func.def.return_type = return_type;
-    func.def.return_visibility = Visibility::Public;
-
-    // Distinct return types are only required for private functions
-    // Public functions should have open auto-inferred
-    match ty {
-        "Private" => func.def.return_distinctness = Distinctness::Distinct,
-        "Public" => func.def.is_open = true,
-        _ => (),
-    }
-
-    Ok(())
-}
-
-/// Transform a function to work with AVM bytecode
-fn transform_vm_function(
-    func: &mut NoirFunction,
-    _storage_defined: bool,
-) -> Result<(), AztecMacroError> {
-    // Push Avm context creation to the beginning of the function
-    let create_context = create_avm_context()?;
-    func.def.body.0.insert(0, create_context);
-
-    // We want the function to be seen as a public function
-    func.def.is_open = true;
-
-    // NOTE: the line below is a temporary hack to trigger external transpilation tools
-    // It will be removed once the transpiler is integrated into the Noir compiler
-    func.def.name.0.contents = format!("avm_{}", func.def.name.0.contents);
-    Ok(())
-}
-
-/// Transform Unconstrained
-///
-/// Inserts the following code at the beginning of an unconstrained function
-/// ```noir
-/// let storage = Storage::init(Context::none());
-/// ```
-///
-/// This will allow developers to access their contract' storage struct in unconstrained functions
-fn transform_unconstrained(func: &mut NoirFunction) {
-    func.def.body.0.insert(0, abstract_storage("Unconstrained", true));
-}
-
-fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<StructId> {
-    context
-        .def_map(crate_id)
-        .expect("ICE: Missing crate in def_map")
-        .modules()
-        .iter()
-        .flat_map(|(_, module)| {
-            module.type_definitions().filter_map(|typ| {
-                if let ModuleDefId::TypeId(struct_id) = typ {
-                    Some(struct_id)
-                } else {
-                    None
-                }
-            })
-        })
-        .collect()
-}
-
-fn collect_traits(context: &HirContext) -> Vec<TraitId> {
-    let crates = context.crates();
-    crates
-        .flat_map(|crate_id| context.def_map(&crate_id).map(|def_map| def_map.modules()))
-        .flatten()
-        .flat_map(|module| {
-            module.type_definitions().filter_map(|typ| {
-                if let ModuleDefId::TraitId(struct_id) = typ {
-                    Some(struct_id)
-                } else {
-                    None
-                }
-            })
-        })
-        .collect()
-}
-
-/// Substitutes the signature literal that was introduced in the selector method previously with the actual signature.
-fn transform_event(
-    struct_id: StructId,
-    interner: &mut NodeInterner,
-) -> Result<(), (AztecMacroError, FileId)> {
-    let struct_type = interner.get_struct(struct_id);
-    let selector_id = interner
-        .lookup_method(&Type::Struct(struct_type.clone(), vec![]), struct_id, "selector", false)
-        .ok_or_else(|| {
-            let error = AztecMacroError::EventError {
-                span: struct_type.borrow().location.span,
-                message: "Selector method not found".to_owned(),
-            };
-            (error, struct_type.borrow().location.file)
-        })?;
-    let selector_function = interner.function(&selector_id);
-
-    let compute_selector_statement = interner.statement(
-        selector_function.block(interner).statements().first().ok_or_else(|| {
-            let error = AztecMacroError::EventError {
-                span: struct_type.borrow().location.span,
-                message: "Compute selector statement not found".to_owned(),
-            };
-            (error, struct_type.borrow().location.file)
-        })?,
-    );
-
-    let compute_selector_expression = match compute_selector_statement {
-        HirStatement::Expression(expression_id) => match interner.expression(&expression_id) {
-            HirExpression::Call(hir_call_expression) => Some(hir_call_expression),
-            _ => None,
-        },
-        _ => None,
-    }
-    .ok_or_else(|| {
-        let error = AztecMacroError::EventError {
-            span: struct_type.borrow().location.span,
-            message: "Compute selector statement is not a call expression".to_owned(),
-        };
-        (error, struct_type.borrow().location.file)
-    })?;
-
-    let first_arg_id = compute_selector_expression.arguments.first().ok_or_else(|| {
-        let error = AztecMacroError::EventError {
-            span: struct_type.borrow().location.span,
-            message: "Compute selector statement is not a call expression".to_owned(),
-        };
-        (error, struct_type.borrow().location.file)
-    })?;
-
-    match interner.expression(first_arg_id) {
-        HirExpression::Literal(HirLiteral::Str(signature))
-            if signature == SIGNATURE_PLACEHOLDER =>
-        {
-            let selector_literal_id = *first_arg_id;
-
-            let structure = interner.get_struct(struct_id);
-            let signature = event_signature(&structure.borrow());
-            interner.update_expression(selector_literal_id, |expr| {
-                *expr = HirExpression::Literal(HirLiteral::Str(signature.clone()));
-            });
-
-            // Also update the type! It might have a different length now than the placeholder.
-            interner.push_expr_type(
-                selector_literal_id,
-                Type::String(Box::new(Type::Constant(signature.len() as u64))),
-            );
-            Ok(())
-        }
-        _ => Err((
-            AztecMacroError::EventError {
-                span: struct_type.borrow().location.span,
-                message: "Signature placeholder literal does not match".to_owned(),
-            },
-            struct_type.borrow().location.file,
-        )),
-    }
-}
-
-fn transform_events(
+fn transform_collected_defs(
     crate_id: &CrateId,
     context: &mut HirContext,
-) -> Result<(), (AztecMacroError, FileId)> {
-    for struct_id in collect_crate_structs(crate_id, context) {
-        let attributes = context.def_interner.struct_attributes(&struct_id);
-        if attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Event)) {
-            transform_event(struct_id, &mut context.def_interner)?;
-        }
-    }
-    Ok(())
-}
-
-/// Obtains the serialized length of a type that implements the Serialize trait.
-fn get_serialized_length(
-    traits: &[TraitId],
-    typ: &Type,
-    interner: &NodeInterner,
-) -> Result<u64, AztecMacroError> {
-    let (struct_name, maybe_stored_in_state) = match typ {
-        Type::Struct(struct_type, generics) => {
-            Ok((struct_type.borrow().name.0.contents.clone(), generics.first()))
-        }
-        _ => Err(AztecMacroError::CouldNotAssignStorageSlots {
-            secondary_message: Some("State storage variable must be a struct".to_string()),
-        }),
-    }?;
-    let stored_in_state =
-        maybe_stored_in_state.ok_or(AztecMacroError::CouldNotAssignStorageSlots {
-            secondary_message: Some("State storage variable must be generic".to_string()),
-        })?;
-
-    let is_note = traits.iter().any(|&trait_id| {
-        let r#trait = interner.get_trait(trait_id);
-        r#trait.name.0.contents == "NoteInterface"
-            && !interner.lookup_all_trait_implementations(stored_in_state, trait_id).is_empty()
-    });
-
-    // Maps and (private) Notes always occupy a single slot. Someone could store a Note in PublicMutable for whatever reason though.
-    if struct_name == "Map" || (is_note && struct_name != "PublicMutable") {
-        return Ok(1);
-    }
-
-    let serialized_trait_impl_kind = traits
-        .iter()
-        .find_map(|&trait_id| {
-            let r#trait = interner.get_trait(trait_id);
-            if r#trait.borrow().name.0.contents == "Serialize"
-                && r#trait.borrow().generics.len() == 1
-            {
-                interner
-                    .lookup_all_trait_implementations(stored_in_state, trait_id)
-                    .into_iter()
-                    .next()
-            } else {
-                None
-            }
-        })
-        .ok_or(AztecMacroError::CouldNotAssignStorageSlots {
-            secondary_message: Some("Stored data must implement Serialize trait".to_string()),
-        })?;
-
-    let serialized_trait_impl_id = match serialized_trait_impl_kind {
-        TraitImplKind::Normal(trait_impl_id) => Ok(trait_impl_id),
-        _ => Err(AztecMacroError::CouldNotAssignStorageSlots { secondary_message: None }),
-    }?;
-
-    let serialized_trait_impl_shared = interner.get_trait_implementation(*serialized_trait_impl_id);
-    let serialized_trait_impl = serialized_trait_impl_shared.borrow();
-
-    match serialized_trait_impl.trait_generics.first().unwrap() {
-        Type::Constant(value) => Ok(*value),
-        _ => Err(AztecMacroError::CouldNotAssignStorageSlots { secondary_message: None }),
-    }
-}
-
-/// Assigns storage slots to the storage struct fields based on the serialized length of the types. This automatic assignment
-/// will only trigger if the assigned storage slot is invalid (0 as generated by generate_storage_implementation)
-fn assign_storage_slots(
-    crate_id: &CrateId,
-    context: &mut HirContext,
-) -> Result<(), (AztecMacroError, FileId)> {
-    let traits: Vec<_> = collect_traits(context);
-    for struct_id in collect_crate_structs(crate_id, context) {
-        let interner: &mut NodeInterner = context.def_interner.borrow_mut();
-        let r#struct = interner.get_struct(struct_id);
-        let file_id = r#struct.borrow().location.file;
-        if r#struct.borrow().name.0.contents == "Storage" && r#struct.borrow().id.krate().is_root()
-        {
-            let init_id = interner
-                .lookup_method(
-                    &Type::Struct(interner.get_struct(struct_id), vec![]),
-                    struct_id,
-                    "init",
-                    false,
-                )
-                .ok_or((
-                    AztecMacroError::CouldNotAssignStorageSlots {
-                        secondary_message: Some(
-                            "Storage struct must have an init function".to_string(),
-                        ),
-                    },
-                    file_id,
-                ))?;
-            let init_function = interner.function(&init_id).block(interner);
-            let init_function_statement_id = init_function.statements().first().ok_or((
-                AztecMacroError::CouldNotAssignStorageSlots {
-                    secondary_message: Some("Init storage statement not found".to_string()),
-                },
-                file_id,
-            ))?;
-            let storage_constructor_statement = interner.statement(init_function_statement_id);
-
-            let storage_constructor_expression = match storage_constructor_statement {
-                HirStatement::Expression(expression_id) => {
-                    match interner.expression(&expression_id) {
-                        HirExpression::Constructor(hir_constructor_expression) => {
-                            Ok(hir_constructor_expression)
-                        }
-                        _ => Err((AztecMacroError::CouldNotAssignStorageSlots {
-                            secondary_message: Some(
-                                "Storage constructor statement must be a constructor expression"
-                                    .to_string(),
-                            ),
-                        }, file_id))
-                    }
-                }
-                _ => Err((
-                    AztecMacroError::CouldNotAssignStorageSlots {
-                        secondary_message: Some(
-                            "Storage constructor statement must be an expression".to_string(),
-                        ),
-                    },
-                    file_id,
-                )),
-            }?;
-
-            let mut storage_slot: u64 = 1;
-            for (index, (_, expr_id)) in storage_constructor_expression.fields.iter().enumerate() {
-                let fields = r#struct.borrow().get_fields(&[]);
-                let (_, field_type) = fields.get(index).unwrap();
-                let new_call_expression = match interner.expression(expr_id) {
-                    HirExpression::Call(hir_call_expression) => Ok(hir_call_expression),
-                    _ => Err((
-                        AztecMacroError::CouldNotAssignStorageSlots {
-                            secondary_message: Some(
-                                "Storage field initialization expression is not a call expression"
-                                    .to_string(),
-                            ),
-                        },
-                        file_id,
-                    )),
-                }?;
-
-                let slot_arg_expression = interner.expression(&new_call_expression.arguments[1]);
-
-                let current_storage_slot = match slot_arg_expression {
-                    HirExpression::Literal(HirLiteral::Integer(slot, _)) => Ok(slot.to_u128()),
-                    _ => Err((
-                        AztecMacroError::CouldNotAssignStorageSlots {
-                            secondary_message: Some(
-                                "Storage slot argument expression must be a literal integer"
-                                    .to_string(),
-                            ),
-                        },
-                        file_id,
-                    )),
-                }?;
-
-                if current_storage_slot != 0 {
-                    continue;
-                }
-
-                let type_serialized_len = get_serialized_length(&traits, field_type, interner)
-                    .map_err(|err| (err, file_id))?;
-                interner.update_expression(new_call_expression.arguments[1], |expr| {
-                    *expr = HirExpression::Literal(HirLiteral::Integer(
-                        FieldElement::from(u128::from(storage_slot)),
-                        false,
-                    ));
-                });
-
-                storage_slot += type_serialized_len;
-            }
-        }
-    }
-    Ok(())
-}
-
-const SIGNATURE_PLACEHOLDER: &str = "SIGNATURE_PLACEHOLDER";
-
-/// Generates the impl for an event selector
-///
-/// Inserts the following code:
-/// ```noir
-/// impl SomeStruct {
-///    fn selector() -> FunctionSelector {
-///       aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature("SIGNATURE_PLACEHOLDER")
-///    }
-/// }
-/// ```
-///
-/// This allows developers to emit events without having to write the signature of the event every time they emit it.
-/// The signature cannot be known at this point since types are not resolved yet, so we use a signature placeholder.
-/// It'll get resolved after by transforming the HIR.
-fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
-    let struct_type =
-        make_type(UnresolvedTypeData::Named(path(structure.name.clone()), vec![], true));
-
-    let selector_path =
-        chained_dep!("aztec", "protocol_types", "abis", "function_selector", "FunctionSelector");
-    let mut from_signature_path = selector_path.clone();
-    from_signature_path.segments.push(ident("from_signature"));
-
-    let selector_fun_body = BlockExpression(vec![make_statement(StatementKind::Expression(call(
-        variable_path(from_signature_path),
-        vec![expression(ExpressionKind::Literal(Literal::Str(SIGNATURE_PLACEHOLDER.to_string())))],
-    )))]);
-
-    // Define `FunctionSelector` return type
-    let return_type =
-        FunctionReturnType::Ty(make_type(UnresolvedTypeData::Named(selector_path, vec![], true)));
-
-    let mut selector_fn_def = FunctionDefinition::normal(
-        &ident("selector"),
-        &vec![],
-        &[],
-        &selector_fun_body,
-        &[],
-        &return_type,
-    );
-
-    selector_fn_def.visibility = ItemVisibility::Public;
-
-    // Seems to be necessary on contract modules
-    selector_fn_def.return_visibility = Visibility::Public;
-
-    TypeImpl {
-        object_type: struct_type,
-        type_span: structure.span,
-        generics: vec![],
-        methods: vec![(NoirFunction::normal(selector_fn_def), Span::default())],
-    }
-}
-
-/// Helper function that returns what the private context would look like in the ast
-/// This should make it available to be consumed within aztec private annotated functions.
-///
-/// The replaced code:
-/// ```noir
-/// /// Before
-/// fn foo(inputs: PrivateContextInputs) {
-///    // ...
-/// }
-///
-/// /// After
-/// #[aztec(private)]
-/// fn foo() {
-///   // ...
-/// }
-fn create_inputs(ty: &str) -> Param {
-    let context_ident = ident("inputs");
-    let context_pattern = Pattern::Identifier(context_ident);
-
-    let path_snippet = ty.to_case(Case::Snake); // e.g. private_context_inputs
-    let type_path = chained_dep!("aztec", "context", "inputs", &path_snippet, ty);
-
-    let context_type = make_type(UnresolvedTypeData::Named(type_path, vec![], true));
-    let visibility = Visibility::Private;
-
-    Param { pattern: context_pattern, typ: context_type, visibility, span: Span::default() }
-}
-
-/// Creates an initialization check to ensure that the contract has been initialized, meant to
-/// be injected as the first statement of any function after the context has been created.
-///
-/// ```noir
-/// assert_is_initialized(&mut context);
-/// ```
-fn create_init_check() -> Statement {
-    make_statement(StatementKind::Expression(call(
-        variable_path(chained_dep!("aztec", "initializer", "assert_is_initialized")),
-        vec![mutable_reference("context")],
-    )))
-}
-
-/// Creates a call to mark_as_initialized which emits the initialization nullifier, meant to
-/// be injected as the last statement before returning in a constructor.
-///
-/// ```noir
-/// mark_as_initialized(&mut context);
-/// ```
-fn create_mark_as_initialized(ty: &str) -> Statement {
-    let name = if ty == "Public" { "mark_as_initialized_public" } else { "mark_as_initialized" };
-    make_statement(StatementKind::Expression(call(
-        variable_path(chained_dep!("aztec", "initializer", name)),
-        vec![mutable_reference("context")],
-    )))
-}
-
-/// Creates a check for internal functions ensuring that the caller is self.
-///
-/// ```noir
-/// assert(context.msg_sender() == context.this_address(), "Function can only be called internally");
-/// ```
-fn create_internal_check(fname: &str) -> Statement {
-    make_statement(StatementKind::Constrain(ConstrainStatement(
-        make_eq(
-            method_call(variable("context"), "msg_sender", vec![]),
-            method_call(variable("context"), "this_address", vec![]),
-        ),
-        Some(expression(ExpressionKind::Literal(Literal::Str(format!(
-            "Function {} can only be called internally",
-            fname
-        ))))),
-        ConstrainKind::Assert,
-    )))
-}
-
-/// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
-/// appended into the args hash object.
-///
-/// The replaced code:
-/// ```noir
-/// #[aztec(private)]
-/// fn foo(structInput: SomeStruct, arrayInput: [u8; 10], fieldInput: Field) -> Field {
-///     // Create the hasher object
-///     let mut hasher = Hasher::new();
-///
-///     // struct inputs call serialize on them to add an array of fields
-///     hasher.add_multiple(structInput.serialize());
-///
-///     // Array inputs are iterated over and each element is added to the hasher (as a field)
-///     for i in 0..arrayInput.len() {
-///         hasher.add(arrayInput[i] as Field);
-///     }
-///     // Field inputs are added to the hasher
-///     hasher.add({ident});
-///
-///     // Create the context
-///     // The inputs (injected by this `create_inputs`) and completed hash object are passed to the context
-///     let mut context = PrivateContext::new(inputs, hasher.hash());
-/// }
-/// ```
-fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
-    let mut injected_expressions: Vec<Statement> = vec![];
-
-    // `let mut hasher = Hasher::new();`
-    let let_hasher = mutable_assignment(
-        "hasher", // Assigned to
-        call(
-            variable_path(chained_dep!("aztec", "hasher", "Hasher", "new")), // Path
-            vec![],                                                          // args
-        ),
-    );
-
-    // Completes: `let mut hasher = Hasher::new();`
-    injected_expressions.push(let_hasher);
-
-    // Iterate over each of the function parameters, adding to them to the hasher
-    for Param { pattern, typ, span, .. } in params {
-        match pattern {
-            Pattern::Identifier(identifier) => {
-                // Match the type to determine the padding to do
-                let unresolved_type = &typ.typ;
-                let expression = match unresolved_type {
-                    // `hasher.add_multiple({ident}.serialize())`
-                    UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier),
-                    UnresolvedTypeData::Array(_, arr_type) => {
-                        add_array_to_hasher(identifier, arr_type)
-                    }
-                    // `hasher.add({ident})`
-                    UnresolvedTypeData::FieldElement => add_field_to_hasher(identifier),
-                    // Add the integer to the hasher, casted to a field
-                    // `hasher.add({ident} as Field)`
-                    UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
-                        add_cast_to_hasher(identifier)
-                    }
-                    UnresolvedTypeData::String(..) => {
-                        let (var_bytes, id) = str_to_bytes(identifier);
-                        injected_expressions.push(var_bytes);
-                        add_array_to_hasher(
-                            &id,
-                            &UnresolvedType {
-                                typ: UnresolvedTypeData::Integer(
-                                    Signedness::Unsigned,
-                                    noirc_frontend::IntegerBitSize::ThirtyTwo,
-                                ),
-                                span: None,
-                            },
-                        )
-                    }
-                    _ => {
-                        return Err(AztecMacroError::UnsupportedFunctionArgumentType {
-                            typ: unresolved_type.clone(),
-                            span: *span,
-                        })
-                    }
-                };
-                injected_expressions.push(expression);
-            }
-            _ => todo!(), // Maybe unreachable?
-        }
-    }
-
-    // Create the inputs to the context
-    let inputs_expression = variable("inputs");
-    // `hasher.hash()`
-    let hash_call = method_call(
-        variable("hasher"), // variable
-        "hash",             // method name
-        vec![],             // args
-    );
-
-    let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
-
-    // let mut context = {ty}::new(inputs, hash);
-    let let_context = mutable_assignment(
-        "context", // Assigned to
-        call(
-            variable_path(chained_dep!("aztec", "context", &path_snippet, ty, "new")), // Path
-            vec![inputs_expression, hash_call],                                        // args
-        ),
-    );
-    injected_expressions.push(let_context);
-
-    // Return all expressions that will be injected by the hasher
-    Ok(injected_expressions)
-}
-
-/// Creates an mutable avm context
-///
-/// ```noir
-/// /// Before
-/// #[aztec(public-vm)]
-/// fn foo() -> Field {
-///   let mut context = aztec::context::AVMContext::new();
-///   let timestamp = context.timestamp();
-///   // ...
-/// }
-///
-/// /// After
-/// #[aztec(private)]
-/// fn foo() -> Field {
-///     let mut timestamp = context.timestamp();
-///     // ...
-/// }
-fn create_avm_context() -> Result<Statement, AztecMacroError> {
-    let let_context = mutable_assignment(
-        "context", // Assigned to
-        call(
-            variable_path(chained_dep!("aztec", "context", "AVMContext", "new")), // Path
-            vec![],                                                               // args
-        ),
-    );
-
-    Ok(let_context)
-}
-
-/// Abstract Return Type
-///
-/// This function intercepts the function's current return type and replaces it with pushes
-/// To the kernel
-///
-/// The replaced code:
-/// ```noir
-/// /// Before
-/// #[aztec(private)]
-/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
-///   // ...
-///   let my_return_value: Field = 10;
-///   context.return_values.push(my_return_value);
-/// }
-///
-/// /// After
-/// #[aztec(private)]
-/// fn foo() -> Field {
-///     // ...
-///    let my_return_value: Field = 10;
-///    my_return_value
-/// }
-/// ```
-/// Similarly; Structs will be pushed to the context, after serialize() is called on them.
-/// Arrays will be iterated over and each element will be pushed to the context.
-/// Any primitive type that can be cast will be casted to a field and pushed to the context.
-fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
-    let current_return_type = func.return_type().typ;
-    let last_statement = func.def.body.0.last()?;
-
-    // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
-    // Doesn't need done until we have settled on a kernel size
-    // TODO: support tuples here and in inputs -> convert into an issue
-    // Check if the return type is an expression, if it is, we can handle it
-    match last_statement {
-        Statement { kind: StatementKind::Expression(expression), .. } => {
-            match current_return_type {
-                // Call serialize on structs, push the whole array, calling push_array
-                UnresolvedTypeData::Named(..) => Some(make_struct_return_type(expression.clone())),
-                UnresolvedTypeData::Array(..) => Some(make_array_return_type(expression.clone())),
-                // Cast these types to a field before pushing
-                UnresolvedTypeData::Bool | UnresolvedTypeData::Integer(..) => {
-                    Some(make_castable_return_type(expression.clone()))
-                }
-                UnresolvedTypeData::FieldElement => Some(make_return_push(expression.clone())),
-                _ => None,
-            }
-        }
-        _ => None,
-    }
-}
-
-/// Abstract storage
-///
-/// For private functions:
-/// ```noir
-/// #[aztec(private)]
-/// fn lol() {
-///     let storage = Storage::init(Context::private(context));
-/// }
-/// ```
-///
-/// For public functions:
-/// ```noir
-/// #[aztec(public)]
-/// fn lol() {
-///    let storage = Storage::init(Context::public(context));
-/// }
-/// ```
-///
-/// For unconstrained functions:
-/// ```noir
-/// unconstrained fn lol() {
-///   let storage = Storage::init(Context::none());
-/// }
-fn abstract_storage(typ: &str, unconstrained: bool) -> Statement {
-    let init_context_call = if unconstrained {
-        call(
-            variable_path(chained_dep!("aztec", "context", "Context", "none")), // Path
-            vec![],                                                             // args
+    collected_trait_impls: &[UnresolvedTraitImpl],
+    collected_functions: &mut [UnresolvedFunctions],
+) -> Result<(), (MacroError, FileId)> {
+    if has_aztec_dependency(crate_id, context) {
+        inject_compute_note_hash_and_nullifier(
+            crate_id,
+            context,
+            collected_trait_impls,
+            collected_functions,
         )
     } else {
-        call(
-            variable_path(chained_dep!("aztec", "context", "Context", typ)), // Path
-            vec![mutable_reference("context")],                              // args
-        )
-    };
-
-    assignment(
-        "storage", // Assigned to
-        call(
-            variable_path(chained_path!("Storage", "init")), // Path
-            vec![init_context_call],                         // args
-        ),
-    )
-}
-
-/// Context Return Values
-///
-/// Creates an instance to the context return values
-/// ```noir
-/// `context.return_values`
-/// ```
-fn context_return_values() -> Expression {
-    member_access("context", "return_values")
-}
-
-fn make_statement(kind: StatementKind) -> Statement {
-    Statement { span: Span::default(), kind }
-}
-
-/// Make return Push
-///
-/// Translates to:
-/// `context.return_values.push({push_value})`
-fn make_return_push(push_value: Expression) -> Statement {
-    make_statement(StatementKind::Semi(method_call(
-        context_return_values(),
-        "push",
-        vec![push_value],
-    )))
-}
-
-/// Make Return push array
-///
-/// Translates to:
-/// `context.return_values.extend_from_array({push_value})`
-fn make_return_extend_from_array(push_value: Expression) -> Statement {
-    make_statement(StatementKind::Semi(method_call(
-        context_return_values(),
-        "extend_from_array",
-        vec![push_value],
-    )))
-}
-
-/// Make struct return type
-///
-/// Translates to:
-/// ```noir
-/// `context.return_values.extend_from_array({push_value}.serialize())`
-fn make_struct_return_type(expression: Expression) -> Statement {
-    let serialized_call = method_call(
-        expression,  // variable
-        "serialize", // method name
-        vec![],      // args
-    );
-    make_return_extend_from_array(serialized_call)
-}
-
-/// Make array return type
-///
-/// Translates to:
-/// ```noir
-/// for i in 0..{ident}.len() {
-///    context.return_values.push({ident}[i] as Field)
-/// }
-/// ```
-fn make_array_return_type(expression: Expression) -> Statement {
-    let inner_cast_expression =
-        cast(index_array_variable(expression.clone(), "i"), UnresolvedTypeData::FieldElement);
-    let assignment = make_statement(StatementKind::Semi(method_call(
-        context_return_values(), // variable
-        "push",                  // method name
-        vec![inner_cast_expression],
-    )));
-
-    create_loop_over(expression, vec![assignment])
-}
-
-/// Castable return type
-///
-/// Translates to:
-/// ```noir
-/// context.return_values.push({ident} as Field)
-/// ```
-fn make_castable_return_type(expression: Expression) -> Statement {
-    // Cast these types to a field before pushing
-    let cast_expression = cast(expression, UnresolvedTypeData::FieldElement);
-    make_return_push(cast_expression)
-}
-
-/// Create Return Type
-///
-/// Public functions return protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs while
-/// private functions return protocol_types::abis::private_circuit_public_inputs::::PrivateCircuitPublicInputs
-///
-/// This call constructs an ast token referencing the above types
-/// The name is set in the function above `transform`, hence the
-/// whole token name is passed in
-///
-/// The replaced code:
-/// ```noir
-///
-/// /// Before
-/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
-///    // ...
-/// }
-///
-/// /// After
-/// #[aztec(private)]
-/// fn foo() {
-///  // ...
-/// }
-fn create_return_type(ty: &str) -> FunctionReturnType {
-    let path_snippet = ty.to_case(Case::Snake); // e.g. private_circuit_public_inputs or public_circuit_public_inputs
-    let return_path = chained_dep!("aztec", "protocol_types", "abis", &path_snippet, ty);
-    return_type(return_path)
-}
-
-/// Create Context Finish
-///
-/// Each aztec function calls `context.finish()` at the end of a function
-/// to return values required by the kernel.
-///
-/// The replaced code:
-/// ```noir
-/// /// Before
-/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
-///   // ...
-///  context.finish()
-/// }
-///
-/// /// After
-/// #[aztec(private)]
-/// fn foo() {
-///  // ...
-/// }
-fn create_context_finish() -> Statement {
-    let method_call = method_call(
-        variable("context"), // variable
-        "finish",            // method name
-        vec![],              // args
-    );
-    make_statement(StatementKind::Expression(method_call))
+        Ok(())
+    }
 }
 
 //
-//                 Methods to create hasher inputs
+//                    Transform Hir Nodes for Aztec
 //
 
-fn add_struct_to_hasher(identifier: &Ident) -> Statement {
-    // If this is a struct, we call serialize and add the array to the hasher
-    let serialized_call = method_call(
-        variable_path(path(identifier.clone())), // variable
-        "serialize",                             // method name
-        vec![],                                  // args
-    );
-
-    make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),    // variable
-        "add_multiple",        // method name
-        vec![serialized_call], // args
-    )))
-}
-
-fn str_to_bytes(identifier: &Ident) -> (Statement, Ident) {
-    // let identifier_as_bytes = identifier.as_bytes();
-    let var = variable_ident(identifier.clone());
-    let contents = if let ExpressionKind::Variable(p) = &var.kind {
-        p.segments.first().cloned().unwrap_or_else(|| panic!("No segments")).0.contents
-    } else {
-        panic!("Unexpected identifier type")
-    };
-    let bytes_name = format!("{}_bytes", contents);
-    let var_bytes = assignment(&bytes_name, method_call(var, "as_bytes", vec![]));
-    let id = Ident::new(bytes_name, Span::default());
-
-    (var_bytes, id)
-}
-
-fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
-    // casted to a field
-    let span = var.span;
-
-    // `array.len()`
-    let end_range_expression = method_call(
-        var,    // variable
-        "len",  // method name
-        vec![], // args
-    );
-
-    // What will be looped over
-    // - `hasher.add({ident}[i] as Field)`
-    let for_loop_block = expression(ExpressionKind::Block(BlockExpression(loop_body)));
-
-    // `for i in 0..{ident}.len()`
-    make_statement(StatementKind::For(ForLoopStatement {
-        range: ForRange::Range(
-            expression(ExpressionKind::Literal(Literal::Integer(
-                FieldElement::from(i128::from(0)),
-                false,
-            ))),
-            end_range_expression,
-        ),
-        identifier: ident("i"),
-        block: for_loop_block,
-        span,
-    }))
-}
-
-fn add_array_to_hasher(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
-    // casted to a field
-
-    // Wrap in the semi thing - does that mean ended with semi colon?
-    // `hasher.add({ident}[i] as Field)`
-
-    let arr_index = index_array(identifier.clone(), "i");
-    let (add_expression, hasher_method_name) = match arr_type.typ {
-        UnresolvedTypeData::Named(..) => {
-            let hasher_method_name = "add_multiple".to_owned();
-            let call = method_call(
-                // All serialize on each element
-                arr_index,   // variable
-                "serialize", // method name
-                vec![],      // args
-            );
-            (call, hasher_method_name)
-        }
-        _ => {
-            let hasher_method_name = "add".to_owned();
-            let call = cast(
-                arr_index,                        // lhs - `ident[i]`
-                UnresolvedTypeData::FieldElement, // cast to - `as Field`
-            );
-            (call, hasher_method_name)
-        }
-    };
-
-    let block_statement = make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),  // variable
-        &hasher_method_name, // method name
-        vec![add_expression],
-    )));
-
-    create_loop_over(variable_ident(identifier.clone()), vec![block_statement])
-}
-
-fn add_field_to_hasher(identifier: &Ident) -> Statement {
-    // `hasher.add({ident})`
-    let ident = variable_path(path(identifier.clone()));
-    make_statement(StatementKind::Semi(method_call(
-        variable("hasher"), // variable
-        "add",              // method name
-        vec![ident],        // args
-    )))
-}
-
-fn add_cast_to_hasher(identifier: &Ident) -> Statement {
-    // `hasher.add({ident} as Field)`
-    // `{ident} as Field`
-    let cast_operation = cast(
-        variable_path(path(identifier.clone())), // lhs
-        UnresolvedTypeData::FieldElement,        // rhs
-    );
-
-    // `hasher.add({ident} as Field)`
-    make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),   // variable
-        "add",                // method name
-        vec![cast_operation], // args
-    )))
-}
-
-/// Computes the aztec signature for a resolved type.
-fn signature_of_type(typ: &Type) -> String {
-    match typ {
-        Type::Integer(Signedness::Signed, bit_size) => format!("i{}", bit_size),
-        Type::Integer(Signedness::Unsigned, bit_size) => format!("u{}", bit_size),
-        Type::FieldElement => "Field".to_owned(),
-        Type::Bool => "bool".to_owned(),
-        Type::Array(len, typ) => {
-            if let Type::Constant(len) = **len {
-                format!("[{};{len}]", signature_of_type(typ))
-            } else {
-                unimplemented!("Cannot generate signature for array with length type {:?}", typ)
-            }
-        }
-        Type::Struct(def, args) => {
-            let fields = def.borrow().get_fields(args);
-            let fields = vecmap(fields, |(_, typ)| signature_of_type(&typ));
-            format!("({})", fields.join(","))
-        }
-        Type::Tuple(types) => {
-            let fields = vecmap(types, signature_of_type);
-            format!("({})", fields.join(","))
-        }
-        _ => unimplemented!("Cannot generate signature for type {:?}", typ),
-    }
-}
-
-/// Computes the signature for a resolved event type.
-/// It has the form 'EventName(Field,(Field),[u8;2])'
-fn event_signature(event: &StructType) -> String {
-    let fields = vecmap(event.get_fields(&[]), |(_, typ)| signature_of_type(&typ));
-    format!("{}({})", event.name.0.contents, fields.join(","))
-}
-
-fn inject_compute_note_hash_and_nullifier(
+/// Completes the Hir with data gathered from type resolution
+fn transform_hir(
     crate_id: &CrateId,
     context: &mut HirContext,
-    unresolved_traits_impls: &[UnresolvedTraitImpl],
-    collected_functions: &mut [UnresolvedFunctions],
-) -> Result<(), (MacroError, FileId)> {
-    // We first fetch modules in this crate which correspond to contracts, along with their file id.
-    let contract_module_file_ids: Vec<(LocalModuleId, FileId)> = context
-        .def_map(crate_id)
-        .expect("ICE: Missing crate in def_map")
-        .modules()
-        .iter()
-        .filter(|(_, module)| module.is_contract)
-        .map(|(idx, module)| (LocalModuleId(idx), module.location.file))
-        .collect();
-
-    // If the current crate does not contain a contract module we simply skip it.
-    if contract_module_file_ids.is_empty() {
-        return Ok(());
-    } else if contract_module_file_ids.len() != 1 {
-        panic!("Found multiple contracts in the same crate");
-    }
-
-    let (module_id, file_id) = contract_module_file_ids[0];
-
-    // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
-    // escape hatch for this mechanism.
-    // TODO(#4647): improve this diagnosis and error messaging.
-    if collected_functions.iter().any(|coll_funcs_data| {
-        check_for_compute_note_hash_and_nullifier_definition(&coll_funcs_data.functions, module_id)
-    }) {
-        return Ok(());
-    }
-
-    // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
-    // contract might use. These are the types that implement the NoteInterface trait, which provides the
-    // get_note_type_id function.
-    let note_types = fetch_struct_trait_impls(context, unresolved_traits_impls, "NoteInterface");
-
-    // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
-    let func = generate_compute_note_hash_and_nullifier(&note_types);
-
-    // And inject the newly created function into the contract.
-
-    // TODO(#4373): We don't have a reasonable location for the source code of this autogenerated function, so we simply
-    // pass an empty span. This function should not produce errors anyway so this should not matter.
-    let location = Location::new(Span::empty(0), file_id);
-
-    // These are the same things the ModCollector does when collecting functions: we push the function to the
-    // NodeInterner, declare it in the module (which checks for duplicate definitions), and finally add it to the list
-    // on collected but unresolved functions.
-
-    let func_id = context.def_interner.push_empty_fn();
-    context.def_interner.push_function(
-        func_id,
-        &func.def,
-        ModuleId { krate: *crate_id, local_id: module_id },
-        location,
-    );
-
-    context.def_map_mut(crate_id).unwrap()
-        .modules_mut()[module_id.0]
-        .declare_function(
-            func.name_ident().clone(), func_id
-        ).expect(
-            "Failed to declare the autogenerated compute_note_hash_and_nullifier function, likely due to a duplicate definition. See https://github.com/AztecProtocol/aztec-packages/issues/4647."
-        );
-
-    collected_functions
-        .iter_mut()
-        .find(|fns| fns.file_id == file_id)
-        .expect("ICE: no functions found in contract file")
-        .push_fn(module_id, func_id, func.clone());
-
-    Ok(())
-}
-
-// Fetches the name of all structs that implement trait_name, both in the current crate and all of its dependencies.
-fn fetch_struct_trait_impls(
-    context: &mut HirContext,
-    unresolved_traits_impls: &[UnresolvedTraitImpl],
-    trait_name: &str,
-) -> Vec<String> {
-    let mut struct_typenames: Vec<String> = Vec::new();
-
-    // These structs can be declared in either external crates or the current one. External crates that contain
-    // dependencies have already been processed and resolved, but are available here via the NodeInterner. Note that
-    // crates on which the current crate does not depend on may not have been processed, and will be ignored.
-    for trait_impl_id in 0..context.def_interner.next_trait_impl_id().0 {
-        let trait_impl = &context.def_interner.get_trait_implementation(TraitImplId(trait_impl_id));
-
-        if trait_impl.borrow().ident.0.contents == *trait_name {
-            if let Type::Struct(s, _) = &trait_impl.borrow().typ {
-                struct_typenames.push(s.borrow().name.0.contents.clone());
-            } else {
-                panic!("Found impl for {} on non-Struct", trait_name);
-            }
-        }
-    }
-
-    // This crate's traits and impls have not yet been resolved, so we look for impls in unresolved_trait_impls.
-    struct_typenames.extend(
-        unresolved_traits_impls
-            .iter()
-            .filter(|trait_impl| {
-                trait_impl
-                    .trait_path
-                    .segments
-                    .last()
-                    .expect("ICE: empty trait_impl path")
-                    .0
-                    .contents
-                    == *trait_name
-            })
-            .filter_map(|trait_impl| match &trait_impl.object_type.typ {
-                UnresolvedTypeData::Named(path, _, _) => {
-                    Some(path.segments.last().unwrap().0.contents.clone())
-                }
-                _ => None,
-            }),
-    );
-
-    struct_typenames
-}
-
-fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFunction {
-    let function_source = generate_compute_note_hash_and_nullifier_source(note_types);
-
-    let (function_ast, errors) = parse_program(&function_source);
-    if !errors.is_empty() {
-        dbg!(errors.clone());
-    }
-    assert_eq!(errors.len(), 0, "Failed to parse Noir macro code. This is either a bug in the compiler or the Noir macro code");
-
-    let mut function_ast = function_ast.into_sorted();
-    function_ast.functions.remove(0)
-}
-
-fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) -> String {
-    // TODO(#4649): The serialized_note parameter is a fixed-size array, but we don't know what length it should have.
-    // For now we hardcode it to 20, which is the same as MAX_NOTE_FIELDS_LENGTH.
-
-    if note_types.is_empty() {
-        // TODO(#4520): Even if the contract does not include any notes, other parts of the stack expect for this
-        // function to exist, so we include a dummy version. We likely should error out here instead.
-        "
-        unconstrained fn compute_note_hash_and_nullifier(
-            contract_address: AztecAddress,
-            nonce: Field,
-            storage_slot: Field,
-            note_type_id: Field,
-            serialized_note: [Field; 20]
-        ) -> pub [Field; 4] {
-            [0, 0, 0, 0]
-        }"
-        .to_string()
-    } else {
-        // For contracts that include notes we do a simple if-else chain comparing note_type_id with the different
-        // get_note_type_id of each of the note types.
-
-        let if_statements: Vec<String> = note_types.iter().map(|note_type| format!(
-            "if (note_type_id == {0}::get_note_type_id()) {{
-                dep::aztec::note::utils::compute_note_hash_and_nullifier({0}::deserialize_content, note_header, serialized_note)
-            }}"
-        , note_type)).collect();
-
-        // TODO(#4520): error out on the else instead of returning a zero array
-        let full_if_statement = if_statements.join(" else ")
-            + "
-            else {
-                [0, 0, 0, 0]
-            }";
-
-        format!(
-            "
-            unconstrained fn compute_note_hash_and_nullifier(
-                contract_address: AztecAddress,
-                nonce: Field,
-                storage_slot: Field,
-                note_type_id: Field,
-                serialized_note: [Field; 20]
-            ) -> pub [Field; 4] {{
-                let note_header = dep::aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
-
-                {}
-            }}",
-            full_if_statement
-        )
-    }
+) -> Result<(), (AztecMacroError, FileId)> {
+    transform_events(crate_id, context)?;
+    assign_storage_slots(crate_id, context)
 }
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
new file mode 100644
index 00000000000..4f8f3f19ab8
--- /dev/null
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -0,0 +1,195 @@
+use noirc_errors::{Location, Span};
+use noirc_frontend::{
+    graph::CrateId,
+    hir::{
+        def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
+        def_map::{LocalModuleId, ModuleId},
+    },
+    macros_api::{FileId, HirContext, MacroError},
+    node_interner::FuncId,
+    parse_program, FunctionReturnType, NoirFunction, UnresolvedTypeData,
+};
+
+use crate::utils::hir_utils::fetch_struct_trait_impls;
+
+// Check if "compute_note_hash_and_nullifier(AztecAddress,Field,Field,Field,[Field; N]) -> [Field; 4]" is defined
+fn check_for_compute_note_hash_and_nullifier_definition(
+    functions_data: &[(LocalModuleId, FuncId, NoirFunction)],
+    module_id: LocalModuleId,
+) -> bool {
+    functions_data.iter().filter(|func_data| func_data.0 == module_id).any(|func_data| {
+        func_data.2.def.name.0.contents == "compute_note_hash_and_nullifier"
+                && func_data.2.def.parameters.len() == 5
+                && match &func_data.2.def.parameters[0].typ.typ {
+                    UnresolvedTypeData::Named(path, _, _) => path.segments.last().unwrap().0.contents == "AztecAddress",
+                    _ => false,
+                }
+                && func_data.2.def.parameters[1].typ.typ == UnresolvedTypeData::FieldElement
+                && func_data.2.def.parameters[2].typ.typ == UnresolvedTypeData::FieldElement
+                && func_data.2.def.parameters[3].typ.typ == UnresolvedTypeData::FieldElement
+                // checks if the 5th parameter is an array and the Box<UnresolvedType> in
+                // Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>) contains only fields
+                && match &func_data.2.def.parameters[4].typ.typ {
+                    UnresolvedTypeData::Array(_, inner_type) => {
+                        matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
+                    },
+                    _ => false,
+                }
+                // We check the return type the same way as we did the 5th parameter
+                && match &func_data.2.def.return_type {
+                    FunctionReturnType::Default(_) => false,
+                    FunctionReturnType::Ty(unresolved_type) => {
+                        match &unresolved_type.typ {
+                            UnresolvedTypeData::Array(_, inner_type) => {
+                                matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
+                            },
+                            _ => false,
+                        }
+                    }
+                }
+    })
+}
+
+pub fn inject_compute_note_hash_and_nullifier(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+    unresolved_traits_impls: &[UnresolvedTraitImpl],
+    collected_functions: &mut [UnresolvedFunctions],
+) -> Result<(), (MacroError, FileId)> {
+    // We first fetch modules in this crate which correspond to contracts, along with their file id.
+    let contract_module_file_ids: Vec<(LocalModuleId, FileId)> = context
+        .def_map(crate_id)
+        .expect("ICE: Missing crate in def_map")
+        .modules()
+        .iter()
+        .filter(|(_, module)| module.is_contract)
+        .map(|(idx, module)| (LocalModuleId(idx), module.location.file))
+        .collect();
+
+    // If the current crate does not contain a contract module we simply skip it.
+    if contract_module_file_ids.is_empty() {
+        return Ok(());
+    } else if contract_module_file_ids.len() != 1 {
+        panic!("Found multiple contracts in the same crate");
+    }
+
+    let (module_id, file_id) = contract_module_file_ids[0];
+
+    // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
+    // escape hatch for this mechanism.
+    // TODO(#4647): improve this diagnosis and error messaging.
+    if collected_functions.iter().any(|coll_funcs_data| {
+        check_for_compute_note_hash_and_nullifier_definition(&coll_funcs_data.functions, module_id)
+    }) {
+        return Ok(());
+    }
+
+    // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
+    // contract might use. These are the types that implement the NoteInterface trait, which provides the
+    // get_note_type_id function.
+    let note_types = fetch_struct_trait_impls(context, unresolved_traits_impls, "NoteInterface");
+
+    // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
+    let func = generate_compute_note_hash_and_nullifier(&note_types);
+
+    // And inject the newly created function into the contract.
+
+    // TODO(#4373): We don't have a reasonable location for the source code of this autogenerated function, so we simply
+    // pass an empty span. This function should not produce errors anyway so this should not matter.
+    let location = Location::new(Span::empty(0), file_id);
+
+    // These are the same things the ModCollector does when collecting functions: we push the function to the
+    // NodeInterner, declare it in the module (which checks for duplicate definitions), and finally add it to the list
+    // on collected but unresolved functions.
+
+    let func_id = context.def_interner.push_empty_fn();
+    context.def_interner.push_function(
+        func_id,
+        &func.def,
+        ModuleId { krate: *crate_id, local_id: module_id },
+        location,
+    );
+
+    context.def_map_mut(crate_id).unwrap()
+        .modules_mut()[module_id.0]
+        .declare_function(
+            func.name_ident().clone(), func_id
+        ).expect(
+            "Failed to declare the autogenerated compute_note_hash_and_nullifier function, likely due to a duplicate definition. See https://github.com/AztecProtocol/aztec-packages/issues/4647."
+        );
+
+    collected_functions
+        .iter_mut()
+        .find(|fns| fns.file_id == file_id)
+        .expect("ICE: no functions found in contract file")
+        .push_fn(module_id, func_id, func.clone());
+
+    Ok(())
+}
+
+fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFunction {
+    let function_source = generate_compute_note_hash_and_nullifier_source(note_types);
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors.clone());
+    }
+    assert_eq!(errors.len(), 0, "Failed to parse Noir macro code. This is either a bug in the compiler or the Noir macro code");
+
+    let mut function_ast = function_ast.into_sorted();
+    function_ast.functions.remove(0)
+}
+
+fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) -> String {
+    // TODO(#4649): The serialized_note parameter is a fixed-size array, but we don't know what length it should have.
+    // For now we hardcode it to 20, which is the same as MAX_NOTE_FIELDS_LENGTH.
+
+    if note_types.is_empty() {
+        // Even if the contract does not include any notes, other parts of the stack expect for this function to exist,
+        // so we include a dummy version.
+        "
+        unconstrained fn compute_note_hash_and_nullifier(
+            contract_address: AztecAddress,
+            nonce: Field,
+            storage_slot: Field,
+            note_type_id: Field,
+            serialized_note: [Field; 20]
+        ) -> pub [Field; 4] {
+            assert(false, \"This contract does not use private notes\");
+            [0, 0, 0, 0]
+        }"
+        .to_string()
+    } else {
+        // For contracts that include notes we do a simple if-else chain comparing note_type_id with the different
+        // get_note_type_id of each of the note types.
+
+        let if_statements: Vec<String> = note_types.iter().map(|note_type| format!(
+            "if (note_type_id == {0}::get_note_type_id()) {{
+                dep::aztec::note::utils::compute_note_hash_and_nullifier({0}::deserialize_content, note_header, serialized_note)
+            }}"
+        , note_type)).collect();
+
+        let full_if_statement = if_statements.join(" else ")
+            + "
+            else {
+                assert(false, \"Unknown note type ID\");
+                [0, 0, 0, 0]
+            }";
+
+        format!(
+            "
+            unconstrained fn compute_note_hash_and_nullifier(
+                contract_address: AztecAddress,
+                nonce: Field,
+                storage_slot: Field,
+                note_type_id: Field,
+                serialized_note: [Field; 20]
+            ) -> pub [Field; 4] {{
+                let note_header = dep::aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
+
+                {}
+            }}",
+            full_if_statement
+        )
+    }
+}
diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
new file mode 100644
index 00000000000..b02709efacb
--- /dev/null
+++ b/aztec_macros/src/transforms/events.rs
@@ -0,0 +1,178 @@
+use iter_extended::vecmap;
+use noirc_errors::Span;
+use noirc_frontend::{
+    graph::CrateId,
+    macros_api::{
+        BlockExpression, FileId, HirContext, HirExpression, HirLiteral, HirStatement, NodeInterner,
+        NoirStruct, PathKind, StatementKind, StructId, StructType, Type, TypeImpl,
+        UnresolvedTypeData,
+    },
+    token::SecondaryAttribute,
+    ExpressionKind, FunctionDefinition, FunctionReturnType, ItemVisibility, Literal, NoirFunction,
+    Visibility,
+};
+
+use crate::{
+    chained_dep,
+    utils::{
+        ast_utils::{
+            call, expression, ident, ident_path, make_statement, make_type, path, variable_path,
+        },
+        constants::SIGNATURE_PLACEHOLDER,
+        errors::AztecMacroError,
+        hir_utils::{collect_crate_structs, signature_of_type},
+    },
+};
+
+/// Generates the impl for an event selector
+///
+/// Inserts the following code:
+/// ```noir
+/// impl SomeStruct {
+///    fn selector() -> FunctionSelector {
+///       aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature("SIGNATURE_PLACEHOLDER")
+///    }
+/// }
+/// ```
+///
+/// This allows developers to emit events without having to write the signature of the event every time they emit it.
+/// The signature cannot be known at this point since types are not resolved yet, so we use a signature placeholder.
+/// It'll get resolved after by transforming the HIR.
+pub fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
+    let struct_type =
+        make_type(UnresolvedTypeData::Named(path(structure.name.clone()), vec![], true));
+
+    let selector_path =
+        chained_dep!("aztec", "protocol_types", "abis", "function_selector", "FunctionSelector");
+    let mut from_signature_path = selector_path.clone();
+    from_signature_path.segments.push(ident("from_signature"));
+
+    let selector_fun_body = BlockExpression(vec![make_statement(StatementKind::Expression(call(
+        variable_path(from_signature_path),
+        vec![expression(ExpressionKind::Literal(Literal::Str(SIGNATURE_PLACEHOLDER.to_string())))],
+    )))]);
+
+    // Define `FunctionSelector` return type
+    let return_type =
+        FunctionReturnType::Ty(make_type(UnresolvedTypeData::Named(selector_path, vec![], true)));
+
+    let mut selector_fn_def = FunctionDefinition::normal(
+        &ident("selector"),
+        &vec![],
+        &[],
+        &selector_fun_body,
+        &[],
+        &return_type,
+    );
+
+    selector_fn_def.visibility = ItemVisibility::Public;
+
+    // Seems to be necessary on contract modules
+    selector_fn_def.return_visibility = Visibility::Public;
+
+    TypeImpl {
+        object_type: struct_type,
+        type_span: structure.span,
+        generics: vec![],
+        methods: vec![(NoirFunction::normal(selector_fn_def), Span::default())],
+    }
+}
+
+/// Computes the signature for a resolved event type.
+/// It has the form 'EventName(Field,(Field),[u8;2])'
+fn event_signature(event: &StructType) -> String {
+    let fields = vecmap(event.get_fields(&[]), |(_, typ)| signature_of_type(&typ));
+    format!("{}({})", event.name.0.contents, fields.join(","))
+}
+
+/// Substitutes the signature literal that was introduced in the selector method previously with the actual signature.
+fn transform_event(
+    struct_id: StructId,
+    interner: &mut NodeInterner,
+) -> Result<(), (AztecMacroError, FileId)> {
+    let struct_type = interner.get_struct(struct_id);
+    let selector_id = interner
+        .lookup_method(&Type::Struct(struct_type.clone(), vec![]), struct_id, "selector", false)
+        .ok_or_else(|| {
+            let error = AztecMacroError::EventError {
+                span: struct_type.borrow().location.span,
+                message: "Selector method not found".to_owned(),
+            };
+            (error, struct_type.borrow().location.file)
+        })?;
+    let selector_function = interner.function(&selector_id);
+
+    let compute_selector_statement = interner.statement(
+        selector_function.block(interner).statements().first().ok_or_else(|| {
+            let error = AztecMacroError::EventError {
+                span: struct_type.borrow().location.span,
+                message: "Compute selector statement not found".to_owned(),
+            };
+            (error, struct_type.borrow().location.file)
+        })?,
+    );
+
+    let compute_selector_expression = match compute_selector_statement {
+        HirStatement::Expression(expression_id) => match interner.expression(&expression_id) {
+            HirExpression::Call(hir_call_expression) => Some(hir_call_expression),
+            _ => None,
+        },
+        _ => None,
+    }
+    .ok_or_else(|| {
+        let error = AztecMacroError::EventError {
+            span: struct_type.borrow().location.span,
+            message: "Compute selector statement is not a call expression".to_owned(),
+        };
+        (error, struct_type.borrow().location.file)
+    })?;
+
+    let first_arg_id = compute_selector_expression.arguments.first().ok_or_else(|| {
+        let error = AztecMacroError::EventError {
+            span: struct_type.borrow().location.span,
+            message: "Compute selector statement is not a call expression".to_owned(),
+        };
+        (error, struct_type.borrow().location.file)
+    })?;
+
+    match interner.expression(first_arg_id) {
+        HirExpression::Literal(HirLiteral::Str(signature))
+            if signature == SIGNATURE_PLACEHOLDER =>
+        {
+            let selector_literal_id = *first_arg_id;
+
+            let structure = interner.get_struct(struct_id);
+            let signature = event_signature(&structure.borrow());
+            interner.update_expression(selector_literal_id, |expr| {
+                *expr = HirExpression::Literal(HirLiteral::Str(signature.clone()));
+            });
+
+            // Also update the type! It might have a different length now than the placeholder.
+            interner.push_expr_type(
+                selector_literal_id,
+                Type::String(Box::new(Type::Constant(signature.len() as u64))),
+            );
+            Ok(())
+        }
+        _ => Err((
+            AztecMacroError::EventError {
+                span: struct_type.borrow().location.span,
+                message: "Signature placeholder literal does not match".to_owned(),
+            },
+            struct_type.borrow().location.file,
+        )),
+    }
+}
+
+pub fn transform_events(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+) -> Result<(), (AztecMacroError, FileId)> {
+    for struct_id in collect_crate_structs(crate_id, context) {
+        let attributes = context.def_interner.struct_attributes(&struct_id);
+        if attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Event)) {
+            transform_event(struct_id, &mut context.def_interner)?;
+        }
+    }
+    Ok(())
+}
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
new file mode 100644
index 00000000000..8b3c7d2f53b
--- /dev/null
+++ b/aztec_macros/src/transforms/functions.rs
@@ -0,0 +1,707 @@
+use convert_case::{Case, Casing};
+use noirc_errors::Span;
+use noirc_frontend::{
+    macros_api::FieldElement, BlockExpression, ConstrainKind, ConstrainStatement, Distinctness,
+    Expression, ExpressionKind, ForLoopStatement, ForRange, FunctionReturnType, Ident, Literal,
+    NoirFunction, Param, PathKind, Pattern, Signedness, Statement, StatementKind, UnresolvedType,
+    UnresolvedTypeData, Visibility,
+};
+
+use crate::{
+    chained_dep, chained_path,
+    utils::{
+        ast_utils::{
+            assignment, call, cast, expression, ident, ident_path, index_array,
+            index_array_variable, make_eq, make_statement, make_type, member_access, method_call,
+            mutable_assignment, mutable_reference, path, return_type, variable, variable_ident,
+            variable_path,
+        },
+        errors::AztecMacroError,
+    },
+};
+
+// If it does, it will insert the following things:
+/// - A new Input that is provided for a kernel app circuit, named: {Public/Private}ContextInputs
+/// - Hashes all of the function input variables
+///     - This instantiates a helper function
+pub fn transform_function(
+    ty: &str,
+    func: &mut NoirFunction,
+    storage_defined: bool,
+    is_initializer: bool,
+    insert_init_check: bool,
+    is_internal: bool,
+) -> Result<(), AztecMacroError> {
+    let context_name = format!("{}Context", ty);
+    let inputs_name = format!("{}ContextInputs", ty);
+    let return_type_name = format!("{}CircuitPublicInputs", ty);
+
+    // Add check that msg sender equals this address and flag function as internal
+    if is_internal {
+        let is_internal_check = create_internal_check(func.name());
+        func.def.body.0.insert(0, is_internal_check);
+    }
+
+    // Add initialization check
+    if insert_init_check {
+        let init_check = create_init_check();
+        func.def.body.0.insert(0, init_check);
+    }
+
+    // Add access to the storage struct
+    if storage_defined {
+        let storage_def = abstract_storage(&ty.to_lowercase(), false);
+        func.def.body.0.insert(0, storage_def);
+    }
+
+    // Insert the context creation as the first action
+    let create_context = create_context(&context_name, &func.def.parameters)?;
+    func.def.body.0.splice(0..0, (create_context).iter().cloned());
+
+    // Add the inputs to the params
+    let input = create_inputs(&inputs_name);
+    func.def.parameters.insert(0, input);
+
+    // Abstract return types such that they get added to the kernel's return_values
+    if let Some(return_values) = abstract_return_values(func) {
+        // In case we are pushing return values to the context, we remove the statement that originated it
+        // This avoids running duplicate code, since blocks like if/else can be value returning statements
+        func.def.body.0.pop();
+        // Add the new return statement
+        func.def.body.0.push(return_values);
+    }
+
+    // Before returning mark the contract as initialized
+    if is_initializer {
+        let mark_initialized = create_mark_as_initialized();
+        func.def.body.0.push(mark_initialized);
+    }
+
+    // Push the finish method call to the end of the function
+    let finish_def = create_context_finish();
+    func.def.body.0.push(finish_def);
+
+    let return_type = create_return_type(&return_type_name);
+    func.def.return_type = return_type;
+    func.def.return_visibility = Visibility::Public;
+
+    // Distinct return types are only required for private functions
+    // Public functions should have unconstrained auto-inferred
+    match ty {
+        "Private" => func.def.return_distinctness = Distinctness::Distinct,
+        "Public" => func.def.is_unconstrained = true,
+        _ => (),
+    }
+
+    Ok(())
+}
+
+/// Transform a function to work with AVM bytecode
+pub fn transform_vm_function(
+    func: &mut NoirFunction,
+    storage_defined: bool,
+) -> Result<(), AztecMacroError> {
+    // Create access to storage
+    if storage_defined {
+        let storage = abstract_storage("public_vm", true);
+        func.def.body.0.insert(0, storage);
+    }
+
+    // Push Avm context creation to the beginning of the function
+    let create_context = create_avm_context()?;
+    func.def.body.0.insert(0, create_context);
+
+    // We want the function to be seen as a public function
+    func.def.is_unconstrained = true;
+
+    // NOTE: the line below is a temporary hack to trigger external transpilation tools
+    // It will be removed once the transpiler is integrated into the Noir compiler
+    func.def.name.0.contents = format!("avm_{}", func.def.name.0.contents);
+    Ok(())
+}
+
+/// Transform Unconstrained
+///
+/// Inserts the following code at the beginning of an unconstrained function
+/// ```noir
+/// let storage = Storage::init(Context::none());
+/// ```
+///
+/// This will allow developers to access their contract' storage struct in unconstrained functions
+pub fn transform_unconstrained(func: &mut NoirFunction) {
+    func.def.body.0.insert(0, abstract_storage("Unconstrained", true));
+}
+
+/// Helper function that returns what the private context would look like in the ast
+/// This should make it available to be consumed within aztec private annotated functions.
+///
+/// The replaced code:
+/// ```noir
+/// /// Before
+/// fn foo(inputs: PrivateContextInputs) {
+///    // ...
+/// }
+///
+/// /// After
+/// #[aztec(private)]
+/// fn foo() {
+///   // ...
+/// }
+fn create_inputs(ty: &str) -> Param {
+    let context_ident = ident("inputs");
+    let context_pattern = Pattern::Identifier(context_ident);
+
+    let path_snippet = ty.to_case(Case::Snake); // e.g. private_context_inputs
+    let type_path = chained_dep!("aztec", "context", "inputs", &path_snippet, ty);
+
+    let context_type = make_type(UnresolvedTypeData::Named(type_path, vec![], true));
+    let visibility = Visibility::Private;
+
+    Param { pattern: context_pattern, typ: context_type, visibility, span: Span::default() }
+}
+
+/// Creates an initialization check to ensure that the contract has been initialized, meant to
+/// be injected as the first statement of any function after the context has been created.
+///
+/// ```noir
+/// assert_is_initialized(&mut context);
+/// ```
+fn create_init_check() -> Statement {
+    make_statement(StatementKind::Expression(call(
+        variable_path(chained_dep!("aztec", "initializer", "assert_is_initialized")),
+        vec![mutable_reference("context")],
+    )))
+}
+
+/// Creates a call to mark_as_initialized which emits the initialization nullifier, meant to
+/// be injected as the last statement before returning in a constructor.
+///
+/// ```noir
+/// mark_as_initialized(&mut context);
+/// ```
+fn create_mark_as_initialized() -> Statement {
+    make_statement(StatementKind::Expression(call(
+        variable_path(chained_dep!("aztec", "initializer", "mark_as_initialized")),
+        vec![mutable_reference("context")],
+    )))
+}
+
+/// Creates a check for internal functions ensuring that the caller is self.
+///
+/// ```noir
+/// assert(context.msg_sender() == context.this_address(), "Function can only be called internally");
+/// ```
+fn create_internal_check(fname: &str) -> Statement {
+    make_statement(StatementKind::Constrain(ConstrainStatement(
+        make_eq(
+            method_call(variable("context"), "msg_sender", vec![]),
+            method_call(variable("context"), "this_address", vec![]),
+        ),
+        Some(expression(ExpressionKind::Literal(Literal::Str(format!(
+            "Function {} can only be called internally",
+            fname
+        ))))),
+        ConstrainKind::Assert,
+    )))
+}
+
+/// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
+/// appended into the args hash object.
+///
+/// The replaced code:
+/// ```noir
+/// #[aztec(private)]
+/// fn foo(structInput: SomeStruct, arrayInput: [u8; 10], fieldInput: Field) -> Field {
+///     // Create the hasher object
+///     let mut hasher = Hasher::new();
+///
+///     // struct inputs call serialize on them to add an array of fields
+///     hasher.add_multiple(structInput.serialize());
+///
+///     // Array inputs are iterated over and each element is added to the hasher (as a field)
+///     for i in 0..arrayInput.len() {
+///         hasher.add(arrayInput[i] as Field);
+///     }
+///     // Field inputs are added to the hasher
+///     hasher.add({ident});
+///
+///     // Create the context
+///     // The inputs (injected by this `create_inputs`) and completed hash object are passed to the context
+///     let mut context = PrivateContext::new(inputs, hasher.hash());
+/// }
+/// ```
+fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
+    let mut injected_expressions: Vec<Statement> = vec![];
+
+    // `let mut hasher = Hasher::new();`
+    let let_hasher = mutable_assignment(
+        "hasher", // Assigned to
+        call(
+            variable_path(chained_dep!("aztec", "hasher", "Hasher", "new")), // Path
+            vec![],                                                          // args
+        ),
+    );
+
+    // Completes: `let mut hasher = Hasher::new();`
+    injected_expressions.push(let_hasher);
+
+    // Iterate over each of the function parameters, adding to them to the hasher
+    for Param { pattern, typ, span, .. } in params {
+        match pattern {
+            Pattern::Identifier(identifier) => {
+                // Match the type to determine the padding to do
+                let unresolved_type = &typ.typ;
+                let expression = match unresolved_type {
+                    // `hasher.add_multiple({ident}.serialize())`
+                    UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier),
+                    UnresolvedTypeData::Array(_, arr_type) => {
+                        add_array_to_hasher(identifier, arr_type)
+                    }
+                    // `hasher.add({ident})`
+                    UnresolvedTypeData::FieldElement => add_field_to_hasher(identifier),
+                    // Add the integer to the hasher, casted to a field
+                    // `hasher.add({ident} as Field)`
+                    UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
+                        add_cast_to_hasher(identifier)
+                    }
+                    UnresolvedTypeData::String(..) => {
+                        let (var_bytes, id) = str_to_bytes(identifier);
+                        injected_expressions.push(var_bytes);
+                        add_array_to_hasher(
+                            &id,
+                            &UnresolvedType {
+                                typ: UnresolvedTypeData::Integer(
+                                    Signedness::Unsigned,
+                                    noirc_frontend::IntegerBitSize::ThirtyTwo,
+                                ),
+                                span: None,
+                            },
+                        )
+                    }
+                    _ => {
+                        return Err(AztecMacroError::UnsupportedFunctionArgumentType {
+                            typ: unresolved_type.clone(),
+                            span: *span,
+                        })
+                    }
+                };
+                injected_expressions.push(expression);
+            }
+            _ => todo!(), // Maybe unreachable?
+        }
+    }
+
+    // Create the inputs to the context
+    let inputs_expression = variable("inputs");
+    // `hasher.hash()`
+    let hash_call = method_call(
+        variable("hasher"), // variable
+        "hash",             // method name
+        vec![],             // args
+    );
+
+    let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
+
+    // let mut context = {ty}::new(inputs, hash);
+    let let_context = mutable_assignment(
+        "context", // Assigned to
+        call(
+            variable_path(chained_dep!("aztec", "context", &path_snippet, ty, "new")), // Path
+            vec![inputs_expression, hash_call],                                        // args
+        ),
+    );
+    injected_expressions.push(let_context);
+
+    // Return all expressions that will be injected by the hasher
+    Ok(injected_expressions)
+}
+
+/// Creates an mutable avm context
+///
+/// ```noir
+/// /// Before
+/// #[aztec(public-vm)]
+/// fn foo() -> Field {
+///   let mut context = aztec::context::AVMContext::new();
+///   let timestamp = context.timestamp();
+///   // ...
+/// }
+///
+/// /// After
+/// #[aztec(private)]
+/// fn foo() -> Field {
+///     let mut timestamp = context.timestamp();
+///     // ...
+/// }
+fn create_avm_context() -> Result<Statement, AztecMacroError> {
+    let let_context = mutable_assignment(
+        "context", // Assigned to
+        call(
+            variable_path(chained_dep!("aztec", "context", "AVMContext", "new")), // Path
+            vec![],                                                               // args
+        ),
+    );
+
+    Ok(let_context)
+}
+
+/// Abstract Return Type
+///
+/// This function intercepts the function's current return type and replaces it with pushes
+/// To the kernel
+///
+/// The replaced code:
+/// ```noir
+/// /// Before
+/// #[aztec(private)]
+/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
+///   // ...
+///   let my_return_value: Field = 10;
+///   context.return_values.push(my_return_value);
+/// }
+///
+/// /// After
+/// #[aztec(private)]
+/// fn foo() -> Field {
+///     // ...
+///    let my_return_value: Field = 10;
+///    my_return_value
+/// }
+/// ```
+/// Similarly; Structs will be pushed to the context, after serialize() is called on them.
+/// Arrays will be iterated over and each element will be pushed to the context.
+/// Any primitive type that can be cast will be casted to a field and pushed to the context.
+fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
+    let current_return_type = func.return_type().typ;
+    let last_statement = func.def.body.0.last()?;
+
+    // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
+    // Doesn't need done until we have settled on a kernel size
+    // TODO: support tuples here and in inputs -> convert into an issue
+    // Check if the return type is an expression, if it is, we can handle it
+    match last_statement {
+        Statement { kind: StatementKind::Expression(expression), .. } => {
+            match current_return_type {
+                // Call serialize on structs, push the whole array, calling push_array
+                UnresolvedTypeData::Named(..) => Some(make_struct_return_type(expression.clone())),
+                UnresolvedTypeData::Array(..) => Some(make_array_return_type(expression.clone())),
+                // Cast these types to a field before pushing
+                UnresolvedTypeData::Bool | UnresolvedTypeData::Integer(..) => {
+                    Some(make_castable_return_type(expression.clone()))
+                }
+                UnresolvedTypeData::FieldElement => Some(make_return_push(expression.clone())),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Abstract storage
+///
+/// For private functions:
+/// ```noir
+/// #[aztec(private)]
+/// fn lol() {
+///     let storage = Storage::init(Context::private(context));
+/// }
+/// ```
+///
+/// For public functions:
+/// ```noir
+/// #[aztec(public)]
+/// fn lol() {
+///    let storage = Storage::init(Context::public(context));
+/// }
+/// ```
+///
+/// For unconstrained functions:
+/// ```noir
+/// unconstrained fn lol() {
+///   let storage = Storage::init(Context::none());
+/// }
+fn abstract_storage(typ: &str, unconstrained: bool) -> Statement {
+    let init_context_call = if unconstrained {
+        call(
+            variable_path(chained_dep!("aztec", "context", "Context", "none")), // Path
+            vec![],                                                             // args
+        )
+    } else {
+        call(
+            variable_path(chained_dep!("aztec", "context", "Context", typ)), // Path
+            vec![mutable_reference("context")],                              // args
+        )
+    };
+
+    assignment(
+        "storage", // Assigned to
+        call(
+            variable_path(chained_path!("Storage", "init")), // Path
+            vec![init_context_call],                         // args
+        ),
+    )
+}
+
+/// Context Return Values
+///
+/// Creates an instance to the context return values
+/// ```noir
+/// `context.return_values`
+/// ```
+fn context_return_values() -> Expression {
+    member_access("context", "return_values")
+}
+
+/// Make return Push
+///
+/// Translates to:
+/// `context.return_values.push({push_value})`
+fn make_return_push(push_value: Expression) -> Statement {
+    make_statement(StatementKind::Semi(method_call(
+        context_return_values(),
+        "push",
+        vec![push_value],
+    )))
+}
+
+/// Make Return push array
+///
+/// Translates to:
+/// `context.return_values.extend_from_array({push_value})`
+fn make_return_extend_from_array(push_value: Expression) -> Statement {
+    make_statement(StatementKind::Semi(method_call(
+        context_return_values(),
+        "extend_from_array",
+        vec![push_value],
+    )))
+}
+
+/// Make struct return type
+///
+/// Translates to:
+/// ```noir
+/// `context.return_values.extend_from_array({push_value}.serialize())`
+fn make_struct_return_type(expression: Expression) -> Statement {
+    let serialized_call = method_call(
+        expression,  // variable
+        "serialize", // method name
+        vec![],      // args
+    );
+    make_return_extend_from_array(serialized_call)
+}
+
+/// Make array return type
+///
+/// Translates to:
+/// ```noir
+/// for i in 0..{ident}.len() {
+///    context.return_values.push({ident}[i] as Field)
+/// }
+/// ```
+fn make_array_return_type(expression: Expression) -> Statement {
+    let inner_cast_expression =
+        cast(index_array_variable(expression.clone(), "i"), UnresolvedTypeData::FieldElement);
+    let assignment = make_statement(StatementKind::Semi(method_call(
+        context_return_values(), // variable
+        "push",                  // method name
+        vec![inner_cast_expression],
+    )));
+
+    create_loop_over(expression, vec![assignment])
+}
+
+/// Castable return type
+///
+/// Translates to:
+/// ```noir
+/// context.return_values.push({ident} as Field)
+/// ```
+fn make_castable_return_type(expression: Expression) -> Statement {
+    // Cast these types to a field before pushing
+    let cast_expression = cast(expression, UnresolvedTypeData::FieldElement);
+    make_return_push(cast_expression)
+}
+
+/// Create Return Type
+///
+/// Public functions return protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs while
+/// private functions return protocol_types::abis::private_circuit_public_inputs::::PrivateCircuitPublicInputs
+///
+/// This call constructs an ast token referencing the above types
+/// The name is set in the function above `transform`, hence the
+/// whole token name is passed in
+///
+/// The replaced code:
+/// ```noir
+///
+/// /// Before
+/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
+///    // ...
+/// }
+///
+/// /// After
+/// #[aztec(private)]
+/// fn foo() {
+///  // ...
+/// }
+fn create_return_type(ty: &str) -> FunctionReturnType {
+    let path_snippet = ty.to_case(Case::Snake); // e.g. private_circuit_public_inputs or public_circuit_public_inputs
+    let return_path = chained_dep!("aztec", "protocol_types", "abis", &path_snippet, ty);
+    return_type(return_path)
+}
+
+/// Create Context Finish
+///
+/// Each aztec function calls `context.finish()` at the end of a function
+/// to return values required by the kernel.
+///
+/// The replaced code:
+/// ```noir
+/// /// Before
+/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
+///   // ...
+///  context.finish()
+/// }
+///
+/// /// After
+/// #[aztec(private)]
+/// fn foo() {
+///  // ...
+/// }
+fn create_context_finish() -> Statement {
+    let method_call = method_call(
+        variable("context"), // variable
+        "finish",            // method name
+        vec![],              // args
+    );
+    make_statement(StatementKind::Expression(method_call))
+}
+
+//
+//                 Methods to create hasher inputs
+//
+
+fn add_struct_to_hasher(identifier: &Ident) -> Statement {
+    // If this is a struct, we call serialize and add the array to the hasher
+    let serialized_call = method_call(
+        variable_path(path(identifier.clone())), // variable
+        "serialize",                             // method name
+        vec![],                                  // args
+    );
+
+    make_statement(StatementKind::Semi(method_call(
+        variable("hasher"),    // variable
+        "add_multiple",        // method name
+        vec![serialized_call], // args
+    )))
+}
+
+fn str_to_bytes(identifier: &Ident) -> (Statement, Ident) {
+    // let identifier_as_bytes = identifier.as_bytes();
+    let var = variable_ident(identifier.clone());
+    let contents = if let ExpressionKind::Variable(p) = &var.kind {
+        p.segments.first().cloned().unwrap_or_else(|| panic!("No segments")).0.contents
+    } else {
+        panic!("Unexpected identifier type")
+    };
+    let bytes_name = format!("{}_bytes", contents);
+    let var_bytes = assignment(&bytes_name, method_call(var, "as_bytes", vec![]));
+    let id = Ident::new(bytes_name, Span::default());
+
+    (var_bytes, id)
+}
+
+fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
+    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
+    // casted to a field
+    let span = var.span;
+
+    // `array.len()`
+    let end_range_expression = method_call(
+        var,    // variable
+        "len",  // method name
+        vec![], // args
+    );
+
+    // What will be looped over
+    // - `hasher.add({ident}[i] as Field)`
+    let for_loop_block = expression(ExpressionKind::Block(BlockExpression(loop_body)));
+
+    // `for i in 0..{ident}.len()`
+    make_statement(StatementKind::For(ForLoopStatement {
+        range: ForRange::Range(
+            expression(ExpressionKind::Literal(Literal::Integer(
+                FieldElement::from(i128::from(0)),
+                false,
+            ))),
+            end_range_expression,
+        ),
+        identifier: ident("i"),
+        block: for_loop_block,
+        span,
+    }))
+}
+
+fn add_array_to_hasher(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
+    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
+    // casted to a field
+
+    // Wrap in the semi thing - does that mean ended with semi colon?
+    // `hasher.add({ident}[i] as Field)`
+
+    let arr_index = index_array(identifier.clone(), "i");
+    let (add_expression, hasher_method_name) = match arr_type.typ {
+        UnresolvedTypeData::Named(..) => {
+            let hasher_method_name = "add_multiple".to_owned();
+            let call = method_call(
+                // All serialize on each element
+                arr_index,   // variable
+                "serialize", // method name
+                vec![],      // args
+            );
+            (call, hasher_method_name)
+        }
+        _ => {
+            let hasher_method_name = "add".to_owned();
+            let call = cast(
+                arr_index,                        // lhs - `ident[i]`
+                UnresolvedTypeData::FieldElement, // cast to - `as Field`
+            );
+            (call, hasher_method_name)
+        }
+    };
+
+    let block_statement = make_statement(StatementKind::Semi(method_call(
+        variable("hasher"),  // variable
+        &hasher_method_name, // method name
+        vec![add_expression],
+    )));
+
+    create_loop_over(variable_ident(identifier.clone()), vec![block_statement])
+}
+
+fn add_field_to_hasher(identifier: &Ident) -> Statement {
+    // `hasher.add({ident})`
+    let ident = variable_path(path(identifier.clone()));
+    make_statement(StatementKind::Semi(method_call(
+        variable("hasher"), // variable
+        "add",              // method name
+        vec![ident],        // args
+    )))
+}
+
+fn add_cast_to_hasher(identifier: &Ident) -> Statement {
+    // `hasher.add({ident} as Field)`
+    // `{ident} as Field`
+    let cast_operation = cast(
+        variable_path(path(identifier.clone())), // lhs
+        UnresolvedTypeData::FieldElement,        // rhs
+    );
+
+    // `hasher.add({ident} as Field)`
+    make_statement(StatementKind::Semi(method_call(
+        variable("hasher"),   // variable
+        "add",                // method name
+        vec![cast_operation], // args
+    )))
+}
diff --git a/aztec_macros/src/transforms/mod.rs b/aztec_macros/src/transforms/mod.rs
new file mode 100644
index 00000000000..144ffc3efc3
--- /dev/null
+++ b/aztec_macros/src/transforms/mod.rs
@@ -0,0 +1,4 @@
+pub mod compute_note_hash_and_nullifier;
+pub mod events;
+pub mod functions;
+pub mod storage;
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
new file mode 100644
index 00000000000..40a094f78e3
--- /dev/null
+++ b/aztec_macros/src/transforms/storage.rs
@@ -0,0 +1,346 @@
+use std::borrow::{Borrow, BorrowMut};
+
+use noirc_errors::Span;
+use noirc_frontend::{
+    graph::CrateId,
+    macros_api::{
+        FieldElement, FileId, HirContext, HirExpression, HirLiteral, HirStatement, NodeInterner,
+    },
+    node_interner::{TraitId, TraitImplKind},
+    parser::SortedModule,
+    BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
+    PathKind, Pattern, StatementKind, Type, TypeImpl, UnresolvedType, UnresolvedTypeData,
+};
+
+use crate::{
+    chained_dep, chained_path,
+    utils::{
+        ast_utils::{
+            call, expression, ident, ident_path, lambda, make_statement, make_type, pattern,
+            return_type, variable, variable_path,
+        },
+        errors::AztecMacroError,
+        hir_utils::{collect_crate_structs, collect_traits},
+    },
+};
+
+// Check to see if the user has defined a storage struct
+pub fn check_for_storage_definition(module: &SortedModule) -> bool {
+    module.types.iter().any(|r#struct| r#struct.name.0.contents == "Storage")
+}
+
+// Check to see if the user has defined a storage struct
+pub fn check_for_storage_implementation(module: &SortedModule) -> bool {
+    module.impls.iter().any(|r#impl| match &r#impl.object_type.typ {
+        UnresolvedTypeData::Named(path, _, _) => {
+            path.segments.last().is_some_and(|segment| segment.0.contents == "Storage")
+        }
+        _ => false,
+    })
+}
+
+/// Auxiliary function to generate the storage constructor for a given field, using
+/// the Storage definition as a reference. Supports nesting.
+pub fn generate_storage_field_constructor(
+    (type_ident, unresolved_type): &(Ident, UnresolvedType),
+    slot: Expression,
+) -> Result<Expression, AztecMacroError> {
+    let typ = &unresolved_type.typ;
+    match typ {
+        UnresolvedTypeData::Named(path, generics, _) => {
+            let mut new_path = path.clone().to_owned();
+            new_path.segments.push(ident("new"));
+            match path.segments.last().unwrap().0.contents.as_str() {
+                "Map" => Ok(call(
+                    variable_path(new_path),
+                    vec![
+                        variable("context"),
+                        slot,
+                        lambda(
+                            vec![
+                                (
+                                    pattern("context"),
+                                    make_type(UnresolvedTypeData::Named(
+                                        chained_dep!("aztec", "context", "Context"),
+                                        vec![],
+                                        true,
+                                    )),
+                                ),
+                                (
+                                    Pattern::Identifier(ident("slot")),
+                                    make_type(UnresolvedTypeData::FieldElement),
+                                ),
+                            ],
+                            generate_storage_field_constructor(
+                                &(type_ident.clone(), generics.iter().last().unwrap().clone()),
+                                variable("slot"),
+                            )?,
+                        ),
+                    ],
+                )),
+                _ => Ok(call(variable_path(new_path), vec![variable("context"), slot])),
+            }
+        }
+        _ => Err(AztecMacroError::UnsupportedStorageType {
+            typ: typ.clone(),
+            span: Some(type_ident.span()),
+        }),
+    }
+}
+
+// Generates the Storage implementation block from the Storage struct definition if it does not exist
+/// From:
+///
+/// struct Storage {
+///     a_map: Map<Field, SomeStoragePrimitive<ASerializableType>>,
+///     a_nested_map: Map<Field, Map<Field, SomeStoragePrimitive<ASerializableType>>>,
+///     a_field: SomeStoragePrimitive<ASerializableType>,
+/// }
+///
+/// To:
+///
+/// impl Storage {
+///    fn init(context: Context) -> Self {
+///        Storage {
+///             a_map: Map::new(context, 0, |context, slot| {
+///                 SomeStoragePrimitive::new(context, slot)
+///             }),
+///             a_nested_map: Map::new(context, 0, |context, slot| {
+///                 Map::new(context, slot, |context, slot| {
+///                     SomeStoragePrimitive::new(context, slot)
+///                })
+///            }),
+///            a_field: SomeStoragePrimitive::new(context, 0),
+///         }
+///    }
+/// }
+///
+/// Storage slots are generated as 0 and will be populated using the information from the HIR
+/// at a later stage.
+pub fn generate_storage_implementation(module: &mut SortedModule) -> Result<(), AztecMacroError> {
+    let definition =
+        module.types.iter().find(|r#struct| r#struct.name.0.contents == "Storage").unwrap();
+
+    let slot_zero = expression(ExpressionKind::Literal(Literal::Integer(
+        FieldElement::from(i128::from(0)),
+        false,
+    )));
+
+    let field_constructors = definition
+        .fields
+        .iter()
+        .flat_map(|field| {
+            generate_storage_field_constructor(field, slot_zero.clone())
+                .map(|expression| (field.0.clone(), expression))
+        })
+        .collect();
+
+    let storage_constructor_statement = make_statement(StatementKind::Expression(expression(
+        ExpressionKind::constructor((chained_path!("Storage"), field_constructors)),
+    )));
+
+    let init = NoirFunction::normal(FunctionDefinition::normal(
+        &ident("init"),
+        &vec![],
+        &[(
+            ident("context"),
+            make_type(UnresolvedTypeData::Named(
+                chained_dep!("aztec", "context", "Context"),
+                vec![],
+                true,
+            )),
+        )],
+        &BlockExpression(vec![storage_constructor_statement]),
+        &[],
+        &return_type(chained_path!("Self")),
+    ));
+
+    let storage_impl = TypeImpl {
+        object_type: UnresolvedType {
+            typ: UnresolvedTypeData::Named(chained_path!("Storage"), vec![], true),
+            span: Some(Span::default()),
+        },
+        type_span: Span::default(),
+        generics: vec![],
+        methods: vec![(init, Span::default())],
+    };
+    module.impls.push(storage_impl);
+
+    Ok(())
+}
+
+/// Obtains the serialized length of a type that implements the Serialize trait.
+fn get_serialized_length(
+    traits: &[TraitId],
+    typ: &Type,
+    interner: &NodeInterner,
+) -> Result<u64, AztecMacroError> {
+    let (struct_name, maybe_stored_in_state) = match typ {
+        Type::Struct(struct_type, generics) => {
+            Ok((struct_type.borrow().name.0.contents.clone(), generics.first()))
+        }
+        _ => Err(AztecMacroError::CouldNotAssignStorageSlots {
+            secondary_message: Some("State storage variable must be a struct".to_string()),
+        }),
+    }?;
+    let stored_in_state =
+        maybe_stored_in_state.ok_or(AztecMacroError::CouldNotAssignStorageSlots {
+            secondary_message: Some("State storage variable must be generic".to_string()),
+        })?;
+
+    let is_note = traits.iter().any(|&trait_id| {
+        let r#trait = interner.get_trait(trait_id);
+        r#trait.name.0.contents == "NoteInterface"
+            && !interner.lookup_all_trait_implementations(stored_in_state, trait_id).is_empty()
+    });
+
+    // Maps and (private) Notes always occupy a single slot. Someone could store a Note in PublicMutable for whatever reason though.
+    if struct_name == "Map" || (is_note && struct_name != "PublicMutable") {
+        return Ok(1);
+    }
+
+    let serialized_trait_impl_kind = traits
+        .iter()
+        .find_map(|&trait_id| {
+            let r#trait = interner.get_trait(trait_id);
+            if r#trait.borrow().name.0.contents == "Serialize"
+                && r#trait.borrow().generics.len() == 1
+            {
+                interner
+                    .lookup_all_trait_implementations(stored_in_state, trait_id)
+                    .into_iter()
+                    .next()
+            } else {
+                None
+            }
+        })
+        .ok_or(AztecMacroError::CouldNotAssignStorageSlots {
+            secondary_message: Some("Stored data must implement Serialize trait".to_string()),
+        })?;
+
+    let serialized_trait_impl_id = match serialized_trait_impl_kind {
+        TraitImplKind::Normal(trait_impl_id) => Ok(trait_impl_id),
+        _ => Err(AztecMacroError::CouldNotAssignStorageSlots { secondary_message: None }),
+    }?;
+
+    let serialized_trait_impl_shared = interner.get_trait_implementation(*serialized_trait_impl_id);
+    let serialized_trait_impl = serialized_trait_impl_shared.borrow();
+
+    match serialized_trait_impl.trait_generics.first().unwrap() {
+        Type::Constant(value) => Ok(*value),
+        _ => Err(AztecMacroError::CouldNotAssignStorageSlots { secondary_message: None }),
+    }
+}
+
+/// Assigns storage slots to the storage struct fields based on the serialized length of the types. This automatic assignment
+/// will only trigger if the assigned storage slot is invalid (0 as generated by generate_storage_implementation)
+pub fn assign_storage_slots(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+) -> Result<(), (AztecMacroError, FileId)> {
+    let traits: Vec<_> = collect_traits(context);
+    for struct_id in collect_crate_structs(crate_id, context) {
+        let interner: &mut NodeInterner = context.def_interner.borrow_mut();
+        let r#struct = interner.get_struct(struct_id);
+        let file_id = r#struct.borrow().location.file;
+        if r#struct.borrow().name.0.contents == "Storage" && r#struct.borrow().id.krate().is_root()
+        {
+            let init_id = interner
+                .lookup_method(
+                    &Type::Struct(interner.get_struct(struct_id), vec![]),
+                    struct_id,
+                    "init",
+                    false,
+                )
+                .ok_or((
+                    AztecMacroError::CouldNotAssignStorageSlots {
+                        secondary_message: Some(
+                            "Storage struct must have an init function".to_string(),
+                        ),
+                    },
+                    file_id,
+                ))?;
+            let init_function = interner.function(&init_id).block(interner);
+            let init_function_statement_id = init_function.statements().first().ok_or((
+                AztecMacroError::CouldNotAssignStorageSlots {
+                    secondary_message: Some("Init storage statement not found".to_string()),
+                },
+                file_id,
+            ))?;
+            let storage_constructor_statement = interner.statement(init_function_statement_id);
+
+            let storage_constructor_expression = match storage_constructor_statement {
+                HirStatement::Expression(expression_id) => {
+                    match interner.expression(&expression_id) {
+                        HirExpression::Constructor(hir_constructor_expression) => {
+                            Ok(hir_constructor_expression)
+                        }
+                        _ => Err((AztecMacroError::CouldNotAssignStorageSlots {
+                            secondary_message: Some(
+                                "Storage constructor statement must be a constructor expression"
+                                    .to_string(),
+                            ),
+                        }, file_id))
+                    }
+                }
+                _ => Err((
+                    AztecMacroError::CouldNotAssignStorageSlots {
+                        secondary_message: Some(
+                            "Storage constructor statement must be an expression".to_string(),
+                        ),
+                    },
+                    file_id,
+                )),
+            }?;
+
+            let mut storage_slot: u64 = 1;
+            for (index, (_, expr_id)) in storage_constructor_expression.fields.iter().enumerate() {
+                let fields = r#struct.borrow().get_fields(&[]);
+                let (_, field_type) = fields.get(index).unwrap();
+                let new_call_expression = match interner.expression(expr_id) {
+                    HirExpression::Call(hir_call_expression) => Ok(hir_call_expression),
+                    _ => Err((
+                        AztecMacroError::CouldNotAssignStorageSlots {
+                            secondary_message: Some(
+                                "Storage field initialization expression is not a call expression"
+                                    .to_string(),
+                            ),
+                        },
+                        file_id,
+                    )),
+                }?;
+
+                let slot_arg_expression = interner.expression(&new_call_expression.arguments[1]);
+
+                let current_storage_slot = match slot_arg_expression {
+                    HirExpression::Literal(HirLiteral::Integer(slot, _)) => Ok(slot.to_u128()),
+                    _ => Err((
+                        AztecMacroError::CouldNotAssignStorageSlots {
+                            secondary_message: Some(
+                                "Storage slot argument expression must be a literal integer"
+                                    .to_string(),
+                            ),
+                        },
+                        file_id,
+                    )),
+                }?;
+
+                if current_storage_slot != 0 {
+                    continue;
+                }
+
+                let type_serialized_len = get_serialized_length(&traits, field_type, interner)
+                    .map_err(|err| (err, file_id))?;
+                interner.update_expression(new_call_expression.arguments[1], |expr| {
+                    *expr = HirExpression::Literal(HirLiteral::Integer(
+                        FieldElement::from(u128::from(storage_slot)),
+                        false,
+                    ));
+                });
+
+                storage_slot += type_serialized_len;
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
new file mode 100644
index 00000000000..71c6a93f388
--- /dev/null
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -0,0 +1,183 @@
+use noirc_errors::{Span, Spanned};
+use noirc_frontend::{
+    token::SecondaryAttribute, BinaryOpKind, CallExpression, CastExpression, Expression,
+    ExpressionKind, FunctionReturnType, Ident, IndexExpression, InfixExpression, Lambda,
+    LetStatement, MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression,
+    Statement, StatementKind, UnaryOp, UnresolvedType, UnresolvedTypeData,
+};
+
+//
+//             Helper macros for creating noir ast nodes
+//
+pub fn ident(name: &str) -> Ident {
+    Ident::new(name.to_string(), Span::default())
+}
+
+pub fn ident_path(name: &str) -> Path {
+    Path::from_ident(ident(name))
+}
+
+pub fn path(ident: Ident) -> Path {
+    Path::from_ident(ident)
+}
+
+pub fn expression(kind: ExpressionKind) -> Expression {
+    Expression::new(kind, Span::default())
+}
+
+pub fn variable(name: &str) -> Expression {
+    expression(ExpressionKind::Variable(ident_path(name)))
+}
+
+pub fn variable_ident(identifier: Ident) -> Expression {
+    expression(ExpressionKind::Variable(path(identifier)))
+}
+
+pub fn variable_path(path: Path) -> Expression {
+    expression(ExpressionKind::Variable(path))
+}
+
+pub fn method_call(
+    object: Expression,
+    method_name: &str,
+    arguments: Vec<Expression>,
+) -> Expression {
+    expression(ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+        object,
+        method_name: ident(method_name),
+        arguments,
+    })))
+}
+
+pub fn call(func: Expression, arguments: Vec<Expression>) -> Expression {
+    expression(ExpressionKind::Call(Box::new(CallExpression { func: Box::new(func), arguments })))
+}
+
+pub fn pattern(name: &str) -> Pattern {
+    Pattern::Identifier(ident(name))
+}
+
+pub fn mutable(name: &str) -> Pattern {
+    Pattern::Mutable(Box::new(pattern(name)), Span::default(), true)
+}
+
+pub fn mutable_assignment(name: &str, assigned_to: Expression) -> Statement {
+    make_statement(StatementKind::Let(LetStatement {
+        pattern: mutable(name),
+        r#type: make_type(UnresolvedTypeData::Unspecified),
+        expression: assigned_to,
+    }))
+}
+
+pub fn mutable_reference(variable_name: &str) -> Expression {
+    expression(ExpressionKind::Prefix(Box::new(PrefixExpression {
+        operator: UnaryOp::MutableReference,
+        rhs: variable(variable_name),
+    })))
+}
+
+pub fn assignment(name: &str, assigned_to: Expression) -> Statement {
+    make_statement(StatementKind::Let(LetStatement {
+        pattern: pattern(name),
+        r#type: make_type(UnresolvedTypeData::Unspecified),
+        expression: assigned_to,
+    }))
+}
+
+pub fn member_access(lhs: &str, rhs: &str) -> Expression {
+    expression(ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
+        lhs: variable(lhs),
+        rhs: ident(rhs),
+    })))
+}
+
+pub fn return_type(path: Path) -> FunctionReturnType {
+    let ty = make_type(UnresolvedTypeData::Named(path, vec![], true));
+    FunctionReturnType::Ty(ty)
+}
+
+pub fn lambda(parameters: Vec<(Pattern, UnresolvedType)>, body: Expression) -> Expression {
+    expression(ExpressionKind::Lambda(Box::new(Lambda {
+        parameters,
+        return_type: UnresolvedType {
+            typ: UnresolvedTypeData::Unspecified,
+            span: Some(Span::default()),
+        },
+        body,
+    })))
+}
+
+pub fn make_eq(lhs: Expression, rhs: Expression) -> Expression {
+    expression(ExpressionKind::Infix(Box::new(InfixExpression {
+        lhs,
+        rhs,
+        operator: Spanned::from(Span::default(), BinaryOpKind::Equal),
+    })))
+}
+
+pub fn make_statement(kind: StatementKind) -> Statement {
+    Statement { span: Span::default(), kind }
+}
+
+#[macro_export]
+macro_rules! chained_path {
+    ( $base:expr ) => {
+        {
+            ident_path($base)
+        }
+    };
+    ( $base:expr $(, $tail:expr)* ) => {
+        {
+            let mut base_path = ident_path($base);
+            $(
+                base_path.segments.push(ident($tail));
+            )*
+            base_path
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! chained_dep {
+    ( $base:expr $(, $tail:expr)* ) => {
+        {
+            let mut base_path = ident_path($base);
+            base_path.kind = PathKind::Dep;
+            $(
+                base_path.segments.push(ident($tail));
+            )*
+            base_path
+        }
+    }
+}
+
+pub fn cast(lhs: Expression, ty: UnresolvedTypeData) -> Expression {
+    expression(ExpressionKind::Cast(Box::new(CastExpression { lhs, r#type: make_type(ty) })))
+}
+
+pub fn make_type(typ: UnresolvedTypeData) -> UnresolvedType {
+    UnresolvedType { typ, span: Some(Span::default()) }
+}
+
+pub fn index_array(array: Ident, index: &str) -> Expression {
+    expression(ExpressionKind::Index(Box::new(IndexExpression {
+        collection: variable_path(path(array)),
+        index: variable(index),
+    })))
+}
+
+pub fn index_array_variable(array: Expression, index: &str) -> Expression {
+    expression(ExpressionKind::Index(Box::new(IndexExpression {
+        collection: array,
+        index: variable(index),
+    })))
+}
+
+/// Checks if an attribute is a custom attribute with a specific name
+pub fn is_custom_attribute(attr: &SecondaryAttribute, attribute_name: &str) -> bool {
+    if let SecondaryAttribute::Custom(custom_attr) = attr {
+        custom_attr.as_str() == attribute_name
+    } else {
+        false
+    }
+}
diff --git a/aztec_macros/src/utils/checks.rs b/aztec_macros/src/utils/checks.rs
new file mode 100644
index 00000000000..5232f67ae87
--- /dev/null
+++ b/aztec_macros/src/utils/checks.rs
@@ -0,0 +1,22 @@
+use noirc_frontend::{
+    graph::CrateId,
+    macros_api::{FileId, HirContext, MacroError},
+};
+
+use super::errors::AztecMacroError;
+
+/// Creates an error alerting the user that they have not downloaded the Aztec-noir library
+pub fn check_for_aztec_dependency(
+    crate_id: &CrateId,
+    context: &HirContext,
+) -> Result<(), (MacroError, FileId)> {
+    if has_aztec_dependency(crate_id, context) {
+        Ok(())
+    } else {
+        Err((AztecMacroError::AztecDepNotFound.into(), context.crate_graph[crate_id].root_file_id))
+    }
+}
+
+pub fn has_aztec_dependency(crate_id: &CrateId, context: &HirContext) -> bool {
+    context.crate_graph[crate_id].dependencies.iter().any(|dep| dep.as_name() == "aztec")
+}
diff --git a/aztec_macros/src/utils/constants.rs b/aztec_macros/src/utils/constants.rs
new file mode 100644
index 00000000000..464cd10e2c7
--- /dev/null
+++ b/aztec_macros/src/utils/constants.rs
@@ -0,0 +1,3 @@
+pub const FUNCTION_TREE_HEIGHT: u32 = 5;
+pub const MAX_CONTRACT_PRIVATE_FUNCTIONS: usize = 2_usize.pow(FUNCTION_TREE_HEIGHT);
+pub const SIGNATURE_PLACEHOLDER: &str = "SIGNATURE_PLACEHOLDER";
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
new file mode 100644
index 00000000000..63892b58af9
--- /dev/null
+++ b/aztec_macros/src/utils/errors.rs
@@ -0,0 +1,69 @@
+use noirc_errors::Span;
+use noirc_frontend::{macros_api::MacroError, UnresolvedTypeData};
+
+use super::constants::MAX_CONTRACT_PRIVATE_FUNCTIONS;
+
+#[derive(Debug, Clone)]
+pub enum AztecMacroError {
+    AztecDepNotFound,
+    ContractHasTooManyPrivateFunctions { span: Span },
+    ContractConstructorMissing { span: Span },
+    UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
+    UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
+    CouldNotAssignStorageSlots { secondary_message: Option<String> },
+    CouldNotImplementNoteSerialization { span: Option<Span>, typ: UnresolvedTypeData },
+    EventError { span: Span, message: String },
+    UnsupportedAttributes { span: Span, secondary_message: Option<String> },
+}
+
+impl From<AztecMacroError> for MacroError {
+    fn from(err: AztecMacroError) -> Self {
+        match err {
+            AztecMacroError::AztecDepNotFound {} => MacroError {
+                primary_message: "Aztec dependency not found. Please add aztec as a dependency in your Cargo.toml. For more information go to https://docs.aztec.network/developers/debugging/aztecnr-errors#aztec-dependency-not-found-please-add-aztec-as-a-dependency-in-your-nargotoml".to_owned(),
+                secondary_message: None,
+                span: None,
+            },
+            AztecMacroError::ContractHasTooManyPrivateFunctions { span } => MacroError {
+                primary_message: format!("Contract can only have a maximum of {} private functions", MAX_CONTRACT_PRIVATE_FUNCTIONS),
+                secondary_message: None,
+                span: Some(span),
+            },
+            AztecMacroError::ContractConstructorMissing { span } => MacroError {
+                primary_message: "Contract must have a constructor function".to_owned(),
+                secondary_message: None,
+                span: Some(span),
+            },
+            AztecMacroError::UnsupportedFunctionArgumentType { span, typ } => MacroError {
+                primary_message: format!("Provided parameter type `{typ:?}` is not supported in Aztec contract interface"),
+                secondary_message: None,
+                span: Some(span),
+            },
+            AztecMacroError::UnsupportedStorageType { span, typ } => MacroError {
+                primary_message: format!("Provided storage type `{typ:?}` is not directly supported in Aztec. Please provide a custom storage implementation"),
+                secondary_message: None,
+                span,
+            },
+            AztecMacroError::CouldNotAssignStorageSlots { secondary_message } => MacroError {
+                primary_message: "Could not assign storage slots, please provide a custom storage implementation".to_string(),
+                secondary_message,
+                span: None,
+            },
+            AztecMacroError::CouldNotImplementNoteSerialization { span, typ } => MacroError {
+                primary_message: format!("Could not implement serialization methods for note `{typ:?}`, please provide a serialize_content and deserialize_content methods"),
+                secondary_message: None,
+                span,
+            },
+            AztecMacroError::EventError { span, message } => MacroError {
+                primary_message: message,
+                secondary_message: None,
+                span: Some(span),
+            },
+AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
+                primary_message: "Unsupported attributes in contract function".to_string(),
+                secondary_message,
+                span: Some(span),
+            },
+        }
+    }
+}
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
new file mode 100644
index 00000000000..f31a0584261
--- /dev/null
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -0,0 +1,118 @@
+use iter_extended::vecmap;
+use noirc_frontend::{
+    graph::CrateId,
+    hir::def_collector::dc_crate::UnresolvedTraitImpl,
+    macros_api::{HirContext, ModuleDefId, StructId},
+    node_interner::{TraitId, TraitImplId},
+    Signedness, Type, UnresolvedTypeData,
+};
+
+pub fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<StructId> {
+    context
+        .def_map(crate_id)
+        .expect("ICE: Missing crate in def_map")
+        .modules()
+        .iter()
+        .flat_map(|(_, module)| {
+            module.type_definitions().filter_map(|typ| {
+                if let ModuleDefId::TypeId(struct_id) = typ {
+                    Some(struct_id)
+                } else {
+                    None
+                }
+            })
+        })
+        .collect()
+}
+
+pub fn collect_traits(context: &HirContext) -> Vec<TraitId> {
+    let crates = context.crates();
+    crates
+        .flat_map(|crate_id| context.def_map(&crate_id).map(|def_map| def_map.modules()))
+        .flatten()
+        .flat_map(|module| {
+            module.type_definitions().filter_map(|typ| {
+                if let ModuleDefId::TraitId(struct_id) = typ {
+                    Some(struct_id)
+                } else {
+                    None
+                }
+            })
+        })
+        .collect()
+}
+
+/// Computes the aztec signature for a resolved type.
+pub fn signature_of_type(typ: &Type) -> String {
+    match typ {
+        Type::Integer(Signedness::Signed, bit_size) => format!("i{}", bit_size),
+        Type::Integer(Signedness::Unsigned, bit_size) => format!("u{}", bit_size),
+        Type::FieldElement => "Field".to_owned(),
+        Type::Bool => "bool".to_owned(),
+        Type::Array(len, typ) => {
+            if let Type::Constant(len) = **len {
+                format!("[{};{len}]", signature_of_type(typ))
+            } else {
+                unimplemented!("Cannot generate signature for array with length type {:?}", typ)
+            }
+        }
+        Type::Struct(def, args) => {
+            let fields = def.borrow().get_fields(args);
+            let fields = vecmap(fields, |(_, typ)| signature_of_type(&typ));
+            format!("({})", fields.join(","))
+        }
+        Type::Tuple(types) => {
+            let fields = vecmap(types, signature_of_type);
+            format!("({})", fields.join(","))
+        }
+        _ => unimplemented!("Cannot generate signature for type {:?}", typ),
+    }
+}
+
+// Fetches the name of all structs that implement trait_name, both in the current crate and all of its dependencies.
+pub fn fetch_struct_trait_impls(
+    context: &mut HirContext,
+    unresolved_traits_impls: &[UnresolvedTraitImpl],
+    trait_name: &str,
+) -> Vec<String> {
+    let mut struct_typenames: Vec<String> = Vec::new();
+
+    // These structs can be declared in either external crates or the current one. External crates that contain
+    // dependencies have already been processed and resolved, but are available here via the NodeInterner. Note that
+    // crates on which the current crate does not depend on may not have been processed, and will be ignored.
+    for trait_impl_id in 0..context.def_interner.next_trait_impl_id().0 {
+        let trait_impl = &context.def_interner.get_trait_implementation(TraitImplId(trait_impl_id));
+
+        if trait_impl.borrow().ident.0.contents == *trait_name {
+            if let Type::Struct(s, _) = &trait_impl.borrow().typ {
+                struct_typenames.push(s.borrow().name.0.contents.clone());
+            } else {
+                panic!("Found impl for {} on non-Struct", trait_name);
+            }
+        }
+    }
+
+    // This crate's traits and impls have not yet been resolved, so we look for impls in unresolved_trait_impls.
+    struct_typenames.extend(
+        unresolved_traits_impls
+            .iter()
+            .filter(|trait_impl| {
+                trait_impl
+                    .trait_path
+                    .segments
+                    .last()
+                    .expect("ICE: empty trait_impl path")
+                    .0
+                    .contents
+                    == *trait_name
+            })
+            .filter_map(|trait_impl| match &trait_impl.object_type.typ {
+                UnresolvedTypeData::Named(path, _, _) => {
+                    Some(path.segments.last().unwrap().0.contents.clone())
+                }
+                _ => None,
+            }),
+    );
+
+    struct_typenames
+}
diff --git a/aztec_macros/src/utils/mod.rs b/aztec_macros/src/utils/mod.rs
new file mode 100644
index 00000000000..c8914f83025
--- /dev/null
+++ b/aztec_macros/src/utils/mod.rs
@@ -0,0 +1,5 @@
+pub mod ast_utils;
+pub mod checks;
+pub mod constants;
+pub mod errors;
+pub mod hir_utils;
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index 5f4b66e7dd2..66e8dc0e730 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -9,23 +9,6 @@ use noirc_evaluator::errors::SsaReport;
 
 use super::debug::DebugFile;
 
-/// Describes the types of smart contract functions that are allowed.
-/// Unlike the similar enum in noirc_frontend, 'open' and 'unconstrained'
-/// are mutually exclusive here. In the case a function is both, 'unconstrained'
-/// takes precedence.
-#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ContractFunctionType {
-    /// This function will be executed in a private
-    /// context.
-    Secret,
-    /// This function will be executed in a public
-    /// context.
-    Open,
-    /// This function cannot constrain any values and can use nondeterministic features
-    /// like arrays of a dynamic size.
-    Unconstrained,
-}
-
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CompiledContract {
     pub noir_version: String,
@@ -55,9 +38,9 @@ pub struct CompiledContract {
 pub struct ContractFunction {
     pub name: String,
 
-    pub function_type: ContractFunctionType,
+    pub is_unconstrained: bool,
 
-    pub is_internal: bool,
+    pub custom_attributes: Vec<String>,
 
     pub abi: Abi,
 
@@ -69,13 +52,3 @@ pub struct ContractFunction {
 
     pub debug: DebugInfo,
 }
-
-impl ContractFunctionType {
-    pub(super) fn new(kind: noirc_frontend::ContractFunctionType, is_unconstrained: bool) -> Self {
-        match (kind, is_unconstrained) {
-            (_, true) => Self::Unconstrained,
-            (noirc_frontend::ContractFunctionType::Secret, false) => Self::Secret,
-            (noirc_frontend::ContractFunctionType::Open, false) => Self::Open,
-        }
-    }
-}
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index fa134f8a0dd..c9494a64b41 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -18,6 +18,7 @@ use noirc_frontend::hir::Context;
 use noirc_frontend::macros_api::MacroProcessor;
 use noirc_frontend::monomorphization::{monomorphize, monomorphize_debug, MonomorphizationError};
 use noirc_frontend::node_interner::FuncId;
+use noirc_frontend::token::SecondaryAttribute;
 use std::path::Path;
 use thiserror::Error;
 use tracing::info;
@@ -30,7 +31,7 @@ mod stdlib;
 
 use debug::filter_relevant_files;
 
-pub use contract::{CompiledContract, ContractFunction, ContractFunctionType};
+pub use contract::{CompiledContract, ContractFunction};
 pub use debug::DebugFile;
 pub use program::CompiledProgram;
 
@@ -398,19 +399,24 @@ fn compile_contract_inner(
         };
         warnings.extend(function.warnings);
         let modifiers = context.def_interner.function_modifiers(&function_id);
-        let func_type = modifiers
-            .contract_function_type
-            .expect("Expected contract function to have a contract visibility");
 
-        let function_type = ContractFunctionType::new(func_type, modifiers.is_unconstrained);
+        let custom_attributes = modifiers
+            .attributes
+            .secondary
+            .iter()
+            .filter_map(
+                |attr| if let SecondaryAttribute::Custom(tag) = attr { Some(tag) } else { None },
+            )
+            .cloned()
+            .collect();
 
         functions.push(ContractFunction {
             name,
-            function_type,
-            is_internal: modifiers.is_internal.unwrap_or(false),
+            custom_attributes,
             abi: function.abi,
             bytecode: function.circuit,
             debug: function.debug,
+            is_unconstrained: modifiers.is_unconstrained,
         });
     }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 530b6dc69fc..911f4c1924e 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -831,10 +831,15 @@ impl<'block> BrilligBlock<'block> {
             _ => unreachable!("ICE: array set on non-array"),
         };
 
+        // Here we want to compare the reference count against 1.
+        let one = self.brillig_context.make_usize_constant(1_usize.into());
         let condition = self.brillig_context.allocate_register();
-
-        self.brillig_context.usize_op(reference_count, condition, BinaryIntOp::Equals, 1_usize);
-
+        self.brillig_context.memory_op(
+            reference_count,
+            one.address,
+            condition,
+            BinaryIntOp::Equals,
+        );
         self.brillig_context.branch_instruction(condition, |ctx, cond| {
             if cond {
                 // Reference count is 1, we can mutate the array directly
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 1e53713dfe0..2a96965171b 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -27,7 +27,6 @@ use acvm::{
     FieldElement,
 };
 use debug_show::DebugShow;
-use num_bigint::BigUint;
 
 /// The Brillig VM does not apply a limit to the memory address space,
 /// As a convention, we take use 64 bits. This means that we assume that
@@ -215,7 +214,6 @@ impl BrilligContext {
         // Computes array_ptr + index, ie array[index]
         let index_of_element_in_memory = self.allocate_register();
         self.memory_op(array_ptr, index.address, index_of_element_in_memory, BinaryIntOp::Add);
-
         self.load_instruction(result, index_of_element_in_memory);
         // Free up temporary register
         self.deallocate_register(index_of_element_in_memory);
@@ -232,7 +230,12 @@ impl BrilligContext {
         self.debug_show.array_set(array_ptr, index.address, value);
         // Computes array_ptr + index, ie array[index]
         let index_of_element_in_memory = self.allocate_register();
-        self.memory_op(array_ptr, index.address, index_of_element_in_memory, BinaryIntOp::Add);
+        self.binary_instruction(
+            SingleAddrVariable::new_usize(array_ptr),
+            index,
+            SingleAddrVariable::new_usize(index_of_element_in_memory),
+            BrilligBinaryOp::Integer(BinaryIntOp::Add),
+        );
 
         self.store_instruction(index_of_element_in_memory, value);
         // Free up temporary register
@@ -592,6 +595,7 @@ impl BrilligContext {
     /// Stores the value of `constant` in the `result` register
     pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: Value) {
         self.debug_show.const_instruction(result.address, constant);
+
         self.push_opcode(BrilligOpcode::Const {
             destination: result.address,
             value: constant,
@@ -760,6 +764,8 @@ impl BrilligContext {
     /// Instead truncation instructions are emitted as to when a
     /// truncation should be done.
     /// For Brillig, all integer operations will overflow as its cheap.
+    /// We currently use cast to truncate: we cast to the required bit size
+    /// and back to the original bit size.
     pub(crate) fn truncate_instruction(
         &mut self,
         destination_of_truncated_value: SingleAddrVariable,
@@ -778,20 +784,12 @@ impl BrilligContext {
             value_to_truncate.bit_size
         );
 
-        let mask = BigUint::from(2_u32).pow(bit_size) - BigUint::from(1_u32);
-        let mask_constant = self.make_constant(
-            FieldElement::from_be_bytes_reduce(&mask.to_bytes_be()).into(),
-            value_to_truncate.bit_size,
-        );
-
-        self.binary_instruction(
-            value_to_truncate,
-            mask_constant,
-            destination_of_truncated_value,
-            BrilligBinaryOp::Integer(BinaryIntOp::And),
-        );
-
-        self.deallocate_single_addr(mask_constant);
+        // We cast back and forth to ensure that the value is truncated.
+        let intermediate_register =
+            SingleAddrVariable { address: self.allocate_register(), bit_size };
+        self.cast_instruction(intermediate_register, value_to_truncate);
+        self.cast_instruction(destination_of_truncated_value, intermediate_register);
+        self.deallocate_register(intermediate_register.address);
     }
 
     /// Emits a stop instruction
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index def1b082890..a9ecc1a53e5 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -369,11 +369,6 @@ pub struct FunctionDefinition {
     // and `secondary` attributes (ones that do not change the function kind)
     pub attributes: Attributes,
 
-    /// True if this function was defined with the 'open' keyword
-    pub is_open: bool,
-
-    pub is_internal: bool,
-
     /// True if this function was defined with the 'unconstrained' keyword
     pub is_unconstrained: bool,
 
@@ -406,18 +401,6 @@ pub enum FunctionReturnType {
     Ty(UnresolvedType),
 }
 
-/// Describes the types of smart contract functions that are allowed.
-/// - All Noir programs in the non-contract context can be seen as `Secret`.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ContractFunctionType {
-    /// This function will be executed in a private
-    /// context.
-    Secret,
-    /// This function will be executed in a public
-    /// context.
-    Open,
-}
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ArrayLiteral {
     Standard(Vec<Expression>),
@@ -674,8 +657,6 @@ impl FunctionDefinition {
         FunctionDefinition {
             name: name.clone(),
             attributes: Attributes::empty(),
-            is_open: false,
-            is_internal: false,
             is_unconstrained: false,
             visibility: ItemVisibility::Private,
             generics: generics.clone(),
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index a5dfc738824..0c53bff4a54 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -246,6 +246,7 @@ impl DefCollector {
             crate_root,
             crate_id,
             context,
+            macro_processors,
         ));
 
         let submodules = vecmap(def_collector.def_map.modules().iter(), |(index, _)| index);
@@ -255,7 +256,7 @@ impl DefCollector {
         // TODO(#4653): generalize this function
         for macro_processor in macro_processors {
             macro_processor
-                .process_unresolved_traits_impls(
+                .process_collected_defs(
                     &crate_id,
                     context,
                     &def_collector.collected_traits_impls,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 6ac263d80be..ae99e61e534 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -7,6 +7,7 @@ use noirc_errors::Location;
 use crate::{
     graph::CrateId,
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
+    macros_api::MacroProcessor,
     node_interner::{FunctionModifiers, TraitId, TypeAliasId},
     parser::{SortedModule, SortedSubModule},
     FunctionDefinition, Ident, LetStatement, ModuleDeclaration, NoirFunction, NoirStruct,
@@ -41,16 +42,28 @@ pub fn collect_defs(
     module_id: LocalModuleId,
     crate_id: CrateId,
     context: &mut Context,
+    macro_processors: &[&dyn MacroProcessor],
 ) -> Vec<(CompilationError, FileId)> {
     let mut collector = ModCollector { def_collector, file_id, module_id };
     let mut errors: Vec<(CompilationError, FileId)> = vec![];
 
     // First resolve the module declarations
     for decl in ast.module_decls {
-        errors.extend(collector.parse_module_declaration(context, &decl, crate_id));
+        errors.extend(collector.parse_module_declaration(
+            context,
+            &decl,
+            crate_id,
+            macro_processors,
+        ));
     }
 
-    errors.extend(collector.collect_submodules(context, crate_id, ast.submodules, file_id));
+    errors.extend(collector.collect_submodules(
+        context,
+        crate_id,
+        ast.submodules,
+        file_id,
+        macro_processors,
+    ));
 
     // Then add the imports to defCollector to resolve once all modules in the hierarchy have been resolved
     for import in ast.imports {
@@ -398,8 +411,6 @@ impl<'a> ModCollector<'a> {
                             // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629
                             attributes: crate::token::Attributes::empty(),
                             is_unconstrained: false,
-                            contract_function_type: None,
-                            is_internal: None,
                         };
 
                         let location = Location::new(name.span(), self.file_id);
@@ -494,6 +505,7 @@ impl<'a> ModCollector<'a> {
         crate_id: CrateId,
         submodules: Vec<SortedSubModule>,
         file_id: FileId,
+        macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
         for submodule in submodules {
@@ -506,6 +518,7 @@ impl<'a> ModCollector<'a> {
                         child,
                         crate_id,
                         context,
+                        macro_processors,
                     ));
                 }
                 Err(error) => {
@@ -524,6 +537,7 @@ impl<'a> ModCollector<'a> {
         context: &mut Context,
         mod_decl: &ModuleDeclaration,
         crate_id: CrateId,
+        macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
         let child_file_id =
@@ -559,7 +573,19 @@ impl<'a> ModCollector<'a> {
 
         // Parse the AST for the module we just found and then recursively look for it's defs
         let (ast, parsing_errors) = context.parsed_file_results(child_file_id);
-        let ast = ast.into_sorted();
+        let mut ast = ast.into_sorted();
+
+        for macro_processor in macro_processors {
+            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, context) {
+                Ok(processed_ast) => {
+                    ast = processed_ast;
+                }
+                Err((error, file_id)) => {
+                    let def_error = DefCollectorErrorKind::MacroError(error);
+                    errors.push((def_error.into(), file_id));
+                }
+            }
+        }
 
         errors.extend(
             parsing_errors.iter().map(|e| (e.clone().into(), child_file_id)).collect::<Vec<_>>(),
@@ -575,6 +601,7 @@ impl<'a> ModCollector<'a> {
                     child_mod_id,
                     crate_id,
                     context,
+                    macro_processors,
                 ));
             }
             Err(error) => {
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 1049599f079..30a1ba2ee34 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -64,14 +64,10 @@ pub enum ResolverError {
     IncorrectGenericCount { span: Span, item_name: String, actual: usize, expected: usize },
     #[error("{0}")]
     ParserError(Box<ParserError>),
-    #[error("Function is not defined in a contract yet sets its contract visibility")]
-    ContractFunctionTypeInNormalFunction { span: Span },
     #[error("Cannot create a mutable reference to {variable}, it was declared to be immutable")]
     MutableReferenceToImmutableVariable { variable: String, span: Span },
     #[error("Mutable references to array indices are unsupported")]
     MutableReferenceToArrayElement { span: Span },
-    #[error("Function is not defined in a contract yet sets is_internal")]
-    ContractFunctionInternalInNormalFunction { span: Span },
     #[error("Numeric constants should be printed without formatting braces")]
     NumericConstantInFormatString { name: String, span: Span },
     #[error("Closure environment must be a tuple or unit type")]
@@ -276,22 +272,12 @@ impl From<ResolverError> for Diagnostic {
                 )
             }
             ResolverError::ParserError(error) => (*error).into(),
-            ResolverError::ContractFunctionTypeInNormalFunction { span } => Diagnostic::simple_error(
-                "Only functions defined within contracts can set their contract function type".into(),
-                "Non-contract functions cannot be 'open'".into(),
-                span,
-            ),
             ResolverError::MutableReferenceToImmutableVariable { variable, span } => {
                 Diagnostic::simple_error(format!("Cannot mutably reference the immutable variable {variable}"), format!("{variable} is immutable"), span)
             },
             ResolverError::MutableReferenceToArrayElement { span } => {
                 Diagnostic::simple_error("Mutable references to array elements are currently unsupported".into(), "Try storing the element in a fresh variable first".into(), span)
             },
-            ResolverError::ContractFunctionInternalInNormalFunction { span } => Diagnostic::simple_error(
-                "Only functions defined within contracts can set their functions to be internal".into(),
-                "Non-contract functions cannot be 'internal'".into(),
-                span,
-            ),
             ResolverError::NumericConstantInFormatString { name, span } => Diagnostic::simple_error(
                 format!("cannot find `{name}` in this scope "),
                 "Numeric constants should be printed without formatting braces".to_string(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 567cc20f789..00b1b443430 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -37,11 +37,11 @@ use crate::{
     StatementKind,
 };
 use crate::{
-    ArrayLiteral, ContractFunctionType, Distinctness, ForRange, FunctionDefinition,
-    FunctionReturnType, Generics, ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path,
-    PathKind, Pattern, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind,
-    UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData,
-    UnresolvedTypeExpression, Visibility, ERROR_IDENT,
+    ArrayLiteral, Distinctness, ForRange, FunctionDefinition, FunctionReturnType, Generics,
+    ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern, Shared,
+    StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp, UnresolvedGenerics,
+    UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
+    Visibility, ERROR_IDENT,
 };
 use fm::FileId;
 use iter_extended::vecmap;
@@ -234,8 +234,6 @@ impl<'a> Resolver<'a> {
         let def = FunctionDefinition {
             name: name.clone(),
             attributes: Attributes::empty(),
-            is_open: false,
-            is_internal: false,
             is_unconstrained: false,
             visibility: ItemVisibility::Public, // Trait functions are always public
             generics: generics.clone(),
@@ -973,9 +971,6 @@ impl<'a> Resolver<'a> {
 
         self.interner.push_definition_type(name_ident.id, typ.clone());
 
-        self.handle_function_type(&func_id);
-        self.handle_is_function_internal(&func_id);
-
         let direct_generics = func.def.generics.iter();
         let direct_generics = direct_generics
             .filter_map(|generic| self.find_generic(&generic.0.contents))
@@ -1023,34 +1018,14 @@ impl<'a> Resolver<'a> {
     /// True if the `distinct` keyword is allowed on a function's return type
     fn distinct_allowed(&self, func: &NoirFunction) -> bool {
         if self.in_contract {
-            // "open" and "unconstrained" functions are compiled to brillig and thus duplication of
+            // "unconstrained" functions are compiled to brillig and thus duplication of
             // witness indices in their abis is not a concern.
-            !func.def.is_unconstrained && !func.def.is_open
+            !func.def.is_unconstrained
         } else {
             func.name() == MAIN_FUNCTION
         }
     }
 
-    fn handle_function_type(&mut self, function: &FuncId) {
-        let function_type = self.interner.function_modifiers(function).contract_function_type;
-
-        if !self.in_contract && function_type == Some(ContractFunctionType::Open) {
-            let span = self.interner.function_ident(function).span();
-            self.errors.push(ResolverError::ContractFunctionTypeInNormalFunction { span });
-            self.interner.function_modifiers_mut(function).contract_function_type = None;
-        }
-    }
-
-    fn handle_is_function_internal(&mut self, function: &FuncId) {
-        if !self.in_contract {
-            if self.interner.function_modifiers(function).is_internal == Some(true) {
-                let span = self.interner.function_ident(function).span();
-                self.push_err(ResolverError::ContractFunctionInternalInNormalFunction { span });
-            }
-            self.interner.function_modifiers_mut(function).is_internal = None;
-        }
-    }
-
     fn declare_numeric_generics(&mut self, params: &[Type], return_type: &Type) {
         if self.generics.is_empty() {
             return;
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index f096c220200..3dc9d05b15e 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -664,7 +664,6 @@ pub enum Keyword {
     Let,
     Mod,
     Mut,
-    Open,
     Pub,
     Return,
     ReturnData,
@@ -706,7 +705,6 @@ impl fmt::Display for Keyword {
             Keyword::Let => write!(f, "let"),
             Keyword::Mod => write!(f, "mod"),
             Keyword::Mut => write!(f, "mut"),
-            Keyword::Open => write!(f, "open"),
             Keyword::Pub => write!(f, "pub"),
             Keyword::Return => write!(f, "return"),
             Keyword::ReturnData => write!(f, "return_data"),
@@ -751,7 +749,6 @@ impl Keyword {
             "let" => Keyword::Let,
             "mod" => Keyword::Mod,
             "mut" => Keyword::Mut,
-            "open" => Keyword::Open,
             "pub" => Keyword::Pub,
             "return" => Keyword::Return,
             "return_data" => Keyword::ReturnData,
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 800d66b0dfb..1871b594ae7 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -76,12 +76,12 @@ pub mod macros_api {
         ) -> Result<SortedModule, (MacroError, FileId)>;
 
         // TODO(#4653): generalize this function
-        fn process_unresolved_traits_impls(
+        fn process_collected_defs(
             &self,
             _crate_id: &CrateId,
             _context: &mut HirContext,
-            _unresolved_traits_impls: &[UnresolvedTraitImpl],
-            _collected_functions: &mut Vec<UnresolvedFunctions>,
+            _collected_trait_impls: &[UnresolvedTraitImpl],
+            _collected_functions: &mut [UnresolvedFunctions],
         ) -> Result<(), (MacroError, FileId)>;
 
         /// Function to manipulate the AST after type checking has been completed.
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 9d11ecd54bc..4938d33aff9 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -28,8 +28,8 @@ use crate::{
     },
     node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId},
     token::FunctionAttribute,
-    ContractFunctionType, FunctionKind, IntegerBitSize, Signedness, Type, TypeBinding,
-    TypeBindings, TypeVariable, TypeVariableKind, UnaryOp, Visibility,
+    FunctionKind, IntegerBitSize, Signedness, Type, TypeBinding, TypeBindings, TypeVariable,
+    TypeVariableKind, UnaryOp, Visibility,
 };
 
 use self::ast::{Definition, FuncId, Function, LocalId, Program};
@@ -312,8 +312,7 @@ impl<'interner> Monomorphizer<'interner> {
             Type::TraitAsType(..) => &body_return_type,
             _ => meta.return_type(),
         });
-        let unconstrained = modifiers.is_unconstrained
-            || matches!(modifiers.contract_function_type, Some(ContractFunctionType::Open));
+        let unconstrained = modifiers.is_unconstrained;
 
         let parameters = self.parameters(&meta.parameters);
         let body = self.expr(body_expr_id)?;
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index dc632527898..b83d2008530 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -28,8 +28,8 @@ use crate::hir_def::{
 };
 use crate::token::{Attributes, SecondaryAttribute};
 use crate::{
-    BinaryOpKind, ContractFunctionType, FunctionDefinition, Generics, ItemVisibility, Shared,
-    TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind,
+    BinaryOpKind, FunctionDefinition, Generics, ItemVisibility, Shared, TypeAlias, TypeBindings,
+    TypeVariable, TypeVariableId, TypeVariableKind,
 };
 
 /// An arbitrary number to limit the recursion depth when searching for trait impls.
@@ -241,15 +241,6 @@ pub struct FunctionModifiers {
     pub attributes: Attributes,
 
     pub is_unconstrained: bool,
-
-    /// This function's type in its contract.
-    /// If this function is not in a contract, this is always 'Secret'.
-    pub contract_function_type: Option<ContractFunctionType>,
-
-    /// This function's contract visibility.
-    /// If this function is internal can only be called by itself.
-    /// Will be None if not in contract.
-    pub is_internal: Option<bool>,
 }
 
 impl FunctionModifiers {
@@ -262,8 +253,6 @@ impl FunctionModifiers {
             visibility: ItemVisibility::Public,
             attributes: Attributes::empty(),
             is_unconstrained: false,
-            is_internal: None,
-            contract_function_type: None,
         }
     }
 }
@@ -759,17 +748,11 @@ impl NodeInterner {
         module: ModuleId,
         location: Location,
     ) -> DefinitionId {
-        use ContractFunctionType::*;
-
-        // We're filling in contract_function_type and is_internal now, but these will be verified
-        // later during name resolution.
         let modifiers = FunctionModifiers {
             name: function.name.0.contents.clone(),
             visibility: function.visibility,
             attributes: function.attributes.clone(),
             is_unconstrained: function.is_unconstrained,
-            contract_function_type: Some(if function.is_open { Open } else { Secret }),
-            is_internal: Some(function.is_internal),
         };
         self.push_function_definition(id, modifiers, module, location)
     }
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index a2a4577a993..06e1a958eb1 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -36,9 +36,6 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
                 name,
                 attributes,
                 is_unconstrained: modifiers.0,
-                is_open: modifiers.2,
-                // Whether a function is internal or not is now set through `aztec_macros`
-                is_internal: false,
                 visibility: modifiers.1,
                 generics,
                 parameters,
@@ -67,17 +64,14 @@ fn visibility_modifier() -> impl NoirParser<ItemVisibility> {
     choice((is_pub_crate, is_pub, is_private))
 }
 
-/// function_modifiers: 'unconstrained'? (visibility)? 'open'?
+/// function_modifiers: 'unconstrained'? (visibility)?
 ///
-/// returns (is_unconstrained, visibility, is_open) for whether each keyword was present
-fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility, bool)> {
+/// returns (is_unconstrained, visibility) for whether each keyword was present
+fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility)> {
     keyword(Keyword::Unconstrained)
         .or_not()
         .then(visibility_modifier())
-        .then(keyword(Keyword::Open).or_not())
-        .map(|((unconstrained, visibility), open)| {
-            (unconstrained.is_some(), visibility, open.is_some())
-        })
+        .map(|(unconstrained, visibility)| (unconstrained.is_some(), visibility))
 }
 
 /// non_empty_ident_list: ident ',' non_empty_ident_list
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
index df8d50178d5..1e2a6b4d65d 100644
--- a/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -120,11 +120,7 @@ pub(super) fn trait_implementation() -> impl NoirParser<TopLevelStatement> {
 
 fn trait_implementation_body() -> impl NoirParser<Vec<TraitImplItem>> {
     let function = function::function_definition(true).validate(|mut f, span, emit| {
-        if f.def().is_internal
-            || f.def().is_unconstrained
-            || f.def().is_open
-            || f.def().visibility != ItemVisibility::Private
-        {
+        if f.def().is_unconstrained || f.def().visibility != ItemVisibility::Private {
             emit(ParserError::with_reason(ParserErrorReason::TraitImplFunctionModifiers, span));
         }
         // Trait impl functions are always public
diff --git a/compiler/wasm/src/types/noir_artifact.ts b/compiler/wasm/src/types/noir_artifact.ts
index 832a6ed9bf9..935c99043da 100644
--- a/compiler/wasm/src/types/noir_artifact.ts
+++ b/compiler/wasm/src/types/noir_artifact.ts
@@ -32,19 +32,16 @@ export interface EventAbi {
   fields: ABIVariable[];
 }
 
-/** The Noir function types. */
-export type NoirFunctionType = 'Open' | 'Secret' | 'Unconstrained';
-
 /**
  * The compilation result of an Noir function.
  */
 export interface NoirFunctionEntry {
   /** The name of the function. */
   name: string;
-  /** The type of the function. */
-  function_type: NoirFunctionType;
-  /** Whether the function is internal. */
-  is_internal: boolean;
+  /** Whether the function is unconstrained. */
+  is_unconstrained: boolean;
+  /** The custom attributes applied to the function. */
+  custom_attributes: string[];
   /** The ABI of the function. */
   abi: Abi;
   /** The bytecode of the function in base64. */
diff --git a/compiler/wasm/test/fixtures/deps/lib-c/src/lib.nr b/compiler/wasm/test/fixtures/deps/lib-c/src/lib.nr
index 5c0b5a621e0..144bcec0532 100644
--- a/compiler/wasm/test/fixtures/deps/lib-c/src/lib.nr
+++ b/compiler/wasm/test/fixtures/deps/lib-c/src/lib.nr
@@ -1 +1 @@
-mod module;
\ No newline at end of file
+mod module;
diff --git a/compiler/wasm/test/fixtures/deps/lib-c/src/module.nr b/compiler/wasm/test/fixtures/deps/lib-c/src/module.nr
index 2746c97edf0..f4ad3bff5c9 100644
--- a/compiler/wasm/test/fixtures/deps/lib-c/src/module.nr
+++ b/compiler/wasm/test/fixtures/deps/lib-c/src/module.nr
@@ -1 +1 @@
-mod foo;
\ No newline at end of file
+mod foo;
diff --git a/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr b/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr
index e0c82fb1960..0376cd4cb87 100644
--- a/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr
+++ b/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr
@@ -1,3 +1,3 @@
 pub fn bar(param: Field) -> Field {
-  dep::std::hash::pedersen_hash([param])
+    dep::std::hash::pedersen_hash([param])
 }
diff --git a/compiler/wasm/test/fixtures/noir-contract/src/main.nr b/compiler/wasm/test/fixtures/noir-contract/src/main.nr
index b980af369cf..fc1dc8a5a17 100644
--- a/compiler/wasm/test/fixtures/noir-contract/src/main.nr
+++ b/compiler/wasm/test/fixtures/noir-contract/src/main.nr
@@ -5,8 +5,7 @@ contract TestContract {
         [foo::bar(param), param + pub_param]
     }
 
-    open fn openFunction() -> pub Field {
+    fn someFunction() -> pub Field {
         42
     }
-
 }
diff --git a/docs/scripts/codegen_nargo_reference.sh b/docs/scripts/codegen_nargo_reference.sh
index 4ff7d43d142..6a9fda9420b 100755
--- a/docs/scripts/codegen_nargo_reference.sh
+++ b/docs/scripts/codegen_nargo_reference.sh
@@ -30,4 +30,4 @@ sidebar_position: 0
 ---
 " > $NARGO_REFERENCE
 
-cargo run -F codegen-docs -- info >> $NARGO_REFERENCE
+cargo run --bin nargo -F codegen-docs -- info >> $NARGO_REFERENCE
diff --git a/test_programs/compile_failure/assert_msg_runtime/src/main.nr b/test_programs/compile_failure/assert_msg_runtime/src/main.nr
index bec3082550a..fa21442e816 100644
--- a/test_programs/compile_failure/assert_msg_runtime/src/main.nr
+++ b/test_programs/compile_failure/assert_msg_runtime/src/main.nr
@@ -4,4 +4,4 @@ fn main(x: Field, y: pub Field) {
     let z = x + y;
     assert(z != y, f"Expected z != y, but got both equal {z}");
     assert_eq(x, y, f"Expected x == y, but x is {x} and y is {y}");
-}
\ No newline at end of file
+}
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr b/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr
index 428b2006363..bd77551e304 100644
--- a/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr
+++ b/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr
@@ -7,4 +7,4 @@ unconstrained fn conditional(x: Field) -> Field {
     assert_eq(z, 25, f"Expected 25 but got {z}");
     assert(x == 10, f"Expected x to equal 10, but got {x}");
     1
-}
\ No newline at end of file
+}
diff --git a/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr b/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
index cf3279cac0d..473ad8e8d6a 100644
--- a/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
+++ b/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
@@ -5,4 +5,4 @@ unconstrained fn mut_ref_identity(value: &mut Field) -> Field {
 fn main(mut x: Field, y: pub Field) {
     let returned_x = mut_ref_identity(&mut x);
     assert(returned_x == x);
-}
\ No newline at end of file
+}
diff --git a/test_programs/compile_success_contract/contract_with_impl/src/main.nr b/test_programs/compile_success_contract/contract_with_impl/src/main.nr
index ddcb5d54d78..1c6b6c217c4 100644
--- a/test_programs/compile_success_contract/contract_with_impl/src/main.nr
+++ b/test_programs/compile_success_contract/contract_with_impl/src/main.nr
@@ -2,6 +2,6 @@ contract Foo {
     struct T { x: [Field] }
 
     impl T {
-        fn t(self){}
+        fn t(self) {}
     }
 }
diff --git a/test_programs/compile_success_contract/simple_contract/src/main.nr b/test_programs/compile_success_contract/simple_contract/src/main.nr
index ed90ac8bd1d..7412e1386bf 100644
--- a/test_programs/compile_success_contract/simple_contract/src/main.nr
+++ b/test_programs/compile_success_contract/simple_contract/src/main.nr
@@ -8,12 +8,9 @@ contract Foo {
     fn quadruple(x: Field) -> pub Field {
         x * 4
     }
-    open fn skibbidy(x: Field) -> pub Field {
-        x * 5
-    }
     // Regression for issue #3344
     #[contract_library_method]
-    fn foo(x : u8) -> u8 {
+    fn foo(x: u8) -> u8 {
         x
     }
 }
diff --git a/test_programs/execution_success/brillig_cow_regression/src/main.nr b/test_programs/execution_success/brillig_cow_regression/src/main.nr
index ba51548d9dd..1cae9b1ba41 100644
--- a/test_programs/execution_success/brillig_cow_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_regression/src/main.nr
@@ -8,9 +8,9 @@ global MAX_NEW_CONTRACTS_PER_TX: u64 = 1;
 global NUM_ENCRYPTED_LOGS_HASHES_PER_TX: u64 = 1;
 global NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: u64 = 1;
 global NUM_FIELDS_PER_SHA256 = 2;
-global CALLDATA_HASH_INPUT_SIZE = 169;
-global CALL_DATA_HASH_LOG_FIELDS = 4;
-global CALL_DATA_HASH_FULL_FIELDS = 165;
+global TX_EFFECT_HASH_INPUT_SIZE = 169;
+global TX_EFFECT_HASH_LOG_FIELDS = 4;
+global TX_EFFECT_HASH_FULL_FIELDS = 165;
 
 struct PublicDataUpdateRequest {
     leaf_slot : Field,
@@ -99,7 +99,7 @@ impl U256 {
 }
 
 unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA256] {
-    let mut calldata_hash_inputs = [0; CALLDATA_HASH_INPUT_SIZE];
+    let mut tx_effects_hash_inputs = [0; TX_EFFECT_HASH_INPUT_SIZE];
 
     let new_note_hashes = kernel_data.new_note_hashes;
     let new_nullifiers = kernel_data.new_nullifiers;
@@ -111,65 +111,65 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA
     let mut offset = 0;
 
     for j in 0..MAX_NEW_NOTE_HASHES_PER_TX {
-        calldata_hash_inputs[offset + j] = new_note_hashes[j];
+        tx_effects_hash_inputs[offset + j] = new_note_hashes[j];
     }
     offset += MAX_NEW_NOTE_HASHES_PER_TX ;
 
     for j in 0..MAX_NEW_NULLIFIERS_PER_TX {
-        calldata_hash_inputs[offset + j] = new_nullifiers[j];
+        tx_effects_hash_inputs[offset + j] = new_nullifiers[j];
     }
     offset += MAX_NEW_NULLIFIERS_PER_TX ;
 
     for j in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX {
-        calldata_hash_inputs[offset + j * 2] =
+        tx_effects_hash_inputs[offset + j * 2] =
                 public_data_update_requests[j].leaf_slot;
-        calldata_hash_inputs[offset + j * 2 + 1] =
+        tx_effects_hash_inputs[offset + j * 2 + 1] =
                 public_data_update_requests[j].new_value;
     }
     offset += MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX * 2;
 
     for j in 0..MAX_NEW_L2_TO_L1_MSGS_PER_TX {
-        calldata_hash_inputs[offset + j] = newL2ToL1msgs[j];
+        tx_effects_hash_inputs[offset + j] = newL2ToL1msgs[j];
     }
     offset += MAX_NEW_L2_TO_L1_MSGS_PER_TX;
 
     let contract_leaf = kernel_data.new_contracts[0];
-    calldata_hash_inputs[offset] = contract_leaf.hash();
+    tx_effects_hash_inputs[offset] = contract_leaf.hash();
 
     offset += MAX_NEW_CONTRACTS_PER_TX;
 
     let new_contracts = kernel_data.new_contracts;
-    calldata_hash_inputs[offset] = new_contracts[0].contract_address;
+    tx_effects_hash_inputs[offset] = new_contracts[0].contract_address;
 
-    calldata_hash_inputs[offset + 1] = new_contracts[0].portal_contract_address;
+    tx_effects_hash_inputs[offset + 1] = new_contracts[0].portal_contract_address;
 
     offset += MAX_NEW_CONTRACTS_PER_TX * 2;
 
     for j in 0..NUM_FIELDS_PER_SHA256 {
-        calldata_hash_inputs[offset + j] = encryptedLogsHash[j];
+        tx_effects_hash_inputs[offset + j] = encryptedLogsHash[j];
     }
 
     offset += NUM_ENCRYPTED_LOGS_HASHES_PER_TX * NUM_FIELDS_PER_SHA256;
 
     for j in 0..NUM_FIELDS_PER_SHA256 {
-        calldata_hash_inputs[offset + j] = unencryptedLogsHash[j];
+        tx_effects_hash_inputs[offset + j] = unencryptedLogsHash[j];
     }
 
     offset += NUM_UNENCRYPTED_LOGS_HASHES_PER_TX * NUM_FIELDS_PER_SHA256;
-    assert_eq(offset, CALLDATA_HASH_INPUT_SIZE); // Sanity check
+    assert_eq(offset, TX_EFFECT_HASH_INPUT_SIZE); // Sanity check
 
-    let mut hash_input_flattened = [0; CALL_DATA_HASH_FULL_FIELDS * 32 + CALL_DATA_HASH_LOG_FIELDS * 16];
-    for offset in 0..CALL_DATA_HASH_FULL_FIELDS {
-        let input_as_bytes = calldata_hash_inputs[offset].to_be_bytes(32);
+    let mut hash_input_flattened = [0; TX_EFFECT_HASH_FULL_FIELDS * 32 + TX_EFFECT_HASH_LOG_FIELDS * 16];
+    for offset in 0..TX_EFFECT_HASH_FULL_FIELDS {
+        let input_as_bytes = tx_effects_hash_inputs[offset].to_be_bytes(32);
         for byte_index in 0..32 {
             hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];
         }
     }
 
-    for log_field_index in 0..CALL_DATA_HASH_LOG_FIELDS {
-        let input_as_bytes = calldata_hash_inputs[CALL_DATA_HASH_FULL_FIELDS + log_field_index].to_be_bytes(16);
+    for log_field_index in 0..TX_EFFECT_HASH_LOG_FIELDS {
+        let input_as_bytes = tx_effects_hash_inputs[TX_EFFECT_HASH_FULL_FIELDS + log_field_index].to_be_bytes(16);
         for byte_index in 0..16 {
-            hash_input_flattened[CALL_DATA_HASH_FULL_FIELDS * 32 + log_field_index * 16 + byte_index] = input_as_bytes[byte_index];
+            hash_input_flattened[TX_EFFECT_HASH_FULL_FIELDS * 32 + log_field_index * 16 + byte_index] = input_as_bytes[byte_index];
         }
     }
 
diff --git a/test_programs/execution_success/double_verify_proof/Nargo.toml b/test_programs/execution_success/double_verify_proof/Nargo.toml
index a4edd2e4288..c5954f54bdb 100644
--- a/test_programs/execution_success/double_verify_proof/Nargo.toml
+++ b/test_programs/execution_success/double_verify_proof/Nargo.toml
@@ -2,4 +2,6 @@
 name = "double_verify_proof"
 type = "bin"
 authors = [""]
-[dependencies]
+compiler_version = ">=0.24.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/double_verify_proof/src/main.nr b/test_programs/execution_success/double_verify_proof/src/main.nr
index e4c6926efbc..4edf5c5af9f 100644
--- a/test_programs/execution_success/double_verify_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof/src/main.nr
@@ -1,6 +1,5 @@
 use dep::std;
 
-#[recursive]
 fn main(
     verification_key: [Field; 114],
     // This is the proof without public inputs attached.
diff --git a/test_programs/execution_success/double_verify_proof_recursive/Nargo.toml b/test_programs/execution_success/double_verify_proof_recursive/Nargo.toml
new file mode 100644
index 00000000000..b7688b33bfd
--- /dev/null
+++ b/test_programs/execution_success/double_verify_proof_recursive/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "double_verify_proof_recursive"
+type = "bin"
+authors = [""]
+[dependencies]
diff --git a/test_programs/execution_success/double_verify_proof_recursive/Prover.toml b/test_programs/execution_success/double_verify_proof_recursive/Prover.toml
new file mode 100644
index 00000000000..dff48212e50
--- /dev/null
+++ b/test_programs/execution_success/double_verify_proof_recursive/Prover.toml
@@ -0,0 +1,5 @@
+key_hash = "0x096129b1c6e108252fc5c829c4cc9b7e8f0d1fd9f29c2532b563d6396645e08f"
+proof = ["0x000000000000000000000000000000d62b795bec274279129a71195796825fcc","0x00000000000000000000000000000000000793ab763140f20a68a6bd2721fd74","0x00000000000000000000000000000053141d06d3307b36153f321511199e579c","0x00000000000000000000000000000000000a4b55d6c21f98a9c434911dcb5c67","0x0000000000000000000000000000005f9d324c0abd22cec92d99dbec438e9491","0x0000000000000000000000000000000000240dfafe1b53dc27147cbab14ea893","0x000000000000000000000000000000044a61d3aac32c6931247cf334a19d9611","0x000000000000000000000000000000000003f0f8cf4207bfa85c23ec9f8d0c88","0x00000000000000000000000000000002168a470e39ba2ac266f6b474de12045f","0x000000000000000000000000000000000025791e7d3feab542345c00ec5a30df","0x000000000000000000000000000000dcafd76d4c3640969c80e017b951ef6397","0x00000000000000000000000000000000001d27f75a1256771e88e0c86fc42dbc","0x0000000000000000000000000000007347ae7d2d9d7fc2b8f0baa014ee1fed9f","0x000000000000000000000000000000000018bd927f42bf7caf9555f56f09000d","0x000000000000000000000000000000041f765f83cbe5904c8f453f70a4531d10","0x00000000000000000000000000000000001858aabeeb5331a221419f4fed1c19","0x000000000000000000000000000000d254a54caaedf8287b9af951b2f2611121","0x000000000000000000000000000000000005ab493623c9563cf2e55ba5f18200","0x00000000000000000000000000000014f24cddc1a02440dc63637df8032c8074","0x000000000000000000000000000000000011950c16cef98471b1d78b935195a4","0x000000000000000000000000000000b0340b459e6bd5cc8f031c8654a502897f","0x00000000000000000000000000000000000e1cf3968dac4545a76a2ae58e512c","0x0000000000000000000000000000002adf7218aa06ca0d2c2e600dcc39193a2d","0x00000000000000000000000000000000001302e7e4b0f14749bd885ca25588b6","0x00000000000000000000000000000092009ce4056e79ab815d8cdfd4491138ae","0x000000000000000000000000000000000018af11e853c6cf2f0f6274b0da8133","0x000000000000000000000000000000dd3dc6f49232141718527b3a0e4b26e21d","0x00000000000000000000000000000000001a877853348a8b695c4f9a9aa4ce68","0x000000000000000000000000000000aecfc56ba07155450b368140d6324023b5","0x000000000000000000000000000000000029c11052798c57ece614617d33fcc2","0x000000000000000000000000000000eb106ffc816d16fb84e84b0b61157b2603","0x000000000000000000000000000000000026c3cac16206899a21cb5126841446","0x000000000000000000000000000000a782ed54805fe845068b362b58e2fa34ec","0x00000000000000000000000000000000000cf046a1bfcc666b7f28b572676073","0x000000000000000000000000000000b931c8dda60bb4aca4cc817f5540f1209f","0x000000000000000000000000000000000024ad50c3936fafc3d190e6a4874223","0x000000000000000000000000000000cce90cfbaf5671c8c8652db28a3a9566f7","0x000000000000000000000000000000000003574db9d0f84380c9635660f86354","0x0000000000000000000000000000003eb3e1dc31846a90f721e7a08c6d6dc4f7","0x000000000000000000000000000000000028999a700cd1abae1a288eebb9a91c","0x000000000000000000000000000000c1be4d385b11387e14eb9817050d772f78","0x000000000000000000000000000000000003c56b5bad8b4484c66ac921f1f102","0x000000000000000000000000000000ace245cabf0f00dc7fd253dd8af0377a14","0x0000000000000000000000000000000000107f1731fcf34b364c813599fa1df7","0x035b937d404932b542b706eb810ef4a7dca4566d4dde1ad6a8717f46167ead7e","0x17608cef3dc7960f41cb1295706df663727d45ee598a61e05e989d111449fb65","0x054712a950ad67da3aa860e49e6891f99b586b7f37caff94eb013fdb374b61ee","0x04b755083086c769b7f593e0e48d68dc54be808203351380ca5566a48149d8bb","0x17d7670b0915235f626fdc1d7e1134d2be906ef138d7843384b3ebc23b1d630f","0x064cf544ab5f4e3dab47960502cccc83321fb275068dfbdd3a2fcbc6dddcaa65","0x083338262712e2b66769ea40d9f412b18caa1bc81a51ff5a50b6c41f8c4b3d23","0x0cdd38958cab97defde00f4a5961b6fd676e29d9f2c352f6bb2c68b91f83f8af","0x02c8bdd005c2f43a0a8cbb2744916ce5c322dfa5b23367a829c12699f4036d32","0x25bac73c7e7b659fbea3135b7a0decf9db8dc3045bd2837dae337c64cc722546","0x19eb361aa419d37bce3d2e8b2b7692a02a9559e83d7f3d8fe9169970fbbc2cba","0x2494bd5106d00e05c7ea60e632e9fe03773b7f2c5b662aa37ec512a01f4a0775","0x18c52c2f2c6e7be1d7847c15e452a3a9c64316103d12e4b5b9a82fac4e940ee9","0x0e0342810456ef78f498c1bfa085a5f3cbc06db1f32fabd0ea9ad27dccac1680","0x024c13d6ef56af33ed7164ea8e47ddecc8a487b000d8b1b45edcd3895a503ba2","0x26e0d127f626bd39b55bc5d0c131dbf03fe006dc5c3edc57dda1e629799a4317","0x1b1140061bc52b15c4f5e100729a81968ee79dc03deb966a18850335a8e44a8b","0x1bb76f945199e71d531a89288912087a02dd0e83020e65d671485bf2e5e86e1a","0x29269900859c6d86e404185b415bf3b279cd100f38cfdb0077e8d6a299c4fd35","0x22b5e94bae2f6f0cdb424a3b12c4bf82cec3fb228e012c1974ed457827bbe012","0x18d3543a93249778e7a57936170dae85ffc47c2567f2d0076a32c0bb86fcf10a","0x03721dc2670206cde42a175fd56bcce32cf6cb8801450a8e8e4b3d4e07785973","0x2806db136dd214d3ac1478460855cae6a4324ab45cab35320d104fee26c260e8","0x1c3749f1937082afbbae9375b9be708cf339e1983e57ef4447f36cfa560c685c","0x1067b8cfb90ef08bcb48aea56b2716334241787c2004a95682d68a0685566fd0","0x0f41aee4416398f1d48ffc302403273cddef34a41f98507c53682041d82e51ff","0x10d854c9f0bfbdff7ca91a68f4978e9a79e7b14243d92f465f17bdf88d9f64f8","0x00000000000000000000000000000000018938b11099e0cdc05ddab84a153a97","0x0000000000000000000000000000000001d7dda1471f0dc3b3a3d3438c197982","0x00000000000000000000000000000000022682917da43ab9a6e9cbcece1db86d","0x2453913e6b0f36eab883ac4b0e0604d56aaeb9c55e641135173e63c342f1a660","0x05216c1b58dc43a49d01aaba3113b0e86be450fc17d28016e648e7162a1b67fb","0x152b34845a0222a2b41354c0d395a250d8363dc18748647d85acd89d6934ec56","0x1dfc6e971ce82b7dcda1f7f282713c6e22a8c79258a61209bda69719806da544","0x2968dd8b3af8e3953f1fbbd72f4c49b8270597bb27d4037adc157ac6083bee60","0x1b9425b88a4c7d39b3d75afe66917a9aa1d2055724392bc01fb918d84ff1410e","0x04ab571f236d8e750904dc307dd274003d9130f1a7110e4c1521cfb408877c73","0x2ad84f26fdc5831545272d02b806bb0e6dae44e71f73552c4eb9ff06030748c7","0x020e632b99d325db774b8630fb50b9a4e74d35b7f27d9fc02c65087ee747e42c","0x09a8c5a3171268cb61c02515c01c109889200ed13f415ae54df2078bbb887f92","0x1143281a9451abbb4c34c3fa84e7678c2af2e7ea8c05160a6f7f06988fc91af8","0x000000000000000000000000000000cbda736ca5cf6bc75413c2cc9e28ab0a68","0x00000000000000000000000000000000001ee78c9cc56aa5991062ae2e338587","0x000000000000000000000000000000bc9bfcdebb486f4cb314e681d2cc5f8df6","0x00000000000000000000000000000000000ad538431d04771bca7f633cb659ff","0x000000000000000000000000000000d45b317afcefa466a59bba9e171f1af70c","0x0000000000000000000000000000000000133c50180ea17932e4881124e7a7c6","0x000000000000000000000000000000fc9ed37f543775849f3e84eaa06f77f992","0x00000000000000000000000000000000001372873c9c051d1baff99248b8f70e"]
+public_inputs = ["0x0000000000000000000000000000000000000000000000000000000000000003"]
+verification_key = ["0x2b337de1c8c14f22ec9b9e2f96afef3652627366f8170a0a948dad4ac1bd5e80","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000005","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x00000000000000000000000000000092139c61bae1a44f0fc7689507414be688","0x00000000000000000000000000000000000160ce4e279582f91bde4f03f5e9a2","0x0000000000000000000000000000005dc2d37f658c3b2d60f24740eb13b65d79","0x000000000000000000000000000000000007e3e8a5d98a1177ec85bf88f163a5","0x000000000000000000000000000000dc3035fbd7ff16412a8fd7da587a935298","0x000000000000000000000000000000000023d08e2817ac16990004ed11d8fc66","0x000000000000000000000000000000356a5ad59c646c746a8d09f5d154e47c4f","0x00000000000000000000000000000000000708529196af3c8e16ffa580c26182","0x0000000000000000000000000000002ddfe70eb7a1280596e8e4a804f118a6dd","0x000000000000000000000000000000000013757e15a0905f298303784a161b21","0x000000000000000000000000000000a23a729df796935c7824e3a26be794829b","0x000000000000000000000000000000000005775b6c146c4a59856e869fe5a70e","0x000000000000000000000000000000eef0c9e088fd2d45aa40311082d1f2809b","0x00000000000000000000000000000000001d539ccbfc556d0ad59307a218de65","0x000000000000000000000000000000a2c848beceb6ab7806fd3b88037b8410fc","0x0000000000000000000000000000000000177004deeb1f9d401fd7b1af1a5ac8","0x0000000000000000000000000000002508eb63672a733f20de1a97644be4f540","0x00000000000000000000000000000000000d82d51f2f75d806285fd248c819b8","0x000000000000000000000000000000d002f9100cbba8a29f13b11513c53c59d0","0x000000000000000000000000000000000006cd3b0e3460533b9e5ea2cdc0fcbb","0x000000000000000000000000000000f45ea38a93b2f810c5633ddb54927c1c96","0x000000000000000000000000000000000021791de65f9a28ec7024b1a87ab4f3","0x000000000000000000000000000000926511a0439502c86885a8c6f0327aa7ad","0x000000000000000000000000000000000029fa14a969c5d81ed3abbbfb11220a","0x000000000000000000000000000000b84c3258e8206f560e5b5b18cbeafef87e","0x00000000000000000000000000000000002a910445cd8fc895e5d235cd8ea185","0x000000000000000000000000000000887e67f15e84bcb8507a5064a363f6043b","0x000000000000000000000000000000000014dc6643d801c3ef27c2066b6e2bb4","0x000000000000000000000000000000e38e900b42c314ba803088e8fbf125203f","0x000000000000000000000000000000000020690fd4869db418306046b38161dc","0x0000000000000000000000000000001e2fa856bf7951b8292b1e88185993629c","0x0000000000000000000000000000000000048a85e0bbac7c60ad3d78f601f63c","0x0000000000000000000000000000006f457719495073d3666d77a625aeab0c51","0x00000000000000000000000000000000002623ad892dc62b1fa7d0a650f0d470","0x000000000000000000000000000000dbfcc8a467e021c03b13f74a9f79c3a10c","0x0000000000000000000000000000000000295f6f10976c37bd9c6f96bb7187d5","0x000000000000000000000000000000c13ef9a937cc12420fb38d9ab8e848e85e","0x000000000000000000000000000000000003560a3b334e887532f605c9cb7628","0x0000000000000000000000000000009bcebf08a4599cdda0fb96312d4dc0c7a9","0x000000000000000000000000000000000015adc8bb1e01c835f48959d1237bd6","0x00000000000000000000000000000047762ab839e4ff63c77605a9f383da37c2","0x000000000000000000000000000000000016a8c3c53d89660cf271522cd301fb","0x000000000000000000000000000000f0c8539a0b5f94420a513f9c305b932bfe","0x00000000000000000000000000000000002957ba01d9de5638f808f88a692533","0x000000000000000000000000000000ab17c6189d67d3bf5dd2f3885de0151b6f","0x0000000000000000000000000000000000060d8aa43fdc434d1942263f364d95","0x0000000000000000000000000000005d292333b3adb497f00b4bc32d45229060","0x00000000000000000000000000000000001a1018a66221883639f2898a66f345","0x00000000000000000000000000000006555a806b1993291deba0dc44e2abf431","0x00000000000000000000000000000000000cacff7099a9d5e35a21f4a00b2dc3","0x000000000000000000000000000000f50c11ba95d349c36d143eefd12e494950","0x00000000000000000000000000000000001022e8c5f02d639bc9dd8bc4407f99","0x000000000000000000000000000000c76828795098eda73d50b4b585c60afc60","0x00000000000000000000000000000000002bf09c0ec7011e93888962f2406630","0x00000000000000000000000000000049e5c83a8978d832fb8e144548e3ca1adb","0x00000000000000000000000000000000000e0ec242c2e160a984f61ca5adf5f5","0x0000000000000000000000000000009c5d6e08a6605ab4513748ac0fa017dd1c","0x00000000000000000000000000000000001f54baa07558e5fb055bd9ba49c067","0x0000000000000000000000000000001e1ee7ee29bbb5e4b080c6091c1433ce62","0x000000000000000000000000000000000024aec62a9d9763499267dc98c33428","0x0000000000000000000000000000001a96755946ff16f0d6632365f0eb0ab4d4","0x000000000000000000000000000000000028cf3e22bcd53782ebc3e0490e27e5","0x00000000000000000000000000000043148d7d8c9ba43f2133fab4201435a364","0x0000000000000000000000000000000000234ce541f1f5117dd404cfaf01a229","0x000000000000000000000000000000a7fb95ffb461d9514a1070e2d2403982ef","0x00000000000000000000000000000000003016955028b6390f446c3fd0c5b424","0x00000000000000000000000000000008863c3b7cd7cddc20ba79ce915051c56e","0x000000000000000000000000000000000013ef666111b0be56a235983d397d2a","0x000000000000000000000000000000e3993f465fc9f56e93ac769e597b752c1c","0x0000000000000000000000000000000000217f7c4235161e9a3c16c45b6ca499","0x0000000000000000000000000000008ffa4cd96bc67b0b7df5678271e1114075","0x0000000000000000000000000000000000256467bfcb63d9fdcb5dde397757ad","0x00000000000000000000000000000054e5eb270bb64bde6e6ececadfd8c3236c","0x00000000000000000000000000000000000e52d1bd75812c33c6f3d79ee4b94c","0x000000000000000000000000000000484a2c641dce55bc2dd64ef0cd790a7fea","0x00000000000000000000000000000000000ff417d256be43e73c8b1aa85bdda3","0x0000000000000000000000000000000b72e7b7713ab5da44e0f864182e748a23","0x00000000000000000000000000000000001a221055f1625ad833a44705f5f74e","0x00000000000000000000000000000067a99a34e9b81a17ad001db02e29bcb82a","0x000000000000000000000000000000000018a6c02e398389827568fa960e86e2","0x000000000000000000000000000000bb29f26f9890d6cc6401f4921d5884edca","0x00000000000000000000000000000000000868357b28039385c5a5058b6d358e","0x00000000000000000000000000000036fb6e229dde8edf7ec858b12d7e8be485","0x00000000000000000000000000000000001060afe929554ca473103f5e68193c","0x00000000000000000000000000000015226e07e207744c0857074dcab883af4a","0x00000000000000000000000000000000000b1c02619282755533457230b19b4a","0x0000000000000000000000000000001f2a0277e4807e6e1cbabca21dde5eb5e1","0x00000000000000000000000000000000000d928deafed363659688ed4ccdef52","0x000000000000000000000000000000363f0c994e91cecad25835338edee2294f","0x00000000000000000000000000000000002eea648c8732596b1314fe2a4d2f05","0x000000000000000000000000000000b2671d2ae51d31c1210433c3972bb64578","0x00000000000000000000000000000000000ab49886c2b94bd0bd3f6ed1dbbe2c"]
+proof_b = ["0x000000000000000000000000000000f05c69448ca29bdf52076f9b073bb30fed","0x000000000000000000000000000000000028c86bb3e27b4aaaaef126f7df5349","0x00000000000000000000000000000026ae031fc93594375dfc7f3bbe027f97d5","0x000000000000000000000000000000000000dd12c7290fe7f775796a233b8590","0x000000000000000000000000000000c1ee6631704de424d010c5c4ac8293ac49","0x00000000000000000000000000000000002f41818c9aa83f5c8d9bdd128015b9","0x000000000000000000000000000000b50a5801482f7e3a5de8ab3cce0f10b0d3","0x000000000000000000000000000000000022a0bc69c293dbf293b25bc9eef7f8","0x0000000000000000000000000000003b02abf1967ef394154dc15d763135e903","0x00000000000000000000000000000000000d8a2ee46acc6d1ed8d517b56d47c8","0x00000000000000000000000000000039bf0d1b3d8cf9de898f101c626e978d78","0x0000000000000000000000000000000000008faa7df2451a24d291a9b584f1a5","0x000000000000000000000000000000c1dae329ed7adf63a2d89a5f16fb98b6d8","0x00000000000000000000000000000000001ff0bc16fc0bd4aa2d6255690453c2","0x000000000000000000000000000000d12d7589f853a9b472613efa56689beaf1","0x00000000000000000000000000000000002d6fbc798f4403751df6aeee8bedd3","0x0000000000000000000000000000007c1fa069cb17194fecf88db9dd54a4ee36","0x0000000000000000000000000000000000268e026f9814822a42b2d59eec5d24","0x000000000000000000000000000000c3fb56beab774218cd63498fc050a5fd9b","0x00000000000000000000000000000000000071c014d7b5063f005a0bc2ee1af4","0x000000000000000000000000000000ae12b25371c6af42bbe0a85cddd2eaebc7","0x000000000000000000000000000000000026d270e1ffc9c7c344c694dfadda83","0x00000000000000000000000000000080280858c6be461716921caa3c26f3f6f3","0x000000000000000000000000000000000001dcdd3f39e27d0ce6aa5d14dff4c1","0x000000000000000000000000000000080e1d2c913c834ebcf7e0600c076c08fd","0x00000000000000000000000000000000002df3d142217694e65fb7c355d62764","0x000000000000000000000000000000e5e336f3f59d77e500f49771bfbeb12e83","0x000000000000000000000000000000000028fffe08bdc4c0690643d2e1a1275f","0x000000000000000000000000000000db5618b32afc13e18f21b39f3fbede9d11","0x00000000000000000000000000000000001d244818370d43fb7e8bc67e03787b","0x0000000000000000000000000000006bcc1fd3f9f78449ad1df1bc11bc379edd","0x000000000000000000000000000000000009ac9cbb285edbf5b3a973f3f5f1cb","0x000000000000000000000000000000fd885905b6c0fc95bb4dd0b11f6797d4b3","0x000000000000000000000000000000000021f07995cdd835145e19c38127c562","0x000000000000000000000000000000bbbf2b975c2c97ae4b45c4a52059e53ee3","0x000000000000000000000000000000000024158163788841cf4590bbc1e89a90","0x0000000000000000000000000000009aca93d2b1386ea412d4b36ea5bb9894a8","0x00000000000000000000000000000000002532d1d210e8ed4c2f5c00cbaaa475","0x000000000000000000000000000000634a88caa1d77cb6b5fe77cac31458fc31","0x00000000000000000000000000000000000bdf18bae92fce7cfddab5520cac6e","0x000000000000000000000000000000622e9626255170ccec77602c755aa193e1","0x000000000000000000000000000000000001d4edba370e04436a988bad05dada","0x000000000000000000000000000000b52934323a0aec8f803cdaafee2ab7bfb2","0x0000000000000000000000000000000000155312af5e0e25ca9fd61aef9e58ed","0x06270b517855f6f6a608e432883d1d1030a12a1e33022dc142b7728691421da2","0x2af7c794d7b720b25eb1df0afd8c8e3c15b6e518194c3caea7966a5f8210ff04","0x073fe573aeb27d81a5713be93e1365390dcbc3c8e7439ff1d36a84cc014f5642","0x11351b961147431e54535248b58b35cf5cddb9b13827899167617d7a96794d64","0x297c9421c9c3db286770787c35b86bc41583386491b4ae55e5fa81aefa21efc4","0x0f4eeca3ff4a3495f859898937688652d33f9b4dd3e003e12adf15278e0997c3","0x133e3d8b82721d40d919f2326810ba6f07eff3f7d20d86b2bde692a811522019","0x2c502f53c9698b73bb8c8f9b9cf2d705d16a64a7040348b4b39c637a2064316c","0x0cbc1971e1c566cde9d9125c91cdc88e817db182692f836c1a5170a6246eaf73","0x12c47793e7db706c637cd4b4d96d227f569850176b852b1fe8ad522ddb38ef0e","0x0cd7b300e9309a135285be1aeb02b152f97931a7357ab6d609a2cb1970aab877","0x2a7789dfe286c9d0a7592f1c9316e730cb14c9d843aefc4764d76e7f8571c96a","0x248ac54ce3dbf37796621882a4ac76046df5ab680da487fd85cce76b1ae392d3","0x149d1d07cebe320f77b03533e34912545cedeae62bd9778d37724728762b5710","0x00fe29daebdaed61309790e70e2dcefa3f3af4c6c965ce424b8dbcf09b8e4b49","0x2b75b3bace61b731d7f0c003a144b62b0a4fbe9f0d14ca89b0652b70210014b3","0x2588ef27cfb6e0d8c6f9a969b2da44fead30a02ed70a563fd15aa45bb671de1c","0x2b74d7674b55642697b4a1e226eddb0e4918b2d57aa5b99093dc46cadcdea000","0x244c626845d3a5040f08f01e9611f968ad675ca857789149b13a0cfa83a2e064","0x2cb8d02f90cae33fd7bcfb80af4aff067c4f5fc4b3f9228d5b8f768bc8f6c971","0x1372f3d1f04e0c39a50e823d5da03d70bebe19a1b8e28f8c2ff601cc0bfc0095","0x19af6601d2613426a50b7c35d60562a5f2f2634e6af56dac13459632e15570ee","0x13c2a16ed3b65dcd9414659be79af17995d344de34eaf962343b0f1e76c73a57","0x0dd5dcdbd50b8774831d4f01f930804d38b4266dfee085185530880a0c3903c0","0x07e91848d660b11b722638680ac60f20db9507fdc8d610ce762600f5a1aacd29","0x1f9c2a94d10c0a7fb60292cfc46fd3d2501181bea0ffe1f5f2501d474be3a785","0x14edb9c5bd389eae08a5ea2a7a1662894e1e878c142084d966a625bef68cf7c3","0x00000000000000000000000000000000cecd01810814d175f0a533f0067618c4","0x00000000000000000000000000000000f82935013ce5c82720c63e533af41db8","0x000000000000000000000000000000012185688171b6bed850e748b66f7222ac","0x2dd7f5ff2150155c2ac86ebe28d9ecbca2eea812b0021ab2bceae111cfea8325","0x04ea6c2daf2b9e827d2213c3d03953410dcf1ed67ba34a3c00e772be92606a8b","0x163f2bd18dcde52f99b9867c944780fd718d1612927053b139b280fc55013d1b","0x05e388fd160ccac30a8f7b18a4bd042f705e92b5937e8c0e9478e2ff623907c6","0x00ba3f6f527d6ed3ff17a63b1d5be3c42bdfae88fdf63311fc7b871157939309","0x16187d9daa8c2e5a1a9ab15be7ca6a8feebfb31bea76f9a3ca69381881c70561","0x0f64522e4904edb7377b14a7b9dad848829167324ef5c016346b3ad8251191ee","0x273bbe6000a4001dce369e5a36cc0b0ca3fd351665b688238aa8c556a6ca6b8e","0x022d2232efb2faa8307846c9a4c697aabad1b7f1336b35ad72fa8922975b49d9","0x0d82d478bff3955c4b0a34ef94427ca5f9da23147ad953c89f2e428277ec2825","0x18d886be90343010659c231583be61a138e28e37c24771e3cb61fbe2587d0671","0x000000000000000000000000000000196ba6a58dbeb7c34cb1d6287e23d434de","0x00000000000000000000000000000000001df8ae8a1589590f8863c1fefd8dfd","0x000000000000000000000000000000f30e11b2c5fbefa166cbb9f58c5f8e1a4c","0x000000000000000000000000000000000026420ade7666bc0ab1cf1fd9d0c534","0x0000000000000000000000000000000feb5b7d8260d25a1ee1ce76ff461673fc","0x00000000000000000000000000000000002bd2ac6223a80671b777bf5dca70a4","0x000000000000000000000000000000690f757006d2fa1ddb0114c9f268783537","0x000000000000000000000000000000000023ad36feadd91e50118f32e97a0204"]
\ No newline at end of file
diff --git a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
new file mode 100644
index 00000000000..e4c6926efbc
--- /dev/null
+++ b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
@@ -0,0 +1,29 @@
+use dep::std;
+
+#[recursive]
+fn main(
+    verification_key: [Field; 114],
+    // This is the proof without public inputs attached.
+    // 
+    // This means: the size of this does not change with the number of public inputs.
+    proof: [Field; 93],
+    public_inputs: pub [Field; 1],
+    // This is currently not public. It is fine given that the vk is a part of the circuit definition.
+    // I believe we want to eventually make it public too though.
+    key_hash: Field,
+    proof_b: [Field; 93]
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
diff --git a/test_programs/noir_test_failure/should_fail_suite_with_one_failure/Nargo.toml b/test_programs/noir_test_failure/should_fail_suite_with_one_failure/Nargo.toml
new file mode 100644
index 00000000000..3d2cf2c6096
--- /dev/null
+++ b/test_programs/noir_test_failure/should_fail_suite_with_one_failure/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "should_fail_with_mismatch"
+type = "bin"
+authors = [""]
+[dependencies]
diff --git a/test_programs/test_libraries/exporting_lib/src/lib.nr b/test_programs/test_libraries/exporting_lib/src/lib.nr
index af1fd7a32de..bfb1819132a 100644
--- a/test_programs/test_libraries/exporting_lib/src/lib.nr
+++ b/test_programs/test_libraries/exporting_lib/src/lib.nr
@@ -1,4 +1,3 @@
-
 struct MyStruct {
     inner: Field
 }
diff --git a/tooling/acvm_cli/Cargo.toml b/tooling/acvm_cli/Cargo.toml
new file mode 100644
index 00000000000..72424405d36
--- /dev/null
+++ b/tooling/acvm_cli/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+name = "acvm_cli"
+description = "The entrypoint for executing the ACVM"
+# x-release-please-start-version
+version = "0.40.0"
+# x-release-please-end
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+# Rename binary from `acvm_cli` to `acvm`
+[[bin]]
+name = "acvm"
+path = "src/main.rs"
+
+[dependencies]
+thiserror.workspace = true
+toml.workspace = true
+color-eyre = "0.6.2"
+clap.workspace = true
+acvm.workspace = true
+nargo.workspace = true
+const_format.workspace = true
+bn254_blackbox_solver.workspace = true
+acir.workspace = true
+
+# Logs
+tracing-subscriber.workspace = true
+tracing-appender = "0.2.3"
+
+[dev-dependencies]
+rand = "0.8.5"
+proptest = "1.2.0"
+paste = "1.0.14"
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
new file mode 100644
index 00000000000..255b6131fd6
--- /dev/null
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -0,0 +1,78 @@
+use std::io::{self, Write};
+
+use acir::circuit::Circuit;
+use acir::native_types::WitnessMap;
+use bn254_blackbox_solver::Bn254BlackBoxSolver;
+use clap::Args;
+
+use crate::cli::fs::inputs::{read_bytecode_from_file, read_inputs_from_file};
+use crate::cli::fs::witness::save_witness_to_dir;
+use crate::errors::CliError;
+use nargo::ops::{execute_circuit, DefaultForeignCallExecutor};
+
+use super::fs::witness::create_output_witness_string;
+
+/// Executes a circuit to calculate its return value
+#[derive(Debug, Clone, Args)]
+pub(crate) struct ExecuteCommand {
+    /// Write the execution witness to named file
+    #[clap(long, short)]
+    output_witness: Option<String>,
+
+    /// The name of the toml file which contains the input witness map
+    #[clap(long, short)]
+    input_witness: String,
+
+    /// The name of the binary file containing circuit bytecode
+    #[clap(long, short)]
+    bytecode: String,
+
+    /// The working directory
+    #[clap(long, short)]
+    working_directory: String,
+
+    /// Set to print output witness to stdout
+    #[clap(long, short, action)]
+    print: bool,
+}
+
+fn run_command(args: ExecuteCommand) -> Result<String, CliError> {
+    let bytecode = read_bytecode_from_file(&args.working_directory, &args.bytecode)?;
+    let circuit_inputs = read_inputs_from_file(&args.working_directory, &args.input_witness)?;
+    let output_witness = execute_program_from_witness(&circuit_inputs, &bytecode, None)?;
+    let output_witness_string = create_output_witness_string(&output_witness)?;
+    if args.output_witness.is_some() {
+        save_witness_to_dir(
+            &output_witness_string,
+            &args.working_directory,
+            &args.output_witness.unwrap(),
+        )?;
+    }
+    Ok(output_witness_string)
+}
+
+pub(crate) fn run(args: ExecuteCommand) -> Result<String, CliError> {
+    let print = args.print;
+    let output_witness_string = run_command(args)?;
+    if print {
+        io::stdout().write_all(output_witness_string.as_bytes()).unwrap();
+    }
+    Ok(output_witness_string)
+}
+
+pub(crate) fn execute_program_from_witness(
+    inputs_map: &WitnessMap,
+    bytecode: &[u8],
+    foreign_call_resolver_url: Option<&str>,
+) -> Result<WitnessMap, CliError> {
+    let blackbox_solver = Bn254BlackBoxSolver::new();
+    let circuit: Circuit = Circuit::deserialize_circuit(bytecode)
+        .map_err(|_| CliError::CircuitDeserializationError())?;
+    execute_circuit(
+        &circuit,
+        inputs_map.clone(),
+        &blackbox_solver,
+        &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
+    )
+    .map_err(CliError::CircuitExecutionError)
+}
diff --git a/tooling/acvm_cli/src/cli/fs/inputs.rs b/tooling/acvm_cli/src/cli/fs/inputs.rs
new file mode 100644
index 00000000000..2a46cfba884
--- /dev/null
+++ b/tooling/acvm_cli/src/cli/fs/inputs.rs
@@ -0,0 +1,54 @@
+use acir::{
+    native_types::{Witness, WitnessMap},
+    FieldElement,
+};
+use toml::Table;
+
+use crate::errors::{CliError, FilesystemError};
+use std::{fs::read, path::Path};
+
+/// Returns the circuit's parameters parsed from a toml file at the given location
+pub(crate) fn read_inputs_from_file<P: AsRef<Path>>(
+    working_directory: P,
+    file_name: &String,
+) -> Result<WitnessMap, CliError> {
+    let file_path = working_directory.as_ref().join(file_name);
+    if !file_path.exists() {
+        return Err(CliError::FilesystemError(FilesystemError::MissingTomlFile(
+            file_name.to_owned(),
+            file_path,
+        )));
+    }
+
+    let input_string = std::fs::read_to_string(file_path)
+        .map_err(|_| FilesystemError::InvalidTomlFile(file_name.clone()))?;
+    let input_map = input_string
+        .parse::<Table>()
+        .map_err(|_| FilesystemError::InvalidTomlFile(file_name.clone()))?;
+    let mut witnesses: WitnessMap = WitnessMap::new();
+    for (key, value) in input_map.into_iter() {
+        let index =
+            Witness(key.trim().parse().map_err(|_| CliError::WitnessIndexError(key.clone()))?);
+        if !value.is_str() {
+            return Err(CliError::WitnessValueError(key.clone()));
+        }
+        let field = FieldElement::from_hex(value.as_str().unwrap()).unwrap();
+        witnesses.insert(index, field);
+    }
+
+    Ok(witnesses)
+}
+
+/// Returns the circuit's bytecode read from the file at the given location
+pub(crate) fn read_bytecode_from_file<P: AsRef<Path>>(
+    working_directory: P,
+    file_name: &String,
+) -> Result<Vec<u8>, FilesystemError> {
+    let file_path = working_directory.as_ref().join(file_name);
+    if !file_path.exists() {
+        return Err(FilesystemError::MissingBytecodeFile(file_name.to_owned(), file_path));
+    }
+    let bytecode: Vec<u8> =
+        read(file_path).map_err(|_| FilesystemError::InvalidBytecodeFile(file_name.clone()))?;
+    Ok(bytecode)
+}
diff --git a/tooling/acvm_cli/src/cli/fs/mod.rs b/tooling/acvm_cli/src/cli/fs/mod.rs
new file mode 100644
index 00000000000..f23ba06fd8b
--- /dev/null
+++ b/tooling/acvm_cli/src/cli/fs/mod.rs
@@ -0,0 +1,2 @@
+pub(super) mod inputs;
+pub(super) mod witness;
diff --git a/tooling/acvm_cli/src/cli/fs/witness.rs b/tooling/acvm_cli/src/cli/fs/witness.rs
new file mode 100644
index 00000000000..2daaa5a3a58
--- /dev/null
+++ b/tooling/acvm_cli/src/cli/fs/witness.rs
@@ -0,0 +1,36 @@
+use std::{
+    collections::BTreeMap,
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+};
+
+use acvm::acir::native_types::WitnessMap;
+
+use crate::errors::{CliError, FilesystemError};
+
+/// Saves the provided output witnesses to a toml file created at the given location
+pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
+    output_witness: &String,
+    witness_dir: P,
+    file_name: &String,
+) -> Result<PathBuf, FilesystemError> {
+    let witness_path = witness_dir.as_ref().join(file_name);
+
+    let mut file = File::create(&witness_path)
+        .map_err(|_| FilesystemError::OutputWitnessCreationFailed(file_name.clone()))?;
+    write!(file, "{}", output_witness)
+        .map_err(|_| FilesystemError::OutputWitnessWriteFailed(file_name.clone()))?;
+
+    Ok(witness_path)
+}
+
+/// Creates a toml representation of the provided witness map
+pub(crate) fn create_output_witness_string(witnesses: &WitnessMap) -> Result<String, CliError> {
+    let mut witness_map: BTreeMap<String, String> = BTreeMap::new();
+    for (key, value) in witnesses.clone().into_iter() {
+        witness_map.insert(key.0.to_string(), format!("0x{}", value.to_hex()));
+    }
+
+    toml::to_string(&witness_map).map_err(|_| CliError::OutputWitnessSerializationFailed())
+}
diff --git a/tooling/acvm_cli/src/cli/mod.rs b/tooling/acvm_cli/src/cli/mod.rs
new file mode 100644
index 00000000000..a610b08ab77
--- /dev/null
+++ b/tooling/acvm_cli/src/cli/mod.rs
@@ -0,0 +1,41 @@
+use clap::{Parser, Subcommand};
+use color_eyre::eyre;
+use const_format::formatcp;
+
+mod execute_cmd;
+mod fs;
+
+const ACVM_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+static VERSION_STRING: &str = formatcp!("version = {}\n", ACVM_VERSION,);
+
+#[derive(Parser, Debug)]
+#[command(name="acvm", author, version=VERSION_STRING, about, long_about = None)]
+struct ACVMCli {
+    #[command(subcommand)]
+    command: ACVMCommand,
+}
+
+#[non_exhaustive]
+#[derive(Subcommand, Clone, Debug)]
+enum ACVMCommand {
+    Execute(execute_cmd::ExecuteCommand),
+}
+
+#[cfg(not(feature = "codegen-docs"))]
+pub(crate) fn start_cli() -> eyre::Result<()> {
+    let ACVMCli { command } = ACVMCli::parse();
+
+    match command {
+        ACVMCommand::Execute(args) => execute_cmd::run(args),
+    }?;
+
+    Ok(())
+}
+
+#[cfg(feature = "codegen-docs")]
+pub(crate) fn start_cli() -> eyre::Result<()> {
+    let markdown: String = clap_markdown::help_markdown::<NargoCli>();
+    println!("{markdown}");
+    Ok(())
+}
diff --git a/tooling/acvm_cli/src/errors.rs b/tooling/acvm_cli/src/errors.rs
new file mode 100644
index 00000000000..035388d05f7
--- /dev/null
+++ b/tooling/acvm_cli/src/errors.rs
@@ -0,0 +1,52 @@
+use nargo::NargoError;
+use std::path::PathBuf;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub(crate) enum FilesystemError {
+    #[error(
+        " Error: cannot find {0} in expected location {1:?}.\n Please generate this file at the expected location."
+    )]
+    MissingTomlFile(String, PathBuf),
+    #[error(" Error: failed to parse toml file {0}.")]
+    InvalidTomlFile(String),
+    #[error(
+      " Error: cannot find {0} in expected location {1:?}.\n Please generate this file at the expected location."
+    )]
+    MissingBytecodeFile(String, PathBuf),
+
+    #[error(" Error: failed to read bytecode file {0}.")]
+    InvalidBytecodeFile(String),
+
+    #[error(" Error: failed to create output witness file {0}.")]
+    OutputWitnessCreationFailed(String),
+
+    #[error(" Error: failed to write output witness file {0}.")]
+    OutputWitnessWriteFailed(String),
+}
+
+#[derive(Debug, Error)]
+pub(crate) enum CliError {
+    /// Filesystem errors
+    #[error(transparent)]
+    FilesystemError(#[from] FilesystemError),
+
+    /// Error related to circuit deserialization
+    #[error("Error: failed to deserialize circuit")]
+    CircuitDeserializationError(),
+
+    /// Error related to circuit execution
+    #[error(transparent)]
+    CircuitExecutionError(#[from] NargoError),
+
+    /// Input Witness Value Error
+    #[error("Error: failed to parse witness value {0}")]
+    WitnessValueError(String),
+
+    /// Input Witness Index Error
+    #[error("Error: failed to parse witness index {0}")]
+    WitnessIndexError(String),
+
+    #[error(" Error: failed to serialize output witness.")]
+    OutputWitnessSerializationFailed(),
+}
diff --git a/tooling/acvm_cli/src/main.rs b/tooling/acvm_cli/src/main.rs
new file mode 100644
index 00000000000..33cadc73a7c
--- /dev/null
+++ b/tooling/acvm_cli/src/main.rs
@@ -0,0 +1,36 @@
+#![forbid(unsafe_code)]
+#![warn(unreachable_pub)]
+#![warn(clippy::semicolon_if_nothing_returned)]
+#![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
+
+mod cli;
+mod errors;
+
+use std::env;
+
+use tracing_appender::rolling;
+use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
+
+fn main() {
+    // Setup tracing
+    if let Ok(log_dir) = env::var("ACVM_LOG_DIR") {
+        let debug_file = rolling::daily(log_dir, "acvm-log");
+        tracing_subscriber::fmt()
+            .with_span_events(FmtSpan::ACTIVE)
+            .with_writer(debug_file)
+            .with_ansi(false)
+            .with_env_filter(EnvFilter::from_default_env())
+            .init();
+    } else {
+        tracing_subscriber::fmt()
+            .with_span_events(FmtSpan::ACTIVE)
+            .with_ansi(true)
+            .with_env_filter(EnvFilter::from_env("NOIR_LOG"))
+            .init();
+    }
+
+    if let Err(report) = cli::start_cli() {
+        eprintln!("{report}");
+        std::process::exit(1);
+    }
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 231d4d897a9..854e284dd43 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -6,6 +6,7 @@ brillig_to_bytes_integration
 debug_logs
 double_verify_nested_proof
 double_verify_proof
+double_verify_proof_recursive
 modulus
 references
 scalar_mul
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index d928b09fcb9..020ce49662f 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -1,6 +1,6 @@
 use acvm::acir::circuit::Circuit;
 use noirc_abi::{Abi, ContractEvent};
-use noirc_driver::{CompiledContract, ContractFunction, ContractFunctionType};
+use noirc_driver::{CompiledContract, ContractFunction};
 use serde::{Deserialize, Serialize};
 
 use noirc_driver::DebugFile;
@@ -43,9 +43,9 @@ impl From<CompiledContract> for ContractArtifact {
 pub struct ContractFunctionArtifact {
     pub name: String,
 
-    pub function_type: ContractFunctionType,
+    pub is_unconstrained: bool,
 
-    pub is_internal: bool,
+    pub custom_attributes: Vec<String>,
 
     pub abi: Abi,
 
@@ -66,8 +66,8 @@ impl From<ContractFunction> for ContractFunctionArtifact {
     fn from(func: ContractFunction) -> Self {
         ContractFunctionArtifact {
             name: func.name,
-            function_type: func.function_type,
-            is_internal: func.is_internal,
+            is_unconstrained: func.is_unconstrained,
+            custom_attributes: func.custom_attributes,
             abi: func.abi,
             bytecode: func.bytecode,
             debug_symbols: func.debug,

From 773cf190ee21381d826ba80391a5d7d5efae9174 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=A1s=20Garc=C3=ADa?= <nicolasgarcia214@gmail.com>
Date: Wed, 13 Mar 2024 10:00:17 -0500
Subject: [PATCH 071/416] feat: Visible aliases for nargo commands (#4453)

# Description

Closes #4452

## Documentation\

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/src/cli/check_cmd.rs   | 1 +
 tooling/nargo_cli/src/cli/execute_cmd.rs | 1 +
 tooling/nargo_cli/src/cli/info_cmd.rs    | 1 +
 tooling/nargo_cli/src/cli/prove_cmd.rs   | 1 +
 tooling/nargo_cli/src/cli/test_cmd.rs    | 1 +
 tooling/nargo_cli/src/cli/verify_cmd.rs  | 1 +
 6 files changed, 6 insertions(+)

diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 242a640e484..897073f4e20 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -24,6 +24,7 @@ use super::NargoConfig;
 
 /// Checks the constraint system for errors
 #[derive(Debug, Clone, Args)]
+#[clap(visible_alias = "c")]
 pub(crate) struct CheckCommand {
     /// The name of the package to check
     #[clap(long, conflicts_with = "workspace")]
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 85c0a4160a7..1be2fbf61d9 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -23,6 +23,7 @@ use crate::errors::CliError;
 
 /// Executes a circuit to calculate its return value
 #[derive(Debug, Clone, Args)]
+#[clap(visible_alias = "e")]
 pub(crate) struct ExecuteCommand {
     /// Write the execution witness to named file
     witness_name: Option<String>,
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 300e1a35be2..391e8061a07 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -30,6 +30,7 @@ use super::{compile_cmd::compile_workspace, NargoConfig};
 /// 1. The number of ACIR opcodes
 /// 2. Counts the final number gates in the circuit used by a backend
 #[derive(Debug, Clone, Args)]
+#[clap(visible_alias = "i")]
 pub(crate) struct InfoCommand {
     /// The name of the package to detail
     #[clap(long, conflicts_with = "workspace")]
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index f0a9b3185b9..e413db0e5f3 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -20,6 +20,7 @@ use crate::{backends::Backend, cli::execute_cmd::execute_program, errors::CliErr
 
 /// Create proof for this program. The proof is returned as a hex encoded string.
 #[derive(Debug, Clone, Args)]
+#[clap(visible_alias = "p")]
 pub(crate) struct ProveCommand {
     /// The name of the toml file which contains the inputs for the prover
     #[clap(long, short, default_value = PROVER_INPUT_FILE)]
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 2828aaf01eb..88a804d5cf4 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -25,6 +25,7 @@ use super::NargoConfig;
 
 /// Run the tests for this program
 #[derive(Debug, Clone, Args)]
+#[clap(visible_alias = "t")]
 pub(crate) struct TestCommand {
     /// If given, only tests with names containing this string will be run
     test_name: Option<String>,
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
index 1063b50ab6c..3e23c9a3e9f 100644
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ b/tooling/nargo_cli/src/cli/verify_cmd.rs
@@ -17,6 +17,7 @@ use noirc_frontend::graph::CrateName;
 
 /// Given a proof and a program, verify whether the proof is valid
 #[derive(Debug, Clone, Args)]
+#[clap(visible_alias = "v")]
 pub(crate) struct VerifyCommand {
     /// The name of the toml file which contains the inputs for the verifier
     #[clap(long, short, default_value = VERIFIER_INPUT_FILE)]

From 9ca1a60f9310f9822414c62dfa410c85bfe1737b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 13 Mar 2024 15:30:50 +0000
Subject: [PATCH 072/416] chore: allow setting namespace visibility on
 functions (#4510)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR allows setting non-public visibilities when adding functions to
namespaces. This doesn't currently cause any changes as we never
actually read this visibility but we start to do so in a later PR.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../compute_note_hash_and_nullifier.rs        |  4 +--
 .../src/hir/def_collector/dc_mod.rs           | 11 +++----
 .../src/hir/def_map/item_scope.rs             | 13 ++++++--
 .../src/hir/def_map/module_data.rs            | 30 +++++++++++--------
 .../src/hir/resolution/impls.rs               | 11 +++++--
 .../src/hir/resolution/traits.rs              | 11 +++++--
 6 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index 4f8f3f19ab8..fd538dc578b 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -7,7 +7,7 @@ use noirc_frontend::{
     },
     macros_api::{FileId, HirContext, MacroError},
     node_interner::FuncId,
-    parse_program, FunctionReturnType, NoirFunction, UnresolvedTypeData,
+    parse_program, FunctionReturnType, ItemVisibility, NoirFunction, UnresolvedTypeData,
 };
 
 use crate::utils::hir_utils::fetch_struct_trait_impls;
@@ -113,7 +113,7 @@ pub fn inject_compute_note_hash_and_nullifier(
     context.def_map_mut(crate_id).unwrap()
         .modules_mut()[module_id.0]
         .declare_function(
-            func.name_ident().clone(), func_id
+            func.name_ident().clone(), ItemVisibility::Public, func_id
         ).expect(
             "Failed to declare the autogenerated compute_note_hash_and_nullifier function, likely due to a duplicate definition. See https://github.com/AztecProtocol/aztec-packages/issues/4647."
         );
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index ae99e61e534..5adb9eb5b7e 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -10,8 +10,8 @@ use crate::{
     macros_api::MacroProcessor,
     node_interner::{FunctionModifiers, TraitId, TypeAliasId},
     parser::{SortedModule, SortedSubModule},
-    FunctionDefinition, Ident, LetStatement, ModuleDeclaration, NoirFunction, NoirStruct,
-    NoirTrait, NoirTraitImpl, NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
+    FunctionDefinition, Ident, ItemVisibility, LetStatement, ModuleDeclaration, NoirFunction,
+    NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
 };
 
 use super::{
@@ -232,6 +232,7 @@ impl<'a> ModCollector<'a> {
 
             let name = function.name_ident().clone();
             let func_id = context.def_interner.push_empty_fn();
+            let visibility = function.def.visibility;
 
             // First create dummy function in the DefInterner
             // So that we can get a FuncId
@@ -248,7 +249,7 @@ impl<'a> ModCollector<'a> {
 
             // Add function to scope/ns of the module
             let result = self.def_collector.def_map.modules[self.module_id.0]
-                .declare_function(name, func_id);
+                .declare_function(name, visibility, func_id);
 
             if let Err((first_def, second_def)) = result {
                 let error = DefCollectorErrorKind::Duplicate {
@@ -407,7 +408,7 @@ impl<'a> ModCollector<'a> {
 
                         let modifiers = FunctionModifiers {
                             name: name.to_string(),
-                            visibility: crate::ItemVisibility::Public,
+                            visibility: ItemVisibility::Public,
                             // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629
                             attributes: crate::token::Attributes::empty(),
                             is_unconstrained: false,
@@ -419,7 +420,7 @@ impl<'a> ModCollector<'a> {
                             .push_function_definition(func_id, modifiers, trait_id.0, location);
 
                         match self.def_collector.def_map.modules[trait_id.0.local_id.0]
-                            .declare_function(name.clone(), func_id)
+                            .declare_function(name.clone(), ItemVisibility::Public, func_id)
                         {
                             Ok(()) => {
                                 if let Some(body) = body {
diff --git a/compiler/noirc_frontend/src/hir/def_map/item_scope.rs b/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
index 178b91e1e84..cd4eafdf669 100644
--- a/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
@@ -19,10 +19,11 @@ impl ItemScope {
     pub fn add_definition(
         &mut self,
         name: Ident,
+        visibility: ItemVisibility,
         mod_def: ModuleDefId,
         trait_id: Option<TraitId>,
     ) -> Result<(), (Ident, Ident)> {
-        self.add_item_to_namespace(name, mod_def, trait_id, false)?;
+        self.add_item_to_namespace(name, visibility, mod_def, trait_id, false)?;
         self.defs.push(mod_def);
         Ok(())
     }
@@ -33,6 +34,7 @@ impl ItemScope {
     pub fn add_item_to_namespace(
         &mut self,
         name: Ident,
+        visibility: ItemVisibility,
         mod_def: ModuleDefId,
         trait_id: Option<TraitId>,
         is_prelude: bool,
@@ -41,6 +43,11 @@ impl ItemScope {
             if let Entry::Occupied(mut o) = map.entry(name.clone()) {
                 let trait_hashmap = o.get_mut();
                 if let Entry::Occupied(mut n) = trait_hashmap.entry(trait_id) {
+                    // Generally we want to reject having two of the same ident in the same namespace.
+                    // The exception to this is when we're explicitly importing something
+                    // which exists in the Noir stdlib prelude.
+                    //
+                    // In this case we ignore the prelude and favour the explicit import.
                     let is_prelude = std::mem::replace(&mut n.get_mut().2, is_prelude);
                     let old_ident = o.key();
 
@@ -50,12 +57,12 @@ impl ItemScope {
                         Err((old_ident.clone(), name))
                     }
                 } else {
-                    trait_hashmap.insert(trait_id, (mod_def, ItemVisibility::Public, is_prelude));
+                    trait_hashmap.insert(trait_id, (mod_def, visibility, is_prelude));
                     Ok(())
                 }
             } else {
                 let mut trait_hashmap = HashMap::new();
-                trait_hashmap.insert(trait_id, (mod_def, ItemVisibility::Public, is_prelude));
+                trait_hashmap.insert(trait_id, (mod_def, visibility, is_prelude));
                 map.insert(name, trait_hashmap);
                 Ok(())
             }
diff --git a/compiler/noirc_frontend/src/hir/def_map/module_data.rs b/compiler/noirc_frontend/src/hir/def_map/module_data.rs
index 309618dd011..4dd38f0e3e5 100644
--- a/compiler/noirc_frontend/src/hir/def_map/module_data.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/module_data.rs
@@ -4,7 +4,7 @@ use noirc_errors::Location;
 
 use crate::{
     node_interner::{FuncId, GlobalId, StructId, TraitId, TypeAliasId},
-    Ident,
+    Ident, ItemVisibility,
 };
 
 use super::{ItemScope, LocalModuleId, ModuleDefId, ModuleId, PerNs};
@@ -48,18 +48,24 @@ impl ModuleData {
     fn declare(
         &mut self,
         name: Ident,
+        visibility: ItemVisibility,
         item_id: ModuleDefId,
         trait_id: Option<TraitId>,
     ) -> Result<(), (Ident, Ident)> {
-        self.scope.add_definition(name.clone(), item_id, trait_id)?;
+        self.scope.add_definition(name.clone(), visibility, item_id, trait_id)?;
 
         // definitions is a subset of self.scope so it is expected if self.scope.define_func_def
         // returns without error, so will self.definitions.define_func_def.
-        self.definitions.add_definition(name, item_id, trait_id)
+        self.definitions.add_definition(name, visibility, item_id, trait_id)
     }
 
-    pub fn declare_function(&mut self, name: Ident, id: FuncId) -> Result<(), (Ident, Ident)> {
-        self.declare(name, id.into(), None)
+    pub fn declare_function(
+        &mut self,
+        name: Ident,
+        visibility: ItemVisibility,
+        id: FuncId,
+    ) -> Result<(), (Ident, Ident)> {
+        self.declare(name, visibility, id.into(), None)
     }
 
     pub fn declare_trait_function(
@@ -68,7 +74,7 @@ impl ModuleData {
         id: FuncId,
         trait_id: TraitId,
     ) -> Result<(), (Ident, Ident)> {
-        self.declare(name, id.into(), Some(trait_id))
+        self.declare(name, ItemVisibility::Public, id.into(), Some(trait_id))
     }
 
     pub fn remove_function(&mut self, name: &Ident) {
@@ -77,11 +83,11 @@ impl ModuleData {
     }
 
     pub fn declare_global(&mut self, name: Ident, id: GlobalId) -> Result<(), (Ident, Ident)> {
-        self.declare(name, id.into(), None)
+        self.declare(name, ItemVisibility::Public, id.into(), None)
     }
 
     pub fn declare_struct(&mut self, name: Ident, id: StructId) -> Result<(), (Ident, Ident)> {
-        self.declare(name, ModuleDefId::TypeId(id), None)
+        self.declare(name, ItemVisibility::Public, ModuleDefId::TypeId(id), None)
     }
 
     pub fn declare_type_alias(
@@ -89,11 +95,11 @@ impl ModuleData {
         name: Ident,
         id: TypeAliasId,
     ) -> Result<(), (Ident, Ident)> {
-        self.declare(name, id.into(), None)
+        self.declare(name, ItemVisibility::Public, id.into(), None)
     }
 
     pub fn declare_trait(&mut self, name: Ident, id: TraitId) -> Result<(), (Ident, Ident)> {
-        self.declare(name, ModuleDefId::TraitId(id), None)
+        self.declare(name, ItemVisibility::Public, ModuleDefId::TraitId(id), None)
     }
 
     pub fn declare_child_module(
@@ -101,7 +107,7 @@ impl ModuleData {
         name: Ident,
         child_id: ModuleId,
     ) -> Result<(), (Ident, Ident)> {
-        self.declare(name, child_id.into(), None)
+        self.declare(name, ItemVisibility::Public, child_id.into(), None)
     }
 
     pub fn find_func_with_name(&self, name: &Ident) -> Option<FuncId> {
@@ -114,7 +120,7 @@ impl ModuleData {
         id: ModuleDefId,
         is_prelude: bool,
     ) -> Result<(), (Ident, Ident)> {
-        self.scope.add_item_to_namespace(name, id, None, is_prelude)
+        self.scope.add_item_to_namespace(name, ItemVisibility::Public, id, None, is_prelude)
     }
 
     pub fn find_name(&self, name: &Ident) -> PerNs {
diff --git a/compiler/noirc_frontend/src/hir/resolution/impls.rs b/compiler/noirc_frontend/src/hir/resolution/impls.rs
index 4aa70f00cfc..72f6adc3770 100644
--- a/compiler/noirc_frontend/src/hir/resolution/impls.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/impls.rs
@@ -13,7 +13,7 @@ use crate::{
         Context,
     },
     node_interner::{FuncId, NodeInterner},
-    Type,
+    ItemVisibility, Type,
 };
 
 use super::{
@@ -67,7 +67,14 @@ pub(crate) fn collect_impls(
                     // be accessed with the `TypeName::method` syntax. We'll check later whether the
                     // object types in each method overlap or not. If they do, we issue an error.
                     // If not, that is specialization which is allowed.
-                    if module.declare_function(method.name_ident().clone(), *method_id).is_err() {
+                    if module
+                        .declare_function(
+                            method.name_ident().clone(),
+                            ItemVisibility::Public,
+                            *method_id,
+                        )
+                        .is_err()
+                    {
                         module.remove_function(method.name_ident());
                     }
                 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index 5d546954f0d..04da558a642 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -16,7 +16,7 @@ use crate::{
     },
     hir_def::traits::{TraitConstant, TraitFunction, TraitImpl, TraitType},
     node_interner::{FuncId, NodeInterner, TraitId},
-    Generics, Path, Shared, TraitItem, Type, TypeVariable, TypeVariableKind,
+    Generics, ItemVisibility, Path, Shared, TraitItem, Type, TypeVariable, TypeVariableKind,
 };
 
 use super::{
@@ -301,7 +301,14 @@ fn collect_trait_impl(
                 // be accessed with the `TypeName::method` syntax. We'll check later whether the
                 // object types in each method overlap or not. If they do, we issue an error.
                 // If not, that is specialization which is allowed.
-                if module.declare_function(method.name_ident().clone(), *method_id).is_err() {
+                if module
+                    .declare_function(
+                        method.name_ident().clone(),
+                        ItemVisibility::Public,
+                        *method_id,
+                    )
+                    .is_err()
+                {
                     module.remove_function(method.name_ident());
                 }
             }

From 80373d612c023e3e165b49b6d1729486b0ba3b4b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 13 Mar 2024 17:04:16 +0000
Subject: [PATCH 073/416] feat: optimize sha2 implementation (#4441)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're currently performing byte decompositions in the sha2 functions
through repeated division. This would be more efficient if we just did
the full byte decomposition at once and then iterate through the
results.

I've also removed some noop casts.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/sha256.nr | 22 ++++++++++++----------
 noir_stdlib/src/sha512.nr | 22 ++++++++++++----------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/noir_stdlib/src/sha256.nr b/noir_stdlib/src/sha256.nr
index 2f686a64165..8ca6808568d 100644
--- a/noir_stdlib/src/sha256.nr
+++ b/noir_stdlib/src/sha256.nr
@@ -6,9 +6,11 @@ fn msg_u8_to_u32(msg: [u8; 64]) -> [u32; 16] {
     let mut msg32: [u32; 16] = [0; 16];
 
     for i in 0..16 {
+        let mut msg_field: Field = 0;
         for j in 0..4 {
-            msg32[15 - i] = (msg32[15 - i] << 8) + msg[64 - 4*(i + 1) + j] as u32;
+            msg_field = msg_field * 256 + msg[64 - 4*(i + 1) + j] as Field;
         }
+        msg32[15 - i] = msg_field as u32;
     }
 
     msg32
@@ -21,7 +23,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
     let mut i: u64 = 0; // Message byte pointer
     for k in 0..N {
         // Populate msg_block
-        msg_block[i as Field] = msg[k];
+        msg_block[i] = msg[k];
         i = i + 1;
         if i == 64 {
             // Enough to hash block
@@ -32,7 +34,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
     }
     // Pad the rest such that we have a [u32; 2] block at the end representing the length
     // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).
-    msg_block[i as Field] = 1 << 7;
+    msg_block[i] = 1 << 7;
     i = i + 1;
     // If i >= 57, there aren't enough bits in the current message block to accomplish this, so
     // the 1 and 0s fill up the current block, which we then compress accordingly.
@@ -41,7 +43,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
         if i < 64 {
             for _i in 57..64 {
                 if i <= 63 {
-                    msg_block[i as Field] = 0;
+                    msg_block[i] = 0;
                     i += 1;
                 }
             }
@@ -51,16 +53,16 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
         i = 0;
     }
 
+    let len = 8 * msg.len();
+    let len_bytes = (len as Field).to_le_bytes(8);
     for _i in 0..64 {
         // In any case, fill blocks up with zeros until the last 64 (i.e. until i = 56).
         if i < 56 {
-            msg_block[i as Field] = 0;
+            msg_block[i] = 0;
             i = i + 1;
         } else if i < 64 {
-            let mut len = 8 * msg.len();
             for j in 0..8 {
-                msg_block[63 - j] = len as u8;
-                len >>= 8;
+                msg_block[63 - j] = len_bytes[j];
             }
             i += 8;
         }
@@ -70,9 +72,9 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
 
     // Return final hash as byte array
     for j in 0..8 {
+        let h_bytes = (h[7 - j] as Field).to_le_bytes(4);
         for k in 0..4 {
-            out_h[31 - 4*j - k] = h[7 - j] as u8;
-            h[7-j] >>= 8;
+            out_h[31 - 4*j - k] = h_bytes[k];
         }
     }
 
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index 4dfe78308e2..a766ae50d55 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -77,9 +77,11 @@ fn msg_u8_to_u64(msg: [u8; 128]) -> [u64; 16] {
     let mut msg64: [u64; 16] = [0; 16];
 
     for i in 0..16 {
+        let mut msg_field: Field = 0;
         for j in 0..8 {
-            msg64[15 - i] = (msg64[15 - i] << 8) + msg[128 - 8*(i + 1) + j] as u64;
+            msg_field = msg_field * 256 + msg[128 - 8*(i + 1) + j] as Field;
         }
+        msg64[15 - i] = msg_field as u64;
     }
 
     msg64
@@ -94,7 +96,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
     let mut i: u64 = 0; // Message byte pointer
     for k in 0..msg.len() {
         // Populate msg_block
-        msg_block[i as Field] = msg[k];
+        msg_block[i] = msg[k];
         i = i + 1;
         if i == 128 {
             // Enough to hash block
@@ -108,7 +110,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
     }
     // Pad the rest such that we have a [u64; 2] block at the end representing the length
     // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).
-    msg_block[i as Field] = 1 << 7;
+    msg_block[i] = 1 << 7;
     i += 1;
     // If i >= 113, there aren't enough bits in the current message block to accomplish this, so
     // the 1 and 0s fill up the current block, which we then compress accordingly.
@@ -117,7 +119,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
         if i < 128 {
             for _i in 113..128 {
                 if i <= 127 {
-                    msg_block[i as Field] = 0;
+                    msg_block[i] = 0;
                     i += 1;
                 }
             }
@@ -130,16 +132,16 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
         i = 0;
     }
 
+    let len = 8 * msg.len();
+    let len_bytes = (len as Field).to_le_bytes(16);
     for _i in 0..128 {
         // In any case, fill blocks up with zeros until the last 128 (i.e. until i = 112).
         if i < 112 {
-            msg_block[i as Field] = 0;
+            msg_block[i] = 0;
             i += 1;
         } else if i < 128 {
-            let mut len = 8 * msg.len();
             for j in 0..16 {
-                msg_block[127 - j] = len as u8;
-                len >>= 8;
+                msg_block[127 - j] = len_bytes[j];
             }
             i += 16; // Done.
         }
@@ -151,9 +153,9 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
     }
     // Return final hash as byte array
     for j in 0..8 {
+        let h_bytes = (h[7 - j] as Field).to_le_bytes(8);
         for k in 0..8 {
-            out_h[63 - 8*j - k] = h[7 - j] as u8;
-            h[7-j] >>= 8;
+            out_h[63 - 8*j - k] = h_bytes[k];
         }
     }
 

From eeeebacd10698e847f773e26dac8a4a5eb8e84ed Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 13 Mar 2024 12:26:44 -0500
Subject: [PATCH 074/416] fix: Substitute generics when checking the field
 count of a type (#4547)

# Description

## Problem\*

Resolves #4545

## Summary\*

A prior assumption we had where we didn't need to bind generics just to
check how many fields a type can have turned out not to be true. Binding
generics is important for cases such as the new test case where generic
lengths are used.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir_def/types.rs |  6 +-----
 compiler/noirc_frontend/src/tests.rs         | 10 ++++++++++
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 5ab036eef5b..60bc5b2470f 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -127,11 +127,7 @@ impl Type {
                 let fields = struct_type.get_fields(args);
                 fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count())
             }
-            Type::Alias(def, _) => {
-                // It is safe to access `typ` without instantiating generics here since generics
-                // cannot change the number of fields in `typ`.
-                def.borrow().typ.field_count()
-            }
+            Type::Alias(def, generics) => def.borrow().get_type(generics).field_count(),
             Type::Tuple(fields) => {
                 fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count())
             }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 3f78bd43ba9..1158f4c229a 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1213,4 +1213,14 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         "#;
         assert_eq!(get_program_errors(src).len(), 0);
     }
+
+    // Regression for #4545
+    #[test]
+    fn type_aliases_in_main() {
+        let src = r#"
+            type Outer<N> = [u8; N];
+            fn main(_arg: Outer<1>) {}
+        "#;
+        assert_eq!(get_program_errors(src).len(), 0);
+    }
 }

From 44e60b67469de88f20842c4eead64d736f7bd4a0 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 13 Mar 2024 18:15:25 +0000
Subject: [PATCH 075/416] feat: add `nargo compile --watch` command (#4464)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR creates the outline of a `watch` command to be built on in
subsequent PRs.

Currently this just watches the full workspace directory and on any
change to a `.nr` file, will recompile the workspace/package and display
any errors/warnings.

## Additional Context



## Documentation\*

Check one:
- [] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[Exceptional Case]** Documentation to be submitted in a separate
PR.
Will be documented when feature is public.
# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                               | 283 ++++++++++++++++++++---
 cspell.json                              |   1 +
 deny.toml                                |   1 +
 tooling/nargo_cli/Cargo.toml             |   6 +-
 tooling/nargo_cli/src/cli/compile_cmd.rs |  97 ++++++--
 5 files changed, 336 insertions(+), 52 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d5ce8a10509..3b7c1b6e56e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -411,7 +411,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138985dd8aefbefeaa66b01b7f5b2b6b4c333fcef1cc5f32c63a2aabe37d6de3"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.28",
  "lsp-types 0.94.1",
  "pin-project-lite",
  "rustix",
@@ -967,14 +967,14 @@ checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335"
 
 [[package]]
 name = "console"
-version = "0.15.8"
+version = "0.15.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
 dependencies = [
  "encode_unicode 0.3.6",
  "lazy_static",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -1675,6 +1675,15 @@ dependencies = [
  "rayon",
 ]
 
+[[package]]
+name = "file-id"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6584280525fb2059cba3db2c04abf947a1a29a45ddae89f3870f8281704fafc9"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "filetime"
 version = "0.2.22"
@@ -1749,6 +1758,15 @@ dependencies = [
  "percent-encoding 2.3.0",
 ]
 
+[[package]]
+name = "fsevent-sys"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "funty"
 version = "2.0.0"
@@ -1763,9 +1781,9 @@ checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
 
 [[package]]
 name = "futures"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1778,9 +1796,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1788,15 +1806,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1806,15 +1824,15 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1823,21 +1841,21 @@ dependencies = [
 
 [[package]]
 name = "futures-sink"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
 
 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
 
 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
 dependencies = [
  "futures 0.1.31",
  "futures-channel",
@@ -2096,9 +2114,9 @@ checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
 [[package]]
 name = "hyper"
-version = "0.14.28"
+version = "0.14.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
+checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -2111,7 +2129,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2",
+ "socket2 0.4.9",
  "tokio",
  "tower-service",
  "tracing",
@@ -2120,9 +2138,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.2"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
 dependencies = [
  "futures-util",
  "http",
@@ -2290,6 +2308,26 @@ dependencies = [
  "str_stack",
 ]
 
+[[package]]
+name = "inotify"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
+dependencies = [
+ "bitflags 1.3.2",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -2363,7 +2401,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2b99d4207e2a04fb4581746903c2bb7eb376f88de9c699d0f3e10feeac0cd3a"
 dependencies = [
  "derive_more",
- "futures 0.3.30",
+ "futures 0.3.28",
  "jsonrpc-core",
  "jsonrpc-pubsub",
  "log",
@@ -2378,7 +2416,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.28",
  "futures-executor",
  "futures-util",
  "log",
@@ -2393,7 +2431,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b51da17abecbdab3e3d4f26b01c5ec075e88d3abe3ab3b05dc9aa69392764ec0"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.28",
  "jsonrpc-client-transports",
 ]
 
@@ -2415,7 +2453,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1dea6e07251d9ce6a552abfb5d7ad6bc290a4596c8dcc3d795fae2bbdc1f3ff"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.28",
  "hyper",
  "jsonrpc-core",
  "jsonrpc-server-utils",
@@ -2431,7 +2469,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240f87695e6c6f62fb37f05c02c04953cf68d6408b8c1c89de85c7a0125b1011"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.28",
  "jsonrpc-core",
  "lazy_static",
  "log",
@@ -2447,7 +2485,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4fdea130485b572c39a460d50888beb00afb3e35de23ccd7fad8ff19f0e0d4"
 dependencies = [
  "bytes",
- "futures 0.3.30",
+ "futures 0.3.28",
  "globset",
  "jsonrpc-core",
  "lazy_static",
@@ -2479,6 +2517,26 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "kqueue"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7447f1ca1b7b563588a205fe93dea8df60fd981423a768bc1c0ded35ed147d0c"
+dependencies = [
+ "kqueue-sys",
+ "libc",
+]
+
+[[package]]
+name = "kqueue-sys"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -2503,6 +2561,17 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
 
+[[package]]
+name = "libredox"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
+dependencies = [
+ "bitflags 2.4.2",
+ "libc",
+ "redox_syscall 0.4.1",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.13"
@@ -2659,6 +2728,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
 dependencies = [
  "libc",
+ "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.48.0",
 ]
@@ -2727,6 +2797,8 @@ dependencies = [
  "noirc_driver",
  "noirc_errors",
  "noirc_frontend",
+ "notify",
+ "notify-debouncer-full",
  "paste",
  "pprof",
  "predicates 2.1.5",
@@ -2738,6 +2810,7 @@ dependencies = [
  "similar-asserts",
  "tempfile",
  "termcolor",
+ "termion",
  "test-binary",
  "thiserror",
  "tokio",
@@ -3050,6 +3123,39 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
+[[package]]
+name = "notify"
+version = "6.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
+dependencies = [
+ "bitflags 2.4.2",
+ "crossbeam-channel",
+ "filetime",
+ "fsevent-sys",
+ "inotify",
+ "kqueue",
+ "libc",
+ "log",
+ "mio",
+ "walkdir",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "notify-debouncer-full"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f5dab59c348b9b50cf7f261960a20e389feb2713636399cd9082cd4b536154"
+dependencies = [
+ "crossbeam-channel",
+ "file-id",
+ "log",
+ "notify",
+ "parking_lot 0.12.1",
+ "walkdir",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -3111,6 +3217,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "numtoa"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
+
 [[package]]
 name = "object"
 version = "0.31.1"
@@ -3670,6 +3782,21 @@ dependencies = [
  "bitflags 1.3.2",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_termios"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
+
 [[package]]
 name = "redox_users"
 version = "0.4.3"
@@ -4432,6 +4559,16 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "socket2"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "socket2"
 version = "0.5.5"
@@ -4608,6 +4745,18 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "termion"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "417813675a504dfbbf21bfde32c03e5bf9f2413999962b479023c02848c1c7a5"
+dependencies = [
+ "libc",
+ "libredox",
+ "numtoa",
+ "redox_termios",
+]
+
 [[package]]
 name = "termtree"
 version = "0.4.1"
@@ -4743,7 +4892,7 @@ dependencies = [
  "mio",
  "num_cpus",
  "pin-project-lite",
- "socket2",
+ "socket2 0.5.5",
  "tokio-macros",
  "windows-sys 0.48.0",
 ]
@@ -5490,6 +5639,15 @@ dependencies = [
  "windows_x86_64_msvc 0.33.0",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -5508,6 +5666,21 @@ dependencies = [
  "windows-targets 0.52.4",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.48.1"
@@ -5538,6 +5711,12 @@ dependencies = [
  "windows_x86_64_msvc 0.52.4",
 ]
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.0"
@@ -5556,6 +5735,12 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.0"
@@ -5574,6 +5759,12 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.0"
@@ -5592,6 +5783,12 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.0"
@@ -5610,6 +5807,12 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.0"
@@ -5622,6 +5825,12 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.0"
@@ -5640,6 +5849,12 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.0"
diff --git a/cspell.json b/cspell.json
index d961b600f40..34dafa2b614 100644
--- a/cspell.json
+++ b/cspell.json
@@ -52,6 +52,7 @@
         "csat",
         "curvegroup",
         "databus",
+        "debouncer",
         "deflater",
         "deflatten",
         "deflattened",
diff --git a/deny.toml b/deny.toml
index 578f8427263..eff233687e8 100644
--- a/deny.toml
+++ b/deny.toml
@@ -69,6 +69,7 @@ exceptions = [
     # https://tldrlegal.com/license/creative-commons-cc0-1.0-universal
     { allow = ["CC0-1.0"], name = "more-asserts" },
     { allow = ["CC0-1.0"], name = "jsonrpc" },
+    { allow = ["CC0-1.0"], name = "notify" },
     { allow = ["MPL-2.0"], name = "sized-chunks" },
     { allow = ["MPL-2.0"], name = "webpki-roots" },
 
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index 57edbf5ae04..f92a2421b0f 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -50,6 +50,10 @@ tokio = { version = "1.0", features = ["io-std"] }
 dap.workspace = true
 clap-markdown = { git = "https://github.com/noir-lang/clap-markdown", rev = "450d759532c88f0dba70891ceecdbc9ff8f25d2b", optional = true }
 
+notify = "6.1.1"
+notify-debouncer-full = "0.3.1"
+termion = "3.0.0"
+
 # Backends
 backend-interface = { path = "../backend_interface" }
 
@@ -86,4 +90,4 @@ name = "iai"
 harness = false
 
 [features]
-codegen-docs = ["dep:clap-markdown"]
\ No newline at end of file
+codegen-docs = ["dep:clap-markdown"]
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 4309f0db3ea..9b7bf9cdb0c 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -1,4 +1,6 @@
+use std::io::Write;
 use std::path::Path;
+use std::time::Duration;
 
 use fm::FileManager;
 use nargo::artifacts::program::ProgramArtifact;
@@ -15,6 +17,8 @@ use noirc_frontend::graph::CrateName;
 
 use clap::Args;
 use noirc_frontend::hir::ParsedFiles;
+use notify::{EventKind, RecursiveMode, Watcher};
+use notify_debouncer_full::new_debouncer;
 
 use crate::backends::Backend;
 use crate::errors::CliError;
@@ -31,17 +35,21 @@ pub(crate) struct CompileCommand {
     #[clap(long, conflicts_with = "workspace")]
     package: Option<CrateName>,
 
-    /// Compile all packages in the workspace
+    /// Compile all packages in the workspace.
     #[clap(long, conflicts_with = "package")]
     workspace: bool,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
+
+    /// Watch workspace and recompile on changes.
+    #[clap(long, hide = true)]
+    watch: bool,
 }
 
 pub(crate) fn run(
     backend: &Backend,
-    args: CompileCommand,
+    mut args: CompileCommand,
     config: NargoConfig,
 ) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
@@ -54,28 +62,82 @@ pub(crate) fn run(
         selection,
         Some(NOIR_ARTIFACT_VERSION_STRING.to_owned()),
     )?;
-    let circuit_dir = workspace.target_directory_path();
 
+    if args.compile_options.expression_width.is_none() {
+        args.compile_options.expression_width = Some(backend.get_backend_info_or_default());
+    };
+
+    if args.watch {
+        watch_workspace(&workspace, &args.compile_options)
+            .map_err(|err| CliError::Generic(err.to_string()))?;
+    } else {
+        compile_workspace_full(&workspace, &args.compile_options)?;
+    }
+
+    Ok(())
+}
+
+fn watch_workspace(workspace: &Workspace, compile_options: &CompileOptions) -> notify::Result<()> {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    // No specific tickrate, max debounce time 1 seconds
+    let mut debouncer = new_debouncer(Duration::from_secs(1), None, tx)?;
+
+    // Add a path to be watched. All files and directories at that path and
+    // below will be monitored for changes.
+    debouncer.watcher().watch(&workspace.root_dir, RecursiveMode::Recursive)?;
+
+    let mut screen = std::io::stdout();
+    write!(screen, "{}", termion::cursor::Save).unwrap();
+    screen.flush().unwrap();
+    let _ = compile_workspace_full(workspace, compile_options);
+    for res in rx {
+        let debounced_events = res.map_err(|mut err| err.remove(0))?;
+
+        // We only want to trigger a rebuild if a noir source file has been modified.
+        let noir_files_modified = debounced_events.iter().any(|event| {
+            let mut event_paths = event.event.paths.iter();
+            let event_affects_noir_file =
+                event_paths.any(|path| path.extension().map_or(false, |ext| ext == "nr"));
+
+            let is_relevant_event_kind = matches!(
+                event.kind,
+                EventKind::Create(_) | EventKind::Modify(_) | EventKind::Remove(_)
+            );
+
+            is_relevant_event_kind && event_affects_noir_file
+        });
+
+        if noir_files_modified {
+            write!(screen, "{}{}", termion::cursor::Restore, termion::clear::AfterCursor).unwrap();
+            screen.flush().unwrap();
+            let _ = compile_workspace_full(workspace, compile_options);
+        }
+    }
+
+    screen.flush().unwrap();
+
+    Ok(())
+}
+
+fn compile_workspace_full(
+    workspace: &Workspace,
+    compile_options: &CompileOptions,
+) -> Result<(), CliError> {
     let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
+    insert_all_files_for_workspace_into_file_manager(workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
-    let compiled_workspace = compile_workspace(
-        &workspace_file_manager,
-        &parsed_files,
-        &workspace,
-        &args.compile_options,
-    );
+    let expression_width =
+        compile_options.expression_width.expect("expression width should have been set");
+    let compiled_workspace =
+        compile_workspace(&workspace_file_manager, &parsed_files, workspace, compile_options);
 
     let (compiled_programs, compiled_contracts) = report_errors(
         compiled_workspace,
         &workspace_file_manager,
-        args.compile_options.deny_warnings,
-        args.compile_options.silence_warnings,
+        compile_options.deny_warnings,
+        compile_options.silence_warnings,
     )?;
 
     let (binary_packages, contract_packages): (Vec<_>, Vec<_>) = workspace
@@ -85,11 +147,12 @@ pub(crate) fn run(
         .partition(|package| package.is_binary());
 
     // Save build artifacts to disk.
-    let only_acir = args.compile_options.only_acir;
+    let only_acir = compile_options.only_acir;
     for (package, program) in binary_packages.into_iter().zip(compiled_programs) {
         let program = nargo::ops::transform_program(program, expression_width);
         save_program(program.clone(), &package, &workspace.target_directory_path(), only_acir);
     }
+    let circuit_dir = workspace.target_directory_path();
     for (package, contract) in contract_packages.into_iter().zip(compiled_contracts) {
         let contract = nargo::ops::transform_contract(contract, expression_width);
         save_contract(contract, &package, &circuit_dir);

From d8710c4442be2fcffc348f1f5776bc278d028ad0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 13 Mar 2024 15:17:41 -0500
Subject: [PATCH 076/416] chore: Add `Instruction::DecrementRc` (#4525)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4522

## Summary\*

Experimenting with this to see how much it improves performance of
unconstrained code using arrays.

## Additional Context

Currently the new dec_rc instruction is only issued for function
parameters when a function is finished - assuming the parameters are not
also returned.

CC @sirasistant for visibility

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Álvaro Rodríguez <sirasistant@gmail.com>
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 18 ++++++++---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  2 +-
 .../src/ssa/function_builder/mod.rs           | 21 ++++++++++++-
 .../noirc_evaluator/src/ssa/ir/instruction.rs | 16 +++++++++-
 .../noirc_evaluator/src/ssa/ir/printer.rs     |  3 ++
 compiler/noirc_evaluator/src/ssa/opt/die.rs   | 26 +++++++++-------
 .../src/ssa/ssa_gen/context.rs                | 31 +++++++++++++++++++
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  9 +++---
 8 files changed, 103 insertions(+), 23 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 911f4c1924e..938a80e87d1 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -227,9 +227,7 @@ impl<'block> BrilligBlock<'block> {
                         dfg,
                     );
                 }
-                _ => {
-                    todo!("ICE: Param type not supported")
-                }
+                Type::Function => todo!("ICE: Type::Function Param not supported"),
             }
         }
     }
@@ -661,11 +659,21 @@ impl<'block> BrilligBlock<'block> {
                 let rc_register = match self.convert_ssa_value(*value, dfg) {
                     BrilligVariable::BrilligArray(BrilligArray { rc, .. })
                     | BrilligVariable::BrilligVector(BrilligVector { rc, .. }) => rc,
-                    _ => unreachable!("ICE: increment rc on non-array"),
+                    other => unreachable!("ICE: increment rc on non-array: {other:?}"),
                 };
                 self.brillig_context.usize_op_in_place(rc_register, BinaryIntOp::Add, 1);
             }
-            _ => todo!("ICE: Instruction not supported {instruction:?}"),
+            Instruction::DecrementRc { value } => {
+                let rc_register = match self.convert_ssa_value(*value, dfg) {
+                    BrilligVariable::BrilligArray(BrilligArray { rc, .. })
+                    | BrilligVariable::BrilligVector(BrilligVector { rc, .. }) => rc,
+                    other => unreachable!("ICE: decrement rc on non-array: {other:?}"),
+                };
+                self.brillig_context.usize_op_in_place(rc_register, BinaryIntOp::Sub, 1);
+            }
+            Instruction::EnableSideEffects { .. } => {
+                todo!("enable_side_effects not supported by brillig")
+            }
         };
 
         let dead_variables = self
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 140ed0b53ff..4442efe286a 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -503,7 +503,7 @@ impl Context {
             Instruction::Load { .. } => {
                 unreachable!("Expected all load instructions to be removed before acir_gen")
             }
-            Instruction::IncrementRc { .. } => {
+            Instruction::IncrementRc { .. } | Instruction::DecrementRc { .. } => {
                 // Do nothing. Only Brillig needs to worry about reference counted arrays
             }
             Instruction::RangeCheck { value, max_bit_size, assert_message } => {
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index bf34a47485b..2c39c83b342 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -384,6 +384,20 @@ impl FunctionBuilder {
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
     pub(crate) fn increment_array_reference_count(&mut self, value: ValueId) {
+        self.update_array_reference_count(value, true);
+    }
+
+    /// Insert instructions to decrement the reference count of any array(s) stored
+    /// within the given value. If the given value is not an array and does not contain
+    /// any arrays, this does nothing.
+    pub(crate) fn decrement_array_reference_count(&mut self, value: ValueId) {
+        self.update_array_reference_count(value, false);
+    }
+
+    /// Increment or decrement the given value's reference count if it is an array.
+    /// If it is not an array, this does nothing. Note that inc_rc and dec_rc instructions
+    /// are ignored outside of unconstrained code.
+    pub(crate) fn update_array_reference_count(&mut self, value: ValueId, increment: bool) {
         match self.type_of_value(value) {
             Type::Numeric(_) => (),
             Type::Function => (),
@@ -396,7 +410,12 @@ impl FunctionBuilder {
             typ @ Type::Array(..) | typ @ Type::Slice(..) => {
                 // If there are nested arrays or slices, we wait until ArrayGet
                 // is issued to increment the count of that array.
-                self.insert_instruction(Instruction::IncrementRc { value }, None);
+                let instruction = if increment {
+                    Instruction::IncrementRc { value }
+                } else {
+                    Instruction::DecrementRc { value }
+                };
+                self.insert_instruction(instruction, None);
 
                 // This is a bit odd, but in brillig the inc_rc instruction operates on
                 // a copy of the array's metadata, so we need to re-store a loaded array
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 0b6c7074e45..afade4b0616 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -194,6 +194,13 @@ pub(crate) enum Instruction {
     /// implemented via reference counting. In ACIR code this is done with im::Vector and these
     /// IncrementRc instructions are ignored.
     IncrementRc { value: ValueId },
+
+    /// An instruction to decrement the reference count of a value.
+    ///
+    /// This currently only has an effect in Brillig code where array sharing and copy on write is
+    /// implemented via reference counting. In ACIR code this is done with im::Vector and these
+    /// DecrementRc instructions are ignored.
+    DecrementRc { value: ValueId },
 }
 
 impl Instruction {
@@ -214,6 +221,7 @@ impl Instruction {
             Instruction::Constrain(..)
             | Instruction::Store { .. }
             | Instruction::IncrementRc { .. }
+            | Instruction::DecrementRc { .. }
             | Instruction::RangeCheck { .. }
             | Instruction::EnableSideEffects { .. } => InstructionResultType::None,
             Instruction::Allocate { .. }
@@ -250,6 +258,7 @@ impl Instruction {
             | Load { .. }
             | Store { .. }
             | IncrementRc { .. }
+            | DecrementRc { .. }
             | RangeCheck { .. } => false,
 
             Call { func, .. } => match dfg[*func] {
@@ -285,6 +294,7 @@ impl Instruction {
             | Store { .. }
             | EnableSideEffects { .. }
             | IncrementRc { .. }
+            | DecrementRc { .. }
             | RangeCheck { .. } => true,
 
             // Some `Intrinsic`s have side effects so we must check what kind of `Call` this is.
@@ -353,6 +363,7 @@ impl Instruction {
                 Instruction::ArraySet { array: f(*array), index: f(*index), value: f(*value) }
             }
             Instruction::IncrementRc { value } => Instruction::IncrementRc { value: f(*value) },
+            Instruction::DecrementRc { value } => Instruction::DecrementRc { value: f(*value) },
             Instruction::RangeCheck { value, max_bit_size, assert_message } => {
                 Instruction::RangeCheck {
                     value: f(*value),
@@ -409,7 +420,9 @@ impl Instruction {
             Instruction::EnableSideEffects { condition } => {
                 f(*condition);
             }
-            Instruction::IncrementRc { value } | Instruction::RangeCheck { value, .. } => {
+            Instruction::IncrementRc { value }
+            | Instruction::DecrementRc { value }
+            | Instruction::RangeCheck { value, .. } => {
                 f(*value);
             }
         }
@@ -554,6 +567,7 @@ impl Instruction {
             Instruction::Load { .. } => None,
             Instruction::Store { .. } => None,
             Instruction::IncrementRc { .. } => None,
+            Instruction::DecrementRc { .. } => None,
             Instruction::RangeCheck { value, max_bit_size, .. } => {
                 if let Some(numeric_constant) = dfg.get_numeric_constant(*value) {
                     if numeric_constant.num_bits() < *max_bit_size {
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 9bd43fab1ff..6ef618fba6f 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -188,6 +188,9 @@ fn display_instruction_inner(
         Instruction::IncrementRc { value } => {
             writeln!(f, "inc_rc {}", show(*value))
         }
+        Instruction::DecrementRc { value } => {
+            writeln!(f, "dec_rc {}", show(*value))
+        }
         Instruction::RangeCheck { value, max_bit_size, .. } => {
             writeln!(f, "range_check {} to {} bits", show(*value), *max_bit_size,)
         }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index f7d8adb5275..4c7beff0fbe 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -44,7 +44,7 @@ fn dead_instruction_elimination(function: &mut Function) {
         context.remove_unused_instructions_in_block(function, *block);
     }
 
-    context.remove_increment_rc_instructions(&mut function.dfg);
+    context.remove_rc_instructions(&mut function.dfg);
 }
 
 /// Per function context for tracking unused values and which instructions to remove.
@@ -53,10 +53,10 @@ struct Context {
     used_values: HashSet<ValueId>,
     instructions_to_remove: HashSet<InstructionId>,
 
-    /// IncrementRc instructions must be revisited after the main DIE pass since
+    /// IncrementRc & DecrementRc instructions must be revisited after the main DIE pass since
     /// they technically contain side-effects but we still want to remove them if their
     /// `value` parameter is not used elsewhere.
-    increment_rc_instructions: Vec<(InstructionId, BasicBlockId)>,
+    rc_instructions: Vec<(InstructionId, BasicBlockId)>,
 }
 
 impl Context {
@@ -85,8 +85,9 @@ impl Context {
             } else {
                 let instruction = &function.dfg[*instruction_id];
 
-                if let Instruction::IncrementRc { .. } = instruction {
-                    self.increment_rc_instructions.push((*instruction_id, block_id));
+                use Instruction::*;
+                if matches!(instruction, IncrementRc { .. } | DecrementRc { .. }) {
+                    self.rc_instructions.push((*instruction_id, block_id));
                 } else {
                     instruction.for_each_value(|value| {
                         self.mark_used_instruction_results(&function.dfg, value);
@@ -145,16 +146,19 @@ impl Context {
         }
     }
 
-    fn remove_increment_rc_instructions(self, dfg: &mut DataFlowGraph) {
-        for (increment_rc, block) in self.increment_rc_instructions {
-            let value = match &dfg[increment_rc] {
+    fn remove_rc_instructions(self, dfg: &mut DataFlowGraph) {
+        for (rc, block) in self.rc_instructions {
+            let value = match &dfg[rc] {
                 Instruction::IncrementRc { value } => *value,
-                other => unreachable!("Expected IncrementRc instruction, found {other:?}"),
+                Instruction::DecrementRc { value } => *value,
+                other => {
+                    unreachable!("Expected IncrementRc or DecrementRc instruction, found {other:?}")
+                }
             };
 
-            // This could be more efficient if we have to remove multiple IncrementRcs in a single block
+            // This could be more efficient if we have to remove multiple instructions in a single block
             if !self.used_values.contains(&value) {
-                dfg[block].instructions_mut().retain(|instruction| *instruction != increment_rc);
+                dfg[block].instructions_mut().retain(|instruction| *instruction != rc);
             }
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index 9c760c013a9..409b99958a9 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -10,6 +10,7 @@ use noirc_frontend::{BinaryOpKind, Signedness};
 
 use crate::errors::RuntimeError;
 use crate::ssa::function_builder::FunctionBuilder;
+use crate::ssa::ir::basic_block::BasicBlockId;
 use crate::ssa::ir::dfg::DataFlowGraph;
 use crate::ssa::ir::function::FunctionId as IrFunctionId;
 use crate::ssa::ir::function::{Function, RuntimeType};
@@ -1022,6 +1023,36 @@ impl<'a> FunctionContext<'a> {
             }
         }
     }
+
+    /// Increments the reference count of all parameters. Returns the entry block of the function.
+    ///
+    /// This is done on parameters rather than call arguments so that we can optimize out
+    /// paired inc/dec instructions within brillig functions more easily.
+    pub(crate) fn increment_parameter_rcs(&mut self) -> BasicBlockId {
+        let entry = self.builder.current_function.entry_block();
+        let parameters = self.builder.current_function.dfg.block_parameters(entry).to_vec();
+
+        for parameter in parameters {
+            self.builder.increment_array_reference_count(parameter);
+        }
+
+        entry
+    }
+
+    /// Ends a local scope of a function.
+    /// This will issue DecrementRc instructions for any arrays in the given starting scope
+    /// block's parameters. Arrays that are also used in terminator instructions for the scope are
+    /// ignored.
+    pub(crate) fn end_scope(&mut self, scope: BasicBlockId, terminator_args: &[ValueId]) {
+        let mut dropped_parameters =
+            self.builder.current_function.dfg.block_parameters(scope).to_vec();
+
+        dropped_parameters.retain(|parameter| !terminator_args.contains(parameter));
+
+        for parameter in dropped_parameters {
+            self.builder.decrement_array_reference_count(parameter);
+        }
+    }
 }
 
 /// True if the given operator cannot be encoded directly and needs
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index f3fa5d1d2f8..3d8ae0bb3eb 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -121,8 +121,11 @@ impl<'a> FunctionContext<'a> {
     /// Codegen a function's body and set its return value to that of its last parameter.
     /// For functions returning nothing, this will be an empty list.
     fn codegen_function_body(&mut self, body: &Expression) -> Result<(), RuntimeError> {
+        let entry_block = self.increment_parameter_rcs();
         let return_value = self.codegen_expression(body)?;
         let results = return_value.into_value_list(self);
+        self.end_scope(entry_block, &results);
+
         self.builder.terminate_with_return(results);
         Ok(())
     }
@@ -595,10 +598,8 @@ impl<'a> FunctionContext<'a> {
             arguments.append(&mut values);
         }
 
-        // If an array is passed as an argument we increase its reference count
-        for argument in &arguments {
-            self.builder.increment_array_reference_count(*argument);
-        }
+        // Don't need to increment array reference counts when passed in as arguments
+        // since it is done within the function to each parameter already.
 
         self.codegen_intrinsic_call_checks(function, &arguments, call.location);
         Ok(self.insert_call(function, arguments, &call.return_type, call.location))

From d4213a03c9f77ee8e7663fc965a825258d90a368 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Thu, 14 Mar 2024 05:55:50 -0400
Subject: [PATCH 077/416] feat: Sync from aztec-packages (#4546)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
chore: Pull noir
(https://github.com/AztecProtocol/aztec-packages/pull/5193)
feat: Check initialization arguments in constructors
(https://github.com/AztecProtocol/aztec-packages/pull/5144)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 .aztec-sync-commit                       |  2 +-
 aztec_macros/src/transforms/functions.rs | 23 +++++++++++++++++++++++
 cspell.json                              |  1 +
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 5a1cd9c70bd..4d9320c79ba 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-58e15edf7fd3d32267b0aed883fc84f6cee327c9
+aa90f6ed7bfae06bdf6990816d154bbd24993689
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 8b3c7d2f53b..09c11e173fe 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -48,6 +48,12 @@ pub fn transform_function(
         func.def.body.0.insert(0, init_check);
     }
 
+    // Add assertion for initialization arguments
+    if is_initializer {
+        let assert_init_args = create_assert_init_args();
+        func.def.body.0.insert(0, assert_init_args);
+    }
+
     // Add access to the storage struct
     if storage_defined {
         let storage_def = abstract_storage(&ty.to_lowercase(), false);
@@ -205,6 +211,23 @@ fn create_internal_check(fname: &str) -> Statement {
     )))
 }
 
+/// Creates a call to assert_initialization_args_match_address_preimage to ensure
+/// the initialization arguments used in the init call match the address preimage.
+///
+/// ```noir
+/// assert_initialization_args_match_address_preimage(context);
+/// ```
+fn create_assert_init_args() -> Statement {
+    make_statement(StatementKind::Expression(call(
+        variable_path(chained_dep!(
+            "aztec",
+            "initializer",
+            "assert_initialization_args_match_address_preimage"
+        )),
+        vec![variable("context")],
+    )))
+}
+
 /// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
 /// appended into the args hash object.
 ///
diff --git a/cspell.json b/cspell.json
index 34dafa2b614..8cfc5e695a2 100644
--- a/cspell.json
+++ b/cspell.json
@@ -140,6 +140,7 @@
         "plonkc",
         "PLONKish",
         "pprof",
+        "preimage",
         "preprocess",
         "prettytable",
         "printstd",

From 57dd91b18faaceba457ee8b76b6819cea6bb7359 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 14 Mar 2024 10:02:35 -0500
Subject: [PATCH 078/416] chore: Add more `Hash` impls to stdlib (#4470)

# Description

## Problem\*

Resolves a TODO in #4241

## Summary\*

Adds the remaining Hash impls for primitive types in the stdlib

## Additional Context

I've marked this as "no documentation needed" but we should probably
document somewhere that these types are hashable. Where should this go?
The existing "hash methods" page doesn't seem to fit.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/hash.nr | 101 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 97 insertions(+), 4 deletions(-)

diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index fcf21436197..896dae15371 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -4,6 +4,7 @@ mod poseidon2;
 mod pedersen;
 
 use crate::default::Default;
+use crate::uint128::U128;
 
 #[foreign(sha256)]
 // docs:start:sha256
@@ -120,10 +121,102 @@ where
     }    
 }
 
-// TODO: add implementations for the remainder of primitive types.
-impl Hash for Field{
+impl Hash for Field {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        let input: [Field] = [self];
-        H::write(state, input);
+        H::write(state, [self]);
+    }
+}
+
+impl Hash for u8 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for u32 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for u64 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for i8 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for i32 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for i64 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for bool {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self as Field]);
+    }
+}
+
+impl Hash for () {
+    fn hash<H>(_self: Self, _state: &mut H) where H: Hasher {}
+}
+
+impl Hash for U128 {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        H::write(state, [self.lo as Field, self.hi as Field]);
+    }
+}
+
+impl<T, N> Hash for [T; N] where T: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        for elem in self {
+            elem.hash(state);
+        }
+    }
+}
+
+impl<A, B> Hash for (A, B) where A: Hash, B: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        self.0.hash(state);
+        self.1.hash(state);
+    }
+}
+
+impl<A, B, C> Hash for (A, B, C) where A: Hash, B: Hash, C: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        self.0.hash(state);
+        self.1.hash(state);
+        self.2.hash(state);
+    }
+}
+
+impl<A, B, C, D> Hash for (A, B, C, D) where A: Hash, B: Hash, C: Hash, D: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        self.0.hash(state);
+        self.1.hash(state);
+        self.2.hash(state);
+        self.3.hash(state);
+    }
+}
+
+impl<A, B, C, D, E> Hash for (A, B, C, D, E) where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        self.0.hash(state);
+        self.1.hash(state);
+        self.2.hash(state);
+        self.3.hash(state);
+        self.4.hash(state);
     }
 }

From c8aa16bc7e78456cce1736fac82496996a8761f4 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 14 Mar 2024 10:40:26 -0500
Subject: [PATCH 079/416] fix: Evaluate operators in globals in types (#4537)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Evaluate operators in the definitions of globals when these globals are
used in a type position.

This often happens when using a global as the size of an array where the
global is the result
of some arithmetic expression.

## Additional Context

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/resolution/resolver.rs            | 65 +++++++++++++++++--
 compiler/noirc_frontend/src/tests.rs          | 12 ++++
 2 files changed, 72 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 00b1b443430..c33b83257b0 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -37,11 +37,11 @@ use crate::{
     StatementKind,
 };
 use crate::{
-    ArrayLiteral, Distinctness, ForRange, FunctionDefinition, FunctionReturnType, Generics,
-    ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern, Shared,
-    StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp, UnresolvedGenerics,
-    UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
-    Visibility, ERROR_IDENT,
+    ArrayLiteral, BinaryOpKind, Distinctness, ForRange, FunctionDefinition, FunctionReturnType,
+    Generics, ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
+    Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp,
+    UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData,
+    UnresolvedTypeExpression, Visibility, ERROR_IDENT,
 };
 use fm::FileId;
 use iter_extended::vecmap;
@@ -1943,10 +1943,65 @@ impl<'a> Resolver<'a> {
         rhs: ExprId,
         span: Span,
     ) -> Result<u128, Option<ResolverError>> {
+        // Arbitrary amount of recursive calls to try before giving up
+        let fuel = 100;
+        self.try_eval_array_length_id_with_fuel(rhs, span, fuel)
+    }
+
+    fn try_eval_array_length_id_with_fuel(
+        &self,
+        rhs: ExprId,
+        span: Span,
+        fuel: u32,
+    ) -> Result<u128, Option<ResolverError>> {
+        if fuel == 0 {
+            // If we reach here, it is likely from evaluating cyclic globals. We expect an error to
+            // be issued for them after name resolution so issue no error now.
+            return Err(None);
+        }
+
         match self.interner.expression(&rhs) {
             HirExpression::Literal(HirLiteral::Integer(int, false)) => {
                 int.try_into_u128().ok_or(Some(ResolverError::IntegerTooLarge { span }))
             }
+            HirExpression::Ident(ident) => {
+                let definition = self.interner.definition(ident.id);
+                match definition.kind {
+                    DefinitionKind::Global(global_id) => {
+                        let let_statement = self.interner.get_global_let_statement(global_id);
+                        if let Some(let_statement) = let_statement {
+                            let expression = let_statement.expression;
+                            self.try_eval_array_length_id_with_fuel(expression, span, fuel - 1)
+                        } else {
+                            Err(Some(ResolverError::InvalidArrayLengthExpr { span }))
+                        }
+                    }
+                    _ => Err(Some(ResolverError::InvalidArrayLengthExpr { span })),
+                }
+            }
+            HirExpression::Infix(infix) => {
+                let lhs = self.try_eval_array_length_id_with_fuel(infix.lhs, span, fuel - 1)?;
+                let rhs = self.try_eval_array_length_id_with_fuel(infix.rhs, span, fuel - 1)?;
+
+                match infix.operator.kind {
+                    BinaryOpKind::Add => Ok(lhs + rhs),
+                    BinaryOpKind::Subtract => Ok(lhs - rhs),
+                    BinaryOpKind::Multiply => Ok(lhs * rhs),
+                    BinaryOpKind::Divide => Ok(lhs / rhs),
+                    BinaryOpKind::Equal => Ok((lhs == rhs) as u128),
+                    BinaryOpKind::NotEqual => Ok((lhs != rhs) as u128),
+                    BinaryOpKind::Less => Ok((lhs < rhs) as u128),
+                    BinaryOpKind::LessEqual => Ok((lhs <= rhs) as u128),
+                    BinaryOpKind::Greater => Ok((lhs > rhs) as u128),
+                    BinaryOpKind::GreaterEqual => Ok((lhs >= rhs) as u128),
+                    BinaryOpKind::And => Ok(lhs & rhs),
+                    BinaryOpKind::Or => Ok(lhs | rhs),
+                    BinaryOpKind::Xor => Ok(lhs ^ rhs),
+                    BinaryOpKind::ShiftRight => Ok(lhs >> rhs),
+                    BinaryOpKind::ShiftLeft => Ok(lhs << rhs),
+                    BinaryOpKind::Modulo => Ok(lhs % rhs),
+                }
+            }
             _other => Err(Some(ResolverError::InvalidArrayLengthExpr { span })),
         }
     }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 1158f4c229a..b8ed6fb73d2 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1214,6 +1214,18 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         assert_eq!(get_program_errors(src).len(), 0);
     }
 
+    #[test]
+    fn operators_in_global_used_in_type() {
+        let src = r#"
+            global ONE = 1;
+            global COUNT = ONE + 2;
+            fn main() {
+                let _array: [Field; COUNT] = [1, 2, 3];
+            }
+        "#;
+        assert_eq!(get_program_errors(src).len(), 0);
+    }
+
     // Regression for #4545
     #[test]
     fn type_aliases_in_main() {

From de4986eb74b28b2e1065fa6b413d02457ddf61b0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 14 Mar 2024 11:18:23 -0500
Subject: [PATCH 080/416] fix: Make `nargo` the default binary for cargo run
 (#4554)

# Description

## Problem\*

The acvm binary was added recently which prevents developers from using
`cargo run` without an additional `--bin nargo` to specify the nargo
binary

## Summary\*

Sets the default binary to run to `nargo` for `cargo run`.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index f92a2421b0f..1629ae86edb 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -1,6 +1,7 @@
 [package]
 name = "nargo_cli"
 description = "Noir's package manager"
+default-run = "nargo"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true

From fe9a437b6d7ddc3f78665df1a576236555880c51 Mon Sep 17 00:00:00 2001
From: Andy <35195301+Andy53@users.noreply.github.com>
Date: Thu, 14 Mar 2024 11:37:05 -0600
Subject: [PATCH 081/416] feat: remove curly braces with fmt  (#4529)

# Description

## Problem\*

Resolves
https://github.com/noir-lang/noir/compare/master...Andy53:noir:fmt_remvoes_curly_braces_when_there_is_a_single_import?expand=1

Closes #4480

## Summary\*
Removes curly braces from imports when there is only a single import.

`use dep::std::hash::{sha256};`

becomes:
`use dep::std::hash::sha256;


## Additional Context



## Documentation\*

Check one:
- [ X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ X] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jfecher11@gmail.com>
---
 noir_stdlib/src/array.nr                          | 2 +-
 tooling/nargo_fmt/src/rewrite/imports.rs          | 9 ++++++++-
 tooling/nargo_fmt/tests/expected/contract.nr      | 2 +-
 tooling/nargo_fmt/tests/expected/import_braces.nr | 1 +
 tooling/nargo_fmt/tests/input/contract.nr         | 2 +-
 tooling/nargo_fmt/tests/input/import_braces.nr    | 1 +
 6 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 tooling/nargo_fmt/tests/expected/import_braces.nr
 create mode 100644 tooling/nargo_fmt/tests/input/import_braces.nr

diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index 3da4b649174..baa4bef50cc 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -1,4 +1,4 @@
-use crate::cmp::{Ord};
+use crate::cmp::Ord;
 
 // TODO: Once we fully move to the new SSA pass this module can be removed and replaced
 // by the methods in the `slice` module
diff --git a/tooling/nargo_fmt/src/rewrite/imports.rs b/tooling/nargo_fmt/src/rewrite/imports.rs
index 2788f778140..55eb259bcdd 100644
--- a/tooling/nargo_fmt/src/rewrite/imports.rs
+++ b/tooling/nargo_fmt/src/rewrite/imports.rs
@@ -102,7 +102,14 @@ impl UseTree {
 
         let mut iter = self.path.iter().peekable();
         while let Some(segment) = iter.next() {
-            let segment_str = segment.rewrite(visitor, shape);
+            let mut segment_str = segment.rewrite(visitor, shape);
+            if segment_str.contains('{')
+                && !segment_str.contains(',')
+                && !segment_str.contains("::")
+            {
+                let empty = "";
+                segment_str = segment_str.replace(['{', '}'], empty);
+            }
             result.push_str(&segment_str);
 
             if iter.peek().is_some() {
diff --git a/tooling/nargo_fmt/tests/expected/contract.nr b/tooling/nargo_fmt/tests/expected/contract.nr
index c5b19a686d2..97a6ebd6b77 100644
--- a/tooling/nargo_fmt/tests/expected/contract.nr
+++ b/tooling/nargo_fmt/tests/expected/contract.nr
@@ -11,7 +11,7 @@ contract Benchmarking {
         context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
         log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
-        types::address::{AztecAddress}
+        types::address::AztecAddress
     };
 
     struct Storage {
diff --git a/tooling/nargo_fmt/tests/expected/import_braces.nr b/tooling/nargo_fmt/tests/expected/import_braces.nr
new file mode 100644
index 00000000000..49c9d09001e
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/import_braces.nr
@@ -0,0 +1 @@
+use dep::std::hash::sha256;
diff --git a/tooling/nargo_fmt/tests/input/contract.nr b/tooling/nargo_fmt/tests/input/contract.nr
index c5b19a686d2..97a6ebd6b77 100644
--- a/tooling/nargo_fmt/tests/input/contract.nr
+++ b/tooling/nargo_fmt/tests/input/contract.nr
@@ -11,7 +11,7 @@ contract Benchmarking {
         context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
         log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
-        types::address::{AztecAddress}
+        types::address::AztecAddress
     };
 
     struct Storage {
diff --git a/tooling/nargo_fmt/tests/input/import_braces.nr b/tooling/nargo_fmt/tests/input/import_braces.nr
new file mode 100644
index 00000000000..88c7e9562a8
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/import_braces.nr
@@ -0,0 +1 @@
+use dep::std::hash::{sha256};
\ No newline at end of file

From 3ad88696ab63d8b1838b4ca7e9a3a97f823ca976 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 14 Mar 2024 20:38:06 +0000
Subject: [PATCH 082/416] chore: separate tests for execution failures from
 compilation failures (#4559)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I just had a test pass when it should have failed in #4491 because
despite compiling when it shouldn't have, it failed in execution
(because I didn't provide a `Prover.toml` but the circuit took
arguments).

We're then masking potential test failures by not separating circuits
which we expect to fail to compile vs fail to execute. I've created an
`execution_failure` directory to hold all of the latter and updated the
`compile_failure` tests to only compile the circuit rather than
executing it.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../brillig_nested_slices/Prover.toml         |  2 -
 .../custom_entry_not_found/Prover.toml        |  1 -
 .../dep_impl_primitive/Prover.toml            |  1 -
 .../compile_failure/depend_on_bin/Prover.toml |  1 -
 .../div_by_zero_modulo/Prover.toml            |  0
 .../dup_trait_implementation_4/Prover.toml    |  0
 .../dup_trait_implementation_5/Prover.toml    |  0
 .../dup_trait_items_1/Prover.toml             |  0
 .../dup_trait_items_2/Prover.toml             |  0
 .../dup_trait_items_3/Prover.toml             |  0
 .../dup_trait_items_4/Prover.toml             |  0
 .../dup_trait_items_5/Prover.toml             |  0
 .../dup_trait_items_6/Prover.toml             |  0
 .../hashmap_load_factor/Prover.toml           | 26 ------------
 .../negate_unsigned/Prover.toml               |  0
 .../orphaned_trait_impl/Prover.toml           |  2 -
 .../slice_remove_failure/Prover.toml          |  2 -
 .../crates/a/Prover.toml                      |  2 -
 .../crates/b/Prover.toml                      |  2 -
 .../assert_msg_runtime/Nargo.toml             |  0
 .../assert_msg_runtime/Prover.toml            |  0
 .../assert_msg_runtime/src/main.nr            |  0
 .../brillig_assert_fail/Nargo.toml            |  0
 .../brillig_assert_fail/Prover.toml           |  0
 .../brillig_assert_fail/src/main.nr           |  0
 .../brillig_assert_msg_runtime/Nargo.toml     |  0
 .../brillig_assert_msg_runtime/Prover.toml    |  0
 .../brillig_assert_msg_runtime/src/main.nr    |  0
 .../div_by_zero_constants/Nargo.toml          |  0
 .../div_by_zero_constants}/Prover.toml        |  0
 .../div_by_zero_constants/src/main.nr         |  0
 .../div_by_zero_modulo/Nargo.toml             |  0
 .../div_by_zero_modulo}/Prover.toml           |  0
 .../div_by_zero_modulo/src/main.nr            |  0
 .../div_by_zero_numerator_witness/Nargo.toml  |  0
 .../div_by_zero_numerator_witness/Prover.toml |  0
 .../div_by_zero_numerator_witness/src/main.nr |  0
 .../div_by_zero_witness/Nargo.toml            |  0
 .../div_by_zero_witness/Prover.toml           |  0
 .../div_by_zero_witness/src/main.nr           |  0
 .../dyn_index_fail_nested_array/Nargo.toml    |  0
 .../dyn_index_fail_nested_array/Prover.toml   |  0
 .../dyn_index_fail_nested_array/src/main.nr   |  0
 .../dynamic_index_failure/Nargo.toml          |  0
 .../dynamic_index_failure/Prover.toml         |  0
 .../dynamic_index_failure/src/main.nr         |  0
 .../option_expect/Nargo.toml                  |  0
 .../option_expect/src/main.nr                 |  0
 .../slice_access_failure/Nargo.toml           |  0
 .../slice_access_failure}/Prover.toml         |  0
 .../slice_access_failure/src/main.nr          |  0
 .../slice_insert_failure/Nargo.toml           |  0
 .../slice_insert_failure}/Prover.toml         |  0
 .../slice_insert_failure/src/main.nr          |  0
 .../slice_remove_failure/Nargo.toml           |  0
 .../slice_remove_failure}/Prover.toml         |  0
 .../slice_remove_failure/src/main.nr          |  0
 .../workspace_fail/Nargo.toml                 |  0
 .../workspace_fail/crates/a/Nargo.toml        |  0
 .../workspace_fail/crates/a/Prover.toml       |  0
 .../workspace_fail/crates/a/src/main.nr       |  0
 .../workspace_fail/crates/b/Nargo.toml        |  0
 .../workspace_fail/crates/b/Prover.toml       |  0
 .../workspace_fail/crates/b/src/main.nr       |  0
 tooling/nargo_cli/build.rs                    | 41 ++++++++++++++++++-
 65 files changed, 40 insertions(+), 40 deletions(-)
 delete mode 100644 test_programs/compile_failure/brillig_nested_slices/Prover.toml
 delete mode 100644 test_programs/compile_failure/custom_entry_not_found/Prover.toml
 delete mode 100644 test_programs/compile_failure/dep_impl_primitive/Prover.toml
 delete mode 100644 test_programs/compile_failure/depend_on_bin/Prover.toml
 delete mode 100644 test_programs/compile_failure/div_by_zero_modulo/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_implementation_4/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_implementation_5/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_items_1/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_items_2/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_items_3/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_items_4/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_items_5/Prover.toml
 delete mode 100644 test_programs/compile_failure/dup_trait_items_6/Prover.toml
 delete mode 100644 test_programs/compile_failure/hashmap_load_factor/Prover.toml
 delete mode 100644 test_programs/compile_failure/negate_unsigned/Prover.toml
 delete mode 100644 test_programs/compile_failure/orphaned_trait_impl/Prover.toml
 delete mode 100644 test_programs/compile_failure/slice_remove_failure/Prover.toml
 delete mode 100644 test_programs/compile_failure/workspace_missing_toml/crates/a/Prover.toml
 delete mode 100644 test_programs/compile_failure/workspace_missing_toml/crates/b/Prover.toml
 rename test_programs/{compile_failure => execution_failure}/assert_msg_runtime/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/assert_msg_runtime/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/assert_msg_runtime/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/brillig_assert_fail/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/brillig_assert_fail/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/brillig_assert_fail/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/brillig_assert_msg_runtime/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/brillig_assert_msg_runtime/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/brillig_assert_msg_runtime/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_constants/Nargo.toml (100%)
 rename test_programs/{compile_failure/cyclic_dep => execution_failure/div_by_zero_constants}/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_constants/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_modulo/Nargo.toml (100%)
 rename test_programs/{compile_failure/div_by_zero_constants => execution_failure/div_by_zero_modulo}/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_modulo/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_numerator_witness/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_numerator_witness/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_numerator_witness/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_witness/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_witness/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/div_by_zero_witness/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/dyn_index_fail_nested_array/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/dyn_index_fail_nested_array/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/dyn_index_fail_nested_array/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/dynamic_index_failure/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/dynamic_index_failure/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/dynamic_index_failure/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/option_expect/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/option_expect/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/slice_access_failure/Nargo.toml (100%)
 rename test_programs/{compile_failure/radix_non_constant_length => execution_failure/slice_access_failure}/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/slice_access_failure/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/slice_insert_failure/Nargo.toml (100%)
 rename test_programs/{compile_failure/slice_access_failure => execution_failure/slice_insert_failure}/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/slice_insert_failure/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/slice_remove_failure/Nargo.toml (100%)
 rename test_programs/{compile_failure/slice_insert_failure => execution_failure/slice_remove_failure}/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/slice_remove_failure/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/crates/a/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/crates/a/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/crates/a/src/main.nr (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/crates/b/Nargo.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/crates/b/Prover.toml (100%)
 rename test_programs/{compile_failure => execution_failure}/workspace_fail/crates/b/src/main.nr (100%)

diff --git a/test_programs/compile_failure/brillig_nested_slices/Prover.toml b/test_programs/compile_failure/brillig_nested_slices/Prover.toml
deleted file mode 100644
index c52564de922..00000000000
--- a/test_programs/compile_failure/brillig_nested_slices/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-a = "5"
-b = "10"
diff --git a/test_programs/compile_failure/custom_entry_not_found/Prover.toml b/test_programs/compile_failure/custom_entry_not_found/Prover.toml
deleted file mode 100644
index 4dd6b405159..00000000000
--- a/test_programs/compile_failure/custom_entry_not_found/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = "1"
diff --git a/test_programs/compile_failure/dep_impl_primitive/Prover.toml b/test_programs/compile_failure/dep_impl_primitive/Prover.toml
deleted file mode 100644
index 7d4290a117a..00000000000
--- a/test_programs/compile_failure/dep_impl_primitive/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = 1
diff --git a/test_programs/compile_failure/depend_on_bin/Prover.toml b/test_programs/compile_failure/depend_on_bin/Prover.toml
deleted file mode 100644
index 7d4290a117a..00000000000
--- a/test_programs/compile_failure/depend_on_bin/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = 1
diff --git a/test_programs/compile_failure/div_by_zero_modulo/Prover.toml b/test_programs/compile_failure/div_by_zero_modulo/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_implementation_4/Prover.toml b/test_programs/compile_failure/dup_trait_implementation_4/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_implementation_5/Prover.toml b/test_programs/compile_failure/dup_trait_implementation_5/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_items_1/Prover.toml b/test_programs/compile_failure/dup_trait_items_1/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_items_2/Prover.toml b/test_programs/compile_failure/dup_trait_items_2/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_items_3/Prover.toml b/test_programs/compile_failure/dup_trait_items_3/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_items_4/Prover.toml b/test_programs/compile_failure/dup_trait_items_4/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_items_5/Prover.toml b/test_programs/compile_failure/dup_trait_items_5/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/dup_trait_items_6/Prover.toml b/test_programs/compile_failure/dup_trait_items_6/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/hashmap_load_factor/Prover.toml b/test_programs/compile_failure/hashmap_load_factor/Prover.toml
deleted file mode 100644
index e54319c61e9..00000000000
--- a/test_programs/compile_failure/hashmap_load_factor/Prover.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-# Expected 6 key-value entries for hashmap capacity of 8.
-# These must be distinct (both key-to-key, and value-to-value) for correct testing.
-
-[[input]]
-key = 2
-value = 17
-
-[[input]]
-key = 3
-value = 19
-
-[[input]]
-key = 5
-value = 23
-
-[[input]]
-key = 7
-value = 29
-
-[[input]]
-key = 11
-value = 31
-
-[[input]]
-key = 41
-value = 43
\ No newline at end of file
diff --git a/test_programs/compile_failure/negate_unsigned/Prover.toml b/test_programs/compile_failure/negate_unsigned/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/compile_failure/orphaned_trait_impl/Prover.toml b/test_programs/compile_failure/orphaned_trait_impl/Prover.toml
deleted file mode 100644
index 2c1854573a4..00000000000
--- a/test_programs/compile_failure/orphaned_trait_impl/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = 1
-y = 2
diff --git a/test_programs/compile_failure/slice_remove_failure/Prover.toml b/test_programs/compile_failure/slice_remove_failure/Prover.toml
deleted file mode 100644
index f28f2f8cc48..00000000000
--- a/test_programs/compile_failure/slice_remove_failure/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "5"
-y = "10"
diff --git a/test_programs/compile_failure/workspace_missing_toml/crates/a/Prover.toml b/test_programs/compile_failure/workspace_missing_toml/crates/a/Prover.toml
deleted file mode 100644
index 465ef562de4..00000000000
--- a/test_programs/compile_failure/workspace_missing_toml/crates/a/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "1"
-y = "1"
diff --git a/test_programs/compile_failure/workspace_missing_toml/crates/b/Prover.toml b/test_programs/compile_failure/workspace_missing_toml/crates/b/Prover.toml
deleted file mode 100644
index a0397e89477..00000000000
--- a/test_programs/compile_failure/workspace_missing_toml/crates/b/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "1"
-y = "0"
diff --git a/test_programs/compile_failure/assert_msg_runtime/Nargo.toml b/test_programs/execution_failure/assert_msg_runtime/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/assert_msg_runtime/Nargo.toml
rename to test_programs/execution_failure/assert_msg_runtime/Nargo.toml
diff --git a/test_programs/compile_failure/assert_msg_runtime/Prover.toml b/test_programs/execution_failure/assert_msg_runtime/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/assert_msg_runtime/Prover.toml
rename to test_programs/execution_failure/assert_msg_runtime/Prover.toml
diff --git a/test_programs/compile_failure/assert_msg_runtime/src/main.nr b/test_programs/execution_failure/assert_msg_runtime/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/assert_msg_runtime/src/main.nr
rename to test_programs/execution_failure/assert_msg_runtime/src/main.nr
diff --git a/test_programs/compile_failure/brillig_assert_fail/Nargo.toml b/test_programs/execution_failure/brillig_assert_fail/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/brillig_assert_fail/Nargo.toml
rename to test_programs/execution_failure/brillig_assert_fail/Nargo.toml
diff --git a/test_programs/compile_failure/brillig_assert_fail/Prover.toml b/test_programs/execution_failure/brillig_assert_fail/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/brillig_assert_fail/Prover.toml
rename to test_programs/execution_failure/brillig_assert_fail/Prover.toml
diff --git a/test_programs/compile_failure/brillig_assert_fail/src/main.nr b/test_programs/execution_failure/brillig_assert_fail/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/brillig_assert_fail/src/main.nr
rename to test_programs/execution_failure/brillig_assert_fail/src/main.nr
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/Nargo.toml b/test_programs/execution_failure/brillig_assert_msg_runtime/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/brillig_assert_msg_runtime/Nargo.toml
rename to test_programs/execution_failure/brillig_assert_msg_runtime/Nargo.toml
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/Prover.toml b/test_programs/execution_failure/brillig_assert_msg_runtime/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/brillig_assert_msg_runtime/Prover.toml
rename to test_programs/execution_failure/brillig_assert_msg_runtime/Prover.toml
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr b/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr
rename to test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
diff --git a/test_programs/compile_failure/div_by_zero_constants/Nargo.toml b/test_programs/execution_failure/div_by_zero_constants/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_constants/Nargo.toml
rename to test_programs/execution_failure/div_by_zero_constants/Nargo.toml
diff --git a/test_programs/compile_failure/cyclic_dep/Prover.toml b/test_programs/execution_failure/div_by_zero_constants/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/cyclic_dep/Prover.toml
rename to test_programs/execution_failure/div_by_zero_constants/Prover.toml
diff --git a/test_programs/compile_failure/div_by_zero_constants/src/main.nr b/test_programs/execution_failure/div_by_zero_constants/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_constants/src/main.nr
rename to test_programs/execution_failure/div_by_zero_constants/src/main.nr
diff --git a/test_programs/compile_failure/div_by_zero_modulo/Nargo.toml b/test_programs/execution_failure/div_by_zero_modulo/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_modulo/Nargo.toml
rename to test_programs/execution_failure/div_by_zero_modulo/Nargo.toml
diff --git a/test_programs/compile_failure/div_by_zero_constants/Prover.toml b/test_programs/execution_failure/div_by_zero_modulo/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_constants/Prover.toml
rename to test_programs/execution_failure/div_by_zero_modulo/Prover.toml
diff --git a/test_programs/compile_failure/div_by_zero_modulo/src/main.nr b/test_programs/execution_failure/div_by_zero_modulo/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_modulo/src/main.nr
rename to test_programs/execution_failure/div_by_zero_modulo/src/main.nr
diff --git a/test_programs/compile_failure/div_by_zero_numerator_witness/Nargo.toml b/test_programs/execution_failure/div_by_zero_numerator_witness/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_numerator_witness/Nargo.toml
rename to test_programs/execution_failure/div_by_zero_numerator_witness/Nargo.toml
diff --git a/test_programs/compile_failure/div_by_zero_numerator_witness/Prover.toml b/test_programs/execution_failure/div_by_zero_numerator_witness/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_numerator_witness/Prover.toml
rename to test_programs/execution_failure/div_by_zero_numerator_witness/Prover.toml
diff --git a/test_programs/compile_failure/div_by_zero_numerator_witness/src/main.nr b/test_programs/execution_failure/div_by_zero_numerator_witness/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_numerator_witness/src/main.nr
rename to test_programs/execution_failure/div_by_zero_numerator_witness/src/main.nr
diff --git a/test_programs/compile_failure/div_by_zero_witness/Nargo.toml b/test_programs/execution_failure/div_by_zero_witness/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_witness/Nargo.toml
rename to test_programs/execution_failure/div_by_zero_witness/Nargo.toml
diff --git a/test_programs/compile_failure/div_by_zero_witness/Prover.toml b/test_programs/execution_failure/div_by_zero_witness/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_witness/Prover.toml
rename to test_programs/execution_failure/div_by_zero_witness/Prover.toml
diff --git a/test_programs/compile_failure/div_by_zero_witness/src/main.nr b/test_programs/execution_failure/div_by_zero_witness/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/div_by_zero_witness/src/main.nr
rename to test_programs/execution_failure/div_by_zero_witness/src/main.nr
diff --git a/test_programs/compile_failure/dyn_index_fail_nested_array/Nargo.toml b/test_programs/execution_failure/dyn_index_fail_nested_array/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/dyn_index_fail_nested_array/Nargo.toml
rename to test_programs/execution_failure/dyn_index_fail_nested_array/Nargo.toml
diff --git a/test_programs/compile_failure/dyn_index_fail_nested_array/Prover.toml b/test_programs/execution_failure/dyn_index_fail_nested_array/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/dyn_index_fail_nested_array/Prover.toml
rename to test_programs/execution_failure/dyn_index_fail_nested_array/Prover.toml
diff --git a/test_programs/compile_failure/dyn_index_fail_nested_array/src/main.nr b/test_programs/execution_failure/dyn_index_fail_nested_array/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/dyn_index_fail_nested_array/src/main.nr
rename to test_programs/execution_failure/dyn_index_fail_nested_array/src/main.nr
diff --git a/test_programs/compile_failure/dynamic_index_failure/Nargo.toml b/test_programs/execution_failure/dynamic_index_failure/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/dynamic_index_failure/Nargo.toml
rename to test_programs/execution_failure/dynamic_index_failure/Nargo.toml
diff --git a/test_programs/compile_failure/dynamic_index_failure/Prover.toml b/test_programs/execution_failure/dynamic_index_failure/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/dynamic_index_failure/Prover.toml
rename to test_programs/execution_failure/dynamic_index_failure/Prover.toml
diff --git a/test_programs/compile_failure/dynamic_index_failure/src/main.nr b/test_programs/execution_failure/dynamic_index_failure/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/dynamic_index_failure/src/main.nr
rename to test_programs/execution_failure/dynamic_index_failure/src/main.nr
diff --git a/test_programs/compile_failure/option_expect/Nargo.toml b/test_programs/execution_failure/option_expect/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/option_expect/Nargo.toml
rename to test_programs/execution_failure/option_expect/Nargo.toml
diff --git a/test_programs/compile_failure/option_expect/src/main.nr b/test_programs/execution_failure/option_expect/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/option_expect/src/main.nr
rename to test_programs/execution_failure/option_expect/src/main.nr
diff --git a/test_programs/compile_failure/slice_access_failure/Nargo.toml b/test_programs/execution_failure/slice_access_failure/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/slice_access_failure/Nargo.toml
rename to test_programs/execution_failure/slice_access_failure/Nargo.toml
diff --git a/test_programs/compile_failure/radix_non_constant_length/Prover.toml b/test_programs/execution_failure/slice_access_failure/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/radix_non_constant_length/Prover.toml
rename to test_programs/execution_failure/slice_access_failure/Prover.toml
diff --git a/test_programs/compile_failure/slice_access_failure/src/main.nr b/test_programs/execution_failure/slice_access_failure/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/slice_access_failure/src/main.nr
rename to test_programs/execution_failure/slice_access_failure/src/main.nr
diff --git a/test_programs/compile_failure/slice_insert_failure/Nargo.toml b/test_programs/execution_failure/slice_insert_failure/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/slice_insert_failure/Nargo.toml
rename to test_programs/execution_failure/slice_insert_failure/Nargo.toml
diff --git a/test_programs/compile_failure/slice_access_failure/Prover.toml b/test_programs/execution_failure/slice_insert_failure/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/slice_access_failure/Prover.toml
rename to test_programs/execution_failure/slice_insert_failure/Prover.toml
diff --git a/test_programs/compile_failure/slice_insert_failure/src/main.nr b/test_programs/execution_failure/slice_insert_failure/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/slice_insert_failure/src/main.nr
rename to test_programs/execution_failure/slice_insert_failure/src/main.nr
diff --git a/test_programs/compile_failure/slice_remove_failure/Nargo.toml b/test_programs/execution_failure/slice_remove_failure/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/slice_remove_failure/Nargo.toml
rename to test_programs/execution_failure/slice_remove_failure/Nargo.toml
diff --git a/test_programs/compile_failure/slice_insert_failure/Prover.toml b/test_programs/execution_failure/slice_remove_failure/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/slice_insert_failure/Prover.toml
rename to test_programs/execution_failure/slice_remove_failure/Prover.toml
diff --git a/test_programs/compile_failure/slice_remove_failure/src/main.nr b/test_programs/execution_failure/slice_remove_failure/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/slice_remove_failure/src/main.nr
rename to test_programs/execution_failure/slice_remove_failure/src/main.nr
diff --git a/test_programs/compile_failure/workspace_fail/Nargo.toml b/test_programs/execution_failure/workspace_fail/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/Nargo.toml
rename to test_programs/execution_failure/workspace_fail/Nargo.toml
diff --git a/test_programs/compile_failure/workspace_fail/crates/a/Nargo.toml b/test_programs/execution_failure/workspace_fail/crates/a/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/crates/a/Nargo.toml
rename to test_programs/execution_failure/workspace_fail/crates/a/Nargo.toml
diff --git a/test_programs/compile_failure/workspace_fail/crates/a/Prover.toml b/test_programs/execution_failure/workspace_fail/crates/a/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/crates/a/Prover.toml
rename to test_programs/execution_failure/workspace_fail/crates/a/Prover.toml
diff --git a/test_programs/compile_failure/workspace_fail/crates/a/src/main.nr b/test_programs/execution_failure/workspace_fail/crates/a/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/crates/a/src/main.nr
rename to test_programs/execution_failure/workspace_fail/crates/a/src/main.nr
diff --git a/test_programs/compile_failure/workspace_fail/crates/b/Nargo.toml b/test_programs/execution_failure/workspace_fail/crates/b/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/crates/b/Nargo.toml
rename to test_programs/execution_failure/workspace_fail/crates/b/Nargo.toml
diff --git a/test_programs/compile_failure/workspace_fail/crates/b/Prover.toml b/test_programs/execution_failure/workspace_fail/crates/b/Prover.toml
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/crates/b/Prover.toml
rename to test_programs/execution_failure/workspace_fail/crates/b/Prover.toml
diff --git a/test_programs/compile_failure/workspace_fail/crates/b/src/main.nr b/test_programs/execution_failure/workspace_fail/crates/b/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/workspace_fail/crates/b/src/main.nr
rename to test_programs/execution_failure/workspace_fail/crates/b/src/main.nr
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 1ca12b75dfb..f68ccbfd50e 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -41,6 +41,7 @@ fn main() {
     println!("cargo:rerun-if-changed={}", test_dir.as_os_str().to_str().unwrap());
 
     generate_execution_success_tests(&mut test_file, &test_dir);
+    generate_execution_failure_tests(&mut test_file, &test_dir);
     generate_noir_test_success_tests(&mut test_file, &test_dir);
     generate_noir_test_failure_tests(&mut test_file, &test_dir);
     generate_compile_success_empty_tests(&mut test_file, &test_dir);
@@ -86,6 +87,44 @@ fn execution_success_{test_name}() {{
     }
 }
 
+fn generate_execution_failure_tests(test_file: &mut File, test_data_dir: &Path) {
+    let test_sub_dir = "execution_failure";
+    let test_data_dir = test_data_dir.join(test_sub_dir);
+
+    let test_case_dirs =
+        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
+
+    for test_dir in test_case_dirs {
+        let test_name =
+            test_dir.file_name().into_string().expect("Directory can't be converted to string");
+        if test_name.contains('-') {
+            panic!(
+                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
+            );
+        };
+        let test_dir = &test_dir.path();
+
+        write!(
+            test_file,
+            r#"
+#[test]
+fn execution_failure_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("execute").arg("--force");
+
+    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
+}}
+            "#,
+            test_dir = test_dir.display(),
+        )
+        .expect("Could not write templated test file.");
+    }
+}
+
 fn generate_noir_test_success_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_sub_dir = "noir_test_success";
     let test_data_dir = test_data_dir.join(test_sub_dir);
@@ -281,7 +320,7 @@ fn compile_failure_{test_name}() {{
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
+    cmd.arg("compile").arg("--force");
 
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}

From 8396e2194533024aaed0b2de4679f031937da86e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Fri, 15 Mar 2024 12:26:55 +0000
Subject: [PATCH 083/416] chore: fixing some broken links (#4556)

---
 .../noir/standard_library/black_box_fns.md     | 18 +++++++++---------
 .../noir/standard_library/black_box_fns.md     | 18 +++++++++---------
 .../noir/standard_library/black_box_fns.md     | 18 +++++++++---------
 3 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/docs/docs/noir/standard_library/black_box_fns.md b/docs/docs/noir/standard_library/black_box_fns.md
index eae8744abf0..be8c65679c3 100644
--- a/docs/docs/noir/standard_library/black_box_fns.md
+++ b/docs/docs/noir/standard_library/black_box_fns.md
@@ -12,18 +12,18 @@ The ACVM spec defines a set of blackbox functions which backends will be expecte
 
 Here is a list of the current black box functions:
 
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Blake3](./cryptographic_primitives/hashes#blake3)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
 - [Recursive proof verification](./recursion)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
diff --git a/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md
index eae8744abf0..be8c65679c3 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md
@@ -12,18 +12,18 @@ The ACVM spec defines a set of blackbox functions which backends will be expecte
 
 Here is a list of the current black box functions:
 
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Blake3](./cryptographic_primitives/hashes#blake3)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
 - [Recursive proof verification](./recursion)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
index eae8744abf0..be8c65679c3 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
@@ -12,18 +12,18 @@ The ACVM spec defines a set of blackbox functions which backends will be expecte
 
 Here is a list of the current black box functions:
 
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Blake3](./cryptographic_primitives/hashes#blake3)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
 - [Recursive proof verification](./recursion)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.

From 4cf700bcfe157ebc82cdf7321a16959b7a4add57 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 15 Mar 2024 08:40:43 -0500
Subject: [PATCH 084/416] feat: Add more impls on Option (#4549)

# Description

## Problem\*

Resolves

## Summary\*

Adds more trait implementations on the Option type.

## Additional Context

This PR depends on https://github.com/noir-lang/noir/pull/4470 to be
merged first since it requires `bool: Hash`

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[Exceptional Case]** Documentation to be submitted in a separate
PR.
- Once both this and https://github.com/noir-lang/noir/pull/4470 are
merged I think I'll add all the new impls to the docs at once.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/option.nr | 52 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index 1c32f758af7..c94a1cf836e 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -1,3 +1,7 @@
+use crate::hash::{Hash, Hasher};
+use crate::cmp::{Ordering, Ord, Eq};
+use crate::default::Default;
+
 struct Option<T> {
     _is_some: bool,
     _value: T,
@@ -152,3 +156,51 @@ impl<T> Option<T> {
         }
     }
 }
+
+impl<T> Default for Option<T> {
+    fn default() -> Self {
+        Option::none()
+    }
+}
+
+impl<T> Eq for Option<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        if self._is_some == other._is_some {
+            if self._is_some {
+                self._value == other._value
+            } else {
+                true
+            }
+        } else {
+            false
+        }
+    }
+}
+
+impl<T> Hash for Option<T> where T: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher {
+        self._is_some.hash(state);
+        if self._is_some {
+            self._value.hash(state);
+        }
+    }
+}
+
+// For this impl we're declaring Option::none < Option::some
+impl<T> Ord for Option<T> where T: Ord {
+    fn cmp(self, other: Self) -> Ordering {
+        if self._is_some {
+            if other._is_some {
+                self._value.cmp(other._value)
+            } else {
+                Ordering::greater()
+            }
+        } else {
+            if other._is_some {
+                Ordering::less()
+            } else {
+                Ordering::equal()
+            }
+        }
+    }
+}

From a8b7cdb8a3698bc8923b6fa8714deebb8bf3923f Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 15 Mar 2024 15:20:40 +0000
Subject: [PATCH 085/416] feat: allow usage of noir `#[test]` syntax in stdlib
 (#4553)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Running tests within the Noir stdlib is a little complicated as nargo
will not accept it as a regular crate as the stdlib uses features which
are disallowed in other crates. This means that in a number of cases
we're placing stdlib unit tests inside of the `test_programs` instead of
just using the `#[test]` format inside of the stdlib itself.

This is suboptimal as it separates the implementation from the tests in
the repository and once https://github.com/noir-lang/noir/pull/4491 is
merged, it will be impossible to use this method to test any private
functions within the stdlib.

This PR then adds a new integration test which is equivalent to running
`nargo test` on the stdlib and moves some tests over to the stdlib as an
example.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/field/bn254.nr                | 78 +++++++++++++++++
 .../field_comparisons/Nargo.toml              |  6 --
 .../field_comparisons/Prover.toml             |  1 -
 .../field_comparisons/src/main.nr             | 86 -------------------
 tooling/nargo_cli/tests/stdlib-tests.rs       | 62 +++++++++++++
 5 files changed, 140 insertions(+), 93 deletions(-)
 delete mode 100644 test_programs/compile_success_empty/field_comparisons/Nargo.toml
 delete mode 100644 test_programs/compile_success_empty/field_comparisons/Prover.toml
 delete mode 100644 test_programs/compile_success_empty/field_comparisons/src/main.nr
 create mode 100644 tooling/nargo_cli/tests/stdlib-tests.rs

diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index 9e1445fd3ba..765f8a9d849 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -101,3 +101,81 @@ pub fn gt(a: Field, b: Field) -> bool {
 pub fn lt(a: Field, b: Field) -> bool {
     gt(b, a)
 }
+
+mod tests {
+    // TODO: Allow imports from "super"
+    use crate::field::bn254::{decompose_unsafe, decompose, lt_unsafe, assert_gt, gt, lt, TWO_POW_128, lte_unsafe, PLO, PHI};
+
+    #[test]
+    fn check_decompose_unsafe() {
+        assert_eq(decompose_unsafe(TWO_POW_128), (0, 1));
+        assert_eq(decompose_unsafe(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
+        assert_eq(decompose_unsafe(0x1234567890), (0x1234567890, 0));
+    }
+
+    #[test]
+    fn check_decompose() {
+        assert_eq(decompose(TWO_POW_128), (0, 1));
+        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
+        assert_eq(decompose(0x1234567890), (0x1234567890, 0));
+    }
+
+    #[test]
+    fn check_lt_unsafe() {
+        assert(lt_unsafe(0, 1, 16));
+        assert(lt_unsafe(0, 0x100, 16));
+        assert(lt_unsafe(0x100, TWO_POW_128 - 1, 16));
+        assert(!lt_unsafe(0, TWO_POW_128, 16));
+    }
+
+    #[test]
+    fn check_lte_unsafe() {
+        assert(lte_unsafe(0, 1, 16));
+        assert(lte_unsafe(0, 0x100, 16));
+        assert(lte_unsafe(0x100, TWO_POW_128 - 1, 16));
+        assert(!lte_unsafe(0, TWO_POW_128, 16));
+
+        assert(lte_unsafe(0, 0, 16));
+        assert(lte_unsafe(0x100, 0x100, 16));
+        assert(lte_unsafe(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
+        assert(lte_unsafe(TWO_POW_128, TWO_POW_128, 16));
+    }
+
+    #[test]
+    fn check_assert_gt() {
+        assert_gt(1, 0);
+        assert_gt(0x100, 0);
+        assert_gt((0 - 1), (0 - 2));
+        assert_gt(TWO_POW_128, 0);
+        assert_gt(0 - 1, 0);
+    }
+
+    #[test]
+    fn check_gt() {
+        assert(gt(1, 0));
+        assert(gt(0x100, 0));
+        assert(gt((0 - 1), (0 - 2)));
+        assert(gt(TWO_POW_128, 0));
+        assert(!gt(0, 0));
+        assert(!gt(0, 0x100));
+        assert(gt(0 - 1, 0 - 2));
+        assert(!gt(0 - 2, 0 - 1));
+    }
+
+    #[test]
+    fn check_plo_phi() {
+        assert_eq(PLO + PHI * TWO_POW_128, 0);
+        let p_bytes = crate::field::modulus_le_bytes();
+        let mut p_low: Field = 0;
+        let mut p_high: Field = 0;
+
+        let mut offset = 1;
+        for i in 0..16 {
+            p_low += (p_bytes[i] as Field) * offset;
+            p_high += (p_bytes[i + 16] as Field) * offset;
+            offset *= 256;
+        }
+        assert_eq(p_low, PLO);
+        assert_eq(p_high, PHI);
+    }
+}
diff --git a/test_programs/compile_success_empty/field_comparisons/Nargo.toml b/test_programs/compile_success_empty/field_comparisons/Nargo.toml
deleted file mode 100644
index e8b06655c58..00000000000
--- a/test_programs/compile_success_empty/field_comparisons/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "field_comparisons"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/compile_success_empty/field_comparisons/Prover.toml b/test_programs/compile_success_empty/field_comparisons/Prover.toml
deleted file mode 100644
index 8b137891791..00000000000
--- a/test_programs/compile_success_empty/field_comparisons/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test_programs/compile_success_empty/field_comparisons/src/main.nr b/test_programs/compile_success_empty/field_comparisons/src/main.nr
deleted file mode 100644
index 48cca6c89fc..00000000000
--- a/test_programs/compile_success_empty/field_comparisons/src/main.nr
+++ /dev/null
@@ -1,86 +0,0 @@
-use dep::std::field::bn254::{PLO, PHI, TWO_POW_128, decompose, decompose_unsafe, lt_unsafe, lte_unsafe, assert_gt, gt};
-
-fn check_plo_phi() {
-    assert_eq(PLO + PHI * TWO_POW_128, 0);
-    let p_bytes = dep::std::field::modulus_le_bytes();
-    let mut p_low: Field = 0;
-    let mut p_high: Field = 0;
-
-    let mut offset = 1;
-    for i in 0..16 {
-        p_low += (p_bytes[i] as Field) * offset;
-        p_high += (p_bytes[i + 16] as Field) * offset;
-        offset *= 256;
-    }
-    assert_eq(p_low, PLO);
-    assert_eq(p_high, PHI);
-}
-
-fn check_decompose_unsafe() {
-    assert_eq(decompose_unsafe(TWO_POW_128), (0, 1));
-    assert_eq(decompose_unsafe(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
-    assert_eq(decompose_unsafe(0x1234567890), (0x1234567890, 0));
-}
-
-fn check_decompose() {
-    assert_eq(decompose(TWO_POW_128), (0, 1));
-    assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
-    assert_eq(decompose(0x1234567890), (0x1234567890, 0));
-}
-
-fn check_lt_unsafe() {
-    assert(lt_unsafe(0, 1, 16));
-    assert(lt_unsafe(0, 0x100, 16));
-    assert(lt_unsafe(0x100, TWO_POW_128 - 1, 16));
-    assert(!lt_unsafe(0, TWO_POW_128, 16));
-}
-
-fn check_lte_unsafe() {
-    assert(lte_unsafe(0, 1, 16));
-    assert(lte_unsafe(0, 0x100, 16));
-    assert(lte_unsafe(0x100, TWO_POW_128 - 1, 16));
-    assert(!lte_unsafe(0, TWO_POW_128, 16));
-
-    assert(lte_unsafe(0, 0, 16));
-    assert(lte_unsafe(0x100, 0x100, 16));
-    assert(lte_unsafe(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
-    assert(lte_unsafe(TWO_POW_128, TWO_POW_128, 16));
-}
-
-fn check_assert_gt() {
-    assert_gt(1, 0);
-    assert_gt(0x100, 0);
-    assert_gt((0 - 1), (0 - 2));
-    assert_gt(TWO_POW_128, 0);
-    assert_gt(0 - 1, 0);
-}
-
-fn check_gt() {
-    assert(gt(1, 0));
-    assert(gt(0x100, 0));
-    assert(gt((0 - 1), (0 - 2)));
-    assert(gt(TWO_POW_128, 0));
-    assert(!gt(0, 0));
-    assert(!gt(0, 0x100));
-    assert(gt(0 - 1, 0 - 2));
-    assert(!gt(0 - 2, 0 - 1));
-}
-
-fn checks() {
-    check_plo_phi();
-    check_decompose_unsafe();
-    check_decompose();
-    check_lt_unsafe();
-    check_lte_unsafe();
-    check_assert_gt();
-    check_gt();
-}
-
-unconstrained fn checks_in_brillig() {
-    checks();
-}
-
-fn main() {
-    checks();
-    checks_in_brillig();
-}
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
new file mode 100644
index 00000000000..9d377cfaee9
--- /dev/null
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -0,0 +1,62 @@
+use std::{collections::BTreeMap, path::PathBuf};
+
+use acvm::blackbox_solver::StubbedBlackBoxSolver;
+use noirc_driver::{check_crate, file_manager_with_stdlib, CompileOptions};
+use noirc_frontend::hir::FunctionNameMatch;
+
+use nargo::{
+    ops::{report_errors, run_test, TestStatus},
+    package::{Package, PackageType},
+    parse_all, prepare_package,
+};
+
+#[test]
+fn stdlib_noir_tests() {
+    let mut file_manager = file_manager_with_stdlib(&PathBuf::from("."));
+    file_manager.add_file_with_source_canonical_path(&PathBuf::from("main.nr"), "".to_owned());
+    let parsed_files = parse_all(&file_manager);
+
+    // We need a dummy package as we cannot compile the stdlib on its own.
+    let dummy_package = Package {
+        version: None,
+        compiler_required_version: None,
+        root_dir: PathBuf::from("."),
+        package_type: PackageType::Binary,
+        entry_path: PathBuf::from("main.nr"),
+        name: "dummy".parse().unwrap(),
+        dependencies: BTreeMap::new(),
+    };
+
+    let (mut context, dummy_crate_id) =
+        prepare_package(&file_manager, &parsed_files, &dummy_package);
+
+    let result = check_crate(&mut context, dummy_crate_id, true, false);
+    report_errors(result, &context.file_manager, true, false)
+        .expect("Error encountered while compiling standard library");
+
+    // We can now search within the stdlib for any test functions to compile.
+
+    let test_functions = context.get_all_test_functions_in_crate_matching(
+        context.stdlib_crate_id(),
+        FunctionNameMatch::Anything,
+    );
+
+    let test_report: Vec<(String, TestStatus)> = test_functions
+        .into_iter()
+        .map(|(test_name, test_function)| {
+            let status = run_test(
+                &StubbedBlackBoxSolver,
+                &mut context,
+                &test_function,
+                false,
+                None,
+                &CompileOptions::default(),
+            );
+
+            (test_name, status)
+        })
+        .collect();
+
+    assert!(!test_report.is_empty(), "Could not find any tests within the stdlib");
+    assert!(test_report.iter().all(|(_, status)| !status.failed()));
+}

From 4c3ac2958fcaaa90eddb60e92cd30eac50b5d2b5 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 15 Mar 2024 16:20:53 +0000
Subject: [PATCH 086/416] chore: fix docker test workflows (#4566)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Docker tests have been broken for a while. This PR builds the types
package so that the `noir_wasm` package can build.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/scripts/noir-wasm-build.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/scripts/noir-wasm-build.sh b/.github/scripts/noir-wasm-build.sh
index f799387b6f6..48e3ad73769 100755
--- a/.github/scripts/noir-wasm-build.sh
+++ b/.github/scripts/noir-wasm-build.sh
@@ -2,4 +2,5 @@
 set -eu
 
 .github/scripts/wasm-pack-install.sh
+yarn workspace @noir-lang/types build
 yarn workspace @noir-lang/noir_wasm build

From 414194cdbeb65096c25152084d25ab79d80d2f3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Fri, 15 Mar 2024 18:54:04 +0000
Subject: [PATCH 087/416] chore: making docs build before cutting versions
 (#4568)

# Description

Release was broken because the CI doesn't build docs before cutting new
versions. Instead of changing the CI I'm adding docs build to the `yarn
version` command.

I'm also adding the missing 0.25.0 docs (took a snapshot at tag 0.25.0)
---
 docs/package.json                             |   2 +-
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 127 +++++++++++++++++
 .../NoirJS/backend_barretenberg/index.md      |  46 ++++++
 .../interfaces/Backend.md                     | 132 ++++++++++++++++++
 .../type-aliases/BackendOptions.md            |  21 +++
 .../type-aliases/CompiledCircuit.md           |  20 +++
 .../type-aliases/ProofData.md                 |  20 +++
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  | 132 ++++++++++++++++++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +++
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +++
 .../functions/ecdsa_secp256k1_verify.md       |  28 ++++
 .../functions/ecdsa_secp256r1_verify.md       |  28 ++++
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +++
 .../NoirJS/noir_js/functions/sha256.md        |  21 +++
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +++
 .../reference/NoirJS/noir_js/index.md         |  37 +++++
 .../noir_js/type-aliases/CompiledCircuit.md   |  20 +++
 .../type-aliases/ForeignCallHandler.md        |  24 ++++
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 ++
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 ++
 .../NoirJS/noir_js/type-aliases/InputMap.md   |  13 ++
 .../NoirJS/noir_js/type-aliases/ProofData.md  |  20 +++
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 ++
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 +++++++
 .../noir_wasm/functions/compile_contract.md   |  51 +++++++
 .../noir_wasm/functions/createFileManager.md  |  21 +++
 .../functions/inflateDebugSymbols.md          |  21 +++
 .../reference/NoirJS/noir_wasm/index.md       |  49 +++++++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 34 files changed, 1011 insertions(+), 1 deletion(-)
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/interfaces/Backend.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/InputMap.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ProofData.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs

diff --git a/docs/package.json b/docs/package.json
index 146c2a9800c..779b72149b1 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -8,7 +8,7 @@
     "build": "yarn preprocess && yarn version::stables && docusaurus build",
     "version::stables": "ts-node ./scripts/setStable.ts",
     "serve": "serve build",
-    "version": "yarn preprocess && docusaurus docs:version"
+    "version": "yarn preprocess && docusaurus build && docusaurus docs:version"
   },
   "dependencies": {
     "@docusaurus/core": "^3.0.1",
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..d60940df3ea
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,127 @@
+# BarretenbergBackend
+
+## Implements
+
+- [`Backend`](../interfaces/Backend.md)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | [`CompiledCircuit`](../type-aliases/CompiledCircuit.md) |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Implementation of
+
+[`Backend`](../interfaces/Backend.md).[`destroy`](../interfaces/Backend.md#destroy)
+
+#### Description
+
+Destroys the backend
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | [`ProofData`](../type-aliases/ProofData.md) | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..e32501acb71
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,46 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+
+### Interfaces
+
+| Interface | Description |
+| :------ | :------ |
+| [Backend](interfaces/Backend.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+| [CompiledCircuit](type-aliases/CompiledCircuit.md) | - |
+| [ProofData](type-aliases/ProofData.md) | - |
+
+## Functions
+
+### publicInputsToWitnessMap()
+
+```ts
+publicInputsToWitnessMap(publicInputs, abi): WitnessMap
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `publicInputs` | `string`[] |
+| `abi` | `Abi` |
+
+#### Returns
+
+`WitnessMap`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/interfaces/Backend.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/interfaces/Backend.md
new file mode 100644
index 00000000000..3eb9645c8d2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/interfaces/Backend.md
@@ -0,0 +1,132 @@
+# Backend
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the backend
+
+***
+
+### generateFinalProof()
+
+```ts
+generateFinalProof(decompressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `decompressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
+
+#### Description
+
+Generates a final proof (not meant to be verified in another circuit)
+
+***
+
+### generateIntermediateProof()
+
+```ts
+generateIntermediateProof(decompressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `decompressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
+
+#### Description
+
+Generates an intermediate proof (meant to be verified in another circuit)
+
+***
+
+### generateIntermediateProofArtifacts()
+
+```ts
+generateIntermediateProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
+| `numOfPublicInputs` | `number` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Retrieves the artifacts from a proof in the Field format
+
+***
+
+### verifyFinalProof()
+
+```ts
+verifyFinalProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a final proof
+
+***
+
+### verifyIntermediateProof()
+
+```ts
+verifyIntermediateProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies an intermediate proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md
new file mode 100644
index 00000000000..34e0dd04205
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md
@@ -0,0 +1,20 @@
+# CompiledCircuit
+
+```ts
+type CompiledCircuit: object;
+```
+
+## Description
+
+The representation of a compiled circuit
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `abi` | `Abi` | **Description**<br /><br />ABI representation of the circuit |
+| `bytecode` | `string` | **Description**<br /><br />The bytecode of the circuit |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md
new file mode 100644
index 00000000000..05cebbc4e94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md
@@ -0,0 +1,20 @@
+# ProofData
+
+```ts
+type ProofData: object;
+```
+
+## Description
+
+The representation of a proof
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `proof` | `Uint8Array` | **Description**<br /><br />An byte array representing the proof |
+| `publicInputs` | `string`[] | **Description**<br /><br />Public inputs of a proof |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..2aaa55bccf6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"}]},{"type":"category","label":"Interfaces","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/interfaces/Backend","label":"Backend"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit","label":"CompiledCircuit"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/ProofData","label":"ProofData"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..421d274fff8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,132 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit, backend)
+
+```ts
+new Noir(circuit, backend?): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | [`CompiledCircuit`](../type-aliases/CompiledCircuit.md) |
+| `backend`? | `Backend` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the underlying backend instance.
+
+#### Example
+
+```typescript
+await noir.destroy();
+```
+
+***
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | [`InputMap`](../type-aliases/InputMap.md) |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+### generateProof()
+
+```ts
+generateProof(inputs, foreignCallHandler?): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | [`InputMap`](../type-aliases/InputMap.md) |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
+
+#### Description
+
+Generates a witness and a proof given an object as input.
+
+#### Example
+
+```typescript
+async generateProof(input)
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Instantiates the verification key and verifies a proof.
+
+#### Example
+
+```typescript
+async verifyProof(proof)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..d600e21b299
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,37 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [CompiledCircuit](type-aliases/CompiledCircuit.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [InputMap](type-aliases/InputMap.md) | - |
+| [ProofData](type-aliases/ProofData.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md
new file mode 100644
index 00000000000..34e0dd04205
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md
@@ -0,0 +1,20 @@
+# CompiledCircuit
+
+```ts
+type CompiledCircuit: object;
+```
+
+## Description
+
+The representation of a compiled circuit
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `abi` | `Abi` | **Description**<br /><br />ABI representation of the circuit |
+| `bytecode` | `string` | **Description**<br /><br />The bytecode of the circuit |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/InputMap.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/InputMap.md
new file mode 100644
index 00000000000..c714e999d93
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/InputMap.md
@@ -0,0 +1,13 @@
+# InputMap
+
+```ts
+type InputMap: object;
+```
+
+## Index signature
+
+ \[`key`: `string`\]: `InputValue`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ProofData.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ProofData.md
new file mode 100644
index 00000000000..05cebbc4e94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/ProofData.md
@@ -0,0 +1,20 @@
+# ProofData
+
+```ts
+type ProofData: object;
+```
+
+## Description
+
+The representation of a proof
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `proof` | `Uint8Array` | **Description**<br /><br />An byte array representing the proof |
+| `publicInputs` | `string`[] | **Description**<br /><br />Public inputs of a proof |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..fe2629ddc9f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/CompiledCircuit","label":"CompiledCircuit"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/InputMap","label":"InputMap"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ProofData","label":"ProofData"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.25.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file

From 6a9ea35c4f1578058179aa08eedf44eb18bad4a1 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Fri, 15 Mar 2024 16:35:37 -0400
Subject: [PATCH 088/416] feat: add as_slice builtin function, add execution
 test (#4523)

# Description

## Problem\*

Expected to resolve slowdown in
https://github.com/noir-lang/noir/pull/4504/

## Summary\*

Adds builtin function for `as_slice`, allowing it to be much more
efficient (`O(1)` instead of `O(n)`)

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: vezenovm <mvezenov@gmail.com>
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 63 +++++++++++++------
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 54 +++++++++++++++-
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  4 ++
 .../src/ssa/ir/instruction/call.rs            | 10 +++
 noir_stdlib/src/array.nr                      | 10 +--
 .../array_to_slice/Nargo.toml                 |  7 +++
 .../array_to_slice/Prover.toml                |  2 +
 .../array_to_slice/src/main.nr                | 33 ++++++++++
 .../brillig_array_to_slice/Nargo.toml         |  7 +++
 .../brillig_array_to_slice/Prover.toml        |  1 +
 .../brillig_array_to_slice/src/main.nr        | 18 ++++++
 11 files changed, 181 insertions(+), 28 deletions(-)
 create mode 100644 test_programs/execution_success/array_to_slice/Nargo.toml
 create mode 100644 test_programs/execution_success/array_to_slice/Prover.toml
 create mode 100644 test_programs/execution_success/array_to_slice/src/main.nr
 create mode 100644 test_programs/execution_success/brillig_array_to_slice/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_array_to_slice/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_array_to_slice/src/main.nr

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 938a80e87d1..99400b13528 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -453,6 +453,29 @@ impl<'block> BrilligBlock<'block> {
                         self.convert_ssa_array_len(arguments[0], result_variable.address, dfg);
                     }
                 }
+                Value::Intrinsic(Intrinsic::AsSlice) => {
+                    let source_variable = self.convert_ssa_value(arguments[0], dfg);
+                    let result_ids = dfg.instruction_results(instruction_id);
+                    let destination_len_variable = self.variables.define_single_addr_variable(
+                        self.function_context,
+                        self.brillig_context,
+                        result_ids[0],
+                        dfg,
+                    );
+                    let destination_variable = self.variables.define_variable(
+                        self.function_context,
+                        self.brillig_context,
+                        result_ids[1],
+                        dfg,
+                    );
+                    let source_size_as_register =
+                        self.convert_ssa_array_set(source_variable, destination_variable, None);
+
+                    // we need to explicitly set the destination_len_variable
+                    self.brillig_context
+                        .mov_instruction(destination_len_variable.address, source_size_as_register);
+                    self.brillig_context.deallocate_register(source_size_as_register);
+                }
                 Value::Intrinsic(
                     Intrinsic::SlicePushBack
                     | Intrinsic::SlicePopBack
@@ -612,13 +635,12 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 self.validate_array_index(source_variable, index_register);
-
-                self.convert_ssa_array_set(
+                let source_size_as_register = self.convert_ssa_array_set(
                     source_variable,
                     destination_variable,
-                    index_register.address,
-                    value_variable,
+                    Some((index_register.address, value_variable)),
                 );
+                self.brillig_context.deallocate_register(source_size_as_register);
             }
             Instruction::RangeCheck { value, max_bit_size, assert_message } => {
                 let value = self.convert_ssa_single_addr_value(*value, dfg);
@@ -806,23 +828,25 @@ impl<'block> BrilligBlock<'block> {
 
     /// Array set operation in SSA returns a new array or slice that is a copy of the parameter array or slice
     /// With a specific value changed.
+    ///
+    /// Returns `source_size_as_register`, which is expected to be deallocated with:
+    /// `self.brillig_context.deallocate_register(source_size_as_register)`
     fn convert_ssa_array_set(
         &mut self,
         source_variable: BrilligVariable,
         destination_variable: BrilligVariable,
-        index_register: MemoryAddress,
-        value_variable: BrilligVariable,
-    ) {
+        opt_index_and_value: Option<(MemoryAddress, BrilligVariable)>,
+    ) -> MemoryAddress {
         let destination_pointer = match destination_variable {
             BrilligVariable::BrilligArray(BrilligArray { pointer, .. }) => pointer,
             BrilligVariable::BrilligVector(BrilligVector { pointer, .. }) => pointer,
-            _ => unreachable!("ICE: array set returns non-array"),
+            _ => unreachable!("ICE: array_set SSA returns non-array"),
         };
 
         let reference_count = match source_variable {
             BrilligVariable::BrilligArray(BrilligArray { rc, .. })
             | BrilligVariable::BrilligVector(BrilligVector { rc, .. }) => rc,
-            _ => unreachable!("ICE: array set on non-array"),
+            _ => unreachable!("ICE: array_set SSA on non-array"),
         };
 
         let (source_pointer, source_size_as_register) = match source_variable {
@@ -836,7 +860,7 @@ impl<'block> BrilligBlock<'block> {
                 self.brillig_context.mov_instruction(source_size_register, size);
                 (pointer, source_size_register)
             }
-            _ => unreachable!("ICE: array set on non-array"),
+            _ => unreachable!("ICE: array_set SSA on non-array"),
         };
 
         // Here we want to compare the reference count against 1.
@@ -879,18 +903,20 @@ impl<'block> BrilligBlock<'block> {
                 self.brillig_context.mov_instruction(target_size, source_size_as_register);
                 self.brillig_context.usize_const(target_rc, 1_usize.into());
             }
-            _ => unreachable!("ICE: array set on non-array"),
+            _ => unreachable!("ICE: array_set SSA on non-array"),
         }
 
-        // Then set the value in the newly created array
-        self.store_variable_in_array(
-            destination_pointer,
-            SingleAddrVariable::new_usize(index_register),
-            value_variable,
-        );
+        if let Some((index_register, value_variable)) = opt_index_and_value {
+            // Then set the value in the newly created array
+            self.store_variable_in_array(
+                destination_pointer,
+                SingleAddrVariable::new_usize(index_register),
+                value_variable,
+            );
+        }
 
-        self.brillig_context.deallocate_register(source_size_as_register);
         self.brillig_context.deallocate_register(condition);
+        source_size_as_register
     }
 
     pub(crate) fn store_variable_in_array_with_ctx(
@@ -1319,6 +1345,7 @@ impl<'block> BrilligBlock<'block> {
             Value::Param { .. } | Value::Instruction { .. } => {
                 // All block parameters and instruction results should have already been
                 // converted to registers so we fetch from the cache.
+
                 self.variables.get_allocation(self.function_context, value_id, dfg)
             }
             Value::NumericConstant { constant, .. } => {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 4442efe286a..5a4fa021f1f 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1025,7 +1025,13 @@ impl Context {
         self.array_set_value(&store_value, result_block_id, &mut var_index)?;
 
         let element_type_sizes = if !can_omit_element_sizes_array(&array_typ) {
-            Some(self.init_element_type_sizes_array(&array_typ, array_id, None, dfg)?)
+            let acir_value = self.convert_value(array_id, dfg);
+            Some(self.init_element_type_sizes_array(
+                &array_typ,
+                array_id,
+                Some(&acir_value),
+                dfg,
+            )?)
         } else {
             None
         };
@@ -1246,7 +1252,8 @@ impl Context {
             let read = self.acir_context.read_from_memory(source, &index_var)?;
             Ok::<AcirValue, RuntimeError>(AcirValue::Var(read, AcirType::field()))
         })?;
-        self.initialize_array(destination, array_len, Some(AcirValue::Array(init_values.into())))?;
+        let array: im::Vector<AcirValue> = init_values.into();
+        self.initialize_array(destination, array_len, Some(AcirValue::Array(array)))?;
         Ok(())
     }
 
@@ -1663,6 +1670,49 @@ impl Context {
                 };
                 Ok(vec![AcirValue::Var(self.acir_context.add_constant(len), AcirType::field())])
             }
+            Intrinsic::AsSlice => {
+                let (slice_contents, slice_typ, block_id) =
+                    self.check_array_is_initialized(arguments[0], dfg)?;
+                assert!(!slice_typ.is_nested_slice(), "ICE: Nested slice used in ACIR generation");
+
+                let result_block_id = self.block_id(&result_ids[1]);
+                let acir_value = self.convert_value(slice_contents, dfg);
+
+                let array_len = if !slice_typ.contains_slice_element() {
+                    slice_typ.flattened_size()
+                } else {
+                    self.flattened_slice_size(slice_contents, dfg)
+                };
+                let slice_length = self.acir_context.add_constant(array_len);
+                self.copy_dynamic_array(block_id, result_block_id, array_len)?;
+
+                let element_type_sizes = if !can_omit_element_sizes_array(&slice_typ) {
+                    Some(self.init_element_type_sizes_array(
+                        &slice_typ,
+                        slice_contents,
+                        Some(&acir_value),
+                        dfg,
+                    )?)
+                } else {
+                    None
+                };
+
+                let value_types = self.convert_value(slice_contents, dfg).flat_numeric_types();
+                assert!(
+                    array_len == value_types.len(),
+                    "AsSlice: unexpected length difference: {:?} != {:?}",
+                    array_len,
+                    value_types.len()
+                );
+
+                let result = AcirValue::DynamicArray(AcirDynamicArray {
+                    block_id: result_block_id,
+                    len: value_types.len(),
+                    value_types,
+                    element_type_sizes,
+                });
+                Ok(vec![AcirValue::Var(slice_length, AcirType::field()), result])
+            }
             Intrinsic::SlicePushBack => {
                 // arguments = [slice_length, slice_contents, ...elements_to_push]
                 let slice_length = self.convert_value(arguments[0], dfg).into_var()?;
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index afade4b0616..dd190c112f3 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -37,6 +37,7 @@ pub(crate) type InstructionId = Id<Instruction>;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum Intrinsic {
     ArrayLen,
+    AsSlice,
     AssertConstant,
     SlicePushBack,
     SlicePushFront,
@@ -57,6 +58,7 @@ impl std::fmt::Display for Intrinsic {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Intrinsic::ArrayLen => write!(f, "array_len"),
+            Intrinsic::AsSlice => write!(f, "as_slice"),
             Intrinsic::AssertConstant => write!(f, "assert_constant"),
             Intrinsic::SlicePushBack => write!(f, "slice_push_back"),
             Intrinsic::SlicePushFront => write!(f, "slice_push_front"),
@@ -89,6 +91,7 @@ impl Intrinsic {
             Intrinsic::ToBits(_) | Intrinsic::ToRadix(_) => true,
 
             Intrinsic::ArrayLen
+            | Intrinsic::AsSlice
             | Intrinsic::SlicePushBack
             | Intrinsic::SlicePushFront
             | Intrinsic::SlicePopBack
@@ -109,6 +112,7 @@ impl Intrinsic {
     pub(crate) fn lookup(name: &str) -> Option<Intrinsic> {
         match name {
             "array_len" => Some(Intrinsic::ArrayLen),
+            "as_slice" => Some(Intrinsic::AsSlice),
             "assert_constant" => Some(Intrinsic::AssertConstant),
             "apply_range_constraint" => Some(Intrinsic::ApplyRangeConstraint),
             "slice_push_back" => Some(Intrinsic::SlicePushBack),
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 9349d58c4d9..8b800e0db54 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -84,6 +84,16 @@ pub(super) fn simplify_call(
                 SimplifyResult::None
             }
         }
+        Intrinsic::AsSlice => {
+            let slice = dfg.get_array_constant(arguments[0]);
+            if let Some((slice, element_type)) = slice {
+                let slice_length = dfg.make_constant(slice.len().into(), Type::length_type());
+                let new_slice = dfg.make_array(slice, element_type);
+                SimplifyResult::SimplifiedToMultiple(vec![slice_length, new_slice])
+            } else {
+                SimplifyResult::None
+            }
+        }
         Intrinsic::SlicePushBack => {
             let slice = dfg.get_array_constant(arguments[1]);
             if let Some((mut slice, element_type)) = slice {
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index baa4bef50cc..8a8a1fad01c 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -52,14 +52,8 @@ impl<T, N> [T; N] {
         result
     }
 
-    // Converts an array into a slice.
-    pub fn as_slice(self) -> [T] {
-        let mut slice = [];
-        for elem in self {
-            slice = slice.push_back(elem);
-        }
-        slice
-    }
+    #[builtin(as_slice)]
+    pub fn as_slice(self) -> [T] {}
 
     // Apply a function to each element of an array, returning a new array
     // containing the mapped elements.
diff --git a/test_programs/execution_success/array_to_slice/Nargo.toml b/test_programs/execution_success/array_to_slice/Nargo.toml
new file mode 100644
index 00000000000..90c67b07b2b
--- /dev/null
+++ b/test_programs/execution_success/array_to_slice/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "array_to_slice"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.24.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/array_to_slice/Prover.toml b/test_programs/execution_success/array_to_slice/Prover.toml
new file mode 100644
index 00000000000..26fdbc19975
--- /dev/null
+++ b/test_programs/execution_success/array_to_slice/Prover.toml
@@ -0,0 +1,2 @@
+x = "0"
+y = "1"
diff --git a/test_programs/execution_success/array_to_slice/src/main.nr b/test_programs/execution_success/array_to_slice/src/main.nr
new file mode 100644
index 00000000000..4f5594c6d11
--- /dev/null
+++ b/test_programs/execution_success/array_to_slice/src/main.nr
@@ -0,0 +1,33 @@
+// Converts an array into a slice.
+fn as_slice_push<T, N>(xs: [T; N]) -> [T] {
+    let mut slice = [];
+    for elem in xs {
+        slice = slice.push_back(elem);
+    }
+    slice
+}
+
+fn main(x: Field, y: pub Field) {
+    let xs: [Field; 0] = [];
+    let ys: [Field; 1] = [1];
+    let zs: [Field; 2] = [1, 2];
+    let ws: [Field; 3] = [1; 3];
+    let qs: [Field; 4] = [3, 2, 1, 0];
+
+    let mut dynamic: [Field; 4] = [3, 2, 1, 0];
+    let dynamic_expected: [Field; 4] = [1000, 2, 1, 0];
+    dynamic[x] = 1000;
+
+    assert(x != y);
+    assert(xs.as_slice() == as_slice_push(xs));
+    assert(ys.as_slice() == as_slice_push(ys));
+    assert(zs.as_slice() == as_slice_push(zs));
+    assert(ws.as_slice() == as_slice_push(ws));
+    assert(qs.as_slice() == as_slice_push(qs));
+
+    assert(dynamic.as_slice()[0] == dynamic_expected[0]);
+    assert(dynamic.as_slice()[1] == dynamic_expected[1]);
+    assert(dynamic.as_slice()[2] == dynamic_expected[2]);
+    assert(dynamic.as_slice()[3] == dynamic_expected[3]);
+    assert(dynamic.as_slice().len() == 4);
+}
diff --git a/test_programs/execution_success/brillig_array_to_slice/Nargo.toml b/test_programs/execution_success/brillig_array_to_slice/Nargo.toml
new file mode 100644
index 00000000000..58157c38c26
--- /dev/null
+++ b/test_programs/execution_success/brillig_array_to_slice/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "brillig_array_to_slice"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.25.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_array_to_slice/Prover.toml b/test_programs/execution_success/brillig_array_to_slice/Prover.toml
new file mode 100644
index 00000000000..11497a473bc
--- /dev/null
+++ b/test_programs/execution_success/brillig_array_to_slice/Prover.toml
@@ -0,0 +1 @@
+x = "0"
diff --git a/test_programs/execution_success/brillig_array_to_slice/src/main.nr b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
new file mode 100644
index 00000000000..8f7fcf24bae
--- /dev/null
+++ b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
@@ -0,0 +1,18 @@
+unconstrained fn brillig_as_slice(x: Field) -> (u64, Field, Field) {
+    let mut dynamic: [Field; 1] = [1];
+    dynamic[x] = 2;
+    assert(dynamic[0] == 2);
+
+    let brillig_slice = dynamic.as_slice();
+    assert(brillig_slice.len() == 1);
+
+    (brillig_slice.len(), dynamic[0], brillig_slice[0])
+}
+
+fn main(x: Field) {
+    let (slice_len, dynamic_0, slice_0) = brillig_as_slice(x);
+    assert(slice_len == 1);
+    assert(dynamic_0 == 2);
+    assert(slice_0 == 2);
+}
+

From dfa5126f2c65843c34701cacddf2cbcfb0d7ff11 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 18 Mar 2024 13:44:03 -0500
Subject: [PATCH 089/416] feat: RC optimization pass (#4560)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

`inc_rc` and `dec_rc` instructions can bloat unconstrained code with
unneeded rc changes on otherwise immutable arrays.

## Summary\*

Adds an optimization pass to remove `inc_rc vN .. dec_rc vN` pairs as
long as there are not `array_set` instructions in the same function
which may mutate an array of the same type.

## Additional Context

I thought of tracking all inc and dec instructions in the function
originally but eventually limited it to finding just those in the
function's entry block and exit block respectively. The later is the
only place we currently issue dec_rc instructions anyway. This
restriction greatly simplifies the code since we do not have to merge
intermediate results across several blocks, nor do we have to handle
inc/dec in loops.

This pass applies to both acir and brillig functions since acir
functions can still be called in an unconstrained context.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Álvaro Rodríguez <sirasistant@gmail.com>
---
 compiler/noirc_evaluator/src/ssa.rs           |   6 +-
 .../src/ssa/function_builder/mod.rs           |  73 ++--
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |   1 +
 compiler/noirc_evaluator/src/ssa/opt/rc.rs    | 327 ++++++++++++++++++
 .../src/monomorphization/debug.rs             |   4 +-
 5 files changed, 379 insertions(+), 32 deletions(-)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/rc.rs

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 56cb76adbe4..808cf7533c9 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -48,6 +48,7 @@ pub(crate) fn optimize_into_acir(
     let ssa_gen_span_guard = ssa_gen_span.enter();
     let ssa = SsaBuilder::new(program, print_ssa_passes, force_brillig_output)?
         .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
+        .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
         .run_pass(Ssa::inline_functions, "After Inlining:")
         // Run mem2reg with the CFG separated into blocks
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
@@ -59,10 +60,7 @@ pub(crate) fn optimize_into_acir(
         // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
         .run_pass(Ssa::fold_constants, "After Constant Folding:")
-        .run_pass(
-            Ssa::fold_constants_using_constraints,
-            "After Constant Folding With Constraint Info:",
-        )
+        .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
         .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
         .finish();
 
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 2c39c83b342..aa5a7fedd92 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -195,12 +195,9 @@ impl FunctionBuilder {
         self.call_stack.clone()
     }
 
-    /// Insert a Load instruction at the end of the current block, loading from the given offset
-    /// of the given address which should point to a previous Allocate instruction. Note that
-    /// this is limited to loading a single value. Loading multiple values (such as a tuple)
-    /// will require multiple loads.
-    /// 'offset' is in units of FieldElements here. So loading the fourth FieldElement stored in
-    /// an array will have an offset of 3.
+    /// Insert a Load instruction at the end of the current block, loading from the given address
+    /// which should point to a previous Allocate instruction. Note that this is limited to loading
+    /// a single value. Loading multiple values (such as a tuple) will require multiple loads.
     /// Returns the element that was loaded.
     pub(crate) fn insert_load(&mut self, address: ValueId, type_to_load: Type) -> ValueId {
         self.insert_instruction(Instruction::Load { address }, Some(vec![type_to_load])).first()
@@ -221,11 +218,9 @@ impl FunctionBuilder {
         operator: BinaryOp,
         rhs: ValueId,
     ) -> ValueId {
-        assert_eq!(
-            self.type_of_value(lhs),
-            self.type_of_value(rhs),
-            "ICE - Binary instruction operands must have the same type"
-        );
+        let lhs_type = self.type_of_value(lhs);
+        let rhs_type = self.type_of_value(rhs);
+        assert_eq!(lhs_type, rhs_type, "ICE - Binary instruction operands must have the same type");
         let instruction = Instruction::Binary(Binary { lhs, rhs, operator });
         self.insert_instruction(instruction, None).first()
     }
@@ -309,6 +304,18 @@ impl FunctionBuilder {
         self.insert_instruction(Instruction::ArraySet { array, index, value }, None).first()
     }
 
+    /// Insert an instruction to increment an array's reference count. This only has an effect
+    /// in unconstrained code where arrays are reference counted and copy on write.
+    pub(crate) fn insert_inc_rc(&mut self, value: ValueId) {
+        self.insert_instruction(Instruction::IncrementRc { value }, None);
+    }
+
+    /// Insert an instruction to decrement an array's reference count. This only has an effect
+    /// in unconstrained code where arrays are reference counted and copy on write.
+    pub(crate) fn insert_dec_rc(&mut self, value: ValueId) {
+        self.insert_instruction(Instruction::DecrementRc { value }, None);
+    }
+
     /// Terminates the current block with the given terminator instruction
     fn terminate_block_with(&mut self, terminator: TerminatorInstruction) {
         self.current_function.dfg.set_block_terminator(self.current_block, terminator);
@@ -384,51 +391,65 @@ impl FunctionBuilder {
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
     pub(crate) fn increment_array_reference_count(&mut self, value: ValueId) {
-        self.update_array_reference_count(value, true);
+        self.update_array_reference_count(value, true, None);
     }
 
     /// Insert instructions to decrement the reference count of any array(s) stored
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
     pub(crate) fn decrement_array_reference_count(&mut self, value: ValueId) {
-        self.update_array_reference_count(value, false);
+        self.update_array_reference_count(value, false, None);
     }
 
     /// Increment or decrement the given value's reference count if it is an array.
     /// If it is not an array, this does nothing. Note that inc_rc and dec_rc instructions
     /// are ignored outside of unconstrained code.
-    pub(crate) fn update_array_reference_count(&mut self, value: ValueId, increment: bool) {
+    fn update_array_reference_count(
+        &mut self,
+        value: ValueId,
+        increment: bool,
+        load_address: Option<ValueId>,
+    ) {
         match self.type_of_value(value) {
             Type::Numeric(_) => (),
             Type::Function => (),
             Type::Reference(element) => {
                 if element.contains_an_array() {
-                    let value = self.insert_load(value, element.as_ref().clone());
-                    self.increment_array_reference_count(value);
+                    let reference = value;
+                    let value = self.insert_load(reference, element.as_ref().clone());
+                    self.update_array_reference_count(value, increment, Some(reference));
                 }
             }
             typ @ Type::Array(..) | typ @ Type::Slice(..) => {
                 // If there are nested arrays or slices, we wait until ArrayGet
                 // is issued to increment the count of that array.
-                let instruction = if increment {
-                    Instruction::IncrementRc { value }
-                } else {
-                    Instruction::DecrementRc { value }
+                let update_rc = |this: &mut Self, value| {
+                    if increment {
+                        this.insert_inc_rc(value);
+                    } else {
+                        this.insert_dec_rc(value);
+                    }
                 };
-                self.insert_instruction(instruction, None);
+
+                update_rc(self, value);
+                let dfg = &self.current_function.dfg;
 
                 // This is a bit odd, but in brillig the inc_rc instruction operates on
                 // a copy of the array's metadata, so we need to re-store a loaded array
                 // even if there have been no other changes to it.
-                if let Value::Instruction { instruction, .. } = &self.current_function.dfg[value] {
-                    let instruction = &self.current_function.dfg[*instruction];
+                if let Some(address) = load_address {
+                    // If we already have a load from the Type::Reference case, avoid inserting
+                    // another load and rc update.
+                    self.insert_store(address, value);
+                } else if let Value::Instruction { instruction, .. } = &dfg[value] {
+                    let instruction = &dfg[*instruction];
                     if let Instruction::Load { address } = instruction {
                         // We can't re-use `value` in case the original address was stored
                         // to again in the meantime. So introduce another load.
                         let address = *address;
-                        let value = self.insert_load(address, typ);
-                        self.insert_instruction(Instruction::IncrementRc { value }, None);
-                        self.insert_store(address, value);
+                        let new_load = self.insert_load(address, typ);
+                        update_rc(self, new_load);
+                        self.insert_store(address, new_load);
                     }
                 }
             }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index a315695f7db..8f98b3fb17f 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -12,6 +12,7 @@ mod die;
 pub(crate) mod flatten_cfg;
 mod inlining;
 mod mem2reg;
+mod rc;
 mod remove_bit_shifts;
 mod simplify_cfg;
 mod unrolling;
diff --git a/compiler/noirc_evaluator/src/ssa/opt/rc.rs b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
new file mode 100644
index 00000000000..4766bc3e8d2
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
@@ -0,0 +1,327 @@
+use std::collections::{HashMap, HashSet};
+
+use crate::ssa::{
+    ir::{
+        basic_block::BasicBlockId,
+        function::Function,
+        instruction::{Instruction, InstructionId, TerminatorInstruction},
+        types::Type,
+        value::ValueId,
+    },
+    ssa_gen::Ssa,
+};
+
+impl Ssa {
+    /// This pass removes `inc_rc` and `dec_rc` instructions
+    /// as long as there are no `array_set` instructions to an array
+    /// of the same type in between.
+    ///
+    /// Note that this pass is very conservative since the array_set
+    /// instruction does not need to be to the same array. This is because
+    /// the given array may alias another array (e.g. function parameters or
+    /// a `load`ed array from a reference).
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn remove_paired_rc(mut self) -> Ssa {
+        for function in self.functions.values_mut() {
+            remove_paired_rc(function);
+        }
+        self
+    }
+}
+
+#[derive(Default)]
+struct Context {
+    // All inc_rc instructions encountered without a corresponding dec_rc.
+    // These are only searched for in the first block of a function.
+    //
+    // The type of the array being operated on is recorded.
+    // If an array_set to that array type is encountered, that is also recorded.
+    inc_rcs: HashMap<Type, Vec<IncRc>>,
+}
+
+struct IncRc {
+    id: InstructionId,
+    array: ValueId,
+    possibly_mutated: bool,
+}
+
+/// This function is very simplistic for now. It takes advantage of the fact that dec_rc
+/// instructions are currently issued only at the end of a function for parameters and will
+/// only check the first and last block for inc & dec rc instructions to be removed. The rest
+/// of the function is still checked for array_set instructions.
+///
+/// This restriction lets this function largely ignore merging intermediate results from other
+/// blocks and handling loops.
+fn remove_paired_rc(function: &mut Function) {
+    // `dec_rc` is only issued for parameters currently so we can speed things
+    // up a bit by skipping any functions without them.
+    if !contains_array_parameter(function) {
+        return;
+    }
+
+    let mut context = Context::default();
+
+    context.find_rcs_in_entry_block(function);
+    context.scan_for_array_sets(function);
+    let to_remove = context.find_rcs_to_remove(function);
+    remove_instructions(to_remove, function);
+}
+
+fn contains_array_parameter(function: &mut Function) -> bool {
+    let mut parameters = function.parameters().iter();
+    parameters.any(|parameter| function.dfg.type_of_value(*parameter).contains_an_array())
+}
+
+impl Context {
+    fn find_rcs_in_entry_block(&mut self, function: &Function) {
+        let entry = function.entry_block();
+
+        for instruction in function.dfg[entry].instructions() {
+            if let Instruction::IncrementRc { value } = &function.dfg[*instruction] {
+                let typ = function.dfg.type_of_value(*value);
+
+                // We assume arrays aren't mutated until we find an array_set
+                let inc_rc = IncRc { id: *instruction, array: *value, possibly_mutated: false };
+                self.inc_rcs.entry(typ).or_default().push(inc_rc);
+            }
+        }
+    }
+
+    /// Find each array_set instruction in the function and mark any arrays used
+    /// by the inc_rc instructions as possibly mutated if they're the same type.
+    fn scan_for_array_sets(&mut self, function: &Function) {
+        for block in function.reachable_blocks() {
+            for instruction in function.dfg[block].instructions() {
+                if let Instruction::ArraySet { array, .. } = function.dfg[*instruction] {
+                    let typ = function.dfg.type_of_value(array);
+                    if let Some(inc_rcs) = self.inc_rcs.get_mut(&typ) {
+                        for inc_rc in inc_rcs {
+                            inc_rc.possibly_mutated = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Find each dec_rc instruction and if the most recent inc_rc instruction for the same value
+    /// is not possibly mutated, then we can remove them both. Returns each such pair.
+    fn find_rcs_to_remove(&mut self, function: &Function) -> HashSet<InstructionId> {
+        let last_block = Self::find_last_block(function);
+        let mut to_remove = HashSet::new();
+
+        for instruction in function.dfg[last_block].instructions() {
+            if let Instruction::DecrementRc { value } = &function.dfg[*instruction] {
+                if let Some(inc_rc) = self.pop_rc_for(*value, function) {
+                    if !inc_rc.possibly_mutated {
+                        to_remove.insert(inc_rc.id);
+                        to_remove.insert(*instruction);
+                    }
+                }
+            }
+        }
+
+        to_remove
+    }
+
+    /// Finds the block of the function with the Return instruction
+    fn find_last_block(function: &Function) -> BasicBlockId {
+        for block in function.reachable_blocks() {
+            if matches!(
+                function.dfg[block].terminator(),
+                Some(TerminatorInstruction::Return { .. })
+            ) {
+                return block;
+            }
+        }
+
+        unreachable!("SSA Function {} has no reachable return instruction!", function.id())
+    }
+
+    /// Finds and pops the IncRc for the given array value if possible.
+    fn pop_rc_for(&mut self, value: ValueId, function: &Function) -> Option<IncRc> {
+        let typ = function.dfg.type_of_value(value);
+
+        let rcs = self.inc_rcs.get_mut(&typ)?;
+        let position = rcs.iter().position(|inc_rc| inc_rc.array == value)?;
+
+        Some(rcs.remove(position))
+    }
+}
+
+fn remove_instructions(to_remove: HashSet<InstructionId>, function: &mut Function) {
+    if !to_remove.is_empty() {
+        for block in function.reachable_blocks() {
+            function.dfg[block]
+                .instructions_mut()
+                .retain(|instruction| !to_remove.contains(instruction));
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::rc::Rc;
+
+    use crate::ssa::{
+        function_builder::FunctionBuilder,
+        ir::{
+            basic_block::BasicBlockId, dfg::DataFlowGraph, function::RuntimeType,
+            instruction::Instruction, map::Id, types::Type,
+        },
+    };
+
+    fn count_inc_rcs(block: BasicBlockId, dfg: &DataFlowGraph) -> usize {
+        dfg[block]
+            .instructions()
+            .iter()
+            .filter(|instruction_id| {
+                matches!(dfg[**instruction_id], Instruction::IncrementRc { .. })
+            })
+            .count()
+    }
+
+    fn count_dec_rcs(block: BasicBlockId, dfg: &DataFlowGraph) -> usize {
+        dfg[block]
+            .instructions()
+            .iter()
+            .filter(|instruction_id| {
+                matches!(dfg[**instruction_id], Instruction::DecrementRc { .. })
+            })
+            .count()
+    }
+
+    #[test]
+    fn single_block_fn_return_array() {
+        // This is the output for the program with a function:
+        // unconstrained fn foo(x: [Field; 2]) -> [[Field; 2]; 1] {
+        //     [array]
+        // }
+        //
+        // fn foo {
+        //   b0(v0: [Field; 2]):
+        //     inc_rc v0
+        //     inc_rc v0
+        //     dec_rc v0
+        //     return [v0]
+        // }
+        let main_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("foo".into(), main_id, RuntimeType::Brillig);
+
+        let inner_array_type = Type::Array(Rc::new(vec![Type::field()]), 2);
+        let v0 = builder.add_parameter(inner_array_type.clone());
+
+        builder.insert_inc_rc(v0);
+        builder.insert_inc_rc(v0);
+        builder.insert_dec_rc(v0);
+
+        let outer_array_type = Type::Array(Rc::new(vec![inner_array_type]), 1);
+        let array = builder.array_constant(vec![v0].into(), outer_array_type);
+        builder.terminate_with_return(vec![array]);
+
+        let ssa = builder.finish().remove_paired_rc();
+        let main = ssa.main();
+        let entry = main.entry_block();
+
+        assert_eq!(count_inc_rcs(entry, &main.dfg), 1);
+        assert_eq!(count_dec_rcs(entry, &main.dfg), 0);
+    }
+
+    #[test]
+    fn single_block_mutation() {
+        // fn mutator(mut array: [Field; 2]) {
+        //     array[0] = 5;
+        // }
+        //
+        // fn mutator {
+        //   b0(v0: [Field; 2]):
+        //     v1 = allocate
+        //     store v0 at v1
+        //     inc_rc v0
+        //     v2 = load v1
+        //     v7 = array_set v2, index u64 0, value Field 5
+        //     store v7 at v1
+        //     dec_rc v0
+        //     return
+        // }
+        let main_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("mutator".into(), main_id, RuntimeType::Acir);
+
+        let array_type = Type::Array(Rc::new(vec![Type::field()]), 2);
+        let v0 = builder.add_parameter(array_type.clone());
+
+        let v1 = builder.insert_allocate(array_type.clone());
+        builder.insert_store(v1, v0);
+        builder.insert_inc_rc(v0);
+        let v2 = builder.insert_load(v1, array_type);
+
+        let zero = builder.numeric_constant(0u128, Type::unsigned(64));
+        let five = builder.field_constant(5u128);
+        let v7 = builder.insert_array_set(v2, zero, five);
+
+        builder.insert_store(v1, v7);
+        builder.insert_dec_rc(v0);
+        builder.terminate_with_return(vec![]);
+
+        let ssa = builder.finish().remove_paired_rc();
+        let main = ssa.main();
+        let entry = main.entry_block();
+
+        // No changes, the array is possibly mutated
+        assert_eq!(count_inc_rcs(entry, &main.dfg), 1);
+        assert_eq!(count_dec_rcs(entry, &main.dfg), 1);
+    }
+
+    // Similar to single_block_mutation but for a function which
+    // uses a mutable reference parameter.
+    #[test]
+    fn single_block_mutation_through_reference() {
+        // fn mutator2(array: &mut [Field; 2]) {
+        //     array[0] = 5;
+        // }
+        //
+        // fn mutator2 {
+        //   b0(v0: &mut [Field; 2]):
+        //     v1 = load v0
+        //     inc_rc v1
+        //     store v1 at v0
+        //     v2 = load v0
+        //     v7 = array_set v2, index u64 0, value Field 5
+        //     store v7 at v0
+        //     v8 = load v0
+        //     dec_rc v8
+        //     store v8 at v0
+        //     return
+        // }
+        let main_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("mutator2".into(), main_id, RuntimeType::Acir);
+
+        let array_type = Type::Array(Rc::new(vec![Type::field()]), 2);
+        let reference_type = Type::Reference(Rc::new(array_type.clone()));
+
+        let v0 = builder.add_parameter(reference_type);
+
+        let v1 = builder.insert_load(v0, array_type.clone());
+        builder.insert_inc_rc(v1);
+        builder.insert_store(v0, v1);
+
+        let v2 = builder.insert_load(v1, array_type.clone());
+        let zero = builder.numeric_constant(0u128, Type::unsigned(64));
+        let five = builder.field_constant(5u128);
+        let v7 = builder.insert_array_set(v2, zero, five);
+
+        builder.insert_store(v0, v7);
+        let v8 = builder.insert_load(v0, array_type);
+        builder.insert_dec_rc(v8);
+        builder.insert_store(v0, v8);
+        builder.terminate_with_return(vec![]);
+
+        let ssa = builder.finish().remove_paired_rc();
+        let main = ssa.main();
+        let entry = main.entry_block();
+
+        // No changes, the array is possibly mutated
+        assert_eq!(count_inc_rcs(entry, &main.dfg), 1);
+        assert_eq!(count_dec_rcs(entry, &main.dfg), 1);
+    }
+}
diff --git a/compiler/noirc_frontend/src/monomorphization/debug.rs b/compiler/noirc_frontend/src/monomorphization/debug.rs
index cf4e0ab792e..3a03177f8ec 100644
--- a/compiler/noirc_frontend/src/monomorphization/debug.rs
+++ b/compiler/noirc_frontend/src/monomorphization/debug.rs
@@ -195,8 +195,8 @@ fn element_type_at_index(ptype: &PrintableType, i: usize) -> &PrintableType {
         PrintableType::Tuple { types } => &types[i],
         PrintableType::Struct { name: _name, fields } => &fields[i].1,
         PrintableType::String { length: _length } => &PrintableType::UnsignedInteger { width: 8 },
-        _ => {
-            panic!["expected type with sub-fields, found terminal type"]
+        other => {
+            panic!["expected type with sub-fields, found terminal type: {other:?}"]
         }
     }
 }

From 265bd8b284e5acd572a3812a94a99fc102227ff2 Mon Sep 17 00:00:00 2001
From: Andy <35195301+Andy53@users.noreply.github.com>
Date: Mon, 18 Mar 2024 13:11:52 -0600
Subject: [PATCH 090/416] fix: added error messages for passing oracles and
 references from unconstrained to constrained functions (#4570)

# Description
Added compiler errors for when a oracle or reference is passed from a
unconstrained to a constrained function.

## Problem\*
Currently the compiler panics when you pass a reference or an oracle
from a unconstrained to constrained function.

Resolves https://github.com/noir-lang/noir/issues/4565

Closes 4565

## Summary\*
A compiler error has been added for each condition with an appropriate
message to aid the user.

## Documentation\*

Check one:
- [X ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ X] I have tested the changes locally.
- [ X] I have formatted the changes with
[Prettier](https://prettier.io/) and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 compiler/noirc_evaluator/src/errors.rs        |  3 +++
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  8 +++++---
 .../src/hir/type_check/errors.rs              |  5 +++++
 .../noirc_frontend/src/hir/type_check/expr.rs | 20 +++++++++++--------
 .../unconstrained_oracle/Nargo.toml           |  5 +++++
 .../unconstrained_oracle/src/main.nr          |  9 +++++++++
 .../unconstrained_ref/Nargo.toml              |  5 +++++
 .../unconstrained_ref/src/main.nr             |  8 ++++++++
 8 files changed, 52 insertions(+), 11 deletions(-)
 create mode 100644 test_programs/compile_failure/unconstrained_oracle/Nargo.toml
 create mode 100644 test_programs/compile_failure/unconstrained_oracle/src/main.nr
 create mode 100644 test_programs/compile_failure/unconstrained_ref/Nargo.toml
 create mode 100644 test_programs/compile_failure/unconstrained_ref/src/main.nr

diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index 40f4336e0b5..06259e06248 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -48,6 +48,8 @@ pub enum RuntimeError {
     BigIntModulus { call_stack: CallStack },
     #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
     UnconstrainedSliceReturnToConstrained { call_stack: CallStack },
+    #[error("All `oracle` methods should be wrapped in an unconstrained fn")]
+    UnconstrainedOracleReturnToConstrained { call_stack: CallStack },
 }
 
 // We avoid showing the actual lhs and rhs since most of the time they are just 0
@@ -139,6 +141,7 @@ impl RuntimeError {
             | RuntimeError::NestedSlice { call_stack, .. }
             | RuntimeError::BigIntModulus { call_stack, .. }
             | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack } => call_stack,
+            RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 5a4fa021f1f..8390f480e3a 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -612,9 +612,11 @@ impl Context {
                             self.ssa_values.insert(*result, output);
                         }
                     }
-                    Value::ForeignFunction(_) => unreachable!(
-                        "All `oracle` methods should be wrapped in an unconstrained fn"
-                    ),
+                    Value::ForeignFunction(_) => {
+                        return Err(RuntimeError::UnconstrainedOracleReturnToConstrained {
+                            call_stack: self.acir_context.get_call_stack(),
+                        })
+                    }
                     _ => unreachable!("expected calling a function but got {function_value:?}"),
                 }
             }
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 7eacc8eb2d1..3d834128688 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -122,6 +122,10 @@ pub enum TypeCheckError {
         "Cannot pass a mutable reference from a constrained runtime to an unconstrained runtime"
     )]
     ConstrainedReferenceToUnconstrained { span: Span },
+    #[error(
+        "Cannot pass a mutable reference from a unconstrained runtime to an constrained runtime"
+    )]
+    UnconstrainedReferenceToConstrained { span: Span },
     #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
     UnconstrainedSliceReturnToConstrained { span: Span },
     #[error("Only sized types may be used in the entry point to a program")]
@@ -229,6 +233,7 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::OverflowingAssignment { span, .. }
             | TypeCheckError::FieldModulo { span }
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
+            | TypeCheckError::UnconstrainedReferenceToConstrained { span }
             | TypeCheckError::UnconstrainedSliceReturnToConstrained { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 7219f4d09c6..0b3dd022209 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -184,14 +184,18 @@ impl<'interner> TypeChecker<'interner> {
                 let return_type = self.bind_function_type(function, args, span);
 
                 // Check that we are not passing a slice from an unconstrained runtime to a constrained runtime
-                if is_current_func_constrained
-                    && is_unconstrained_call
-                    && return_type.contains_slice()
-                {
-                    self.errors.push(TypeCheckError::UnconstrainedSliceReturnToConstrained {
-                        span: self.interner.expr_span(expr_id),
-                    });
-                    return Type::Error;
+                if is_current_func_constrained && is_unconstrained_call {
+                    if return_type.contains_slice() {
+                        self.errors.push(TypeCheckError::UnconstrainedSliceReturnToConstrained {
+                            span: self.interner.expr_span(expr_id),
+                        });
+                        return Type::Error;
+                    } else if matches!(&return_type.follow_bindings(), Type::MutableReference(_)) {
+                        self.errors.push(TypeCheckError::UnconstrainedReferenceToConstrained {
+                            span: self.interner.expr_span(expr_id),
+                        });
+                        return Type::Error;
+                    }
                 }
 
                 return_type
diff --git a/test_programs/compile_failure/unconstrained_oracle/Nargo.toml b/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
new file mode 100644
index 00000000000..1081b5ab8e2
--- /dev/null
+++ b/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "unconstrained_oracle"
+type = "bin"
+authors = [""]
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/unconstrained_oracle/src/main.nr b/test_programs/compile_failure/unconstrained_oracle/src/main.nr
new file mode 100644
index 00000000000..abc7bf51ab8
--- /dev/null
+++ b/test_programs/compile_failure/unconstrained_oracle/src/main.nr
@@ -0,0 +1,9 @@
+#[oracle(getNoun)]
+unconstrained fn external_fn() -> Field {
+    100 / 5
+}
+
+fn main() {
+    let x = anon();
+    assert(x * 5 == 100);
+}
diff --git a/test_programs/compile_failure/unconstrained_ref/Nargo.toml b/test_programs/compile_failure/unconstrained_ref/Nargo.toml
new file mode 100644
index 00000000000..b120a3b5532
--- /dev/null
+++ b/test_programs/compile_failure/unconstrained_ref/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "unconstrained_ref"
+type = "bin"
+authors = [""]
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/unconstrained_ref/src/main.nr b/test_programs/compile_failure/unconstrained_ref/src/main.nr
new file mode 100644
index 00000000000..bb4b2090ddb
--- /dev/null
+++ b/test_programs/compile_failure/unconstrained_ref/src/main.nr
@@ -0,0 +1,8 @@
+unconstrained fn uncon_ref() -> &mut Field {
+    let lr = &mut 7;
+    lr
+}
+
+fn main() {
+    let e = uncon_ref();
+}
\ No newline at end of file

From c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 19 Mar 2024 05:25:45 -0400
Subject: [PATCH 091/416] feat: Sync from aztec-packages (#4573)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
chore(avm-simulator): update e2e test
(https://github.com/AztecProtocol/aztec-packages/pull/5283)
feat!: Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
feat: initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
feat: Check initializer msg.sender matches deployer from address
preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
feat: Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
feat(avm): brillig CONST of size > u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
feat: New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
feat!: Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
END_COMMIT_OVERRIDE

---------

Co-authored-by: sirasistant <sirasistant@gmail.com>
---
 .aztec-sync-commit                            |    2 +-
 .github/scripts/wasm-bindgen-install.sh       |    2 +-
 acvm-repo/acir/codegen/acir.cpp               |  246 +++-
 acvm-repo/acir/src/circuit/opcodes.rs         |   16 +
 .../acvm/src/compiler/transformers/mod.rs     |    1 +
 acvm-repo/acvm/src/pwg/mod.rs                 |    1 +
 acvm-repo/brillig/src/opcodes.rs              |   10 +-
 acvm-repo/brillig_vm/src/arithmetic.rs        |   80 +-
 aztec_macros/src/lib.rs                       |    9 -
 aztec_macros/src/transforms/functions.rs      |   19 +-
 aztec_macros/src/utils/errors.rs              |    6 -
 .../brillig/brillig_gen/brillig_black_box.rs  |    4 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |  451 ++++---
 .../brillig/brillig_gen/brillig_directive.rs  |    2 +-
 .../brillig/brillig_gen/brillig_slice_ops.rs  |  165 +--
 .../noirc_evaluator/src/brillig/brillig_ir.rs | 1095 +----------------
 .../brillig/brillig_ir/brillig_variable.rs    |    9 +-
 .../src/brillig/brillig_ir/codegen_binary.rs  |   29 +
 .../src/brillig/brillig_ir/codegen_calls.rs   |  102 ++
 .../brillig_ir/codegen_control_flow.rs        |  141 +++
 .../brillig/brillig_ir/codegen_intrinsic.rs   |   89 ++
 .../src/brillig/brillig_ir/codegen_memory.rs  |  255 ++++
 .../src/brillig/brillig_ir/codegen_stack.rs   |   26 +
 .../src/brillig/brillig_ir/debug_show.rs      |  165 +--
 .../src/brillig/brillig_ir/entry_point.rs     |  115 +-
 .../src/brillig/brillig_ir/instructions.rs    |  522 ++++++++
 .../src/brillig/brillig_ir/registers.rs       |   28 +-
 .../brillig_signed_div/Nargo.toml             |    6 +
 .../brillig_signed_div/Prover.toml            |   75 ++
 .../brillig_signed_div/src/main.nr            |   11 +
 tooling/bb_abstraction_leaks/build.rs         |    2 +-
 .../noir_js_backend_barretenberg/package.json |    2 +-
 yarn.lock                                     |   10 +-
 33 files changed, 2042 insertions(+), 1654 deletions(-)
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
 create mode 100644 compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
 create mode 100644 test_programs/execution_success/brillig_signed_div/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_signed_div/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_signed_div/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 4d9320c79ba..973bfd1534b 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-aa90f6ed7bfae06bdf6990816d154bbd24993689
+82f8cf5eba9deacdab43ad4ef95dbf27dd1c11c7
diff --git a/.github/scripts/wasm-bindgen-install.sh b/.github/scripts/wasm-bindgen-install.sh
index a548372ee2c..20908003693 100755
--- a/.github/scripts/wasm-bindgen-install.sh
+++ b/.github/scripts/wasm-bindgen-install.sh
@@ -6,7 +6,7 @@ cd $(dirname "$0")
 ./cargo-binstall-install.sh
 
 # Install wasm-bindgen-cli.
-if [ "$(wasm-bindgen --version | cut -d' ' -f2)" != "0.2.86" ]; then
+if [ "$(wasm-bindgen --version &> /dev/null | cut -d' ' -f2)" != "0.2.86" ]; then
   echo "Building wasm-bindgen..."
   cargo binstall wasm-bindgen-cli@0.2.86 --force --no-confirm
 fi
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 0fc84d47a0f..11afd44ed6d 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -31,13 +31,31 @@ namespace Circuit {
             static Div bincodeDeserialize(std::vector<uint8_t>);
         };
 
+        struct IntegerDiv {
+            friend bool operator==(const IntegerDiv&, const IntegerDiv&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static IntegerDiv bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Equals {
             friend bool operator==(const Equals&, const Equals&);
             std::vector<uint8_t> bincodeSerialize() const;
             static Equals bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Add, Sub, Mul, Div, Equals> value;
+        struct LessThan {
+            friend bool operator==(const LessThan&, const LessThan&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static LessThan bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct LessThanEquals {
+            friend bool operator==(const LessThanEquals&, const LessThanEquals&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static LessThanEquals bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Add, Sub, Mul, Div, IntegerDiv, Equals, LessThan, LessThanEquals> value;
 
         friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -64,16 +82,10 @@ namespace Circuit {
             static Mul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct SignedDiv {
-            friend bool operator==(const SignedDiv&, const SignedDiv&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static SignedDiv bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct UnsignedDiv {
-            friend bool operator==(const UnsignedDiv&, const UnsignedDiv&);
+        struct Div {
+            friend bool operator==(const Div&, const Div&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static UnsignedDiv bincodeDeserialize(std::vector<uint8_t>);
+            static Div bincodeDeserialize(std::vector<uint8_t>);
         };
 
         struct Equals {
@@ -124,7 +136,7 @@ namespace Circuit {
             static Shr bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Add, Sub, Mul, SignedDiv, UnsignedDiv, Equals, LessThan, LessThanEquals, And, Or, Xor, Shl, Shr> value;
+        std::variant<Add, Sub, Mul, Div, Equals, LessThan, LessThanEquals, And, Or, Xor, Shl, Shr> value;
 
         friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1053,7 +1065,17 @@ namespace Circuit {
             static MemoryInit bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit> value;
+        struct Call {
+            uint32_t id;
+            std::vector<Circuit::Witness> inputs;
+            std::vector<Circuit::Witness> outputs;
+
+            friend bool operator==(const Call&, const Call&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Call bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit, Call> value;
 
         friend bool operator==(const Opcode&, const Opcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1317,6 +1339,41 @@ Circuit::BinaryFieldOp::Div serde::Deserializable<Circuit::BinaryFieldOp::Div>::
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BinaryFieldOp::IntegerDiv::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BinaryFieldOp::IntegerDiv>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BinaryFieldOp::IntegerDiv BinaryFieldOp::IntegerDiv::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BinaryFieldOp::IntegerDiv>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BinaryFieldOp::IntegerDiv>::serialize(const Circuit::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BinaryFieldOp::IntegerDiv serde::Deserializable<Circuit::BinaryFieldOp::IntegerDiv>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryFieldOp::IntegerDiv obj;
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) {
@@ -1352,6 +1409,76 @@ Circuit::BinaryFieldOp::Equals serde::Deserializable<Circuit::BinaryFieldOp::Equ
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BinaryFieldOp::LessThan::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BinaryFieldOp::LessThan>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BinaryFieldOp::LessThan BinaryFieldOp::LessThan::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BinaryFieldOp::LessThan>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BinaryFieldOp::LessThan>::serialize(const Circuit::BinaryFieldOp::LessThan &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BinaryFieldOp::LessThan serde::Deserializable<Circuit::BinaryFieldOp::LessThan>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryFieldOp::LessThan obj;
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BinaryFieldOp::LessThanEquals::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BinaryFieldOp::LessThanEquals>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BinaryFieldOp::LessThanEquals BinaryFieldOp::LessThanEquals::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BinaryFieldOp::LessThanEquals>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BinaryFieldOp::LessThanEquals>::serialize(const Circuit::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BinaryFieldOp::LessThanEquals serde::Deserializable<Circuit::BinaryFieldOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryFieldOp::LessThanEquals obj;
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) {
@@ -1501,19 +1628,19 @@ Circuit::BinaryIntOp::Mul serde::Deserializable<Circuit::BinaryIntOp::Mul>::dese
 
 namespace Circuit {
 
-    inline bool operator==(const BinaryIntOp::SignedDiv &lhs, const BinaryIntOp::SignedDiv &rhs) {
+    inline bool operator==(const BinaryIntOp::Div &lhs, const BinaryIntOp::Div &rhs) {
         return true;
     }
 
-    inline std::vector<uint8_t> BinaryIntOp::SignedDiv::bincodeSerialize() const {
+    inline std::vector<uint8_t> BinaryIntOp::Div::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BinaryIntOp::SignedDiv>::serialize(*this, serializer);
+        serde::Serializable<BinaryIntOp::Div>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BinaryIntOp::SignedDiv BinaryIntOp::SignedDiv::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BinaryIntOp::Div BinaryIntOp::Div::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BinaryIntOp::SignedDiv>::deserialize(deserializer);
+        auto value = serde::Deserializable<BinaryIntOp::Div>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -1524,48 +1651,13 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::SignedDiv>::serialize(const Circuit::BinaryIntOp::SignedDiv &obj, Serializer &serializer) {
+void serde::Serializable<Circuit::BinaryIntOp::Div>::serialize(const Circuit::BinaryIntOp::Div &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::SignedDiv serde::Deserializable<Circuit::BinaryIntOp::SignedDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::SignedDiv obj;
-    return obj;
-}
-
-namespace Circuit {
-
-    inline bool operator==(const BinaryIntOp::UnsignedDiv &lhs, const BinaryIntOp::UnsignedDiv &rhs) {
-        return true;
-    }
-
-    inline std::vector<uint8_t> BinaryIntOp::UnsignedDiv::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BinaryIntOp::UnsignedDiv>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BinaryIntOp::UnsignedDiv BinaryIntOp::UnsignedDiv::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BinaryIntOp::UnsignedDiv>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Circuit
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::UnsignedDiv>::serialize(const Circuit::BinaryIntOp::UnsignedDiv &obj, Serializer &serializer) {
-}
-
-template <>
-template <typename Deserializer>
-Circuit::BinaryIntOp::UnsignedDiv serde::Deserializable<Circuit::BinaryIntOp::UnsignedDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::UnsignedDiv obj;
+Circuit::BinaryIntOp::Div serde::Deserializable<Circuit::BinaryIntOp::Div>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryIntOp::Div obj;
     return obj;
 }
 
@@ -6012,6 +6104,50 @@ Circuit::Opcode::MemoryInit serde::Deserializable<Circuit::Opcode::MemoryInit>::
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) {
+        if (!(lhs.id == rhs.id)) { return false; }
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> Opcode::Call::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<Opcode::Call>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline Opcode::Call Opcode::Call::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<Opcode::Call>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::Opcode::Call>::serialize(const Circuit::Opcode::Call &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.id)>::serialize(obj.id, serializer);
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::Opcode::Call serde::Deserializable<Circuit::Opcode::Call>::deserialize(Deserializer &deserializer) {
+    Circuit::Opcode::Call obj;
+    obj.id = serde::Deserializable<decltype(obj.id)>::deserialize(deserializer);
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) {
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index f725ba8c32a..064a9d1244a 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -29,6 +29,17 @@ pub enum Opcode {
         block_id: BlockId,
         init: Vec<Witness>,
     },
+    /// Calls to functions represented as a separate circuit. A call opcode allows us
+    /// to build a call stack when executing the outer-most circuit.
+    Call {
+        /// Id for the function being called. It is the responsibility of the executor
+        /// to fetch the appropriate circuit from this id.
+        id: u32,
+        /// Inputs to the function call
+        inputs: Vec<Witness>,
+        /// Outputs of the function call
+        outputs: Vec<Witness>,
+    },
 }
 
 impl std::fmt::Display for Opcode {
@@ -86,6 +97,11 @@ impl std::fmt::Display for Opcode {
                 write!(f, "INIT ")?;
                 write!(f, "(id: {}, len: {}) ", block_id.0, init.len())
             }
+            Opcode::Call { id, inputs, outputs } => {
+                write!(f, "CALL func {}: ", id)?;
+                writeln!(f, "inputs: {:?}", inputs)?;
+                writeln!(f, "outputs: {:?}", outputs)
+            }
         }
     }
 }
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 214243d9360..2e549854521 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -145,6 +145,7 @@ pub(super) fn transform_internal(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
+            Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
         }
     }
 
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index d8323e5ef5f..0fd733a6336 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -281,6 +281,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
                 res => res.map(|_| ()),
             },
+            Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
         };
         self.handle_opcode_resolution(resolution)
     }
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index 51df1f90941..03a8e53e510 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -180,9 +180,16 @@ pub enum BinaryFieldOp {
     Add,
     Sub,
     Mul,
+    /// Field division
     Div,
+    /// Integer division
+    IntegerDiv,
     /// (==) equal
     Equals,
+    /// (<) Field less than
+    LessThan,
+    /// (<=) field less or equal
+    LessThanEquals,
 }
 
 /// Binary fixed-length integer expressions
@@ -191,8 +198,7 @@ pub enum BinaryIntOp {
     Add,
     Sub,
     Mul,
-    SignedDiv,
-    UnsignedDiv,
+    Div,
     /// (==) equal
     Equals,
     /// (<) Field less than
diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
index 9d7b6fe8f02..81103be582d 100644
--- a/acvm-repo/brillig_vm/src/arithmetic.rs
+++ b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -1,6 +1,6 @@
 use acir::brillig::{BinaryFieldOp, BinaryIntOp};
 use acir::FieldElement;
-use num_bigint::{BigInt, BigUint};
+use num_bigint::BigUint;
 use num_traits::{One, ToPrimitive, Zero};
 
 /// Evaluate a binary operation on two FieldElements and return the result as a FieldElement.
@@ -15,7 +15,16 @@ pub(crate) fn evaluate_binary_field_op(
         BinaryFieldOp::Sub => a - b,
         BinaryFieldOp::Mul => a * b,
         BinaryFieldOp::Div => a / b,
+        BinaryFieldOp::IntegerDiv => {
+            let a_big = BigUint::from_bytes_be(&a.to_be_bytes());
+            let b_big = BigUint::from_bytes_be(&b.to_be_bytes());
+
+            let result = a_big / b_big;
+            FieldElement::from_be_bytes_reduce(&result.to_bytes_be())
+        }
         BinaryFieldOp::Equals => (a == b).into(),
+        BinaryFieldOp::LessThan => (a < b).into(),
+        BinaryFieldOp::LessThanEquals => (a <= b).into(),
     }
 }
 
@@ -33,7 +42,7 @@ pub(crate) fn evaluate_binary_bigint_op(
         BinaryIntOp::Sub => (bit_modulo + a - b) % bit_modulo,
         BinaryIntOp::Mul => (a * b) % bit_modulo,
         // Perform unsigned division using the modulo operation on a and b.
-        BinaryIntOp::UnsignedDiv => {
+        BinaryIntOp::Div => {
             let b_mod = b % bit_modulo;
             if b_mod.is_zero() {
                 BigUint::zero()
@@ -41,16 +50,6 @@ pub(crate) fn evaluate_binary_bigint_op(
                 (a % bit_modulo) / b_mod
             }
         }
-        // Perform signed division by first converting a and b to signed integers and then back to unsigned after the operation.
-        BinaryIntOp::SignedDiv => {
-            let b_signed = to_big_signed(b, bit_size);
-            if b_signed.is_zero() {
-                BigUint::zero()
-            } else {
-                let signed_div = to_big_signed(a, bit_size) / b_signed;
-                to_big_unsigned(signed_div, bit_size)
-            }
-        }
         // Perform a == operation, returning 0 or 1
         BinaryIntOp::Equals => {
             if (a % bit_modulo) == (b % bit_modulo) {
@@ -94,23 +93,6 @@ pub(crate) fn evaluate_binary_bigint_op(
     Ok(result)
 }
 
-fn to_big_signed(a: BigUint, bit_size: u32) -> BigInt {
-    let pow_2 = BigUint::from(2_u32).pow(bit_size - 1);
-    if a < pow_2 {
-        BigInt::from(a)
-    } else {
-        BigInt::from(a) - 2 * BigInt::from(pow_2)
-    }
-}
-
-fn to_big_unsigned(a: BigInt, bit_size: u32) -> BigUint {
-    if a >= BigInt::zero() {
-        BigUint::from_bytes_le(&a.to_bytes_le().1)
-    } else {
-        BigUint::from(2_u32).pow(bit_size) - BigUint::from_bytes_le(&a.to_bytes_le().1)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -130,24 +112,6 @@ mod tests {
         result_value.to_u128().unwrap()
     }
 
-    fn to_signed(a: u128, bit_size: u32) -> i128 {
-        assert!(bit_size < 128);
-        let pow_2 = 2_u128.pow(bit_size - 1);
-        if a < pow_2 {
-            a as i128
-        } else {
-            (a.wrapping_sub(2 * pow_2)) as i128
-        }
-    }
-
-    fn to_unsigned(a: i128, bit_size: u32) -> u128 {
-        if a >= 0 {
-            a as u128
-        } else {
-            (a + 2_i128.pow(bit_size)) as u128
-        }
-    }
-
     fn to_negative(a: u128, bit_size: u32) -> u128 {
         assert!(a > 0);
         let two_pow = 2_u128.pow(bit_size);
@@ -224,26 +188,6 @@ mod tests {
         let test_ops =
             vec![TestParams { a: 5, b: 3, result: 1 }, TestParams { a: 5, b: 10, result: 0 }];
 
-        evaluate_int_ops(test_ops, BinaryIntOp::UnsignedDiv, bit_size);
-    }
-
-    #[test]
-    fn to_signed_roundtrip() {
-        let bit_size = 32;
-        let minus_one = 2_u128.pow(bit_size) - 1;
-        assert_eq!(to_unsigned(to_signed(minus_one, bit_size), bit_size), minus_one);
-    }
-
-    #[test]
-    fn signed_div_test() {
-        let bit_size = 32;
-
-        let test_ops = vec![
-            TestParams { a: 5, b: to_negative(10, bit_size), result: 0 },
-            TestParams { a: 5, b: to_negative(1, bit_size), result: to_negative(5, bit_size) },
-            TestParams { a: to_negative(5, bit_size), b: to_negative(1, bit_size), result: 5 },
-        ];
-
-        evaluate_int_ops(test_ops, BinaryIntOp::SignedDiv, bit_size);
+        evaluate_int_ops(test_ops, BinaryIntOp::Div, bit_size);
     }
 }
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 1f3546cbb6a..e0100977eee 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -179,15 +179,6 @@ fn transform_module(
                 crate_graph.root_file_id,
             ));
         }
-
-        let constructor_defined = module.functions.iter().any(|func| func.name() == "constructor");
-        if !constructor_defined {
-            let crate_graph = &context.crate_graph[crate_id];
-            return Err((
-                AztecMacroError::ContractConstructorMissing { span: Span::default() },
-                crate_graph.root_file_id,
-            ));
-        }
     }
 
     Ok(has_transformed_module)
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 09c11e173fe..c719651e10e 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -48,10 +48,9 @@ pub fn transform_function(
         func.def.body.0.insert(0, init_check);
     }
 
-    // Add assertion for initialization arguments
+    // Add assertion for initialization arguments and sender
     if is_initializer {
-        let assert_init_args = create_assert_init_args();
-        func.def.body.0.insert(0, assert_init_args);
+        func.def.body.0.insert(0, create_assert_initializer());
     }
 
     // Add access to the storage struct
@@ -120,9 +119,6 @@ pub fn transform_vm_function(
     // We want the function to be seen as a public function
     func.def.is_unconstrained = true;
 
-    // NOTE: the line below is a temporary hack to trigger external transpilation tools
-    // It will be removed once the transpiler is integrated into the Noir compiler
-    func.def.name.0.contents = format!("avm_{}", func.def.name.0.contents);
     Ok(())
 }
 
@@ -211,18 +207,19 @@ fn create_internal_check(fname: &str) -> Statement {
     )))
 }
 
-/// Creates a call to assert_initialization_args_match_address_preimage to ensure
-/// the initialization arguments used in the init call match the address preimage.
+/// Creates a call to assert_initialization_matches_address_preimage to be inserted
+/// in the initializer. Checks that the args and sender to the initializer match the
+/// commitments from the address preimage.
 ///
 /// ```noir
-/// assert_initialization_args_match_address_preimage(context);
+/// assert_initialization_matches_address_preimage(context);
 /// ```
-fn create_assert_init_args() -> Statement {
+fn create_assert_initializer() -> Statement {
     make_statement(StatementKind::Expression(call(
         variable_path(chained_dep!(
             "aztec",
             "initializer",
-            "assert_initialization_args_match_address_preimage"
+            "assert_initialization_matches_address_preimage"
         )),
         vec![variable("context")],
     )))
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 63892b58af9..199473baec6 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -7,7 +7,6 @@ use super::constants::MAX_CONTRACT_PRIVATE_FUNCTIONS;
 pub enum AztecMacroError {
     AztecDepNotFound,
     ContractHasTooManyPrivateFunctions { span: Span },
-    ContractConstructorMissing { span: Span },
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
@@ -29,11 +28,6 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: Some(span),
             },
-            AztecMacroError::ContractConstructorMissing { span } => MacroError {
-                primary_message: "Contract must have a constructor function".to_owned(),
-                secondary_message: None,
-                span: Some(span),
-            },
             AztecMacroError::UnsupportedFunctionArgumentType { span, typ } => MacroError {
                 primary_message: format!("Provided parameter type `{typ:?}` is not supported in Aztec contract interface"),
                 secondary_message: None,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index d542240a40c..36e5c99a2ca 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -167,7 +167,7 @@ pub(crate) fn convert_black_box_call(
             ) = (function_arguments, function_results)
             {
                 let message_hash = convert_array_or_vector(brillig_context, message, bb_func);
-                let signature = brillig_context.array_to_vector(signature);
+                let signature = brillig_context.array_to_vector_instruction(signature);
                 brillig_context.black_box_op_instruction(BlackBoxOp::SchnorrVerify {
                     public_key_x: public_key_x.address,
                     public_key_y: public_key_y.address,
@@ -368,7 +368,7 @@ fn convert_array_or_vector(
     bb_func: &BlackBoxFunc,
 ) -> BrilligVector {
     match array_or_vector {
-        BrilligVariable::BrilligArray(array) => brillig_context.array_to_vector(array),
+        BrilligVariable::BrilligArray(array) => brillig_context.array_to_vector_instruction(array),
         BrilligVariable::BrilligVector(vector) => *vector,
         _ => unreachable!(
             "ICE: {} expected an array or a vector, but got {:?}",
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 99400b13528..f808bfac43b 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -16,7 +16,7 @@ use crate::ssa::ir::{
     types::{NumericType, Type},
     value::{Value, ValueId},
 };
-use acvm::acir::brillig::{BinaryFieldOp, BinaryIntOp, MemoryAddress, ValueOrArray};
+use acvm::acir::brillig::{MemoryAddress, ValueOrArray};
 use acvm::brillig_vm::brillig::HeapVector;
 use acvm::FieldElement;
 use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
@@ -155,7 +155,7 @@ impl<'block> BrilligBlock<'block> {
                         return_variable.extract_registers()
                     })
                     .collect();
-                self.brillig_context.return_instruction(&return_registers);
+                self.brillig_context.codegen_return(&return_registers);
             }
         }
     }
@@ -297,16 +297,15 @@ impl<'block> BrilligBlock<'block> {
                     Type::Reference(element) => match *element {
                         Type::Array(..) => {
                             self.brillig_context
-                                .allocate_array_reference_instruction(address_register.address);
+                                .codegen_allocate_array_reference(address_register.address);
                         }
                         Type::Slice(..) => {
                             self.brillig_context
-                                .allocate_vector_reference_instruction(address_register.address);
+                                .codegen_allocate_vector_reference(address_register.address);
                         }
                         _ => {
-                            self.brillig_context.allocate_single_addr_reference_instruction(
-                                address_register.address,
-                            );
+                            self.brillig_context
+                                .codegen_allocate_single_addr_reference(address_register.address);
                         }
                     },
                     _ => {
@@ -318,8 +317,7 @@ impl<'block> BrilligBlock<'block> {
                 let address_var = self.convert_ssa_single_addr_value(*address, dfg);
                 let source_variable = self.convert_ssa_value(*value, dfg);
 
-                self.brillig_context
-                    .store_variable_instruction(address_var.address, source_variable);
+                self.brillig_context.codegen_store_variable(address_var.address, source_variable);
             }
             Instruction::Load { address } => {
                 let target_variable = self.variables.define_variable(
@@ -332,7 +330,7 @@ impl<'block> BrilligBlock<'block> {
                 let address_variable = self.convert_ssa_single_addr_value(*address, dfg);
 
                 self.brillig_context
-                    .load_variable_instruction(target_variable, address_variable.address);
+                    .codegen_load_variable(target_variable, address_variable.address);
             }
             Instruction::Not(value) => {
                 let condition_register = self.convert_ssa_single_addr_value(*value, dfg);
@@ -374,16 +372,16 @@ impl<'block> BrilligBlock<'block> {
                         if let ValueOrArray::HeapVector(HeapVector { size, .. }) = output_register {
                             // Update the stack pointer so that we do not overwrite
                             // dynamic memory returned from other external calls
-                            self.brillig_context.update_stack_pointer(*size);
+                            self.brillig_context.increase_free_memory_pointer_instruction(*size);
 
                             // Update the dynamic slice length maintained in SSA
                             if let ValueOrArray::MemoryAddress(len_index) = output_registers[i - 1]
                             {
                                 let element_size = dfg[result_ids[i]].get_type().element_size();
                                 self.brillig_context.mov_instruction(len_index, *size);
-                                self.brillig_context.usize_op_in_place(
+                                self.brillig_context.codegen_usize_op_in_place(
                                     len_index,
-                                    BinaryIntOp::UnsignedDiv,
+                                    BrilligBinaryOp::UnsignedDiv,
                                     element_size,
                                 );
                             } else {
@@ -518,7 +516,7 @@ impl<'block> BrilligBlock<'block> {
                     // Update the user-facing slice length
                     self.brillig_context.mov_instruction(target_len.address, limb_count.address);
 
-                    self.brillig_context.radix_instruction(
+                    self.brillig_context.codegen_to_radix(
                         source,
                         target_vector,
                         radix,
@@ -547,18 +545,18 @@ impl<'block> BrilligBlock<'block> {
                         dfg,
                     ) {
                         BrilligVariable::BrilligArray(array) => {
-                            self.brillig_context.array_to_vector(&array)
+                            self.brillig_context.array_to_vector_instruction(&array)
                         }
                         BrilligVariable::BrilligVector(vector) => vector,
                         BrilligVariable::SingleAddr(..) => unreachable!("ICE: ToBits on non-array"),
                     };
 
-                    let radix = self.brillig_context.make_constant(2_usize.into(), 32);
+                    let radix = self.brillig_context.make_constant_instruction(2_usize.into(), 32);
 
                     // Update the user-facing slice length
                     self.brillig_context.mov_instruction(target_len.address, limb_count.address);
 
-                    self.brillig_context.radix_instruction(
+                    self.brillig_context.codegen_to_radix(
                         source,
                         target_vector,
                         radix,
@@ -581,7 +579,7 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 let source_register = self.convert_ssa_single_addr_value(*value, dfg);
-                self.brillig_context.truncate_instruction(
+                self.brillig_context.codegen_truncate(
                     destination_register,
                     source_register,
                     *bit_size,
@@ -655,20 +653,19 @@ impl<'block> BrilligBlock<'block> {
 
                     // Create a field constant with the max
                     let max = BigUint::from(2_u128).pow(*max_bit_size) - BigUint::from(1_u128);
-                    let right = self.brillig_context.make_constant(
+                    let right = self.brillig_context.make_constant_instruction(
                         FieldElement::from_be_bytes_reduce(&max.to_bytes_be()).into(),
                         FieldElement::max_num_bits(),
                     );
 
                     // Check if lte max
-                    let brillig_binary_op = BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals);
                     let condition =
                         SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                     self.brillig_context.binary_instruction(
                         left,
                         right,
                         condition,
-                        brillig_binary_op,
+                        BrilligBinaryOp::LessThanEquals,
                     );
 
                     self.brillig_context.constrain_instruction(condition, assert_message.clone());
@@ -683,7 +680,11 @@ impl<'block> BrilligBlock<'block> {
                     | BrilligVariable::BrilligVector(BrilligVector { rc, .. }) => rc,
                     other => unreachable!("ICE: increment rc on non-array: {other:?}"),
                 };
-                self.brillig_context.usize_op_in_place(rc_register, BinaryIntOp::Add, 1);
+                self.brillig_context.codegen_usize_op_in_place(
+                    rc_register,
+                    BrilligBinaryOp::Add,
+                    1,
+                );
             }
             Instruction::DecrementRc { value } => {
                 let rc_register = match self.convert_ssa_value(*value, dfg) {
@@ -691,7 +692,11 @@ impl<'block> BrilligBlock<'block> {
                     | BrilligVariable::BrilligVector(BrilligVector { rc, .. }) => rc,
                     other => unreachable!("ICE: decrement rc on non-array: {other:?}"),
                 };
-                self.brillig_context.usize_op_in_place(rc_register, BinaryIntOp::Sub, 1);
+                self.brillig_context.codegen_usize_op_in_place(
+                    rc_register,
+                    BrilligBinaryOp::Sub,
+                    1,
+                );
             }
             Instruction::EnableSideEffects { .. } => {
                 todo!("enable_side_effects not supported by brillig")
@@ -733,7 +738,7 @@ impl<'block> BrilligBlock<'block> {
 
         let saved_registers = self
             .brillig_context
-            .pre_call_save_registers_prep_args(&argument_registers, &variables_to_save);
+            .codegen_pre_call_save_registers_prep_args(&argument_registers, &variables_to_save);
 
         // We don't save and restore constants, so we dump them before a external call since the callee might use the registers where they are allocated.
         self.variables.dump_constants();
@@ -767,7 +772,7 @@ impl<'block> BrilligBlock<'block> {
 
         // puts the returns into the returned_registers and restores saved_registers
         self.brillig_context
-            .post_call_prep_returns_load_registers(&returned_registers, &saved_registers);
+            .codegen_post_call_prep_returns_load_registers(&returned_registers, &saved_registers);
     }
 
     fn validate_array_index(
@@ -777,7 +782,7 @@ impl<'block> BrilligBlock<'block> {
     ) {
         let (size_as_register, should_deallocate_size) = match array_variable {
             BrilligVariable::BrilligArray(BrilligArray { size, .. }) => {
-                (self.brillig_context.make_usize_constant(size.into()), true)
+                (self.brillig_context.make_usize_constant_instruction(size.into()), true)
             }
             BrilligVariable::BrilligVector(BrilligVector { size, .. }) => {
                 (SingleAddrVariable::new_usize(size), false)
@@ -787,11 +792,11 @@ impl<'block> BrilligBlock<'block> {
 
         let condition = SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
 
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             index_register.address,
             size_as_register.address,
             condition.address,
-            BinaryIntOp::LessThan,
+            BrilligBinaryOp::LessThan,
         );
 
         self.brillig_context
@@ -811,7 +816,7 @@ impl<'block> BrilligBlock<'block> {
     ) {
         match destination_variable {
             BrilligVariable::SingleAddr(destination_register) => {
-                self.brillig_context.array_get(
+                self.brillig_context.codegen_array_get(
                     array_pointer,
                     index_var,
                     destination_register.address,
@@ -819,8 +824,8 @@ impl<'block> BrilligBlock<'block> {
             }
             BrilligVariable::BrilligArray(..) | BrilligVariable::BrilligVector(..) => {
                 let reference = self.brillig_context.allocate_register();
-                self.brillig_context.array_get(array_pointer, index_var, reference);
-                self.brillig_context.load_variable_instruction(destination_variable, reference);
+                self.brillig_context.codegen_array_get(array_pointer, index_var, reference);
+                self.brillig_context.codegen_load_variable(destination_variable, reference);
                 self.brillig_context.deallocate_register(reference);
             }
         }
@@ -852,7 +857,7 @@ impl<'block> BrilligBlock<'block> {
         let (source_pointer, source_size_as_register) = match source_variable {
             BrilligVariable::BrilligArray(BrilligArray { size, pointer, rc: _ }) => {
                 let source_size_register = self.brillig_context.allocate_register();
-                self.brillig_context.usize_const(source_size_register, size.into());
+                self.brillig_context.usize_const_instruction(source_size_register, size.into());
                 (pointer, source_size_register)
             }
             BrilligVariable::BrilligVector(BrilligVector { size, pointer, rc: _ }) => {
@@ -864,23 +869,23 @@ impl<'block> BrilligBlock<'block> {
         };
 
         // Here we want to compare the reference count against 1.
-        let one = self.brillig_context.make_usize_constant(1_usize.into());
+        let one = self.brillig_context.make_usize_constant_instruction(1_usize.into());
         let condition = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             reference_count,
             one.address,
             condition,
-            BinaryIntOp::Equals,
+            BrilligBinaryOp::Equals,
         );
-        self.brillig_context.branch_instruction(condition, |ctx, cond| {
+        self.brillig_context.codegen_branch(condition, |ctx, cond| {
             if cond {
                 // Reference count is 1, we can mutate the array directly
                 ctx.mov_instruction(destination_pointer, source_pointer);
             } else {
                 // First issue a array copy to the destination
-                ctx.allocate_array_instruction(destination_pointer, source_size_as_register);
+                ctx.codegen_allocate_array(destination_pointer, source_size_as_register);
 
-                ctx.copy_array_instruction(
+                ctx.codegen_copy_array(
                     source_pointer,
                     destination_pointer,
                     SingleAddrVariable::new(
@@ -893,7 +898,7 @@ impl<'block> BrilligBlock<'block> {
 
         match destination_variable {
             BrilligVariable::BrilligArray(BrilligArray { rc: target_rc, .. }) => {
-                self.brillig_context.usize_const(target_rc, 1_usize.into());
+                self.brillig_context.usize_const_instruction(target_rc, 1_usize.into());
             }
             BrilligVariable::BrilligVector(BrilligVector {
                 size: target_size,
@@ -901,7 +906,7 @@ impl<'block> BrilligBlock<'block> {
                 ..
             }) => {
                 self.brillig_context.mov_instruction(target_size, source_size_as_register);
-                self.brillig_context.usize_const(target_rc, 1_usize.into());
+                self.brillig_context.usize_const_instruction(target_rc, 1_usize.into());
             }
             _ => unreachable!("ICE: array_set SSA on non-array"),
         }
@@ -927,20 +932,20 @@ impl<'block> BrilligBlock<'block> {
     ) {
         match value_variable {
             BrilligVariable::SingleAddr(value_variable) => {
-                ctx.array_set(destination_pointer, index_register, value_variable.address);
+                ctx.codegen_array_set(destination_pointer, index_register, value_variable.address);
             }
             BrilligVariable::BrilligArray(_) => {
                 let reference: MemoryAddress = ctx.allocate_register();
-                ctx.allocate_array_reference_instruction(reference);
-                ctx.store_variable_instruction(reference, value_variable);
-                ctx.array_set(destination_pointer, index_register, reference);
+                ctx.codegen_allocate_array_reference(reference);
+                ctx.codegen_store_variable(reference, value_variable);
+                ctx.codegen_array_set(destination_pointer, index_register, reference);
                 ctx.deallocate_register(reference);
             }
             BrilligVariable::BrilligVector(_) => {
                 let reference = ctx.allocate_register();
-                ctx.allocate_vector_reference_instruction(reference);
-                ctx.store_variable_instruction(reference, value_variable);
-                ctx.array_set(destination_pointer, index_register, reference);
+                ctx.codegen_allocate_vector_reference(reference);
+                ctx.codegen_store_variable(reference, value_variable);
+                ctx.codegen_array_set(destination_pointer, index_register, reference);
                 ctx.deallocate_register(reference);
             }
         }
@@ -998,7 +1003,12 @@ impl<'block> BrilligBlock<'block> {
                     self.convert_ssa_value(*arg, dfg)
                 });
 
-                self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Add);
+                self.update_slice_length(
+                    target_len.address,
+                    arguments[0],
+                    dfg,
+                    BrilligBinaryOp::Add,
+                );
 
                 self.slice_push_back_operation(target_vector, source_vector, &item_values);
             }
@@ -1024,7 +1034,12 @@ impl<'block> BrilligBlock<'block> {
                     self.convert_ssa_value(*arg, dfg)
                 });
 
-                self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Add);
+                self.update_slice_length(
+                    target_len.address,
+                    arguments[0],
+                    dfg,
+                    BrilligBinaryOp::Add,
+                );
 
                 self.slice_push_front_operation(target_vector, source_vector, &item_values);
             }
@@ -1057,7 +1072,12 @@ impl<'block> BrilligBlock<'block> {
                     )
                 });
 
-                self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Sub);
+                self.update_slice_length(
+                    target_len.address,
+                    arguments[0],
+                    dfg,
+                    BrilligBinaryOp::Sub,
+                );
 
                 self.slice_pop_back_operation(target_vector, source_vector, &pop_variables);
             }
@@ -1089,7 +1109,12 @@ impl<'block> BrilligBlock<'block> {
                 );
                 let target_vector = target_variable.extract_vector();
 
-                self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Sub);
+                self.update_slice_length(
+                    target_len.address,
+                    arguments[0],
+                    dfg,
+                    BrilligBinaryOp::Sub,
+                );
 
                 self.slice_pop_front_operation(target_vector, source_vector, &pop_variables);
             }
@@ -1118,20 +1143,26 @@ impl<'block> BrilligBlock<'block> {
                 // https://github.com/noir-lang/noir/issues/1889#issuecomment-1668048587
                 let user_index = self.convert_ssa_single_addr_value(arguments[2], dfg);
 
-                let converted_index = self.brillig_context.make_usize_constant(element_size.into());
+                let converted_index =
+                    self.brillig_context.make_usize_constant_instruction(element_size.into());
 
-                self.brillig_context.memory_op(
+                self.brillig_context.memory_op_instruction(
                     converted_index.address,
                     user_index.address,
                     converted_index.address,
-                    BinaryIntOp::Mul,
+                    BrilligBinaryOp::Mul,
                 );
 
                 let items = vecmap(&arguments[3..element_size + 3], |arg| {
                     self.convert_ssa_value(*arg, dfg)
                 });
 
-                self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Add);
+                self.update_slice_length(
+                    target_len.address,
+                    arguments[0],
+                    dfg,
+                    BrilligBinaryOp::Add,
+                );
 
                 self.slice_insert_operation(target_vector, source_vector, converted_index, &items);
                 self.brillig_context.deallocate_single_addr(converted_index);
@@ -1161,12 +1192,13 @@ impl<'block> BrilligBlock<'block> {
                 // https://github.com/noir-lang/noir/issues/1889#issuecomment-1668048587
                 let user_index = self.convert_ssa_single_addr_value(arguments[2], dfg);
 
-                let converted_index = self.brillig_context.make_usize_constant(element_size.into());
-                self.brillig_context.memory_op(
+                let converted_index =
+                    self.brillig_context.make_usize_constant_instruction(element_size.into());
+                self.brillig_context.memory_op_instruction(
                     converted_index.address,
                     user_index.address,
                     converted_index.address,
-                    BinaryIntOp::Mul,
+                    BrilligBinaryOp::Mul,
                 );
 
                 let removed_items = vecmap(&results[2..element_size + 2], |result| {
@@ -1178,7 +1210,12 @@ impl<'block> BrilligBlock<'block> {
                     )
                 });
 
-                self.update_slice_length(target_len.address, arguments[0], dfg, BinaryIntOp::Sub);
+                self.update_slice_length(
+                    target_len.address,
+                    arguments[0],
+                    dfg,
+                    BrilligBinaryOp::Sub,
+                );
 
                 self.slice_remove_operation(
                     target_vector,
@@ -1207,12 +1244,12 @@ impl<'block> BrilligBlock<'block> {
         target_len: MemoryAddress,
         source_value: ValueId,
         dfg: &DataFlowGraph,
-        binary_op: BinaryIntOp,
+        binary_op: BrilligBinaryOp,
     ) {
         let source_len_variable = self.convert_ssa_value(source_value, dfg);
         let source_len = source_len_variable.extract_single_addr();
 
-        self.brillig_context.usize_op(source_len.address, target_len, binary_op, 1);
+        self.brillig_context.codegen_usize_op(source_len.address, target_len, binary_op, 1);
     }
 
     /// Converts an SSA cast to a sequence of Brillig opcodes.
@@ -1237,14 +1274,166 @@ impl<'block> BrilligBlock<'block> {
         let left = self.convert_ssa_single_addr_value(binary.lhs, dfg);
         let right = self.convert_ssa_single_addr_value(binary.rhs, dfg);
 
-        let (brillig_binary_op, is_signed) =
-            convert_ssa_binary_op_to_brillig_binary_op(binary.operator, &binary_type);
+        let (is_field, is_signed) = match binary_type {
+            Type::Numeric(numeric_type) => match numeric_type {
+                NumericType::Signed { .. } => (false, true),
+                NumericType::Unsigned { .. } => (false, false),
+                NumericType::NativeField => (true, false),
+            },
+            _ => unreachable!("only numeric types are allowed in binary operations. References are handled separately"),
+        };
+
+        let brillig_binary_op = match binary.operator {
+            BinaryOp::Div => {
+                if is_signed {
+                    self.convert_signed_division(left, right, result_variable);
+                    return;
+                } else if is_field {
+                    BrilligBinaryOp::FieldDiv
+                } else {
+                    BrilligBinaryOp::UnsignedDiv
+                }
+            }
+            BinaryOp::Mod => {
+                if is_signed {
+                    self.convert_signed_modulo(left, right, result_variable);
+                    return;
+                } else {
+                    BrilligBinaryOp::Modulo
+                }
+            }
+            BinaryOp::Add => BrilligBinaryOp::Add,
+            BinaryOp::Sub => BrilligBinaryOp::Sub,
+            BinaryOp::Mul => BrilligBinaryOp::Mul,
+            BinaryOp::Eq => BrilligBinaryOp::Equals,
+            BinaryOp::Lt => BrilligBinaryOp::LessThan,
+            BinaryOp::And => BrilligBinaryOp::And,
+            BinaryOp::Or => BrilligBinaryOp::Or,
+            BinaryOp::Xor => BrilligBinaryOp::Xor,
+            BinaryOp::Shl => BrilligBinaryOp::Shl,
+            BinaryOp::Shr => BrilligBinaryOp::Shr,
+        };
 
         self.brillig_context.binary_instruction(left, right, result_variable, brillig_binary_op);
 
         self.add_overflow_check(brillig_binary_op, left, right, result_variable, is_signed);
     }
 
+    /// Splits a two's complement signed integer in the sign bit and the absolute value.
+    /// For example, -6 i8 (11111010) is split to 00000110 (6, absolute value) and 1 (is_negative).
+    fn absolute_value(
+        &mut self,
+        num: SingleAddrVariable,
+        absolute_value: SingleAddrVariable,
+        result_is_negative: SingleAddrVariable,
+    ) {
+        let max_positive = self
+            .brillig_context
+            .make_constant_instruction(((1_u128 << (num.bit_size - 1)) - 1).into(), num.bit_size);
+
+        // Compute if num is negative
+        self.brillig_context.binary_instruction(
+            max_positive,
+            num,
+            result_is_negative,
+            BrilligBinaryOp::LessThan,
+        );
+
+        self.brillig_context.codegen_branch(result_is_negative.address, |ctx, is_negative| {
+            if is_negative {
+                // Two's complement of num
+                let zero = ctx.make_constant_instruction(0_usize.into(), num.bit_size);
+                ctx.binary_instruction(zero, num, absolute_value, BrilligBinaryOp::Sub);
+                ctx.deallocate_single_addr(zero);
+            } else {
+                // Simply move the original num
+                ctx.mov_instruction(absolute_value.address, num.address);
+            }
+        });
+        self.brillig_context.deallocate_single_addr(max_positive);
+    }
+
+    fn convert_signed_division(
+        &mut self,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+        result: SingleAddrVariable,
+    ) {
+        let left_is_negative = SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
+        let left_abs_value =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), left.bit_size);
+
+        let right_is_negative =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
+        let right_abs_value =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), right.bit_size);
+
+        let result_is_negative =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
+
+        // Compute both absolute values
+        self.absolute_value(left, left_abs_value, left_is_negative);
+        self.absolute_value(right, right_abs_value, right_is_negative);
+
+        // Perform the division on the absolute values
+        self.brillig_context.binary_instruction(
+            left_abs_value,
+            right_abs_value,
+            result,
+            BrilligBinaryOp::UnsignedDiv,
+        );
+
+        // Compute result sign
+        self.brillig_context.binary_instruction(
+            left_is_negative,
+            right_is_negative,
+            result_is_negative,
+            BrilligBinaryOp::Xor,
+        );
+
+        // If result has to be negative, perform two's complement
+        self.brillig_context.codegen_if(result_is_negative.address, |ctx| {
+            let zero = ctx.make_constant_instruction(0_usize.into(), result.bit_size);
+            ctx.binary_instruction(zero, result, result, BrilligBinaryOp::Sub);
+            ctx.deallocate_single_addr(zero);
+        });
+
+        self.brillig_context.deallocate_single_addr(left_is_negative);
+        self.brillig_context.deallocate_single_addr(left_abs_value);
+        self.brillig_context.deallocate_single_addr(right_is_negative);
+        self.brillig_context.deallocate_single_addr(right_abs_value);
+        self.brillig_context.deallocate_single_addr(result_is_negative);
+    }
+
+    fn convert_signed_modulo(
+        &mut self,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+        result: SingleAddrVariable,
+    ) {
+        let scratch_var_i =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), left.bit_size);
+        let scratch_var_j =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), left.bit_size);
+
+        // i = left / right
+        self.convert_signed_division(left, right, scratch_var_i);
+
+        // j = i * right
+        self.brillig_context.binary_instruction(
+            scratch_var_i,
+            right,
+            scratch_var_j,
+            BrilligBinaryOp::Mul,
+        );
+
+        // result_register = left - j
+        self.brillig_context.binary_instruction(left, scratch_var_j, result, BrilligBinaryOp::Sub);
+        // Free scratch registers
+        self.brillig_context.deallocate_single_addr(scratch_var_i);
+        self.brillig_context.deallocate_single_addr(scratch_var_j);
+    }
+
     fn add_overflow_check(
         &mut self,
         binary_operation: BrilligBinaryOp,
@@ -1253,15 +1442,14 @@ impl<'block> BrilligBlock<'block> {
         result: SingleAddrVariable,
         is_signed: bool,
     ) {
-        let (op, bit_size) = if let BrilligBinaryOp::Integer(op) = binary_operation {
-            // Bit size is checked at compile time to be equal for left and right
-            (op, left.bit_size)
-        } else {
+        let bit_size = left.bit_size;
+
+        if bit_size == FieldElement::max_num_bits() {
             return;
-        };
+        }
 
-        match (op, is_signed) {
-            (BinaryIntOp::Add, false) => {
+        match (binary_operation, is_signed) {
+            (BrilligBinaryOp::Add, false) => {
                 let condition =
                     SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that lhs <= result
@@ -1269,7 +1457,7 @@ impl<'block> BrilligBlock<'block> {
                     left,
                     result,
                     condition,
-                    BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals),
+                    BrilligBinaryOp::LessThanEquals,
                 );
                 self.brillig_context.constrain_instruction(
                     condition,
@@ -1277,7 +1465,7 @@ impl<'block> BrilligBlock<'block> {
                 );
                 self.brillig_context.deallocate_single_addr(condition);
             }
-            (BinaryIntOp::Sub, false) => {
+            (BrilligBinaryOp::Sub, false) => {
                 let condition =
                     SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that rhs <= lhs
@@ -1285,7 +1473,7 @@ impl<'block> BrilligBlock<'block> {
                     right,
                     left,
                     condition,
-                    BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals),
+                    BrilligBinaryOp::LessThanEquals,
                 );
                 self.brillig_context.constrain_instruction(
                     condition,
@@ -1293,19 +1481,20 @@ impl<'block> BrilligBlock<'block> {
                 );
                 self.brillig_context.deallocate_single_addr(condition);
             }
-            (BinaryIntOp::Mul, false) => {
+            (BrilligBinaryOp::Mul, false) => {
                 // Multiplication overflow is only possible for bit sizes > 1
                 if bit_size > 1 {
                     let is_right_zero =
                         SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
-                    let zero = self.brillig_context.make_constant(0_usize.into(), bit_size);
+                    let zero =
+                        self.brillig_context.make_constant_instruction(0_usize.into(), bit_size);
                     self.brillig_context.binary_instruction(
                         zero,
                         right,
                         is_right_zero,
-                        BrilligBinaryOp::Integer(BinaryIntOp::Equals),
+                        BrilligBinaryOp::Equals,
                     );
-                    self.brillig_context.if_not_instruction(is_right_zero.address, |ctx| {
+                    self.brillig_context.codegen_if_not(is_right_zero.address, |ctx| {
                         let condition = SingleAddrVariable::new(ctx.allocate_register(), 1);
                         let division = SingleAddrVariable::new(ctx.allocate_register(), bit_size);
                         // Check that result / rhs == lhs
@@ -1313,14 +1502,9 @@ impl<'block> BrilligBlock<'block> {
                             result,
                             right,
                             division,
-                            BrilligBinaryOp::Integer(BinaryIntOp::UnsignedDiv),
-                        );
-                        ctx.binary_instruction(
-                            division,
-                            left,
-                            condition,
-                            BrilligBinaryOp::Integer(BinaryIntOp::Equals),
+                            BrilligBinaryOp::UnsignedDiv,
                         );
+                        ctx.binary_instruction(division, left, condition, BrilligBinaryOp::Equals);
                         ctx.constrain_instruction(
                             condition,
                             Some("attempt to multiply with overflow".to_string()),
@@ -1372,17 +1556,21 @@ impl<'block> BrilligBlock<'block> {
                     // Initialize the variable
                     let pointer = match new_variable {
                         BrilligVariable::BrilligArray(brillig_array) => {
+                            self.brillig_context.codegen_allocate_fixed_length_array(
+                                brillig_array.pointer,
+                                array.len(),
+                            );
                             self.brillig_context
-                                .allocate_fixed_length_array(brillig_array.pointer, array.len());
-                            self.brillig_context.usize_const(brillig_array.rc, 1_usize.into());
+                                .usize_const_instruction(brillig_array.rc, 1_usize.into());
 
                             brillig_array.pointer
                         }
                         BrilligVariable::BrilligVector(vector) => {
-                            self.brillig_context.usize_const(vector.size, array.len().into());
                             self.brillig_context
-                                .allocate_array_instruction(vector.pointer, vector.size);
-                            self.brillig_context.usize_const(vector.rc, 1_usize.into());
+                                .usize_const_instruction(vector.size, array.len().into());
+                            self.brillig_context
+                                .codegen_allocate_array(vector.pointer, vector.size);
+                            self.brillig_context.usize_const_instruction(vector.rc, 1_usize.into());
 
                             vector.pointer
                         }
@@ -1395,16 +1583,16 @@ impl<'block> BrilligBlock<'block> {
 
                     // Allocate a register for the iterator
                     let iterator_register =
-                        self.brillig_context.make_usize_constant(0_usize.into());
+                        self.brillig_context.make_usize_constant_instruction(0_usize.into());
 
                     for element_id in array.iter() {
                         let element_variable = self.convert_ssa_value(*element_id, dfg);
                         // Store the item in memory
                         self.store_variable_in_array(pointer, iterator_register, element_variable);
                         // Increment the iterator
-                        self.brillig_context.usize_op_in_place(
+                        self.brillig_context.codegen_usize_op_in_place(
                             iterator_register.address,
-                            BinaryIntOp::Add,
+                            BrilligBinaryOp::Add,
                             1,
                         );
                     }
@@ -1466,8 +1654,8 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 let array = variable.extract_array();
-                self.brillig_context.allocate_fixed_length_array(array.pointer, array.size);
-                self.brillig_context.usize_const(array.rc, 1_usize.into());
+                self.brillig_context.codegen_allocate_fixed_length_array(array.pointer, array.size);
+                self.brillig_context.usize_const_instruction(array.rc, 1_usize.into());
 
                 variable
             }
@@ -1483,8 +1671,8 @@ impl<'block> BrilligBlock<'block> {
                 // Set the pointer to the current stack frame
                 // The stack pointer will then be updated by the caller of this method
                 // once the external call is resolved and the array size is known
-                self.brillig_context.set_array_pointer(vector.pointer);
-                self.brillig_context.usize_const(vector.rc, 1_usize.into());
+                self.brillig_context.load_free_memory_pointer_instruction(vector.pointer);
+                self.brillig_context.usize_const_instruction(vector.rc, 1_usize.into());
 
                 variable
             }
@@ -1508,13 +1696,14 @@ impl<'block> BrilligBlock<'block> {
 
         match array_variable {
             BrilligVariable::BrilligArray(BrilligArray { size, .. }) => {
-                self.brillig_context.usize_const(result_register, (size / element_size).into());
+                self.brillig_context
+                    .usize_const_instruction(result_register, (size / element_size).into());
             }
             BrilligVariable::BrilligVector(BrilligVector { size, .. }) => {
-                self.brillig_context.usize_op(
+                self.brillig_context.codegen_usize_op(
                     size,
                     result_register,
-                    BinaryIntOp::UnsignedDiv,
+                    BrilligBinaryOp::UnsignedDiv,
                     element_size,
                 );
             }
@@ -1551,67 +1740,3 @@ pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type
         }
     }
 }
-
-/// Convert an SSA binary operation into:
-/// - Brillig Binary Integer Op, if it is a integer type
-/// - Brillig Binary Field Op, if it is a field type
-pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op(
-    ssa_op: BinaryOp,
-    typ: &Type,
-) -> (BrilligBinaryOp, bool) {
-    // First get the bit size and whether its a signed integer, if it is a numeric type
-    // if it is not,then we return None, indicating that
-    // it is a Field.
-    let bit_size_signedness = match typ {
-          Type::Numeric(numeric_type) => match numeric_type {
-              NumericType::Signed { bit_size } => Some((bit_size, true)),
-              NumericType::Unsigned { bit_size } => Some((bit_size, false)),
-              NumericType::NativeField => None,
-          },
-          _ => unreachable!("only numeric types are allowed in binary operations. References are handled separately"),
-      };
-
-    fn binary_op_to_field_op(op: BinaryOp) -> BrilligBinaryOp {
-        match op {
-            BinaryOp::Add => BrilligBinaryOp::Field(BinaryFieldOp::Add),
-            BinaryOp::Sub => BrilligBinaryOp::Field(BinaryFieldOp::Sub),
-            BinaryOp::Mul => BrilligBinaryOp::Field(BinaryFieldOp::Mul),
-            BinaryOp::Div => BrilligBinaryOp::Field(BinaryFieldOp::Div),
-            BinaryOp::Eq => BrilligBinaryOp::Field(BinaryFieldOp::Equals),
-            _ => unreachable!(
-                "Field type cannot be used with {op}. This should have been caught by the frontend"
-            ),
-        }
-    }
-
-    fn binary_op_to_int_op(op: BinaryOp, is_signed: bool) -> BrilligBinaryOp {
-        let operation = match op {
-            BinaryOp::Add => BinaryIntOp::Add,
-            BinaryOp::Sub => BinaryIntOp::Sub,
-            BinaryOp::Mul => BinaryIntOp::Mul,
-            BinaryOp::Div => {
-                if is_signed {
-                    BinaryIntOp::SignedDiv
-                } else {
-                    BinaryIntOp::UnsignedDiv
-                }
-            }
-            BinaryOp::Mod => return BrilligBinaryOp::Modulo { is_signed_integer: is_signed },
-            BinaryOp::Eq => BinaryIntOp::Equals,
-            BinaryOp::Lt => BinaryIntOp::LessThan,
-            BinaryOp::And => BinaryIntOp::And,
-            BinaryOp::Or => BinaryIntOp::Or,
-            BinaryOp::Xor => BinaryIntOp::Xor,
-            BinaryOp::Shl => BinaryIntOp::Shl,
-            BinaryOp::Shr => BinaryIntOp::Shr,
-        };
-
-        BrilligBinaryOp::Integer(operation)
-    }
-
-    // If bit size is available then it is a binary integer operation
-    match bit_size_signedness {
-        Some((_, is_signed)) => (binary_op_to_int_op(ssa_op, is_signed), is_signed),
-        None => (binary_op_to_field_op(ssa_op), false),
-    }
-}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
index 93c4b1a5042..26b21e918ff 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
@@ -65,7 +65,7 @@ pub(crate) fn directive_quotient(bit_size: u32) -> GeneratedBrillig {
             },
             //q = a/b is set into register (2)
             BrilligOpcode::BinaryIntOp {
-                op: BinaryIntOp::UnsignedDiv,
+                op: BinaryIntOp::Div,
                 lhs: MemoryAddress::from(0),
                 rhs: MemoryAddress::from(1),
                 destination: MemoryAddress::from(2),
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 969f95cff20..98dd17ce080 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -1,7 +1,6 @@
-use acvm::brillig_vm::brillig::BinaryIntOp;
-
-use crate::brillig::brillig_ir::brillig_variable::{
-    BrilligVariable, BrilligVector, SingleAddrVariable,
+use crate::brillig::brillig_ir::{
+    brillig_variable::{BrilligVariable, BrilligVector, SingleAddrVariable},
+    BrilligBinaryOp,
 };
 
 use super::brillig_block::BrilligBlock;
@@ -14,30 +13,30 @@ impl<'block> BrilligBlock<'block> {
         variables_to_insert: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector incrementing the size by variables_to_insert.len()
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.size,
             target_vector.size,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             variables_to_insert.len(),
         );
-        self.brillig_context.allocate_array_instruction(target_vector.pointer, target_vector.size);
+        self.brillig_context.codegen_allocate_array(target_vector.pointer, target_vector.size);
         // We initialize the RC of the target vector to 1
-        self.brillig_context.usize_const(target_vector.rc, 1_usize.into());
+        self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Now we copy the source vector into the target vector
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_vector.pointer,
             target_vector.pointer,
             SingleAddrVariable::new_usize(source_vector.size),
         );
 
         for (index, variable) in variables_to_insert.iter().enumerate() {
-            let target_index = self.brillig_context.make_usize_constant(index.into());
-            self.brillig_context.memory_op(
+            let target_index = self.brillig_context.make_usize_constant_instruction(index.into());
+            self.brillig_context.memory_op_instruction(
                 target_index.address,
                 source_vector.size,
                 target_index.address,
-                BinaryIntOp::Add,
+                BrilligBinaryOp::Add,
             );
             self.store_variable_in_array(target_vector.pointer, target_index, *variable);
             self.brillig_context.deallocate_single_addr(target_index);
@@ -51,27 +50,27 @@ impl<'block> BrilligBlock<'block> {
         variables_to_insert: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector incrementing the size by variables_to_insert.len()
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.size,
             target_vector.size,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             variables_to_insert.len(),
         );
-        self.brillig_context.allocate_array_instruction(target_vector.pointer, target_vector.size);
+        self.brillig_context.codegen_allocate_array(target_vector.pointer, target_vector.size);
         // We initialize the RC of the target vector to 1
-        self.brillig_context.usize_const(target_vector.rc, 1_usize.into());
+        self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Now we offset the target pointer by variables_to_insert.len()
         let destination_copy_pointer = self.brillig_context.allocate_register();
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             target_vector.pointer,
             destination_copy_pointer,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             variables_to_insert.len(),
         );
 
         // Now we copy the source vector into the target vector starting at index variables_to_insert.len()
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_vector.pointer,
             destination_copy_pointer,
             SingleAddrVariable::new_usize(source_vector.size),
@@ -79,7 +78,7 @@ impl<'block> BrilligBlock<'block> {
 
         // Then we write the items to insert at the start
         for (index, variable) in variables_to_insert.iter().enumerate() {
-            let target_index = self.brillig_context.make_usize_constant(index.into());
+            let target_index = self.brillig_context.make_usize_constant_instruction(index.into());
             self.store_variable_in_array(target_vector.pointer, target_index, *variable);
             self.brillig_context.deallocate_single_addr(target_index);
         }
@@ -94,34 +93,34 @@ impl<'block> BrilligBlock<'block> {
         removed_items: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector decrementing the size by removed_items.len()
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.size,
             target_vector.size,
-            BinaryIntOp::Sub,
+            BrilligBinaryOp::Sub,
             removed_items.len(),
         );
-        self.brillig_context.allocate_array_instruction(target_vector.pointer, target_vector.size);
+        self.brillig_context.codegen_allocate_array(target_vector.pointer, target_vector.size);
         // We initialize the RC of the target vector to 1
-        self.brillig_context.usize_const(target_vector.rc, 1_usize.into());
+        self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Now we offset the source pointer by removed_items.len()
         let source_copy_pointer = self.brillig_context.allocate_register();
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.pointer,
             source_copy_pointer,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             removed_items.len(),
         );
 
         // Now we copy the source vector starting at index removed_items.len() into the target vector
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_copy_pointer,
             target_vector.pointer,
             SingleAddrVariable::new_usize(target_vector.size),
         );
 
         for (index, variable) in removed_items.iter().enumerate() {
-            let target_index = self.brillig_context.make_usize_constant(index.into());
+            let target_index = self.brillig_context.make_usize_constant_instruction(index.into());
             self.retrieve_variable_from_array(source_vector.pointer, target_index, *variable);
             self.brillig_context.deallocate_single_addr(target_index);
         }
@@ -136,30 +135,30 @@ impl<'block> BrilligBlock<'block> {
         removed_items: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector decrementing the size by removed_items.len()
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.size,
             target_vector.size,
-            BinaryIntOp::Sub,
+            BrilligBinaryOp::Sub,
             removed_items.len(),
         );
-        self.brillig_context.allocate_array_instruction(target_vector.pointer, target_vector.size);
+        self.brillig_context.codegen_allocate_array(target_vector.pointer, target_vector.size);
         // We initialize the RC of the target vector to 1
-        self.brillig_context.usize_const(target_vector.rc, 1_usize.into());
+        self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Now we copy all elements except the last items into the target vector
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_vector.pointer,
             target_vector.pointer,
             SingleAddrVariable::new_usize(target_vector.size),
         );
 
         for (index, variable) in removed_items.iter().enumerate() {
-            let target_index = self.brillig_context.make_usize_constant(index.into());
-            self.brillig_context.memory_op(
+            let target_index = self.brillig_context.make_usize_constant_instruction(index.into());
+            self.brillig_context.memory_op_instruction(
                 target_index.address,
                 target_vector.size,
                 target_index.address,
-                BinaryIntOp::Add,
+                BrilligBinaryOp::Add,
             );
             self.retrieve_variable_from_array(source_vector.pointer, target_index, *variable);
             self.brillig_context.deallocate_single_addr(target_index);
@@ -174,18 +173,18 @@ impl<'block> BrilligBlock<'block> {
         items: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector incrementing the size by items.len()
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.size,
             target_vector.size,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             items.len(),
         );
-        self.brillig_context.allocate_array_instruction(target_vector.pointer, target_vector.size);
+        self.brillig_context.codegen_allocate_array(target_vector.pointer, target_vector.size);
         // We initialize the RC of the target vector to 1
-        self.brillig_context.usize_const(target_vector.rc, 1_usize.into());
+        self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Copy the elements to the left of the index
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_vector.pointer,
             target_vector.pointer,
             index,
@@ -193,38 +192,38 @@ impl<'block> BrilligBlock<'block> {
 
         // Compute the source pointer just at the index
         let source_pointer_at_index = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             source_vector.pointer,
             index.address,
             source_pointer_at_index,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
         );
 
         // Compute the target pointer after the inserted elements
         let target_pointer_after_index = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             target_vector.pointer,
             index.address,
             target_pointer_after_index,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
         );
-        self.brillig_context.usize_op_in_place(
+        self.brillig_context.codegen_usize_op_in_place(
             target_pointer_after_index,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             items.len(),
         );
 
         // Compute the number of elements to the right of the index
         let item_count = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             source_vector.size,
             index.address,
             item_count,
-            BinaryIntOp::Sub,
+            BrilligBinaryOp::Sub,
         );
 
         // Copy the elements to the right of the index
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_pointer_at_index,
             target_pointer_after_index,
             SingleAddrVariable::new_usize(item_count),
@@ -232,12 +231,13 @@ impl<'block> BrilligBlock<'block> {
 
         // Write the items to insert starting at the index
         for (subitem_index, variable) in items.iter().enumerate() {
-            let target_index = self.brillig_context.make_usize_constant(subitem_index.into());
-            self.brillig_context.memory_op(
+            let target_index =
+                self.brillig_context.make_usize_constant_instruction(subitem_index.into());
+            self.brillig_context.memory_op_instruction(
                 target_index.address,
                 index.address,
                 target_index.address,
-                BinaryIntOp::Add,
+                BrilligBinaryOp::Add,
             );
             self.store_variable_in_array(target_vector.pointer, target_index, *variable);
             self.brillig_context.deallocate_single_addr(target_index);
@@ -256,18 +256,18 @@ impl<'block> BrilligBlock<'block> {
         removed_items: &[BrilligVariable],
     ) {
         // First we need to allocate the target vector decrementing the size by removed_items.len()
-        self.brillig_context.usize_op(
+        self.brillig_context.codegen_usize_op(
             source_vector.size,
             target_vector.size,
-            BinaryIntOp::Sub,
+            BrilligBinaryOp::Sub,
             removed_items.len(),
         );
-        self.brillig_context.allocate_array_instruction(target_vector.pointer, target_vector.size);
+        self.brillig_context.codegen_allocate_array(target_vector.pointer, target_vector.size);
         // We initialize the RC of the target vector to 1
-        self.brillig_context.usize_const(target_vector.rc, 1_usize.into());
+        self.brillig_context.usize_const_instruction(target_vector.rc, 1_usize.into());
 
         // Copy the elements to the left of the index
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_vector.pointer,
             target_vector.pointer,
             index,
@@ -275,39 +275,43 @@ impl<'block> BrilligBlock<'block> {
 
         // Compute the source pointer after the removed items
         let source_pointer_after_index = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             source_vector.pointer,
             index.address,
             source_pointer_after_index,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
         );
-        self.brillig_context.usize_op_in_place(
+        self.brillig_context.codegen_usize_op_in_place(
             source_pointer_after_index,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
             removed_items.len(),
         );
 
         // Compute the target pointer at the index
         let target_pointer_at_index = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             target_vector.pointer,
             index.address,
             target_pointer_at_index,
-            BinaryIntOp::Add,
+            BrilligBinaryOp::Add,
         );
 
         // Compute the number of elements to the right of the index
         let item_count = self.brillig_context.allocate_register();
-        self.brillig_context.memory_op(
+        self.brillig_context.memory_op_instruction(
             source_vector.size,
             index.address,
             item_count,
-            BinaryIntOp::Sub,
+            BrilligBinaryOp::Sub,
+        );
+        self.brillig_context.codegen_usize_op_in_place(
+            item_count,
+            BrilligBinaryOp::Sub,
+            removed_items.len(),
         );
-        self.brillig_context.usize_op_in_place(item_count, BinaryIntOp::Sub, removed_items.len());
 
         // Copy the elements to the right of the index
-        self.brillig_context.copy_array_instruction(
+        self.brillig_context.codegen_copy_array(
             source_pointer_after_index,
             target_pointer_at_index,
             SingleAddrVariable::new_usize(item_count),
@@ -315,12 +319,13 @@ impl<'block> BrilligBlock<'block> {
 
         // Get the removed items
         for (subitem_index, variable) in removed_items.iter().enumerate() {
-            let target_index = self.brillig_context.make_usize_constant(subitem_index.into());
-            self.brillig_context.memory_op(
+            let target_index =
+                self.brillig_context.make_usize_constant_instruction(subitem_index.into());
+            self.brillig_context.memory_op_instruction(
                 target_index.address,
                 index.address,
                 target_index.address,
-                BinaryIntOp::Add,
+                BrilligBinaryOp::Add,
             );
             self.retrieve_variable_from_array(source_vector.pointer, target_index, *variable);
             self.brillig_context.deallocate_single_addr(target_index);
@@ -338,7 +343,7 @@ impl<'block> BrilligBlock<'block> {
         match source_variable {
             BrilligVariable::BrilligVector(source_vector) => source_vector,
             BrilligVariable::BrilligArray(source_array) => {
-                self.brillig_context.array_to_vector(&source_array)
+                self.brillig_context.array_to_vector_instruction(&source_array)
             }
             _ => unreachable!("ICE: unsupported slice push back source {:?}", source_variable),
         }
@@ -425,7 +430,7 @@ mod tests {
             };
 
             // Cast the source array to a vector
-            let source_vector = context.array_to_vector(&array_variable);
+            let source_vector = context.array_to_vector_instruction(&array_variable);
 
             // Allocate the results
             let target_vector = BrilligVector {
@@ -450,7 +455,7 @@ mod tests {
                 );
             }
 
-            context.return_instruction(&[target_vector.pointer, target_vector.rc]);
+            context.codegen_return(&[target_vector.pointer, target_vector.rc]);
 
             let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
             let (vm, return_data_offset, return_data_size) =
@@ -518,7 +523,7 @@ mod tests {
             };
 
             // Cast the source array to a vector
-            let source_vector = context.array_to_vector(&array_variable);
+            let source_vector = context.array_to_vector_instruction(&array_variable);
 
             // Allocate the results
             let target_vector = BrilligVector {
@@ -547,7 +552,7 @@ mod tests {
                 );
             }
 
-            context.return_instruction(&[
+            context.codegen_return(&[
                 target_vector.pointer,
                 target_vector.rc,
                 removed_item.address,
@@ -620,7 +625,7 @@ mod tests {
             );
 
             // Cast the source array to a vector
-            let source_vector = context.array_to_vector(&array_variable);
+            let source_vector = context.array_to_vector_instruction(&array_variable);
 
             // Allocate the results
             let target_vector = BrilligVector {
@@ -638,7 +643,7 @@ mod tests {
                 &[BrilligVariable::SingleAddr(item_to_insert)],
             );
 
-            context.return_instruction(&[target_vector.pointer, target_vector.rc]);
+            context.codegen_return(&[target_vector.pointer, target_vector.rc]);
             let calldata = array.into_iter().chain(vec![item]).chain(vec![index]).collect();
 
             let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
@@ -741,7 +746,7 @@ mod tests {
             );
 
             // Cast the source array to a vector
-            let source_vector = context.array_to_vector(&array_variable);
+            let source_vector = context.array_to_vector_instruction(&array_variable);
 
             // Allocate the results
             let target_vector = BrilligVector {
@@ -763,7 +768,7 @@ mod tests {
                 &[BrilligVariable::SingleAddr(removed_item)],
             );
 
-            context.return_instruction(&[
+            context.codegen_return(&[
                 target_vector.pointer,
                 target_vector.size,
                 removed_item.address,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 2a96965171b..9138f57083a 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -4,28 +4,30 @@
 //! `brillig_gen` is therefore the module which combines both
 //! ssa types and types in this module.
 //! A similar paradigm can be seen with the `acir_ir` module.
+//!
+//! The brillig ir provides instructions and codegens.
+//! The instructions are low level operations that are printed via debug_show.
+//! They should emit few opcodes. Codegens on the other hand orchestrate the
+//! low level instructions to emit the desired high level operation.
 pub(crate) mod artifact;
 pub(crate) mod brillig_variable;
 pub(crate) mod debug_show;
 pub(crate) mod registers;
 
+mod codegen_binary;
+mod codegen_calls;
+mod codegen_control_flow;
+mod codegen_intrinsic;
+mod codegen_memory;
+mod codegen_stack;
 mod entry_point;
+mod instructions;
 
-use crate::ssa::ir::dfg::CallStack;
+pub(crate) use instructions::BrilligBinaryOp;
 
-use self::{
-    artifact::{BrilligArtifact, UnresolvedJumpLocation},
-    brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
-    registers::BrilligRegistersContext,
-};
-use acvm::{
-    acir::brillig::{
-        BinaryFieldOp, BinaryIntOp, BlackBoxOp, MemoryAddress, Opcode as BrilligOpcode, Value,
-        ValueOrArray,
-    },
-    brillig_vm::brillig::HeapValueType,
-    FieldElement,
-};
+use self::{artifact::BrilligArtifact, registers::BrilligRegistersContext};
+use crate::ssa::ir::dfg::CallStack;
+use acvm::acir::brillig::{MemoryAddress, Opcode as BrilligOpcode};
 use debug_show::DebugShow;
 
 /// The Brillig VM does not apply a limit to the memory address space,
@@ -35,8 +37,8 @@ pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
 
 // Registers reserved in runtime for special purposes.
 pub(crate) enum ReservedRegisters {
-    /// This register stores the stack pointer. Allocations must be done after this pointer.
-    StackPointer = 0,
+    /// This register stores the free memory pointer. Allocations must be done after this pointer.
+    FreeMemoryPointer = 0,
     /// This register stores the previous stack pointer. The registers of the caller are stored here.
     PreviousStackPointer = 1,
 }
@@ -53,9 +55,9 @@ impl ReservedRegisters {
         Self::NUM_RESERVED_REGISTERS
     }
 
-    /// Returns the stack pointer register. This will get used to allocate memory in runtime.
-    pub(crate) fn stack_pointer() -> MemoryAddress {
-        MemoryAddress::from(ReservedRegisters::StackPointer as usize)
+    /// Returns the free memory pointer register. This will get used to allocate memory in runtime.
+    pub(crate) fn free_memory_pointer() -> MemoryAddress {
+        MemoryAddress::from(ReservedRegisters::FreeMemoryPointer as usize)
     }
 
     /// Returns the previous stack pointer register. This will be used to restore the registers after a fn call.
@@ -99,12 +101,8 @@ impl BrilligContext {
         }
     }
 
-    pub(crate) fn set_allocated_registers(&mut self, allocated_registers: Vec<MemoryAddress>) {
-        self.registers = BrilligRegistersContext::from_preallocated_registers(allocated_registers);
-    }
-
     /// Adds a brillig instruction to the brillig byte code
-    pub(crate) fn push_opcode(&mut self, opcode: BrilligOpcode) {
+    fn push_opcode(&mut self, opcode: BrilligOpcode) {
         self.obj.push_opcode(opcode);
     }
 
@@ -113,1054 +111,24 @@ impl BrilligContext {
         self.obj
     }
 
-    /// Allocates an array of size `size` and stores the pointer to the array
-    /// in `pointer_register`
-    pub(crate) fn allocate_fixed_length_array(
-        &mut self,
-        pointer_register: MemoryAddress,
-        size: usize,
-    ) {
-        // debug_show handled by allocate_array_instruction
-        let size_register = self.make_usize_constant(size.into());
-        self.allocate_array_instruction(pointer_register, size_register.address);
-        self.deallocate_single_addr(size_register);
-    }
-
-    /// Allocates an array of size contained in size_register and stores the
-    /// pointer to the array in `pointer_register`
-    pub(crate) fn allocate_array_instruction(
-        &mut self,
-        pointer_register: MemoryAddress,
-        size_register: MemoryAddress,
-    ) {
-        self.debug_show.allocate_array_instruction(pointer_register, size_register);
-        self.set_array_pointer(pointer_register);
-        self.update_stack_pointer(size_register);
-    }
-
-    pub(crate) fn set_array_pointer(&mut self, pointer_register: MemoryAddress) {
-        self.debug_show.mov_instruction(pointer_register, ReservedRegisters::stack_pointer());
-        self.push_opcode(BrilligOpcode::Mov {
-            destination: pointer_register,
-            source: ReservedRegisters::stack_pointer(),
-        });
-    }
-
-    pub(crate) fn update_stack_pointer(&mut self, size_register: MemoryAddress) {
-        self.memory_op(
-            ReservedRegisters::stack_pointer(),
-            size_register,
-            ReservedRegisters::stack_pointer(),
-            BinaryIntOp::Add,
-        );
-    }
-
-    /// Allocates a variable in memory and stores the
-    /// pointer to the array in `pointer_register`
-    fn allocate_variable_reference_instruction(
-        &mut self,
-        pointer_register: MemoryAddress,
-        size: usize,
-    ) {
-        self.debug_show.allocate_instruction(pointer_register);
-        // A variable can be stored in up to three values, so we reserve three values for that.
-        let size_register = self.make_usize_constant(size.into());
-        self.push_opcode(BrilligOpcode::Mov {
-            destination: pointer_register,
-            source: ReservedRegisters::stack_pointer(),
-        });
-        self.memory_op(
-            ReservedRegisters::stack_pointer(),
-            size_register.address,
-            ReservedRegisters::stack_pointer(),
-            BinaryIntOp::Add,
-        );
-        self.deallocate_single_addr(size_register);
-    }
-
-    pub(crate) fn allocate_single_addr_reference_instruction(
-        &mut self,
-        pointer_register: MemoryAddress,
-    ) {
-        self.allocate_variable_reference_instruction(pointer_register, 1);
-    }
-
-    pub(crate) fn allocate_array_reference_instruction(&mut self, pointer_register: MemoryAddress) {
-        self.allocate_variable_reference_instruction(
-            pointer_register,
-            BrilligArray::registers_count(),
-        );
-    }
-
-    pub(crate) fn allocate_vector_reference_instruction(
-        &mut self,
-        pointer_register: MemoryAddress,
-    ) {
-        self.allocate_variable_reference_instruction(
-            pointer_register,
-            BrilligVector::registers_count(),
-        );
-    }
-
-    /// Gets the value in the array at index `index` and stores it in `result`
-    pub(crate) fn array_get(
-        &mut self,
-        array_ptr: MemoryAddress,
-        index: SingleAddrVariable,
-        result: MemoryAddress,
-    ) {
-        assert!(index.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
-        self.debug_show.array_get(array_ptr, index.address, result);
-        // Computes array_ptr + index, ie array[index]
-        let index_of_element_in_memory = self.allocate_register();
-        self.memory_op(array_ptr, index.address, index_of_element_in_memory, BinaryIntOp::Add);
-        self.load_instruction(result, index_of_element_in_memory);
-        // Free up temporary register
-        self.deallocate_register(index_of_element_in_memory);
-    }
-
-    /// Sets the item in the array at index `index` to `value`
-    pub(crate) fn array_set(
-        &mut self,
-        array_ptr: MemoryAddress,
-        index: SingleAddrVariable,
-        value: MemoryAddress,
-    ) {
-        assert!(index.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
-        self.debug_show.array_set(array_ptr, index.address, value);
-        // Computes array_ptr + index, ie array[index]
-        let index_of_element_in_memory = self.allocate_register();
-        self.binary_instruction(
-            SingleAddrVariable::new_usize(array_ptr),
-            index,
-            SingleAddrVariable::new_usize(index_of_element_in_memory),
-            BrilligBinaryOp::Integer(BinaryIntOp::Add),
-        );
-
-        self.store_instruction(index_of_element_in_memory, value);
-        // Free up temporary register
-        self.deallocate_register(index_of_element_in_memory);
-    }
-
-    /// Copies the values of an array pointed by source with length stored in `num_elements_register`
-    /// Into the array pointed by destination
-    pub(crate) fn copy_array_instruction(
-        &mut self,
-        source_pointer: MemoryAddress,
-        destination_pointer: MemoryAddress,
-        num_elements_variable: SingleAddrVariable,
-    ) {
-        assert!(num_elements_variable.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
-        self.debug_show.copy_array_instruction(
-            source_pointer,
-            destination_pointer,
-            num_elements_variable.address,
-        );
-
-        let value_register = self.allocate_register();
-
-        self.loop_instruction(num_elements_variable.address, |ctx, iterator| {
-            ctx.array_get(source_pointer, iterator, value_register);
-            ctx.array_set(destination_pointer, iterator, value_register);
-        });
-
-        self.deallocate_register(value_register);
-    }
-
-    /// This instruction will issue a loop that will iterate iteration_count times
-    /// The body of the loop should be issued by the caller in the on_iteration closure.
-    pub(crate) fn loop_instruction<F>(&mut self, iteration_count: MemoryAddress, on_iteration: F)
-    where
-        F: FnOnce(&mut BrilligContext, SingleAddrVariable),
-    {
-        let iterator_register = self.make_usize_constant(0_u128.into());
-
-        let (loop_section, loop_label) = self.reserve_next_section_label();
-        self.enter_section(loop_section);
-
-        // Loop body
-
-        // Check if iterator < iteration_count
-        let iterator_less_than_iterations =
-            SingleAddrVariable { address: self.allocate_register(), bit_size: 1 };
-
-        self.memory_op(
-            iterator_register.address,
-            iteration_count,
-            iterator_less_than_iterations.address,
-            BinaryIntOp::LessThan,
-        );
-
-        let (exit_loop_section, exit_loop_label) = self.reserve_next_section_label();
-
-        self.not_instruction(iterator_less_than_iterations, iterator_less_than_iterations);
-
-        self.jump_if_instruction(iterator_less_than_iterations.address, exit_loop_label);
-
-        // Call the on iteration function
-        on_iteration(self, iterator_register);
-
-        // Increment the iterator register
-        self.usize_op_in_place(iterator_register.address, BinaryIntOp::Add, 1);
-
-        self.jump_instruction(loop_label);
-
-        // Exit the loop
-        self.enter_section(exit_loop_section);
-
-        // Deallocate our temporary registers
-        self.deallocate_single_addr(iterator_less_than_iterations);
-        self.deallocate_single_addr(iterator_register);
-    }
-
-    /// This instruction will issue an if-then branch that will check if the condition is true
-    /// and if so, perform the instructions given in `f(self, true)` and otherwise perform the
-    /// instructions given in `f(self, false)`. A boolean is passed instead of two separate
-    /// functions to allow the given function to mutably alias its environment.
-    pub(crate) fn branch_instruction(
-        &mut self,
-        condition: MemoryAddress,
-        mut f: impl FnMut(&mut BrilligContext, bool),
-    ) {
-        // Reserve 3 sections
-        let (then_section, then_label) = self.reserve_next_section_label();
-        let (otherwise_section, otherwise_label) = self.reserve_next_section_label();
-        let (end_section, end_label) = self.reserve_next_section_label();
-
-        self.jump_if_instruction(condition, then_label.clone());
-        self.jump_instruction(otherwise_label.clone());
-
-        self.enter_section(then_section);
-        f(self, true);
-        self.jump_instruction(end_label.clone());
-
-        self.enter_section(otherwise_section);
-        f(self, false);
-        self.jump_instruction(end_label.clone());
-
-        self.enter_section(end_section);
-    }
-
-    /// This instruction issues a branch that jumps over the code generated by the given function if the condition is truthy
-    pub(crate) fn if_not_instruction(
-        &mut self,
-        condition: MemoryAddress,
-        f: impl FnOnce(&mut BrilligContext),
-    ) {
-        let (end_section, end_label) = self.reserve_next_section_label();
-
-        self.jump_if_instruction(condition, end_label.clone());
-
-        f(self);
-
-        self.enter_section(end_section);
-    }
-
-    /// Adds a label to the next opcode
-    pub(crate) fn enter_context<T: ToString>(&mut self, label: T) {
-        self.debug_show.enter_context(label.to_string());
-        self.context_label = label.to_string();
-        self.section_label = 0;
-        // Add a context label to the next opcode
-        self.obj.add_label_at_position(label.to_string(), self.obj.index_of_next_opcode());
-        // Add a section label to the next opcode
-        self.obj
-            .add_label_at_position(self.current_section_label(), self.obj.index_of_next_opcode());
-    }
-
-    /// Enter the given section
-    fn enter_section(&mut self, section: usize) {
-        self.section_label = section;
-        self.obj
-            .add_label_at_position(self.current_section_label(), self.obj.index_of_next_opcode());
-    }
-
-    /// Create, reserve, and return a new section label.
-    fn reserve_next_section_label(&mut self) -> (usize, String) {
-        let section = self.next_section;
-        self.next_section += 1;
-        (section, self.compute_section_label(section))
-    }
-
-    /// Internal function used to compute the section labels
-    fn compute_section_label(&self, section: usize) -> String {
-        format!("{}-{}", self.context_label, section)
-    }
-
-    /// Returns the current section label
-    fn current_section_label(&self) -> String {
-        self.compute_section_label(self.section_label)
-    }
-
-    /// Adds a unresolved `Jump` instruction to the bytecode.
-    pub(crate) fn jump_instruction<T: ToString>(&mut self, target_label: T) {
-        self.debug_show.jump_instruction(target_label.to_string());
-        self.add_unresolved_jump(BrilligOpcode::Jump { location: 0 }, target_label.to_string());
-    }
-
-    /// Adds a unresolved `JumpIf` instruction to the bytecode.
-    pub(crate) fn jump_if_instruction<T: ToString>(
-        &mut self,
-        condition: MemoryAddress,
-        target_label: T,
-    ) {
-        self.debug_show.jump_if_instruction(condition, target_label.to_string());
-        self.add_unresolved_jump(
-            BrilligOpcode::JumpIf { condition, location: 0 },
-            target_label.to_string(),
-        );
-    }
-
-    /// Adds a unresolved `Jump` instruction to the bytecode.
-    fn add_unresolved_jump(
-        &mut self,
-        jmp_instruction: BrilligOpcode,
-        destination: UnresolvedJumpLocation,
-    ) {
-        self.obj.add_unresolved_jump(jmp_instruction, destination);
-    }
-
-    /// Allocates an unused register.
-    pub(crate) fn allocate_register(&mut self) -> MemoryAddress {
-        self.registers.allocate_register()
-    }
-
-    /// Push a register to the deallocation list, ready for reuse.
-    pub(crate) fn deallocate_register(&mut self, register_index: MemoryAddress) {
-        self.registers.deallocate_register(register_index);
-    }
-
-    /// Deallocates the address where the single address variable is stored
-    pub(crate) fn deallocate_single_addr(&mut self, var: SingleAddrVariable) {
-        self.deallocate_register(var.address);
-    }
-}
-
-impl BrilligContext {
-    /// Emits brillig bytecode to jump to a trap condition if `condition`
-    /// is false.
-    pub(crate) fn constrain_instruction(
-        &mut self,
-        condition: SingleAddrVariable,
-        assert_message: Option<String>,
-    ) {
-        assert!(condition.bit_size == 1);
-        self.debug_show.constrain_instruction(condition.address);
-        let (next_section, next_label) = self.reserve_next_section_label();
-        self.add_unresolved_jump(
-            BrilligOpcode::JumpIf { condition: condition.address, location: 0 },
-            next_label,
-        );
-        self.push_opcode(BrilligOpcode::Trap);
-        if let Some(assert_message) = assert_message {
-            self.obj.add_assert_message_to_last_opcode(assert_message);
-        }
-        self.enter_section(next_section);
-    }
-
-    /// Processes a return instruction.
-    ///
-    /// For Brillig, the return is implicit, since there is no explicit return instruction.
-    /// The caller will take `N` values from the Register starting at register index 0.
-    /// `N` indicates the number of return values expected.
-    ///
-    /// Brillig does not have an explicit return instruction, so this
-    /// method will move all register values to the first `N` values in
-    /// the VM.
-    pub(crate) fn return_instruction(&mut self, return_registers: &[MemoryAddress]) {
-        self.debug_show.return_instruction(return_registers);
-        let mut sources = Vec::with_capacity(return_registers.len());
-        let mut destinations = Vec::with_capacity(return_registers.len());
-
-        for (destination_index, return_register) in return_registers.iter().enumerate() {
-            // In case we have fewer return registers than indices to write to, ensure we've allocated this register
-            let destination_register = ReservedRegisters::user_register_index(destination_index);
-            self.registers.ensure_register_is_allocated(destination_register);
-            sources.push(*return_register);
-            destinations.push(destination_register);
-        }
-        destinations
-            .iter()
-            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
-        self.mov_registers_to_registers_instruction(sources, destinations);
-        self.stop_instruction();
-    }
-
-    /// This function moves values from a set of registers to another set of registers.
-    /// It first moves all sources to new allocated registers to avoid overwriting.
-    pub(crate) fn mov_registers_to_registers_instruction(
-        &mut self,
-        sources: Vec<MemoryAddress>,
-        destinations: Vec<MemoryAddress>,
-    ) {
-        let new_sources: Vec<_> = sources
-            .iter()
-            .map(|source| {
-                let new_source = self.allocate_register();
-                self.mov_instruction(new_source, *source);
-                new_source
-            })
-            .collect();
-        for (new_source, destination) in new_sources.iter().zip(destinations.iter()) {
-            self.mov_instruction(*destination, *new_source);
-            self.deallocate_register(*new_source);
-        }
-    }
-
-    /// Emits a `mov` instruction.
-    ///
-    /// Copies the value at `source` into `destination`
-    pub(crate) fn mov_instruction(&mut self, destination: MemoryAddress, source: MemoryAddress) {
-        self.debug_show.mov_instruction(destination, source);
-        self.push_opcode(BrilligOpcode::Mov { destination, source });
-    }
-
-    /// Cast truncates the value to the given bit size and converts the type of the value in memory to that bit size.
-    pub(crate) fn cast_instruction(
-        &mut self,
-        destination: SingleAddrVariable,
-        source: SingleAddrVariable,
-    ) {
-        self.debug_show.cast_instruction(destination.address, source.address, destination.bit_size);
-        self.push_opcode(BrilligOpcode::Cast {
-            destination: destination.address,
-            source: source.address,
-            bit_size: destination.bit_size,
-        });
-    }
-
-    fn binary_result_bit_size(operation: BrilligBinaryOp, arguments_bit_size: u32) -> u32 {
-        match operation {
-            BrilligBinaryOp::Field(BinaryFieldOp::Equals)
-            | BrilligBinaryOp::Integer(BinaryIntOp::Equals)
-            | BrilligBinaryOp::Integer(BinaryIntOp::LessThan)
-            | BrilligBinaryOp::Integer(BinaryIntOp::LessThanEquals) => 1,
-            _ => arguments_bit_size,
-        }
-    }
-
-    /// Processes a binary instruction according `operation`.
-    ///
-    /// This method will compute lhs <operation> rhs
-    /// and store the result in the `result` register.
-    pub(crate) fn binary_instruction(
-        &mut self,
-        lhs: SingleAddrVariable,
-        rhs: SingleAddrVariable,
-        result: SingleAddrVariable,
-        operation: BrilligBinaryOp,
-    ) {
-        assert!(
-            lhs.bit_size == rhs.bit_size,
-            "Not equal bit size for lhs and rhs: lhs {}, rhs {}",
-            lhs.bit_size,
-            rhs.bit_size
-        );
-        let expected_result_bit_size =
-            BrilligContext::binary_result_bit_size(operation, lhs.bit_size);
-        assert!(
-            result.bit_size == expected_result_bit_size,
-            "Expected result bit size to be {}, got {} for operation {:?}",
-            expected_result_bit_size,
-            result.bit_size,
-            operation
-        );
-        self.debug_show.binary_instruction(lhs.address, rhs.address, result.address, operation);
-        match operation {
-            BrilligBinaryOp::Field(op) => {
-                let opcode = BrilligOpcode::BinaryFieldOp {
-                    op,
-                    destination: result.address,
-                    lhs: lhs.address,
-                    rhs: rhs.address,
-                };
-                self.push_opcode(opcode);
-            }
-            BrilligBinaryOp::Integer(op) => {
-                let opcode = BrilligOpcode::BinaryIntOp {
-                    op,
-                    destination: result.address,
-                    bit_size: lhs.bit_size,
-                    lhs: lhs.address,
-                    rhs: rhs.address,
-                };
-                self.push_opcode(opcode);
-            }
-            BrilligBinaryOp::Modulo { is_signed_integer } => {
-                self.modulo_instruction(result, lhs, rhs, is_signed_integer);
-            }
-        }
-    }
-
-    /// Stores the value of `constant` in the `result` register
-    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: Value) {
-        self.debug_show.const_instruction(result.address, constant);
-
-        self.push_opcode(BrilligOpcode::Const {
-            destination: result.address,
-            value: constant,
-            bit_size: result.bit_size,
-        });
-    }
-
-    pub(crate) fn usize_const(&mut self, result: MemoryAddress, constant: Value) {
-        self.const_instruction(SingleAddrVariable::new_usize(result), constant);
-    }
-
-    /// Processes a not instruction.
-    ///
-    /// Not is computed using a subtraction operation as there is no native not instruction
-    /// in Brillig.
-    pub(crate) fn not_instruction(
-        &mut self,
-        input: SingleAddrVariable,
-        result: SingleAddrVariable,
-    ) {
-        self.debug_show.not_instruction(input.address, input.bit_size, result.address);
-        // Compile !x as ((-1) - x)
-        let u_max = FieldElement::from(2_i128).pow(&FieldElement::from(input.bit_size as i128))
-            - FieldElement::one();
-        let max = self.make_constant(Value::from(u_max), input.bit_size);
-
-        let opcode = BrilligOpcode::BinaryIntOp {
-            destination: result.address,
-            op: BinaryIntOp::Sub,
-            bit_size: input.bit_size,
-            lhs: max.address,
-            rhs: input.address,
-        };
-        self.push_opcode(opcode);
-        self.deallocate_single_addr(max);
-    }
-
-    /// Processes a foreign call instruction.
-    ///
-    /// Note: the function being called is external and will
-    /// not be linked during brillig generation.
-    pub(crate) fn foreign_call_instruction(
-        &mut self,
-        func_name: String,
-        inputs: &[ValueOrArray],
-        input_value_types: &[HeapValueType],
-        outputs: &[ValueOrArray],
-        output_value_types: &[HeapValueType],
-    ) {
-        assert!(inputs.len() == input_value_types.len());
-        assert!(outputs.len() == output_value_types.len());
-        self.debug_show.foreign_call_instruction(func_name.clone(), inputs, outputs);
-        let opcode = BrilligOpcode::ForeignCall {
-            function: func_name,
-            destinations: outputs.to_vec(),
-            destination_value_types: output_value_types.to_vec(),
-            inputs: inputs.to_vec(),
-            input_value_types: input_value_types.to_vec(),
-        };
-        self.push_opcode(opcode);
-    }
-
-    /// Emits a load instruction
-    pub(crate) fn load_instruction(
-        &mut self,
-        destination: MemoryAddress,
-        source_pointer: MemoryAddress,
-    ) {
-        self.debug_show.load_instruction(destination, source_pointer);
-        self.push_opcode(BrilligOpcode::Load { destination, source_pointer });
-    }
-
-    /// Loads a variable stored previously
-    pub(crate) fn load_variable_instruction(
-        &mut self,
-        destination: BrilligVariable,
-        variable_pointer: MemoryAddress,
-    ) {
-        match destination {
-            BrilligVariable::SingleAddr(single_addr) => {
-                self.load_instruction(single_addr.address, variable_pointer);
-            }
-            BrilligVariable::BrilligArray(BrilligArray { pointer, size: _, rc }) => {
-                self.load_instruction(pointer, variable_pointer);
-
-                let rc_pointer = self.allocate_register();
-                self.mov_instruction(rc_pointer, variable_pointer);
-                self.usize_op_in_place(rc_pointer, BinaryIntOp::Add, 1_usize);
-
-                self.load_instruction(rc, rc_pointer);
-                self.deallocate_register(rc_pointer);
-            }
-            BrilligVariable::BrilligVector(BrilligVector { pointer, size, rc }) => {
-                self.load_instruction(pointer, variable_pointer);
-
-                let size_pointer = self.allocate_register();
-                self.mov_instruction(size_pointer, variable_pointer);
-                self.usize_op_in_place(size_pointer, BinaryIntOp::Add, 1_usize);
-
-                self.load_instruction(size, size_pointer);
-                self.deallocate_register(size_pointer);
-
-                let rc_pointer = self.allocate_register();
-                self.mov_instruction(rc_pointer, variable_pointer);
-                self.usize_op_in_place(rc_pointer, BinaryIntOp::Add, 2_usize);
-
-                self.load_instruction(rc, rc_pointer);
-                self.deallocate_register(rc_pointer);
-            }
-        }
-    }
-
-    /// Emits a store instruction
-    pub(crate) fn store_instruction(
-        &mut self,
-        destination_pointer: MemoryAddress,
-        source: MemoryAddress,
-    ) {
-        self.debug_show.store_instruction(destination_pointer, source);
-        self.push_opcode(BrilligOpcode::Store { destination_pointer, source });
-    }
-
-    /// Stores a variable by saving its registers to memory
-    pub(crate) fn store_variable_instruction(
-        &mut self,
-        variable_pointer: MemoryAddress,
-        source: BrilligVariable,
-    ) {
-        match source {
-            BrilligVariable::SingleAddr(single_addr) => {
-                self.store_instruction(variable_pointer, single_addr.address);
-            }
-            BrilligVariable::BrilligArray(BrilligArray { pointer, size: _, rc }) => {
-                self.store_instruction(variable_pointer, pointer);
-
-                let rc_pointer: MemoryAddress = self.allocate_register();
-                self.mov_instruction(rc_pointer, variable_pointer);
-                self.usize_op_in_place(rc_pointer, BinaryIntOp::Add, 1_usize);
-                self.store_instruction(rc_pointer, rc);
-                self.deallocate_register(rc_pointer);
-            }
-            BrilligVariable::BrilligVector(BrilligVector { pointer, size, rc }) => {
-                self.store_instruction(variable_pointer, pointer);
-
-                let size_pointer = self.allocate_register();
-                self.mov_instruction(size_pointer, variable_pointer);
-                self.usize_op_in_place(size_pointer, BinaryIntOp::Add, 1_usize);
-                self.store_instruction(size_pointer, size);
-
-                let rc_pointer: MemoryAddress = self.allocate_register();
-                self.mov_instruction(rc_pointer, variable_pointer);
-                self.usize_op_in_place(rc_pointer, BinaryIntOp::Add, 2_usize);
-                self.store_instruction(rc_pointer, rc);
-
-                self.deallocate_register(size_pointer);
-                self.deallocate_register(rc_pointer);
-            }
-        }
-    }
-
-    /// Emits a truncate instruction.
-    ///
-    /// Note: Truncation is used as an optimization in the SSA IR
-    /// for the ACIR generation pass; ACIR gen does not overflow
-    /// on every integer operation since it would be in-efficient.
-    /// Instead truncation instructions are emitted as to when a
-    /// truncation should be done.
-    /// For Brillig, all integer operations will overflow as its cheap.
-    /// We currently use cast to truncate: we cast to the required bit size
-    /// and back to the original bit size.
-    pub(crate) fn truncate_instruction(
-        &mut self,
-        destination_of_truncated_value: SingleAddrVariable,
-        value_to_truncate: SingleAddrVariable,
-        bit_size: u32,
-    ) {
-        self.debug_show.truncate_instruction(
-            destination_of_truncated_value.address,
-            value_to_truncate.address,
-            bit_size,
-        );
-        assert!(
-            bit_size <= value_to_truncate.bit_size,
-            "tried to truncate to a bit size {} greater than the variable size {}",
-            bit_size,
-            value_to_truncate.bit_size
-        );
-
-        // We cast back and forth to ensure that the value is truncated.
-        let intermediate_register =
-            SingleAddrVariable { address: self.allocate_register(), bit_size };
-        self.cast_instruction(intermediate_register, value_to_truncate);
-        self.cast_instruction(destination_of_truncated_value, intermediate_register);
-        self.deallocate_register(intermediate_register.address);
-    }
-
-    /// Emits a stop instruction
-    pub(crate) fn stop_instruction(&mut self) {
-        self.debug_show.stop_instruction();
-        self.push_opcode(BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 });
-    }
-
-    /// Returns a register which holds the value of a constant
-    pub(crate) fn make_constant(&mut self, constant: Value, bit_size: u32) -> SingleAddrVariable {
-        let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
-        self.const_instruction(var, constant);
-        var
-    }
-
-    /// Returns a register which holds the value of an usize constant
-    pub(crate) fn make_usize_constant(&mut self, constant: Value) -> SingleAddrVariable {
-        let register = self.allocate_register();
-        self.usize_const(register, constant);
-        SingleAddrVariable::new_usize(register)
-    }
-
-    /// Computes left % right by emitting the necessary Brillig opcodes.
-    ///
-    /// This is done by using the following formula:
-    ///
-    /// a % b = a - (b * (a / b))
-    ///
-    /// Brillig does not have an explicit modulo operation,
-    /// so we must emit multiple opcodes and process it differently
-    /// to other binary instructions.
-    pub(crate) fn modulo_instruction(
-        &mut self,
-        result: SingleAddrVariable,
-        left: SingleAddrVariable,
-        right: SingleAddrVariable,
-        signed: bool,
-    ) {
-        // no debug_show, shown in binary instruction
-        let scratch_register_i = self.allocate_register();
-        let scratch_register_j = self.allocate_register();
-
-        assert!(
-            left.bit_size == right.bit_size,
-            "Not equal bitsize: lhs {}, rhs {}",
-            left.bit_size,
-            right.bit_size
-        );
-        let bit_size = left.bit_size;
-        // i = left / right
-        self.push_opcode(BrilligOpcode::BinaryIntOp {
-            op: match signed {
-                true => BinaryIntOp::SignedDiv,
-                false => BinaryIntOp::UnsignedDiv,
-            },
-            destination: scratch_register_i,
-            bit_size,
-            lhs: left.address,
-            rhs: right.address,
-        });
-
-        // j = i * right
-        self.push_opcode(BrilligOpcode::BinaryIntOp {
-            op: BinaryIntOp::Mul,
-            destination: scratch_register_j,
-            bit_size,
-            lhs: scratch_register_i,
-            rhs: right.address,
-        });
-
-        // result_register = left - j
-        self.push_opcode(BrilligOpcode::BinaryIntOp {
-            op: BinaryIntOp::Sub,
-            destination: result.address,
-            bit_size,
-            lhs: left.address,
-            rhs: scratch_register_j,
-        });
-        // Free scratch registers
-        self.deallocate_register(scratch_register_i);
-        self.deallocate_register(scratch_register_j);
-    }
-
-    /// Adds a unresolved external `Call` instruction to the bytecode.
-    /// This calls into another function compiled into this brillig artifact.
-    pub(crate) fn add_external_call_instruction<T: ToString>(&mut self, func_label: T) {
-        self.debug_show.add_external_call_instruction(func_label.to_string());
-        self.obj.add_unresolved_external_call(
-            BrilligOpcode::Call { location: 0 },
-            func_label.to_string(),
-        );
-    }
-
-    /// Returns the i'th register after the reserved ones
-    pub(crate) fn register(&self, i: usize) -> MemoryAddress {
-        MemoryAddress::from(ReservedRegisters::NUM_RESERVED_REGISTERS + i)
-    }
-
-    /// Saves all of the registers that have been used up until this point.
-    fn save_registers_of_vars(&mut self, vars: &[BrilligVariable]) -> Vec<MemoryAddress> {
-        // Save all of the used registers at this point in memory
-        // because the function call will/may overwrite them.
-        //
-        // Note that here it is important that the stack pointer register is at register 0,
-        // as after the first register save we add to the pointer.
-        let mut used_registers: Vec<_> =
-            vars.iter().flat_map(|var| var.extract_registers()).collect();
-
-        // Also dump the previous stack pointer
-        used_registers.push(ReservedRegisters::previous_stack_pointer());
-        for register in used_registers.iter() {
-            self.store_instruction(ReservedRegisters::stack_pointer(), *register);
-            // Add one to our stack pointer
-            self.usize_op_in_place(ReservedRegisters::stack_pointer(), BinaryIntOp::Add, 1);
-        }
-
-        // Store the location of our registers in the previous stack pointer
-        self.mov_instruction(
-            ReservedRegisters::previous_stack_pointer(),
-            ReservedRegisters::stack_pointer(),
-        );
-        used_registers
-    }
-
-    /// Loads all of the registers that have been save by save_all_used_registers.
-    fn load_all_saved_registers(&mut self, used_registers: &[MemoryAddress]) {
-        // Load all of the used registers that we saved.
-        // We do all the reverse operations of save_all_used_registers.
-        // Iterate our registers in reverse
-        let iterator_register = self.allocate_register();
-        self.mov_instruction(iterator_register, ReservedRegisters::previous_stack_pointer());
-
-        for register in used_registers.iter().rev() {
-            // Subtract one from our stack pointer
-            self.usize_op_in_place(iterator_register, BinaryIntOp::Sub, 1);
-            self.load_instruction(*register, iterator_register);
-        }
-    }
-
-    /// Utility method to perform a binary instruction with a constant value in place
-    pub(crate) fn usize_op_in_place(
-        &mut self,
-        destination: MemoryAddress,
-        op: BinaryIntOp,
-        constant: usize,
-    ) {
-        self.usize_op(destination, destination, op, constant);
-    }
-
-    /// Utility method to perform a binary instruction with a constant value
-    pub(crate) fn usize_op(
-        &mut self,
-        operand: MemoryAddress,
-        destination: MemoryAddress,
-        op: BinaryIntOp,
-        constant: usize,
-    ) {
-        let const_register = self.make_usize_constant(Value::from(constant));
-        self.memory_op(operand, const_register.address, destination, op);
-        // Mark as no longer used for this purpose, frees for reuse
-        self.deallocate_single_addr(const_register);
-    }
-
-    /// Utility method to perform a binary instruction with a memory address
-    pub(crate) fn memory_op(
-        &mut self,
-        lhs: MemoryAddress,
-        rhs: MemoryAddress,
-        destination: MemoryAddress,
-        op: BinaryIntOp,
-    ) {
-        self.binary_instruction(
-            SingleAddrVariable::new_usize(lhs),
-            SingleAddrVariable::new_usize(rhs),
-            SingleAddrVariable::new(
-                destination,
-                BrilligContext::binary_result_bit_size(
-                    BrilligBinaryOp::Integer(op),
-                    BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-                ),
-            ),
-            BrilligBinaryOp::Integer(op),
-        );
-    }
-
-    // Used before a call instruction.
-    // Save all the registers we have used to the stack.
-    // Move argument values to the front of the register indices.
-    pub(crate) fn pre_call_save_registers_prep_args(
-        &mut self,
-        arguments: &[MemoryAddress],
-        variables_to_save: &[BrilligVariable],
-    ) -> Vec<MemoryAddress> {
-        // Save all the registers we have used to the stack.
-        let saved_registers = self.save_registers_of_vars(variables_to_save);
-
-        // Move argument values to the front of the registers
-        //
-        // This means that the arguments will be in the first `n` registers after
-        // the number of reserved registers.
-        let (sources, destinations): (Vec<_>, Vec<_>) =
-            arguments.iter().enumerate().map(|(i, argument)| (*argument, self.register(i))).unzip();
-        destinations
-            .iter()
-            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
-        self.mov_registers_to_registers_instruction(sources, destinations);
-        saved_registers
-    }
-
-    // Used after a call instruction.
-    // Move return values to the front of the register indices.
-    // Load all the registers we have previous saved in save_registers_prep_args.
-    pub(crate) fn post_call_prep_returns_load_registers(
-        &mut self,
-        result_registers: &[MemoryAddress],
-        saved_registers: &[MemoryAddress],
-    ) {
-        // Allocate our result registers and write into them
-        // We assume the return values of our call are held in 0..num results register indices
-        let (sources, destinations): (Vec<_>, Vec<_>) = result_registers
-            .iter()
-            .enumerate()
-            .map(|(i, result_register)| (self.register(i), *result_register))
-            .unzip();
-        sources.iter().for_each(|source| self.registers.ensure_register_is_allocated(*source));
-        self.mov_registers_to_registers_instruction(sources, destinations);
-
-        // Restore all the same registers we have, in exact reverse order.
-        // Note that we have allocated some registers above, which we will not be handling here,
-        // only restoring registers that were used prior to the call finishing.
-        // After the call instruction, the stack frame pointer should be back to where we left off,
-        // so we do our instructions in reverse order.
-        self.load_all_saved_registers(saved_registers);
-    }
-
-    /// Utility method to transform a HeapArray to a HeapVector by making a runtime constant with the size.
-    pub(crate) fn array_to_vector(&mut self, array: &BrilligArray) -> BrilligVector {
-        let size_register = self.make_usize_constant(array.size.into());
-        BrilligVector { size: size_register.address, pointer: array.pointer, rc: array.rc }
-    }
-
-    /// Issues a blackbox operation.
-    pub(crate) fn black_box_op_instruction(&mut self, op: BlackBoxOp) {
-        self.debug_show.black_box_op_instruction(&op);
-        self.push_opcode(BrilligOpcode::BlackBox(op));
-    }
-
-    /// Issues a to_radix instruction. This instruction will write the modulus of the source register
-    /// And the radix register limb_count times to the target vector.
-    pub(crate) fn radix_instruction(
-        &mut self,
-        source_field: SingleAddrVariable,
-        target_vector: BrilligVector,
-        radix: SingleAddrVariable,
-        limb_count: SingleAddrVariable,
-        big_endian: bool,
-    ) {
-        assert!(source_field.bit_size == FieldElement::max_num_bits());
-        assert!(radix.bit_size == 32);
-        assert!(limb_count.bit_size == 32);
-        let radix_as_field =
-            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
-        self.cast_instruction(radix_as_field, radix);
-
-        self.cast_instruction(SingleAddrVariable::new_usize(target_vector.size), limb_count);
-        self.usize_const(target_vector.rc, 1_usize.into());
-        self.allocate_array_instruction(target_vector.pointer, target_vector.size);
-
-        let shifted_field =
-            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
-        self.mov_instruction(shifted_field.address, source_field.address);
-
-        let modulus_field =
-            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
-
-        self.loop_instruction(target_vector.size, |ctx, iterator_register| {
-            // Compute the modulus
-            ctx.modulo_instruction(modulus_field, shifted_field, radix_as_field, false);
-            // Write it
-            ctx.array_set(target_vector.pointer, iterator_register, modulus_field.address);
-            // Integer div the field
-            ctx.binary_instruction(
-                shifted_field,
-                radix_as_field,
-                shifted_field,
-                BrilligBinaryOp::Integer(BinaryIntOp::UnsignedDiv),
-            );
-        });
-
-        // Deallocate our temporary registers
-        self.deallocate_single_addr(shifted_field);
-        self.deallocate_single_addr(modulus_field);
-        self.deallocate_single_addr(radix_as_field);
-
-        if big_endian {
-            self.reverse_vector_in_place_instruction(target_vector);
-        }
-    }
-
-    /// This instruction will reverse the order of the elements in a vector.
-    pub(crate) fn reverse_vector_in_place_instruction(&mut self, vector: BrilligVector) {
-        let iteration_count = self.allocate_register();
-        self.usize_op(vector.size, iteration_count, BinaryIntOp::UnsignedDiv, 2);
-
-        let start_value_register = self.allocate_register();
-        let index_at_end_of_array = self.allocate_register();
-        let end_value_register = self.allocate_register();
-
-        self.loop_instruction(iteration_count, |ctx, iterator_register| {
-            // Load both values
-            ctx.array_get(vector.pointer, iterator_register, start_value_register);
-
-            // The index at the end of array is size - 1 - iterator
-            ctx.mov_instruction(index_at_end_of_array, vector.size);
-            ctx.usize_op_in_place(index_at_end_of_array, BinaryIntOp::Sub, 1);
-            ctx.memory_op(
-                index_at_end_of_array,
-                iterator_register.address,
-                index_at_end_of_array,
-                BinaryIntOp::Sub,
-            );
-
-            ctx.array_get(
-                vector.pointer,
-                SingleAddrVariable::new_usize(index_at_end_of_array),
-                end_value_register,
-            );
-
-            // Write both values
-            ctx.array_set(vector.pointer, iterator_register, end_value_register);
-            ctx.array_set(
-                vector.pointer,
-                SingleAddrVariable::new_usize(index_at_end_of_array),
-                start_value_register,
-            );
-        });
-
-        self.deallocate_register(iteration_count);
-        self.deallocate_register(start_value_register);
-        self.deallocate_register(end_value_register);
-        self.deallocate_register(index_at_end_of_array);
-    }
-
     /// Sets a current call stack that the next pushed opcodes will be associated with.
     pub(crate) fn set_call_stack(&mut self, call_stack: CallStack) {
         self.obj.set_call_stack(call_stack);
     }
 }
 
-/// Type to encapsulate the binary operation types in Brillig
-#[derive(Clone, Copy, Debug)]
-pub(crate) enum BrilligBinaryOp {
-    Field(BinaryFieldOp),
-    Integer(BinaryIntOp),
-    // Modulo operation requires more than one brillig opcode
-    Modulo { is_signed_integer: bool },
-}
-
 #[cfg(test)]
 pub(crate) mod tests {
     use std::vec;
 
     use acvm::acir::brillig::{
-        BinaryIntOp, ForeignCallParam, ForeignCallResult, HeapVector, MemoryAddress, Value,
-        ValueOrArray,
+        ForeignCallParam, ForeignCallResult, HeapVector, MemoryAddress, Value, ValueOrArray,
     };
     use acvm::brillig_vm::brillig::HeapValueType;
     use acvm::brillig_vm::{VMStatus, VM};
     use acvm::{BlackBoxFunctionSolver, BlackBoxResolutionError, FieldElement};
 
-    use crate::brillig::brillig_ir::BrilligContext;
+    use crate::brillig::brillig_ir::{BrilligBinaryOp, BrilligContext};
 
     use super::artifact::{BrilligParameter, GeneratedBrillig};
     use super::{BrilligOpcode, ReservedRegisters};
@@ -1264,14 +232,14 @@ pub(crate) mod tests {
         //   assert(the_sequence.len() == 12);
         // }
         let mut context = BrilligContext::new(true);
-        let r_stack = ReservedRegisters::stack_pointer();
+        let r_stack = ReservedRegisters::free_memory_pointer();
         // Start stack pointer at 0
-        context.usize_const(r_stack, Value::from(ReservedRegisters::len() + 3));
+        context.usize_const_instruction(r_stack, Value::from(ReservedRegisters::len() + 3));
         let r_input_size = MemoryAddress::from(ReservedRegisters::len());
         let r_array_ptr = MemoryAddress::from(ReservedRegisters::len() + 1);
         let r_output_size = MemoryAddress::from(ReservedRegisters::len() + 2);
         let r_equality = MemoryAddress::from(ReservedRegisters::len() + 3);
-        context.usize_const(r_input_size, Value::from(12_usize));
+        context.usize_const_instruction(r_input_size, Value::from(12_usize));
         // copy our stack frame to r_array_ptr
         context.mov_instruction(r_array_ptr, r_stack);
         context.foreign_call_instruction(
@@ -1282,9 +250,14 @@ pub(crate) mod tests {
             &[HeapValueType::Vector { value_types: vec![HeapValueType::Simple] }],
         );
         // push stack frame by r_returned_size
-        context.memory_op(r_stack, r_output_size, r_stack, BinaryIntOp::Add);
+        context.memory_op_instruction(r_stack, r_output_size, r_stack, BrilligBinaryOp::Add);
         // check r_input_size == r_output_size
-        context.memory_op(r_input_size, r_output_size, r_equality, BinaryIntOp::Equals);
+        context.memory_op_instruction(
+            r_input_size,
+            r_output_size,
+            r_equality,
+            BrilligBinaryOp::Equals,
+        );
         // We push a JumpIf and Trap opcode directly as the constrain instruction
         // uses unresolved jumps which requires a block to be constructed in SSA and
         // we don't need this for Brillig IR tests
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
index b94f8140ddd..b415421dd92 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
@@ -1,5 +1,6 @@
-use acvm::brillig_vm::brillig::{
-    HeapArray, HeapValueType, HeapVector, MemoryAddress, ValueOrArray,
+use acvm::{
+    brillig_vm::brillig::{HeapArray, HeapValueType, HeapVector, MemoryAddress, ValueOrArray},
+    FieldElement,
 };
 use serde::{Deserialize, Serialize};
 
@@ -21,6 +22,10 @@ impl SingleAddrVariable {
     pub(crate) fn new_usize(address: MemoryAddress) -> Self {
         SingleAddrVariable { address, bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE }
     }
+
+    pub(crate) fn new_field(address: MemoryAddress) -> Self {
+        SingleAddrVariable { address, bit_size: FieldElement::max_num_bits() }
+    }
 }
 
 /// The representation of a noir array in the Brillig IR
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
new file mode 100644
index 00000000000..248a304d820
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
@@ -0,0 +1,29 @@
+use acvm::acir::brillig::{MemoryAddress, Value};
+
+use super::{instructions::BrilligBinaryOp, BrilligContext};
+
+impl BrilligContext {
+    /// Utility method to perform a binary instruction with a constant value in place
+    pub(crate) fn codegen_usize_op_in_place(
+        &mut self,
+        destination: MemoryAddress,
+        op: BrilligBinaryOp,
+        constant: usize,
+    ) {
+        self.codegen_usize_op(destination, destination, op, constant);
+    }
+
+    /// Utility method to perform a binary instruction with a constant value
+    pub(crate) fn codegen_usize_op(
+        &mut self,
+        operand: MemoryAddress,
+        destination: MemoryAddress,
+        op: BrilligBinaryOp,
+        constant: usize,
+    ) {
+        let const_register = self.make_usize_constant_instruction(Value::from(constant));
+        self.memory_op_instruction(operand, const_register.address, destination, op);
+        // Mark as no longer used for this purpose, frees for reuse
+        self.deallocate_single_addr(const_register);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
new file mode 100644
index 00000000000..db65849a6b8
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
@@ -0,0 +1,102 @@
+use acvm::acir::brillig::MemoryAddress;
+
+use super::{
+    brillig_variable::BrilligVariable, BrilligBinaryOp, BrilligContext, ReservedRegisters,
+};
+
+impl BrilligContext {
+    /// Saves all of the registers that have been used up until this point.
+    fn codegen_save_registers_of_vars(&mut self, vars: &[BrilligVariable]) -> Vec<MemoryAddress> {
+        // Save all of the used registers at this point in memory
+        // because the function call will/may overwrite them.
+        //
+        // Note that here it is important that the stack pointer register is at register 0,
+        // as after the first register save we add to the pointer.
+        let mut used_registers: Vec<_> =
+            vars.iter().flat_map(|var| var.extract_registers()).collect();
+
+        // Also dump the previous stack pointer
+        used_registers.push(ReservedRegisters::previous_stack_pointer());
+        for register in used_registers.iter() {
+            self.store_instruction(ReservedRegisters::free_memory_pointer(), *register);
+            // Add one to our stack pointer
+            self.codegen_usize_op_in_place(
+                ReservedRegisters::free_memory_pointer(),
+                BrilligBinaryOp::Add,
+                1,
+            );
+        }
+
+        // Store the location of our registers in the previous stack pointer
+        self.mov_instruction(
+            ReservedRegisters::previous_stack_pointer(),
+            ReservedRegisters::free_memory_pointer(),
+        );
+        used_registers
+    }
+
+    /// Loads all of the registers that have been save by save_all_used_registers.
+    fn codegen_load_all_saved_registers(&mut self, used_registers: &[MemoryAddress]) {
+        // Load all of the used registers that we saved.
+        // We do all the reverse operations of save_all_used_registers.
+        // Iterate our registers in reverse
+        let iterator_register = self.allocate_register();
+        self.mov_instruction(iterator_register, ReservedRegisters::previous_stack_pointer());
+
+        for register in used_registers.iter().rev() {
+            // Subtract one from our stack pointer
+            self.codegen_usize_op_in_place(iterator_register, BrilligBinaryOp::Sub, 1);
+            self.load_instruction(*register, iterator_register);
+        }
+    }
+
+    // Used before a call instruction.
+    // Save all the registers we have used to the stack.
+    // Move argument values to the front of the register indices.
+    pub(crate) fn codegen_pre_call_save_registers_prep_args(
+        &mut self,
+        arguments: &[MemoryAddress],
+        variables_to_save: &[BrilligVariable],
+    ) -> Vec<MemoryAddress> {
+        // Save all the registers we have used to the stack.
+        let saved_registers = self.codegen_save_registers_of_vars(variables_to_save);
+
+        // Move argument values to the front of the registers
+        //
+        // This means that the arguments will be in the first `n` registers after
+        // the number of reserved registers.
+        let (sources, destinations): (Vec<_>, Vec<_>) =
+            arguments.iter().enumerate().map(|(i, argument)| (*argument, self.register(i))).unzip();
+        destinations
+            .iter()
+            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
+        self.codegen_mov_registers_to_registers(sources, destinations);
+        saved_registers
+    }
+
+    // Used after a call instruction.
+    // Move return values to the front of the register indices.
+    // Load all the registers we have previous saved in save_registers_prep_args.
+    pub(crate) fn codegen_post_call_prep_returns_load_registers(
+        &mut self,
+        result_registers: &[MemoryAddress],
+        saved_registers: &[MemoryAddress],
+    ) {
+        // Allocate our result registers and write into them
+        // We assume the return values of our call are held in 0..num results register indices
+        let (sources, destinations): (Vec<_>, Vec<_>) = result_registers
+            .iter()
+            .enumerate()
+            .map(|(i, result_register)| (self.register(i), *result_register))
+            .unzip();
+        sources.iter().for_each(|source| self.registers.ensure_register_is_allocated(*source));
+        self.codegen_mov_registers_to_registers(sources, destinations);
+
+        // Restore all the same registers we have, in exact reverse order.
+        // Note that we have allocated some registers above, which we will not be handling here,
+        // only restoring registers that were used prior to the call finishing.
+        // After the call instruction, the stack frame pointer should be back to where we left off,
+        // so we do our instructions in reverse order.
+        self.codegen_load_all_saved_registers(saved_registers);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
new file mode 100644
index 00000000000..116eaa5103f
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -0,0 +1,141 @@
+use acvm::acir::brillig::MemoryAddress;
+
+use super::{
+    brillig_variable::SingleAddrVariable, BrilligBinaryOp, BrilligContext, ReservedRegisters,
+};
+
+impl BrilligContext {
+    /// Codegens a return from the current function.
+    ///
+    /// For Brillig, the return is implicit, since there is no explicit return instruction.
+    /// The caller will take `N` values from the Register starting at register index 0.
+    /// `N` indicates the number of return values expected.
+    ///
+    /// Brillig does not have an explicit return instruction, so this
+    /// method will move all register values to the first `N` values in
+    /// the VM.
+    pub(crate) fn codegen_return(&mut self, return_registers: &[MemoryAddress]) {
+        let mut sources = Vec::with_capacity(return_registers.len());
+        let mut destinations = Vec::with_capacity(return_registers.len());
+
+        for (destination_index, return_register) in return_registers.iter().enumerate() {
+            // In case we have fewer return registers than indices to write to, ensure we've allocated this register
+            let destination_register = ReservedRegisters::user_register_index(destination_index);
+            self.registers.ensure_register_is_allocated(destination_register);
+            sources.push(*return_register);
+            destinations.push(destination_register);
+        }
+        destinations
+            .iter()
+            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
+        self.codegen_mov_registers_to_registers(sources, destinations);
+        self.stop_instruction();
+    }
+
+    /// This codegen will issue a loop that will iterate iteration_count times
+    /// The body of the loop should be issued by the caller in the on_iteration closure.
+    pub(crate) fn codegen_loop<F>(&mut self, iteration_count: MemoryAddress, on_iteration: F)
+    where
+        F: FnOnce(&mut BrilligContext, SingleAddrVariable),
+    {
+        let iterator_register = self.make_usize_constant_instruction(0_u128.into());
+
+        let (loop_section, loop_label) = self.reserve_next_section_label();
+        self.enter_section(loop_section);
+
+        // Loop body
+
+        // Check if iterator < iteration_count
+        let iterator_less_than_iterations =
+            SingleAddrVariable { address: self.allocate_register(), bit_size: 1 };
+
+        self.memory_op_instruction(
+            iterator_register.address,
+            iteration_count,
+            iterator_less_than_iterations.address,
+            BrilligBinaryOp::LessThan,
+        );
+
+        let (exit_loop_section, exit_loop_label) = self.reserve_next_section_label();
+
+        self.not_instruction(iterator_less_than_iterations, iterator_less_than_iterations);
+
+        self.jump_if_instruction(iterator_less_than_iterations.address, exit_loop_label);
+
+        // Call the on iteration function
+        on_iteration(self, iterator_register);
+
+        // Increment the iterator register
+        self.codegen_usize_op_in_place(iterator_register.address, BrilligBinaryOp::Add, 1);
+
+        self.jump_instruction(loop_label);
+
+        // Exit the loop
+        self.enter_section(exit_loop_section);
+
+        // Deallocate our temporary registers
+        self.deallocate_single_addr(iterator_less_than_iterations);
+        self.deallocate_single_addr(iterator_register);
+    }
+
+    /// This codegen will issue an if-then branch that will check if the condition is true
+    /// and if so, perform the instructions given in `f(self, true)` and otherwise perform the
+    /// instructions given in `f(self, false)`. A boolean is passed instead of two separate
+    /// functions to allow the given function to mutably alias its environment.
+    pub(crate) fn codegen_branch(
+        &mut self,
+        condition: MemoryAddress,
+        mut f: impl FnMut(&mut BrilligContext, bool),
+    ) {
+        // Reserve 3 sections
+        let (then_section, then_label) = self.reserve_next_section_label();
+        let (otherwise_section, otherwise_label) = self.reserve_next_section_label();
+        let (end_section, end_label) = self.reserve_next_section_label();
+
+        self.jump_if_instruction(condition, then_label.clone());
+        self.jump_instruction(otherwise_label.clone());
+
+        self.enter_section(then_section);
+        f(self, true);
+        self.jump_instruction(end_label.clone());
+
+        self.enter_section(otherwise_section);
+        f(self, false);
+        self.jump_instruction(end_label.clone());
+
+        self.enter_section(end_section);
+    }
+
+    /// This codegen issues a branch that jumps over the code generated by the given function if the condition is false
+    pub(crate) fn codegen_if(
+        &mut self,
+        condition: MemoryAddress,
+        f: impl FnOnce(&mut BrilligContext),
+    ) {
+        let (end_section, end_label) = self.reserve_next_section_label();
+        let (then_section, then_label) = self.reserve_next_section_label();
+
+        self.jump_if_instruction(condition, then_label.clone());
+        self.jump_instruction(end_label.clone());
+
+        self.enter_section(then_section);
+        f(self);
+
+        self.enter_section(end_section);
+    }
+
+    /// This codegen issues a branch that jumps over the code generated by the given function if the condition is truthy
+    pub(crate) fn codegen_if_not(
+        &mut self,
+        condition: MemoryAddress,
+        f: impl FnOnce(&mut BrilligContext),
+    ) {
+        let (end_section, end_label) = self.reserve_next_section_label();
+
+        self.jump_if_instruction(condition, end_label.clone());
+
+        f(self);
+
+        self.enter_section(end_section);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
new file mode 100644
index 00000000000..be262d9dee7
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -0,0 +1,89 @@
+use acvm::FieldElement;
+
+use crate::brillig::brillig_ir::BrilligBinaryOp;
+
+use super::{
+    brillig_variable::{BrilligVector, SingleAddrVariable},
+    BrilligContext,
+};
+
+impl BrilligContext {
+    /// Codegens a truncation of a value to the given bit size
+    pub(crate) fn codegen_truncate(
+        &mut self,
+        destination_of_truncated_value: SingleAddrVariable,
+        value_to_truncate: SingleAddrVariable,
+        bit_size: u32,
+    ) {
+        assert!(
+            bit_size <= value_to_truncate.bit_size,
+            "tried to truncate to a bit size {} greater than the variable size {}",
+            bit_size,
+            value_to_truncate.bit_size
+        );
+
+        // We cast back and forth to ensure that the value is truncated.
+        let intermediate_register =
+            SingleAddrVariable { address: self.allocate_register(), bit_size };
+        self.cast_instruction(intermediate_register, value_to_truncate);
+        self.cast_instruction(destination_of_truncated_value, intermediate_register);
+        self.deallocate_single_addr(intermediate_register);
+    }
+
+    /// Issues a to_radix instruction. This instruction will write the modulus of the source register
+    /// And the radix register limb_count times to the target vector.
+    pub(crate) fn codegen_to_radix(
+        &mut self,
+        source_field: SingleAddrVariable,
+        target_vector: BrilligVector,
+        radix: SingleAddrVariable,
+        limb_count: SingleAddrVariable,
+        big_endian: bool,
+    ) {
+        assert!(source_field.bit_size == FieldElement::max_num_bits());
+        assert!(radix.bit_size == 32);
+        assert!(limb_count.bit_size == 32);
+        let radix_as_field =
+            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
+        self.cast_instruction(radix_as_field, radix);
+
+        self.cast_instruction(SingleAddrVariable::new_usize(target_vector.size), limb_count);
+        self.usize_const_instruction(target_vector.rc, 1_usize.into());
+        self.codegen_allocate_array(target_vector.pointer, target_vector.size);
+
+        let shifted_field =
+            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
+        self.mov_instruction(shifted_field.address, source_field.address);
+
+        let modulus_field =
+            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
+
+        self.codegen_loop(target_vector.size, |ctx, iterator_register| {
+            // Compute the modulus
+            ctx.binary_instruction(
+                shifted_field,
+                radix_as_field,
+                modulus_field,
+                BrilligBinaryOp::Modulo,
+            );
+            // Write it
+            ctx.codegen_array_set(target_vector.pointer, iterator_register, modulus_field.address);
+            // Integer div the field
+            ctx.binary_instruction(
+                shifted_field,
+                radix_as_field,
+                shifted_field,
+                BrilligBinaryOp::UnsignedDiv,
+            );
+        });
+
+        // Deallocate our temporary registers
+        self.deallocate_single_addr(shifted_field);
+        self.deallocate_single_addr(modulus_field);
+        self.deallocate_single_addr(radix_as_field);
+
+        if big_endian {
+            self.codegen_reverse_vector_in_place(target_vector);
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
new file mode 100644
index 00000000000..15761113f51
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
@@ -0,0 +1,255 @@
+use acvm::acir::brillig::MemoryAddress;
+
+use crate::brillig::brillig_ir::BrilligBinaryOp;
+
+use super::{
+    brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
+    BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+};
+
+impl BrilligContext {
+    /// Allocates an array of size `size` and stores the pointer to the array
+    /// in `pointer_register`
+    pub(crate) fn codegen_allocate_fixed_length_array(
+        &mut self,
+        pointer_register: MemoryAddress,
+        size: usize,
+    ) {
+        let size_register = self.make_usize_constant_instruction(size.into());
+        self.codegen_allocate_array(pointer_register, size_register.address);
+        self.deallocate_single_addr(size_register);
+    }
+
+    /// Allocates an array of size contained in size_register and stores the
+    /// pointer to the array in `pointer_register`
+    pub(crate) fn codegen_allocate_array(
+        &mut self,
+        pointer_register: MemoryAddress,
+        size_register: MemoryAddress,
+    ) {
+        self.load_free_memory_pointer_instruction(pointer_register);
+        self.increase_free_memory_pointer_instruction(size_register);
+    }
+
+    /// Allocates a variable in memory and stores the
+    /// pointer to the array in `pointer_register`
+    fn codegen_allocate_variable_reference(
+        &mut self,
+        pointer_register: MemoryAddress,
+        size: usize,
+    ) {
+        // A variable can be stored in up to three values, so we reserve three values for that.
+        let size_register = self.make_usize_constant_instruction(size.into());
+        self.mov_instruction(pointer_register, ReservedRegisters::free_memory_pointer());
+        self.memory_op_instruction(
+            ReservedRegisters::free_memory_pointer(),
+            size_register.address,
+            ReservedRegisters::free_memory_pointer(),
+            BrilligBinaryOp::Add,
+        );
+        self.deallocate_single_addr(size_register);
+    }
+
+    pub(crate) fn codegen_allocate_single_addr_reference(
+        &mut self,
+        pointer_register: MemoryAddress,
+    ) {
+        self.codegen_allocate_variable_reference(pointer_register, 1);
+    }
+
+    pub(crate) fn codegen_allocate_array_reference(&mut self, pointer_register: MemoryAddress) {
+        self.codegen_allocate_variable_reference(pointer_register, BrilligArray::registers_count());
+    }
+
+    pub(crate) fn codegen_allocate_vector_reference(&mut self, pointer_register: MemoryAddress) {
+        self.codegen_allocate_variable_reference(
+            pointer_register,
+            BrilligVector::registers_count(),
+        );
+    }
+
+    /// Gets the value in the array at index `index` and stores it in `result`
+    pub(crate) fn codegen_array_get(
+        &mut self,
+        array_ptr: MemoryAddress,
+        index: SingleAddrVariable,
+        result: MemoryAddress,
+    ) {
+        assert!(index.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        // Computes array_ptr + index, ie array[index]
+        let index_of_element_in_memory = self.allocate_register();
+        self.memory_op_instruction(
+            array_ptr,
+            index.address,
+            index_of_element_in_memory,
+            BrilligBinaryOp::Add,
+        );
+        self.load_instruction(result, index_of_element_in_memory);
+        // Free up temporary register
+        self.deallocate_register(index_of_element_in_memory);
+    }
+
+    /// Sets the item in the array at index `index` to `value`
+    pub(crate) fn codegen_array_set(
+        &mut self,
+        array_ptr: MemoryAddress,
+        index: SingleAddrVariable,
+        value: MemoryAddress,
+    ) {
+        assert!(index.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        // Computes array_ptr + index, ie array[index]
+        let index_of_element_in_memory = self.allocate_register();
+        self.binary_instruction(
+            SingleAddrVariable::new_usize(array_ptr),
+            index,
+            SingleAddrVariable::new_usize(index_of_element_in_memory),
+            BrilligBinaryOp::Add,
+        );
+
+        self.store_instruction(index_of_element_in_memory, value);
+        // Free up temporary register
+        self.deallocate_register(index_of_element_in_memory);
+    }
+
+    /// Copies the values of an array pointed by source with length stored in `num_elements_register`
+    /// Into the array pointed by destination
+    pub(crate) fn codegen_copy_array(
+        &mut self,
+        source_pointer: MemoryAddress,
+        destination_pointer: MemoryAddress,
+        num_elements_variable: SingleAddrVariable,
+    ) {
+        assert!(num_elements_variable.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+
+        let value_register = self.allocate_register();
+
+        self.codegen_loop(num_elements_variable.address, |ctx, iterator| {
+            ctx.codegen_array_get(source_pointer, iterator, value_register);
+            ctx.codegen_array_set(destination_pointer, iterator, value_register);
+        });
+
+        self.deallocate_register(value_register);
+    }
+
+    /// Loads a variable stored previously
+    pub(crate) fn codegen_load_variable(
+        &mut self,
+        destination: BrilligVariable,
+        variable_pointer: MemoryAddress,
+    ) {
+        match destination {
+            BrilligVariable::SingleAddr(single_addr) => {
+                self.load_instruction(single_addr.address, variable_pointer);
+            }
+            BrilligVariable::BrilligArray(BrilligArray { pointer, size: _, rc }) => {
+                self.load_instruction(pointer, variable_pointer);
+
+                let rc_pointer = self.allocate_register();
+                self.mov_instruction(rc_pointer, variable_pointer);
+                self.codegen_usize_op_in_place(rc_pointer, BrilligBinaryOp::Add, 1_usize);
+
+                self.load_instruction(rc, rc_pointer);
+                self.deallocate_register(rc_pointer);
+            }
+            BrilligVariable::BrilligVector(BrilligVector { pointer, size, rc }) => {
+                self.load_instruction(pointer, variable_pointer);
+
+                let size_pointer = self.allocate_register();
+                self.mov_instruction(size_pointer, variable_pointer);
+                self.codegen_usize_op_in_place(size_pointer, BrilligBinaryOp::Add, 1_usize);
+
+                self.load_instruction(size, size_pointer);
+                self.deallocate_register(size_pointer);
+
+                let rc_pointer = self.allocate_register();
+                self.mov_instruction(rc_pointer, variable_pointer);
+                self.codegen_usize_op_in_place(rc_pointer, BrilligBinaryOp::Add, 2_usize);
+
+                self.load_instruction(rc, rc_pointer);
+                self.deallocate_register(rc_pointer);
+            }
+        }
+    }
+
+    /// Stores a variable by saving its registers to memory
+    pub(crate) fn codegen_store_variable(
+        &mut self,
+        variable_pointer: MemoryAddress,
+        source: BrilligVariable,
+    ) {
+        match source {
+            BrilligVariable::SingleAddr(single_addr) => {
+                self.store_instruction(variable_pointer, single_addr.address);
+            }
+            BrilligVariable::BrilligArray(BrilligArray { pointer, size: _, rc }) => {
+                self.store_instruction(variable_pointer, pointer);
+
+                let rc_pointer: MemoryAddress = self.allocate_register();
+                self.mov_instruction(rc_pointer, variable_pointer);
+                self.codegen_usize_op_in_place(rc_pointer, BrilligBinaryOp::Add, 1_usize);
+                self.store_instruction(rc_pointer, rc);
+                self.deallocate_register(rc_pointer);
+            }
+            BrilligVariable::BrilligVector(BrilligVector { pointer, size, rc }) => {
+                self.store_instruction(variable_pointer, pointer);
+
+                let size_pointer = self.allocate_register();
+                self.mov_instruction(size_pointer, variable_pointer);
+                self.codegen_usize_op_in_place(size_pointer, BrilligBinaryOp::Add, 1_usize);
+                self.store_instruction(size_pointer, size);
+
+                let rc_pointer: MemoryAddress = self.allocate_register();
+                self.mov_instruction(rc_pointer, variable_pointer);
+                self.codegen_usize_op_in_place(rc_pointer, BrilligBinaryOp::Add, 2_usize);
+                self.store_instruction(rc_pointer, rc);
+
+                self.deallocate_register(size_pointer);
+                self.deallocate_register(rc_pointer);
+            }
+        }
+    }
+
+    /// This instruction will reverse the order of the elements in a vector.
+    pub(crate) fn codegen_reverse_vector_in_place(&mut self, vector: BrilligVector) {
+        let iteration_count = self.allocate_register();
+        self.codegen_usize_op(vector.size, iteration_count, BrilligBinaryOp::UnsignedDiv, 2);
+
+        let start_value_register = self.allocate_register();
+        let index_at_end_of_array = self.allocate_register();
+        let end_value_register = self.allocate_register();
+
+        self.codegen_loop(iteration_count, |ctx, iterator_register| {
+            // Load both values
+            ctx.codegen_array_get(vector.pointer, iterator_register, start_value_register);
+
+            // The index at the end of array is size - 1 - iterator
+            ctx.mov_instruction(index_at_end_of_array, vector.size);
+            ctx.codegen_usize_op_in_place(index_at_end_of_array, BrilligBinaryOp::Sub, 1);
+            ctx.memory_op_instruction(
+                index_at_end_of_array,
+                iterator_register.address,
+                index_at_end_of_array,
+                BrilligBinaryOp::Sub,
+            );
+
+            ctx.codegen_array_get(
+                vector.pointer,
+                SingleAddrVariable::new_usize(index_at_end_of_array),
+                end_value_register,
+            );
+
+            // Write both values
+            ctx.codegen_array_set(vector.pointer, iterator_register, end_value_register);
+            ctx.codegen_array_set(
+                vector.pointer,
+                SingleAddrVariable::new_usize(index_at_end_of_array),
+                start_value_register,
+            );
+        });
+
+        self.deallocate_register(iteration_count);
+        self.deallocate_register(start_value_register);
+        self.deallocate_register(end_value_register);
+        self.deallocate_register(index_at_end_of_array);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
new file mode 100644
index 00000000000..1c30f0f848f
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
@@ -0,0 +1,26 @@
+use acvm::acir::brillig::MemoryAddress;
+
+use super::BrilligContext;
+
+impl BrilligContext {
+    /// This function moves values from a set of registers to another set of registers.
+    /// It first moves all sources to new allocated registers to avoid overwriting.
+    pub(crate) fn codegen_mov_registers_to_registers(
+        &mut self,
+        sources: Vec<MemoryAddress>,
+        destinations: Vec<MemoryAddress>,
+    ) {
+        let new_sources: Vec<_> = sources
+            .iter()
+            .map(|source| {
+                let new_source = self.allocate_register();
+                self.mov_instruction(new_source, *source);
+                new_source
+            })
+            .collect();
+        for (new_source, destination) in new_sources.iter().zip(destinations.iter()) {
+            self.mov_instruction(*destination, *new_source);
+            self.deallocate_register(*new_source);
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index e32ce6f6b92..fa99e968a31 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -2,10 +2,7 @@
 
 use super::BrilligBinaryOp;
 use crate::brillig::brillig_ir::ReservedRegisters;
-use acvm::acir::brillig::{
-    BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapArray, HeapVector, MemoryAddress, Value,
-    ValueOrArray,
-};
+use acvm::acir::brillig::{BlackBoxOp, HeapArray, HeapVector, MemoryAddress, Value, ValueOrArray};
 
 /// Trait for converting values into debug-friendly strings.
 trait DebugToString {
@@ -26,8 +23,8 @@ default_to_string_impl! { str usize u32 }
 
 impl DebugToString for MemoryAddress {
     fn debug_to_string(&self) -> String {
-        if *self == ReservedRegisters::stack_pointer() {
-            "Stack".into()
+        if *self == ReservedRegisters::free_memory_pointer() {
+            "FreeMem".into()
         } else if *self == ReservedRegisters::previous_stack_pointer() {
             "PrevStack".into()
         } else {
@@ -48,47 +45,23 @@ impl DebugToString for HeapVector {
     }
 }
 
-impl DebugToString for BinaryFieldOp {
-    fn debug_to_string(&self) -> String {
-        match self {
-            BinaryFieldOp::Add => "f+".into(),
-            BinaryFieldOp::Sub => "f-".into(),
-            BinaryFieldOp::Mul => "f*".into(),
-            BinaryFieldOp::Div => "f/".into(),
-            BinaryFieldOp::Equals => "f==".into(),
-        }
-    }
-}
-
-impl DebugToString for BinaryIntOp {
-    fn debug_to_string(&self) -> String {
-        match self {
-            BinaryIntOp::Add => "+".into(),
-            BinaryIntOp::Sub => "-".into(),
-            BinaryIntOp::Mul => "*".into(),
-            BinaryIntOp::Equals => "==".into(),
-            BinaryIntOp::SignedDiv => "/".into(),
-            BinaryIntOp::UnsignedDiv => "//".into(),
-            BinaryIntOp::LessThan => "<".into(),
-            BinaryIntOp::LessThanEquals => "<=".into(),
-            BinaryIntOp::And => "&&".into(),
-            BinaryIntOp::Or => "||".into(),
-            BinaryIntOp::Xor => "^".into(),
-            BinaryIntOp::Shl => "<<".into(),
-            BinaryIntOp::Shr => ">>".into(),
-        }
-    }
-}
-
 impl DebugToString for BrilligBinaryOp {
     fn debug_to_string(&self) -> String {
         match self {
-            BrilligBinaryOp::Field(op) => op.debug_to_string(),
-            BrilligBinaryOp::Integer(op) => op.debug_to_string(),
-            BrilligBinaryOp::Modulo { is_signed_integer } => {
-                let op = if *is_signed_integer { "%" } else { "%%" };
-                op.into()
-            }
+            BrilligBinaryOp::Add => "+".into(),
+            BrilligBinaryOp::Sub => "-".into(),
+            BrilligBinaryOp::Mul => "*".into(),
+            BrilligBinaryOp::Equals => "==".into(),
+            BrilligBinaryOp::FieldDiv => "f/".into(),
+            BrilligBinaryOp::UnsignedDiv => "/".into(),
+            BrilligBinaryOp::LessThan => "<".into(),
+            BrilligBinaryOp::LessThanEquals => "<=".into(),
+            BrilligBinaryOp::And => "&&".into(),
+            BrilligBinaryOp::Or => "||".into(),
+            BrilligBinaryOp::Xor => "^".into(),
+            BrilligBinaryOp::Shl => "<<".into(),
+            BrilligBinaryOp::Shr => ">>".into(),
+            BrilligBinaryOp::Modulo => "%".into(),
         }
     }
 }
@@ -143,17 +116,6 @@ impl DebugShow {
         debug_println!(self.enable_debug_trace, "  ASSERT {} != 0", condition);
     }
 
-    /// Processes a return instruction.
-    pub(crate) fn return_instruction(&self, return_registers: &[MemoryAddress]) {
-        let registers_string = return_registers
-            .iter()
-            .map(MemoryAddress::debug_to_string)
-            .collect::<Vec<String>>()
-            .join(", ");
-
-        debug_println!(self.enable_debug_trace, "  // return {};", registers_string);
-    }
-
     /// Emits a `mov` instruction.
     pub(crate) fn mov_instruction(&self, destination: MemoryAddress, source: MemoryAddress) {
         debug_println!(self.enable_debug_trace, "  MOV {}, {}", destination, source);
@@ -240,64 +202,17 @@ impl DebugShow {
         debug_println!(self.enable_debug_trace, "  STOP");
     }
 
-    /// Debug function for allocate_array_instruction
-    pub(crate) fn allocate_array_instruction(
-        &self,
-        pointer_register: MemoryAddress,
-        size_register: MemoryAddress,
-    ) {
-        debug_println!(
-            self.enable_debug_trace,
-            "  ALLOCATE_ARRAY {} SIZE {}",
-            pointer_register,
-            size_register
-        );
-    }
-
-    /// Debug function for allocate_instruction
-    pub(crate) fn allocate_instruction(&self, pointer_register: MemoryAddress) {
-        debug_println!(self.enable_debug_trace, "  ALLOCATE {} ", pointer_register);
-    }
-
-    /// Debug function for array_get
-    pub(crate) fn array_get(
-        &self,
-        array_ptr: MemoryAddress,
-        index: MemoryAddress,
-        result: MemoryAddress,
-    ) {
-        debug_println!(
-            self.enable_debug_trace,
-            "  ARRAY_GET {}[{}] -> {}",
-            array_ptr,
-            index,
-            result
-        );
-    }
-
-    /// Debug function for array_set
-    pub(crate) fn array_set(
-        &self,
-        array_ptr: MemoryAddress,
-        index: MemoryAddress,
-        value: MemoryAddress,
-    ) {
-        debug_println!(self.enable_debug_trace, "  ARRAY_SET {}[{}] = {}", array_ptr, index, value);
-    }
-
-    /// Debug function for copy_array_instruction
-    pub(crate) fn copy_array_instruction(
+    /// Emits a external stop instruction (returns data)
+    pub(crate) fn external_stop_instruction(
         &self,
-        source: MemoryAddress,
-        destination: MemoryAddress,
-        num_elements_register: MemoryAddress,
+        return_data_offset: usize,
+        return_data_size: usize,
     ) {
         debug_println!(
             self.enable_debug_trace,
-            "  COPY_ARRAY {} -> {} ({} ELEMENTS)",
-            source,
-            destination,
-            num_elements_register
+            "  EXT_STOP {}..{}",
+            return_data_offset,
+            return_data_offset + return_data_size
         );
     }
 
@@ -328,22 +243,6 @@ impl DebugShow {
         );
     }
 
-    /// Debug function for cast_instruction
-    pub(crate) fn truncate_instruction(
-        &self,
-        destination: MemoryAddress,
-        source: MemoryAddress,
-        target_bit_size: u32,
-    ) {
-        debug_println!(
-            self.enable_debug_trace,
-            "  TRUNCATE {} FROM {} TO {} BITS",
-            destination,
-            source,
-            target_bit_size
-        );
-    }
-
     /// Debug function for black_box_op
     pub(crate) fn black_box_op_instruction(&self, op: &BlackBoxOp) {
         match op {
@@ -529,4 +428,20 @@ impl DebugShow {
     pub(crate) fn add_external_call_instruction(&self, func_label: String) {
         debug_println!(self.enable_debug_trace, "  CALL {}", func_label);
     }
+
+    /// Debug function for calldata_copy
+    pub(crate) fn calldata_copy_instruction(
+        &self,
+        destination: MemoryAddress,
+        calldata_size: usize,
+        offset: usize,
+    ) {
+        debug_println!(
+            self.enable_debug_trace,
+            "  CALLDATA_COPY {} {}..{}",
+            destination,
+            offset,
+            offset + calldata_size
+        );
+    }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 83440e4a51d..14c4ada8606 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -3,12 +3,9 @@ use super::{
     brillig_variable::{BrilligArray, BrilligVariable, SingleAddrVariable},
     debug_show::DebugShow,
     registers::BrilligRegistersContext,
-    BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-};
-use acvm::{
-    acir::brillig::{MemoryAddress, Opcode as BrilligOpcode},
-    FieldElement,
+    BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
+use acvm::{acir::brillig::MemoryAddress, FieldElement};
 
 pub(crate) const MAX_STACK_SIZE: usize = 1024;
 
@@ -28,18 +25,18 @@ impl BrilligContext {
             debug_show: DebugShow::new(false),
         };
 
-        context.entry_point_instruction(&arguments, &return_parameters);
+        context.codegen_entry_point(&arguments, &return_parameters);
 
         context.add_external_call_instruction(target_function);
 
-        context.exit_point_instruction(&arguments, &return_parameters);
+        context.codegen_exit_point(&arguments, &return_parameters);
         context.artifact()
     }
 
     /// Adds the instructions needed to handle entry point parameters
     /// The runtime will leave the parameters in calldata.
     /// Arrays will be passed flattened.
-    fn entry_point_instruction(
+    fn codegen_entry_point(
         &mut self,
         arguments: &[BrilligParameter],
         return_parameters: &[BrilligParameter],
@@ -48,11 +45,10 @@ impl BrilligContext {
         let return_data_size = BrilligContext::flattened_tuple_size(return_parameters);
 
         // Set initial value of stack pointer: MAX_STACK_SIZE + calldata_size + return_data_size
-        self.push_opcode(BrilligOpcode::Const {
-            destination: ReservedRegisters::stack_pointer(),
-            value: (MAX_STACK_SIZE + calldata_size + return_data_size).into(),
-            bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-        });
+        self.const_instruction(
+            SingleAddrVariable::new_usize(ReservedRegisters::free_memory_pointer()),
+            (MAX_STACK_SIZE + calldata_size + return_data_size).into(),
+        );
 
         // Copy calldata
         self.copy_and_cast_calldata(arguments);
@@ -75,8 +71,8 @@ impl BrilligContext {
                 }
                 BrilligParameter::Array(_, _) => {
                     let pointer_to_the_array_in_calldata =
-                        self.make_usize_constant(current_calldata_pointer.into());
-                    let rc_register = self.make_usize_constant(1_usize.into());
+                        self.make_usize_constant_instruction(current_calldata_pointer.into());
+                    let rc_register = self.make_usize_constant_instruction(1_usize.into());
                     let flattened_size = BrilligContext::flattened_size(argument);
                     let var = BrilligVariable::BrilligArray(BrilligArray {
                         pointer: pointer_to_the_array_in_calldata.address,
@@ -111,11 +107,7 @@ impl BrilligContext {
 
     fn copy_and_cast_calldata(&mut self, arguments: &[BrilligParameter]) {
         let calldata_size = BrilligContext::flattened_tuple_size(arguments);
-        self.push_opcode(BrilligOpcode::CalldataCopy {
-            destination_address: MemoryAddress(MAX_STACK_SIZE),
-            size: calldata_size,
-            offset: 0,
-        });
+        self.calldata_copy_instruction(MemoryAddress(MAX_STACK_SIZE), calldata_size, 0);
 
         fn flat_bit_sizes(param: &BrilligParameter) -> Box<dyn Iterator<Item = u32> + '_> {
             match param {
@@ -130,11 +122,10 @@ impl BrilligContext {
         for (i, bit_size) in arguments.iter().flat_map(flat_bit_sizes).enumerate() {
             // Calldatacopy tags everything with field type, so when downcast when necessary
             if bit_size < FieldElement::max_num_bits() {
-                self.push_opcode(BrilligOpcode::Cast {
-                    destination: MemoryAddress(MAX_STACK_SIZE + i),
-                    source: MemoryAddress(MAX_STACK_SIZE + i),
-                    bit_size,
-                });
+                self.cast_instruction(
+                    SingleAddrVariable::new(MemoryAddress(MAX_STACK_SIZE + i), bit_size),
+                    SingleAddrVariable::new_field(MemoryAddress(MAX_STACK_SIZE + i)),
+                );
             }
         }
     }
@@ -178,7 +169,7 @@ impl BrilligContext {
             let target_item_size = item_type.len();
             let source_item_size = BrilligContext::flattened_tuple_size(item_type);
 
-            self.allocate_fixed_length_array(
+            self.codegen_allocate_fixed_length_array(
                 deflattened_array_pointer,
                 item_count * target_item_size,
             );
@@ -190,20 +181,22 @@ impl BrilligContext {
                 let mut source_offset = 0;
 
                 for (subitem_index, subitem) in item_type.iter().enumerate() {
-                    let source_index =
-                        self.make_usize_constant((source_item_base_index + source_offset).into());
+                    let source_index = self.make_usize_constant_instruction(
+                        (source_item_base_index + source_offset).into(),
+                    );
 
-                    let target_index =
-                        self.make_usize_constant((target_item_base_index + subitem_index).into());
+                    let target_index = self.make_usize_constant_instruction(
+                        (target_item_base_index + subitem_index).into(),
+                    );
 
                     match subitem {
                         BrilligParameter::SingleAddr(_) => {
-                            self.array_get(
+                            self.codegen_array_get(
                                 flattened_array_pointer,
                                 source_index,
                                 movement_register,
                             );
-                            self.array_set(
+                            self.codegen_array_set(
                                 deflattened_array_pointer,
                                 target_index,
                                 movement_register,
@@ -216,11 +209,11 @@ impl BrilligContext {
                         ) => {
                             let nested_array_pointer = self.allocate_register();
                             self.mov_instruction(nested_array_pointer, flattened_array_pointer);
-                            self.memory_op(
+                            self.memory_op_instruction(
                                 nested_array_pointer,
                                 source_index.address,
                                 nested_array_pointer,
-                                acvm::brillig_vm::brillig::BinaryIntOp::Add,
+                                BrilligBinaryOp::Add,
                             );
                             let deflattened_nested_array_pointer = self.deflatten_array(
                                 nested_array_item_type,
@@ -229,17 +222,21 @@ impl BrilligContext {
                             );
                             let reference = self.allocate_register();
                             let rc = self.allocate_register();
-                            self.usize_const(rc, 1_usize.into());
+                            self.usize_const_instruction(rc, 1_usize.into());
 
-                            self.allocate_array_reference_instruction(reference);
+                            self.codegen_allocate_array_reference(reference);
                             let array_variable = BrilligVariable::BrilligArray(BrilligArray {
                                 pointer: deflattened_nested_array_pointer,
                                 size: nested_array_item_type.len() * nested_array_item_count,
                                 rc,
                             });
-                            self.store_variable_instruction(reference, array_variable);
+                            self.codegen_store_variable(reference, array_variable);
 
-                            self.array_set(deflattened_array_pointer, target_index, reference);
+                            self.codegen_array_set(
+                                deflattened_array_pointer,
+                                target_index,
+                                reference,
+                            );
 
                             self.deallocate_register(nested_array_pointer);
                             self.deallocate_register(reference);
@@ -272,7 +269,7 @@ impl BrilligContext {
     /// The runtime expects the results in a contiguous memory region.
     /// Arrays are expected to be returned with all the nested arrays flattened.
     /// However, the function called returns variables (that have extra data) and the returned arrays are deflattened.
-    fn exit_point_instruction(
+    fn codegen_exit_point(
         &mut self,
         arguments: &[BrilligParameter],
         return_parameters: &[BrilligParameter],
@@ -318,7 +315,8 @@ impl BrilligContext {
                 }
                 BrilligParameter::Array(item_type, item_count) => {
                     let returned_pointer = returned_variable.extract_array().pointer;
-                    let pointer_to_return_data = self.make_usize_constant(return_data_index.into());
+                    let pointer_to_return_data =
+                        self.make_usize_constant_instruction(return_data_index.into());
 
                     self.flatten_array(
                         item_type,
@@ -336,7 +334,7 @@ impl BrilligContext {
             }
         }
 
-        self.push_opcode(BrilligOpcode::Stop { return_data_offset, return_data_size });
+        self.external_stop_instruction(return_data_offset, return_data_size);
     }
 
     // Flattens an array by recursively copying nested arrays and regular items.
@@ -361,19 +359,21 @@ impl BrilligContext {
                 let mut target_offset = 0;
 
                 for (subitem_index, subitem) in item_type.iter().enumerate() {
-                    let source_index =
-                        self.make_usize_constant((source_item_base_index + subitem_index).into());
-                    let target_index =
-                        self.make_usize_constant((target_item_base_index + target_offset).into());
+                    let source_index = self.make_usize_constant_instruction(
+                        (source_item_base_index + subitem_index).into(),
+                    );
+                    let target_index = self.make_usize_constant_instruction(
+                        (target_item_base_index + target_offset).into(),
+                    );
 
                     match subitem {
                         BrilligParameter::SingleAddr(_) => {
-                            self.array_get(
+                            self.codegen_array_get(
                                 deflattened_array_pointer,
                                 source_index,
                                 movement_register,
                             );
-                            self.array_set(
+                            self.codegen_array_set(
                                 flattened_array_pointer,
                                 target_index,
                                 movement_register,
@@ -385,7 +385,7 @@ impl BrilligContext {
                             nested_array_item_count,
                         ) => {
                             let nested_array_reference = self.allocate_register();
-                            self.array_get(
+                            self.codegen_array_get(
                                 deflattened_array_pointer,
                                 source_index,
                                 nested_array_reference,
@@ -398,7 +398,7 @@ impl BrilligContext {
                                     rc: self.allocate_register(),
                                 });
 
-                            self.load_variable_instruction(
+                            self.codegen_load_variable(
                                 nested_array_variable,
                                 nested_array_reference,
                             );
@@ -410,11 +410,11 @@ impl BrilligContext {
                                 flattened_array_pointer,
                             );
 
-                            self.memory_op(
+                            self.memory_op_instruction(
                                 flattened_nested_array_pointer,
                                 target_index.address,
                                 flattened_nested_array_pointer,
-                                acvm::brillig_vm::brillig::BinaryIntOp::Add,
+                                BrilligBinaryOp::Add,
                             );
 
                             self.flatten_array(
@@ -443,12 +443,9 @@ impl BrilligContext {
 
             self.deallocate_register(movement_register);
         } else {
-            let item_count = self.make_usize_constant((item_count * item_type.len()).into());
-            self.copy_array_instruction(
-                deflattened_array_pointer,
-                flattened_array_pointer,
-                item_count,
-            );
+            let item_count =
+                self.make_usize_constant_instruction((item_count * item_type.len()).into());
+            self.codegen_copy_array(deflattened_array_pointer, flattened_array_pointer, item_count);
             self.deallocate_single_addr(item_count);
         }
     }
@@ -493,7 +490,7 @@ mod tests {
         context.load_instruction(array_pointer, array_pointer);
         context.load_instruction(array_value, array_pointer);
 
-        context.return_instruction(&[array_value]);
+        context.codegen_return(&[array_value]);
 
         let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
         let (vm, return_data_offset, return_data_size) =
@@ -531,7 +528,7 @@ mod tests {
             rc: context.allocate_register(),
         };
 
-        context.return_instruction(&brillig_array.extract_registers());
+        context.codegen_return(&brillig_array.extract_registers());
 
         let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
         let (vm, return_data_pointer, return_data_size) =
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
new file mode 100644
index 00000000000..5c2a6bfacca
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -0,0 +1,522 @@
+use acvm::{
+    acir::brillig::{
+        BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapValueType, MemoryAddress,
+        Opcode as BrilligOpcode, Value, ValueOrArray,
+    },
+    FieldElement,
+};
+
+use super::{
+    artifact::UnresolvedJumpLocation,
+    brillig_variable::{BrilligArray, BrilligVector, SingleAddrVariable},
+    BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+};
+
+/// Low level instructions of the brillig IR, used by the brillig ir codegens and brillig_gen
+/// Printed using debug_slow
+impl BrilligContext {
+    /// Processes a binary instruction according `operation`.
+    ///
+    /// This method will compute lhs <operation> rhs
+    /// and store the result in the `result` register.
+    pub(crate) fn binary_instruction(
+        &mut self,
+        lhs: SingleAddrVariable,
+        rhs: SingleAddrVariable,
+        result: SingleAddrVariable,
+        operation: BrilligBinaryOp,
+    ) {
+        self.debug_show.binary_instruction(lhs.address, rhs.address, result.address, operation);
+        self.binary(lhs, rhs, result, operation);
+    }
+
+    /// Processes a not instruction.
+    ///
+    /// Not is computed using a subtraction operation as there is no native not instruction
+    /// in Brillig.
+    pub(crate) fn not_instruction(
+        &mut self,
+        input: SingleAddrVariable,
+        result: SingleAddrVariable,
+    ) {
+        self.debug_show.not_instruction(input.address, input.bit_size, result.address);
+        // Compile !x as ((-1) - x)
+        let u_max = FieldElement::from(2_i128).pow(&FieldElement::from(input.bit_size as i128))
+            - FieldElement::one();
+        let max = self.make_constant(Value::from(u_max), input.bit_size);
+
+        self.binary(max, input, result, BrilligBinaryOp::Sub);
+        self.deallocate_single_addr(max);
+    }
+
+    /// Utility method to perform a binary instruction with a memory address
+    pub(crate) fn memory_op_instruction(
+        &mut self,
+        lhs: MemoryAddress,
+        rhs: MemoryAddress,
+        destination: MemoryAddress,
+        op: BrilligBinaryOp,
+    ) {
+        self.binary_instruction(
+            SingleAddrVariable::new_usize(lhs),
+            SingleAddrVariable::new_usize(rhs),
+            SingleAddrVariable::new(
+                destination,
+                BrilligContext::binary_result_bit_size(op, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
+            ),
+            op,
+        );
+    }
+
+    fn binary(
+        &mut self,
+        lhs: SingleAddrVariable,
+        rhs: SingleAddrVariable,
+        result: SingleAddrVariable,
+        operation: BrilligBinaryOp,
+    ) {
+        assert!(
+            lhs.bit_size == rhs.bit_size,
+            "Not equal bit size for lhs and rhs: lhs {}, rhs {}",
+            lhs.bit_size,
+            rhs.bit_size
+        );
+        let is_field_op = lhs.bit_size == FieldElement::max_num_bits();
+        let expected_result_bit_size =
+            BrilligContext::binary_result_bit_size(operation, lhs.bit_size);
+        assert!(
+            result.bit_size == expected_result_bit_size,
+            "Expected result bit size to be {}, got {} for operation {:?}",
+            expected_result_bit_size,
+            result.bit_size,
+            operation
+        );
+
+        if let BrilligBinaryOp::Modulo = operation {
+            self.modulo(result, lhs, rhs);
+        } else if is_field_op {
+            self.push_opcode(BrilligOpcode::BinaryFieldOp {
+                op: operation.into(),
+                destination: result.address,
+                lhs: lhs.address,
+                rhs: rhs.address,
+            });
+        } else {
+            self.push_opcode(BrilligOpcode::BinaryIntOp {
+                op: operation.into(),
+                destination: result.address,
+                bit_size: lhs.bit_size,
+                lhs: lhs.address,
+                rhs: rhs.address,
+            });
+        }
+    }
+
+    /// Computes left % right by emitting the necessary Brillig opcodes.
+    ///
+    /// This is done by using the following formula:
+    ///
+    /// a % b = a - (b * (a / b))
+    ///
+    /// Brillig does not have an explicit modulo operation,
+    /// so we must emit multiple opcodes and process it differently
+    /// to other binary instructions.
+    fn modulo(
+        &mut self,
+        result: SingleAddrVariable,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+    ) {
+        assert!(
+            left.bit_size == right.bit_size,
+            "Not equal bitsize: lhs {}, rhs {}",
+            left.bit_size,
+            right.bit_size
+        );
+        let bit_size = left.bit_size;
+
+        let scratch_var_i = SingleAddrVariable::new(self.allocate_register(), bit_size);
+        let scratch_var_j = SingleAddrVariable::new(self.allocate_register(), bit_size);
+
+        // i = left / right
+        self.binary(left, right, scratch_var_i, BrilligBinaryOp::UnsignedDiv);
+
+        // j = i * right
+        self.binary(scratch_var_i, right, scratch_var_j, BrilligBinaryOp::Mul);
+
+        // result_register = left - j
+        self.binary(left, scratch_var_j, result, BrilligBinaryOp::Sub);
+        // Free scratch registers
+        self.deallocate_single_addr(scratch_var_i);
+        self.deallocate_single_addr(scratch_var_j);
+    }
+
+    fn binary_result_bit_size(operation: BrilligBinaryOp, arguments_bit_size: u32) -> u32 {
+        match operation {
+            BrilligBinaryOp::Equals
+            | BrilligBinaryOp::LessThan
+            | BrilligBinaryOp::LessThanEquals => 1,
+            _ => arguments_bit_size,
+        }
+    }
+
+    /// Processes a foreign call instruction.
+    ///
+    /// Note: the function being called is external and will
+    /// not be linked during brillig generation.
+    pub(crate) fn foreign_call_instruction(
+        &mut self,
+        func_name: String,
+        inputs: &[ValueOrArray],
+        input_value_types: &[HeapValueType],
+        outputs: &[ValueOrArray],
+        output_value_types: &[HeapValueType],
+    ) {
+        self.debug_show.foreign_call_instruction(func_name.clone(), inputs, outputs);
+
+        assert!(inputs.len() == input_value_types.len());
+        assert!(outputs.len() == output_value_types.len());
+
+        self.push_opcode(BrilligOpcode::ForeignCall {
+            function: func_name,
+            destinations: outputs.to_vec(),
+            destination_value_types: output_value_types.to_vec(),
+            inputs: inputs.to_vec(),
+            input_value_types: input_value_types.to_vec(),
+        });
+    }
+
+    /// Adds a unresolved external `Call` instruction to the bytecode.
+    /// This calls into another function compiled into this brillig artifact.
+    pub(crate) fn add_external_call_instruction<T: ToString>(&mut self, func_label: T) {
+        self.debug_show.add_external_call_instruction(func_label.to_string());
+        self.obj.add_unresolved_external_call(
+            BrilligOpcode::Call { location: 0 },
+            func_label.to_string(),
+        );
+    }
+
+    /// Adds a unresolved `Jump` instruction to the bytecode.
+    pub(crate) fn jump_instruction<T: ToString>(&mut self, target_label: T) {
+        self.debug_show.jump_instruction(target_label.to_string());
+        self.add_unresolved_jump(BrilligOpcode::Jump { location: 0 }, target_label.to_string());
+    }
+
+    /// Adds a unresolved `JumpIf` instruction to the bytecode.
+    pub(crate) fn jump_if_instruction<T: ToString>(
+        &mut self,
+        condition: MemoryAddress,
+        target_label: T,
+    ) {
+        self.debug_show.jump_if_instruction(condition, target_label.to_string());
+        self.add_unresolved_jump(
+            BrilligOpcode::JumpIf { condition, location: 0 },
+            target_label.to_string(),
+        );
+    }
+
+    /// Emits brillig bytecode to jump to a trap condition if `condition`
+    /// is false.
+    pub(crate) fn constrain_instruction(
+        &mut self,
+        condition: SingleAddrVariable,
+        assert_message: Option<String>,
+    ) {
+        self.debug_show.constrain_instruction(condition.address);
+
+        assert!(condition.bit_size == 1);
+
+        let (next_section, next_label) = self.reserve_next_section_label();
+        self.add_unresolved_jump(
+            BrilligOpcode::JumpIf { condition: condition.address, location: 0 },
+            next_label,
+        );
+        self.push_opcode(BrilligOpcode::Trap);
+        if let Some(assert_message) = assert_message {
+            self.obj.add_assert_message_to_last_opcode(assert_message);
+        }
+        self.enter_section(next_section);
+    }
+
+    /// Adds a unresolved `Jump` to the bytecode.
+    fn add_unresolved_jump(
+        &mut self,
+        jmp_instruction: BrilligOpcode,
+        destination: UnresolvedJumpLocation,
+    ) {
+        self.obj.add_unresolved_jump(jmp_instruction, destination);
+    }
+
+    /// Adds a label to the next opcode
+    pub(crate) fn enter_context<T: ToString>(&mut self, label: T) {
+        self.debug_show.enter_context(label.to_string());
+        self.context_label = label.to_string();
+        self.section_label = 0;
+        // Add a context label to the next opcode
+        self.obj.add_label_at_position(label.to_string(), self.obj.index_of_next_opcode());
+        // Add a section label to the next opcode
+        self.obj
+            .add_label_at_position(self.current_section_label(), self.obj.index_of_next_opcode());
+    }
+
+    /// Enter the given section
+    pub(super) fn enter_section(&mut self, section: usize) {
+        self.section_label = section;
+        self.obj
+            .add_label_at_position(self.current_section_label(), self.obj.index_of_next_opcode());
+    }
+
+    /// Create, reserve, and return a new section label.
+    pub(super) fn reserve_next_section_label(&mut self) -> (usize, String) {
+        let section = self.next_section;
+        self.next_section += 1;
+        (section, self.compute_section_label(section))
+    }
+
+    /// Internal function used to compute the section labels
+    fn compute_section_label(&self, section: usize) -> String {
+        format!("{}-{}", self.context_label, section)
+    }
+
+    /// Returns the current section label
+    fn current_section_label(&self) -> String {
+        self.compute_section_label(self.section_label)
+    }
+
+    /// Emits a stop instruction
+    pub(crate) fn stop_instruction(&mut self) {
+        self.debug_show.stop_instruction();
+        self.push_opcode(BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 });
+    }
+
+    /// Emits a external stop instruction (returns data)
+    pub(crate) fn external_stop_instruction(
+        &mut self,
+        return_data_offset: usize,
+        return_data_size: usize,
+    ) {
+        self.debug_show.external_stop_instruction(return_data_offset, return_data_size);
+        self.push_opcode(BrilligOpcode::Stop { return_data_offset, return_data_size });
+    }
+
+    /// Issues a blackbox operation.
+    pub(crate) fn black_box_op_instruction(&mut self, op: BlackBoxOp) {
+        self.debug_show.black_box_op_instruction(&op);
+        self.push_opcode(BrilligOpcode::BlackBox(op));
+    }
+
+    pub(crate) fn load_free_memory_pointer_instruction(&mut self, pointer_register: MemoryAddress) {
+        self.debug_show.mov_instruction(pointer_register, ReservedRegisters::free_memory_pointer());
+        self.push_opcode(BrilligOpcode::Mov {
+            destination: pointer_register,
+            source: ReservedRegisters::free_memory_pointer(),
+        });
+    }
+
+    pub(crate) fn increase_free_memory_pointer_instruction(
+        &mut self,
+        size_register: MemoryAddress,
+    ) {
+        self.memory_op_instruction(
+            ReservedRegisters::free_memory_pointer(),
+            size_register,
+            ReservedRegisters::free_memory_pointer(),
+            BrilligBinaryOp::Add,
+        );
+    }
+
+    /// Emits a store instruction
+    pub(crate) fn store_instruction(
+        &mut self,
+        destination_pointer: MemoryAddress,
+        source: MemoryAddress,
+    ) {
+        self.debug_show.store_instruction(destination_pointer, source);
+        self.push_opcode(BrilligOpcode::Store { destination_pointer, source });
+    }
+
+    /// Utility method to transform a HeapArray to a HeapVector by making a runtime constant with the size.
+    pub(crate) fn array_to_vector_instruction(&mut self, array: &BrilligArray) -> BrilligVector {
+        let size_register = self.make_usize_constant_instruction(array.size.into());
+        BrilligVector { size: size_register.address, pointer: array.pointer, rc: array.rc }
+    }
+
+    /// Emits a load instruction
+    pub(crate) fn load_instruction(
+        &mut self,
+        destination: MemoryAddress,
+        source_pointer: MemoryAddress,
+    ) {
+        self.debug_show.load_instruction(destination, source_pointer);
+        self.push_opcode(BrilligOpcode::Load { destination, source_pointer });
+    }
+
+    /// Emits a `mov` instruction.
+    ///
+    /// Copies the value at `source` into `destination`
+    pub(crate) fn mov_instruction(&mut self, destination: MemoryAddress, source: MemoryAddress) {
+        self.debug_show.mov_instruction(destination, source);
+        self.push_opcode(BrilligOpcode::Mov { destination, source });
+    }
+
+    /// Cast truncates the value to the given bit size and converts the type of the value in memory to that bit size.
+    pub(crate) fn cast_instruction(
+        &mut self,
+        destination: SingleAddrVariable,
+        source: SingleAddrVariable,
+    ) {
+        self.debug_show.cast_instruction(destination.address, source.address, destination.bit_size);
+        self.cast(destination, source);
+    }
+
+    pub(crate) fn cast(&mut self, destination: SingleAddrVariable, source: SingleAddrVariable) {
+        self.push_opcode(BrilligOpcode::Cast {
+            destination: destination.address,
+            source: source.address,
+            bit_size: destination.bit_size,
+        });
+    }
+
+    /// Stores the value of `constant` in the `result` register
+    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: Value) {
+        self.debug_show.const_instruction(result.address, constant);
+        self.constant(result, constant);
+    }
+
+    fn constant(&mut self, result: SingleAddrVariable, constant: Value) {
+        if result.bit_size > 128 && !constant.to_field().fits_in_u128() {
+            let high = Value::from(FieldElement::from_be_bytes_reduce(
+                constant
+                    .to_field()
+                    .to_be_bytes()
+                    .get(0..16)
+                    .expect("FieldElement::to_be_bytes() too short!"),
+            ));
+            let low = Value::from(constant.to_u128());
+            let high_register = SingleAddrVariable::new(self.allocate_register(), 254);
+            let low_register = SingleAddrVariable::new(self.allocate_register(), 254);
+            let intermediate_register = SingleAddrVariable::new(self.allocate_register(), 254);
+            self.constant(high_register, high);
+            self.constant(low_register, low);
+            // I want to multiply high by 2^128, but I can't get that big constant in.
+            // So I'll multiply by 2^64 twice.
+            self.constant(intermediate_register, Value::from(1_u128 << 64));
+            self.binary(high_register, intermediate_register, high_register, BrilligBinaryOp::Mul);
+            self.binary(high_register, intermediate_register, high_register, BrilligBinaryOp::Mul);
+            // Now we can add.
+            self.binary(high_register, low_register, intermediate_register, BrilligBinaryOp::Add);
+            self.cast(result, intermediate_register);
+            self.deallocate_single_addr(high_register);
+            self.deallocate_single_addr(low_register);
+            self.deallocate_single_addr(intermediate_register);
+        } else {
+            self.push_opcode(BrilligOpcode::Const {
+                destination: result.address,
+                value: constant,
+                bit_size: result.bit_size,
+            });
+        }
+    }
+
+    pub(crate) fn usize_const_instruction(&mut self, result: MemoryAddress, constant: Value) {
+        self.const_instruction(SingleAddrVariable::new_usize(result), constant);
+    }
+
+    /// Returns a register which holds the value of a constant
+    pub(crate) fn make_constant_instruction(
+        &mut self,
+        constant: Value,
+        bit_size: u32,
+    ) -> SingleAddrVariable {
+        let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
+        self.const_instruction(var, constant);
+        var
+    }
+
+    fn make_constant(&mut self, constant: Value, bit_size: u32) -> SingleAddrVariable {
+        let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
+        self.constant(var, constant);
+        var
+    }
+
+    /// Returns a register which holds the value of an usize constant
+    pub(crate) fn make_usize_constant_instruction(
+        &mut self,
+        constant: Value,
+    ) -> SingleAddrVariable {
+        let register = self.allocate_register();
+        self.usize_const_instruction(register, constant);
+        SingleAddrVariable::new_usize(register)
+    }
+
+    pub(super) fn calldata_copy_instruction(
+        &mut self,
+        destination: MemoryAddress,
+        calldata_size: usize,
+        offset: usize,
+    ) {
+        self.debug_show.calldata_copy_instruction(destination, calldata_size, offset);
+
+        self.push_opcode(BrilligOpcode::CalldataCopy {
+            destination_address: destination,
+            size: calldata_size,
+            offset,
+        });
+    }
+}
+
+/// Type to encapsulate the binary operation types in Brillig
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum BrilligBinaryOp {
+    Add,
+    Sub,
+    Mul,
+    FieldDiv,
+    UnsignedDiv,
+    Equals,
+    LessThan,
+    LessThanEquals,
+    And,
+    Or,
+    Xor,
+    Shl,
+    Shr,
+    // Modulo operation requires more than one brillig opcode
+    Modulo,
+}
+
+impl From<BrilligBinaryOp> for BinaryFieldOp {
+    fn from(operation: BrilligBinaryOp) -> BinaryFieldOp {
+        match operation {
+            BrilligBinaryOp::Add => BinaryFieldOp::Add,
+            BrilligBinaryOp::Sub => BinaryFieldOp::Sub,
+            BrilligBinaryOp::Mul => BinaryFieldOp::Mul,
+            BrilligBinaryOp::FieldDiv => BinaryFieldOp::Div,
+            BrilligBinaryOp::UnsignedDiv => BinaryFieldOp::IntegerDiv,
+            BrilligBinaryOp::Equals => BinaryFieldOp::Equals,
+            BrilligBinaryOp::LessThan => BinaryFieldOp::LessThan,
+            BrilligBinaryOp::LessThanEquals => BinaryFieldOp::LessThanEquals,
+            _ => panic!("Unsupported operation: {:?} on a field", operation),
+        }
+    }
+}
+
+impl From<BrilligBinaryOp> for BinaryIntOp {
+    fn from(operation: BrilligBinaryOp) -> BinaryIntOp {
+        match operation {
+            BrilligBinaryOp::Add => BinaryIntOp::Add,
+            BrilligBinaryOp::Sub => BinaryIntOp::Sub,
+            BrilligBinaryOp::Mul => BinaryIntOp::Mul,
+            BrilligBinaryOp::UnsignedDiv => BinaryIntOp::Div,
+            BrilligBinaryOp::Equals => BinaryIntOp::Equals,
+            BrilligBinaryOp::LessThan => BinaryIntOp::LessThan,
+            BrilligBinaryOp::LessThanEquals => BinaryIntOp::LessThanEquals,
+            BrilligBinaryOp::And => BinaryIntOp::And,
+            BrilligBinaryOp::Or => BinaryIntOp::Or,
+            BrilligBinaryOp::Xor => BinaryIntOp::Xor,
+            BrilligBinaryOp::Shl => BinaryIntOp::Shl,
+            BrilligBinaryOp::Shr => BinaryIntOp::Shr,
+            _ => panic!("Unsupported operation: {:?} on an integer", operation),
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
index 8c0e36215a9..f756f06aa69 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
@@ -2,7 +2,7 @@ use acvm::acir::brillig::MemoryAddress;
 
 use crate::brillig::brillig_ir::entry_point::MAX_STACK_SIZE;
 
-use super::ReservedRegisters;
+use super::{brillig_variable::SingleAddrVariable, BrilligContext, ReservedRegisters};
 
 /// Every brillig stack frame/call context has its own view of register space.
 /// This is maintained by copying these registers to the stack during calls and reading them back.
@@ -81,3 +81,29 @@ impl BrilligRegistersContext {
         self.deallocated_registers.push(register_index);
     }
 }
+
+impl BrilligContext {
+    /// Returns the i'th register after the reserved ones
+    pub(crate) fn register(&self, i: usize) -> MemoryAddress {
+        MemoryAddress::from(ReservedRegisters::NUM_RESERVED_REGISTERS + i)
+    }
+
+    /// Allocates an unused register.
+    pub(crate) fn allocate_register(&mut self) -> MemoryAddress {
+        self.registers.allocate_register()
+    }
+
+    pub(crate) fn set_allocated_registers(&mut self, allocated_registers: Vec<MemoryAddress>) {
+        self.registers = BrilligRegistersContext::from_preallocated_registers(allocated_registers);
+    }
+
+    /// Push a register to the deallocation list, ready for reuse.
+    pub(crate) fn deallocate_register(&mut self, register_index: MemoryAddress) {
+        self.registers.deallocate_register(register_index);
+    }
+
+    /// Deallocates the address where the single address variable is stored
+    pub(crate) fn deallocate_single_addr(&mut self, var: SingleAddrVariable) {
+        self.deallocate_register(var.address);
+    }
+}
diff --git a/test_programs/execution_success/brillig_signed_div/Nargo.toml b/test_programs/execution_success/brillig_signed_div/Nargo.toml
new file mode 100644
index 00000000000..4bb9c5ecc1c
--- /dev/null
+++ b/test_programs/execution_success/brillig_signed_div/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "brillig_signed_div"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_signed_div/Prover.toml b/test_programs/execution_success/brillig_signed_div/Prover.toml
new file mode 100644
index 00000000000..be93fec5cc3
--- /dev/null
+++ b/test_programs/execution_success/brillig_signed_div/Prover.toml
@@ -0,0 +1,75 @@
+[[ops]]
+lhs = 4
+rhs = 255    # -1
+result = 252 # -4
+
+[[ops]]
+lhs = 4
+rhs = 254    # -2
+result = 254 # -2
+
+[[ops]]
+lhs = 4
+rhs = 253    # -3
+result = 255 # -1
+
+[[ops]]
+lhs = 4
+rhs = 252    # -4
+result = 255 # -1
+
+[[ops]]
+lhs = 4
+rhs = 251  # -5
+result = 0
+
+[[ops]]
+lhs = 252  # -4
+rhs = 255  # -1
+result = 4
+
+[[ops]]
+lhs = 252  # -4
+rhs = 254  # -2
+result = 2
+
+[[ops]]
+lhs = 252  # -4
+rhs = 253  # -3
+result = 1
+
+[[ops]]
+lhs = 252  # -4
+rhs = 252  # -4
+result = 1
+
+[[ops]]
+lhs = 252  # -4
+rhs = 251  # -5
+result = 0
+
+
+[[ops]]
+lhs = 4
+rhs = 1
+result = 4
+
+[[ops]]
+lhs = 4
+rhs = 2
+result = 2
+
+[[ops]]
+lhs = 4
+rhs = 3
+result = 1
+
+[[ops]]
+lhs = 4
+rhs = 4
+result = 1
+
+[[ops]]
+lhs = 4
+rhs = 5
+result = 0
diff --git a/test_programs/execution_success/brillig_signed_div/src/main.nr b/test_programs/execution_success/brillig_signed_div/src/main.nr
new file mode 100644
index 00000000000..bc3f5c3bdc0
--- /dev/null
+++ b/test_programs/execution_success/brillig_signed_div/src/main.nr
@@ -0,0 +1,11 @@
+struct SignedDivOp {
+    lhs: i8,
+    rhs: i8,
+    result: i8,
+}
+
+unconstrained fn main(ops: [SignedDivOp; 15]) {
+    for i in 0..15 {
+        assert_eq(ops[i].lhs / ops[i].rhs, ops[i].result);
+    }
+}
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 0bd2b1c076a..2eae9e1f07e 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.26.3";
+const VERSION: &str = "0.29.0";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index d94999f324b..09673d7fd4e 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.26.3",
+    "@aztec/bb.js": "0.29.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index 49485193532..dc3253de21a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.26.3":
-  version: 0.26.3
-  resolution: "@aztec/bb.js@npm:0.26.3"
+"@aztec/bb.js@npm:0.29.0":
+  version: 0.29.0
+  resolution: "@aztec/bb.js@npm:0.29.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 74c2b7ef5405f56472cf7c41d1c13261df07b1d5019e3ede9b63d218378e0fb73ccf5c52f1cc524505efad5799b347b497349d7c9b6fe82286014b1574f12309
+  checksum: ae2bae0eed1a64f79f4694d0b02a51b87bb00ef1d9a331193dc9ace69a47819d93b923114e95e77b9b4d3de28c94bf5bdd1e839b0236979aaa0cfcda7a04fa97
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.26.3
+    "@aztec/bb.js": 0.29.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 764f6a39c3b7321f7b7146fb0f486de9225b19c3 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 19 Mar 2024 12:02:25 +0000
Subject: [PATCH 092/416] chore: Add clarfiication on the difference in
 recursive aggregation circuits (#4567)

# Description

## Problem\*

Resolves comment here
https://github.com/noir-lang/noir/pull/4563#discussion_r1526534631

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../double_verify_nested_proof/src/main.nr         | 14 +++++++++++---
 .../double_verify_proof/src/main.nr                |  1 +
 .../double_verify_proof_recursive/src/main.nr      |  1 +
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/test_programs/execution_success/double_verify_nested_proof/src/main.nr b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
index 0466f2a226d..95d4b6f6995 100644
--- a/test_programs/execution_success/double_verify_nested_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
@@ -1,10 +1,18 @@
 use dep::std;
 
+// This circuit aggregates two recursive proofs from `double_verify_proof_recursive`.
+// Recursive aggregation is a backend-specific process and it is expected for backends 
+// to attach any extra data they may need (e.g. aggregation objects) to their proofs. 
+// Whether the proof we are verifying itself contains a recursive proof is expected to be 
+// a circuit constant by the barretenberg. Barretenberg hides this circuit constant in the 
+// proof serialization. Thus, we must have separate circuits for verifying a normal proof and a recursive proof
+// with two different proof sizes.
 fn main(
     verification_key: [Field; 114],
-    // This is the proof without public inputs attached.
-    // 
-    // This means: the size of this does not change with the number of public inputs.
+    // This is the proof without user-specified public inputs attached.
+    //
+    // This means: the size of this does not change with the number of public inputs unless
+    // they have been attached by the backend.
     proof: [Field; 109],
     public_inputs: pub [Field; 1],
     // This is currently not public. It is fine given that the vk is a part of the circuit definition.
diff --git a/test_programs/execution_success/double_verify_proof/src/main.nr b/test_programs/execution_success/double_verify_proof/src/main.nr
index 4edf5c5af9f..d832ce0f049 100644
--- a/test_programs/execution_success/double_verify_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof/src/main.nr
@@ -1,5 +1,6 @@
 use dep::std;
 
+// This circuit aggregates two proofs from `assert_statement_recursive`.
 fn main(
     verification_key: [Field; 114],
     // This is the proof without public inputs attached.
diff --git a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
index e4c6926efbc..86b4971c3a6 100644
--- a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
@@ -1,5 +1,6 @@
 use dep::std;
 
+// This circuit aggregates two proofs from `assert_statement_recursive`.
 #[recursive]
 fn main(
     verification_key: [Field; 114],

From 938d5e85eda00a05de5014e64d3dc9fc7c24936d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Tue, 19 Mar 2024 15:07:34 +0100
Subject: [PATCH 093/416] fix: Signed integer comparisons in brillig (#4579)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4286

## Summary\*

Fixes signed integer comparison by comparing biased versions of the two
operands

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 39 ++++++++++++++++++-
 .../brillig_signed_cmp/Nargo.toml             |  6 +++
 .../brillig_signed_cmp/Prover.toml            |  1 +
 .../brillig_signed_cmp/src/main.nr            |  8 ++++
 4 files changed, 53 insertions(+), 1 deletion(-)
 create mode 100644 test_programs/execution_success/brillig_signed_cmp/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_signed_cmp/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_signed_cmp/src/main.nr

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index f808bfac43b..a9eea74ddd9 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1306,7 +1306,14 @@ impl<'block> BrilligBlock<'block> {
             BinaryOp::Sub => BrilligBinaryOp::Sub,
             BinaryOp::Mul => BrilligBinaryOp::Mul,
             BinaryOp::Eq => BrilligBinaryOp::Equals,
-            BinaryOp::Lt => BrilligBinaryOp::LessThan,
+            BinaryOp::Lt => {
+                if is_signed {
+                    self.convert_signed_less_than(left, right, result_variable);
+                    return;
+                } else {
+                    BrilligBinaryOp::LessThan
+                }
+            }
             BinaryOp::And => BrilligBinaryOp::And,
             BinaryOp::Or => BrilligBinaryOp::Or,
             BinaryOp::Xor => BrilligBinaryOp::Xor,
@@ -1434,6 +1441,36 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.deallocate_single_addr(scratch_var_j);
     }
 
+    fn convert_signed_less_than(
+        &mut self,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+        result: SingleAddrVariable,
+    ) {
+        let biased_left =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), left.bit_size);
+        let biased_right =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), right.bit_size);
+
+        let bias = self
+            .brillig_context
+            .make_constant_instruction((1_u128 << (left.bit_size - 1)).into(), left.bit_size);
+
+        self.brillig_context.binary_instruction(left, bias, biased_left, BrilligBinaryOp::Add);
+        self.brillig_context.binary_instruction(right, bias, biased_right, BrilligBinaryOp::Add);
+
+        self.brillig_context.binary_instruction(
+            biased_left,
+            biased_right,
+            result,
+            BrilligBinaryOp::LessThan,
+        );
+
+        self.brillig_context.deallocate_single_addr(biased_left);
+        self.brillig_context.deallocate_single_addr(biased_right);
+        self.brillig_context.deallocate_single_addr(bias);
+    }
+
     fn add_overflow_check(
         &mut self,
         binary_operation: BrilligBinaryOp,
diff --git a/test_programs/execution_success/brillig_signed_cmp/Nargo.toml b/test_programs/execution_success/brillig_signed_cmp/Nargo.toml
new file mode 100644
index 00000000000..3f485df4a82
--- /dev/null
+++ b/test_programs/execution_success/brillig_signed_cmp/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "brillig_signed_cmp"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_signed_cmp/Prover.toml b/test_programs/execution_success/brillig_signed_cmp/Prover.toml
new file mode 100644
index 00000000000..4b719f83c16
--- /dev/null
+++ b/test_programs/execution_success/brillig_signed_cmp/Prover.toml
@@ -0,0 +1 @@
+minus_one = 255
diff --git a/test_programs/execution_success/brillig_signed_cmp/src/main.nr b/test_programs/execution_success/brillig_signed_cmp/src/main.nr
new file mode 100644
index 00000000000..3e3ea0f4b0f
--- /dev/null
+++ b/test_programs/execution_success/brillig_signed_cmp/src/main.nr
@@ -0,0 +1,8 @@
+unconstrained fn main(minus_one: i8) {
+    assert(minus_one < 0);
+    assert(0 < minus_one as u8);
+    assert(0 > minus_one);
+    let most_negative_number = minus_one * 127 - 1;
+    assert(most_negative_number < 0);
+    assert(127 > most_negative_number);
+}

From 3eb6acb9c1f23ecd552361ebdd82320c059bc4b9 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 19 Mar 2024 15:58:51 +0000
Subject: [PATCH 094/416] chore: update deps (#4582)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR just bumps and deduplicates versions of various dependencies


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock | 176 +++++++++++++++--------------------------------------
 1 file changed, 50 insertions(+), 126 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3b7c1b6e56e..37bf5135468 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -124,9 +124,9 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
 [[package]]
 name = "ahash"
-version = "0.7.7"
+version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd"
+checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
 dependencies = [
  "getrandom 0.2.10",
  "once_cell",
@@ -135,9 +135,9 @@ dependencies = [
 
 [[package]]
 name = "ahash"
-version = "0.8.6"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91429305e9f0a25f6205c5b8e0d2db09e0708a7a6df0f42212bb56c32c8ac97a"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if 1.0.0",
  "getrandom 0.2.10",
@@ -411,7 +411,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138985dd8aefbefeaa66b01b7f5b2b6b4c333fcef1cc5f32c63a2aabe37d6de3"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "lsp-types 0.94.1",
  "pin-project-lite",
  "rustix",
@@ -967,14 +967,14 @@ checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335"
 
 [[package]]
 name = "console"
-version = "0.15.7"
+version = "0.15.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
 dependencies = [
  "encode_unicode 0.3.6",
  "lazy_static",
  "libc",
- "windows-sys 0.45.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1781,9 +1781,9 @@ checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
 
 [[package]]
 name = "futures"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1796,9 +1796,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1806,15 +1806,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1824,15 +1824,15 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1841,21 +1841,21 @@ dependencies = [
 
 [[package]]
 name = "futures-sink"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
 
 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
 
 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
 dependencies = [
  "futures 0.1.31",
  "futures-channel",
@@ -1999,7 +1999,7 @@ dependencies = [
  "indexmap 2.0.0",
  "slab",
  "tokio",
- "tokio-util 0.7.8",
+ "tokio-util 0.7.10",
  "tracing",
 ]
 
@@ -2015,7 +2015,7 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
 dependencies = [
- "ahash 0.7.7",
+ "ahash 0.7.8",
 ]
 
 [[package]]
@@ -2024,7 +2024,7 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 dependencies = [
- "ahash 0.7.7",
+ "ahash 0.7.8",
 ]
 
 [[package]]
@@ -2033,7 +2033,7 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
 dependencies = [
- "ahash 0.8.6",
+ "ahash 0.8.11",
 ]
 
 [[package]]
@@ -2114,9 +2114,9 @@ checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
 [[package]]
 name = "hyper"
-version = "0.14.27"
+version = "0.14.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468"
+checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -2129,7 +2129,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.4.9",
+ "socket2",
  "tokio",
  "tower-service",
  "tracing",
@@ -2138,9 +2138,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http",
@@ -2296,7 +2296,7 @@ version = "0.11.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fb7c1b80a1dfa604bb4a649a5c5aeef3d913f7c520cb42b40e534e8a61bcdfc"
 dependencies = [
- "ahash 0.8.6",
+ "ahash 0.8.11",
  "indexmap 1.9.3",
  "is-terminal",
  "itoa",
@@ -2401,7 +2401,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2b99d4207e2a04fb4581746903c2bb7eb376f88de9c699d0f3e10feeac0cd3a"
 dependencies = [
  "derive_more",
- "futures 0.3.28",
+ "futures 0.3.30",
  "jsonrpc-core",
  "jsonrpc-pubsub",
  "log",
@@ -2416,7 +2416,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "futures-executor",
  "futures-util",
  "log",
@@ -2431,7 +2431,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b51da17abecbdab3e3d4f26b01c5ec075e88d3abe3ab3b05dc9aa69392764ec0"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "jsonrpc-client-transports",
 ]
 
@@ -2453,7 +2453,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1dea6e07251d9ce6a552abfb5d7ad6bc290a4596c8dcc3d795fae2bbdc1f3ff"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "hyper",
  "jsonrpc-core",
  "jsonrpc-server-utils",
@@ -2469,7 +2469,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240f87695e6c6f62fb37f05c02c04953cf68d6408b8c1c89de85c7a0125b1011"
 dependencies = [
- "futures 0.3.28",
+ "futures 0.3.30",
  "jsonrpc-core",
  "lazy_static",
  "log",
@@ -2485,7 +2485,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4fdea130485b572c39a460d50888beb00afb3e35de23ccd7fad8ff19f0e0d4"
 dependencies = [
  "bytes",
- "futures 0.3.28",
+ "futures 0.3.30",
  "globset",
  "jsonrpc-core",
  "lazy_static",
@@ -2814,7 +2814,7 @@ dependencies = [
  "test-binary",
  "thiserror",
  "tokio",
- "tokio-util 0.7.8",
+ "tokio-util 0.7.10",
  "toml 0.7.6",
  "tower",
  "tracing-appender",
@@ -4559,16 +4559,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "socket2"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
-dependencies = [
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "socket2"
 version = "0.5.5"
@@ -4882,9 +4872,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.35.0"
+version = "1.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d45b238a16291a4e1584e61820b8ae57d696cc5015c459c229ccc6990cc1c"
+checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
 dependencies = [
  "backtrace",
  "bytes",
@@ -4892,7 +4882,7 @@ dependencies = [
  "mio",
  "num_cpus",
  "pin-project-lite",
- "socket2 0.5.5",
+ "socket2",
  "tokio-macros",
  "windows-sys 0.48.0",
 ]
@@ -4920,9 +4910,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
+checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -4945,9 +4935,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.8"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d"
+checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
 dependencies = [
  "bytes",
  "futures-core",
@@ -5639,15 +5629,6 @@ dependencies = [
  "windows_x86_64_msvc 0.33.0",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
-dependencies = [
- "windows-targets 0.42.2",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -5666,21 +5647,6 @@ dependencies = [
  "windows-targets 0.52.4",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.48.1"
@@ -5711,12 +5677,6 @@ dependencies = [
  "windows_x86_64_msvc 0.52.4",
 ]
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.0"
@@ -5735,12 +5695,6 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.0"
@@ -5759,12 +5713,6 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.0"
@@ -5783,12 +5731,6 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.0"
@@ -5807,12 +5749,6 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.0"
@@ -5825,12 +5761,6 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.0"
@@ -5849,12 +5779,6 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.0"

From f2f827d51e6fe99fa3d17f125b22743da25e25be Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 19 Mar 2024 12:37:23 -0500
Subject: [PATCH 095/416] feat: Add `break` and `continue` in unconstrained
 code (#4569)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4259

## Summary\*

Implements break & continue in for loops in unconstrained code only.

When attempted to use outside of a loop or in a constrained function, an
error is issued.

## Additional Context

I didn't put a link to the docs in an error message, should I? It seems
like this may be something we may want to do in other errors as well.

This PR is currently missing documentation.
The test failures are from the change to terminator instructions. This
was needed since otherwise when break/continue set the terminator it was
being overridden when `codegen_if` would set the terminator instruction
for the same block afterward. One somewhat messy way to fix this is to
switch to an empty, unreachable block. Then the if's terminator would
set on that block instead. But if we push any instructions in between
those would be lost too and we'd be none the wiser. Although pushing
instructions after a break is usually a logic error in the compiler
anyway.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/function_builder/mod.rs           | 11 ++--
 compiler/noirc_evaluator/src/ssa/ir/cfg.rs    |  4 --
 .../noirc_evaluator/src/ssa/opt/inlining.rs   | 13 ++--
 .../src/ssa/ssa_gen/context.rs                | 33 +++++++++-
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    | 22 +++++++
 compiler/noirc_frontend/src/ast/statement.rs  |  6 ++
 .../src/hir/resolution/errors.rs              | 20 ++++++
 .../src/hir/resolution/resolver.rs            | 47 ++++++++++++--
 .../noirc_frontend/src/hir/type_check/stmt.rs |  2 +-
 compiler/noirc_frontend/src/hir_def/stmt.rs   |  2 +
 compiler/noirc_frontend/src/lexer/token.rs    |  6 ++
 .../src/monomorphization/ast.rs               |  2 +
 .../src/monomorphization/mod.rs               |  2 +
 .../src/monomorphization/printer.rs           |  2 +
 compiler/noirc_frontend/src/parser/parser.rs  | 10 +++
 compiler/noirc_frontend/src/tests.rs          | 30 +++++++++
 docs/docs/noir/concepts/control_flow.md       | 62 ++++++++++++++-----
 docs/docs/noir/concepts/unconstrained.md      |  4 ++
 noir_stdlib/src/collections/map.nr            | 18 +++---
 .../break_and_continue/Nargo.toml             |  7 +++
 .../break_and_continue/src/main.nr            | 15 +++++
 tooling/nargo_fmt/src/visitor/stmt.rs         |  2 +
 22 files changed, 275 insertions(+), 45 deletions(-)
 create mode 100644 test_programs/execution_success/break_and_continue/Nargo.toml
 create mode 100644 test_programs/execution_success/break_and_continue/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index aa5a7fedd92..0726b557616 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -49,11 +49,10 @@ impl FunctionBuilder {
     ) -> Self {
         let mut new_function = Function::new(function_name, function_id);
         new_function.set_runtime(runtime);
-        let current_block = new_function.entry_block();
 
         Self {
+            current_block: new_function.entry_block(),
             current_function: new_function,
-            current_block,
             finished_functions: Vec::new(),
             call_stack: CallStack::new(),
         }
@@ -153,9 +152,10 @@ impl FunctionBuilder {
         instruction: Instruction,
         ctrl_typevars: Option<Vec<Type>>,
     ) -> InsertInstructionResult {
+        let block = self.current_block();
         self.current_function.dfg.insert_instruction_and_results(
             instruction,
-            self.current_block,
+            block,
             ctrl_typevars,
             self.call_stack.clone(),
         )
@@ -317,8 +317,11 @@ impl FunctionBuilder {
     }
 
     /// Terminates the current block with the given terminator instruction
+    /// if the current block does not already have a terminator instruction.
     fn terminate_block_with(&mut self, terminator: TerminatorInstruction) {
-        self.current_function.dfg.set_block_terminator(self.current_block, terminator);
+        if self.current_function.dfg[self.current_block].terminator().is_none() {
+            self.current_function.dfg.set_block_terminator(self.current_block, terminator);
+        }
     }
 
     /// Terminate the current block with a jmp instruction to jmp to the given
diff --git a/compiler/noirc_evaluator/src/ssa/ir/cfg.rs b/compiler/noirc_evaluator/src/ssa/ir/cfg.rs
index ebfbf003ec4..5a3f07cd673 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/cfg.rs
@@ -95,10 +95,6 @@ impl ControlFlowGraph {
         );
         predecessor_node.successors.insert(to);
         let successor_node = self.data.entry(to).or_default();
-        assert!(
-            successor_node.predecessors.len() < 2,
-            "ICE: A cfg node cannot have more than two predecessors"
-        );
         successor_node.predecessors.insert(from);
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 776f22b2877..aff06af9921 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -487,6 +487,13 @@ impl<'function> PerFunctionContext<'function> {
             }
             TerminatorInstruction::Return { return_values, call_stack } => {
                 let return_values = vecmap(return_values, |value| self.translate_value(*value));
+
+                // Note that `translate_block` would take us back to the point at which the
+                // inlining of this source block began. Since additional blocks may have been
+                // inlined since, we are interested in the block representing the current program
+                // point, obtained via `current_block`.
+                let block_id = self.context.builder.current_block();
+
                 if self.inlining_entry {
                     let mut new_call_stack = self.context.call_stack.clone();
                     new_call_stack.append(call_stack.clone());
@@ -495,11 +502,7 @@ impl<'function> PerFunctionContext<'function> {
                         .set_call_stack(new_call_stack)
                         .terminate_with_return(return_values.clone());
                 }
-                // Note that `translate_block` would take us back to the point at which the
-                // inlining of this source block began. Since additional blocks may have been
-                // inlined since, we are interested in the block representing the current program
-                // point, obtained via `current_block`.
-                let block_id = self.context.builder.current_block();
+
                 Some((block_id, return_values))
             }
         }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index 409b99958a9..a9a707ca8ed 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -39,6 +39,11 @@ pub(super) struct FunctionContext<'a> {
 
     pub(super) builder: FunctionBuilder,
     shared_context: &'a SharedContext,
+
+    /// Contains any loops we're currently in the middle of translating.
+    /// These are ordered such that an inner loop is at the end of the vector and
+    /// outer loops are at the beginning. When a loop is finished, it is popped.
+    loops: Vec<Loop>,
 }
 
 /// Shared context for all functions during ssa codegen. This is the only
@@ -72,6 +77,13 @@ pub(super) struct SharedContext {
     pub(super) program: Program,
 }
 
+#[derive(Copy, Clone)]
+pub(super) struct Loop {
+    pub(super) loop_entry: BasicBlockId,
+    pub(super) loop_index: ValueId,
+    pub(super) loop_end: BasicBlockId,
+}
+
 /// The queue of functions remaining to compile
 type FunctionQueue = Vec<(ast::FuncId, IrFunctionId)>;
 
@@ -97,7 +109,8 @@ impl<'a> FunctionContext<'a> {
             .1;
 
         let builder = FunctionBuilder::new(function_name, function_id, runtime);
-        let mut this = Self { definitions: HashMap::default(), builder, shared_context };
+        let definitions = HashMap::default();
+        let mut this = Self { definitions, builder, shared_context, loops: Vec::new() };
         this.add_parameters_to_scope(parameters);
         this
     }
@@ -1053,6 +1066,24 @@ impl<'a> FunctionContext<'a> {
             self.builder.decrement_array_reference_count(parameter);
         }
     }
+
+    pub(crate) fn enter_loop(
+        &mut self,
+        loop_entry: BasicBlockId,
+        loop_index: ValueId,
+        loop_end: BasicBlockId,
+    ) {
+        self.loops.push(Loop { loop_entry, loop_index, loop_end });
+    }
+
+    pub(crate) fn exit_loop(&mut self) {
+        self.loops.pop();
+    }
+
+    pub(crate) fn current_loop(&self) -> Loop {
+        // The frontend should ensure break/continue are never used outside a loop
+        *self.loops.last().expect("current_loop: not in a loop!")
+    }
 }
 
 /// True if the given operator cannot be encoded directly and needs
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 3d8ae0bb3eb..5acb266b4c1 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -152,6 +152,8 @@ impl<'a> FunctionContext<'a> {
             }
             Expression::Assign(assign) => self.codegen_assign(assign),
             Expression::Semi(semi) => self.codegen_semi(semi),
+            Expression::Break => Ok(self.codegen_break()),
+            Expression::Continue => Ok(self.codegen_continue()),
         }
     }
 
@@ -477,6 +479,10 @@ impl<'a> FunctionContext<'a> {
         let index_type = Self::convert_non_tuple_type(&for_expr.index_type);
         let loop_index = self.builder.add_block_parameter(loop_entry, index_type);
 
+        // Remember the blocks and variable used in case there are break/continue instructions
+        // within the loop which need to jump to them.
+        self.enter_loop(loop_entry, loop_index, loop_end);
+
         self.builder.set_location(for_expr.start_range_location);
         let start_index = self.codegen_non_tuple_expression(&for_expr.start_range)?;
 
@@ -507,6 +513,7 @@ impl<'a> FunctionContext<'a> {
 
         // Finish by switching back to the end of the loop
         self.builder.switch_to_block(loop_end);
+        self.exit_loop();
         Ok(Self::unit_value())
     }
 
@@ -736,4 +743,19 @@ impl<'a> FunctionContext<'a> {
         self.codegen_expression(expr)?;
         Ok(Self::unit_value())
     }
+
+    fn codegen_break(&mut self) -> Values {
+        let loop_end = self.current_loop().loop_end;
+        self.builder.terminate_with_jmp(loop_end, Vec::new());
+        Self::unit_value()
+    }
+
+    fn codegen_continue(&mut self) -> Values {
+        let loop_ = self.current_loop();
+
+        // Must remember to increment i before jumping
+        let new_loop_index = self.make_offset(loop_.loop_index, 1);
+        self.builder.terminate_with_jmp(loop_.loop_entry, vec![new_loop_index]);
+        Self::unit_value()
+    }
 }
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 387840b57c4..fb7f520ee71 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -35,6 +35,8 @@ pub enum StatementKind {
     Expression(Expression),
     Assign(AssignStatement),
     For(ForLoopStatement),
+    Break,
+    Continue,
     // This is an expression with a trailing semi-colon
     Semi(Expression),
     // This statement is the result of a recovered parse error.
@@ -59,6 +61,8 @@ impl Statement {
             | StatementKind::Constrain(_)
             | StatementKind::Assign(_)
             | StatementKind::Semi(_)
+            | StatementKind::Break
+            | StatementKind::Continue
             | StatementKind::Error => {
                 // To match rust, statements always require a semicolon, even at the end of a block
                 if semi.is_none() {
@@ -637,6 +641,8 @@ impl Display for StatementKind {
             StatementKind::Expression(expression) => expression.fmt(f),
             StatementKind::Assign(assign) => assign.fmt(f),
             StatementKind::For(for_loop) => for_loop.fmt(f),
+            StatementKind::Break => write!(f, "break"),
+            StatementKind::Continue => write!(f, "continue"),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
             StatementKind::Error => write!(f, "Error"),
         }
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 30a1ba2ee34..3c6c0582292 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -84,6 +84,10 @@ pub enum ResolverError {
     LowLevelFunctionOutsideOfStdlib { ident: Ident },
     #[error("Dependency cycle found, '{item}' recursively depends on itself: {cycle} ")]
     DependencyCycle { span: Span, item: String, cycle: String },
+    #[error("break/continue are only allowed in unconstrained functions")]
+    JumpInConstrainedFn { is_break: bool, span: Span },
+    #[error("break/continue are only allowed within loops")]
+    JumpOutsideLoop { is_break: bool, span: Span },
 }
 
 impl ResolverError {
@@ -322,6 +326,22 @@ impl From<ResolverError> for Diagnostic {
                     span,
                 )
             },
+            ResolverError::JumpInConstrainedFn { is_break, span } => {
+                let item = if is_break { "break" } else { "continue" };
+                Diagnostic::simple_error(
+                    format!("{item} is only allowed in unconstrained functions"),
+                    "Constrained code must always have a known number of loop iterations".into(),
+                    span,
+                )
+            },
+            ResolverError::JumpOutsideLoop { is_break, span } => {
+                let item = if is_break { "break" } else { "continue" };
+                Diagnostic::simple_error(
+                    format!("{item} is only allowed within loops"),
+                    "".into(),
+                    span,
+                )
+            },
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index c33b83257b0..90716bb958d 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -39,7 +39,7 @@ use crate::{
 use crate::{
     ArrayLiteral, BinaryOpKind, Distinctness, ForRange, FunctionDefinition, FunctionReturnType,
     Generics, ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
-    Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp,
+    Shared, Statement, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp,
     UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData,
     UnresolvedTypeExpression, Visibility, ERROR_IDENT,
 };
@@ -115,6 +115,13 @@ pub struct Resolver<'a> {
     /// that are captured. We do this in order to create the hidden environment
     /// parameter for the lambda function.
     lambda_stack: Vec<LambdaContext>,
+
+    /// True if we're currently resolving an unconstrained function
+    in_unconstrained_fn: bool,
+
+    /// How many loops we're currently within.
+    /// This increases by 1 at the start of a loop, and decreases by 1 when it ends.
+    nested_loops: u32,
 }
 
 /// ResolverMetas are tagged onto each definition to track how many times they are used
@@ -155,6 +162,8 @@ impl<'a> Resolver<'a> {
             current_item: None,
             file,
             in_contract,
+            in_unconstrained_fn: false,
+            nested_loops: 0,
         }
     }
 
@@ -416,6 +425,11 @@ impl<'a> Resolver<'a> {
 
     fn intern_function(&mut self, func: NoirFunction, id: FuncId) -> (HirFunction, FuncMeta) {
         let func_meta = self.extract_meta(&func, id);
+
+        if func.def.is_unconstrained {
+            self.in_unconstrained_fn = true;
+        }
+
         let hir_func = match func.kind {
             FunctionKind::Builtin | FunctionKind::LowLevel | FunctionKind::Oracle => {
                 HirFunction::empty()
@@ -1148,7 +1162,7 @@ impl<'a> Resolver<'a> {
         })
     }
 
-    pub fn resolve_stmt(&mut self, stmt: StatementKind) -> HirStatement {
+    pub fn resolve_stmt(&mut self, stmt: StatementKind, span: Span) -> HirStatement {
         match stmt {
             StatementKind::Let(let_stmt) => {
                 let expression = self.resolve_expression(let_stmt.expression);
@@ -1188,6 +1202,8 @@ impl<'a> Resolver<'a> {
                         let end_range = self.resolve_expression(end_range);
                         let (identifier, block) = (for_loop.identifier, for_loop.block);
 
+                        self.nested_loops += 1;
+
                         // TODO: For loop variables are currently mutable by default since we haven't
                         //       yet implemented syntax for them to be optionally mutable.
                         let (identifier, block) = self.in_new_scope(|this| {
@@ -1200,6 +1216,8 @@ impl<'a> Resolver<'a> {
                             (decl, this.resolve_expression(block))
                         });
 
+                        self.nested_loops -= 1;
+
                         HirStatement::For(HirForStatement {
                             start_range,
                             end_range,
@@ -1210,10 +1228,18 @@ impl<'a> Resolver<'a> {
                     range @ ForRange::Array(_) => {
                         let for_stmt =
                             range.into_for(for_loop.identifier, for_loop.block, for_loop.span);
-                        self.resolve_stmt(for_stmt)
+                        self.resolve_stmt(for_stmt, for_loop.span)
                     }
                 }
             }
+            StatementKind::Break => {
+                self.check_break_continue(true, span);
+                HirStatement::Break
+            }
+            StatementKind::Continue => {
+                self.check_break_continue(false, span);
+                HirStatement::Continue
+            }
             StatementKind::Error => HirStatement::Error,
         }
     }
@@ -1260,8 +1286,8 @@ impl<'a> Resolver<'a> {
         Some(self.resolve_expression(assert_msg_call_expr))
     }
 
-    pub fn intern_stmt(&mut self, stmt: StatementKind) -> StmtId {
-        let hir_stmt = self.resolve_stmt(stmt);
+    pub fn intern_stmt(&mut self, stmt: Statement) -> StmtId {
+        let hir_stmt = self.resolve_stmt(stmt.kind, stmt.span);
         self.interner.push_stmt(hir_stmt)
     }
 
@@ -1909,7 +1935,7 @@ impl<'a> Resolver<'a> {
 
     fn resolve_block(&mut self, block_expr: BlockExpression) -> HirExpression {
         let statements =
-            self.in_new_scope(|this| vecmap(block_expr.0, |stmt| this.intern_stmt(stmt.kind)));
+            self.in_new_scope(|this| vecmap(block_expr.0, |stmt| this.intern_stmt(stmt)));
         HirExpression::Block(HirBlockExpression(statements))
     }
 
@@ -2036,6 +2062,15 @@ impl<'a> Resolver<'a> {
         }
         HirLiteral::FmtStr(str, fmt_str_idents)
     }
+
+    fn check_break_continue(&mut self, is_break: bool, span: Span) {
+        if !self.in_unconstrained_fn {
+            self.push_err(ResolverError::JumpInConstrainedFn { is_break, span });
+        }
+        if self.nested_loops == 0 {
+            self.push_err(ResolverError::JumpOutsideLoop { is_break, span });
+        }
+    }
 }
 
 /// Gives an error if a user tries to create a mutable reference
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index 358bea86922..e90da555803 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -51,7 +51,7 @@ impl<'interner> TypeChecker<'interner> {
             HirStatement::Constrain(constrain_stmt) => self.check_constrain_stmt(constrain_stmt),
             HirStatement::Assign(assign_stmt) => self.check_assign_stmt(assign_stmt, stmt_id),
             HirStatement::For(for_loop) => self.check_for_loop(for_loop),
-            HirStatement::Error => (),
+            HirStatement::Break | HirStatement::Continue | HirStatement::Error => (),
         }
         Type::Unit
     }
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index b910be1fdda..4e5f718cf47 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -14,6 +14,8 @@ pub enum HirStatement {
     Constrain(HirConstrainStatement),
     Assign(HirAssignStatement),
     For(HirForStatement),
+    Break,
+    Continue,
     Expression(ExprId),
     Semi(ExprId),
     Error,
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 3dc9d05b15e..1e341d34510 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -644,10 +644,12 @@ pub enum Keyword {
     Assert,
     AssertEq,
     Bool,
+    Break,
     CallData,
     Char,
     CompTime,
     Constrain,
+    Continue,
     Contract,
     Crate,
     Dep,
@@ -685,10 +687,12 @@ impl fmt::Display for Keyword {
             Keyword::Assert => write!(f, "assert"),
             Keyword::AssertEq => write!(f, "assert_eq"),
             Keyword::Bool => write!(f, "bool"),
+            Keyword::Break => write!(f, "break"),
             Keyword::Char => write!(f, "char"),
             Keyword::CallData => write!(f, "call_data"),
             Keyword::CompTime => write!(f, "comptime"),
             Keyword::Constrain => write!(f, "constrain"),
+            Keyword::Continue => write!(f, "continue"),
             Keyword::Contract => write!(f, "contract"),
             Keyword::Crate => write!(f, "crate"),
             Keyword::Dep => write!(f, "dep"),
@@ -729,10 +733,12 @@ impl Keyword {
             "assert" => Keyword::Assert,
             "assert_eq" => Keyword::AssertEq,
             "bool" => Keyword::Bool,
+            "break" => Keyword::Break,
             "call_data" => Keyword::CallData,
             "char" => Keyword::Char,
             "comptime" => Keyword::CompTime,
             "constrain" => Keyword::Constrain,
+            "continue" => Keyword::Continue,
             "contract" => Keyword::Contract,
             "crate" => Keyword::Crate,
             "dep" => Keyword::Dep,
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 7fcf8e87792..21b77127360 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -38,6 +38,8 @@ pub enum Expression {
     Constrain(Box<Expression>, Location, Option<Box<Expression>>),
     Assign(Assign),
     Semi(Box<Expression>),
+    Break,
+    Continue,
 }
 
 /// A definition is either a local (variable), function, or is a built-in
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 4938d33aff9..a99a4e61d4d 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -594,6 +594,8 @@ impl<'interner> Monomorphizer<'interner> {
             HirStatement::Semi(expr) => {
                 self.expr(expr).map(|expr| ast::Expression::Semi(Box::new(expr)))
             }
+            HirStatement::Break => Ok(ast::Expression::Break),
+            HirStatement::Continue => Ok(ast::Expression::Continue),
             HirStatement::Error => unreachable!(),
         }
     }
diff --git a/compiler/noirc_frontend/src/monomorphization/printer.rs b/compiler/noirc_frontend/src/monomorphization/printer.rs
index 7aec2193494..c3e34890ce0 100644
--- a/compiler/noirc_frontend/src/monomorphization/printer.rs
+++ b/compiler/noirc_frontend/src/monomorphization/printer.rs
@@ -73,6 +73,8 @@ impl AstPrinter {
                 self.print_expr(expr, f)?;
                 write!(f, ";")
             }
+            Expression::Break => write!(f, "break"),
+            Expression::Continue => write!(f, "continue"),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 383a1ffafc9..b2d9d7e6802 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -421,6 +421,8 @@ where
             declaration(expr_parser.clone()),
             assignment(expr_parser.clone()),
             for_loop(expr_no_constructors, statement),
+            break_statement(),
+            continue_statement(),
             return_statement(expr_parser.clone()),
             expr_parser.map(StatementKind::Expression),
         ))
@@ -431,6 +433,14 @@ fn fresh_statement() -> impl NoirParser<StatementKind> {
     statement(expression(), expression_no_constructors(expression()))
 }
 
+fn break_statement() -> impl NoirParser<StatementKind> {
+    keyword(Keyword::Break).to(StatementKind::Break)
+}
+
+fn continue_statement() -> impl NoirParser<StatementKind> {
+    keyword(Keyword::Continue).to(StatementKind::Continue)
+}
+
 fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
 where
     P: ExprParser + 'a,
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index b8ed6fb73d2..98dbc42adcd 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -778,6 +778,8 @@ mod test {
                 HirStatement::Semi(semi_expr) => semi_expr,
                 HirStatement::For(for_loop) => for_loop.block,
                 HirStatement::Error => panic!("Invalid HirStatement!"),
+                HirStatement::Break => panic!("Unexpected break"),
+                HirStatement::Continue => panic!("Unexpected continue"),
             };
             let expr = interner.expression(&expr_id);
 
@@ -1226,6 +1228,34 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         assert_eq!(get_program_errors(src).len(), 0);
     }
 
+    #[test]
+    fn break_and_continue_in_constrained_fn() {
+        let src = r#"
+            fn main() {
+                for i in 0 .. 10 {
+                    if i == 2 {
+                        continue;
+                    }
+                    if i == 5 {
+                        break;
+                    }
+                }
+            }
+        "#;
+        assert_eq!(get_program_errors(src).len(), 2);
+    }
+
+    #[test]
+    fn break_and_continue_outside_loop() {
+        let src = r#"
+            unconstrained fn main() {
+                continue;
+                break;
+            }
+        "#;
+        assert_eq!(get_program_errors(src).len(), 2);
+    }
+
     // Regression for #4545
     #[test]
     fn type_aliases_in_main() {
diff --git a/docs/docs/noir/concepts/control_flow.md b/docs/docs/noir/concepts/control_flow.md
index 4ce65236db3..045d3c3a5f5 100644
--- a/docs/docs/noir/concepts/control_flow.md
+++ b/docs/docs/noir/concepts/control_flow.md
@@ -7,21 +7,6 @@ keywords: [Noir programming language, loops, for loop, if-else statements, Rust
 sidebar_position: 2
 ---
 
-## Loops
-
-Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
-times.
-
-The following block of code between the braces is run 10 times.
-
-```rust
-for i in 0..10 {
-    // do something
-};
-```
-
-The index for loops is of type `u64`.
-
 ## If Expressions
 
 Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
@@ -43,3 +28,50 @@ if a == 0 {
 }
 assert(x == 2);
 ```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/docs/noir/concepts/unconstrained.md b/docs/docs/noir/concepts/unconstrained.md
index 89d12c1c971..b8e71fe65f0 100644
--- a/docs/docs/noir/concepts/unconstrained.md
+++ b/docs/docs/noir/concepts/unconstrained.md
@@ -93,3 +93,7 @@ Backend circuit size: 2902
 This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
 
 Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index 2d76acf1f3a..5f8cc6dab62 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -288,10 +288,10 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         let mut result = Option::none();
 
         let hash = self.hash(key);
-        let mut break = false;
+        let mut should_break = false;
 
         for attempt in 0..N {
-            if !break {
+            if !should_break {
                 let index = self.quadratic_probe(hash, attempt as u64);
                 let slot = self._table[index];
 
@@ -300,7 +300,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
                     let (current_key, value) = slot.key_value_unchecked();
                     if current_key == key {
                         result = Option::some(value);
-                        break = true;
+                        should_break = true;
                     }
                 }
             }
@@ -324,10 +324,10 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         self.assert_load_factor();
 
         let hash = self.hash(key);
-        let mut break = false;
+        let mut should_break = false;
 
         for attempt in 0..N {
-            if !break {
+            if !should_break {
                 let index = self.quadratic_probe(hash, attempt as u64);
                 let mut slot = self._table[index];
                 let mut insert = false;
@@ -346,7 +346,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
                 if insert {
                     slot.set(key, value);
                     self._table[index] = slot;
-                    break = true;
+                    should_break = true;
                 }
             }
         }
@@ -364,10 +364,10 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
         H: Hasher {
         // docs:end:remove
         let hash = self.hash(key);
-        let mut break = false;
+        let mut should_break = false;
 
         for attempt in 0..N {
-            if !break {
+            if !should_break {
                 let index = self.quadratic_probe(hash, attempt as u64);
                 let mut slot = self._table[index];
 
@@ -378,7 +378,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
                         slot.mark_deleted();
                         self._table[index] = slot;
                         self._len -= 1;
-                        break = true;
+                        should_break = true;
                     }
                 }
             }
diff --git a/test_programs/execution_success/break_and_continue/Nargo.toml b/test_programs/execution_success/break_and_continue/Nargo.toml
new file mode 100644
index 00000000000..483602478ba
--- /dev/null
+++ b/test_programs/execution_success/break_and_continue/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "break_and_continue"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.24.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/break_and_continue/src/main.nr b/test_programs/execution_success/break_and_continue/src/main.nr
new file mode 100644
index 00000000000..67dce03ac64
--- /dev/null
+++ b/test_programs/execution_success/break_and_continue/src/main.nr
@@ -0,0 +1,15 @@
+unconstrained fn main() {
+    let mut count = 0;
+
+    for i in 0..10 {
+        if i == 2 {
+            continue;
+        }
+        if i == 5 {
+            break;
+        }
+        count += 1;
+    }
+
+    assert(count == 4);
+}
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index 44c5dad6b5d..ee8cc990e0e 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -95,6 +95,8 @@ impl super::FmtVisitor<'_> {
                     self.push_rewrite(self.slice(span).to_string(), span);
                 }
                 StatementKind::Error => unreachable!(),
+                StatementKind::Break => self.push_rewrite("break;".into(), span),
+                StatementKind::Continue => self.push_rewrite("continue;".into(), span),
             }
 
             self.last_position = span.end();

From b86300c3391cb89bf467dce044968c901fcb4bc0 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 19 Mar 2024 19:23:17 +0000
Subject: [PATCH 096/416] chore: Standardise workspace JS dependencies (#4583)

# Description

## Problem\*



## Summary\*

This PR standardizes the versions of various JS dependencies across the
workspace

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../@yarnpkg/plugin-interactive-tools.cjs     |  541 +++++++++
 .yarnrc.yml                                   |    9 +-
 acvm-repo/acvm_js/package.json                |   12 +-
 compiler/integration-tests/package.json       |    8 +-
 compiler/wasm/package.json                    |   12 +-
 docs/package.json                             |    6 +-
 package.json                                  |   10 +-
 tooling/noir_codegen/package.json             |   10 +-
 tooling/noir_js/package.json                  |   10 +-
 .../noir_js_backend_barretenberg/package.json |   10 +-
 .../tsconfig.cjs.json                         |    1 +
 tooling/noir_js_types/package.json            |    8 +-
 tooling/noirc_abi_wasm/package.json           |    4 +-
 yarn.lock                                     | 1039 ++++-------------
 14 files changed, 851 insertions(+), 829 deletions(-)
 create mode 100644 .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs

diff --git a/.yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs b/.yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
new file mode 100644
index 00000000000..bc2ca19f116
--- /dev/null
+++ b/.yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
@@ -0,0 +1,541 @@
+/* eslint-disable */
+//prettier-ignore
+module.exports = {
+name: "@yarnpkg/plugin-interactive-tools",
+factory: function (require) {
+var plugin=(()=>{var bF=Object.create;var D_=Object.defineProperty;var BF=Object.getOwnPropertyDescriptor;var UF=Object.getOwnPropertyNames;var jF=Object.getPrototypeOf,zF=Object.prototype.hasOwnProperty;var hi=(o=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(o,{get:(l,f)=>(typeof require<"u"?require:l)[f]}):o)(function(o){if(typeof require<"u")return require.apply(this,arguments);throw new Error('Dynamic require of "'+o+'" is not supported')});var nt=(o,l)=>()=>(l||o((l={exports:{}}).exports,l),l.exports),HF=(o,l)=>{for(var f in l)D_(o,f,{get:l[f],enumerable:!0})},j8=(o,l,f,h)=>{if(l&&typeof l=="object"||typeof l=="function")for(let E of UF(l))!zF.call(o,E)&&E!==f&&D_(o,E,{get:()=>l[E],enumerable:!(h=BF(l,E))||h.enumerable});return o};var V0=(o,l,f)=>(f=o!=null?bF(jF(o)):{},j8(l||!o||!o.__esModule?D_(f,"default",{value:o,enumerable:!0}):f,o)),qF=o=>j8(D_({},"__esModule",{value:!0}),o);var Py=nt((Xz,H8)=>{"use strict";var z8=Object.getOwnPropertySymbols,WF=Object.prototype.hasOwnProperty,VF=Object.prototype.propertyIsEnumerable;function GF(o){if(o==null)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(o)}function YF(){try{if(!Object.assign)return!1;var o=new String("abc");if(o[5]="de",Object.getOwnPropertyNames(o)[0]==="5")return!1;for(var l={},f=0;f<10;f++)l["_"+String.fromCharCode(f)]=f;var h=Object.getOwnPropertyNames(l).map(function(t){return l[t]});if(h.join("")!=="0123456789")return!1;var E={};return"abcdefghijklmnopqrst".split("").forEach(function(t){E[t]=t}),Object.keys(Object.assign({},E)).join("")==="abcdefghijklmnopqrst"}catch{return!1}}H8.exports=YF()?Object.assign:function(o,l){for(var f,h=GF(o),E,t=1;t<arguments.length;t++){f=Object(arguments[t]);for(var N in f)WF.call(f,N)&&(h[N]=f[N]);if(z8){E=z8(f);for(var F=0;F<E.length;F++)VF.call(f,E[F])&&(h[E[F]]=f[E[F]])}}return h}});var eS=nt(gu=>{"use strict";var qE=Py(),Zf=typeof Symbol=="function"&&Symbol.for,Iy=Zf?Symbol.for("react.element"):60103,KF=Zf?Symbol.for("react.portal"):60106,XF=Zf?Symbol.for("react.fragment"):60107,QF=Zf?Symbol.for("react.strict_mode"):60108,JF=Zf?Symbol.for("react.profiler"):60114,ZF=Zf?Symbol.for("react.provider"):60109,$F=Zf?Symbol.for("react.context"):60110,eP=Zf?Symbol.for("react.forward_ref"):60112,tP=Zf?Symbol.for("react.suspense"):60113,nP=Zf?Symbol.for("react.memo"):60115,rP=Zf?Symbol.for("react.lazy"):60116,q8=typeof Symbol=="function"&&Symbol.iterator;function by(o){for(var l="https://reactjs.org/docs/error-decoder.html?invariant="+o,f=1;f<arguments.length;f++)l+="&args[]="+encodeURIComponent(arguments[f]);return"Minified React error #"+o+"; visit "+l+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var W8={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},V8={};function qv(o,l,f){this.props=o,this.context=l,this.refs=V8,this.updater=f||W8}qv.prototype.isReactComponent={};qv.prototype.setState=function(o,l){if(typeof o!="object"&&typeof o!="function"&&o!=null)throw Error(by(85));this.updater.enqueueSetState(this,o,l,"setState")};qv.prototype.forceUpdate=function(o){this.updater.enqueueForceUpdate(this,o,"forceUpdate")};function G8(){}G8.prototype=qv.prototype;function WE(o,l,f){this.props=o,this.context=l,this.refs=V8,this.updater=f||W8}var VE=WE.prototype=new G8;VE.constructor=WE;qE(VE,qv.prototype);VE.isPureReactComponent=!0;var GE={current:null},Y8=Object.prototype.hasOwnProperty,K8={key:!0,ref:!0,__self:!0,__source:!0};function X8(o,l,f){var h,E={},t=null,N=null;if(l!=null)for(h in l.ref!==void 0&&(N=l.ref),l.key!==void 0&&(t=""+l.key),l)Y8.call(l,h)&&!K8.hasOwnProperty(h)&&(E[h]=l[h]);var F=arguments.length-2;if(F===1)E.children=f;else if(1<F){for(var k=Array(F),x=0;x<F;x++)k[x]=arguments[x+2];E.children=k}if(o&&o.defaultProps)for(h in F=o.defaultProps,F)E[h]===void 0&&(E[h]=F[h]);return{$$typeof:Iy,type:o,key:t,ref:N,props:E,_owner:GE.current}}function iP(o,l){return{$$typeof:Iy,type:o.type,key:l,ref:o.ref,props:o.props,_owner:o._owner}}function YE(o){return typeof o=="object"&&o!==null&&o.$$typeof===Iy}function uP(o){var l={"=":"=0",":":"=2"};return"$"+(""+o).replace(/[=:]/g,function(f){return l[f]})}var Q8=/\/+/g,w_=[];function J8(o,l,f,h){if(w_.length){var E=w_.pop();return E.result=o,E.keyPrefix=l,E.func=f,E.context=h,E.count=0,E}return{result:o,keyPrefix:l,func:f,context:h,count:0}}function Z8(o){o.result=null,o.keyPrefix=null,o.func=null,o.context=null,o.count=0,10>w_.length&&w_.push(o)}function jE(o,l,f,h){var E=typeof o;(E==="undefined"||E==="boolean")&&(o=null);var t=!1;if(o===null)t=!0;else switch(E){case"string":case"number":t=!0;break;case"object":switch(o.$$typeof){case Iy:case KF:t=!0}}if(t)return f(h,o,l===""?"."+UE(o,0):l),1;if(t=0,l=l===""?".":l+":",Array.isArray(o))for(var N=0;N<o.length;N++){E=o[N];var F=l+UE(E,N);t+=jE(E,F,f,h)}else if(o===null||typeof o!="object"?F=null:(F=q8&&o[q8]||o["@@iterator"],F=typeof F=="function"?F:null),typeof F=="function")for(o=F.call(o),N=0;!(E=o.next()).done;)E=E.value,F=l+UE(E,N++),t+=jE(E,F,f,h);else if(E==="object")throw f=""+o,Error(by(31,f==="[object Object]"?"object with keys {"+Object.keys(o).join(", ")+"}":f,""));return t}function zE(o,l,f){return o==null?0:jE(o,"",l,f)}function UE(o,l){return typeof o=="object"&&o!==null&&o.key!=null?uP(o.key):l.toString(36)}function oP(o,l){o.func.call(o.context,l,o.count++)}function lP(o,l,f){var h=o.result,E=o.keyPrefix;o=o.func.call(o.context,l,o.count++),Array.isArray(o)?HE(o,h,f,function(t){return t}):o!=null&&(YE(o)&&(o=iP(o,E+(!o.key||l&&l.key===o.key?"":(""+o.key).replace(Q8,"$&/")+"/")+f)),h.push(o))}function HE(o,l,f,h,E){var t="";f!=null&&(t=(""+f).replace(Q8,"$&/")+"/"),l=J8(l,t,h,E),zE(o,lP,l),Z8(l)}var $8={current:null};function K1(){var o=$8.current;if(o===null)throw Error(by(321));return o}var sP={ReactCurrentDispatcher:$8,ReactCurrentBatchConfig:{suspense:null},ReactCurrentOwner:GE,IsSomeRendererActing:{current:!1},assign:qE};gu.Children={map:function(o,l,f){if(o==null)return o;var h=[];return HE(o,h,null,l,f),h},forEach:function(o,l,f){if(o==null)return o;l=J8(null,null,l,f),zE(o,oP,l),Z8(l)},count:function(o){return zE(o,function(){return null},null)},toArray:function(o){var l=[];return HE(o,l,null,function(f){return f}),l},only:function(o){if(!YE(o))throw Error(by(143));return o}};gu.Component=qv;gu.Fragment=XF;gu.Profiler=JF;gu.PureComponent=WE;gu.StrictMode=QF;gu.Suspense=tP;gu.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=sP;gu.cloneElement=function(o,l,f){if(o==null)throw Error(by(267,o));var h=qE({},o.props),E=o.key,t=o.ref,N=o._owner;if(l!=null){if(l.ref!==void 0&&(t=l.ref,N=GE.current),l.key!==void 0&&(E=""+l.key),o.type&&o.type.defaultProps)var F=o.type.defaultProps;for(k in l)Y8.call(l,k)&&!K8.hasOwnProperty(k)&&(h[k]=l[k]===void 0&&F!==void 0?F[k]:l[k])}var k=arguments.length-2;if(k===1)h.children=f;else if(1<k){F=Array(k);for(var x=0;x<k;x++)F[x]=arguments[x+2];h.children=F}return{$$typeof:Iy,type:o.type,key:E,ref:t,props:h,_owner:N}};gu.createContext=function(o,l){return l===void 0&&(l=null),o={$$typeof:$F,_calculateChangedBits:l,_currentValue:o,_currentValue2:o,_threadCount:0,Provider:null,Consumer:null},o.Provider={$$typeof:ZF,_context:o},o.Consumer=o};gu.createElement=X8;gu.createFactory=function(o){var l=X8.bind(null,o);return l.type=o,l};gu.createRef=function(){return{current:null}};gu.forwardRef=function(o){return{$$typeof:eP,render:o}};gu.isValidElement=YE;gu.lazy=function(o){return{$$typeof:rP,_ctor:o,_status:-1,_result:null}};gu.memo=function(o,l){return{$$typeof:nP,type:o,compare:l===void 0?null:l}};gu.useCallback=function(o,l){return K1().useCallback(o,l)};gu.useContext=function(o,l){return K1().useContext(o,l)};gu.useDebugValue=function(){};gu.useEffect=function(o,l){return K1().useEffect(o,l)};gu.useImperativeHandle=function(o,l,f){return K1().useImperativeHandle(o,l,f)};gu.useLayoutEffect=function(o,l){return K1().useLayoutEffect(o,l)};gu.useMemo=function(o,l){return K1().useMemo(o,l)};gu.useReducer=function(o,l,f){return K1().useReducer(o,l,f)};gu.useRef=function(o){return K1().useRef(o)};gu.useState=function(o){return K1().useState(o)};gu.version="16.13.1"});var nS=nt((Jz,tS)=>{"use strict";var aP="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";tS.exports=aP});var XE=nt((Zz,oS)=>{"use strict";var KE=function(){};process.env.NODE_ENV!=="production"&&(rS=nS(),S_={},iS=Function.call.bind(Object.prototype.hasOwnProperty),KE=function(o){var l="Warning: "+o;typeof console<"u"&&console.error(l);try{throw new Error(l)}catch{}});var rS,S_,iS;function uS(o,l,f,h,E){if(process.env.NODE_ENV!=="production"){for(var t in o)if(iS(o,t)){var N;try{if(typeof o[t]!="function"){var F=Error((h||"React class")+": "+f+" type `"+t+"` is invalid; it must be a function, usually from the `prop-types` package, but received `"+typeof o[t]+"`.");throw F.name="Invariant Violation",F}N=o[t](l,t,h,f,null,rS)}catch(x){N=x}if(N&&!(N instanceof Error)&&KE((h||"React class")+": type specification of "+f+" `"+t+"` is invalid; the type checker function must return `null` or an `Error` but returned a "+typeof N+". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."),N instanceof Error&&!(N.message in S_)){S_[N.message]=!0;var k=E?E():"";KE("Failed "+f+" type: "+N.message+(k!=null?k:""))}}}}uS.resetWarningCache=function(){process.env.NODE_ENV!=="production"&&(S_={})};oS.exports=uS});var lS=nt(_u=>{"use strict";process.env.NODE_ENV!=="production"&&function(){"use strict";var o=Py(),l=XE(),f="16.13.1",h=typeof Symbol=="function"&&Symbol.for,E=h?Symbol.for("react.element"):60103,t=h?Symbol.for("react.portal"):60106,N=h?Symbol.for("react.fragment"):60107,F=h?Symbol.for("react.strict_mode"):60108,k=h?Symbol.for("react.profiler"):60114,x=h?Symbol.for("react.provider"):60109,j=h?Symbol.for("react.context"):60110,q=h?Symbol.for("react.concurrent_mode"):60111,V=h?Symbol.for("react.forward_ref"):60112,re=h?Symbol.for("react.suspense"):60113,y=h?Symbol.for("react.suspense_list"):60120,me=h?Symbol.for("react.memo"):60115,De=h?Symbol.for("react.lazy"):60116,ge=h?Symbol.for("react.block"):60121,ae=h?Symbol.for("react.fundamental"):60117,we=h?Symbol.for("react.responder"):60118,he=h?Symbol.for("react.scope"):60119,ve=typeof Symbol=="function"&&Symbol.iterator,ue="@@iterator";function Ae(Q){if(Q===null||typeof Q!="object")return null;var Se=ve&&Q[ve]||Q[ue];return typeof Se=="function"?Se:null}var ze={current:null},We={suspense:null},gt={current:null},_t=/^(.*)[\\\/]/;function Qe(Q,Se,Fe){var Le="";if(Se){var pt=Se.fileName,Yn=pt.replace(_t,"");if(/^index\./.test(Yn)){var Cn=pt.match(_t);if(Cn){var cr=Cn[1];if(cr){var Si=cr.replace(_t,"");Yn=Si+"/"+Yn}}}Le=" (at "+Yn+":"+Se.lineNumber+")"}else Fe&&(Le=" (created by "+Fe+")");return`
+    in `+(Q||"Unknown")+Le}var ot=1;function Ve(Q){return Q._status===ot?Q._result:null}function Pt(Q,Se,Fe){var Le=Se.displayName||Se.name||"";return Q.displayName||(Le!==""?Fe+"("+Le+")":Fe)}function Jt(Q){if(Q==null)return null;if(typeof Q.tag=="number"&&dt("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue."),typeof Q=="function")return Q.displayName||Q.name||null;if(typeof Q=="string")return Q;switch(Q){case N:return"Fragment";case t:return"Portal";case k:return"Profiler";case F:return"StrictMode";case re:return"Suspense";case y:return"SuspenseList"}if(typeof Q=="object")switch(Q.$$typeof){case j:return"Context.Consumer";case x:return"Context.Provider";case V:return Pt(Q,Q.render,"ForwardRef");case me:return Jt(Q.type);case ge:return Jt(Q.render);case De:{var Se=Q,Fe=Ve(Se);if(Fe)return Jt(Fe);break}}return null}var it={},J=null;function ce(Q){J=Q}it.getCurrentStack=null,it.getStackAddendum=function(){var Q="";if(J){var Se=Jt(J.type),Fe=J._owner;Q+=Qe(Se,J._source,Fe&&Jt(Fe.type))}var Le=it.getCurrentStack;return Le&&(Q+=Le()||""),Q};var Re={current:!1},le={ReactCurrentDispatcher:ze,ReactCurrentBatchConfig:We,ReactCurrentOwner:gt,IsSomeRendererActing:Re,assign:o};o(le,{ReactDebugCurrentFrame:it,ReactComponentTreeHook:{}});function He(Q){{for(var Se=arguments.length,Fe=new Array(Se>1?Se-1:0),Le=1;Le<Se;Le++)Fe[Le-1]=arguments[Le];At("warn",Q,Fe)}}function dt(Q){{for(var Se=arguments.length,Fe=new Array(Se>1?Se-1:0),Le=1;Le<Se;Le++)Fe[Le-1]=arguments[Le];At("error",Q,Fe)}}function At(Q,Se,Fe){{var Le=Fe.length>0&&typeof Fe[Fe.length-1]=="string"&&Fe[Fe.length-1].indexOf(`
+    in`)===0;if(!Le){var pt=le.ReactDebugCurrentFrame,Yn=pt.getStackAddendum();Yn!==""&&(Se+="%s",Fe=Fe.concat([Yn]))}var Cn=Fe.map(function(Ou){return""+Ou});Cn.unshift("Warning: "+Se),Function.prototype.apply.call(console[Q],console,Cn);try{var cr=0,Si="Warning: "+Se.replace(/%s/g,function(){return Fe[cr++]});throw new Error(Si)}catch{}}}var nn={};function an(Q,Se){{var Fe=Q.constructor,Le=Fe&&(Fe.displayName||Fe.name)||"ReactClass",pt=Le+"."+Se;if(nn[pt])return;dt("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",Se,Le),nn[pt]=!0}}var On={isMounted:function(Q){return!1},enqueueForceUpdate:function(Q,Se,Fe){an(Q,"forceUpdate")},enqueueReplaceState:function(Q,Se,Fe,Le){an(Q,"replaceState")},enqueueSetState:function(Q,Se,Fe,Le){an(Q,"setState")}},lr={};Object.freeze(lr);function ln(Q,Se,Fe){this.props=Q,this.context=Se,this.refs=lr,this.updater=Fe||On}ln.prototype.isReactComponent={},ln.prototype.setState=function(Q,Se){if(!(typeof Q=="object"||typeof Q=="function"||Q==null))throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,Q,Se,"setState")},ln.prototype.forceUpdate=function(Q){this.updater.enqueueForceUpdate(this,Q,"forceUpdate")};{var Vt={isMounted:["isMounted","Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],replaceState:["replaceState","Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]},Er=function(Q,Se){Object.defineProperty(ln.prototype,Q,{get:function(){He("%s(...) is deprecated in plain JavaScript React classes. %s",Se[0],Se[1])}})};for(var S in Vt)Vt.hasOwnProperty(S)&&Er(S,Vt[S])}function zt(){}zt.prototype=ln.prototype;function Xn(Q,Se,Fe){this.props=Q,this.context=Se,this.refs=lr,this.updater=Fe||On}var vr=Xn.prototype=new zt;vr.constructor=Xn,o(vr,ln.prototype),vr.isPureReactComponent=!0;function jr(){var Q={current:null};return Object.seal(Q),Q}var fr=Object.prototype.hasOwnProperty,zr={key:!0,ref:!0,__self:!0,__source:!0},Xt,Du,c0;c0={};function Ao(Q){if(fr.call(Q,"ref")){var Se=Object.getOwnPropertyDescriptor(Q,"ref").get;if(Se&&Se.isReactWarning)return!1}return Q.ref!==void 0}function Jo(Q){if(fr.call(Q,"key")){var Se=Object.getOwnPropertyDescriptor(Q,"key").get;if(Se&&Se.isReactWarning)return!1}return Q.key!==void 0}function Fs(Q,Se){var Fe=function(){Xt||(Xt=!0,dt("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://fb.me/react-special-props)",Se))};Fe.isReactWarning=!0,Object.defineProperty(Q,"key",{get:Fe,configurable:!0})}function Zo(Q,Se){var Fe=function(){Du||(Du=!0,dt("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://fb.me/react-special-props)",Se))};Fe.isReactWarning=!0,Object.defineProperty(Q,"ref",{get:Fe,configurable:!0})}function $o(Q){if(typeof Q.ref=="string"&&gt.current&&Q.__self&&gt.current.stateNode!==Q.__self){var Se=Jt(gt.current.type);c0[Se]||(dt('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://fb.me/react-strict-mode-string-ref',Jt(gt.current.type),Q.ref),c0[Se]=!0)}}var qt=function(Q,Se,Fe,Le,pt,Yn,Cn){var cr={$$typeof:E,type:Q,key:Se,ref:Fe,props:Cn,_owner:Yn};return cr._store={},Object.defineProperty(cr._store,"validated",{configurable:!1,enumerable:!1,writable:!0,value:!1}),Object.defineProperty(cr,"_self",{configurable:!1,enumerable:!1,writable:!1,value:Le}),Object.defineProperty(cr,"_source",{configurable:!1,enumerable:!1,writable:!1,value:pt}),Object.freeze&&(Object.freeze(cr.props),Object.freeze(cr)),cr};function xi(Q,Se,Fe){var Le,pt={},Yn=null,Cn=null,cr=null,Si=null;if(Se!=null){Ao(Se)&&(Cn=Se.ref,$o(Se)),Jo(Se)&&(Yn=""+Se.key),cr=Se.__self===void 0?null:Se.__self,Si=Se.__source===void 0?null:Se.__source;for(Le in Se)fr.call(Se,Le)&&!zr.hasOwnProperty(Le)&&(pt[Le]=Se[Le])}var Ou=arguments.length-2;if(Ou===1)pt.children=Fe;else if(Ou>1){for(var ju=Array(Ou),zu=0;zu<Ou;zu++)ju[zu]=arguments[zu+2];Object.freeze&&Object.freeze(ju),pt.children=ju}if(Q&&Q.defaultProps){var wu=Q.defaultProps;for(Le in wu)pt[Le]===void 0&&(pt[Le]=wu[Le])}if(Yn||Cn){var Ti=typeof Q=="function"?Q.displayName||Q.name||"Unknown":Q;Yn&&Fs(pt,Ti),Cn&&Zo(pt,Ti)}return qt(Q,Yn,Cn,cr,Si,gt.current,pt)}function lu(Q,Se){var Fe=qt(Q.type,Se,Q.ref,Q._self,Q._source,Q._owner,Q.props);return Fe}function vi(Q,Se,Fe){if(Q==null)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+Q+".");var Le,pt=o({},Q.props),Yn=Q.key,Cn=Q.ref,cr=Q._self,Si=Q._source,Ou=Q._owner;if(Se!=null){Ao(Se)&&(Cn=Se.ref,Ou=gt.current),Jo(Se)&&(Yn=""+Se.key);var ju;Q.type&&Q.type.defaultProps&&(ju=Q.type.defaultProps);for(Le in Se)fr.call(Se,Le)&&!zr.hasOwnProperty(Le)&&(Se[Le]===void 0&&ju!==void 0?pt[Le]=ju[Le]:pt[Le]=Se[Le])}var zu=arguments.length-2;if(zu===1)pt.children=Fe;else if(zu>1){for(var wu=Array(zu),Ti=0;Ti<zu;Ti++)wu[Ti]=arguments[Ti+2];pt.children=wu}return qt(Q.type,Yn,Cn,cr,Si,Ou,pt)}function Dr(Q){return typeof Q=="object"&&Q!==null&&Q.$$typeof===E}var el=".",Y0=":";function Bu(Q){var Se=/[=:]/g,Fe={"=":"=0",":":"=2"},Le=(""+Q).replace(Se,function(pt){return Fe[pt]});return"$"+Le}var K0=!1,Kr=/\/+/g;function Oo(Q){return(""+Q).replace(Kr,"$&/")}var Mo=10,F0=[];function su(Q,Se,Fe,Le){if(F0.length){var pt=F0.pop();return pt.result=Q,pt.keyPrefix=Se,pt.func=Fe,pt.context=Le,pt.count=0,pt}else return{result:Q,keyPrefix:Se,func:Fe,context:Le,count:0}}function ki(Q){Q.result=null,Q.keyPrefix=null,Q.func=null,Q.context=null,Q.count=0,F0.length<Mo&&F0.push(Q)}function Ps(Q,Se,Fe,Le){var pt=typeof Q;(pt==="undefined"||pt==="boolean")&&(Q=null);var Yn=!1;if(Q===null)Yn=!0;else switch(pt){case"string":case"number":Yn=!0;break;case"object":switch(Q.$$typeof){case E:case t:Yn=!0}}if(Yn)return Fe(Le,Q,Se===""?el+P0(Q,0):Se),1;var Cn,cr,Si=0,Ou=Se===""?el:Se+Y0;if(Array.isArray(Q))for(var ju=0;ju<Q.length;ju++)Cn=Q[ju],cr=Ou+P0(Cn,ju),Si+=Ps(Cn,cr,Fe,Le);else{var zu=Ae(Q);if(typeof zu=="function"){zu===Q.entries&&(K0||He("Using Maps as children is deprecated and will be removed in a future major release. Consider converting children to an array of keyed ReactElements instead."),K0=!0);for(var wu=zu.call(Q),Ti,Fo=0;!(Ti=wu.next()).done;)Cn=Ti.value,cr=Ou+P0(Cn,Fo++),Si+=Ps(Cn,cr,Fe,Le)}else if(pt==="object"){var Mu="";Mu=" If you meant to render a collection of children, use an array instead."+it.getStackAddendum();var po=""+Q;throw Error("Objects are not valid as a React child (found: "+(po==="[object Object]"?"object with keys {"+Object.keys(Q).join(", ")+"}":po)+")."+Mu)}}return Si}function Kl(Q,Se,Fe){return Q==null?0:Ps(Q,"",Se,Fe)}function P0(Q,Se){return typeof Q=="object"&&Q!==null&&Q.key!=null?Bu(Q.key):Se.toString(36)}function d0(Q,Se,Fe){var Le=Q.func,pt=Q.context;Le.call(pt,Se,Q.count++)}function Hr(Q,Se,Fe){if(Q==null)return Q;var Le=su(null,null,Se,Fe);Kl(Q,d0,Le),ki(Le)}function Ri(Q,Se,Fe){var Le=Q.result,pt=Q.keyPrefix,Yn=Q.func,Cn=Q.context,cr=Yn.call(Cn,Se,Q.count++);Array.isArray(cr)?X0(cr,Le,Fe,function(Si){return Si}):cr!=null&&(Dr(cr)&&(cr=lu(cr,pt+(cr.key&&(!Se||Se.key!==cr.key)?Oo(cr.key)+"/":"")+Fe)),Le.push(cr))}function X0(Q,Se,Fe,Le,pt){var Yn="";Fe!=null&&(Yn=Oo(Fe)+"/");var Cn=su(Se,Yn,Le,pt);Kl(Q,Ri,Cn),ki(Cn)}function mi(Q,Se,Fe){if(Q==null)return Q;var Le=[];return X0(Q,Le,null,Se,Fe),Le}function en(Q){return Kl(Q,function(){return null},null)}function In(Q){var Se=[];return X0(Q,Se,null,function(Fe){return Fe}),Se}function Ai(Q){if(!Dr(Q))throw Error("React.Children.only expected to receive a single React element child.");return Q}function yi(Q,Se){Se===void 0?Se=null:Se!==null&&typeof Se!="function"&&dt("createContext: Expected the optional second argument to be a function. Instead received: %s",Se);var Fe={$$typeof:j,_calculateChangedBits:Se,_currentValue:Q,_currentValue2:Q,_threadCount:0,Provider:null,Consumer:null};Fe.Provider={$$typeof:x,_context:Fe};var Le=!1,pt=!1;{var Yn={$$typeof:j,_context:Fe,_calculateChangedBits:Fe._calculateChangedBits};Object.defineProperties(Yn,{Provider:{get:function(){return pt||(pt=!0,dt("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?")),Fe.Provider},set:function(Cn){Fe.Provider=Cn}},_currentValue:{get:function(){return Fe._currentValue},set:function(Cn){Fe._currentValue=Cn}},_currentValue2:{get:function(){return Fe._currentValue2},set:function(Cn){Fe._currentValue2=Cn}},_threadCount:{get:function(){return Fe._threadCount},set:function(Cn){Fe._threadCount=Cn}},Consumer:{get:function(){return Le||(Le=!0,dt("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")),Fe.Consumer}}}),Fe.Consumer=Yn}return Fe._currentRenderer=null,Fe._currentRenderer2=null,Fe}function Wt(Q){var Se={$$typeof:De,_ctor:Q,_status:-1,_result:null};{var Fe,Le;Object.defineProperties(Se,{defaultProps:{configurable:!0,get:function(){return Fe},set:function(pt){dt("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."),Fe=pt,Object.defineProperty(Se,"defaultProps",{enumerable:!0})}},propTypes:{configurable:!0,get:function(){return Le},set:function(pt){dt("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."),Le=pt,Object.defineProperty(Se,"propTypes",{enumerable:!0})}}})}return Se}function Ru(Q){return Q!=null&&Q.$$typeof===me?dt("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."):typeof Q!="function"?dt("forwardRef requires a render function but was given %s.",Q===null?"null":typeof Q):Q.length!==0&&Q.length!==2&&dt("forwardRef render functions accept exactly two parameters: props and ref. %s",Q.length===1?"Did you forget to use the ref parameter?":"Any additional parameter will be undefined."),Q!=null&&(Q.defaultProps!=null||Q.propTypes!=null)&&dt("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?"),{$$typeof:V,render:Q}}function eu(Q){return typeof Q=="string"||typeof Q=="function"||Q===N||Q===q||Q===k||Q===F||Q===re||Q===y||typeof Q=="object"&&Q!==null&&(Q.$$typeof===De||Q.$$typeof===me||Q.$$typeof===x||Q.$$typeof===j||Q.$$typeof===V||Q.$$typeof===ae||Q.$$typeof===we||Q.$$typeof===he||Q.$$typeof===ge)}function Q0(Q,Se){return eu(Q)||dt("memo: The first argument must be a component. Instead received: %s",Q===null?"null":typeof Q),{$$typeof:me,type:Q,compare:Se===void 0?null:Se}}function Yi(){var Q=ze.current;if(Q===null)throw Error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem.`);return Q}function Xl(Q,Se){var Fe=Yi();if(Se!==void 0&&dt("useContext() second argument is reserved for future use in React. Passing it is not supported. You passed: %s.%s",Se,typeof Se=="number"&&Array.isArray(arguments[2])?`
+
+Did you call array.map(useContext)? Calling Hooks inside a loop is not supported. Learn more at https://fb.me/rules-of-hooks`:""),Q._context!==void 0){var Le=Q._context;Le.Consumer===Q?dt("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?"):Le.Provider===Q&&dt("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?")}return Fe.useContext(Q,Se)}function ko(Q){var Se=Yi();return Se.useState(Q)}function li(Q,Se,Fe){var Le=Yi();return Le.useReducer(Q,Se,Fe)}function ao(Q){var Se=Yi();return Se.useRef(Q)}function Ql(Q,Se){var Fe=Yi();return Fe.useEffect(Q,Se)}function No(Q,Se){var Fe=Yi();return Fe.useLayoutEffect(Q,Se)}function Is(Q,Se){var Fe=Yi();return Fe.useCallback(Q,Se)}function $n(Q,Se){var Fe=Yi();return Fe.useMemo(Q,Se)}function tl(Q,Se,Fe){var Le=Yi();return Le.useImperativeHandle(Q,Se,Fe)}function fo(Q,Se){{var Fe=Yi();return Fe.useDebugValue(Q,Se)}}var I0;I0=!1;function Sl(){if(gt.current){var Q=Jt(gt.current.type);if(Q)return`
+
+Check the render method of \``+Q+"`."}return""}function Lo(Q){if(Q!==void 0){var Se=Q.fileName.replace(/^.*[\\\/]/,""),Fe=Q.lineNumber;return`
+
+Check your code at `+Se+":"+Fe+"."}return""}function St(Q){return Q!=null?Lo(Q.__source):""}var Bt={};function Hn(Q){var Se=Sl();if(!Se){var Fe=typeof Q=="string"?Q:Q.displayName||Q.name;Fe&&(Se=`
+
+Check the top-level render call using <`+Fe+">.")}return Se}function qr(Q,Se){if(!(!Q._store||Q._store.validated||Q.key!=null)){Q._store.validated=!0;var Fe=Hn(Se);if(!Bt[Fe]){Bt[Fe]=!0;var Le="";Q&&Q._owner&&Q._owner!==gt.current&&(Le=" It was passed a child from "+Jt(Q._owner.type)+"."),ce(Q),dt('Each child in a list should have a unique "key" prop.%s%s See https://fb.me/react-warning-keys for more information.',Fe,Le),ce(null)}}}function Ki(Q,Se){if(typeof Q=="object"){if(Array.isArray(Q))for(var Fe=0;Fe<Q.length;Fe++){var Le=Q[Fe];Dr(Le)&&qr(Le,Se)}else if(Dr(Q))Q._store&&(Q._store.validated=!0);else if(Q){var pt=Ae(Q);if(typeof pt=="function"&&pt!==Q.entries)for(var Yn=pt.call(Q),Cn;!(Cn=Yn.next()).done;)Dr(Cn.value)&&qr(Cn.value,Se)}}}function Xr(Q){{var Se=Q.type;if(Se==null||typeof Se=="string")return;var Fe=Jt(Se),Le;if(typeof Se=="function")Le=Se.propTypes;else if(typeof Se=="object"&&(Se.$$typeof===V||Se.$$typeof===me))Le=Se.propTypes;else return;Le?(ce(Q),l(Le,Q.props,"prop",Fe,it.getStackAddendum),ce(null)):Se.PropTypes!==void 0&&!I0&&(I0=!0,dt("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?",Fe||"Unknown")),typeof Se.getDefaultProps=="function"&&!Se.getDefaultProps.isReactClassApproved&&dt("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.")}}function Au(Q){{ce(Q);for(var Se=Object.keys(Q.props),Fe=0;Fe<Se.length;Fe++){var Le=Se[Fe];if(Le!=="children"&&Le!=="key"){dt("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.",Le);break}}Q.ref!==null&&dt("Invalid attribute `ref` supplied to `React.Fragment`."),ce(null)}}function p0(Q,Se,Fe){var Le=eu(Q);if(!Le){var pt="";(Q===void 0||typeof Q=="object"&&Q!==null&&Object.keys(Q).length===0)&&(pt+=" You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");var Yn=St(Se);Yn?pt+=Yn:pt+=Sl();var Cn;Q===null?Cn="null":Array.isArray(Q)?Cn="array":Q!==void 0&&Q.$$typeof===E?(Cn="<"+(Jt(Q.type)||"Unknown")+" />",pt=" Did you accidentally export a JSX literal instead of a component?"):Cn=typeof Q,dt("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s",Cn,pt)}var cr=xi.apply(this,arguments);if(cr==null)return cr;if(Le)for(var Si=2;Si<arguments.length;Si++)Ki(arguments[Si],Q);return Q===N?Au(cr):Xr(cr),cr}var Ni=!1;function h0(Q){var Se=p0.bind(null,Q);return Se.type=Q,Ni||(Ni=!0,He("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")),Object.defineProperty(Se,"type",{enumerable:!1,get:function(){return He("Factory.type is deprecated. Access the class directly before passing it to createFactory."),Object.defineProperty(this,"type",{value:Q}),Q}}),Se}function hs(Q,Se,Fe){for(var Le=vi.apply(this,arguments),pt=2;pt<arguments.length;pt++)Ki(arguments[pt],Le.type);return Xr(Le),Le}try{var Ct=Object.freeze({}),co=new Map([[Ct,null]]),nl=new Set([Ct]);co.set(0,0),nl.add(0)}catch{}var Jl=p0,Uu=hs,vs=h0,b0={map:mi,forEach:Hr,count:en,toArray:In,only:Ai};_u.Children=b0,_u.Component=ln,_u.Fragment=N,_u.Profiler=k,_u.PureComponent=Xn,_u.StrictMode=F,_u.Suspense=re,_u.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=le,_u.cloneElement=Uu,_u.createContext=yi,_u.createElement=Jl,_u.createFactory=vs,_u.createRef=jr,_u.forwardRef=Ru,_u.isValidElement=Dr,_u.lazy=Wt,_u.memo=Q0,_u.useCallback=Is,_u.useContext=Xl,_u.useDebugValue=fo,_u.useEffect=Ql,_u.useImperativeHandle=tl,_u.useLayoutEffect=No,_u.useMemo=$n,_u.useReducer=li,_u.useRef=ao,_u.useState=ko,_u.version=f}()});var Mi=nt((eH,QE)=>{"use strict";process.env.NODE_ENV==="production"?QE.exports=eS():QE.exports=lS()});var sS=nt((Wv,By)=>{(function(){var o,l="4.17.21",f=200,h="Unsupported core-js use. Try https://npms.io/search?q=ponyfill.",E="Expected a function",t="Invalid `variable` option passed into `_.template`",N="__lodash_hash_undefined__",F=500,k="__lodash_placeholder__",x=1,j=2,q=4,V=1,re=2,y=1,me=2,De=4,ge=8,ae=16,we=32,he=64,ve=128,ue=256,Ae=512,ze=30,We="...",gt=800,_t=16,Qe=1,ot=2,Ve=3,Pt=1/0,Jt=9007199254740991,it=17976931348623157e292,J=0/0,ce=4294967295,Re=ce-1,le=ce>>>1,He=[["ary",ve],["bind",y],["bindKey",me],["curry",ge],["curryRight",ae],["flip",Ae],["partial",we],["partialRight",he],["rearg",ue]],dt="[object Arguments]",At="[object Array]",nn="[object AsyncFunction]",an="[object Boolean]",On="[object Date]",lr="[object DOMException]",ln="[object Error]",Vt="[object Function]",Er="[object GeneratorFunction]",S="[object Map]",zt="[object Number]",Xn="[object Null]",vr="[object Object]",jr="[object Promise]",fr="[object Proxy]",zr="[object RegExp]",Xt="[object Set]",Du="[object String]",c0="[object Symbol]",Ao="[object Undefined]",Jo="[object WeakMap]",Fs="[object WeakSet]",Zo="[object ArrayBuffer]",$o="[object DataView]",qt="[object Float32Array]",xi="[object Float64Array]",lu="[object Int8Array]",vi="[object Int16Array]",Dr="[object Int32Array]",el="[object Uint8Array]",Y0="[object Uint8ClampedArray]",Bu="[object Uint16Array]",K0="[object Uint32Array]",Kr=/\b__p \+= '';/g,Oo=/\b(__p \+=) '' \+/g,Mo=/(__e\(.*?\)|\b__t\)) \+\n'';/g,F0=/&(?:amp|lt|gt|quot|#39);/g,su=/[&<>"']/g,ki=RegExp(F0.source),Ps=RegExp(su.source),Kl=/<%-([\s\S]+?)%>/g,P0=/<%([\s\S]+?)%>/g,d0=/<%=([\s\S]+?)%>/g,Hr=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,Ri=/^\w*$/,X0=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,mi=/[\\^$.*+?()[\]{}|]/g,en=RegExp(mi.source),In=/^\s+/,Ai=/\s/,yi=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Wt=/\{\n\/\* \[wrapped with (.+)\] \*/,Ru=/,? & /,eu=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Q0=/[()=,{}\[\]\/\s]/,Yi=/\\(\\)?/g,Xl=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,ko=/\w*$/,li=/^[-+]0x[0-9a-f]+$/i,ao=/^0b[01]+$/i,Ql=/^\[object .+?Constructor\]$/,No=/^0o[0-7]+$/i,Is=/^(?:0|[1-9]\d*)$/,$n=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,tl=/($^)/,fo=/['\n\r\u2028\u2029\\]/g,I0="\\ud800-\\udfff",Sl="\\u0300-\\u036f",Lo="\\ufe20-\\ufe2f",St="\\u20d0-\\u20ff",Bt=Sl+Lo+St,Hn="\\u2700-\\u27bf",qr="a-z\\xdf-\\xf6\\xf8-\\xff",Ki="\\xac\\xb1\\xd7\\xf7",Xr="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",Au="\\u2000-\\u206f",p0=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",Ni="A-Z\\xc0-\\xd6\\xd8-\\xde",h0="\\ufe0e\\ufe0f",hs=Ki+Xr+Au+p0,Ct="['\u2019]",co="["+I0+"]",nl="["+hs+"]",Jl="["+Bt+"]",Uu="\\d+",vs="["+Hn+"]",b0="["+qr+"]",Q="[^"+I0+hs+Uu+Hn+qr+Ni+"]",Se="\\ud83c[\\udffb-\\udfff]",Fe="(?:"+Jl+"|"+Se+")",Le="[^"+I0+"]",pt="(?:\\ud83c[\\udde6-\\uddff]){2}",Yn="[\\ud800-\\udbff][\\udc00-\\udfff]",Cn="["+Ni+"]",cr="\\u200d",Si="(?:"+b0+"|"+Q+")",Ou="(?:"+Cn+"|"+Q+")",ju="(?:"+Ct+"(?:d|ll|m|re|s|t|ve))?",zu="(?:"+Ct+"(?:D|LL|M|RE|S|T|VE))?",wu=Fe+"?",Ti="["+h0+"]?",Fo="(?:"+cr+"(?:"+[Le,pt,Yn].join("|")+")"+Ti+wu+")*",Mu="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",po="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",Hu=Ti+wu+Fo,Pa="(?:"+[vs,pt,Yn].join("|")+")"+Hu,v0="(?:"+[Le+Jl+"?",Jl,pt,Yn,co].join("|")+")",ia=RegExp(Ct,"g"),J0=RegExp(Jl,"g"),ua=RegExp(Se+"(?="+Se+")|"+v0+Hu,"g"),Ia=RegExp([Cn+"?"+b0+"+"+ju+"(?="+[nl,Cn,"$"].join("|")+")",Ou+"+"+zu+"(?="+[nl,Cn+Si,"$"].join("|")+")",Cn+"?"+Si+"+"+ju,Cn+"+"+zu,po,Mu,Uu,Pa].join("|"),"g"),ms=RegExp("["+cr+I0+Bt+h0+"]"),S0=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Qn=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],ac=-1,si={};si[qt]=si[xi]=si[lu]=si[vi]=si[Dr]=si[el]=si[Y0]=si[Bu]=si[K0]=!0,si[dt]=si[At]=si[Zo]=si[an]=si[$o]=si[On]=si[ln]=si[Vt]=si[S]=si[zt]=si[vr]=si[zr]=si[Xt]=si[Du]=si[Jo]=!1;var Jr={};Jr[dt]=Jr[At]=Jr[Zo]=Jr[$o]=Jr[an]=Jr[On]=Jr[qt]=Jr[xi]=Jr[lu]=Jr[vi]=Jr[Dr]=Jr[S]=Jr[zt]=Jr[vr]=Jr[zr]=Jr[Xt]=Jr[Du]=Jr[c0]=Jr[el]=Jr[Y0]=Jr[Bu]=Jr[K0]=!0,Jr[ln]=Jr[Vt]=Jr[Jo]=!1;var Zl={\u00C0:"A",\u00C1:"A",\u00C2:"A",\u00C3:"A",\u00C4:"A",\u00C5:"A",\u00E0:"a",\u00E1:"a",\u00E2:"a",\u00E3:"a",\u00E4:"a",\u00E5:"a",\u00C7:"C",\u00E7:"c",\u00D0:"D",\u00F0:"d",\u00C8:"E",\u00C9:"E",\u00CA:"E",\u00CB:"E",\u00E8:"e",\u00E9:"e",\u00EA:"e",\u00EB:"e",\u00CC:"I",\u00CD:"I",\u00CE:"I",\u00CF:"I",\u00EC:"i",\u00ED:"i",\u00EE:"i",\u00EF:"i",\u00D1:"N",\u00F1:"n",\u00D2:"O",\u00D3:"O",\u00D4:"O",\u00D5:"O",\u00D6:"O",\u00D8:"O",\u00F2:"o",\u00F3:"o",\u00F4:"o",\u00F5:"o",\u00F6:"o",\u00F8:"o",\u00D9:"U",\u00DA:"U",\u00DB:"U",\u00DC:"U",\u00F9:"u",\u00FA:"u",\u00FB:"u",\u00FC:"u",\u00DD:"Y",\u00FD:"y",\u00FF:"y",\u00C6:"Ae",\u00E6:"ae",\u00DE:"Th",\u00FE:"th",\u00DF:"ss",\u0100:"A",\u0102:"A",\u0104:"A",\u0101:"a",\u0103:"a",\u0105:"a",\u0106:"C",\u0108:"C",\u010A:"C",\u010C:"C",\u0107:"c",\u0109:"c",\u010B:"c",\u010D:"c",\u010E:"D",\u0110:"D",\u010F:"d",\u0111:"d",\u0112:"E",\u0114:"E",\u0116:"E",\u0118:"E",\u011A:"E",\u0113:"e",\u0115:"e",\u0117:"e",\u0119:"e",\u011B:"e",\u011C:"G",\u011E:"G",\u0120:"G",\u0122:"G",\u011D:"g",\u011F:"g",\u0121:"g",\u0123:"g",\u0124:"H",\u0126:"H",\u0125:"h",\u0127:"h",\u0128:"I",\u012A:"I",\u012C:"I",\u012E:"I",\u0130:"I",\u0129:"i",\u012B:"i",\u012D:"i",\u012F:"i",\u0131:"i",\u0134:"J",\u0135:"j",\u0136:"K",\u0137:"k",\u0138:"k",\u0139:"L",\u013B:"L",\u013D:"L",\u013F:"L",\u0141:"L",\u013A:"l",\u013C:"l",\u013E:"l",\u0140:"l",\u0142:"l",\u0143:"N",\u0145:"N",\u0147:"N",\u014A:"N",\u0144:"n",\u0146:"n",\u0148:"n",\u014B:"n",\u014C:"O",\u014E:"O",\u0150:"O",\u014D:"o",\u014F:"o",\u0151:"o",\u0154:"R",\u0156:"R",\u0158:"R",\u0155:"r",\u0157:"r",\u0159:"r",\u015A:"S",\u015C:"S",\u015E:"S",\u0160:"S",\u015B:"s",\u015D:"s",\u015F:"s",\u0161:"s",\u0162:"T",\u0164:"T",\u0166:"T",\u0163:"t",\u0165:"t",\u0167:"t",\u0168:"U",\u016A:"U",\u016C:"U",\u016E:"U",\u0170:"U",\u0172:"U",\u0169:"u",\u016B:"u",\u016D:"u",\u016F:"u",\u0171:"u",\u0173:"u",\u0174:"W",\u0175:"w",\u0176:"Y",\u0177:"y",\u0178:"Y",\u0179:"Z",\u017B:"Z",\u017D:"Z",\u017A:"z",\u017C:"z",\u017E:"z",\u0132:"IJ",\u0133:"ij",\u0152:"Oe",\u0153:"oe",\u0149:"'n",\u017F:"s"},oa={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},pf={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"},bs={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},ba=parseFloat,Bs=parseInt,m0=typeof global=="object"&&global&&global.Object===Object&&global,Us=typeof self=="object"&&self&&self.Object===Object&&self,zi=m0||Us||Function("return this")(),U=typeof Wv=="object"&&Wv&&!Wv.nodeType&&Wv,H=U&&typeof By=="object"&&By&&!By.nodeType&&By,Y=H&&H.exports===U,ee=Y&&m0.process,Ce=function(){try{var xe=H&&H.require&&H.require("util").types;return xe||ee&&ee.binding&&ee.binding("util")}catch{}}(),_e=Ce&&Ce.isArrayBuffer,Oe=Ce&&Ce.isDate,$=Ce&&Ce.isMap,Ne=Ce&&Ce.isRegExp,Je=Ce&&Ce.isSet,vt=Ce&&Ce.isTypedArray;function oe(xe,tt,Ke){switch(Ke.length){case 0:return xe.call(tt);case 1:return xe.call(tt,Ke[0]);case 2:return xe.call(tt,Ke[0],Ke[1]);case 3:return xe.call(tt,Ke[0],Ke[1],Ke[2])}return xe.apply(tt,Ke)}function qe(xe,tt,Ke,Yt){for(var Kt=-1,pr=xe==null?0:xe.length;++Kt<pr;){var Ei=xe[Kt];tt(Yt,Ei,Ke(Ei),xe)}return Yt}function rt(xe,tt){for(var Ke=-1,Yt=xe==null?0:xe.length;++Ke<Yt&&tt(xe[Ke],Ke,xe)!==!1;);return xe}function xt(xe,tt){for(var Ke=xe==null?0:xe.length;Ke--&&tt(xe[Ke],Ke,xe)!==!1;);return xe}function kt(xe,tt){for(var Ke=-1,Yt=xe==null?0:xe.length;++Ke<Yt;)if(!tt(xe[Ke],Ke,xe))return!1;return!0}function bt(xe,tt){for(var Ke=-1,Yt=xe==null?0:xe.length,Kt=0,pr=[];++Ke<Yt;){var Ei=xe[Ke];tt(Ei,Ke,xe)&&(pr[Kt++]=Ei)}return pr}function sn(xe,tt){var Ke=xe==null?0:xe.length;return!!Ke&&wt(xe,tt,0)>-1}function rn(xe,tt,Ke){for(var Yt=-1,Kt=xe==null?0:xe.length;++Yt<Kt;)if(Ke(tt,xe[Yt]))return!0;return!1}function Ft(xe,tt){for(var Ke=-1,Yt=xe==null?0:xe.length,Kt=Array(Yt);++Ke<Yt;)Kt[Ke]=tt(xe[Ke],Ke,xe);return Kt}function Dn(xe,tt){for(var Ke=-1,Yt=tt.length,Kt=xe.length;++Ke<Yt;)xe[Kt+Ke]=tt[Ke];return xe}function dr(xe,tt,Ke,Yt){var Kt=-1,pr=xe==null?0:xe.length;for(Yt&&pr&&(Ke=xe[++Kt]);++Kt<pr;)Ke=tt(Ke,xe[Kt],Kt,xe);return Ke}function er(xe,tt,Ke,Yt){var Kt=xe==null?0:xe.length;for(Yt&&Kt&&(Ke=xe[--Kt]);Kt--;)Ke=tt(Ke,xe[Kt],Kt,xe);return Ke}function Cr(xe,tt){for(var Ke=-1,Yt=xe==null?0:xe.length;++Ke<Yt;)if(tt(xe[Ke],Ke,xe))return!0;return!1}var Rn=fn("length");function Nr(xe){return xe.split("")}function y0(xe){return xe.match(eu)||[]}function Lr(xe,tt,Ke){var Yt;return Ke(xe,function(Kt,pr,Ei){if(tt(Kt,pr,Ei))return Yt=pr,!1}),Yt}function ut(xe,tt,Ke,Yt){for(var Kt=xe.length,pr=Ke+(Yt?1:-1);Yt?pr--:++pr<Kt;)if(tt(xe[pr],pr,xe))return pr;return-1}function wt(xe,tt,Ke){return tt===tt?la(xe,tt,Ke):ut(xe,It,Ke)}function et(xe,tt,Ke,Yt){for(var Kt=Ke-1,pr=xe.length;++Kt<pr;)if(Yt(xe[Kt],tt))return Kt;return-1}function It(xe){return xe!==xe}function un(xe,tt){var Ke=xe==null?0:xe.length;return Ke?ku(xe,tt)/Ke:J}function fn(xe){return function(tt){return tt==null?o:tt[xe]}}function Jn(xe){return function(tt){return xe==null?o:xe[tt]}}function wr(xe,tt,Ke,Yt,Kt){return Kt(xe,function(pr,Ei,bn){Ke=Yt?(Yt=!1,pr):tt(Ke,pr,Ei,bn)}),Ke}function au(xe,tt){var Ke=xe.length;for(xe.sort(tt);Ke--;)xe[Ke]=xe[Ke].value;return xe}function ku(xe,tt){for(var Ke,Yt=-1,Kt=xe.length;++Yt<Kt;){var pr=tt(xe[Yt]);pr!==o&&(Ke=Ke===o?pr:Ke+pr)}return Ke}function T0(xe,tt){for(var Ke=-1,Yt=Array(xe);++Ke<xe;)Yt[Ke]=tt(Ke);return Yt}function Z0(xe,tt){return Ft(tt,function(Ke){return[Ke,xe[Ke]]})}function Nu(xe){return xe&&xe.slice(0,ho(xe)+1).replace(In,"")}function gi(xe){return function(tt){return xe(tt)}}function Po(xe,tt){return Ft(tt,function(Ke){return xe[Ke]})}function rl(xe,tt){return xe.has(tt)}function hf(xe,tt){for(var Ke=-1,Yt=xe.length;++Ke<Yt&&wt(tt,xe[Ke],0)>-1;);return Ke}function Tl(xe,tt){for(var Ke=xe.length;Ke--&&wt(tt,xe[Ke],0)>-1;);return Ke}function vf(xe,tt){for(var Ke=xe.length,Yt=0;Ke--;)xe[Ke]===tt&&++Yt;return Yt}var Io=Jn(Zl),ys=Jn(oa);function js(xe){return"\\"+bs[xe]}function bo(xe,tt){return xe==null?o:xe[tt]}function Bo(xe){return ms.test(xe)}function gs(xe){return S0.test(xe)}function Xu(xe){for(var tt,Ke=[];!(tt=xe.next()).done;)Ke.push(tt.value);return Ke}function Su(xe){var tt=-1,Ke=Array(xe.size);return xe.forEach(function(Yt,Kt){Ke[++tt]=[Kt,Yt]}),Ke}function _i(xe,tt){return function(Ke){return xe(tt(Ke))}}function C0(xe,tt){for(var Ke=-1,Yt=xe.length,Kt=0,pr=[];++Ke<Yt;){var Ei=xe[Ke];(Ei===tt||Ei===k)&&(xe[Ke]=k,pr[Kt++]=Ke)}return pr}function $0(xe){var tt=-1,Ke=Array(xe.size);return xe.forEach(function(Yt){Ke[++tt]=Yt}),Ke}function Uo(xe){var tt=-1,Ke=Array(xe.size);return xe.forEach(function(Yt){Ke[++tt]=[Yt,Yt]}),Ke}function la(xe,tt,Ke){for(var Yt=Ke-1,Kt=xe.length;++Yt<Kt;)if(xe[Yt]===tt)return Yt;return-1}function $l(xe,tt,Ke){for(var Yt=Ke+1;Yt--;)if(xe[Yt]===tt)return Yt;return Yt}function tu(xe){return Bo(xe)?Ci(xe):Rn(xe)}function Zr(xe){return Bo(xe)?mf(xe):Nr(xe)}function ho(xe){for(var tt=xe.length;tt--&&Ai.test(xe.charAt(tt)););return tt}var Bi=Jn(pf);function Ci(xe){for(var tt=ua.lastIndex=0;ua.test(xe);)++tt;return tt}function mf(xe){return xe.match(ua)||[]}function yf(xe){return xe.match(Ia)||[]}var eo=function xe(tt){tt=tt==null?zi:to.defaults(zi.Object(),tt,to.pick(zi,Qn));var Ke=tt.Array,Yt=tt.Date,Kt=tt.Error,pr=tt.Function,Ei=tt.Math,bn=tt.Object,mu=tt.RegExp,Qu=tt.String,$r=tt.TypeError,Qr=Ke.prototype,qu=pr.prototype,xn=bn.prototype,x0=tt["__core-js_shared__"],Lu=qu.toString,ui=xn.hasOwnProperty,Cl=0,zs=function(){var p=/[^.]+$/.exec(x0&&x0.keys&&x0.keys.IE_PROTO||"");return p?"Symbol(src)_1."+p:""}(),Wu=xn.toString,sa=Lu.call(bn),Xi=zi._,Hs=mu("^"+Lu.call(ui).replace(mi,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),R0=Y?tt.Buffer:o,Hi=tt.Symbol,A0=tt.Uint8Array,qi=R0?R0.allocUnsafe:o,il=_i(bn.getPrototypeOf,bn),xl=bn.create,B0=xn.propertyIsEnumerable,O0=Qr.splice,vo=Hi?Hi.isConcatSpreadable:o,Fu=Hi?Hi.iterator:o,Ju=Hi?Hi.toStringTag:o,es=function(){try{var p=Eo(bn,"defineProperty");return p({},"",{}),p}catch{}}(),_s=tt.clearTimeout!==zi.clearTimeout&&tt.clearTimeout,aa=Yt&&Yt.now!==zi.Date.now&&Yt.now,gf=tt.setTimeout!==zi.setTimeout&&tt.setTimeout,Zu=Ei.ceil,Es=Ei.floor,Rr=bn.getOwnPropertySymbols,no=R0?R0.isBuffer:o,nu=tt.isFinite,fu=Qr.join,Li=_i(bn.keys,bn),ei=Ei.max,Kn=Ei.min,$u=Yt.now,g0=tt.parseInt,_0=Ei.random,Ln=Qr.reverse,fe=Eo(tt,"DataView"),ie=Eo(tt,"Map"),Pe=Eo(tt,"Promise"),Me=Eo(tt,"Set"),at=Eo(tt,"WeakMap"),mt=Eo(bn,"create"),Qt=at&&new at,An={},Sn=Ea(fe),_n=Ea(ie),Tn=Ea(Pe),ir=Ea(Me),Ut=Ea(at),Fi=Hi?Hi.prototype:o,Ar=Fi?Fi.valueOf:o,mr=Fi?Fi.toString:o;function K(p){if(Gu(p)&&!tr(p)&&!(p instanceof ft)){if(p instanceof Wr)return p;if(ui.call(p,"__wrapped__"))return P2(p)}return new Wr(p)}var ti=function(){function p(){}return function(m){if(!Iu(m))return{};if(xl)return xl(m);p.prototype=m;var R=new p;return p.prototype=o,R}}();function ni(){}function Wr(p,m){this.__wrapped__=p,this.__actions__=[],this.__chain__=!!m,this.__index__=0,this.__values__=o}K.templateSettings={escape:Kl,evaluate:P0,interpolate:d0,variable:"",imports:{_:K}},K.prototype=ni.prototype,K.prototype.constructor=K,Wr.prototype=ti(ni.prototype),Wr.prototype.constructor=Wr;function ft(p){this.__wrapped__=p,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=ce,this.__views__=[]}function Di(){var p=new ft(this.__wrapped__);return p.__actions__=iu(this.__actions__),p.__dir__=this.__dir__,p.__filtered__=this.__filtered__,p.__iteratees__=iu(this.__iteratees__),p.__takeCount__=this.__takeCount__,p.__views__=iu(this.__views__),p}function ru(){if(this.__filtered__){var p=new ft(this);p.__dir__=-1,p.__filtered__=!0}else p=this.clone(),p.__dir__*=-1;return p}function E0(){var p=this.__wrapped__.value(),m=this.__dir__,R=tr(p),I=m<0,W=R?p.length:0,te=rs(0,W,this.__views__),pe=te.start,Ee=te.end,be=Ee-pe,Dt=I?Ee:pe-1,Tt=this.__iteratees__,Ot=Tt.length,on=0,Mn=Kn(be,this.__takeCount__);if(!R||!I&&W==be&&Mn==be)return _h(p,this.__actions__);var rr=[];e:for(;be--&&on<Mn;){Dt+=m;for(var br=-1,ar=p[Dt];++br<Ot;){var ri=Tt[br],fi=ri.iteratee,zl=ri.type,Zi=fi(ar);if(zl==ot)ar=Zi;else if(!Zi){if(zl==Qe)continue e;break e}}rr[on++]=ar}return rr}ft.prototype=ti(ni.prototype),ft.prototype.constructor=ft;function Un(p){var m=-1,R=p==null?0:p.length;for(this.clear();++m<R;){var I=p[m];this.set(I[0],I[1])}}function e0(){this.__data__=mt?mt(null):{},this.size=0}function ro(p){var m=this.has(p)&&delete this.__data__[p];return this.size-=m?1:0,m}function mo(p){var m=this.__data__;if(mt){var R=m[p];return R===N?o:R}return ui.call(m,p)?m[p]:o}function t0(p){var m=this.__data__;return mt?m[p]!==o:ui.call(m,p)}function jo(p,m){var R=this.__data__;return this.size+=this.has(p)?0:1,R[p]=mt&&m===o?N:m,this}Un.prototype.clear=e0,Un.prototype.delete=ro,Un.prototype.get=mo,Un.prototype.has=t0,Un.prototype.set=jo;function io(p){var m=-1,R=p==null?0:p.length;for(this.clear();++m<R;){var I=p[m];this.set(I[0],I[1])}}function Ba(){this.__data__=[],this.size=0}function _f(p){var m=this.__data__,R=ts(m,p);if(R<0)return!1;var I=m.length-1;return R==I?m.pop():O0.call(m,R,1),--this.size,!0}function fc(p){var m=this.__data__,R=ts(m,p);return R<0?o:m[R][1]}function Ds(p){return ts(this.__data__,p)>-1}function fa(p,m){var R=this.__data__,I=ts(R,p);return I<0?(++this.size,R.push([p,m])):R[I][1]=m,this}io.prototype.clear=Ba,io.prototype.delete=_f,io.prototype.get=fc,io.prototype.has=Ds,io.prototype.set=fa;function U0(p){var m=-1,R=p==null?0:p.length;for(this.clear();++m<R;){var I=p[m];this.set(I[0],I[1])}}function cc(){this.size=0,this.__data__={hash:new Un,map:new(ie||io),string:new Un}}function Ua(p){var m=dl(this,p).delete(p);return this.size-=m?1:0,m}function _2(p){return dl(this,p).get(p)}function nd(p){return dl(this,p).has(p)}function rd(p,m){var R=dl(this,p),I=R.size;return R.set(p,m),this.size+=R.size==I?0:1,this}U0.prototype.clear=cc,U0.prototype.delete=Ua,U0.prototype.get=_2,U0.prototype.has=nd,U0.prototype.set=rd;function yo(p){var m=-1,R=p==null?0:p.length;for(this.__data__=new U0;++m<R;)this.add(p[m])}function qc(p){return this.__data__.set(p,N),this}function Rl(p){return this.__data__.has(p)}yo.prototype.add=yo.prototype.push=qc,yo.prototype.has=Rl;function ul(p){var m=this.__data__=new io(p);this.size=m.size}function E2(){this.__data__=new io,this.size=0}function qs(p){var m=this.__data__,R=m.delete(p);return this.size=m.size,R}function Al(p){return this.__data__.get(p)}function id(p){return this.__data__.has(p)}function zo(p,m){var R=this.__data__;if(R instanceof io){var I=R.__data__;if(!ie||I.length<f-1)return I.push([p,m]),this.size=++R.size,this;R=this.__data__=new U0(I)}return R.set(p,m),this.size=R.size,this}ul.prototype.clear=E2,ul.prototype.delete=qs,ul.prototype.get=Al,ul.prototype.has=id,ul.prototype.set=zo;function ja(p,m){var R=tr(p),I=!R&&pl(p),W=!R&&!I&&Js(p),te=!R&&!I&&!W&&Ra(p),pe=R||I||W||te,Ee=pe?T0(p.length,Qu):[],be=Ee.length;for(var Dt in p)(m||ui.call(p,Dt))&&!(pe&&(Dt=="length"||W&&(Dt=="offset"||Dt=="parent")||te&&(Dt=="buffer"||Dt=="byteLength"||Dt=="byteOffset")||Do(Dt,be)))&&Ee.push(Dt);return Ee}function za(p){var m=p.length;return m?p[ad(0,m-1)]:o}function Ha(p,m){return wc(iu(p),n0(m,0,p.length))}function ca(p){return wc(iu(p))}function ws(p,m,R){(R!==o&&!So(p[m],R)||R===o&&!(m in p))&&Vu(p,m,R)}function Ss(p,m,R){var I=p[m];(!(ui.call(p,m)&&So(I,R))||R===o&&!(m in p))&&Vu(p,m,R)}function ts(p,m){for(var R=p.length;R--;)if(So(p[R][0],m))return R;return-1}function Ho(p,m,R,I){return Ts(p,function(W,te,pe){m(I,W,R(W),pe)}),I}function Ef(p,m){return p&&M0(m,N0(m),p)}function ol(p,m){return p&&M0(m,dn(m),p)}function Vu(p,m,R){m=="__proto__"&&es?es(p,m,{configurable:!0,enumerable:!0,value:R,writable:!0}):p[m]=R}function qa(p,m){for(var R=-1,I=m.length,W=Ke(I),te=p==null;++R<I;)W[R]=te?o:Ul(p,m[R]);return W}function n0(p,m,R){return p===p&&(R!==o&&(p=p<=R?p:R),m!==o&&(p=p>=m?p:m)),p}function j0(p,m,R,I,W,te){var pe,Ee=m&x,be=m&j,Dt=m&q;if(R&&(pe=W?R(p,I,W,te):R(p)),pe!==o)return pe;if(!Iu(p))return p;var Tt=tr(p);if(Tt){if(pe=Cs(p),!Ee)return iu(p,pe)}else{var Ot=Pu(p),on=Ot==Vt||Ot==Er;if(Js(p))return vc(p,Ee);if(Ot==vr||Ot==dt||on&&!W){if(pe=be||on?{}:Ec(p),!Ee)return be?ns(p,ol(pe,p)):u0(p,Ef(pe,p))}else{if(!Jr[Ot])return W?p:{};pe=Th(p,Ot,Ee)}}te||(te=new ul);var Mn=te.get(p);if(Mn)return Mn;te.set(p,pe),Pd(p)?p.forEach(function(ar){pe.add(j0(ar,m,R,ar,p,te))}):_p(p)&&p.forEach(function(ar,ri){pe.set(ri,j0(ar,m,R,ri,p,te))});var rr=Dt?be?sr:r1:be?dn:N0,br=Tt?o:rr(p);return rt(br||p,function(ar,ri){br&&(ri=ar,ar=p[ri]),Ss(pe,ri,j0(ar,m,R,ri,p,te))}),pe}function Df(p){var m=N0(p);return function(R){return Wc(R,p,m)}}function Wc(p,m,R){var I=R.length;if(p==null)return!I;for(p=bn(p);I--;){var W=R[I],te=m[W],pe=p[W];if(pe===o&&!(W in p)||!te(pe))return!1}return!0}function dc(p,m,R){if(typeof p!="function")throw new $r(E);return Qa(function(){p.apply(o,R)},m)}function Ol(p,m,R,I){var W=-1,te=sn,pe=!0,Ee=p.length,be=[],Dt=m.length;if(!Ee)return be;R&&(m=Ft(m,gi(R))),I?(te=rn,pe=!1):m.length>=f&&(te=rl,pe=!1,m=new yo(m));e:for(;++W<Ee;){var Tt=p[W],Ot=R==null?Tt:R(Tt);if(Tt=I||Tt!==0?Tt:0,pe&&Ot===Ot){for(var on=Dt;on--;)if(m[on]===Ot)continue e;be.push(Tt)}else te(m,Ot,I)||be.push(Tt)}return be}var Ts=fl(A),da=fl(P,!0);function ud(p,m){var R=!0;return Ts(p,function(I,W,te){return R=!!m(I,W,te),R}),R}function pa(p,m,R){for(var I=-1,W=p.length;++I<W;){var te=p[I],pe=m(te);if(pe!=null&&(Ee===o?pe===pe&&!Bl(pe):R(pe,Ee)))var Ee=pe,be=te}return be}function pc(p,m,R,I){var W=p.length;for(R=Mr(R),R<0&&(R=-R>W?0:W+R),I=I===o||I>W?W:Mr(I),I<0&&(I+=W),I=R>I?0:Dp(I);R<I;)p[R++]=m;return p}function Vc(p,m){var R=[];return Ts(p,function(I,W,te){m(I,W,te)&&R.push(I)}),R}function Wi(p,m,R,I,W){var te=-1,pe=p.length;for(R||(R=is),W||(W=[]);++te<pe;){var Ee=p[te];m>0&&R(Ee)?m>1?Wi(Ee,m-1,R,I,W):Dn(W,Ee):I||(W[W.length]=Ee)}return W}var _=yc(),g=yc(!0);function A(p,m){return p&&_(p,m,N0)}function P(p,m){return p&&g(p,m,N0)}function B(p,m){return bt(m,function(R){return xa(p[R])})}function Z(p,m){m=Ws(m,p);for(var R=0,I=m.length;p!=null&&R<I;)p=p[Fl(m[R++])];return R&&R==I?p:o}function de(p,m,R){var I=m(p);return tr(p)?I:Dn(I,R(p))}function yt(p){return p==null?p===o?Ao:Xn:Ju&&Ju in bn(p)?gc(p):Xa(p)}function Rt(p,m){return p>m}function Nt(p,m){return p!=null&&ui.call(p,m)}function xr(p,m){return p!=null&&m in bn(p)}function r0(p,m,R){return p>=Kn(m,R)&&p<ei(m,R)}function cu(p,m,R){for(var I=R?rn:sn,W=p[0].length,te=p.length,pe=te,Ee=Ke(te),be=1/0,Dt=[];pe--;){var Tt=p[pe];pe&&m&&(Tt=Ft(Tt,gi(m))),be=Kn(Tt.length,be),Ee[pe]=!R&&(m||W>=120&&Tt.length>=120)?new yo(pe&&Tt):o}Tt=p[0];var Ot=-1,on=Ee[0];e:for(;++Ot<W&&Dt.length<be;){var Mn=Tt[Ot],rr=m?m(Mn):Mn;if(Mn=R||Mn!==0?Mn:0,!(on?rl(on,rr):I(Dt,rr,R))){for(pe=te;--pe;){var br=Ee[pe];if(!(br?rl(br,rr):I(p[pe],rr,R)))continue e}on&&on.push(rr),Dt.push(Mn)}}return Dt}function z0(p,m,R,I){return A(p,function(W,te,pe){m(I,R(W),te,pe)}),I}function Ml(p,m,R){m=Ws(m,p),p=Ed(p,m);var I=p==null?p:p[Fl(Il(m))];return I==null?o:oe(I,p,R)}function i0(p){return Gu(p)&&yt(p)==dt}function Ge(p){return Gu(p)&&yt(p)==Zo}function je(p){return Gu(p)&&yt(p)==On}function st(p,m,R,I,W){return p===m?!0:p==null||m==null||!Gu(p)&&!Gu(m)?p!==p&&m!==m:$t(p,m,R,I,st,W)}function $t(p,m,R,I,W,te){var pe=tr(p),Ee=tr(m),be=pe?At:Pu(p),Dt=Ee?At:Pu(m);be=be==dt?vr:be,Dt=Dt==dt?vr:Dt;var Tt=be==vr,Ot=Dt==vr,on=be==Dt;if(on&&Js(p)){if(!Js(m))return!1;pe=!0,Tt=!1}if(on&&!Tt)return te||(te=new ul),pe||Ra(p)?Of(p,m,R,I,W,te):Sh(p,m,be,R,I,W,te);if(!(R&V)){var Mn=Tt&&ui.call(p,"__wrapped__"),rr=Ot&&ui.call(m,"__wrapped__");if(Mn||rr){var br=Mn?p.value():p,ar=rr?m.value():m;return te||(te=new ul),W(br,ar,R,I,te)}}return on?(te||(te=new ul),cm(p,m,R,I,W,te)):!1}function Wn(p){return Gu(p)&&Pu(p)==S}function oi(p,m,R,I){var W=R.length,te=W,pe=!I;if(p==null)return!te;for(p=bn(p);W--;){var Ee=R[W];if(pe&&Ee[2]?Ee[1]!==p[Ee[0]]:!(Ee[0]in p))return!1}for(;++W<te;){Ee=R[W];var be=Ee[0],Dt=p[be],Tt=Ee[1];if(pe&&Ee[2]){if(Dt===o&&!(be in p))return!1}else{var Ot=new ul;if(I)var on=I(Dt,Tt,be,p,m,Ot);if(!(on===o?st(Tt,Dt,V|re,I,Ot):on))return!1}}return!0}function ur(p){if(!Iu(p)||dm(p))return!1;var m=xa(p)?Hs:Ql;return m.test(Ea(p))}function ai(p){return Gu(p)&&yt(p)==zr}function Qi(p){return Gu(p)&&Pu(p)==Xt}function Vr(p){return Gu(p)&&Ld(p.length)&&!!si[yt(p)]}function Tu(p){return typeof p=="function"?p:p==null?l0:typeof p=="object"?tr(p)?wf(p[0],p[1]):w2(p):Ip(p)}function Wa(p){if(!Nf(p))return Li(p);var m=[];for(var R in bn(p))ui.call(p,R)&&R!="constructor"&&m.push(R);return m}function Va(p){if(!Iu(p))return i1(p);var m=Nf(p),R=[];for(var I in p)I=="constructor"&&(m||!ui.call(p,I))||R.push(I);return R}function od(p,m){return p<m}function D2(p,m){var R=-1,I=hl(p)?Ke(p.length):[];return Ts(p,function(W,te,pe){I[++R]=m(W,te,pe)}),I}function w2(p){var m=jn(p);return m.length==1&&m[0][2]?gd(m[0][0],m[0][1]):function(R){return R===p||oi(R,p,m)}}function wf(p,m){return Ji(p)&&Lf(m)?gd(Fl(p),m):function(R){var I=Ul(R,p);return I===o&&I===m?xc(R,p):st(m,I,V|re)}}function ld(p,m,R,I,W){p!==m&&_(m,function(te,pe){if(W||(W=new ul),Iu(te))hh(p,m,pe,R,ld,I,W);else{var Ee=I?I(Ff(p,pe),te,pe+"",p,m,W):o;Ee===o&&(Ee=te),ws(p,pe,Ee)}},dn)}function hh(p,m,R,I,W,te,pe){var Ee=Ff(p,R),be=Ff(m,R),Dt=pe.get(be);if(Dt){ws(p,R,Dt);return}var Tt=te?te(Ee,be,R+"",p,m,pe):o,Ot=Tt===o;if(Ot){var on=tr(be),Mn=!on&&Js(be),rr=!on&&!Mn&&Ra(be);Tt=be,on||Mn||rr?tr(Ee)?Tt=Ee:o0(Ee)?Tt=iu(Ee):Mn?(Ot=!1,Tt=vc(be,!0)):rr?(Ot=!1,Tt=$c(be,!0)):Tt=[]:Cc(be)||pl(be)?(Tt=Ee,pl(Ee)?Tt=yu(Ee):(!Iu(Ee)||xa(Ee))&&(Tt=Ec(be))):Ot=!1}Ot&&(pe.set(be,Tt),W(Tt,be,I,te,pe),pe.delete(be)),ws(p,R,Tt)}function Gc(p,m){var R=p.length;if(!!R)return m+=m<0?R:0,Do(m,R)?p[m]:o}function go(p,m,R){m.length?m=Ft(m,function(te){return tr(te)?function(pe){return Z(pe,te.length===1?te[0]:te)}:te}):m=[l0];var I=-1;m=Ft(m,gi(Vn()));var W=D2(p,function(te,pe,Ee){var be=Ft(m,function(Dt){return Dt(te)});return{criteria:be,index:++I,value:te}});return au(W,function(te,pe){return sm(te,pe,R)})}function vh(p,m){return mh(p,m,function(R,I){return xc(p,I)})}function mh(p,m,R){for(var I=-1,W=m.length,te={};++I<W;){var pe=m[I],Ee=Z(p,pe);R(Ee,pe)&&Ga(te,Ws(pe,p),Ee)}return te}function _o(p){return function(m){return Z(m,p)}}function kl(p,m,R,I){var W=I?et:wt,te=-1,pe=m.length,Ee=p;for(p===m&&(m=iu(m)),R&&(Ee=Ft(p,gi(R)));++te<pe;)for(var be=0,Dt=m[te],Tt=R?R(Dt):Dt;(be=W(Ee,Tt,be,I))>-1;)Ee!==p&&O0.call(Ee,be,1),O0.call(p,be,1);return p}function sd(p,m){for(var R=p?m.length:0,I=R-1;R--;){var W=m[R];if(R==I||W!==te){var te=W;Do(W)?O0.call(p,W,1):x2(p,W)}}return p}function ad(p,m){return p+Es(_0()*(m-p+1))}function S2(p,m,R,I){for(var W=-1,te=ei(Zu((m-p)/(R||1)),0),pe=Ke(te);te--;)pe[I?te:++W]=p,p+=R;return pe}function Yc(p,m){var R="";if(!p||m<1||m>Jt)return R;do m%2&&(R+=p),m=Es(m/2),m&&(p+=p);while(m);return R}function Ir(p,m){return l1(L2(p,m,l0),p+"")}function fd(p){return za(Nc(p))}function cd(p,m){var R=Nc(p);return wc(R,n0(m,0,R.length))}function Ga(p,m,R,I){if(!Iu(p))return p;m=Ws(m,p);for(var W=-1,te=m.length,pe=te-1,Ee=p;Ee!=null&&++W<te;){var be=Fl(m[W]),Dt=R;if(be==="__proto__"||be==="constructor"||be==="prototype")return p;if(W!=pe){var Tt=Ee[be];Dt=I?I(Tt,be,Ee):o,Dt===o&&(Dt=Iu(Tt)?Tt:Do(m[W+1])?[]:{})}Ss(Ee,be,Dt),Ee=Ee[be]}return p}var Kc=Qt?function(p,m){return Qt.set(p,m),p}:l0,T2=es?function(p,m){return es(p,"toString",{configurable:!0,enumerable:!1,value:Xd(m),writable:!0})}:l0;function ll(p){return wc(Nc(p))}function sl(p,m,R){var I=-1,W=p.length;m<0&&(m=-m>W?0:W+m),R=R>W?W:R,R<0&&(R+=W),W=m>R?0:R-m>>>0,m>>>=0;for(var te=Ke(W);++I<W;)te[I]=p[I+m];return te}function yh(p,m){var R;return Ts(p,function(I,W,te){return R=m(I,W,te),!R}),!!R}function Sf(p,m,R){var I=0,W=p==null?I:p.length;if(typeof m=="number"&&m===m&&W<=le){for(;I<W;){var te=I+W>>>1,pe=p[te];pe!==null&&!Bl(pe)&&(R?pe<=m:pe<m)?I=te+1:W=te}return W}return Xc(p,m,l0,R)}function Xc(p,m,R,I){var W=0,te=p==null?0:p.length;if(te===0)return 0;m=R(m);for(var pe=m!==m,Ee=m===null,be=Bl(m),Dt=m===o;W<te;){var Tt=Es((W+te)/2),Ot=R(p[Tt]),on=Ot!==o,Mn=Ot===null,rr=Ot===Ot,br=Bl(Ot);if(pe)var ar=I||rr;else Dt?ar=rr&&(I||on):Ee?ar=rr&&on&&(I||!Mn):be?ar=rr&&on&&!Mn&&(I||!br):Mn||br?ar=!1:ar=I?Ot<=m:Ot<m;ar?W=Tt+1:te=Tt}return Kn(te,Re)}function C2(p,m){for(var R=-1,I=p.length,W=0,te=[];++R<I;){var pe=p[R],Ee=m?m(pe):pe;if(!R||!So(Ee,be)){var be=Ee;te[W++]=pe===0?0:pe}}return te}function gh(p){return typeof p=="number"?p:Bl(p)?J:+p}function al(p){if(typeof p=="string")return p;if(tr(p))return Ft(p,al)+"";if(Bl(p))return mr?mr.call(p):"";var m=p+"";return m=="0"&&1/p==-Pt?"-0":m}function ha(p,m,R){var I=-1,W=sn,te=p.length,pe=!0,Ee=[],be=Ee;if(R)pe=!1,W=rn;else if(te>=f){var Dt=m?null:am(p);if(Dt)return $0(Dt);pe=!1,W=rl,be=new yo}else be=m?[]:Ee;e:for(;++I<te;){var Tt=p[I],Ot=m?m(Tt):Tt;if(Tt=R||Tt!==0?Tt:0,pe&&Ot===Ot){for(var on=be.length;on--;)if(be[on]===Ot)continue e;m&&be.push(Ot),Ee.push(Tt)}else W(be,Ot,R)||(be!==Ee&&be.push(Ot),Ee.push(Tt))}return Ee}function x2(p,m){return m=Ws(m,p),p=Ed(p,m),p==null||delete p[Fl(Il(m))]}function R2(p,m,R,I){return Ga(p,m,R(Z(p,m)),I)}function hc(p,m,R,I){for(var W=p.length,te=I?W:-1;(I?te--:++te<W)&&m(p[te],te,p););return R?sl(p,I?0:te,I?te+1:W):sl(p,I?te+1:0,I?W:te)}function _h(p,m){var R=p;return R instanceof ft&&(R=R.value()),dr(m,function(I,W){return W.func.apply(W.thisArg,Dn([I],W.args))},R)}function A2(p,m,R){var I=p.length;if(I<2)return I?ha(p[0]):[];for(var W=-1,te=Ke(I);++W<I;)for(var pe=p[W],Ee=-1;++Ee<I;)Ee!=W&&(te[W]=Ol(te[W]||pe,p[Ee],m,R));return ha(Wi(te,1),m,R)}function dd(p,m,R){for(var I=-1,W=p.length,te=m.length,pe={};++I<W;){var Ee=I<te?m[I]:o;R(pe,p[I],Ee)}return pe}function Qc(p){return o0(p)?p:[]}function Jc(p){return typeof p=="function"?p:l0}function Ws(p,m){return tr(p)?p:Ji(p,m)?[p]:s1(Ui(p))}var O2=Ir;function va(p,m,R){var I=p.length;return R=R===o?I:R,!m&&R>=I?p:sl(p,m,R)}var Zc=_s||function(p){return zi.clearTimeout(p)};function vc(p,m){if(m)return p.slice();var R=p.length,I=qi?qi(R):new p.constructor(R);return p.copy(I),I}function mc(p){var m=new p.constructor(p.byteLength);return new A0(m).set(new A0(p)),m}function pd(p,m){var R=m?mc(p.buffer):p.buffer;return new p.constructor(R,p.byteOffset,p.byteLength)}function Eh(p){var m=new p.constructor(p.source,ko.exec(p));return m.lastIndex=p.lastIndex,m}function Tf(p){return Ar?bn(Ar.call(p)):{}}function $c(p,m){var R=m?mc(p.buffer):p.buffer;return new p.constructor(R,p.byteOffset,p.length)}function Dh(p,m){if(p!==m){var R=p!==o,I=p===null,W=p===p,te=Bl(p),pe=m!==o,Ee=m===null,be=m===m,Dt=Bl(m);if(!Ee&&!Dt&&!te&&p>m||te&&pe&&be&&!Ee&&!Dt||I&&pe&&be||!R&&be||!W)return 1;if(!I&&!te&&!Dt&&p<m||Dt&&R&&W&&!I&&!te||Ee&&R&&W||!pe&&W||!be)return-1}return 0}function sm(p,m,R){for(var I=-1,W=p.criteria,te=m.criteria,pe=W.length,Ee=R.length;++I<pe;){var be=Dh(W[I],te[I]);if(be){if(I>=Ee)return be;var Dt=R[I];return be*(Dt=="desc"?-1:1)}}return p.index-m.index}function Vs(p,m,R,I){for(var W=-1,te=p.length,pe=R.length,Ee=-1,be=m.length,Dt=ei(te-pe,0),Tt=Ke(be+Dt),Ot=!I;++Ee<be;)Tt[Ee]=m[Ee];for(;++W<pe;)(Ot||W<te)&&(Tt[R[W]]=p[W]);for(;Dt--;)Tt[Ee++]=p[W++];return Tt}function ma(p,m,R,I){for(var W=-1,te=p.length,pe=-1,Ee=R.length,be=-1,Dt=m.length,Tt=ei(te-Ee,0),Ot=Ke(Tt+Dt),on=!I;++W<Tt;)Ot[W]=p[W];for(var Mn=W;++be<Dt;)Ot[Mn+be]=m[be];for(;++pe<Ee;)(on||W<te)&&(Ot[Mn+R[pe]]=p[W++]);return Ot}function iu(p,m){var R=-1,I=p.length;for(m||(m=Ke(I));++R<I;)m[R]=p[R];return m}function M0(p,m,R,I){var W=!R;R||(R={});for(var te=-1,pe=m.length;++te<pe;){var Ee=m[te],be=I?I(R[Ee],p[Ee],Ee,R,p):o;be===o&&(be=p[Ee]),W?Vu(R,Ee,be):Ss(R,Ee,be)}return R}function u0(p,m){return M0(p,oo(p),m)}function ns(p,m){return M0(p,Ka(p),m)}function Ya(p,m){return function(R,I){var W=tr(R)?qe:Ho,te=m?m():{};return W(R,p,Vn(I,2),te)}}function uo(p){return Ir(function(m,R){var I=-1,W=R.length,te=W>1?R[W-1]:o,pe=W>2?R[2]:o;for(te=p.length>3&&typeof te=="function"?(W--,te):o,pe&&lo(R[0],R[1],pe)&&(te=W<3?o:te,W=1),m=bn(m);++I<W;){var Ee=R[I];Ee&&p(m,Ee,I,te)}return m})}function fl(p,m){return function(R,I){if(R==null)return R;if(!hl(R))return p(R,I);for(var W=R.length,te=m?W:-1,pe=bn(R);(m?te--:++te<W)&&I(pe[te],te,pe)!==!1;);return R}}function yc(p){return function(m,R,I){for(var W=-1,te=bn(m),pe=I(m),Ee=pe.length;Ee--;){var be=pe[p?Ee:++W];if(R(te[be],be,te)===!1)break}return m}}function M2(p,m,R){var I=m&y,W=xf(p);function te(){var pe=this&&this!==zi&&this instanceof te?W:p;return pe.apply(I?R:this,arguments)}return te}function wh(p){return function(m){m=Ui(m);var R=Bo(m)?Zr(m):o,I=R?R[0]:m.charAt(0),W=R?va(R,1).join(""):m.slice(1);return I[p]()+W}}function Cf(p){return function(m){return dr(Dv(Vd(m).replace(ia,"")),p,"")}}function xf(p){return function(){var m=arguments;switch(m.length){case 0:return new p;case 1:return new p(m[0]);case 2:return new p(m[0],m[1]);case 3:return new p(m[0],m[1],m[2]);case 4:return new p(m[0],m[1],m[2],m[3]);case 5:return new p(m[0],m[1],m[2],m[3],m[4]);case 6:return new p(m[0],m[1],m[2],m[3],m[4],m[5]);case 7:return new p(m[0],m[1],m[2],m[3],m[4],m[5],m[6])}var R=ti(p.prototype),I=p.apply(R,m);return Iu(I)?I:R}}function e1(p,m,R){var I=xf(p);function W(){for(var te=arguments.length,pe=Ke(te),Ee=te,be=yr(W);Ee--;)pe[Ee]=arguments[Ee];var Dt=te<3&&pe[0]!==be&&pe[te-1]!==be?[]:C0(pe,be);if(te-=Dt.length,te<R)return wi(p,m,ya,W.placeholder,o,pe,Dt,o,o,R-te);var Tt=this&&this!==zi&&this instanceof W?I:p;return oe(Tt,this,pe)}return W}function Nl(p){return function(m,R,I){var W=bn(m);if(!hl(m)){var te=Vn(R,3);m=N0(m),R=function(Ee){return te(W[Ee],Ee,W)}}var pe=p(m,R,I);return pe>-1?W[te?m[pe]:pe]:o}}function t1(p){return cl(function(m){var R=m.length,I=R,W=Wr.prototype.thru;for(p&&m.reverse();I--;){var te=m[I];if(typeof te!="function")throw new $r(E);if(W&&!pe&&qo(te)=="wrapper")var pe=new Wr([],!0)}for(I=pe?I:R;++I<R;){te=m[I];var Ee=qo(te),be=Ee=="wrapper"?qn(te):o;be&&kf(be[0])&&be[1]==(ve|ge|we|ue)&&!be[4].length&&be[9]==1?pe=pe[qo(be[0])].apply(pe,be[3]):pe=te.length==1&&kf(te)?pe[Ee]():pe.thru(te)}return function(){var Dt=arguments,Tt=Dt[0];if(pe&&Dt.length==1&&tr(Tt))return pe.plant(Tt).value();for(var Ot=0,on=R?m[Ot].apply(this,Dt):Tt;++Ot<R;)on=m[Ot].call(this,on);return on}})}function ya(p,m,R,I,W,te,pe,Ee,be,Dt){var Tt=m&ve,Ot=m&y,on=m&me,Mn=m&(ge|ae),rr=m&Ae,br=on?o:xf(p);function ar(){for(var ri=arguments.length,fi=Ke(ri),zl=ri;zl--;)fi[zl]=arguments[zl];if(Mn)var Zi=yr(ar),so=vf(fi,Zi);if(I&&(fi=Vs(fi,I,W,Mn)),te&&(fi=ma(fi,te,pe,Mn)),ri-=so,Mn&&ri<Dt){var s0=C0(fi,Zi);return wi(p,m,ya,ar.placeholder,R,fi,s0,Ee,be,Dt-ri)}var Os=Ot?R:this,Co=on?Os[p]:p;return ri=fi.length,Ee?fi=u1(fi,Ee):rr&&ri>1&&fi.reverse(),Tt&&be<ri&&(fi.length=be),this&&this!==zi&&this instanceof ar&&(Co=br||xf(Co)),Co.apply(Os,fi)}return ar}function hd(p,m){return function(R,I){return z0(R,p,m(I),{})}}function vd(p,m){return function(R,I){var W;if(R===o&&I===o)return m;if(R!==o&&(W=R),I!==o){if(W===o)return I;typeof R=="string"||typeof I=="string"?(R=al(R),I=al(I)):(R=gh(R),I=gh(I)),W=p(R,I)}return W}}function Fr(p){return cl(function(m){return m=Ft(m,gi(Vn())),Ir(function(R){var I=this;return p(m,function(W){return oe(W,I,R)})})})}function ga(p,m){m=m===o?" ":al(m);var R=m.length;if(R<2)return R?Yc(m,p):m;var I=Yc(m,Zu(p/tu(m)));return Bo(m)?va(Zr(I),0,p).join(""):I.slice(0,p)}function k2(p,m,R,I){var W=m&y,te=xf(p);function pe(){for(var Ee=-1,be=arguments.length,Dt=-1,Tt=I.length,Ot=Ke(Tt+be),on=this&&this!==zi&&this instanceof pe?te:p;++Dt<Tt;)Ot[Dt]=I[Dt];for(;be--;)Ot[Dt++]=arguments[++Ee];return oe(on,W?R:this,Ot)}return pe}function n1(p){return function(m,R,I){return I&&typeof I!="number"&&lo(m,R,I)&&(R=I=o),m=Aa(m),R===o?(R=m,m=0):R=Aa(R),I=I===o?m<R?1:-1:Aa(I),S2(m,R,I,p)}}function md(p){return function(m,R){return typeof m=="string"&&typeof R=="string"||(m=vl(m),R=vl(R)),p(m,R)}}function wi(p,m,R,I,W,te,pe,Ee,be,Dt){var Tt=m&ge,Ot=Tt?pe:o,on=Tt?o:pe,Mn=Tt?te:o,rr=Tt?o:te;m|=Tt?we:he,m&=~(Tt?he:we),m&De||(m&=~(y|me));var br=[p,m,W,Mn,Ot,rr,on,Ee,be,Dt],ar=R.apply(o,br);return kf(p)&&o1(ar,br),ar.placeholder=I,F2(ar,p,m)}function N2(p){var m=Ei[p];return function(R,I){if(R=vl(R),I=I==null?0:Kn(Mr(I),292),I&&nu(R)){var W=(Ui(R)+"e").split("e"),te=m(W[0]+"e"+(+W[1]+I));return W=(Ui(te)+"e").split("e"),+(W[0]+"e"+(+W[1]-I))}return m(R)}}var am=Me&&1/$0(new Me([,-0]))[1]==Pt?function(p){return new Me(p)}:Pp;function yd(p){return function(m){var R=Pu(m);return R==S?Su(m):R==Xt?Uo(m):Z0(m,p(m))}}function hn(p,m,R,I,W,te,pe,Ee){var be=m&me;if(!be&&typeof p!="function")throw new $r(E);var Dt=I?I.length:0;if(Dt||(m&=~(we|he),I=W=o),pe=pe===o?pe:ei(Mr(pe),0),Ee=Ee===o?Ee:Mr(Ee),Dt-=W?W.length:0,m&he){var Tt=I,Ot=W;I=W=o}var on=be?o:qn(p),Mn=[p,m,R,I,W,Tt,Ot,te,pe,Ee];if(on&&Dc(Mn,on),p=Mn[0],m=Mn[1],R=Mn[2],I=Mn[3],W=Mn[4],Ee=Mn[9]=Mn[9]===o?be?0:p.length:ei(Mn[9]-Dt,0),!Ee&&m&(ge|ae)&&(m&=~(ge|ae)),!m||m==y)var rr=M2(p,m,R);else m==ge||m==ae?rr=e1(p,m,Ee):(m==we||m==(y|we))&&!W.length?rr=k2(p,m,R,I):rr=ya.apply(o,Mn);var br=on?Kc:o1;return F2(br(rr,Mn),p,m)}function Rf(p,m,R,I){return p===o||So(p,xn[R])&&!ui.call(I,R)?m:p}function Af(p,m,R,I,W,te){return Iu(p)&&Iu(m)&&(te.set(m,p),ld(p,m,o,Af,te),te.delete(m)),p}function fm(p){return Cc(p)?o:p}function Of(p,m,R,I,W,te){var pe=R&V,Ee=p.length,be=m.length;if(Ee!=be&&!(pe&&be>Ee))return!1;var Dt=te.get(p),Tt=te.get(m);if(Dt&&Tt)return Dt==m&&Tt==p;var Ot=-1,on=!0,Mn=R&re?new yo:o;for(te.set(p,m),te.set(m,p);++Ot<Ee;){var rr=p[Ot],br=m[Ot];if(I)var ar=pe?I(br,rr,Ot,m,p,te):I(rr,br,Ot,p,m,te);if(ar!==o){if(ar)continue;on=!1;break}if(Mn){if(!Cr(m,function(ri,fi){if(!rl(Mn,fi)&&(rr===ri||W(rr,ri,R,I,te)))return Mn.push(fi)})){on=!1;break}}else if(!(rr===br||W(rr,br,R,I,te))){on=!1;break}}return te.delete(p),te.delete(m),on}function Sh(p,m,R,I,W,te,pe){switch(R){case $o:if(p.byteLength!=m.byteLength||p.byteOffset!=m.byteOffset)return!1;p=p.buffer,m=m.buffer;case Zo:return!(p.byteLength!=m.byteLength||!te(new A0(p),new A0(m)));case an:case On:case zt:return So(+p,+m);case ln:return p.name==m.name&&p.message==m.message;case zr:case Du:return p==m+"";case S:var Ee=Su;case Xt:var be=I&V;if(Ee||(Ee=$0),p.size!=m.size&&!be)return!1;var Dt=pe.get(p);if(Dt)return Dt==m;I|=re,pe.set(p,m);var Tt=Of(Ee(p),Ee(m),I,W,te,pe);return pe.delete(p),Tt;case c0:if(Ar)return Ar.call(p)==Ar.call(m)}return!1}function cm(p,m,R,I,W,te){var pe=R&V,Ee=r1(p),be=Ee.length,Dt=r1(m),Tt=Dt.length;if(be!=Tt&&!pe)return!1;for(var Ot=be;Ot--;){var on=Ee[Ot];if(!(pe?on in m:ui.call(m,on)))return!1}var Mn=te.get(p),rr=te.get(m);if(Mn&&rr)return Mn==m&&rr==p;var br=!0;te.set(p,m),te.set(m,p);for(var ar=pe;++Ot<be;){on=Ee[Ot];var ri=p[on],fi=m[on];if(I)var zl=pe?I(fi,ri,on,m,p,te):I(ri,fi,on,p,m,te);if(!(zl===o?ri===fi||W(ri,fi,R,I,te):zl)){br=!1;break}ar||(ar=on=="constructor")}if(br&&!ar){var Zi=p.constructor,so=m.constructor;Zi!=so&&"constructor"in p&&"constructor"in m&&!(typeof Zi=="function"&&Zi instanceof Zi&&typeof so=="function"&&so instanceof so)&&(br=!1)}return te.delete(p),te.delete(m),br}function cl(p){return l1(L2(p,o,f1),p+"")}function r1(p){return de(p,N0,oo)}function sr(p){return de(p,dn,Ka)}var qn=Qt?function(p){return Qt.get(p)}:Pp;function qo(p){for(var m=p.name+"",R=An[m],I=ui.call(An,m)?R.length:0;I--;){var W=R[I],te=W.func;if(te==null||te==p)return W.name}return m}function yr(p){var m=ui.call(K,"placeholder")?K:p;return m.placeholder}function Vn(){var p=K.iteratee||kp;return p=p===kp?Tu:p,arguments.length?p(arguments[0],arguments[1]):p}function dl(p,m){var R=p.__data__;return Gr(m)?R[typeof m=="string"?"string":"hash"]:R.map}function jn(p){for(var m=N0(p),R=m.length;R--;){var I=m[R],W=p[I];m[R]=[I,W,Lf(W)]}return m}function Eo(p,m){var R=bo(p,m);return ur(R)?R:o}function gc(p){var m=ui.call(p,Ju),R=p[Ju];try{p[Ju]=o;var I=!0}catch{}var W=Wu.call(p);return I&&(m?p[Ju]=R:delete p[Ju]),W}var oo=Rr?function(p){return p==null?[]:(p=bn(p),bt(Rr(p),function(m){return B0.call(p,m)}))}:bp,Ka=Rr?function(p){for(var m=[];p;)Dn(m,oo(p)),p=il(p);return m}:bp,Pu=yt;(fe&&Pu(new fe(new ArrayBuffer(1)))!=$o||ie&&Pu(new ie)!=S||Pe&&Pu(Pe.resolve())!=jr||Me&&Pu(new Me)!=Xt||at&&Pu(new at)!=Jo)&&(Pu=function(p){var m=yt(p),R=m==vr?p.constructor:o,I=R?Ea(R):"";if(I)switch(I){case Sn:return $o;case _n:return S;case Tn:return jr;case ir:return Xt;case Ut:return Jo}return m});function rs(p,m,R){for(var I=-1,W=R.length;++I<W;){var te=R[I],pe=te.size;switch(te.type){case"drop":p+=pe;break;case"dropRight":m-=pe;break;case"take":m=Kn(m,p+pe);break;case"takeRight":p=ei(p,m-pe);break}}return{start:p,end:m}}function Mf(p){var m=p.match(Wt);return m?m[1].split(Ru):[]}function _c(p,m,R){m=Ws(m,p);for(var I=-1,W=m.length,te=!1;++I<W;){var pe=Fl(m[I]);if(!(te=p!=null&&R(p,pe)))break;p=p[pe]}return te||++I!=W?te:(W=p==null?0:p.length,!!W&&Ld(W)&&Do(pe,W)&&(tr(p)||pl(p)))}function Cs(p){var m=p.length,R=new p.constructor(m);return m&&typeof p[0]=="string"&&ui.call(p,"index")&&(R.index=p.index,R.input=p.input),R}function Ec(p){return typeof p.constructor=="function"&&!Nf(p)?ti(il(p)):{}}function Th(p,m,R){var I=p.constructor;switch(m){case Zo:return mc(p);case an:case On:return new I(+p);case $o:return pd(p,R);case qt:case xi:case lu:case vi:case Dr:case el:case Y0:case Bu:case K0:return $c(p,R);case S:return new I;case zt:case Du:return new I(p);case zr:return Eh(p);case Xt:return new I;case c0:return Tf(p)}}function cn(p,m){var R=m.length;if(!R)return p;var I=R-1;return m[I]=(R>1?"& ":"")+m[I],m=m.join(R>2?", ":" "),p.replace(yi,`{
+/* [wrapped with `+m+`] */
+`)}function is(p){return tr(p)||pl(p)||!!(vo&&p&&p[vo])}function Do(p,m){var R=typeof p;return m=m==null?Jt:m,!!m&&(R=="number"||R!="symbol"&&Is.test(p))&&p>-1&&p%1==0&&p<m}function lo(p,m,R){if(!Iu(R))return!1;var I=typeof m;return(I=="number"?hl(R)&&Do(m,R.length):I=="string"&&m in R)?So(R[m],p):!1}function Ji(p,m){if(tr(p))return!1;var R=typeof p;return R=="number"||R=="symbol"||R=="boolean"||p==null||Bl(p)?!0:Ri.test(p)||!Hr.test(p)||m!=null&&p in bn(m)}function Gr(p){var m=typeof p;return m=="string"||m=="number"||m=="symbol"||m=="boolean"?p!=="__proto__":p===null}function kf(p){var m=qo(p),R=K[m];if(typeof R!="function"||!(m in ft.prototype))return!1;if(p===R)return!0;var I=qn(R);return!!I&&p===I[0]}function dm(p){return!!zs&&zs in p}var Ll=x0?xa:Bp;function Nf(p){var m=p&&p.constructor,R=typeof m=="function"&&m.prototype||xn;return p===R}function Lf(p){return p===p&&!Iu(p)}function gd(p,m){return function(R){return R==null?!1:R[p]===m&&(m!==o||p in bn(R))}}function _d(p){var m=xd(p,function(I){return R.size===F&&R.clear(),I}),R=m.cache;return m}function Dc(p,m){var R=p[1],I=m[1],W=R|I,te=W<(y|me|ve),pe=I==ve&&R==ge||I==ve&&R==ue&&p[7].length<=m[8]||I==(ve|ue)&&m[7].length<=m[8]&&R==ge;if(!(te||pe))return p;I&y&&(p[2]=m[2],W|=R&y?0:De);var Ee=m[3];if(Ee){var be=p[3];p[3]=be?Vs(be,Ee,m[4]):Ee,p[4]=be?C0(p[3],k):m[4]}return Ee=m[5],Ee&&(be=p[5],p[5]=be?ma(be,Ee,m[6]):Ee,p[6]=be?C0(p[5],k):m[6]),Ee=m[7],Ee&&(p[7]=Ee),I&ve&&(p[8]=p[8]==null?m[8]:Kn(p[8],m[8])),p[9]==null&&(p[9]=m[9]),p[0]=m[0],p[1]=W,p}function i1(p){var m=[];if(p!=null)for(var R in bn(p))m.push(R);return m}function Xa(p){return Wu.call(p)}function L2(p,m,R){return m=ei(m===o?p.length-1:m,0),function(){for(var I=arguments,W=-1,te=ei(I.length-m,0),pe=Ke(te);++W<te;)pe[W]=I[m+W];W=-1;for(var Ee=Ke(m+1);++W<m;)Ee[W]=I[W];return Ee[m]=R(pe),oe(p,this,Ee)}}function Ed(p,m){return m.length<2?p:Z(p,sl(m,0,-1))}function u1(p,m){for(var R=p.length,I=Kn(m.length,R),W=iu(p);I--;){var te=m[I];p[I]=Do(te,R)?W[te]:o}return p}function Ff(p,m){if(!(m==="constructor"&&typeof p[m]=="function")&&m!="__proto__")return p[m]}var o1=Dd(Kc),Qa=gf||function(p,m){return zi.setTimeout(p,m)},l1=Dd(T2);function F2(p,m,R){var I=m+"";return l1(p,cn(I,Ch(Mf(I),R)))}function Dd(p){var m=0,R=0;return function(){var I=$u(),W=_t-(I-R);if(R=I,W>0){if(++m>=gt)return arguments[0]}else m=0;return p.apply(o,arguments)}}function wc(p,m){var R=-1,I=p.length,W=I-1;for(m=m===o?I:m;++R<m;){var te=ad(R,W),pe=p[te];p[te]=p[R],p[R]=pe}return p.length=m,p}var s1=_d(function(p){var m=[];return p.charCodeAt(0)===46&&m.push(""),p.replace(X0,function(R,I,W,te){m.push(W?te.replace(Yi,"$1"):I||R)}),m});function Fl(p){if(typeof p=="string"||Bl(p))return p;var m=p+"";return m=="0"&&1/p==-Pt?"-0":m}function Ea(p){if(p!=null){try{return Lu.call(p)}catch{}try{return p+""}catch{}}return""}function Ch(p,m){return rt(He,function(R){var I="_."+R[0];m&R[1]&&!sn(p,I)&&p.push(I)}),p.sort()}function P2(p){if(p instanceof ft)return p.clone();var m=new Wr(p.__wrapped__,p.__chain__);return m.__actions__=iu(p.__actions__),m.__index__=p.__index__,m.__values__=p.__values__,m}function I2(p,m,R){(R?lo(p,m,R):m===o)?m=1:m=ei(Mr(m),0);var I=p==null?0:p.length;if(!I||m<1)return[];for(var W=0,te=0,pe=Ke(Zu(I/m));W<I;)pe[te++]=sl(p,W,W+=m);return pe}function xh(p){for(var m=-1,R=p==null?0:p.length,I=0,W=[];++m<R;){var te=p[m];te&&(W[I++]=te)}return W}function pm(){var p=arguments.length;if(!p)return[];for(var m=Ke(p-1),R=arguments[0],I=p;I--;)m[I-1]=arguments[I];return Dn(tr(R)?iu(R):[R],Wi(m,1))}var Rh=Ir(function(p,m){return o0(p)?Ol(p,Wi(m,1,o0,!0)):[]}),Pl=Ir(function(p,m){var R=Il(m);return o0(R)&&(R=o),o0(p)?Ol(p,Wi(m,1,o0,!0),Vn(R,2)):[]}),us=Ir(function(p,m){var R=Il(m);return o0(R)&&(R=o),o0(p)?Ol(p,Wi(m,1,o0,!0),o,R):[]});function xs(p,m,R){var I=p==null?0:p.length;return I?(m=R||m===o?1:Mr(m),sl(p,m<0?0:m,I)):[]}function Gs(p,m,R){var I=p==null?0:p.length;return I?(m=R||m===o?1:Mr(m),m=I-m,sl(p,0,m<0?0:m)):[]}function b2(p,m){return p&&p.length?hc(p,Vn(m,3),!0,!0):[]}function Ah(p,m){return p&&p.length?hc(p,Vn(m,3),!0):[]}function B2(p,m,R,I){var W=p==null?0:p.length;return W?(R&&typeof R!="number"&&lo(p,m,R)&&(R=0,I=W),pc(p,m,R,I)):[]}function U2(p,m,R){var I=p==null?0:p.length;if(!I)return-1;var W=R==null?0:Mr(R);return W<0&&(W=ei(I+W,0)),ut(p,Vn(m,3),W)}function a1(p,m,R){var I=p==null?0:p.length;if(!I)return-1;var W=I-1;return R!==o&&(W=Mr(R),W=R<0?ei(I+W,0):Kn(W,I-1)),ut(p,Vn(m,3),W,!0)}function f1(p){var m=p==null?0:p.length;return m?Wi(p,1):[]}function Oh(p){var m=p==null?0:p.length;return m?Wi(p,Pt):[]}function j2(p,m){var R=p==null?0:p.length;return R?(m=m===o?1:Mr(m),Wi(p,m)):[]}function z2(p){for(var m=-1,R=p==null?0:p.length,I={};++m<R;){var W=p[m];I[W[0]]=W[1]}return I}function Rs(p){return p&&p.length?p[0]:o}function Ja(p,m,R){var I=p==null?0:p.length;if(!I)return-1;var W=R==null?0:Mr(R);return W<0&&(W=ei(I+W,0)),wt(p,m,W)}function Mh(p){var m=p==null?0:p.length;return m?sl(p,0,-1):[]}var du=Ir(function(p){var m=Ft(p,Qc);return m.length&&m[0]===p[0]?cu(m):[]}),c1=Ir(function(p){var m=Il(p),R=Ft(p,Qc);return m===Il(R)?m=o:R.pop(),R.length&&R[0]===p[0]?cu(R,Vn(m,2)):[]}),kh=Ir(function(p){var m=Il(p),R=Ft(p,Qc);return m=typeof m=="function"?m:o,m&&R.pop(),R.length&&R[0]===p[0]?cu(R,o,m):[]});function d1(p,m){return p==null?"":fu.call(p,m)}function Il(p){var m=p==null?0:p.length;return m?p[m-1]:o}function Nh(p,m,R){var I=p==null?0:p.length;if(!I)return-1;var W=I;return R!==o&&(W=Mr(R),W=W<0?ei(I+W,0):Kn(W,I-1)),m===m?$l(p,m,W):ut(p,It,W,!0)}function H2(p,m){return p&&p.length?Gc(p,Mr(m)):o}var Lh=Ir(p1);function p1(p,m){return p&&p.length&&m&&m.length?kl(p,m):p}function bl(p,m,R){return p&&p.length&&m&&m.length?kl(p,m,Vn(R,2)):p}function Za(p,m,R){return p&&p.length&&m&&m.length?kl(p,m,o,R):p}var Da=cl(function(p,m){var R=p==null?0:p.length,I=qa(p,m);return sd(p,Ft(m,function(W){return Do(W,R)?+W:W}).sort(Dh)),I});function q2(p,m){var R=[];if(!(p&&p.length))return R;var I=-1,W=[],te=p.length;for(m=Vn(m,3);++I<te;){var pe=p[I];m(pe,I,p)&&(R.push(pe),W.push(I))}return sd(p,W),R}function W2(p){return p==null?p:Ln.call(p)}function hm(p,m,R){var I=p==null?0:p.length;return I?(R&&typeof R!="number"&&lo(p,m,R)?(m=0,R=I):(m=m==null?0:Mr(m),R=R===o?I:Mr(R)),sl(p,m,R)):[]}function V2(p,m){return Sf(p,m)}function Fh(p,m,R){return Xc(p,m,Vn(R,2))}function Ph(p,m){var R=p==null?0:p.length;if(R){var I=Sf(p,m);if(I<R&&So(p[I],m))return I}return-1}function G2(p,m){return Sf(p,m,!0)}function vm(p,m,R){return Xc(p,m,Vn(R,2),!0)}function mm(p,m){var R=p==null?0:p.length;if(R){var I=Sf(p,m,!0)-1;if(So(p[I],m))return I}return-1}function Ih(p){return p&&p.length?C2(p):[]}function ym(p,m){return p&&p.length?C2(p,Vn(m,2)):[]}function Y2(p){var m=p==null?0:p.length;return m?sl(p,1,m):[]}function h1(p,m,R){return p&&p.length?(m=R||m===o?1:Mr(m),sl(p,0,m<0?0:m)):[]}function v1(p,m,R){var I=p==null?0:p.length;return I?(m=R||m===o?1:Mr(m),m=I-m,sl(p,m<0?0:m,I)):[]}function m1(p,m){return p&&p.length?hc(p,Vn(m,3),!1,!0):[]}function wa(p,m){return p&&p.length?hc(p,Vn(m,3)):[]}var K2=Ir(function(p){return ha(Wi(p,1,o0,!0))}),Ys=Ir(function(p){var m=Il(p);return o0(m)&&(m=o),ha(Wi(p,1,o0,!0),Vn(m,2))}),Ks=Ir(function(p){var m=Il(p);return m=typeof m=="function"?m:o,ha(Wi(p,1,o0,!0),o,m)});function Xs(p){return p&&p.length?ha(p):[]}function X2(p,m){return p&&p.length?ha(p,Vn(m,2)):[]}function Sa(p,m){return m=typeof m=="function"?m:o,p&&p.length?ha(p,o,m):[]}function y1(p){if(!(p&&p.length))return[];var m=0;return p=bt(p,function(R){if(o0(R))return m=ei(R.length,m),!0}),T0(m,function(R){return Ft(p,fn(R))})}function wd(p,m){if(!(p&&p.length))return[];var R=y1(p);return m==null?R:Ft(R,function(I){return oe(m,o,I)})}var Sc=Ir(function(p,m){return o0(p)?Ol(p,m):[]}),Q2=Ir(function(p){return A2(bt(p,o0))}),wo=Ir(function(p){var m=Il(p);return o0(m)&&(m=o),A2(bt(p,o0),Vn(m,2))}),bh=Ir(function(p){var m=Il(p);return m=typeof m=="function"?m:o,A2(bt(p,o0),o,m)}),Bh=Ir(y1);function Uh(p,m){return dd(p||[],m||[],Ss)}function jh(p,m){return dd(p||[],m||[],Ga)}var gm=Ir(function(p){var m=p.length,R=m>1?p[m-1]:o;return R=typeof R=="function"?(p.pop(),R):o,wd(p,R)});function zh(p){var m=K(p);return m.__chain__=!0,m}function Hh(p,m){return m(p),p}function g1(p,m){return m(p)}var J2=cl(function(p){var m=p.length,R=m?p[0]:0,I=this.__wrapped__,W=function(te){return qa(te,p)};return m>1||this.__actions__.length||!(I instanceof ft)||!Do(R)?this.thru(W):(I=I.slice(R,+R+(m?1:0)),I.__actions__.push({func:g1,args:[W],thisArg:o}),new Wr(I,this.__chain__).thru(function(te){return m&&!te.length&&te.push(o),te}))});function qh(){return zh(this)}function Z2(){return new Wr(this.value(),this.__chain__)}function Wh(){this.__values__===o&&(this.__values__=fv(this.value()));var p=this.__index__>=this.__values__.length,m=p?o:this.__values__[this.__index__++];return{done:p,value:m}}function _m(){return this}function Em(p){for(var m,R=this;R instanceof ni;){var I=P2(R);I.__index__=0,I.__values__=o,m?W.__wrapped__=I:m=I;var W=I;R=R.__wrapped__}return W.__wrapped__=p,m}function Pf(){var p=this.__wrapped__;if(p instanceof ft){var m=p;return this.__actions__.length&&(m=new ft(this)),m=m.reverse(),m.__actions__.push({func:g1,args:[W2],thisArg:o}),new Wr(m,this.__chain__)}return this.thru(W2)}function If(){return _h(this.__wrapped__,this.__actions__)}var Sd=Ya(function(p,m,R){ui.call(p,R)?++p[R]:Vu(p,R,1)});function Dm(p,m,R){var I=tr(p)?kt:ud;return R&&lo(p,m,R)&&(m=o),I(p,Vn(m,3))}function $2(p,m){var R=tr(p)?bt:Vc;return R(p,Vn(m,3))}var Td=Nl(U2),ep=Nl(a1);function Vh(p,m){return Wi(_1(p,m),1)}function tp(p,m){return Wi(_1(p,m),Pt)}function Gh(p,m,R){return R=R===o?1:Mr(R),Wi(_1(p,m),R)}function Yh(p,m){var R=tr(p)?rt:Ts;return R(p,Vn(m,3))}function np(p,m){var R=tr(p)?xt:da;return R(p,Vn(m,3))}var wm=Ya(function(p,m,R){ui.call(p,R)?p[R].push(m):Vu(p,R,[m])});function Sm(p,m,R,I){p=hl(p)?p:Nc(p),R=R&&!I?Mr(R):0;var W=p.length;return R<0&&(R=ei(W+R,0)),S1(p)?R<=W&&p.indexOf(m,R)>-1:!!W&&wt(p,m,R)>-1}var Tm=Ir(function(p,m,R){var I=-1,W=typeof m=="function",te=hl(p)?Ke(p.length):[];return Ts(p,function(pe){te[++I]=W?oe(m,pe,R):Ml(pe,m,R)}),te}),Kh=Ya(function(p,m,R){Vu(p,R,m)});function _1(p,m){var R=tr(p)?Ft:D2;return R(p,Vn(m,3))}function Cm(p,m,R,I){return p==null?[]:(tr(m)||(m=m==null?[]:[m]),R=I?o:R,tr(R)||(R=R==null?[]:[R]),go(p,m,R))}var rp=Ya(function(p,m,R){p[R?0:1].push(m)},function(){return[[],[]]});function ip(p,m,R){var I=tr(p)?dr:wr,W=arguments.length<3;return I(p,Vn(m,4),R,W,Ts)}function xm(p,m,R){var I=tr(p)?er:wr,W=arguments.length<3;return I(p,Vn(m,4),R,W,da)}function Rm(p,m){var R=tr(p)?bt:Vc;return R(p,Rd(Vn(m,3)))}function Xh(p){var m=tr(p)?za:fd;return m(p)}function Am(p,m,R){(R?lo(p,m,R):m===o)?m=1:m=Mr(m);var I=tr(p)?Ha:cd;return I(p,m)}function Om(p){var m=tr(p)?ca:ll;return m(p)}function up(p){if(p==null)return 0;if(hl(p))return S1(p)?tu(p):p.length;var m=Pu(p);return m==S||m==Xt?p.size:Wa(p).length}function op(p,m,R){var I=tr(p)?Cr:yh;return R&&lo(p,m,R)&&(m=o),I(p,Vn(m,3))}var Ta=Ir(function(p,m){if(p==null)return[];var R=m.length;return R>1&&lo(p,m[0],m[1])?m=[]:R>2&&lo(m[0],m[1],m[2])&&(m=[m[0]]),go(p,Wi(m,1),[])}),E1=aa||function(){return zi.Date.now()};function lp(p,m){if(typeof m!="function")throw new $r(E);return p=Mr(p),function(){if(--p<1)return m.apply(this,arguments)}}function Qh(p,m,R){return m=R?o:m,m=p&&m==null?p.length:m,hn(p,ve,o,o,o,o,m)}function Cd(p,m){var R;if(typeof m!="function")throw new $r(E);return p=Mr(p),function(){return--p>0&&(R=m.apply(this,arguments)),p<=1&&(m=o),R}}var D1=Ir(function(p,m,R){var I=y;if(R.length){var W=C0(R,yr(D1));I|=we}return hn(p,I,m,R,W)}),Jh=Ir(function(p,m,R){var I=y|me;if(R.length){var W=C0(R,yr(Jh));I|=we}return hn(m,I,p,R,W)});function sp(p,m,R){m=R?o:m;var I=hn(p,ge,o,o,o,o,o,m);return I.placeholder=sp.placeholder,I}function Zh(p,m,R){m=R?o:m;var I=hn(p,ae,o,o,o,o,o,m);return I.placeholder=Zh.placeholder,I}function ap(p,m,R){var I,W,te,pe,Ee,be,Dt=0,Tt=!1,Ot=!1,on=!0;if(typeof p!="function")throw new $r(E);m=vl(m)||0,Iu(R)&&(Tt=!!R.leading,Ot="maxWait"in R,te=Ot?ei(vl(R.maxWait)||0,m):te,on="trailing"in R?!!R.trailing:on);function Mn(s0){var Os=I,Co=W;return I=W=o,Dt=s0,pe=p.apply(Co,Os),pe}function rr(s0){return Dt=s0,Ee=Qa(ri,m),Tt?Mn(s0):pe}function br(s0){var Os=s0-be,Co=s0-Dt,kv=m-Os;return Ot?Kn(kv,te-Co):kv}function ar(s0){var Os=s0-be,Co=s0-Dt;return be===o||Os>=m||Os<0||Ot&&Co>=te}function ri(){var s0=E1();if(ar(s0))return fi(s0);Ee=Qa(ri,br(s0))}function fi(s0){return Ee=o,on&&I?Mn(s0):(I=W=o,pe)}function zl(){Ee!==o&&Zc(Ee),Dt=0,I=be=W=Ee=o}function Zi(){return Ee===o?pe:fi(E1())}function so(){var s0=E1(),Os=ar(s0);if(I=arguments,W=this,be=s0,Os){if(Ee===o)return rr(be);if(Ot)return Zc(Ee),Ee=Qa(ri,m),Mn(be)}return Ee===o&&(Ee=Qa(ri,m)),pe}return so.cancel=zl,so.flush=Zi,so}var $h=Ir(function(p,m){return dc(p,1,m)}),ev=Ir(function(p,m,R){return dc(p,vl(m)||0,R)});function fp(p){return hn(p,Ae)}function xd(p,m){if(typeof p!="function"||m!=null&&typeof m!="function")throw new $r(E);var R=function(){var I=arguments,W=m?m.apply(this,I):I[0],te=R.cache;if(te.has(W))return te.get(W);var pe=p.apply(this,I);return R.cache=te.set(W,pe)||te,pe};return R.cache=new(xd.Cache||U0),R}xd.Cache=U0;function Rd(p){if(typeof p!="function")throw new $r(E);return function(){var m=arguments;switch(m.length){case 0:return!p.call(this);case 1:return!p.call(this,m[0]);case 2:return!p.call(this,m[0],m[1]);case 3:return!p.call(this,m[0],m[1],m[2])}return!p.apply(this,m)}}function H0(p){return Cd(2,p)}var Ad=O2(function(p,m){m=m.length==1&&tr(m[0])?Ft(m[0],gi(Vn())):Ft(Wi(m,1),gi(Vn()));var R=m.length;return Ir(function(I){for(var W=-1,te=Kn(I.length,R);++W<te;)I[W]=m[W].call(this,I[W]);return oe(p,this,I)})}),Ca=Ir(function(p,m){var R=C0(m,yr(Ca));return hn(p,we,o,m,R)}),$a=Ir(function(p,m){var R=C0(m,yr($a));return hn(p,he,o,m,R)}),Od=cl(function(p,m){return hn(p,ue,o,o,o,m)});function Md(p,m){if(typeof p!="function")throw new $r(E);return m=m===o?m:Mr(m),Ir(p,m)}function cp(p,m){if(typeof p!="function")throw new $r(E);return m=m==null?0:ei(Mr(m),0),Ir(function(R){var I=R[m],W=va(R,0,m);return I&&Dn(W,I),oe(p,this,W)})}function kd(p,m,R){var I=!0,W=!0;if(typeof p!="function")throw new $r(E);return Iu(R)&&(I="leading"in R?!!R.leading:I,W="trailing"in R?!!R.trailing:W),ap(p,m,{leading:I,maxWait:m,trailing:W})}function tv(p){return Qh(p,1)}function Mm(p,m){return Ca(Jc(m),p)}function nv(){if(!arguments.length)return[];var p=arguments[0];return tr(p)?p:[p]}function dp(p){return j0(p,q)}function pp(p,m){return m=typeof m=="function"?m:o,j0(p,q,m)}function hp(p){return j0(p,x|q)}function km(p,m){return m=typeof m=="function"?m:o,j0(p,x|q,m)}function Nm(p,m){return m==null||Wc(p,m,N0(m))}function So(p,m){return p===m||p!==p&&m!==m}var Nd=md(Rt),Lm=md(function(p,m){return p>=m}),pl=i0(function(){return arguments}())?i0:function(p){return Gu(p)&&ui.call(p,"callee")&&!B0.call(p,"callee")},tr=Ke.isArray,Qs=_e?gi(_e):Ge;function hl(p){return p!=null&&Ld(p.length)&&!xa(p)}function o0(p){return Gu(p)&&hl(p)}function rv(p){return p===!0||p===!1||Gu(p)&&yt(p)==an}var Js=no||Bp,vp=Oe?gi(Oe):je;function Fm(p){return Gu(p)&&p.nodeType===1&&!Cc(p)}function iv(p){if(p==null)return!0;if(hl(p)&&(tr(p)||typeof p=="string"||typeof p.splice=="function"||Js(p)||Ra(p)||pl(p)))return!p.length;var m=Pu(p);if(m==S||m==Xt)return!p.size;if(Nf(p))return!Wa(p).length;for(var R in p)if(ui.call(p,R))return!1;return!0}function mp(p,m){return st(p,m)}function Pm(p,m,R){R=typeof R=="function"?R:o;var I=R?R(p,m):o;return I===o?st(p,m,o,R):!!I}function yp(p){if(!Gu(p))return!1;var m=yt(p);return m==ln||m==lr||typeof p.message=="string"&&typeof p.name=="string"&&!Cc(p)}function Tc(p){return typeof p=="number"&&nu(p)}function xa(p){if(!Iu(p))return!1;var m=yt(p);return m==Vt||m==Er||m==nn||m==fr}function gp(p){return typeof p=="number"&&p==Mr(p)}function Ld(p){return typeof p=="number"&&p>-1&&p%1==0&&p<=Jt}function Iu(p){var m=typeof p;return p!=null&&(m=="object"||m=="function")}function Gu(p){return p!=null&&typeof p=="object"}var _p=$?gi($):Wn;function Ep(p,m){return p===m||oi(p,m,jn(m))}function uv(p,m,R){return R=typeof R=="function"?R:o,oi(p,m,jn(m),R)}function Im(p){return ov(p)&&p!=+p}function bm(p){if(Ll(p))throw new Kt(h);return ur(p)}function Bm(p){return p===null}function Fd(p){return p==null}function ov(p){return typeof p=="number"||Gu(p)&&yt(p)==zt}function Cc(p){if(!Gu(p)||yt(p)!=vr)return!1;var m=il(p);if(m===null)return!0;var R=ui.call(m,"constructor")&&m.constructor;return typeof R=="function"&&R instanceof R&&Lu.call(R)==sa}var w1=Ne?gi(Ne):ai;function Um(p){return gp(p)&&p>=-Jt&&p<=Jt}var Pd=Je?gi(Je):Qi;function S1(p){return typeof p=="string"||!tr(p)&&Gu(p)&&yt(p)==Du}function Bl(p){return typeof p=="symbol"||Gu(p)&&yt(p)==c0}var Ra=vt?gi(vt):Vr;function lv(p){return p===o}function jm(p){return Gu(p)&&Pu(p)==Jo}function sv(p){return Gu(p)&&yt(p)==Fs}var av=md(od),zm=md(function(p,m){return p<=m});function fv(p){if(!p)return[];if(hl(p))return S1(p)?Zr(p):iu(p);if(Fu&&p[Fu])return Xu(p[Fu]());var m=Pu(p),R=m==S?Su:m==Xt?$0:Nc;return R(p)}function Aa(p){if(!p)return p===0?p:0;if(p=vl(p),p===Pt||p===-Pt){var m=p<0?-1:1;return m*it}return p===p?p:0}function Mr(p){var m=Aa(p),R=m%1;return m===m?R?m-R:m:0}function Dp(p){return p?n0(Mr(p),0,ce):0}function vl(p){if(typeof p=="number")return p;if(Bl(p))return J;if(Iu(p)){var m=typeof p.valueOf=="function"?p.valueOf():p;p=Iu(m)?m+"":m}if(typeof p!="string")return p===0?p:+p;p=Nu(p);var R=ao.test(p);return R||No.test(p)?Bs(p.slice(2),R?2:8):li.test(p)?J:+p}function yu(p){return M0(p,dn(p))}function T1(p){return p?n0(Mr(p),-Jt,Jt):p===0?p:0}function Ui(p){return p==null?"":al(p)}var wp=uo(function(p,m){if(Nf(m)||hl(m)){M0(m,N0(m),p);return}for(var R in m)ui.call(m,R)&&Ss(p,R,m[R])}),Id=uo(function(p,m){M0(m,dn(m),p)}),To=uo(function(p,m,R,I){M0(m,dn(m),p,I)}),As=uo(function(p,m,R,I){M0(m,N0(m),p,I)}),bf=cl(qa);function bd(p,m){var R=ti(p);return m==null?R:Ef(R,m)}var Sp=Ir(function(p,m){p=bn(p);var R=-1,I=m.length,W=I>2?m[2]:o;for(W&&lo(m[0],m[1],W)&&(I=1);++R<I;)for(var te=m[R],pe=dn(te),Ee=-1,be=pe.length;++Ee<be;){var Dt=pe[Ee],Tt=p[Dt];(Tt===o||So(Tt,xn[Dt])&&!ui.call(p,Dt))&&(p[Dt]=te[Dt])}return p}),C1=Ir(function(p){return p.push(o,Af),oe(Oc,o,p)});function x1(p,m){return Lr(p,Vn(m,3),A)}function Tp(p,m){return Lr(p,Vn(m,3),P)}function nr(p,m){return p==null?p:_(p,Vn(m,3),dn)}function ml(p,m){return p==null?p:g(p,Vn(m,3),dn)}function Gn(p,m){return p&&A(p,Vn(m,3))}function q0(p,m){return p&&P(p,Vn(m,3))}function k0(p){return p==null?[]:B(p,N0(p))}function Bd(p){return p==null?[]:B(p,dn(p))}function Ul(p,m,R){var I=p==null?o:Z(p,m);return I===o?R:I}function R1(p,m){return p!=null&&_c(p,m,Nt)}function xc(p,m){return p!=null&&_c(p,m,xr)}var Rc=hd(function(p,m,R){m!=null&&typeof m.toString!="function"&&(m=Wu.call(m)),p[m]=R},Xd(l0)),Ud=hd(function(p,m,R){m!=null&&typeof m.toString!="function"&&(m=Wu.call(m)),ui.call(p,m)?p[m].push(R):p[m]=[R]},Vn),Cp=Ir(Ml);function N0(p){return hl(p)?ja(p):Wa(p)}function dn(p){return hl(p)?ja(p,!0):Va(p)}function jd(p,m){var R={};return m=Vn(m,3),A(p,function(I,W,te){Vu(R,m(I,W,te),I)}),R}function zd(p,m){var R={};return m=Vn(m,3),A(p,function(I,W,te){Vu(R,W,m(I,W,te))}),R}var Ac=uo(function(p,m,R){ld(p,m,R)}),Oc=uo(function(p,m,R,I){ld(p,m,R,I)}),Mc=cl(function(p,m){var R={};if(p==null)return R;var I=!1;m=Ft(m,function(te){return te=Ws(te,p),I||(I=te.length>1),te}),M0(p,sr(p),R),I&&(R=j0(R,x|j|q,fm));for(var W=m.length;W--;)x2(R,m[W]);return R});function A1(p,m){return ef(p,Rd(Vn(m)))}var xp=cl(function(p,m){return p==null?{}:vh(p,m)});function ef(p,m){if(p==null)return{};var R=Ft(sr(p),function(I){return[I]});return m=Vn(m),mh(p,R,function(I,W){return m(I,W[0])})}function Hm(p,m,R){m=Ws(m,p);var I=-1,W=m.length;for(W||(W=1,p=o);++I<W;){var te=p==null?o:p[Fl(m[I])];te===o&&(I=W,te=R),p=xa(te)?te.call(p):te}return p}function kc(p,m,R){return p==null?p:Ga(p,m,R)}function Hd(p,m,R,I){return I=typeof I=="function"?I:o,p==null?p:Ga(p,m,R,I)}var cv=yd(N0),O1=yd(dn);function Bf(p,m,R){var I=tr(p),W=I||Js(p)||Ra(p);if(m=Vn(m,4),R==null){var te=p&&p.constructor;W?R=I?new te:[]:Iu(p)?R=xa(te)?ti(il(p)):{}:R={}}return(W?rt:A)(p,function(pe,Ee,be){return m(R,pe,Ee,be)}),R}function Uf(p,m){return p==null?!0:x2(p,m)}function M1(p,m,R){return p==null?p:R2(p,m,Jc(R))}function jl(p,m,R,I){return I=typeof I=="function"?I:o,p==null?p:R2(p,m,Jc(R),I)}function Nc(p){return p==null?[]:Po(p,N0(p))}function jf(p){return p==null?[]:Po(p,dn(p))}function qm(p,m,R){return R===o&&(R=m,m=o),R!==o&&(R=vl(R),R=R===R?R:0),m!==o&&(m=vl(m),m=m===m?m:0),n0(vl(p),m,R)}function yl(p,m,R){return m=Aa(m),R===o?(R=m,m=0):R=Aa(R),p=vl(p),r0(p,m,R)}function qd(p,m,R){if(R&&typeof R!="boolean"&&lo(p,m,R)&&(m=R=o),R===o&&(typeof m=="boolean"?(R=m,m=o):typeof p=="boolean"&&(R=p,p=o)),p===o&&m===o?(p=0,m=1):(p=Aa(p),m===o?(m=p,p=0):m=Aa(m)),p>m){var I=p;p=m,m=I}if(R||p%1||m%1){var W=_0();return Kn(p+W*(m-p+ba("1e-"+((W+"").length-1))),m)}return ad(p,m)}var Wd=Cf(function(p,m,R){return m=m.toLowerCase(),p+(R?Wo(m):m)});function Wo(p){return Op(Ui(p).toLowerCase())}function Vd(p){return p=Ui(p),p&&p.replace($n,Io).replace(J0,"")}function Wm(p,m,R){p=Ui(p),m=al(m);var I=p.length;R=R===o?I:n0(Mr(R),0,I);var W=R;return R-=m.length,R>=0&&p.slice(R,W)==m}function k1(p){return p=Ui(p),p&&Ps.test(p)?p.replace(su,ys):p}function Vm(p){return p=Ui(p),p&&en.test(p)?p.replace(mi,"\\$&"):p}var Gm=Cf(function(p,m,R){return p+(R?"-":"")+m.toLowerCase()}),dv=Cf(function(p,m,R){return p+(R?" ":"")+m.toLowerCase()}),Ym=wh("toLowerCase");function pv(p,m,R){p=Ui(p),m=Mr(m);var I=m?tu(p):0;if(!m||I>=m)return p;var W=(m-I)/2;return ga(Es(W),R)+p+ga(Zu(W),R)}function Km(p,m,R){p=Ui(p),m=Mr(m);var I=m?tu(p):0;return m&&I<m?p+ga(m-I,R):p}function Xm(p,m,R){p=Ui(p),m=Mr(m);var I=m?tu(p):0;return m&&I<m?ga(m-I,R)+p:p}function Qm(p,m,R){return R||m==null?m=0:m&&(m=+m),g0(Ui(p).replace(In,""),m||0)}function hv(p,m,R){return(R?lo(p,m,R):m===o)?m=1:m=Mr(m),Yc(Ui(p),m)}function Jm(){var p=arguments,m=Ui(p[0]);return p.length<3?m:m.replace(p[1],p[2])}var Rp=Cf(function(p,m,R){return p+(R?"_":"")+m.toLowerCase()});function Zm(p,m,R){return R&&typeof R!="number"&&lo(p,m,R)&&(m=R=o),R=R===o?ce:R>>>0,R?(p=Ui(p),p&&(typeof m=="string"||m!=null&&!w1(m))&&(m=al(m),!m&&Bo(p))?va(Zr(p),0,R):p.split(m,R)):[]}var zf=Cf(function(p,m,R){return p+(R?" ":"")+Op(m)});function vv(p,m,R){return p=Ui(p),R=R==null?0:n0(Mr(R),0,p.length),m=al(m),p.slice(R,R+m.length)==m}function mv(p,m,R){var I=K.templateSettings;R&&lo(p,m,R)&&(m=o),p=Ui(p),m=To({},m,I,Rf);var W=To({},m.imports,I.imports,Rf),te=N0(W),pe=Po(W,te),Ee,be,Dt=0,Tt=m.interpolate||tl,Ot="__p += '",on=mu((m.escape||tl).source+"|"+Tt.source+"|"+(Tt===d0?Xl:tl).source+"|"+(m.evaluate||tl).source+"|$","g"),Mn="//# sourceURL="+(ui.call(m,"sourceURL")?(m.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++ac+"]")+`
+`;p.replace(on,function(ar,ri,fi,zl,Zi,so){return fi||(fi=zl),Ot+=p.slice(Dt,so).replace(fo,js),ri&&(Ee=!0,Ot+=`' +
+__e(`+ri+`) +
+'`),Zi&&(be=!0,Ot+=`';
+`+Zi+`;
+__p += '`),fi&&(Ot+=`' +
+((__t = (`+fi+`)) == null ? '' : __t) +
+'`),Dt=so+ar.length,ar}),Ot+=`';
+`;var rr=ui.call(m,"variable")&&m.variable;if(!rr)Ot=`with (obj) {
+`+Ot+`
+}
+`;else if(Q0.test(rr))throw new Kt(t);Ot=(be?Ot.replace(Kr,""):Ot).replace(Oo,"$1").replace(Mo,"$1;"),Ot="function("+(rr||"obj")+`) {
+`+(rr?"":`obj || (obj = {});
+`)+"var __t, __p = ''"+(Ee?", __e = _.escape":"")+(be?`, __j = Array.prototype.join;
+function print() { __p += __j.call(arguments, '') }
+`:`;
+`)+Ot+`return __p
+}`;var br=wv(function(){return pr(te,Mn+"return "+Ot).apply(o,pe)});if(br.source=Ot,yp(br))throw br;return br}function yv(p){return Ui(p).toLowerCase()}function Gd(p){return Ui(p).toUpperCase()}function Yd(p,m,R){if(p=Ui(p),p&&(R||m===o))return Nu(p);if(!p||!(m=al(m)))return p;var I=Zr(p),W=Zr(m),te=hf(I,W),pe=Tl(I,W)+1;return va(I,te,pe).join("")}function Ap(p,m,R){if(p=Ui(p),p&&(R||m===o))return p.slice(0,ho(p)+1);if(!p||!(m=al(m)))return p;var I=Zr(p),W=Tl(I,Zr(m))+1;return va(I,0,W).join("")}function gv(p,m,R){if(p=Ui(p),p&&(R||m===o))return p.replace(In,"");if(!p||!(m=al(m)))return p;var I=Zr(p),W=hf(I,Zr(m));return va(I,W).join("")}function Kd(p,m){var R=ze,I=We;if(Iu(m)){var W="separator"in m?m.separator:W;R="length"in m?Mr(m.length):R,I="omission"in m?al(m.omission):I}p=Ui(p);var te=p.length;if(Bo(p)){var pe=Zr(p);te=pe.length}if(R>=te)return p;var Ee=R-tu(I);if(Ee<1)return I;var be=pe?va(pe,0,Ee).join(""):p.slice(0,Ee);if(W===o)return be+I;if(pe&&(Ee+=be.length-Ee),w1(W)){if(p.slice(Ee).search(W)){var Dt,Tt=be;for(W.global||(W=mu(W.source,Ui(ko.exec(W))+"g")),W.lastIndex=0;Dt=W.exec(Tt);)var Ot=Dt.index;be=be.slice(0,Ot===o?Ee:Ot)}}else if(p.indexOf(al(W),Ee)!=Ee){var on=be.lastIndexOf(W);on>-1&&(be=be.slice(0,on))}return be+I}function _v(p){return p=Ui(p),p&&ki.test(p)?p.replace(F0,Bi):p}var Ev=Cf(function(p,m,R){return p+(R?" ":"")+m.toUpperCase()}),Op=wh("toUpperCase");function Dv(p,m,R){return p=Ui(p),m=R?o:m,m===o?gs(p)?yf(p):y0(p):p.match(m)||[]}var wv=Ir(function(p,m){try{return oe(p,o,m)}catch(R){return yp(R)?R:new Kt(R)}}),$m=cl(function(p,m){return rt(m,function(R){R=Fl(R),Vu(p,R,D1(p[R],p))}),p});function Sv(p){var m=p==null?0:p.length,R=Vn();return p=m?Ft(p,function(I){if(typeof I[1]!="function")throw new $r(E);return[R(I[0]),I[1]]}):[],Ir(function(I){for(var W=-1;++W<m;){var te=p[W];if(oe(te[0],this,I))return oe(te[1],this,I)}})}function ey(p){return Df(j0(p,x))}function Xd(p){return function(){return p}}function Tv(p,m){return p==null||p!==p?m:p}var Mp=t1(),ty=t1(!0);function l0(p){return p}function kp(p){return Tu(typeof p=="function"?p:j0(p,x))}function ny(p){return w2(j0(p,x))}function ry(p,m){return wf(p,j0(m,x))}var Np=Ir(function(p,m){return function(R){return Ml(R,p,m)}}),tf=Ir(function(p,m){return function(R){return Ml(p,R,m)}});function Lp(p,m,R){var I=N0(m),W=B(m,I);R==null&&!(Iu(m)&&(W.length||!I.length))&&(R=m,m=p,p=this,W=B(m,N0(m)));var te=!(Iu(R)&&"chain"in R)||!!R.chain,pe=xa(p);return rt(W,function(Ee){var be=m[Ee];p[Ee]=be,pe&&(p.prototype[Ee]=function(){var Dt=this.__chain__;if(te||Dt){var Tt=p(this.__wrapped__),Ot=Tt.__actions__=iu(this.__actions__);return Ot.push({func:be,args:arguments,thisArg:p}),Tt.__chain__=Dt,Tt}return be.apply(p,Dn([this.value()],arguments))})}),p}function Fp(){return zi._===this&&(zi._=Xi),this}function Pp(){}function iy(p){return p=Mr(p),Ir(function(m){return Gc(m,p)})}var uy=Fr(Ft),Cv=Fr(kt),Hf=Fr(Cr);function Ip(p){return Ji(p)?fn(Fl(p)):_o(p)}function xv(p){return function(m){return p==null?o:Z(p,m)}}var oy=n1(),ly=n1(!0);function bp(){return[]}function Bp(){return!1}function sy(){return{}}function ay(){return""}function Rv(){return!0}function Up(p,m){if(p=Mr(p),p<1||p>Jt)return[];var R=ce,I=Kn(p,ce);m=Vn(m),p-=ce;for(var W=T0(I,m);++R<p;)m(R);return W}function jp(p){return tr(p)?Ft(p,Fl):Bl(p)?[p]:iu(s1(Ui(p)))}function Qd(p){var m=++Cl;return Ui(p)+m}var fy=vd(function(p,m){return p+m},0),N1=N2("ceil"),cy=vd(function(p,m){return p/m},1),Av=N2("floor");function Ov(p){return p&&p.length?pa(p,l0,Rt):o}function dy(p,m){return p&&p.length?pa(p,Vn(m,2),Rt):o}function qf(p){return un(p,l0)}function zp(p,m){return un(p,Vn(m,2))}function Mv(p){return p&&p.length?pa(p,l0,od):o}function py(p,m){return p&&p.length?pa(p,Vn(m,2),od):o}var hy=vd(function(p,m){return p*m},1),Hp=N2("round"),vy=vd(function(p,m){return p-m},0);function Zs(p){return p&&p.length?ku(p,l0):0}function my(p,m){return p&&p.length?ku(p,Vn(m,2)):0}return K.after=lp,K.ary=Qh,K.assign=wp,K.assignIn=Id,K.assignInWith=To,K.assignWith=As,K.at=bf,K.before=Cd,K.bind=D1,K.bindAll=$m,K.bindKey=Jh,K.castArray=nv,K.chain=zh,K.chunk=I2,K.compact=xh,K.concat=pm,K.cond=Sv,K.conforms=ey,K.constant=Xd,K.countBy=Sd,K.create=bd,K.curry=sp,K.curryRight=Zh,K.debounce=ap,K.defaults=Sp,K.defaultsDeep=C1,K.defer=$h,K.delay=ev,K.difference=Rh,K.differenceBy=Pl,K.differenceWith=us,K.drop=xs,K.dropRight=Gs,K.dropRightWhile=b2,K.dropWhile=Ah,K.fill=B2,K.filter=$2,K.flatMap=Vh,K.flatMapDeep=tp,K.flatMapDepth=Gh,K.flatten=f1,K.flattenDeep=Oh,K.flattenDepth=j2,K.flip=fp,K.flow=Mp,K.flowRight=ty,K.fromPairs=z2,K.functions=k0,K.functionsIn=Bd,K.groupBy=wm,K.initial=Mh,K.intersection=du,K.intersectionBy=c1,K.intersectionWith=kh,K.invert=Rc,K.invertBy=Ud,K.invokeMap=Tm,K.iteratee=kp,K.keyBy=Kh,K.keys=N0,K.keysIn=dn,K.map=_1,K.mapKeys=jd,K.mapValues=zd,K.matches=ny,K.matchesProperty=ry,K.memoize=xd,K.merge=Ac,K.mergeWith=Oc,K.method=Np,K.methodOf=tf,K.mixin=Lp,K.negate=Rd,K.nthArg=iy,K.omit=Mc,K.omitBy=A1,K.once=H0,K.orderBy=Cm,K.over=uy,K.overArgs=Ad,K.overEvery=Cv,K.overSome=Hf,K.partial=Ca,K.partialRight=$a,K.partition=rp,K.pick=xp,K.pickBy=ef,K.property=Ip,K.propertyOf=xv,K.pull=Lh,K.pullAll=p1,K.pullAllBy=bl,K.pullAllWith=Za,K.pullAt=Da,K.range=oy,K.rangeRight=ly,K.rearg=Od,K.reject=Rm,K.remove=q2,K.rest=Md,K.reverse=W2,K.sampleSize=Am,K.set=kc,K.setWith=Hd,K.shuffle=Om,K.slice=hm,K.sortBy=Ta,K.sortedUniq=Ih,K.sortedUniqBy=ym,K.split=Zm,K.spread=cp,K.tail=Y2,K.take=h1,K.takeRight=v1,K.takeRightWhile=m1,K.takeWhile=wa,K.tap=Hh,K.throttle=kd,K.thru=g1,K.toArray=fv,K.toPairs=cv,K.toPairsIn=O1,K.toPath=jp,K.toPlainObject=yu,K.transform=Bf,K.unary=tv,K.union=K2,K.unionBy=Ys,K.unionWith=Ks,K.uniq=Xs,K.uniqBy=X2,K.uniqWith=Sa,K.unset=Uf,K.unzip=y1,K.unzipWith=wd,K.update=M1,K.updateWith=jl,K.values=Nc,K.valuesIn=jf,K.without=Sc,K.words=Dv,K.wrap=Mm,K.xor=Q2,K.xorBy=wo,K.xorWith=bh,K.zip=Bh,K.zipObject=Uh,K.zipObjectDeep=jh,K.zipWith=gm,K.entries=cv,K.entriesIn=O1,K.extend=Id,K.extendWith=To,Lp(K,K),K.add=fy,K.attempt=wv,K.camelCase=Wd,K.capitalize=Wo,K.ceil=N1,K.clamp=qm,K.clone=dp,K.cloneDeep=hp,K.cloneDeepWith=km,K.cloneWith=pp,K.conformsTo=Nm,K.deburr=Vd,K.defaultTo=Tv,K.divide=cy,K.endsWith=Wm,K.eq=So,K.escape=k1,K.escapeRegExp=Vm,K.every=Dm,K.find=Td,K.findIndex=U2,K.findKey=x1,K.findLast=ep,K.findLastIndex=a1,K.findLastKey=Tp,K.floor=Av,K.forEach=Yh,K.forEachRight=np,K.forIn=nr,K.forInRight=ml,K.forOwn=Gn,K.forOwnRight=q0,K.get=Ul,K.gt=Nd,K.gte=Lm,K.has=R1,K.hasIn=xc,K.head=Rs,K.identity=l0,K.includes=Sm,K.indexOf=Ja,K.inRange=yl,K.invoke=Cp,K.isArguments=pl,K.isArray=tr,K.isArrayBuffer=Qs,K.isArrayLike=hl,K.isArrayLikeObject=o0,K.isBoolean=rv,K.isBuffer=Js,K.isDate=vp,K.isElement=Fm,K.isEmpty=iv,K.isEqual=mp,K.isEqualWith=Pm,K.isError=yp,K.isFinite=Tc,K.isFunction=xa,K.isInteger=gp,K.isLength=Ld,K.isMap=_p,K.isMatch=Ep,K.isMatchWith=uv,K.isNaN=Im,K.isNative=bm,K.isNil=Fd,K.isNull=Bm,K.isNumber=ov,K.isObject=Iu,K.isObjectLike=Gu,K.isPlainObject=Cc,K.isRegExp=w1,K.isSafeInteger=Um,K.isSet=Pd,K.isString=S1,K.isSymbol=Bl,K.isTypedArray=Ra,K.isUndefined=lv,K.isWeakMap=jm,K.isWeakSet=sv,K.join=d1,K.kebabCase=Gm,K.last=Il,K.lastIndexOf=Nh,K.lowerCase=dv,K.lowerFirst=Ym,K.lt=av,K.lte=zm,K.max=Ov,K.maxBy=dy,K.mean=qf,K.meanBy=zp,K.min=Mv,K.minBy=py,K.stubArray=bp,K.stubFalse=Bp,K.stubObject=sy,K.stubString=ay,K.stubTrue=Rv,K.multiply=hy,K.nth=H2,K.noConflict=Fp,K.noop=Pp,K.now=E1,K.pad=pv,K.padEnd=Km,K.padStart=Xm,K.parseInt=Qm,K.random=qd,K.reduce=ip,K.reduceRight=xm,K.repeat=hv,K.replace=Jm,K.result=Hm,K.round=Hp,K.runInContext=xe,K.sample=Xh,K.size=up,K.snakeCase=Rp,K.some=op,K.sortedIndex=V2,K.sortedIndexBy=Fh,K.sortedIndexOf=Ph,K.sortedLastIndex=G2,K.sortedLastIndexBy=vm,K.sortedLastIndexOf=mm,K.startCase=zf,K.startsWith=vv,K.subtract=vy,K.sum=Zs,K.sumBy=my,K.template=mv,K.times=Up,K.toFinite=Aa,K.toInteger=Mr,K.toLength=Dp,K.toLower=yv,K.toNumber=vl,K.toSafeInteger=T1,K.toString=Ui,K.toUpper=Gd,K.trim=Yd,K.trimEnd=Ap,K.trimStart=gv,K.truncate=Kd,K.unescape=_v,K.uniqueId=Qd,K.upperCase=Ev,K.upperFirst=Op,K.each=Yh,K.eachRight=np,K.first=Rs,Lp(K,function(){var p={};return A(K,function(m,R){ui.call(K.prototype,R)||(p[R]=m)}),p}(),{chain:!1}),K.VERSION=l,rt(["bind","bindKey","curry","curryRight","partial","partialRight"],function(p){K[p].placeholder=K}),rt(["drop","take"],function(p,m){ft.prototype[p]=function(R){R=R===o?1:ei(Mr(R),0);var I=this.__filtered__&&!m?new ft(this):this.clone();return I.__filtered__?I.__takeCount__=Kn(R,I.__takeCount__):I.__views__.push({size:Kn(R,ce),type:p+(I.__dir__<0?"Right":"")}),I},ft.prototype[p+"Right"]=function(R){return this.reverse()[p](R).reverse()}}),rt(["filter","map","takeWhile"],function(p,m){var R=m+1,I=R==Qe||R==Ve;ft.prototype[p]=function(W){var te=this.clone();return te.__iteratees__.push({iteratee:Vn(W,3),type:R}),te.__filtered__=te.__filtered__||I,te}}),rt(["head","last"],function(p,m){var R="take"+(m?"Right":"");ft.prototype[p]=function(){return this[R](1).value()[0]}}),rt(["initial","tail"],function(p,m){var R="drop"+(m?"":"Right");ft.prototype[p]=function(){return this.__filtered__?new ft(this):this[R](1)}}),ft.prototype.compact=function(){return this.filter(l0)},ft.prototype.find=function(p){return this.filter(p).head()},ft.prototype.findLast=function(p){return this.reverse().find(p)},ft.prototype.invokeMap=Ir(function(p,m){return typeof p=="function"?new ft(this):this.map(function(R){return Ml(R,p,m)})}),ft.prototype.reject=function(p){return this.filter(Rd(Vn(p)))},ft.prototype.slice=function(p,m){p=Mr(p);var R=this;return R.__filtered__&&(p>0||m<0)?new ft(R):(p<0?R=R.takeRight(-p):p&&(R=R.drop(p)),m!==o&&(m=Mr(m),R=m<0?R.dropRight(-m):R.take(m-p)),R)},ft.prototype.takeRightWhile=function(p){return this.reverse().takeWhile(p).reverse()},ft.prototype.toArray=function(){return this.take(ce)},A(ft.prototype,function(p,m){var R=/^(?:filter|find|map|reject)|While$/.test(m),I=/^(?:head|last)$/.test(m),W=K[I?"take"+(m=="last"?"Right":""):m],te=I||/^find/.test(m);!W||(K.prototype[m]=function(){var pe=this.__wrapped__,Ee=I?[1]:arguments,be=pe instanceof ft,Dt=Ee[0],Tt=be||tr(pe),Ot=function(ri){var fi=W.apply(K,Dn([ri],Ee));return I&&on?fi[0]:fi};Tt&&R&&typeof Dt=="function"&&Dt.length!=1&&(be=Tt=!1);var on=this.__chain__,Mn=!!this.__actions__.length,rr=te&&!on,br=be&&!Mn;if(!te&&Tt){pe=br?pe:new ft(this);var ar=p.apply(pe,Ee);return ar.__actions__.push({func:g1,args:[Ot],thisArg:o}),new Wr(ar,on)}return rr&&br?p.apply(this,Ee):(ar=this.thru(Ot),rr?I?ar.value()[0]:ar.value():ar)})}),rt(["pop","push","shift","sort","splice","unshift"],function(p){var m=Qr[p],R=/^(?:push|sort|unshift)$/.test(p)?"tap":"thru",I=/^(?:pop|shift)$/.test(p);K.prototype[p]=function(){var W=arguments;if(I&&!this.__chain__){var te=this.value();return m.apply(tr(te)?te:[],W)}return this[R](function(pe){return m.apply(tr(pe)?pe:[],W)})}}),A(ft.prototype,function(p,m){var R=K[m];if(R){var I=R.name+"";ui.call(An,I)||(An[I]=[]),An[I].push({name:m,func:R})}}),An[ya(o,me).name]=[{name:"wrapper",func:o}],ft.prototype.clone=Di,ft.prototype.reverse=ru,ft.prototype.value=E0,K.prototype.at=J2,K.prototype.chain=qh,K.prototype.commit=Z2,K.prototype.next=Wh,K.prototype.plant=Em,K.prototype.reverse=Pf,K.prototype.toJSON=K.prototype.valueOf=K.prototype.value=If,K.prototype.first=K.prototype.head,Fu&&(K.prototype[Fu]=_m),K},to=eo();typeof define=="function"&&typeof define.amd=="object"&&define.amd?(zi._=to,define(function(){return to})):H?((H.exports=to)._=to,U._=to):zi._=to}).call(Wv)});var ZE=nt((tH,JE)=>{"use strict";var Pi=JE.exports;JE.exports.default=Pi;var Eu="\x1B[",Uy="\x1B]",Vv="\x07",T_=";",aS=process.env.TERM_PROGRAM==="Apple_Terminal";Pi.cursorTo=(o,l)=>{if(typeof o!="number")throw new TypeError("The `x` argument is required");return typeof l!="number"?Eu+(o+1)+"G":Eu+(l+1)+";"+(o+1)+"H"};Pi.cursorMove=(o,l)=>{if(typeof o!="number")throw new TypeError("The `x` argument is required");let f="";return o<0?f+=Eu+-o+"D":o>0&&(f+=Eu+o+"C"),l<0?f+=Eu+-l+"A":l>0&&(f+=Eu+l+"B"),f};Pi.cursorUp=(o=1)=>Eu+o+"A";Pi.cursorDown=(o=1)=>Eu+o+"B";Pi.cursorForward=(o=1)=>Eu+o+"C";Pi.cursorBackward=(o=1)=>Eu+o+"D";Pi.cursorLeft=Eu+"G";Pi.cursorSavePosition=aS?"\x1B7":Eu+"s";Pi.cursorRestorePosition=aS?"\x1B8":Eu+"u";Pi.cursorGetPosition=Eu+"6n";Pi.cursorNextLine=Eu+"E";Pi.cursorPrevLine=Eu+"F";Pi.cursorHide=Eu+"?25l";Pi.cursorShow=Eu+"?25h";Pi.eraseLines=o=>{let l="";for(let f=0;f<o;f++)l+=Pi.eraseLine+(f<o-1?Pi.cursorUp():"");return o&&(l+=Pi.cursorLeft),l};Pi.eraseEndLine=Eu+"K";Pi.eraseStartLine=Eu+"1K";Pi.eraseLine=Eu+"2K";Pi.eraseDown=Eu+"J";Pi.eraseUp=Eu+"1J";Pi.eraseScreen=Eu+"2J";Pi.scrollUp=Eu+"S";Pi.scrollDown=Eu+"T";Pi.clearScreen="\x1Bc";Pi.clearTerminal=process.platform==="win32"?`${Pi.eraseScreen}${Eu}0f`:`${Pi.eraseScreen}${Eu}3J${Eu}H`;Pi.beep=Vv;Pi.link=(o,l)=>[Uy,"8",T_,T_,l,Vv,o,Uy,"8",T_,T_,Vv].join("");Pi.image=(o,l={})=>{let f=`${Uy}1337;File=inline=1`;return l.width&&(f+=`;width=${l.width}`),l.height&&(f+=`;height=${l.height}`),l.preserveAspectRatio===!1&&(f+=";preserveAspectRatio=0"),f+":"+o.toString("base64")+Vv};Pi.iTerm={setCwd:(o=process.cwd())=>`${Uy}50;CurrentDir=${o}${Vv}`,annotation:(o,l={})=>{let f=`${Uy}1337;`,h=typeof l.x<"u",E=typeof l.y<"u";if((h||E)&&!(h&&E&&typeof l.length<"u"))throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");return o=o.replace(/\|/g,""),f+=l.isHidden?"AddHiddenAnnotation=":"AddAnnotation=",l.length>0?f+=(h?[o,l.length,l.x,l.y]:[l.length,o]).join("|"):f+=o,f+Vv}}});var cS=nt((nH,$E)=>{"use strict";var fS=(o,l)=>{for(let f of Reflect.ownKeys(l))Object.defineProperty(o,f,Object.getOwnPropertyDescriptor(l,f));return o};$E.exports=fS;$E.exports.default=fS});var pS=nt((rH,x_)=>{"use strict";var fP=cS(),C_=new WeakMap,dS=(o,l={})=>{if(typeof o!="function")throw new TypeError("Expected a function");let f,h=0,E=o.displayName||o.name||"<anonymous>",t=function(...N){if(C_.set(t,++h),h===1)f=o.apply(this,N),o=null;else if(l.throw===!0)throw new Error(`Function \`${E}\` can only be called once`);return f};return fP(t,o),C_.set(t,h),t};x_.exports=dS;x_.exports.default=dS;x_.exports.callCount=o=>{if(!C_.has(o))throw new Error(`The given function \`${o.name}\` is not wrapped by the \`onetime\` package`);return C_.get(o)}});var hS=nt((iH,R_)=>{R_.exports=["SIGABRT","SIGALRM","SIGHUP","SIGINT","SIGTERM"];process.platform!=="win32"&&R_.exports.push("SIGVTALRM","SIGXCPU","SIGXFSZ","SIGUSR2","SIGTRAP","SIGSYS","SIGQUIT","SIGIOT");process.platform==="linux"&&R_.exports.push("SIGIO","SIGPOLL","SIGPWR","SIGSTKFLT","SIGUNUSED")});var nD=nt((uH,Kv)=>{var w0=global.process,Jp=function(o){return o&&typeof o=="object"&&typeof o.removeListener=="function"&&typeof o.emit=="function"&&typeof o.reallyExit=="function"&&typeof o.listeners=="function"&&typeof o.kill=="function"&&typeof o.pid=="number"&&typeof o.on=="function"};Jp(w0)?(vS=hi("assert"),Gv=hS(),mS=/^win/i.test(w0.platform),jy=hi("events"),typeof jy!="function"&&(jy=jy.EventEmitter),w0.__signal_exit_emitter__?wl=w0.__signal_exit_emitter__:(wl=w0.__signal_exit_emitter__=new jy,wl.count=0,wl.emitted={}),wl.infinite||(wl.setMaxListeners(1/0),wl.infinite=!0),Kv.exports=function(o,l){if(!Jp(global.process))return function(){};vS.equal(typeof o,"function","a callback must be provided for exit handler"),Yv===!1&&eD();var f="exit";l&&l.alwaysLast&&(f="afterexit");var h=function(){wl.removeListener(f,o),wl.listeners("exit").length===0&&wl.listeners("afterexit").length===0&&A_()};return wl.on(f,o),h},A_=function(){!Yv||!Jp(global.process)||(Yv=!1,Gv.forEach(function(l){try{w0.removeListener(l,O_[l])}catch{}}),w0.emit=M_,w0.reallyExit=tD,wl.count-=1)},Kv.exports.unload=A_,Zp=function(l,f,h){wl.emitted[l]||(wl.emitted[l]=!0,wl.emit(l,f,h))},O_={},Gv.forEach(function(o){O_[o]=function(){if(!!Jp(global.process)){var f=w0.listeners(o);f.length===wl.count&&(A_(),Zp("exit",null,o),Zp("afterexit",null,o),mS&&o==="SIGHUP"&&(o="SIGINT"),w0.kill(w0.pid,o))}}}),Kv.exports.signals=function(){return Gv},Yv=!1,eD=function(){Yv||!Jp(global.process)||(Yv=!0,wl.count+=1,Gv=Gv.filter(function(l){try{return w0.on(l,O_[l]),!0}catch{return!1}}),w0.emit=gS,w0.reallyExit=yS)},Kv.exports.load=eD,tD=w0.reallyExit,yS=function(l){!Jp(global.process)||(w0.exitCode=l||0,Zp("exit",w0.exitCode,null),Zp("afterexit",w0.exitCode,null),tD.call(w0,w0.exitCode))},M_=w0.emit,gS=function(l,f){if(l==="exit"&&Jp(global.process)){f!==void 0&&(w0.exitCode=f);var h=M_.apply(this,arguments);return Zp("exit",w0.exitCode,null),Zp("afterexit",w0.exitCode,null),h}else return M_.apply(this,arguments)}):Kv.exports=function(){return function(){}};var vS,Gv,mS,jy,wl,A_,Zp,O_,Yv,eD,tD,yS,M_,gS});var ES=nt((oH,_S)=>{"use strict";var cP=pS(),dP=nD();_S.exports=cP(()=>{dP(()=>{process.stderr.write("\x1B[?25h")},{alwaysLast:!0})})});var rD=nt(Xv=>{"use strict";var pP=ES(),k_=!1;Xv.show=(o=process.stderr)=>{!o.isTTY||(k_=!1,o.write("\x1B[?25h"))};Xv.hide=(o=process.stderr)=>{!o.isTTY||(pP(),k_=!0,o.write("\x1B[?25l"))};Xv.toggle=(o,l)=>{o!==void 0&&(k_=o),k_?Xv.show(l):Xv.hide(l)}});var TS=nt(zy=>{"use strict";var SS=zy&&zy.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(zy,"__esModule",{value:!0});var DS=SS(ZE()),wS=SS(rD()),hP=(o,{showCursor:l=!1}={})=>{let f=0,h="",E=!1,t=N=>{!l&&!E&&(wS.default.hide(),E=!0);let F=N+`
+`;F!==h&&(h=F,o.write(DS.default.eraseLines(f)+F),f=F.split(`
+`).length)};return t.clear=()=>{o.write(DS.default.eraseLines(f)),h="",f=0},t.done=()=>{h="",f=0,l||(wS.default.show(),E=!1)},t};zy.default={create:hP}});var CS=nt((aH,vP)=>{vP.exports=[{name:"AppVeyor",constant:"APPVEYOR",env:"APPVEYOR",pr:"APPVEYOR_PULL_REQUEST_NUMBER"},{name:"Azure Pipelines",constant:"AZURE_PIPELINES",env:"SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",pr:"SYSTEM_PULLREQUEST_PULLREQUESTID"},{name:"Bamboo",constant:"BAMBOO",env:"bamboo_planKey"},{name:"Bitbucket Pipelines",constant:"BITBUCKET",env:"BITBUCKET_COMMIT",pr:"BITBUCKET_PR_ID"},{name:"Bitrise",constant:"BITRISE",env:"BITRISE_IO",pr:"BITRISE_PULL_REQUEST"},{name:"Buddy",constant:"BUDDY",env:"BUDDY_WORKSPACE_ID",pr:"BUDDY_EXECUTION_PULL_REQUEST_ID"},{name:"Buildkite",constant:"BUILDKITE",env:"BUILDKITE",pr:{env:"BUILDKITE_PULL_REQUEST",ne:"false"}},{name:"CircleCI",constant:"CIRCLE",env:"CIRCLECI",pr:"CIRCLE_PULL_REQUEST"},{name:"Cirrus CI",constant:"CIRRUS",env:"CIRRUS_CI",pr:"CIRRUS_PR"},{name:"AWS CodeBuild",constant:"CODEBUILD",env:"CODEBUILD_BUILD_ARN"},{name:"Codeship",constant:"CODESHIP",env:{CI_NAME:"codeship"}},{name:"Drone",constant:"DRONE",env:"DRONE",pr:{DRONE_BUILD_EVENT:"pull_request"}},{name:"dsari",constant:"DSARI",env:"DSARI"},{name:"GitLab CI",constant:"GITLAB",env:"GITLAB_CI"},{name:"GoCD",constant:"GOCD",env:"GO_PIPELINE_LABEL"},{name:"Hudson",constant:"HUDSON",env:"HUDSON_URL"},{name:"Jenkins",constant:"JENKINS",env:["JENKINS_URL","BUILD_ID"],pr:{any:["ghprbPullId","CHANGE_ID"]}},{name:"Magnum CI",constant:"MAGNUM",env:"MAGNUM"},{name:"Netlify CI",constant:"NETLIFY",env:"NETLIFY_BUILD_BASE",pr:{env:"PULL_REQUEST",ne:"false"}},{name:"Sail CI",constant:"SAIL",env:"SAILCI",pr:"SAIL_PULL_REQUEST_NUMBER"},{name:"Semaphore",constant:"SEMAPHORE",env:"SEMAPHORE",pr:"PULL_REQUEST_NUMBER"},{name:"Shippable",constant:"SHIPPABLE",env:"SHIPPABLE",pr:{IS_PULL_REQUEST:"true"}},{name:"Solano CI",constant:"SOLANO",env:"TDDIUM",pr:"TDDIUM_PR_ID"},{name:"Strider CD",constant:"STRIDER",env:"STRIDER"},{name:"TaskCluster",constant:"TASKCLUSTER",env:["TASK_ID","RUN_ID"]},{name:"TeamCity",constant:"TEAMCITY",env:"TEAMCITY_VERSION"},{name:"Travis CI",constant:"TRAVIS",env:"TRAVIS",pr:{env:"TRAVIS_PULL_REQUEST",ne:"false"}}]});var AS=nt(Fa=>{"use strict";var RS=CS(),Uc=process.env;Object.defineProperty(Fa,"_vendors",{value:RS.map(function(o){return o.constant})});Fa.name=null;Fa.isPR=null;RS.forEach(function(o){var l=Array.isArray(o.env)?o.env:[o.env],f=l.every(function(h){return xS(h)});if(Fa[o.constant]=f,f)switch(Fa.name=o.name,typeof o.pr){case"string":Fa.isPR=!!Uc[o.pr];break;case"object":"env"in o.pr?Fa.isPR=o.pr.env in Uc&&Uc[o.pr.env]!==o.pr.ne:"any"in o.pr?Fa.isPR=o.pr.any.some(function(h){return!!Uc[h]}):Fa.isPR=xS(o.pr);break;default:Fa.isPR=null}});Fa.isCI=!!(Uc.CI||Uc.CONTINUOUS_INTEGRATION||Uc.BUILD_NUMBER||Uc.RUN_ID||Fa.name);function xS(o){return typeof o=="string"?!!Uc[o]:Object.keys(o).every(function(l){return Uc[l]===o[l]})}});var MS=nt((cH,OS)=>{"use strict";OS.exports=AS().isCI});var NS=nt((dH,kS)=>{"use strict";var mP=o=>{let l=new Set;do for(let f of Reflect.ownKeys(o))l.add([o,f]);while((o=Reflect.getPrototypeOf(o))&&o!==Object.prototype);return l};kS.exports=(o,{include:l,exclude:f}={})=>{let h=E=>{let t=N=>typeof N=="string"?E===N:N.test(E);return l?l.some(t):f?!f.some(t):!0};for(let[E,t]of mP(o.constructor.prototype)){if(t==="constructor"||!h(t))continue;let N=Reflect.getOwnPropertyDescriptor(E,t);N&&typeof N.value=="function"&&(o[t]=o[t].bind(o))}return o}});var jS=nt(ou=>{"use strict";Object.defineProperty(ou,"__esModule",{value:!0});var Jv,Wy,I_,b_,fD;typeof window>"u"||typeof MessageChannel!="function"?(Qv=null,iD=null,uD=function(){if(Qv!==null)try{var o=ou.unstable_now();Qv(!0,o),Qv=null}catch(l){throw setTimeout(uD,0),l}},LS=Date.now(),ou.unstable_now=function(){return Date.now()-LS},Jv=function(o){Qv!==null?setTimeout(Jv,0,o):(Qv=o,setTimeout(uD,0))},Wy=function(o,l){iD=setTimeout(o,l)},I_=function(){clearTimeout(iD)},b_=function(){return!1},fD=ou.unstable_forceFrameRate=function(){}):(N_=window.performance,oD=window.Date,PS=window.setTimeout,IS=window.clearTimeout,typeof console<"u"&&(bS=window.cancelAnimationFrame,typeof window.requestAnimationFrame!="function"&&console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"),typeof bS!="function"&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills")),typeof N_=="object"&&typeof N_.now=="function"?ou.unstable_now=function(){return N_.now()}:(BS=oD.now(),ou.unstable_now=function(){return oD.now()-BS}),Hy=!1,qy=null,L_=-1,lD=5,sD=0,b_=function(){return ou.unstable_now()>=sD},fD=function(){},ou.unstable_forceFrameRate=function(o){0>o||125<o?console.error("forceFrameRate takes a positive int between 0 and 125, forcing framerates higher than 125 fps is not unsupported"):lD=0<o?Math.floor(1e3/o):5},aD=new MessageChannel,F_=aD.port2,aD.port1.onmessage=function(){if(qy!==null){var o=ou.unstable_now();sD=o+lD;try{qy(!0,o)?F_.postMessage(null):(Hy=!1,qy=null)}catch(l){throw F_.postMessage(null),l}}else Hy=!1},Jv=function(o){qy=o,Hy||(Hy=!0,F_.postMessage(null))},Wy=function(o,l){L_=PS(function(){o(ou.unstable_now())},l)},I_=function(){IS(L_),L_=-1});var Qv,iD,uD,LS,N_,oD,PS,IS,bS,BS,Hy,qy,L_,lD,sD,aD,F_;function cD(o,l){var f=o.length;o.push(l);e:for(;;){var h=Math.floor((f-1)/2),E=o[h];if(E!==void 0&&0<P_(E,l))o[h]=l,o[f]=E,f=h;else break e}}function cf(o){return o=o[0],o===void 0?null:o}function B_(o){var l=o[0];if(l!==void 0){var f=o.pop();if(f!==l){o[0]=f;e:for(var h=0,E=o.length;h<E;){var t=2*(h+1)-1,N=o[t],F=t+1,k=o[F];if(N!==void 0&&0>P_(N,f))k!==void 0&&0>P_(k,N)?(o[h]=k,o[F]=f,h=F):(o[h]=N,o[t]=f,h=t);else if(k!==void 0&&0>P_(k,f))o[h]=k,o[F]=f,h=F;else break e}}return l}return null}function P_(o,l){var f=o.sortIndex-l.sortIndex;return f!==0?f:o.id-l.id}var $f=[],f2=[],yP=1,Ls=null,ds=3,U_=!1,$p=!1,Vy=!1;function j_(o){for(var l=cf(f2);l!==null;){if(l.callback===null)B_(f2);else if(l.startTime<=o)B_(f2),l.sortIndex=l.expirationTime,cD($f,l);else break;l=cf(f2)}}function dD(o){if(Vy=!1,j_(o),!$p)if(cf($f)!==null)$p=!0,Jv(pD);else{var l=cf(f2);l!==null&&Wy(dD,l.startTime-o)}}function pD(o,l){$p=!1,Vy&&(Vy=!1,I_()),U_=!0;var f=ds;try{for(j_(l),Ls=cf($f);Ls!==null&&(!(Ls.expirationTime>l)||o&&!b_());){var h=Ls.callback;if(h!==null){Ls.callback=null,ds=Ls.priorityLevel;var E=h(Ls.expirationTime<=l);l=ou.unstable_now(),typeof E=="function"?Ls.callback=E:Ls===cf($f)&&B_($f),j_(l)}else B_($f);Ls=cf($f)}if(Ls!==null)var t=!0;else{var N=cf(f2);N!==null&&Wy(dD,N.startTime-l),t=!1}return t}finally{Ls=null,ds=f,U_=!1}}function US(o){switch(o){case 1:return-1;case 2:return 250;case 5:return 1073741823;case 4:return 1e4;default:return 5e3}}var gP=fD;ou.unstable_ImmediatePriority=1;ou.unstable_UserBlockingPriority=2;ou.unstable_NormalPriority=3;ou.unstable_IdlePriority=5;ou.unstable_LowPriority=4;ou.unstable_runWithPriority=function(o,l){switch(o){case 1:case 2:case 3:case 4:case 5:break;default:o=3}var f=ds;ds=o;try{return l()}finally{ds=f}};ou.unstable_next=function(o){switch(ds){case 1:case 2:case 3:var l=3;break;default:l=ds}var f=ds;ds=l;try{return o()}finally{ds=f}};ou.unstable_scheduleCallback=function(o,l,f){var h=ou.unstable_now();if(typeof f=="object"&&f!==null){var E=f.delay;E=typeof E=="number"&&0<E?h+E:h,f=typeof f.timeout=="number"?f.timeout:US(o)}else f=US(o),E=h;return f=E+f,o={id:yP++,callback:l,priorityLevel:o,startTime:E,expirationTime:f,sortIndex:-1},E>h?(o.sortIndex=E,cD(f2,o),cf($f)===null&&o===cf(f2)&&(Vy?I_():Vy=!0,Wy(dD,E-h))):(o.sortIndex=f,cD($f,o),$p||U_||($p=!0,Jv(pD))),o};ou.unstable_cancelCallback=function(o){o.callback=null};ou.unstable_wrapCallback=function(o){var l=ds;return function(){var f=ds;ds=l;try{return o.apply(this,arguments)}finally{ds=f}}};ou.unstable_getCurrentPriorityLevel=function(){return ds};ou.unstable_shouldYield=function(){var o=ou.unstable_now();j_(o);var l=cf($f);return l!==Ls&&Ls!==null&&l!==null&&l.callback!==null&&l.startTime<=o&&l.expirationTime<Ls.expirationTime||b_()};ou.unstable_requestPaint=gP;ou.unstable_continueExecution=function(){$p||U_||($p=!0,Jv(pD))};ou.unstable_pauseExecution=function(){};ou.unstable_getFirstCallbackNode=function(){return cf($f)};ou.unstable_Profiling=null});var zS=nt(Ii=>{"use strict";process.env.NODE_ENV!=="production"&&function(){"use strict";Object.defineProperty(Ii,"__esModule",{value:!0});var o=!1,l=!1,f=!0,h,E,t,N,F;if(typeof window>"u"||typeof MessageChannel!="function"){var k=null,x=null,j=function(){if(k!==null)try{var St=Ii.unstable_now(),Bt=!0;k(Bt,St),k=null}catch(Hn){throw setTimeout(j,0),Hn}},q=Date.now();Ii.unstable_now=function(){return Date.now()-q},h=function(St){k!==null?setTimeout(h,0,St):(k=St,setTimeout(j,0))},E=function(St,Bt){x=setTimeout(St,Bt)},t=function(){clearTimeout(x)},N=function(){return!1},F=Ii.unstable_forceFrameRate=function(){}}else{var V=window.performance,re=window.Date,y=window.setTimeout,me=window.clearTimeout;if(typeof console<"u"){var De=window.requestAnimationFrame,ge=window.cancelAnimationFrame;typeof De!="function"&&console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"),typeof ge!="function"&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills")}if(typeof V=="object"&&typeof V.now=="function")Ii.unstable_now=function(){return V.now()};else{var ae=re.now();Ii.unstable_now=function(){return re.now()-ae}}var we=!1,he=null,ve=-1,ue=5,Ae=0,ze=300,We=!1;if(l&&navigator!==void 0&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0){var gt=navigator.scheduling;N=function(){var St=Ii.unstable_now();return St>=Ae?We||gt.isInputPending()?!0:St>=ze:!1},F=function(){We=!0}}else N=function(){return Ii.unstable_now()>=Ae},F=function(){};Ii.unstable_forceFrameRate=function(St){if(St<0||St>125){console.error("forceFrameRate takes a positive int between 0 and 125, forcing framerates higher than 125 fps is not unsupported");return}St>0?ue=Math.floor(1e3/St):ue=5};var _t=function(){if(he!==null){var St=Ii.unstable_now();Ae=St+ue;var Bt=!0;try{var Hn=he(Bt,St);Hn?ot.postMessage(null):(we=!1,he=null)}catch(qr){throw ot.postMessage(null),qr}}else we=!1;We=!1},Qe=new MessageChannel,ot=Qe.port2;Qe.port1.onmessage=_t,h=function(St){he=St,we||(we=!0,ot.postMessage(null))},E=function(St,Bt){ve=y(function(){St(Ii.unstable_now())},Bt)},t=function(){me(ve),ve=-1}}function Ve(St,Bt){var Hn=St.length;St.push(Bt),it(St,Bt,Hn)}function Pt(St){var Bt=St[0];return Bt===void 0?null:Bt}function Jt(St){var Bt=St[0];if(Bt!==void 0){var Hn=St.pop();return Hn!==Bt&&(St[0]=Hn,J(St,Hn,0)),Bt}else return null}function it(St,Bt,Hn){for(var qr=Hn;;){var Ki=Math.floor((qr-1)/2),Xr=St[Ki];if(Xr!==void 0&&ce(Xr,Bt)>0)St[Ki]=Bt,St[qr]=Xr,qr=Ki;else return}}function J(St,Bt,Hn){for(var qr=Hn,Ki=St.length;qr<Ki;){var Xr=(qr+1)*2-1,Au=St[Xr],p0=Xr+1,Ni=St[p0];if(Au!==void 0&&ce(Au,Bt)<0)Ni!==void 0&&ce(Ni,Au)<0?(St[qr]=Ni,St[p0]=Bt,qr=p0):(St[qr]=Au,St[Xr]=Bt,qr=Xr);else if(Ni!==void 0&&ce(Ni,Bt)<0)St[qr]=Ni,St[p0]=Bt,qr=p0;else return}}function ce(St,Bt){var Hn=St.sortIndex-Bt.sortIndex;return Hn!==0?Hn:St.id-Bt.id}var Re=0,le=1,He=2,dt=3,At=4,nn=5,an=0,On=0,lr=4,ln=f?typeof SharedArrayBuffer=="function"?new SharedArrayBuffer(lr*Int32Array.BYTES_PER_ELEMENT):typeof ArrayBuffer=="function"?new ArrayBuffer(lr*Int32Array.BYTES_PER_ELEMENT):null:null,Vt=f&&ln!==null?new Int32Array(ln):[],Er=0,S=1,zt=2,Xn=3;f&&(Vt[Er]=Re,Vt[Xn]=0,Vt[S]=0);var vr=131072,jr=524288,fr=0,zr=null,Xt=null,Du=0,c0=1,Ao=2,Jo=3,Fs=4,Zo=5,$o=6,qt=7,xi=8;function lu(St){if(Xt!==null){var Bt=Du;if(Du+=St.length,Du+1>fr){if(fr*=2,fr>jr){console.error("Scheduler Profiling: Event log exceeded maximum size. Don't forget to call `stopLoggingProfilingEvents()`."),Dr();return}var Hn=new Int32Array(fr*4);Hn.set(Xt),zr=Hn.buffer,Xt=Hn}Xt.set(St,Bt)}}function vi(){fr=vr,zr=new ArrayBuffer(fr*4),Xt=new Int32Array(zr),Du=0}function Dr(){var St=zr;return fr=0,zr=null,Xt=null,Du=0,St}function el(St,Bt){f&&(Vt[Xn]++,Xt!==null&&lu([c0,Bt*1e3,St.id,St.priorityLevel]))}function Y0(St,Bt){f&&(Vt[Er]=Re,Vt[S]=0,Vt[Xn]--,Xt!==null&&lu([Ao,Bt*1e3,St.id]))}function Bu(St,Bt){f&&(Vt[Xn]--,Xt!==null&&lu([Fs,Bt*1e3,St.id]))}function K0(St,Bt){f&&(Vt[Er]=Re,Vt[S]=0,Vt[Xn]--,Xt!==null&&lu([Jo,Bt*1e3,St.id]))}function Kr(St,Bt){f&&(an++,Vt[Er]=St.priorityLevel,Vt[S]=St.id,Vt[zt]=an,Xt!==null&&lu([Zo,Bt*1e3,St.id,an]))}function Oo(St,Bt){f&&(Vt[Er]=Re,Vt[S]=0,Vt[zt]=0,Xt!==null&&lu([$o,Bt*1e3,St.id,an]))}function Mo(St){f&&(On++,Xt!==null&&lu([qt,St*1e3,On]))}function F0(St){f&&Xt!==null&&lu([xi,St*1e3,On])}var su=1073741823,ki=-1,Ps=250,Kl=5e3,P0=1e4,d0=su,Hr=[],Ri=[],X0=1,mi=!1,en=null,In=dt,Ai=!1,yi=!1,Wt=!1;function Ru(St){for(var Bt=Pt(Ri);Bt!==null;){if(Bt.callback===null)Jt(Ri);else if(Bt.startTime<=St)Jt(Ri),Bt.sortIndex=Bt.expirationTime,Ve(Hr,Bt),f&&(el(Bt,St),Bt.isQueued=!0);else return;Bt=Pt(Ri)}}function eu(St){if(Wt=!1,Ru(St),!yi)if(Pt(Hr)!==null)yi=!0,h(Q0);else{var Bt=Pt(Ri);Bt!==null&&E(eu,Bt.startTime-St)}}function Q0(St,Bt){f&&F0(Bt),yi=!1,Wt&&(Wt=!1,t()),Ai=!0;var Hn=In;try{if(f)try{return Yi(St,Bt)}catch(Xr){if(en!==null){var qr=Ii.unstable_now();K0(en,qr),en.isQueued=!1}throw Xr}else return Yi(St,Bt)}finally{if(en=null,In=Hn,Ai=!1,f){var Ki=Ii.unstable_now();Mo(Ki)}}}function Yi(St,Bt){var Hn=Bt;for(Ru(Hn),en=Pt(Hr);en!==null&&!(o&&mi)&&!(en.expirationTime>Hn&&(!St||N()));){var qr=en.callback;if(qr!==null){en.callback=null,In=en.priorityLevel;var Ki=en.expirationTime<=Hn;Kr(en,Hn);var Xr=qr(Ki);Hn=Ii.unstable_now(),typeof Xr=="function"?(en.callback=Xr,Oo(en,Hn)):(f&&(Y0(en,Hn),en.isQueued=!1),en===Pt(Hr)&&Jt(Hr)),Ru(Hn)}else Jt(Hr);en=Pt(Hr)}if(en!==null)return!0;var Au=Pt(Ri);return Au!==null&&E(eu,Au.startTime-Hn),!1}function Xl(St,Bt){switch(St){case le:case He:case dt:case At:case nn:break;default:St=dt}var Hn=In;In=St;try{return Bt()}finally{In=Hn}}function ko(St){var Bt;switch(In){case le:case He:case dt:Bt=dt;break;default:Bt=In;break}var Hn=In;In=Bt;try{return St()}finally{In=Hn}}function li(St){var Bt=In;return function(){var Hn=In;In=Bt;try{return St.apply(this,arguments)}finally{In=Hn}}}function ao(St){switch(St){case le:return ki;case He:return Ps;case nn:return d0;case At:return P0;case dt:default:return Kl}}function Ql(St,Bt,Hn){var qr=Ii.unstable_now(),Ki,Xr;if(typeof Hn=="object"&&Hn!==null){var Au=Hn.delay;typeof Au=="number"&&Au>0?Ki=qr+Au:Ki=qr,Xr=typeof Hn.timeout=="number"?Hn.timeout:ao(St)}else Xr=ao(St),Ki=qr;var p0=Ki+Xr,Ni={id:X0++,callback:Bt,priorityLevel:St,startTime:Ki,expirationTime:p0,sortIndex:-1};return f&&(Ni.isQueued=!1),Ki>qr?(Ni.sortIndex=Ki,Ve(Ri,Ni),Pt(Hr)===null&&Ni===Pt(Ri)&&(Wt?t():Wt=!0,E(eu,Ki-qr))):(Ni.sortIndex=p0,Ve(Hr,Ni),f&&(el(Ni,qr),Ni.isQueued=!0),!yi&&!Ai&&(yi=!0,h(Q0))),Ni}function No(){mi=!0}function Is(){mi=!1,!yi&&!Ai&&(yi=!0,h(Q0))}function $n(){return Pt(Hr)}function tl(St){if(f&&St.isQueued){var Bt=Ii.unstable_now();Bu(St,Bt),St.isQueued=!1}St.callback=null}function fo(){return In}function I0(){var St=Ii.unstable_now();Ru(St);var Bt=Pt(Hr);return Bt!==en&&en!==null&&Bt!==null&&Bt.callback!==null&&Bt.startTime<=St&&Bt.expirationTime<en.expirationTime||N()}var Sl=F,Lo=f?{startLoggingProfilingEvents:vi,stopLoggingProfilingEvents:Dr,sharedProfilingBuffer:ln}:null;Ii.unstable_ImmediatePriority=le,Ii.unstable_UserBlockingPriority=He,Ii.unstable_NormalPriority=dt,Ii.unstable_IdlePriority=nn,Ii.unstable_LowPriority=At,Ii.unstable_runWithPriority=Xl,Ii.unstable_next=ko,Ii.unstable_scheduleCallback=Ql,Ii.unstable_cancelCallback=tl,Ii.unstable_wrapCallback=li,Ii.unstable_getCurrentPriorityLevel=fo,Ii.unstable_shouldYield=I0,Ii.unstable_requestPaint=Sl,Ii.unstable_continueExecution=Is,Ii.unstable_pauseExecution=No,Ii.unstable_getFirstCallbackNode=$n,Ii.unstable_Profiling=Lo}()});var z_=nt((vH,hD)=>{"use strict";process.env.NODE_ENV==="production"?hD.exports=jS():hD.exports=zS()});var HS=nt((mH,Gy)=>{Gy.exports=function o(l){"use strict";var f=Py(),h=Mi(),E=z_();function t(_){for(var g="https://reactjs.org/docs/error-decoder.html?invariant="+_,A=1;A<arguments.length;A++)g+="&args[]="+encodeURIComponent(arguments[A]);return"Minified React error #"+_+"; visit "+g+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var N=h.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;N.hasOwnProperty("ReactCurrentDispatcher")||(N.ReactCurrentDispatcher={current:null}),N.hasOwnProperty("ReactCurrentBatchConfig")||(N.ReactCurrentBatchConfig={suspense:null});var F=typeof Symbol=="function"&&Symbol.for,k=F?Symbol.for("react.element"):60103,x=F?Symbol.for("react.portal"):60106,j=F?Symbol.for("react.fragment"):60107,q=F?Symbol.for("react.strict_mode"):60108,V=F?Symbol.for("react.profiler"):60114,re=F?Symbol.for("react.provider"):60109,y=F?Symbol.for("react.context"):60110,me=F?Symbol.for("react.concurrent_mode"):60111,De=F?Symbol.for("react.forward_ref"):60112,ge=F?Symbol.for("react.suspense"):60113,ae=F?Symbol.for("react.suspense_list"):60120,we=F?Symbol.for("react.memo"):60115,he=F?Symbol.for("react.lazy"):60116;F&&Symbol.for("react.fundamental"),F&&Symbol.for("react.responder"),F&&Symbol.for("react.scope");var ve=typeof Symbol=="function"&&Symbol.iterator;function ue(_){return _===null||typeof _!="object"?null:(_=ve&&_[ve]||_["@@iterator"],typeof _=="function"?_:null)}function Ae(_){if(_._status===-1){_._status=0;var g=_._ctor;g=g(),_._result=g,g.then(function(A){_._status===0&&(A=A.default,_._status=1,_._result=A)},function(A){_._status===0&&(_._status=2,_._result=A)})}}function ze(_){if(_==null)return null;if(typeof _=="function")return _.displayName||_.name||null;if(typeof _=="string")return _;switch(_){case j:return"Fragment";case x:return"Portal";case V:return"Profiler";case q:return"StrictMode";case ge:return"Suspense";case ae:return"SuspenseList"}if(typeof _=="object")switch(_.$$typeof){case y:return"Context.Consumer";case re:return"Context.Provider";case De:var g=_.render;return g=g.displayName||g.name||"",_.displayName||(g!==""?"ForwardRef("+g+")":"ForwardRef");case we:return ze(_.type);case he:if(_=_._status===1?_._result:null)return ze(_)}return null}function We(_){var g=_,A=_;if(_.alternate)for(;g.return;)g=g.return;else{_=g;do g=_,(g.effectTag&1026)!==0&&(A=g.return),_=g.return;while(_)}return g.tag===3?A:null}function gt(_){if(We(_)!==_)throw Error(t(188))}function _t(_){var g=_.alternate;if(!g){if(g=We(_),g===null)throw Error(t(188));return g!==_?null:_}for(var A=_,P=g;;){var B=A.return;if(B===null)break;var Z=B.alternate;if(Z===null){if(P=B.return,P!==null){A=P;continue}break}if(B.child===Z.child){for(Z=B.child;Z;){if(Z===A)return gt(B),_;if(Z===P)return gt(B),g;Z=Z.sibling}throw Error(t(188))}if(A.return!==P.return)A=B,P=Z;else{for(var de=!1,yt=B.child;yt;){if(yt===A){de=!0,A=B,P=Z;break}if(yt===P){de=!0,P=B,A=Z;break}yt=yt.sibling}if(!de){for(yt=Z.child;yt;){if(yt===A){de=!0,A=Z,P=B;break}if(yt===P){de=!0,P=Z,A=B;break}yt=yt.sibling}if(!de)throw Error(t(189))}}if(A.alternate!==P)throw Error(t(190))}if(A.tag!==3)throw Error(t(188));return A.stateNode.current===A?_:g}function Qe(_){if(_=_t(_),!_)return null;for(var g=_;;){if(g.tag===5||g.tag===6)return g;if(g.child)g.child.return=g,g=g.child;else{if(g===_)break;for(;!g.sibling;){if(!g.return||g.return===_)return null;g=g.return}g.sibling.return=g.return,g=g.sibling}}return null}function ot(_){if(_=_t(_),!_)return null;for(var g=_;;){if(g.tag===5||g.tag===6)return g;if(g.child&&g.tag!==4)g.child.return=g,g=g.child;else{if(g===_)break;for(;!g.sibling;){if(!g.return||g.return===_)return null;g=g.return}g.sibling.return=g.return,g=g.sibling}}return null}var Ve=l.getPublicInstance,Pt=l.getRootHostContext,Jt=l.getChildHostContext,it=l.prepareForCommit,J=l.resetAfterCommit,ce=l.createInstance,Re=l.appendInitialChild,le=l.finalizeInitialChildren,He=l.prepareUpdate,dt=l.shouldSetTextContent,At=l.shouldDeprioritizeSubtree,nn=l.createTextInstance,an=l.setTimeout,On=l.clearTimeout,lr=l.noTimeout,ln=l.isPrimaryRenderer,Vt=l.supportsMutation,Er=l.supportsPersistence,S=l.supportsHydration,zt=l.appendChild,Xn=l.appendChildToContainer,vr=l.commitTextUpdate,jr=l.commitMount,fr=l.commitUpdate,zr=l.insertBefore,Xt=l.insertInContainerBefore,Du=l.removeChild,c0=l.removeChildFromContainer,Ao=l.resetTextContent,Jo=l.hideInstance,Fs=l.hideTextInstance,Zo=l.unhideInstance,$o=l.unhideTextInstance,qt=l.cloneInstance,xi=l.createContainerChildSet,lu=l.appendChildToContainerChildSet,vi=l.finalizeContainerChildren,Dr=l.replaceContainerChildren,el=l.cloneHiddenInstance,Y0=l.cloneHiddenTextInstance,Bu=l.canHydrateInstance,K0=l.canHydrateTextInstance,Kr=l.isSuspenseInstancePending,Oo=l.isSuspenseInstanceFallback,Mo=l.getNextHydratableSibling,F0=l.getFirstHydratableChild,su=l.hydrateInstance,ki=l.hydrateTextInstance,Ps=l.getNextHydratableInstanceAfterSuspenseInstance,Kl=l.commitHydratedContainer,P0=l.commitHydratedSuspenseInstance,d0=/^(.*)[\\\/]/;function Hr(_){var g="";do{e:switch(_.tag){case 3:case 4:case 6:case 7:case 10:case 9:var A="";break e;default:var P=_._debugOwner,B=_._debugSource,Z=ze(_.type);A=null,P&&(A=ze(P.type)),P=Z,Z="",B?Z=" (at "+B.fileName.replace(d0,"")+":"+B.lineNumber+")":A&&(Z=" (created by "+A+")"),A=`
+    in `+(P||"Unknown")+Z}g+=A,_=_.return}while(_);return g}var Ri=[],X0=-1;function mi(_){0>X0||(_.current=Ri[X0],Ri[X0]=null,X0--)}function en(_,g){X0++,Ri[X0]=_.current,_.current=g}var In={},Ai={current:In},yi={current:!1},Wt=In;function Ru(_,g){var A=_.type.contextTypes;if(!A)return In;var P=_.stateNode;if(P&&P.__reactInternalMemoizedUnmaskedChildContext===g)return P.__reactInternalMemoizedMaskedChildContext;var B={},Z;for(Z in A)B[Z]=g[Z];return P&&(_=_.stateNode,_.__reactInternalMemoizedUnmaskedChildContext=g,_.__reactInternalMemoizedMaskedChildContext=B),B}function eu(_){return _=_.childContextTypes,_!=null}function Q0(_){mi(yi,_),mi(Ai,_)}function Yi(_){mi(yi,_),mi(Ai,_)}function Xl(_,g,A){if(Ai.current!==In)throw Error(t(168));en(Ai,g,_),en(yi,A,_)}function ko(_,g,A){var P=_.stateNode;if(_=g.childContextTypes,typeof P.getChildContext!="function")return A;P=P.getChildContext();for(var B in P)if(!(B in _))throw Error(t(108,ze(g)||"Unknown",B));return f({},A,{},P)}function li(_){var g=_.stateNode;return g=g&&g.__reactInternalMemoizedMergedChildContext||In,Wt=Ai.current,en(Ai,g,_),en(yi,yi.current,_),!0}function ao(_,g,A){var P=_.stateNode;if(!P)throw Error(t(169));A?(g=ko(_,g,Wt),P.__reactInternalMemoizedMergedChildContext=g,mi(yi,_),mi(Ai,_),en(Ai,g,_)):mi(yi,_),en(yi,A,_)}var Ql=E.unstable_runWithPriority,No=E.unstable_scheduleCallback,Is=E.unstable_cancelCallback,$n=E.unstable_shouldYield,tl=E.unstable_requestPaint,fo=E.unstable_now,I0=E.unstable_getCurrentPriorityLevel,Sl=E.unstable_ImmediatePriority,Lo=E.unstable_UserBlockingPriority,St=E.unstable_NormalPriority,Bt=E.unstable_LowPriority,Hn=E.unstable_IdlePriority,qr={},Ki=tl!==void 0?tl:function(){},Xr=null,Au=null,p0=!1,Ni=fo(),h0=1e4>Ni?fo:function(){return fo()-Ni};function hs(){switch(I0()){case Sl:return 99;case Lo:return 98;case St:return 97;case Bt:return 96;case Hn:return 95;default:throw Error(t(332))}}function Ct(_){switch(_){case 99:return Sl;case 98:return Lo;case 97:return St;case 96:return Bt;case 95:return Hn;default:throw Error(t(332))}}function co(_,g){return _=Ct(_),Ql(_,g)}function nl(_,g,A){return _=Ct(_),No(_,g,A)}function Jl(_){return Xr===null?(Xr=[_],Au=No(Sl,vs)):Xr.push(_),qr}function Uu(){if(Au!==null){var _=Au;Au=null,Is(_)}vs()}function vs(){if(!p0&&Xr!==null){p0=!0;var _=0;try{var g=Xr;co(99,function(){for(;_<g.length;_++){var A=g[_];do A=A(!0);while(A!==null)}}),Xr=null}catch(A){throw Xr!==null&&(Xr=Xr.slice(_+1)),No(Sl,Uu),A}finally{p0=!1}}}var b0=3;function Q(_,g,A){return A/=10,1073741821-(((1073741821-_+g/10)/A|0)+1)*A}function Se(_,g){return _===g&&(_!==0||1/_===1/g)||_!==_&&g!==g}var Fe=typeof Object.is=="function"?Object.is:Se,Le=Object.prototype.hasOwnProperty;function pt(_,g){if(Fe(_,g))return!0;if(typeof _!="object"||_===null||typeof g!="object"||g===null)return!1;var A=Object.keys(_),P=Object.keys(g);if(A.length!==P.length)return!1;for(P=0;P<A.length;P++)if(!Le.call(g,A[P])||!Fe(_[A[P]],g[A[P]]))return!1;return!0}function Yn(_,g){if(_&&_.defaultProps){g=f({},g),_=_.defaultProps;for(var A in _)g[A]===void 0&&(g[A]=_[A])}return g}var Cn={current:null},cr=null,Si=null,Ou=null;function ju(){Ou=Si=cr=null}function zu(_,g){var A=_.type._context;ln?(en(Cn,A._currentValue,_),A._currentValue=g):(en(Cn,A._currentValue2,_),A._currentValue2=g)}function wu(_){var g=Cn.current;mi(Cn,_),_=_.type._context,ln?_._currentValue=g:_._currentValue2=g}function Ti(_,g){for(;_!==null;){var A=_.alternate;if(_.childExpirationTime<g)_.childExpirationTime=g,A!==null&&A.childExpirationTime<g&&(A.childExpirationTime=g);else if(A!==null&&A.childExpirationTime<g)A.childExpirationTime=g;else break;_=_.return}}function Fo(_,g){cr=_,Ou=Si=null,_=_.dependencies,_!==null&&_.firstContext!==null&&(_.expirationTime>=g&&(ho=!0),_.firstContext=null)}function Mu(_,g){if(Ou!==_&&g!==!1&&g!==0)if((typeof g!="number"||g===1073741823)&&(Ou=_,g=1073741823),g={context:_,observedBits:g,next:null},Si===null){if(cr===null)throw Error(t(308));Si=g,cr.dependencies={expirationTime:0,firstContext:g,responders:null}}else Si=Si.next=g;return ln?_._currentValue:_._currentValue2}var po=!1;function Hu(_){return{baseState:_,firstUpdate:null,lastUpdate:null,firstCapturedUpdate:null,lastCapturedUpdate:null,firstEffect:null,lastEffect:null,firstCapturedEffect:null,lastCapturedEffect:null}}function Pa(_){return{baseState:_.baseState,firstUpdate:_.firstUpdate,lastUpdate:_.lastUpdate,firstCapturedUpdate:null,lastCapturedUpdate:null,firstEffect:null,lastEffect:null,firstCapturedEffect:null,lastCapturedEffect:null}}function v0(_,g){return{expirationTime:_,suspenseConfig:g,tag:0,payload:null,callback:null,next:null,nextEffect:null}}function ia(_,g){_.lastUpdate===null?_.firstUpdate=_.lastUpdate=g:(_.lastUpdate.next=g,_.lastUpdate=g)}function J0(_,g){var A=_.alternate;if(A===null){var P=_.updateQueue,B=null;P===null&&(P=_.updateQueue=Hu(_.memoizedState))}else P=_.updateQueue,B=A.updateQueue,P===null?B===null?(P=_.updateQueue=Hu(_.memoizedState),B=A.updateQueue=Hu(A.memoizedState)):P=_.updateQueue=Pa(B):B===null&&(B=A.updateQueue=Pa(P));B===null||P===B?ia(P,g):P.lastUpdate===null||B.lastUpdate===null?(ia(P,g),ia(B,g)):(ia(P,g),B.lastUpdate=g)}function ua(_,g){var A=_.updateQueue;A=A===null?_.updateQueue=Hu(_.memoizedState):Ia(_,A),A.lastCapturedUpdate===null?A.firstCapturedUpdate=A.lastCapturedUpdate=g:(A.lastCapturedUpdate.next=g,A.lastCapturedUpdate=g)}function Ia(_,g){var A=_.alternate;return A!==null&&g===A.updateQueue&&(g=_.updateQueue=Pa(g)),g}function ms(_,g,A,P,B,Z){switch(A.tag){case 1:return _=A.payload,typeof _=="function"?_.call(Z,P,B):_;case 3:_.effectTag=_.effectTag&-4097|64;case 0:if(_=A.payload,B=typeof _=="function"?_.call(Z,P,B):_,B==null)break;return f({},P,B);case 2:po=!0}return P}function S0(_,g,A,P,B){po=!1,g=Ia(_,g);for(var Z=g.baseState,de=null,yt=0,Rt=g.firstUpdate,Nt=Z;Rt!==null;){var xr=Rt.expirationTime;xr<B?(de===null&&(de=Rt,Z=Nt),yt<xr&&(yt=xr)):(cc(xr,Rt.suspenseConfig),Nt=ms(_,g,Rt,Nt,A,P),Rt.callback!==null&&(_.effectTag|=32,Rt.nextEffect=null,g.lastEffect===null?g.firstEffect=g.lastEffect=Rt:(g.lastEffect.nextEffect=Rt,g.lastEffect=Rt))),Rt=Rt.next}for(xr=null,Rt=g.firstCapturedUpdate;Rt!==null;){var r0=Rt.expirationTime;r0<B?(xr===null&&(xr=Rt,de===null&&(Z=Nt)),yt<r0&&(yt=r0)):(Nt=ms(_,g,Rt,Nt,A,P),Rt.callback!==null&&(_.effectTag|=32,Rt.nextEffect=null,g.lastCapturedEffect===null?g.firstCapturedEffect=g.lastCapturedEffect=Rt:(g.lastCapturedEffect.nextEffect=Rt,g.lastCapturedEffect=Rt))),Rt=Rt.next}de===null&&(g.lastUpdate=null),xr===null?g.lastCapturedUpdate=null:_.effectTag|=32,de===null&&xr===null&&(Z=Nt),g.baseState=Z,g.firstUpdate=de,g.firstCapturedUpdate=xr,Ua(yt),_.expirationTime=yt,_.memoizedState=Nt}function Qn(_,g,A){g.firstCapturedUpdate!==null&&(g.lastUpdate!==null&&(g.lastUpdate.next=g.firstCapturedUpdate,g.lastUpdate=g.lastCapturedUpdate),g.firstCapturedUpdate=g.lastCapturedUpdate=null),ac(g.firstEffect,A),g.firstEffect=g.lastEffect=null,ac(g.firstCapturedEffect,A),g.firstCapturedEffect=g.lastCapturedEffect=null}function ac(_,g){for(;_!==null;){var A=_.callback;if(A!==null){_.callback=null;var P=g;if(typeof A!="function")throw Error(t(191,A));A.call(P)}_=_.nextEffect}}var si=N.ReactCurrentBatchConfig,Jr=new h.Component().refs;function Zl(_,g,A,P){g=_.memoizedState,A=A(P,g),A=A==null?g:f({},g,A),_.memoizedState=A,P=_.updateQueue,P!==null&&_.expirationTime===0&&(P.baseState=A)}var oa={isMounted:function(_){return(_=_._reactInternalFiber)?We(_)===_:!1},enqueueSetState:function(_,g,A){_=_._reactInternalFiber;var P=E0(),B=si.suspense;P=Un(P,_,B),B=v0(P,B),B.payload=g,A!=null&&(B.callback=A),J0(_,B),e0(_,P)},enqueueReplaceState:function(_,g,A){_=_._reactInternalFiber;var P=E0(),B=si.suspense;P=Un(P,_,B),B=v0(P,B),B.tag=1,B.payload=g,A!=null&&(B.callback=A),J0(_,B),e0(_,P)},enqueueForceUpdate:function(_,g){_=_._reactInternalFiber;var A=E0(),P=si.suspense;A=Un(A,_,P),P=v0(A,P),P.tag=2,g!=null&&(P.callback=g),J0(_,P),e0(_,A)}};function pf(_,g,A,P,B,Z,de){return _=_.stateNode,typeof _.shouldComponentUpdate=="function"?_.shouldComponentUpdate(P,Z,de):g.prototype&&g.prototype.isPureReactComponent?!pt(A,P)||!pt(B,Z):!0}function bs(_,g,A){var P=!1,B=In,Z=g.contextType;return typeof Z=="object"&&Z!==null?Z=Mu(Z):(B=eu(g)?Wt:Ai.current,P=g.contextTypes,Z=(P=P!=null)?Ru(_,B):In),g=new g(A,Z),_.memoizedState=g.state!==null&&g.state!==void 0?g.state:null,g.updater=oa,_.stateNode=g,g._reactInternalFiber=_,P&&(_=_.stateNode,_.__reactInternalMemoizedUnmaskedChildContext=B,_.__reactInternalMemoizedMaskedChildContext=Z),g}function ba(_,g,A,P){_=g.state,typeof g.componentWillReceiveProps=="function"&&g.componentWillReceiveProps(A,P),typeof g.UNSAFE_componentWillReceiveProps=="function"&&g.UNSAFE_componentWillReceiveProps(A,P),g.state!==_&&oa.enqueueReplaceState(g,g.state,null)}function Bs(_,g,A,P){var B=_.stateNode;B.props=A,B.state=_.memoizedState,B.refs=Jr;var Z=g.contextType;typeof Z=="object"&&Z!==null?B.context=Mu(Z):(Z=eu(g)?Wt:Ai.current,B.context=Ru(_,Z)),Z=_.updateQueue,Z!==null&&(S0(_,Z,A,B,P),B.state=_.memoizedState),Z=g.getDerivedStateFromProps,typeof Z=="function"&&(Zl(_,g,Z,A),B.state=_.memoizedState),typeof g.getDerivedStateFromProps=="function"||typeof B.getSnapshotBeforeUpdate=="function"||typeof B.UNSAFE_componentWillMount!="function"&&typeof B.componentWillMount!="function"||(g=B.state,typeof B.componentWillMount=="function"&&B.componentWillMount(),typeof B.UNSAFE_componentWillMount=="function"&&B.UNSAFE_componentWillMount(),g!==B.state&&oa.enqueueReplaceState(B,B.state,null),Z=_.updateQueue,Z!==null&&(S0(_,Z,A,B,P),B.state=_.memoizedState)),typeof B.componentDidMount=="function"&&(_.effectTag|=4)}var m0=Array.isArray;function Us(_,g,A){if(_=A.ref,_!==null&&typeof _!="function"&&typeof _!="object"){if(A._owner){if(A=A._owner,A){if(A.tag!==1)throw Error(t(309));var P=A.stateNode}if(!P)throw Error(t(147,_));var B=""+_;return g!==null&&g.ref!==null&&typeof g.ref=="function"&&g.ref._stringRef===B?g.ref:(g=function(Z){var de=P.refs;de===Jr&&(de=P.refs={}),Z===null?delete de[B]:de[B]=Z},g._stringRef=B,g)}if(typeof _!="string")throw Error(t(284));if(!A._owner)throw Error(t(290,_))}return _}function zi(_,g){if(_.type!=="textarea")throw Error(t(31,Object.prototype.toString.call(g)==="[object Object]"?"object with keys {"+Object.keys(g).join(", ")+"}":g,""))}function U(_){function g(Ge,je){if(_){var st=Ge.lastEffect;st!==null?(st.nextEffect=je,Ge.lastEffect=je):Ge.firstEffect=Ge.lastEffect=je,je.nextEffect=null,je.effectTag=8}}function A(Ge,je){if(!_)return null;for(;je!==null;)g(Ge,je),je=je.sibling;return null}function P(Ge,je){for(Ge=new Map;je!==null;)je.key!==null?Ge.set(je.key,je):Ge.set(je.index,je),je=je.sibling;return Ge}function B(Ge,je,st){return Ge=Vu(Ge,je,st),Ge.index=0,Ge.sibling=null,Ge}function Z(Ge,je,st){return Ge.index=st,_?(st=Ge.alternate,st!==null?(st=st.index,st<je?(Ge.effectTag=2,je):st):(Ge.effectTag=2,je)):je}function de(Ge){return _&&Ge.alternate===null&&(Ge.effectTag=2),Ge}function yt(Ge,je,st,$t){return je===null||je.tag!==6?(je=j0(st,Ge.mode,$t),je.return=Ge,je):(je=B(je,st,$t),je.return=Ge,je)}function Rt(Ge,je,st,$t){return je!==null&&je.elementType===st.type?($t=B(je,st.props,$t),$t.ref=Us(Ge,je,st),$t.return=Ge,$t):($t=qa(st.type,st.key,st.props,null,Ge.mode,$t),$t.ref=Us(Ge,je,st),$t.return=Ge,$t)}function Nt(Ge,je,st,$t){return je===null||je.tag!==4||je.stateNode.containerInfo!==st.containerInfo||je.stateNode.implementation!==st.implementation?(je=Df(st,Ge.mode,$t),je.return=Ge,je):(je=B(je,st.children||[],$t),je.return=Ge,je)}function xr(Ge,je,st,$t,Wn){return je===null||je.tag!==7?(je=n0(st,Ge.mode,$t,Wn),je.return=Ge,je):(je=B(je,st,$t),je.return=Ge,je)}function r0(Ge,je,st){if(typeof je=="string"||typeof je=="number")return je=j0(""+je,Ge.mode,st),je.return=Ge,je;if(typeof je=="object"&&je!==null){switch(je.$$typeof){case k:return st=qa(je.type,je.key,je.props,null,Ge.mode,st),st.ref=Us(Ge,null,je),st.return=Ge,st;case x:return je=Df(je,Ge.mode,st),je.return=Ge,je}if(m0(je)||ue(je))return je=n0(je,Ge.mode,st,null),je.return=Ge,je;zi(Ge,je)}return null}function cu(Ge,je,st,$t){var Wn=je!==null?je.key:null;if(typeof st=="string"||typeof st=="number")return Wn!==null?null:yt(Ge,je,""+st,$t);if(typeof st=="object"&&st!==null){switch(st.$$typeof){case k:return st.key===Wn?st.type===j?xr(Ge,je,st.props.children,$t,Wn):Rt(Ge,je,st,$t):null;case x:return st.key===Wn?Nt(Ge,je,st,$t):null}if(m0(st)||ue(st))return Wn!==null?null:xr(Ge,je,st,$t,null);zi(Ge,st)}return null}function z0(Ge,je,st,$t,Wn){if(typeof $t=="string"||typeof $t=="number")return Ge=Ge.get(st)||null,yt(je,Ge,""+$t,Wn);if(typeof $t=="object"&&$t!==null){switch($t.$$typeof){case k:return Ge=Ge.get($t.key===null?st:$t.key)||null,$t.type===j?xr(je,Ge,$t.props.children,Wn,$t.key):Rt(je,Ge,$t,Wn);case x:return Ge=Ge.get($t.key===null?st:$t.key)||null,Nt(je,Ge,$t,Wn)}if(m0($t)||ue($t))return Ge=Ge.get(st)||null,xr(je,Ge,$t,Wn,null);zi(je,$t)}return null}function Ml(Ge,je,st,$t){for(var Wn=null,oi=null,ur=je,ai=je=0,Qi=null;ur!==null&&ai<st.length;ai++){ur.index>ai?(Qi=ur,ur=null):Qi=ur.sibling;var Vr=cu(Ge,ur,st[ai],$t);if(Vr===null){ur===null&&(ur=Qi);break}_&&ur&&Vr.alternate===null&&g(Ge,ur),je=Z(Vr,je,ai),oi===null?Wn=Vr:oi.sibling=Vr,oi=Vr,ur=Qi}if(ai===st.length)return A(Ge,ur),Wn;if(ur===null){for(;ai<st.length;ai++)ur=r0(Ge,st[ai],$t),ur!==null&&(je=Z(ur,je,ai),oi===null?Wn=ur:oi.sibling=ur,oi=ur);return Wn}for(ur=P(Ge,ur);ai<st.length;ai++)Qi=z0(ur,Ge,ai,st[ai],$t),Qi!==null&&(_&&Qi.alternate!==null&&ur.delete(Qi.key===null?ai:Qi.key),je=Z(Qi,je,ai),oi===null?Wn=Qi:oi.sibling=Qi,oi=Qi);return _&&ur.forEach(function(Tu){return g(Ge,Tu)}),Wn}function i0(Ge,je,st,$t){var Wn=ue(st);if(typeof Wn!="function")throw Error(t(150));if(st=Wn.call(st),st==null)throw Error(t(151));for(var oi=Wn=null,ur=je,ai=je=0,Qi=null,Vr=st.next();ur!==null&&!Vr.done;ai++,Vr=st.next()){ur.index>ai?(Qi=ur,ur=null):Qi=ur.sibling;var Tu=cu(Ge,ur,Vr.value,$t);if(Tu===null){ur===null&&(ur=Qi);break}_&&ur&&Tu.alternate===null&&g(Ge,ur),je=Z(Tu,je,ai),oi===null?Wn=Tu:oi.sibling=Tu,oi=Tu,ur=Qi}if(Vr.done)return A(Ge,ur),Wn;if(ur===null){for(;!Vr.done;ai++,Vr=st.next())Vr=r0(Ge,Vr.value,$t),Vr!==null&&(je=Z(Vr,je,ai),oi===null?Wn=Vr:oi.sibling=Vr,oi=Vr);return Wn}for(ur=P(Ge,ur);!Vr.done;ai++,Vr=st.next())Vr=z0(ur,Ge,ai,Vr.value,$t),Vr!==null&&(_&&Vr.alternate!==null&&ur.delete(Vr.key===null?ai:Vr.key),je=Z(Vr,je,ai),oi===null?Wn=Vr:oi.sibling=Vr,oi=Vr);return _&&ur.forEach(function(Wa){return g(Ge,Wa)}),Wn}return function(Ge,je,st,$t){var Wn=typeof st=="object"&&st!==null&&st.type===j&&st.key===null;Wn&&(st=st.props.children);var oi=typeof st=="object"&&st!==null;if(oi)switch(st.$$typeof){case k:e:{for(oi=st.key,Wn=je;Wn!==null;){if(Wn.key===oi)if(Wn.tag===7?st.type===j:Wn.elementType===st.type){A(Ge,Wn.sibling),je=B(Wn,st.type===j?st.props.children:st.props,$t),je.ref=Us(Ge,Wn,st),je.return=Ge,Ge=je;break e}else{A(Ge,Wn);break}else g(Ge,Wn);Wn=Wn.sibling}st.type===j?(je=n0(st.props.children,Ge.mode,$t,st.key),je.return=Ge,Ge=je):($t=qa(st.type,st.key,st.props,null,Ge.mode,$t),$t.ref=Us(Ge,je,st),$t.return=Ge,Ge=$t)}return de(Ge);case x:e:{for(Wn=st.key;je!==null;){if(je.key===Wn)if(je.tag===4&&je.stateNode.containerInfo===st.containerInfo&&je.stateNode.implementation===st.implementation){A(Ge,je.sibling),je=B(je,st.children||[],$t),je.return=Ge,Ge=je;break e}else{A(Ge,je);break}else g(Ge,je);je=je.sibling}je=Df(st,Ge.mode,$t),je.return=Ge,Ge=je}return de(Ge)}if(typeof st=="string"||typeof st=="number")return st=""+st,je!==null&&je.tag===6?(A(Ge,je.sibling),je=B(je,st,$t),je.return=Ge,Ge=je):(A(Ge,je),je=j0(st,Ge.mode,$t),je.return=Ge,Ge=je),de(Ge);if(m0(st))return Ml(Ge,je,st,$t);if(ue(st))return i0(Ge,je,st,$t);if(oi&&zi(Ge,st),typeof st>"u"&&!Wn)switch(Ge.tag){case 1:case 0:throw Ge=Ge.type,Error(t(152,Ge.displayName||Ge.name||"Component"))}return A(Ge,je)}}var H=U(!0),Y=U(!1),ee={},Ce={current:ee},_e={current:ee},Oe={current:ee};function $(_){if(_===ee)throw Error(t(174));return _}function Ne(_,g){en(Oe,g,_),en(_e,_,_),en(Ce,ee,_),g=Pt(g),mi(Ce,_),en(Ce,g,_)}function Je(_){mi(Ce,_),mi(_e,_),mi(Oe,_)}function vt(_){var g=$(Oe.current),A=$(Ce.current);g=Jt(A,_.type,g),A!==g&&(en(_e,_,_),en(Ce,g,_))}function oe(_){_e.current===_&&(mi(Ce,_),mi(_e,_))}var qe={current:0};function rt(_){for(var g=_;g!==null;){if(g.tag===13){var A=g.memoizedState;if(A!==null&&(A=A.dehydrated,A===null||Kr(A)||Oo(A)))return g}else if(g.tag===19&&g.memoizedProps.revealOrder!==void 0){if((g.effectTag&64)!==0)return g}else if(g.child!==null){g.child.return=g,g=g.child;continue}if(g===_)break;for(;g.sibling===null;){if(g.return===null||g.return===_)return null;g=g.return}g.sibling.return=g.return,g=g.sibling}return null}function xt(_,g){return{responder:_,props:g}}var kt=N.ReactCurrentDispatcher,bt=N.ReactCurrentBatchConfig,sn=0,rn=null,Ft=null,Dn=null,dr=null,er=null,Cr=null,Rn=0,Nr=null,y0=0,Lr=!1,ut=null,wt=0;function et(){throw Error(t(321))}function It(_,g){if(g===null)return!1;for(var A=0;A<g.length&&A<_.length;A++)if(!Fe(_[A],g[A]))return!1;return!0}function un(_,g,A,P,B,Z){if(sn=Z,rn=g,Dn=_!==null?_.memoizedState:null,kt.current=Dn===null?Bo:gs,g=A(P,B),Lr){do Lr=!1,wt+=1,Dn=_!==null?_.memoizedState:null,Cr=dr,Nr=er=Ft=null,kt.current=gs,g=A(P,B);while(Lr);ut=null,wt=0}if(kt.current=bo,_=rn,_.memoizedState=dr,_.expirationTime=Rn,_.updateQueue=Nr,_.effectTag|=y0,_=Ft!==null&&Ft.next!==null,sn=0,Cr=er=dr=Dn=Ft=rn=null,Rn=0,Nr=null,y0=0,_)throw Error(t(300));return g}function fn(){kt.current=bo,sn=0,Cr=er=dr=Dn=Ft=rn=null,Rn=0,Nr=null,y0=0,Lr=!1,ut=null,wt=0}function Jn(){var _={memoizedState:null,baseState:null,queue:null,baseUpdate:null,next:null};return er===null?dr=er=_:er=er.next=_,er}function wr(){if(Cr!==null)er=Cr,Cr=er.next,Ft=Dn,Dn=Ft!==null?Ft.next:null;else{if(Dn===null)throw Error(t(310));Ft=Dn;var _={memoizedState:Ft.memoizedState,baseState:Ft.baseState,queue:Ft.queue,baseUpdate:Ft.baseUpdate,next:null};er=er===null?dr=_:er.next=_,Dn=Ft.next}return er}function au(_,g){return typeof g=="function"?g(_):g}function ku(_){var g=wr(),A=g.queue;if(A===null)throw Error(t(311));if(A.lastRenderedReducer=_,0<wt){var P=A.dispatch;if(ut!==null){var B=ut.get(A);if(B!==void 0){ut.delete(A);var Z=g.memoizedState;do Z=_(Z,B.action),B=B.next;while(B!==null);return Fe(Z,g.memoizedState)||(ho=!0),g.memoizedState=Z,g.baseUpdate===A.last&&(g.baseState=Z),A.lastRenderedState=Z,[Z,P]}}return[g.memoizedState,P]}P=A.last;var de=g.baseUpdate;if(Z=g.baseState,de!==null?(P!==null&&(P.next=null),P=de.next):P=P!==null?P.next:null,P!==null){var yt=B=null,Rt=P,Nt=!1;do{var xr=Rt.expirationTime;xr<sn?(Nt||(Nt=!0,yt=de,B=Z),xr>Rn&&(Rn=xr,Ua(Rn))):(cc(xr,Rt.suspenseConfig),Z=Rt.eagerReducer===_?Rt.eagerState:_(Z,Rt.action)),de=Rt,Rt=Rt.next}while(Rt!==null&&Rt!==P);Nt||(yt=de,B=Z),Fe(Z,g.memoizedState)||(ho=!0),g.memoizedState=Z,g.baseUpdate=yt,g.baseState=B,A.lastRenderedState=Z}return[g.memoizedState,A.dispatch]}function T0(_){var g=Jn();return typeof _=="function"&&(_=_()),g.memoizedState=g.baseState=_,_=g.queue={last:null,dispatch:null,lastRenderedReducer:au,lastRenderedState:_},_=_.dispatch=js.bind(null,rn,_),[g.memoizedState,_]}function Z0(_){return ku(au,_)}function Nu(_,g,A,P){return _={tag:_,create:g,destroy:A,deps:P,next:null},Nr===null?(Nr={lastEffect:null},Nr.lastEffect=_.next=_):(g=Nr.lastEffect,g===null?Nr.lastEffect=_.next=_:(A=g.next,g.next=_,_.next=A,Nr.lastEffect=_)),_}function gi(_,g,A,P){var B=Jn();y0|=_,B.memoizedState=Nu(g,A,void 0,P===void 0?null:P)}function Po(_,g,A,P){var B=wr();P=P===void 0?null:P;var Z=void 0;if(Ft!==null){var de=Ft.memoizedState;if(Z=de.destroy,P!==null&&It(P,de.deps)){Nu(0,A,Z,P);return}}y0|=_,B.memoizedState=Nu(g,A,Z,P)}function rl(_,g){return gi(516,192,_,g)}function hf(_,g){return Po(516,192,_,g)}function Tl(_,g){if(typeof g=="function")return _=_(),g(_),function(){g(null)};if(g!=null)return _=_(),g.current=_,function(){g.current=null}}function vf(){}function Io(_,g){return Jn().memoizedState=[_,g===void 0?null:g],_}function ys(_,g){var A=wr();g=g===void 0?null:g;var P=A.memoizedState;return P!==null&&g!==null&&It(g,P[1])?P[0]:(A.memoizedState=[_,g],_)}function js(_,g,A){if(!(25>wt))throw Error(t(301));var P=_.alternate;if(_===rn||P!==null&&P===rn)if(Lr=!0,_={expirationTime:sn,suspenseConfig:null,action:A,eagerReducer:null,eagerState:null,next:null},ut===null&&(ut=new Map),A=ut.get(g),A===void 0)ut.set(g,_);else{for(g=A;g.next!==null;)g=g.next;g.next=_}else{var B=E0(),Z=si.suspense;B=Un(B,_,Z),Z={expirationTime:B,suspenseConfig:Z,action:A,eagerReducer:null,eagerState:null,next:null};var de=g.last;if(de===null)Z.next=Z;else{var yt=de.next;yt!==null&&(Z.next=yt),de.next=Z}if(g.last=Z,_.expirationTime===0&&(P===null||P.expirationTime===0)&&(P=g.lastRenderedReducer,P!==null))try{var Rt=g.lastRenderedState,Nt=P(Rt,A);if(Z.eagerReducer=P,Z.eagerState=Nt,Fe(Nt,Rt))return}catch{}finally{}e0(_,B)}}var bo={readContext:Mu,useCallback:et,useContext:et,useEffect:et,useImperativeHandle:et,useLayoutEffect:et,useMemo:et,useReducer:et,useRef:et,useState:et,useDebugValue:et,useResponder:et,useDeferredValue:et,useTransition:et},Bo={readContext:Mu,useCallback:Io,useContext:Mu,useEffect:rl,useImperativeHandle:function(_,g,A){return A=A!=null?A.concat([_]):null,gi(4,36,Tl.bind(null,g,_),A)},useLayoutEffect:function(_,g){return gi(4,36,_,g)},useMemo:function(_,g){var A=Jn();return g=g===void 0?null:g,_=_(),A.memoizedState=[_,g],_},useReducer:function(_,g,A){var P=Jn();return g=A!==void 0?A(g):g,P.memoizedState=P.baseState=g,_=P.queue={last:null,dispatch:null,lastRenderedReducer:_,lastRenderedState:g},_=_.dispatch=js.bind(null,rn,_),[P.memoizedState,_]},useRef:function(_){var g=Jn();return _={current:_},g.memoizedState=_},useState:T0,useDebugValue:vf,useResponder:xt,useDeferredValue:function(_,g){var A=T0(_),P=A[0],B=A[1];return rl(function(){E.unstable_next(function(){var Z=bt.suspense;bt.suspense=g===void 0?null:g;try{B(_)}finally{bt.suspense=Z}})},[_,g]),P},useTransition:function(_){var g=T0(!1),A=g[0],P=g[1];return[Io(function(B){P(!0),E.unstable_next(function(){var Z=bt.suspense;bt.suspense=_===void 0?null:_;try{P(!1),B()}finally{bt.suspense=Z}})},[_,A]),A]}},gs={readContext:Mu,useCallback:ys,useContext:Mu,useEffect:hf,useImperativeHandle:function(_,g,A){return A=A!=null?A.concat([_]):null,Po(4,36,Tl.bind(null,g,_),A)},useLayoutEffect:function(_,g){return Po(4,36,_,g)},useMemo:function(_,g){var A=wr();g=g===void 0?null:g;var P=A.memoizedState;return P!==null&&g!==null&&It(g,P[1])?P[0]:(_=_(),A.memoizedState=[_,g],_)},useReducer:ku,useRef:function(){return wr().memoizedState},useState:Z0,useDebugValue:vf,useResponder:xt,useDeferredValue:function(_,g){var A=Z0(_),P=A[0],B=A[1];return hf(function(){E.unstable_next(function(){var Z=bt.suspense;bt.suspense=g===void 0?null:g;try{B(_)}finally{bt.suspense=Z}})},[_,g]),P},useTransition:function(_){var g=Z0(!1),A=g[0],P=g[1];return[ys(function(B){P(!0),E.unstable_next(function(){var Z=bt.suspense;bt.suspense=_===void 0?null:_;try{P(!1),B()}finally{bt.suspense=Z}})},[_,A]),A]}},Xu=null,Su=null,_i=!1;function C0(_,g){var A=Ho(5,null,null,0);A.elementType="DELETED",A.type="DELETED",A.stateNode=g,A.return=_,A.effectTag=8,_.lastEffect!==null?(_.lastEffect.nextEffect=A,_.lastEffect=A):_.firstEffect=_.lastEffect=A}function $0(_,g){switch(_.tag){case 5:return g=Bu(g,_.type,_.pendingProps),g!==null?(_.stateNode=g,!0):!1;case 6:return g=K0(g,_.pendingProps),g!==null?(_.stateNode=g,!0):!1;case 13:return!1;default:return!1}}function Uo(_){if(_i){var g=Su;if(g){var A=g;if(!$0(_,g)){if(g=Mo(A),!g||!$0(_,g)){_.effectTag=_.effectTag&-1025|2,_i=!1,Xu=_;return}C0(Xu,A)}Xu=_,Su=F0(g)}else _.effectTag=_.effectTag&-1025|2,_i=!1,Xu=_}}function la(_){for(_=_.return;_!==null&&_.tag!==5&&_.tag!==3&&_.tag!==13;)_=_.return;Xu=_}function $l(_){if(!S||_!==Xu)return!1;if(!_i)return la(_),_i=!0,!1;var g=_.type;if(_.tag!==5||g!=="head"&&g!=="body"&&!dt(g,_.memoizedProps))for(g=Su;g;)C0(_,g),g=Mo(g);if(la(_),_.tag===13){if(!S)throw Error(t(316));if(_=_.memoizedState,_=_!==null?_.dehydrated:null,!_)throw Error(t(317));Su=Ps(_)}else Su=Xu?Mo(_.stateNode):null;return!0}function tu(){S&&(Su=Xu=null,_i=!1)}var Zr=N.ReactCurrentOwner,ho=!1;function Bi(_,g,A,P){g.child=_===null?Y(g,null,A,P):H(g,_.child,A,P)}function Ci(_,g,A,P,B){A=A.render;var Z=g.ref;return Fo(g,B),P=un(_,g,A,P,Z,B),_!==null&&!ho?(g.updateQueue=_.updateQueue,g.effectTag&=-517,_.expirationTime<=B&&(_.expirationTime=0),mu(_,g,B)):(g.effectTag|=1,Bi(_,g,P,B),g.child)}function mf(_,g,A,P,B,Z){if(_===null){var de=A.type;return typeof de=="function"&&!Ef(de)&&de.defaultProps===void 0&&A.compare===null&&A.defaultProps===void 0?(g.tag=15,g.type=de,yf(_,g,de,P,B,Z)):(_=qa(A.type,null,P,null,g.mode,Z),_.ref=g.ref,_.return=g,g.child=_)}return de=_.child,B<Z&&(B=de.memoizedProps,A=A.compare,A=A!==null?A:pt,A(B,P)&&_.ref===g.ref)?mu(_,g,Z):(g.effectTag|=1,_=Vu(de,P,Z),_.ref=g.ref,_.return=g,g.child=_)}function yf(_,g,A,P,B,Z){return _!==null&&pt(_.memoizedProps,P)&&_.ref===g.ref&&(ho=!1,B<Z)?mu(_,g,Z):to(_,g,A,P,Z)}function eo(_,g){var A=g.ref;(_===null&&A!==null||_!==null&&_.ref!==A)&&(g.effectTag|=128)}function to(_,g,A,P,B){var Z=eu(A)?Wt:Ai.current;return Z=Ru(g,Z),Fo(g,B),A=un(_,g,A,P,Z,B),_!==null&&!ho?(g.updateQueue=_.updateQueue,g.effectTag&=-517,_.expirationTime<=B&&(_.expirationTime=0),mu(_,g,B)):(g.effectTag|=1,Bi(_,g,A,B),g.child)}function xe(_,g,A,P,B){if(eu(A)){var Z=!0;li(g)}else Z=!1;if(Fo(g,B),g.stateNode===null)_!==null&&(_.alternate=null,g.alternate=null,g.effectTag|=2),bs(g,A,P,B),Bs(g,A,P,B),P=!0;else if(_===null){var de=g.stateNode,yt=g.memoizedProps;de.props=yt;var Rt=de.context,Nt=A.contextType;typeof Nt=="object"&&Nt!==null?Nt=Mu(Nt):(Nt=eu(A)?Wt:Ai.current,Nt=Ru(g,Nt));var xr=A.getDerivedStateFromProps,r0=typeof xr=="function"||typeof de.getSnapshotBeforeUpdate=="function";r0||typeof de.UNSAFE_componentWillReceiveProps!="function"&&typeof de.componentWillReceiveProps!="function"||(yt!==P||Rt!==Nt)&&ba(g,de,P,Nt),po=!1;var cu=g.memoizedState;Rt=de.state=cu;var z0=g.updateQueue;z0!==null&&(S0(g,z0,P,de,B),Rt=g.memoizedState),yt!==P||cu!==Rt||yi.current||po?(typeof xr=="function"&&(Zl(g,A,xr,P),Rt=g.memoizedState),(yt=po||pf(g,A,yt,P,cu,Rt,Nt))?(r0||typeof de.UNSAFE_componentWillMount!="function"&&typeof de.componentWillMount!="function"||(typeof de.componentWillMount=="function"&&de.componentWillMount(),typeof de.UNSAFE_componentWillMount=="function"&&de.UNSAFE_componentWillMount()),typeof de.componentDidMount=="function"&&(g.effectTag|=4)):(typeof de.componentDidMount=="function"&&(g.effectTag|=4),g.memoizedProps=P,g.memoizedState=Rt),de.props=P,de.state=Rt,de.context=Nt,P=yt):(typeof de.componentDidMount=="function"&&(g.effectTag|=4),P=!1)}else de=g.stateNode,yt=g.memoizedProps,de.props=g.type===g.elementType?yt:Yn(g.type,yt),Rt=de.context,Nt=A.contextType,typeof Nt=="object"&&Nt!==null?Nt=Mu(Nt):(Nt=eu(A)?Wt:Ai.current,Nt=Ru(g,Nt)),xr=A.getDerivedStateFromProps,(r0=typeof xr=="function"||typeof de.getSnapshotBeforeUpdate=="function")||typeof de.UNSAFE_componentWillReceiveProps!="function"&&typeof de.componentWillReceiveProps!="function"||(yt!==P||Rt!==Nt)&&ba(g,de,P,Nt),po=!1,Rt=g.memoizedState,cu=de.state=Rt,z0=g.updateQueue,z0!==null&&(S0(g,z0,P,de,B),cu=g.memoizedState),yt!==P||Rt!==cu||yi.current||po?(typeof xr=="function"&&(Zl(g,A,xr,P),cu=g.memoizedState),(xr=po||pf(g,A,yt,P,Rt,cu,Nt))?(r0||typeof de.UNSAFE_componentWillUpdate!="function"&&typeof de.componentWillUpdate!="function"||(typeof de.componentWillUpdate=="function"&&de.componentWillUpdate(P,cu,Nt),typeof de.UNSAFE_componentWillUpdate=="function"&&de.UNSAFE_componentWillUpdate(P,cu,Nt)),typeof de.componentDidUpdate=="function"&&(g.effectTag|=4),typeof de.getSnapshotBeforeUpdate=="function"&&(g.effectTag|=256)):(typeof de.componentDidUpdate!="function"||yt===_.memoizedProps&&Rt===_.memoizedState||(g.effectTag|=4),typeof de.getSnapshotBeforeUpdate!="function"||yt===_.memoizedProps&&Rt===_.memoizedState||(g.effectTag|=256),g.memoizedProps=P,g.memoizedState=cu),de.props=P,de.state=cu,de.context=Nt,P=xr):(typeof de.componentDidUpdate!="function"||yt===_.memoizedProps&&Rt===_.memoizedState||(g.effectTag|=4),typeof de.getSnapshotBeforeUpdate!="function"||yt===_.memoizedProps&&Rt===_.memoizedState||(g.effectTag|=256),P=!1);return tt(_,g,A,P,Z,B)}function tt(_,g,A,P,B,Z){eo(_,g);var de=(g.effectTag&64)!==0;if(!P&&!de)return B&&ao(g,A,!1),mu(_,g,Z);P=g.stateNode,Zr.current=g;var yt=de&&typeof A.getDerivedStateFromError!="function"?null:P.render();return g.effectTag|=1,_!==null&&de?(g.child=H(g,_.child,null,Z),g.child=H(g,null,yt,Z)):Bi(_,g,yt,Z),g.memoizedState=P.state,B&&ao(g,A,!0),g.child}function Ke(_){var g=_.stateNode;g.pendingContext?Xl(_,g.pendingContext,g.pendingContext!==g.context):g.context&&Xl(_,g.context,!1),Ne(_,g.containerInfo)}var Yt={dehydrated:null,retryTime:0};function Kt(_,g,A){var P=g.mode,B=g.pendingProps,Z=qe.current,de=!1,yt;if((yt=(g.effectTag&64)!==0)||(yt=(Z&2)!==0&&(_===null||_.memoizedState!==null)),yt?(de=!0,g.effectTag&=-65):_!==null&&_.memoizedState===null||B.fallback===void 0||B.unstable_avoidThisFallback===!0||(Z|=1),en(qe,Z&1,g),_===null){if(B.fallback!==void 0&&Uo(g),de){if(de=B.fallback,B=n0(null,P,0,null),B.return=g,(g.mode&2)===0)for(_=g.memoizedState!==null?g.child.child:g.child,B.child=_;_!==null;)_.return=B,_=_.sibling;return A=n0(de,P,A,null),A.return=g,B.sibling=A,g.memoizedState=Yt,g.child=B,A}return P=B.children,g.memoizedState=null,g.child=Y(g,null,P,A)}if(_.memoizedState!==null){if(_=_.child,P=_.sibling,de){if(B=B.fallback,A=Vu(_,_.pendingProps,0),A.return=g,(g.mode&2)===0&&(de=g.memoizedState!==null?g.child.child:g.child,de!==_.child))for(A.child=de;de!==null;)de.return=A,de=de.sibling;return P=Vu(P,B,P.expirationTime),P.return=g,A.sibling=P,A.childExpirationTime=0,g.memoizedState=Yt,g.child=A,P}return A=H(g,_.child,B.children,A),g.memoizedState=null,g.child=A}if(_=_.child,de){if(de=B.fallback,B=n0(null,P,0,null),B.return=g,B.child=_,_!==null&&(_.return=B),(g.mode&2)===0)for(_=g.memoizedState!==null?g.child.child:g.child,B.child=_;_!==null;)_.return=B,_=_.sibling;return A=n0(de,P,A,null),A.return=g,B.sibling=A,A.effectTag|=2,B.childExpirationTime=0,g.memoizedState=Yt,g.child=B,A}return g.memoizedState=null,g.child=H(g,_,B.children,A)}function pr(_,g){_.expirationTime<g&&(_.expirationTime=g);var A=_.alternate;A!==null&&A.expirationTime<g&&(A.expirationTime=g),Ti(_.return,g)}function Ei(_,g,A,P,B,Z){var de=_.memoizedState;de===null?_.memoizedState={isBackwards:g,rendering:null,last:P,tail:A,tailExpiration:0,tailMode:B,lastEffect:Z}:(de.isBackwards=g,de.rendering=null,de.last=P,de.tail=A,de.tailExpiration=0,de.tailMode=B,de.lastEffect=Z)}function bn(_,g,A){var P=g.pendingProps,B=P.revealOrder,Z=P.tail;if(Bi(_,g,P.children,A),P=qe.current,(P&2)!==0)P=P&1|2,g.effectTag|=64;else{if(_!==null&&(_.effectTag&64)!==0)e:for(_=g.child;_!==null;){if(_.tag===13)_.memoizedState!==null&&pr(_,A);else if(_.tag===19)pr(_,A);else if(_.child!==null){_.child.return=_,_=_.child;continue}if(_===g)break e;for(;_.sibling===null;){if(_.return===null||_.return===g)break e;_=_.return}_.sibling.return=_.return,_=_.sibling}P&=1}if(en(qe,P,g),(g.mode&2)===0)g.memoizedState=null;else switch(B){case"forwards":for(A=g.child,B=null;A!==null;)_=A.alternate,_!==null&&rt(_)===null&&(B=A),A=A.sibling;A=B,A===null?(B=g.child,g.child=null):(B=A.sibling,A.sibling=null),Ei(g,!1,B,A,Z,g.lastEffect);break;case"backwards":for(A=null,B=g.child,g.child=null;B!==null;){if(_=B.alternate,_!==null&&rt(_)===null){g.child=B;break}_=B.sibling,B.sibling=A,A=B,B=_}Ei(g,!0,A,null,Z,g.lastEffect);break;case"together":Ei(g,!1,null,null,void 0,g.lastEffect);break;default:g.memoizedState=null}return g.child}function mu(_,g,A){_!==null&&(g.dependencies=_.dependencies);var P=g.expirationTime;if(P!==0&&Ua(P),g.childExpirationTime<A)return null;if(_!==null&&g.child!==_.child)throw Error(t(153));if(g.child!==null){for(_=g.child,A=Vu(_,_.pendingProps,_.expirationTime),g.child=A,A.return=g;_.sibling!==null;)_=_.sibling,A=A.sibling=Vu(_,_.pendingProps,_.expirationTime),A.return=g;A.sibling=null}return g.child}function Qu(_){_.effectTag|=4}var $r,Qr,qu,xn;if(Vt)$r=function(_,g){for(var A=g.child;A!==null;){if(A.tag===5||A.tag===6)Re(_,A.stateNode);else if(A.tag!==4&&A.child!==null){A.child.return=A,A=A.child;continue}if(A===g)break;for(;A.sibling===null;){if(A.return===null||A.return===g)return;A=A.return}A.sibling.return=A.return,A=A.sibling}},Qr=function(){},qu=function(_,g,A,P,B){if(_=_.memoizedProps,_!==P){var Z=g.stateNode,de=$(Ce.current);A=He(Z,A,_,P,B,de),(g.updateQueue=A)&&Qu(g)}},xn=function(_,g,A,P){A!==P&&Qu(g)};else if(Er){$r=function(_,g,A,P){for(var B=g.child;B!==null;){if(B.tag===5){var Z=B.stateNode;A&&P&&(Z=el(Z,B.type,B.memoizedProps,B)),Re(_,Z)}else if(B.tag===6)Z=B.stateNode,A&&P&&(Z=Y0(Z,B.memoizedProps,B)),Re(_,Z);else if(B.tag!==4){if(B.tag===13&&(B.effectTag&4)!==0&&(Z=B.memoizedState!==null)){var de=B.child;if(de!==null&&(de.child!==null&&(de.child.return=de,$r(_,de,!0,Z)),Z=de.sibling,Z!==null)){Z.return=B,B=Z;continue}}if(B.child!==null){B.child.return=B,B=B.child;continue}}if(B===g)break;for(;B.sibling===null;){if(B.return===null||B.return===g)return;B=B.return}B.sibling.return=B.return,B=B.sibling}};var x0=function(_,g,A,P){for(var B=g.child;B!==null;){if(B.tag===5){var Z=B.stateNode;A&&P&&(Z=el(Z,B.type,B.memoizedProps,B)),lu(_,Z)}else if(B.tag===6)Z=B.stateNode,A&&P&&(Z=Y0(Z,B.memoizedProps,B)),lu(_,Z);else if(B.tag!==4){if(B.tag===13&&(B.effectTag&4)!==0&&(Z=B.memoizedState!==null)){var de=B.child;if(de!==null&&(de.child!==null&&(de.child.return=de,x0(_,de,!0,Z)),Z=de.sibling,Z!==null)){Z.return=B,B=Z;continue}}if(B.child!==null){B.child.return=B,B=B.child;continue}}if(B===g)break;for(;B.sibling===null;){if(B.return===null||B.return===g)return;B=B.return}B.sibling.return=B.return,B=B.sibling}};Qr=function(_){var g=_.stateNode;if(_.firstEffect!==null){var A=g.containerInfo,P=xi(A);x0(P,_,!1,!1),g.pendingChildren=P,Qu(_),vi(A,P)}},qu=function(_,g,A,P,B){var Z=_.stateNode,de=_.memoizedProps;if((_=g.firstEffect===null)&&de===P)g.stateNode=Z;else{var yt=g.stateNode,Rt=$(Ce.current),Nt=null;de!==P&&(Nt=He(yt,A,de,P,B,Rt)),_&&Nt===null?g.stateNode=Z:(Z=qt(Z,Nt,A,de,P,g,_,yt),le(Z,A,P,B,Rt)&&Qu(g),g.stateNode=Z,_?Qu(g):$r(Z,g,!1,!1))}},xn=function(_,g,A,P){A!==P&&(_=$(Oe.current),A=$(Ce.current),g.stateNode=nn(P,_,A,g),Qu(g))}}else Qr=function(){},qu=function(){},xn=function(){};function Lu(_,g){switch(_.tailMode){case"hidden":g=_.tail;for(var A=null;g!==null;)g.alternate!==null&&(A=g),g=g.sibling;A===null?_.tail=null:A.sibling=null;break;case"collapsed":A=_.tail;for(var P=null;A!==null;)A.alternate!==null&&(P=A),A=A.sibling;P===null?g||_.tail===null?_.tail=null:_.tail.sibling=null:P.sibling=null}}function ui(_){switch(_.tag){case 1:eu(_.type)&&Q0(_);var g=_.effectTag;return g&4096?(_.effectTag=g&-4097|64,_):null;case 3:if(Je(_),Yi(_),g=_.effectTag,(g&64)!==0)throw Error(t(285));return _.effectTag=g&-4097|64,_;case 5:return oe(_),null;case 13:return mi(qe,_),g=_.effectTag,g&4096?(_.effectTag=g&-4097|64,_):null;case 19:return mi(qe,_),null;case 4:return Je(_),null;case 10:return wu(_),null;default:return null}}function Cl(_,g){return{value:_,source:g,stack:Hr(g)}}var zs=typeof WeakSet=="function"?WeakSet:Set;function Wu(_,g){var A=g.source,P=g.stack;P===null&&A!==null&&(P=Hr(A)),A!==null&&ze(A.type),g=g.value,_!==null&&_.tag===1&&ze(_.type);try{console.error(g)}catch(B){setTimeout(function(){throw B})}}function sa(_,g){try{g.props=_.memoizedProps,g.state=_.memoizedState,g.componentWillUnmount()}catch(A){zo(_,A)}}function Xi(_){var g=_.ref;if(g!==null)if(typeof g=="function")try{g(null)}catch(A){zo(_,A)}else g.current=null}function Hs(_,g){switch(g.tag){case 0:case 11:case 15:R0(2,0,g);break;case 1:if(g.effectTag&256&&_!==null){var A=_.memoizedProps,P=_.memoizedState;_=g.stateNode,g=_.getSnapshotBeforeUpdate(g.elementType===g.type?A:Yn(g.type,A),P),_.__reactInternalSnapshotBeforeUpdate=g}break;case 3:case 5:case 6:case 4:case 17:break;default:throw Error(t(163))}}function R0(_,g,A){if(A=A.updateQueue,A=A!==null?A.lastEffect:null,A!==null){var P=A=A.next;do{if((P.tag&_)!==0){var B=P.destroy;P.destroy=void 0,B!==void 0&&B()}(P.tag&g)!==0&&(B=P.create,P.destroy=B()),P=P.next}while(P!==A)}}function Hi(_,g,A){switch(typeof ws=="function"&&ws(g),g.tag){case 0:case 11:case 14:case 15:if(_=g.updateQueue,_!==null&&(_=_.lastEffect,_!==null)){var P=_.next;co(97<A?97:A,function(){var B=P;do{var Z=B.destroy;if(Z!==void 0){var de=g;try{Z()}catch(yt){zo(de,yt)}}B=B.next}while(B!==P)})}break;case 1:Xi(g),A=g.stateNode,typeof A.componentWillUnmount=="function"&&sa(g,A);break;case 5:Xi(g);break;case 4:Vt?O0(_,g,A):Er&&il(g)}}function A0(_,g,A){for(var P=g;;)if(Hi(_,P,A),P.child===null||Vt&&P.tag===4){if(P===g)break;for(;P.sibling===null;){if(P.return===null||P.return===g)return;P=P.return}P.sibling.return=P.return,P=P.sibling}else P.child.return=P,P=P.child}function qi(_){var g=_.alternate;_.return=null,_.child=null,_.memoizedState=null,_.updateQueue=null,_.dependencies=null,_.alternate=null,_.firstEffect=null,_.lastEffect=null,_.pendingProps=null,_.memoizedProps=null,g!==null&&qi(g)}function il(_){if(Er){_=_.stateNode.containerInfo;var g=xi(_);Dr(_,g)}}function xl(_){return _.tag===5||_.tag===3||_.tag===4}function B0(_){if(Vt){e:{for(var g=_.return;g!==null;){if(xl(g)){var A=g;break e}g=g.return}throw Error(t(160))}switch(g=A.stateNode,A.tag){case 5:var P=!1;break;case 3:g=g.containerInfo,P=!0;break;case 4:g=g.containerInfo,P=!0;break;default:throw Error(t(161))}A.effectTag&16&&(Ao(g),A.effectTag&=-17);e:t:for(A=_;;){for(;A.sibling===null;){if(A.return===null||xl(A.return)){A=null;break e}A=A.return}for(A.sibling.return=A.return,A=A.sibling;A.tag!==5&&A.tag!==6&&A.tag!==18;){if(A.effectTag&2||A.child===null||A.tag===4)continue t;A.child.return=A,A=A.child}if(!(A.effectTag&2)){A=A.stateNode;break e}}for(var B=_;;){var Z=B.tag===5||B.tag===6;if(Z)Z=Z?B.stateNode:B.stateNode.instance,A?P?Xt(g,Z,A):zr(g,Z,A):P?Xn(g,Z):zt(g,Z);else if(B.tag!==4&&B.child!==null){B.child.return=B,B=B.child;continue}if(B===_)break;for(;B.sibling===null;){if(B.return===null||B.return===_)return;B=B.return}B.sibling.return=B.return,B=B.sibling}}}function O0(_,g,A){for(var P=g,B=!1,Z,de;;){if(!B){B=P.return;e:for(;;){if(B===null)throw Error(t(160));switch(Z=B.stateNode,B.tag){case 5:de=!1;break e;case 3:Z=Z.containerInfo,de=!0;break e;case 4:Z=Z.containerInfo,de=!0;break e}B=B.return}B=!0}if(P.tag===5||P.tag===6)A0(_,P,A),de?c0(Z,P.stateNode):Du(Z,P.stateNode);else if(P.tag===4){if(P.child!==null){Z=P.stateNode.containerInfo,de=!0,P.child.return=P,P=P.child;continue}}else if(Hi(_,P,A),P.child!==null){P.child.return=P,P=P.child;continue}if(P===g)break;for(;P.sibling===null;){if(P.return===null||P.return===g)return;P=P.return,P.tag===4&&(B=!1)}P.sibling.return=P.return,P=P.sibling}}function vo(_,g){if(Vt)switch(g.tag){case 0:case 11:case 14:case 15:R0(4,8,g);break;case 1:break;case 5:var A=g.stateNode;if(A!=null){var P=g.memoizedProps;_=_!==null?_.memoizedProps:P;var B=g.type,Z=g.updateQueue;g.updateQueue=null,Z!==null&&fr(A,Z,B,_,P,g)}break;case 6:if(g.stateNode===null)throw Error(t(162));A=g.memoizedProps,vr(g.stateNode,_!==null?_.memoizedProps:A,A);break;case 3:S&&(g=g.stateNode,g.hydrate&&(g.hydrate=!1,Kl(g.containerInfo)));break;case 12:break;case 13:Fu(g),Ju(g);break;case 19:Ju(g);break;case 17:break;case 20:break;case 21:break;default:throw Error(t(163))}else{switch(g.tag){case 0:case 11:case 14:case 15:R0(4,8,g);return;case 12:return;case 13:Fu(g),Ju(g);return;case 19:Ju(g);return;case 3:S&&(A=g.stateNode,A.hydrate&&(A.hydrate=!1,Kl(A.containerInfo)))}e:if(Er)switch(g.tag){case 1:case 5:case 6:case 20:break e;case 3:case 4:g=g.stateNode,Dr(g.containerInfo,g.pendingChildren);break e;default:throw Error(t(163))}}}function Fu(_){var g=_;if(_.memoizedState===null)var A=!1;else A=!0,g=_.child,Tn=h0();if(Vt&&g!==null){e:if(_=g,Vt)for(g=_;;){if(g.tag===5){var P=g.stateNode;A?Jo(P):Zo(g.stateNode,g.memoizedProps)}else if(g.tag===6)P=g.stateNode,A?Fs(P):$o(P,g.memoizedProps);else if(g.tag===13&&g.memoizedState!==null&&g.memoizedState.dehydrated===null){P=g.child.sibling,P.return=g,g=P;continue}else if(g.child!==null){g.child.return=g,g=g.child;continue}if(g===_)break e;for(;g.sibling===null;){if(g.return===null||g.return===_)break e;g=g.return}g.sibling.return=g.return,g=g.sibling}}}function Ju(_){var g=_.updateQueue;if(g!==null){_.updateQueue=null;var A=_.stateNode;A===null&&(A=_.stateNode=new zs),g.forEach(function(P){var B=za.bind(null,_,P);A.has(P)||(A.add(P),P.then(B,B))})}}var es=typeof WeakMap=="function"?WeakMap:Map;function _s(_,g,A){A=v0(A,null),A.tag=3,A.payload={element:null};var P=g.value;return A.callback=function(){Fi||(Fi=!0,Ar=P),Wu(_,g)},A}function aa(_,g,A){A=v0(A,null),A.tag=3;var P=_.type.getDerivedStateFromError;if(typeof P=="function"){var B=g.value;A.payload=function(){return Wu(_,g),P(B)}}var Z=_.stateNode;return Z!==null&&typeof Z.componentDidCatch=="function"&&(A.callback=function(){typeof P!="function"&&(mr===null?mr=new Set([this]):mr.add(this),Wu(_,g));var de=g.stack;this.componentDidCatch(g.value,{componentStack:de!==null?de:""})}),A}var gf=Math.ceil,Zu=N.ReactCurrentDispatcher,Es=N.ReactCurrentOwner,Rr=0,no=8,nu=16,fu=32,Li=0,ei=1,Kn=2,$u=3,g0=4,_0=5,Ln=Rr,fe=null,ie=null,Pe=0,Me=Li,at=null,mt=1073741823,Qt=1073741823,An=null,Sn=0,_n=!1,Tn=0,ir=500,Ut=null,Fi=!1,Ar=null,mr=null,K=!1,ti=null,ni=90,Wr=null,ft=0,Di=null,ru=0;function E0(){return(Ln&(nu|fu))!==Rr?1073741821-(h0()/10|0):ru!==0?ru:ru=1073741821-(h0()/10|0)}function Un(_,g,A){if(g=g.mode,(g&2)===0)return 1073741823;var P=hs();if((g&4)===0)return P===99?1073741823:1073741822;if((Ln&nu)!==Rr)return Pe;if(A!==null)_=Q(_,A.timeoutMs|0||5e3,250);else switch(P){case 99:_=1073741823;break;case 98:_=Q(_,150,100);break;case 97:case 96:_=Q(_,5e3,250);break;case 95:_=2;break;default:throw Error(t(326))}return fe!==null&&_===Pe&&--_,_}function e0(_,g){if(50<ft)throw ft=0,Di=null,Error(t(185));if(_=ro(_,g),_!==null){var A=hs();g===1073741823?(Ln&no)!==Rr&&(Ln&(nu|fu))===Rr?io(_):(t0(_),Ln===Rr&&Uu()):t0(_),(Ln&4)===Rr||A!==98&&A!==99||(Wr===null?Wr=new Map([[_,g]]):(A=Wr.get(_),(A===void 0||A>g)&&Wr.set(_,g)))}}function ro(_,g){_.expirationTime<g&&(_.expirationTime=g);var A=_.alternate;A!==null&&A.expirationTime<g&&(A.expirationTime=g);var P=_.return,B=null;if(P===null&&_.tag===3)B=_.stateNode;else for(;P!==null;){if(A=P.alternate,P.childExpirationTime<g&&(P.childExpirationTime=g),A!==null&&A.childExpirationTime<g&&(A.childExpirationTime=g),P.return===null&&P.tag===3){B=P.stateNode;break}P=P.return}return B!==null&&(fe===B&&(Ua(g),Me===g0&&Ol(B,Pe)),Ts(B,g)),B}function mo(_){var g=_.lastExpiredTime;return g!==0||(g=_.firstPendingTime,!dc(_,g))?g:(g=_.lastPingedTime,_=_.nextKnownPendingLevel,g>_?g:_)}function t0(_){if(_.lastExpiredTime!==0)_.callbackExpirationTime=1073741823,_.callbackPriority=99,_.callbackNode=Jl(io.bind(null,_));else{var g=mo(_),A=_.callbackNode;if(g===0)A!==null&&(_.callbackNode=null,_.callbackExpirationTime=0,_.callbackPriority=90);else{var P=E0();if(g===1073741823?P=99:g===1||g===2?P=95:(P=10*(1073741821-g)-10*(1073741821-P),P=0>=P?99:250>=P?98:5250>=P?97:95),A!==null){var B=_.callbackPriority;if(_.callbackExpirationTime===g&&B>=P)return;A!==qr&&Is(A)}_.callbackExpirationTime=g,_.callbackPriority=P,g=g===1073741823?Jl(io.bind(null,_)):nl(P,jo.bind(null,_),{timeout:10*(1073741821-g)-h0()}),_.callbackNode=g}}}function jo(_,g){if(ru=0,g)return g=E0(),da(_,g),t0(_),null;var A=mo(_);if(A!==0){if(g=_.callbackNode,(Ln&(nu|fu))!==Rr)throw Error(t(327));if(qs(),_===fe&&A===Pe||Ds(_,A),ie!==null){var P=Ln;Ln|=nu;var B=U0(_);do try{nd();break}catch(yt){fa(_,yt)}while(1);if(ju(),Ln=P,Zu.current=B,Me===ei)throw g=at,Ds(_,A),Ol(_,A),t0(_),g;if(ie===null)switch(B=_.finishedWork=_.current.alternate,_.finishedExpirationTime=A,P=Me,fe=null,P){case Li:case ei:throw Error(t(345));case Kn:da(_,2<A?2:A);break;case $u:if(Ol(_,A),P=_.lastSuspendedTime,A===P&&(_.nextKnownPendingLevel=qc(B)),mt===1073741823&&(B=Tn+ir-h0(),10<B)){if(_n){var Z=_.lastPingedTime;if(Z===0||Z>=A){_.lastPingedTime=A,Ds(_,A);break}}if(Z=mo(_),Z!==0&&Z!==A)break;if(P!==0&&P!==A){_.lastPingedTime=P;break}_.timeoutHandle=an(Rl.bind(null,_),B);break}Rl(_);break;case g0:if(Ol(_,A),P=_.lastSuspendedTime,A===P&&(_.nextKnownPendingLevel=qc(B)),_n&&(B=_.lastPingedTime,B===0||B>=A)){_.lastPingedTime=A,Ds(_,A);break}if(B=mo(_),B!==0&&B!==A)break;if(P!==0&&P!==A){_.lastPingedTime=P;break}if(Qt!==1073741823?P=10*(1073741821-Qt)-h0():mt===1073741823?P=0:(P=10*(1073741821-mt)-5e3,B=h0(),A=10*(1073741821-A)-B,P=B-P,0>P&&(P=0),P=(120>P?120:480>P?480:1080>P?1080:1920>P?1920:3e3>P?3e3:4320>P?4320:1960*gf(P/1960))-P,A<P&&(P=A)),10<P){_.timeoutHandle=an(Rl.bind(null,_),P);break}Rl(_);break;case _0:if(mt!==1073741823&&An!==null){Z=mt;var de=An;if(P=de.busyMinDurationMs|0,0>=P?P=0:(B=de.busyDelayMs|0,Z=h0()-(10*(1073741821-Z)-(de.timeoutMs|0||5e3)),P=Z<=B?0:B+P-Z),10<P){Ol(_,A),_.timeoutHandle=an(Rl.bind(null,_),P);break}}Rl(_);break;default:throw Error(t(329))}if(t0(_),_.callbackNode===g)return jo.bind(null,_)}}return null}function io(_){var g=_.lastExpiredTime;if(g=g!==0?g:1073741823,_.finishedExpirationTime===g)Rl(_);else{if((Ln&(nu|fu))!==Rr)throw Error(t(327));if(qs(),_===fe&&g===Pe||Ds(_,g),ie!==null){var A=Ln;Ln|=nu;var P=U0(_);do try{_2();break}catch(B){fa(_,B)}while(1);if(ju(),Ln=A,Zu.current=P,Me===ei)throw A=at,Ds(_,g),Ol(_,g),t0(_),A;if(ie!==null)throw Error(t(261));_.finishedWork=_.current.alternate,_.finishedExpirationTime=g,fe=null,Rl(_),t0(_)}}return null}function Ba(_,g){da(_,g),t0(_),(Ln&(nu|fu))===Rr&&Uu()}function _f(){if(Wr!==null){var _=Wr;Wr=null,_.forEach(function(g,A){da(A,g),t0(A)}),Uu()}}function fc(_,g){if((Ln&(nu|fu))!==Rr)throw Error(t(187));var A=Ln;Ln|=1;try{return co(99,_.bind(null,g))}finally{Ln=A,Uu()}}function Ds(_,g){_.finishedWork=null,_.finishedExpirationTime=0;var A=_.timeoutHandle;if(A!==lr&&(_.timeoutHandle=lr,On(A)),ie!==null)for(A=ie.return;A!==null;){var P=A;switch(P.tag){case 1:var B=P.type.childContextTypes;B!=null&&Q0(P);break;case 3:Je(P),Yi(P);break;case 5:oe(P);break;case 4:Je(P);break;case 13:mi(qe,P);break;case 19:mi(qe,P);break;case 10:wu(P)}A=A.return}fe=_,ie=Vu(_.current,null,g),Pe=g,Me=Li,at=null,Qt=mt=1073741823,An=null,Sn=0,_n=!1}function fa(_,g){do{try{if(ju(),fn(),ie===null||ie.return===null)return Me=ei,at=g,null;e:{var A=_,P=ie.return,B=ie,Z=g;if(g=Pe,B.effectTag|=2048,B.firstEffect=B.lastEffect=null,Z!==null&&typeof Z=="object"&&typeof Z.then=="function"){var de=Z,yt=(qe.current&1)!==0,Rt=P;do{var Nt;if(Nt=Rt.tag===13){var xr=Rt.memoizedState;if(xr!==null)Nt=xr.dehydrated!==null;else{var r0=Rt.memoizedProps;Nt=r0.fallback===void 0?!1:r0.unstable_avoidThisFallback!==!0?!0:!yt}}if(Nt){var cu=Rt.updateQueue;if(cu===null){var z0=new Set;z0.add(de),Rt.updateQueue=z0}else cu.add(de);if((Rt.mode&2)===0){if(Rt.effectTag|=64,B.effectTag&=-2981,B.tag===1)if(B.alternate===null)B.tag=17;else{var Ml=v0(1073741823,null);Ml.tag=2,J0(B,Ml)}B.expirationTime=1073741823;break e}Z=void 0,B=g;var i0=A.pingCache;if(i0===null?(i0=A.pingCache=new es,Z=new Set,i0.set(de,Z)):(Z=i0.get(de),Z===void 0&&(Z=new Set,i0.set(de,Z))),!Z.has(B)){Z.add(B);var Ge=ja.bind(null,A,de,B);de.then(Ge,Ge)}Rt.effectTag|=4096,Rt.expirationTime=g;break e}Rt=Rt.return}while(Rt!==null);Z=Error((ze(B.type)||"A React component")+` suspended while rendering, but no fallback UI was specified.
+
+Add a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.`+Hr(B))}Me!==_0&&(Me=Kn),Z=Cl(Z,B),Rt=P;do{switch(Rt.tag){case 3:de=Z,Rt.effectTag|=4096,Rt.expirationTime=g;var je=_s(Rt,de,g);ua(Rt,je);break e;case 1:de=Z;var st=Rt.type,$t=Rt.stateNode;if((Rt.effectTag&64)===0&&(typeof st.getDerivedStateFromError=="function"||$t!==null&&typeof $t.componentDidCatch=="function"&&(mr===null||!mr.has($t)))){Rt.effectTag|=4096,Rt.expirationTime=g;var Wn=aa(Rt,de,g);ua(Rt,Wn);break e}}Rt=Rt.return}while(Rt!==null)}ie=yo(ie)}catch(oi){g=oi;continue}break}while(1)}function U0(){var _=Zu.current;return Zu.current=bo,_===null?bo:_}function cc(_,g){_<mt&&2<_&&(mt=_),g!==null&&_<Qt&&2<_&&(Qt=_,An=g)}function Ua(_){_>Sn&&(Sn=_)}function _2(){for(;ie!==null;)ie=rd(ie)}function nd(){for(;ie!==null&&!$n();)ie=rd(ie)}function rd(_){var g=Ha(_.alternate,_,Pe);return _.memoizedProps=_.pendingProps,g===null&&(g=yo(_)),Es.current=null,g}function yo(_){ie=_;do{var g=ie.alternate;if(_=ie.return,(ie.effectTag&2048)===0){e:{var A=g;g=ie;var P=Pe,B=g.pendingProps;switch(g.tag){case 2:break;case 16:break;case 15:case 0:break;case 1:eu(g.type)&&Q0(g);break;case 3:Je(g),Yi(g),B=g.stateNode,B.pendingContext&&(B.context=B.pendingContext,B.pendingContext=null),(A===null||A.child===null)&&$l(g)&&Qu(g),Qr(g);break;case 5:oe(g);var Z=$(Oe.current);if(P=g.type,A!==null&&g.stateNode!=null)qu(A,g,P,B,Z),A.ref!==g.ref&&(g.effectTag|=128);else if(B){if(A=$(Ce.current),$l(g)){if(B=g,!S)throw Error(t(175));A=su(B.stateNode,B.type,B.memoizedProps,Z,A,B),B.updateQueue=A,A=A!==null,A&&Qu(g)}else{var de=ce(P,B,Z,A,g);$r(de,g,!1,!1),g.stateNode=de,le(de,P,B,Z,A)&&Qu(g)}g.ref!==null&&(g.effectTag|=128)}else if(g.stateNode===null)throw Error(t(166));break;case 6:if(A&&g.stateNode!=null)xn(A,g,A.memoizedProps,B);else{if(typeof B!="string"&&g.stateNode===null)throw Error(t(166));if(A=$(Oe.current),Z=$(Ce.current),$l(g)){if(A=g,!S)throw Error(t(176));(A=ki(A.stateNode,A.memoizedProps,A))&&Qu(g)}else g.stateNode=nn(B,A,Z,g)}break;case 11:break;case 13:if(mi(qe,g),B=g.memoizedState,(g.effectTag&64)!==0){g.expirationTime=P;break e}B=B!==null,Z=!1,A===null?g.memoizedProps.fallback!==void 0&&$l(g):(P=A.memoizedState,Z=P!==null,B||P===null||(P=A.child.sibling,P!==null&&(de=g.firstEffect,de!==null?(g.firstEffect=P,P.nextEffect=de):(g.firstEffect=g.lastEffect=P,P.nextEffect=null),P.effectTag=8))),B&&!Z&&(g.mode&2)!==0&&(A===null&&g.memoizedProps.unstable_avoidThisFallback!==!0||(qe.current&1)!==0?Me===Li&&(Me=$u):((Me===Li||Me===$u)&&(Me=g0),Sn!==0&&fe!==null&&(Ol(fe,Pe),Ts(fe,Sn)))),Er&&B&&(g.effectTag|=4),Vt&&(B||Z)&&(g.effectTag|=4);break;case 7:break;case 8:break;case 12:break;case 4:Je(g),Qr(g);break;case 10:wu(g);break;case 9:break;case 14:break;case 17:eu(g.type)&&Q0(g);break;case 19:if(mi(qe,g),B=g.memoizedState,B===null)break;if(Z=(g.effectTag&64)!==0,de=B.rendering,de===null){if(Z)Lu(B,!1);else if(Me!==Li||A!==null&&(A.effectTag&64)!==0)for(A=g.child;A!==null;){if(de=rt(A),de!==null){for(g.effectTag|=64,Lu(B,!1),A=de.updateQueue,A!==null&&(g.updateQueue=A,g.effectTag|=4),B.lastEffect===null&&(g.firstEffect=null),g.lastEffect=B.lastEffect,A=P,B=g.child;B!==null;)Z=B,P=A,Z.effectTag&=2,Z.nextEffect=null,Z.firstEffect=null,Z.lastEffect=null,de=Z.alternate,de===null?(Z.childExpirationTime=0,Z.expirationTime=P,Z.child=null,Z.memoizedProps=null,Z.memoizedState=null,Z.updateQueue=null,Z.dependencies=null):(Z.childExpirationTime=de.childExpirationTime,Z.expirationTime=de.expirationTime,Z.child=de.child,Z.memoizedProps=de.memoizedProps,Z.memoizedState=de.memoizedState,Z.updateQueue=de.updateQueue,P=de.dependencies,Z.dependencies=P===null?null:{expirationTime:P.expirationTime,firstContext:P.firstContext,responders:P.responders}),B=B.sibling;en(qe,qe.current&1|2,g),g=g.child;break e}A=A.sibling}}else{if(!Z)if(A=rt(de),A!==null){if(g.effectTag|=64,Z=!0,A=A.updateQueue,A!==null&&(g.updateQueue=A,g.effectTag|=4),Lu(B,!0),B.tail===null&&B.tailMode==="hidden"&&!de.alternate){g=g.lastEffect=B.lastEffect,g!==null&&(g.nextEffect=null);break}}else h0()>B.tailExpiration&&1<P&&(g.effectTag|=64,Z=!0,Lu(B,!1),g.expirationTime=g.childExpirationTime=P-1);B.isBackwards?(de.sibling=g.child,g.child=de):(A=B.last,A!==null?A.sibling=de:g.child=de,B.last=de)}if(B.tail!==null){B.tailExpiration===0&&(B.tailExpiration=h0()+500),A=B.tail,B.rendering=A,B.tail=A.sibling,B.lastEffect=g.lastEffect,A.sibling=null,B=qe.current,B=Z?B&1|2:B&1,en(qe,B,g),g=A;break e}break;case 20:break;case 21:break;default:throw Error(t(156,g.tag))}g=null}if(A=ie,Pe===1||A.childExpirationTime!==1){for(B=0,Z=A.child;Z!==null;)P=Z.expirationTime,de=Z.childExpirationTime,P>B&&(B=P),de>B&&(B=de),Z=Z.sibling;A.childExpirationTime=B}if(g!==null)return g;_!==null&&(_.effectTag&2048)===0&&(_.firstEffect===null&&(_.firstEffect=ie.firstEffect),ie.lastEffect!==null&&(_.lastEffect!==null&&(_.lastEffect.nextEffect=ie.firstEffect),_.lastEffect=ie.lastEffect),1<ie.effectTag&&(_.lastEffect!==null?_.lastEffect.nextEffect=ie:_.firstEffect=ie,_.lastEffect=ie))}else{if(g=ui(ie,Pe),g!==null)return g.effectTag&=2047,g;_!==null&&(_.firstEffect=_.lastEffect=null,_.effectTag|=2048)}if(g=ie.sibling,g!==null)return g;ie=_}while(ie!==null);return Me===Li&&(Me=_0),null}function qc(_){var g=_.expirationTime;return _=_.childExpirationTime,g>_?g:_}function Rl(_){var g=hs();return co(99,ul.bind(null,_,g)),null}function ul(_,g){do qs();while(ti!==null);if((Ln&(nu|fu))!==Rr)throw Error(t(327));var A=_.finishedWork,P=_.finishedExpirationTime;if(A===null)return null;if(_.finishedWork=null,_.finishedExpirationTime=0,A===_.current)throw Error(t(177));_.callbackNode=null,_.callbackExpirationTime=0,_.callbackPriority=90,_.nextKnownPendingLevel=0;var B=qc(A);if(_.firstPendingTime=B,P<=_.lastSuspendedTime?_.firstSuspendedTime=_.lastSuspendedTime=_.nextKnownPendingLevel=0:P<=_.firstSuspendedTime&&(_.firstSuspendedTime=P-1),P<=_.lastPingedTime&&(_.lastPingedTime=0),P<=_.lastExpiredTime&&(_.lastExpiredTime=0),_===fe&&(ie=fe=null,Pe=0),1<A.effectTag?A.lastEffect!==null?(A.lastEffect.nextEffect=A,B=A.firstEffect):B=A:B=A.firstEffect,B!==null){var Z=Ln;Ln|=fu,Es.current=null,it(_.containerInfo),Ut=B;do try{E2()}catch(Tu){if(Ut===null)throw Error(t(330));zo(Ut,Tu),Ut=Ut.nextEffect}while(Ut!==null);Ut=B;do try{for(var de=_,yt=g;Ut!==null;){var Rt=Ut.effectTag;if(Rt&16&&Vt&&Ao(Ut.stateNode),Rt&128){var Nt=Ut.alternate;if(Nt!==null){var xr=Nt.ref;xr!==null&&(typeof xr=="function"?xr(null):xr.current=null)}}switch(Rt&1038){case 2:B0(Ut),Ut.effectTag&=-3;break;case 6:B0(Ut),Ut.effectTag&=-3,vo(Ut.alternate,Ut);break;case 1024:Ut.effectTag&=-1025;break;case 1028:Ut.effectTag&=-1025,vo(Ut.alternate,Ut);break;case 4:vo(Ut.alternate,Ut);break;case 8:var r0=de,cu=Ut,z0=yt;Vt?O0(r0,cu,z0):A0(r0,cu,z0),qi(cu)}Ut=Ut.nextEffect}}catch(Tu){if(Ut===null)throw Error(t(330));zo(Ut,Tu),Ut=Ut.nextEffect}while(Ut!==null);J(_.containerInfo),_.current=A,Ut=B;do try{for(Rt=P;Ut!==null;){var Ml=Ut.effectTag;if(Ml&36){var i0=Ut.alternate;switch(Nt=Ut,xr=Rt,Nt.tag){case 0:case 11:case 15:R0(16,32,Nt);break;case 1:var Ge=Nt.stateNode;if(Nt.effectTag&4)if(i0===null)Ge.componentDidMount();else{var je=Nt.elementType===Nt.type?i0.memoizedProps:Yn(Nt.type,i0.memoizedProps);Ge.componentDidUpdate(je,i0.memoizedState,Ge.__reactInternalSnapshotBeforeUpdate)}var st=Nt.updateQueue;st!==null&&Qn(Nt,st,Ge,xr);break;case 3:var $t=Nt.updateQueue;if($t!==null){if(de=null,Nt.child!==null)switch(Nt.child.tag){case 5:de=Ve(Nt.child.stateNode);break;case 1:de=Nt.child.stateNode}Qn(Nt,$t,de,xr)}break;case 5:var Wn=Nt.stateNode;i0===null&&Nt.effectTag&4&&jr(Wn,Nt.type,Nt.memoizedProps,Nt);break;case 6:break;case 4:break;case 12:break;case 13:if(S&&Nt.memoizedState===null){var oi=Nt.alternate;if(oi!==null){var ur=oi.memoizedState;if(ur!==null){var ai=ur.dehydrated;ai!==null&&P0(ai)}}}break;case 19:case 17:case 20:case 21:break;default:throw Error(t(163))}}if(Ml&128){Nt=void 0;var Qi=Ut.ref;if(Qi!==null){var Vr=Ut.stateNode;switch(Ut.tag){case 5:Nt=Ve(Vr);break;default:Nt=Vr}typeof Qi=="function"?Qi(Nt):Qi.current=Nt}}Ut=Ut.nextEffect}}catch(Tu){if(Ut===null)throw Error(t(330));zo(Ut,Tu),Ut=Ut.nextEffect}while(Ut!==null);Ut=null,Ki(),Ln=Z}else _.current=A;if(K)K=!1,ti=_,ni=g;else for(Ut=B;Ut!==null;)g=Ut.nextEffect,Ut.nextEffect=null,Ut=g;if(g=_.firstPendingTime,g===0&&(mr=null),g===1073741823?_===Di?ft++:(ft=0,Di=_):ft=0,typeof ca=="function"&&ca(A.stateNode,P),t0(_),Fi)throw Fi=!1,_=Ar,Ar=null,_;return(Ln&no)!==Rr||Uu(),null}function E2(){for(;Ut!==null;){var _=Ut.effectTag;(_&256)!==0&&Hs(Ut.alternate,Ut),(_&512)===0||K||(K=!0,nl(97,function(){return qs(),null})),Ut=Ut.nextEffect}}function qs(){if(ni!==90){var _=97<ni?97:ni;return ni=90,co(_,Al)}}function Al(){if(ti===null)return!1;var _=ti;if(ti=null,(Ln&(nu|fu))!==Rr)throw Error(t(331));var g=Ln;for(Ln|=fu,_=_.current.firstEffect;_!==null;){try{var A=_;if((A.effectTag&512)!==0)switch(A.tag){case 0:case 11:case 15:R0(128,0,A),R0(0,64,A)}}catch(P){if(_===null)throw Error(t(330));zo(_,P)}A=_.nextEffect,_.nextEffect=null,_=A}return Ln=g,Uu(),!0}function id(_,g,A){g=Cl(A,g),g=_s(_,g,1073741823),J0(_,g),_=ro(_,1073741823),_!==null&&t0(_)}function zo(_,g){if(_.tag===3)id(_,_,g);else for(var A=_.return;A!==null;){if(A.tag===3){id(A,_,g);break}else if(A.tag===1){var P=A.stateNode;if(typeof A.type.getDerivedStateFromError=="function"||typeof P.componentDidCatch=="function"&&(mr===null||!mr.has(P))){_=Cl(g,_),_=aa(A,_,1073741823),J0(A,_),A=ro(A,1073741823),A!==null&&t0(A);break}}A=A.return}}function ja(_,g,A){var P=_.pingCache;P!==null&&P.delete(g),fe===_&&Pe===A?Me===g0||Me===$u&&mt===1073741823&&h0()-Tn<ir?Ds(_,Pe):_n=!0:dc(_,A)&&(g=_.lastPingedTime,g!==0&&g<A||(_.lastPingedTime=A,_.finishedExpirationTime===A&&(_.finishedExpirationTime=0,_.finishedWork=null),t0(_)))}function za(_,g){var A=_.stateNode;A!==null&&A.delete(g),g=0,g===0&&(g=E0(),g=Un(g,_,null)),_=ro(_,g),_!==null&&t0(_)}var Ha;Ha=function(_,g,A){var P=g.expirationTime;if(_!==null){var B=g.pendingProps;if(_.memoizedProps!==B||yi.current)ho=!0;else{if(P<A){switch(ho=!1,g.tag){case 3:Ke(g),tu();break;case 5:if(vt(g),g.mode&4&&A!==1&&At(g.type,B))return g.expirationTime=g.childExpirationTime=1,null;break;case 1:eu(g.type)&&li(g);break;case 4:Ne(g,g.stateNode.containerInfo);break;case 10:zu(g,g.memoizedProps.value);break;case 13:if(g.memoizedState!==null)return P=g.child.childExpirationTime,P!==0&&P>=A?Kt(_,g,A):(en(qe,qe.current&1,g),g=mu(_,g,A),g!==null?g.sibling:null);en(qe,qe.current&1,g);break;case 19:if(P=g.childExpirationTime>=A,(_.effectTag&64)!==0){if(P)return bn(_,g,A);g.effectTag|=64}if(B=g.memoizedState,B!==null&&(B.rendering=null,B.tail=null),en(qe,qe.current,g),!P)return null}return mu(_,g,A)}ho=!1}}else ho=!1;switch(g.expirationTime=0,g.tag){case 2:if(P=g.type,_!==null&&(_.alternate=null,g.alternate=null,g.effectTag|=2),_=g.pendingProps,B=Ru(g,Ai.current),Fo(g,A),B=un(null,g,P,_,B,A),g.effectTag|=1,typeof B=="object"&&B!==null&&typeof B.render=="function"&&B.$$typeof===void 0){if(g.tag=1,fn(),eu(P)){var Z=!0;li(g)}else Z=!1;g.memoizedState=B.state!==null&&B.state!==void 0?B.state:null;var de=P.getDerivedStateFromProps;typeof de=="function"&&Zl(g,P,de,_),B.updater=oa,g.stateNode=B,B._reactInternalFiber=g,Bs(g,P,_,A),g=tt(null,g,P,!0,Z,A)}else g.tag=0,Bi(null,g,B,A),g=g.child;return g;case 16:if(B=g.elementType,_!==null&&(_.alternate=null,g.alternate=null,g.effectTag|=2),_=g.pendingProps,Ae(B),B._status!==1)throw B._result;switch(B=B._result,g.type=B,Z=g.tag=ol(B),_=Yn(B,_),Z){case 0:g=to(null,g,B,_,A);break;case 1:g=xe(null,g,B,_,A);break;case 11:g=Ci(null,g,B,_,A);break;case 14:g=mf(null,g,B,Yn(B.type,_),P,A);break;default:throw Error(t(306,B,""))}return g;case 0:return P=g.type,B=g.pendingProps,B=g.elementType===P?B:Yn(P,B),to(_,g,P,B,A);case 1:return P=g.type,B=g.pendingProps,B=g.elementType===P?B:Yn(P,B),xe(_,g,P,B,A);case 3:if(Ke(g),P=g.updateQueue,P===null)throw Error(t(282));if(B=g.memoizedState,B=B!==null?B.element:null,S0(g,P,g.pendingProps,null,A),P=g.memoizedState.element,P===B)tu(),g=mu(_,g,A);else{if((B=g.stateNode.hydrate)&&(S?(Su=F0(g.stateNode.containerInfo),Xu=g,B=_i=!0):B=!1),B)for(A=Y(g,null,P,A),g.child=A;A;)A.effectTag=A.effectTag&-3|1024,A=A.sibling;else Bi(_,g,P,A),tu();g=g.child}return g;case 5:return vt(g),_===null&&Uo(g),P=g.type,B=g.pendingProps,Z=_!==null?_.memoizedProps:null,de=B.children,dt(P,B)?de=null:Z!==null&&dt(P,Z)&&(g.effectTag|=16),eo(_,g),g.mode&4&&A!==1&&At(P,B)?(g.expirationTime=g.childExpirationTime=1,g=null):(Bi(_,g,de,A),g=g.child),g;case 6:return _===null&&Uo(g),null;case 13:return Kt(_,g,A);case 4:return Ne(g,g.stateNode.containerInfo),P=g.pendingProps,_===null?g.child=H(g,null,P,A):Bi(_,g,P,A),g.child;case 11:return P=g.type,B=g.pendingProps,B=g.elementType===P?B:Yn(P,B),Ci(_,g,P,B,A);case 7:return Bi(_,g,g.pendingProps,A),g.child;case 8:return Bi(_,g,g.pendingProps.children,A),g.child;case 12:return Bi(_,g,g.pendingProps.children,A),g.child;case 10:e:{if(P=g.type._context,B=g.pendingProps,de=g.memoizedProps,Z=B.value,zu(g,Z),de!==null){var yt=de.value;if(Z=Fe(yt,Z)?0:(typeof P._calculateChangedBits=="function"?P._calculateChangedBits(yt,Z):1073741823)|0,Z===0){if(de.children===B.children&&!yi.current){g=mu(_,g,A);break e}}else for(yt=g.child,yt!==null&&(yt.return=g);yt!==null;){var Rt=yt.dependencies;if(Rt!==null){de=yt.child;for(var Nt=Rt.firstContext;Nt!==null;){if(Nt.context===P&&(Nt.observedBits&Z)!==0){yt.tag===1&&(Nt=v0(A,null),Nt.tag=2,J0(yt,Nt)),yt.expirationTime<A&&(yt.expirationTime=A),Nt=yt.alternate,Nt!==null&&Nt.expirationTime<A&&(Nt.expirationTime=A),Ti(yt.return,A),Rt.expirationTime<A&&(Rt.expirationTime=A);break}Nt=Nt.next}}else de=yt.tag===10&&yt.type===g.type?null:yt.child;if(de!==null)de.return=yt;else for(de=yt;de!==null;){if(de===g){de=null;break}if(yt=de.sibling,yt!==null){yt.return=de.return,de=yt;break}de=de.return}yt=de}}Bi(_,g,B.children,A),g=g.child}return g;case 9:return B=g.type,Z=g.pendingProps,P=Z.children,Fo(g,A),B=Mu(B,Z.unstable_observedBits),P=P(B),g.effectTag|=1,Bi(_,g,P,A),g.child;case 14:return B=g.type,Z=Yn(B,g.pendingProps),Z=Yn(B.type,Z),mf(_,g,B,Z,P,A);case 15:return yf(_,g,g.type,g.pendingProps,P,A);case 17:return P=g.type,B=g.pendingProps,B=g.elementType===P?B:Yn(P,B),_!==null&&(_.alternate=null,g.alternate=null,g.effectTag|=2),g.tag=1,eu(P)?(_=!0,li(g)):_=!1,Fo(g,A),bs(g,P,B,A),Bs(g,P,B,A),tt(null,g,P,!0,_,A);case 19:return bn(_,g,A)}throw Error(t(156,g.tag))};var ca=null,ws=null;function Ss(_){if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u")return!1;var g=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(g.isDisabled||!g.supportsFiber)return!0;try{var A=g.inject(_);ca=function(P){try{g.onCommitFiberRoot(A,P,void 0,(P.current.effectTag&64)===64)}catch{}},ws=function(P){try{g.onCommitFiberUnmount(A,P)}catch{}}}catch{}return!0}function ts(_,g,A,P){this.tag=_,this.key=A,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=g,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=P,this.effectTag=0,this.lastEffect=this.firstEffect=this.nextEffect=null,this.childExpirationTime=this.expirationTime=0,this.alternate=null}function Ho(_,g,A,P){return new ts(_,g,A,P)}function Ef(_){return _=_.prototype,!(!_||!_.isReactComponent)}function ol(_){if(typeof _=="function")return Ef(_)?1:0;if(_!=null){if(_=_.$$typeof,_===De)return 11;if(_===we)return 14}return 2}function Vu(_,g){var A=_.alternate;return A===null?(A=Ho(_.tag,g,_.key,_.mode),A.elementType=_.elementType,A.type=_.type,A.stateNode=_.stateNode,A.alternate=_,_.alternate=A):(A.pendingProps=g,A.effectTag=0,A.nextEffect=null,A.firstEffect=null,A.lastEffect=null),A.childExpirationTime=_.childExpirationTime,A.expirationTime=_.expirationTime,A.child=_.child,A.memoizedProps=_.memoizedProps,A.memoizedState=_.memoizedState,A.updateQueue=_.updateQueue,g=_.dependencies,A.dependencies=g===null?null:{expirationTime:g.expirationTime,firstContext:g.firstContext,responders:g.responders},A.sibling=_.sibling,A.index=_.index,A.ref=_.ref,A}function qa(_,g,A,P,B,Z){var de=2;if(P=_,typeof _=="function")Ef(_)&&(de=1);else if(typeof _=="string")de=5;else e:switch(_){case j:return n0(A.children,B,Z,g);case me:de=8,B|=7;break;case q:de=8,B|=1;break;case V:return _=Ho(12,A,g,B|8),_.elementType=V,_.type=V,_.expirationTime=Z,_;case ge:return _=Ho(13,A,g,B),_.type=ge,_.elementType=ge,_.expirationTime=Z,_;case ae:return _=Ho(19,A,g,B),_.elementType=ae,_.expirationTime=Z,_;default:if(typeof _=="object"&&_!==null)switch(_.$$typeof){case re:de=10;break e;case y:de=9;break e;case De:de=11;break e;case we:de=14;break e;case he:de=16,P=null;break e}throw Error(t(130,_==null?_:typeof _,""))}return g=Ho(de,A,g,B),g.elementType=_,g.type=P,g.expirationTime=Z,g}function n0(_,g,A,P){return _=Ho(7,_,P,g),_.expirationTime=A,_}function j0(_,g,A){return _=Ho(6,_,null,g),_.expirationTime=A,_}function Df(_,g,A){return g=Ho(4,_.children!==null?_.children:[],_.key,g),g.expirationTime=A,g.stateNode={containerInfo:_.containerInfo,pendingChildren:null,implementation:_.implementation},g}function Wc(_,g,A){this.tag=g,this.current=null,this.containerInfo=_,this.pingCache=this.pendingChildren=null,this.finishedExpirationTime=0,this.finishedWork=null,this.timeoutHandle=lr,this.pendingContext=this.context=null,this.hydrate=A,this.callbackNode=null,this.callbackPriority=90,this.lastExpiredTime=this.lastPingedTime=this.nextKnownPendingLevel=this.lastSuspendedTime=this.firstSuspendedTime=this.firstPendingTime=0}function dc(_,g){var A=_.firstSuspendedTime;return _=_.lastSuspendedTime,A!==0&&A>=g&&_<=g}function Ol(_,g){var A=_.firstSuspendedTime,P=_.lastSuspendedTime;A<g&&(_.firstSuspendedTime=g),(P>g||A===0)&&(_.lastSuspendedTime=g),g<=_.lastPingedTime&&(_.lastPingedTime=0),g<=_.lastExpiredTime&&(_.lastExpiredTime=0)}function Ts(_,g){g>_.firstPendingTime&&(_.firstPendingTime=g);var A=_.firstSuspendedTime;A!==0&&(g>=A?_.firstSuspendedTime=_.lastSuspendedTime=_.nextKnownPendingLevel=0:g>=_.lastSuspendedTime&&(_.lastSuspendedTime=g+1),g>_.nextKnownPendingLevel&&(_.nextKnownPendingLevel=g))}function da(_,g){var A=_.lastExpiredTime;(A===0||A>g)&&(_.lastExpiredTime=g)}function ud(_){var g=_._reactInternalFiber;if(g===void 0)throw typeof _.render=="function"?Error(t(188)):Error(t(268,Object.keys(_)));return _=Qe(g),_===null?null:_.stateNode}function pa(_,g){_=_.memoizedState,_!==null&&_.dehydrated!==null&&_.retryTime<g&&(_.retryTime=g)}function pc(_,g){pa(_,g),(_=_.alternate)&&pa(_,g)}var Vc={createContainer:function(_,g,A){return _=new Wc(_,g,A),g=Ho(3,null,null,g===2?7:g===1?3:0),_.current=g,g.stateNode=_},updateContainer:function(_,g,A,P){var B=g.current,Z=E0(),de=si.suspense;Z=Un(Z,B,de);e:if(A){A=A._reactInternalFiber;t:{if(We(A)!==A||A.tag!==1)throw Error(t(170));var yt=A;do{switch(yt.tag){case 3:yt=yt.stateNode.context;break t;case 1:if(eu(yt.type)){yt=yt.stateNode.__reactInternalMemoizedMergedChildContext;break t}}yt=yt.return}while(yt!==null);throw Error(t(171))}if(A.tag===1){var Rt=A.type;if(eu(Rt)){A=ko(A,Rt,yt);break e}}A=yt}else A=In;return g.context===null?g.context=A:g.pendingContext=A,g=v0(Z,de),g.payload={element:_},P=P===void 0?null:P,P!==null&&(g.callback=P),J0(B,g),e0(B,Z),Z},batchedEventUpdates:function(_,g){var A=Ln;Ln|=2;try{return _(g)}finally{Ln=A,Ln===Rr&&Uu()}},batchedUpdates:function(_,g){var A=Ln;Ln|=1;try{return _(g)}finally{Ln=A,Ln===Rr&&Uu()}},unbatchedUpdates:function(_,g){var A=Ln;Ln&=-2,Ln|=no;try{return _(g)}finally{Ln=A,Ln===Rr&&Uu()}},deferredUpdates:function(_){return co(97,_)},syncUpdates:function(_,g,A,P){return co(99,_.bind(null,g,A,P))},discreteUpdates:function(_,g,A,P){var B=Ln;Ln|=4;try{return co(98,_.bind(null,g,A,P))}finally{Ln=B,Ln===Rr&&Uu()}},flushDiscreteUpdates:function(){(Ln&(1|nu|fu))===Rr&&(_f(),qs())},flushControlled:function(_){var g=Ln;Ln|=1;try{co(99,_)}finally{Ln=g,Ln===Rr&&Uu()}},flushSync:fc,flushPassiveEffects:qs,IsThisRendererActing:{current:!1},getPublicRootInstance:function(_){if(_=_.current,!_.child)return null;switch(_.child.tag){case 5:return Ve(_.child.stateNode);default:return _.child.stateNode}},attemptSynchronousHydration:function(_){switch(_.tag){case 3:var g=_.stateNode;g.hydrate&&Ba(g,g.firstPendingTime);break;case 13:fc(function(){return e0(_,1073741823)}),g=Q(E0(),150,100),pc(_,g)}},attemptUserBlockingHydration:function(_){if(_.tag===13){var g=Q(E0(),150,100);e0(_,g),pc(_,g)}},attemptContinuousHydration:function(_){if(_.tag===13){E0();var g=b0++;e0(_,g),pc(_,g)}},attemptHydrationAtCurrentPriority:function(_){if(_.tag===13){var g=E0();g=Un(g,_,null),e0(_,g),pc(_,g)}},findHostInstance:ud,findHostInstanceWithWarning:function(_){return ud(_)},findHostInstanceWithNoPortals:function(_){return _=ot(_),_===null?null:_.tag===20?_.stateNode.instance:_.stateNode},shouldSuspend:function(){return!1},injectIntoDevTools:function(_){var g=_.findFiberByHostInstance;return Ss(f({},_,{overrideHookState:null,overrideProps:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:N.ReactCurrentDispatcher,findHostInstanceByFiber:function(A){return A=Qe(A),A===null?null:A.stateNode},findFiberByHostInstance:function(A){return g?g(A):null},findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null}))}};Gy.exports=Vc.default||Vc;var Wi=Gy.exports;return Gy.exports=o,Wi}});var qS=nt(ec=>{"use strict";Object.defineProperty(ec,"__esModule",{value:!0});var _P=0;ec.__interactionsRef=null;ec.__subscriberRef=null;ec.unstable_clear=function(o){return o()};ec.unstable_getCurrent=function(){return null};ec.unstable_getThreadID=function(){return++_P};ec.unstable_trace=function(o,l,f){return f()};ec.unstable_wrap=function(o){return o};ec.unstable_subscribe=function(){};ec.unstable_unsubscribe=function(){}});var WS=nt(vu=>{"use strict";process.env.NODE_ENV!=="production"&&function(){"use strict";Object.defineProperty(vu,"__esModule",{value:!0});var o=!0,l=0,f=0,h=0;vu.__interactionsRef=null,vu.__subscriberRef=null,o&&(vu.__interactionsRef={current:new Set},vu.__subscriberRef={current:null});function E(ae){if(!o)return ae();var we=vu.__interactionsRef.current;vu.__interactionsRef.current=new Set;try{return ae()}finally{vu.__interactionsRef.current=we}}function t(){return o?vu.__interactionsRef.current:null}function N(){return++h}function F(ae,we,he){var ve=arguments.length>3&&arguments[3]!==void 0?arguments[3]:l;if(!o)return he();var ue={__count:1,id:f++,name:ae,timestamp:we},Ae=vu.__interactionsRef.current,ze=new Set(Ae);ze.add(ue),vu.__interactionsRef.current=ze;var We=vu.__subscriberRef.current,gt;try{We!==null&&We.onInteractionTraced(ue)}finally{try{We!==null&&We.onWorkStarted(ze,ve)}finally{try{gt=he()}finally{vu.__interactionsRef.current=Ae;try{We!==null&&We.onWorkStopped(ze,ve)}finally{ue.__count--,We!==null&&ue.__count===0&&We.onInteractionScheduledWorkCompleted(ue)}}}}return gt}function k(ae){var we=arguments.length>1&&arguments[1]!==void 0?arguments[1]:l;if(!o)return ae;var he=vu.__interactionsRef.current,ve=vu.__subscriberRef.current;ve!==null&&ve.onWorkScheduled(he,we),he.forEach(function(ze){ze.__count++});var ue=!1;function Ae(){var ze=vu.__interactionsRef.current;vu.__interactionsRef.current=he,ve=vu.__subscriberRef.current;try{var We;try{ve!==null&&ve.onWorkStarted(he,we)}finally{try{We=ae.apply(void 0,arguments)}finally{vu.__interactionsRef.current=ze,ve!==null&&ve.onWorkStopped(he,we)}}return We}finally{ue||(ue=!0,he.forEach(function(gt){gt.__count--,ve!==null&&gt.__count===0&&ve.onInteractionScheduledWorkCompleted(gt)}))}}return Ae.cancel=function(){ve=vu.__subscriberRef.current;try{ve!==null&&ve.onWorkCanceled(he,we)}finally{he.forEach(function(We){We.__count--,ve&&We.__count===0&&ve.onInteractionScheduledWorkCompleted(We)})}},Ae}var x=null;o&&(x=new Set);function j(ae){o&&(x.add(ae),x.size===1&&(vu.__subscriberRef.current={onInteractionScheduledWorkCompleted:re,onInteractionTraced:V,onWorkCanceled:ge,onWorkScheduled:y,onWorkStarted:me,onWorkStopped:De}))}function q(ae){o&&(x.delete(ae),x.size===0&&(vu.__subscriberRef.current=null))}function V(ae){var we=!1,he=null;if(x.forEach(function(ve){try{ve.onInteractionTraced(ae)}catch(ue){we||(we=!0,he=ue)}}),we)throw he}function re(ae){var we=!1,he=null;if(x.forEach(function(ve){try{ve.onInteractionScheduledWorkCompleted(ae)}catch(ue){we||(we=!0,he=ue)}}),we)throw he}function y(ae,we){var he=!1,ve=null;if(x.forEach(function(ue){try{ue.onWorkScheduled(ae,we)}catch(Ae){he||(he=!0,ve=Ae)}}),he)throw ve}function me(ae,we){var he=!1,ve=null;if(x.forEach(function(ue){try{ue.onWorkStarted(ae,we)}catch(Ae){he||(he=!0,ve=Ae)}}),he)throw ve}function De(ae,we){var he=!1,ve=null;if(x.forEach(function(ue){try{ue.onWorkStopped(ae,we)}catch(Ae){he||(he=!0,ve=Ae)}}),he)throw ve}function ge(ae,we){var he=!1,ve=null;if(x.forEach(function(ue){try{ue.onWorkCanceled(ae,we)}catch(Ae){he||(he=!0,ve=Ae)}}),he)throw ve}vu.unstable_clear=E,vu.unstable_getCurrent=t,vu.unstable_getThreadID=N,vu.unstable_trace=F,vu.unstable_wrap=k,vu.unstable_subscribe=j,vu.unstable_unsubscribe=q}()});var VS=nt((_H,vD)=>{"use strict";process.env.NODE_ENV==="production"?vD.exports=qS():vD.exports=WS()});var GS=nt((EH,Yy)=>{"use strict";process.env.NODE_ENV!=="production"&&(Yy.exports=function o(l){"use strict";var f=Py(),h=Mi(),E=XE(),t=z_(),N=VS(),F=0,k=1,x=2,j=3,q=4,V=5,re=6,y=7,me=8,De=9,ge=10,ae=11,we=12,he=13,ve=14,ue=15,Ae=16,ze=17,We=18,gt=19,_t=20,Qe=21,ot=function(){};ot=function(c,d){for(var D=arguments.length,C=new Array(D>2?D-2:0),O=2;O<D;O++)C[O-2]=arguments[O];if(d===void 0)throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning message argument");if(C.length>8)throw new Error("warningWithoutStack() currently supports at most 8 arguments.");if(!c){if(typeof console<"u"){var z=C.map(function(se){return""+se});z.unshift("Warning: "+d),Function.prototype.apply.call(console.error,console,z)}try{var G=0,ne="Warning: "+d.replace(/%s/g,function(){return C[G++]});throw new Error(ne)}catch{}}};var Ve=ot;function Pt(c){return c._reactInternalFiber}function Jt(c,d){c._reactInternalFiber=d}var it=h.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;it.hasOwnProperty("ReactCurrentDispatcher")||(it.ReactCurrentDispatcher={current:null}),it.hasOwnProperty("ReactCurrentBatchConfig")||(it.ReactCurrentBatchConfig={suspense:null});var J=typeof Symbol=="function"&&Symbol.for,ce=J?Symbol.for("react.element"):60103,Re=J?Symbol.for("react.portal"):60106,le=J?Symbol.for("react.fragment"):60107,He=J?Symbol.for("react.strict_mode"):60108,dt=J?Symbol.for("react.profiler"):60114,At=J?Symbol.for("react.provider"):60109,nn=J?Symbol.for("react.context"):60110,an=J?Symbol.for("react.concurrent_mode"):60111,On=J?Symbol.for("react.forward_ref"):60112,lr=J?Symbol.for("react.suspense"):60113,ln=J?Symbol.for("react.suspense_list"):60120,Vt=J?Symbol.for("react.memo"):60115,Er=J?Symbol.for("react.lazy"):60116,S=J?Symbol.for("react.fundamental"):60117,zt=J?Symbol.for("react.responder"):60118,Xn=J?Symbol.for("react.scope"):60119,vr=typeof Symbol=="function"&&Symbol.iterator,jr="@@iterator";function fr(c){if(c===null||typeof c!="object")return null;var d=vr&&c[vr]||c[jr];return typeof d=="function"?d:null}var zr=Ve;zr=function(c,d){if(!c){for(var D=it.ReactDebugCurrentFrame,C=D.getStackAddendum(),O=arguments.length,z=new Array(O>2?O-2:0),G=2;G<O;G++)z[G-2]=arguments[G];Ve.apply(void 0,[!1,d+"%s"].concat(z,[C]))}};var Xt=zr,Du=-1,c0=0,Ao=1,Jo=2;function Fs(c){return c._status===Ao?c._result:null}function Zo(c){if(c._status===Du){c._status=c0;var d=c._ctor,D=d();c._result=D,D.then(function(C){if(c._status===c0){var O=C.default;O===void 0&&Xt(!1,`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,C),c._status=Ao,c._result=O}},function(C){c._status===c0&&(c._status=Jo,c._result=C)})}}function $o(c,d,D){var C=d.displayName||d.name||"";return c.displayName||(C!==""?D+"("+C+")":D)}function qt(c){if(c==null)return null;if(typeof c.tag=="number"&&Ve(!1,"Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue."),typeof c=="function")return c.displayName||c.name||null;if(typeof c=="string")return c;switch(c){case le:return"Fragment";case Re:return"Portal";case dt:return"Profiler";case He:return"StrictMode";case lr:return"Suspense";case ln:return"SuspenseList"}if(typeof c=="object")switch(c.$$typeof){case nn:return"Context.Consumer";case At:return"Context.Provider";case On:return $o(c,c.render,"ForwardRef");case Vt:return qt(c.type);case Er:{var d=c,D=Fs(d);if(D)return qt(D);break}}return null}var xi=0,lu=1,vi=2,Dr=4,el=6,Y0=8,Bu=16,K0=32,Kr=64,Oo=128,Mo=256,F0=512,su=1024,ki=1028,Ps=932,Kl=2047,P0=2048,d0=4096,Hr=!0,Ri=!0,X0=!0,mi=!0,en=!0,In=!0,Ai=!1,yi=!1,Wt=!1,Ru=!1,eu=!1,Q0=!0,Yi=!1,Xl=!1,ko=!1,li=!1,ao=!1,Ql=it.ReactCurrentOwner;function No(c){var d=c,D=c;if(c.alternate)for(;d.return;)d=d.return;else{var C=d;do d=C,(d.effectTag&(vi|su))!==xi&&(D=d.return),C=d.return;while(C)}return d.tag===j?D:null}function Is(c){return No(c)===c}function $n(c){{var d=Ql.current;if(d!==null&&d.tag===k){var D=d,C=D.stateNode;C._warnedAboutRefsInRender||Ve(!1,"%s is accessing isMounted inside its render() function. render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.",qt(D.type)||"A component"),C._warnedAboutRefsInRender=!0}}var O=Pt(c);return O?No(O)===O:!1}function tl(c){if(No(c)!==c)throw Error("Unable to find node on an unmounted component.")}function fo(c){var d=c.alternate;if(!d){var D=No(c);if(D===null)throw Error("Unable to find node on an unmounted component.");return D!==c?null:c}for(var C=c,O=d;;){var z=C.return;if(z===null)break;var G=z.alternate;if(G===null){var ne=z.return;if(ne!==null){C=O=ne;continue}break}if(z.child===G.child){for(var se=z.child;se;){if(se===C)return tl(z),c;if(se===O)return tl(z),d;se=se.sibling}throw Error("Unable to find node on an unmounted component.")}if(C.return!==O.return)C=z,O=G;else{for(var Ue=!1,Xe=z.child;Xe;){if(Xe===C){Ue=!0,C=z,O=G;break}if(Xe===O){Ue=!0,O=z,C=G;break}Xe=Xe.sibling}if(!Ue){for(Xe=G.child;Xe;){if(Xe===C){Ue=!0,C=G,O=z;break}if(Xe===O){Ue=!0,O=G,C=z;break}Xe=Xe.sibling}if(!Ue)throw Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.")}}if(C.alternate!==O)throw Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.")}if(C.tag!==j)throw Error("Unable to find node on an unmounted component.");return C.stateNode.current===C?c:d}function I0(c){var d=fo(c);if(!d)return null;for(var D=d;;){if(D.tag===V||D.tag===re)return D;if(D.child){D.child.return=D,D=D.child;continue}if(D===d)return null;for(;!D.sibling;){if(!D.return||D.return===d)return null;D=D.return}D.sibling.return=D.return,D=D.sibling}return null}function Sl(c){var d=fo(c);if(!d)return null;for(var D=d;;){if(D.tag===V||D.tag===re||Wt&&D.tag===_t)return D;if(D.child&&D.tag!==q){D.child.return=D,D=D.child;continue}if(D===d)return null;for(;!D.sibling;){if(!D.return||D.return===d)return null;D=D.return}D.sibling.return=D.return,D=D.sibling}return null}var Lo=l.getPublicInstance,St=l.getRootHostContext,Bt=l.getChildHostContext,Hn=l.prepareForCommit,qr=l.resetAfterCommit,Ki=l.createInstance,Xr=l.appendInitialChild,Au=l.finalizeInitialChildren,p0=l.prepareUpdate,Ni=l.shouldSetTextContent,h0=l.shouldDeprioritizeSubtree,hs=l.createTextInstance,Ct=l.setTimeout,co=l.clearTimeout,nl=l.noTimeout,Jl=l.now,Uu=l.isPrimaryRenderer,vs=l.warnsIfNotActing,b0=l.supportsMutation,Q=l.supportsPersistence,Se=l.supportsHydration,Fe=l.mountResponderInstance,Le=l.unmountResponderInstance,pt=l.getFundamentalComponentInstance,Yn=l.mountFundamentalComponent,Cn=l.shouldUpdateFundamentalComponent,cr=l.getInstanceFromNode,Si=l.appendChild,Ou=l.appendChildToContainer,ju=l.commitTextUpdate,zu=l.commitMount,wu=l.commitUpdate,Ti=l.insertBefore,Fo=l.insertInContainerBefore,Mu=l.removeChild,po=l.removeChildFromContainer,Hu=l.resetTextContent,Pa=l.hideInstance,v0=l.hideTextInstance,ia=l.unhideInstance,J0=l.unhideTextInstance,ua=l.updateFundamentalComponent,Ia=l.unmountFundamentalComponent,ms=l.cloneInstance,S0=l.createContainerChildSet,Qn=l.appendChildToContainerChildSet,ac=l.finalizeContainerChildren,si=l.replaceContainerChildren,Jr=l.cloneHiddenInstance,Zl=l.cloneHiddenTextInstance,oa=l.cloneInstance,pf=l.canHydrateInstance,bs=l.canHydrateTextInstance,ba=l.canHydrateSuspenseInstance,Bs=l.isSuspenseInstancePending,m0=l.isSuspenseInstanceFallback,Us=l.registerSuspenseInstanceRetry,zi=l.getNextHydratableSibling,U=l.getFirstHydratableChild,H=l.hydrateInstance,Y=l.hydrateTextInstance,ee=l.hydrateSuspenseInstance,Ce=l.getNextHydratableInstanceAfterSuspenseInstance,_e=l.commitHydratedContainer,Oe=l.commitHydratedSuspenseInstance,$=l.clearSuspenseBoundary,Ne=l.clearSuspenseBoundaryFromContainer,Je=l.didNotMatchHydratedContainerTextInstance,vt=l.didNotMatchHydratedTextInstance,oe=l.didNotHydrateContainerInstance,qe=l.didNotHydrateInstance,rt=l.didNotFindHydratableContainerInstance,xt=l.didNotFindHydratableContainerTextInstance,kt=l.didNotFindHydratableContainerSuspenseInstance,bt=l.didNotFindHydratableInstance,sn=l.didNotFindHydratableTextInstance,rn=l.didNotFindHydratableSuspenseInstance,Ft=/^(.*)[\\\/]/,Dn=function(c,d,D){var C="";if(d){var O=d.fileName,z=O.replace(Ft,"");if(/^index\./.test(z)){var G=O.match(Ft);if(G){var ne=G[1];if(ne){var se=ne.replace(Ft,"");z=se+"/"+z}}}C=" (at "+z+":"+d.lineNumber+")"}else D&&(C=" (created by "+D+")");return`
+    in `+(c||"Unknown")+C},dr=it.ReactDebugCurrentFrame;function er(c){switch(c.tag){case j:case q:case re:case y:case ge:case De:return"";default:var d=c._debugOwner,D=c._debugSource,C=qt(c.type),O=null;return d&&(O=qt(d.type)),Dn(C,D,O)}}function Cr(c){var d="",D=c;do d+=er(D),D=D.return;while(D);return d}var Rn=null,Nr=null;function y0(){{if(Rn===null)return null;var c=Rn._debugOwner;if(c!==null&&typeof c<"u")return qt(c.type)}return null}function Lr(){return Rn===null?"":Cr(Rn)}function ut(){dr.getCurrentStack=null,Rn=null,Nr=null}function wt(c){dr.getCurrentStack=Lr,Rn=c,Nr=null}function et(c){Nr=c}var It="\u269B",un="\u26D4",fn=typeof performance<"u"&&typeof performance.mark=="function"&&typeof performance.clearMarks=="function"&&typeof performance.measure=="function"&&typeof performance.clearMeasures=="function",Jn=null,wr=null,au=null,ku=!1,T0=!1,Z0=!1,Nu=0,gi=0,Po=new Set,rl=function(c){return It+" "+c},hf=function(c,d){var D=d?un+" ":It+" ",C=d?" Warning: "+d:"";return""+D+c+C},Tl=function(c){performance.mark(rl(c))},vf=function(c){performance.clearMarks(rl(c))},Io=function(c,d,D){var C=rl(d),O=hf(c,D);try{performance.measure(O,C)}catch{}performance.clearMarks(C),performance.clearMeasures(O)},ys=function(c,d){return c+" (#"+d+")"},js=function(c,d,D){return D===null?c+" ["+(d?"update":"mount")+"]":c+"."+D},bo=function(c,d){var D=qt(c.type)||"Unknown",C=c._debugID,O=c.alternate!==null,z=js(D,O,d);if(ku&&Po.has(z))return!1;Po.add(z);var G=ys(z,C);return Tl(G),!0},Bo=function(c,d){var D=qt(c.type)||"Unknown",C=c._debugID,O=c.alternate!==null,z=js(D,O,d),G=ys(z,C);vf(G)},gs=function(c,d,D){var C=qt(c.type)||"Unknown",O=c._debugID,z=c.alternate!==null,G=js(C,z,d),ne=ys(G,O);Io(G,ne,D)},Xu=function(c){switch(c.tag){case j:case V:case re:case q:case y:case ge:case De:case me:return!0;default:return!1}},Su=function(){wr!==null&&au!==null&&Bo(au,wr),au=null,wr=null,Z0=!1},_i=function(){for(var c=Jn;c;)c._debugIsCurrentlyTiming&&gs(c,null,null),c=c.return},C0=function(c){c.return!==null&&C0(c.return),c._debugIsCurrentlyTiming&&bo(c,null)},$0=function(){Jn!==null&&C0(Jn)};function Uo(){Hr&&gi++}function la(){Hr&&(ku&&(T0=!0),wr!==null&&wr!=="componentWillMount"&&wr!=="componentWillReceiveProps"&&(Z0=!0))}function $l(c){if(Hr){if(!fn||Xu(c)||(Jn=c,!bo(c,null)))return;c._debugIsCurrentlyTiming=!0}}function tu(c){if(Hr){if(!fn||Xu(c))return;c._debugIsCurrentlyTiming=!1,Bo(c,null)}}function Zr(c){if(Hr){if(!fn||Xu(c)||(Jn=c.return,!c._debugIsCurrentlyTiming))return;c._debugIsCurrentlyTiming=!1,gs(c,null,null)}}function ho(c){if(Hr){if(!fn||Xu(c)||(Jn=c.return,!c._debugIsCurrentlyTiming))return;c._debugIsCurrentlyTiming=!1;var d=c.tag===he?"Rendering was suspended":"An error was thrown inside this error boundary";gs(c,null,d)}}function Bi(c,d){if(Hr){if(!fn||(Su(),!bo(c,d)))return;au=c,wr=d}}function Ci(){if(Hr){if(!fn)return;if(wr!==null&&au!==null){var c=Z0?"Scheduled a cascading update":null;gs(au,wr,c)}wr=null,au=null}}function mf(c){if(Hr){if(Jn=c,!fn)return;Nu=0,Tl("(React Tree Reconciliation)"),$0()}}function yf(c,d){if(Hr){if(!fn)return;var D=null;if(c!==null)if(c.tag===j)D="A top-level update interrupted the previous render";else{var C=qt(c.type)||"Unknown";D="An update to "+C+" interrupted the previous render"}else Nu>1&&(D="There were cascading updates");Nu=0;var O=d?"(React Tree Reconciliation: Completed Root)":"(React Tree Reconciliation: Yielded)";_i(),Io(O,"(React Tree Reconciliation)",D)}}function eo(){if(Hr){if(!fn)return;ku=!0,T0=!1,Po.clear(),Tl("(Committing Changes)")}}function to(){if(Hr){if(!fn)return;var c=null;T0?c="Lifecycle hook scheduled a cascading update":Nu>0&&(c="Caused by a cascading update in earlier commit"),T0=!1,Nu++,ku=!1,Po.clear(),Io("(Committing Changes)","(Committing Changes)",c)}}function xe(){if(Hr){if(!fn)return;gi=0,Tl("(Committing Snapshot Effects)")}}function tt(){if(Hr){if(!fn)return;var c=gi;gi=0,Io("(Committing Snapshot Effects: "+c+" Total)","(Committing Snapshot Effects)",null)}}function Ke(){if(Hr){if(!fn)return;gi=0,Tl("(Committing Host Effects)")}}function Yt(){if(Hr){if(!fn)return;var c=gi;gi=0,Io("(Committing Host Effects: "+c+" Total)","(Committing Host Effects)",null)}}function Kt(){if(Hr){if(!fn)return;gi=0,Tl("(Calling Lifecycle Methods)")}}function pr(){if(Hr){if(!fn)return;var c=gi;gi=0,Io("(Calling Lifecycle Methods: "+c+" Total)","(Calling Lifecycle Methods)",null)}}var Ei=[],bn;bn=[];var mu=-1;function Qu(c){return{current:c}}function $r(c,d){if(mu<0){Ve(!1,"Unexpected pop.");return}d!==bn[mu]&&Ve(!1,"Unexpected Fiber popped."),c.current=Ei[mu],Ei[mu]=null,bn[mu]=null,mu--}function Qr(c,d,D){mu++,Ei[mu]=c.current,bn[mu]=D,c.current=d}var qu;qu={};var xn={};Object.freeze(xn);var x0=Qu(xn),Lu=Qu(!1),ui=xn;function Cl(c,d,D){return li?xn:D&&Xi(d)?ui:x0.current}function zs(c,d,D){if(!li){var C=c.stateNode;C.__reactInternalMemoizedUnmaskedChildContext=d,C.__reactInternalMemoizedMaskedChildContext=D}}function Wu(c,d){if(li)return xn;var D=c.type,C=D.contextTypes;if(!C)return xn;var O=c.stateNode;if(O&&O.__reactInternalMemoizedUnmaskedChildContext===d)return O.__reactInternalMemoizedMaskedChildContext;var z={};for(var G in C)z[G]=d[G];{var ne=qt(D)||"Unknown";E(C,z,"context",ne,Lr)}return O&&zs(c,d,z),z}function sa(){return li?!1:Lu.current}function Xi(c){if(li)return!1;var d=c.childContextTypes;return d!=null}function Hs(c){li||($r(Lu,c),$r(x0,c))}function R0(c){li||($r(Lu,c),$r(x0,c))}function Hi(c,d,D){if(!li){if(x0.current!==xn)throw Error("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");Qr(x0,d,c),Qr(Lu,D,c)}}function A0(c,d,D){if(li)return D;var C=c.stateNode,O=d.childContextTypes;if(typeof C.getChildContext!="function"){{var z=qt(d)||"Unknown";qu[z]||(qu[z]=!0,Ve(!1,"%s.childContextTypes is specified but there is no getChildContext() method on the instance. You can either define getChildContext() on %s or remove childContextTypes from it.",z,z))}return D}var G;et("getChildContext"),Bi(c,"getChildContext"),G=C.getChildContext(),Ci(),et(null);for(var ne in G)if(!(ne in O))throw Error((qt(d)||"Unknown")+'.getChildContext(): key "'+ne+'" is not defined in childContextTypes.');{var se=qt(d)||"Unknown";E(O,G,"child context",se,Lr)}return f({},D,{},G)}function qi(c){if(li)return!1;var d=c.stateNode,D=d&&d.__reactInternalMemoizedMergedChildContext||xn;return ui=x0.current,Qr(x0,D,c),Qr(Lu,Lu.current,c),!0}function il(c,d,D){if(!li){var C=c.stateNode;if(!C)throw Error("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");if(D){var O=A0(c,d,ui);C.__reactInternalMemoizedMergedChildContext=O,$r(Lu,c),$r(x0,c),Qr(x0,O,c),Qr(Lu,D,c)}else $r(Lu,c),Qr(Lu,D,c)}}function xl(c){if(li)return xn;if(!(Is(c)&&c.tag===k))throw Error("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.");var d=c;do{switch(d.tag){case j:return d.stateNode.context;case k:{var D=d.type;if(Xi(D))return d.stateNode.__reactInternalMemoizedMergedChildContext;break}}d=d.return}while(d!==null);throw Error("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.")}var B0=1,O0=2,vo=t.unstable_runWithPriority,Fu=t.unstable_scheduleCallback,Ju=t.unstable_cancelCallback,es=t.unstable_shouldYield,_s=t.unstable_requestPaint,aa=t.unstable_now,gf=t.unstable_getCurrentPriorityLevel,Zu=t.unstable_ImmediatePriority,Es=t.unstable_UserBlockingPriority,Rr=t.unstable_NormalPriority,no=t.unstable_LowPriority,nu=t.unstable_IdlePriority;if(In&&!(N.__interactionsRef!=null&&N.__interactionsRef.current!=null))throw Error("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at http://fb.me/react-profiling");var fu={},Li=99,ei=98,Kn=97,$u=96,g0=95,_0=90,Ln=es,fe=_s!==void 0?_s:function(){},ie=null,Pe=null,Me=!1,at=aa(),mt=at<1e4?aa:function(){return aa()-at};function Qt(){switch(gf()){case Zu:return Li;case Es:return ei;case Rr:return Kn;case no:return $u;case nu:return g0;default:throw Error("Unknown priority level.")}}function An(c){switch(c){case Li:return Zu;case ei:return Es;case Kn:return Rr;case $u:return no;case g0:return nu;default:throw Error("Unknown priority level.")}}function Sn(c,d){var D=An(c);return vo(D,d)}function _n(c,d,D){var C=An(c);return Fu(C,d,D)}function Tn(c){return ie===null?(ie=[c],Pe=Fu(Zu,Fi)):ie.push(c),fu}function ir(c){c!==fu&&Ju(c)}function Ut(){if(Pe!==null){var c=Pe;Pe=null,Ju(c)}Fi()}function Fi(){if(!Me&&ie!==null){Me=!0;var c=0;try{var d=!0,D=ie;Sn(Li,function(){for(;c<D.length;c++){var C=D[c];do C=C(d);while(C!==null)}}),ie=null}catch(C){throw ie!==null&&(ie=ie.slice(c+1)),Fu(Zu,Ut),C}finally{Me=!1}}}var Ar=0,mr=1,K=2,ti=4,ni=8,Wr=1073741823,ft=0,Di=1,ru=2,E0=3,Un=Wr,e0=Un-1,ro=10,mo=e0-1;function t0(c){return mo-(c/ro|0)}function jo(c){return(mo-c)*ro}function io(c,d){return((c/d|0)+1)*d}function Ba(c,d,D){return mo-io(mo-c+d/ro,D/ro)}var _f=5e3,fc=250;function Ds(c){return Ba(c,_f,fc)}function fa(c,d){return Ba(c,d,fc)}var U0=500,cc=100;function Ua(c){return Ba(c,U0,cc)}function _2(c){return E0++}function nd(c,d){if(d===Un)return Li;if(d===Di||d===ru)return g0;var D=jo(d)-jo(c);return D<=0?Li:D<=U0+cc?ei:D<=_f+fc?Kn:g0}function rd(c,d){return c===d&&(c!==0||1/c===1/d)||c!==c&&d!==d}var yo=typeof Object.is=="function"?Object.is:rd,qc=Object.prototype.hasOwnProperty;function Rl(c,d){if(yo(c,d))return!0;if(typeof c!="object"||c===null||typeof d!="object"||d===null)return!1;var D=Object.keys(c),C=Object.keys(d);if(D.length!==C.length)return!1;for(var O=0;O<D.length;O++)if(!qc.call(d,D[O])||!yo(c[D[O]],d[D[O]]))return!1;return!0}var ul=function(){};{var E2=function(c){for(var d=arguments.length,D=new Array(d>1?d-1:0),C=1;C<d;C++)D[C-1]=arguments[C];var O=0,z="Warning: "+c.replace(/%s/g,function(){return D[O++]});typeof console<"u"&&console.warn(z);try{throw new Error(z)}catch{}};ul=function(c,d){if(d===void 0)throw new Error("`lowPriorityWarningWithoutStack(condition, format, ...args)` requires a warning message argument");if(!c){for(var D=arguments.length,C=new Array(D>2?D-2:0),O=2;O<D;O++)C[O-2]=arguments[O];E2.apply(void 0,[d].concat(C))}}}var qs=ul,Al={recordUnsafeLifecycleWarnings:function(c,d){},flushPendingUnsafeLifecycleWarnings:function(){},recordLegacyContextWarning:function(c,d){},flushLegacyContextWarning:function(){},discardPendingWarnings:function(){}};{var id=function(c){for(var d=null,D=c;D!==null;)D.mode&mr&&(d=D),D=D.return;return d},zo=function(c){var d=[];return c.forEach(function(D){d.push(D)}),d.sort().join(", ")},ja=[],za=[],Ha=[],ca=[],ws=[],Ss=[],ts=new Set;Al.recordUnsafeLifecycleWarnings=function(c,d){ts.has(c.type)||(typeof d.componentWillMount=="function"&&d.componentWillMount.__suppressDeprecationWarning!==!0&&ja.push(c),c.mode&mr&&typeof d.UNSAFE_componentWillMount=="function"&&za.push(c),typeof d.componentWillReceiveProps=="function"&&d.componentWillReceiveProps.__suppressDeprecationWarning!==!0&&Ha.push(c),c.mode&mr&&typeof d.UNSAFE_componentWillReceiveProps=="function"&&ca.push(c),typeof d.componentWillUpdate=="function"&&d.componentWillUpdate.__suppressDeprecationWarning!==!0&&ws.push(c),c.mode&mr&&typeof d.UNSAFE_componentWillUpdate=="function"&&Ss.push(c))},Al.flushPendingUnsafeLifecycleWarnings=function(){var c=new Set;ja.length>0&&(ja.forEach(function(Lt){c.add(qt(Lt.type)||"Component"),ts.add(Lt.type)}),ja=[]);var d=new Set;za.length>0&&(za.forEach(function(Lt){d.add(qt(Lt.type)||"Component"),ts.add(Lt.type)}),za=[]);var D=new Set;Ha.length>0&&(Ha.forEach(function(Lt){D.add(qt(Lt.type)||"Component"),ts.add(Lt.type)}),Ha=[]);var C=new Set;ca.length>0&&(ca.forEach(function(Lt){C.add(qt(Lt.type)||"Component"),ts.add(Lt.type)}),ca=[]);var O=new Set;ws.length>0&&(ws.forEach(function(Lt){O.add(qt(Lt.type)||"Component"),ts.add(Lt.type)}),ws=[]);var z=new Set;if(Ss.length>0&&(Ss.forEach(function(Lt){z.add(qt(Lt.type)||"Component"),ts.add(Lt.type)}),Ss=[]),d.size>0){var G=zo(d);Ve(!1,`Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. See https://fb.me/react-unsafe-component-lifecycles for details.
+
+* Move code with side effects to componentDidMount, and set initial state in the constructor.
+
+Please update the following components: %s`,G)}if(C.size>0){var ne=zo(C);Ve(!1,`Using UNSAFE_componentWillReceiveProps in strict mode is not recommended and may indicate bugs in your code. See https://fb.me/react-unsafe-component-lifecycles for details.
+
+* Move data fetching code or side effects to componentDidUpdate.
+* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://fb.me/react-derived-state
+
+Please update the following components: %s`,ne)}if(z.size>0){var se=zo(z);Ve(!1,`Using UNSAFE_componentWillUpdate in strict mode is not recommended and may indicate bugs in your code. See https://fb.me/react-unsafe-component-lifecycles for details.
+
+* Move data fetching code or side effects to componentDidUpdate.
+
+Please update the following components: %s`,se)}if(c.size>0){var Ue=zo(c);qs(!1,`componentWillMount has been renamed, and is not recommended for use. See https://fb.me/react-unsafe-component-lifecycles for details.
+
+* Move code with side effects to componentDidMount, and set initial state in the constructor.
+* Rename componentWillMount to UNSAFE_componentWillMount to suppress this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run \`npx react-codemod rename-unsafe-lifecycles\` in your project source folder.
+
+Please update the following components: %s`,Ue)}if(D.size>0){var Xe=zo(D);qs(!1,`componentWillReceiveProps has been renamed, and is not recommended for use. See https://fb.me/react-unsafe-component-lifecycles for details.
+
+* Move data fetching code or side effects to componentDidUpdate.
+* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://fb.me/react-derived-state
+* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run \`npx react-codemod rename-unsafe-lifecycles\` in your project source folder.
+
+Please update the following components: %s`,Xe)}if(O.size>0){var ht=zo(O);qs(!1,`componentWillUpdate has been renamed, and is not recommended for use. See https://fb.me/react-unsafe-component-lifecycles for details.
+
+* Move data fetching code or side effects to componentDidUpdate.
+* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run \`npx react-codemod rename-unsafe-lifecycles\` in your project source folder.
+
+Please update the following components: %s`,ht)}};var Ho=new Map,Ef=new Set;Al.recordLegacyContextWarning=function(c,d){var D=id(c);if(D===null){Ve(!1,"Expected to find a StrictMode component in a strict mode tree. This error is likely caused by a bug in React. Please file an issue.");return}if(!Ef.has(c.type)){var C=Ho.get(D);(c.type.contextTypes!=null||c.type.childContextTypes!=null||d!==null&&typeof d.getChildContext=="function")&&(C===void 0&&(C=[],Ho.set(D,C)),C.push(c))}},Al.flushLegacyContextWarning=function(){Ho.forEach(function(c,d){var D=new Set;c.forEach(function(z){D.add(qt(z.type)||"Component"),Ef.add(z.type)});var C=zo(D),O=Cr(d);Ve(!1,`Legacy context API has been detected within a strict-mode tree.
+
+The old API will be supported in all 16.x releases, but applications using it should migrate to the new version.
+
+Please update the following components: %s
+
+Learn more about this warning here: https://fb.me/react-legacy-context%s`,C,O)})},Al.discardPendingWarnings=function(){ja=[],za=[],Ha=[],ca=[],ws=[],Ss=[],Ho=new Map}}var ol=null,Vu=null,qa=function(c){ol=c};function n0(c){{if(ol===null)return c;var d=ol(c);return d===void 0?c:d.current}}function j0(c){return n0(c)}function Df(c){{if(ol===null)return c;var d=ol(c);if(d===void 0){if(c!=null&&typeof c.render=="function"){var D=n0(c.render);if(c.render!==D){var C={$$typeof:On,render:D};return c.displayName!==void 0&&(C.displayName=c.displayName),C}}return c}return d.current}}function Wc(c,d){{if(ol===null)return!1;var D=c.elementType,C=d.type,O=!1,z=typeof C=="object"&&C!==null?C.$$typeof:null;switch(c.tag){case k:{typeof C=="function"&&(O=!0);break}case F:{(typeof C=="function"||z===Er)&&(O=!0);break}case ae:{(z===On||z===Er)&&(O=!0);break}case ve:case ue:{(z===Vt||z===Er)&&(O=!0);break}default:return!1}if(O){var G=ol(D);if(G!==void 0&&G===ol(C))return!0}return!1}}function dc(c){{if(ol===null||typeof WeakSet!="function")return;Vu===null&&(Vu=new WeakSet),Vu.add(c)}}var Ol=function(c,d){{if(ol===null)return;var D=d.staleFamilies,C=d.updatedFamilies;tf(),Rp(function(){da(c.current,C,D)})}},Ts=function(c,d){{if(c.context!==xn)return;tf(),pv(function(){Xg(d,c,null,null)})}};function da(c,d,D){{var C=c.alternate,O=c.child,z=c.sibling,G=c.tag,ne=c.type,se=null;switch(G){case F:case ue:case k:se=ne;break;case ae:se=ne.render;break;default:break}if(ol===null)throw new Error("Expected resolveFamily to be set during hot reload.");var Ue=!1,Xe=!1;if(se!==null){var ht=ol(se);ht!==void 0&&(D.has(ht)?Xe=!0:d.has(ht)&&(G===k?Xe=!0:Ue=!0))}Vu!==null&&(Vu.has(c)||C!==null&&Vu.has(C))&&(Xe=!0),Xe&&(c._debugNeedsRemount=!0),(Xe||Ue)&&yl(c,Un),O!==null&&!Xe&&da(O,d,D),z!==null&&da(z,d,D)}}var ud=function(c,d){{var D=new Set,C=new Set(d.map(function(O){return O.current}));return pa(c.current,C,D),D}};function pa(c,d,D){{var C=c.child,O=c.sibling,z=c.tag,G=c.type,ne=null;switch(z){case F:case ue:case k:ne=G;break;case ae:ne=G.render;break;default:break}var se=!1;ne!==null&&d.has(ne)&&(se=!0),se?pc(c,D):C!==null&&pa(C,d,D),O!==null&&pa(O,d,D)}}function pc(c,d){{var D=Vc(c,d);if(D)return;for(var C=c;;){switch(C.tag){case V:d.add(C.stateNode);return;case q:d.add(C.stateNode.containerInfo);return;case j:d.add(C.stateNode.containerInfo);return}if(C.return===null)throw new Error("Expected to reach root first.");C=C.return}}}function Vc(c,d){for(var D=c,C=!1;;){if(D.tag===V)C=!0,d.add(D.stateNode);else if(D.child!==null){D.child.return=D,D=D.child;continue}if(D===c)return C;for(;D.sibling===null;){if(D.return===null||D.return===c)return C;D=D.return}D.sibling.return=D.return,D=D.sibling}return!1}function Wi(c,d){if(c&&c.defaultProps){var D=f({},d),C=c.defaultProps;for(var O in C)D[O]===void 0&&(D[O]=C[O]);return D}return d}function _(c){if(Zo(c),c._status!==Ao)throw c._result;return c._result}var g=Qu(null),A;A={};var P=null,B=null,Z=null,de=!1;function yt(){P=null,B=null,Z=null,de=!1}function Rt(){de=!0}function Nt(){de=!1}function xr(c,d){var D=c.type._context;Uu?(Qr(g,D._currentValue,c),D._currentValue=d,D._currentRenderer===void 0||D._currentRenderer===null||D._currentRenderer===A||Ve(!1,"Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."),D._currentRenderer=A):(Qr(g,D._currentValue2,c),D._currentValue2=d,D._currentRenderer2===void 0||D._currentRenderer2===null||D._currentRenderer2===A||Ve(!1,"Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."),D._currentRenderer2=A)}function r0(c){var d=g.current;$r(g,c);var D=c.type._context;Uu?D._currentValue=d:D._currentValue2=d}function cu(c,d,D){if(yo(D,d))return 0;var C=typeof c._calculateChangedBits=="function"?c._calculateChangedBits(D,d):Wr;return(C&Wr)!==C&&Xt(!1,"calculateChangedBits: Expected the return value to be a 31-bit integer. Instead received: %s",C),C|0}function z0(c,d){for(var D=c;D!==null;){var C=D.alternate;if(D.childExpirationTime<d)D.childExpirationTime=d,C!==null&&C.childExpirationTime<d&&(C.childExpirationTime=d);else if(C!==null&&C.childExpirationTime<d)C.childExpirationTime=d;else break;D=D.return}}function Ml(c,d,D,C){var O=c.child;for(O!==null&&(O.return=c);O!==null;){var z=void 0,G=O.dependencies;if(G!==null){z=O.child;for(var ne=G.firstContext;ne!==null;){if(ne.context===d&&(ne.observedBits&D)!==0){if(O.tag===k){var se=Tu(C,null);se.tag=$t,Va(O,se)}O.expirationTime<C&&(O.expirationTime=C);var Ue=O.alternate;Ue!==null&&Ue.expirationTime<C&&(Ue.expirationTime=C),z0(O.return,C),G.expirationTime<C&&(G.expirationTime=C);break}ne=ne.next}}else if(O.tag===ge)z=O.type===c.type?null:O.child;else if(Ai&&O.tag===We){var Xe=O.return;if(Xe===null)throw Error("We just came from a parent so we must have had a parent. This is a bug in React.");Xe.expirationTime<C&&(Xe.expirationTime=C);var ht=Xe.alternate;ht!==null&&ht.expirationTime<C&&(ht.expirationTime=C),z0(Xe,C),z=O.sibling}else z=O.child;if(z!==null)z.return=O;else for(z=O;z!==null;){if(z===c){z=null;break}var Lt=z.sibling;if(Lt!==null){Lt.return=z.return,z=Lt;break}z=z.return}O=z}}function i0(c,d){P=c,B=null,Z=null;var D=c.dependencies;if(D!==null){var C=D.firstContext;C!==null&&(D.expirationTime>=d&&op(),D.firstContext=null)}}function Ge(c,d){if(de&&Xt(!1,"Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."),Z!==c){if(!(d===!1||d===0)){var D;typeof d!="number"||d===Wr?(Z=c,D=Wr):D=d;var C={context:c,observedBits:D,next:null};if(B===null){if(P===null)throw Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");B=C,P.dependencies={expirationTime:ft,firstContext:C,responders:null}}else B=B.next=C}}return Uu?c._currentValue:c._currentValue2}var je=0,st=1,$t=2,Wn=3,oi=!1,ur,ai;ur=!1,ai=null;function Qi(c){var d={baseState:c,firstUpdate:null,lastUpdate:null,firstCapturedUpdate:null,lastCapturedUpdate:null,firstEffect:null,lastEffect:null,firstCapturedEffect:null,lastCapturedEffect:null};return d}function Vr(c){var d={baseState:c.baseState,firstUpdate:c.firstUpdate,lastUpdate:c.lastUpdate,firstCapturedUpdate:null,lastCapturedUpdate:null,firstEffect:null,lastEffect:null,firstCapturedEffect:null,lastCapturedEffect:null};return d}function Tu(c,d){var D={expirationTime:c,suspenseConfig:d,tag:je,payload:null,callback:null,next:null,nextEffect:null};return D.priority=Qt(),D}function Wa(c,d){c.lastUpdate===null?c.firstUpdate=c.lastUpdate=d:(c.lastUpdate.next=d,c.lastUpdate=d)}function Va(c,d){var D=c.alternate,C,O;D===null?(C=c.updateQueue,O=null,C===null&&(C=c.updateQueue=Qi(c.memoizedState))):(C=c.updateQueue,O=D.updateQueue,C===null?O===null?(C=c.updateQueue=Qi(c.memoizedState),O=D.updateQueue=Qi(D.memoizedState)):C=c.updateQueue=Vr(O):O===null&&(O=D.updateQueue=Vr(C))),O===null||C===O?Wa(C,d):C.lastUpdate===null||O.lastUpdate===null?(Wa(C,d),Wa(O,d)):(Wa(C,d),O.lastUpdate=d),c.tag===k&&(ai===C||O!==null&&ai===O)&&!ur&&(Ve(!1,"An update (setState, replaceState, or forceUpdate) was scheduled from inside an update function. Update functions should be pure, with zero side-effects. Consider using componentDidUpdate or a callback."),ur=!0)}function od(c,d){var D=c.updateQueue;D===null?D=c.updateQueue=Qi(c.memoizedState):D=D2(c,D),D.lastCapturedUpdate===null?D.firstCapturedUpdate=D.lastCapturedUpdate=d:(D.lastCapturedUpdate.next=d,D.lastCapturedUpdate=d)}function D2(c,d){var D=c.alternate;return D!==null&&d===D.updateQueue&&(d=c.updateQueue=Vr(d)),d}function w2(c,d,D,C,O,z){switch(D.tag){case st:{var G=D.payload;if(typeof G=="function"){Rt(),Ri&&c.mode&mr&&G.call(z,C,O);var ne=G.call(z,C,O);return Nt(),ne}return G}case Wn:c.effectTag=c.effectTag&~d0|Kr;case je:{var se=D.payload,Ue;return typeof se=="function"?(Rt(),Ri&&c.mode&mr&&se.call(z,C,O),Ue=se.call(z,C,O),Nt()):Ue=se,Ue==null?C:f({},C,Ue)}case $t:return oi=!0,C}return C}function wf(c,d,D,C,O){oi=!1,d=D2(c,d),ai=d;for(var z=d.baseState,G=null,ne=ft,se=d.firstUpdate,Ue=z;se!==null;){var Xe=se.expirationTime;if(Xe<O)G===null&&(G=se,z=Ue),ne<Xe&&(ne=Xe);else{gv(Xe,se.suspenseConfig),Ue=w2(c,d,se,Ue,D,C);var ht=se.callback;ht!==null&&(c.effectTag|=K0,se.nextEffect=null,d.lastEffect===null?d.firstEffect=d.lastEffect=se:(d.lastEffect.nextEffect=se,d.lastEffect=se))}se=se.next}var Lt=null;for(se=d.firstCapturedUpdate;se!==null;){var Gt=se.expirationTime;if(Gt<O)Lt===null&&(Lt=se,G===null&&(z=Ue)),ne<Gt&&(ne=Gt);else{Ue=w2(c,d,se,Ue,D,C);var Ht=se.callback;Ht!==null&&(c.effectTag|=K0,se.nextEffect=null,d.lastCapturedEffect===null?d.firstCapturedEffect=d.lastCapturedEffect=se:(d.lastCapturedEffect.nextEffect=se,d.lastCapturedEffect=se))}se=se.next}G===null&&(d.lastUpdate=null),Lt===null?d.lastCapturedUpdate=null:c.effectTag|=K0,G===null&&Lt===null&&(z=Ue),d.baseState=z,d.firstUpdate=G,d.firstCapturedUpdate=Lt,Kd(ne),c.expirationTime=ne,c.memoizedState=Ue,ai=null}function ld(c,d){if(typeof c!="function")throw Error("Invalid argument passed as callback. Expected a function. Instead received: "+c);c.call(d)}function hh(){oi=!1}function Gc(){return oi}function go(c,d,D,C){d.firstCapturedUpdate!==null&&(d.lastUpdate!==null&&(d.lastUpdate.next=d.firstCapturedUpdate,d.lastUpdate=d.lastCapturedUpdate),d.firstCapturedUpdate=d.lastCapturedUpdate=null),vh(d.firstEffect,D),d.firstEffect=d.lastEffect=null,vh(d.firstCapturedEffect,D),d.firstCapturedEffect=d.lastCapturedEffect=null}function vh(c,d){for(;c!==null;){var D=c.callback;D!==null&&(c.callback=null,ld(D,d)),c=c.nextEffect}}var mh=it.ReactCurrentBatchConfig;function _o(){return mh.suspense}var kl={},sd=Array.isArray,ad=new h.Component().refs,S2,Yc,Ir,fd,cd,Ga,Kc,T2,ll,sl;{S2=new Set,Yc=new Set,Ir=new Set,fd=new Set,T2=new Set,cd=new Set,ll=new Set,sl=new Set;var yh=new Set;Kc=function(c,d){if(!(c===null||typeof c=="function")){var D=d+"_"+c;yh.has(D)||(yh.add(D),Ve(!1,"%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.",d,c))}},Ga=function(c,d){if(d===void 0){var D=qt(c)||"Component";cd.has(D)||(cd.add(D),Ve(!1,"%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.",D))}},Object.defineProperty(kl,"_processChildContext",{enumerable:!1,value:function(){throw Error("_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn't supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal).")}}),Object.freeze(kl)}function Sf(c,d,D,C){var O=c.memoizedState;Ri&&c.mode&mr&&D(C,O);var z=D(C,O);Ga(d,z);var G=z==null?O:f({},O,z);c.memoizedState=G;var ne=c.updateQueue;ne!==null&&c.expirationTime===ft&&(ne.baseState=G)}var Xc={isMounted:$n,enqueueSetState:function(c,d,D){var C=Pt(c),O=jl(),z=_o(),G=jf(O,C,z),ne=Tu(G,z);ne.payload=d,D!=null&&(Kc(D,"setState"),ne.callback=D),Va(C,ne),yl(C,G)},enqueueReplaceState:function(c,d,D){var C=Pt(c),O=jl(),z=_o(),G=jf(O,C,z),ne=Tu(G,z);ne.tag=st,ne.payload=d,D!=null&&(Kc(D,"replaceState"),ne.callback=D),Va(C,ne),yl(C,G)},enqueueForceUpdate:function(c,d){var D=Pt(c),C=jl(),O=_o(),z=jf(C,D,O),G=Tu(z,O);G.tag=$t,d!=null&&(Kc(d,"forceUpdate"),G.callback=d),Va(D,G),yl(D,z)}};function C2(c,d,D,C,O,z,G){var ne=c.stateNode;if(typeof ne.shouldComponentUpdate=="function"){Bi(c,"shouldComponentUpdate");var se=ne.shouldComponentUpdate(C,z,G);return Ci(),se===void 0&&Ve(!1,"%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.",qt(d)||"Component"),se}return d.prototype&&d.prototype.isPureReactComponent?!Rl(D,C)||!Rl(O,z):!0}function gh(c,d,D){var C=c.stateNode;{var O=qt(d)||"Component",z=C.render;z||(d.prototype&&typeof d.prototype.render=="function"?Ve(!1,"%s(...): No `render` method found on the returned component instance: did you accidentally return an object from the constructor?",O):Ve(!1,"%s(...): No `render` method found on the returned component instance: you may have forgotten to define `render`.",O));var G=!C.getInitialState||C.getInitialState.isReactClassApproved||C.state;G||Ve(!1,"getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?",O);var ne=!C.getDefaultProps||C.getDefaultProps.isReactClassApproved;ne||Ve(!1,"getDefaultProps was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Use a static property to define defaultProps instead.",O);var se=!C.propTypes;se||Ve(!1,"propTypes was defined as an instance property on %s. Use a static property to define propTypes instead.",O);var Ue=!C.contextType;if(Ue||Ve(!1,"contextType was defined as an instance property on %s. Use a static property to define contextType instead.",O),li)d.childContextTypes&&Ve(!1,"%s uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.",O),d.contextTypes&&Ve(!1,"%s uses the legacy contextTypes API which is no longer supported. Use React.createContext() with static contextType instead.",O);else{var Xe=!C.contextTypes;Xe||Ve(!1,"contextTypes was defined as an instance property on %s. Use a static property to define contextTypes instead.",O),d.contextType&&d.contextTypes&&!ll.has(d)&&(ll.add(d),Ve(!1,"%s declares both contextTypes and contextType static properties. The legacy contextTypes property will be ignored.",O))}var ht=typeof C.componentShouldUpdate!="function";ht||Ve(!1,"%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.",O),d.prototype&&d.prototype.isPureReactComponent&&typeof C.shouldComponentUpdate<"u"&&Ve(!1,"%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.",qt(d)||"A pure component");var Lt=typeof C.componentDidUnmount!="function";Lt||Ve(!1,"%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?",O);var Gt=typeof C.componentDidReceiveProps!="function";Gt||Ve(!1,"%s has a method called componentDidReceiveProps(). But there is no such lifecycle method. If you meant to update the state in response to changing props, use componentWillReceiveProps(). If you meant to fetch data or run side-effects or mutations after React has updated the UI, use componentDidUpdate().",O);var Ht=typeof C.componentWillRecieveProps!="function";Ht||Ve(!1,"%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",O);var yn=typeof C.UNSAFE_componentWillRecieveProps!="function";yn||Ve(!1,"%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",O);var kr=C.props!==D;C.props===void 0||!kr||Ve(!1,"%s(...): When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.",O,O);var ii=!C.defaultProps;ii||Ve(!1,"Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.",O,O),typeof C.getSnapshotBeforeUpdate=="function"&&typeof C.componentDidUpdate!="function"&&!Ir.has(d)&&(Ir.add(d),Ve(!1,"%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.",qt(d)));var Oi=typeof C.getDerivedStateFromProps!="function";Oi||Ve(!1,"%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.",O);var L0=typeof C.getDerivedStateFromError!="function";L0||Ve(!1,"%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.",O);var $i=typeof d.getSnapshotBeforeUpdate!="function";$i||Ve(!1,"%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.",O);var lt=C.state;lt&&(typeof lt!="object"||sd(lt))&&Ve(!1,"%s.state: must be set to an object or null",O),typeof C.getChildContext=="function"&&typeof d.childContextTypes!="object"&&Ve(!1,"%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().",O)}}function al(c,d){d.updater=Xc,c.stateNode=d,Jt(d,c),d._reactInternalInstance=kl}function ha(c,d,D,C){var O=!1,z=xn,G=xn,ne=d.contextType;if("contextType"in d){var se=ne===null||ne!==void 0&&ne.$$typeof===nn&&ne._context===void 0;if(!se&&!sl.has(d)){sl.add(d);var Ue="";ne===void 0?Ue=" However, it is set to undefined. This can be caused by a typo or by mixing up named and default imports. This can also happen due to a circular dependency, so try moving the createContext() call to a separate file.":typeof ne!="object"?Ue=" However, it is set to a "+typeof ne+".":ne.$$typeof===At?Ue=" Did you accidentally pass the Context.Provider instead?":ne._context!==void 0?Ue=" Did you accidentally pass the Context.Consumer instead?":Ue=" However, it is set to an object with keys {"+Object.keys(ne).join(", ")+"}.",Ve(!1,"%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s",qt(d)||"Component",Ue)}}if(typeof ne=="object"&&ne!==null)G=Ge(ne);else if(!li){z=Cl(c,d,!0);var Xe=d.contextTypes;O=Xe!=null,G=O?Wu(c,z):xn}Ri&&c.mode&mr&&new d(D,G);var ht=new d(D,G),Lt=c.memoizedState=ht.state!==null&&ht.state!==void 0?ht.state:null;al(c,ht);{if(typeof d.getDerivedStateFromProps=="function"&&Lt===null){var Gt=qt(d)||"Component";Yc.has(Gt)||(Yc.add(Gt),Ve(!1,"`%s` uses `getDerivedStateFromProps` but its initial state is %s. This is not recommended. Instead, define the initial state by assigning an object to `this.state` in the constructor of `%s`. This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",Gt,ht.state===null?"null":"undefined",Gt))}if(typeof d.getDerivedStateFromProps=="function"||typeof ht.getSnapshotBeforeUpdate=="function"){var Ht=null,yn=null,kr=null;if(typeof ht.componentWillMount=="function"&&ht.componentWillMount.__suppressDeprecationWarning!==!0?Ht="componentWillMount":typeof ht.UNSAFE_componentWillMount=="function"&&(Ht="UNSAFE_componentWillMount"),typeof ht.componentWillReceiveProps=="function"&&ht.componentWillReceiveProps.__suppressDeprecationWarning!==!0?yn="componentWillReceiveProps":typeof ht.UNSAFE_componentWillReceiveProps=="function"&&(yn="UNSAFE_componentWillReceiveProps"),typeof ht.componentWillUpdate=="function"&&ht.componentWillUpdate.__suppressDeprecationWarning!==!0?kr="componentWillUpdate":typeof ht.UNSAFE_componentWillUpdate=="function"&&(kr="UNSAFE_componentWillUpdate"),Ht!==null||yn!==null||kr!==null){var ii=qt(d)||"Component",Oi=typeof d.getDerivedStateFromProps=="function"?"getDerivedStateFromProps()":"getSnapshotBeforeUpdate()";fd.has(ii)||(fd.add(ii),Ve(!1,`Unsafe legacy lifecycles will not be called for components using new component APIs.
+
+%s uses %s but also contains the following legacy lifecycles:%s%s%s
+
+The above lifecycles should be removed. Learn more about this warning here:
+https://fb.me/react-unsafe-component-lifecycles`,ii,Oi,Ht!==null?`
+  `+Ht:"",yn!==null?`
+  `+yn:"",kr!==null?`
+  `+kr:""))}}}return O&&zs(c,z,G),ht}function x2(c,d){Bi(c,"componentWillMount");var D=d.state;typeof d.componentWillMount=="function"&&d.componentWillMount(),typeof d.UNSAFE_componentWillMount=="function"&&d.UNSAFE_componentWillMount(),Ci(),D!==d.state&&(Ve(!1,"%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",qt(c.type)||"Component"),Xc.enqueueReplaceState(d,d.state,null))}function R2(c,d,D,C){var O=d.state;if(Bi(c,"componentWillReceiveProps"),typeof d.componentWillReceiveProps=="function"&&d.componentWillReceiveProps(D,C),typeof d.UNSAFE_componentWillReceiveProps=="function"&&d.UNSAFE_componentWillReceiveProps(D,C),Ci(),d.state!==O){{var z=qt(c.type)||"Component";S2.has(z)||(S2.add(z),Ve(!1,"%s.componentWillReceiveProps(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",z))}Xc.enqueueReplaceState(d,d.state,null)}}function hc(c,d,D,C){gh(c,d,D);var O=c.stateNode;O.props=D,O.state=c.memoizedState,O.refs=ad;var z=d.contextType;if(typeof z=="object"&&z!==null)O.context=Ge(z);else if(li)O.context=xn;else{var G=Cl(c,d,!0);O.context=Wu(c,G)}{if(O.state===D){var ne=qt(d)||"Component";T2.has(ne)||(T2.add(ne),Ve(!1,"%s: It is not recommended to assign props directly to state because updates to props won't be reflected in state. In most cases, it is better to use props directly.",ne))}c.mode&mr&&Al.recordLegacyContextWarning(c,O),mi&&Al.recordUnsafeLifecycleWarnings(c,O)}var se=c.updateQueue;se!==null&&(wf(c,se,D,O,C),O.state=c.memoizedState);var Ue=d.getDerivedStateFromProps;typeof Ue=="function"&&(Sf(c,d,Ue,D),O.state=c.memoizedState),typeof d.getDerivedStateFromProps!="function"&&typeof O.getSnapshotBeforeUpdate!="function"&&(typeof O.UNSAFE_componentWillMount=="function"||typeof O.componentWillMount=="function")&&(x2(c,O),se=c.updateQueue,se!==null&&(wf(c,se,D,O,C),O.state=c.memoizedState)),typeof O.componentDidMount=="function"&&(c.effectTag|=Dr)}function _h(c,d,D,C){var O=c.stateNode,z=c.memoizedProps;O.props=z;var G=O.context,ne=d.contextType,se=xn;if(typeof ne=="object"&&ne!==null)se=Ge(ne);else if(!li){var Ue=Cl(c,d,!0);se=Wu(c,Ue)}var Xe=d.getDerivedStateFromProps,ht=typeof Xe=="function"||typeof O.getSnapshotBeforeUpdate=="function";!ht&&(typeof O.UNSAFE_componentWillReceiveProps=="function"||typeof O.componentWillReceiveProps=="function")&&(z!==D||G!==se)&&R2(c,O,D,se),hh();var Lt=c.memoizedState,Gt=O.state=Lt,Ht=c.updateQueue;if(Ht!==null&&(wf(c,Ht,D,O,C),Gt=c.memoizedState),z===D&&Lt===Gt&&!sa()&&!Gc())return typeof O.componentDidMount=="function"&&(c.effectTag|=Dr),!1;typeof Xe=="function"&&(Sf(c,d,Xe,D),Gt=c.memoizedState);var yn=Gc()||C2(c,d,z,D,Lt,Gt,se);return yn?(!ht&&(typeof O.UNSAFE_componentWillMount=="function"||typeof O.componentWillMount=="function")&&(Bi(c,"componentWillMount"),typeof O.componentWillMount=="function"&&O.componentWillMount(),typeof O.UNSAFE_componentWillMount=="function"&&O.UNSAFE_componentWillMount(),Ci()),typeof O.componentDidMount=="function"&&(c.effectTag|=Dr)):(typeof O.componentDidMount=="function"&&(c.effectTag|=Dr),c.memoizedProps=D,c.memoizedState=Gt),O.props=D,O.state=Gt,O.context=se,yn}function A2(c,d,D,C,O){var z=d.stateNode,G=d.memoizedProps;z.props=d.type===d.elementType?G:Wi(d.type,G);var ne=z.context,se=D.contextType,Ue=xn;if(typeof se=="object"&&se!==null)Ue=Ge(se);else if(!li){var Xe=Cl(d,D,!0);Ue=Wu(d,Xe)}var ht=D.getDerivedStateFromProps,Lt=typeof ht=="function"||typeof z.getSnapshotBeforeUpdate=="function";!Lt&&(typeof z.UNSAFE_componentWillReceiveProps=="function"||typeof z.componentWillReceiveProps=="function")&&(G!==C||ne!==Ue)&&R2(d,z,C,Ue),hh();var Gt=d.memoizedState,Ht=z.state=Gt,yn=d.updateQueue;if(yn!==null&&(wf(d,yn,C,z,O),Ht=d.memoizedState),G===C&&Gt===Ht&&!sa()&&!Gc())return typeof z.componentDidUpdate=="function"&&(G!==c.memoizedProps||Gt!==c.memoizedState)&&(d.effectTag|=Dr),typeof z.getSnapshotBeforeUpdate=="function"&&(G!==c.memoizedProps||Gt!==c.memoizedState)&&(d.effectTag|=Mo),!1;typeof ht=="function"&&(Sf(d,D,ht,C),Ht=d.memoizedState);var kr=Gc()||C2(d,D,G,C,Gt,Ht,Ue);return kr?(!Lt&&(typeof z.UNSAFE_componentWillUpdate=="function"||typeof z.componentWillUpdate=="function")&&(Bi(d,"componentWillUpdate"),typeof z.componentWillUpdate=="function"&&z.componentWillUpdate(C,Ht,Ue),typeof z.UNSAFE_componentWillUpdate=="function"&&z.UNSAFE_componentWillUpdate(C,Ht,Ue),Ci()),typeof z.componentDidUpdate=="function"&&(d.effectTag|=Dr),typeof z.getSnapshotBeforeUpdate=="function"&&(d.effectTag|=Mo)):(typeof z.componentDidUpdate=="function"&&(G!==c.memoizedProps||Gt!==c.memoizedState)&&(d.effectTag|=Dr),typeof z.getSnapshotBeforeUpdate=="function"&&(G!==c.memoizedProps||Gt!==c.memoizedState)&&(d.effectTag|=Mo),d.memoizedProps=C,d.memoizedState=Ht),z.props=C,z.state=Ht,z.context=Ue,kr}var dd,Qc,Jc,Ws,O2,va=function(c){};dd=!1,Qc=!1,Jc={},Ws={},O2={},va=function(c){if(!(c===null||typeof c!="object")&&!(!c._store||c._store.validated||c.key!=null)){if(typeof c._store!="object")throw Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.");c._store.validated=!0;var d='Each child in a list should have a unique "key" prop. See https://fb.me/react-warning-keys for more information.'+Lr();Ws[d]||(Ws[d]=!0,Xt(!1,'Each child in a list should have a unique "key" prop. See https://fb.me/react-warning-keys for more information.'))}};var Zc=Array.isArray;function vc(c,d,D){var C=D.ref;if(C!==null&&typeof C!="function"&&typeof C!="object"){if(c.mode&mr||ko){var O=qt(c.type)||"Component";Jc[O]||(ko?Ve(!1,'Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. We recommend using useRef() or createRef() instead. Learn more about using refs safely here: https://fb.me/react-strict-mode-string-ref%s',O,C,Cr(c)):Ve(!1,'A string ref, "%s", has been found within a strict mode tree. String refs are a source of potential bugs and should be avoided. We recommend using useRef() or createRef() instead. Learn more about using refs safely here: https://fb.me/react-strict-mode-string-ref%s',C,Cr(c)),Jc[O]=!0)}if(D._owner){var z=D._owner,G;if(z){var ne=z;if(ne.tag!==k)throw Error("Function components cannot have refs. Did you mean to use React.forwardRef()?");G=ne.stateNode}if(!G)throw Error("Missing owner for string ref "+C+". This error is likely caused by a bug in React. Please file an issue.");var se=""+C;if(d!==null&&d.ref!==null&&typeof d.ref=="function"&&d.ref._stringRef===se)return d.ref;var Ue=function(Xe){var ht=G.refs;ht===ad&&(ht=G.refs={}),Xe===null?delete ht[se]:ht[se]=Xe};return Ue._stringRef=se,Ue}else{if(typeof C!="string")throw Error("Expected ref to be a function, a string, an object returned by React.createRef(), or null.");if(!D._owner)throw Error("Element ref was specified as a string ("+C+`) but no owner was set. This could happen for one of the following reasons:
+1. You may be adding a ref to a function component
+2. You may be adding a ref to a component that was not created inside a component's render method
+3. You have multiple copies of React loaded
+See https://fb.me/react-refs-must-have-owner for more information.`)}}return C}function mc(c,d){if(c.type!=="textarea"){var D="";throw D=" If you meant to render a collection of children, use an array instead."+Lr(),Error("Objects are not valid as a React child (found: "+(Object.prototype.toString.call(d)==="[object Object]"?"object with keys {"+Object.keys(d).join(", ")+"}":d)+")."+D)}}function pd(){var c="Functions are not valid as a React child. This may happen if you return a Component instead of <Component /> from render. Or maybe you meant to call this function rather than return it."+Lr();O2[c]||(O2[c]=!0,Xt(!1,"Functions are not valid as a React child. This may happen if you return a Component instead of <Component /> from render. Or maybe you meant to call this function rather than return it."))}function Eh(c){function d(lt,Mt){if(!!c){var $e=lt.lastEffect;$e!==null?($e.nextEffect=Mt,lt.lastEffect=Mt):lt.firstEffect=lt.lastEffect=Mt,Mt.nextEffect=null,Mt.effectTag=Y0}}function D(lt,Mt){if(!c)return null;for(var $e=Mt;$e!==null;)d(lt,$e),$e=$e.sibling;return null}function C(lt,Mt){for(var $e=new Map,jt=Mt;jt!==null;)jt.key!==null?$e.set(jt.key,jt):$e.set(jt.index,jt),jt=jt.sibling;return $e}function O(lt,Mt,$e){var jt=Co(lt,Mt,$e);return jt.index=0,jt.sibling=null,jt}function z(lt,Mt,$e){if(lt.index=$e,!c)return Mt;var jt=lt.alternate;if(jt!==null){var Fn=jt.index;return Fn<Mt?(lt.effectTag=vi,Mt):Fn}else return lt.effectTag=vi,Mt}function G(lt){return c&&lt.alternate===null&&(lt.effectTag=vi),lt}function ne(lt,Mt,$e,jt){if(Mt===null||Mt.tag!==re){var Fn=_y($e,lt.mode,jt);return Fn.return=lt,Fn}else{var vn=O(Mt,$e,jt);return vn.return=lt,vn}}function se(lt,Mt,$e,jt){if(Mt!==null&&(Mt.elementType===$e.type||Wc(Mt,$e))){var Fn=O(Mt,$e.props,jt);return Fn.ref=vc(lt,Mt,$e),Fn.return=lt,Fn._debugSource=$e._source,Fn._debugOwner=$e._owner,Fn}else{var vn=gy($e,lt.mode,jt);return vn.ref=vc(lt,Mt,$e),vn.return=lt,vn}}function Ue(lt,Mt,$e,jt){if(Mt===null||Mt.tag!==q||Mt.stateNode.containerInfo!==$e.containerInfo||Mt.stateNode.implementation!==$e.implementation){var Fn=Ey($e,lt.mode,jt);return Fn.return=lt,Fn}else{var vn=O(Mt,$e.children||[],jt);return vn.return=lt,vn}}function Xe(lt,Mt,$e,jt,Fn){if(Mt===null||Mt.tag!==y){var vn=nf($e,lt.mode,jt,Fn);return vn.return=lt,vn}else{var Vi=O(Mt,$e,jt);return Vi.return=lt,Vi}}function ht(lt,Mt,$e){if(typeof Mt=="string"||typeof Mt=="number"){var jt=_y(""+Mt,lt.mode,$e);return jt.return=lt,jt}if(typeof Mt=="object"&&Mt!==null){switch(Mt.$$typeof){case ce:{var Fn=gy(Mt,lt.mode,$e);return Fn.ref=vc(lt,null,Mt),Fn.return=lt,Fn}case Re:{var vn=Ey(Mt,lt.mode,$e);return vn.return=lt,vn}}if(Zc(Mt)||fr(Mt)){var Vi=nf(Mt,lt.mode,$e,null);return Vi.return=lt,Vi}mc(lt,Mt)}return typeof Mt=="function"&&pd(),null}function Lt(lt,Mt,$e,jt){var Fn=Mt!==null?Mt.key:null;if(typeof $e=="string"||typeof $e=="number")return Fn!==null?null:ne(lt,Mt,""+$e,jt);if(typeof $e=="object"&&$e!==null){switch($e.$$typeof){case ce:return $e.key===Fn?$e.type===le?Xe(lt,Mt,$e.props.children,jt,Fn):se(lt,Mt,$e,jt):null;case Re:return $e.key===Fn?Ue(lt,Mt,$e,jt):null}if(Zc($e)||fr($e))return Fn!==null?null:Xe(lt,Mt,$e,jt,null);mc(lt,$e)}return typeof $e=="function"&&pd(),null}function Gt(lt,Mt,$e,jt,Fn){if(typeof jt=="string"||typeof jt=="number"){var vn=lt.get($e)||null;return ne(Mt,vn,""+jt,Fn)}if(typeof jt=="object"&&jt!==null){switch(jt.$$typeof){case ce:{var Vi=lt.get(jt.key===null?$e:jt.key)||null;return jt.type===le?Xe(Mt,Vi,jt.props.children,Fn,jt.key):se(Mt,Vi,jt,Fn)}case Re:{var ci=lt.get(jt.key===null?$e:jt.key)||null;return Ue(Mt,ci,jt,Fn)}}if(Zc(jt)||fr(jt)){var Yu=lt.get($e)||null;return Xe(Mt,Yu,jt,Fn,null)}mc(Mt,jt)}return typeof jt=="function"&&pd(),null}function Ht(lt,Mt){{if(typeof lt!="object"||lt===null)return Mt;switch(lt.$$typeof){case ce:case Re:va(lt);var $e=lt.key;if(typeof $e!="string")break;if(Mt===null){Mt=new Set,Mt.add($e);break}if(!Mt.has($e)){Mt.add($e);break}Xt(!1,"Encountered two children with the same key, `%s`. Keys should be unique so that components maintain their identity across updates. Non-unique keys may cause children to be duplicated and/or omitted \u2014 the behavior is unsupported and could change in a future version.",$e);break;default:break}}return Mt}function yn(lt,Mt,$e,jt){for(var Fn=null,vn=0;vn<$e.length;vn++){var Vi=$e[vn];Fn=Ht(Vi,Fn)}for(var ci=null,Yu=null,hr=Mt,pu=0,Yr=0,Cu=null;hr!==null&&Yr<$e.length;Yr++){hr.index>Yr?(Cu=hr,hr=null):Cu=hr.sibling;var D0=Lt(lt,hr,$e[Yr],jt);if(D0===null){hr===null&&(hr=Cu);break}c&&hr&&D0.alternate===null&&d(lt,hr),pu=z(D0,pu,Yr),Yu===null?ci=D0:Yu.sibling=D0,Yu=D0,hr=Cu}if(Yr===$e.length)return D(lt,hr),ci;if(hr===null){for(;Yr<$e.length;Yr++){var W0=ht(lt,$e[Yr],jt);W0!==null&&(pu=z(W0,pu,Yr),Yu===null?ci=W0:Yu.sibling=W0,Yu=W0)}return ci}for(var Ms=C(lt,hr);Yr<$e.length;Yr++){var Ku=Gt(Ms,lt,Yr,$e[Yr],jt);Ku!==null&&(c&&Ku.alternate!==null&&Ms.delete(Ku.key===null?Yr:Ku.key),pu=z(Ku,pu,Yr),Yu===null?ci=Ku:Yu.sibling=Ku,Yu=Ku)}return c&&Ms.forEach(function(gl){return d(lt,gl)}),ci}function kr(lt,Mt,$e,jt){var Fn=fr($e);if(typeof Fn!="function")throw Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");{typeof Symbol=="function"&&$e[Symbol.toStringTag]==="Generator"&&(Qc||Xt(!1,"Using Generators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. Keep in mind you might need to polyfill these features for older browsers."),Qc=!0),$e.entries===Fn&&(dd||Xt(!1,"Using Maps as children is unsupported and will likely yield unexpected results. Convert it to a sequence/iterable of keyed ReactElements instead."),dd=!0);var vn=Fn.call($e);if(vn)for(var Vi=null,ci=vn.next();!ci.done;ci=vn.next()){var Yu=ci.value;Vi=Ht(Yu,Vi)}}var hr=Fn.call($e);if(hr==null)throw Error("An iterable object provided no iterator.");for(var pu=null,Yr=null,Cu=Mt,D0=0,W0=0,Ms=null,Ku=hr.next();Cu!==null&&!Ku.done;W0++,Ku=hr.next()){Cu.index>W0?(Ms=Cu,Cu=null):Ms=Cu.sibling;var gl=Lt(lt,Cu,Ku.value,jt);if(gl===null){Cu===null&&(Cu=Ms);break}c&&Cu&&gl.alternate===null&&d(lt,Cu),D0=z(gl,D0,W0),Yr===null?pu=gl:Yr.sibling=gl,Yr=gl,Cu=Ms}if(Ku.done)return D(lt,Cu),pu;if(Cu===null){for(;!Ku.done;W0++,Ku=hr.next()){var rf=ht(lt,Ku.value,jt);rf!==null&&(D0=z(rf,D0,W0),Yr===null?pu=rf:Yr.sibling=rf,Yr=rf)}return pu}for(var Vo=C(lt,Cu);!Ku.done;W0++,Ku=hr.next()){var ks=Gt(Vo,lt,W0,Ku.value,jt);ks!==null&&(c&&ks.alternate!==null&&Vo.delete(ks.key===null?W0:ks.key),D0=z(ks,D0,W0),Yr===null?pu=ks:Yr.sibling=ks,Yr=ks)}return c&&Vo.forEach(function(Jd){return d(lt,Jd)}),pu}function ii(lt,Mt,$e,jt){if(Mt!==null&&Mt.tag===re){D(lt,Mt.sibling);var Fn=O(Mt,$e,jt);return Fn.return=lt,Fn}D(lt,Mt);var vn=_y($e,lt.mode,jt);return vn.return=lt,vn}function Oi(lt,Mt,$e,jt){for(var Fn=$e.key,vn=Mt;vn!==null;){if(vn.key===Fn)if(vn.tag===y?$e.type===le:vn.elementType===$e.type||Wc(vn,$e)){D(lt,vn.sibling);var Vi=O(vn,$e.type===le?$e.props.children:$e.props,jt);return Vi.ref=vc(lt,vn,$e),Vi.return=lt,Vi._debugSource=$e._source,Vi._debugOwner=$e._owner,Vi}else{D(lt,vn);break}else d(lt,vn);vn=vn.sibling}if($e.type===le){var ci=nf($e.props.children,lt.mode,jt,$e.key);return ci.return=lt,ci}else{var Yu=gy($e,lt.mode,jt);return Yu.ref=vc(lt,Mt,$e),Yu.return=lt,Yu}}function L0(lt,Mt,$e,jt){for(var Fn=$e.key,vn=Mt;vn!==null;){if(vn.key===Fn)if(vn.tag===q&&vn.stateNode.containerInfo===$e.containerInfo&&vn.stateNode.implementation===$e.implementation){D(lt,vn.sibling);var Vi=O(vn,$e.children||[],jt);return Vi.return=lt,Vi}else{D(lt,vn);break}else d(lt,vn);vn=vn.sibling}var ci=Ey($e,lt.mode,jt);return ci.return=lt,ci}function $i(lt,Mt,$e,jt){var Fn=typeof $e=="object"&&$e!==null&&$e.type===le&&$e.key===null;Fn&&($e=$e.props.children);var vn=typeof $e=="object"&&$e!==null;if(vn)switch($e.$$typeof){case ce:return G(Oi(lt,Mt,$e,jt));case Re:return G(L0(lt,Mt,$e,jt))}if(typeof $e=="string"||typeof $e=="number")return G(ii(lt,Mt,""+$e,jt));if(Zc($e))return yn(lt,Mt,$e,jt);if(fr($e))return kr(lt,Mt,$e,jt);if(vn&&mc(lt,$e),typeof $e=="function"&&pd(),typeof $e>"u"&&!Fn)switch(lt.tag){case k:{var Vi=lt.stateNode;if(Vi.render._isMockFunction)break}case F:{var ci=lt.type;throw Error((ci.displayName||ci.name||"Component")+"(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.")}}return D(lt,Mt)}return $i}var Tf=Eh(!0),$c=Eh(!1);function Dh(c,d){if(!(c===null||d.child===c.child))throw Error("Resuming work not yet implemented.");if(d.child!==null){var D=d.child,C=Co(D,D.pendingProps,D.expirationTime);for(d.child=C,C.return=d;D.sibling!==null;)D=D.sibling,C=C.sibling=Co(D,D.pendingProps,D.expirationTime),C.return=d;C.sibling=null}}function sm(c,d){for(var D=c.child;D!==null;)kv(D,d),D=D.sibling}var Vs={},ma=Qu(Vs),iu=Qu(Vs),M0=Qu(Vs);function u0(c){if(c===Vs)throw Error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.");return c}function ns(){var c=u0(M0.current);return c}function Ya(c,d){Qr(M0,d,c),Qr(iu,c,c),Qr(ma,Vs,c);var D=St(d);$r(ma,c),Qr(ma,D,c)}function uo(c){$r(ma,c),$r(iu,c),$r(M0,c)}function fl(){var c=u0(ma.current);return c}function yc(c){var d=u0(M0.current),D=u0(ma.current),C=Bt(D,c.type,d);D!==C&&(Qr(iu,c,c),Qr(ma,C,c))}function M2(c){iu.current===c&&($r(ma,c),$r(iu,c))}var wh=0,Cf=1,xf=1,e1=2,Nl=Qu(wh);function t1(c,d){return(c&d)!==0}function ya(c){return c&Cf}function hd(c,d){return c&Cf|d}function vd(c,d){return c|d}function Fr(c,d){Qr(Nl,d,c)}function ga(c){$r(Nl,c)}function k2(c,d){var D=c.memoizedState;if(D!==null)return D.dehydrated!==null;var C=c.memoizedProps;return C.fallback===void 0?!1:C.unstable_avoidThisFallback!==!0?!0:!d}function n1(c){for(var d=c;d!==null;){if(d.tag===he){var D=d.memoizedState;if(D!==null){var C=D.dehydrated;if(C===null||Bs(C)||m0(C))return d}}else if(d.tag===gt&&d.memoizedProps.revealOrder!==void 0){var O=(d.effectTag&Kr)!==xi;if(O)return d}else if(d.child!==null){d.child.return=d,d=d.child;continue}if(d===c)return null;for(;d.sibling===null;){if(d.return===null||d.return===c)return null;d=d.return}d.sibling.return=d.return,d=d.sibling}return null}var md={},wi=Array.isArray;function N2(c,d,D,C){return{fiber:C,props:d,responder:c,rootEventTypes:null,state:D}}function am(c,d,D,C,O){var z=md,G=c.getInitialState;G!==null&&(z=G(d));var ne=N2(c,d,z,D);if(!O)for(var se=D;se!==null;){var Ue=se.tag;if(Ue===V){O=se.stateNode;break}else if(Ue===j){O=se.stateNode.containerInfo;break}se=se.return}Fe(c,ne,d,z,O),C.set(c,ne)}function yd(c,d,D,C,O){var z,G;if(c&&(z=c.responder,G=c.props),!(z&&z.$$typeof===zt))throw Error("An invalid value was used as an event listener. Expect one or many event listeners created via React.unstable_useResponder().");var ne=G;if(D.has(z)){Xt(!1,'Duplicate event responder "%s" found in event listeners. Event listeners passed to elements cannot use the same event responder more than once.',z.displayName);return}D.add(z);var se=C.get(z);se===void 0?am(z,ne,d,C,O):(se.props=ne,se.fiber=d)}function hn(c,d,D){var C=new Set,O=d.dependencies;if(c!=null){O===null&&(O=d.dependencies={expirationTime:ft,firstContext:null,responders:new Map});var z=O.responders;if(z===null&&(z=new Map),wi(c))for(var G=0,ne=c.length;G<ne;G++){var se=c[G];yd(se,d,C,z,D)}else yd(c,d,C,z,D)}if(O!==null){var Ue=O.responders;if(Ue!==null)for(var Xe=Array.from(Ue.keys()),ht=0,Lt=Xe.length;ht<Lt;ht++){var Gt=Xe[ht];if(!C.has(Gt)){var Ht=Ue.get(Gt);Le(Ht),Ue.delete(Gt)}}}}function Rf(c,d){var D={responder:c,props:d};return Object.freeze(D),D}var Af=0,fm=2,Of=4,Sh=8,cm=16,cl=32,r1=64,sr=128,qn=it.ReactCurrentDispatcher,qo=it.ReactCurrentBatchConfig,yr;yr=new Set;var Vn=ft,dl=null,jn=null,Eo=null,gc=null,oo=null,Ka=null,Pu=ft,rs=null,Mf=0,_c=!1,Cs=null,Ec=0,Th=25,cn=null,is=null,Do=-1,lo=!1;function Ji(){{var c=cn;is===null?is=[c]:is.push(c)}}function Gr(){{var c=cn;is!==null&&(Do++,is[Do]!==c&&dm(c))}}function kf(c){c!=null&&!Array.isArray(c)&&Xt(!1,"%s received a final argument that is not an array (instead, received `%s`). When specified, the final argument must be an array.",cn,typeof c)}function dm(c){{var d=qt(dl.type);if(!yr.has(d)&&(yr.add(d),is!==null)){for(var D="",C=30,O=0;O<=Do;O++){for(var z=is[O],G=O===Do?c:z,ne=O+1+". "+z;ne.length<C;)ne+=" ";ne+=G+`
+`,D+=ne}Xt(!1,`React has detected a change in the order of Hooks called by %s. This will lead to bugs and errors if not fixed. For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks
+
+   Previous render            Next render
+   ------------------------------------------------------
+%s   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+`,d,D)}}}function Ll(){throw Error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem.`)}function Nf(c,d){if(lo)return!1;if(d===null)return Xt(!1,"%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.",cn),!1;c.length!==d.length&&Xt(!1,`The final argument passed to %s changed size between renders. The order and size of this array must remain constant.
+
+Previous: %s
+Incoming: %s`,cn,"["+d.join(", ")+"]","["+c.join(", ")+"]");for(var D=0;D<d.length&&D<c.length;D++)if(!yo(c[D],d[D]))return!1;return!0}function Lf(c,d,D,C,O,z){Vn=z,dl=d,Eo=c!==null?c.memoizedState:null,is=c!==null?c._debugHookTypes:null,Do=-1,lo=c!==null&&c.type!==d.type,Eo!==null?qn.current=z2:is!==null?qn.current=j2:qn.current=Oh;var G=D(C,O);if(_c){do _c=!1,Ec+=1,lo=!1,Eo=c!==null?c.memoizedState:null,Ka=gc,jn=null,oo=null,rs=null,Do=-1,qn.current=z2,G=D(C,O);while(_c);Cs=null,Ec=0}qn.current=f1;var ne=dl;ne.memoizedState=gc,ne.expirationTime=Pu,ne.updateQueue=rs,ne.effectTag|=Mf,ne._debugHookTypes=is;var se=jn!==null&&jn.next!==null;if(Vn=ft,dl=null,jn=null,Eo=null,gc=null,oo=null,Ka=null,cn=null,is=null,Do=-1,Pu=ft,rs=null,Mf=0,se)throw Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");return G}function gd(c,d,D){d.updateQueue=c.updateQueue,d.effectTag&=~(F0|Dr),c.expirationTime<=D&&(c.expirationTime=ft)}function _d(){qn.current=f1,Vn=ft,dl=null,jn=null,Eo=null,gc=null,oo=null,Ka=null,is=null,Do=-1,cn=null,Pu=ft,rs=null,Mf=0,_c=!1,Cs=null,Ec=0}function Dc(){var c={memoizedState:null,baseState:null,queue:null,baseUpdate:null,next:null};return oo===null?gc=oo=c:oo=oo.next=c,oo}function i1(){if(Ka!==null)oo=Ka,Ka=oo.next,jn=Eo,Eo=jn!==null?jn.next:null;else{if(Eo===null)throw Error("Rendered more hooks than during the previous render.");jn=Eo;var c={memoizedState:jn.memoizedState,baseState:jn.baseState,queue:jn.queue,baseUpdate:jn.baseUpdate,next:null};oo===null?oo=gc=c:oo=oo.next=c,Eo=jn.next}return oo}function Xa(){return{lastEffect:null}}function L2(c,d){return typeof d=="function"?d(c):d}function Ed(c,d,D){var C=Dc(),O;D!==void 0?O=D(d):O=d,C.memoizedState=C.baseState=O;var z=C.queue={last:null,dispatch:null,lastRenderedReducer:c,lastRenderedState:O},G=z.dispatch=a1.bind(null,dl,z);return[C.memoizedState,G]}function u1(c,d,D){var C=i1(),O=C.queue;if(O===null)throw Error("Should have a queue. This is likely a bug in React. Please file an issue.");if(O.lastRenderedReducer=c,Ec>0){var z=O.dispatch;if(Cs!==null){var G=Cs.get(O);if(G!==void 0){Cs.delete(O);var ne=C.memoizedState,se=G;do{var Ue=se.action;ne=c(ne,Ue),se=se.next}while(se!==null);return yo(ne,C.memoizedState)||op(),C.memoizedState=ne,C.baseUpdate===O.last&&(C.baseState=ne),O.lastRenderedState=ne,[ne,z]}}return[C.memoizedState,z]}var Xe=O.last,ht=C.baseUpdate,Lt=C.baseState,Gt;if(ht!==null?(Xe!==null&&(Xe.next=null),Gt=ht.next):Gt=Xe!==null?Xe.next:null,Gt!==null){var Ht=Lt,yn=null,kr=null,ii=ht,Oi=Gt,L0=!1;do{var $i=Oi.expirationTime;if($i<Vn)L0||(L0=!0,kr=ii,yn=Ht),$i>Pu&&(Pu=$i,Kd(Pu));else if(gv($i,Oi.suspenseConfig),Oi.eagerReducer===c)Ht=Oi.eagerState;else{var lt=Oi.action;Ht=c(Ht,lt)}ii=Oi,Oi=Oi.next}while(Oi!==null&&Oi!==Gt);L0||(kr=ii,yn=Ht),yo(Ht,C.memoizedState)||op(),C.memoizedState=Ht,C.baseUpdate=kr,C.baseState=yn,O.lastRenderedState=Ht}var Mt=O.dispatch;return[C.memoizedState,Mt]}function Ff(c){var d=Dc();typeof c=="function"&&(c=c()),d.memoizedState=d.baseState=c;var D=d.queue={last:null,dispatch:null,lastRenderedReducer:L2,lastRenderedState:c},C=D.dispatch=a1.bind(null,dl,D);return[d.memoizedState,C]}function o1(c){return u1(L2,c)}function Qa(c,d,D,C){var O={tag:c,create:d,destroy:D,deps:C,next:null};if(rs===null)rs=Xa(),rs.lastEffect=O.next=O;else{var z=rs.lastEffect;if(z===null)rs.lastEffect=O.next=O;else{var G=z.next;z.next=O,O.next=G,rs.lastEffect=O}}return O}function l1(c){var d=Dc(),D={current:c};return Object.seal(D),d.memoizedState=D,D}function F2(c){var d=i1();return d.memoizedState}function Dd(c,d,D,C){var O=Dc(),z=C===void 0?null:C;Mf|=c,O.memoizedState=Qa(d,D,void 0,z)}function wc(c,d,D,C){var O=i1(),z=C===void 0?null:C,G=void 0;if(jn!==null){var ne=jn.memoizedState;if(G=ne.destroy,z!==null){var se=ne.deps;if(Nf(z,se)){Qa(Af,D,G,z);return}}}Mf|=c,O.memoizedState=Qa(d,D,G,z)}function s1(c,d){return typeof jest<"u"&&Mv(dl),Dd(Dr|F0,sr|r1,c,d)}function Fl(c,d){return typeof jest<"u"&&Mv(dl),wc(Dr|F0,sr|r1,c,d)}function Ea(c,d){return Dd(Dr,Of|cl,c,d)}function Ch(c,d){return wc(Dr,Of|cl,c,d)}function P2(c,d){if(typeof d=="function"){var D=d,C=c();return D(C),function(){D(null)}}else if(d!=null){var O=d;O.hasOwnProperty("current")||Xt(!1,"Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.","an object with keys {"+Object.keys(O).join(", ")+"}");var z=c();return O.current=z,function(){O.current=null}}}function I2(c,d,D){typeof d!="function"&&Xt(!1,"Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.",d!==null?typeof d:"null");var C=D!=null?D.concat([c]):null;return Dd(Dr,Of|cl,P2.bind(null,d,c),C)}function xh(c,d,D){typeof d!="function"&&Xt(!1,"Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.",d!==null?typeof d:"null");var C=D!=null?D.concat([c]):null;return wc(Dr,Of|cl,P2.bind(null,d,c),C)}function pm(c,d){}var Rh=pm;function Pl(c,d){var D=Dc(),C=d===void 0?null:d;return D.memoizedState=[c,C],c}function us(c,d){var D=i1(),C=d===void 0?null:d,O=D.memoizedState;if(O!==null&&C!==null){var z=O[1];if(Nf(C,z))return O[0]}return D.memoizedState=[c,C],c}function xs(c,d){var D=Dc(),C=d===void 0?null:d,O=c();return D.memoizedState=[O,C],O}function Gs(c,d){var D=i1(),C=d===void 0?null:d,O=D.memoizedState;if(O!==null&&C!==null){var z=O[1];if(Nf(C,z))return O[0]}var G=c();return D.memoizedState=[G,C],G}function b2(c,d){var D=Ff(c),C=D[0],O=D[1];return s1(function(){t.unstable_next(function(){var z=qo.suspense;qo.suspense=d===void 0?null:d;try{O(c)}finally{qo.suspense=z}})},[c,d]),C}function Ah(c,d){var D=o1(c),C=D[0],O=D[1];return Fl(function(){t.unstable_next(function(){var z=qo.suspense;qo.suspense=d===void 0?null:d;try{O(c)}finally{qo.suspense=z}})},[c,d]),C}function B2(c){var d=Ff(!1),D=d[0],C=d[1],O=Pl(function(z){C(!0),t.unstable_next(function(){var G=qo.suspense;qo.suspense=c===void 0?null:c;try{C(!1),z()}finally{qo.suspense=G}})},[c,D]);return[O,D]}function U2(c){var d=o1(!1),D=d[0],C=d[1],O=us(function(z){C(!0),t.unstable_next(function(){var G=qo.suspense;qo.suspense=c===void 0?null:c;try{C(!1),z()}finally{qo.suspense=G}})},[c,D]);return[O,D]}function a1(c,d,D){if(!(Ec<Th))throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");typeof arguments[3]=="function"&&Xt(!1,"State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");var C=c.alternate;if(c===dl||C!==null&&C===dl){_c=!0;var O={expirationTime:Vn,suspenseConfig:null,action:D,eagerReducer:null,eagerState:null,next:null};O.priority=Qt(),Cs===null&&(Cs=new Map);var z=Cs.get(d);if(z===void 0)Cs.set(d,O);else{for(var G=z;G.next!==null;)G=G.next;G.next=O}}else{var ne=jl(),se=_o(),Ue=jf(ne,c,se),Xe={expirationTime:Ue,suspenseConfig:se,action:D,eagerReducer:null,eagerState:null,next:null};Xe.priority=Qt();var ht=d.last;if(ht===null)Xe.next=Xe;else{var Lt=ht.next;Lt!==null&&(Xe.next=Lt),ht.next=Xe}if(d.last=Xe,c.expirationTime===ft&&(C===null||C.expirationTime===ft)){var Gt=d.lastRenderedReducer;if(Gt!==null){var Ht;Ht=qn.current,qn.current=Ja;try{var yn=d.lastRenderedState,kr=Gt(yn,D);if(Xe.eagerReducer=Gt,Xe.eagerState=kr,yo(kr,yn))return}catch{}finally{qn.current=Ht}}}typeof jest<"u"&&(zp(c),hy(c)),yl(c,Ue)}}var f1={readContext:Ge,useCallback:Ll,useContext:Ll,useEffect:Ll,useImperativeHandle:Ll,useLayoutEffect:Ll,useMemo:Ll,useReducer:Ll,useRef:Ll,useState:Ll,useDebugValue:Ll,useResponder:Ll,useDeferredValue:Ll,useTransition:Ll},Oh=null,j2=null,z2=null,Rs=null,Ja=null;{var Mh=function(){Xt(!1,"Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().")},du=function(){Xt(!1,"Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. You can only call Hooks at the top level of your React function. For more information, see https://fb.me/rules-of-hooks")};Oh={readContext:function(c,d){return Ge(c,d)},useCallback:function(c,d){return cn="useCallback",Ji(),kf(d),Pl(c,d)},useContext:function(c,d){return cn="useContext",Ji(),Ge(c,d)},useEffect:function(c,d){return cn="useEffect",Ji(),kf(d),s1(c,d)},useImperativeHandle:function(c,d,D){return cn="useImperativeHandle",Ji(),kf(D),I2(c,d,D)},useLayoutEffect:function(c,d){return cn="useLayoutEffect",Ji(),kf(d),Ea(c,d)},useMemo:function(c,d){cn="useMemo",Ji(),kf(d);var D=qn.current;qn.current=Rs;try{return xs(c,d)}finally{qn.current=D}},useReducer:function(c,d,D){cn="useReducer",Ji();var C=qn.current;qn.current=Rs;try{return Ed(c,d,D)}finally{qn.current=C}},useRef:function(c){return cn="useRef",Ji(),l1(c)},useState:function(c){cn="useState",Ji();var d=qn.current;qn.current=Rs;try{return Ff(c)}finally{qn.current=d}},useDebugValue:function(c,d){return cn="useDebugValue",Ji(),void 0},useResponder:function(c,d){return cn="useResponder",Ji(),Rf(c,d)},useDeferredValue:function(c,d){return cn="useDeferredValue",Ji(),b2(c,d)},useTransition:function(c){return cn="useTransition",Ji(),B2(c)}},j2={readContext:function(c,d){return Ge(c,d)},useCallback:function(c,d){return cn="useCallback",Gr(),Pl(c,d)},useContext:function(c,d){return cn="useContext",Gr(),Ge(c,d)},useEffect:function(c,d){return cn="useEffect",Gr(),s1(c,d)},useImperativeHandle:function(c,d,D){return cn="useImperativeHandle",Gr(),I2(c,d,D)},useLayoutEffect:function(c,d){return cn="useLayoutEffect",Gr(),Ea(c,d)},useMemo:function(c,d){cn="useMemo",Gr();var D=qn.current;qn.current=Rs;try{return xs(c,d)}finally{qn.current=D}},useReducer:function(c,d,D){cn="useReducer",Gr();var C=qn.current;qn.current=Rs;try{return Ed(c,d,D)}finally{qn.current=C}},useRef:function(c){return cn="useRef",Gr(),l1(c)},useState:function(c){cn="useState",Gr();var d=qn.current;qn.current=Rs;try{return Ff(c)}finally{qn.current=d}},useDebugValue:function(c,d){return cn="useDebugValue",Gr(),void 0},useResponder:function(c,d){return cn="useResponder",Gr(),Rf(c,d)},useDeferredValue:function(c,d){return cn="useDeferredValue",Gr(),b2(c,d)},useTransition:function(c){return cn="useTransition",Gr(),B2(c)}},z2={readContext:function(c,d){return Ge(c,d)},useCallback:function(c,d){return cn="useCallback",Gr(),us(c,d)},useContext:function(c,d){return cn="useContext",Gr(),Ge(c,d)},useEffect:function(c,d){return cn="useEffect",Gr(),Fl(c,d)},useImperativeHandle:function(c,d,D){return cn="useImperativeHandle",Gr(),xh(c,d,D)},useLayoutEffect:function(c,d){return cn="useLayoutEffect",Gr(),Ch(c,d)},useMemo:function(c,d){cn="useMemo",Gr();var D=qn.current;qn.current=Ja;try{return Gs(c,d)}finally{qn.current=D}},useReducer:function(c,d,D){cn="useReducer",Gr();var C=qn.current;qn.current=Ja;try{return u1(c,d,D)}finally{qn.current=C}},useRef:function(c){return cn="useRef",Gr(),F2(c)},useState:function(c){cn="useState",Gr();var d=qn.current;qn.current=Ja;try{return o1(c)}finally{qn.current=d}},useDebugValue:function(c,d){return cn="useDebugValue",Gr(),Rh(c,d)},useResponder:function(c,d){return cn="useResponder",Gr(),Rf(c,d)},useDeferredValue:function(c,d){return cn="useDeferredValue",Gr(),Ah(c,d)},useTransition:function(c){return cn="useTransition",Gr(),U2(c)}},Rs={readContext:function(c,d){return Mh(),Ge(c,d)},useCallback:function(c,d){return cn="useCallback",du(),Ji(),Pl(c,d)},useContext:function(c,d){return cn="useContext",du(),Ji(),Ge(c,d)},useEffect:function(c,d){return cn="useEffect",du(),Ji(),s1(c,d)},useImperativeHandle:function(c,d,D){return cn="useImperativeHandle",du(),Ji(),I2(c,d,D)},useLayoutEffect:function(c,d){return cn="useLayoutEffect",du(),Ji(),Ea(c,d)},useMemo:function(c,d){cn="useMemo",du(),Ji();var D=qn.current;qn.current=Rs;try{return xs(c,d)}finally{qn.current=D}},useReducer:function(c,d,D){cn="useReducer",du(),Ji();var C=qn.current;qn.current=Rs;try{return Ed(c,d,D)}finally{qn.current=C}},useRef:function(c){return cn="useRef",du(),Ji(),l1(c)},useState:function(c){cn="useState",du(),Ji();var d=qn.current;qn.current=Rs;try{return Ff(c)}finally{qn.current=d}},useDebugValue:function(c,d){return cn="useDebugValue",du(),Ji(),void 0},useResponder:function(c,d){return cn="useResponder",du(),Ji(),Rf(c,d)},useDeferredValue:function(c,d){return cn="useDeferredValue",du(),Ji(),b2(c,d)},useTransition:function(c){return cn="useTransition",du(),Ji(),B2(c)}},Ja={readContext:function(c,d){return Mh(),Ge(c,d)},useCallback:function(c,d){return cn="useCallback",du(),Gr(),us(c,d)},useContext:function(c,d){return cn="useContext",du(),Gr(),Ge(c,d)},useEffect:function(c,d){return cn="useEffect",du(),Gr(),Fl(c,d)},useImperativeHandle:function(c,d,D){return cn="useImperativeHandle",du(),Gr(),xh(c,d,D)},useLayoutEffect:function(c,d){return cn="useLayoutEffect",du(),Gr(),Ch(c,d)},useMemo:function(c,d){cn="useMemo",du(),Gr();var D=qn.current;qn.current=Ja;try{return Gs(c,d)}finally{qn.current=D}},useReducer:function(c,d,D){cn="useReducer",du(),Gr();var C=qn.current;qn.current=Ja;try{return u1(c,d,D)}finally{qn.current=C}},useRef:function(c){return cn="useRef",du(),Gr(),F2(c)},useState:function(c){cn="useState",du(),Gr();var d=qn.current;qn.current=Ja;try{return o1(c)}finally{qn.current=d}},useDebugValue:function(c,d){return cn="useDebugValue",du(),Gr(),Rh(c,d)},useResponder:function(c,d){return cn="useResponder",du(),Gr(),Rf(c,d)},useDeferredValue:function(c,d){return cn="useDeferredValue",du(),Gr(),Ah(c,d)},useTransition:function(c){return cn="useTransition",du(),Gr(),U2(c)}}}var c1=t.unstable_now,kh=0,d1=-1;function Il(){return kh}function Nh(){!en||(kh=c1())}function H2(c){!en||(d1=c1(),c.actualStartTime<0&&(c.actualStartTime=c1()))}function Lh(c){!en||(d1=-1)}function p1(c,d){if(!!en&&d1>=0){var D=c1()-d1;c.actualDuration+=D,d&&(c.selfBaseDuration=D),d1=-1}}var bl=null,Za=null,Da=!1;function q2(){Da&&Xt(!1,"We should not be hydrating here. This is a bug in React. Please file a bug.")}function W2(c){if(!Se)return!1;var d=c.stateNode.containerInfo;return Za=U(d),bl=c,Da=!0,!0}function hm(c,d){return Se?(Za=zi(d),Y2(c),Da=!0,!0):!1}function V2(c,d){switch(c.tag){case j:oe(c.stateNode.containerInfo,d);break;case V:qe(c.type,c.memoizedProps,c.stateNode,d);break}var D=U4();D.stateNode=d,D.return=c,D.effectTag=Y0,c.lastEffect!==null?(c.lastEffect.nextEffect=D,c.lastEffect=D):c.firstEffect=c.lastEffect=D}function Fh(c,d){switch(d.effectTag=d.effectTag&~su|vi,c.tag){case j:{var D=c.stateNode.containerInfo;switch(d.tag){case V:var C=d.type,O=d.pendingProps;rt(D,C,O);break;case re:var z=d.pendingProps;xt(D,z);break;case he:kt(D);break}break}case V:{var G=c.type,ne=c.memoizedProps,se=c.stateNode;switch(d.tag){case V:var Ue=d.type,Xe=d.pendingProps;bt(G,ne,se,Ue,Xe);break;case re:var ht=d.pendingProps;sn(G,ne,se,ht);break;case he:rn(G,ne,se);break}break}default:return}}function Ph(c,d){switch(c.tag){case V:{var D=c.type,C=c.pendingProps,O=pf(d,D,C);return O!==null?(c.stateNode=O,!0):!1}case re:{var z=c.pendingProps,G=bs(d,z);return G!==null?(c.stateNode=G,!0):!1}case he:{if(Ai){var ne=ba(d);if(ne!==null){var se={dehydrated:ne,retryTime:Di};c.memoizedState=se;var Ue=j4(ne);return Ue.return=c,c.child=Ue,!0}}return!1}default:return!1}}function G2(c){if(!!Da){var d=Za;if(!d){Fh(bl,c),Da=!1,bl=c;return}var D=d;if(!Ph(c,d)){if(d=zi(D),!d||!Ph(c,d)){Fh(bl,c),Da=!1,bl=c;return}V2(bl,D)}bl=c,Za=U(d)}}function vm(c,d,D){if(!Se)throw Error("Expected prepareToHydrateHostInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");var C=c.stateNode,O=H(C,c.type,c.memoizedProps,d,D,c);return c.updateQueue=O,O!==null}function mm(c){if(!Se)throw Error("Expected prepareToHydrateHostTextInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");var d=c.stateNode,D=c.memoizedProps,C=Y(d,D,c);if(C){var O=bl;if(O!==null)switch(O.tag){case j:{var z=O.stateNode.containerInfo;Je(z,d,D);break}case V:{var G=O.type,ne=O.memoizedProps,se=O.stateNode;vt(G,ne,se,d,D);break}}}return C}function Ih(c){if(!Se)throw Error("Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");var d=c.memoizedState,D=d!==null?d.dehydrated:null;if(!D)throw Error("Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue.");ee(D,c)}function ym(c){if(!Se)throw Error("Expected skipPastDehydratedSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");var d=c.memoizedState,D=d!==null?d.dehydrated:null;if(!D)throw Error("Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue.");return Ce(D)}function Y2(c){for(var d=c.return;d!==null&&d.tag!==V&&d.tag!==j&&d.tag!==he;)d=d.return;bl=d}function h1(c){if(!Se||c!==bl)return!1;if(!Da)return Y2(c),Da=!0,!1;var d=c.type;if(c.tag!==V||d!=="head"&&d!=="body"&&!Ni(d,c.memoizedProps))for(var D=Za;D;)V2(c,D),D=zi(D);return Y2(c),c.tag===he?Za=ym(c):Za=bl?zi(c.stateNode):null,!0}function v1(){!Se||(bl=null,Za=null,Da=!1)}var m1=it.ReactCurrentOwner,wa=!1,K2,Ys,Ks,Xs,X2,Sa,y1,wd,Sc,Q2;K2={},Ys={},Ks={},Xs={},X2={},Sa=!1,y1=!1,wd={},Sc={},Q2={};function wo(c,d,D,C){c===null?d.child=$c(d,null,D,C):d.child=Tf(d,c.child,D,C)}function bh(c,d,D,C){d.child=Tf(d,c.child,null,C),d.child=Tf(d,null,D,C)}function Bh(c,d,D,C,O){if(d.type!==d.elementType){var z=D.propTypes;z&&E(z,C,"prop",qt(D),Lr)}var G=D.render,ne=d.ref,se;return i0(d,O),m1.current=d,et("render"),se=Lf(c,d,G,C,ne,O),Ri&&d.mode&mr&&d.memoizedState!==null&&(se=Lf(c,d,G,C,ne,O)),et(null),c!==null&&!wa?(gd(c,d,O),Ta(c,d,O)):(d.effectTag|=lu,wo(c,d,se,O),d.child)}function Uh(c,d,D,C,O,z){if(c===null){var G=D.type;if(s0(G)&&D.compare===null&&D.defaultProps===void 0){var ne=G;return ne=n0(G),d.tag=ue,d.type=ne,$2(d,G),jh(c,d,ne,C,O,z)}{var se=G.propTypes;se&&E(se,C,"prop",qt(G),Lr)}var Ue=yy(D.type,null,C,null,d.mode,z);return Ue.ref=d.ref,Ue.return=d,d.child=Ue,Ue}{var Xe=D.type,ht=Xe.propTypes;ht&&E(ht,C,"prop",qt(Xe),Lr)}var Lt=c.child;if(O<z){var Gt=Lt.memoizedProps,Ht=D.compare;if(Ht=Ht!==null?Ht:Rl,Ht(Gt,C)&&c.ref===d.ref)return Ta(c,d,z)}d.effectTag|=lu;var yn=Co(Lt,C,z);return yn.ref=d.ref,yn.return=d,d.child=yn,yn}function jh(c,d,D,C,O,z){if(d.type!==d.elementType){var G=d.elementType;G.$$typeof===Er&&(G=Fs(G));var ne=G&&G.propTypes;ne&&E(ne,C,"prop",qt(G),Lr)}if(c!==null){var se=c.memoizedProps;if(Rl(se,C)&&c.ref===d.ref&&d.type===c.type&&(wa=!1,O<z))return Ta(c,d,z)}return J2(c,d,D,C,z)}function gm(c,d,D){var C=d.pendingProps;return wo(c,d,C,D),d.child}function zh(c,d,D){var C=d.pendingProps.children;return wo(c,d,C,D),d.child}function Hh(c,d,D){en&&(d.effectTag|=Dr);var C=d.pendingProps,O=C.children;return wo(c,d,O,D),d.child}function g1(c,d){var D=d.ref;(c===null&&D!==null||c!==null&&c.ref!==D)&&(d.effectTag|=Oo)}function J2(c,d,D,C,O){if(d.type!==d.elementType){var z=D.propTypes;z&&E(z,C,"prop",qt(D),Lr)}var G;if(!li){var ne=Cl(d,D,!0);G=Wu(d,ne)}var se;return i0(d,O),m1.current=d,et("render"),se=Lf(c,d,D,C,G,O),Ri&&d.mode&mr&&d.memoizedState!==null&&(se=Lf(c,d,D,C,G,O)),et(null),c!==null&&!wa?(gd(c,d,O),Ta(c,d,O)):(d.effectTag|=lu,wo(c,d,se,O),d.child)}function qh(c,d,D,C,O){if(d.type!==d.elementType){var z=D.propTypes;z&&E(z,C,"prop",qt(D),Lr)}var G;Xi(D)?(G=!0,qi(d)):G=!1,i0(d,O);var ne=d.stateNode,se;ne===null?(c!==null&&(c.alternate=null,d.alternate=null,d.effectTag|=vi),ha(d,D,C,O),hc(d,D,C,O),se=!0):c===null?se=_h(d,D,C,O):se=A2(c,d,D,C,O);var Ue=Z2(c,d,D,se,G,O);{var Xe=d.stateNode;Xe.props!==C&&(Sa||Xt(!1,"It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.",qt(d.type)||"a component"),Sa=!0)}return Ue}function Z2(c,d,D,C,O,z){g1(c,d);var G=(d.effectTag&Kr)!==xi;if(!C&&!G)return O&&il(d,D,!1),Ta(c,d,z);var ne=d.stateNode;m1.current=d;var se;return G&&typeof D.getDerivedStateFromError!="function"?(se=null,en&&Lh(d)):(et("render"),se=ne.render(),Ri&&d.mode&mr&&ne.render(),et(null)),d.effectTag|=lu,c!==null&&G?bh(c,d,se,z):wo(c,d,se,z),d.memoizedState=ne.state,O&&il(d,D,!0),d.child}function Wh(c){var d=c.stateNode;d.pendingContext?Hi(c,d.pendingContext,d.pendingContext!==d.context):d.context&&Hi(c,d.context,!1),Ya(c,d.containerInfo)}function _m(c,d,D){Wh(d);var C=d.updateQueue;if(C===null)throw Error("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue.");var O=d.pendingProps,z=d.memoizedState,G=z!==null?z.element:null;wf(d,C,O,null,D);var ne=d.memoizedState,se=ne.element;if(se===G)return v1(),Ta(c,d,D);var Ue=d.stateNode;if(Ue.hydrate&&W2(d)){var Xe=$c(d,null,se,D);d.child=Xe;for(var ht=Xe;ht;)ht.effectTag=ht.effectTag&~vi|su,ht=ht.sibling}else wo(c,d,se,D),v1();return d.child}function Em(c,d,D){yc(d),c===null&&G2(d);var C=d.type,O=d.pendingProps,z=c!==null?c.memoizedProps:null,G=O.children,ne=Ni(C,O);return ne?G=null:z!==null&&Ni(C,z)&&(d.effectTag|=Bu),g1(c,d),d.mode&ti&&D!==Di&&h0(C,O)?(In&&R(Di),d.expirationTime=d.childExpirationTime=Di,null):(wo(c,d,G,D),d.child)}function Pf(c,d){return c===null&&G2(d),null}function If(c,d,D,C,O){c!==null&&(c.alternate=null,d.alternate=null,d.effectTag|=vi);var z=d.pendingProps;tu(d);var G=_(D);d.type=G;var ne=d.tag=Os(G);$l(d);var se=Wi(G,z),Ue;switch(ne){case F:{$2(d,G),d.type=G=n0(G),Ue=J2(null,d,G,se,O);break}case k:{d.type=G=j0(G),Ue=qh(null,d,G,se,O);break}case ae:{d.type=G=Df(G),Ue=Bh(null,d,G,se,O);break}case ve:{if(d.type!==d.elementType){var Xe=G.propTypes;Xe&&E(Xe,se,"prop",qt(G),Lr)}Ue=Uh(null,d,G,Wi(G.type,se),C,O);break}default:{var ht="";throw G!==null&&typeof G=="object"&&G.$$typeof===Er&&(ht=" Did you wrap a component in React.lazy() more than once?"),Error("Element type is invalid. Received a promise that resolves to: "+G+". Lazy element type must resolve to a class or function."+ht)}}return Ue}function Sd(c,d,D,C,O){c!==null&&(c.alternate=null,d.alternate=null,d.effectTag|=vi),d.tag=k;var z;return Xi(D)?(z=!0,qi(d)):z=!1,i0(d,O),ha(d,D,C,O),hc(d,D,C,O),Z2(null,d,D,!0,z,O)}function Dm(c,d,D,C){c!==null&&(c.alternate=null,d.alternate=null,d.effectTag|=vi);var O=d.pendingProps,z;if(!li){var G=Cl(d,D,!1);z=Wu(d,G)}i0(d,C);var ne;{if(D.prototype&&typeof D.prototype.render=="function"){var se=qt(D)||"Unknown";K2[se]||(Ve(!1,"The <%s /> component appears to have a render method, but doesn't extend React.Component. This is likely to cause errors. Change %s to extend React.Component instead.",se,se),K2[se]=!0)}d.mode&mr&&Al.recordLegacyContextWarning(d,null),m1.current=d,ne=Lf(null,d,D,O,z,C)}if(d.effectTag|=lu,typeof ne=="object"&&ne!==null&&typeof ne.render=="function"&&ne.$$typeof===void 0){{var Ue=qt(D)||"Unknown";Ys[Ue]||(Ve(!1,"The <%s /> component appears to be a function component that returns a class instance. Change %s to a class that extends React.Component instead. If you can't use a class try assigning the prototype on the function as a workaround. `%s.prototype = React.Component.prototype`. Don't use an arrow function since it cannot be called with `new` by React.",Ue,Ue,Ue),Ys[Ue]=!0)}d.tag=k,_d();var Xe=!1;Xi(D)?(Xe=!0,qi(d)):Xe=!1,d.memoizedState=ne.state!==null&&ne.state!==void 0?ne.state:null;var ht=D.getDerivedStateFromProps;return typeof ht=="function"&&Sf(d,D,ht,O),al(d,ne),hc(d,D,O,C),Z2(null,d,D,!0,Xe,C)}else return d.tag=F,li&&D.contextTypes&&Ve(!1,"%s uses the legacy contextTypes API which is no longer supported. Use React.createContext() with React.useContext() instead.",qt(D)||"Unknown"),Ri&&d.mode&mr&&d.memoizedState!==null&&(ne=Lf(null,d,D,O,z,C)),wo(null,d,ne,C),$2(d,D),d.child}function $2(c,d){if(d&&d.childContextTypes&&Ve(!1,"%s(...): childContextTypes cannot be defined on a function component.",d.displayName||d.name||"Component"),c.ref!==null){var D="",C=y0();C&&(D+=`
+
+Check the render method of \``+C+"`.");var O=C||c._debugID||"",z=c._debugSource;z&&(O=z.fileName+":"+z.lineNumber),X2[O]||(X2[O]=!0,Xt(!1,"Function components cannot be given refs. Attempts to access this ref will fail. Did you mean to use React.forwardRef()?%s",D))}if(Xl&&d.defaultProps!==void 0){var G=qt(d)||"Unknown";Q2[G]||(Ve(!1,"%s: Support for defaultProps will be removed from function components in a future major release. Use JavaScript default parameters instead.",G),Q2[G]=!0)}if(typeof d.getDerivedStateFromProps=="function"){var ne=qt(d)||"Unknown";Xs[ne]||(Ve(!1,"%s: Function components do not support getDerivedStateFromProps.",ne),Xs[ne]=!0)}if(typeof d.contextType=="object"&&d.contextType!==null){var se=qt(d)||"Unknown";Ks[se]||(Ve(!1,"%s: Function components do not support contextType.",se),Ks[se]=!0)}}var Td={dehydrated:null,retryTime:ft};function ep(c,d,D){return t1(c,e1)&&(d===null||d.memoizedState!==null)}function Vh(c,d,D){var C=d.mode,O=d.pendingProps;Jg(d)&&(d.effectTag|=Kr);var z=Nl.current,G=!1,ne=(d.effectTag&Kr)!==xi;if(ne||ep(z,c,d)?(G=!0,d.effectTag&=~Kr):(c===null||c.memoizedState!==null)&&O.fallback!==void 0&&O.unstable_avoidThisFallback!==!0&&(z=vd(z,xf)),z=ya(z),Fr(d,z),"maxDuration"in O&&(y1||(y1=!0,Xt(!1,"maxDuration has been removed from React. Remove the maxDuration prop."))),c===null){if(O.fallback!==void 0&&(G2(d),Ai)){var se=d.memoizedState;if(se!==null){var Ue=se.dehydrated;if(Ue!==null)return Gh(d,Ue,D)}}if(G){var Xe=O.fallback,ht=nf(null,C,ft,null);if(ht.return=d,(d.mode&K)===Ar){var Lt=d.memoizedState,Gt=Lt!==null?d.child.child:d.child;ht.child=Gt;for(var Ht=Gt;Ht!==null;)Ht.return=ht,Ht=Ht.sibling}var yn=nf(Xe,C,D,null);return yn.return=d,ht.sibling=yn,d.memoizedState=Td,d.child=ht,yn}else{var kr=O.children;return d.memoizedState=null,d.child=$c(d,null,kr,D)}}else{var ii=c.memoizedState;if(ii!==null){if(Ai){var Oi=ii.dehydrated;if(Oi!==null)if(ne){if(d.memoizedState!==null)return d.child=c.child,d.effectTag|=Kr,null;var L0=O.fallback,$i=nf(null,C,ft,null);if($i.return=d,$i.child=null,(d.mode&K)===Ar)for(var lt=$i.child=d.child;lt!==null;)lt.return=$i,lt=lt.sibling;else Tf(d,c.child,null,D);if(en&&d.mode&ni){for(var Mt=0,$e=$i.child;$e!==null;)Mt+=$e.treeBaseDuration,$e=$e.sibling;$i.treeBaseDuration=Mt}var jt=nf(L0,C,D,null);return jt.return=d,$i.sibling=jt,jt.effectTag|=vi,$i.childExpirationTime=ft,d.memoizedState=Td,d.child=$i,jt}else return Yh(c,d,Oi,ii,D)}var Fn=c.child,vn=Fn.sibling;if(G){var Vi=O.fallback,ci=Co(Fn,Fn.pendingProps,ft);if(ci.return=d,(d.mode&K)===Ar){var Yu=d.memoizedState,hr=Yu!==null?d.child.child:d.child;if(hr!==Fn.child){ci.child=hr;for(var pu=hr;pu!==null;)pu.return=ci,pu=pu.sibling}}if(en&&d.mode&ni){for(var Yr=0,Cu=ci.child;Cu!==null;)Yr+=Cu.treeBaseDuration,Cu=Cu.sibling;ci.treeBaseDuration=Yr}var D0=Co(vn,Vi,vn.expirationTime);return D0.return=d,ci.sibling=D0,ci.childExpirationTime=ft,d.memoizedState=Td,d.child=ci,D0}else{var W0=O.children,Ms=Fn.child,Ku=Tf(d,Ms,W0,D);return d.memoizedState=null,d.child=Ku}}else{var gl=c.child;if(G){var rf=O.fallback,Vo=nf(null,C,ft,null);if(Vo.return=d,Vo.child=gl,gl!==null&&(gl.return=Vo),(d.mode&K)===Ar){var ks=d.memoizedState,Jd=ks!==null?d.child.child:d.child;Vo.child=Jd;for(var Vf=Jd;Vf!==null;)Vf.return=Vo,Vf=Vf.sibling}if(en&&d.mode&ni){for(var Lc=0,Hl=Vo.child;Hl!==null;)Lc+=Hl.treeBaseDuration,Hl=Hl.sibling;Vo.treeBaseDuration=Lc}var Go=nf(rf,C,D,null);return Go.return=d,Vo.sibling=Go,Go.effectTag|=vi,Vo.childExpirationTime=ft,d.memoizedState=Td,d.child=Vo,Go}else{d.memoizedState=null;var L1=O.children;return d.child=Tf(d,gl,L1,D)}}}}function tp(c,d,D){d.memoizedState=null;var C=d.pendingProps,O=C.children;return wo(c,d,O,D),d.child}function Gh(c,d,D){if((c.mode&K)===Ar)Xt(!1,"Cannot hydrate Suspense in legacy mode. Switch from ReactDOM.hydrate(element, container) to ReactDOM.createBlockingRoot(container, { hydrate: true }).render(element) or remove the Suspense components from the server rendered components."),c.expirationTime=Un;else if(m0(d)){var C=jl(),O=Ds(C);In&&R(O),c.expirationTime=O}else c.expirationTime=Di,In&&R(Di);return null}function Yh(c,d,D,C,O){if(q2(),(d.mode&K)===Ar||m0(D))return tp(c,d,O);var z=c.childExpirationTime>=O;if(wa||z){if(O<Un&&C.retryTime<=O){var G=O+1;C.retryTime=G,yl(c,G)}return Ev(),tp(c,d,O)}else{if(Bs(D))return d.effectTag|=Kr,d.child=c.child,Us(D,oy.bind(null,c)),null;hm(d,D);for(var ne=d.pendingProps,se=ne.children,Ue=$c(d,null,se,O),Xe=Ue;Xe;)Xe.effectTag|=su,Xe=Xe.sibling;return d.child=Ue,d.child}}function np(c,d){c.expirationTime<d&&(c.expirationTime=d);var D=c.alternate;D!==null&&D.expirationTime<d&&(D.expirationTime=d),z0(c.return,d)}function wm(c,d,D){for(var C=d;C!==null;){if(C.tag===he){var O=C.memoizedState;O!==null&&np(C,D)}else if(C.tag===gt)np(C,D);else if(C.child!==null){C.child.return=C,C=C.child;continue}if(C===c)return;for(;C.sibling===null;){if(C.return===null||C.return===c)return;C=C.return}C.sibling.return=C.return,C=C.sibling}}function Sm(c){for(var d=c,D=null;d!==null;){var C=d.alternate;C!==null&&n1(C)===null&&(D=d),d=d.sibling}return D}function Tm(c){if(c!==void 0&&c!=="forwards"&&c!=="backwards"&&c!=="together"&&!wd[c])if(wd[c]=!0,typeof c=="string")switch(c.toLowerCase()){case"together":case"forwards":case"backwards":{Xt(!1,'"%s" is not a valid value for revealOrder on <SuspenseList />. Use lowercase "%s" instead.',c,c.toLowerCase());break}case"forward":case"backward":{Xt(!1,'"%s" is not a valid value for revealOrder on <SuspenseList />. React uses the -s suffix in the spelling. Use "%ss" instead.',c,c.toLowerCase());break}default:Xt(!1,'"%s" is not a supported revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?',c);break}else Xt(!1,'%s is not a supported value for revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?',c)}function Kh(c,d){c!==void 0&&!Sc[c]&&(c!=="collapsed"&&c!=="hidden"?(Sc[c]=!0,Xt(!1,'"%s" is not a supported value for tail on <SuspenseList />. Did you mean "collapsed" or "hidden"?',c)):d!=="forwards"&&d!=="backwards"&&(Sc[c]=!0,Xt(!1,'<SuspenseList tail="%s" /> is only valid if revealOrder is "forwards" or "backwards". Did you mean to specify revealOrder="forwards"?',c)))}function _1(c,d){{var D=Array.isArray(c),C=!D&&typeof fr(c)=="function";if(D||C){var O=D?"array":"iterable";return Xt(!1,"A nested %s was passed to row #%s in <SuspenseList />. Wrap it in an additional SuspenseList to configure its revealOrder: <SuspenseList revealOrder=...> ... <SuspenseList revealOrder=...>{%s}</SuspenseList> ... </SuspenseList>",O,d,O),!1}}return!0}function Cm(c,d){if((d==="forwards"||d==="backwards")&&c!==void 0&&c!==null&&c!==!1)if(Array.isArray(c)){for(var D=0;D<c.length;D++)if(!_1(c[D],D))return}else{var C=fr(c);if(typeof C=="function"){var O=C.call(c);if(O)for(var z=O.next(),G=0;!z.done;z=O.next()){if(!_1(z.value,G))return;G++}}else Xt(!1,'A single row was passed to a <SuspenseList revealOrder="%s" />. This is not useful since it needs multiple rows. Did you mean to pass multiple children or an array?',d)}}function rp(c,d,D,C,O,z){var G=c.memoizedState;G===null?c.memoizedState={isBackwards:d,rendering:null,last:C,tail:D,tailExpiration:0,tailMode:O,lastEffect:z}:(G.isBackwards=d,G.rendering=null,G.last=C,G.tail=D,G.tailExpiration=0,G.tailMode=O,G.lastEffect=z)}function ip(c,d,D){var C=d.pendingProps,O=C.revealOrder,z=C.tail,G=C.children;Tm(O),Kh(z,O),Cm(G,O),wo(c,d,G,D);var ne=Nl.current,se=t1(ne,e1);if(se)ne=hd(ne,e1),d.effectTag|=Kr;else{var Ue=c!==null&&(c.effectTag&Kr)!==xi;Ue&&wm(d,d.child,D),ne=ya(ne)}if(Fr(d,ne),(d.mode&K)===Ar)d.memoizedState=null;else switch(O){case"forwards":{var Xe=Sm(d.child),ht;Xe===null?(ht=d.child,d.child=null):(ht=Xe.sibling,Xe.sibling=null),rp(d,!1,ht,Xe,z,d.lastEffect);break}case"backwards":{var Lt=null,Gt=d.child;for(d.child=null;Gt!==null;){var Ht=Gt.alternate;if(Ht!==null&&n1(Ht)===null){d.child=Gt;break}var yn=Gt.sibling;Gt.sibling=Lt,Lt=Gt,Gt=yn}rp(d,!0,Lt,null,z,d.lastEffect);break}case"together":{rp(d,!1,null,null,void 0,d.lastEffect);break}default:d.memoizedState=null}return d.child}function xm(c,d,D){Ya(d,d.stateNode.containerInfo);var C=d.pendingProps;return c===null?d.child=Tf(d,null,C,D):wo(c,d,C,D),d.child}function Rm(c,d,D){var C=d.type,O=C._context,z=d.pendingProps,G=d.memoizedProps,ne=z.value;{var se=d.type.propTypes;se&&E(se,z,"prop","Context.Provider",Lr)}if(xr(d,ne),G!==null){var Ue=G.value,Xe=cu(O,ne,Ue);if(Xe===0){if(G.children===z.children&&!sa())return Ta(c,d,D)}else Ml(d,O,Xe,D)}var ht=z.children;return wo(c,d,ht,D),d.child}var Xh=!1;function Am(c,d,D){var C=d.type;C._context===void 0?C!==C.Consumer&&(Xh||(Xh=!0,Xt(!1,"Rendering <Context> directly is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?"))):C=C._context;var O=d.pendingProps,z=O.children;typeof z!="function"&&Ve(!1,"A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."),i0(d,D);var G=Ge(C,O.unstable_observedBits),ne;return m1.current=d,et("render"),ne=z(G),et(null),d.effectTag|=lu,wo(c,d,ne,D),d.child}function Om(c,d,D){var C=d.type.impl;if(C.reconcileChildren===!1)return null;var O=d.pendingProps,z=O.children;return wo(c,d,z,D),d.child}function up(c,d,D){var C=d.pendingProps,O=C.children;return wo(c,d,O,D),d.child}function op(){wa=!0}function Ta(c,d,D){tu(d),c!==null&&(d.dependencies=c.dependencies),en&&Lh(d);var C=d.expirationTime;C!==ft&&Kd(C);var O=d.childExpirationTime;return O<D?null:(Dh(c,d),d.child)}function E1(c,d,D){{var C=d.return;if(C===null)throw new Error("Cannot swap the root fiber.");if(c.alternate=null,d.alternate=null,D.index=d.index,D.sibling=d.sibling,D.return=d.return,D.ref=d.ref,d===C.child)C.child=D;else{var O=C.child;if(O===null)throw new Error("Expected parent to have a child.");for(;O.sibling!==d;)if(O=O.sibling,O===null)throw new Error("Expected to find the previous sibling.");O.sibling=D}var z=C.lastEffect;return z!==null?(z.nextEffect=c,C.lastEffect=c):C.firstEffect=C.lastEffect=c,c.nextEffect=null,c.effectTag=Y0,D.effectTag|=vi,D}}function lp(c,d,D){var C=d.expirationTime;if(d._debugNeedsRemount&&c!==null)return E1(c,d,yy(d.type,d.key,d.pendingProps,d._debugOwner||null,d.mode,d.expirationTime));if(c!==null){var O=c.memoizedProps,z=d.pendingProps;if(O!==z||sa()||d.type!==c.type)wa=!0;else if(C<D){switch(wa=!1,d.tag){case j:Wh(d),v1();break;case V:if(yc(d),d.mode&ti&&D!==Di&&h0(d.type,z))return In&&R(Di),d.expirationTime=d.childExpirationTime=Di,null;break;case k:{var G=d.type;Xi(G)&&qi(d);break}case q:Ya(d,d.stateNode.containerInfo);break;case ge:{var ne=d.memoizedProps.value;xr(d,ne);break}case we:if(en){var se=d.childExpirationTime>=D;se&&(d.effectTag|=Dr)}break;case he:{var Ue=d.memoizedState;if(Ue!==null){if(Ai&&Ue.dehydrated!==null){Fr(d,ya(Nl.current)),d.effectTag|=Kr;break}var Xe=d.child,ht=Xe.childExpirationTime;if(ht!==ft&&ht>=D)return Vh(c,d,D);Fr(d,ya(Nl.current));var Lt=Ta(c,d,D);return Lt!==null?Lt.sibling:null}else Fr(d,ya(Nl.current));break}case gt:{var Gt=(c.effectTag&Kr)!==xi,Ht=d.childExpirationTime>=D;if(Gt){if(Ht)return ip(c,d,D);d.effectTag|=Kr}var yn=d.memoizedState;if(yn!==null&&(yn.rendering=null,yn.tail=null),Fr(d,Nl.current),Ht)break;return null}}return Ta(c,d,D)}else wa=!1}else wa=!1;switch(d.expirationTime=ft,d.tag){case x:return Dm(c,d,d.type,D);case Ae:{var kr=d.elementType;return If(c,d,kr,C,D)}case F:{var ii=d.type,Oi=d.pendingProps,L0=d.elementType===ii?Oi:Wi(ii,Oi);return J2(c,d,ii,L0,D)}case k:{var $i=d.type,lt=d.pendingProps,Mt=d.elementType===$i?lt:Wi($i,lt);return qh(c,d,$i,Mt,D)}case j:return _m(c,d,D);case V:return Em(c,d,D);case re:return Pf(c,d);case he:return Vh(c,d,D);case q:return xm(c,d,D);case ae:{var $e=d.type,jt=d.pendingProps,Fn=d.elementType===$e?jt:Wi($e,jt);return Bh(c,d,$e,Fn,D)}case y:return gm(c,d,D);case me:return zh(c,d,D);case we:return Hh(c,d,D);case ge:return Rm(c,d,D);case De:return Am(c,d,D);case ve:{var vn=d.type,Vi=d.pendingProps,ci=Wi(vn,Vi);if(d.type!==d.elementType){var Yu=vn.propTypes;Yu&&E(Yu,ci,"prop",qt(vn),Lr)}return ci=Wi(vn.type,ci),Uh(c,d,vn,ci,C,D)}case ue:return jh(c,d,d.type,d.pendingProps,C,D);case ze:{var hr=d.type,pu=d.pendingProps,Yr=d.elementType===hr?pu:Wi(hr,pu);return Sd(c,d,hr,Yr,D)}case gt:return ip(c,d,D);case _t:{if(Wt)return Om(c,d,D);break}case Qe:{if(Ru)return up(c,d,D);break}}throw Error("Unknown unit of work tag ("+d.tag+"). This error is likely caused by a bug in React. Please file an issue.")}function Qh(c,d,D,C){return{currentFiber:c,impl:D,instance:null,prevProps:null,props:d,state:C}}function Cd(c){return c.tag===he&&c.memoizedState!==null}function D1(c){return c.child.sibling.child}var Jh={};function sp(c,d,D){if(Ru){if(c.tag===V){var C=c.type,O=c.memoizedProps,z=c.stateNode,G=Lo(z);G!==null&&d(C,O||Jh,G)===!0&&D.push(G)}var ne=c.child;Cd(c)&&(ne=D1(c)),ne!==null&&ap(ne,d,D)}}function Zh(c,d){if(Ru){if(c.tag===V){var D=c.type,C=c.memoizedProps,O=c.stateNode,z=Lo(O);if(z!==null&&d(D,C,z)===!0)return z}var G=c.child;if(Cd(c)&&(G=D1(c)),G!==null)return $h(G,d)}return null}function ap(c,d,D){for(var C=c;C!==null;)sp(C,d,D),C=C.sibling}function $h(c,d){for(var D=c;D!==null;){var C=Zh(D,d);if(C!==null)return C;D=D.sibling}return null}function ev(c,d,D){if(xd(c,d))D.push(c.stateNode.methods);else{var C=c.child;Cd(c)&&(C=D1(c)),C!==null&&fp(C,d,D)}}function fp(c,d,D){for(var C=c;C!==null;)ev(C,d,D),C=C.sibling}function xd(c,d){return c.tag===Qe&&c.type===d&&c.stateNode!==null}function Rd(c,d){return{getChildren:function(){var D=d.fiber,C=D.child,O=[];return C!==null&&fp(C,c,O),O.length===0?null:O},getChildrenFromRoot:function(){for(var D=d.fiber,C=D;C!==null;){var O=C.return;if(O===null||(C=O,C.tag===Qe&&C.type===c))break}var z=[];return fp(C.child,c,z),z.length===0?null:z},getParent:function(){for(var D=d.fiber.return;D!==null;){if(D.tag===Qe&&D.type===c)return D.stateNode.methods;D=D.return}return null},getProps:function(){var D=d.fiber;return D.memoizedProps},queryAllNodes:function(D){var C=d.fiber,O=C.child,z=[];return O!==null&&ap(O,D,z),z.length===0?null:z},queryFirstNode:function(D){var C=d.fiber,O=C.child;return O!==null?$h(O,D):null},containsNode:function(D){for(var C=cr(D);C!==null;){if(C.tag===Qe&&C.type===c&&C.stateNode===d)return!0;C=C.return}return!1}}}function H0(c){c.effectTag|=Dr}function Ad(c){c.effectTag|=Oo}var Ca,$a,Od,Md;if(b0)Ca=function(c,d,D,C){for(var O=d.child;O!==null;){if(O.tag===V||O.tag===re)Xr(c,O.stateNode);else if(Wt&&O.tag===_t)Xr(c,O.stateNode.instance);else if(O.tag!==q){if(O.child!==null){O.child.return=O,O=O.child;continue}}if(O===d)return;for(;O.sibling===null;){if(O.return===null||O.return===d)return;O=O.return}O.sibling.return=O.return,O=O.sibling}},$a=function(c){},Od=function(c,d,D,C,O){var z=c.memoizedProps;if(z!==C){var G=d.stateNode,ne=fl(),se=p0(G,D,z,C,O,ne);d.updateQueue=se,se&&H0(d)}},Md=function(c,d,D,C){D!==C&&H0(d)};else if(Q){Ca=function(c,d,D,C){for(var O=d.child;O!==null;){e:if(O.tag===V){var z=O.stateNode;if(D&&C){var G=O.memoizedProps,ne=O.type;z=Jr(z,ne,G,O)}Xr(c,z)}else if(O.tag===re){var se=O.stateNode;if(D&&C){var Ue=O.memoizedProps;se=Zl(se,Ue,O)}Xr(c,se)}else if(Wt&&O.tag===_t){var Xe=O.stateNode.instance;if(D&&C){var ht=O.memoizedProps,Lt=O.type;Xe=Jr(Xe,Lt,ht,O)}Xr(c,Xe)}else if(O.tag!==q){if(O.tag===he){if((O.effectTag&Dr)!==xi){var Gt=O.memoizedState!==null;if(Gt){var Ht=O.child;if(Ht!==null){Ht.child!==null&&(Ht.child.return=Ht,Ca(c,Ht,!0,Gt));var yn=Ht.sibling;if(yn!==null){yn.return=O,O=yn;continue}}}}if(O.child!==null){O.child.return=O,O=O.child;continue}}else if(O.child!==null){O.child.return=O,O=O.child;continue}}if(O=O,O===d)return;for(;O.sibling===null;){if(O.return===null||O.return===d)return;O=O.return}O.sibling.return=O.return,O=O.sibling}};var cp=function(c,d,D,C){for(var O=d.child;O!==null;){e:if(O.tag===V){var z=O.stateNode;if(D&&C){var G=O.memoizedProps,ne=O.type;z=Jr(z,ne,G,O)}Qn(c,z)}else if(O.tag===re){var se=O.stateNode;if(D&&C){var Ue=O.memoizedProps;se=Zl(se,Ue,O)}Qn(c,se)}else if(Wt&&O.tag===_t){var Xe=O.stateNode.instance;if(D&&C){var ht=O.memoizedProps,Lt=O.type;Xe=Jr(Xe,Lt,ht,O)}Qn(c,Xe)}else if(O.tag!==q){if(O.tag===he){if((O.effectTag&Dr)!==xi){var Gt=O.memoizedState!==null;if(Gt){var Ht=O.child;if(Ht!==null){Ht.child!==null&&(Ht.child.return=Ht,cp(c,Ht,!0,Gt));var yn=Ht.sibling;if(yn!==null){yn.return=O,O=yn;continue}}}}if(O.child!==null){O.child.return=O,O=O.child;continue}}else if(O.child!==null){O.child.return=O,O=O.child;continue}}if(O=O,O===d)return;for(;O.sibling===null;){if(O.return===null||O.return===d)return;O=O.return}O.sibling.return=O.return,O=O.sibling}};$a=function(c){var d=c.stateNode,D=c.firstEffect===null;if(!D){var C=d.containerInfo,O=S0(C);cp(O,c,!1,!1),d.pendingChildren=O,H0(c),ac(C,O)}},Od=function(c,d,D,C,O){var z=c.stateNode,G=c.memoizedProps,ne=d.firstEffect===null;if(ne&&G===C){d.stateNode=z;return}var se=d.stateNode,Ue=fl(),Xe=null;if(G!==C&&(Xe=p0(se,D,G,C,O,Ue)),ne&&Xe===null){d.stateNode=z;return}var ht=ms(z,Xe,D,G,C,d,ne,se);Au(ht,D,C,O,Ue)&&H0(d),d.stateNode=ht,ne?H0(d):Ca(ht,d,!1,!1)},Md=function(c,d,D,C){if(D!==C){var O=ns(),z=fl();d.stateNode=hs(C,O,z,d),H0(d)}}}else $a=function(c){},Od=function(c,d,D,C,O){},Md=function(c,d,D,C){};function kd(c,d){switch(c.tailMode){case"hidden":{for(var D=c.tail,C=null;D!==null;)D.alternate!==null&&(C=D),D=D.sibling;C===null?c.tail=null:C.sibling=null;break}case"collapsed":{for(var O=c.tail,z=null;O!==null;)O.alternate!==null&&(z=O),O=O.sibling;z===null?!d&&c.tail!==null?c.tail.sibling=null:c.tail=null:z.sibling=null;break}}}function tv(c,d,D){var C=d.pendingProps;switch(d.tag){case x:break;case Ae:break;case ue:case F:break;case k:{var O=d.type;Xi(O)&&Hs(d);break}case j:{uo(d),R0(d);var z=d.stateNode;if(z.pendingContext&&(z.context=z.pendingContext,z.pendingContext=null),c===null||c.child===null){var G=h1(d);G&&H0(d)}$a(d);break}case V:{M2(d);var ne=ns(),se=d.type;if(c!==null&&d.stateNode!=null){if(Od(c,d,se,C,ne),yi){var Ue=c.memoizedProps.listeners,Xe=C.listeners;Ue!==Xe&&H0(d)}c.ref!==d.ref&&Ad(d)}else{if(!C){if(d.stateNode===null)throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");break}var ht=fl(),Lt=h1(d);if(Lt){if(vm(d,ne,ht)&&H0(d),yi){var Gt=C.listeners;Gt!=null&&hn(Gt,d,ne)}}else{var Ht=Ki(se,C,ne,ht,d);if(Ca(Ht,d,!1,!1),d.stateNode=Ht,yi){var yn=C.listeners;yn!=null&&hn(yn,d,ne)}Au(Ht,se,C,ne,ht)&&H0(d)}d.ref!==null&&Ad(d)}break}case re:{var kr=C;if(c&&d.stateNode!=null){var ii=c.memoizedProps;Md(c,d,ii,kr)}else{if(typeof kr!="string"&&d.stateNode===null)throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");var Oi=ns(),L0=fl(),$i=h1(d);$i?mm(d)&&H0(d):d.stateNode=hs(kr,Oi,L0,d)}break}case ae:break;case he:{ga(d);var lt=d.memoizedState;if(Ai&&lt!==null&&lt.dehydrated!==null)if(c===null){var Mt=h1(d);if(!Mt)throw Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React.");return Ih(d),In&&R(Di),null}else return v1(),(d.effectTag&Kr)===xi&&(d.memoizedState=null),d.effectTag|=Dr,null;if((d.effectTag&Kr)!==xi)return d.expirationTime=D,d;var $e=lt!==null,jt=!1;if(c===null)d.memoizedProps.fallback!==void 0&&h1(d);else{var Fn=c.memoizedState;if(jt=Fn!==null,!$e&&Fn!==null){var vn=c.child.sibling;if(vn!==null){var Vi=d.firstEffect;Vi!==null?(d.firstEffect=vn,vn.nextEffect=Vi):(d.firstEffect=d.lastEffect=vn,vn.nextEffect=null),vn.effectTag=Y0}}}if($e&&!jt&&(d.mode&K)!==Ar){var ci=c===null&&d.memoizedProps.unstable_avoidThisFallback!==!0;ci||t1(Nl.current,xf)?_v():Ev()}Q&&$e&&(d.effectTag|=Dr),b0&&($e||jt)&&(d.effectTag|=Dr),Yi&&d.updateQueue!==null&&d.memoizedProps.suspenseCallback!=null&&(d.effectTag|=Dr);break}case y:break;case me:break;case we:break;case q:uo(d),$a(d);break;case ge:r0(d);break;case De:break;case ve:break;case ze:{var Yu=d.type;Xi(Yu)&&Hs(d);break}case gt:{ga(d);var hr=d.memoizedState;if(hr===null)break;var pu=(d.effectTag&Kr)!==xi,Yr=hr.rendering;if(Yr===null)if(pu)kd(hr,!1);else{var Cu=Dv()&&(c===null||(c.effectTag&Kr)===xi);if(!Cu)for(var D0=d.child;D0!==null;){var W0=n1(D0);if(W0!==null){pu=!0,d.effectTag|=Kr,kd(hr,!1);var Ms=W0.updateQueue;return Ms!==null&&(d.updateQueue=Ms,d.effectTag|=Dr),hr.lastEffect===null&&(d.firstEffect=null),d.lastEffect=hr.lastEffect,sm(d,D),Fr(d,hd(Nl.current,e1)),d.child}D0=D0.sibling}}else{if(!pu){var Ku=n1(Yr);if(Ku!==null){d.effectTag|=Kr,pu=!0;var gl=Ku.updateQueue;if(gl!==null&&(d.updateQueue=gl,d.effectTag|=Dr),kd(hr,!0),hr.tail===null&&hr.tailMode==="hidden"&&!Yr.alternate){var rf=d.lastEffect=hr.lastEffect;return rf!==null&&(rf.nextEffect=null),null}}else if(mt()>hr.tailExpiration&&D>Di){d.effectTag|=Kr,pu=!0,kd(hr,!1);var Vo=D-1;d.expirationTime=d.childExpirationTime=Vo,In&&R(Vo)}}if(hr.isBackwards)Yr.sibling=d.child,d.child=Yr;else{var ks=hr.last;ks!==null?ks.sibling=Yr:d.child=Yr,hr.last=Yr}}if(hr.tail!==null){if(hr.tailExpiration===0){var Jd=500;hr.tailExpiration=mt()+Jd}var Vf=hr.tail;hr.rendering=Vf,hr.tail=Vf.sibling,hr.lastEffect=d.lastEffect,Vf.sibling=null;var Lc=Nl.current;return pu?Lc=hd(Lc,e1):Lc=ya(Lc),Fr(d,Lc),Vf}break}case _t:{if(Wt){var Hl=d.type.impl,Go=d.stateNode;if(Go===null){var L1=Hl.getInitialState,i_;L1!==void 0&&(i_=L1(C)),Go=d.stateNode=Qh(d,C,Hl,i_||{});var u_=pt(Go);if(Go.instance=u_,Hl.reconcileChildren===!1)return null;Ca(u_,d,!1,!1),Yn(Go)}else{var nE=Go.props;if(Go.prevProps=nE,Go.props=C,Go.currentFiber=d,Q){var o_=oa(Go);Go.instance=o_,Ca(o_,d,!1,!1)}var rE=Cn(Go);rE&&H0(d)}}break}case Qe:{if(Ru)if(c===null){var iE=d.type,Ry={fiber:d,methods:null};if(d.stateNode=Ry,Ry.methods=Rd(iE,Ry),yi){var l_=C.listeners;if(l_!=null){var uE=ns();hn(l_,d,uE)}}d.ref!==null&&(Ad(d),H0(d))}else{if(yi){var oE=c.memoizedProps.listeners,lE=C.listeners;(oE!==lE||d.ref!==null)&&H0(d)}else d.ref!==null&&H0(d);c.ref!==d.ref&&Ad(d)}break}default:throw Error("Unknown unit of work tag ("+d.tag+"). This error is likely caused by a bug in React. Please file an issue.")}return null}function Mm(c,d){switch(c.tag){case k:{var D=c.type;Xi(D)&&Hs(c);var C=c.effectTag;return C&d0?(c.effectTag=C&~d0|Kr,c):null}case j:{uo(c),R0(c);var O=c.effectTag;if((O&Kr)!==xi)throw Error("The root failed to unmount after an error. This is likely a bug in React. Please file an issue.");return c.effectTag=O&~d0|Kr,c}case V:return M2(c),null;case he:{if(ga(c),Ai){var z=c.memoizedState;if(z!==null&&z.dehydrated!==null){if(c.alternate===null)throw Error("Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue.");v1()}}var G=c.effectTag;return G&d0?(c.effectTag=G&~d0|Kr,c):null}case gt:return ga(c),null;case q:return uo(c),null;case ge:return r0(c),null;default:return null}}function nv(c){switch(c.tag){case k:{var d=c.type.childContextTypes;d!=null&&Hs(c);break}case j:{uo(c),R0(c);break}case V:{M2(c);break}case q:uo(c);break;case he:ga(c);break;case gt:ga(c);break;case ge:r0(c);break;default:break}}function dp(c,d){return{value:c,source:d,stack:Cr(d)}}var pp=function(c,d,D,C,O,z,G,ne,se){var Ue=Array.prototype.slice.call(arguments,3);try{d.apply(D,Ue)}catch(Xe){this.onError(Xe)}};if(typeof window<"u"&&typeof window.dispatchEvent=="function"&&typeof document<"u"&&typeof document.createEvent=="function"){var hp=document.createElement("react"),km=function(c,d,D,C,O,z,G,ne,se){if(!(typeof document<"u"))throw Error("The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous.");var Ue=document.createEvent("Event"),Xe=!0,ht=window.event,Lt=Object.getOwnPropertyDescriptor(window,"event"),Gt=Array.prototype.slice.call(arguments,3);function Ht(){hp.removeEventListener(L0,Ht,!1),typeof window.event<"u"&&window.hasOwnProperty("event")&&(window.event=ht),d.apply(D,Gt),Xe=!1}var yn,kr=!1,ii=!1;function Oi($i){if(yn=$i.error,kr=!0,yn===null&&$i.colno===0&&$i.lineno===0&&(ii=!0),$i.defaultPrevented&&yn!=null&&typeof yn=="object")try{yn._suppressLogging=!0}catch{}}var L0="react-"+(c||"invokeguardedcallback");window.addEventListener("error",Oi),hp.addEventListener(L0,Ht,!1),Ue.initEvent(L0,!1,!1),hp.dispatchEvent(Ue),Lt&&Object.defineProperty(window,"event",Lt),Xe&&(kr?ii&&(yn=new Error("A cross-origin error was thrown. React doesn't have access to the actual error object in development. See https://fb.me/react-crossorigin-error for more information.")):yn=new Error(`An error was thrown inside one of your components, but React doesn't know what it was. This is likely due to browser flakiness. React does its best to preserve the "Pause on exceptions" behavior of the DevTools, which requires some DEV-mode only tricks. It's possible that these don't work in your browser. Try triggering the error in production mode, or switching to a modern browser. If you suspect that this is actually an issue with React, please file an issue.`),this.onError(yn)),window.removeEventListener("error",Oi)};pp=km}var Nm=pp,So=!1,Nd=null,Lm={onError:function(c){So=!0,Nd=c}};function pl(c,d,D,C,O,z,G,ne,se){So=!1,Nd=null,Nm.apply(Lm,arguments)}function tr(){return So}function Qs(){if(So){var c=Nd;return So=!1,Nd=null,c}else throw Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.")}function hl(c){return!0}function o0(c){var d=hl(c);if(d!==!1){var D=c.error;{var C=c.componentName,O=c.componentStack,z=c.errorBoundaryName,G=c.errorBoundaryFound,ne=c.willRetry;if(D!=null&&D._suppressLogging){if(G&&ne)return;console.error(D)}var se=C?"The above error occurred in the <"+C+"> component:":"The above error occurred in one of your React components:",Ue;G&&z?ne?Ue="React will try to recreate this component tree from scratch "+("using the error boundary you provided, "+z+"."):Ue="This error was initially handled by the error boundary "+z+`.
+Recreating the tree from scratch failed so React will unmount the tree.`:Ue=`Consider adding an error boundary to your tree to customize error handling behavior.
+Visit https://fb.me/react-error-boundaries to learn more about error boundaries.`;var Xe=""+se+O+`
+
+`+(""+Ue);console.error(Xe)}}}var rv=null;rv=new Set;var Js=typeof WeakSet=="function"?WeakSet:Set;function vp(c,d){var D=d.source,C=d.stack;C===null&&D!==null&&(C=Cr(D));var O={componentName:D!==null?qt(D.type):null,componentStack:C!==null?C:"",error:d.value,errorBoundary:null,errorBoundaryName:null,errorBoundaryFound:!1,willRetry:!1};c!==null&&c.tag===k&&(O.errorBoundary=c.stateNode,O.errorBoundaryName=qt(c.type),O.errorBoundaryFound=!0,O.willRetry=!0);try{o0(O)}catch(z){setTimeout(function(){throw z})}}var Fm=function(c,d){Bi(c,"componentWillUnmount"),d.props=c.memoizedProps,d.state=c.memoizedState,d.componentWillUnmount(),Ci()};function iv(c,d){if(pl(null,Fm,null,c,d),tr()){var D=Qs();Hf(c,D)}}function mp(c){var d=c.ref;if(d!==null)if(typeof d=="function"){if(pl(null,d,null,null),tr()){var D=Qs();Hf(c,D)}}else d.current=null}function Pm(c,d){if(pl(null,d,null),tr()){var D=Qs();Hf(c,D)}}function yp(c,d){switch(d.tag){case F:case ae:case ue:{Tc(fm,Af,d);return}case k:{if(d.effectTag&Mo&&c!==null){var D=c.memoizedProps,C=c.memoizedState;Bi(d,"getSnapshotBeforeUpdate");var O=d.stateNode;d.type===d.elementType&&!Sa&&(O.props!==d.memoizedProps&&Xt(!1,"Expected %s props to match memoized props before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(d.type)||"instance"),O.state!==d.memoizedState&&Xt(!1,"Expected %s state to match memoized state before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(d.type)||"instance"));var z=O.getSnapshotBeforeUpdate(d.elementType===d.type?D:Wi(d.type,D),C);{var G=rv;z===void 0&&!G.has(d.type)&&(G.add(d.type),Ve(!1,"%s.getSnapshotBeforeUpdate(): A snapshot value (or null) must be returned. You have returned undefined.",qt(d.type)))}O.__reactInternalSnapshotBeforeUpdate=z,Ci()}return}case j:case V:case re:case q:case ze:return;default:throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.")}}function Tc(c,d,D){var C=D.updateQueue,O=C!==null?C.lastEffect:null;if(O!==null){var z=O.next,G=z;do{if((G.tag&c)!==Af){var ne=G.destroy;G.destroy=void 0,ne!==void 0&&ne()}if((G.tag&d)!==Af){var se=G.create;G.destroy=se();{var Ue=G.destroy;if(Ue!==void 0&&typeof Ue!="function"){var Xe=void 0;Ue===null?Xe=" You returned null. If your effect does not require clean up, return undefined (or nothing).":typeof Ue.then=="function"?Xe=`
+
+It looks like you wrote useEffect(async () => ...) or returned a Promise. Instead, write the async function inside your effect and call it immediately:
+
+useEffect(() => {
+  async function fetchData() {
+    // You can await here
+    const response = await MyAPI.getData(someId);
+    // ...
+  }
+  fetchData();
+}, [someId]); // Or [] if effect doesn't need props or state
+
+Learn more about data fetching with Hooks: https://fb.me/react-hooks-data-fetching`:Xe=" You returned: "+Ue,Ve(!1,"An effect function must not return anything besides a function, which is used for clean-up.%s%s",Xe,Cr(D))}}}G=G.next}while(G!==z)}}function xa(c){if((c.effectTag&F0)!==xi)switch(c.tag){case F:case ae:case ue:{Tc(sr,Af,c),Tc(Af,r1,c);break}default:break}}function gp(c,d,D,C){switch(D.tag){case F:case ae:case ue:{Tc(cm,cl,D);break}case k:{var O=D.stateNode;if(D.effectTag&Dr)if(d===null)Bi(D,"componentDidMount"),D.type===D.elementType&&!Sa&&(O.props!==D.memoizedProps&&Xt(!1,"Expected %s props to match memoized props before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(D.type)||"instance"),O.state!==D.memoizedState&&Xt(!1,"Expected %s state to match memoized state before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(D.type)||"instance")),O.componentDidMount(),Ci();else{var z=D.elementType===D.type?d.memoizedProps:Wi(D.type,d.memoizedProps),G=d.memoizedState;Bi(D,"componentDidUpdate"),D.type===D.elementType&&!Sa&&(O.props!==D.memoizedProps&&Xt(!1,"Expected %s props to match memoized props before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(D.type)||"instance"),O.state!==D.memoizedState&&Xt(!1,"Expected %s state to match memoized state before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(D.type)||"instance")),O.componentDidUpdate(z,G,O.__reactInternalSnapshotBeforeUpdate),Ci()}var ne=D.updateQueue;ne!==null&&(D.type===D.elementType&&!Sa&&(O.props!==D.memoizedProps&&Xt(!1,"Expected %s props to match memoized props before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(D.type)||"instance"),O.state!==D.memoizedState&&Xt(!1,"Expected %s state to match memoized state before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",qt(D.type)||"instance")),go(D,ne,O,C));return}case j:{var se=D.updateQueue;if(se!==null){var Ue=null;if(D.child!==null)switch(D.child.tag){case V:Ue=Lo(D.child.stateNode);break;case k:Ue=D.child.stateNode;break}go(D,se,Ue,C)}return}case V:{var Xe=D.stateNode;if(d===null&&D.effectTag&Dr){var ht=D.type,Lt=D.memoizedProps;zu(Xe,ht,Lt,D)}return}case re:return;case q:return;case we:{if(en){var Gt=D.memoizedProps.onRender;typeof Gt=="function"&&(In?Gt(D.memoizedProps.id,d===null?"mount":"update",D.actualDuration,D.treeBaseDuration,D.actualStartTime,Il(),c.memoizedInteractions):Gt(D.memoizedProps.id,d===null?"mount":"update",D.actualDuration,D.treeBaseDuration,D.actualStartTime,Il()))}return}case he:{Bl(c,D);return}case gt:case ze:case _t:case Qe:return;default:throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.")}}function Ld(c,d){if(b0)for(var D=c;;){if(D.tag===V){var C=D.stateNode;d?Pa(C):ia(D.stateNode,D.memoizedProps)}else if(D.tag===re){var O=D.stateNode;d?v0(O):J0(O,D.memoizedProps)}else if(D.tag===he&&D.memoizedState!==null&&D.memoizedState.dehydrated===null){var z=D.child.sibling;z.return=D,D=z;continue}else if(D.child!==null){D.child.return=D,D=D.child;continue}if(D===c)return;for(;D.sibling===null;){if(D.return===null||D.return===c)return;D=D.return}D.sibling.return=D.return,D=D.sibling}}function Iu(c){var d=c.ref;if(d!==null){var D=c.stateNode,C;switch(c.tag){case V:C=Lo(D);break;default:C=D}Ru&&c.tag===Qe&&(C=D.methods),typeof d=="function"?d(C):(d.hasOwnProperty("current")||Ve(!1,"Unexpected ref object provided for %s. Use either a ref-setter function or React.createRef().%s",qt(c.type),Cr(c)),d.current=C)}}function Gu(c){var d=c.ref;d!==null&&(typeof d=="function"?d(null):d.current=null)}function _p(c,d,D){switch(Mn(d),d.tag){case F:case ae:case ve:case ue:{var C=d.updateQueue;if(C!==null){var O=C.lastEffect;if(O!==null){var z=O.next,G=D>Kn?Kn:D;Sn(G,function(){var ii=z;do{var Oi=ii.destroy;Oi!==void 0&&Pm(d,Oi),ii=ii.next}while(ii!==z)})}}break}case k:{mp(d);var ne=d.stateNode;typeof ne.componentWillUnmount=="function"&&iv(d,ne);return}case V:{if(yi){var se=d.dependencies;if(se!==null){var Ue=se.responders;if(Ue!==null){for(var Xe=Array.from(Ue.values()),ht=0,Lt=Xe.length;ht<Lt;ht++){var Gt=Xe[ht];Le(Gt)}se.responders=null}}}mp(d);return}case q:{b0?w1(c,d,D):Q&&Im(d);return}case _t:{if(Wt){var Ht=d.stateNode;Ht!==null&&(Ia(Ht),d.stateNode=null)}return}case We:{if(Yi){var yn=c.hydrationCallbacks;if(yn!==null){var kr=yn.onDeleted;kr&&kr(d.stateNode)}}return}case Qe:Ru&&mp(d)}}function Ep(c,d,D){for(var C=d;;){if(_p(c,C,D),C.child!==null&&(!b0||C.tag!==q)){C.child.return=C,C=C.child;continue}if(C===d)return;for(;C.sibling===null;){if(C.return===null||C.return===d)return;C=C.return}C.sibling.return=C.return,C=C.sibling}}function uv(c){var d=c.alternate;c.return=null,c.child=null,c.memoizedState=null,c.updateQueue=null,c.dependencies=null,c.alternate=null,c.firstEffect=null,c.lastEffect=null,c.pendingProps=null,c.memoizedProps=null,d!==null&&uv(d)}function Im(c){if(!!Q){var d=c.stateNode,D=d.containerInfo,C=S0(D);si(D,C)}}function bm(c){if(!!Q)switch(c.tag){case k:case V:case re:case _t:return;case j:case q:{var d=c.stateNode,D=d.containerInfo,C=d.pendingChildren;si(D,C);return}default:throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.")}}function Bm(c){for(var d=c.return;d!==null;){if(Fd(d))return d;d=d.return}throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.")}function Fd(c){return c.tag===V||c.tag===j||c.tag===q}function ov(c){var d=c;e:for(;;){for(;d.sibling===null;){if(d.return===null||Fd(d.return))return null;d=d.return}for(d.sibling.return=d.return,d=d.sibling;d.tag!==V&&d.tag!==re&&d.tag!==We;){if(d.effectTag&vi||d.child===null||d.tag===q)continue e;d.child.return=d,d=d.child}if(!(d.effectTag&vi))return d.stateNode}}function Cc(c){if(!!b0){var d=Bm(c),D,C,O=d.stateNode;switch(d.tag){case V:D=O,C=!1;break;case j:D=O.containerInfo,C=!0;break;case q:D=O.containerInfo,C=!0;break;case _t:Wt&&(D=O.instance,C=!1);default:throw Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.")}d.effectTag&Bu&&(Hu(D),d.effectTag&=~Bu);for(var z=ov(c),G=c;;){var ne=G.tag===V||G.tag===re;if(ne||Wt&&G.tag===_t){var se=ne?G.stateNode:G.stateNode.instance;z?C?Fo(D,se,z):Ti(D,se,z):C?Ou(D,se):Si(D,se)}else if(G.tag!==q){if(G.child!==null){G.child.return=G,G=G.child;continue}}if(G===c)return;for(;G.sibling===null;){if(G.return===null||G.return===c)return;G=G.return}G.sibling.return=G.return,G=G.sibling}}}function w1(c,d,D){for(var C=d,O=!1,z,G;;){if(!O){var ne=C.return;e:for(;;){if(ne===null)throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");var se=ne.stateNode;switch(ne.tag){case V:z=se,G=!1;break e;case j:z=se.containerInfo,G=!0;break e;case q:z=se.containerInfo,G=!0;break e;case _t:Wt&&(z=se.instance,G=!1)}ne=ne.return}O=!0}if(C.tag===V||C.tag===re)Ep(c,C,D),G?po(z,C.stateNode):Mu(z,C.stateNode);else if(Wt&&C.tag===_t){var Ue=C.stateNode.instance;Ep(c,C,D),G?po(z,Ue):Mu(z,Ue)}else if(Ai&&C.tag===We){if(Yi){var Xe=c.hydrationCallbacks;if(Xe!==null){var ht=Xe.onDeleted;ht&&ht(C.stateNode)}}G?Ne(z,C.stateNode):$(z,C.stateNode)}else if(C.tag===q){if(C.child!==null){z=C.stateNode.containerInfo,G=!0,C.child.return=C,C=C.child;continue}}else if(_p(c,C,D),C.child!==null){C.child.return=C,C=C.child;continue}if(C===d)return;for(;C.sibling===null;){if(C.return===null||C.return===d)return;C=C.return,C.tag===q&&(O=!1)}C.sibling.return=C.return,C=C.sibling}}function Um(c,d,D){b0?w1(c,d,D):Ep(c,d,D),uv(d)}function Pd(c,d){if(!b0){switch(d.tag){case F:case ae:case ve:case ue:{Tc(Of,Sh,d);return}case we:return;case he:{S1(d),Ra(d);return}case gt:{Ra(d);return}case j:{if(Se){var D=d.stateNode;D.hydrate&&(D.hydrate=!1,_e(D.containerInfo))}break}}bm(d);return}switch(d.tag){case F:case ae:case ve:case ue:{Tc(Of,Sh,d);return}case k:return;case V:{var C=d.stateNode;if(C!=null){var O=d.memoizedProps,z=c!==null?c.memoizedProps:O,G=d.type,ne=d.updateQueue;if(d.updateQueue=null,ne!==null&&wu(C,ne,G,z,O,d),yi){var se=z.listeners,Ue=O.listeners;se!==Ue&&hn(Ue,d,null)}}return}case re:{if(d.stateNode===null)throw Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.");var Xe=d.stateNode,ht=d.memoizedProps,Lt=c!==null?c.memoizedProps:ht;ju(Xe,Lt,ht);return}case j:{if(Se){var Gt=d.stateNode;Gt.hydrate&&(Gt.hydrate=!1,_e(Gt.containerInfo))}return}case we:return;case he:{S1(d),Ra(d);return}case gt:{Ra(d);return}case ze:return;case _t:{if(Wt){var Ht=d.stateNode;ua(Ht)}return}case Qe:{if(Ru){var yn=d.stateNode;if(yn.fiber=d,yi){var kr=d.memoizedProps,ii=c!==null?c.memoizedProps:kr,Oi=ii.listeners,L0=kr.listeners;Oi!==L0&&hn(L0,d,null)}}return}default:throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.")}}function S1(c){var d=c.memoizedState,D,C=c;if(d===null?D=!1:(D=!0,C=c.child,Ap()),b0&&C!==null&&Ld(C,D),Yi&&d!==null){var O=c.memoizedProps.suspenseCallback;if(typeof O=="function"){var z=c.updateQueue;z!==null&&O(new Set(z))}else O!==void 0&&Xt(!1,"Unexpected type for suspenseCallback.")}}function Bl(c,d){if(!!Se){var D=d.memoizedState;if(D===null){var C=d.alternate;if(C!==null){var O=C.memoizedState;if(O!==null){var z=O.dehydrated;if(z!==null&&(Oe(z),Yi)){var G=c.hydrationCallbacks;if(G!==null){var ne=G.onHydrated;ne&&ne(z)}}}}}}}function Ra(c){var d=c.updateQueue;if(d!==null){c.updateQueue=null;var D=c.stateNode;D===null&&(D=c.stateNode=new Js),d.forEach(function(C){var O=ly.bind(null,c,C);D.has(C)||(In&&C.__reactDoNotTraceInteractions!==!0&&(O=N.unstable_wrap(O)),D.add(C),C.then(O,O))})}}function lv(c){!b0||Hu(c.stateNode)}var jm=typeof WeakMap=="function"?WeakMap:Map;function sv(c,d,D){var C=Tu(D,null);C.tag=Wn,C.payload={element:null};var O=d.value;return C.callback=function(){uy(O),vp(c,d)},C}function av(c,d,D){var C=Tu(D,null);C.tag=Wn;var O=c.type.getDerivedStateFromError;if(typeof O=="function"){var z=d.value;C.payload=function(){return vp(c,d),O(z)}}var G=c.stateNode;return G!==null&&typeof G.componentDidCatch=="function"?C.callback=function(){dc(c),typeof O!="function"&&(Pp(this),vp(c,d));var se=d.value,Ue=d.stack;this.componentDidCatch(se,{componentStack:Ue!==null?Ue:""}),typeof O!="function"&&c.expirationTime!==Un&&Ve(!1,"%s: Error boundaries should implement getDerivedStateFromError(). In that method, return a state update to display an error message or fallback UI.",qt(c.type)||"Unknown")}:C.callback=function(){dc(c)},C}function zm(c,d,D){var C=c.pingCache,O;if(C===null?(C=c.pingCache=new jm,O=new Set,C.set(D,O)):(O=C.get(D),O===void 0&&(O=new Set,C.set(D,O))),!O.has(d)){O.add(d);var z=Ip.bind(null,c,D,d);D.then(z,z)}}function fv(c,d,D,C,O){if(D.effectTag|=P0,D.firstEffect=D.lastEffect=null,C!==null&&typeof C=="object"&&typeof C.then=="function"){var z=C;my(D);var G=t1(Nl.current,xf),ne=d;do{if(ne.tag===he&&k2(ne,G)){var se=ne.updateQueue;if(se===null){var Ue=new Set;Ue.add(z),ne.updateQueue=Ue}else se.add(z);if((ne.mode&K)===Ar){if(ne.effectTag|=Kr,D.effectTag&=~(Ps|P0),D.tag===k){var Xe=D.alternate;if(Xe===null)D.tag=ze;else{var ht=Tu(Un,null);ht.tag=$t,Va(D,ht)}}D.expirationTime=Un;return}zm(c,O,z),ne.effectTag|=d0,ne.expirationTime=O;return}ne=ne.return}while(ne!==null);C=new Error((qt(D.type)||"A React component")+` suspended while rendering, but no fallback UI was specified.
+
+Add a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.`+Cr(D))}Op(),C=dp(C,D);var Lt=d;do{switch(Lt.tag){case j:{var Gt=C;Lt.effectTag|=d0,Lt.expirationTime=O;var Ht=sv(Lt,Gt,O);od(Lt,Ht);return}case k:var yn=C,kr=Lt.type,ii=Lt.stateNode;if((Lt.effectTag&Kr)===xi&&(typeof kr.getDerivedStateFromError=="function"||ii!==null&&typeof ii.componentDidCatch=="function"&&!Fp(ii))){Lt.effectTag|=d0,Lt.expirationTime=O;var Oi=av(Lt,yn,O);od(Lt,Oi);return}break;default:break}Lt=Lt.return}while(Lt!==null)}var Aa=Math.ceil,Mr=it.ReactCurrentDispatcher,Dp=it.ReactCurrentOwner,vl=it.IsSomeRendererActing,yu=0,T1=1,Ui=2,wp=4,Id=8,To=16,As=32,bf=0,bd=1,Sp=2,C1=3,x1=4,Tp=5,nr=yu,ml=null,Gn=null,q0=ft,k0=bf,Bd=null,Ul=Un,R1=Un,xc=null,Rc=ft,Ud=!1,Cp=0,N0=500,dn=null,jd=!1,zd=null,Ac=null,Oc=!1,Mc=null,A1=_0,xp=ft,ef=null,Hm=50,kc=0,Hd=null,cv=50,O1=0,Bf=null,Uf=null,M1=ft;function jl(){return(nr&(To|As))!==yu?t0(mt()):(M1!==ft||(M1=t0(mt())),M1)}function Nc(){return t0(mt())}function jf(c,d,D){var C=d.mode;if((C&K)===Ar)return Un;var O=Qt();if((C&ti)===Ar)return O===Li?Un:e0;if((nr&To)!==yu)return q0;var z;if(D!==null)z=fa(c,D.timeoutMs|0||_f);else switch(O){case Li:z=Un;break;case ei:z=Ua(c);break;case Kn:case $u:z=Ds(c);break;case g0:z=ru;break;default:throw Error("Expected a valid priority level")}return ml!==null&&z===q0&&(z-=1),z}function qm(c,d){sy(),dy(c);var D=qd(c,d);if(D===null){fy(c);return}jp(c,d),la();var C=Qt();if(d===Un?(nr&Id)!==yu&&(nr&(To|As))===yu?(W(D,d),k1(D)):(Wo(D),W(D,d),nr===yu&&Ut()):(Wo(D),W(D,d)),(nr&wp)!==yu&&(C===ei||C===Li))if(ef===null)ef=new Map([[D,d]]);else{var O=ef.get(D);(O===void 0||O>d)&&ef.set(D,d)}}var yl=qm;function qd(c,d){c.expirationTime<d&&(c.expirationTime=d);var D=c.alternate;D!==null&&D.expirationTime<d&&(D.expirationTime=d);var C=c.return,O=null;if(C===null&&c.tag===j)O=c.stateNode;else for(;C!==null;){if(D=C.alternate,C.childExpirationTime<d&&(C.childExpirationTime=d),D!==null&&D.childExpirationTime<d&&(D.childExpirationTime=d),C.return===null&&C.tag===j){O=C.stateNode;break}C=C.return}return O!==null&&(ml===O&&(Kd(d),k0===x1&&Wf(O,q0)),Kg(O,d)),O}function Wd(c){var d=c.lastExpiredTime;if(d!==ft)return d;var D=c.firstPendingTime;if(!Yg(c,D))return D;var C=c.lastPingedTime,O=c.nextKnownPendingLevel;return C>O?C:O}function Wo(c){var d=c.lastExpiredTime;if(d!==ft){c.callbackExpirationTime=Un,c.callbackPriority=Li,c.callbackNode=Tn(k1.bind(null,c));return}var D=Wd(c),C=c.callbackNode;if(D===ft){C!==null&&(c.callbackNode=null,c.callbackExpirationTime=ft,c.callbackPriority=_0);return}var O=jl(),z=nd(O,D);if(C!==null){var G=c.callbackPriority,ne=c.callbackExpirationTime;if(ne===D&&G>=z)return;ir(C)}c.callbackExpirationTime=D,c.callbackPriority=z;var se;D===Un?se=Tn(k1.bind(null,c)):ao?se=_n(z,Vd.bind(null,c)):se=_n(z,Vd.bind(null,c),{timeout:jo(D)-mt()}),c.callbackNode=se}function Vd(c,d){if(M1=ft,d){var D=jl();return qp(c,D),Wo(c),null}var C=Wd(c);if(C!==ft){var O=c.callbackNode;if((nr&(To|As))!==yu)throw Error("Should not already be working.");if(tf(),(c!==ml||C!==q0)&&(zf(c,C),te(c,C)),Gn!==null){var z=nr;nr|=To;var G=mv(c),ne=Gd(c);mf(Gn);do try{ey();break}catch(Xe){vv(c,Xe)}while(!0);if(yt(),nr=z,yv(G),In&&Yd(ne),k0===bd){var se=Bd;throw Up(),zf(c,C),Wf(c,C),Wo(c),se}if(Gn!==null)Up();else{Rv();var Ue=c.finishedWork=c.current.alternate;c.finishedExpirationTime=C,Wm(c,Ue,k0,C)}if(Wo(c),c.callbackNode===O)return Vd.bind(null,c)}}return null}function Wm(c,d,D,C){switch(ml=null,D){case bf:case bd:throw Error("Root did not complete. This is a bug in React.");case Sp:{qp(c,C>ru?ru:C);break}case C1:{Wf(c,C);var O=c.lastSuspendedTime;C===O&&(c.nextKnownPendingLevel=Mp(d)),p();var z=Ul===Un;if(z&&!(Q0&&qf.current)){var G=Cp+N0-mt();if(G>10){if(Ud){var ne=c.lastPingedTime;if(ne===ft||ne>=C){c.lastPingedTime=C,zf(c,C);break}}var se=Wd(c);if(se!==ft&&se!==C)break;if(O!==ft&&O!==C){c.lastPingedTime=O;break}c.timeoutHandle=Ct(l0.bind(null,c),G);break}}l0(c);break}case x1:{Wf(c,C);var Ue=c.lastSuspendedTime;if(C===Ue&&(c.nextKnownPendingLevel=Mp(d)),p(),!(Q0&&qf.current)){if(Ud){var Xe=c.lastPingedTime;if(Xe===ft||Xe>=C){c.lastPingedTime=C,zf(c,C);break}}var ht=Wd(c);if(ht!==ft&&ht!==C)break;if(Ue!==ft&&Ue!==C){c.lastPingedTime=Ue;break}var Lt;if(R1!==Un)Lt=jo(R1)-mt();else if(Ul===Un)Lt=0;else{var Gt=wv(Ul),Ht=mt(),yn=jo(C)-Ht,kr=Ht-Gt;kr<0&&(kr=0),Lt=bp(kr)-kr,yn<Lt&&(Lt=yn)}if(Lt>10){c.timeoutHandle=Ct(l0.bind(null,c),Lt);break}}l0(c);break}case Tp:{if(!(Q0&&qf.current)&&Ul!==Un&&xc!==null){var ii=Bp(Ul,C,xc);if(ii>10){Wf(c,C),c.timeoutHandle=Ct(l0.bind(null,c),ii);break}}l0(c);break}default:throw Error("Unknown root exit status.")}}function k1(c){var d=c.lastExpiredTime,D=d!==ft?d:Un;if(c.finishedExpirationTime===D)l0(c);else{if((nr&(To|As))!==yu)throw Error("Should not already be working.");if(tf(),(c!==ml||D!==q0)&&(zf(c,D),te(c,D)),Gn!==null){var C=nr;nr|=To;var O=mv(c),z=Gd(c);mf(Gn);do try{Sv();break}catch(ne){vv(c,ne)}while(!0);if(yt(),nr=C,yv(O),In&&Yd(z),k0===bd){var G=Bd;throw Up(),zf(c,D),Wf(c,D),Wo(c),G}if(Gn!==null)throw Error("Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");Rv(),c.finishedWork=c.current.alternate,c.finishedExpirationTime=D,Vm(c,k0,D),Wo(c)}}return null}function Vm(c,d,D){ml=null,(d===C1||d===x1)&&p(),l0(c)}function Gm(c,d){qp(c,d),Wo(c),(nr&(To|As))===yu&&Ut()}function dv(){if((nr&(T1|To|As))!==yu){(nr&To)!==yu&&Xt(!1,"unstable_flushDiscreteUpdates: Cannot flush updates when React is already rendering.");return}Km(),tf()}function Ym(c){return Sn(Kn,c)}function pv(c,d,D,C){return Sn(Li,c.bind(null,d,D,C))}function Km(){if(ef!==null){var c=ef;ef=null,c.forEach(function(d,D){qp(D,d),Wo(D)}),Ut()}}function Xm(c,d){var D=nr;nr|=T1;try{return c(d)}finally{nr=D,nr===yu&&Ut()}}function Qm(c,d){var D=nr;nr|=Ui;try{return c(d)}finally{nr=D,nr===yu&&Ut()}}function hv(c,d,D,C){var O=nr;nr|=wp;try{return Sn(ei,c.bind(null,d,D,C))}finally{nr=O,nr===yu&&Ut()}}function Jm(c,d){var D=nr;nr&=~T1,nr|=Id;try{return c(d)}finally{nr=D,nr===yu&&Ut()}}function Rp(c,d){if((nr&(To|As))!==yu)throw Error("flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering.");var D=nr;nr|=T1;try{return Sn(Li,c.bind(null,d))}finally{nr=D,Ut()}}function Zm(c){var d=nr;nr|=T1;try{Sn(Li,c)}finally{nr=d,nr===yu&&Ut()}}function zf(c,d){c.finishedWork=null,c.finishedExpirationTime=ft;var D=c.timeoutHandle;if(D!==nl&&(c.timeoutHandle=nl,co(D)),Gn!==null)for(var C=Gn.return;C!==null;)nv(C),C=C.return;ml=c,Gn=Co(c.current,null,d),q0=d,k0=bf,Bd=null,Ul=Un,R1=Un,xc=null,Rc=ft,Ud=!1,In&&(Uf=null),Al.discardPendingWarnings(),Zs=null}function vv(c,d){do{try{if(yt(),_d(),ut(),Gn===null||Gn.return===null)return k0=bd,Bd=d,null;en&&Gn.mode&ni&&p1(Gn,!0),fv(c,Gn.return,Gn,d,q0),Gn=Tv(Gn)}catch(D){d=D;continue}return}while(!0)}function mv(c){var d=Mr.current;return Mr.current=f1,d===null?f1:d}function yv(c){Mr.current=c}function Gd(c){if(In){var d=N.__interactionsRef.current;return N.__interactionsRef.current=c.memoizedInteractions,d}return null}function Yd(c){In&&(N.__interactionsRef.current=c)}function Ap(){Cp=mt()}function gv(c,d){c<Ul&&c>ru&&(Ul=c),d!==null&&c<R1&&c>ru&&(R1=c,xc=d)}function Kd(c){c>Rc&&(Rc=c)}function _v(){k0===bf&&(k0=C1)}function Ev(){(k0===bf||k0===C1)&&(k0=x1),Rc!==ft&&ml!==null&&(Wf(ml,q0),Kg(ml,Rc))}function Op(){k0!==Tp&&(k0=Sp)}function Dv(){return k0===bf}function wv(c){var d=jo(c);return d-_f}function $m(c,d){var D=jo(c);return D-(d.timeoutMs|0||_f)}function Sv(){for(;Gn!==null;)Gn=Xd(Gn)}function ey(){for(;Gn!==null&&!Ln();)Gn=Xd(Gn)}function Xd(c){var d=c.alternate;$l(c),wt(c);var D;return en&&(c.mode&ni)!==Ar?(H2(c),D=N1(d,c,q0),p1(c,!0)):D=N1(d,c,q0),ut(),c.memoizedProps=c.pendingProps,D===null&&(D=Tv(c)),Dp.current=null,D}function Tv(c){Gn=c;do{var d=Gn.alternate,D=Gn.return;if((Gn.effectTag&P0)===xi){wt(Gn);var C=void 0;if(!en||(Gn.mode&ni)===Ar?C=tv(d,Gn,q0):(H2(Gn),C=tv(d,Gn,q0),p1(Gn,!1)),Zr(Gn),ut(),ty(Gn),C!==null)return C;if(D!==null&&(D.effectTag&P0)===xi){D.firstEffect===null&&(D.firstEffect=Gn.firstEffect),Gn.lastEffect!==null&&(D.lastEffect!==null&&(D.lastEffect.nextEffect=Gn.firstEffect),D.lastEffect=Gn.lastEffect);var O=Gn.effectTag;O>lu&&(D.lastEffect!==null?D.lastEffect.nextEffect=Gn:D.firstEffect=Gn,D.lastEffect=Gn)}}else{var z=Mm(Gn,q0);if(en&&(Gn.mode&ni)!==Ar){p1(Gn,!1);for(var G=Gn.actualDuration,ne=Gn.child;ne!==null;)G+=ne.actualDuration,ne=ne.sibling;Gn.actualDuration=G}if(z!==null)return ho(Gn),z.effectTag&=Kl,z;Zr(Gn),D!==null&&(D.firstEffect=D.lastEffect=null,D.effectTag|=P0)}var se=Gn.sibling;if(se!==null)return se;Gn=D}while(Gn!==null);return k0===bf&&(k0=Tp),null}function Mp(c){var d=c.expirationTime,D=c.childExpirationTime;return d>D?d:D}function ty(c){if(!(q0!==Di&&c.childExpirationTime===Di)){var d=ft;if(en&&(c.mode&ni)!==Ar){for(var D=c.actualDuration,C=c.selfBaseDuration,O=c.alternate===null||c.child!==c.alternate.child,z=c.child;z!==null;){var G=z.expirationTime,ne=z.childExpirationTime;G>d&&(d=G),ne>d&&(d=ne),O&&(D+=z.actualDuration),C+=z.treeBaseDuration,z=z.sibling}c.actualDuration=D,c.treeBaseDuration=C}else for(var se=c.child;se!==null;){var Ue=se.expirationTime,Xe=se.childExpirationTime;Ue>d&&(d=Ue),Xe>d&&(d=Xe),se=se.sibling}c.childExpirationTime=d}}function l0(c){var d=Qt();return Sn(Li,kp.bind(null,c,d)),null}function kp(c,d){do tf();while(Mc!==null);if(ay(),(nr&(To|As))!==yu)throw Error("Should not already be working.");var D=c.finishedWork,C=c.finishedExpirationTime;if(D===null)return null;if(c.finishedWork=null,c.finishedExpirationTime=ft,D===c.current)throw Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");c.callbackNode=null,c.callbackExpirationTime=ft,c.callbackPriority=_0,c.nextKnownPendingLevel=ft,eo();var O=Mp(D);q4(c,C,O),c===ml&&(ml=null,Gn=null,q0=ft);var z;if(D.effectTag>lu?D.lastEffect!==null?(D.lastEffect.nextEffect=D,z=D.firstEffect):z=D:z=D.firstEffect,z!==null){var G=nr;nr|=As;var ne=Gd(c);Dp.current=null,xe(),Hn(c.containerInfo),dn=z;do if(pl(null,ny,null),tr()){if(dn===null)throw Error("Should be working on an effect.");var se=Qs();Hf(dn,se),dn=dn.nextEffect}while(dn!==null);tt(),en&&Nh(),Ke(),dn=z;do if(pl(null,ry,null,c,d),tr()){if(dn===null)throw Error("Should be working on an effect.");var Ue=Qs();Hf(dn,Ue),dn=dn.nextEffect}while(dn!==null);Yt(),qr(c.containerInfo),c.current=D,Kt(),dn=z;do if(pl(null,Np,null,c,C),tr()){if(dn===null)throw Error("Should be working on an effect.");var Xe=Qs();Hf(dn,Xe),dn=dn.nextEffect}while(dn!==null);pr(),dn=null,fe(),In&&Yd(ne),nr=G}else c.current=D,xe(),tt(),en&&Nh(),Ke(),Yt(),Kt(),pr();to();var ht=Oc;if(Oc)Oc=!1,Mc=c,xp=C,A1=d;else for(dn=z;dn!==null;){var Lt=dn.nextEffect;dn.nextEffect=null,dn=Lt}var Gt=c.firstPendingTime;if(Gt!==ft){if(In){if(Uf!==null){var Ht=Uf;Uf=null;for(var yn=0;yn<Ht.length;yn++)I(c,Ht[yn],c.memoizedInteractions)}W(c,Gt)}}else Ac=null;if(In&&(ht||pe(c,C)),Gt===Un?c===Hd?kc++:(kc=0,Hd=c):kc=0,on(D.stateNode,C),Wo(c),jd){jd=!1;var kr=zd;throw zd=null,kr}return(nr&Id)!==yu||Ut(),null}function ny(){for(;dn!==null;){var c=dn.effectTag;if((c&Mo)!==xi){wt(dn),Uo();var d=dn.alternate;yp(d,dn),ut()}(c&F0)!==xi&&(Oc||(Oc=!0,_n(Kn,function(){return tf(),null}))),dn=dn.nextEffect}}function ry(c,d){for(;dn!==null;){wt(dn);var D=dn.effectTag;if(D&Bu&&lv(dn),D&Oo){var C=dn.alternate;C!==null&&Gu(C)}var O=D&(vi|Dr|Y0|su);switch(O){case vi:{Cc(dn),dn.effectTag&=~vi;break}case el:{Cc(dn),dn.effectTag&=~vi;var z=dn.alternate;Pd(z,dn);break}case su:{dn.effectTag&=~su;break}case ki:{dn.effectTag&=~su;var G=dn.alternate;Pd(G,dn);break}case Dr:{var ne=dn.alternate;Pd(ne,dn);break}case Y0:{Um(c,dn,d);break}}Uo(),ut(),dn=dn.nextEffect}}function Np(c,d){for(;dn!==null;){wt(dn);var D=dn.effectTag;if(D&(Dr|K0)){Uo();var C=dn.alternate;gp(c,C,dn,d)}D&Oo&&(Uo(),Iu(dn)),ut(),dn=dn.nextEffect}}function tf(){if(A1!==_0){var c=A1>Kn?Kn:A1;return A1=_0,Sn(c,Lp)}}function Lp(){if(Mc===null)return!1;var c=Mc,d=xp;if(Mc=null,xp=ft,(nr&(To|As))!==yu)throw Error("Cannot flush passive effects while already rendering.");var D=nr;nr|=As;for(var C=Gd(c),O=c.current.firstEffect;O!==null;){{if(wt(O),pl(null,xa,null,O),tr()){if(O===null)throw Error("Should be working on an effect.");var z=Qs();Hf(O,z)}ut()}var G=O.nextEffect;O.nextEffect=null,O=G}return In&&(Yd(C),pe(c,d)),nr=D,Ut(),O1=Mc===null?0:O1+1,!0}function Fp(c){return Ac!==null&&Ac.has(c)}function Pp(c){Ac===null?Ac=new Set([c]):Ac.add(c)}function iy(c){jd||(jd=!0,zd=c)}var uy=iy;function Cv(c,d,D){var C=dp(D,d),O=sv(c,C,Un);Va(c,O);var z=qd(c,Un);z!==null&&(Wo(z),W(z,Un))}function Hf(c,d){if(c.tag===j){Cv(c,c,d);return}for(var D=c.return;D!==null;){if(D.tag===j){Cv(D,c,d);return}else if(D.tag===k){var C=D.type,O=D.stateNode;if(typeof C.getDerivedStateFromError=="function"||typeof O.componentDidCatch=="function"&&!Fp(O)){var z=dp(d,c),G=av(D,z,Un);Va(D,G);var ne=qd(D,Un);ne!==null&&(Wo(ne),W(ne,Un));return}}D=D.return}}function Ip(c,d,D){var C=c.pingCache;if(C!==null&&C.delete(d),ml===c&&q0===D){k0===x1||k0===C1&&Ul===Un&&mt()-Cp<N0?zf(c,q0):Ud=!0;return}if(!!Yg(c,D)){var O=c.lastPingedTime;O!==ft&&O<D||(c.lastPingedTime=D,c.finishedExpirationTime===D&&(c.finishedExpirationTime=ft,c.finishedWork=null),Wo(c),W(c,D))}}function xv(c,d){if(d===ft){var D=null,C=jl();d=jf(C,c,D)}var O=qd(c,d);O!==null&&(Wo(O),W(O,d))}function oy(c){var d=c.memoizedState,D=ft;d!==null&&(D=d.retryTime),xv(c,D)}function ly(c,d){var D=ft,C;if(Ai)switch(c.tag){case he:C=c.stateNode;var O=c.memoizedState;O!==null&&(D=O.retryTime);break;case gt:C=c.stateNode;break;default:throw Error("Pinged unknown suspense boundary type. This is probably a bug in React.")}else C=c.stateNode;C!==null&&C.delete(d),xv(c,D)}function bp(c){return c<120?120:c<480?480:c<1080?1080:c<1920?1920:c<3e3?3e3:c<4320?4320:Aa(c/1960)*1960}function Bp(c,d,D){var C=D.busyMinDurationMs|0;if(C<=0)return 0;var O=D.busyDelayMs|0,z=mt(),G=$m(c,D),ne=z-G;if(ne<=O)return 0;var se=O+C-ne;return se}function sy(){if(kc>Hm)throw kc=0,Hd=null,Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");O1>cv&&(O1=0,Xt(!1,"Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render."))}function ay(){Al.flushLegacyContextWarning(),mi&&Al.flushPendingUnsafeLifecycleWarnings()}function Rv(){var c=!0;yf(Bf,c),Bf=null}function Up(){var c=!1;yf(Bf,c),Bf=null}function jp(c,d){Hr&&ml!==null&&d>q0&&(Bf=c)}var Qd=null;function fy(c){{var d=c.tag;if(d!==j&&d!==k&&d!==F&&d!==ae&&d!==ve&&d!==ue)return;var D=qt(c.type)||"ReactComponent";if(Qd!==null){if(Qd.has(D))return;Qd.add(D)}else Qd=new Set([D]);Ve(!1,"Can't perform a React state update on an unmounted component. This is a no-op, but it indicates a memory leak in your application. To fix, cancel all subscriptions and asynchronous tasks in %s.%s",d===k?"the componentWillUnmount method":"a useEffect cleanup function",Cr(c))}}var N1;if(X0){var cy=null;N1=function(c,d,D){var C=Gg(cy,d);try{return lp(c,d,D)}catch(z){if(z!==null&&typeof z=="object"&&typeof z.then=="function")throw z;if(yt(),_d(),nv(d),Gg(d,C),en&&d.mode&ni&&H2(d),pl(null,lp,null,c,d,D),tr()){var O=Qs();throw O}else throw z}}}else N1=lp;var Av=!1,Ov=!1;function dy(c){if(c.tag===k)switch(Nr){case"getChildContext":if(Ov)return;Ve(!1,"setState(...): Cannot call setState() inside getChildContext()"),Ov=!0;break;case"render":if(Av)return;Ve(!1,"Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state."),Av=!0;break}}var qf={current:!1};function zp(c){vs===!0&&vl.current===!0&&qf.current!==!0&&Ve(!1,`It looks like you're using the wrong act() around your test interactions.
+Be sure to use the matching version of act() corresponding to your renderer:
+
+// for react-dom:
+import {act} from 'react-dom/test-utils';
+// ...
+act(() => ...);
+
+// for react-test-renderer:
+import TestRenderer from 'react-test-renderer';
+const {act} = TestRenderer;
+// ...
+act(() => ...);%s`,Cr(c))}function Mv(c){vs===!0&&(c.mode&mr)!==Ar&&vl.current===!1&&qf.current===!1&&Ve(!1,`An update to %s ran an effect, but was not wrapped in act(...).
+
+When testing, code that causes React state updates should be wrapped into act(...):
+
+act(() => {
+  /* fire events that update state */
+});
+/* assert on the output */
+
+This ensures that you're testing the behavior the user would see in the browser. Learn more at https://fb.me/react-wrap-tests-with-act%s`,qt(c.type),Cr(c))}function py(c){vs===!0&&nr===yu&&vl.current===!1&&qf.current===!1&&Ve(!1,`An update to %s inside a test was not wrapped in act(...).
+
+When testing, code that causes React state updates should be wrapped into act(...):
+
+act(() => {
+  /* fire events that update state */
+});
+/* assert on the output */
+
+This ensures that you're testing the behavior the user would see in the browser. Learn more at https://fb.me/react-wrap-tests-with-act%s`,qt(c.type),Cr(c))}var hy=py,Hp=!1;function vy(c){Hp===!1&&t.unstable_flushAllWithoutAsserting===void 0&&(c.mode&K||c.mode&ti?(Hp=!0,Ve(!1,`In Concurrent or Sync modes, the "scheduler" module needs to be mocked to guarantee consistent behaviour across tests and browsers. For example, with jest: 
+jest.mock('scheduler', () => require('scheduler/unstable_mock'));
+
+For more info, visit https://fb.me/react-mock-scheduler`)):eu===!0&&(Hp=!0,Ve(!1,`Starting from React v17, the "scheduler" module will need to be mocked to guarantee consistent behaviour across tests and browsers. For example, with jest: 
+jest.mock('scheduler', () => require('scheduler/unstable_mock'));
+
+For more info, visit https://fb.me/react-mock-scheduler`)))}var Zs=null;function my(c){{var d=Qt();if((c.mode&ti)!==xi&&(d===ei||d===Li))for(var D=c;D!==null;){var C=D.alternate;if(C!==null)switch(D.tag){case k:var O=C.updateQueue;if(O!==null)for(var z=O.firstUpdate;z!==null;){var G=z.priority;if(G===ei||G===Li){Zs===null?Zs=new Set([qt(D.type)]):Zs.add(qt(D.type));break}z=z.next}break;case F:case ae:case ue:if(D.memoizedState!==null&&D.memoizedState.baseUpdate!==null)for(var ne=D.memoizedState.baseUpdate;ne!==null;){var se=ne.priority;if(se===ei||se===Li){Zs===null?Zs=new Set([qt(D.type)]):Zs.add(qt(D.type));break}if(ne.next===D.memoizedState.baseUpdate)break;ne=ne.next}break;default:break}D=D.return}}}function p(){if(Zs!==null){var c=[];Zs.forEach(function(d){return c.push(d)}),Zs=null,c.length>0&&Ve(!1,`%s triggered a user-blocking update that suspended.
+
+The fix is to split the update into multiple parts: a user-blocking update to provide immediate feedback, and another update that triggers the bulk of the changes.
+
+Refer to the documentation for useTransition to learn how to implement this pattern.`,c.sort().join(", "))}}function m(c,d){return d*1e3+c.interactionThreadID}function R(c){!In||(Uf===null?Uf=[c]:Uf.push(c))}function I(c,d,D){if(!!In&&D.size>0){var C=c.pendingInteractionMap,O=C.get(d);O!=null?D.forEach(function(ne){O.has(ne)||ne.__count++,O.add(ne)}):(C.set(d,new Set(D)),D.forEach(function(ne){ne.__count++}));var z=N.__subscriberRef.current;if(z!==null){var G=m(c,d);z.onWorkScheduled(D,G)}}}function W(c,d){!In||I(c,d,N.__interactionsRef.current)}function te(c,d){if(!!In){var D=new Set;if(c.pendingInteractionMap.forEach(function(z,G){G>=d&&z.forEach(function(ne){return D.add(ne)})}),c.memoizedInteractions=D,D.size>0){var C=N.__subscriberRef.current;if(C!==null){var O=m(c,d);try{C.onWorkStarted(D,O)}catch(z){_n(Li,function(){throw z})}}}}}function pe(c,d){if(!!In){var D=c.firstPendingTime,C;try{if(C=N.__subscriberRef.current,C!==null&&c.memoizedInteractions.size>0){var O=m(c,d);C.onWorkStopped(c.memoizedInteractions,O)}}catch(G){_n(Li,function(){throw G})}finally{var z=c.pendingInteractionMap;z.forEach(function(G,ne){ne>D&&(z.delete(ne),G.forEach(function(se){if(se.__count--,C!==null&&se.__count===0)try{C.onInteractionScheduledWorkCompleted(se)}catch(Ue){_n(Li,function(){throw Ue})}}))})}}}var Ee=null,be=null,Dt=!1,Tt=typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u";function Ot(c){if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u")return!1;var d=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(d.isDisabled)return!0;if(!d.supportsFiber)return Ve(!1,"The installed version of React DevTools is too old and will not work with the current version of React. Please update React DevTools. https://fb.me/react-devtools"),!0;try{var D=d.inject(c);Ee=function(C,O){try{var z=(C.current.effectTag&Kr)===Kr;if(en){var G=Nc(),ne=nd(G,O);d.onCommitFiberRoot(D,C,ne,z)}else d.onCommitFiberRoot(D,C,void 0,z)}catch(se){Dt||(Dt=!0,Ve(!1,"React DevTools encountered an error: %s",se))}},be=function(C){try{d.onCommitFiberUnmount(D,C)}catch(O){Dt||(Dt=!0,Ve(!1,"React DevTools encountered an error: %s",O))}}}catch(C){Ve(!1,"React DevTools encountered an error: %s.",C)}return!0}function on(c,d){typeof Ee=="function"&&Ee(c,d)}function Mn(c){typeof be=="function"&&be(c)}var rr;{rr=!1;try{var br=Object.preventExtensions({}),ar=new Map([[br,null]]),ri=new Set([br]);ar.set(0,0),ri.add(0)}catch{rr=!0}}var fi=1;function zl(c,d,D,C){this.tag=c,this.key=D,this.elementType=null,this.type=null,this.stateNode=null,this.return=null,this.child=null,this.sibling=null,this.index=0,this.ref=null,this.pendingProps=d,this.memoizedProps=null,this.updateQueue=null,this.memoizedState=null,this.dependencies=null,this.mode=C,this.effectTag=xi,this.nextEffect=null,this.firstEffect=null,this.lastEffect=null,this.expirationTime=ft,this.childExpirationTime=ft,this.alternate=null,en&&(this.actualDuration=Number.NaN,this.actualStartTime=Number.NaN,this.selfBaseDuration=Number.NaN,this.treeBaseDuration=Number.NaN,this.actualDuration=0,this.actualStartTime=-1,this.selfBaseDuration=0,this.treeBaseDuration=0),Hr&&(this._debugID=fi++,this._debugIsCurrentlyTiming=!1),this._debugSource=null,this._debugOwner=null,this._debugNeedsRemount=!1,this._debugHookTypes=null,!rr&&typeof Object.preventExtensions=="function"&&Object.preventExtensions(this)}var Zi=function(c,d,D,C){return new zl(c,d,D,C)};function so(c){var d=c.prototype;return!!(d&&d.isReactComponent)}function s0(c){return typeof c=="function"&&!so(c)&&c.defaultProps===void 0}function Os(c){if(typeof c=="function")return so(c)?k:F;if(c!=null){var d=c.$$typeof;if(d===On)return ae;if(d===Vt)return ve}return x}function Co(c,d,D){var C=c.alternate;C===null?(C=Zi(c.tag,d,c.key,c.mode),C.elementType=c.elementType,C.type=c.type,C.stateNode=c.stateNode,C._debugID=c._debugID,C._debugSource=c._debugSource,C._debugOwner=c._debugOwner,C._debugHookTypes=c._debugHookTypes,C.alternate=c,c.alternate=C):(C.pendingProps=d,C.effectTag=xi,C.nextEffect=null,C.firstEffect=null,C.lastEffect=null,en&&(C.actualDuration=0,C.actualStartTime=-1)),C.childExpirationTime=c.childExpirationTime,C.expirationTime=c.expirationTime,C.child=c.child,C.memoizedProps=c.memoizedProps,C.memoizedState=c.memoizedState,C.updateQueue=c.updateQueue;var O=c.dependencies;switch(C.dependencies=O===null?null:{expirationTime:O.expirationTime,firstContext:O.firstContext,responders:O.responders},C.sibling=c.sibling,C.index=c.index,C.ref=c.ref,en&&(C.selfBaseDuration=c.selfBaseDuration,C.treeBaseDuration=c.treeBaseDuration),C._debugNeedsRemount=c._debugNeedsRemount,C.tag){case x:case F:case ue:C.type=n0(c.type);break;case k:C.type=j0(c.type);break;case ae:C.type=Df(c.type);break;default:break}return C}function kv(c,d){c.effectTag&=vi,c.nextEffect=null,c.firstEffect=null,c.lastEffect=null;var D=c.alternate;if(D===null)c.childExpirationTime=ft,c.expirationTime=d,c.child=null,c.memoizedProps=null,c.memoizedState=null,c.updateQueue=null,c.dependencies=null,en&&(c.selfBaseDuration=0,c.treeBaseDuration=0);else{c.childExpirationTime=D.childExpirationTime,c.expirationTime=D.expirationTime,c.child=D.child,c.memoizedProps=D.memoizedProps,c.memoizedState=D.memoizedState,c.updateQueue=D.updateQueue;var C=D.dependencies;c.dependencies=C===null?null:{expirationTime:C.expirationTime,firstContext:C.firstContext,responders:C.responders},en&&(c.selfBaseDuration=D.selfBaseDuration,c.treeBaseDuration=D.treeBaseDuration)}return c}function F4(c){var d;return c===O0?d=ti|K|mr:c===B0?d=K|mr:d=Ar,en&&Tt&&(d|=ni),Zi(j,null,null,d)}function yy(c,d,D,C,O,z){var G,ne=x,se=c;if(typeof c=="function")so(c)?(ne=k,se=j0(se)):se=n0(se);else if(typeof c=="string")ne=V;else{e:switch(c){case le:return nf(D.children,O,z,d);case an:ne=me,O|=ti|K|mr;break;case He:ne=me,O|=mr;break;case dt:return I4(D,O,z,d);case lr:return b4(D,O,z,d);case ln:return B4(D,O,z,d);default:{if(typeof c=="object"&&c!==null)switch(c.$$typeof){case At:ne=ge;break e;case nn:ne=De;break e;case On:ne=ae,se=Df(se);break e;case Vt:ne=ve;break e;case Er:ne=Ae,se=null;break e;case S:if(Wt)return Vg(c,D,O,z,d);break;case Xn:if(Ru)return P4(c,D,O,z,d)}var Ue="";{(c===void 0||typeof c=="object"&&c!==null&&Object.keys(c).length===0)&&(Ue+=" You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");var Xe=C?qt(C.type):null;Xe&&(Ue+=`
+
+Check the render method of \``+Xe+"`.")}throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: "+(c==null?c:typeof c)+"."+Ue)}}}return G=Zi(ne,D,d,O),G.elementType=c,G.type=se,G.expirationTime=z,G}function gy(c,d,D){var C=null;C=c._owner;var O=c.type,z=c.key,G=c.props,ne=yy(O,z,G,C,d,D);return ne._debugSource=c._source,ne._debugOwner=c._owner,ne}function nf(c,d,D,C){var O=Zi(y,c,C,d);return O.expirationTime=D,O}function Vg(c,d,D,C,O){var z=Zi(_t,d,O,D);return z.elementType=c,z.type=c,z.expirationTime=C,z}function P4(c,d,D,C,O){var z=Zi(Qe,d,O,D);return z.type=c,z.elementType=c,z.expirationTime=C,z}function I4(c,d,D,C){(typeof c.id!="string"||typeof c.onRender!="function")&&Ve(!1,'Profiler must specify an "id" string and "onRender" function as props');var O=Zi(we,c,C,d|ni);return O.elementType=dt,O.type=dt,O.expirationTime=D,O}function b4(c,d,D,C){var O=Zi(he,c,C,d);return O.type=lr,O.elementType=lr,O.expirationTime=D,O}function B4(c,d,D,C){var O=Zi(gt,c,C,d);return O.type=ln,O.elementType=ln,O.expirationTime=D,O}function _y(c,d,D){var C=Zi(re,c,null,d);return C.expirationTime=D,C}function U4(){var c=Zi(V,null,null,Ar);return c.elementType="DELETED",c.type="DELETED",c}function j4(c){var d=Zi(We,null,null,Ar);return d.stateNode=c,d}function Ey(c,d,D){var C=c.children!==null?c.children:[],O=Zi(q,C,c.key,d);return O.expirationTime=D,O.stateNode={containerInfo:c.containerInfo,pendingChildren:null,implementation:c.implementation},O}function Gg(c,d){return c===null&&(c=Zi(x,null,null,Ar)),c.tag=d.tag,c.key=d.key,c.elementType=d.elementType,c.type=d.type,c.stateNode=d.stateNode,c.return=d.return,c.child=d.child,c.sibling=d.sibling,c.index=d.index,c.ref=d.ref,c.pendingProps=d.pendingProps,c.memoizedProps=d.memoizedProps,c.updateQueue=d.updateQueue,c.memoizedState=d.memoizedState,c.dependencies=d.dependencies,c.mode=d.mode,c.effectTag=d.effectTag,c.nextEffect=d.nextEffect,c.firstEffect=d.firstEffect,c.lastEffect=d.lastEffect,c.expirationTime=d.expirationTime,c.childExpirationTime=d.childExpirationTime,c.alternate=d.alternate,en&&(c.actualDuration=d.actualDuration,c.actualStartTime=d.actualStartTime,c.selfBaseDuration=d.selfBaseDuration,c.treeBaseDuration=d.treeBaseDuration),c._debugID=d._debugID,c._debugSource=d._debugSource,c._debugOwner=d._debugOwner,c._debugIsCurrentlyTiming=d._debugIsCurrentlyTiming,c._debugNeedsRemount=d._debugNeedsRemount,c._debugHookTypes=d._debugHookTypes,c}function z4(c,d,D){this.tag=d,this.current=null,this.containerInfo=c,this.pendingChildren=null,this.pingCache=null,this.finishedExpirationTime=ft,this.finishedWork=null,this.timeoutHandle=nl,this.context=null,this.pendingContext=null,this.hydrate=D,this.callbackNode=null,this.callbackPriority=_0,this.firstPendingTime=ft,this.firstSuspendedTime=ft,this.lastSuspendedTime=ft,this.nextKnownPendingLevel=ft,this.lastPingedTime=ft,this.lastExpiredTime=ft,In&&(this.interactionThreadID=N.unstable_getThreadID(),this.memoizedInteractions=new Set,this.pendingInteractionMap=new Map),Yi&&(this.hydrationCallbacks=null)}function H4(c,d,D,C){var O=new z4(c,d,D);Yi&&(O.hydrationCallbacks=C);var z=F4(d);return O.current=z,z.stateNode=O,O}function Yg(c,d){var D=c.firstSuspendedTime,C=c.lastSuspendedTime;return D!==ft&&D>=d&&C<=d}function Wf(c,d){var D=c.firstSuspendedTime,C=c.lastSuspendedTime;D<d&&(c.firstSuspendedTime=d),(C>d||D===ft)&&(c.lastSuspendedTime=d),d<=c.lastPingedTime&&(c.lastPingedTime=ft),d<=c.lastExpiredTime&&(c.lastExpiredTime=ft)}function Kg(c,d){var D=c.firstPendingTime;d>D&&(c.firstPendingTime=d);var C=c.firstSuspendedTime;C!==ft&&(d>=C?c.firstSuspendedTime=c.lastSuspendedTime=c.nextKnownPendingLevel=ft:d>=c.lastSuspendedTime&&(c.lastSuspendedTime=d+1),d>c.nextKnownPendingLevel&&(c.nextKnownPendingLevel=d))}function q4(c,d,D){c.firstPendingTime=D,d<=c.lastSuspendedTime?c.firstSuspendedTime=c.lastSuspendedTime=c.nextKnownPendingLevel=ft:d<=c.firstSuspendedTime&&(c.firstSuspendedTime=d-1),d<=c.lastPingedTime&&(c.lastPingedTime=ft),d<=c.lastExpiredTime&&(c.lastExpiredTime=ft)}function qp(c,d){var D=c.lastExpiredTime;(D===ft||D>d)&&(c.lastExpiredTime=d)}var W4={debugTool:null},Nv=W4,Dy,wy;Dy=!1,wy={};function V4(c){if(!c)return xn;var d=Pt(c),D=xl(d);if(d.tag===k){var C=d.type;if(Xi(C))return A0(d,C,D)}return D}function Sy(c){var d=Pt(c);if(d===void 0)throw typeof c.render=="function"?Error("Unable to find node on an unmounted component."):Error("Argument appears to not be a ReactComponent. Keys: "+Object.keys(c));var D=I0(d);return D===null?null:D.stateNode}function G4(c,d){{var D=Pt(c);if(D===void 0)throw typeof c.render=="function"?Error("Unable to find node on an unmounted component."):Error("Argument appears to not be a ReactComponent. Keys: "+Object.keys(c));var C=I0(D);if(C===null)return null;if(C.mode&mr){var O=qt(D.type)||"Component";wy[O]||(wy[O]=!0,D.mode&mr?Ve(!1,"%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://fb.me/react-strict-mode-find-node%s",d,d,O,Cr(C)):Ve(!1,"%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://fb.me/react-strict-mode-find-node%s",d,d,O,Cr(C)))}return C.stateNode}return Sy(c)}function Y4(c,d,D,C){return H4(c,d,D,C)}function Xg(c,d,D,C){var O=d.current,z=jl();typeof jest<"u"&&(vy(O),zp(O));var G=_o(),ne=jf(z,O,G);Nv.debugTool&&(O.alternate===null?Nv.debugTool.onMountContainer(d):c===null?Nv.debugTool.onUnmountContainer(d):Nv.debugTool.onUpdateContainer(d));var se=V4(D);d.context===null?d.context=se:d.pendingContext=se,Nr==="render"&&Rn!==null&&!Dy&&(Dy=!0,Ve(!1,`Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.
+
+Check the render method of %s.`,qt(Rn.type)||"Unknown"));var Ue=Tu(ne,G);return Ue.payload={element:c},C=C===void 0?null:C,C!==null&&(typeof C!="function"&&Ve(!1,"render(...): Expected the last optional `callback` argument to be a function. Instead received: %s.",C),Ue.callback=C),Va(O,Ue),yl(O,ne),ne}function K4(c){var d=c.current;if(!d.child)return null;switch(d.child.tag){case V:return Lo(d.child.stateNode);default:return d.child.stateNode}}function X4(c){switch(c.tag){case j:var d=c.stateNode;d.hydrate&&Gm(d,d.firstPendingTime);break;case he:Rp(function(){return yl(c,Un)});var D=Ua(jl());Lv(c,D);break}}function Qg(c,d){var D=c.memoizedState;D!==null&&D.dehydrated!==null&&D.retryTime<d&&(D.retryTime=d)}function Lv(c,d){Qg(c,d);var D=c.alternate;D&&Qg(D,d)}function Q4(c){if(c.tag===he){var d=Ua(jl());yl(c,d),Lv(c,d)}}function Ty(c){if(c.tag===he){var d=_2(jl());yl(c,d),Lv(c,d)}}function J4(c){if(c.tag===he){var d=jl(),D=jf(d,c,null);yl(c,D),Lv(c,D)}}function Z4(c){var d=Sl(c);return d===null?null:d.tag===_t?d.stateNode.instance:d.stateNode}var Cy=function(c){return!1};function Jg(c){return Cy(c)}var Zg=null,$g=null,e_=null,t_=null;{var xy=function(c,d,D,C){if(D>=d.length)return C;var O=d[D],z=Array.isArray(c)?c.slice():f({},c);return z[O]=xy(c[O],d,D+1,C),z},n_=function(c,d,D){return xy(c,d,0,D)};Zg=function(c,d,D,C){for(var O=c.memoizedState;O!==null&&d>0;)O=O.next,d--;if(O!==null){var z=n_(O.memoizedState,D,C);O.memoizedState=z,O.baseState=z,c.memoizedProps=f({},c.memoizedProps),yl(c,Un)}},$g=function(c,d,D){c.pendingProps=n_(c.memoizedProps,d,D),c.alternate&&(c.alternate.pendingProps=c.pendingProps),yl(c,Un)},e_=function(c){yl(c,Un)},t_=function(c){Cy=c}}function $4(c){var d=c.findFiberByHostInstance,D=it.ReactCurrentDispatcher;return Ot(f({},c,{overrideHookState:Zg,overrideProps:$g,setSuspenseHandler:t_,scheduleUpdate:e_,currentDispatcherRef:D,findHostInstanceByFiber:function(C){var O=I0(C);return O===null?null:O.stateNode},findFiberByHostInstance:function(C){return d?d(C):null},findHostInstancesForRefresh:ud,scheduleRefresh:Ol,scheduleRoot:Ts,setRefreshHandler:qa,getCurrentFiber:function(){return Rn}}))}var r_=Object.freeze({createContainer:Y4,updateContainer:Xg,batchedEventUpdates:Qm,batchedUpdates:Xm,unbatchedUpdates:Jm,deferredUpdates:Ym,syncUpdates:pv,discreteUpdates:hv,flushDiscreteUpdates:dv,flushControlled:Zm,flushSync:Rp,flushPassiveEffects:tf,IsThisRendererActing:qf,getPublicRootInstance:K4,attemptSynchronousHydration:X4,attemptUserBlockingHydration:Q4,attemptContinuousHydration:Ty,attemptHydrationAtCurrentPriority:J4,findHostInstance:Sy,findHostInstanceWithWarning:G4,findHostInstanceWithNoPortals:Z4,shouldSuspend:Jg,injectIntoDevTools:$4}),eE=r_.default||r_;Yy.exports=eE;var tE=Yy.exports;return Yy.exports=o,tE})});var YS=nt((DH,mD)=>{"use strict";process.env.NODE_ENV==="production"?mD.exports=HS():mD.exports=GS()});var XS=nt((wH,KS)=>{"use strict";var EP={ALIGN_COUNT:8,ALIGN_AUTO:0,ALIGN_FLEX_START:1,ALIGN_CENTER:2,ALIGN_FLEX_END:3,ALIGN_STRETCH:4,ALIGN_BASELINE:5,ALIGN_SPACE_BETWEEN:6,ALIGN_SPACE_AROUND:7,DIMENSION_COUNT:2,DIMENSION_WIDTH:0,DIMENSION_HEIGHT:1,DIRECTION_COUNT:3,DIRECTION_INHERIT:0,DIRECTION_LTR:1,DIRECTION_RTL:2,DISPLAY_COUNT:2,DISPLAY_FLEX:0,DISPLAY_NONE:1,EDGE_COUNT:9,EDGE_LEFT:0,EDGE_TOP:1,EDGE_RIGHT:2,EDGE_BOTTOM:3,EDGE_START:4,EDGE_END:5,EDGE_HORIZONTAL:6,EDGE_VERTICAL:7,EDGE_ALL:8,EXPERIMENTAL_FEATURE_COUNT:1,EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS:0,FLEX_DIRECTION_COUNT:4,FLEX_DIRECTION_COLUMN:0,FLEX_DIRECTION_COLUMN_REVERSE:1,FLEX_DIRECTION_ROW:2,FLEX_DIRECTION_ROW_REVERSE:3,JUSTIFY_COUNT:6,JUSTIFY_FLEX_START:0,JUSTIFY_CENTER:1,JUSTIFY_FLEX_END:2,JUSTIFY_SPACE_BETWEEN:3,JUSTIFY_SPACE_AROUND:4,JUSTIFY_SPACE_EVENLY:5,LOG_LEVEL_COUNT:6,LOG_LEVEL_ERROR:0,LOG_LEVEL_WARN:1,LOG_LEVEL_INFO:2,LOG_LEVEL_DEBUG:3,LOG_LEVEL_VERBOSE:4,LOG_LEVEL_FATAL:5,MEASURE_MODE_COUNT:3,MEASURE_MODE_UNDEFINED:0,MEASURE_MODE_EXACTLY:1,MEASURE_MODE_AT_MOST:2,NODE_TYPE_COUNT:2,NODE_TYPE_DEFAULT:0,NODE_TYPE_TEXT:1,OVERFLOW_COUNT:3,OVERFLOW_VISIBLE:0,OVERFLOW_HIDDEN:1,OVERFLOW_SCROLL:2,POSITION_TYPE_COUNT:2,POSITION_TYPE_RELATIVE:0,POSITION_TYPE_ABSOLUTE:1,PRINT_OPTIONS_COUNT:3,PRINT_OPTIONS_LAYOUT:1,PRINT_OPTIONS_STYLE:2,PRINT_OPTIONS_CHILDREN:4,UNIT_COUNT:4,UNIT_UNDEFINED:0,UNIT_POINT:1,UNIT_PERCENT:2,UNIT_AUTO:3,WRAP_COUNT:3,WRAP_NO_WRAP:0,WRAP_WRAP:1,WRAP_WRAP_REVERSE:2};KS.exports=EP});var $S=nt((SH,ZS)=>{"use strict";var DP=Object.assign||function(o){for(var l=1;l<arguments.length;l++){var f=arguments[l];for(var h in f)Object.prototype.hasOwnProperty.call(f,h)&&(o[h]=f[h])}return o},H_=function(){function o(l,f){for(var h=0;h<f.length;h++){var E=f[h];E.enumerable=E.enumerable||!1,E.configurable=!0,"value"in E&&(E.writable=!0),Object.defineProperty(l,E.key,E)}}return function(l,f,h){return f&&o(l.prototype,f),h&&o(l,h),l}}();function yD(o,l,f){return l in o?Object.defineProperty(o,l,{value:f,enumerable:!0,configurable:!0,writable:!0}):o[l]=f,o}function gD(o,l){if(!(o instanceof l))throw new TypeError("Cannot call a class as a function")}var tc=XS(),wP=function(){function o(l,f,h,E,t,N){gD(this,o),this.left=l,this.right=f,this.top=h,this.bottom=E,this.width=t,this.height=N}return H_(o,[{key:"fromJS",value:function(f){f(this.left,this.right,this.top,this.bottom,this.width,this.height)}},{key:"toString",value:function(){return"<Layout#"+this.left+":"+this.right+";"+this.top+":"+this.bottom+";"+this.width+":"+this.height+">"}}]),o}(),QS=function(){H_(o,null,[{key:"fromJS",value:function(f){var h=f.width,E=f.height;return new o(h,E)}}]);function o(l,f){gD(this,o),this.width=l,this.height=f}return H_(o,[{key:"fromJS",value:function(f){f(this.width,this.height)}},{key:"toString",value:function(){return"<Size#"+this.width+"x"+this.height+">"}}]),o}(),JS=function(){function o(l,f){gD(this,o),this.unit=l,this.value=f}return H_(o,[{key:"fromJS",value:function(f){f(this.unit,this.value)}},{key:"toString",value:function(){switch(this.unit){case tc.UNIT_POINT:return String(this.value);case tc.UNIT_PERCENT:return this.value+"%";case tc.UNIT_AUTO:return"auto";default:return this.value+"?"}}},{key:"valueOf",value:function(){return this.value}}]),o}();ZS.exports=function(o,l){function f(N,F,k){var x=N[F];N[F]=function(){for(var j=arguments.length,q=Array(j),V=0;V<j;V++)q[V]=arguments[V];return k.call.apply(k,[this,x].concat(q))}}for(var h=["setPosition","setMargin","setFlexBasis","setWidth","setHeight","setMinWidth","setMinHeight","setMaxWidth","setMaxHeight","setPadding"],E=function(){var F,k=h[t],x=(F={},yD(F,tc.UNIT_POINT,l.Node.prototype[k]),yD(F,tc.UNIT_PERCENT,l.Node.prototype[k+"Percent"]),yD(F,tc.UNIT_AUTO,l.Node.prototype[k+"Auto"]),F);f(l.Node.prototype,k,function(j){for(var q=arguments.length,V=Array(q>1?q-1:0),re=1;re<q;re++)V[re-1]=arguments[re];var y=V.pop(),me=void 0,De=void 0;if(y==="auto")me=tc.UNIT_AUTO,De=void 0;else if(y instanceof JS)me=y.unit,De=y.valueOf();else if(me=typeof y=="string"&&y.endsWith("%")?tc.UNIT_PERCENT:tc.UNIT_POINT,De=parseFloat(y),!Number.isNaN(y)&&Number.isNaN(De))throw new Error("Invalid value "+y+" for "+k);if(!x[me])throw new Error('Failed to execute "'+k+`": Unsupported unit '`+y+"'");if(De!==void 0){var ge;return(ge=x[me]).call.apply(ge,[this].concat(V,[De]))}else{var ae;return(ae=x[me]).call.apply(ae,[this].concat(V))}})},t=0;t<h.length;t++)E();return f(l.Config.prototype,"free",function(){l.Config.destroy(this)}),f(l.Node,"create",function(N,F){return F?l.Node.createWithConfig(F):l.Node.createDefault()}),f(l.Node.prototype,"free",function(){l.Node.destroy(this)}),f(l.Node.prototype,"freeRecursive",function(){for(var N=0,F=this.getChildCount();N<F;++N)this.getChild(0).freeRecursive();this.free()}),f(l.Node.prototype,"setMeasureFunc",function(N,F){return F?N.call(this,function(){return QS.fromJS(F.apply(void 0,arguments))}):this.unsetMeasureFunc()}),f(l.Node.prototype,"calculateLayout",function(N){var F=arguments.length>1&&arguments[1]!==void 0?arguments[1]:NaN,k=arguments.length>2&&arguments[2]!==void 0?arguments[2]:NaN,x=arguments.length>3&&arguments[3]!==void 0?arguments[3]:tc.DIRECTION_LTR;return N.call(this,F,k,x)}),DP({Config:l.Config,Node:l.Node,Layout:o("Layout",wP),Size:o("Size",QS),Value:o("Value",JS),getInstanceCount:function(){return l.getInstanceCount.apply(l,arguments)}},tc)}});var eT=nt((exports,module)=>{(function(o,l){typeof define=="function"&&define.amd?define([],function(){return l}):typeof module=="object"&&module.exports?module.exports=l:(o.nbind=o.nbind||{}).init=l})(exports,function(Module,cb){typeof Module=="function"&&(cb=Module,Module={}),Module.onRuntimeInitialized=function(o,l){return function(){o&&o.apply(this,arguments);try{Module.ccall("nbind_init")}catch(f){l(f);return}l(null,{bind:Module._nbind_value,reflect:Module.NBind.reflect,queryType:Module.NBind.queryType,toggleLightGC:Module.toggleLightGC,lib:Module})}}(Module.onRuntimeInitialized,cb);var Module;Module||(Module=(typeof Module<"u"?Module:null)||{});var moduleOverrides={};for(var key in Module)Module.hasOwnProperty(key)&&(moduleOverrides[key]=Module[key]);var ENVIRONMENT_IS_WEB=!1,ENVIRONMENT_IS_WORKER=!1,ENVIRONMENT_IS_NODE=!1,ENVIRONMENT_IS_SHELL=!1;if(Module.ENVIRONMENT)if(Module.ENVIRONMENT==="WEB")ENVIRONMENT_IS_WEB=!0;else if(Module.ENVIRONMENT==="WORKER")ENVIRONMENT_IS_WORKER=!0;else if(Module.ENVIRONMENT==="NODE")ENVIRONMENT_IS_NODE=!0;else if(Module.ENVIRONMENT==="SHELL")ENVIRONMENT_IS_SHELL=!0;else throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.");else ENVIRONMENT_IS_WEB=typeof window=="object",ENVIRONMENT_IS_WORKER=typeof importScripts=="function",ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof hi=="function"&&!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_WORKER,ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;if(ENVIRONMENT_IS_NODE){Module.print||(Module.print=console.log),Module.printErr||(Module.printErr=console.warn);var nodeFS,nodePath;Module.read=function(l,f){nodeFS||(nodeFS={}("")),nodePath||(nodePath={}("")),l=nodePath.normalize(l);var h=nodeFS.readFileSync(l);return f?h:h.toString()},Module.readBinary=function(l){var f=Module.read(l,!0);return f.buffer||(f=new Uint8Array(f)),assert(f.buffer),f},Module.load=function(l){globalEval(read(l))},Module.thisProgram||(process.argv.length>1?Module.thisProgram=process.argv[1].replace(/\\/g,"/"):Module.thisProgram="unknown-program"),Module.arguments=process.argv.slice(2),typeof module<"u"&&(module.exports=Module),Module.inspect=function(){return"[Emscripten Module object]"}}else if(ENVIRONMENT_IS_SHELL)Module.print||(Module.print=print),typeof printErr<"u"&&(Module.printErr=printErr),typeof read<"u"?Module.read=read:Module.read=function(){throw"no read() available"},Module.readBinary=function(l){if(typeof readbuffer=="function")return new Uint8Array(readbuffer(l));var f=read(l,"binary");return assert(typeof f=="object"),f},typeof scriptArgs<"u"?Module.arguments=scriptArgs:typeof arguments<"u"&&(Module.arguments=arguments),typeof quit=="function"&&(Module.quit=function(o,l){quit(o)});else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(Module.read=function(l){var f=new XMLHttpRequest;return f.open("GET",l,!1),f.send(null),f.responseText},ENVIRONMENT_IS_WORKER&&(Module.readBinary=function(l){var f=new XMLHttpRequest;return f.open("GET",l,!1),f.responseType="arraybuffer",f.send(null),new Uint8Array(f.response)}),Module.readAsync=function(l,f,h){var E=new XMLHttpRequest;E.open("GET",l,!0),E.responseType="arraybuffer",E.onload=function(){E.status==200||E.status==0&&E.response?f(E.response):h()},E.onerror=h,E.send(null)},typeof arguments<"u"&&(Module.arguments=arguments),typeof console<"u")Module.print||(Module.print=function(l){console.log(l)}),Module.printErr||(Module.printErr=function(l){console.warn(l)});else{var TRY_USE_DUMP=!1;Module.print||(Module.print=TRY_USE_DUMP&&typeof dump<"u"?function(o){dump(o)}:function(o){})}ENVIRONMENT_IS_WORKER&&(Module.load=importScripts),typeof Module.setWindowTitle>"u"&&(Module.setWindowTitle=function(o){document.title=o})}else throw"Unknown runtime environment. Where are we?";function globalEval(o){eval.call(null,o)}!Module.load&&Module.read&&(Module.load=function(l){globalEval(Module.read(l))}),Module.print||(Module.print=function(){}),Module.printErr||(Module.printErr=Module.print),Module.arguments||(Module.arguments=[]),Module.thisProgram||(Module.thisProgram="./this.program"),Module.quit||(Module.quit=function(o,l){throw l}),Module.print=Module.print,Module.printErr=Module.printErr,Module.preRun=[],Module.postRun=[];for(var key in moduleOverrides)moduleOverrides.hasOwnProperty(key)&&(Module[key]=moduleOverrides[key]);moduleOverrides=void 0;var Runtime={setTempRet0:function(o){return tempRet0=o,o},getTempRet0:function(){return tempRet0},stackSave:function(){return STACKTOP},stackRestore:function(o){STACKTOP=o},getNativeTypeSize:function(o){switch(o){case"i1":case"i8":return 1;case"i16":return 2;case"i32":return 4;case"i64":return 8;case"float":return 4;case"double":return 8;default:{if(o[o.length-1]==="*")return Runtime.QUANTUM_SIZE;if(o[0]==="i"){var l=parseInt(o.substr(1));return assert(l%8===0),l/8}else return 0}}},getNativeFieldSize:function(o){return Math.max(Runtime.getNativeTypeSize(o),Runtime.QUANTUM_SIZE)},STACK_ALIGN:16,prepVararg:function(o,l){return l==="double"||l==="i64"?o&7&&(assert((o&7)===4),o+=4):assert((o&3)===0),o},getAlignSize:function(o,l,f){return!f&&(o=="i64"||o=="double")?8:o?Math.min(l||(o?Runtime.getNativeFieldSize(o):0),Runtime.QUANTUM_SIZE):Math.min(l,8)},dynCall:function(o,l,f){return f&&f.length?Module["dynCall_"+o].apply(null,[l].concat(f)):Module["dynCall_"+o].call(null,l)},functionPointers:[],addFunction:function(o){for(var l=0;l<Runtime.functionPointers.length;l++)if(!Runtime.functionPointers[l])return Runtime.functionPointers[l]=o,2*(1+l);throw"Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."},removeFunction:function(o){Runtime.functionPointers[(o-2)/2]=null},warnOnce:function(o){Runtime.warnOnce.shown||(Runtime.warnOnce.shown={}),Runtime.warnOnce.shown[o]||(Runtime.warnOnce.shown[o]=1,Module.printErr(o))},funcWrappers:{},getFuncWrapper:function(o,l){if(!!o){assert(l),Runtime.funcWrappers[l]||(Runtime.funcWrappers[l]={});var f=Runtime.funcWrappers[l];return f[o]||(l.length===1?f[o]=function(){return Runtime.dynCall(l,o)}:l.length===2?f[o]=function(E){return Runtime.dynCall(l,o,[E])}:f[o]=function(){return Runtime.dynCall(l,o,Array.prototype.slice.call(arguments))}),f[o]}},getCompilerSetting:function(o){throw"You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"},stackAlloc:function(o){var l=STACKTOP;return STACKTOP=STACKTOP+o|0,STACKTOP=STACKTOP+15&-16,l},staticAlloc:function(o){var l=STATICTOP;return STATICTOP=STATICTOP+o|0,STATICTOP=STATICTOP+15&-16,l},dynamicAlloc:function(o){var l=HEAP32[DYNAMICTOP_PTR>>2],f=(l+o+15|0)&-16;if(HEAP32[DYNAMICTOP_PTR>>2]=f,f>=TOTAL_MEMORY){var h=enlargeMemory();if(!h)return HEAP32[DYNAMICTOP_PTR>>2]=l,0}return l},alignMemory:function(o,l){var f=o=Math.ceil(o/(l||16))*(l||16);return f},makeBigInt:function(o,l,f){var h=f?+(o>>>0)+ +(l>>>0)*4294967296:+(o>>>0)+ +(l|0)*4294967296;return h},GLOBAL_BASE:8,QUANTUM_SIZE:4,__dummy__:0};Module.Runtime=Runtime;var ABORT=0,EXITSTATUS=0;function assert(o,l){o||abort("Assertion failed: "+l)}function getCFunc(ident){var func=Module["_"+ident];if(!func)try{func=eval("_"+ident)}catch(o){}return assert(func,"Cannot call unknown function "+ident+" (perhaps LLVM optimizations or closure removed it?)"),func}var cwrap,ccall;(function(){var JSfuncs={stackSave:function(){Runtime.stackSave()},stackRestore:function(){Runtime.stackRestore()},arrayToC:function(o){var l=Runtime.stackAlloc(o.length);return writeArrayToMemory(o,l),l},stringToC:function(o){var l=0;if(o!=null&&o!==0){var f=(o.length<<2)+1;l=Runtime.stackAlloc(f),stringToUTF8(o,l,f)}return l}},toC={string:JSfuncs.stringToC,array:JSfuncs.arrayToC};ccall=function(l,f,h,E,t){var N=getCFunc(l),F=[],k=0;if(E)for(var x=0;x<E.length;x++){var j=toC[h[x]];j?(k===0&&(k=Runtime.stackSave()),F[x]=j(E[x])):F[x]=E[x]}var q=N.apply(null,F);if(f==="string"&&(q=Pointer_stringify(q)),k!==0){if(t&&t.async){EmterpreterAsync.asyncFinalizers.push(function(){Runtime.stackRestore(k)});return}Runtime.stackRestore(k)}return q};var sourceRegex=/^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;function parseJSFunc(o){var l=o.toString().match(sourceRegex).slice(1);return{arguments:l[0],body:l[1],returnValue:l[2]}}var JSsource=null;function ensureJSsource(){if(!JSsource){JSsource={};for(var o in JSfuncs)JSfuncs.hasOwnProperty(o)&&(JSsource[o]=parseJSFunc(JSfuncs[o]))}}cwrap=function cwrap(ident,returnType,argTypes){argTypes=argTypes||[];var cfunc=getCFunc(ident),numericArgs=argTypes.every(function(o){return o==="number"}),numericRet=returnType!=="string";if(numericRet&&numericArgs)return cfunc;var argNames=argTypes.map(function(o,l){return"$"+l}),funcstr="(function("+argNames.join(",")+") {",nargs=argTypes.length;if(!numericArgs){ensureJSsource(),funcstr+="var stack = "+JSsource.stackSave.body+";";for(var i=0;i<nargs;i++){var arg=argNames[i],type=argTypes[i];if(type!=="number"){var convertCode=JSsource[type+"ToC"];funcstr+="var "+convertCode.arguments+" = "+arg+";",funcstr+=convertCode.body+";",funcstr+=arg+"=("+convertCode.returnValue+");"}}}var cfuncname=parseJSFunc(function(){return cfunc}).returnValue;if(funcstr+="var ret = "+cfuncname+"("+argNames.join(",")+");",!numericRet){var strgfy=parseJSFunc(function(){return Pointer_stringify}).returnValue;funcstr+="ret = "+strgfy+"(ret);"}return numericArgs||(ensureJSsource(),funcstr+=JSsource.stackRestore.body.replace("()","(stack)")+";"),funcstr+="return ret})",eval(funcstr)}})(),Module.ccall=ccall,Module.cwrap=cwrap;function setValue(o,l,f,h){switch(f=f||"i8",f.charAt(f.length-1)==="*"&&(f="i32"),f){case"i1":HEAP8[o>>0]=l;break;case"i8":HEAP8[o>>0]=l;break;case"i16":HEAP16[o>>1]=l;break;case"i32":HEAP32[o>>2]=l;break;case"i64":tempI64=[l>>>0,(tempDouble=l,+Math_abs(tempDouble)>=1?tempDouble>0?(Math_min(+Math_floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math_ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[o>>2]=tempI64[0],HEAP32[o+4>>2]=tempI64[1];break;case"float":HEAPF32[o>>2]=l;break;case"double":HEAPF64[o>>3]=l;break;default:abort("invalid type for setValue: "+f)}}Module.setValue=setValue;function getValue(o,l,f){switch(l=l||"i8",l.charAt(l.length-1)==="*"&&(l="i32"),l){case"i1":return HEAP8[o>>0];case"i8":return HEAP8[o>>0];case"i16":return HEAP16[o>>1];case"i32":return HEAP32[o>>2];case"i64":return HEAP32[o>>2];case"float":return HEAPF32[o>>2];case"double":return HEAPF64[o>>3];default:abort("invalid type for setValue: "+l)}return null}Module.getValue=getValue;var ALLOC_NORMAL=0,ALLOC_STACK=1,ALLOC_STATIC=2,ALLOC_DYNAMIC=3,ALLOC_NONE=4;Module.ALLOC_NORMAL=ALLOC_NORMAL,Module.ALLOC_STACK=ALLOC_STACK,Module.ALLOC_STATIC=ALLOC_STATIC,Module.ALLOC_DYNAMIC=ALLOC_DYNAMIC,Module.ALLOC_NONE=ALLOC_NONE;function allocate(o,l,f,h){var E,t;typeof o=="number"?(E=!0,t=o):(E=!1,t=o.length);var N=typeof l=="string"?l:null,F;if(f==ALLOC_NONE?F=h:F=[typeof _malloc=="function"?_malloc:Runtime.staticAlloc,Runtime.stackAlloc,Runtime.staticAlloc,Runtime.dynamicAlloc][f===void 0?ALLOC_STATIC:f](Math.max(t,N?1:l.length)),E){var h=F,k;for(assert((F&3)==0),k=F+(t&-4);h<k;h+=4)HEAP32[h>>2]=0;for(k=F+t;h<k;)HEAP8[h++>>0]=0;return F}if(N==="i8")return o.subarray||o.slice?HEAPU8.set(o,F):HEAPU8.set(new Uint8Array(o),F),F;for(var x=0,j,q,V;x<t;){var re=o[x];if(typeof re=="function"&&(re=Runtime.getFunctionIndex(re)),j=N||l[x],j===0){x++;continue}j=="i64"&&(j="i32"),setValue(F+x,re,j),V!==j&&(q=Runtime.getNativeTypeSize(j),V=j),x+=q}return F}Module.allocate=allocate;function getMemory(o){return staticSealed?runtimeInitialized?_malloc(o):Runtime.dynamicAlloc(o):Runtime.staticAlloc(o)}Module.getMemory=getMemory;function Pointer_stringify(o,l){if(l===0||!o)return"";for(var f=0,h,E=0;h=HEAPU8[o+E>>0],f|=h,!(h==0&&!l||(E++,l&&E==l)););l||(l=E);var t="";if(f<128){for(var N=1024,F;l>0;)F=String.fromCharCode.apply(String,HEAPU8.subarray(o,o+Math.min(l,N))),t=t?t+F:F,o+=N,l-=N;return t}return Module.UTF8ToString(o)}Module.Pointer_stringify=Pointer_stringify;function AsciiToString(o){for(var l="";;){var f=HEAP8[o++>>0];if(!f)return l;l+=String.fromCharCode(f)}}Module.AsciiToString=AsciiToString;function stringToAscii(o,l){return writeAsciiToMemory(o,l,!1)}Module.stringToAscii=stringToAscii;var UTF8Decoder=typeof TextDecoder<"u"?new TextDecoder("utf8"):void 0;function UTF8ArrayToString(o,l){for(var f=l;o[f];)++f;if(f-l>16&&o.subarray&&UTF8Decoder)return UTF8Decoder.decode(o.subarray(l,f));for(var h,E,t,N,F,k,x="";;){if(h=o[l++],!h)return x;if(!(h&128)){x+=String.fromCharCode(h);continue}if(E=o[l++]&63,(h&224)==192){x+=String.fromCharCode((h&31)<<6|E);continue}if(t=o[l++]&63,(h&240)==224?h=(h&15)<<12|E<<6|t:(N=o[l++]&63,(h&248)==240?h=(h&7)<<18|E<<12|t<<6|N:(F=o[l++]&63,(h&252)==248?h=(h&3)<<24|E<<18|t<<12|N<<6|F:(k=o[l++]&63,h=(h&1)<<30|E<<24|t<<18|N<<12|F<<6|k))),h<65536)x+=String.fromCharCode(h);else{var j=h-65536;x+=String.fromCharCode(55296|j>>10,56320|j&1023)}}}Module.UTF8ArrayToString=UTF8ArrayToString;function UTF8ToString(o){return UTF8ArrayToString(HEAPU8,o)}Module.UTF8ToString=UTF8ToString;function stringToUTF8Array(o,l,f,h){if(!(h>0))return 0;for(var E=f,t=f+h-1,N=0;N<o.length;++N){var F=o.charCodeAt(N);if(F>=55296&&F<=57343&&(F=65536+((F&1023)<<10)|o.charCodeAt(++N)&1023),F<=127){if(f>=t)break;l[f++]=F}else if(F<=2047){if(f+1>=t)break;l[f++]=192|F>>6,l[f++]=128|F&63}else if(F<=65535){if(f+2>=t)break;l[f++]=224|F>>12,l[f++]=128|F>>6&63,l[f++]=128|F&63}else if(F<=2097151){if(f+3>=t)break;l[f++]=240|F>>18,l[f++]=128|F>>12&63,l[f++]=128|F>>6&63,l[f++]=128|F&63}else if(F<=67108863){if(f+4>=t)break;l[f++]=248|F>>24,l[f++]=128|F>>18&63,l[f++]=128|F>>12&63,l[f++]=128|F>>6&63,l[f++]=128|F&63}else{if(f+5>=t)break;l[f++]=252|F>>30,l[f++]=128|F>>24&63,l[f++]=128|F>>18&63,l[f++]=128|F>>12&63,l[f++]=128|F>>6&63,l[f++]=128|F&63}}return l[f]=0,f-E}Module.stringToUTF8Array=stringToUTF8Array;function stringToUTF8(o,l,f){return stringToUTF8Array(o,HEAPU8,l,f)}Module.stringToUTF8=stringToUTF8;function lengthBytesUTF8(o){for(var l=0,f=0;f<o.length;++f){var h=o.charCodeAt(f);h>=55296&&h<=57343&&(h=65536+((h&1023)<<10)|o.charCodeAt(++f)&1023),h<=127?++l:h<=2047?l+=2:h<=65535?l+=3:h<=2097151?l+=4:h<=67108863?l+=5:l+=6}return l}Module.lengthBytesUTF8=lengthBytesUTF8;var UTF16Decoder=typeof TextDecoder<"u"?new TextDecoder("utf-16le"):void 0;function demangle(o){var l=Module.___cxa_demangle||Module.__cxa_demangle;if(l){try{var f=o.substr(1),h=lengthBytesUTF8(f)+1,E=_malloc(h);stringToUTF8(f,E,h);var t=_malloc(4),N=l(E,0,0,t);if(getValue(t,"i32")===0&&N)return Pointer_stringify(N)}catch{}finally{E&&_free(E),t&&_free(t),N&&_free(N)}return o}return Runtime.warnOnce("warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling"),o}function demangleAll(o){var l=/__Z[\w\d_]+/g;return o.replace(l,function(f){var h=demangle(f);return f===h?f:f+" ["+h+"]"})}function jsStackTrace(){var o=new Error;if(!o.stack){try{throw new Error(0)}catch(l){o=l}if(!o.stack)return"(no stack trace available)"}return o.stack.toString()}function stackTrace(){var o=jsStackTrace();return Module.extraStackTrace&&(o+=`
+`+Module.extraStackTrace()),demangleAll(o)}Module.stackTrace=stackTrace;var HEAP,buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferViews(){Module.HEAP8=HEAP8=new Int8Array(buffer),Module.HEAP16=HEAP16=new Int16Array(buffer),Module.HEAP32=HEAP32=new Int32Array(buffer),Module.HEAPU8=HEAPU8=new Uint8Array(buffer),Module.HEAPU16=HEAPU16=new Uint16Array(buffer),Module.HEAPU32=HEAPU32=new Uint32Array(buffer),Module.HEAPF32=HEAPF32=new Float32Array(buffer),Module.HEAPF64=HEAPF64=new Float64Array(buffer)}var STATIC_BASE,STATICTOP,staticSealed,STACK_BASE,STACKTOP,STACK_MAX,DYNAMIC_BASE,DYNAMICTOP_PTR;STATIC_BASE=STATICTOP=STACK_BASE=STACKTOP=STACK_MAX=DYNAMIC_BASE=DYNAMICTOP_PTR=0,staticSealed=!1;function abortOnCannotGrowMemory(){abort("Cannot enlarge memory arrays. Either (1) compile with  -s TOTAL_MEMORY=X  with X higher than the current value "+TOTAL_MEMORY+", (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or (4) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 ")}function enlargeMemory(){abortOnCannotGrowMemory()}var TOTAL_STACK=Module.TOTAL_STACK||5242880,TOTAL_MEMORY=Module.TOTAL_MEMORY||134217728;TOTAL_MEMORY<TOTAL_STACK&&Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was "+TOTAL_MEMORY+"! (TOTAL_STACK="+TOTAL_STACK+")"),Module.buffer?buffer=Module.buffer:buffer=new ArrayBuffer(TOTAL_MEMORY),updateGlobalBufferViews();function getTotalMemory(){return TOTAL_MEMORY}if(HEAP32[0]=1668509029,HEAP16[1]=25459,HEAPU8[2]!==115||HEAPU8[3]!==99)throw"Runtime error: expected the system to be little-endian!";Module.HEAP=HEAP,Module.buffer=buffer,Module.HEAP8=HEAP8,Module.HEAP16=HEAP16,Module.HEAP32=HEAP32,Module.HEAPU8=HEAPU8,Module.HEAPU16=HEAPU16,Module.HEAPU32=HEAPU32,Module.HEAPF32=HEAPF32,Module.HEAPF64=HEAPF64;function callRuntimeCallbacks(o){for(;o.length>0;){var l=o.shift();if(typeof l=="function"){l();continue}var f=l.func;typeof f=="number"?l.arg===void 0?Module.dynCall_v(f):Module.dynCall_vi(f,l.arg):f(l.arg===void 0?null:l.arg)}}var __ATPRERUN__=[],__ATINIT__=[],__ATMAIN__=[],__ATEXIT__=[],__ATPOSTRUN__=[],runtimeInitialized=!1,runtimeExited=!1;function preRun(){if(Module.preRun)for(typeof Module.preRun=="function"&&(Module.preRun=[Module.preRun]);Module.preRun.length;)addOnPreRun(Module.preRun.shift());callRuntimeCallbacks(__ATPRERUN__)}function ensureInitRuntime(){runtimeInitialized||(runtimeInitialized=!0,callRuntimeCallbacks(__ATINIT__))}function preMain(){callRuntimeCallbacks(__ATMAIN__)}function exitRuntime(){callRuntimeCallbacks(__ATEXIT__),runtimeExited=!0}function postRun(){if(Module.postRun)for(typeof Module.postRun=="function"&&(Module.postRun=[Module.postRun]);Module.postRun.length;)addOnPostRun(Module.postRun.shift());callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(o){__ATPRERUN__.unshift(o)}Module.addOnPreRun=addOnPreRun;function addOnInit(o){__ATINIT__.unshift(o)}Module.addOnInit=addOnInit;function addOnPreMain(o){__ATMAIN__.unshift(o)}Module.addOnPreMain=addOnPreMain;function addOnExit(o){__ATEXIT__.unshift(o)}Module.addOnExit=addOnExit;function addOnPostRun(o){__ATPOSTRUN__.unshift(o)}Module.addOnPostRun=addOnPostRun;function intArrayFromString(o,l,f){var h=f>0?f:lengthBytesUTF8(o)+1,E=new Array(h),t=stringToUTF8Array(o,E,0,E.length);return l&&(E.length=t),E}Module.intArrayFromString=intArrayFromString;function intArrayToString(o){for(var l=[],f=0;f<o.length;f++){var h=o[f];h>255&&(h&=255),l.push(String.fromCharCode(h))}return l.join("")}Module.intArrayToString=intArrayToString;function writeStringToMemory(o,l,f){Runtime.warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");var h,E;f&&(E=l+lengthBytesUTF8(o),h=HEAP8[E]),stringToUTF8(o,l,1/0),f&&(HEAP8[E]=h)}Module.writeStringToMemory=writeStringToMemory;function writeArrayToMemory(o,l){HEAP8.set(o,l)}Module.writeArrayToMemory=writeArrayToMemory;function writeAsciiToMemory(o,l,f){for(var h=0;h<o.length;++h)HEAP8[l++>>0]=o.charCodeAt(h);f||(HEAP8[l>>0]=0)}if(Module.writeAsciiToMemory=writeAsciiToMemory,(!Math.imul||Math.imul(4294967295,5)!==-5)&&(Math.imul=function o(l,f){var h=l>>>16,E=l&65535,t=f>>>16,N=f&65535;return E*N+(h*N+E*t<<16)|0}),Math.imul=Math.imul,!Math.fround){var froundBuffer=new Float32Array(1);Math.fround=function(o){return froundBuffer[0]=o,froundBuffer[0]}}Math.fround=Math.fround,Math.clz32||(Math.clz32=function(o){o=o>>>0;for(var l=0;l<32;l++)if(o&1<<31-l)return l;return 32}),Math.clz32=Math.clz32,Math.trunc||(Math.trunc=function(o){return o<0?Math.ceil(o):Math.floor(o)}),Math.trunc=Math.trunc;var Math_abs=Math.abs,Math_cos=Math.cos,Math_sin=Math.sin,Math_tan=Math.tan,Math_acos=Math.acos,Math_asin=Math.asin,Math_atan=Math.atan,Math_atan2=Math.atan2,Math_exp=Math.exp,Math_log=Math.log,Math_sqrt=Math.sqrt,Math_ceil=Math.ceil,Math_floor=Math.floor,Math_pow=Math.pow,Math_imul=Math.imul,Math_fround=Math.fround,Math_round=Math.round,Math_min=Math.min,Math_clz32=Math.clz32,Math_trunc=Math.trunc,runDependencies=0,runDependencyWatcher=null,dependenciesFulfilled=null;function getUniqueRunDependency(o){return o}function addRunDependency(o){runDependencies++,Module.monitorRunDependencies&&Module.monitorRunDependencies(runDependencies)}Module.addRunDependency=addRunDependency;function removeRunDependency(o){if(runDependencies--,Module.monitorRunDependencies&&Module.monitorRunDependencies(runDependencies),runDependencies==0&&(runDependencyWatcher!==null&&(clearInterval(runDependencyWatcher),runDependencyWatcher=null),dependenciesFulfilled)){var l=dependenciesFulfilled;dependenciesFulfilled=null,l()}}Module.removeRunDependency=removeRunDependency,Module.preloadedImages={},Module.preloadedAudios={};var ASM_CONSTS=[function(o,l,f,h,E,t,N,F){return _nbind.callbackSignatureList[o].apply(this,arguments)}];function _emscripten_asm_const_iiiiiiii(o,l,f,h,E,t,N,F){return ASM_CONSTS[o](l,f,h,E,t,N,F)}function _emscripten_asm_const_iiiii(o,l,f,h,E){return ASM_CONSTS[o](l,f,h,E)}function _emscripten_asm_const_iiidddddd(o,l,f,h,E,t,N,F,k){return ASM_CONSTS[o](l,f,h,E,t,N,F,k)}function _emscripten_asm_const_iiididi(o,l,f,h,E,t,N){return ASM_CONSTS[o](l,f,h,E,t,N)}function _emscripten_asm_const_iiii(o,l,f,h){return ASM_CONSTS[o](l,f,h)}function _emscripten_asm_const_iiiid(o,l,f,h,E){return ASM_CONSTS[o](l,f,h,E)}function _emscripten_asm_const_iiiiii(o,l,f,h,E,t){return ASM_CONSTS[o](l,f,h,E,t)}STATIC_BASE=Runtime.GLOBAL_BASE,STATICTOP=STATIC_BASE+12800,__ATINIT__.push({func:function(){__GLOBAL__sub_I_Yoga_cpp()}},{func:function(){__GLOBAL__sub_I_nbind_cc()}},{func:function(){__GLOBAL__sub_I_common_cc()}},{func:function(){__GLOBAL__sub_I_Binding_cc()}}),allocate([0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,127,0,0,192,127,0,0,192,127,0,0,192,127,3,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,3,0,0,0,0,0,192,127,3,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,192,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,127,0,0,192,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,127,0,0,0,0,0,0,0,0,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,127,0,0,192,127,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,128,191,0,0,128,191,0,0,192,127,0,0,0,0,0,0,0,0,0,0,128,63,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,190,12,0,0,200,12,0,0,208,12,0,0,216,12,0,0,230,12,0,0,242,12,0,0,1,0,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,192,127,3,0,0,0,180,45,0,0,181,45,0,0,182,45,0,0,181,45,0,0,182,45,0,0,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,3,0,0,0,1,0,0,0,4,0,0,0,183,45,0,0,181,45,0,0,181,45,0,0,181,45,0,0,181,45,0,0,181,45,0,0,181,45,0,0,184,45,0,0,185,45,0,0,181,45,0,0,181,45,0,0,182,45,0,0,186,45,0,0,185,45,0,0,148,4,0,0,3,0,0,0,187,45,0,0,164,4,0,0,188,45,0,0,2,0,0,0,189,45,0,0,164,4,0,0,188,45,0,0,185,45,0,0,164,4,0,0,185,45,0,0,164,4,0,0,188,45,0,0,181,45,0,0,182,45,0,0,181,45,0,0,0,0,0,0,0,0,0,0,1,0,0,0,5,0,0,0,6,0,0,0,1,0,0,0,7,0,0,0,183,45,0,0,182,45,0,0,181,45,0,0,190,45,0,0,190,45,0,0,182,45,0,0,182,45,0,0,185,45,0,0,181,45,0,0,185,45,0,0,182,45,0,0,181,45,0,0,185,45,0,0,182,45,0,0,185,45,0,0,48,5,0,0,3,0,0,0,56,5,0,0,1,0,0,0,189,45,0,0,185,45,0,0,164,4,0,0,76,5,0,0,2,0,0,0,191,45,0,0,186,45,0,0,182,45,0,0,185,45,0,0,192,45,0,0,185,45,0,0,182,45,0,0,186,45,0,0,185,45,0,0,76,5,0,0,76,5,0,0,136,5,0,0,182,45,0,0,181,45,0,0,2,0,0,0,190,45,0,0,136,5,0,0,56,19,0,0,156,5,0,0,2,0,0,0,184,45,0,0,0,0,0,0,0,0,0,0,1,0,0,0,8,0,0,0,9,0,0,0,1,0,0,0,10,0,0,0,204,5,0,0,181,45,0,0,181,45,0,0,2,0,0,0,180,45,0,0,204,5,0,0,2,0,0,0,195,45,0,0,236,5,0,0,97,19,0,0,198,45,0,0,211,45,0,0,212,45,0,0,213,45,0,0,214,45,0,0,215,45,0,0,188,45,0,0,182,45,0,0,216,45,0,0,217,45,0,0,218,45,0,0,219,45,0,0,192,45,0,0,181,45,0,0,0,0,0,0,185,45,0,0,110,19,0,0,186,45,0,0,115,19,0,0,221,45,0,0,120,19,0,0,148,4,0,0,132,19,0,0,96,6,0,0,145,19,0,0,222,45,0,0,164,19,0,0,223,45,0,0,173,19,0,0,0,0,0,0,3,0,0,0,104,6,0,0,1,0,0,0,187,45,0,0,0,0,0,0,0,0,0,0,1,0,0,0,11,0,0,0,12,0,0,0,1,0,0,0,13,0,0,0,185,45,0,0,224,45,0,0,164,6,0,0,188,45,0,0,172,6,0,0,180,6,0,0,2,0,0,0,188,6,0,0,7,0,0,0,224,45,0,0,7,0,0,0,164,6,0,0,1,0,0,0,213,45,0,0,185,45,0,0,224,45,0,0,172,6,0,0,185,45,0,0,224,45,0,0,164,6,0,0,185,45,0,0,224,45,0,0,211,45,0,0,211,45,0,0,222,45,0,0,211,45,0,0,224,45,0,0,222,45,0,0,211,45,0,0,224,45,0,0,172,6,0,0,222,45,0,0,211,45,0,0,224,45,0,0,188,45,0,0,222,45,0,0,211,45,0,0,40,7,0,0,188,45,0,0,2,0,0,0,224,45,0,0,185,45,0,0,188,45,0,0,188,45,0,0,188,45,0,0,188,45,0,0,222,45,0,0,224,45,0,0,148,4,0,0,185,45,0,0,148,4,0,0,148,4,0,0,148,4,0,0,148,4,0,0,148,4,0,0,185,45,0,0,164,6,0,0,148,4,0,0,0,0,0,0,0,0,0,0,1,0,0,0,14,0,0,0,15,0,0,0,1,0,0,0,16,0,0,0,148,7,0,0,2,0,0,0,225,45,0,0,183,45,0,0,188,45,0,0,168,7,0,0,5,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,234,45,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,148,45,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,9,0,0,5,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,2,0,0,0,242,45,0,0,0,4,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,67,111,117,108,100,32,110,111,116,32,97,108,108,111,99,97,116,101,32,109,101,109,111,114,121,32,102,111,114,32,110,111,100,101,0,67,97,110,110,111,116,32,114,101,115,101,116,32,97,32,110,111,100,101,32,119,104,105,99,104,32,115,116,105,108,108,32,104,97,115,32,99,104,105,108,100,114,101,110,32,97,116,116,97,99,104,101,100,0,67,97,110,110,111,116,32,114,101,115,101,116,32,97,32,110,111,100,101,32,115,116,105,108,108,32,97,116,116,97,99,104,101,100,32,116,111,32,97,32,112,97,114,101,110,116,0,67,111,117,108,100,32,110,111,116,32,97,108,108,111,99,97,116,101,32,109,101,109,111,114,121,32,102,111,114,32,99,111,110,102,105,103,0,67,97,110,110,111,116,32,115,101,116,32,109,101,97,115,117,114,101,32,102,117,110,99,116,105,111,110,58,32,78,111,100,101,115,32,119,105,116,104,32,109,101,97,115,117,114,101,32,102,117,110,99,116,105,111,110,115,32,99,97,110,110,111,116,32,104,97,118,101,32,99,104,105,108,100,114,101,110,46,0,67,104,105,108,100,32,97,108,114,101,97,100,121,32,104,97,115,32,97,32,112,97,114,101,110,116,44,32,105,116,32,109,117,115,116,32,98,101,32,114,101,109,111,118,101,100,32,102,105,114,115,116,46,0,67,97,110,110,111,116,32,97,100,100,32,99,104,105,108,100,58,32,78,111,100,101,115,32,119,105,116,104,32,109,101,97,115,117,114,101,32,102,117,110,99,116,105,111,110,115,32,99,97,110,110,111,116,32,104,97,118,101,32,99,104,105,108,100,114,101,110,46,0,79,110,108,121,32,108,101,97,102,32,110,111,100,101,115,32,119,105,116,104,32,99,117,115,116,111,109,32,109,101,97,115,117,114,101,32,102,117,110,99,116,105,111,110,115,115,104,111,117,108,100,32,109,97,110,117,97,108,108,121,32,109,97,114,107,32,116,104,101,109,115,101,108,118,101,115,32,97,115,32,100,105,114,116,121,0,67,97,110,110,111,116,32,103,101,116,32,108,97,121,111,117,116,32,112,114,111,112,101,114,116,105,101,115,32,111,102,32,109,117,108,116,105,45,101,100,103,101,32,115,104,111,114,116,104,97,110,100,115,0,37,115,37,100,46,123,91,115,107,105,112,112,101,100,93,32,0,119,109,58,32,37,115,44,32,104,109,58,32,37,115,44,32,97,119,58,32,37,102,32,97,104,58,32,37,102,32,61,62,32,100,58,32,40,37,102,44,32,37,102,41,32,37,115,10,0,37,115,37,100,46,123,37,115,0,42,0,119,109,58,32,37,115,44,32,104,109,58,32,37,115,44,32,97,119,58,32,37,102,32,97,104,58,32,37,102,32,37,115,10,0,37,115,37,100,46,125,37,115,0,119,109,58,32,37,115,44,32,104,109,58,32,37,115,44,32,100,58,32,40,37,102,44,32,37,102,41,32,37,115,10,0,79,117,116,32,111,102,32,99,97,99,104,101,32,101,110,116,114,105,101,115,33,10,0,83,99,97,108,101,32,102,97,99,116,111,114,32,115,104,111,117,108,100,32,110,111,116,32,98,101,32,108,101,115,115,32,116,104,97,110,32,122,101,114,111,0,105,110,105,116,105,97,108,0,37,115,10,0,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,0,85,78,68,69,70,73,78,69,68,0,69,88,65,67,84,76,89,0,65,84,95,77,79,83,84,0,76,65,89,95,85,78,68,69,70,73,78,69,68,0,76,65,89,95,69,88,65,67,84,76,89,0,76,65,89,95,65,84,95,77,79,83,84,0,97,118,97,105,108,97,98,108,101,87,105,100,116,104,32,105,115,32,105,110,100,101,102,105,110,105,116,101,32,115,111,32,119,105,100,116,104,77,101,97,115,117,114,101,77,111,100,101,32,109,117,115,116,32,98,101,32,89,71,77,101,97,115,117,114,101,77,111,100,101,85,110,100,101,102,105,110,101,100,0,97,118,97,105,108,97,98,108,101,72,101,105,103,104,116,32,105,115,32,105,110,100,101,102,105,110,105,116,101,32,115,111,32,104,101,105,103,104,116,77,101,97,115,117,114,101,77,111,100,101,32,109,117,115,116,32,98,101,32,89,71,77,101,97,115,117,114,101,77,111,100,101,85,110,100,101,102,105,110,101,100,0,102,108,101,120,0,115,116,114,101,116,99,104,0,109,117,108,116,105,108,105,110,101,45,115,116,114,101,116,99,104,0,69,120,112,101,99,116,101,100,32,110,111,100,101,32,116,111,32,104,97,118,101,32,99,117,115,116,111,109,32,109,101,97,115,117,114,101,32,102,117,110,99,116,105,111,110,0,109,101,97,115,117,114,101,0,69,120,112,101,99,116,32,99,117,115,116,111,109,32,98,97,115,101,108,105,110,101,32,102,117,110,99,116,105,111,110,32,116,111,32,110,111,116,32,114,101,116,117,114,110,32,78,97,78,0,97,98,115,45,109,101,97,115,117,114,101,0,97,98,115,45,108,97,121,111,117,116,0,78,111,100,101,0,99,114,101,97,116,101,68,101,102,97,117,108,116,0,99,114,101,97,116,101,87,105,116,104,67,111,110,102,105,103,0,100,101,115,116,114,111,121,0,114,101,115,101,116,0,99,111,112,121,83,116,121,108,101,0,115,101,116,80,111,115,105,116,105,111,110,84,121,112,101,0,115,101,116,80,111,115,105,116,105,111,110,0,115,101,116,80,111,115,105,116,105,111,110,80,101,114,99,101,110,116,0,115,101,116,65,108,105,103,110,67,111,110,116,101,110,116,0,115,101,116,65,108,105,103,110,73,116,101,109,115,0,115,101,116,65,108,105,103,110,83,101,108,102,0,115,101,116,70,108,101,120,68,105,114,101,99,116,105,111,110,0,115,101,116,70,108,101,120,87,114,97,112,0,115,101,116,74,117,115,116,105,102,121,67,111,110,116,101,110,116,0,115,101,116,77,97,114,103,105,110,0,115,101,116,77,97,114,103,105,110,80,101,114,99,101,110,116,0,115,101,116,77,97,114,103,105,110,65,117,116,111,0,115,101,116,79,118,101,114,102,108,111,119,0,115,101,116,68,105,115,112,108,97,121,0,115,101,116,70,108,101,120,0,115,101,116,70,108,101,120,66,97,115,105,115,0,115,101,116,70,108,101,120,66,97,115,105,115,80,101,114,99,101,110,116,0,115,101,116,70,108,101,120,71,114,111,119,0,115,101,116,70,108,101,120,83,104,114,105,110,107,0,115,101,116,87,105,100,116,104,0,115,101,116,87,105,100,116,104,80,101,114,99,101,110,116,0,115,101,116,87,105,100,116,104,65,117,116,111,0,115,101,116,72,101,105,103,104,116,0,115,101,116,72,101,105,103,104,116,80,101,114,99,101,110,116,0,115,101,116,72,101,105,103,104,116,65,117,116,111,0,115,101,116,77,105,110,87,105,100,116,104,0,115,101,116,77,105,110,87,105,100,116,104,80,101,114,99,101,110,116,0,115,101,116,77,105,110,72,101,105,103,104,116,0,115,101,116,77,105,110,72,101,105,103,104,116,80,101,114,99,101,110,116,0,115,101,116,77,97,120,87,105,100,116,104,0,115,101,116,77,97,120,87,105,100,116,104,80,101,114,99,101,110,116,0,115,101,116,77,97,120,72,101,105,103,104,116,0,115,101,116,77,97,120,72,101,105,103,104,116,80,101,114,99,101,110,116,0,115,101,116,65,115,112,101,99,116,82,97,116,105,111,0,115,101,116,66,111,114,100,101,114,0,115,101,116,80,97,100,100,105,110,103,0,115,101,116,80,97,100,100,105,110,103,80,101,114,99,101,110,116,0,103,101,116,80,111,115,105,116,105,111,110,84,121,112,101,0,103,101,116,80,111,115,105,116,105,111,110,0,103,101,116,65,108,105,103,110,67,111,110,116,101,110,116,0,103,101,116,65,108,105,103,110,73,116,101,109,115,0,103,101,116,65,108,105,103,110,83,101,108,102,0,103,101,116,70,108,101,120,68,105,114,101,99,116,105,111,110,0,103,101,116,70,108,101,120,87,114,97,112,0,103,101,116,74,117,115,116,105,102,121,67,111,110,116,101,110,116,0,103,101,116,77,97,114,103,105,110,0,103,101,116,70,108,101,120,66,97,115,105,115,0,103,101,116,70,108,101,120,71,114,111,119,0,103,101,116,70,108,101,120,83,104,114,105,110,107,0,103,101,116,87,105,100,116,104,0,103,101,116,72,101,105,103,104,116,0,103,101,116,77,105,110,87,105,100,116,104,0,103,101,116,77,105,110,72,101,105,103,104,116,0,103,101,116,77,97,120,87,105,100,116,104,0,103,101,116,77,97,120,72,101,105,103,104,116,0,103,101,116,65,115,112,101,99,116,82,97,116,105,111,0,103,101,116,66,111,114,100,101,114,0,103,101,116,79,118,101,114,102,108,111,119,0,103,101,116,68,105,115,112,108,97,121,0,103,101,116,80,97,100,100,105,110,103,0,105,110,115,101,114,116,67,104,105,108,100,0,114,101,109,111,118,101,67,104,105,108,100,0,103,101,116,67,104,105,108,100,67,111,117,110,116,0,103,101,116,80,97,114,101,110,116,0,103,101,116,67,104,105,108,100,0,115,101,116,77,101,97,115,117,114,101,70,117,110,99,0,117,110,115,101,116,77,101,97,115,117,114,101,70,117,110,99,0,109,97,114,107,68,105,114,116,121,0,105,115,68,105,114,116,121,0,99,97,108,99,117,108,97,116,101,76,97,121,111,117,116,0,103,101,116,67,111,109,112,117,116,101,100,76,101,102,116,0,103,101,116,67,111,109,112,117,116,101,100,82,105,103,104,116,0,103,101,116,67,111,109,112,117,116,101,100,84,111,112,0,103,101,116,67,111,109,112,117,116,101,100,66,111,116,116,111,109,0,103,101,116,67,111,109,112,117,116,101,100,87,105,100,116,104,0,103,101,116,67,111,109,112,117,116,101,100,72,101,105,103,104,116,0,103,101,116,67,111,109,112,117,116,101,100,76,97,121,111,117,116,0,103,101,116,67,111,109,112,117,116,101,100,77,97,114,103,105,110,0,103,101,116,67,111,109,112,117,116,101,100,66,111,114,100,101,114,0,103,101,116,67,111,109,112,117,116,101,100,80,97,100,100,105,110,103,0,67,111,110,102,105,103,0,99,114,101,97,116,101,0,115,101,116,69,120,112,101,114,105,109,101,110,116,97,108,70,101,97,116,117,114,101,69,110,97,98,108,101,100,0,115,101,116,80,111,105,110,116,83,99,97,108,101,70,97,99,116,111,114,0,105,115,69,120,112,101,114,105,109,101,110,116,97,108,70,101,97,116,117,114,101,69,110,97,98,108,101,100,0,86,97,108,117,101,0,76,97,121,111,117,116,0,83,105,122,101,0,103,101,116,73,110,115,116,97,110,99,101,67,111,117,110,116,0,73,110,116,54,52,0,1,1,1,2,2,4,4,4,4,8,8,4,8,118,111,105,100,0,98,111,111,108,0,115,116,100,58,58,115,116,114,105,110,103,0,99,98,70,117,110,99,116,105,111,110,32,38,0,99,111,110,115,116,32,99,98,70,117,110,99,116,105,111,110,32,38,0,69,120,116,101,114,110,97,108,0,66,117,102,102,101,114,0,78,66,105,110,100,73,68,0,78,66,105,110,100,0,98,105,110,100,95,118,97,108,117,101,0,114,101,102,108,101,99,116,0,113,117,101,114,121,84,121,112,101,0,108,97,108,108,111,99,0,108,114,101,115,101,116,0,123,114,101,116,117,114,110,40,95,110,98,105,110,100,46,99,97,108,108,98,97,99,107,83,105,103,110,97,116,117,114,101,76,105,115,116,91,36,48,93,46,97,112,112,108,121,40,116,104,105,115,44,97,114,103,117,109,101,110,116,115,41,41,59,125,0,95,110,98,105,110,100,95,110,101,119,0,17,0,10,0,17,17,17,0,0,0,0,5,0,0,0,0,0,0,9,0,0,0,0,11,0,0,0,0,0,0,0,0,17,0,15,10,17,17,17,3,10,7,0,1,19,9,11,11,0,0,9,6,11,0,0,11,0,6,17,0,0,0,17,17,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,17,0,10,10,17,17,17,0,10,0,0,2,0,9,11,0,0,0,9,0,11,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,12,0,0,0,0,9,12,0,0,0,0,0,12,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,13,0,0,0,4,13,0,0,0,0,9,14,0,0,0,0,0,14,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,15,0,0,0,0,9,16,0,0,0,0,0,16,0,0,16,0,0,18,0,0,0,18,18,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,0,0,0,18,18,18,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,10,0,0,0,0,9,11,0,0,0,0,0,11,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,12,0,0,0,0,9,12,0,0,0,0,0,12,0,0,12,0,0,45,43,32,32,32,48,88,48,120,0,40,110,117,108,108,41,0,45,48,88,43,48,88,32,48,88,45,48,120,43,48,120,32,48,120,0,105,110,102,0,73,78,70,0,110,97,110,0,78,65,78,0,48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70,46,0,84,33,34,25,13,1,2,3,17,75,28,12,16,4,11,29,18,30,39,104,110,111,112,113,98,32,5,6,15,19,20,21,26,8,22,7,40,36,23,24,9,10,14,27,31,37,35,131,130,125,38,42,43,60,61,62,63,67,71,74,77,88,89,90,91,92,93,94,95,96,97,99,100,101,102,103,105,106,107,108,114,115,116,121,122,123,124,0,73,108,108,101,103,97,108,32,98,121,116,101,32,115,101,113,117,101,110,99,101,0,68,111,109,97,105,110,32,101,114,114,111,114,0,82,101,115,117,108,116,32,110,111,116,32,114,101,112,114,101,115,101,110,116,97,98,108,101,0,78,111,116,32,97,32,116,116,121,0,80,101,114,109,105,115,115,105,111,110,32,100,101,110,105,101,100,0,79,112,101,114,97,116,105,111,110,32,110,111,116,32,112,101,114,109,105,116,116,101,100,0,78,111,32,115,117,99,104,32,102,105,108,101,32,111,114,32,100,105,114,101,99,116,111,114,121,0,78,111,32,115,117,99,104,32,112,114,111,99,101,115,115,0,70,105,108,101,32,101,120,105,115,116,115,0,86,97,108,117,101,32,116,111,111,32,108,97,114,103,101,32,102,111,114,32,100,97,116,97,32,116,121,112,101,0,78,111,32,115,112,97,99,101,32,108,101,102,116,32,111,110,32,100,101,118,105,99,101,0,79,117,116,32,111,102,32,109,101,109,111,114,121,0,82,101,115,111,117,114,99,101,32,98,117,115,121,0,73,110,116,101,114,114,117,112,116,101,100,32,115,121,115,116,101,109,32,99,97,108,108,0,82,101,115,111,117,114,99,101,32,116,101,109,112,111,114,97,114,105,108,121,32,117,110,97,118,97,105,108,97,98,108,101,0,73,110,118,97,108,105,100,32,115,101,101,107,0,67,114,111,115,115,45,100,101,118,105,99,101,32,108,105,110,107,0,82,101,97,100,45,111,110,108,121,32,102,105,108,101,32,115,121,115,116,101,109,0,68,105,114,101,99,116,111,114,121,32,110,111,116,32,101,109,112,116,121,0,67,111,110,110,101,99,116,105,111,110,32,114,101,115,101,116,32,98,121,32,112,101,101,114,0,79,112,101,114,97,116,105,111,110,32,116,105,109,101,100,32,111,117,116,0,67,111,110,110,101,99,116,105,111,110,32,114,101,102,117,115,101,100,0,72,111,115,116,32,105,115,32,100,111,119,110,0,72,111,115,116,32,105,115,32,117,110,114,101,97,99,104,97,98,108,101,0,65,100,100,114,101,115,115,32,105,110,32,117,115,101,0,66,114,111,107,101,110,32,112,105,112,101,0,73,47,79,32,101,114,114,111,114,0,78,111,32,115,117,99,104,32,100,101,118,105,99,101,32,111,114,32,97,100,100,114,101,115,115,0,66,108,111,99,107,32,100,101,118,105,99,101,32,114,101,113,117,105,114,101,100,0,78,111,32,115,117,99,104,32,100,101,118,105,99,101,0,78,111,116,32,97,32,100,105,114,101,99,116,111,114,121,0,73,115,32,97,32,100,105,114,101,99,116,111,114,121,0,84,101,120,116,32,102,105,108,101,32,98,117,115,121,0,69,120,101,99,32,102,111,114,109,97,116,32,101,114,114,111,114,0,73,110,118,97,108,105,100,32,97,114,103,117,109,101,110,116,0,65,114,103,117,109,101,110,116,32,108,105,115,116,32,116,111,111,32,108,111,110,103,0,83,121,109,98,111,108,105,99,32,108,105,110,107,32,108,111,111,112,0,70,105,108,101,110,97,109,101,32,116,111,111,32,108,111,110,103,0,84,111,111,32,109,97,110,121,32,111,112,101,110,32,102,105,108,101,115,32,105,110,32,115,121,115,116,101,109,0,78,111,32,102,105,108,101,32,100,101,115,99,114,105,112,116,111,114,115,32,97,118,97,105,108,97,98,108,101,0,66,97,100,32,102,105,108,101,32,100,101,115,99,114,105,112,116,111,114,0,78,111,32,99,104,105,108,100,32,112,114,111,99,101,115,115,0,66,97,100,32,97,100,100,114,101,115,115,0,70,105,108,101,32,116,111,111,32,108,97,114,103,101,0,84,111,111,32,109,97,110,121,32,108,105,110,107,115,0,78,111,32,108,111,99,107,115,32,97,118,97,105,108,97,98,108,101,0,82,101,115,111,117,114,99,101,32,100,101,97,100,108,111,99,107,32,119,111,117,108,100,32,111,99,99,117,114,0,83,116,97,116,101,32,110,111,116,32,114,101,99,111,118,101,114,97,98,108,101,0,80,114,101,118,105,111,117,115,32,111,119,110,101,114,32,100,105,101,100,0,79,112,101,114,97,116,105,111,110,32,99,97,110,99,101,108,101,100,0,70,117,110,99,116,105,111,110,32,110,111,116,32,105,109,112,108,101,109,101,110,116,101,100,0,78,111,32,109,101,115,115,97,103,101,32,111,102,32,100,101,115,105,114,101,100,32,116,121,112,101,0,73,100,101,110,116,105,102,105,101,114,32,114,101,109,111,118,101,100,0,68,101,118,105,99,101,32,110,111,116,32,97,32,115,116,114,101,97,109,0,78,111,32,100,97,116,97,32,97,118,97,105,108,97,98,108,101,0,68,101,118,105,99,101,32,116,105,109,101,111,117,116,0,79,117,116,32,111,102,32,115,116,114,101,97,109,115,32,114,101,115,111,117,114,99,101,115,0,76,105,110,107,32,104,97,115,32,98,101,101,110,32,115,101,118,101,114,101,100,0,80,114,111,116,111,99,111,108,32,101,114,114,111,114,0,66,97,100,32,109,101,115,115,97,103,101,0,70,105,108,101,32,100,101,115,99,114,105,112,116,111,114,32,105,110,32,98,97,100,32,115,116,97,116,101,0,78,111,116,32,97,32,115,111,99,107,101,116,0,68,101,115,116,105,110,97,116,105,111,110,32,97,100,100,114,101,115,115,32,114,101,113,117,105,114,101,100,0,77,101,115,115,97,103,101,32,116,111,111,32,108,97,114,103,101,0,80,114,111,116,111,99,111,108,32,119,114,111,110,103,32,116,121,112,101,32,102,111,114,32,115,111,99,107,101,116,0,80,114,111,116,111,99,111,108,32,110,111,116,32,97,118,97,105,108,97,98,108,101,0,80,114,111,116,111,99,111,108,32,110,111,116,32,115,117,112,112,111,114,116,101,100,0,83,111,99,107,101,116,32,116,121,112,101,32,110,111,116,32,115,117,112,112,111,114,116,101,100,0,78,111,116,32,115,117,112,112,111,114,116,101,100,0,80,114,111,116,111,99,111,108,32,102,97,109,105,108,121,32,110,111,116,32,115,117,112,112,111,114,116,101,100,0,65,100,100,114,101,115,115,32,102,97,109,105,108,121,32,110,111,116,32,115,117,112,112,111,114,116,101,100,32,98,121,32,112,114,111,116,111,99,111,108,0,65,100,100,114,101,115,115,32,110,111,116,32,97,118,97,105,108,97,98,108,101,0,78,101,116,119,111,114,107,32,105,115,32,100,111,119,110,0,78,101,116,119,111,114,107,32,117,110,114,101,97,99,104,97,98,108,101,0,67,111,110,110,101,99,116,105,111,110,32,114,101,115,101,116,32,98,121,32,110,101,116,119,111,114,107,0,67,111,110,110,101,99,116,105,111,110,32,97,98,111,114,116,101,100,0,78,111,32,98,117,102,102,101,114,32,115,112,97,99,101,32,97,118,97,105,108,97,98,108,101,0,83,111,99,107,101,116,32,105,115,32,99,111,110,110,101,99,116,101,100,0,83,111,99,107,101,116,32,110,111,116,32,99,111,110,110,101,99,116,101,100,0,67,97,110,110,111,116,32,115,101,110,100,32,97,102,116,101,114,32,115,111,99,107,101,116,32,115,104,117,116,100,111,119,110,0,79,112,101,114,97,116,105,111,110,32,97,108,114,101,97,100,121,32,105,110,32,112,114,111,103,114,101,115,115,0,79,112,101,114,97,116,105,111,110,32,105,110,32,112,114,111,103,114,101,115,115,0,83,116,97,108,101,32,102,105,108,101,32,104,97,110,100,108,101,0,82,101,109,111,116,101,32,73,47,79,32,101,114,114,111,114,0,81,117,111,116,97,32,101,120,99,101,101,100,101,100,0,78,111,32,109,101,100,105,117,109,32,102,111,117,110,100,0,87,114,111,110,103,32,109,101,100,105,117,109,32,116,121,112,101,0,78,111,32,101,114,114,111,114,32,105,110,102,111,114,109,97,116,105,111,110,0,0],"i8",ALLOC_NONE,Runtime.GLOBAL_BASE);var tempDoublePtr=STATICTOP;STATICTOP+=16;function _atexit(o,l){__ATEXIT__.unshift({func:o,arg:l})}function ___cxa_atexit(){return _atexit.apply(null,arguments)}function _abort(){Module.abort()}function __ZN8facebook4yoga14YGNodeToStringEPNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP6YGNode14YGPrintOptionsj(){Module.printErr("missing function: _ZN8facebook4yoga14YGNodeToStringEPNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP6YGNode14YGPrintOptionsj"),abort(-1)}function __decorate(o,l,f,h){var E=arguments.length,t=E<3?l:h===null?h=Object.getOwnPropertyDescriptor(l,f):h,N;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")t=Reflect.decorate(o,l,f,h);else for(var F=o.length-1;F>=0;F--)(N=o[F])&&(t=(E<3?N(t):E>3?N(l,f,t):N(l,f))||t);return E>3&&t&&Object.defineProperty(l,f,t),t}function _defineHidden(o){return function(l,f){Object.defineProperty(l,f,{configurable:!1,enumerable:!1,value:o,writable:!0})}}var _nbind={};function __nbind_free_external(o){_nbind.externalList[o].dereference(o)}function __nbind_reference_external(o){_nbind.externalList[o].reference()}function _llvm_stackrestore(o){var l=_llvm_stacksave,f=l.LLVM_SAVEDSTACKS[o];l.LLVM_SAVEDSTACKS.splice(o,1),Runtime.stackRestore(f)}function __nbind_register_pool(o,l,f,h){_nbind.Pool.pageSize=o,_nbind.Pool.usedPtr=l/4,_nbind.Pool.rootPtr=f,_nbind.Pool.pagePtr=h/4,HEAP32[l/4]=16909060,HEAP8[l]==1&&(_nbind.bigEndian=!0),HEAP32[l/4]=0,_nbind.makeTypeKindTbl=(t={},t[1024]=_nbind.PrimitiveType,t[64]=_nbind.Int64Type,t[2048]=_nbind.BindClass,t[3072]=_nbind.BindClassPtr,t[4096]=_nbind.SharedClassPtr,t[5120]=_nbind.ArrayType,t[6144]=_nbind.ArrayType,t[7168]=_nbind.CStringType,t[9216]=_nbind.CallbackType,t[10240]=_nbind.BindType,t),_nbind.makeTypeNameTbl={Buffer:_nbind.BufferType,External:_nbind.ExternalType,Int64:_nbind.Int64Type,_nbind_new:_nbind.CreateValueType,bool:_nbind.BooleanType,"cbFunction &":_nbind.CallbackType,"const cbFunction &":_nbind.CallbackType,"const std::string &":_nbind.StringType,"std::string":_nbind.StringType},Module.toggleLightGC=_nbind.toggleLightGC,_nbind.callUpcast=Module.dynCall_ii;var E=_nbind.makeType(_nbind.constructType,{flags:2048,id:0,name:""});E.proto=Module,_nbind.BindClass.list.push(E);var t}function _emscripten_set_main_loop_timing(o,l){if(Browser.mainLoop.timingMode=o,Browser.mainLoop.timingValue=l,!Browser.mainLoop.func)return 1;if(o==0)Browser.mainLoop.scheduler=function(){var N=Math.max(0,Browser.mainLoop.tickStartTime+l-_emscripten_get_now())|0;setTimeout(Browser.mainLoop.runner,N)},Browser.mainLoop.method="timeout";else if(o==1)Browser.mainLoop.scheduler=function(){Browser.requestAnimationFrame(Browser.mainLoop.runner)},Browser.mainLoop.method="rAF";else if(o==2){if(!window.setImmediate){let t=function(N){N.source===window&&N.data===h&&(N.stopPropagation(),f.shift()())};var E=t,f=[],h="setimmediate";window.addEventListener("message",t,!0),window.setImmediate=function(F){f.push(F),ENVIRONMENT_IS_WORKER?(Module.setImmediates===void 0&&(Module.setImmediates=[]),Module.setImmediates.push(F),window.postMessage({target:h})):window.postMessage(h,"*")}}Browser.mainLoop.scheduler=function(){window.setImmediate(Browser.mainLoop.runner)},Browser.mainLoop.method="immediate"}return 0}function _emscripten_get_now(){abort()}function _emscripten_set_main_loop(o,l,f,h,E){Module.noExitRuntime=!0,assert(!Browser.mainLoop.func,"emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters."),Browser.mainLoop.func=o,Browser.mainLoop.arg=h;var t;typeof h<"u"?t=function(){Module.dynCall_vi(o,h)}:t=function(){Module.dynCall_v(o)};var N=Browser.mainLoop.currentlyRunningMainloop;if(Browser.mainLoop.runner=function(){if(!ABORT){if(Browser.mainLoop.queue.length>0){var k=Date.now(),x=Browser.mainLoop.queue.shift();if(x.func(x.arg),Browser.mainLoop.remainingBlockers){var j=Browser.mainLoop.remainingBlockers,q=j%1==0?j-1:Math.floor(j);x.counted?Browser.mainLoop.remainingBlockers=q:(q=q+.5,Browser.mainLoop.remainingBlockers=(8*j+q)/9)}if(console.log('main loop blocker "'+x.name+'" took '+(Date.now()-k)+" ms"),Browser.mainLoop.updateStatus(),N<Browser.mainLoop.currentlyRunningMainloop)return;setTimeout(Browser.mainLoop.runner,0);return}if(!(N<Browser.mainLoop.currentlyRunningMainloop)){if(Browser.mainLoop.currentFrameNumber=Browser.mainLoop.currentFrameNumber+1|0,Browser.mainLoop.timingMode==1&&Browser.mainLoop.timingValue>1&&Browser.mainLoop.currentFrameNumber%Browser.mainLoop.timingValue!=0){Browser.mainLoop.scheduler();return}else Browser.mainLoop.timingMode==0&&(Browser.mainLoop.tickStartTime=_emscripten_get_now());Browser.mainLoop.method==="timeout"&&Module.ctx&&(Module.printErr("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!"),Browser.mainLoop.method=""),Browser.mainLoop.runIter(t),!(N<Browser.mainLoop.currentlyRunningMainloop)&&(typeof SDL=="object"&&SDL.audio&&SDL.audio.queueNewAudioData&&SDL.audio.queueNewAudioData(),Browser.mainLoop.scheduler())}}},E||(l&&l>0?_emscripten_set_main_loop_timing(0,1e3/l):_emscripten_set_main_loop_timing(1,1),Browser.mainLoop.scheduler()),f)throw"SimulateInfiniteLoop"}var Browser={mainLoop:{scheduler:null,method:"",currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],pause:function(){Browser.mainLoop.scheduler=null,Browser.mainLoop.currentlyRunningMainloop++},resume:function(){Browser.mainLoop.currentlyRunningMainloop++;var o=Browser.mainLoop.timingMode,l=Browser.mainLoop.timingValue,f=Browser.mainLoop.func;Browser.mainLoop.func=null,_emscripten_set_main_loop(f,0,!1,Browser.mainLoop.arg,!0),_emscripten_set_main_loop_timing(o,l),Browser.mainLoop.scheduler()},updateStatus:function(){if(Module.setStatus){var o=Module.statusMessage||"Please wait...",l=Browser.mainLoop.remainingBlockers,f=Browser.mainLoop.expectedBlockers;l?l<f?Module.setStatus(o+" ("+(f-l)+"/"+f+")"):Module.setStatus(o):Module.setStatus("")}},runIter:function(o){if(!ABORT){if(Module.preMainLoop){var l=Module.preMainLoop();if(l===!1)return}try{o()}catch(f){if(f instanceof ExitStatus)return;throw f&&typeof f=="object"&&f.stack&&Module.printErr("exception thrown: "+[f,f.stack]),f}Module.postMainLoop&&Module.postMainLoop()}}},isFullscreen:!1,pointerLock:!1,moduleContextCreatedCallbacks:[],workers:[],init:function(){if(Module.preloadPlugins||(Module.preloadPlugins=[]),Browser.initted)return;Browser.initted=!0;try{new Blob,Browser.hasBlobConstructor=!0}catch{Browser.hasBlobConstructor=!1,console.log("warning: no blob constructor, cannot create blobs with mimetypes")}Browser.BlobBuilder=typeof MozBlobBuilder<"u"?MozBlobBuilder:typeof WebKitBlobBuilder<"u"?WebKitBlobBuilder:Browser.hasBlobConstructor?null:console.log("warning: no BlobBuilder"),Browser.URLObject=typeof window<"u"?window.URL?window.URL:window.webkitURL:void 0,!Module.noImageDecoding&&typeof Browser.URLObject>"u"&&(console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."),Module.noImageDecoding=!0);var o={};o.canHandle=function(t){return!Module.noImageDecoding&&/\.(jpg|jpeg|png|bmp)$/i.test(t)},o.handle=function(t,N,F,k){var x=null;if(Browser.hasBlobConstructor)try{x=new Blob([t],{type:Browser.getMimetype(N)}),x.size!==t.length&&(x=new Blob([new Uint8Array(t).buffer],{type:Browser.getMimetype(N)}))}catch(re){Runtime.warnOnce("Blob constructor present but fails: "+re+"; falling back to blob builder")}if(!x){var j=new Browser.BlobBuilder;j.append(new Uint8Array(t).buffer),x=j.getBlob()}var q=Browser.URLObject.createObjectURL(x),V=new Image;V.onload=function(){assert(V.complete,"Image "+N+" could not be decoded");var y=document.createElement("canvas");y.width=V.width,y.height=V.height;var me=y.getContext("2d");me.drawImage(V,0,0),Module.preloadedImages[N]=y,Browser.URLObject.revokeObjectURL(q),F&&F(t)},V.onerror=function(y){console.log("Image "+q+" could not be decoded"),k&&k()},V.src=q},Module.preloadPlugins.push(o);var l={};l.canHandle=function(t){return!Module.noAudioDecoding&&t.substr(-4)in{".ogg":1,".wav":1,".mp3":1}},l.handle=function(t,N,F,k){var x=!1;function j(me){x||(x=!0,Module.preloadedAudios[N]=me,F&&F(t))}function q(){x||(x=!0,Module.preloadedAudios[N]=new Audio,k&&k())}if(Browser.hasBlobConstructor){try{var V=new Blob([t],{type:Browser.getMimetype(N)})}catch{return q()}var re=Browser.URLObject.createObjectURL(V),y=new Audio;y.addEventListener("canplaythrough",function(){j(y)},!1),y.onerror=function(De){if(x)return;console.log("warning: browser could not fully decode audio "+N+", trying slower base64 approach");function ge(ae){for(var we="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",he="=",ve="",ue=0,Ae=0,ze=0;ze<ae.length;ze++)for(ue=ue<<8|ae[ze],Ae+=8;Ae>=6;){var We=ue>>Ae-6&63;Ae-=6,ve+=we[We]}return Ae==2?(ve+=we[(ue&3)<<4],ve+=he+he):Ae==4&&(ve+=we[(ue&15)<<2],ve+=he),ve}y.src="data:audio/x-"+N.substr(-3)+";base64,"+ge(t),j(y)},y.src=re,Browser.safeSetTimeout(function(){j(y)},1e4)}else return q()},Module.preloadPlugins.push(l);function f(){Browser.pointerLock=document.pointerLockElement===Module.canvas||document.mozPointerLockElement===Module.canvas||document.webkitPointerLockElement===Module.canvas||document.msPointerLockElement===Module.canvas}var h=Module.canvas;h&&(h.requestPointerLock=h.requestPointerLock||h.mozRequestPointerLock||h.webkitRequestPointerLock||h.msRequestPointerLock||function(){},h.exitPointerLock=document.exitPointerLock||document.mozExitPointerLock||document.webkitExitPointerLock||document.msExitPointerLock||function(){},h.exitPointerLock=h.exitPointerLock.bind(document),document.addEventListener("pointerlockchange",f,!1),document.addEventListener("mozpointerlockchange",f,!1),document.addEventListener("webkitpointerlockchange",f,!1),document.addEventListener("mspointerlockchange",f,!1),Module.elementPointerLock&&h.addEventListener("click",function(E){!Browser.pointerLock&&Module.canvas.requestPointerLock&&(Module.canvas.requestPointerLock(),E.preventDefault())},!1))},createContext:function(o,l,f,h){if(l&&Module.ctx&&o==Module.canvas)return Module.ctx;var E,t;if(l){var N={antialias:!1,alpha:!1};if(h)for(var F in h)N[F]=h[F];t=GL.createContext(o,N),t&&(E=GL.getContext(t).GLctx)}else E=o.getContext("2d");return E?(f&&(l||assert(typeof GLctx>"u","cannot set in module if GLctx is used, but we are a non-GL context that would replace it"),Module.ctx=E,l&&GL.makeContextCurrent(t),Module.useWebGL=l,Browser.moduleContextCreatedCallbacks.forEach(function(k){k()}),Browser.init()),E):null},destroyContext:function(o,l,f){},fullscreenHandlersInstalled:!1,lockPointer:void 0,resizeCanvas:void 0,requestFullscreen:function(o,l,f){Browser.lockPointer=o,Browser.resizeCanvas=l,Browser.vrDevice=f,typeof Browser.lockPointer>"u"&&(Browser.lockPointer=!0),typeof Browser.resizeCanvas>"u"&&(Browser.resizeCanvas=!1),typeof Browser.vrDevice>"u"&&(Browser.vrDevice=null);var h=Module.canvas;function E(){Browser.isFullscreen=!1;var N=h.parentNode;(document.fullscreenElement||document.mozFullScreenElement||document.msFullscreenElement||document.webkitFullscreenElement||document.webkitCurrentFullScreenElement)===N?(h.exitFullscreen=document.exitFullscreen||document.cancelFullScreen||document.mozCancelFullScreen||document.msExitFullscreen||document.webkitCancelFullScreen||function(){},h.exitFullscreen=h.exitFullscreen.bind(document),Browser.lockPointer&&h.requestPointerLock(),Browser.isFullscreen=!0,Browser.resizeCanvas&&Browser.setFullscreenCanvasSize()):(N.parentNode.insertBefore(h,N),N.parentNode.removeChild(N),Browser.resizeCanvas&&Browser.setWindowedCanvasSize()),Module.onFullScreen&&Module.onFullScreen(Browser.isFullscreen),Module.onFullscreen&&Module.onFullscreen(Browser.isFullscreen),Browser.updateCanvasDimensions(h)}Browser.fullscreenHandlersInstalled||(Browser.fullscreenHandlersInstalled=!0,document.addEventListener("fullscreenchange",E,!1),document.addEventListener("mozfullscreenchange",E,!1),document.addEventListener("webkitfullscreenchange",E,!1),document.addEventListener("MSFullscreenChange",E,!1));var t=document.createElement("div");h.parentNode.insertBefore(t,h),t.appendChild(h),t.requestFullscreen=t.requestFullscreen||t.mozRequestFullScreen||t.msRequestFullscreen||(t.webkitRequestFullscreen?function(){t.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT)}:null)||(t.webkitRequestFullScreen?function(){t.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT)}:null),f?t.requestFullscreen({vrDisplay:f}):t.requestFullscreen()},requestFullScreen:function(o,l,f){return Module.printErr("Browser.requestFullScreen() is deprecated. Please call Browser.requestFullscreen instead."),Browser.requestFullScreen=function(h,E,t){return Browser.requestFullscreen(h,E,t)},Browser.requestFullscreen(o,l,f)},nextRAF:0,fakeRequestAnimationFrame:function(o){var l=Date.now();if(Browser.nextRAF===0)Browser.nextRAF=l+1e3/60;else for(;l+2>=Browser.nextRAF;)Browser.nextRAF+=1e3/60;var f=Math.max(Browser.nextRAF-l,0);setTimeout(o,f)},requestAnimationFrame:function o(l){typeof window>"u"?Browser.fakeRequestAnimationFrame(l):(window.requestAnimationFrame||(window.requestAnimationFrame=window.requestAnimationFrame||window.mozRequestAnimationFrame||window.webkitRequestAnimationFrame||window.msRequestAnimationFrame||window.oRequestAnimationFrame||Browser.fakeRequestAnimationFrame),window.requestAnimationFrame(l))},safeCallback:function(o){return function(){if(!ABORT)return o.apply(null,arguments)}},allowAsyncCallbacks:!0,queuedAsyncCallbacks:[],pauseAsyncCallbacks:function(){Browser.allowAsyncCallbacks=!1},resumeAsyncCallbacks:function(){if(Browser.allowAsyncCallbacks=!0,Browser.queuedAsyncCallbacks.length>0){var o=Browser.queuedAsyncCallbacks;Browser.queuedAsyncCallbacks=[],o.forEach(function(l){l()})}},safeRequestAnimationFrame:function(o){return Browser.requestAnimationFrame(function(){ABORT||(Browser.allowAsyncCallbacks?o():Browser.queuedAsyncCallbacks.push(o))})},safeSetTimeout:function(o,l){return Module.noExitRuntime=!0,setTimeout(function(){ABORT||(Browser.allowAsyncCallbacks?o():Browser.queuedAsyncCallbacks.push(o))},l)},safeSetInterval:function(o,l){return Module.noExitRuntime=!0,setInterval(function(){ABORT||Browser.allowAsyncCallbacks&&o()},l)},getMimetype:function(o){return{jpg:"image/jpeg",jpeg:"image/jpeg",png:"image/png",bmp:"image/bmp",ogg:"audio/ogg",wav:"audio/wav",mp3:"audio/mpeg"}[o.substr(o.lastIndexOf(".")+1)]},getUserMedia:function(o){window.getUserMedia||(window.getUserMedia=navigator.getUserMedia||navigator.mozGetUserMedia),window.getUserMedia(o)},getMovementX:function(o){return o.movementX||o.mozMovementX||o.webkitMovementX||0},getMovementY:function(o){return o.movementY||o.mozMovementY||o.webkitMovementY||0},getMouseWheelDelta:function(o){var l=0;switch(o.type){case"DOMMouseScroll":l=o.detail;break;case"mousewheel":l=o.wheelDelta;break;case"wheel":l=o.deltaY;break;default:throw"unrecognized mouse wheel event: "+o.type}return l},mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,touches:{},lastTouches:{},calculateMouseEvent:function(o){if(Browser.pointerLock)o.type!="mousemove"&&"mozMovementX"in o?Browser.mouseMovementX=Browser.mouseMovementY=0:(Browser.mouseMovementX=Browser.getMovementX(o),Browser.mouseMovementY=Browser.getMovementY(o)),typeof SDL<"u"?(Browser.mouseX=SDL.mouseX+Browser.mouseMovementX,Browser.mouseY=SDL.mouseY+Browser.mouseMovementY):(Browser.mouseX+=Browser.mouseMovementX,Browser.mouseY+=Browser.mouseMovementY);else{var l=Module.canvas.getBoundingClientRect(),f=Module.canvas.width,h=Module.canvas.height,E=typeof window.scrollX<"u"?window.scrollX:window.pageXOffset,t=typeof window.scrollY<"u"?window.scrollY:window.pageYOffset;if(o.type==="touchstart"||o.type==="touchend"||o.type==="touchmove"){var N=o.touch;if(N===void 0)return;var F=N.pageX-(E+l.left),k=N.pageY-(t+l.top);F=F*(f/l.width),k=k*(h/l.height);var x={x:F,y:k};if(o.type==="touchstart")Browser.lastTouches[N.identifier]=x,Browser.touches[N.identifier]=x;else if(o.type==="touchend"||o.type==="touchmove"){var j=Browser.touches[N.identifier];j||(j=x),Browser.lastTouches[N.identifier]=j,Browser.touches[N.identifier]=x}return}var q=o.pageX-(E+l.left),V=o.pageY-(t+l.top);q=q*(f/l.width),V=V*(h/l.height),Browser.mouseMovementX=q-Browser.mouseX,Browser.mouseMovementY=V-Browser.mouseY,Browser.mouseX=q,Browser.mouseY=V}},asyncLoad:function(o,l,f,h){var E=h?"":"al "+o;Module.readAsync(o,function(t){assert(t,'Loading data file "'+o+'" failed (no arrayBuffer).'),l(new Uint8Array(t)),E&&removeRunDependency(E)},function(t){if(f)f();else throw'Loading data file "'+o+'" failed.'}),E&&addRunDependency(E)},resizeListeners:[],updateResizeListeners:function(){var o=Module.canvas;Browser.resizeListeners.forEach(function(l){l(o.width,o.height)})},setCanvasSize:function(o,l,f){var h=Module.canvas;Browser.updateCanvasDimensions(h,o,l),f||Browser.updateResizeListeners()},windowedWidth:0,windowedHeight:0,setFullscreenCanvasSize:function(){if(typeof SDL<"u"){var o=HEAPU32[SDL.screen+Runtime.QUANTUM_SIZE*0>>2];o=o|8388608,HEAP32[SDL.screen+Runtime.QUANTUM_SIZE*0>>2]=o}Browser.updateResizeListeners()},setWindowedCanvasSize:function(){if(typeof SDL<"u"){var o=HEAPU32[SDL.screen+Runtime.QUANTUM_SIZE*0>>2];o=o&-8388609,HEAP32[SDL.screen+Runtime.QUANTUM_SIZE*0>>2]=o}Browser.updateResizeListeners()},updateCanvasDimensions:function(o,l,f){l&&f?(o.widthNative=l,o.heightNative=f):(l=o.widthNative,f=o.heightNative);var h=l,E=f;if(Module.forcedAspectRatio&&Module.forcedAspectRatio>0&&(h/E<Module.forcedAspectRatio?h=Math.round(E*Module.forcedAspectRatio):E=Math.round(h/Module.forcedAspectRatio)),(document.fullscreenElement||document.mozFullScreenElement||document.msFullscreenElement||document.webkitFullscreenElement||document.webkitCurrentFullScreenElement)===o.parentNode&&typeof screen<"u"){var t=Math.min(screen.width/h,screen.height/E);h=Math.round(h*t),E=Math.round(E*t)}Browser.resizeCanvas?(o.width!=h&&(o.width=h),o.height!=E&&(o.height=E),typeof o.style<"u"&&(o.style.removeProperty("width"),o.style.removeProperty("height"))):(o.width!=l&&(o.width=l),o.height!=f&&(o.height=f),typeof o.style<"u"&&(h!=l||E!=f?(o.style.setProperty("width",h+"px","important"),o.style.setProperty("height",E+"px","important")):(o.style.removeProperty("width"),o.style.removeProperty("height"))))},wgetRequests:{},nextWgetRequestHandle:0,getNextWgetRequestHandle:function(){var o=Browser.nextWgetRequestHandle;return Browser.nextWgetRequestHandle++,o}},SYSCALLS={varargs:0,get:function(o){SYSCALLS.varargs+=4;var l=HEAP32[SYSCALLS.varargs-4>>2];return l},getStr:function(){var o=Pointer_stringify(SYSCALLS.get());return o},get64:function(){var o=SYSCALLS.get(),l=SYSCALLS.get();return o>=0?assert(l===0):assert(l===-1),o},getZero:function(){assert(SYSCALLS.get()===0)}};function ___syscall6(o,l){SYSCALLS.varargs=l;try{var f=SYSCALLS.getStreamFromFD();return FS.close(f),0}catch(h){return(typeof FS>"u"||!(h instanceof FS.ErrnoError))&&abort(h),-h.errno}}function ___syscall54(o,l){SYSCALLS.varargs=l;try{return 0}catch(f){return(typeof FS>"u"||!(f instanceof FS.ErrnoError))&&abort(f),-f.errno}}function _typeModule(o){var l=[[0,1,"X"],[1,1,"const X"],[128,1,"X *"],[256,1,"X &"],[384,1,"X &&"],[512,1,"std::shared_ptr<X>"],[640,1,"std::unique_ptr<X>"],[5120,1,"std::vector<X>"],[6144,2,"std::array<X, Y>"],[9216,-1,"std::function<X (Y)>"]];function f(k,x,j,q,V,re){if(x==1){var y=q&896;(y==128||y==256||y==384)&&(k="X const")}var me;return re?me=j.replace("X",k).replace("Y",V):me=k.replace("X",j).replace("Y",V),me.replace(/([*&]) (?=[*&])/g,"$1")}function h(k,x,j,q,V){throw new Error(k+" type "+j.replace("X",x+"?")+(q?" with flag "+q:"")+" in "+V)}function E(k,x,j,q,V,re,y,me){re===void 0&&(re="X"),me===void 0&&(me=1);var De=j(k);if(De)return De;var ge=q(k),ae=ge.placeholderFlag,we=l[ae];y&&we&&(re=f(y[2],y[0],re,we[0],"?",!0));var he;ae==0&&(he="Unbound"),ae>=10&&(he="Corrupt"),me>20&&(he="Deeply nested"),he&&h(he,k,re,ae,V||"?");var ve=ge.paramList[0],ue=E(ve,x,j,q,V,re,we,me+1),Ae,ze={flags:we[0],id:k,name:"",paramList:[ue]},We=[],gt="?";switch(ge.placeholderFlag){case 1:Ae=ue.spec;break;case 2:if((ue.flags&15360)==1024&&ue.spec.ptrSize==1){ze.flags=7168;break}case 3:case 6:case 5:Ae=ue.spec,ue.flags&15360;break;case 8:gt=""+ge.paramList[1],ze.paramList.push(ge.paramList[1]);break;case 9:for(var _t=0,Qe=ge.paramList[1];_t<Qe.length;_t++){var ot=Qe[_t],Ve=E(ot,x,j,q,V,re,we,me+1);We.push(Ve.name),ze.paramList.push(Ve)}gt=We.join(", ");break;default:break}if(ze.name=f(we[2],we[0],ue.name,ue.flags,gt),Ae){for(var Pt=0,Jt=Object.keys(Ae);Pt<Jt.length;Pt++){var it=Jt[Pt];ze[it]=ze[it]||Ae[it]}ze.flags|=Ae.flags}return t(x,ze)}function t(k,x){var j=x.flags,q=j&896,V=j&15360;return!x.name&&V==1024&&(x.ptrSize==1?x.name=(j&16?"":(j&8?"un":"")+"signed ")+"char":x.name=(j&8?"u":"")+(j&32?"float":"int")+(x.ptrSize*8+"_t")),x.ptrSize==8&&!(j&32)&&(V=64),V==2048&&(q==512||q==640?V=4096:q&&(V=3072)),k(V,x)}var N=function(){function k(x){this.id=x.id,this.name=x.name,this.flags=x.flags,this.spec=x}return k.prototype.toString=function(){return this.name},k}(),F={Type:N,getComplexType:E,makeType:t,structureList:l};return o.output=F,o.output||F}function __nbind_register_type(o,l){var f=_nbind.readAsciiString(l),h={flags:10240,id:o,name:f};_nbind.makeType(_nbind.constructType,h)}function __nbind_register_callback_signature(o,l){var f=_nbind.readTypeIdList(o,l),h=_nbind.callbackSignatureList.length;return _nbind.callbackSignatureList[h]=_nbind.makeJSCaller(f),h}function __extends(o,l){for(var f in l)l.hasOwnProperty(f)&&(o[f]=l[f]);function h(){this.constructor=o}h.prototype=l.prototype,o.prototype=new h}function __nbind_register_class(o,l,f,h,E,t,N){var F=_nbind.readAsciiString(N),k=_nbind.readPolicyList(l),x=HEAPU32.subarray(o/4,o/4+2),j={flags:2048|(k.Value?2:0),id:x[0],name:F},q=_nbind.makeType(_nbind.constructType,j);q.ptrType=_nbind.getComplexType(x[1],_nbind.constructType,_nbind.getType,_nbind.queryType),q.destroy=_nbind.makeMethodCaller(q.ptrType,{boundID:j.id,flags:0,name:"destroy",num:0,ptr:t,title:q.name+".free",typeList:["void","uint32_t","uint32_t"]}),E&&(q.superIdList=Array.prototype.slice.call(HEAPU32.subarray(f/4,f/4+E)),q.upcastList=Array.prototype.slice.call(HEAPU32.subarray(h/4,h/4+E))),Module[q.name]=q.makeBound(k),_nbind.BindClass.list.push(q)}function _removeAccessorPrefix(o){var l=/^[Gg]et_?([A-Z]?([A-Z]?))/;return o.replace(l,function(f,h,E){return E?h:h.toLowerCase()})}function __nbind_register_function(o,l,f,h,E,t,N,F,k,x){var j=_nbind.getType(o),q=_nbind.readPolicyList(l),V=_nbind.readTypeIdList(f,h),re;if(N==5)re=[{direct:E,name:"__nbindConstructor",ptr:0,title:j.name+" constructor",typeList:["uint32_t"].concat(V.slice(1))},{direct:t,name:"__nbindValueConstructor",ptr:0,title:j.name+" value constructor",typeList:["void","uint32_t"].concat(V.slice(1))}];else{var y=_nbind.readAsciiString(F),me=(j.name&&j.name+".")+y;(N==3||N==4)&&(y=_removeAccessorPrefix(y)),re=[{boundID:o,direct:t,name:y,ptr:E,title:me,typeList:V}]}for(var De=0,ge=re;De<ge.length;De++){var ae=ge[De];ae.signatureType=N,ae.policyTbl=q,ae.num=k,ae.flags=x,j.addMethod(ae)}}function _nbind_value(o,l){_nbind.typeNameTbl[o]||_nbind.throwError("Unknown value type "+o),Module.NBind.bind_value(o,l),_defineHidden(_nbind.typeNameTbl[o].proto.prototype.__nbindValueConstructor)(l.prototype,"__nbindValueConstructor")}Module._nbind_value=_nbind_value;function __nbind_get_value_object(o,l){var f=_nbind.popValue(o);if(!f.fromJS)throw new Error("Object "+f+" has no fromJS function");f.fromJS(function(){f.__nbindValueConstructor.apply(this,Array.prototype.concat.apply([l],arguments))})}function _emscripten_memcpy_big(o,l,f){return HEAPU8.set(HEAPU8.subarray(l,l+f),o),o}function __nbind_register_primitive(o,l,f){var h={flags:1024|f,id:o,ptrSize:l};_nbind.makeType(_nbind.constructType,h)}var cttz_i8=allocate([8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0],"i8",ALLOC_STATIC);function ___setErrNo(o){return Module.___errno_location&&(HEAP32[Module.___errno_location()>>2]=o),o}function _llvm_stacksave(){var o=_llvm_stacksave;return o.LLVM_SAVEDSTACKS||(o.LLVM_SAVEDSTACKS=[]),o.LLVM_SAVEDSTACKS.push(Runtime.stackSave()),o.LLVM_SAVEDSTACKS.length-1}function ___syscall140(o,l){SYSCALLS.varargs=l;try{var f=SYSCALLS.getStreamFromFD(),h=SYSCALLS.get(),E=SYSCALLS.get(),t=SYSCALLS.get(),N=SYSCALLS.get(),F=E;return FS.llseek(f,F,N),HEAP32[t>>2]=f.position,f.getdents&&F===0&&N===0&&(f.getdents=null),0}catch(k){return(typeof FS>"u"||!(k instanceof FS.ErrnoError))&&abort(k),-k.errno}}function ___syscall146(o,l){SYSCALLS.varargs=l;try{var f=SYSCALLS.get(),h=SYSCALLS.get(),E=SYSCALLS.get(),t=0;___syscall146.buffer||(___syscall146.buffers=[null,[],[]],___syscall146.printChar=function(j,q){var V=___syscall146.buffers[j];assert(V),q===0||q===10?((j===1?Module.print:Module.printErr)(UTF8ArrayToString(V,0)),V.length=0):V.push(q)});for(var N=0;N<E;N++){for(var F=HEAP32[h+N*8>>2],k=HEAP32[h+(N*8+4)>>2],x=0;x<k;x++)___syscall146.printChar(f,HEAPU8[F+x]);t+=k}return t}catch(j){return(typeof FS>"u"||!(j instanceof FS.ErrnoError))&&abort(j),-j.errno}}function __nbind_finish(){for(var o=0,l=_nbind.BindClass.list;o<l.length;o++){var f=l[o];f.finish()}}var ___dso_handle=STATICTOP;STATICTOP+=16,function(_nbind){var typeIdTbl={};_nbind.typeNameTbl={};var Pool=function(){function o(){}return o.lalloc=function(l){l=l+7&-8;var f=HEAPU32[o.usedPtr];if(l>o.pageSize/2||l>o.pageSize-f){var h=_nbind.typeNameTbl.NBind.proto;return h.lalloc(l)}else return HEAPU32[o.usedPtr]=f+l,o.rootPtr+f},o.lreset=function(l,f){var h=HEAPU32[o.pagePtr];if(h){var E=_nbind.typeNameTbl.NBind.proto;E.lreset(l,f)}else HEAPU32[o.usedPtr]=l},o}();_nbind.Pool=Pool;function constructType(o,l){var f=o==10240?_nbind.makeTypeNameTbl[l.name]||_nbind.BindType:_nbind.makeTypeKindTbl[o],h=new f(l);return typeIdTbl[l.id]=h,_nbind.typeNameTbl[l.name]=h,h}_nbind.constructType=constructType;function getType(o){return typeIdTbl[o]}_nbind.getType=getType;function queryType(o){var l=HEAPU8[o],f=_nbind.structureList[l][1];o/=4,f<0&&(++o,f=HEAPU32[o]+1);var h=Array.prototype.slice.call(HEAPU32.subarray(o+1,o+1+f));return l==9&&(h=[h[0],h.slice(1)]),{paramList:h,placeholderFlag:l}}_nbind.queryType=queryType;function getTypes(o,l){return o.map(function(f){return typeof f=="number"?_nbind.getComplexType(f,constructType,getType,queryType,l):_nbind.typeNameTbl[f]})}_nbind.getTypes=getTypes;function readTypeIdList(o,l){return Array.prototype.slice.call(HEAPU32,o/4,o/4+l)}_nbind.readTypeIdList=readTypeIdList;function readAsciiString(o){for(var l=o;HEAPU8[l++];);return String.fromCharCode.apply("",HEAPU8.subarray(o,l-1))}_nbind.readAsciiString=readAsciiString;function readPolicyList(o){var l={};if(o)for(;;){var f=HEAPU32[o/4];if(!f)break;l[readAsciiString(f)]=!0,o+=4}return l}_nbind.readPolicyList=readPolicyList;function getDynCall(o,l){var f={float32_t:"d",float64_t:"d",int64_t:"d",uint64_t:"d",void:"v"},h=o.map(function(t){return f[t.name]||"i"}).join(""),E=Module["dynCall_"+h];if(!E)throw new Error("dynCall_"+h+" not found for "+l+"("+o.map(function(t){return t.name}).join(", ")+")");return E}_nbind.getDynCall=getDynCall;function addMethod(o,l,f,h){var E=o[l];o.hasOwnProperty(l)&&E?((E.arity||E.arity===0)&&(E=_nbind.makeOverloader(E,E.arity),o[l]=E),E.addMethod(f,h)):(f.arity=h,o[l]=f)}_nbind.addMethod=addMethod;function throwError(o){throw new Error(o)}_nbind.throwError=throwError,_nbind.bigEndian=!1,_a=_typeModule(_typeModule),_nbind.Type=_a.Type,_nbind.makeType=_a.makeType,_nbind.getComplexType=_a.getComplexType,_nbind.structureList=_a.structureList;var BindType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.heap=HEAPU32,f.ptrSize=4,f}return l.prototype.needsWireRead=function(f){return!!this.wireRead||!!this.makeWireRead},l.prototype.needsWireWrite=function(f){return!!this.wireWrite||!!this.makeWireWrite},l}(_nbind.Type);_nbind.BindType=BindType;var PrimitiveType=function(o){__extends(l,o);function l(f){var h=o.call(this,f)||this,E=f.flags&32?{32:HEAPF32,64:HEAPF64}:f.flags&8?{8:HEAPU8,16:HEAPU16,32:HEAPU32}:{8:HEAP8,16:HEAP16,32:HEAP32};return h.heap=E[f.ptrSize*8],h.ptrSize=f.ptrSize,h}return l.prototype.needsWireWrite=function(f){return!!f&&!!f.Strict},l.prototype.makeWireWrite=function(f,h){return h&&h.Strict&&function(E){if(typeof E=="number")return E;throw new Error("Type mismatch")}},l}(BindType);_nbind.PrimitiveType=PrimitiveType;function pushCString(o,l){if(o==null){if(l&&l.Nullable)return 0;throw new Error("Type mismatch")}if(l&&l.Strict){if(typeof o!="string")throw new Error("Type mismatch")}else o=o.toString();var f=Module.lengthBytesUTF8(o)+1,h=_nbind.Pool.lalloc(f);return Module.stringToUTF8Array(o,HEAPU8,h,f),h}_nbind.pushCString=pushCString;function popCString(o){return o===0?null:Module.Pointer_stringify(o)}_nbind.popCString=popCString;var CStringType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireRead=popCString,f.wireWrite=pushCString,f.readResources=[_nbind.resources.pool],f.writeResources=[_nbind.resources.pool],f}return l.prototype.makeWireWrite=function(f,h){return function(E){return pushCString(E,h)}},l}(BindType);_nbind.CStringType=CStringType;var BooleanType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireRead=function(h){return!!h},f}return l.prototype.needsWireWrite=function(f){return!!f&&!!f.Strict},l.prototype.makeWireRead=function(f){return"!!("+f+")"},l.prototype.makeWireWrite=function(f,h){return h&&h.Strict&&function(E){if(typeof E=="boolean")return E;throw new Error("Type mismatch")}||f},l}(BindType);_nbind.BooleanType=BooleanType;var Wrapper=function(){function o(){}return o.prototype.persist=function(){this.__nbindState|=1},o}();_nbind.Wrapper=Wrapper;function makeBound(o,l){var f=function(h){__extends(E,h);function E(t,N,F,k){var x=h.call(this)||this;if(!(x instanceof E))return new(Function.prototype.bind.apply(E,Array.prototype.concat.apply([null],arguments)));var j=N,q=F,V=k;if(t!==_nbind.ptrMarker){var re=x.__nbindConstructor.apply(x,arguments);j=4608,V=HEAPU32[re/4],q=HEAPU32[re/4+1]}var y={configurable:!0,enumerable:!1,value:null,writable:!1},me={__nbindFlags:j,__nbindPtr:q};V&&(me.__nbindShared=V,_nbind.mark(x));for(var De=0,ge=Object.keys(me);De<ge.length;De++){var ae=ge[De];y.value=me[ae],Object.defineProperty(x,ae,y)}return _defineHidden(0)(x,"__nbindState"),x}return E.prototype.free=function(){l.destroy.call(this,this.__nbindShared,this.__nbindFlags),this.__nbindState|=2,disableMember(this,"__nbindShared"),disableMember(this,"__nbindPtr")},E}(Wrapper);return __decorate([_defineHidden()],f.prototype,"__nbindConstructor",void 0),__decorate([_defineHidden()],f.prototype,"__nbindValueConstructor",void 0),__decorate([_defineHidden(o)],f.prototype,"__nbindPolicies",void 0),f}_nbind.makeBound=makeBound;function disableMember(o,l){function f(){throw new Error("Accessing deleted object")}Object.defineProperty(o,l,{configurable:!1,enumerable:!1,get:f,set:f})}_nbind.ptrMarker={};var BindClass=function(o){__extends(l,o);function l(f){var h=o.call(this,f)||this;return h.wireRead=function(E){return _nbind.popValue(E,h.ptrType)},h.wireWrite=function(E){return pushPointer(E,h.ptrType,!0)},h.pendingSuperCount=0,h.ready=!1,h.methodTbl={},f.paramList?(h.classType=f.paramList[0].classType,h.proto=h.classType.proto):h.classType=h,h}return l.prototype.makeBound=function(f){var h=_nbind.makeBound(f,this);return this.proto=h,this.ptrType.proto=h,h},l.prototype.addMethod=function(f){var h=this.methodTbl[f.name]||[];h.push(f),this.methodTbl[f.name]=h},l.prototype.registerMethods=function(f,h){for(var E,t=0,N=Object.keys(f.methodTbl);t<N.length;t++)for(var F=N[t],k=f.methodTbl[F],x=0,j=k;x<j.length;x++){var q=j[x],V=void 0,re=void 0;if(V=this.proto.prototype,!(h&&q.signatureType!=1))switch(q.signatureType){case 1:V=this.proto;case 5:re=_nbind.makeCaller(q),_nbind.addMethod(V,q.name,re,q.typeList.length-1);break;case 4:E=_nbind.makeMethodCaller(f.ptrType,q);break;case 3:Object.defineProperty(V,q.name,{configurable:!0,enumerable:!1,get:_nbind.makeMethodCaller(f.ptrType,q),set:E});break;case 2:re=_nbind.makeMethodCaller(f.ptrType,q),_nbind.addMethod(V,q.name,re,q.typeList.length-1);break;default:break}}},l.prototype.registerSuperMethods=function(f,h,E){if(!E[f.name]){E[f.name]=!0;for(var t=0,N,F=0,k=f.superIdList||[];F<k.length;F++){var x=k[F],j=_nbind.getType(x);t++<h||h<0?N=-1:N=0,this.registerSuperMethods(j,N,E)}this.registerMethods(f,h<0)}},l.prototype.finish=function(){if(this.ready)return this;this.ready=!0,this.superList=(this.superIdList||[]).map(function(E){return _nbind.getType(E).finish()});var f=this.proto;if(this.superList.length){var h=function(){this.constructor=f};h.prototype=this.superList[0].proto.prototype,f.prototype=new h}return f!=Module&&(f.prototype.__nbindType=this),this.registerSuperMethods(this,1,{}),this},l.prototype.upcastStep=function(f,h){if(f==this)return h;for(var E=0;E<this.superList.length;++E){var t=this.superList[E].upcastStep(f,_nbind.callUpcast(this.upcastList[E],h));if(t)return t}return 0},l}(_nbind.BindType);BindClass.list=[],_nbind.BindClass=BindClass;function popPointer(o,l){return o?new l.proto(_nbind.ptrMarker,l.flags,o):null}_nbind.popPointer=popPointer;function pushPointer(o,l,f){if(!(o instanceof _nbind.Wrapper)){if(f)return _nbind.pushValue(o);throw new Error("Type mismatch")}var h=o.__nbindPtr,E=o.__nbindType.classType,t=l.classType;if(o instanceof l.proto)for(;E!=t;)h=_nbind.callUpcast(E.upcastList[0],h),E=E.superList[0];else if(h=E.upcastStep(t,h),!h)throw new Error("Type mismatch");return h}_nbind.pushPointer=pushPointer;function pushMutablePointer(o,l){var f=pushPointer(o,l);if(o.__nbindFlags&1)throw new Error("Passing a const value as a non-const argument");return f}var BindClassPtr=function(o){__extends(l,o);function l(f){var h=o.call(this,f)||this;h.classType=f.paramList[0].classType,h.proto=h.classType.proto;var E=f.flags&1,t=(h.flags&896)==256&&f.flags&2,N=E?pushPointer:pushMutablePointer,F=t?_nbind.popValue:popPointer;return h.makeWireWrite=function(k,x){return x.Nullable?function(j){return j?N(j,h):0}:function(j){return N(j,h)}},h.wireRead=function(k){return F(k,h)},h.wireWrite=function(k){return N(k,h)},h}return l}(_nbind.BindType);_nbind.BindClassPtr=BindClassPtr;function popShared(o,l){var f=HEAPU32[o/4],h=HEAPU32[o/4+1];return h?new l.proto(_nbind.ptrMarker,l.flags,h,f):null}_nbind.popShared=popShared;function pushShared(o,l){if(!(o instanceof l.proto))throw new Error("Type mismatch");return o.__nbindShared}function pushMutableShared(o,l){if(!(o instanceof l.proto))throw new Error("Type mismatch");if(o.__nbindFlags&1)throw new Error("Passing a const value as a non-const argument");return o.__nbindShared}var SharedClassPtr=function(o){__extends(l,o);function l(f){var h=o.call(this,f)||this;h.readResources=[_nbind.resources.pool],h.classType=f.paramList[0].classType,h.proto=h.classType.proto;var E=f.flags&1,t=E?pushShared:pushMutableShared;return h.wireRead=function(N){return popShared(N,h)},h.wireWrite=function(N){return t(N,h)},h}return l}(_nbind.BindType);_nbind.SharedClassPtr=SharedClassPtr,_nbind.externalList=[0];var firstFreeExternal=0,External=function(){function o(l){this.refCount=1,this.data=l}return o.prototype.register=function(){var l=firstFreeExternal;return l?firstFreeExternal=_nbind.externalList[l]:l=_nbind.externalList.length,_nbind.externalList[l]=this,l},o.prototype.reference=function(){++this.refCount},o.prototype.dereference=function(l){--this.refCount==0&&(this.free&&this.free(),_nbind.externalList[l]=firstFreeExternal,firstFreeExternal=l)},o}();_nbind.External=External;function popExternal(o){var l=_nbind.externalList[o];return l.dereference(o),l.data}function pushExternal(o){var l=new External(o);return l.reference(),l.register()}var ExternalType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireRead=popExternal,f.wireWrite=pushExternal,f}return l}(_nbind.BindType);_nbind.ExternalType=ExternalType,_nbind.callbackSignatureList=[];var CallbackType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireWrite=function(h){return typeof h!="function"&&_nbind.throwError("Type mismatch"),new _nbind.External(h).register()},f}return l}(_nbind.BindType);_nbind.CallbackType=CallbackType,_nbind.valueList=[0];var firstFreeValue=0;function pushValue(o){var l=firstFreeValue;return l?firstFreeValue=_nbind.valueList[l]:l=_nbind.valueList.length,_nbind.valueList[l]=o,l*2+1}_nbind.pushValue=pushValue;function popValue(o,l){if(o||_nbind.throwError("Value type JavaScript class is missing or not registered"),o&1){o>>=1;var f=_nbind.valueList[o];return _nbind.valueList[o]=firstFreeValue,firstFreeValue=o,f}else{if(l)return _nbind.popShared(o,l);throw new Error("Invalid value slot "+o)}}_nbind.popValue=popValue;var valueBase=18446744073709552e3;function push64(o){return typeof o=="number"?o:pushValue(o)*4096+valueBase}function pop64(o){return o<valueBase?o:popValue((o-valueBase)/4096)}var CreateValueType=function(o){__extends(l,o);function l(){return o!==null&&o.apply(this,arguments)||this}return l.prototype.makeWireWrite=function(f){return"(_nbind.pushValue(new "+f+"))"},l}(_nbind.BindType);_nbind.CreateValueType=CreateValueType;var Int64Type=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireWrite=push64,f.wireRead=pop64,f}return l}(_nbind.BindType);_nbind.Int64Type=Int64Type;function pushArray(o,l){if(!o)return 0;var f=o.length;if((l.size||l.size===0)&&f<l.size)throw new Error("Type mismatch");var h=l.memberType.ptrSize,E=_nbind.Pool.lalloc(4+f*h);HEAPU32[E/4]=f;var t=l.memberType.heap,N=(E+4)/h,F=l.memberType.wireWrite,k=0;if(F)for(;k<f;)t[N++]=F(o[k++]);else for(;k<f;)t[N++]=o[k++];return E}_nbind.pushArray=pushArray;function popArray(o,l){if(o===0)return null;var f=HEAPU32[o/4],h=new Array(f),E=l.memberType.heap;o=(o+4)/l.memberType.ptrSize;var t=l.memberType.wireRead,N=0;if(t)for(;N<f;)h[N++]=t(E[o++]);else for(;N<f;)h[N++]=E[o++];return h}_nbind.popArray=popArray;var ArrayType=function(o){__extends(l,o);function l(f){var h=o.call(this,f)||this;return h.wireRead=function(E){return popArray(E,h)},h.wireWrite=function(E){return pushArray(E,h)},h.readResources=[_nbind.resources.pool],h.writeResources=[_nbind.resources.pool],h.memberType=f.paramList[0],f.paramList[1]&&(h.size=f.paramList[1]),h}return l}(_nbind.BindType);_nbind.ArrayType=ArrayType;function pushString(o,l){if(o==null)if(l&&l.Nullable)o="";else throw new Error("Type mismatch");if(l&&l.Strict){if(typeof o!="string")throw new Error("Type mismatch")}else o=o.toString();var f=Module.lengthBytesUTF8(o),h=_nbind.Pool.lalloc(4+f+1);return HEAPU32[h/4]=f,Module.stringToUTF8Array(o,HEAPU8,h+4,f+1),h}_nbind.pushString=pushString;function popString(o){if(o===0)return null;var l=HEAPU32[o/4];return Module.Pointer_stringify(o+4,l)}_nbind.popString=popString;var StringType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireRead=popString,f.wireWrite=pushString,f.readResources=[_nbind.resources.pool],f.writeResources=[_nbind.resources.pool],f}return l.prototype.makeWireWrite=function(f,h){return function(E){return pushString(E,h)}},l}(_nbind.BindType);_nbind.StringType=StringType;function makeArgList(o){return Array.apply(null,Array(o)).map(function(l,f){return"a"+(f+1)})}function anyNeedsWireWrite(o,l){return o.reduce(function(f,h){return f||h.needsWireWrite(l)},!1)}function anyNeedsWireRead(o,l){return o.reduce(function(f,h){return f||!!h.needsWireRead(l)},!1)}function makeWireRead(o,l,f,h){var E=o.length;return f.makeWireRead?f.makeWireRead(h,o,E):f.wireRead?(o[E]=f.wireRead,"(convertParamList["+E+"]("+h+"))"):h}function makeWireWrite(o,l,f,h){var E,t=o.length;return f.makeWireWrite?E=f.makeWireWrite(h,l,o,t):E=f.wireWrite,E?typeof E=="string"?E:(o[t]=E,"(convertParamList["+t+"]("+h+"))"):h}function buildCallerFunction(dynCall,ptrType,ptr,num,policyTbl,needsWireWrite,prefix,returnType,argTypeList,mask,err){var argList=makeArgList(argTypeList.length),convertParamList=[],callExpression=makeWireRead(convertParamList,policyTbl,returnType,"dynCall("+[prefix].concat(argList.map(function(o,l){return makeWireWrite(convertParamList,policyTbl,argTypeList[l],o)})).join(",")+")"),resourceSet=_nbind.listResources([returnType],argTypeList),sourceCode="function("+argList.join(",")+"){"+(mask?"this.__nbindFlags&mask&&err();":"")+resourceSet.makeOpen()+"var r="+callExpression+";"+resourceSet.makeClose()+"return r;}";return eval("("+sourceCode+")")}function buildJSCallerFunction(returnType,argTypeList){var argList=makeArgList(argTypeList.length),convertParamList=[],callExpression=makeWireWrite(convertParamList,null,returnType,"_nbind.externalList[num].data("+argList.map(function(o,l){return makeWireRead(convertParamList,null,argTypeList[l],o)}).join(",")+")"),resourceSet=_nbind.listResources(argTypeList,[returnType]);resourceSet.remove(_nbind.resources.pool);var sourceCode="function("+["dummy","num"].concat(argList).join(",")+"){"+resourceSet.makeOpen()+"var r="+callExpression+";"+resourceSet.makeClose()+"return r;}";return eval("("+sourceCode+")")}_nbind.buildJSCallerFunction=buildJSCallerFunction;function makeJSCaller(o){var l=o.length-1,f=_nbind.getTypes(o,"callback"),h=f[0],E=f.slice(1),t=anyNeedsWireRead(E,null),N=h.needsWireWrite(null);if(!N&&!t)switch(l){case 0:return function(F,k){return _nbind.externalList[k].data()};case 1:return function(F,k,x){return _nbind.externalList[k].data(x)};case 2:return function(F,k,x,j){return _nbind.externalList[k].data(x,j)};case 3:return function(F,k,x,j,q){return _nbind.externalList[k].data(x,j,q)};default:break}return buildJSCallerFunction(h,E)}_nbind.makeJSCaller=makeJSCaller;function makeMethodCaller(o,l){var f=l.typeList.length-1,h=l.typeList.slice(0);h.splice(1,0,"uint32_t",l.boundID);var E=_nbind.getTypes(h,l.title),t=E[0],N=E.slice(3),F=t.needsWireRead(l.policyTbl),k=anyNeedsWireWrite(N,l.policyTbl),x=l.ptr,j=l.num,q=_nbind.getDynCall(E,l.title),V=~l.flags&1;function re(){throw new Error("Calling a non-const method on a const object")}if(!F&&!k)switch(f){case 0:return function(){return this.__nbindFlags&V?re():q(x,j,_nbind.pushPointer(this,o))};case 1:return function(y){return this.__nbindFlags&V?re():q(x,j,_nbind.pushPointer(this,o),y)};case 2:return function(y,me){return this.__nbindFlags&V?re():q(x,j,_nbind.pushPointer(this,o),y,me)};case 3:return function(y,me,De){return this.__nbindFlags&V?re():q(x,j,_nbind.pushPointer(this,o),y,me,De)};default:break}return buildCallerFunction(q,o,x,j,l.policyTbl,k,"ptr,num,pushPointer(this,ptrType)",t,N,V,re)}_nbind.makeMethodCaller=makeMethodCaller;function makeCaller(o){var l=o.typeList.length-1,f=_nbind.getTypes(o.typeList,o.title),h=f[0],E=f.slice(1),t=h.needsWireRead(o.policyTbl),N=anyNeedsWireWrite(E,o.policyTbl),F=o.direct,k=o.ptr;if(o.direct&&!t&&!N){var x=_nbind.getDynCall(f,o.title);switch(l){case 0:return function(){return x(F)};case 1:return function(re){return x(F,re)};case 2:return function(re,y){return x(F,re,y)};case 3:return function(re,y,me){return x(F,re,y,me)};default:break}k=0}var j;if(k){var q=o.typeList.slice(0);q.splice(1,0,"uint32_t"),f=_nbind.getTypes(q,o.title),j="ptr,num"}else k=F,j="ptr";var V=_nbind.getDynCall(f,o.title);return buildCallerFunction(V,null,k,o.num,o.policyTbl,N,j,h,E)}_nbind.makeCaller=makeCaller;function makeOverloader(o,l){var f=[];function h(){return f[arguments.length].apply(this,arguments)}return h.addMethod=function(E,t){f[t]=E},h.addMethod(o,l),h}_nbind.makeOverloader=makeOverloader;var Resource=function(){function o(l,f){var h=this;this.makeOpen=function(){return Object.keys(h.openTbl).join("")},this.makeClose=function(){return Object.keys(h.closeTbl).join("")},this.openTbl={},this.closeTbl={},l&&(this.openTbl[l]=!0),f&&(this.closeTbl[f]=!0)}return o.prototype.add=function(l){for(var f=0,h=Object.keys(l.openTbl);f<h.length;f++){var E=h[f];this.openTbl[E]=!0}for(var t=0,N=Object.keys(l.closeTbl);t<N.length;t++){var E=N[t];this.closeTbl[E]=!0}},o.prototype.remove=function(l){for(var f=0,h=Object.keys(l.openTbl);f<h.length;f++){var E=h[f];delete this.openTbl[E]}for(var t=0,N=Object.keys(l.closeTbl);t<N.length;t++){var E=N[t];delete this.closeTbl[E]}},o}();_nbind.Resource=Resource;function listResources(o,l){for(var f=new Resource,h=0,E=o;h<E.length;h++)for(var t=E[h],N=0,F=t.readResources||[];N<F.length;N++){var k=F[N];f.add(k)}for(var x=0,j=l;x<j.length;x++)for(var t=j[x],q=0,V=t.writeResources||[];q<V.length;q++){var k=V[q];f.add(k)}return f}_nbind.listResources=listResources,_nbind.resources={pool:new Resource("var used=HEAPU32[_nbind.Pool.usedPtr],page=HEAPU32[_nbind.Pool.pagePtr];","_nbind.Pool.lreset(used,page);")};var ExternalBuffer=function(o){__extends(l,o);function l(f,h){var E=o.call(this,f)||this;return E.ptr=h,E}return l.prototype.free=function(){_free(this.ptr)},l}(_nbind.External);function getBuffer(o){return o instanceof ArrayBuffer?new Uint8Array(o):o instanceof DataView?new Uint8Array(o.buffer,o.byteOffset,o.byteLength):o}function pushBuffer(o,l){if(o==null&&l&&l.Nullable&&(o=[]),typeof o!="object")throw new Error("Type mismatch");var f=o,h=f.byteLength||f.length;if(!h&&h!==0&&f.byteLength!==0)throw new Error("Type mismatch");var E=_nbind.Pool.lalloc(8),t=_malloc(h),N=E/4;return HEAPU32[N++]=h,HEAPU32[N++]=t,HEAPU32[N++]=new ExternalBuffer(o,t).register(),HEAPU8.set(getBuffer(o),t),E}var BufferType=function(o){__extends(l,o);function l(){var f=o!==null&&o.apply(this,arguments)||this;return f.wireWrite=pushBuffer,f.readResources=[_nbind.resources.pool],f.writeResources=[_nbind.resources.pool],f}return l.prototype.makeWireWrite=function(f,h){return function(E){return pushBuffer(E,h)}},l}(_nbind.BindType);_nbind.BufferType=BufferType;function commitBuffer(o,l,f){var h=_nbind.externalList[o].data,E=Buffer;if(typeof Buffer!="function"&&(E=function(){}),!(h instanceof Array)){var t=HEAPU8.subarray(l,l+f);if(h instanceof E){var N=void 0;typeof Buffer.from=="function"&&Buffer.from.length>=3?N=Buffer.from(t):N=new Buffer(t),N.copy(h)}else getBuffer(h).set(t)}}_nbind.commitBuffer=commitBuffer;var dirtyList=[],gcTimer=0;function sweep(){for(var o=0,l=dirtyList;o<l.length;o++){var f=l[o];f.__nbindState&3||f.free()}dirtyList=[],gcTimer=0}_nbind.mark=function(o){};function toggleLightGC(o){o?_nbind.mark=function(l){dirtyList.push(l),gcTimer||(gcTimer=setTimeout(sweep,0))}:_nbind.mark=function(l){}}_nbind.toggleLightGC=toggleLightGC}(_nbind),Module.requestFullScreen=function o(l,f,h){Module.printErr("Module.requestFullScreen is deprecated. Please call Module.requestFullscreen instead."),Module.requestFullScreen=Module.requestFullscreen,Browser.requestFullScreen(l,f,h)},Module.requestFullscreen=function o(l,f,h){Browser.requestFullscreen(l,f,h)},Module.requestAnimationFrame=function o(l){Browser.requestAnimationFrame(l)},Module.setCanvasSize=function o(l,f,h){Browser.setCanvasSize(l,f,h)},Module.pauseMainLoop=function o(){Browser.mainLoop.pause()},Module.resumeMainLoop=function o(){Browser.mainLoop.resume()},Module.getUserMedia=function o(){Browser.getUserMedia()},Module.createContext=function o(l,f,h,E){return Browser.createContext(l,f,h,E)},ENVIRONMENT_IS_NODE?_emscripten_get_now=function(){var l=process.hrtime();return l[0]*1e3+l[1]/1e6}:typeof dateNow<"u"?_emscripten_get_now=dateNow:typeof self=="object"&&self.performance&&typeof self.performance.now=="function"?_emscripten_get_now=function(){return self.performance.now()}:typeof performance=="object"&&typeof performance.now=="function"?_emscripten_get_now=function(){return performance.now()}:_emscripten_get_now=Date.now,__ATEXIT__.push(function(){var o=Module._fflush;o&&o(0);var l=___syscall146.printChar;if(!!l){var f=___syscall146.buffers;f[1].length&&l(1,10),f[2].length&&l(2,10)}}),DYNAMICTOP_PTR=allocate(1,"i32",ALLOC_STATIC),STACK_BASE=STACKTOP=Runtime.alignMemory(STATICTOP),STACK_MAX=STACK_BASE+TOTAL_STACK,DYNAMIC_BASE=Runtime.alignMemory(STACK_MAX),HEAP32[DYNAMICTOP_PTR>>2]=DYNAMIC_BASE,staticSealed=!0;function invoke_viiiii(o,l,f,h,E,t){try{Module.dynCall_viiiii(o,l,f,h,E,t)}catch(N){if(typeof N!="number"&&N!=="longjmp")throw N;Module.setThrew(1,0)}}function invoke_vif(o,l,f){try{Module.dynCall_vif(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_vid(o,l,f){try{Module.dynCall_vid(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_fiff(o,l,f,h){try{return Module.dynCall_fiff(o,l,f,h)}catch(E){if(typeof E!="number"&&E!=="longjmp")throw E;Module.setThrew(1,0)}}function invoke_vi(o,l){try{Module.dynCall_vi(o,l)}catch(f){if(typeof f!="number"&&f!=="longjmp")throw f;Module.setThrew(1,0)}}function invoke_vii(o,l,f){try{Module.dynCall_vii(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_ii(o,l){try{return Module.dynCall_ii(o,l)}catch(f){if(typeof f!="number"&&f!=="longjmp")throw f;Module.setThrew(1,0)}}function invoke_viddi(o,l,f,h,E){try{Module.dynCall_viddi(o,l,f,h,E)}catch(t){if(typeof t!="number"&&t!=="longjmp")throw t;Module.setThrew(1,0)}}function invoke_vidd(o,l,f,h){try{Module.dynCall_vidd(o,l,f,h)}catch(E){if(typeof E!="number"&&E!=="longjmp")throw E;Module.setThrew(1,0)}}function invoke_iiii(o,l,f,h){try{return Module.dynCall_iiii(o,l,f,h)}catch(E){if(typeof E!="number"&&E!=="longjmp")throw E;Module.setThrew(1,0)}}function invoke_diii(o,l,f,h){try{return Module.dynCall_diii(o,l,f,h)}catch(E){if(typeof E!="number"&&E!=="longjmp")throw E;Module.setThrew(1,0)}}function invoke_di(o,l){try{return Module.dynCall_di(o,l)}catch(f){if(typeof f!="number"&&f!=="longjmp")throw f;Module.setThrew(1,0)}}function invoke_iid(o,l,f){try{return Module.dynCall_iid(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_iii(o,l,f){try{return Module.dynCall_iii(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_viiddi(o,l,f,h,E,t){try{Module.dynCall_viiddi(o,l,f,h,E,t)}catch(N){if(typeof N!="number"&&N!=="longjmp")throw N;Module.setThrew(1,0)}}function invoke_viiiiii(o,l,f,h,E,t,N){try{Module.dynCall_viiiiii(o,l,f,h,E,t,N)}catch(F){if(typeof F!="number"&&F!=="longjmp")throw F;Module.setThrew(1,0)}}function invoke_dii(o,l,f){try{return Module.dynCall_dii(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_i(o){try{return Module.dynCall_i(o)}catch(l){if(typeof l!="number"&&l!=="longjmp")throw l;Module.setThrew(1,0)}}function invoke_iiiiii(o,l,f,h,E,t){try{return Module.dynCall_iiiiii(o,l,f,h,E,t)}catch(N){if(typeof N!="number"&&N!=="longjmp")throw N;Module.setThrew(1,0)}}function invoke_viiid(o,l,f,h,E){try{Module.dynCall_viiid(o,l,f,h,E)}catch(t){if(typeof t!="number"&&t!=="longjmp")throw t;Module.setThrew(1,0)}}function invoke_viififi(o,l,f,h,E,t,N){try{Module.dynCall_viififi(o,l,f,h,E,t,N)}catch(F){if(typeof F!="number"&&F!=="longjmp")throw F;Module.setThrew(1,0)}}function invoke_viii(o,l,f,h){try{Module.dynCall_viii(o,l,f,h)}catch(E){if(typeof E!="number"&&E!=="longjmp")throw E;Module.setThrew(1,0)}}function invoke_v(o){try{Module.dynCall_v(o)}catch(l){if(typeof l!="number"&&l!=="longjmp")throw l;Module.setThrew(1,0)}}function invoke_viid(o,l,f,h){try{Module.dynCall_viid(o,l,f,h)}catch(E){if(typeof E!="number"&&E!=="longjmp")throw E;Module.setThrew(1,0)}}function invoke_idd(o,l,f){try{return Module.dynCall_idd(o,l,f)}catch(h){if(typeof h!="number"&&h!=="longjmp")throw h;Module.setThrew(1,0)}}function invoke_viiii(o,l,f,h,E){try{Module.dynCall_viiii(o,l,f,h,E)}catch(t){if(typeof t!="number"&&t!=="longjmp")throw t;Module.setThrew(1,0)}}Module.asmGlobalArg={Math,Int8Array,Int16Array,Int32Array,Uint8Array,Uint16Array,Uint32Array,Float32Array,Float64Array,NaN:NaN,Infinity:1/0},Module.asmLibraryArg={abort,assert,enlargeMemory,getTotalMemory,abortOnCannotGrowMemory,invoke_viiiii,invoke_vif,invoke_vid,invoke_fiff,invoke_vi,invoke_vii,invoke_ii,invoke_viddi,invoke_vidd,invoke_iiii,invoke_diii,invoke_di,invoke_iid,invoke_iii,invoke_viiddi,invoke_viiiiii,invoke_dii,invoke_i,invoke_iiiiii,invoke_viiid,invoke_viififi,invoke_viii,invoke_v,invoke_viid,invoke_idd,invoke_viiii,_emscripten_asm_const_iiiii,_emscripten_asm_const_iiidddddd,_emscripten_asm_const_iiiid,__nbind_reference_external,_emscripten_asm_const_iiiiiiii,_removeAccessorPrefix,_typeModule,__nbind_register_pool,__decorate,_llvm_stackrestore,___cxa_atexit,__extends,__nbind_get_value_object,__ZN8facebook4yoga14YGNodeToStringEPNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP6YGNode14YGPrintOptionsj,_emscripten_set_main_loop_timing,__nbind_register_primitive,__nbind_register_type,_emscripten_memcpy_big,__nbind_register_function,___setErrNo,__nbind_register_class,__nbind_finish,_abort,_nbind_value,_llvm_stacksave,___syscall54,_defineHidden,_emscripten_set_main_loop,_emscripten_get_now,__nbind_register_callback_signature,_emscripten_asm_const_iiiiii,__nbind_free_external,_emscripten_asm_const_iiii,_emscripten_asm_const_iiididi,___syscall6,_atexit,___syscall140,___syscall146,DYNAMICTOP_PTR,tempDoublePtr,ABORT,STACKTOP,STACK_MAX,cttz_i8,___dso_handle};var asm=function(o,l,f){var h=new o.Int8Array(f),E=new o.Int16Array(f),t=new o.Int32Array(f),N=new o.Uint8Array(f),F=new o.Uint16Array(f),k=new o.Uint32Array(f),x=new o.Float32Array(f),j=new o.Float64Array(f),q=l.DYNAMICTOP_PTR|0,V=l.tempDoublePtr|0,re=l.ABORT|0,y=l.STACKTOP|0,me=l.STACK_MAX|0,De=l.cttz_i8|0,ge=l.___dso_handle|0,ae=0,we=0,he=0,ve=0,ue=o.NaN,Ae=o.Infinity,ze=0,We=0,gt=0,_t=0,Qe=0,ot=0,Ve=o.Math.floor,Pt=o.Math.abs,Jt=o.Math.sqrt,it=o.Math.pow,J=o.Math.cos,ce=o.Math.sin,Re=o.Math.tan,le=o.Math.acos,He=o.Math.asin,dt=o.Math.atan,At=o.Math.atan2,nn=o.Math.exp,an=o.Math.log,On=o.Math.ceil,lr=o.Math.imul,ln=o.Math.min,Vt=o.Math.max,Er=o.Math.clz32,S=o.Math.fround,zt=l.abort,Xn=l.assert,vr=l.enlargeMemory,jr=l.getTotalMemory,fr=l.abortOnCannotGrowMemory,zr=l.invoke_viiiii,Xt=l.invoke_vif,Du=l.invoke_vid,c0=l.invoke_fiff,Ao=l.invoke_vi,Jo=l.invoke_vii,Fs=l.invoke_ii,Zo=l.invoke_viddi,$o=l.invoke_vidd,qt=l.invoke_iiii,xi=l.invoke_diii,lu=l.invoke_di,vi=l.invoke_iid,Dr=l.invoke_iii,el=l.invoke_viiddi,Y0=l.invoke_viiiiii,Bu=l.invoke_dii,K0=l.invoke_i,Kr=l.invoke_iiiiii,Oo=l.invoke_viiid,Mo=l.invoke_viififi,F0=l.invoke_viii,su=l.invoke_v,ki=l.invoke_viid,Ps=l.invoke_idd,Kl=l.invoke_viiii,P0=l._emscripten_asm_const_iiiii,d0=l._emscripten_asm_const_iiidddddd,Hr=l._emscripten_asm_const_iiiid,Ri=l.__nbind_reference_external,X0=l._emscripten_asm_const_iiiiiiii,mi=l._removeAccessorPrefix,en=l._typeModule,In=l.__nbind_register_pool,Ai=l.__decorate,yi=l._llvm_stackrestore,Wt=l.___cxa_atexit,Ru=l.__extends,eu=l.__nbind_get_value_object,Q0=l.__ZN8facebook4yoga14YGNodeToStringEPNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP6YGNode14YGPrintOptionsj,Yi=l._emscripten_set_main_loop_timing,Xl=l.__nbind_register_primitive,ko=l.__nbind_register_type,li=l._emscripten_memcpy_big,ao=l.__nbind_register_function,Ql=l.___setErrNo,No=l.__nbind_register_class,Is=l.__nbind_finish,$n=l._abort,tl=l._nbind_value,fo=l._llvm_stacksave,I0=l.___syscall54,Sl=l._defineHidden,Lo=l._emscripten_set_main_loop,St=l._emscripten_get_now,Bt=l.__nbind_register_callback_signature,Hn=l._emscripten_asm_const_iiiiii,qr=l.__nbind_free_external,Ki=l._emscripten_asm_const_iiii,Xr=l._emscripten_asm_const_iiididi,Au=l.___syscall6,p0=l._atexit,Ni=l.___syscall140,h0=l.___syscall146,hs=S(0);let Ct=S(0);function co(e){e=e|0;var n=0;return n=y,y=y+e|0,y=y+15&-16,n|0}function nl(){return y|0}function Jl(e){e=e|0,y=e}function Uu(e,n){e=e|0,n=n|0,y=e,me=n}function vs(e,n){e=e|0,n=n|0,ae||(ae=e,we=n)}function b0(e){e=e|0,ot=e}function Q(){return ot|0}function Se(){var e=0,n=0;gr(8104,8,400)|0,gr(8504,408,540)|0,e=9044,n=e+44|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));h[9088]=0,h[9089]=1,t[2273]=0,t[2274]=948,t[2275]=948,Wt(17,8104,ge|0)|0}function Fe(e){e=e|0,ac(e+948|0)}function Le(e){return e=S(e),((mr(e)|0)&2147483647)>>>0>2139095040|0}function pt(e,n,r){e=e|0,n=n|0,r=r|0;e:do if(t[e+(n<<3)+4>>2]|0)e=e+(n<<3)|0;else{if((n|2|0)==3&&t[e+60>>2]|0){e=e+56|0;break}switch(n|0){case 0:case 2:case 4:case 5:{if(t[e+52>>2]|0){e=e+48|0;break e}break}default:}if(t[e+68>>2]|0){e=e+64|0;break}else{e=(n|1|0)==5?948:r;break}}while(0);return e|0}function Yn(e){e=e|0;var n=0;return n=p_(1e3)|0,Cn(e,(n|0)!=0,2456),t[2276]=(t[2276]|0)+1,gr(n|0,8104,1e3)|0,h[e+2>>0]|0&&(t[n+4>>2]=2,t[n+12>>2]=4),t[n+976>>2]=e,n|0}function Cn(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;s=y,y=y+16|0,u=s,n||(t[u>>2]=r,Cl(e,5,3197,u)),y=s}function cr(){return Yn(956)|0}function Si(e){e=e|0;var n=0;return n=pn(1e3)|0,Ou(n,e),Cn(t[e+976>>2]|0,1,2456),t[2276]=(t[2276]|0)+1,t[n+944>>2]=0,n|0}function Ou(e,n){e=e|0,n=n|0;var r=0;gr(e|0,n|0,948)|0,sa(e+948|0,n+948|0),r=e+960|0,e=n+960|0,n=r+40|0;do t[r>>2]=t[e>>2],r=r+4|0,e=e+4|0;while((r|0)<(n|0))}function ju(e){e=e|0;var n=0,r=0,u=0,s=0;if(n=e+944|0,r=t[n>>2]|0,r|0&&(zu(r+948|0,e)|0,t[n>>2]=0),r=wu(e)|0,r|0){n=0;do t[(Ti(e,n)|0)+944>>2]=0,n=n+1|0;while((n|0)!=(r|0))}r=e+948|0,u=t[r>>2]|0,s=e+952|0,n=t[s>>2]|0,(n|0)!=(u|0)&&(t[s>>2]=n+(~((n+-4-u|0)>>>2)<<2)),Fo(r),h_(e),t[2276]=(t[2276]|0)+-1}function zu(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0;u=t[e>>2]|0,w=e+4|0,r=t[w>>2]|0,a=r;e:do if((u|0)==(r|0))s=u,v=4;else for(e=u;;){if((t[e>>2]|0)==(n|0)){s=e,v=4;break e}if(e=e+4|0,(e|0)==(r|0)){e=0;break}}while(0);return(v|0)==4&&((s|0)!=(r|0)?(u=s+4|0,e=a-u|0,n=e>>2,n&&(ky(s|0,u|0,e|0)|0,r=t[w>>2]|0),e=s+(n<<2)|0,(r|0)==(e|0)||(t[w>>2]=r+(~((r+-4-e|0)>>>2)<<2)),e=1):e=0),e|0}function wu(e){return e=e|0,(t[e+952>>2]|0)-(t[e+948>>2]|0)>>2|0}function Ti(e,n){e=e|0,n=n|0;var r=0;return r=t[e+948>>2]|0,(t[e+952>>2]|0)-r>>2>>>0>n>>>0?e=t[r+(n<<2)>>2]|0:e=0,e|0}function Fo(e){e=e|0;var n=0,r=0,u=0,s=0;u=y,y=y+32|0,n=u,s=t[e>>2]|0,r=(t[e+4>>2]|0)-s|0,((t[e+8>>2]|0)-s|0)>>>0>r>>>0&&(s=r>>2,K(n,s,s,e+8|0),ti(e,n),ni(n)),y=u}function Mu(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0;L=wu(e)|0;do if(L|0){if((t[(Ti(e,0)|0)+944>>2]|0)==(e|0)){if(!(zu(e+948|0,n)|0))break;gr(n+400|0,8504,540)|0,t[n+944>>2]=0,Qn(e);break}v=t[(t[e+976>>2]|0)+12>>2]|0,w=e+948|0,T=(v|0)==0,r=0,a=0;do u=t[(t[w>>2]|0)+(a<<2)>>2]|0,(u|0)==(n|0)?Qn(e):(s=Si(u)|0,t[(t[w>>2]|0)+(r<<2)>>2]=s,t[s+944>>2]=e,T||BE[v&15](u,s,e,r),r=r+1|0),a=a+1|0;while((a|0)!=(L|0));if(r>>>0<L>>>0){T=e+948|0,w=e+952|0,v=r,r=t[w>>2]|0;do a=(t[T>>2]|0)+(v<<2)|0,u=a+4|0,s=r-u|0,n=s>>2,n&&(ky(a|0,u|0,s|0)|0,r=t[w>>2]|0),s=r,u=a+(n<<2)|0,(s|0)!=(u|0)&&(r=s+(~((s+-4-u|0)>>>2)<<2)|0,t[w>>2]=r),v=v+1|0;while((v|0)!=(L|0))}}while(0)}function po(e){e=e|0;var n=0,r=0,u=0,s=0;Hu(e,(wu(e)|0)==0,2491),Hu(e,(t[e+944>>2]|0)==0,2545),n=e+948|0,r=t[n>>2]|0,u=e+952|0,s=t[u>>2]|0,(s|0)!=(r|0)&&(t[u>>2]=s+(~((s+-4-r|0)>>>2)<<2)),Fo(n),n=e+976|0,r=t[n>>2]|0,gr(e|0,8104,1e3)|0,h[r+2>>0]|0&&(t[e+4>>2]=2,t[e+12>>2]=4),t[n>>2]=r}function Hu(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;s=y,y=y+16|0,u=s,n||(t[u>>2]=r,pr(e,5,3197,u)),y=s}function Pa(){return t[2276]|0}function v0(){var e=0;return e=p_(20)|0,ia((e|0)!=0,2592),t[2277]=(t[2277]|0)+1,t[e>>2]=t[239],t[e+4>>2]=t[240],t[e+8>>2]=t[241],t[e+12>>2]=t[242],t[e+16>>2]=t[243],e|0}function ia(e,n){e=e|0,n=n|0;var r=0,u=0;u=y,y=y+16|0,r=u,e||(t[r>>2]=n,pr(0,5,3197,r)),y=u}function J0(e){e=e|0,h_(e),t[2277]=(t[2277]|0)+-1}function ua(e,n){e=e|0,n=n|0;var r=0;n?(Hu(e,(wu(e)|0)==0,2629),r=1):(r=0,n=0),t[e+964>>2]=n,t[e+988>>2]=r}function Ia(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,a=u+8|0,s=u+4|0,v=u,t[s>>2]=n,Hu(e,(t[n+944>>2]|0)==0,2709),Hu(e,(t[e+964>>2]|0)==0,2763),ms(e),n=e+948|0,t[v>>2]=(t[n>>2]|0)+(r<<2),t[a>>2]=t[v>>2],S0(n,a,s)|0,t[(t[s>>2]|0)+944>>2]=e,Qn(e),y=u}function ms(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0;if(r=wu(e)|0,r|0&&(t[(Ti(e,0)|0)+944>>2]|0)!=(e|0)){u=t[(t[e+976>>2]|0)+12>>2]|0,s=e+948|0,a=(u|0)==0,n=0;do v=t[(t[s>>2]|0)+(n<<2)>>2]|0,w=Si(v)|0,t[(t[s>>2]|0)+(n<<2)>>2]=w,t[w+944>>2]=e,a||BE[u&15](v,w,e,n),n=n+1|0;while((n|0)!=(r|0))}}function S0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0,Ze=0,Ye=0;Ze=y,y=y+64|0,b=Ze+52|0,w=Ze+48|0,X=Ze+28|0,Be=Ze+24|0,Te=Ze+20|0,ye=Ze,u=t[e>>2]|0,a=u,n=u+((t[n>>2]|0)-a>>2<<2)|0,u=e+4|0,s=t[u>>2]|0,v=e+8|0;do if(s>>>0<(t[v>>2]|0)>>>0){if((n|0)==(s|0)){t[n>>2]=t[r>>2],t[u>>2]=(t[u>>2]|0)+4;break}Wr(e,n,s,n+4|0),n>>>0<=r>>>0&&(r=(t[u>>2]|0)>>>0>r>>>0?r+4|0:r),t[n>>2]=t[r>>2]}else{u=(s-a>>2)+1|0,s=R0(e)|0,s>>>0<u>>>0&&di(e),M=t[e>>2]|0,L=(t[v>>2]|0)-M|0,a=L>>1,K(ye,L>>2>>>0<s>>>1>>>0?a>>>0<u>>>0?u:a:s,n-M>>2,e+8|0),M=ye+8|0,u=t[M>>2]|0,a=ye+12|0,L=t[a>>2]|0,v=L,T=u;do if((u|0)==(L|0)){if(L=ye+4|0,u=t[L>>2]|0,Ye=t[ye>>2]|0,s=Ye,u>>>0<=Ye>>>0){u=v-s>>1,u=(u|0)==0?1:u,K(X,u,u>>>2,t[ye+16>>2]|0),t[Be>>2]=t[L>>2],t[Te>>2]=t[M>>2],t[w>>2]=t[Be>>2],t[b>>2]=t[Te>>2],Di(X,w,b),u=t[ye>>2]|0,t[ye>>2]=t[X>>2],t[X>>2]=u,u=X+4|0,Ye=t[L>>2]|0,t[L>>2]=t[u>>2],t[u>>2]=Ye,u=X+8|0,Ye=t[M>>2]|0,t[M>>2]=t[u>>2],t[u>>2]=Ye,u=X+12|0,Ye=t[a>>2]|0,t[a>>2]=t[u>>2],t[u>>2]=Ye,ni(X),u=t[M>>2]|0;break}a=u,v=((a-s>>2)+1|0)/-2|0,w=u+(v<<2)|0,s=T-a|0,a=s>>2,a&&(ky(w|0,u|0,s|0)|0,u=t[L>>2]|0),Ye=w+(a<<2)|0,t[M>>2]=Ye,t[L>>2]=u+(v<<2),u=Ye}while(0);t[u>>2]=t[r>>2],t[M>>2]=(t[M>>2]|0)+4,n=ft(e,ye,n)|0,ni(ye)}while(0);return y=Ze,n|0}function Qn(e){e=e|0;var n=0;do{if(n=e+984|0,h[n>>0]|0)break;h[n>>0]=1,x[e+504>>2]=S(ue),e=t[e+944>>2]|0}while((e|0)!=0)}function ac(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-4-u|0)>>>2)<<2)),Et(r))}function si(e){return e=e|0,t[e+944>>2]|0}function Jr(e){e=e|0,Hu(e,(t[e+964>>2]|0)!=0,2832),Qn(e)}function Zl(e){return e=e|0,(h[e+984>>0]|0)!=0|0}function oa(e,n){e=e|0,n=n|0,vL(e,n,400)|0&&(gr(e|0,n|0,400)|0,Qn(e))}function pf(e){e=e|0;var n=Ct;return n=S(x[e+44>>2]),e=Le(n)|0,S(e?S(0):n)}function bs(e){e=e|0;var n=Ct;return n=S(x[e+48>>2]),Le(n)|0&&(n=h[(t[e+976>>2]|0)+2>>0]|0?S(1):S(0)),S(n)}function ba(e,n){e=e|0,n=n|0,t[e+980>>2]=n}function Bs(e){return e=e|0,t[e+980>>2]|0}function m0(e,n){e=e|0,n=n|0;var r=0;r=e+4|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function Us(e){return e=e|0,t[e+4>>2]|0}function zi(e,n){e=e|0,n=n|0;var r=0;r=e+8|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function U(e){return e=e|0,t[e+8>>2]|0}function H(e,n){e=e|0,n=n|0;var r=0;r=e+12|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function Y(e){return e=e|0,t[e+12>>2]|0}function ee(e,n){e=e|0,n=n|0;var r=0;r=e+16|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function Ce(e){return e=e|0,t[e+16>>2]|0}function _e(e,n){e=e|0,n=n|0;var r=0;r=e+20|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function Oe(e){return e=e|0,t[e+20>>2]|0}function $(e,n){e=e|0,n=n|0;var r=0;r=e+24|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function Ne(e){return e=e|0,t[e+24>>2]|0}function Je(e,n){e=e|0,n=n|0;var r=0;r=e+28|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function vt(e){return e=e|0,t[e+28>>2]|0}function oe(e,n){e=e|0,n=n|0;var r=0;r=e+32|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function qe(e){return e=e|0,t[e+32>>2]|0}function rt(e,n){e=e|0,n=n|0;var r=0;r=e+36|0,(t[r>>2]|0)!=(n|0)&&(t[r>>2]=n,Qn(e))}function xt(e){return e=e|0,t[e+36>>2]|0}function kt(e,n){e=e|0,n=S(n);var r=0;r=e+40|0,S(x[r>>2])!=n&&(x[r>>2]=n,Qn(e))}function bt(e,n){e=e|0,n=S(n);var r=0;r=e+44|0,S(x[r>>2])!=n&&(x[r>>2]=n,Qn(e))}function sn(e,n){e=e|0,n=S(n);var r=0;r=e+48|0,S(x[r>>2])!=n&&(x[r>>2]=n,Qn(e))}function rn(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+52|0,s=e+56|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function Ft(e,n){e=e|0,n=S(n);var r=0,u=0;u=e+52|0,r=e+56|0,S(x[u>>2])==n&&(t[r>>2]|0)==2||(x[u>>2]=n,u=Le(n)|0,t[r>>2]=u?3:2,Qn(e))}function Dn(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+52|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function dr(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=(a^1)&1,s=e+132+(n<<3)|0,n=e+132+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function er(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=a?0:2,s=e+132+(n<<3)|0,n=e+132+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function Cr(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=n+132+(r<<3)|0,n=t[u+4>>2]|0,r=e,t[r>>2]=t[u>>2],t[r+4>>2]=n}function Rn(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=(a^1)&1,s=e+60+(n<<3)|0,n=e+60+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function Nr(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=a?0:2,s=e+60+(n<<3)|0,n=e+60+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function y0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=n+60+(r<<3)|0,n=t[u+4>>2]|0,r=e,t[r>>2]=t[u>>2],t[r+4>>2]=n}function Lr(e,n){e=e|0,n=n|0;var r=0;r=e+60+(n<<3)+4|0,(t[r>>2]|0)!=3&&(x[e+60+(n<<3)>>2]=S(ue),t[r>>2]=3,Qn(e))}function ut(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=(a^1)&1,s=e+204+(n<<3)|0,n=e+204+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function wt(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=a?0:2,s=e+204+(n<<3)|0,n=e+204+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function et(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=n+204+(r<<3)|0,n=t[u+4>>2]|0,r=e,t[r>>2]=t[u>>2],t[r+4>>2]=n}function It(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0,a=0;a=Le(r)|0,u=(a^1)&1,s=e+276+(n<<3)|0,n=e+276+(n<<3)+4|0,a|S(x[s>>2])==r&&(t[n>>2]|0)==(u|0)||(x[s>>2]=r,t[n>>2]=u,Qn(e))}function un(e,n){return e=e|0,n=n|0,S(x[e+276+(n<<3)>>2])}function fn(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+348|0,s=e+352|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function Jn(e,n){e=e|0,n=S(n);var r=0,u=0;u=e+348|0,r=e+352|0,S(x[u>>2])==n&&(t[r>>2]|0)==2||(x[u>>2]=n,u=Le(n)|0,t[r>>2]=u?3:2,Qn(e))}function wr(e){e=e|0;var n=0;n=e+352|0,(t[n>>2]|0)!=3&&(x[e+348>>2]=S(ue),t[n>>2]=3,Qn(e))}function au(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+348|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function ku(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+356|0,s=e+360|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function T0(e,n){e=e|0,n=S(n);var r=0,u=0;u=e+356|0,r=e+360|0,S(x[u>>2])==n&&(t[r>>2]|0)==2||(x[u>>2]=n,u=Le(n)|0,t[r>>2]=u?3:2,Qn(e))}function Z0(e){e=e|0;var n=0;n=e+360|0,(t[n>>2]|0)!=3&&(x[e+356>>2]=S(ue),t[n>>2]=3,Qn(e))}function Nu(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+356|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function gi(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+364|0,s=e+368|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function Po(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=a?0:2,u=e+364|0,s=e+368|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function rl(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+364|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function hf(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+372|0,s=e+376|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function Tl(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=a?0:2,u=e+372|0,s=e+376|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function vf(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+372|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function Io(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+380|0,s=e+384|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function ys(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=a?0:2,u=e+380|0,s=e+384|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function js(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+380|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function bo(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=(a^1)&1,u=e+388|0,s=e+392|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function Bo(e,n){e=e|0,n=S(n);var r=0,u=0,s=0,a=0;a=Le(n)|0,r=a?0:2,u=e+388|0,s=e+392|0,a|S(x[u>>2])==n&&(t[s>>2]|0)==(r|0)||(x[u>>2]=n,t[s>>2]=r,Qn(e))}function gs(e,n){e=e|0,n=n|0;var r=0,u=0;u=n+388|0,r=t[u+4>>2]|0,n=e,t[n>>2]=t[u>>2],t[n+4>>2]=r}function Xu(e,n){e=e|0,n=S(n);var r=0;r=e+396|0,S(x[r>>2])!=n&&(x[r>>2]=n,Qn(e))}function Su(e){return e=e|0,S(x[e+396>>2])}function _i(e){return e=e|0,S(x[e+400>>2])}function C0(e){return e=e|0,S(x[e+404>>2])}function $0(e){return e=e|0,S(x[e+408>>2])}function Uo(e){return e=e|0,S(x[e+412>>2])}function la(e){return e=e|0,S(x[e+416>>2])}function $l(e){return e=e|0,S(x[e+420>>2])}function tu(e,n){switch(e=e|0,n=n|0,Hu(e,(n|0)<6,2918),n|0){case 0:{n=(t[e+496>>2]|0)==2?5:4;break}case 2:{n=(t[e+496>>2]|0)==2?4:5;break}default:}return S(x[e+424+(n<<2)>>2])}function Zr(e,n){switch(e=e|0,n=n|0,Hu(e,(n|0)<6,2918),n|0){case 0:{n=(t[e+496>>2]|0)==2?5:4;break}case 2:{n=(t[e+496>>2]|0)==2?4:5;break}default:}return S(x[e+448+(n<<2)>>2])}function ho(e,n){switch(e=e|0,n=n|0,Hu(e,(n|0)<6,2918),n|0){case 0:{n=(t[e+496>>2]|0)==2?5:4;break}case 2:{n=(t[e+496>>2]|0)==2?4:5;break}default:}return S(x[e+472+(n<<2)>>2])}function Bi(e,n){e=e|0,n=n|0;var r=0,u=Ct;return r=t[e+4>>2]|0,(r|0)==(t[n+4>>2]|0)?r?(u=S(x[e>>2]),e=S(Pt(S(u-S(x[n>>2]))))<S(999999974e-13)):e=1:e=0,e|0}function Ci(e,n){e=S(e),n=S(n);var r=0;return Le(e)|0?r=Le(n)|0:r=S(Pt(S(e-n)))<S(999999974e-13),r|0}function mf(e,n){e=e|0,n=n|0,yf(e,n)}function yf(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r+4|0,t[u>>2]=0,t[u+4>>2]=0,t[u+8>>2]=0,Q0(u|0,e|0,n|0,0),pr(e,3,(h[u+11>>0]|0)<0?t[u>>2]|0:u,r),BL(u),y=r}function eo(e,n,r,u){e=S(e),n=S(n),r=r|0,u=u|0;var s=Ct;e=S(e*n),s=S(NE(e,S(1)));do if(Ci(s,S(0))|0)e=S(e-s);else{if(e=S(e-s),Ci(s,S(1))|0){e=S(e+S(1));break}if(r){e=S(e+S(1));break}u||(s>S(.5)?s=S(1):(u=Ci(s,S(.5))|0,s=S(u?1:0)),e=S(e+s))}while(0);return S(e/n)}function to(e,n,r,u,s,a,v,w,T,L,M,b,X){e=e|0,n=S(n),r=r|0,u=S(u),s=s|0,a=S(a),v=v|0,w=S(w),T=S(T),L=S(L),M=S(M),b=S(b),X=X|0;var Be=0,Te=Ct,ye=Ct,Ze=Ct,Ye=Ct,ct=Ct,ke=Ct;return T<S(0)|L<S(0)?X=0:((X|0)!=0&&(Te=S(x[X+4>>2]),Te!=S(0))?(Ze=S(eo(n,Te,0,0)),Ye=S(eo(u,Te,0,0)),ye=S(eo(a,Te,0,0)),Te=S(eo(w,Te,0,0))):(ye=a,Ze=n,Te=w,Ye=u),(s|0)==(e|0)?Be=Ci(ye,Ze)|0:Be=0,(v|0)==(r|0)?X=Ci(Te,Ye)|0:X=0,!Be&&(ct=S(n-M),!(xe(e,ct,T)|0))&&!(tt(e,ct,s,T)|0)?Be=Ke(e,ct,s,a,T)|0:Be=1,!X&&(ke=S(u-b),!(xe(r,ke,L)|0))&&!(tt(r,ke,v,L)|0)?X=Ke(r,ke,v,w,L)|0:X=1,X=Be&X),X|0}function xe(e,n,r){return e=e|0,n=S(n),r=S(r),(e|0)==1?e=Ci(n,r)|0:e=0,e|0}function tt(e,n,r,u){return e=e|0,n=S(n),r=r|0,u=S(u),(e|0)==2&(r|0)==0?n>=u?e=1:e=Ci(n,u)|0:e=0,e|0}function Ke(e,n,r,u,s){return e=e|0,n=S(n),r=r|0,u=S(u),s=S(s),(e|0)==2&(r|0)==2&u>n?s<=n?e=1:e=Ci(n,s)|0:e=0,e|0}function Yt(e,n,r,u,s,a,v,w,T,L,M){e=e|0,n=S(n),r=S(r),u=u|0,s=s|0,a=a|0,v=S(v),w=S(w),T=T|0,L=L|0,M=M|0;var b=0,X=0,Be=0,Te=0,ye=Ct,Ze=Ct,Ye=0,ct=0,ke=0,Ie=0,Zt=0,Br=0,Pn=0,gn=0,_r=0,Pr=0,kn=0,uu=Ct,os=Ct,ls=Ct,ss=0,ea=0;kn=y,y=y+160|0,gn=kn+152|0,Pn=kn+120|0,Br=kn+104|0,ke=kn+72|0,Te=kn+56|0,Zt=kn+8|0,ct=kn,Ie=(t[2279]|0)+1|0,t[2279]=Ie,_r=e+984|0,(h[_r>>0]|0)!=0&&(t[e+512>>2]|0)!=(t[2278]|0)?Ye=4:(t[e+516>>2]|0)==(u|0)?Pr=0:Ye=4,(Ye|0)==4&&(t[e+520>>2]=0,t[e+924>>2]=-1,t[e+928>>2]=-1,x[e+932>>2]=S(-1),x[e+936>>2]=S(-1),Pr=1);e:do if(t[e+964>>2]|0)if(ye=S(Kt(e,2,v)),Ze=S(Kt(e,0,v)),b=e+916|0,ls=S(x[b>>2]),os=S(x[e+920>>2]),uu=S(x[e+932>>2]),to(s,n,a,r,t[e+924>>2]|0,ls,t[e+928>>2]|0,os,uu,S(x[e+936>>2]),ye,Ze,M)|0)Ye=22;else if(Be=t[e+520>>2]|0,!Be)Ye=21;else for(X=0;;){if(b=e+524+(X*24|0)|0,uu=S(x[b>>2]),os=S(x[e+524+(X*24|0)+4>>2]),ls=S(x[e+524+(X*24|0)+16>>2]),to(s,n,a,r,t[e+524+(X*24|0)+8>>2]|0,uu,t[e+524+(X*24|0)+12>>2]|0,os,ls,S(x[e+524+(X*24|0)+20>>2]),ye,Ze,M)|0){Ye=22;break e}if(X=X+1|0,X>>>0>=Be>>>0){Ye=21;break}}else{if(T){if(b=e+916|0,!(Ci(S(x[b>>2]),n)|0)){Ye=21;break}if(!(Ci(S(x[e+920>>2]),r)|0)){Ye=21;break}if((t[e+924>>2]|0)!=(s|0)){Ye=21;break}b=(t[e+928>>2]|0)==(a|0)?b:0,Ye=22;break}if(Be=t[e+520>>2]|0,!Be)Ye=21;else for(X=0;;){if(b=e+524+(X*24|0)|0,Ci(S(x[b>>2]),n)|0&&Ci(S(x[e+524+(X*24|0)+4>>2]),r)|0&&(t[e+524+(X*24|0)+8>>2]|0)==(s|0)&&(t[e+524+(X*24|0)+12>>2]|0)==(a|0)){Ye=22;break e}if(X=X+1|0,X>>>0>=Be>>>0){Ye=21;break}}}while(0);do if((Ye|0)==21)h[11697]|0?(b=0,Ye=28):(b=0,Ye=31);else if((Ye|0)==22){if(X=(h[11697]|0)!=0,!((b|0)!=0&(Pr^1)))if(X){Ye=28;break}else{Ye=31;break}Te=b+16|0,t[e+908>>2]=t[Te>>2],Be=b+20|0,t[e+912>>2]=t[Be>>2],(h[11698]|0)==0|X^1||(t[ct>>2]=Ei(Ie)|0,t[ct+4>>2]=Ie,pr(e,4,2972,ct),X=t[e+972>>2]|0,X|0&&P1[X&127](e),s=bn(s,T)|0,a=bn(a,T)|0,ea=+S(x[Te>>2]),ss=+S(x[Be>>2]),t[Zt>>2]=s,t[Zt+4>>2]=a,j[Zt+8>>3]=+n,j[Zt+16>>3]=+r,j[Zt+24>>3]=ea,j[Zt+32>>3]=ss,t[Zt+40>>2]=L,pr(e,4,2989,Zt))}while(0);return(Ye|0)==28&&(X=Ei(Ie)|0,t[Te>>2]=X,t[Te+4>>2]=Ie,t[Te+8>>2]=Pr?3047:11699,pr(e,4,3038,Te),X=t[e+972>>2]|0,X|0&&P1[X&127](e),Zt=bn(s,T)|0,Ye=bn(a,T)|0,t[ke>>2]=Zt,t[ke+4>>2]=Ye,j[ke+8>>3]=+n,j[ke+16>>3]=+r,t[ke+24>>2]=L,pr(e,4,3049,ke),Ye=31),(Ye|0)==31&&(mu(e,n,r,u,s,a,v,w,T,M),h[11697]|0&&(X=t[2279]|0,Zt=Ei(X)|0,t[Br>>2]=Zt,t[Br+4>>2]=X,t[Br+8>>2]=Pr?3047:11699,pr(e,4,3083,Br),X=t[e+972>>2]|0,X|0&&P1[X&127](e),Zt=bn(s,T)|0,Br=bn(a,T)|0,ss=+S(x[e+908>>2]),ea=+S(x[e+912>>2]),t[Pn>>2]=Zt,t[Pn+4>>2]=Br,j[Pn+8>>3]=ss,j[Pn+16>>3]=ea,t[Pn+24>>2]=L,pr(e,4,3092,Pn)),t[e+516>>2]=u,b||(X=e+520|0,b=t[X>>2]|0,(b|0)==16&&(h[11697]|0&&pr(e,4,3124,gn),t[X>>2]=0,b=0),T?b=e+916|0:(t[X>>2]=b+1,b=e+524+(b*24|0)|0),x[b>>2]=n,x[b+4>>2]=r,t[b+8>>2]=s,t[b+12>>2]=a,t[b+16>>2]=t[e+908>>2],t[b+20>>2]=t[e+912>>2],b=0)),T&&(t[e+416>>2]=t[e+908>>2],t[e+420>>2]=t[e+912>>2],h[e+985>>0]=1,h[_r>>0]=0),t[2279]=(t[2279]|0)+-1,t[e+512>>2]=t[2278],y=kn,Pr|(b|0)==0|0}function Kt(e,n,r){e=e|0,n=n|0,r=S(r);var u=Ct;return u=S(Hi(e,n,r)),S(u+S(A0(e,n,r)))}function pr(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=y,y=y+16|0,s=a,t[s>>2]=u,e?u=t[e+976>>2]|0:u=0,zs(u,e,n,r,s),y=a}function Ei(e){return e=e|0,(e>>>0>60?3201:3201+(60-e)|0)|0}function bn(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;return s=y,y=y+32|0,r=s+12|0,u=s,t[r>>2]=t[254],t[r+4>>2]=t[255],t[r+8>>2]=t[256],t[u>>2]=t[257],t[u+4>>2]=t[258],t[u+8>>2]=t[259],(e|0)>2?e=11699:e=t[(n?u:r)+(e<<2)>>2]|0,y=s,e|0}function mu(e,n,r,u,s,a,v,w,T,L){e=e|0,n=S(n),r=S(r),u=u|0,s=s|0,a=a|0,v=S(v),w=S(w),T=T|0,L=L|0;var M=0,b=0,X=0,Be=0,Te=Ct,ye=Ct,Ze=Ct,Ye=Ct,ct=Ct,ke=Ct,Ie=Ct,Zt=0,Br=0,Pn=0,gn=Ct,_r=Ct,Pr=0,kn=Ct,uu=0,os=0,ls=0,ss=0,ea=0,t2=0,n2=0,uf=0,r2=0,Fc=0,Pc=0,i2=0,u2=0,o2=0,pi=0,of=0,l2=0,Yf=0,s2=Ct,a2=Ct,Ic=Ct,bc=Ct,Kf=Ct,ql=0,La=0,Ns=0,lf=0,b1=0,B1=Ct,Bc=Ct,U1=Ct,j1=Ct,Wl=Ct,El=Ct,sf=0,hu=Ct,z1=Ct,as=Ct,Xf=Ct,fs=Ct,Qf=Ct,H1=0,q1=0,Jf=Ct,Vl=Ct,af=0,W1=0,V1=0,G1=0,Sr=Ct,bu=0,Dl=0,cs=0,Gl=0,Or=0,Bn=0,ff=0,mn=Ct,Y1=0,a0=0;ff=y,y=y+16|0,ql=ff+12|0,La=ff+8|0,Ns=ff+4|0,lf=ff,Hu(e,(s|0)==0|(Le(n)|0)^1,3326),Hu(e,(a|0)==0|(Le(r)|0)^1,3406),Dl=xl(e,u)|0,t[e+496>>2]=Dl,Or=B0(2,Dl)|0,Bn=B0(0,Dl)|0,x[e+440>>2]=S(Hi(e,Or,v)),x[e+444>>2]=S(A0(e,Or,v)),x[e+428>>2]=S(Hi(e,Bn,v)),x[e+436>>2]=S(A0(e,Bn,v)),x[e+464>>2]=S(O0(e,Or)),x[e+468>>2]=S(vo(e,Or)),x[e+452>>2]=S(O0(e,Bn)),x[e+460>>2]=S(vo(e,Bn)),x[e+488>>2]=S(Fu(e,Or,v)),x[e+492>>2]=S(Ju(e,Or,v)),x[e+476>>2]=S(Fu(e,Bn,v)),x[e+484>>2]=S(Ju(e,Bn,v));do if(t[e+964>>2]|0)es(e,n,r,s,a,v,w);else{if(cs=e+948|0,Gl=(t[e+952>>2]|0)-(t[cs>>2]|0)>>2,!Gl){_s(e,n,r,s,a,v,w);break}if(!T&&aa(e,n,r,s,a,v,w)|0)break;ms(e),of=e+508|0,h[of>>0]=0,Or=B0(t[e+4>>2]|0,Dl)|0,Bn=gf(Or,Dl)|0,bu=qi(Or)|0,l2=t[e+8>>2]|0,W1=e+28|0,Yf=(t[W1>>2]|0)!=0,fs=bu?v:w,Jf=bu?w:v,s2=S(Zu(e,Or,v)),a2=S(Es(e,Or,v)),Te=S(Zu(e,Bn,v)),Qf=S(Rr(e,Or,v)),Vl=S(Rr(e,Bn,v)),Pn=bu?s:a,af=bu?a:s,Sr=bu?Qf:Vl,ct=bu?Vl:Qf,Xf=S(Kt(e,2,v)),Ye=S(Kt(e,0,v)),ye=S(S(xn(e+364|0,v))-Sr),Ze=S(S(xn(e+380|0,v))-Sr),ke=S(S(xn(e+372|0,w))-ct),Ie=S(S(xn(e+388|0,w))-ct),Ic=bu?ye:ke,bc=bu?Ze:Ie,Xf=S(n-Xf),n=S(Xf-Sr),Le(n)|0?Sr=n:Sr=S(xu(S(Kp(n,Ze)),ye)),z1=S(r-Ye),n=S(z1-ct),Le(n)|0?as=n:as=S(xu(S(Kp(n,Ie)),ke)),ye=bu?Sr:as,hu=bu?as:Sr;e:do if((Pn|0)==1)for(u=0,b=0;;){if(M=Ti(e,b)|0,!u)S(nu(M))>S(0)&&S(fu(M))>S(0)?u=M:u=0;else if(no(M)|0){Be=0;break e}if(b=b+1|0,b>>>0>=Gl>>>0){Be=u;break}}else Be=0;while(0);Zt=Be+500|0,Br=Be+504|0,u=0,M=0,n=S(0),X=0;do{if(b=t[(t[cs>>2]|0)+(X<<2)>>2]|0,(t[b+36>>2]|0)==1)Li(b),h[b+985>>0]=1,h[b+984>>0]=0;else{Qr(b),T&&x0(b,xl(b,Dl)|0,ye,hu,Sr);do if((t[b+24>>2]|0)!=1)if((b|0)==(Be|0)){t[Zt>>2]=t[2278],x[Br>>2]=S(0);break}else{ei(e,b,Sr,s,as,Sr,as,a,Dl,L);break}else M|0&&(t[M+960>>2]=b),t[b+960>>2]=0,M=b,u=(u|0)==0?b:u;while(0);El=S(x[b+504>>2]),n=S(n+S(El+S(Kt(b,Or,Sr))))}X=X+1|0}while((X|0)!=(Gl|0));for(ls=n>ye,sf=Yf&((Pn|0)==2&ls)?1:Pn,uu=(af|0)==1,ea=uu&(T^1),t2=(sf|0)==1,n2=(sf|0)==2,uf=976+(Or<<2)|0,r2=(af|2|0)==2,o2=uu&(Yf^1),Fc=1040+(Bn<<2)|0,Pc=1040+(Or<<2)|0,i2=976+(Bn<<2)|0,u2=(af|0)!=1,ls=Yf&((Pn|0)!=0&ls),os=e+976|0,uu=uu^1,n=ye,Pr=0,ss=0,El=S(0),Kf=S(0);;){e:do if(Pr>>>0<Gl>>>0)for(Br=t[cs>>2]|0,X=0,Ie=S(0),ke=S(0),Ze=S(0),ye=S(0),b=0,M=0,Be=Pr;;){if(Zt=t[Br+(Be<<2)>>2]|0,(t[Zt+36>>2]|0)!=1&&(t[Zt+940>>2]=ss,(t[Zt+24>>2]|0)!=1)){if(Ye=S(Kt(Zt,Or,Sr)),pi=t[uf>>2]|0,r=S(xn(Zt+380+(pi<<3)|0,fs)),ct=S(x[Zt+504>>2]),r=S(Kp(r,ct)),r=S(xu(S(xn(Zt+364+(pi<<3)|0,fs)),r)),Yf&(X|0)!=0&S(Ye+S(ke+r))>n){a=X,Ye=Ie,Pn=Be;break e}Ye=S(Ye+r),r=S(ke+Ye),Ye=S(Ie+Ye),no(Zt)|0&&(Ze=S(Ze+S(nu(Zt))),ye=S(ye-S(ct*S(fu(Zt))))),M|0&&(t[M+960>>2]=Zt),t[Zt+960>>2]=0,X=X+1|0,M=Zt,b=(b|0)==0?Zt:b}else Ye=Ie,r=ke;if(Be=Be+1|0,Be>>>0<Gl>>>0)Ie=Ye,ke=r;else{a=X,Pn=Be;break}}else a=0,Ye=S(0),Ze=S(0),ye=S(0),b=0,Pn=Pr;while(0);pi=Ze>S(0)&Ze<S(1),gn=pi?S(1):Ze,pi=ye>S(0)&ye<S(1),Ie=pi?S(1):ye;do if(t2)pi=51;else if(Ye<Ic&((Le(Ic)|0)^1))n=Ic,pi=51;else if(Ye>bc&((Le(bc)|0)^1))n=bc,pi=51;else if(h[(t[os>>2]|0)+3>>0]|0)pi=51;else{if(gn!=S(0)&&S(nu(e))!=S(0)){pi=53;break}n=Ye,pi=53}while(0);if((pi|0)==51&&(pi=0,Le(n)|0?pi=53:(_r=S(n-Ye),kn=n)),(pi|0)==53&&(pi=0,Ye<S(0)?(_r=S(-Ye),kn=n):(_r=S(0),kn=n)),!ea&&(b1=(b|0)==0,!b1)){X=t[uf>>2]|0,Be=_r<S(0),ct=S(_r/Ie),Zt=_r>S(0),ke=S(_r/gn),Ze=S(0),Ye=S(0),n=S(0),M=b;do r=S(xn(M+380+(X<<3)|0,fs)),ye=S(xn(M+364+(X<<3)|0,fs)),ye=S(Kp(r,S(xu(ye,S(x[M+504>>2]))))),Be?(r=S(ye*S(fu(M))),r!=S(-0)&&(mn=S(ye-S(ct*r)),B1=S(Kn(M,Or,mn,kn,Sr)),mn!=B1)&&(Ze=S(Ze-S(B1-ye)),n=S(n+r))):Zt&&(Bc=S(nu(M)),Bc!=S(0))&&(mn=S(ye+S(ke*Bc)),U1=S(Kn(M,Or,mn,kn,Sr)),mn!=U1)&&(Ze=S(Ze-S(U1-ye)),Ye=S(Ye-Bc)),M=t[M+960>>2]|0;while((M|0)!=0);if(n=S(Ie+n),ye=S(_r+Ze),b1)n=S(0);else{ct=S(gn+Ye),Be=t[uf>>2]|0,Zt=ye<S(0),Br=n==S(0),ke=S(ye/n),X=ye>S(0),ct=S(ye/ct),n=S(0);do{mn=S(xn(b+380+(Be<<3)|0,fs)),Ze=S(xn(b+364+(Be<<3)|0,fs)),Ze=S(Kp(mn,S(xu(Ze,S(x[b+504>>2]))))),Zt?(mn=S(Ze*S(fu(b))),ye=S(-mn),mn!=S(-0)?(mn=S(ke*ye),ye=S(Kn(b,Or,S(Ze+(Br?ye:mn)),kn,Sr))):ye=Ze):X&&(j1=S(nu(b)),j1!=S(0))?ye=S(Kn(b,Or,S(Ze+S(ct*j1)),kn,Sr)):ye=Ze,n=S(n-S(ye-Ze)),Ye=S(Kt(b,Or,Sr)),r=S(Kt(b,Bn,Sr)),ye=S(ye+Ye),x[La>>2]=ye,t[lf>>2]=1,Ze=S(x[b+396>>2]);e:do if(Le(Ze)|0){M=Le(hu)|0;do if(!M){if(ls|(qu(b,Bn,hu)|0|uu)||($u(e,b)|0)!=4||(t[(g0(b,Bn)|0)+4>>2]|0)==3||(t[(_0(b,Bn)|0)+4>>2]|0)==3)break;x[ql>>2]=hu,t[Ns>>2]=1;break e}while(0);if(qu(b,Bn,hu)|0){M=t[b+992+(t[i2>>2]<<2)>>2]|0,mn=S(r+S(xn(M,hu))),x[ql>>2]=mn,M=u2&(t[M+4>>2]|0)==2,t[Ns>>2]=((Le(mn)|0|M)^1)&1;break}else{x[ql>>2]=hu,t[Ns>>2]=M?0:2;break}}else mn=S(ye-Ye),gn=S(mn/Ze),mn=S(Ze*mn),t[Ns>>2]=1,x[ql>>2]=S(r+(bu?gn:mn));while(0);Ln(b,Or,kn,Sr,lf,La),Ln(b,Bn,hu,Sr,Ns,ql);do if(!(qu(b,Bn,hu)|0)&&($u(e,b)|0)==4){if((t[(g0(b,Bn)|0)+4>>2]|0)==3){M=0;break}M=(t[(_0(b,Bn)|0)+4>>2]|0)!=3}else M=0;while(0);mn=S(x[La>>2]),gn=S(x[ql>>2]),Y1=t[lf>>2]|0,a0=t[Ns>>2]|0,Yt(b,bu?mn:gn,bu?gn:mn,Dl,bu?Y1:a0,bu?a0:Y1,Sr,as,T&(M^1),3488,L)|0,h[of>>0]=h[of>>0]|h[b+508>>0],b=t[b+960>>2]|0}while((b|0)!=0)}}else n=S(0);if(n=S(_r+n),a0=n<S(0)&1,h[of>>0]=a0|N[of>>0],n2&n>S(0)?(M=t[uf>>2]|0,(t[e+364+(M<<3)+4>>2]|0)!=0&&(Wl=S(xn(e+364+(M<<3)|0,fs)),Wl>=S(0))?ye=S(xu(S(0),S(Wl-S(kn-n)))):ye=S(0)):ye=n,Zt=Pr>>>0<Pn>>>0,Zt){Be=t[cs>>2]|0,X=Pr,M=0;do b=t[Be+(X<<2)>>2]|0,t[b+24>>2]|0||(M=((t[(g0(b,Or)|0)+4>>2]|0)==3&1)+M|0,M=M+((t[(_0(b,Or)|0)+4>>2]|0)==3&1)|0),X=X+1|0;while((X|0)!=(Pn|0));M?(Ye=S(0),r=S(0)):pi=101}else pi=101;e:do if((pi|0)==101)switch(pi=0,l2|0){case 1:{M=0,Ye=S(ye*S(.5)),r=S(0);break e}case 2:{M=0,Ye=ye,r=S(0);break e}case 3:{if(a>>>0<=1){M=0,Ye=S(0),r=S(0);break e}r=S((a+-1|0)>>>0),M=0,Ye=S(0),r=S(S(xu(ye,S(0)))/r);break e}case 5:{r=S(ye/S((a+1|0)>>>0)),M=0,Ye=r;break e}case 4:{r=S(ye/S(a>>>0)),M=0,Ye=S(r*S(.5));break e}default:{M=0,Ye=S(0),r=S(0);break e}}while(0);if(n=S(s2+Ye),Zt){Ze=S(ye/S(M|0)),X=t[cs>>2]|0,b=Pr,ye=S(0);do{M=t[X+(b<<2)>>2]|0;e:do if((t[M+36>>2]|0)!=1){switch(t[M+24>>2]|0){case 1:{if(fe(M,Or)|0){if(!T)break e;mn=S(ie(M,Or,kn)),mn=S(mn+S(O0(e,Or))),mn=S(mn+S(Hi(M,Or,Sr))),x[M+400+(t[Pc>>2]<<2)>>2]=mn;break e}break}case 0:if(a0=(t[(g0(M,Or)|0)+4>>2]|0)==3,mn=S(Ze+n),n=a0?mn:n,T&&(a0=M+400+(t[Pc>>2]<<2)|0,x[a0>>2]=S(n+S(x[a0>>2]))),a0=(t[(_0(M,Or)|0)+4>>2]|0)==3,mn=S(Ze+n),n=a0?mn:n,ea){mn=S(r+S(Kt(M,Or,Sr))),ye=hu,n=S(n+S(mn+S(x[M+504>>2])));break e}else{n=S(n+S(r+S(Pe(M,Or,Sr)))),ye=S(xu(ye,S(Pe(M,Bn,Sr))));break e}default:}T&&(mn=S(Ye+S(O0(e,Or))),a0=M+400+(t[Pc>>2]<<2)|0,x[a0>>2]=S(mn+S(x[a0>>2])))}while(0);b=b+1|0}while((b|0)!=(Pn|0))}else ye=S(0);if(r=S(a2+n),r2?Ye=S(S(Kn(e,Bn,S(Vl+ye),Jf,v))-Vl):Ye=hu,Ze=S(S(Kn(e,Bn,S(Vl+(o2?hu:ye)),Jf,v))-Vl),Zt&T){b=Pr;do{X=t[(t[cs>>2]|0)+(b<<2)>>2]|0;do if((t[X+36>>2]|0)!=1){if((t[X+24>>2]|0)==1){if(fe(X,Bn)|0){if(mn=S(ie(X,Bn,hu)),mn=S(mn+S(O0(e,Bn))),mn=S(mn+S(Hi(X,Bn,Sr))),M=t[Fc>>2]|0,x[X+400+(M<<2)>>2]=mn,!(Le(mn)|0))break}else M=t[Fc>>2]|0;mn=S(O0(e,Bn)),x[X+400+(M<<2)>>2]=S(mn+S(Hi(X,Bn,Sr)));break}M=$u(e,X)|0;do if((M|0)==4){if((t[(g0(X,Bn)|0)+4>>2]|0)==3){pi=139;break}if((t[(_0(X,Bn)|0)+4>>2]|0)==3){pi=139;break}if(qu(X,Bn,hu)|0){n=Te;break}Y1=t[X+908+(t[uf>>2]<<2)>>2]|0,t[ql>>2]=Y1,n=S(x[X+396>>2]),a0=Le(n)|0,ye=(t[V>>2]=Y1,S(x[V>>2])),a0?n=Ze:(_r=S(Kt(X,Bn,Sr)),mn=S(ye/n),n=S(n*ye),n=S(_r+(bu?mn:n))),x[La>>2]=n,x[ql>>2]=S(S(Kt(X,Or,Sr))+ye),t[Ns>>2]=1,t[lf>>2]=1,Ln(X,Or,kn,Sr,Ns,ql),Ln(X,Bn,hu,Sr,lf,La),n=S(x[ql>>2]),_r=S(x[La>>2]),mn=bu?n:_r,n=bu?_r:n,a0=((Le(mn)|0)^1)&1,Yt(X,mn,n,Dl,a0,((Le(n)|0)^1)&1,Sr,as,1,3493,L)|0,n=Te}else pi=139;while(0);e:do if((pi|0)==139){pi=0,n=S(Ye-S(Pe(X,Bn,Sr)));do if((t[(g0(X,Bn)|0)+4>>2]|0)==3){if((t[(_0(X,Bn)|0)+4>>2]|0)!=3)break;n=S(Te+S(xu(S(0),S(n*S(.5)))));break e}while(0);if((t[(_0(X,Bn)|0)+4>>2]|0)==3){n=Te;break}if((t[(g0(X,Bn)|0)+4>>2]|0)==3){n=S(Te+S(xu(S(0),n)));break}switch(M|0){case 1:{n=Te;break e}case 2:{n=S(Te+S(n*S(.5)));break e}default:{n=S(Te+n);break e}}}while(0);mn=S(El+n),a0=X+400+(t[Fc>>2]<<2)|0,x[a0>>2]=S(mn+S(x[a0>>2]))}while(0);b=b+1|0}while((b|0)!=(Pn|0))}if(El=S(El+Ze),Kf=S(xu(Kf,r)),a=ss+1|0,Pn>>>0>=Gl>>>0)break;n=kn,Pr=Pn,ss=a}do if(T){if(M=a>>>0>1,!M&&!(Me(e)|0))break;if(!(Le(hu)|0)){n=S(hu-El);e:do switch(t[e+12>>2]|0){case 3:{Te=S(Te+n),ke=S(0);break}case 2:{Te=S(Te+S(n*S(.5))),ke=S(0);break}case 4:{hu>El?ke=S(n/S(a>>>0)):ke=S(0);break}case 7:if(hu>El){Te=S(Te+S(n/S(a<<1>>>0))),ke=S(n/S(a>>>0)),ke=M?ke:S(0);break e}else{Te=S(Te+S(n*S(.5))),ke=S(0);break e}case 6:{ke=S(n/S(ss>>>0)),ke=hu>El&M?ke:S(0);break}default:ke=S(0)}while(0);if(a|0)for(Zt=1040+(Bn<<2)|0,Br=976+(Bn<<2)|0,Be=0,b=0;;){e:do if(b>>>0<Gl>>>0)for(ye=S(0),Ze=S(0),n=S(0),X=b;;){M=t[(t[cs>>2]|0)+(X<<2)>>2]|0;do if((t[M+36>>2]|0)!=1&&(t[M+24>>2]|0)==0){if((t[M+940>>2]|0)!=(Be|0))break e;if(at(M,Bn)|0&&(mn=S(x[M+908+(t[Br>>2]<<2)>>2]),n=S(xu(n,S(mn+S(Kt(M,Bn,Sr)))))),($u(e,M)|0)!=5)break;Wl=S(mt(M)),Wl=S(Wl+S(Hi(M,0,Sr))),mn=S(x[M+912>>2]),mn=S(S(mn+S(Kt(M,0,Sr)))-Wl),Wl=S(xu(Ze,Wl)),mn=S(xu(ye,mn)),ye=mn,Ze=Wl,n=S(xu(n,S(Wl+mn)))}while(0);if(M=X+1|0,M>>>0<Gl>>>0)X=M;else{X=M;break}}else Ze=S(0),n=S(0),X=b;while(0);if(ct=S(ke+n),r=Te,Te=S(Te+ct),b>>>0<X>>>0){Ye=S(r+Ze),M=b;do{b=t[(t[cs>>2]|0)+(M<<2)>>2]|0;e:do if((t[b+36>>2]|0)!=1&&(t[b+24>>2]|0)==0)switch($u(e,b)|0){case 1:{mn=S(r+S(Hi(b,Bn,Sr))),x[b+400+(t[Zt>>2]<<2)>>2]=mn;break e}case 3:{mn=S(S(Te-S(A0(b,Bn,Sr)))-S(x[b+908+(t[Br>>2]<<2)>>2])),x[b+400+(t[Zt>>2]<<2)>>2]=mn;break e}case 2:{mn=S(r+S(S(ct-S(x[b+908+(t[Br>>2]<<2)>>2]))*S(.5))),x[b+400+(t[Zt>>2]<<2)>>2]=mn;break e}case 4:{if(mn=S(r+S(Hi(b,Bn,Sr))),x[b+400+(t[Zt>>2]<<2)>>2]=mn,qu(b,Bn,hu)|0||(bu?(ye=S(x[b+908>>2]),n=S(ye+S(Kt(b,Or,Sr))),Ze=ct):(Ze=S(x[b+912>>2]),Ze=S(Ze+S(Kt(b,Bn,Sr))),n=ct,ye=S(x[b+908>>2])),Ci(n,ye)|0&&Ci(Ze,S(x[b+912>>2]))|0))break e;Yt(b,n,Ze,Dl,1,1,Sr,as,1,3501,L)|0;break e}case 5:{x[b+404>>2]=S(S(Ye-S(mt(b)))+S(ie(b,0,hu)));break e}default:break e}while(0);M=M+1|0}while((M|0)!=(X|0))}if(Be=Be+1|0,(Be|0)==(a|0))break;b=X}}}while(0);if(x[e+908>>2]=S(Kn(e,2,Xf,v,v)),x[e+912>>2]=S(Kn(e,0,z1,w,v)),(sf|0)!=0&&(H1=t[e+32>>2]|0,q1=(sf|0)==2,!(q1&(H1|0)!=2))?q1&(H1|0)==2&&(n=S(Qf+kn),n=S(xu(S(Kp(n,S(Qt(e,Or,Kf,fs)))),Qf)),pi=198):(n=S(Kn(e,Or,Kf,fs,v)),pi=198),(pi|0)==198&&(x[e+908+(t[976+(Or<<2)>>2]<<2)>>2]=n),(af|0)!=0&&(V1=t[e+32>>2]|0,G1=(af|0)==2,!(G1&(V1|0)!=2))?G1&(V1|0)==2&&(n=S(Vl+hu),n=S(xu(S(Kp(n,S(Qt(e,Bn,S(Vl+El),Jf)))),Vl)),pi=204):(n=S(Kn(e,Bn,S(Vl+El),Jf,v)),pi=204),(pi|0)==204&&(x[e+908+(t[976+(Bn<<2)>>2]<<2)>>2]=n),T){if((t[W1>>2]|0)==2){b=976+(Bn<<2)|0,X=1040+(Bn<<2)|0,M=0;do Be=Ti(e,M)|0,t[Be+24>>2]|0||(Y1=t[b>>2]|0,mn=S(x[e+908+(Y1<<2)>>2]),a0=Be+400+(t[X>>2]<<2)|0,mn=S(mn-S(x[a0>>2])),x[a0>>2]=S(mn-S(x[Be+908+(Y1<<2)>>2]))),M=M+1|0;while((M|0)!=(Gl|0))}if(u|0){M=bu?sf:s;do An(e,u,Sr,M,as,Dl,L),u=t[u+960>>2]|0;while((u|0)!=0)}if(M=(Or|2|0)==3,b=(Bn|2|0)==3,M|b){u=0;do X=t[(t[cs>>2]|0)+(u<<2)>>2]|0,(t[X+36>>2]|0)!=1&&(M&&Sn(e,X,Or),b&&Sn(e,X,Bn)),u=u+1|0;while((u|0)!=(Gl|0))}}}while(0);y=ff}function Qu(e,n){e=e|0,n=S(n);var r=0;Cn(e,n>=S(0),3147),r=n==S(0),x[e+4>>2]=r?S(0):n}function $r(e,n,r,u){e=e|0,n=S(n),r=S(r),u=u|0;var s=Ct,a=Ct,v=0,w=0,T=0;t[2278]=(t[2278]|0)+1,Qr(e),qu(e,2,n)|0?(s=S(xn(t[e+992>>2]|0,n)),T=1,s=S(s+S(Kt(e,2,n)))):(s=S(xn(e+380|0,n)),s>=S(0)?T=2:(T=((Le(n)|0)^1)&1,s=n)),qu(e,0,r)|0?(a=S(xn(t[e+996>>2]|0,r)),w=1,a=S(a+S(Kt(e,0,n)))):(a=S(xn(e+388|0,r)),a>=S(0)?w=2:(w=((Le(r)|0)^1)&1,a=r)),v=e+976|0,Yt(e,s,a,u,T,w,n,r,1,3189,t[v>>2]|0)|0&&(x0(e,t[e+496>>2]|0,n,r,n),Lu(e,S(x[(t[v>>2]|0)+4>>2]),S(0),S(0)),h[11696]|0)&&mf(e,7)}function Qr(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;w=y,y=y+32|0,v=w+24|0,a=w+16|0,u=w+8|0,s=w,r=0;do n=e+380+(r<<3)|0,(t[e+380+(r<<3)+4>>2]|0)!=0&&(T=n,L=t[T+4>>2]|0,M=u,t[M>>2]=t[T>>2],t[M+4>>2]=L,M=e+364+(r<<3)|0,L=t[M+4>>2]|0,T=s,t[T>>2]=t[M>>2],t[T+4>>2]=L,t[a>>2]=t[u>>2],t[a+4>>2]=t[u+4>>2],t[v>>2]=t[s>>2],t[v+4>>2]=t[s+4>>2],Bi(a,v)|0)||(n=e+348+(r<<3)|0),t[e+992+(r<<2)>>2]=n,r=r+1|0;while((r|0)!=2);y=w}function qu(e,n,r){e=e|0,n=n|0,r=S(r);var u=0;switch(e=t[e+992+(t[976+(n<<2)>>2]<<2)>>2]|0,t[e+4>>2]|0){case 0:case 3:{e=0;break}case 1:{S(x[e>>2])<S(0)?e=0:u=5;break}case 2:{S(x[e>>2])<S(0)?e=0:e=(Le(r)|0)^1;break}default:u=5}return(u|0)==5&&(e=1),e|0}function xn(e,n){switch(e=e|0,n=S(n),t[e+4>>2]|0){case 2:{n=S(S(S(x[e>>2])*n)/S(100));break}case 1:{n=S(x[e>>2]);break}default:n=S(ue)}return S(n)}function x0(e,n,r,u,s){e=e|0,n=n|0,r=S(r),u=S(u),s=S(s);var a=0,v=Ct;n=t[e+944>>2]|0?n:1,a=B0(t[e+4>>2]|0,n)|0,n=gf(a,n)|0,r=S(Ar(e,a,r)),u=S(Ar(e,n,u)),v=S(r+S(Hi(e,a,s))),x[e+400+(t[1040+(a<<2)>>2]<<2)>>2]=v,r=S(r+S(A0(e,a,s))),x[e+400+(t[1e3+(a<<2)>>2]<<2)>>2]=r,r=S(u+S(Hi(e,n,s))),x[e+400+(t[1040+(n<<2)>>2]<<2)>>2]=r,s=S(u+S(A0(e,n,s))),x[e+400+(t[1e3+(n<<2)>>2]<<2)>>2]=s}function Lu(e,n,r,u){e=e|0,n=S(n),r=S(r),u=S(u);var s=0,a=0,v=Ct,w=Ct,T=0,L=0,M=Ct,b=0,X=Ct,Be=Ct,Te=Ct,ye=Ct;if(n!=S(0)&&(s=e+400|0,ye=S(x[s>>2]),a=e+404|0,Te=S(x[a>>2]),b=e+416|0,Be=S(x[b>>2]),L=e+420|0,v=S(x[L>>2]),X=S(ye+r),M=S(Te+u),u=S(X+Be),w=S(M+v),T=(t[e+988>>2]|0)==1,x[s>>2]=S(eo(ye,n,0,T)),x[a>>2]=S(eo(Te,n,0,T)),r=S(NE(S(Be*n),S(1))),Ci(r,S(0))|0?a=0:a=(Ci(r,S(1))|0)^1,r=S(NE(S(v*n),S(1))),Ci(r,S(0))|0?s=0:s=(Ci(r,S(1))|0)^1,ye=S(eo(u,n,T&a,T&(a^1))),x[b>>2]=S(ye-S(eo(X,n,0,T))),ye=S(eo(w,n,T&s,T&(s^1))),x[L>>2]=S(ye-S(eo(M,n,0,T))),a=(t[e+952>>2]|0)-(t[e+948>>2]|0)>>2,a|0)){s=0;do Lu(Ti(e,s)|0,n,X,M),s=s+1|0;while((s|0)!=(a|0))}}function ui(e,n,r,u,s){switch(e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,r|0){case 5:case 0:{e=v8(t[489]|0,u,s)|0;break}default:e=FL(u,s)|0}return e|0}function Cl(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;s=y,y=y+16|0,a=s,t[a>>2]=u,zs(e,0,n,r,a),y=s}function zs(e,n,r,u,s){if(e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,e=e|0?e:956,I8[t[e+8>>2]&1](e,n,r,u,s)|0,(r|0)==5)$n();else return}function Wu(e,n,r){e=e|0,n=n|0,r=r|0,h[e+n>>0]=r&1}function sa(e,n){e=e|0,n=n|0;var r=0,u=0;t[e>>2]=0,t[e+4>>2]=0,t[e+8>>2]=0,r=n+4|0,u=(t[r>>2]|0)-(t[n>>2]|0)>>2,u|0&&(Xi(e,u),Hs(e,t[n>>2]|0,t[r>>2]|0,u))}function Xi(e,n){e=e|0,n=n|0;var r=0;if((R0(e)|0)>>>0<n>>>0&&di(e),n>>>0>1073741823)$n();else{r=pn(n<<2)|0,t[e+4>>2]=r,t[e>>2]=r,t[e+8>>2]=r+(n<<2);return}}function Hs(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,u=e+4|0,e=r-n|0,(e|0)>0&&(gr(t[u>>2]|0,n|0,e|0)|0,t[u>>2]=(t[u>>2]|0)+(e>>>2<<2))}function R0(e){return e=e|0,1073741823}function Hi(e,n,r){return e=e|0,n=n|0,r=S(r),qi(n)|0&&(t[e+96>>2]|0)!=0?e=e+92|0:e=pt(e+60|0,t[1040+(n<<2)>>2]|0,992)|0,S(il(e,r))}function A0(e,n,r){return e=e|0,n=n|0,r=S(r),qi(n)|0&&(t[e+104>>2]|0)!=0?e=e+100|0:e=pt(e+60|0,t[1e3+(n<<2)>>2]|0,992)|0,S(il(e,r))}function qi(e){return e=e|0,(e|1|0)==3|0}function il(e,n){return e=e|0,n=S(n),(t[e+4>>2]|0)==3?n=S(0):n=S(xn(e,n)),S(n)}function xl(e,n){return e=e|0,n=n|0,e=t[e>>2]|0,((e|0)==0?(n|0)>1?n:1:e)|0}function B0(e,n){e=e|0,n=n|0;var r=0;e:do if((n|0)==2){switch(e|0){case 2:{e=3;break e}case 3:break;default:{r=4;break e}}e=2}else r=4;while(0);return e|0}function O0(e,n){e=e|0,n=n|0;var r=Ct;return qi(n)|0&&(t[e+312>>2]|0)!=0&&(r=S(x[e+308>>2]),r>=S(0))||(r=S(xu(S(x[(pt(e+276|0,t[1040+(n<<2)>>2]|0,992)|0)>>2]),S(0)))),S(r)}function vo(e,n){e=e|0,n=n|0;var r=Ct;return qi(n)|0&&(t[e+320>>2]|0)!=0&&(r=S(x[e+316>>2]),r>=S(0))||(r=S(xu(S(x[(pt(e+276|0,t[1e3+(n<<2)>>2]|0,992)|0)>>2]),S(0)))),S(r)}function Fu(e,n,r){e=e|0,n=n|0,r=S(r);var u=Ct;return qi(n)|0&&(t[e+240>>2]|0)!=0&&(u=S(xn(e+236|0,r)),u>=S(0))||(u=S(xu(S(xn(pt(e+204|0,t[1040+(n<<2)>>2]|0,992)|0,r)),S(0)))),S(u)}function Ju(e,n,r){e=e|0,n=n|0,r=S(r);var u=Ct;return qi(n)|0&&(t[e+248>>2]|0)!=0&&(u=S(xn(e+244|0,r)),u>=S(0))||(u=S(xu(S(xn(pt(e+204|0,t[1e3+(n<<2)>>2]|0,992)|0,r)),S(0)))),S(u)}function es(e,n,r,u,s,a,v){e=e|0,n=S(n),r=S(r),u=u|0,s=s|0,a=S(a),v=S(v);var w=Ct,T=Ct,L=Ct,M=Ct,b=Ct,X=Ct,Be=0,Te=0,ye=0;ye=y,y=y+16|0,Be=ye,Te=e+964|0,Hu(e,(t[Te>>2]|0)!=0,3519),w=S(Rr(e,2,n)),T=S(Rr(e,0,n)),L=S(Kt(e,2,n)),M=S(Kt(e,0,n)),Le(n)|0?b=n:b=S(xu(S(0),S(S(n-L)-w))),Le(r)|0?X=r:X=S(xu(S(0),S(S(r-M)-T))),(u|0)==1&(s|0)==1?(x[e+908>>2]=S(Kn(e,2,S(n-L),a,a)),n=S(Kn(e,0,S(r-M),v,a))):(b8[t[Te>>2]&1](Be,e,b,u,X,s),b=S(w+S(x[Be>>2])),X=S(n-L),x[e+908>>2]=S(Kn(e,2,(u|2|0)==2?b:X,a,a)),X=S(T+S(x[Be+4>>2])),n=S(r-M),n=S(Kn(e,0,(s|2|0)==2?X:n,v,a))),x[e+912>>2]=n,y=ye}function _s(e,n,r,u,s,a,v){e=e|0,n=S(n),r=S(r),u=u|0,s=s|0,a=S(a),v=S(v);var w=Ct,T=Ct,L=Ct,M=Ct;L=S(Rr(e,2,a)),w=S(Rr(e,0,a)),M=S(Kt(e,2,a)),T=S(Kt(e,0,a)),n=S(n-M),x[e+908>>2]=S(Kn(e,2,(u|2|0)==2?L:n,a,a)),r=S(r-T),x[e+912>>2]=S(Kn(e,0,(s|2|0)==2?w:r,v,a))}function aa(e,n,r,u,s,a,v){e=e|0,n=S(n),r=S(r),u=u|0,s=s|0,a=S(a),v=S(v);var w=0,T=Ct,L=Ct;return w=(u|0)==2,!(n<=S(0)&w)&&!(r<=S(0)&(s|0)==2)&&!((u|0)==1&(s|0)==1)?e=0:(T=S(Kt(e,0,a)),L=S(Kt(e,2,a)),w=n<S(0)&w|(Le(n)|0),n=S(n-L),x[e+908>>2]=S(Kn(e,2,w?S(0):n,a,a)),n=S(r-T),w=r<S(0)&(s|0)==2|(Le(r)|0),x[e+912>>2]=S(Kn(e,0,w?S(0):n,v,a)),e=1),e|0}function gf(e,n){return e=e|0,n=n|0,_n(e)|0?e=B0(2,n)|0:e=0,e|0}function Zu(e,n,r){return e=e|0,n=n|0,r=S(r),r=S(Fu(e,n,r)),S(r+S(O0(e,n)))}function Es(e,n,r){return e=e|0,n=n|0,r=S(r),r=S(Ju(e,n,r)),S(r+S(vo(e,n)))}function Rr(e,n,r){e=e|0,n=n|0,r=S(r);var u=Ct;return u=S(Zu(e,n,r)),S(u+S(Es(e,n,r)))}function no(e){return e=e|0,t[e+24>>2]|0?e=0:S(nu(e))!=S(0)?e=1:e=S(fu(e))!=S(0),e|0}function nu(e){e=e|0;var n=Ct;if(t[e+944>>2]|0){if(n=S(x[e+44>>2]),Le(n)|0)return n=S(x[e+40>>2]),e=n>S(0)&((Le(n)|0)^1),S(e?n:S(0))}else n=S(0);return S(n)}function fu(e){e=e|0;var n=Ct,r=0,u=Ct;do if(t[e+944>>2]|0){if(n=S(x[e+48>>2]),Le(n)|0){if(r=h[(t[e+976>>2]|0)+2>>0]|0,r<<24>>24==0&&(u=S(x[e+40>>2]),u<S(0)&((Le(u)|0)^1))){n=S(-u);break}n=r<<24>>24?S(1):S(0)}}else n=S(0);while(0);return S(n)}function Li(e){e=e|0;var n=0,r=0;if(jv(e+400|0,0,540)|0,h[e+985>>0]=1,ms(e),r=wu(e)|0,r|0){n=e+948|0,e=0;do Li(t[(t[n>>2]|0)+(e<<2)>>2]|0),e=e+1|0;while((e|0)!=(r|0))}}function ei(e,n,r,u,s,a,v,w,T,L){e=e|0,n=n|0,r=S(r),u=u|0,s=S(s),a=S(a),v=S(v),w=w|0,T=T|0,L=L|0;var M=0,b=Ct,X=0,Be=0,Te=Ct,ye=Ct,Ze=0,Ye=Ct,ct=0,ke=Ct,Ie=0,Zt=0,Br=0,Pn=0,gn=0,_r=0,Pr=0,kn=0,uu=0,os=0;uu=y,y=y+16|0,Br=uu+12|0,Pn=uu+8|0,gn=uu+4|0,_r=uu,kn=B0(t[e+4>>2]|0,T)|0,Ie=qi(kn)|0,b=S(xn(Tn(n)|0,Ie?a:v)),Zt=qu(n,2,a)|0,Pr=qu(n,0,v)|0;do if(!(Le(b)|0)&&!(Le(Ie?r:s)|0)){if(M=n+504|0,!(Le(S(x[M>>2]))|0)&&(!(ir(t[n+976>>2]|0,0)|0)||(t[n+500>>2]|0)==(t[2278]|0)))break;x[M>>2]=S(xu(b,S(Rr(n,kn,a))))}else X=7;while(0);do if((X|0)==7){if(ct=Ie^1,!(ct|Zt^1)){v=S(xn(t[n+992>>2]|0,a)),x[n+504>>2]=S(xu(v,S(Rr(n,2,a))));break}if(!(Ie|Pr^1)){v=S(xn(t[n+996>>2]|0,v)),x[n+504>>2]=S(xu(v,S(Rr(n,0,a))));break}x[Br>>2]=S(ue),x[Pn>>2]=S(ue),t[gn>>2]=0,t[_r>>2]=0,Ye=S(Kt(n,2,a)),ke=S(Kt(n,0,a)),Zt?(Te=S(Ye+S(xn(t[n+992>>2]|0,a))),x[Br>>2]=Te,t[gn>>2]=1,Be=1):(Be=0,Te=S(ue)),Pr?(b=S(ke+S(xn(t[n+996>>2]|0,v))),x[Pn>>2]=b,t[_r>>2]=1,M=1):(M=0,b=S(ue)),X=t[e+32>>2]|0,Ie&(X|0)==2?X=2:Le(Te)|0&&!(Le(r)|0)&&(x[Br>>2]=r,t[gn>>2]=2,Be=2,Te=r),!((X|0)==2&ct)&&Le(b)|0&&!(Le(s)|0)&&(x[Pn>>2]=s,t[_r>>2]=2,M=2,b=s),ye=S(x[n+396>>2]),Ze=Le(ye)|0;do if(Ze)X=Be;else{if((Be|0)==1&ct){x[Pn>>2]=S(S(Te-Ye)/ye),t[_r>>2]=1,M=1,X=1;break}Ie&(M|0)==1?(x[Br>>2]=S(ye*S(b-ke)),t[gn>>2]=1,M=1,X=1):X=Be}while(0);os=Le(r)|0,Be=($u(e,n)|0)!=4,!(Ie|Zt|((u|0)!=1|os)|(Be|(X|0)==1))&&(x[Br>>2]=r,t[gn>>2]=1,!Ze)&&(x[Pn>>2]=S(S(r-Ye)/ye),t[_r>>2]=1,M=1),!(Pr|ct|((w|0)!=1|(Le(s)|0))|(Be|(M|0)==1))&&(x[Pn>>2]=s,t[_r>>2]=1,!Ze)&&(x[Br>>2]=S(ye*S(s-ke)),t[gn>>2]=1),Ln(n,2,a,a,gn,Br),Ln(n,0,v,a,_r,Pn),r=S(x[Br>>2]),s=S(x[Pn>>2]),Yt(n,r,s,T,t[gn>>2]|0,t[_r>>2]|0,a,v,0,3565,L)|0,v=S(x[n+908+(t[976+(kn<<2)>>2]<<2)>>2]),x[n+504>>2]=S(xu(v,S(Rr(n,kn,a))))}while(0);t[n+500>>2]=t[2278],y=uu}function Kn(e,n,r,u,s){return e=e|0,n=n|0,r=S(r),u=S(u),s=S(s),u=S(Qt(e,n,r,u)),S(xu(u,S(Rr(e,n,s))))}function $u(e,n){return e=e|0,n=n|0,n=n+20|0,n=t[((t[n>>2]|0)==0?e+16|0:n)>>2]|0,(n|0)==5&&_n(t[e+4>>2]|0)|0&&(n=1),n|0}function g0(e,n){return e=e|0,n=n|0,qi(n)|0&&(t[e+96>>2]|0)!=0?n=4:n=t[1040+(n<<2)>>2]|0,e+60+(n<<3)|0}function _0(e,n){return e=e|0,n=n|0,qi(n)|0&&(t[e+104>>2]|0)!=0?n=5:n=t[1e3+(n<<2)>>2]|0,e+60+(n<<3)|0}function Ln(e,n,r,u,s,a){switch(e=e|0,n=n|0,r=S(r),u=S(u),s=s|0,a=a|0,r=S(xn(e+380+(t[976+(n<<2)>>2]<<3)|0,r)),r=S(r+S(Kt(e,n,u))),t[s>>2]|0){case 2:case 1:{s=Le(r)|0,u=S(x[a>>2]),x[a>>2]=s|u<r?u:r;break}case 0:{Le(r)|0||(t[s>>2]=2,x[a>>2]=r);break}default:}}function fe(e,n){return e=e|0,n=n|0,e=e+132|0,qi(n)|0&&(t[(pt(e,4,948)|0)+4>>2]|0)!=0?e=1:e=(t[(pt(e,t[1040+(n<<2)>>2]|0,948)|0)+4>>2]|0)!=0,e|0}function ie(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0;return e=e+132|0,qi(n)|0&&(u=pt(e,4,948)|0,(t[u+4>>2]|0)!=0)?s=4:(u=pt(e,t[1040+(n<<2)>>2]|0,948)|0,t[u+4>>2]|0?s=4:r=S(0)),(s|0)==4&&(r=S(xn(u,r))),S(r)}function Pe(e,n,r){e=e|0,n=n|0,r=S(r);var u=Ct;return u=S(x[e+908+(t[976+(n<<2)>>2]<<2)>>2]),u=S(u+S(Hi(e,n,r))),S(u+S(A0(e,n,r)))}function Me(e){e=e|0;var n=0,r=0,u=0;e:do if(_n(t[e+4>>2]|0)|0)n=0;else if((t[e+16>>2]|0)!=5)if(r=wu(e)|0,!r)n=0;else for(n=0;;){if(u=Ti(e,n)|0,(t[u+24>>2]|0)==0&&(t[u+20>>2]|0)==5){n=1;break e}if(n=n+1|0,n>>>0>=r>>>0){n=0;break}}else n=1;while(0);return n|0}function at(e,n){e=e|0,n=n|0;var r=Ct;return r=S(x[e+908+(t[976+(n<<2)>>2]<<2)>>2]),r>=S(0)&((Le(r)|0)^1)|0}function mt(e){e=e|0;var n=Ct,r=0,u=0,s=0,a=0,v=0,w=0,T=Ct;if(r=t[e+968>>2]|0,r)T=S(x[e+908>>2]),n=S(x[e+912>>2]),n=S(N8[r&0](e,T,n)),Hu(e,(Le(n)|0)^1,3573);else{a=wu(e)|0;do if(a|0){for(r=0,s=0;;){if(u=Ti(e,s)|0,t[u+940>>2]|0){v=8;break}if((t[u+24>>2]|0)!=1)if(w=($u(e,u)|0)==5,w){r=u;break}else r=(r|0)==0?u:r;if(s=s+1|0,s>>>0>=a>>>0){v=8;break}}if((v|0)==8&&!r)break;return n=S(mt(r)),S(n+S(x[r+404>>2]))}while(0);n=S(x[e+912>>2])}return S(n)}function Qt(e,n,r,u){e=e|0,n=n|0,r=S(r),u=S(u);var s=Ct,a=0;return _n(n)|0?(n=1,a=3):qi(n)|0?(n=0,a=3):(u=S(ue),s=S(ue)),(a|0)==3&&(s=S(xn(e+364+(n<<3)|0,u)),u=S(xn(e+380+(n<<3)|0,u))),a=u<r&(u>=S(0)&((Le(u)|0)^1)),r=a?u:r,a=s>=S(0)&((Le(s)|0)^1)&r<s,S(a?s:r)}function An(e,n,r,u,s,a,v){e=e|0,n=n|0,r=S(r),u=u|0,s=S(s),a=a|0,v=v|0;var w=Ct,T=Ct,L=0,M=0,b=Ct,X=Ct,Be=Ct,Te=0,ye=0,Ze=0,Ye=0,ct=Ct,ke=0;Ze=B0(t[e+4>>2]|0,a)|0,Te=gf(Ze,a)|0,ye=qi(Ze)|0,b=S(Kt(n,2,r)),X=S(Kt(n,0,r)),qu(n,2,r)|0?w=S(b+S(xn(t[n+992>>2]|0,r))):fe(n,2)|0&&Ut(n,2)|0?(w=S(x[e+908>>2]),T=S(O0(e,2)),T=S(w-S(T+S(vo(e,2)))),w=S(ie(n,2,r)),w=S(Kn(n,2,S(T-S(w+S(Fi(n,2,r)))),r,r))):w=S(ue),qu(n,0,s)|0?T=S(X+S(xn(t[n+996>>2]|0,s))):fe(n,0)|0&&Ut(n,0)|0?(T=S(x[e+912>>2]),ct=S(O0(e,0)),ct=S(T-S(ct+S(vo(e,0)))),T=S(ie(n,0,s)),T=S(Kn(n,0,S(ct-S(T+S(Fi(n,0,s)))),s,r))):T=S(ue),L=Le(w)|0,M=Le(T)|0;do if(L^M&&(Be=S(x[n+396>>2]),!(Le(Be)|0)))if(L){w=S(b+S(S(T-X)*Be));break}else{ct=S(X+S(S(w-b)/Be)),T=M?ct:T;break}while(0);M=Le(w)|0,L=Le(T)|0,M|L&&(ke=(M^1)&1,u=r>S(0)&((u|0)!=0&M),w=ye?w:u?r:w,Yt(n,w,T,a,ye?ke:u?2:ke,M&(L^1)&1,w,T,0,3623,v)|0,w=S(x[n+908>>2]),w=S(w+S(Kt(n,2,r))),T=S(x[n+912>>2]),T=S(T+S(Kt(n,0,r)))),Yt(n,w,T,a,1,1,w,T,1,3635,v)|0,Ut(n,Ze)|0&&!(fe(n,Ze)|0)?(ke=t[976+(Ze<<2)>>2]|0,ct=S(x[e+908+(ke<<2)>>2]),ct=S(ct-S(x[n+908+(ke<<2)>>2])),ct=S(ct-S(vo(e,Ze))),ct=S(ct-S(A0(n,Ze,r))),ct=S(ct-S(Fi(n,Ze,ye?r:s))),x[n+400+(t[1040+(Ze<<2)>>2]<<2)>>2]=ct):Ye=21;do if((Ye|0)==21){if(!(fe(n,Ze)|0)&&(t[e+8>>2]|0)==1){ke=t[976+(Ze<<2)>>2]|0,ct=S(x[e+908+(ke<<2)>>2]),ct=S(S(ct-S(x[n+908+(ke<<2)>>2]))*S(.5)),x[n+400+(t[1040+(Ze<<2)>>2]<<2)>>2]=ct;break}!(fe(n,Ze)|0)&&(t[e+8>>2]|0)==2&&(ke=t[976+(Ze<<2)>>2]|0,ct=S(x[e+908+(ke<<2)>>2]),ct=S(ct-S(x[n+908+(ke<<2)>>2])),x[n+400+(t[1040+(Ze<<2)>>2]<<2)>>2]=ct)}while(0);Ut(n,Te)|0&&!(fe(n,Te)|0)?(ke=t[976+(Te<<2)>>2]|0,ct=S(x[e+908+(ke<<2)>>2]),ct=S(ct-S(x[n+908+(ke<<2)>>2])),ct=S(ct-S(vo(e,Te))),ct=S(ct-S(A0(n,Te,r))),ct=S(ct-S(Fi(n,Te,ye?s:r))),x[n+400+(t[1040+(Te<<2)>>2]<<2)>>2]=ct):Ye=30;do if((Ye|0)==30&&!(fe(n,Te)|0)){if(($u(e,n)|0)==2){ke=t[976+(Te<<2)>>2]|0,ct=S(x[e+908+(ke<<2)>>2]),ct=S(S(ct-S(x[n+908+(ke<<2)>>2]))*S(.5)),x[n+400+(t[1040+(Te<<2)>>2]<<2)>>2]=ct;break}ke=($u(e,n)|0)==3,ke^(t[e+28>>2]|0)==2&&(ke=t[976+(Te<<2)>>2]|0,ct=S(x[e+908+(ke<<2)>>2]),ct=S(ct-S(x[n+908+(ke<<2)>>2])),x[n+400+(t[1040+(Te<<2)>>2]<<2)>>2]=ct)}while(0)}function Sn(e,n,r){e=e|0,n=n|0,r=r|0;var u=Ct,s=0;s=t[976+(r<<2)>>2]|0,u=S(x[n+908+(s<<2)>>2]),u=S(S(x[e+908+(s<<2)>>2])-u),u=S(u-S(x[n+400+(t[1040+(r<<2)>>2]<<2)>>2])),x[n+400+(t[1e3+(r<<2)>>2]<<2)>>2]=u}function _n(e){return e=e|0,(e|1|0)==1|0}function Tn(e){e=e|0;var n=Ct;switch(t[e+56>>2]|0){case 0:case 3:{n=S(x[e+40>>2]),n>S(0)&((Le(n)|0)^1)?e=h[(t[e+976>>2]|0)+2>>0]|0?1056:992:e=1056;break}default:e=e+52|0}return e|0}function ir(e,n){return e=e|0,n=n|0,(h[e+n>>0]|0)!=0|0}function Ut(e,n){return e=e|0,n=n|0,e=e+132|0,qi(n)|0&&(t[(pt(e,5,948)|0)+4>>2]|0)!=0?e=1:e=(t[(pt(e,t[1e3+(n<<2)>>2]|0,948)|0)+4>>2]|0)!=0,e|0}function Fi(e,n,r){e=e|0,n=n|0,r=S(r);var u=0,s=0;return e=e+132|0,qi(n)|0&&(u=pt(e,5,948)|0,(t[u+4>>2]|0)!=0)?s=4:(u=pt(e,t[1e3+(n<<2)>>2]|0,948)|0,t[u+4>>2]|0?s=4:r=S(0)),(s|0)==4&&(r=S(xn(u,r))),S(r)}function Ar(e,n,r){return e=e|0,n=n|0,r=S(r),fe(e,n)|0?r=S(ie(e,n,r)):r=S(-S(Fi(e,n,r))),S(r)}function mr(e){return e=S(e),x[V>>2]=e,t[V>>2]|0|0}function K(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>1073741823)$n();else{s=pn(n<<2)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<2)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<2)}function ti(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>2)<<2)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function ni(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-4-n|0)>>>2)<<2)),e=t[e>>2]|0,e|0&&Et(e)}function Wr(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;if(v=e+4|0,w=t[v>>2]|0,s=w-u|0,a=s>>2,e=n+(a<<2)|0,e>>>0<r>>>0){u=w;do t[u>>2]=t[e>>2],e=e+4|0,u=(t[v>>2]|0)+4|0,t[v>>2]=u;while(e>>>0<r>>>0)}a|0&&ky(w+(0-a<<2)|0,n|0,s|0)|0}function ft(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0;return w=n+4|0,T=t[w>>2]|0,s=t[e>>2]|0,v=r,a=v-s|0,u=T+(0-(a>>2)<<2)|0,t[w>>2]=u,(a|0)>0&&gr(u|0,s|0,a|0)|0,s=e+4|0,a=n+8|0,u=(t[s>>2]|0)-v|0,(u|0)>0&&(gr(t[a>>2]|0,r|0,u|0)|0,t[a>>2]=(t[a>>2]|0)+(u>>>2<<2)),v=t[e>>2]|0,t[e>>2]=t[w>>2],t[w>>2]=v,v=t[s>>2]|0,t[s>>2]=t[a>>2],t[a>>2]=v,v=e+8|0,r=n+12|0,e=t[v>>2]|0,t[v>>2]=t[r>>2],t[r>>2]=e,t[n>>2]=t[w>>2],T|0}function Di(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;if(v=t[n>>2]|0,a=t[r>>2]|0,(v|0)!=(a|0)){s=e+8|0,r=((a+-4-v|0)>>>2)+1|0,e=v,u=t[s>>2]|0;do t[u>>2]=t[e>>2],u=(t[s>>2]|0)+4|0,t[s>>2]=u,e=e+4|0;while((e|0)!=(a|0));t[n>>2]=v+(r<<2)}}function ru(){Se()}function E0(){var e=0;return e=pn(4)|0,Un(e),e|0}function Un(e){e=e|0,t[e>>2]=v0()|0}function e0(e){e=e|0,e|0&&(ro(e),Et(e))}function ro(e){e=e|0,J0(t[e>>2]|0)}function mo(e,n,r){e=e|0,n=n|0,r=r|0,Wu(t[e>>2]|0,n,r)}function t0(e,n){e=e|0,n=S(n),Qu(t[e>>2]|0,n)}function jo(e,n){return e=e|0,n=n|0,ir(t[e>>2]|0,n)|0}function io(){var e=0;return e=pn(8)|0,Ba(e,0),e|0}function Ba(e,n){e=e|0,n=n|0,n?n=Yn(t[n>>2]|0)|0:n=cr()|0,t[e>>2]=n,t[e+4>>2]=0,ba(n,e)}function _f(e){e=e|0;var n=0;return n=pn(8)|0,Ba(n,e),n|0}function fc(e){e=e|0,e|0&&(Ds(e),Et(e))}function Ds(e){e=e|0;var n=0;ju(t[e>>2]|0),n=e+4|0,e=t[n>>2]|0,t[n>>2]=0,e|0&&(fa(e),Et(e))}function fa(e){e=e|0,U0(e)}function U0(e){e=e|0,e=t[e>>2]|0,e|0&&qr(e|0)}function cc(e){return e=e|0,Bs(e)|0}function Ua(e){e=e|0;var n=0,r=0;r=e+4|0,n=t[r>>2]|0,t[r>>2]=0,n|0&&(fa(n),Et(n)),po(t[e>>2]|0)}function _2(e,n){e=e|0,n=n|0,oa(t[e>>2]|0,t[n>>2]|0)}function nd(e,n){e=e|0,n=n|0,$(t[e>>2]|0,n)}function rd(e,n,r){e=e|0,n=n|0,r=+r,dr(t[e>>2]|0,n,S(r))}function yo(e,n,r){e=e|0,n=n|0,r=+r,er(t[e>>2]|0,n,S(r))}function qc(e,n){e=e|0,n=n|0,H(t[e>>2]|0,n)}function Rl(e,n){e=e|0,n=n|0,ee(t[e>>2]|0,n)}function ul(e,n){e=e|0,n=n|0,_e(t[e>>2]|0,n)}function E2(e,n){e=e|0,n=n|0,m0(t[e>>2]|0,n)}function qs(e,n){e=e|0,n=n|0,Je(t[e>>2]|0,n)}function Al(e,n){e=e|0,n=n|0,zi(t[e>>2]|0,n)}function id(e,n,r){e=e|0,n=n|0,r=+r,Rn(t[e>>2]|0,n,S(r))}function zo(e,n,r){e=e|0,n=n|0,r=+r,Nr(t[e>>2]|0,n,S(r))}function ja(e,n){e=e|0,n=n|0,Lr(t[e>>2]|0,n)}function za(e,n){e=e|0,n=n|0,oe(t[e>>2]|0,n)}function Ha(e,n){e=e|0,n=n|0,rt(t[e>>2]|0,n)}function ca(e,n){e=e|0,n=+n,kt(t[e>>2]|0,S(n))}function ws(e,n){e=e|0,n=+n,rn(t[e>>2]|0,S(n))}function Ss(e,n){e=e|0,n=+n,Ft(t[e>>2]|0,S(n))}function ts(e,n){e=e|0,n=+n,bt(t[e>>2]|0,S(n))}function Ho(e,n){e=e|0,n=+n,sn(t[e>>2]|0,S(n))}function Ef(e,n){e=e|0,n=+n,fn(t[e>>2]|0,S(n))}function ol(e,n){e=e|0,n=+n,Jn(t[e>>2]|0,S(n))}function Vu(e){e=e|0,wr(t[e>>2]|0)}function qa(e,n){e=e|0,n=+n,ku(t[e>>2]|0,S(n))}function n0(e,n){e=e|0,n=+n,T0(t[e>>2]|0,S(n))}function j0(e){e=e|0,Z0(t[e>>2]|0)}function Df(e,n){e=e|0,n=+n,gi(t[e>>2]|0,S(n))}function Wc(e,n){e=e|0,n=+n,Po(t[e>>2]|0,S(n))}function dc(e,n){e=e|0,n=+n,hf(t[e>>2]|0,S(n))}function Ol(e,n){e=e|0,n=+n,Tl(t[e>>2]|0,S(n))}function Ts(e,n){e=e|0,n=+n,Io(t[e>>2]|0,S(n))}function da(e,n){e=e|0,n=+n,ys(t[e>>2]|0,S(n))}function ud(e,n){e=e|0,n=+n,bo(t[e>>2]|0,S(n))}function pa(e,n){e=e|0,n=+n,Bo(t[e>>2]|0,S(n))}function pc(e,n){e=e|0,n=+n,Xu(t[e>>2]|0,S(n))}function Vc(e,n,r){e=e|0,n=n|0,r=+r,It(t[e>>2]|0,n,S(r))}function Wi(e,n,r){e=e|0,n=n|0,r=+r,ut(t[e>>2]|0,n,S(r))}function _(e,n,r){e=e|0,n=n|0,r=+r,wt(t[e>>2]|0,n,S(r))}function g(e){return e=e|0,Ne(t[e>>2]|0)|0}function A(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;u=y,y=y+16|0,s=u,Cr(s,t[n>>2]|0,r),P(e,s),y=u}function P(e,n){e=e|0,n=n|0,B(e,t[n+4>>2]|0,+S(x[n>>2]))}function B(e,n,r){e=e|0,n=n|0,r=+r,t[e>>2]=n,j[e+8>>3]=r}function Z(e){return e=e|0,Y(t[e>>2]|0)|0}function de(e){return e=e|0,Ce(t[e>>2]|0)|0}function yt(e){return e=e|0,Oe(t[e>>2]|0)|0}function Rt(e){return e=e|0,Us(t[e>>2]|0)|0}function Nt(e){return e=e|0,vt(t[e>>2]|0)|0}function xr(e){return e=e|0,U(t[e>>2]|0)|0}function r0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;u=y,y=y+16|0,s=u,y0(s,t[n>>2]|0,r),P(e,s),y=u}function cu(e){return e=e|0,qe(t[e>>2]|0)|0}function z0(e){return e=e|0,xt(t[e>>2]|0)|0}function Ml(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,Dn(u,t[n>>2]|0),P(e,u),y=r}function i0(e){return e=e|0,+ +S(pf(t[e>>2]|0))}function Ge(e){return e=e|0,+ +S(bs(t[e>>2]|0))}function je(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,au(u,t[n>>2]|0),P(e,u),y=r}function st(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,Nu(u,t[n>>2]|0),P(e,u),y=r}function $t(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,rl(u,t[n>>2]|0),P(e,u),y=r}function Wn(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,vf(u,t[n>>2]|0),P(e,u),y=r}function oi(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,js(u,t[n>>2]|0),P(e,u),y=r}function ur(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,gs(u,t[n>>2]|0),P(e,u),y=r}function ai(e){return e=e|0,+ +S(Su(t[e>>2]|0))}function Qi(e,n){return e=e|0,n=n|0,+ +S(un(t[e>>2]|0,n))}function Vr(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;u=y,y=y+16|0,s=u,et(s,t[n>>2]|0,r),P(e,s),y=u}function Tu(e,n,r){e=e|0,n=n|0,r=r|0,Ia(t[e>>2]|0,t[n>>2]|0,r)}function Wa(e,n){e=e|0,n=n|0,Mu(t[e>>2]|0,t[n>>2]|0)}function Va(e){return e=e|0,wu(t[e>>2]|0)|0}function od(e){return e=e|0,e=si(t[e>>2]|0)|0,e?e=cc(e)|0:e=0,e|0}function D2(e,n){return e=e|0,n=n|0,e=Ti(t[e>>2]|0,n)|0,e?e=cc(e)|0:e=0,e|0}function w2(e,n){e=e|0,n=n|0;var r=0,u=0;u=pn(4)|0,wf(u,n),r=e+4|0,n=t[r>>2]|0,t[r>>2]=u,n|0&&(fa(n),Et(n)),ua(t[e>>2]|0,1)}function wf(e,n){e=e|0,n=n|0,sl(e,n)}function ld(e,n,r,u,s,a){e=e|0,n=n|0,r=S(r),u=u|0,s=S(s),a=a|0;var v=0,w=0;v=y,y=y+16|0,w=v,hh(w,Bs(n)|0,+r,u,+s,a),x[e>>2]=S(+j[w>>3]),x[e+4>>2]=S(+j[w+8>>3]),y=v}function hh(e,n,r,u,s,a){e=e|0,n=n|0,r=+r,u=u|0,s=+s,a=a|0;var v=0,w=0,T=0,L=0,M=0;v=y,y=y+32|0,M=v+8|0,L=v+20|0,T=v,w=v+16|0,j[M>>3]=r,t[L>>2]=u,j[T>>3]=s,t[w>>2]=a,Gc(e,t[n+4>>2]|0,M,L,T,w),y=v}function Gc(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0;var v=0,w=0;v=y,y=y+16|0,w=v,Ma(w),n=go(n)|0,vh(e,n,+j[r>>3],t[u>>2]|0,+j[s>>3],t[a>>2]|0),ka(w),y=v}function go(e){return e=e|0,t[e>>2]|0}function vh(e,n,r,u,s,a){e=e|0,n=n|0,r=+r,u=u|0,s=+s,a=a|0;var v=0;v=_o(mh()|0)|0,r=+kl(r),u=sd(u)|0,s=+kl(s),ad(e,Xr(0,v|0,n|0,+r,u|0,+s,sd(a)|0)|0)}function mh(){var e=0;return h[7608]|0||(Kc(9120),e=7608,t[e>>2]=1,t[e+4>>2]=0),9120}function _o(e){return e=e|0,t[e+8>>2]|0}function kl(e){return e=+e,+ +Ga(e)}function sd(e){return e=e|0,cd(e)|0}function ad(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;s=y,y=y+32|0,r=s,u=n,u&1?(S2(r,0),eu(u|0,r|0)|0,Yc(e,r),Ir(r)):(t[e>>2]=t[n>>2],t[e+4>>2]=t[n+4>>2],t[e+8>>2]=t[n+8>>2],t[e+12>>2]=t[n+12>>2]),y=s}function S2(e,n){e=e|0,n=n|0,fd(e,n),t[e+8>>2]=0,h[e+24>>0]=0}function Yc(e,n){e=e|0,n=n|0,n=n+8|0,t[e>>2]=t[n>>2],t[e+4>>2]=t[n+4>>2],t[e+8>>2]=t[n+8>>2],t[e+12>>2]=t[n+12>>2]}function Ir(e){e=e|0,h[e+24>>0]=0}function fd(e,n){e=e|0,n=n|0,t[e>>2]=n}function cd(e){return e=e|0,e|0}function Ga(e){return e=+e,+e}function Kc(e){e=e|0,ll(e,T2()|0,4)}function T2(){return 1064}function ll(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r,t[e+8>>2]=Bt(n|0,r+1|0)|0}function sl(e,n){e=e|0,n=n|0,n=t[n>>2]|0,t[e>>2]=n,Ri(n|0)}function yh(e){e=e|0;var n=0,r=0;r=e+4|0,n=t[r>>2]|0,t[r>>2]=0,n|0&&(fa(n),Et(n)),ua(t[e>>2]|0,0)}function Sf(e){e=e|0,Jr(t[e>>2]|0)}function Xc(e){return e=e|0,Zl(t[e>>2]|0)|0}function C2(e,n,r,u){e=e|0,n=+n,r=+r,u=u|0,$r(t[e>>2]|0,S(n),S(r),u)}function gh(e){return e=e|0,+ +S(_i(t[e>>2]|0))}function al(e){return e=e|0,+ +S($0(t[e>>2]|0))}function ha(e){return e=e|0,+ +S(C0(t[e>>2]|0))}function x2(e){return e=e|0,+ +S(Uo(t[e>>2]|0))}function R2(e){return e=e|0,+ +S(la(t[e>>2]|0))}function hc(e){return e=e|0,+ +S($l(t[e>>2]|0))}function _h(e,n){e=e|0,n=n|0,j[e>>3]=+S(_i(t[n>>2]|0)),j[e+8>>3]=+S($0(t[n>>2]|0)),j[e+16>>3]=+S(C0(t[n>>2]|0)),j[e+24>>3]=+S(Uo(t[n>>2]|0)),j[e+32>>3]=+S(la(t[n>>2]|0)),j[e+40>>3]=+S($l(t[n>>2]|0))}function A2(e,n){return e=e|0,n=n|0,+ +S(tu(t[e>>2]|0,n))}function dd(e,n){return e=e|0,n=n|0,+ +S(Zr(t[e>>2]|0,n))}function Qc(e,n){return e=e|0,n=n|0,+ +S(ho(t[e>>2]|0,n))}function Jc(){return Pa()|0}function Ws(){O2(),va(),Zc(),vc(),mc(),pd()}function O2(){E7(11713,4938,1)}function va(){UA(10448)}function Zc(){EA(10408)}function vc(){qR(10324)}function mc(){nE(10096)}function pd(){Eh(9132)}function Eh(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0,Ze=0,Ye=0,ct=0,ke=0,Ie=0,Zt=0,Br=0,Pn=0,gn=0,_r=0,Pr=0,kn=0,uu=0,os=0,ls=0,ss=0,ea=0,t2=0,n2=0,uf=0,r2=0,Fc=0,Pc=0,i2=0,u2=0,o2=0,pi=0,of=0,l2=0,Yf=0,s2=0,a2=0,Ic=0,bc=0,Kf=0,ql=0,La=0,Ns=0,lf=0,b1=0,B1=0,Bc=0,U1=0,j1=0,Wl=0,El=0,sf=0,hu=0,z1=0,as=0,Xf=0,fs=0,Qf=0,H1=0,q1=0,Jf=0,Vl=0,af=0,W1=0,V1=0,G1=0,Sr=0,bu=0,Dl=0,cs=0,Gl=0,Or=0,Bn=0,ff=0;n=y,y=y+672|0,r=n+656|0,ff=n+648|0,Bn=n+640|0,Or=n+632|0,Gl=n+624|0,cs=n+616|0,Dl=n+608|0,bu=n+600|0,Sr=n+592|0,G1=n+584|0,V1=n+576|0,W1=n+568|0,af=n+560|0,Vl=n+552|0,Jf=n+544|0,q1=n+536|0,H1=n+528|0,Qf=n+520|0,fs=n+512|0,Xf=n+504|0,as=n+496|0,z1=n+488|0,hu=n+480|0,sf=n+472|0,El=n+464|0,Wl=n+456|0,j1=n+448|0,U1=n+440|0,Bc=n+432|0,B1=n+424|0,b1=n+416|0,lf=n+408|0,Ns=n+400|0,La=n+392|0,ql=n+384|0,Kf=n+376|0,bc=n+368|0,Ic=n+360|0,a2=n+352|0,s2=n+344|0,Yf=n+336|0,l2=n+328|0,of=n+320|0,pi=n+312|0,o2=n+304|0,u2=n+296|0,i2=n+288|0,Pc=n+280|0,Fc=n+272|0,r2=n+264|0,uf=n+256|0,n2=n+248|0,t2=n+240|0,ea=n+232|0,ss=n+224|0,ls=n+216|0,os=n+208|0,uu=n+200|0,kn=n+192|0,Pr=n+184|0,_r=n+176|0,gn=n+168|0,Pn=n+160|0,Br=n+152|0,Zt=n+144|0,Ie=n+136|0,ke=n+128|0,ct=n+120|0,Ye=n+112|0,Ze=n+104|0,ye=n+96|0,Te=n+88|0,Be=n+80|0,X=n+72|0,b=n+64|0,M=n+56|0,L=n+48|0,T=n+40|0,w=n+32|0,v=n+24|0,a=n+16|0,s=n+8|0,u=n,Tf(e,3646),$c(e,3651,2)|0,Dh(e,3665,2)|0,sm(e,3682,18)|0,t[ff>>2]=19,t[ff+4>>2]=0,t[r>>2]=t[ff>>2],t[r+4>>2]=t[ff+4>>2],Vs(e,3690,r)|0,t[Bn>>2]=1,t[Bn+4>>2]=0,t[r>>2]=t[Bn>>2],t[r+4>>2]=t[Bn+4>>2],ma(e,3696,r)|0,t[Or>>2]=2,t[Or+4>>2]=0,t[r>>2]=t[Or>>2],t[r+4>>2]=t[Or+4>>2],iu(e,3706,r)|0,t[Gl>>2]=1,t[Gl+4>>2]=0,t[r>>2]=t[Gl>>2],t[r+4>>2]=t[Gl+4>>2],M0(e,3722,r)|0,t[cs>>2]=2,t[cs+4>>2]=0,t[r>>2]=t[cs>>2],t[r+4>>2]=t[cs+4>>2],M0(e,3734,r)|0,t[Dl>>2]=3,t[Dl+4>>2]=0,t[r>>2]=t[Dl>>2],t[r+4>>2]=t[Dl+4>>2],iu(e,3753,r)|0,t[bu>>2]=4,t[bu+4>>2]=0,t[r>>2]=t[bu>>2],t[r+4>>2]=t[bu+4>>2],iu(e,3769,r)|0,t[Sr>>2]=5,t[Sr+4>>2]=0,t[r>>2]=t[Sr>>2],t[r+4>>2]=t[Sr+4>>2],iu(e,3783,r)|0,t[G1>>2]=6,t[G1+4>>2]=0,t[r>>2]=t[G1>>2],t[r+4>>2]=t[G1+4>>2],iu(e,3796,r)|0,t[V1>>2]=7,t[V1+4>>2]=0,t[r>>2]=t[V1>>2],t[r+4>>2]=t[V1+4>>2],iu(e,3813,r)|0,t[W1>>2]=8,t[W1+4>>2]=0,t[r>>2]=t[W1>>2],t[r+4>>2]=t[W1+4>>2],iu(e,3825,r)|0,t[af>>2]=3,t[af+4>>2]=0,t[r>>2]=t[af>>2],t[r+4>>2]=t[af+4>>2],M0(e,3843,r)|0,t[Vl>>2]=4,t[Vl+4>>2]=0,t[r>>2]=t[Vl>>2],t[r+4>>2]=t[Vl+4>>2],M0(e,3853,r)|0,t[Jf>>2]=9,t[Jf+4>>2]=0,t[r>>2]=t[Jf>>2],t[r+4>>2]=t[Jf+4>>2],iu(e,3870,r)|0,t[q1>>2]=10,t[q1+4>>2]=0,t[r>>2]=t[q1>>2],t[r+4>>2]=t[q1+4>>2],iu(e,3884,r)|0,t[H1>>2]=11,t[H1+4>>2]=0,t[r>>2]=t[H1>>2],t[r+4>>2]=t[H1+4>>2],iu(e,3896,r)|0,t[Qf>>2]=1,t[Qf+4>>2]=0,t[r>>2]=t[Qf>>2],t[r+4>>2]=t[Qf+4>>2],u0(e,3907,r)|0,t[fs>>2]=2,t[fs+4>>2]=0,t[r>>2]=t[fs>>2],t[r+4>>2]=t[fs+4>>2],u0(e,3915,r)|0,t[Xf>>2]=3,t[Xf+4>>2]=0,t[r>>2]=t[Xf>>2],t[r+4>>2]=t[Xf+4>>2],u0(e,3928,r)|0,t[as>>2]=4,t[as+4>>2]=0,t[r>>2]=t[as>>2],t[r+4>>2]=t[as+4>>2],u0(e,3948,r)|0,t[z1>>2]=5,t[z1+4>>2]=0,t[r>>2]=t[z1>>2],t[r+4>>2]=t[z1+4>>2],u0(e,3960,r)|0,t[hu>>2]=6,t[hu+4>>2]=0,t[r>>2]=t[hu>>2],t[r+4>>2]=t[hu+4>>2],u0(e,3974,r)|0,t[sf>>2]=7,t[sf+4>>2]=0,t[r>>2]=t[sf>>2],t[r+4>>2]=t[sf+4>>2],u0(e,3983,r)|0,t[El>>2]=20,t[El+4>>2]=0,t[r>>2]=t[El>>2],t[r+4>>2]=t[El+4>>2],Vs(e,3999,r)|0,t[Wl>>2]=8,t[Wl+4>>2]=0,t[r>>2]=t[Wl>>2],t[r+4>>2]=t[Wl+4>>2],u0(e,4012,r)|0,t[j1>>2]=9,t[j1+4>>2]=0,t[r>>2]=t[j1>>2],t[r+4>>2]=t[j1+4>>2],u0(e,4022,r)|0,t[U1>>2]=21,t[U1+4>>2]=0,t[r>>2]=t[U1>>2],t[r+4>>2]=t[U1+4>>2],Vs(e,4039,r)|0,t[Bc>>2]=10,t[Bc+4>>2]=0,t[r>>2]=t[Bc>>2],t[r+4>>2]=t[Bc+4>>2],u0(e,4053,r)|0,t[B1>>2]=11,t[B1+4>>2]=0,t[r>>2]=t[B1>>2],t[r+4>>2]=t[B1+4>>2],u0(e,4065,r)|0,t[b1>>2]=12,t[b1+4>>2]=0,t[r>>2]=t[b1>>2],t[r+4>>2]=t[b1+4>>2],u0(e,4084,r)|0,t[lf>>2]=13,t[lf+4>>2]=0,t[r>>2]=t[lf>>2],t[r+4>>2]=t[lf+4>>2],u0(e,4097,r)|0,t[Ns>>2]=14,t[Ns+4>>2]=0,t[r>>2]=t[Ns>>2],t[r+4>>2]=t[Ns+4>>2],u0(e,4117,r)|0,t[La>>2]=15,t[La+4>>2]=0,t[r>>2]=t[La>>2],t[r+4>>2]=t[La+4>>2],u0(e,4129,r)|0,t[ql>>2]=16,t[ql+4>>2]=0,t[r>>2]=t[ql>>2],t[r+4>>2]=t[ql+4>>2],u0(e,4148,r)|0,t[Kf>>2]=17,t[Kf+4>>2]=0,t[r>>2]=t[Kf>>2],t[r+4>>2]=t[Kf+4>>2],u0(e,4161,r)|0,t[bc>>2]=18,t[bc+4>>2]=0,t[r>>2]=t[bc>>2],t[r+4>>2]=t[bc+4>>2],u0(e,4181,r)|0,t[Ic>>2]=5,t[Ic+4>>2]=0,t[r>>2]=t[Ic>>2],t[r+4>>2]=t[Ic+4>>2],M0(e,4196,r)|0,t[a2>>2]=6,t[a2+4>>2]=0,t[r>>2]=t[a2>>2],t[r+4>>2]=t[a2+4>>2],M0(e,4206,r)|0,t[s2>>2]=7,t[s2+4>>2]=0,t[r>>2]=t[s2>>2],t[r+4>>2]=t[s2+4>>2],M0(e,4217,r)|0,t[Yf>>2]=3,t[Yf+4>>2]=0,t[r>>2]=t[Yf>>2],t[r+4>>2]=t[Yf+4>>2],ns(e,4235,r)|0,t[l2>>2]=1,t[l2+4>>2]=0,t[r>>2]=t[l2>>2],t[r+4>>2]=t[l2+4>>2],Ya(e,4251,r)|0,t[of>>2]=4,t[of+4>>2]=0,t[r>>2]=t[of>>2],t[r+4>>2]=t[of+4>>2],ns(e,4263,r)|0,t[pi>>2]=5,t[pi+4>>2]=0,t[r>>2]=t[pi>>2],t[r+4>>2]=t[pi+4>>2],ns(e,4279,r)|0,t[o2>>2]=6,t[o2+4>>2]=0,t[r>>2]=t[o2>>2],t[r+4>>2]=t[o2+4>>2],ns(e,4293,r)|0,t[u2>>2]=7,t[u2+4>>2]=0,t[r>>2]=t[u2>>2],t[r+4>>2]=t[u2+4>>2],ns(e,4306,r)|0,t[i2>>2]=8,t[i2+4>>2]=0,t[r>>2]=t[i2>>2],t[r+4>>2]=t[i2+4>>2],ns(e,4323,r)|0,t[Pc>>2]=9,t[Pc+4>>2]=0,t[r>>2]=t[Pc>>2],t[r+4>>2]=t[Pc+4>>2],ns(e,4335,r)|0,t[Fc>>2]=2,t[Fc+4>>2]=0,t[r>>2]=t[Fc>>2],t[r+4>>2]=t[Fc+4>>2],Ya(e,4353,r)|0,t[r2>>2]=12,t[r2+4>>2]=0,t[r>>2]=t[r2>>2],t[r+4>>2]=t[r2+4>>2],uo(e,4363,r)|0,t[uf>>2]=1,t[uf+4>>2]=0,t[r>>2]=t[uf>>2],t[r+4>>2]=t[uf+4>>2],fl(e,4376,r)|0,t[n2>>2]=2,t[n2+4>>2]=0,t[r>>2]=t[n2>>2],t[r+4>>2]=t[n2+4>>2],fl(e,4388,r)|0,t[t2>>2]=13,t[t2+4>>2]=0,t[r>>2]=t[t2>>2],t[r+4>>2]=t[t2+4>>2],uo(e,4402,r)|0,t[ea>>2]=14,t[ea+4>>2]=0,t[r>>2]=t[ea>>2],t[r+4>>2]=t[ea+4>>2],uo(e,4411,r)|0,t[ss>>2]=15,t[ss+4>>2]=0,t[r>>2]=t[ss>>2],t[r+4>>2]=t[ss+4>>2],uo(e,4421,r)|0,t[ls>>2]=16,t[ls+4>>2]=0,t[r>>2]=t[ls>>2],t[r+4>>2]=t[ls+4>>2],uo(e,4433,r)|0,t[os>>2]=17,t[os+4>>2]=0,t[r>>2]=t[os>>2],t[r+4>>2]=t[os+4>>2],uo(e,4446,r)|0,t[uu>>2]=18,t[uu+4>>2]=0,t[r>>2]=t[uu>>2],t[r+4>>2]=t[uu+4>>2],uo(e,4458,r)|0,t[kn>>2]=3,t[kn+4>>2]=0,t[r>>2]=t[kn>>2],t[r+4>>2]=t[kn+4>>2],fl(e,4471,r)|0,t[Pr>>2]=1,t[Pr+4>>2]=0,t[r>>2]=t[Pr>>2],t[r+4>>2]=t[Pr+4>>2],yc(e,4486,r)|0,t[_r>>2]=10,t[_r+4>>2]=0,t[r>>2]=t[_r>>2],t[r+4>>2]=t[_r+4>>2],ns(e,4496,r)|0,t[gn>>2]=11,t[gn+4>>2]=0,t[r>>2]=t[gn>>2],t[r+4>>2]=t[gn+4>>2],ns(e,4508,r)|0,t[Pn>>2]=3,t[Pn+4>>2]=0,t[r>>2]=t[Pn>>2],t[r+4>>2]=t[Pn+4>>2],Ya(e,4519,r)|0,t[Br>>2]=4,t[Br+4>>2]=0,t[r>>2]=t[Br>>2],t[r+4>>2]=t[Br+4>>2],M2(e,4530,r)|0,t[Zt>>2]=19,t[Zt+4>>2]=0,t[r>>2]=t[Zt>>2],t[r+4>>2]=t[Zt+4>>2],wh(e,4542,r)|0,t[Ie>>2]=12,t[Ie+4>>2]=0,t[r>>2]=t[Ie>>2],t[r+4>>2]=t[Ie+4>>2],Cf(e,4554,r)|0,t[ke>>2]=13,t[ke+4>>2]=0,t[r>>2]=t[ke>>2],t[r+4>>2]=t[ke+4>>2],xf(e,4568,r)|0,t[ct>>2]=2,t[ct+4>>2]=0,t[r>>2]=t[ct>>2],t[r+4>>2]=t[ct+4>>2],e1(e,4578,r)|0,t[Ye>>2]=20,t[Ye+4>>2]=0,t[r>>2]=t[Ye>>2],t[r+4>>2]=t[Ye+4>>2],Nl(e,4587,r)|0,t[Ze>>2]=22,t[Ze+4>>2]=0,t[r>>2]=t[Ze>>2],t[r+4>>2]=t[Ze+4>>2],Vs(e,4602,r)|0,t[ye>>2]=23,t[ye+4>>2]=0,t[r>>2]=t[ye>>2],t[r+4>>2]=t[ye+4>>2],Vs(e,4619,r)|0,t[Te>>2]=14,t[Te+4>>2]=0,t[r>>2]=t[Te>>2],t[r+4>>2]=t[Te+4>>2],t1(e,4629,r)|0,t[Be>>2]=1,t[Be+4>>2]=0,t[r>>2]=t[Be>>2],t[r+4>>2]=t[Be+4>>2],ya(e,4637,r)|0,t[X>>2]=4,t[X+4>>2]=0,t[r>>2]=t[X>>2],t[r+4>>2]=t[X+4>>2],fl(e,4653,r)|0,t[b>>2]=5,t[b+4>>2]=0,t[r>>2]=t[b>>2],t[r+4>>2]=t[b+4>>2],fl(e,4669,r)|0,t[M>>2]=6,t[M+4>>2]=0,t[r>>2]=t[M>>2],t[r+4>>2]=t[M+4>>2],fl(e,4686,r)|0,t[L>>2]=7,t[L+4>>2]=0,t[r>>2]=t[L>>2],t[r+4>>2]=t[L+4>>2],fl(e,4701,r)|0,t[T>>2]=8,t[T+4>>2]=0,t[r>>2]=t[T>>2],t[r+4>>2]=t[T+4>>2],fl(e,4719,r)|0,t[w>>2]=9,t[w+4>>2]=0,t[r>>2]=t[w>>2],t[r+4>>2]=t[w+4>>2],fl(e,4736,r)|0,t[v>>2]=21,t[v+4>>2]=0,t[r>>2]=t[v>>2],t[r+4>>2]=t[v+4>>2],hd(e,4754,r)|0,t[a>>2]=2,t[a+4>>2]=0,t[r>>2]=t[a>>2],t[r+4>>2]=t[a+4>>2],yc(e,4772,r)|0,t[s>>2]=3,t[s+4>>2]=0,t[r>>2]=t[s>>2],t[r+4>>2]=t[s+4>>2],yc(e,4790,r)|0,t[u>>2]=4,t[u+4>>2]=0,t[r>>2]=t[u>>2],t[r+4>>2]=t[u+4>>2],yc(e,4808,r)|0,y=n}function Tf(e,n){e=e|0,n=n|0;var r=0;r=rf()|0,t[e>>2]=r,Vo(r,n),Zd(t[e>>2]|0)}function $c(e,n,r){return e=e|0,n=n|0,r=r|0,Mt(e,Fr(n)|0,r,0),e|0}function Dh(e,n,r){return e=e|0,n=n|0,r=r|0,d(e,Fr(n)|0,r,0),e|0}function sm(e,n,r){return e=e|0,n=n|0,r=r|0,Q4(e,Fr(n)|0,r,0),e|0}function Vs(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],H4(e,n,s),y=u,e|0}function ma(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],zl(e,n,s),y=u,e|0}function iu(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],p(e,n,s),y=u,e|0}function M0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Rv(e,n,s),y=u,e|0}function u0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],ny(e,n,s),y=u,e|0}function ns(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Gd(e,n,s),y=u,e|0}function Ya(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Vd(e,n,s),y=u,e|0}function uo(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],k0(e,n,s),y=u,e|0}function fl(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Dp(e,n,s),y=u,e|0}function yc(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],bm(e,n,s),y=u,e|0}function M2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],o0(e,n,s),y=u,e|0}function wh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Ad(e,n,s),y=u,e|0}function Cf(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Am(e,n,s),y=u,e|0}function xf(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],$2(e,n,s),y=u,e|0}function e1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],y1(e,n,s),y=u,e|0}function Nl(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Za(e,n,s),y=u,e|0}function t1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],B2(e,n,s),y=u,e|0}function ya(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],L2(e,n,s),y=u,e|0}function hd(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],vd(e,n,s),y=u,e|0}function vd(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],ga(e,r,s,1),y=u}function Fr(e){return e=e|0,e|0}function ga(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=k2()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=n1(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,md(a,u)|0,u),y=s}function k2(){var e=0,n=0;if(h[7616]|0||(cl(9136),Wt(24,9136,ge|0)|0,n=7616,t[n>>2]=1,t[n+4>>2]=0),!(sr(9136)|0)){e=9136,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));cl(9136)}return 9136}function n1(e){return e=e|0,0}function md(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=k2()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],Rf(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Af(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function wi(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0;var v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0;v=y,y=y+32|0,X=v+24|0,b=v+20|0,T=v+16|0,M=v+12|0,L=v+8|0,w=v+4|0,Be=v,t[b>>2]=n,t[T>>2]=r,t[M>>2]=u,t[L>>2]=s,t[w>>2]=a,a=e+28|0,t[Be>>2]=t[a>>2],t[X>>2]=t[Be>>2],N2(e+24|0,X,b,M,L,T,w)|0,t[a>>2]=t[t[a>>2]>>2],y=v}function N2(e,n,r,u,s,a,v){return e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,v=v|0,e=am(n)|0,n=pn(24)|0,yd(n+4|0,t[r>>2]|0,t[u>>2]|0,t[s>>2]|0,t[a>>2]|0,t[v>>2]|0),t[n>>2]=t[e>>2],t[e>>2]=n,n|0}function am(e){return e=e|0,t[e>>2]|0}function yd(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,t[e>>2]=n,t[e+4>>2]=r,t[e+8>>2]=u,t[e+12>>2]=s,t[e+16>>2]=a}function hn(e,n){return e=e|0,n=n|0,n|e|0}function Rf(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Af(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=fm(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Of(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],Rf(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Sh(e,w),cm(w),y=L;return}}function fm(e){return e=e|0,357913941}function Of(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Sh(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function cm(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function cl(e){e=e|0,qo(e)}function r1(e){e=e|0,qn(e+24|0)}function sr(e){return e=e|0,t[e>>2]|0}function qn(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function qo(e){e=e|0;var n=0;n=yr()|0,jn(e,2,3,n,Vn()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function yr(){return 9228}function Vn(){return 1140}function dl(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;return r=y,y=y+16|0,u=r+8|0,s=r,a=Eo(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],n=gc(n,u)|0,y=r,n|0}function jn(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,t[e>>2]=n,t[e+4>>2]=r,t[e+8>>2]=u,t[e+12>>2]=s,t[e+16>>2]=a}function Eo(e){return e=e|0,(t[(k2()|0)+24>>2]|0)+(e*12|0)|0}function gc(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;return s=y,y=y+48|0,u=s,r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),I1[r&31](u,e),u=oo(u)|0,y=s,u|0}function oo(e){e=e|0;var n=0,r=0,u=0,s=0;return s=y,y=y+32|0,n=s+12|0,r=s,u=Pu(Ka()|0)|0,u?(rs(n,u),Mf(r,n),_c(e,r),e=Cs(n)|0):e=Ec(e)|0,y=s,e|0}function Ka(){var e=0;return h[7632]|0||(Nf(9184),Wt(25,9184,ge|0)|0,e=7632,t[e>>2]=1,t[e+4>>2]=0),9184}function Pu(e){return e=e|0,t[e+36>>2]|0}function rs(e,n){e=e|0,n=n|0,t[e>>2]=n,t[e+4>>2]=e,t[e+8>>2]=0}function Mf(e,n){e=e|0,n=n|0,t[e>>2]=t[n>>2],t[e+4>>2]=t[n+4>>2],t[e+8>>2]=0}function _c(e,n){e=e|0,n=n|0,lo(n,e,e+8|0,e+16|0,e+24|0,e+32|0,e+40|0)|0}function Cs(e){return e=e|0,t[(t[e+4>>2]|0)+8>>2]|0}function Ec(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0,T=0;T=y,y=y+16|0,r=T+4|0,u=T,s=Oa(8)|0,a=s,v=pn(48)|0,w=v,n=w+48|0;do t[w>>2]=t[e>>2],w=w+4|0,e=e+4|0;while((w|0)<(n|0));return n=a+4|0,t[n>>2]=v,w=pn(8)|0,v=t[n>>2]|0,t[u>>2]=0,t[r>>2]=t[u>>2],Th(w,v,r),t[s>>2]=w,y=T,a|0}function Th(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,r=pn(16)|0,t[r+4>>2]=0,t[r+8>>2]=0,t[r>>2]=1092,t[r+12>>2]=n,t[e+4>>2]=r}function cn(e){e=e|0,Uv(e),Et(e)}function is(e){e=e|0,e=t[e+12>>2]|0,e|0&&Et(e)}function Do(e){e=e|0,Et(e)}function lo(e,n,r,u,s,a,v){return e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,v=v|0,a=Ji(t[e>>2]|0,n,r,u,s,a,v)|0,v=e+4|0,t[(t[v>>2]|0)+8>>2]=a,t[(t[v>>2]|0)+8>>2]|0}function Ji(e,n,r,u,s,a,v){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,v=v|0;var w=0,T=0;return w=y,y=y+16|0,T=w,Ma(T),e=go(e)|0,v=Gr(e,+j[n>>3],+j[r>>3],+j[u>>3],+j[s>>3],+j[a>>3],+j[v>>3])|0,ka(T),y=w,v|0}function Gr(e,n,r,u,s,a,v){e=e|0,n=+n,r=+r,u=+u,s=+s,a=+a,v=+v;var w=0;return w=_o(kf()|0)|0,n=+kl(n),r=+kl(r),u=+kl(u),s=+kl(s),a=+kl(a),d0(0,w|0,e|0,+n,+r,+u,+s,+a,+ +kl(v))|0}function kf(){var e=0;return h[7624]|0||(dm(9172),e=7624,t[e>>2]=1,t[e+4>>2]=0),9172}function dm(e){e=e|0,ll(e,Ll()|0,6)}function Ll(){return 1112}function Nf(e){e=e|0,Xa(e)}function Lf(e){e=e|0,gd(e+24|0),_d(e+16|0)}function gd(e){e=e|0,i1(e)}function _d(e){e=e|0,Dc(e)}function Dc(e){e=e|0;var n=0,r=0;if(n=t[e>>2]|0,n|0)do r=n,n=t[n>>2]|0,Et(r);while((n|0)!=0);t[e>>2]=0}function i1(e){e=e|0;var n=0,r=0;if(n=t[e>>2]|0,n|0)do r=n,n=t[n>>2]|0,Et(r);while((n|0)!=0);t[e>>2]=0}function Xa(e){e=e|0;var n=0;t[e+16>>2]=0,t[e+20>>2]=0,n=e+24|0,t[n>>2]=0,t[e+28>>2]=n,t[e+36>>2]=0,h[e+40>>0]=0,h[e+41>>0]=0}function L2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Ed(e,r,s,0),y=u}function Ed(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=u1()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Ff(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,o1(a,u)|0,u),y=s}function u1(){var e=0,n=0;if(h[7640]|0||(Fl(9232),Wt(26,9232,ge|0)|0,n=7640,t[n>>2]=1,t[n+4>>2]=0),!(sr(9232)|0)){e=9232,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Fl(9232)}return 9232}function Ff(e){return e=e|0,0}function o1(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=u1()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],Qa(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(l1(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function Qa(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function l1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=F2(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Dd(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],Qa(a,u,r),t[T>>2]=(t[T>>2]|0)+12,wc(e,w),s1(w),y=L;return}}function F2(e){return e=e|0,357913941}function Dd(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function wc(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function s1(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Fl(e){e=e|0,P2(e)}function Ea(e){e=e|0,Ch(e+24|0)}function Ch(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function P2(e){e=e|0;var n=0;n=yr()|0,jn(e,2,1,n,I2()|0,3),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function I2(){return 1144}function xh(e,n,r,u,s){e=e|0,n=n|0,r=+r,u=+u,s=s|0;var a=0,v=0,w=0,T=0;a=y,y=y+16|0,v=a+8|0,w=a,T=pm(e)|0,e=t[T+4>>2]|0,t[w>>2]=t[T>>2],t[w+4>>2]=e,t[v>>2]=t[w>>2],t[v+4>>2]=t[w+4>>2],Rh(n,v,r,u,s),y=a}function pm(e){return e=e|0,(t[(u1()|0)+24>>2]|0)+(e*12|0)|0}function Rh(e,n,r,u,s){e=e|0,n=n|0,r=+r,u=+u,s=s|0;var a=0,v=0,w=0,T=0,L=0;L=y,y=y+16|0,v=L+2|0,w=L+1|0,T=L,a=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(a=t[(t[e>>2]|0)+a>>2]|0),Pl(v,r),r=+us(v,r),Pl(w,u),u=+us(w,u),xs(T,s),T=Gs(T,s)|0,L8[a&1](e,r,u,T),y=L}function Pl(e,n){e=e|0,n=+n}function us(e,n){return e=e|0,n=+n,+ +Ah(n)}function xs(e,n){e=e|0,n=n|0}function Gs(e,n){return e=e|0,n=n|0,b2(n)|0}function b2(e){return e=e|0,e|0}function Ah(e){return e=+e,+e}function B2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],U2(e,r,s,1),y=u}function U2(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=a1()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=f1(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Oh(a,u)|0,u),y=s}function a1(){var e=0,n=0;if(h[7648]|0||(c1(9268),Wt(27,9268,ge|0)|0,n=7648,t[n>>2]=1,t[n+4>>2]=0),!(sr(9268)|0)){e=9268,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));c1(9268)}return 9268}function f1(e){return e=e|0,0}function Oh(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=a1()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],j2(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(z2(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function j2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function z2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Rs(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Ja(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],j2(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Mh(e,w),du(w),y=L;return}}function Rs(e){return e=e|0,357913941}function Ja(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Mh(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function du(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function c1(e){e=e|0,Il(e)}function kh(e){e=e|0,d1(e+24|0)}function d1(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Il(e){e=e|0;var n=0;n=yr()|0,jn(e,2,4,n,Nh()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function Nh(){return 1160}function H2(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;return r=y,y=y+16|0,u=r+8|0,s=r,a=Lh(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],n=p1(n,u)|0,y=r,n|0}function Lh(e){return e=e|0,(t[(a1()|0)+24>>2]|0)+(e*12|0)|0}function p1(e,n){e=e|0,n=n|0;var r=0;return r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),bl(Qp[r&31](e)|0)|0}function bl(e){return e=e|0,e&1|0}function Za(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Da(e,r,s,0),y=u}function Da(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=q2()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=W2(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,hm(a,u)|0,u),y=s}function q2(){var e=0,n=0;if(h[7656]|0||(Ih(9304),Wt(28,9304,ge|0)|0,n=7656,t[n>>2]=1,t[n+4>>2]=0),!(sr(9304)|0)){e=9304,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Ih(9304)}return 9304}function W2(e){return e=e|0,0}function hm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=q2()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],V2(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Fh(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function V2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Fh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Ph(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,G2(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],V2(a,u,r),t[T>>2]=(t[T>>2]|0)+12,vm(e,w),mm(w),y=L;return}}function Ph(e){return e=e|0,357913941}function G2(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function vm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function mm(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Ih(e){e=e|0,h1(e)}function ym(e){e=e|0,Y2(e+24|0)}function Y2(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function h1(e){e=e|0;var n=0;n=yr()|0,jn(e,2,5,n,v1()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function v1(){return 1164}function m1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,s=u+8|0,a=u,v=wa(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],K2(n,s,r),y=u}function wa(e){return e=e|0,(t[(q2()|0)+24>>2]|0)+(e*12|0)|0}function K2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),Ys(s,r),r=Ks(s,r)|0,I1[u&31](e,r),Xs(s),y=a}function Ys(e,n){e=e|0,n=n|0,X2(e,n)}function Ks(e,n){return e=e|0,n=n|0,e|0}function Xs(e){e=e|0,fa(e)}function X2(e,n){e=e|0,n=n|0,Sa(e,n)}function Sa(e,n){e=e|0,n=n|0,t[e>>2]=n}function y1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],wd(e,r,s,0),y=u}function wd(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Sc()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Q2(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,wo(a,u)|0,u),y=s}function Sc(){var e=0,n=0;if(h[7664]|0||(Hh(9340),Wt(29,9340,ge|0)|0,n=7664,t[n>>2]=1,t[n+4>>2]=0),!(sr(9340)|0)){e=9340,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Hh(9340)}return 9340}function Q2(e){return e=e|0,0}function wo(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Sc()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],bh(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Bh(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function bh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Bh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Uh(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,jh(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],bh(a,u,r),t[T>>2]=(t[T>>2]|0)+12,gm(e,w),zh(w),y=L;return}}function Uh(e){return e=e|0,357913941}function jh(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function gm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function zh(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Hh(e){e=e|0,qh(e)}function g1(e){e=e|0,J2(e+24|0)}function J2(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function qh(e){e=e|0;var n=0;n=yr()|0,jn(e,2,4,n,Z2()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function Z2(){return 1180}function Wh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=_m(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],r=Em(n,s,r)|0,y=u,r|0}function _m(e){return e=e|0,(t[(Sc()|0)+24>>2]|0)+(e*12|0)|0}function Em(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;return a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),Pf(s,r),s=If(s,r)|0,s=Sd(bE[u&15](e,s)|0)|0,y=a,s|0}function Pf(e,n){e=e|0,n=n|0}function If(e,n){return e=e|0,n=n|0,Dm(n)|0}function Sd(e){return e=e|0,e|0}function Dm(e){return e=e|0,e|0}function $2(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Td(e,r,s,0),y=u}function Td(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=ep()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Vh(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,tp(a,u)|0,u),y=s}function ep(){var e=0,n=0;if(h[7672]|0||(Kh(9376),Wt(30,9376,ge|0)|0,n=7672,t[n>>2]=1,t[n+4>>2]=0),!(sr(9376)|0)){e=9376,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Kh(9376)}return 9376}function Vh(e){return e=e|0,0}function tp(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=ep()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],Gh(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Yh(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function Gh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Yh(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=np(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,wm(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],Gh(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Sm(e,w),Tm(w),y=L;return}}function np(e){return e=e|0,357913941}function wm(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Sm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Tm(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Kh(e){e=e|0,rp(e)}function _1(e){e=e|0,Cm(e+24|0)}function Cm(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function rp(e){e=e|0;var n=0;n=yr()|0,jn(e,2,5,n,ip()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function ip(){return 1196}function xm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;return r=y,y=y+16|0,u=r+8|0,s=r,a=Rm(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],n=Xh(n,u)|0,y=r,n|0}function Rm(e){return e=e|0,(t[(ep()|0)+24>>2]|0)+(e*12|0)|0}function Xh(e,n){e=e|0,n=n|0;var r=0;return r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),Sd(Qp[r&31](e)|0)|0}function Am(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Om(e,r,s,1),y=u}function Om(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=up()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=op(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Ta(a,u)|0,u),y=s}function up(){var e=0,n=0;if(h[7680]|0||(sp(9412),Wt(31,9412,ge|0)|0,n=7680,t[n>>2]=1,t[n+4>>2]=0),!(sr(9412)|0)){e=9412,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));sp(9412)}return 9412}function op(e){return e=e|0,0}function Ta(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=up()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],E1(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(lp(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function E1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function lp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Qh(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Cd(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],E1(a,u,r),t[T>>2]=(t[T>>2]|0)+12,D1(e,w),Jh(w),y=L;return}}function Qh(e){return e=e|0,357913941}function Cd(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function D1(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Jh(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function sp(e){e=e|0,$h(e)}function Zh(e){e=e|0,ap(e+24|0)}function ap(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function $h(e){e=e|0;var n=0;n=yr()|0,jn(e,2,6,n,ev()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function ev(){return 1200}function fp(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;return r=y,y=y+16|0,u=r+8|0,s=r,a=xd(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],n=Rd(n,u)|0,y=r,n|0}function xd(e){return e=e|0,(t[(up()|0)+24>>2]|0)+(e*12|0)|0}function Rd(e,n){e=e|0,n=n|0;var r=0;return r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),H0(Qp[r&31](e)|0)|0}function H0(e){return e=e|0,e|0}function Ad(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Ca(e,r,s,0),y=u}function Ca(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=$a()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Od(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Md(a,u)|0,u),y=s}function $a(){var e=0,n=0;if(h[7688]|0||(pp(9448),Wt(32,9448,ge|0)|0,n=7688,t[n>>2]=1,t[n+4>>2]=0),!(sr(9448)|0)){e=9448,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));pp(9448)}return 9448}function Od(e){return e=e|0,0}function Md(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=$a()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],cp(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(kd(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function cp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function kd(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=tv(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Mm(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],cp(a,u,r),t[T>>2]=(t[T>>2]|0)+12,nv(e,w),dp(w),y=L;return}}function tv(e){return e=e|0,357913941}function Mm(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function nv(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function dp(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function pp(e){e=e|0,Nm(e)}function hp(e){e=e|0,km(e+24|0)}function km(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Nm(e){e=e|0;var n=0;n=yr()|0,jn(e,2,6,n,So()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function So(){return 1204}function Nd(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,s=u+8|0,a=u,v=Lm(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],pl(n,s,r),y=u}function Lm(e){return e=e|0,(t[($a()|0)+24>>2]|0)+(e*12|0)|0}function pl(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),tr(s,r),s=Qs(s,r)|0,I1[u&31](e,s),y=a}function tr(e,n){e=e|0,n=n|0}function Qs(e,n){return e=e|0,n=n|0,hl(n)|0}function hl(e){return e=e|0,e|0}function o0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],rv(e,r,s,0),y=u}function rv(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Js()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=vp(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Fm(a,u)|0,u),y=s}function Js(){var e=0,n=0;if(h[7696]|0||(gp(9484),Wt(33,9484,ge|0)|0,n=7696,t[n>>2]=1,t[n+4>>2]=0),!(sr(9484)|0)){e=9484,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));gp(9484)}return 9484}function vp(e){return e=e|0,0}function Fm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Js()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],iv(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(mp(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function iv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function mp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Pm(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,yp(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],iv(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Tc(e,w),xa(w),y=L;return}}function Pm(e){return e=e|0,357913941}function yp(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Tc(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function xa(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function gp(e){e=e|0,Gu(e)}function Ld(e){e=e|0,Iu(e+24|0)}function Iu(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Gu(e){e=e|0;var n=0;n=yr()|0,jn(e,2,1,n,_p()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function _p(){return 1212}function Ep(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;s=y,y=y+16|0,a=s+8|0,v=s,w=uv(e)|0,e=t[w+4>>2]|0,t[v>>2]=t[w>>2],t[v+4>>2]=e,t[a>>2]=t[v>>2],t[a+4>>2]=t[v+4>>2],Im(n,a,r,u),y=s}function uv(e){return e=e|0,(t[(Js()|0)+24>>2]|0)+(e*12|0)|0}function Im(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;w=y,y=y+16|0,a=w+1|0,v=w,s=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(s=t[(t[e>>2]|0)+s>>2]|0),tr(a,r),a=Qs(a,r)|0,Pf(v,u),v=If(v,u)|0,Fy[s&15](e,a,v),y=w}function bm(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Bm(e,r,s,1),y=u}function Bm(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Fd()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=ov(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Cc(a,u)|0,u),y=s}function Fd(){var e=0,n=0;if(h[7704]|0||(lv(9520),Wt(34,9520,ge|0)|0,n=7704,t[n>>2]=1,t[n+4>>2]=0),!(sr(9520)|0)){e=9520,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));lv(9520)}return 9520}function ov(e){return e=e|0,0}function Cc(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Fd()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],w1(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Um(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function w1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Um(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Pd(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,S1(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],w1(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Bl(e,w),Ra(w),y=L;return}}function Pd(e){return e=e|0,357913941}function S1(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Bl(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Ra(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function lv(e){e=e|0,av(e)}function jm(e){e=e|0,sv(e+24|0)}function sv(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function av(e){e=e|0;var n=0;n=yr()|0,jn(e,2,1,n,zm()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function zm(){return 1224}function fv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;return s=y,y=y+16|0,a=s+8|0,v=s,w=Aa(e)|0,e=t[w+4>>2]|0,t[v>>2]=t[w>>2],t[v+4>>2]=e,t[a>>2]=t[v>>2],t[a+4>>2]=t[v+4>>2],u=+Mr(n,a,r),y=s,+u}function Aa(e){return e=e|0,(t[(Fd()|0)+24>>2]|0)+(e*12|0)|0}function Mr(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),xs(s,r),s=Gs(s,r)|0,v=+Ga(+P8[u&7](e,s)),y=a,+v}function Dp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],vl(e,r,s,1),y=u}function vl(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=yu()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=T1(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Ui(a,u)|0,u),y=s}function yu(){var e=0,n=0;if(h[7712]|0||(Sp(9556),Wt(35,9556,ge|0)|0,n=7712,t[n>>2]=1,t[n+4>>2]=0),!(sr(9556)|0)){e=9556,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Sp(9556)}return 9556}function T1(e){return e=e|0,0}function Ui(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=yu()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],wp(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Id(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function wp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Id(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=To(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,As(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],wp(a,u,r),t[T>>2]=(t[T>>2]|0)+12,bf(e,w),bd(w),y=L;return}}function To(e){return e=e|0,357913941}function As(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function bf(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function bd(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Sp(e){e=e|0,Tp(e)}function C1(e){e=e|0,x1(e+24|0)}function x1(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Tp(e){e=e|0;var n=0;n=yr()|0,jn(e,2,5,n,nr()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function nr(){return 1232}function ml(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=Gn(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],r=+q0(n,s),y=u,+r}function Gn(e){return e=e|0,(t[(yu()|0)+24>>2]|0)+(e*12|0)|0}function q0(e,n){e=e|0,n=n|0;var r=0;return r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),+ +Ga(+F8[r&15](e))}function k0(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Bd(e,r,s,1),y=u}function Bd(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Ul()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=R1(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,xc(a,u)|0,u),y=s}function Ul(){var e=0,n=0;if(h[7720]|0||(zd(9592),Wt(36,9592,ge|0)|0,n=7720,t[n>>2]=1,t[n+4>>2]=0),!(sr(9592)|0)){e=9592,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));zd(9592)}return 9592}function R1(e){return e=e|0,0}function xc(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Ul()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],Rc(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Ud(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function Rc(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Ud(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Cp(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,N0(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],Rc(a,u,r),t[T>>2]=(t[T>>2]|0)+12,dn(e,w),jd(w),y=L;return}}function Cp(e){return e=e|0,357913941}function N0(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function dn(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function jd(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function zd(e){e=e|0,Mc(e)}function Ac(e){e=e|0,Oc(e+24|0)}function Oc(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Mc(e){e=e|0;var n=0;n=yr()|0,jn(e,2,7,n,A1()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function A1(){return 1276}function xp(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;return r=y,y=y+16|0,u=r+8|0,s=r,a=ef(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],n=Hm(n,u)|0,y=r,n|0}function ef(e){return e=e|0,(t[(Ul()|0)+24>>2]|0)+(e*12|0)|0}function Hm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;return s=y,y=y+16|0,u=s,r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),I1[r&31](u,e),u=kc(u)|0,y=s,u|0}function kc(e){e=e|0;var n=0,r=0,u=0,s=0;return s=y,y=y+32|0,n=s+12|0,r=s,u=Pu(Hd()|0)|0,u?(rs(n,u),Mf(r,n),cv(e,r),e=Cs(n)|0):e=O1(e)|0,y=s,e|0}function Hd(){var e=0;return h[7736]|0||(Wo(9640),Wt(25,9640,ge|0)|0,e=7736,t[e>>2]=1,t[e+4>>2]=0),9640}function cv(e,n){e=e|0,n=n|0,Nc(n,e,e+8|0)|0}function O1(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0;return r=y,y=y+16|0,s=r+4|0,v=r,u=Oa(8)|0,n=u,w=pn(16)|0,t[w>>2]=t[e>>2],t[w+4>>2]=t[e+4>>2],t[w+8>>2]=t[e+8>>2],t[w+12>>2]=t[e+12>>2],a=n+4|0,t[a>>2]=w,e=pn(8)|0,a=t[a>>2]|0,t[v>>2]=0,t[s>>2]=t[v>>2],Bf(e,a,s),t[u>>2]=e,y=r,n|0}function Bf(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,r=pn(16)|0,t[r+4>>2]=0,t[r+8>>2]=0,t[r>>2]=1244,t[r+12>>2]=n,t[e+4>>2]=r}function Uf(e){e=e|0,Uv(e),Et(e)}function M1(e){e=e|0,e=t[e+12>>2]|0,e|0&&Et(e)}function jl(e){e=e|0,Et(e)}function Nc(e,n,r){return e=e|0,n=n|0,r=r|0,n=jf(t[e>>2]|0,n,r)|0,r=e+4|0,t[(t[r>>2]|0)+8>>2]=n,t[(t[r>>2]|0)+8>>2]|0}function jf(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;return u=y,y=y+16|0,s=u,Ma(s),e=go(e)|0,r=qm(e,t[n>>2]|0,+j[r>>3])|0,ka(s),y=u,r|0}function qm(e,n,r){e=e|0,n=n|0,r=+r;var u=0;return u=_o(yl()|0)|0,n=sd(n)|0,Hr(0,u|0,e|0,n|0,+ +kl(r))|0}function yl(){var e=0;return h[7728]|0||(qd(9628),e=7728,t[e>>2]=1,t[e+4>>2]=0),9628}function qd(e){e=e|0,ll(e,Wd()|0,2)}function Wd(){return 1264}function Wo(e){e=e|0,Xa(e)}function Vd(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Wm(e,r,s,1),y=u}function Wm(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=k1()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Vm(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Gm(a,u)|0,u),y=s}function k1(){var e=0,n=0;if(h[7744]|0||(hv(9684),Wt(37,9684,ge|0)|0,n=7744,t[n>>2]=1,t[n+4>>2]=0),!(sr(9684)|0)){e=9684,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));hv(9684)}return 9684}function Vm(e){return e=e|0,0}function Gm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=k1()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],dv(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Ym(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function dv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Ym(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=pv(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Km(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],dv(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Xm(e,w),Qm(w),y=L;return}}function pv(e){return e=e|0,357913941}function Km(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Xm(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Qm(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function hv(e){e=e|0,Zm(e)}function Jm(e){e=e|0,Rp(e+24|0)}function Rp(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Zm(e){e=e|0;var n=0;n=yr()|0,jn(e,2,5,n,zf()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function zf(){return 1280}function vv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=mv(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],r=yv(n,s,r)|0,y=u,r|0}function mv(e){return e=e|0,(t[(k1()|0)+24>>2]|0)+(e*12|0)|0}function yv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return v=y,y=y+32|0,s=v,a=v+16|0,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),xs(a,r),a=Gs(a,r)|0,Fy[u&15](s,e,a),a=kc(s)|0,y=v,a|0}function Gd(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Yd(e,r,s,1),y=u}function Yd(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Ap()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=gv(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Kd(a,u)|0,u),y=s}function Ap(){var e=0,n=0;if(h[7752]|0||(Sv(9720),Wt(38,9720,ge|0)|0,n=7752,t[n>>2]=1,t[n+4>>2]=0),!(sr(9720)|0)){e=9720,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Sv(9720)}return 9720}function gv(e){return e=e|0,0}function Kd(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Ap()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],_v(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Ev(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function _v(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Ev(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Op(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Dv(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],_v(a,u,r),t[T>>2]=(t[T>>2]|0)+12,wv(e,w),$m(w),y=L;return}}function Op(e){return e=e|0,357913941}function Dv(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function wv(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function $m(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Sv(e){e=e|0,Tv(e)}function ey(e){e=e|0,Xd(e+24|0)}function Xd(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Tv(e){e=e|0;var n=0;n=yr()|0,jn(e,2,8,n,Mp()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function Mp(){return 1288}function ty(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;return r=y,y=y+16|0,u=r+8|0,s=r,a=l0(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],n=kp(n,u)|0,y=r,n|0}function l0(e){return e=e|0,(t[(Ap()|0)+24>>2]|0)+(e*12|0)|0}function kp(e,n){e=e|0,n=n|0;var r=0;return r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),cd(Qp[r&31](e)|0)|0}function ny(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],ry(e,r,s,0),y=u}function ry(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Np()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=tf(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Lp(a,u)|0,u),y=s}function Np(){var e=0,n=0;if(h[7760]|0||(Ip(9756),Wt(39,9756,ge|0)|0,n=7760,t[n>>2]=1,t[n+4>>2]=0),!(sr(9756)|0)){e=9756,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Ip(9756)}return 9756}function tf(e){return e=e|0,0}function Lp(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Np()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],Fp(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(Pp(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function Fp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function Pp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=iy(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,uy(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],Fp(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Cv(e,w),Hf(w),y=L;return}}function iy(e){return e=e|0,357913941}function uy(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Cv(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Hf(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Ip(e){e=e|0,ly(e)}function xv(e){e=e|0,oy(e+24|0)}function oy(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function ly(e){e=e|0;var n=0;n=yr()|0,jn(e,2,8,n,bp()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function bp(){return 1292}function Bp(e,n,r){e=e|0,n=n|0,r=+r;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,s=u+8|0,a=u,v=sy(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],ay(n,s,r),y=u}function sy(e){return e=e|0,(t[(Np()|0)+24>>2]|0)+(e*12|0)|0}function ay(e,n,r){e=e|0,n=n|0,r=+r;var u=0,s=0,a=0;a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),Pl(s,r),r=+us(s,r),k8[u&31](e,r),y=a}function Rv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Up(e,r,s,0),y=u}function Up(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=jp()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Qd(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,fy(a,u)|0,u),y=s}function jp(){var e=0,n=0;if(h[7768]|0||(zp(9792),Wt(40,9792,ge|0)|0,n=7768,t[n>>2]=1,t[n+4>>2]=0),!(sr(9792)|0)){e=9792,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));zp(9792)}return 9792}function Qd(e){return e=e|0,0}function fy(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=jp()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],N1(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(cy(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function N1(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function cy(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Av(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Ov(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],N1(a,u,r),t[T>>2]=(t[T>>2]|0)+12,dy(e,w),qf(w),y=L;return}}function Av(e){return e=e|0,357913941}function Ov(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function dy(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function qf(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function zp(e){e=e|0,hy(e)}function Mv(e){e=e|0,py(e+24|0)}function py(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function hy(e){e=e|0;var n=0;n=yr()|0,jn(e,2,1,n,Hp()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function Hp(){return 1300}function vy(e,n,r,u){e=e|0,n=n|0,r=r|0,u=+u;var s=0,a=0,v=0,w=0;s=y,y=y+16|0,a=s+8|0,v=s,w=Zs(e)|0,e=t[w+4>>2]|0,t[v>>2]=t[w>>2],t[v+4>>2]=e,t[a>>2]=t[v>>2],t[a+4>>2]=t[v+4>>2],my(n,a,r,u),y=s}function Zs(e){return e=e|0,(t[(jp()|0)+24>>2]|0)+(e*12|0)|0}function my(e,n,r,u){e=e|0,n=n|0,r=r|0,u=+u;var s=0,a=0,v=0,w=0;w=y,y=y+16|0,a=w+1|0,v=w,s=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(s=t[(t[e>>2]|0)+s>>2]|0),xs(a,r),a=Gs(a,r)|0,Pl(v,u),u=+us(v,u),U8[s&15](e,a,u),y=w}function p(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],m(e,r,s,0),y=u}function m(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=R()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=I(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,W(a,u)|0,u),y=s}function R(){var e=0,n=0;if(h[7776]|0||(Ot(9828),Wt(41,9828,ge|0)|0,n=7776,t[n>>2]=1,t[n+4>>2]=0),!(sr(9828)|0)){e=9828,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Ot(9828)}return 9828}function I(e){return e=e|0,0}function W(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=R()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],te(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(pe(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function te(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function pe(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Ee(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,be(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],te(a,u,r),t[T>>2]=(t[T>>2]|0)+12,Dt(e,w),Tt(w),y=L;return}}function Ee(e){return e=e|0,357913941}function be(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function Dt(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Tt(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Ot(e){e=e|0,rr(e)}function on(e){e=e|0,Mn(e+24|0)}function Mn(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function rr(e){e=e|0;var n=0;n=yr()|0,jn(e,2,7,n,br()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function br(){return 1312}function ar(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,s=u+8|0,a=u,v=ri(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],fi(n,s,r),y=u}function ri(e){return e=e|0,(t[(R()|0)+24>>2]|0)+(e*12|0)|0}function fi(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),xs(s,r),s=Gs(s,r)|0,I1[u&31](e,s),y=a}function zl(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Zi(e,r,s,0),y=u}function Zi(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=so()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=s0(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,Os(a,u)|0,u),y=s}function so(){var e=0,n=0;if(h[7784]|0||(Vg(9864),Wt(42,9864,ge|0)|0,n=7784,t[n>>2]=1,t[n+4>>2]=0),!(sr(9864)|0)){e=9864,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Vg(9864)}return 9864}function s0(e){return e=e|0,0}function Os(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=so()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],Co(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(kv(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function Co(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function kv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=F4(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,yy(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],Co(a,u,r),t[T>>2]=(t[T>>2]|0)+12,gy(e,w),nf(w),y=L;return}}function F4(e){return e=e|0,357913941}function yy(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function gy(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function nf(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Vg(e){e=e|0,b4(e)}function P4(e){e=e|0,I4(e+24|0)}function I4(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function b4(e){e=e|0;var n=0;n=yr()|0,jn(e,2,8,n,B4()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function B4(){return 1320}function _y(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,s=u+8|0,a=u,v=U4(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],j4(n,s,r),y=u}function U4(e){return e=e|0,(t[(so()|0)+24>>2]|0)+(e*12|0)|0}function j4(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),Ey(s,r),s=Gg(s,r)|0,I1[u&31](e,s),y=a}function Ey(e,n){e=e|0,n=n|0}function Gg(e,n){return e=e|0,n=n|0,z4(n)|0}function z4(e){return e=e|0,e|0}function H4(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],Yg(e,r,s,0),y=u}function Yg(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=Wf()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=Kg(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,q4(a,u)|0,u),y=s}function Wf(){var e=0,n=0;if(h[7792]|0||(Sy(9900),Wt(43,9900,ge|0)|0,n=7792,t[n>>2]=1,t[n+4>>2]=0),!(sr(9900)|0)){e=9900,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Sy(9900)}return 9900}function Kg(e){return e=e|0,0}function q4(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=Wf()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],qp(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(W4(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function qp(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function W4(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=Nv(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,Dy(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],qp(a,u,r),t[T>>2]=(t[T>>2]|0)+12,wy(e,w),V4(w),y=L;return}}function Nv(e){return e=e|0,357913941}function Dy(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function wy(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function V4(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function Sy(e){e=e|0,Xg(e)}function G4(e){e=e|0,Y4(e+24|0)}function Y4(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Xg(e){e=e|0;var n=0;n=yr()|0,jn(e,2,22,n,K4()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function K4(){return 1344}function X4(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0;r=y,y=y+16|0,u=r+8|0,s=r,a=Qg(e)|0,e=t[a+4>>2]|0,t[s>>2]=t[a>>2],t[s+4>>2]=e,t[u>>2]=t[s>>2],t[u+4>>2]=t[s+4>>2],Lv(n,u),y=r}function Qg(e){return e=e|0,(t[(Wf()|0)+24>>2]|0)+(e*12|0)|0}function Lv(e,n){e=e|0,n=n|0;var r=0;r=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(r=t[(t[e>>2]|0)+r>>2]|0),P1[r&127](e)}function Q4(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=Ty()|0,e=J4(r)|0,wi(a,n,s,e,Z4(r,u)|0,u)}function Ty(){var e=0,n=0;if(h[7800]|0||(xy(9936),Wt(44,9936,ge|0)|0,n=7800,t[n>>2]=1,t[n+4>>2]=0),!(sr(9936)|0)){e=9936,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));xy(9936)}return 9936}function J4(e){return e=e|0,e|0}function Z4(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=Ty()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(Cy(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(Jg(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function Cy(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function Jg(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=Zg(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,$g(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,Cy(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,e_(e,s),t_(s),y=w;return}}function Zg(e){return e=e|0,536870911}function $g(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function e_(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function t_(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function xy(e){e=e|0,r_(e)}function n_(e){e=e|0,$4(e+24|0)}function $4(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function r_(e){e=e|0;var n=0;n=yr()|0,jn(e,1,23,n,So()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function eE(e,n){e=e|0,n=n|0,c(t[(tE(e)|0)>>2]|0,n)}function tE(e){return e=e|0,(t[(Ty()|0)+24>>2]|0)+(e<<3)|0}function c(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,tr(u,n),n=Qs(u,n)|0,P1[e&127](n),y=r}function d(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=D()|0,e=C(r)|0,wi(a,n,s,e,O(r,u)|0,u)}function D(){var e=0,n=0;if(h[7808]|0||(ht(9972),Wt(45,9972,ge|0)|0,n=7808,t[n>>2]=1,t[n+4>>2]=0),!(sr(9972)|0)){e=9972,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));ht(9972)}return 9972}function C(e){return e=e|0,e|0}function O(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=D()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(z(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(G(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function z(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function G(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=ne(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,se(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,z(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,Ue(e,s),Xe(s),y=w;return}}function ne(e){return e=e|0,536870911}function se(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function Ue(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Xe(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function ht(e){e=e|0,Ht(e)}function Lt(e){e=e|0,Gt(e+24|0)}function Gt(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function Ht(e){e=e|0;var n=0;n=yr()|0,jn(e,1,9,n,yn()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function yn(){return 1348}function kr(e,n){return e=e|0,n=n|0,Oi(t[(ii(e)|0)>>2]|0,n)|0}function ii(e){return e=e|0,(t[(D()|0)+24>>2]|0)+(e<<3)|0}function Oi(e,n){e=e|0,n=n|0;var r=0,u=0;return r=y,y=y+16|0,u=r,L0(u,n),n=$i(u,n)|0,n=Sd(Qp[e&31](n)|0)|0,y=r,n|0}function L0(e,n){e=e|0,n=n|0}function $i(e,n){return e=e|0,n=n|0,lt(n)|0}function lt(e){return e=e|0,e|0}function Mt(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=$e()|0,e=jt(r)|0,wi(a,n,s,e,Fn(r,u)|0,u)}function $e(){var e=0,n=0;if(h[7816]|0||(Yr(10008),Wt(46,10008,ge|0)|0,n=7816,t[n>>2]=1,t[n+4>>2]=0),!(sr(10008)|0)){e=10008,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Yr(10008)}return 10008}function jt(e){return e=e|0,e|0}function Fn(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=$e()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(vn(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(Vi(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function vn(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function Vi(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=ci(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,Yu(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,vn(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,hr(e,s),pu(s),y=w;return}}function ci(e){return e=e|0,536870911}function Yu(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function hr(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function pu(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function Yr(e){e=e|0,W0(e)}function Cu(e){e=e|0,D0(e+24|0)}function D0(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function W0(e){e=e|0;var n=0;n=yr()|0,jn(e,1,15,n,ip()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function Ms(e){return e=e|0,gl(t[(Ku(e)|0)>>2]|0)|0}function Ku(e){return e=e|0,(t[($e()|0)+24>>2]|0)+(e<<3)|0}function gl(e){return e=e|0,Sd(E_[e&7]()|0)|0}function rf(){var e=0;return h[7832]|0||(u_(10052),Wt(25,10052,ge|0)|0,e=7832,t[e>>2]=1,t[e+4>>2]=0),10052}function Vo(e,n){e=e|0,n=n|0,t[e>>2]=ks()|0,t[e+4>>2]=Jd()|0,t[e+12>>2]=n,t[e+8>>2]=Vf()|0,t[e+32>>2]=2}function ks(){return 11709}function Jd(){return 1188}function Vf(){return L1()|0}function Lc(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(Go(r),Et(r)):n|0&&(Ds(n),Et(n))}function Hl(e,n){return e=e|0,n=n|0,n&e|0}function Go(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function L1(){var e=0;return h[7824]|0||(t[2511]=i_()|0,t[2512]=0,e=7824,t[e>>2]=1,t[e+4>>2]=0),10044}function i_(){return 0}function u_(e){e=e|0,Xa(e)}function nE(e){e=e|0;var n=0,r=0,u=0,s=0,a=0;n=y,y=y+32|0,r=n+24|0,a=n+16|0,s=n+8|0,u=n,o_(e,4827),rE(e,4834,3)|0,iE(e,3682,47)|0,t[a>>2]=9,t[a+4>>2]=0,t[r>>2]=t[a>>2],t[r+4>>2]=t[a+4>>2],Ry(e,4841,r)|0,t[s>>2]=1,t[s+4>>2]=0,t[r>>2]=t[s>>2],t[r+4>>2]=t[s+4>>2],l_(e,4871,r)|0,t[u>>2]=10,t[u+4>>2]=0,t[r>>2]=t[u>>2],t[r+4>>2]=t[u+4>>2],uE(e,4891,r)|0,y=n}function o_(e,n){e=e|0,n=n|0;var r=0;r=PR()|0,t[e>>2]=r,IR(r,n),Zd(t[e>>2]|0)}function rE(e,n,r){return e=e|0,n=n|0,r=r|0,_R(e,Fr(n)|0,r,0),e|0}function iE(e,n,r){return e=e|0,n=n|0,r=r|0,iR(e,Fr(n)|0,r,0),e|0}function Ry(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],U9(e,n,s),y=u,e|0}function l_(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],E9(e,n,s),y=u,e|0}function uE(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=t[r+4>>2]|0,t[a>>2]=t[r>>2],t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],oE(e,n,s),y=u,e|0}function oE(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],lE(e,r,s,1),y=u}function lE(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=sE()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=o9(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,l9(a,u)|0,u),y=s}function sE(){var e=0,n=0;if(h[7840]|0||(hw(10100),Wt(48,10100,ge|0)|0,n=7840,t[n>>2]=1,t[n+4>>2]=0),!(sr(10100)|0)){e=10100,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));hw(10100)}return 10100}function o9(e){return e=e|0,0}function l9(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=sE()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],pw(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(s9(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function pw(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function s9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=a9(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,f9(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],pw(a,u,r),t[T>>2]=(t[T>>2]|0)+12,c9(e,w),d9(w),y=L;return}}function a9(e){return e=e|0,357913941}function f9(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function c9(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function d9(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function hw(e){e=e|0,v9(e)}function p9(e){e=e|0,h9(e+24|0)}function h9(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function v9(e){e=e|0;var n=0;n=yr()|0,jn(e,2,6,n,m9()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function m9(){return 1364}function y9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;return u=y,y=y+16|0,s=u+8|0,a=u,v=g9(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],r=_9(n,s,r)|0,y=u,r|0}function g9(e){return e=e|0,(t[(sE()|0)+24>>2]|0)+(e*12|0)|0}function _9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;return a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),xs(s,r),s=Gs(s,r)|0,s=bl(bE[u&15](e,s)|0)|0,y=a,s|0}function E9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],D9(e,r,s,0),y=u}function D9(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=aE()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=w9(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,S9(a,u)|0,u),y=s}function aE(){var e=0,n=0;if(h[7848]|0||(mw(10136),Wt(49,10136,ge|0)|0,n=7848,t[n>>2]=1,t[n+4>>2]=0),!(sr(10136)|0)){e=10136,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));mw(10136)}return 10136}function w9(e){return e=e|0,0}function S9(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=aE()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],vw(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(T9(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function vw(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function T9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=C9(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,x9(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],vw(a,u,r),t[T>>2]=(t[T>>2]|0)+12,R9(e,w),A9(w),y=L;return}}function C9(e){return e=e|0,357913941}function x9(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function R9(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function A9(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function mw(e){e=e|0,k9(e)}function O9(e){e=e|0,M9(e+24|0)}function M9(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function k9(e){e=e|0;var n=0;n=yr()|0,jn(e,2,9,n,N9()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function N9(){return 1372}function L9(e,n,r){e=e|0,n=n|0,r=+r;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,s=u+8|0,a=u,v=F9(e)|0,e=t[v+4>>2]|0,t[a>>2]=t[v>>2],t[a+4>>2]=e,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],P9(n,s,r),y=u}function F9(e){return e=e|0,(t[(aE()|0)+24>>2]|0)+(e*12|0)|0}function P9(e,n,r){e=e|0,n=n|0,r=+r;var u=0,s=0,a=0,v=Ct;a=y,y=y+16|0,s=a,u=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(u=t[(t[e>>2]|0)+u>>2]|0),I9(s,r),v=S(b9(s,r)),M8[u&1](e,v),y=a}function I9(e,n){e=e|0,n=+n}function b9(e,n){return e=e|0,n=+n,S(B9(n))}function B9(e){return e=+e,S(e)}function U9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,s=u+8|0,a=u,w=t[r>>2]|0,v=t[r+4>>2]|0,r=Fr(n)|0,t[a>>2]=w,t[a+4>>2]=v,t[s>>2]=t[a>>2],t[s+4>>2]=t[a+4>>2],j9(e,r,s,0),y=u}function j9(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0,T=0,L=0,M=0;s=y,y=y+32|0,a=s+16|0,M=s+8|0,w=s,L=t[r>>2]|0,T=t[r+4>>2]|0,v=t[e>>2]|0,e=fE()|0,t[M>>2]=L,t[M+4>>2]=T,t[a>>2]=t[M>>2],t[a+4>>2]=t[M+4>>2],r=z9(a)|0,t[w>>2]=L,t[w+4>>2]=T,t[a>>2]=t[w>>2],t[a+4>>2]=t[w+4>>2],wi(v,n,e,r,H9(a,u)|0,u),y=s}function fE(){var e=0,n=0;if(h[7856]|0||(gw(10172),Wt(50,10172,ge|0)|0,n=7856,t[n>>2]=1,t[n+4>>2]=0),!(sr(10172)|0)){e=10172,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));gw(10172)}return 10172}function z9(e){return e=e|0,0}function H9(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0;return M=y,y=y+32|0,s=M+24|0,v=M+16|0,w=M,T=M+8|0,a=t[e>>2]|0,u=t[e+4>>2]|0,t[w>>2]=a,t[w+4>>2]=u,b=fE()|0,L=b+24|0,e=hn(n,4)|0,t[T>>2]=e,n=b+28|0,r=t[n>>2]|0,r>>>0<(t[b+32>>2]|0)>>>0?(t[v>>2]=a,t[v+4>>2]=u,t[s>>2]=t[v>>2],t[s+4>>2]=t[v+4>>2],yw(r,s,e),e=(t[n>>2]|0)+12|0,t[n>>2]=e):(q9(L,w,T),e=t[n>>2]|0),y=M,((e-(t[L>>2]|0)|0)/12|0)+-1|0}function yw(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=t[n+4>>2]|0,t[e>>2]=t[n>>2],t[e+4>>2]=u,t[e+8>>2]=r}function q9(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;if(L=y,y=y+48|0,u=L+32|0,v=L+24|0,w=L,T=e+4|0,s=(((t[T>>2]|0)-(t[e>>2]|0)|0)/12|0)+1|0,a=W9(e)|0,a>>>0<s>>>0)di(e);else{M=t[e>>2]|0,X=((t[e+8>>2]|0)-M|0)/12|0,b=X<<1,V9(w,X>>>0<a>>>1>>>0?b>>>0<s>>>0?s:b:a,((t[T>>2]|0)-M|0)/12|0,e+8|0),T=w+8|0,a=t[T>>2]|0,s=t[n+4>>2]|0,r=t[r>>2]|0,t[v>>2]=t[n>>2],t[v+4>>2]=s,t[u>>2]=t[v>>2],t[u+4>>2]=t[v+4>>2],yw(a,u,r),t[T>>2]=(t[T>>2]|0)+12,G9(e,w),Y9(w),y=L;return}}function W9(e){return e=e|0,357913941}function V9(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>357913941)$n();else{s=pn(n*12|0)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r*12|0)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n*12|0)}function G9(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(((s|0)/-12|0)*12|0)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Y9(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~(((u+-12-n|0)>>>0)/12|0)*12|0)),e=t[e>>2]|0,e|0&&Et(e)}function gw(e){e=e|0,Q9(e)}function K9(e){e=e|0,X9(e+24|0)}function X9(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~(((n+-12-u|0)>>>0)/12|0)*12|0)),Et(r))}function Q9(e){e=e|0;var n=0;n=yr()|0,jn(e,2,3,n,J9()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function J9(){return 1380}function Z9(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;s=y,y=y+16|0,a=s+8|0,v=s,w=$9(e)|0,e=t[w+4>>2]|0,t[v>>2]=t[w>>2],t[v+4>>2]=e,t[a>>2]=t[v>>2],t[a+4>>2]=t[v+4>>2],eR(n,a,r,u),y=s}function $9(e){return e=e|0,(t[(fE()|0)+24>>2]|0)+(e*12|0)|0}function eR(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;w=y,y=y+16|0,a=w+1|0,v=w,s=t[n>>2]|0,n=t[n+4>>2]|0,e=e+(n>>1)|0,n&1&&(s=t[(t[e>>2]|0)+s>>2]|0),xs(a,r),a=Gs(a,r)|0,tR(v,u),v=nR(v,u)|0,Fy[s&15](e,a,v),y=w}function tR(e,n){e=e|0,n=n|0}function nR(e,n){return e=e|0,n=n|0,rR(n)|0}function rR(e){return e=e|0,(e|0)!=0|0}function iR(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=cE()|0,e=uR(r)|0,wi(a,n,s,e,oR(r,u)|0,u)}function cE(){var e=0,n=0;if(h[7864]|0||(Ew(10208),Wt(51,10208,ge|0)|0,n=7864,t[n>>2]=1,t[n+4>>2]=0),!(sr(10208)|0)){e=10208,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Ew(10208)}return 10208}function uR(e){return e=e|0,e|0}function oR(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=cE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(_w(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(lR(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function _w(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function lR(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=sR(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,aR(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,_w(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,fR(e,s),cR(s),y=w;return}}function sR(e){return e=e|0,536870911}function aR(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function fR(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function cR(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function Ew(e){e=e|0,hR(e)}function dR(e){e=e|0,pR(e+24|0)}function pR(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function hR(e){e=e|0;var n=0;n=yr()|0,jn(e,1,24,n,vR()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function vR(){return 1392}function mR(e,n){e=e|0,n=n|0,gR(t[(yR(e)|0)>>2]|0,n)}function yR(e){return e=e|0,(t[(cE()|0)+24>>2]|0)+(e<<3)|0}function gR(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,L0(u,n),n=$i(u,n)|0,P1[e&127](n),y=r}function _R(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=dE()|0,e=ER(r)|0,wi(a,n,s,e,DR(r,u)|0,u)}function dE(){var e=0,n=0;if(h[7872]|0||(ww(10244),Wt(52,10244,ge|0)|0,n=7872,t[n>>2]=1,t[n+4>>2]=0),!(sr(10244)|0)){e=10244,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));ww(10244)}return 10244}function ER(e){return e=e|0,e|0}function DR(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=dE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(Dw(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(wR(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function Dw(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function wR(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=SR(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,TR(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,Dw(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,CR(e,s),xR(s),y=w;return}}function SR(e){return e=e|0,536870911}function TR(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function CR(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function xR(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function ww(e){e=e|0,OR(e)}function RR(e){e=e|0,AR(e+24|0)}function AR(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function OR(e){e=e|0;var n=0;n=yr()|0,jn(e,1,16,n,MR()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function MR(){return 1400}function kR(e){return e=e|0,LR(t[(NR(e)|0)>>2]|0)|0}function NR(e){return e=e|0,(t[(dE()|0)+24>>2]|0)+(e<<3)|0}function LR(e){return e=e|0,FR(E_[e&7]()|0)|0}function FR(e){return e=e|0,e|0}function PR(){var e=0;return h[7880]|0||(HR(10280),Wt(25,10280,ge|0)|0,e=7880,t[e>>2]=1,t[e+4>>2]=0),10280}function IR(e,n){e=e|0,n=n|0,t[e>>2]=bR()|0,t[e+4>>2]=BR()|0,t[e+12>>2]=n,t[e+8>>2]=UR()|0,t[e+32>>2]=4}function bR(){return 11711}function BR(){return 1356}function UR(){return L1()|0}function jR(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(zR(r),Et(r)):n|0&&(ro(n),Et(n))}function zR(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function HR(e){e=e|0,Xa(e)}function qR(e){e=e|0,WR(e,4920),VR(e)|0,GR(e)|0}function WR(e,n){e=e|0,n=n|0;var r=0;r=Hd()|0,t[e>>2]=r,pA(r,n),Zd(t[e>>2]|0)}function VR(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,rA()|0),e|0}function GR(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,YR()|0),e|0}function YR(){var e=0;return h[7888]|0||(Sw(10328),Wt(53,10328,ge|0)|0,e=7888,t[e>>2]=1,t[e+4>>2]=0),sr(10328)|0||Sw(10328),10328}function Wp(e,n){e=e|0,n=n|0,wi(e,0,n,0,0,0)}function Sw(e){e=e|0,QR(e),Vp(e,10)}function KR(e){e=e|0,XR(e+24|0)}function XR(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function QR(e){e=e|0;var n=0;n=yr()|0,jn(e,5,1,n,eA()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function JR(e,n,r){e=e|0,n=n|0,r=+r,ZR(e,n,r)}function Vp(e,n){e=e|0,n=n|0,t[e+20>>2]=n}function ZR(e,n,r){e=e|0,n=n|0,r=+r;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+16|0,a=u+8|0,w=u+13|0,s=u,v=u+12|0,xs(w,n),t[a>>2]=Gs(w,n)|0,Pl(v,r),j[s>>3]=+us(v,r),$R(e,a,s),y=u}function $R(e,n,r){e=e|0,n=n|0,r=r|0,B(e+8|0,t[n>>2]|0,+j[r>>3]),h[e+24>>0]=1}function eA(){return 1404}function tA(e,n){return e=e|0,n=+n,nA(e,n)|0}function nA(e,n){e=e|0,n=+n;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return u=y,y=y+16|0,a=u+4|0,v=u+8|0,w=u,s=Oa(8)|0,r=s,T=pn(16)|0,xs(a,e),e=Gs(a,e)|0,Pl(v,n),B(T,e,+us(v,n)),v=r+4|0,t[v>>2]=T,e=pn(8)|0,v=t[v>>2]|0,t[w>>2]=0,t[a>>2]=t[w>>2],Bf(e,v,a),t[s>>2]=e,y=u,r|0}function rA(){var e=0;return h[7896]|0||(Tw(10364),Wt(54,10364,ge|0)|0,e=7896,t[e>>2]=1,t[e+4>>2]=0),sr(10364)|0||Tw(10364),10364}function Tw(e){e=e|0,oA(e),Vp(e,55)}function iA(e){e=e|0,uA(e+24|0)}function uA(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function oA(e){e=e|0;var n=0;n=yr()|0,jn(e,5,4,n,fA()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function lA(e){e=e|0,sA(e)}function sA(e){e=e|0,aA(e)}function aA(e){e=e|0,Cw(e+8|0),h[e+24>>0]=1}function Cw(e){e=e|0,t[e>>2]=0,j[e+8>>3]=0}function fA(){return 1424}function cA(){return dA()|0}function dA(){var e=0,n=0,r=0,u=0,s=0,a=0,v=0;return n=y,y=y+16|0,s=n+4|0,v=n,r=Oa(8)|0,e=r,u=pn(16)|0,Cw(u),a=e+4|0,t[a>>2]=u,u=pn(8)|0,a=t[a>>2]|0,t[v>>2]=0,t[s>>2]=t[v>>2],Bf(u,a,s),t[r>>2]=u,y=n,e|0}function pA(e,n){e=e|0,n=n|0,t[e>>2]=hA()|0,t[e+4>>2]=vA()|0,t[e+12>>2]=n,t[e+8>>2]=mA()|0,t[e+32>>2]=5}function hA(){return 11710}function vA(){return 1416}function mA(){return s_()|0}function yA(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(gA(r),Et(r)):n|0&&Et(n)}function gA(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function s_(){var e=0;return h[7904]|0||(t[2600]=_A()|0,t[2601]=0,e=7904,t[e>>2]=1,t[e+4>>2]=0),10400}function _A(){return t[357]|0}function EA(e){e=e|0,DA(e,4926),wA(e)|0}function DA(e,n){e=e|0,n=n|0;var r=0;r=Ka()|0,t[e>>2]=r,LA(r,n),Zd(t[e>>2]|0)}function wA(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,SA()|0),e|0}function SA(){var e=0;return h[7912]|0||(xw(10412),Wt(56,10412,ge|0)|0,e=7912,t[e>>2]=1,t[e+4>>2]=0),sr(10412)|0||xw(10412),10412}function xw(e){e=e|0,xA(e),Vp(e,57)}function TA(e){e=e|0,CA(e+24|0)}function CA(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function xA(e){e=e|0;var n=0;n=yr()|0,jn(e,5,5,n,MA()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function RA(e){e=e|0,AA(e)}function AA(e){e=e|0,OA(e)}function OA(e){e=e|0;var n=0,r=0;n=e+8|0,r=n+48|0;do t[n>>2]=0,n=n+4|0;while((n|0)<(r|0));h[e+56>>0]=1}function MA(){return 1432}function kA(){return NA()|0}function NA(){var e=0,n=0,r=0,u=0,s=0,a=0,v=0,w=0;v=y,y=y+16|0,e=v+4|0,n=v,r=Oa(8)|0,u=r,s=pn(48)|0,a=s,w=a+48|0;do t[a>>2]=0,a=a+4|0;while((a|0)<(w|0));return a=u+4|0,t[a>>2]=s,w=pn(8)|0,a=t[a>>2]|0,t[n>>2]=0,t[e>>2]=t[n>>2],Th(w,a,e),t[r>>2]=w,y=v,u|0}function LA(e,n){e=e|0,n=n|0,t[e>>2]=FA()|0,t[e+4>>2]=PA()|0,t[e+12>>2]=n,t[e+8>>2]=IA()|0,t[e+32>>2]=6}function FA(){return 11704}function PA(){return 1436}function IA(){return s_()|0}function bA(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(BA(r),Et(r)):n|0&&Et(n)}function BA(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function UA(e){e=e|0,jA(e,4933),zA(e)|0,HA(e)|0}function jA(e,n){e=e|0,n=n|0;var r=0;r=d7()|0,t[e>>2]=r,p7(r,n),Zd(t[e>>2]|0)}function zA(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,n7()|0),e|0}function HA(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,qA()|0),e|0}function qA(){var e=0;return h[7920]|0||(Rw(10452),Wt(58,10452,ge|0)|0,e=7920,t[e>>2]=1,t[e+4>>2]=0),sr(10452)|0||Rw(10452),10452}function Rw(e){e=e|0,GA(e),Vp(e,1)}function WA(e){e=e|0,VA(e+24|0)}function VA(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function GA(e){e=e|0;var n=0;n=yr()|0,jn(e,5,1,n,QA()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function YA(e,n,r){e=e|0,n=+n,r=+r,KA(e,n,r)}function KA(e,n,r){e=e|0,n=+n,r=+r;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+32|0,a=u+8|0,w=u+17|0,s=u,v=u+16|0,Pl(w,n),j[a>>3]=+us(w,n),Pl(v,r),j[s>>3]=+us(v,r),XA(e,a,s),y=u}function XA(e,n,r){e=e|0,n=n|0,r=r|0,Aw(e+8|0,+j[n>>3],+j[r>>3]),h[e+24>>0]=1}function Aw(e,n,r){e=e|0,n=+n,r=+r,j[e>>3]=n,j[e+8>>3]=r}function QA(){return 1472}function JA(e,n){return e=+e,n=+n,ZA(e,n)|0}function ZA(e,n){e=+e,n=+n;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return u=y,y=y+16|0,v=u+4|0,w=u+8|0,T=u,s=Oa(8)|0,r=s,a=pn(16)|0,Pl(v,e),e=+us(v,e),Pl(w,n),Aw(a,e,+us(w,n)),w=r+4|0,t[w>>2]=a,a=pn(8)|0,w=t[w>>2]|0,t[T>>2]=0,t[v>>2]=t[T>>2],Ow(a,w,v),t[s>>2]=a,y=u,r|0}function Ow(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,r=pn(16)|0,t[r+4>>2]=0,t[r+8>>2]=0,t[r>>2]=1452,t[r+12>>2]=n,t[e+4>>2]=r}function $A(e){e=e|0,Uv(e),Et(e)}function e7(e){e=e|0,e=t[e+12>>2]|0,e|0&&Et(e)}function t7(e){e=e|0,Et(e)}function n7(){var e=0;return h[7928]|0||(Mw(10488),Wt(59,10488,ge|0)|0,e=7928,t[e>>2]=1,t[e+4>>2]=0),sr(10488)|0||Mw(10488),10488}function Mw(e){e=e|0,u7(e),Vp(e,60)}function r7(e){e=e|0,i7(e+24|0)}function i7(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function u7(e){e=e|0;var n=0;n=yr()|0,jn(e,5,6,n,a7()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function o7(e){e=e|0,l7(e)}function l7(e){e=e|0,s7(e)}function s7(e){e=e|0,kw(e+8|0),h[e+24>>0]=1}function kw(e){e=e|0,t[e>>2]=0,t[e+4>>2]=0,t[e+8>>2]=0,t[e+12>>2]=0}function a7(){return 1492}function f7(){return c7()|0}function c7(){var e=0,n=0,r=0,u=0,s=0,a=0,v=0;return n=y,y=y+16|0,s=n+4|0,v=n,r=Oa(8)|0,e=r,u=pn(16)|0,kw(u),a=e+4|0,t[a>>2]=u,u=pn(8)|0,a=t[a>>2]|0,t[v>>2]=0,t[s>>2]=t[v>>2],Ow(u,a,s),t[r>>2]=u,y=n,e|0}function d7(){var e=0;return h[7936]|0||(_7(10524),Wt(25,10524,ge|0)|0,e=7936,t[e>>2]=1,t[e+4>>2]=0),10524}function p7(e,n){e=e|0,n=n|0,t[e>>2]=h7()|0,t[e+4>>2]=v7()|0,t[e+12>>2]=n,t[e+8>>2]=m7()|0,t[e+32>>2]=7}function h7(){return 11700}function v7(){return 1484}function m7(){return s_()|0}function y7(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(g7(r),Et(r)):n|0&&Et(n)}function g7(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function _7(e){e=e|0,Xa(e)}function E7(e,n,r){e=e|0,n=n|0,r=r|0,e=Fr(n)|0,n=D7(r)|0,r=w7(r,0)|0,Z7(e,n,r,pE()|0,0)}function D7(e){return e=e|0,e|0}function w7(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=pE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(Lw(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(O7(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function pE(){var e=0,n=0;if(h[7944]|0||(Nw(10568),Wt(61,10568,ge|0)|0,n=7944,t[n>>2]=1,t[n+4>>2]=0),!(sr(10568)|0)){e=10568,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));Nw(10568)}return 10568}function Nw(e){e=e|0,C7(e)}function S7(e){e=e|0,T7(e+24|0)}function T7(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function C7(e){e=e|0;var n=0;n=yr()|0,jn(e,1,17,n,ev()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function x7(e){return e=e|0,A7(t[(R7(e)|0)>>2]|0)|0}function R7(e){return e=e|0,(t[(pE()|0)+24>>2]|0)+(e<<3)|0}function A7(e){return e=e|0,H0(E_[e&7]()|0)|0}function Lw(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function O7(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=M7(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,k7(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,Lw(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,N7(e,s),L7(s),y=w;return}}function M7(e){return e=e|0,536870911}function k7(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function N7(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function L7(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function F7(){P7()}function P7(){I7(10604)}function I7(e){e=e|0,b7(e,4955)}function b7(e,n){e=e|0,n=n|0;var r=0;r=B7()|0,t[e>>2]=r,U7(r,n),Zd(t[e>>2]|0)}function B7(){var e=0;return h[7952]|0||(K7(10612),Wt(25,10612,ge|0)|0,e=7952,t[e>>2]=1,t[e+4>>2]=0),10612}function U7(e,n){e=e|0,n=n|0,t[e>>2]=q7()|0,t[e+4>>2]=W7()|0,t[e+12>>2]=n,t[e+8>>2]=V7()|0,t[e+32>>2]=8}function Zd(e){e=e|0;var n=0,r=0;n=y,y=y+16|0,r=n,Fv()|0,t[r>>2]=e,j7(10608,r),y=n}function Fv(){return h[11714]|0||(t[2652]=0,Wt(62,10608,ge|0)|0,h[11714]=1),10608}function j7(e,n){e=e|0,n=n|0;var r=0;r=pn(8)|0,t[r+4>>2]=t[n>>2],t[r>>2]=t[e>>2],t[e>>2]=r}function z7(e){e=e|0,H7(e)}function H7(e){e=e|0;var n=0,r=0;if(n=t[e>>2]|0,n|0)do r=n,n=t[n>>2]|0,Et(r);while((n|0)!=0);t[e>>2]=0}function q7(){return 11715}function W7(){return 1496}function V7(){return L1()|0}function G7(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(Y7(r),Et(r)):n|0&&Et(n)}function Y7(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function K7(e){e=e|0,Xa(e)}function X7(e,n){e=e|0,n=n|0;var r=0,u=0;Fv()|0,r=t[2652]|0;e:do if(r|0){for(;u=t[r+4>>2]|0,!(u|0&&(h8(hE(u)|0,e)|0)==0);)if(r=t[r>>2]|0,!r)break e;Q7(u,n)}while(0)}function hE(e){return e=e|0,t[e+12>>2]|0}function Q7(e,n){e=e|0,n=n|0;var r=0;e=e+36|0,r=t[e>>2]|0,r|0&&(fa(r),Et(r)),r=pn(4)|0,wf(r,n),t[e>>2]=r}function vE(){return h[11716]|0||(t[2664]=0,Wt(63,10656,ge|0)|0,h[11716]=1),10656}function Fw(){var e=0;return h[11717]|0?e=t[2665]|0:(J7(),t[2665]=1504,h[11717]=1,e=1504),e|0}function J7(){h[11740]|0||(h[11718]=hn(hn(8,0)|0,0)|0,h[11719]=hn(hn(0,0)|0,0)|0,h[11720]=hn(hn(0,16)|0,0)|0,h[11721]=hn(hn(8,0)|0,0)|0,h[11722]=hn(hn(0,0)|0,0)|0,h[11723]=hn(hn(8,0)|0,0)|0,h[11724]=hn(hn(0,0)|0,0)|0,h[11725]=hn(hn(8,0)|0,0)|0,h[11726]=hn(hn(0,0)|0,0)|0,h[11727]=hn(hn(8,0)|0,0)|0,h[11728]=hn(hn(0,0)|0,0)|0,h[11729]=hn(hn(0,0)|0,32)|0,h[11730]=hn(hn(0,0)|0,32)|0,h[11740]=1)}function Pw(){return 1572}function Z7(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0,L=0,M=0;a=y,y=y+32|0,M=a+16|0,L=a+12|0,T=a+8|0,w=a+4|0,v=a,t[M>>2]=e,t[L>>2]=n,t[T>>2]=r,t[w>>2]=u,t[v>>2]=s,vE()|0,$7(10656,M,L,T,w,v),y=a}function $7(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0;var v=0;v=pn(24)|0,yd(v+4|0,t[n>>2]|0,t[r>>2]|0,t[u>>2]|0,t[s>>2]|0,t[a>>2]|0),t[v>>2]=t[e>>2],t[e>>2]=v}function Iw(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0,Ze=0,Ye=0,ct=0;if(ct=y,y=y+32|0,Te=ct+20|0,ye=ct+8|0,Ze=ct+4|0,Ye=ct,n=t[n>>2]|0,n|0){Be=Te+4|0,T=Te+8|0,L=ye+4|0,M=ye+8|0,b=ye+8|0,X=Te+8|0;do{if(v=n+4|0,w=mE(v)|0,w|0){if(s=Ay(w)|0,t[Te>>2]=0,t[Be>>2]=0,t[T>>2]=0,u=(Oy(w)|0)+1|0,eO(Te,u),u|0)for(;u=u+-1|0,Gf(ye,t[s>>2]|0),a=t[Be>>2]|0,a>>>0<(t[X>>2]|0)>>>0?(t[a>>2]=t[ye>>2],t[Be>>2]=(t[Be>>2]|0)+4):yE(Te,ye),u;)s=s+4|0;u=My(w)|0,t[ye>>2]=0,t[L>>2]=0,t[M>>2]=0;e:do if(t[u>>2]|0)for(s=0,a=0;;){if((s|0)==(a|0)?tO(ye,u):(t[s>>2]=t[u>>2],t[L>>2]=(t[L>>2]|0)+4),u=u+4|0,!(t[u>>2]|0))break e;s=t[L>>2]|0,a=t[b>>2]|0}while(0);t[Ze>>2]=a_(v)|0,t[Ye>>2]=sr(w)|0,nO(r,e,Ze,Ye,Te,ye),gE(ye),F1(Te)}n=t[n>>2]|0}while((n|0)!=0)}y=ct}function mE(e){return e=e|0,t[e+12>>2]|0}function Ay(e){return e=e|0,t[e+12>>2]|0}function Oy(e){return e=e|0,t[e+16>>2]|0}function eO(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;s=y,y=y+32|0,r=s,u=t[e>>2]|0,(t[e+8>>2]|0)-u>>2>>>0<n>>>0&&(Ww(r,n,(t[e+4>>2]|0)-u>>2,e+8|0),Vw(e,r),Gw(r)),y=s}function yE(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0;if(v=y,y=y+32|0,r=v,u=e+4|0,s=((t[u>>2]|0)-(t[e>>2]|0)>>2)+1|0,a=qw(e)|0,a>>>0<s>>>0)di(e);else{w=t[e>>2]|0,L=(t[e+8>>2]|0)-w|0,T=L>>1,Ww(r,L>>2>>>0<a>>>1>>>0?T>>>0<s>>>0?s:T:a,(t[u>>2]|0)-w>>2,e+8|0),a=r+8|0,t[t[a>>2]>>2]=t[n>>2],t[a>>2]=(t[a>>2]|0)+4,Vw(e,r),Gw(r),y=v;return}}function My(e){return e=e|0,t[e+8>>2]|0}function tO(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0;if(v=y,y=y+32|0,r=v,u=e+4|0,s=((t[u>>2]|0)-(t[e>>2]|0)>>2)+1|0,a=Hw(e)|0,a>>>0<s>>>0)di(e);else{w=t[e>>2]|0,L=(t[e+8>>2]|0)-w|0,T=L>>1,DO(r,L>>2>>>0<a>>>1>>>0?T>>>0<s>>>0?s:T:a,(t[u>>2]|0)-w>>2,e+8|0),a=r+8|0,t[t[a>>2]>>2]=t[n>>2],t[a>>2]=(t[a>>2]|0)+4,wO(e,r),SO(r),y=v;return}}function a_(e){return e=e|0,t[e>>2]|0}function nO(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,rO(e,n,r,u,s,a)}function gE(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-4-u|0)>>>2)<<2)),Et(r))}function F1(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-4-u|0)>>>2)<<2)),Et(r))}function rO(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0;var v=0,w=0,T=0,L=0,M=0,b=0;v=y,y=y+48|0,M=v+40|0,w=v+32|0,b=v+24|0,T=v+12|0,L=v,Ma(w),e=go(e)|0,t[b>>2]=t[n>>2],r=t[r>>2]|0,u=t[u>>2]|0,_E(T,s),iO(L,a),t[M>>2]=t[b>>2],uO(e,M,r,u,T,L),gE(L),F1(T),ka(w),y=v}function _E(e,n){e=e|0,n=n|0;var r=0,u=0;t[e>>2]=0,t[e+4>>2]=0,t[e+8>>2]=0,r=n+4|0,u=(t[r>>2]|0)-(t[n>>2]|0)>>2,u|0&&(_O(e,u),EO(e,t[n>>2]|0,t[r>>2]|0,u))}function iO(e,n){e=e|0,n=n|0;var r=0,u=0;t[e>>2]=0,t[e+4>>2]=0,t[e+8>>2]=0,r=n+4|0,u=(t[r>>2]|0)-(t[n>>2]|0)>>2,u|0&&(yO(e,u),gO(e,t[n>>2]|0,t[r>>2]|0,u))}function uO(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0;var v=0,w=0,T=0,L=0,M=0,b=0;v=y,y=y+32|0,M=v+28|0,b=v+24|0,w=v+12|0,T=v,L=_o(oO()|0)|0,t[b>>2]=t[n>>2],t[M>>2]=t[b>>2],n=Gp(M)|0,r=bw(r)|0,u=EE(u)|0,t[w>>2]=t[s>>2],M=s+4|0,t[w+4>>2]=t[M>>2],b=s+8|0,t[w+8>>2]=t[b>>2],t[b>>2]=0,t[M>>2]=0,t[s>>2]=0,s=DE(w)|0,t[T>>2]=t[a>>2],M=a+4|0,t[T+4>>2]=t[M>>2],b=a+8|0,t[T+8>>2]=t[b>>2],t[b>>2]=0,t[M>>2]=0,t[a>>2]=0,X0(0,L|0,e|0,n|0,r|0,u|0,s|0,lO(T)|0)|0,gE(T),F1(w),y=v}function oO(){var e=0;return h[7968]|0||(vO(10708),e=7968,t[e>>2]=1,t[e+4>>2]=0),10708}function Gp(e){return e=e|0,Uw(e)|0}function bw(e){return e=e|0,Bw(e)|0}function EE(e){return e=e|0,H0(e)|0}function DE(e){return e=e|0,aO(e)|0}function lO(e){return e=e|0,sO(e)|0}function sO(e){e=e|0;var n=0,r=0,u=0;if(u=(t[e+4>>2]|0)-(t[e>>2]|0)|0,r=u>>2,u=Oa(u+4|0)|0,t[u>>2]=r,r|0){n=0;do t[u+4+(n<<2)>>2]=Bw(t[(t[e>>2]|0)+(n<<2)>>2]|0)|0,n=n+1|0;while((n|0)!=(r|0))}return u|0}function Bw(e){return e=e|0,e|0}function aO(e){e=e|0;var n=0,r=0,u=0;if(u=(t[e+4>>2]|0)-(t[e>>2]|0)|0,r=u>>2,u=Oa(u+4|0)|0,t[u>>2]=r,r|0){n=0;do t[u+4+(n<<2)>>2]=Uw((t[e>>2]|0)+(n<<2)|0)|0,n=n+1|0;while((n|0)!=(r|0))}return u|0}function Uw(e){e=e|0;var n=0,r=0,u=0,s=0;return s=y,y=y+32|0,n=s+12|0,r=s,u=Pu(jw()|0)|0,u?(rs(n,u),Mf(r,n),VN(e,r),e=Cs(n)|0):e=fO(e)|0,y=s,e|0}function jw(){var e=0;return h[7960]|0||(hO(10664),Wt(25,10664,ge|0)|0,e=7960,t[e>>2]=1,t[e+4>>2]=0),10664}function fO(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0;return r=y,y=y+16|0,s=r+4|0,v=r,u=Oa(8)|0,n=u,w=pn(4)|0,t[w>>2]=t[e>>2],a=n+4|0,t[a>>2]=w,e=pn(8)|0,a=t[a>>2]|0,t[v>>2]=0,t[s>>2]=t[v>>2],zw(e,a,s),t[u>>2]=e,y=r,n|0}function zw(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,r=pn(16)|0,t[r+4>>2]=0,t[r+8>>2]=0,t[r>>2]=1656,t[r+12>>2]=n,t[e+4>>2]=r}function cO(e){e=e|0,Uv(e),Et(e)}function dO(e){e=e|0,e=t[e+12>>2]|0,e|0&&Et(e)}function pO(e){e=e|0,Et(e)}function hO(e){e=e|0,Xa(e)}function vO(e){e=e|0,ll(e,mO()|0,5)}function mO(){return 1676}function yO(e,n){e=e|0,n=n|0;var r=0;if((Hw(e)|0)>>>0<n>>>0&&di(e),n>>>0>1073741823)$n();else{r=pn(n<<2)|0,t[e+4>>2]=r,t[e>>2]=r,t[e+8>>2]=r+(n<<2);return}}function gO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,u=e+4|0,e=r-n|0,(e|0)>0&&(gr(t[u>>2]|0,n|0,e|0)|0,t[u>>2]=(t[u>>2]|0)+(e>>>2<<2))}function Hw(e){return e=e|0,1073741823}function _O(e,n){e=e|0,n=n|0;var r=0;if((qw(e)|0)>>>0<n>>>0&&di(e),n>>>0>1073741823)$n();else{r=pn(n<<2)|0,t[e+4>>2]=r,t[e>>2]=r,t[e+8>>2]=r+(n<<2);return}}function EO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,u=e+4|0,e=r-n|0,(e|0)>0&&(gr(t[u>>2]|0,n|0,e|0)|0,t[u>>2]=(t[u>>2]|0)+(e>>>2<<2))}function qw(e){return e=e|0,1073741823}function DO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>1073741823)$n();else{s=pn(n<<2)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<2)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<2)}function wO(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>2)<<2)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function SO(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-4-n|0)>>>2)<<2)),e=t[e>>2]|0,e|0&&Et(e)}function Ww(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>1073741823)$n();else{s=pn(n<<2)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<2)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<2)}function Vw(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>2)<<2)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Gw(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-4-n|0)>>>2)<<2)),e=t[e>>2]|0,e|0&&Et(e)}function TO(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0;if(ye=y,y=y+32|0,M=ye+20|0,b=ye+12|0,L=ye+16|0,X=ye+4|0,Be=ye,Te=ye+8|0,w=Fw()|0,a=t[w>>2]|0,v=t[a>>2]|0,v|0)for(T=t[w+8>>2]|0,w=t[w+4>>2]|0;Gf(M,v),CO(e,M,w,T),a=a+4|0,v=t[a>>2]|0,v;)T=T+1|0,w=w+1|0;if(a=Pw()|0,v=t[a>>2]|0,v|0)do Gf(M,v),t[b>>2]=t[a+4>>2],xO(n,M,b),a=a+8|0,v=t[a>>2]|0;while((v|0)!=0);if(a=t[(Fv()|0)>>2]|0,a|0)do n=t[a+4>>2]|0,Gf(M,t[(Pv(n)|0)>>2]|0),t[b>>2]=hE(n)|0,RO(r,M,b),a=t[a>>2]|0;while((a|0)!=0);if(Gf(L,0),a=vE()|0,t[M>>2]=t[L>>2],Iw(M,a,s),a=t[(Fv()|0)>>2]|0,a|0){e=M+4|0,n=M+8|0,r=M+8|0;do{if(T=t[a+4>>2]|0,Gf(b,t[(Pv(T)|0)>>2]|0),AO(X,Yw(T)|0),v=t[X>>2]|0,v|0){t[M>>2]=0,t[e>>2]=0,t[n>>2]=0;do Gf(Be,t[(Pv(t[v+4>>2]|0)|0)>>2]|0),w=t[e>>2]|0,w>>>0<(t[r>>2]|0)>>>0?(t[w>>2]=t[Be>>2],t[e>>2]=(t[e>>2]|0)+4):yE(M,Be),v=t[v>>2]|0;while((v|0)!=0);OO(u,b,M),F1(M)}t[Te>>2]=t[b>>2],L=Kw(T)|0,t[M>>2]=t[Te>>2],Iw(M,L,s),_d(X),a=t[a>>2]|0}while((a|0)!=0)}y=ye}function CO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,zO(e,n,r,u)}function xO(e,n,r){e=e|0,n=n|0,r=r|0,jO(e,n,r)}function Pv(e){return e=e|0,e|0}function RO(e,n,r){e=e|0,n=n|0,r=r|0,IO(e,n,r)}function Yw(e){return e=e|0,e+16|0}function AO(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;if(a=y,y=y+16|0,s=a+8|0,r=a,t[e>>2]=0,u=t[n>>2]|0,t[s>>2]=u,t[r>>2]=e,r=PO(r)|0,u|0){if(u=pn(12)|0,v=(Xw(s)|0)+4|0,e=t[v+4>>2]|0,n=u+4|0,t[n>>2]=t[v>>2],t[n+4>>2]=e,n=t[t[s>>2]>>2]|0,t[s>>2]=n,!n)e=u;else for(n=u;e=pn(12)|0,T=(Xw(s)|0)+4|0,w=t[T+4>>2]|0,v=e+4|0,t[v>>2]=t[T>>2],t[v+4>>2]=w,t[n>>2]=e,v=t[t[s>>2]>>2]|0,t[s>>2]=v,v;)n=e;t[e>>2]=t[r>>2],t[r>>2]=u}y=a}function OO(e,n,r){e=e|0,n=n|0,r=r|0,MO(e,n,r)}function Kw(e){return e=e|0,e+24|0}function MO(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+32|0,v=u+24|0,s=u+16|0,w=u+12|0,a=u,Ma(s),e=go(e)|0,t[w>>2]=t[n>>2],_E(a,r),t[v>>2]=t[w>>2],kO(e,v,a),F1(a),ka(s),y=u}function kO(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=y,y=y+32|0,v=u+16|0,w=u+12|0,s=u,a=_o(NO()|0)|0,t[w>>2]=t[n>>2],t[v>>2]=t[w>>2],n=Gp(v)|0,t[s>>2]=t[r>>2],v=r+4|0,t[s+4>>2]=t[v>>2],w=r+8|0,t[s+8>>2]=t[w>>2],t[w>>2]=0,t[v>>2]=0,t[r>>2]=0,P0(0,a|0,e|0,n|0,DE(s)|0)|0,F1(s),y=u}function NO(){var e=0;return h[7976]|0||(LO(10720),e=7976,t[e>>2]=1,t[e+4>>2]=0),10720}function LO(e){e=e|0,ll(e,FO()|0,2)}function FO(){return 1732}function PO(e){return e=e|0,t[e>>2]|0}function Xw(e){return e=e|0,t[e>>2]|0}function IO(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+32|0,a=u+16|0,s=u+8|0,v=u,Ma(s),e=go(e)|0,t[v>>2]=t[n>>2],r=t[r>>2]|0,t[a>>2]=t[v>>2],Qw(e,a,r),ka(s),y=u}function Qw(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+16|0,a=u+4|0,v=u,s=_o(bO()|0)|0,t[v>>2]=t[n>>2],t[a>>2]=t[v>>2],n=Gp(a)|0,P0(0,s|0,e|0,n|0,bw(r)|0)|0,y=u}function bO(){var e=0;return h[7984]|0||(BO(10732),e=7984,t[e>>2]=1,t[e+4>>2]=0),10732}function BO(e){e=e|0,ll(e,UO()|0,2)}function UO(){return 1744}function jO(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;u=y,y=y+32|0,a=u+16|0,s=u+8|0,v=u,Ma(s),e=go(e)|0,t[v>>2]=t[n>>2],r=t[r>>2]|0,t[a>>2]=t[v>>2],Qw(e,a,r),ka(s),y=u}function zO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;s=y,y=y+32|0,v=s+16|0,a=s+8|0,w=s,Ma(a),e=go(e)|0,t[w>>2]=t[n>>2],r=h[r>>0]|0,u=h[u>>0]|0,t[v>>2]=t[w>>2],HO(e,v,r,u),ka(a),y=s}function HO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;s=y,y=y+16|0,v=s+4|0,w=s,a=_o(qO()|0)|0,t[w>>2]=t[n>>2],t[v>>2]=t[w>>2],n=Gp(v)|0,r=Iv(r)|0,Hn(0,a|0,e|0,n|0,r|0,Iv(u)|0)|0,y=s}function qO(){var e=0;return h[7992]|0||(VO(10744),e=7992,t[e>>2]=1,t[e+4>>2]=0),10744}function Iv(e){return e=e|0,WO(e)|0}function WO(e){return e=e|0,e&255|0}function VO(e){e=e|0,ll(e,GO()|0,3)}function GO(){return 1756}function YO(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;switch(X=y,y=y+32|0,w=X+8|0,T=X+4|0,L=X+20|0,M=X,Sa(e,0),u=WN(n)|0,t[w>>2]=0,b=w+4|0,t[b>>2]=0,t[w+8>>2]=0,u<<24>>24){case 0:{h[L>>0]=0,KO(T,r,L),f_(e,T)|0,U0(T);break}case 8:{b=RE(n)|0,h[L>>0]=8,Gf(M,t[b+4>>2]|0),XO(T,r,L,M,b+8|0),f_(e,T)|0,U0(T);break}case 9:{if(a=RE(n)|0,n=t[a+4>>2]|0,n|0)for(v=w+8|0,s=a+12|0;n=n+-1|0,Gf(T,t[s>>2]|0),u=t[b>>2]|0,u>>>0<(t[v>>2]|0)>>>0?(t[u>>2]=t[T>>2],t[b>>2]=(t[b>>2]|0)+4):yE(w,T),n;)s=s+4|0;h[L>>0]=9,Gf(M,t[a+8>>2]|0),QO(T,r,L,M,w),f_(e,T)|0,U0(T);break}default:b=RE(n)|0,h[L>>0]=u,Gf(M,t[b+4>>2]|0),JO(T,r,L,M),f_(e,T)|0,U0(T)}F1(w),y=X}function KO(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;u=y,y=y+16|0,s=u,Ma(s),n=go(n)|0,fM(e,n,h[r>>0]|0),ka(s),y=u}function f_(e,n){e=e|0,n=n|0;var r=0;return r=t[e>>2]|0,r|0&&qr(r|0),t[e>>2]=t[n>>2],t[n>>2]=0,e|0}function XO(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0;a=y,y=y+32|0,w=a+16|0,v=a+8|0,T=a,Ma(v),n=go(n)|0,r=h[r>>0]|0,t[T>>2]=t[u>>2],s=t[s>>2]|0,t[w>>2]=t[T>>2],oM(e,n,r,w,s),ka(v),y=a}function QO(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0,L=0;a=y,y=y+32|0,T=a+24|0,v=a+16|0,L=a+12|0,w=a,Ma(v),n=go(n)|0,r=h[r>>0]|0,t[L>>2]=t[u>>2],_E(w,s),t[T>>2]=t[L>>2],nM(e,n,r,T,w),F1(w),ka(v),y=a}function JO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;s=y,y=y+32|0,v=s+16|0,a=s+8|0,w=s,Ma(a),n=go(n)|0,r=h[r>>0]|0,t[w>>2]=t[u>>2],t[v>>2]=t[w>>2],ZO(e,n,r,v),ka(a),y=s}function ZO(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0,v=0,w=0;s=y,y=y+16|0,a=s+4|0,w=s,v=_o($O()|0)|0,r=Iv(r)|0,t[w>>2]=t[u>>2],t[a>>2]=t[w>>2],c_(e,P0(0,v|0,n|0,r|0,Gp(a)|0)|0),y=s}function $O(){var e=0;return h[8e3]|0||(eM(10756),e=8e3,t[e>>2]=1,t[e+4>>2]=0),10756}function c_(e,n){e=e|0,n=n|0,Sa(e,n)}function eM(e){e=e|0,ll(e,tM()|0,2)}function tM(){return 1772}function nM(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0,L=0;a=y,y=y+32|0,T=a+16|0,L=a+12|0,v=a,w=_o(rM()|0)|0,r=Iv(r)|0,t[L>>2]=t[u>>2],t[T>>2]=t[L>>2],u=Gp(T)|0,t[v>>2]=t[s>>2],T=s+4|0,t[v+4>>2]=t[T>>2],L=s+8|0,t[v+8>>2]=t[L>>2],t[L>>2]=0,t[T>>2]=0,t[s>>2]=0,c_(e,Hn(0,w|0,n|0,r|0,u|0,DE(v)|0)|0),F1(v),y=a}function rM(){var e=0;return h[8008]|0||(iM(10768),e=8008,t[e>>2]=1,t[e+4>>2]=0),10768}function iM(e){e=e|0,ll(e,uM()|0,3)}function uM(){return 1784}function oM(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0;a=y,y=y+16|0,w=a+4|0,T=a,v=_o(lM()|0)|0,r=Iv(r)|0,t[T>>2]=t[u>>2],t[w>>2]=t[T>>2],u=Gp(w)|0,c_(e,Hn(0,v|0,n|0,r|0,u|0,EE(s)|0)|0),y=a}function lM(){var e=0;return h[8016]|0||(sM(10780),e=8016,t[e>>2]=1,t[e+4>>2]=0),10780}function sM(e){e=e|0,ll(e,aM()|0,3)}function aM(){return 1800}function fM(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;u=_o(cM()|0)|0,c_(e,Ki(0,u|0,n|0,Iv(r)|0)|0)}function cM(){var e=0;return h[8024]|0||(dM(10792),e=8024,t[e>>2]=1,t[e+4>>2]=0),10792}function dM(e){e=e|0,ll(e,pM()|0,1)}function pM(){return 1816}function hM(){vM(),mM(),yM()}function vM(){t[2702]=T8(65536)|0}function mM(){bM(10856)}function yM(){gM(10816)}function gM(e){e=e|0,_M(e,5044),EM(e)|0}function _M(e,n){e=e|0,n=n|0;var r=0;r=jw()|0,t[e>>2]=r,kM(r,n),Zd(t[e>>2]|0)}function EM(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,DM()|0),e|0}function DM(){var e=0;return h[8032]|0||(Jw(10820),Wt(64,10820,ge|0)|0,e=8032,t[e>>2]=1,t[e+4>>2]=0),sr(10820)|0||Jw(10820),10820}function Jw(e){e=e|0,TM(e),Vp(e,25)}function wM(e){e=e|0,SM(e+24|0)}function SM(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function TM(e){e=e|0;var n=0;n=yr()|0,jn(e,5,18,n,AM()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function CM(e,n){e=e|0,n=n|0,xM(e,n)}function xM(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;r=y,y=y+16|0,u=r,s=r+4|0,Pf(s,n),t[u>>2]=If(s,n)|0,RM(e,u),y=r}function RM(e,n){e=e|0,n=n|0,Zw(e+4|0,t[n>>2]|0),h[e+8>>0]=1}function Zw(e,n){e=e|0,n=n|0,t[e>>2]=n}function AM(){return 1824}function OM(e){return e=e|0,MM(e)|0}function MM(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0;return r=y,y=y+16|0,s=r+4|0,v=r,u=Oa(8)|0,n=u,w=pn(4)|0,Pf(s,e),Zw(w,If(s,e)|0),a=n+4|0,t[a>>2]=w,e=pn(8)|0,a=t[a>>2]|0,t[v>>2]=0,t[s>>2]=t[v>>2],zw(e,a,s),t[u>>2]=e,y=r,n|0}function Oa(e){e=e|0;var n=0,r=0;return e=e+7&-8,e>>>0<=32768&&(n=t[2701]|0,e>>>0<=(65536-n|0)>>>0)?(r=(t[2702]|0)+n|0,t[2701]=n+e,e=r):(e=T8(e+8|0)|0,t[e>>2]=t[2703],t[2703]=e,e=e+8|0),e|0}function kM(e,n){e=e|0,n=n|0,t[e>>2]=NM()|0,t[e+4>>2]=LM()|0,t[e+12>>2]=n,t[e+8>>2]=FM()|0,t[e+32>>2]=9}function NM(){return 11744}function LM(){return 1832}function FM(){return s_()|0}function PM(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(IM(r),Et(r)):n|0&&Et(n)}function IM(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function bM(e){e=e|0,BM(e,5052),UM(e)|0,jM(e,5058,26)|0,zM(e,5069,1)|0,HM(e,5077,10)|0,qM(e,5087,19)|0,WM(e,5094,27)|0}function BM(e,n){e=e|0,n=n|0;var r=0;r=IN()|0,t[e>>2]=r,bN(r,n),Zd(t[e>>2]|0)}function UM(e){e=e|0;var n=0;return n=t[e>>2]|0,Wp(n,wN()|0),e|0}function jM(e,n,r){return e=e|0,n=n|0,r=r|0,iN(e,Fr(n)|0,r,0),e|0}function zM(e,n,r){return e=e|0,n=n|0,r=r|0,qk(e,Fr(n)|0,r,0),e|0}function HM(e,n,r){return e=e|0,n=n|0,r=r|0,Dk(e,Fr(n)|0,r,0),e|0}function qM(e,n,r){return e=e|0,n=n|0,r=r|0,ok(e,Fr(n)|0,r,0),e|0}function $w(e,n){e=e|0,n=n|0;var r=0,u=0;e:for(;;){for(r=t[2703]|0;;){if((r|0)==(n|0))break e;if(u=t[r>>2]|0,t[2703]=u,!r)r=u;else break}Et(r)}t[2701]=e}function WM(e,n,r){return e=e|0,n=n|0,r=r|0,VM(e,Fr(n)|0,r,0),e|0}function VM(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=wE()|0,e=GM(r)|0,wi(a,n,s,e,YM(r,u)|0,u)}function wE(){var e=0,n=0;if(h[8040]|0||(t8(10860),Wt(65,10860,ge|0)|0,n=8040,t[n>>2]=1,t[n+4>>2]=0),!(sr(10860)|0)){e=10860,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));t8(10860)}return 10860}function GM(e){return e=e|0,e|0}function YM(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=wE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(e8(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(KM(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function e8(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function KM(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=XM(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,QM(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,e8(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,JM(e,s),ZM(s),y=w;return}}function XM(e){return e=e|0,536870911}function QM(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function JM(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function ZM(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function t8(e){e=e|0,tk(e)}function $M(e){e=e|0,ek(e+24|0)}function ek(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function tk(e){e=e|0;var n=0;n=yr()|0,jn(e,1,11,n,nk()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function nk(){return 1840}function rk(e,n,r){e=e|0,n=n|0,r=r|0,uk(t[(ik(e)|0)>>2]|0,n,r)}function ik(e){return e=e|0,(t[(wE()|0)+24>>2]|0)+(e<<3)|0}function uk(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;u=y,y=y+16|0,a=u+1|0,s=u,Pf(a,n),n=If(a,n)|0,Pf(s,r),r=If(s,r)|0,I1[e&31](n,r),y=u}function ok(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=SE()|0,e=lk(r)|0,wi(a,n,s,e,sk(r,u)|0,u)}function SE(){var e=0,n=0;if(h[8048]|0||(r8(10896),Wt(66,10896,ge|0)|0,n=8048,t[n>>2]=1,t[n+4>>2]=0),!(sr(10896)|0)){e=10896,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));r8(10896)}return 10896}function lk(e){return e=e|0,e|0}function sk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=SE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(n8(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(ak(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function n8(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function ak(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=fk(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,ck(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,n8(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,dk(e,s),pk(s),y=w;return}}function fk(e){return e=e|0,536870911}function ck(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function dk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function pk(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function r8(e){e=e|0,mk(e)}function hk(e){e=e|0,vk(e+24|0)}function vk(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function mk(e){e=e|0;var n=0;n=yr()|0,jn(e,1,11,n,yk()|0,1),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function yk(){return 1852}function gk(e,n){return e=e|0,n=n|0,Ek(t[(_k(e)|0)>>2]|0,n)|0}function _k(e){return e=e|0,(t[(SE()|0)+24>>2]|0)+(e<<3)|0}function Ek(e,n){e=e|0,n=n|0;var r=0,u=0;return r=y,y=y+16|0,u=r,Pf(u,n),n=If(u,n)|0,n=H0(Qp[e&31](n)|0)|0,y=r,n|0}function Dk(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=TE()|0,e=wk(r)|0,wi(a,n,s,e,Sk(r,u)|0,u)}function TE(){var e=0,n=0;if(h[8056]|0||(u8(10932),Wt(67,10932,ge|0)|0,n=8056,t[n>>2]=1,t[n+4>>2]=0),!(sr(10932)|0)){e=10932,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));u8(10932)}return 10932}function wk(e){return e=e|0,e|0}function Sk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=TE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(i8(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(Tk(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function i8(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function Tk(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=Ck(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,xk(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,i8(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,Rk(e,s),Ak(s),y=w;return}}function Ck(e){return e=e|0,536870911}function xk(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function Rk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Ak(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function u8(e){e=e|0,kk(e)}function Ok(e){e=e|0,Mk(e+24|0)}function Mk(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function kk(e){e=e|0;var n=0;n=yr()|0,jn(e,1,7,n,Nk()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function Nk(){return 1860}function Lk(e,n,r){return e=e|0,n=n|0,r=r|0,Pk(t[(Fk(e)|0)>>2]|0,n,r)|0}function Fk(e){return e=e|0,(t[(TE()|0)+24>>2]|0)+(e<<3)|0}function Pk(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0;return u=y,y=y+32|0,v=u+12|0,a=u+8|0,w=u,T=u+16|0,s=u+4|0,Ik(T,n),bk(w,T,n),Ys(s,r),r=Ks(s,r)|0,t[v>>2]=t[w>>2],Fy[e&15](a,v,r),r=Bk(a)|0,U0(a),Xs(s),y=u,r|0}function Ik(e,n){e=e|0,n=n|0}function bk(e,n,r){e=e|0,n=n|0,r=r|0,Uk(e,r)}function Bk(e){return e=e|0,go(e)|0}function Uk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0;s=y,y=y+16|0,r=s,u=n,u&1?(jk(r,0),eu(u|0,r|0)|0,zk(e,r),Hk(r)):t[e>>2]=t[n>>2],y=s}function jk(e,n){e=e|0,n=n|0,fd(e,n),t[e+4>>2]=0,h[e+8>>0]=0}function zk(e,n){e=e|0,n=n|0,t[e>>2]=t[n+4>>2]}function Hk(e){e=e|0,h[e+8>>0]=0}function qk(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=CE()|0,e=Wk(r)|0,wi(a,n,s,e,Vk(r,u)|0,u)}function CE(){var e=0,n=0;if(h[8064]|0||(l8(10968),Wt(68,10968,ge|0)|0,n=8064,t[n>>2]=1,t[n+4>>2]=0),!(sr(10968)|0)){e=10968,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));l8(10968)}return 10968}function Wk(e){return e=e|0,e|0}function Vk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=CE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(o8(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(Gk(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function o8(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function Gk(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=Yk(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,Kk(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,o8(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,Xk(e,s),Qk(s),y=w;return}}function Yk(e){return e=e|0,536870911}function Kk(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function Xk(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function Qk(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function l8(e){e=e|0,$k(e)}function Jk(e){e=e|0,Zk(e+24|0)}function Zk(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function $k(e){e=e|0;var n=0;n=yr()|0,jn(e,1,1,n,eN()|0,5),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function eN(){return 1872}function tN(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,rN(t[(nN(e)|0)>>2]|0,n,r,u,s,a)}function nN(e){return e=e|0,(t[(CE()|0)+24>>2]|0)+(e<<3)|0}function rN(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0;var v=0,w=0,T=0,L=0,M=0,b=0;v=y,y=y+32|0,w=v+16|0,T=v+12|0,L=v+8|0,M=v+4|0,b=v,Ys(w,n),n=Ks(w,n)|0,Ys(T,r),r=Ks(T,r)|0,Ys(L,u),u=Ks(L,u)|0,Ys(M,s),s=Ks(M,s)|0,Ys(b,a),a=Ks(b,a)|0,O8[e&1](n,r,u,s,a),Xs(b),Xs(M),Xs(L),Xs(T),Xs(w),y=v}function iN(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;a=t[e>>2]|0,s=xE()|0,e=uN(r)|0,wi(a,n,s,e,oN(r,u)|0,u)}function xE(){var e=0,n=0;if(h[8072]|0||(a8(11004),Wt(69,11004,ge|0)|0,n=8072,t[n>>2]=1,t[n+4>>2]=0),!(sr(11004)|0)){e=11004,n=e+36|0;do t[e>>2]=0,e=e+4|0;while((e|0)<(n|0));a8(11004)}return 11004}function uN(e){return e=e|0,e|0}function oN(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0,w=0,T=0;return w=y,y=y+16|0,s=w,a=w+4|0,t[s>>2]=e,T=xE()|0,v=T+24|0,n=hn(n,4)|0,t[a>>2]=n,r=T+28|0,u=t[r>>2]|0,u>>>0<(t[T+32>>2]|0)>>>0?(s8(u,e,n),n=(t[r>>2]|0)+8|0,t[r>>2]=n):(lN(v,s,a),n=t[r>>2]|0),y=w,(n-(t[v>>2]|0)>>3)+-1|0}function s8(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,t[e+4>>2]=r}function lN(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0;if(w=y,y=y+32|0,s=w,a=e+4|0,v=((t[a>>2]|0)-(t[e>>2]|0)>>3)+1|0,u=sN(e)|0,u>>>0<v>>>0)di(e);else{T=t[e>>2]|0,M=(t[e+8>>2]|0)-T|0,L=M>>2,aN(s,M>>3>>>0<u>>>1>>>0?L>>>0<v>>>0?v:L:u,(t[a>>2]|0)-T>>3,e+8|0),v=s+8|0,s8(t[v>>2]|0,t[n>>2]|0,t[r>>2]|0),t[v>>2]=(t[v>>2]|0)+8,fN(e,s),cN(s),y=w;return}}function sN(e){return e=e|0,536870911}function aN(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0;t[e+12>>2]=0,t[e+16>>2]=u;do if(n)if(n>>>0>536870911)$n();else{s=pn(n<<3)|0;break}else s=0;while(0);t[e>>2]=s,u=s+(r<<3)|0,t[e+8>>2]=u,t[e+4>>2]=u,t[e+12>>2]=s+(n<<3)}function fN(e,n){e=e|0,n=n|0;var r=0,u=0,s=0,a=0,v=0;u=t[e>>2]|0,v=e+4|0,a=n+4|0,s=(t[v>>2]|0)-u|0,r=(t[a>>2]|0)+(0-(s>>3)<<3)|0,t[a>>2]=r,(s|0)>0?(gr(r|0,u|0,s|0)|0,u=a,r=t[a>>2]|0):u=a,a=t[e>>2]|0,t[e>>2]=r,t[u>>2]=a,a=n+8|0,s=t[v>>2]|0,t[v>>2]=t[a>>2],t[a>>2]=s,a=e+8|0,v=n+12|0,e=t[a>>2]|0,t[a>>2]=t[v>>2],t[v>>2]=e,t[n>>2]=t[u>>2]}function cN(e){e=e|0;var n=0,r=0,u=0;n=t[e+4>>2]|0,r=e+8|0,u=t[r>>2]|0,(u|0)!=(n|0)&&(t[r>>2]=u+(~((u+-8-n|0)>>>3)<<3)),e=t[e>>2]|0,e|0&&Et(e)}function a8(e){e=e|0,hN(e)}function dN(e){e=e|0,pN(e+24|0)}function pN(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function hN(e){e=e|0;var n=0;n=yr()|0,jn(e,1,12,n,vN()|0,2),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function vN(){return 1896}function mN(e,n,r){e=e|0,n=n|0,r=r|0,gN(t[(yN(e)|0)>>2]|0,n,r)}function yN(e){return e=e|0,(t[(xE()|0)+24>>2]|0)+(e<<3)|0}function gN(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;u=y,y=y+16|0,a=u+4|0,s=u,_N(a,n),n=EN(a,n)|0,Ys(s,r),r=Ks(s,r)|0,I1[e&31](n,r),Xs(s),y=u}function _N(e,n){e=e|0,n=n|0}function EN(e,n){return e=e|0,n=n|0,DN(n)|0}function DN(e){return e=e|0,e|0}function wN(){var e=0;return h[8080]|0||(f8(11040),Wt(70,11040,ge|0)|0,e=8080,t[e>>2]=1,t[e+4>>2]=0),sr(11040)|0||f8(11040),11040}function f8(e){e=e|0,CN(e),Vp(e,71)}function SN(e){e=e|0,TN(e+24|0)}function TN(e){e=e|0;var n=0,r=0,u=0;r=t[e>>2]|0,u=r,r|0&&(e=e+4|0,n=t[e>>2]|0,(n|0)!=(r|0)&&(t[e>>2]=n+(~((n+-8-u|0)>>>3)<<3)),Et(r))}function CN(e){e=e|0;var n=0;n=yr()|0,jn(e,5,7,n,ON()|0,0),t[e+24>>2]=0,t[e+28>>2]=0,t[e+32>>2]=0}function xN(e){e=e|0,RN(e)}function RN(e){e=e|0,AN(e)}function AN(e){e=e|0,h[e+8>>0]=1}function ON(){return 1936}function MN(){return kN()|0}function kN(){var e=0,n=0,r=0,u=0,s=0,a=0,v=0;return n=y,y=y+16|0,s=n+4|0,v=n,r=Oa(8)|0,e=r,a=e+4|0,t[a>>2]=pn(1)|0,u=pn(8)|0,a=t[a>>2]|0,t[v>>2]=0,t[s>>2]=t[v>>2],NN(u,a,s),t[r>>2]=u,y=n,e|0}function NN(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]=n,r=pn(16)|0,t[r+4>>2]=0,t[r+8>>2]=0,t[r>>2]=1916,t[r+12>>2]=n,t[e+4>>2]=r}function LN(e){e=e|0,Uv(e),Et(e)}function FN(e){e=e|0,e=t[e+12>>2]|0,e|0&&Et(e)}function PN(e){e=e|0,Et(e)}function IN(){var e=0;return h[8088]|0||(qN(11076),Wt(25,11076,ge|0)|0,e=8088,t[e>>2]=1,t[e+4>>2]=0),11076}function bN(e,n){e=e|0,n=n|0,t[e>>2]=BN()|0,t[e+4>>2]=UN()|0,t[e+12>>2]=n,t[e+8>>2]=jN()|0,t[e+32>>2]=10}function BN(){return 11745}function UN(){return 1940}function jN(){return L1()|0}function zN(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,(Hl(u,896)|0)==512?r|0&&(HN(r),Et(r)):n|0&&Et(n)}function HN(e){e=e|0,e=t[e+4>>2]|0,e|0&&$d(e)}function qN(e){e=e|0,Xa(e)}function Gf(e,n){e=e|0,n=n|0,t[e>>2]=n}function RE(e){return e=e|0,t[e>>2]|0}function WN(e){return e=e|0,h[t[e>>2]>>0]|0}function VN(e,n){e=e|0,n=n|0;var r=0,u=0;r=y,y=y+16|0,u=r,t[u>>2]=t[e>>2],GN(n,u)|0,y=r}function GN(e,n){e=e|0,n=n|0;var r=0;return r=YN(t[e>>2]|0,n)|0,n=e+4|0,t[(t[n>>2]|0)+8>>2]=r,t[(t[n>>2]|0)+8>>2]|0}function YN(e,n){e=e|0,n=n|0;var r=0,u=0;return r=y,y=y+16|0,u=r,Ma(u),e=go(e)|0,n=KN(e,t[n>>2]|0)|0,ka(u),y=r,n|0}function Ma(e){e=e|0,t[e>>2]=t[2701],t[e+4>>2]=t[2703]}function KN(e,n){e=e|0,n=n|0;var r=0;return r=_o(XN()|0)|0,Ki(0,r|0,e|0,EE(n)|0)|0}function ka(e){e=e|0,$w(t[e>>2]|0,t[e+4>>2]|0)}function XN(){var e=0;return h[8096]|0||(QN(11120),e=8096,t[e>>2]=1,t[e+4>>2]=0),11120}function QN(e){e=e|0,ll(e,JN()|0,1)}function JN(){return 1948}function ZN(){$N()}function $N(){var e=0,n=0,r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0;if(Te=y,y=y+16|0,M=Te+4|0,b=Te,In(65536,10804,t[2702]|0,10812),r=Fw()|0,n=t[r>>2]|0,e=t[n>>2]|0,e|0)for(u=t[r+8>>2]|0,r=t[r+4>>2]|0;Xl(e|0,N[r>>0]|0|0,h[u>>0]|0),n=n+4|0,e=t[n>>2]|0,e;)u=u+1|0,r=r+1|0;if(e=Pw()|0,n=t[e>>2]|0,n|0)do ko(n|0,t[e+4>>2]|0),e=e+8|0,n=t[e>>2]|0;while((n|0)!=0);ko(eL()|0,5167),L=Fv()|0,e=t[L>>2]|0;e:do if(e|0){do tL(t[e+4>>2]|0),e=t[e>>2]|0;while((e|0)!=0);if(e=t[L>>2]|0,e|0){T=L;do{for(;s=e,e=t[e>>2]|0,s=t[s+4>>2]|0,!!(nL(s)|0);)if(t[b>>2]=T,t[M>>2]=t[b>>2],rL(L,M)|0,!e)break e;if(iL(s),T=t[T>>2]|0,n=c8(s)|0,a=fo()|0,v=y,y=y+((1*(n<<2)|0)+15&-16)|0,w=y,y=y+((1*(n<<2)|0)+15&-16)|0,n=t[(Yw(s)|0)>>2]|0,n|0)for(r=v,u=w;t[r>>2]=t[(Pv(t[n+4>>2]|0)|0)>>2],t[u>>2]=t[n+8>>2],n=t[n>>2]|0,n;)r=r+4|0,u=u+4|0;ye=Pv(s)|0,n=uL(s)|0,r=c8(s)|0,u=oL(s)|0,No(ye|0,n|0,v|0,w|0,r|0,u|0,hE(s)|0),yi(a|0)}while((e|0)!=0)}}while(0);if(e=t[(vE()|0)>>2]|0,e|0)do ye=e+4|0,L=mE(ye)|0,s=My(L)|0,a=Ay(L)|0,v=(Oy(L)|0)+1|0,w=d_(L)|0,T=d8(ye)|0,L=sr(L)|0,M=a_(ye)|0,b=AE(ye)|0,ao(0,s|0,a|0,v|0,w|0,T|0,L|0,M|0,b|0,OE(ye)|0),e=t[e>>2]|0;while((e|0)!=0);e=t[(Fv()|0)>>2]|0;e:do if(e|0){t:for(;;){if(n=t[e+4>>2]|0,n|0&&(X=t[(Pv(n)|0)>>2]|0,Be=t[(Kw(n)|0)>>2]|0,Be|0)){r=Be;do{n=r+4|0,u=mE(n)|0;n:do if(u|0)switch(sr(u)|0){case 0:break t;case 4:case 3:case 2:{w=My(u)|0,T=Ay(u)|0,L=(Oy(u)|0)+1|0,M=d_(u)|0,b=sr(u)|0,ye=a_(n)|0,ao(X|0,w|0,T|0,L|0,M|0,0,b|0,ye|0,AE(n)|0,OE(n)|0);break n}case 1:{v=My(u)|0,w=Ay(u)|0,T=(Oy(u)|0)+1|0,L=d_(u)|0,M=d8(n)|0,b=sr(u)|0,ye=a_(n)|0,ao(X|0,v|0,w|0,T|0,L|0,M|0,b|0,ye|0,AE(n)|0,OE(n)|0);break n}case 5:{L=My(u)|0,M=Ay(u)|0,b=(Oy(u)|0)+1|0,ye=d_(u)|0,ao(X|0,L|0,M|0,b|0,ye|0,lL(u)|0,sr(u)|0,0,0,0);break n}default:break n}while(0);r=t[r>>2]|0}while((r|0)!=0)}if(e=t[e>>2]|0,!e)break e}$n()}while(0);Is(),y=Te}function eL(){return 11703}function tL(e){e=e|0,h[e+40>>0]=0}function nL(e){return e=e|0,(h[e+40>>0]|0)!=0|0}function rL(e,n){return e=e|0,n=n|0,n=sL(n)|0,e=t[n>>2]|0,t[n>>2]=t[e>>2],Et(e),t[n>>2]|0}function iL(e){e=e|0,h[e+40>>0]=1}function c8(e){return e=e|0,t[e+20>>2]|0}function uL(e){return e=e|0,t[e+8>>2]|0}function oL(e){return e=e|0,t[e+32>>2]|0}function d_(e){return e=e|0,t[e+4>>2]|0}function d8(e){return e=e|0,t[e+4>>2]|0}function AE(e){return e=e|0,t[e+8>>2]|0}function OE(e){return e=e|0,t[e+16>>2]|0}function lL(e){return e=e|0,t[e+20>>2]|0}function sL(e){return e=e|0,t[e>>2]|0}function p_(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0,Ze=0,Ye=0,ct=0,ke=0,Ie=0,Zt=0;Zt=y,y=y+16|0,X=Zt;do if(e>>>0<245){if(L=e>>>0<11?16:e+11&-8,e=L>>>3,b=t[2783]|0,r=b>>>e,r&3|0)return n=(r&1^1)+e|0,e=11172+(n<<1<<2)|0,r=e+8|0,u=t[r>>2]|0,s=u+8|0,a=t[s>>2]|0,(e|0)==(a|0)?t[2783]=b&~(1<<n):(t[a+12>>2]=e,t[r>>2]=a),Ie=n<<3,t[u+4>>2]=Ie|3,Ie=u+Ie+4|0,t[Ie>>2]=t[Ie>>2]|1,Ie=s,y=Zt,Ie|0;if(M=t[2785]|0,L>>>0>M>>>0){if(r|0)return n=2<<e,n=r<<e&(n|0-n),n=(n&0-n)+-1|0,v=n>>>12&16,n=n>>>v,r=n>>>5&8,n=n>>>r,s=n>>>2&4,n=n>>>s,e=n>>>1&2,n=n>>>e,u=n>>>1&1,u=(r|v|s|e|u)+(n>>>u)|0,n=11172+(u<<1<<2)|0,e=n+8|0,s=t[e>>2]|0,v=s+8|0,r=t[v>>2]|0,(n|0)==(r|0)?(e=b&~(1<<u),t[2783]=e):(t[r+12>>2]=n,t[e>>2]=r,e=b),a=(u<<3)-L|0,t[s+4>>2]=L|3,u=s+L|0,t[u+4>>2]=a|1,t[u+a>>2]=a,M|0&&(s=t[2788]|0,n=M>>>3,r=11172+(n<<1<<2)|0,n=1<<n,e&n?(e=r+8|0,n=t[e>>2]|0):(t[2783]=e|n,n=r,e=r+8|0),t[e>>2]=s,t[n+12>>2]=s,t[s+8>>2]=n,t[s+12>>2]=r),t[2785]=a,t[2788]=u,Ie=v,y=Zt,Ie|0;if(w=t[2784]|0,w){if(r=(w&0-w)+-1|0,v=r>>>12&16,r=r>>>v,a=r>>>5&8,r=r>>>a,T=r>>>2&4,r=r>>>T,u=r>>>1&2,r=r>>>u,e=r>>>1&1,e=t[11436+((a|v|T|u|e)+(r>>>e)<<2)>>2]|0,r=(t[e+4>>2]&-8)-L|0,u=t[e+16+(((t[e+16>>2]|0)==0&1)<<2)>>2]|0,!u)T=e,a=r;else{do v=(t[u+4>>2]&-8)-L|0,T=v>>>0<r>>>0,r=T?v:r,e=T?u:e,u=t[u+16+(((t[u+16>>2]|0)==0&1)<<2)>>2]|0;while((u|0)!=0);T=e,a=r}if(v=T+L|0,T>>>0<v>>>0){s=t[T+24>>2]|0,n=t[T+12>>2]|0;do if((n|0)==(T|0)){if(e=T+20|0,n=t[e>>2]|0,!n&&(e=T+16|0,n=t[e>>2]|0,!n)){r=0;break}for(;;){if(r=n+20|0,u=t[r>>2]|0,u|0){n=u,e=r;continue}if(r=n+16|0,u=t[r>>2]|0,u)n=u,e=r;else break}t[e>>2]=0,r=n}else r=t[T+8>>2]|0,t[r+12>>2]=n,t[n+8>>2]=r,r=n;while(0);do if(s|0){if(n=t[T+28>>2]|0,e=11436+(n<<2)|0,(T|0)==(t[e>>2]|0)){if(t[e>>2]=r,!r){t[2784]=w&~(1<<n);break}}else if(t[s+16+(((t[s+16>>2]|0)!=(T|0)&1)<<2)>>2]=r,!r)break;t[r+24>>2]=s,n=t[T+16>>2]|0,n|0&&(t[r+16>>2]=n,t[n+24>>2]=r),n=t[T+20>>2]|0,n|0&&(t[r+20>>2]=n,t[n+24>>2]=r)}while(0);return a>>>0<16?(Ie=a+L|0,t[T+4>>2]=Ie|3,Ie=T+Ie+4|0,t[Ie>>2]=t[Ie>>2]|1):(t[T+4>>2]=L|3,t[v+4>>2]=a|1,t[v+a>>2]=a,M|0&&(u=t[2788]|0,n=M>>>3,r=11172+(n<<1<<2)|0,n=1<<n,b&n?(e=r+8|0,n=t[e>>2]|0):(t[2783]=b|n,n=r,e=r+8|0),t[e>>2]=u,t[n+12>>2]=u,t[u+8>>2]=n,t[u+12>>2]=r),t[2785]=a,t[2788]=v),Ie=T+8|0,y=Zt,Ie|0}else b=L}else b=L}else b=L}else if(e>>>0<=4294967231)if(e=e+11|0,L=e&-8,T=t[2784]|0,T){u=0-L|0,e=e>>>8,e?L>>>0>16777215?w=31:(b=(e+1048320|0)>>>16&8,ke=e<<b,M=(ke+520192|0)>>>16&4,ke=ke<<M,w=(ke+245760|0)>>>16&2,w=14-(M|b|w)+(ke<<w>>>15)|0,w=L>>>(w+7|0)&1|w<<1):w=0,r=t[11436+(w<<2)>>2]|0;e:do if(!r)r=0,e=0,ke=57;else for(e=0,v=L<<((w|0)==31?0:25-(w>>>1)|0),a=0;;){if(s=(t[r+4>>2]&-8)-L|0,s>>>0<u>>>0)if(s)e=r,u=s;else{e=r,u=0,s=r,ke=61;break e}if(s=t[r+20>>2]|0,r=t[r+16+(v>>>31<<2)>>2]|0,a=(s|0)==0|(s|0)==(r|0)?a:s,s=(r|0)==0,s){r=a,ke=57;break}else v=v<<((s^1)&1)}while(0);if((ke|0)==57){if((r|0)==0&(e|0)==0){if(e=2<<w,e=T&(e|0-e),!e){b=L;break}b=(e&0-e)+-1|0,v=b>>>12&16,b=b>>>v,a=b>>>5&8,b=b>>>a,w=b>>>2&4,b=b>>>w,M=b>>>1&2,b=b>>>M,r=b>>>1&1,e=0,r=t[11436+((a|v|w|M|r)+(b>>>r)<<2)>>2]|0}r?(s=r,ke=61):(w=e,v=u)}if((ke|0)==61)for(;;)if(ke=0,r=(t[s+4>>2]&-8)-L|0,b=r>>>0<u>>>0,r=b?r:u,e=b?s:e,s=t[s+16+(((t[s+16>>2]|0)==0&1)<<2)>>2]|0,s)u=r,ke=61;else{w=e,v=r;break}if((w|0)!=0&&v>>>0<((t[2785]|0)-L|0)>>>0){if(a=w+L|0,w>>>0>=a>>>0)return Ie=0,y=Zt,Ie|0;s=t[w+24>>2]|0,n=t[w+12>>2]|0;do if((n|0)==(w|0)){if(e=w+20|0,n=t[e>>2]|0,!n&&(e=w+16|0,n=t[e>>2]|0,!n)){n=0;break}for(;;){if(r=n+20|0,u=t[r>>2]|0,u|0){n=u,e=r;continue}if(r=n+16|0,u=t[r>>2]|0,u)n=u,e=r;else break}t[e>>2]=0}else Ie=t[w+8>>2]|0,t[Ie+12>>2]=n,t[n+8>>2]=Ie;while(0);do if(s){if(e=t[w+28>>2]|0,r=11436+(e<<2)|0,(w|0)==(t[r>>2]|0)){if(t[r>>2]=n,!n){u=T&~(1<<e),t[2784]=u;break}}else if(t[s+16+(((t[s+16>>2]|0)!=(w|0)&1)<<2)>>2]=n,!n){u=T;break}t[n+24>>2]=s,e=t[w+16>>2]|0,e|0&&(t[n+16>>2]=e,t[e+24>>2]=n),e=t[w+20>>2]|0,e&&(t[n+20>>2]=e,t[e+24>>2]=n),u=T}else u=T;while(0);do if(v>>>0>=16){if(t[w+4>>2]=L|3,t[a+4>>2]=v|1,t[a+v>>2]=v,n=v>>>3,v>>>0<256){r=11172+(n<<1<<2)|0,e=t[2783]|0,n=1<<n,e&n?(e=r+8|0,n=t[e>>2]|0):(t[2783]=e|n,n=r,e=r+8|0),t[e>>2]=a,t[n+12>>2]=a,t[a+8>>2]=n,t[a+12>>2]=r;break}if(n=v>>>8,n?v>>>0>16777215?n=31:(ke=(n+1048320|0)>>>16&8,Ie=n<<ke,ct=(Ie+520192|0)>>>16&4,Ie=Ie<<ct,n=(Ie+245760|0)>>>16&2,n=14-(ct|ke|n)+(Ie<<n>>>15)|0,n=v>>>(n+7|0)&1|n<<1):n=0,r=11436+(n<<2)|0,t[a+28>>2]=n,e=a+16|0,t[e+4>>2]=0,t[e>>2]=0,e=1<<n,!(u&e)){t[2784]=u|e,t[r>>2]=a,t[a+24>>2]=r,t[a+12>>2]=a,t[a+8>>2]=a;break}for(e=v<<((n|0)==31?0:25-(n>>>1)|0),r=t[r>>2]|0;;){if((t[r+4>>2]&-8|0)==(v|0)){ke=97;break}if(u=r+16+(e>>>31<<2)|0,n=t[u>>2]|0,n)e=e<<1,r=n;else{ke=96;break}}if((ke|0)==96){t[u>>2]=a,t[a+24>>2]=r,t[a+12>>2]=a,t[a+8>>2]=a;break}else if((ke|0)==97){ke=r+8|0,Ie=t[ke>>2]|0,t[Ie+12>>2]=a,t[ke>>2]=a,t[a+8>>2]=Ie,t[a+12>>2]=r,t[a+24>>2]=0;break}}else Ie=v+L|0,t[w+4>>2]=Ie|3,Ie=w+Ie+4|0,t[Ie>>2]=t[Ie>>2]|1;while(0);return Ie=w+8|0,y=Zt,Ie|0}else b=L}else b=L;else b=-1;while(0);if(r=t[2785]|0,r>>>0>=b>>>0)return n=r-b|0,e=t[2788]|0,n>>>0>15?(Ie=e+b|0,t[2788]=Ie,t[2785]=n,t[Ie+4>>2]=n|1,t[Ie+n>>2]=n,t[e+4>>2]=b|3):(t[2785]=0,t[2788]=0,t[e+4>>2]=r|3,Ie=e+r+4|0,t[Ie>>2]=t[Ie>>2]|1),Ie=e+8|0,y=Zt,Ie|0;if(v=t[2786]|0,v>>>0>b>>>0)return ct=v-b|0,t[2786]=ct,Ie=t[2789]|0,ke=Ie+b|0,t[2789]=ke,t[ke+4>>2]=ct|1,t[Ie+4>>2]=b|3,Ie=Ie+8|0,y=Zt,Ie|0;if(t[2901]|0?e=t[2903]|0:(t[2903]=4096,t[2902]=4096,t[2904]=-1,t[2905]=-1,t[2906]=0,t[2894]=0,e=X&-16^1431655768,t[X>>2]=e,t[2901]=e,e=4096),w=b+48|0,T=b+47|0,a=e+T|0,s=0-e|0,L=a&s,L>>>0<=b>>>0||(e=t[2893]|0,e|0&&(M=t[2891]|0,X=M+L|0,X>>>0<=M>>>0|X>>>0>e>>>0)))return Ie=0,y=Zt,Ie|0;e:do if(t[2894]&4)n=0,ke=133;else{r=t[2789]|0;t:do if(r){for(u=11580;e=t[u>>2]|0,!(e>>>0<=r>>>0&&(ye=u+4|0,(e+(t[ye>>2]|0)|0)>>>0>r>>>0));)if(e=t[u+8>>2]|0,e)u=e;else{ke=118;break t}if(n=a-v&s,n>>>0<2147483647)if(e=e2(n|0)|0,(e|0)==((t[u>>2]|0)+(t[ye>>2]|0)|0)){if((e|0)!=-1){v=n,a=e,ke=135;break e}}else u=e,ke=126;else n=0}else ke=118;while(0);do if((ke|0)==118)if(r=e2(0)|0,(r|0)!=-1&&(n=r,Be=t[2902]|0,Te=Be+-1|0,n=((Te&n|0)==0?0:(Te+n&0-Be)-n|0)+L|0,Be=t[2891]|0,Te=n+Be|0,n>>>0>b>>>0&n>>>0<2147483647)){if(ye=t[2893]|0,ye|0&&Te>>>0<=Be>>>0|Te>>>0>ye>>>0){n=0;break}if(e=e2(n|0)|0,(e|0)==(r|0)){v=n,a=r,ke=135;break e}else u=e,ke=126}else n=0;while(0);do if((ke|0)==126){if(r=0-n|0,!(w>>>0>n>>>0&(n>>>0<2147483647&(u|0)!=-1)))if((u|0)==-1){n=0;break}else{v=n,a=u,ke=135;break e}if(e=t[2903]|0,e=T-n+e&0-e,e>>>0>=2147483647){v=n,a=u,ke=135;break e}if((e2(e|0)|0)==-1){e2(r|0)|0,n=0;break}else{v=e+n|0,a=u,ke=135;break e}}while(0);t[2894]=t[2894]|4,ke=133}while(0);if((ke|0)==133&&L>>>0<2147483647&&(ct=e2(L|0)|0,ye=e2(0)|0,Ze=ye-ct|0,Ye=Ze>>>0>(b+40|0)>>>0,!((ct|0)==-1|Ye^1|ct>>>0<ye>>>0&((ct|0)!=-1&(ye|0)!=-1)^1))&&(v=Ye?Ze:n,a=ct,ke=135),(ke|0)==135){n=(t[2891]|0)+v|0,t[2891]=n,n>>>0>(t[2892]|0)>>>0&&(t[2892]=n),T=t[2789]|0;do if(T){for(n=11580;;){if(e=t[n>>2]|0,r=n+4|0,u=t[r>>2]|0,(a|0)==(e+u|0)){ke=145;break}if(s=t[n+8>>2]|0,s)n=s;else break}if((ke|0)==145&&(t[n+12>>2]&8|0)==0&&T>>>0<a>>>0&T>>>0>=e>>>0){t[r>>2]=u+v,Ie=T+8|0,Ie=(Ie&7|0)==0?0:0-Ie&7,ke=T+Ie|0,Ie=(t[2786]|0)+(v-Ie)|0,t[2789]=ke,t[2786]=Ie,t[ke+4>>2]=Ie|1,t[ke+Ie+4>>2]=40,t[2790]=t[2905];break}for(a>>>0<(t[2787]|0)>>>0&&(t[2787]=a),r=a+v|0,n=11580;;){if((t[n>>2]|0)==(r|0)){ke=153;break}if(e=t[n+8>>2]|0,e)n=e;else break}if((ke|0)==153&&(t[n+12>>2]&8|0)==0){t[n>>2]=a,M=n+4|0,t[M>>2]=(t[M>>2]|0)+v,M=a+8|0,M=a+((M&7|0)==0?0:0-M&7)|0,n=r+8|0,n=r+((n&7|0)==0?0:0-n&7)|0,L=M+b|0,w=n-M-b|0,t[M+4>>2]=b|3;do if((n|0)!=(T|0)){if((n|0)==(t[2788]|0)){Ie=(t[2785]|0)+w|0,t[2785]=Ie,t[2788]=L,t[L+4>>2]=Ie|1,t[L+Ie>>2]=Ie;break}if(e=t[n+4>>2]|0,(e&3|0)==1){v=e&-8,u=e>>>3;e:do if(e>>>0<256)if(e=t[n+8>>2]|0,r=t[n+12>>2]|0,(r|0)==(e|0)){t[2783]=t[2783]&~(1<<u);break}else{t[e+12>>2]=r,t[r+8>>2]=e;break}else{a=t[n+24>>2]|0,e=t[n+12>>2]|0;do if((e|0)==(n|0)){if(u=n+16|0,r=u+4|0,e=t[r>>2]|0,!e)if(e=t[u>>2]|0,e)r=u;else{e=0;break}for(;;){if(u=e+20|0,s=t[u>>2]|0,s|0){e=s,r=u;continue}if(u=e+16|0,s=t[u>>2]|0,s)e=s,r=u;else break}t[r>>2]=0}else Ie=t[n+8>>2]|0,t[Ie+12>>2]=e,t[e+8>>2]=Ie;while(0);if(!a)break;r=t[n+28>>2]|0,u=11436+(r<<2)|0;do if((n|0)!=(t[u>>2]|0)){if(t[a+16+(((t[a+16>>2]|0)!=(n|0)&1)<<2)>>2]=e,!e)break e}else{if(t[u>>2]=e,e|0)break;t[2784]=t[2784]&~(1<<r);break e}while(0);if(t[e+24>>2]=a,r=n+16|0,u=t[r>>2]|0,u|0&&(t[e+16>>2]=u,t[u+24>>2]=e),r=t[r+4>>2]|0,!r)break;t[e+20>>2]=r,t[r+24>>2]=e}while(0);n=n+v|0,s=v+w|0}else s=w;if(n=n+4|0,t[n>>2]=t[n>>2]&-2,t[L+4>>2]=s|1,t[L+s>>2]=s,n=s>>>3,s>>>0<256){r=11172+(n<<1<<2)|0,e=t[2783]|0,n=1<<n,e&n?(e=r+8|0,n=t[e>>2]|0):(t[2783]=e|n,n=r,e=r+8|0),t[e>>2]=L,t[n+12>>2]=L,t[L+8>>2]=n,t[L+12>>2]=r;break}n=s>>>8;do if(!n)n=0;else{if(s>>>0>16777215){n=31;break}ke=(n+1048320|0)>>>16&8,Ie=n<<ke,ct=(Ie+520192|0)>>>16&4,Ie=Ie<<ct,n=(Ie+245760|0)>>>16&2,n=14-(ct|ke|n)+(Ie<<n>>>15)|0,n=s>>>(n+7|0)&1|n<<1}while(0);if(u=11436+(n<<2)|0,t[L+28>>2]=n,e=L+16|0,t[e+4>>2]=0,t[e>>2]=0,e=t[2784]|0,r=1<<n,!(e&r)){t[2784]=e|r,t[u>>2]=L,t[L+24>>2]=u,t[L+12>>2]=L,t[L+8>>2]=L;break}for(e=s<<((n|0)==31?0:25-(n>>>1)|0),r=t[u>>2]|0;;){if((t[r+4>>2]&-8|0)==(s|0)){ke=194;break}if(u=r+16+(e>>>31<<2)|0,n=t[u>>2]|0,n)e=e<<1,r=n;else{ke=193;break}}if((ke|0)==193){t[u>>2]=L,t[L+24>>2]=r,t[L+12>>2]=L,t[L+8>>2]=L;break}else if((ke|0)==194){ke=r+8|0,Ie=t[ke>>2]|0,t[Ie+12>>2]=L,t[ke>>2]=L,t[L+8>>2]=Ie,t[L+12>>2]=r,t[L+24>>2]=0;break}}else Ie=(t[2786]|0)+w|0,t[2786]=Ie,t[2789]=L,t[L+4>>2]=Ie|1;while(0);return Ie=M+8|0,y=Zt,Ie|0}for(n=11580;e=t[n>>2]|0,!(e>>>0<=T>>>0&&(Ie=e+(t[n+4>>2]|0)|0,Ie>>>0>T>>>0));)n=t[n+8>>2]|0;s=Ie+-47|0,e=s+8|0,e=s+((e&7|0)==0?0:0-e&7)|0,s=T+16|0,e=e>>>0<s>>>0?T:e,n=e+8|0,r=a+8|0,r=(r&7|0)==0?0:0-r&7,ke=a+r|0,r=v+-40-r|0,t[2789]=ke,t[2786]=r,t[ke+4>>2]=r|1,t[ke+r+4>>2]=40,t[2790]=t[2905],r=e+4|0,t[r>>2]=27,t[n>>2]=t[2895],t[n+4>>2]=t[2896],t[n+8>>2]=t[2897],t[n+12>>2]=t[2898],t[2895]=a,t[2896]=v,t[2898]=0,t[2897]=n,n=e+24|0;do ke=n,n=n+4|0,t[n>>2]=7;while((ke+8|0)>>>0<Ie>>>0);if((e|0)!=(T|0)){if(a=e-T|0,t[r>>2]=t[r>>2]&-2,t[T+4>>2]=a|1,t[e>>2]=a,n=a>>>3,a>>>0<256){r=11172+(n<<1<<2)|0,e=t[2783]|0,n=1<<n,e&n?(e=r+8|0,n=t[e>>2]|0):(t[2783]=e|n,n=r,e=r+8|0),t[e>>2]=T,t[n+12>>2]=T,t[T+8>>2]=n,t[T+12>>2]=r;break}if(n=a>>>8,n?a>>>0>16777215?r=31:(ke=(n+1048320|0)>>>16&8,Ie=n<<ke,ct=(Ie+520192|0)>>>16&4,Ie=Ie<<ct,r=(Ie+245760|0)>>>16&2,r=14-(ct|ke|r)+(Ie<<r>>>15)|0,r=a>>>(r+7|0)&1|r<<1):r=0,u=11436+(r<<2)|0,t[T+28>>2]=r,t[T+20>>2]=0,t[s>>2]=0,n=t[2784]|0,e=1<<r,!(n&e)){t[2784]=n|e,t[u>>2]=T,t[T+24>>2]=u,t[T+12>>2]=T,t[T+8>>2]=T;break}for(e=a<<((r|0)==31?0:25-(r>>>1)|0),r=t[u>>2]|0;;){if((t[r+4>>2]&-8|0)==(a|0)){ke=216;break}if(u=r+16+(e>>>31<<2)|0,n=t[u>>2]|0,n)e=e<<1,r=n;else{ke=215;break}}if((ke|0)==215){t[u>>2]=T,t[T+24>>2]=r,t[T+12>>2]=T,t[T+8>>2]=T;break}else if((ke|0)==216){ke=r+8|0,Ie=t[ke>>2]|0,t[Ie+12>>2]=T,t[ke>>2]=T,t[T+8>>2]=Ie,t[T+12>>2]=r,t[T+24>>2]=0;break}}}else{Ie=t[2787]|0,(Ie|0)==0|a>>>0<Ie>>>0&&(t[2787]=a),t[2895]=a,t[2896]=v,t[2898]=0,t[2792]=t[2901],t[2791]=-1,n=0;do Ie=11172+(n<<1<<2)|0,t[Ie+12>>2]=Ie,t[Ie+8>>2]=Ie,n=n+1|0;while((n|0)!=32);Ie=a+8|0,Ie=(Ie&7|0)==0?0:0-Ie&7,ke=a+Ie|0,Ie=v+-40-Ie|0,t[2789]=ke,t[2786]=Ie,t[ke+4>>2]=Ie|1,t[ke+Ie+4>>2]=40,t[2790]=t[2905]}while(0);if(n=t[2786]|0,n>>>0>b>>>0)return ct=n-b|0,t[2786]=ct,Ie=t[2789]|0,ke=Ie+b|0,t[2789]=ke,t[ke+4>>2]=ct|1,t[Ie+4>>2]=b|3,Ie=Ie+8|0,y=Zt,Ie|0}return t[(bv()|0)>>2]=12,Ie=0,y=Zt,Ie|0}function h_(e){e=e|0;var n=0,r=0,u=0,s=0,a=0,v=0,w=0,T=0;if(!!e){r=e+-8|0,s=t[2787]|0,e=t[e+-4>>2]|0,n=e&-8,T=r+n|0;do if(e&1)w=r,v=r;else{if(u=t[r>>2]|0,!(e&3)||(v=r+(0-u)|0,a=u+n|0,v>>>0<s>>>0))return;if((v|0)==(t[2788]|0)){if(e=T+4|0,n=t[e>>2]|0,(n&3|0)!=3){w=v,n=a;break}t[2785]=a,t[e>>2]=n&-2,t[v+4>>2]=a|1,t[v+a>>2]=a;return}if(r=u>>>3,u>>>0<256)if(e=t[v+8>>2]|0,n=t[v+12>>2]|0,(n|0)==(e|0)){t[2783]=t[2783]&~(1<<r),w=v,n=a;break}else{t[e+12>>2]=n,t[n+8>>2]=e,w=v,n=a;break}s=t[v+24>>2]|0,e=t[v+12>>2]|0;do if((e|0)==(v|0)){if(r=v+16|0,n=r+4|0,e=t[n>>2]|0,!e)if(e=t[r>>2]|0,e)n=r;else{e=0;break}for(;;){if(r=e+20|0,u=t[r>>2]|0,u|0){e=u,n=r;continue}if(r=e+16|0,u=t[r>>2]|0,u)e=u,n=r;else break}t[n>>2]=0}else w=t[v+8>>2]|0,t[w+12>>2]=e,t[e+8>>2]=w;while(0);if(s){if(n=t[v+28>>2]|0,r=11436+(n<<2)|0,(v|0)==(t[r>>2]|0)){if(t[r>>2]=e,!e){t[2784]=t[2784]&~(1<<n),w=v,n=a;break}}else if(t[s+16+(((t[s+16>>2]|0)!=(v|0)&1)<<2)>>2]=e,!e){w=v,n=a;break}t[e+24>>2]=s,n=v+16|0,r=t[n>>2]|0,r|0&&(t[e+16>>2]=r,t[r+24>>2]=e),n=t[n+4>>2]|0,n?(t[e+20>>2]=n,t[n+24>>2]=e,w=v,n=a):(w=v,n=a)}else w=v,n=a}while(0);if(!(v>>>0>=T>>>0)&&(e=T+4|0,u=t[e>>2]|0,!!(u&1))){if(u&2)t[e>>2]=u&-2,t[w+4>>2]=n|1,t[v+n>>2]=n,s=n;else{if(e=t[2788]|0,(T|0)==(t[2789]|0)){if(T=(t[2786]|0)+n|0,t[2786]=T,t[2789]=w,t[w+4>>2]=T|1,(w|0)!=(e|0))return;t[2788]=0,t[2785]=0;return}if((T|0)==(e|0)){T=(t[2785]|0)+n|0,t[2785]=T,t[2788]=v,t[w+4>>2]=T|1,t[v+T>>2]=T;return}s=(u&-8)+n|0,r=u>>>3;do if(u>>>0<256)if(n=t[T+8>>2]|0,e=t[T+12>>2]|0,(e|0)==(n|0)){t[2783]=t[2783]&~(1<<r);break}else{t[n+12>>2]=e,t[e+8>>2]=n;break}else{a=t[T+24>>2]|0,e=t[T+12>>2]|0;do if((e|0)==(T|0)){if(r=T+16|0,n=r+4|0,e=t[n>>2]|0,!e)if(e=t[r>>2]|0,e)n=r;else{r=0;break}for(;;){if(r=e+20|0,u=t[r>>2]|0,u|0){e=u,n=r;continue}if(r=e+16|0,u=t[r>>2]|0,u)e=u,n=r;else break}t[n>>2]=0,r=e}else r=t[T+8>>2]|0,t[r+12>>2]=e,t[e+8>>2]=r,r=e;while(0);if(a|0){if(e=t[T+28>>2]|0,n=11436+(e<<2)|0,(T|0)==(t[n>>2]|0)){if(t[n>>2]=r,!r){t[2784]=t[2784]&~(1<<e);break}}else if(t[a+16+(((t[a+16>>2]|0)!=(T|0)&1)<<2)>>2]=r,!r)break;t[r+24>>2]=a,e=T+16|0,n=t[e>>2]|0,n|0&&(t[r+16>>2]=n,t[n+24>>2]=r),e=t[e+4>>2]|0,e|0&&(t[r+20>>2]=e,t[e+24>>2]=r)}}while(0);if(t[w+4>>2]=s|1,t[v+s>>2]=s,(w|0)==(t[2788]|0)){t[2785]=s;return}}if(e=s>>>3,s>>>0<256){r=11172+(e<<1<<2)|0,n=t[2783]|0,e=1<<e,n&e?(n=r+8|0,e=t[n>>2]|0):(t[2783]=n|e,e=r,n=r+8|0),t[n>>2]=w,t[e+12>>2]=w,t[w+8>>2]=e,t[w+12>>2]=r;return}e=s>>>8,e?s>>>0>16777215?e=31:(v=(e+1048320|0)>>>16&8,T=e<<v,a=(T+520192|0)>>>16&4,T=T<<a,e=(T+245760|0)>>>16&2,e=14-(a|v|e)+(T<<e>>>15)|0,e=s>>>(e+7|0)&1|e<<1):e=0,u=11436+(e<<2)|0,t[w+28>>2]=e,t[w+20>>2]=0,t[w+16>>2]=0,n=t[2784]|0,r=1<<e;do if(n&r){for(n=s<<((e|0)==31?0:25-(e>>>1)|0),r=t[u>>2]|0;;){if((t[r+4>>2]&-8|0)==(s|0)){e=73;break}if(u=r+16+(n>>>31<<2)|0,e=t[u>>2]|0,e)n=n<<1,r=e;else{e=72;break}}if((e|0)==72){t[u>>2]=w,t[w+24>>2]=r,t[w+12>>2]=w,t[w+8>>2]=w;break}else if((e|0)==73){v=r+8|0,T=t[v>>2]|0,t[T+12>>2]=w,t[v>>2]=w,t[w+8>>2]=T,t[w+12>>2]=r,t[w+24>>2]=0;break}}else t[2784]=n|r,t[u>>2]=w,t[w+24>>2]=u,t[w+12>>2]=w,t[w+8>>2]=w;while(0);if(T=(t[2791]|0)+-1|0,t[2791]=T,!T)e=11588;else return;for(;e=t[e>>2]|0,e;)e=e+8|0;t[2791]=-1}}}function aL(){return 11628}function fL(e){e=e|0;var n=0,r=0;return n=y,y=y+16|0,r=n,t[r>>2]=pL(t[e+60>>2]|0)|0,e=v_(Au(6,r|0)|0)|0,y=n,e|0}function p8(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0;b=y,y=y+48|0,L=b+16|0,a=b,s=b+32|0,w=e+28|0,u=t[w>>2]|0,t[s>>2]=u,T=e+20|0,u=(t[T>>2]|0)-u|0,t[s+4>>2]=u,t[s+8>>2]=n,t[s+12>>2]=r,u=u+r|0,v=e+60|0,t[a>>2]=t[v>>2],t[a+4>>2]=s,t[a+8>>2]=2,a=v_(h0(146,a|0)|0)|0;e:do if((u|0)!=(a|0)){for(n=2;!((a|0)<0);)if(u=u-a|0,Be=t[s+4>>2]|0,X=a>>>0>Be>>>0,s=X?s+8|0:s,n=(X<<31>>31)+n|0,Be=a-(X?Be:0)|0,t[s>>2]=(t[s>>2]|0)+Be,X=s+4|0,t[X>>2]=(t[X>>2]|0)-Be,t[L>>2]=t[v>>2],t[L+4>>2]=s,t[L+8>>2]=n,a=v_(h0(146,L|0)|0)|0,(u|0)==(a|0)){M=3;break e}t[e+16>>2]=0,t[w>>2]=0,t[T>>2]=0,t[e>>2]=t[e>>2]|32,(n|0)==2?r=0:r=r-(t[s+4>>2]|0)|0}else M=3;while(0);return(M|0)==3&&(Be=t[e+44>>2]|0,t[e+16>>2]=Be+(t[e+48>>2]|0),t[w>>2]=Be,t[T>>2]=Be),y=b,r|0}function cL(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;return s=y,y=y+32|0,a=s,u=s+20|0,t[a>>2]=t[e+60>>2],t[a+4>>2]=0,t[a+8>>2]=n,t[a+12>>2]=u,t[a+16>>2]=r,(v_(Ni(140,a|0)|0)|0)<0?(t[u>>2]=-1,e=-1):e=t[u>>2]|0,y=s,e|0}function v_(e){return e=e|0,e>>>0>4294963200&&(t[(bv()|0)>>2]=0-e,e=-1),e|0}function bv(){return(dL()|0)+64|0}function dL(){return ME()|0}function ME(){return 2084}function pL(e){return e=e|0,e|0}function hL(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;return s=y,y=y+32|0,u=s,t[e+36>>2]=1,(t[e>>2]&64|0)==0&&(t[u>>2]=t[e+60>>2],t[u+4>>2]=21523,t[u+8>>2]=s+16,I0(54,u|0)|0)&&(h[e+75>>0]=-1),u=p8(e,n,r)|0,y=s,u|0}function h8(e,n){e=e|0,n=n|0;var r=0,u=0;if(r=h[e>>0]|0,u=h[n>>0]|0,r<<24>>24==0||r<<24>>24!=u<<24>>24)e=u;else{do e=e+1|0,n=n+1|0,r=h[e>>0]|0,u=h[n>>0]|0;while(!(r<<24>>24==0||r<<24>>24!=u<<24>>24));e=u}return(r&255)-(e&255)|0}function vL(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0;e:do if(!r)e=0;else{for(;u=h[e>>0]|0,s=h[n>>0]|0,u<<24>>24==s<<24>>24;)if(r=r+-1|0,r)e=e+1|0,n=n+1|0;else{e=0;break e}e=(u&255)-(s&255)|0}while(0);return e|0}function v8(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0;ye=y,y=y+224|0,M=ye+120|0,b=ye+80|0,Be=ye,Te=ye+136|0,u=b,s=u+40|0;do t[u>>2]=0,u=u+4|0;while((u|0)<(s|0));return t[M>>2]=t[r>>2],(kE(0,n,M,Be,b)|0)<0?r=-1:((t[e+76>>2]|0)>-1?X=mL(e)|0:X=0,r=t[e>>2]|0,L=r&32,(h[e+74>>0]|0)<1&&(t[e>>2]=r&-33),u=e+48|0,t[u>>2]|0?r=kE(e,n,M,Be,b)|0:(s=e+44|0,a=t[s>>2]|0,t[s>>2]=Te,v=e+28|0,t[v>>2]=Te,w=e+20|0,t[w>>2]=Te,t[u>>2]=80,T=e+16|0,t[T>>2]=Te+80,r=kE(e,n,M,Be,b)|0,a&&(__[t[e+36>>2]&7](e,0,0)|0,r=(t[w>>2]|0)==0?-1:r,t[s>>2]=a,t[u>>2]=0,t[T>>2]=0,t[v>>2]=0,t[w>>2]=0)),u=t[e>>2]|0,t[e>>2]=u|L,X|0&&yL(e),r=(u&32|0)==0?r:-1),y=ye,r|0}function kE(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0,Ze=0,Ye=0,ct=0,ke=0,Ie=0,Zt=0,Br=0,Pn=0,gn=0,_r=0,Pr=0,kn=0;kn=y,y=y+64|0,Pn=kn+16|0,gn=kn,Zt=kn+24|0,_r=kn+8|0,Pr=kn+20|0,t[Pn>>2]=n,ct=(e|0)!=0,ke=Zt+40|0,Ie=ke,Zt=Zt+39|0,Br=_r+4|0,v=0,a=0,M=0;e:for(;;){do if((a|0)>-1)if((v|0)>(2147483647-a|0)){t[(bv()|0)>>2]=75,a=-1;break}else{a=v+a|0;break}while(0);if(v=h[n>>0]|0,v<<24>>24)w=n;else{Ye=87;break}t:for(;;){switch(v<<24>>24){case 37:{v=w,Ye=9;break t}case 0:{v=w;break t}default:}Ze=w+1|0,t[Pn>>2]=Ze,v=h[Ze>>0]|0,w=Ze}t:do if((Ye|0)==9)for(;;){if(Ye=0,(h[w+1>>0]|0)!=37)break t;if(v=v+1|0,w=w+2|0,t[Pn>>2]=w,(h[w>>0]|0)==37)Ye=9;else break}while(0);if(v=v-n|0,ct&&Yo(e,n,v),v|0){n=w;continue}T=w+1|0,v=(h[T>>0]|0)+-48|0,v>>>0<10?(Ze=(h[w+2>>0]|0)==36,ye=Ze?v:-1,M=Ze?1:M,T=Ze?w+3|0:T):ye=-1,t[Pn>>2]=T,v=h[T>>0]|0,w=(v<<24>>24)+-32|0;t:do if(w>>>0<32)for(L=0,b=v;;){if(v=1<<w,!(v&75913)){v=b;break t}if(L=v|L,T=T+1|0,t[Pn>>2]=T,v=h[T>>0]|0,w=(v<<24>>24)+-32|0,w>>>0>=32)break;b=v}else L=0;while(0);if(v<<24>>24==42){if(w=T+1|0,v=(h[w>>0]|0)+-48|0,v>>>0<10&&(h[T+2>>0]|0)==36)t[s+(v<<2)>>2]=10,v=t[u+((h[w>>0]|0)+-48<<3)>>2]|0,M=1,T=T+3|0;else{if(M|0){a=-1;break}ct?(M=(t[r>>2]|0)+(4-1)&~(4-1),v=t[M>>2]|0,t[r>>2]=M+4,M=0,T=w):(v=0,M=0,T=w)}t[Pn>>2]=T,Ze=(v|0)<0,v=Ze?0-v|0:v,L=Ze?L|8192:L}else{if(v=m8(Pn)|0,(v|0)<0){a=-1;break}T=t[Pn>>2]|0}do if((h[T>>0]|0)==46){if((h[T+1>>0]|0)!=42){t[Pn>>2]=T+1,w=m8(Pn)|0,T=t[Pn>>2]|0;break}if(b=T+2|0,w=(h[b>>0]|0)+-48|0,w>>>0<10&&(h[T+3>>0]|0)==36){t[s+(w<<2)>>2]=10,w=t[u+((h[b>>0]|0)+-48<<3)>>2]|0,T=T+4|0,t[Pn>>2]=T;break}if(M|0){a=-1;break e}ct?(Ze=(t[r>>2]|0)+(4-1)&~(4-1),w=t[Ze>>2]|0,t[r>>2]=Ze+4):w=0,t[Pn>>2]=b,T=b}else w=-1;while(0);for(Te=0;;){if(((h[T>>0]|0)+-65|0)>>>0>57){a=-1;break e}if(Ze=T+1|0,t[Pn>>2]=Ze,b=h[(h[T>>0]|0)+-65+(5178+(Te*58|0))>>0]|0,X=b&255,(X+-1|0)>>>0<8)Te=X,T=Ze;else break}if(!(b<<24>>24)){a=-1;break}Be=(ye|0)>-1;do if(b<<24>>24==19)if(Be){a=-1;break e}else Ye=49;else{if(Be){t[s+(ye<<2)>>2]=X,Be=u+(ye<<3)|0,ye=t[Be+4>>2]|0,Ye=gn,t[Ye>>2]=t[Be>>2],t[Ye+4>>2]=ye,Ye=49;break}if(!ct){a=0;break e}y8(gn,X,r)}while(0);if((Ye|0)==49&&(Ye=0,!ct)){v=0,n=Ze;continue}T=h[T>>0]|0,T=(Te|0)!=0&(T&15|0)==3?T&-33:T,Be=L&-65537,ye=(L&8192|0)==0?L:Be;t:do switch(T|0){case 110:switch((Te&255)<<24>>24){case 0:{t[t[gn>>2]>>2]=a,v=0,n=Ze;continue e}case 1:{t[t[gn>>2]>>2]=a,v=0,n=Ze;continue e}case 2:{v=t[gn>>2]|0,t[v>>2]=a,t[v+4>>2]=((a|0)<0)<<31>>31,v=0,n=Ze;continue e}case 3:{E[t[gn>>2]>>1]=a,v=0,n=Ze;continue e}case 4:{h[t[gn>>2]>>0]=a,v=0,n=Ze;continue e}case 6:{t[t[gn>>2]>>2]=a,v=0,n=Ze;continue e}case 7:{v=t[gn>>2]|0,t[v>>2]=a,t[v+4>>2]=((a|0)<0)<<31>>31,v=0,n=Ze;continue e}default:{v=0,n=Ze;continue e}}case 112:{T=120,w=w>>>0>8?w:8,n=ye|8,Ye=61;break}case 88:case 120:{n=ye,Ye=61;break}case 111:{T=gn,n=t[T>>2]|0,T=t[T+4>>2]|0,X=_L(n,T,ke)|0,Be=Ie-X|0,L=0,b=5642,w=(ye&8|0)==0|(w|0)>(Be|0)?w:Be+1|0,Be=ye,Ye=67;break}case 105:case 100:if(T=gn,n=t[T>>2]|0,T=t[T+4>>2]|0,(T|0)<0){n=m_(0,0,n|0,T|0)|0,T=ot,L=gn,t[L>>2]=n,t[L+4>>2]=T,L=1,b=5642,Ye=66;break t}else{L=(ye&2049|0)!=0&1,b=(ye&2048|0)==0?(ye&1|0)==0?5642:5644:5643,Ye=66;break t}case 117:{T=gn,L=0,b=5642,n=t[T>>2]|0,T=t[T+4>>2]|0,Ye=66;break}case 99:{h[Zt>>0]=t[gn>>2],n=Zt,L=0,b=5642,X=ke,T=1,w=Be;break}case 109:{T=EL(t[(bv()|0)>>2]|0)|0,Ye=71;break}case 115:{T=t[gn>>2]|0,T=T|0?T:5652,Ye=71;break}case 67:{t[_r>>2]=t[gn>>2],t[Br>>2]=0,t[gn>>2]=_r,X=-1,T=_r,Ye=75;break}case 83:{n=t[gn>>2]|0,w?(X=w,T=n,Ye=75):(_l(e,32,v,0,ye),n=0,Ye=84);break}case 65:case 71:case 70:case 69:case 97:case 103:case 102:case 101:{v=wL(e,+j[gn>>3],v,w,ye,T)|0,n=Ze;continue e}default:L=0,b=5642,X=ke,T=w,w=ye}while(0);t:do if((Ye|0)==61)ye=gn,Te=t[ye>>2]|0,ye=t[ye+4>>2]|0,X=gL(Te,ye,ke,T&32)|0,b=(n&8|0)==0|(Te|0)==0&(ye|0)==0,L=b?0:2,b=b?5642:5642+(T>>4)|0,Be=n,n=Te,T=ye,Ye=67;else if((Ye|0)==66)X=Bv(n,T,ke)|0,Be=ye,Ye=67;else if((Ye|0)==71)Ye=0,ye=DL(T,0,w)|0,Te=(ye|0)==0,n=T,L=0,b=5642,X=Te?T+w|0:ye,T=Te?w:ye-T|0,w=Be;else if((Ye|0)==75){for(Ye=0,b=T,n=0,w=0;L=t[b>>2]|0,!(!L||(w=g8(Pr,L)|0,(w|0)<0|w>>>0>(X-n|0)>>>0));)if(n=w+n|0,X>>>0>n>>>0)b=b+4|0;else break;if((w|0)<0){a=-1;break e}if(_l(e,32,v,n,ye),!n)n=0,Ye=84;else for(L=0;;){if(w=t[T>>2]|0,!w){Ye=84;break t}if(w=g8(Pr,w)|0,L=w+L|0,(L|0)>(n|0)){Ye=84;break t}if(Yo(e,Pr,w),L>>>0>=n>>>0){Ye=84;break}else T=T+4|0}}while(0);if((Ye|0)==67)Ye=0,T=(n|0)!=0|(T|0)!=0,ye=(w|0)!=0|T,T=((T^1)&1)+(Ie-X)|0,n=ye?X:ke,X=ke,T=ye?(w|0)>(T|0)?w:T:w,w=(w|0)>-1?Be&-65537:Be;else if((Ye|0)==84){Ye=0,_l(e,32,v,n,ye^8192),v=(v|0)>(n|0)?v:n,n=Ze;continue}Te=X-n|0,Be=(T|0)<(Te|0)?Te:T,ye=Be+L|0,v=(v|0)<(ye|0)?ye:v,_l(e,32,v,ye,w),Yo(e,b,L),_l(e,48,v,ye,w^65536),_l(e,48,Be,Te,0),Yo(e,n,Te),_l(e,32,v,ye,w^8192),n=Ze}e:do if((Ye|0)==87&&!e)if(!M)a=0;else{for(a=1;n=t[s+(a<<2)>>2]|0,!!n;)if(y8(u+(a<<3)|0,n,r),a=a+1|0,(a|0)>=10){a=1;break e}for(;;){if(t[s+(a<<2)>>2]|0){a=-1;break e}if(a=a+1|0,(a|0)>=10){a=1;break}}}while(0);return y=kn,a|0}function mL(e){return e=e|0,0}function yL(e){e=e|0}function Yo(e,n,r){e=e|0,n=n|0,r=r|0,t[e>>2]&32||kL(n,r,e)|0}function m8(e){e=e|0;var n=0,r=0,u=0;if(r=t[e>>2]|0,u=(h[r>>0]|0)+-48|0,u>>>0<10){n=0;do n=u+(n*10|0)|0,r=r+1|0,t[e>>2]=r,u=(h[r>>0]|0)+-48|0;while(u>>>0<10)}else n=0;return n|0}function y8(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;e:do if(n>>>0<=20)do switch(n|0){case 9:{u=(t[r>>2]|0)+(4-1)&~(4-1),n=t[u>>2]|0,t[r>>2]=u+4,t[e>>2]=n;break e}case 10:{u=(t[r>>2]|0)+(4-1)&~(4-1),n=t[u>>2]|0,t[r>>2]=u+4,u=e,t[u>>2]=n,t[u+4>>2]=((n|0)<0)<<31>>31;break e}case 11:{u=(t[r>>2]|0)+(4-1)&~(4-1),n=t[u>>2]|0,t[r>>2]=u+4,u=e,t[u>>2]=n,t[u+4>>2]=0;break e}case 12:{u=(t[r>>2]|0)+(8-1)&~(8-1),n=u,s=t[n>>2]|0,n=t[n+4>>2]|0,t[r>>2]=u+8,u=e,t[u>>2]=s,t[u+4>>2]=n;break e}case 13:{s=(t[r>>2]|0)+(4-1)&~(4-1),u=t[s>>2]|0,t[r>>2]=s+4,u=(u&65535)<<16>>16,s=e,t[s>>2]=u,t[s+4>>2]=((u|0)<0)<<31>>31;break e}case 14:{s=(t[r>>2]|0)+(4-1)&~(4-1),u=t[s>>2]|0,t[r>>2]=s+4,s=e,t[s>>2]=u&65535,t[s+4>>2]=0;break e}case 15:{s=(t[r>>2]|0)+(4-1)&~(4-1),u=t[s>>2]|0,t[r>>2]=s+4,u=(u&255)<<24>>24,s=e,t[s>>2]=u,t[s+4>>2]=((u|0)<0)<<31>>31;break e}case 16:{s=(t[r>>2]|0)+(4-1)&~(4-1),u=t[s>>2]|0,t[r>>2]=s+4,s=e,t[s>>2]=u&255,t[s+4>>2]=0;break e}case 17:{s=(t[r>>2]|0)+(8-1)&~(8-1),a=+j[s>>3],t[r>>2]=s+8,j[e>>3]=a;break e}case 18:{s=(t[r>>2]|0)+(8-1)&~(8-1),a=+j[s>>3],t[r>>2]=s+8,j[e>>3]=a;break e}default:break e}while(0);while(0)}function gL(e,n,r,u){if(e=e|0,n=n|0,r=r|0,u=u|0,!((e|0)==0&(n|0)==0))do r=r+-1|0,h[r>>0]=N[5694+(e&15)>>0]|0|u,e=y_(e|0,n|0,4)|0,n=ot;while(!((e|0)==0&(n|0)==0));return r|0}function _L(e,n,r){if(e=e|0,n=n|0,r=r|0,!((e|0)==0&(n|0)==0))do r=r+-1|0,h[r>>0]=e&7|48,e=y_(e|0,n|0,3)|0,n=ot;while(!((e|0)==0&(n|0)==0));return r|0}function Bv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;if(n>>>0>0|(n|0)==0&e>>>0>4294967295){for(;u=PE(e|0,n|0,10,0)|0,r=r+-1|0,h[r>>0]=u&255|48,u=e,e=FE(e|0,n|0,10,0)|0,n>>>0>9|(n|0)==9&u>>>0>4294967295;)n=ot;n=e}else n=e;if(n)for(;r=r+-1|0,h[r>>0]=(n>>>0)%10|0|48,!(n>>>0<10);)n=(n>>>0)/10|0;return r|0}function EL(e){return e=e|0,RL(e,t[(xL()|0)+188>>2]|0)|0}function DL(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;a=n&255,u=(r|0)!=0;e:do if(u&(e&3|0)!=0)for(s=n&255;;){if((h[e>>0]|0)==s<<24>>24){v=6;break e}if(e=e+1|0,r=r+-1|0,u=(r|0)!=0,!(u&(e&3|0)!=0)){v=5;break}}else v=5;while(0);(v|0)==5&&(u?v=6:r=0);e:do if((v|0)==6&&(s=n&255,(h[e>>0]|0)!=s<<24>>24)){u=lr(a,16843009)|0;t:do if(r>>>0>3){for(;a=t[e>>2]^u,!((a&-2139062144^-2139062144)&a+-16843009|0);)if(e=e+4|0,r=r+-4|0,r>>>0<=3){v=11;break t}}else v=11;while(0);if((v|0)==11&&!r){r=0;break}for(;;){if((h[e>>0]|0)==s<<24>>24)break e;if(e=e+1|0,r=r+-1|0,!r){r=0;break}}}while(0);return(r|0?e:0)|0}function _l(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0;if(v=y,y=y+256|0,a=v,(r|0)>(u|0)&(s&73728|0)==0){if(s=r-u|0,jv(a|0,n|0,(s>>>0<256?s:256)|0)|0,s>>>0>255){n=r-u|0;do Yo(e,a,256),s=s+-256|0;while(s>>>0>255);s=n&255}Yo(e,a,s)}y=v}function g8(e,n){return e=e|0,n=n|0,e?e=TL(e,n,0)|0:e=0,e|0}function wL(e,n,r,u,s,a){e=e|0,n=+n,r=r|0,u=u|0,s=s|0,a=a|0;var v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0,ye=0,Ze=0,Ye=0,ct=0,ke=0,Ie=0,Zt=0,Br=0,Pn=0,gn=0,_r=0,Pr=0,kn=0,uu=0;uu=y,y=y+560|0,T=uu+8|0,Ze=uu,kn=uu+524|0,Pr=kn,L=uu+512|0,t[Ze>>2]=0,_r=L+12|0,_8(n)|0,(ot|0)<0?(n=-n,Pn=1,Br=5659):(Pn=(s&2049|0)!=0&1,Br=(s&2048|0)==0?(s&1|0)==0?5660:5665:5662),_8(n)|0,gn=ot&2146435072;do if(gn>>>0<2146435072|(gn|0)==2146435072&0<0){if(Be=+SL(n,Ze)*2,v=Be!=0,v&&(t[Ze>>2]=(t[Ze>>2]|0)+-1),ct=a|32,(ct|0)==97){Te=a&32,X=(Te|0)==0?Br:Br+9|0,b=Pn|2,v=12-u|0;do if(u>>>0>11|(v|0)==0)n=Be;else{n=8;do v=v+-1|0,n=n*16;while((v|0)!=0);if((h[X>>0]|0)==45){n=-(n+(-Be-n));break}else{n=Be+n-n;break}}while(0);w=t[Ze>>2]|0,v=(w|0)<0?0-w|0:w,v=Bv(v,((v|0)<0)<<31>>31,_r)|0,(v|0)==(_r|0)&&(v=L+11|0,h[v>>0]=48),h[v+-1>>0]=(w>>31&2)+43,M=v+-2|0,h[M>>0]=a+15,L=(u|0)<1,T=(s&8|0)==0,v=kn;do gn=~~n,w=v+1|0,h[v>>0]=N[5694+gn>>0]|Te,n=(n-+(gn|0))*16,(w-Pr|0)==1&&!(T&(L&n==0))?(h[w>>0]=46,v=v+2|0):v=w;while(n!=0);gn=v-Pr|0,Pr=_r-M|0,_r=(u|0)!=0&(gn+-2|0)<(u|0)?u+2|0:gn,v=Pr+b+_r|0,_l(e,32,r,v,s),Yo(e,X,b),_l(e,48,r,v,s^65536),Yo(e,kn,gn),_l(e,48,_r-gn|0,0,0),Yo(e,M,Pr),_l(e,32,r,v,s^8192);break}w=(u|0)<0?6:u,v?(v=(t[Ze>>2]|0)+-28|0,t[Ze>>2]=v,n=Be*268435456):(n=Be,v=t[Ze>>2]|0),gn=(v|0)<0?T:T+288|0,T=gn;do Ie=~~n>>>0,t[T>>2]=Ie,T=T+4|0,n=(n-+(Ie>>>0))*1e9;while(n!=0);if((v|0)>0)for(L=gn,b=T;;){if(M=(v|0)<29?v:29,v=b+-4|0,v>>>0>=L>>>0){T=0;do ke=C8(t[v>>2]|0,0,M|0)|0,ke=LE(ke|0,ot|0,T|0,0)|0,Ie=ot,Ye=PE(ke|0,Ie|0,1e9,0)|0,t[v>>2]=Ye,T=FE(ke|0,Ie|0,1e9,0)|0,v=v+-4|0;while(v>>>0>=L>>>0);T&&(L=L+-4|0,t[L>>2]=T)}for(T=b;!(T>>>0<=L>>>0);)if(v=T+-4|0,!(t[v>>2]|0))T=v;else break;if(v=(t[Ze>>2]|0)-M|0,t[Ze>>2]=v,(v|0)>0)b=T;else break}else L=gn;if((v|0)<0){u=((w+25|0)/9|0)+1|0,ye=(ct|0)==102;do{if(Te=0-v|0,Te=(Te|0)<9?Te:9,L>>>0<T>>>0){M=(1<<Te)+-1|0,b=1e9>>>Te,X=0,v=L;do Ie=t[v>>2]|0,t[v>>2]=(Ie>>>Te)+X,X=lr(Ie&M,b)|0,v=v+4|0;while(v>>>0<T>>>0);v=(t[L>>2]|0)==0?L+4|0:L,X?(t[T>>2]=X,L=v,v=T+4|0):(L=v,v=T)}else L=(t[L>>2]|0)==0?L+4|0:L,v=T;T=ye?gn:L,T=(v-T>>2|0)>(u|0)?T+(u<<2)|0:v,v=(t[Ze>>2]|0)+Te|0,t[Ze>>2]=v}while((v|0)<0);v=L,u=T}else v=L,u=T;if(Ie=gn,v>>>0<u>>>0){if(T=(Ie-v>>2)*9|0,M=t[v>>2]|0,M>>>0>=10){L=10;do L=L*10|0,T=T+1|0;while(M>>>0>=L>>>0)}}else T=0;if(ye=(ct|0)==103,Ye=(w|0)!=0,L=w-((ct|0)!=102?T:0)+((Ye&ye)<<31>>31)|0,(L|0)<(((u-Ie>>2)*9|0)+-9|0)){if(L=L+9216|0,Te=gn+4+(((L|0)/9|0)+-1024<<2)|0,L=((L|0)%9|0)+1|0,(L|0)<9){M=10;do M=M*10|0,L=L+1|0;while((L|0)!=9)}else M=10;if(b=t[Te>>2]|0,X=(b>>>0)%(M>>>0)|0,L=(Te+4|0)==(u|0),L&(X|0)==0)L=Te;else if(Be=(((b>>>0)/(M>>>0)|0)&1|0)==0?9007199254740992:9007199254740994,ke=(M|0)/2|0,n=X>>>0<ke>>>0?.5:L&(X|0)==(ke|0)?1:1.5,Pn&&(ke=(h[Br>>0]|0)==45,n=ke?-n:n,Be=ke?-Be:Be),L=b-X|0,t[Te>>2]=L,Be+n!=Be){if(ke=L+M|0,t[Te>>2]=ke,ke>>>0>999999999)for(T=Te;L=T+-4|0,t[T>>2]=0,L>>>0<v>>>0&&(v=v+-4|0,t[v>>2]=0),ke=(t[L>>2]|0)+1|0,t[L>>2]=ke,ke>>>0>999999999;)T=L;else L=Te;if(T=(Ie-v>>2)*9|0,b=t[v>>2]|0,b>>>0>=10){M=10;do M=M*10|0,T=T+1|0;while(b>>>0>=M>>>0)}}else L=Te;L=L+4|0,L=u>>>0>L>>>0?L:u,ke=v}else L=u,ke=v;for(ct=L;;){if(ct>>>0<=ke>>>0){Ze=0;break}if(v=ct+-4|0,!(t[v>>2]|0))ct=v;else{Ze=1;break}}u=0-T|0;do if(ye)if(v=((Ye^1)&1)+w|0,(v|0)>(T|0)&(T|0)>-5?(M=a+-1|0,w=v+-1-T|0):(M=a+-2|0,w=v+-1|0),v=s&8,v)Te=v;else{if(Ze&&(Zt=t[ct+-4>>2]|0,(Zt|0)!=0))if((Zt>>>0)%10|0)L=0;else{L=0,v=10;do v=v*10|0,L=L+1|0;while(!((Zt>>>0)%(v>>>0)|0|0))}else L=9;if(v=((ct-Ie>>2)*9|0)+-9|0,(M|32|0)==102){Te=v-L|0,Te=(Te|0)>0?Te:0,w=(w|0)<(Te|0)?w:Te,Te=0;break}else{Te=v+T-L|0,Te=(Te|0)>0?Te:0,w=(w|0)<(Te|0)?w:Te,Te=0;break}}else M=a,Te=s&8;while(0);if(ye=w|Te,b=(ye|0)!=0&1,X=(M|32|0)==102,X)Ye=0,v=(T|0)>0?T:0;else{if(v=(T|0)<0?u:T,v=Bv(v,((v|0)<0)<<31>>31,_r)|0,L=_r,(L-v|0)<2)do v=v+-1|0,h[v>>0]=48;while((L-v|0)<2);h[v+-1>>0]=(T>>31&2)+43,v=v+-2|0,h[v>>0]=M,Ye=v,v=L-v|0}if(v=Pn+1+w+b+v|0,_l(e,32,r,v,s),Yo(e,Br,Pn),_l(e,48,r,v,s^65536),X){M=ke>>>0>gn>>>0?gn:ke,Te=kn+9|0,b=Te,X=kn+8|0,L=M;do{if(T=Bv(t[L>>2]|0,0,Te)|0,(L|0)==(M|0))(T|0)==(Te|0)&&(h[X>>0]=48,T=X);else if(T>>>0>kn>>>0){jv(kn|0,48,T-Pr|0)|0;do T=T+-1|0;while(T>>>0>kn>>>0)}Yo(e,T,b-T|0),L=L+4|0}while(L>>>0<=gn>>>0);if(ye|0&&Yo(e,5710,1),L>>>0<ct>>>0&(w|0)>0)for(;;){if(T=Bv(t[L>>2]|0,0,Te)|0,T>>>0>kn>>>0){jv(kn|0,48,T-Pr|0)|0;do T=T+-1|0;while(T>>>0>kn>>>0)}if(Yo(e,T,(w|0)<9?w:9),L=L+4|0,T=w+-9|0,L>>>0<ct>>>0&(w|0)>9)w=T;else{w=T;break}}_l(e,48,w+9|0,9,0)}else{if(ye=Ze?ct:ke+4|0,(w|0)>-1){Ze=kn+9|0,Te=(Te|0)==0,u=Ze,b=0-Pr|0,X=kn+8|0,M=ke;do{T=Bv(t[M>>2]|0,0,Ze)|0,(T|0)==(Ze|0)&&(h[X>>0]=48,T=X);do if((M|0)==(ke|0)){if(L=T+1|0,Yo(e,T,1),Te&(w|0)<1){T=L;break}Yo(e,5710,1),T=L}else{if(T>>>0<=kn>>>0)break;jv(kn|0,48,T+b|0)|0;do T=T+-1|0;while(T>>>0>kn>>>0)}while(0);Pr=u-T|0,Yo(e,T,(w|0)>(Pr|0)?Pr:w),w=w-Pr|0,M=M+4|0}while(M>>>0<ye>>>0&(w|0)>-1)}_l(e,48,w+18|0,18,0),Yo(e,Ye,_r-Ye|0)}_l(e,32,r,v,s^8192)}else kn=(a&32|0)!=0,v=Pn+3|0,_l(e,32,r,v,s&-65537),Yo(e,Br,Pn),Yo(e,n!=n|!1?kn?5686:5690:kn?5678:5682,3),_l(e,32,r,v,s^8192);while(0);return y=uu,((v|0)<(r|0)?r:v)|0}function _8(e){e=+e;var n=0;return j[V>>3]=e,n=t[V>>2]|0,ot=t[V+4>>2]|0,n|0}function SL(e,n){return e=+e,n=n|0,+ +E8(e,n)}function E8(e,n){e=+e,n=n|0;var r=0,u=0,s=0;switch(j[V>>3]=e,r=t[V>>2]|0,u=t[V+4>>2]|0,s=y_(r|0,u|0,52)|0,s&2047){case 0:{e!=0?(e=+E8(e*18446744073709552e3,n),r=(t[n>>2]|0)+-64|0):r=0,t[n>>2]=r;break}case 2047:break;default:t[n>>2]=(s&2047)+-1022,t[V>>2]=r,t[V+4>>2]=u&-2146435073|1071644672,e=+j[V>>3]}return+e}function TL(e,n,r){e=e|0,n=n|0,r=r|0;do if(e){if(n>>>0<128){h[e>>0]=n,e=1;break}if(!(t[t[(CL()|0)+188>>2]>>2]|0))if((n&-128|0)==57216){h[e>>0]=n,e=1;break}else{t[(bv()|0)>>2]=84,e=-1;break}if(n>>>0<2048){h[e>>0]=n>>>6|192,h[e+1>>0]=n&63|128,e=2;break}if(n>>>0<55296|(n&-8192|0)==57344){h[e>>0]=n>>>12|224,h[e+1>>0]=n>>>6&63|128,h[e+2>>0]=n&63|128,e=3;break}if((n+-65536|0)>>>0<1048576){h[e>>0]=n>>>18|240,h[e+1>>0]=n>>>12&63|128,h[e+2>>0]=n>>>6&63|128,h[e+3>>0]=n&63|128,e=4;break}else{t[(bv()|0)>>2]=84,e=-1;break}}else e=1;while(0);return e|0}function CL(){return ME()|0}function xL(){return ME()|0}function RL(e,n){e=e|0,n=n|0;var r=0,u=0;for(u=0;;){if((N[5712+u>>0]|0)==(e|0)){e=2;break}if(r=u+1|0,(r|0)==87){r=5800,u=87,e=5;break}else u=r}if((e|0)==2&&(u?(r=5800,e=5):r=5800),(e|0)==5)for(;;){do e=r,r=r+1|0;while((h[e>>0]|0)!=0);if(u=u+-1|0,u)e=5;else break}return AL(r,t[n+20>>2]|0)|0}function AL(e,n){return e=e|0,n=n|0,OL(e,n)|0}function OL(e,n){return e=e|0,n=n|0,n?n=ML(t[n>>2]|0,t[n+4>>2]|0,e)|0:n=0,(n|0?n:e)|0}function ML(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0;X=(t[e>>2]|0)+1794895138|0,a=Yp(t[e+8>>2]|0,X)|0,u=Yp(t[e+12>>2]|0,X)|0,s=Yp(t[e+16>>2]|0,X)|0;e:do if(a>>>0<n>>>2>>>0&&(b=n-(a<<2)|0,u>>>0<b>>>0&s>>>0<b>>>0)&&((s|u)&3|0)==0){for(b=u>>>2,M=s>>>2,L=0;;){if(w=a>>>1,T=L+w|0,v=T<<1,s=v+b|0,u=Yp(t[e+(s<<2)>>2]|0,X)|0,s=Yp(t[e+(s+1<<2)>>2]|0,X)|0,!(s>>>0<n>>>0&u>>>0<(n-s|0)>>>0)){u=0;break e}if(h[e+(s+u)>>0]|0){u=0;break e}if(u=h8(r,e+s|0)|0,!u)break;if(u=(u|0)<0,(a|0)==1){u=0;break e}else L=u?L:T,a=u?w:a-w|0}u=v+M|0,s=Yp(t[e+(u<<2)>>2]|0,X)|0,u=Yp(t[e+(u+1<<2)>>2]|0,X)|0,u>>>0<n>>>0&s>>>0<(n-u|0)>>>0?u=(h[e+(u+s)>>0]|0)==0?e+u|0:0:u=0}else u=0;while(0);return u|0}function Yp(e,n){e=e|0,n=n|0;var r=0;return r=A8(e|0)|0,((n|0)==0?e:r)|0}function kL(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0,w=0;u=r+16|0,s=t[u>>2]|0,s?a=5:NL(r)|0?u=0:(s=t[u>>2]|0,a=5);e:do if((a|0)==5){if(w=r+20|0,v=t[w>>2]|0,u=v,(s-v|0)>>>0<n>>>0){u=__[t[r+36>>2]&7](r,e,n)|0;break}t:do if((h[r+75>>0]|0)>-1){for(v=n;;){if(!v){a=0,s=e;break t}if(s=v+-1|0,(h[e+s>>0]|0)==10)break;v=s}if(u=__[t[r+36>>2]&7](r,e,v)|0,u>>>0<v>>>0)break e;a=v,s=e+v|0,n=n-v|0,u=t[w>>2]|0}else a=0,s=e;while(0);gr(u|0,s|0,n|0)|0,t[w>>2]=(t[w>>2]|0)+n,u=a+n|0}while(0);return u|0}function NL(e){e=e|0;var n=0,r=0;return n=e+74|0,r=h[n>>0]|0,h[n>>0]=r+255|r,n=t[e>>2]|0,n&8?(t[e>>2]=n|32,e=-1):(t[e+8>>2]=0,t[e+4>>2]=0,r=t[e+44>>2]|0,t[e+28>>2]=r,t[e+20>>2]=r,t[e+16>>2]=r+(t[e+48>>2]|0),e=0),e|0}function xu(e,n){e=S(e),n=S(n);var r=0,u=0;r=D8(e)|0;do if((r&2147483647)>>>0<=2139095040){if(u=D8(n)|0,(u&2147483647)>>>0<=2139095040)if((u^r|0)<0){e=(r|0)<0?n:e;break}else{e=e<n?n:e;break}}else e=n;while(0);return S(e)}function D8(e){return e=S(e),x[V>>2]=e,t[V>>2]|0|0}function Kp(e,n){e=S(e),n=S(n);var r=0,u=0;r=w8(e)|0;do if((r&2147483647)>>>0<=2139095040){if(u=w8(n)|0,(u&2147483647)>>>0<=2139095040)if((u^r|0)<0){e=(r|0)<0?e:n;break}else{e=e<n?e:n;break}}else e=n;while(0);return S(e)}function w8(e){return e=S(e),x[V>>2]=e,t[V>>2]|0|0}function NE(e,n){e=S(e),n=S(n);var r=0,u=0,s=0,a=0,v=0,w=0,T=0,L=0;a=(x[V>>2]=e,t[V>>2]|0),w=(x[V>>2]=n,t[V>>2]|0),r=a>>>23&255,v=w>>>23&255,T=a&-2147483648,s=w<<1;e:do if((s|0)!=0&&!((r|0)==255|((LL(n)|0)&2147483647)>>>0>2139095040)){if(u=a<<1,u>>>0<=s>>>0)return n=S(e*S(0)),S((u|0)==(s|0)?n:e);if(r)u=a&8388607|8388608;else{if(r=a<<9,(r|0)>-1){u=r,r=0;do r=r+-1|0,u=u<<1;while((u|0)>-1)}else r=0;u=a<<1-r}if(v)w=w&8388607|8388608;else{if(a=w<<9,(a|0)>-1){s=0;do s=s+-1|0,a=a<<1;while((a|0)>-1)}else s=0;v=s,w=w<<1-s}s=u-w|0,a=(s|0)>-1;t:do if((r|0)>(v|0)){for(;;){if(a)if(s)u=s;else break;if(u=u<<1,r=r+-1|0,s=u-w|0,a=(s|0)>-1,(r|0)<=(v|0))break t}n=S(e*S(0));break e}while(0);if(a)if(s)u=s;else{n=S(e*S(0));break}if(u>>>0<8388608)do u=u<<1,r=r+-1|0;while(u>>>0<8388608);(r|0)>0?r=u+-8388608|r<<23:r=u>>>(1-r|0),n=(t[V>>2]=r|T,S(x[V>>2]))}else L=3;while(0);return(L|0)==3&&(n=S(e*n),n=S(n/n)),S(n)}function LL(e){return e=S(e),x[V>>2]=e,t[V>>2]|0|0}function FL(e,n){return e=e|0,n=n|0,v8(t[582]|0,e,n)|0}function di(e){e=e|0,$n()}function Uv(e){e=e|0}function PL(e,n){return e=e|0,n=n|0,0}function IL(e){return e=e|0,(S8(e+4|0)|0)==-1?(P1[t[(t[e>>2]|0)+8>>2]&127](e),e=1):e=0,e|0}function S8(e){e=e|0;var n=0;return n=t[e>>2]|0,t[e>>2]=n+-1,n+-1|0}function $d(e){e=e|0,IL(e)|0&&bL(e)}function bL(e){e=e|0;var n=0;n=e+8|0,(t[n>>2]|0)!=0&&(S8(n)|0)!=-1||P1[t[(t[e>>2]|0)+16>>2]&127](e)}function pn(e){e=e|0;var n=0;for(n=(e|0)==0?1:e;e=p_(n)|0,!(e|0);){if(e=UL()|0,!e){e=0;break}B8[e&0]()}return e|0}function T8(e){return e=e|0,pn(e)|0}function Et(e){e=e|0,h_(e)}function BL(e){e=e|0,(h[e+11>>0]|0)<0&&Et(t[e>>2]|0)}function UL(){var e=0;return e=t[2923]|0,t[2923]=e+0,e|0}function jL(){}function m_(e,n,r,u){return e=e|0,n=n|0,r=r|0,u=u|0,u=n-u-(r>>>0>e>>>0|0)>>>0,ot=u,e-r>>>0|0|0}function LE(e,n,r,u){return e=e|0,n=n|0,r=r|0,u=u|0,r=e+r>>>0,ot=n+u+(r>>>0<e>>>0|0)>>>0,r|0|0}function jv(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0,v=0;if(a=e+r|0,n=n&255,(r|0)>=67){for(;e&3;)h[e>>0]=n,e=e+1|0;for(u=a&-4|0,s=u-64|0,v=n|n<<8|n<<16|n<<24;(e|0)<=(s|0);)t[e>>2]=v,t[e+4>>2]=v,t[e+8>>2]=v,t[e+12>>2]=v,t[e+16>>2]=v,t[e+20>>2]=v,t[e+24>>2]=v,t[e+28>>2]=v,t[e+32>>2]=v,t[e+36>>2]=v,t[e+40>>2]=v,t[e+44>>2]=v,t[e+48>>2]=v,t[e+52>>2]=v,t[e+56>>2]=v,t[e+60>>2]=v,e=e+64|0;for(;(e|0)<(u|0);)t[e>>2]=v,e=e+4|0}for(;(e|0)<(a|0);)h[e>>0]=n,e=e+1|0;return a-r|0}function C8(e,n,r){return e=e|0,n=n|0,r=r|0,(r|0)<32?(ot=n<<r|(e&(1<<r)-1<<32-r)>>>32-r,e<<r):(ot=e<<r-32,0)}function y_(e,n,r){return e=e|0,n=n|0,r=r|0,(r|0)<32?(ot=n>>>r,e>>>r|(n&(1<<r)-1)<<32-r):(ot=0,n>>>r-32|0)}function gr(e,n,r){e=e|0,n=n|0,r=r|0;var u=0,s=0,a=0;if((r|0)>=8192)return li(e|0,n|0,r|0)|0;if(a=e|0,s=e+r|0,(e&3)==(n&3)){for(;e&3;){if(!r)return a|0;h[e>>0]=h[n>>0]|0,e=e+1|0,n=n+1|0,r=r-1|0}for(r=s&-4|0,u=r-64|0;(e|0)<=(u|0);)t[e>>2]=t[n>>2],t[e+4>>2]=t[n+4>>2],t[e+8>>2]=t[n+8>>2],t[e+12>>2]=t[n+12>>2],t[e+16>>2]=t[n+16>>2],t[e+20>>2]=t[n+20>>2],t[e+24>>2]=t[n+24>>2],t[e+28>>2]=t[n+28>>2],t[e+32>>2]=t[n+32>>2],t[e+36>>2]=t[n+36>>2],t[e+40>>2]=t[n+40>>2],t[e+44>>2]=t[n+44>>2],t[e+48>>2]=t[n+48>>2],t[e+52>>2]=t[n+52>>2],t[e+56>>2]=t[n+56>>2],t[e+60>>2]=t[n+60>>2],e=e+64|0,n=n+64|0;for(;(e|0)<(r|0);)t[e>>2]=t[n>>2],e=e+4|0,n=n+4|0}else for(r=s-4|0;(e|0)<(r|0);)h[e>>0]=h[n>>0]|0,h[e+1>>0]=h[n+1>>0]|0,h[e+2>>0]=h[n+2>>0]|0,h[e+3>>0]=h[n+3>>0]|0,e=e+4|0,n=n+4|0;for(;(e|0)<(s|0);)h[e>>0]=h[n>>0]|0,e=e+1|0,n=n+1|0;return a|0}function x8(e){e=e|0;var n=0;return n=h[De+(e&255)>>0]|0,(n|0)<8?n|0:(n=h[De+(e>>8&255)>>0]|0,(n|0)<8?n+8|0:(n=h[De+(e>>16&255)>>0]|0,(n|0)<8?n+16|0:(h[De+(e>>>24)>>0]|0)+24|0))}function R8(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0;var a=0,v=0,w=0,T=0,L=0,M=0,b=0,X=0,Be=0,Te=0;if(M=e,T=n,L=T,v=r,X=u,w=X,!L)return a=(s|0)!=0,w?a?(t[s>>2]=e|0,t[s+4>>2]=n&0,X=0,s=0,ot=X,s|0):(X=0,s=0,ot=X,s|0):(a&&(t[s>>2]=(M>>>0)%(v>>>0),t[s+4>>2]=0),X=0,s=(M>>>0)/(v>>>0)>>>0,ot=X,s|0);a=(w|0)==0;do if(v){if(!a){if(a=(Er(w|0)|0)-(Er(L|0)|0)|0,a>>>0<=31){b=a+1|0,w=31-a|0,n=a-31>>31,v=b,e=M>>>(b>>>0)&n|L<<w,n=L>>>(b>>>0)&n,a=0,w=M<<w;break}return s?(t[s>>2]=e|0,t[s+4>>2]=T|n&0,X=0,s=0,ot=X,s|0):(X=0,s=0,ot=X,s|0)}if(a=v-1|0,a&v|0){w=(Er(v|0)|0)+33-(Er(L|0)|0)|0,Te=64-w|0,b=32-w|0,T=b>>31,Be=w-32|0,n=Be>>31,v=w,e=b-1>>31&L>>>(Be>>>0)|(L<<b|M>>>(w>>>0))&n,n=n&L>>>(w>>>0),a=M<<Te&T,w=(L<<Te|M>>>(Be>>>0))&T|M<<b&w-33>>31;break}return s|0&&(t[s>>2]=a&M,t[s+4>>2]=0),(v|0)==1?(Be=T|n&0,Te=e|0|0,ot=Be,Te|0):(Te=x8(v|0)|0,Be=L>>>(Te>>>0)|0,Te=L<<32-Te|M>>>(Te>>>0)|0,ot=Be,Te|0)}else{if(a)return s|0&&(t[s>>2]=(L>>>0)%(v>>>0),t[s+4>>2]=0),Be=0,Te=(L>>>0)/(v>>>0)>>>0,ot=Be,Te|0;if(!M)return s|0&&(t[s>>2]=0,t[s+4>>2]=(L>>>0)%(w>>>0)),Be=0,Te=(L>>>0)/(w>>>0)>>>0,ot=Be,Te|0;if(a=w-1|0,!(a&w))return s|0&&(t[s>>2]=e|0,t[s+4>>2]=a&L|n&0),Be=0,Te=L>>>((x8(w|0)|0)>>>0),ot=Be,Te|0;if(a=(Er(w|0)|0)-(Er(L|0)|0)|0,a>>>0<=30){n=a+1|0,w=31-a|0,v=n,e=L<<w|M>>>(n>>>0),n=L>>>(n>>>0),a=0,w=M<<w;break}return s?(t[s>>2]=e|0,t[s+4>>2]=T|n&0,Be=0,Te=0,ot=Be,Te|0):(Be=0,Te=0,ot=Be,Te|0)}while(0);if(!v)L=w,T=0,w=0;else{b=r|0|0,M=X|u&0,L=LE(b|0,M|0,-1,-1)|0,r=ot,T=w,w=0;do u=T,T=a>>>31|T<<1,a=w|a<<1,u=e<<1|u>>>31|0,X=e>>>31|n<<1|0,m_(L|0,r|0,u|0,X|0)|0,Te=ot,Be=Te>>31|((Te|0)<0?-1:0)<<1,w=Be&1,e=m_(u|0,X|0,Be&b|0,(((Te|0)<0?-1:0)>>31|((Te|0)<0?-1:0)<<1)&M|0)|0,n=ot,v=v-1|0;while((v|0)!=0);L=T,T=0}return v=0,s|0&&(t[s>>2]=e,t[s+4>>2]=n),Be=(a|0)>>>31|(L|v)<<1|(v<<1|a>>>31)&0|T,Te=(a<<1|0>>>31)&-2|w,ot=Be,Te|0}function FE(e,n,r,u){return e=e|0,n=n|0,r=r|0,u=u|0,R8(e,n,r,u,0)|0}function e2(e){e=e|0;var n=0,r=0;return r=e+15&-16|0,n=t[q>>2]|0,e=n+r|0,(r|0)>0&(e|0)<(n|0)|(e|0)<0?(fr()|0,Ql(12),-1):(t[q>>2]=e,(e|0)>(jr()|0)&&(vr()|0)==0?(t[q>>2]=n,Ql(12),-1):n|0)}function ky(e,n,r){e=e|0,n=n|0,r=r|0;var u=0;if((n|0)<(e|0)&(e|0)<(n+r|0)){for(u=e,n=n+r|0,e=e+r|0;(r|0)>0;)e=e-1|0,n=n-1|0,r=r-1|0,h[e>>0]=h[n>>0]|0;e=u}else gr(e,n,r)|0;return e|0}function PE(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0;var s=0,a=0;return a=y,y=y+16|0,s=a|0,R8(e,n,r,u,s)|0,y=a,ot=t[s+4>>2]|0,t[s>>2]|0|0}function A8(e){return e=e|0,(e&255)<<24|(e>>8&255)<<16|(e>>16&255)<<8|e>>>24|0}function zL(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,O8[e&1](n|0,r|0,u|0,s|0,a|0)}function HL(e,n,r){e=e|0,n=n|0,r=S(r),M8[e&1](n|0,S(r))}function qL(e,n,r){e=e|0,n=n|0,r=+r,k8[e&31](n|0,+r)}function WL(e,n,r,u){return e=e|0,n=n|0,r=S(r),u=S(u),S(N8[e&0](n|0,S(r),S(u)))}function VL(e,n){e=e|0,n=n|0,P1[e&127](n|0)}function YL(e,n,r){e=e|0,n=n|0,r=r|0,I1[e&31](n|0,r|0)}function KL(e,n){return e=e|0,n=n|0,Qp[e&31](n|0)|0}function XL(e,n,r,u,s){e=e|0,n=n|0,r=+r,u=+u,s=s|0,L8[e&1](n|0,+r,+u,s|0)}function QL(e,n,r,u){e=e|0,n=n|0,r=+r,u=+u,MF[e&1](n|0,+r,+u)}function JL(e,n,r,u){return e=e|0,n=n|0,r=r|0,u=u|0,__[e&7](n|0,r|0,u|0)|0}function ZL(e,n,r,u){return e=e|0,n=n|0,r=r|0,u=u|0,+kF[e&1](n|0,r|0,u|0)}function $L(e,n){return e=e|0,n=n|0,+F8[e&15](n|0)}function eF(e,n,r){return e=e|0,n=n|0,r=+r,NF[e&1](n|0,+r)|0}function tF(e,n,r){return e=e|0,n=n|0,r=r|0,bE[e&15](n|0,r|0)|0}function nF(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=+u,s=+s,a=a|0,LF[e&1](n|0,r|0,+u,+s,a|0)}function rF(e,n,r,u,s,a,v){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,v=v|0,FF[e&1](n|0,r|0,u|0,s|0,a|0,v|0)}function iF(e,n,r){return e=e|0,n=n|0,r=r|0,+P8[e&7](n|0,r|0)}function uF(e){return e=e|0,E_[e&7]()|0}function oF(e,n,r,u,s,a){return e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,I8[e&1](n|0,r|0,u|0,s|0,a|0)|0}function lF(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=+s,PF[e&1](n|0,r|0,u|0,+s)}function sF(e,n,r,u,s,a,v){e=e|0,n=n|0,r=r|0,u=S(u),s=s|0,a=S(a),v=v|0,b8[e&1](n|0,r|0,S(u),s|0,S(a),v|0)}function aF(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,Fy[e&15](n|0,r|0,u|0)}function fF(e){e=e|0,B8[e&0]()}function cF(e,n,r,u){e=e|0,n=n|0,r=r|0,u=+u,U8[e&15](n|0,r|0,+u)}function dF(e,n,r){return e=e|0,n=+n,r=+r,IF[e&1](+n,+r)|0}function pF(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,BE[e&15](n|0,r|0,u|0,s|0)}function hF(e,n,r,u,s){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,zt(0)}function vF(e,n){e=e|0,n=S(n),zt(1)}function $s(e,n){e=e|0,n=+n,zt(2)}function mF(e,n,r){return e=e|0,n=S(n),r=S(r),zt(3),Ct}function Zn(e){e=e|0,zt(4)}function Ny(e,n){e=e|0,n=n|0,zt(5)}function Na(e){return e=e|0,zt(6),0}function yF(e,n,r,u){e=e|0,n=+n,r=+r,u=u|0,zt(7)}function gF(e,n,r){e=e|0,n=+n,r=+r,zt(8)}function _F(e,n,r){return e=e|0,n=n|0,r=r|0,zt(9),0}function EF(e,n,r){return e=e|0,n=n|0,r=r|0,zt(10),0}function Xp(e){return e=e|0,zt(11),0}function DF(e,n){return e=e|0,n=+n,zt(12),0}function Ly(e,n){return e=e|0,n=n|0,zt(13),0}function wF(e,n,r,u,s){e=e|0,n=n|0,r=+r,u=+u,s=s|0,zt(14)}function SF(e,n,r,u,s,a){e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,a=a|0,zt(15)}function IE(e,n){return e=e|0,n=n|0,zt(16),0}function TF(){return zt(17),0}function CF(e,n,r,u,s){return e=e|0,n=n|0,r=r|0,u=u|0,s=s|0,zt(18),0}function xF(e,n,r,u){e=e|0,n=n|0,r=r|0,u=+u,zt(19)}function RF(e,n,r,u,s,a){e=e|0,n=n|0,r=S(r),u=u|0,s=S(s),a=a|0,zt(20)}function g_(e,n,r){e=e|0,n=n|0,r=r|0,zt(21)}function AF(){zt(22)}function zv(e,n,r){e=e|0,n=n|0,r=+r,zt(23)}function OF(e,n){return e=+e,n=+n,zt(24),0}function Hv(e,n,r,u){e=e|0,n=n|0,r=r|0,u=u|0,zt(25)}var O8=[hF,TO],M8=[vF,t0],k8=[$s,ca,ws,Ss,ts,Ho,Ef,ol,qa,n0,Df,Wc,dc,Ol,Ts,da,ud,pa,pc,$s,$s,$s,$s,$s,$s,$s,$s,$s,$s,$s,$s,$s],N8=[mF],P1=[Zn,Uv,cn,is,Do,Uf,M1,jl,$A,e7,t7,cO,dO,pO,LN,FN,PN,Fe,fc,Ua,Vu,j0,yh,Sf,r1,Lf,Ea,kh,ym,g1,_1,Zh,hp,Ld,jm,C1,Ac,Jm,ey,xv,Mv,on,P4,G4,n_,Lt,Cu,e0,p9,O9,K9,dR,RR,KR,iA,lA,TA,RA,WA,r7,o7,S7,z7,gd,wM,$M,hk,Ok,Jk,dN,SN,xN,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn,Zn],I1=[Ny,_2,nd,qc,Rl,ul,E2,qs,Al,ja,za,Ha,Ml,je,st,$t,Wn,oi,ur,Wa,w2,_h,X4,eE,mR,CM,X7,$w,Ny,Ny,Ny,Ny],Qp=[Na,fL,_f,g,Z,de,yt,Rt,Nt,xr,cu,z0,Va,od,Xc,Ms,kR,x7,OM,Oa,Na,Na,Na,Na,Na,Na,Na,Na,Na,Na,Na,Na],L8=[yF,C2],MF=[gF,YA],__=[_F,p8,cL,hL,Wh,vv,y9,Lk],kF=[EF,fv],F8=[Xp,i0,Ge,ai,gh,al,ha,x2,R2,hc,Xp,Xp,Xp,Xp,Xp,Xp],NF=[DF,tA],bE=[Ly,PL,D2,dl,H2,xm,fp,xp,ty,kr,jo,gk,Ly,Ly,Ly,Ly],LF=[wF,xh],FF=[SF,tN],P8=[IE,Qi,A2,dd,Qc,ml,IE,IE],E_=[TF,Jc,io,E0,cA,kA,f7,MN],I8=[CF,ui],PF=[xF,vy],b8=[RF,ld],Fy=[g_,A,r0,Vr,Tu,m1,Nd,ar,_y,mo,YO,rk,mN,g_,g_,g_],B8=[AF],U8=[zv,rd,yo,id,zo,Vc,Wi,_,Bp,L9,JR,zv,zv,zv,zv,zv],IF=[OF,JA],BE=[Hv,Ep,Lc,Z9,jR,yA,bA,y7,G7,PM,zN,Hv,Hv,Hv,Hv,Hv];return{_llvm_bswap_i32:A8,dynCall_idd:dF,dynCall_i:uF,_i64Subtract:m_,___udivdi3:FE,dynCall_vif:HL,setThrew:vs,dynCall_viii:aF,_bitshift64Lshr:y_,_bitshift64Shl:C8,dynCall_vi:VL,dynCall_viiddi:nF,dynCall_diii:ZL,dynCall_iii:tF,_memset:jv,_sbrk:e2,_memcpy:gr,__GLOBAL__sub_I_Yoga_cpp:ru,dynCall_vii:YL,___uremdi3:PE,dynCall_vid:qL,stackAlloc:co,_nbind_init:ZN,getTempRet0:Q,dynCall_di:$L,dynCall_iid:eF,setTempRet0:b0,_i64Add:LE,dynCall_fiff:WL,dynCall_iiii:JL,_emscripten_get_global_libc:aL,dynCall_viid:cF,dynCall_viiid:lF,dynCall_viififi:sF,dynCall_ii:KL,__GLOBAL__sub_I_Binding_cc:hM,dynCall_viiii:pF,dynCall_iiiiii:oF,stackSave:nl,dynCall_viiiii:zL,__GLOBAL__sub_I_nbind_cc:Ws,dynCall_vidd:QL,_free:h_,runPostSets:jL,dynCall_viiiiii:rF,establishStackSpace:Uu,_memmove:ky,stackRestore:Jl,_malloc:p_,__GLOBAL__sub_I_common_cc:F7,dynCall_viddi:XL,dynCall_dii:iF,dynCall_v:fF}}(Module.asmGlobalArg,Module.asmLibraryArg,buffer),_llvm_bswap_i32=Module._llvm_bswap_i32=asm._llvm_bswap_i32,getTempRet0=Module.getTempRet0=asm.getTempRet0,___udivdi3=Module.___udivdi3=asm.___udivdi3,setThrew=Module.setThrew=asm.setThrew,_bitshift64Lshr=Module._bitshift64Lshr=asm._bitshift64Lshr,_bitshift64Shl=Module._bitshift64Shl=asm._bitshift64Shl,_memset=Module._memset=asm._memset,_sbrk=Module._sbrk=asm._sbrk,_memcpy=Module._memcpy=asm._memcpy,stackAlloc=Module.stackAlloc=asm.stackAlloc,___uremdi3=Module.___uremdi3=asm.___uremdi3,_nbind_init=Module._nbind_init=asm._nbind_init,_i64Subtract=Module._i64Subtract=asm._i64Subtract,setTempRet0=Module.setTempRet0=asm.setTempRet0,_i64Add=Module._i64Add=asm._i64Add,_emscripten_get_global_libc=Module._emscripten_get_global_libc=asm._emscripten_get_global_libc,__GLOBAL__sub_I_Yoga_cpp=Module.__GLOBAL__sub_I_Yoga_cpp=asm.__GLOBAL__sub_I_Yoga_cpp,__GLOBAL__sub_I_Binding_cc=Module.__GLOBAL__sub_I_Binding_cc=asm.__GLOBAL__sub_I_Binding_cc,stackSave=Module.stackSave=asm.stackSave,__GLOBAL__sub_I_nbind_cc=Module.__GLOBAL__sub_I_nbind_cc=asm.__GLOBAL__sub_I_nbind_cc,_free=Module._free=asm._free,runPostSets=Module.runPostSets=asm.runPostSets,establishStackSpace=Module.establishStackSpace=asm.establishStackSpace,_memmove=Module._memmove=asm._memmove,stackRestore=Module.stackRestore=asm.stackRestore,_malloc=Module._malloc=asm._malloc,__GLOBAL__sub_I_common_cc=Module.__GLOBAL__sub_I_common_cc=asm.__GLOBAL__sub_I_common_cc,dynCall_viiiii=Module.dynCall_viiiii=asm.dynCall_viiiii,dynCall_vif=Module.dynCall_vif=asm.dynCall_vif,dynCall_vid=Module.dynCall_vid=asm.dynCall_vid,dynCall_fiff=Module.dynCall_fiff=asm.dynCall_fiff,dynCall_vi=Module.dynCall_vi=asm.dynCall_vi,dynCall_vii=Module.dynCall_vii=asm.dynCall_vii,dynCall_ii=Module.dynCall_ii=asm.dynCall_ii,dynCall_viddi=Module.dynCall_viddi=asm.dynCall_viddi,dynCall_vidd=Module.dynCall_vidd=asm.dynCall_vidd,dynCall_iiii=Module.dynCall_iiii=asm.dynCall_iiii,dynCall_diii=Module.dynCall_diii=asm.dynCall_diii,dynCall_di=Module.dynCall_di=asm.dynCall_di,dynCall_iid=Module.dynCall_iid=asm.dynCall_iid,dynCall_iii=Module.dynCall_iii=asm.dynCall_iii,dynCall_viiddi=Module.dynCall_viiddi=asm.dynCall_viiddi,dynCall_viiiiii=Module.dynCall_viiiiii=asm.dynCall_viiiiii,dynCall_dii=Module.dynCall_dii=asm.dynCall_dii,dynCall_i=Module.dynCall_i=asm.dynCall_i,dynCall_iiiiii=Module.dynCall_iiiiii=asm.dynCall_iiiiii,dynCall_viiid=Module.dynCall_viiid=asm.dynCall_viiid,dynCall_viififi=Module.dynCall_viififi=asm.dynCall_viififi,dynCall_viii=Module.dynCall_viii=asm.dynCall_viii,dynCall_v=Module.dynCall_v=asm.dynCall_v,dynCall_viid=Module.dynCall_viid=asm.dynCall_viid,dynCall_idd=Module.dynCall_idd=asm.dynCall_idd,dynCall_viiii=Module.dynCall_viiii=asm.dynCall_viiii;Runtime.stackAlloc=Module.stackAlloc,Runtime.stackSave=Module.stackSave,Runtime.stackRestore=Module.stackRestore,Runtime.establishStackSpace=Module.establishStackSpace,Runtime.setTempRet0=Module.setTempRet0,Runtime.getTempRet0=Module.getTempRet0,Module.asm=asm;function ExitStatus(o){this.name="ExitStatus",this.message="Program terminated with exit("+o+")",this.status=o}ExitStatus.prototype=new Error,ExitStatus.prototype.constructor=ExitStatus;var initialStackTop,preloadStartTime=null,calledMain=!1;dependenciesFulfilled=function o(){Module.calledRun||run(),Module.calledRun||(dependenciesFulfilled=o)},Module.callMain=Module.callMain=function o(l){l=l||[],ensureInitRuntime();var f=l.length+1;function h(){for(var k=0;k<4-1;k++)E.push(0)}var E=[allocate(intArrayFromString(Module.thisProgram),"i8",ALLOC_NORMAL)];h();for(var t=0;t<f-1;t=t+1)E.push(allocate(intArrayFromString(l[t]),"i8",ALLOC_NORMAL)),h();E.push(0),E=allocate(E,"i32",ALLOC_NORMAL);try{var N=Module._main(f,E,0);exit(N,!0)}catch(k){if(k instanceof ExitStatus)return;if(k=="SimulateInfiniteLoop"){Module.noExitRuntime=!0;return}else{var F=k;k&&typeof k=="object"&&k.stack&&(F=[k,k.stack]),Module.printErr("exception thrown: "+F),Module.quit(1,k)}}finally{calledMain=!0}};function run(o){if(o=o||Module.arguments,preloadStartTime===null&&(preloadStartTime=Date.now()),runDependencies>0||(preRun(),runDependencies>0)||Module.calledRun)return;function l(){Module.calledRun||(Module.calledRun=!0,!ABORT&&(ensureInitRuntime(),preMain(),Module.onRuntimeInitialized&&Module.onRuntimeInitialized(),Module._main&&shouldRunNow&&Module.callMain(o),postRun()))}Module.setStatus?(Module.setStatus("Running..."),setTimeout(function(){setTimeout(function(){Module.setStatus("")},1),l()},1)):l()}Module.run=Module.run=run;function exit(o,l){l&&Module.noExitRuntime||(Module.noExitRuntime||(ABORT=!0,EXITSTATUS=o,STACKTOP=initialStackTop,exitRuntime(),Module.onExit&&Module.onExit(o)),ENVIRONMENT_IS_NODE&&process.exit(o),Module.quit(o,new ExitStatus(o)))}Module.exit=Module.exit=exit;var abortDecorators=[];function abort(o){Module.onAbort&&Module.onAbort(o),o!==void 0?(Module.print(o),Module.printErr(o),o=JSON.stringify(o)):o="",ABORT=!0,EXITSTATUS=1;var l=`
+If this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.`,f="abort("+o+") at "+stackTrace()+l;throw abortDecorators&&abortDecorators.forEach(function(h){f=h(f,o)}),f}if(Module.abort=Module.abort=abort,Module.preInit)for(typeof Module.preInit=="function"&&(Module.preInit=[Module.preInit]);Module.preInit.length>0;)Module.preInit.pop()();var shouldRunNow=!0;Module.noInitialRun&&(shouldRunNow=!1),run()})});var eh=nt((CH,tT)=>{"use strict";var SP=$S(),TP=eT(),_D=!1,ED=null;TP({},function(o,l){if(!_D){if(_D=!0,o)throw o;ED=l}});if(!_D)throw new Error("Failed to load the yoga module - it needed to be loaded synchronously, but didn't");tT.exports=SP(ED.bind,ED.lib)});var rT=nt((xH,nT)=>{"use strict";nT.exports=({onlyFirst:o=!1}={})=>{let l=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|");return new RegExp(l,o?void 0:"g")}});var DD=nt((RH,iT)=>{"use strict";var CP=rT();iT.exports=o=>typeof o=="string"?o.replace(CP(),""):o});var SD=nt((AH,wD)=>{"use strict";var uT=o=>Number.isNaN(o)?!1:o>=4352&&(o<=4447||o===9001||o===9002||11904<=o&&o<=12871&&o!==12351||12880<=o&&o<=19903||19968<=o&&o<=42182||43360<=o&&o<=43388||44032<=o&&o<=55203||63744<=o&&o<=64255||65040<=o&&o<=65049||65072<=o&&o<=65131||65281<=o&&o<=65376||65504<=o&&o<=65510||110592<=o&&o<=110593||127488<=o&&o<=127569||131072<=o&&o<=262141);wD.exports=uT;wD.exports.default=uT});var lT=nt((OH,oT)=>{"use strict";oT.exports=function(){return/\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g}});var q_=nt((MH,TD)=>{"use strict";var xP=DD(),RP=SD(),AP=lT(),sT=o=>{if(typeof o!="string"||o.length===0||(o=xP(o),o.length===0))return 0;o=o.replace(AP(),"  ");let l=0;for(let f=0;f<o.length;f++){let h=o.codePointAt(f);h<=31||h>=127&&h<=159||h>=768&&h<=879||(h>65535&&f++,l+=RP(h)?2:1)}return l};TD.exports=sT;TD.exports.default=sT});var xD=nt((kH,CD)=>{"use strict";var OP=q_(),aT=o=>{let l=0;for(let f of o.split(`
+`))l=Math.max(l,OP(f));return l};CD.exports=aT;CD.exports.default=aT});var fT=nt(Ky=>{"use strict";var MP=Ky&&Ky.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Ky,"__esModule",{value:!0});var kP=MP(xD()),RD={};Ky.default=o=>{if(o.length===0)return{width:0,height:0};if(RD[o])return RD[o];let l=kP.default(o),f=o.split(`
+`).length;return RD[o]={width:l,height:f},{width:l,height:f}}});var cT=nt(Xy=>{"use strict";var NP=Xy&&Xy.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Xy,"__esModule",{value:!0});var Gi=NP(eh()),LP=(o,l)=>{"position"in l&&o.setPositionType(l.position==="absolute"?Gi.default.POSITION_TYPE_ABSOLUTE:Gi.default.POSITION_TYPE_RELATIVE)},FP=(o,l)=>{"marginLeft"in l&&o.setMargin(Gi.default.EDGE_START,l.marginLeft||0),"marginRight"in l&&o.setMargin(Gi.default.EDGE_END,l.marginRight||0),"marginTop"in l&&o.setMargin(Gi.default.EDGE_TOP,l.marginTop||0),"marginBottom"in l&&o.setMargin(Gi.default.EDGE_BOTTOM,l.marginBottom||0)},PP=(o,l)=>{"paddingLeft"in l&&o.setPadding(Gi.default.EDGE_LEFT,l.paddingLeft||0),"paddingRight"in l&&o.setPadding(Gi.default.EDGE_RIGHT,l.paddingRight||0),"paddingTop"in l&&o.setPadding(Gi.default.EDGE_TOP,l.paddingTop||0),"paddingBottom"in l&&o.setPadding(Gi.default.EDGE_BOTTOM,l.paddingBottom||0)},IP=(o,l)=>{var f;"flexGrow"in l&&o.setFlexGrow((f=l.flexGrow)!==null&&f!==void 0?f:0),"flexShrink"in l&&o.setFlexShrink(typeof l.flexShrink=="number"?l.flexShrink:1),"flexDirection"in l&&(l.flexDirection==="row"&&o.setFlexDirection(Gi.default.FLEX_DIRECTION_ROW),l.flexDirection==="row-reverse"&&o.setFlexDirection(Gi.default.FLEX_DIRECTION_ROW_REVERSE),l.flexDirection==="column"&&o.setFlexDirection(Gi.default.FLEX_DIRECTION_COLUMN),l.flexDirection==="column-reverse"&&o.setFlexDirection(Gi.default.FLEX_DIRECTION_COLUMN_REVERSE)),"flexBasis"in l&&(typeof l.flexBasis=="number"?o.setFlexBasis(l.flexBasis):typeof l.flexBasis=="string"?o.setFlexBasisPercent(Number.parseInt(l.flexBasis,10)):o.setFlexBasis(NaN)),"alignItems"in l&&((l.alignItems==="stretch"||!l.alignItems)&&o.setAlignItems(Gi.default.ALIGN_STRETCH),l.alignItems==="flex-start"&&o.setAlignItems(Gi.default.ALIGN_FLEX_START),l.alignItems==="center"&&o.setAlignItems(Gi.default.ALIGN_CENTER),l.alignItems==="flex-end"&&o.setAlignItems(Gi.default.ALIGN_FLEX_END)),"alignSelf"in l&&((l.alignSelf==="auto"||!l.alignSelf)&&o.setAlignSelf(Gi.default.ALIGN_AUTO),l.alignSelf==="flex-start"&&o.setAlignSelf(Gi.default.ALIGN_FLEX_START),l.alignSelf==="center"&&o.setAlignSelf(Gi.default.ALIGN_CENTER),l.alignSelf==="flex-end"&&o.setAlignSelf(Gi.default.ALIGN_FLEX_END)),"justifyContent"in l&&((l.justifyContent==="flex-start"||!l.justifyContent)&&o.setJustifyContent(Gi.default.JUSTIFY_FLEX_START),l.justifyContent==="center"&&o.setJustifyContent(Gi.default.JUSTIFY_CENTER),l.justifyContent==="flex-end"&&o.setJustifyContent(Gi.default.JUSTIFY_FLEX_END),l.justifyContent==="space-between"&&o.setJustifyContent(Gi.default.JUSTIFY_SPACE_BETWEEN),l.justifyContent==="space-around"&&o.setJustifyContent(Gi.default.JUSTIFY_SPACE_AROUND))},bP=(o,l)=>{var f,h;"width"in l&&(typeof l.width=="number"?o.setWidth(l.width):typeof l.width=="string"?o.setWidthPercent(Number.parseInt(l.width,10)):o.setWidthAuto()),"height"in l&&(typeof l.height=="number"?o.setHeight(l.height):typeof l.height=="string"?o.setHeightPercent(Number.parseInt(l.height,10)):o.setHeightAuto()),"minWidth"in l&&(typeof l.minWidth=="string"?o.setMinWidthPercent(Number.parseInt(l.minWidth,10)):o.setMinWidth((f=l.minWidth)!==null&&f!==void 0?f:0)),"minHeight"in l&&(typeof l.minHeight=="string"?o.setMinHeightPercent(Number.parseInt(l.minHeight,10)):o.setMinHeight((h=l.minHeight)!==null&&h!==void 0?h:0))},BP=(o,l)=>{"display"in l&&o.setDisplay(l.display==="flex"?Gi.default.DISPLAY_FLEX:Gi.default.DISPLAY_NONE)},UP=(o,l)=>{if("borderStyle"in l){let f=typeof l.borderStyle=="string"?1:0;o.setBorder(Gi.default.EDGE_TOP,f),o.setBorder(Gi.default.EDGE_BOTTOM,f),o.setBorder(Gi.default.EDGE_LEFT,f),o.setBorder(Gi.default.EDGE_RIGHT,f)}};Xy.default=(o,l={})=>{LP(o,l),FP(o,l),PP(o,l),IP(o,l),bP(o,l),BP(o,l),UP(o,l)}});var pT=nt((FH,dT)=>{"use strict";dT.exports={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}});var AD=nt((PH,vT)=>{var Qy=pT(),hT={};for(let o of Object.keys(Qy))hT[Qy[o]]=o;var zn={rgb:{channels:3,labels:"rgb"},hsl:{channels:3,labels:"hsl"},hsv:{channels:3,labels:"hsv"},hwb:{channels:3,labels:"hwb"},cmyk:{channels:4,labels:"cmyk"},xyz:{channels:3,labels:"xyz"},lab:{channels:3,labels:"lab"},lch:{channels:3,labels:"lch"},hex:{channels:1,labels:["hex"]},keyword:{channels:1,labels:["keyword"]},ansi16:{channels:1,labels:["ansi16"]},ansi256:{channels:1,labels:["ansi256"]},hcg:{channels:3,labels:["h","c","g"]},apple:{channels:3,labels:["r16","g16","b16"]},gray:{channels:1,labels:["gray"]}};vT.exports=zn;for(let o of Object.keys(zn)){if(!("channels"in zn[o]))throw new Error("missing channels property: "+o);if(!("labels"in zn[o]))throw new Error("missing channel labels property: "+o);if(zn[o].labels.length!==zn[o].channels)throw new Error("channel and label counts mismatch: "+o);let{channels:l,labels:f}=zn[o];delete zn[o].channels,delete zn[o].labels,Object.defineProperty(zn[o],"channels",{value:l}),Object.defineProperty(zn[o],"labels",{value:f})}zn.rgb.hsl=function(o){let l=o[0]/255,f=o[1]/255,h=o[2]/255,E=Math.min(l,f,h),t=Math.max(l,f,h),N=t-E,F,k;t===E?F=0:l===t?F=(f-h)/N:f===t?F=2+(h-l)/N:h===t&&(F=4+(l-f)/N),F=Math.min(F*60,360),F<0&&(F+=360);let x=(E+t)/2;return t===E?k=0:x<=.5?k=N/(t+E):k=N/(2-t-E),[F,k*100,x*100]};zn.rgb.hsv=function(o){let l,f,h,E,t,N=o[0]/255,F=o[1]/255,k=o[2]/255,x=Math.max(N,F,k),j=x-Math.min(N,F,k),q=function(V){return(x-V)/6/j+1/2};return j===0?(E=0,t=0):(t=j/x,l=q(N),f=q(F),h=q(k),N===x?E=h-f:F===x?E=1/3+l-h:k===x&&(E=2/3+f-l),E<0?E+=1:E>1&&(E-=1)),[E*360,t*100,x*100]};zn.rgb.hwb=function(o){let l=o[0],f=o[1],h=o[2],E=zn.rgb.hsl(o)[0],t=1/255*Math.min(l,Math.min(f,h));return h=1-1/255*Math.max(l,Math.max(f,h)),[E,t*100,h*100]};zn.rgb.cmyk=function(o){let l=o[0]/255,f=o[1]/255,h=o[2]/255,E=Math.min(1-l,1-f,1-h),t=(1-l-E)/(1-E)||0,N=(1-f-E)/(1-E)||0,F=(1-h-E)/(1-E)||0;return[t*100,N*100,F*100,E*100]};function jP(o,l){return(o[0]-l[0])**2+(o[1]-l[1])**2+(o[2]-l[2])**2}zn.rgb.keyword=function(o){let l=hT[o];if(l)return l;let f=1/0,h;for(let E of Object.keys(Qy)){let t=Qy[E],N=jP(o,t);N<f&&(f=N,h=E)}return h};zn.keyword.rgb=function(o){return Qy[o]};zn.rgb.xyz=function(o){let l=o[0]/255,f=o[1]/255,h=o[2]/255;l=l>.04045?((l+.055)/1.055)**2.4:l/12.92,f=f>.04045?((f+.055)/1.055)**2.4:f/12.92,h=h>.04045?((h+.055)/1.055)**2.4:h/12.92;let E=l*.4124+f*.3576+h*.1805,t=l*.2126+f*.7152+h*.0722,N=l*.0193+f*.1192+h*.9505;return[E*100,t*100,N*100]};zn.rgb.lab=function(o){let l=zn.rgb.xyz(o),f=l[0],h=l[1],E=l[2];f/=95.047,h/=100,E/=108.883,f=f>.008856?f**(1/3):7.787*f+16/116,h=h>.008856?h**(1/3):7.787*h+16/116,E=E>.008856?E**(1/3):7.787*E+16/116;let t=116*h-16,N=500*(f-h),F=200*(h-E);return[t,N,F]};zn.hsl.rgb=function(o){let l=o[0]/360,f=o[1]/100,h=o[2]/100,E,t,N;if(f===0)return N=h*255,[N,N,N];h<.5?E=h*(1+f):E=h+f-h*f;let F=2*h-E,k=[0,0,0];for(let x=0;x<3;x++)t=l+1/3*-(x-1),t<0&&t++,t>1&&t--,6*t<1?N=F+(E-F)*6*t:2*t<1?N=E:3*t<2?N=F+(E-F)*(2/3-t)*6:N=F,k[x]=N*255;return k};zn.hsl.hsv=function(o){let l=o[0],f=o[1]/100,h=o[2]/100,E=f,t=Math.max(h,.01);h*=2,f*=h<=1?h:2-h,E*=t<=1?t:2-t;let N=(h+f)/2,F=h===0?2*E/(t+E):2*f/(h+f);return[l,F*100,N*100]};zn.hsv.rgb=function(o){let l=o[0]/60,f=o[1]/100,h=o[2]/100,E=Math.floor(l)%6,t=l-Math.floor(l),N=255*h*(1-f),F=255*h*(1-f*t),k=255*h*(1-f*(1-t));switch(h*=255,E){case 0:return[h,k,N];case 1:return[F,h,N];case 2:return[N,h,k];case 3:return[N,F,h];case 4:return[k,N,h];case 5:return[h,N,F]}};zn.hsv.hsl=function(o){let l=o[0],f=o[1]/100,h=o[2]/100,E=Math.max(h,.01),t,N;N=(2-f)*h;let F=(2-f)*E;return t=f*E,t/=F<=1?F:2-F,t=t||0,N/=2,[l,t*100,N*100]};zn.hwb.rgb=function(o){let l=o[0]/360,f=o[1]/100,h=o[2]/100,E=f+h,t;E>1&&(f/=E,h/=E);let N=Math.floor(6*l),F=1-h;t=6*l-N,(N&1)!==0&&(t=1-t);let k=f+t*(F-f),x,j,q;switch(N){default:case 6:case 0:x=F,j=k,q=f;break;case 1:x=k,j=F,q=f;break;case 2:x=f,j=F,q=k;break;case 3:x=f,j=k,q=F;break;case 4:x=k,j=f,q=F;break;case 5:x=F,j=f,q=k;break}return[x*255,j*255,q*255]};zn.cmyk.rgb=function(o){let l=o[0]/100,f=o[1]/100,h=o[2]/100,E=o[3]/100,t=1-Math.min(1,l*(1-E)+E),N=1-Math.min(1,f*(1-E)+E),F=1-Math.min(1,h*(1-E)+E);return[t*255,N*255,F*255]};zn.xyz.rgb=function(o){let l=o[0]/100,f=o[1]/100,h=o[2]/100,E,t,N;return E=l*3.2406+f*-1.5372+h*-.4986,t=l*-.9689+f*1.8758+h*.0415,N=l*.0557+f*-.204+h*1.057,E=E>.0031308?1.055*E**(1/2.4)-.055:E*12.92,t=t>.0031308?1.055*t**(1/2.4)-.055:t*12.92,N=N>.0031308?1.055*N**(1/2.4)-.055:N*12.92,E=Math.min(Math.max(0,E),1),t=Math.min(Math.max(0,t),1),N=Math.min(Math.max(0,N),1),[E*255,t*255,N*255]};zn.xyz.lab=function(o){let l=o[0],f=o[1],h=o[2];l/=95.047,f/=100,h/=108.883,l=l>.008856?l**(1/3):7.787*l+16/116,f=f>.008856?f**(1/3):7.787*f+16/116,h=h>.008856?h**(1/3):7.787*h+16/116;let E=116*f-16,t=500*(l-f),N=200*(f-h);return[E,t,N]};zn.lab.xyz=function(o){let l=o[0],f=o[1],h=o[2],E,t,N;t=(l+16)/116,E=f/500+t,N=t-h/200;let F=t**3,k=E**3,x=N**3;return t=F>.008856?F:(t-16/116)/7.787,E=k>.008856?k:(E-16/116)/7.787,N=x>.008856?x:(N-16/116)/7.787,E*=95.047,t*=100,N*=108.883,[E,t,N]};zn.lab.lch=function(o){let l=o[0],f=o[1],h=o[2],E;E=Math.atan2(h,f)*360/2/Math.PI,E<0&&(E+=360);let N=Math.sqrt(f*f+h*h);return[l,N,E]};zn.lch.lab=function(o){let l=o[0],f=o[1],E=o[2]/360*2*Math.PI,t=f*Math.cos(E),N=f*Math.sin(E);return[l,t,N]};zn.rgb.ansi16=function(o,l=null){let[f,h,E]=o,t=l===null?zn.rgb.hsv(o)[2]:l;if(t=Math.round(t/50),t===0)return 30;let N=30+(Math.round(E/255)<<2|Math.round(h/255)<<1|Math.round(f/255));return t===2&&(N+=60),N};zn.hsv.ansi16=function(o){return zn.rgb.ansi16(zn.hsv.rgb(o),o[2])};zn.rgb.ansi256=function(o){let l=o[0],f=o[1],h=o[2];return l===f&&f===h?l<8?16:l>248?231:Math.round((l-8)/247*24)+232:16+36*Math.round(l/255*5)+6*Math.round(f/255*5)+Math.round(h/255*5)};zn.ansi16.rgb=function(o){let l=o%10;if(l===0||l===7)return o>50&&(l+=3.5),l=l/10.5*255,[l,l,l];let f=(~~(o>50)+1)*.5,h=(l&1)*f*255,E=(l>>1&1)*f*255,t=(l>>2&1)*f*255;return[h,E,t]};zn.ansi256.rgb=function(o){if(o>=232){let t=(o-232)*10+8;return[t,t,t]}o-=16;let l,f=Math.floor(o/36)/5*255,h=Math.floor((l=o%36)/6)/5*255,E=l%6/5*255;return[f,h,E]};zn.rgb.hex=function(o){let f=(((Math.round(o[0])&255)<<16)+((Math.round(o[1])&255)<<8)+(Math.round(o[2])&255)).toString(16).toUpperCase();return"000000".substring(f.length)+f};zn.hex.rgb=function(o){let l=o.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);if(!l)return[0,0,0];let f=l[0];l[0].length===3&&(f=f.split("").map(F=>F+F).join(""));let h=parseInt(f,16),E=h>>16&255,t=h>>8&255,N=h&255;return[E,t,N]};zn.rgb.hcg=function(o){let l=o[0]/255,f=o[1]/255,h=o[2]/255,E=Math.max(Math.max(l,f),h),t=Math.min(Math.min(l,f),h),N=E-t,F,k;return N<1?F=t/(1-N):F=0,N<=0?k=0:E===l?k=(f-h)/N%6:E===f?k=2+(h-l)/N:k=4+(l-f)/N,k/=6,k%=1,[k*360,N*100,F*100]};zn.hsl.hcg=function(o){let l=o[1]/100,f=o[2]/100,h=f<.5?2*l*f:2*l*(1-f),E=0;return h<1&&(E=(f-.5*h)/(1-h)),[o[0],h*100,E*100]};zn.hsv.hcg=function(o){let l=o[1]/100,f=o[2]/100,h=l*f,E=0;return h<1&&(E=(f-h)/(1-h)),[o[0],h*100,E*100]};zn.hcg.rgb=function(o){let l=o[0]/360,f=o[1]/100,h=o[2]/100;if(f===0)return[h*255,h*255,h*255];let E=[0,0,0],t=l%1*6,N=t%1,F=1-N,k=0;switch(Math.floor(t)){case 0:E[0]=1,E[1]=N,E[2]=0;break;case 1:E[0]=F,E[1]=1,E[2]=0;break;case 2:E[0]=0,E[1]=1,E[2]=N;break;case 3:E[0]=0,E[1]=F,E[2]=1;break;case 4:E[0]=N,E[1]=0,E[2]=1;break;default:E[0]=1,E[1]=0,E[2]=F}return k=(1-f)*h,[(f*E[0]+k)*255,(f*E[1]+k)*255,(f*E[2]+k)*255]};zn.hcg.hsv=function(o){let l=o[1]/100,f=o[2]/100,h=l+f*(1-l),E=0;return h>0&&(E=l/h),[o[0],E*100,h*100]};zn.hcg.hsl=function(o){let l=o[1]/100,h=o[2]/100*(1-l)+.5*l,E=0;return h>0&&h<.5?E=l/(2*h):h>=.5&&h<1&&(E=l/(2*(1-h))),[o[0],E*100,h*100]};zn.hcg.hwb=function(o){let l=o[1]/100,f=o[2]/100,h=l+f*(1-l);return[o[0],(h-l)*100,(1-h)*100]};zn.hwb.hcg=function(o){let l=o[1]/100,h=1-o[2]/100,E=h-l,t=0;return E<1&&(t=(h-E)/(1-E)),[o[0],E*100,t*100]};zn.apple.rgb=function(o){return[o[0]/65535*255,o[1]/65535*255,o[2]/65535*255]};zn.rgb.apple=function(o){return[o[0]/255*65535,o[1]/255*65535,o[2]/255*65535]};zn.gray.rgb=function(o){return[o[0]/100*255,o[0]/100*255,o[0]/100*255]};zn.gray.hsl=function(o){return[0,0,o[0]]};zn.gray.hsv=zn.gray.hsl;zn.gray.hwb=function(o){return[0,100,o[0]]};zn.gray.cmyk=function(o){return[0,0,0,o[0]]};zn.gray.lab=function(o){return[o[0],0,0]};zn.gray.hex=function(o){let l=Math.round(o[0]/100*255)&255,h=((l<<16)+(l<<8)+l).toString(16).toUpperCase();return"000000".substring(h.length)+h};zn.rgb.gray=function(o){return[(o[0]+o[1]+o[2])/3/255*100]}});var yT=nt((IH,mT)=>{var W_=AD();function zP(){let o={},l=Object.keys(W_);for(let f=l.length,h=0;h<f;h++)o[l[h]]={distance:-1,parent:null};return o}function HP(o){let l=zP(),f=[o];for(l[o].distance=0;f.length;){let h=f.pop(),E=Object.keys(W_[h]);for(let t=E.length,N=0;N<t;N++){let F=E[N],k=l[F];k.distance===-1&&(k.distance=l[h].distance+1,k.parent=h,f.unshift(F))}}return l}function qP(o,l){return function(f){return l(o(f))}}function WP(o,l){let f=[l[o].parent,o],h=W_[l[o].parent][o],E=l[o].parent;for(;l[E].parent;)f.unshift(l[E].parent),h=qP(W_[l[E].parent][E],h),E=l[E].parent;return h.conversion=f,h}mT.exports=function(o){let l=HP(o),f={},h=Object.keys(l);for(let E=h.length,t=0;t<E;t++){let N=h[t];l[N].parent!==null&&(f[N]=WP(N,l))}return f}});var _T=nt((bH,gT)=>{var OD=AD(),VP=yT(),Zv={},GP=Object.keys(OD);function YP(o){let l=function(...f){let h=f[0];return h==null?h:(h.length>1&&(f=h),o(f))};return"conversion"in o&&(l.conversion=o.conversion),l}function KP(o){let l=function(...f){let h=f[0];if(h==null)return h;h.length>1&&(f=h);let E=o(f);if(typeof E=="object")for(let t=E.length,N=0;N<t;N++)E[N]=Math.round(E[N]);return E};return"conversion"in o&&(l.conversion=o.conversion),l}GP.forEach(o=>{Zv[o]={},Object.defineProperty(Zv[o],"channels",{value:OD[o].channels}),Object.defineProperty(Zv[o],"labels",{value:OD[o].labels});let l=VP(o);Object.keys(l).forEach(h=>{let E=l[h];Zv[o][h]=KP(E),Zv[o][h].raw=YP(E)})});gT.exports=Zv});var G_=nt((BH,TT)=>{"use strict";var ET=(o,l)=>(...f)=>`\x1B[${o(...f)+l}m`,DT=(o,l)=>(...f)=>{let h=o(...f);return`\x1B[${38+l};5;${h}m`},wT=(o,l)=>(...f)=>{let h=o(...f);return`\x1B[${38+l};2;${h[0]};${h[1]};${h[2]}m`},V_=o=>o,ST=(o,l,f)=>[o,l,f],$v=(o,l,f)=>{Object.defineProperty(o,l,{get:()=>{let h=f();return Object.defineProperty(o,l,{value:h,enumerable:!0,configurable:!0}),h},enumerable:!0,configurable:!0})},MD,em=(o,l,f,h)=>{MD===void 0&&(MD=_T());let E=h?10:0,t={};for(let[N,F]of Object.entries(MD)){let k=N==="ansi16"?"ansi":N;N===l?t[k]=o(f,E):typeof F=="object"&&(t[k]=o(F[l],E))}return t};function XP(){let o=new Map,l={modifier:{reset:[0,0],bold:[1,22],dim:[2,22],italic:[3,23],underline:[4,24],inverse:[7,27],hidden:[8,28],strikethrough:[9,29]},color:{black:[30,39],red:[31,39],green:[32,39],yellow:[33,39],blue:[34,39],magenta:[35,39],cyan:[36,39],white:[37,39],blackBright:[90,39],redBright:[91,39],greenBright:[92,39],yellowBright:[93,39],blueBright:[94,39],magentaBright:[95,39],cyanBright:[96,39],whiteBright:[97,39]},bgColor:{bgBlack:[40,49],bgRed:[41,49],bgGreen:[42,49],bgYellow:[43,49],bgBlue:[44,49],bgMagenta:[45,49],bgCyan:[46,49],bgWhite:[47,49],bgBlackBright:[100,49],bgRedBright:[101,49],bgGreenBright:[102,49],bgYellowBright:[103,49],bgBlueBright:[104,49],bgMagentaBright:[105,49],bgCyanBright:[106,49],bgWhiteBright:[107,49]}};l.color.gray=l.color.blackBright,l.bgColor.bgGray=l.bgColor.bgBlackBright,l.color.grey=l.color.blackBright,l.bgColor.bgGrey=l.bgColor.bgBlackBright;for(let[f,h]of Object.entries(l)){for(let[E,t]of Object.entries(h))l[E]={open:`\x1B[${t[0]}m`,close:`\x1B[${t[1]}m`},h[E]=l[E],o.set(t[0],t[1]);Object.defineProperty(l,f,{value:h,enumerable:!1})}return Object.defineProperty(l,"codes",{value:o,enumerable:!1}),l.color.close="\x1B[39m",l.bgColor.close="\x1B[49m",$v(l.color,"ansi",()=>em(ET,"ansi16",V_,!1)),$v(l.color,"ansi256",()=>em(DT,"ansi256",V_,!1)),$v(l.color,"ansi16m",()=>em(wT,"rgb",ST,!1)),$v(l.bgColor,"ansi",()=>em(ET,"ansi16",V_,!0)),$v(l.bgColor,"ansi256",()=>em(DT,"ansi256",V_,!0)),$v(l.bgColor,"ansi16m",()=>em(wT,"rgb",ST,!0)),l}Object.defineProperty(TT,"exports",{enumerable:!0,get:XP})});var RT=nt((UH,xT)=>{"use strict";var Jy=q_(),QP=DD(),JP=G_(),ND=new Set(["\x1B","\x9B"]),ZP=39,CT=o=>`${ND.values().next().value}[${o}m`,$P=o=>o.split(" ").map(l=>Jy(l)),kD=(o,l,f)=>{let h=[...l],E=!1,t=Jy(QP(o[o.length-1]));for(let[N,F]of h.entries()){let k=Jy(F);if(t+k<=f?o[o.length-1]+=F:(o.push(F),t=0),ND.has(F))E=!0;else if(E&&F==="m"){E=!1;continue}E||(t+=k,t===f&&N<h.length-1&&(o.push(""),t=0))}!t&&o[o.length-1].length>0&&o.length>1&&(o[o.length-2]+=o.pop())},eI=o=>{let l=o.split(" "),f=l.length;for(;f>0&&!(Jy(l[f-1])>0);)f--;return f===l.length?o:l.slice(0,f).join(" ")+l.slice(f).join("")},tI=(o,l,f={})=>{if(f.trim!==!1&&o.trim()==="")return"";let h="",E="",t,N=$P(o),F=[""];for(let[k,x]of o.split(" ").entries()){f.trim!==!1&&(F[F.length-1]=F[F.length-1].trimLeft());let j=Jy(F[F.length-1]);if(k!==0&&(j>=l&&(f.wordWrap===!1||f.trim===!1)&&(F.push(""),j=0),(j>0||f.trim===!1)&&(F[F.length-1]+=" ",j++)),f.hard&&N[k]>l){let q=l-j,V=1+Math.floor((N[k]-q-1)/l);Math.floor((N[k]-1)/l)<V&&F.push(""),kD(F,x,l);continue}if(j+N[k]>l&&j>0&&N[k]>0){if(f.wordWrap===!1&&j<l){kD(F,x,l);continue}F.push("")}if(j+N[k]>l&&f.wordWrap===!1){kD(F,x,l);continue}F[F.length-1]+=x}f.trim!==!1&&(F=F.map(eI)),h=F.join(`
+`);for(let[k,x]of[...h].entries()){if(E+=x,ND.has(x)){let q=parseFloat(/\d[^m]*/.exec(h.slice(k,k+4)));t=q===ZP?null:q}let j=JP.codes.get(Number(t));t&&j&&(h[k+1]===`
+`?E+=CT(j):x===`
+`&&(E+=CT(t)))}return E};xT.exports=(o,l,f)=>String(o).normalize().replace(/\r\n/g,`
+`).split(`
+`).map(h=>tI(h,l,f)).join(`
+`)});var MT=nt((jH,OT)=>{"use strict";var AT="[\uD800-\uDBFF][\uDC00-\uDFFF]",nI=o=>o&&o.exact?new RegExp(`^${AT}$`):new RegExp(AT,"g");OT.exports=nI});var LD=nt((zH,FT)=>{"use strict";var rI=SD(),iI=MT(),kT=G_(),LT=["\x1B","\x9B"],Y_=o=>`${LT[0]}[${o}m`,NT=(o,l,f)=>{let h=[];o=[...o];for(let E of o){let t=E;E.match(";")&&(E=E.split(";")[0][0]+"0");let N=kT.codes.get(parseInt(E,10));if(N){let F=o.indexOf(N.toString());F>=0?o.splice(F,1):h.push(Y_(l?N:t))}else if(l){h.push(Y_(0));break}else h.push(Y_(t))}if(l&&(h=h.filter((E,t)=>h.indexOf(E)===t),f!==void 0)){let E=Y_(kT.codes.get(parseInt(f,10)));h=h.reduce((t,N)=>N===E?[N,...t]:[...t,N],[])}return h.join("")};FT.exports=(o,l,f)=>{let h=[...o.normalize()],E=[];f=typeof f=="number"?f:h.length;let t=!1,N,F=0,k="";for(let[x,j]of h.entries()){let q=!1;if(LT.includes(j)){let V=/\d[^m]*/.exec(o.slice(x,x+18));N=V&&V.length>0?V[0]:void 0,F<f&&(t=!0,N!==void 0&&E.push(N))}else t&&j==="m"&&(t=!1,q=!0);if(!t&&!q&&++F,!iI({exact:!0}).test(j)&&rI(j.codePointAt())&&++F,F>l&&F<=f)k+=j;else if(F===l&&!t&&N!==void 0)k=NT(E);else if(F>=f){k+=NT(E,!0,N);break}}return k}});var IT=nt((HH,PT)=>{"use strict";var c2=LD(),uI=q_();function K_(o,l,f){if(o.charAt(l)===" ")return l;for(let h=1;h<=3;h++)if(f){if(o.charAt(l+h)===" ")return l+h}else if(o.charAt(l-h)===" ")return l-h;return l}PT.exports=(o,l,f)=>{f={position:"end",preferTruncationOnSpace:!1,...f};let{position:h,space:E,preferTruncationOnSpace:t}=f,N="\u2026",F=1;if(typeof o!="string")throw new TypeError(`Expected \`input\` to be a string, got ${typeof o}`);if(typeof l!="number")throw new TypeError(`Expected \`columns\` to be a number, got ${typeof l}`);if(l<1)return"";if(l===1)return N;let k=uI(o);if(k<=l)return o;if(h==="start"){if(t){let x=K_(o,k-l+1,!0);return N+c2(o,x,k).trim()}return E===!0&&(N+=" ",F=2),N+c2(o,k-l+F,k)}if(h==="middle"){E===!0&&(N=" "+N+" ",F=3);let x=Math.floor(l/2);if(t){let j=K_(o,x),q=K_(o,k-(l-x)+1,!0);return c2(o,0,j)+N+c2(o,q,k).trim()}return c2(o,0,x)+N+c2(o,k-(l-x)+F,k)}if(h==="end"){if(t){let x=K_(o,l-1);return c2(o,0,x)+N}return E===!0&&(N=" "+N,F=2),c2(o,0,l-F)+N}throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${h}`)}});var PD=nt(Zy=>{"use strict";var bT=Zy&&Zy.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Zy,"__esModule",{value:!0});var oI=bT(RT()),lI=bT(IT()),FD={};Zy.default=(o,l,f)=>{let h=o+String(l)+String(f);if(FD[h])return FD[h];let E=o;if(f==="wrap"&&(E=oI.default(o,l,{trim:!1,hard:!0})),f.startsWith("truncate")){let t="end";f==="truncate-middle"&&(t="middle"),f==="truncate-start"&&(t="start"),E=lI.default(o,l,{position:t})}return FD[h]=E,E}});var bD=nt(ID=>{"use strict";Object.defineProperty(ID,"__esModule",{value:!0});var BT=o=>{let l="";if(o.childNodes.length>0)for(let f of o.childNodes){let h="";f.nodeName==="#text"?h=f.nodeValue:((f.nodeName==="ink-text"||f.nodeName==="ink-virtual-text")&&(h=BT(f)),h.length>0&&typeof f.internal_transform=="function"&&(h=f.internal_transform(h))),l+=h}return l};ID.default=BT});var BD=nt(f0=>{"use strict";var $y=f0&&f0.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(f0,"__esModule",{value:!0});f0.setTextNodeValue=f0.createTextNode=f0.setStyle=f0.setAttribute=f0.removeChildNode=f0.insertBeforeNode=f0.appendChildNode=f0.createNode=f0.TEXT_NAME=void 0;var sI=$y(eh()),UT=$y(fT()),aI=$y(cT()),fI=$y(PD()),cI=$y(bD());f0.TEXT_NAME="#text";f0.createNode=o=>{var l;let f={nodeName:o,style:{},attributes:{},childNodes:[],parentNode:null,yogaNode:o==="ink-virtual-text"?void 0:sI.default.Node.create()};return o==="ink-text"&&((l=f.yogaNode)===null||l===void 0||l.setMeasureFunc(dI.bind(null,f))),f};f0.appendChildNode=(o,l)=>{var f;l.parentNode&&f0.removeChildNode(l.parentNode,l),l.parentNode=o,o.childNodes.push(l),l.yogaNode&&((f=o.yogaNode)===null||f===void 0||f.insertChild(l.yogaNode,o.yogaNode.getChildCount())),(o.nodeName==="ink-text"||o.nodeName==="ink-virtual-text")&&X_(o)};f0.insertBeforeNode=(o,l,f)=>{var h,E;l.parentNode&&f0.removeChildNode(l.parentNode,l),l.parentNode=o;let t=o.childNodes.indexOf(f);if(t>=0){o.childNodes.splice(t,0,l),l.yogaNode&&((h=o.yogaNode)===null||h===void 0||h.insertChild(l.yogaNode,t));return}o.childNodes.push(l),l.yogaNode&&((E=o.yogaNode)===null||E===void 0||E.insertChild(l.yogaNode,o.yogaNode.getChildCount())),(o.nodeName==="ink-text"||o.nodeName==="ink-virtual-text")&&X_(o)};f0.removeChildNode=(o,l)=>{var f,h;l.yogaNode&&((h=(f=l.parentNode)===null||f===void 0?void 0:f.yogaNode)===null||h===void 0||h.removeChild(l.yogaNode)),l.parentNode=null;let E=o.childNodes.indexOf(l);E>=0&&o.childNodes.splice(E,1),(o.nodeName==="ink-text"||o.nodeName==="ink-virtual-text")&&X_(o)};f0.setAttribute=(o,l,f)=>{o.attributes[l]=f};f0.setStyle=(o,l)=>{o.style=l,o.yogaNode&&aI.default(o.yogaNode,l)};f0.createTextNode=o=>{let l={nodeName:"#text",nodeValue:o,yogaNode:void 0,parentNode:null,style:{}};return f0.setTextNodeValue(l,o),l};var dI=function(o,l){var f,h;let E=o.nodeName==="#text"?o.nodeValue:cI.default(o),t=UT.default(E);if(t.width<=l||t.width>=1&&l>0&&l<1)return t;let N=(h=(f=o.style)===null||f===void 0?void 0:f.textWrap)!==null&&h!==void 0?h:"wrap",F=fI.default(E,l,N);return UT.default(F)},jT=o=>{var l;if(!(!o||!o.parentNode))return(l=o.yogaNode)!==null&&l!==void 0?l:jT(o.parentNode)},X_=o=>{let l=jT(o);l==null||l.markDirty()};f0.setTextNodeValue=(o,l)=>{typeof l!="string"&&(l=String(l)),o.nodeValue=l,X_(o)}});var th=nt((GH,zT)=>{"use strict";zT.exports={BINARY_TYPES:["nodebuffer","arraybuffer","fragments"],GUID:"258EAFA5-E914-47DA-95CA-C5AB0DC85B11",kStatusCode:Symbol("status-code"),kWebSocket:Symbol("websocket"),EMPTY_BUFFER:Buffer.alloc(0),NOOP:()=>{}}});var eg=nt((YH,UD)=>{"use strict";var{EMPTY_BUFFER:pI}=th();function HT(o,l){if(o.length===0)return pI;if(o.length===1)return o[0];let f=Buffer.allocUnsafe(l),h=0;for(let E=0;E<o.length;E++){let t=o[E];f.set(t,h),h+=t.length}return h<l?f.slice(0,h):f}function qT(o,l,f,h,E){for(let t=0;t<E;t++)f[h+t]=o[t]^l[t&3]}function WT(o,l){let f=o.length;for(let h=0;h<f;h++)o[h]^=l[h&3]}function VT(o){return o.byteLength===o.buffer.byteLength?o.buffer:o.buffer.slice(o.byteOffset,o.byteOffset+o.byteLength)}function Q_(o){if(Q_.readOnly=!0,Buffer.isBuffer(o))return o;let l;return o instanceof ArrayBuffer?l=Buffer.from(o):ArrayBuffer.isView(o)?l=Buffer.from(o.buffer,o.byteOffset,o.byteLength):(l=Buffer.from(o),Q_.readOnly=!1),l}try{let o=hi("bufferutil"),l=o.BufferUtil||o;UD.exports={concat:HT,mask(f,h,E,t,N){N<48?qT(f,h,E,t,N):l.mask(f,h,E,t,N)},toArrayBuffer:VT,toBuffer:Q_,unmask(f,h){f.length<32?WT(f,h):l.unmask(f,h)}}}catch{UD.exports={concat:HT,mask:qT,toArrayBuffer:VT,toBuffer:Q_,unmask:WT}}});var KT=nt((KH,YT)=>{"use strict";var GT=Symbol("kDone"),jD=Symbol("kRun"),zD=class{constructor(l){this[GT]=()=>{this.pending--,this[jD]()},this.concurrency=l||1/0,this.jobs=[],this.pending=0}add(l){this.jobs.push(l),this[jD]()}[jD](){if(this.pending!==this.concurrency&&this.jobs.length){let l=this.jobs.shift();this.pending++,l(this[GT])}}};YT.exports=zD});var rg=nt((XH,ZT)=>{"use strict";var tg=hi("zlib"),XT=eg(),hI=KT(),{kStatusCode:QT,NOOP:vI}=th(),mI=Buffer.from([0,0,255,255]),Z_=Symbol("permessage-deflate"),X1=Symbol("total-length"),ng=Symbol("callback"),d2=Symbol("buffers"),HD=Symbol("error"),J_,qD=class{constructor(l,f,h){if(this._maxPayload=h|0,this._options=l||{},this._threshold=this._options.threshold!==void 0?this._options.threshold:1024,this._isServer=!!f,this._deflate=null,this._inflate=null,this.params=null,!J_){let E=this._options.concurrencyLimit!==void 0?this._options.concurrencyLimit:10;J_=new hI(E)}}static get extensionName(){return"permessage-deflate"}offer(){let l={};return this._options.serverNoContextTakeover&&(l.server_no_context_takeover=!0),this._options.clientNoContextTakeover&&(l.client_no_context_takeover=!0),this._options.serverMaxWindowBits&&(l.server_max_window_bits=this._options.serverMaxWindowBits),this._options.clientMaxWindowBits?l.client_max_window_bits=this._options.clientMaxWindowBits:this._options.clientMaxWindowBits==null&&(l.client_max_window_bits=!0),l}accept(l){return l=this.normalizeParams(l),this.params=this._isServer?this.acceptAsServer(l):this.acceptAsClient(l),this.params}cleanup(){if(this._inflate&&(this._inflate.close(),this._inflate=null),this._deflate){let l=this._deflate[ng];this._deflate.close(),this._deflate=null,l&&l(new Error("The deflate stream was closed while data was being processed"))}}acceptAsServer(l){let f=this._options,h=l.find(E=>!(f.serverNoContextTakeover===!1&&E.server_no_context_takeover||E.server_max_window_bits&&(f.serverMaxWindowBits===!1||typeof f.serverMaxWindowBits=="number"&&f.serverMaxWindowBits>E.server_max_window_bits)||typeof f.clientMaxWindowBits=="number"&&!E.client_max_window_bits));if(!h)throw new Error("None of the extension offers can be accepted");return f.serverNoContextTakeover&&(h.server_no_context_takeover=!0),f.clientNoContextTakeover&&(h.client_no_context_takeover=!0),typeof f.serverMaxWindowBits=="number"&&(h.server_max_window_bits=f.serverMaxWindowBits),typeof f.clientMaxWindowBits=="number"?h.client_max_window_bits=f.clientMaxWindowBits:(h.client_max_window_bits===!0||f.clientMaxWindowBits===!1)&&delete h.client_max_window_bits,h}acceptAsClient(l){let f=l[0];if(this._options.clientNoContextTakeover===!1&&f.client_no_context_takeover)throw new Error('Unexpected parameter "client_no_context_takeover"');if(!f.client_max_window_bits)typeof this._options.clientMaxWindowBits=="number"&&(f.client_max_window_bits=this._options.clientMaxWindowBits);else if(this._options.clientMaxWindowBits===!1||typeof this._options.clientMaxWindowBits=="number"&&f.client_max_window_bits>this._options.clientMaxWindowBits)throw new Error('Unexpected or invalid parameter "client_max_window_bits"');return f}normalizeParams(l){return l.forEach(f=>{Object.keys(f).forEach(h=>{let E=f[h];if(E.length>1)throw new Error(`Parameter "${h}" must have only a single value`);if(E=E[0],h==="client_max_window_bits"){if(E!==!0){let t=+E;if(!Number.isInteger(t)||t<8||t>15)throw new TypeError(`Invalid value for parameter "${h}": ${E}`);E=t}else if(!this._isServer)throw new TypeError(`Invalid value for parameter "${h}": ${E}`)}else if(h==="server_max_window_bits"){let t=+E;if(!Number.isInteger(t)||t<8||t>15)throw new TypeError(`Invalid value for parameter "${h}": ${E}`);E=t}else if(h==="client_no_context_takeover"||h==="server_no_context_takeover"){if(E!==!0)throw new TypeError(`Invalid value for parameter "${h}": ${E}`)}else throw new Error(`Unknown parameter "${h}"`);f[h]=E})}),l}decompress(l,f,h){J_.add(E=>{this._decompress(l,f,(t,N)=>{E(),h(t,N)})})}compress(l,f,h){J_.add(E=>{this._compress(l,f,(t,N)=>{E(),h(t,N)})})}_decompress(l,f,h){let E=this._isServer?"client":"server";if(!this._inflate){let t=`${E}_max_window_bits`,N=typeof this.params[t]!="number"?tg.Z_DEFAULT_WINDOWBITS:this.params[t];this._inflate=tg.createInflateRaw({...this._options.zlibInflateOptions,windowBits:N}),this._inflate[Z_]=this,this._inflate[X1]=0,this._inflate[d2]=[],this._inflate.on("error",gI),this._inflate.on("data",JT)}this._inflate[ng]=h,this._inflate.write(l),f&&this._inflate.write(mI),this._inflate.flush(()=>{let t=this._inflate[HD];if(t){this._inflate.close(),this._inflate=null,h(t);return}let N=XT.concat(this._inflate[d2],this._inflate[X1]);this._inflate._readableState.endEmitted?(this._inflate.close(),this._inflate=null):(this._inflate[X1]=0,this._inflate[d2]=[],f&&this.params[`${E}_no_context_takeover`]&&this._inflate.reset()),h(null,N)})}_compress(l,f,h){let E=this._isServer?"server":"client";if(!this._deflate){let t=`${E}_max_window_bits`,N=typeof this.params[t]!="number"?tg.Z_DEFAULT_WINDOWBITS:this.params[t];this._deflate=tg.createDeflateRaw({...this._options.zlibDeflateOptions,windowBits:N}),this._deflate[X1]=0,this._deflate[d2]=[],this._deflate.on("error",vI),this._deflate.on("data",yI)}this._deflate[ng]=h,this._deflate.write(l),this._deflate.flush(tg.Z_SYNC_FLUSH,()=>{if(!this._deflate)return;let t=XT.concat(this._deflate[d2],this._deflate[X1]);f&&(t=t.slice(0,t.length-4)),this._deflate[ng]=null,this._deflate[X1]=0,this._deflate[d2]=[],f&&this.params[`${E}_no_context_takeover`]&&this._deflate.reset(),h(null,t)})}};ZT.exports=qD;function yI(o){this[d2].push(o),this[X1]+=o.length}function JT(o){if(this[X1]+=o.length,this[Z_]._maxPayload<1||this[X1]<=this[Z_]._maxPayload){this[d2].push(o);return}this[HD]=new RangeError("Max payload size exceeded"),this[HD][QT]=1009,this.removeListener("data",JT),this.reset()}function gI(o){this[Z_]._inflate=null,o[QT]=1007,this[ng](o)}});var VD=nt((QH,WD)=>{"use strict";function $T(o){return o>=1e3&&o<=1014&&o!==1004&&o!==1005&&o!==1006||o>=3e3&&o<=4999}function eC(o){let l=o.length,f=0;for(;f<l;)if((o[f]&128)===0)f++;else if((o[f]&224)===192){if(f+1===l||(o[f+1]&192)!==128||(o[f]&254)===192)return!1;f+=2}else if((o[f]&240)===224){if(f+2>=l||(o[f+1]&192)!==128||(o[f+2]&192)!==128||o[f]===224&&(o[f+1]&224)===128||o[f]===237&&(o[f+1]&224)===160)return!1;f+=3}else if((o[f]&248)===240){if(f+3>=l||(o[f+1]&192)!==128||(o[f+2]&192)!==128||(o[f+3]&192)!==128||o[f]===240&&(o[f+1]&240)===128||o[f]===244&&o[f+1]>143||o[f]>244)return!1;f+=4}else return!1;return!0}try{let o=hi("utf-8-validate");typeof o=="object"&&(o=o.Validation.isValidUTF8),WD.exports={isValidStatusCode:$T,isValidUTF8(l){return l.length<150?eC(l):o(l)}}}catch{WD.exports={isValidStatusCode:$T,isValidUTF8:eC}}});var XD=nt((JH,oC)=>{"use strict";var{Writable:_I}=hi("stream"),tC=rg(),{BINARY_TYPES:EI,EMPTY_BUFFER:DI,kStatusCode:wI,kWebSocket:SI}=th(),{concat:GD,toArrayBuffer:TI,unmask:CI}=eg(),{isValidStatusCode:xI,isValidUTF8:nC}=VD(),ig=0,rC=1,iC=2,uC=3,YD=4,RI=5,KD=class extends _I{constructor(l,f,h,E){super(),this._binaryType=l||EI[0],this[SI]=void 0,this._extensions=f||{},this._isServer=!!h,this._maxPayload=E|0,this._bufferedBytes=0,this._buffers=[],this._compressed=!1,this._payloadLength=0,this._mask=void 0,this._fragmented=0,this._masked=!1,this._fin=!1,this._opcode=0,this._totalPayloadLength=0,this._messageLength=0,this._fragments=[],this._state=ig,this._loop=!1}_write(l,f,h){if(this._opcode===8&&this._state==ig)return h();this._bufferedBytes+=l.length,this._buffers.push(l),this.startLoop(h)}consume(l){if(this._bufferedBytes-=l,l===this._buffers[0].length)return this._buffers.shift();if(l<this._buffers[0].length){let h=this._buffers[0];return this._buffers[0]=h.slice(l),h.slice(0,l)}let f=Buffer.allocUnsafe(l);do{let h=this._buffers[0],E=f.length-l;l>=h.length?f.set(this._buffers.shift(),E):(f.set(new Uint8Array(h.buffer,h.byteOffset,l),E),this._buffers[0]=h.slice(l)),l-=h.length}while(l>0);return f}startLoop(l){let f;this._loop=!0;do switch(this._state){case ig:f=this.getInfo();break;case rC:f=this.getPayloadLength16();break;case iC:f=this.getPayloadLength64();break;case uC:this.getMask();break;case YD:f=this.getData(l);break;default:this._loop=!1;return}while(this._loop);l(f)}getInfo(){if(this._bufferedBytes<2){this._loop=!1;return}let l=this.consume(2);if((l[0]&48)!==0)return this._loop=!1,Ko(RangeError,"RSV2 and RSV3 must be clear",!0,1002);let f=(l[0]&64)===64;if(f&&!this._extensions[tC.extensionName])return this._loop=!1,Ko(RangeError,"RSV1 must be clear",!0,1002);if(this._fin=(l[0]&128)===128,this._opcode=l[0]&15,this._payloadLength=l[1]&127,this._opcode===0){if(f)return this._loop=!1,Ko(RangeError,"RSV1 must be clear",!0,1002);if(!this._fragmented)return this._loop=!1,Ko(RangeError,"invalid opcode 0",!0,1002);this._opcode=this._fragmented}else if(this._opcode===1||this._opcode===2){if(this._fragmented)return this._loop=!1,Ko(RangeError,`invalid opcode ${this._opcode}`,!0,1002);this._compressed=f}else if(this._opcode>7&&this._opcode<11){if(!this._fin)return this._loop=!1,Ko(RangeError,"FIN must be set",!0,1002);if(f)return this._loop=!1,Ko(RangeError,"RSV1 must be clear",!0,1002);if(this._payloadLength>125)return this._loop=!1,Ko(RangeError,`invalid payload length ${this._payloadLength}`,!0,1002)}else return this._loop=!1,Ko(RangeError,`invalid opcode ${this._opcode}`,!0,1002);if(!this._fin&&!this._fragmented&&(this._fragmented=this._opcode),this._masked=(l[1]&128)===128,this._isServer){if(!this._masked)return this._loop=!1,Ko(RangeError,"MASK must be set",!0,1002)}else if(this._masked)return this._loop=!1,Ko(RangeError,"MASK must be clear",!0,1002);if(this._payloadLength===126)this._state=rC;else if(this._payloadLength===127)this._state=iC;else return this.haveLength()}getPayloadLength16(){if(this._bufferedBytes<2){this._loop=!1;return}return this._payloadLength=this.consume(2).readUInt16BE(0),this.haveLength()}getPayloadLength64(){if(this._bufferedBytes<8){this._loop=!1;return}let l=this.consume(8),f=l.readUInt32BE(0);return f>Math.pow(2,53-32)-1?(this._loop=!1,Ko(RangeError,"Unsupported WebSocket frame: payload length > 2^53 - 1",!1,1009)):(this._payloadLength=f*Math.pow(2,32)+l.readUInt32BE(4),this.haveLength())}haveLength(){if(this._payloadLength&&this._opcode<8&&(this._totalPayloadLength+=this._payloadLength,this._totalPayloadLength>this._maxPayload&&this._maxPayload>0))return this._loop=!1,Ko(RangeError,"Max payload size exceeded",!1,1009);this._masked?this._state=uC:this._state=YD}getMask(){if(this._bufferedBytes<4){this._loop=!1;return}this._mask=this.consume(4),this._state=YD}getData(l){let f=DI;if(this._payloadLength){if(this._bufferedBytes<this._payloadLength){this._loop=!1;return}f=this.consume(this._payloadLength),this._masked&&CI(f,this._mask)}if(this._opcode>7)return this.controlMessage(f);if(this._compressed){this._state=RI,this.decompress(f,l);return}return f.length&&(this._messageLength=this._totalPayloadLength,this._fragments.push(f)),this.dataMessage()}decompress(l,f){this._extensions[tC.extensionName].decompress(l,this._fin,(E,t)=>{if(E)return f(E);if(t.length){if(this._messageLength+=t.length,this._messageLength>this._maxPayload&&this._maxPayload>0)return f(Ko(RangeError,"Max payload size exceeded",!1,1009));this._fragments.push(t)}let N=this.dataMessage();if(N)return f(N);this.startLoop(f)})}dataMessage(){if(this._fin){let l=this._messageLength,f=this._fragments;if(this._totalPayloadLength=0,this._messageLength=0,this._fragmented=0,this._fragments=[],this._opcode===2){let h;this._binaryType==="nodebuffer"?h=GD(f,l):this._binaryType==="arraybuffer"?h=TI(GD(f,l)):h=f,this.emit("message",h)}else{let h=GD(f,l);if(!nC(h))return this._loop=!1,Ko(Error,"invalid UTF-8 sequence",!0,1007);this.emit("message",h.toString())}}this._state=ig}controlMessage(l){if(this._opcode===8)if(this._loop=!1,l.length===0)this.emit("conclude",1005,""),this.end();else{if(l.length===1)return Ko(RangeError,"invalid payload length 1",!0,1002);{let f=l.readUInt16BE(0);if(!xI(f))return Ko(RangeError,`invalid status code ${f}`,!0,1002);let h=l.slice(2);if(!nC(h))return Ko(Error,"invalid UTF-8 sequence",!0,1007);this.emit("conclude",f,h.toString()),this.end()}}else this._opcode===9?this.emit("ping",l):this.emit("pong",l);this._state=ig}};oC.exports=KD;function Ko(o,l,f,h){let E=new o(f?`Invalid WebSocket frame: ${l}`:l);return Error.captureStackTrace(E,Ko),E[wI]=h,E}});var QD=nt((ZH,aC)=>{"use strict";var{randomFillSync:AI}=hi("crypto"),lC=rg(),{EMPTY_BUFFER:OI}=th(),{isValidStatusCode:MI}=VD(),{mask:sC,toBuffer:Q1}=eg(),nh=Buffer.alloc(4),jc=class{constructor(l,f){this._extensions=f||{},this._socket=l,this._firstFragment=!0,this._compress=!1,this._bufferedBytes=0,this._deflating=!1,this._queue=[]}static frame(l,f){let h=f.mask&&f.readOnly,E=f.mask?6:2,t=l.length;l.length>=65536?(E+=8,t=127):l.length>125&&(E+=2,t=126);let N=Buffer.allocUnsafe(h?l.length+E:E);return N[0]=f.fin?f.opcode|128:f.opcode,f.rsv1&&(N[0]|=64),N[1]=t,t===126?N.writeUInt16BE(l.length,2):t===127&&(N.writeUInt32BE(0,2),N.writeUInt32BE(l.length,6)),f.mask?(AI(nh,0,4),N[1]|=128,N[E-4]=nh[0],N[E-3]=nh[1],N[E-2]=nh[2],N[E-1]=nh[3],h?(sC(l,nh,N,E,l.length),[N]):(sC(l,nh,l,0,l.length),[N,l])):[N,l]}close(l,f,h,E){let t;if(l===void 0)t=OI;else{if(typeof l!="number"||!MI(l))throw new TypeError("First argument must be a valid error code number");if(f===void 0||f==="")t=Buffer.allocUnsafe(2),t.writeUInt16BE(l,0);else{let N=Buffer.byteLength(f);if(N>123)throw new RangeError("The message must not be greater than 123 bytes");t=Buffer.allocUnsafe(2+N),t.writeUInt16BE(l,0),t.write(f,2)}}this._deflating?this.enqueue([this.doClose,t,h,E]):this.doClose(t,h,E)}doClose(l,f,h){this.sendFrame(jc.frame(l,{fin:!0,rsv1:!1,opcode:8,mask:f,readOnly:!1}),h)}ping(l,f,h){let E=Q1(l);if(E.length>125)throw new RangeError("The data size must not be greater than 125 bytes");this._deflating?this.enqueue([this.doPing,E,f,Q1.readOnly,h]):this.doPing(E,f,Q1.readOnly,h)}doPing(l,f,h,E){this.sendFrame(jc.frame(l,{fin:!0,rsv1:!1,opcode:9,mask:f,readOnly:h}),E)}pong(l,f,h){let E=Q1(l);if(E.length>125)throw new RangeError("The data size must not be greater than 125 bytes");this._deflating?this.enqueue([this.doPong,E,f,Q1.readOnly,h]):this.doPong(E,f,Q1.readOnly,h)}doPong(l,f,h,E){this.sendFrame(jc.frame(l,{fin:!0,rsv1:!1,opcode:10,mask:f,readOnly:h}),E)}send(l,f,h){let E=Q1(l),t=this._extensions[lC.extensionName],N=f.binary?2:1,F=f.compress;if(this._firstFragment?(this._firstFragment=!1,F&&t&&(F=E.length>=t._threshold),this._compress=F):(F=!1,N=0),f.fin&&(this._firstFragment=!0),t){let k={fin:f.fin,rsv1:F,opcode:N,mask:f.mask,readOnly:Q1.readOnly};this._deflating?this.enqueue([this.dispatch,E,this._compress,k,h]):this.dispatch(E,this._compress,k,h)}else this.sendFrame(jc.frame(E,{fin:f.fin,rsv1:!1,opcode:N,mask:f.mask,readOnly:Q1.readOnly}),h)}dispatch(l,f,h,E){if(!f){this.sendFrame(jc.frame(l,h),E);return}let t=this._extensions[lC.extensionName];this._bufferedBytes+=l.length,this._deflating=!0,t.compress(l,h.fin,(N,F)=>{if(this._socket.destroyed){let k=new Error("The socket was closed while data was being compressed");typeof E=="function"&&E(k);for(let x=0;x<this._queue.length;x++){let j=this._queue[x][4];typeof j=="function"&&j(k)}return}this._bufferedBytes-=l.length,this._deflating=!1,h.readOnly=!1,this.sendFrame(jc.frame(F,h),E),this.dequeue()})}dequeue(){for(;!this._deflating&&this._queue.length;){let l=this._queue.shift();this._bufferedBytes-=l[1].length,Reflect.apply(l[0],this,l.slice(1))}}enqueue(l){this._bufferedBytes+=l[1].length,this._queue.push(l)}sendFrame(l,f){l.length===2?(this._socket.cork(),this._socket.write(l[0]),this._socket.write(l[1],f),this._socket.uncork()):this._socket.write(l[0],f)}};aC.exports=jc});var cC=nt(($H,fC)=>{"use strict";var tm=class{constructor(l,f){this.target=f,this.type=l}},JD=class extends tm{constructor(l,f){super("message",f),this.data=l}},ZD=class extends tm{constructor(l,f,h){super("close",h),this.wasClean=h._closeFrameReceived&&h._closeFrameSent,this.reason=f,this.code=l}},$D=class extends tm{constructor(l){super("open",l)}},e3=class extends tm{constructor(l,f){super("error",f),this.message=l.message,this.error=l}},kI={addEventListener(o,l,f){if(typeof l!="function")return;function h(k){l.call(this,new JD(k,this))}function E(k,x){l.call(this,new ZD(k,x,this))}function t(k){l.call(this,new e3(k,this))}function N(){l.call(this,new $D(this))}let F=f&&f.once?"once":"on";o==="message"?(h._listener=l,this[F](o,h)):o==="close"?(E._listener=l,this[F](o,E)):o==="error"?(t._listener=l,this[F](o,t)):o==="open"?(N._listener=l,this[F](o,N)):this[F](o,l)},removeEventListener(o,l){let f=this.listeners(o);for(let h=0;h<f.length;h++)(f[h]===l||f[h]._listener===l)&&this.removeListener(o,f[h])}};fC.exports=kI});var t3=nt((eq,dC)=>{"use strict";var ug=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,0,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,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,0,0,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,0,1,0,1,0];function zc(o,l,f){o[l]===void 0?o[l]=[f]:o[l].push(f)}function NI(o){let l=Object.create(null);if(o===void 0||o==="")return l;let f=Object.create(null),h=!1,E=!1,t=!1,N,F,k=-1,x=-1,j=0;for(;j<o.length;j++){let V=o.charCodeAt(j);if(N===void 0)if(x===-1&&ug[V]===1)k===-1&&(k=j);else if(V===32||V===9)x===-1&&k!==-1&&(x=j);else if(V===59||V===44){if(k===-1)throw new SyntaxError(`Unexpected character at index ${j}`);x===-1&&(x=j);let re=o.slice(k,x);V===44?(zc(l,re,f),f=Object.create(null)):N=re,k=x=-1}else throw new SyntaxError(`Unexpected character at index ${j}`);else if(F===void 0)if(x===-1&&ug[V]===1)k===-1&&(k=j);else if(V===32||V===9)x===-1&&k!==-1&&(x=j);else if(V===59||V===44){if(k===-1)throw new SyntaxError(`Unexpected character at index ${j}`);x===-1&&(x=j),zc(f,o.slice(k,x),!0),V===44&&(zc(l,N,f),f=Object.create(null),N=void 0),k=x=-1}else if(V===61&&k!==-1&&x===-1)F=o.slice(k,j),k=x=-1;else throw new SyntaxError(`Unexpected character at index ${j}`);else if(E){if(ug[V]!==1)throw new SyntaxError(`Unexpected character at index ${j}`);k===-1?k=j:h||(h=!0),E=!1}else if(t)if(ug[V]===1)k===-1&&(k=j);else if(V===34&&k!==-1)t=!1,x=j;else if(V===92)E=!0;else throw new SyntaxError(`Unexpected character at index ${j}`);else if(V===34&&o.charCodeAt(j-1)===61)t=!0;else if(x===-1&&ug[V]===1)k===-1&&(k=j);else if(k!==-1&&(V===32||V===9))x===-1&&(x=j);else if(V===59||V===44){if(k===-1)throw new SyntaxError(`Unexpected character at index ${j}`);x===-1&&(x=j);let re=o.slice(k,x);h&&(re=re.replace(/\\/g,""),h=!1),zc(f,F,re),V===44&&(zc(l,N,f),f=Object.create(null),N=void 0),F=void 0,k=x=-1}else throw new SyntaxError(`Unexpected character at index ${j}`)}if(k===-1||t)throw new SyntaxError("Unexpected end of input");x===-1&&(x=j);let q=o.slice(k,x);return N===void 0?zc(l,q,f):(F===void 0?zc(f,q,!0):h?zc(f,F,q.replace(/\\/g,"")):zc(f,F,q),zc(l,N,f)),l}function LI(o){return Object.keys(o).map(l=>{let f=o[l];return Array.isArray(f)||(f=[f]),f.map(h=>[l].concat(Object.keys(h).map(E=>{let t=h[E];return Array.isArray(t)||(t=[t]),t.map(N=>N===!0?E:`${E}=${N}`).join("; ")})).join("; ")).join(", ")}).join(", ")}dC.exports={format:LI,parse:NI}});var o3=nt((tq,wC)=>{"use strict";var FI=hi("events"),PI=hi("https"),II=hi("http"),vC=hi("net"),bI=hi("tls"),{randomBytes:BI,createHash:UI}=hi("crypto"),{URL:n3}=hi("url"),p2=rg(),jI=XD(),zI=QD(),{BINARY_TYPES:pC,EMPTY_BUFFER:r3,GUID:HI,kStatusCode:qI,kWebSocket:ta,NOOP:mC}=th(),{addEventListener:WI,removeEventListener:VI}=cC(),{format:GI,parse:YI}=t3(),{toBuffer:KI}=eg(),yC=["CONNECTING","OPEN","CLOSING","CLOSED"],i3=[8,13],XI=30*1e3,ji=class extends FI{constructor(l,f,h){super(),this._binaryType=pC[0],this._closeCode=1006,this._closeFrameReceived=!1,this._closeFrameSent=!1,this._closeMessage="",this._closeTimer=null,this._extensions={},this._protocol="",this._readyState=ji.CONNECTING,this._receiver=null,this._sender=null,this._socket=null,l!==null?(this._bufferedAmount=0,this._isServer=!1,this._redirects=0,Array.isArray(f)?f=f.join(", "):typeof f=="object"&&f!==null&&(h=f,f=void 0),gC(this,l,f,h)):this._isServer=!0}get binaryType(){return this._binaryType}set binaryType(l){!pC.includes(l)||(this._binaryType=l,this._receiver&&(this._receiver._binaryType=l))}get bufferedAmount(){return this._socket?this._socket._writableState.length+this._sender._bufferedBytes:this._bufferedAmount}get extensions(){return Object.keys(this._extensions).join()}get protocol(){return this._protocol}get readyState(){return this._readyState}get url(){return this._url}setSocket(l,f,h){let E=new jI(this.binaryType,this._extensions,this._isServer,h);this._sender=new zI(l,this._extensions),this._receiver=E,this._socket=l,E[ta]=this,l[ta]=this,E.on("conclude",ZI),E.on("drain",$I),E.on("error",eb),E.on("message",tb),E.on("ping",nb),E.on("pong",rb),l.setTimeout(0),l.setNoDelay(),f.length>0&&l.unshift(f),l.on("close",_C),l.on("data",$_),l.on("end",EC),l.on("error",DC),this._readyState=ji.OPEN,this.emit("open")}emitClose(){if(!this._socket){this._readyState=ji.CLOSED,this.emit("close",this._closeCode,this._closeMessage);return}this._extensions[p2.extensionName]&&this._extensions[p2.extensionName].cleanup(),this._receiver.removeAllListeners(),this._readyState=ji.CLOSED,this.emit("close",this._closeCode,this._closeMessage)}close(l,f){if(this.readyState!==ji.CLOSED){if(this.readyState===ji.CONNECTING){let h="WebSocket was closed before the connection was established";return J1(this,this._req,h)}if(this.readyState===ji.CLOSING){this._closeFrameSent&&this._closeFrameReceived&&this._socket.end();return}this._readyState=ji.CLOSING,this._sender.close(l,f,!this._isServer,h=>{h||(this._closeFrameSent=!0,this._closeFrameReceived&&this._socket.end())}),this._closeTimer=setTimeout(this._socket.destroy.bind(this._socket),XI)}}ping(l,f,h){if(this.readyState===ji.CONNECTING)throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");if(typeof l=="function"?(h=l,l=f=void 0):typeof f=="function"&&(h=f,f=void 0),typeof l=="number"&&(l=l.toString()),this.readyState!==ji.OPEN){u3(this,l,h);return}f===void 0&&(f=!this._isServer),this._sender.ping(l||r3,f,h)}pong(l,f,h){if(this.readyState===ji.CONNECTING)throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");if(typeof l=="function"?(h=l,l=f=void 0):typeof f=="function"&&(h=f,f=void 0),typeof l=="number"&&(l=l.toString()),this.readyState!==ji.OPEN){u3(this,l,h);return}f===void 0&&(f=!this._isServer),this._sender.pong(l||r3,f,h)}send(l,f,h){if(this.readyState===ji.CONNECTING)throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");if(typeof f=="function"&&(h=f,f={}),typeof l=="number"&&(l=l.toString()),this.readyState!==ji.OPEN){u3(this,l,h);return}let E={binary:typeof l!="string",mask:!this._isServer,compress:!0,fin:!0,...f};this._extensions[p2.extensionName]||(E.compress=!1),this._sender.send(l||r3,E,h)}terminate(){if(this.readyState!==ji.CLOSED){if(this.readyState===ji.CONNECTING){let l="WebSocket was closed before the connection was established";return J1(this,this._req,l)}this._socket&&(this._readyState=ji.CLOSING,this._socket.destroy())}}};yC.forEach((o,l)=>{let f={enumerable:!0,value:l};Object.defineProperty(ji.prototype,o,f),Object.defineProperty(ji,o,f)});["binaryType","bufferedAmount","extensions","protocol","readyState","url"].forEach(o=>{Object.defineProperty(ji.prototype,o,{enumerable:!0})});["open","error","close","message"].forEach(o=>{Object.defineProperty(ji.prototype,`on${o}`,{configurable:!0,enumerable:!0,get(){let l=this.listeners(o);for(let f=0;f<l.length;f++)if(l[f]._listener)return l[f]._listener},set(l){let f=this.listeners(o);for(let h=0;h<f.length;h++)f[h]._listener&&this.removeListener(o,f[h]);this.addEventListener(o,l)}})});ji.prototype.addEventListener=WI;ji.prototype.removeEventListener=VI;wC.exports=ji;function gC(o,l,f,h){let E={protocolVersion:i3[1],maxPayload:104857600,perMessageDeflate:!0,followRedirects:!1,maxRedirects:10,...h,createConnection:void 0,socketPath:void 0,hostname:void 0,protocol:void 0,timeout:void 0,method:void 0,host:void 0,path:void 0,port:void 0};if(!i3.includes(E.protocolVersion))throw new RangeError(`Unsupported protocol version: ${E.protocolVersion} (supported versions: ${i3.join(", ")})`);let t;l instanceof n3?(t=l,o._url=l.href):(t=new n3(l),o._url=l);let N=t.protocol==="ws+unix:";if(!t.host&&(!N||!t.pathname))throw new Error(`Invalid URL: ${o.url}`);let F=t.protocol==="wss:"||t.protocol==="https:",k=F?443:80,x=BI(16).toString("base64"),j=F?PI.get:II.get,q;if(E.createConnection=F?JI:QI,E.defaultPort=E.defaultPort||k,E.port=t.port||k,E.host=t.hostname.startsWith("[")?t.hostname.slice(1,-1):t.hostname,E.headers={"Sec-WebSocket-Version":E.protocolVersion,"Sec-WebSocket-Key":x,Connection:"Upgrade",Upgrade:"websocket",...E.headers},E.path=t.pathname+t.search,E.timeout=E.handshakeTimeout,E.perMessageDeflate&&(q=new p2(E.perMessageDeflate!==!0?E.perMessageDeflate:{},!1,E.maxPayload),E.headers["Sec-WebSocket-Extensions"]=GI({[p2.extensionName]:q.offer()})),f&&(E.headers["Sec-WebSocket-Protocol"]=f),E.origin&&(E.protocolVersion<13?E.headers["Sec-WebSocket-Origin"]=E.origin:E.headers.Origin=E.origin),(t.username||t.password)&&(E.auth=`${t.username}:${t.password}`),N){let re=E.path.split(":");E.socketPath=re[0],E.path=re[1]}let V=o._req=j(E);E.timeout&&V.on("timeout",()=>{J1(o,V,"Opening handshake has timed out")}),V.on("error",re=>{V===null||V.aborted||(V=o._req=null,o._readyState=ji.CLOSING,o.emit("error",re),o.emitClose())}),V.on("response",re=>{let y=re.headers.location,me=re.statusCode;if(y&&E.followRedirects&&me>=300&&me<400){if(++o._redirects>E.maxRedirects){J1(o,V,"Maximum redirects exceeded");return}V.abort();let De=new n3(y,l);gC(o,De,f,h)}else o.emit("unexpected-response",V,re)||J1(o,V,`Unexpected server response: ${re.statusCode}`)}),V.on("upgrade",(re,y,me)=>{if(o.emit("upgrade",re),o.readyState!==ji.CONNECTING)return;V=o._req=null;let De=UI("sha1").update(x+HI).digest("base64");if(re.headers["sec-websocket-accept"]!==De){J1(o,y,"Invalid Sec-WebSocket-Accept header");return}let ge=re.headers["sec-websocket-protocol"],ae=(f||"").split(/, */),we;if(!f&&ge?we="Server sent a subprotocol but none was requested":f&&!ge?we="Server sent no subprotocol":ge&&!ae.includes(ge)&&(we="Server sent an invalid subprotocol"),we){J1(o,y,we);return}if(ge&&(o._protocol=ge),q)try{let he=YI(re.headers["sec-websocket-extensions"]);he[p2.extensionName]&&(q.accept(he[p2.extensionName]),o._extensions[p2.extensionName]=q)}catch{J1(o,y,"Invalid Sec-WebSocket-Extensions header");return}o.setSocket(y,me,E.maxPayload)})}function QI(o){return o.path=o.socketPath,vC.connect(o)}function JI(o){return o.path=void 0,!o.servername&&o.servername!==""&&(o.servername=vC.isIP(o.host)?"":o.host),bI.connect(o)}function J1(o,l,f){o._readyState=ji.CLOSING;let h=new Error(f);Error.captureStackTrace(h,J1),l.setHeader?(l.abort(),l.socket&&!l.socket.destroyed&&l.socket.destroy(),l.once("abort",o.emitClose.bind(o)),o.emit("error",h)):(l.destroy(h),l.once("error",o.emit.bind(o,"error")),l.once("close",o.emitClose.bind(o)))}function u3(o,l,f){if(l){let h=KI(l).length;o._socket?o._sender._bufferedBytes+=h:o._bufferedAmount+=h}if(f){let h=new Error(`WebSocket is not open: readyState ${o.readyState} (${yC[o.readyState]})`);f(h)}}function ZI(o,l){let f=this[ta];f._socket.removeListener("data",$_),f._socket.resume(),f._closeFrameReceived=!0,f._closeMessage=l,f._closeCode=o,o===1005?f.close():f.close(o,l)}function $I(){this[ta]._socket.resume()}function eb(o){let l=this[ta];l._socket.removeListener("data",$_),l._readyState=ji.CLOSING,l._closeCode=o[qI],l.emit("error",o),l._socket.destroy()}function hC(){this[ta].emitClose()}function tb(o){this[ta].emit("message",o)}function nb(o){let l=this[ta];l.pong(o,!l._isServer,mC),l.emit("ping",o)}function rb(o){this[ta].emit("pong",o)}function _C(){let o=this[ta];this.removeListener("close",_C),this.removeListener("end",EC),o._readyState=ji.CLOSING,o._socket.read(),o._receiver.end(),this.removeListener("data",$_),this[ta]=void 0,clearTimeout(o._closeTimer),o._receiver._writableState.finished||o._receiver._writableState.errorEmitted?o.emitClose():(o._receiver.on("error",hC),o._receiver.on("finish",hC))}function $_(o){this[ta]._receiver.write(o)||this.pause()}function EC(){let o=this[ta];o._readyState=ji.CLOSING,o._receiver.end(),this.end()}function DC(){let o=this[ta];this.removeListener("error",DC),this.on("error",mC),o&&(o._readyState=ji.CLOSING,this.destroy())}});var xC=nt((nq,CC)=>{"use strict";var{Duplex:ib}=hi("stream");function SC(o){o.emit("close")}function ub(){!this.destroyed&&this._writableState.finished&&this.destroy()}function TC(o){this.removeListener("error",TC),this.destroy(),this.listenerCount("error")===0&&this.emit("error",o)}function ob(o,l){let f=!0;function h(){f&&o._socket.resume()}o.readyState===o.CONNECTING?o.once("open",function(){o._receiver.removeAllListeners("drain"),o._receiver.on("drain",h)}):(o._receiver.removeAllListeners("drain"),o._receiver.on("drain",h));let E=new ib({...l,autoDestroy:!1,emitClose:!1,objectMode:!1,writableObjectMode:!1});return o.on("message",function(N){E.push(N)||(f=!1,o._socket.pause())}),o.once("error",function(N){E.destroyed||E.destroy(N)}),o.once("close",function(){E.destroyed||E.push(null)}),E._destroy=function(t,N){if(o.readyState===o.CLOSED){N(t),process.nextTick(SC,E);return}let F=!1;o.once("error",function(x){F=!0,N(x)}),o.once("close",function(){F||N(t),process.nextTick(SC,E)}),o.terminate()},E._final=function(t){if(o.readyState===o.CONNECTING){o.once("open",function(){E._final(t)});return}o._socket!==null&&(o._socket._writableState.finished?(t(),E._readableState.endEmitted&&E.destroy()):(o._socket.once("finish",function(){t()}),o.close()))},E._read=function(){o.readyState===o.OPEN&&!f&&(f=!0,o._receiver._writableState.needDrain||o._socket.resume())},E._write=function(t,N,F){if(o.readyState===o.CONNECTING){o.once("open",function(){E._write(t,N,F)});return}o.send(t,F)},E.on("end",ub),E.on("error",TC),E}CC.exports=ob});var AC=nt((rq,RC)=>{"use strict";var lb=hi("events"),{createHash:sb}=hi("crypto"),{createServer:ab,STATUS_CODES:l3}=hi("http"),rh=rg(),fb=o3(),{format:db,parse:pb}=t3(),{GUID:hb,kWebSocket:vb}=th(),mb=/^[+/0-9A-Za-z]{22}==$/,s3=class extends lb{constructor(l,f){if(super(),l={maxPayload:100*1024*1024,perMessageDeflate:!1,handleProtocols:null,clientTracking:!0,verifyClient:null,noServer:!1,backlog:null,server:null,host:null,path:null,port:null,...l},l.port==null&&!l.server&&!l.noServer)throw new TypeError('One of the "port", "server", or "noServer" options must be specified');if(l.port!=null?(this._server=ab((h,E)=>{let t=l3[426];E.writeHead(426,{"Content-Length":t.length,"Content-Type":"text/plain"}),E.end(t)}),this._server.listen(l.port,l.host,l.backlog,f)):l.server&&(this._server=l.server),this._server){let h=this.emit.bind(this,"connection");this._removeListeners=yb(this._server,{listening:this.emit.bind(this,"listening"),error:this.emit.bind(this,"error"),upgrade:(E,t,N)=>{this.handleUpgrade(E,t,N,h)}})}l.perMessageDeflate===!0&&(l.perMessageDeflate={}),l.clientTracking&&(this.clients=new Set),this.options=l}address(){if(this.options.noServer)throw new Error('The server is operating in "noServer" mode');return this._server?this._server.address():null}close(l){if(l&&this.once("close",l),this.clients)for(let h of this.clients)h.terminate();let f=this._server;if(f&&(this._removeListeners(),this._removeListeners=this._server=null,this.options.port!=null)){f.close(()=>this.emit("close"));return}process.nextTick(gb,this)}shouldHandle(l){if(this.options.path){let f=l.url.indexOf("?");if((f!==-1?l.url.slice(0,f):l.url)!==this.options.path)return!1}return!0}handleUpgrade(l,f,h,E){f.on("error",a3);let t=l.headers["sec-websocket-key"]!==void 0?l.headers["sec-websocket-key"].trim():!1,N=+l.headers["sec-websocket-version"],F={};if(l.method!=="GET"||l.headers.upgrade.toLowerCase()!=="websocket"||!t||!mb.test(t)||N!==8&&N!==13||!this.shouldHandle(l))return e4(f,400);if(this.options.perMessageDeflate){let k=new rh(this.options.perMessageDeflate,!0,this.options.maxPayload);try{let x=pb(l.headers["sec-websocket-extensions"]);x[rh.extensionName]&&(k.accept(x[rh.extensionName]),F[rh.extensionName]=k)}catch{return e4(f,400)}}if(this.options.verifyClient){let k={origin:l.headers[`${N===8?"sec-websocket-origin":"origin"}`],secure:!!(l.socket.authorized||l.socket.encrypted),req:l};if(this.options.verifyClient.length===2){this.options.verifyClient(k,(x,j,q,V)=>{if(!x)return e4(f,j||401,q,V);this.completeUpgrade(t,F,l,f,h,E)});return}if(!this.options.verifyClient(k))return e4(f,401)}this.completeUpgrade(t,F,l,f,h,E)}completeUpgrade(l,f,h,E,t,N){if(!E.readable||!E.writable)return E.destroy();if(E[vb])throw new Error("server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration");let k=["HTTP/1.1 101 Switching Protocols","Upgrade: websocket","Connection: Upgrade",`Sec-WebSocket-Accept: ${sb("sha1").update(l+hb).digest("base64")}`],x=new fb(null),j=h.headers["sec-websocket-protocol"];if(j&&(j=j.split(",").map(_b),this.options.handleProtocols?j=this.options.handleProtocols(j,h):j=j[0],j&&(k.push(`Sec-WebSocket-Protocol: ${j}`),x._protocol=j)),f[rh.extensionName]){let q=f[rh.extensionName].params,V=db({[rh.extensionName]:[q]});k.push(`Sec-WebSocket-Extensions: ${V}`),x._extensions=f}this.emit("headers",k,h),E.write(k.concat(`\r
+`).join(`\r
+`)),E.removeListener("error",a3),x.setSocket(E,t,this.options.maxPayload),this.clients&&(this.clients.add(x),x.on("close",()=>this.clients.delete(x))),N(x,h)}};RC.exports=s3;function yb(o,l){for(let f of Object.keys(l))o.on(f,l[f]);return function(){for(let h of Object.keys(l))o.removeListener(h,l[h])}}function gb(o){o.emit("close")}function a3(){this.destroy()}function e4(o,l,f,h){o.writable&&(f=f||l3[l],h={Connection:"close","Content-Type":"text/html","Content-Length":Buffer.byteLength(f),...h},o.write(`HTTP/1.1 ${l} ${l3[l]}\r
+`+Object.keys(h).map(E=>`${E}: ${h[E]}`).join(`\r
+`)+`\r
+\r
+`+f)),o.removeListener("error",a3),o.destroy()}function _b(o){return o.trim()}});var MC=nt((iq,OC)=>{"use strict";var og=o3();og.createWebSocketStream=xC();og.Server=AC();og.Receiver=XD();og.Sender=QD();OC.exports=og});var kC=nt(t4=>{"use strict";var Eb=t4&&t4.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(t4,"__esModule",{value:!0});var Db=Eb(MC()),lg=global;lg.WebSocket||(lg.WebSocket=Db.default);lg.window||(lg.window=global);lg.window.__REACT_DEVTOOLS_COMPONENT_FILTERS__=[{type:1,value:7,isEnabled:!0},{type:2,value:"InternalApp",isEnabled:!0,isValid:!0},{type:2,value:"InternalAppContext",isEnabled:!0,isValid:!0},{type:2,value:"InternalStdoutContext",isEnabled:!0,isValid:!0},{type:2,value:"InternalStderrContext",isEnabled:!0,isValid:!0},{type:2,value:"InternalStdinContext",isEnabled:!0,isValid:!0},{type:2,value:"InternalFocusContext",isEnabled:!0,isValid:!0}]});var NC=nt((n4,f3)=>{(function(o,l){typeof n4=="object"&&typeof f3=="object"?f3.exports=l():typeof define=="function"&&define.amd?define([],l):typeof n4=="object"?n4.ReactDevToolsBackend=l():o.ReactDevToolsBackend=l()})(window,function(){return function(o){var l={};function f(h){if(l[h])return l[h].exports;var E=l[h]={i:h,l:!1,exports:{}};return o[h].call(E.exports,E,E.exports,f),E.l=!0,E.exports}return f.m=o,f.c=l,f.d=function(h,E,t){f.o(h,E)||Object.defineProperty(h,E,{enumerable:!0,get:t})},f.r=function(h){typeof Symbol<"u"&&Symbol.toStringTag&&Object.defineProperty(h,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(h,"__esModule",{value:!0})},f.t=function(h,E){if(1&E&&(h=f(h)),8&E||4&E&&typeof h=="object"&&h&&h.__esModule)return h;var t=Object.create(null);if(f.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:h}),2&E&&typeof h!="string")for(var N in h)f.d(t,N,function(F){return h[F]}.bind(null,N));return t},f.n=function(h){var E=h&&h.__esModule?function(){return h.default}:function(){return h};return f.d(E,"a",E),E},f.o=function(h,E){return Object.prototype.hasOwnProperty.call(h,E)},f.p="",f(f.s=20)}([function(o,l,f){"use strict";o.exports=f(12)},function(o,l,f){"use strict";var h=Object.getOwnPropertySymbols,E=Object.prototype.hasOwnProperty,t=Object.prototype.propertyIsEnumerable;function N(F){if(F==null)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(F)}o.exports=function(){try{if(!Object.assign)return!1;var F=new String("abc");if(F[5]="de",Object.getOwnPropertyNames(F)[0]==="5")return!1;for(var k={},x=0;x<10;x++)k["_"+String.fromCharCode(x)]=x;if(Object.getOwnPropertyNames(k).map(function(q){return k[q]}).join("")!=="0123456789")return!1;var j={};return"abcdefghijklmnopqrst".split("").forEach(function(q){j[q]=q}),Object.keys(Object.assign({},j)).join("")==="abcdefghijklmnopqrst"}catch{return!1}}()?Object.assign:function(F,k){for(var x,j,q=N(F),V=1;V<arguments.length;V++){for(var re in x=Object(arguments[V]))E.call(x,re)&&(q[re]=x[re]);if(h){j=h(x);for(var y=0;y<j.length;y++)t.call(x,j[y])&&(q[j[y]]=x[j[y]])}}return q}},function(o,l,f){(function(h){function E(ve){return(E=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(ue){return typeof ue}:function(ue){return ue&&typeof Symbol=="function"&&ue.constructor===Symbol&&ue!==Symbol.prototype?"symbol":typeof ue})(ve)}var t=/^\s+|\s+$/g,N=/^[-+]0x[0-9a-f]+$/i,F=/^0b[01]+$/i,k=/^0o[0-7]+$/i,x=parseInt,j=(h===void 0?"undefined":E(h))=="object"&&h&&h.Object===Object&&h,q=(typeof self>"u"?"undefined":E(self))=="object"&&self&&self.Object===Object&&self,V=j||q||Function("return this")(),re=Object.prototype.toString,y=Math.max,me=Math.min,De=function(){return V.Date.now()};function ge(ve,ue,Ae){var ze,We,gt,_t,Qe,ot,Ve=0,Pt=!1,Jt=!1,it=!0;if(typeof ve!="function")throw new TypeError("Expected a function");function J(At){var nn=ze,an=We;return ze=We=void 0,Ve=At,_t=ve.apply(an,nn)}function ce(At){return Ve=At,Qe=setTimeout(le,ue),Pt?J(At):_t}function Re(At){var nn=At-ot;return ot===void 0||nn>=ue||nn<0||Jt&&At-Ve>=gt}function le(){var At=De();if(Re(At))return He(At);Qe=setTimeout(le,function(nn){var an=ue-(nn-ot);return Jt?me(an,gt-(nn-Ve)):an}(At))}function He(At){return Qe=void 0,it&&ze?J(At):(ze=We=void 0,_t)}function dt(){var At=De(),nn=Re(At);if(ze=arguments,We=this,ot=At,nn){if(Qe===void 0)return ce(ot);if(Jt)return Qe=setTimeout(le,ue),J(ot)}return Qe===void 0&&(Qe=setTimeout(le,ue)),_t}return ue=he(ue)||0,ae(Ae)&&(Pt=!!Ae.leading,gt=(Jt="maxWait"in Ae)?y(he(Ae.maxWait)||0,ue):gt,it="trailing"in Ae?!!Ae.trailing:it),dt.cancel=function(){Qe!==void 0&&clearTimeout(Qe),Ve=0,ze=ot=We=Qe=void 0},dt.flush=function(){return Qe===void 0?_t:He(De())},dt}function ae(ve){var ue=E(ve);return!!ve&&(ue=="object"||ue=="function")}function we(ve){return E(ve)=="symbol"||function(ue){return!!ue&&E(ue)=="object"}(ve)&&re.call(ve)=="[object Symbol]"}function he(ve){if(typeof ve=="number")return ve;if(we(ve))return NaN;if(ae(ve)){var ue=typeof ve.valueOf=="function"?ve.valueOf():ve;ve=ae(ue)?ue+"":ue}if(typeof ve!="string")return ve===0?ve:+ve;ve=ve.replace(t,"");var Ae=F.test(ve);return Ae||k.test(ve)?x(ve.slice(2),Ae?2:8):N.test(ve)?NaN:+ve}o.exports=function(ve,ue,Ae){var ze=!0,We=!0;if(typeof ve!="function")throw new TypeError("Expected a function");return ae(Ae)&&(ze="leading"in Ae?!!Ae.leading:ze,We="trailing"in Ae?!!Ae.trailing:We),ge(ve,ue,{leading:ze,maxWait:ue,trailing:We})}}).call(this,f(4))},function(o,l,f){(function(h){function E(J){return(E=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(ce){return typeof ce}:function(ce){return ce&&typeof Symbol=="function"&&ce.constructor===Symbol&&ce!==Symbol.prototype?"symbol":typeof ce})(J)}var t;l=o.exports=y,t=(h===void 0?"undefined":E(h))==="object"&&h.env&&h.env.NODE_DEBUG&&/\bsemver\b/i.test(h.env.NODE_DEBUG)?function(){var J=Array.prototype.slice.call(arguments,0);J.unshift("SEMVER"),console.log.apply(console,J)}:function(){},l.SEMVER_SPEC_VERSION="2.0.0";var N=Number.MAX_SAFE_INTEGER||9007199254740991,F=l.re=[],k=l.src=[],x=l.tokens={},j=0;function q(J){x[J]=j++}q("NUMERICIDENTIFIER"),k[x.NUMERICIDENTIFIER]="0|[1-9]\\d*",q("NUMERICIDENTIFIERLOOSE"),k[x.NUMERICIDENTIFIERLOOSE]="[0-9]+",q("NONNUMERICIDENTIFIER"),k[x.NONNUMERICIDENTIFIER]="\\d*[a-zA-Z-][a-zA-Z0-9-]*",q("MAINVERSION"),k[x.MAINVERSION]="("+k[x.NUMERICIDENTIFIER]+")\\.("+k[x.NUMERICIDENTIFIER]+")\\.("+k[x.NUMERICIDENTIFIER]+")",q("MAINVERSIONLOOSE"),k[x.MAINVERSIONLOOSE]="("+k[x.NUMERICIDENTIFIERLOOSE]+")\\.("+k[x.NUMERICIDENTIFIERLOOSE]+")\\.("+k[x.NUMERICIDENTIFIERLOOSE]+")",q("PRERELEASEIDENTIFIER"),k[x.PRERELEASEIDENTIFIER]="(?:"+k[x.NUMERICIDENTIFIER]+"|"+k[x.NONNUMERICIDENTIFIER]+")",q("PRERELEASEIDENTIFIERLOOSE"),k[x.PRERELEASEIDENTIFIERLOOSE]="(?:"+k[x.NUMERICIDENTIFIERLOOSE]+"|"+k[x.NONNUMERICIDENTIFIER]+")",q("PRERELEASE"),k[x.PRERELEASE]="(?:-("+k[x.PRERELEASEIDENTIFIER]+"(?:\\."+k[x.PRERELEASEIDENTIFIER]+")*))",q("PRERELEASELOOSE"),k[x.PRERELEASELOOSE]="(?:-?("+k[x.PRERELEASEIDENTIFIERLOOSE]+"(?:\\."+k[x.PRERELEASEIDENTIFIERLOOSE]+")*))",q("BUILDIDENTIFIER"),k[x.BUILDIDENTIFIER]="[0-9A-Za-z-]+",q("BUILD"),k[x.BUILD]="(?:\\+("+k[x.BUILDIDENTIFIER]+"(?:\\."+k[x.BUILDIDENTIFIER]+")*))",q("FULL"),q("FULLPLAIN"),k[x.FULLPLAIN]="v?"+k[x.MAINVERSION]+k[x.PRERELEASE]+"?"+k[x.BUILD]+"?",k[x.FULL]="^"+k[x.FULLPLAIN]+"$",q("LOOSEPLAIN"),k[x.LOOSEPLAIN]="[v=\\s]*"+k[x.MAINVERSIONLOOSE]+k[x.PRERELEASELOOSE]+"?"+k[x.BUILD]+"?",q("LOOSE"),k[x.LOOSE]="^"+k[x.LOOSEPLAIN]+"$",q("GTLT"),k[x.GTLT]="((?:<|>)?=?)",q("XRANGEIDENTIFIERLOOSE"),k[x.XRANGEIDENTIFIERLOOSE]=k[x.NUMERICIDENTIFIERLOOSE]+"|x|X|\\*",q("XRANGEIDENTIFIER"),k[x.XRANGEIDENTIFIER]=k[x.NUMERICIDENTIFIER]+"|x|X|\\*",q("XRANGEPLAIN"),k[x.XRANGEPLAIN]="[v=\\s]*("+k[x.XRANGEIDENTIFIER]+")(?:\\.("+k[x.XRANGEIDENTIFIER]+")(?:\\.("+k[x.XRANGEIDENTIFIER]+")(?:"+k[x.PRERELEASE]+")?"+k[x.BUILD]+"?)?)?",q("XRANGEPLAINLOOSE"),k[x.XRANGEPLAINLOOSE]="[v=\\s]*("+k[x.XRANGEIDENTIFIERLOOSE]+")(?:\\.("+k[x.XRANGEIDENTIFIERLOOSE]+")(?:\\.("+k[x.XRANGEIDENTIFIERLOOSE]+")(?:"+k[x.PRERELEASELOOSE]+")?"+k[x.BUILD]+"?)?)?",q("XRANGE"),k[x.XRANGE]="^"+k[x.GTLT]+"\\s*"+k[x.XRANGEPLAIN]+"$",q("XRANGELOOSE"),k[x.XRANGELOOSE]="^"+k[x.GTLT]+"\\s*"+k[x.XRANGEPLAINLOOSE]+"$",q("COERCE"),k[x.COERCE]="(^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])",q("COERCERTL"),F[x.COERCERTL]=new RegExp(k[x.COERCE],"g"),q("LONETILDE"),k[x.LONETILDE]="(?:~>?)",q("TILDETRIM"),k[x.TILDETRIM]="(\\s*)"+k[x.LONETILDE]+"\\s+",F[x.TILDETRIM]=new RegExp(k[x.TILDETRIM],"g"),q("TILDE"),k[x.TILDE]="^"+k[x.LONETILDE]+k[x.XRANGEPLAIN]+"$",q("TILDELOOSE"),k[x.TILDELOOSE]="^"+k[x.LONETILDE]+k[x.XRANGEPLAINLOOSE]+"$",q("LONECARET"),k[x.LONECARET]="(?:\\^)",q("CARETTRIM"),k[x.CARETTRIM]="(\\s*)"+k[x.LONECARET]+"\\s+",F[x.CARETTRIM]=new RegExp(k[x.CARETTRIM],"g"),q("CARET"),k[x.CARET]="^"+k[x.LONECARET]+k[x.XRANGEPLAIN]+"$",q("CARETLOOSE"),k[x.CARETLOOSE]="^"+k[x.LONECARET]+k[x.XRANGEPLAINLOOSE]+"$",q("COMPARATORLOOSE"),k[x.COMPARATORLOOSE]="^"+k[x.GTLT]+"\\s*("+k[x.LOOSEPLAIN]+")$|^$",q("COMPARATOR"),k[x.COMPARATOR]="^"+k[x.GTLT]+"\\s*("+k[x.FULLPLAIN]+")$|^$",q("COMPARATORTRIM"),k[x.COMPARATORTRIM]="(\\s*)"+k[x.GTLT]+"\\s*("+k[x.LOOSEPLAIN]+"|"+k[x.XRANGEPLAIN]+")",F[x.COMPARATORTRIM]=new RegExp(k[x.COMPARATORTRIM],"g"),q("HYPHENRANGE"),k[x.HYPHENRANGE]="^\\s*("+k[x.XRANGEPLAIN]+")\\s+-\\s+("+k[x.XRANGEPLAIN]+")\\s*$",q("HYPHENRANGELOOSE"),k[x.HYPHENRANGELOOSE]="^\\s*("+k[x.XRANGEPLAINLOOSE]+")\\s+-\\s+("+k[x.XRANGEPLAINLOOSE]+")\\s*$",q("STAR"),k[x.STAR]="(<|>)?=?\\s*\\*";for(var V=0;V<j;V++)t(V,k[V]),F[V]||(F[V]=new RegExp(k[V]));function re(J,ce){if(ce&&E(ce)==="object"||(ce={loose:!!ce,includePrerelease:!1}),J instanceof y)return J;if(typeof J!="string"||J.length>256||!(ce.loose?F[x.LOOSE]:F[x.FULL]).test(J))return null;try{return new y(J,ce)}catch{return null}}function y(J,ce){if(ce&&E(ce)==="object"||(ce={loose:!!ce,includePrerelease:!1}),J instanceof y){if(J.loose===ce.loose)return J;J=J.version}else if(typeof J!="string")throw new TypeError("Invalid Version: "+J);if(J.length>256)throw new TypeError("version is longer than 256 characters");if(!(this instanceof y))return new y(J,ce);t("SemVer",J,ce),this.options=ce,this.loose=!!ce.loose;var Re=J.trim().match(ce.loose?F[x.LOOSE]:F[x.FULL]);if(!Re)throw new TypeError("Invalid Version: "+J);if(this.raw=J,this.major=+Re[1],this.minor=+Re[2],this.patch=+Re[3],this.major>N||this.major<0)throw new TypeError("Invalid major version");if(this.minor>N||this.minor<0)throw new TypeError("Invalid minor version");if(this.patch>N||this.patch<0)throw new TypeError("Invalid patch version");Re[4]?this.prerelease=Re[4].split(".").map(function(le){if(/^[0-9]+$/.test(le)){var He=+le;if(He>=0&&He<N)return He}return le}):this.prerelease=[],this.build=Re[5]?Re[5].split("."):[],this.format()}l.parse=re,l.valid=function(J,ce){var Re=re(J,ce);return Re?Re.version:null},l.clean=function(J,ce){var Re=re(J.trim().replace(/^[=v]+/,""),ce);return Re?Re.version:null},l.SemVer=y,y.prototype.format=function(){return this.version=this.major+"."+this.minor+"."+this.patch,this.prerelease.length&&(this.version+="-"+this.prerelease.join(".")),this.version},y.prototype.toString=function(){return this.version},y.prototype.compare=function(J){return t("SemVer.compare",this.version,this.options,J),J instanceof y||(J=new y(J,this.options)),this.compareMain(J)||this.comparePre(J)},y.prototype.compareMain=function(J){return J instanceof y||(J=new y(J,this.options)),De(this.major,J.major)||De(this.minor,J.minor)||De(this.patch,J.patch)},y.prototype.comparePre=function(J){if(J instanceof y||(J=new y(J,this.options)),this.prerelease.length&&!J.prerelease.length)return-1;if(!this.prerelease.length&&J.prerelease.length)return 1;if(!this.prerelease.length&&!J.prerelease.length)return 0;var ce=0;do{var Re=this.prerelease[ce],le=J.prerelease[ce];if(t("prerelease compare",ce,Re,le),Re===void 0&&le===void 0)return 0;if(le===void 0)return 1;if(Re===void 0)return-1;if(Re!==le)return De(Re,le)}while(++ce)},y.prototype.compareBuild=function(J){J instanceof y||(J=new y(J,this.options));var ce=0;do{var Re=this.build[ce],le=J.build[ce];if(t("prerelease compare",ce,Re,le),Re===void 0&&le===void 0)return 0;if(le===void 0)return 1;if(Re===void 0)return-1;if(Re!==le)return De(Re,le)}while(++ce)},y.prototype.inc=function(J,ce){switch(J){case"premajor":this.prerelease.length=0,this.patch=0,this.minor=0,this.major++,this.inc("pre",ce);break;case"preminor":this.prerelease.length=0,this.patch=0,this.minor++,this.inc("pre",ce);break;case"prepatch":this.prerelease.length=0,this.inc("patch",ce),this.inc("pre",ce);break;case"prerelease":this.prerelease.length===0&&this.inc("patch",ce),this.inc("pre",ce);break;case"major":this.minor===0&&this.patch===0&&this.prerelease.length!==0||this.major++,this.minor=0,this.patch=0,this.prerelease=[];break;case"minor":this.patch===0&&this.prerelease.length!==0||this.minor++,this.patch=0,this.prerelease=[];break;case"patch":this.prerelease.length===0&&this.patch++,this.prerelease=[];break;case"pre":if(this.prerelease.length===0)this.prerelease=[0];else{for(var Re=this.prerelease.length;--Re>=0;)typeof this.prerelease[Re]=="number"&&(this.prerelease[Re]++,Re=-2);Re===-1&&this.prerelease.push(0)}ce&&(this.prerelease[0]===ce?isNaN(this.prerelease[1])&&(this.prerelease=[ce,0]):this.prerelease=[ce,0]);break;default:throw new Error("invalid increment argument: "+J)}return this.format(),this.raw=this.version,this},l.inc=function(J,ce,Re,le){typeof Re=="string"&&(le=Re,Re=void 0);try{return new y(J,Re).inc(ce,le).version}catch{return null}},l.diff=function(J,ce){if(he(J,ce))return null;var Re=re(J),le=re(ce),He="";if(Re.prerelease.length||le.prerelease.length){He="pre";var dt="prerelease"}for(var At in Re)if((At==="major"||At==="minor"||At==="patch")&&Re[At]!==le[At])return He+At;return dt},l.compareIdentifiers=De;var me=/^[0-9]+$/;function De(J,ce){var Re=me.test(J),le=me.test(ce);return Re&&le&&(J=+J,ce=+ce),J===ce?0:Re&&!le?-1:le&&!Re?1:J<ce?-1:1}function ge(J,ce,Re){return new y(J,Re).compare(new y(ce,Re))}function ae(J,ce,Re){return ge(J,ce,Re)>0}function we(J,ce,Re){return ge(J,ce,Re)<0}function he(J,ce,Re){return ge(J,ce,Re)===0}function ve(J,ce,Re){return ge(J,ce,Re)!==0}function ue(J,ce,Re){return ge(J,ce,Re)>=0}function Ae(J,ce,Re){return ge(J,ce,Re)<=0}function ze(J,ce,Re,le){switch(ce){case"===":return E(J)==="object"&&(J=J.version),E(Re)==="object"&&(Re=Re.version),J===Re;case"!==":return E(J)==="object"&&(J=J.version),E(Re)==="object"&&(Re=Re.version),J!==Re;case"":case"=":case"==":return he(J,Re,le);case"!=":return ve(J,Re,le);case">":return ae(J,Re,le);case">=":return ue(J,Re,le);case"<":return we(J,Re,le);case"<=":return Ae(J,Re,le);default:throw new TypeError("Invalid operator: "+ce)}}function We(J,ce){if(ce&&E(ce)==="object"||(ce={loose:!!ce,includePrerelease:!1}),J instanceof We){if(J.loose===!!ce.loose)return J;J=J.value}if(!(this instanceof We))return new We(J,ce);t("comparator",J,ce),this.options=ce,this.loose=!!ce.loose,this.parse(J),this.semver===gt?this.value="":this.value=this.operator+this.semver.version,t("comp",this)}l.rcompareIdentifiers=function(J,ce){return De(ce,J)},l.major=function(J,ce){return new y(J,ce).major},l.minor=function(J,ce){return new y(J,ce).minor},l.patch=function(J,ce){return new y(J,ce).patch},l.compare=ge,l.compareLoose=function(J,ce){return ge(J,ce,!0)},l.compareBuild=function(J,ce,Re){var le=new y(J,Re),He=new y(ce,Re);return le.compare(He)||le.compareBuild(He)},l.rcompare=function(J,ce,Re){return ge(ce,J,Re)},l.sort=function(J,ce){return J.sort(function(Re,le){return l.compareBuild(Re,le,ce)})},l.rsort=function(J,ce){return J.sort(function(Re,le){return l.compareBuild(le,Re,ce)})},l.gt=ae,l.lt=we,l.eq=he,l.neq=ve,l.gte=ue,l.lte=Ae,l.cmp=ze,l.Comparator=We;var gt={};function _t(J,ce){if(ce&&E(ce)==="object"||(ce={loose:!!ce,includePrerelease:!1}),J instanceof _t)return J.loose===!!ce.loose&&J.includePrerelease===!!ce.includePrerelease?J:new _t(J.raw,ce);if(J instanceof We)return new _t(J.value,ce);if(!(this instanceof _t))return new _t(J,ce);if(this.options=ce,this.loose=!!ce.loose,this.includePrerelease=!!ce.includePrerelease,this.raw=J,this.set=J.split(/\s*\|\|\s*/).map(function(Re){return this.parseRange(Re.trim())},this).filter(function(Re){return Re.length}),!this.set.length)throw new TypeError("Invalid SemVer Range: "+J);this.format()}function Qe(J,ce){for(var Re=!0,le=J.slice(),He=le.pop();Re&&le.length;)Re=le.every(function(dt){return He.intersects(dt,ce)}),He=le.pop();return Re}function ot(J){return!J||J.toLowerCase()==="x"||J==="*"}function Ve(J,ce,Re,le,He,dt,At,nn,an,On,lr,ln,Vt){return((ce=ot(Re)?"":ot(le)?">="+Re+".0.0":ot(He)?">="+Re+"."+le+".0":">="+ce)+" "+(nn=ot(an)?"":ot(On)?"<"+(+an+1)+".0.0":ot(lr)?"<"+an+"."+(+On+1)+".0":ln?"<="+an+"."+On+"."+lr+"-"+ln:"<="+nn)).trim()}function Pt(J,ce,Re){for(var le=0;le<J.length;le++)if(!J[le].test(ce))return!1;if(ce.prerelease.length&&!Re.includePrerelease){for(le=0;le<J.length;le++)if(t(J[le].semver),J[le].semver!==gt&&J[le].semver.prerelease.length>0){var He=J[le].semver;if(He.major===ce.major&&He.minor===ce.minor&&He.patch===ce.patch)return!0}return!1}return!0}function Jt(J,ce,Re){try{ce=new _t(ce,Re)}catch{return!1}return ce.test(J)}function it(J,ce,Re,le){var He,dt,At,nn,an;switch(J=new y(J,le),ce=new _t(ce,le),Re){case">":He=ae,dt=Ae,At=we,nn=">",an=">=";break;case"<":He=we,dt=ue,At=ae,nn="<",an="<=";break;default:throw new TypeError('Must provide a hilo val of "<" or ">"')}if(Jt(J,ce,le))return!1;for(var On=0;On<ce.set.length;++On){var lr=ce.set[On],ln=null,Vt=null;if(lr.forEach(function(Er){Er.semver===gt&&(Er=new We(">=0.0.0")),ln=ln||Er,Vt=Vt||Er,He(Er.semver,ln.semver,le)?ln=Er:At(Er.semver,Vt.semver,le)&&(Vt=Er)}),ln.operator===nn||ln.operator===an||(!Vt.operator||Vt.operator===nn)&&dt(J,Vt.semver)||Vt.operator===an&&At(J,Vt.semver))return!1}return!0}We.prototype.parse=function(J){var ce=this.options.loose?F[x.COMPARATORLOOSE]:F[x.COMPARATOR],Re=J.match(ce);if(!Re)throw new TypeError("Invalid comparator: "+J);this.operator=Re[1]!==void 0?Re[1]:"",this.operator==="="&&(this.operator=""),Re[2]?this.semver=new y(Re[2],this.options.loose):this.semver=gt},We.prototype.toString=function(){return this.value},We.prototype.test=function(J){if(t("Comparator.test",J,this.options.loose),this.semver===gt||J===gt)return!0;if(typeof J=="string")try{J=new y(J,this.options)}catch{return!1}return ze(J,this.operator,this.semver,this.options)},We.prototype.intersects=function(J,ce){if(!(J instanceof We))throw new TypeError("a Comparator is required");var Re;if(ce&&E(ce)==="object"||(ce={loose:!!ce,includePrerelease:!1}),this.operator==="")return this.value===""||(Re=new _t(J.value,ce),Jt(this.value,Re,ce));if(J.operator==="")return J.value===""||(Re=new _t(this.value,ce),Jt(J.semver,Re,ce));var le=!(this.operator!==">="&&this.operator!==">"||J.operator!==">="&&J.operator!==">"),He=!(this.operator!=="<="&&this.operator!=="<"||J.operator!=="<="&&J.operator!=="<"),dt=this.semver.version===J.semver.version,At=!(this.operator!==">="&&this.operator!=="<="||J.operator!==">="&&J.operator!=="<="),nn=ze(this.semver,"<",J.semver,ce)&&(this.operator===">="||this.operator===">")&&(J.operator==="<="||J.operator==="<"),an=ze(this.semver,">",J.semver,ce)&&(this.operator==="<="||this.operator==="<")&&(J.operator===">="||J.operator===">");return le||He||dt&&At||nn||an},l.Range=_t,_t.prototype.format=function(){return this.range=this.set.map(function(J){return J.join(" ").trim()}).join("||").trim(),this.range},_t.prototype.toString=function(){return this.range},_t.prototype.parseRange=function(J){var ce=this.options.loose;J=J.trim();var Re=ce?F[x.HYPHENRANGELOOSE]:F[x.HYPHENRANGE];J=J.replace(Re,Ve),t("hyphen replace",J),J=J.replace(F[x.COMPARATORTRIM],"$1$2$3"),t("comparator trim",J,F[x.COMPARATORTRIM]),J=(J=(J=J.replace(F[x.TILDETRIM],"$1~")).replace(F[x.CARETTRIM],"$1^")).split(/\s+/).join(" ");var le=ce?F[x.COMPARATORLOOSE]:F[x.COMPARATOR],He=J.split(" ").map(function(dt){return function(At,nn){return t("comp",At,nn),At=function(an,On){return an.trim().split(/\s+/).map(function(lr){return function(ln,Vt){t("caret",ln,Vt);var Er=Vt.loose?F[x.CARETLOOSE]:F[x.CARET];return ln.replace(Er,function(S,zt,Xn,vr,jr){var fr;return t("caret",ln,S,zt,Xn,vr,jr),ot(zt)?fr="":ot(Xn)?fr=">="+zt+".0.0 <"+(+zt+1)+".0.0":ot(vr)?fr=zt==="0"?">="+zt+"."+Xn+".0 <"+zt+"."+(+Xn+1)+".0":">="+zt+"."+Xn+".0 <"+(+zt+1)+".0.0":jr?(t("replaceCaret pr",jr),fr=zt==="0"?Xn==="0"?">="+zt+"."+Xn+"."+vr+"-"+jr+" <"+zt+"."+Xn+"."+(+vr+1):">="+zt+"."+Xn+"."+vr+"-"+jr+" <"+zt+"."+(+Xn+1)+".0":">="+zt+"."+Xn+"."+vr+"-"+jr+" <"+(+zt+1)+".0.0"):(t("no pr"),fr=zt==="0"?Xn==="0"?">="+zt+"."+Xn+"."+vr+" <"+zt+"."+Xn+"."+(+vr+1):">="+zt+"."+Xn+"."+vr+" <"+zt+"."+(+Xn+1)+".0":">="+zt+"."+Xn+"."+vr+" <"+(+zt+1)+".0.0"),t("caret return",fr),fr})}(lr,On)}).join(" ")}(At,nn),t("caret",At),At=function(an,On){return an.trim().split(/\s+/).map(function(lr){return function(ln,Vt){var Er=Vt.loose?F[x.TILDELOOSE]:F[x.TILDE];return ln.replace(Er,function(S,zt,Xn,vr,jr){var fr;return t("tilde",ln,S,zt,Xn,vr,jr),ot(zt)?fr="":ot(Xn)?fr=">="+zt+".0.0 <"+(+zt+1)+".0.0":ot(vr)?fr=">="+zt+"."+Xn+".0 <"+zt+"."+(+Xn+1)+".0":jr?(t("replaceTilde pr",jr),fr=">="+zt+"."+Xn+"."+vr+"-"+jr+" <"+zt+"."+(+Xn+1)+".0"):fr=">="+zt+"."+Xn+"."+vr+" <"+zt+"."+(+Xn+1)+".0",t("tilde return",fr),fr})}(lr,On)}).join(" ")}(At,nn),t("tildes",At),At=function(an,On){return t("replaceXRanges",an,On),an.split(/\s+/).map(function(lr){return function(ln,Vt){ln=ln.trim();var Er=Vt.loose?F[x.XRANGELOOSE]:F[x.XRANGE];return ln.replace(Er,function(S,zt,Xn,vr,jr,fr){t("xRange",ln,S,zt,Xn,vr,jr,fr);var zr=ot(Xn),Xt=zr||ot(vr),Du=Xt||ot(jr),c0=Du;return zt==="="&&c0&&(zt=""),fr=Vt.includePrerelease?"-0":"",zr?S=zt===">"||zt==="<"?"<0.0.0-0":"*":zt&&c0?(Xt&&(vr=0),jr=0,zt===">"?(zt=">=",Xt?(Xn=+Xn+1,vr=0,jr=0):(vr=+vr+1,jr=0)):zt==="<="&&(zt="<",Xt?Xn=+Xn+1:vr=+vr+1),S=zt+Xn+"."+vr+"."+jr+fr):Xt?S=">="+Xn+".0.0"+fr+" <"+(+Xn+1)+".0.0"+fr:Du&&(S=">="+Xn+"."+vr+".0"+fr+" <"+Xn+"."+(+vr+1)+".0"+fr),t("xRange return",S),S})}(lr,On)}).join(" ")}(At,nn),t("xrange",At),At=function(an,On){return t("replaceStars",an,On),an.trim().replace(F[x.STAR],"")}(At,nn),t("stars",At),At}(dt,this.options)},this).join(" ").split(/\s+/);return this.options.loose&&(He=He.filter(function(dt){return!!dt.match(le)})),He=He.map(function(dt){return new We(dt,this.options)},this)},_t.prototype.intersects=function(J,ce){if(!(J instanceof _t))throw new TypeError("a Range is required");return this.set.some(function(Re){return Qe(Re,ce)&&J.set.some(function(le){return Qe(le,ce)&&Re.every(function(He){return le.every(function(dt){return He.intersects(dt,ce)})})})})},l.toComparators=function(J,ce){return new _t(J,ce).set.map(function(Re){return Re.map(function(le){return le.value}).join(" ").trim().split(" ")})},_t.prototype.test=function(J){if(!J)return!1;if(typeof J=="string")try{J=new y(J,this.options)}catch{return!1}for(var ce=0;ce<this.set.length;ce++)if(Pt(this.set[ce],J,this.options))return!0;return!1},l.satisfies=Jt,l.maxSatisfying=function(J,ce,Re){var le=null,He=null;try{var dt=new _t(ce,Re)}catch{return null}return J.forEach(function(At){dt.test(At)&&(le&&He.compare(At)!==-1||(He=new y(le=At,Re)))}),le},l.minSatisfying=function(J,ce,Re){var le=null,He=null;try{var dt=new _t(ce,Re)}catch{return null}return J.forEach(function(At){dt.test(At)&&(le&&He.compare(At)!==1||(He=new y(le=At,Re)))}),le},l.minVersion=function(J,ce){J=new _t(J,ce);var Re=new y("0.0.0");if(J.test(Re)||(Re=new y("0.0.0-0"),J.test(Re)))return Re;Re=null;for(var le=0;le<J.set.length;++le)J.set[le].forEach(function(He){var dt=new y(He.semver.version);switch(He.operator){case">":dt.prerelease.length===0?dt.patch++:dt.prerelease.push(0),dt.raw=dt.format();case"":case">=":Re&&!ae(Re,dt)||(Re=dt);break;case"<":case"<=":break;default:throw new Error("Unexpected operation: "+He.operator)}});return Re&&J.test(Re)?Re:null},l.validRange=function(J,ce){try{return new _t(J,ce).range||"*"}catch{return null}},l.ltr=function(J,ce,Re){return it(J,ce,"<",Re)},l.gtr=function(J,ce,Re){return it(J,ce,">",Re)},l.outside=it,l.prerelease=function(J,ce){var Re=re(J,ce);return Re&&Re.prerelease.length?Re.prerelease:null},l.intersects=function(J,ce,Re){return J=new _t(J,Re),ce=new _t(ce,Re),J.intersects(ce)},l.coerce=function(J,ce){if(J instanceof y)return J;if(typeof J=="number"&&(J=String(J)),typeof J!="string")return null;var Re=null;if((ce=ce||{}).rtl){for(var le;(le=F[x.COERCERTL].exec(J))&&(!Re||Re.index+Re[0].length!==J.length);)Re&&le.index+le[0].length===Re.index+Re[0].length||(Re=le),F[x.COERCERTL].lastIndex=le.index+le[1].length+le[2].length;F[x.COERCERTL].lastIndex=-1}else Re=J.match(F[x.COERCE]);return Re===null?null:re(Re[2]+"."+(Re[3]||"0")+"."+(Re[4]||"0"),ce)}}).call(this,f(5))},function(o,l){function f(E){return(f=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(E)}var h;h=function(){return this}();try{h=h||new Function("return this")()}catch{(typeof window>"u"?"undefined":f(window))==="object"&&(h=window)}o.exports=h},function(o,l){var f,h,E=o.exports={};function t(){throw new Error("setTimeout has not been defined")}function N(){throw new Error("clearTimeout has not been defined")}function F(De){if(f===setTimeout)return setTimeout(De,0);if((f===t||!f)&&setTimeout)return f=setTimeout,setTimeout(De,0);try{return f(De,0)}catch{try{return f.call(null,De,0)}catch{return f.call(this,De,0)}}}(function(){try{f=typeof setTimeout=="function"?setTimeout:t}catch{f=t}try{h=typeof clearTimeout=="function"?clearTimeout:N}catch{h=N}})();var k,x=[],j=!1,q=-1;function V(){j&&k&&(j=!1,k.length?x=k.concat(x):q=-1,x.length&&re())}function re(){if(!j){var De=F(V);j=!0;for(var ge=x.length;ge;){for(k=x,x=[];++q<ge;)k&&k[q].run();q=-1,ge=x.length}k=null,j=!1,function(ae){if(h===clearTimeout)return clearTimeout(ae);if((h===N||!h)&&clearTimeout)return h=clearTimeout,clearTimeout(ae);try{h(ae)}catch{try{return h.call(null,ae)}catch{return h.call(this,ae)}}}(De)}}function y(De,ge){this.fun=De,this.array=ge}function me(){}E.nextTick=function(De){var ge=new Array(arguments.length-1);if(arguments.length>1)for(var ae=1;ae<arguments.length;ae++)ge[ae-1]=arguments[ae];x.push(new y(De,ge)),x.length!==1||j||F(re)},y.prototype.run=function(){this.fun.apply(null,this.array)},E.title="browser",E.browser=!0,E.env={},E.argv=[],E.version="",E.versions={},E.on=me,E.addListener=me,E.once=me,E.off=me,E.removeListener=me,E.removeAllListeners=me,E.emit=me,E.prependListener=me,E.prependOnceListener=me,E.listeners=function(De){return[]},E.binding=function(De){throw new Error("process.binding is not supported")},E.cwd=function(){return"/"},E.chdir=function(De){throw new Error("process.chdir is not supported")},E.umask=function(){return 0}},function(o,l,f){"use strict";function h(ze,We){if(!(ze instanceof We))throw new TypeError("Cannot call a class as a function")}function E(ze,We){for(var gt=0;gt<We.length;gt++){var _t=We[gt];_t.enumerable=_t.enumerable||!1,_t.configurable=!0,"value"in _t&&(_t.writable=!0),Object.defineProperty(ze,_t.key,_t)}}var t=f(10),N=Symbol("max"),F=Symbol("length"),k=Symbol("lengthCalculator"),x=Symbol("allowStale"),j=Symbol("maxAge"),q=Symbol("dispose"),V=Symbol("noDisposeOnSet"),re=Symbol("lruList"),y=Symbol("cache"),me=Symbol("updateAgeOnGet"),De=function(){return 1},ge=function(){function ze(Qe){if(h(this,ze),typeof Qe=="number"&&(Qe={max:Qe}),Qe||(Qe={}),Qe.max&&(typeof Qe.max!="number"||Qe.max<0))throw new TypeError("max must be a non-negative number");this[N]=Qe.max||1/0;var ot=Qe.length||De;if(this[k]=typeof ot!="function"?De:ot,this[x]=Qe.stale||!1,Qe.maxAge&&typeof Qe.maxAge!="number")throw new TypeError("maxAge must be a number");this[j]=Qe.maxAge||0,this[q]=Qe.dispose,this[V]=Qe.noDisposeOnSet||!1,this[me]=Qe.updateAgeOnGet||!1,this.reset()}var We,gt,_t;return We=ze,(gt=[{key:"rforEach",value:function(Qe,ot){ot=ot||this;for(var Ve=this[re].tail;Ve!==null;){var Pt=Ve.prev;Ae(this,Qe,Ve,ot),Ve=Pt}}},{key:"forEach",value:function(Qe,ot){ot=ot||this;for(var Ve=this[re].head;Ve!==null;){var Pt=Ve.next;Ae(this,Qe,Ve,ot),Ve=Pt}}},{key:"keys",value:function(){return this[re].toArray().map(function(Qe){return Qe.key})}},{key:"values",value:function(){return this[re].toArray().map(function(Qe){return Qe.value})}},{key:"reset",value:function(){var Qe=this;this[q]&&this[re]&&this[re].length&&this[re].forEach(function(ot){return Qe[q](ot.key,ot.value)}),this[y]=new Map,this[re]=new t,this[F]=0}},{key:"dump",value:function(){var Qe=this;return this[re].map(function(ot){return!we(Qe,ot)&&{k:ot.key,v:ot.value,e:ot.now+(ot.maxAge||0)}}).toArray().filter(function(ot){return ot})}},{key:"dumpLru",value:function(){return this[re]}},{key:"set",value:function(Qe,ot,Ve){if((Ve=Ve||this[j])&&typeof Ve!="number")throw new TypeError("maxAge must be a number");var Pt=Ve?Date.now():0,Jt=this[k](ot,Qe);if(this[y].has(Qe)){if(Jt>this[N])return ve(this,this[y].get(Qe)),!1;var it=this[y].get(Qe).value;return this[q]&&(this[V]||this[q](Qe,it.value)),it.now=Pt,it.maxAge=Ve,it.value=ot,this[F]+=Jt-it.length,it.length=Jt,this.get(Qe),he(this),!0}var J=new ue(Qe,ot,Jt,Pt,Ve);return J.length>this[N]?(this[q]&&this[q](Qe,ot),!1):(this[F]+=J.length,this[re].unshift(J),this[y].set(Qe,this[re].head),he(this),!0)}},{key:"has",value:function(Qe){if(!this[y].has(Qe))return!1;var ot=this[y].get(Qe).value;return!we(this,ot)}},{key:"get",value:function(Qe){return ae(this,Qe,!0)}},{key:"peek",value:function(Qe){return ae(this,Qe,!1)}},{key:"pop",value:function(){var Qe=this[re].tail;return Qe?(ve(this,Qe),Qe.value):null}},{key:"del",value:function(Qe){ve(this,this[y].get(Qe))}},{key:"load",value:function(Qe){this.reset();for(var ot=Date.now(),Ve=Qe.length-1;Ve>=0;Ve--){var Pt=Qe[Ve],Jt=Pt.e||0;if(Jt===0)this.set(Pt.k,Pt.v);else{var it=Jt-ot;it>0&&this.set(Pt.k,Pt.v,it)}}}},{key:"prune",value:function(){var Qe=this;this[y].forEach(function(ot,Ve){return ae(Qe,Ve,!1)})}},{key:"max",set:function(Qe){if(typeof Qe!="number"||Qe<0)throw new TypeError("max must be a non-negative number");this[N]=Qe||1/0,he(this)},get:function(){return this[N]}},{key:"allowStale",set:function(Qe){this[x]=!!Qe},get:function(){return this[x]}},{key:"maxAge",set:function(Qe){if(typeof Qe!="number")throw new TypeError("maxAge must be a non-negative number");this[j]=Qe,he(this)},get:function(){return this[j]}},{key:"lengthCalculator",set:function(Qe){var ot=this;typeof Qe!="function"&&(Qe=De),Qe!==this[k]&&(this[k]=Qe,this[F]=0,this[re].forEach(function(Ve){Ve.length=ot[k](Ve.value,Ve.key),ot[F]+=Ve.length})),he(this)},get:function(){return this[k]}},{key:"length",get:function(){return this[F]}},{key:"itemCount",get:function(){return this[re].length}}])&&E(We.prototype,gt),_t&&E(We,_t),ze}(),ae=function(ze,We,gt){var _t=ze[y].get(We);if(_t){var Qe=_t.value;if(we(ze,Qe)){if(ve(ze,_t),!ze[x])return}else gt&&(ze[me]&&(_t.value.now=Date.now()),ze[re].unshiftNode(_t));return Qe.value}},we=function(ze,We){if(!We||!We.maxAge&&!ze[j])return!1;var gt=Date.now()-We.now;return We.maxAge?gt>We.maxAge:ze[j]&&gt>ze[j]},he=function(ze){if(ze[F]>ze[N])for(var We=ze[re].tail;ze[F]>ze[N]&&We!==null;){var gt=We.prev;ve(ze,We),We=gt}},ve=function(ze,We){if(We){var gt=We.value;ze[q]&&ze[q](gt.key,gt.value),ze[F]-=gt.length,ze[y].delete(gt.key),ze[re].removeNode(We)}},ue=function ze(We,gt,_t,Qe,ot){h(this,ze),this.key=We,this.value=gt,this.length=_t,this.now=Qe,this.maxAge=ot||0},Ae=function(ze,We,gt,_t){var Qe=gt.value;we(ze,Qe)&&(ve(ze,gt),ze[x]||(Qe=void 0)),Qe&&We.call(_t,Qe.value,Qe.key,ze)};o.exports=ge},function(o,l,f){(function(h){function E(t){return(E=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(N){return typeof N}:function(N){return N&&typeof Symbol=="function"&&N.constructor===Symbol&&N!==Symbol.prototype?"symbol":typeof N})(t)}o.exports=function(){if(typeof document>"u"||!document.addEventListener)return null;var t,N,F,k={};return k.copy=function(){var x=!1,j=null,q=!1;function V(){x=!1,j=null,q&&window.getSelection().removeAllRanges(),q=!1}return document.addEventListener("copy",function(re){if(x){for(var y in j)re.clipboardData.setData(y,j[y]);re.preventDefault()}}),function(re){return new Promise(function(y,me){x=!0,typeof re=="string"?j={"text/plain":re}:re instanceof Node?j={"text/html":new XMLSerializer().serializeToString(re)}:re instanceof Object?j=re:me("Invalid data type. Must be string, DOM node, or an object mapping MIME types to strings."),function De(ge){try{if(document.execCommand("copy"))V(),y();else{if(ge)throw V(),new Error("Unable to copy. Perhaps it's not available in your browser?");(function(){var ae=document.getSelection();if(!document.queryCommandEnabled("copy")&&ae.isCollapsed){var we=document.createRange();we.selectNodeContents(document.body),ae.removeAllRanges(),ae.addRange(we),q=!0}})(),De(!0)}}catch(ae){V(),me(ae)}}(!1)})}}(),k.paste=(F=!1,document.addEventListener("paste",function(x){if(F){F=!1,x.preventDefault();var j=t;t=null,j(x.clipboardData.getData(N))}}),function(x){return new Promise(function(j,q){F=!0,t=j,N=x||"text/plain";try{document.execCommand("paste")||(F=!1,q(new Error("Unable to paste. Pasting only works in Internet Explorer at the moment.")))}catch(V){F=!1,q(new Error(V))}})}),typeof ClipboardEvent>"u"&&window.clipboardData!==void 0&&window.clipboardData.setData!==void 0&&(function(x){function j(he,ve){return function(){he.apply(ve,arguments)}}function q(he){if(E(this)!="object")throw new TypeError("Promises must be constructed via new");if(typeof he!="function")throw new TypeError("not a function");this._state=null,this._value=null,this._deferreds=[],ge(he,j(re,this),j(y,this))}function V(he){var ve=this;return this._state===null?void this._deferreds.push(he):void ae(function(){var ue=ve._state?he.onFulfilled:he.onRejected;if(ue!==null){var Ae;try{Ae=ue(ve._value)}catch(ze){return void he.reject(ze)}he.resolve(Ae)}else(ve._state?he.resolve:he.reject)(ve._value)})}function re(he){try{if(he===this)throw new TypeError("A promise cannot be resolved with itself.");if(he&&(E(he)=="object"||typeof he=="function")){var ve=he.then;if(typeof ve=="function")return void ge(j(ve,he),j(re,this),j(y,this))}this._state=!0,this._value=he,me.call(this)}catch(ue){y.call(this,ue)}}function y(he){this._state=!1,this._value=he,me.call(this)}function me(){for(var he=0,ve=this._deferreds.length;ve>he;he++)V.call(this,this._deferreds[he]);this._deferreds=null}function De(he,ve,ue,Ae){this.onFulfilled=typeof he=="function"?he:null,this.onRejected=typeof ve=="function"?ve:null,this.resolve=ue,this.reject=Ae}function ge(he,ve,ue){var Ae=!1;try{he(function(ze){Ae||(Ae=!0,ve(ze))},function(ze){Ae||(Ae=!0,ue(ze))})}catch(ze){if(Ae)return;Ae=!0,ue(ze)}}var ae=q.immediateFn||typeof h=="function"&&h||function(he){setTimeout(he,1)},we=Array.isArray||function(he){return Object.prototype.toString.call(he)==="[object Array]"};q.prototype.catch=function(he){return this.then(null,he)},q.prototype.then=function(he,ve){var ue=this;return new q(function(Ae,ze){V.call(ue,new De(he,ve,Ae,ze))})},q.all=function(){var he=Array.prototype.slice.call(arguments.length===1&&we(arguments[0])?arguments[0]:arguments);return new q(function(ve,ue){function Ae(gt,_t){try{if(_t&&(E(_t)=="object"||typeof _t=="function")){var Qe=_t.then;if(typeof Qe=="function")return void Qe.call(_t,function(ot){Ae(gt,ot)},ue)}he[gt]=_t,--ze==0&&ve(he)}catch(ot){ue(ot)}}if(he.length===0)return ve([]);for(var ze=he.length,We=0;We<he.length;We++)Ae(We,he[We])})},q.resolve=function(he){return he&&E(he)=="object"&&he.constructor===q?he:new q(function(ve){ve(he)})},q.reject=function(he){return new q(function(ve,ue){ue(he)})},q.race=function(he){return new q(function(ve,ue){for(var Ae=0,ze=he.length;ze>Ae;Ae++)he[Ae].then(ve,ue)})},o.exports?o.exports=q:x.Promise||(x.Promise=q)}(this),k.copy=function(x){return new Promise(function(j,q){if(typeof x!="string"&&!("text/plain"in x))throw new Error("You must provide a text/plain type.");var V=typeof x=="string"?x:x["text/plain"];window.clipboardData.setData("Text",V)?j():q(new Error("Copying was rejected."))})},k.paste=function(){return new Promise(function(x,j){var q=window.clipboardData.getData("Text");q?x(q):j(new Error("Pasting was rejected."))})}),k}()}).call(this,f(13).setImmediate)},function(o,l,f){"use strict";o.exports=f(15)},function(o,l,f){"use strict";f.r(l),l.default=`:root {
+  /**
+   * IMPORTANT: When new theme variables are added below\u2013 also add them to SettingsContext updateThemeVariables()
+   */
+
+  /* Light theme */
+  --light-color-attribute-name: #ef6632;
+  --light-color-attribute-name-not-editable: #23272f;
+  --light-color-attribute-name-inverted: rgba(255, 255, 255, 0.7);
+  --light-color-attribute-value: #1a1aa6;
+  --light-color-attribute-value-inverted: #ffffff;
+  --light-color-attribute-editable-value: #1a1aa6;
+  --light-color-background: #ffffff;
+  --light-color-background-hover: rgba(0, 136, 250, 0.1);
+  --light-color-background-inactive: #e5e5e5;
+  --light-color-background-invalid: #fff0f0;
+  --light-color-background-selected: #0088fa;
+  --light-color-button-background: #ffffff;
+  --light-color-button-background-focus: #ededed;
+  --light-color-button: #5f6673;
+  --light-color-button-disabled: #cfd1d5;
+  --light-color-button-active: #0088fa;
+  --light-color-button-focus: #23272f;
+  --light-color-button-hover: #23272f;
+  --light-color-border: #eeeeee;
+  --light-color-commit-did-not-render-fill: #cfd1d5;
+  --light-color-commit-did-not-render-fill-text: #000000;
+  --light-color-commit-did-not-render-pattern: #cfd1d5;
+  --light-color-commit-did-not-render-pattern-text: #333333;
+  --light-color-commit-gradient-0: #37afa9;
+  --light-color-commit-gradient-1: #63b19e;
+  --light-color-commit-gradient-2: #80b393;
+  --light-color-commit-gradient-3: #97b488;
+  --light-color-commit-gradient-4: #abb67d;
+  --light-color-commit-gradient-5: #beb771;
+  --light-color-commit-gradient-6: #cfb965;
+  --light-color-commit-gradient-7: #dfba57;
+  --light-color-commit-gradient-8: #efbb49;
+  --light-color-commit-gradient-9: #febc38;
+  --light-color-commit-gradient-text: #000000;
+  --light-color-component-name: #6a51b2;
+  --light-color-component-name-inverted: #ffffff;
+  --light-color-component-badge-background: rgba(0, 0, 0, 0.1);
+  --light-color-component-badge-background-inverted: rgba(255, 255, 255, 0.25);
+  --light-color-component-badge-count: #777d88;
+  --light-color-component-badge-count-inverted: rgba(255, 255, 255, 0.7);
+  --light-color-context-background: rgba(0,0,0,.9);
+  --light-color-context-background-hover: rgba(255, 255, 255, 0.1);
+  --light-color-context-background-selected: #178fb9;
+  --light-color-context-border: #3d424a;
+  --light-color-context-text: #ffffff;
+  --light-color-context-text-selected: #ffffff;
+  --light-color-dim: #777d88;
+  --light-color-dimmer: #cfd1d5;
+  --light-color-dimmest: #eff0f1;
+  --light-color-error-background: hsl(0, 100%, 97%);
+  --light-color-error-border: hsl(0, 100%, 92%);
+  --light-color-error-text: #ff0000;
+  --light-color-expand-collapse-toggle: #777d88;
+  --light-color-link: #0000ff;
+  --light-color-modal-background: rgba(255, 255, 255, 0.75);
+  --light-color-record-active: #fc3a4b;
+  --light-color-record-hover: #3578e5;
+  --light-color-record-inactive: #0088fa;
+  --light-color-scroll-thumb: #c2c2c2;
+  --light-color-scroll-track: #fafafa;
+  --light-color-search-match: yellow;
+  --light-color-search-match-current: #f7923b;
+  --light-color-selected-tree-highlight-active: rgba(0, 136, 250, 0.1);
+  --light-color-selected-tree-highlight-inactive: rgba(0, 0, 0, 0.05);
+  --light-color-shadow: rgba(0, 0, 0, 0.25);
+  --light-color-tab-selected-border: #0088fa;
+  --light-color-text: #000000;
+  --light-color-text-invalid: #ff0000;
+  --light-color-text-selected: #ffffff;
+  --light-color-toggle-background-invalid: #fc3a4b;
+  --light-color-toggle-background-on: #0088fa;
+  --light-color-toggle-background-off: #cfd1d5;
+  --light-color-toggle-text: #ffffff;
+  --light-color-tooltip-background: rgba(0, 0, 0, 0.9);
+  --light-color-tooltip-text: #ffffff;
+
+  /* Dark theme */
+  --dark-color-attribute-name: #9d87d2;
+  --dark-color-attribute-name-not-editable: #ededed;
+  --dark-color-attribute-name-inverted: #282828;
+  --dark-color-attribute-value: #cedae0;
+  --dark-color-attribute-value-inverted: #ffffff;
+  --dark-color-attribute-editable-value: yellow;
+  --dark-color-background: #282c34;
+  --dark-color-background-hover: rgba(255, 255, 255, 0.1);
+  --dark-color-background-inactive: #3d424a;
+  --dark-color-background-invalid: #5c0000;
+  --dark-color-background-selected: #178fb9;
+  --dark-color-button-background: #282c34;
+  --dark-color-button-background-focus: #3d424a;
+  --dark-color-button: #afb3b9;
+  --dark-color-button-active: #61dafb;
+  --dark-color-button-disabled: #4f5766;
+  --dark-color-button-focus: #a2e9fc;
+  --dark-color-button-hover: #ededed;
+  --dark-color-border: #3d424a;
+  --dark-color-commit-did-not-render-fill: #777d88;
+  --dark-color-commit-did-not-render-fill-text: #000000;
+  --dark-color-commit-did-not-render-pattern: #666c77;
+  --dark-color-commit-did-not-render-pattern-text: #ffffff;
+  --dark-color-commit-gradient-0: #37afa9;
+  --dark-color-commit-gradient-1: #63b19e;
+  --dark-color-commit-gradient-2: #80b393;
+  --dark-color-commit-gradient-3: #97b488;
+  --dark-color-commit-gradient-4: #abb67d;
+  --dark-color-commit-gradient-5: #beb771;
+  --dark-color-commit-gradient-6: #cfb965;
+  --dark-color-commit-gradient-7: #dfba57;
+  --dark-color-commit-gradient-8: #efbb49;
+  --dark-color-commit-gradient-9: #febc38;
+  --dark-color-commit-gradient-text: #000000;
+  --dark-color-component-name: #61dafb;
+  --dark-color-component-name-inverted: #282828;
+  --dark-color-component-badge-background: rgba(255, 255, 255, 0.25);
+  --dark-color-component-badge-background-inverted: rgba(0, 0, 0, 0.25);
+  --dark-color-component-badge-count: #8f949d;
+  --dark-color-component-badge-count-inverted: rgba(255, 255, 255, 0.7);
+  --dark-color-context-background: rgba(255,255,255,.9);
+  --dark-color-context-background-hover: rgba(0, 136, 250, 0.1);
+  --dark-color-context-background-selected: #0088fa;
+  --dark-color-context-border: #eeeeee;
+  --dark-color-context-text: #000000;
+  --dark-color-context-text-selected: #ffffff;
+  --dark-color-dim: #8f949d;
+  --dark-color-dimmer: #777d88;
+  --dark-color-dimmest: #4f5766;
+  --dark-color-error-background: #200;
+  --dark-color-error-border: #900;
+  --dark-color-error-text: #f55;
+  --dark-color-expand-collapse-toggle: #8f949d;
+  --dark-color-link: #61dafb;
+  --dark-color-modal-background: rgba(0, 0, 0, 0.75);
+  --dark-color-record-active: #fc3a4b;
+  --dark-color-record-hover: #a2e9fc;
+  --dark-color-record-inactive: #61dafb;
+  --dark-color-scroll-thumb: #afb3b9;
+  --dark-color-scroll-track: #313640;
+  --dark-color-search-match: yellow;
+  --dark-color-search-match-current: #f7923b;
+  --dark-color-selected-tree-highlight-active: rgba(23, 143, 185, 0.15);
+  --dark-color-selected-tree-highlight-inactive: rgba(255, 255, 255, 0.05);
+  --dark-color-shadow: rgba(0, 0, 0, 0.5);
+  --dark-color-tab-selected-border: #178fb9;
+  --dark-color-text: #ffffff;
+  --dark-color-text-invalid: #ff8080;
+  --dark-color-text-selected: #ffffff;
+  --dark-color-toggle-background-invalid: #fc3a4b;
+  --dark-color-toggle-background-on: #178fb9;
+  --dark-color-toggle-background-off: #777d88;
+  --dark-color-toggle-text: #ffffff;
+  --dark-color-tooltip-background: rgba(255, 255, 255, 0.9);
+  --dark-color-tooltip-text: #000000;
+
+  /* Font smoothing */
+  --light-font-smoothing: auto;
+  --dark-font-smoothing: antialiased;
+  --font-smoothing: auto;
+
+  /* Compact density */
+  --compact-font-size-monospace-small: 9px;
+  --compact-font-size-monospace-normal: 11px;
+  --compact-font-size-monospace-large: 15px;
+  --compact-font-size-sans-small: 10px;
+  --compact-font-size-sans-normal: 12px;
+  --compact-font-size-sans-large: 14px;
+  --compact-line-height-data: 18px;
+  --compact-root-font-size: 16px;
+
+  /* Comfortable density */
+  --comfortable-font-size-monospace-small: 10px;
+  --comfortable-font-size-monospace-normal: 13px;
+  --comfortable-font-size-monospace-large: 17px;
+  --comfortable-font-size-sans-small: 12px;
+  --comfortable-font-size-sans-normal: 14px;
+  --comfortable-font-size-sans-large: 16px;
+  --comfortable-line-height-data: 22px;
+  --comfortable-root-font-size: 20px;
+
+  /* GitHub.com system fonts */
+  --font-family-monospace: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo,
+    Courier, monospace;
+  --font-family-sans: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica,
+    Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol;
+
+  /* Constant values shared between JS and CSS */
+  --interaction-commit-size: 10px;
+  --interaction-label-width: 200px;
+}
+`},function(o,l,f){"use strict";function h(k){var x=this;if(x instanceof h||(x=new h),x.tail=null,x.head=null,x.length=0,k&&typeof k.forEach=="function")k.forEach(function(V){x.push(V)});else if(arguments.length>0)for(var j=0,q=arguments.length;j<q;j++)x.push(arguments[j]);return x}function E(k,x,j){var q=x===k.head?new F(j,null,x,k):new F(j,x,x.next,k);return q.next===null&&(k.tail=q),q.prev===null&&(k.head=q),k.length++,q}function t(k,x){k.tail=new F(x,k.tail,null,k),k.head||(k.head=k.tail),k.length++}function N(k,x){k.head=new F(x,null,k.head,k),k.tail||(k.tail=k.head),k.length++}function F(k,x,j,q){if(!(this instanceof F))return new F(k,x,j,q);this.list=q,this.value=k,x?(x.next=this,this.prev=x):this.prev=null,j?(j.prev=this,this.next=j):this.next=null}o.exports=h,h.Node=F,h.create=h,h.prototype.removeNode=function(k){if(k.list!==this)throw new Error("removing node which does not belong to this list");var x=k.next,j=k.prev;return x&&(x.prev=j),j&&(j.next=x),k===this.head&&(this.head=x),k===this.tail&&(this.tail=j),k.list.length--,k.next=null,k.prev=null,k.list=null,x},h.prototype.unshiftNode=function(k){if(k!==this.head){k.list&&k.list.removeNode(k);var x=this.head;k.list=this,k.next=x,x&&(x.prev=k),this.head=k,this.tail||(this.tail=k),this.length++}},h.prototype.pushNode=function(k){if(k!==this.tail){k.list&&k.list.removeNode(k);var x=this.tail;k.list=this,k.prev=x,x&&(x.next=k),this.tail=k,this.head||(this.head=k),this.length++}},h.prototype.push=function(){for(var k=0,x=arguments.length;k<x;k++)t(this,arguments[k]);return this.length},h.prototype.unshift=function(){for(var k=0,x=arguments.length;k<x;k++)N(this,arguments[k]);return this.length},h.prototype.pop=function(){if(this.tail){var k=this.tail.value;return this.tail=this.tail.prev,this.tail?this.tail.next=null:this.head=null,this.length--,k}},h.prototype.shift=function(){if(this.head){var k=this.head.value;return this.head=this.head.next,this.head?this.head.prev=null:this.tail=null,this.length--,k}},h.prototype.forEach=function(k,x){x=x||this;for(var j=this.head,q=0;j!==null;q++)k.call(x,j.value,q,this),j=j.next},h.prototype.forEachReverse=function(k,x){x=x||this;for(var j=this.tail,q=this.length-1;j!==null;q--)k.call(x,j.value,q,this),j=j.prev},h.prototype.get=function(k){for(var x=0,j=this.head;j!==null&&x<k;x++)j=j.next;if(x===k&&j!==null)return j.value},h.prototype.getReverse=function(k){for(var x=0,j=this.tail;j!==null&&x<k;x++)j=j.prev;if(x===k&&j!==null)return j.value},h.prototype.map=function(k,x){x=x||this;for(var j=new h,q=this.head;q!==null;)j.push(k.call(x,q.value,this)),q=q.next;return j},h.prototype.mapReverse=function(k,x){x=x||this;for(var j=new h,q=this.tail;q!==null;)j.push(k.call(x,q.value,this)),q=q.prev;return j},h.prototype.reduce=function(k,x){var j,q=this.head;if(arguments.length>1)j=x;else{if(!this.head)throw new TypeError("Reduce of empty list with no initial value");q=this.head.next,j=this.head.value}for(var V=0;q!==null;V++)j=k(j,q.value,V),q=q.next;return j},h.prototype.reduceReverse=function(k,x){var j,q=this.tail;if(arguments.length>1)j=x;else{if(!this.tail)throw new TypeError("Reduce of empty list with no initial value");q=this.tail.prev,j=this.tail.value}for(var V=this.length-1;q!==null;V--)j=k(j,q.value,V),q=q.prev;return j},h.prototype.toArray=function(){for(var k=new Array(this.length),x=0,j=this.head;j!==null;x++)k[x]=j.value,j=j.next;return k},h.prototype.toArrayReverse=function(){for(var k=new Array(this.length),x=0,j=this.tail;j!==null;x++)k[x]=j.value,j=j.prev;return k},h.prototype.slice=function(k,x){(x=x||this.length)<0&&(x+=this.length),(k=k||0)<0&&(k+=this.length);var j=new h;if(x<k||x<0)return j;k<0&&(k=0),x>this.length&&(x=this.length);for(var q=0,V=this.head;V!==null&&q<k;q++)V=V.next;for(;V!==null&&q<x;q++,V=V.next)j.push(V.value);return j},h.prototype.sliceReverse=function(k,x){(x=x||this.length)<0&&(x+=this.length),(k=k||0)<0&&(k+=this.length);var j=new h;if(x<k||x<0)return j;k<0&&(k=0),x>this.length&&(x=this.length);for(var q=this.length,V=this.tail;V!==null&&q>x;q--)V=V.prev;for(;V!==null&&q>k;q--,V=V.prev)j.push(V.value);return j},h.prototype.splice=function(k,x){k>this.length&&(k=this.length-1),k<0&&(k=this.length+k);for(var j=0,q=this.head;q!==null&&j<k;j++)q=q.next;var V=[];for(j=0;q&&j<x;j++)V.push(q.value),q=this.removeNode(q);for(q===null&&(q=this.tail),q!==this.head&&q!==this.tail&&(q=q.prev),j=2;j<arguments.length;j++)q=E(this,q,arguments[j]);return V},h.prototype.reverse=function(){for(var k=this.head,x=this.tail,j=k;j!==null;j=j.prev){var q=j.prev;j.prev=j.next,j.next=q}return this.head=x,this.tail=k,this};try{f(11)(h)}catch{}},function(o,l,f){"use strict";o.exports=function(h){h.prototype[Symbol.iterator]=regeneratorRuntime.mark(function E(){var t;return regeneratorRuntime.wrap(function(N){for(;;)switch(N.prev=N.next){case 0:t=this.head;case 1:if(!t){N.next=7;break}return N.next=4,t.value;case 4:t=t.next,N.next=1;break;case 7:case"end":return N.stop()}},E,this)})}},function(o,l,f){"use strict";function h(it){return(h=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(J){return typeof J}:function(J){return J&&typeof Symbol=="function"&&J.constructor===Symbol&&J!==Symbol.prototype?"symbol":typeof J})(it)}var E=60103,t=60106,N=60107,F=60108,k=60114,x=60109,j=60110,q=60112,V=60113,re=60120,y=60115,me=60116,De=60121,ge=60122,ae=60117,we=60129,he=60131;if(typeof Symbol=="function"&&Symbol.for){var ve=Symbol.for;E=ve("react.element"),t=ve("react.portal"),N=ve("react.fragment"),F=ve("react.strict_mode"),k=ve("react.profiler"),x=ve("react.provider"),j=ve("react.context"),q=ve("react.forward_ref"),V=ve("react.suspense"),re=ve("react.suspense_list"),y=ve("react.memo"),me=ve("react.lazy"),De=ve("react.block"),ge=ve("react.server.block"),ae=ve("react.fundamental"),we=ve("react.debug_trace_mode"),he=ve("react.legacy_hidden")}function ue(it){if(h(it)==="object"&&it!==null){var J=it.$$typeof;switch(J){case E:switch(it=it.type){case N:case k:case F:case V:case re:return it;default:switch(it=it&&it.$$typeof){case j:case q:case me:case y:case x:return it;default:return J}}case t:return J}}}var Ae=x,ze=E,We=q,gt=N,_t=me,Qe=y,ot=t,Ve=k,Pt=F,Jt=V;l.ContextConsumer=j,l.ContextProvider=Ae,l.Element=ze,l.ForwardRef=We,l.Fragment=gt,l.Lazy=_t,l.Memo=Qe,l.Portal=ot,l.Profiler=Ve,l.StrictMode=Pt,l.Suspense=Jt,l.isAsyncMode=function(){return!1},l.isConcurrentMode=function(){return!1},l.isContextConsumer=function(it){return ue(it)===j},l.isContextProvider=function(it){return ue(it)===x},l.isElement=function(it){return h(it)==="object"&&it!==null&&it.$$typeof===E},l.isForwardRef=function(it){return ue(it)===q},l.isFragment=function(it){return ue(it)===N},l.isLazy=function(it){return ue(it)===me},l.isMemo=function(it){return ue(it)===y},l.isPortal=function(it){return ue(it)===t},l.isProfiler=function(it){return ue(it)===k},l.isStrictMode=function(it){return ue(it)===F},l.isSuspense=function(it){return ue(it)===V},l.isValidElementType=function(it){return typeof it=="string"||typeof it=="function"||it===N||it===k||it===we||it===F||it===V||it===re||it===he||h(it)==="object"&&it!==null&&(it.$$typeof===me||it.$$typeof===y||it.$$typeof===x||it.$$typeof===j||it.$$typeof===q||it.$$typeof===ae||it.$$typeof===De||it[0]===ge)},l.typeOf=ue},function(o,l,f){(function(h){var E=h!==void 0&&h||typeof self<"u"&&self||window,t=Function.prototype.apply;function N(F,k){this._id=F,this._clearFn=k}l.setTimeout=function(){return new N(t.call(setTimeout,E,arguments),clearTimeout)},l.setInterval=function(){return new N(t.call(setInterval,E,arguments),clearInterval)},l.clearTimeout=l.clearInterval=function(F){F&&F.close()},N.prototype.unref=N.prototype.ref=function(){},N.prototype.close=function(){this._clearFn.call(E,this._id)},l.enroll=function(F,k){clearTimeout(F._idleTimeoutId),F._idleTimeout=k},l.unenroll=function(F){clearTimeout(F._idleTimeoutId),F._idleTimeout=-1},l._unrefActive=l.active=function(F){clearTimeout(F._idleTimeoutId);var k=F._idleTimeout;k>=0&&(F._idleTimeoutId=setTimeout(function(){F._onTimeout&&F._onTimeout()},k))},f(14),l.setImmediate=typeof self<"u"&&self.setImmediate||h!==void 0&&h.setImmediate||this&&this.setImmediate,l.clearImmediate=typeof self<"u"&&self.clearImmediate||h!==void 0&&h.clearImmediate||this&&this.clearImmediate}).call(this,f(4))},function(o,l,f){(function(h,E){(function(t,N){"use strict";if(!t.setImmediate){var F,k,x,j,q,V=1,re={},y=!1,me=t.document,De=Object.getPrototypeOf&&Object.getPrototypeOf(t);De=De&&De.setTimeout?De:t,{}.toString.call(t.process)==="[object process]"?F=function(we){E.nextTick(function(){ae(we)})}:function(){if(t.postMessage&&!t.importScripts){var we=!0,he=t.onmessage;return t.onmessage=function(){we=!1},t.postMessage("","*"),t.onmessage=he,we}}()?(j="setImmediate$"+Math.random()+"$",q=function(we){we.source===t&&typeof we.data=="string"&&we.data.indexOf(j)===0&&ae(+we.data.slice(j.length))},t.addEventListener?t.addEventListener("message",q,!1):t.attachEvent("onmessage",q),F=function(we){t.postMessage(j+we,"*")}):t.MessageChannel?((x=new MessageChannel).port1.onmessage=function(we){ae(we.data)},F=function(we){x.port2.postMessage(we)}):me&&"onreadystatechange"in me.createElement("script")?(k=me.documentElement,F=function(we){var he=me.createElement("script");he.onreadystatechange=function(){ae(we),he.onreadystatechange=null,k.removeChild(he),he=null},k.appendChild(he)}):F=function(we){setTimeout(ae,0,we)},De.setImmediate=function(we){typeof we!="function"&&(we=new Function(""+we));for(var he=new Array(arguments.length-1),ve=0;ve<he.length;ve++)he[ve]=arguments[ve+1];var ue={callback:we,args:he};return re[V]=ue,F(V),V++},De.clearImmediate=ge}function ge(we){delete re[we]}function ae(we){if(y)setTimeout(ae,0,we);else{var he=re[we];if(he){y=!0;try{(function(ve){var ue=ve.callback,Ae=ve.args;switch(Ae.length){case 0:ue();break;case 1:ue(Ae[0]);break;case 2:ue(Ae[0],Ae[1]);break;case 3:ue(Ae[0],Ae[1],Ae[2]);break;default:ue.apply(void 0,Ae)}})(he)}finally{ge(we),y=!1}}}}})(typeof self>"u"?h===void 0?this:h:self)}).call(this,f(4),f(5))},function(o,l,f){"use strict";function h(ue){return(h=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(Ae){return typeof Ae}:function(Ae){return Ae&&typeof Symbol=="function"&&Ae.constructor===Symbol&&Ae!==Symbol.prototype?"symbol":typeof Ae})(ue)}var E=f(1),t=f(16),N=f(18).__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,F=60128;if(typeof Symbol=="function"&&Symbol.for){var k=Symbol.for;F=k("react.opaque.id")}var x=[],j=null,q=null;function V(){if(j===null){var ue=new Map;try{me.useContext({_currentValue:null}),me.useState(null),me.useReducer(function(gt){return gt},null),me.useRef(null),me.useLayoutEffect(function(){}),me.useEffect(function(){}),me.useImperativeHandle(void 0,function(){return null}),me.useDebugValue(null),me.useCallback(function(){}),me.useMemo(function(){return null})}finally{var Ae=x;x=[]}for(var ze=0;ze<Ae.length;ze++){var We=Ae[ze];ue.set(We.primitive,t.parse(We.stackError))}j=ue}return j}var re=null;function y(){var ue=re;return ue!==null&&(re=ue.next),ue}var me={readContext:function(ue){return ue._currentValue},useCallback:function(ue){var Ae=y();return x.push({primitive:"Callback",stackError:Error(),value:Ae!==null?Ae.memoizedState[0]:ue}),ue},useContext:function(ue){return x.push({primitive:"Context",stackError:Error(),value:ue._currentValue}),ue._currentValue},useEffect:function(ue){y(),x.push({primitive:"Effect",stackError:Error(),value:ue})},useImperativeHandle:function(ue){y();var Ae=void 0;ue!==null&&h(ue)==="object"&&(Ae=ue.current),x.push({primitive:"ImperativeHandle",stackError:Error(),value:Ae})},useDebugValue:function(ue,Ae){x.push({primitive:"DebugValue",stackError:Error(),value:typeof Ae=="function"?Ae(ue):ue})},useLayoutEffect:function(ue){y(),x.push({primitive:"LayoutEffect",stackError:Error(),value:ue})},useMemo:function(ue){var Ae=y();return ue=Ae!==null?Ae.memoizedState[0]:ue(),x.push({primitive:"Memo",stackError:Error(),value:ue}),ue},useReducer:function(ue,Ae,ze){return Ae=(ue=y())!==null?ue.memoizedState:ze!==void 0?ze(Ae):Ae,x.push({primitive:"Reducer",stackError:Error(),value:Ae}),[Ae,function(){}]},useRef:function(ue){var Ae=y();return ue=Ae!==null?Ae.memoizedState:{current:ue},x.push({primitive:"Ref",stackError:Error(),value:ue.current}),ue},useState:function(ue){var Ae=y();return ue=Ae!==null?Ae.memoizedState:typeof ue=="function"?ue():ue,x.push({primitive:"State",stackError:Error(),value:ue}),[ue,function(){}]},useTransition:function(){return y(),y(),x.push({primitive:"Transition",stackError:Error(),value:void 0}),[function(){},!1]},useMutableSource:function(ue,Ae){return y(),y(),y(),y(),ue=Ae(ue._source),x.push({primitive:"MutableSource",stackError:Error(),value:ue}),ue},useDeferredValue:function(ue){return y(),y(),x.push({primitive:"DeferredValue",stackError:Error(),value:ue}),ue},useOpaqueIdentifier:function(){var ue=y();return q&&q.mode===0&&y(),(ue=ue===null?void 0:ue.memoizedState)&&ue.$$typeof===F&&(ue=void 0),x.push({primitive:"OpaqueIdentifier",stackError:Error(),value:ue}),ue}},De=0;function ge(ue,Ae,ze){var We=Ae[ze].source,gt=0;e:for(;gt<ue.length;gt++)if(ue[gt].source===We){for(var _t=ze+1,Qe=gt+1;_t<Ae.length&&Qe<ue.length;_t++,Qe++)if(ue[Qe].source!==Ae[_t].source)continue e;return gt}return-1}function ae(ue,Ae){return!!ue&&(Ae="use"+Ae,!(ue.length<Ae.length)&&ue.lastIndexOf(Ae)===ue.length-Ae.length)}function we(ue){if(!ue)return"";var Ae=ue.lastIndexOf(".");return Ae===-1&&(Ae=0),ue.substr(Ae,3)==="use"&&(Ae+=3),ue.substr(Ae)}function he(ue,Ae){for(var ze=[],We=null,gt=ze,_t=0,Qe=[],ot=0;ot<Ae.length;ot++){var Ve=Ae[ot],Pt=ue,Jt=t.parse(Ve.stackError);e:{var it=Jt,J=ge(it,Pt,De);if(J!==-1)Pt=J;else{for(var ce=0;ce<Pt.length&&5>ce;ce++)if((J=ge(it,Pt,ce))!==-1){De=ce,Pt=J;break e}Pt=-1}}e:{if(it=Jt,(J=V().get(Ve.primitive))!==void 0){for(ce=0;ce<J.length&&ce<it.length;ce++)if(J[ce].source!==it[ce].source){ce<it.length-1&&ae(it[ce].functionName,Ve.primitive)&&ce++,ce<it.length-1&&ae(it[ce].functionName,Ve.primitive)&&ce++,it=ce;break e}}it=-1}if((Jt=Pt===-1||it===-1||2>Pt-it?null:Jt.slice(it,Pt-1))!==null){if(Pt=0,We!==null){for(;Pt<Jt.length&&Pt<We.length&&Jt[Jt.length-Pt-1].source===We[We.length-Pt-1].source;)Pt++;for(We=We.length-1;We>Pt;We--)gt=Qe.pop()}for(We=Jt.length-Pt-1;1<=We;We--)Pt=[],gt.push({id:null,isStateEditable:!1,name:we(Jt[We-1].functionName),value:void 0,subHooks:Pt}),Qe.push(gt),gt=Pt;We=Jt}Pt=(Jt=Ve.primitive)==="Context"||Jt==="DebugValue"?null:_t++,gt.push({id:Pt,isStateEditable:Jt==="Reducer"||Jt==="State",name:Jt,value:Ve.value,subHooks:[]})}return function Re(le,He){for(var dt=[],At=0;At<le.length;At++){var nn=le[At];nn.name==="DebugValue"&&nn.subHooks.length===0?(le.splice(At,1),At--,dt.push(nn)):Re(nn.subHooks,nn)}He!==null&&(dt.length===1?He.value=dt[0].value:1<dt.length&&(He.value=dt.map(function(an){return an.value})))}(ze,null),ze}function ve(ue,Ae,ze){ze==null&&(ze=N.ReactCurrentDispatcher);var We=ze.current;ze.current=me;try{var gt=Error();ue(Ae)}finally{ue=x,x=[],ze.current=We}return he(ze=t.parse(gt),ue)}l.inspectHooks=ve,l.inspectHooksOfFiber=function(ue,Ae){if(Ae==null&&(Ae=N.ReactCurrentDispatcher),q=ue,ue.tag!==0&&ue.tag!==15&&ue.tag!==11&&ue.tag!==22)throw Error("Unknown Fiber. Needs to be a function component to inspect hooks.");V();var ze=ue.type,We=ue.memoizedProps;if(ze!==ue.elementType&&ze&&ze.defaultProps){We=E({},We);var gt=ze.defaultProps;for(_t in gt)We[_t]===void 0&&(We[_t]=gt[_t])}re=ue.memoizedState;var _t=new Map;try{for(gt=ue;gt;){if(gt.tag===10){var Qe=gt.type._context;_t.has(Qe)||(_t.set(Qe,Qe._currentValue),Qe._currentValue=gt.memoizedProps.value)}gt=gt.return}if(ue.tag===11){var ot=ze.render;ze=We;var Ve=ue.ref,Pt=(ue=Ae).current;ue.current=me;try{var Jt=Error();ot(ze,Ve)}finally{var it=x;x=[],ue.current=Pt}return he(t.parse(Jt),it)}return ve(ze,We,Ae)}finally{re=null,function(J){J.forEach(function(ce,Re){return Re._currentValue=ce})}(_t)}}},function(o,l,f){var h,E,t;(function(N,F){"use strict";E=[f(17)],(t=typeof(h=function(k){var x=/(^|@)\S+:\d+/,j=/^\s*at .*(\S+:\d+|\(native\))/m,q=/^(eval@)?(\[native code])?$/;return{parse:function(V){if(V.stacktrace!==void 0||V["opera#sourceloc"]!==void 0)return this.parseOpera(V);if(V.stack&&V.stack.match(j))return this.parseV8OrIE(V);if(V.stack)return this.parseFFOrSafari(V);throw new Error("Cannot parse given Error object")},extractLocation:function(V){if(V.indexOf(":")===-1)return[V];var re=/(.+?)(?::(\d+))?(?::(\d+))?$/.exec(V.replace(/[()]/g,""));return[re[1],re[2]||void 0,re[3]||void 0]},parseV8OrIE:function(V){return V.stack.split(`
+`).filter(function(re){return!!re.match(j)},this).map(function(re){re.indexOf("(eval ")>-1&&(re=re.replace(/eval code/g,"eval").replace(/(\(eval at [^()]*)|(\),.*$)/g,""));var y=re.replace(/^\s+/,"").replace(/\(eval code/g,"("),me=y.match(/ (\((.+):(\d+):(\d+)\)$)/),De=(y=me?y.replace(me[0],""):y).split(/\s+/).slice(1),ge=this.extractLocation(me?me[1]:De.pop()),ae=De.join(" ")||void 0,we=["eval","<anonymous>"].indexOf(ge[0])>-1?void 0:ge[0];return new k({functionName:ae,fileName:we,lineNumber:ge[1],columnNumber:ge[2],source:re})},this)},parseFFOrSafari:function(V){return V.stack.split(`
+`).filter(function(re){return!re.match(q)},this).map(function(re){if(re.indexOf(" > eval")>-1&&(re=re.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,":$1")),re.indexOf("@")===-1&&re.indexOf(":")===-1)return new k({functionName:re});var y=/((.*".+"[^@]*)?[^@]*)(?:@)/,me=re.match(y),De=me&&me[1]?me[1]:void 0,ge=this.extractLocation(re.replace(y,""));return new k({functionName:De,fileName:ge[0],lineNumber:ge[1],columnNumber:ge[2],source:re})},this)},parseOpera:function(V){return!V.stacktrace||V.message.indexOf(`
+`)>-1&&V.message.split(`
+`).length>V.stacktrace.split(`
+`).length?this.parseOpera9(V):V.stack?this.parseOpera11(V):this.parseOpera10(V)},parseOpera9:function(V){for(var re=/Line (\d+).*script (?:in )?(\S+)/i,y=V.message.split(`
+`),me=[],De=2,ge=y.length;De<ge;De+=2){var ae=re.exec(y[De]);ae&&me.push(new k({fileName:ae[2],lineNumber:ae[1],source:y[De]}))}return me},parseOpera10:function(V){for(var re=/Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i,y=V.stacktrace.split(`
+`),me=[],De=0,ge=y.length;De<ge;De+=2){var ae=re.exec(y[De]);ae&&me.push(new k({functionName:ae[3]||void 0,fileName:ae[2],lineNumber:ae[1],source:y[De]}))}return me},parseOpera11:function(V){return V.stack.split(`
+`).filter(function(re){return!!re.match(x)&&!re.match(/^Error created at/)},this).map(function(re){var y,me=re.split("@"),De=this.extractLocation(me.pop()),ge=me.shift()||"",ae=ge.replace(/<anonymous function(: (\w+))?>/,"$2").replace(/\([^)]*\)/g,"")||void 0;ge.match(/\(([^)]*)\)/)&&(y=ge.replace(/^[^(]+\(([^)]*)\)$/,"$1"));var we=y===void 0||y==="[arguments not available]"?void 0:y.split(",");return new k({functionName:ae,args:we,fileName:De[0],lineNumber:De[1],columnNumber:De[2],source:re})},this)}}})=="function"?h.apply(l,E):h)===void 0||(o.exports=t)})()},function(o,l,f){var h,E,t;(function(N,F){"use strict";E=[],(t=typeof(h=function(){function k(ae){return ae.charAt(0).toUpperCase()+ae.substring(1)}function x(ae){return function(){return this[ae]}}var j=["isConstructor","isEval","isNative","isToplevel"],q=["columnNumber","lineNumber"],V=["fileName","functionName","source"],re=j.concat(q,V,["args"]);function y(ae){if(ae)for(var we=0;we<re.length;we++)ae[re[we]]!==void 0&&this["set"+k(re[we])](ae[re[we]])}y.prototype={getArgs:function(){return this.args},setArgs:function(ae){if(Object.prototype.toString.call(ae)!=="[object Array]")throw new TypeError("Args must be an Array");this.args=ae},getEvalOrigin:function(){return this.evalOrigin},setEvalOrigin:function(ae){if(ae instanceof y)this.evalOrigin=ae;else{if(!(ae instanceof Object))throw new TypeError("Eval Origin must be an Object or StackFrame");this.evalOrigin=new y(ae)}},toString:function(){var ae=this.getFileName()||"",we=this.getLineNumber()||"",he=this.getColumnNumber()||"",ve=this.getFunctionName()||"";return this.getIsEval()?ae?"[eval] ("+ae+":"+we+":"+he+")":"[eval]:"+we+":"+he:ve?ve+" ("+ae+":"+we+":"+he+")":ae+":"+we+":"+he}},y.fromString=function(ae){var we=ae.indexOf("("),he=ae.lastIndexOf(")"),ve=ae.substring(0,we),ue=ae.substring(we+1,he).split(","),Ae=ae.substring(he+1);if(Ae.indexOf("@")===0)var ze=/@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(Ae,""),We=ze[1],gt=ze[2],_t=ze[3];return new y({functionName:ve,args:ue||void 0,fileName:We,lineNumber:gt||void 0,columnNumber:_t||void 0})};for(var me=0;me<j.length;me++)y.prototype["get"+k(j[me])]=x(j[me]),y.prototype["set"+k(j[me])]=function(ae){return function(we){this[ae]=Boolean(we)}}(j[me]);for(var De=0;De<q.length;De++)y.prototype["get"+k(q[De])]=x(q[De]),y.prototype["set"+k(q[De])]=function(ae){return function(we){if(he=we,isNaN(parseFloat(he))||!isFinite(he))throw new TypeError(ae+" must be a Number");var he;this[ae]=Number(we)}}(q[De]);for(var ge=0;ge<V.length;ge++)y.prototype["get"+k(V[ge])]=x(V[ge]),y.prototype["set"+k(V[ge])]=function(ae){return function(we){this[ae]=String(we)}}(V[ge]);return y})=="function"?h.apply(l,E):h)===void 0||(o.exports=t)})()},function(o,l,f){"use strict";o.exports=f(19)},function(o,l,f){"use strict";function h(le){return(h=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(He){return typeof He}:function(He){return He&&typeof Symbol=="function"&&He.constructor===Symbol&&He!==Symbol.prototype?"symbol":typeof He})(le)}var E=f(1),t=60103,N=60106;l.Fragment=60107,l.StrictMode=60108,l.Profiler=60114;var F=60109,k=60110,x=60112;l.Suspense=60113,l.unstable_SuspenseList=60120;var j=60115,q=60116,V=60121;if(l.unstable_DebugTracingMode=60129,l.unstable_LegacyHidden=60131,typeof Symbol=="function"&&Symbol.for){var re=Symbol.for;t=re("react.element"),N=re("react.portal"),l.Fragment=re("react.fragment"),l.StrictMode=re("react.strict_mode"),l.Profiler=re("react.profiler"),F=re("react.provider"),k=re("react.context"),x=re("react.forward_ref"),l.Suspense=re("react.suspense"),l.unstable_SuspenseList=re("react.suspense_list"),j=re("react.memo"),q=re("react.lazy"),V=re("react.block"),l.unstable_DebugTracingMode=re("react.debug_trace_mode"),l.unstable_LegacyHidden=re("react.legacy_hidden")}var y=typeof Symbol=="function"&&Symbol.iterator;function me(le){for(var He="https://reactjs.org/docs/error-decoder.html?invariant="+le,dt=1;dt<arguments.length;dt++)He+="&args[]="+encodeURIComponent(arguments[dt]);return"Minified React error #"+le+"; visit "+He+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var De={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},ge={};function ae(le,He,dt){this.props=le,this.context=He,this.refs=ge,this.updater=dt||De}function we(){}function he(le,He,dt){this.props=le,this.context=He,this.refs=ge,this.updater=dt||De}ae.prototype.isReactComponent={},ae.prototype.setState=function(le,He){if(h(le)!=="object"&&typeof le!="function"&&le!=null)throw Error(me(85));this.updater.enqueueSetState(this,le,He,"setState")},ae.prototype.forceUpdate=function(le){this.updater.enqueueForceUpdate(this,le,"forceUpdate")},we.prototype=ae.prototype;var ve=he.prototype=new we;ve.constructor=he,E(ve,ae.prototype),ve.isPureReactComponent=!0;var ue={current:null},Ae=Object.prototype.hasOwnProperty,ze={key:!0,ref:!0,__self:!0,__source:!0};function We(le,He,dt){var At,nn={},an=null,On=null;if(He!=null)for(At in He.ref!==void 0&&(On=He.ref),He.key!==void 0&&(an=""+He.key),He)Ae.call(He,At)&&!ze.hasOwnProperty(At)&&(nn[At]=He[At]);var lr=arguments.length-2;if(lr===1)nn.children=dt;else if(1<lr){for(var ln=Array(lr),Vt=0;Vt<lr;Vt++)ln[Vt]=arguments[Vt+2];nn.children=ln}if(le&&le.defaultProps)for(At in lr=le.defaultProps)nn[At]===void 0&&(nn[At]=lr[At]);return{$$typeof:t,type:le,key:an,ref:On,props:nn,_owner:ue.current}}function gt(le){return h(le)==="object"&&le!==null&&le.$$typeof===t}var _t=/\/+/g;function Qe(le,He){return h(le)==="object"&&le!==null&&le.key!=null?function(dt){var At={"=":"=0",":":"=2"};return"$"+dt.replace(/[=:]/g,function(nn){return At[nn]})}(""+le.key):He.toString(36)}function ot(le,He,dt,At,nn){var an=h(le);an!=="undefined"&&an!=="boolean"||(le=null);var On=!1;if(le===null)On=!0;else switch(an){case"string":case"number":On=!0;break;case"object":switch(le.$$typeof){case t:case N:On=!0}}if(On)return nn=nn(On=le),le=At===""?"."+Qe(On,0):At,Array.isArray(nn)?(dt="",le!=null&&(dt=le.replace(_t,"$&/")+"/"),ot(nn,He,dt,"",function(Vt){return Vt})):nn!=null&&(gt(nn)&&(nn=function(Vt,Er){return{$$typeof:t,type:Vt.type,key:Er,ref:Vt.ref,props:Vt.props,_owner:Vt._owner}}(nn,dt+(!nn.key||On&&On.key===nn.key?"":(""+nn.key).replace(_t,"$&/")+"/")+le)),He.push(nn)),1;if(On=0,At=At===""?".":At+":",Array.isArray(le))for(var lr=0;lr<le.length;lr++){var ln=At+Qe(an=le[lr],lr);On+=ot(an,He,dt,ln,nn)}else if(typeof(ln=function(Vt){return Vt===null||h(Vt)!=="object"?null:typeof(Vt=y&&Vt[y]||Vt["@@iterator"])=="function"?Vt:null}(le))=="function")for(le=ln.call(le),lr=0;!(an=le.next()).done;)On+=ot(an=an.value,He,dt,ln=At+Qe(an,lr++),nn);else if(an==="object")throw He=""+le,Error(me(31,He==="[object Object]"?"object with keys {"+Object.keys(le).join(", ")+"}":He));return On}function Ve(le,He,dt){if(le==null)return le;var At=[],nn=0;return ot(le,At,"","",function(an){return He.call(dt,an,nn++)}),At}function Pt(le){if(le._status===-1){var He=le._result;He=He(),le._status=0,le._result=He,He.then(function(dt){le._status===0&&(dt=dt.default,le._status=1,le._result=dt)},function(dt){le._status===0&&(le._status=2,le._result=dt)})}if(le._status===1)return le._result;throw le._result}function Jt(le){return{$$typeof:V,_data:le.load.apply(null,le.args),_render:le.render}}var it={current:null};function J(){var le=it.current;if(le===null)throw Error(me(321));return le}var ce={transition:0},Re={ReactCurrentDispatcher:it,ReactCurrentBatchConfig:ce,ReactCurrentOwner:ue,IsSomeRendererActing:{current:!1},assign:E};l.Children={map:Ve,forEach:function(le,He,dt){Ve(le,function(){He.apply(this,arguments)},dt)},count:function(le){var He=0;return Ve(le,function(){He++}),He},toArray:function(le){return Ve(le,function(He){return He})||[]},only:function(le){if(!gt(le))throw Error(me(143));return le}},l.Component=ae,l.PureComponent=he,l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=Re,l.cloneElement=function(le,He,dt){if(le==null)throw Error(me(267,le));var At=E({},le.props),nn=le.key,an=le.ref,On=le._owner;if(He!=null){if(He.ref!==void 0&&(an=He.ref,On=ue.current),He.key!==void 0&&(nn=""+He.key),le.type&&le.type.defaultProps)var lr=le.type.defaultProps;for(ln in He)Ae.call(He,ln)&&!ze.hasOwnProperty(ln)&&(At[ln]=He[ln]===void 0&&lr!==void 0?lr[ln]:He[ln])}var ln=arguments.length-2;if(ln===1)At.children=dt;else if(1<ln){lr=Array(ln);for(var Vt=0;Vt<ln;Vt++)lr[Vt]=arguments[Vt+2];At.children=lr}return{$$typeof:t,type:le.type,key:nn,ref:an,props:At,_owner:On}},l.createContext=function(le,He){return He===void 0&&(He=null),(le={$$typeof:k,_calculateChangedBits:He,_currentValue:le,_currentValue2:le,_threadCount:0,Provider:null,Consumer:null}).Provider={$$typeof:F,_context:le},le.Consumer=le},l.createElement=We,l.createFactory=function(le){var He=We.bind(null,le);return He.type=le,He},l.createRef=function(){return{current:null}},l.forwardRef=function(le){return{$$typeof:x,render:le}},l.isValidElement=gt,l.lazy=function(le){return{$$typeof:q,_payload:{_status:-1,_result:le},_init:Pt}},l.memo=function(le,He){return{$$typeof:j,type:le,compare:He===void 0?null:He}},l.unstable_block=function(le,He){return He===void 0?function(){return{$$typeof:V,_data:void 0,_render:le}}:function(){return{$$typeof:q,_payload:{load:He,args:arguments,render:le},_init:Jt}}},l.unstable_createMutableSource=function(le,He){return{_getVersion:He,_source:le,_workInProgressVersionPrimary:null,_workInProgressVersionSecondary:null}},l.unstable_startTransition=function(le){var He=ce.transition;ce.transition=1;try{le()}finally{ce.transition=He}},l.unstable_useDeferredValue=function(le){return J().useDeferredValue(le)},l.unstable_useMutableSource=function(le,He,dt){return J().useMutableSource(le,He,dt)},l.unstable_useOpaqueIdentifier=function(){return J().useOpaqueIdentifier()},l.unstable_useTransition=function(){return J().useTransition()},l.useCallback=function(le,He){return J().useCallback(le,He)},l.useContext=function(le,He){return J().useContext(le,He)},l.useDebugValue=function(){},l.useEffect=function(le,He){return J().useEffect(le,He)},l.useImperativeHandle=function(le,He,dt){return J().useImperativeHandle(le,He,dt)},l.useLayoutEffect=function(le,He){return J().useLayoutEffect(le,He)},l.useMemo=function(le,He){return J().useMemo(le,He)},l.useReducer=function(le,He,dt){return J().useReducer(le,He,dt)},l.useRef=function(le){return J().useRef(le)},l.useState=function(le){return J().useState(le)},l.version="17.0.0-alpha.0-experimental-51a3aa6af"},function(o,l,f){"use strict";function h(U,H){for(var Y=0;Y<H.length;Y++){var ee=H[Y];ee.enumerable=ee.enumerable||!1,ee.configurable=!0,"value"in ee&&(ee.writable=!0),Object.defineProperty(U,ee.key,ee)}}f.r(l),f.d(l,"connectToDevTools",function(){return zi});var E=function(){function U(){var Ce,_e,Oe;(function($,Ne){if(!($ instanceof Ne))throw new TypeError("Cannot call a class as a function")})(this,U),Ce=this,_e="listenersMap",Oe=new Map,_e in Ce?Object.defineProperty(Ce,_e,{value:Oe,enumerable:!0,configurable:!0,writable:!0}):Ce[_e]=Oe}var H,Y,ee;return H=U,(Y=[{key:"addListener",value:function(Ce,_e){var Oe=this.listenersMap.get(Ce);Oe===void 0?this.listenersMap.set(Ce,[_e]):Oe.indexOf(_e)<0&&Oe.push(_e)}},{key:"emit",value:function(Ce){var _e=this.listenersMap.get(Ce);if(_e!==void 0){for(var Oe=arguments.length,$=new Array(Oe>1?Oe-1:0),Ne=1;Ne<Oe;Ne++)$[Ne-1]=arguments[Ne];if(_e.length===1){var Je=_e[0];Je.apply(null,$)}else{for(var vt=!1,oe=null,qe=Array.from(_e),rt=0;rt<qe.length;rt++){var xt=qe[rt];try{xt.apply(null,$)}catch(kt){oe===null&&(vt=!0,oe=kt)}}if(vt)throw oe}}}},{key:"removeAllListeners",value:function(){this.listenersMap.clear()}},{key:"removeListener",value:function(Ce,_e){var Oe=this.listenersMap.get(Ce);if(Oe!==void 0){var $=Oe.indexOf(_e);$>=0&&Oe.splice($,1)}}}])&&h(H.prototype,Y),ee&&h(H,ee),U}(),t=f(2),N=f.n(t);try{var F=f(9).default,k=function(U){var H=new RegExp("".concat(U,": ([0-9]+)")),Y=F.match(H);return parseInt(Y[1],10)};k("comfortable-line-height-data"),k("compact-line-height-data")}catch{}function x(U){try{return sessionStorage.getItem(U)}catch{return null}}function j(U){try{sessionStorage.removeItem(U)}catch{}}function q(U,H){try{return sessionStorage.setItem(U,H)}catch{}}var V=function(U,H){return U===H},re=f(1),y=f.n(re);function me(U){return U.ownerDocument?U.ownerDocument.defaultView:null}function De(U){var H=me(U);return H?H.frameElement:null}function ge(U){var H=he(U);return ae([U.getBoundingClientRect(),{top:H.borderTop,left:H.borderLeft,bottom:H.borderBottom,right:H.borderRight,width:0,height:0}])}function ae(U){return U.reduce(function(H,Y){return H==null?Y:{top:H.top+Y.top,left:H.left+Y.left,width:H.width,height:H.height,bottom:H.bottom+Y.bottom,right:H.right+Y.right}})}function we(U,H){var Y=De(U);if(Y&&Y!==H){for(var ee=[U.getBoundingClientRect()],Ce=Y,_e=!1;Ce;){var Oe=ge(Ce);if(ee.push(Oe),Ce=De(Ce),_e)break;Ce&&me(Ce)===H&&(_e=!0)}return ae(ee)}return U.getBoundingClientRect()}function he(U){var H=window.getComputedStyle(U);return{borderLeft:parseInt(H.borderLeftWidth,10),borderRight:parseInt(H.borderRightWidth,10),borderTop:parseInt(H.borderTopWidth,10),borderBottom:parseInt(H.borderBottomWidth,10),marginLeft:parseInt(H.marginLeft,10),marginRight:parseInt(H.marginRight,10),marginTop:parseInt(H.marginTop,10),marginBottom:parseInt(H.marginBottom,10),paddingLeft:parseInt(H.paddingLeft,10),paddingRight:parseInt(H.paddingRight,10),paddingTop:parseInt(H.paddingTop,10),paddingBottom:parseInt(H.paddingBottom,10)}}function ve(U,H){var Y;if(typeof Symbol>"u"||U[Symbol.iterator]==null){if(Array.isArray(U)||(Y=function(Ne,Je){if(!!Ne){if(typeof Ne=="string")return ue(Ne,Je);var vt=Object.prototype.toString.call(Ne).slice(8,-1);if(vt==="Object"&&Ne.constructor&&(vt=Ne.constructor.name),vt==="Map"||vt==="Set")return Array.from(Ne);if(vt==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(vt))return ue(Ne,Je)}}(U))||H&&U&&typeof U.length=="number"){Y&&(U=Y);var ee=0,Ce=function(){};return{s:Ce,n:function(){return ee>=U.length?{done:!0}:{done:!1,value:U[ee++]}},e:function(Ne){throw Ne},f:Ce}}throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var _e,Oe=!0,$=!1;return{s:function(){Y=U[Symbol.iterator]()},n:function(){var Ne=Y.next();return Oe=Ne.done,Ne},e:function(Ne){$=!0,_e=Ne},f:function(){try{Oe||Y.return==null||Y.return()}finally{if($)throw _e}}}}function ue(U,H){(H==null||H>U.length)&&(H=U.length);for(var Y=0,ee=new Array(H);Y<H;Y++)ee[Y]=U[Y];return ee}function Ae(U,H){if(!(U instanceof H))throw new TypeError("Cannot call a class as a function")}function ze(U,H){for(var Y=0;Y<H.length;Y++){var ee=H[Y];ee.enumerable=ee.enumerable||!1,ee.configurable=!0,"value"in ee&&(ee.writable=!0),Object.defineProperty(U,ee.key,ee)}}function We(U,H,Y){return H&&ze(U.prototype,H),Y&&ze(U,Y),U}var gt=function(){function U(H,Y){Ae(this,U),this.node=H.createElement("div"),this.border=H.createElement("div"),this.padding=H.createElement("div"),this.content=H.createElement("div"),this.border.style.borderColor=Ve.border,this.padding.style.borderColor=Ve.padding,this.content.style.backgroundColor=Ve.background,y()(this.node.style,{borderColor:Ve.margin,pointerEvents:"none",position:"fixed"}),this.node.style.zIndex="10000000",this.node.appendChild(this.border),this.border.appendChild(this.padding),this.padding.appendChild(this.content),Y.appendChild(this.node)}return We(U,[{key:"remove",value:function(){this.node.parentNode&&this.node.parentNode.removeChild(this.node)}},{key:"update",value:function(H,Y){ot(Y,"margin",this.node),ot(Y,"border",this.border),ot(Y,"padding",this.padding),y()(this.content.style,{height:H.height-Y.borderTop-Y.borderBottom-Y.paddingTop-Y.paddingBottom+"px",width:H.width-Y.borderLeft-Y.borderRight-Y.paddingLeft-Y.paddingRight+"px"}),y()(this.node.style,{top:H.top-Y.marginTop+"px",left:H.left-Y.marginLeft+"px"})}}]),U}(),_t=function(){function U(H,Y){Ae(this,U),this.tip=H.createElement("div"),y()(this.tip.style,{display:"flex",flexFlow:"row nowrap",backgroundColor:"#333740",borderRadius:"2px",fontFamily:'"SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace',fontWeight:"bold",padding:"3px 5px",pointerEvents:"none",position:"fixed",fontSize:"12px",whiteSpace:"nowrap"}),this.nameSpan=H.createElement("span"),this.tip.appendChild(this.nameSpan),y()(this.nameSpan.style,{color:"#ee78e6",borderRight:"1px solid #aaaaaa",paddingRight:"0.5rem",marginRight:"0.5rem"}),this.dimSpan=H.createElement("span"),this.tip.appendChild(this.dimSpan),y()(this.dimSpan.style,{color:"#d7d7d7"}),this.tip.style.zIndex="10000000",Y.appendChild(this.tip)}return We(U,[{key:"remove",value:function(){this.tip.parentNode&&this.tip.parentNode.removeChild(this.tip)}},{key:"updateText",value:function(H,Y,ee){this.nameSpan.textContent=H,this.dimSpan.textContent=Math.round(Y)+"px \xD7 "+Math.round(ee)+"px"}},{key:"updatePosition",value:function(H,Y){var ee=this.tip.getBoundingClientRect(),Ce=function(_e,Oe,$){var Ne,Je=Math.max($.height,20),vt=Math.max($.width,60);Ne=_e.top+_e.height+Je<=Oe.top+Oe.height?_e.top+_e.height<Oe.top+0?Oe.top+5:_e.top+_e.height+5:_e.top-Je<=Oe.top+Oe.height?_e.top-Je-5<Oe.top+5?Oe.top+5:_e.top-Je-5:Oe.top+Oe.height-Je-5;var oe=_e.left+5;return _e.left<Oe.left&&(oe=Oe.left+5),_e.left+vt>Oe.left+Oe.width&&(oe=Oe.left+Oe.width-vt-5),{style:{top:Ne+="px",left:oe+="px"}}}(H,Y,{width:ee.width,height:ee.height});y()(this.tip.style,Ce.style)}}]),U}(),Qe=function(){function U(){Ae(this,U);var H=window.__REACT_DEVTOOLS_TARGET_WINDOW__||window;this.window=H;var Y=window.__REACT_DEVTOOLS_TARGET_WINDOW__||window;this.tipBoundsWindow=Y;var ee=H.document;this.container=ee.createElement("div"),this.container.style.zIndex="10000000",this.tip=new _t(ee,this.container),this.rects=[],ee.body.appendChild(this.container)}return We(U,[{key:"remove",value:function(){this.tip.remove(),this.rects.forEach(function(H){H.remove()}),this.rects.length=0,this.container.parentNode&&this.container.parentNode.removeChild(this.container)}},{key:"inspect",value:function(H,Y){for(var ee=this,Ce=H.filter(function(xt){return xt.nodeType===Node.ELEMENT_NODE});this.rects.length>Ce.length;)this.rects.pop().remove();if(Ce.length!==0){for(;this.rects.length<Ce.length;)this.rects.push(new gt(this.window.document,this.container));var _e={top:Number.POSITIVE_INFINITY,right:Number.NEGATIVE_INFINITY,bottom:Number.NEGATIVE_INFINITY,left:Number.POSITIVE_INFINITY};if(Ce.forEach(function(xt,kt){var bt=we(xt,ee.window),sn=he(xt);_e.top=Math.min(_e.top,bt.top-sn.marginTop),_e.right=Math.max(_e.right,bt.left+bt.width+sn.marginRight),_e.bottom=Math.max(_e.bottom,bt.top+bt.height+sn.marginBottom),_e.left=Math.min(_e.left,bt.left-sn.marginLeft),ee.rects[kt].update(bt,sn)}),!Y){Y=Ce[0].nodeName.toLowerCase();var Oe=Ce[0],$=Oe.ownerDocument.defaultView.__REACT_DEVTOOLS_GLOBAL_HOOK__;if($!=null&&$.rendererInterfaces!=null){var Ne,Je=null,vt=ve($.rendererInterfaces.values());try{for(vt.s();!(Ne=vt.n()).done;){var oe=Ne.value,qe=oe.getFiberIDForNative(Oe,!0);if(qe!==null){Je=oe.getDisplayNameForFiberID(qe,!0);break}}}catch(xt){vt.e(xt)}finally{vt.f()}Je&&(Y+=" (in "+Je+")")}}this.tip.updateText(Y,_e.right-_e.left,_e.bottom-_e.top);var rt=we(this.tipBoundsWindow.document.documentElement,this.window);this.tip.updatePosition({top:_e.top,left:_e.left,height:_e.bottom-_e.top,width:_e.right-_e.left},{top:rt.top+this.tipBoundsWindow.scrollY,left:rt.left+this.tipBoundsWindow.scrollX,height:this.tipBoundsWindow.innerHeight,width:this.tipBoundsWindow.innerWidth})}}}]),U}();function ot(U,H,Y){y()(Y.style,{borderTopWidth:U[H+"Top"]+"px",borderLeftWidth:U[H+"Left"]+"px",borderRightWidth:U[H+"Right"]+"px",borderBottomWidth:U[H+"Bottom"]+"px",borderStyle:"solid"})}var Ve={background:"rgba(120, 170, 210, 0.7)",padding:"rgba(77, 200, 0, 0.3)",margin:"rgba(255, 155, 0, 0.3)",border:"rgba(255, 200, 50, 0.3)"},Pt=null,Jt=null;function it(){Pt=null,Jt!==null&&(Jt.remove(),Jt=null)}function J(U,H,Y){window.document!=null&&(Pt!==null&&clearTimeout(Pt),U!=null&&(Jt===null&&(Jt=new Qe),Jt.inspect(U,H),Y&&(Pt=setTimeout(it,2e3))))}var ce=new Set;function Re(U,H){function Y(oe){oe&&typeof oe.addEventListener=="function"&&(oe.addEventListener("click",_e,!0),oe.addEventListener("mousedown",Oe,!0),oe.addEventListener("mouseover",Oe,!0),oe.addEventListener("mouseup",Oe,!0),oe.addEventListener("pointerdown",$,!0),oe.addEventListener("pointerover",Ne,!0),oe.addEventListener("pointerup",Je,!0))}function ee(){it(),Ce(window),ce.forEach(function(oe){try{Ce(oe.contentWindow)}catch{}}),ce=new Set}function Ce(oe){oe&&typeof oe.removeEventListener=="function"&&(oe.removeEventListener("click",_e,!0),oe.removeEventListener("mousedown",Oe,!0),oe.removeEventListener("mouseover",Oe,!0),oe.removeEventListener("mouseup",Oe,!0),oe.removeEventListener("pointerdown",$,!0),oe.removeEventListener("pointerover",Ne,!0),oe.removeEventListener("pointerup",Je,!0))}function _e(oe){oe.preventDefault(),oe.stopPropagation(),ee(),U.send("stopInspectingNative",!0)}function Oe(oe){oe.preventDefault(),oe.stopPropagation()}function $(oe){oe.preventDefault(),oe.stopPropagation(),vt(oe.target)}function Ne(oe){oe.preventDefault(),oe.stopPropagation();var qe=oe.target;if(qe.tagName==="IFRAME"){var rt=qe;try{ce.has(rt)||(Y(rt.contentWindow),ce.add(rt))}catch{}}J([qe],null,!1),vt(qe)}function Je(oe){oe.preventDefault(),oe.stopPropagation()}U.addListener("clearNativeElementHighlight",function(){it()}),U.addListener("highlightNativeElement",function(oe){var qe=oe.displayName,rt=oe.hideAfterTimeout,xt=oe.id,kt=oe.openNativeElementsPanel,bt=oe.rendererID,sn=oe.scrollIntoView,rn=H.rendererInterfaces[bt];rn==null&&console.warn('Invalid renderer id "'.concat(bt,'" for element "').concat(xt,'"'));var Ft=null;if(rn!=null&&(Ft=rn.findNativeNodesForFiberID(xt)),Ft!=null&&Ft[0]!=null){var Dn=Ft[0];sn&&typeof Dn.scrollIntoView=="function"&&Dn.scrollIntoView({block:"nearest",inline:"nearest"}),J(Ft,qe,rt),kt&&(window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0=Dn,U.send("syncSelectionToNativeElementsPanel"))}else it()}),U.addListener("shutdown",ee),U.addListener("startInspectingNative",function(){Y(window)}),U.addListener("stopInspectingNative",ee);var vt=N()(function(oe){var qe=arguments.length>1&&arguments[1]!==void 0?arguments[1]:V,rt=void 0,xt=[],kt=void 0,bt=!1,sn=function(Ft,Dn){return qe(Ft,xt[Dn])},rn=function(){for(var Ft=arguments.length,Dn=Array(Ft),dr=0;dr<Ft;dr++)Dn[dr]=arguments[dr];return bt&&rt===this&&Dn.length===xt.length&&Dn.every(sn)?kt:(bt=!0,rt=this,xt=Dn,kt=oe.apply(this,Dn))};return rn}(function(oe){var qe=H.getIDForNode(oe);qe!==null&&U.send("selectFiber",qe)}),200,{leading:!1})}var le=["#37afa9","#63b19e","#80b393","#97b488","#abb67d","#beb771","#cfb965","#dfba57","#efbb49","#febc38"],He=null;function dt(U){He===null&&function(){(He=window.document.createElement("canvas")).style.cssText=`
+    xx-background-color: red;
+    xx-opacity: 0.5;
+    bottom: 0;
+    left: 0;
+    pointer-events: none;
+    position: fixed;
+    right: 0;
+    top: 0;
+    z-index: 1000000000;
+  `;var ee=window.document.documentElement;ee.insertBefore(He,ee.firstChild)}();var H=He;H.width=window.innerWidth,H.height=window.innerHeight;var Y=H.getContext("2d");Y.clearRect(0,0,H.width,H.height),U.forEach(function(ee){var Ce=ee.count,_e=ee.rect;if(_e!==null){var Oe=Math.min(le.length-1,Ce-1);(function($,Ne,Je){var vt=Ne.height,oe=Ne.left,qe=Ne.top,rt=Ne.width;$.lineWidth=1,$.strokeStyle="#f0f0f0",$.strokeRect(oe-1,qe-1,rt+2,vt+2),$.lineWidth=1,$.strokeStyle="#f0f0f0",$.strokeRect(oe+1,qe+1,rt-1,vt-1),$.strokeStyle=Je,$.setLineDash([0]),$.lineWidth=1,$.strokeRect(oe,qe,rt-1,vt-1),$.setLineDash([0])})(Y,_e,le[Oe])}})}function At(U){return(At=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}var nn=(typeof performance>"u"?"undefined":At(performance))==="object"&&typeof performance.now=="function"?function(){return performance.now()}:function(){return Date.now()},an=new Map,On=null,lr=!1,ln=null;function Vt(U){(lr=U)||(an.clear(),On!==null&&(cancelAnimationFrame(On),On=null),ln!==null&&(clearTimeout(ln),ln=null),He!==null&&(He.parentNode!=null&&He.parentNode.removeChild(He),He=null))}function Er(U){lr&&(U.forEach(function(H){var Y=an.get(H),ee=nn(),Ce=Y!=null?Y.lastMeasuredAt:0,_e=Y!=null?Y.rect:null;(_e===null||Ce+250<ee)&&(Ce=ee,_e=function(Oe){if(!Oe||typeof Oe.getBoundingClientRect!="function")return null;var $=window.__REACT_DEVTOOLS_TARGET_WINDOW__||window;return we(Oe,$)}(H)),an.set(H,{count:Y!=null?Y.count+1:1,expirationTime:Y!=null?Math.min(ee+3e3,Y.expirationTime+250):ee+250,lastMeasuredAt:Ce,rect:_e})}),ln!==null&&(clearTimeout(ln),ln=null),On===null&&(On=requestAnimationFrame(S)))}function S(){On=null,ln=null;var U=nn(),H=Number.MAX_VALUE;an.forEach(function(Y,ee){Y.expirationTime<U?an.delete(ee):H=Math.min(H,Y.expirationTime)}),dt(an),H!==Number.MAX_VALUE&&(ln=setTimeout(S,H-U))}var zt=f(3),Xn=f(6),vr=f.n(Xn),jr=f(0),fr=60120;if(typeof Symbol=="function"&&Symbol.for){var zr=Symbol.for;zr("react.element"),zr("react.portal"),zr("react.fragment"),zr("react.strict_mode"),zr("react.profiler"),zr("react.provider"),zr("react.context"),zr("react.forward_ref"),zr("react.suspense"),fr=zr("react.suspense_list"),zr("react.memo"),zr("react.lazy"),zr("react.block"),zr("react.server.block"),zr("react.fundamental"),zr("react.scope"),zr("react.opaque.id"),zr("react.debug_trace_mode"),zr("react.offscreen"),zr("react.legacy_hidden")}function Xt(U){return(Xt=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}var Du={inspectable:Symbol("inspectable"),inspected:Symbol("inspected"),name:Symbol("name"),preview_long:Symbol("preview_long"),preview_short:Symbol("preview_short"),readonly:Symbol("readonly"),size:Symbol("size"),type:Symbol("type"),unserializable:Symbol("unserializable")};function c0(U,H,Y,ee,Ce){ee.push(Ce);var _e={inspectable:H,type:U,preview_long:ki(Y,!0),preview_short:ki(Y,!1),name:Y.constructor&&Y.constructor.name!=="Object"?Y.constructor.name:""};return U==="array"||U==="typed_array"?_e.size=Y.length:U==="object"&&(_e.size=Object.keys(Y).length),U!=="iterator"&&U!=="typed_array"||(_e.readonly=!0),_e}function Ao(U,H,Y,ee,Ce){var _e,Oe=arguments.length>5&&arguments[5]!==void 0?arguments[5]:0,$=Mo(U);switch($){case"html_element":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:U.tagName,type:$};case"function":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:typeof U.name!="function"&&U.name?U.name:"function",type:$};case"string":return U.length<=500?U:U.slice(0,500)+"...";case"bigint":case"symbol":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:U.toString(),type:$};case"react_element":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:F0(U)||"Unknown",type:$};case"array_buffer":case"data_view":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:$==="data_view"?"DataView":"ArrayBuffer",size:U.byteLength,type:$};case"array":return _e=Ce(ee),Oe>=2&&!_e?c0($,!0,U,H,ee):U.map(function(vt,oe){return Ao(vt,H,Y,ee.concat([oe]),Ce,_e?1:Oe+1)});case"html_all_collection":case"typed_array":case"iterator":if(_e=Ce(ee),Oe>=2&&!_e)return c0($,!0,U,H,ee);var Ne={unserializable:!0,type:$,readonly:!0,size:$==="typed_array"?U.length:void 0,preview_short:ki(U,!1),preview_long:ki(U,!0),name:U.constructor&&U.constructor.name!=="Object"?U.constructor.name:""};return Xt(U[Symbol.iterator])&&Array.from(U).forEach(function(vt,oe){return Ne[oe]=Ao(vt,H,Y,ee.concat([oe]),Ce,_e?1:Oe+1)}),Y.push(ee),Ne;case"opaque_iterator":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:U[Symbol.toStringTag],type:$};case"date":case"regexp":return H.push(ee),{inspectable:!1,preview_short:ki(U,!1),preview_long:ki(U,!0),name:U.toString(),type:$};case"object":if(_e=Ce(ee),Oe>=2&&!_e)return c0($,!0,U,H,ee);var Je={};return lu(U).forEach(function(vt){var oe=vt.toString();Je[oe]=Ao(U[vt],H,Y,ee.concat([oe]),Ce,_e?1:Oe+1)}),Je;case"infinity":case"nan":case"undefined":return H.push(ee),{type:$};default:return U}}function Jo(U){return(Jo=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function Fs(U){return function(H){if(Array.isArray(H))return Zo(H)}(U)||function(H){if(typeof Symbol<"u"&&Symbol.iterator in Object(H))return Array.from(H)}(U)||function(H,Y){if(!!H){if(typeof H=="string")return Zo(H,Y);var ee=Object.prototype.toString.call(H).slice(8,-1);if(ee==="Object"&&H.constructor&&(ee=H.constructor.name),ee==="Map"||ee==="Set")return Array.from(H);if(ee==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(ee))return Zo(H,Y)}}(U)||function(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}()}function Zo(U,H){(H==null||H>U.length)&&(H=U.length);for(var Y=0,ee=new Array(H);Y<H;Y++)ee[Y]=U[Y];return ee}var $o=new WeakMap,qt=new vr.a({max:1e3});function xi(U,H){return U.toString()>H.toString()?1:H.toString()>U.toString()?-1:0}function lu(U){for(var H=[],Y=U,ee=function(){var Ce=[].concat(Fs(Object.keys(Y)),Fs(Object.getOwnPropertySymbols(Y))),_e=Object.getOwnPropertyDescriptors(Y);Ce.forEach(function(Oe){_e[Oe].enumerable&&H.push(Oe)}),Y=Object.getPrototypeOf(Y)};Y!=null;)ee();return H}function vi(U){var H=arguments.length>1&&arguments[1]!==void 0?arguments[1]:"Anonymous",Y=$o.get(U);if(Y!=null)return Y;var ee=H;return typeof U.displayName=="string"?ee=U.displayName:typeof U.name=="string"&&U.name!==""&&(ee=U.name),$o.set(U,ee),ee}var Dr=0;function el(){return++Dr}function Y0(U){var H=qt.get(U);if(H!==void 0)return H;for(var Y=new Array(U.length),ee=0;ee<U.length;ee++)Y[ee]=U.codePointAt(ee);return qt.set(U,Y),Y}function Bu(U,H){return H.reduce(function(Y,ee){if(Y){if(hasOwnProperty.call(Y,ee))return Y[ee];if(typeof Y[Symbol.iterator]=="function")return Array.from(Y)[ee]}return null},U)}function K0(U,H){var Y=H.length,ee=H[Y-1];if(U!=null){var Ce=Bu(U,H.slice(0,Y-1));Ce&&(Array.isArray(Ce)?Ce.splice(ee,1):delete Ce[ee])}}function Kr(U,H,Y){var ee=H.length;if(U!=null){var Ce=Bu(U,H.slice(0,ee-1));if(Ce){var _e=H[ee-1];Ce[Y[ee-1]]=Ce[_e],Array.isArray(Ce)?Ce.splice(_e,1):delete Ce[_e]}}}function Oo(U,H,Y){var ee=H.length,Ce=H[ee-1];if(U!=null){var _e=Bu(U,H.slice(0,ee-1));_e&&(_e[Ce]=Y)}}function Mo(U){if(U===null)return"null";if(U===void 0)return"undefined";if(Object(jr.isElement)(U))return"react_element";if(typeof HTMLElement<"u"&&U instanceof HTMLElement)return"html_element";switch(Jo(U)){case"bigint":return"bigint";case"boolean":return"boolean";case"function":return"function";case"number":return Number.isNaN(U)?"nan":Number.isFinite(U)?"number":"infinity";case"object":if(Array.isArray(U))return"array";if(ArrayBuffer.isView(U))return hasOwnProperty.call(U.constructor,"BYTES_PER_ELEMENT")?"typed_array":"data_view";if(U.constructor&&U.constructor.name==="ArrayBuffer")return"array_buffer";if(typeof U[Symbol.iterator]=="function")return U[Symbol.iterator]()===U?"opaque_iterator":"iterator";if(U.constructor&&U.constructor.name==="RegExp")return"regexp";var H=Object.prototype.toString.call(U);return H==="[object Date]"?"date":H==="[object HTMLAllCollection]"?"html_all_collection":"object";case"string":return"string";case"symbol":return"symbol";case"undefined":return Object.prototype.toString.call(U)==="[object HTMLAllCollection]"?"html_all_collection":"undefined";default:return"unknown"}}function F0(U){switch(Object(jr.typeOf)(U)){case jr.ContextConsumer:return"ContextConsumer";case jr.ContextProvider:return"ContextProvider";case jr.ForwardRef:return"ForwardRef";case jr.Fragment:return"Fragment";case jr.Lazy:return"Lazy";case jr.Memo:return"Memo";case jr.Portal:return"Portal";case jr.Profiler:return"Profiler";case jr.StrictMode:return"StrictMode";case jr.Suspense:return"Suspense";case fr:return"SuspenseList";default:var H=U.type;return typeof H=="string"?H:typeof H=="function"?vi(H,"Anonymous"):H!=null?"NotImplementedInDevtools":"Element"}}function su(U){var H=arguments.length>1&&arguments[1]!==void 0?arguments[1]:50;return U.length>H?U.substr(0,H)+"\u2026":U}function ki(U,H){if(U!=null&&hasOwnProperty.call(U,Du.type))return H?U[Du.preview_long]:U[Du.preview_short];switch(Mo(U)){case"html_element":return"<".concat(su(U.tagName.toLowerCase())," />");case"function":return su("\u0192 ".concat(typeof U.name=="function"?"":U.name,"() {}"));case"string":return'"'.concat(U,'"');case"bigint":return su(U.toString()+"n");case"regexp":case"symbol":return su(U.toString());case"react_element":return"<".concat(su(F0(U)||"Unknown")," />");case"array_buffer":return"ArrayBuffer(".concat(U.byteLength,")");case"data_view":return"DataView(".concat(U.buffer.byteLength,")");case"array":if(H){for(var Y="",ee=0;ee<U.length&&(ee>0&&(Y+=", "),!((Y+=ki(U[ee],!1)).length>50));ee++);return"[".concat(su(Y),"]")}var Ce=hasOwnProperty.call(U,Du.size)?U[Du.size]:U.length;return"Array(".concat(Ce,")");case"typed_array":var _e="".concat(U.constructor.name,"(").concat(U.length,")");if(H){for(var Oe="",$=0;$<U.length&&($>0&&(Oe+=", "),!((Oe+=U[$]).length>50));$++);return"".concat(_e," [").concat(su(Oe),"]")}return _e;case"iterator":var Ne=U.constructor.name;if(H){for(var Je=Array.from(U),vt="",oe=0;oe<Je.length;oe++){var qe=Je[oe];if(oe>0&&(vt+=", "),Array.isArray(qe)){var rt=ki(qe[0],!0),xt=ki(qe[1],!1);vt+="".concat(rt," => ").concat(xt)}else vt+=ki(qe,!1);if(vt.length>50)break}return"".concat(Ne,"(").concat(U.size,") {").concat(su(vt),"}")}return"".concat(Ne,"(").concat(U.size,")");case"opaque_iterator":return U[Symbol.toStringTag];case"date":return U.toString();case"object":if(H){for(var kt=lu(U).sort(xi),bt="",sn=0;sn<kt.length;sn++){var rn=kt[sn];if(sn>0&&(bt+=", "),(bt+="".concat(rn.toString(),": ").concat(ki(U[rn],!1))).length>50)break}return"{".concat(su(bt),"}")}return"{\u2026}";case"boolean":case"number":case"infinity":case"nan":case"null":case"undefined":return U;default:try{return su(""+U)}catch{return"unserializable"}}}var Ps=f(7);function Kl(U){return(Kl=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function P0(U,H){var Y=Object.keys(U);if(Object.getOwnPropertySymbols){var ee=Object.getOwnPropertySymbols(U);H&&(ee=ee.filter(function(Ce){return Object.getOwnPropertyDescriptor(U,Ce).enumerable})),Y.push.apply(Y,ee)}return Y}function d0(U){for(var H=1;H<arguments.length;H++){var Y=arguments[H]!=null?arguments[H]:{};H%2?P0(Object(Y),!0).forEach(function(ee){Hr(U,ee,Y[ee])}):Object.getOwnPropertyDescriptors?Object.defineProperties(U,Object.getOwnPropertyDescriptors(Y)):P0(Object(Y)).forEach(function(ee){Object.defineProperty(U,ee,Object.getOwnPropertyDescriptor(Y,ee))})}return U}function Hr(U,H,Y){return H in U?Object.defineProperty(U,H,{value:Y,enumerable:!0,configurable:!0,writable:!0}):U[H]=Y,U}function Ri(U,H){var Y=arguments.length>2&&arguments[2]!==void 0?arguments[2]:[];if(U!==null){var ee=[],Ce=[],_e=Ao(U,ee,Ce,Y,H);return{data:_e,cleaned:ee,unserializable:Ce}}return null}function X0(U){var H,Y,ee=(H=U,Y=new Set,JSON.stringify(H,function(Oe,$){if(Kl($)==="object"&&$!==null){if(Y.has($))return;Y.add($)}return typeof $=="bigint"?$.toString()+"n":$})),Ce=ee===void 0?"undefined":ee,_e=window.__REACT_DEVTOOLS_GLOBAL_HOOK__.clipboardCopyText;typeof _e=="function"?_e(Ce).catch(function(Oe){}):Object(Ps.copy)(Ce)}function mi(U,H){var Y=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,ee=H[Y],Ce=Array.isArray(U)?U.slice():d0({},U);return Y+1===H.length?Array.isArray(Ce)?Ce.splice(ee,1):delete Ce[ee]:Ce[ee]=mi(U[ee],H,Y+1),Ce}function en(U,H,Y){var ee=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,Ce=H[ee],_e=Array.isArray(U)?U.slice():d0({},U);if(ee+1===H.length){var Oe=Y[ee];_e[Oe]=_e[Ce],Array.isArray(_e)?_e.splice(Ce,1):delete _e[Ce]}else _e[Ce]=en(U[Ce],H,Y,ee+1);return _e}function In(U,H,Y){var ee=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;if(ee>=H.length)return Y;var Ce=H[ee],_e=Array.isArray(U)?U.slice():d0({},U);return _e[Ce]=In(U[Ce],H,Y,ee+1),_e}var Ai=f(8);function yi(U,H){var Y=Object.keys(U);if(Object.getOwnPropertySymbols){var ee=Object.getOwnPropertySymbols(U);H&&(ee=ee.filter(function(Ce){return Object.getOwnPropertyDescriptor(U,Ce).enumerable})),Y.push.apply(Y,ee)}return Y}function Wt(U){for(var H=1;H<arguments.length;H++){var Y=arguments[H]!=null?arguments[H]:{};H%2?yi(Object(Y),!0).forEach(function(ee){Ru(U,ee,Y[ee])}):Object.getOwnPropertyDescriptors?Object.defineProperties(U,Object.getOwnPropertyDescriptors(Y)):yi(Object(Y)).forEach(function(ee){Object.defineProperty(U,ee,Object.getOwnPropertyDescriptor(Y,ee))})}return U}function Ru(U,H,Y){return H in U?Object.defineProperty(U,H,{value:Y,enumerable:!0,configurable:!0,writable:!0}):U[H]=Y,U}function eu(U){return function(H){if(Array.isArray(H))return ko(H)}(U)||function(H){if(typeof Symbol<"u"&&Symbol.iterator in Object(H))return Array.from(H)}(U)||Xl(U)||function(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}()}function Q0(U,H){return function(Y){if(Array.isArray(Y))return Y}(U)||function(Y,ee){if(!(typeof Symbol>"u"||!(Symbol.iterator in Object(Y)))){var Ce=[],_e=!0,Oe=!1,$=void 0;try{for(var Ne,Je=Y[Symbol.iterator]();!(_e=(Ne=Je.next()).done)&&(Ce.push(Ne.value),!ee||Ce.length!==ee);_e=!0);}catch(vt){Oe=!0,$=vt}finally{try{_e||Je.return==null||Je.return()}finally{if(Oe)throw $}}return Ce}}(U,H)||Xl(U,H)||function(){throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}()}function Yi(U,H){var Y;if(typeof Symbol>"u"||U[Symbol.iterator]==null){if(Array.isArray(U)||(Y=Xl(U))||H&&U&&typeof U.length=="number"){Y&&(U=Y);var ee=0,Ce=function(){};return{s:Ce,n:function(){return ee>=U.length?{done:!0}:{done:!1,value:U[ee++]}},e:function(Ne){throw Ne},f:Ce}}throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var _e,Oe=!0,$=!1;return{s:function(){Y=U[Symbol.iterator]()},n:function(){var Ne=Y.next();return Oe=Ne.done,Ne},e:function(Ne){$=!0,_e=Ne},f:function(){try{Oe||Y.return==null||Y.return()}finally{if($)throw _e}}}}function Xl(U,H){if(U){if(typeof U=="string")return ko(U,H);var Y=Object.prototype.toString.call(U).slice(8,-1);return Y==="Object"&&U.constructor&&(Y=U.constructor.name),Y==="Map"||Y==="Set"?Array.from(U):Y==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(Y)?ko(U,H):void 0}}function ko(U,H){(H==null||H>U.length)&&(H=U.length);for(var Y=0,ee=new Array(H);Y<H;Y++)ee[Y]=U[Y];return ee}function li(U){return(li=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function ao(U){return U.flags!==void 0?U.flags:U.effectTag}var Ql=(typeof performance>"u"?"undefined":li(performance))==="object"&&typeof performance.now=="function"?function(){return performance.now()}:function(){return Date.now()};function No(U){var H=null;function Y(rn){var Ft=li(rn)==="object"&&rn!==null?rn.$$typeof:rn;return li(Ft)==="symbol"?Ft.toString():Ft}var ee=H=Object(zt.gte)(U,"17.0.0-alpha")?{Block:22,ClassComponent:1,ContextConsumer:9,ContextProvider:10,CoroutineComponent:-1,CoroutineHandlerPhase:-1,DehydratedSuspenseComponent:18,ForwardRef:11,Fragment:7,FunctionComponent:0,HostComponent:5,HostPortal:4,HostRoot:3,HostText:6,IncompleteClassComponent:17,IndeterminateComponent:2,LazyComponent:16,MemoComponent:14,Mode:8,OffscreenComponent:23,Profiler:12,SimpleMemoComponent:15,SuspenseComponent:13,SuspenseListComponent:19,YieldComponent:-1}:Object(zt.gte)(U,"16.6.0-beta.0")?{Block:22,ClassComponent:1,ContextConsumer:9,ContextProvider:10,CoroutineComponent:-1,CoroutineHandlerPhase:-1,DehydratedSuspenseComponent:18,ForwardRef:11,Fragment:7,FunctionComponent:0,HostComponent:5,HostPortal:4,HostRoot:3,HostText:6,IncompleteClassComponent:17,IndeterminateComponent:2,LazyComponent:16,MemoComponent:14,Mode:8,OffscreenComponent:-1,Profiler:12,SimpleMemoComponent:15,SuspenseComponent:13,SuspenseListComponent:19,YieldComponent:-1}:Object(zt.gte)(U,"16.4.3-alpha")?{Block:-1,ClassComponent:2,ContextConsumer:11,ContextProvider:12,CoroutineComponent:-1,CoroutineHandlerPhase:-1,DehydratedSuspenseComponent:-1,ForwardRef:13,Fragment:9,FunctionComponent:0,HostComponent:7,HostPortal:6,HostRoot:5,HostText:8,IncompleteClassComponent:-1,IndeterminateComponent:4,LazyComponent:-1,MemoComponent:-1,Mode:10,OffscreenComponent:-1,Profiler:15,SimpleMemoComponent:-1,SuspenseComponent:16,SuspenseListComponent:-1,YieldComponent:-1}:{Block:-1,ClassComponent:2,ContextConsumer:12,ContextProvider:13,CoroutineComponent:7,CoroutineHandlerPhase:8,DehydratedSuspenseComponent:-1,ForwardRef:14,Fragment:10,FunctionComponent:1,HostComponent:5,HostPortal:4,HostRoot:3,HostText:6,IncompleteClassComponent:-1,IndeterminateComponent:0,LazyComponent:-1,MemoComponent:-1,Mode:11,OffscreenComponent:-1,Profiler:15,SimpleMemoComponent:-1,SuspenseComponent:16,SuspenseListComponent:-1,YieldComponent:9},Ce=ee.ClassComponent,_e=ee.IncompleteClassComponent,Oe=ee.FunctionComponent,$=ee.IndeterminateComponent,Ne=ee.ForwardRef,Je=ee.HostRoot,vt=ee.HostComponent,oe=ee.HostPortal,qe=ee.HostText,rt=ee.Fragment,xt=ee.MemoComponent,kt=ee.SimpleMemoComponent,bt=ee.SuspenseComponent,sn=ee.SuspenseListComponent;return{getDisplayNameForFiber:function(rn){var Ft=rn.type,Dn=rn.tag,dr=Ft;li(Ft)==="object"&&Ft!==null&&(dr=function Cr(Rn){switch(Y(Rn)){case 60115:case"Symbol(react.memo)":return Cr(Rn.type);case 60112:case"Symbol(react.forward_ref)":return Rn.render;default:return Rn}}(Ft));var er=null;switch(Dn){case Ce:case _e:return vi(dr);case Oe:case $:return vi(dr);case Ne:return Ft&&Ft.displayName||vi(dr,"Anonymous");case Je:return null;case vt:return Ft;case oe:case qe:case rt:return null;case xt:case kt:return vi(dr,"Anonymous");case bt:return"Suspense";case sn:return"SuspenseList";default:switch(Y(Ft)){case 60111:case"Symbol(react.concurrent_mode)":case"Symbol(react.async_mode)":return null;case 60109:case"Symbol(react.provider)":return er=rn.type._context||rn.type.context,"".concat(er.displayName||"Context",".Provider");case 60110:case"Symbol(react.context)":return er=rn.type._context||rn.type,"".concat(er.displayName||"Context",".Consumer");case 60108:case"Symbol(react.strict_mode)":return null;case 60114:case"Symbol(react.profiler)":return"Profiler(".concat(rn.memoizedProps.id,")");case 60119:case"Symbol(react.scope)":return"Scope";default:return null}}},getTypeSymbol:Y,ReactPriorityLevels:{ImmediatePriority:99,UserBlockingPriority:98,NormalPriority:97,LowPriority:96,IdlePriority:95,NoPriority:90},ReactTypeOfWork:H,ReactTypeOfSideEffect:{NoFlags:0,PerformedWork:1,Placement:2}}}function Is(U,H,Y,ee){var Ce=No(Y.version),_e=Ce.getDisplayNameForFiber,Oe=Ce.getTypeSymbol,$=Ce.ReactPriorityLevels,Ne=Ce.ReactTypeOfWork,Je=Ce.ReactTypeOfSideEffect,vt=Je.NoFlags,oe=Je.PerformedWork,qe=Je.Placement,rt=Ne.FunctionComponent,xt=Ne.ClassComponent,kt=Ne.ContextConsumer,bt=Ne.DehydratedSuspenseComponent,sn=Ne.Fragment,rn=Ne.ForwardRef,Ft=Ne.HostRoot,Dn=Ne.HostPortal,dr=Ne.HostComponent,er=Ne.HostText,Cr=Ne.IncompleteClassComponent,Rn=Ne.IndeterminateComponent,Nr=Ne.MemoComponent,y0=Ne.OffscreenComponent,Lr=Ne.SimpleMemoComponent,ut=Ne.SuspenseComponent,wt=Ne.SuspenseListComponent,et=$.ImmediatePriority,It=$.UserBlockingPriority,un=$.NormalPriority,fn=$.LowPriority,Jn=$.IdlePriority,wr=$.NoPriority,au=Y.overrideHookState,ku=Y.overrideHookStateDeletePath,T0=Y.overrideHookStateRenamePath,Z0=Y.overrideProps,Nu=Y.overridePropsDeletePath,gi=Y.overridePropsRenamePath,Po=Y.setSuspenseHandler,rl=Y.scheduleUpdate,hf=typeof Po=="function"&&typeof rl=="function";co(Y);var Tl=window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__!==!1,vf=window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__===!0;(Tl||vf)&&Jl({appendComponentStack:Tl,breakOnConsoleErrors:vf});var Io=new Set,ys=new Set,js=new Set,bo=!1,Bo=new Set;function gs(fe){js.clear(),Io.clear(),ys.clear(),fe.forEach(function(ie){if(ie.isEnabled)switch(ie.type){case 2:ie.isValid&&ie.value!==""&&Io.add(new RegExp(ie.value,"i"));break;case 1:js.add(ie.value);break;case 3:ie.isValid&&ie.value!==""&&ys.add(new RegExp(ie.value,"i"));break;case 4:Io.add(new RegExp("\\("));break;default:console.warn('Invalid component filter type "'.concat(ie.type,'"'))}})}function Xu(fe){var ie=fe._debugSource,Pe=fe.tag,Me=fe.type;switch(Pe){case bt:return!0;case Dn:case er:case sn:case y0:return!0;case Ft:return!1;default:switch(Oe(Me)){case 60111:case"Symbol(react.concurrent_mode)":case"Symbol(react.async_mode)":case 60108:case"Symbol(react.strict_mode)":return!0}}var at=Su(fe);if(js.has(at))return!0;if(Io.size>0){var mt=_e(fe);if(mt!=null){var Qt,An=Yi(Io);try{for(An.s();!(Qt=An.n()).done;)if(Qt.value.test(mt))return!0}catch(ir){An.e(ir)}finally{An.f()}}}if(ie!=null&&ys.size>0){var Sn,_n=ie.fileName,Tn=Yi(ys);try{for(Tn.s();!(Sn=Tn.n()).done;)if(Sn.value.test(_n))return!0}catch(ir){Tn.e(ir)}finally{Tn.f()}}return!1}function Su(fe){var ie=fe.type;switch(fe.tag){case xt:case Cr:return 1;case rt:case Rn:return 5;case rn:return 6;case Ft:return 11;case dr:return 7;case Dn:case er:case sn:return 9;case Nr:case Lr:return 8;case ut:return 12;case wt:return 13;default:switch(Oe(ie)){case 60111:case"Symbol(react.concurrent_mode)":case"Symbol(react.async_mode)":return 9;case 60109:case"Symbol(react.provider)":return 2;case 60110:case"Symbol(react.context)":return 2;case 60108:case"Symbol(react.strict_mode)":return 9;case 60114:case"Symbol(react.profiler)":return 10;default:return 9}}}function _i(fe){if(Uo.has(fe))return fe;var ie=fe.alternate;return ie!=null&&Uo.has(ie)?ie:(Uo.add(fe),fe)}window.__REACT_DEVTOOLS_COMPONENT_FILTERS__!=null?gs(window.__REACT_DEVTOOLS_COMPONENT_FILTERS__):gs([{type:1,value:7,isEnabled:!0}]);var C0=new Map,$0=new Map,Uo=new Set,la=new Map,$l=new Map,tu=-1;function Zr(fe){if(!C0.has(fe)){var ie=el();C0.set(fe,ie),$0.set(ie,fe)}return C0.get(fe)}function ho(fe){switch(Su(fe)){case 1:if(B0!==null){var ie=Zr(_i(fe)),Pe=Ci(fe);Pe!==null&&B0.set(ie,Pe)}}}var Bi={};function Ci(fe){switch(Su(fe)){case 1:var ie=fe.stateNode,Pe=Bi,Me=Bi;return ie!=null&&(ie.constructor&&ie.constructor.contextType!=null?Me=ie.context:(Pe=ie.context)&&Object.keys(Pe).length===0&&(Pe=Bi)),[Pe,Me];default:return null}}function mf(fe){switch(Su(fe)){case 1:if(B0!==null){var ie=Zr(_i(fe)),Pe=B0.has(ie)?B0.get(ie):null,Me=Ci(fe);if(Pe==null||Me==null)return null;var at=Q0(Pe,2),mt=at[0],Qt=at[1],An=Q0(Me,2),Sn=An[0],_n=An[1];if(Sn!==Bi)return eo(mt,Sn);if(_n!==Bi)return Qt!==_n}}return null}function yf(fe,ie){if(fe==null||ie==null)return!1;if(ie.hasOwnProperty("baseState")&&ie.hasOwnProperty("memoizedState")&&ie.hasOwnProperty("next")&&ie.hasOwnProperty("queue"))for(;ie!==null;){if(ie.memoizedState!==fe.memoizedState)return!0;ie=ie.next,fe=fe.next}return!1}function eo(fe,ie){if(fe==null||ie==null||ie.hasOwnProperty("baseState")&&ie.hasOwnProperty("memoizedState")&&ie.hasOwnProperty("next")&&ie.hasOwnProperty("queue"))return null;var Pe,Me=[],at=Yi(new Set([].concat(eu(Object.keys(fe)),eu(Object.keys(ie)))));try{for(at.s();!(Pe=at.n()).done;){var mt=Pe.value;fe[mt]!==ie[mt]&&Me.push(mt)}}catch(Qt){at.e(Qt)}finally{at.f()}return Me}function to(fe,ie){switch(ie.tag){case xt:case rt:case kt:case Nr:case Lr:return(ao(ie)&oe)===oe;default:return fe.memoizedProps!==ie.memoizedProps||fe.memoizedState!==ie.memoizedState||fe.ref!==ie.ref}}var xe=[],tt=[],Ke=[],Yt=[],Kt=new Map,pr=0,Ei=null;function bn(fe){xe.push(fe)}function mu(fe){if(xe.length!==0||tt.length!==0||Ke.length!==0||Ei!==null||Fu){var ie=tt.length+Ke.length+(Ei===null?0:1),Pe=new Array(3+pr+(ie>0?2+ie:0)+xe.length),Me=0;if(Pe[Me++]=H,Pe[Me++]=tu,Pe[Me++]=pr,Kt.forEach(function(An,Sn){Pe[Me++]=Sn.length;for(var _n=Y0(Sn),Tn=0;Tn<_n.length;Tn++)Pe[Me+Tn]=_n[Tn];Me+=Sn.length}),ie>0){Pe[Me++]=2,Pe[Me++]=ie;for(var at=tt.length-1;at>=0;at--)Pe[Me++]=tt[at];for(var mt=0;mt<Ke.length;mt++)Pe[Me+mt]=Ke[mt];Me+=Ke.length,Ei!==null&&(Pe[Me]=Ei,Me++)}for(var Qt=0;Qt<xe.length;Qt++)Pe[Me+Qt]=xe[Qt];Me+=xe.length,Yt!==null?Yt.push(Pe):U.emit("operations",Pe),xe.length=0,tt.length=0,Ke.length=0,Ei=null,Kt.clear(),pr=0}}function Qu(fe){if(fe===null)return 0;var ie=Kt.get(fe);if(ie!==void 0)return ie;var Pe=Kt.size+1;return Kt.set(fe,Pe),pr+=fe.length+1,Pe}function $r(fe,ie){no!==null&&(fe!==no&&fe!==no.alternate||Li(null));var Pe=fe.tag===Ft,Me=_i(fe);if(C0.has(Me)){var at=Zr(Me);Pe?Ei=at:Xu(fe)||(ie?Ke.push(at):tt.push(at)),C0.delete(Me),$0.delete(at),Uo.delete(Me),fe.hasOwnProperty("treeBaseDuration")&&($l.delete(at),la.delete(at))}else Uo.delete(Me)}function Qr(fe,ie,Pe,Me){var at=function(Tn){if(Rr===null||!fu)return!1;var ir=Tn.return,Ut=ir!==null?ir.alternate:null;if(no===ir||no===Ut&&Ut!==null){var Fi=_0(Tn),Ar=Rr[nu+1];if(Ar===void 0)throw new Error("Expected to see a frame at the next depth.");if(Fi.index===Ar.index&&Fi.key===Ar.key&&Fi.displayName===Ar.displayName)return no=Tn,nu++,fu=nu!==Rr.length-1,!1}return fu=!1,!0}(fe),mt=!Xu(fe);if(mt&&function(Tn,ir){var Ut=Tn.tag===Ft,Fi=Zr(_i(Tn)),Ar=Tn.hasOwnProperty("_debugOwner"),mr=Tn.hasOwnProperty("treeBaseDuration");if(Ut)bn(1),bn(Fi),bn(11),bn(mr?1:0),bn(Ar?1:0),Fu&&xl!==null&&xl.set(Fi,g0(Tn));else{var K=Tn.key,ti=_e(Tn),ni=Su(Tn),Wr=Tn._debugOwner,ft=Wr!=null?Zr(_i(Wr)):0,Di=ir?Zr(_i(ir)):0,ru=Qu(ti),E0=Qu(K===null?null:""+K);bn(1),bn(Fi),bn(ni),bn(Di),bn(ft),bn(ru),bn(E0)}mr&&($l.set(Fi,tu),xn(Tn))}(fe,ie),bo&&Me&&Su(fe)===7&&(Bo.add(fe.stateNode),Me=!1),fe.tag===Ne.SuspenseComponent)if(fe.memoizedState!==null){var Qt=fe.child,An=Qt?Qt.sibling:null,Sn=An?An.child:null;Sn!==null&&Qr(Sn,mt?fe:ie,!0,Me)}else{var _n=null;y0===-1?_n=fe.child:fe.child!==null&&(_n=fe.child.child),_n!==null&&Qr(_n,mt?fe:ie,!0,Me)}else fe.child!==null&&Qr(fe.child,mt?fe:ie,!0,Me);(function(Tn){fu=Tn})(at),Pe&&fe.sibling!==null&&Qr(fe.sibling,ie,!0,Me)}function qu(fe){var ie=fe.tag===Ne.SuspenseComponent&&fe.memoizedState!==null,Pe=fe.child;if(ie){var Me=fe.child,at=Me?Me.sibling:null;Pe=at?at.child:null}for(;Pe!==null;)Pe.return!==null&&(qu(Pe),$r(Pe,!0)),Pe=Pe.sibling}function xn(fe){var ie=Zr(_i(fe)),Pe=fe.actualDuration,Me=fe.treeBaseDuration;if(la.set(ie,Me||0),Fu){var at=fe.alternate;if(at==null||Me!==at.treeBaseDuration){var mt=Math.floor(1e3*(Me||0));bn(4),bn(ie),bn(mt)}if((at==null||to(at,fe))&&Pe!=null){for(var Qt=Pe,An=fe.child;An!==null;)Qt-=An.actualDuration||0,An=An.sibling;var Sn=il;if(Sn.durations.push(ie,Pe,Qt),Sn.maxActualDuration=Math.max(Sn.maxActualDuration,Pe),es){var _n=function(Tn,ir){switch(Su(ir)){case 1:case 5:case 8:case 6:return Tn===null?{context:null,didHooksChange:!1,isFirstMount:!0,props:null,state:null}:{context:mf(ir),didHooksChange:yf(Tn.memoizedState,ir.memoizedState),isFirstMount:!1,props:eo(Tn.memoizedProps,ir.memoizedProps),state:eo(Tn.memoizedState,ir.memoizedState)};default:return null}}(at,fe);_n!==null&&Sn.changeDescriptions!==null&&Sn.changeDescriptions.set(ie,_n),ho(fe)}}}}function x0(fe,ie){if(Xu(fe)){var Pe=fe.child;if(fe.tag===ut&&fe.memoizedState!==null){var Me=fe.child,at=Me?Me.sibling:null,mt=at?at.child:null;mt!==null&&(Pe=mt)}for(;Pe!==null;)x0(Pe,ie),Pe=Pe.sibling}else ie.push(Zr(_i(fe)))}function Lu(fe,ie,Pe,Me){if(bo){var at=Su(fe);Me?at===7&&(Bo.add(fe.stateNode),Me=!1):at!==5&&at!==1&&at!==2||(Me=to(ie,fe))}Xi!==null&&Xi.id===Zr(_i(fe))&&to(ie,fe)&&(Hs=!0);var mt=!Xu(fe),Qt=fe.tag===ut,An=!1,Sn=Qt&&ie.memoizedState!==null,_n=Qt&&fe.memoizedState!==null;if(Sn&&_n){var Tn=fe.child,ir=Tn?Tn.sibling:null,Ut=ie.child,Fi=Ut?Ut.sibling:null;ir!=null&&Fi!=null&&Lu(ir,Fi,fe,Me)&&(An=!0)}else if(Sn&&!_n){var Ar=fe.child;Ar!==null&&Qr(Ar,mt?fe:Pe,!0,Me),An=!0}else if(!Sn&&_n){qu(ie);var mr=fe.child,K=mr?mr.sibling:null;K!=null&&(Qr(K,mt?fe:Pe,!0,Me),An=!0)}else if(fe.child!==ie.child){for(var ti=fe.child,ni=ie.child;ti;){if(ti.alternate){var Wr=ti.alternate;Lu(ti,Wr,mt?fe:Pe,Me)&&(An=!0),Wr!==ni&&(An=!0)}else Qr(ti,mt?fe:Pe,!1,Me),An=!0;ti=ti.sibling,An||ni===null||(ni=ni.sibling)}ni!==null&&(An=!0)}else bo&&Me&&ui(Zr(_i(fe))).forEach(function(ru){Bo.add(ru.stateNode)});if(mt&&fe.hasOwnProperty("treeBaseDuration")&&xn(fe),An){if(mt){var ft=fe.child;if(_n){var Di=fe.child;ft=Di?Di.sibling:null}return ft!=null&&function(ru,E0){for(var Un=[],e0=E0;e0!==null;)x0(e0,Un),e0=e0.sibling;var ro=Un.length;if(!(ro<2)){bn(3),bn(Zr(_i(ru))),bn(ro);for(var mo=0;mo<Un.length;mo++)bn(Un[mo])}}(fe,ft),!1}return!0}return!1}function ui(fe){var ie=[],Pe=Wu(fe);if(!Pe)return ie;for(var Me=Pe;;){if(Me.tag===dr||Me.tag===er)ie.push(Me);else if(Me.child){Me.child.return=Me,Me=Me.child;continue}if(Me===Pe)return ie;for(;!Me.sibling;){if(!Me.return||Me.return===Pe)return ie;Me=Me.return}Me.sibling.return=Me.return,Me=Me.sibling}return ie}function Cl(fe){try{var ie=Wu(fe);if(ie===null)return null;if(ie.tag===ut&&ie.memoizedState!==null){var Pe=ie.child&&ie.child.sibling;Pe!=null&&(ie=Pe)}return ui(fe).map(function(Me){return Me.stateNode}).filter(Boolean)}catch{return null}}function zs(fe){var ie=fe;if(fe.alternate)for(;ie.return;)ie=ie.return;else{if((ao(ie)&qe)!==vt)return 1;for(;ie.return;)if((ao(ie=ie.return)&qe)!==vt)return 1}return ie.tag===Ft?2:3}function Wu(fe){var ie=$0.get(fe);if(ie==null)return console.warn('Could not find Fiber with id "'.concat(fe,'"')),null;var Pe=ie.alternate;if(!Pe){var Me=zs(ie);if(Me===3)throw Error("Unable to find node on an unmounted component.");return Me===1?null:ie}for(var at=ie,mt=Pe;;){var Qt=at.return;if(Qt===null)break;var An=Qt.alternate;if(An===null){var Sn=Qt.return;if(Sn!==null){at=mt=Sn;continue}break}if(Qt.child===An.child){for(var _n=Qt.child;_n;){if(_n===at){if(zs(Qt)!==2)throw Error("Unable to find node on an unmounted component.");return ie}if(_n===mt){if(zs(Qt)!==2)throw Error("Unable to find node on an unmounted component.");return Pe}_n=_n.sibling}throw Error("Unable to find node on an unmounted component.")}if(at.return!==mt.return)at=Qt,mt=An;else{for(var Tn=!1,ir=Qt.child;ir;){if(ir===at){Tn=!0,at=Qt,mt=An;break}if(ir===mt){Tn=!0,mt=Qt,at=An;break}ir=ir.sibling}if(!Tn){for(ir=An.child;ir;){if(ir===at){Tn=!0,at=An,mt=Qt;break}if(ir===mt){Tn=!0,mt=An,at=Qt;break}ir=ir.sibling}if(!Tn)throw Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.")}}if(at.alternate!==mt)throw Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.")}if(at.tag!==Ft)throw Error("Unable to find node on an unmounted component.");return at.stateNode.current===at?ie:Pe}function sa(fe){var ie=Wu(fe);if(ie==null)return null;var Pe=ie._debugOwner,Me=ie._debugSource,at=ie.stateNode,mt=ie.key,Qt=ie.memoizedProps,An=ie.memoizedState,Sn=ie.dependencies,_n=ie.tag,Tn=ie.type,ir=Su(ie),Ut=!(_n!==rt&&_n!==Lr&&_n!==rn||!An&&!Sn),Fi=Oe(Tn),Ar=!1,mr=null;if(_n===xt||_n===rt||_n===Cr||_n===Rn||_n===Nr||_n===rn||_n===Lr)Ar=!0,at&&at.context!=null&&(ir===1&&!(Tn.contextTypes||Tn.contextType)||(mr=at.context));else if(Fi===60110||Fi==="Symbol(react.context)"){var K=Tn._context||Tn;mr=K._currentValue||null;for(var ti=ie.return;ti!==null;){var ni=ti.type,Wr=Oe(ni);if((Wr===60109||Wr==="Symbol(react.provider)")&&(ni._context||ni.context)===K){mr=ti.memoizedProps.value;break}ti=ti.return}}var ft=!1;mr!==null&&(ft=!!Tn.contextTypes,mr={value:mr});var Di=null;if(Pe){Di=[];for(var ru=Pe;ru!==null;)Di.push({displayName:_e(ru)||"Anonymous",id:Zr(_i(ru)),type:Su(ru)}),ru=ru._debugOwner||null}var E0=_n===ut&&An!==null,Un=null;if(Ut){var e0={};for(var ro in console)try{e0[ro]=console[ro],console[ro]=function(){}}catch{}try{Un=Object(Ai.inspectHooksOfFiber)(ie,Y.currentDispatcherRef)}finally{for(var mo in e0)try{console[mo]=e0[mo]}catch{}}}for(var t0=null,jo=ie;jo.return!==null;)jo=jo.return;var io=jo.stateNode;return io!=null&&io._debugRootType!==null&&(t0=io._debugRootType),{id:fe,canEditHooks:typeof au=="function",canEditFunctionProps:typeof Z0=="function",canEditHooksAndDeletePaths:typeof ku=="function",canEditHooksAndRenamePaths:typeof T0=="function",canEditFunctionPropsDeletePaths:typeof Nu=="function",canEditFunctionPropsRenamePaths:typeof gi=="function",canToggleSuspense:hf&&(!E0||Zu.has(fe)),canViewSource:Ar,hasLegacyContext:ft,key:mt!=null?mt:null,displayName:_e(ie),type:ir,context:mr,hooks:Un,props:Qt,state:Ut?null:An,owners:Di,source:Me||null,rootType:t0,rendererPackageName:Y.rendererPackageName,rendererVersion:Y.version}}var Xi=null,Hs=!1,R0={};function Hi(fe){return Xi!==null&&Xi.id===fe&&!Hs}function A0(fe){var ie=R0;fe.forEach(function(Pe){ie[Pe]||(ie[Pe]={}),ie=ie[Pe]})}function qi(fe,ie){return function(Pe){switch(ie){case"hooks":if(Pe.length===1||Pe[Pe.length-1]==="subHooks"||Pe[Pe.length-2]==="subHooks")return!0}var Me=fe===null?R0:R0[fe];if(!Me)return!1;for(var at=0;at<Pe.length;at++)if(!(Me=Me[Pe[at]]))return!1;return!0}}var il=null,xl=null,B0=null,O0=null,vo=null,Fu=!1,Ju=0,es=!1,_s=null;function aa(fe){Fu||(es=fe,xl=new Map,O0=new Map(la),vo=new Map($l),B0=new Map,U.getFiberRoots(H).forEach(function(ie){var Pe=Zr(_i(ie.current));xl.set(Pe,g0(ie.current)),fe&&function Me(at){ho(at);for(var mt=at.child;mt!==null;)Me(mt),mt=mt.sibling}(ie.current)}),Fu=!0,Ju=Ql(),_s=new Map)}function gf(){return!1}x("React::DevTools::reloadAndProfile")==="true"&&aa(x("React::DevTools::recordChangeDescriptions")==="true");var Zu=new Set;function Es(fe){var ie=Zr(_i(fe));return Zu.has(ie)}var Rr=null,no=null,nu=-1,fu=!1;function Li(fe){fe===null&&(no=null,nu=-1,fu=!1),Rr=fe}var ei=new Map,Kn=new Map;function $u(fe,ie){var Pe=g0(ie),Me=Kn.get(Pe)||0;Kn.set(Pe,Me+1);var at="".concat(Pe,":").concat(Me);ei.set(fe,at)}function g0(fe){for(var ie=null,Pe=null,Me=fe.child,at=0;at<3&&Me!==null;at++){var mt=_e(Me);if(mt!==null&&(typeof Me.type=="function"?ie=mt:Pe===null&&(Pe=mt)),ie!==null)break;Me=Me.child}return ie||Pe||"Anonymous"}function _0(fe){var ie=fe.key,Pe=_e(fe),Me=fe.index;switch(fe.tag){case Ft:var at=Zr(_i(fe)),mt=ei.get(at);if(mt===void 0)throw new Error("Expected mounted root to have known pseudo key.");Pe=mt;break;case dr:Pe=fe.type}return{displayName:Pe,key:ie,index:Me}}var Ln=function(fe){if(fe==null)return"Unknown";switch(fe){case et:return"Immediate";case It:return"User-Blocking";case un:return"Normal";case fn:return"Low";case Jn:return"Idle";case wr:default:return"Unknown"}};return{cleanup:function(){},copyElementPath:function(fe,ie){Hi(fe)&&X0(Bu(Xi,ie))},deletePath:function(fe,ie,Pe,Me){var at=Wu(ie);if(at!==null){var mt=at.stateNode;switch(fe){case"context":switch(Me=Me.slice(1),at.tag){case xt:Me.length===0||K0(mt.context,Me),mt.forceUpdate()}break;case"hooks":typeof ku=="function"&&ku(at,Pe,Me);break;case"props":mt===null?typeof Nu=="function"&&Nu(at,Me):(at.pendingProps=mi(mt.props,Me),mt.forceUpdate());break;case"state":K0(mt.state,Me),mt.forceUpdate()}}},findNativeNodesForFiberID:Cl,flushInitialOperations:function(){var fe=Yt;Yt=null,fe!==null&&fe.length>0?fe.forEach(function(ie){U.emit("operations",ie)}):(Rr!==null&&(fu=!0),U.getFiberRoots(H).forEach(function(ie){$u(tu=Zr(_i(ie.current)),ie.current),Fu&&ie.memoizedInteractions!=null&&(il={changeDescriptions:es?new Map:null,durations:[],commitTime:Ql()-Ju,interactions:Array.from(ie.memoizedInteractions).map(function(Pe){return Wt(Wt({},Pe),{},{timestamp:Pe.timestamp-Ju})}),maxActualDuration:0,priorityLevel:null}),Qr(ie.current,null,!1,!1),mu(),tu=-1}))},getBestMatchForTrackedPath:function(){if(Rr===null||no===null)return null;for(var fe=no;fe!==null&&Xu(fe);)fe=fe.return;return fe===null?null:{id:Zr(_i(fe)),isFullMatch:nu===Rr.length-1}},getDisplayNameForFiberID:function(fe){var ie=$0.get(fe);return ie!=null?_e(ie):null},getFiberIDForNative:function(fe){var ie=arguments.length>1&&arguments[1]!==void 0&&arguments[1],Pe=Y.findFiberByHostInstance(fe);if(Pe!=null){if(ie)for(;Pe!==null&&Xu(Pe);)Pe=Pe.return;return Zr(_i(Pe))}return null},getInstanceAndStyle:function(fe){var ie=null,Pe=null,Me=Wu(fe);return Me!==null&&(ie=Me.stateNode,Me.memoizedProps!==null&&(Pe=Me.memoizedProps.style)),{instance:ie,style:Pe}},getOwnersList:function(fe){var ie=Wu(fe);if(ie==null)return null;var Pe=ie._debugOwner,Me=[{displayName:_e(ie)||"Anonymous",id:fe,type:Su(ie)}];if(Pe)for(var at=Pe;at!==null;)Me.unshift({displayName:_e(at)||"Anonymous",id:Zr(_i(at)),type:Su(at)}),at=at._debugOwner||null;return Me},getPathForElement:function(fe){var ie=$0.get(fe);if(ie==null)return null;for(var Pe=[];ie!==null;)Pe.push(_0(ie)),ie=ie.return;return Pe.reverse(),Pe},getProfilingData:function(){var fe=[];if(_s===null)throw Error("getProfilingData() called before any profiling data was recorded");return _s.forEach(function(ie,Pe){var Me=[],at=[],mt=new Map,Qt=new Map,An=xl!==null&&xl.get(Pe)||"Unknown";O0!=null&&O0.forEach(function(Sn,_n){vo!=null&&vo.get(_n)===Pe&&at.push([_n,Sn])}),ie.forEach(function(Sn,_n){var Tn=Sn.changeDescriptions,ir=Sn.durations,Ut=Sn.interactions,Fi=Sn.maxActualDuration,Ar=Sn.priorityLevel,mr=Sn.commitTime,K=[];Ut.forEach(function(Di){mt.has(Di.id)||mt.set(Di.id,Di),K.push(Di.id);var ru=Qt.get(Di.id);ru!=null?ru.push(_n):Qt.set(Di.id,[_n])});for(var ti=[],ni=[],Wr=0;Wr<ir.length;Wr+=3){var ft=ir[Wr];ti.push([ft,ir[Wr+1]]),ni.push([ft,ir[Wr+2]])}Me.push({changeDescriptions:Tn!==null?Array.from(Tn.entries()):null,duration:Fi,fiberActualDurations:ti,fiberSelfDurations:ni,interactionIDs:K,priorityLevel:Ar,timestamp:mr})}),fe.push({commitData:Me,displayName:An,initialTreeBaseDurations:at,interactionCommits:Array.from(Qt.entries()),interactions:Array.from(mt.entries()),rootID:Pe})}),{dataForRoots:fe,rendererID:H}},handleCommitFiberRoot:function(fe,ie){var Pe=fe.current,Me=Pe.alternate;tu=Zr(_i(Pe)),Rr!==null&&(fu=!0),bo&&Bo.clear();var at=fe.memoizedInteractions!=null;if(Fu&&at&&(il={changeDescriptions:es?new Map:null,durations:[],commitTime:Ql()-Ju,interactions:Array.from(fe.memoizedInteractions).map(function(Sn){return Wt(Wt({},Sn),{},{timestamp:Sn.timestamp-Ju})}),maxActualDuration:0,priorityLevel:ie==null?null:Ln(ie)}),Me){var mt=Me.memoizedState!=null&&Me.memoizedState.element!=null,Qt=Pe.memoizedState!=null&&Pe.memoizedState.element!=null;!mt&&Qt?($u(tu,Pe),Qr(Pe,null,!1,!1)):mt&&Qt?Lu(Pe,Me,null,!1):mt&&!Qt&&(function(Sn){var _n=ei.get(Sn);if(_n===void 0)throw new Error("Expected root pseudo key to be known.");var Tn=_n.substring(0,_n.lastIndexOf(":")),ir=Kn.get(Tn);if(ir===void 0)throw new Error("Expected counter to be known.");ir>1?Kn.set(Tn,ir-1):Kn.delete(Tn),ei.delete(Sn)}(tu),$r(Pe,!1))}else $u(tu,Pe),Qr(Pe,null,!1,!1);if(Fu&&at){var An=_s.get(tu);An!=null?An.push(il):_s.set(tu,[il])}mu(),bo&&U.emit("traceUpdates",Bo),tu=-1},handleCommitFiberUnmount:function(fe){$r(fe,!1)},inspectElement:function(fe,ie){if(Hi(fe)){if(ie!=null){A0(ie);var Pe=null;return ie[0]==="hooks"&&(Pe="hooks"),{id:fe,type:"hydrated-path",path:ie,value:Ri(Bu(Xi,ie),qi(null,Pe),ie)}}return{id:fe,type:"no-change"}}if(Hs=!1,Xi!==null&&Xi.id===fe||(R0={}),(Xi=sa(fe))===null)return{id:fe,type:"not-found"};ie!=null&&A0(ie),function(at){var mt=at.hooks,Qt=at.id,An=at.props,Sn=$0.get(Qt);if(Sn!=null){var _n=Sn.elementType,Tn=Sn.stateNode,ir=Sn.tag,Ut=Sn.type;switch(ir){case xt:case Cr:case Rn:ee.$r=Tn;break;case rt:ee.$r={hooks:mt,props:An,type:Ut};break;case rn:ee.$r={props:An,type:Ut.render};break;case Nr:case Lr:ee.$r={props:An,type:_n!=null&&_n.type!=null?_n.type:Ut};break;default:ee.$r=null}}else console.warn('Could not find Fiber with id "'.concat(Qt,'"'))}(Xi);var Me=Wt({},Xi);return Me.context=Ri(Me.context,qi("context",null)),Me.hooks=Ri(Me.hooks,qi("hooks","hooks")),Me.props=Ri(Me.props,qi("props",null)),Me.state=Ri(Me.state,qi("state",null)),{id:fe,type:"full-data",value:Me}},logElementToConsole:function(fe){var ie=Hi(fe)?Xi:sa(fe);if(ie!==null){var Pe=typeof console.groupCollapsed=="function";Pe&&console.groupCollapsed("[Click to expand] %c<".concat(ie.displayName||"Component"," />"),"color: var(--dom-tag-name-color); font-weight: normal;"),ie.props!==null&&console.log("Props:",ie.props),ie.state!==null&&console.log("State:",ie.state),ie.hooks!==null&&console.log("Hooks:",ie.hooks);var Me=Cl(fe);Me!==null&&console.log("Nodes:",Me),ie.source!==null&&console.log("Location:",ie.source),(window.chrome||/firefox/i.test(navigator.userAgent))&&console.log("Right-click any value to save it as a global variable for further inspection."),Pe&&console.groupEnd()}else console.warn('Could not find Fiber with id "'.concat(fe,'"'))},prepareViewAttributeSource:function(fe,ie){Hi(fe)&&(window.$attribute=Bu(Xi,ie))},prepareViewElementSource:function(fe){var ie=$0.get(fe);if(ie!=null){var Pe=ie.elementType,Me=ie.tag,at=ie.type;switch(Me){case xt:case Cr:case Rn:case rt:ee.$type=at;break;case rn:ee.$type=at.render;break;case Nr:case Lr:ee.$type=Pe!=null&&Pe.type!=null?Pe.type:at;break;default:ee.$type=null}}else console.warn('Could not find Fiber with id "'.concat(fe,'"'))},overrideSuspense:function(fe,ie){if(typeof Po!="function"||typeof rl!="function")throw new Error("Expected overrideSuspense() to not get called for earlier React versions.");ie?(Zu.add(fe),Zu.size===1&&Po(Es)):(Zu.delete(fe),Zu.size===0&&Po(gf));var Pe=$0.get(fe);Pe!=null&&rl(Pe)},overrideValueAtPath:function(fe,ie,Pe,Me,at){var mt=Wu(ie);if(mt!==null){var Qt=mt.stateNode;switch(fe){case"context":switch(Me=Me.slice(1),mt.tag){case xt:Me.length===0?Qt.context=at:Oo(Qt.context,Me,at),Qt.forceUpdate()}break;case"hooks":typeof au=="function"&&au(mt,Pe,Me,at);break;case"props":switch(mt.tag){case xt:mt.pendingProps=In(Qt.props,Me,at),Qt.forceUpdate();break;default:typeof Z0=="function"&&Z0(mt,Me,at)}break;case"state":switch(mt.tag){case xt:Oo(Qt.state,Me,at),Qt.forceUpdate()}}}},renamePath:function(fe,ie,Pe,Me,at){var mt=Wu(ie);if(mt!==null){var Qt=mt.stateNode;switch(fe){case"context":switch(Me=Me.slice(1),at=at.slice(1),mt.tag){case xt:Me.length===0||Kr(Qt.context,Me,at),Qt.forceUpdate()}break;case"hooks":typeof T0=="function"&&T0(mt,Pe,Me,at);break;case"props":Qt===null?typeof gi=="function"&&gi(mt,Me,at):(mt.pendingProps=en(Qt.props,Me,at),Qt.forceUpdate());break;case"state":Kr(Qt.state,Me,at),Qt.forceUpdate()}}},renderer:Y,setTraceUpdatesEnabled:function(fe){bo=fe},setTrackedPath:Li,startProfiling:aa,stopProfiling:function(){Fu=!1,es=!1},storeAsGlobal:function(fe,ie,Pe){if(Hi(fe)){var Me=Bu(Xi,ie),at="$reactTemp".concat(Pe);window[at]=Me,console.log(at),console.log(Me)}},updateComponentFilters:function(fe){if(Fu)throw Error("Cannot modify filter preferences while profiling");U.getFiberRoots(H).forEach(function(ie){tu=Zr(_i(ie.current)),qu(ie.current),$r(ie.current,!1),tu=-1}),gs(fe),Kn.clear(),U.getFiberRoots(H).forEach(function(ie){$u(tu=Zr(_i(ie.current)),ie.current),Qr(ie.current,null,!1,!1),mu(ie),tu=-1})}}}var $n;function tl(U){return(tl=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function fo(U,H,Y){if($n===void 0)try{throw Error()}catch(Ce){var ee=Ce.stack.trim().match(/\n( *(at )?)/);$n=ee&&ee[1]||""}return`
+`+$n+U}var I0=!1;function Sl(U,H,Y){if(!U||I0)return"";var ee,Ce=Error.prepareStackTrace;Error.prepareStackTrace=void 0,I0=!0;var _e=Y.current;Y.current=null;try{if(H){var Oe=function(){throw Error()};if(Object.defineProperty(Oe.prototype,"props",{set:function(){throw Error()}}),(typeof Reflect>"u"?"undefined":tl(Reflect))==="object"&&Reflect.construct){try{Reflect.construct(Oe,[])}catch(qe){ee=qe}Reflect.construct(U,[],Oe)}else{try{Oe.call()}catch(qe){ee=qe}U.call(Oe.prototype)}}else{try{throw Error()}catch(qe){ee=qe}U()}}catch(qe){if(qe&&ee&&typeof qe.stack=="string"){for(var $=qe.stack.split(`
+`),Ne=ee.stack.split(`
+`),Je=$.length-1,vt=Ne.length-1;Je>=1&&vt>=0&&$[Je]!==Ne[vt];)vt--;for(;Je>=1&&vt>=0;Je--,vt--)if($[Je]!==Ne[vt]){if(Je!==1||vt!==1)do if(Je--,--vt<0||$[Je]!==Ne[vt])return`
+`+$[Je].replace(" at new "," at ");while(Je>=1&&vt>=0);break}}}finally{I0=!1,Error.prepareStackTrace=Ce,Y.current=_e}var oe=U?U.displayName||U.name:"";return oe?fo(oe):""}function Lo(U,H,Y,ee){return Sl(U,!1,ee)}function St(U,H,Y){var ee=U.HostComponent,Ce=U.LazyComponent,_e=U.SuspenseComponent,Oe=U.SuspenseListComponent,$=U.FunctionComponent,Ne=U.IndeterminateComponent,Je=U.SimpleMemoComponent,vt=U.ForwardRef,oe=U.Block,qe=U.ClassComponent;switch(H.tag){case ee:return fo(H.type);case Ce:return fo("Lazy");case _e:return fo("Suspense");case Oe:return fo("SuspenseList");case $:case Ne:case Je:return Lo(H.type,0,0,Y);case vt:return Lo(H.type.render,0,0,Y);case oe:return Lo(H.type._render,0,0,Y);case qe:return function(rt,xt,kt,bt){return Sl(rt,!0,bt)}(H.type,0,0,Y);default:return""}}function Bt(U,H,Y){try{var ee="",Ce=H;do ee+=St(U,Ce,Y),Ce=Ce.return;while(Ce);return ee}catch(_e){return`
+Error generating stack: `+_e.message+`
+`+_e.stack}}function Hn(U,H){var Y;if(typeof Symbol>"u"||U[Symbol.iterator]==null){if(Array.isArray(U)||(Y=function(Ne,Je){if(!!Ne){if(typeof Ne=="string")return qr(Ne,Je);var vt=Object.prototype.toString.call(Ne).slice(8,-1);if(vt==="Object"&&Ne.constructor&&(vt=Ne.constructor.name),vt==="Map"||vt==="Set")return Array.from(Ne);if(vt==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(vt))return qr(Ne,Je)}}(U))||H&&U&&typeof U.length=="number"){Y&&(U=Y);var ee=0,Ce=function(){};return{s:Ce,n:function(){return ee>=U.length?{done:!0}:{done:!1,value:U[ee++]}},e:function(Ne){throw Ne},f:Ce}}throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var _e,Oe=!0,$=!1;return{s:function(){Y=U[Symbol.iterator]()},n:function(){var Ne=Y.next();return Oe=Ne.done,Ne},e:function(Ne){$=!0,_e=Ne},f:function(){try{Oe||Y.return==null||Y.return()}finally{if($)throw _e}}}}function qr(U,H){(H==null||H>U.length)&&(H=U.length);for(var Y=0,ee=new Array(H);Y<H;Y++)ee[Y]=U[Y];return ee}var Ki=["error","trace","warn"],Xr=/\s{4}(in|at)\s{1}/,Au=/:\d+:\d+(\n|$)/,p0=new Map,Ni=console,h0={};for(var hs in console)h0[hs]=console[hs];var Ct=null;function co(U){var H=U.currentDispatcherRef,Y=U.getCurrentFiber,ee=U.findFiberByHostInstance,Ce=U.version;if(typeof ee=="function"&&H!=null&&typeof Y=="function"){var _e=No(Ce).ReactTypeOfWork;p0.set(U,{currentDispatcherRef:H,getCurrentFiber:Y,workTagMap:_e})}}var nl={appendComponentStack:!1,breakOnConsoleErrors:!1};function Jl(U){var H=U.appendComponentStack,Y=U.breakOnConsoleErrors;if(nl.appendComponentStack=H,nl.breakOnConsoleErrors=Y,Ct===null){var ee={};Ct=function(){for(var Ce in ee)try{Ni[Ce]=ee[Ce]}catch{}},Ki.forEach(function(Ce){try{var _e=ee[Ce]=Ni[Ce],Oe=function(){for(var $=nl.appendComponentStack,Ne=(nl.breakOnConsoleErrors,arguments.length),Je=new Array(Ne),vt=0;vt<Ne;vt++)Je[vt]=arguments[vt];if($)try{var oe=Je.length>0?Je[Je.length-1]:null,qe=oe!==null&&(Xr.test(oe)||Au.test(oe));if(!qe){var rt,xt=Hn(p0.values());try{for(xt.s();!(rt=xt.n()).done;){var kt=rt.value,bt=kt.currentDispatcherRef,sn=kt.getCurrentFiber,rn=kt.workTagMap,Ft=sn();if(Ft!=null){var Dn=Bt(rn,Ft,bt);Dn!==""&&Je.push(Dn);break}}}catch(dr){xt.e(dr)}finally{xt.f()}}}catch{}_e.apply(void 0,Je)};Oe.__REACT_DEVTOOLS_ORIGINAL_METHOD__=_e,Ni[Ce]=Oe}catch{}})}}function Uu(U){return(Uu=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function vs(U,H){for(var Y=0;Y<H.length;Y++){var ee=H[Y];ee.enumerable=ee.enumerable||!1,ee.configurable=!0,"value"in ee&&(ee.writable=!0),Object.defineProperty(U,ee.key,ee)}}function b0(U,H){return(b0=Object.setPrototypeOf||function(Y,ee){return Y.__proto__=ee,Y})(U,H)}function Q(U){var H=function(){if(typeof Reflect>"u"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch{return!1}}();return function(){var Y,ee=Le(U);if(H){var Ce=Le(this).constructor;Y=Reflect.construct(ee,arguments,Ce)}else Y=ee.apply(this,arguments);return Se(this,Y)}}function Se(U,H){return!H||Uu(H)!=="object"&&typeof H!="function"?Fe(U):H}function Fe(U){if(U===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return U}function Le(U){return(Le=Object.setPrototypeOf?Object.getPrototypeOf:function(H){return H.__proto__||Object.getPrototypeOf(H)})(U)}function pt(U,H,Y){return H in U?Object.defineProperty(U,H,{value:Y,enumerable:!0,configurable:!0,writable:!0}):U[H]=Y,U}var Yn=function(U){(function(Oe,$){if(typeof $!="function"&&$!==null)throw new TypeError("Super expression must either be null or a function");Oe.prototype=Object.create($&&$.prototype,{constructor:{value:Oe,writable:!0,configurable:!0}}),$&&b0(Oe,$)})(_e,U);var H,Y,ee,Ce=Q(_e);function _e(Oe){var $;(function(oe,qe){if(!(oe instanceof qe))throw new TypeError("Cannot call a class as a function")})(this,_e),pt(Fe($=Ce.call(this)),"_isProfiling",!1),pt(Fe($),"_recordChangeDescriptions",!1),pt(Fe($),"_rendererInterfaces",{}),pt(Fe($),"_persistedSelection",null),pt(Fe($),"_persistedSelectionMatch",null),pt(Fe($),"_traceUpdatesEnabled",!1),pt(Fe($),"copyElementPath",function(oe){var qe=oe.id,rt=oe.path,xt=oe.rendererID,kt=$._rendererInterfaces[xt];kt==null?console.warn('Invalid renderer id "'.concat(xt,'" for element "').concat(qe,'"')):kt.copyElementPath(qe,rt)}),pt(Fe($),"deletePath",function(oe){var qe=oe.hookID,rt=oe.id,xt=oe.path,kt=oe.rendererID,bt=oe.type,sn=$._rendererInterfaces[kt];sn==null?console.warn('Invalid renderer id "'.concat(kt,'" for element "').concat(rt,'"')):sn.deletePath(bt,rt,qe,xt)}),pt(Fe($),"getProfilingData",function(oe){var qe=oe.rendererID,rt=$._rendererInterfaces[qe];rt==null&&console.warn('Invalid renderer id "'.concat(qe,'"')),$._bridge.send("profilingData",rt.getProfilingData())}),pt(Fe($),"getProfilingStatus",function(){$._bridge.send("profilingStatus",$._isProfiling)}),pt(Fe($),"getOwnersList",function(oe){var qe=oe.id,rt=oe.rendererID,xt=$._rendererInterfaces[rt];if(xt==null)console.warn('Invalid renderer id "'.concat(rt,'" for element "').concat(qe,'"'));else{var kt=xt.getOwnersList(qe);$._bridge.send("ownersList",{id:qe,owners:kt})}}),pt(Fe($),"inspectElement",function(oe){var qe=oe.id,rt=oe.path,xt=oe.rendererID,kt=$._rendererInterfaces[xt];kt==null?console.warn('Invalid renderer id "'.concat(xt,'" for element "').concat(qe,'"')):($._bridge.send("inspectedElement",kt.inspectElement(qe,rt)),$._persistedSelectionMatch!==null&&$._persistedSelectionMatch.id===qe||($._persistedSelection=null,$._persistedSelectionMatch=null,kt.setTrackedPath(null),$._throttledPersistSelection(xt,qe)))}),pt(Fe($),"logElementToConsole",function(oe){var qe=oe.id,rt=oe.rendererID,xt=$._rendererInterfaces[rt];xt==null?console.warn('Invalid renderer id "'.concat(rt,'" for element "').concat(qe,'"')):xt.logElementToConsole(qe)}),pt(Fe($),"overrideSuspense",function(oe){var qe=oe.id,rt=oe.rendererID,xt=oe.forceFallback,kt=$._rendererInterfaces[rt];kt==null?console.warn('Invalid renderer id "'.concat(rt,'" for element "').concat(qe,'"')):kt.overrideSuspense(qe,xt)}),pt(Fe($),"overrideValueAtPath",function(oe){var qe=oe.hookID,rt=oe.id,xt=oe.path,kt=oe.rendererID,bt=oe.type,sn=oe.value,rn=$._rendererInterfaces[kt];rn==null?console.warn('Invalid renderer id "'.concat(kt,'" for element "').concat(rt,'"')):rn.overrideValueAtPath(bt,rt,qe,xt,sn)}),pt(Fe($),"overrideContext",function(oe){var qe=oe.id,rt=oe.path,xt=oe.rendererID,kt=oe.wasForwarded,bt=oe.value;kt||$.overrideValueAtPath({id:qe,path:rt,rendererID:xt,type:"context",value:bt})}),pt(Fe($),"overrideHookState",function(oe){var qe=oe.id,rt=(oe.hookID,oe.path),xt=oe.rendererID,kt=oe.wasForwarded,bt=oe.value;kt||$.overrideValueAtPath({id:qe,path:rt,rendererID:xt,type:"hooks",value:bt})}),pt(Fe($),"overrideProps",function(oe){var qe=oe.id,rt=oe.path,xt=oe.rendererID,kt=oe.wasForwarded,bt=oe.value;kt||$.overrideValueAtPath({id:qe,path:rt,rendererID:xt,type:"props",value:bt})}),pt(Fe($),"overrideState",function(oe){var qe=oe.id,rt=oe.path,xt=oe.rendererID,kt=oe.wasForwarded,bt=oe.value;kt||$.overrideValueAtPath({id:qe,path:rt,rendererID:xt,type:"state",value:bt})}),pt(Fe($),"reloadAndProfile",function(oe){q("React::DevTools::reloadAndProfile","true"),q("React::DevTools::recordChangeDescriptions",oe?"true":"false"),$._bridge.send("reloadAppForProfiling")}),pt(Fe($),"renamePath",function(oe){var qe=oe.hookID,rt=oe.id,xt=oe.newPath,kt=oe.oldPath,bt=oe.rendererID,sn=oe.type,rn=$._rendererInterfaces[bt];rn==null?console.warn('Invalid renderer id "'.concat(bt,'" for element "').concat(rt,'"')):rn.renamePath(sn,rt,qe,kt,xt)}),pt(Fe($),"setTraceUpdatesEnabled",function(oe){for(var qe in $._traceUpdatesEnabled=oe,Vt(oe),$._rendererInterfaces)$._rendererInterfaces[qe].setTraceUpdatesEnabled(oe)}),pt(Fe($),"syncSelectionFromNativeElementsPanel",function(){var oe=window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;oe!=null&&$.selectNode(oe)}),pt(Fe($),"shutdown",function(){$.emit("shutdown")}),pt(Fe($),"startProfiling",function(oe){for(var qe in $._recordChangeDescriptions=oe,$._isProfiling=!0,$._rendererInterfaces)$._rendererInterfaces[qe].startProfiling(oe);$._bridge.send("profilingStatus",$._isProfiling)}),pt(Fe($),"stopProfiling",function(){for(var oe in $._isProfiling=!1,$._recordChangeDescriptions=!1,$._rendererInterfaces)$._rendererInterfaces[oe].stopProfiling();$._bridge.send("profilingStatus",$._isProfiling)}),pt(Fe($),"storeAsGlobal",function(oe){var qe=oe.count,rt=oe.id,xt=oe.path,kt=oe.rendererID,bt=$._rendererInterfaces[kt];bt==null?console.warn('Invalid renderer id "'.concat(kt,'" for element "').concat(rt,'"')):bt.storeAsGlobal(rt,xt,qe)}),pt(Fe($),"updateConsolePatchSettings",function(oe){var qe=oe.appendComponentStack,rt=oe.breakOnConsoleErrors;qe||rt?Jl({appendComponentStack:qe,breakOnConsoleErrors:rt}):Ct!==null&&(Ct(),Ct=null)}),pt(Fe($),"updateComponentFilters",function(oe){for(var qe in $._rendererInterfaces)$._rendererInterfaces[qe].updateComponentFilters(oe)}),pt(Fe($),"viewAttributeSource",function(oe){var qe=oe.id,rt=oe.path,xt=oe.rendererID,kt=$._rendererInterfaces[xt];kt==null?console.warn('Invalid renderer id "'.concat(xt,'" for element "').concat(qe,'"')):kt.prepareViewAttributeSource(qe,rt)}),pt(Fe($),"viewElementSource",function(oe){var qe=oe.id,rt=oe.rendererID,xt=$._rendererInterfaces[rt];xt==null?console.warn('Invalid renderer id "'.concat(rt,'" for element "').concat(qe,'"')):xt.prepareViewElementSource(qe)}),pt(Fe($),"onTraceUpdates",function(oe){$.emit("traceUpdates",oe)}),pt(Fe($),"onHookOperations",function(oe){if($._bridge.send("operations",oe),$._persistedSelection!==null){var qe=oe[0];if($._persistedSelection.rendererID===qe){var rt=$._rendererInterfaces[qe];if(rt==null)console.warn('Invalid renderer id "'.concat(qe,'"'));else{var xt=$._persistedSelectionMatch,kt=rt.getBestMatchForTrackedPath();$._persistedSelectionMatch=kt;var bt=xt!==null?xt.id:null,sn=kt!==null?kt.id:null;bt!==sn&&sn!==null&&$._bridge.send("selectFiber",sn),kt!==null&&kt.isFullMatch&&($._persistedSelection=null,$._persistedSelectionMatch=null,rt.setTrackedPath(null))}}}}),pt(Fe($),"_throttledPersistSelection",N()(function(oe,qe){var rt=$._rendererInterfaces[oe],xt=rt!=null?rt.getPathForElement(qe):null;xt!==null?q("React::DevTools::lastSelection",JSON.stringify({rendererID:oe,path:xt})):j("React::DevTools::lastSelection")},1e3)),x("React::DevTools::reloadAndProfile")==="true"&&($._recordChangeDescriptions=x("React::DevTools::recordChangeDescriptions")==="true",$._isProfiling=!0,j("React::DevTools::recordChangeDescriptions"),j("React::DevTools::reloadAndProfile"));var Ne=x("React::DevTools::lastSelection");Ne!=null&&($._persistedSelection=JSON.parse(Ne)),$._bridge=Oe,Oe.addListener("copyElementPath",$.copyElementPath),Oe.addListener("deletePath",$.deletePath),Oe.addListener("getProfilingData",$.getProfilingData),Oe.addListener("getProfilingStatus",$.getProfilingStatus),Oe.addListener("getOwnersList",$.getOwnersList),Oe.addListener("inspectElement",$.inspectElement),Oe.addListener("logElementToConsole",$.logElementToConsole),Oe.addListener("overrideSuspense",$.overrideSuspense),Oe.addListener("overrideValueAtPath",$.overrideValueAtPath),Oe.addListener("reloadAndProfile",$.reloadAndProfile),Oe.addListener("renamePath",$.renamePath),Oe.addListener("setTraceUpdatesEnabled",$.setTraceUpdatesEnabled),Oe.addListener("startProfiling",$.startProfiling),Oe.addListener("stopProfiling",$.stopProfiling),Oe.addListener("storeAsGlobal",$.storeAsGlobal),Oe.addListener("syncSelectionFromNativeElementsPanel",$.syncSelectionFromNativeElementsPanel),Oe.addListener("shutdown",$.shutdown),Oe.addListener("updateConsolePatchSettings",$.updateConsolePatchSettings),Oe.addListener("updateComponentFilters",$.updateComponentFilters),Oe.addListener("viewAttributeSource",$.viewAttributeSource),Oe.addListener("viewElementSource",$.viewElementSource),Oe.addListener("overrideContext",$.overrideContext),Oe.addListener("overrideHookState",$.overrideHookState),Oe.addListener("overrideProps",$.overrideProps),Oe.addListener("overrideState",$.overrideState),$._isProfiling&&Oe.send("profilingStatus",!0);var Je,vt=!1;try{localStorage.getItem("test"),vt=!0}catch{}return Oe.send("isBackendStorageAPISupported",vt),Re(Oe,Fe($)),Je=Fe($),Je.addListener("traceUpdates",Er),$}return H=_e,(Y=[{key:"getInstanceAndStyle",value:function(Oe){var $=Oe.id,Ne=Oe.rendererID,Je=this._rendererInterfaces[Ne];return Je==null?(console.warn('Invalid renderer id "'.concat(Ne,'"')),null):Je.getInstanceAndStyle($)}},{key:"getIDForNode",value:function(Oe){for(var $ in this._rendererInterfaces){var Ne=this._rendererInterfaces[$];try{var Je=Ne.getFiberIDForNative(Oe,!0);if(Je!==null)return Je}catch{}}return null}},{key:"selectNode",value:function(Oe){var $=this.getIDForNode(Oe);$!==null&&this._bridge.send("selectFiber",$)}},{key:"setRendererInterface",value:function(Oe,$){this._rendererInterfaces[Oe]=$,this._isProfiling&&$.startProfiling(this._recordChangeDescriptions),$.setTraceUpdatesEnabled(this._traceUpdatesEnabled);var Ne=this._persistedSelection;Ne!==null&&Ne.rendererID===Oe&&$.setTrackedPath(Ne.path)}},{key:"onUnsupportedRenderer",value:function(Oe){this._bridge.send("unsupportedRendererVersion",Oe)}},{key:"rendererInterfaces",get:function(){return this._rendererInterfaces}}])&&vs(H.prototype,Y),ee&&vs(H,ee),_e}(E);function Cn(U){return(Cn=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function cr(U){return function(H){if(Array.isArray(H))return Si(H)}(U)||function(H){if(typeof Symbol<"u"&&Symbol.iterator in Object(H))return Array.from(H)}(U)||function(H,Y){if(!!H){if(typeof H=="string")return Si(H,Y);var ee=Object.prototype.toString.call(H).slice(8,-1);if(ee==="Object"&&H.constructor&&(ee=H.constructor.name),ee==="Map"||ee==="Set")return Array.from(H);if(ee==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(ee))return Si(H,Y)}}(U)||function(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}()}function Si(U,H){(H==null||H>U.length)&&(H=U.length);for(var Y=0,ee=new Array(H);Y<H;Y++)ee[Y]=U[Y];return ee}function Ou(U,H){for(var Y=0;Y<H.length;Y++){var ee=H[Y];ee.enumerable=ee.enumerable||!1,ee.configurable=!0,"value"in ee&&(ee.writable=!0),Object.defineProperty(U,ee.key,ee)}}function ju(U,H){return(ju=Object.setPrototypeOf||function(Y,ee){return Y.__proto__=ee,Y})(U,H)}function zu(U){var H=function(){if(typeof Reflect>"u"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch{return!1}}();return function(){var Y,ee=Fo(U);if(H){var Ce=Fo(this).constructor;Y=Reflect.construct(ee,arguments,Ce)}else Y=ee.apply(this,arguments);return wu(this,Y)}}function wu(U,H){return!H||Cn(H)!=="object"&&typeof H!="function"?Ti(U):H}function Ti(U){if(U===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return U}function Fo(U){return(Fo=Object.setPrototypeOf?Object.getPrototypeOf:function(H){return H.__proto__||Object.getPrototypeOf(H)})(U)}function Mu(U,H,Y){return H in U?Object.defineProperty(U,H,{value:Y,enumerable:!0,configurable:!0,writable:!0}):U[H]=Y,U}var po=function(U){(function(Oe,$){if(typeof $!="function"&&$!==null)throw new TypeError("Super expression must either be null or a function");Oe.prototype=Object.create($&&$.prototype,{constructor:{value:Oe,writable:!0,configurable:!0}}),$&&ju(Oe,$)})(_e,U);var H,Y,ee,Ce=zu(_e);function _e(Oe){var $;return function(Ne,Je){if(!(Ne instanceof Je))throw new TypeError("Cannot call a class as a function")}(this,_e),Mu(Ti($=Ce.call(this)),"_isShutdown",!1),Mu(Ti($),"_messageQueue",[]),Mu(Ti($),"_timeoutID",null),Mu(Ti($),"_wallUnlisten",null),Mu(Ti($),"_flush",function(){if($._timeoutID!==null&&(clearTimeout($._timeoutID),$._timeoutID=null),$._messageQueue.length){for(var Ne=0;Ne<$._messageQueue.length;Ne+=2){var Je;(Je=$._wall).send.apply(Je,[$._messageQueue[Ne]].concat(cr($._messageQueue[Ne+1])))}$._messageQueue.length=0,$._timeoutID=setTimeout($._flush,100)}}),Mu(Ti($),"overrideValueAtPath",function(Ne){var Je=Ne.id,vt=Ne.path,oe=Ne.rendererID,qe=Ne.type,rt=Ne.value;switch(qe){case"context":$.send("overrideContext",{id:Je,path:vt,rendererID:oe,wasForwarded:!0,value:rt});break;case"hooks":$.send("overrideHookState",{id:Je,path:vt,rendererID:oe,wasForwarded:!0,value:rt});break;case"props":$.send("overrideProps",{id:Je,path:vt,rendererID:oe,wasForwarded:!0,value:rt});break;case"state":$.send("overrideState",{id:Je,path:vt,rendererID:oe,wasForwarded:!0,value:rt})}}),$._wall=Oe,$._wallUnlisten=Oe.listen(function(Ne){Ti($).emit(Ne.event,Ne.payload)})||null,$.addListener("overrideValueAtPath",$.overrideValueAtPath),$}return H=_e,(Y=[{key:"send",value:function(Oe){if(this._isShutdown)console.warn('Cannot send message "'.concat(Oe,'" through a Bridge that has been shutdown.'));else{for(var $=arguments.length,Ne=new Array($>1?$-1:0),Je=1;Je<$;Je++)Ne[Je-1]=arguments[Je];this._messageQueue.push(Oe,Ne),this._timeoutID||(this._timeoutID=setTimeout(this._flush,0))}}},{key:"shutdown",value:function(){if(this._isShutdown)console.warn("Bridge was already shutdown.");else{this.send("shutdown"),this._isShutdown=!0,this.addListener=function(){},this.emit=function(){},this.removeAllListeners();var Oe=this._wallUnlisten;Oe&&Oe();do this._flush();while(this._messageQueue.length);this._timeoutID!==null&&(clearTimeout(this._timeoutID),this._timeoutID=null)}}},{key:"wall",get:function(){return this._wall}}])&&Ou(H.prototype,Y),ee&&Ou(H,ee),_e}(E);function Hu(U,H,Y){var ee=U[H];return U[H]=function(Ce){return Y.call(this,ee,arguments)},ee}function Pa(U,H){for(var Y in H)U[Y]=H[Y]}function v0(U){typeof U.forceUpdate=="function"?U.forceUpdate():U.updater!=null&&typeof U.updater.enqueueForceUpdate=="function"&&U.updater.enqueueForceUpdate(this,function(){},"forceUpdate")}function ia(U,H){var Y=Object.keys(U);if(Object.getOwnPropertySymbols){var ee=Object.getOwnPropertySymbols(U);H&&(ee=ee.filter(function(Ce){return Object.getOwnPropertyDescriptor(U,Ce).enumerable})),Y.push.apply(Y,ee)}return Y}function J0(U){for(var H=1;H<arguments.length;H++){var Y=arguments[H]!=null?arguments[H]:{};H%2?ia(Object(Y),!0).forEach(function(ee){ua(U,ee,Y[ee])}):Object.getOwnPropertyDescriptors?Object.defineProperties(U,Object.getOwnPropertyDescriptors(Y)):ia(Object(Y)).forEach(function(ee){Object.defineProperty(U,ee,Object.getOwnPropertyDescriptor(Y,ee))})}return U}function ua(U,H,Y){return H in U?Object.defineProperty(U,H,{value:Y,enumerable:!0,configurable:!0,writable:!0}):U[H]=Y,U}function Ia(U){return(Ia=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function ms(U){var H=null,Y=null;if(U._currentElement!=null){U._currentElement.key&&(Y=""+U._currentElement.key);var ee=U._currentElement.type;typeof ee=="string"?H=ee:typeof ee=="function"&&(H=vi(ee))}return{displayName:H,key:Y}}function S0(U){if(U._currentElement!=null){var H=U._currentElement.type;if(typeof H=="function")return U.getPublicInstance()!==null?1:5;if(typeof H=="string")return 7}return 9}function Qn(U){var H=[];if(Ia(U)==="object"){if(!(U._currentElement===null||U._currentElement===!1)){if(U._renderedComponent){var Y=U._renderedComponent;S0(Y)!==9&&H.push(Y)}else if(U._renderedChildren){var ee=U._renderedChildren;for(var Ce in ee){var _e=ee[Ce];S0(_e)!==9&&H.push(_e)}}}}return H}function ac(U,H,Y,ee){var Ce,_e=new Map,Oe=new WeakMap,$=new WeakMap,Ne=null;function Je(ut){if(Ia(ut)!=="object"||ut===null)throw new Error("Invalid internal instance: "+ut);if(!Oe.has(ut)){var wt=el();Oe.set(ut,wt),_e.set(wt,ut)}return Oe.get(ut)}function vt(ut,wt){if(ut.length!==wt.length)return!1;for(var et=0;et<ut.length;et++)if(ut[et]!==wt[et])return!1;return!0}Y.ComponentTree?(Ne=function(ut,wt){var et=Y.ComponentTree.getClosestInstanceFromNode(ut);return Oe.get(et)||null},Ce=function(ut){var wt=_e.get(ut);return Y.ComponentTree.getNodeFromInstance(wt)}):Y.Mount.getID&&Y.Mount.getNode&&(Ne=function(ut,wt){return null},Ce=function(ut){return null});var oe=[],qe=null;function rt(ut,wt,et){if(et===0){var It=ut._currentElement!=null&&ut._currentElement._owner!=null;er(1),er(wt),er(11),er(0),er(It?1:0)}else{var un=S0(ut),fn=ms(ut),Jn=fn.displayName,wr=fn.key,au=ut._currentElement!=null&&ut._currentElement._owner!=null?Je(ut._currentElement._owner):0,ku=Cr(Jn),T0=Cr(wr);er(1),er(wt),er(un),er(et),er(au),er(ku),er(T0)}}function xt(ut,wt,et){er(3),er(wt);var It=et.map(Je);er(It.length);for(var un=0;un<It.length;un++)er(It[un])}function kt(ut,wt,et){var It=_e.get(ut);It!=null&&($.set(It,et),rt(It,ut,wt),Qn(It).forEach(function(un){return kt(Je(un),ut,et)}))}Y.Reconciler&&(qe=function(ut,wt){var et={};for(var It in wt)et[It]=Hu(ut,It,wt[It]);return et}(Y.Reconciler,{mountComponent:function(ut,wt){var et=wt[0],It=wt[3];if(S0(et)===9)return ut.apply(this,wt);if(It._topLevelWrapper===void 0)return ut.apply(this,wt);var un=Je(et);rt(et,un,oe.length>0?oe[oe.length-1]:0),oe.push(un),$.set(et,Je(It._topLevelWrapper));try{var fn=ut.apply(this,wt);return oe.pop(),fn}catch(wr){throw oe=[],wr}finally{if(oe.length===0){var Jn=$.get(et);if(Jn===void 0)throw new Error("Expected to find root ID.");dr(Jn)}}},performUpdateIfNecessary:function(ut,wt){var et=wt[0];if(S0(et)===9)return ut.apply(this,wt);var It=Je(et);oe.push(It);var un=Qn(et);try{var fn=ut.apply(this,wt),Jn=Qn(et);return vt(un,Jn)||xt(et,It,Jn),oe.pop(),fn}catch(au){throw oe=[],au}finally{if(oe.length===0){var wr=$.get(et);if(wr===void 0)throw new Error("Expected to find root ID.");dr(wr)}}},receiveComponent:function(ut,wt){var et=wt[0];if(S0(et)===9)return ut.apply(this,wt);var It=Je(et);oe.push(It);var un=Qn(et);try{var fn=ut.apply(this,wt),Jn=Qn(et);return vt(un,Jn)||xt(et,It,Jn),oe.pop(),fn}catch(au){throw oe=[],au}finally{if(oe.length===0){var wr=$.get(et);if(wr===void 0)throw new Error("Expected to find root ID.");dr(wr)}}},unmountComponent:function(ut,wt){var et=wt[0];if(S0(et)===9)return ut.apply(this,wt);var It=Je(et);oe.push(It);try{var un=ut.apply(this,wt);return oe.pop(),function(Jn,wr){rn.push(wr),_e.delete(wr)}(0,It),un}catch(Jn){throw oe=[],Jn}finally{if(oe.length===0){var fn=$.get(et);if(fn===void 0)throw new Error("Expected to find root ID.");dr(fn)}}}}));var bt=[],sn=new Map,rn=[],Ft=0,Dn=null;function dr(ut){if(bt.length!==0||rn.length!==0||Dn!==null){var wt=rn.length+(Dn===null?0:1),et=new Array(3+Ft+(wt>0?2+wt:0)+bt.length),It=0;if(et[It++]=H,et[It++]=ut,et[It++]=Ft,sn.forEach(function(Jn,wr){et[It++]=wr.length;for(var au=Y0(wr),ku=0;ku<au.length;ku++)et[It+ku]=au[ku];It+=wr.length}),wt>0){et[It++]=2,et[It++]=wt;for(var un=0;un<rn.length;un++)et[It++]=rn[un];Dn!==null&&(et[It]=Dn,It++)}for(var fn=0;fn<bt.length;fn++)et[It+fn]=bt[fn];It+=bt.length,U.emit("operations",et),bt.length=0,rn=[],Dn=null,sn.clear(),Ft=0}}function er(ut){bt.push(ut)}function Cr(ut){if(ut===null)return 0;var wt=sn.get(ut);if(wt!==void 0)return wt;var et=sn.size+1;return sn.set(ut,et),Ft+=ut.length+1,et}var Rn=null,Nr={};function y0(ut){return function(wt){var et=Nr[ut];if(!et)return!1;for(var It=0;It<wt.length;It++)if(!(et=et[wt[It]]))return!1;return!0}}function Lr(ut){var wt=_e.get(ut);if(wt==null)return null;var et=ms(wt),It=et.displayName,un=et.key,fn=S0(wt),Jn=null,wr=null,au=null,ku=null,T0=null,Z0=wt._currentElement;if(Z0!==null){au=Z0.props,T0=Z0._source!=null?Z0._source:null;var Nu=Z0._owner;if(Nu)for(wr=[];Nu!=null;)wr.push({displayName:ms(Nu).displayName||"Unknown",id:Je(Nu),type:S0(Nu)}),Nu._currentElement&&(Nu=Nu._currentElement._owner)}var gi=wt._instance;return gi!=null&&(Jn=gi.context||null,ku=gi.state||null),{id:ut,canEditHooks:!1,canEditFunctionProps:!1,canEditHooksAndDeletePaths:!1,canEditHooksAndRenamePaths:!1,canEditFunctionPropsDeletePaths:!1,canEditFunctionPropsRenamePaths:!1,canToggleSuspense:!1,canViewSource:fn===1||fn===5,hasLegacyContext:!0,displayName:It,type:fn,key:un!=null?un:null,context:Jn,hooks:null,props:au,state:ku,owners:wr,source:T0,rootType:null,rendererPackageName:null,rendererVersion:null}}return{cleanup:function(){qe!==null&&(Y.Component?Pa(Y.Component.Mixin,qe):Pa(Y.Reconciler,qe)),qe=null},copyElementPath:function(ut,wt){var et=Lr(ut);et!==null&&X0(Bu(et,wt))},deletePath:function(ut,wt,et,It){var un=_e.get(wt);if(un!=null){var fn=un._instance;if(fn!=null)switch(ut){case"context":K0(fn.context,It),v0(fn);break;case"hooks":throw new Error("Hooks not supported by this renderer");case"props":var Jn=un._currentElement;un._currentElement=J0(J0({},Jn),{},{props:mi(Jn.props,It)}),v0(fn);break;case"state":K0(fn.state,It),v0(fn)}}},flushInitialOperations:function(){var ut=Y.Mount._instancesByReactRootID||Y.Mount._instancesByContainerID;for(var wt in ut){var et=Je(ut[wt]);kt(et,0,et),dr(et)}},getBestMatchForTrackedPath:function(){return null},getDisplayNameForFiberID:function(ut){var wt=_e.get(ut);return wt?ms(wt).displayName:null},getFiberIDForNative:Ne,getInstanceAndStyle:function(ut){var wt=null,et=null,It=_e.get(ut);if(It!=null){wt=It._instance||null;var un=It._currentElement;un!=null&&un.props!=null&&(et=un.props.style||null)}return{instance:wt,style:et}},findNativeNodesForFiberID:function(ut){var wt=Ce(ut);return wt==null?null:[wt]},getOwnersList:function(ut){return null},getPathForElement:function(ut){return null},getProfilingData:function(){throw new Error("getProfilingData not supported by this renderer")},handleCommitFiberRoot:function(){throw new Error("handleCommitFiberRoot not supported by this renderer")},handleCommitFiberUnmount:function(){throw new Error("handleCommitFiberUnmount not supported by this renderer")},inspectElement:function(ut,wt){Rn!==ut&&(Rn=ut,Nr={});var et=Lr(ut);return et===null?{id:ut,type:"not-found"}:(wt!=null&&function(It){var un=Nr;It.forEach(function(fn){un[fn]||(un[fn]={}),un=un[fn]})}(wt),function(It){var un=_e.get(It);if(un!=null)switch(S0(un)){case 1:ee.$r=un._instance;break;case 5:var fn=un._currentElement;if(fn==null)return void console.warn('Could not find element with id "'.concat(It,'"'));ee.$r={props:fn.props,type:fn.type};break;default:ee.$r=null}else console.warn('Could not find instance with id "'.concat(It,'"'))}(ut),et.context=Ri(et.context,y0("context")),et.props=Ri(et.props,y0("props")),et.state=Ri(et.state,y0("state")),{id:ut,type:"full-data",value:et})},logElementToConsole:function(ut){var wt=Lr(ut);if(wt!==null){var et=typeof console.groupCollapsed=="function";et&&console.groupCollapsed("[Click to expand] %c<".concat(wt.displayName||"Component"," />"),"color: var(--dom-tag-name-color); font-weight: normal;"),wt.props!==null&&console.log("Props:",wt.props),wt.state!==null&&console.log("State:",wt.state),wt.context!==null&&console.log("Context:",wt.context);var It=Ce(ut);It!==null&&console.log("Node:",It),(window.chrome||/firefox/i.test(navigator.userAgent))&&console.log("Right-click any value to save it as a global variable for further inspection."),et&&console.groupEnd()}else console.warn('Could not find element with id "'.concat(ut,'"'))},overrideSuspense:function(){throw new Error("overrideSuspense not supported by this renderer")},overrideValueAtPath:function(ut,wt,et,It,un){var fn=_e.get(wt);if(fn!=null){var Jn=fn._instance;if(Jn!=null)switch(ut){case"context":Oo(Jn.context,It,un),v0(Jn);break;case"hooks":throw new Error("Hooks not supported by this renderer");case"props":var wr=fn._currentElement;fn._currentElement=J0(J0({},wr),{},{props:In(wr.props,It,un)}),v0(Jn);break;case"state":Oo(Jn.state,It,un),v0(Jn)}}},renamePath:function(ut,wt,et,It,un){var fn=_e.get(wt);if(fn!=null){var Jn=fn._instance;if(Jn!=null)switch(ut){case"context":Kr(Jn.context,It,un),v0(Jn);break;case"hooks":throw new Error("Hooks not supported by this renderer");case"props":var wr=fn._currentElement;fn._currentElement=J0(J0({},wr),{},{props:en(wr.props,It,un)}),v0(Jn);break;case"state":Kr(Jn.state,It,un),v0(Jn)}}},prepareViewAttributeSource:function(ut,wt){var et=Lr(ut);et!==null&&(window.$attribute=Bu(et,wt))},prepareViewElementSource:function(ut){var wt=_e.get(ut);if(wt!=null){var et=wt._currentElement;et!=null?ee.$type=et.type:console.warn('Could not find element with id "'.concat(ut,'"'))}else console.warn('Could not find instance with id "'.concat(ut,'"'))},renderer:Y,setTraceUpdatesEnabled:function(ut){},setTrackedPath:function(ut){},startProfiling:function(){},stopProfiling:function(){},storeAsGlobal:function(ut,wt,et){var It=Lr(ut);if(It!==null){var un=Bu(It,wt),fn="$reactTemp".concat(et);window[fn]=un,console.log(fn),console.log(un)}},updateComponentFilters:function(ut){}}}function si(U,H){var Y=!1,ee={bottom:0,left:0,right:0,top:0},Ce=H[U];if(Ce!=null){for(var _e=0,Oe=Object.keys(ee);_e<Oe.length;_e++)ee[Oe[_e]]=Ce;Y=!0}var $=H[U+"Horizontal"];if($!=null)ee.left=$,ee.right=$,Y=!0;else{var Ne=H[U+"Left"];Ne!=null&&(ee.left=Ne,Y=!0);var Je=H[U+"Right"];Je!=null&&(ee.right=Je,Y=!0);var vt=H[U+"End"];vt!=null&&(ee.right=vt,Y=!0);var oe=H[U+"Start"];oe!=null&&(ee.left=oe,Y=!0)}var qe=H[U+"Vertical"];if(qe!=null)ee.bottom=qe,ee.top=qe,Y=!0;else{var rt=H[U+"Bottom"];rt!=null&&(ee.bottom=rt,Y=!0);var xt=H[U+"Top"];xt!=null&&(ee.top=xt,Y=!0)}return Y?ee:null}function Jr(U){return(Jr=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(H){return typeof H}:function(H){return H&&typeof Symbol=="function"&&H.constructor===Symbol&&H!==Symbol.prototype?"symbol":typeof H})(U)}function Zl(U,H,Y){return H in U?Object.defineProperty(U,H,{value:Y,enumerable:!0,configurable:!0,writable:!0}):U[H]=Y,U}function oa(U,H,Y,ee){U.addListener("NativeStyleEditor_measure",function(Ce){var _e=Ce.id,Oe=Ce.rendererID;ba(H,U,Y,_e,Oe)}),U.addListener("NativeStyleEditor_renameAttribute",function(Ce){var _e=Ce.id,Oe=Ce.rendererID,$=Ce.oldName,Ne=Ce.newName,Je=Ce.value;(function(vt,oe,qe,rt,xt,kt){var bt,sn=vt.getInstanceAndStyle({id:oe,rendererID:qe});if(!(!sn||!sn.style)){var rn,Ft=sn.instance,Dn=sn.style,dr=xt?(Zl(bt={},rt,void 0),Zl(bt,xt,kt),bt):Zl({},rt,void 0);if(Ft!==null&&typeof Ft.setNativeProps=="function"){var er=bs.get(oe);er?Object.assign(er,dr):bs.set(oe,dr),Ft.setNativeProps({style:dr})}else if(Array.isArray(Dn)){var Cr=Dn.length-1;Jr(Dn[Cr])!=="object"||Array.isArray(Dn[Cr])?vt.overrideValueAtPath({type:"props",id:oe,rendererID:qe,path:["style"],value:Dn.concat([dr])}):(delete(rn=Bs(Dn[Cr]))[rt],xt?rn[xt]=kt:rn[rt]=void 0,vt.overrideValueAtPath({type:"props",id:oe,rendererID:qe,path:["style",Cr],value:rn}))}else Jr(Dn)==="object"?(delete(rn=Bs(Dn))[rt],xt?rn[xt]=kt:rn[rt]=void 0,vt.overrideValueAtPath({type:"props",id:oe,rendererID:qe,path:["style"],value:rn})):vt.overrideValueAtPath({type:"props",id:oe,rendererID:qe,path:["style"],value:[Dn,dr]});vt.emit("hideNativeHighlight")}})(H,_e,Oe,$,Ne,Je),setTimeout(function(){return ba(H,U,Y,_e,Oe)})}),U.addListener("NativeStyleEditor_setValue",function(Ce){var _e=Ce.id,Oe=Ce.rendererID,$=Ce.name,Ne=Ce.value;(function(Je,vt,oe,qe,rt){var xt=Je.getInstanceAndStyle({id:vt,rendererID:oe});if(!(!xt||!xt.style)){var kt=xt.instance,bt=xt.style,sn=Zl({},qe,rt);if(kt!==null&&typeof kt.setNativeProps=="function"){var rn=bs.get(vt);rn?Object.assign(rn,sn):bs.set(vt,sn),kt.setNativeProps({style:sn})}else if(Array.isArray(bt)){var Ft=bt.length-1;Jr(bt[Ft])!=="object"||Array.isArray(bt[Ft])?Je.overrideValueAtPath({type:"props",id:vt,rendererID:oe,path:["style"],value:bt.concat([sn])}):Je.overrideValueAtPath({type:"props",id:vt,rendererID:oe,path:["style",Ft,qe],value:rt})}else Je.overrideValueAtPath({type:"props",id:vt,rendererID:oe,path:["style"],value:[bt,sn]});Je.emit("hideNativeHighlight")}})(H,_e,Oe,$,Ne),setTimeout(function(){return ba(H,U,Y,_e,Oe)})}),U.send("isNativeStyleEditorSupported",{isSupported:!0,validAttributes:ee})}var pf={top:0,left:0,right:0,bottom:0},bs=new Map;function ba(U,H,Y,ee,Ce){var _e=U.getInstanceAndStyle({id:ee,rendererID:Ce});if(_e&&_e.style){var Oe=_e.instance,$=Y(_e.style),Ne=bs.get(ee);Ne!=null&&($=Object.assign({},$,Ne)),Oe&&typeof Oe.measure=="function"?Oe.measure(function(Je,vt,oe,qe,rt,xt){if(typeof Je=="number"){var kt=$!=null&&si("margin",$)||pf,bt=$!=null&&si("padding",$)||pf;H.send("NativeStyleEditor_styleAndLayout",{id:ee,layout:{x:Je,y:vt,width:oe,height:qe,left:rt,top:xt,margin:kt,padding:bt},style:$||null})}else H.send("NativeStyleEditor_styleAndLayout",{id:ee,layout:null,style:$||null})}):H.send("NativeStyleEditor_styleAndLayout",{id:ee,layout:null,style:$||null})}else H.send("NativeStyleEditor_styleAndLayout",{id:ee,layout:null,style:null})}function Bs(U){var H={};for(var Y in U)H[Y]=U[Y];return H}(function(U){if(U.hasOwnProperty("__REACT_DEVTOOLS_GLOBAL_HOOK__"))return null;var H=0,Y=!1,ee={},Ce=new Map,_e={},Oe=new Map,$={rendererInterfaces:Ce,listeners:_e,renderers:Oe,emit:function(Ne,Je){_e[Ne]&&_e[Ne].map(function(vt){return vt(Je)})},getFiberRoots:function(Ne){var Je=ee;return Je[Ne]||(Je[Ne]=new Set),Je[Ne]},inject:function(Ne){var Je=++H;Oe.set(Je,Ne);var vt=Y?"deadcode":function(kt){try{if(typeof kt.version=="string")return kt.bundleType>0?"development":"production";var bt=Function.prototype.toString;if(kt.Mount&&kt.Mount._renderNewRootComponent){var sn=bt.call(kt.Mount._renderNewRootComponent);return sn.indexOf("function")!==0?"production":sn.indexOf("storedMeasure")!==-1?"development":sn.indexOf("should be a pure function")!==-1?sn.indexOf("NODE_ENV")!==-1||sn.indexOf("development")!==-1||sn.indexOf("true")!==-1?"development":sn.indexOf("nextElement")!==-1||sn.indexOf("nextComponent")!==-1?"unminified":"development":sn.indexOf("nextElement")!==-1||sn.indexOf("nextComponent")!==-1?"unminified":"outdated"}}catch{}return"production"}(Ne);try{var oe=window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__!==!1,qe=window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__===!0;(oe||qe)&&(co(Ne),Jl({appendComponentStack:oe,breakOnConsoleErrors:qe}))}catch{}var rt=U.__REACT_DEVTOOLS_ATTACH__;if(typeof rt=="function"){var xt=rt($,Je,Ne,U);$.rendererInterfaces.set(Je,xt)}return $.emit("renderer",{id:Je,renderer:Ne,reactBuildType:vt}),Je},on:function(Ne,Je){_e[Ne]||(_e[Ne]=[]),_e[Ne].push(Je)},off:function(Ne,Je){if(_e[Ne]){var vt=_e[Ne].indexOf(Je);vt!==-1&&_e[Ne].splice(vt,1),_e[Ne].length||delete _e[Ne]}},sub:function(Ne,Je){return $.on(Ne,Je),function(){return $.off(Ne,Je)}},supportsFiber:!0,checkDCE:function(Ne){try{Function.prototype.toString.call(Ne).indexOf("^_^")>-1&&(Y=!0,setTimeout(function(){throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://reactjs.org/link/perf-use-production-build")}))}catch{}},onCommitFiberUnmount:function(Ne,Je){var vt=Ce.get(Ne);vt!=null&&vt.handleCommitFiberUnmount(Je)},onCommitFiberRoot:function(Ne,Je,vt){var oe=$.getFiberRoots(Ne),qe=Je.current,rt=oe.has(Je),xt=qe.memoizedState==null||qe.memoizedState.element==null;rt||xt?rt&&xt&&oe.delete(Je):oe.add(Je);var kt=Ce.get(Ne);kt!=null&&kt.handleCommitFiberRoot(Je,vt)}};Object.defineProperty(U,"__REACT_DEVTOOLS_GLOBAL_HOOK__",{configurable:!1,enumerable:!1,get:function(){return $}})})(window);var m0=window.__REACT_DEVTOOLS_GLOBAL_HOOK__,Us=[{type:1,value:7,isEnabled:!0}];function zi(U){if(m0!=null){var H=U||{},Y=H.host,ee=Y===void 0?"localhost":Y,Ce=H.nativeStyleEditorValidAttributes,_e=H.useHttps,Oe=_e!==void 0&&_e,$=H.port,Ne=$===void 0?8097:$,Je=H.websocket,vt=H.resolveRNStyle,oe=vt===void 0?null:vt,qe=H.isAppActive,rt=Oe?"wss":"ws",xt=null;if((qe===void 0?function(){return!0}:qe)()){var kt=null,bt=[],sn=rt+"://"+ee+":"+Ne,rn=Je||new window.WebSocket(sn);rn.onclose=function(){kt!==null&&kt.emit("shutdown"),Ft()},rn.onerror=function(){Ft()},rn.onmessage=function(Dn){var dr;try{if(typeof Dn.data!="string")throw Error();dr=JSON.parse(Dn.data)}catch{return void console.error("[React DevTools] Failed to parse JSON: "+Dn.data)}bt.forEach(function(er){try{er(dr)}catch(Cr){throw console.log("[React DevTools] Error calling listener",dr),console.log("error:",Cr),Cr}})},rn.onopen=function(){(kt=new po({listen:function(Rn){return bt.push(Rn),function(){var Nr=bt.indexOf(Rn);Nr>=0&&bt.splice(Nr,1)}},send:function(Rn,Nr,y0){rn.readyState===rn.OPEN?rn.send(JSON.stringify({event:Rn,payload:Nr})):(kt!==null&&kt.shutdown(),Ft())}})).addListener("inspectElement",function(Rn){var Nr=Rn.id,y0=Rn.rendererID,Lr=Dn.rendererInterfaces[y0];if(Lr!=null){var ut=Lr.findNativeNodesForFiberID(Nr);ut!=null&&ut[0]!=null&&Dn.emit("showNativeHighlight",ut[0])}}),kt.addListener("updateComponentFilters",function(Rn){Us=Rn}),window.__REACT_DEVTOOLS_COMPONENT_FILTERS__==null&&kt.send("overrideComponentFilters",Us);var Dn=new Yn(kt);if(Dn.addListener("shutdown",function(){m0.emit("shutdown")}),function(Rn,Nr,y0){if(Rn==null)return function(){};var Lr=[Rn.sub("renderer-attached",function(et){var It=et.id,un=(et.renderer,et.rendererInterface);Nr.setRendererInterface(It,un),un.flushInitialOperations()}),Rn.sub("unsupported-renderer-version",function(et){Nr.onUnsupportedRenderer(et)}),Rn.sub("operations",Nr.onHookOperations),Rn.sub("traceUpdates",Nr.onTraceUpdates)],ut=function(et,It){var un=Rn.rendererInterfaces.get(et);un==null&&(typeof It.findFiberByHostInstance=="function"?un=Is(Rn,et,It,y0):It.ComponentTree&&(un=ac(Rn,et,It,y0)),un!=null&&Rn.rendererInterfaces.set(et,un)),un!=null?Rn.emit("renderer-attached",{id:et,renderer:It,rendererInterface:un}):Rn.emit("unsupported-renderer-version",et)};Rn.renderers.forEach(function(et,It){ut(It,et)}),Lr.push(Rn.sub("renderer",function(et){var It=et.id,un=et.renderer;ut(It,un)})),Rn.emit("react-devtools",Nr),Rn.reactDevtoolsAgent=Nr;var wt=function(){Lr.forEach(function(et){return et()}),Rn.rendererInterfaces.forEach(function(et){et.cleanup()}),Rn.reactDevtoolsAgent=null};Nr.addListener("shutdown",wt),Lr.push(function(){Nr.removeListener("shutdown",wt)})}(m0,Dn,window),oe!=null||m0.resolveRNStyle!=null)oa(kt,Dn,oe||m0.resolveRNStyle,Ce||m0.nativeStyleEditorValidAttributes||null);else{var dr,er,Cr=function(){kt!==null&&oa(kt,Dn,dr,er)};m0.hasOwnProperty("resolveRNStyle")||Object.defineProperty(m0,"resolveRNStyle",{enumerable:!1,get:function(){return dr},set:function(Rn){dr=Rn,Cr()}}),m0.hasOwnProperty("nativeStyleEditorValidAttributes")||Object.defineProperty(m0,"nativeStyleEditorValidAttributes",{enumerable:!1,get:function(){return er},set:function(Rn){er=Rn,Cr()}})}}}else Ft()}function Ft(){xt===null&&(xt=setTimeout(function(){return zi(U)},2e3))}}}])})});var FC=nt(LC=>{"use strict";Object.defineProperty(LC,"__esModule",{value:!0});kC();var wb=NC();wb.connectToDevTools()});var UC=nt(sg=>{"use strict";var BC=sg&&sg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(sg,"__esModule",{value:!0});var PC=z_(),Sb=BC(YS()),IC=BC(eh()),ps=BD();process.env.DEV==="true"&&FC();var bC=o=>{o==null||o.unsetMeasureFunc(),o==null||o.freeRecursive()};sg.default=Sb.default({schedulePassiveEffects:PC.unstable_scheduleCallback,cancelPassiveEffects:PC.unstable_cancelCallback,now:Date.now,getRootHostContext:()=>({isInsideText:!1}),prepareForCommit:()=>{},resetAfterCommit:o=>{if(o.isStaticDirty){o.isStaticDirty=!1,typeof o.onImmediateRender=="function"&&o.onImmediateRender();return}typeof o.onRender=="function"&&o.onRender()},getChildHostContext:(o,l)=>{let f=o.isInsideText,h=l==="ink-text"||l==="ink-virtual-text";return f===h?o:{isInsideText:h}},shouldSetTextContent:()=>!1,createInstance:(o,l,f,h)=>{if(h.isInsideText&&o==="ink-box")throw new Error("<Box> can\u2019t be nested inside <Text> component");let E=o==="ink-text"&&h.isInsideText?"ink-virtual-text":o,t=ps.createNode(E);for(let[N,F]of Object.entries(l))N!=="children"&&(N==="style"?ps.setStyle(t,F):N==="internal_transform"?t.internal_transform=F:N==="internal_static"?t.internal_static=!0:ps.setAttribute(t,N,F));return t},createTextInstance:(o,l,f)=>{if(!f.isInsideText)throw new Error(`Text string "${o}" must be rendered inside <Text> component`);return ps.createTextNode(o)},resetTextContent:()=>{},hideTextInstance:o=>{ps.setTextNodeValue(o,"")},unhideTextInstance:(o,l)=>{ps.setTextNodeValue(o,l)},getPublicInstance:o=>o,hideInstance:o=>{var l;(l=o.yogaNode)===null||l===void 0||l.setDisplay(IC.default.DISPLAY_NONE)},unhideInstance:o=>{var l;(l=o.yogaNode)===null||l===void 0||l.setDisplay(IC.default.DISPLAY_FLEX)},appendInitialChild:ps.appendChildNode,appendChild:ps.appendChildNode,insertBefore:ps.insertBeforeNode,finalizeInitialChildren:(o,l,f,h)=>(o.internal_static&&(h.isStaticDirty=!0,h.staticNode=o),!1),supportsMutation:!0,appendChildToContainer:ps.appendChildNode,insertInContainerBefore:ps.insertBeforeNode,removeChildFromContainer:(o,l)=>{ps.removeChildNode(o,l),bC(l.yogaNode)},prepareUpdate:(o,l,f,h,E)=>{o.internal_static&&(E.isStaticDirty=!0);let t={},N=Object.keys(h);for(let F of N)if(h[F]!==f[F]){if(F==="style"&&typeof h.style=="object"&&typeof f.style=="object"){let x=h.style,j=f.style,q=Object.keys(x);for(let V of q){if(V==="borderStyle"||V==="borderColor"){if(typeof t.style!="object"){let re={};t.style=re}t.style.borderStyle=x.borderStyle,t.style.borderColor=x.borderColor}if(x[V]!==j[V]){if(typeof t.style!="object"){let re={};t.style=re}t.style[V]=x[V]}}continue}t[F]=h[F]}return t},commitUpdate:(o,l)=>{for(let[f,h]of Object.entries(l))f!=="children"&&(f==="style"?ps.setStyle(o,h):f==="internal_transform"?o.internal_transform=h:f==="internal_static"?o.internal_static=!0:ps.setAttribute(o,f,h))},commitTextUpdate:(o,l,f)=>{ps.setTextNodeValue(o,f)},removeChild:(o,l)=>{ps.removeChildNode(o,l),bC(l.yogaNode)}})});var zC=nt((sq,jC)=>{"use strict";jC.exports=(o,l=1,f)=>{if(f={indent:" ",includeEmptyLines:!1,...f},typeof o!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof o}\``);if(typeof l!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof l}\``);if(typeof f.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof f.indent}\``);if(l===0)return o;let h=f.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return o.replace(h,f.indent.repeat(l))}});var HC=nt(ag=>{"use strict";var Tb=ag&&ag.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(ag,"__esModule",{value:!0});var r4=Tb(eh());ag.default=o=>o.getComputedWidth()-o.getComputedPadding(r4.default.EDGE_LEFT)-o.getComputedPadding(r4.default.EDGE_RIGHT)-o.getComputedBorder(r4.default.EDGE_LEFT)-o.getComputedBorder(r4.default.EDGE_RIGHT)});var qC=nt((fq,Cb)=>{Cb.exports={single:{topLeft:"\u250C",topRight:"\u2510",bottomRight:"\u2518",bottomLeft:"\u2514",vertical:"\u2502",horizontal:"\u2500"},double:{topLeft:"\u2554",topRight:"\u2557",bottomRight:"\u255D",bottomLeft:"\u255A",vertical:"\u2551",horizontal:"\u2550"},round:{topLeft:"\u256D",topRight:"\u256E",bottomRight:"\u256F",bottomLeft:"\u2570",vertical:"\u2502",horizontal:"\u2500"},bold:{topLeft:"\u250F",topRight:"\u2513",bottomRight:"\u251B",bottomLeft:"\u2517",vertical:"\u2503",horizontal:"\u2501"},singleDouble:{topLeft:"\u2553",topRight:"\u2556",bottomRight:"\u255C",bottomLeft:"\u2559",vertical:"\u2551",horizontal:"\u2500"},doubleSingle:{topLeft:"\u2552",topRight:"\u2555",bottomRight:"\u255B",bottomLeft:"\u2558",vertical:"\u2502",horizontal:"\u2550"},classic:{topLeft:"+",topRight:"+",bottomRight:"+",bottomLeft:"+",vertical:"|",horizontal:"-"}}});var VC=nt((cq,c3)=>{"use strict";var WC=qC();c3.exports=WC;c3.exports.default=WC});var YC=nt((dq,GC)=>{"use strict";GC.exports=(o,l=process.argv)=>{let f=o.startsWith("-")?"":o.length===1?"-":"--",h=l.indexOf(f+o),E=l.indexOf("--");return h!==-1&&(E===-1||h<E)}});var QC=nt((pq,XC)=>{"use strict";var xb=hi("os"),KC=hi("tty"),df=YC(),{env:Xo}=process,h2;df("no-color")||df("no-colors")||df("color=false")||df("color=never")?h2=0:(df("color")||df("colors")||df("color=true")||df("color=always"))&&(h2=1);"FORCE_COLOR"in Xo&&(Xo.FORCE_COLOR==="true"?h2=1:Xo.FORCE_COLOR==="false"?h2=0:h2=Xo.FORCE_COLOR.length===0?1:Math.min(parseInt(Xo.FORCE_COLOR,10),3));function d3(o){return o===0?!1:{level:o,hasBasic:!0,has256:o>=2,has16m:o>=3}}function p3(o,l){if(h2===0)return 0;if(df("color=16m")||df("color=full")||df("color=truecolor"))return 3;if(df("color=256"))return 2;if(o&&!l&&h2===void 0)return 0;let f=h2||0;if(Xo.TERM==="dumb")return f;if(process.platform==="win32"){let h=xb.release().split(".");return Number(h[0])>=10&&Number(h[2])>=10586?Number(h[2])>=14931?3:2:1}if("CI"in Xo)return["TRAVIS","CIRCLECI","APPVEYOR","GITLAB_CI"].some(h=>h in Xo)||Xo.CI_NAME==="codeship"?1:f;if("TEAMCITY_VERSION"in Xo)return/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(Xo.TEAMCITY_VERSION)?1:0;if("GITHUB_ACTIONS"in Xo)return 1;if(Xo.COLORTERM==="truecolor")return 3;if("TERM_PROGRAM"in Xo){let h=parseInt((Xo.TERM_PROGRAM_VERSION||"").split(".")[0],10);switch(Xo.TERM_PROGRAM){case"iTerm.app":return h>=3?3:2;case"Apple_Terminal":return 2}}return/-256(color)?$/i.test(Xo.TERM)?2:/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(Xo.TERM)||"COLORTERM"in Xo?1:f}function Rb(o){let l=p3(o,o&&o.isTTY);return d3(l)}XC.exports={supportsColor:Rb,stdout:d3(p3(!0,KC.isatty(1))),stderr:d3(p3(!0,KC.isatty(2)))}});var ZC=nt((hq,JC)=>{"use strict";var Ab=(o,l,f)=>{let h=o.indexOf(l);if(h===-1)return o;let E=l.length,t=0,N="";do N+=o.substr(t,h-t)+l+f,t=h+E,h=o.indexOf(l,t);while(h!==-1);return N+=o.substr(t),N},Ob=(o,l,f,h)=>{let E=0,t="";do{let N=o[h-1]==="\r";t+=o.substr(E,(N?h-1:h)-E)+l+(N?`\r
+`:`
+`)+f,E=h+1,h=o.indexOf(`
+`,E)}while(h!==-1);return t+=o.substr(E),t};JC.exports={stringReplaceAll:Ab,stringEncaseCRLFWithFirstIndex:Ob}});var r6=nt((vq,n6)=>{"use strict";var Mb=/(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi,$C=/(?:^|\.)(\w+)(?:\(([^)]*)\))?/g,kb=/^(['"])((?:\\.|(?!\1)[^\\])*)\1$/,Nb=/\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi,Lb=new Map([["n",`
+`],["r","\r"],["t","	"],["b","\b"],["f","\f"],["v","\v"],["0","\0"],["\\","\\"],["e","\x1B"],["a","\x07"]]);function t6(o){let l=o[0]==="u",f=o[1]==="{";return l&&!f&&o.length===5||o[0]==="x"&&o.length===3?String.fromCharCode(parseInt(o.slice(1),16)):l&&f?String.fromCodePoint(parseInt(o.slice(2,-1),16)):Lb.get(o)||o}function Fb(o,l){let f=[],h=l.trim().split(/\s*,\s*/g),E;for(let t of h){let N=Number(t);if(!Number.isNaN(N))f.push(N);else if(E=t.match(kb))f.push(E[2].replace(Nb,(F,k,x)=>k?t6(k):x));else throw new Error(`Invalid Chalk template style argument: ${t} (in style '${o}')`)}return f}function Pb(o){$C.lastIndex=0;let l=[],f;for(;(f=$C.exec(o))!==null;){let h=f[1];if(f[2]){let E=Fb(h,f[2]);l.push([h].concat(E))}else l.push([h])}return l}function e6(o,l){let f={};for(let E of l)for(let t of E.styles)f[t[0]]=E.inverse?null:t.slice(1);let h=o;for(let[E,t]of Object.entries(f))if(!!Array.isArray(t)){if(!(E in h))throw new Error(`Unknown Chalk style: ${E}`);h=t.length>0?h[E](...t):h[E]}return h}n6.exports=(o,l)=>{let f=[],h=[],E=[];if(l.replace(Mb,(t,N,F,k,x,j)=>{if(N)E.push(t6(N));else if(k){let q=E.join("");E=[],h.push(f.length===0?q:e6(o,f)(q)),f.push({inverse:F,styles:Pb(k)})}else if(x){if(f.length===0)throw new Error("Found extraneous } in Chalk template literal");h.push(e6(o,f)(E.join(""))),E=[],f.pop()}else E.push(j)}),h.push(E.join("")),f.length>0){let t=`Chalk template literal is missing ${f.length} closing bracket${f.length===1?"":"s"} (\`}\`)`;throw new Error(t)}return h.join("")}});var s4=nt((mq,a6)=>{"use strict";var fg=G_(),{stdout:v3,stderr:m3}=QC(),{stringReplaceAll:Ib,stringEncaseCRLFWithFirstIndex:bb}=ZC(),{isArray:i4}=Array,u6=["ansi","ansi","ansi256","ansi16m"],nm=Object.create(null),Bb=(o,l={})=>{if(l.level&&!(Number.isInteger(l.level)&&l.level>=0&&l.level<=3))throw new Error("The `level` option should be an integer from 0 to 3");let f=v3?v3.level:0;o.level=l.level===void 0?f:l.level},y3=class{constructor(l){return o6(l)}},o6=o=>{let l={};return Bb(l,o),l.template=(...f)=>s6(l.template,...f),Object.setPrototypeOf(l,u4.prototype),Object.setPrototypeOf(l.template,l),l.template.constructor=()=>{throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.")},l.template.Instance=y3,l.template};function u4(o){return o6(o)}for(let[o,l]of Object.entries(fg))nm[o]={get(){let f=o4(this,g3(l.open,l.close,this._styler),this._isEmpty);return Object.defineProperty(this,o,{value:f}),f}};nm.visible={get(){let o=o4(this,this._styler,!0);return Object.defineProperty(this,"visible",{value:o}),o}};var l6=["rgb","hex","keyword","hsl","hsv","hwb","ansi","ansi256"];for(let o of l6)nm[o]={get(){let{level:l}=this;return function(...f){let h=g3(fg.color[u6[l]][o](...f),fg.color.close,this._styler);return o4(this,h,this._isEmpty)}}};for(let o of l6){let l="bg"+o[0].toUpperCase()+o.slice(1);nm[l]={get(){let{level:f}=this;return function(...h){let E=g3(fg.bgColor[u6[f]][o](...h),fg.bgColor.close,this._styler);return o4(this,E,this._isEmpty)}}}}var Ub=Object.defineProperties(()=>{},{...nm,level:{enumerable:!0,get(){return this._generator.level},set(o){this._generator.level=o}}}),g3=(o,l,f)=>{let h,E;return f===void 0?(h=o,E=l):(h=f.openAll+o,E=l+f.closeAll),{open:o,close:l,openAll:h,closeAll:E,parent:f}},o4=(o,l,f)=>{let h=(...E)=>i4(E[0])&&i4(E[0].raw)?i6(h,s6(h,...E)):i6(h,E.length===1?""+E[0]:E.join(" "));return Object.setPrototypeOf(h,Ub),h._generator=o,h._styler=l,h._isEmpty=f,h},i6=(o,l)=>{if(o.level<=0||!l)return o._isEmpty?"":l;let f=o._styler;if(f===void 0)return l;let{openAll:h,closeAll:E}=f;if(l.indexOf("\x1B")!==-1)for(;f!==void 0;)l=Ib(l,f.close,f.open),f=f.parent;let t=l.indexOf(`
+`);return t!==-1&&(l=bb(l,E,h,t)),h+l+E},h3,s6=(o,...l)=>{let[f]=l;if(!i4(f)||!i4(f.raw))return l.join(" ");let h=l.slice(1),E=[f.raw[0]];for(let t=1;t<f.length;t++)E.push(String(h[t-1]).replace(/[{}\\]/g,"\\$&"),String(f.raw[t]));return h3===void 0&&(h3=r6()),h3(o,E.join(""))};Object.defineProperties(u4.prototype,nm);var l4=u4();l4.supportsColor=v3;l4.stderr=u4({level:m3?m3.level:0});l4.stderr.supportsColor=m3;a6.exports=l4});var _3=nt(dg=>{"use strict";var jb=dg&&dg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(dg,"__esModule",{value:!0});var cg=jb(s4()),zb=/^(rgb|hsl|hsv|hwb)\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/,Hb=/^(ansi|ansi256)\(\s?(\d+)\s?\)$/,a4=(o,l)=>l==="foreground"?o:"bg"+o[0].toUpperCase()+o.slice(1);dg.default=(o,l,f)=>{if(!l)return o;if(l in cg.default){let E=a4(l,f);return cg.default[E](o)}if(l.startsWith("#")){let E=a4("hex",f);return cg.default[E](l)(o)}if(l.startsWith("ansi")){let E=Hb.exec(l);if(!E)return o;let t=a4(E[1],f),N=Number(E[2]);return cg.default[t](N)(o)}if(l.startsWith("rgb")||l.startsWith("hsl")||l.startsWith("hsv")||l.startsWith("hwb")){let E=zb.exec(l);if(!E)return o;let t=a4(E[1],f),N=Number(E[2]),F=Number(E[3]),k=Number(E[4]);return cg.default[t](N,F,k)(o)}return o}});var c6=nt(pg=>{"use strict";var f6=pg&&pg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(pg,"__esModule",{value:!0});var qb=f6(VC()),E3=f6(_3());pg.default=(o,l,f,h)=>{if(typeof f.style.borderStyle=="string"){let E=f.yogaNode.getComputedWidth(),t=f.yogaNode.getComputedHeight(),N=f.style.borderColor,F=qb.default[f.style.borderStyle],k=E3.default(F.topLeft+F.horizontal.repeat(E-2)+F.topRight,N,"foreground"),x=(E3.default(F.vertical,N,"foreground")+`
+`).repeat(t-2),j=E3.default(F.bottomLeft+F.horizontal.repeat(E-2)+F.bottomRight,N,"foreground");h.write(o,l,k,{transformers:[]}),h.write(o,l+1,x,{transformers:[]}),h.write(o+E-1,l+1,x,{transformers:[]}),h.write(o,l+t-1,j,{transformers:[]})}}});var p6=nt(hg=>{"use strict";var ih=hg&&hg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(hg,"__esModule",{value:!0});var Wb=ih(eh()),Vb=ih(xD()),Gb=ih(zC()),Yb=ih(PD()),Kb=ih(HC()),Xb=ih(bD()),Qb=ih(c6()),Jb=(o,l)=>{var f;let h=(f=o.childNodes[0])===null||f===void 0?void 0:f.yogaNode;if(h){let E=h.getComputedLeft(),t=h.getComputedTop();l=`
+`.repeat(t)+Gb.default(l,E)}return l},d6=(o,l,f)=>{var h;let{offsetX:E=0,offsetY:t=0,transformers:N=[],skipStaticElements:F}=f;if(F&&o.internal_static)return;let{yogaNode:k}=o;if(k){if(k.getDisplay()===Wb.default.DISPLAY_NONE)return;let x=E+k.getComputedLeft(),j=t+k.getComputedTop(),q=N;if(typeof o.internal_transform=="function"&&(q=[o.internal_transform,...N]),o.nodeName==="ink-text"){let V=Xb.default(o);if(V.length>0){let re=Vb.default(V),y=Kb.default(k);if(re>y){let me=(h=o.style.textWrap)!==null&&h!==void 0?h:"wrap";V=Yb.default(V,y,me)}V=Jb(o,V),l.write(x,j,V,{transformers:q})}return}if(o.nodeName==="ink-box"&&Qb.default(x,j,o,l),o.nodeName==="ink-root"||o.nodeName==="ink-box")for(let V of o.childNodes)d6(V,l,{offsetX:x,offsetY:j,transformers:q,skipStaticElements:F})}};hg.default=d6});var v6=nt((Eq,h6)=>{"use strict";h6.exports=o=>{o=Object.assign({onlyFirst:!1},o);let l=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|");return new RegExp(l,o.onlyFirst?void 0:"g")}});var y6=nt((Dq,D3)=>{"use strict";var Zb=v6(),m6=o=>typeof o=="string"?o.replace(Zb(),""):o;D3.exports=m6;D3.exports.default=m6});var E6=nt((wq,_6)=>{"use strict";var g6="[\uD800-\uDBFF][\uDC00-\uDFFF]";_6.exports=o=>o&&o.exact?new RegExp(`^${g6}$`):new RegExp(g6,"g")});var w6=nt((Sq,w3)=>{"use strict";var $b=y6(),eB=E6(),D6=o=>$b(o).replace(eB()," ").length;w3.exports=D6;w3.exports.default=D6});var C6=nt(vg=>{"use strict";var T6=vg&&vg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(vg,"__esModule",{value:!0});var S6=T6(LD()),tB=T6(w6()),S3=class{constructor(l){this.writes=[];let{width:f,height:h}=l;this.width=f,this.height=h}write(l,f,h,E){let{transformers:t}=E;!h||this.writes.push({x:l,y:f,text:h,transformers:t})}get(){let l=[];for(let h=0;h<this.height;h++)l.push(" ".repeat(this.width));for(let h of this.writes){let{x:E,y:t,text:N,transformers:F}=h,k=N.split(`
+`),x=0;for(let j of k){let q=l[t+x];if(!q)continue;let V=tB.default(j);for(let re of F)j=re(j);l[t+x]=S6.default(q,0,E)+j+S6.default(q,E+V),x++}}return{output:l.map(h=>h.trimRight()).join(`
+`),height:l.length}}};vg.default=S3});var A6=nt(mg=>{"use strict";var T3=mg&&mg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(mg,"__esModule",{value:!0});var nB=T3(eh()),x6=T3(p6()),R6=T3(C6());mg.default=(o,l)=>{var f;if(o.yogaNode.setWidth(l),o.yogaNode){o.yogaNode.calculateLayout(void 0,void 0,nB.default.DIRECTION_LTR);let h=new R6.default({width:o.yogaNode.getComputedWidth(),height:o.yogaNode.getComputedHeight()});x6.default(o,h,{skipStaticElements:!0});let E;!((f=o.staticNode)===null||f===void 0)&&f.yogaNode&&(E=new R6.default({width:o.staticNode.yogaNode.getComputedWidth(),height:o.staticNode.yogaNode.getComputedHeight()}),x6.default(o.staticNode,E,{skipStaticElements:!1}));let{output:t,height:N}=h.get();return{output:t,outputHeight:N,staticOutput:E?`${E.get().output}
+`:""}}return{output:"",outputHeight:0,staticOutput:""}}});var N6=nt((xq,k6)=>{"use strict";var O6=hi("stream"),M6=["assert","count","countReset","debug","dir","dirxml","error","group","groupCollapsed","groupEnd","info","log","table","time","timeEnd","timeLog","trace","warn"],C3={},rB=o=>{let l=new O6.PassThrough,f=new O6.PassThrough;l.write=E=>o("stdout",E),f.write=E=>o("stderr",E);let h=new console.Console(l,f);for(let E of M6)C3[E]=console[E],console[E]=h[E];return()=>{for(let E of M6)console[E]=C3[E];C3={}}};k6.exports=rB});var R3=nt(x3=>{"use strict";Object.defineProperty(x3,"__esModule",{value:!0});x3.default=new WeakMap});var O3=nt(A3=>{"use strict";Object.defineProperty(A3,"__esModule",{value:!0});var iB=Mi(),L6=iB.createContext({exit:()=>{}});L6.displayName="InternalAppContext";A3.default=L6});var k3=nt(M3=>{"use strict";Object.defineProperty(M3,"__esModule",{value:!0});var uB=Mi(),F6=uB.createContext({stdin:void 0,setRawMode:()=>{},isRawModeSupported:!1,internal_exitOnCtrlC:!0});F6.displayName="InternalStdinContext";M3.default=F6});var L3=nt(N3=>{"use strict";Object.defineProperty(N3,"__esModule",{value:!0});var oB=Mi(),P6=oB.createContext({stdout:void 0,write:()=>{}});P6.displayName="InternalStdoutContext";N3.default=P6});var P3=nt(F3=>{"use strict";Object.defineProperty(F3,"__esModule",{value:!0});var lB=Mi(),I6=lB.createContext({stderr:void 0,write:()=>{}});I6.displayName="InternalStderrContext";F3.default=I6});var f4=nt(I3=>{"use strict";Object.defineProperty(I3,"__esModule",{value:!0});var sB=Mi(),b6=sB.createContext({activeId:void 0,add:()=>{},remove:()=>{},activate:()=>{},deactivate:()=>{},enableFocus:()=>{},disableFocus:()=>{},focusNext:()=>{},focusPrevious:()=>{}});b6.displayName="InternalFocusContext";I3.default=b6});var U6=nt((Lq,B6)=>{"use strict";var aB=/[|\\{}()[\]^$+*?.-]/g;B6.exports=o=>{if(typeof o!="string")throw new TypeError("Expected a string");return o.replace(aB,"\\$&")}});var q6=nt((Fq,H6)=>{"use strict";var fB=U6(),z6=[].concat(hi("module").builtinModules,"bootstrap_node","node").map(o=>new RegExp(`(?:\\(${o}\\.js:\\d+:\\d+\\)$|^\\s*at ${o}\\.js:\\d+:\\d+$)`));z6.push(/\(internal\/[^:]+:\d+:\d+\)$/,/\s*at internal\/[^:]+:\d+:\d+$/,/\/\.node-spawn-wrap-\w+-\w+\/node:\d+:\d+\)?$/);var yg=class{constructor(l){l={ignoredPackages:[],...l},"internals"in l||(l.internals=yg.nodeInternals()),"cwd"in l||(l.cwd=process.cwd()),this._cwd=l.cwd.replace(/\\/g,"/"),this._internals=[].concat(l.internals,cB(l.ignoredPackages)),this._wrapCallSite=l.wrapCallSite||!1}static nodeInternals(){return[...z6]}clean(l,f=0){f=" ".repeat(f),Array.isArray(l)||(l=l.split(`
+`)),!/^\s*at /.test(l[0])&&/^\s*at /.test(l[1])&&(l=l.slice(1));let h=!1,E=null,t=[];return l.forEach(N=>{if(N=N.replace(/\\/g,"/"),this._internals.some(k=>k.test(N)))return;let F=/^\s*at /.test(N);h?N=N.trimEnd().replace(/^(\s+)at /,"$1"):(N=N.trim(),F&&(N=N.slice(3))),N=N.replace(`${this._cwd}/`,""),N&&(F?(E&&(t.push(E),E=null),t.push(N)):(h=!0,E=N))}),t.map(N=>`${f}${N}
+`).join("")}captureString(l,f=this.captureString){typeof l=="function"&&(f=l,l=1/0);let{stackTraceLimit:h}=Error;l&&(Error.stackTraceLimit=l);let E={};Error.captureStackTrace(E,f);let{stack:t}=E;return Error.stackTraceLimit=h,this.clean(t)}capture(l,f=this.capture){typeof l=="function"&&(f=l,l=1/0);let{prepareStackTrace:h,stackTraceLimit:E}=Error;Error.prepareStackTrace=(F,k)=>this._wrapCallSite?k.map(this._wrapCallSite):k,l&&(Error.stackTraceLimit=l);let t={};Error.captureStackTrace(t,f);let{stack:N}=t;return Object.assign(Error,{prepareStackTrace:h,stackTraceLimit:E}),N}at(l=this.at){let[f]=this.capture(1,l);if(!f)return{};let h={line:f.getLineNumber(),column:f.getColumnNumber()};j6(h,f.getFileName(),this._cwd),f.isConstructor()&&(h.constructor=!0),f.isEval()&&(h.evalOrigin=f.getEvalOrigin()),f.isNative()&&(h.native=!0);let E;try{E=f.getTypeName()}catch{}E&&E!=="Object"&&E!=="[object Object]"&&(h.type=E);let t=f.getFunctionName();t&&(h.function=t);let N=f.getMethodName();return N&&t!==N&&(h.method=N),h}parseLine(l){let f=l&&l.match(dB);if(!f)return null;let h=f[1]==="new",E=f[2],t=f[3],N=f[4],F=Number(f[5]),k=Number(f[6]),x=f[7],j=f[8],q=f[9],V=f[10]==="native",re=f[11]===")",y,me={};if(j&&(me.line=Number(j)),q&&(me.column=Number(q)),re&&x){let De=0;for(let ge=x.length-1;ge>0;ge--)if(x.charAt(ge)===")")De++;else if(x.charAt(ge)==="("&&x.charAt(ge-1)===" "&&(De--,De===-1&&x.charAt(ge-1)===" ")){let ae=x.slice(0,ge-1);x=x.slice(ge+1),E+=` (${ae}`;break}}if(E){let De=E.match(pB);De&&(E=De[1],y=De[2])}return j6(me,x,this._cwd),h&&(me.constructor=!0),t&&(me.evalOrigin=t,me.evalLine=F,me.evalColumn=k,me.evalFile=N&&N.replace(/\\/g,"/")),V&&(me.native=!0),E&&(me.function=E),y&&E!==y&&(me.method=y),me}};function j6(o,l,f){l&&(l=l.replace(/\\/g,"/"),l.startsWith(`${f}/`)&&(l=l.slice(f.length+1)),o.file=l)}function cB(o){if(o.length===0)return[];let l=o.map(f=>fB(f));return new RegExp(`[/\\\\]node_modules[/\\\\](?:${l.join("|")})[/\\\\][^:]+:\\d+:\\d+`)}var dB=new RegExp("^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"),pB=/^(.*?) \[as (.*?)\]$/;H6.exports=yg});var V6=nt((Pq,W6)=>{"use strict";W6.exports=(o,l)=>o.replace(/^\t+/gm,f=>" ".repeat(f.length*(l||2)))});var Y6=nt((Iq,G6)=>{"use strict";var hB=V6(),vB=(o,l)=>{let f=[],h=o-l,E=o+l;for(let t=h;t<=E;t++)f.push(t);return f};G6.exports=(o,l,f)=>{if(typeof o!="string")throw new TypeError("Source code is missing.");if(!l||l<1)throw new TypeError("Line number must start from `1`.");if(o=hB(o).split(/\r?\n/),!(l>o.length))return f={around:3,...f},vB(l,f.around).filter(h=>o[h-1]!==void 0).map(h=>({line:h,value:o[h-1]}))}});var c4=nt(nc=>{"use strict";var mB=nc&&nc.__createBinding||(Object.create?function(o,l,f,h){h===void 0&&(h=f),Object.defineProperty(o,h,{enumerable:!0,get:function(){return l[f]}})}:function(o,l,f,h){h===void 0&&(h=f),o[h]=l[f]}),yB=nc&&nc.__setModuleDefault||(Object.create?function(o,l){Object.defineProperty(o,"default",{enumerable:!0,value:l})}:function(o,l){o.default=l}),gB=nc&&nc.__importStar||function(o){if(o&&o.__esModule)return o;var l={};if(o!=null)for(var f in o)f!=="default"&&Object.hasOwnProperty.call(o,f)&&mB(l,o,f);return yB(l,o),l},_B=nc&&nc.__rest||function(o,l){var f={};for(var h in o)Object.prototype.hasOwnProperty.call(o,h)&&l.indexOf(h)<0&&(f[h]=o[h]);if(o!=null&&typeof Object.getOwnPropertySymbols=="function")for(var E=0,h=Object.getOwnPropertySymbols(o);E<h.length;E++)l.indexOf(h[E])<0&&Object.prototype.propertyIsEnumerable.call(o,h[E])&&(f[h[E]]=o[h[E]]);return f};Object.defineProperty(nc,"__esModule",{value:!0});var K6=gB(Mi()),b3=K6.forwardRef((o,l)=>{var{children:f}=o,h=_B(o,["children"]);let E=Object.assign(Object.assign({},h),{marginLeft:h.marginLeft||h.marginX||h.margin||0,marginRight:h.marginRight||h.marginX||h.margin||0,marginTop:h.marginTop||h.marginY||h.margin||0,marginBottom:h.marginBottom||h.marginY||h.margin||0,paddingLeft:h.paddingLeft||h.paddingX||h.padding||0,paddingRight:h.paddingRight||h.paddingX||h.padding||0,paddingTop:h.paddingTop||h.paddingY||h.padding||0,paddingBottom:h.paddingBottom||h.paddingY||h.padding||0});return K6.default.createElement("ink-box",{ref:l,style:E},f)});b3.displayName="Box";b3.defaultProps={flexDirection:"row",flexGrow:0,flexShrink:1};nc.default=b3});var j3=nt(gg=>{"use strict";var B3=gg&&gg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(gg,"__esModule",{value:!0});var EB=B3(Mi()),rm=B3(s4()),X6=B3(_3()),U3=({color:o,backgroundColor:l,dimColor:f,bold:h,italic:E,underline:t,strikethrough:N,inverse:F,wrap:k,children:x})=>{if(x==null)return null;let j=q=>(f&&(q=rm.default.dim(q)),o&&(q=X6.default(q,o,"foreground")),l&&(q=X6.default(q,l,"background")),h&&(q=rm.default.bold(q)),E&&(q=rm.default.italic(q)),t&&(q=rm.default.underline(q)),N&&(q=rm.default.strikethrough(q)),F&&(q=rm.default.inverse(q)),q);return EB.default.createElement("ink-text",{style:{flexGrow:0,flexShrink:1,flexDirection:"row",textWrap:k},internal_transform:j},x)};U3.displayName="Text";U3.defaultProps={dimColor:!1,bold:!1,italic:!1,underline:!1,strikethrough:!1,wrap:"wrap"};gg.default=U3});var $6=nt(rc=>{"use strict";var DB=rc&&rc.__createBinding||(Object.create?function(o,l,f,h){h===void 0&&(h=f),Object.defineProperty(o,h,{enumerable:!0,get:function(){return l[f]}})}:function(o,l,f,h){h===void 0&&(h=f),o[h]=l[f]}),wB=rc&&rc.__setModuleDefault||(Object.create?function(o,l){Object.defineProperty(o,"default",{enumerable:!0,value:l})}:function(o,l){o.default=l}),SB=rc&&rc.__importStar||function(o){if(o&&o.__esModule)return o;var l={};if(o!=null)for(var f in o)f!=="default"&&Object.hasOwnProperty.call(o,f)&&DB(l,o,f);return wB(l,o),l},_g=rc&&rc.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(rc,"__esModule",{value:!0});var Q6=SB(hi("fs")),Qo=_g(Mi()),J6=_g(q6()),TB=_g(Y6()),Z1=_g(c4()),Hc=_g(j3()),Z6=new J6.default({cwd:process.cwd(),internals:J6.default.nodeInternals()}),CB=({error:o})=>{let l=o.stack?o.stack.split(`
+`).slice(1):void 0,f=l?Z6.parseLine(l[0]):void 0,h,E=0;if((f==null?void 0:f.file)&&(f==null?void 0:f.line)&&Q6.existsSync(f.file)){let t=Q6.readFileSync(f.file,"utf8");if(h=TB.default(t,f.line),h)for(let{line:N}of h)E=Math.max(E,String(N).length)}return Qo.default.createElement(Z1.default,{flexDirection:"column",padding:1},Qo.default.createElement(Z1.default,null,Qo.default.createElement(Hc.default,{backgroundColor:"red",color:"white"}," ","ERROR"," "),Qo.default.createElement(Hc.default,null," ",o.message)),f&&Qo.default.createElement(Z1.default,{marginTop:1},Qo.default.createElement(Hc.default,{dimColor:!0},f.file,":",f.line,":",f.column)),f&&h&&Qo.default.createElement(Z1.default,{marginTop:1,flexDirection:"column"},h.map(({line:t,value:N})=>Qo.default.createElement(Z1.default,{key:t},Qo.default.createElement(Z1.default,{width:E+1},Qo.default.createElement(Hc.default,{dimColor:t!==f.line,backgroundColor:t===f.line?"red":void 0,color:t===f.line?"white":void 0},String(t).padStart(E," "),":")),Qo.default.createElement(Hc.default,{key:t,backgroundColor:t===f.line?"red":void 0,color:t===f.line?"white":void 0}," "+N)))),o.stack&&Qo.default.createElement(Z1.default,{marginTop:1,flexDirection:"column"},o.stack.split(`
+`).slice(1).map(t=>{let N=Z6.parseLine(t);return N?Qo.default.createElement(Z1.default,{key:t},Qo.default.createElement(Hc.default,{dimColor:!0},"- "),Qo.default.createElement(Hc.default,{dimColor:!0,bold:!0},N.function),Qo.default.createElement(Hc.default,{dimColor:!0,color:"gray"}," ","(",N.file,":",N.line,":",N.column,")")):Qo.default.createElement(Z1.default,{key:t},Qo.default.createElement(Hc.default,{dimColor:!0},"- "),Qo.default.createElement(Hc.default,{dimColor:!0,bold:!0},t))})))};rc.default=CB});var tx=nt(ic=>{"use strict";var xB=ic&&ic.__createBinding||(Object.create?function(o,l,f,h){h===void 0&&(h=f),Object.defineProperty(o,h,{enumerable:!0,get:function(){return l[f]}})}:function(o,l,f,h){h===void 0&&(h=f),o[h]=l[f]}),RB=ic&&ic.__setModuleDefault||(Object.create?function(o,l){Object.defineProperty(o,"default",{enumerable:!0,value:l})}:function(o,l){o.default=l}),AB=ic&&ic.__importStar||function(o){if(o&&o.__esModule)return o;var l={};if(o!=null)for(var f in o)f!=="default"&&Object.hasOwnProperty.call(o,f)&&xB(l,o,f);return RB(l,o),l},oh=ic&&ic.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(ic,"__esModule",{value:!0});var uh=AB(Mi()),ex=oh(rD()),OB=oh(O3()),MB=oh(k3()),kB=oh(L3()),NB=oh(P3()),LB=oh(f4()),FB=oh($6()),PB="	",IB="\x1B[Z",bB="\x1B",d4=class extends uh.PureComponent{constructor(){super(...arguments),this.state={isFocusEnabled:!0,activeFocusId:void 0,focusables:[],error:void 0},this.rawModeEnabledCount=0,this.handleSetRawMode=l=>{let{stdin:f}=this.props;if(!this.isRawModeSupported())throw f===process.stdin?new Error(`Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.
+Read about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported`):new Error(`Raw mode is not supported on the stdin provided to Ink.
+Read about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported`);if(f.setEncoding("utf8"),l){this.rawModeEnabledCount===0&&(f.addListener("data",this.handleInput),f.resume(),f.setRawMode(!0)),this.rawModeEnabledCount++;return}--this.rawModeEnabledCount===0&&(f.setRawMode(!1),f.removeListener("data",this.handleInput),f.pause())},this.handleInput=l=>{l===""&&this.props.exitOnCtrlC&&this.handleExit(),l===bB&&this.state.activeFocusId&&this.setState({activeFocusId:void 0}),this.state.isFocusEnabled&&this.state.focusables.length>0&&(l===PB&&this.focusNext(),l===IB&&this.focusPrevious())},this.handleExit=l=>{this.isRawModeSupported()&&this.handleSetRawMode(!1),this.props.onExit(l)},this.enableFocus=()=>{this.setState({isFocusEnabled:!0})},this.disableFocus=()=>{this.setState({isFocusEnabled:!1})},this.focusNext=()=>{this.setState(l=>{let f=l.focusables[0].id;return{activeFocusId:this.findNextFocusable(l)||f}})},this.focusPrevious=()=>{this.setState(l=>{let f=l.focusables[l.focusables.length-1].id;return{activeFocusId:this.findPreviousFocusable(l)||f}})},this.addFocusable=(l,{autoFocus:f})=>{this.setState(h=>{let E=h.activeFocusId;return!E&&f&&(E=l),{activeFocusId:E,focusables:[...h.focusables,{id:l,isActive:!0}]}})},this.removeFocusable=l=>{this.setState(f=>({activeFocusId:f.activeFocusId===l?void 0:f.activeFocusId,focusables:f.focusables.filter(h=>h.id!==l)}))},this.activateFocusable=l=>{this.setState(f=>({focusables:f.focusables.map(h=>h.id!==l?h:{id:l,isActive:!0})}))},this.deactivateFocusable=l=>{this.setState(f=>({activeFocusId:f.activeFocusId===l?void 0:f.activeFocusId,focusables:f.focusables.map(h=>h.id!==l?h:{id:l,isActive:!1})}))},this.findNextFocusable=l=>{let f=l.focusables.findIndex(h=>h.id===l.activeFocusId);for(let h=f+1;h<l.focusables.length;h++)if(l.focusables[h].isActive)return l.focusables[h].id},this.findPreviousFocusable=l=>{let f=l.focusables.findIndex(h=>h.id===l.activeFocusId);for(let h=f-1;h>=0;h--)if(l.focusables[h].isActive)return l.focusables[h].id}}static getDerivedStateFromError(l){return{error:l}}isRawModeSupported(){return this.props.stdin.isTTY}render(){return uh.default.createElement(OB.default.Provider,{value:{exit:this.handleExit}},uh.default.createElement(MB.default.Provider,{value:{stdin:this.props.stdin,setRawMode:this.handleSetRawMode,isRawModeSupported:this.isRawModeSupported(),internal_exitOnCtrlC:this.props.exitOnCtrlC}},uh.default.createElement(kB.default.Provider,{value:{stdout:this.props.stdout,write:this.props.writeToStdout}},uh.default.createElement(NB.default.Provider,{value:{stderr:this.props.stderr,write:this.props.writeToStderr}},uh.default.createElement(LB.default.Provider,{value:{activeId:this.state.activeFocusId,add:this.addFocusable,remove:this.removeFocusable,activate:this.activateFocusable,deactivate:this.deactivateFocusable,enableFocus:this.enableFocus,disableFocus:this.disableFocus,focusNext:this.focusNext,focusPrevious:this.focusPrevious}},this.state.error?uh.default.createElement(FB.default,{error:this.state.error}):this.props.children)))))}componentDidMount(){ex.default.hide(this.props.stdout)}componentWillUnmount(){ex.default.show(this.props.stdout),this.isRawModeSupported()&&this.handleSetRawMode(!1)}componentDidCatch(l){this.handleExit(l)}};ic.default=d4;d4.displayName="InternalApp"});var ix=nt(uc=>{"use strict";var BB=uc&&uc.__createBinding||(Object.create?function(o,l,f,h){h===void 0&&(h=f),Object.defineProperty(o,h,{enumerable:!0,get:function(){return l[f]}})}:function(o,l,f,h){h===void 0&&(h=f),o[h]=l[f]}),UB=uc&&uc.__setModuleDefault||(Object.create?function(o,l){Object.defineProperty(o,"default",{enumerable:!0,value:l})}:function(o,l){o.default=l}),jB=uc&&uc.__importStar||function(o){if(o&&o.__esModule)return o;var l={};if(o!=null)for(var f in o)f!=="default"&&Object.hasOwnProperty.call(o,f)&&BB(l,o,f);return UB(l,o),l},oc=uc&&uc.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(uc,"__esModule",{value:!0});var zB=oc(Mi()),nx=sS(),HB=oc(TS()),qB=oc(ZE()),WB=oc(MS()),VB=oc(NS()),p4=oc(UC()),GB=oc(A6()),YB=oc(nD()),KB=oc(N6()),XB=jB(BD()),QB=oc(R3()),JB=oc(tx()),im=process.env.CI==="false"?!1:WB.default,rx=()=>{},z3=class{constructor(l){this.resolveExitPromise=()=>{},this.rejectExitPromise=()=>{},this.unsubscribeExit=()=>{},this.onRender=()=>{if(this.isUnmounted)return;let{output:f,outputHeight:h,staticOutput:E}=GB.default(this.rootNode,this.options.stdout.columns||80),t=E&&E!==`
+`;if(this.options.debug){t&&(this.fullStaticOutput+=E),this.options.stdout.write(this.fullStaticOutput+f);return}if(im){t&&this.options.stdout.write(E),this.lastOutput=f;return}if(t&&(this.fullStaticOutput+=E),h>=this.options.stdout.rows){this.options.stdout.write(qB.default.clearTerminal+this.fullStaticOutput+f),this.lastOutput=f;return}t&&(this.log.clear(),this.options.stdout.write(E),this.log(f)),!t&&f!==this.lastOutput&&this.throttledLog(f),this.lastOutput=f},VB.default(this),this.options=l,this.rootNode=XB.createNode("ink-root"),this.rootNode.onRender=l.debug?this.onRender:nx.throttle(this.onRender,32,{leading:!0,trailing:!0}),this.rootNode.onImmediateRender=this.onRender,this.log=HB.default.create(l.stdout),this.throttledLog=l.debug?this.log:nx.throttle(this.log,void 0,{leading:!0,trailing:!0}),this.isUnmounted=!1,this.lastOutput="",this.fullStaticOutput="",this.container=p4.default.createContainer(this.rootNode,!1,!1),this.unsubscribeExit=YB.default(this.unmount,{alwaysLast:!1}),process.env.DEV==="true"&&p4.default.injectIntoDevTools({bundleType:0,version:"16.13.1",rendererPackageName:"ink"}),l.patchConsole&&this.patchConsole(),im||(l.stdout.on("resize",this.onRender),this.unsubscribeResize=()=>{l.stdout.off("resize",this.onRender)})}render(l){let f=zB.default.createElement(JB.default,{stdin:this.options.stdin,stdout:this.options.stdout,stderr:this.options.stderr,writeToStdout:this.writeToStdout,writeToStderr:this.writeToStderr,exitOnCtrlC:this.options.exitOnCtrlC,onExit:this.unmount},l);p4.default.updateContainer(f,this.container,null,rx)}writeToStdout(l){if(!this.isUnmounted){if(this.options.debug){this.options.stdout.write(l+this.fullStaticOutput+this.lastOutput);return}if(im){this.options.stdout.write(l);return}this.log.clear(),this.options.stdout.write(l),this.log(this.lastOutput)}}writeToStderr(l){if(!this.isUnmounted){if(this.options.debug){this.options.stderr.write(l),this.options.stdout.write(this.fullStaticOutput+this.lastOutput);return}if(im){this.options.stderr.write(l);return}this.log.clear(),this.options.stderr.write(l),this.log(this.lastOutput)}}unmount(l){this.isUnmounted||(this.onRender(),this.unsubscribeExit(),typeof this.restoreConsole=="function"&&this.restoreConsole(),typeof this.unsubscribeResize=="function"&&this.unsubscribeResize(),im?this.options.stdout.write(this.lastOutput+`
+`):this.options.debug||this.log.done(),this.isUnmounted=!0,p4.default.updateContainer(null,this.container,null,rx),QB.default.delete(this.options.stdout),l instanceof Error?this.rejectExitPromise(l):this.resolveExitPromise())}waitUntilExit(){return this.exitPromise||(this.exitPromise=new Promise((l,f)=>{this.resolveExitPromise=l,this.rejectExitPromise=f})),this.exitPromise}clear(){!im&&!this.options.debug&&this.log.clear()}patchConsole(){this.options.debug||(this.restoreConsole=KB.default((l,f)=>{l==="stdout"&&this.writeToStdout(f),l==="stderr"&&(f.startsWith("The above error occurred")||this.writeToStderr(f))}))}};uc.default=z3});var ox=nt(Eg=>{"use strict";var ux=Eg&&Eg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Eg,"__esModule",{value:!0});var ZB=ux(ix()),h4=ux(R3()),$B=hi("stream"),eU=(o,l)=>{let f=Object.assign({stdout:process.stdout,stdin:process.stdin,stderr:process.stderr,debug:!1,exitOnCtrlC:!0,patchConsole:!0},tU(l)),h=nU(f.stdout,()=>new ZB.default(f));return h.render(o),{rerender:h.render,unmount:()=>h.unmount(),waitUntilExit:h.waitUntilExit,cleanup:()=>h4.default.delete(f.stdout),clear:h.clear}};Eg.default=eU;var tU=(o={})=>o instanceof $B.Stream?{stdout:o,stdin:process.stdin}:o,nU=(o,l)=>{let f;return h4.default.has(o)?f=h4.default.get(o):(f=l(),h4.default.set(o,f)),f}});var sx=nt($1=>{"use strict";var rU=$1&&$1.__createBinding||(Object.create?function(o,l,f,h){h===void 0&&(h=f),Object.defineProperty(o,h,{enumerable:!0,get:function(){return l[f]}})}:function(o,l,f,h){h===void 0&&(h=f),o[h]=l[f]}),iU=$1&&$1.__setModuleDefault||(Object.create?function(o,l){Object.defineProperty(o,"default",{enumerable:!0,value:l})}:function(o,l){o.default=l}),uU=$1&&$1.__importStar||function(o){if(o&&o.__esModule)return o;var l={};if(o!=null)for(var f in o)f!=="default"&&Object.hasOwnProperty.call(o,f)&&rU(l,o,f);return iU(l,o),l};Object.defineProperty($1,"__esModule",{value:!0});var Dg=uU(Mi()),lx=o=>{let{items:l,children:f,style:h}=o,[E,t]=Dg.useState(0),N=Dg.useMemo(()=>l.slice(E),[l,E]);Dg.useLayoutEffect(()=>{t(l.length)},[l.length]);let F=N.map((x,j)=>f(x,E+j)),k=Dg.useMemo(()=>Object.assign({position:"absolute",flexDirection:"column"},h),[h]);return Dg.default.createElement("ink-box",{internal_static:!0,style:k},F)};lx.displayName="Static";$1.default=lx});var fx=nt(wg=>{"use strict";var oU=wg&&wg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(wg,"__esModule",{value:!0});var lU=oU(Mi()),ax=({children:o,transform:l})=>o==null?null:lU.default.createElement("ink-text",{style:{flexGrow:0,flexShrink:1,flexDirection:"row"},internal_transform:l},o);ax.displayName="Transform";wg.default=ax});var dx=nt(Sg=>{"use strict";var sU=Sg&&Sg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Sg,"__esModule",{value:!0});var aU=sU(Mi()),cx=({count:o=1})=>aU.default.createElement("ink-text",null,`
+`.repeat(o));cx.displayName="Newline";Sg.default=cx});var vx=nt(Tg=>{"use strict";var px=Tg&&Tg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Tg,"__esModule",{value:!0});var fU=px(Mi()),cU=px(c4()),hx=()=>fU.default.createElement(cU.default,{flexGrow:1});hx.displayName="Spacer";Tg.default=hx});var v4=nt(Cg=>{"use strict";var dU=Cg&&Cg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Cg,"__esModule",{value:!0});var pU=Mi(),hU=dU(k3()),vU=()=>pU.useContext(hU.default);Cg.default=vU});var yx=nt(xg=>{"use strict";var mU=xg&&xg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(xg,"__esModule",{value:!0});var mx=Mi(),yU=mU(v4()),gU=(o,l={})=>{let{stdin:f,setRawMode:h,internal_exitOnCtrlC:E}=yU.default();mx.useEffect(()=>{if(l.isActive!==!1)return h(!0),()=>{h(!1)}},[l.isActive,h]),mx.useEffect(()=>{if(l.isActive===!1)return;let t=N=>{let F=String(N),k={upArrow:F==="\x1B[A",downArrow:F==="\x1B[B",leftArrow:F==="\x1B[D",rightArrow:F==="\x1B[C",pageDown:F==="\x1B[6~",pageUp:F==="\x1B[5~",return:F==="\r",escape:F==="\x1B",ctrl:!1,shift:!1,tab:F==="	"||F==="\x1B[Z",backspace:F==="\b",delete:F==="\x7F"||F==="\x1B[3~",meta:!1};F<=""&&!k.return&&(F=String.fromCharCode(F.charCodeAt(0)+"a".charCodeAt(0)-1),k.ctrl=!0),F.startsWith("\x1B")&&(F=F.slice(1),k.meta=!0);let x=F>="A"&&F<="Z",j=F>="\u0410"&&F<="\u042F";F.length===1&&(x||j)&&(k.shift=!0),k.tab&&F==="[Z"&&(k.shift=!0),(k.tab||k.backspace||k.delete)&&(F=""),(!(F==="c"&&k.ctrl)||!E)&&o(F,k)};return f==null||f.on("data",t),()=>{f==null||f.off("data",t)}},[l.isActive,f,E,o])};xg.default=gU});var gx=nt(Rg=>{"use strict";var _U=Rg&&Rg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Rg,"__esModule",{value:!0});var EU=Mi(),DU=_U(O3()),wU=()=>EU.useContext(DU.default);Rg.default=wU});var _x=nt(Ag=>{"use strict";var SU=Ag&&Ag.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Ag,"__esModule",{value:!0});var TU=Mi(),CU=SU(L3()),xU=()=>TU.useContext(CU.default);Ag.default=xU});var Ex=nt(Og=>{"use strict";var RU=Og&&Og.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Og,"__esModule",{value:!0});var AU=Mi(),OU=RU(P3()),MU=()=>AU.useContext(OU.default);Og.default=MU});var wx=nt(kg=>{"use strict";var Dx=kg&&kg.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(kg,"__esModule",{value:!0});var Mg=Mi(),kU=Dx(f4()),NU=Dx(v4()),LU=({isActive:o=!0,autoFocus:l=!1}={})=>{let{isRawModeSupported:f,setRawMode:h}=NU.default(),{activeId:E,add:t,remove:N,activate:F,deactivate:k}=Mg.useContext(kU.default),x=Mg.useMemo(()=>Math.random().toString().slice(2,7),[]);return Mg.useEffect(()=>(t(x,{autoFocus:l}),()=>{N(x)}),[x,l]),Mg.useEffect(()=>{o?F(x):k(x)},[o,x]),Mg.useEffect(()=>{if(!(!f||!o))return h(!0),()=>{h(!1)}},[o]),{isFocused:Boolean(x)&&E===x}};kg.default=LU});var Sx=nt(Ng=>{"use strict";var FU=Ng&&Ng.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(Ng,"__esModule",{value:!0});var PU=Mi(),IU=FU(f4()),bU=()=>{let o=PU.useContext(IU.default);return{enableFocus:o.enableFocus,disableFocus:o.disableFocus,focusNext:o.focusNext,focusPrevious:o.focusPrevious}};Ng.default=bU});var Tx=nt(H3=>{"use strict";Object.defineProperty(H3,"__esModule",{value:!0});H3.default=o=>{var l,f,h,E;return{width:(f=(l=o.yogaNode)===null||l===void 0?void 0:l.getComputedWidth())!==null&&f!==void 0?f:0,height:(E=(h=o.yogaNode)===null||h===void 0?void 0:h.getComputedHeight())!==null&&E!==void 0?E:0}}});var lc=nt(Yl=>{"use strict";Object.defineProperty(Yl,"__esModule",{value:!0});var BU=ox();Object.defineProperty(Yl,"render",{enumerable:!0,get:function(){return BU.default}});var UU=c4();Object.defineProperty(Yl,"Box",{enumerable:!0,get:function(){return UU.default}});var jU=j3();Object.defineProperty(Yl,"Text",{enumerable:!0,get:function(){return jU.default}});var zU=sx();Object.defineProperty(Yl,"Static",{enumerable:!0,get:function(){return zU.default}});var HU=fx();Object.defineProperty(Yl,"Transform",{enumerable:!0,get:function(){return HU.default}});var qU=dx();Object.defineProperty(Yl,"Newline",{enumerable:!0,get:function(){return qU.default}});var WU=vx();Object.defineProperty(Yl,"Spacer",{enumerable:!0,get:function(){return WU.default}});var VU=yx();Object.defineProperty(Yl,"useInput",{enumerable:!0,get:function(){return VU.default}});var GU=gx();Object.defineProperty(Yl,"useApp",{enumerable:!0,get:function(){return GU.default}});var YU=v4();Object.defineProperty(Yl,"useStdin",{enumerable:!0,get:function(){return YU.default}});var KU=_x();Object.defineProperty(Yl,"useStdout",{enumerable:!0,get:function(){return KU.default}});var XU=Ex();Object.defineProperty(Yl,"useStderr",{enumerable:!0,get:function(){return XU.default}});var QU=wx();Object.defineProperty(Yl,"useFocus",{enumerable:!0,get:function(){return QU.default}});var JU=Sx();Object.defineProperty(Yl,"useFocusManager",{enumerable:!0,get:function(){return JU.default}});var ZU=Tx();Object.defineProperty(Yl,"measureElement",{enumerable:!0,get:function(){return ZU.default}})});var Fx=nt(Lg=>{"use strict";Object.defineProperty(Lg,"__esModule",{value:!0});Lg.UncontrolledTextInput=void 0;var Nx=Mi(),V3=Mi(),kx=lc(),ah=s4(),Lx=({value:o,placeholder:l="",focus:f=!0,mask:h,highlightPastedText:E=!1,showCursor:t=!0,onChange:N,onSubmit:F})=>{let[{cursorOffset:k,cursorWidth:x},j]=V3.useState({cursorOffset:(o||"").length,cursorWidth:0});V3.useEffect(()=>{j(me=>{if(!f||!t)return me;let De=o||"";return me.cursorOffset>De.length-1?{cursorOffset:De.length,cursorWidth:0}:me})},[o,f,t]);let q=E?x:0,V=h?h.repeat(o.length):o,re=V,y=l?ah.grey(l):void 0;if(t&&f){y=l.length>0?ah.inverse(l[0])+ah.grey(l.slice(1)):ah.inverse(" "),re=V.length>0?"":ah.inverse(" ");let me=0;for(let De of V)me>=k-q&&me<=k?re+=ah.inverse(De):re+=De,me++;V.length>0&&k===V.length&&(re+=ah.inverse(" "))}return kx.useInput((me,De)=>{if(De.upArrow||De.downArrow||De.ctrl&&me==="c"||De.tab||De.shift&&De.tab)return;if(De.return){F&&F(o);return}let ge=k,ae=o,we=0;De.leftArrow?t&&ge--:De.rightArrow?t&&ge++:De.backspace||De.delete?k>0&&(ae=o.slice(0,k-1)+o.slice(k,o.length),ge--):(ae=o.slice(0,k)+me+o.slice(k,o.length),ge+=me.length,me.length>1&&(we=me.length)),k<0&&(ge=0),k>o.length&&(ge=o.length),j({cursorOffset:ge,cursorWidth:we}),ae!==o&&N(ae)},{isActive:f}),Nx.createElement(kx.Text,null,l?V.length>0?re:y:re)};Lg.default=Lx;Lg.UncontrolledTextInput=o=>{let[l,f]=V3.useState("");return Nx.createElement(Lx,Object.assign({},o,{value:l,onChange:f}))}});var Ix=nt(S4=>{"use strict";Object.defineProperty(S4,"__esModule",{value:!0});function Fg(o){let l=[...o.caches],f=l.shift();return f===void 0?Px():{get(h,E,t={miss:()=>Promise.resolve()}){return f.get(h,E,t).catch(()=>Fg({caches:l}).get(h,E,t))},set(h,E){return f.set(h,E).catch(()=>Fg({caches:l}).set(h,E))},delete(h){return f.delete(h).catch(()=>Fg({caches:l}).delete(h))},clear(){return f.clear().catch(()=>Fg({caches:l}).clear())}}}function Px(){return{get(o,l,f={miss:()=>Promise.resolve()}){return l().then(E=>Promise.all([E,f.miss(E)])).then(([E])=>E)},set(o,l){return Promise.resolve(l)},delete(o){return Promise.resolve()},clear(){return Promise.resolve()}}}S4.createFallbackableCache=Fg;S4.createNullCache=Px});var Bx=nt((EW,bx)=>{bx.exports=Ix()});var Ux=nt(G3=>{"use strict";Object.defineProperty(G3,"__esModule",{value:!0});function $U(o={serializable:!0}){let l={};return{get(f,h,E={miss:()=>Promise.resolve()}){let t=JSON.stringify(f);if(t in l)return Promise.resolve(o.serializable?JSON.parse(l[t]):l[t]);let N=h(),F=E&&E.miss||(()=>Promise.resolve());return N.then(k=>F(k)).then(()=>N)},set(f,h){return l[JSON.stringify(f)]=o.serializable?JSON.stringify(h):h,Promise.resolve(h)},delete(f){return delete l[JSON.stringify(f)],Promise.resolve()},clear(){return l={},Promise.resolve()}}}G3.createInMemoryCache=$U});var zx=nt((wW,jx)=>{jx.exports=Ux()});var qx=nt(sc=>{"use strict";Object.defineProperty(sc,"__esModule",{value:!0});function ej(o,l,f){let h={"x-algolia-api-key":f,"x-algolia-application-id":l};return{headers(){return o===Y3.WithinHeaders?h:{}},queryParameters(){return o===Y3.WithinQueryParameters?h:{}}}}function tj(o){let l=0,f=()=>(l++,new Promise(h=>{setTimeout(()=>{h(o(f))},Math.min(100*l,1e3))}));return o(f)}function Hx(o,l=(f,h)=>Promise.resolve()){return Object.assign(o,{wait(f){return Hx(o.then(h=>Promise.all([l(h,f),h])).then(h=>h[1]))}})}function nj(o){let l=o.length-1;for(l;l>0;l--){let f=Math.floor(Math.random()*(l+1)),h=o[l];o[l]=o[f],o[f]=h}return o}function rj(o,l){return Object.keys(l!==void 0?l:{}).forEach(f=>{o[f]=l[f](o)}),o}function ij(o,...l){let f=0;return o.replace(/%s/g,()=>encodeURIComponent(l[f++]))}var uj="4.2.0",oj=o=>()=>o.transporter.requester.destroy(),Y3={WithinQueryParameters:0,WithinHeaders:1};sc.AuthMode=Y3;sc.addMethods=rj;sc.createAuth=ej;sc.createRetryablePromise=tj;sc.createWaitablePromise=Hx;sc.destroy=oj;sc.encode=ij;sc.shuffle=nj;sc.version=uj});var Pg=nt((TW,Wx)=>{Wx.exports=qx()});var Vx=nt(K3=>{"use strict";Object.defineProperty(K3,"__esModule",{value:!0});var lj={Delete:"DELETE",Get:"GET",Post:"POST",Put:"PUT"};K3.MethodEnum=lj});var Ig=nt((xW,Gx)=>{Gx.exports=Vx()});var l5=nt(G0=>{"use strict";Object.defineProperty(G0,"__esModule",{value:!0});var Kx=Ig();function X3(o,l){let f=o||{},h=f.data||{};return Object.keys(f).forEach(E=>{["timeout","headers","queryParameters","data","cacheable"].indexOf(E)===-1&&(h[E]=f[E])}),{data:Object.entries(h).length>0?h:void 0,timeout:f.timeout||l,headers:f.headers||{},queryParameters:f.queryParameters||{},cacheable:f.cacheable}}var T4={Read:1,Write:2,Any:3},um={Up:1,Down:2,Timeouted:3},Xx=2*60*1e3;function J3(o,l=um.Up){return{...o,status:l,lastUpdate:Date.now()}}function Qx(o){return o.status===um.Up||Date.now()-o.lastUpdate>Xx}function Jx(o){return o.status===um.Timeouted&&Date.now()-o.lastUpdate<=Xx}function Z3(o){return{protocol:o.protocol||"https",url:o.url,accept:o.accept||T4.Any}}function sj(o,l){return Promise.all(l.map(f=>o.get(f,()=>Promise.resolve(J3(f))))).then(f=>{let h=f.filter(F=>Qx(F)),E=f.filter(F=>Jx(F)),t=[...h,...E],N=t.length>0?t.map(F=>Z3(F)):l;return{getTimeout(F,k){return(E.length===0&&F===0?1:E.length+3+F)*k},statelessHosts:N}})}var aj=({isTimedOut:o,status:l})=>!o&&~~l===0,fj=o=>{let l=o.status;return o.isTimedOut||aj(o)||~~(l/100)!==2&&~~(l/100)!==4},cj=({status:o})=>~~(o/100)===2,dj=(o,l)=>fj(o)?l.onRetry(o):cj(o)?l.onSucess(o):l.onFail(o);function Yx(o,l,f,h){let E=[],t=n5(f,h),N=r5(o,h),F=f.method,k=f.method!==Kx.MethodEnum.Get?{}:{...f.data,...h.data},x={"x-algolia-agent":o.userAgent.value,...o.queryParameters,...k,...h.queryParameters},j=0,q=(V,re)=>{let y=V.pop();if(y===void 0)throw o5(Q3(E));let me={data:t,headers:N,method:F,url:e5(y,f.path,x),connectTimeout:re(j,o.timeouts.connect),responseTimeout:re(j,h.timeout)},De=ae=>{let we={request:me,response:ae,host:y,triesLeft:V.length};return E.push(we),we},ge={onSucess:ae=>Zx(ae),onRetry(ae){let we=De(ae);return ae.isTimedOut&&j++,Promise.all([o.logger.info("Retryable failure",$3(we)),o.hostsCache.set(y,J3(y,ae.isTimedOut?um.Timeouted:um.Down))]).then(()=>q(V,re))},onFail(ae){throw De(ae),$x(ae,Q3(E))}};return o.requester.send(me).then(ae=>dj(ae,ge))};return sj(o.hostsCache,l).then(V=>q([...V.statelessHosts].reverse(),V.getTimeout))}function pj(o){let{hostsCache:l,logger:f,requester:h,requestsCache:E,responsesCache:t,timeouts:N,userAgent:F,hosts:k,queryParameters:x,headers:j}=o,q={hostsCache:l,logger:f,requester:h,requestsCache:E,responsesCache:t,timeouts:N,userAgent:F,headers:j,queryParameters:x,hosts:k.map(V=>Z3(V)),read(V,re){let y=X3(re,q.timeouts.read),me=()=>Yx(q,q.hosts.filter(ae=>(ae.accept&T4.Read)!==0),V,y);if((y.cacheable!==void 0?y.cacheable:V.cacheable)!==!0)return me();let ge={request:V,mappedRequestOptions:y,transporter:{queryParameters:q.queryParameters,headers:q.headers}};return q.responsesCache.get(ge,()=>q.requestsCache.get(ge,()=>q.requestsCache.set(ge,me()).then(ae=>Promise.all([q.requestsCache.delete(ge),ae]),ae=>Promise.all([q.requestsCache.delete(ge),Promise.reject(ae)])).then(([ae,we])=>we)),{miss:ae=>q.responsesCache.set(ge,ae)})},write(V,re){return Yx(q,q.hosts.filter(y=>(y.accept&T4.Write)!==0),V,X3(re,q.timeouts.write))}};return q}function hj(o){let l={value:`Algolia for JavaScript (${o})`,add(f){let h=`; ${f.segment}${f.version!==void 0?` (${f.version})`:""}`;return l.value.indexOf(h)===-1&&(l.value=`${l.value}${h}`),l}};return l}function Zx(o){try{return JSON.parse(o.content)}catch(l){throw u5(l.message,o)}}function $x({content:o,status:l},f){let h=o;try{h=JSON.parse(o).message}catch{}return i5(h,l,f)}function vj(o,...l){let f=0;return o.replace(/%s/g,()=>encodeURIComponent(l[f++]))}function e5(o,l,f){let h=t5(f),E=`${o.protocol}://${o.url}/${l.charAt(0)==="/"?l.substr(1):l}`;return h.length&&(E+=`?${h}`),E}function t5(o){let l=f=>Object.prototype.toString.call(f)==="[object Object]"||Object.prototype.toString.call(f)==="[object Array]";return Object.keys(o).map(f=>vj("%s=%s",f,l(o[f])?JSON.stringify(o[f]):o[f])).join("&")}function n5(o,l){if(o.method===Kx.MethodEnum.Get||o.data===void 0&&l.data===void 0)return;let f=Array.isArray(o.data)?o.data:{...o.data,...l.data};return JSON.stringify(f)}function r5(o,l){let f={...o.headers,...l.headers},h={};return Object.keys(f).forEach(E=>{let t=f[E];h[E.toLowerCase()]=t}),h}function Q3(o){return o.map(l=>$3(l))}function $3(o){let l=o.request.headers["x-algolia-api-key"]?{"x-algolia-api-key":"*****"}:{};return{...o,request:{...o.request,headers:{...o.request.headers,...l}}}}function i5(o,l,f){return{name:"ApiError",message:o,status:l,transporterStackTrace:f}}function u5(o,l){return{name:"DeserializationError",message:o,response:l}}function o5(o){return{name:"RetryError",message:"Unreachable hosts - your application id may be incorrect. If the error persists, contact support@algolia.com.",transporterStackTrace:o}}G0.CallEnum=T4;G0.HostStatusEnum=um;G0.createApiError=i5;G0.createDeserializationError=u5;G0.createMappedRequestOptions=X3;G0.createRetryError=o5;G0.createStatefulHost=J3;G0.createStatelessHost=Z3;G0.createTransporter=pj;G0.createUserAgent=hj;G0.deserializeFailure=$x;G0.deserializeSuccess=Zx;G0.isStatefulHostTimeouted=Jx;G0.isStatefulHostUp=Qx;G0.serializeData=n5;G0.serializeHeaders=r5;G0.serializeQueryParameters=t5;G0.serializeUrl=e5;G0.stackFrameWithoutCredentials=$3;G0.stackTraceWithoutCredentials=Q3});var bg=nt((AW,s5)=>{s5.exports=l5()});var a5=nt(y2=>{"use strict";Object.defineProperty(y2,"__esModule",{value:!0});var om=Pg(),mj=bg(),Bg=Ig(),yj=o=>{let l=o.region||"us",f=om.createAuth(om.AuthMode.WithinHeaders,o.appId,o.apiKey),h=mj.createTransporter({hosts:[{url:`analytics.${l}.algolia.com`}],...o,headers:{...f.headers(),"content-type":"application/json",...o.headers},queryParameters:{...f.queryParameters(),...o.queryParameters}}),E=o.appId;return om.addMethods({appId:E,transporter:h},o.methods)},gj=o=>(l,f)=>o.transporter.write({method:Bg.MethodEnum.Post,path:"2/abtests",data:l},f),_j=o=>(l,f)=>o.transporter.write({method:Bg.MethodEnum.Delete,path:om.encode("2/abtests/%s",l)},f),Ej=o=>(l,f)=>o.transporter.read({method:Bg.MethodEnum.Get,path:om.encode("2/abtests/%s",l)},f),Dj=o=>l=>o.transporter.read({method:Bg.MethodEnum.Get,path:"2/abtests"},l),wj=o=>(l,f)=>o.transporter.write({method:Bg.MethodEnum.Post,path:om.encode("2/abtests/%s/stop",l)},f);y2.addABTest=gj;y2.createAnalyticsClient=yj;y2.deleteABTest=_j;y2.getABTest=Ej;y2.getABTests=Dj;y2.stopABTest=wj});var c5=nt((MW,f5)=>{f5.exports=a5()});var p5=nt(Ug=>{"use strict";Object.defineProperty(Ug,"__esModule",{value:!0});var ew=Pg(),Sj=bg(),d5=Ig(),Tj=o=>{let l=o.region||"us",f=ew.createAuth(ew.AuthMode.WithinHeaders,o.appId,o.apiKey),h=Sj.createTransporter({hosts:[{url:`recommendation.${l}.algolia.com`}],...o,headers:{...f.headers(),"content-type":"application/json",...o.headers},queryParameters:{...f.queryParameters(),...o.queryParameters}});return ew.addMethods({appId:o.appId,transporter:h},o.methods)},Cj=o=>l=>o.transporter.read({method:d5.MethodEnum.Get,path:"1/strategies/personalization"},l),xj=o=>(l,f)=>o.transporter.write({method:d5.MethodEnum.Post,path:"1/strategies/personalization",data:l},f);Ug.createRecommendationClient=Tj;Ug.getPersonalizationStrategy=Cj;Ug.setPersonalizationStrategy=xj});var v5=nt((NW,h5)=>{h5.exports=p5()});var A5=nt(tn=>{"use strict";Object.defineProperty(tn,"__esModule",{value:!0});var Nn=Pg(),ra=bg(),Ur=Ig(),Rj=hi("crypto");function C4(o){let l=f=>o.request(f).then(h=>{if(o.batch!==void 0&&o.batch(h.hits),!o.shouldStop(h))return h.cursor?l({cursor:h.cursor}):l({page:(f.page||0)+1})});return l({})}var Aj=o=>{let l=o.appId,f=Nn.createAuth(o.authMode!==void 0?o.authMode:Nn.AuthMode.WithinHeaders,l,o.apiKey),h=ra.createTransporter({hosts:[{url:`${l}-dsn.algolia.net`,accept:ra.CallEnum.Read},{url:`${l}.algolia.net`,accept:ra.CallEnum.Write}].concat(Nn.shuffle([{url:`${l}-1.algolianet.com`},{url:`${l}-2.algolianet.com`},{url:`${l}-3.algolianet.com`}])),...o,headers:{...f.headers(),"content-type":"application/x-www-form-urlencoded",...o.headers},queryParameters:{...f.queryParameters(),...o.queryParameters}}),E={transporter:h,appId:l,addAlgoliaAgent(t,N){h.userAgent.add({segment:t,version:N})},clearCache(){return Promise.all([h.requestsCache.clear(),h.responsesCache.clear()]).then(()=>{})}};return Nn.addMethods(E,o.methods)};function m5(){return{name:"MissingObjectIDError",message:"All objects must have an unique objectID (like a primary key) to be valid. Algolia is also able to generate objectIDs automatically but *it's not recommended*. To do it, use the `{'autoGenerateObjectIDIfNotExist': true}` option."}}function y5(){return{name:"ObjectNotFoundError",message:"Object not found."}}function g5(){return{name:"ValidUntilNotFoundError",message:"ValidUntil not found in given secured api key."}}var Oj=o=>(l,f)=>{let{queryParameters:h,...E}=f||{},t={acl:l,...h!==void 0?{queryParameters:h}:{}},N=(F,k)=>Nn.createRetryablePromise(x=>jg(o)(F.key,k).catch(j=>{if(j.status!==404)throw j;return x()}));return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:"1/keys",data:t},E),N)},Mj=o=>(l,f,h)=>{let E=ra.createMappedRequestOptions(h);return E.queryParameters["X-Algolia-User-ID"]=l,o.transporter.write({method:Ur.MethodEnum.Post,path:"1/clusters/mapping",data:{cluster:f}},E)},kj=o=>(l,f,h)=>o.transporter.write({method:Ur.MethodEnum.Post,path:"1/clusters/mapping/batch",data:{users:l,cluster:f}},h),x4=o=>(l,f,h)=>{let E=(t,N)=>zg(o)(l,{methods:{waitTask:xo}}).waitTask(t.taskID,N);return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/operation",l),data:{operation:"copy",destination:f}},h),E)},Nj=o=>(l,f,h)=>x4(o)(l,f,{...h,scope:[A4.Rules]}),Lj=o=>(l,f,h)=>x4(o)(l,f,{...h,scope:[A4.Settings]}),Fj=o=>(l,f,h)=>x4(o)(l,f,{...h,scope:[A4.Synonyms]}),Pj=o=>(l,f)=>{let h=(E,t)=>Nn.createRetryablePromise(N=>jg(o)(l,t).then(N).catch(F=>{if(F.status!==404)throw F}));return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Delete,path:Nn.encode("1/keys/%s",l)},f),h)},Ij=()=>(o,l)=>{let f=ra.serializeQueryParameters(l),h=Rj.createHmac("sha256",o).update(f).digest("hex");return Buffer.from(h+f).toString("base64")},jg=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/keys/%s",l)},f),bj=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:"1/logs"},l),Bj=()=>o=>{let l=Buffer.from(o,"base64").toString("ascii"),f=/validUntil=(\d+)/,h=l.match(f);if(h===null)throw g5();return parseInt(h[1],10)-Math.round(new Date().getTime()/1e3)},Uj=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:"1/clusters/mapping/top"},l),jj=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/clusters/mapping/%s",l)},f),zj=o=>l=>{let{retrieveMappings:f,...h}=l||{};return f===!0&&(h.getClusters=!0),o.transporter.read({method:Ur.MethodEnum.Get,path:"1/clusters/mapping/pending"},h)},zg=o=>(l,f={})=>{let h={transporter:o.transporter,appId:o.appId,indexName:l};return Nn.addMethods(h,f.methods)},Hj=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:"1/keys"},l),qj=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:"1/clusters"},l),Wj=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:"1/indexes"},l),Vj=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:"1/clusters/mapping"},l),Gj=o=>(l,f,h)=>{let E=(t,N)=>zg(o)(l,{methods:{waitTask:xo}}).waitTask(t.taskID,N);return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/operation",l),data:{operation:"move",destination:f}},h),E)},Yj=o=>(l,f)=>{let h=(E,t)=>Promise.all(Object.keys(E.taskID).map(N=>zg(o)(N,{methods:{waitTask:xo}}).waitTask(E.taskID[N],t)));return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:"1/indexes/*/batch",data:{requests:l}},f),h)},Kj=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Post,path:"1/indexes/*/objects",data:{requests:l}},f),Xj=o=>(l,f)=>{let h=l.map(E=>({...E,params:ra.serializeQueryParameters(E.params||{})}));return o.transporter.read({method:Ur.MethodEnum.Post,path:"1/indexes/*/queries",data:{requests:h},cacheable:!0},f)},Qj=o=>(l,f)=>Promise.all(l.map(h=>{let{facetName:E,facetQuery:t,...N}=h.params;return zg(o)(h.indexName,{methods:{searchForFacetValues:C5}}).searchForFacetValues(E,t,{...f,...N})})),Jj=o=>(l,f)=>{let h=ra.createMappedRequestOptions(f);return h.queryParameters["X-Algolia-User-ID"]=l,o.transporter.write({method:Ur.MethodEnum.Delete,path:"1/clusters/mapping"},h)},Zj=o=>(l,f)=>{let h=(E,t)=>Nn.createRetryablePromise(N=>jg(o)(l,t).catch(F=>{if(F.status!==404)throw F;return N()}));return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/keys/%s/restore",l)},f),h)},$j=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Post,path:"1/clusters/mapping/search",data:{query:l}},f),ez=o=>(l,f)=>{let h=Object.assign({},f),{queryParameters:E,...t}=f||{},N=E?{queryParameters:E}:{},F=["acl","indexes","referers","restrictSources","queryParameters","description","maxQueriesPerIPPerHour","maxHitsPerQuery"],k=j=>Object.keys(h).filter(q=>F.indexOf(q)!==-1).every(q=>j[q]===h[q]),x=(j,q)=>Nn.createRetryablePromise(V=>jg(o)(l,q).then(re=>k(re)?Promise.resolve():V()));return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Put,path:Nn.encode("1/keys/%s",l),data:N},t),x)},_5=o=>(l,f)=>{let h=(E,t)=>xo(o)(E.taskID,t);return Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/batch",o.indexName),data:{requests:l}},f),h)},tz=o=>l=>C4({...l,shouldStop:f=>f.cursor===void 0,request:f=>o.transporter.read({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/browse",o.indexName),data:f},l)}),nz=o=>l=>{let f={hitsPerPage:1e3,...l};return C4({...f,shouldStop:h=>h.hits.length<f.hitsPerPage,request(h){return x5(o)("",{...f,...h}).then(E=>({...E,hits:E.hits.map(t=>(delete t._highlightResult,t))}))}})},rz=o=>l=>{let f={hitsPerPage:1e3,...l};return C4({...f,shouldStop:h=>h.hits.length<f.hitsPerPage,request(h){return R5(o)("",{...f,...h}).then(E=>({...E,hits:E.hits.map(t=>(delete t._highlightResult,t))}))}})},R4=o=>(l,f,h)=>{let{batchSize:E,...t}=h||{},N={taskIDs:[],objectIDs:[]},F=(k=0)=>{let x=[],j;for(j=k;j<l.length&&(x.push(l[j]),x.length!==(E||1e3));j++);return x.length===0?Promise.resolve(N):_5(o)(x.map(q=>({action:f,body:q})),t).then(q=>(N.objectIDs=N.objectIDs.concat(q.objectIDs),N.taskIDs.push(q.taskID),j++,F(j)))};return Nn.createWaitablePromise(F(),(k,x)=>Promise.all(k.taskIDs.map(j=>xo(o)(j,x))))},iz=o=>l=>Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/clear",o.indexName)},l),(f,h)=>xo(o)(f.taskID,h)),uz=o=>l=>{let{forwardToReplicas:f,...h}=l||{},E=ra.createMappedRequestOptions(h);return f&&(E.queryParameters.forwardToReplicas=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/rules/clear",o.indexName)},E),(t,N)=>xo(o)(t.taskID,N))},oz=o=>l=>{let{forwardToReplicas:f,...h}=l||{},E=ra.createMappedRequestOptions(h);return f&&(E.queryParameters.forwardToReplicas=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/synonyms/clear",o.indexName)},E),(t,N)=>xo(o)(t.taskID,N))},lz=o=>(l,f)=>Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/deleteByQuery",o.indexName),data:l},f),(h,E)=>xo(o)(h.taskID,E)),sz=o=>l=>Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Delete,path:Nn.encode("1/indexes/%s",o.indexName)},l),(f,h)=>xo(o)(f.taskID,h)),az=o=>(l,f)=>Nn.createWaitablePromise(E5(o)([l],f).then(h=>({taskID:h.taskIDs[0]})),(h,E)=>xo(o)(h.taskID,E)),E5=o=>(l,f)=>{let h=l.map(E=>({objectID:E}));return R4(o)(h,fh.DeleteObject,f)},fz=o=>(l,f)=>{let{forwardToReplicas:h,...E}=f||{},t=ra.createMappedRequestOptions(E);return h&&(t.queryParameters.forwardToReplicas=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Delete,path:Nn.encode("1/indexes/%s/rules/%s",o.indexName,l)},t),(N,F)=>xo(o)(N.taskID,F))},cz=o=>(l,f)=>{let{forwardToReplicas:h,...E}=f||{},t=ra.createMappedRequestOptions(E);return h&&(t.queryParameters.forwardToReplicas=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Delete,path:Nn.encode("1/indexes/%s/synonyms/%s",o.indexName,l)},t),(N,F)=>xo(o)(N.taskID,F))},dz=o=>l=>D5(o)(l).then(()=>!0).catch(f=>{if(f.status!==404)throw f;return!1}),pz=o=>(l,f)=>{let{query:h,paginate:E,...t}=f||{},N=0,F=()=>T5(o)(h||"",{...t,page:N}).then(k=>{for(let[x,j]of Object.entries(k.hits))if(l(j))return{object:j,position:parseInt(x,10),page:N};if(N++,E===!1||N>=k.nbPages)throw y5();return F()});return F()},hz=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/indexes/%s/%s",o.indexName,l)},f),vz=()=>(o,l)=>{for(let[f,h]of Object.entries(o.hits))if(h.objectID===l)return parseInt(f,10);return-1},mz=o=>(l,f)=>{let{attributesToRetrieve:h,...E}=f||{},t=l.map(N=>({indexName:o.indexName,objectID:N,...h?{attributesToRetrieve:h}:{}}));return o.transporter.read({method:Ur.MethodEnum.Post,path:"1/indexes/*/objects",data:{requests:t}},E)},yz=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/indexes/%s/rules/%s",o.indexName,l)},f),D5=o=>l=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/indexes/%s/settings",o.indexName),data:{getVersion:2}},l),gz=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/indexes/%s/synonyms/%s",o.indexName,l)},f),w5=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Get,path:Nn.encode("1/indexes/%s/task/%s",o.indexName,l.toString())},f),_z=o=>(l,f)=>Nn.createWaitablePromise(S5(o)([l],f).then(h=>({objectID:h.objectIDs[0],taskID:h.taskIDs[0]})),(h,E)=>xo(o)(h.taskID,E)),S5=o=>(l,f)=>{let{createIfNotExists:h,...E}=f||{},t=h?fh.PartialUpdateObject:fh.PartialUpdateObjectNoCreate;return R4(o)(l,t,E)},Ez=o=>(l,f)=>{let{safe:h,autoGenerateObjectIDIfNotExist:E,batchSize:t,...N}=f||{},F=(y,me,De,ge)=>Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/operation",y),data:{operation:De,destination:me}},ge),(ae,we)=>xo(o)(ae.taskID,we)),k=Math.random().toString(36).substring(7),x=`${o.indexName}_tmp_${k}`,j=tw({appId:o.appId,transporter:o.transporter,indexName:x}),q=[],V=F(o.indexName,x,"copy",{...N,scope:["settings","synonyms","rules"]});q.push(V);let re=(h?V.wait(N):V).then(()=>{let y=j(l,{...N,autoGenerateObjectIDIfNotExist:E,batchSize:t});return q.push(y),h?y.wait(N):y}).then(()=>{let y=F(x,o.indexName,"move",N);return q.push(y),h?y.wait(N):y}).then(()=>Promise.all(q)).then(([y,me,De])=>({objectIDs:me.objectIDs,taskIDs:[y.taskID,...me.taskIDs,De.taskID]}));return Nn.createWaitablePromise(re,(y,me)=>Promise.all(q.map(De=>De.wait(me))))},Dz=o=>(l,f)=>nw(o)(l,{...f,clearExistingRules:!0}),wz=o=>(l,f)=>rw(o)(l,{...f,replaceExistingSynonyms:!0}),Sz=o=>(l,f)=>Nn.createWaitablePromise(tw(o)([l],f).then(h=>({objectID:h.objectIDs[0],taskID:h.taskIDs[0]})),(h,E)=>xo(o)(h.taskID,E)),tw=o=>(l,f)=>{let{autoGenerateObjectIDIfNotExist:h,...E}=f||{},t=h?fh.AddObject:fh.UpdateObject;if(t===fh.UpdateObject){for(let N of l)if(N.objectID===void 0)return Nn.createWaitablePromise(Promise.reject(m5()))}return R4(o)(l,t,E)},Tz=o=>(l,f)=>nw(o)([l],f),nw=o=>(l,f)=>{let{forwardToReplicas:h,clearExistingRules:E,...t}=f||{},N=ra.createMappedRequestOptions(t);return h&&(N.queryParameters.forwardToReplicas=1),E&&(N.queryParameters.clearExistingRules=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/rules/batch",o.indexName),data:l},N),(F,k)=>xo(o)(F.taskID,k))},Cz=o=>(l,f)=>rw(o)([l],f),rw=o=>(l,f)=>{let{forwardToReplicas:h,replaceExistingSynonyms:E,...t}=f||{},N=ra.createMappedRequestOptions(t);return h&&(N.queryParameters.forwardToReplicas=1),E&&(N.queryParameters.replaceExistingSynonyms=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/synonyms/batch",o.indexName),data:l},N),(F,k)=>xo(o)(F.taskID,k))},T5=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/query",o.indexName),data:{query:l},cacheable:!0},f),C5=o=>(l,f,h)=>o.transporter.read({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/facets/%s/query",o.indexName,l),data:{facetQuery:f},cacheable:!0},h),x5=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/rules/search",o.indexName),data:{query:l}},f),R5=o=>(l,f)=>o.transporter.read({method:Ur.MethodEnum.Post,path:Nn.encode("1/indexes/%s/synonyms/search",o.indexName),data:{query:l}},f),xz=o=>(l,f)=>{let{forwardToReplicas:h,...E}=f||{},t=ra.createMappedRequestOptions(E);return h&&(t.queryParameters.forwardToReplicas=1),Nn.createWaitablePromise(o.transporter.write({method:Ur.MethodEnum.Put,path:Nn.encode("1/indexes/%s/settings",o.indexName),data:l},t),(N,F)=>xo(o)(N.taskID,F))},xo=o=>(l,f)=>Nn.createRetryablePromise(h=>w5(o)(l,f).then(E=>E.status!=="published"?h():void 0)),Rz={AddObject:"addObject",Analytics:"analytics",Browser:"browse",DeleteIndex:"deleteIndex",DeleteObject:"deleteObject",EditSettings:"editSettings",ListIndexes:"listIndexes",Logs:"logs",Recommendation:"recommendation",Search:"search",SeeUnretrievableAttributes:"seeUnretrievableAttributes",Settings:"settings",Usage:"usage"},fh={AddObject:"addObject",UpdateObject:"updateObject",PartialUpdateObject:"partialUpdateObject",PartialUpdateObjectNoCreate:"partialUpdateObjectNoCreate",DeleteObject:"deleteObject"},A4={Settings:"settings",Synonyms:"synonyms",Rules:"rules"},Az={None:"none",StopIfEnoughMatches:"stopIfEnoughMatches"},Oz={Synonym:"synonym",OneWaySynonym:"oneWaySynonym",AltCorrection1:"altCorrection1",AltCorrection2:"altCorrection2",Placeholder:"placeholder"};tn.ApiKeyACLEnum=Rz;tn.BatchActionEnum=fh;tn.ScopeEnum=A4;tn.StrategyEnum=Az;tn.SynonymEnum=Oz;tn.addApiKey=Oj;tn.assignUserID=Mj;tn.assignUserIDs=kj;tn.batch=_5;tn.browseObjects=tz;tn.browseRules=nz;tn.browseSynonyms=rz;tn.chunkedBatch=R4;tn.clearObjects=iz;tn.clearRules=uz;tn.clearSynonyms=oz;tn.copyIndex=x4;tn.copyRules=Nj;tn.copySettings=Lj;tn.copySynonyms=Fj;tn.createBrowsablePromise=C4;tn.createMissingObjectIDError=m5;tn.createObjectNotFoundError=y5;tn.createSearchClient=Aj;tn.createValidUntilNotFoundError=g5;tn.deleteApiKey=Pj;tn.deleteBy=lz;tn.deleteIndex=sz;tn.deleteObject=az;tn.deleteObjects=E5;tn.deleteRule=fz;tn.deleteSynonym=cz;tn.exists=dz;tn.findObject=pz;tn.generateSecuredApiKey=Ij;tn.getApiKey=jg;tn.getLogs=bj;tn.getObject=hz;tn.getObjectPosition=vz;tn.getObjects=mz;tn.getRule=yz;tn.getSecuredApiKeyRemainingValidity=Bj;tn.getSettings=D5;tn.getSynonym=gz;tn.getTask=w5;tn.getTopUserIDs=Uj;tn.getUserID=jj;tn.hasPendingMappings=zj;tn.initIndex=zg;tn.listApiKeys=Hj;tn.listClusters=qj;tn.listIndices=Wj;tn.listUserIDs=Vj;tn.moveIndex=Gj;tn.multipleBatch=Yj;tn.multipleGetObjects=Kj;tn.multipleQueries=Xj;tn.multipleSearchForFacetValues=Qj;tn.partialUpdateObject=_z;tn.partialUpdateObjects=S5;tn.removeUserID=Jj;tn.replaceAllObjects=Ez;tn.replaceAllRules=Dz;tn.replaceAllSynonyms=wz;tn.restoreApiKey=Zj;tn.saveObject=Sz;tn.saveObjects=tw;tn.saveRule=Tz;tn.saveRules=nw;tn.saveSynonym=Cz;tn.saveSynonyms=rw;tn.search=T5;tn.searchForFacetValues=C5;tn.searchRules=x5;tn.searchSynonyms=R5;tn.searchUserIDs=$j;tn.setSettings=xz;tn.updateApiKey=ez;tn.waitTask=xo});var M5=nt((FW,O5)=>{O5.exports=A5()});var k5=nt(O4=>{"use strict";Object.defineProperty(O4,"__esModule",{value:!0});function Mz(){return{debug(o,l){return Promise.resolve()},info(o,l){return Promise.resolve()},error(o,l){return Promise.resolve()}}}var kz={Debug:1,Info:2,Error:3};O4.LogLevelEnum=kz;O4.createNullLogger=Mz});var L5=nt((IW,N5)=>{N5.exports=k5()});var I5=nt(iw=>{"use strict";Object.defineProperty(iw,"__esModule",{value:!0});var F5=hi("http"),P5=hi("https"),Nz=hi("url");function Lz(){let o={keepAlive:!0},l=new F5.Agent(o),f=new P5.Agent(o);return{send(h){return new Promise(E=>{let t=Nz.parse(h.url),N=t.query===null?t.pathname:`${t.pathname}?${t.query}`,F={agent:t.protocol==="https:"?f:l,hostname:t.hostname,path:N,method:h.method,headers:h.headers,...t.port!==void 0?{port:t.port||""}:{}},k=(t.protocol==="https:"?P5:F5).request(F,V=>{let re="";V.on("data",y=>re+=y),V.on("end",()=>{clearTimeout(j),clearTimeout(q),E({status:V.statusCode||0,content:re,isTimedOut:!1})})}),x=(V,re)=>setTimeout(()=>{k.abort(),E({status:0,content:re,isTimedOut:!0})},V*1e3),j=x(h.connectTimeout,"Connection timeout"),q;k.on("error",V=>{clearTimeout(j),clearTimeout(q),E({status:0,content:V.message,isTimedOut:!1})}),k.once("response",()=>{clearTimeout(j),q=x(h.responseTimeout,"Socket timeout")}),h.data!==void 0&&k.write(h.data),k.end()})},destroy(){return l.destroy(),f.destroy(),Promise.resolve()}}}iw.createNodeHttpRequester=Lz});var B5=nt((BW,b5)=>{b5.exports=I5()});var H5=nt((UW,z5)=>{"use strict";var U5=Bx(),Fz=zx(),lm=c5(),ow=Pg(),uw=v5(),wn=M5(),Pz=L5(),Iz=B5(),bz=bg();function j5(o,l,f){let h={appId:o,apiKey:l,timeouts:{connect:2,read:5,write:30},requester:Iz.createNodeHttpRequester(),logger:Pz.createNullLogger(),responsesCache:U5.createNullCache(),requestsCache:U5.createNullCache(),hostsCache:Fz.createInMemoryCache(),userAgent:bz.createUserAgent(ow.version).add({segment:"Node.js",version:process.versions.node})};return wn.createSearchClient({...h,...f,methods:{search:wn.multipleQueries,searchForFacetValues:wn.multipleSearchForFacetValues,multipleBatch:wn.multipleBatch,multipleGetObjects:wn.multipleGetObjects,multipleQueries:wn.multipleQueries,copyIndex:wn.copyIndex,copySettings:wn.copySettings,copyRules:wn.copyRules,copySynonyms:wn.copySynonyms,moveIndex:wn.moveIndex,listIndices:wn.listIndices,getLogs:wn.getLogs,listClusters:wn.listClusters,multipleSearchForFacetValues:wn.multipleSearchForFacetValues,getApiKey:wn.getApiKey,addApiKey:wn.addApiKey,listApiKeys:wn.listApiKeys,updateApiKey:wn.updateApiKey,deleteApiKey:wn.deleteApiKey,restoreApiKey:wn.restoreApiKey,assignUserID:wn.assignUserID,assignUserIDs:wn.assignUserIDs,getUserID:wn.getUserID,searchUserIDs:wn.searchUserIDs,listUserIDs:wn.listUserIDs,getTopUserIDs:wn.getTopUserIDs,removeUserID:wn.removeUserID,hasPendingMappings:wn.hasPendingMappings,generateSecuredApiKey:wn.generateSecuredApiKey,getSecuredApiKeyRemainingValidity:wn.getSecuredApiKeyRemainingValidity,destroy:ow.destroy,initIndex:E=>t=>wn.initIndex(E)(t,{methods:{batch:wn.batch,delete:wn.deleteIndex,getObject:wn.getObject,getObjects:wn.getObjects,saveObject:wn.saveObject,saveObjects:wn.saveObjects,search:wn.search,searchForFacetValues:wn.searchForFacetValues,waitTask:wn.waitTask,setSettings:wn.setSettings,getSettings:wn.getSettings,partialUpdateObject:wn.partialUpdateObject,partialUpdateObjects:wn.partialUpdateObjects,deleteObject:wn.deleteObject,deleteObjects:wn.deleteObjects,deleteBy:wn.deleteBy,clearObjects:wn.clearObjects,browseObjects:wn.browseObjects,getObjectPosition:wn.getObjectPosition,findObject:wn.findObject,exists:wn.exists,saveSynonym:wn.saveSynonym,saveSynonyms:wn.saveSynonyms,getSynonym:wn.getSynonym,searchSynonyms:wn.searchSynonyms,browseSynonyms:wn.browseSynonyms,deleteSynonym:wn.deleteSynonym,clearSynonyms:wn.clearSynonyms,replaceAllObjects:wn.replaceAllObjects,replaceAllSynonyms:wn.replaceAllSynonyms,searchRules:wn.searchRules,getRule:wn.getRule,deleteRule:wn.deleteRule,saveRule:wn.saveRule,saveRules:wn.saveRules,replaceAllRules:wn.replaceAllRules,browseRules:wn.browseRules,clearRules:wn.clearRules}}),initAnalytics:()=>E=>lm.createAnalyticsClient({...h,...E,methods:{addABTest:lm.addABTest,getABTest:lm.getABTest,getABTests:lm.getABTests,stopABTest:lm.stopABTest,deleteABTest:lm.deleteABTest}}),initRecommendation:()=>E=>uw.createRecommendationClient({...h,...E,methods:{getPersonalizationStrategy:uw.getPersonalizationStrategy,setPersonalizationStrategy:uw.setPersonalizationStrategy}})}})}j5.version=ow.version;z5.exports=j5});var W5=nt((jW,lw)=>{var q5=H5();lw.exports=q5;lw.exports.default=q5});var Yz={};HF(Yz,{default:()=>Gz});var G5=hi("@yarnpkg/cli"),ch=hi("@yarnpkg/core");var Cx=V0(lc()),lh=V0(Mi()),m4=(0,lh.memo)(({active:o})=>{let l=(0,lh.useMemo)(()=>o?"\u25C9":"\u25EF",[o]),f=(0,lh.useMemo)(()=>o?"green":"yellow",[o]);return lh.default.createElement(Cx.Text,{color:f},l)});var m2=V0(lc()),na=V0(Mi());var xx=V0(lc()),y4=V0(Mi());function v2({active:o},l,f){let{stdin:h}=(0,xx.useStdin)(),E=(0,y4.useCallback)((t,N)=>l(t,N),f);(0,y4.useEffect)(()=>{if(!(!o||!h))return h.on("keypress",E),()=>{h.off("keypress",E)}},[o,E,h])}var Rx=function({active:o},l,f){v2({active:o},(h,E)=>{E.name==="tab"&&(E.shift?l("before"):l("after"))},f)};var g4=function(o,l,{active:f,minus:h,plus:E,set:t,loop:N=!0}){v2({active:f},(F,k)=>{let x=l.indexOf(o);switch(k.name){case h:{let j=x-1;if(N){t(l[(l.length+j)%l.length]);return}if(j<0)return;t(l[j])}break;case E:{let j=x+1;if(N){t(l[j%l.length]);return}if(j>=l.length)return;t(l[j])}break}},[l,o,E,t,N])};var _4=({active:o=!0,children:l=[],radius:f=10,size:h=1,loop:E=!0,onFocusRequest:t,willReachEnd:N})=>{let F=De=>{if(De.key===null)throw new Error("Expected all children to have a key");return De.key},k=na.default.Children.map(l,De=>F(De)),x=k[0],[j,q]=(0,na.useState)(x),V=k.indexOf(j);(0,na.useEffect)(()=>{k.includes(j)||q(x)},[l]),(0,na.useEffect)(()=>{N&&V>=k.length-2&&N()},[V]),Rx({active:o&&!!t},De=>{t==null||t(De)},[t]),g4(j,k,{active:o,minus:"up",plus:"down",set:q,loop:E});let re=V-f,y=V+f;y>k.length&&(re-=y-k.length,y=k.length),re<0&&(y+=-re,re=0),y>=k.length&&(y=k.length-1);let me=[];for(let De=re;De<=y;++De){let ge=k[De],ae=o&&ge===j;me.push(na.default.createElement(m2.Box,{key:ge,height:h},na.default.createElement(m2.Box,{marginLeft:1,marginRight:1},na.default.createElement(m2.Text,null,ae?na.default.createElement(m2.Text,{color:"cyan",bold:!0},">"):" ")),na.default.createElement(m2.Box,null,na.default.cloneElement(l[De],{active:ae}))))}return na.default.createElement(m2.Box,{flexDirection:"column",width:"100%"},me)};var E4=V0(Mi());var Ax=V0(lc()),ed=V0(Mi()),Ox=hi("readline"),q3=ed.default.createContext(null),Mx=({children:o})=>{let{stdin:l,setRawMode:f}=(0,Ax.useStdin)();(0,ed.useEffect)(()=>{f&&f(!0),l&&(0,Ox.emitKeypressEvents)(l)},[l,f]);let[h,E]=(0,ed.useState)(new Map),t=(0,ed.useMemo)(()=>({getAll:()=>h,get:N=>h.get(N),set:(N,F)=>E(new Map([...h,[N,F]]))}),[h,E]);return ed.default.createElement(q3.Provider,{value:t,children:o})};function sh(o,l){let f=(0,E4.useContext)(q3);if(f===null)throw new Error("Expected this hook to run with a ministore context attached");if(typeof o>"u")return f.getAll();let h=(0,E4.useCallback)(t=>{f.set(o,t)},[o,f.set]),E=f.get(o);return typeof E>"u"&&(E=l),[E,h]}var D4=V0(lc()),W3=V0(Mi());async function w4(o,l,{stdin:f,stdout:h,stderr:E}={}){let t,N=k=>{let{exit:x}=(0,D4.useApp)();v2({active:!0},(j,q)=>{q.name==="return"&&(t=k,x())},[x,k])},{waitUntilExit:F}=(0,D4.render)(W3.default.createElement(Mx,null,W3.default.createElement(o,{...l,useSubmit:N})),{stdin:f,stdout:h,stderr:E});return await F(),t}var Y5=hi("clipanion"),K5=V0(Fx()),or=V0(lc()),En=V0(Mi());var V5=V0(W5()),sw={appId:"OFCNCOG2CU",apiKey:"6fe4476ee5a1832882e326b506d14126",indexName:"npm-search"},Bz=(0,V5.default)(sw.appId,sw.apiKey).initIndex(sw.indexName),aw=async(o,l=0)=>await Bz.search(o,{analyticsTags:["yarn-plugin-interactive-tools"],attributesToRetrieve:["name","version","owner","repository","humanDownloadsLast30Days"],page:l,hitsPerPage:10});var Hg=["regular","dev","peer"],dh=class extends G5.BaseCommand{async execute(){let l=await ch.Configuration.find(this.context.cwd,this.context.plugins),f=()=>En.default.createElement(or.Box,{flexDirection:"row"},En.default.createElement(or.Box,{flexDirection:"column",width:48},En.default.createElement(or.Box,null,En.default.createElement(or.Text,null,"Press ",En.default.createElement(or.Text,{bold:!0,color:"cyanBright"},"<up>"),"/",En.default.createElement(or.Text,{bold:!0,color:"cyanBright"},"<down>")," to move between packages.")),En.default.createElement(or.Box,null,En.default.createElement(or.Text,null,"Press ",En.default.createElement(or.Text,{bold:!0,color:"cyanBright"},"<space>")," to select a package.")),En.default.createElement(or.Box,null,En.default.createElement(or.Text,null,"Press ",En.default.createElement(or.Text,{bold:!0,color:"cyanBright"},"<space>")," again to change the target."))),En.default.createElement(or.Box,{flexDirection:"column"},En.default.createElement(or.Box,{marginLeft:1},En.default.createElement(or.Text,null,"Press ",En.default.createElement(or.Text,{bold:!0,color:"cyanBright"},"<enter>")," to install the selected packages.")),En.default.createElement(or.Box,{marginLeft:1},En.default.createElement(or.Text,null,"Press ",En.default.createElement(or.Text,{bold:!0,color:"cyanBright"},"<ctrl+c>")," to abort.")))),h=()=>En.default.createElement(En.default.Fragment,null,En.default.createElement(or.Box,{width:15},En.default.createElement(or.Text,{bold:!0,underline:!0,color:"gray"},"Owner")),En.default.createElement(or.Box,{width:11},En.default.createElement(or.Text,{bold:!0,underline:!0,color:"gray"},"Version")),En.default.createElement(or.Box,{width:10},En.default.createElement(or.Text,{bold:!0,underline:!0,color:"gray"},"Downloads"))),E=()=>En.default.createElement(or.Box,{width:17},En.default.createElement(or.Text,{bold:!0,underline:!0,color:"gray"},"Target")),t=({hit:re,active:y})=>{let[me,De]=sh(re.name,null);v2({active:y},(we,he)=>{if(he.name!=="space")return;if(!me){De(Hg[0]);return}let ve=Hg.indexOf(me)+1;ve===Hg.length?De(null):De(Hg[ve])},[me,De]);let ge=ch.structUtils.parseIdent(re.name),ae=ch.structUtils.prettyIdent(l,ge);return En.default.createElement(or.Box,null,En.default.createElement(or.Box,{width:45},En.default.createElement(or.Text,{bold:!0,wrap:"wrap"},ae)),En.default.createElement(or.Box,{width:14,marginLeft:1},En.default.createElement(or.Text,{bold:!0,wrap:"truncate"},re.owner.name)),En.default.createElement(or.Box,{width:10,marginLeft:1},En.default.createElement(or.Text,{italic:!0,wrap:"truncate"},re.version)),En.default.createElement(or.Box,{width:16,marginLeft:1},En.default.createElement(or.Text,null,re.humanDownloadsLast30Days)))},N=({name:re,active:y})=>{let[me]=sh(re,null),De=ch.structUtils.parseIdent(re);return En.default.createElement(or.Box,null,En.default.createElement(or.Box,{width:47},En.default.createElement(or.Text,{bold:!0}," - ",ch.structUtils.prettyIdent(l,De))),Hg.map(ge=>En.default.createElement(or.Box,{key:ge,width:14,marginLeft:1},En.default.createElement(or.Text,null," ",En.default.createElement(m4,{active:me===ge})," ",En.default.createElement(or.Text,{bold:!0},ge)))))},F=()=>En.default.createElement(or.Box,{marginTop:1},En.default.createElement(or.Text,null,"Powered by Algolia.")),x=await w4(({useSubmit:re})=>{let y=sh();re(y);let me=Array.from(y.keys()).filter(We=>y.get(We)!==null),[De,ge]=(0,En.useState)(""),[ae,we]=(0,En.useState)(0),[he,ve]=(0,En.useState)([]),ue=We=>{We.match(/\t| /)||ge(We)},Ae=async()=>{we(0);let We=await aw(De);We.query===De&&ve(We.hits)},ze=async()=>{let We=await aw(De,ae+1);We.query===De&&We.page-1===ae&&(we(We.page),ve([...he,...We.hits]))};return(0,En.useEffect)(()=>{De?Ae():ve([])},[De]),En.default.createElement(or.Box,{flexDirection:"column"},En.default.createElement(f,null),En.default.createElement(or.Box,{flexDirection:"row",marginTop:1},En.default.createElement(or.Text,{bold:!0},"Search: "),En.default.createElement(or.Box,{width:41},En.default.createElement(K5.default,{value:De,onChange:ue,placeholder:"i.e. babel, webpack, react...",showCursor:!1})),En.default.createElement(h,null)),he.length?En.default.createElement(_4,{radius:2,loop:!1,children:he.map(We=>En.default.createElement(t,{key:We.name,hit:We,active:!1})),willReachEnd:ze}):En.default.createElement(or.Text,{color:"gray"},"Start typing..."),En.default.createElement(or.Box,{flexDirection:"row",marginTop:1},En.default.createElement(or.Box,{width:49},En.default.createElement(or.Text,{bold:!0},"Selected:")),En.default.createElement(E,null)),me.length?me.map(We=>En.default.createElement(N,{key:We,name:We,active:!1})):En.default.createElement(or.Text,{color:"gray"},"No selected packages..."),En.default.createElement(F,null))},{},{stdin:this.context.stdin,stdout:this.context.stdout,stderr:this.context.stderr});if(typeof x>"u")return 1;let j=Array.from(x.keys()).filter(re=>x.get(re)==="regular"),q=Array.from(x.keys()).filter(re=>x.get(re)==="dev"),V=Array.from(x.keys()).filter(re=>x.get(re)==="peer");return j.length&&await this.cli.run(["add",...j]),q.length&&await this.cli.run(["add","--dev",...q]),V&&await this.cli.run(["add","--peer",...V]),0}};dh.paths=[["search"]],dh.usage=Y5.Command.Usage({category:"Interactive commands",description:"open the search interface",details:`
+    This command opens a fullscreen terminal interface where you can search for and install packages from the npm registry.
+    `,examples:[["Open the search window","yarn search"]]});var N4=hi("@yarnpkg/cli"),Ro=hi("@yarnpkg/core");var qg=V0(lc()),g2=V0(Mi());var X5=V0(lc()),Q5=V0(Mi()),M4=({length:o,active:l})=>{if(o===0)return null;let f=o>1?` ${"-".repeat(o-1)}`:" ";return Q5.default.createElement(X5.Text,{dimColor:!l},f)};var J5=function({active:o,skewer:l,options:f,value:h,onChange:E,sizes:t=[]}){let N=f.filter(({label:k})=>!!k).map(({value:k})=>k),F=f.findIndex(k=>k.value===h&&k.label!="");return g4(h,N,{active:o,minus:"left",plus:"right",set:E}),g2.default.createElement(g2.default.Fragment,null,f.map(({label:k},x)=>{let j=x===F,q=t[x]-1||0,V=k.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,""),re=Math.max(0,q-V.length-2);return k?g2.default.createElement(qg.Box,{key:k,width:q,marginLeft:1},g2.default.createElement(qg.Text,{wrap:"truncate"},g2.default.createElement(m4,{active:j})," ",k),l?g2.default.createElement(M4,{active:o,length:re}):null):g2.default.createElement(qg.Box,{key:`spacer-${x}`,width:q,marginLeft:1})}))};var r9=hi("@yarnpkg/plugin-essentials"),L4=hi("clipanion");function td(){}td.prototype={diff:function(l,f){var h=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},E=h.callback;typeof h=="function"&&(E=h,h={}),this.options=h;var t=this;function N(me){return E?(setTimeout(function(){E(void 0,me)},0),!0):me}l=this.castInput(l),f=this.castInput(f),l=this.removeEmpty(this.tokenize(l)),f=this.removeEmpty(this.tokenize(f));var F=f.length,k=l.length,x=1,j=F+k;h.maxEditLength&&(j=Math.min(j,h.maxEditLength));var q=[{newPos:-1,components:[]}],V=this.extractCommon(q[0],f,l,0);if(q[0].newPos+1>=F&&V+1>=k)return N([{value:this.join(f),count:f.length}]);function re(){for(var me=-1*x;me<=x;me+=2){var De=void 0,ge=q[me-1],ae=q[me+1],we=(ae?ae.newPos:0)-me;ge&&(q[me-1]=void 0);var he=ge&&ge.newPos+1<F,ve=ae&&0<=we&&we<k;if(!he&&!ve){q[me]=void 0;continue}if(!he||ve&&ge.newPos<ae.newPos?(De=jz(ae),t.pushComponent(De.components,void 0,!0)):(De=ge,De.newPos++,t.pushComponent(De.components,!0,void 0)),we=t.extractCommon(De,f,l,me),De.newPos+1>=F&&we+1>=k)return N(Uz(t,De.components,f,l,t.useLongestToken));q[me]=De}x++}if(E)(function me(){setTimeout(function(){if(x>j)return E();re()||me()},0)})();else for(;x<=j;){var y=re();if(y)return y}},pushComponent:function(l,f,h){var E=l[l.length-1];E&&E.added===f&&E.removed===h?l[l.length-1]={count:E.count+1,added:f,removed:h}:l.push({count:1,added:f,removed:h})},extractCommon:function(l,f,h,E){for(var t=f.length,N=h.length,F=l.newPos,k=F-E,x=0;F+1<t&&k+1<N&&this.equals(f[F+1],h[k+1]);)F++,k++,x++;return x&&l.components.push({count:x}),l.newPos=F,k},equals:function(l,f){return this.options.comparator?this.options.comparator(l,f):l===f||this.options.ignoreCase&&l.toLowerCase()===f.toLowerCase()},removeEmpty:function(l){for(var f=[],h=0;h<l.length;h++)l[h]&&f.push(l[h]);return f},castInput:function(l){return l},tokenize:function(l){return l.split("")},join:function(l){return l.join("")}};function Uz(o,l,f,h,E){for(var t=0,N=l.length,F=0,k=0;t<N;t++){var x=l[t];if(x.removed){if(x.value=o.join(h.slice(k,k+x.count)),k+=x.count,t&&l[t-1].added){var q=l[t-1];l[t-1]=l[t],l[t]=q}}else{if(!x.added&&E){var j=f.slice(F,F+x.count);j=j.map(function(re,y){var me=h[k+y];return me.length>re.length?me:re}),x.value=o.join(j)}else x.value=o.join(f.slice(F,F+x.count));F+=x.count,x.added||(k+=x.count)}}var V=l[N-1];return N>1&&typeof V.value=="string"&&(V.added||V.removed)&&o.equals("",V.value)&&(l[N-2].value+=V.value,l.pop()),l}function jz(o){return{newPos:o.newPos,components:o.components.slice(0)}}var rV=new td;function zz(o,l){if(typeof o=="function")l.callback=o;else if(o)for(var f in o)o.hasOwnProperty(f)&&(l[f]=o[f]);return l}var Z5=/^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/,$5=/\S/,dw=new td;dw.equals=function(o,l){return this.options.ignoreCase&&(o=o.toLowerCase(),l=l.toLowerCase()),o===l||this.options.ignoreWhitespace&&!$5.test(o)&&!$5.test(l)};dw.tokenize=function(o){for(var l=o.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/),f=0;f<l.length-1;f++)!l[f+1]&&l[f+2]&&Z5.test(l[f])&&Z5.test(l[f+2])&&(l[f]+=l[f+2],l.splice(f+1,2),f--);return l};function e9(o,l,f){return f=zz(f,{ignoreWhitespace:!0}),dw.diff(o,l,f)}var t9=new td;t9.tokenize=function(o){var l=[],f=o.split(/(\n|\r\n)/);f[f.length-1]||f.pop();for(var h=0;h<f.length;h++){var E=f[h];h%2&&!this.options.newlineIsToken?l[l.length-1]+=E:(this.options.ignoreWhitespace&&(E=E.trim()),l.push(E))}return l};var Hz=new td;Hz.tokenize=function(o){return o.split(/(\S.+?[.!?])(?=\s+|$)/)};var qz=new td;qz.tokenize=function(o){return o.split(/([{}:;,]|\s+)/)};function k4(o){return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?k4=function(l){return typeof l}:k4=function(l){return l&&typeof Symbol=="function"&&l.constructor===Symbol&&l!==Symbol.prototype?"symbol":typeof l},k4(o)}var Wz=Object.prototype.toString,Wg=new td;Wg.useLongestToken=!0;Wg.tokenize=t9.tokenize;Wg.castInput=function(o){var l=this.options,f=l.undefinedReplacement,h=l.stringifyReplacer,E=h===void 0?function(t,N){return typeof N>"u"?f:N}:h;return typeof o=="string"?o:JSON.stringify(fw(o,null,null,E),E,"  ")};Wg.equals=function(o,l){return td.prototype.equals.call(Wg,o.replace(/,([\r\n])/g,"$1"),l.replace(/,([\r\n])/g,"$1"))};function fw(o,l,f,h,E){l=l||[],f=f||[],h&&(o=h(E,o));var t;for(t=0;t<l.length;t+=1)if(l[t]===o)return f[t];var N;if(Wz.call(o)==="[object Array]"){for(l.push(o),N=new Array(o.length),f.push(N),t=0;t<o.length;t+=1)N[t]=fw(o[t],l,f,h,E);return l.pop(),f.pop(),N}if(o&&o.toJSON&&(o=o.toJSON()),k4(o)==="object"&&o!==null){l.push(o),N={},f.push(N);var F=[],k;for(k in o)o.hasOwnProperty(k)&&F.push(k);for(F.sort(),t=0;t<F.length;t+=1)k=F[t],N[k]=fw(o[k],l,f,h,k);l.pop(),f.pop()}else N=o;return N}var cw=new td;cw.tokenize=function(o){return o.slice()};cw.join=cw.removeEmpty=function(o){return o};var bi=V0(lc()),Tr=V0(Mi()),i9=V0(hi("semver")),n9=/^((?:[\^~]|>=?)?)([0-9]+)(\.[0-9]+)(\.[0-9]+)((?:-\S+)?)$/,u9=(o,l)=>o.length>0?[o.slice(0,l)].concat(u9(o.slice(l),l)):[],ph=class extends N4.BaseCommand{async execute(){if(!this.context.stdout.isTTY)throw new L4.UsageError("This command can only be run in a TTY environment");let l=await Ro.Configuration.find(this.context.cwd,this.context.plugins),{project:f,workspace:h}=await Ro.Project.find(l,this.context.cwd),E=await Ro.Cache.find(l);if(!h)throw new N4.WorkspaceRequiredError(f.cwd,this.context.cwd);await f.restoreInstallState({restoreResolutions:!1});let t=this.context.stdout.rows-7,N=(ae,we)=>{let he=e9(ae,we),ve="";for(let ue of he)ue.added?ve+=Ro.formatUtils.pretty(l,ue.value,"green"):ue.removed||(ve+=ue.value);return ve},F=(ae,we)=>{if(ae===we)return we;let he=Ro.structUtils.parseRange(ae),ve=Ro.structUtils.parseRange(we),ue=he.selector.match(n9),Ae=ve.selector.match(n9);if(!ue||!Ae)return N(ae,we);let ze=["gray","red","yellow","green","magenta"],We=null,gt="";for(let _t=1;_t<ze.length;++_t)We!==null||ue[_t]!==Ae[_t]?(We===null&&(We=ze[_t-1]),gt+=Ro.formatUtils.pretty(l,Ae[_t],We)):gt+=Ae[_t];return gt},k=async(ae,we,he)=>{let ve=await r9.suggestUtils.fetchDescriptorFrom(ae,he,{project:f,cache:E,preserveModifier:we,workspace:h});return ve!==null?ve.range:ae.range},x=async ae=>{let we=i9.default.valid(ae.range)?`^${ae.range}`:ae.range,[he,ve]=await Promise.all([k(ae,ae.range,we).catch(()=>null),k(ae,ae.range,"latest").catch(()=>null)]),ue=[{value:null,label:ae.range}];return he&&he!==ae.range?ue.push({value:he,label:F(ae.range,he)}):ue.push({value:null,label:""}),ve&&ve!==he&&ve!==ae.range?ue.push({value:ve,label:F(ae.range,ve)}):ue.push({value:null,label:""}),ue},j=()=>Tr.default.createElement(bi.Box,{flexDirection:"row"},Tr.default.createElement(bi.Box,{flexDirection:"column",width:49},Tr.default.createElement(bi.Box,{marginLeft:1},Tr.default.createElement(bi.Text,null,"Press ",Tr.default.createElement(bi.Text,{bold:!0,color:"cyanBright"},"<up>"),"/",Tr.default.createElement(bi.Text,{bold:!0,color:"cyanBright"},"<down>")," to select packages.")),Tr.default.createElement(bi.Box,{marginLeft:1},Tr.default.createElement(bi.Text,null,"Press ",Tr.default.createElement(bi.Text,{bold:!0,color:"cyanBright"},"<left>"),"/",Tr.default.createElement(bi.Text,{bold:!0,color:"cyanBright"},"<right>")," to select versions."))),Tr.default.createElement(bi.Box,{flexDirection:"column"},Tr.default.createElement(bi.Box,{marginLeft:1},Tr.default.createElement(bi.Text,null,"Press ",Tr.default.createElement(bi.Text,{bold:!0,color:"cyanBright"},"<enter>")," to install.")),Tr.default.createElement(bi.Box,{marginLeft:1},Tr.default.createElement(bi.Text,null,"Press ",Tr.default.createElement(bi.Text,{bold:!0,color:"cyanBright"},"<ctrl+c>")," to abort.")))),q=()=>Tr.default.createElement(bi.Box,{flexDirection:"row",paddingTop:1,paddingBottom:1},Tr.default.createElement(bi.Box,{width:50},Tr.default.createElement(bi.Text,{bold:!0},Tr.default.createElement(bi.Text,{color:"greenBright"},"?")," Pick the packages you want to upgrade.")),Tr.default.createElement(bi.Box,{width:17},Tr.default.createElement(bi.Text,{bold:!0,underline:!0,color:"gray"},"Current")),Tr.default.createElement(bi.Box,{width:17},Tr.default.createElement(bi.Text,{bold:!0,underline:!0,color:"gray"},"Range")),Tr.default.createElement(bi.Box,{width:17},Tr.default.createElement(bi.Text,{bold:!0,underline:!0,color:"gray"},"Latest"))),V=({active:ae,descriptor:we,suggestions:he})=>{let[ve,ue]=sh(we.descriptorHash,null),Ae=Ro.structUtils.stringifyIdent(we),ze=Math.max(0,45-Ae.length);return Tr.default.createElement(Tr.default.Fragment,null,Tr.default.createElement(bi.Box,null,Tr.default.createElement(bi.Box,{width:45},Tr.default.createElement(bi.Text,{bold:!0},Ro.structUtils.prettyIdent(l,we)),Tr.default.createElement(M4,{active:ae,length:ze})),Tr.default.createElement(J5,{active:ae,options:he,value:ve,skewer:!0,onChange:ue,sizes:[17,17,17]})))},re=({dependencies:ae})=>{let[we,he]=(0,Tr.useState)(ae.map(()=>null)),ve=(0,Tr.useRef)(!0),ue=async Ae=>{let ze=await x(Ae);return ze.filter(We=>We.label!=="").length<=1?null:{descriptor:Ae,suggestions:ze}};return(0,Tr.useEffect)(()=>()=>{ve.current=!1},[]),(0,Tr.useEffect)(()=>{let Ae=Math.trunc(t*1.75),ze=ae.slice(0,Ae),We=ae.slice(Ae),gt=u9(We,t),_t=ze.map(ue).reduce(async(Qe,ot)=>{await Qe;let Ve=await ot;Ve!==null&&(!ve.current||he(Pt=>{let Jt=Pt.findIndex(J=>J===null),it=[...Pt];return it[Jt]=Ve,it}))},Promise.resolve());gt.reduce((Qe,ot)=>Promise.all(ot.map(Ve=>Promise.resolve().then(()=>ue(Ve)))).then(async Ve=>{Ve=Ve.filter(Pt=>Pt!==null),await Qe,ve.current&&he(Pt=>{let Jt=Pt.findIndex(it=>it===null);return Pt.slice(0,Jt).concat(Ve).concat(Pt.slice(Jt+Ve.length))})}),_t).then(()=>{ve.current&&he(Qe=>Qe.filter(ot=>ot!==null))})},[]),we.length?Tr.default.createElement(_4,{radius:t>>1,children:we.map((Ae,ze)=>Ae!==null?Tr.default.createElement(V,{key:ze,active:!1,descriptor:Ae.descriptor,suggestions:Ae.suggestions}):Tr.default.createElement(bi.Text,{key:ze},"Loading..."))}):Tr.default.createElement(bi.Text,null,"No upgrades found")},me=await w4(({useSubmit:ae})=>{ae(sh());let we=new Map;for(let ve of f.workspaces)for(let ue of["dependencies","devDependencies"])for(let Ae of ve.manifest[ue].values())f.tryWorkspaceByDescriptor(Ae)===null&&(Ae.range.startsWith("link:")||we.set(Ae.descriptorHash,Ae));let he=Ro.miscUtils.sortMap(we.values(),ve=>Ro.structUtils.stringifyDescriptor(ve));return Tr.default.createElement(bi.Box,{flexDirection:"column"},Tr.default.createElement(j,null),Tr.default.createElement(q,null),Tr.default.createElement(re,{dependencies:he}))},{},{stdin:this.context.stdin,stdout:this.context.stdout,stderr:this.context.stderr});if(typeof me>"u")return 1;let De=!1;for(let ae of f.workspaces)for(let we of["dependencies","devDependencies"]){let he=ae.manifest[we];for(let ve of he.values()){let ue=me.get(ve.descriptorHash);typeof ue<"u"&&ue!==null&&(he.set(ve.identHash,Ro.structUtils.makeDescriptor(ve,ue)),De=!0)}}return De?(await Ro.StreamReport.start({configuration:l,stdout:this.context.stdout,includeLogs:!this.context.quiet},async ae=>{await f.install({cache:E,report:ae})})).exitCode():0}};ph.paths=[["upgrade-interactive"]],ph.usage=L4.Command.Usage({category:"Interactive commands",description:"open the upgrade interface",details:`
+      This command opens a fullscreen terminal interface where you can see any out of date packages used by your application, their status compared to the latest versions available on the remote registry, and select packages to upgrade.
+    `,examples:[["Open the upgrade window","yarn upgrade-interactive"]]});var Vz={commands:[dh,ph]},Gz=Vz;return qF(Yz);})();
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+/** @license React v0.0.0-experimental-51a3aa6af
+ * react-debug-tools.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.0.0-experimental-51a3aa6af
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.0.0-experimental-51a3aa6af
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.18.0
+ * scheduler-tracing.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.18.0
+ * scheduler-tracing.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.18.0
+ * scheduler.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.18.0
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.24.0
+ * react-reconciler.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v0.24.0
+ * react-reconciler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v16.13.1
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @license React v16.13.1
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+return plugin;
+}
+};
diff --git a/.yarnrc.yml b/.yarnrc.yml
index 6d27afaac27..c513a5dbaaa 100644
--- a/.yarnrc.yml
+++ b/.yarnrc.yml
@@ -1,3 +1,7 @@
+logFilters:
+  - code: YN0013
+    level: discard
+
 nodeLinker: node-modules
 
 plugins:
@@ -5,8 +9,7 @@ plugins:
     spec: "@yarnpkg/plugin-typescript"
   - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
     spec: "@yarnpkg/plugin-workspace-tools"
+  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
+    spec: "@yarnpkg/plugin-interactive-tools"
 
 yarnPath: .yarn/releases/yarn-3.6.3.cjs
-logFilters:
-  - code: YN0013
-    level: discard
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 0a9cd7235f5..2f444ba565a 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -41,14 +41,14 @@
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
     "@web/dev-server-esbuild": "^0.3.6",
-    "@web/test-runner": "^0.15.3",
+    "@web/test-runner": "^0.18.1",
     "@web/test-runner-playwright": "^0.10.0",
-    "chai": "^4.3.7",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "mocha": "^10.2.0",
-    "prettier": "3.0.3",
+    "prettier": "3.2.5",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.4.2"
   }
 }
diff --git a/compiler/integration-tests/package.json b/compiler/integration-tests/package.json
index 798b7c55312..431fe408a8b 100644
--- a/compiler/integration-tests/package.json
+++ b/compiler/integration-tests/package.json
@@ -20,13 +20,13 @@
         "@nomicfoundation/hardhat-ethers": "^3.0.0",
         "@web/dev-server-esbuild": "^0.3.6",
         "@web/dev-server-import-maps": "^0.2.0",
-        "@web/test-runner": "^0.15.3",
+        "@web/test-runner": "^0.18.1",
         "@web/test-runner-playwright": "^0.10.0",
-        "eslint": "^8.56.0",
-        "eslint-plugin-prettier": "^5.0.0",
+        "eslint": "^8.57.0",
+        "eslint-plugin-prettier": "^5.1.3",
         "ethers": "^6.7.1",
         "hardhat": "^2.17.4",
-        "prettier": "3.0.3",
+        "prettier": "3.2.5",
         "smol-toml": "^1.1.2",
         "toml": "^3.0.0",
         "tslog": "^4.9.2"
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index 6dfa3215483..8db3876a753 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -55,27 +55,27 @@
     "@types/sinon": "^17",
     "@wasm-tool/wasm-pack-plugin": "^1.7.0",
     "@web/dev-server-esbuild": "^0.3.6",
-    "@web/test-runner": "^0.18.0",
+    "@web/test-runner": "^0.18.1",
     "@web/test-runner-playwright": "^0.11.0",
     "adm-zip": "^0.5.0",
     "assert": "^2.1.0",
     "browserify-fs": "^1.0.0",
-    "chai": "^4.3.10",
+    "chai": "^4.4.1",
     "copy-webpack-plugin": "^12.0.2",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "html-webpack-plugin": "^5.6.0",
     "memfs": "^4.6.0",
     "mocha": "^10.2.0",
     "mocha-each": "^2.0.1",
     "path-browserify": "^1.0.1",
-    "prettier": "3.0.3",
+    "prettier": "3.2.5",
     "process": "^0.11.10",
     "readable-stream": "^4.4.2",
     "sinon": "^17.0.1",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.1",
-    "typescript": "~5.2.2",
+    "typescript": "^5.4.2",
     "unzipit": "^1.4.3",
     "url": "^0.11.3",
     "webpack": "^5.90.1",
diff --git a/docs/package.json b/docs/package.json
index 779b72149b1..661a0a0dcab 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -34,15 +34,15 @@
     "@docusaurus/types": "^3.0.1",
     "@types/prettier": "^3",
     "docusaurus-plugin-typedoc": "1.0.0-next.18",
-    "eslint-plugin-prettier": "^5.0.0",
-    "prettier": "3.0.3",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "3.2.5",
     "serve": "^14.2.1",
     "ts-node": "^10.9.1",
     "typedoc": "^0.25.0",
     "typedoc-plugin-frontmatter": "^0.0.2",
     "typedoc-plugin-markdown": "4.0.0-next.25",
     "typedoc-plugin-merge-modules": "^5.1.0",
-    "typescript": "~5.2.2"
+    "typescript": "^5.4.2"
   },
   "browserslist": {
     "production": [
diff --git a/package.json b/package.json
index fcf36c9b969..049c1634dd2 100644
--- a/package.json
+++ b/package.json
@@ -36,14 +36,14 @@
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^6.7.3",
     "@typescript-eslint/parser": "^6.7.3",
-    "chai": "^4.3.7",
+    "chai": "^4.4.1",
     "cspell": "^8.3.2",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "mocha": "^10.2.0",
-    "prettier": "3.0.3",
+    "prettier": "3.2.5",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.4.2"
   },
   "packageManager": "yarn@3.6.4"
 }
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 68ee7184928..485f4252e29 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -51,13 +51,13 @@
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.6.2",
     "@types/prettier": "^3",
-    "chai": "^4.3.8",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "mocha": "^10.2.0",
-    "prettier": "3.0.3",
+    "prettier": "3.2.5",
     "ts-node": "^10.9.1",
     "tsx": "^4.6.2",
-    "typescript": "^5.2.2"
+    "typescript": "^5.4.2"
   }
 }
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index 0a40d300ea4..0da6e695202 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -53,14 +53,14 @@
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.6.2",
     "@types/prettier": "^3",
-    "chai": "^4.3.8",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "mocha": "^10.2.0",
-    "prettier": "3.0.3",
+    "prettier": "3.2.5",
     "ts-node": "^10.9.1",
     "tsc-multi": "^1.1.0",
     "tsx": "^4.6.2",
-    "typescript": "^5.2.2"
+    "typescript": "^5.4.2"
   }
 }
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 09673d7fd4e..6223f8d2969 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -49,12 +49,12 @@
   "devDependencies": {
     "@types/node": "^20.6.2",
     "@types/prettier": "^3",
-    "chai": "^4.3.8",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
     "mocha": "^10.2.0",
-    "prettier": "3.0.3",
+    "prettier": "3.2.5",
     "ts-node": "^10.9.1",
-    "typescript": "5.1.5"
+    "typescript": "5.4.2"
   }
 }
diff --git a/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json b/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json
index 15d273af62e..ac1e3784480 100644
--- a/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json
+++ b/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json
@@ -2,6 +2,7 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "module": "CommonJS",
+    "moduleResolution": "Node",
     "outDir": "./lib/cjs"
   },
 }
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index d853813303d..d7a08debb54 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -40,9 +40,9 @@
   },
   "devDependencies": {
     "@types/prettier": "^3",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.0.0",
-    "prettier": "3.0.3",
-    "typescript": "^5.2.2"
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "3.2.5",
+    "typescript": "^5.4.2"
   }
 }
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 8fb9eb314a5..a6cc5503242 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -43,9 +43,9 @@
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
     "@web/dev-server-esbuild": "^0.3.6",
-    "@web/test-runner": "^0.15.3",
+    "@web/test-runner": "^0.18.1",
     "@web/test-runner-playwright": "^0.10.0",
-    "eslint": "^8.56.0",
+    "eslint": "^8.57.0",
     "mocha": "^10.2.0"
   }
 }
diff --git a/yarn.lock b/yarn.lock
index dc3253de21a..ee120fbb18e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3485,10 +3485,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint/js@npm:8.56.0":
-  version: 8.56.0
-  resolution: "@eslint/js@npm:8.56.0"
-  checksum: 5804130574ef810207bdf321c265437814e7a26f4e6fac9b496de3206afd52f533e09ec002a3be06cd9adcc9da63e727f1883938e663c4e4751c007d5b58e539
+"@eslint/js@npm:8.57.0":
+  version: 8.57.0
+  resolution: "@eslint/js@npm:8.57.0"
+  checksum: 315dc65b0e9893e2bff139bddace7ea601ad77ed47b4550e73da8c9c2d2766c7a575c3cddf17ef85b8fd6a36ff34f91729d0dcca56e73ca887c10df91a41b0bb
   languageName: node
   linkType: hard
 
@@ -3926,14 +3926,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@humanwhocodes/config-array@npm:^0.11.13":
-  version: 0.11.13
-  resolution: "@humanwhocodes/config-array@npm:0.11.13"
+"@humanwhocodes/config-array@npm:^0.11.14":
+  version: 0.11.14
+  resolution: "@humanwhocodes/config-array@npm:0.11.14"
   dependencies:
-    "@humanwhocodes/object-schema": ^2.0.1
-    debug: ^4.1.1
+    "@humanwhocodes/object-schema": ^2.0.2
+    debug: ^4.3.1
     minimatch: ^3.0.5
-  checksum: f8ea57b0d7ed7f2d64cd3944654976829d9da91c04d9c860e18804729a33f7681f78166ef4c761850b8c324d362f7d53f14c5c44907a6b38b32c703ff85e4805
+  checksum: 861ccce9eaea5de19546653bccf75bf09fe878bc39c3aab00aeee2d2a0e654516adad38dd1098aab5e3af0145bbcbf3f309bdf4d964f8dab9dcd5834ae4c02f2
   languageName: node
   linkType: hard
 
@@ -3944,10 +3944,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@humanwhocodes/object-schema@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "@humanwhocodes/object-schema@npm:2.0.1"
-  checksum: 24929487b1ed48795d2f08346a0116cc5ee4634848bce64161fb947109352c562310fd159fc64dda0e8b853307f5794605191a9547f7341158559ca3c8262a45
+"@humanwhocodes/object-schema@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@humanwhocodes/object-schema@npm:2.0.2"
+  checksum: 2fc11503361b5fb4f14714c700c02a3f4c7c93e9acd6b87a29f62c522d90470f364d6161b03d1cc618b979f2ae02aed1106fd29d302695d8927e2fc8165ba8ee
   languageName: node
   linkType: hard
 
@@ -4380,15 +4380,15 @@ __metadata:
   dependencies:
     "@esm-bundle/chai": ^4.3.4-fix.0
     "@web/dev-server-esbuild": ^0.3.6
-    "@web/test-runner": ^0.15.3
+    "@web/test-runner": ^0.18.1
     "@web/test-runner-playwright": ^0.10.0
-    chai: ^4.3.7
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    chai: ^4.4.1
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     mocha: ^10.2.0
-    prettier: 3.0.3
+    prettier: 3.2.5
     ts-node: ^10.9.1
-    typescript: ^5.0.4
+    typescript: ^5.4.2
   languageName: unknown
   linkType: soft
 
@@ -4400,14 +4400,14 @@ __metadata:
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3
-    chai: ^4.3.8
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    chai: ^4.4.1
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     fflate: ^0.8.0
     mocha: ^10.2.0
-    prettier: 3.0.3
+    prettier: 3.2.5
     ts-node: ^10.9.1
-    typescript: 5.1.5
+    typescript: 5.4.2
   languageName: unknown
   linkType: soft
 
@@ -4421,16 +4421,16 @@ __metadata:
     "@types/mocha": ^10.0.1
     "@types/node": ^20.6.2
     "@types/prettier": ^3
-    chai: ^4.3.8
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    chai: ^4.4.1
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     glob: ^10.3.10
     mocha: ^10.2.0
-    prettier: 3.0.3
+    prettier: 3.2.5
     ts-command-line-args: ^2.5.1
     ts-node: ^10.9.1
     tsx: ^4.6.2
-    typescript: ^5.2.2
+    typescript: ^5.4.2
   bin:
     noir-codegen: lib/main.js
   languageName: unknown
@@ -4447,15 +4447,15 @@ __metadata:
     "@types/mocha": ^10.0.1
     "@types/node": ^20.6.2
     "@types/prettier": ^3
-    chai: ^4.3.8
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    chai: ^4.4.1
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     mocha: ^10.2.0
-    prettier: 3.0.3
+    prettier: 3.2.5
     ts-node: ^10.9.1
     tsc-multi: ^1.1.0
     tsx: ^4.6.2
-    typescript: ^5.2.2
+    typescript: ^5.4.2
   languageName: unknown
   linkType: soft
 
@@ -4477,28 +4477,28 @@ __metadata:
     "@types/sinon": ^17
     "@wasm-tool/wasm-pack-plugin": ^1.7.0
     "@web/dev-server-esbuild": ^0.3.6
-    "@web/test-runner": ^0.18.0
+    "@web/test-runner": ^0.18.1
     "@web/test-runner-playwright": ^0.11.0
     adm-zip: ^0.5.0
     assert: ^2.1.0
     browserify-fs: ^1.0.0
-    chai: ^4.3.10
+    chai: ^4.4.1
     copy-webpack-plugin: ^12.0.2
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     html-webpack-plugin: ^5.6.0
     memfs: ^4.6.0
     mocha: ^10.2.0
     mocha-each: ^2.0.1
     pako: ^2.1.0
     path-browserify: ^1.0.1
-    prettier: 3.0.3
+    prettier: 3.2.5
     process: ^0.11.10
     readable-stream: ^4.4.2
     sinon: ^17.0.1
     ts-loader: ^9.5.1
     ts-node: ^10.9.1
-    typescript: ~5.2.2
+    typescript: ^5.4.2
     unzipit: ^1.4.3
     url: ^0.11.3
     webpack: ^5.90.1
@@ -4514,9 +4514,9 @@ __metadata:
     "@esm-bundle/chai": ^4.3.4-fix.0
     "@noir-lang/types": "workspace:*"
     "@web/dev-server-esbuild": ^0.3.6
-    "@web/test-runner": ^0.15.3
+    "@web/test-runner": ^0.18.1
     "@web/test-runner-playwright": ^0.10.0
-    eslint: ^8.56.0
+    eslint: ^8.57.0
     mocha: ^10.2.0
   languageName: unknown
   linkType: soft
@@ -4527,14 +4527,14 @@ __metadata:
   dependencies:
     "@typescript-eslint/eslint-plugin": ^6.7.3
     "@typescript-eslint/parser": ^6.7.3
-    chai: ^4.3.7
+    chai: ^4.4.1
     cspell: ^8.3.2
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     mocha: ^10.2.0
-    prettier: 3.0.3
+    prettier: 3.2.5
     ts-node: ^10.9.1
-    typescript: ^5.0.4
+    typescript: ^5.4.2
   languageName: unknown
   linkType: soft
 
@@ -4543,10 +4543,10 @@ __metadata:
   resolution: "@noir-lang/types@workspace:tooling/noir_js_types"
   dependencies:
     "@types/prettier": ^3
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
-    prettier: 3.0.3
-    typescript: ^5.2.2
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
+    prettier: 3.2.5
+    typescript: ^5.4.2
   languageName: unknown
   linkType: soft
 
@@ -4876,17 +4876,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@pkgr/utils@npm:^2.4.2":
-  version: 2.4.2
-  resolution: "@pkgr/utils@npm:2.4.2"
-  dependencies:
-    cross-spawn: ^7.0.3
-    fast-glob: ^3.3.0
-    is-glob: ^4.0.3
-    open: ^9.1.0
-    picocolors: ^1.0.0
-    tslib: ^2.6.0
-  checksum: 24e04c121269317d259614cd32beea3af38277151c4002df5883c4be920b8e3490bb897748e844f9d46bf68230f86dabd4e8f093773130e7e60529a769a132fc
+"@pkgr/core@npm:^0.1.0":
+  version: 0.1.1
+  resolution: "@pkgr/core@npm:0.1.1"
+  checksum: 6f25fd2e3008f259c77207ac9915b02f1628420403b2630c92a07ff963129238c9262afc9e84344c7a23b5cc1f3965e2cd17e3798219f5fd78a63d144d3cceba
   languageName: node
   linkType: hard
 
@@ -4924,64 +4917,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@puppeteer/browsers@npm:0.5.0":
-  version: 0.5.0
-  resolution: "@puppeteer/browsers@npm:0.5.0"
-  dependencies:
-    debug: 4.3.4
-    extract-zip: 2.0.1
-    https-proxy-agent: 5.0.1
-    progress: 2.0.3
-    proxy-from-env: 1.1.0
-    tar-fs: 2.1.1
-    unbzip2-stream: 1.4.3
-    yargs: 17.7.1
-  peerDependencies:
-    typescript: ">= 4.7.4"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  bin:
-    browsers: lib/cjs/main-cli.js
-  checksum: d75fde03be4be106ca907834739251c2bb0b33a09fa23315c5dbe8b8b4cfed2f1b26af62e1dbe5fccc227e9bc87b51da0815461b982477eb01439bfdd6e7b01a
-  languageName: node
-  linkType: hard
-
-"@puppeteer/browsers@npm:1.4.6":
-  version: 1.4.6
-  resolution: "@puppeteer/browsers@npm:1.4.6"
+"@puppeteer/browsers@npm:2.1.0":
+  version: 2.1.0
+  resolution: "@puppeteer/browsers@npm:2.1.0"
   dependencies:
     debug: 4.3.4
     extract-zip: 2.0.1
     progress: 2.0.3
-    proxy-agent: 6.3.0
-    tar-fs: 3.0.4
+    proxy-agent: 6.4.0
+    semver: 7.6.0
+    tar-fs: 3.0.5
     unbzip2-stream: 1.4.3
-    yargs: 17.7.1
-  peerDependencies:
-    typescript: ">= 4.7.4"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
+    yargs: 17.7.2
   bin:
     browsers: lib/cjs/main-cli.js
-  checksum: 29569dd8a8a41737bb0dd40cce6279cfc8764afc6242d2f9d8ae610bed7e466fc77eeb27b9b3ac53dd04927a1a0e26389f282f6ba057210979b36ab455009d64
-  languageName: node
-  linkType: hard
-
-"@rollup/plugin-node-resolve@npm:^13.0.4":
-  version: 13.3.0
-  resolution: "@rollup/plugin-node-resolve@npm:13.3.0"
-  dependencies:
-    "@rollup/pluginutils": ^3.1.0
-    "@types/resolve": 1.17.1
-    deepmerge: ^4.2.2
-    is-builtin-module: ^3.1.0
-    is-module: ^1.0.0
-    resolve: ^1.19.0
-  peerDependencies:
-    rollup: ^2.42.0
-  checksum: ec5418e6b3c23a9e30683056b3010e9d325316dcfae93fbc673ae64dad8e56a2ce761c15c48f5e2dcfe0c822fdc4a4905ee6346e3dcf90603ba2260afef5a5e6
+  checksum: 318740056fc716cf26179f053eb47e119bc01658f59382a19fb7d39e5b9232a7ad7d82e33445e0519683c13e22b328193fc9952c99d09cdc09f6539391d4749c
   languageName: node
   linkType: hard
 
@@ -5004,19 +4954,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@rollup/pluginutils@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "@rollup/pluginutils@npm:3.1.0"
-  dependencies:
-    "@types/estree": 0.0.39
-    estree-walker: ^1.0.1
-    picomatch: ^2.2.2
-  peerDependencies:
-    rollup: ^1.20.0||^2.0.0
-  checksum: 8be16e27863c219edbb25a4e6ec2fe0e1e451d9e917b6a43cf2ae5bc025a6b8faaa40f82a6e53b66d0de37b58ff472c6c3d57a83037ae635041f8df959d6d9aa
-  languageName: node
-  linkType: hard
-
 "@rollup/pluginutils@npm:^5.0.1":
   version: 5.1.0
   resolution: "@rollup/pluginutils@npm:5.1.0"
@@ -5785,13 +5722,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/estree@npm:0.0.39":
-  version: 0.0.39
-  resolution: "@types/estree@npm:0.0.39"
-  checksum: 412fb5b9868f2c418126451821833414189b75cc6bf84361156feed733e3d92ec220b9d74a89e52722e03d5e241b2932732711b7497374a404fad49087adc248
-  languageName: node
-  linkType: hard
-
 "@types/express-serve-static-core@npm:*, @types/express-serve-static-core@npm:^4.17.33":
   version: 4.17.41
   resolution: "@types/express-serve-static-core@npm:4.17.41"
@@ -6027,13 +5957,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/mocha@npm:^8.2.0":
-  version: 8.2.3
-  resolution: "@types/mocha@npm:8.2.3"
-  checksum: b43ed1b642a2ee62bf10792a07d5d21d66ab8b4d2cf5d822c8a7643e77b90009aecc000eefab5f6ddc9eb69004192f84119a6f97a8499e1a13ea082e7a5e71bf
-  languageName: node
-  linkType: hard
-
 "@types/ms@npm:*":
   version: 0.7.34
   resolution: "@types/ms@npm:0.7.34"
@@ -6226,15 +6149,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/resolve@npm:1.17.1":
-  version: 1.17.1
-  resolution: "@types/resolve@npm:1.17.1"
-  dependencies:
-    "@types/node": "*"
-  checksum: dc6a6df507656004e242dcb02c784479deca516d5f4b58a1707e708022b269ae147e1da0521f3e8ad0d63638869d87e0adc023f0bd5454aa6f72ac66c7525cf5
-  languageName: node
-  linkType: hard
-
 "@types/resolve@npm:1.20.2":
   version: 1.20.2
   resolution: "@types/resolve@npm:1.20.2"
@@ -6550,15 +6464,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/browser-logs@npm:^0.2.6":
-  version: 0.2.6
-  resolution: "@web/browser-logs@npm:0.2.6"
-  dependencies:
-    errorstacks: ^2.2.0
-  checksum: 82693e37a7e5a3c3df255e1e4feef6e6c2f2b7f5f883e1a9fd233d09a22c4f3e9e3dfd2ec809d7a02f0894156f26b89f1759bf4e9317640ee3630e9a3d9ec2a8
-  languageName: node
-  linkType: hard
-
 "@web/browser-logs@npm:^0.3.4":
   version: 0.3.4
   resolution: "@web/browser-logs@npm:0.3.4"
@@ -6577,15 +6482,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/config-loader@npm:^0.1.3":
-  version: 0.1.3
-  resolution: "@web/config-loader@npm:0.1.3"
-  dependencies:
-    semver: ^7.3.4
-  checksum: 278554bd00b757eaf296ba904a224c61d4698df1a5d6c04931c40bc6bb308e81e767055cbf283b763cc530aae6b200bb950aa19eb41aa8979a3a2b29e5f0ac7a
-  languageName: node
-  linkType: hard
-
 "@web/config-loader@npm:^0.3.0":
   version: 0.3.1
   resolution: "@web/config-loader@npm:0.3.1"
@@ -6698,20 +6594,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/dev-server-rollup@npm:^0.4.1":
-  version: 0.4.1
-  resolution: "@web/dev-server-rollup@npm:0.4.1"
-  dependencies:
-    "@rollup/plugin-node-resolve": ^13.0.4
-    "@web/dev-server-core": ^0.4.1
-    nanocolors: ^0.2.1
-    parse5: ^6.0.1
-    rollup: ^2.67.0
-    whatwg-url: ^11.0.0
-  checksum: a0c3566f67b5a5ead3822431302ddcaa9d043b18fdcf1190056a4e0539e5d5b545ebfecaf6021412eb4b5b6e074c2b1eff35c71e859195623c7c07e065f9df58
-  languageName: node
-  linkType: hard
-
 "@web/dev-server-rollup@npm:^0.6.1":
   version: 0.6.1
   resolution: "@web/dev-server-rollup@npm:0.6.1"
@@ -6726,31 +6608,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/dev-server@npm:^0.1.38":
-  version: 0.1.38
-  resolution: "@web/dev-server@npm:0.1.38"
-  dependencies:
-    "@babel/code-frame": ^7.12.11
-    "@types/command-line-args": ^5.0.0
-    "@web/config-loader": ^0.1.3
-    "@web/dev-server-core": ^0.4.1
-    "@web/dev-server-rollup": ^0.4.1
-    camelcase: ^6.2.0
-    command-line-args: ^5.1.1
-    command-line-usage: ^7.0.1
-    debounce: ^1.2.0
-    deepmerge: ^4.2.2
-    ip: ^1.1.5
-    nanocolors: ^0.2.1
-    open: ^8.0.2
-    portfinder: ^1.0.32
-  bin:
-    wds: dist/bin.js
-    web-dev-server: dist/bin.js
-  checksum: eeaf34f8744f58cfb9493155ad8548a87cae4e445a2fa894610b070f66cb303614d247bb609e378b9df342935ad980a259630317c444d19f9796abfcfb20bb13
-  languageName: node
-  linkType: hard
-
 "@web/dev-server@npm:^0.4.0":
   version: 0.4.1
   resolution: "@web/dev-server@npm:0.4.1"
@@ -6796,38 +6653,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/test-runner-chrome@npm:^0.12.1":
-  version: 0.12.1
-  resolution: "@web/test-runner-chrome@npm:0.12.1"
-  dependencies:
-    "@web/test-runner-core": ^0.10.29
-    "@web/test-runner-coverage-v8": ^0.5.0
-    chrome-launcher: ^0.15.0
-    puppeteer-core: ^19.8.1
-  checksum: 08964e4c22c286231a6bdc003393316a7e0c7878560a9394d8bb9212c3c2e37799bc0aaf4732921213647c3dc89169146f65746d381feaa9c281c0373bf9da59
-  languageName: node
-  linkType: hard
-
-"@web/test-runner-chrome@npm:^0.15.0":
-  version: 0.15.0
-  resolution: "@web/test-runner-chrome@npm:0.15.0"
+"@web/test-runner-chrome@npm:^0.16.0":
+  version: 0.16.0
+  resolution: "@web/test-runner-chrome@npm:0.16.0"
   dependencies:
     "@web/test-runner-core": ^0.13.0
     "@web/test-runner-coverage-v8": ^0.8.0
     async-mutex: 0.4.0
     chrome-launcher: ^0.15.0
-    puppeteer-core: ^20.0.0
-  checksum: 091aa83707aa1a6ade8074c37050f9a0fae2729f223b5e7d756f86ccdadcd85e738cc47d0a4ae8ac6ea930142cc20e341f5d3ad30a3a81d6666b353a7e8c2dd4
-  languageName: node
-  linkType: hard
-
-"@web/test-runner-commands@npm:^0.6.6":
-  version: 0.6.6
-  resolution: "@web/test-runner-commands@npm:0.6.6"
-  dependencies:
-    "@web/test-runner-core": ^0.10.29
-    mkdirp: ^1.0.4
-  checksum: b25533edd9ec59aeec28756a52ae4c6730388c336fa94e0c21eedf208012efd9aedf96c47ebad9a98cce9d87c4ee539b318a571e1e2bfb1bf8e5f1f6889c98e4
+    puppeteer-core: ^22.0.0
+  checksum: 99cfa93d12e8854fb2d104de1f8c5a73403e39fc56e5ed78e24f63e903299521750c7b475253dfb75293a2e604ed83d5cfdc1e593a72e9208a99a511bdb6169a
   languageName: node
   linkType: hard
 
@@ -6841,40 +6676,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/test-runner-core@npm:^0.10.20, @web/test-runner-core@npm:^0.10.29":
-  version: 0.10.29
-  resolution: "@web/test-runner-core@npm:0.10.29"
-  dependencies:
-    "@babel/code-frame": ^7.12.11
-    "@types/babel__code-frame": ^7.0.2
-    "@types/co-body": ^6.1.0
-    "@types/convert-source-map": ^2.0.0
-    "@types/debounce": ^1.2.0
-    "@types/istanbul-lib-coverage": ^2.0.3
-    "@types/istanbul-reports": ^3.0.0
-    "@web/browser-logs": ^0.2.6
-    "@web/dev-server-core": ^0.4.1
-    chokidar: ^3.4.3
-    cli-cursor: ^3.1.0
-    co-body: ^6.1.0
-    convert-source-map: ^2.0.0
-    debounce: ^1.2.0
-    dependency-graph: ^0.11.0
-    globby: ^11.0.1
-    ip: ^1.1.5
-    istanbul-lib-coverage: ^3.0.0
-    istanbul-lib-report: ^3.0.0
-    istanbul-reports: ^3.0.2
-    log-update: ^4.0.0
-    nanocolors: ^0.2.1
-    nanoid: ^3.1.25
-    open: ^8.0.2
-    picomatch: ^2.2.2
-    source-map: ^0.7.3
-  checksum: 635a510442bea3bce97596a2aed1c58a6154b4b83a44bf3e9c9497a751f42426cae5f67555916c4fd63064a4e91a5e26755e3090887ebac38ec0ab2691e1fe6c
-  languageName: node
-  linkType: hard
-
 "@web/test-runner-core@npm:^0.12.0":
   version: 0.12.0
   resolution: "@web/test-runner-core@npm:0.12.0"
@@ -6943,18 +6744,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/test-runner-coverage-v8@npm:^0.5.0":
-  version: 0.5.0
-  resolution: "@web/test-runner-coverage-v8@npm:0.5.0"
-  dependencies:
-    "@web/test-runner-core": ^0.10.20
-    istanbul-lib-coverage: ^3.0.0
-    picomatch: ^2.2.2
-    v8-to-istanbul: ^9.0.1
-  checksum: e69dc6379cff24f28bd21cc37a661945fbf7f3fd532da813e74f4042efe17fc191cdb7c09f1e1ea276167952b0116478ba0fe7af0966fa4867278c3a2cd772df
-  languageName: node
-  linkType: hard
-
 "@web/test-runner-coverage-v8@npm:^0.7.3":
   version: 0.7.3
   resolution: "@web/test-runner-coverage-v8@npm:0.7.3"
@@ -6981,16 +6770,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/test-runner-mocha@npm:^0.7.5":
-  version: 0.7.5
-  resolution: "@web/test-runner-mocha@npm:0.7.5"
-  dependencies:
-    "@types/mocha": ^8.2.0
-    "@web/test-runner-core": ^0.10.20
-  checksum: 12f87299945d230815bb783de2953ac4239306c1a67145ef5b78cfb0b361ae7f659e5d3e5150af2cedc6f2c55adf10652b761f016430a7ac2d7f77b91ecb9cd1
-  languageName: node
-  linkType: hard
-
 "@web/test-runner-mocha@npm:^0.9.0":
   version: 0.9.0
   resolution: "@web/test-runner-mocha@npm:0.9.0"
@@ -7022,41 +6801,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@web/test-runner@npm:^0.15.3":
-  version: 0.15.3
-  resolution: "@web/test-runner@npm:0.15.3"
-  dependencies:
-    "@web/browser-logs": ^0.2.6
-    "@web/config-loader": ^0.1.3
-    "@web/dev-server": ^0.1.38
-    "@web/test-runner-chrome": ^0.12.1
-    "@web/test-runner-commands": ^0.6.6
-    "@web/test-runner-core": ^0.10.29
-    "@web/test-runner-mocha": ^0.7.5
-    camelcase: ^6.2.0
-    command-line-args: ^5.1.1
-    command-line-usage: ^7.0.1
-    convert-source-map: ^2.0.0
-    diff: ^5.0.0
-    globby: ^11.0.1
-    nanocolors: ^0.2.1
-    portfinder: ^1.0.32
-    source-map: ^0.7.3
-  bin:
-    web-test-runner: dist/bin.js
-    wtr: dist/bin.js
-  checksum: 75d00d4f15f9977ff4e8fca84e1c7f9d834073688df06d9e4b62bf43cad65a36b2ae21b9ebab5706e4d3b07fc639bb90758b1be1df036c8b80137ec3407a8f08
-  languageName: node
-  linkType: hard
-
-"@web/test-runner@npm:^0.18.0":
-  version: 0.18.0
-  resolution: "@web/test-runner@npm:0.18.0"
+"@web/test-runner@npm:^0.18.1":
+  version: 0.18.1
+  resolution: "@web/test-runner@npm:0.18.1"
   dependencies:
     "@web/browser-logs": ^0.4.0
     "@web/config-loader": ^0.3.0
     "@web/dev-server": ^0.4.0
-    "@web/test-runner-chrome": ^0.15.0
+    "@web/test-runner-chrome": ^0.16.0
     "@web/test-runner-commands": ^0.9.0
     "@web/test-runner-core": ^0.13.0
     "@web/test-runner-mocha": ^0.9.0
@@ -7072,7 +6824,7 @@ __metadata:
   bin:
     web-test-runner: dist/bin.js
     wtr: dist/bin.js
-  checksum: d5e410f08cb954f9854a3d837f5f704b578376ee8b0452cff66aeca2eb3cb98e50556ca3b958bda567b42af2ef2cd0a7424eaea40f9b3e80362ae788fbd33118
+  checksum: eb21fc5978da2ccbfd6ffac0f61b519036d68a9cdcf211c1dbafa9c6b6f92bb10a9267dec02f4d71dfc45e636166d98712ff9a347af951eabff99b0d7e5899b5
   languageName: node
   linkType: hard
 
@@ -7958,6 +7710,41 @@ __metadata:
   languageName: node
   linkType: hard
 
+"bare-events@npm:^2.0.0, bare-events@npm:^2.2.0":
+  version: 2.2.1
+  resolution: "bare-events@npm:2.2.1"
+  checksum: f4f830fe780b105fce189180761cf69ac60848212133ca7d29eb94f8888f813bf70f339e4e651b200aa8304fc9dc77ca7443756cc68b43294367b5867ad4536b
+  languageName: node
+  linkType: hard
+
+"bare-fs@npm:^2.1.1":
+  version: 2.2.2
+  resolution: "bare-fs@npm:2.2.2"
+  dependencies:
+    bare-events: ^2.0.0
+    bare-os: ^2.0.0
+    bare-path: ^2.0.0
+    streamx: ^2.13.0
+  checksum: 5b6d26690ee4de93b559f6a1187b6ff553224fe4faea5ef9cbd235b13e033ef96a598dc28eb10aad17d1f35baed24e14e18436534041913f905a0c50ed27713a
+  languageName: node
+  linkType: hard
+
+"bare-os@npm:^2.0.0, bare-os@npm:^2.1.0":
+  version: 2.2.1
+  resolution: "bare-os@npm:2.2.1"
+  checksum: 7d870d8955531809253dfbceeda5b68e8396ef640166f8ff6c4c5e344f18a6bc9253f6d5e7d9ae2841426b66e9b7b1a39b2a102e6b23e1ddff26ad8a8981af81
+  languageName: node
+  linkType: hard
+
+"bare-path@npm:^2.0.0, bare-path@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "bare-path@npm:2.1.0"
+  dependencies:
+    bare-os: ^2.1.0
+  checksum: 03f260e72bd0ae0df4cd712322a2d3c8c16701ffaa55cf2d517ae62b7f78c64b7ec5bba81ec579367f966472481f5160db282e6663bd0fc8cfb09ebe272d8bba
+  languageName: node
+  linkType: hard
+
 "base-x@npm:^3.0.2":
   version: 3.0.9
   resolution: "base-x@npm:3.0.9"
@@ -7995,13 +7782,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"big-integer@npm:^1.6.44":
-  version: 1.6.52
-  resolution: "big-integer@npm:1.6.52"
-  checksum: 6e86885787a20fed96521958ae9086960e4e4b5e74d04f3ef7513d4d0ad631a9f3bde2730fc8aaa4b00419fc865f6ec573e5320234531ef37505da7da192c40b
-  languageName: node
-  linkType: hard
-
 "big.js@npm:^5.2.2":
   version: 5.2.2
   resolution: "big.js@npm:5.2.2"
@@ -8023,17 +7803,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bl@npm:^4.0.3":
-  version: 4.1.0
-  resolution: "bl@npm:4.1.0"
-  dependencies:
-    buffer: ^5.5.0
-    inherits: ^2.0.4
-    readable-stream: ^3.4.0
-  checksum: 9e8521fa7e83aa9427c6f8ccdcba6e8167ef30cc9a22df26effcc5ab682ef91d2cbc23a239f945d099289e4bbcfae7a192e9c28c84c6202e710a0dfec3722662
-  languageName: node
-  linkType: hard
-
 "bl@npm:~0.8.1":
   version: 0.8.2
   resolution: "bl@npm:0.8.2"
@@ -8177,15 +7946,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bplist-parser@npm:^0.2.0":
-  version: 0.2.0
-  resolution: "bplist-parser@npm:0.2.0"
-  dependencies:
-    big-integer: ^1.6.44
-  checksum: d5339dd16afc51de6c88f88f58a45b72ed6a06aa31f5557d09877575f220b7c1d3fbe375da0b62e6a10d4b8ed80523567e351f24014f5bc886ad523758142cdd
-  languageName: node
-  linkType: hard
-
 "brace-expansion@npm:^1.1.7":
   version: 1.1.11
   resolution: "brace-expansion@npm:1.1.11"
@@ -8320,7 +8080,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"buffer@npm:^5.2.1, buffer@npm:^5.5.0":
+"buffer@npm:^5.2.1":
   version: 5.7.1
   resolution: "buffer@npm:5.7.1"
   dependencies:
@@ -8347,15 +8107,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bundle-name@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "bundle-name@npm:3.0.0"
-  dependencies:
-    run-applescript: ^5.0.0
-  checksum: edf2b1fbe6096ed32e7566947ace2ea937ee427391744d7510a2880c4b9a5b3543d3f6c551236a29e5c87d3195f8e2912516290e638c15bcbede7b37cc375615
-  languageName: node
-  linkType: hard
-
 "bundle-name@npm:^4.1.0":
   version: 4.1.0
   resolution: "bundle-name@npm:4.1.0"
@@ -8553,9 +8304,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chai@npm:^4.3.10, chai@npm:^4.3.7, chai@npm:^4.3.8":
-  version: 4.3.10
-  resolution: "chai@npm:4.3.10"
+"chai@npm:^4.4.1":
+  version: 4.4.1
+  resolution: "chai@npm:4.4.1"
   dependencies:
     assertion-error: ^1.1.0
     check-error: ^1.0.3
@@ -8564,7 +8315,7 @@ __metadata:
     loupe: ^2.3.6
     pathval: ^1.1.1
     type-detect: ^4.0.8
-  checksum: 536668c60a0d985a0fbd94418028e388d243a925d7c5e858c7443e334753511614a3b6a124bac9ca077dfc4c37acc367d62f8c294960f440749536dc181dfc6d
+  checksum: 9ab84f36eb8e0b280c56c6c21ca4da5933132cd8a0c89c384f1497f77953640db0bc151edd47f81748240a9fab57b78f7d925edfeedc8e8fc98016d71f40c36e
   languageName: node
   linkType: hard
 
@@ -8753,13 +8504,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chownr@npm:^1.1.1":
-  version: 1.1.4
-  resolution: "chownr@npm:1.1.4"
-  checksum: 115648f8eb38bac5e41c3857f3e663f9c39ed6480d1349977c4d96c95a47266fcacc5a5aabf3cb6c481e22d72f41992827db47301851766c4fd77ac21a4f081d
-  languageName: node
-  linkType: hard
-
 "chownr@npm:^2.0.0":
   version: 2.0.0
   resolution: "chownr@npm:2.0.0"
@@ -8788,25 +8532,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chromium-bidi@npm:0.4.16":
-  version: 0.4.16
-  resolution: "chromium-bidi@npm:0.4.16"
-  dependencies:
-    mitt: 3.0.0
-  peerDependencies:
-    devtools-protocol: "*"
-  checksum: 9cbb362fdf589dbdfd1618499c5bbdac45a3aa1291c1d2faa2f1ea3768738677985175d1bb1511dfe3e188bc78e6ea2acb453564ece7e09f535bbcd2253ce06a
-  languageName: node
-  linkType: hard
-
-"chromium-bidi@npm:0.4.7":
-  version: 0.4.7
-  resolution: "chromium-bidi@npm:0.4.7"
+"chromium-bidi@npm:0.5.12":
+  version: 0.5.12
+  resolution: "chromium-bidi@npm:0.5.12"
   dependencies:
-    mitt: 3.0.0
+    mitt: 3.0.1
+    urlpattern-polyfill: 10.0.0
   peerDependencies:
     devtools-protocol: "*"
-  checksum: eec7581e2eddd2c95014c6edc5aae0b036c79bbeadee05166436b16139b6932c902c5ce21d95ed919a592f58d3a47c5469dc5f3de2a300700b2748ab119ad65e
+  checksum: c14aedc9725a813d82ce66423750757383af6d7580b4f22f8756d31a340b8d6d77dd30a4de0e213f2f89e63faf54a333431acc07675791f1c176d2275e499525
   languageName: node
   linkType: hard
 
@@ -9543,15 +9277,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cross-fetch@npm:3.1.5":
-  version: 3.1.5
-  resolution: "cross-fetch@npm:3.1.5"
-  dependencies:
-    node-fetch: 2.6.7
-  checksum: f6b8c6ee3ef993ace6277fd789c71b6acf1b504fd5f5c7128df4ef2f125a429e29cd62dc8c127523f04a5f2fa4771ed80e3f3d9695617f441425045f505cf3bb
-  languageName: node
-  linkType: hard
-
 "cross-fetch@npm:4.0.0":
   version: 4.0.0
   resolution: "cross-fetch@npm:4.0.0"
@@ -9947,7 +9672,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:4, debug@npm:4.3.4, debug@npm:^4.0.0, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.2.0, debug@npm:^4.3.2, debug@npm:^4.3.3, debug@npm:^4.3.4":
+"debug@npm:4, debug@npm:4.3.4, debug@npm:^4.0.0, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.2.0, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.3, debug@npm:^4.3.4":
   version: 4.3.4
   resolution: "debug@npm:4.3.4"
   dependencies:
@@ -10039,16 +9764,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"default-browser-id@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "default-browser-id@npm:3.0.0"
-  dependencies:
-    bplist-parser: ^0.2.0
-    untildify: ^4.0.0
-  checksum: 279c7ad492542e5556336b6c254a4eaf31b2c63a5433265655ae6e47301197b6cfb15c595a6fdc6463b2ff8e1a1a1ed3cba56038a60e1527ba4ab1628c6b9941
-  languageName: node
-  linkType: hard
-
 "default-browser-id@npm:^5.0.0":
   version: 5.0.0
   resolution: "default-browser-id@npm:5.0.0"
@@ -10056,18 +9771,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"default-browser@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "default-browser@npm:4.0.0"
-  dependencies:
-    bundle-name: ^3.0.0
-    default-browser-id: ^3.0.0
-    execa: ^7.1.1
-    titleize: ^3.0.0
-  checksum: 40c5af984799042b140300be5639c9742599bda76dc9eba5ac9ad5943c83dd36cebc4471eafcfddf8e0ec817166d5ba89d56f08e66a126c7c7908a179cead1a7
-  languageName: node
-  linkType: hard
-
 "default-browser@npm:^5.2.1":
   version: 5.2.1
   resolution: "default-browser@npm:5.2.1"
@@ -10273,17 +9976,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"devtools-protocol@npm:0.0.1107588":
-  version: 0.0.1107588
-  resolution: "devtools-protocol@npm:0.0.1107588"
-  checksum: 9064fd643f39ae0adabb8f425b746899ff24371d89a5047d38752653259e6afcb6bcb2d9759ff727eb5885cfc0f9ba8eb384850a2af00694135622e88080e3e5
-  languageName: node
-  linkType: hard
-
-"devtools-protocol@npm:0.0.1147663":
-  version: 0.0.1147663
-  resolution: "devtools-protocol@npm:0.0.1147663"
-  checksum: 0631f2b6c6cd7f56e7d62a85bfc291f7e167f0f2de90969ef61fb24e2bd546b2e9530043d2bc3fe6c4d7a9e00473004272d2c2832a10a05e4b75c03a22f549fc
+"devtools-protocol@npm:0.0.1249869":
+  version: 0.0.1249869
+  resolution: "devtools-protocol@npm:0.0.1249869"
+  checksum: 549dda02f6d778741930e5abdde3f8e5d39e16fdbe8af38597a974e9c239798dd464250bd7ab4360d77e3d059620e95be7cf05150142473bf9b661ed28a616ed
   languageName: node
   linkType: hard
 
@@ -10351,9 +10047,9 @@ __metadata:
     axios: ^1.4.0
     clsx: ^1.2.1
     docusaurus-plugin-typedoc: 1.0.0-next.18
-    eslint-plugin-prettier: ^5.0.0
+    eslint-plugin-prettier: ^5.1.3
     hast-util-is-element: ^1.1.0
-    prettier: 3.0.3
+    prettier: 3.2.5
     prism-react-renderer: ^2.1.0
     react: ^18.2.0
     react-dom: ^18.2.0
@@ -10366,7 +10062,7 @@ __metadata:
     typedoc-plugin-frontmatter: ^0.0.2
     typedoc-plugin-markdown: 4.0.0-next.25
     typedoc-plugin-merge-modules: ^5.1.0
-    typescript: ~5.2.2
+    typescript: ^5.4.2
   languageName: unknown
   linkType: soft
 
@@ -10604,7 +10300,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"end-of-stream@npm:^1.1.0, end-of-stream@npm:^1.4.1":
+"end-of-stream@npm:^1.1.0":
   version: 1.4.4
   resolution: "end-of-stream@npm:1.4.4"
   dependencies:
@@ -10925,22 +10621,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint-plugin-prettier@npm:^5.0.0":
-  version: 5.0.1
-  resolution: "eslint-plugin-prettier@npm:5.0.1"
+"eslint-plugin-prettier@npm:^5.1.3":
+  version: 5.1.3
+  resolution: "eslint-plugin-prettier@npm:5.1.3"
   dependencies:
     prettier-linter-helpers: ^1.0.0
-    synckit: ^0.8.5
+    synckit: ^0.8.6
   peerDependencies:
     "@types/eslint": ">=8.0.0"
     eslint: ">=8.0.0"
+    eslint-config-prettier: "*"
     prettier: ">=3.0.0"
   peerDependenciesMeta:
     "@types/eslint":
       optional: true
     eslint-config-prettier:
       optional: true
-  checksum: c2261033b97bafe99ccb7cc47c2fac6fa85b8bbc8b128042e52631f906b69e12afed2cdd9d7e3021cc892ee8dd4204a3574e1f32a0b718b4bb3b440944b6983b
+  checksum: eb2a7d46a1887e1b93788ee8f8eb81e0b6b2a6f5a66a62bc6f375b033fc4e7ca16448da99380be800042786e76cf5c0df9c87a51a2c9b960ed47acbd7c0b9381
   languageName: node
   linkType: hard
 
@@ -10971,15 +10668,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint@npm:^8.56.0":
-  version: 8.56.0
-  resolution: "eslint@npm:8.56.0"
+"eslint@npm:^8.57.0":
+  version: 8.57.0
+  resolution: "eslint@npm:8.57.0"
   dependencies:
     "@eslint-community/eslint-utils": ^4.2.0
     "@eslint-community/regexpp": ^4.6.1
     "@eslint/eslintrc": ^2.1.4
-    "@eslint/js": 8.56.0
-    "@humanwhocodes/config-array": ^0.11.13
+    "@eslint/js": 8.57.0
+    "@humanwhocodes/config-array": ^0.11.14
     "@humanwhocodes/module-importer": ^1.0.1
     "@nodelib/fs.walk": ^1.2.8
     "@ungap/structured-clone": ^1.2.0
@@ -11015,7 +10712,7 @@ __metadata:
     text-table: ^0.2.0
   bin:
     eslint: bin/eslint.js
-  checksum: 883436d1e809b4a25d9eb03d42f584b84c408dbac28b0019f6ea07b5177940bf3cca86208f749a6a1e0039b63e085ee47aca1236c30721e91f0deef5cc5a5136
+  checksum: 3a48d7ff85ab420a8447e9810d8087aea5b1df9ef68c9151732b478de698389ee656fd895635b5f2871c89ee5a2652b3f343d11e9db6f8486880374ebc74a2d9
   languageName: node
   linkType: hard
 
@@ -11131,13 +10828,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"estree-walker@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "estree-walker@npm:1.0.1"
-  checksum: 7e70da539691f6db03a08e7ce94f394ce2eef4180e136d251af299d41f92fb2d28ebcd9a6e393e3728d7970aeb5358705ddf7209d52fbcb2dd4693f95dcf925f
-  languageName: node
-  linkType: hard
-
 "estree-walker@npm:^2.0.2":
   version: 2.0.2
   resolution: "estree-walker@npm:2.0.2"
@@ -11357,23 +11047,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"execa@npm:^7.1.1":
-  version: 7.2.0
-  resolution: "execa@npm:7.2.0"
-  dependencies:
-    cross-spawn: ^7.0.3
-    get-stream: ^6.0.1
-    human-signals: ^4.3.0
-    is-stream: ^3.0.0
-    merge-stream: ^2.0.0
-    npm-run-path: ^5.1.0
-    onetime: ^6.0.0
-    signal-exit: ^3.0.7
-    strip-final-newline: ^3.0.0
-  checksum: 14fd17ba0ca8c87b277584d93b1d9fc24f2a65e5152b31d5eb159a3b814854283eaae5f51efa9525e304447e2f757c691877f7adff8fde5746aae67eb1edd1cc
-  languageName: node
-  linkType: hard
-
 "exponential-backoff@npm:^3.1.1":
   version: 3.1.1
   resolution: "exponential-backoff@npm:3.1.1"
@@ -11887,13 +11560,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fs-constants@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "fs-constants@npm:1.0.0"
-  checksum: 18f5b718371816155849475ac36c7d0b24d39a11d91348cfcb308b4494824413e03572c403c86d3a260e049465518c4f0d5bd00f0371cdfcad6d4f30a85b350d
-  languageName: node
-  linkType: hard
-
 "fs-extra@npm:^0.30.0":
   version: 0.30.0
   resolution: "fs-extra@npm:0.30.0"
@@ -13130,6 +12796,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"http-proxy-agent@npm:^7.0.1":
+  version: 7.0.2
+  resolution: "http-proxy-agent@npm:7.0.2"
+  dependencies:
+    agent-base: ^7.1.0
+    debug: ^4.3.4
+  checksum: 670858c8f8f3146db5889e1fa117630910101db601fff7d5a8aa637da0abedf68c899f03d3451cac2f83bcc4c3d2dabf339b3aa00ff8080571cceb02c3ce02f3
+  languageName: node
+  linkType: hard
+
 "http-proxy-middleware@npm:^2.0.3":
   version: 2.0.6
   resolution: "http-proxy-middleware@npm:2.0.6"
@@ -13169,7 +12845,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"https-proxy-agent@npm:5.0.1, https-proxy-agent@npm:^5.0.0":
+"https-proxy-agent@npm:^5.0.0":
   version: 5.0.1
   resolution: "https-proxy-agent@npm:5.0.1"
   dependencies:
@@ -13179,7 +12855,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"https-proxy-agent@npm:^7.0.0, https-proxy-agent@npm:^7.0.1, https-proxy-agent@npm:^7.0.2":
+"https-proxy-agent@npm:^7.0.1, https-proxy-agent@npm:^7.0.2":
   version: 7.0.2
   resolution: "https-proxy-agent@npm:7.0.2"
   dependencies:
@@ -13189,6 +12865,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"https-proxy-agent@npm:^7.0.3":
+  version: 7.0.4
+  resolution: "https-proxy-agent@npm:7.0.4"
+  dependencies:
+    agent-base: ^7.0.2
+    debug: 4
+  checksum: daaab857a967a2519ddc724f91edbbd388d766ff141b9025b629f92b9408fc83cee8a27e11a907aede392938e9c398e240d643e178408a59e4073539cde8cfe9
+  languageName: node
+  linkType: hard
+
 "human-signals@npm:^2.1.0":
   version: 2.1.0
   resolution: "human-signals@npm:2.1.0"
@@ -13196,13 +12882,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"human-signals@npm:^4.3.0":
-  version: 4.3.1
-  resolution: "human-signals@npm:4.3.1"
-  checksum: 6f12958df3f21b6fdaf02d90896c271df00636a31e2bbea05bddf817a35c66b38a6fdac5863e2df85bd52f34958997f1f50350ff97249e1dff8452865d5235d1
-  languageName: node
-  linkType: hard
-
 "hyperdyperid@npm:^1.2.0":
   version: 1.2.0
   resolution: "hyperdyperid@npm:1.2.0"
@@ -13438,13 +13117,13 @@ __metadata:
     "@nomicfoundation/hardhat-ethers": ^3.0.0
     "@web/dev-server-esbuild": ^0.3.6
     "@web/dev-server-import-maps": ^0.2.0
-    "@web/test-runner": ^0.15.3
+    "@web/test-runner": ^0.18.1
     "@web/test-runner-playwright": ^0.10.0
-    eslint: ^8.56.0
-    eslint-plugin-prettier: ^5.0.0
+    eslint: ^8.57.0
+    eslint-plugin-prettier: ^5.1.3
     ethers: ^6.7.1
     hardhat: ^2.17.4
-    prettier: 3.0.3
+    prettier: 3.2.5
     smol-toml: ^1.1.2
     toml: ^3.0.0
     tslog: ^4.9.2
@@ -13578,7 +13257,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-builtin-module@npm:^3.1.0, is-builtin-module@npm:^3.2.1":
+"is-builtin-module@npm:^3.2.1":
   version: 3.2.1
   resolution: "is-builtin-module@npm:3.2.1"
   dependencies:
@@ -13899,13 +13578,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-stream@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "is-stream@npm:3.0.0"
-  checksum: 172093fe99119ffd07611ab6d1bcccfe8bc4aa80d864b15f43e63e54b7abc71e779acd69afdb854c4e2a67fdc16ae710e370eda40088d1cfc956a50ed82d8f16
-  languageName: node
-  linkType: hard
-
 "is-typed-array@npm:^1.1.3":
   version: 1.1.12
   resolution: "is-typed-array@npm:1.1.12"
@@ -16034,13 +15706,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mimic-fn@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "mimic-fn@npm:4.0.0"
-  checksum: 995dcece15ee29aa16e188de6633d43a3db4611bcf93620e7e62109ec41c79c0f34277165b8ce5e361205049766e371851264c21ac64ca35499acb5421c2ba56
-  languageName: node
-  linkType: hard
-
 "mimic-response@npm:^1.0.0, mimic-response@npm:^1.0.1":
   version: 1.0.1
   resolution: "mimic-response@npm:1.0.1"
@@ -16205,17 +15870,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mitt@npm:3.0.0":
-  version: 3.0.0
-  resolution: "mitt@npm:3.0.0"
-  checksum: f7be5049d27d18b1dbe9408452d66376fa60ae4a79fe9319869d1b90ae8cbaedadc7e9dab30b32d781411256d468be5538996bb7368941c09009ef6bbfa6bfc7
-  languageName: node
-  linkType: hard
-
-"mkdirp-classic@npm:^0.5.2":
-  version: 0.5.3
-  resolution: "mkdirp-classic@npm:0.5.3"
-  checksum: 3f4e088208270bbcc148d53b73e9a5bd9eef05ad2cbf3b3d0ff8795278d50dd1d11a8ef1875ff5aea3fa888931f95bfcb2ad5b7c1061cfefd6284d199e6776ac
+"mitt@npm:3.0.1":
+  version: 3.0.1
+  resolution: "mitt@npm:3.0.1"
+  checksum: b55a489ac9c2949ab166b7f060601d3b6d893a852515ae9eca4e11df01c013876df777ea109317622b5c1c60e8aae252558e33c8c94e14124db38f64a39614b1
   languageName: node
   linkType: hard
 
@@ -16449,20 +16107,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"node-fetch@npm:2.6.7":
-  version: 2.6.7
-  resolution: "node-fetch@npm:2.6.7"
-  dependencies:
-    whatwg-url: ^5.0.0
-  peerDependencies:
-    encoding: ^0.1.0
-  peerDependenciesMeta:
-    encoding:
-      optional: true
-  checksum: 8d816ffd1ee22cab8301c7756ef04f3437f18dace86a1dae22cf81db8ef29c0bf6655f3215cb0cdb22b420b6fe141e64b26905e7f33f9377a7fa59135ea3e10b
-  languageName: node
-  linkType: hard
-
 "node-fetch@npm:^2.6.12":
   version: 2.7.0
   resolution: "node-fetch@npm:2.7.0"
@@ -16577,15 +16221,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"npm-run-path@npm:^5.1.0":
-  version: 5.1.0
-  resolution: "npm-run-path@npm:5.1.0"
-  dependencies:
-    path-key: ^4.0.0
-  checksum: dc184eb5ec239d6a2b990b43236845332ef12f4e0beaa9701de724aa797fe40b6bbd0157fb7639d24d3ab13f5d5cf22d223a19c6300846b8126f335f788bee66
-  languageName: node
-  linkType: hard
-
 "nprogress@npm:^0.2.0":
   version: 0.2.0
   resolution: "nprogress@npm:0.2.0"
@@ -16718,15 +16353,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"onetime@npm:^6.0.0":
-  version: 6.0.0
-  resolution: "onetime@npm:6.0.0"
-  dependencies:
-    mimic-fn: ^4.0.0
-  checksum: 0846ce78e440841335d4e9182ef69d5762e9f38aa7499b19f42ea1c4cd40f0b4446094c455c713f9adac3f4ae86f613bb5e30c99e52652764d06a89f709b3788
-  languageName: node
-  linkType: hard
-
 "only@npm:~0.0.2":
   version: 0.0.2
   resolution: "only@npm:0.0.2"
@@ -16757,18 +16383,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"open@npm:^9.1.0":
-  version: 9.1.0
-  resolution: "open@npm:9.1.0"
-  dependencies:
-    default-browser: ^4.0.0
-    define-lazy-prop: ^3.0.0
-    is-inside-container: ^1.0.0
-    is-wsl: ^2.2.0
-  checksum: 3993c0f61d51fed8ac290e99c9c3cf45d3b6cfb3e2aa2b74cafd312c3486c22fd81df16ac8f3ab91dd8a4e3e729a16fc2480cfc406c4833416cf908acf1ae7c9
-  languageName: node
-  linkType: hard
-
 "opener@npm:^1.5.2":
   version: 1.5.2
   resolution: "opener@npm:1.5.2"
@@ -16954,7 +16568,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pac-proxy-agent@npm:^7.0.0":
+"pac-proxy-agent@npm:^7.0.1":
   version: 7.0.1
   resolution: "pac-proxy-agent@npm:7.0.1"
   dependencies:
@@ -17181,13 +16795,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"path-key@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "path-key@npm:4.0.0"
-  checksum: 8e6c314ae6d16b83e93032c61020129f6f4484590a777eed709c4a01b50e498822b00f76ceaf94bc64dbd90b327df56ceadce27da3d83393790f1219e07721d7
-  languageName: node
-  linkType: hard
-
 "path-parse@npm:^1.0.6, path-parse@npm:^1.0.7":
   version: 1.0.7
   resolution: "path-parse@npm:1.0.7"
@@ -17833,12 +17440,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prettier@npm:3.0.3":
-  version: 3.0.3
-  resolution: "prettier@npm:3.0.3"
+"prettier@npm:3.2.5":
+  version: 3.2.5
+  resolution: "prettier@npm:3.2.5"
   bin:
     prettier: bin/prettier.cjs
-  checksum: e10b9af02b281f6c617362ebd2571b1d7fc9fb8a3bd17e371754428cda992e5e8d8b7a046e8f7d3e2da1dcd21aa001e2e3c797402ebb6111b5cd19609dd228e0
+  checksum: 2ee4e1417572372afb7a13bb446b34f20f1bf1747db77cf6ccaf57a9be005f2f15c40f903d41a6b79eec3f57fff14d32a20fb6dee1f126da48908926fe43c311
   languageName: node
   linkType: hard
 
@@ -17970,23 +17577,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"proxy-agent@npm:6.3.0":
-  version: 6.3.0
-  resolution: "proxy-agent@npm:6.3.0"
+"proxy-agent@npm:6.4.0":
+  version: 6.4.0
+  resolution: "proxy-agent@npm:6.4.0"
   dependencies:
     agent-base: ^7.0.2
     debug: ^4.3.4
-    http-proxy-agent: ^7.0.0
-    https-proxy-agent: ^7.0.0
+    http-proxy-agent: ^7.0.1
+    https-proxy-agent: ^7.0.3
     lru-cache: ^7.14.1
-    pac-proxy-agent: ^7.0.0
+    pac-proxy-agent: ^7.0.1
     proxy-from-env: ^1.1.0
-    socks-proxy-agent: ^8.0.1
-  checksum: e3fb0633d665e352ed4efe23ae5616b8301423dfa4ff1c5975d093da8a636181a97391f7a91c6a7ffae17c1a305df855e95507f73bcdafda8876198c64b88f5b
+    socks-proxy-agent: ^8.0.2
+  checksum: 4d3794ad5e07486298902f0a7f250d0f869fa0e92d790767ca3f793a81374ce0ab6c605f8ab8e791c4d754da96656b48d1c24cb7094bfd310a15867e4a0841d7
   languageName: node
   linkType: hard
 
-"proxy-from-env@npm:1.1.0, proxy-from-env@npm:^1.1.0":
+"proxy-from-env@npm:^1.1.0":
   version: 1.1.0
   resolution: "proxy-from-env@npm:1.1.0"
   checksum: ed7fcc2ba0a33404958e34d95d18638249a68c430e30fcb6c478497d72739ba64ce9810a24f53a7d921d0c065e5b78e3822759800698167256b04659366ca4d4
@@ -18049,46 +17656,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"puppeteer-core@npm:^19.8.1":
-  version: 19.11.1
-  resolution: "puppeteer-core@npm:19.11.1"
-  dependencies:
-    "@puppeteer/browsers": 0.5.0
-    chromium-bidi: 0.4.7
-    cross-fetch: 3.1.5
-    debug: 4.3.4
-    devtools-protocol: 0.0.1107588
-    extract-zip: 2.0.1
-    https-proxy-agent: 5.0.1
-    proxy-from-env: 1.1.0
-    tar-fs: 2.1.1
-    unbzip2-stream: 1.4.3
-    ws: 8.13.0
-  peerDependencies:
-    typescript: ">= 4.7.4"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 06126e478b8b653e83b98b51cec35dceef8ab576abd1369afd45360c5bac3711443e58ebe3b852d40801a118e4cb7ddf5d3154518b5a9294ee93f7a42d9f22d4
-  languageName: node
-  linkType: hard
-
-"puppeteer-core@npm:^20.0.0":
-  version: 20.9.0
-  resolution: "puppeteer-core@npm:20.9.0"
+"puppeteer-core@npm:^22.0.0":
+  version: 22.4.1
+  resolution: "puppeteer-core@npm:22.4.1"
   dependencies:
-    "@puppeteer/browsers": 1.4.6
-    chromium-bidi: 0.4.16
+    "@puppeteer/browsers": 2.1.0
+    chromium-bidi: 0.5.12
     cross-fetch: 4.0.0
     debug: 4.3.4
-    devtools-protocol: 0.0.1147663
-    ws: 8.13.0
-  peerDependencies:
-    typescript: ">= 4.7.4"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: d298598445b0f2032c02d0ed7d1d18a8d2d2fcaf6fc31fc96e93e2669a7fc6fbee0338bd9b8c8f8822887f18a8fb680b77bb56e96fe1928baadb52292bbd93b4
+    devtools-protocol: 0.0.1249869
+    ws: 8.16.0
+  checksum: 01c28c4f0f66a4ed6c7fee14871920fd25c60ae3507c1b8aed37968b240021f8d0cdd37cb863cebb88fde792ae9fea453e3b943931ae075c99f8e90303d2625f
   languageName: node
   linkType: hard
 
@@ -18411,7 +17989,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"readable-stream@npm:^3.0.6, readable-stream@npm:^3.1.1, readable-stream@npm:^3.4.0, readable-stream@npm:^3.6.0":
+"readable-stream@npm:^3.0.6, readable-stream@npm:^3.4.0, readable-stream@npm:^3.6.0":
   version: 3.6.2
   resolution: "readable-stream@npm:3.6.2"
   dependencies:
@@ -18929,7 +18507,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@npm:^1.1.6, resolve@npm:^1.14.2, resolve@npm:^1.19.0, resolve@npm:^1.20.0, resolve@npm:^1.22.1, resolve@npm:^1.3.2":
+"resolve@npm:^1.1.6, resolve@npm:^1.14.2, resolve@npm:^1.20.0, resolve@npm:^1.22.1, resolve@npm:^1.3.2":
   version: 1.22.8
   resolution: "resolve@npm:1.22.8"
   dependencies:
@@ -18951,7 +18529,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@patch:resolve@^1.1.6#~builtin<compat/resolve>, resolve@patch:resolve@^1.14.2#~builtin<compat/resolve>, resolve@patch:resolve@^1.19.0#~builtin<compat/resolve>, resolve@patch:resolve@^1.20.0#~builtin<compat/resolve>, resolve@patch:resolve@^1.22.1#~builtin<compat/resolve>, resolve@patch:resolve@^1.3.2#~builtin<compat/resolve>":
+"resolve@patch:resolve@^1.1.6#~builtin<compat/resolve>, resolve@patch:resolve@^1.14.2#~builtin<compat/resolve>, resolve@patch:resolve@^1.20.0#~builtin<compat/resolve>, resolve@patch:resolve@^1.22.1#~builtin<compat/resolve>, resolve@patch:resolve@^1.3.2#~builtin<compat/resolve>":
   version: 1.22.8
   resolution: "resolve@patch:resolve@npm%3A1.22.8#~builtin<compat/resolve>::version=1.22.8&hash=c3c19d"
   dependencies:
@@ -19067,20 +18645,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"rollup@npm:^2.67.0":
-  version: 2.79.1
-  resolution: "rollup@npm:2.79.1"
-  dependencies:
-    fsevents: ~2.3.2
-  dependenciesMeta:
-    fsevents:
-      optional: true
-  bin:
-    rollup: dist/bin/rollup
-  checksum: 6a2bf167b3587d4df709b37d149ad0300692cc5deb510f89ac7bdc77c8738c9546ae3de9322b0968e1ed2b0e984571f5f55aae28fa7de4cfcb1bc5402a4e2be6
-  languageName: node
-  linkType: hard
-
 "rollup@npm:^4.4.0":
   version: 4.9.4
   resolution: "rollup@npm:4.9.4"
@@ -19156,15 +18720,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"run-applescript@npm:^5.0.0":
-  version: 5.0.0
-  resolution: "run-applescript@npm:5.0.0"
-  dependencies:
-    execa: ^5.0.0
-  checksum: d00c2dbfa5b2d774de7451194b8b125f40f65fc183de7d9dcae97f57f59433586d3c39b9001e111c38bfa24c3436c99df1bb4066a2a0c90d39a8c4cd6889af77
-  languageName: node
-  linkType: hard
-
 "run-applescript@npm:^7.0.0":
   version: 7.0.0
   resolution: "run-applescript@npm:7.0.0"
@@ -19352,6 +18907,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"semver@npm:7.6.0":
+  version: 7.6.0
+  resolution: "semver@npm:7.6.0"
+  dependencies:
+    lru-cache: ^6.0.0
+  bin:
+    semver: bin/semver.js
+  checksum: 7427f05b70786c696640edc29fdd4bc33b2acf3bbe1740b955029044f80575fc664e1a512e4113c3af21e767154a94b4aa214bf6cd6e42a1f6dba5914e0b208c
+  languageName: node
+  linkType: hard
+
 "semver@npm:^5.4.1, semver@npm:^5.5.0":
   version: 5.7.2
   resolution: "semver@npm:5.7.2"
@@ -19955,6 +19521,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"streamx@npm:^2.13.0":
+  version: 2.16.1
+  resolution: "streamx@npm:2.16.1"
+  dependencies:
+    bare-events: ^2.2.0
+    fast-fifo: ^1.1.0
+    queue-tick: ^1.0.1
+  dependenciesMeta:
+    bare-events:
+      optional: true
+  checksum: 6bbb4c38c0ab6ddbe0857d55e72f71288f308f2a9f4413b7b07391cdf9f94232ffc2bbe40a1212d2e09634ecdbd5052b444c73cc8d67ae1c97e2b7e553dad559
+  languageName: node
+  linkType: hard
+
 "streamx@npm:^2.15.0":
   version: 2.15.6
   resolution: "streamx@npm:2.15.6"
@@ -20088,13 +19668,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-final-newline@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "strip-final-newline@npm:3.0.0"
-  checksum: 23ee263adfa2070cd0f23d1ac14e2ed2f000c9b44229aec9c799f1367ec001478469560abefd00c5c99ee6f0b31c137d53ec6029c53e9f32a93804e18c201050
-  languageName: node
-  linkType: hard
-
 "strip-hex-prefix@npm:1.0.0":
   version: 1.0.0
   resolution: "strip-hex-prefix@npm:1.0.0"
@@ -20222,13 +19795,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"synckit@npm:^0.8.5":
-  version: 0.8.6
-  resolution: "synckit@npm:0.8.6"
+"synckit@npm:^0.8.6":
+  version: 0.8.8
+  resolution: "synckit@npm:0.8.8"
   dependencies:
-    "@pkgr/utils": ^2.4.2
+    "@pkgr/core": ^0.1.0
     tslib: ^2.6.2
-  checksum: 7c1f4991d0afd63c090c0537f1cf8619dd5777a40cf83bf46beadbf4eb0f9e400d92044e90a177a305df4bcb56efbaf1b689877f301f2672d865b6eecf1be75a
+  checksum: 9ed5d33abb785f5f24e2531efd53b2782ca77abf7912f734d170134552b99001915531be5a50297aa45c5701b5c9041e8762e6cd7a38e41e2461c1e7fccdedf8
   languageName: node
   linkType: hard
 
@@ -20275,39 +19848,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tar-fs@npm:2.1.1":
-  version: 2.1.1
-  resolution: "tar-fs@npm:2.1.1"
-  dependencies:
-    chownr: ^1.1.1
-    mkdirp-classic: ^0.5.2
-    pump: ^3.0.0
-    tar-stream: ^2.1.4
-  checksum: f5b9a70059f5b2969e65f037b4e4da2daf0fa762d3d232ffd96e819e3f94665dbbbe62f76f084f1acb4dbdcce16c6e4dac08d12ffc6d24b8d76720f4d9cf032d
-  languageName: node
-  linkType: hard
-
-"tar-fs@npm:3.0.4":
-  version: 3.0.4
-  resolution: "tar-fs@npm:3.0.4"
+"tar-fs@npm:3.0.5":
+  version: 3.0.5
+  resolution: "tar-fs@npm:3.0.5"
   dependencies:
-    mkdirp-classic: ^0.5.2
+    bare-fs: ^2.1.1
+    bare-path: ^2.1.0
     pump: ^3.0.0
     tar-stream: ^3.1.5
-  checksum: dcf4054f9e92ca0efe61c2b3f612914fb259a47900aa908a63106513a6d006c899b426ada53eb88d9dbbf089b5724c8e90b96a2c4ca6171845fa14203d734e30
-  languageName: node
-  linkType: hard
-
-"tar-stream@npm:^2.1.4":
-  version: 2.2.0
-  resolution: "tar-stream@npm:2.2.0"
-  dependencies:
-    bl: ^4.0.3
-    end-of-stream: ^1.4.1
-    fs-constants: ^1.0.0
-    inherits: ^2.0.3
-    readable-stream: ^3.1.1
-  checksum: 699831a8b97666ef50021c767f84924cfee21c142c2eb0e79c63254e140e6408d6d55a065a2992548e72b06de39237ef2b802b99e3ece93ca3904a37622a66f3
+  dependenciesMeta:
+    bare-fs:
+      optional: true
+    bare-path:
+      optional: true
+  checksum: e31c7e3e525fec0afecdec1cac58071809e396187725f2eba442f08a4c5649c8cd6b7ce25982f9a91bb0f055628df47c08177dd2ea4f5dafd3c22f42f8da8f00
   languageName: node
   linkType: hard
 
@@ -20452,13 +20006,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"titleize@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "titleize@npm:3.0.0"
-  checksum: 71fbbeabbfb36ccd840559f67f21e356e1d03da2915b32d2ae1a60ddcc13a124be2739f696d2feb884983441d159a18649e8d956648d591bdad35c430a6b6d28
-  languageName: node
-  linkType: hard
-
 "tmp@npm:0.0.33":
   version: 0.0.33
   resolution: "tmp@npm:0.0.33"
@@ -20861,63 +20408,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:5.1.5":
-  version: 5.1.5
-  resolution: "typescript@npm:5.1.5"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 0eef8699e05ae767096924dbed633c340b4d36e953bb8ed87fb12e9dd9dcea5055ceac7182c614a556dbd346a8a82df799d330e1e286ae66e17c84e1710f6a6f
-  languageName: node
-  linkType: hard
-
-"typescript@npm:^5.0.4, typescript@npm:^5.2.2":
-  version: 5.3.3
-  resolution: "typescript@npm:5.3.3"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 2007ccb6e51bbbf6fde0a78099efe04dc1c3dfbdff04ca3b6a8bc717991862b39fd6126c0c3ebf2d2d98ac5e960bcaa873826bb2bb241f14277034148f41f6a2
-  languageName: node
-  linkType: hard
-
-"typescript@npm:~5.2.2":
-  version: 5.2.2
-  resolution: "typescript@npm:5.2.2"
+"typescript@npm:5.4.2, typescript@npm:^5.4.2":
+  version: 5.4.2
+  resolution: "typescript@npm:5.4.2"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: 7912821dac4d962d315c36800fe387cdc0a6298dba7ec171b350b4a6e988b51d7b8f051317786db1094bd7431d526b648aba7da8236607febb26cf5b871d2d3c
+  checksum: 96d80fde25a09bcb04d399082fb27a808a9e17c2111e43849d2aafbd642d835e4f4ef0de09b0ba795ec2a700be6c4c2c3f62bf4660c05404c948727b5bbfb32a
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@5.1.5#~builtin<compat/typescript>":
-  version: 5.1.5
-  resolution: "typescript@patch:typescript@npm%3A5.1.5#~builtin<compat/typescript>::version=5.1.5&hash=5da071"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 12ff5d14888805f24479e54bc8a3f83647107a6345f6c29dffcd429fb345be55f584a37e262cca58a0105203e41d4cb4e31b1b9096c9abeca0e2ace8eb00935e
-  languageName: node
-  linkType: hard
-
-"typescript@patch:typescript@^5.0.4#~builtin<compat/typescript>, typescript@patch:typescript@^5.2.2#~builtin<compat/typescript>":
-  version: 5.3.3
-  resolution: "typescript@patch:typescript@npm%3A5.3.3#~builtin<compat/typescript>::version=5.3.3&hash=f3b441"
+"typescript@patch:typescript@5.4.2#~builtin<compat/typescript>, typescript@patch:typescript@^5.4.2#~builtin<compat/typescript>":
+  version: 5.4.2
+  resolution: "typescript@patch:typescript@npm%3A5.4.2#~builtin<compat/typescript>::version=5.4.2&hash=f3b441"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: f61375590b3162599f0f0d5b8737877ac0a7bc52761dbb585d67e7b8753a3a4c42d9a554c4cc929f591ffcf3a2b0602f65ae3ce74714fd5652623a816862b610
-  languageName: node
-  linkType: hard
-
-"typescript@patch:typescript@~5.2.2#~builtin<compat/typescript>":
-  version: 5.2.2
-  resolution: "typescript@patch:typescript@npm%3A5.2.2#~builtin<compat/typescript>::version=5.2.2&hash=f3b441"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 0f4da2f15e6f1245e49db15801dbee52f2bbfb267e1c39225afdab5afee1a72839cd86000e65ee9d7e4dfaff12239d28beaf5ee431357fcced15fb08583d72ca
+  checksum: c1b669146bca5529873aae60870e243fa8140c85f57ca32c42f898f586d73ce4a6b4f6bb02ae312729e214d7f5859a0c70da3e527a116fdf5ad00c9fc733ecc6
   languageName: node
   linkType: hard
 
@@ -21283,13 +20790,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"untildify@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "untildify@npm:4.0.0"
-  checksum: 39ced9c418a74f73f0a56e1ba4634b4d959422dff61f4c72a8e39f60b99380c1b45ed776fbaa0a4101b157e4310d873ad7d114e8534ca02609b4916bb4187fb9
-  languageName: node
-  linkType: hard
-
 "unzipit@npm:^1.4.3":
   version: 1.4.3
   resolution: "unzipit@npm:1.4.3"
@@ -21412,6 +20912,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"urlpattern-polyfill@npm:10.0.0":
+  version: 10.0.0
+  resolution: "urlpattern-polyfill@npm:10.0.0"
+  checksum: 61d890f151ea4ecf34a3dcab32c65ad1f3cda857c9d154af198260c6e5b2ad96d024593409baaa6d4428dd1ab206c14799bf37fe011117ac93a6a44913ac5aa4
+  languageName: node
+  linkType: hard
+
 "util-deprecate@npm:^1.0.1, util-deprecate@npm:^1.0.2, util-deprecate@npm:~1.0.1":
   version: 1.0.2
   resolution: "util-deprecate@npm:1.0.2"
@@ -22139,9 +21646,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ws@npm:8.13.0":
-  version: 8.13.0
-  resolution: "ws@npm:8.13.0"
+"ws@npm:8.16.0, ws@npm:^8.16.0":
+  version: 8.16.0
+  resolution: "ws@npm:8.16.0"
   peerDependencies:
     bufferutil: ^4.0.1
     utf-8-validate: ">=5.0.2"
@@ -22150,7 +21657,7 @@ __metadata:
       optional: true
     utf-8-validate:
       optional: true
-  checksum: 53e991bbf928faf5dc6efac9b8eb9ab6497c69feeb94f963d648b7a3530a720b19ec2e0ec037344257e05a4f35bd9ad04d9de6f289615ffb133282031b18c61c
+  checksum: feb3eecd2bae82fa8a8beef800290ce437d8b8063bdc69712725f21aef77c49cb2ff45c6e5e7fce622248f9c7abaee506bae0a9064067ffd6935460c7357321b
   languageName: node
   linkType: hard
 
@@ -22199,21 +21706,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ws@npm:^8.16.0":
-  version: 8.16.0
-  resolution: "ws@npm:8.16.0"
-  peerDependencies:
-    bufferutil: ^4.0.1
-    utf-8-validate: ">=5.0.2"
-  peerDependenciesMeta:
-    bufferutil:
-      optional: true
-    utf-8-validate:
-      optional: true
-  checksum: feb3eecd2bae82fa8a8beef800290ce437d8b8063bdc69712725f21aef77c49cb2ff45c6e5e7fce622248f9c7abaee506bae0a9064067ffd6935460c7357321b
-  languageName: node
-  linkType: hard
-
 "xdg-basedir@npm:^4.0.0":
   version: 4.0.0
   resolution: "xdg-basedir@npm:4.0.0"
@@ -22362,22 +21854,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:17.7.1":
-  version: 17.7.1
-  resolution: "yargs@npm:17.7.1"
-  dependencies:
-    cliui: ^8.0.1
-    escalade: ^3.1.1
-    get-caller-file: ^2.0.5
-    require-directory: ^2.1.1
-    string-width: ^4.2.3
-    y18n: ^5.0.5
-    yargs-parser: ^21.1.1
-  checksum: 3d8a43c336a4942bc68080768664aca85c7bd406f018bad362fd255c41c8f4e650277f42fd65d543fce99e084124ddafee7bbfc1a5c6a8fda4cec78609dcf8d4
-  languageName: node
-  linkType: hard
-
-"yargs@npm:^17.7.1":
+"yargs@npm:17.7.2, yargs@npm:^17.7.1":
   version: 17.7.2
   resolution: "yargs@npm:17.7.2"
   dependencies:

From 30dbe2ea32e05d2d360ccac398621245f42a8484 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 19 Mar 2024 20:22:25 +0000
Subject: [PATCH 097/416] chore: fix docs builds (#4593)

---
 docs/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/package.json b/docs/package.json
index 661a0a0dcab..78560707795 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -3,7 +3,7 @@
   "version": "0.0.0",
   "private": true,
   "scripts": {
-    "preprocess": "./scripts/codegen_nargo_reference.sh && yarn node ./scripts/preprocess/index.js",
+    "preprocess": "yarn workspace @noir-lang/acvm_js build && ./scripts/codegen_nargo_reference.sh && yarn node ./scripts/preprocess/index.js",
     "start": "yarn preprocess && docusaurus start",
     "build": "yarn preprocess && yarn version::stables && docusaurus build",
     "version::stables": "ts-node ./scripts/setStable.ts",

From 9a241f9622b342cd9d56bf8481219cfc374c0510 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Tue, 19 Mar 2024 16:03:29 -0400
Subject: [PATCH 098/416] feat!: separating out array and slice types in the
 AST (#4504)

# Description

Replacement for https://github.com/noir-lang/noir/pull/4232. Holding off
on closing it to possibly port fixes from it, but wanted to start fresh
because this approach is quite different.

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4220

## Summary\*

- Removes `NotConstant`
- Separate syntax for slice literals: `&[..]`
- Separate AST/type constructors for slices

Notes:
- I removed several broken links that were blocking updating the docs:
+ A few were to a missing `reference` docs folder, likely from an
in-progress branch
+ One was to some `base_order_curve`, which has been moved to reference
the `BigInt` struct

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Jake Fecher <jfecher11@gmail.com>
Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  14 +-
 compiler/noirc_frontend/src/ast/expression.rs |  19 +++
 compiler/noirc_frontend/src/ast/mod.rs        |   9 +-
 .../src/hir/resolution/resolver.rs            |  57 +++++---
 .../src/hir/type_check/errors.rs              |   3 +
 .../noirc_frontend/src/hir/type_check/expr.rs | 130 ++++++++++--------
 .../noirc_frontend/src/hir/type_check/stmt.rs |   1 +
 compiler/noirc_frontend/src/hir_def/expr.rs   |   1 +
 compiler/noirc_frontend/src/hir_def/types.rs  | 113 ++++++---------
 .../src/monomorphization/ast.rs               |   1 +
 .../src/monomorphization/debug.rs             |   1 +
 .../src/monomorphization/mod.rs               |  49 ++++---
 .../src/monomorphization/printer.rs           |   5 +
 compiler/noirc_frontend/src/node_interner.rs  |   3 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  87 +++++++++++-
 .../noirc_frontend/src/parser/parser/types.rs |  13 +-
 compiler/noirc_printable_type/src/lib.rs      |  38 +++--
 docs/docs/how_to/merkle-proof.mdx             |   4 +-
 docs/docs/noir/concepts/data_types/arrays.md  |   2 +-
 docs/docs/noir/concepts/data_types/fields.md  |   4 +-
 docs/docs/noir/concepts/data_types/slices.mdx |  31 ++++-
 docs/docs/noir/concepts/functions.md          |   2 +-
 docs/docs/noir/standard_library/bigint.md     |   4 +-
 .../noir/standard_library/containers/vec.mdx  |  12 +-
 .../ecdsa_sig_verification.mdx                |  24 +++-
 .../cryptographic_primitives/hashes.mdx       |  62 ++++++++-
 .../cryptographic_primitives/schnorr.mdx      |  10 ++
 .../noir/standard_library/merkle_trees.md     |   4 +-
 docs/docs/noir/standard_library/recursion.md  |   4 +-
 docs/docs/noir/standard_library/traits.md     |  11 +-
 docs/docs/noir/standard_library/zeroed.md     |   1 +
 noir_stdlib/src/bigint.nr                     |  29 ++--
 noir_stdlib/src/cmp.nr                        |  30 ++++
 noir_stdlib/src/collections/vec.nr            |   2 +-
 noir_stdlib/src/default.nr                    |   6 +
 noir_stdlib/src/ecdsa_secp256k1.nr            |  12 ++
 noir_stdlib/src/ecdsa_secp256r1.nr            |  11 ++
 noir_stdlib/src/hash.nr                       |  90 +++++++++---
 noir_stdlib/src/hash/mimc.nr                  |   2 +-
 noir_stdlib/src/hash/pedersen.nr              |   6 +-
 noir_stdlib/src/hash/poseidon.nr              |   2 +-
 noir_stdlib/src/hash/poseidon2.nr             |   2 +-
 noir_stdlib/src/schnorr.nr                    |  12 ++
 noir_stdlib/src/slice.nr                      |   3 +
 .../compile_success_empty/vectors/src/main.nr |   2 +-
 .../array_to_slice/src/main.nr                |   2 +-
 .../execution_success/bigint/src/main.nr      |   8 +-
 .../brillig_hash_to_field/src/main.nr         |   2 +-
 .../brillig_keccak/src/main.nr                |   2 +-
 .../brillig_schnorr/src/main.nr               |   2 +-
 .../brillig_slices/src/main.nr                |   8 +-
 .../hash_to_field/src/main.nr                 |   2 +-
 .../nested_array_in_slice/src/main.nr         |   2 +-
 .../regression_4202/src/main.nr               |   2 +-
 .../execution_success/schnorr/src/main.nr     |   2 +-
 .../slice_dynamic_index/src/main.nr           |   2 +-
 .../execution_success/slices/src/main.nr      |  35 +++--
 tooling/debugger/tests/debug.rs               |   4 +-
 tooling/nargo/src/artifacts/debug_vars.rs     |  27 +++-
 tooling/nargo_cli/build.rs                    |   4 +-
 tooling/nargo_fmt/src/rewrite/array.rs        |  10 +-
 tooling/nargo_fmt/src/rewrite/expr.rs         |  11 +-
 tooling/nargo_fmt/src/rewrite/typ.rs          |  12 +-
 tooling/noirc_abi/src/lib.rs                  |   2 +-
 64 files changed, 763 insertions(+), 304 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 5acb266b4c1..a39df14d60a 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -199,6 +199,15 @@ impl<'a> FunctionContext<'a> {
                     ast::Type::Array(_, _) => {
                         self.codegen_array_checked(elements, typ[0].clone())?
                     }
+                    _ => unreachable!("ICE: unexpected array literal type, got {}", array.typ),
+                })
+            }
+            ast::Literal::Slice(array) => {
+                let elements =
+                    try_vecmap(&array.contents, |element| self.codegen_expression(element))?;
+
+                let typ = Self::convert_type(&array.typ).flatten();
+                Ok(match array.typ {
                     ast::Type::Slice(_) => {
                         let slice_length =
                             self.builder.length_constant(array.contents.len() as u128);
@@ -206,10 +215,7 @@ impl<'a> FunctionContext<'a> {
                             self.codegen_array_checked(elements, typ[1].clone())?;
                         Tree::Branch(vec![slice_length.into(), slice_contents])
                     }
-                    _ => unreachable!(
-                        "ICE: array literal type must be an array or a slice, but got {}",
-                        array.typ
-                    ),
+                    _ => unreachable!("ICE: unexpected slice literal type, got {}", array.typ),
                 })
             }
             ast::Literal::Integer(value, typ, location) => {
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index a9ecc1a53e5..09c09daf9b9 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -70,6 +70,17 @@ impl ExpressionKind {
         }))
     }
 
+    pub fn slice(contents: Vec<Expression>) -> ExpressionKind {
+        ExpressionKind::Literal(Literal::Slice(ArrayLiteral::Standard(contents)))
+    }
+
+    pub fn repeated_slice(repeated_element: Expression, length: Expression) -> ExpressionKind {
+        ExpressionKind::Literal(Literal::Slice(ArrayLiteral::Repeated {
+            repeated_element: Box::new(repeated_element),
+            length: Box::new(length),
+        }))
+    }
+
     pub fn integer(contents: FieldElement) -> ExpressionKind {
         ExpressionKind::Literal(Literal::Integer(contents, false))
     }
@@ -319,6 +330,7 @@ impl UnaryOp {
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum Literal {
     Array(ArrayLiteral),
+    Slice(ArrayLiteral),
     Bool(bool),
     Integer(FieldElement, /*sign*/ bool), // false for positive integer and true for negative
     Str(String),
@@ -498,6 +510,13 @@ impl Display for Literal {
             Literal::Array(ArrayLiteral::Repeated { repeated_element, length }) => {
                 write!(f, "[{repeated_element}; {length}]")
             }
+            Literal::Slice(ArrayLiteral::Standard(elements)) => {
+                let contents = vecmap(elements, ToString::to_string);
+                write!(f, "&[{}]", contents.join(", "))
+            }
+            Literal::Slice(ArrayLiteral::Repeated { repeated_element, length }) => {
+                write!(f, "&[{repeated_element}; {length}]")
+            }
             Literal::Bool(boolean) => write!(f, "{}", if *boolean { "true" } else { "false" }),
             Literal::Integer(integer, sign) => {
                 if *sign {
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 8a420c32fb8..4547dc2a176 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -83,7 +83,8 @@ impl core::fmt::Display for IntegerBitSize {
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum UnresolvedTypeData {
     FieldElement,
-    Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>), // [4]Witness = Array(4, Witness)
+    Array(UnresolvedTypeExpression, Box<UnresolvedType>), // [Field; 4] = Array(4, Field)
+    Slice(Box<UnresolvedType>),
     Integer(Signedness, IntegerBitSize), // u32 = Integer(unsigned, ThirtyTwo)
     Bool,
     Expression(UnresolvedTypeExpression),
@@ -151,10 +152,8 @@ impl std::fmt::Display for UnresolvedTypeData {
         use UnresolvedTypeData::*;
         match self {
             FieldElement => write!(f, "Field"),
-            Array(len, typ) => match len {
-                None => write!(f, "[{typ}]"),
-                Some(len) => write!(f, "[{typ}; {len}]"),
-            },
+            Array(len, typ) => write!(f, "[{typ}; {len}]"),
+            Slice(typ) => write!(f, "[{typ}]"),
             Integer(sign, num_bits) => match sign {
                 Signedness::Signed => write!(f, "i{num_bits}"),
                 Signedness::Unsigned => write!(f, "u{num_bits}"),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 90716bb958d..c6606386f7b 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -481,13 +481,13 @@ impl<'a> Resolver<'a> {
             FieldElement => Type::FieldElement,
             Array(size, elem) => {
                 let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
-                let size = if size.is_none() {
-                    Type::NotConstant
-                } else {
-                    self.resolve_array_size(size, new_variables)
-                };
+                let size = self.resolve_array_size(Some(size), new_variables);
                 Type::Array(Box::new(size), elem)
             }
+            Slice(elem) => {
+                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
+                Type::Slice(elem)
+            }
             Expression(expr) => self.convert_expression_type(expr),
             Integer(sign, bits) => Type::Integer(sign, bits),
             Bool => Type::Bool,
@@ -1084,7 +1084,6 @@ impl<'a> Resolver<'a> {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::NotConstant
             | Type::TraitAsType(..)
             | Type::Forall(_, _) => (),
 
@@ -1095,6 +1094,10 @@ impl<'a> Resolver<'a> {
                 Self::find_numeric_generics_in_type(element_type, found);
             }
 
+            Type::Slice(element_type) => {
+                Self::find_numeric_generics_in_type(element_type, found);
+            }
+
             Type::Tuple(fields) => {
                 for field in fields {
                     Self::find_numeric_generics_in_type(field, found);
@@ -1402,27 +1405,37 @@ impl<'a> Resolver<'a> {
         }
     }
 
+    fn resolve_array_literal(&mut self, array_literal: ArrayLiteral) -> HirArrayLiteral {
+        match array_literal {
+            ArrayLiteral::Standard(elements) => {
+                let elements = vecmap(elements, |elem| self.resolve_expression(elem));
+                HirArrayLiteral::Standard(elements)
+            }
+            ArrayLiteral::Repeated { repeated_element, length } => {
+                let span = length.span;
+                let length =
+                    UnresolvedTypeExpression::from_expr(*length, span).unwrap_or_else(|error| {
+                        self.errors.push(ResolverError::ParserError(Box::new(error)));
+                        UnresolvedTypeExpression::Constant(0, span)
+                    });
+
+                let length = self.convert_expression_type(length);
+                let repeated_element = self.resolve_expression(*repeated_element);
+
+                HirArrayLiteral::Repeated { repeated_element, length }
+            }
+        }
+    }
+
     pub fn resolve_expression(&mut self, expr: Expression) -> ExprId {
         let hir_expr = match expr.kind {
             ExpressionKind::Literal(literal) => HirExpression::Literal(match literal {
                 Literal::Bool(b) => HirLiteral::Bool(b),
-                Literal::Array(ArrayLiteral::Standard(elements)) => {
-                    let elements = vecmap(elements, |elem| self.resolve_expression(elem));
-                    HirLiteral::Array(HirArrayLiteral::Standard(elements))
+                Literal::Array(array_literal) => {
+                    HirLiteral::Array(self.resolve_array_literal(array_literal))
                 }
-                Literal::Array(ArrayLiteral::Repeated { repeated_element, length }) => {
-                    let span = length.span;
-                    let length = UnresolvedTypeExpression::from_expr(*length, span).unwrap_or_else(
-                        |error| {
-                            self.errors.push(ResolverError::ParserError(Box::new(error)));
-                            UnresolvedTypeExpression::Constant(0, span)
-                        },
-                    );
-
-                    let length = self.convert_expression_type(length);
-                    let repeated_element = self.resolve_expression(*repeated_element);
-
-                    HirLiteral::Array(HirArrayLiteral::Repeated { repeated_element, length })
+                Literal::Slice(array_literal) => {
+                    HirLiteral::Slice(self.resolve_array_literal(array_literal))
                 }
                 Literal::Integer(integer, sign) => HirLiteral::Integer(integer, sign),
                 Literal::Str(str) => HirLiteral::Str(str),
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 3d834128688..4e2a3a8b4a2 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -128,6 +128,8 @@ pub enum TypeCheckError {
     UnconstrainedReferenceToConstrained { span: Span },
     #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
     UnconstrainedSliceReturnToConstrained { span: Span },
+    #[error("Slices must have constant length")]
+    NonConstantSliceLength { span: Span },
     #[error("Only sized types may be used in the entry point to a program")]
     InvalidTypeForEntryPoint { span: Span },
     #[error("Mismatched number of parameters in trait implementation")]
@@ -233,6 +235,7 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::OverflowingAssignment { span, .. }
             | TypeCheckError::FieldModulo { span }
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
+            | TypeCheckError::NonConstantSliceLength { span }
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
             | TypeCheckError::UnconstrainedSliceReturnToConstrained { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 0b3dd022209..eb998b59755 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -48,6 +48,49 @@ impl<'interner> TypeChecker<'interner> {
         false
     }
 
+    fn check_hir_array_literal(
+        &mut self,
+        hir_array_literal: HirArrayLiteral,
+    ) -> (Result<u64, Box<Type>>, Box<Type>) {
+        match hir_array_literal {
+            HirArrayLiteral::Standard(arr) => {
+                let elem_types = vecmap(&arr, |arg| self.check_expression(arg));
+
+                let first_elem_type = elem_types
+                    .first()
+                    .cloned()
+                    .unwrap_or_else(|| self.interner.next_type_variable());
+
+                // Check if the array is homogeneous
+                for (index, elem_type) in elem_types.iter().enumerate().skip(1) {
+                    let location = self.interner.expr_location(&arr[index]);
+
+                    elem_type.unify(&first_elem_type, &mut self.errors, || {
+                        TypeCheckError::NonHomogeneousArray {
+                            first_span: self.interner.expr_location(&arr[0]).span,
+                            first_type: first_elem_type.to_string(),
+                            first_index: index,
+                            second_span: location.span,
+                            second_type: elem_type.to_string(),
+                            second_index: index + 1,
+                        }
+                        .add_context("elements in an array must have the same type")
+                    });
+                }
+
+                (Ok(arr.len() as u64), Box::new(first_elem_type.clone()))
+            }
+            HirArrayLiteral::Repeated { repeated_element, length } => {
+                let elem_type = self.check_expression(&repeated_element);
+                let length = match length {
+                    Type::Constant(length) => Ok(length),
+                    other => Err(Box::new(other)),
+                };
+                (length, Box::new(elem_type))
+            }
+        }
+    }
+
     /// Infers a type for a given expression, and return this type.
     /// As a side-effect, this function will also remember this type in the NodeInterner
     /// for the given expr_id key.
@@ -59,64 +102,42 @@ impl<'interner> TypeChecker<'interner> {
     pub(crate) fn check_expression(&mut self, expr_id: &ExprId) -> Type {
         let typ = match self.interner.expression(expr_id) {
             HirExpression::Ident(ident) => self.check_ident(ident, expr_id),
-            HirExpression::Literal(literal) => {
-                match literal {
-                    HirLiteral::Array(HirArrayLiteral::Standard(arr)) => {
-                        let elem_types = vecmap(&arr, |arg| self.check_expression(arg));
-
-                        let first_elem_type = elem_types
-                            .first()
-                            .cloned()
-                            .unwrap_or_else(|| self.interner.next_type_variable());
-
-                        let arr_type = Type::Array(
-                            Box::new(Type::constant_variable(arr.len() as u64, self.interner)),
-                            Box::new(first_elem_type.clone()),
-                        );
-
-                        // Check if the array is homogeneous
-                        for (index, elem_type) in elem_types.iter().enumerate().skip(1) {
-                            let location = self.interner.expr_location(&arr[index]);
-
-                            elem_type.unify(&first_elem_type, &mut self.errors, || {
-                                TypeCheckError::NonHomogeneousArray {
-                                    first_span: self.interner.expr_location(&arr[0]).span,
-                                    first_type: first_elem_type.to_string(),
-                                    first_index: index,
-                                    second_span: location.span,
-                                    second_type: elem_type.to_string(),
-                                    second_index: index + 1,
-                                }
-                                .add_context("elements in an array must have the same type")
+            HirExpression::Literal(literal) => match literal {
+                HirLiteral::Array(hir_array_literal) => {
+                    let (length, elem_type) = self.check_hir_array_literal(hir_array_literal);
+                    Type::Array(
+                        length.map_or_else(
+                            |typ| typ,
+                            |constant| Box::new(Type::constant_variable(constant, self.interner)),
+                        ),
+                        elem_type,
+                    )
+                }
+                HirLiteral::Slice(hir_array_literal) => {
+                    let (length_type, elem_type) = self.check_hir_array_literal(hir_array_literal);
+                    match length_type {
+                        Ok(_length) => Type::Slice(elem_type),
+                        Err(_non_constant) => {
+                            self.errors.push(TypeCheckError::NonConstantSliceLength {
+                                span: self.interner.expr_span(expr_id),
                             });
+                            Type::Error
                         }
-
-                        arr_type
-                    }
-                    HirLiteral::Array(HirArrayLiteral::Repeated { repeated_element, length }) => {
-                        let elem_type = self.check_expression(&repeated_element);
-                        let length = match length {
-                            Type::Constant(length) => {
-                                Type::constant_variable(length, self.interner)
-                            }
-                            other => other,
-                        };
-                        Type::Array(Box::new(length), Box::new(elem_type))
                     }
-                    HirLiteral::Bool(_) => Type::Bool,
-                    HirLiteral::Integer(_, _) => Type::polymorphic_integer_or_field(self.interner),
-                    HirLiteral::Str(string) => {
-                        let len = Type::Constant(string.len() as u64);
-                        Type::String(Box::new(len))
-                    }
-                    HirLiteral::FmtStr(string, idents) => {
-                        let len = Type::Constant(string.len() as u64);
-                        let types = vecmap(&idents, |elem| self.check_expression(elem));
-                        Type::FmtString(Box::new(len), Box::new(Type::Tuple(types)))
-                    }
-                    HirLiteral::Unit => Type::Unit,
                 }
-            }
+                HirLiteral::Bool(_) => Type::Bool,
+                HirLiteral::Integer(_, _) => Type::polymorphic_integer_or_field(self.interner),
+                HirLiteral::Str(string) => {
+                    let len = Type::Constant(string.len() as u64);
+                    Type::String(Box::new(len))
+                }
+                HirLiteral::FmtStr(string, idents) => {
+                    let len = Type::Constant(string.len() as u64);
+                    let types = vecmap(&idents, |elem| self.check_expression(elem));
+                    Type::FmtString(Box::new(len), Box::new(Type::Tuple(types)))
+                }
+                HirLiteral::Unit => Type::Unit,
+            },
             HirExpression::Infix(infix_expr) => {
                 // The type of the infix expression must be looked up from a type table
                 let lhs_type = self.check_expression(&infix_expr.lhs);
@@ -557,6 +578,7 @@ impl<'interner> TypeChecker<'interner> {
             // XXX: We can check the array bounds here also, but it may be better to constant fold first
             // and have ConstId instead of ExprId for constants
             Type::Array(_, base_type) => *base_type,
+            Type::Slice(base_type) => *base_type,
             Type::Error => Type::Error,
             typ => {
                 let span = self.interner.expr_span(&new_lhs);
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index e90da555803..49ba3244dc9 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -256,6 +256,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 let typ = match lvalue_type.follow_bindings() {
                     Type::Array(_, elem_type) => *elem_type,
+                    Type::Slice(elem_type) => *elem_type,
                     Type::Error => Type::Error,
                     other => {
                         // TODO: Need a better span here
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index b4c590de491..6a1b4385f0d 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -99,6 +99,7 @@ impl HirBinaryOp {
 #[derive(Debug, Clone)]
 pub enum HirLiteral {
     Array(HirArrayLiteral),
+    Slice(HirArrayLiteral),
     Bool(bool),
     Integer(FieldElement, bool), //true for negative integer and false for positive
     Str(String),
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 60bc5b2470f..7fb26aa3879 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -27,6 +27,9 @@ pub enum Type {
     /// is either a type variable of some kind or a Type::Constant.
     Array(Box<Type>, Box<Type>),
 
+    /// Slice(E) is a slice of elements of type E.
+    Slice(Box<Type>),
+
     /// A primitive integer type with the given sign and bit count.
     /// E.g. `u32` would be `Integer(Unsigned, ThirtyTwo)`
     Integer(Signedness, IntegerBitSize),
@@ -98,11 +101,6 @@ pub enum Type {
     /// bind to an integer without special checks to bind it to a non-type.
     Constant(u64),
 
-    /// The type of a slice is an array of size NotConstant.
-    /// The size of an array literal is resolved to this if it ever uses operations
-    /// involving slices.
-    NotConstant,
-
     /// The result of some type error. Remembering type errors as their own type variant lets
     /// us avoid issuing repeat type errors for the same item. For example, a lambda with
     /// an invalid type would otherwise issue a new error each time it is called
@@ -146,27 +144,23 @@ impl Type {
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Constant(_)
-            | Type::NotConstant
+            | Type::Slice(_)
             | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
         }
     }
 
     pub(crate) fn is_nested_slice(&self) -> bool {
         match self {
-            Type::Array(size, elem) => {
-                if let Type::NotConstant = size.as_ref() {
-                    elem.as_ref().contains_slice()
-                } else {
-                    false
-                }
-            }
+            Type::Slice(elem) => elem.as_ref().contains_slice(),
+            Type::Array(_, elem) => elem.as_ref().contains_slice(),
+            Type::Alias(alias, generics) => alias.borrow().get_type(generics).is_nested_slice(),
             _ => false,
         }
     }
 
     pub(crate) fn contains_slice(&self) -> bool {
         match self {
-            Type::Array(size, _) => matches!(size.as_ref(), Type::NotConstant),
+            Type::Slice(_) => true,
             Type::Struct(struct_typ, generics) => {
                 let fields = struct_typ.borrow().get_fields(generics);
                 for field in fields.iter() {
@@ -453,7 +447,7 @@ pub enum TypeVariableKind {
     /// that can only be bound to Type::Integer, or other polymorphic integers.
     Integer,
 
-    /// A potentially constant array size. This will only bind to itself, Type::NotConstant, or
+    /// A potentially constant array size. This will only bind to itself or
     /// Type::Constant(n) with a matching size. This defaults to Type::Constant(n) if still unbound
     /// during monomorphization.
     Constant(u64),
@@ -631,14 +625,13 @@ impl Type {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::NotConstant
             | Type::Forall(_, _)
             | Type::TraitAsType(..) => false,
 
             Type::Array(length, elem) => {
                 elem.contains_numeric_typevar(target_id) || named_generic_id_matches_target(length)
             }
-
+            Type::Slice(elem) => elem.contains_numeric_typevar(target_id),
             Type::Tuple(fields) => {
                 fields.iter().any(|field| field.contains_numeric_typevar(target_id))
             }
@@ -696,8 +689,8 @@ impl Type {
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
-            | Type::TraitAsType(..)
-            | Type::NotConstant => false,
+            | Type::Slice(_)
+            | Type::TraitAsType(..) => false,
 
             Type::Alias(alias, generics) => {
                 let alias = alias.borrow();
@@ -766,11 +759,10 @@ impl std::fmt::Display for Type {
                 write!(f, "Field")
             }
             Type::Array(len, typ) => {
-                if matches!(len.follow_bindings(), Type::NotConstant) {
-                    write!(f, "[{typ}]")
-                } else {
-                    write!(f, "[{typ}; {len}]")
-                }
+                write!(f, "[{typ}; {len}]")
+            }
+            Type::Slice(typ) => {
+                write!(f, "[{typ}]")
             }
             Type::Integer(sign, num_bits) => match sign {
                 Signedness::Signed => write!(f, "i{num_bits}"),
@@ -860,7 +852,6 @@ impl std::fmt::Display for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element}")
             }
-            Type::NotConstant => write!(f, "_"),
         }
     }
 }
@@ -916,10 +907,6 @@ impl Type {
                 bindings.insert(target_id, (var.clone(), this));
                 Ok(())
             }
-            Type::NotConstant => {
-                bindings.insert(target_id, (var.clone(), Type::NotConstant));
-                Ok(())
-            }
             // A TypeVariable is less specific than a MaybeConstant, so we bind
             // to the other type variable instead.
             Type::TypeVariable(new_var, kind) => {
@@ -947,14 +934,8 @@ impl Type {
                             bindings.insert(*new_target_id, (new_var.clone(), clone));
                             Ok(())
                         }
-                        // The lengths don't match, but neither are set in stone so we can
-                        // just set them both to NotConstant. See issue 2370
-                        TypeVariableKind::Constant(_) => {
-                            // *length != target_length
-                            bindings.insert(target_id, (var.clone(), Type::NotConstant));
-                            bindings.insert(*new_target_id, (new_var.clone(), Type::NotConstant));
-                            Ok(())
-                        }
+                        // *length != target_length
+                        TypeVariableKind::Constant(_) => Err(UnificationError),
                         TypeVariableKind::IntegerOrField => Err(UnificationError),
                         TypeVariableKind::Integer => Err(UnificationError),
                     },
@@ -1164,6 +1145,8 @@ impl Type {
                 elem_a.try_unify(elem_b, bindings)
             }
 
+            (Slice(elem_a), Slice(elem_b)) => elem_a.try_unify(elem_b, bindings),
+
             (String(len_a), String(len_b)) => len_a.try_unify(len_b, bindings),
 
             (FmtString(len_a, elements_a), FmtString(len_b, elements_b)) => {
@@ -1308,20 +1291,14 @@ impl Type {
         let this = self.follow_bindings();
         let target = target.follow_bindings();
 
-        if let (Type::Array(size1, element1), Type::Array(size2, element2)) = (&this, &target) {
-            let size1 = size1.follow_bindings();
-            let size2 = size2.follow_bindings();
-
-            // If we have an array and our target is a slice
-            if matches!(size1, Type::Constant(_)) && matches!(size2, Type::NotConstant) {
-                // Still have to ensure the element types match.
-                // Don't need to issue an error here if not, it will be done in unify_with_coercions
-                let mut bindings = TypeBindings::new();
-                if element1.try_unify(element2, &mut bindings).is_ok() {
-                    convert_array_expression_to_slice(expression, this, target, interner);
-                    Self::apply_type_bindings(bindings);
-                    return true;
-                }
+        if let (Type::Array(_size, element1), Type::Slice(element2)) = (&this, &target) {
+            // Still have to ensure the element types match.
+            // Don't need to issue an error here if not, it will be done in unify_with_coercions
+            let mut bindings = TypeBindings::new();
+            if element1.try_unify(element2, &mut bindings).is_ok() {
+                convert_array_expression_to_slice(expression, this, target, interner);
+                Self::apply_type_bindings(bindings);
+                return true;
             }
         }
         false
@@ -1489,6 +1466,10 @@ impl Type {
                 let element = element.substitute_helper(type_bindings, substitute_bound_typevars);
                 Type::Array(Box::new(size), Box::new(element))
             }
+            Type::Slice(element) => {
+                let element = element.substitute_helper(type_bindings, substitute_bound_typevars);
+                Type::Slice(Box::new(element))
+            }
             Type::String(size) => {
                 let size = size.substitute_helper(type_bindings, substitute_bound_typevars);
                 Type::String(Box::new(size))
@@ -1548,7 +1529,6 @@ impl Type {
             | Type::Constant(_)
             | Type::TraitAsType(..)
             | Type::Error
-            | Type::NotConstant
             | Type::Unit => self.clone(),
         }
     }
@@ -1557,6 +1537,7 @@ impl Type {
     pub fn occurs(&self, target_id: TypeVariableId) -> bool {
         match self {
             Type::Array(len, elem) => len.occurs(target_id) || elem.occurs(target_id),
+            Type::Slice(elem) => elem.occurs(target_id),
             Type::String(len) => len.occurs(target_id),
             Type::FmtString(len, fields) => {
                 let len_occurs = len.occurs(target_id);
@@ -1589,7 +1570,6 @@ impl Type {
             | Type::Constant(_)
             | Type::TraitAsType(..)
             | Type::Error
-            | Type::NotConstant
             | Type::Unit => false,
         }
     }
@@ -1606,6 +1586,7 @@ impl Type {
             Array(size, elem) => {
                 Array(Box::new(size.follow_bindings()), Box::new(elem.follow_bindings()))
             }
+            Slice(elem) => Slice(Box::new(elem.follow_bindings())),
             String(size) => String(Box::new(size.follow_bindings())),
             FmtString(size, args) => {
                 let size = Box::new(size.follow_bindings());
@@ -1640,14 +1621,9 @@ impl Type {
 
             // Expect that this function should only be called on instantiated types
             Forall(..) => unreachable!(),
-            TraitAsType(..)
-            | FieldElement
-            | Integer(_, _)
-            | Bool
-            | Constant(_)
-            | Unit
-            | Error
-            | NotConstant => self.clone(),
+            TraitAsType(..) | FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Error => {
+                self.clone()
+            }
         }
     }
 
@@ -1727,6 +1703,10 @@ impl From<&Type> for PrintableType {
                 let typ = typ.as_ref();
                 PrintableType::Array { length, typ: Box::new(typ.into()) }
             }
+            Type::Slice(typ) => {
+                let typ = typ.as_ref();
+                PrintableType::Slice { typ: Box::new(typ.into()) }
+            }
             Type::Integer(sign, bit_width) => match sign {
                 Signedness::Unsigned => {
                     PrintableType::UnsignedInteger { width: (*bit_width).into() }
@@ -1772,7 +1752,6 @@ impl From<&Type> for PrintableType {
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
             }
-            Type::NotConstant => unreachable!(),
         }
     }
 }
@@ -1784,11 +1763,10 @@ impl std::fmt::Debug for Type {
                 write!(f, "Field")
             }
             Type::Array(len, typ) => {
-                if matches!(len.follow_bindings(), Type::NotConstant) {
-                    write!(f, "[{typ:?}]")
-                } else {
-                    write!(f, "[{typ:?}; {len:?}]")
-                }
+                write!(f, "[{typ:?}; {len:?}]")
+            }
+            Type::Slice(typ) => {
+                write!(f, "[{typ:?}]")
             }
             Type::Integer(sign, num_bits) => match sign {
                 Signedness::Signed => write!(f, "i{num_bits}"),
@@ -1858,7 +1836,6 @@ impl std::fmt::Debug for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element:?}")
             }
-            Type::NotConstant => write!(f, "NotConstant"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 21b77127360..4f633cbb350 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -89,6 +89,7 @@ pub struct For {
 #[derive(Debug, Clone, Hash)]
 pub enum Literal {
     Array(ArrayLiteral),
+    Slice(ArrayLiteral),
     Integer(FieldElement, Type, Location),
     Bool(bool),
     Str(String),
diff --git a/compiler/noirc_frontend/src/monomorphization/debug.rs b/compiler/noirc_frontend/src/monomorphization/debug.rs
index 3a03177f8ec..88943be727f 100644
--- a/compiler/noirc_frontend/src/monomorphization/debug.rs
+++ b/compiler/noirc_frontend/src/monomorphization/debug.rs
@@ -192,6 +192,7 @@ impl<'interner> Monomorphizer<'interner> {
 fn element_type_at_index(ptype: &PrintableType, i: usize) -> &PrintableType {
     match ptype {
         PrintableType::Array { length: _length, typ } => typ.as_ref(),
+        PrintableType::Slice { typ } => typ.as_ref(),
         PrintableType::Tuple { types } => &types[i],
         PrintableType::Struct { name: _name, fields } => &fields[i].1,
         PrintableType::String { length: _length } => &PrintableType::UnsignedInteger { width: 8 },
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index a99a4e61d4d..d4fe2e0a2aa 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -418,9 +418,15 @@ impl<'interner> Monomorphizer<'interner> {
                 }
             }
             HirExpression::Literal(HirLiteral::Array(array)) => match array {
-                HirArrayLiteral::Standard(array) => self.standard_array(expr, array)?,
+                HirArrayLiteral::Standard(array) => self.standard_array(expr, array, false)?,
                 HirArrayLiteral::Repeated { repeated_element, length } => {
-                    self.repeated_array(expr, repeated_element, length)?
+                    self.repeated_array(expr, repeated_element, length, false)?
+                }
+            },
+            HirExpression::Literal(HirLiteral::Slice(array)) => match array {
+                HirArrayLiteral::Standard(array) => self.standard_array(expr, array, true)?,
+                HirArrayLiteral::Repeated { repeated_element, length } => {
+                    self.repeated_array(expr, repeated_element, length, true)?
                 }
             },
             HirExpression::Literal(HirLiteral::Unit) => ast::Expression::Block(vec![]),
@@ -519,10 +525,15 @@ impl<'interner> Monomorphizer<'interner> {
         &mut self,
         array: node_interner::ExprId,
         array_elements: Vec<node_interner::ExprId>,
+        is_slice: bool,
     ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.convert_type(&self.interner.id_type(array));
         let contents = try_vecmap(array_elements, |id| self.expr(id))?;
-        Ok(ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })))
+        if is_slice {
+            Ok(ast::Expression::Literal(ast::Literal::Slice(ast::ArrayLiteral { contents, typ })))
+        } else {
+            Ok(ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })))
+        }
     }
 
     fn repeated_array(
@@ -530,6 +541,7 @@ impl<'interner> Monomorphizer<'interner> {
         array: node_interner::ExprId,
         repeated_element: node_interner::ExprId,
         length: HirType,
+        is_slice: bool,
     ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.convert_type(&self.interner.id_type(array));
 
@@ -539,7 +551,11 @@ impl<'interner> Monomorphizer<'interner> {
         })?;
 
         let contents = try_vecmap(0..length, |_| self.expr(repeated_element))?;
-        Ok(ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })))
+        if is_slice {
+            Ok(ast::Expression::Literal(ast::Literal::Slice(ast::ArrayLiteral { contents, typ })))
+        } else {
+            Ok(ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })))
+        }
     }
 
     fn index(
@@ -854,12 +870,13 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::Unit => ast::Type::Unit,
             HirType::Array(length, element) => {
                 let element = Box::new(self.convert_type(element.as_ref()));
-
-                if let Some(length) = length.evaluate_to_u64() {
-                    ast::Type::Array(length, element)
-                } else {
-                    ast::Type::Slice(element)
-                }
+                // TODO: convert to MonomorphizationError
+                let length = length.evaluate_to_u64().unwrap_or(0);
+                ast::Type::Array(length, element)
+            }
+            HirType::Slice(element) => {
+                let element = Box::new(self.convert_type(element.as_ref()));
+                ast::Type::Slice(element)
             }
             HirType::TraitAsType(..) => {
                 unreachable!("All TraitAsType should be replaced before calling convert_type");
@@ -934,10 +951,7 @@ impl<'interner> Monomorphizer<'interner> {
                 ast::Type::MutableReference(Box::new(element))
             }
 
-            HirType::Forall(_, _)
-            | HirType::Constant(_)
-            | HirType::NotConstant
-            | HirType::Error => {
+            HirType::Forall(_, _) | HirType::Constant(_) | HirType::Error => {
                 unreachable!("Unexpected type {} found", typ)
             }
         }
@@ -1152,11 +1166,7 @@ impl<'interner> Monomorphizer<'interner> {
     fn append_printable_type_info_inner(typ: &Type, arguments: &mut Vec<ast::Expression>) {
         // Disallow printing slices and mutable references for consistency,
         // since they cannot be passed from ACIR into Brillig
-        if let HirType::Array(size, _) = typ {
-            if let HirType::NotConstant = **size {
-                unreachable!("println and format strings do not support slices. Convert the slice to an array before passing it to println");
-            }
-        } else if matches!(typ, HirType::MutableReference(_)) {
+        if matches!(typ, HirType::MutableReference(_)) {
             unreachable!("println and format strings do not support mutable references.");
         }
 
@@ -1224,6 +1234,7 @@ impl<'interner> Monomorphizer<'interner> {
         location: Location,
     ) -> ast::Expression {
         use ast::*;
+
         let int_type = Type::Integer(crate::Signedness::Unsigned, arr_elem_bits);
 
         let bytes_as_expr = vecmap(bytes, |byte| {
diff --git a/compiler/noirc_frontend/src/monomorphization/printer.rs b/compiler/noirc_frontend/src/monomorphization/printer.rs
index c3e34890ce0..c253bfe7930 100644
--- a/compiler/noirc_frontend/src/monomorphization/printer.rs
+++ b/compiler/noirc_frontend/src/monomorphization/printer.rs
@@ -97,6 +97,11 @@ impl AstPrinter {
                 self.print_comma_separated(&array.contents, f)?;
                 write!(f, "]")
             }
+            super::ast::Literal::Slice(array) => {
+                write!(f, "&[")?;
+                self.print_comma_separated(&array.contents, f)?;
+                write!(f, "]")
+            }
             super::ast::Literal::Integer(x, _, _) => x.fmt(f),
             super::ast::Literal::Bool(x) => x.fmt(f),
             super::ast::Literal::Str(s) => s.fmt(f),
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index b83d2008530..4e184e1391b 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1664,6 +1664,7 @@ enum TypeMethodKey {
     /// accept only fields or integers, it is just that their names may not clash.
     FieldOrInt,
     Array,
+    Slice,
     Bool,
     String,
     FmtString,
@@ -1679,6 +1680,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
     match &typ {
         Type::FieldElement => Some(FieldOrInt),
         Type::Array(_, _) => Some(Array),
+        Type::Slice(_) => Some(Slice),
         Type::Integer(_, _) => Some(FieldOrInt),
         Type::TypeVariable(_, TypeVariableKind::IntegerOrField) => Some(FieldOrInt),
         Type::TypeVariable(_, TypeVariableKind::Integer) => Some(FieldOrInt),
@@ -1697,7 +1699,6 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         | Type::Forall(_, _)
         | Type::Constant(_)
         | Type::Error
-        | Type::NotConstant
         | Type::Struct(_, _)
         | Type::TraitAsType(..) => None,
     }
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index b2d9d7e6802..f2e22da3c2c 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -575,6 +575,7 @@ fn parse_type_inner(
         format_string_type(recursive_type_parser.clone()),
         named_type(recursive_type_parser.clone()),
         named_trait(recursive_type_parser.clone()),
+        slice_type(recursive_type_parser.clone()),
         array_type(recursive_type_parser.clone()),
         parenthesized_type(recursive_type_parser.clone()),
         tuple_type(recursive_type_parser.clone()),
@@ -711,13 +712,22 @@ fn generic_type_args(
 fn array_type(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
     just(Token::LeftBracket)
         .ignore_then(type_parser)
-        .then(just(Token::Semicolon).ignore_then(type_expression()).or_not())
+        .then(just(Token::Semicolon).ignore_then(type_expression()))
         .then_ignore(just(Token::RightBracket))
         .map_with_span(|(element_type, size), span| {
             UnresolvedTypeData::Array(size, Box::new(element_type)).with_span(span)
         })
 }
 
+fn slice_type(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
+    just(Token::LeftBracket)
+        .ignore_then(type_parser)
+        .then_ignore(just(Token::RightBracket))
+        .map_with_span(|element_type, span| {
+            UnresolvedTypeData::Slice(Box::new(element_type)).with_span(span)
+        })
+}
+
 fn type_expression() -> impl NoirParser<UnresolvedTypeExpression> {
     recursive(|expr| {
         expression_with_precedence(
@@ -1079,6 +1089,36 @@ where
         .map(|(lhs, count)| ExpressionKind::repeated_array(lhs, count))
 }
 
+fn slice_expr<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    just(Token::Ampersand)
+        .ignore_then(standard_slice(expr_parser.clone()).or(slice_sugar(expr_parser)))
+}
+
+/// &[a, b, c, ...]
+fn standard_slice<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    expression_list(expr_parser)
+        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
+        .validate(|elements, _span, _emit| ExpressionKind::slice(elements))
+}
+
+/// &[a; N]
+fn slice_sugar<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
+where
+    P: ExprParser,
+{
+    expr_parser
+        .clone()
+        .then(just(Token::Semicolon).ignore_then(expr_parser))
+        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
+        .map(|(lhs, count)| ExpressionKind::repeated_slice(lhs, count))
+}
+
 fn expression_list<P>(expr_parser: P) -> impl NoirParser<Vec<Expression>>
 where
     P: ExprParser,
@@ -1102,6 +1142,7 @@ where
 {
     choice((
         if_expr(expr_no_constructors, statement.clone()),
+        slice_expr(expr_parser.clone()),
         array_expr(expr_parser.clone()),
         if allow_constructors {
             constructor(expr_parser.clone()).boxed()
@@ -1293,6 +1334,50 @@ mod test {
         parse_all_failing(array_expr(expression()), invalid);
     }
 
+    fn expr_to_slice(expr: ExpressionKind) -> ArrayLiteral {
+        let lit = match expr {
+            ExpressionKind::Literal(literal) => literal,
+            _ => unreachable!("expected a literal"),
+        };
+
+        match lit {
+            Literal::Slice(arr) => arr,
+            _ => unreachable!("expected a slice: {:?}", lit),
+        }
+    }
+
+    #[test]
+    fn parse_slice() {
+        let valid = vec![
+            "&[0, 1, 2,3, 4]",
+            "&[0,1,2,3,4,]", // Trailing commas are valid syntax
+            "&[0;5]",
+        ];
+
+        for expr in parse_all(slice_expr(expression()), valid) {
+            match expr_to_slice(expr) {
+                ArrayLiteral::Standard(elements) => assert_eq!(elements.len(), 5),
+                ArrayLiteral::Repeated { length, .. } => {
+                    assert_eq!(length.kind, ExpressionKind::integer(5i128.into()));
+                }
+            }
+        }
+
+        parse_all_failing(
+            slice_expr(expression()),
+            vec!["0,1,2,3,4]", "&[[0,1,2,3,4]", "&[0,1,2,,]", "&[0,1,2,3,4"],
+        );
+    }
+
+    #[test]
+    fn parse_slice_sugar() {
+        let valid = vec!["&[0;7]", "&[(1, 2); 4]", "&[0;Four]", "&[2;1+3-a]"];
+        parse_all(slice_expr(expression()), valid);
+
+        let invalid = vec!["&[0;;4]", "&[1, 2; 3]"];
+        parse_all_failing(slice_expr(expression()), invalid);
+    }
+
     #[test]
     fn parse_block() {
         parse_with(block(fresh_statement()), "{ [0,1,2,3,4] }").unwrap();
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index 572397d6527..d8a63d161b9 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -88,13 +88,24 @@ pub(super) fn array_type(
 ) -> impl NoirParser<UnresolvedType> {
     just(Token::LeftBracket)
         .ignore_then(type_parser)
-        .then(just(Token::Semicolon).ignore_then(type_expression()).or_not())
+        .then(just(Token::Semicolon).ignore_then(type_expression()))
         .then_ignore(just(Token::RightBracket))
         .map_with_span(|(element_type, size), span| {
             UnresolvedTypeData::Array(size, Box::new(element_type)).with_span(span)
         })
 }
 
+pub(super) fn slice_type(
+    type_parser: impl NoirParser<UnresolvedType>,
+) -> impl NoirParser<UnresolvedType> {
+    just(Token::LeftBracket)
+        .ignore_then(type_parser)
+        .then_ignore(just(Token::RightBracket))
+        .map_with_span(|element_type, span| {
+            UnresolvedTypeData::Slice(Box::new(element_type)).with_span(span)
+        })
+}
+
 pub(super) fn type_expression() -> impl NoirParser<UnresolvedTypeExpression> {
     recursive(|expr| {
         expression_with_precedence(
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index 60f233cd86d..d3d20654adc 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -15,6 +15,10 @@ pub enum PrintableType {
         #[serde(rename = "type")]
         typ: Box<PrintableType>,
     },
+    Slice {
+        #[serde(rename = "type")]
+        typ: Box<PrintableType>,
+    },
     Tuple {
         types: Vec<PrintableType>,
     },
@@ -50,7 +54,7 @@ pub enum PrintableType {
 pub enum PrintableValue {
     Field(FieldElement),
     String(String),
-    Vec(Vec<PrintableValue>),
+    Vec { array_elements: Vec<PrintableValue>, is_slice: bool },
     Struct(BTreeMap<String, PrintableValue>),
     Other,
 }
@@ -184,9 +188,12 @@ fn to_string(value: &PrintableValue, typ: &PrintableType) -> Option<String> {
         (_, PrintableType::MutableReference { .. }) => {
             output.push_str("<<mutable ref>>");
         }
-        (PrintableValue::Vec(vector), PrintableType::Array { typ, .. }) => {
+        (PrintableValue::Vec { array_elements, is_slice }, PrintableType::Array { typ, .. }) => {
+            if *is_slice {
+                output.push('&')
+            }
             output.push('[');
-            let mut values = vector.iter().peekable();
+            let mut values = array_elements.iter().peekable();
             while let Some(value) = values.next() {
                 output.push_str(&format!(
                     "{}",
@@ -221,9 +228,9 @@ fn to_string(value: &PrintableValue, typ: &PrintableType) -> Option<String> {
             output.push_str(" }");
         }
 
-        (PrintableValue::Vec(values), PrintableType::Tuple { types }) => {
+        (PrintableValue::Vec { array_elements, .. }, PrintableType::Tuple { types }) => {
             output.push('(');
-            let mut elems = values.iter().zip(types).peekable();
+            let mut elems = array_elements.iter().zip(types).peekable();
             while let Some((value, typ)) = elems.next() {
                 output.push_str(
                     &PrintableValueDisplay::Plain(value.clone(), typ.clone()).to_string(),
@@ -322,7 +329,7 @@ pub fn decode_value(
                 array_elements.push(decode_value(field_iterator, typ));
             }
 
-            PrintableValue::Vec(array_elements)
+            PrintableValue::Vec { array_elements, is_slice: false }
         }
         PrintableType::Array { length: Some(length), typ } => {
             let length = *length as usize;
@@ -331,11 +338,24 @@ pub fn decode_value(
                 array_elements.push(decode_value(field_iterator, typ));
             }
 
-            PrintableValue::Vec(array_elements)
+            PrintableValue::Vec { array_elements, is_slice: false }
         }
-        PrintableType::Tuple { types } => {
-            PrintableValue::Vec(vecmap(types, |typ| decode_value(field_iterator, typ)))
+        PrintableType::Slice { typ } => {
+            let length = field_iterator
+                .next()
+                .expect("not enough data to decode variable array length")
+                .to_u128() as usize;
+            let mut array_elements = Vec::with_capacity(length);
+            for _ in 0..length {
+                array_elements.push(decode_value(field_iterator, typ));
+            }
+
+            PrintableValue::Vec { array_elements, is_slice: true }
         }
+        PrintableType::Tuple { types } => PrintableValue::Vec {
+            array_elements: vecmap(types, |typ| decode_value(field_iterator, typ)),
+            is_slice: false,
+        },
         PrintableType::String { length } => {
             let field_elements: Vec<FieldElement> = field_iterator.take(*length as usize).collect();
 
diff --git a/docs/docs/how_to/merkle-proof.mdx b/docs/docs/how_to/merkle-proof.mdx
index 34074659ac1..003c7019a93 100644
--- a/docs/docs/how_to/merkle-proof.mdx
+++ b/docs/docs/how_to/merkle-proof.mdx
@@ -14,7 +14,7 @@ in a merkle tree.
 use dep::std;
 
 fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
-    let leaf = std::hash::hash_to_field(message);
+    let leaf = std::hash::hash_to_field(message.as_slice());
     let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
     assert(merkle_root == root);
 }
@@ -27,7 +27,7 @@ random oracle. If only collision resistance is needed, then one can call `std::h
 instead.
 
 ```rust
-let leaf = std::hash::hash_to_field(message);
+let leaf = std::hash::hash_to_field(message.as_slice());
 ```
 
 The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
diff --git a/docs/docs/noir/concepts/data_types/arrays.md b/docs/docs/noir/concepts/data_types/arrays.md
index a8bd338e736..efce3e95d32 100644
--- a/docs/docs/noir/concepts/data_types/arrays.md
+++ b/docs/docs/noir/concepts/data_types/arrays.md
@@ -72,7 +72,7 @@ let element = array[0][0];
 ```
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
 ```rust
-let slice : [[Field]] = [];
+let slice : [[Field]] = &[];
 ```
 
 ## Types
diff --git a/docs/docs/noir/concepts/data_types/fields.md b/docs/docs/noir/concepts/data_types/fields.md
index 99b4aa63549..a10a4810788 100644
--- a/docs/docs/noir/concepts/data_types/fields.md
+++ b/docs/docs/noir/concepts/data_types/fields.md
@@ -42,7 +42,7 @@ After declaring a Field, you can use these common methods on it:
 Transforms the field into an array of bits, Little Endian.
 
 ```rust
-fn to_le_bits<N>(_x : Field, _bit_size: u32) -> [u1; N]
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
 ```
 
 example:
@@ -59,7 +59,7 @@ fn main() {
 Transforms the field into an array of bits, Big Endian.
 
 ```rust
-fn to_be_bits<N>(_x : Field, _bit_size: u32) -> [u1; N]
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
 ```
 
 example:
diff --git a/docs/docs/noir/concepts/data_types/slices.mdx b/docs/docs/noir/concepts/data_types/slices.mdx
index 4a6ee816aa2..828faf4a8f8 100644
--- a/docs/docs/noir/concepts/data_types/slices.mdx
+++ b/docs/docs/noir/concepts/data_types/slices.mdx
@@ -15,13 +15,19 @@ A slice is a dynamically-sized view into a sequence of elements. They can be res
 use dep::std::slice;
 
 fn main() -> pub Field {
-    let mut slice: [Field] = [0; 2];
+    let mut slice: [Field] = &[0; 2];
 
     let mut new_slice = slice.push_back(6);
     new_slice.len()
 }
 ```
 
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
 View the corresponding test file [here][test-file].
 
 [test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
@@ -42,7 +48,7 @@ example:
 
 ```rust
 fn main() -> pub Field {
-    let mut slice: [Field] = [0; 2];
+    let mut slice: [Field] = &[0; 2];
 
     let mut new_slice = slice.push_back(6);
     new_slice.len()
@@ -62,7 +68,7 @@ fn push_front(_self: Self, _elem: T) -> Self
 Example:
 
 ```rust
-let mut new_slice: [Field] = [];
+let mut new_slice: [Field] = &[];
 new_slice = new_slice.push_front(20);
 assert(new_slice[0] == 20); // returns true
 ```
@@ -112,7 +118,7 @@ fn append(mut self, other: Self) -> Self
 Example:
 
 ```rust
-let append = [1, 2].append([3, 4, 5]);
+let append = &[1, 2].append(&[3, 4, 5]);
 ```
 
 ### insert
@@ -145,3 +151,20 @@ Example:
 ```rust
 let (remove_slice, removed_elem) = slice.remove(3);
 ```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
diff --git a/docs/docs/noir/concepts/functions.md b/docs/docs/noir/concepts/functions.md
index 48aba9cd058..2c9bc33fdfc 100644
--- a/docs/docs/noir/concepts/functions.md
+++ b/docs/docs/noir/concepts/functions.md
@@ -71,7 +71,7 @@ fn main(x : [Field]) {
 
 #[test]
 fn test_one() {
-    main([1, 2]);
+    main(&[1, 2]);
 }
 ```
 
diff --git a/docs/docs/noir/standard_library/bigint.md b/docs/docs/noir/standard_library/bigint.md
index 7d7931840cf..9aa4fb77112 100644
--- a/docs/docs/noir/standard_library/bigint.md
+++ b/docs/docs/noir/standard_library/bigint.md
@@ -31,7 +31,7 @@ For instance the big integer 'Secpk1Fq' in the standard library refers to intege
 
 Feel free to explore the source code for the other primes:
 
-#include_code curve_order_base noir_stdlib/src/bigint.nr rust
+#include_code big_int_definition noir_stdlib/src/bigint.nr rust
 
 ## Example usage
 
@@ -48,7 +48,7 @@ The available operations for each big integer are:
 Construct a big integer from its little-endian bytes representation. Example:
 
 ```rust
- let a = Secpk1Fq::from_le_bytes([x, y, 0, 45, 2]);
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
  ```
 
 Sure, here's the formatted version of the remaining methods:
diff --git a/docs/docs/noir/standard_library/containers/vec.mdx b/docs/docs/noir/standard_library/containers/vec.mdx
index 1954f05bc76..fcfd7e07aa0 100644
--- a/docs/docs/noir/standard_library/containers/vec.mdx
+++ b/docs/docs/noir/standard_library/containers/vec.mdx
@@ -49,8 +49,8 @@ pub fn from_slice(slice: [T]) -> Self
 Example:
 
 ```rust
-let arr: [Field] = [1, 2, 3];
-let vector_from_slice = Vec::from_slice(arr);
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
 assert(vector_from_slice.len() == 3);
 ```
 
@@ -80,7 +80,7 @@ pub fn get(self, index: Field) -> T
 Example:
 
 ```rust
-let vector: Vec<Field> = Vec::from_slice([10, 20, 30]);
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
 assert(vector.get(1) == 20);
 ```
 
@@ -111,7 +111,7 @@ pub fn pop(&mut self) -> T
 Example:
 
 ```rust
-let mut vector = Vec::from_slice([10, 20]);
+let mut vector = Vec::from_slice(&[10, 20]);
 let popped_elem = vector.pop();
 assert(popped_elem == 20);
 assert(vector.len() == 1);
@@ -128,7 +128,7 @@ pub fn insert(&mut self, index: Field, elem: T)
 Example:
 
 ```rust
-let mut vector = Vec::from_slice([10, 30]);
+let mut vector = Vec::from_slice(&[10, 30]);
 vector.insert(1, 20);
 assert(vector.get(1) == 20);
 ```
@@ -144,7 +144,7 @@ pub fn remove(&mut self, index: Field) -> T
 Example:
 
 ```rust
-let mut vector = Vec::from_slice([10, 20, 30]);
+let mut vector = Vec::from_slice(&[10, 20, 30]);
 let removed_elem = vector.remove(1);
 assert(removed_elem == 20);
 assert(vector.len() == 2);
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
index d67a1ac94df..6787c9f46a1 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -11,7 +11,8 @@ Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 cur
 
 ## ecdsa_secp256k1::verify_signature
 
-Verifier for ECDSA Secp256k1 signatures
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
 
 #include_code ecdsa_secp256k1 noir_stdlib/src/ecdsa_secp256k1.nr rust
 
@@ -24,9 +25,20 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+#include_code ecdsa_secp256k1_slice noir_stdlib/src/ecdsa_secp256k1.nr rust
+
+<BlackBoxInfo />
+
 ## ecdsa_secp256r1::verify_signature
 
-Verifier for ECDSA Secp256r1 signatures
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
 
 #include_code ecdsa_secp256r1 noir_stdlib/src/ecdsa_secp256r1.nr rust
 
@@ -40,3 +52,11 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 ```
 
 <BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+#include_code ecdsa_secp256r1_slice noir_stdlib/src/ecdsa_secp256r1.nr rust
+
+<BlackBoxInfo />
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
index b9239f822e8..f98c90a97c8 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -13,6 +13,7 @@ import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
 ## sha256
 
 Given an array of bytes, returns the resulting sha256 hash.
+See sha256_slice for a version that works directly on slices.
 
 #include_code sha256 noir_stdlib/src/hash.nr rust
 
@@ -27,9 +28,18 @@ fn main() {
 
 <BlackBoxInfo />
 
+## sha256_slice
+
+A version of sha256 specialized to slices:
+
+#include_code sha256_slice noir_stdlib/src/hash.nr rust
+
+<BlackBoxInfo />
+
 ## blake2s
 
 Given an array of bytes, returns an array with the Blake2 hash
+See blake2s_slice for a version that works directly on slices.
 
 #include_code blake2s noir_stdlib/src/hash.nr rust
 
@@ -44,9 +54,18 @@ fn main() {
 
 <BlackBoxInfo />
 
+## blake2s_slice
+
+A version of blake2s specialized to slices:
+
+#include_code blake2s_slice noir_stdlib/src/hash.nr rust
+
+<BlackBoxInfo />
+
 ## blake3
 
 Given an array of bytes, returns an array with the Blake3 hash
+See blake3_slice for a version that works directly on slices.
 
 #include_code blake3 noir_stdlib/src/hash.nr rust
 
@@ -61,9 +80,18 @@ fn main() {
 
 <BlackBoxInfo />
 
+## blake3_slice
+
+A version of blake3 specialized to slices:
+
+#include_code blake3_slice noir_stdlib/src/hash.nr rust
+
+<BlackBoxInfo />
+
 ## pedersen_hash
 
 Given an array of Fields, returns the Pedersen hash.
+See pedersen_hash_slice for a version that works directly on slices.
 
 #include_code pedersen_hash noir_stdlib/src/hash.nr rust
 
@@ -73,10 +101,18 @@ example:
 
 <BlackBoxInfo />
 
+## pedersen_hash_slice
+
+Given a slice of Fields, returns the Pedersen hash.
+
+#include_code pedersen_hash_slice noir_stdlib/src/hash.nr rust
+
+<BlackBoxInfo />
 
 ## pedersen_commitment
 
 Given an array of Fields, returns the Pedersen commitment.
+See pedersen_commitment_slice for a version that works directly on slices.
 
 #include_code pedersen_commitment noir_stdlib/src/hash.nr rust
 
@@ -86,11 +122,20 @@ example:
 
 <BlackBoxInfo />
 
+## pedersen_commitment_slice
+
+Given a slice of Fields, returns the Pedersen commitment.
+
+#include_code pedersen_commitment_slice noir_stdlib/src/hash.nr rust
+
+<BlackBoxInfo />
+
 ## keccak256
 
-Given an array of bytes (`u8`), returns the resulting keccak hash as an array of 32 bytes
-(`[u8; 32]`). Specify a message_size to hash only the first `message_size` bytes
-of the input.
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input. See keccak256_slice for a version that works
+directly on slices.
 
 #include_code keccak256 noir_stdlib/src/hash.nr rust
 
@@ -100,6 +145,15 @@ example:
 
 <BlackBoxInfo />
 
+## keccak256_slice
+
+Given a slice of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`).
+
+#include_code keccak256_slice noir_stdlib/src/hash.nr rust
+
+<BlackBoxInfo />
+
 ## poseidon
 
 Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
@@ -156,7 +210,7 @@ fn main() {
 ## hash_to_field
 
 ```rust
-fn hash_to_field<N>(_input : [Field; N]) -> Field {}
+fn hash_to_field(_input : [Field]) -> Field {}
 ```
 
 Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx
index 0e0c358c6e1..2c9eb18cd34 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -10,6 +10,7 @@ import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
 ## schnorr::verify_signature
 
 Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
 
 #include_code schnorr_verify noir_stdlib/src/schnorr.nr rust
 
@@ -34,3 +35,12 @@ const signature = Array.from(
 ```
 
 <BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+#include_code schnorr_verify_slice noir_stdlib/src/schnorr.nr rust
+
+<BlackBoxInfo />
diff --git a/docs/docs/noir/standard_library/merkle_trees.md b/docs/docs/noir/standard_library/merkle_trees.md
index fa488677884..6a9ebf72ada 100644
--- a/docs/docs/noir/standard_library/merkle_trees.md
+++ b/docs/docs/noir/standard_library/merkle_trees.md
@@ -42,9 +42,9 @@ fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]
     let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
     let pubkey_x = pubkey[0];
     let pubkey_y = pubkey[1];
-    let note_commitment = std::hash::pedersen([pubkey_x, pubkey_y, secret]);
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
 
-    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path);
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
     println(root);
 }
 ```
diff --git a/docs/docs/noir/standard_library/recursion.md b/docs/docs/noir/standard_library/recursion.md
index 9337499dac8..a93894043dc 100644
--- a/docs/docs/noir/standard_library/recursion.md
+++ b/docs/docs/noir/standard_library/recursion.md
@@ -29,8 +29,8 @@ By incorporating this attribute directly in the circuit's definition, tooling li
 ## Verifying Recursive Proofs
 
 ```rust
-#[foreign(verify_proof)]
-fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : Field, _key_hash : Field) {}
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 ```
 
 :::info
diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
index fb6d5ae1c48..e6e7e6d40cb 100644
--- a/docs/docs/noir/standard_library/traits.md
+++ b/docs/docs/noir/standard_library/traits.md
@@ -32,6 +32,8 @@ impl Default for bool { .. }
 impl<T, N> Default for [T; N]
     where T: Default { .. }
 
+impl<T> Default for [T] { .. }
+
 impl<A, B> Default for (A, B)
     where A: Default, B: Default { .. }
 
@@ -46,7 +48,8 @@ impl<A, B, C, D, E> Default for (A, B, C, D, E)
 ```
 
 For primitive integer types, the return value of `default` is `0`. Container
-types such as arrays are filled with default values of their element type.
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
 
 
 ## `std::convert`
@@ -112,6 +115,9 @@ impl Eq for bool { .. }
 impl<T, N> Eq for [T; N]
     where T: Eq { .. }
 
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
 impl<A, B> Eq for (A, B)
     where A: Eq, B: Eq { .. }
 
@@ -154,6 +160,9 @@ impl Ord for bool { .. }
 impl<T, N> Ord for [T; N]
     where T: Ord { .. }
 
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
 impl<A, B> Ord for (A, B)
     where A: Ord, B: Ord { .. }
 
diff --git a/docs/docs/noir/standard_library/zeroed.md b/docs/docs/noir/standard_library/zeroed.md
index 97dab02dac2..f450fecdd36 100644
--- a/docs/docs/noir/standard_library/zeroed.md
+++ b/docs/docs/noir/standard_library/zeroed.md
@@ -18,6 +18,7 @@ This function currently supports the following types:
 - Bool
 - Uint
 - Array
+- Slice
 - String
 - Tuple
 - Function
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index e7fc28ba39b..39ec40a1480 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,25 +1,24 @@
 use crate::ops::{Add, Sub, Mul, Div};
 use crate::cmp::Eq;
 
-// docs:start:curve_order_base
-global bn254_fq = [0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
-                   0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
-global bn254_fr = [0x01, 0x00, 0x00, 0x00, 0x3F, 0x59, 0x1F, 0x43, 0x09, 0x97, 0xB9, 0x79, 0x48, 0xE8, 0x33, 0x28, 
-                   0x5D, 0x58, 0x81, 0x81, 0xB6, 0x45, 0x50, 0xB8, 0x29, 0xA0, 0x31, 0xE1, 0x72, 0x4E, 0x64, 0x30];
-global secpk1_fr = [0x41, 0x41, 0x36, 0xD0, 0x8C, 0x5E, 0xD2, 0xBF, 0x3B, 0xA0, 0x48, 0xAF, 0xE6, 0xDC, 0xAE, 0xBA,
-                    0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpk1_fq = [0x2F, 0xFC, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpr1_fq = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpr1_fr = [0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3, 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC,
-                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,0xFF, 0xFF, 0xFF, 0xFF];
-// docs:end:curve_order_base
-
+global bn254_fq = &[0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
+                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
+global bn254_fr = &[0x01, 0x00, 0x00, 0x00, 0x3F, 0x59, 0x1F, 0x43, 0x09, 0x97, 0xB9, 0x79, 0x48, 0xE8, 0x33, 0x28, 
+                    0x5D, 0x58, 0x81, 0x81, 0xB6, 0x45, 0x50, 0xB8, 0x29, 0xA0, 0x31, 0xE1, 0x72, 0x4E, 0x64, 0x30];
+global secpk1_fr = &[0x41, 0x41, 0x36, 0xD0, 0x8C, 0x5E, 0xD2, 0xBF, 0x3B, 0xA0, 0x48, 0xAF, 0xE6, 0xDC, 0xAE, 0xBA,
+                     0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+global secpk1_fq = &[0x2F, 0xFC, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+global secpr1_fq = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
+global secpr1_fr = &[0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3, 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC,
+                           0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,0xFF, 0xFF, 0xFF, 0xFF];
+// docs:start:big_int_definition
 struct BigInt {
     pointer: u32,
     modulus: u32,
 }
+// docs:end:big_int_definition
 
 impl BigInt {
     #[builtin(bigint_add)]
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
index 38316e5d6a8..0eed50eb42b 100644
--- a/noir_stdlib/src/cmp.nr
+++ b/noir_stdlib/src/cmp.nr
@@ -28,6 +28,16 @@ impl<T, N> Eq for [T; N] where T: Eq {
     }
 }
 
+impl<T> Eq for [T] where T: Eq {
+    fn eq(self, other: [T]) -> bool {
+        let mut result = self.len() == other.len();
+        for i in 0 .. self.len() {
+            result &= self[i].eq(other[i]);
+        }
+        result
+    }
+}
+
 impl<N> Eq for str<N> {
     fn eq(self, other: str<N>) -> bool {
         let self_bytes = self.as_bytes();
@@ -213,6 +223,26 @@ impl<T, N> Ord for [T; N] where T: Ord {
     }
 }
 
+impl<T> Ord for [T] where T: Ord {
+    // The first non-equal element of both arrays determines
+    // the ordering for the whole array.
+    fn cmp(self, other: [T]) -> Ordering {
+        let mut result = self.len().cmp(other.len());
+        for i in 0 .. self.len() {
+            if result == Ordering::equal() {
+                let result_i = self[i].cmp(other[i]);
+
+                if result_i == Ordering::less() {
+                    result = result_i;
+                } else if result_i == Ordering::greater() {
+                    result = result_i;
+                }
+            }
+        }
+        result
+    }
+}
+
 impl<A, B> Ord for (A, B) where A: Ord, B: Ord {
     fn cmp(self, other: (A, B)) -> Ordering {
         let result = self.0.cmp(other.0);
diff --git a/noir_stdlib/src/collections/vec.nr b/noir_stdlib/src/collections/vec.nr
index deec98185ff..56354438c89 100644
--- a/noir_stdlib/src/collections/vec.nr
+++ b/noir_stdlib/src/collections/vec.nr
@@ -5,7 +5,7 @@ struct Vec<T> {
 // A separate type is technically not needed but helps differentiate which operations are mutable.
 impl<T> Vec<T> {
     pub fn new() -> Self {
-        Self { slice: [] }
+        Self { slice: &[] }
     }
 
     // Create a Vec containing each element from the given slice.
diff --git a/noir_stdlib/src/default.nr b/noir_stdlib/src/default.nr
index 32c4f3f3b48..bd2f1ce0cd2 100644
--- a/noir_stdlib/src/default.nr
+++ b/noir_stdlib/src/default.nr
@@ -23,6 +23,12 @@ impl<T, N> Default for [T; N] where T: Default {
     }
 }
 
+impl<T> Default for [T] {
+    fn default() -> [T] {
+        &[]
+    }
+}
+
 impl<A, B> Default for (A, B) where A: Default, B: Default {
     fn default() -> (A, B) {
         (A::default(), B::default())
diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr
index b72a1acd041..f84e2221f57 100644
--- a/noir_stdlib/src/ecdsa_secp256k1.nr
+++ b/noir_stdlib/src/ecdsa_secp256k1.nr
@@ -8,3 +8,15 @@ pub fn verify_signature<N>(
 ) -> bool
 // docs:end:ecdsa_secp256k1
 {}
+
+#[foreign(ecdsa_secp256k1)]
+// docs:start:ecdsa_secp256k1_slice
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+// docs:end:ecdsa_secp256k1_slice
+{}
+
diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr
index ef92bf24ae4..76e68aeeafa 100644
--- a/noir_stdlib/src/ecdsa_secp256r1.nr
+++ b/noir_stdlib/src/ecdsa_secp256r1.nr
@@ -8,3 +8,14 @@ pub fn verify_signature<N>(
 ) -> bool
 // docs:end:ecdsa_secp256r1
 {}
+
+#[foreign(ecdsa_secp256r1)]
+// docs:start:ecdsa_secp256r1_slice
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+// docs:end:ecdsa_secp256r1_slice
+{}
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 896dae15371..1a61b5e084e 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -12,38 +12,69 @@ pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:sha256
 {}
 
+#[foreign(sha256)]
+// docs:start:sha256_slice
+pub fn sha256_slice(input: [u8]) -> [u8; 32]
+// docs:end:sha256_slice
+{}
+
 #[foreign(blake2s)]
 // docs:start:blake2s
 pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake2s
 {}
 
+#[foreign(blake2s)]
+// docs:start:blake2s_slice
+pub fn blake2s_slice(input: [u8]) -> [u8; 32]
+// docs:end:blake2s_slice
+{}
+
 #[foreign(blake3)]
 // docs:start:blake3
 pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake3
 {}
 
+#[foreign(blake3)]
+// docs:start:blake3_slice
+pub fn blake3_slice(input: [u8]) -> [u8; 32]
+// docs:end:blake3_slice
+{}
+
 // docs:start:pedersen_commitment
 struct PedersenPoint {
    x : Field,
    y : Field,
 }
 
-pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint
-// docs:end:pedersen_commitment
-{
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+    // docs:end:pedersen_commitment
     pedersen_commitment_with_separator(input, 0)
 }
 
+// docs:start:pedersen_commitment_slice
+pub fn pedersen_commitment_slice(input: [Field]) -> PedersenPoint {
+    pedersen_commitment_with_separator_slice(input, 0)
+}
+// docs:end:pedersen_commitment_slice
+
 #[foreign(pedersen_commitment)]
 pub fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
 
+#[foreign(pedersen_commitment)]
+pub fn __pedersen_commitment_with_separator_slice(input: [Field], separator: u32) -> [Field; 2] {}
+
 pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> PedersenPoint {
     let values = __pedersen_commitment_with_separator(input, separator);
     PedersenPoint { x: values[0], y: values[1] }
 }
 
+pub fn pedersen_commitment_with_separator_slice(input: [Field], separator: u32) -> PedersenPoint {
+    let values = __pedersen_commitment_with_separator_slice(input, separator);
+    PedersenPoint { x: values[0], y: values[1] }
+}
+
 // docs:start:pedersen_hash
 pub fn pedersen_hash<N>(input: [Field; N]) -> Field
 // docs:end:pedersen_hash
@@ -51,20 +82,30 @@ pub fn pedersen_hash<N>(input: [Field; N]) -> Field
     pedersen_hash_with_separator(input, 0)
 }
 
+// docs:start:pedersen_hash_slice
+pub fn pedersen_hash_slice(input: [Field]) -> Field
+// docs:end:pedersen_hash_slice
+{
+    pedersen_hash_with_separator_slice(input, 0)
+}
+
 #[foreign(pedersen_hash)]
 pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {}
 
-pub fn hash_to_field<N>(input: [Field; N]) -> Field {
-    let mut inputs_as_bytes = [];
+#[foreign(pedersen_hash)]
+pub fn pedersen_hash_with_separator_slice(input: [Field], separator: u32) -> Field {}
+
+pub fn hash_to_field(inputs: [Field]) -> Field {
+    let mut inputs_as_bytes = &[];
 
-    for i in 0..N {
-        let input_bytes = input[i].to_le_bytes(32);
+    for input in inputs {
+        let input_bytes = input.to_le_bytes(32);
         for i in 0..32 {
             inputs_as_bytes = inputs_as_bytes.push_back(input_bytes[i]);
         }
     }
 
-    let hashed_input = blake2s(inputs_as_bytes);
+    let hashed_input = blake2s_slice(inputs_as_bytes);
     crate::field::bytes32_to_field(hashed_input)
 }
 
@@ -74,6 +115,12 @@ pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
 // docs:end:keccak256
 {}
 
+#[foreign(keccak256)]
+// docs:start:keccak256_slice
+pub fn keccak256_slice(input: [u8], message_size: u32) -> [u8; 32]
+// docs:end:keccak256_slice
+{}
+
 #[foreign(poseidon2_permutation)]
 pub fn poseidon2_permutation<N>(_input: [Field; N], _state_length: u32) -> [Field; N] {}
 
@@ -123,49 +170,49 @@ where
 
 impl Hash for Field {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self]);
+        H::write(state, &[self]);
     }
 }
 
 impl Hash for u8 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
 impl Hash for u32 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
 impl Hash for u64 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
 impl Hash for i8 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
 impl Hash for i32 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
 impl Hash for i64 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
 impl Hash for bool {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self as Field]);
+        H::write(state, &[self as Field]);
     }
 }
 
@@ -175,7 +222,7 @@ impl Hash for () {
 
 impl Hash for U128 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, [self.lo as Field, self.hi as Field]);
+        H::write(state, &[self.lo as Field, self.hi as Field]);
     }
 }
 
@@ -187,6 +234,15 @@ impl<T, N> Hash for [T; N] where T: Hash {
     }
 }
 
+impl<T> Hash for [T] where T: Hash {
+    fn hash<H>(self, state: &mut H) where H: Hasher{
+        self.len().hash(state);
+        for elem in self {
+            elem.hash(state);
+        }
+    }
+}
+
 impl<A, B> Hash for (A, B) where A: Hash, B: Hash {
     fn hash<H>(self, state: &mut H) where H: Hasher{
         self.0.hash(state);
diff --git a/noir_stdlib/src/hash/mimc.nr b/noir_stdlib/src/hash/mimc.nr
index db8a32d7909..1fb53701013 100644
--- a/noir_stdlib/src/hash/mimc.nr
+++ b/noir_stdlib/src/hash/mimc.nr
@@ -152,7 +152,7 @@ impl Hasher for MimcHasher {
 impl Default for MimcHasher{
     fn default() -> Self{
         MimcHasher{
-            _state: [],
+            _state: &[],
             _len: 0,
         }
     }
diff --git a/noir_stdlib/src/hash/pedersen.nr b/noir_stdlib/src/hash/pedersen.nr
index ace6851099d..ad21e728945 100644
--- a/noir_stdlib/src/hash/pedersen.nr
+++ b/noir_stdlib/src/hash/pedersen.nr
@@ -1,4 +1,4 @@
-use crate::hash::{Hasher, pedersen_hash};
+use crate::hash::{Hasher, pedersen_hash_slice};
 use crate::default::Default;
 
 struct PedersenHasher{
@@ -7,7 +7,7 @@ struct PedersenHasher{
 
 impl Hasher for PedersenHasher {
     fn finish(self) -> Field {
-       pedersen_hash(self._state)
+       pedersen_hash_slice(self._state)
     }
 
     fn write(&mut self, input: [Field]){
@@ -18,7 +18,7 @@ impl Hasher for PedersenHasher {
 impl Default for PedersenHasher{
     fn default() -> Self{
         PedersenHasher{
-            _state: []
+            _state: &[]
         }
     }
 }
diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr
index 7f99ad36316..85a0802f630 100644
--- a/noir_stdlib/src/hash/poseidon.nr
+++ b/noir_stdlib/src/hash/poseidon.nr
@@ -171,7 +171,7 @@ impl Hasher for PoseidonHasher {
 impl Default for PoseidonHasher{
     fn default() -> Self{
         PoseidonHasher{
-            _state: [],
+            _state: &[],
             _len: 0,
         }
     }
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 52229f18dbd..5b97d809896 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -139,7 +139,7 @@ impl Hasher for Poseidon2Hasher {
 impl Default for Poseidon2Hasher{
     fn default() -> Self{
         Poseidon2Hasher{
-            _state: [],
+            _state: &[],
             _len: 0,
         }
     }
diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr
index 757963d40d7..c63915061cb 100644
--- a/noir_stdlib/src/schnorr.nr
+++ b/noir_stdlib/src/schnorr.nr
@@ -8,3 +8,15 @@ pub fn verify_signature<N>(
 ) -> bool
 // docs:end:schnorr_verify
 {}
+
+#[foreign(schnorr_verify)]
+// docs:start:schnorr_verify_slice
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+// docs:end:schnorr_verify_slice
+{}
+
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index ea8d09d14ce..164b4f96cf6 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -1,4 +1,7 @@
 impl<T> [T] {
+    #[builtin(array_len)]
+    pub fn len(self) -> u64 {}
+
     /// Push a new element to the end of the slice, returning a
     /// new slice with a length one greater than the
     /// original unmodified slice.
diff --git a/test_programs/compile_success_empty/vectors/src/main.nr b/test_programs/compile_success_empty/vectors/src/main.nr
index 28187a4f619..d105ceed180 100644
--- a/test_programs/compile_success_empty/vectors/src/main.nr
+++ b/test_programs/compile_success_empty/vectors/src/main.nr
@@ -26,7 +26,7 @@ fn main(x: Field, y: pub Field) {
     assert(vector.get(3) == 3);
     assert(vector.len() == 4);
 
-    let mut inputs_vector = Vec::from_slice([x, y]);
+    let mut inputs_vector = Vec::from_slice(&[x, y]);
     assert(inputs_vector.get(0) == x);
     assert(inputs_vector.get(1) == y);
 }
diff --git a/test_programs/execution_success/array_to_slice/src/main.nr b/test_programs/execution_success/array_to_slice/src/main.nr
index 4f5594c6d11..b97f68fc280 100644
--- a/test_programs/execution_success/array_to_slice/src/main.nr
+++ b/test_programs/execution_success/array_to_slice/src/main.nr
@@ -1,6 +1,6 @@
 // Converts an array into a slice.
 fn as_slice_push<T, N>(xs: [T; N]) -> [T] {
-    let mut slice = [];
+    let mut slice = &[];
     for elem in xs {
         slice = slice.push_back(elem);
     }
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index b6c23276c15..db269d63ac0 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -2,8 +2,8 @@ use dep::std::bigint;
 use dep::std::{bigint::Secpk1Fq, println};
 
 fn main(mut x: [u8; 5], y: [u8; 5]) {
-    let a = bigint::Secpk1Fq::from_le_bytes([x[0], x[1], x[2], x[3], x[4]]);
-    let b = bigint::Secpk1Fq::from_le_bytes([y[0], y[1], y[2], y[3], y[4]]);
+    let a = bigint::Secpk1Fq::from_le_bytes(&[x[0], x[1], x[2], x[3], x[4]]);
+    let b = bigint::Secpk1Fq::from_le_bytes(&[y[0], y[1], y[2], y[3], y[4]]);
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
     for i in 0..5 {
@@ -19,8 +19,8 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
 
 // docs:start:big_int_example
 fn big_int_example(x: u8, y: u8) {
-    let a = Secpk1Fq::from_le_bytes([x, y, 0, 45, 2]);
-    let b = Secpk1Fq::from_le_bytes([y, x, 9]);
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
     let c = (a + b) * b / a;
     let d = c.to_le_bytes();
     println(d[0]);
diff --git a/test_programs/execution_success/brillig_hash_to_field/src/main.nr b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
index 4b4177a521e..53ed85b3ddd 100644
--- a/test_programs/execution_success/brillig_hash_to_field/src/main.nr
+++ b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
@@ -7,5 +7,5 @@ fn main(input: Field) -> pub Field {
 }
 
 unconstrained fn hash_to_field(input: Field) -> Field {
-    std::hash::hash_to_field([input])
+    std::hash::hash_to_field(&[input])
 }
diff --git a/test_programs/execution_success/brillig_keccak/src/main.nr b/test_programs/execution_success/brillig_keccak/src/main.nr
index 1e9b65a6eb4..a300bc18279 100644
--- a/test_programs/execution_success/brillig_keccak/src/main.nr
+++ b/test_programs/execution_success/brillig_keccak/src/main.nr
@@ -7,7 +7,7 @@ fn main(x: Field, result: [u8; 32]) {
     // The padding is taken care of by the program
     let digest = keccak256([x as u8], 1);
     assert(digest == result);
-    //#1399: variable meesage size
+    //#1399: variable message size
     let message_size = 4;
     let hash_a = keccak256([1, 2, 3, 4], message_size);
     let hash_b = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
diff --git a/test_programs/execution_success/brillig_schnorr/src/main.nr b/test_programs/execution_success/brillig_schnorr/src/main.nr
index 4cc79ae7e07..03c635b4f6f 100644
--- a/test_programs/execution_success/brillig_schnorr/src/main.nr
+++ b/test_programs/execution_success/brillig_schnorr/src/main.nr
@@ -17,7 +17,7 @@ unconstrained fn main(
     // Is there ever a situation where someone would want 
     // to ensure that a signature was invalid?
     // Check that passing a slice as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message_field_bytes);
+    let valid_signature = std::schnorr::verify_signature_slice(pub_key_x, pub_key_y, signature, message_field_bytes);
     assert(valid_signature);
     // Check that passing an array as the message is valid
     let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
diff --git a/test_programs/execution_success/brillig_slices/src/main.nr b/test_programs/execution_success/brillig_slices/src/main.nr
index 847c41de25c..2cf1850f151 100644
--- a/test_programs/execution_success/brillig_slices/src/main.nr
+++ b/test_programs/execution_success/brillig_slices/src/main.nr
@@ -1,6 +1,6 @@
 use dep::std::slice;
 unconstrained fn main(x: Field, y: Field) {
-    let mut slice: [Field] = [y, x];
+    let mut slice: [Field] = &[y, x];
     assert(slice.len() == 2);
 
     slice = slice.push_back(7);
@@ -108,7 +108,7 @@ unconstrained fn merge_slices_else(x: Field) {
 }
 // Test returning a merged slice without a mutation
 unconstrained fn merge_slices_return(x: Field, y: Field) -> [Field] {
-    let slice = [0; 2];
+    let slice = &[0; 2];
     if x != y {
         if x != 20 { slice.push_back(y) } else { slice }
     } else {
@@ -117,7 +117,7 @@ unconstrained fn merge_slices_return(x: Field, y: Field) -> [Field] {
 }
 // Test mutating a slice inside of an if statement
 unconstrained fn merge_slices_mutate(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -128,7 +128,7 @@ unconstrained fn merge_slices_mutate(x: Field, y: Field) -> [Field] {
 }
 // Test mutating a slice inside of a loop in an if statement
 unconstrained fn merge_slices_mutate_in_loop(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         for i in 0..5 {
             slice = slice.push_back(i as Field);
diff --git a/test_programs/execution_success/hash_to_field/src/main.nr b/test_programs/execution_success/hash_to_field/src/main.nr
index 5af1c5af55e..242b5ecbc18 100644
--- a/test_programs/execution_success/hash_to_field/src/main.nr
+++ b/test_programs/execution_success/hash_to_field/src/main.nr
@@ -1,5 +1,5 @@
 use dep::std;
 
 fn main(input: Field) -> pub Field {
-    std::hash::hash_to_field([input])
+    std::hash::hash_to_field(&[input])
 }
diff --git a/test_programs/execution_success/nested_array_in_slice/src/main.nr b/test_programs/execution_success/nested_array_in_slice/src/main.nr
index a3007d5d0dc..0890115e95a 100644
--- a/test_programs/execution_success/nested_array_in_slice/src/main.nr
+++ b/test_programs/execution_success/nested_array_in_slice/src/main.nr
@@ -13,7 +13,7 @@ fn main(y: Field) {
     let foo_two = Foo { a: 4, b: [5, 6, 21], bar: Bar { inner: [103, 104, 105] } };
     let foo_three = Foo { a: 7, b: [8, 9, 22], bar: Bar { inner: [106, 107, 108] } };
     let foo_four = Foo { a: 10, b: [11, 12, 23], bar: Bar { inner: [109, 110, 111] } };
-    let mut x = [foo_one];
+    let mut x = &[foo_one];
     x = x.push_back(foo_two);
     x = x.push_back(foo_three);
     x = x.push_back(foo_four);
diff --git a/test_programs/execution_success/regression_4202/src/main.nr b/test_programs/execution_success/regression_4202/src/main.nr
index 37d2ee4578d..faa14f03912 100644
--- a/test_programs/execution_success/regression_4202/src/main.nr
+++ b/test_programs/execution_success/regression_4202/src/main.nr
@@ -1,5 +1,5 @@
 fn main(input: [u32; 4]) {
-    let mut slice1: [u32] = [1, 2, 3, 4];
+    let mut slice1: [u32] = &[1, 2, 3, 4];
     if slice1[0] == 3 {
         slice1[1] = 4;
     }
diff --git a/test_programs/execution_success/schnorr/src/main.nr b/test_programs/execution_success/schnorr/src/main.nr
index 107af152625..9e2838c34d9 100644
--- a/test_programs/execution_success/schnorr/src/main.nr
+++ b/test_programs/execution_success/schnorr/src/main.nr
@@ -17,7 +17,7 @@ fn main(
     // Is there ever a situation where someone would want 
     // to ensure that a signature was invalid?
     // Check that passing a slice as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message_field_bytes);
+    let valid_signature = std::schnorr::verify_signature_slice(pub_key_x, pub_key_y, signature, message_field_bytes);
     assert(valid_signature);
     // Check that passing an array as the message is valid
     let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
diff --git a/test_programs/execution_success/slice_dynamic_index/src/main.nr b/test_programs/execution_success/slice_dynamic_index/src/main.nr
index 41fc9a645c1..9b97c0721bb 100644
--- a/test_programs/execution_success/slice_dynamic_index/src/main.nr
+++ b/test_programs/execution_success/slice_dynamic_index/src/main.nr
@@ -4,7 +4,7 @@ fn main(x: Field) {
 }
 
 fn regression_dynamic_slice_index(x: Field, y: Field) {
-    let mut slice = [];
+    let mut slice = &[];
     for i in 0..5 {
         slice = slice.push_back(i as Field);
     }
diff --git a/test_programs/execution_success/slices/src/main.nr b/test_programs/execution_success/slices/src/main.nr
index e44edf872a4..b20e3478898 100644
--- a/test_programs/execution_success/slices/src/main.nr
+++ b/test_programs/execution_success/slices/src/main.nr
@@ -2,7 +2,7 @@ use dep::std::slice;
 use dep::std;
 
 fn main(x: Field, y: pub Field) {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     assert(slice[0] == 0);
     assert(slice[0] != 1);
     slice[0] = x;
@@ -13,7 +13,7 @@ fn main(x: Field, y: pub Field) {
     assert(slice_plus_10[2] != 8);
     assert(slice_plus_10.len() == 3);
 
-    let mut new_slice = [];
+    let mut new_slice = &[];
     for i in 0..5 {
         new_slice = new_slice.push_back(i);
     }
@@ -41,7 +41,7 @@ fn main(x: Field, y: pub Field) {
     assert(remove_slice[3] == 3);
     assert(remove_slice.len() == 4);
 
-    let append = [1, 2].append([3, 4, 5]);
+    let append = &[1, 2].append(&[3, 4, 5]);
     assert(append.len() == 5);
     assert(append[0] == 1);
     assert(append[4] == 5);
@@ -55,9 +55,10 @@ fn main(x: Field, y: pub Field) {
     regression_slice_call_result(x, y);
     regression_4506();
 }
+
 // Ensure that slices of struct/tuple values work.
 fn regression_2083() {
-    let y = [(1, 2)];
+    let y = &[(1, 2)];
     let y = y.push_back((3, 4)); // [(1, 2), (3, 4)]
     let y = y.push_back((5, 6)); // [(1, 2), (3, 4), (5, 6)]
     assert(y[2].1 == 6);
@@ -86,6 +87,7 @@ fn regression_2083() {
     assert(x.0 == 5);
     assert(x.1 == 6);
 }
+
 // The parameters to this function must come from witness values (inputs to main)
 fn regression_merge_slices(x: Field, y: Field) {
     merge_slices_if(x, y);
@@ -146,18 +148,20 @@ fn merge_slices_else(x: Field) {
     assert(slice[2] == 5);
     assert(slice.len() == 3);
 }
+
 // Test returning a merged slice without a mutation
 fn merge_slices_return(x: Field, y: Field) -> [Field] {
-    let slice = [0; 2];
+    let slice = &[0; 2];
     if x != y {
         if x != 20 { slice.push_back(y) } else { slice }
     } else {
         slice
     }
 }
+
 // Test mutating a slice inside of an if statement
 fn merge_slices_mutate(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -166,9 +170,10 @@ fn merge_slices_mutate(x: Field, y: Field) -> [Field] {
     }
     slice
 }
+
 // Test mutating a slice inside of a loop in an if statement
 fn merge_slices_mutate_in_loop(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         for i in 0..5 {
             slice = slice.push_back(i as Field);
@@ -180,7 +185,7 @@ fn merge_slices_mutate_in_loop(x: Field, y: Field) -> [Field] {
 }
 
 fn merge_slices_mutate_two_ifs(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -199,7 +204,7 @@ fn merge_slices_mutate_two_ifs(x: Field, y: Field) -> [Field] {
 }
 
 fn merge_slices_mutate_between_ifs(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -225,7 +230,7 @@ fn merge_slices_mutate_between_ifs(x: Field, y: Field) -> [Field] {
 }
 
 fn merge_slices_push_then_pop(x: Field, y: Field) {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -249,7 +254,7 @@ fn merge_slices_push_then_pop(x: Field, y: Field) {
 }
 
 fn merge_slices_push_then_insert(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -272,7 +277,7 @@ fn merge_slices_push_then_insert(x: Field, y: Field) -> [Field] {
 }
 
 fn merge_slices_remove_between_ifs(x: Field, y: Field) -> [Field] {
-    let mut slice = [0; 2];
+    let mut slice = &[0; 2];
     if x != y {
         slice = slice.push_back(y);
         slice = slice.push_back(x);
@@ -298,8 +303,8 @@ fn merge_slices_remove_between_ifs(x: Field, y: Field) -> [Field] {
 // Previously, we'd get a type error when trying to assign an array of a different size to
 // an existing array variable. Now, we infer the variable must be a slice.
 fn regression_2370() {
-    let mut slice = [];
-    slice = [1, 2, 3];
+    let mut slice = &[];
+    slice = &[1, 2, 3];
 }
 
 fn regression_4418(x: Field) {
@@ -327,6 +332,6 @@ fn regression_slice_call_result(x: Field, y: Field) {
 }
 
 fn regression_4506() {
-    let slice: [Field] = [1, 2, 3];
+    let slice: [Field] = &[1, 2, 3];
     assert(slice == slice);
 }
diff --git a/tooling/debugger/tests/debug.rs b/tooling/debugger/tests/debug.rs
index 143ee7987f8..4de1b25f48a 100644
--- a/tooling/debugger/tests/debug.rs
+++ b/tooling/debugger/tests/debug.rs
@@ -12,7 +12,9 @@ mod tests {
         let nargo_bin =
             cargo_bin("nargo").into_os_string().into_string().expect("Cannot parse nargo path");
 
-        let mut dbg_session = spawn_bash(Some(15000)).expect("Could not start bash session");
+        let timeout_seconds = 120;
+        let mut dbg_session =
+            spawn_bash(Some(timeout_seconds * 1000)).expect("Could not start bash session");
 
         // Set backend to `/dev/null` to force an error if nargo tries to speak to a backend.
         dbg_session
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 66568bec833..0e9e177e023 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -93,16 +93,27 @@ impl DebugVars {
             .unwrap_or_else(|| panic!("type unavailable for type id {cursor_type_id:?}"));
         for index in indexes.iter() {
             (cursor, cursor_type) = match (cursor, cursor_type) {
-                (PrintableValue::Vec(array), PrintableType::Array { length, typ }) => {
+                (
+                    PrintableValue::Vec { array_elements, is_slice },
+                    PrintableType::Array { length, typ },
+                ) => {
+                    assert!(!*is_slice, "slice has array type");
                     if let Some(len) = length {
                         if *index as u64 >= *len {
                             panic!("unexpected field index past array length")
                         }
-                        if *len != array.len() as u64 {
+                        if *len != array_elements.len() as u64 {
                             panic!("type/array length mismatch")
                         }
                     }
-                    (array.get_mut(*index as usize).unwrap(), &*Box::leak(typ.clone()))
+                    (array_elements.get_mut(*index as usize).unwrap(), &*Box::leak(typ.clone()))
+                }
+                (
+                    PrintableValue::Vec { array_elements, is_slice },
+                    PrintableType::Slice { typ },
+                ) => {
+                    assert!(*is_slice, "array has slice type");
+                    (array_elements.get_mut(*index as usize).unwrap(), &*Box::leak(typ.clone()))
                 }
                 (
                     PrintableValue::Struct(field_map),
@@ -114,18 +125,22 @@ impl DebugVars {
                     let (key, typ) = fields.get(*index as usize).unwrap();
                     (field_map.get_mut(key).unwrap(), typ)
                 }
-                (PrintableValue::Vec(array), PrintableType::Tuple { types }) => {
+                (
+                    PrintableValue::Vec { array_elements, is_slice },
+                    PrintableType::Tuple { types },
+                ) => {
+                    assert!(!*is_slice, "slice has tuple type");
                     if *index >= types.len() as u32 {
                         panic!(
                             "unexpected field index ({index}) past tuple length ({})",
                             types.len()
                         );
                     }
-                    if types.len() != array.len() {
+                    if types.len() != array_elements.len() {
                         panic!("type/array length mismatch")
                     }
                     let typ = types.get(*index as usize).unwrap();
-                    (array.get_mut(*index as usize).unwrap(), typ)
+                    (array_elements.get_mut(*index as usize).unwrap(), typ)
                 }
                 _ => {
                     panic!("unexpected assign field of {cursor_type:?} type");
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index f68ccbfd50e..a796eeac326 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -242,8 +242,8 @@ fn compile_success_empty_{test_name}() {{
     }}
 
     // `compile_success_empty` tests should be able to compile down to an empty circuit.
-    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|_| {{
-        panic!("JSON was not well-formatted {{:?}}",output.stdout)
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
+        panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
     }});
     let num_opcodes = &json["programs"][0]["acir_opcodes"];
     assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
diff --git a/tooling/nargo_fmt/src/rewrite/array.rs b/tooling/nargo_fmt/src/rewrite/array.rs
index 77e5e756f19..db7dc4701b7 100644
--- a/tooling/nargo_fmt/src/rewrite/array.rs
+++ b/tooling/nargo_fmt/src/rewrite/array.rs
@@ -6,7 +6,12 @@ use crate::{
     visitor::{expr::NewlineMode, FmtVisitor},
 };
 
-pub(crate) fn rewrite(mut visitor: FmtVisitor, array: Vec<Expression>, array_span: Span) -> String {
+pub(crate) fn rewrite(
+    mut visitor: FmtVisitor,
+    array: Vec<Expression>,
+    array_span: Span,
+    is_slice: bool,
+) -> String {
     let pattern: &[_] = &[' ', '\t'];
 
     visitor.indent.block_indent(visitor.config);
@@ -75,8 +80,9 @@ pub(crate) fn rewrite(mut visitor: FmtVisitor, array: Vec<Expression>, array_spa
         }
     }
 
+    let open_bracket = if is_slice { "&[" } else { "[" };
     crate::visitor::expr::wrap_exprs(
-        "[",
+        open_bracket,
         "]",
         items_str.trim().into(),
         nested_indent,
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 32d104f559b..ffb8dea5a9d 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -122,7 +122,16 @@ pub(crate) fn rewrite(
                 format!("[{repeated}; {length}]")
             }
             Literal::Array(ArrayLiteral::Standard(exprs)) => {
-                super::array(visitor.fork(), exprs, span)
+                super::array(visitor.fork(), exprs, span, false)
+            }
+            Literal::Slice(ArrayLiteral::Repeated { repeated_element, length }) => {
+                let repeated = rewrite_sub_expr(visitor, shape, *repeated_element);
+                let length = rewrite_sub_expr(visitor, shape, *length);
+
+                format!("&[{repeated}; {length}]")
+            }
+            Literal::Slice(ArrayLiteral::Standard(exprs)) => {
+                super::array(visitor.fork(), exprs, span, true)
             }
             Literal::Unit => "()".to_string(),
         },
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
index aaa77b0bea5..922337cdb74 100644
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ b/tooling/nargo_fmt/src/rewrite/typ.rs
@@ -9,12 +9,12 @@ pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType)
     match typ.typ {
         UnresolvedTypeData::Array(length, element) => {
             let typ = rewrite(visitor, _shape, *element);
-            if let Some(length) = length {
-                let length = visitor.slice(length.span());
-                format!("[{typ}; {length}]")
-            } else {
-                format!("[{typ}]")
-            }
+            let length = visitor.slice(length.span());
+            format!("[{typ}; {length}]")
+        }
+        UnresolvedTypeData::Slice(element) => {
+            let typ = rewrite(visitor, _shape, *element);
+            format!("[{typ}]")
         }
         UnresolvedTypeData::Parenthesized(typ) => {
             let typ = rewrite(visitor, _shape, *typ);
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 26feab65d83..26edb7a2af6 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -178,7 +178,7 @@ impl AbiType {
             | Type::TypeVariable(_, _)
             | Type::NamedGeneric(..)
             | Type::Forall(..)
-            | Type::NotConstant
+            | Type::Slice(_)
             | Type::Function(_, _, _) => unreachable!("Type cannot be used in the abi"),
             Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
             Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"),

From cba1bff95911a7a1d3ea714735786db595a435cf Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 19 Mar 2024 23:36:53 +0000
Subject: [PATCH 099/416] chore: fix assignees for opening issues based on CI
 (#4596)

---
 .github/ACVM_NOT_PUBLISHABLE.md     | 3 +--
 .github/CRATES_IO_PUBLISH_FAILED.md | 2 +-
 .github/DEAD_LINKS_IN_DOCS.md       | 2 +-
 .github/JS_PUBLISH_FAILED.md        | 2 +-
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/.github/ACVM_NOT_PUBLISHABLE.md b/.github/ACVM_NOT_PUBLISHABLE.md
index e7eacb3b523..33230f8e8d8 100644
--- a/.github/ACVM_NOT_PUBLISHABLE.md
+++ b/.github/ACVM_NOT_PUBLISHABLE.md
@@ -1,9 +1,8 @@
 ---
 title: "ACVM crates are not publishable"
-assignees: TomAFrench kevaundray savio-sou
+assignees: TomAFrench, Savio-Sou
 ---
 
-
 The ACVM crates are currently unpublishable, making a release will NOT push our crates to crates.io.
 
 This is likely due to a crate we depend on bumping its MSRV above our own. Our lockfile is not taken into account when publishing to crates.io (as people downloading our crate don't use it) so we need to be able to use the most up to date versions of our dependencies (including transient dependencies) specified. 
diff --git a/.github/CRATES_IO_PUBLISH_FAILED.md b/.github/CRATES_IO_PUBLISH_FAILED.md
index ec4de319772..5e2d4b7b77f 100644
--- a/.github/CRATES_IO_PUBLISH_FAILED.md
+++ b/.github/CRATES_IO_PUBLISH_FAILED.md
@@ -1,6 +1,6 @@
 ---
 title: "ACVM crates failed to publish"
-assignees: TomAFrench kevaundray savio-sou
+assignees: TomAFrench, Savio-Sou
 ---
 
 The {{env.CRATE_VERSION}} release of the ACVM crates failed.
diff --git a/.github/DEAD_LINKS_IN_DOCS.md b/.github/DEAD_LINKS_IN_DOCS.md
index b1671276dcf..dcd4f44cdf2 100644
--- a/.github/DEAD_LINKS_IN_DOCS.md
+++ b/.github/DEAD_LINKS_IN_DOCS.md
@@ -1,6 +1,6 @@
 ---
 title: "Docs contains dead links"
-assignees: signorecello catmcgee critesjosh jzaki Savio-Sou
+assignees: signorecello, catmcgee, critesjosh, jzaki, Savio-Sou
 labels: documentation
 ---
 
diff --git a/.github/JS_PUBLISH_FAILED.md b/.github/JS_PUBLISH_FAILED.md
index 9adba2776c8..f91af361d7d 100644
--- a/.github/JS_PUBLISH_FAILED.md
+++ b/.github/JS_PUBLISH_FAILED.md
@@ -1,6 +1,6 @@
 ---
 title: "JS packages failed to publish"
-assignees: TomAFrench kevaundray Savio-Sou
+assignees: TomAFrench, Savio-Sou
 labels: js
 ---
 

From 859906ddf03ab33f7a14e8551f17cd1c1b59f25e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 20 Mar 2024 13:01:15 +0000
Subject: [PATCH 100/416] chore(ci): fix long debugger test times (#4599)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're currently not closing the spawned bash process so we have to wait
for the full timeout duration before the test registers as successful.
This PR then adds an explicit call to `exit` to finish the test early.

I've also shortened the timeout as 2 minutes seems excessive.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/debugger/tests/debug.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tooling/debugger/tests/debug.rs b/tooling/debugger/tests/debug.rs
index 4de1b25f48a..b104a2c84ac 100644
--- a/tooling/debugger/tests/debug.rs
+++ b/tooling/debugger/tests/debug.rs
@@ -12,7 +12,7 @@ mod tests {
         let nargo_bin =
             cargo_bin("nargo").into_os_string().into_string().expect("Cannot parse nargo path");
 
-        let timeout_seconds = 120;
+        let timeout_seconds = 20;
         let mut dbg_session =
             spawn_bash(Some(timeout_seconds * 1000)).expect("Could not start bash session");
 
@@ -51,5 +51,8 @@ mod tests {
         dbg_session
             .exp_regex(".*Circuit witness successfully solved.*")
             .expect("Expected circuit witness to be successfully solved.");
+
+        // Exit the bash session.
+        dbg_session.send_line("exit").expect("Failed to quit bash session");
     }
 }

From 4c3a30b4991a329d3c52e1dfa59d854d7e6910db Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 20 Mar 2024 10:48:06 -0500
Subject: [PATCH 101/416] feat: Add experimental `quote` expression to parser
 (#4595)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4586

Part of https://github.com/noir-lang/noir/issues/4594

## Summary\*

Adds a `quote { ... }` expression to the parser along with a new builtin
`Code` type which it is the only method of creating.

## Additional Context

The quote expression can only currently quote expressions and
statements. It cannot yet quote top-level statements - we'd need more
parser changes for this. In particular the top level statement parser
would now need to be recursive and passed down all the way to the
expression level...

Trying to use `quote` in a program gives you an `experimental feature`
warning. Indeed, the only thing you can do with it currently is panic
once it gets to monomorphization without being removed from the runtime
program yet.

## Documentation\*

Check one:
- [x] No documentation needed.
- I'm following the pattern with other experimental features and waiting
to document them until they're stable. For this, it means quote won't be
documented until the base for metaprogramming is completed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/expression.rs |  2 ++
 .../src/hir/resolution/resolver.rs            |  4 ++++
 .../noirc_frontend/src/hir/type_check/expr.rs |  1 +
 compiler/noirc_frontend/src/hir_def/expr.rs   |  1 +
 compiler/noirc_frontend/src/hir_def/types.rs  | 22 ++++++++++++++++---
 compiler/noirc_frontend/src/lexer/token.rs    |  3 +++
 .../src/monomorphization/mod.rs               |  2 ++
 compiler/noirc_frontend/src/node_interner.rs  |  2 ++
 compiler/noirc_frontend/src/parser/parser.rs  | 16 +++++++++++++-
 tooling/nargo_fmt/src/rewrite/expr.rs         | 18 ++++++++++-----
 tooling/noirc_abi/src/lib.rs                  |  3 ++-
 11 files changed, 63 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 09c09daf9b9..d646a6ca98a 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -27,6 +27,7 @@ pub enum ExpressionKind {
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
+    Quote(BlockExpression),
     Error,
 }
 
@@ -495,6 +496,7 @@ impl Display for ExpressionKind {
             }
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
+            Quote(block) => write!(f, "quote {block}"),
             Error => write!(f, "Error"),
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index c6606386f7b..3fbde8a890b 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1085,6 +1085,7 @@ impl<'a> Resolver<'a> {
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::TraitAsType(..)
+            | Type::Code
             | Type::Forall(_, _) => (),
 
             Type::Array(length, element_type) => {
@@ -1620,6 +1621,9 @@ impl<'a> Resolver<'a> {
                 })
             }),
             ExpressionKind::Parenthesized(sub_expr) => return self.resolve_expression(*sub_expr),
+
+            // The quoted expression isn't resolved since we don't want errors if variables aren't defined
+            ExpressionKind::Quote(block) => HirExpression::Quote(block),
         };
 
         // If these lines are ever changed, make sure to change the early return
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index eb998b59755..6ee0460784f 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -332,6 +332,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 Type::Function(params, Box::new(lambda.return_type), Box::new(env_type))
             }
+            HirExpression::Quote(_) => Type::Code,
         };
 
         self.interner.push_expr_type(*expr_id, typ.clone());
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index 6a1b4385f0d..61743d2cdc7 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -31,6 +31,7 @@ pub enum HirExpression {
     Tuple(Vec<ExprId>),
     Lambda(HirLambda),
     Error,
+    Quote(crate::BlockExpression),
 }
 
 impl HirExpression {
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 7fb26aa3879..3c5627f739b 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -101,6 +101,9 @@ pub enum Type {
     /// bind to an integer without special checks to bind it to a non-type.
     Constant(u64),
 
+    /// The type of quoted code in macros. This is always a comptime-only type
+    Code,
+
     /// The result of some type error. Remembering type errors as their own type variant lets
     /// us avoid issuing repeat type errors for the same item. For example, a lambda with
     /// an invalid type would otherwise issue a new error each time it is called
@@ -144,6 +147,7 @@ impl Type {
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Constant(_)
+            | Type::Code
             | Type::Slice(_)
             | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
         }
@@ -626,6 +630,7 @@ impl Type {
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::Forall(_, _)
+            | Type::Code
             | Type::TraitAsType(..) => false,
 
             Type::Array(length, elem) => {
@@ -689,6 +694,7 @@ impl Type {
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
+            | Type::Code
             | Type::Slice(_)
             | Type::TraitAsType(..) => false,
 
@@ -852,6 +858,7 @@ impl std::fmt::Display for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element}")
             }
+            Type::Code => write!(f, "Code"),
         }
     }
 }
@@ -1529,6 +1536,7 @@ impl Type {
             | Type::Constant(_)
             | Type::TraitAsType(..)
             | Type::Error
+            | Type::Code
             | Type::Unit => self.clone(),
         }
     }
@@ -1570,6 +1578,7 @@ impl Type {
             | Type::Constant(_)
             | Type::TraitAsType(..)
             | Type::Error
+            | Type::Code
             | Type::Unit => false,
         }
     }
@@ -1621,9 +1630,14 @@ impl Type {
 
             // Expect that this function should only be called on instantiated types
             Forall(..) => unreachable!(),
-            TraitAsType(..) | FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Error => {
-                self.clone()
-            }
+            TraitAsType(..)
+            | FieldElement
+            | Integer(_, _)
+            | Bool
+            | Constant(_)
+            | Unit
+            | Code
+            | Error => self.clone(),
         }
     }
 
@@ -1752,6 +1766,7 @@ impl From<&Type> for PrintableType {
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
             }
+            Type::Code => unreachable!(),
         }
     }
 }
@@ -1836,6 +1851,7 @@ impl std::fmt::Debug for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element:?}")
             }
+            Type::Code => write!(f, "Code"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 1e341d34510..4432a3f9e07 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -667,6 +667,7 @@ pub enum Keyword {
     Mod,
     Mut,
     Pub,
+    Quote,
     Return,
     ReturnData,
     String,
@@ -710,6 +711,7 @@ impl fmt::Display for Keyword {
             Keyword::Mod => write!(f, "mod"),
             Keyword::Mut => write!(f, "mut"),
             Keyword::Pub => write!(f, "pub"),
+            Keyword::Quote => write!(f, "quote"),
             Keyword::Return => write!(f, "return"),
             Keyword::ReturnData => write!(f, "return_data"),
             Keyword::String => write!(f, "str"),
@@ -756,6 +758,7 @@ impl Keyword {
             "mod" => Keyword::Mod,
             "mut" => Keyword::Mut,
             "pub" => Keyword::Pub,
+            "quote" => Keyword::Quote,
             "return" => Keyword::Return,
             "return_data" => Keyword::ReturnData,
             "str" => Keyword::String,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index d4fe2e0a2aa..9b0f57a7d39 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -516,6 +516,7 @@ impl<'interner> Monomorphizer<'interner> {
                 unreachable!("Encountered HirExpression::MethodCall during monomorphization {hir_method_call:?}")
             }
             HirExpression::Error => unreachable!("Encountered Error node during monomorphization"),
+            HirExpression::Quote(_) => unreachable!("quote expression remaining in runtime code"),
         };
 
         Ok(expr)
@@ -954,6 +955,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::Forall(_, _) | HirType::Constant(_) | HirType::Error => {
                 unreachable!("Unexpected type {} found", typ)
             }
+            HirType::Code => unreachable!("Tried to translate Code type into runtime code"),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 4e184e1391b..09e0cb04d26 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1672,6 +1672,7 @@ enum TypeMethodKey {
     Tuple,
     Function,
     Generic,
+    Code,
 }
 
 fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
@@ -1691,6 +1692,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::Tuple(_) => Some(Tuple),
         Type::Function(_, _, _) => Some(Function),
         Type::NamedGeneric(_, _) => Some(Generic),
+        Type::Code => Some(Code),
         Type::MutableReference(element) => get_type_method_key(element),
         Type::Alias(alias, _) => get_type_method_key(&alias.borrow().typ),
 
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index f2e22da3c2c..dec1c7aa9ce 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1150,7 +1150,8 @@ where
             nothing().boxed()
         },
         lambdas::lambda(expr_parser.clone()),
-        block(statement).map(ExpressionKind::Block),
+        block(statement.clone()).map(ExpressionKind::Block),
+        quote(statement),
         variable(),
         literal(),
     ))
@@ -1175,6 +1176,19 @@ where
         .labelled(ParsingRuleLabel::Atom)
 }
 
+fn quote<'a, P>(statement: P) -> impl NoirParser<ExpressionKind> + 'a
+where
+    P: NoirParser<StatementKind> + 'a,
+{
+    keyword(Keyword::Quote).ignore_then(block(statement)).validate(|block, span, emit| {
+        emit(ParserError::with_reason(
+            ParserErrorReason::ExperimentalFeature("quoted expressions"),
+            span,
+        ));
+        ExpressionKind::Quote(block)
+    })
+}
+
 fn tuple<P>(expr_parser: P) -> impl NoirParser<Expression>
 where
     P: ExprParser,
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index ffb8dea5a9d..6cf69a2309d 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -1,4 +1,7 @@
-use noirc_frontend::{token::Token, ArrayLiteral, Expression, ExpressionKind, Literal, UnaryOp};
+use noirc_frontend::{
+    macros_api::Span, token::Token, ArrayLiteral, BlockExpression, Expression, ExpressionKind,
+    Literal, UnaryOp,
+};
 
 use crate::visitor::{
     expr::{format_brackets, format_parens, NewlineMode},
@@ -20,11 +23,7 @@ pub(crate) fn rewrite(
     shape: Shape,
 ) -> String {
     match kind {
-        ExpressionKind::Block(block) => {
-            let mut visitor = visitor.fork();
-            visitor.visit_block(block, span);
-            visitor.finish()
-        }
+        ExpressionKind::Block(block) => rewrite_block(visitor, block, span),
         ExpressionKind::Prefix(prefix) => {
             let op = match prefix.operator {
                 UnaryOp::Minus => "-",
@@ -159,6 +158,13 @@ pub(crate) fn rewrite(
             visitor.format_if(*if_expr)
         }
         ExpressionKind::Lambda(_) | ExpressionKind::Variable(_) => visitor.slice(span).to_string(),
+        ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
         ExpressionKind::Error => unreachable!(),
     }
 }
+
+fn rewrite_block(visitor: &FmtVisitor, block: BlockExpression, span: Span) -> String {
+    let mut visitor = visitor.fork();
+    visitor.visit_block(block, span);
+    visitor.finish()
+}
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 26edb7a2af6..cffb0c20cd5 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -178,8 +178,9 @@ impl AbiType {
             | Type::TypeVariable(_, _)
             | Type::NamedGeneric(..)
             | Type::Forall(..)
+            | Type::Code
             | Type::Slice(_)
-            | Type::Function(_, _, _) => unreachable!("Type cannot be used in the abi"),
+            | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
             Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
             Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"),
         }

From 77f03815e5682adceb055e29140840d196feb338 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 20 Mar 2024 16:00:01 +0000
Subject: [PATCH 102/416] chore: fix up benchmarking scripts (#4601)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR gets our criterion benchmarks working again after we made
various changes to the repo structure. I've also changed it to bench
proving times.

I'm going to follow up with changes to run this in CI.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/benches/criterion.rs | 24 +++++++++++++++++-------
 tooling/nargo_cli/benches/utils.rs     | 13 +++++++++----
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/tooling/nargo_cli/benches/criterion.rs b/tooling/nargo_cli/benches/criterion.rs
index a7b094fd7aa..9f67bcffd6e 100644
--- a/tooling/nargo_cli/benches/criterion.rs
+++ b/tooling/nargo_cli/benches/criterion.rs
@@ -1,9 +1,10 @@
 //! Select representative tests to bench with criterion
 use assert_cmd::prelude::{CommandCargoExt, OutputAssertExt};
 use criterion::{criterion_group, criterion_main, Criterion};
+
 use paste::paste;
 use pprof::criterion::{Output, PProfProfiler};
-use std::process::Command;
+use std::{process::Command, time::Duration};
 include!("./utils.rs");
 
 macro_rules! criterion_command {
@@ -15,9 +16,11 @@ macro_rules! criterion_command {
                     let mut cmd = Command::cargo_bin("nargo").unwrap();
                     cmd.arg("--program-dir").arg(&test_program_dir);
                     cmd.arg($command_string);
+                    cmd.arg("--force");
 
-                    c.bench_function(&format!("{}_{}", test_program_dir.file_name().unwrap().to_str().unwrap(), $command_string), |b| {
-                        b.iter(|| cmd.assert())
+                    let benchmark_name = format!("{}_{}", test_program_dir.file_name().unwrap().to_str().unwrap(), $command_string);
+                    c.bench_function(&benchmark_name, |b| {
+                        b.iter(|| cmd.assert().success())
                     });
                 }
             }
@@ -25,9 +28,16 @@ macro_rules! criterion_command {
     };
 }
 criterion_command!(execution, "execute");
+criterion_command!(prove, "prove");
+
+criterion_group! {
+    name = execution_benches;
+    config = Criterion::default().sample_size(20).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = criterion_selected_tests_execution
+}
 criterion_group! {
-    name = benches;
-    config = Criterion::default().sample_size(20).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets =  criterion_selected_tests_execution
+    name = prove_benches;
+    config = Criterion::default().sample_size(10).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = criterion_selected_tests_prove
 }
-criterion_main!(benches);
+criterion_main!(execution_benches, prove_benches);
diff --git a/tooling/nargo_cli/benches/utils.rs b/tooling/nargo_cli/benches/utils.rs
index 52a6b718c44..47968f7e898 100644
--- a/tooling/nargo_cli/benches/utils.rs
+++ b/tooling/nargo_cli/benches/utils.rs
@@ -4,11 +4,16 @@ use std::path::PathBuf;
 fn get_selected_tests() -> Vec<PathBuf> {
     let manifest_dir = match std::env::var("CARGO_MANIFEST_DIR") {
         Ok(dir) => PathBuf::from(dir),
-        Err(_) => std::env::current_dir().unwrap().join("crates").join("nargo_cli"),
+        Err(_) => std::env::current_dir().unwrap(),
     };
-    let test_dir = manifest_dir.join("tests").join("execution_success");
+    let test_dir = manifest_dir
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .join("test_programs")
+        .join("execution_success");
 
-    let selected_tests =
-        vec!["8_integration", "sha256_blocks", "struct", "eddsa", "regression", "regression_2099"];
+    let selected_tests = vec!["struct", "eddsa", "regression"];
     selected_tests.into_iter().map(|t| test_dir.join(t)).collect()
 }

From 3d1e45680b07e3c98432b7bfb8ff32c4437dc5f8 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Wed, 20 Mar 2024 16:18:51 -0400
Subject: [PATCH 103/416] chore: regression test for #2540 (#4602)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/2540

## Summary\*

Fixed in https://github.com/noir-lang/noir/pull/4504

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/tests.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 98dbc42adcd..6f92cb52a88 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1256,6 +1256,22 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         assert_eq!(get_program_errors(src).len(), 2);
     }
 
+    // Regression for #2540
+    #[test]
+    fn for_loop_over_array() {
+        let src = r#"
+            fn hello<N>(_array: [u1; N]) {
+                for _ in 0..N {}
+            }
+
+            fn main() {
+                let array: [u1; 2] = [0, 1];
+                hello(array);
+            }
+        "#;
+        assert_eq!(get_program_errors(src).len(), 0);
+    }
+
     // Regression for #4545
     #[test]
     fn type_aliases_in_main() {

From 13eb71b8de44eb6aad9c37943ad06fc73db589f5 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Thu, 21 Mar 2024 06:31:07 -0400
Subject: [PATCH 104/416] feat: Sync from aztec-packages (#4581)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
feat(acir)!: Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
feat!: automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
END_COMMIT_OVERRIDE

---------

Co-authored-by: vezenovm <mvezenov@gmail.com>
Co-authored-by: Álvaro Rodríguez <sirasistant@gmail.com>
---
 .aztec-sync-commit                            |    2 +-
 Cargo.lock                                    |   27 +-
 acvm-repo/acir/codegen/acir.cpp               | 1792 +++++++++--------
 acvm-repo/acir/codegen/witness.cpp            |  130 +-
 acvm-repo/acir/src/circuit/mod.rs             |   76 +-
 acvm-repo/acir/src/lib.rs                     |   10 +-
 acvm-repo/acir/src/native_types/mod.rs        |    4 +-
 .../acir/src/native_types/witness_stack.rs    |   64 +
 .../acir/tests/test_program_serialization.rs  |  119 +-
 acvm-repo/acvm_js/src/compression.rs          |   15 +-
 acvm-repo/acvm_js/src/execute.rs              |   18 +-
 acvm-repo/acvm_js/src/public_witness.rs       |   47 +-
 acvm-repo/acvm_js/test/shared/addition.ts     |   10 +-
 .../test/shared/complex_foreign_call.ts       |   14 +-
 .../test/shared/fixed_base_scalar_mul.ts      |    6 +-
 acvm-repo/acvm_js/test/shared/foreign_call.ts |    8 +-
 acvm-repo/acvm_js/test/shared/memory_op.ts    |    8 +-
 acvm-repo/acvm_js/test/shared/pedersen.ts     |    4 +-
 .../acvm_js/test/shared/schnorr_verify.ts     |   24 +-
 .../test/shared/witness_compression.ts        |   22 +-
 acvm-repo/brillig/src/opcodes.rs              |    7 +
 acvm-repo/brillig_vm/src/lib.rs               |   55 +
 aztec_macros/Cargo.toml                       |    2 +
 aztec_macros/src/lib.rs                       |   58 +-
 aztec_macros/src/transforms/mod.rs            |    1 +
 aztec_macros/src/transforms/note_interface.rs |  583 ++++++
 aztec_macros/src/utils/ast_utils.rs           |   12 +-
 aztec_macros/src/utils/errors.rs              |   10 +-
 compiler/noirc_driver/src/contract.rs         |    8 +-
 compiler/noirc_driver/src/lib.rs              |    9 +-
 compiler/noirc_driver/src/program.rs          |    8 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |   27 +-
 .../src/brillig/brillig_ir/debug_show.rs      |   18 +
 .../src/brillig/brillig_ir/instructions.rs    |   19 +
 compiler/noirc_evaluator/src/errors.rs        |    4 +-
 .../src/hir/def_collector/dc_mod.rs           |    7 +-
 .../noirc_frontend/src/hir/def_map/mod.rs     |    3 +-
 .../src/hir/type_check/errors.rs              |    4 +-
 .../noirc_frontend/src/hir/type_check/expr.rs |    2 +-
 compiler/noirc_frontend/src/lib.rs            |    1 +
 .../unconstrained_oracle/Nargo.toml           |    2 +
 .../unconstrained_ref/Nargo.toml              |    2 +
 .../unconstrained_ref/src/main.nr             |    2 +-
 .../witness_compression/Nargo.toml            |    7 +
 .../witness_compression/Prover.toml           |    2 +
 .../witness_compression/src/main.nr           |    7 +
 tooling/acvm_cli/src/cli/execute_cmd.rs       |    6 +-
 tooling/acvm_cli/src/errors.rs                |    2 +-
 tooling/backend_interface/src/proof_system.rs |   39 +-
 .../backend_interface/src/smart_contract.rs   |   15 +-
 tooling/bb_abstraction_leaks/build.rs         |    2 +-
 tooling/debugger/src/dap.rs                   |    9 +-
 tooling/nargo/src/artifacts/contract.rs       |    8 +-
 tooling/nargo/src/artifacts/program.rs        |   24 +-
 tooling/nargo/src/ops/optimize.rs             |   19 +-
 tooling/nargo/src/ops/test.rs                 |   15 +-
 tooling/nargo/src/ops/transform.rs            |   25 +-
 .../nargo_cli/src/cli/codegen_verifier_cmd.rs |    8 +-
 tooling/nargo_cli/src/cli/compile_cmd.rs      |    4 +-
 tooling/nargo_cli/src/cli/debug_cmd.rs        |    2 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |    3 +-
 tooling/nargo_cli/src/cli/fs/program.rs       |    9 +-
 tooling/nargo_cli/src/cli/fs/witness.rs       |    6 +-
 tooling/nargo_cli/src/cli/info_cmd.rs         |    8 +-
 tooling/nargo_cli/src/cli/prove_cmd.rs        |    5 +-
 tooling/nargo_cli/src/cli/verify_cmd.rs       |    2 +-
 tooling/nargo_cli/src/errors.rs               |    6 +-
 .../noir_js_backend_barretenberg/package.json |    2 +-
 .../noir_js_backend_barretenberg/src/index.ts |    1 -
 yarn.lock                                     |   10 +-
 70 files changed, 2305 insertions(+), 1185 deletions(-)
 create mode 100644 acvm-repo/acir/src/native_types/witness_stack.rs
 create mode 100644 aztec_macros/src/transforms/note_interface.rs
 create mode 100644 test_programs/execution_success/witness_compression/Nargo.toml
 create mode 100644 test_programs/execution_success/witness_compression/Prover.toml
 create mode 100644 test_programs/execution_success/witness_compression/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 973bfd1534b..ead8f3147c0 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-82f8cf5eba9deacdab43ad4ef95dbf27dd1c11c7
+208abbb63af4c9a3f25d723fe1c49e82aa461061
diff --git a/Cargo.lock b/Cargo.lock
index 37bf5135468..99c19417267 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -439,6 +439,7 @@ dependencies = [
  "iter-extended",
  "noirc_errors",
  "noirc_frontend",
+ "regex",
 ]
 
 [[package]]
@@ -2655,9 +2656,9 @@ checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "memmap2"
@@ -3822,14 +3823,14 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.1"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2eae68fc220f7cf2532e4494aded17545fce192d59cd996e0fe7887f4ceb575"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.3.3",
- "regex-syntax 0.7.4",
+ "regex-automata 0.4.5",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -3846,10 +3847,16 @@ name = "regex-automata"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39354c10dd07468c2e73926b23bb9c2caca74c5501e38a35da70406f1d923310"
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.7.4",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -3864,6 +3871,12 @@ version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
 
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
 [[package]]
 name = "region"
 version = "3.0.0"
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 11afd44ed6d..ca281d89637 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -3,7 +3,7 @@
 #include "serde.hpp"
 #include "bincode.hpp"
 
-namespace Circuit {
+namespace Program {
 
     struct BinaryFieldOp {
 
@@ -152,7 +152,7 @@ namespace Circuit {
     };
 
     struct HeapArray {
-        Circuit::MemoryAddress pointer;
+        Program::MemoryAddress pointer;
         uint64_t size;
 
         friend bool operator==(const HeapArray&, const HeapArray&);
@@ -161,8 +161,8 @@ namespace Circuit {
     };
 
     struct HeapVector {
-        Circuit::MemoryAddress pointer;
-        Circuit::MemoryAddress size;
+        Program::MemoryAddress pointer;
+        Program::MemoryAddress size;
 
         friend bool operator==(const HeapVector&, const HeapVector&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -172,8 +172,8 @@ namespace Circuit {
     struct BlackBoxOp {
 
         struct Sha256 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Sha256&, const Sha256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -181,8 +181,8 @@ namespace Circuit {
         };
 
         struct Blake2s {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -190,8 +190,8 @@ namespace Circuit {
         };
 
         struct Blake3 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -199,8 +199,8 @@ namespace Circuit {
         };
 
         struct Keccak256 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -208,8 +208,8 @@ namespace Circuit {
         };
 
         struct Keccakf1600 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -217,11 +217,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256k1 {
-            Circuit::HeapVector hashed_msg;
-            Circuit::HeapArray public_key_x;
-            Circuit::HeapArray public_key_y;
-            Circuit::HeapArray signature;
-            Circuit::MemoryAddress result;
+            Program::HeapVector hashed_msg;
+            Program::HeapArray public_key_x;
+            Program::HeapArray public_key_y;
+            Program::HeapArray signature;
+            Program::MemoryAddress result;
 
             friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -229,11 +229,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256r1 {
-            Circuit::HeapVector hashed_msg;
-            Circuit::HeapArray public_key_x;
-            Circuit::HeapArray public_key_y;
-            Circuit::HeapArray signature;
-            Circuit::MemoryAddress result;
+            Program::HeapVector hashed_msg;
+            Program::HeapArray public_key_x;
+            Program::HeapArray public_key_y;
+            Program::HeapArray signature;
+            Program::MemoryAddress result;
 
             friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -241,11 +241,11 @@ namespace Circuit {
         };
 
         struct SchnorrVerify {
-            Circuit::MemoryAddress public_key_x;
-            Circuit::MemoryAddress public_key_y;
-            Circuit::HeapVector message;
-            Circuit::HeapVector signature;
-            Circuit::MemoryAddress result;
+            Program::MemoryAddress public_key_x;
+            Program::MemoryAddress public_key_y;
+            Program::HeapVector message;
+            Program::HeapVector signature;
+            Program::MemoryAddress result;
 
             friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -253,9 +253,9 @@ namespace Circuit {
         };
 
         struct PedersenCommitment {
-            Circuit::HeapVector inputs;
-            Circuit::MemoryAddress domain_separator;
-            Circuit::HeapArray output;
+            Program::HeapVector inputs;
+            Program::MemoryAddress domain_separator;
+            Program::HeapArray output;
 
             friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -263,9 +263,9 @@ namespace Circuit {
         };
 
         struct PedersenHash {
-            Circuit::HeapVector inputs;
-            Circuit::MemoryAddress domain_separator;
-            Circuit::MemoryAddress output;
+            Program::HeapVector inputs;
+            Program::MemoryAddress domain_separator;
+            Program::MemoryAddress output;
 
             friend bool operator==(const PedersenHash&, const PedersenHash&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -273,9 +273,9 @@ namespace Circuit {
         };
 
         struct FixedBaseScalarMul {
-            Circuit::MemoryAddress low;
-            Circuit::MemoryAddress high;
-            Circuit::HeapArray result;
+            Program::MemoryAddress low;
+            Program::MemoryAddress high;
+            Program::HeapArray result;
 
             friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -283,11 +283,11 @@ namespace Circuit {
         };
 
         struct EmbeddedCurveAdd {
-            Circuit::MemoryAddress input1_x;
-            Circuit::MemoryAddress input1_y;
-            Circuit::MemoryAddress input2_x;
-            Circuit::MemoryAddress input2_y;
-            Circuit::HeapArray result;
+            Program::MemoryAddress input1_x;
+            Program::MemoryAddress input1_y;
+            Program::MemoryAddress input2_x;
+            Program::MemoryAddress input2_y;
+            Program::HeapArray result;
 
             friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -295,9 +295,9 @@ namespace Circuit {
         };
 
         struct BigIntAdd {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntAdd&, const BigIntAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -305,9 +305,9 @@ namespace Circuit {
         };
 
         struct BigIntSub {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntSub&, const BigIntSub&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -315,9 +315,9 @@ namespace Circuit {
         };
 
         struct BigIntMul {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntMul&, const BigIntMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -325,9 +325,9 @@ namespace Circuit {
         };
 
         struct BigIntDiv {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntDiv&, const BigIntDiv&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -335,9 +335,9 @@ namespace Circuit {
         };
 
         struct BigIntFromLeBytes {
-            Circuit::HeapVector inputs;
-            Circuit::HeapVector modulus;
-            Circuit::MemoryAddress output;
+            Program::HeapVector inputs;
+            Program::HeapVector modulus;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -345,8 +345,8 @@ namespace Circuit {
         };
 
         struct BigIntToLeBytes {
-            Circuit::MemoryAddress input;
-            Circuit::HeapVector output;
+            Program::MemoryAddress input;
+            Program::HeapVector output;
 
             friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -354,9 +354,9 @@ namespace Circuit {
         };
 
         struct Poseidon2Permutation {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
-            Circuit::MemoryAddress len;
+            Program::HeapVector message;
+            Program::HeapArray output;
+            Program::MemoryAddress len;
 
             friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -364,9 +364,9 @@ namespace Circuit {
         };
 
         struct Sha256Compression {
-            Circuit::HeapVector input;
-            Circuit::HeapVector hash_values;
-            Circuit::HeapArray output;
+            Program::HeapVector input;
+            Program::HeapVector hash_values;
+            Program::HeapArray output;
 
             friend bool operator==(const Sha256Compression&, const Sha256Compression&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -391,7 +391,7 @@ namespace Circuit {
         };
 
         struct Array {
-            std::vector<Circuit::HeapValueType> value_types;
+            std::vector<Program::HeapValueType> value_types;
             uint64_t size;
 
             friend bool operator==(const Array&, const Array&);
@@ -400,7 +400,7 @@ namespace Circuit {
         };
 
         struct Vector {
-            std::vector<Circuit::HeapValueType> value_types;
+            std::vector<Program::HeapValueType> value_types;
 
             friend bool operator==(const Vector&, const Vector&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -425,7 +425,7 @@ namespace Circuit {
     struct ValueOrArray {
 
         struct MemoryAddress {
-            Circuit::MemoryAddress value;
+            Program::MemoryAddress value;
 
             friend bool operator==(const MemoryAddress&, const MemoryAddress&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -433,7 +433,7 @@ namespace Circuit {
         };
 
         struct HeapArray {
-            Circuit::HeapArray value;
+            Program::HeapArray value;
 
             friend bool operator==(const HeapArray&, const HeapArray&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -441,7 +441,7 @@ namespace Circuit {
         };
 
         struct HeapVector {
-            Circuit::HeapVector value;
+            Program::HeapVector value;
 
             friend bool operator==(const HeapVector&, const HeapVector&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -458,10 +458,10 @@ namespace Circuit {
     struct BrilligOpcode {
 
         struct BinaryFieldOp {
-            Circuit::MemoryAddress destination;
-            Circuit::BinaryFieldOp op;
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
+            Program::MemoryAddress destination;
+            Program::BinaryFieldOp op;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
 
             friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -469,11 +469,11 @@ namespace Circuit {
         };
 
         struct BinaryIntOp {
-            Circuit::MemoryAddress destination;
-            Circuit::BinaryIntOp op;
+            Program::MemoryAddress destination;
+            Program::BinaryIntOp op;
             uint32_t bit_size;
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
 
             friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -481,8 +481,8 @@ namespace Circuit {
         };
 
         struct Cast {
-            Circuit::MemoryAddress destination;
-            Circuit::MemoryAddress source;
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source;
             uint32_t bit_size;
 
             friend bool operator==(const Cast&, const Cast&);
@@ -491,7 +491,7 @@ namespace Circuit {
         };
 
         struct JumpIfNot {
-            Circuit::MemoryAddress condition;
+            Program::MemoryAddress condition;
             uint64_t location;
 
             friend bool operator==(const JumpIfNot&, const JumpIfNot&);
@@ -500,7 +500,7 @@ namespace Circuit {
         };
 
         struct JumpIf {
-            Circuit::MemoryAddress condition;
+            Program::MemoryAddress condition;
             uint64_t location;
 
             friend bool operator==(const JumpIf&, const JumpIf&);
@@ -517,7 +517,7 @@ namespace Circuit {
         };
 
         struct CalldataCopy {
-            Circuit::MemoryAddress destination_address;
+            Program::MemoryAddress destination_address;
             uint64_t size;
             uint64_t offset;
 
@@ -535,9 +535,9 @@ namespace Circuit {
         };
 
         struct Const {
-            Circuit::MemoryAddress destination;
+            Program::MemoryAddress destination;
             uint32_t bit_size;
-            Circuit::Value value;
+            Program::Value value;
 
             friend bool operator==(const Const&, const Const&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -552,10 +552,10 @@ namespace Circuit {
 
         struct ForeignCall {
             std::string function;
-            std::vector<Circuit::ValueOrArray> destinations;
-            std::vector<Circuit::HeapValueType> destination_value_types;
-            std::vector<Circuit::ValueOrArray> inputs;
-            std::vector<Circuit::HeapValueType> input_value_types;
+            std::vector<Program::ValueOrArray> destinations;
+            std::vector<Program::HeapValueType> destination_value_types;
+            std::vector<Program::ValueOrArray> inputs;
+            std::vector<Program::HeapValueType> input_value_types;
 
             friend bool operator==(const ForeignCall&, const ForeignCall&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -563,17 +563,28 @@ namespace Circuit {
         };
 
         struct Mov {
-            Circuit::MemoryAddress destination;
-            Circuit::MemoryAddress source;
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source;
 
             friend bool operator==(const Mov&, const Mov&);
             std::vector<uint8_t> bincodeSerialize() const;
             static Mov bincodeDeserialize(std::vector<uint8_t>);
         };
 
+        struct ConditionalMov {
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source_a;
+            Program::MemoryAddress source_b;
+            Program::MemoryAddress condition;
+
+            friend bool operator==(const ConditionalMov&, const ConditionalMov&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static ConditionalMov bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Load {
-            Circuit::MemoryAddress destination;
-            Circuit::MemoryAddress source_pointer;
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source_pointer;
 
             friend bool operator==(const Load&, const Load&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -581,8 +592,8 @@ namespace Circuit {
         };
 
         struct Store {
-            Circuit::MemoryAddress destination_pointer;
-            Circuit::MemoryAddress source;
+            Program::MemoryAddress destination_pointer;
+            Program::MemoryAddress source;
 
             friend bool operator==(const Store&, const Store&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -590,7 +601,7 @@ namespace Circuit {
         };
 
         struct BlackBox {
-            Circuit::BlackBoxOp value;
+            Program::BlackBoxOp value;
 
             friend bool operator==(const BlackBox&, const BlackBox&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -612,7 +623,7 @@ namespace Circuit {
             static Stop bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, Load, Store, BlackBox, Trap, Stop> value;
+        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, ConditionalMov, Load, Store, BlackBox, Trap, Stop> value;
 
         friend bool operator==(const BrilligOpcode&, const BrilligOpcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -628,7 +639,7 @@ namespace Circuit {
     };
 
     struct FunctionInput {
-        Circuit::Witness witness;
+        Program::Witness witness;
         uint32_t num_bits;
 
         friend bool operator==(const FunctionInput&, const FunctionInput&);
@@ -639,9 +650,9 @@ namespace Circuit {
     struct BlackBoxFuncCall {
 
         struct AND {
-            Circuit::FunctionInput lhs;
-            Circuit::FunctionInput rhs;
-            Circuit::Witness output;
+            Program::FunctionInput lhs;
+            Program::FunctionInput rhs;
+            Program::Witness output;
 
             friend bool operator==(const AND&, const AND&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -649,9 +660,9 @@ namespace Circuit {
         };
 
         struct XOR {
-            Circuit::FunctionInput lhs;
-            Circuit::FunctionInput rhs;
-            Circuit::Witness output;
+            Program::FunctionInput lhs;
+            Program::FunctionInput rhs;
+            Program::Witness output;
 
             friend bool operator==(const XOR&, const XOR&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -659,7 +670,7 @@ namespace Circuit {
         };
 
         struct RANGE {
-            Circuit::FunctionInput input;
+            Program::FunctionInput input;
 
             friend bool operator==(const RANGE&, const RANGE&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -667,8 +678,8 @@ namespace Circuit {
         };
 
         struct SHA256 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const SHA256&, const SHA256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -676,8 +687,8 @@ namespace Circuit {
         };
 
         struct Blake2s {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -685,8 +696,8 @@ namespace Circuit {
         };
 
         struct Blake3 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -694,11 +705,11 @@ namespace Circuit {
         };
 
         struct SchnorrVerify {
-            Circuit::FunctionInput public_key_x;
-            Circuit::FunctionInput public_key_y;
-            std::vector<Circuit::FunctionInput> signature;
-            std::vector<Circuit::FunctionInput> message;
-            Circuit::Witness output;
+            Program::FunctionInput public_key_x;
+            Program::FunctionInput public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> message;
+            Program::Witness output;
 
             friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -706,9 +717,9 @@ namespace Circuit {
         };
 
         struct PedersenCommitment {
-            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> inputs;
             uint32_t domain_separator;
-            std::array<Circuit::Witness, 2> outputs;
+            std::array<Program::Witness, 2> outputs;
 
             friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -716,9 +727,9 @@ namespace Circuit {
         };
 
         struct PedersenHash {
-            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> inputs;
             uint32_t domain_separator;
-            Circuit::Witness output;
+            Program::Witness output;
 
             friend bool operator==(const PedersenHash&, const PedersenHash&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -726,11 +737,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256k1 {
-            std::vector<Circuit::FunctionInput> public_key_x;
-            std::vector<Circuit::FunctionInput> public_key_y;
-            std::vector<Circuit::FunctionInput> signature;
-            std::vector<Circuit::FunctionInput> hashed_message;
-            Circuit::Witness output;
+            std::vector<Program::FunctionInput> public_key_x;
+            std::vector<Program::FunctionInput> public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> hashed_message;
+            Program::Witness output;
 
             friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -738,11 +749,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256r1 {
-            std::vector<Circuit::FunctionInput> public_key_x;
-            std::vector<Circuit::FunctionInput> public_key_y;
-            std::vector<Circuit::FunctionInput> signature;
-            std::vector<Circuit::FunctionInput> hashed_message;
-            Circuit::Witness output;
+            std::vector<Program::FunctionInput> public_key_x;
+            std::vector<Program::FunctionInput> public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> hashed_message;
+            Program::Witness output;
 
             friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -750,9 +761,9 @@ namespace Circuit {
         };
 
         struct FixedBaseScalarMul {
-            Circuit::FunctionInput low;
-            Circuit::FunctionInput high;
-            std::array<Circuit::Witness, 2> outputs;
+            Program::FunctionInput low;
+            Program::FunctionInput high;
+            std::array<Program::Witness, 2> outputs;
 
             friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -760,11 +771,11 @@ namespace Circuit {
         };
 
         struct EmbeddedCurveAdd {
-            Circuit::FunctionInput input1_x;
-            Circuit::FunctionInput input1_y;
-            Circuit::FunctionInput input2_x;
-            Circuit::FunctionInput input2_y;
-            std::array<Circuit::Witness, 2> outputs;
+            Program::FunctionInput input1_x;
+            Program::FunctionInput input1_y;
+            Program::FunctionInput input2_x;
+            Program::FunctionInput input2_y;
+            std::array<Program::Witness, 2> outputs;
 
             friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -772,8 +783,8 @@ namespace Circuit {
         };
 
         struct Keccak256 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -781,9 +792,9 @@ namespace Circuit {
         };
 
         struct Keccak256VariableLength {
-            std::vector<Circuit::FunctionInput> inputs;
-            Circuit::FunctionInput var_message_size;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            Program::FunctionInput var_message_size;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccak256VariableLength&, const Keccak256VariableLength&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -791,8 +802,8 @@ namespace Circuit {
         };
 
         struct Keccakf1600 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -800,10 +811,10 @@ namespace Circuit {
         };
 
         struct RecursiveAggregation {
-            std::vector<Circuit::FunctionInput> verification_key;
-            std::vector<Circuit::FunctionInput> proof;
-            std::vector<Circuit::FunctionInput> public_inputs;
-            Circuit::FunctionInput key_hash;
+            std::vector<Program::FunctionInput> verification_key;
+            std::vector<Program::FunctionInput> proof;
+            std::vector<Program::FunctionInput> public_inputs;
+            Program::FunctionInput key_hash;
 
             friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -851,7 +862,7 @@ namespace Circuit {
         };
 
         struct BigIntFromLeBytes {
-            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> inputs;
             std::vector<uint8_t> modulus;
             uint32_t output;
 
@@ -862,7 +873,7 @@ namespace Circuit {
 
         struct BigIntToLeBytes {
             uint32_t input;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -870,8 +881,8 @@ namespace Circuit {
         };
 
         struct Poseidon2Permutation {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
             uint32_t len;
 
             friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
@@ -880,9 +891,9 @@ namespace Circuit {
         };
 
         struct Sha256Compression {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::FunctionInput> hash_values;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> hash_values;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Sha256Compression&, const Sha256Compression&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -905,8 +916,8 @@ namespace Circuit {
     };
 
     struct Expression {
-        std::vector<std::tuple<std::string, Circuit::Witness, Circuit::Witness>> mul_terms;
-        std::vector<std::tuple<std::string, Circuit::Witness>> linear_combinations;
+        std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
+        std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
         std::string q_c;
 
         friend bool operator==(const Expression&, const Expression&);
@@ -917,7 +928,7 @@ namespace Circuit {
     struct BrilligInputs {
 
         struct Single {
-            Circuit::Expression value;
+            Program::Expression value;
 
             friend bool operator==(const Single&, const Single&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -925,7 +936,7 @@ namespace Circuit {
         };
 
         struct Array {
-            std::vector<Circuit::Expression> value;
+            std::vector<Program::Expression> value;
 
             friend bool operator==(const Array&, const Array&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -933,7 +944,7 @@ namespace Circuit {
         };
 
         struct MemoryArray {
-            Circuit::BlockId value;
+            Program::BlockId value;
 
             friend bool operator==(const MemoryArray&, const MemoryArray&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -950,7 +961,7 @@ namespace Circuit {
     struct BrilligOutputs {
 
         struct Simple {
-            Circuit::Witness value;
+            Program::Witness value;
 
             friend bool operator==(const Simple&, const Simple&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -958,7 +969,7 @@ namespace Circuit {
         };
 
         struct Array {
-            std::vector<Circuit::Witness> value;
+            std::vector<Program::Witness> value;
 
             friend bool operator==(const Array&, const Array&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -973,10 +984,10 @@ namespace Circuit {
     };
 
     struct Brillig {
-        std::vector<Circuit::BrilligInputs> inputs;
-        std::vector<Circuit::BrilligOutputs> outputs;
-        std::vector<Circuit::BrilligOpcode> bytecode;
-        std::optional<Circuit::Expression> predicate;
+        std::vector<Program::BrilligInputs> inputs;
+        std::vector<Program::BrilligOutputs> outputs;
+        std::vector<Program::BrilligOpcode> bytecode;
+        std::optional<Program::Expression> predicate;
 
         friend bool operator==(const Brillig&, const Brillig&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -986,8 +997,8 @@ namespace Circuit {
     struct Directive {
 
         struct ToLeRadix {
-            Circuit::Expression a;
-            std::vector<Circuit::Witness> b;
+            Program::Expression a;
+            std::vector<Program::Witness> b;
             uint32_t radix;
 
             friend bool operator==(const ToLeRadix&, const ToLeRadix&);
@@ -1003,9 +1014,9 @@ namespace Circuit {
     };
 
     struct MemOp {
-        Circuit::Expression operation;
-        Circuit::Expression index;
-        Circuit::Expression value;
+        Program::Expression operation;
+        Program::Expression index;
+        Program::Expression value;
 
         friend bool operator==(const MemOp&, const MemOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1015,7 +1026,7 @@ namespace Circuit {
     struct Opcode {
 
         struct AssertZero {
-            Circuit::Expression value;
+            Program::Expression value;
 
             friend bool operator==(const AssertZero&, const AssertZero&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1023,7 +1034,7 @@ namespace Circuit {
         };
 
         struct BlackBoxFuncCall {
-            Circuit::BlackBoxFuncCall value;
+            Program::BlackBoxFuncCall value;
 
             friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1031,7 +1042,7 @@ namespace Circuit {
         };
 
         struct Directive {
-            Circuit::Directive value;
+            Program::Directive value;
 
             friend bool operator==(const Directive&, const Directive&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1039,7 +1050,7 @@ namespace Circuit {
         };
 
         struct Brillig {
-            Circuit::Brillig value;
+            Program::Brillig value;
 
             friend bool operator==(const Brillig&, const Brillig&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1047,9 +1058,9 @@ namespace Circuit {
         };
 
         struct MemoryOp {
-            Circuit::BlockId block_id;
-            Circuit::MemOp op;
-            std::optional<Circuit::Expression> predicate;
+            Program::BlockId block_id;
+            Program::MemOp op;
+            std::optional<Program::Expression> predicate;
 
             friend bool operator==(const MemoryOp&, const MemoryOp&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1057,8 +1068,8 @@ namespace Circuit {
         };
 
         struct MemoryInit {
-            Circuit::BlockId block_id;
-            std::vector<Circuit::Witness> init;
+            Program::BlockId block_id;
+            std::vector<Program::Witness> init;
 
             friend bool operator==(const MemoryInit&, const MemoryInit&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1067,8 +1078,8 @@ namespace Circuit {
 
         struct Call {
             uint32_t id;
-            std::vector<Circuit::Witness> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::Witness> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Call&, const Call&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1132,7 +1143,7 @@ namespace Circuit {
     };
 
     struct PublicInputs {
-        std::vector<Circuit::Witness> value;
+        std::vector<Program::Witness> value;
 
         friend bool operator==(const PublicInputs&, const PublicInputs&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1141,12 +1152,12 @@ namespace Circuit {
 
     struct Circuit {
         uint32_t current_witness_index;
-        std::vector<Circuit::Opcode> opcodes;
-        Circuit::ExpressionWidth expression_width;
-        std::vector<Circuit::Witness> private_parameters;
-        Circuit::PublicInputs public_parameters;
-        Circuit::PublicInputs return_values;
-        std::vector<std::tuple<Circuit::OpcodeLocation, std::string>> assert_messages;
+        std::vector<Program::Opcode> opcodes;
+        Program::ExpressionWidth expression_width;
+        std::vector<Program::Witness> private_parameters;
+        Program::PublicInputs public_parameters;
+        Program::PublicInputs return_values;
+        std::vector<std::tuple<Program::OpcodeLocation, std::string>> assert_messages;
         bool recursive;
 
         friend bool operator==(const Circuit&, const Circuit&);
@@ -1154,10 +1165,18 @@ namespace Circuit {
         static Circuit bincodeDeserialize(std::vector<uint8_t>);
     };
 
-} // end of namespace Circuit
+    struct Program {
+        std::vector<Program::Circuit> functions;
 
+        friend bool operator==(const Program&, const Program&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Program bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+} // end of namespace Program
 
-namespace Circuit {
+
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -1179,11 +1198,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp>::serialize(const Circuit::BinaryFieldOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp>::serialize(const Program::BinaryFieldOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -1191,15 +1210,15 @@ void serde::Serializable<Circuit::BinaryFieldOp>::serialize(const Circuit::Binar
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp serde::Deserializable<Circuit::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
+Program::BinaryFieldOp serde::Deserializable<Program::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BinaryFieldOp obj;
+    Program::BinaryFieldOp obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Add &lhs, const BinaryFieldOp::Add &rhs) {
         return true;
@@ -1220,21 +1239,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Add>::serialize(const Circuit::BinaryFieldOp::Add &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Add>::serialize(const Program::BinaryFieldOp::Add &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Add serde::Deserializable<Circuit::BinaryFieldOp::Add>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Add obj;
+Program::BinaryFieldOp::Add serde::Deserializable<Program::BinaryFieldOp::Add>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Add obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Sub &lhs, const BinaryFieldOp::Sub &rhs) {
         return true;
@@ -1255,21 +1274,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Sub>::serialize(const Circuit::BinaryFieldOp::Sub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Sub>::serialize(const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Sub serde::Deserializable<Circuit::BinaryFieldOp::Sub>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Sub obj;
+Program::BinaryFieldOp::Sub serde::Deserializable<Program::BinaryFieldOp::Sub>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Sub obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Mul &lhs, const BinaryFieldOp::Mul &rhs) {
         return true;
@@ -1290,21 +1309,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Mul>::serialize(const Circuit::BinaryFieldOp::Mul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Mul>::serialize(const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Mul serde::Deserializable<Circuit::BinaryFieldOp::Mul>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Mul obj;
+Program::BinaryFieldOp::Mul serde::Deserializable<Program::BinaryFieldOp::Mul>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Mul obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Div &lhs, const BinaryFieldOp::Div &rhs) {
         return true;
@@ -1325,21 +1344,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Div>::serialize(const Circuit::BinaryFieldOp::Div &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Div>::serialize(const Program::BinaryFieldOp::Div &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Div serde::Deserializable<Circuit::BinaryFieldOp::Div>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Div obj;
+Program::BinaryFieldOp::Div serde::Deserializable<Program::BinaryFieldOp::Div>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Div obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) {
         return true;
@@ -1360,21 +1379,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::IntegerDiv>::serialize(const Circuit::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::IntegerDiv>::serialize(const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::IntegerDiv serde::Deserializable<Circuit::BinaryFieldOp::IntegerDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::IntegerDiv obj;
+Program::BinaryFieldOp::IntegerDiv serde::Deserializable<Program::BinaryFieldOp::IntegerDiv>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::IntegerDiv obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) {
         return true;
@@ -1395,21 +1414,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Equals>::serialize(const Circuit::BinaryFieldOp::Equals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Equals>::serialize(const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Equals serde::Deserializable<Circuit::BinaryFieldOp::Equals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Equals obj;
+Program::BinaryFieldOp::Equals serde::Deserializable<Program::BinaryFieldOp::Equals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Equals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) {
         return true;
@@ -1430,21 +1449,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::LessThan>::serialize(const Circuit::BinaryFieldOp::LessThan &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::LessThan>::serialize(const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::LessThan serde::Deserializable<Circuit::BinaryFieldOp::LessThan>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::LessThan obj;
+Program::BinaryFieldOp::LessThan serde::Deserializable<Program::BinaryFieldOp::LessThan>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::LessThan obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) {
         return true;
@@ -1465,21 +1484,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::LessThanEquals>::serialize(const Circuit::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::LessThanEquals>::serialize(const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::LessThanEquals serde::Deserializable<Circuit::BinaryFieldOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::LessThanEquals obj;
+Program::BinaryFieldOp::LessThanEquals serde::Deserializable<Program::BinaryFieldOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::LessThanEquals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -1501,11 +1520,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp>::serialize(const Circuit::BinaryIntOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp>::serialize(const Program::BinaryIntOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -1513,15 +1532,15 @@ void serde::Serializable<Circuit::BinaryIntOp>::serialize(const Circuit::BinaryI
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp serde::Deserializable<Circuit::BinaryIntOp>::deserialize(Deserializer &deserializer) {
+Program::BinaryIntOp serde::Deserializable<Program::BinaryIntOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BinaryIntOp obj;
+    Program::BinaryIntOp obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Add &lhs, const BinaryIntOp::Add &rhs) {
         return true;
@@ -1542,21 +1561,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Add>::serialize(const Circuit::BinaryIntOp::Add &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Add>::serialize(const Program::BinaryIntOp::Add &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Add serde::Deserializable<Circuit::BinaryIntOp::Add>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Add obj;
+Program::BinaryIntOp::Add serde::Deserializable<Program::BinaryIntOp::Add>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Add obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Sub &lhs, const BinaryIntOp::Sub &rhs) {
         return true;
@@ -1577,21 +1596,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Sub>::serialize(const Circuit::BinaryIntOp::Sub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Sub>::serialize(const Program::BinaryIntOp::Sub &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Sub serde::Deserializable<Circuit::BinaryIntOp::Sub>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Sub obj;
+Program::BinaryIntOp::Sub serde::Deserializable<Program::BinaryIntOp::Sub>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Sub obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Mul &lhs, const BinaryIntOp::Mul &rhs) {
         return true;
@@ -1612,21 +1631,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Mul>::serialize(const Circuit::BinaryIntOp::Mul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Mul>::serialize(const Program::BinaryIntOp::Mul &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Mul serde::Deserializable<Circuit::BinaryIntOp::Mul>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Mul obj;
+Program::BinaryIntOp::Mul serde::Deserializable<Program::BinaryIntOp::Mul>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Mul obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Div &lhs, const BinaryIntOp::Div &rhs) {
         return true;
@@ -1647,21 +1666,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Div>::serialize(const Circuit::BinaryIntOp::Div &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Div>::serialize(const Program::BinaryIntOp::Div &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Div serde::Deserializable<Circuit::BinaryIntOp::Div>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Div obj;
+Program::BinaryIntOp::Div serde::Deserializable<Program::BinaryIntOp::Div>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Div obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Equals &lhs, const BinaryIntOp::Equals &rhs) {
         return true;
@@ -1682,21 +1701,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Equals>::serialize(const Circuit::BinaryIntOp::Equals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Equals>::serialize(const Program::BinaryIntOp::Equals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Equals serde::Deserializable<Circuit::BinaryIntOp::Equals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Equals obj;
+Program::BinaryIntOp::Equals serde::Deserializable<Program::BinaryIntOp::Equals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Equals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::LessThan &lhs, const BinaryIntOp::LessThan &rhs) {
         return true;
@@ -1717,21 +1736,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::LessThan>::serialize(const Circuit::BinaryIntOp::LessThan &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::LessThan>::serialize(const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::LessThan serde::Deserializable<Circuit::BinaryIntOp::LessThan>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::LessThan obj;
+Program::BinaryIntOp::LessThan serde::Deserializable<Program::BinaryIntOp::LessThan>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::LessThan obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, const BinaryIntOp::LessThanEquals &rhs) {
         return true;
@@ -1752,21 +1771,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::LessThanEquals>::serialize(const Circuit::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::LessThanEquals>::serialize(const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::LessThanEquals serde::Deserializable<Circuit::BinaryIntOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::LessThanEquals obj;
+Program::BinaryIntOp::LessThanEquals serde::Deserializable<Program::BinaryIntOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::LessThanEquals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::And &lhs, const BinaryIntOp::And &rhs) {
         return true;
@@ -1787,21 +1806,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::And>::serialize(const Circuit::BinaryIntOp::And &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::And>::serialize(const Program::BinaryIntOp::And &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::And serde::Deserializable<Circuit::BinaryIntOp::And>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::And obj;
+Program::BinaryIntOp::And serde::Deserializable<Program::BinaryIntOp::And>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::And obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) {
         return true;
@@ -1822,21 +1841,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Or>::serialize(const Circuit::BinaryIntOp::Or &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Or>::serialize(const Program::BinaryIntOp::Or &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Or serde::Deserializable<Circuit::BinaryIntOp::Or>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Or obj;
+Program::BinaryIntOp::Or serde::Deserializable<Program::BinaryIntOp::Or>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Or obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Xor &lhs, const BinaryIntOp::Xor &rhs) {
         return true;
@@ -1857,21 +1876,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Xor>::serialize(const Circuit::BinaryIntOp::Xor &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Xor>::serialize(const Program::BinaryIntOp::Xor &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Xor serde::Deserializable<Circuit::BinaryIntOp::Xor>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Xor obj;
+Program::BinaryIntOp::Xor serde::Deserializable<Program::BinaryIntOp::Xor>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Xor obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Shl &lhs, const BinaryIntOp::Shl &rhs) {
         return true;
@@ -1892,21 +1911,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Shl>::serialize(const Circuit::BinaryIntOp::Shl &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Shl>::serialize(const Program::BinaryIntOp::Shl &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Shl serde::Deserializable<Circuit::BinaryIntOp::Shl>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Shl obj;
+Program::BinaryIntOp::Shl serde::Deserializable<Program::BinaryIntOp::Shl>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Shl obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Shr &lhs, const BinaryIntOp::Shr &rhs) {
         return true;
@@ -1927,21 +1946,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Shr>::serialize(const Circuit::BinaryIntOp::Shr &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Shr>::serialize(const Program::BinaryIntOp::Shr &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Shr serde::Deserializable<Circuit::BinaryIntOp::Shr>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Shr obj;
+Program::BinaryIntOp::Shr serde::Deserializable<Program::BinaryIntOp::Shr>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Shr obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall &lhs, const BlackBoxFuncCall &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -1963,11 +1982,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall>::serialize(const Circuit::BlackBoxFuncCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall>::serialize(const Program::BlackBoxFuncCall &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -1975,15 +1994,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall>::serialize(const Circuit::Bl
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall serde::Deserializable<Circuit::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
+Program::BlackBoxFuncCall serde::Deserializable<Program::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BlackBoxFuncCall obj;
+    Program::BlackBoxFuncCall obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::AND &lhs, const BlackBoxFuncCall::AND &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2007,11 +2026,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::AND>::serialize(const Circuit::BlackBoxFuncCall::AND &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::AND>::serialize(const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2019,15 +2038,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::AND>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::AND serde::Deserializable<Circuit::BlackBoxFuncCall::AND>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::AND obj;
+Program::BlackBoxFuncCall::AND serde::Deserializable<Program::BlackBoxFuncCall::AND>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::AND obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::XOR &lhs, const BlackBoxFuncCall::XOR &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2051,11 +2070,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::XOR>::serialize(const Circuit::BlackBoxFuncCall::XOR &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::XOR>::serialize(const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2063,15 +2082,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::XOR>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::XOR serde::Deserializable<Circuit::BlackBoxFuncCall::XOR>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::XOR obj;
+Program::BlackBoxFuncCall::XOR serde::Deserializable<Program::BlackBoxFuncCall::XOR>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::XOR obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, const BlackBoxFuncCall::RANGE &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -2093,23 +2112,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::RANGE>::serialize(const Circuit::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::RANGE>::serialize(const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::RANGE serde::Deserializable<Circuit::BlackBoxFuncCall::RANGE>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::RANGE obj;
+Program::BlackBoxFuncCall::RANGE serde::Deserializable<Program::BlackBoxFuncCall::RANGE>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::RANGE obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::SHA256 &lhs, const BlackBoxFuncCall::SHA256 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2132,25 +2151,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::SHA256>::serialize(const Circuit::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::SHA256>::serialize(const Program::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::SHA256 serde::Deserializable<Circuit::BlackBoxFuncCall::SHA256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::SHA256 obj;
+Program::BlackBoxFuncCall::SHA256 serde::Deserializable<Program::BlackBoxFuncCall::SHA256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::SHA256 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, const BlackBoxFuncCall::Blake2s &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2173,25 +2192,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Blake2s>::serialize(const Circuit::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Blake2s>::serialize(const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Blake2s serde::Deserializable<Circuit::BlackBoxFuncCall::Blake2s>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Blake2s obj;
+Program::BlackBoxFuncCall::Blake2s serde::Deserializable<Program::BlackBoxFuncCall::Blake2s>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Blake2s obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, const BlackBoxFuncCall::Blake3 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2214,25 +2233,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Blake3>::serialize(const Circuit::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Blake3>::serialize(const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Blake3 serde::Deserializable<Circuit::BlackBoxFuncCall::Blake3>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Blake3 obj;
+Program::BlackBoxFuncCall::Blake3 serde::Deserializable<Program::BlackBoxFuncCall::Blake3>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Blake3 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, const BlackBoxFuncCall::SchnorrVerify &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -2258,11 +2277,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::SchnorrVerify>::serialize(const Circuit::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::SchnorrVerify>::serialize(const Program::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
@@ -2272,8 +2291,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::SchnorrVerify>::serialize(co
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Circuit::BlackBoxFuncCall::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::SchnorrVerify obj;
+Program::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Program::BlackBoxFuncCall::SchnorrVerify>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::SchnorrVerify obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
@@ -2282,7 +2301,7 @@ Circuit::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Circuit::BlackBox
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, const BlackBoxFuncCall::PedersenCommitment &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2306,11 +2325,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::serialize(const Circuit::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::PedersenCommitment>::serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -2318,15 +2337,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::seriali
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::PedersenCommitment serde::Deserializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::PedersenCommitment obj;
+Program::BlackBoxFuncCall::PedersenCommitment serde::Deserializable<Program::BlackBoxFuncCall::PedersenCommitment>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::PedersenCommitment obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, const BlackBoxFuncCall::PedersenHash &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2350,11 +2369,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenHash>::serialize(const Circuit::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::PedersenHash>::serialize(const Program::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2362,15 +2381,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenHash>::serialize(con
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::PedersenHash serde::Deserializable<Circuit::BlackBoxFuncCall::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::PedersenHash obj;
+Program::BlackBoxFuncCall::PedersenHash serde::Deserializable<Program::BlackBoxFuncCall::PedersenHash>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::PedersenHash obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -2396,11 +2415,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256k1>::serialize(const Circuit::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::EcdsaSecp256k1>::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
@@ -2410,8 +2429,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256k1>::serialize(c
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxFuncCall::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EcdsaSecp256k1 obj;
+Program::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable<Program::BlackBoxFuncCall::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::EcdsaSecp256k1 obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
@@ -2420,7 +2439,7 @@ Circuit::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBo
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256r1 &lhs, const BlackBoxFuncCall::EcdsaSecp256r1 &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -2446,11 +2465,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256r1>::serialize(const Circuit::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::EcdsaSecp256r1>::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
@@ -2460,8 +2479,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256r1>::serialize(c
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxFuncCall::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EcdsaSecp256r1 obj;
+Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Program::BlackBoxFuncCall::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::EcdsaSecp256r1 obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
@@ -2470,7 +2489,7 @@ Circuit::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBo
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::FixedBaseScalarMul &lhs, const BlackBoxFuncCall::FixedBaseScalarMul &rhs) {
         if (!(lhs.low == rhs.low)) { return false; }
@@ -2494,11 +2513,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::FixedBaseScalarMul>::serialize(const Circuit::BlackBoxFuncCall::FixedBaseScalarMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::FixedBaseScalarMul>::serialize(const Program::BlackBoxFuncCall::FixedBaseScalarMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
     serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -2506,15 +2525,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::FixedBaseScalarMul>::seriali
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::FixedBaseScalarMul serde::Deserializable<Circuit::BlackBoxFuncCall::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::FixedBaseScalarMul obj;
+Program::BlackBoxFuncCall::FixedBaseScalarMul serde::Deserializable<Program::BlackBoxFuncCall::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::FixedBaseScalarMul obj;
     obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
     obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) {
         if (!(lhs.input1_x == rhs.input1_x)) { return false; }
@@ -2540,11 +2559,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize(const Circuit::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
     serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
     serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
@@ -2554,8 +2573,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxFuncCall::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EmbeddedCurveAdd obj;
+Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Program::BlackBoxFuncCall::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::EmbeddedCurveAdd obj;
     obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
     obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
     obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
@@ -2564,7 +2583,7 @@ Circuit::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Circuit::Black
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2587,25 +2606,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Keccak256>::serialize(const Circuit::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Keccak256>::serialize(const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Keccak256 serde::Deserializable<Circuit::BlackBoxFuncCall::Keccak256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Keccak256 obj;
+Program::BlackBoxFuncCall::Keccak256 serde::Deserializable<Program::BlackBoxFuncCall::Keccak256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Keccak256 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccak256VariableLength &lhs, const BlackBoxFuncCall::Keccak256VariableLength &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2629,11 +2648,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Keccak256VariableLength>::serialize(const Circuit::BlackBoxFuncCall::Keccak256VariableLength &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Keccak256VariableLength>::serialize(const Program::BlackBoxFuncCall::Keccak256VariableLength &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.var_message_size)>::serialize(obj.var_message_size, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -2641,15 +2660,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::Keccak256VariableLength>::se
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Keccak256VariableLength serde::Deserializable<Circuit::BlackBoxFuncCall::Keccak256VariableLength>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Keccak256VariableLength obj;
+Program::BlackBoxFuncCall::Keccak256VariableLength serde::Deserializable<Program::BlackBoxFuncCall::Keccak256VariableLength>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Keccak256VariableLength obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.var_message_size = serde::Deserializable<decltype(obj.var_message_size)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, const BlackBoxFuncCall::Keccakf1600 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2672,25 +2691,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Keccakf1600>::serialize(const Circuit::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Keccakf1600>::serialize(const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Keccakf1600 serde::Deserializable<Circuit::BlackBoxFuncCall::Keccakf1600>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Keccakf1600 obj;
+Program::BlackBoxFuncCall::Keccakf1600 serde::Deserializable<Program::BlackBoxFuncCall::Keccakf1600>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Keccakf1600 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, const BlackBoxFuncCall::RecursiveAggregation &rhs) {
         if (!(lhs.verification_key == rhs.verification_key)) { return false; }
@@ -2715,11 +2734,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::RecursiveAggregation>::serialize(const Circuit::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::RecursiveAggregation>::serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.verification_key)>::serialize(obj.verification_key, serializer);
     serde::Serializable<decltype(obj.proof)>::serialize(obj.proof, serializer);
     serde::Serializable<decltype(obj.public_inputs)>::serialize(obj.public_inputs, serializer);
@@ -2728,8 +2747,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::RecursiveAggregation>::seria
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Circuit::BlackBoxFuncCall::RecursiveAggregation>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::RecursiveAggregation obj;
+Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Program::BlackBoxFuncCall::RecursiveAggregation>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::RecursiveAggregation obj;
     obj.verification_key = serde::Deserializable<decltype(obj.verification_key)>::deserialize(deserializer);
     obj.proof = serde::Deserializable<decltype(obj.proof)>::deserialize(deserializer);
     obj.public_inputs = serde::Deserializable<decltype(obj.public_inputs)>::deserialize(deserializer);
@@ -2737,7 +2756,7 @@ Circuit::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Circuit::B
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, const BlackBoxFuncCall::BigIntAdd &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2761,11 +2780,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntAdd>::serialize(const Circuit::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntAdd>::serialize(const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2773,15 +2792,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntAdd>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntAdd obj;
+Program::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Program::BlackBoxFuncCall::BigIntAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntAdd obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, const BlackBoxFuncCall::BigIntSub &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2805,11 +2824,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntSub>::serialize(const Circuit::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntSub>::serialize(const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2817,15 +2836,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntSub>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntSub serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntSub>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntSub obj;
+Program::BlackBoxFuncCall::BigIntSub serde::Deserializable<Program::BlackBoxFuncCall::BigIntSub>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, const BlackBoxFuncCall::BigIntMul &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2849,11 +2868,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntMul>::serialize(const Circuit::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntMul>::serialize(const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2861,15 +2880,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntMul>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntMul serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntMul obj;
+Program::BlackBoxFuncCall::BigIntMul serde::Deserializable<Program::BlackBoxFuncCall::BigIntMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntMul obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, const BlackBoxFuncCall::BigIntDiv &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2893,11 +2912,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntDiv>::serialize(const Circuit::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntDiv>::serialize(const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2905,15 +2924,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntDiv>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntDiv serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntDiv obj;
+Program::BlackBoxFuncCall::BigIntDiv serde::Deserializable<Program::BlackBoxFuncCall::BigIntDiv>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntDiv obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, const BlackBoxFuncCall::BigIntFromLeBytes &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2937,11 +2956,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::serialize(const Circuit::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntFromLeBytes>::serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.modulus)>::serialize(obj.modulus, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2949,15 +2968,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::serializ
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntFromLeBytes obj;
+Program::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable<Program::BlackBoxFuncCall::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntFromLeBytes obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.modulus = serde::Deserializable<decltype(obj.modulus)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, const BlackBoxFuncCall::BigIntToLeBytes &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -2980,25 +2999,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntToLeBytes>::serialize(const Circuit::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntToLeBytes>::serialize(const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntToLeBytes obj;
+Program::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable<Program::BlackBoxFuncCall::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntToLeBytes obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, const BlackBoxFuncCall::Poseidon2Permutation &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3022,11 +3041,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::serialize(const Circuit::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Poseidon2Permutation>::serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
     serde::Serializable<decltype(obj.len)>::serialize(obj.len, serializer);
@@ -3034,15 +3053,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::seria
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Poseidon2Permutation obj;
+Program::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable<Program::BlackBoxFuncCall::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Poseidon2Permutation obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     obj.len = serde::Deserializable<decltype(obj.len)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, const BlackBoxFuncCall::Sha256Compression &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3066,11 +3085,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Sha256Compression>::serialize(const Circuit::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Sha256Compression>::serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.hash_values)>::serialize(obj.hash_values, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -3078,15 +3097,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::Sha256Compression>::serializ
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Sha256Compression serde::Deserializable<Circuit::BlackBoxFuncCall::Sha256Compression>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Sha256Compression obj;
+Program::BlackBoxFuncCall::Sha256Compression serde::Deserializable<Program::BlackBoxFuncCall::Sha256Compression>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Sha256Compression obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.hash_values = serde::Deserializable<decltype(obj.hash_values)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -3108,11 +3127,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp>::serialize(const Circuit::BlackBoxOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp>::serialize(const Program::BlackBoxOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -3120,15 +3139,15 @@ void serde::Serializable<Circuit::BlackBoxOp>::serialize(const Circuit::BlackBox
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp serde::Deserializable<Circuit::BlackBoxOp>::deserialize(Deserializer &deserializer) {
+Program::BlackBoxOp serde::Deserializable<Program::BlackBoxOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BlackBoxOp obj;
+    Program::BlackBoxOp obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3151,25 +3170,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Sha256>::serialize(const Circuit::BlackBoxOp::Sha256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Sha256>::serialize(const Program::BlackBoxOp::Sha256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Sha256 serde::Deserializable<Circuit::BlackBoxOp::Sha256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Sha256 obj;
+Program::BlackBoxOp::Sha256 serde::Deserializable<Program::BlackBoxOp::Sha256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Sha256 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Blake2s &lhs, const BlackBoxOp::Blake2s &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3192,25 +3211,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Blake2s>::serialize(const Circuit::BlackBoxOp::Blake2s &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Blake2s>::serialize(const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Blake2s serde::Deserializable<Circuit::BlackBoxOp::Blake2s>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Blake2s obj;
+Program::BlackBoxOp::Blake2s serde::Deserializable<Program::BlackBoxOp::Blake2s>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Blake2s obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3233,25 +3252,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Blake3>::serialize(const Circuit::BlackBoxOp::Blake3 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Blake3>::serialize(const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Blake3 serde::Deserializable<Circuit::BlackBoxOp::Blake3>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Blake3 obj;
+Program::BlackBoxOp::Blake3 serde::Deserializable<Program::BlackBoxOp::Blake3>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Blake3 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3274,25 +3293,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Keccak256>::serialize(const Circuit::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Keccak256>::serialize(const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Keccak256 serde::Deserializable<Circuit::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Keccak256 obj;
+Program::BlackBoxOp::Keccak256 serde::Deserializable<Program::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Keccak256 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3315,25 +3334,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Keccakf1600>::serialize(const Circuit::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Keccakf1600>::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Keccakf1600 serde::Deserializable<Circuit::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Keccakf1600 obj;
+Program::BlackBoxOp::Keccakf1600 serde::Deserializable<Program::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Keccakf1600 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) {
         if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
@@ -3359,11 +3378,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256k1>::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
@@ -3373,8 +3392,8 @@ void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EcdsaSecp256k1 obj;
+Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EcdsaSecp256k1 obj;
     obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
@@ -3383,7 +3402,7 @@ Circuit::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxOp::E
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) {
         if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
@@ -3409,11 +3428,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256r1>::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
@@ -3423,8 +3442,8 @@ void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EcdsaSecp256r1 obj;
+Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EcdsaSecp256r1 obj;
     obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
@@ -3433,7 +3452,7 @@ Circuit::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxOp::E
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -3459,11 +3478,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::SchnorrVerify>::serialize(const Circuit::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::SchnorrVerify>::serialize(const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
@@ -3473,8 +3492,8 @@ void serde::Serializable<Circuit::BlackBoxOp::SchnorrVerify>::serialize(const Ci
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::SchnorrVerify obj;
+Program::BlackBoxOp::SchnorrVerify serde::Deserializable<Program::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::SchnorrVerify obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
@@ -3483,7 +3502,7 @@ Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::Sc
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3507,11 +3526,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(const Circuit::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::PedersenCommitment>::serialize(const Program::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3519,15 +3538,15 @@ void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(con
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::PedersenCommitment serde::Deserializable<Circuit::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::PedersenCommitment obj;
+Program::BlackBoxOp::PedersenCommitment serde::Deserializable<Program::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::PedersenCommitment obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3551,11 +3570,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Circuit::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::PedersenHash>::serialize(const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3563,15 +3582,15 @@ void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Cir
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::PedersenHash serde::Deserializable<Circuit::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::PedersenHash obj;
+Program::BlackBoxOp::PedersenHash serde::Deserializable<Program::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::PedersenHash obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, const BlackBoxOp::FixedBaseScalarMul &rhs) {
         if (!(lhs.low == rhs.low)) { return false; }
@@ -3595,11 +3614,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::serialize(const Circuit::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::FixedBaseScalarMul>::serialize(const Program::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
     serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
     serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
@@ -3607,15 +3626,15 @@ void serde::Serializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::serialize(con
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::FixedBaseScalarMul obj;
+Program::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Program::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::FixedBaseScalarMul obj;
     obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
     obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
     obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) {
         if (!(lhs.input1_x == rhs.input1_x)) { return false; }
@@ -3641,11 +3660,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Circuit::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
     serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
     serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
@@ -3655,8 +3674,8 @@ void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EmbeddedCurveAdd obj;
+Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Program::BlackBoxOp::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EmbeddedCurveAdd obj;
     obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
     obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
     obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
@@ -3665,7 +3684,7 @@ Circuit::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxOp:
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, const BlackBoxOp::BigIntAdd &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3689,11 +3708,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntAdd>::serialize(const Circuit::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntAdd>::serialize(const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3701,15 +3720,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntAdd>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntAdd serde::Deserializable<Circuit::BlackBoxOp::BigIntAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntAdd obj;
+Program::BlackBoxOp::BigIntAdd serde::Deserializable<Program::BlackBoxOp::BigIntAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntAdd obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntSub &lhs, const BlackBoxOp::BigIntSub &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3733,11 +3752,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntSub>::serialize(const Circuit::BlackBoxOp::BigIntSub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntSub>::serialize(const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3745,15 +3764,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntSub>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntSub serde::Deserializable<Circuit::BlackBoxOp::BigIntSub>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntSub obj;
+Program::BlackBoxOp::BigIntSub serde::Deserializable<Program::BlackBoxOp::BigIntSub>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntMul &lhs, const BlackBoxOp::BigIntMul &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3777,11 +3796,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntMul>::serialize(const Circuit::BlackBoxOp::BigIntMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntMul>::serialize(const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3789,15 +3808,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntMul>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntMul serde::Deserializable<Circuit::BlackBoxOp::BigIntMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntMul obj;
+Program::BlackBoxOp::BigIntMul serde::Deserializable<Program::BlackBoxOp::BigIntMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntMul obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, const BlackBoxOp::BigIntDiv &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3821,11 +3840,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntDiv>::serialize(const Circuit::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntDiv>::serialize(const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3833,15 +3852,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntDiv>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntDiv serde::Deserializable<Circuit::BlackBoxOp::BigIntDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntDiv obj;
+Program::BlackBoxOp::BigIntDiv serde::Deserializable<Program::BlackBoxOp::BigIntDiv>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntDiv obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, const BlackBoxOp::BigIntFromLeBytes &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3865,11 +3884,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::serialize(const Circuit::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntFromLeBytes>::serialize(const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.modulus)>::serialize(obj.modulus, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3877,15 +3896,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::serialize(cons
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntFromLeBytes serde::Deserializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntFromLeBytes obj;
+Program::BlackBoxOp::BigIntFromLeBytes serde::Deserializable<Program::BlackBoxOp::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntFromLeBytes obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.modulus = serde::Deserializable<decltype(obj.modulus)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, const BlackBoxOp::BigIntToLeBytes &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -3908,25 +3927,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntToLeBytes>::serialize(const Circuit::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntToLeBytes>::serialize(const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntToLeBytes serde::Deserializable<Circuit::BlackBoxOp::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntToLeBytes obj;
+Program::BlackBoxOp::BigIntToLeBytes serde::Deserializable<Program::BlackBoxOp::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntToLeBytes obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, const BlackBoxOp::Poseidon2Permutation &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3950,11 +3969,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Poseidon2Permutation>::serialize(const Circuit::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Poseidon2Permutation>::serialize(const Program::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
     serde::Serializable<decltype(obj.len)>::serialize(obj.len, serializer);
@@ -3962,15 +3981,15 @@ void serde::Serializable<Circuit::BlackBoxOp::Poseidon2Permutation>::serialize(c
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Poseidon2Permutation serde::Deserializable<Circuit::BlackBoxOp::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Poseidon2Permutation obj;
+Program::BlackBoxOp::Poseidon2Permutation serde::Deserializable<Program::BlackBoxOp::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Poseidon2Permutation obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     obj.len = serde::Deserializable<decltype(obj.len)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, const BlackBoxOp::Sha256Compression &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -3994,11 +4013,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Sha256Compression>::serialize(const Circuit::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Sha256Compression>::serialize(const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.hash_values)>::serialize(obj.hash_values, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -4006,15 +4025,15 @@ void serde::Serializable<Circuit::BlackBoxOp::Sha256Compression>::serialize(cons
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Sha256Compression serde::Deserializable<Circuit::BlackBoxOp::Sha256Compression>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Sha256Compression obj;
+Program::BlackBoxOp::Sha256Compression serde::Deserializable<Program::BlackBoxOp::Sha256Compression>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Sha256Compression obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.hash_values = serde::Deserializable<decltype(obj.hash_values)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlockId &lhs, const BlockId &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4036,11 +4055,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlockId>::serialize(const Circuit::BlockId &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlockId>::serialize(const Program::BlockId &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -4048,15 +4067,15 @@ void serde::Serializable<Circuit::BlockId>::serialize(const Circuit::BlockId &ob
 
 template <>
 template <typename Deserializer>
-Circuit::BlockId serde::Deserializable<Circuit::BlockId>::deserialize(Deserializer &deserializer) {
+Program::BlockId serde::Deserializable<Program::BlockId>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BlockId obj;
+    Program::BlockId obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Brillig &lhs, const Brillig &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -4081,11 +4100,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Brillig>::serialize(const Circuit::Brillig &obj, Serializer &serializer) {
+void serde::Serializable<Program::Brillig>::serialize(const Program::Brillig &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -4096,9 +4115,9 @@ void serde::Serializable<Circuit::Brillig>::serialize(const Circuit::Brillig &ob
 
 template <>
 template <typename Deserializer>
-Circuit::Brillig serde::Deserializable<Circuit::Brillig>::deserialize(Deserializer &deserializer) {
+Program::Brillig serde::Deserializable<Program::Brillig>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Brillig obj;
+    Program::Brillig obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     obj.bytecode = serde::Deserializable<decltype(obj.bytecode)>::deserialize(deserializer);
@@ -4107,7 +4126,7 @@ Circuit::Brillig serde::Deserializable<Circuit::Brillig>::deserialize(Deserializ
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4129,11 +4148,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs>::serialize(const Circuit::BrilligInputs &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs>::serialize(const Program::BrilligInputs &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -4141,15 +4160,15 @@ void serde::Serializable<Circuit::BrilligInputs>::serialize(const Circuit::Brill
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs serde::Deserializable<Circuit::BrilligInputs>::deserialize(Deserializer &deserializer) {
+Program::BrilligInputs serde::Deserializable<Program::BrilligInputs>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BrilligInputs obj;
+    Program::BrilligInputs obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs::Single &lhs, const BrilligInputs::Single &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4171,23 +4190,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs::Single>::serialize(const Circuit::BrilligInputs::Single &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs::Single>::serialize(const Program::BrilligInputs::Single &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs::Single serde::Deserializable<Circuit::BrilligInputs::Single>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligInputs::Single obj;
+Program::BrilligInputs::Single serde::Deserializable<Program::BrilligInputs::Single>::deserialize(Deserializer &deserializer) {
+    Program::BrilligInputs::Single obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs::Array &lhs, const BrilligInputs::Array &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4209,23 +4228,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs::Array>::serialize(const Circuit::BrilligInputs::Array &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs::Array>::serialize(const Program::BrilligInputs::Array &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs::Array serde::Deserializable<Circuit::BrilligInputs::Array>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligInputs::Array obj;
+Program::BrilligInputs::Array serde::Deserializable<Program::BrilligInputs::Array>::deserialize(Deserializer &deserializer) {
+    Program::BrilligInputs::Array obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs::MemoryArray &lhs, const BrilligInputs::MemoryArray &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4247,23 +4266,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs::MemoryArray>::serialize(const Circuit::BrilligInputs::MemoryArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs::MemoryArray>::serialize(const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs::MemoryArray serde::Deserializable<Circuit::BrilligInputs::MemoryArray>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligInputs::MemoryArray obj;
+Program::BrilligInputs::MemoryArray serde::Deserializable<Program::BrilligInputs::MemoryArray>::deserialize(Deserializer &deserializer) {
+    Program::BrilligInputs::MemoryArray obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4285,11 +4304,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode>::serialize(const Circuit::BrilligOpcode &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode>::serialize(const Program::BrilligOpcode &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -4297,15 +4316,15 @@ void serde::Serializable<Circuit::BrilligOpcode>::serialize(const Circuit::Brill
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode serde::Deserializable<Circuit::BrilligOpcode>::deserialize(Deserializer &deserializer) {
+Program::BrilligOpcode serde::Deserializable<Program::BrilligOpcode>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BrilligOpcode obj;
+    Program::BrilligOpcode obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, const BrilligOpcode::BinaryFieldOp &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4330,11 +4349,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::BinaryFieldOp>::serialize(const Circuit::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::BinaryFieldOp>::serialize(const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
@@ -4343,8 +4362,8 @@ void serde::Serializable<Circuit::BrilligOpcode::BinaryFieldOp>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::BinaryFieldOp serde::Deserializable<Circuit::BrilligOpcode::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::BinaryFieldOp obj;
+Program::BrilligOpcode::BinaryFieldOp serde::Deserializable<Program::BrilligOpcode::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::BinaryFieldOp obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
@@ -4352,7 +4371,7 @@ Circuit::BrilligOpcode::BinaryFieldOp serde::Deserializable<Circuit::BrilligOpco
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::BinaryIntOp &lhs, const BrilligOpcode::BinaryIntOp &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4378,11 +4397,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::BinaryIntOp>::serialize(const Circuit::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::BinaryIntOp>::serialize(const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
     serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
@@ -4392,8 +4411,8 @@ void serde::Serializable<Circuit::BrilligOpcode::BinaryIntOp>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::BinaryIntOp serde::Deserializable<Circuit::BrilligOpcode::BinaryIntOp>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::BinaryIntOp obj;
+Program::BrilligOpcode::BinaryIntOp serde::Deserializable<Program::BrilligOpcode::BinaryIntOp>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::BinaryIntOp obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
     obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
@@ -4402,7 +4421,7 @@ Circuit::BrilligOpcode::BinaryIntOp serde::Deserializable<Circuit::BrilligOpcode
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Cast &lhs, const BrilligOpcode::Cast &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4426,11 +4445,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Cast>::serialize(const Circuit::BrilligOpcode::Cast &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Cast>::serialize(const Program::BrilligOpcode::Cast &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.source)>::serialize(obj.source, serializer);
     serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
@@ -4438,15 +4457,15 @@ void serde::Serializable<Circuit::BrilligOpcode::Cast>::serialize(const Circuit:
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Cast serde::Deserializable<Circuit::BrilligOpcode::Cast>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Cast obj;
+Program::BrilligOpcode::Cast serde::Deserializable<Program::BrilligOpcode::Cast>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Cast obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.source = serde::Deserializable<decltype(obj.source)>::deserialize(deserializer);
     obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, const BrilligOpcode::JumpIfNot &rhs) {
         if (!(lhs.condition == rhs.condition)) { return false; }
@@ -4469,25 +4488,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::JumpIfNot>::serialize(const Circuit::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::JumpIfNot>::serialize(const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.condition)>::serialize(obj.condition, serializer);
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::JumpIfNot serde::Deserializable<Circuit::BrilligOpcode::JumpIfNot>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::JumpIfNot obj;
+Program::BrilligOpcode::JumpIfNot serde::Deserializable<Program::BrilligOpcode::JumpIfNot>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::JumpIfNot obj;
     obj.condition = serde::Deserializable<decltype(obj.condition)>::deserialize(deserializer);
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::JumpIf &lhs, const BrilligOpcode::JumpIf &rhs) {
         if (!(lhs.condition == rhs.condition)) { return false; }
@@ -4510,25 +4529,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::JumpIf>::serialize(const Circuit::BrilligOpcode::JumpIf &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::JumpIf>::serialize(const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.condition)>::serialize(obj.condition, serializer);
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::JumpIf serde::Deserializable<Circuit::BrilligOpcode::JumpIf>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::JumpIf obj;
+Program::BrilligOpcode::JumpIf serde::Deserializable<Program::BrilligOpcode::JumpIf>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::JumpIf obj;
     obj.condition = serde::Deserializable<decltype(obj.condition)>::deserialize(deserializer);
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Jump &lhs, const BrilligOpcode::Jump &rhs) {
         if (!(lhs.location == rhs.location)) { return false; }
@@ -4550,23 +4569,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Jump>::serialize(const Circuit::BrilligOpcode::Jump &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Jump>::serialize(const Program::BrilligOpcode::Jump &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Jump serde::Deserializable<Circuit::BrilligOpcode::Jump>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Jump obj;
+Program::BrilligOpcode::Jump serde::Deserializable<Program::BrilligOpcode::Jump>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Jump obj;
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, const BrilligOpcode::CalldataCopy &rhs) {
         if (!(lhs.destination_address == rhs.destination_address)) { return false; }
@@ -4590,11 +4609,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::CalldataCopy>::serialize(const Circuit::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::CalldataCopy>::serialize(const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination_address)>::serialize(obj.destination_address, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
     serde::Serializable<decltype(obj.offset)>::serialize(obj.offset, serializer);
@@ -4602,15 +4621,15 @@ void serde::Serializable<Circuit::BrilligOpcode::CalldataCopy>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::CalldataCopy serde::Deserializable<Circuit::BrilligOpcode::CalldataCopy>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::CalldataCopy obj;
+Program::BrilligOpcode::CalldataCopy serde::Deserializable<Program::BrilligOpcode::CalldataCopy>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::CalldataCopy obj;
     obj.destination_address = serde::Deserializable<decltype(obj.destination_address)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     obj.offset = serde::Deserializable<decltype(obj.offset)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Call &lhs, const BrilligOpcode::Call &rhs) {
         if (!(lhs.location == rhs.location)) { return false; }
@@ -4632,23 +4651,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Call>::serialize(const Circuit::BrilligOpcode::Call &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Call>::serialize(const Program::BrilligOpcode::Call &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Call serde::Deserializable<Circuit::BrilligOpcode::Call>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Call obj;
+Program::BrilligOpcode::Call serde::Deserializable<Program::BrilligOpcode::Call>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Call obj;
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Const &lhs, const BrilligOpcode::Const &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4672,11 +4691,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Const>::serialize(const Circuit::BrilligOpcode::Const &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Const>::serialize(const Program::BrilligOpcode::Const &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
@@ -4684,15 +4703,15 @@ void serde::Serializable<Circuit::BrilligOpcode::Const>::serialize(const Circuit
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Const serde::Deserializable<Circuit::BrilligOpcode::Const>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Const obj;
+Program::BrilligOpcode::Const serde::Deserializable<Program::BrilligOpcode::Const>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Const obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Return &lhs, const BrilligOpcode::Return &rhs) {
         return true;
@@ -4713,21 +4732,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Return>::serialize(const Circuit::BrilligOpcode::Return &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Return>::serialize(const Program::BrilligOpcode::Return &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Return serde::Deserializable<Circuit::BrilligOpcode::Return>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Return obj;
+Program::BrilligOpcode::Return serde::Deserializable<Program::BrilligOpcode::Return>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Return obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::ForeignCall &lhs, const BrilligOpcode::ForeignCall &rhs) {
         if (!(lhs.function == rhs.function)) { return false; }
@@ -4753,11 +4772,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::ForeignCall>::serialize(const Circuit::BrilligOpcode::ForeignCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::ForeignCall>::serialize(const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.function)>::serialize(obj.function, serializer);
     serde::Serializable<decltype(obj.destinations)>::serialize(obj.destinations, serializer);
     serde::Serializable<decltype(obj.destination_value_types)>::serialize(obj.destination_value_types, serializer);
@@ -4767,8 +4786,8 @@ void serde::Serializable<Circuit::BrilligOpcode::ForeignCall>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::ForeignCall serde::Deserializable<Circuit::BrilligOpcode::ForeignCall>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::ForeignCall obj;
+Program::BrilligOpcode::ForeignCall serde::Deserializable<Program::BrilligOpcode::ForeignCall>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::ForeignCall obj;
     obj.function = serde::Deserializable<decltype(obj.function)>::deserialize(deserializer);
     obj.destinations = serde::Deserializable<decltype(obj.destinations)>::deserialize(deserializer);
     obj.destination_value_types = serde::Deserializable<decltype(obj.destination_value_types)>::deserialize(deserializer);
@@ -4777,7 +4796,7 @@ Circuit::BrilligOpcode::ForeignCall serde::Deserializable<Circuit::BrilligOpcode
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Mov &lhs, const BrilligOpcode::Mov &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4800,25 +4819,72 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Mov>::serialize(const Circuit::BrilligOpcode::Mov &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Mov>::serialize(const Program::BrilligOpcode::Mov &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.source)>::serialize(obj.source, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Mov serde::Deserializable<Circuit::BrilligOpcode::Mov>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Mov obj;
+Program::BrilligOpcode::Mov serde::Deserializable<Program::BrilligOpcode::Mov>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Mov obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.source = serde::Deserializable<decltype(obj.source)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
+
+    inline bool operator==(const BrilligOpcode::ConditionalMov &lhs, const BrilligOpcode::ConditionalMov &rhs) {
+        if (!(lhs.destination == rhs.destination)) { return false; }
+        if (!(lhs.source_a == rhs.source_a)) { return false; }
+        if (!(lhs.source_b == rhs.source_b)) { return false; }
+        if (!(lhs.condition == rhs.condition)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BrilligOpcode::ConditionalMov::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BrilligOpcode::ConditionalMov>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BrilligOpcode::ConditionalMov BrilligOpcode::ConditionalMov::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BrilligOpcode::ConditionalMov>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BrilligOpcode::ConditionalMov>::serialize(const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
+    serde::Serializable<decltype(obj.source_a)>::serialize(obj.source_a, serializer);
+    serde::Serializable<decltype(obj.source_b)>::serialize(obj.source_b, serializer);
+    serde::Serializable<decltype(obj.condition)>::serialize(obj.condition, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::BrilligOpcode::ConditionalMov serde::Deserializable<Program::BrilligOpcode::ConditionalMov>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::ConditionalMov obj;
+    obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
+    obj.source_a = serde::Deserializable<decltype(obj.source_a)>::deserialize(deserializer);
+    obj.source_b = serde::Deserializable<decltype(obj.source_b)>::deserialize(deserializer);
+    obj.condition = serde::Deserializable<decltype(obj.condition)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Load &lhs, const BrilligOpcode::Load &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4841,25 +4907,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Load>::serialize(const Circuit::BrilligOpcode::Load &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Load>::serialize(const Program::BrilligOpcode::Load &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.source_pointer)>::serialize(obj.source_pointer, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Load serde::Deserializable<Circuit::BrilligOpcode::Load>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Load obj;
+Program::BrilligOpcode::Load serde::Deserializable<Program::BrilligOpcode::Load>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Load obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.source_pointer = serde::Deserializable<decltype(obj.source_pointer)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Store &lhs, const BrilligOpcode::Store &rhs) {
         if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; }
@@ -4882,25 +4948,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Store>::serialize(const Circuit::BrilligOpcode::Store &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Store>::serialize(const Program::BrilligOpcode::Store &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination_pointer)>::serialize(obj.destination_pointer, serializer);
     serde::Serializable<decltype(obj.source)>::serialize(obj.source, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Store serde::Deserializable<Circuit::BrilligOpcode::Store>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Store obj;
+Program::BrilligOpcode::Store serde::Deserializable<Program::BrilligOpcode::Store>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Store obj;
     obj.destination_pointer = serde::Deserializable<decltype(obj.destination_pointer)>::deserialize(deserializer);
     obj.source = serde::Deserializable<decltype(obj.source)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::BlackBox &lhs, const BrilligOpcode::BlackBox &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4922,23 +4988,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::BlackBox>::serialize(const Circuit::BrilligOpcode::BlackBox &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::BlackBox>::serialize(const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::BlackBox serde::Deserializable<Circuit::BrilligOpcode::BlackBox>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::BlackBox obj;
+Program::BrilligOpcode::BlackBox serde::Deserializable<Program::BrilligOpcode::BlackBox>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::BlackBox obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) {
         return true;
@@ -4959,21 +5025,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Trap>::serialize(const Circuit::BrilligOpcode::Trap &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Trap>::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Trap serde::Deserializable<Circuit::BrilligOpcode::Trap>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Trap obj;
+Program::BrilligOpcode::Trap serde::Deserializable<Program::BrilligOpcode::Trap>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Trap obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Stop &lhs, const BrilligOpcode::Stop &rhs) {
         if (!(lhs.return_data_offset == rhs.return_data_offset)) { return false; }
@@ -4996,25 +5062,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Stop>::serialize(const Circuit::BrilligOpcode::Stop &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Stop>::serialize(const Program::BrilligOpcode::Stop &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.return_data_offset)>::serialize(obj.return_data_offset, serializer);
     serde::Serializable<decltype(obj.return_data_size)>::serialize(obj.return_data_size, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Stop serde::Deserializable<Circuit::BrilligOpcode::Stop>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Stop obj;
+Program::BrilligOpcode::Stop serde::Deserializable<Program::BrilligOpcode::Stop>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Stop obj;
     obj.return_data_offset = serde::Deserializable<decltype(obj.return_data_offset)>::deserialize(deserializer);
     obj.return_data_size = serde::Deserializable<decltype(obj.return_data_size)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5036,11 +5102,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOutputs>::serialize(const Circuit::BrilligOutputs &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOutputs>::serialize(const Program::BrilligOutputs &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5048,15 +5114,15 @@ void serde::Serializable<Circuit::BrilligOutputs>::serialize(const Circuit::Bril
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOutputs serde::Deserializable<Circuit::BrilligOutputs>::deserialize(Deserializer &deserializer) {
+Program::BrilligOutputs serde::Deserializable<Program::BrilligOutputs>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BrilligOutputs obj;
+    Program::BrilligOutputs obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOutputs::Simple &lhs, const BrilligOutputs::Simple &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5078,23 +5144,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOutputs::Simple>::serialize(const Circuit::BrilligOutputs::Simple &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOutputs::Simple>::serialize(const Program::BrilligOutputs::Simple &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOutputs::Simple serde::Deserializable<Circuit::BrilligOutputs::Simple>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOutputs::Simple obj;
+Program::BrilligOutputs::Simple serde::Deserializable<Program::BrilligOutputs::Simple>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOutputs::Simple obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOutputs::Array &lhs, const BrilligOutputs::Array &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5116,23 +5182,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOutputs::Array>::serialize(const Circuit::BrilligOutputs::Array &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOutputs::Array>::serialize(const Program::BrilligOutputs::Array &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOutputs::Array serde::Deserializable<Circuit::BrilligOutputs::Array>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOutputs::Array obj;
+Program::BrilligOutputs::Array serde::Deserializable<Program::BrilligOutputs::Array>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOutputs::Array obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Circuit &lhs, const Circuit &rhs) {
         if (!(lhs.current_witness_index == rhs.current_witness_index)) { return false; }
@@ -5161,11 +5227,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit &obj, Serializer &serializer) {
+void serde::Serializable<Program::Circuit>::serialize(const Program::Circuit &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.current_witness_index)>::serialize(obj.current_witness_index, serializer);
     serde::Serializable<decltype(obj.opcodes)>::serialize(obj.opcodes, serializer);
@@ -5180,9 +5246,9 @@ void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit &ob
 
 template <>
 template <typename Deserializer>
-Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializer &deserializer) {
+Program::Circuit serde::Deserializable<Program::Circuit>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Circuit obj;
+    Program::Circuit obj;
     obj.current_witness_index = serde::Deserializable<decltype(obj.current_witness_index)>::deserialize(deserializer);
     obj.opcodes = serde::Deserializable<decltype(obj.opcodes)>::deserialize(deserializer);
     obj.expression_width = serde::Deserializable<decltype(obj.expression_width)>::deserialize(deserializer);
@@ -5195,7 +5261,7 @@ Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializ
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Directive &lhs, const Directive &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5217,11 +5283,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Directive>::serialize(const Circuit::Directive &obj, Serializer &serializer) {
+void serde::Serializable<Program::Directive>::serialize(const Program::Directive &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5229,15 +5295,15 @@ void serde::Serializable<Circuit::Directive>::serialize(const Circuit::Directive
 
 template <>
 template <typename Deserializer>
-Circuit::Directive serde::Deserializable<Circuit::Directive>::deserialize(Deserializer &deserializer) {
+Program::Directive serde::Deserializable<Program::Directive>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Directive obj;
+    Program::Directive obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Directive::ToLeRadix &lhs, const Directive::ToLeRadix &rhs) {
         if (!(lhs.a == rhs.a)) { return false; }
@@ -5261,11 +5327,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Directive::ToLeRadix>::serialize(const Circuit::Directive::ToLeRadix &obj, Serializer &serializer) {
+void serde::Serializable<Program::Directive::ToLeRadix>::serialize(const Program::Directive::ToLeRadix &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.a)>::serialize(obj.a, serializer);
     serde::Serializable<decltype(obj.b)>::serialize(obj.b, serializer);
     serde::Serializable<decltype(obj.radix)>::serialize(obj.radix, serializer);
@@ -5273,15 +5339,15 @@ void serde::Serializable<Circuit::Directive::ToLeRadix>::serialize(const Circuit
 
 template <>
 template <typename Deserializer>
-Circuit::Directive::ToLeRadix serde::Deserializable<Circuit::Directive::ToLeRadix>::deserialize(Deserializer &deserializer) {
-    Circuit::Directive::ToLeRadix obj;
+Program::Directive::ToLeRadix serde::Deserializable<Program::Directive::ToLeRadix>::deserialize(Deserializer &deserializer) {
+    Program::Directive::ToLeRadix obj;
     obj.a = serde::Deserializable<decltype(obj.a)>::deserialize(deserializer);
     obj.b = serde::Deserializable<decltype(obj.b)>::deserialize(deserializer);
     obj.radix = serde::Deserializable<decltype(obj.radix)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Expression &lhs, const Expression &rhs) {
         if (!(lhs.mul_terms == rhs.mul_terms)) { return false; }
@@ -5305,11 +5371,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Expression>::serialize(const Circuit::Expression &obj, Serializer &serializer) {
+void serde::Serializable<Program::Expression>::serialize(const Program::Expression &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.mul_terms)>::serialize(obj.mul_terms, serializer);
     serde::Serializable<decltype(obj.linear_combinations)>::serialize(obj.linear_combinations, serializer);
@@ -5319,9 +5385,9 @@ void serde::Serializable<Circuit::Expression>::serialize(const Circuit::Expressi
 
 template <>
 template <typename Deserializer>
-Circuit::Expression serde::Deserializable<Circuit::Expression>::deserialize(Deserializer &deserializer) {
+Program::Expression serde::Deserializable<Program::Expression>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Expression obj;
+    Program::Expression obj;
     obj.mul_terms = serde::Deserializable<decltype(obj.mul_terms)>::deserialize(deserializer);
     obj.linear_combinations = serde::Deserializable<decltype(obj.linear_combinations)>::deserialize(deserializer);
     obj.q_c = serde::Deserializable<decltype(obj.q_c)>::deserialize(deserializer);
@@ -5329,7 +5395,7 @@ Circuit::Expression serde::Deserializable<Circuit::Expression>::deserialize(Dese
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5351,11 +5417,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ExpressionWidth>::serialize(const Circuit::ExpressionWidth &obj, Serializer &serializer) {
+void serde::Serializable<Program::ExpressionWidth>::serialize(const Program::ExpressionWidth &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5363,15 +5429,15 @@ void serde::Serializable<Circuit::ExpressionWidth>::serialize(const Circuit::Exp
 
 template <>
 template <typename Deserializer>
-Circuit::ExpressionWidth serde::Deserializable<Circuit::ExpressionWidth>::deserialize(Deserializer &deserializer) {
+Program::ExpressionWidth serde::Deserializable<Program::ExpressionWidth>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::ExpressionWidth obj;
+    Program::ExpressionWidth obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ExpressionWidth::Unbounded &lhs, const ExpressionWidth::Unbounded &rhs) {
         return true;
@@ -5392,21 +5458,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ExpressionWidth::Unbounded>::serialize(const Circuit::ExpressionWidth::Unbounded &obj, Serializer &serializer) {
+void serde::Serializable<Program::ExpressionWidth::Unbounded>::serialize(const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ExpressionWidth::Unbounded serde::Deserializable<Circuit::ExpressionWidth::Unbounded>::deserialize(Deserializer &deserializer) {
-    Circuit::ExpressionWidth::Unbounded obj;
+Program::ExpressionWidth::Unbounded serde::Deserializable<Program::ExpressionWidth::Unbounded>::deserialize(Deserializer &deserializer) {
+    Program::ExpressionWidth::Unbounded obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ExpressionWidth::Bounded &lhs, const ExpressionWidth::Bounded &rhs) {
         if (!(lhs.width == rhs.width)) { return false; }
@@ -5428,23 +5494,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ExpressionWidth::Bounded>::serialize(const Circuit::ExpressionWidth::Bounded &obj, Serializer &serializer) {
+void serde::Serializable<Program::ExpressionWidth::Bounded>::serialize(const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.width)>::serialize(obj.width, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ExpressionWidth::Bounded serde::Deserializable<Circuit::ExpressionWidth::Bounded>::deserialize(Deserializer &deserializer) {
-    Circuit::ExpressionWidth::Bounded obj;
+Program::ExpressionWidth::Bounded serde::Deserializable<Program::ExpressionWidth::Bounded>::deserialize(Deserializer &deserializer) {
+    Program::ExpressionWidth::Bounded obj;
     obj.width = serde::Deserializable<decltype(obj.width)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) {
         if (!(lhs.witness == rhs.witness)) { return false; }
@@ -5467,11 +5533,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::FunctionInput>::serialize(const Circuit::FunctionInput &obj, Serializer &serializer) {
+void serde::Serializable<Program::FunctionInput>::serialize(const Program::FunctionInput &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.witness)>::serialize(obj.witness, serializer);
     serde::Serializable<decltype(obj.num_bits)>::serialize(obj.num_bits, serializer);
@@ -5480,16 +5546,16 @@ void serde::Serializable<Circuit::FunctionInput>::serialize(const Circuit::Funct
 
 template <>
 template <typename Deserializer>
-Circuit::FunctionInput serde::Deserializable<Circuit::FunctionInput>::deserialize(Deserializer &deserializer) {
+Program::FunctionInput serde::Deserializable<Program::FunctionInput>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::FunctionInput obj;
+    Program::FunctionInput obj;
     obj.witness = serde::Deserializable<decltype(obj.witness)>::deserialize(deserializer);
     obj.num_bits = serde::Deserializable<decltype(obj.num_bits)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) {
         if (!(lhs.pointer == rhs.pointer)) { return false; }
@@ -5512,11 +5578,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapArray>::serialize(const Circuit::HeapArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapArray>::serialize(const Program::HeapArray &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.pointer)>::serialize(obj.pointer, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
@@ -5525,16 +5591,16 @@ void serde::Serializable<Circuit::HeapArray>::serialize(const Circuit::HeapArray
 
 template <>
 template <typename Deserializer>
-Circuit::HeapArray serde::Deserializable<Circuit::HeapArray>::deserialize(Deserializer &deserializer) {
+Program::HeapArray serde::Deserializable<Program::HeapArray>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::HeapArray obj;
+    Program::HeapArray obj;
     obj.pointer = serde::Deserializable<decltype(obj.pointer)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5556,11 +5622,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType>::serialize(const Circuit::HeapValueType &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType>::serialize(const Program::HeapValueType &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5568,15 +5634,15 @@ void serde::Serializable<Circuit::HeapValueType>::serialize(const Circuit::HeapV
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType serde::Deserializable<Circuit::HeapValueType>::deserialize(Deserializer &deserializer) {
+Program::HeapValueType serde::Deserializable<Program::HeapValueType>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::HeapValueType obj;
+    Program::HeapValueType obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType::Simple &lhs, const HeapValueType::Simple &rhs) {
         return true;
@@ -5597,21 +5663,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType::Simple>::serialize(const Circuit::HeapValueType::Simple &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType::Simple>::serialize(const Program::HeapValueType::Simple &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType::Simple serde::Deserializable<Circuit::HeapValueType::Simple>::deserialize(Deserializer &deserializer) {
-    Circuit::HeapValueType::Simple obj;
+Program::HeapValueType::Simple serde::Deserializable<Program::HeapValueType::Simple>::deserialize(Deserializer &deserializer) {
+    Program::HeapValueType::Simple obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType::Array &lhs, const HeapValueType::Array &rhs) {
         if (!(lhs.value_types == rhs.value_types)) { return false; }
@@ -5634,25 +5700,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType::Array>::serialize(const Circuit::HeapValueType::Array &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType::Array>::serialize(const Program::HeapValueType::Array &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value_types)>::serialize(obj.value_types, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType::Array serde::Deserializable<Circuit::HeapValueType::Array>::deserialize(Deserializer &deserializer) {
-    Circuit::HeapValueType::Array obj;
+Program::HeapValueType::Array serde::Deserializable<Program::HeapValueType::Array>::deserialize(Deserializer &deserializer) {
+    Program::HeapValueType::Array obj;
     obj.value_types = serde::Deserializable<decltype(obj.value_types)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType::Vector &lhs, const HeapValueType::Vector &rhs) {
         if (!(lhs.value_types == rhs.value_types)) { return false; }
@@ -5674,23 +5740,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType::Vector>::serialize(const Circuit::HeapValueType::Vector &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType::Vector>::serialize(const Program::HeapValueType::Vector &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value_types)>::serialize(obj.value_types, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType::Vector serde::Deserializable<Circuit::HeapValueType::Vector>::deserialize(Deserializer &deserializer) {
-    Circuit::HeapValueType::Vector obj;
+Program::HeapValueType::Vector serde::Deserializable<Program::HeapValueType::Vector>::deserialize(Deserializer &deserializer) {
+    Program::HeapValueType::Vector obj;
     obj.value_types = serde::Deserializable<decltype(obj.value_types)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) {
         if (!(lhs.pointer == rhs.pointer)) { return false; }
@@ -5713,11 +5779,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapVector>::serialize(const Circuit::HeapVector &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapVector>::serialize(const Program::HeapVector &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.pointer)>::serialize(obj.pointer, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
@@ -5726,16 +5792,16 @@ void serde::Serializable<Circuit::HeapVector>::serialize(const Circuit::HeapVect
 
 template <>
 template <typename Deserializer>
-Circuit::HeapVector serde::Deserializable<Circuit::HeapVector>::deserialize(Deserializer &deserializer) {
+Program::HeapVector serde::Deserializable<Program::HeapVector>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::HeapVector obj;
+    Program::HeapVector obj;
     obj.pointer = serde::Deserializable<decltype(obj.pointer)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const MemOp &lhs, const MemOp &rhs) {
         if (!(lhs.operation == rhs.operation)) { return false; }
@@ -5759,11 +5825,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::MemOp>::serialize(const Circuit::MemOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::MemOp>::serialize(const Program::MemOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.operation)>::serialize(obj.operation, serializer);
     serde::Serializable<decltype(obj.index)>::serialize(obj.index, serializer);
@@ -5773,9 +5839,9 @@ void serde::Serializable<Circuit::MemOp>::serialize(const Circuit::MemOp &obj, S
 
 template <>
 template <typename Deserializer>
-Circuit::MemOp serde::Deserializable<Circuit::MemOp>::deserialize(Deserializer &deserializer) {
+Program::MemOp serde::Deserializable<Program::MemOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::MemOp obj;
+    Program::MemOp obj;
     obj.operation = serde::Deserializable<decltype(obj.operation)>::deserialize(deserializer);
     obj.index = serde::Deserializable<decltype(obj.index)>::deserialize(deserializer);
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
@@ -5783,7 +5849,7 @@ Circuit::MemOp serde::Deserializable<Circuit::MemOp>::deserialize(Deserializer &
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5805,11 +5871,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::MemoryAddress>::serialize(const Circuit::MemoryAddress &obj, Serializer &serializer) {
+void serde::Serializable<Program::MemoryAddress>::serialize(const Program::MemoryAddress &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5817,15 +5883,15 @@ void serde::Serializable<Circuit::MemoryAddress>::serialize(const Circuit::Memor
 
 template <>
 template <typename Deserializer>
-Circuit::MemoryAddress serde::Deserializable<Circuit::MemoryAddress>::deserialize(Deserializer &deserializer) {
+Program::MemoryAddress serde::Deserializable<Program::MemoryAddress>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::MemoryAddress obj;
+    Program::MemoryAddress obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode &lhs, const Opcode &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5847,11 +5913,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode>::serialize(const Circuit::Opcode &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode>::serialize(const Program::Opcode &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5859,15 +5925,15 @@ void serde::Serializable<Circuit::Opcode>::serialize(const Circuit::Opcode &obj,
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode serde::Deserializable<Circuit::Opcode>::deserialize(Deserializer &deserializer) {
+Program::Opcode serde::Deserializable<Program::Opcode>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Opcode obj;
+    Program::Opcode obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5889,23 +5955,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::AssertZero>::serialize(const Circuit::Opcode::AssertZero &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::AssertZero>::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::AssertZero serde::Deserializable<Circuit::Opcode::AssertZero>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::AssertZero obj;
+Program::Opcode::AssertZero serde::Deserializable<Program::Opcode::AssertZero>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::AssertZero obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5927,23 +5993,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::BlackBoxFuncCall>::serialize(const Circuit::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::BlackBoxFuncCall>::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::BlackBoxFuncCall serde::Deserializable<Circuit::Opcode::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::BlackBoxFuncCall obj;
+Program::Opcode::BlackBoxFuncCall serde::Deserializable<Program::Opcode::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::BlackBoxFuncCall obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::Directive &lhs, const Opcode::Directive &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5965,23 +6031,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Directive>::serialize(const Circuit::Opcode::Directive &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::Directive>::serialize(const Program::Opcode::Directive &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Directive serde::Deserializable<Circuit::Opcode::Directive>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::Directive obj;
+Program::Opcode::Directive serde::Deserializable<Program::Opcode::Directive>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::Directive obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::Brillig &lhs, const Opcode::Brillig &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6003,23 +6069,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Brillig>::serialize(const Circuit::Opcode::Brillig &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::Brillig>::serialize(const Program::Opcode::Brillig &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Brillig serde::Deserializable<Circuit::Opcode::Brillig>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::Brillig obj;
+Program::Opcode::Brillig serde::Deserializable<Program::Opcode::Brillig>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::Brillig obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::MemoryOp &lhs, const Opcode::MemoryOp &rhs) {
         if (!(lhs.block_id == rhs.block_id)) { return false; }
@@ -6043,11 +6109,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::MemoryOp>::serialize(const Circuit::Opcode::MemoryOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::MemoryOp>::serialize(const Program::Opcode::MemoryOp &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
     serde::Serializable<decltype(obj.predicate)>::serialize(obj.predicate, serializer);
@@ -6055,15 +6121,15 @@ void serde::Serializable<Circuit::Opcode::MemoryOp>::serialize(const Circuit::Op
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::MemoryOp serde::Deserializable<Circuit::Opcode::MemoryOp>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::MemoryOp obj;
+Program::Opcode::MemoryOp serde::Deserializable<Program::Opcode::MemoryOp>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::MemoryOp obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
     obj.predicate = serde::Deserializable<decltype(obj.predicate)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) {
         if (!(lhs.block_id == rhs.block_id)) { return false; }
@@ -6086,25 +6152,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::MemoryInit>::serialize(const Circuit::Opcode::MemoryInit &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::MemoryInit>::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::MemoryInit serde::Deserializable<Circuit::Opcode::MemoryInit>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::MemoryInit obj;
+Program::Opcode::MemoryInit serde::Deserializable<Program::Opcode::MemoryInit>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::MemoryInit obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) {
         if (!(lhs.id == rhs.id)) { return false; }
@@ -6128,11 +6194,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Call>::serialize(const Circuit::Opcode::Call &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::Call>::serialize(const Program::Opcode::Call &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.id)>::serialize(obj.id, serializer);
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -6140,15 +6206,15 @@ void serde::Serializable<Circuit::Opcode::Call>::serialize(const Circuit::Opcode
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Call serde::Deserializable<Circuit::Opcode::Call>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::Call obj;
+Program::Opcode::Call serde::Deserializable<Program::Opcode::Call>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::Call obj;
     obj.id = serde::Deserializable<decltype(obj.id)>::deserialize(deserializer);
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6170,11 +6236,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::OpcodeLocation>::serialize(const Circuit::OpcodeLocation &obj, Serializer &serializer) {
+void serde::Serializable<Program::OpcodeLocation>::serialize(const Program::OpcodeLocation &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6182,15 +6248,15 @@ void serde::Serializable<Circuit::OpcodeLocation>::serialize(const Circuit::Opco
 
 template <>
 template <typename Deserializer>
-Circuit::OpcodeLocation serde::Deserializable<Circuit::OpcodeLocation>::deserialize(Deserializer &deserializer) {
+Program::OpcodeLocation serde::Deserializable<Program::OpcodeLocation>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::OpcodeLocation obj;
+    Program::OpcodeLocation obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const OpcodeLocation::Acir &lhs, const OpcodeLocation::Acir &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6212,23 +6278,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::OpcodeLocation::Acir>::serialize(const Circuit::OpcodeLocation::Acir &obj, Serializer &serializer) {
+void serde::Serializable<Program::OpcodeLocation::Acir>::serialize(const Program::OpcodeLocation::Acir &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::OpcodeLocation::Acir serde::Deserializable<Circuit::OpcodeLocation::Acir>::deserialize(Deserializer &deserializer) {
-    Circuit::OpcodeLocation::Acir obj;
+Program::OpcodeLocation::Acir serde::Deserializable<Program::OpcodeLocation::Acir>::deserialize(Deserializer &deserializer) {
+    Program::OpcodeLocation::Acir obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const OpcodeLocation::Brillig &lhs, const OpcodeLocation::Brillig &rhs) {
         if (!(lhs.acir_index == rhs.acir_index)) { return false; }
@@ -6251,25 +6317,67 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::OpcodeLocation::Brillig>::serialize(const Circuit::OpcodeLocation::Brillig &obj, Serializer &serializer) {
+void serde::Serializable<Program::OpcodeLocation::Brillig>::serialize(const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.acir_index)>::serialize(obj.acir_index, serializer);
     serde::Serializable<decltype(obj.brillig_index)>::serialize(obj.brillig_index, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::OpcodeLocation::Brillig serde::Deserializable<Circuit::OpcodeLocation::Brillig>::deserialize(Deserializer &deserializer) {
-    Circuit::OpcodeLocation::Brillig obj;
+Program::OpcodeLocation::Brillig serde::Deserializable<Program::OpcodeLocation::Brillig>::deserialize(Deserializer &deserializer) {
+    Program::OpcodeLocation::Brillig obj;
     obj.acir_index = serde::Deserializable<decltype(obj.acir_index)>::deserialize(deserializer);
     obj.brillig_index = serde::Deserializable<decltype(obj.brillig_index)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
+
+    inline bool operator==(const Program &lhs, const Program &rhs) {
+        if (!(lhs.functions == rhs.functions)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> Program::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<Program>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline Program Program::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<Program>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::Program>::serialize(const Program::Program &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.functions)>::serialize(obj.functions, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::Program serde::Deserializable<Program::Program>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::Program obj;
+    obj.functions = serde::Deserializable<decltype(obj.functions)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
 
     inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6291,11 +6399,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::PublicInputs>::serialize(const Circuit::PublicInputs &obj, Serializer &serializer) {
+void serde::Serializable<Program::PublicInputs>::serialize(const Program::PublicInputs &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6303,15 +6411,15 @@ void serde::Serializable<Circuit::PublicInputs>::serialize(const Circuit::Public
 
 template <>
 template <typename Deserializer>
-Circuit::PublicInputs serde::Deserializable<Circuit::PublicInputs>::deserialize(Deserializer &deserializer) {
+Program::PublicInputs serde::Deserializable<Program::PublicInputs>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::PublicInputs obj;
+    Program::PublicInputs obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Value &lhs, const Value &rhs) {
         if (!(lhs.inner == rhs.inner)) { return false; }
@@ -6333,11 +6441,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Value>::serialize(const Circuit::Value &obj, Serializer &serializer) {
+void serde::Serializable<Program::Value>::serialize(const Program::Value &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.inner)>::serialize(obj.inner, serializer);
     serializer.decrease_container_depth();
@@ -6345,15 +6453,15 @@ void serde::Serializable<Circuit::Value>::serialize(const Circuit::Value &obj, S
 
 template <>
 template <typename Deserializer>
-Circuit::Value serde::Deserializable<Circuit::Value>::deserialize(Deserializer &deserializer) {
+Program::Value serde::Deserializable<Program::Value>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Value obj;
+    Program::Value obj;
     obj.inner = serde::Deserializable<decltype(obj.inner)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6375,11 +6483,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray>::serialize(const Circuit::ValueOrArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray>::serialize(const Program::ValueOrArray &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6387,15 +6495,15 @@ void serde::Serializable<Circuit::ValueOrArray>::serialize(const Circuit::ValueO
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray serde::Deserializable<Circuit::ValueOrArray>::deserialize(Deserializer &deserializer) {
+Program::ValueOrArray serde::Deserializable<Program::ValueOrArray>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::ValueOrArray obj;
+    Program::ValueOrArray obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray::MemoryAddress &lhs, const ValueOrArray::MemoryAddress &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6417,23 +6525,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray::MemoryAddress>::serialize(const Circuit::ValueOrArray::MemoryAddress &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray::MemoryAddress>::serialize(const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray::MemoryAddress serde::Deserializable<Circuit::ValueOrArray::MemoryAddress>::deserialize(Deserializer &deserializer) {
-    Circuit::ValueOrArray::MemoryAddress obj;
+Program::ValueOrArray::MemoryAddress serde::Deserializable<Program::ValueOrArray::MemoryAddress>::deserialize(Deserializer &deserializer) {
+    Program::ValueOrArray::MemoryAddress obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray::HeapArray &lhs, const ValueOrArray::HeapArray &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6455,23 +6563,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray::HeapArray>::serialize(const Circuit::ValueOrArray::HeapArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray::HeapArray>::serialize(const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray::HeapArray serde::Deserializable<Circuit::ValueOrArray::HeapArray>::deserialize(Deserializer &deserializer) {
-    Circuit::ValueOrArray::HeapArray obj;
+Program::ValueOrArray::HeapArray serde::Deserializable<Program::ValueOrArray::HeapArray>::deserialize(Deserializer &deserializer) {
+    Program::ValueOrArray::HeapArray obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray::HeapVector &lhs, const ValueOrArray::HeapVector &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6493,23 +6601,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray::HeapVector>::serialize(const Circuit::ValueOrArray::HeapVector &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray::HeapVector>::serialize(const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray::HeapVector serde::Deserializable<Circuit::ValueOrArray::HeapVector>::deserialize(Deserializer &deserializer) {
-    Circuit::ValueOrArray::HeapVector obj;
+Program::ValueOrArray::HeapVector serde::Deserializable<Program::ValueOrArray::HeapVector>::deserialize(Deserializer &deserializer) {
+    Program::ValueOrArray::HeapVector obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Witness &lhs, const Witness &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6531,11 +6639,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Witness>::serialize(const Circuit::Witness &obj, Serializer &serializer) {
+void serde::Serializable<Program::Witness>::serialize(const Program::Witness &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6543,9 +6651,9 @@ void serde::Serializable<Circuit::Witness>::serialize(const Circuit::Witness &ob
 
 template <>
 template <typename Deserializer>
-Circuit::Witness serde::Deserializable<Circuit::Witness>::deserialize(Deserializer &deserializer) {
+Program::Witness serde::Deserializable<Program::Witness>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Witness obj;
+    Program::Witness obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
diff --git a/acvm-repo/acir/codegen/witness.cpp b/acvm-repo/acir/codegen/witness.cpp
index 118d4ca7ac5..ad2b0550db2 100644
--- a/acvm-repo/acir/codegen/witness.cpp
+++ b/acvm-repo/acir/codegen/witness.cpp
@@ -3,7 +3,7 @@
 #include "serde.hpp"
 #include "bincode.hpp"
 
-namespace WitnessMap {
+namespace WitnessStack {
 
     struct Witness {
         uint32_t value;
@@ -14,17 +14,79 @@ namespace WitnessMap {
     };
 
     struct WitnessMap {
-        std::map<WitnessMap::Witness, std::string> value;
+        std::map<WitnessStack::Witness, std::string> value;
 
         friend bool operator==(const WitnessMap&, const WitnessMap&);
         std::vector<uint8_t> bincodeSerialize() const;
         static WitnessMap bincodeDeserialize(std::vector<uint8_t>);
     };
 
-} // end of namespace WitnessMap
+    struct StackItem {
+        uint32_t index;
+        WitnessStack::WitnessMap witness;
 
+        friend bool operator==(const StackItem&, const StackItem&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static StackItem bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct WitnessStack {
+        std::vector<WitnessStack::StackItem> stack;
+
+        friend bool operator==(const WitnessStack&, const WitnessStack&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static WitnessStack bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+} // end of namespace WitnessStack
+
+
+namespace WitnessStack {
+
+    inline bool operator==(const StackItem &lhs, const StackItem &rhs) {
+        if (!(lhs.index == rhs.index)) { return false; }
+        if (!(lhs.witness == rhs.witness)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> StackItem::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<StackItem>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline StackItem StackItem::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<StackItem>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace WitnessStack
+
+template <>
+template <typename Serializer>
+void serde::Serializable<WitnessStack::StackItem>::serialize(const WitnessStack::StackItem &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.index)>::serialize(obj.index, serializer);
+    serde::Serializable<decltype(obj.witness)>::serialize(obj.witness, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+WitnessStack::StackItem serde::Deserializable<WitnessStack::StackItem>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    WitnessStack::StackItem obj;
+    obj.index = serde::Deserializable<decltype(obj.index)>::deserialize(deserializer);
+    obj.witness = serde::Deserializable<decltype(obj.witness)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
 
-namespace WitnessMap {
+namespace WitnessStack {
 
     inline bool operator==(const Witness &lhs, const Witness &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -46,11 +108,11 @@ namespace WitnessMap {
         return value;
     }
 
-} // end of namespace WitnessMap
+} // end of namespace WitnessStack
 
 template <>
 template <typename Serializer>
-void serde::Serializable<WitnessMap::Witness>::serialize(const WitnessMap::Witness &obj, Serializer &serializer) {
+void serde::Serializable<WitnessStack::Witness>::serialize(const WitnessStack::Witness &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -58,15 +120,15 @@ void serde::Serializable<WitnessMap::Witness>::serialize(const WitnessMap::Witne
 
 template <>
 template <typename Deserializer>
-WitnessMap::Witness serde::Deserializable<WitnessMap::Witness>::deserialize(Deserializer &deserializer) {
+WitnessStack::Witness serde::Deserializable<WitnessStack::Witness>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    WitnessMap::Witness obj;
+    WitnessStack::Witness obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace WitnessMap {
+namespace WitnessStack {
 
     inline bool operator==(const WitnessMap &lhs, const WitnessMap &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -88,11 +150,11 @@ namespace WitnessMap {
         return value;
     }
 
-} // end of namespace WitnessMap
+} // end of namespace WitnessStack
 
 template <>
 template <typename Serializer>
-void serde::Serializable<WitnessMap::WitnessMap>::serialize(const WitnessMap::WitnessMap &obj, Serializer &serializer) {
+void serde::Serializable<WitnessStack::WitnessMap>::serialize(const WitnessStack::WitnessMap &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -100,10 +162,52 @@ void serde::Serializable<WitnessMap::WitnessMap>::serialize(const WitnessMap::Wi
 
 template <>
 template <typename Deserializer>
-WitnessMap::WitnessMap serde::Deserializable<WitnessMap::WitnessMap>::deserialize(Deserializer &deserializer) {
+WitnessStack::WitnessMap serde::Deserializable<WitnessStack::WitnessMap>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    WitnessMap::WitnessMap obj;
+    WitnessStack::WitnessMap obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
+
+namespace WitnessStack {
+
+    inline bool operator==(const WitnessStack &lhs, const WitnessStack &rhs) {
+        if (!(lhs.stack == rhs.stack)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> WitnessStack::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<WitnessStack>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline WitnessStack WitnessStack::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<WitnessStack>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace WitnessStack
+
+template <>
+template <typename Serializer>
+void serde::Serializable<WitnessStack::WitnessStack>::serialize(const WitnessStack::WitnessStack &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.stack)>::serialize(obj.stack, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+WitnessStack::WitnessStack serde::Deserializable<WitnessStack::WitnessStack>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    WitnessStack::WitnessStack obj;
+    obj.stack = serde::Deserializable<decltype(obj.stack)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index 7e6cbf23803..b5d6348d34f 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -32,6 +32,13 @@ pub enum ExpressionWidth {
     },
 }
 
+/// A program represented by multiple ACIR circuits. The execution trace of these
+/// circuits is dictated by construction of the [crate::native_types::WitnessStack].
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct Program {
+    pub functions: Vec<Circuit>,
+}
+
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct Circuit {
     // current_witness_index is the highest witness index in the circuit. The next witness to be added to this circuit
@@ -152,7 +159,9 @@ impl Circuit {
             self.public_parameters.0.union(&self.return_values.0).cloned().collect();
         PublicInputs(public_inputs)
     }
+}
 
+impl Program {
     fn write<W: std::io::Write>(&self, writer: W) -> std::io::Result<()> {
         let buf = bincode::serialize(self).unwrap();
         let mut encoder = flate2::write::GzEncoder::new(writer, Compression::default());
@@ -169,36 +178,36 @@ impl Circuit {
             .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))
     }
 
-    pub fn serialize_circuit(circuit: &Circuit) -> Vec<u8> {
-        let mut circuit_bytes: Vec<u8> = Vec::new();
-        circuit.write(&mut circuit_bytes).expect("expected circuit to be serializable");
-        circuit_bytes
+    pub fn serialize_program(program: &Program) -> Vec<u8> {
+        let mut program_bytes: Vec<u8> = Vec::new();
+        program.write(&mut program_bytes).expect("expected circuit to be serializable");
+        program_bytes
     }
 
-    pub fn deserialize_circuit(serialized_circuit: &[u8]) -> std::io::Result<Self> {
-        Circuit::read(serialized_circuit)
+    pub fn deserialize_program(serialized_circuit: &[u8]) -> std::io::Result<Self> {
+        Program::read(serialized_circuit)
     }
 
-    // Serialize and base64 encode circuit
-    pub fn serialize_circuit_base64<S>(circuit: &Circuit, s: S) -> Result<S::Ok, S::Error>
+    // Serialize and base64 encode program
+    pub fn serialize_program_base64<S>(program: &Program, s: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        let circuit_bytes = Circuit::serialize_circuit(circuit);
-        let encoded_b64 = base64::engine::general_purpose::STANDARD.encode(circuit_bytes);
+        let program_bytes = Program::serialize_program(program);
+        let encoded_b64 = base64::engine::general_purpose::STANDARD.encode(program_bytes);
         s.serialize_str(&encoded_b64)
     }
 
-    // Deserialize and base64 decode circuit
-    pub fn deserialize_circuit_base64<'de, D>(deserializer: D) -> Result<Circuit, D::Error>
+    // Deserialize and base64 decode program
+    pub fn deserialize_program_base64<'de, D>(deserializer: D) -> Result<Program, D::Error>
     where
         D: Deserializer<'de>,
     {
         let bytecode_b64: String = serde::Deserialize::deserialize(deserializer)?;
-        let circuit_bytes = base64::engine::general_purpose::STANDARD
+        let program_bytes = base64::engine::general_purpose::STANDARD
             .decode(bytecode_b64)
             .map_err(D::Error::custom)?;
-        let circuit = Self::deserialize_circuit(&circuit_bytes).map_err(D::Error::custom)?;
+        let circuit = Self::deserialize_program(&program_bytes).map_err(D::Error::custom)?;
         Ok(circuit)
     }
 }
@@ -240,6 +249,22 @@ impl std::fmt::Debug for Circuit {
     }
 }
 
+impl std::fmt::Display for Program {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (func_index, function) in self.functions.iter().enumerate() {
+            writeln!(f, "func {}", func_index)?;
+            writeln!(f, "{}", function)?;
+        }
+        Ok(())
+    }
+}
+
+impl std::fmt::Debug for Program {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct PublicInputs(pub BTreeSet<Witness>);
 
@@ -262,7 +287,10 @@ mod tests {
         opcodes::{BlackBoxFuncCall, FunctionInput},
         Circuit, Compression, Opcode, PublicInputs,
     };
-    use crate::{circuit::ExpressionWidth, native_types::Witness};
+    use crate::{
+        circuit::{ExpressionWidth, Program},
+        native_types::Witness,
+    };
     use acir_field::FieldElement;
 
     fn and_opcode() -> Opcode {
@@ -348,14 +376,15 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
+        let program = Program { functions: vec![circuit] };
 
-        fn read_write(circuit: Circuit) -> (Circuit, Circuit) {
-            let bytes = Circuit::serialize_circuit(&circuit);
-            let got_circuit = Circuit::deserialize_circuit(&bytes).unwrap();
-            (circuit, got_circuit)
+        fn read_write(program: Program) -> (Program, Program) {
+            let bytes = Program::serialize_program(&program);
+            let got_program = Program::deserialize_program(&bytes).unwrap();
+            (program, got_program)
         }
 
-        let (circ, got_circ) = read_write(circuit);
+        let (circ, got_circ) = read_write(program);
         assert_eq!(circ, got_circ);
     }
 
@@ -380,11 +409,12 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
+        let program = Program { functions: vec![circuit] };
 
-        let json = serde_json::to_string_pretty(&circuit).unwrap();
+        let json = serde_json::to_string_pretty(&program).unwrap();
 
         let deserialized = serde_json::from_str(&json).unwrap();
-        assert_eq!(circuit, deserialized);
+        assert_eq!(program, deserialized);
     }
 
     #[test]
@@ -400,7 +430,7 @@ mod tests {
         encoder.write_all(bad_circuit).unwrap();
         encoder.finish().unwrap();
 
-        let deserialization_result = Circuit::deserialize_circuit(&zipped_bad_circuit);
+        let deserialization_result = Program::deserialize_program(&zipped_bad_circuit);
         assert!(deserialization_result.is_err());
     }
 }
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index c7be5026850..d14159f34a1 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -42,9 +42,9 @@ mod reflection {
             brillig::{BrilligInputs, BrilligOutputs},
             directives::Directive,
             opcodes::BlackBoxFuncCall,
-            Circuit, ExpressionWidth, Opcode, OpcodeLocation,
+            Circuit, ExpressionWidth, Opcode, OpcodeLocation, Program,
         },
-        native_types::{Witness, WitnessMap},
+        native_types::{Witness, WitnessMap, WitnessStack},
     };
 
     #[test]
@@ -59,6 +59,7 @@ mod reflection {
         };
 
         let mut tracer = Tracer::new(TracerConfig::default());
+        tracer.trace_simple_type::<Program>().unwrap();
         tracer.trace_simple_type::<Circuit>().unwrap();
         tracer.trace_simple_type::<ExpressionWidth>().unwrap();
         tracer.trace_simple_type::<Opcode>().unwrap();
@@ -78,7 +79,7 @@ mod reflection {
 
         // Create C++ class definitions.
         let mut source = Vec::new();
-        let config = serde_generate::CodeGeneratorConfig::new("Circuit".to_string())
+        let config = serde_generate::CodeGeneratorConfig::new("Program".to_string())
             .with_encodings(vec![serde_generate::Encoding::Bincode]);
         let generator = serde_generate::cpp::CodeGenerator::new(&config);
         generator.output(&mut source, &registry).unwrap();
@@ -106,12 +107,13 @@ mod reflection {
         let mut tracer = Tracer::new(TracerConfig::default());
         tracer.trace_simple_type::<Witness>().unwrap();
         tracer.trace_simple_type::<WitnessMap>().unwrap();
+        tracer.trace_simple_type::<WitnessStack>().unwrap();
 
         let registry = tracer.registry().unwrap();
 
         // Create C++ class definitions.
         let mut source = Vec::new();
-        let config = serde_generate::CodeGeneratorConfig::new("WitnessMap".to_string())
+        let config = serde_generate::CodeGeneratorConfig::new("WitnessStack".to_string())
             .with_encodings(vec![serde_generate::Encoding::Bincode]);
         let generator = serde_generate::cpp::CodeGenerator::new(&config);
         generator.output(&mut source, &registry).unwrap();
diff --git a/acvm-repo/acir/src/native_types/mod.rs b/acvm-repo/acir/src/native_types/mod.rs
index 66c822bfff8..eb9d1f6fd03 100644
--- a/acvm-repo/acir/src/native_types/mod.rs
+++ b/acvm-repo/acir/src/native_types/mod.rs
@@ -1,8 +1,10 @@
 mod expression;
 mod witness;
 mod witness_map;
+mod witness_stack;
 
 pub use expression::Expression;
 pub use witness::Witness;
 pub use witness_map::WitnessMap;
-pub use witness_map::WitnessMapError;
+pub use witness_stack::WitnessStack;
+pub use witness_stack::WitnessStackError;
diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs
new file mode 100644
index 00000000000..9592d90b014
--- /dev/null
+++ b/acvm-repo/acir/src/native_types/witness_stack.rs
@@ -0,0 +1,64 @@
+use std::io::Read;
+
+use flate2::bufread::GzDecoder;
+use flate2::bufread::GzEncoder;
+use flate2::Compression;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::WitnessMap;
+
+#[derive(Debug, Error)]
+enum SerializationError {
+    #[error(transparent)]
+    Deflate(#[from] std::io::Error),
+}
+
+#[derive(Debug, Error)]
+#[error(transparent)]
+pub struct WitnessStackError(#[from] SerializationError);
+
+/// An ordered set of witness maps for separate circuits
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
+pub struct WitnessStack {
+    pub stack: Vec<StackItem>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
+pub struct StackItem {
+    /// Index into a [crate::circuit::Program] function list for which we have an associated witness
+    pub index: u32,
+    /// A full witness for the respective constraint system specified by the index
+    pub witness: WitnessMap,
+}
+
+impl From<WitnessMap> for WitnessStack {
+    fn from(witness: WitnessMap) -> Self {
+        let stack = vec![StackItem { index: 0, witness }];
+        Self { stack }
+    }
+}
+
+impl TryFrom<WitnessStack> for Vec<u8> {
+    type Error = WitnessStackError;
+
+    fn try_from(val: WitnessStack) -> Result<Self, Self::Error> {
+        let buf = bincode::serialize(&val).unwrap();
+        let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best());
+        let mut buf_c = Vec::new();
+        deflater.read_to_end(&mut buf_c).map_err(|err| WitnessStackError(err.into()))?;
+        Ok(buf_c)
+    }
+}
+
+impl TryFrom<&[u8]> for WitnessStack {
+    type Error = WitnessStackError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        let mut deflater = GzDecoder::new(bytes);
+        let mut buf_d = Vec::new();
+        deflater.read_to_end(&mut buf_d).map_err(|err| WitnessStackError(err.into()))?;
+        let witness_stack = bincode::deserialize(&buf_d).unwrap();
+        Ok(witness_stack)
+    }
+}
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 2c8ad2b9986..64385a37582 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -1,13 +1,13 @@
 //! This integration test defines a set of circuits which are used in order to test the acvm_js package.
 //!
-//! The acvm_js test suite contains serialized [circuits][`Circuit`] which must be kept in sync with the format
+//! The acvm_js test suite contains serialized program [circuits][`Program`] which must be kept in sync with the format
 //! outputted from the [ACIR crate][acir].
 //! Breaking changes to the serialization format then require refreshing acvm_js's test suite.
 //! This file contains Rust definitions of these circuits and outputs the updated serialized format.
 //!
 //! These tests also check this circuit serialization against an expected value, erroring if the serialization changes.
 //! Generally in this situation we just need to refresh the `expected_serialization` variables to match the
-//! actual output, **HOWEVER** note that this results in a breaking change to the ACIR format.
+//! actual output, **HOWEVER** note that this results in a breaking change to the backend ACIR format.
 
 use std::collections::BTreeSet;
 
@@ -15,7 +15,7 @@ use acir::{
     circuit::{
         brillig::{Brillig, BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, BlockId, FunctionInput, MemOp},
-        Circuit, Opcode, PublicInputs,
+        Circuit, Opcode, Program, PublicInputs,
     },
     native_types::{Expression, Witness},
 };
@@ -41,16 +41,17 @@ fn addition_circuit() {
         return_values: PublicInputs([Witness(3)].into()),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 208, 49, 14, 192, 32, 8, 5, 80, 212, 30, 8, 4, 20,
-        182, 94, 165, 166, 122, 255, 35, 52, 77, 28, 76, 58, 214, 191, 124, 166, 23, 242, 15, 0, 8,
-        240, 77, 154, 125, 206, 198, 127, 161, 176, 209, 138, 139, 197, 88, 68, 122, 205, 157, 152,
-        46, 204, 222, 76, 81, 180, 21, 35, 35, 53, 189, 179, 49, 119, 19, 171, 222, 188, 162, 147,
-        112, 167, 161, 206, 99, 98, 105, 223, 95, 248, 26, 113, 90, 97, 185, 97, 217, 56, 173, 35,
-        63, 243, 81, 87, 163, 125, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 75, 14, 128, 32, 12, 68, 249, 120, 160, 150,
+        182, 208, 238, 188, 138, 68, 184, 255, 17, 212, 200, 130, 196, 165, 188, 164, 153, 174, 94,
+        38, 227, 221, 203, 118, 159, 119, 95, 226, 200, 125, 36, 252, 3, 253, 66, 87, 152, 92, 4,
+        153, 185, 149, 212, 144, 240, 128, 100, 85, 5, 88, 106, 86, 84, 20, 149, 51, 41, 81, 83,
+        214, 98, 213, 10, 24, 50, 53, 236, 98, 212, 135, 44, 174, 235, 5, 143, 35, 12, 151, 159,
+        126, 55, 109, 28, 231, 145, 47, 245, 105, 191, 143, 133, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -71,13 +72,14 @@ fn fixed_base_scalar_mul_circuit() {
         return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(3), Witness(4)])),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 91, 10, 0, 32, 16, 2, 109, 171, 175, 46, 221,
-        209, 247, 229, 130, 130, 140, 200, 92, 0, 11, 157, 228, 35, 127, 212, 200, 29, 61, 116, 76,
-        220, 217, 250, 171, 91, 113, 160, 66, 104, 242, 97, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233,
+        29, 61, 43, 3, 5, 121, 34, 207, 86, 231, 162, 198, 157, 124, 228, 71, 157, 220, 232, 161,
+        227, 226, 206, 214, 95, 221, 74, 0, 116, 58, 13, 182, 105, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -98,13 +100,14 @@ fn pedersen_circuit() {
         return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(3)])),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 135, 9, 0, 48, 8, 75, 171, 224, 255, 15, 139,
-        27, 196, 64, 200, 100, 0, 15, 133, 80, 57, 89, 219, 127, 39, 173, 126, 235, 236, 247, 151,
-        48, 224, 71, 90, 33, 97, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 7, 6, 0, 0, 8, 108, 209, 255, 63, 156, 54, 233,
+        56, 55, 17, 26, 18, 196, 241, 169, 250, 178, 141, 167, 32, 159, 254, 234, 238, 255, 87,
+        112, 52, 63, 63, 101, 105, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -139,26 +142,27 @@ fn schnorr_verify_circuit() {
         return_values: PublicInputs(BTreeSet::from([output])),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 74, 3, 1, 20, 69, 209, 177, 247, 222, 123,
-        239, 189, 119, 141, 93, 99, 220, 133, 251, 95, 130, 152, 103, 78, 32, 3, 195, 33, 4, 66,
-        248, 239, 254, 20, 69, 209, 84, 212, 158, 216, 206, 223, 234, 219, 204, 146, 239, 91, 170,
-        111, 103, 245, 109, 101, 27, 219, 217, 193, 250, 219, 197, 110, 246, 176, 151, 125, 236,
-        231, 0, 7, 57, 196, 97, 142, 112, 148, 99, 28, 231, 4, 39, 57, 197, 105, 206, 112, 150,
-        115, 156, 231, 2, 23, 185, 196, 101, 174, 112, 149, 107, 92, 231, 6, 55, 185, 197, 109,
-        238, 112, 151, 123, 220, 231, 1, 15, 121, 196, 99, 158, 240, 148, 103, 60, 231, 5, 47, 121,
-        197, 107, 222, 240, 150, 119, 188, 231, 3, 75, 124, 228, 83, 195, 142, 121, 158, 125, 126,
-        225, 43, 223, 248, 206, 15, 126, 178, 204, 47, 86, 248, 237, 119, 43, 76, 127, 105, 47,
-        189, 165, 181, 116, 150, 198, 234, 125, 117, 249, 47, 233, 41, 45, 165, 163, 52, 148, 126,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 78, 2, 1, 20, 69, 81, 236, 189, 247, 222,
+        123, 239, 93, 177, 33, 34, 238, 194, 253, 47, 193, 200, 147, 67, 194, 36, 147, 163, 33, 33,
+        228, 191, 219, 82, 168, 63, 63, 181, 183, 197, 223, 177, 147, 191, 181, 183, 149, 69, 159,
+        183, 213, 222, 238, 218, 219, 206, 14, 118, 178, 139, 141, 183, 135, 189, 236, 99, 63, 7,
+        56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227,
+        60, 23, 184, 200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187,
+        220, 227, 62, 15, 120, 200, 35, 30, 243, 132, 167, 60, 227, 57, 47, 120, 201, 43, 94, 243,
+        134, 183, 188, 227, 61, 31, 248, 200, 39, 22, 249, 204, 151, 166, 29, 243, 188, 250, 255,
+        141, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 123, 171, 76, 127, 105, 47,
+        189, 165, 181, 116, 150, 198, 26, 125, 245, 248, 45, 233, 41, 45, 165, 163, 52, 148, 126,
         210, 78, 186, 73, 51, 233, 37, 173, 164, 147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33,
-        45, 164, 131, 52, 144, 253, 23, 139, 218, 238, 217, 60, 123, 103, 235, 236, 156, 141, 179,
-        239, 166, 93, 183, 237, 185, 107, 199, 125, 251, 29, 218, 237, 216, 94, 167, 118, 58, 183,
-        207, 165, 93, 174, 237, 113, 107, 135, 123, 247, 47, 185, 251, 147, 59, 191, 184, 239, 155,
-        187, 126, 184, 103, 217, 29, 235, 55, 171, 223, 173, 104, 184, 231, 255, 243, 7, 236, 52,
-        239, 128, 225, 3, 0, 0,
+        45, 164, 131, 52, 144, 253, 151, 11, 245, 221, 179, 121, 246, 206, 214, 217, 57, 27, 103,
+        223, 109, 187, 238, 218, 115, 223, 142, 135, 246, 59, 182, 219, 169, 189, 206, 237, 116,
+        105, 159, 107, 187, 220, 218, 227, 222, 14, 143, 238, 95, 116, 247, 23, 119, 126, 115, 223,
+        146, 187, 150, 221, 179, 226, 142, 141, 155, 53, 238, 86, 104, 186, 231, 255, 243, 7, 100,
+        141, 232, 192, 233, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -202,15 +206,16 @@ fn simple_brillig_foreign_call() {
         private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 177, 10, 192, 32, 16, 67, 227, 21, 74, 233,
-        212, 79, 177, 127, 208, 159, 233, 224, 226, 32, 226, 247, 139, 168, 16, 68, 93, 244, 45,
-        119, 228, 142, 144, 92, 0, 20, 50, 7, 237, 76, 213, 190, 50, 245, 26, 175, 218, 231, 165,
-        57, 175, 148, 14, 137, 179, 147, 191, 114, 211, 221, 216, 240, 59, 63, 107, 221, 115, 104,
-        181, 103, 244, 43, 36, 10, 38, 68, 108, 25, 253, 238, 136, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 65, 10, 192, 32, 12, 4, 77, 10, 165, 244, 214,
+        159, 216, 31, 244, 51, 61, 120, 241, 32, 226, 251, 85, 140, 176, 136, 122, 209, 129, 144,
+        176, 9, 97, 151, 84, 225, 74, 69, 50, 31, 48, 35, 85, 251, 164, 235, 53, 94, 218, 247, 75,
+        163, 95, 150, 12, 153, 179, 227, 191, 114, 195, 222, 216, 240, 59, 63, 75, 221, 251, 208,
+        106, 207, 232, 150, 65, 100, 53, 33, 2, 22, 232, 178, 27, 144, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -301,19 +306,20 @@ fn complex_brillig_foreign_call() {
         private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3)]),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 125, 177, 163, 35, 179,
-        154, 35, 8, 51, 7, 232, 204, 9, 188, 139, 184, 83, 116, 233, 241, 173, 152, 98, 12, 213,
-        141, 21, 244, 65, 232, 39, 175, 233, 35, 73, 155, 3, 32, 204, 48, 206, 18, 158, 19, 175,
-        37, 60, 175, 228, 209, 30, 195, 143, 226, 197, 178, 103, 105, 76, 110, 160, 209, 156, 160,
-        209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 241,
-        250, 201, 99, 206, 251, 96, 95, 161, 242, 14, 193, 243, 40, 162, 105, 253, 219, 12, 75, 47,
-        146, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96, 20, 85, 75, 253, 136, 249, 87, 249, 105,
-        231, 220, 4, 249, 237, 132, 56, 20, 224, 109, 113, 223, 88, 82, 153, 34, 64, 34, 14, 164,
-        69, 172, 48, 2, 23, 243, 6, 31, 25, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 65, 14, 132, 32, 12, 108, 101, 117, 205, 222,
+        246, 7, 38, 187, 15, 96, 247, 5, 254, 197, 120, 211, 232, 209, 231, 139, 113, 136, 181, 65,
+        47, 98, 162, 147, 52, 20, 24, 202, 164, 45, 48, 205, 200, 157, 49, 124, 227, 44, 129, 207,
+        152, 75, 120, 94, 137, 209, 30, 195, 143, 227, 197, 178, 103, 105, 76, 110, 160, 209, 156,
+        160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 97,
+        254, 196, 152, 99, 157, 176, 87, 168, 188, 147, 224, 121, 20, 209, 180, 254, 109, 70, 75,
+        47, 178, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96, 20, 85, 75, 253, 8, 255, 171, 246,
+        121, 231, 220, 4, 249, 237, 132, 56, 28, 224, 109, 113, 223, 180, 164, 50, 165, 0, 137, 17,
+        72, 139, 88, 97, 4, 173, 98, 132, 157, 33, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -342,13 +348,16 @@ fn memory_op_circuit() {
         return_values: PublicInputs([Witness(4)].into()),
         ..Circuit::default()
     };
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let program = Program { functions: vec![circuit] };
+
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 145, 187, 17, 0, 32, 8, 67, 195, 111, 31, 220, 192,
-        253, 167, 178, 144, 2, 239, 236, 132, 194, 52, 129, 230, 93, 8, 6, 64, 176, 101, 225, 28,
-        78, 49, 43, 238, 154, 225, 254, 166, 209, 205, 165, 98, 174, 212, 177, 188, 187, 92, 255,
-        173, 92, 173, 190, 93, 82, 80, 78, 123, 14, 127, 60, 97, 1, 210, 144, 46, 242, 19, 3, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 201, 13, 0, 32, 8, 147, 195, 125, 112, 3, 247,
+        159, 74, 141, 60, 106, 226, 79, 120, 216, 132, 180, 124, 154, 82, 168, 108, 212, 57, 2,
+        122, 129, 157, 201, 181, 150, 59, 186, 179, 189, 161, 101, 251, 82, 176, 175, 196, 121, 89,
+        118, 185, 246, 91, 185, 26, 125, 187, 64, 80, 134, 29, 195, 31, 79, 24, 2, 250, 167, 252,
+        27, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
diff --git a/acvm-repo/acvm_js/src/compression.rs b/acvm-repo/acvm_js/src/compression.rs
index fedaa514bf0..18e9216297e 100644
--- a/acvm-repo/acvm_js/src/compression.rs
+++ b/acvm-repo/acvm_js/src/compression.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use js_sys::JsString;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -13,10 +13,11 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString>
     console_error_panic_hook::set_once();
 
     let witness_map = WitnessMap::from(witness_map);
-    let compressed_witness_map: Vec<u8> =
-        Vec::<u8>::try_from(witness_map).map_err(|err| err.to_string())?;
+    let witness_stack = WitnessStack::from(witness_map);
+    let compressed_witness_stack: Vec<u8> =
+        Vec::<u8>::try_from(witness_stack).map_err(|err| err.to_string())?;
 
-    Ok(compressed_witness_map)
+    Ok(compressed_witness_stack)
 }
 
 /// Decompresses a compressed witness as outputted by Nargo into a `WitnessMap`.
@@ -27,8 +28,8 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString>
 pub fn decompress_witness(compressed_witness: Vec<u8>) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
 
-    let witness_map =
-        WitnessMap::try_from(compressed_witness.as_slice()).map_err(|err| err.to_string())?;
+    let witness_stack =
+        WitnessStack::try_from(compressed_witness.as_slice()).map_err(|err| err.to_string())?;
 
-    Ok(witness_map.into())
+    Ok(witness_stack.stack[0].witness.clone().into())
 }
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 3f691e1abf2..ac71a573e64 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -1,5 +1,5 @@
 use acvm::{
-    acir::circuit::Circuit,
+    acir::circuit::Program,
     pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM},
 };
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
@@ -34,7 +34,7 @@ pub async fn create_black_box_solver() -> WasmBlackBoxFunctionSolver {
 /// @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
 #[wasm_bindgen(js_name = executeCircuit, skip_jsdoc)]
 pub async fn execute_circuit(
-    circuit: Vec<u8>,
+    program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
 ) -> Result<JsWitnessMap, Error> {
@@ -42,7 +42,7 @@ pub async fn execute_circuit(
 
     let solver = WasmBlackBoxFunctionSolver::initialize().await;
 
-    execute_circuit_with_black_box_solver(&solver, circuit, initial_witness, foreign_call_handler)
+    execute_circuit_with_black_box_solver(&solver, program, initial_witness, foreign_call_handler)
         .await
 }
 
@@ -56,13 +56,21 @@ pub async fn execute_circuit(
 #[wasm_bindgen(js_name = executeCircuitWithBlackBoxSolver, skip_jsdoc)]
 pub async fn execute_circuit_with_black_box_solver(
     solver: &WasmBlackBoxFunctionSolver,
-    circuit: Vec<u8>,
+    // TODO(https://github.com/noir-lang/noir/issues/4428): These need to be updated to match the same interfaces
+    // as the native ACVM executor. Right now native execution still only handles one circuit so I do not feel the need
+    // to break the JS interface just yet.
+    program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
 ) -> Result<JsWitnessMap, Error> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit = Circuit::deserialize_circuit(&circuit)
+    let program: Program = Program::deserialize_program(&program)
         .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
+    let circuit = match program.functions.len() {
+        0 => return Ok(initial_witness),
+        1 => &program.functions[0],
+        _ => return Err(JsExecutionError::new("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit".to_string(), None).into())
+    };
 
     let mut acvm = ACVM::new(&solver.0, &circuit.opcodes, initial_witness.into());
 
diff --git a/acvm-repo/acvm_js/src/public_witness.rs b/acvm-repo/acvm_js/src/public_witness.rs
index 8dc66c435b3..a0d5b5f8be2 100644
--- a/acvm-repo/acvm_js/src/public_witness.rs
+++ b/acvm-repo/acvm_js/src/public_witness.rs
@@ -1,5 +1,5 @@
 use acvm::acir::{
-    circuit::Circuit,
+    circuit::Program,
     native_types::{Witness, WitnessMap},
 };
 use js_sys::JsString;
@@ -26,16 +26,25 @@ fn extract_indices(witness_map: &WitnessMap, indices: Vec<Witness>) -> Result<Wi
 /// @returns {WitnessMap} A witness map containing the circuit's return values.
 #[wasm_bindgen(js_name = getReturnWitness)]
 pub fn get_return_witness(
-    circuit: Vec<u8>,
+    // TODO(https://github.com/noir-lang/noir/issues/4428): These need to be updated to match the same interfaces
+    // as the native ACVM executor. Right now native execution still only handles one circuit so I do not feel the need
+    // to break the JS interface just yet.
+    program: Vec<u8>,
     witness_map: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit =
-        Circuit::deserialize_circuit(&circuit).expect("Failed to deserialize circuit");
+    let program: Program =
+        Program::deserialize_program(&program).expect("Failed to deserialize circuit");
+    let circuit = match program.functions.len() {
+        0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
+        1 => &program.functions[0],
+        _ => return Err(JsString::from("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit"))
+    };
+
     let witness_map = WitnessMap::from(witness_map);
 
     let return_witness =
-        extract_indices(&witness_map, circuit.return_values.0.into_iter().collect())?;
+        extract_indices(&witness_map, circuit.return_values.0.clone().into_iter().collect())?;
 
     Ok(JsWitnessMap::from(return_witness))
 }
@@ -47,16 +56,22 @@ pub fn get_return_witness(
 /// @returns {WitnessMap} A witness map containing the circuit's public parameters.
 #[wasm_bindgen(js_name = getPublicParametersWitness)]
 pub fn get_public_parameters_witness(
-    circuit: Vec<u8>,
+    program: Vec<u8>,
     solved_witness: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit =
-        Circuit::deserialize_circuit(&circuit).expect("Failed to deserialize circuit");
+    let program: Program =
+        Program::deserialize_program(&program).expect("Failed to deserialize circuit");
+    let circuit = match program.functions.len() {
+        0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
+        1 => &program.functions[0],
+        _ => return Err(JsString::from("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit"))
+    };
+
     let witness_map = WitnessMap::from(solved_witness);
 
     let public_params_witness =
-        extract_indices(&witness_map, circuit.public_parameters.0.into_iter().collect())?;
+        extract_indices(&witness_map, circuit.public_parameters.0.clone().into_iter().collect())?;
 
     Ok(JsWitnessMap::from(public_params_witness))
 }
@@ -68,16 +83,22 @@ pub fn get_public_parameters_witness(
 /// @returns {WitnessMap} A witness map containing the circuit's public inputs.
 #[wasm_bindgen(js_name = getPublicWitness)]
 pub fn get_public_witness(
-    circuit: Vec<u8>,
+    program: Vec<u8>,
     solved_witness: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit =
-        Circuit::deserialize_circuit(&circuit).expect("Failed to deserialize circuit");
+    let program: Program =
+        Program::deserialize_program(&program).expect("Failed to deserialize circuit");
+    let circuit = match program.functions.len() {
+        0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
+        1 => &program.functions[0],
+        _ => return Err(JsString::from("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit"))
+    };
+
     let witness_map = WitnessMap::from(solved_witness);
 
     let public_witness =
-        extract_indices(&witness_map, circuit.public_inputs().0.into_iter().collect())?;
+        extract_indices(&witness_map, circuit.public_inputs().0.clone().into_iter().collect())?;
 
     Ok(JsWitnessMap::from(public_witness))
 }
diff --git a/acvm-repo/acvm_js/test/shared/addition.ts b/acvm-repo/acvm_js/test/shared/addition.ts
index 217902bdea6..b56a4286878 100644
--- a/acvm-repo/acvm_js/test/shared/addition.ts
+++ b/acvm-repo/acvm_js/test/shared/addition.ts
@@ -2,11 +2,11 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `addition_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 208, 49, 14, 192, 32, 8, 5, 80, 212, 30, 8, 4, 20, 182, 94, 165, 166, 122,
-  255, 35, 52, 77, 28, 76, 58, 214, 191, 124, 166, 23, 242, 15, 0, 8, 240, 77, 154, 125, 206, 198, 127, 161, 176, 209,
-  138, 139, 197, 88, 68, 122, 205, 157, 152, 46, 204, 222, 76, 81, 180, 21, 35, 35, 53, 189, 179, 49, 119, 19, 171, 222,
-  188, 162, 147, 112, 167, 161, 206, 99, 98, 105, 223, 95, 248, 26, 113, 90, 97, 185, 97, 217, 56, 173, 35, 63, 243, 81,
-  87, 163, 125, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 75, 14, 128, 32, 12, 68, 249, 120, 160, 150, 182, 208, 238, 188, 138, 68,
+  184, 255, 17, 212, 200, 130, 196, 165, 188, 164, 153, 174, 94, 38, 227, 221, 203, 118, 159, 119, 95, 226, 200, 125,
+  36, 252, 3, 253, 66, 87, 152, 92, 4, 153, 185, 149, 212, 144, 240, 128, 100, 85, 5, 88, 106, 86, 84, 20, 149, 51, 41,
+  81, 83, 214, 98, 213, 10, 24, 50, 53, 236, 98, 212, 135, 44, 174, 235, 5, 143, 35, 12, 151, 159, 126, 55, 109, 28,
+  231, 145, 47, 245, 105, 191, 143, 133, 1, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index 27abd72305f..fba8470585f 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 125, 177, 163, 35, 179, 154, 35, 8, 51, 7, 232, 204,
-  9, 188, 139, 184, 83, 116, 233, 241, 173, 152, 98, 12, 213, 141, 21, 244, 65, 232, 39, 175, 233, 35, 73, 155, 3, 32,
-  204, 48, 206, 18, 158, 19, 175, 37, 60, 175, 228, 209, 30, 195, 143, 226, 197, 178, 103, 105, 76, 110, 160, 209, 156,
-  160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 241, 250, 201, 99, 206, 251,
-  96, 95, 161, 242, 14, 193, 243, 40, 162, 105, 253, 219, 12, 75, 47, 146, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96,
-  20, 85, 75, 253, 136, 249, 87, 249, 105, 231, 220, 4, 249, 237, 132, 56, 20, 224, 109, 113, 223, 88, 82, 153, 34, 64,
-  34, 14, 164, 69, 172, 48, 2, 23, 243, 6, 31, 25, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 65, 14, 132, 32, 12, 108, 101, 117, 205, 222, 246, 7, 38, 187, 15, 96,
+  247, 5, 254, 197, 120, 211, 232, 209, 231, 139, 113, 136, 181, 65, 47, 98, 162, 147, 52, 20, 24, 202, 164, 45, 48,
+  205, 200, 157, 49, 124, 227, 44, 129, 207, 152, 75, 120, 94, 137, 209, 30, 195, 143, 227, 197, 178, 103, 105, 76, 110,
+  160, 209, 156, 160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 97, 254, 196,
+  152, 99, 157, 176, 87, 168, 188, 147, 224, 121, 20, 209, 180, 254, 109, 70, 75, 47, 178, 186, 251, 37, 116, 86, 93,
+  219, 55, 245, 96, 20, 85, 75, 253, 8, 255, 171, 246, 121, 231, 220, 4, 249, 237, 132, 56, 28, 224, 109, 113, 223, 180,
+  164, 50, 165, 0, 137, 17, 72, 139, 88, 97, 4, 173, 98, 132, 157, 33, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
index c0859f50135..5aef521f231 100644
--- a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
+++ b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
@@ -1,8 +1,8 @@
 // See `fixed_base_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 91, 10, 0, 32, 16, 2, 109, 171, 175, 46, 221, 209, 247, 229, 130, 130,
-  140, 200, 92, 0, 11, 157, 228, 35, 127, 212, 200, 29, 61, 116, 76, 220, 217, 250, 171, 91, 113, 160, 66, 104, 242, 97,
-  0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, 29, 61, 43, 3, 5, 121, 34,
+  207, 86, 231, 162, 198, 157, 124, 228, 71, 157, 220, 232, 161, 227, 226, 206, 214, 95, 221, 74, 0, 116, 58, 13, 182,
+  105, 0, 0, 0,
 ]);
 export const initialWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index 0be8937b57d..dd010f0c5e5 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,10 +2,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 177, 10, 192, 32, 16, 67, 227, 21, 74, 233, 212, 79, 177, 127, 208, 159,
-  233, 224, 226, 32, 226, 247, 139, 168, 16, 68, 93, 244, 45, 119, 228, 142, 144, 92, 0, 20, 50, 7, 237, 76, 213, 190,
-  50, 245, 26, 175, 218, 231, 165, 57, 175, 148, 14, 137, 179, 147, 191, 114, 211, 221, 216, 240, 59, 63, 107, 221, 115,
-  104, 181, 103, 244, 43, 36, 10, 38, 68, 108, 25, 253, 238, 136, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 65, 10, 192, 32, 12, 4, 77, 10, 165, 244, 214, 159, 216, 31, 244, 51, 61,
+  120, 241, 32, 226, 251, 85, 140, 176, 136, 122, 209, 129, 144, 176, 9, 97, 151, 84, 225, 74, 69, 50, 31, 48, 35, 85,
+  251, 164, 235, 53, 94, 218, 247, 75, 163, 95, 150, 12, 153, 179, 227, 191, 114, 195, 222, 216, 240, 59, 63, 75, 221,
+  251, 208, 106, 207, 232, 150, 65, 100, 53, 33, 2, 22, 232, 178, 27, 144, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index b5ab64b3447..1d0e06b3c8a 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 145, 187, 17, 0, 32, 8, 67, 195, 111, 31, 220, 192, 253, 167, 178, 144, 2,
-  239, 236, 132, 194, 52, 129, 230, 93, 8, 6, 64, 176, 101, 225, 28, 78, 49, 43, 238, 154, 225, 254, 166, 209, 205, 165,
-  98, 174, 212, 177, 188, 187, 92, 255, 173, 92, 173, 190, 93, 82, 80, 78, 123, 14, 127, 60, 97, 1, 210, 144, 46, 242,
-  19, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 201, 13, 0, 32, 8, 147, 195, 125, 112, 3, 247, 159, 74, 141, 60, 106, 226,
+  79, 120, 216, 132, 180, 124, 154, 82, 168, 108, 212, 57, 2, 122, 129, 157, 201, 181, 150, 59, 186, 179, 189, 161, 101,
+  251, 82, 176, 175, 196, 121, 89, 118, 185, 246, 91, 185, 26, 125, 187, 64, 80, 134, 29, 195, 31, 79, 24, 2, 250, 167,
+  252, 27, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/pedersen.ts b/acvm-repo/acvm_js/test/shared/pedersen.ts
index 5150d24131c..00d207053d8 100644
--- a/acvm-repo/acvm_js/test/shared/pedersen.ts
+++ b/acvm-repo/acvm_js/test/shared/pedersen.ts
@@ -1,7 +1,7 @@
 // See `pedersen_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 135, 9, 0, 48, 8, 75, 171, 224, 255, 15, 139, 27, 196, 64, 200, 100, 0, 15,
-  133, 80, 57, 89, 219, 127, 39, 173, 126, 235, 236, 247, 151, 48, 224, 71, 90, 33, 97, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 7, 6, 0, 0, 8, 108, 209, 255, 63, 156, 54, 233, 56, 55, 17, 26, 18, 196,
+  241, 169, 250, 178, 141, 167, 32, 159, 254, 234, 238, 255, 87, 112, 52, 63, 63, 101, 105, 0, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([[1, '0x0000000000000000000000000000000000000000000000000000000000000001']]);
diff --git a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
index 2127de66f69..14c32c615c8 100644
--- a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
+++ b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
@@ -1,17 +1,17 @@
 // See `schnorr_verify_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 74, 3, 1, 20, 69, 209, 177, 247, 222, 123, 239, 189, 119, 141, 93, 99,
-  220, 133, 251, 95, 130, 152, 103, 78, 32, 3, 195, 33, 4, 66, 248, 239, 254, 20, 69, 209, 84, 212, 158, 216, 206, 223,
-  234, 219, 204, 146, 239, 91, 170, 111, 103, 245, 109, 101, 27, 219, 217, 193, 250, 219, 197, 110, 246, 176, 151, 125,
-  236, 231, 0, 7, 57, 196, 97, 142, 112, 148, 99, 28, 231, 4, 39, 57, 197, 105, 206, 112, 150, 115, 156, 231, 2, 23,
-  185, 196, 101, 174, 112, 149, 107, 92, 231, 6, 55, 185, 197, 109, 238, 112, 151, 123, 220, 231, 1, 15, 121, 196, 99,
-  158, 240, 148, 103, 60, 231, 5, 47, 121, 197, 107, 222, 240, 150, 119, 188, 231, 3, 75, 124, 228, 83, 195, 142, 121,
-  158, 125, 126, 225, 43, 223, 248, 206, 15, 126, 178, 204, 47, 86, 248, 237, 119, 43, 76, 127, 105, 47, 189, 165, 181,
-  116, 150, 198, 234, 125, 117, 249, 47, 233, 41, 45, 165, 163, 52, 148, 126, 210, 78, 186, 73, 51, 233, 37, 173, 164,
-  147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33, 45, 164, 131, 52, 144, 253, 23, 139, 218, 238, 217, 60, 123, 103,
-  235, 236, 156, 141, 179, 239, 166, 93, 183, 237, 185, 107, 199, 125, 251, 29, 218, 237, 216, 94, 167, 118, 58, 183,
-  207, 165, 93, 174, 237, 113, 107, 135, 123, 247, 47, 185, 251, 147, 59, 191, 184, 239, 155, 187, 126, 184, 103, 217,
-  29, 235, 55, 171, 223, 173, 104, 184, 231, 255, 243, 7, 236, 52, 239, 128, 225, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 78, 2, 1, 20, 69, 81, 236, 189, 247, 222, 123, 239, 93, 177, 33, 34,
+  238, 194, 253, 47, 193, 200, 147, 67, 194, 36, 147, 163, 33, 33, 228, 191, 219, 82, 168, 63, 63, 181, 183, 197, 223,
+  177, 147, 191, 181, 183, 149, 69, 159, 183, 213, 222, 238, 218, 219, 206, 14, 118, 178, 139, 141, 183, 135, 189, 236,
+  99, 63, 7, 56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60, 23, 184,
+  200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187, 220, 227, 62, 15, 120, 200, 35, 30,
+  243, 132, 167, 60, 227, 57, 47, 120, 201, 43, 94, 243, 134, 183, 188, 227, 61, 31, 248, 200, 39, 22, 249, 204, 151,
+  166, 29, 243, 188, 250, 255, 141, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 123, 171, 76, 127, 105, 47,
+  189, 165, 181, 116, 150, 198, 26, 125, 245, 248, 45, 233, 41, 45, 165, 163, 52, 148, 126, 210, 78, 186, 73, 51, 233,
+  37, 173, 164, 147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33, 45, 164, 131, 52, 144, 253, 151, 11, 245, 221, 179,
+  121, 246, 206, 214, 217, 57, 27, 103, 223, 109, 187, 238, 218, 115, 223, 142, 135, 246, 59, 182, 219, 169, 189, 206,
+  237, 116, 105, 159, 107, 187, 220, 218, 227, 222, 14, 143, 238, 95, 116, 247, 23, 119, 126, 115, 223, 146, 187, 150,
+  221, 179, 226, 142, 141, 155, 53, 238, 86, 104, 186, 231, 255, 243, 7, 100, 141, 232, 192, 233, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/witness_compression.ts b/acvm-repo/acvm_js/test/shared/witness_compression.ts
index 36b9a0284af..d2326c1b11b 100644
--- a/acvm-repo/acvm_js/test/shared/witness_compression.ts
+++ b/acvm-repo/acvm_js/test/shared/witness_compression.ts
@@ -4,19 +4,21 @@
 //   assert(x != y);
 //   x + y
 // }
+//
+// Regenerate this byte array by going to the Noir integration tests and running `/test_programs/execution_success/witness_compression`
+// after recompiling Noir to print the witness byte array to be written to file after execution
 
 export const expectedCompressedWitnessMap = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 173, 208, 187, 13, 128, 48, 12, 4, 80, 190, 153, 199, 142, 237, 196, 238, 88, 133,
-  8, 103, 255, 17, 64, 34, 5, 61, 62, 233, 164, 171, 94, 113, 105, 122, 51, 63, 61, 198, 134, 127, 193, 37, 206, 202,
-  235, 199, 34, 40, 204, 94, 179, 35, 225, 9, 217, 154, 10, 176, 180, 162, 168, 40, 42, 87, 86, 34, 87, 214, 106, 205,
-  42, 24, 50, 57, 118, 49, 234, 3, 219, 2, 173, 61, 240, 175, 20, 103, 209, 13, 151, 252, 77, 33, 208, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 173, 206, 185, 13, 0, 48, 8, 67, 209, 144, 107, 30, 146, 44, 144, 253, 167, 162,
+  65, 130, 158, 239, 198, 174, 158, 44, 45, 178, 211, 254, 222, 90, 203, 17, 206, 186, 29, 252, 53, 64, 107, 114, 150,
+  46, 206, 122, 6, 24, 73, 44, 193, 220, 1, 0, 0,
 ]);
 
 export const expectedWitnessMap = new Map([
-  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [2, '0x0000000000000000000000000000000000000000000000000000000000000002'],
-  [3, '0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000'],
-  [4, '0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000'],
-  [5, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [6, '0x0000000000000000000000000000000000000000000000000000000000000003'],
+  [0, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [1, '0x0000000000000000000000000000000000000000000000000000000000000002'],
+  [2, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [4, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [5, '0x0000000000000000000000000000000000000000000000000000000000000003'],
 ]);
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index 03a8e53e510..22a0ebe1170 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -156,6 +156,13 @@ pub enum BrilligOpcode {
         destination: MemoryAddress,
         source: MemoryAddress,
     },
+    /// destination = condition > 0 ? source_a : source_b
+    ConditionalMov {
+        destination: MemoryAddress,
+        source_a: MemoryAddress,
+        source_b: MemoryAddress,
+        condition: MemoryAddress,
+    },
     Load {
         destination: MemoryAddress,
         source_pointer: MemoryAddress,
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index c7bf014f068..e2a037618a4 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -339,6 +339,15 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 self.memory.write(*destination_address, source_value);
                 self.increment_program_counter()
             }
+            Opcode::ConditionalMov { destination, source_a, source_b, condition } => {
+                let condition_value = self.memory.read(*condition);
+                if condition_value.is_zero() {
+                    self.memory.write(*destination, self.memory.read(*source_b));
+                } else {
+                    self.memory.write(*destination, self.memory.read(*source_a));
+                }
+                self.increment_program_counter()
+            }
             Opcode::Trap => self.fail("explicit trap hit in brillig".to_string()),
             Opcode::Stop { return_data_offset, return_data_size } => {
                 self.finish(*return_data_offset, *return_data_size)
@@ -793,6 +802,52 @@ mod tests {
         assert_eq!(source_value, Value::from(1u128));
     }
 
+    #[test]
+    fn cmov_opcode() {
+        let calldata =
+            vec![Value::from(0u128), Value::from(1u128), Value::from(2u128), Value::from(3u128)];
+
+        let calldata_copy = Opcode::CalldataCopy {
+            destination_address: MemoryAddress::from(0),
+            size: 4,
+            offset: 0,
+        };
+
+        let opcodes = &[
+            calldata_copy,
+            Opcode::ConditionalMov {
+                destination: MemoryAddress(4), // Sets 3_u128 to memory address 4
+                source_a: MemoryAddress(2),
+                source_b: MemoryAddress(3),
+                condition: MemoryAddress(0),
+            },
+            Opcode::ConditionalMov {
+                destination: MemoryAddress(5), // Sets 2_u128 to memory address 5
+                source_a: MemoryAddress(2),
+                source_b: MemoryAddress(3),
+                condition: MemoryAddress(1),
+            },
+        ];
+        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
+
+        let VM { memory, .. } = vm;
+
+        let destination_value = memory.read(MemoryAddress::from(4));
+        assert_eq!(destination_value, Value::from(3_u128));
+
+        let source_value = memory.read(MemoryAddress::from(5));
+        assert_eq!(source_value, Value::from(2_u128));
+    }
+
     #[test]
     fn cmp_binary_ops() {
         let bit_size = 32;
diff --git a/aztec_macros/Cargo.toml b/aztec_macros/Cargo.toml
index ed9821fabcf..355036d28a7 100644
--- a/aztec_macros/Cargo.toml
+++ b/aztec_macros/Cargo.toml
@@ -14,3 +14,5 @@ noirc_frontend.workspace = true
 noirc_errors.workspace = true
 iter-extended.workspace = true
 convert_case = "0.6.0"
+regex = "1.10"
+
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index e0100977eee..0fe450e6cb1 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -5,22 +5,27 @@ use transforms::{
     compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
     events::{generate_selector_impl, transform_events},
     functions::{transform_function, transform_unconstrained, transform_vm_function},
+    note_interface::generate_note_interface_impl,
     storage::{
         assign_storage_slots, check_for_storage_definition, check_for_storage_implementation,
         generate_storage_implementation,
     },
 };
 
-use noirc_frontend::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
-
-use noirc_frontend::macros_api::SortedModule;
-use noirc_frontend::macros_api::{CrateId, MacroError};
-use noirc_frontend::macros_api::{FileId, MacroProcessor};
-use noirc_frontend::macros_api::{HirContext, SecondaryAttribute, Span};
+use noirc_frontend::{
+    hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
+    macros_api::{
+        CrateId, FileId, HirContext, MacroError, MacroProcessor, SecondaryAttribute, SortedModule,
+        Span,
+    },
+};
 
-use utils::ast_utils::is_custom_attribute;
-use utils::checks::{check_for_aztec_dependency, has_aztec_dependency};
-use utils::{constants::MAX_CONTRACT_PRIVATE_FUNCTIONS, errors::AztecMacroError};
+use utils::{
+    ast_utils::is_custom_attribute,
+    checks::{check_for_aztec_dependency, has_aztec_dependency},
+    constants::MAX_CONTRACT_PRIVATE_FUNCTIONS,
+    errors::AztecMacroError,
+};
 pub struct AztecMacro;
 
 impl MacroProcessor for AztecMacro {
@@ -28,9 +33,10 @@ impl MacroProcessor for AztecMacro {
         &self,
         ast: SortedModule,
         crate_id: &CrateId,
+        file_id: FileId,
         context: &HirContext,
     ) -> Result<SortedModule, (MacroError, FileId)> {
-        transform(ast, crate_id, context)
+        transform(ast, crate_id, file_id, context)
     }
 
     fn process_collected_defs(
@@ -61,38 +67,34 @@ impl MacroProcessor for AztecMacro {
 fn transform(
     mut ast: SortedModule,
     crate_id: &CrateId,
+    file_id: FileId,
     context: &HirContext,
 ) -> Result<SortedModule, (MacroError, FileId)> {
     // Usage -> mut ast -> aztec_library::transform(&mut ast)
     // Covers all functions in the ast
     for submodule in ast.submodules.iter_mut().filter(|submodule| submodule.is_contract) {
-        if transform_module(&mut submodule.contents, crate_id, context)
-            .map_err(|(err, file_id)| (err.into(), file_id))?
-        {
+        if transform_module(&mut submodule.contents).map_err(|err| (err.into(), file_id))? {
             check_for_aztec_dependency(crate_id, context)?;
         }
     }
+
+    generate_note_interface_impl(&mut ast).map_err(|err| (err.into(), file_id))?;
+
     Ok(ast)
 }
 
 /// Determines if ast nodes are annotated with aztec attributes.
 /// For annotated functions it calls the `transform` function which will perform the required transformations.
 /// Returns true if an annotated node is found, false otherwise
-fn transform_module(
-    module: &mut SortedModule,
-    crate_id: &CrateId,
-    context: &HirContext,
-) -> Result<bool, (AztecMacroError, FileId)> {
+fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError> {
     let mut has_transformed_module = false;
 
     // Check for a user defined storage struct
     let storage_defined = check_for_storage_definition(module);
     let storage_implemented = check_for_storage_implementation(module);
 
-    let crate_graph = &context.crate_graph[crate_id];
-
     if storage_defined && !storage_implemented {
-        generate_storage_implementation(module).map_err(|err| (err, crate_graph.root_file_id))?;
+        generate_storage_implementation(module)?;
     }
 
     for structure in module.types.iter() {
@@ -144,12 +146,10 @@ fn transform_module(
                 is_initializer,
                 insert_init_check,
                 is_internal,
-            )
-            .map_err(|err| (err, crate_graph.root_file_id))?;
+            )?;
             has_transformed_module = true;
         } else if is_public_vm {
-            transform_vm_function(func, storage_defined)
-                .map_err(|err| (err, crate_graph.root_file_id))?;
+            transform_vm_function(func, storage_defined)?;
             has_transformed_module = true;
         } else if storage_defined && func.def.is_unconstrained {
             transform_unconstrained(func);
@@ -173,11 +173,9 @@ fn transform_module(
             .count();
 
         if private_functions_count > MAX_CONTRACT_PRIVATE_FUNCTIONS {
-            let crate_graph = &context.crate_graph[crate_id];
-            return Err((
-                AztecMacroError::ContractHasTooManyPrivateFunctions { span: Span::default() },
-                crate_graph.root_file_id,
-            ));
+            return Err(AztecMacroError::ContractHasTooManyPrivateFunctions {
+                span: Span::default(),
+            });
         }
     }
 
diff --git a/aztec_macros/src/transforms/mod.rs b/aztec_macros/src/transforms/mod.rs
index 144ffc3efc3..5a454c75148 100644
--- a/aztec_macros/src/transforms/mod.rs
+++ b/aztec_macros/src/transforms/mod.rs
@@ -1,4 +1,5 @@
 pub mod compute_note_hash_and_nullifier;
 pub mod events;
 pub mod functions;
+pub mod note_interface;
 pub mod storage;
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
new file mode 100644
index 00000000000..01d0272088b
--- /dev/null
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -0,0 +1,583 @@
+use noirc_errors::Span;
+use noirc_frontend::{
+    parse_program, parser::SortedModule, ItemVisibility, NoirFunction, NoirStruct, PathKind,
+    TraitImplItem, TypeImpl, UnresolvedTypeData, UnresolvedTypeExpression,
+};
+use regex::Regex;
+
+use crate::{
+    chained_dep,
+    utils::{
+        ast_utils::{
+            check_trait_method_implemented, ident, ident_path, is_custom_attribute, make_type,
+        },
+        errors::AztecMacroError,
+    },
+};
+
+// Automatic implementation of most of the methods in the NoteInterface trait, guiding the user with meaningful error messages in case some
+// methods must be implemented manually.
+pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), AztecMacroError> {
+    // Find structs annotated with #[aztec(note)]
+    let annotated_note_structs = module
+        .types
+        .iter_mut()
+        .filter(|typ| typ.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(note)")));
+
+    let mut note_properties_structs = vec![];
+
+    for note_struct in annotated_note_structs {
+        // Look for the NoteInterface trait implementation for the note
+        let trait_impl = module
+            .trait_impls
+            .iter_mut()
+            .find(|trait_impl| {
+                if let UnresolvedTypeData::Named(struct_path, _, _) = &trait_impl.object_type.typ {
+                    struct_path.last_segment() == note_struct.name
+                        && trait_impl.trait_name.last_segment().0.contents == "NoteInterface"
+                } else {
+                    false
+                }
+            })
+            .ok_or(AztecMacroError::CouldNotImplementNoteInterface {
+                span: Some(note_struct.name.span()),
+                secondary_message: Some(format!(
+                    "Could not find NoteInterface trait implementation for note: {}",
+                    note_struct.name.0.contents
+                )),
+            })?;
+        let note_interface_impl_span: Option<Span> = trait_impl.object_type.span;
+        // Look for the note struct implementation, generate a default one if it doesn't exist (in order to append methods to it)
+        let existing_impl = module.impls.iter_mut().find(|r#impl| match &r#impl.object_type.typ {
+            UnresolvedTypeData::Named(path, _, _) => path.last_segment().eq(&note_struct.name),
+            _ => false,
+        });
+        let note_impl = if let Some(note_impl) = existing_impl {
+            note_impl
+        } else {
+            let default_impl = TypeImpl {
+                object_type: trait_impl.object_type.clone(),
+                type_span: note_struct.name.span(),
+                generics: vec![],
+                methods: vec![],
+            };
+            module.impls.push(default_impl.clone());
+            module.impls.last_mut().unwrap()
+        };
+        // Identify the note type (struct name), its fields and its serialized length (generic param of NoteInterface trait impl)
+        let note_type = note_struct.name.0.contents.to_string();
+        let mut note_fields = vec![];
+        let note_serialized_len = match &trait_impl.trait_generics[0].typ {
+            UnresolvedTypeData::Named(path, _, _) => Ok(path.last_segment().0.contents.to_string()),
+            UnresolvedTypeData::Expression(UnresolvedTypeExpression::Constant(val, _)) => {
+                Ok(val.to_string())
+            }
+            _ => Err(AztecMacroError::CouldNotImplementNoteInterface {
+                span: trait_impl.object_type.span,
+                secondary_message: Some(format!(
+                    "Cannot find note serialization length for: {}",
+                    note_type
+                )),
+            }),
+        }?;
+
+        // Automatically inject the header field if it's not present
+        let (header_field_name, _) = if let Some(existing_header) =
+            note_struct.fields.iter().find(|(_, field_type)| match &field_type.typ {
+                UnresolvedTypeData::Named(path, _, _) => {
+                    path.last_segment().0.contents == "NoteHeader"
+                }
+                _ => false,
+            }) {
+            existing_header.clone()
+        } else {
+            let generated_header = (
+                ident("header"),
+                make_type(UnresolvedTypeData::Named(
+                    chained_dep!("aztec", "note", "note_header", "NoteHeader"),
+                    vec![],
+                    false,
+                )),
+            );
+            note_struct.fields.push(generated_header.clone());
+            generated_header
+        };
+
+        for (field_ident, field_type) in note_struct.fields.iter() {
+            note_fields.push((
+                field_ident.0.contents.to_string(),
+                field_type.typ.to_string().replace("plain::", ""),
+            ));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "serialize_content")
+            && !check_trait_method_implemented(trait_impl, "deserialize_content")
+            && !note_impl.methods.iter().any(|(func, _)| func.def.name.0.contents == "properties")
+        {
+            let note_serialize_content_fn = generate_note_serialize_content(
+                &note_type,
+                &note_fields,
+                &note_serialized_len,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(note_serialize_content_fn));
+
+            let note_deserialize_content_fn = generate_note_deserialize_content(
+                &note_type,
+                &note_fields,
+                &note_serialized_len,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(note_deserialize_content_fn));
+
+            let note_properties_struct = generate_note_properties_struct(
+                &note_type,
+                &note_fields,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            note_properties_structs.push(note_properties_struct);
+            let note_properties_fn = generate_note_properties_fn(
+                &note_type,
+                &note_fields,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            note_impl.methods.push((note_properties_fn, note_impl.type_span));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "get_header") {
+            let get_header_fn = generate_note_get_header(
+                &note_type,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(get_header_fn));
+        }
+        if !check_trait_method_implemented(trait_impl, "set_header") {
+            let set_header_fn = generate_note_set_header(
+                &note_type,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(set_header_fn));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "get_note_type_id") {
+            let get_note_type_id_fn =
+                generate_note_get_type_id(&note_type, note_interface_impl_span)?;
+            trait_impl.items.push(TraitImplItem::Function(get_note_type_id_fn));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "compute_note_content_hash") {
+            let get_header_fn =
+                generate_compute_note_content_hash(&note_type, note_interface_impl_span)?;
+            trait_impl.items.push(TraitImplItem::Function(get_header_fn));
+        }
+    }
+
+    module.types.extend(note_properties_structs);
+    Ok(())
+}
+
+fn generate_note_get_header(
+    note_type: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn get_header(note: {}) -> dep::aztec::note::note_header::NoteHeader {{
+            note.{}
+        }}
+    ",
+        note_type, note_header_field_name
+    )
+    .to_string();
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn get_header). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+fn generate_note_set_header(
+    note_type: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn set_header(self: &mut {}, header: dep::aztec::note::note_header::NoteHeader) {{
+            self.{} = header;
+        }}
+    ",
+        note_type, note_header_field_name
+    );
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface  {
+            secondary_message: Some("Failed to parse Noir macro code (fn set_header). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate the note type id getter method. The id itself its calculated as the concatenation
+// of the conversion of the characters in the note's struct name to unsigned integers.
+fn generate_note_get_type_id(
+    note_type: &str,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    // TODO(#4519) Improve automatic note id generation and assignment
+    let note_id =
+        note_type.chars().map(|c| (c as u32).to_string()).collect::<Vec<String>>().join("");
+    let function_source = format!(
+        "
+        fn get_note_type_id() -> Field {{
+            {}
+        }}
+    ",
+        note_id
+    )
+    .to_string();
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn get_note_type_id). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate a struct that represents the note's serialization metadata, as
+//
+// NoteTypeFields {
+//     field1: PropertySelector { index: 0, offset: 0, length: 32 },
+//     field2: PropertySelector { index: 1, offset: 0, length: 32 },
+//     ...
+// }
+//
+// It assumes each field occupies an entire field and its serialized in definition order
+fn generate_note_properties_struct(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirStruct, AztecMacroError> {
+    let struct_source =
+        generate_note_properties_struct_source(note_type, note_fields, note_header_field_name);
+
+    let (struct_ast, errors) = parse_program(&struct_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some(format!("Failed to parse Noir macro code (struct {}Properties). This is either a bug in the compiler or the Noir macro code", note_type)),
+            span: impl_span
+        });
+    }
+
+    let mut struct_ast = struct_ast.into_sorted();
+    Ok(struct_ast.types.remove(0))
+}
+
+// Generate the deserialize_content method as
+//
+// fn deserialize_content(serialized_note: [Field; NOTE_SERILIZED_LEN]) -> Self {
+//     NoteType {
+//        note_field1: serialized_note[0] as Field,
+//        note_field2: NoteFieldType2::from_field(serialized_note[1])...
+//     }
+// }
+// It assumes every note field is stored in an individual serialized field,
+// and can be converted to the original type via the from_field() trait (structs) or cast as Field (integers)
+fn generate_note_deserialize_content(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = generate_note_deserialize_content_source(
+        note_type,
+        note_fields,
+        note_serialize_len,
+        note_header_field_name,
+    );
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn deserialize_content). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Generate the serialize_content method as
+//
+// fn serialize_content(self: {}) -> [Field; NOTE_SERIALIZED_LEN] {
+//   [self.note_field1 as Field, self.note_field2.to_field()...]
+// }
+//
+// It assumes every struct field can be converted either via the to_field() trait (structs) or cast as Field (integers)
+fn generate_note_serialize_content(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = generate_note_serialize_content_source(
+        note_type,
+        note_fields,
+        note_serialize_len,
+        note_header_field_name,
+    );
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn serialize_content). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate a function in the Note's impl that returns the note's fields metadata
+fn generate_note_properties_fn(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source =
+        generate_note_properties_fn_source(note_type, note_fields, note_header_field_name);
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn properties). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate the method to compute the note's content hash as:
+// fn compute_note_content_hash(self: NoteType) -> Field {
+//    // TODO(#1205) Should use a non-zero generator index.
+//    dep::aztec::hash::pedersen_hash(self.serialize_content(), 0)
+// }
+//
+fn generate_compute_note_content_hash(
+    note_type: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn compute_note_content_hash(self: {}) -> Field {{
+            // TODO(#1205) Should use a non-zero generator index.
+            dep::aztec::hash::pedersen_hash(self.serialize_content(), 0)
+        }}
+        ",
+        note_type
+    );
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn compute_note_content_hash). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Source code generator functions. These utility methods produce Noir code as strings, that are then parsed and added to the AST.
+
+fn generate_note_properties_struct_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+) -> String {
+    let note_property_selectors = note_fields
+        .iter()
+        .filter_map(|(field_name, _)| {
+            if field_name != note_header_field_name {
+                Some(format!(
+                    "{}: dep::aztec::note::note_getter_options::PropertySelector",
+                    field_name
+                ))
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(",\n");
+    format!(
+        "
+        struct {}Properties {{
+            {}
+        }}",
+        note_type, note_property_selectors
+    )
+    .to_string()
+}
+
+fn generate_note_properties_fn_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+) -> String {
+    let note_property_selectors = note_fields
+        .iter()
+        .enumerate()
+        .filter_map(|(index, (field_name, _))| {
+            if field_name != note_header_field_name {
+                Some(format!(
+                    "{}: dep::aztec::note::note_getter_options::PropertySelector {{ index: {}, offset: 0, length: 32 }}",
+                    field_name,
+                    index
+                ))
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(", ");
+    format!(
+        "
+        pub fn properties() -> {}Properties {{
+            {}Properties {{
+                {}
+            }}
+        }}",
+        note_type, note_type, note_property_selectors
+    )
+    .to_string()
+}
+
+fn generate_note_serialize_content_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+) -> String {
+    let note_fields = note_fields
+        .iter()
+        .filter_map(|(field_name, field_type)| {
+            if field_name != note_header_field_name {
+                if field_type == "Field" {
+                    Some(format!("self.{}", field_name))
+                } else {
+                    Some(format!("self.{}.to_field()", field_name))
+                }
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(", ");
+    format!(
+        "
+        fn serialize_content(self: {}) -> [Field; {}] {{
+            [{}]
+        }}",
+        note_type, note_serialize_len, note_fields
+    )
+    .to_string()
+}
+
+fn generate_note_deserialize_content_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+) -> String {
+    let note_fields = note_fields
+        .iter()
+        .enumerate()
+        .map(|(index, (field_name, field_type))| {
+            if field_name != note_header_field_name {
+                // TODO: Simplify this when https://github.com/noir-lang/noir/issues/4463 is fixed
+                if field_type.eq("Field")
+                    || Regex::new(r"u[0-9]+").unwrap().is_match(field_type)
+                    || field_type.eq("bool")
+                {
+                    format!("{}: serialized_note[{}] as {},", field_name, index, field_type)
+                } else {
+                    format!(
+                        "{}: {}::from_field(serialized_note[{}]),",
+                        field_name, field_type, index
+                    )
+                }
+            } else {
+                format!(
+                    "{}: dep::aztec::note::note_header::NoteHeader::empty()",
+                    note_header_field_name
+                )
+            }
+        })
+        .collect::<Vec<String>>()
+        .join("\n");
+    format!(
+        "
+        fn deserialize_content(serialized_note: [Field; {}]) -> Self {{
+            {} {{
+                {}
+            }}
+        }}",
+        note_serialize_len, note_type, note_fields
+    )
+    .to_string()
+}
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index 71c6a93f388..bdcbad646c2 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -2,8 +2,9 @@ use noirc_errors::{Span, Spanned};
 use noirc_frontend::{
     token::SecondaryAttribute, BinaryOpKind, CallExpression, CastExpression, Expression,
     ExpressionKind, FunctionReturnType, Ident, IndexExpression, InfixExpression, Lambda,
-    LetStatement, MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression,
-    Statement, StatementKind, UnaryOp, UnresolvedType, UnresolvedTypeData,
+    LetStatement, MemberAccessExpression, MethodCallExpression, NoirTraitImpl, Path, Pattern,
+    PrefixExpression, Statement, StatementKind, TraitImplItem, UnaryOp, UnresolvedType,
+    UnresolvedTypeData,
 };
 
 //
@@ -173,6 +174,13 @@ pub fn index_array_variable(array: Expression, index: &str) -> Expression {
     })))
 }
 
+pub fn check_trait_method_implemented(trait_impl: &NoirTraitImpl, method_name: &str) -> bool {
+    trait_impl.items.iter().any(|item| match item {
+        TraitImplItem::Function(func) => func.def.name.0.contents == method_name,
+        _ => false,
+    })
+}
+
 /// Checks if an attribute is a custom attribute with a specific name
 pub fn is_custom_attribute(attr: &SecondaryAttribute, attribute_name: &str) -> bool {
     if let SecondaryAttribute::Custom(custom_attr) = attr {
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 199473baec6..48186555eff 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -10,7 +10,7 @@ pub enum AztecMacroError {
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
-    CouldNotImplementNoteSerialization { span: Option<Span>, typ: UnresolvedTypeData },
+    CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
     EventError { span: Span, message: String },
     UnsupportedAttributes { span: Span, secondary_message: Option<String> },
 }
@@ -43,9 +43,9 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span: None,
             },
-            AztecMacroError::CouldNotImplementNoteSerialization { span, typ } => MacroError {
-                primary_message: format!("Could not implement serialization methods for note `{typ:?}`, please provide a serialize_content and deserialize_content methods"),
-                secondary_message: None,
+            AztecMacroError::CouldNotImplementNoteInterface { span, secondary_message } => MacroError {
+                primary_message: "Could not implement automatic methods for note, please provide an implementation of the NoteInterface trait".to_string(),
+                secondary_message,
                 span,
             },
             AztecMacroError::EventError { span, message } => MacroError {
@@ -53,7 +53,7 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: Some(span),
             },
-AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
+            AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
                 primary_message: "Unsupported attributes in contract function".to_string(),
                 secondary_message,
                 span: Some(span),
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index 66e8dc0e730..9a0e25a321b 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use fm::FileId;
 use noirc_abi::{Abi, ContractEvent};
 use noirc_errors::debug_info::DebugInfo;
@@ -45,10 +45,10 @@ pub struct ContractFunction {
     pub abi: Abi,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Circuit,
+    pub bytecode: Program,
 
     pub debug: DebugInfo,
 }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index c9494a64b41..bc3062e5807 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -3,7 +3,7 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
-use acvm::acir::circuit::ExpressionWidth;
+use acvm::acir::circuit::{ExpressionWidth, Program};
 use clap::Args;
 use fm::{FileId, FileManager};
 use iter_extended::vecmap;
@@ -298,7 +298,7 @@ pub fn compile_main(
 
     if options.print_acir {
         println!("Compiled ACIR for main (unoptimized):");
-        println!("{}", compiled_program.circuit);
+        println!("{}", compiled_program.program);
     }
 
     Ok((compiled_program, warnings))
@@ -414,7 +414,7 @@ fn compile_contract_inner(
             name,
             custom_attributes,
             abi: function.abi,
-            bytecode: function.circuit,
+            bytecode: function.program,
             debug: function.debug,
             is_unconstrained: modifiers.is_unconstrained,
         });
@@ -487,7 +487,8 @@ pub fn compile_no_check(
 
     Ok(CompiledProgram {
         hash,
-        circuit,
+        // TODO(https://github.com/noir-lang/noir/issues/4428)
+        program: Program { functions: vec![circuit] },
         debug,
         abi,
         file_map,
diff --git a/compiler/noirc_driver/src/program.rs b/compiler/noirc_driver/src/program.rs
index 8d509d3bf68..6f527297dcb 100644
--- a/compiler/noirc_driver/src/program.rs
+++ b/compiler/noirc_driver/src/program.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use fm::FileId;
 
 use noirc_errors::debug_info::DebugInfo;
@@ -19,10 +19,10 @@ pub struct CompiledProgram {
     pub hash: u64,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub circuit: Circuit,
+    pub program: Program,
     pub abi: noirc_abi::Abi,
     pub debug: DebugInfo,
     pub file_map: BTreeMap<FileId, DebugFile>,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index a9eea74ddd9..94e81d02053 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1346,18 +1346,23 @@ impl<'block> BrilligBlock<'block> {
             BrilligBinaryOp::LessThan,
         );
 
-        self.brillig_context.codegen_branch(result_is_negative.address, |ctx, is_negative| {
-            if is_negative {
-                // Two's complement of num
-                let zero = ctx.make_constant_instruction(0_usize.into(), num.bit_size);
-                ctx.binary_instruction(zero, num, absolute_value, BrilligBinaryOp::Sub);
-                ctx.deallocate_single_addr(zero);
-            } else {
-                // Simply move the original num
-                ctx.mov_instruction(absolute_value.address, num.address);
-            }
-        });
+        // Two's complement of num
+        let zero = self.brillig_context.make_constant_instruction(0_usize.into(), num.bit_size);
+        let twos_complement =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), num.bit_size);
+        self.brillig_context.binary_instruction(zero, num, twos_complement, BrilligBinaryOp::Sub);
+
+        // absolute_value = result_is_negative ? twos_complement : num
+        self.brillig_context.conditional_mov_instruction(
+            absolute_value.address,
+            result_is_negative.address,
+            twos_complement.address,
+            num.address,
+        );
+
+        self.brillig_context.deallocate_single_addr(zero);
         self.brillig_context.deallocate_single_addr(max_positive);
+        self.brillig_context.deallocate_single_addr(twos_complement);
     }
 
     fn convert_signed_division(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index fa99e968a31..5611905697c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -121,6 +121,24 @@ impl DebugShow {
         debug_println!(self.enable_debug_trace, "  MOV {}, {}", destination, source);
     }
 
+    /// Emits a conditional `mov` instruction.
+    pub(crate) fn conditional_mov_instruction(
+        &self,
+        destination: MemoryAddress,
+        condition: MemoryAddress,
+        source_a: MemoryAddress,
+        source_b: MemoryAddress,
+    ) {
+        debug_println!(
+            self.enable_debug_trace,
+            "  CMOV {} = {}? {} : {}",
+            destination,
+            condition,
+            source_a,
+            source_b
+        );
+    }
+
     /// Emits a `cast` instruction.
     pub(crate) fn cast_instruction(
         &self,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 5c2a6bfacca..99fb4c89f64 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -359,6 +359,25 @@ impl BrilligContext {
         self.push_opcode(BrilligOpcode::Mov { destination, source });
     }
 
+    /// Emits a conditional `mov` instruction.
+    ///
+    /// Copies the value at `source` into `destination`
+    pub(crate) fn conditional_mov_instruction(
+        &mut self,
+        destination: MemoryAddress,
+        condition: MemoryAddress,
+        source_a: MemoryAddress,
+        source_b: MemoryAddress,
+    ) {
+        self.debug_show.conditional_mov_instruction(destination, condition, source_a, source_b);
+        self.push_opcode(BrilligOpcode::ConditionalMov {
+            destination,
+            source_a,
+            source_b,
+            condition,
+        });
+    }
+
     /// Cast truncates the value to the given bit size and converts the type of the value in memory to that bit size.
     pub(crate) fn cast_instruction(
         &mut self,
diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index 06259e06248..b3e838e708e 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -140,8 +140,8 @@ impl RuntimeError {
             | RuntimeError::UnsupportedIntegerSize { call_stack, .. }
             | RuntimeError::NestedSlice { call_stack, .. }
             | RuntimeError::BigIntModulus { call_stack, .. }
-            | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack } => call_stack,
-            RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
+            | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack }
+            | RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 5adb9eb5b7e..fcb20c740c7 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -577,7 +577,12 @@ impl<'a> ModCollector<'a> {
         let mut ast = ast.into_sorted();
 
         for macro_processor in macro_processors {
-            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, context) {
+            match macro_processor.process_untyped_ast(
+                ast.clone(),
+                &crate_id,
+                child_file_id,
+                context,
+            ) {
                 Ok(processed_ast) => {
                     ast = processed_ast;
                 }
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 1326ffca9f7..157227f763e 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -91,7 +91,8 @@ impl CrateDefMap {
         let mut ast = ast.into_sorted();
 
         for macro_processor in macro_processors {
-            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, context) {
+            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, root_file_id, context)
+            {
                 Ok(processed_ast) => {
                     ast = processed_ast;
                 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 4e2a3a8b4a2..642cebc83b0 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -235,9 +235,9 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::OverflowingAssignment { span, .. }
             | TypeCheckError::FieldModulo { span }
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
-            | TypeCheckError::NonConstantSliceLength { span }
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
-            | TypeCheckError::UnconstrainedSliceReturnToConstrained { span } => {
+            | TypeCheckError::UnconstrainedSliceReturnToConstrained { span }
+            | TypeCheckError::NonConstantSliceLength { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 6ee0460784f..10476b6caef 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -217,7 +217,7 @@ impl<'interner> TypeChecker<'interner> {
                         });
                         return Type::Error;
                     }
-                }
+                };
 
                 return_type
             }
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 1871b594ae7..6ce6f4325e4 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -72,6 +72,7 @@ pub mod macros_api {
             &self,
             ast: SortedModule,
             crate_id: &CrateId,
+            file_id: FileId,
             context: &HirContext,
         ) -> Result<SortedModule, (MacroError, FileId)>;
 
diff --git a/test_programs/compile_failure/unconstrained_oracle/Nargo.toml b/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
index 1081b5ab8e2..7c3fb8766bf 100644
--- a/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
+++ b/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
@@ -2,4 +2,6 @@
 name = "unconstrained_oracle"
 type = "bin"
 authors = [""]
+compiler_version = ">=0.25.0"
+
 [dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/unconstrained_ref/Nargo.toml b/test_programs/compile_failure/unconstrained_ref/Nargo.toml
index b120a3b5532..c03aaea5fca 100644
--- a/test_programs/compile_failure/unconstrained_ref/Nargo.toml
+++ b/test_programs/compile_failure/unconstrained_ref/Nargo.toml
@@ -2,4 +2,6 @@
 name = "unconstrained_ref"
 type = "bin"
 authors = [""]
+compiler_version = ">=0.25.0"
+
 [dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/unconstrained_ref/src/main.nr b/test_programs/compile_failure/unconstrained_ref/src/main.nr
index bb4b2090ddb..1491badaa49 100644
--- a/test_programs/compile_failure/unconstrained_ref/src/main.nr
+++ b/test_programs/compile_failure/unconstrained_ref/src/main.nr
@@ -5,4 +5,4 @@ unconstrained fn uncon_ref() -> &mut Field {
 
 fn main() {
     let e = uncon_ref();
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/witness_compression/Nargo.toml b/test_programs/execution_success/witness_compression/Nargo.toml
new file mode 100644
index 00000000000..7d6ba0c1938
--- /dev/null
+++ b/test_programs/execution_success/witness_compression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "witness_compression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.24.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/witness_compression/Prover.toml b/test_programs/execution_success/witness_compression/Prover.toml
new file mode 100644
index 00000000000..8c12ebba6cf
--- /dev/null
+++ b/test_programs/execution_success/witness_compression/Prover.toml
@@ -0,0 +1,2 @@
+x = "1"
+y = "2"
diff --git a/test_programs/execution_success/witness_compression/src/main.nr b/test_programs/execution_success/witness_compression/src/main.nr
new file mode 100644
index 00000000000..3027d35b13a
--- /dev/null
+++ b/test_programs/execution_success/witness_compression/src/main.nr
@@ -0,0 +1,7 @@
+// This test should be used to regenerate the serialized witness used in the `acvm_js` integration tests.
+// The `acvm_js` test file containing the serialized witness should be also called `witness_compression`.
+// After recompiling Noir, you can manually print the witness byte array to be written to file after execution.
+fn main(x: Field, y: pub Field) -> pub Field {
+    assert(x != y);
+    x + y
+}
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index 255b6131fd6..b76d0eccc29 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -1,6 +1,6 @@
 use std::io::{self, Write};
 
-use acir::circuit::Circuit;
+use acir::circuit::Program;
 use acir::native_types::WitnessMap;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
@@ -66,10 +66,10 @@ pub(crate) fn execute_program_from_witness(
     foreign_call_resolver_url: Option<&str>,
 ) -> Result<WitnessMap, CliError> {
     let blackbox_solver = Bn254BlackBoxSolver::new();
-    let circuit: Circuit = Circuit::deserialize_circuit(bytecode)
+    let program: Program = Program::deserialize_program(bytecode)
         .map_err(|_| CliError::CircuitDeserializationError())?;
     execute_circuit(
-        &circuit,
+        &program.functions[0],
         inputs_map.clone(),
         &blackbox_solver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
diff --git a/tooling/acvm_cli/src/errors.rs b/tooling/acvm_cli/src/errors.rs
index 035388d05f7..923046410ea 100644
--- a/tooling/acvm_cli/src/errors.rs
+++ b/tooling/acvm_cli/src/errors.rs
@@ -32,7 +32,7 @@ pub(crate) enum CliError {
     FilesystemError(#[from] FilesystemError),
 
     /// Error related to circuit deserialization
-    #[error("Error: failed to deserialize circuit")]
+    #[error("Error: failed to deserialize circuit in ACVM CLI")]
     CircuitDeserializationError(),
 
     /// Error related to circuit execution
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index 485381006df..105ae337793 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -3,8 +3,8 @@ use std::io::Write;
 use std::path::Path;
 
 use acvm::acir::{
-    circuit::{Circuit, ExpressionWidth},
-    native_types::WitnessMap,
+    circuit::{ExpressionWidth, Program},
+    native_types::{WitnessMap, WitnessStack},
 };
 use acvm::FieldElement;
 use tempfile::tempdir;
@@ -17,7 +17,7 @@ use crate::cli::{
 use crate::{Backend, BackendError};
 
 impl Backend {
-    pub fn get_exact_circuit_size(&self, circuit: &Circuit) -> Result<u32, BackendError> {
+    pub fn get_exact_circuit_size(&self, program: &Program) -> Result<u32, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
 
@@ -26,8 +26,8 @@ impl Backend {
 
         // Create a temporary file for the circuit
         let circuit_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &circuit_path);
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &circuit_path);
 
         GatesCommand { crs_path: self.crs_directory(), bytecode_path: circuit_path }
             .run(binary_path)
@@ -55,8 +55,8 @@ impl Backend {
     #[tracing::instrument(level = "trace", skip_all)]
     pub fn prove(
         &self,
-        circuit: &Circuit,
-        witness_values: WitnessMap,
+        program: &Program,
+        witness_values: WitnessStack,
     ) -> Result<Vec<u8>, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
@@ -72,9 +72,9 @@ impl Backend {
 
         // Create a temporary file for the circuit
         //
-        let bytecode_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create proof and store it in the specified path
         let proof_with_public_inputs =
@@ -82,7 +82,8 @@ impl Backend {
                 .run(binary_path)?;
 
         let proof = bb_abstraction_leaks::remove_public_inputs(
-            circuit.public_inputs().0.len(),
+            // TODO(https://github.com/noir-lang/noir/issues/4428)
+            program.functions[0].public_inputs().0.len(),
             &proof_with_public_inputs,
         );
         Ok(proof)
@@ -93,7 +94,7 @@ impl Backend {
         &self,
         proof: &[u8],
         public_inputs: WitnessMap,
-        circuit: &Circuit,
+        program: &Program,
     ) -> Result<bool, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
@@ -108,9 +109,9 @@ impl Backend {
         write_to_file(&proof_with_public_inputs, &proof_path);
 
         // Create a temporary file for the circuit
-        let bytecode_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create the verification key and write it to the specified path
         let vk_path = temp_directory.join("vk");
@@ -128,7 +129,7 @@ impl Backend {
 
     pub fn get_intermediate_proof_artifacts(
         &self,
-        circuit: &Circuit,
+        program: &Program,
         proof: &[u8],
         public_inputs: WitnessMap,
     ) -> Result<(Vec<FieldElement>, FieldElement, Vec<FieldElement>), BackendError> {
@@ -140,9 +141,9 @@ impl Backend {
 
         // Create a temporary file for the circuit
         //
-        let bytecode_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create the verification key and write it to the specified path
         let vk_path = temp_directory.join("vk");
diff --git a/tooling/backend_interface/src/smart_contract.rs b/tooling/backend_interface/src/smart_contract.rs
index 5af75e48389..f6beeeb09d9 100644
--- a/tooling/backend_interface/src/smart_contract.rs
+++ b/tooling/backend_interface/src/smart_contract.rs
@@ -3,11 +3,11 @@ use crate::{
     cli::{ContractCommand, WriteVkCommand},
     Backend, BackendError,
 };
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use tempfile::tempdir;
 
 impl Backend {
-    pub fn eth_contract(&self, circuit: &Circuit) -> Result<String, BackendError> {
+    pub fn eth_contract(&self, program: &Program) -> Result<String, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
 
@@ -15,9 +15,9 @@ impl Backend {
         let temp_directory_path = temp_directory.path().to_path_buf();
 
         // Create a temporary file for the circuit
-        let bytecode_path = temp_directory_path.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory_path.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create the verification key and write it to the specified path
         let vk_path = temp_directory_path.join("vk");
@@ -38,7 +38,7 @@ mod tests {
     use std::collections::BTreeSet;
 
     use acvm::acir::{
-        circuit::{Circuit, ExpressionWidth, Opcode, PublicInputs},
+        circuit::{Circuit, ExpressionWidth, Opcode, Program, PublicInputs},
         native_types::{Expression, Witness},
     };
 
@@ -59,8 +59,9 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
+        let program = Program { functions: vec![circuit] };
 
-        let contract = get_mock_backend()?.eth_contract(&circuit)?;
+        let contract = get_mock_backend()?.eth_contract(&program)?;
 
         assert!(contract.contains("contract VerifierContract"));
 
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 2eae9e1f07e..362d2132952 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.29.0";
+const VERSION: &str = "0.30.1";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index 7c722ed0a61..ea3204ebbbc 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -607,8 +607,13 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver>(
         file_map: program.file_map,
         warnings: program.warnings,
     };
-    let mut session =
-        DapSession::new(server, solver, &program.circuit, &debug_artifact, initial_witness);
+    let mut session = DapSession::new(
+        server,
+        solver,
+        &program.program.functions[0],
+        &debug_artifact,
+        initial_witness,
+    );
 
     session.run_loop()
 }
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index 020ce49662f..c0316a6d1a2 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -1,4 +1,4 @@
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use noirc_abi::{Abi, ContractEvent};
 use noirc_driver::{CompiledContract, ContractFunction};
 use serde::{Deserialize, Serialize};
@@ -50,10 +50,10 @@ pub struct ContractFunctionArtifact {
     pub abi: Abi,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Circuit,
+    pub bytecode: Program,
 
     #[serde(
         serialize_with = "DebugInfo::serialize_compressed_base64_json",
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/nargo/src/artifacts/program.rs
index d8dc42ec214..046db1cd8fa 100644
--- a/tooling/nargo/src/artifacts/program.rs
+++ b/tooling/nargo/src/artifacts/program.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use fm::FileId;
 use noirc_abi::Abi;
 use noirc_driver::CompiledProgram;
@@ -21,10 +21,10 @@ pub struct ProgramArtifact {
     pub abi: Abi,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Circuit,
+    pub bytecode: Program,
 
     #[serde(
         serialize_with = "DebugInfo::serialize_compressed_base64_json",
@@ -37,14 +37,14 @@ pub struct ProgramArtifact {
 }
 
 impl From<CompiledProgram> for ProgramArtifact {
-    fn from(program: CompiledProgram) -> Self {
+    fn from(compiled_program: CompiledProgram) -> Self {
         ProgramArtifact {
-            hash: program.hash,
-            abi: program.abi,
-            noir_version: program.noir_version,
-            bytecode: program.circuit,
-            debug_symbols: program.debug,
-            file_map: program.file_map,
+            hash: compiled_program.hash,
+            abi: compiled_program.abi,
+            noir_version: compiled_program.noir_version,
+            bytecode: compiled_program.program,
+            debug_symbols: compiled_program.debug,
+            file_map: compiled_program.file_map,
         }
     }
 }
@@ -55,7 +55,7 @@ impl From<ProgramArtifact> for CompiledProgram {
             hash: program.hash,
             abi: program.abi,
             noir_version: program.noir_version,
-            circuit: program.bytecode,
+            program: program.bytecode,
             debug: program.debug_symbols,
             file_map: program.file_map,
             warnings: vec![],
diff --git a/tooling/nargo/src/ops/optimize.rs b/tooling/nargo/src/ops/optimize.rs
index 2d0c4c43d25..cfaaf27ea98 100644
--- a/tooling/nargo/src/ops/optimize.rs
+++ b/tooling/nargo/src/ops/optimize.rs
@@ -1,17 +1,22 @@
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 
-pub fn optimize_program(mut program: CompiledProgram) -> CompiledProgram {
-    let (optimized_circuit, location_map) = acvm::compiler::optimize(program.circuit);
-    program.circuit = optimized_circuit;
-    program.debug.update_acir(location_map);
-    program
+/// TODO(https://github.com/noir-lang/noir/issues/4428): Need to update how these passes are run to account for
+/// multiple ACIR functions
+
+pub fn optimize_program(mut compiled_program: CompiledProgram) -> CompiledProgram {
+    let (optimized_circuit, location_map) =
+        acvm::compiler::optimize(std::mem::take(&mut compiled_program.program.functions[0]));
+    compiled_program.program.functions[0] = optimized_circuit;
+    compiled_program.debug.update_acir(location_map);
+    compiled_program
 }
 
 pub fn optimize_contract(contract: CompiledContract) -> CompiledContract {
     let functions = vecmap(contract.functions, |mut func| {
-        let (optimized_bytecode, location_map) = acvm::compiler::optimize(func.bytecode);
-        func.bytecode = optimized_bytecode;
+        let (optimized_bytecode, location_map) =
+            acvm::compiler::optimize(std::mem::take(&mut func.bytecode.functions[0]));
+        func.bytecode.functions[0] = optimized_bytecode;
         func.debug.update_acir(location_map);
         func
     });
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 8ddcb5cf8d2..8cf2934da4d 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -28,18 +28,23 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
     foreign_call_resolver_url: Option<&str>,
     config: &CompileOptions,
 ) -> TestStatus {
-    let program = compile_no_check(context, config, test_function.get_id(), None, false);
-    match program {
-        Ok(program) => {
+    let compiled_program = compile_no_check(context, config, test_function.get_id(), None, false);
+    match compiled_program {
+        Ok(compiled_program) => {
             // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen,
             // otherwise constraints involving these expressions will not error.
             let circuit_execution = execute_circuit(
-                &program.circuit,
+                // TODO(https://github.com/noir-lang/noir/issues/4428)
+                &compiled_program.program.functions[0],
                 WitnessMap::new(),
                 blackbox_solver,
                 &mut DefaultForeignCallExecutor::new(show_output, foreign_call_resolver_url),
             );
-            test_status_program_compile_pass(test_function, program.debug, circuit_execution)
+            test_status_program_compile_pass(
+                test_function,
+                compiled_program.debug,
+                circuit_execution,
+            )
         }
         Err(err) => test_status_program_compile_fail(err, test_function),
     }
diff --git a/tooling/nargo/src/ops/transform.rs b/tooling/nargo/src/ops/transform.rs
index 9267ed7e045..274286a46e4 100644
--- a/tooling/nargo/src/ops/transform.rs
+++ b/tooling/nargo/src/ops/transform.rs
@@ -2,16 +2,21 @@ use acvm::acir::circuit::ExpressionWidth;
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 
+/// TODO(https://github.com/noir-lang/noir/issues/4428): Need to update how these passes are run to account for
+/// multiple ACIR functions
+
 pub fn transform_program(
-    mut program: CompiledProgram,
+    mut compiled_program: CompiledProgram,
     expression_width: ExpressionWidth,
 ) -> CompiledProgram {
-    let (optimized_circuit, location_map) =
-        acvm::compiler::compile(program.circuit, expression_width);
+    let (optimized_circuit, location_map) = acvm::compiler::compile(
+        std::mem::take(&mut compiled_program.program.functions[0]),
+        expression_width,
+    );
 
-    program.circuit = optimized_circuit;
-    program.debug.update_acir(location_map);
-    program
+    compiled_program.program.functions[0] = optimized_circuit;
+    compiled_program.debug.update_acir(location_map);
+    compiled_program
 }
 
 pub fn transform_contract(
@@ -19,9 +24,11 @@ pub fn transform_contract(
     expression_width: ExpressionWidth,
 ) -> CompiledContract {
     let functions = vecmap(contract.functions, |mut func| {
-        let (optimized_bytecode, location_map) =
-            acvm::compiler::compile(func.bytecode, expression_width);
-        func.bytecode = optimized_bytecode;
+        let (optimized_bytecode, location_map) = acvm::compiler::compile(
+            std::mem::take(&mut func.bytecode.functions[0]),
+            expression_width,
+        );
+        func.bytecode.functions[0] = optimized_bytecode;
         func.debug.update_acir(location_map);
         func
     });
diff --git a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
index f0fe2e0ea78..259e209b65a 100644
--- a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
+++ b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
@@ -64,7 +64,13 @@ pub(crate) fn run(
 
         let program = nargo::ops::transform_program(program, expression_width);
 
-        let smart_contract_string = backend.eth_contract(&program.circuit)?;
+        // TODO(https://github.com/noir-lang/noir/issues/4428):
+        // We do not expect to have a smart contract verifier for a foldable program with multiple circuits.
+        // However, in the future we can expect to possibly have non-inlined ACIR functions during compilation
+        // that will be inlined at a later step such as by the ACVM compiler or by the backend.
+        // Add appropriate handling here once the compiler enables multiple ACIR functions.
+        assert_eq!(program.program.functions.len(), 1);
+        let smart_contract_string = backend.eth_contract(&program.program)?;
 
         let contract_dir = workspace.contracts_directory_path(package);
         create_named_dir(&contract_dir, "contract");
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 9b7bf9cdb0c..54e8535f094 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -214,10 +214,10 @@ pub(super) fn save_program(
     circuit_dir: &Path,
     only_acir_opt: bool,
 ) {
-    let program_artifact = ProgramArtifact::from(program.clone());
     if only_acir_opt {
-        only_acir(&program_artifact, circuit_dir);
+        only_acir(program.program, circuit_dir);
     } else {
+        let program_artifact = ProgramArtifact::from(program.clone());
         save_program_to_file(&program_artifact, &package.name, circuit_dir);
     }
 }
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 2c4937b6f16..1f448105ee2 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -235,7 +235,7 @@ pub(crate) fn debug_program(
 
     noir_debugger::debug_circuit(
         &blackbox_solver,
-        &compiled_program.circuit,
+        &compiled_program.program.functions[0],
         debug_artifact,
         initial_witness,
     )
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 1be2fbf61d9..022bf7b761e 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -136,8 +136,9 @@ pub(crate) fn execute_program(
 
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
+    // TODO(https://github.com/noir-lang/noir/issues/4428)
     let solved_witness_err = nargo::ops::execute_circuit(
-        &compiled_program.circuit,
+        &compiled_program.program.functions[0],
         initial_witness,
         &blackbox_solver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
diff --git a/tooling/nargo_cli/src/cli/fs/program.rs b/tooling/nargo_cli/src/cli/fs/program.rs
index 1fb57ae6685..77005e8d5af 100644
--- a/tooling/nargo_cli/src/cli/fs/program.rs
+++ b/tooling/nargo_cli/src/cli/fs/program.rs
@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use nargo::artifacts::{contract::ContractArtifact, program::ProgramArtifact};
 use noirc_frontend::graph::CrateName;
 
@@ -18,13 +18,10 @@ pub(crate) fn save_program_to_file<P: AsRef<Path>>(
 }
 
 /// Writes the bytecode as acir.gz
-pub(crate) fn only_acir<P: AsRef<Path>>(
-    program_artifact: &ProgramArtifact,
-    circuit_dir: P,
-) -> PathBuf {
+pub(crate) fn only_acir<P: AsRef<Path>>(program: Program, circuit_dir: P) -> PathBuf {
     create_named_dir(circuit_dir.as_ref(), "target");
     let circuit_path = circuit_dir.as_ref().join("acir").with_extension("gz");
-    let bytes = Circuit::serialize_circuit(&program_artifact.bytecode);
+    let bytes = Program::serialize_program(&program);
     write_to_file(&bytes, &circuit_path);
 
     circuit_path
diff --git a/tooling/nargo_cli/src/cli/fs/witness.rs b/tooling/nargo_cli/src/cli/fs/witness.rs
index 1a2cf88f4a1..52b5c385e5d 100644
--- a/tooling/nargo_cli/src/cli/fs/witness.rs
+++ b/tooling/nargo_cli/src/cli/fs/witness.rs
@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use nargo::constants::WITNESS_EXT;
 
 use super::{create_named_dir, write_to_file};
@@ -14,7 +14,9 @@ pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
     create_named_dir(witness_dir.as_ref(), "witness");
     let witness_path = witness_dir.as_ref().join(witness_name).with_extension(WITNESS_EXT);
 
-    let buf: Vec<u8> = witnesses.try_into()?;
+    // TODO(https://github.com/noir-lang/noir/issues/4428)
+    let witness_stack: WitnessStack = witnesses.into();
+    let buf: Vec<u8> = witness_stack.try_into()?;
 
     write_to_file(buf.as_slice(), &witness_path);
 
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 391e8061a07..49924622392 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -276,8 +276,9 @@ fn count_opcodes_and_gates_in_program(
     Ok(ProgramInfo {
         name: package.name.to_string(),
         expression_width,
-        acir_opcodes: compiled_program.circuit.opcodes.len(),
-        circuit_size: backend.get_exact_circuit_size(&compiled_program.circuit)?,
+        // TODO(https://github.com/noir-lang/noir/issues/4428)
+        acir_opcodes: compiled_program.program.functions[0].opcodes.len(),
+        circuit_size: backend.get_exact_circuit_size(&compiled_program.program)?,
     })
 }
 
@@ -292,7 +293,8 @@ fn count_opcodes_and_gates_in_contract(
         .map(|function| -> Result<_, BackendError> {
             Ok(FunctionInfo {
                 name: function.name,
-                acir_opcodes: function.bytecode.opcodes.len(),
+                // TODO(https://github.com/noir-lang/noir/issues/4428)
+                acir_opcodes: function.bytecode.functions[0].opcodes.len(),
                 circuit_size: backend.get_exact_circuit_size(&function.bytecode)?,
             })
         })
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index e413db0e5f3..272f2fa8e5d 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -1,3 +1,4 @@
+use acvm::acir::native_types::WitnessStack;
 use clap::Args;
 use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
 use nargo::ops::{compile_program, report_errors};
@@ -138,11 +139,11 @@ pub(crate) fn prove_package(
         Format::Toml,
     )?;
 
-    let proof = backend.prove(&compiled_program.circuit, solved_witness)?;
+    let proof = backend.prove(&compiled_program.program, WitnessStack::from(solved_witness))?;
 
     if check_proof {
         let public_inputs = public_abi.encode(&public_inputs, return_value)?;
-        let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.circuit)?;
+        let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.program)?;
 
         if !valid_proof {
             return Err(CliError::InvalidProof("".into()));
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
index 3e23c9a3e9f..7202a179aae 100644
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ b/tooling/nargo_cli/src/cli/verify_cmd.rs
@@ -102,7 +102,7 @@ fn verify_package(
 
     let proof = load_hex_data(&proof_path)?;
 
-    let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.circuit)?;
+    let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.program)?;
 
     if valid_proof {
         Ok(())
diff --git a/tooling/nargo_cli/src/errors.rs b/tooling/nargo_cli/src/errors.rs
index c2996f53420..40fb7886405 100644
--- a/tooling/nargo_cli/src/errors.rs
+++ b/tooling/nargo_cli/src/errors.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessMapError;
+use acvm::acir::native_types::WitnessStackError;
 use hex::FromHexError;
 use nargo::{errors::CompileError, NargoError};
 use nargo_toml::ManifestError;
@@ -22,9 +22,9 @@ pub(crate) enum FilesystemError {
     #[error(transparent)]
     InputParserError(#[from] InputParserError),
 
-    /// WitnessMap serialization error
+    /// WitnessStack serialization error
     #[error(transparent)]
-    WitnessMapSerialization(#[from] WitnessMapError),
+    WitnessStackSerialization(#[from] WitnessStackError),
 
     #[error("Error: could not deserialize build program: {0}")]
     ProgramSerializationError(String),
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 6223f8d2969..92b8460d1db 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.29.0",
+    "@aztec/bb.js": "0.30.1",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/tooling/noir_js_backend_barretenberg/src/index.ts b/tooling/noir_js_backend_barretenberg/src/index.ts
index af03743eb2f..bfdf1005a93 100644
--- a/tooling/noir_js_backend_barretenberg/src/index.ts
+++ b/tooling/noir_js_backend_barretenberg/src/index.ts
@@ -45,7 +45,6 @@ export class BarretenbergBackend implements Backend {
       }
       const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
       const api = await Barretenberg.new(this.options);
-
       const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode);
       const crs = await Crs.new(subgroupSize + 1);
       await api.commonInitSlabAllocator(subgroupSize);
diff --git a/yarn.lock b/yarn.lock
index ee120fbb18e..3932935167d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.29.0":
-  version: 0.29.0
-  resolution: "@aztec/bb.js@npm:0.29.0"
+"@aztec/bb.js@npm:0.30.1":
+  version: 0.30.1
+  resolution: "@aztec/bb.js@npm:0.30.1"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: ae2bae0eed1a64f79f4694d0b02a51b87bb00ef1d9a331193dc9ace69a47819d93b923114e95e77b9b4d3de28c94bf5bdd1e839b0236979aaa0cfcda7a04fa97
+  checksum: 52d0acaaf0966aa969b863adeb688df5c1abe7c8a0595bc2dca8603a8649f11eb39071aacbdc05b19f320f022b98691a41cb18a601ad84e6d82955ae6f885106
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.29.0
+    "@aztec/bb.js": 0.30.1
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 04734976e92475b1ab94257e30bc3438c7358681 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 21 Mar 2024 15:18:51 +0000
Subject: [PATCH 105/416] fix(ssa): Use accurate type during SSA AsSlice
 simplficiation (#4610)

# Description

## Problem\*

Resolves #4609

## Summary\*

We were not accurately converting the type from an array to a slice
during `AsSlice` SSA simplification. This led to the slice capacity
tracker not accurately tracking the slice size.

## Additional Context


## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/ir/instruction/call.rs            |  9 ++++----
 compiler/noirc_evaluator/src/ssa/ir/types.rs  |  7 ++++++
 .../array_to_slice/src/main.nr                | 23 +++++++++++++++++++
 3 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 8b800e0db54..5b268de239d 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -85,10 +85,11 @@ pub(super) fn simplify_call(
             }
         }
         Intrinsic::AsSlice => {
-            let slice = dfg.get_array_constant(arguments[0]);
-            if let Some((slice, element_type)) = slice {
-                let slice_length = dfg.make_constant(slice.len().into(), Type::length_type());
-                let new_slice = dfg.make_array(slice, element_type);
+            let array = dfg.get_array_constant(arguments[0]);
+            if let Some((array, array_type)) = array {
+                let slice_length = dfg.make_constant(array.len().into(), Type::length_type());
+                let inner_element_types = array_type.element_types();
+                let new_slice = dfg.make_array(array, Type::Slice(inner_element_types));
                 SimplifyResult::SimplifiedToMultiple(vec![slice_length, new_slice])
             } else {
                 SimplifyResult::None
diff --git a/compiler/noirc_evaluator/src/ssa/ir/types.rs b/compiler/noirc_evaluator/src/ssa/ir/types.rs
index ea3f5393245..48036580d29 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/types.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/types.rs
@@ -159,6 +159,13 @@ impl Type {
             Type::Reference(element) => element.contains_an_array(),
         }
     }
+
+    pub(crate) fn element_types(self) -> Rc<Vec<Type>> {
+        match self {
+            Type::Array(element_types, _) | Type::Slice(element_types) => element_types,
+            other => panic!("element_types: Expected array or slice, found {other}"),
+        }
+    }
 }
 
 /// Composite Types are essentially flattened struct or tuple types.
diff --git a/test_programs/execution_success/array_to_slice/src/main.nr b/test_programs/execution_success/array_to_slice/src/main.nr
index b97f68fc280..0d0f9562d7b 100644
--- a/test_programs/execution_success/array_to_slice/src/main.nr
+++ b/test_programs/execution_success/array_to_slice/src/main.nr
@@ -7,6 +7,7 @@ fn as_slice_push<T, N>(xs: [T; N]) -> [T] {
     slice
 }
 
+// Expected that x == 0 and y == 1
 fn main(x: Field, y: pub Field) {
     let xs: [Field; 0] = [];
     let ys: [Field; 1] = [1];
@@ -30,4 +31,26 @@ fn main(x: Field, y: pub Field) {
     assert(dynamic.as_slice()[2] == dynamic_expected[2]);
     assert(dynamic.as_slice()[3] == dynamic_expected[3]);
     assert(dynamic.as_slice().len() == 4);
+
+    regression_4609_append_slices(x, y);
+    regression_4609_append_dynamic_slices(x, y);
+}
+
+fn regression_4609_append_slices(x: Field, y: Field) {
+    let sl = [x, 1, 2, 3].as_slice();
+    let sl2 = [y, 5, 6].as_slice();
+    let sl3 = sl.append(sl2);
+    assert(sl3[0] == x);
+    assert(sl3[4] == y);
+}
+
+fn regression_4609_append_dynamic_slices(x: Field, y: Field) {
+    let mut sl = [x, 1, 2, 3].as_slice();
+    sl[x] = x + 10;
+    let mut sl2 = [y, 5, 6].as_slice();
+    sl2[y] = y + 5;
+    let sl3 = sl.append(sl2);
+    assert(sl3[0] == 10);
+    assert(sl3[4] == y);
+    assert(sl3[5] == 6);
 }

From ff95fd93451b2053360a16b7d3204ca251199296 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Thu, 21 Mar 2024 11:47:00 -0400
Subject: [PATCH 106/416] feat: add specific error for attempting `string[x] =
 ".."` (#4611)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4267

## Summary\*

New error:

```bash
error: Strings do not support indexed assignment
  ┌─ /Users/michaelklein/Coding/rust/noir/test_programs/compile_failure/mutable_str_index/src/main.nr:3:5
  │
3 │     example[0] = "?";
  │     -------
  │

Aborting due to 1 previous error
```

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/type_check/errors.rs | 5 ++++-
 compiler/noirc_frontend/src/hir/type_check/stmt.rs   | 5 +++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 642cebc83b0..6beb6929ce1 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -140,6 +140,8 @@ pub enum TypeCheckError {
         method_name: String,
         span: Span,
     },
+    #[error("Strings do not support indexed assignment")]
+    StringIndexAssign { span: Span },
 }
 
 impl TypeCheckError {
@@ -237,7 +239,8 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
             | TypeCheckError::UnconstrainedSliceReturnToConstrained { span }
-            | TypeCheckError::NonConstantSliceLength { span } => {
+            | TypeCheckError::NonConstantSliceLength { span }
+            | TypeCheckError::StringIndexAssign { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index 49ba3244dc9..69363d5f00a 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -258,6 +258,11 @@ impl<'interner> TypeChecker<'interner> {
                     Type::Array(_, elem_type) => *elem_type,
                     Type::Slice(elem_type) => *elem_type,
                     Type::Error => Type::Error,
+                    Type::String(_) => {
+                        let (_lvalue_name, lvalue_span) = self.get_lvalue_name_and_span(&lvalue);
+                        self.errors.push(TypeCheckError::StringIndexAssign { span: lvalue_span });
+                        Type::Error
+                    }
                     other => {
                         // TODO: Need a better span here
                         self.errors.push(TypeCheckError::TypeMismatch {

From 6271b8b82342fbfa147fcd57abf1032eb63306d8 Mon Sep 17 00:00:00 2001
From: CodeDragonVN <150457827+CodeDragonVN@users.noreply.github.com>
Date: Thu, 21 Mar 2024 18:14:45 +0000
Subject: [PATCH 107/416] chore: update docs with function names to match
 version 0.25.0 specifications (#4466)

# Description

## Problem

Other how-to guides not mentioned in #4410 need to be updated to the
v0.24.0 function naming.

## Summary

This pull request updates the documentation to match the function naming
conventions introduced in version 0.24.0. Specifically, it changes
references from `generateFinalProof` and `verifyFinalProof` to
`generateProof` and `verifyProof` respectively.

## Additional Context

The changes were made across multiple documentation files, including
tutorials and how-to guides.

## Documentation

- [x] Documentation included in this PR.

# PR Checklist

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: josh crites <jc@joshcrites.com>
---
 docs/docs/how_to/how-to-oracles.md                           | 2 +-
 docs/docs/tutorials/noirjs_app.md                            | 4 ++--
 docs/versioned_docs/version-v0.24.0/how_to/how-to-oracles.md | 2 +-
 docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md  | 4 ++--
 docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md | 2 +-
 docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md  | 4 ++--
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index 0d84d992320..ab225b9421f 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -198,7 +198,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateFinalProof(inputs, foreignCallHandler)
+await noir.generateProof(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
diff --git a/docs/docs/tutorials/noirjs_app.md b/docs/docs/tutorials/noirjs_app.md
index ad76dd255cc..12beb476994 100644
--- a/docs/docs/tutorials/noirjs_app.md
+++ b/docs/docs/tutorials/noirjs_app.md
@@ -243,7 +243,7 @@ Now we're ready to prove stuff! Let's feed some inputs to our circuit and calcul
 await setup(); // let's squeeze our wasm inits here
 
 display('logs', 'Generating proof... ⌛');
-const proof = await noir.generateFinalProof(input);
+const proof = await noir.generateProof(input);
 display('logs', 'Generating proof... ✅');
 display('results', proof.proof);
 ```
@@ -264,7 +264,7 @@ Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add th
 
 ```js
 display('logs', 'Verifying proof... ⌛');
-const verification = await noir.verifyFinalProof(proof);
+const verification = await noir.verifyProof(proof);
 if (verification) display('logs', 'Verifying proof... ✅');
 ```
 
diff --git a/docs/versioned_docs/version-v0.24.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.24.0/how_to/how-to-oracles.md
index 0d84d992320..ab225b9421f 100644
--- a/docs/versioned_docs/version-v0.24.0/how_to/how-to-oracles.md
+++ b/docs/versioned_docs/version-v0.24.0/how_to/how-to-oracles.md
@@ -198,7 +198,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateFinalProof(inputs, foreignCallHandler)
+await noir.generateProof(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
diff --git a/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md
index ad76dd255cc..12beb476994 100644
--- a/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md
@@ -243,7 +243,7 @@ Now we're ready to prove stuff! Let's feed some inputs to our circuit and calcul
 await setup(); // let's squeeze our wasm inits here
 
 display('logs', 'Generating proof... ⌛');
-const proof = await noir.generateFinalProof(input);
+const proof = await noir.generateProof(input);
 display('logs', 'Generating proof... ✅');
 display('results', proof.proof);
 ```
@@ -264,7 +264,7 @@ Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add th
 
 ```js
 display('logs', 'Verifying proof... ⌛');
-const verification = await noir.verifyFinalProof(proof);
+const verification = await noir.verifyProof(proof);
 if (verification) display('logs', 'Verifying proof... ✅');
 ```
 
diff --git a/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md
index 0d84d992320..ab225b9421f 100644
--- a/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md
+++ b/docs/versioned_docs/version-v0.25.0/how_to/how-to-oracles.md
@@ -198,7 +198,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateFinalProof(inputs, foreignCallHandler)
+await noir.generateProof(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
diff --git a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
index ad76dd255cc..12beb476994 100644
--- a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
@@ -243,7 +243,7 @@ Now we're ready to prove stuff! Let's feed some inputs to our circuit and calcul
 await setup(); // let's squeeze our wasm inits here
 
 display('logs', 'Generating proof... ⌛');
-const proof = await noir.generateFinalProof(input);
+const proof = await noir.generateProof(input);
 display('logs', 'Generating proof... ✅');
 display('results', proof.proof);
 ```
@@ -264,7 +264,7 @@ Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add th
 
 ```js
 display('logs', 'Verifying proof... ⌛');
-const verification = await noir.verifyFinalProof(proof);
+const verification = await noir.verifyProof(proof);
 if (verification) display('logs', 'Verifying proof... ✅');
 ```
 

From ea3bb7f0673b9aa9b290ce263e6ce36475e0bc1a Mon Sep 17 00:00:00 2001
From: George Kushnir <n4ru@users.noreply.github.com>
Date: Fri, 22 Mar 2024 08:20:39 -0400
Subject: [PATCH 108/416] chore: Update integers.md to note support for Fields
 using `from_integer` (#4536)

Resolves #4524
---
 docs/docs/noir/concepts/data_types/integers.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/noir/concepts/data_types/integers.md b/docs/docs/noir/concepts/data_types/integers.md
index 4d58d96fed5..1c6b375db49 100644
--- a/docs/docs/noir/concepts/data_types/integers.md
+++ b/docs/docs/noir/concepts/data_types/integers.md
@@ -51,7 +51,7 @@ The built-in structure `U128` allows you to use 128-bit unsigned integers almost
 - You cannot cast between a native integer and `U128`
 - There is a higher performance cost when using `U128`, compared to a native type.
 
-Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions.
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
 
 ```rust
 fn main() {

From b62ecf53553049d5940cf5f818f8affa51e512ad Mon Sep 17 00:00:00 2001
From: Savio <72797635+Savio-Sou@users.noreply.github.com>
Date: Mon, 25 Mar 2024 06:48:48 -0400
Subject: [PATCH 109/416] chore(github): Improve PR template "document later"
 checkbox description (#4625)

# Description

## Problem\*

Describing the option as "Exceptional Case" wasn't very intuitive. Some
PRs that were meant to check that box checked the "No documentation
needed." box instead.

## Summary\*

Describe the option as "For Experimental Features" instead, as most if
not all such exceptional cases that docs were preferred to be delayed
came from features being still experimental (i.e. not intended for
public use yet).

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/pull_request_template.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index e81ede7199d..dfb141e29f7 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -17,7 +17,7 @@ Resolves <!-- Link to GitHub Issue -->
 Check one:
 - [ ] No documentation needed.
 - [ ] Documentation included in this PR.
-- [ ] **[Exceptional Case]** Documentation to be submitted in a separate PR.
+- [ ] **[For Experimental Features]** Documentation to be submitted in a separate PR.
 
 # PR Checklist\*
 

From 59ea775445ebb548d3ec457721421de0b0399728 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 25 Mar 2024 15:04:57 +0000
Subject: [PATCH 110/416] chore: convert `BlockExpression` into a standard
 struct (#4623)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR splits out some more mundane changes from #4429.
`BlockExpression` is now a standard rather than tuple struct to make it
easier for us to add an `unsafe` property (and potentially `unchecked`
in future)

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 aztec_macros/src/transforms/events.rs         | 12 ++++--
 aztec_macros/src/transforms/functions.rs      | 29 +++++++-------
 aztec_macros/src/transforms/storage.rs        |  2 +-
 compiler/noirc_frontend/src/ast/expression.rs | 32 +++++++++-------
 compiler/noirc_frontend/src/ast/function.rs   |  2 +-
 compiler/noirc_frontend/src/ast/statement.rs  | 14 ++++---
 compiler/noirc_frontend/src/debug/mod.rs      | 38 +++++++++++--------
 .../src/hir/resolution/resolver.rs            |  6 +--
 .../noirc_frontend/src/hir/type_check/mod.rs  |  3 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |  8 ++--
 .../src/monomorphization/mod.rs               |  2 +-
 compiler/noirc_frontend/src/parser/parser.rs  | 20 +++++-----
 tooling/nargo_fmt/src/visitor/expr.rs         |  4 +-
 13 files changed, 98 insertions(+), 74 deletions(-)

diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
index b02709efacb..e7e39ed29ba 100644
--- a/aztec_macros/src/transforms/events.rs
+++ b/aztec_macros/src/transforms/events.rs
@@ -47,10 +47,14 @@ pub fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
     let mut from_signature_path = selector_path.clone();
     from_signature_path.segments.push(ident("from_signature"));
 
-    let selector_fun_body = BlockExpression(vec![make_statement(StatementKind::Expression(call(
-        variable_path(from_signature_path),
-        vec![expression(ExpressionKind::Literal(Literal::Str(SIGNATURE_PLACEHOLDER.to_string())))],
-    )))]);
+    let selector_fun_body = BlockExpression {
+        statements: vec![make_statement(StatementKind::Expression(call(
+            variable_path(from_signature_path),
+            vec![expression(ExpressionKind::Literal(Literal::Str(
+                SIGNATURE_PLACEHOLDER.to_string(),
+            )))],
+        )))],
+    };
 
     // Define `FunctionSelector` return type
     let return_type =
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index c719651e10e..855969732d0 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -39,29 +39,29 @@ pub fn transform_function(
     // Add check that msg sender equals this address and flag function as internal
     if is_internal {
         let is_internal_check = create_internal_check(func.name());
-        func.def.body.0.insert(0, is_internal_check);
+        func.def.body.statements.insert(0, is_internal_check);
     }
 
     // Add initialization check
     if insert_init_check {
         let init_check = create_init_check();
-        func.def.body.0.insert(0, init_check);
+        func.def.body.statements.insert(0, init_check);
     }
 
     // Add assertion for initialization arguments and sender
     if is_initializer {
-        func.def.body.0.insert(0, create_assert_initializer());
+        func.def.body.statements.insert(0, create_assert_initializer());
     }
 
     // Add access to the storage struct
     if storage_defined {
         let storage_def = abstract_storage(&ty.to_lowercase(), false);
-        func.def.body.0.insert(0, storage_def);
+        func.def.body.statements.insert(0, storage_def);
     }
 
     // Insert the context creation as the first action
     let create_context = create_context(&context_name, &func.def.parameters)?;
-    func.def.body.0.splice(0..0, (create_context).iter().cloned());
+    func.def.body.statements.splice(0..0, (create_context).iter().cloned());
 
     // Add the inputs to the params
     let input = create_inputs(&inputs_name);
@@ -71,20 +71,20 @@ pub fn transform_function(
     if let Some(return_values) = abstract_return_values(func) {
         // In case we are pushing return values to the context, we remove the statement that originated it
         // This avoids running duplicate code, since blocks like if/else can be value returning statements
-        func.def.body.0.pop();
+        func.def.body.statements.pop();
         // Add the new return statement
-        func.def.body.0.push(return_values);
+        func.def.body.statements.push(return_values);
     }
 
     // Before returning mark the contract as initialized
     if is_initializer {
         let mark_initialized = create_mark_as_initialized();
-        func.def.body.0.push(mark_initialized);
+        func.def.body.statements.push(mark_initialized);
     }
 
     // Push the finish method call to the end of the function
     let finish_def = create_context_finish();
-    func.def.body.0.push(finish_def);
+    func.def.body.statements.push(finish_def);
 
     let return_type = create_return_type(&return_type_name);
     func.def.return_type = return_type;
@@ -109,12 +109,12 @@ pub fn transform_vm_function(
     // Create access to storage
     if storage_defined {
         let storage = abstract_storage("public_vm", true);
-        func.def.body.0.insert(0, storage);
+        func.def.body.statements.insert(0, storage);
     }
 
     // Push Avm context creation to the beginning of the function
     let create_context = create_avm_context()?;
-    func.def.body.0.insert(0, create_context);
+    func.def.body.statements.insert(0, create_context);
 
     // We want the function to be seen as a public function
     func.def.is_unconstrained = true;
@@ -131,7 +131,7 @@ pub fn transform_vm_function(
 ///
 /// This will allow developers to access their contract' storage struct in unconstrained functions
 pub fn transform_unconstrained(func: &mut NoirFunction) {
-    func.def.body.0.insert(0, abstract_storage("Unconstrained", true));
+    func.def.body.statements.insert(0, abstract_storage("Unconstrained", true));
 }
 
 /// Helper function that returns what the private context would look like in the ast
@@ -393,7 +393,7 @@ fn create_avm_context() -> Result<Statement, AztecMacroError> {
 /// Any primitive type that can be cast will be casted to a field and pushed to the context.
 fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
     let current_return_type = func.return_type().typ;
-    let last_statement = func.def.body.0.last()?;
+    let last_statement = func.def.body.statements.last()?;
 
     // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
     // Doesn't need done until we have settled on a kernel size
@@ -645,7 +645,8 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
 
     // What will be looped over
     // - `hasher.add({ident}[i] as Field)`
-    let for_loop_block = expression(ExpressionKind::Block(BlockExpression(loop_body)));
+    let for_loop_block =
+        expression(ExpressionKind::Block(BlockExpression { statements: loop_body }));
 
     // `for i in 0..{ident}.len()`
     make_statement(StatementKind::For(ForLoopStatement {
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 40a094f78e3..10f44d01bb4 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -150,7 +150,7 @@ pub fn generate_storage_implementation(module: &mut SortedModule) -> Result<(),
                 true,
             )),
         )],
-        &BlockExpression(vec![storage_constructor_statement]),
+        &BlockExpression { statements: vec![storage_constructor_statement] },
         &[],
         &return_type(chained_path!("Self")),
     ));
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index d646a6ca98a..0e5919bf7db 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -192,16 +192,18 @@ impl Expression {
         // with tuples without calling them. E.g. `if c { t } else { e }(a, b)` is interpreted
         // as a sequence of { if, tuple } rather than a function call. This behavior matches rust.
         let kind = if matches!(&lhs.kind, ExpressionKind::If(..)) {
-            ExpressionKind::Block(BlockExpression(vec![
-                Statement { kind: StatementKind::Expression(lhs), span },
-                Statement {
-                    kind: StatementKind::Expression(Expression::new(
-                        ExpressionKind::Tuple(arguments),
+            ExpressionKind::Block(BlockExpression {
+                statements: vec![
+                    Statement { kind: StatementKind::Expression(lhs), span },
+                    Statement {
+                        kind: StatementKind::Expression(Expression::new(
+                            ExpressionKind::Tuple(arguments),
+                            span,
+                        )),
                         span,
-                    )),
-                    span,
-                },
-            ]))
+                    },
+                ],
+            })
         } else {
             ExpressionKind::Call(Box::new(CallExpression { func: Box::new(lhs), arguments }))
         };
@@ -452,19 +454,21 @@ pub struct IndexExpression {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct BlockExpression(pub Vec<Statement>);
+pub struct BlockExpression {
+    pub statements: Vec<Statement>,
+}
 
 impl BlockExpression {
     pub fn pop(&mut self) -> Option<StatementKind> {
-        self.0.pop().map(|stmt| stmt.kind)
+        self.statements.pop().map(|stmt| stmt.kind)
     }
 
     pub fn len(&self) -> usize {
-        self.0.len()
+        self.statements.len()
     }
 
     pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
+        self.statements.is_empty()
     }
 }
 
@@ -542,7 +546,7 @@ impl Display for Literal {
 impl Display for BlockExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "{{")?;
-        for statement in &self.0 {
+        for statement in &self.statements {
             let statement = statement.kind.to_string();
             for line in statement.lines() {
                 writeln!(f, "    {line}")?;
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index 46f0ac0fa0f..3e8b78c1312 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -83,7 +83,7 @@ impl NoirFunction {
         &mut self.def
     }
     pub fn number_of_statements(&self) -> usize {
-        self.def.body.0.len()
+        self.def.body.statements.len()
     }
     pub fn span(&self) -> Span {
         self.def.span
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index fb7f520ee71..b14ead8ad42 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -603,10 +603,12 @@ impl ForRange {
                 };
 
                 let block_span = block.span;
-                let new_block = BlockExpression(vec![
-                    let_elem,
-                    Statement { kind: StatementKind::Expression(block), span: block_span },
-                ]);
+                let new_block = BlockExpression {
+                    statements: vec![
+                        let_elem,
+                        Statement { kind: StatementKind::Expression(block), span: block_span },
+                    ],
+                };
                 let new_block = Expression::new(ExpressionKind::Block(new_block), block_span);
                 let for_loop = Statement {
                     kind: StatementKind::For(ForLoopStatement {
@@ -618,7 +620,9 @@ impl ForRange {
                     span: for_loop_span,
                 };
 
-                let block = ExpressionKind::Block(BlockExpression(vec![let_array, for_loop]));
+                let block = ExpressionKind::Block(BlockExpression {
+                    statements: vec![let_array, for_loop],
+                });
                 StatementKind::Expression(Expression::new(block, for_loop_span))
             }
         }
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 05916502d73..8e5c174d270 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -113,7 +113,7 @@ impl DebugInstrumenter {
             })
             .collect();
 
-        let func_body = &mut func.body.0;
+        let func_body = &mut func.body.statements;
         let mut statements = take(func_body);
 
         self.walk_scope(&mut statements, func.span);
@@ -243,7 +243,9 @@ impl DebugInstrumenter {
                 pattern: ast::Pattern::Tuple(vars_pattern, let_stmt.pattern.span()),
                 r#type: ast::UnresolvedType::unspecified(),
                 expression: ast::Expression {
-                    kind: ast::ExpressionKind::Block(ast::BlockExpression(block_stmts)),
+                    kind: ast::ExpressionKind::Block(ast::BlockExpression {
+                        statements: block_stmts,
+                    }),
                     span: let_stmt.expression.span,
                 },
             }),
@@ -330,11 +332,13 @@ impl DebugInstrumenter {
             kind: ast::StatementKind::Assign(ast::AssignStatement {
                 lvalue: assign_stmt.lvalue.clone(),
                 expression: ast::Expression {
-                    kind: ast::ExpressionKind::Block(ast::BlockExpression(vec![
-                        ast::Statement { kind: let_kind, span: expression_span },
-                        new_assign_stmt,
-                        ast::Statement { kind: ret_kind, span: expression_span },
-                    ])),
+                    kind: ast::ExpressionKind::Block(ast::BlockExpression {
+                        statements: vec![
+                            ast::Statement { kind: let_kind, span: expression_span },
+                            new_assign_stmt,
+                            ast::Statement { kind: ret_kind, span: expression_span },
+                        ],
+                    }),
                     span: expression_span,
                 },
             }),
@@ -344,7 +348,7 @@ impl DebugInstrumenter {
 
     fn walk_expr(&mut self, expr: &mut ast::Expression) {
         match &mut expr.kind {
-            ast::ExpressionKind::Block(ast::BlockExpression(ref mut statements)) => {
+            ast::ExpressionKind::Block(ast::BlockExpression { ref mut statements, .. }) => {
                 self.scope.push(HashMap::default());
                 self.walk_scope(statements, expr.span);
             }
@@ -415,14 +419,16 @@ impl DebugInstrumenter {
 
         self.walk_expr(&mut for_stmt.block);
         for_stmt.block = ast::Expression {
-            kind: ast::ExpressionKind::Block(ast::BlockExpression(vec![
-                set_stmt,
-                ast::Statement {
-                    kind: ast::StatementKind::Semi(for_stmt.block.clone()),
-                    span: for_stmt.block.span,
-                },
-                drop_stmt,
-            ])),
+            kind: ast::ExpressionKind::Block(ast::BlockExpression {
+                statements: vec![
+                    set_stmt,
+                    ast::Statement {
+                        kind: ast::StatementKind::Semi(for_stmt.block.clone()),
+                        span: for_stmt.block.span,
+                    },
+                    drop_stmt,
+                ],
+            }),
             span: for_stmt.span,
         };
     }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 3fbde8a890b..f8e3c4cab60 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -252,7 +252,7 @@ impl<'a> Resolver<'a> {
                 typ: typ.clone(),
                 span: name.span(),
             }),
-            body: BlockExpression(Vec::new()),
+            body: BlockExpression { statements: Vec::new() },
             span: name.span(),
             where_clause: where_clause.to_vec(),
             return_type: return_type.clone(),
@@ -1952,8 +1952,8 @@ impl<'a> Resolver<'a> {
 
     fn resolve_block(&mut self, block_expr: BlockExpression) -> HirExpression {
         let statements =
-            self.in_new_scope(|this| vecmap(block_expr.0, |stmt| this.intern_stmt(stmt)));
-        HirExpression::Block(HirBlockExpression(statements))
+            self.in_new_scope(|this| vecmap(block_expr.statements, |stmt| this.intern_stmt(stmt)));
+        HirExpression::Block(HirBlockExpression { statements })
     }
 
     pub fn intern_block(&mut self, block: BlockExpression) -> ExprId {
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index ab759f454e5..137608f8037 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -468,7 +468,8 @@ mod test {
             expression: expr_id,
         };
         let stmt_id = interner.push_stmt(HirStatement::Let(let_stmt));
-        let expr_id = interner.push_expr(HirExpression::Block(HirBlockExpression(vec![stmt_id])));
+        let expr_id = interner
+            .push_expr(HirExpression::Block(HirBlockExpression { statements: vec![stmt_id] }));
         interner.push_expr_location(expr_id, Span::single_char(0), file);
 
         // Create function to enclose the let statement
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index 61743d2cdc7..c2f6031bf6d 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -37,7 +37,7 @@ pub enum HirExpression {
 impl HirExpression {
     /// Returns an empty block expression
     pub const fn empty_block() -> HirExpression {
-        HirExpression::Block(HirBlockExpression(vec![]))
+        HirExpression::Block(HirBlockExpression { statements: vec![] })
     }
 }
 
@@ -249,11 +249,13 @@ pub struct HirIndexExpression {
 }
 
 #[derive(Debug, Clone)]
-pub struct HirBlockExpression(pub Vec<StmtId>);
+pub struct HirBlockExpression {
+    pub statements: Vec<StmtId>,
+}
 
 impl HirBlockExpression {
     pub fn statements(&self) -> &[StmtId] {
-        &self.0
+        &self.statements
     }
 }
 
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 9b0f57a7d39..618eba8f190 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -430,7 +430,7 @@ impl<'interner> Monomorphizer<'interner> {
                 }
             },
             HirExpression::Literal(HirLiteral::Unit) => ast::Expression::Block(vec![]),
-            HirExpression::Block(block) => self.block(block.0)?,
+            HirExpression::Block(block) => self.block(block.statements)?,
 
             HirExpression::Prefix(prefix) => {
                 let location = self.interner.expr_location(&expr);
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index dec1c7aa9ce..a40355be8aa 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -347,7 +347,7 @@ fn block<'a>(
             [(LeftParen, RightParen), (LeftBracket, RightBracket)],
             |span| vec![Statement { kind: StatementKind::Error, span }],
         ))
-        .map(BlockExpression)
+        .map(|statements| BlockExpression { statements })
 }
 
 fn check_statements_require_semicolon(
@@ -1015,10 +1015,12 @@ where
             // Wrap the inner `if` expression in a block expression.
             // i.e. rewrite the sugared form `if cond1 {} else if cond2 {}` as `if cond1 {} else { if cond2 {} }`.
             let if_expression = Expression::new(kind, span);
-            let desugared_else = BlockExpression(vec![Statement {
-                kind: StatementKind::Expression(if_expression),
-                span,
-            }]);
+            let desugared_else = BlockExpression {
+                statements: vec![Statement {
+                    kind: StatementKind::Expression(if_expression),
+                    span,
+                }],
+            };
             Expression::new(ExpressionKind::Block(desugared_else), span)
         }));
 
@@ -1399,13 +1401,13 @@ mod test {
         // Regression for #1310: this should be parsed as a block and not a function call
         let res =
             parse_with(block(fresh_statement()), "{ if true { 1 } else { 2 } (3, 4) }").unwrap();
-        match unwrap_expr(&res.0.last().unwrap().kind) {
+        match unwrap_expr(&res.statements.last().unwrap().kind) {
             // The `if` followed by a tuple is currently creates a block around both in case
             // there was none to start with, so there is an extra block here.
             ExpressionKind::Block(block) => {
-                assert_eq!(block.0.len(), 2);
-                assert!(matches!(unwrap_expr(&block.0[0].kind), ExpressionKind::If(_)));
-                assert!(matches!(unwrap_expr(&block.0[1].kind), ExpressionKind::Tuple(_)));
+                assert_eq!(block.statements.len(), 2);
+                assert!(matches!(unwrap_expr(&block.statements[0].kind), ExpressionKind::If(_)));
+                assert!(matches!(unwrap_expr(&block.statements[1].kind), ExpressionKind::Tuple(_)));
             }
             _ => unreachable!(),
         }
diff --git a/tooling/nargo_fmt/src/visitor/expr.rs b/tooling/nargo_fmt/src/visitor/expr.rs
index 2cd0e881e84..f9836adda18 100644
--- a/tooling/nargo_fmt/src/visitor/expr.rs
+++ b/tooling/nargo_fmt/src/visitor/expr.rs
@@ -119,11 +119,11 @@ impl FmtVisitor<'_> {
         self.last_position = block_span.start() + 1; // `{`
         self.push_str("{");
 
-        self.trim_spaces_after_opening_brace(&block.0);
+        self.trim_spaces_after_opening_brace(&block.statements);
 
         self.indent.block_indent(self.config);
 
-        self.visit_stmts(block.0);
+        self.visit_stmts(block.statements);
 
         let span = (self.last_position..block_span.end() - 1).into();
         self.close_block(span);

From c46b164ce56e6a8f81255fb17eb6539bd040f336 Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Mon, 25 Mar 2024 21:27:58 +0000
Subject: [PATCH 111/416] chore: Release Noir(0.26.0) (#4526)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.26.0</summary>

## [0.26.0](https://github.com/noir-lang/noir/compare/v0.25.0...v0.26.0)
(2024-03-25)


### ⚠ BREAKING CHANGES

* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* separating out array and slice types in the AST
([#4504](https://github.com/noir-lang/noir/issues/4504))
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Remove open keyword from Noir
(https://github.com/AztecProtocol/aztec-packages/pull/4967)

### Features

* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add `break` and `continue` in unconstrained code
([#4569](https://github.com/noir-lang/noir/issues/4569))
([f2f827d](https://github.com/noir-lang/noir/commit/f2f827d51e6fe99fa3d17f125b22743da25e25be))
* Add `nargo compile --watch` command
([#4464](https://github.com/noir-lang/noir/issues/4464))
([44e60b6](https://github.com/noir-lang/noir/commit/44e60b67469de88f20842c4eead64d736f7bd4a0))
* Add as_slice builtin function, add execution test
([#4523](https://github.com/noir-lang/noir/issues/4523))
([6a9ea35](https://github.com/noir-lang/noir/commit/6a9ea35c4f1578058179aa08eedf44eb18bad4a1))
* Add checks for bit size consistency on brillig gen
([#4542](https://github.com/noir-lang/noir/issues/4542))
([f3243b7](https://github.com/noir-lang/noir/commit/f3243b763c0b15ae90beb8e35630df27f3d314c0))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add experimental `quote` expression to parser
([#4595](https://github.com/noir-lang/noir/issues/4595))
([4c3a30b](https://github.com/noir-lang/noir/commit/4c3a30b4991a329d3c52e1dfa59d854d7e6910db))
* Add more impls on Option
([#4549](https://github.com/noir-lang/noir/issues/4549))
([4cf700b](https://github.com/noir-lang/noir/commit/4cf700bcfe157ebc82cdf7321a16959b7a4add57))
* Add specific error for attempting `string[x] = ".."`
([#4611](https://github.com/noir-lang/noir/issues/4611))
([ff95fd9](https://github.com/noir-lang/noir/commit/ff95fd93451b2053360a16b7d3204ca251199296))
* Allow usage of noir `#[test]` syntax in stdlib
([#4553](https://github.com/noir-lang/noir/issues/4553))
([a8b7cdb](https://github.com/noir-lang/noir/commit/a8b7cdb8a3698bc8923b6fa8714deebb8bf3923f))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Check initialization arguments in constructors
(https://github.com/AztecProtocol/aztec-packages/pull/5144)
([d4213a0](https://github.com/noir-lang/noir/commit/d4213a03c9f77ee8e7663fc965a825258d90a368))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Integrated native ACVM
(https://github.com/AztecProtocol/aztec-packages/pull/4903)
([a6016b4](https://github.com/noir-lang/noir/commit/a6016b46abf6da6de4566cf6d35a675d805dd9b5))
* Make brillig-gen more AVM-friendly
(https://github.com/AztecProtocol/aztec-packages/pull/5091)
([a6016b4](https://github.com/noir-lang/noir/commit/a6016b46abf6da6de4566cf6d35a675d805dd9b5))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Optimize sha2 implementation
([#4441](https://github.com/noir-lang/noir/issues/4441))
([80373d6](https://github.com/noir-lang/noir/commit/80373d612c023e3e165b49b6d1729486b0ba3b4b))
* RC optimization pass
([#4560](https://github.com/noir-lang/noir/issues/4560))
([dfa5126](https://github.com/noir-lang/noir/commit/dfa5126f2c65843c34701cacddf2cbcfb0d7ff11))
* Remove curly braces with fmt
([#4529](https://github.com/noir-lang/noir/issues/4529))
([fe9a437](https://github.com/noir-lang/noir/commit/fe9a437b6d7ddc3f78665df1a576236555880c51))
* Separating out array and slice types in the AST
([#4504](https://github.com/noir-lang/noir/issues/4504))
([9a241f9](https://github.com/noir-lang/noir/commit/9a241f9622b342cd9d56bf8481219cfc374c0510))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Visible aliases for nargo commands
([#4453](https://github.com/noir-lang/noir/issues/4453))
([773cf19](https://github.com/noir-lang/noir/commit/773cf190ee21381d826ba80391a5d7d5efae9174))


### Bug Fixes

* **acir_gen:** More granular element sizes array check
([#4528](https://github.com/noir-lang/noir/issues/4528))
([f93d16e](https://github.com/noir-lang/noir/commit/f93d16e3e89c5df358c982deae4f3c2d4c82b77f))
* Added error messages for passing oracles and references from
unconstrained to constrained functions
([#4570](https://github.com/noir-lang/noir/issues/4570))
([265bd8b](https://github.com/noir-lang/noir/commit/265bd8b284e5acd572a3812a94a99fc102227ff2))
* Allow non-integer globals to reference struct methods
([#4490](https://github.com/noir-lang/noir/issues/4490))
([00d6494](https://github.com/noir-lang/noir/commit/00d6494ae70b10e1872d96fb4e57ecb0b5f01787))
* Dynamic assert messages in brillig
([#4531](https://github.com/noir-lang/noir/issues/4531))
([e24d3fc](https://github.com/noir-lang/noir/commit/e24d3fc5a084610d9511e3c5421275cb9c84a548))
* Evaluate operators in globals in types
([#4537](https://github.com/noir-lang/noir/issues/4537))
([c8aa16b](https://github.com/noir-lang/noir/commit/c8aa16bc7e78456cce1736fac82496996a8761f4))
* Make `nargo` the default binary for cargo run
([#4554](https://github.com/noir-lang/noir/issues/4554))
([de4986e](https://github.com/noir-lang/noir/commit/de4986eb74b28b2e1065fa6b413d02457ddf61b0))
* Signed integer comparisons in brillig
([#4579](https://github.com/noir-lang/noir/issues/4579))
([938d5e8](https://github.com/noir-lang/noir/commit/938d5e85eda00a05de5014e64d3dc9fc7c24936d))
* **ssa:** Use accurate type during SSA AsSlice simplficiation
([#4610](https://github.com/noir-lang/noir/issues/4610))
([0473497](https://github.com/noir-lang/noir/commit/04734976e92475b1ab94257e30bc3438c7358681))
* Substitute generics when checking the field count of a type
([#4547](https://github.com/noir-lang/noir/issues/4547))
([eeeebac](https://github.com/noir-lang/noir/commit/eeeebacd10698e847f773e26dac8a4a5eb8e84ed))


### Miscellaneous Chores

* Remove open keyword from Noir
(https://github.com/AztecProtocol/aztec-packages/pull/4967)
([a6016b4](https://github.com/noir-lang/noir/commit/a6016b46abf6da6de4566cf6d35a675d805dd9b5))
</details>

<details><summary>0.42.0</summary>

## [0.42.0](https://github.com/noir-lang/noir/compare/v0.41.0...v0.42.0)
(2024-03-25)


### ⚠ BREAKING CHANGES

* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
* Rename Arithmetic opcode to AssertZero
([#3840](https://github.com/noir-lang/noir/issues/3840))
* Remove unused methods on ACIR opcodes
([#3841](https://github.com/noir-lang/noir/issues/3841))
* Remove partial backend feature
([#3805](https://github.com/noir-lang/noir/issues/3805))

### Features

* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add support for overriding expression width
([#4117](https://github.com/noir-lang/noir/issues/4117))
([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Aztec-packages
([#3754](https://github.com/noir-lang/noir/issues/3754))
([c043265](https://github.com/noir-lang/noir/commit/c043265e550b59bd4296504826fe15d3ce3e9ad2))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove range constraints from witnesses which are constrained to be
constants ([#3928](https://github.com/noir-lang/noir/issues/3928))
([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
* Remove replacement of boolean range opcodes with `AssertZero` opcodes
([#4107](https://github.com/noir-lang/noir/issues/4107))
([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Speed up transformation of debug messages
([#3815](https://github.com/noir-lang/noir/issues/3815))
([2a8af1e](https://github.com/noir-lang/noir/commit/2a8af1e4141ffff61547ee1c2837a6392bd5db48))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync `aztec-packages`
([#4011](https://github.com/noir-lang/noir/issues/4011))
([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
* Sync commits from `aztec-packages`
([#4068](https://github.com/noir-lang/noir/issues/4068))
([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))


### Bug Fixes

* Deserialize odd length hex literals
([#3747](https://github.com/noir-lang/noir/issues/3747))
([4000fb2](https://github.com/noir-lang/noir/commit/4000fb279221eb07187d657bfaa7f1c7b311abf2))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Remove panic from `init_log_level` in `acvm_js`
([#4195](https://github.com/noir-lang/noir/issues/4195))
([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
* Return error rather instead of panicking on invalid circuit
([#3976](https://github.com/noir-lang/noir/issues/3976))
([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove partial backend feature
([#3805](https://github.com/noir-lang/noir/issues/3805))
([0383100](https://github.com/noir-lang/noir/commit/0383100853a80a5b28b797cdfeae0d271f1b7805))
* Remove unused methods on ACIR opcodes
([#3841](https://github.com/noir-lang/noir/issues/3841))
([9e5d0e8](https://github.com/noir-lang/noir/commit/9e5d0e813d61a0bfb5ee68174ed287c5a20f1579))
* Rename Arithmetic opcode to AssertZero
([#3840](https://github.com/noir-lang/noir/issues/3840))
([836f171](https://github.com/noir-lang/noir/commit/836f17145c2901060706294461c2d282dd121b3e))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).
---
 .release-please-manifest.json                 |  4 +-
 CHANGELOG.md                                  | 62 ++++++++++++++
 Cargo.lock                                    | 50 ++++++------
 Cargo.toml                                    | 14 ++--
 acvm-repo/CHANGELOG.md                        | 81 +++++++++++++++++++
 acvm-repo/acir/Cargo.toml                     |  2 +-
 acvm-repo/acir_field/Cargo.toml               |  2 +-
 acvm-repo/acvm/Cargo.toml                     |  2 +-
 acvm-repo/acvm_js/Cargo.toml                  |  2 +-
 acvm-repo/acvm_js/package.json                |  2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |  2 +-
 acvm-repo/brillig/Cargo.toml                  |  2 +-
 acvm-repo/brillig_vm/Cargo.toml               |  2 +-
 compiler/wasm/package.json                    |  2 +-
 flake.nix                                     |  2 +-
 tooling/noir_codegen/package.json             |  2 +-
 tooling/noir_js/package.json                  |  2 +-
 .../noir_js_backend_barretenberg/package.json |  2 +-
 tooling/noir_js_types/package.json            |  2 +-
 tooling/noirc_abi_wasm/package.json           |  2 +-
 20 files changed, 192 insertions(+), 49 deletions(-)

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index b38234ca0b9..d4cc095c484 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.25.0",
-  "acvm-repo": "0.41.0"
+  ".": "0.26.0",
+  "acvm-repo": "0.42.0"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cdbccf768ca..7c4bcad5840 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.26.0](https://github.com/noir-lang/noir/compare/v0.25.0...v0.26.0) (2024-03-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* separating out array and slice types in the AST ([#4504](https://github.com/noir-lang/noir/issues/4504))
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Remove open keyword from Noir (https://github.com/AztecProtocol/aztec-packages/pull/4967)
+
+### Features
+
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add `break` and `continue` in unconstrained code ([#4569](https://github.com/noir-lang/noir/issues/4569)) ([f2f827d](https://github.com/noir-lang/noir/commit/f2f827d51e6fe99fa3d17f125b22743da25e25be))
+* Add `nargo compile --watch` command ([#4464](https://github.com/noir-lang/noir/issues/4464)) ([44e60b6](https://github.com/noir-lang/noir/commit/44e60b67469de88f20842c4eead64d736f7bd4a0))
+* Add as_slice builtin function, add execution test ([#4523](https://github.com/noir-lang/noir/issues/4523)) ([6a9ea35](https://github.com/noir-lang/noir/commit/6a9ea35c4f1578058179aa08eedf44eb18bad4a1))
+* Add checks for bit size consistency on brillig gen ([#4542](https://github.com/noir-lang/noir/issues/4542)) ([f3243b7](https://github.com/noir-lang/noir/commit/f3243b763c0b15ae90beb8e35630df27f3d314c0))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add experimental `quote` expression to parser ([#4595](https://github.com/noir-lang/noir/issues/4595)) ([4c3a30b](https://github.com/noir-lang/noir/commit/4c3a30b4991a329d3c52e1dfa59d854d7e6910db))
+* Add more impls on Option ([#4549](https://github.com/noir-lang/noir/issues/4549)) ([4cf700b](https://github.com/noir-lang/noir/commit/4cf700bcfe157ebc82cdf7321a16959b7a4add57))
+* Add specific error for attempting `string[x] = ".."` ([#4611](https://github.com/noir-lang/noir/issues/4611)) ([ff95fd9](https://github.com/noir-lang/noir/commit/ff95fd93451b2053360a16b7d3204ca251199296))
+* Allow usage of noir `#[test]` syntax in stdlib ([#4553](https://github.com/noir-lang/noir/issues/4553)) ([a8b7cdb](https://github.com/noir-lang/noir/commit/a8b7cdb8a3698bc8923b6fa8714deebb8bf3923f))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Check initialization arguments in constructors (https://github.com/AztecProtocol/aztec-packages/pull/5144) ([d4213a0](https://github.com/noir-lang/noir/commit/d4213a03c9f77ee8e7663fc965a825258d90a368))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Integrated native ACVM (https://github.com/AztecProtocol/aztec-packages/pull/4903) ([a6016b4](https://github.com/noir-lang/noir/commit/a6016b46abf6da6de4566cf6d35a675d805dd9b5))
+* Make brillig-gen more AVM-friendly (https://github.com/AztecProtocol/aztec-packages/pull/5091) ([a6016b4](https://github.com/noir-lang/noir/commit/a6016b46abf6da6de4566cf6d35a675d805dd9b5))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Optimize sha2 implementation ([#4441](https://github.com/noir-lang/noir/issues/4441)) ([80373d6](https://github.com/noir-lang/noir/commit/80373d612c023e3e165b49b6d1729486b0ba3b4b))
+* RC optimization pass ([#4560](https://github.com/noir-lang/noir/issues/4560)) ([dfa5126](https://github.com/noir-lang/noir/commit/dfa5126f2c65843c34701cacddf2cbcfb0d7ff11))
+* Remove curly braces with fmt  ([#4529](https://github.com/noir-lang/noir/issues/4529)) ([fe9a437](https://github.com/noir-lang/noir/commit/fe9a437b6d7ddc3f78665df1a576236555880c51))
+* Separating out array and slice types in the AST ([#4504](https://github.com/noir-lang/noir/issues/4504)) ([9a241f9](https://github.com/noir-lang/noir/commit/9a241f9622b342cd9d56bf8481219cfc374c0510))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Visible aliases for nargo commands ([#4453](https://github.com/noir-lang/noir/issues/4453)) ([773cf19](https://github.com/noir-lang/noir/commit/773cf190ee21381d826ba80391a5d7d5efae9174))
+
+
+### Bug Fixes
+
+* **acir_gen:** More granular element sizes array check ([#4528](https://github.com/noir-lang/noir/issues/4528)) ([f93d16e](https://github.com/noir-lang/noir/commit/f93d16e3e89c5df358c982deae4f3c2d4c82b77f))
+* Added error messages for passing oracles and references from unconstrained to constrained functions ([#4570](https://github.com/noir-lang/noir/issues/4570)) ([265bd8b](https://github.com/noir-lang/noir/commit/265bd8b284e5acd572a3812a94a99fc102227ff2))
+* Allow non-integer globals to reference struct methods ([#4490](https://github.com/noir-lang/noir/issues/4490)) ([00d6494](https://github.com/noir-lang/noir/commit/00d6494ae70b10e1872d96fb4e57ecb0b5f01787))
+* Dynamic assert messages in brillig ([#4531](https://github.com/noir-lang/noir/issues/4531)) ([e24d3fc](https://github.com/noir-lang/noir/commit/e24d3fc5a084610d9511e3c5421275cb9c84a548))
+* Evaluate operators in globals in types ([#4537](https://github.com/noir-lang/noir/issues/4537)) ([c8aa16b](https://github.com/noir-lang/noir/commit/c8aa16bc7e78456cce1736fac82496996a8761f4))
+* Make `nargo` the default binary for cargo run ([#4554](https://github.com/noir-lang/noir/issues/4554)) ([de4986e](https://github.com/noir-lang/noir/commit/de4986eb74b28b2e1065fa6b413d02457ddf61b0))
+* Signed integer comparisons in brillig ([#4579](https://github.com/noir-lang/noir/issues/4579)) ([938d5e8](https://github.com/noir-lang/noir/commit/938d5e85eda00a05de5014e64d3dc9fc7c24936d))
+* **ssa:** Use accurate type during SSA AsSlice simplficiation ([#4610](https://github.com/noir-lang/noir/issues/4610)) ([0473497](https://github.com/noir-lang/noir/commit/04734976e92475b1ab94257e30bc3438c7358681))
+* Substitute generics when checking the field count of a type ([#4547](https://github.com/noir-lang/noir/issues/4547)) ([eeeebac](https://github.com/noir-lang/noir/commit/eeeebacd10698e847f773e26dac8a4a5eb8e84ed))
+
+
+### Miscellaneous Chores
+
+* Remove open keyword from Noir (https://github.com/AztecProtocol/aztec-packages/pull/4967) ([a6016b4](https://github.com/noir-lang/noir/commit/a6016b46abf6da6de4566cf6d35a675d805dd9b5))
+
 ## [0.25.0](https://github.com/noir-lang/noir/compare/v0.24.0...v0.25.0) (2024-03-11)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 99c19417267..d5a610ab57f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -23,7 +23,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -37,7 +37,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -53,7 +53,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "acir",
  "blake2",
@@ -88,7 +88,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -232,7 +232,7 @@ checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "arena"
-version = "0.25.0"
+version = "0.26.0"
 
 [[package]]
 name = "ark-bls12-381"
@@ -433,7 +433,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -631,7 +631,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.41.0"
+version = "0.42.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1736,7 +1736,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2357,7 +2357,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.25.0"
+version = "0.26.0"
 
 [[package]]
 name = "itertools"
@@ -2742,7 +2742,7 @@ checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
 name = "nargo"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2769,7 +2769,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2824,7 +2824,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2836,7 +2836,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2909,7 +2909,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2944,7 +2944,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -2970,7 +2970,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2993,7 +2993,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -3010,7 +3010,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3027,7 +3027,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_driver"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -3048,7 +3048,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3066,7 +3066,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "fxhash",
@@ -3082,7 +3082,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "arena",
@@ -3107,7 +3107,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index b8f9b9ceacc..74d2e6e05c7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.25.0"
+version = "0.26.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -52,12 +52,12 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.41.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.41.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.41.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.41.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.41.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.41.0", path = "acvm-repo/blackbox_solver", default-features = false }
+acir_field = { version = "0.42.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.42.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.42.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.42.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.42.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.42.0", path = "acvm-repo/blackbox_solver", default-features = false }
 bn254_blackbox_solver = { version = "0.39.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index 4f220d6eeba..33cc83d7dd9 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,87 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.42.0](https://github.com/noir-lang/noir/compare/v0.41.0...v0.42.0) (2024-03-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955))
+* Rename Arithmetic opcode to AssertZero ([#3840](https://github.com/noir-lang/noir/issues/3840))
+* Remove unused methods on ACIR opcodes ([#3841](https://github.com/noir-lang/noir/issues/3841))
+* Remove partial backend feature ([#3805](https://github.com/noir-lang/noir/issues/3805))
+
+### Features
+
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add support for overriding expression width ([#4117](https://github.com/noir-lang/noir/issues/4117)) ([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Aztec-packages ([#3754](https://github.com/noir-lang/noir/issues/3754)) ([c043265](https://github.com/noir-lang/noir/commit/c043265e550b59bd4296504826fe15d3ce3e9ad2))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955)) ([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove range constraints from witnesses which are constrained to be constants ([#3928](https://github.com/noir-lang/noir/issues/3928)) ([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
+* Remove replacement of boolean range opcodes with `AssertZero` opcodes ([#4107](https://github.com/noir-lang/noir/issues/4107)) ([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Speed up transformation of debug messages ([#3815](https://github.com/noir-lang/noir/issues/3815)) ([2a8af1e](https://github.com/noir-lang/noir/commit/2a8af1e4141ffff61547ee1c2837a6392bd5db48))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync `aztec-packages` ([#4011](https://github.com/noir-lang/noir/issues/4011)) ([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
+* Sync commits from `aztec-packages` ([#4068](https://github.com/noir-lang/noir/issues/4068)) ([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144)) ([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+
+
+### Bug Fixes
+
+* Deserialize odd length hex literals ([#3747](https://github.com/noir-lang/noir/issues/3747)) ([4000fb2](https://github.com/noir-lang/noir/commit/4000fb279221eb07187d657bfaa7f1c7b311abf2))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Remove panic from `init_log_level` in `acvm_js` ([#4195](https://github.com/noir-lang/noir/issues/4195)) ([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
+* Return error rather instead of panicking on invalid circuit ([#3976](https://github.com/noir-lang/noir/issues/3976)) ([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove partial backend feature ([#3805](https://github.com/noir-lang/noir/issues/3805)) ([0383100](https://github.com/noir-lang/noir/commit/0383100853a80a5b28b797cdfeae0d271f1b7805))
+* Remove unused methods on ACIR opcodes ([#3841](https://github.com/noir-lang/noir/issues/3841)) ([9e5d0e8](https://github.com/noir-lang/noir/commit/9e5d0e813d61a0bfb5ee68174ed287c5a20f1579))
+* Rename Arithmetic opcode to AssertZero ([#3840](https://github.com/noir-lang/noir/issues/3840)) ([836f171](https://github.com/noir-lang/noir/commit/836f17145c2901060706294461c2d282dd121b3e))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.41.0](https://github.com/noir-lang/noir/compare/v0.40.0...v0.41.0) (2024-03-11)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index be859d7d054..368f49258f9 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index c2056b73277..d63a885bfd8 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index d585850170a..d0ea52e859d 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 63fca2bd32a..65c072b1d96 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 2f444ba565a..55345a2ddf6 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index a783193edba..8f5ff862360 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 57f89e091b4..d3f082fda86 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 1c7add5cb40..32dabe6ecb0 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.41.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index 8db3876a753..6d11a5ba5c8 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.25.0",
+  "version": "0.26.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/flake.nix b/flake.nix
index 785d5aead56..1cb421a49ef 100644
--- a/flake.nix
+++ b/flake.nix
@@ -73,7 +73,7 @@
       # Configuration shared between builds
       config = {
         # x-release-please-start-version
-        version = "0.25.0";
+        version = "0.26.0";
         # x-release-please-end
 
         src = pkgs.lib.cleanSourceWith {
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 485f4252e29..1eabc6a1398 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.25.0",
+  "version": "0.26.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index 0da6e695202..c8d4873e095 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.25.0",
+  "version": "0.26.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 92b8460d1db..aec8204f065 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.25.0",
+  "version": "0.26.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index d7a08debb54..eadb6f49665 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index a6cc5503242..e93a8e6a5e3 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.25.0",
+  "version": "0.26.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From d6f10438487fea39b099f6bd313f89c6197b2af7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 26 Mar 2024 13:10:08 +0000
Subject: [PATCH 112/416] chore: fix acvm crates reporting errors as JS
 packages (#4637)

# Description

## Problem\*

Addresses incorrect content of #4634

## Summary\*

We were raising an alert for a bad publish of the ACVM crates as if they
were the JS packages so this PR updates the alert to be consistent.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/ACVM_PUBLISH_FAILED.md     | 10 ++++++++++
 .github/workflows/publish-acvm.yml |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 .github/ACVM_PUBLISH_FAILED.md

diff --git a/.github/ACVM_PUBLISH_FAILED.md b/.github/ACVM_PUBLISH_FAILED.md
new file mode 100644
index 00000000000..00e692a64d8
--- /dev/null
+++ b/.github/ACVM_PUBLISH_FAILED.md
@@ -0,0 +1,10 @@
+---
+title: "ACVM crates failed to publish"
+assignees: TomAFrench, Savio-Sou
+---
+
+The {{env.CRATE_VERSION}} release of the ACVM crates failed.
+
+Check the [Publish ACVM crates]({{env.WORKFLOW_URL}}) workflow for details.
+
+This issue was raised by the workflow `{{env.WORKFLOW_NAME}}`
diff --git a/.github/workflows/publish-acvm.yml b/.github/workflows/publish-acvm.yml
index 959cd8e4bca..d17d8f294fb 100644
--- a/.github/workflows/publish-acvm.yml
+++ b/.github/workflows/publish-acvm.yml
@@ -74,4 +74,4 @@ jobs:
           WORKFLOW_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         with:
           update_existing: true
-          filename: .github/JS_PUBLISH_FAILED.md
\ No newline at end of file
+          filename: .github/ACVM_PUBLISH_FAILED.md
\ No newline at end of file

From 10f182a77a1662e45c200a701fdd66c5db035a66 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 26 Mar 2024 13:10:27 +0000
Subject: [PATCH 113/416] chore: fix versioning of `bn254_blackbox_solver`
 crate (#4638)

# Description

## Problem\*

Resolves #4634

## Summary\*

The ACVM crate publishing steps are failing because when
`barretenberg_blackbox_solver` was renamed to `bn254_blackbox_solver`
the release please config wasn't updated to match, resulting in the
version not being incremented on releases.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                 | 2 +-
 Cargo.toml                                 | 2 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml | 2 +-
 release-please-config.json                 | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d5a610ab57f..caa6eb4d250 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -600,7 +600,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.39.0"
+version = "0.42.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
diff --git a/Cargo.toml b/Cargo.toml
index 74d2e6e05c7..46ccb401fbd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,7 +58,7 @@ acvm = { version = "0.42.0", path = "acvm-repo/acvm" }
 brillig = { version = "0.42.0", path = "acvm-repo/brillig", default-features = false }
 brillig_vm = { version = "0.42.0", path = "acvm-repo/brillig_vm", default-features = false }
 acvm_blackbox_solver = { version = "0.42.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.39.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "0.42.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 arena = { path = "compiler/utils/arena" }
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index a0a15409604..396e4aa0146 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.39.0"
+version = "0.42.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/release-please-config.json b/release-please-config.json
index e73993ca974..217a86303a1 100644
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -61,8 +61,8 @@
         "acir_field/Cargo.toml",
         "acvm/Cargo.toml",
         "acvm_js/Cargo.toml",
-        "barretenberg_blackbox_solver/Cargo.toml",
         "blackbox_solver/Cargo.toml",
+        "bn254_blackbox_solver/Cargo.toml",
         "brillig/Cargo.toml",
         "brillig_vm/Cargo.toml",
         {

From 1b50ce155cf95193937729c2a23f34b0ade42ea0 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 26 Mar 2024 17:23:04 +0000
Subject: [PATCH 114/416] fix(ssa): Fix slice intrinsic handling in the
 capacity tracker  (#4643)

# Description

## Problem\*

Resolves
https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631

## Summary\*

We were not accurately accounting for situations where the slice
capacity tracker was expecting a capacity from slice intrinsic results.
I have added a case for handling the slice capacity of `AsSlice`.

I also tested this against the `aztec-packages` work and we can
successfully compile now.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../ssa/opt/flatten_cfg/capacity_tracker.rs   | 14 +++++++++++---
 .../regression_capacity_tracker/Nargo.toml    |  7 +++++++
 .../regression_capacity_tracker/Prover.toml   |  3 +++
 .../regression_capacity_tracker/src/main.nr   | 19 +++++++++++++++++++
 4 files changed, 40 insertions(+), 3 deletions(-)
 create mode 100644 test_programs/execution_success/regression_capacity_tracker/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_capacity_tracker/Prover.toml
 create mode 100644 test_programs/execution_success/regression_capacity_tracker/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
index bdfc04f0bbe..93e52542278 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
@@ -73,6 +73,7 @@ impl<'a> SliceCapacityTracker<'a> {
                         Intrinsic::SlicePopFront => (Some(1), results.len() - 1),
                         // The slice capacity of these intrinsics is not determined by the arguments of the function.
                         Intrinsic::ToBits(_) | Intrinsic::ToRadix(_) => (None, 1),
+                        Intrinsic::AsSlice => (Some(0), 1),
                         _ => return,
                     };
                     let result_slice = results[result_index];
@@ -90,6 +91,7 @@ impl<'a> SliceCapacityTracker<'a> {
                                     self.compute_slice_capacity(*arg, slice_sizes);
                                 }
                             }
+
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
                                 let new_capacity = *contents_capacity + 1;
                                 slice_sizes.insert(result_slice, new_capacity);
@@ -102,9 +104,6 @@ impl<'a> SliceCapacityTracker<'a> {
                                 .expect("ICE: Should have an argument index for slice intrinsics");
                             let slice_contents = arguments[argument_index];
 
-                            // We do not decrement the size on intrinsics that could remove values from a slice.
-                            // This is because we could potentially go back to the smaller slice and not fill in dummies.
-                            // This pass should be tracking the potential max that a slice ***could be***
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
                                 let new_capacity = *contents_capacity - 1;
                                 slice_sizes.insert(result_slice, new_capacity);
@@ -121,6 +120,15 @@ impl<'a> SliceCapacityTracker<'a> {
                             slice_sizes
                                 .insert(result_slice, FieldElement::max_num_bytes() as usize);
                         }
+                        Intrinsic::AsSlice => {
+                            let argument_index = argument_index
+                                .expect("ICE: Should have an argument index for AsSlice builtin");
+                            let array_size = self
+                                .dfg
+                                .try_get_array_length(arguments[argument_index])
+                                .expect("ICE: Should be have an array length for AsSlice input");
+                            slice_sizes.insert(result_slice, array_size);
+                        }
                         _ => {}
                     }
                 }
diff --git a/test_programs/execution_success/regression_capacity_tracker/Nargo.toml b/test_programs/execution_success/regression_capacity_tracker/Nargo.toml
new file mode 100644
index 00000000000..d5a3839626f
--- /dev/null
+++ b/test_programs/execution_success/regression_capacity_tracker/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_capacity_tracker"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_capacity_tracker/Prover.toml b/test_programs/execution_success/regression_capacity_tracker/Prover.toml
new file mode 100644
index 00000000000..bbf35b23a0f
--- /dev/null
+++ b/test_programs/execution_success/regression_capacity_tracker/Prover.toml
@@ -0,0 +1,3 @@
+expected = "10"
+first = "10"
+input = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_capacity_tracker/src/main.nr b/test_programs/execution_success/regression_capacity_tracker/src/main.nr
new file mode 100644
index 00000000000..be645c811d2
--- /dev/null
+++ b/test_programs/execution_success/regression_capacity_tracker/src/main.nr
@@ -0,0 +1,19 @@
+// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631
+// for context. 
+// We were not accurately accounting for situations where the slice capacity tracker
+// was expecting a capacity from slice intrinsic results.
+fn main(expected: pub Field, first: Field, input: [Field; 20]) {
+    let mut hasher_slice = input.as_slice();
+    hasher_slice = hasher_slice.push_front(first);
+    assert(hasher_slice[0] == expected);
+    // We need a conditional based upon witnesses 
+    // to force a store of the slice. 
+    // If this successfully compiles it means we have stored 
+    // the results of the slice intrinsics used above.
+    if expected as u32 > 10 {
+        hasher_slice[expected - 10] = 100;
+    } else {
+        hasher_slice[expected] = 100;
+    }
+    assert(hasher_slice[0] == expected);
+}

From 4deda65f239b59a51e0ab4523f48794b27921707 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 26 Mar 2024 19:23:07 +0000
Subject: [PATCH 115/416] chore(ci): add warning sticky comment (#4647)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We currently don't have any feedback for when the release workflow
doesn't fully complete to signal that releases shouldn't be made. I've
updated the workflow so that we post a sticky comment in this situation.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/release.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 83e8e479181..249d83afecc 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -100,6 +100,36 @@ jobs:
           git commit -m "chore(docs): cut new docs version for tag ${{ steps.noir-version.outputs.semver }}"
           git push
 
+  release-end:
+    name: Release End
+    runs-on: ubuntu-latest
+    # We want this job to always run (even if the dependant jobs fail) as we need apply changes to the sticky comment.
+    if: ${{ always() }}
+    
+    needs:
+      - update-acvm-workspace-package-versions
+      - update-docs
+
+    env:
+      # We treat any skipped or failing jobs as a failure for the workflow as a whole.
+      FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }
+
+    steps:  
+      - name: Add warning to sticky comment
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          # delete the comment in case failures have been fixed
+          delete: ${{ !env.FAIL }}
+          message: "The release workflow has not completed successfully. Releasing now will result in a broken release"
+
+      - name: Report overall success
+        run: |
+          if [[ $FAIL == true ]]; then
+              exit 1
+          else
+              exit 0
+          fi
+
   build-binaries:
     name: Build binaries
     needs: [release-please]

From c0bae17e70f55ebf4b1639e0dfb075d8c5c97892 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 26 Mar 2024 14:40:00 -0500
Subject: [PATCH 116/416] fix: Slice coercions (#4640)

# Description

## Problem\*

Resolves #4639

## Summary\*

The array to slice coercion was broken - and it seemingly has always
been so. The coercion never actually called `replace_expr` to replace
the original expression with the `as_slice(original_expr)` coercion.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir_def/types.rs  | 15 ++++++++++-----
 .../slice_coercion/Nargo.toml                 |  7 +++++++
 .../slice_coercion/Prover.toml                |  2 ++
 .../slice_coercion/src/main.nr                | 19 +++++++++++++++++++
 4 files changed, 38 insertions(+), 5 deletions(-)
 create mode 100644 test_programs/execution_success/slice_coercion/Nargo.toml
 create mode 100644 test_programs/execution_success/slice_coercion/Prover.toml
 create mode 100644 test_programs/execution_success/slice_coercion/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 3c5627f739b..65592407d7d 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -1662,14 +1662,19 @@ fn convert_array_expression_to_slice(
     let as_slice = HirExpression::Ident(HirIdent::non_trait_method(as_slice_id, location));
     let func = interner.push_expr(as_slice);
 
-    let arguments = vec![expression];
+    // Copy the expression and give it a new ExprId. The old one
+    // will be mutated in place into a Call expression.
+    let argument = interner.expression(&expression);
+    let argument = interner.push_expr(argument);
+    interner.push_expr_type(argument, array_type.clone());
+    interner.push_expr_location(argument, location.span, location.file);
+
+    let arguments = vec![argument];
     let call = HirExpression::Call(HirCallExpression { func, arguments, location });
-    let call = interner.push_expr(call);
+    interner.replace_expr(&expression, call);
 
-    interner.push_expr_location(call, location.span, location.file);
     interner.push_expr_location(func, location.span, location.file);
-
-    interner.push_expr_type(call, target_type.clone());
+    interner.push_expr_type(expression, target_type.clone());
 
     let func_type = Type::Function(vec![array_type], Box::new(target_type), Box::new(Type::Unit));
     interner.push_expr_type(func, func_type);
diff --git a/test_programs/execution_success/slice_coercion/Nargo.toml b/test_programs/execution_success/slice_coercion/Nargo.toml
new file mode 100644
index 00000000000..659677cc560
--- /dev/null
+++ b/test_programs/execution_success/slice_coercion/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "slice_coercion"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.25.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/slice_coercion/Prover.toml b/test_programs/execution_success/slice_coercion/Prover.toml
new file mode 100644
index 00000000000..09c44a855b0
--- /dev/null
+++ b/test_programs/execution_success/slice_coercion/Prover.toml
@@ -0,0 +1,2 @@
+first = 3
+expected = 3
diff --git a/test_programs/execution_success/slice_coercion/src/main.nr b/test_programs/execution_success/slice_coercion/src/main.nr
new file mode 100644
index 00000000000..a3785e79afa
--- /dev/null
+++ b/test_programs/execution_success/slice_coercion/src/main.nr
@@ -0,0 +1,19 @@
+struct Hasher {
+    fields: [Field],
+}
+
+impl Hasher {
+    pub fn new() -> Self {
+        Self { fields: [] }
+    }
+
+    pub fn add(&mut self, field: Field) {
+        self.fields = self.fields.push_back(field);
+    }
+}
+
+fn main(expected: pub Field, first: Field) {
+    let mut hasher = Hasher::new();
+    hasher.add(first);
+    assert(hasher.fields[0] == expected);
+}

From 166e569aaaffef4c7e3b23bf5b39f0a331f79287 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 26 Mar 2024 19:41:31 +0000
Subject: [PATCH 117/416] chore: delete `R1CSTransformer` (#4649)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The R1CS transformer is currently a no-op as the expression width is
unbounded and we guarantee that expressions will be at most degree 2 by
default.

It also looks increasingly likely that the CSAT transformer code will be
moved into the acir_gen pass so this is redundant.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acvm/src/compiler/transformers/mod.rs  |  5 +----
 acvm-repo/acvm/src/compiler/transformers/r1cs.rs | 16 ----------------
 2 files changed, 1 insertion(+), 20 deletions(-)
 delete mode 100644 acvm-repo/acvm/src/compiler/transformers/r1cs.rs

diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 2e549854521..18f49c154f1 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -6,10 +6,8 @@ use acir::{
 use indexmap::IndexMap;
 
 mod csat;
-mod r1cs;
 
 pub(crate) use csat::CSatTransformer;
-pub(crate) use r1cs::R1CSTransformer;
 
 use super::{transform_assert_messages, AcirTransformationMap};
 
@@ -43,8 +41,7 @@ pub(super) fn transform_internal(
 ) -> (Circuit, Vec<usize>) {
     let mut transformer = match &expression_width {
         ExpressionWidth::Unbounded => {
-            let transformer = R1CSTransformer::new(acir);
-            return (transformer.transform(), acir_opcode_positions);
+            return (acir, acir_opcode_positions);
         }
         ExpressionWidth::Bounded { width } => {
             let mut csat = CSatTransformer::new(*width);
diff --git a/acvm-repo/acvm/src/compiler/transformers/r1cs.rs b/acvm-repo/acvm/src/compiler/transformers/r1cs.rs
deleted file mode 100644
index 3bdd29c9c53..00000000000
--- a/acvm-repo/acvm/src/compiler/transformers/r1cs.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use acir::circuit::Circuit;
-
-/// Currently a "noop" transformer.
-pub(crate) struct R1CSTransformer {
-    acir: Circuit,
-}
-
-impl R1CSTransformer {
-    pub(crate) fn new(acir: Circuit) -> Self {
-        Self { acir }
-    }
-    // TODO: We could possibly make sure that all polynomials are at most degree-2
-    pub(crate) fn transform(self) -> Circuit {
-        self.acir
-    }
-}

From 117eb89fa0256088644ba39000716e7390c7383b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 27 Mar 2024 14:29:55 +0000
Subject: [PATCH 118/416] chore: add missing brace to workflow (#4654)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Followup to #4647


## Additional Context


The previous PR has a missing brace which invalidates the workflow. This
PR adds this.


## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 249d83afecc..b6b88561f4e 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -112,7 +112,7 @@ jobs:
 
     env:
       # We treat any skipped or failing jobs as a failure for the workflow as a whole.
-      FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }
+      FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
 
     steps:  
       - name: Add warning to sticky comment

From d202a086790f6dae33f9df385ab39b64ec8b54db Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 27 Mar 2024 14:29:08 +0000
Subject: [PATCH 119/416] chore: install dependencies for building docs
 dependencies (#4646)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

See docs builds failing on master
https://github.com/noir-lang/noir/actions/runs/8436552091/job/23104382133

This PR updates the workflow to install the necessary dependencies

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .github/workflows/release.yml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b6b88561f4e..8ab5c182ef2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -79,6 +79,15 @@ jobs:
       - name: Install Yarn dependencies
         uses: ./.github/actions/setup
 
+      - name: Install wasm-bindgen-cli
+        uses: taiki-e/install-action@v2
+        with:
+          tool: wasm-bindgen-cli@0.2.86
+
+      - name: Install wasm-opt
+        run: |
+          npm i wasm-opt -g
+
       - name: Query new noir version
         id: noir-version
         run: |

From b87654e2b4761dfacc916dac70d43c1b572ec636 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 27 Mar 2024 17:46:29 +0000
Subject: [PATCH 120/416] fix(ssa): Accurate constant type for slice dummy data
 in flattening (#4661)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We were not accurately constructing the type for slice dummy data. We
were always making slice dummy data a `Field` but this could lead to
errors when eventually merging this value with a different numeric type.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/opt/flatten_cfg/value_merger.rs          |  4 ++--
 .../regression_sha256_slice/Nargo.toml               |  7 +++++++
 .../regression_sha256_slice/Prover.toml              |  1 +
 .../regression_sha256_slice/src/main.nr              | 12 ++++++++++++
 4 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/execution_success/regression_sha256_slice/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_sha256_slice/Prover.toml
 create mode 100644 test_programs/execution_success/regression_sha256_slice/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
index 6b923a2e42d..0a351148fa3 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
@@ -234,9 +234,9 @@ impl<'a> ValueMerger<'a> {
     /// such as with dynamic indexing of non-homogenous slices.
     fn make_slice_dummy_data(&mut self, typ: &Type) -> ValueId {
         match typ {
-            Type::Numeric(_) => {
+            Type::Numeric(numeric_type) => {
                 let zero = FieldElement::zero();
-                self.dfg.make_constant(zero, Type::field())
+                self.dfg.make_constant(zero, Type::Numeric(*numeric_type))
             }
             Type::Array(element_types, len) => {
                 let mut array = im::Vector::new();
diff --git a/test_programs/execution_success/regression_sha256_slice/Nargo.toml b/test_programs/execution_success/regression_sha256_slice/Nargo.toml
new file mode 100644
index 00000000000..759c3b20ba8
--- /dev/null
+++ b/test_programs/execution_success/regression_sha256_slice/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_sha256_slice"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_sha256_slice/Prover.toml b/test_programs/execution_success/regression_sha256_slice/Prover.toml
new file mode 100644
index 00000000000..8a027e9eca9
--- /dev/null
+++ b/test_programs/execution_success/regression_sha256_slice/Prover.toml
@@ -0,0 +1 @@
+x = ["5", "10"]
diff --git a/test_programs/execution_success/regression_sha256_slice/src/main.nr b/test_programs/execution_success/regression_sha256_slice/src/main.nr
new file mode 100644
index 00000000000..60b0911cf09
--- /dev/null
+++ b/test_programs/execution_success/regression_sha256_slice/src/main.nr
@@ -0,0 +1,12 @@
+use dep::std;
+
+fn main(x: [u8; 2]) {
+    let mut y = x.as_slice();
+    let digest1 = std::hash::sha256_slice(y);
+    let mut v = y;
+    if x[0] != 0 {
+        v = y.push_back(x[0]);
+    }
+    let digest2 = std::hash::sha256_slice(v);
+    assert(digest1 != digest2);
+}

From 0bad1bb5ef5dc8cd4ff82e6621d0e6ef72b181fc Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 27 Mar 2024 23:05:57 +0000
Subject: [PATCH 121/416] chore: pass release PR number to sticky comment
 action (#4665)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

See comment

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/release.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 8ab5c182ef2..badcd3af2dd 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -116,6 +116,7 @@ jobs:
     if: ${{ always() }}
     
     needs:
+      - release-please
       - update-acvm-workspace-package-versions
       - update-docs
 
@@ -127,6 +128,8 @@ jobs:
       - name: Add warning to sticky comment
         uses: marocchino/sticky-pull-request-comment@v2
         with:
+          # We need to specify the PR on which to make the comment as workflow is triggered by push.
+          number: ${{ fromJSON(needs.release-please.outputs.release-pr).number }}
           # delete the comment in case failures have been fixed
           delete: ${{ !env.FAIL }}
           message: "The release workflow has not completed successfully. Releasing now will result in a broken release"

From 0bc18c4f78171590dd58bded959f68f53a44cc8c Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 27 Mar 2024 18:59:41 -0400
Subject: [PATCH 122/416] feat: Sync from aztec-packages (#4657)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
chore: Dont double check num bits in brillig vm
(https://github.com/AztecProtocol/aztec-packages/pull/5489)
chore: unify noir macros flow
(https://github.com/AztecProtocol/aztec-packages/pull/5461)
feat!: Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
chore: add AvmContextInputs
(https://github.com/AztecProtocol/aztec-packages/pull/5396)
END_COMMIT_OVERRIDE

---------

Co-authored-by: sirasistant <sirasistant@gmail.com>
---
 .aztec-sync-commit                            |    2 +-
 Cargo.lock                                    |    1 +
 acvm-repo/acir/codegen/acir.cpp               | 1245 ++++++++---------
 .../acir/tests/test_program_serialization.rs  |   46 +-
 acvm-repo/acvm/src/pwg/brillig.rs             |   20 +-
 acvm-repo/acvm/tests/solver.rs                |   41 +-
 acvm-repo/acvm_js/src/foreign_call/inputs.rs  |    4 +-
 acvm-repo/acvm_js/src/foreign_call/outputs.rs |    8 +-
 .../test/shared/complex_foreign_call.ts       |   14 +-
 acvm-repo/acvm_js/test/shared/foreign_call.ts |    8 +-
 acvm-repo/brillig/src/foreign_call.rs         |   26 +-
 acvm-repo/brillig/src/lib.rs                  |    3 -
 acvm-repo/brillig/src/opcodes.rs              |   15 +-
 acvm-repo/brillig/src/value.rs                |  103 --
 acvm-repo/brillig_vm/Cargo.toml               |    1 +
 acvm-repo/brillig_vm/src/arithmetic.rs        |  136 +-
 acvm-repo/brillig_vm/src/black_box.rs         |   67 +-
 acvm-repo/brillig_vm/src/lib.rs               |  754 +++++-----
 acvm-repo/brillig_vm/src/memory.rs            |  170 ++-
 aztec_macros/src/lib.rs                       |   15 +-
 aztec_macros/src/transforms/functions.rs      |  214 ++-
 .../brillig/brillig_gen/brillig_black_box.rs  |   12 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |   10 +-
 .../brillig_gen/brillig_block_variables.rs    |    7 +-
 .../brillig/brillig_gen/brillig_directive.rs  |   37 +-
 .../src/brillig/brillig_gen/brillig_fn.rs     |   16 +-
 .../brillig/brillig_gen/brillig_slice_ops.rs  |  238 ++--
 .../noirc_evaluator/src/brillig/brillig_ir.rs |   17 +-
 .../brillig/brillig_ir/brillig_variable.rs    |   15 +-
 .../src/brillig/brillig_ir/codegen_binary.rs  |    4 +-
 .../brillig/brillig_ir/codegen_intrinsic.rs   |   14 +-
 .../src/brillig/brillig_ir/debug_show.rs      |   11 +-
 .../src/brillig/brillig_ir/entry_point.rs     |   34 +-
 .../src/brillig/brillig_ir/instructions.rs    |   42 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |   16 +-
 compiler/noirc_printable_type/src/lib.rs      |   16 +-
 noir_stdlib/src/collections/bounded_vec.nr    |    9 +
 noir_stdlib/src/field.nr                      |    2 +-
 tooling/bb_abstraction_leaks/build.rs         |    2 +-
 tooling/debugger/src/context.rs               |   12 +-
 tooling/debugger/src/foreign_calls.rs         |   17 +-
 tooling/debugger/src/repl.rs                  |   12 +-
 tooling/nargo/src/artifacts/debug_vars.rs     |   12 +-
 tooling/nargo/src/ops/foreign_calls.rs        |   43 +-
 .../noir_js_backend_barretenberg/package.json |    2 +-
 yarn.lock                                     |   10 +-
 46 files changed, 1886 insertions(+), 1617 deletions(-)
 delete mode 100644 acvm-repo/brillig/src/value.rs

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index ead8f3147c0..ad4ef635e17 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-208abbb63af4c9a3f25d723fe1c49e82aa461061
+a18288d9b8f3057b9e79362d922da656dacf22a9
diff --git a/Cargo.lock b/Cargo.lock
index caa6eb4d250..8c47f03b267 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -637,6 +637,7 @@ dependencies = [
  "acvm_blackbox_solver",
  "num-bigint",
  "num-traits",
+ "thiserror",
 ]
 
 [[package]]
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index ca281d89637..d7ef849ab75 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -5,957 +5,951 @@
 
 namespace Program {
 
-    struct BinaryFieldOp {
+    struct Witness {
+        uint32_t value;
 
-        struct Add {
-            friend bool operator==(const Add&, const Add&);
+        friend bool operator==(const Witness&, const Witness&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Witness bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct FunctionInput {
+        Program::Witness witness;
+        uint32_t num_bits;
+
+        friend bool operator==(const FunctionInput&, const FunctionInput&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static FunctionInput bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct BlackBoxFuncCall {
+
+        struct AND {
+            Program::FunctionInput lhs;
+            Program::FunctionInput rhs;
+            Program::Witness output;
+
+            friend bool operator==(const AND&, const AND&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Add bincodeDeserialize(std::vector<uint8_t>);
+            static AND bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Sub {
-            friend bool operator==(const Sub&, const Sub&);
+        struct XOR {
+            Program::FunctionInput lhs;
+            Program::FunctionInput rhs;
+            Program::Witness output;
+
+            friend bool operator==(const XOR&, const XOR&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Sub bincodeDeserialize(std::vector<uint8_t>);
+            static XOR bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Mul {
-            friend bool operator==(const Mul&, const Mul&);
+        struct RANGE {
+            Program::FunctionInput input;
+
+            friend bool operator==(const RANGE&, const RANGE&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Mul bincodeDeserialize(std::vector<uint8_t>);
+            static RANGE bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Div {
-            friend bool operator==(const Div&, const Div&);
+        struct SHA256 {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const SHA256&, const SHA256&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Div bincodeDeserialize(std::vector<uint8_t>);
+            static SHA256 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct IntegerDiv {
-            friend bool operator==(const IntegerDiv&, const IntegerDiv&);
+        struct Blake2s {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static IntegerDiv bincodeDeserialize(std::vector<uint8_t>);
+            static Blake2s bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Equals {
-            friend bool operator==(const Equals&, const Equals&);
+        struct Blake3 {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Equals bincodeDeserialize(std::vector<uint8_t>);
+            static Blake3 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct LessThan {
-            friend bool operator==(const LessThan&, const LessThan&);
+        struct SchnorrVerify {
+            Program::FunctionInput public_key_x;
+            Program::FunctionInput public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> message;
+            Program::Witness output;
+
+            friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static LessThan bincodeDeserialize(std::vector<uint8_t>);
+            static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct LessThanEquals {
-            friend bool operator==(const LessThanEquals&, const LessThanEquals&);
+        struct PedersenCommitment {
+            std::vector<Program::FunctionInput> inputs;
+            uint32_t domain_separator;
+            std::array<Program::Witness, 2> outputs;
+
+            friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static LessThanEquals bincodeDeserialize(std::vector<uint8_t>);
+            static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Add, Sub, Mul, Div, IntegerDiv, Equals, LessThan, LessThanEquals> value;
+        struct PedersenHash {
+            std::vector<Program::FunctionInput> inputs;
+            uint32_t domain_separator;
+            Program::Witness output;
 
-        friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BinaryFieldOp bincodeDeserialize(std::vector<uint8_t>);
-    };
+            friend bool operator==(const PedersenHash&, const PedersenHash&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-    struct BinaryIntOp {
+        struct EcdsaSecp256k1 {
+            std::vector<Program::FunctionInput> public_key_x;
+            std::vector<Program::FunctionInput> public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> hashed_message;
+            Program::Witness output;
 
-        struct Add {
-            friend bool operator==(const Add&, const Add&);
+            friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Add bincodeDeserialize(std::vector<uint8_t>);
+            static EcdsaSecp256k1 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Sub {
-            friend bool operator==(const Sub&, const Sub&);
+        struct EcdsaSecp256r1 {
+            std::vector<Program::FunctionInput> public_key_x;
+            std::vector<Program::FunctionInput> public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> hashed_message;
+            Program::Witness output;
+
+            friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Sub bincodeDeserialize(std::vector<uint8_t>);
+            static EcdsaSecp256r1 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Mul {
-            friend bool operator==(const Mul&, const Mul&);
+        struct FixedBaseScalarMul {
+            Program::FunctionInput low;
+            Program::FunctionInput high;
+            std::array<Program::Witness, 2> outputs;
+
+            friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Mul bincodeDeserialize(std::vector<uint8_t>);
+            static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Div {
-            friend bool operator==(const Div&, const Div&);
+        struct EmbeddedCurveAdd {
+            Program::FunctionInput input1_x;
+            Program::FunctionInput input1_y;
+            Program::FunctionInput input2_x;
+            Program::FunctionInput input2_y;
+            std::array<Program::Witness, 2> outputs;
+
+            friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Div bincodeDeserialize(std::vector<uint8_t>);
+            static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Equals {
-            friend bool operator==(const Equals&, const Equals&);
+        struct Keccak256 {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Equals bincodeDeserialize(std::vector<uint8_t>);
+            static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct LessThan {
-            friend bool operator==(const LessThan&, const LessThan&);
+        struct Keccak256VariableLength {
+            std::vector<Program::FunctionInput> inputs;
+            Program::FunctionInput var_message_size;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const Keccak256VariableLength&, const Keccak256VariableLength&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static LessThan bincodeDeserialize(std::vector<uint8_t>);
+            static Keccak256VariableLength bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct LessThanEquals {
-            friend bool operator==(const LessThanEquals&, const LessThanEquals&);
+        struct Keccakf1600 {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static LessThanEquals bincodeDeserialize(std::vector<uint8_t>);
+            static Keccakf1600 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct And {
-            friend bool operator==(const And&, const And&);
+        struct RecursiveAggregation {
+            std::vector<Program::FunctionInput> verification_key;
+            std::vector<Program::FunctionInput> proof;
+            std::vector<Program::FunctionInput> public_inputs;
+            Program::FunctionInput key_hash;
+
+            friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static And bincodeDeserialize(std::vector<uint8_t>);
+            static RecursiveAggregation bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Or {
-            friend bool operator==(const Or&, const Or&);
+        struct BigIntAdd {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntAdd&, const BigIntAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Or bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Xor {
-            friend bool operator==(const Xor&, const Xor&);
+        struct BigIntSub {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntSub&, const BigIntSub&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Xor bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Shl {
-            friend bool operator==(const Shl&, const Shl&);
+        struct BigIntMul {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntMul&, const BigIntMul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Shl bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntMul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Shr {
-            friend bool operator==(const Shr&, const Shr&);
+        struct BigIntDiv {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntDiv&, const BigIntDiv&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Shr bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntDiv bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Add, Sub, Mul, Div, Equals, LessThan, LessThanEquals, And, Or, Xor, Shl, Shr> value;
+        struct BigIntFromLeBytes {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<uint8_t> modulus;
+            uint32_t output;
 
-        friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BinaryIntOp bincodeDeserialize(std::vector<uint8_t>);
-    };
+            friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntFromLeBytes bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-    struct MemoryAddress {
-        uint64_t value;
+        struct BigIntToLeBytes {
+            uint32_t input;
+            std::vector<Program::Witness> outputs;
 
-        friend bool operator==(const MemoryAddress&, const MemoryAddress&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static MemoryAddress bincodeDeserialize(std::vector<uint8_t>);
-    };
+            friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntToLeBytes bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-    struct HeapArray {
-        Program::MemoryAddress pointer;
-        uint64_t size;
+        struct Poseidon2Permutation {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
+            uint32_t len;
 
-        friend bool operator==(const HeapArray&, const HeapArray&);
+            friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Poseidon2Permutation bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Sha256Compression {
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> hash_values;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const Sha256Compression&, const Sha256Compression&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+
+        friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static HeapArray bincodeDeserialize(std::vector<uint8_t>);
+        static BlackBoxFuncCall bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct HeapVector {
-        Program::MemoryAddress pointer;
-        Program::MemoryAddress size;
+    struct BlockId {
+        uint32_t value;
 
-        friend bool operator==(const HeapVector&, const HeapVector&);
+        friend bool operator==(const BlockId&, const BlockId&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static HeapVector bincodeDeserialize(std::vector<uint8_t>);
+        static BlockId bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct BlackBoxOp {
+    struct Expression {
+        std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
+        std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
+        std::string q_c;
 
-        struct Sha256 {
-            Program::HeapVector message;
-            Program::HeapArray output;
+        friend bool operator==(const Expression&, const Expression&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Expression bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-            friend bool operator==(const Sha256&, const Sha256&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Sha256 bincodeDeserialize(std::vector<uint8_t>);
-        };
+    struct BrilligInputs {
 
-        struct Blake2s {
-            Program::HeapVector message;
-            Program::HeapArray output;
+        struct Single {
+            Program::Expression value;
 
-            friend bool operator==(const Blake2s&, const Blake2s&);
+            friend bool operator==(const Single&, const Single&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Blake2s bincodeDeserialize(std::vector<uint8_t>);
+            static Single bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Blake3 {
-            Program::HeapVector message;
-            Program::HeapArray output;
+        struct Array {
+            std::vector<Program::Expression> value;
 
-            friend bool operator==(const Blake3&, const Blake3&);
+            friend bool operator==(const Array&, const Array&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Blake3 bincodeDeserialize(std::vector<uint8_t>);
+            static Array bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccak256 {
-            Program::HeapVector message;
-            Program::HeapArray output;
+        struct MemoryArray {
+            Program::BlockId value;
 
-            friend bool operator==(const Keccak256&, const Keccak256&);
+            friend bool operator==(const MemoryArray&, const MemoryArray&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
+            static MemoryArray bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccakf1600 {
-            Program::HeapVector message;
-            Program::HeapArray output;
+        std::variant<Single, Array, MemoryArray> value;
 
-            friend bool operator==(const Keccakf1600&, const Keccakf1600&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Keccakf1600 bincodeDeserialize(std::vector<uint8_t>);
-        };
+        friend bool operator==(const BrilligInputs&, const BrilligInputs&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static BrilligInputs bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-        struct EcdsaSecp256k1 {
-            Program::HeapVector hashed_msg;
-            Program::HeapArray public_key_x;
-            Program::HeapArray public_key_y;
-            Program::HeapArray signature;
-            Program::MemoryAddress result;
+    struct BinaryFieldOp {
 
-            friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
+        struct Add {
+            friend bool operator==(const Add&, const Add&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static EcdsaSecp256k1 bincodeDeserialize(std::vector<uint8_t>);
+            static Add bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct EcdsaSecp256r1 {
-            Program::HeapVector hashed_msg;
-            Program::HeapArray public_key_x;
-            Program::HeapArray public_key_y;
-            Program::HeapArray signature;
-            Program::MemoryAddress result;
-
-            friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
+        struct Sub {
+            friend bool operator==(const Sub&, const Sub&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static EcdsaSecp256r1 bincodeDeserialize(std::vector<uint8_t>);
+            static Sub bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct SchnorrVerify {
-            Program::MemoryAddress public_key_x;
-            Program::MemoryAddress public_key_y;
-            Program::HeapVector message;
-            Program::HeapVector signature;
-            Program::MemoryAddress result;
-
-            friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
+        struct Mul {
+            friend bool operator==(const Mul&, const Mul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
+            static Mul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct PedersenCommitment {
-            Program::HeapVector inputs;
-            Program::MemoryAddress domain_separator;
-            Program::HeapArray output;
-
-            friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
+        struct Div {
+            friend bool operator==(const Div&, const Div&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
+            static Div bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct PedersenHash {
-            Program::HeapVector inputs;
-            Program::MemoryAddress domain_separator;
-            Program::MemoryAddress output;
-
-            friend bool operator==(const PedersenHash&, const PedersenHash&);
+        struct IntegerDiv {
+            friend bool operator==(const IntegerDiv&, const IntegerDiv&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
+            static IntegerDiv bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct FixedBaseScalarMul {
-            Program::MemoryAddress low;
-            Program::MemoryAddress high;
-            Program::HeapArray result;
-
-            friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
+        struct Equals {
+            friend bool operator==(const Equals&, const Equals&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
+            static Equals bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct EmbeddedCurveAdd {
-            Program::MemoryAddress input1_x;
-            Program::MemoryAddress input1_y;
-            Program::MemoryAddress input2_x;
-            Program::MemoryAddress input2_y;
-            Program::HeapArray result;
-
-            friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
+        struct LessThan {
+            friend bool operator==(const LessThan&, const LessThan&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
+            static LessThan bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntAdd {
-            Program::MemoryAddress lhs;
-            Program::MemoryAddress rhs;
-            Program::MemoryAddress output;
-
-            friend bool operator==(const BigIntAdd&, const BigIntAdd&);
+        struct LessThanEquals {
+            friend bool operator==(const LessThanEquals&, const LessThanEquals&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
+            static LessThanEquals bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntSub {
-            Program::MemoryAddress lhs;
-            Program::MemoryAddress rhs;
-            Program::MemoryAddress output;
+        std::variant<Add, Sub, Mul, Div, IntegerDiv, Equals, LessThan, LessThanEquals> value;
 
-            friend bool operator==(const BigIntSub&, const BigIntSub&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
-        };
+        friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static BinaryFieldOp bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-        struct BigIntMul {
-            Program::MemoryAddress lhs;
-            Program::MemoryAddress rhs;
-            Program::MemoryAddress output;
+    struct BinaryIntOp {
 
-            friend bool operator==(const BigIntMul&, const BigIntMul&);
+        struct Add {
+            friend bool operator==(const Add&, const Add&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntMul bincodeDeserialize(std::vector<uint8_t>);
+            static Add bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntDiv {
-            Program::MemoryAddress lhs;
-            Program::MemoryAddress rhs;
-            Program::MemoryAddress output;
-
-            friend bool operator==(const BigIntDiv&, const BigIntDiv&);
+        struct Sub {
+            friend bool operator==(const Sub&, const Sub&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntDiv bincodeDeserialize(std::vector<uint8_t>);
+            static Sub bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntFromLeBytes {
-            Program::HeapVector inputs;
-            Program::HeapVector modulus;
-            Program::MemoryAddress output;
-
-            friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
+        struct Mul {
+            friend bool operator==(const Mul&, const Mul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntFromLeBytes bincodeDeserialize(std::vector<uint8_t>);
+            static Mul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntToLeBytes {
-            Program::MemoryAddress input;
-            Program::HeapVector output;
-
-            friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
+        struct Div {
+            friend bool operator==(const Div&, const Div&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntToLeBytes bincodeDeserialize(std::vector<uint8_t>);
+            static Div bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Poseidon2Permutation {
-            Program::HeapVector message;
-            Program::HeapArray output;
-            Program::MemoryAddress len;
-
-            friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
+        struct Equals {
+            friend bool operator==(const Equals&, const Equals&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Poseidon2Permutation bincodeDeserialize(std::vector<uint8_t>);
+            static Equals bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Sha256Compression {
-            Program::HeapVector input;
-            Program::HeapVector hash_values;
-            Program::HeapArray output;
-
-            friend bool operator==(const Sha256Compression&, const Sha256Compression&);
+        struct LessThan {
+            friend bool operator==(const LessThan&, const LessThan&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
+            static LessThan bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
-
-        friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BlackBoxOp bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct HeapValueType;
-
-    struct HeapValueType {
+        struct LessThanEquals {
+            friend bool operator==(const LessThanEquals&, const LessThanEquals&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static LessThanEquals bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-        struct Simple {
-            friend bool operator==(const Simple&, const Simple&);
+        struct And {
+            friend bool operator==(const And&, const And&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Simple bincodeDeserialize(std::vector<uint8_t>);
+            static And bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Array {
-            std::vector<Program::HeapValueType> value_types;
-            uint64_t size;
+        struct Or {
+            friend bool operator==(const Or&, const Or&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Or bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-            friend bool operator==(const Array&, const Array&);
+        struct Xor {
+            friend bool operator==(const Xor&, const Xor&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Array bincodeDeserialize(std::vector<uint8_t>);
+            static Xor bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Vector {
-            std::vector<Program::HeapValueType> value_types;
+        struct Shl {
+            friend bool operator==(const Shl&, const Shl&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Shl bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-            friend bool operator==(const Vector&, const Vector&);
+        struct Shr {
+            friend bool operator==(const Shr&, const Shr&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Vector bincodeDeserialize(std::vector<uint8_t>);
+            static Shr bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Simple, Array, Vector> value;
+        std::variant<Add, Sub, Mul, Div, Equals, LessThan, LessThanEquals, And, Or, Xor, Shl, Shr> value;
 
-        friend bool operator==(const HeapValueType&, const HeapValueType&);
+        friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static HeapValueType bincodeDeserialize(std::vector<uint8_t>);
+        static BinaryIntOp bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct Value {
-        std::string inner;
+    struct MemoryAddress {
+        uint64_t value;
 
-        friend bool operator==(const Value&, const Value&);
+        friend bool operator==(const MemoryAddress&, const MemoryAddress&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static Value bincodeDeserialize(std::vector<uint8_t>);
+        static MemoryAddress bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct ValueOrArray {
+    struct HeapArray {
+        Program::MemoryAddress pointer;
+        uint64_t size;
 
-        struct MemoryAddress {
-            Program::MemoryAddress value;
+        friend bool operator==(const HeapArray&, const HeapArray&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static HeapArray bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-            friend bool operator==(const MemoryAddress&, const MemoryAddress&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static MemoryAddress bincodeDeserialize(std::vector<uint8_t>);
-        };
+    struct HeapVector {
+        Program::MemoryAddress pointer;
+        Program::MemoryAddress size;
 
-        struct HeapArray {
-            Program::HeapArray value;
+        friend bool operator==(const HeapVector&, const HeapVector&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static HeapVector bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-            friend bool operator==(const HeapArray&, const HeapArray&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static HeapArray bincodeDeserialize(std::vector<uint8_t>);
-        };
+    struct BlackBoxOp {
 
-        struct HeapVector {
-            Program::HeapVector value;
+        struct Sha256 {
+            Program::HeapVector message;
+            Program::HeapArray output;
 
-            friend bool operator==(const HeapVector&, const HeapVector&);
+            friend bool operator==(const Sha256&, const Sha256&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static HeapVector bincodeDeserialize(std::vector<uint8_t>);
+            static Sha256 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<MemoryAddress, HeapArray, HeapVector> value;
-
-        friend bool operator==(const ValueOrArray&, const ValueOrArray&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static ValueOrArray bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct BrilligOpcode {
-
-        struct BinaryFieldOp {
-            Program::MemoryAddress destination;
-            Program::BinaryFieldOp op;
-            Program::MemoryAddress lhs;
-            Program::MemoryAddress rhs;
+        struct Blake2s {
+            Program::HeapVector message;
+            Program::HeapArray output;
 
-            friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
+            friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BinaryFieldOp bincodeDeserialize(std::vector<uint8_t>);
+            static Blake2s bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BinaryIntOp {
-            Program::MemoryAddress destination;
-            Program::BinaryIntOp op;
-            uint32_t bit_size;
-            Program::MemoryAddress lhs;
-            Program::MemoryAddress rhs;
+        struct Blake3 {
+            Program::HeapVector message;
+            Program::HeapArray output;
 
-            friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
+            friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BinaryIntOp bincodeDeserialize(std::vector<uint8_t>);
+            static Blake3 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Cast {
-            Program::MemoryAddress destination;
-            Program::MemoryAddress source;
-            uint32_t bit_size;
+        struct Keccak256 {
+            Program::HeapVector message;
+            Program::HeapArray output;
 
-            friend bool operator==(const Cast&, const Cast&);
+            friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Cast bincodeDeserialize(std::vector<uint8_t>);
+            static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct JumpIfNot {
-            Program::MemoryAddress condition;
-            uint64_t location;
+        struct Keccakf1600 {
+            Program::HeapVector message;
+            Program::HeapArray output;
 
-            friend bool operator==(const JumpIfNot&, const JumpIfNot&);
+            friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static JumpIfNot bincodeDeserialize(std::vector<uint8_t>);
+            static Keccakf1600 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct JumpIf {
-            Program::MemoryAddress condition;
-            uint64_t location;
+        struct EcdsaSecp256k1 {
+            Program::HeapVector hashed_msg;
+            Program::HeapArray public_key_x;
+            Program::HeapArray public_key_y;
+            Program::HeapArray signature;
+            Program::MemoryAddress result;
 
-            friend bool operator==(const JumpIf&, const JumpIf&);
+            friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static JumpIf bincodeDeserialize(std::vector<uint8_t>);
+            static EcdsaSecp256k1 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Jump {
-            uint64_t location;
+        struct EcdsaSecp256r1 {
+            Program::HeapVector hashed_msg;
+            Program::HeapArray public_key_x;
+            Program::HeapArray public_key_y;
+            Program::HeapArray signature;
+            Program::MemoryAddress result;
 
-            friend bool operator==(const Jump&, const Jump&);
+            friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Jump bincodeDeserialize(std::vector<uint8_t>);
+            static EcdsaSecp256r1 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct CalldataCopy {
-            Program::MemoryAddress destination_address;
-            uint64_t size;
-            uint64_t offset;
+        struct SchnorrVerify {
+            Program::MemoryAddress public_key_x;
+            Program::MemoryAddress public_key_y;
+            Program::HeapVector message;
+            Program::HeapVector signature;
+            Program::MemoryAddress result;
 
-            friend bool operator==(const CalldataCopy&, const CalldataCopy&);
+            friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static CalldataCopy bincodeDeserialize(std::vector<uint8_t>);
+            static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Call {
-            uint64_t location;
+        struct PedersenCommitment {
+            Program::HeapVector inputs;
+            Program::MemoryAddress domain_separator;
+            Program::HeapArray output;
 
-            friend bool operator==(const Call&, const Call&);
+            friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Call bincodeDeserialize(std::vector<uint8_t>);
+            static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Const {
-            Program::MemoryAddress destination;
-            uint32_t bit_size;
-            Program::Value value;
+        struct PedersenHash {
+            Program::HeapVector inputs;
+            Program::MemoryAddress domain_separator;
+            Program::MemoryAddress output;
 
-            friend bool operator==(const Const&, const Const&);
+            friend bool operator==(const PedersenHash&, const PedersenHash&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Const bincodeDeserialize(std::vector<uint8_t>);
+            static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Return {
-            friend bool operator==(const Return&, const Return&);
+        struct FixedBaseScalarMul {
+            Program::MemoryAddress low;
+            Program::MemoryAddress high;
+            Program::HeapArray result;
+
+            friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Return bincodeDeserialize(std::vector<uint8_t>);
+            static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct ForeignCall {
-            std::string function;
-            std::vector<Program::ValueOrArray> destinations;
-            std::vector<Program::HeapValueType> destination_value_types;
-            std::vector<Program::ValueOrArray> inputs;
-            std::vector<Program::HeapValueType> input_value_types;
+        struct EmbeddedCurveAdd {
+            Program::MemoryAddress input1_x;
+            Program::MemoryAddress input1_y;
+            Program::MemoryAddress input2_x;
+            Program::MemoryAddress input2_y;
+            Program::HeapArray result;
 
-            friend bool operator==(const ForeignCall&, const ForeignCall&);
+            friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static ForeignCall bincodeDeserialize(std::vector<uint8_t>);
+            static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Mov {
-            Program::MemoryAddress destination;
-            Program::MemoryAddress source;
+        struct BigIntAdd {
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
-            friend bool operator==(const Mov&, const Mov&);
+            friend bool operator==(const BigIntAdd&, const BigIntAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Mov bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct ConditionalMov {
-            Program::MemoryAddress destination;
-            Program::MemoryAddress source_a;
-            Program::MemoryAddress source_b;
-            Program::MemoryAddress condition;
+        struct BigIntSub {
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
-            friend bool operator==(const ConditionalMov&, const ConditionalMov&);
+            friend bool operator==(const BigIntSub&, const BigIntSub&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static ConditionalMov bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Load {
-            Program::MemoryAddress destination;
-            Program::MemoryAddress source_pointer;
+        struct BigIntMul {
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
-            friend bool operator==(const Load&, const Load&);
+            friend bool operator==(const BigIntMul&, const BigIntMul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Load bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntMul bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Store {
-            Program::MemoryAddress destination_pointer;
-            Program::MemoryAddress source;
+        struct BigIntDiv {
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
-            friend bool operator==(const Store&, const Store&);
+            friend bool operator==(const BigIntDiv&, const BigIntDiv&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Store bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntDiv bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BlackBox {
-            Program::BlackBoxOp value;
+        struct BigIntFromLeBytes {
+            Program::HeapVector inputs;
+            Program::HeapVector modulus;
+            Program::MemoryAddress output;
 
-            friend bool operator==(const BlackBox&, const BlackBox&);
+            friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BlackBox bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntFromLeBytes bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Trap {
-            friend bool operator==(const Trap&, const Trap&);
+        struct BigIntToLeBytes {
+            Program::MemoryAddress input;
+            Program::HeapVector output;
+
+            friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Trap bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntToLeBytes bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Stop {
-            uint64_t return_data_offset;
-            uint64_t return_data_size;
+        struct Poseidon2Permutation {
+            Program::HeapVector message;
+            Program::HeapArray output;
+            Program::MemoryAddress len;
 
-            friend bool operator==(const Stop&, const Stop&);
+            friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Stop bincodeDeserialize(std::vector<uint8_t>);
+            static Poseidon2Permutation bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, ConditionalMov, Load, Store, BlackBox, Trap, Stop> value;
+        struct Sha256Compression {
+            Program::HeapVector input;
+            Program::HeapVector hash_values;
+            Program::HeapArray output;
 
-        friend bool operator==(const BrilligOpcode&, const BrilligOpcode&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BrilligOpcode bincodeDeserialize(std::vector<uint8_t>);
-    };
+            friend bool operator==(const Sha256Compression&, const Sha256Compression&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
+        };
 
-    struct Witness {
-        uint32_t value;
+        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
-        friend bool operator==(const Witness&, const Witness&);
+        friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static Witness bincodeDeserialize(std::vector<uint8_t>);
+        static BlackBoxOp bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct FunctionInput {
-        Program::Witness witness;
-        uint32_t num_bits;
-
-        friend bool operator==(const FunctionInput&, const FunctionInput&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static FunctionInput bincodeDeserialize(std::vector<uint8_t>);
-    };
+    struct HeapValueType;
 
-    struct BlackBoxFuncCall {
+    struct HeapValueType {
 
-        struct AND {
-            Program::FunctionInput lhs;
-            Program::FunctionInput rhs;
-            Program::Witness output;
+        struct Simple {
+            uint32_t value;
 
-            friend bool operator==(const AND&, const AND&);
+            friend bool operator==(const Simple&, const Simple&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static AND bincodeDeserialize(std::vector<uint8_t>);
+            static Simple bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct XOR {
-            Program::FunctionInput lhs;
-            Program::FunctionInput rhs;
-            Program::Witness output;
+        struct Array {
+            std::vector<Program::HeapValueType> value_types;
+            uint64_t size;
 
-            friend bool operator==(const XOR&, const XOR&);
+            friend bool operator==(const Array&, const Array&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static XOR bincodeDeserialize(std::vector<uint8_t>);
+            static Array bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct RANGE {
-            Program::FunctionInput input;
+        struct Vector {
+            std::vector<Program::HeapValueType> value_types;
 
-            friend bool operator==(const RANGE&, const RANGE&);
+            friend bool operator==(const Vector&, const Vector&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static RANGE bincodeDeserialize(std::vector<uint8_t>);
+            static Vector bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct SHA256 {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
-
-            friend bool operator==(const SHA256&, const SHA256&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static SHA256 bincodeDeserialize(std::vector<uint8_t>);
-        };
+        std::variant<Simple, Array, Vector> value;
 
-        struct Blake2s {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+        friend bool operator==(const HeapValueType&, const HeapValueType&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static HeapValueType bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-            friend bool operator==(const Blake2s&, const Blake2s&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Blake2s bincodeDeserialize(std::vector<uint8_t>);
-        };
+    struct ValueOrArray {
 
-        struct Blake3 {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+        struct MemoryAddress {
+            Program::MemoryAddress value;
 
-            friend bool operator==(const Blake3&, const Blake3&);
+            friend bool operator==(const MemoryAddress&, const MemoryAddress&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Blake3 bincodeDeserialize(std::vector<uint8_t>);
+            static MemoryAddress bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct SchnorrVerify {
-            Program::FunctionInput public_key_x;
-            Program::FunctionInput public_key_y;
-            std::vector<Program::FunctionInput> signature;
-            std::vector<Program::FunctionInput> message;
-            Program::Witness output;
+        struct HeapArray {
+            Program::HeapArray value;
 
-            friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
+            friend bool operator==(const HeapArray&, const HeapArray&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
+            static HeapArray bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct PedersenCommitment {
-            std::vector<Program::FunctionInput> inputs;
-            uint32_t domain_separator;
-            std::array<Program::Witness, 2> outputs;
+        struct HeapVector {
+            Program::HeapVector value;
 
-            friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
+            friend bool operator==(const HeapVector&, const HeapVector&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
+            static HeapVector bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct PedersenHash {
-            std::vector<Program::FunctionInput> inputs;
-            uint32_t domain_separator;
-            Program::Witness output;
-
-            friend bool operator==(const PedersenHash&, const PedersenHash&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
-        };
+        std::variant<MemoryAddress, HeapArray, HeapVector> value;
 
-        struct EcdsaSecp256k1 {
-            std::vector<Program::FunctionInput> public_key_x;
-            std::vector<Program::FunctionInput> public_key_y;
-            std::vector<Program::FunctionInput> signature;
-            std::vector<Program::FunctionInput> hashed_message;
-            Program::Witness output;
+        friend bool operator==(const ValueOrArray&, const ValueOrArray&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static ValueOrArray bincodeDeserialize(std::vector<uint8_t>);
+    };
 
-            friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static EcdsaSecp256k1 bincodeDeserialize(std::vector<uint8_t>);
-        };
+    struct BrilligOpcode {
 
-        struct EcdsaSecp256r1 {
-            std::vector<Program::FunctionInput> public_key_x;
-            std::vector<Program::FunctionInput> public_key_y;
-            std::vector<Program::FunctionInput> signature;
-            std::vector<Program::FunctionInput> hashed_message;
-            Program::Witness output;
+        struct BinaryFieldOp {
+            Program::MemoryAddress destination;
+            Program::BinaryFieldOp op;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
 
-            friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
+            friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static EcdsaSecp256r1 bincodeDeserialize(std::vector<uint8_t>);
+            static BinaryFieldOp bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct FixedBaseScalarMul {
-            Program::FunctionInput low;
-            Program::FunctionInput high;
-            std::array<Program::Witness, 2> outputs;
+        struct BinaryIntOp {
+            Program::MemoryAddress destination;
+            Program::BinaryIntOp op;
+            uint32_t bit_size;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
 
-            friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
+            friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
+            static BinaryIntOp bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct EmbeddedCurveAdd {
-            Program::FunctionInput input1_x;
-            Program::FunctionInput input1_y;
-            Program::FunctionInput input2_x;
-            Program::FunctionInput input2_y;
-            std::array<Program::Witness, 2> outputs;
+        struct Cast {
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source;
+            uint32_t bit_size;
 
-            friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
+            friend bool operator==(const Cast&, const Cast&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
+            static Cast bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccak256 {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+        struct JumpIfNot {
+            Program::MemoryAddress condition;
+            uint64_t location;
 
-            friend bool operator==(const Keccak256&, const Keccak256&);
+            friend bool operator==(const JumpIfNot&, const JumpIfNot&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
+            static JumpIfNot bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccak256VariableLength {
-            std::vector<Program::FunctionInput> inputs;
-            Program::FunctionInput var_message_size;
-            std::vector<Program::Witness> outputs;
+        struct JumpIf {
+            Program::MemoryAddress condition;
+            uint64_t location;
 
-            friend bool operator==(const Keccak256VariableLength&, const Keccak256VariableLength&);
+            friend bool operator==(const JumpIf&, const JumpIf&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Keccak256VariableLength bincodeDeserialize(std::vector<uint8_t>);
+            static JumpIf bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccakf1600 {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+        struct Jump {
+            uint64_t location;
 
-            friend bool operator==(const Keccakf1600&, const Keccakf1600&);
+            friend bool operator==(const Jump&, const Jump&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Keccakf1600 bincodeDeserialize(std::vector<uint8_t>);
+            static Jump bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct RecursiveAggregation {
-            std::vector<Program::FunctionInput> verification_key;
-            std::vector<Program::FunctionInput> proof;
-            std::vector<Program::FunctionInput> public_inputs;
-            Program::FunctionInput key_hash;
+        struct CalldataCopy {
+            Program::MemoryAddress destination_address;
+            uint64_t size;
+            uint64_t offset;
 
-            friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&);
+            friend bool operator==(const CalldataCopy&, const CalldataCopy&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static RecursiveAggregation bincodeDeserialize(std::vector<uint8_t>);
+            static CalldataCopy bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntAdd {
-            uint32_t lhs;
-            uint32_t rhs;
-            uint32_t output;
+        struct Call {
+            uint64_t location;
 
-            friend bool operator==(const BigIntAdd&, const BigIntAdd&);
+            friend bool operator==(const Call&, const Call&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
+            static Call bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntSub {
-            uint32_t lhs;
-            uint32_t rhs;
-            uint32_t output;
+        struct Const {
+            Program::MemoryAddress destination;
+            uint32_t bit_size;
+            std::string value;
 
-            friend bool operator==(const BigIntSub&, const BigIntSub&);
+            friend bool operator==(const Const&, const Const&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
+            static Const bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntMul {
-            uint32_t lhs;
-            uint32_t rhs;
-            uint32_t output;
-
-            friend bool operator==(const BigIntMul&, const BigIntMul&);
+        struct Return {
+            friend bool operator==(const Return&, const Return&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntMul bincodeDeserialize(std::vector<uint8_t>);
+            static Return bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntDiv {
-            uint32_t lhs;
-            uint32_t rhs;
-            uint32_t output;
+        struct ForeignCall {
+            std::string function;
+            std::vector<Program::ValueOrArray> destinations;
+            std::vector<Program::HeapValueType> destination_value_types;
+            std::vector<Program::ValueOrArray> inputs;
+            std::vector<Program::HeapValueType> input_value_types;
 
-            friend bool operator==(const BigIntDiv&, const BigIntDiv&);
+            friend bool operator==(const ForeignCall&, const ForeignCall&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntDiv bincodeDeserialize(std::vector<uint8_t>);
+            static ForeignCall bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntFromLeBytes {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<uint8_t> modulus;
-            uint32_t output;
+        struct Mov {
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source;
 
-            friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
+            friend bool operator==(const Mov&, const Mov&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntFromLeBytes bincodeDeserialize(std::vector<uint8_t>);
+            static Mov bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntToLeBytes {
-            uint32_t input;
-            std::vector<Program::Witness> outputs;
+        struct ConditionalMov {
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source_a;
+            Program::MemoryAddress source_b;
+            Program::MemoryAddress condition;
 
-            friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
+            friend bool operator==(const ConditionalMov&, const ConditionalMov&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntToLeBytes bincodeDeserialize(std::vector<uint8_t>);
+            static ConditionalMov bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Poseidon2Permutation {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
-            uint32_t len;
+        struct Load {
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source_pointer;
 
-            friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
+            friend bool operator==(const Load&, const Load&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Poseidon2Permutation bincodeDeserialize(std::vector<uint8_t>);
+            static Load bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Sha256Compression {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::FunctionInput> hash_values;
-            std::vector<Program::Witness> outputs;
+        struct Store {
+            Program::MemoryAddress destination_pointer;
+            Program::MemoryAddress source;
 
-            friend bool operator==(const Sha256Compression&, const Sha256Compression&);
+            friend bool operator==(const Store&, const Store&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
+            static Store bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
-
-        friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BlackBoxFuncCall bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct BlockId {
-        uint32_t value;
-
-        friend bool operator==(const BlockId&, const BlockId&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BlockId bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct Expression {
-        std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
-        std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
-        std::string q_c;
-
-        friend bool operator==(const Expression&, const Expression&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static Expression bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct BrilligInputs {
-
-        struct Single {
-            Program::Expression value;
+        struct BlackBox {
+            Program::BlackBoxOp value;
 
-            friend bool operator==(const Single&, const Single&);
+            friend bool operator==(const BlackBox&, const BlackBox&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Single bincodeDeserialize(std::vector<uint8_t>);
+            static BlackBox bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Array {
-            std::vector<Program::Expression> value;
-
-            friend bool operator==(const Array&, const Array&);
+        struct Trap {
+            friend bool operator==(const Trap&, const Trap&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Array bincodeDeserialize(std::vector<uint8_t>);
+            static Trap bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct MemoryArray {
-            Program::BlockId value;
+        struct Stop {
+            uint64_t return_data_offset;
+            uint64_t return_data_size;
 
-            friend bool operator==(const MemoryArray&, const MemoryArray&);
+            friend bool operator==(const Stop&, const Stop&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static MemoryArray bincodeDeserialize(std::vector<uint8_t>);
+            static Stop bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Single, Array, MemoryArray> value;
+        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, ConditionalMov, Load, Store, BlackBox, Trap, Stop> value;
 
-        friend bool operator==(const BrilligInputs&, const BrilligInputs&);
+        friend bool operator==(const BrilligOpcode&, const BrilligOpcode&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static BrilligInputs bincodeDeserialize(std::vector<uint8_t>);
+        static BrilligOpcode bincodeDeserialize(std::vector<uint8_t>);
     };
 
     struct BrilligOutputs {
@@ -5645,6 +5639,7 @@ Program::HeapValueType serde::Deserializable<Program::HeapValueType>::deserializ
 namespace Program {
 
     inline bool operator==(const HeapValueType::Simple &lhs, const HeapValueType::Simple &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
         return true;
     }
 
@@ -5668,12 +5663,14 @@ namespace Program {
 template <>
 template <typename Serializer>
 void serde::Serializable<Program::HeapValueType::Simple>::serialize(const Program::HeapValueType::Simple &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
 Program::HeapValueType::Simple serde::Deserializable<Program::HeapValueType::Simple>::deserialize(Deserializer &deserializer) {
     Program::HeapValueType::Simple obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
@@ -6419,48 +6416,6 @@ Program::PublicInputs serde::Deserializable<Program::PublicInputs>::deserialize(
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const Value &lhs, const Value &rhs) {
-        if (!(lhs.inner == rhs.inner)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> Value::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Value>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline Value Value::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Value>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::Value>::serialize(const Program::Value &obj, Serializer &serializer) {
-    serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.inner)>::serialize(obj.inner, serializer);
-    serializer.decrease_container_depth();
-}
-
-template <>
-template <typename Deserializer>
-Program::Value serde::Deserializable<Program::Value>::deserialize(Deserializer &deserializer) {
-    deserializer.increase_container_depth();
-    Program::Value obj;
-    obj.inner = serde::Deserializable<decltype(obj.inner)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) {
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 64385a37582..8b04292dfaa 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -190,9 +190,9 @@ fn simple_brillig_foreign_call() {
             brillig::Opcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
             brillig::Opcode::Stop { return_data_offset: 0, return_data_size: 1 },
         ],
@@ -211,11 +211,11 @@ fn simple_brillig_foreign_call() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 65, 10, 192, 32, 12, 4, 77, 10, 165, 244, 214,
-        159, 216, 31, 244, 51, 61, 120, 241, 32, 226, 251, 85, 140, 176, 136, 122, 209, 129, 144,
-        176, 9, 97, 151, 84, 225, 74, 69, 50, 31, 48, 35, 85, 251, 164, 235, 53, 94, 218, 247, 75,
-        163, 95, 150, 12, 153, 179, 227, 191, 114, 195, 222, 216, 240, 59, 63, 75, 221, 251, 208,
-        106, 207, 232, 150, 65, 100, 53, 33, 2, 22, 232, 178, 27, 144, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 48, 8, 133, 53, 133, 82, 186,
+        245, 38, 233, 13, 122, 153, 14, 93, 58, 132, 144, 227, 135, 252, 41, 56, 36, 46, 201, 7,
+        162, 168, 200, 123, 34, 52, 142, 28, 72, 245, 38, 106, 9, 247, 30, 202, 118, 142, 27, 215,
+        221, 178, 82, 175, 33, 15, 133, 189, 163, 159, 57, 197, 252, 251, 195, 235, 188, 230, 186,
+        16, 65, 255, 12, 239, 92, 131, 89, 149, 198, 77, 3, 10, 9, 119, 8, 198, 242, 152, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -264,8 +264,8 @@ fn complex_brillig_foreign_call() {
             },
             brillig::Opcode::Const {
                 destination: MemoryAddress(0),
-                value: brillig::Value::from(32_usize),
-                bit_size: 32,
+                value: FieldElement::from(32_usize),
+                bit_size: 64,
             },
             brillig::Opcode::CalldataCopy {
                 destination_address: MemoryAddress(1),
@@ -280,8 +280,8 @@ fn complex_brillig_foreign_call() {
                     ValueOrArray::MemoryAddress(MemoryAddress::from(1)),
                 ],
                 input_value_types: vec![
-                    HeapValueType::Array { size: 3, value_types: vec![HeapValueType::Simple] },
-                    HeapValueType::Simple,
+                    HeapValueType::Array { size: 3, value_types: vec![HeapValueType::field()] },
+                    HeapValueType::field(),
                 ],
                 destinations: vec![
                     ValueOrArray::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
@@ -289,9 +289,9 @@ fn complex_brillig_foreign_call() {
                     ValueOrArray::MemoryAddress(MemoryAddress::from(36)),
                 ],
                 destination_value_types: vec![
-                    HeapValueType::Array { size: 3, value_types: vec![HeapValueType::Simple] },
-                    HeapValueType::Simple,
-                    HeapValueType::Simple,
+                    HeapValueType::Array { size: 3, value_types: vec![HeapValueType::field()] },
+                    HeapValueType::field(),
+                    HeapValueType::field(),
                 ],
             },
             brillig::Opcode::Stop { return_data_offset: 32, return_data_size: 5 },
@@ -311,15 +311,15 @@ fn complex_brillig_foreign_call() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 65, 14, 132, 32, 12, 108, 101, 117, 205, 222,
-        246, 7, 38, 187, 15, 96, 247, 5, 254, 197, 120, 211, 232, 209, 231, 139, 113, 136, 181, 65,
-        47, 98, 162, 147, 52, 20, 24, 202, 164, 45, 48, 205, 200, 157, 49, 124, 227, 44, 129, 207,
-        152, 75, 120, 94, 137, 209, 30, 195, 143, 227, 197, 178, 103, 105, 76, 110, 160, 209, 156,
-        160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 97,
-        254, 196, 152, 99, 157, 176, 87, 168, 188, 147, 224, 121, 20, 209, 180, 254, 109, 70, 75,
-        47, 178, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96, 20, 85, 75, 253, 8, 255, 171, 246,
-        121, 231, 220, 4, 249, 237, 132, 56, 28, 224, 109, 113, 223, 180, 164, 50, 165, 0, 137, 17,
-        72, 139, 88, 97, 4, 173, 98, 132, 157, 33, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 93, 10, 131, 48, 12, 78, 218, 233, 100, 111,
+        187, 193, 96, 59, 64, 231, 9, 188, 139, 248, 166, 232, 163, 167, 23, 11, 126, 197, 24, 250,
+        34, 86, 208, 64, 72, 218, 252, 125, 36, 105, 153, 22, 42, 60, 51, 116, 235, 217, 64, 103,
+        156, 37, 5, 191, 10, 210, 29, 163, 63, 167, 203, 229, 206, 194, 104, 110, 128, 209, 158,
+        128, 49, 236, 195, 69, 231, 157, 114, 46, 73, 251, 103, 35, 239, 231, 225, 57, 243, 156,
+        227, 252, 132, 44, 112, 79, 176, 125, 84, 223, 73, 248, 145, 152, 69, 149, 4, 107, 233,
+        114, 90, 119, 145, 85, 237, 151, 192, 89, 247, 221, 208, 54, 163, 85, 174, 26, 234, 87,
+        232, 63, 101, 103, 21, 55, 169, 216, 73, 72, 249, 5, 197, 234, 132, 123, 179, 35, 247, 155,
+        214, 246, 102, 20, 73, 204, 72, 168, 123, 191, 161, 25, 66, 136, 159, 187, 53, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index 51c7f4c6203..bcf736cd926 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use acir::{
-    brillig::{ForeignCallParam, ForeignCallResult, Value},
+    brillig::{ForeignCallParam, ForeignCallResult},
     circuit::{
         brillig::{Brillig, BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
@@ -11,7 +11,7 @@ use acir::{
     FieldElement,
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
-use brillig_vm::{VMStatus, VM};
+use brillig_vm::{MemoryValue, VMStatus, VM};
 
 use crate::{pwg::OpcodeNotSolvable, OpcodeResolutionError};
 
@@ -73,7 +73,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         acir_index: usize,
     ) -> Result<Self, OpcodeResolutionError> {
         // Set input values
-        let mut calldata: Vec<Value> = Vec::new();
+        let mut calldata: Vec<FieldElement> = Vec::new();
         // Each input represents an expression or array of expressions to evaluate.
         // Iterate over each input and evaluate the expression(s) associated with it.
         // Push the results into memory.
@@ -81,7 +81,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         for input in &brillig.inputs {
             match input {
                 BrilligInputs::Single(expr) => match get_value(expr, initial_witness) {
-                    Ok(value) => calldata.push(value.into()),
+                    Ok(value) => calldata.push(value),
                     Err(_) => {
                         return Err(OpcodeResolutionError::OpcodeNotSolvable(
                             OpcodeNotSolvable::ExpressionHasTooManyUnknowns(expr.clone()),
@@ -92,7 +92,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
                     // Attempt to fetch all array input values
                     for expr in expr_arr.iter() {
                         match get_value(expr, initial_witness) {
-                            Ok(value) => calldata.push(value.into()),
+                            Ok(value) => calldata.push(value),
                             Err(_) => {
                                 return Err(OpcodeResolutionError::OpcodeNotSolvable(
                                     OpcodeNotSolvable::ExpressionHasTooManyUnknowns(expr.clone()),
@@ -110,7 +110,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
                             .block_value
                             .get(&memory_index)
                             .expect("All memory is initialized on creation");
-                        calldata.push((*memory_value).into());
+                        calldata.push(*memory_value);
                     }
                 }
             }
@@ -122,11 +122,11 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         Ok(Self { vm, acir_index })
     }
 
-    pub fn get_memory(&self) -> &[Value] {
+    pub fn get_memory(&self) -> &[MemoryValue] {
         self.vm.get_memory()
     }
 
-    pub fn write_memory_at(&mut self, ptr: usize, value: Value) {
+    pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue) {
         self.vm.write_memory_at(ptr, value);
     }
 
@@ -206,13 +206,13 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         for output in brillig.outputs.iter() {
             match output {
                 BrilligOutputs::Simple(witness) => {
-                    insert_value(witness, memory[current_ret_data_idx].to_field(), witness_map)?;
+                    insert_value(witness, memory[current_ret_data_idx].value, witness_map)?;
                     current_ret_data_idx += 1;
                 }
                 BrilligOutputs::Array(witness_arr) => {
                     for witness in witness_arr.iter() {
                         let value = memory[current_ret_data_idx];
-                        insert_value(witness, value.to_field(), witness_map)?;
+                        insert_value(witness, value.value, witness_map)?;
                         current_ret_data_idx += 1;
                     }
                 }
diff --git a/acvm-repo/acvm/tests/solver.rs b/acvm-repo/acvm/tests/solver.rs
index b267c3005a8..a708db5b030 100644
--- a/acvm-repo/acvm/tests/solver.rs
+++ b/acvm-repo/acvm/tests/solver.rs
@@ -1,7 +1,7 @@
 use std::collections::BTreeMap;
 
 use acir::{
-    brillig::{BinaryFieldOp, MemoryAddress, Opcode as BrilligOpcode, Value, ValueOrArray},
+    brillig::{BinaryFieldOp, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
     circuit::{
         brillig::{Brillig, BrilligInputs, BrilligOutputs},
         opcodes::{BlockId, MemOp},
@@ -70,9 +70,9 @@ fn inversion_brillig_oracle_equivalence() {
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 3 },
         ],
@@ -120,8 +120,7 @@ fn inversion_brillig_oracle_equivalence() {
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
     // As caller of VM, need to resolve foreign calls
-    let foreign_call_result =
-        Value::from(foreign_call_wait_info.inputs[0].unwrap_value().to_field().inverse());
+    let foreign_call_result = foreign_call_wait_info.inputs[0].unwrap_field().inverse();
     // Alter Brillig oracle opcode with foreign call resolution
     acvm.resolve_pending_foreign_call(foreign_call_result.into());
 
@@ -199,16 +198,16 @@ fn double_inversion_brillig_oracle() {
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(3))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(2))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 5 },
         ],
@@ -257,8 +256,7 @@ fn double_inversion_brillig_oracle() {
         acvm.get_pending_foreign_call().expect("should have a brillig foreign call request");
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
-    let x_plus_y_inverse =
-        Value::from(foreign_call_wait_info.inputs[0].unwrap_value().to_field().inverse());
+    let x_plus_y_inverse = foreign_call_wait_info.inputs[0].unwrap_field().inverse();
 
     // Resolve Brillig foreign call
     acvm.resolve_pending_foreign_call(x_plus_y_inverse.into());
@@ -275,8 +273,7 @@ fn double_inversion_brillig_oracle() {
         acvm.get_pending_foreign_call().expect("should have a brillig foreign call request");
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
-    let i_plus_j_inverse =
-        Value::from(foreign_call_wait_info.inputs[0].unwrap_value().to_field().inverse());
+    let i_plus_j_inverse = foreign_call_wait_info.inputs[0].unwrap_field().inverse();
     assert_ne!(x_plus_y_inverse, i_plus_j_inverse);
 
     // Alter Brillig oracle opcode
@@ -334,16 +331,16 @@ fn oracle_dependent_execution() {
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(3))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(2))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 4 },
         ],
@@ -389,8 +386,7 @@ fn oracle_dependent_execution() {
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
     // Resolve Brillig foreign call
-    let x_inverse =
-        Value::from(foreign_call_wait_info.inputs[0].unwrap_value().to_field().inverse());
+    let x_inverse = foreign_call_wait_info.inputs[0].unwrap_field().inverse();
     acvm.resolve_pending_foreign_call(x_inverse.into());
 
     // After filling data request, continue solving
@@ -406,8 +402,7 @@ fn oracle_dependent_execution() {
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
     // Resolve Brillig foreign call
-    let y_inverse =
-        Value::from(foreign_call_wait_info.inputs[0].unwrap_value().to_field().inverse());
+    let y_inverse = foreign_call_wait_info.inputs[0].unwrap_field().inverse();
     acvm.resolve_pending_foreign_call(y_inverse.into());
 
     // We've resolved all the brillig foreign calls so we should be able to complete execution now.
@@ -464,9 +459,9 @@ fn brillig_oracle_predicate() {
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::field()],
             },
         ],
         predicate: Some(Expression::default()),
diff --git a/acvm-repo/acvm_js/src/foreign_call/inputs.rs b/acvm-repo/acvm_js/src/foreign_call/inputs.rs
index 728fc2d3d2f..ebd29fb7d58 100644
--- a/acvm-repo/acvm_js/src/foreign_call/inputs.rs
+++ b/acvm-repo/acvm_js/src/foreign_call/inputs.rs
@@ -8,8 +8,8 @@ pub(super) fn encode_foreign_call_inputs(
     let inputs = js_sys::Array::default();
     for input in foreign_call_inputs {
         let input_array = js_sys::Array::default();
-        for value in input.values() {
-            let hex_js_string = field_element_to_js_string(&value.to_field());
+        for value in input.fields() {
+            let hex_js_string = field_element_to_js_string(&value);
             input_array.push(&hex_js_string);
         }
         inputs.push(&input_array);
diff --git a/acvm-repo/acvm_js/src/foreign_call/outputs.rs b/acvm-repo/acvm_js/src/foreign_call/outputs.rs
index 630b1afb6fd..78fa520aa15 100644
--- a/acvm-repo/acvm_js/src/foreign_call/outputs.rs
+++ b/acvm-repo/acvm_js/src/foreign_call/outputs.rs
@@ -1,18 +1,18 @@
-use acvm::brillig_vm::brillig::{ForeignCallParam, ForeignCallResult, Value};
+use acvm::brillig_vm::brillig::{ForeignCallParam, ForeignCallResult};
 use wasm_bindgen::JsValue;
 
 use crate::js_witness_map::js_value_to_field_element;
 
 fn decode_foreign_call_output(output: JsValue) -> Result<ForeignCallParam, String> {
     if output.is_string() {
-        let value = Value::from(js_value_to_field_element(output)?);
+        let value = js_value_to_field_element(output)?;
         Ok(ForeignCallParam::Single(value))
     } else if output.is_array() {
         let output = js_sys::Array::from(&output);
 
-        let mut values: Vec<Value> = Vec::with_capacity(output.length() as usize);
+        let mut values: Vec<_> = Vec::with_capacity(output.length() as usize);
         for elem in output.iter() {
-            values.push(Value::from(js_value_to_field_element(elem)?));
+            values.push(js_value_to_field_element(elem)?);
         }
         Ok(ForeignCallParam::Array(values))
     } else {
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index fba8470585f..e074cf1ad38 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 65, 14, 132, 32, 12, 108, 101, 117, 205, 222, 246, 7, 38, 187, 15, 96,
-  247, 5, 254, 197, 120, 211, 232, 209, 231, 139, 113, 136, 181, 65, 47, 98, 162, 147, 52, 20, 24, 202, 164, 45, 48,
-  205, 200, 157, 49, 124, 227, 44, 129, 207, 152, 75, 120, 94, 137, 209, 30, 195, 143, 227, 197, 178, 103, 105, 76, 110,
-  160, 209, 156, 160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 97, 254, 196,
-  152, 99, 157, 176, 87, 168, 188, 147, 224, 121, 20, 209, 180, 254, 109, 70, 75, 47, 178, 186, 251, 37, 116, 86, 93,
-  219, 55, 245, 96, 20, 85, 75, 253, 8, 255, 171, 246, 121, 231, 220, 4, 249, 237, 132, 56, 28, 224, 109, 113, 223, 180,
-  164, 50, 165, 0, 137, 17, 72, 139, 88, 97, 4, 173, 98, 132, 157, 33, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 93, 10, 131, 48, 12, 78, 218, 233, 100, 111, 187, 193, 96, 59, 64, 231, 9,
+  188, 139, 248, 166, 232, 163, 167, 23, 11, 126, 197, 24, 250, 34, 86, 208, 64, 72, 218, 252, 125, 36, 105, 153, 22,
+  42, 60, 51, 116, 235, 217, 64, 103, 156, 37, 5, 191, 10, 210, 29, 163, 63, 167, 203, 229, 206, 194, 104, 110, 128,
+  209, 158, 128, 49, 236, 195, 69, 231, 157, 114, 46, 73, 251, 103, 35, 239, 231, 225, 57, 243, 156, 227, 252, 132, 44,
+  112, 79, 176, 125, 84, 223, 73, 248, 145, 152, 69, 149, 4, 107, 233, 114, 90, 119, 145, 85, 237, 151, 192, 89, 247,
+  221, 208, 54, 163, 85, 174, 26, 234, 87, 232, 63, 101, 103, 21, 55, 169, 216, 73, 72, 249, 5, 197, 234, 132, 123, 179,
+  35, 247, 155, 214, 246, 102, 20, 73, 204, 72, 168, 123, 191, 161, 25, 66, 136, 159, 187, 53, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index dd010f0c5e5..eb14cb2e9f1 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,10 +2,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 65, 10, 192, 32, 12, 4, 77, 10, 165, 244, 214, 159, 216, 31, 244, 51, 61,
-  120, 241, 32, 226, 251, 85, 140, 176, 136, 122, 209, 129, 144, 176, 9, 97, 151, 84, 225, 74, 69, 50, 31, 48, 35, 85,
-  251, 164, 235, 53, 94, 218, 247, 75, 163, 95, 150, 12, 153, 179, 227, 191, 114, 195, 222, 216, 240, 59, 63, 75, 221,
-  251, 208, 106, 207, 232, 150, 65, 100, 53, 33, 2, 22, 232, 178, 27, 144, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 48, 8, 133, 53, 133, 82, 186, 245, 38, 233, 13, 122, 153,
+  14, 93, 58, 132, 144, 227, 135, 252, 41, 56, 36, 46, 201, 7, 162, 168, 200, 123, 34, 52, 142, 28, 72, 245, 38, 106, 9,
+  247, 30, 202, 118, 142, 27, 215, 221, 178, 82, 175, 33, 15, 133, 189, 163, 159, 57, 197, 252, 251, 195, 235, 188, 230,
+  186, 16, 65, 255, 12, 239, 92, 131, 89, 149, 198, 77, 3, 10, 9, 119, 8, 198, 242, 152, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/brillig/src/foreign_call.rs b/acvm-repo/brillig/src/foreign_call.rs
index 3f124a9a0a7..e547b99f0eb 100644
--- a/acvm-repo/brillig/src/foreign_call.rs
+++ b/acvm-repo/brillig/src/foreign_call.rs
@@ -1,34 +1,34 @@
-use crate::value::Value;
+use acir_field::FieldElement;
 use serde::{Deserialize, Serialize};
 
 /// Single output of a [foreign call][crate::Opcode::ForeignCall].
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 pub enum ForeignCallParam {
-    Single(Value),
-    Array(Vec<Value>),
+    Single(FieldElement),
+    Array(Vec<FieldElement>),
 }
 
-impl From<Value> for ForeignCallParam {
-    fn from(value: Value) -> Self {
+impl From<FieldElement> for ForeignCallParam {
+    fn from(value: FieldElement) -> Self {
         ForeignCallParam::Single(value)
     }
 }
 
-impl From<Vec<Value>> for ForeignCallParam {
-    fn from(values: Vec<Value>) -> Self {
+impl From<Vec<FieldElement>> for ForeignCallParam {
+    fn from(values: Vec<FieldElement>) -> Self {
         ForeignCallParam::Array(values)
     }
 }
 
 impl ForeignCallParam {
-    pub fn values(&self) -> Vec<Value> {
+    pub fn fields(&self) -> Vec<FieldElement> {
         match self {
             ForeignCallParam::Single(value) => vec![*value],
             ForeignCallParam::Array(values) => values.clone(),
         }
     }
 
-    pub fn unwrap_value(&self) -> Value {
+    pub fn unwrap_field(&self) -> FieldElement {
         match self {
             ForeignCallParam::Single(value) => *value,
             ForeignCallParam::Array(_) => panic!("Expected single value, found array"),
@@ -43,14 +43,14 @@ pub struct ForeignCallResult {
     pub values: Vec<ForeignCallParam>,
 }
 
-impl From<Value> for ForeignCallResult {
-    fn from(value: Value) -> Self {
+impl From<FieldElement> for ForeignCallResult {
+    fn from(value: FieldElement) -> Self {
         ForeignCallResult { values: vec![value.into()] }
     }
 }
 
-impl From<Vec<Value>> for ForeignCallResult {
-    fn from(values: Vec<Value>) -> Self {
+impl From<Vec<FieldElement>> for ForeignCallResult {
+    fn from(values: Vec<FieldElement>) -> Self {
         ForeignCallResult { values: vec![values.into()] }
     }
 }
diff --git a/acvm-repo/brillig/src/lib.rs b/acvm-repo/brillig/src/lib.rs
index 0661e794360..40f2e15acfe 100644
--- a/acvm-repo/brillig/src/lib.rs
+++ b/acvm-repo/brillig/src/lib.rs
@@ -13,7 +13,6 @@
 mod black_box;
 mod foreign_call;
 mod opcodes;
-mod value;
 
 pub use black_box::BlackBoxOp;
 pub use foreign_call::{ForeignCallParam, ForeignCallResult};
@@ -21,5 +20,3 @@ pub use opcodes::{
     BinaryFieldOp, BinaryIntOp, HeapArray, HeapValueType, HeapVector, MemoryAddress, ValueOrArray,
 };
 pub use opcodes::{BrilligOpcode as Opcode, Label};
-pub use value::Typ;
-pub use value::Value;
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index 22a0ebe1170..d1345351986 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -1,4 +1,5 @@
-use crate::{black_box::BlackBoxOp, Value};
+use crate::black_box::BlackBoxOp;
+use acir_field::FieldElement;
 use serde::{Deserialize, Serialize};
 
 pub type Label = usize;
@@ -22,8 +23,8 @@ impl From<usize> for MemoryAddress {
 /// Describes the memory layout for an array/vector element
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub enum HeapValueType {
-    // A single field element is enough to represent the value
-    Simple,
+    // A single field element is enough to represent the value with a given bit size
+    Simple(u32),
     // The value read should be interpreted as a pointer to a heap array, which
     // consists of a pointer to a slice of memory of size elements, and a
     // reference count
@@ -36,7 +37,11 @@ pub enum HeapValueType {
 
 impl HeapValueType {
     pub fn all_simple(types: &[HeapValueType]) -> bool {
-        types.iter().all(|typ| matches!(typ, HeapValueType::Simple))
+        types.iter().all(|typ| matches!(typ, HeapValueType::Simple(_)))
+    }
+
+    pub fn field() -> HeapValueType {
+        HeapValueType::Simple(FieldElement::max_num_bits())
     }
 }
 
@@ -131,7 +136,7 @@ pub enum BrilligOpcode {
     Const {
         destination: MemoryAddress,
         bit_size: u32,
-        value: Value,
+        value: FieldElement,
     },
     Return,
     /// Used to get data from an outside source.
diff --git a/acvm-repo/brillig/src/value.rs b/acvm-repo/brillig/src/value.rs
deleted file mode 100644
index 5a532cbc1a7..00000000000
--- a/acvm-repo/brillig/src/value.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use acir_field::FieldElement;
-use serde::{Deserialize, Serialize};
-use std::ops::{Add, Div, Mul, Neg, Sub};
-
-/// Types of values allowed in the VM
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
-pub enum Typ {
-    Field,
-    Unsigned { bit_size: u32 },
-    Signed { bit_size: u32 },
-}
-
-/// `Value` represents the base descriptor for a value in the VM.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct Value {
-    inner: FieldElement,
-}
-
-impl Value {
-    /// Returns `true` if the `Value` represents `zero`
-    pub fn is_zero(&self) -> bool {
-        self.inner.is_zero()
-    }
-
-    /// Converts `Value` into a `FieldElement`.
-    pub fn to_field(&self) -> FieldElement {
-        self.inner
-    }
-
-    /// Converts `Value` into a `u128`.
-    // TODO: Check what happens if `Value` cannot fit into a u128
-    pub fn to_u128(&self) -> u128 {
-        self.to_field().to_u128()
-    }
-
-    /// Converts `Value` into a u64 and then casts it into a usize.
-    /// Panics: If `Value` cannot fit into a u64 or `Value` does
-    //// not fit into a usize.
-    pub fn to_usize(&self) -> usize {
-        usize::try_from(self.inner.try_to_u64().expect("value does not fit into u64"))
-            .expect("value does not fit into usize")
-    }
-}
-
-impl From<usize> for Value {
-    fn from(value: usize) -> Self {
-        Value { inner: FieldElement::from(value as u128) }
-    }
-}
-
-impl From<u128> for Value {
-    fn from(value: u128) -> Self {
-        Value { inner: FieldElement::from(value) }
-    }
-}
-
-impl From<FieldElement> for Value {
-    fn from(value: FieldElement) -> Self {
-        Value { inner: value }
-    }
-}
-
-impl From<bool> for Value {
-    fn from(value: bool) -> Self {
-        Value { inner: FieldElement::from(value) }
-    }
-}
-
-impl Add for Value {
-    type Output = Value;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Value { inner: self.inner + rhs.inner }
-    }
-}
-impl Sub for Value {
-    type Output = Value;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Value { inner: self.inner - rhs.inner }
-    }
-}
-impl Mul for Value {
-    type Output = Value;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        Value { inner: self.inner * rhs.inner }
-    }
-}
-impl Div for Value {
-    type Output = Value;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        Value { inner: self.inner / rhs.inner }
-    }
-}
-impl Neg for Value {
-    type Output = Value;
-
-    fn neg(self) -> Self::Output {
-        Value { inner: -self.inner }
-    }
-}
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 32dabe6ecb0..95675469479 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -17,6 +17,7 @@ acir.workspace = true
 acvm_blackbox_solver.workspace = true
 num-bigint.workspace = true
 num-traits.workspace = true
+thiserror.workspace = true
 
 [features]
 default = ["bn254"]
diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
index 81103be582d..3d77982ffb1 100644
--- a/acvm-repo/brillig_vm/src/arithmetic.rs
+++ b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -3,56 +3,98 @@ use acir::FieldElement;
 use num_bigint::BigUint;
 use num_traits::{One, ToPrimitive, Zero};
 
-/// Evaluate a binary operation on two FieldElements and return the result as a FieldElement.
+use crate::memory::MemoryValue;
+
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum BrilligArithmeticError {
+    #[error("Bit size for lhs {lhs_bit_size} does not match op bit size {op_bit_size}")]
+    MismatchedLhsBitSize { lhs_bit_size: u32, op_bit_size: u32 },
+    #[error("Bit size for rhs {rhs_bit_size} does not match op bit size {op_bit_size}")]
+    MismatchedRhsBitSize { rhs_bit_size: u32, op_bit_size: u32 },
+    #[error("Shift with bit size {op_bit_size} is invalid")]
+    InvalidShift { op_bit_size: u32 },
+}
+
+/// Evaluate a binary operation on two FieldElement memory values.
 pub(crate) fn evaluate_binary_field_op(
     op: &BinaryFieldOp,
-    a: FieldElement,
-    b: FieldElement,
-) -> FieldElement {
-    match op {
+    lhs: MemoryValue,
+    rhs: MemoryValue,
+) -> Result<MemoryValue, BrilligArithmeticError> {
+    if lhs.bit_size != FieldElement::max_num_bits() {
+        return Err(BrilligArithmeticError::MismatchedLhsBitSize {
+            lhs_bit_size: lhs.bit_size,
+            op_bit_size: FieldElement::max_num_bits(),
+        });
+    }
+    if rhs.bit_size != FieldElement::max_num_bits() {
+        return Err(BrilligArithmeticError::MismatchedRhsBitSize {
+            rhs_bit_size: rhs.bit_size,
+            op_bit_size: FieldElement::max_num_bits(),
+        });
+    }
+
+    let a = lhs.value;
+    let b = rhs.value;
+    Ok(match op {
         // Perform addition, subtraction, multiplication, and division based on the BinaryOp variant.
-        BinaryFieldOp::Add => a + b,
-        BinaryFieldOp::Sub => a - b,
-        BinaryFieldOp::Mul => a * b,
-        BinaryFieldOp::Div => a / b,
+        BinaryFieldOp::Add => (a + b).into(),
+        BinaryFieldOp::Sub => (a - b).into(),
+        BinaryFieldOp::Mul => (a * b).into(),
+        BinaryFieldOp::Div => (a / b).into(),
         BinaryFieldOp::IntegerDiv => {
             let a_big = BigUint::from_bytes_be(&a.to_be_bytes());
             let b_big = BigUint::from_bytes_be(&b.to_be_bytes());
 
             let result = a_big / b_big;
-            FieldElement::from_be_bytes_reduce(&result.to_bytes_be())
+            FieldElement::from_be_bytes_reduce(&result.to_bytes_be()).into()
         }
         BinaryFieldOp::Equals => (a == b).into(),
         BinaryFieldOp::LessThan => (a < b).into(),
         BinaryFieldOp::LessThanEquals => (a <= b).into(),
-    }
+    })
 }
 
-/// Evaluate a binary operation on two unsigned big integers with a given bit size and return the result as a big integer.
-pub(crate) fn evaluate_binary_bigint_op(
+/// Evaluate a binary operation on two unsigned big integers with a given bit size.
+pub(crate) fn evaluate_binary_int_op(
     op: &BinaryIntOp,
-    a: BigUint,
-    b: BigUint,
+    lhs: MemoryValue,
+    rhs: MemoryValue,
     bit_size: u32,
-) -> Result<BigUint, String> {
+) -> Result<MemoryValue, BrilligArithmeticError> {
+    if lhs.bit_size != bit_size {
+        return Err(BrilligArithmeticError::MismatchedLhsBitSize {
+            lhs_bit_size: lhs.bit_size,
+            op_bit_size: bit_size,
+        });
+    }
+    if rhs.bit_size != bit_size {
+        return Err(BrilligArithmeticError::MismatchedRhsBitSize {
+            rhs_bit_size: rhs.bit_size,
+            op_bit_size: bit_size,
+        });
+    }
+
+    let lhs = BigUint::from_bytes_be(&lhs.value.to_be_bytes());
+    let rhs = BigUint::from_bytes_be(&rhs.value.to_be_bytes());
+
     let bit_modulo = &(BigUint::one() << bit_size);
     let result = match op {
         // Perform addition, subtraction, and multiplication, applying a modulo operation to keep the result within the bit size.
-        BinaryIntOp::Add => (a + b) % bit_modulo,
-        BinaryIntOp::Sub => (bit_modulo + a - b) % bit_modulo,
-        BinaryIntOp::Mul => (a * b) % bit_modulo,
+        BinaryIntOp::Add => (lhs + rhs) % bit_modulo,
+        BinaryIntOp::Sub => (bit_modulo + lhs - rhs) % bit_modulo,
+        BinaryIntOp::Mul => (lhs * rhs) % bit_modulo,
         // Perform unsigned division using the modulo operation on a and b.
         BinaryIntOp::Div => {
-            let b_mod = b % bit_modulo;
-            if b_mod.is_zero() {
+            if rhs.is_zero() {
                 BigUint::zero()
             } else {
-                (a % bit_modulo) / b_mod
+                lhs / rhs
             }
         }
         // Perform a == operation, returning 0 or 1
         BinaryIntOp::Equals => {
-            if (a % bit_modulo) == (b % bit_modulo) {
+            if lhs == rhs {
                 BigUint::one()
             } else {
                 BigUint::zero()
@@ -60,7 +102,7 @@ pub(crate) fn evaluate_binary_bigint_op(
         }
         // Perform a < operation, returning 0 or 1
         BinaryIntOp::LessThan => {
-            if (a % bit_modulo) < (b % bit_modulo) {
+            if lhs < rhs {
                 BigUint::one()
             } else {
                 BigUint::zero()
@@ -68,29 +110,40 @@ pub(crate) fn evaluate_binary_bigint_op(
         }
         // Perform a <= operation, returning 0 or 1
         BinaryIntOp::LessThanEquals => {
-            if (a % bit_modulo) <= (b % bit_modulo) {
+            if lhs <= rhs {
                 BigUint::one()
             } else {
                 BigUint::zero()
             }
         }
         // Perform bitwise AND, OR, XOR, left shift, and right shift operations, applying a modulo operation to keep the result within the bit size.
-        BinaryIntOp::And => (a & b) % bit_modulo,
-        BinaryIntOp::Or => (a | b) % bit_modulo,
-        BinaryIntOp::Xor => (a ^ b) % bit_modulo,
+        BinaryIntOp::And => lhs & rhs,
+        BinaryIntOp::Or => lhs | rhs,
+        BinaryIntOp::Xor => lhs ^ rhs,
         BinaryIntOp::Shl => {
-            assert!(bit_size <= 128, "unsupported bit size for right shift");
-            let b = b.to_u128().unwrap();
-            (a << b) % bit_modulo
+            if bit_size > 128 {
+                return Err(BrilligArithmeticError::InvalidShift { op_bit_size: bit_size });
+            }
+            let rhs = rhs.to_u128().unwrap();
+            (lhs << rhs) % bit_modulo
         }
         BinaryIntOp::Shr => {
-            assert!(bit_size <= 128, "unsupported bit size for right shift");
-            let b = b.to_u128().unwrap();
-            (a >> b) % bit_modulo
+            if bit_size > 128 {
+                return Err(BrilligArithmeticError::InvalidShift { op_bit_size: bit_size });
+            }
+            let rhs = rhs.to_u128().unwrap();
+            lhs >> rhs
         }
     };
 
-    Ok(result)
+    let result_as_field = FieldElement::from_be_bytes_reduce(&result.to_bytes_be());
+
+    Ok(match op {
+        BinaryIntOp::Equals | BinaryIntOp::LessThan | BinaryIntOp::LessThanEquals => {
+            MemoryValue::new(result_as_field, 1)
+        }
+        _ => MemoryValue::new(result_as_field, bit_size),
+    })
 }
 
 #[cfg(test)]
@@ -104,12 +157,15 @@ mod tests {
     }
 
     fn evaluate_u128(op: &BinaryIntOp, a: u128, b: u128, bit_size: u32) -> u128 {
-        // Convert to big integers
-        let lhs_big = BigUint::from(a);
-        let rhs_big = BigUint::from(b);
-        let result_value = evaluate_binary_bigint_op(op, lhs_big, rhs_big, bit_size).unwrap();
+        let result_value = evaluate_binary_int_op(
+            op,
+            MemoryValue::new(a.into(), bit_size),
+            MemoryValue::new(b.into(), bit_size),
+            bit_size,
+        )
+        .unwrap();
         // Convert back to u128
-        result_value.to_u128().unwrap()
+        result_value.value.to_u128()
     }
 
     fn to_negative(a: u128, bit_size: u32) -> u128 {
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 73b57b907f3..ab4358739e9 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -1,33 +1,33 @@
-use acir::brillig::{BlackBoxOp, HeapArray, HeapVector, Value};
+use acir::brillig::{BlackBoxOp, HeapArray, HeapVector};
 use acir::{BlackBoxFunc, FieldElement};
 use acvm_blackbox_solver::{
     blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, keccakf1600,
     sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
 };
 
+use crate::memory::MemoryValue;
 use crate::Memory;
 
-fn read_heap_vector<'a>(memory: &'a Memory, vector: &HeapVector) -> &'a [Value] {
-    memory.read_slice(memory.read_ref(vector.pointer), memory.read(vector.size).to_usize())
+fn read_heap_vector<'a>(memory: &'a Memory, vector: &HeapVector) -> &'a [MemoryValue] {
+    let size = memory.read(vector.size);
+    memory.read_slice(memory.read_ref(vector.pointer), size.to_usize())
 }
 
-fn read_heap_array<'a>(memory: &'a Memory, array: &HeapArray) -> &'a [Value] {
+fn read_heap_array<'a>(memory: &'a Memory, array: &HeapArray) -> &'a [MemoryValue] {
     memory.read_slice(memory.read_ref(array.pointer), array.size)
 }
 
 /// Extracts the last byte of every value
-fn to_u8_vec(inputs: &[Value]) -> Vec<u8> {
+fn to_u8_vec(inputs: &[MemoryValue]) -> Vec<u8> {
     let mut result = Vec::with_capacity(inputs.len());
-    for input in inputs {
-        let field_bytes = input.to_field().to_be_bytes();
-        let byte = field_bytes.last().unwrap();
-        result.push(*byte);
+    for &input in inputs {
+        result.push(input.try_into().unwrap());
     }
     result
 }
 
-fn to_value_vec(input: &[u8]) -> Vec<Value> {
-    input.iter().map(|x| Value::from(*x as usize)).collect()
+fn to_value_vec(input: &[u8]) -> Vec<MemoryValue> {
+    input.iter().map(|&x| x.into()).collect()
 }
 
 pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
@@ -63,14 +63,13 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         BlackBoxOp::Keccakf1600 { message, output } => {
             let state_vec: Vec<u64> = read_heap_vector(memory, message)
                 .iter()
-                .map(|value| value.to_field().try_to_u64().unwrap())
+                .map(|&memory_value| memory_value.try_into().unwrap())
                 .collect();
             let state: [u64; 25] = state_vec.try_into().unwrap();
 
             let new_state = keccakf1600(state)?;
 
-            let new_state: Vec<Value> =
-                new_state.into_iter().map(|x| Value::from(x as usize)).collect();
+            let new_state: Vec<MemoryValue> = new_state.into_iter().map(|x| x.into()).collect();
             memory.write_slice(memory.read_ref(output.pointer), &new_state);
             Ok(())
         }
@@ -125,8 +124,8 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::SchnorrVerify { public_key_x, public_key_y, message, signature, result } => {
-            let public_key_x = memory.read(*public_key_x).to_field();
-            let public_key_y = memory.read(*public_key_y).to_field();
+            let public_key_x = memory.read(*public_key_x).try_into().unwrap();
+            let public_key_y = memory.read(*public_key_y).try_into().unwrap();
             let message: Vec<u8> = to_u8_vec(read_heap_vector(memory, message));
             let signature: Vec<u8> = to_u8_vec(read_heap_vector(memory, signature));
             let verified =
@@ -135,26 +134,26 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::FixedBaseScalarMul { low, high, result } => {
-            let low = memory.read(*low).to_field();
-            let high = memory.read(*high).to_field();
+            let low = memory.read(*low).try_into().unwrap();
+            let high = memory.read(*high).try_into().unwrap();
             let (x, y) = solver.fixed_base_scalar_mul(&low, &high)?;
             memory.write_slice(memory.read_ref(result.pointer), &[x.into(), y.into()]);
             Ok(())
         }
         BlackBoxOp::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, result } => {
-            let input1_x = memory.read(*input1_x).to_field();
-            let input1_y = memory.read(*input1_y).to_field();
-            let input2_x = memory.read(*input2_x).to_field();
-            let input2_y = memory.read(*input2_y).to_field();
+            let input1_x = memory.read(*input1_x).try_into().unwrap();
+            let input1_y = memory.read(*input1_y).try_into().unwrap();
+            let input2_x = memory.read(*input2_x).try_into().unwrap();
+            let input2_y = memory.read(*input2_y).try_into().unwrap();
             let (x, y) = solver.ec_add(&input1_x, &input1_y, &input2_x, &input2_y)?;
             memory.write_slice(memory.read_ref(result.pointer), &[x.into(), y.into()]);
             Ok(())
         }
         BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
             let inputs: Vec<FieldElement> =
-                read_heap_vector(memory, inputs).iter().map(|x| x.to_field()).collect();
+                read_heap_vector(memory, inputs).iter().map(|&x| x.try_into().unwrap()).collect();
             let domain_separator: u32 =
-                memory.read(*domain_separator).to_u128().try_into().map_err(|_| {
+                memory.read(*domain_separator).try_into().map_err(|_| {
                     BlackBoxResolutionError::Failed(
                         BlackBoxFunc::PedersenCommitment,
                         "Invalid signature length".to_string(),
@@ -166,9 +165,9 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         }
         BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
             let inputs: Vec<FieldElement> =
-                read_heap_vector(memory, inputs).iter().map(|x| x.to_field()).collect();
+                read_heap_vector(memory, inputs).iter().map(|&x| x.try_into().unwrap()).collect();
             let domain_separator: u32 =
-                memory.read(*domain_separator).to_u128().try_into().map_err(|_| {
+                memory.read(*domain_separator).try_into().map_err(|_| {
                     BlackBoxResolutionError::Failed(
                         BlackBoxFunc::PedersenCommitment,
                         "Invalid signature length".to_string(),
@@ -186,12 +185,12 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         BlackBoxOp::BigIntToLeBytes { .. } => todo!(),
         BlackBoxOp::Poseidon2Permutation { message, output, len } => {
             let input = read_heap_vector(memory, message);
-            let input: Vec<FieldElement> = input.iter().map(|x| x.to_field()).collect();
-            let len = memory.read(*len).to_u128() as u32;
+            let input: Vec<FieldElement> = input.iter().map(|&x| x.try_into().unwrap()).collect();
+            let len = memory.read(*len).try_into().unwrap();
             let result = solver.poseidon2_permutation(&input, len)?;
             let mut values = Vec::new();
             for i in result {
-                values.push(Value::from(i));
+                values.push(i.into());
             }
             memory.write_slice(memory.read_ref(output.pointer), &values);
             Ok(())
@@ -205,8 +204,8 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
                     format!("Expected 16 inputs but encountered {}", &inputs.len()),
                 ));
             }
-            for (i, input) in inputs.iter().enumerate() {
-                message[i] = input.to_u128() as u32;
+            for (i, &input) in inputs.iter().enumerate() {
+                message[i] = input.try_into().unwrap();
             }
             let mut state = [0; 8];
             let values = read_heap_vector(memory, hash_values);
@@ -216,12 +215,12 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
                     format!("Expected 8 values but encountered {}", &values.len()),
                 ));
             }
-            for (i, value) in values.iter().enumerate() {
-                state[i] = value.to_u128() as u32;
+            for (i, &value) in values.iter().enumerate() {
+                state[i] = value.try_into().unwrap();
             }
 
             sha256compression(&mut state, &message);
-            let state = state.map(|x| Value::from(x as u128));
+            let state = state.map(|x| x.into());
 
             memory.write_slice(memory.read_ref(output.pointer), &state);
             Ok(())
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index e2a037618a4..0f430b0d5b2 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -13,23 +13,22 @@
 
 use acir::brillig::{
     BinaryFieldOp, BinaryIntOp, ForeignCallParam, ForeignCallResult, HeapArray, HeapValueType,
-    HeapVector, MemoryAddress, Opcode, Value, ValueOrArray,
+    HeapVector, MemoryAddress, Opcode, ValueOrArray,
 };
 use acir::FieldElement;
+use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
+use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
+use black_box::evaluate_black_box;
+use num_bigint::BigUint;
+
 // Re-export `brillig`.
 pub use acir::brillig;
+pub use memory::{Memory, MemoryValue, MEMORY_ADDRESSING_BIT_SIZE};
 
 mod arithmetic;
 mod black_box;
 mod memory;
 
-use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
-use arithmetic::{evaluate_binary_bigint_op, evaluate_binary_field_op};
-use black_box::evaluate_black_box;
-
-pub use memory::Memory;
-use num_bigint::BigUint;
-
 /// The error call stack contains the opcode indexes of the call stack at the time of failure, plus the index of the opcode that failed.
 pub type ErrorCallStack = Vec<usize>;
 
@@ -63,7 +62,7 @@ pub enum VMStatus {
 /// VM encapsulates the state of the Brillig VM during execution.
 pub struct VM<'a, B: BlackBoxFunctionSolver> {
     /// Calldata to the brillig function
-    calldata: Vec<Value>,
+    calldata: Vec<FieldElement>,
     /// Instruction pointer
     program_counter: usize,
     /// A counter maintained throughout a Brillig process that determines
@@ -79,7 +78,7 @@ pub struct VM<'a, B: BlackBoxFunctionSolver> {
     /// Memory of the VM
     memory: Memory,
     /// Call stack
-    call_stack: Vec<Value>,
+    call_stack: Vec<usize>,
     /// The solver for blackbox functions
     black_box_solver: &'a B,
 }
@@ -87,7 +86,7 @@ pub struct VM<'a, B: BlackBoxFunctionSolver> {
 impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     /// Constructs a new VM instance
     pub fn new(
-        calldata: Vec<Value>,
+        calldata: Vec<FieldElement>,
         bytecode: &'a [Opcode],
         foreign_call_results: Vec<ForeignCallResult>,
         black_box_solver: &'a B,
@@ -143,8 +142,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     /// Indicating that the VM encountered a `Trap` Opcode
     /// or an invalid state.
     fn fail(&mut self, message: String) -> VMStatus {
-        let mut error_stack: Vec<_> =
-            self.call_stack.iter().map(|value| value.to_usize()).collect();
+        let mut error_stack: Vec<_> = self.call_stack.clone();
         error_stack.push(self.program_counter);
         self.status(VMStatus::Failure { call_stack: error_stack, message });
         self.status.clone()
@@ -159,22 +157,18 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         self.status.clone()
     }
 
-    pub fn get_memory(&self) -> &[Value] {
+    pub fn get_memory(&self) -> &[MemoryValue] {
         self.memory.values()
     }
 
-    pub fn write_memory_at(&mut self, ptr: usize, value: Value) {
+    pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue) {
         self.memory.write(MemoryAddress(ptr), value);
     }
 
     /// Returns the VM's current call stack, including the actual program
     /// counter in the last position of the returned vector.
     pub fn get_call_stack(&self) -> Vec<usize> {
-        self.call_stack
-            .iter()
-            .map(|program_counter| program_counter.to_usize())
-            .chain(std::iter::once(self.program_counter))
-            .collect()
+        self.call_stack.iter().copied().chain(std::iter::once(self.program_counter)).collect()
     }
 
     /// Process a single opcode and modify the program counter.
@@ -182,13 +176,16 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         let opcode = &self.bytecode[self.program_counter];
         match opcode {
             Opcode::BinaryFieldOp { op, lhs, rhs, destination: result } => {
-                self.process_binary_field_op(*op, *lhs, *rhs, *result);
-                self.increment_program_counter()
+                if let Err(error) = self.process_binary_field_op(*op, *lhs, *rhs, *result) {
+                    self.fail(error.to_string())
+                } else {
+                    self.increment_program_counter()
+                }
             }
             Opcode::BinaryIntOp { op, bit_size, lhs, rhs, destination: result } => {
                 if let Err(error) = self.process_binary_int_op(*op, *bit_size, *lhs, *rhs, *result)
                 {
-                    self.fail(error)
+                    self.fail(error.to_string())
                 } else {
                     self.increment_program_counter()
                 }
@@ -204,26 +201,29 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 // Check if condition is true
                 // We use 0 to mean false and any other value to mean true
                 let condition_value = self.memory.read(*condition);
-                if !condition_value.is_zero() {
+                if condition_value.try_into().expect("condition value is not a boolean") {
                     return self.set_program_counter(*destination);
                 }
                 self.increment_program_counter()
             }
             Opcode::JumpIfNot { condition, location: destination } => {
                 let condition_value = self.memory.read(*condition);
-                if condition_value.is_zero() {
-                    return self.set_program_counter(*destination);
+                if condition_value.try_into().expect("condition value is not a boolean") {
+                    return self.increment_program_counter();
                 }
-                self.increment_program_counter()
+                self.set_program_counter(*destination)
             }
             Opcode::CalldataCopy { destination_address, size, offset } => {
-                let values = &self.calldata[*offset..(*offset + size)];
-                self.memory.write_slice(*destination_address, values);
+                let values: Vec<_> = self.calldata[*offset..(*offset + size)]
+                    .iter()
+                    .map(|value| MemoryValue::new_field(*value))
+                    .collect();
+                self.memory.write_slice(*destination_address, &values);
                 self.increment_program_counter()
             }
             Opcode::Return => {
                 if let Some(return_location) = self.call_stack.pop() {
-                    self.set_program_counter(return_location.to_usize() + 1)
+                    self.set_program_counter(return_location + 1)
                 } else {
                     self.fail("return opcode hit, but callstack already empty".to_string())
                 }
@@ -254,81 +254,14 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                     return self.wait_for_foreign_call(function.clone(), resolved_inputs);
                 }
 
-                let values = &self.foreign_call_results[self.foreign_call_counter].values;
+                let write_result = self.write_foreign_call_result(
+                    destinations,
+                    destination_value_types,
+                    self.foreign_call_counter,
+                );
 
-                let mut invalid_foreign_call_result = false;
-                for ((destination, value_type), output) in
-                    destinations.iter().zip(destination_value_types).zip(values)
-                {
-                    match (destination, value_type) {
-                        (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple) => {
-                            match output {
-                                ForeignCallParam::Single(value) => {
-                                    self.memory.write(*value_index, *value);
-                                }
-                                _ => unreachable!(
-                                    "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}"
-                                ),
-                            }
-                        }
-                        (
-                            ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
-                            HeapValueType::Array { value_types, size: type_size },
-                        ) if size == type_size => {
-                            if HeapValueType::all_simple(value_types) {
-                                match output {
-                                    ForeignCallParam::Array(values) => {
-                                        if values.len() != *size {
-                                            invalid_foreign_call_result = true;
-                                            break;
-                                        }
-                                        // Convert the destination pointer to a usize
-                                        let destination = self.memory.read_ref(*pointer_index);
-                                        // Write to our destination memory
-                                        self.memory.write_slice(destination, values);
-                                    }
-                                    _ => {
-                                        unreachable!("Function result size does not match brillig bytecode size")
-                                    }
-                                }
-                            } else {
-                                unimplemented!("deflattening heap arrays from foreign calls");
-                            }
-                        }
-                        (
-                            ValueOrArray::HeapVector(HeapVector {pointer: pointer_index, size: size_index }),
-                            HeapValueType::Vector { value_types },
-                        ) => {
-                            if HeapValueType::all_simple(value_types) {
-                                match output {
-                                    ForeignCallParam::Array(values) => {
-                                        // Set our size in the size address
-                                        self.memory.write(*size_index, Value::from(values.len()));
-                                        // Convert the destination pointer to a usize
-                                        let destination = self.memory.read_ref(*pointer_index);
-                                        // Write to our destination memory
-                                        self.memory.write_slice(destination, values);
-                                    }
-                                    _ => {
-                                        unreachable!("Function result size does not match brillig bytecode size")
-                                    }
-                                }
-                            } else {
-                                unimplemented!("deflattening heap vectors from foreign calls");
-                            }
-                        }
-                        _ => {
-                            unreachable!("Unexpected value type {value_type:?} for destination {destination:?}");
-                        }
-                    }
-                }
-
-                // These checks must come after resolving the foreign call outputs as `fail` uses a mutable reference
-                if destinations.len() != values.len() {
-                    self.fail(format!("{} output values were provided as a foreign call result for {} destination slots", values.len(), destinations.len()));
-                }
-                if invalid_foreign_call_result {
-                    self.fail("Function result size does not match brillig bytecode".to_owned());
+                if let Err(e) = write_result {
+                    return self.fail(e);
                 }
 
                 self.foreign_call_counter += 1;
@@ -341,10 +274,10 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
             }
             Opcode::ConditionalMov { destination, source_a, source_b, condition } => {
                 let condition_value = self.memory.read(*condition);
-                if condition_value.is_zero() {
-                    self.memory.write(*destination, self.memory.read(*source_b));
-                } else {
+                if condition_value.try_into().expect("condition value is not a boolean") {
                     self.memory.write(*destination, self.memory.read(*source_a));
+                } else {
+                    self.memory.write(*destination, self.memory.read(*source_b));
                 }
                 self.increment_program_counter()
             }
@@ -369,11 +302,12 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
             }
             Opcode::Call { location } => {
                 // Push a return location
-                self.call_stack.push(Value::from(self.program_counter));
+                self.call_stack.push(self.program_counter);
                 self.set_program_counter(*location)
             }
-            Opcode::Const { destination, value, bit_size: _ } => {
-                self.memory.write(*destination, *value);
+            Opcode::Const { destination, value, bit_size } => {
+                // Consts are not checked in runtime to fit in the bit size, since they can safely be checked statically.
+                self.memory.write(*destination, MemoryValue::new(*value, *bit_size));
                 self.increment_program_counter()
             }
             Opcode::BlackBox(black_box_op) => {
@@ -413,15 +347,19 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         value_type: &HeapValueType,
     ) -> ForeignCallParam {
         match (input, value_type) {
-            (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple) => {
-                self.memory.read(value_index).into()
+            (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(_)) => {
+                self.memory.read(value_index).value.into()
             }
             (
                 ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
                 HeapValueType::Array { value_types, size: type_size },
             ) if *type_size == size => {
                 let start = self.memory.read_ref(pointer_index);
-                self.read_slice_of_values_from_memory(start, size, value_types).into()
+                self.read_slice_of_values_from_memory(start, size, value_types)
+                    .into_iter()
+                    .map(|mem_value| mem_value.value)
+                    .collect::<Vec<_>>()
+                    .into()
             }
             (
                 ValueOrArray::HeapVector(HeapVector { pointer: pointer_index, size: size_index }),
@@ -429,7 +367,11 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
             ) => {
                 let start = self.memory.read_ref(pointer_index);
                 let size = self.memory.read(size_index).to_usize();
-                self.read_slice_of_values_from_memory(start, size, value_types).into()
+                self.read_slice_of_values_from_memory(start, size, value_types)
+                    .into_iter()
+                    .map(|mem_value| mem_value.value)
+                    .collect::<Vec<_>>()
+                    .into()
             }
             _ => {
                 unreachable!("Unexpected value type {value_type:?} for input {input:?}");
@@ -444,7 +386,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         start: MemoryAddress,
         size: usize,
         value_types: &[HeapValueType],
-    ) -> Vec<Value> {
+    ) -> Vec<MemoryValue> {
         if HeapValueType::all_simple(value_types) {
             self.memory.read_slice(start, size).to_vec()
         } else {
@@ -459,9 +401,8 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 .flat_map(|(i, value_type)| {
                     let value_address: MemoryAddress = (start.to_usize() + i).into();
                     match value_type {
-                        HeapValueType::Simple => {
-                            let value = self.memory.read(value_address);
-                            vec![value]
+                        HeapValueType::Simple(_) => {
+                            vec![self.memory.read(value_address)]
                         }
                         HeapValueType::Array { value_types, size } => {
                             let array_address = self.memory.read_ref(value_address);
@@ -486,6 +427,124 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         }
     }
 
+    fn write_foreign_call_result(
+        &mut self,
+        destinations: &[ValueOrArray],
+        destination_value_types: &[HeapValueType],
+        foreign_call_index: usize,
+    ) -> Result<(), String> {
+        let values = &self.foreign_call_results[foreign_call_index].values;
+
+        if destinations.len() != values.len() {
+            return Err(format!(
+                "{} output values were provided as a foreign call result for {} destination slots",
+                values.len(),
+                destinations.len()
+            ));
+        }
+
+        for ((destination, value_type), output) in
+            destinations.iter().zip(destination_value_types).zip(values)
+        {
+            match (destination, value_type) {
+                (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(bit_size)) => {
+                    match output {
+                        ForeignCallParam::Single(value) => {
+                            let memory_value = MemoryValue::new_checked(*value, *bit_size);
+                            if let Some(memory_value) = memory_value {
+                                self.memory.write(*value_index, memory_value);
+                            } else {
+                                return Err(format!(
+                                    "Foreign call result value {} does not fit in bit size {}",
+                                    value,
+                                    bit_size
+                                ));
+                            }
+                        }
+                        _ => return Err(format!(
+                            "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}")
+                        ),
+                    }
+                }
+                (
+                    ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
+                    HeapValueType::Array { value_types, size: type_size },
+                ) if size == type_size => {
+                    if HeapValueType::all_simple(value_types) {
+                        let bit_sizes_iterator = value_types.iter().map(|typ| match typ {
+                            HeapValueType::Simple(bit_size) => *bit_size,
+                            _ => unreachable!("Expected simple value type"),
+                        }).cycle();
+                        match output {
+                            ForeignCallParam::Array(values) => {
+                                if values.len() != *size {
+                                    return Err("Foreign call result array doesn't match expected size".to_string());
+                                }
+                                // Convert the destination pointer to a usize
+                                let destination = self.memory.read_ref(*pointer_index);
+                                // Write to our destination memory
+                                let memory_values: Option<Vec<_>> = values.iter().zip(bit_sizes_iterator).map(
+                                    |(value, bit_size)| MemoryValue::new_checked(*value, bit_size)).collect();
+                                if let Some(memory_values) = memory_values {
+                                    self.memory.write_slice(destination, &memory_values);
+                                } else {
+                                    return Err(format!(
+                                        "Foreign call result values {:?} do not match expected bit sizes",
+                                        values,
+                                    ));
+                                }
+                            }
+                            _ => {
+                                return Err("Function result size does not match brillig bytecode size".to_string());
+                            }
+                        }
+                    } else {
+                        unimplemented!("deflattening heap arrays from foreign calls");
+                    }
+                }
+                (
+                    ValueOrArray::HeapVector(HeapVector {pointer: pointer_index, size: size_index }),
+                    HeapValueType::Vector { value_types },
+                ) => {
+                    if HeapValueType::all_simple(value_types) {
+                        let bit_sizes_iterator = value_types.iter().map(|typ| match typ {
+                            HeapValueType::Simple(bit_size) => *bit_size,
+                            _ => unreachable!("Expected simple value type"),
+                        }).cycle();
+                        match output {
+                            ForeignCallParam::Array(values) => {
+                                // Set our size in the size address
+                                self.memory.write(*size_index, values.len().into());
+                                // Convert the destination pointer to a usize
+                                let destination = self.memory.read_ref(*pointer_index);
+                                // Write to our destination memory
+                                let memory_values: Option<Vec<_>> = values.iter().zip(bit_sizes_iterator).map(|(value, bit_size)| MemoryValue::new_checked(*value, bit_size)).collect();
+                                if let Some(memory_values) = memory_values {
+                                    self.memory.write_slice(destination, &memory_values);
+                                }else{
+                                    return Err(format!(
+                                        "Foreign call result values {:?} do not match expected bit sizes",
+                                        values,
+                                    ));
+                                }
+                            }
+                            _ => {
+                                return Err("Function result size does not match brillig bytecode size".to_string());
+                            }
+                        }
+                    } else {
+                        unimplemented!("deflattening heap vectors from foreign calls");
+                    }
+                }
+                _ => {
+                    return Err(format!("Unexpected value type {value_type:?} for destination {destination:?}"));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     /// Process a binary operation.
     /// This method will not modify the program counter.
     fn process_binary_field_op(
@@ -494,14 +553,15 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         lhs: MemoryAddress,
         rhs: MemoryAddress,
         result: MemoryAddress,
-    ) {
+    ) -> Result<(), BrilligArithmeticError> {
         let lhs_value = self.memory.read(lhs);
         let rhs_value = self.memory.read(rhs);
 
-        let result_value =
-            evaluate_binary_field_op(&op, lhs_value.to_field(), rhs_value.to_field());
+        let result_value = evaluate_binary_field_op(&op, lhs_value, rhs_value)?;
+
+        self.memory.write(result, result_value);
 
-        self.memory.write(result, result_value.into());
+        Ok(())
     }
 
     /// Process a binary operation.
@@ -513,25 +573,23 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         lhs: MemoryAddress,
         rhs: MemoryAddress,
         result: MemoryAddress,
-    ) -> Result<(), String> {
+    ) -> Result<(), BrilligArithmeticError> {
         let lhs_value = self.memory.read(lhs);
         let rhs_value = self.memory.read(rhs);
 
-        // Convert to big integers
-        let lhs_big = BigUint::from_bytes_be(&lhs_value.to_field().to_be_bytes());
-        let rhs_big = BigUint::from_bytes_be(&rhs_value.to_field().to_be_bytes());
-        let result_value = evaluate_binary_bigint_op(&op, lhs_big, rhs_big, bit_size)?;
-        // Convert back to field element
-        self.memory
-            .write(result, FieldElement::from_be_bytes_reduce(&result_value.to_bytes_be()).into());
+        let result_value = evaluate_binary_int_op(&op, lhs_value, rhs_value, bit_size)?;
+        self.memory.write(result, result_value);
         Ok(())
     }
 
     /// Casts a value to a different bit size.
-    fn cast(&self, bit_size: u32, value: Value) -> Value {
-        let lhs_big = BigUint::from_bytes_be(&value.to_field().to_be_bytes());
+    fn cast(&self, bit_size: u32, source_value: MemoryValue) -> MemoryValue {
+        let lhs_big = BigUint::from_bytes_be(&source_value.value.to_be_bytes());
         let mask = BigUint::from(2_u32).pow(bit_size) - 1_u32;
-        FieldElement::from_be_bytes_reduce(&(lhs_big & mask).to_bytes_be()).into()
+        MemoryValue {
+            value: FieldElement::from_be_bytes_reduce(&(lhs_big & mask).to_bytes_be()),
+            bit_size,
+        }
     }
 }
 
@@ -592,7 +650,7 @@ mod tests {
 
     #[test]
     fn add_single_step_smoke() {
-        let calldata = vec![Value::from(27u128)];
+        let calldata = vec![FieldElement::from(27u128)];
 
         // Add opcode to add the value in address `0` and `1`
         // and place the output in address `2`
@@ -618,7 +676,7 @@ mod tests {
         let VM { memory, .. } = vm;
         let output_value = memory.read(MemoryAddress::from(0));
 
-        assert_eq!(output_value, Value::from(27u128));
+        assert_eq!(output_value.value, FieldElement::from(27u128));
     }
 
     #[test]
@@ -627,12 +685,12 @@ mod tests {
         let mut opcodes = vec![];
 
         let lhs = {
-            calldata.push(Value::from(2u128));
+            calldata.push(2u128.into());
             MemoryAddress::from(calldata.len() - 1)
         };
 
         let rhs = {
-            calldata.push(Value::from(2u128));
+            calldata.push(2u128.into());
             MemoryAddress::from(calldata.len() - 1)
         };
 
@@ -643,11 +701,10 @@ mod tests {
             size: 2,
             offset: 0,
         });
-        let equal_cmp_opcode =
-            Opcode::BinaryIntOp { op: BinaryIntOp::Equals, bit_size: 1, lhs, rhs, destination };
-        opcodes.push(equal_cmp_opcode);
+
+        opcodes.push(Opcode::BinaryFieldOp { destination, op: BinaryFieldOp::Equals, lhs, rhs });
         opcodes.push(Opcode::Jump { location: 3 });
-        opcodes.push(Opcode::JumpIf { condition: MemoryAddress::from(2), location: 4 });
+        opcodes.push(Opcode::JumpIf { condition: destination, location: 4 });
 
         let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
 
@@ -657,8 +714,8 @@ mod tests {
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
-        let output_cmp_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(output_cmp_value, Value::from(true));
+        let output_cmp_value = vm.memory.read(destination);
+        assert_eq!(output_cmp_value.value, true.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -669,7 +726,7 @@ mod tests {
 
     #[test]
     fn jmpifnot_opcode() {
-        let calldata = vec![Value::from(1u128), Value::from(2u128)];
+        let calldata = vec![1u128.into(), 2u128.into()];
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -717,7 +774,7 @@ mod tests {
         assert_eq!(status, VMStatus::InProgress);
 
         let output_cmp_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(output_cmp_value, Value::from(false));
+        assert_eq!(output_cmp_value.value, false.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -734,12 +791,12 @@ mod tests {
         // The address at index `2` should have not changed as we jumped over the add opcode
         let VM { memory, .. } = vm;
         let output_value = memory.read(MemoryAddress::from(2));
-        assert_eq!(output_value, Value::from(false));
+        assert_eq!(output_value.value, false.into());
     }
 
     #[test]
     fn cast_opcode() {
-        let calldata = vec![Value::from((2_u128.pow(32)) - 1)];
+        let calldata = vec![((2_u128.pow(32)) - 1).into()];
 
         let opcodes = &[
             Opcode::CalldataCopy {
@@ -768,12 +825,12 @@ mod tests {
         let VM { memory, .. } = vm;
 
         let casted_value = memory.read(MemoryAddress::from(1));
-        assert_eq!(casted_value, Value::from(2_u128.pow(8) - 1));
+        assert_eq!(casted_value.value, (2_u128.pow(8) - 1).into());
     }
 
     #[test]
     fn mov_opcode() {
-        let calldata = vec![Value::from(1u128), Value::from(2u128), Value::from(3u128)];
+        let calldata = vec![(1u128).into(), (2u128).into(), (3u128).into()];
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -796,16 +853,15 @@ mod tests {
         let VM { memory, .. } = vm;
 
         let destination_value = memory.read(MemoryAddress::from(2));
-        assert_eq!(destination_value, Value::from(1u128));
+        assert_eq!(destination_value.value, (1u128).into());
 
         let source_value = memory.read(MemoryAddress::from(0));
-        assert_eq!(source_value, Value::from(1u128));
+        assert_eq!(source_value.value, (1u128).into());
     }
 
     #[test]
     fn cmov_opcode() {
-        let calldata =
-            vec![Value::from(0u128), Value::from(1u128), Value::from(2u128), Value::from(3u128)];
+        let calldata = vec![(0u128).into(), (1u128).into(), (2u128).into(), (3u128).into()];
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -813,8 +869,22 @@ mod tests {
             offset: 0,
         };
 
+        let cast_zero = Opcode::Cast {
+            destination: MemoryAddress::from(0),
+            source: MemoryAddress::from(0),
+            bit_size: 1,
+        };
+
+        let cast_one = Opcode::Cast {
+            destination: MemoryAddress::from(1),
+            source: MemoryAddress::from(1),
+            bit_size: 1,
+        };
+
         let opcodes = &[
             calldata_copy,
+            cast_zero,
+            cast_one,
             Opcode::ConditionalMov {
                 destination: MemoryAddress(4), // Sets 3_u128 to memory address 4
                 source_a: MemoryAddress(2),
@@ -836,28 +906,30 @@ mod tests {
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         let VM { memory, .. } = vm;
 
         let destination_value = memory.read(MemoryAddress::from(4));
-        assert_eq!(destination_value, Value::from(3_u128));
+        assert_eq!(destination_value.value, (3_u128).into());
 
         let source_value = memory.read(MemoryAddress::from(5));
-        assert_eq!(source_value, Value::from(2_u128));
+        assert_eq!(source_value.value, (2_u128).into());
     }
 
     #[test]
     fn cmp_binary_ops() {
         let bit_size = 32;
-        let calldata = vec![
-            Value::from(2u128),
-            Value::from(2u128),
-            Value::from(0u128),
-            Value::from(5u128),
-            Value::from(6u128),
-        ];
+        let calldata =
+            vec![(2u128).into(), (2u128).into(), (0u128).into(), (5u128).into(), (6u128).into()];
+        let calldata_size = calldata.len();
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -865,6 +937,14 @@ mod tests {
             offset: 0,
         };
 
+        let cast_opcodes: Vec<_> = (0..calldata_size)
+            .map(|index| Opcode::Cast {
+                destination: MemoryAddress::from(index),
+                source: MemoryAddress::from(index),
+                bit_size,
+            })
+            .collect();
+
         let equal_opcode = Opcode::BinaryIntOp {
             bit_size,
             op: BinaryIntOp::Equals,
@@ -897,42 +977,47 @@ mod tests {
             destination: MemoryAddress::from(2),
         };
 
-        let opcodes = [
-            calldata_copy,
-            equal_opcode,
-            not_equal_opcode,
-            less_than_opcode,
-            less_than_equal_opcode,
-        ];
+        let opcodes: Vec<_> = std::iter::once(calldata_copy)
+            .chain(cast_opcodes)
+            .chain([equal_opcode, not_equal_opcode, less_than_opcode, less_than_equal_opcode])
+            .collect();
         let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
 
+        // Calldata copy
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
+        for _ in 0..calldata_size {
+            let status = vm.process_opcode();
+            assert_eq!(status, VMStatus::InProgress);
+        }
+
+        // Equals
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
         let output_eq_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(output_eq_value, Value::from(true));
+        assert_eq!(output_eq_value, true.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
         let output_neq_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(output_neq_value, Value::from(false));
+        assert_eq!(output_neq_value, false.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
         let lt_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(lt_value, Value::from(true));
+        assert_eq!(lt_value, true.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         let lte_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(lte_value, Value::from(true));
+        assert_eq!(lte_value, true.into());
     }
+
     #[test]
     fn store_opcode() {
         /// Brillig code for the following:
@@ -942,8 +1027,8 @@ mod tests {
         ///         memory[i] = i as Value;
         ///         i += 1;
         ///     }
-        fn brillig_write_memory(item_count: usize) -> Vec<Value> {
-            let bit_size = 32;
+        fn brillig_write_memory(item_count: usize) -> Vec<MemoryValue> {
+            let bit_size = 64;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_tmp = MemoryAddress::from(2);
@@ -951,21 +1036,17 @@ mod tests {
 
             let start = [
                 // i = 0
-                Opcode::Const { destination: r_i, value: 0u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_i, value: 0u128.into(), bit_size },
                 // len = memory.len() (approximation)
-                Opcode::Const {
-                    destination: r_len,
-                    value: Value::from(item_count as u128),
-                    bit_size: 32,
-                },
+                Opcode::Const { destination: r_len, value: item_count.into(), bit_size },
                 // pointer = free_memory_ptr
-                Opcode::Const { destination: r_pointer, value: 4u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_pointer, value: 4u128.into(), bit_size },
             ];
             let loop_body = [
                 // *i = i
                 Opcode::Store { destination_pointer: r_pointer, source: r_i },
                 // tmp = 1
-                Opcode::Const { destination: r_tmp, value: 1u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_tmp, value: 1u128.into(), bit_size },
                 // i = i + 1 (tmp)
                 Opcode::BinaryIntOp {
                     destination: r_i,
@@ -1000,17 +1081,12 @@ mod tests {
         }
 
         let memory = brillig_write_memory(5);
-        let expected = vec![
-            Value::from(0u128),
-            Value::from(1u128),
-            Value::from(2u128),
-            Value::from(3u128),
-            Value::from(4u128),
-        ];
+        let expected =
+            vec![(0u64).into(), (1u64).into(), (2u64).into(), (3u64).into(), (4u64).into()];
         assert_eq!(memory, expected);
 
         let memory = brillig_write_memory(1024);
-        let expected: Vec<Value> = (0..1024).map(|i| Value::from(i as u128)).collect();
+        let expected: Vec<_> = (0..1024).map(|i: u64| i.into()).collect();
         assert_eq!(memory, expected);
     }
 
@@ -1024,8 +1100,8 @@ mod tests {
         ///         sum += memory[i];
         ///         i += 1;
         ///     }
-        fn brillig_sum_memory(memory: Vec<Value>) -> Value {
-            let bit_size = 32;
+        fn brillig_sum_memory(memory: Vec<FieldElement>) -> FieldElement {
+            let bit_size = 64;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_sum = MemoryAddress::from(2);
@@ -1034,17 +1110,17 @@ mod tests {
 
             let start = [
                 // sum = 0
-                Opcode::Const { destination: r_sum, value: 0u128.into(), bit_size: 32 },
-                // i = 0
-                Opcode::Const { destination: r_i, value: 0u128.into(), bit_size: 32 },
-                // len = array.len() (approximation)
                 Opcode::Const {
-                    destination: r_len,
-                    value: Value::from(memory.len() as u128),
-                    bit_size: 32,
+                    destination: r_sum,
+                    value: 0u128.into(),
+                    bit_size: FieldElement::max_num_bits(),
                 },
+                // i = 0
+                Opcode::Const { destination: r_i, value: 0u128.into(), bit_size },
+                // len = array.len() (approximation)
+                Opcode::Const { destination: r_len, value: memory.len().into(), bit_size },
                 // pointer = array_ptr
-                Opcode::Const { destination: r_pointer, value: 5u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_pointer, value: 5u128.into(), bit_size },
                 Opcode::CalldataCopy {
                     destination_address: MemoryAddress(5),
                     size: memory.len(),
@@ -1055,15 +1131,14 @@ mod tests {
                 // tmp = *i
                 Opcode::Load { destination: r_tmp, source_pointer: r_pointer },
                 // sum = sum + tmp
-                Opcode::BinaryIntOp {
+                Opcode::BinaryFieldOp {
                     destination: r_sum,
                     lhs: r_sum,
-                    op: BinaryIntOp::Add,
+                    op: BinaryFieldOp::Add,
                     rhs: r_tmp,
-                    bit_size,
                 },
                 // tmp = 1
-                Opcode::Const { destination: r_tmp, value: 1u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_tmp, value: 1u128.into(), bit_size },
                 // i = i + 1 (tmp)
                 Opcode::BinaryIntOp {
                     destination: r_i,
@@ -1094,20 +1169,20 @@ mod tests {
 
             let opcodes = [&start[..], &loop_body[..]].concat();
             let vm = brillig_execute_and_get_vm(memory, &opcodes);
-            vm.memory.read(r_sum)
+            vm.memory.read(r_sum).value
         }
 
         assert_eq!(
             brillig_sum_memory(vec![
-                Value::from(1u128),
-                Value::from(2u128),
-                Value::from(3u128),
-                Value::from(4u128),
-                Value::from(5u128),
+                (1u128).into(),
+                (2u128).into(),
+                (3u128).into(),
+                (4u128).into(),
+                (5u128).into(),
             ]),
-            Value::from(15u128)
+            (15u128).into()
         );
-        assert_eq!(brillig_sum_memory(vec![Value::from(1u128); 1024]), Value::from(1024u128));
+        assert_eq!(brillig_sum_memory(vec![(1u128).into(); 1024]), (1024u128).into());
     }
 
     #[test]
@@ -1121,8 +1196,8 @@ mod tests {
         ///         recursive_write(memory, i + 1, len);
         ///     }
         /// Note we represent a 100% in-stack optimized form in brillig
-        fn brillig_recursive_write_memory(size: usize) -> Vec<Value> {
-            let bit_size = 32;
+        fn brillig_recursive_write_memory(size: usize) -> Vec<MemoryValue> {
+            let bit_size = 64;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_tmp = MemoryAddress::from(2);
@@ -1130,15 +1205,15 @@ mod tests {
 
             let start = [
                 // i = 0
-                Opcode::Const { destination: r_i, value: 0u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_i, value: 0u128.into(), bit_size },
                 // len = size
-                Opcode::Const { destination: r_len, value: size.into(), bit_size: 32 },
+                Opcode::Const { destination: r_len, value: size.into(), bit_size },
                 // pointer = free_memory_ptr
-                Opcode::Const { destination: r_pointer, value: 4u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_pointer, value: 4u128.into(), bit_size },
                 // call recursive_fn
                 Opcode::Call {
-                    location: 5, // Call after 'start'
-                },
+                        location: 5, // Call after 'start'
+                    },
                 // end program by jumping to end
                 Opcode::Jump { location: 100 },
             ];
@@ -1160,7 +1235,7 @@ mod tests {
                 // *i = i
                 Opcode::Store { destination_pointer: r_pointer, source: r_i },
                 // tmp = 1
-                Opcode::Const { destination: r_tmp, value: 1u128.into(), bit_size: 32 },
+                Opcode::Const { destination: r_tmp, value: 1u128.into(), bit_size },
                 // i = i + 1 (tmp)
                 Opcode::BinaryIntOp {
                     destination: r_i,
@@ -1188,23 +1263,18 @@ mod tests {
         }
 
         let memory = brillig_recursive_write_memory(5);
-        let expected = vec![
-            Value::from(0u128),
-            Value::from(1u128),
-            Value::from(2u128),
-            Value::from(3u128),
-            Value::from(4u128),
-        ];
+        let expected =
+            vec![(0u64).into(), (1u64).into(), (2u64).into(), (3u64).into(), (4u64).into()];
         assert_eq!(memory, expected);
 
         let memory = brillig_recursive_write_memory(1024);
-        let expected: Vec<Value> = (0..1024).map(|i| Value::from(i as u128)).collect();
+        let expected: Vec<_> = (0..1024).map(|i: u64| i.into()).collect();
         assert_eq!(memory, expected);
     }
 
     /// Helper to execute brillig code
     fn brillig_execute_and_get_vm(
-        calldata: Vec<Value>,
+        calldata: Vec<FieldElement>,
         opcodes: &[Opcode],
     ) -> VM<'_, DummyBlackBoxSolver> {
         let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
@@ -1230,14 +1300,14 @@ mod tests {
 
         let double_program = vec![
             // Load input address with value 5
-            Opcode::Const { destination: r_input, value: Value::from(5u128), bit_size: 32 },
+            Opcode::Const { destination: r_input, value: (5u128).into(), bit_size: 32 },
             // Call foreign function "double" with the input address
             Opcode::ForeignCall {
                 function: "double".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(r_result)],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::Simple(32)],
                 inputs: vec![ValueOrArray::MemoryAddress(r_input)],
-                input_value_types: vec![HeapValueType::Simple],
+                input_value_types: vec![HeapValueType::Simple(32)],
             },
         ];
 
@@ -1248,13 +1318,13 @@ mod tests {
             vm.status,
             VMStatus::ForeignCallWait {
                 function: "double".into(),
-                inputs: vec![Value::from(5u128).into()]
+                inputs: vec![FieldElement::from(5usize).into()]
             }
         );
 
         // Push result we're waiting for
         vm.resolve_foreign_call(
-            Value::from(10u128).into(), // Result of doubling 5u128
+            FieldElement::from(10u128).into(), // Result of doubling 5u128
         );
 
         // Resume VM
@@ -1265,7 +1335,7 @@ mod tests {
 
         // Check result address
         let result_value = vm.memory.read(r_result);
-        assert_eq!(result_value, Value::from(10u128));
+        assert_eq!(result_value, (10u32).into());
 
         // Ensure the foreign call counter has been incremented
         assert_eq!(vm.foreign_call_counter, 1);
@@ -1277,12 +1347,11 @@ mod tests {
         let r_output = MemoryAddress::from(1);
 
         // Define a simple 2x2 matrix in memory
-        let initial_matrix =
-            vec![Value::from(1u128), Value::from(2u128), Value::from(3u128), Value::from(4u128)];
+        let initial_matrix = vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
 
         // Transpose of the matrix (but arbitrary for this test, the 'correct value')
-        let expected_result =
-            vec![Value::from(1u128), Value::from(3u128), Value::from(2u128), Value::from(4u128)];
+        let expected_result: Vec<FieldElement> =
+            vec![(1u128).into(), (3u128).into(), (2u128).into(), (4u128).into()];
 
         let invert_program = vec![
             Opcode::CalldataCopy {
@@ -1291,9 +1360,9 @@ mod tests {
                 offset: 0,
             },
             // input = 0
-            Opcode::Const { destination: r_input, value: 2_usize.into(), bit_size: 32 },
+            Opcode::Const { destination: r_input, value: 2_usize.into(), bit_size: 64 },
             // output = 0
-            Opcode::Const { destination: r_output, value: 2_usize.into(), bit_size: 32 },
+            Opcode::Const { destination: r_output, value: 2_usize.into(), bit_size: 64 },
             // *output = matrix_2x2_transpose(*input)
             Opcode::ForeignCall {
                 function: "matrix_2x2_transpose".into(),
@@ -1303,14 +1372,14 @@ mod tests {
                 })],
                 destination_value_types: vec![HeapValueType::Array {
                     size: initial_matrix.len(),
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                 }],
                 inputs: vec![ValueOrArray::HeapArray(HeapArray {
                     pointer: r_input,
                     size: initial_matrix.len(),
                 })],
                 input_value_types: vec![HeapValueType::Array {
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                     size: initial_matrix.len(),
                 }],
             },
@@ -1338,7 +1407,10 @@ mod tests {
 
         // Check result in memory
         let result_values = vm.memory.read_slice(MemoryAddress(2), 4).to_vec();
-        assert_eq!(result_values, expected_result);
+        assert_eq!(
+            result_values.into_iter().map(|mem_value| mem_value.value).collect::<Vec<_>>(),
+            expected_result
+        );
 
         // Ensure the foreign call counter has been incremented
         assert_eq!(vm.foreign_call_counter, 1);
@@ -1354,10 +1426,10 @@ mod tests {
         let r_output_size = MemoryAddress::from(3);
 
         // Our first string to use the identity function with
-        let input_string =
-            vec![Value::from(1u128), Value::from(2u128), Value::from(3u128), Value::from(4u128)];
+        let input_string: Vec<FieldElement> =
+            vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
         // Double the string (concatenate it with itself)
-        let mut output_string: Vec<Value> =
+        let mut output_string: Vec<_> =
             input_string.iter().cloned().chain(input_string.clone()).collect();
         // Reverse the concatenated string
         output_string.reverse();
@@ -1370,24 +1442,24 @@ mod tests {
                 offset: 0,
             },
             // input_pointer = 4
-            Opcode::Const { destination: r_input_pointer, value: Value::from(4u128), bit_size: 32 },
+            Opcode::Const { destination: r_input_pointer, value: (4u128).into(), bit_size: 64 },
             // input_size = input_string.len() (constant here)
             Opcode::Const {
                 destination: r_input_size,
-                value: Value::from(input_string.len()),
-                bit_size: 32,
+                value: input_string.len().into(),
+                bit_size: 64,
             },
             // output_pointer = 4 + input_size
             Opcode::Const {
                 destination: r_output_pointer,
-                value: Value::from(4 + input_string.len()),
-                bit_size: 32,
+                value: (4 + input_string.len()).into(),
+                bit_size: 64,
             },
             // output_size = input_size * 2
             Opcode::Const {
                 destination: r_output_size,
-                value: Value::from(input_string.len() * 2),
-                bit_size: 32,
+                value: (input_string.len() * 2).into(),
+                bit_size: 64,
             },
             // output_pointer[0..output_size] = string_double(input_pointer[0...input_size])
             Opcode::ForeignCall {
@@ -1397,14 +1469,14 @@ mod tests {
                     size: r_output_size,
                 })],
                 destination_value_types: vec![HeapValueType::Vector {
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                 }],
                 inputs: vec![ValueOrArray::HeapVector(HeapVector {
                     pointer: r_input_pointer,
                     size: r_input_size,
                 })],
                 input_value_types: vec![HeapValueType::Vector {
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                 }],
             },
         ];
@@ -1432,10 +1504,12 @@ mod tests {
         assert_eq!(vm.status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         // Check result in memory
-        let result_values = vm
+        let result_values: Vec<_> = vm
             .memory
             .read_slice(MemoryAddress(4 + input_string.len()), output_string.len())
-            .to_vec();
+            .iter()
+            .map(|mem_val| mem_val.value)
+            .collect();
         assert_eq!(result_values, output_string);
 
         // Ensure the foreign call counter has been incremented
@@ -1448,12 +1522,11 @@ mod tests {
         let r_output = MemoryAddress::from(1);
 
         // Define a simple 2x2 matrix in memory
-        let initial_matrix =
-            vec![Value::from(1u128), Value::from(2u128), Value::from(3u128), Value::from(4u128)];
+        let initial_matrix = vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
 
         // Transpose of the matrix (but arbitrary for this test, the 'correct value')
-        let expected_result =
-            vec![Value::from(1u128), Value::from(3u128), Value::from(2u128), Value::from(4u128)];
+        let expected_result: Vec<FieldElement> =
+            vec![(1u128).into(), (3u128).into(), (2u128).into(), (4u128).into()];
 
         let invert_program = vec![
             Opcode::CalldataCopy {
@@ -1462,9 +1535,9 @@ mod tests {
                 offset: 0,
             },
             // input = 0
-            Opcode::Const { destination: r_input, value: Value::from(2u128), bit_size: 32 },
+            Opcode::Const { destination: r_input, value: (2u128).into(), bit_size: 64 },
             // output = 0
-            Opcode::Const { destination: r_output, value: Value::from(6u128), bit_size: 32 },
+            Opcode::Const { destination: r_output, value: (6u128).into(), bit_size: 64 },
             // *output = matrix_2x2_transpose(*input)
             Opcode::ForeignCall {
                 function: "matrix_2x2_transpose".into(),
@@ -1474,7 +1547,7 @@ mod tests {
                 })],
                 destination_value_types: vec![HeapValueType::Array {
                     size: initial_matrix.len(),
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                 }],
                 inputs: vec![ValueOrArray::HeapArray(HeapArray {
                     pointer: r_input,
@@ -1482,7 +1555,7 @@ mod tests {
                 })],
                 input_value_types: vec![HeapValueType::Array {
                     size: initial_matrix.len(),
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                 }],
             },
         ];
@@ -1508,11 +1581,13 @@ mod tests {
         assert_eq!(vm.status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         // Check initial memory still in place
-        let initial_values = vm.memory.read_slice(MemoryAddress(2), 4).to_vec();
+        let initial_values: Vec<_> =
+            vm.memory.read_slice(MemoryAddress(2), 4).iter().map(|mem_val| mem_val.value).collect();
         assert_eq!(initial_values, initial_matrix);
 
         // Check result in memory
-        let result_values = vm.memory.read_slice(MemoryAddress(6), 4).to_vec();
+        let result_values: Vec<_> =
+            vm.memory.read_slice(MemoryAddress(6), 4).iter().map(|mem_val| mem_val.value).collect();
         assert_eq!(result_values, expected_result);
 
         // Ensure the foreign call counter has been incremented
@@ -1526,23 +1601,13 @@ mod tests {
         let r_output = MemoryAddress::from(2);
 
         // Define a simple 2x2 matrix in memory
-        let matrix_a =
-            vec![Value::from(1u128), Value::from(2u128), Value::from(3u128), Value::from(4u128)];
-
-        let matrix_b = vec![
-            Value::from(10u128),
-            Value::from(11u128),
-            Value::from(12u128),
-            Value::from(13u128),
-        ];
+        let matrix_a = vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
+
+        let matrix_b = vec![(10u128).into(), (11u128).into(), (12u128).into(), (13u128).into()];
 
         // Transpose of the matrix (but arbitrary for this test, the 'correct value')
-        let expected_result = vec![
-            Value::from(34u128),
-            Value::from(37u128),
-            Value::from(78u128),
-            Value::from(85u128),
-        ];
+        let expected_result: Vec<FieldElement> =
+            vec![(34u128).into(), (37u128).into(), (78u128).into(), (85u128).into()];
 
         let matrix_mul_program = vec![
             Opcode::CalldataCopy {
@@ -1551,11 +1616,11 @@ mod tests {
                 offset: 0,
             },
             // input = 3
-            Opcode::Const { destination: r_input_a, value: Value::from(3u128), bit_size: 32 },
+            Opcode::Const { destination: r_input_a, value: (3u128).into(), bit_size: 64 },
             // input = 7
-            Opcode::Const { destination: r_input_b, value: Value::from(7u128), bit_size: 32 },
+            Opcode::Const { destination: r_input_b, value: (7u128).into(), bit_size: 64 },
             // output = 0
-            Opcode::Const { destination: r_output, value: Value::from(0u128), bit_size: 32 },
+            Opcode::Const { destination: r_output, value: (0u128).into(), bit_size: 64 },
             // *output = matrix_2x2_transpose(*input)
             Opcode::ForeignCall {
                 function: "matrix_2x2_transpose".into(),
@@ -1565,7 +1630,7 @@ mod tests {
                 })],
                 destination_value_types: vec![HeapValueType::Array {
                     size: matrix_a.len(),
-                    value_types: vec![HeapValueType::Simple],
+                    value_types: vec![HeapValueType::field()],
                 }],
                 inputs: vec![
                     ValueOrArray::HeapArray(HeapArray { pointer: r_input_a, size: matrix_a.len() }),
@@ -1574,11 +1639,11 @@ mod tests {
                 input_value_types: vec![
                     HeapValueType::Array {
                         size: matrix_a.len(),
-                        value_types: vec![HeapValueType::Simple],
+                        value_types: vec![HeapValueType::field()],
                     },
                     HeapValueType::Array {
                         size: matrix_b.len(),
-                        value_types: vec![HeapValueType::Simple],
+                        value_types: vec![HeapValueType::field()],
                     },
                 ],
             },
@@ -1606,7 +1671,8 @@ mod tests {
         assert_eq!(vm.status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         // Check result in memory
-        let result_values = vm.memory.read_slice(MemoryAddress(0), 4).to_vec();
+        let result_values: Vec<_> =
+            vm.memory.read_slice(MemoryAddress(0), 4).iter().map(|mem_val| mem_val.value).collect();
         assert_eq!(result_values, expected_result);
 
         // Ensure the foreign call counter has been incremented
@@ -1617,47 +1683,54 @@ mod tests {
     fn foreign_call_opcode_nested_arrays_and_slices_input() {
         // [(1, <2,3>, [4]), (5, <6,7,8>, [9])]
 
-        let v2 = vec![Value::from(2u128), Value::from(3u128)];
-        let a4 = vec![Value::from(4u128)];
-        let v6 = vec![Value::from(6u128), Value::from(7u128), Value::from(8u128)];
-        let a9 = vec![Value::from(9u128)];
+        let v2: Vec<MemoryValue> = vec![
+            MemoryValue::from(FieldElement::from(2u128)),
+            MemoryValue::from(FieldElement::from(3u128)),
+        ];
+        let a4: Vec<MemoryValue> = vec![FieldElement::from(4u128).into()];
+        let v6: Vec<MemoryValue> = vec![
+            MemoryValue::from(FieldElement::from(6u128)),
+            MemoryValue::from(FieldElement::from(7u128)),
+            MemoryValue::from(FieldElement::from(8u128)),
+        ];
+        let a9: Vec<MemoryValue> = vec![FieldElement::from(9u128).into()];
 
         // construct memory by declaring all inner arrays/vectors first
-        let v2_ptr = 0u128;
+        let v2_ptr: usize = 0usize;
         let mut memory = v2.clone();
         let v2_start = memory.len();
-        memory.extend(vec![Value::from(v2_ptr), Value::from(v2.len()), Value::from(1u128)]);
+        memory.extend(vec![MemoryValue::from(v2_ptr), v2.len().into(), MemoryValue::from(1_usize)]);
         let a4_ptr = memory.len();
         memory.extend(a4.clone());
         let a4_start = memory.len();
-        memory.extend(vec![Value::from(a4_ptr), Value::from(1u128)]);
+        memory.extend(vec![MemoryValue::from(a4_ptr), MemoryValue::from(1_usize)]);
         let v6_ptr = memory.len();
         memory.extend(v6.clone());
         let v6_start = memory.len();
-        memory.extend(vec![Value::from(v6_ptr), Value::from(v6.len()), Value::from(1u128)]);
+        memory.extend(vec![MemoryValue::from(v6_ptr), v6.len().into(), MemoryValue::from(1_usize)]);
         let a9_ptr = memory.len();
         memory.extend(a9.clone());
         let a9_start = memory.len();
-        memory.extend(vec![Value::from(a9_ptr), Value::from(1u128)]);
+        memory.extend(vec![MemoryValue::from(a9_ptr), MemoryValue::from(1_usize)]);
         // finally we add the contents of the outer array
         let outer_ptr = memory.len();
         let outer_array = vec![
-            Value::from(1u128),
-            Value::from(v2.len()),
-            Value::from(v2_start),
-            Value::from(a4_start),
-            Value::from(5u128),
-            Value::from(v6.len()),
-            Value::from(v6_start),
-            Value::from(a9_start),
+            MemoryValue::from(FieldElement::from(1u128)),
+            MemoryValue::from(v2.len()),
+            MemoryValue::from(v2_start),
+            MemoryValue::from(a4_start),
+            MemoryValue::from(FieldElement::from(5u128)),
+            MemoryValue::from(v6.len()),
+            MemoryValue::from(v6_start),
+            MemoryValue::from(a9_start),
         ];
         memory.extend(outer_array.clone());
 
-        let input_array_value_types = vec![
-            HeapValueType::Simple,
-            HeapValueType::Simple, // size of following vector
-            HeapValueType::Vector { value_types: vec![HeapValueType::Simple] },
-            HeapValueType::Array { value_types: vec![HeapValueType::Simple], size: 1 },
+        let input_array_value_types: Vec<HeapValueType> = vec![
+            HeapValueType::field(),
+            HeapValueType::Simple(64), // size of following vector
+            HeapValueType::Vector { value_types: vec![HeapValueType::field()] },
+            HeapValueType::Array { value_types: vec![HeapValueType::field()], size: 1 },
         ];
 
         // memory address of the end of the above data structures
@@ -1666,19 +1739,24 @@ mod tests {
         let r_input = MemoryAddress::from(r_ptr);
         let r_output = MemoryAddress::from(r_ptr + 1);
 
-        let program = vec![
-            Opcode::CalldataCopy {
-                destination_address: MemoryAddress::from(0),
-                size: memory.len(),
-                offset: 0,
-            },
+        let program: Vec<_> = std::iter::once(Opcode::CalldataCopy {
+            destination_address: MemoryAddress::from(0),
+            size: memory.len(),
+            offset: 0,
+        })
+        .chain(memory.iter().enumerate().map(|(index, mem_value)| Opcode::Cast {
+            destination: MemoryAddress(index),
+            source: MemoryAddress(index),
+            bit_size: mem_value.bit_size,
+        }))
+        .chain(vec![
             // input = 0
-            Opcode::Const { destination: r_input, value: Value::from(outer_ptr), bit_size: 32 },
+            Opcode::Const { destination: r_input, value: (outer_ptr).into(), bit_size: 64 },
             // some_function(input)
             Opcode::ForeignCall {
                 function: "flat_sum".into(),
                 destinations: vec![ValueOrArray::MemoryAddress(r_output)],
-                destination_value_types: vec![HeapValueType::Simple],
+                destination_value_types: vec![HeapValueType::field()],
                 inputs: vec![ValueOrArray::HeapArray(HeapArray {
                     pointer: r_input,
                     size: outer_array.len(),
@@ -1688,9 +1766,13 @@ mod tests {
                     size: outer_array.len(),
                 }],
             },
-        ];
+        ])
+        .collect();
 
-        let mut vm = brillig_execute_and_get_vm(memory, &program);
+        let mut vm = brillig_execute_and_get_vm(
+            memory.into_iter().map(|mem_value| mem_value.value).collect(),
+            &program,
+        );
 
         // Check that VM is waiting
         assert_eq!(
@@ -1698,23 +1780,23 @@ mod tests {
             VMStatus::ForeignCallWait {
                 function: "flat_sum".into(),
                 inputs: vec![ForeignCallParam::Array(vec![
-                    Value::from(1u128),
-                    Value::from(2u128), // size of following vector
-                    Value::from(2u128),
-                    Value::from(3u128),
-                    Value::from(4u128),
-                    Value::from(5u128),
-                    Value::from(3u128), // size of following vector
-                    Value::from(6u128),
-                    Value::from(7u128),
-                    Value::from(8u128),
-                    Value::from(9u128),
+                    (1u128).into(),
+                    (2u128).into(), // size of following vector
+                    (2u128).into(),
+                    (3u128).into(),
+                    (4u128).into(),
+                    (5u128).into(),
+                    (3u128).into(), // size of following vector
+                    (6u128).into(),
+                    (7u128).into(),
+                    (8u128).into(),
+                    (9u128).into(),
                 ])],
             }
         );
 
         // Push result we're waiting for
-        vm.resolve_foreign_call(Value::from(45u128).into());
+        vm.resolve_foreign_call(FieldElement::from(45u128).into());
 
         // Resume VM
         brillig_execute(&mut vm);
@@ -1724,7 +1806,7 @@ mod tests {
 
         // Check result
         let result_value = vm.memory.read(r_output);
-        assert_eq!(result_value, Value::from(45u128));
+        assert_eq!(result_value, MemoryValue::from(FieldElement::from(45u128)));
 
         // Ensure the foreign call counter has been incremented
         assert_eq!(vm.foreign_call_counter, 1);
diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index d1c81447170..d563e13be2e 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -1,30 +1,182 @@
 use acir::{brillig::MemoryAddress, FieldElement};
 
-use crate::Value;
+pub const MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct MemoryValue {
+    pub value: FieldElement,
+    pub bit_size: u32,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum MemoryTypeError {
+    #[error("Bit size for value {value_bit_size} does not match the expected bit size {expected_bit_size}")]
+    MismatchedBitSize { value_bit_size: u32, expected_bit_size: u32 },
+}
+
+impl MemoryValue {
+    pub fn new(value: FieldElement, bit_size: u32) -> Self {
+        MemoryValue { value, bit_size }
+    }
+
+    pub fn new_checked(value: FieldElement, bit_size: u32) -> Option<Self> {
+        if value.num_bits() > bit_size {
+            return None;
+        }
+
+        Some(MemoryValue::new(value, bit_size))
+    }
+
+    pub fn new_field(value: FieldElement) -> Self {
+        MemoryValue { value, bit_size: FieldElement::max_num_bits() }
+    }
+
+    pub fn to_usize(&self) -> usize {
+        assert!(self.bit_size == MEMORY_ADDRESSING_BIT_SIZE, "value is not typed as brillig usize");
+        self.value.to_u128() as usize
+    }
+
+    pub fn expect_bit_size(&self, expected_bit_size: u32) -> Result<(), MemoryTypeError> {
+        if self.bit_size != expected_bit_size {
+            return Err(MemoryTypeError::MismatchedBitSize {
+                value_bit_size: self.bit_size,
+                expected_bit_size,
+            });
+        }
+        Ok(())
+    }
+}
+
+impl std::fmt::Display for MemoryValue {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+        let typ = match self.bit_size {
+            0 => "null".to_string(),
+            1 => "bool".to_string(),
+            _ if self.bit_size == FieldElement::max_num_bits() => "field".to_string(),
+            _ => format!("u{}", self.bit_size),
+        };
+        f.write_str(format!("{}: {}", self.value, typ).as_str())
+    }
+}
+
+impl Default for MemoryValue {
+    fn default() -> Self {
+        MemoryValue::new(FieldElement::zero(), 0)
+    }
+}
+
+impl From<FieldElement> for MemoryValue {
+    fn from(field: FieldElement) -> Self {
+        MemoryValue::new_field(field)
+    }
+}
+
+impl From<usize> for MemoryValue {
+    fn from(value: usize) -> Self {
+        MemoryValue::new(value.into(), MEMORY_ADDRESSING_BIT_SIZE)
+    }
+}
+
+impl From<u64> for MemoryValue {
+    fn from(value: u64) -> Self {
+        MemoryValue::new((value as u128).into(), 64)
+    }
+}
+
+impl From<u32> for MemoryValue {
+    fn from(value: u32) -> Self {
+        MemoryValue::new((value as u128).into(), 32)
+    }
+}
+
+impl From<u8> for MemoryValue {
+    fn from(value: u8) -> Self {
+        MemoryValue::new((value as u128).into(), 8)
+    }
+}
+
+impl From<bool> for MemoryValue {
+    fn from(value: bool) -> Self {
+        MemoryValue::new(value.into(), 1)
+    }
+}
+
+impl TryFrom<MemoryValue> for FieldElement {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_bit_size(FieldElement::max_num_bits())?;
+        Ok(memory_value.value)
+    }
+}
+
+impl TryFrom<MemoryValue> for u64 {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_bit_size(64)?;
+        Ok(memory_value.value.to_u128() as u64)
+    }
+}
+
+impl TryFrom<MemoryValue> for u32 {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_bit_size(32)?;
+        Ok(memory_value.value.to_u128() as u32)
+    }
+}
+
+impl TryFrom<MemoryValue> for u8 {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_bit_size(8)?;
+
+        Ok(memory_value.value.to_u128() as u8)
+    }
+}
+
+impl TryFrom<MemoryValue> for bool {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_bit_size(1)?;
+
+        if memory_value.value == FieldElement::zero() {
+            Ok(false)
+        } else if memory_value.value == FieldElement::one() {
+            Ok(true)
+        } else {
+            unreachable!("value typed as bool is greater than one")
+        }
+    }
+}
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct Memory {
     // Memory is a vector of values.
     // We grow the memory when values past the end are set, extending with 0s.
-    inner: Vec<Value>,
+    inner: Vec<MemoryValue>,
 }
 
 impl Memory {
     /// Gets the value at pointer
-    pub fn read(&self, ptr: MemoryAddress) -> Value {
-        self.inner.get(ptr.to_usize()).copied().unwrap_or(0_u128.into())
+    pub fn read(&self, ptr: MemoryAddress) -> MemoryValue {
+        self.inner.get(ptr.to_usize()).copied().unwrap_or_default()
     }
 
     pub fn read_ref(&self, ptr: MemoryAddress) -> MemoryAddress {
         MemoryAddress(self.read(ptr).to_usize())
     }
 
-    pub fn read_slice(&self, addr: MemoryAddress, len: usize) -> &[Value] {
+    pub fn read_slice(&self, addr: MemoryAddress, len: usize) -> &[MemoryValue] {
         &self.inner[addr.to_usize()..(addr.to_usize() + len)]
     }
 
     /// Sets the value at pointer `ptr` to `value`
-    pub fn write(&mut self, ptr: MemoryAddress, value: Value) {
+    pub fn write(&mut self, ptr: MemoryAddress, value: MemoryValue) {
         self.resize_to_fit(ptr.to_usize() + 1);
         self.inner[ptr.to_usize()] = value;
     }
@@ -33,17 +185,17 @@ impl Memory {
         // Calculate new memory size
         let new_size = std::cmp::max(self.inner.len(), size);
         // Expand memory to new size with default values if needed
-        self.inner.resize(new_size, Value::from(FieldElement::zero()));
+        self.inner.resize(new_size, MemoryValue::default());
     }
 
     /// Sets the values after pointer `ptr` to `values`
-    pub fn write_slice(&mut self, ptr: MemoryAddress, values: &[Value]) {
+    pub fn write_slice(&mut self, ptr: MemoryAddress, values: &[MemoryValue]) {
         self.resize_to_fit(ptr.to_usize() + values.len());
         self.inner[ptr.to_usize()..(ptr.to_usize() + values.len())].copy_from_slice(values);
     }
 
     /// Returns the values of the memory
-    pub fn values(&self) -> &[Value] {
+    pub fn values(&self) -> &[MemoryValue] {
         &self.inner
     }
 }
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 0fe450e6cb1..3ee6f9c21b9 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -4,7 +4,7 @@ mod utils;
 use transforms::{
     compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
     events::{generate_selector_impl, transform_events},
-    functions::{transform_function, transform_unconstrained, transform_vm_function},
+    functions::{transform_function, transform_unconstrained},
     note_interface::generate_note_interface_impl,
     storage::{
         assign_storage_slots, check_for_storage_definition, check_for_storage_implementation,
@@ -138,9 +138,15 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
         }
 
         // Apply transformations to the function based on collected attributes
-        if is_private || is_public {
+        if is_private || is_public || is_public_vm {
             transform_function(
-                if is_private { "Private" } else { "Public" },
+                if is_private {
+                    "Private"
+                } else if is_public_vm {
+                    "Avm"
+                } else {
+                    "Public"
+                },
                 func,
                 storage_defined,
                 is_initializer,
@@ -148,9 +154,6 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
                 is_internal,
             )?;
             has_transformed_module = true;
-        } else if is_public_vm {
-            transform_vm_function(func, storage_defined)?;
-            has_transformed_module = true;
         } else if storage_defined && func.def.is_unconstrained {
             transform_unconstrained(func);
             has_transformed_module = true;
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 855969732d0..9844abc30fe 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -35,6 +35,7 @@ pub fn transform_function(
     let context_name = format!("{}Context", ty);
     let inputs_name = format!("{}ContextInputs", ty);
     let return_type_name = format!("{}CircuitPublicInputs", ty);
+    let is_avm = ty == "Avm";
 
     // Add check that msg sender equals this address and flag function as internal
     if is_internal {
@@ -60,7 +61,11 @@ pub fn transform_function(
     }
 
     // Insert the context creation as the first action
-    let create_context = create_context(&context_name, &func.def.parameters)?;
+    let create_context = if !is_avm {
+        create_context(&context_name, &func.def.parameters)?
+    } else {
+        create_context_avm()?
+    };
     func.def.body.statements.splice(0..0, (create_context).iter().cloned());
 
     // Add the inputs to the params
@@ -68,12 +73,14 @@ pub fn transform_function(
     func.def.parameters.insert(0, input);
 
     // Abstract return types such that they get added to the kernel's return_values
-    if let Some(return_values) = abstract_return_values(func) {
-        // In case we are pushing return values to the context, we remove the statement that originated it
-        // This avoids running duplicate code, since blocks like if/else can be value returning statements
-        func.def.body.statements.pop();
-        // Add the new return statement
-        func.def.body.statements.push(return_values);
+    if !is_avm {
+        if let Some(return_values) = abstract_return_values(func) {
+            // In case we are pushing return values to the context, we remove the statement that originated it
+            // This avoids running duplicate code, since blocks like if/else can be value returning statements
+            func.def.body.statements.pop();
+            // Add the new return statement
+            func.def.body.statements.push(return_values);
+        }
     }
 
     // Before returning mark the contract as initialized
@@ -83,45 +90,29 @@ pub fn transform_function(
     }
 
     // Push the finish method call to the end of the function
-    let finish_def = create_context_finish();
-    func.def.body.statements.push(finish_def);
+    if !is_avm {
+        let finish_def = create_context_finish();
+        func.def.body.statements.push(finish_def);
+    }
 
-    let return_type = create_return_type(&return_type_name);
-    func.def.return_type = return_type;
-    func.def.return_visibility = Visibility::Public;
+    // The AVM doesn't need a return type yet.
+    if !is_avm {
+        let return_type = create_return_type(&return_type_name);
+        func.def.return_type = return_type;
+        func.def.return_visibility = Visibility::Public;
+    }
 
     // Distinct return types are only required for private functions
     // Public functions should have unconstrained auto-inferred
     match ty {
         "Private" => func.def.return_distinctness = Distinctness::Distinct,
-        "Public" => func.def.is_unconstrained = true,
+        "Public" | "Avm" => func.def.is_unconstrained = true,
         _ => (),
     }
 
     Ok(())
 }
 
-/// Transform a function to work with AVM bytecode
-pub fn transform_vm_function(
-    func: &mut NoirFunction,
-    storage_defined: bool,
-) -> Result<(), AztecMacroError> {
-    // Create access to storage
-    if storage_defined {
-        let storage = abstract_storage("public_vm", true);
-        func.def.body.statements.insert(0, storage);
-    }
-
-    // Push Avm context creation to the beginning of the function
-    let create_context = create_avm_context()?;
-    func.def.body.statements.insert(0, create_context);
-
-    // We want the function to be seen as a public function
-    func.def.is_unconstrained = true;
-
-    Ok(())
-}
-
 /// Transform Unconstrained
 ///
 /// Inserts the following code at the beginning of an unconstrained function
@@ -232,62 +223,62 @@ fn create_assert_initializer() -> Statement {
 /// ```noir
 /// #[aztec(private)]
 /// fn foo(structInput: SomeStruct, arrayInput: [u8; 10], fieldInput: Field) -> Field {
-///     // Create the hasher object
-///     let mut hasher = Hasher::new();
+///     // Create the bounded vec object
+///     let mut serialized_args = BoundedVec::new();
 ///
 ///     // struct inputs call serialize on them to add an array of fields
-///     hasher.add_multiple(structInput.serialize());
+///     serialized_args.extend_from_array(structInput.serialize());
 ///
-///     // Array inputs are iterated over and each element is added to the hasher (as a field)
+///     // Array inputs are iterated over and each element is added to the bounded vec (as a field)
 ///     for i in 0..arrayInput.len() {
-///         hasher.add(arrayInput[i] as Field);
+///         serialized_args.push(arrayInput[i] as Field);
 ///     }
-///     // Field inputs are added to the hasher
-///     hasher.add({ident});
+///     // Field inputs are added to the bounded vec
+///     serialized_args.push({ident});
 ///
 ///     // Create the context
 ///     // The inputs (injected by this `create_inputs`) and completed hash object are passed to the context
-///     let mut context = PrivateContext::new(inputs, hasher.hash());
+///     let mut context = PrivateContext::new(inputs, hash_args(serialized_args));
 /// }
 /// ```
 fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
     let mut injected_expressions: Vec<Statement> = vec![];
 
-    // `let mut hasher = Hasher::new();`
-    let let_hasher = mutable_assignment(
-        "hasher", // Assigned to
+    // `let mut serialized_args = BoundedVec::new();`
+    let let_serialized_args = mutable_assignment(
+        "serialized_args", // Assigned to
         call(
-            variable_path(chained_dep!("aztec", "hasher", "Hasher", "new")), // Path
-            vec![],                                                          // args
+            variable_path(chained_dep!("std", "collections", "bounded_vec", "BoundedVec", "new")), // Path
+            vec![], // args
         ),
     );
 
-    // Completes: `let mut hasher = Hasher::new();`
-    injected_expressions.push(let_hasher);
+    // Completes: `let mut serialized_args = BoundedVec::new();`
+    injected_expressions.push(let_serialized_args);
 
-    // Iterate over each of the function parameters, adding to them to the hasher
+    // Iterate over each of the function parameters, adding to them to the bounded vec
     for Param { pattern, typ, span, .. } in params {
         match pattern {
             Pattern::Identifier(identifier) => {
                 // Match the type to determine the padding to do
                 let unresolved_type = &typ.typ;
                 let expression = match unresolved_type {
-                    // `hasher.add_multiple({ident}.serialize())`
-                    UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier),
+                    // `serialized_args.extend_from_array({ident}.serialize())`
+                    UnresolvedTypeData::Named(..) => add_struct_to_serialized_args(identifier),
                     UnresolvedTypeData::Array(_, arr_type) => {
-                        add_array_to_hasher(identifier, arr_type)
+                        add_array_to_serialized_args(identifier, arr_type)
                     }
-                    // `hasher.add({ident})`
-                    UnresolvedTypeData::FieldElement => add_field_to_hasher(identifier),
-                    // Add the integer to the hasher, casted to a field
-                    // `hasher.add({ident} as Field)`
+                    // `serialized_args.push({ident})`
+                    UnresolvedTypeData::FieldElement => add_field_to_serialized_args(identifier),
+                    // Add the integer to the serialized args, casted to a field
+                    // `serialized_args.push({ident} as Field)`
                     UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
-                        add_cast_to_hasher(identifier)
+                        add_cast_to_serialized_args(identifier)
                     }
                     UnresolvedTypeData::String(..) => {
                         let (var_bytes, id) = str_to_bytes(identifier);
                         injected_expressions.push(var_bytes);
-                        add_array_to_hasher(
+                        add_array_to_serialized_args(
                             &id,
                             &UnresolvedType {
                                 typ: UnresolvedTypeData::Integer(
@@ -313,11 +304,10 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
 
     // Create the inputs to the context
     let inputs_expression = variable("inputs");
-    // `hasher.hash()`
-    let hash_call = method_call(
-        variable("hasher"), // variable
-        "hash",             // method name
-        vec![],             // args
+    // `hash_args(serialized_args)`
+    let hash_call = call(
+        variable_path(chained_dep!("aztec", "hash", "hash_args")), // variable
+        vec![variable("serialized_args")],                         // args
     );
 
     let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
@@ -336,33 +326,36 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
     Ok(injected_expressions)
 }
 
-/// Creates an mutable avm context
+/// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
+/// appended into the args hash object.
 ///
+/// The replaced code:
 /// ```noir
-/// /// Before
 /// #[aztec(public-vm)]
-/// fn foo() -> Field {
-///   let mut context = aztec::context::AVMContext::new();
-///   let timestamp = context.timestamp();
-///   // ...
-/// }
-///
-/// /// After
-/// #[aztec(private)]
-/// fn foo() -> Field {
-///     let mut timestamp = context.timestamp();
-///     // ...
+/// fn foo(inputs: AvmContextInputs, ...) -> Field {
+///     let mut context = AvmContext::new(inputs);
 /// }
-fn create_avm_context() -> Result<Statement, AztecMacroError> {
+/// ```
+fn create_context_avm() -> Result<Vec<Statement>, AztecMacroError> {
+    let mut injected_expressions: Vec<Statement> = vec![];
+
+    // Create the inputs to the context
+    let ty = "AvmContext";
+    let inputs_expression = variable("inputs");
+    let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
+
+    // let mut context = {ty}::new(inputs, hash);
     let let_context = mutable_assignment(
         "context", // Assigned to
         call(
-            variable_path(chained_dep!("aztec", "context", "AVMContext", "new")), // Path
-            vec![],                                                               // args
+            variable_path(chained_dep!("aztec", "context", &path_snippet, ty, "new")), // Path
+            vec![inputs_expression],                                                   // args
         ),
     );
+    injected_expressions.push(let_context);
 
-    Ok(let_context)
+    // Return all expressions that will be injected by the hasher
+    Ok(injected_expressions)
 }
 
 /// Abstract Return Type
@@ -598,11 +591,11 @@ fn create_context_finish() -> Statement {
 }
 
 //
-//                 Methods to create hasher inputs
+//                 Methods to create hash_args inputs
 //
 
-fn add_struct_to_hasher(identifier: &Ident) -> Statement {
-    // If this is a struct, we call serialize and add the array to the hasher
+fn add_struct_to_serialized_args(identifier: &Ident) -> Statement {
+    // If this is a struct, we call serialize and add the array to the serialized args
     let serialized_call = method_call(
         variable_path(path(identifier.clone())), // variable
         "serialize",                             // method name
@@ -610,9 +603,9 @@ fn add_struct_to_hasher(identifier: &Ident) -> Statement {
     );
 
     make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),    // variable
-        "add_multiple",        // method name
-        vec![serialized_call], // args
+        variable("serialized_args"), // variable
+        "extend_from_array",         // method name
+        vec![serialized_call],       // args
     )))
 }
 
@@ -632,7 +625,7 @@ fn str_to_bytes(identifier: &Ident) -> (Statement, Ident) {
 }
 
 fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
+    // If this is an array of primitive types (integers / fields) we can add them each to the serialized args
     // casted to a field
     let span = var.span;
 
@@ -644,7 +637,8 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
     );
 
     // What will be looped over
-    // - `hasher.add({ident}[i] as Field)`
+
+    // - `serialized_args.push({ident}[i] as Field)`
     let for_loop_block =
         expression(ExpressionKind::Block(BlockExpression { statements: loop_body }));
 
@@ -663,66 +657,66 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
     }))
 }
 
-fn add_array_to_hasher(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
+fn add_array_to_serialized_args(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
+    // If this is an array of primitive types (integers / fields) we can add them each to the serialized_args
     // casted to a field
 
     // Wrap in the semi thing - does that mean ended with semi colon?
-    // `hasher.add({ident}[i] as Field)`
+    // `serialized_args.push({ident}[i] as Field)`
 
     let arr_index = index_array(identifier.clone(), "i");
-    let (add_expression, hasher_method_name) = match arr_type.typ {
+    let (add_expression, vec_method_name) = match arr_type.typ {
         UnresolvedTypeData::Named(..) => {
-            let hasher_method_name = "add_multiple".to_owned();
+            let vec_method_name = "extend_from_array".to_owned();
             let call = method_call(
                 // All serialize on each element
                 arr_index,   // variable
                 "serialize", // method name
                 vec![],      // args
             );
-            (call, hasher_method_name)
+            (call, vec_method_name)
         }
         _ => {
-            let hasher_method_name = "add".to_owned();
+            let vec_method_name = "push".to_owned();
             let call = cast(
                 arr_index,                        // lhs - `ident[i]`
                 UnresolvedTypeData::FieldElement, // cast to - `as Field`
             );
-            (call, hasher_method_name)
+            (call, vec_method_name)
         }
     };
 
     let block_statement = make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),  // variable
-        &hasher_method_name, // method name
+        variable("serialized_args"), // variable
+        &vec_method_name,            // method name
         vec![add_expression],
     )));
 
     create_loop_over(variable_ident(identifier.clone()), vec![block_statement])
 }
 
-fn add_field_to_hasher(identifier: &Ident) -> Statement {
-    // `hasher.add({ident})`
+fn add_field_to_serialized_args(identifier: &Ident) -> Statement {
+    // `serialized_args.push({ident})`
     let ident = variable_path(path(identifier.clone()));
     make_statement(StatementKind::Semi(method_call(
-        variable("hasher"), // variable
-        "add",              // method name
-        vec![ident],        // args
+        variable("serialized_args"), // variable
+        "push",                      // method name
+        vec![ident],                 // args
     )))
 }
 
-fn add_cast_to_hasher(identifier: &Ident) -> Statement {
-    // `hasher.add({ident} as Field)`
+fn add_cast_to_serialized_args(identifier: &Ident) -> Statement {
+    // `serialized_args.push({ident} as Field)`
     // `{ident} as Field`
     let cast_operation = cast(
         variable_path(path(identifier.clone())), // lhs
         UnresolvedTypeData::FieldElement,        // rhs
     );
 
-    // `hasher.add({ident} as Field)`
+    // `serialized_args.push({ident} as Field)`
     make_statement(StatementKind::Semi(method_call(
-        variable("hasher"),   // variable
-        "add",                // method name
-        vec![cast_operation], // args
+        variable("serialized_args"), // variable
+        "push",                      // method name
+        vec![cast_operation],        // args
     )))
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 36e5c99a2ca..874be06b86c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -1,7 +1,7 @@
 use acvm::acir::{brillig::BlackBoxOp, BlackBoxFunc};
 
 use crate::brillig::brillig_ir::{
-    brillig_variable::{BrilligVariable, BrilligVector},
+    brillig_variable::{BrilligVariable, BrilligVector, SingleAddrVariable},
     BrilligContext,
 };
 
@@ -56,17 +56,23 @@ pub(crate) fn convert_black_box_call(
         }
         BlackBoxFunc::Keccak256 => {
             if let (
-                [message, BrilligVariable::SingleAddr(array_size)],
+                [message, BrilligVariable::SingleAddr(message_size)],
                 [BrilligVariable::BrilligArray(result_array)],
             ) = (function_arguments, function_results)
             {
                 let mut message_vector = convert_array_or_vector(brillig_context, message, bb_func);
-                message_vector.size = array_size.address;
+                let message_size_as_usize =
+                    SingleAddrVariable::new_usize(brillig_context.allocate_register());
+                // Message_size is not usize
+                brillig_context.cast_instruction(message_size_as_usize, *message_size);
+
+                message_vector.size = message_size_as_usize.address;
 
                 brillig_context.black_box_op_instruction(BlackBoxOp::Keccak256 {
                     message: message_vector.to_heap_vector(),
                     output: result_array.to_heap_array(),
                 });
+                brillig_context.deallocate_single_addr(message_size_as_usize);
             } else {
                 unreachable!("ICE: Keccak256 expects message, message size and result array")
             }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 94e81d02053..cf2501ab1c0 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -514,7 +514,7 @@ impl<'block> BrilligBlock<'block> {
                         .extract_vector();
 
                     // Update the user-facing slice length
-                    self.brillig_context.mov_instruction(target_len.address, limb_count.address);
+                    self.brillig_context.cast_instruction(target_len, limb_count);
 
                     self.brillig_context.codegen_to_radix(
                         source,
@@ -522,6 +522,7 @@ impl<'block> BrilligBlock<'block> {
                         radix,
                         limb_count,
                         matches!(endianness, Endian::Big),
+                        8,
                     );
                 }
                 Value::Intrinsic(Intrinsic::ToBits(endianness)) => {
@@ -554,7 +555,7 @@ impl<'block> BrilligBlock<'block> {
                     let radix = self.brillig_context.make_constant_instruction(2_usize.into(), 32);
 
                     // Update the user-facing slice length
-                    self.brillig_context.mov_instruction(target_len.address, limb_count.address);
+                    self.brillig_context.cast_instruction(target_len, limb_count);
 
                     self.brillig_context.codegen_to_radix(
                         source,
@@ -562,6 +563,7 @@ impl<'block> BrilligBlock<'block> {
                         radix,
                         limb_count,
                         matches!(endianness, Endian::Big),
+                        1,
                     );
 
                     self.brillig_context.deallocate_single_addr(radix);
@@ -654,7 +656,7 @@ impl<'block> BrilligBlock<'block> {
                     // Create a field constant with the max
                     let max = BigUint::from(2_u128).pow(*max_bit_size) - BigUint::from(1_u128);
                     let right = self.brillig_context.make_constant_instruction(
-                        FieldElement::from_be_bytes_reduce(&max.to_bytes_be()).into(),
+                        FieldElement::from_be_bytes_reduce(&max.to_bytes_be()),
                         FieldElement::max_num_bits(),
                     );
 
@@ -1584,7 +1586,7 @@ impl<'block> BrilligBlock<'block> {
                         self.variables.allocate_constant(self.brillig_context, value_id, dfg);
 
                     self.brillig_context
-                        .const_instruction(new_variable.extract_single_addr(), (*constant).into());
+                        .const_instruction(new_variable.extract_single_addr(), *constant);
                     new_variable
                 }
             }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
index dc9900daee3..892e82d771a 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
@@ -2,7 +2,10 @@ use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 use crate::{
     brillig::brillig_ir::{
-        brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
+        brillig_variable::{
+            get_bit_size_from_ssa_type, BrilligArray, BrilligVariable, BrilligVector,
+            SingleAddrVariable,
+        },
         BrilligContext,
     },
     ssa::ir::{
@@ -13,7 +16,7 @@ use crate::{
     },
 };
 
-use super::brillig_fn::{get_bit_size_from_ssa_type, FunctionContext};
+use super::brillig_fn::FunctionContext;
 
 #[derive(Debug, Default)]
 pub(crate) struct BlockVariables {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
index 26b21e918ff..15a2a531e78 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
@@ -1,5 +1,5 @@
 use acvm::{
-    acir::brillig::{BinaryFieldOp, BinaryIntOp, MemoryAddress, Opcode as BrilligOpcode, Value},
+    acir::brillig::{BinaryFieldOp, BinaryIntOp, MemoryAddress, Opcode as BrilligOpcode},
     FieldElement,
 };
 
@@ -16,18 +16,32 @@ pub(crate) fn directive_invert() -> GeneratedBrillig {
     // We store the result in this register too.
     let input = MemoryAddress::from(0);
     let one_const = MemoryAddress::from(1);
+    let zero_const = MemoryAddress::from(2);
+    let input_is_zero = MemoryAddress::from(3);
     // Location of the stop opcode
-    let stop_location = 3;
+    let stop_location = 6;
 
     GeneratedBrillig {
         byte_code: vec![
             BrilligOpcode::CalldataCopy { destination_address: input, size: 1, offset: 0 },
+            // Put value zero in register (2)
+            BrilligOpcode::Const {
+                destination: zero_const,
+                value: FieldElement::from(0_usize),
+                bit_size: FieldElement::max_num_bits(),
+            },
+            BrilligOpcode::BinaryFieldOp {
+                op: BinaryFieldOp::Equals,
+                lhs: input,
+                rhs: zero_const,
+                destination: input_is_zero,
+            },
             // If the input is zero, then we jump to the stop opcode
-            BrilligOpcode::JumpIfNot { condition: input, location: stop_location },
+            BrilligOpcode::JumpIf { condition: input_is_zero, location: stop_location },
             // Put value one in register (1)
             BrilligOpcode::Const {
                 destination: one_const,
-                value: Value::from(1_usize),
+                value: FieldElement::from(1_usize),
                 bit_size: FieldElement::max_num_bits(),
             },
             // Divide 1 by the input, and set the result of the division into register (0)
@@ -53,9 +67,12 @@ pub(crate) fn directive_invert() -> GeneratedBrillig {
 ///    (a/b, a-a/b*b)
 /// }
 /// ```
-pub(crate) fn directive_quotient(bit_size: u32) -> GeneratedBrillig {
+pub(crate) fn directive_quotient(mut bit_size: u32) -> GeneratedBrillig {
     // `a` is (0) (i.e register index 0)
     // `b` is (1)
+    if bit_size > FieldElement::max_num_bits() {
+        bit_size = FieldElement::max_num_bits();
+    }
     GeneratedBrillig {
         byte_code: vec![
             BrilligOpcode::CalldataCopy {
@@ -63,6 +80,16 @@ pub(crate) fn directive_quotient(bit_size: u32) -> GeneratedBrillig {
                 size: 2,
                 offset: 0,
             },
+            BrilligOpcode::Cast {
+                destination: MemoryAddress(0),
+                source: MemoryAddress(0),
+                bit_size,
+            },
+            BrilligOpcode::Cast {
+                destination: MemoryAddress(1),
+                source: MemoryAddress(1),
+                bit_size,
+            },
             //q = a/b is set into register (2)
             BrilligOpcode::BinaryIntOp {
                 op: BinaryIntOp::Div,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index 42765d10ce2..92027026ce8 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -3,8 +3,8 @@ use iter_extended::vecmap;
 use crate::{
     brillig::brillig_ir::{
         artifact::{BrilligParameter, Label},
-        brillig_variable::BrilligVariable,
-        BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+        brillig_variable::{get_bit_size_from_ssa_type, BrilligVariable},
+        BrilligContext,
     },
     ssa::ir::{
         basic_block::BasicBlockId,
@@ -112,15 +112,3 @@ impl FunctionContext {
             .collect()
     }
 }
-
-pub(crate) fn get_bit_size_from_ssa_type(typ: &Type) -> u32 {
-    match typ {
-        Type::Numeric(num_type) => num_type.bit_size(),
-        Type::Reference(_) => BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-        // NB. function references are converted to a constant when
-        // translating from SSA to Brillig (to allow for debugger
-        // instrumentation to work properly)
-        Type::Function => 32,
-        _ => unreachable!("ICE bit size not on a non numeric type"),
-    }
-}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 98dd17ce080..e42b2787f73 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -354,7 +354,7 @@ impl<'block> BrilligBlock<'block> {
 mod tests {
     use std::vec;
 
-    use acvm::acir::brillig::Value;
+    use acvm::FieldElement;
 
     use crate::brillig::brillig_gen::brillig_block::BrilligBlock;
     use crate::brillig::brillig_gen::brillig_block_variables::BlockVariables;
@@ -400,9 +400,9 @@ mod tests {
     fn test_slice_push_operation() {
         fn test_case_push(
             push_back: bool,
-            array: Vec<Value>,
-            item_to_push: Value,
-            expected_return: Vec<Value>,
+            array: Vec<FieldElement>,
+            item_to_push: FieldElement,
+            expected_return: Vec<FieldElement>,
         ) {
             let arguments = vec![
                 BrilligParameter::Array(
@@ -462,44 +462,65 @@ mod tests {
                 create_and_run_vm(array.into_iter().chain(vec![item_to_push]).collect(), &bytecode);
             assert_eq!(return_data_size, expected_return.len());
             assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())],
+                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
+                    .iter()
+                    .map(|mem_val| mem_val.value)
+                    .collect::<Vec<_>>(),
                 expected_return
             );
         }
 
         test_case_push(
             true,
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(27_usize),
             vec![
-                Value::from(1_usize),
-                Value::from(2_usize),
-                Value::from(3_usize),
-                Value::from(27_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
             ],
+            FieldElement::from(27_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+                FieldElement::from(27_usize),
+            ],
+        );
+        test_case_push(
+            true,
+            vec![],
+            FieldElement::from(27_usize),
+            vec![FieldElement::from(27_usize)],
         );
-        test_case_push(true, vec![], Value::from(27_usize), vec![Value::from(27_usize)]);
         test_case_push(
             false,
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(27_usize),
             vec![
-                Value::from(27_usize),
-                Value::from(1_usize),
-                Value::from(2_usize),
-                Value::from(3_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(27_usize),
+            vec![
+                FieldElement::from(27_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
             ],
         );
-        test_case_push(false, vec![], Value::from(27_usize), vec![Value::from(27_usize)]);
+        test_case_push(
+            false,
+            vec![],
+            FieldElement::from(27_usize),
+            vec![FieldElement::from(27_usize)],
+        );
     }
 
     #[test]
     fn test_slice_pop_back_operation() {
         fn test_case_pop(
             pop_back: bool,
-            array: Vec<Value>,
-            expected_return_array: Vec<Value>,
-            expected_return_item: Value,
+            array: Vec<FieldElement>,
+            expected_return_array: Vec<FieldElement>,
+            expected_return_item: FieldElement,
         ) {
             let arguments = vec![BrilligParameter::Array(
                 vec![BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE)],
@@ -566,33 +587,44 @@ mod tests {
             assert_eq!(return_data_size, expected_return.len());
 
             assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())],
+                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
+                    .iter()
+                    .map(|mem_val| mem_val.value)
+                    .collect::<Vec<_>>(),
                 expected_return
             );
         }
 
         test_case_pop(
             true,
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            vec![Value::from(1_usize), Value::from(2_usize)],
-            Value::from(3_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            vec![FieldElement::from(1_usize), FieldElement::from(2_usize)],
+            FieldElement::from(3_usize),
         );
-        test_case_pop(true, vec![Value::from(1_usize)], vec![], Value::from(1_usize));
+        test_case_pop(true, vec![FieldElement::from(1_usize)], vec![], FieldElement::from(1_usize));
         test_case_pop(
             false,
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            vec![Value::from(2_usize), Value::from(3_usize)],
-            Value::from(1_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            vec![FieldElement::from(2_usize), FieldElement::from(3_usize)],
+            FieldElement::from(1_usize),
         );
     }
 
     #[test]
     fn test_slice_insert_operation() {
         fn test_case_insert(
-            array: Vec<Value>,
-            item: Value,
-            index: Value,
-            expected_return: Vec<Value>,
+            array: Vec<FieldElement>,
+            item: FieldElement,
+            index: FieldElement,
+            expected_return: Vec<FieldElement>,
         ) {
             let arguments = vec![
                 BrilligParameter::Array(
@@ -651,71 +683,90 @@ mod tests {
             assert_eq!(return_data_size, expected_return.len());
 
             assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())],
+                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
+                    .iter()
+                    .map(|mem_val| mem_val.value)
+                    .collect::<Vec<_>>(),
                 expected_return
             );
         }
 
         test_case_insert(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(27_usize),
-            Value::from(1_usize),
             vec![
-                Value::from(1_usize),
-                Value::from(27_usize),
-                Value::from(2_usize),
-                Value::from(3_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(27_usize),
+            FieldElement::from(1_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(27_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
             ],
         );
 
         test_case_insert(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(27_usize),
-            Value::from(0_usize),
             vec![
-                Value::from(27_usize),
-                Value::from(1_usize),
-                Value::from(2_usize),
-                Value::from(3_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(27_usize),
+            FieldElement::from(0_usize),
+            vec![
+                FieldElement::from(27_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
             ],
         );
         test_case_insert(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(27_usize),
-            Value::from(2_usize),
             vec![
-                Value::from(1_usize),
-                Value::from(2_usize),
-                Value::from(27_usize),
-                Value::from(3_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(27_usize),
+            FieldElement::from(2_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(27_usize),
+                FieldElement::from(3_usize),
             ],
         );
         test_case_insert(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(27_usize),
-            Value::from(3_usize),
             vec![
-                Value::from(1_usize),
-                Value::from(2_usize),
-                Value::from(3_usize),
-                Value::from(27_usize),
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(27_usize),
+            FieldElement::from(3_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+                FieldElement::from(27_usize),
             ],
         );
         test_case_insert(
             vec![],
-            Value::from(27_usize),
-            Value::from(0_usize),
-            vec![Value::from(27_usize)],
+            FieldElement::from(27_usize),
+            FieldElement::from(0_usize),
+            vec![FieldElement::from(27_usize)],
         );
     }
 
     #[test]
     fn test_slice_remove_operation() {
         fn test_case_remove(
-            array: Vec<Value>,
-            index: Value,
-            expected_array: Vec<Value>,
-            expected_removed_item: Value,
+            array: Vec<FieldElement>,
+            index: FieldElement,
+            expected_array: Vec<FieldElement>,
+            expected_removed_item: FieldElement,
         ) {
             let arguments = vec![
                 BrilligParameter::Array(
@@ -784,36 +835,51 @@ mod tests {
             assert_eq!(return_data_size, expected_return.len());
 
             assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())],
+                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
+                    .iter()
+                    .map(|mem_val| mem_val.value)
+                    .collect::<Vec<_>>(),
                 expected_return
             );
         }
 
         test_case_remove(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(0_usize),
-            vec![Value::from(2_usize), Value::from(3_usize)],
-            Value::from(1_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(0_usize),
+            vec![FieldElement::from(2_usize), FieldElement::from(3_usize)],
+            FieldElement::from(1_usize),
         );
 
         test_case_remove(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(1_usize),
-            vec![Value::from(1_usize), Value::from(3_usize)],
-            Value::from(2_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(1_usize),
+            vec![FieldElement::from(1_usize), FieldElement::from(3_usize)],
+            FieldElement::from(2_usize),
         );
 
         test_case_remove(
-            vec![Value::from(1_usize), Value::from(2_usize), Value::from(3_usize)],
-            Value::from(2_usize),
-            vec![Value::from(1_usize), Value::from(2_usize)],
-            Value::from(3_usize),
+            vec![
+                FieldElement::from(1_usize),
+                FieldElement::from(2_usize),
+                FieldElement::from(3_usize),
+            ],
+            FieldElement::from(2_usize),
+            vec![FieldElement::from(1_usize), FieldElement::from(2_usize)],
+            FieldElement::from(3_usize),
         );
         test_case_remove(
-            vec![Value::from(1_usize)],
-            Value::from(0_usize),
+            vec![FieldElement::from(1_usize)],
+            FieldElement::from(0_usize),
             vec![],
-            Value::from(1_usize),
+            FieldElement::from(1_usize),
         );
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 9138f57083a..e5c731be679 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -122,7 +122,7 @@ pub(crate) mod tests {
     use std::vec;
 
     use acvm::acir::brillig::{
-        ForeignCallParam, ForeignCallResult, HeapVector, MemoryAddress, Value, ValueOrArray,
+        ForeignCallParam, ForeignCallResult, HeapVector, MemoryAddress, ValueOrArray,
     };
     use acvm::brillig_vm::brillig::HeapValueType;
     use acvm::brillig_vm::{VMStatus, VM};
@@ -205,7 +205,7 @@ pub(crate) mod tests {
     }
 
     pub(crate) fn create_and_run_vm(
-        calldata: Vec<Value>,
+        calldata: Vec<FieldElement>,
         bytecode: &[BrilligOpcode],
     ) -> (VM<'_, DummyBlackBoxSolver>, usize, usize) {
         let mut vm = VM::new(calldata, bytecode, vec![], &DummyBlackBoxSolver);
@@ -234,20 +234,20 @@ pub(crate) mod tests {
         let mut context = BrilligContext::new(true);
         let r_stack = ReservedRegisters::free_memory_pointer();
         // Start stack pointer at 0
-        context.usize_const_instruction(r_stack, Value::from(ReservedRegisters::len() + 3));
+        context.usize_const_instruction(r_stack, FieldElement::from(ReservedRegisters::len() + 3));
         let r_input_size = MemoryAddress::from(ReservedRegisters::len());
         let r_array_ptr = MemoryAddress::from(ReservedRegisters::len() + 1);
         let r_output_size = MemoryAddress::from(ReservedRegisters::len() + 2);
         let r_equality = MemoryAddress::from(ReservedRegisters::len() + 3);
-        context.usize_const_instruction(r_input_size, Value::from(12_usize));
+        context.usize_const_instruction(r_input_size, FieldElement::from(12_usize));
         // copy our stack frame to r_array_ptr
         context.mov_instruction(r_array_ptr, r_stack);
         context.foreign_call_instruction(
             "make_number_sequence".into(),
             &[ValueOrArray::MemoryAddress(r_input_size)],
-            &[HeapValueType::Simple],
+            &[HeapValueType::Simple(32)],
             &[ValueOrArray::HeapVector(HeapVector { pointer: r_stack, size: r_output_size })],
-            &[HeapValueType::Vector { value_types: vec![HeapValueType::Simple] }],
+            &[HeapValueType::Vector { value_types: vec![HeapValueType::Simple(32)] }],
         );
         // push stack frame by r_returned_size
         context.memory_op_instruction(r_stack, r_output_size, r_stack, BrilligBinaryOp::Add);
@@ -266,8 +266,9 @@ pub(crate) mod tests {
 
         context.stop_instruction();
 
-        let bytecode = context.artifact().finish().byte_code;
-        let number_sequence: Vec<Value> = (0_usize..12_usize).map(Value::from).collect();
+        let bytecode: Vec<BrilligOpcode> = context.artifact().finish().byte_code;
+        let number_sequence: Vec<FieldElement> =
+            (0_usize..12_usize).map(FieldElement::from).collect();
         let mut vm = VM::new(
             vec![],
             &bytecode,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
index b415421dd92..bbfdbb69f7c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
@@ -125,7 +125,9 @@ impl BrilligVariable {
 
 pub(crate) fn type_to_heap_value_type(typ: &Type) -> HeapValueType {
     match typ {
-        Type::Numeric(_) | Type::Reference(_) | Type::Function => HeapValueType::Simple,
+        Type::Numeric(_) | Type::Reference(_) | Type::Function => {
+            HeapValueType::Simple(get_bit_size_from_ssa_type(typ))
+        }
         Type::Array(elem_type, size) => HeapValueType::Array {
             value_types: elem_type.as_ref().iter().map(type_to_heap_value_type).collect(),
             size: typ.element_size() * size,
@@ -135,3 +137,14 @@ pub(crate) fn type_to_heap_value_type(typ: &Type) -> HeapValueType {
         },
     }
 }
+
+pub(crate) fn get_bit_size_from_ssa_type(typ: &Type) -> u32 {
+    match typ {
+        Type::Reference(_) => BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+        // NB. function references are converted to a constant when
+        // translating from SSA to Brillig (to allow for debugger
+        // instrumentation to work properly)
+        Type::Function => 32,
+        typ => typ.bit_size(),
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
index 248a304d820..4ef279bd532 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
@@ -1,4 +1,4 @@
-use acvm::acir::brillig::{MemoryAddress, Value};
+use acvm::{acir::brillig::MemoryAddress, FieldElement};
 
 use super::{instructions::BrilligBinaryOp, BrilligContext};
 
@@ -21,7 +21,7 @@ impl BrilligContext {
         op: BrilligBinaryOp,
         constant: usize,
     ) {
-        let const_register = self.make_usize_constant_instruction(Value::from(constant));
+        let const_register = self.make_usize_constant_instruction(FieldElement::from(constant));
         self.memory_op_instruction(operand, const_register.address, destination, op);
         // Mark as no longer used for this purpose, frees for reuse
         self.deallocate_single_addr(const_register);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
index be262d9dee7..ab756217bcd 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -39,6 +39,7 @@ impl BrilligContext {
         radix: SingleAddrVariable,
         limb_count: SingleAddrVariable,
         big_endian: bool,
+        limb_bit_size: u32,
     ) {
         assert!(source_field.bit_size == FieldElement::max_num_bits());
         assert!(radix.bit_size == 32);
@@ -55,19 +56,23 @@ impl BrilligContext {
             SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
         self.mov_instruction(shifted_field.address, source_field.address);
 
-        let modulus_field =
+        let limb_field =
             SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
 
+        let limb_casted = SingleAddrVariable::new(self.allocate_register(), limb_bit_size);
+
         self.codegen_loop(target_vector.size, |ctx, iterator_register| {
             // Compute the modulus
             ctx.binary_instruction(
                 shifted_field,
                 radix_as_field,
-                modulus_field,
+                limb_field,
                 BrilligBinaryOp::Modulo,
             );
+            // Cast it
+            ctx.cast_instruction(limb_casted, limb_field);
             // Write it
-            ctx.codegen_array_set(target_vector.pointer, iterator_register, modulus_field.address);
+            ctx.codegen_array_set(target_vector.pointer, iterator_register, limb_casted.address);
             // Integer div the field
             ctx.binary_instruction(
                 shifted_field,
@@ -79,7 +84,8 @@ impl BrilligContext {
 
         // Deallocate our temporary registers
         self.deallocate_single_addr(shifted_field);
-        self.deallocate_single_addr(modulus_field);
+        self.deallocate_single_addr(limb_field);
+        self.deallocate_single_addr(limb_casted);
         self.deallocate_single_addr(radix_as_field);
 
         if big_endian {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 5611905697c..4ca1144b6a4 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -2,7 +2,10 @@
 
 use super::BrilligBinaryOp;
 use crate::brillig::brillig_ir::ReservedRegisters;
-use acvm::acir::brillig::{BlackBoxOp, HeapArray, HeapVector, MemoryAddress, Value, ValueOrArray};
+use acvm::{
+    acir::brillig::{BlackBoxOp, HeapArray, HeapVector, MemoryAddress, ValueOrArray},
+    FieldElement,
+};
 
 /// Trait for converting values into debug-friendly strings.
 trait DebugToString {
@@ -66,9 +69,9 @@ impl DebugToString for BrilligBinaryOp {
     }
 }
 
-impl DebugToString for Value {
+impl DebugToString for FieldElement {
     fn debug_to_string(&self) -> String {
-        self.to_usize().to_string()
+        self.to_string()
     }
 }
 
@@ -167,7 +170,7 @@ impl DebugShow {
     }
 
     /// Stores the value of `constant` in the `result` register
-    pub(crate) fn const_instruction(&self, result: MemoryAddress, constant: Value) {
+    pub(crate) fn const_instruction(&self, result: MemoryAddress, constant: FieldElement) {
         debug_println!(self.enable_debug_trace, "  CONST {} = {}", result, constant);
     }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 14c4ada8606..1d823ded718 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -453,7 +453,8 @@ impl BrilligContext {
 
 #[cfg(test)]
 mod tests {
-    use acvm::brillig_vm::brillig::Value;
+
+    use acvm::FieldElement;
 
     use crate::brillig::brillig_ir::{
         artifact::BrilligParameter,
@@ -464,12 +465,12 @@ mod tests {
     #[test]
     fn entry_point_with_nested_array_parameter() {
         let calldata = vec![
-            Value::from(1_usize),
-            Value::from(2_usize),
-            Value::from(3_usize),
-            Value::from(4_usize),
-            Value::from(5_usize),
-            Value::from(6_usize),
+            FieldElement::from(1_usize),
+            FieldElement::from(2_usize),
+            FieldElement::from(3_usize),
+            FieldElement::from(4_usize),
+            FieldElement::from(5_usize),
+            FieldElement::from(6_usize),
         ];
         let arguments = vec![BrilligParameter::Array(
             vec![
@@ -496,18 +497,18 @@ mod tests {
         let (vm, return_data_offset, return_data_size) =
             create_and_run_vm(calldata.clone(), &bytecode);
         assert_eq!(return_data_size, 1, "Return data size is incorrect");
-        assert_eq!(vm.get_memory()[return_data_offset], Value::from(1_usize));
+        assert_eq!(vm.get_memory()[return_data_offset].value, FieldElement::from(1_usize));
     }
 
     #[test]
     fn entry_point_with_nested_array_return() {
         let flattened_array = vec![
-            Value::from(1_usize),
-            Value::from(2_usize),
-            Value::from(3_usize),
-            Value::from(4_usize),
-            Value::from(5_usize),
-            Value::from(6_usize),
+            FieldElement::from(1_usize),
+            FieldElement::from(2_usize),
+            FieldElement::from(3_usize),
+            FieldElement::from(4_usize),
+            FieldElement::from(5_usize),
+            FieldElement::from(6_usize),
         ];
         let array_param = BrilligParameter::Array(
             vec![
@@ -536,7 +537,10 @@ mod tests {
         let memory = vm.get_memory();
 
         assert_eq!(
-            memory[return_data_pointer..(return_data_pointer + flattened_array.len())],
+            memory[return_data_pointer..(return_data_pointer + flattened_array.len())]
+                .iter()
+                .map(|mem_val| mem_val.value)
+                .collect::<Vec<_>>(),
             flattened_array
         );
         assert_eq!(return_data_size, flattened_array.len());
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 99fb4c89f64..f305eb81b01 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -1,7 +1,7 @@
 use acvm::{
     acir::brillig::{
         BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapValueType, MemoryAddress,
-        Opcode as BrilligOpcode, Value, ValueOrArray,
+        Opcode as BrilligOpcode, ValueOrArray,
     },
     FieldElement,
 };
@@ -43,7 +43,7 @@ impl BrilligContext {
         // Compile !x as ((-1) - x)
         let u_max = FieldElement::from(2_i128).pow(&FieldElement::from(input.bit_size as i128))
             - FieldElement::one();
-        let max = self.make_constant(Value::from(u_max), input.bit_size);
+        let max = self.make_constant(u_max, input.bit_size);
 
         self.binary(max, input, result, BrilligBinaryOp::Sub);
         self.deallocate_single_addr(max);
@@ -397,21 +397,23 @@ impl BrilligContext {
     }
 
     /// Stores the value of `constant` in the `result` register
-    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: Value) {
+    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: FieldElement) {
         self.debug_show.const_instruction(result.address, constant);
         self.constant(result, constant);
     }
 
-    fn constant(&mut self, result: SingleAddrVariable, constant: Value) {
-        if result.bit_size > 128 && !constant.to_field().fits_in_u128() {
-            let high = Value::from(FieldElement::from_be_bytes_reduce(
-                constant
-                    .to_field()
-                    .to_be_bytes()
-                    .get(0..16)
-                    .expect("FieldElement::to_be_bytes() too short!"),
-            ));
-            let low = Value::from(constant.to_u128());
+    fn constant(&mut self, result: SingleAddrVariable, constant: FieldElement) {
+        assert!(
+            result.bit_size >= constant.num_bits(),
+            "Constant {} does not fit in bit size {}",
+            constant,
+            result.bit_size
+        );
+        if result.bit_size > 128 && !constant.fits_in_u128() {
+            let high = FieldElement::from_be_bytes_reduce(
+                constant.to_be_bytes().get(0..16).expect("FieldElement::to_be_bytes() too short!"),
+            );
+            let low = FieldElement::from(constant.to_u128());
             let high_register = SingleAddrVariable::new(self.allocate_register(), 254);
             let low_register = SingleAddrVariable::new(self.allocate_register(), 254);
             let intermediate_register = SingleAddrVariable::new(self.allocate_register(), 254);
@@ -419,7 +421,7 @@ impl BrilligContext {
             self.constant(low_register, low);
             // I want to multiply high by 2^128, but I can't get that big constant in.
             // So I'll multiply by 2^64 twice.
-            self.constant(intermediate_register, Value::from(1_u128 << 64));
+            self.constant(intermediate_register, FieldElement::from(1_u128 << 64));
             self.binary(high_register, intermediate_register, high_register, BrilligBinaryOp::Mul);
             self.binary(high_register, intermediate_register, high_register, BrilligBinaryOp::Mul);
             // Now we can add.
@@ -437,14 +439,18 @@ impl BrilligContext {
         }
     }
 
-    pub(crate) fn usize_const_instruction(&mut self, result: MemoryAddress, constant: Value) {
+    pub(crate) fn usize_const_instruction(
+        &mut self,
+        result: MemoryAddress,
+        constant: FieldElement,
+    ) {
         self.const_instruction(SingleAddrVariable::new_usize(result), constant);
     }
 
     /// Returns a register which holds the value of a constant
     pub(crate) fn make_constant_instruction(
         &mut self,
-        constant: Value,
+        constant: FieldElement,
         bit_size: u32,
     ) -> SingleAddrVariable {
         let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
@@ -452,7 +458,7 @@ impl BrilligContext {
         var
     }
 
-    fn make_constant(&mut self, constant: Value, bit_size: u32) -> SingleAddrVariable {
+    fn make_constant(&mut self, constant: FieldElement, bit_size: u32) -> SingleAddrVariable {
         let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
         self.constant(var, constant);
         var
@@ -461,7 +467,7 @@ impl BrilligContext {
     /// Returns a register which holds the value of an usize constant
     pub(crate) fn make_usize_constant_instruction(
         &mut self,
-        constant: Value,
+        constant: FieldElement,
     ) -> SingleAddrVariable {
         let register = self.allocate_register();
         self.usize_const_instruction(register, constant);
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index fb11bae556c..7e951cf4e00 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -11,7 +11,7 @@ use acvm::acir::circuit::brillig::{BrilligInputs, BrilligOutputs};
 use acvm::acir::circuit::opcodes::{BlockId, MemOp};
 use acvm::acir::circuit::Opcode;
 use acvm::blackbox_solver;
-use acvm::brillig_vm::{brillig::Value, VMStatus, VM};
+use acvm::brillig_vm::{MemoryValue, VMStatus, VM};
 use acvm::{
     acir::{
         brillig::Opcode as BrilligOpcode,
@@ -1623,7 +1623,7 @@ impl AcirContext {
         let outputs_var = vecmap(outputs_types.iter(), |output| match output {
             AcirType::NumericType(_) => {
                 let var = self.add_data(AcirVarData::Const(
-                    memory.next().expect("Missing return data").to_field(),
+                    memory.next().expect("Missing return data").value,
                 ));
                 AcirValue::Var(var, output.clone())
             }
@@ -1640,7 +1640,7 @@ impl AcirContext {
         &mut self,
         element_types: &[AcirType],
         size: usize,
-        memory_iter: &mut impl Iterator<Item = Value>,
+        memory_iter: &mut impl Iterator<Item = MemoryValue>,
     ) -> AcirValue {
         let mut array_values = im::Vector::new();
         for _ in 0..size {
@@ -1657,7 +1657,7 @@ impl AcirContext {
                     AcirType::NumericType(_) => {
                         let memory_value =
                             memory_iter.next().expect("ICE: Unexpected end of memory");
-                        let var = self.add_data(AcirVarData::Const(memory_value.to_field()));
+                        let var = self.add_data(AcirVarData::Const(memory_value.value));
                         array_values.push_back(AcirValue::Var(var, element_type.clone()));
                     }
                 }
@@ -1839,21 +1839,21 @@ pub(crate) struct AcirVar(usize);
 /// Returns the finished state of the Brillig VM if execution can complete.
 ///
 /// Returns `None` if complete execution of the Brillig bytecode is not possible.
-fn execute_brillig(code: &[BrilligOpcode], inputs: &[BrilligInputs]) -> Option<Vec<Value>> {
+fn execute_brillig(code: &[BrilligOpcode], inputs: &[BrilligInputs]) -> Option<Vec<MemoryValue>> {
     // Set input values
-    let mut calldata: Vec<Value> = Vec::new();
+    let mut calldata: Vec<FieldElement> = Vec::new();
 
     // Each input represents a constant or array of constants.
     // Iterate over each input and push it into registers and/or memory.
     for input in inputs {
         match input {
             BrilligInputs::Single(expr) => {
-                calldata.push(expr.to_const()?.into());
+                calldata.push(expr.to_const()?);
             }
             BrilligInputs::Array(expr_arr) => {
                 // Attempt to fetch all array input values
                 for expr in expr_arr.iter() {
-                    calldata.push(expr.to_const()?.into());
+                    calldata.push(expr.to_const()?);
                 }
             }
             BrilligInputs::MemoryArray(_) => {
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index d3d20654adc..b9240203a5e 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -88,7 +88,7 @@ impl TryFrom<&[ForeignCallParam]> for PrintableValueDisplay {
         let (is_fmt_str, foreign_call_inputs) =
             foreign_call_inputs.split_last().ok_or(ForeignCallError::MissingForeignCallInputs)?;
 
-        if is_fmt_str.unwrap_value().to_field().is_one() {
+        if is_fmt_str.unwrap_field().is_one() {
             convert_fmt_string_inputs(foreign_call_inputs)
         } else {
             convert_string_inputs(foreign_call_inputs)
@@ -106,8 +106,7 @@ fn convert_string_inputs(
     let printable_type = fetch_printable_type(printable_type_as_values)?;
 
     // We must use a flat map here as each value in a struct will be in a separate input value
-    let mut input_values_as_fields =
-        input_values.iter().flat_map(|param| vecmap(param.values(), |value| value.to_field()));
+    let mut input_values_as_fields = input_values.iter().flat_map(|param| param.fields());
 
     let value = decode_value(&mut input_values_as_fields, &printable_type);
 
@@ -120,7 +119,7 @@ fn convert_fmt_string_inputs(
     let (message, input_and_printable_types) =
         foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
 
-    let message_as_fields = vecmap(message.values(), |value| value.to_field());
+    let message_as_fields = message.fields();
     let message_as_string = decode_string_value(&message_as_fields);
 
     let (num_values, input_and_printable_types) = input_and_printable_types
@@ -128,12 +127,11 @@ fn convert_fmt_string_inputs(
         .ok_or(ForeignCallError::MissingForeignCallInputs)?;
 
     let mut output = Vec::new();
-    let num_values = num_values.unwrap_value().to_field().to_u128() as usize;
+    let num_values = num_values.unwrap_field().to_u128() as usize;
 
     let types_start_at = input_and_printable_types.len() - num_values;
-    let mut input_iter = input_and_printable_types[0..types_start_at]
-        .iter()
-        .flat_map(|param| vecmap(param.values(), |value| value.to_field()));
+    let mut input_iter =
+        input_and_printable_types[0..types_start_at].iter().flat_map(|param| param.fields());
     for printable_type in input_and_printable_types.iter().skip(types_start_at) {
         let printable_type = fetch_printable_type(printable_type)?;
         let value = decode_value(&mut input_iter, &printable_type);
@@ -147,7 +145,7 @@ fn convert_fmt_string_inputs(
 fn fetch_printable_type(
     printable_type: &ForeignCallParam,
 ) -> Result<PrintableType, ForeignCallError> {
-    let printable_type_as_fields = vecmap(printable_type.values(), |value| value.to_field());
+    let printable_type_as_fields = printable_type.fields();
     let printable_type_as_string = decode_string_value(&printable_type_as_fields);
     let printable_type: PrintableType = serde_json::from_str(&printable_type_as_string)?;
 
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 752b96d6591..6d5fbd44247 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -48,6 +48,15 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len = new_len;
     }
 
+    pub fn extend_from_slice(&mut self, slice: [T]) {
+        let new_len = self.len + slice.len();
+        assert(new_len as u64 <= MaxLen as u64, "extend_from_slice out of bounds");
+        for i in 0..slice.len() {
+            self.storage[self.len + i] = slice[i];
+        }
+        self.len = new_len;
+    }
+
     pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>) {
         let append_len = vec.len();
         let new_len = self.len + append_len;
diff --git a/noir_stdlib/src/field.nr b/noir_stdlib/src/field.nr
index 0f4c2caffdf..b876bcc967b 100644
--- a/noir_stdlib/src/field.nr
+++ b/noir_stdlib/src/field.nr
@@ -97,7 +97,7 @@ pub fn modulus_be_bytes() -> [u8] {}
 
 #[builtin(modulus_le_bytes)]
 pub fn modulus_le_bytes() -> [u8] {}
-// Convert a 32 byte array to a field element
+// Convert a 32 byte array to a field element by modding
 pub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {
     // Convert it to a field element
     let mut v = 1;
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 362d2132952..52f7783851a 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.30.1";
+const VERSION: &str = "0.32.0";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index a3ee89263a4..f0de8d5d1c8 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -2,7 +2,7 @@ use crate::foreign_calls::DebugForeignCallExecutor;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
 use acvm::brillig_vm::brillig::ForeignCallResult;
-use acvm::brillig_vm::brillig::Value;
+use acvm::brillig_vm::MemoryValue;
 use acvm::pwg::{
     ACVMStatus, BrilligSolver, BrilligSolverStatus, ForeignCallWaitInfo, StepResult, ACVM,
 };
@@ -506,13 +506,13 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         acir_index < opcodes.len() && matches!(opcodes[acir_index], Opcode::Brillig(..))
     }
 
-    pub(super) fn get_brillig_memory(&self) -> Option<&[Value]> {
+    pub(super) fn get_brillig_memory(&self) -> Option<&[MemoryValue]> {
         self.brillig_solver.as_ref().map(|solver| solver.get_memory())
     }
 
-    pub(super) fn write_brillig_memory(&mut self, ptr: usize, value: FieldElement) {
+    pub(super) fn write_brillig_memory(&mut self, ptr: usize, value: FieldElement, bit_size: u32) {
         if let Some(solver) = self.brillig_solver.as_mut() {
-            solver.write_memory_at(ptr, value.into());
+            solver.write_memory_at(ptr, MemoryValue::new(value, bit_size));
         }
     }
 
@@ -667,7 +667,7 @@ mod tests {
                 },
                 BrilligOpcode::Const {
                     destination: MemoryAddress::from(1),
-                    value: Value::from(fe_0),
+                    value: fe_0,
                     bit_size: 32,
                 },
                 BrilligOpcode::ForeignCall {
@@ -675,7 +675,7 @@ mod tests {
                     destinations: vec![],
                     destination_value_types: vec![],
                     inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                    input_value_types: vec![HeapValueType::Simple],
+                    input_value_types: vec![HeapValueType::field()],
                 },
                 BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
             ],
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index 25f126ff490..aae2212fd54 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -1,6 +1,7 @@
 use acvm::{
-    acir::brillig::{ForeignCallParam, ForeignCallResult, Value},
+    acir::brillig::{ForeignCallParam, ForeignCallResult},
     pwg::ForeignCallWaitInfo,
+    FieldElement,
 };
 use nargo::{
     artifacts::debug::{DebugArtifact, DebugVars, StackFrame},
@@ -81,11 +82,11 @@ impl DebugForeignCallExecutor for DefaultDebugForeignCallExecutor {
     }
 }
 
-fn debug_var_id(value: &Value) -> DebugVarId {
+fn debug_var_id(value: &FieldElement) -> DebugVarId {
     DebugVarId(value.to_u128() as u32)
 }
 
-fn debug_fn_id(value: &Value) -> DebugFnId {
+fn debug_fn_id(value: &FieldElement) -> DebugFnId {
     DebugFnId(value.to_u128() as u32)
 }
 
@@ -100,8 +101,8 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                 let fcp_var_id = &foreign_call.inputs[0];
                 if let ForeignCallParam::Single(var_id_value) = fcp_var_id {
                     let var_id = debug_var_id(var_id_value);
-                    let values: Vec<Value> =
-                        foreign_call.inputs[1..].iter().flat_map(|x| x.values()).collect();
+                    let values: Vec<FieldElement> =
+                        foreign_call.inputs[1..].iter().flat_map(|x| x.fields()).collect();
                     self.debug_vars.assign_var(var_id, &values);
                 }
                 Ok(ForeignCallResult::default().into())
@@ -129,12 +130,12 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                             }
                         })
                         .collect();
-                    let values: Vec<Value> = (0..n - 1 - arity)
+                    let values: Vec<FieldElement> = (0..n - 1 - arity)
                         .flat_map(|i| {
                             foreign_call
                                 .inputs
                                 .get(1 + i)
-                                .map(|fci| fci.values())
+                                .map(|fci| fci.fields())
                                 .unwrap_or_default()
                         })
                         .collect();
@@ -147,7 +148,7 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                 let fcp_value = &foreign_call.inputs[1];
                 if let ForeignCallParam::Single(var_id_value) = fcp_var_id {
                     let var_id = debug_var_id(var_id_value);
-                    self.debug_vars.assign_deref(var_id, &fcp_value.values());
+                    self.debug_vars.assign_deref(var_id, &fcp_value.fields());
                 }
                 Ok(ForeignCallResult::default().into())
             }
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 41dbf604f99..1c077c6ee9b 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -319,12 +319,12 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
             return;
         };
 
-        for (index, value) in memory.iter().enumerate() {
-            println!("{index} = {}", value.to_field());
+        for (index, value) in memory.iter().enumerate().filter(|(_, value)| value.bit_size > 0) {
+            println!("{index} = {}", value);
         }
     }
 
-    pub fn write_brillig_memory(&mut self, index: usize, value: String) {
+    pub fn write_brillig_memory(&mut self, index: usize, value: String, bit_size: u32) {
         let Some(field_value) = FieldElement::try_from_str(&value) else {
             println!("Invalid value: {value}");
             return;
@@ -333,7 +333,7 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
             println!("Not executing a Brillig block");
             return;
         }
-        self.context.write_brillig_memory(index, field_value);
+        self.context.write_brillig_memory(index, field_value, bit_size);
     }
 
     pub fn show_vars(&self) {
@@ -513,8 +513,8 @@ pub fn run<B: BlackBoxFunctionSolver>(
             "memset",
             command! {
                 "update a Brillig memory cell with the given value",
-                (index: usize, value: String) => |index, value| {
-                    ref_context.borrow_mut().write_brillig_memory(index, value);
+                (index: usize, value: String, bit_size: u32) => |index, value, bit_size| {
+                    ref_context.borrow_mut().write_brillig_memory(index, value, bit_size);
                     Ok(CommandStatus::Done)
                 }
             },
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 0e9e177e023..8e5c2bc46a4 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -1,4 +1,4 @@
-use acvm::brillig_vm::brillig::Value;
+use acvm::FieldElement;
 use noirc_errors::debug_info::{
     DebugFnId, DebugFunction, DebugInfo, DebugTypeId, DebugVarId, DebugVariable,
 };
@@ -66,7 +66,7 @@ impl DebugVars {
         }
     }
 
-    pub fn assign_var(&mut self, var_id: DebugVarId, values: &[Value]) {
+    pub fn assign_var(&mut self, var_id: DebugVarId, values: &[FieldElement]) {
         let type_id = &self.variables.get(&var_id).unwrap().debug_type_id;
         let ptype = self.types.get(type_id).unwrap();
 
@@ -74,10 +74,10 @@ impl DebugVars {
             .last_mut()
             .expect("unexpected empty stack frames")
             .1
-            .insert(var_id, decode_value(&mut values.iter().map(|v| v.to_field()), ptype));
+            .insert(var_id, decode_value(&mut values.iter().copied(), ptype));
     }
 
-    pub fn assign_field(&mut self, var_id: DebugVarId, indexes: Vec<u32>, values: &[Value]) {
+    pub fn assign_field(&mut self, var_id: DebugVarId, indexes: Vec<u32>, values: &[FieldElement]) {
         let current_frame = &mut self.frames.last_mut().expect("unexpected empty stack frames").1;
         let mut cursor: &mut PrintableValue = current_frame
             .get_mut(&var_id)
@@ -147,10 +147,10 @@ impl DebugVars {
                 }
             };
         }
-        *cursor = decode_value(&mut values.iter().map(|v| v.to_field()), cursor_type);
+        *cursor = decode_value(&mut values.iter().copied(), cursor_type);
     }
 
-    pub fn assign_deref(&mut self, _var_id: DebugVarId, _values: &[Value]) {
+    pub fn assign_deref(&mut self, _var_id: DebugVarId, _values: &[FieldElement]) {
         unimplemented![]
     }
 
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index f7f36c65c90..ea67f17af2a 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -1,6 +1,7 @@
 use acvm::{
-    acir::brillig::{ForeignCallParam, ForeignCallResult, Value},
+    acir::brillig::{ForeignCallParam, ForeignCallResult},
     pwg::ForeignCallWaitInfo,
+    FieldElement,
 };
 use jsonrpc::{arg as build_json_rpc_arg, minreq_http::Builder, Client};
 use noirc_printable_type::{decode_string_value, ForeignCallError, PrintableValueDisplay};
@@ -46,15 +47,15 @@ impl From<String> for NargoForeignCallResult {
     }
 }
 
-impl From<Value> for NargoForeignCallResult {
-    fn from(value: Value) -> Self {
+impl From<FieldElement> for NargoForeignCallResult {
+    fn from(value: FieldElement) -> Self {
         let foreign_call_result: ForeignCallResult = value.into();
         foreign_call_result.into()
     }
 }
 
-impl From<Vec<Value>> for NargoForeignCallResult {
-    fn from(values: Vec<Value>) -> Self {
+impl From<Vec<FieldElement>> for NargoForeignCallResult {
+    fn from(values: Vec<FieldElement>) -> Self {
         let foreign_call_result: ForeignCallResult = values.into();
         foreign_call_result.into()
     }
@@ -178,7 +179,10 @@ impl DefaultForeignCallExecutor {
     ) -> Result<(usize, &[ForeignCallParam]), ForeignCallError> {
         let (id, params) =
             foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
-        Ok((id.unwrap_value().to_usize(), params))
+        let id =
+            usize::try_from(id.unwrap_field().try_to_u64().expect("value does not fit into u64"))
+                .expect("value does not fit into usize");
+        Ok((id, params))
     }
 
     fn find_mock_by_id(&mut self, id: usize) -> Option<&mut MockedCall> {
@@ -186,12 +190,12 @@ impl DefaultForeignCallExecutor {
     }
 
     fn parse_string(param: &ForeignCallParam) -> String {
-        let fields: Vec<_> = param.values().into_iter().map(|value| value.to_field()).collect();
+        let fields: Vec<_> = param.fields().to_vec();
         decode_string_value(&fields)
     }
 
     fn execute_print(foreign_call_inputs: &[ForeignCallParam]) -> Result<(), ForeignCallError> {
-        let skip_newline = foreign_call_inputs[0].unwrap_value().is_zero();
+        let skip_newline = foreign_call_inputs[0].unwrap_field().is_zero();
 
         let foreign_call_inputs =
             foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?.1;
@@ -242,7 +246,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                 self.mocked_responses.push(MockedCall::new(id, mock_oracle_name));
                 self.last_mock_id += 1;
 
-                Ok(Value::from(id).into())
+                Ok(FieldElement::from(id).into())
             }
             Some(ForeignCall::SetMockParams) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -262,11 +266,8 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
             }
             Some(ForeignCall::SetMockTimes) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
-                let times = params[0]
-                    .unwrap_value()
-                    .to_field()
-                    .try_to_u64()
-                    .expect("Invalid bit size of times");
+                let times =
+                    params[0].unwrap_field().try_to_u64().expect("Invalid bit size of times");
 
                 self.find_mock_by_id(id)
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
@@ -325,10 +326,8 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
 #[cfg(test)]
 mod tests {
     use acvm::{
-        acir::brillig::ForeignCallParam,
-        brillig_vm::brillig::{ForeignCallResult, Value},
-        pwg::ForeignCallWaitInfo,
-        FieldElement,
+        acir::brillig::ForeignCallParam, brillig_vm::brillig::ForeignCallResult,
+        pwg::ForeignCallWaitInfo, FieldElement,
     };
     use jsonrpc_core::Result as RpcResult;
     use jsonrpc_derive::rpc;
@@ -356,11 +355,11 @@ mod tests {
         fn sum(&self, array: ForeignCallParam) -> RpcResult<ForeignCallResult> {
             let mut res: FieldElement = 0_usize.into();
 
-            for value in array.values() {
-                res += value.to_field();
+            for value in array.fields() {
+                res += value;
             }
 
-            Ok(Value::from(res).into())
+            Ok(res.into())
         }
     }
 
@@ -406,7 +405,7 @@ mod tests {
         };
 
         let result = executor.execute(&foreign_call);
-        assert_eq!(result.unwrap(), Value::from(3_usize).into());
+        assert_eq!(result.unwrap(), FieldElement::from(3_usize).into());
 
         server.close();
     }
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index aec8204f065..251dd80c2f4 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.30.1",
+    "@aztec/bb.js": "0.32.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index 3932935167d..a39ae9921da 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.30.1":
-  version: 0.30.1
-  resolution: "@aztec/bb.js@npm:0.30.1"
+"@aztec/bb.js@npm:0.32.0":
+  version: 0.32.0
+  resolution: "@aztec/bb.js@npm:0.32.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 52d0acaaf0966aa969b863adeb688df5c1abe7c8a0595bc2dca8603a8649f11eb39071aacbdc05b19f320f022b98691a41cb18a601ad84e6d82955ae6f885106
+  checksum: 0919957e141ae0a65cfab961dce122fa06de628a10b7cb661d31d8ed4793ce80980fcf315620ceffffa45581db941bad43c392f4b2aa9becaaf7d2faaba01ffc
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.30.1
+    "@aztec/bb.js": 0.32.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 55f558e79933256c0ac0876e0d4c7354af1b4a5b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 28 Mar 2024 12:48:35 +0000
Subject: [PATCH 123/416] chore: include durations of tracing spans in log
 output (#4660)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR updates the filter on span events so that we get the duration of
the span being printed.


Example output:
```
2024-03-27T17:18:17.207634Z TRACE check_crate{crate_id=Root(1) deny_warnings=false disable_macros=false}: noirc_driver: new
2024-03-27T17:18:17.238046Z TRACE check_crate{crate_id=Root(1) deny_warnings=false disable_macros=false}: noirc_driver: close time.busy=30.4ms time.idle=39.3µs
2024-03-27T17:18:17.238075Z TRACE compile_no_check{function_name="main"}: noirc_driver: new
2024-03-27T17:18:17.238081Z TRACE compile_no_check{function_name="main"}:monomorphize: noirc_frontend::monomorphization: new
2024-03-27T17:18:17.238180Z TRACE compile_no_check{function_name="main"}:monomorphize: noirc_frontend::monomorphization: close time.busy=95.5µs time.idle=3.56µs
2024-03-27T17:18:17.238217Z TRACE compile_no_check{function_name="main"}:create_circuit: noirc_evaluator::ssa: new
2024-03-27T17:18:17.238234Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation: noirc_evaluator::ssa: new
2024-03-27T17:18:17.238458Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:defunctionalize: noirc_evaluator::ssa::opt::defunctionalize: new
2024-03-27T17:18:17.238476Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:defunctionalize: noirc_evaluator::ssa::opt::defunctionalize: close time.busy=12.5µs time.idle=6.24µs
2024-03-27T17:18:17.238482Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:remove_paired_rc: noirc_evaluator::ssa::opt::rc: new
2024-03-27T17:18:17.238499Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:remove_paired_rc: noirc_evaluator::ssa::opt::rc: close time.busy=7.51µs time.idle=9.60µs
2024-03-27T17:18:17.238504Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:inline_functions: noirc_evaluator::ssa::opt::inlining: new
2024-03-27T17:18:17.238572Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:inline_functions: noirc_evaluator::ssa::opt::inlining: close time.busy=64.0µs time.idle=3.42µs
2024-03-27T17:18:17.238578Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:mem2reg: noirc_evaluator::ssa::opt::mem2reg: new
2024-03-27T17:18:17.238668Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:mem2reg: noirc_evaluator::ssa::opt::mem2reg: close time.busy=83.6µs time.idle=5.48µs
2024-03-27T17:18:17.238675Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:evaluate_assert_constant: noirc_evaluator::ssa::opt::assert_constant: new
2024-03-27T17:18:17.238682Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:evaluate_assert_constant: noirc_evaluator::ssa::opt::assert_constant: close time.busy=3.01µs time.idle=4.07µs
2024-03-27T17:18:17.238688Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:unroll_loops: noirc_evaluator::ssa::opt::unrolling: new
2024-03-27T17:18:17.387314Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:unroll_loops: noirc_evaluator::ssa::opt::unrolling: close time.busy=149ms time.idle=5.25µs
2024-03-27T17:18:17.387343Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:simplify_cfg: noirc_evaluator::ssa::opt::simplify_cfg: new
2024-03-27T17:18:17.393664Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:simplify_cfg: noirc_evaluator::ssa::opt::simplify_cfg: close time.busy=6.31ms time.idle=6.11µs
2024-03-27T17:18:17.393681Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:flatten_cfg: noirc_evaluator::ssa::opt::flatten_cfg: new
2024-03-27T17:18:22.881528Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:flatten_cfg: noirc_evaluator::ssa::opt::flatten_cfg: close time.busy=5.49s time.idle=9.78µs
2024-03-27T17:18:22.881558Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:remove_bit_shifts: noirc_evaluator::ssa::opt::remove_bit_shifts: new
2024-03-27T17:18:22.939961Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:remove_bit_shifts: noirc_evaluator::ssa::opt::remove_bit_shifts: close time.busy=58.4ms time.idle=7.86µs
2024-03-27T17:18:22.939994Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:mem2reg: noirc_evaluator::ssa::opt::mem2reg: new
2024-03-27T17:18:39.127772Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:mem2reg: noirc_evaluator::ssa::opt::mem2reg: close time.busy=16.2s time.idle=7.82µs
2024-03-27T17:18:39.127802Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:fold_constants: noirc_evaluator::ssa::opt::constant_folding: new
2024-03-27T17:18:42.247447Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:fold_constants: noirc_evaluator::ssa::opt::constant_folding: close time.busy=3.12s time.idle=6.51µs
2024-03-27T17:18:42.247480Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:fold_constants_using_constraints: noirc_evaluator::ssa::opt::constant_folding: new
2024-03-27T17:18:46.333707Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:fold_constants_using_constraints: noirc_evaluator::ssa::opt::constant_folding: close time.busy=4.09s time.idle=10.1µs
2024-03-27T17:18:46.333739Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:dead_instruction_elimination: noirc_evaluator::ssa::opt::die: new
2024-03-27T17:18:47.352043Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation:dead_instruction_elimination: noirc_evaluator::ssa::opt::die: close time.busy=1.02s time.idle=8.20µs
2024-03-27T17:18:47.366309Z TRACE compile_no_check{function_name="main"}:create_circuit:find_last_array_uses: noirc_evaluator::ssa::opt::array_use: new
2024-03-27T17:18:47.371971Z TRACE compile_no_check{function_name="main"}:create_circuit:find_last_array_uses: noirc_evaluator::ssa::opt::array_use: close time.busy=5.64ms time.idle=18.0µs
2024-03-27T17:18:47.371988Z TRACE compile_no_check{function_name="main"}:create_circuit:into_acir: noirc_evaluator::ssa::acir_gen: new
2024-03-27T17:18:54.310129Z TRACE compile_no_check{function_name="main"}:create_circuit:into_acir: noirc_evaluator::ssa::acir_gen: close time.busy=6.94s time.idle=8.21µs
2024-03-27T17:18:54.310156Z TRACE compile_no_check{function_name="main"}:create_circuit:ssa_generation: noirc_evaluator::ssa: close time.busy=30.1s time.idle=6.94s
2024-03-27T17:18:54.311567Z TRACE compile_no_check{function_name="main"}:create_circuit:optimize_acir: acvm::compiler::optimizers: new
2024-03-27T17:18:54.311580Z  INFO compile_no_check{function_name="main"}:create_circuit:optimize_acir: acvm::compiler::optimizers: Number of opcodes before: 8323
2024-03-27T17:18:54.312564Z  INFO compile_no_check{function_name="main"}:create_circuit:optimize_acir: acvm::compiler::optimizers: Number of opcodes after: 8323
2024-03-27T17:18:54.312571Z TRACE compile_no_check{function_name="main"}:create_circuit:optimize_acir: acvm::compiler::optimizers: close time.busy=995µs time.idle=9.56µs
2024-03-27T17:18:54.313322Z TRACE compile_no_check{function_name="main"}:create_circuit:update_acir: noirc_errors::debug_info: new
2024-03-27T17:18:54.314192Z TRACE compile_no_check{function_name="main"}:create_circuit:update_acir: noirc_errors::debug_info: close time.busy=863µs time.idle=6.04µs
2024-03-27T17:18:54.314446Z TRACE compile_no_check{function_name="main"}:create_circuit: noirc_evaluator::ssa: close time.busy=37.1s time.idle=4.23µs
2024-03-27T17:18:54.315015Z TRACE compile_no_check{function_name="main"}: noirc_driver: close time.busy=37.1s time.idle=4.54µs
2024-03-27T17:18:54.320236Z TRACE optimize_acir: acvm::compiler::optimizers: new
2024-03-27T17:18:54.320252Z  INFO optimize_acir: acvm::compiler::optimizers: Number of opcodes before: 8323
2024-03-27T17:18:54.321141Z  INFO optimize_acir: acvm::compiler::optimizers: Number of opcodes after: 8323
2024-03-27T17:18:54.321147Z TRACE optimize_acir: acvm::compiler::optimizers: close time.busy=902µs time.idle=9.38µs
2024-03-27T17:18:54.321156Z TRACE transform_acir{expression_width=Bounded { width: 3 }}: acvm::compiler::transformers: new
2024-03-27T17:18:54.322544Z TRACE transform_acir{expression_width=Bounded { width: 3 }}: acvm::compiler::transformers: close time.busy=1.38ms time.idle=4.58µs
2024-03-27T17:18:54.323134Z TRACE update_acir: noirc_errors::debug_info: new
2024-03-27T17:18:54.323928Z TRACE update_acir: noirc_errors::debug_info: close time.busy=789µs time.idle=5.42µs
```

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/src/main.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tooling/nargo_cli/src/main.rs b/tooling/nargo_cli/src/main.rs
index 3f797b0bf0c..6e2b7069bc4 100644
--- a/tooling/nargo_cli/src/main.rs
+++ b/tooling/nargo_cli/src/main.rs
@@ -25,14 +25,14 @@ fn main() {
     if let Ok(log_dir) = env::var("NARGO_LOG_DIR") {
         let debug_file = rolling::daily(log_dir, "nargo-log");
         tracing_subscriber::fmt()
-            .with_span_events(FmtSpan::ACTIVE)
+            .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
             .with_writer(debug_file)
             .with_ansi(false)
             .with_env_filter(EnvFilter::from_default_env())
             .init();
     } else {
         tracing_subscriber::fmt()
-            .with_span_events(FmtSpan::ACTIVE)
+            .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
             .with_ansi(true)
             .with_env_filter(EnvFilter::from_env("NOIR_LOG"))
             .init();

From 05b32fc9595d0a281e49b99b153030416115f436 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 28 Mar 2024 17:48:24 +0000
Subject: [PATCH 124/416] chore: Pretty print timings for codegen (#4659)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4658

## Summary\*

I was already timing things for a separate issue so I decided to push
this PR. I felt this provided a nice temporary solution. If we deem that
the `tracing` crate can still be used for pretty printing the timings of
each codegen pass we can switch to that in a follow-up, and for now this
provides an easy way to check the timings of each codegen pass.

Example output:
```
After Defunctionalization:: 0 ms
After Removing Paired rc_inc & rc_decs:: 0 ms
After Inlining:: 0 ms
After Mem2Reg:: 0 ms
After Assert Constant:: 0 ms
After Unrolling:: 13 ms
After Simplifying:: 0 ms
After Flattening:: 9 ms
After Removing Bit Shifts:: 0 ms
After Mem2Reg:: 19 ms
After Constant Folding:: 3 ms
After Constraint Folding:: 3 ms
After Dead Instruction Elimination:: 0 ms
SSA to Brillig: 0 ms
SSA to ACIR: 14 ms
```

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 Cargo.lock                          |  7 +++---
 compiler/noirc_driver/src/lib.rs    | 13 +++++++++--
 compiler/noirc_evaluator/Cargo.toml |  3 ++-
 compiler/noirc_evaluator/src/ssa.rs | 34 +++++++++++++++++++++++------
 cspell.json                         |  1 +
 5 files changed, 45 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8c47f03b267..c42c2b5d74e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -789,9 +789,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.30"
+version = "0.4.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "defd4e7873dbddba6c7c91e199c7fcb946abc4a6a4ac3195400bcfb01b5de877"
+checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -799,7 +799,7 @@ dependencies = [
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-targets 0.48.1",
+ "windows-targets 0.52.4",
 ]
 
 [[package]]
@@ -3070,6 +3070,7 @@ name = "noirc_evaluator"
 version = "0.26.0"
 dependencies = [
  "acvm",
+ "chrono",
  "fxhash",
  "im",
  "iter-extended",
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index bc3062e5807..8b3c126dedb 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -68,6 +68,10 @@ pub struct CompileOptions {
     #[arg(long)]
     pub print_acir: bool,
 
+    /// Pretty print benchmark times of each code generation pass
+    #[arg(long, hide = true)]
+    pub benchmark_codegen: bool,
+
     /// Treat all warnings as errors
     #[arg(long, conflicts_with = "silence_warnings")]
     pub deny_warnings: bool,
@@ -478,8 +482,13 @@ pub fn compile_no_check(
         return Ok(cached_program.expect("cache must exist for hashes to match"));
     }
     let visibility = program.return_visibility;
-    let (circuit, debug, input_witnesses, return_witnesses, warnings) =
-        create_circuit(program, options.show_ssa, options.show_brillig, options.force_brillig)?;
+    let (circuit, debug, input_witnesses, return_witnesses, warnings) = create_circuit(
+        program,
+        options.show_ssa,
+        options.show_brillig,
+        options.force_brillig,
+        options.benchmark_codegen,
+    )?;
 
     let abi =
         abi_gen::gen_abi(context, &main_function, input_witnesses, return_witnesses, visibility);
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index a8f0e8d83a9..fad7c3c309e 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -17,4 +17,5 @@ thiserror.workspace = true
 num-bigint = "0.4"
 im = { version = "15.1", features = ["serde"] }
 serde.workspace = true
-tracing.workspace = true
\ No newline at end of file
+tracing.workspace = true
+chrono = "0.4.37"
\ No newline at end of file
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 808cf7533c9..01dc50a7119 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -38,15 +38,16 @@ pub mod ssa_gen;
 /// convert the final SSA into ACIR and return it.
 pub(crate) fn optimize_into_acir(
     program: Program,
-    print_ssa_passes: bool,
+    print_passes: bool,
     print_brillig_trace: bool,
     force_brillig_output: bool,
+    print_timings: bool,
 ) -> Result<GeneratedAcir, RuntimeError> {
     let abi_distinctness = program.return_distinctness;
 
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
     let ssa_gen_span_guard = ssa_gen_span.enter();
-    let ssa = SsaBuilder::new(program, print_ssa_passes, force_brillig_output)?
+    let ssa = SsaBuilder::new(program, print_passes, force_brillig_output, print_timings)?
         .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
         .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
         .run_pass(Ssa::inline_functions, "After Inlining:")
@@ -64,13 +65,28 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
         .finish();
 
-    let brillig = ssa.to_brillig(print_brillig_trace);
+    let brillig = time("SSA to Brillig", print_timings, || ssa.to_brillig(print_brillig_trace));
 
     drop(ssa_gen_span_guard);
 
     let last_array_uses = ssa.find_last_array_uses();
 
-    ssa.into_acir(brillig, abi_distinctness, &last_array_uses)
+    time("SSA to ACIR", print_timings, || {
+        ssa.into_acir(brillig, abi_distinctness, &last_array_uses)
+    })
+}
+
+// Helper to time SSA passes
+fn time<T>(name: &str, print_timings: bool, f: impl FnOnce() -> T) -> T {
+    let start_time = chrono::Utc::now().time();
+    let result = f();
+
+    if print_timings {
+        let end_time = chrono::Utc::now().time();
+        println!("{name}: {} ms", (end_time - start_time).num_milliseconds());
+    }
+
+    result
 }
 
 /// Compiles the [`Program`] into [`ACIR`][acvm::acir::circuit::Circuit].
@@ -83,6 +99,7 @@ pub fn create_circuit(
     enable_ssa_logging: bool,
     enable_brillig_logging: bool,
     force_brillig_output: bool,
+    print_codegen_timings: bool,
 ) -> Result<(Circuit, DebugInfo, Vec<Witness>, Vec<Witness>, Vec<SsaReport>), RuntimeError> {
     let debug_variables = program.debug_variables.clone();
     let debug_types = program.debug_types.clone();
@@ -94,6 +111,7 @@ pub fn create_circuit(
         enable_ssa_logging,
         enable_brillig_logging,
         force_brillig_output,
+        print_codegen_timings,
     )?;
     let opcodes = generated_acir.take_opcodes();
     let current_witness_index = generated_acir.current_witness_index().0;
@@ -176,6 +194,7 @@ fn split_public_and_private_inputs(
 struct SsaBuilder {
     ssa: Ssa,
     print_ssa_passes: bool,
+    print_codegen_timings: bool,
 }
 
 impl SsaBuilder {
@@ -183,9 +202,10 @@ impl SsaBuilder {
         program: Program,
         print_ssa_passes: bool,
         force_brillig_runtime: bool,
+        print_codegen_timings: bool,
     ) -> Result<SsaBuilder, RuntimeError> {
         let ssa = ssa_gen::generate_ssa(program, force_brillig_runtime)?;
-        Ok(SsaBuilder { print_ssa_passes, ssa }.print("Initial SSA:"))
+        Ok(SsaBuilder { print_ssa_passes, print_codegen_timings, ssa }.print("Initial SSA:"))
     }
 
     fn finish(self) -> Ssa {
@@ -194,7 +214,7 @@ impl SsaBuilder {
 
     /// Runs the given SSA pass and prints the SSA afterward if `print_ssa_passes` is true.
     fn run_pass(mut self, pass: fn(Ssa) -> Ssa, msg: &str) -> Self {
-        self.ssa = pass(self.ssa);
+        self.ssa = time(msg, self.print_codegen_timings, || pass(self.ssa));
         self.print(msg)
     }
 
@@ -204,7 +224,7 @@ impl SsaBuilder {
         pass: fn(Ssa) -> Result<Ssa, RuntimeError>,
         msg: &str,
     ) -> Result<Self, RuntimeError> {
-        self.ssa = pass(self.ssa)?;
+        self.ssa = time(msg, self.print_codegen_timings, || pass(self.ssa))?;
         Ok(self.print(msg))
     }
 
diff --git a/cspell.json b/cspell.json
index 8cfc5e695a2..e50940fbd10 100644
--- a/cspell.json
+++ b/cspell.json
@@ -36,6 +36,7 @@
         "castable",
         "catmcgee",
         "Celo",
+        "chrono",
         "chumsky",
         "codegen",
         "codegenned",

From 30c9f3151d447de8c7467ccbee82e32b8c46a396 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 29 Mar 2024 09:55:13 -0500
Subject: [PATCH 125/416] fix: "Types in a binary operation should match, but
 found T and T" (#4648)

# Description

## Problem\*

Resolves #4635
Resolves https://github.com/noir-lang/noir/issues/4502

## Summary\*

This was more difficult to fix than it originally seemed. The main issue
was between interactions with unbound type variables, type aliases, type
rules for operators, and operator traits.

Removing the "infer unbound type variables to be numeric" rule on
operators causes a lot of stdlib code to break where it'd be
unreasonable to have type annotations. This caused unbound type
variables to be bound to the first object type whose impl it was checked
against when calling verify trait impl.

I eventually settled on just delaying the verify trait impl check for
operators until the end of a function when more types are known.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/type_check/errors.rs              |  7 +-
 .../noirc_frontend/src/hir/type_check/expr.rs | 85 ++++++++++---------
 .../noirc_frontend/src/hir/type_check/mod.rs  | 50 ++++++-----
 compiler/noirc_frontend/src/hir_def/types.rs  | 10 +++
 compiler/noirc_frontend/src/tests.rs          | 12 +--
 noir_stdlib/src/cmp.nr                        | 14 +--
 noir_stdlib/src/ops.nr                        | 54 ++++++------
 .../regression_4635/Nargo.toml                |  7 ++
 .../regression_4635/src/main.nr               | 59 +++++++++++++
 .../hashmap_load_factor/Nargo.toml            |  0
 .../hashmap_load_factor/Prover.toml           | 23 +++++
 .../hashmap_load_factor/src/main.nr           |  0
 .../bit_shifts_runtime/src/main.nr            |  2 +-
 13 files changed, 212 insertions(+), 111 deletions(-)
 create mode 100644 test_programs/compile_success_empty/regression_4635/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/regression_4635/src/main.nr
 rename test_programs/{compile_failure => execution_failure}/hashmap_load_factor/Nargo.toml (100%)
 create mode 100644 test_programs/execution_failure/hashmap_load_factor/Prover.toml
 rename test_programs/{compile_failure => execution_failure}/hashmap_load_factor/src/main.nr (100%)

diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 6beb6929ce1..fe9cc9ea2d6 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -65,8 +65,6 @@ pub enum TypeCheckError {
     VariableMustBeMutable { name: String, span: Span },
     #[error("No method named '{method_name}' found for type '{object_type}'")]
     UnresolvedMethodCall { method_name: String, object_type: Type, span: Span },
-    #[error("Comparisons are invalid on Field types. Try casting the operands to a sized integer type first")]
-    InvalidComparisonOnField { span: Span },
     #[error("Integers must have the same signedness LHS is {sign_x:?}, RHS is {sign_y:?}")]
     IntegerSignedness { sign_x: Signedness, sign_y: Signedness, span: Span },
     #[error("Integers must have the same bit width LHS is {bit_width_x}, RHS is {bit_width_y}")]
@@ -76,7 +74,7 @@ pub enum TypeCheckError {
     #[error("{kind} cannot be used in a unary operation")]
     InvalidUnaryOp { kind: String, span: Span },
     #[error("Bitwise operations are invalid on Field types. Try casting the operands to a sized integer type first.")]
-    InvalidBitwiseOperationOnField { span: Span },
+    FieldBitwiseOp { span: Span },
     #[error("Integer cannot be used with type {typ}")]
     IntegerTypeMismatch { typ: Type, span: Span },
     #[error("Cannot use an integer and a Field in a binary operation, try converting the Field into an integer first")]
@@ -224,12 +222,11 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::TupleIndexOutOfBounds { span, .. }
             | TypeCheckError::VariableMustBeMutable { span, .. }
             | TypeCheckError::UnresolvedMethodCall { span, .. }
-            | TypeCheckError::InvalidComparisonOnField { span }
             | TypeCheckError::IntegerSignedness { span, .. }
             | TypeCheckError::IntegerBitWidth { span, .. }
             | TypeCheckError::InvalidInfixOp { span, .. }
             | TypeCheckError::InvalidUnaryOp { span, .. }
-            | TypeCheckError::InvalidBitwiseOperationOnField { span, .. }
+            | TypeCheckError::FieldBitwiseOp { span, .. }
             | TypeCheckError::IntegerTypeMismatch { span, .. }
             | TypeCheckError::FieldComparison { span, .. }
             | TypeCheckError::AmbiguousBitWidth { span, .. }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 10476b6caef..fb66bdeae6e 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -152,14 +152,16 @@ impl<'interner> TypeChecker<'interner> {
                     Ok((typ, use_impl)) => {
                         if use_impl {
                             let id = infix_expr.trait_method_id;
-                            // Assume operators have no trait generics
-                            self.verify_trait_constraint(
-                                &lhs_type,
-                                id.trait_id,
-                                &[],
-                                *expr_id,
-                                span,
-                            );
+
+                            // Delay checking the trait constraint until the end of the function.
+                            // Checking it now could bind an unbound type variable to any type
+                            // that implements the trait.
+                            let constraint = crate::hir_def::traits::TraitConstraint {
+                                typ: lhs_type.clone(),
+                                trait_id: id.trait_id,
+                                trait_generics: Vec::new(),
+                            };
+                            self.trait_constraints.push((constraint, *expr_id));
                             self.typecheck_operator_method(*expr_id, id, &lhs_type, span);
                         }
                         typ
@@ -836,6 +838,10 @@ impl<'interner> TypeChecker<'interner> {
         match (lhs_type, rhs_type) {
             // Avoid reporting errors multiple times
             (Error, _) | (_, Error) => Ok((Bool, false)),
+            (Alias(alias, args), other) | (other, Alias(alias, args)) => {
+                let alias = alias.borrow().get_type(args);
+                self.comparator_operand_type_rules(&alias, other, op, span)
+            }
 
             // Matches on TypeVariable must be first to follow any type
             // bindings.
@@ -844,12 +850,8 @@ impl<'interner> TypeChecker<'interner> {
                     return self.comparator_operand_type_rules(other, binding, op, span);
                 }
 
-                self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
-                Ok((Bool, false))
-            }
-            (Alias(alias, args), other) | (other, Alias(alias, args)) => {
-                let alias = alias.borrow().get_type(args);
-                self.comparator_operand_type_rules(&alias, other, op, span)
+                let use_impl = self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
+                Ok((Bool, use_impl))
             }
             (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => {
                 if sign_x != sign_y {
@@ -1079,13 +1081,16 @@ impl<'interner> TypeChecker<'interner> {
         }
     }
 
+    /// Handles the TypeVariable case for checking binary operators.
+    /// Returns true if we should use the impl for the operator instead of the primitive
+    /// version of it.
     fn bind_type_variables_for_infix(
         &mut self,
         lhs_type: &Type,
         op: &HirBinaryOp,
         rhs_type: &Type,
         span: Span,
-    ) {
+    ) -> bool {
         self.unify(lhs_type, rhs_type, || TypeCheckError::TypeMismatchWithSource {
             expected: lhs_type.clone(),
             actual: rhs_type.clone(),
@@ -1093,22 +1098,26 @@ impl<'interner> TypeChecker<'interner> {
             span,
         });
 
-        // In addition to unifying both types, we also have to bind either
-        // the lhs or rhs to an integer type variable. This ensures if both lhs
-        // and rhs are type variables, that they will have the correct integer
-        // type variable kind instead of TypeVariableKind::Normal.
-        let target = if op.kind.is_valid_for_field_type() {
-            Type::polymorphic_integer_or_field(self.interner)
-        } else {
-            Type::polymorphic_integer(self.interner)
-        };
+        let use_impl = !lhs_type.is_numeric();
+
+        // If this operator isn't valid for fields we have to possibly narrow
+        // TypeVariableKind::IntegerOrField to TypeVariableKind::Integer.
+        // Doing so also ensures a type error if Field is used.
+        // The is_numeric check is to allow impls for custom types to bypass this.
+        if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric() {
+            let target = Type::polymorphic_integer(self.interner);
+
+            use BinaryOpKind::*;
+            use TypeCheckError::*;
+            self.unify(lhs_type, &target, || match op.kind {
+                Less | LessEqual | Greater | GreaterEqual => FieldComparison { span },
+                And | Or | Xor | ShiftRight | ShiftLeft => FieldBitwiseOp { span },
+                Modulo => FieldModulo { span },
+                other => unreachable!("Operator {other:?} should be valid for Field"),
+            });
+        }
 
-        self.unify(lhs_type, &target, || TypeCheckError::TypeMismatchWithSource {
-            expected: lhs_type.clone(),
-            actual: rhs_type.clone(),
-            source: Source::Binary,
-            span,
-        });
+        use_impl
     }
 
     // Given a binary operator and another type. This method will produce the output type
@@ -1130,6 +1139,10 @@ impl<'interner> TypeChecker<'interner> {
         match (lhs_type, rhs_type) {
             // An error type on either side will always return an error
             (Error, _) | (_, Error) => Ok((Error, false)),
+            (Alias(alias, args), other) | (other, Alias(alias, args)) => {
+                let alias = alias.borrow().get_type(args);
+                self.infix_operand_type_rules(&alias, op, other, span)
+            }
 
             // Matches on TypeVariable must be first so that we follow any type
             // bindings.
@@ -1138,14 +1151,8 @@ impl<'interner> TypeChecker<'interner> {
                     return self.infix_operand_type_rules(binding, op, other, span);
                 }
 
-                self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
-
-                // Both types are unified so the choice of which to return is arbitrary
-                Ok((other.clone(), false))
-            }
-            (Alias(alias, args), other) | (other, Alias(alias, args)) => {
-                let alias = alias.borrow().get_type(args);
-                self.infix_operand_type_rules(&alias, op, other, span)
+                let use_impl = self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
+                Ok((other.clone(), use_impl))
             }
             (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => {
                 if sign_x != sign_y {
@@ -1170,7 +1177,7 @@ impl<'interner> TypeChecker<'interner> {
                     if op.kind == BinaryOpKind::Modulo {
                         return Err(TypeCheckError::FieldModulo { span });
                     } else {
-                        return Err(TypeCheckError::InvalidBitwiseOperationOnField { span });
+                        return Err(TypeCheckError::FieldBitwiseOp { span });
                     }
                 }
                 Ok((FieldElement, false))
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 137608f8037..bb42ebf68fb 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -86,31 +86,13 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
 
     let function_last_type = type_checker.check_function_body(function_body_id);
 
-    // Verify any remaining trait constraints arising from the function body
-    for (constraint, expr_id) in std::mem::take(&mut type_checker.trait_constraints) {
-        let span = type_checker.interner.expr_span(&expr_id);
-        type_checker.verify_trait_constraint(
-            &constraint.typ,
-            constraint.trait_id,
-            &constraint.trait_generics,
-            expr_id,
-            span,
-        );
-    }
-
-    errors.append(&mut type_checker.errors);
-
-    // Now remove all the `where` clause constraints we added
-    for constraint in &expected_trait_constraints {
-        interner.remove_assumed_trait_implementations_for_trait(constraint.trait_id);
-    }
-
     // Check declared return type and actual return type
     if !can_ignore_ret {
-        let (expr_span, empty_function) = function_info(interner, function_body_id);
-        let func_span = interner.expr_span(function_body_id); // XXX: We could be more specific and return the span of the last stmt, however stmts do not have spans yet
+        let (expr_span, empty_function) = function_info(type_checker.interner, function_body_id);
+        let func_span = type_checker.interner.expr_span(function_body_id); // XXX: We could be more specific and return the span of the last stmt, however stmts do not have spans yet
         if let Type::TraitAsType(trait_id, _, generics) = &declared_return_type {
-            if interner
+            if type_checker
+                .interner
                 .lookup_trait_implementation(&function_last_type, *trait_id, generics)
                 .is_err()
             {
@@ -126,7 +108,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
             function_last_type.unify_with_coercions(
                 &declared_return_type,
                 *function_body_id,
-                interner,
+                type_checker.interner,
                 &mut errors,
                 || {
                     let mut error = TypeCheckError::TypeMismatchWithSource {
@@ -137,9 +119,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
                     };
 
                     if empty_function {
-                        error = error.add_context(
-                        "implicitly returns `()` as its body has no tail or `return` expression",
-                    );
+                        error = error.add_context("implicitly returns `()` as its body has no tail or `return` expression");
                     }
                     error
                 },
@@ -147,6 +127,24 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
         }
     }
 
+    // Verify any remaining trait constraints arising from the function body
+    for (constraint, expr_id) in std::mem::take(&mut type_checker.trait_constraints) {
+        let span = type_checker.interner.expr_span(&expr_id);
+        type_checker.verify_trait_constraint(
+            &constraint.typ,
+            constraint.trait_id,
+            &constraint.trait_generics,
+            expr_id,
+            span,
+        );
+    }
+
+    // Now remove all the `where` clause constraints we added
+    for constraint in &expected_trait_constraints {
+        type_checker.interner.remove_assumed_trait_implementations_for_trait(constraint.trait_id);
+    }
+
+    errors.append(&mut type_checker.errors);
     errors
 }
 
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 65592407d7d..a2aee5e4716 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -589,6 +589,7 @@ impl Type {
                 TypeBinding::Bound(binding) => binding.is_bindable(),
                 TypeBinding::Unbound(_) => true,
             },
+            Type::Alias(alias, args) => alias.borrow().get_type(args).is_bindable(),
             _ => false,
         }
     }
@@ -605,6 +606,15 @@ impl Type {
         matches!(self.follow_bindings(), Type::Integer(Signedness::Unsigned, _))
     }
 
+    pub fn is_numeric(&self) -> bool {
+        use Type::*;
+        use TypeVariableKind as K;
+        matches!(
+            self.follow_bindings(),
+            FieldElement | Integer(..) | Bool | TypeVariable(_, K::Integer | K::IntegerOrField)
+        )
+    }
+
     fn contains_numeric_typevar(&self, target_id: TypeVariableId) -> bool {
         // True if the given type is a NamedGeneric with the target_id
         let named_generic_id_matches_target = |typ: &Type| {
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 6f92cb52a88..c4f0a8d67ba 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1033,19 +1033,19 @@ mod test {
     fn resolve_complex_closures() {
         let src = r#"
             fn main(x: Field) -> pub Field {
-                let closure_without_captures = |x| x + x;
+                let closure_without_captures = |x: Field| -> Field { x + x };
                 let a = closure_without_captures(1);
 
-                let closure_capturing_a_param = |y| y + x;
+                let closure_capturing_a_param = |y: Field| -> Field { y + x };
                 let b = closure_capturing_a_param(2);
 
-                let closure_capturing_a_local_var = |y| y + b;
+                let closure_capturing_a_local_var = |y: Field| -> Field { y + b };
                 let c = closure_capturing_a_local_var(3);
 
-                let closure_with_transitive_captures = |y| {
+                let closure_with_transitive_captures = |y: Field| -> Field {
                     let d = 5;
-                    let nested_closure = |z| {
-                        let doubly_nested_closure = |w| w + x + b;
+                    let nested_closure = |z: Field| -> Field {
+                        let doubly_nested_closure = |w: Field| -> Field { w + x + b };
                         a + z + y + d + x + doubly_nested_closure(4) + x + y
                     };
                     let res = nested_closure(5);
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
index 0eed50eb42b..dde29d7ee87 100644
--- a/noir_stdlib/src/cmp.nr
+++ b/noir_stdlib/src/cmp.nr
@@ -6,10 +6,10 @@ trait Eq {
 
 impl Eq for Field { fn eq(self, other: Field) -> bool { self == other } }
 
-impl Eq for u1 { fn eq(self, other: u1) -> bool { self == other } }
-impl Eq for u8 { fn eq(self, other: u8) -> bool { self == other } }
-impl Eq for u32 { fn eq(self, other: u32) -> bool { self == other } }
 impl Eq for u64 { fn eq(self, other: u64) -> bool { self == other } }
+impl Eq for u32 { fn eq(self, other: u32) -> bool { self == other } }
+impl Eq for u8 { fn eq(self, other: u8) -> bool { self == other } }
+impl Eq for u1 { fn eq(self, other: u1) -> bool { self == other } }
 
 impl Eq for i8 { fn eq(self, other: i8) -> bool { self == other } }
 impl Eq for i32 { fn eq(self, other: i32) -> bool { self == other } }
@@ -107,8 +107,8 @@ trait Ord {
 
 // Note: Field deliberately does not implement Ord
 
-impl Ord for u8 {
-    fn cmp(self, other: u8) -> Ordering {
+impl Ord for u64 {
+    fn cmp(self, other: u64) -> Ordering {
         if self < other {
             Ordering::less()
         } else if self > other {
@@ -131,8 +131,8 @@ impl Ord for u32 {
     }
 }
 
-impl Ord for u64 {
-    fn cmp(self, other: u64) -> Ordering {
+impl Ord for u8 {
+    fn cmp(self, other: u8) -> Ordering {
         if self < other {
             Ordering::less()
         } else if self > other {
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index e561265629e..d855e794fb4 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -6,9 +6,9 @@ trait Add {
 
 impl Add for Field { fn add(self, other: Field) -> Field { self + other } }
 
-impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
-impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
 impl Add for u64 { fn add(self, other: u64) -> u64 { self + other } }
+impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
+impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
 
 impl Add for i8 { fn add(self, other: i8) -> i8 { self + other } }
 impl Add for i32 { fn add(self, other: i32) -> i32 { self + other } }
@@ -22,9 +22,9 @@ trait Sub {
 
 impl Sub for Field { fn sub(self, other: Field) -> Field { self - other } }
 
-impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
-impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
 impl Sub for u64 { fn sub(self, other: u64) -> u64 { self - other } }
+impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
+impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
 
 impl Sub for i8 { fn sub(self, other: i8) -> i8 { self - other } }
 impl Sub for i32 { fn sub(self, other: i32) -> i32 { self - other } }
@@ -38,9 +38,9 @@ trait Mul {
 
 impl Mul for Field { fn mul(self, other: Field) -> Field { self * other } }
 
-impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
-impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
 impl Mul for u64 { fn mul(self, other: u64) -> u64 { self * other } }
+impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
+impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
 
 impl Mul for i8 { fn mul(self, other: i8) -> i8 { self * other } }
 impl Mul for i32 { fn mul(self, other: i32) -> i32 { self * other } }
@@ -54,9 +54,9 @@ trait Div {
 
 impl Div for Field { fn div(self, other: Field) -> Field { self / other } }
 
-impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
-impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
 impl Div for u64 { fn div(self, other: u64) -> u64 { self / other } }
+impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
+impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
 
 impl Div for i8 { fn div(self, other: i8) -> i8 { self / other } }
 impl Div for i32 { fn div(self, other: i32) -> i32 { self / other } }
@@ -68,9 +68,9 @@ trait Rem{
 }
 // docs:end:rem-trait
 
-impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
-impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
 impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
 
 impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
 impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
@@ -84,9 +84,9 @@ trait BitOr {
 
 impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
 
-impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
-impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
 impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
 
 impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
 impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
@@ -100,9 +100,9 @@ trait BitAnd {
 
 impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
 
-impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
-impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
 impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
+impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
+impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
 
 impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
 impl BitAnd for i32 { fn bitand(self, other: i32) -> i32 { self & other } }
@@ -116,9 +116,9 @@ trait BitXor {
 
 impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
 
-impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
-impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
 impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
+impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
+impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
 
 impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
 impl BitXor for i32 { fn bitxor(self, other: i32) -> i32 { self ^ other } }
@@ -130,14 +130,14 @@ trait Shl {
 }
 // docs:end:shl-trait
 
-impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
 impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
 impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u1 { fn shl(self, other: u1) -> u1 { self << other } }
 
-// Bit shifting is not currently supported for signed integer types
-// impl Shl for i8 { fn shl(self, other: i8) -> i8 { self << other } }
-// impl Shl for i32 { fn shl(self, other: i32) -> i32 { self << other } }
-// impl Shl for i64 { fn shl(self, other: i64) -> i64 { self << other } }
+impl Shl for i8 { fn shl(self, other: i8) -> i8 { self << other } }
+impl Shl for i32 { fn shl(self, other: i32) -> i32 { self << other } }
+impl Shl for i64 { fn shl(self, other: i64) -> i64 { self << other } }
 
 // docs:start:shr-trait
 trait Shr {
@@ -145,11 +145,11 @@ trait Shr {
 }
 // docs:end:shr-trait
 
-impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
-impl Shr for u32 { fn shr(self, other: u32) -> u32 { self >> other } }
 impl Shr for u64 { fn shr(self, other: u64) -> u64 { self >> other } }
+impl Shr for u32 { fn shr(self, other: u32) -> u32 { self >> other } }
+impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
+impl Shr for u1 { fn shr(self, other: u1) -> u1 { self >> other } }
 
-// Bit shifting is not currently supported for signed integer types
-// impl Shr for i8 { fn shr(self, other: i8) -> i8 { self >> other } }
-// impl Shr for i32 { fn shr(self, other: i32) -> i32 { self >> other } }
-// impl Shr for i64 { fn shr(self, other: i64) -> i64 { self >> other } }
+impl Shr for i8 { fn shr(self, other: i8) -> i8 { self >> other } }
+impl Shr for i32 { fn shr(self, other: i32) -> i32 { self >> other } }
+impl Shr for i64 { fn shr(self, other: i64) -> i64 { self >> other } }
diff --git a/test_programs/compile_success_empty/regression_4635/Nargo.toml b/test_programs/compile_success_empty/regression_4635/Nargo.toml
new file mode 100644
index 00000000000..563e262410f
--- /dev/null
+++ b/test_programs/compile_success_empty/regression_4635/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_4635"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/regression_4635/src/main.nr b/test_programs/compile_success_empty/regression_4635/src/main.nr
new file mode 100644
index 00000000000..23918e30785
--- /dev/null
+++ b/test_programs/compile_success_empty/regression_4635/src/main.nr
@@ -0,0 +1,59 @@
+trait FromField {
+    fn from_field(field: Field) -> Self;
+}
+
+impl FromField for Field {
+    fn from_field(value: Field) -> Self {
+        value
+    }
+}
+
+trait Deserialize<N> {
+    fn deserialize(fields: [Field; N]) -> Self;
+}
+
+global AZTEC_ADDRESS_LENGTH = 1;
+
+struct AztecAddress {
+    inner : Field
+}
+
+impl FromField for AztecAddress {
+    fn from_field(value: Field) -> Self {
+        Self { inner: value }
+    }
+}
+
+impl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {
+    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {
+        AztecAddress::from_field(fields[0])
+    }
+}
+
+impl Eq for AztecAddress {
+    fn eq(self, other: Self) -> bool {
+        self.inner == other.inner
+    }
+}
+
+// Custom code
+
+struct MyStruct<T> {
+    a: T
+}
+
+impl<T> Deserialize<1> for MyStruct<T> {
+    fn deserialize(fields: [Field; 1]) -> Self where T: FromField {
+        Self{ a: FromField::from_field(fields[0]) }
+    }
+}
+
+fn main() {
+    let fields = [5; 1];
+    let foo = MyStruct::deserialize(fields); // Note I don't specify T here (the type of `foo.a`)
+
+    let bar = AztecAddress { inner: 5 };
+
+    // Here `T` is apparently inferred to be `AztecAddress`, presumably because of the comparison.
+    assert(foo.a == bar);
+}
diff --git a/test_programs/compile_failure/hashmap_load_factor/Nargo.toml b/test_programs/execution_failure/hashmap_load_factor/Nargo.toml
similarity index 100%
rename from test_programs/compile_failure/hashmap_load_factor/Nargo.toml
rename to test_programs/execution_failure/hashmap_load_factor/Nargo.toml
diff --git a/test_programs/execution_failure/hashmap_load_factor/Prover.toml b/test_programs/execution_failure/hashmap_load_factor/Prover.toml
new file mode 100644
index 00000000000..6d72cab47fa
--- /dev/null
+++ b/test_programs/execution_failure/hashmap_load_factor/Prover.toml
@@ -0,0 +1,23 @@
+[[input]]
+key = 1
+value = 0
+
+[[input]]
+key = 2
+value = 0
+
+[[input]]
+key = 3
+value = 0
+
+[[input]]
+key = 4
+value = 0
+
+[[input]]
+key = 5
+value = 0
+
+[[input]]
+key = 6
+value = 0
diff --git a/test_programs/compile_failure/hashmap_load_factor/src/main.nr b/test_programs/execution_failure/hashmap_load_factor/src/main.nr
similarity index 100%
rename from test_programs/compile_failure/hashmap_load_factor/src/main.nr
rename to test_programs/execution_failure/hashmap_load_factor/src/main.nr
diff --git a/test_programs/execution_success/bit_shifts_runtime/src/main.nr b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
index 28b3ef656c1..ff424c9fbf6 100644
--- a/test_programs/execution_success/bit_shifts_runtime/src/main.nr
+++ b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
@@ -7,7 +7,7 @@ fn main(x: u64, y: u64) {
     assert(x >> y == 32);
 
     // Bit-shift with signed integers
-    let mut a :i8 = y as i8;
+    let mut a: i8 = y as i8;
     let mut b: i8 = x as i8;
     assert(b << 1 == -128);
     assert(b >> 2 == 16);

From 03cdba45ac073fd6fdd91549736f36f1abaef15a Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 29 Mar 2024 10:05:23 -0500
Subject: [PATCH 126/416] fix: Error when a type variable is unbound during
 monomorphization instead of defaulting to Field (#4674)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Adds an error when encountering an unbound `TypeVariableKind::Normal`
instead of defaulting it to a Field.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_driver/src/lib.rs              |   4 +-
 compiler/noirc_frontend/src/ast/statement.rs  |  46 ++-
 compiler/noirc_frontend/src/debug/mod.rs      |  10 +-
 .../src/hir/resolution/resolver.rs            |  21 +-
 .../noirc_frontend/src/hir/type_check/stmt.rs |  32 +-
 compiler/noirc_frontend/src/hir_def/stmt.rs   |  12 +
 compiler/noirc_frontend/src/hir_def/types.rs  |  19 +-
 .../src/monomorphization/errors.rs            |  39 ++
 .../src/monomorphization/mod.rs               | 338 +++++++++---------
 compiler/noirc_frontend/src/parser/parser.rs  |  21 +-
 .../array_length_defaulting/Nargo.toml        |   7 +
 .../array_length_defaulting/src/main.nr       |  10 +
 .../typevar_default/Nargo.toml                |   7 +
 .../typevar_default/src/main.nr               |  12 +
 .../compile_success_empty/option/src/main.nr  |   4 +-
 .../execution_success/prelude/src/main.nr     |   4 +-
 tooling/noirc_abi/src/lib.rs                  |   4 +-
 17 files changed, 356 insertions(+), 234 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/monomorphization/errors.rs
 create mode 100644 test_programs/compile_failure/array_length_defaulting/Nargo.toml
 create mode 100644 test_programs/compile_failure/array_length_defaulting/src/main.nr
 create mode 100644 test_programs/compile_failure/typevar_default/Nargo.toml
 create mode 100644 test_programs/compile_failure/typevar_default/src/main.nr

diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 8b3c126dedb..151633f9e33 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -16,7 +16,9 @@ use noirc_frontend::graph::{CrateId, CrateName};
 use noirc_frontend::hir::def_map::{Contract, CrateDefMap};
 use noirc_frontend::hir::Context;
 use noirc_frontend::macros_api::MacroProcessor;
-use noirc_frontend::monomorphization::{monomorphize, monomorphize_debug, MonomorphizationError};
+use noirc_frontend::monomorphization::{
+    errors::MonomorphizationError, monomorphize, monomorphize_debug,
+};
 use noirc_frontend::node_interner::FuncId;
 use noirc_frontend::token::SecondaryAttribute;
 use std::path::Path;
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index b14ead8ad42..dea9fc0f3d3 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -120,7 +120,7 @@ impl StatementKind {
         // Desugar `a <op>= b` to `a = a <op> b`. This relies on the evaluation of `a` having no side effects,
         // which is currently enforced by the restricted syntax of LValues.
         if operator != Token::Assign {
-            let lvalue_expr = lvalue.as_expression(span);
+            let lvalue_expr = lvalue.as_expression();
             let error_msg = "Token passed to Statement::assign is not a binary operator";
 
             let infix = crate::InfixExpression {
@@ -425,9 +425,9 @@ pub struct AssignStatement {
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum LValue {
     Ident(Ident),
-    MemberAccess { object: Box<LValue>, field_name: Ident },
-    Index { array: Box<LValue>, index: Expression },
-    Dereference(Box<LValue>),
+    MemberAccess { object: Box<LValue>, field_name: Ident, span: Span },
+    Index { array: Box<LValue>, index: Expression, span: Span },
+    Dereference(Box<LValue>, Span),
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -484,28 +484,40 @@ impl Recoverable for Pattern {
 }
 
 impl LValue {
-    fn as_expression(&self, span: Span) -> Expression {
+    fn as_expression(&self) -> Expression {
         let kind = match self {
             LValue::Ident(ident) => ExpressionKind::Variable(Path::from_ident(ident.clone())),
-            LValue::MemberAccess { object, field_name } => {
+            LValue::MemberAccess { object, field_name, span: _ } => {
                 ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
-                    lhs: object.as_expression(span),
+                    lhs: object.as_expression(),
                     rhs: field_name.clone(),
                 }))
             }
-            LValue::Index { array, index } => ExpressionKind::Index(Box::new(IndexExpression {
-                collection: array.as_expression(span),
-                index: index.clone(),
-            })),
-            LValue::Dereference(lvalue) => {
+            LValue::Index { array, index, span: _ } => {
+                ExpressionKind::Index(Box::new(IndexExpression {
+                    collection: array.as_expression(),
+                    index: index.clone(),
+                }))
+            }
+            LValue::Dereference(lvalue, _span) => {
                 ExpressionKind::Prefix(Box::new(crate::PrefixExpression {
                     operator: crate::UnaryOp::Dereference { implicitly_added: false },
-                    rhs: lvalue.as_expression(span),
+                    rhs: lvalue.as_expression(),
                 }))
             }
         };
+        let span = self.span();
         Expression::new(kind, span)
     }
+
+    pub fn span(&self) -> Span {
+        match self {
+            LValue::Ident(ident) => ident.span(),
+            LValue::MemberAccess { span, .. }
+            | LValue::Index { span, .. }
+            | LValue::Dereference(_, span) => *span,
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -675,9 +687,11 @@ impl Display for LValue {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             LValue::Ident(ident) => ident.fmt(f),
-            LValue::MemberAccess { object, field_name } => write!(f, "{object}.{field_name}"),
-            LValue::Index { array, index } => write!(f, "{array}[{index}]"),
-            LValue::Dereference(lvalue) => write!(f, "*{lvalue}"),
+            LValue::MemberAccess { object, field_name, span: _ } => {
+                write!(f, "{object}.{field_name}")
+            }
+            LValue::Index { array, index, span: _ } => write!(f, "{array}[{index}]"),
+            LValue::Dereference(lvalue, _span) => write!(f, "*{lvalue}"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 8e5c174d270..71e0d44b478 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -282,7 +282,7 @@ impl DebugInstrumenter {
                     .unwrap_or_else(|| panic!("var lookup failed for var_name={}", &id.0.contents));
                 build_assign_var_stmt(var_id, id_expr(&ident("__debug_expr", id.span())))
             }
-            ast::LValue::Dereference(_lv) => {
+            ast::LValue::Dereference(_lv, span) => {
                 // TODO: this is a dummy statement for now, but we should
                 // somehow track the derefence and update the pointed to
                 // variable
@@ -303,16 +303,16 @@ impl DebugInstrumenter {
                             });
                             break;
                         }
-                        ast::LValue::MemberAccess { object, field_name } => {
+                        ast::LValue::MemberAccess { object, field_name, span } => {
                             cursor = object;
                             let field_name_id = self.insert_field_name(&field_name.0.contents);
-                            indexes.push(sint_expr(-(field_name_id.0 as i128), expression_span));
+                            indexes.push(sint_expr(-(field_name_id.0 as i128), *span));
                         }
-                        ast::LValue::Index { index, array } => {
+                        ast::LValue::Index { index, array, span: _ } => {
                             cursor = array;
                             indexes.push(index.clone());
                         }
-                        ast::LValue::Dereference(_ref) => {
+                        ast::LValue::Dereference(_ref, _span) => {
                             unimplemented![]
                         }
                     }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index f8e3c4cab60..a6511a6b0fb 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1303,18 +1303,23 @@ impl<'a> Resolver<'a> {
 
                 HirLValue::Ident(ident.0, Type::Error)
             }
-            LValue::MemberAccess { object, field_name } => {
-                let object = Box::new(self.resolve_lvalue(*object));
-                HirLValue::MemberAccess { object, field_name, field_index: None, typ: Type::Error }
-            }
-            LValue::Index { array, index } => {
+            LValue::MemberAccess { object, field_name, span } => HirLValue::MemberAccess {
+                object: Box::new(self.resolve_lvalue(*object)),
+                field_name,
+                location: Location::new(span, self.file),
+                field_index: None,
+                typ: Type::Error,
+            },
+            LValue::Index { array, index, span } => {
                 let array = Box::new(self.resolve_lvalue(*array));
                 let index = self.resolve_expression(index);
-                HirLValue::Index { array, index, typ: Type::Error }
+                let location = Location::new(span, self.file);
+                HirLValue::Index { array, index, location, typ: Type::Error }
             }
-            LValue::Dereference(lvalue) => {
+            LValue::Dereference(lvalue, span) => {
                 let lvalue = Box::new(self.resolve_lvalue(*lvalue));
-                HirLValue::Dereference { lvalue, element_type: Type::Error }
+                let location = Location::new(span, self.file);
+                HirLValue::Dereference { lvalue, location, element_type: Type::Error }
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index 69363d5f00a..b97a4530999 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -1,5 +1,5 @@
 use iter_extended::vecmap;
-use noirc_errors::{Location, Span};
+use noirc_errors::Span;
 
 use crate::hir_def::expr::{HirExpression, HirIdent, HirLiteral};
 use crate::hir_def::stmt::{
@@ -195,41 +195,43 @@ impl<'interner> TypeChecker<'interner> {
 
                 (typ.clone(), HirLValue::Ident(ident.clone(), typ), mutable)
             }
-            HirLValue::MemberAccess { object, field_name, .. } => {
+            HirLValue::MemberAccess { object, field_name, location, .. } => {
                 let (lhs_type, object, mut mutable) = self.check_lvalue(object, assign_span);
                 let mut object = Box::new(object);
-                let span = field_name.span();
                 let field_name = field_name.clone();
 
                 let object_ref = &mut object;
                 let mutable_ref = &mut mutable;
+                let location = *location;
 
                 let dereference_lhs = move |_: &mut Self, _, element_type| {
                     // We must create a temporary value first to move out of object_ref before
                     // we eventually reassign to it.
                     let id = DefinitionId::dummy_id();
-                    let location = Location::new(span, fm::FileId::dummy());
                     let ident = HirIdent::non_trait_method(id, location);
                     let tmp_value = HirLValue::Ident(ident, Type::Error);
 
                     let lvalue = std::mem::replace(object_ref, Box::new(tmp_value));
-                    *object_ref = Box::new(HirLValue::Dereference { lvalue, element_type });
+                    *object_ref =
+                        Box::new(HirLValue::Dereference { lvalue, element_type, location });
                     *mutable_ref = true;
                 };
 
                 let name = &field_name.0.contents;
                 let (object_type, field_index) = self
-                    .check_field_access(&lhs_type, name, span, Some(dereference_lhs))
+                    .check_field_access(&lhs_type, name, field_name.span(), Some(dereference_lhs))
                     .unwrap_or((Type::Error, 0));
 
                 let field_index = Some(field_index);
                 let typ = object_type.clone();
-                let lvalue = HirLValue::MemberAccess { object, field_name, field_index, typ };
+                let lvalue =
+                    HirLValue::MemberAccess { object, field_name, field_index, typ, location };
                 (object_type, lvalue, mutable)
             }
-            HirLValue::Index { array, index, .. } => {
+            HirLValue::Index { array, index, location, .. } => {
                 let index_type = self.check_expression(index);
                 let expr_span = self.interner.expr_span(index);
+                let location = *location;
 
                 index_type.unify(
                     &Type::polymorphic_integer_or_field(self.interner),
@@ -248,7 +250,8 @@ impl<'interner> TypeChecker<'interner> {
                 // as needed to unwrap any &mut wrappers.
                 while let Type::MutableReference(element) = lvalue_type.follow_bindings() {
                     let element_type = element.as_ref().clone();
-                    lvalue = HirLValue::Dereference { lvalue: Box::new(lvalue), element_type };
+                    lvalue =
+                        HirLValue::Dereference { lvalue: Box::new(lvalue), element_type, location };
                     lvalue_type = *element;
                     // We know this value to be mutable now since we found an `&mut`
                     mutable = true;
@@ -275,11 +278,12 @@ impl<'interner> TypeChecker<'interner> {
                 };
 
                 let array = Box::new(lvalue);
-                (typ.clone(), HirLValue::Index { array, index: *index, typ }, mutable)
+                (typ.clone(), HirLValue::Index { array, index: *index, typ, location }, mutable)
             }
-            HirLValue::Dereference { lvalue, element_type: _ } => {
+            HirLValue::Dereference { lvalue, element_type: _, location } => {
                 let (reference_type, lvalue, _) = self.check_lvalue(lvalue, assign_span);
                 let lvalue = Box::new(lvalue);
+                let location = *location;
 
                 let element_type = Type::type_variable(self.interner.next_type_variable_id());
                 let expected_type = Type::MutableReference(Box::new(element_type.clone()));
@@ -291,7 +295,11 @@ impl<'interner> TypeChecker<'interner> {
                 });
 
                 // Dereferences are always mutable since we already type checked against a &mut T
-                (element_type.clone(), HirLValue::Dereference { lvalue, element_type }, true)
+                (
+                    element_type.clone(),
+                    HirLValue::Dereference { lvalue, element_type, location },
+                    true,
+                )
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 4e5f718cf47..c5e287b393c 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -99,6 +99,15 @@ impl HirPattern {
             | HirPattern::Struct(_, _, location) => location.span,
         }
     }
+
+    pub(crate) fn location(&self) -> Location {
+        match self {
+            HirPattern::Identifier(ident) => ident.location,
+            HirPattern::Mutable(_, location)
+            | HirPattern::Tuple(_, location)
+            | HirPattern::Struct(_, _, location) => *location,
+        }
+    }
 }
 
 /// Represents an Ast form that can be assigned to. These
@@ -111,14 +120,17 @@ pub enum HirLValue {
         field_name: Ident,
         field_index: Option<usize>,
         typ: Type,
+        location: Location,
     },
     Index {
         array: Box<HirLValue>,
         index: ExprId,
         typ: Type,
+        location: Location,
     },
     Dereference {
         lvalue: Box<HirLValue>,
         element_type: Type,
+        location: Location,
     },
 }
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index a2aee5e4716..ec8b54c33b8 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -543,11 +543,11 @@ impl TypeBinding {
 pub struct TypeVariableId(pub usize);
 
 impl Type {
-    pub fn default_int_type() -> Type {
+    pub fn default_int_or_field_type() -> Type {
         Type::FieldElement
     }
 
-    pub fn default_range_loop_type() -> Type {
+    pub fn default_int_type() -> Type {
         Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour)
     }
 
@@ -787,7 +787,7 @@ impl std::fmt::Display for Type {
             Type::TypeVariable(var, TypeVariableKind::Normal) => write!(f, "{}", var.borrow()),
             Type::TypeVariable(binding, TypeVariableKind::Integer) => {
                 if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                    write!(f, "{}", TypeVariableKind::Integer.default_type())
+                    write!(f, "{}", Type::default_int_type())
                 } else {
                     write!(f, "{}", binding.borrow())
                 }
@@ -1706,11 +1706,12 @@ impl BinaryTypeOperator {
 impl TypeVariableKind {
     /// Returns the default type this type variable should be bound to if it is still unbound
     /// during monomorphization.
-    pub(crate) fn default_type(&self) -> Type {
+    pub(crate) fn default_type(&self) -> Option<Type> {
         match self {
-            TypeVariableKind::IntegerOrField | TypeVariableKind::Normal => Type::default_int_type(),
-            TypeVariableKind::Integer => Type::default_range_loop_type(),
-            TypeVariableKind::Constant(length) => Type::Constant(*length),
+            TypeVariableKind::IntegerOrField => Some(Type::default_int_or_field_type()),
+            TypeVariableKind::Integer => Some(Type::default_int_type()),
+            TypeVariableKind::Constant(length) => Some(Type::Constant(*length)),
+            TypeVariableKind::Normal => None,
         }
     }
 }
@@ -1744,12 +1745,12 @@ impl From<&Type> for PrintableType {
             },
             Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
                 TypeBinding::Bound(typ) => typ.into(),
-                TypeBinding::Unbound(_) => Type::default_range_loop_type().into(),
+                TypeBinding::Unbound(_) => Type::default_int_type().into(),
             },
             Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
                 match &*binding.borrow() {
                     TypeBinding::Bound(typ) => typ.into(),
-                    TypeBinding::Unbound(_) => Type::default_int_type().into(),
+                    TypeBinding::Unbound(_) => Type::default_int_or_field_type().into(),
                 }
             }
             Type::Bool => PrintableType::Boolean,
diff --git a/compiler/noirc_frontend/src/monomorphization/errors.rs b/compiler/noirc_frontend/src/monomorphization/errors.rs
new file mode 100644
index 00000000000..3011c26cffe
--- /dev/null
+++ b/compiler/noirc_frontend/src/monomorphization/errors.rs
@@ -0,0 +1,39 @@
+use thiserror::Error;
+
+use noirc_errors::{CustomDiagnostic, FileDiagnostic, Location};
+
+#[derive(Debug, Error)]
+pub enum MonomorphizationError {
+    #[error("Length of generic array could not be determined.")]
+    UnknownArrayLength { location: Location },
+
+    #[error("Type annotations needed")]
+    TypeAnnotationsNeeded { location: Location },
+}
+
+impl MonomorphizationError {
+    fn location(&self) -> Location {
+        match self {
+            MonomorphizationError::UnknownArrayLength { location }
+            | MonomorphizationError::TypeAnnotationsNeeded { location } => *location,
+        }
+    }
+}
+
+impl From<MonomorphizationError> for FileDiagnostic {
+    fn from(error: MonomorphizationError) -> FileDiagnostic {
+        let location = error.location();
+        let call_stack = vec![location];
+        let diagnostic = error.into_diagnostic();
+        diagnostic.in_file(location.file).with_call_stack(call_stack)
+    }
+}
+
+impl MonomorphizationError {
+    fn into_diagnostic(self) -> CustomDiagnostic {
+        let message = self.to_string();
+        let location = self.location();
+
+        CustomDiagnostic::simple_error(message, String::new(), location.span)
+    }
+}
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 618eba8f190..2223773948f 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -8,16 +8,6 @@
 //!
 //! The entry point to this pass is the `monomorphize` function which, starting from a given
 //! function, will monomorphize the entire reachable program.
-use acvm::FieldElement;
-use iter_extended::{btree_map, try_vecmap, vecmap};
-use noirc_errors::{CustomDiagnostic, FileDiagnostic, Location};
-use noirc_printable_type::PrintableType;
-use std::{
-    collections::{BTreeMap, HashMap, VecDeque},
-    unreachable,
-};
-use thiserror::Error;
-
 use crate::{
     debug::DebugInstrumenter,
     hir_def::{
@@ -31,13 +21,25 @@ use crate::{
     FunctionKind, IntegerBitSize, Signedness, Type, TypeBinding, TypeBindings, TypeVariable,
     TypeVariableKind, UnaryOp, Visibility,
 };
+use acvm::FieldElement;
+use iter_extended::{btree_map, try_vecmap, vecmap};
+use noirc_errors::Location;
+use noirc_printable_type::PrintableType;
+use std::{
+    collections::{BTreeMap, HashMap, VecDeque},
+    unreachable,
+};
 
-use self::ast::{Definition, FuncId, Function, LocalId, Program};
 use self::debug_types::DebugTypeTracker;
+use self::{
+    ast::{Definition, FuncId, Function, LocalId, Program},
+    errors::MonomorphizationError,
+};
 
 pub mod ast;
 mod debug;
 pub mod debug_types;
+pub mod errors;
 pub mod printer;
 
 struct LambdaContext {
@@ -88,40 +90,6 @@ struct Monomorphizer<'interner> {
 
 type HirType = crate::Type;
 
-#[derive(Debug, Error)]
-pub enum MonomorphizationError {
-    #[error("Length of generic array could not be determined.")]
-    UnknownArrayLength { location: Location },
-}
-
-impl MonomorphizationError {
-    fn call_stack(&self) -> Vec<Location> {
-        match self {
-            MonomorphizationError::UnknownArrayLength { location } => vec![*location],
-        }
-    }
-}
-
-impl From<MonomorphizationError> for FileDiagnostic {
-    fn from(error: MonomorphizationError) -> FileDiagnostic {
-        let call_stack = error.call_stack();
-        let file_id = call_stack.last().map(|location| location.file).unwrap_or_default();
-        let diagnostic = error.into_diagnostic();
-        diagnostic.in_file(file_id).with_call_stack(call_stack)
-    }
-}
-
-impl MonomorphizationError {
-    fn into_diagnostic(self) -> CustomDiagnostic {
-        CustomDiagnostic::simple_error(
-                "Internal Consistency Evaluators Errors: \n
-                This is likely a bug. Consider opening an issue at https://github.com/noir-lang/noir/issues".to_owned(),
-                self.to_string(),
-                noirc_errors::Span::inclusive(0, 0)
-            )
-    }
-}
-
 /// Starting from the given `main` function, monomorphize the entire program,
 /// replacing all references to type variables and NamedGenerics with concrete
 /// types, duplicating definitions as necessary to do so.
@@ -308,13 +276,15 @@ impl<'interner> Monomorphizer<'interner> {
 
         let body_expr_id = *self.interner.function(&f).as_expr();
         let body_return_type = self.interner.id_type(body_expr_id);
-        let return_type = self.convert_type(match meta.return_type() {
+        let return_type = match meta.return_type() {
             Type::TraitAsType(..) => &body_return_type,
-            _ => meta.return_type(),
-        });
+            other => other,
+        };
+
+        let return_type = Self::convert_type(return_type, meta.location)?;
         let unconstrained = modifiers.is_unconstrained;
 
-        let parameters = self.parameters(&meta.parameters);
+        let parameters = self.parameters(&meta.parameters)?;
         let body = self.expr(body_expr_id)?;
         let function = ast::Function { id, name, parameters, body, return_type, unconstrained };
 
@@ -329,12 +299,15 @@ impl<'interner> Monomorphizer<'interner> {
 
     /// Monomorphize each parameter, expanding tuple/struct patterns into multiple parameters
     /// and binding any generic types found.
-    fn parameters(&mut self, params: &Parameters) -> Vec<(ast::LocalId, bool, String, ast::Type)> {
+    fn parameters(
+        &mut self,
+        params: &Parameters,
+    ) -> Result<Vec<(ast::LocalId, bool, String, ast::Type)>, MonomorphizationError> {
         let mut new_params = Vec::with_capacity(params.len());
         for (parameter, typ, _) in &params.0 {
-            self.parameter(parameter, typ, &mut new_params);
+            self.parameter(parameter, typ, &mut new_params)?;
         }
-        new_params
+        Ok(new_params)
     }
 
     fn parameter(
@@ -342,21 +315,22 @@ impl<'interner> Monomorphizer<'interner> {
         param: &HirPattern,
         typ: &HirType,
         new_params: &mut Vec<(ast::LocalId, bool, String, ast::Type)>,
-    ) {
+    ) -> Result<(), MonomorphizationError> {
         match param {
             HirPattern::Identifier(ident) => {
                 let new_id = self.next_local_id();
                 let definition = self.interner.definition(ident.id);
                 let name = definition.name.clone();
-                new_params.push((new_id, definition.mutable, name, self.convert_type(typ)));
+                let typ = Self::convert_type(typ, ident.location)?;
+                new_params.push((new_id, definition.mutable, name, typ));
                 self.define_local(ident.id, new_id);
             }
-            HirPattern::Mutable(pattern, _) => self.parameter(pattern, typ, new_params),
+            HirPattern::Mutable(pattern, _) => self.parameter(pattern, typ, new_params)?,
             HirPattern::Tuple(fields, _) => {
                 let tuple_field_types = unwrap_tuple_type(typ);
 
                 for (field, typ) in fields.iter().zip(tuple_field_types) {
-                    self.parameter(field, &typ, new_params);
+                    self.parameter(field, &typ, new_params)?;
                 }
             }
             HirPattern::Struct(_, fields, _) => {
@@ -373,10 +347,11 @@ impl<'interner> Monomorphizer<'interner> {
                         unreachable!("Expected a field named '{field_name}' in the struct pattern")
                     });
 
-                    self.parameter(field, &field_type, new_params);
+                    self.parameter(field, &field_type, new_params)?;
                 }
             }
         }
+        Ok(())
     }
 
     fn expr(
@@ -399,9 +374,10 @@ impl<'interner> Monomorphizer<'interner> {
             }
             HirExpression::Literal(HirLiteral::Bool(value)) => Literal(Bool(value)),
             HirExpression::Literal(HirLiteral::Integer(value, sign)) => {
+                let location = self.interner.id_location(expr);
+                let typ = Self::convert_type(&self.interner.id_type(expr), location)?;
+
                 if sign {
-                    let typ = self.convert_type(&self.interner.id_type(expr));
-                    let location = self.interner.id_location(expr);
                     match typ {
                         ast::Type::Field => Literal(Integer(-value, typ, location)),
                         ast::Type::Integer(_, bit_size) => {
@@ -412,8 +388,6 @@ impl<'interner> Monomorphizer<'interner> {
                         _ => unreachable!("Integer literal must be numeric"),
                     }
                 } else {
-                    let typ = self.convert_type(&self.interner.id_type(expr));
-                    let location = self.interner.id_location(expr);
                     Literal(Integer(value, typ, location))
                 }
             }
@@ -437,7 +411,7 @@ impl<'interner> Monomorphizer<'interner> {
                 ast::Expression::Unary(ast::Unary {
                     operator: prefix.operator,
                     rhs: Box::new(self.expr(prefix.rhs)?),
-                    result_type: self.convert_type(&self.interner.id_type(expr)),
+                    result_type: Self::convert_type(&self.interner.id_type(expr), location)?,
                     location,
                 })
             }
@@ -466,8 +440,8 @@ impl<'interner> Monomorphizer<'interner> {
                     let function_type = Type::Function(args, Box::new(ret.clone()), env);
 
                     let method = infix.trait_method_id;
-                    let func = self.resolve_trait_method_reference(expr, function_type, method);
-                    self.create_operator_impl_call(func, lhs, infix.operator, rhs, ret, location)
+                    let func = self.resolve_trait_method_reference(expr, function_type, method)?;
+                    self.create_operator_impl_call(func, lhs, infix.operator, rhs, ret, location)?
                 } else {
                     let lhs = Box::new(lhs);
                     let rhs = Box::new(rhs);
@@ -485,23 +459,22 @@ impl<'interner> Monomorphizer<'interner> {
 
             HirExpression::Call(call) => self.function_call(call, expr)?,
 
-            HirExpression::Cast(cast) => ast::Expression::Cast(ast::Cast {
-                lhs: Box::new(self.expr(cast.lhs)?),
-                r#type: self.convert_type(&cast.r#type),
-                location: self.interner.expr_location(&expr),
-            }),
+            HirExpression::Cast(cast) => {
+                let location = self.interner.expr_location(&expr);
+                let typ = Self::convert_type(&cast.r#type, location)?;
+                let lhs = Box::new(self.expr(cast.lhs)?);
+                ast::Expression::Cast(ast::Cast { lhs, r#type: typ, location })
+            }
 
             HirExpression::If(if_expr) => {
-                let cond = self.expr(if_expr.condition)?;
-                let then = self.expr(if_expr.consequence)?;
+                let condition = Box::new(self.expr(if_expr.condition)?);
+                let consequence = Box::new(self.expr(if_expr.consequence)?);
                 let else_ =
                     if_expr.alternative.map(|alt| self.expr(alt)).transpose()?.map(Box::new);
-                ast::Expression::If(ast::If {
-                    condition: Box::new(cond),
-                    consequence: Box::new(then),
-                    alternative: else_,
-                    typ: self.convert_type(&self.interner.id_type(expr)),
-                })
+
+                let location = self.interner.expr_location(&expr);
+                let typ = Self::convert_type(&self.interner.id_type(expr), location)?;
+                ast::Expression::If(ast::If { condition, consequence, alternative: else_, typ })
             }
 
             HirExpression::Tuple(fields) => {
@@ -528,7 +501,8 @@ impl<'interner> Monomorphizer<'interner> {
         array_elements: Vec<node_interner::ExprId>,
         is_slice: bool,
     ) -> Result<ast::Expression, MonomorphizationError> {
-        let typ = self.convert_type(&self.interner.id_type(array));
+        let location = self.interner.expr_location(&array);
+        let typ = Self::convert_type(&self.interner.id_type(array), location)?;
         let contents = try_vecmap(array_elements, |id| self.expr(id))?;
         if is_slice {
             Ok(ast::Expression::Literal(ast::Literal::Slice(ast::ArrayLiteral { contents, typ })))
@@ -544,7 +518,8 @@ impl<'interner> Monomorphizer<'interner> {
         length: HirType,
         is_slice: bool,
     ) -> Result<ast::Expression, MonomorphizationError> {
-        let typ = self.convert_type(&self.interner.id_type(array));
+        let location = self.interner.expr_location(&array);
+        let typ = Self::convert_type(&self.interner.id_type(array), location)?;
 
         let length = length.evaluate_to_u64().ok_or_else(|| {
             let location = self.interner.expr_location(&array);
@@ -564,7 +539,8 @@ impl<'interner> Monomorphizer<'interner> {
         id: node_interner::ExprId,
         index: HirIndexExpression,
     ) -> Result<ast::Expression, MonomorphizationError> {
-        let element_type = self.convert_type(&self.interner.id_type(id));
+        let location = self.interner.expr_location(&id);
+        let element_type = Self::convert_type(&self.interner.id_type(id), location)?;
 
         let collection = Box::new(self.expr(index.collection)?);
         let index = Box::new(self.expr(index.index)?);
@@ -595,11 +571,14 @@ impl<'interner> Monomorphizer<'interner> {
                 self.define_local(for_loop.identifier.id, index_variable);
 
                 let block = Box::new(self.expr(for_loop.block)?);
+                let index_location = for_loop.identifier.location;
+                let index_type = self.interner.id_type(for_loop.start_range);
+                let index_type = Self::convert_type(&index_type, index_location)?;
 
                 Ok(ast::Expression::For(ast::For {
                     index_variable,
                     index_name: self.interner.definition_name(for_loop.identifier.id).to_owned(),
-                    index_type: self.convert_type(&self.interner.id_type(for_loop.start_range)),
+                    index_type,
                     start_range: Box::new(start),
                     end_range: Box::new(end),
                     start_range_location: self.interner.expr_location(&for_loop.start_range),
@@ -623,7 +602,7 @@ impl<'interner> Monomorphizer<'interner> {
     ) -> Result<ast::Expression, MonomorphizationError> {
         let expr = self.expr(let_statement.expression)?;
         let expected_type = self.interner.id_type(let_statement.expression);
-        Ok(self.unpack_pattern(let_statement.pattern, expr, &expected_type))
+        self.unpack_pattern(let_statement.pattern, expr, &expected_type)
     }
 
     fn constructor(
@@ -644,7 +623,8 @@ impl<'interner> Monomorphizer<'interner> {
         for (field_name, expr_id) in constructor.fields {
             let new_id = self.next_local_id();
             let field_type = field_type_map.get(&field_name.0.contents).unwrap();
-            let typ = self.convert_type(field_type);
+            let location = self.interner.expr_location(&expr_id);
+            let typ = Self::convert_type(field_type, location)?;
 
             field_vars.insert(field_name.0.contents.clone(), (new_id, typ));
             let expression = Box::new(self.expr(expr_id)?);
@@ -688,19 +668,19 @@ impl<'interner> Monomorphizer<'interner> {
         pattern: HirPattern,
         value: ast::Expression,
         typ: &HirType,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         match pattern {
             HirPattern::Identifier(ident) => {
                 let new_id = self.next_local_id();
                 self.define_local(ident.id, new_id);
                 let definition = self.interner.definition(ident.id);
 
-                ast::Expression::Let(ast::Let {
+                Ok(ast::Expression::Let(ast::Let {
                     id: new_id,
                     mutable: definition.mutable,
                     name: definition.name.clone(),
                     expression: Box::new(value),
-                })
+                }))
             }
             HirPattern::Mutable(pattern, _) => self.unpack_pattern(*pattern, value, typ),
             HirPattern::Tuple(patterns, _) => {
@@ -729,7 +709,7 @@ impl<'interner> Monomorphizer<'interner> {
         &mut self,
         value: ast::Expression,
         fields: impl Iterator<Item = (HirPattern, HirType)>,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let fresh_id = self.next_local_id();
 
         let mut definitions = vec![ast::Expression::Let(ast::Let {
@@ -740,21 +720,22 @@ impl<'interner> Monomorphizer<'interner> {
         })];
 
         for (i, (field_pattern, field_type)) in fields.into_iter().enumerate() {
-            let location = None;
+            let location = field_pattern.location();
             let mutable = false;
             let definition = Definition::Local(fresh_id);
             let name = i.to_string();
-            let typ = self.convert_type(&field_type);
+            let typ = Self::convert_type(&field_type, location)?;
 
+            let location = Some(location);
             let new_rhs =
                 ast::Expression::Ident(ast::Ident { location, mutable, definition, name, typ });
 
             let new_rhs = ast::Expression::ExtractTupleField(Box::new(new_rhs), i);
-            let new_expr = self.unpack_pattern(field_pattern, new_rhs, &field_type);
+            let new_expr = self.unpack_pattern(field_pattern, new_rhs, &field_type)?;
             definitions.push(new_expr);
         }
 
-        ast::Expression::Block(definitions)
+        Ok(ast::Expression::Block(definitions))
     }
 
     /// Find a captured variable in the innermost closure, and construct an expression
@@ -780,15 +761,20 @@ impl<'interner> Monomorphizer<'interner> {
     }
 
     /// A local (ie non-global) ident only
-    fn local_ident(&mut self, ident: &HirIdent) -> Option<ast::Ident> {
+    fn local_ident(
+        &mut self,
+        ident: &HirIdent,
+    ) -> Result<Option<ast::Ident>, MonomorphizationError> {
         let definition = self.interner.definition(ident.id);
         let name = definition.name.clone();
         let mutable = definition.mutable;
 
-        let definition = self.lookup_local(ident.id)?;
-        let typ = self.convert_type(&self.interner.definition_type(ident.id));
+        let Some(definition) = self.lookup_local(ident.id) else {
+            return Ok(None);
+        };
 
-        Some(ast::Ident { location: Some(ident.location), mutable, definition, name, typ })
+        let typ = Self::convert_type(&self.interner.definition_type(ident.id), ident.location)?;
+        Ok(Some(ast::Ident { location: Some(ident.location), mutable, definition, name, typ }))
     }
 
     fn ident(
@@ -799,7 +785,7 @@ impl<'interner> Monomorphizer<'interner> {
         let typ = self.interner.id_type(expr_id);
 
         if let ImplKind::TraitMethod(method, _, _) = ident.impl_kind {
-            return Ok(self.resolve_trait_method_reference(expr_id, typ, method));
+            return self.resolve_trait_method_reference(expr_id, typ, method);
         }
 
         let definition = self.interner.definition(ident.id);
@@ -809,7 +795,7 @@ impl<'interner> Monomorphizer<'interner> {
                 let location = Some(ident.location);
                 let name = definition.name.clone();
                 let definition = self.lookup_function(*func_id, expr_id, &typ, None);
-                let typ = self.convert_type(&typ);
+                let typ = Self::convert_type(&typ, ident.location)?;
                 let ident = ast::Ident { location, mutable, definition, name, typ: typ.clone() };
                 let ident_expression = ast::Expression::Ident(ident);
                 if self.is_function_closure_type(&typ) {
@@ -832,10 +818,13 @@ impl<'interner> Monomorphizer<'interner> {
                 };
                 self.expr(let_.expression)?
             }
-            DefinitionKind::Local(_) => self.lookup_captured_expr(ident.id).unwrap_or_else(|| {
-                let ident = self.local_ident(&ident).unwrap();
-                ast::Expression::Ident(ident)
-            }),
+            DefinitionKind::Local(_) => match self.lookup_captured_expr(ident.id) {
+                Some(expr) => expr,
+                None => {
+                    let ident = self.local_ident(&ident)?.unwrap();
+                    ast::Expression::Ident(ident)
+                }
+            },
             DefinitionKind::GenericType(type_variable) => {
                 let value = match &*type_variable.borrow() {
                     TypeBinding::Unbound(_) => {
@@ -848,7 +837,7 @@ impl<'interner> Monomorphizer<'interner> {
 
                 let value = FieldElement::from(value as u128);
                 let location = self.interner.id_location(expr_id);
-                let typ = self.convert_type(&typ);
+                let typ = Self::convert_type(&typ, ident.location)?;
                 ast::Expression::Literal(ast::Literal::Integer(value, typ, location))
             }
         };
@@ -857,26 +846,28 @@ impl<'interner> Monomorphizer<'interner> {
     }
 
     /// Convert a non-tuple/struct type to a monomorphized type
-    fn convert_type(&self, typ: &HirType) -> ast::Type {
-        match typ {
+    fn convert_type(typ: &HirType, location: Location) -> Result<ast::Type, MonomorphizationError> {
+        Ok(match typ {
             HirType::FieldElement => ast::Type::Field,
             HirType::Integer(sign, bits) => ast::Type::Integer(*sign, *bits),
             HirType::Bool => ast::Type::Bool,
             HirType::String(size) => ast::Type::String(size.evaluate_to_u64().unwrap_or(0)),
             HirType::FmtString(size, fields) => {
                 let size = size.evaluate_to_u64().unwrap_or(0);
-                let fields = Box::new(self.convert_type(fields.as_ref()));
+                let fields = Box::new(Self::convert_type(fields.as_ref(), location)?);
                 ast::Type::FmtString(size, fields)
             }
             HirType::Unit => ast::Type::Unit,
             HirType::Array(length, element) => {
-                let element = Box::new(self.convert_type(element.as_ref()));
-                // TODO: convert to MonomorphizationError
-                let length = length.evaluate_to_u64().unwrap_or(0);
+                let element = Box::new(Self::convert_type(element.as_ref(), location)?);
+                let length = match length.evaluate_to_u64() {
+                    Some(length) => length,
+                    None => return Err(MonomorphizationError::TypeAnnotationsNeeded { location }),
+                };
                 ast::Type::Array(length, element)
             }
             HirType::Slice(element) => {
-                let element = Box::new(self.convert_type(element.as_ref()));
+                let element = Box::new(Self::convert_type(element.as_ref(), location)?);
                 ast::Type::Slice(element)
             }
             HirType::TraitAsType(..) => {
@@ -884,55 +875,53 @@ impl<'interner> Monomorphizer<'interner> {
             }
             HirType::NamedGeneric(binding, _) => {
                 if let TypeBinding::Bound(binding) = &*binding.borrow() {
-                    return self.convert_type(binding);
+                    return Self::convert_type(binding, location);
                 }
 
                 // Default any remaining unbound type variables.
                 // This should only happen if the variable in question is unused
                 // and within a larger generic type.
-                binding.bind(HirType::default_int_type());
+                binding.bind(HirType::default_int_or_field_type());
                 ast::Type::Field
             }
 
             HirType::TypeVariable(binding, kind) => {
                 if let TypeBinding::Bound(binding) = &*binding.borrow() {
-                    return self.convert_type(binding);
+                    return Self::convert_type(binding, location);
                 }
 
                 // Default any remaining unbound type variables.
                 // This should only happen if the variable in question is unused
                 // and within a larger generic type.
-                let default = if self.is_range_loop
-                    && (matches!(kind, TypeVariableKind::IntegerOrField)
-                        || matches!(kind, TypeVariableKind::Integer))
-                {
-                    Type::default_range_loop_type()
-                } else {
-                    kind.default_type()
+                let default = match kind.default_type() {
+                    Some(typ) => typ,
+                    None => return Err(MonomorphizationError::TypeAnnotationsNeeded { location }),
                 };
 
-                let monomorphized_default = self.convert_type(&default);
+                let monomorphized_default = Self::convert_type(&default, location)?;
                 binding.bind(default);
                 monomorphized_default
             }
 
             HirType::Struct(def, args) => {
                 let fields = def.borrow().get_fields(args);
-                let fields = vecmap(fields, |(_, field)| self.convert_type(&field));
+                let fields = try_vecmap(fields, |(_, field)| Self::convert_type(&field, location))?;
                 ast::Type::Tuple(fields)
             }
 
-            HirType::Alias(def, args) => self.convert_type(&def.borrow().get_type(args)),
+            HirType::Alias(def, args) => {
+                Self::convert_type(&def.borrow().get_type(args), location)?
+            }
 
             HirType::Tuple(fields) => {
-                let fields = vecmap(fields, |x| self.convert_type(x));
+                let fields = try_vecmap(fields, |x| Self::convert_type(x, location))?;
                 ast::Type::Tuple(fields)
             }
 
             HirType::Function(args, ret, env) => {
-                let args = vecmap(args, |x| self.convert_type(x));
-                let ret = Box::new(self.convert_type(ret));
-                let env = self.convert_type(env);
+                let args = try_vecmap(args, |x| Self::convert_type(x, location))?;
+                let ret = Box::new(Self::convert_type(ret, location)?);
+                let env = Self::convert_type(env, location)?;
                 match &env {
                     ast::Type::Unit => ast::Type::Function(args, ret, Box::new(env)),
                     ast::Type::Tuple(_elements) => ast::Type::Tuple(vec![
@@ -948,7 +937,7 @@ impl<'interner> Monomorphizer<'interner> {
             }
 
             HirType::MutableReference(element) => {
-                let element = self.convert_type(element);
+                let element = Self::convert_type(element, location)?;
                 ast::Type::MutableReference(Box::new(element))
             }
 
@@ -956,7 +945,7 @@ impl<'interner> Monomorphizer<'interner> {
                 unreachable!("Unexpected type {} found", typ)
             }
             HirType::Code => unreachable!("Tried to translate Code type into runtime code"),
-        }
+        })
     }
 
     fn is_function_closure(&self, t: ast::Type) -> bool {
@@ -987,7 +976,7 @@ impl<'interner> Monomorphizer<'interner> {
         expr_id: node_interner::ExprId,
         function_type: HirType,
         method: TraitMethodId,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let trait_impl = self
             .interner
             .get_selected_impl_for_expression(expr_id)
@@ -1031,13 +1020,15 @@ impl<'interner> Monomorphizer<'interner> {
         };
 
         let the_trait = self.interner.get_trait(method.trait_id);
-        ast::Expression::Ident(ast::Ident {
+        let location = self.interner.expr_location(&expr_id);
+
+        Ok(ast::Expression::Ident(ast::Ident {
             definition: Definition::Function(func_id),
             mutable: false,
             location: None,
             name: the_trait.methods[method.method_index].name.0.contents.clone(),
-            typ: self.convert_type(&function_type),
-        })
+            typ: Self::convert_type(&function_type, location)?,
+        }))
     }
 
     fn function_call(
@@ -1052,7 +1043,8 @@ impl<'interner> Monomorphizer<'interner> {
         self.patch_debug_instrumentation_call(&call, &mut arguments)?;
 
         let return_type = self.interner.id_type(id);
-        let return_type = self.convert_type(&return_type);
+        let location = self.interner.expr_location(&id);
+        let return_type = Self::convert_type(&return_type, location)?;
 
         let location = call.location;
 
@@ -1072,7 +1064,7 @@ impl<'interner> Monomorphizer<'interner> {
 
         let mut block_expressions = vec![];
         let func_type = self.interner.id_type(call.func);
-        let func_type = self.convert_type(&func_type);
+        let func_type = Self::convert_type(&func_type, location)?;
         let is_closure = self.is_function_closure(func_type);
 
         let func = if is_closure {
@@ -1094,7 +1086,7 @@ impl<'interner> Monomorphizer<'interner> {
                 definition: Definition::Local(local_id),
                 mutable: false,
                 name: "tmp".to_string(),
-                typ: self.convert_type(&self.interner.id_type(call.func)),
+                typ: Self::convert_type(&self.interner.id_type(call.func), location)?,
             });
 
             let env_argument =
@@ -1293,24 +1285,24 @@ impl<'interner> Monomorphizer<'interner> {
 
     fn lvalue(&mut self, lvalue: HirLValue) -> Result<ast::LValue, MonomorphizationError> {
         let value = match lvalue {
-            HirLValue::Ident(ident, _) => self
-                .lookup_captured_lvalue(ident.id)
-                .unwrap_or_else(|| ast::LValue::Ident(self.local_ident(&ident).unwrap())),
+            HirLValue::Ident(ident, _) => match self.lookup_captured_lvalue(ident.id) {
+                Some(value) => value,
+                None => ast::LValue::Ident(self.local_ident(&ident)?.unwrap()),
+            },
             HirLValue::MemberAccess { object, field_index, .. } => {
                 let field_index = field_index.unwrap();
                 let object = Box::new(self.lvalue(*object)?);
                 ast::LValue::MemberAccess { object, field_index }
             }
-            HirLValue::Index { array, index, typ } => {
-                let location = self.interner.expr_location(&index);
+            HirLValue::Index { array, index, typ, location } => {
                 let array = Box::new(self.lvalue(*array)?);
                 let index = Box::new(self.expr(index)?);
-                let element_type = self.convert_type(&typ);
+                let element_type = Self::convert_type(&typ, location)?;
                 ast::LValue::Index { array, index, element_type, location }
             }
-            HirLValue::Dereference { lvalue, element_type } => {
+            HirLValue::Dereference { lvalue, element_type, location } => {
                 let reference = Box::new(self.lvalue(*lvalue)?);
-                let element_type = self.convert_type(&element_type);
+                let element_type = Self::convert_type(&element_type, location)?;
                 ast::LValue::Dereference { reference, element_type }
             }
         };
@@ -1324,7 +1316,7 @@ impl<'interner> Monomorphizer<'interner> {
         expr: node_interner::ExprId,
     ) -> Result<ast::Expression, MonomorphizationError> {
         if lambda.captures.is_empty() {
-            self.lambda_no_capture(lambda)
+            self.lambda_no_capture(lambda, expr)
         } else {
             let (setup, closure_variable) = self.lambda_with_setup(lambda, expr)?;
             Ok(ast::Expression::Block(vec![setup, closure_variable]))
@@ -1334,16 +1326,19 @@ impl<'interner> Monomorphizer<'interner> {
     fn lambda_no_capture(
         &mut self,
         lambda: HirLambda,
+        expr: node_interner::ExprId,
     ) -> Result<ast::Expression, MonomorphizationError> {
-        let ret_type = self.convert_type(&lambda.return_type);
+        let location = self.interner.expr_location(&expr);
+        let ret_type = Self::convert_type(&lambda.return_type, location)?;
         let lambda_name = "lambda";
-        let parameter_types = vecmap(&lambda.parameters, |(_, typ)| self.convert_type(typ));
+        let parameter_types =
+            try_vecmap(&lambda.parameters, |(_, typ)| Self::convert_type(typ, location))?;
 
         // Manually convert to Parameters type so we can reuse the self.parameters method
         let parameters =
             vecmap(lambda.parameters, |(pattern, typ)| (pattern, typ, Visibility::Private)).into();
 
-        let parameters = self.parameters(&parameters);
+        let parameters = self.parameters(&parameters)?;
         let body = self.expr(lambda.body)?;
 
         let id = self.next_function_id();
@@ -1386,15 +1381,17 @@ impl<'interner> Monomorphizer<'interner> {
         // patterns in the resulting tree,
         // which seems more fragile, we directly reuse the return parameters
         // of this function in those cases
-        let ret_type = self.convert_type(&lambda.return_type);
+        let location = self.interner.expr_location(&expr);
+        let ret_type = Self::convert_type(&lambda.return_type, location)?;
         let lambda_name = "lambda";
-        let parameter_types = vecmap(&lambda.parameters, |(_, typ)| self.convert_type(typ));
+        let parameter_types =
+            try_vecmap(&lambda.parameters, |(_, typ)| Self::convert_type(typ, location))?;
 
         // Manually convert to Parameters type so we can reuse the self.parameters method
         let parameters =
             vecmap(lambda.parameters, |(pattern, typ)| (pattern, typ, Visibility::Private)).into();
 
-        let mut converted_parameters = self.parameters(&parameters);
+        let mut converted_parameters = self.parameters(&parameters)?;
 
         let id = self.next_function_id();
         let name = lambda_name.to_owned();
@@ -1402,26 +1399,27 @@ impl<'interner> Monomorphizer<'interner> {
 
         let env_local_id = self.next_local_id();
         let env_name = "env";
-        let env_tuple = ast::Expression::Tuple(vecmap(&lambda.captures, |capture| {
-            match capture.transitive_capture_index {
-                Some(field_index) => match self.lambda_envs_stack.last() {
-                    Some(lambda_ctx) => ast::Expression::ExtractTupleField(
-                        Box::new(ast::Expression::Ident(lambda_ctx.env_ident.clone())),
-                        field_index,
-                    ),
-                    None => unreachable!(
-                        "Expected to find a parent closure environment, but found none"
-                    ),
-                },
-                None => {
-                    let ident = self.local_ident(&capture.ident).unwrap();
-                    ast::Expression::Ident(ident)
+        let env_tuple =
+            ast::Expression::Tuple(try_vecmap(&lambda.captures, |capture| {
+                match capture.transitive_capture_index {
+                    Some(field_index) => {
+                        let lambda_ctx = self.lambda_envs_stack.last().expect(
+                            "Expected to find a parent closure environment, but found none",
+                        );
+
+                        let ident = Box::new(ast::Expression::Ident(lambda_ctx.env_ident.clone()));
+                        Ok(ast::Expression::ExtractTupleField(ident, field_index))
+                    }
+                    None => {
+                        let ident = self.local_ident(&capture.ident)?.unwrap();
+                        Ok(ast::Expression::Ident(ident))
+                    }
                 }
-            }
-        }));
+            })?);
+
         let expr_type = self.interner.id_type(expr);
         let env_typ = if let types::Type::Function(_, _, function_env_type) = expr_type {
-            self.convert_type(&function_env_type)
+            Self::convert_type(&function_env_type, location)?
         } else {
             unreachable!("expected a Function type for a Lambda node")
         };
@@ -1612,10 +1610,10 @@ impl<'interner> Monomorphizer<'interner> {
         rhs: ast::Expression,
         ret: Type,
         location: Location,
-    ) -> ast::Expression {
+    ) -> Result<ast::Expression, MonomorphizationError> {
         let arguments = vec![lhs, rhs];
         let func = Box::new(func);
-        let return_type = self.convert_type(&ret);
+        let return_type = Self::convert_type(&ret, location)?;
 
         let mut result =
             ast::Expression::Call(ast::Call { func, arguments, return_type, location });
@@ -1660,7 +1658,7 @@ impl<'interner> Monomorphizer<'interner> {
             _ => (),
         }
 
-        result
+        Ok(result)
     }
 
     /// Call sites are instantiated against the trait method, but when an impl is later selected,
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index a40355be8aa..7ecff12163a 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -526,8 +526,8 @@ fn assign_operator() -> impl NoirParser<Token> {
 }
 
 enum LValueRhs {
-    MemberAccess(Ident),
-    Index(Expression),
+    MemberAccess(Ident, Span),
+    Index(Expression, Span),
 }
 
 fn lvalue<'a, P>(expr_parser: P) -> impl NoirParser<LValue> + 'a
@@ -539,23 +539,28 @@ where
 
         let dereferences = just(Token::Star)
             .ignore_then(lvalue.clone())
-            .map(|lvalue| LValue::Dereference(Box::new(lvalue)));
+            .map_with_span(|lvalue, span| LValue::Dereference(Box::new(lvalue), span));
 
         let parenthesized = lvalue.delimited_by(just(Token::LeftParen), just(Token::RightParen));
 
         let term = choice((parenthesized, dereferences, l_ident));
 
-        let l_member_rhs = just(Token::Dot).ignore_then(field_name()).map(LValueRhs::MemberAccess);
+        let l_member_rhs =
+            just(Token::Dot).ignore_then(field_name()).map_with_span(LValueRhs::MemberAccess);
 
         let l_index = expr_parser
             .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-            .map(LValueRhs::Index);
+            .map_with_span(LValueRhs::Index);
 
         term.then(l_member_rhs.or(l_index).repeated()).foldl(|lvalue, rhs| match rhs {
-            LValueRhs::MemberAccess(field_name) => {
-                LValue::MemberAccess { object: Box::new(lvalue), field_name }
+            LValueRhs::MemberAccess(field_name, span) => {
+                let span = lvalue.span().merge(span);
+                LValue::MemberAccess { object: Box::new(lvalue), field_name, span }
+            }
+            LValueRhs::Index(index, span) => {
+                let span = lvalue.span().merge(span);
+                LValue::Index { array: Box::new(lvalue), index, span }
             }
-            LValueRhs::Index(index) => LValue::Index { array: Box::new(lvalue), index },
         })
     })
 }
diff --git a/test_programs/compile_failure/array_length_defaulting/Nargo.toml b/test_programs/compile_failure/array_length_defaulting/Nargo.toml
new file mode 100644
index 00000000000..fa376596ee2
--- /dev/null
+++ b/test_programs/compile_failure/array_length_defaulting/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "array_length_defaulting"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
diff --git a/test_programs/compile_failure/array_length_defaulting/src/main.nr b/test_programs/compile_failure/array_length_defaulting/src/main.nr
new file mode 100644
index 00000000000..216a9ae3f0c
--- /dev/null
+++ b/test_programs/compile_failure/array_length_defaulting/src/main.nr
@@ -0,0 +1,10 @@
+fn main() {
+    let x = dep::std::unsafe::zeroed();
+    foo(x);
+}
+
+fn foo<N>(array: [Field; N]) {
+    for elem in array {
+        println(elem);
+    }
+}
diff --git a/test_programs/compile_failure/typevar_default/Nargo.toml b/test_programs/compile_failure/typevar_default/Nargo.toml
new file mode 100644
index 00000000000..b3cd08bb8fe
--- /dev/null
+++ b/test_programs/compile_failure/typevar_default/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "typevar_default"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/typevar_default/src/main.nr b/test_programs/compile_failure/typevar_default/src/main.nr
new file mode 100644
index 00000000000..1eb9cf63de3
--- /dev/null
+++ b/test_programs/compile_failure/typevar_default/src/main.nr
@@ -0,0 +1,12 @@
+fn main() {
+    // Expecting error: type annotations needed (N not known)
+    let _ = slice_to_array(&[1, 2, 3]);
+}
+
+fn slice_to_array<N>(slice: [Field]) -> [Field; N] {
+    let mut array = [0; N];
+    for i in 0 .. N {
+        array[i] = slice[i];
+    }
+    array
+}
diff --git a/test_programs/compile_success_empty/option/src/main.nr b/test_programs/compile_success_empty/option/src/main.nr
index 989c8f65bf4..c5f321256b1 100644
--- a/test_programs/compile_success_empty/option/src/main.nr
+++ b/test_programs/compile_success_empty/option/src/main.nr
@@ -39,9 +39,9 @@ fn main() {
 
     let add1_u64 = |value: Field| Option::some(value as u64 + 1);
 
-    assert(none.and_then(|_value| Option::none()).is_none());
+    assert(none.and_then(|_value| none).is_none());
     assert(none.and_then(add1_u64).is_none());
-    assert(some.and_then(|_value| Option::none()).is_none());
+    assert(some.and_then(|_value| none).is_none());
     assert(some.and_then(add1_u64).unwrap() == 4);
     assert(some.and_then(|x| Option::some(x + ten)).unwrap() == 13);
 
diff --git a/test_programs/execution_success/prelude/src/main.nr b/test_programs/execution_success/prelude/src/main.nr
index c9ae448c486..226341f1e7b 100644
--- a/test_programs/execution_success/prelude/src/main.nr
+++ b/test_programs/execution_success/prelude/src/main.nr
@@ -1,6 +1,6 @@
 fn main() {
-    let _xs = Vec::new();
-    let _option = Option::none();
+    let _xs: Vec<Field> = Vec::new();
+    let _option: Option<Field> = Option::none();
 
     print("42\n");
     println("42");
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index cffb0c20cd5..d0dcb373963 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -147,7 +147,9 @@ impl AbiType {
             Type::TypeVariable(binding, TypeVariableKind::IntegerOrField)
             | Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
                 TypeBinding::Bound(typ) => Self::from_type(context, typ),
-                TypeBinding::Unbound(_) => Self::from_type(context, &Type::default_int_type()),
+                TypeBinding::Unbound(_) => {
+                    Self::from_type(context, &Type::default_int_or_field_type())
+                }
             },
             Type::Bool => Self::Boolean,
             Type::String(size) => {

From c08cc4fcf1cd949bed65ba422759d70b1e154929 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Fri, 29 Mar 2024 12:20:27 -0400
Subject: [PATCH 127/416] chore: add big list of naughty strings test for lexer
 (#4617)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4613

## Summary\*

Converts BLNS items into simple test programs and runs them through the
lexer.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .github/Cross.toml                            |   3 +-
 Cargo.lock                                    |   9 +-
 compiler/noirc_frontend/Cargo.toml            |   1 +
 compiler/noirc_frontend/build.rs              |  15 +
 compiler/noirc_frontend/src/blns/LICENSE      |  21 +
 compiler/noirc_frontend/src/blns/README.md    |   9 +
 .../noirc_frontend/src/blns/blns.base64.json  | 679 ++++++++++++++++++
 compiler/noirc_frontend/src/lexer/lexer.rs    | 110 +++
 8 files changed, 842 insertions(+), 5 deletions(-)
 create mode 100644 compiler/noirc_frontend/build.rs
 create mode 100644 compiler/noirc_frontend/src/blns/LICENSE
 create mode 100644 compiler/noirc_frontend/src/blns/README.md
 create mode 100644 compiler/noirc_frontend/src/blns/blns.base64.json

diff --git a/.github/Cross.toml b/.github/Cross.toml
index 09e6316a59c..6520a288d5d 100644
--- a/.github/Cross.toml
+++ b/.github/Cross.toml
@@ -2,7 +2,8 @@
 passthrough = [
     "HOME",
     "RUST_BACKTRACE",
-    "BARRETENBERG_BIN_DIR"
+    "BARRETENBERG_BIN_DIR",
+    "BLNS_JSON_PATH"
 ]
 volumes = [
     "HOME",
diff --git a/Cargo.lock b/Cargo.lock
index c42c2b5d74e..2f85b26f974 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1044,9 +1044,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
 [[package]]
 name = "corosensei"
@@ -3088,6 +3088,7 @@ version = "0.26.0"
 dependencies = [
  "acvm",
  "arena",
+ "base64 0.21.2",
  "chumsky",
  "fm",
  "iter-extended",
@@ -4555,9 +4556,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "smawk"
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index a3a8d460572..03b92e15032 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -26,6 +26,7 @@ tracing.workspace = true
 petgraph = "0.6"
 
 [dev-dependencies]
+base64.workspace = true
 strum = "0.24"
 strum_macros = "0.24"
 tempfile.workspace = true
diff --git a/compiler/noirc_frontend/build.rs b/compiler/noirc_frontend/build.rs
new file mode 100644
index 00000000000..53ae9489168
--- /dev/null
+++ b/compiler/noirc_frontend/build.rs
@@ -0,0 +1,15 @@
+use std::path::PathBuf;
+
+const BLNS_JSON_PATH: &str = "BLNS_JSON_PATH";
+
+fn main() -> Result<(), String> {
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+
+    let dest_path = PathBuf::from(out_dir.clone()).join("blns.base64.json");
+    let dest_path_str = dest_path.to_str().unwrap();
+
+    println!("cargo:rustc-env={BLNS_JSON_PATH}={dest_path_str}");
+    std::fs::copy("./src/blns/blns.base64.json", dest_path).unwrap();
+
+    Ok(())
+}
diff --git a/compiler/noirc_frontend/src/blns/LICENSE b/compiler/noirc_frontend/src/blns/LICENSE
new file mode 100644
index 00000000000..4ab5bbd793b
--- /dev/null
+++ b/compiler/noirc_frontend/src/blns/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2020 Max Woolf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/compiler/noirc_frontend/src/blns/README.md b/compiler/noirc_frontend/src/blns/README.md
new file mode 100644
index 00000000000..201ed68aef0
--- /dev/null
+++ b/compiler/noirc_frontend/src/blns/README.md
@@ -0,0 +1,9 @@
+# BLNS
+
+[Big List of Naughty Strings](https://github.com/minimaxir/big-list-of-naughty-strings)
+
+## Updating
+
+```bash
+wget -O blns.base64.json "https://raw.githubusercontent.com/minimaxir/big-list-of-naughty-strings/master/blns.base64.json"
+```
diff --git a/compiler/noirc_frontend/src/blns/blns.base64.json b/compiler/noirc_frontend/src/blns/blns.base64.json
new file mode 100644
index 00000000000..18e61c0d2c4
--- /dev/null
+++ b/compiler/noirc_frontend/src/blns/blns.base64.json
@@ -0,0 +1,679 @@
+[
+  "", 
+  "dW5kZWZpbmVk", 
+  "dW5kZWY=", 
+  "bnVsbA==", 
+  "TlVMTA==", 
+  "KG51bGwp", 
+  "bmls", 
+  "TklM", 
+  "dHJ1ZQ==", 
+  "ZmFsc2U=", 
+  "VHJ1ZQ==", 
+  "RmFsc2U=", 
+  "VFJVRQ==", 
+  "RkFMU0U=", 
+  "Tm9uZQ==", 
+  "aGFzT3duUHJvcGVydHk=", 
+  "XA==", 
+  "MA==", 
+  "MQ==", 
+  "MS4wMA==", 
+  "JDEuMDA=", 
+  "MS8y", 
+  "MUUy", 
+  "MUUwMg==", 
+  "MUUrMDI=", 
+  "LTE=", 
+  "LTEuMDA=", 
+  "LSQxLjAw", 
+  "LTEvMg==", 
+  "LTFFMg==", 
+  "LTFFMDI=", 
+  "LTFFKzAy", 
+  "MS8w", 
+  "MC8w", 
+  "LTIxNDc0ODM2NDgvLTE=", 
+  "LTkyMjMzNzIwMzY4NTQ3NzU4MDgvLTE=", 
+  "LTA=", 
+  "LTAuMA==", 
+  "KzA=", 
+  "KzAuMA==", 
+  "MC4wMA==", 
+  "MC4uMA==", 
+  "Lg==", 
+  "MC4wLjA=", 
+  "MCwwMA==", 
+  "MCwsMA==", 
+  "LA==", 
+  "MCwwLDA=", 
+  "MC4wLzA=", 
+  "MS4wLzAuMA==", 
+  "MC4wLzAuMA==", 
+  "MSwwLzAsMA==", 
+  "MCwwLzAsMA==", 
+  "LS0x", 
+  "LQ==", 
+  "LS4=", 
+  "LSw=", 
+  "OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5", 
+  "OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5OTk5", 
+  "TmFO", 
+  "SW5maW5pdHk=", 
+  "LUluZmluaXR5", 
+  "SU5G", 
+  "MSNJTkY=", 
+  "LTEjSU5E", 
+  "MSNRTkFO", 
+  "MSNTTkFO", 
+  "MSNJTkQ=", 
+  "MHgw", 
+  "MHhmZmZmZmZmZg==", 
+  "MHhmZmZmZmZmZmZmZmZmZmZm", 
+  "MHhhYmFkMWRlYQ==", 
+  "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5", 
+  "MSwwMDAuMDA=", 
+  "MSAwMDAuMDA=", 
+  "MScwMDAuMDA=", 
+  "MSwwMDAsMDAwLjAw", 
+  "MSAwMDAgMDAwLjAw", 
+  "MScwMDAnMDAwLjAw", 
+  "MS4wMDAsMDA=", 
+  "MSAwMDAsMDA=", 
+  "MScwMDAsMDA=", 
+  "MS4wMDAuMDAwLDAw", 
+  "MSAwMDAgMDAwLDAw", 
+  "MScwMDAnMDAwLDAw", 
+  "MDEwMDA=", 
+  "MDg=", 
+  "MDk=", 
+  "Mi4yMjUwNzM4NTg1MDcyMDExZS0zMDg=", 
+  "LC4vOydbXS09", 
+  "PD4/OiJ7fXxfKw==", 
+  "IUAjJCVeJiooKWB+", 
+  "AQIDBAUGBwgODxAREhMUFRYXGBkaGxwdHh9/", 
+  "woDCgcKCwoPChMKGwofCiMKJworCi8KMwo3CjsKPwpDCkcKSwpPClMKVwpbCl8KYwpnCmsKbwpzC", 
+  "ncKewp8=", 
+  "CwwgwoXCoOGagOKAgOKAgeKAguKAg+KAhOKAheKAhuKAh+KAiOKAieKAiuKAi+KAqOKAqeKAr+KB", 
+  "n+OAgA==", 
+  "wq3YgNiB2ILYg9iE2IXYnNud3I/hoI7igIvigIzigI3igI7igI/igKrigKvigKzigK3igK7igaDi", 
+  "gaHigaLigaPigaTigabigafigajiganigarigavigaziga3iga7iga/vu7/vv7nvv7rvv7vwkYK9", 
+  "8JuyoPCbsqHwm7Ki8Juyo/CdhbPwnYW08J2FtfCdhbbwnYW38J2FuPCdhbnwnYW686CAgfOggKDz", 
+  "oICh86CAovOggKPzoICk86CApfOggKbzoICn86CAqPOggKnzoICq86CAq/OggKzzoICt86CArvOg", 
+  "gK/zoICw86CAsfOggLLzoICz86CAtPOggLXzoIC286CAt/OggLjzoIC586CAuvOggLvzoIC886CA", 
+  "vfOggL7zoIC/86CBgPOggYHzoIGC86CBg/OggYTzoIGF86CBhvOggYfzoIGI86CBifOggYrzoIGL", 
+  "86CBjPOggY3zoIGO86CBj/OggZDzoIGR86CBkvOggZPzoIGU86CBlfOggZbzoIGX86CBmPOggZnz", 
+  "oIGa86CBm/OggZzzoIGd86CBnvOggZ/zoIGg86CBofOggaLzoIGj86CBpPOggaXzoIGm86CBp/Og", 
+  "gajzoIGp86CBqvOggavzoIGs86CBrfOgga7zoIGv86CBsPOggbHzoIGy86CBs/OggbTzoIG186CB", 
+  "tvOggbfzoIG486CBufOggbrzoIG786CBvPOggb3zoIG+86CBvw==", 
+  "77u/", 
+  "77++", 
+  "zqniiYjDp+KImuKIq8ucwrXiiaTiiaXDtw==", 
+  "w6XDn+KIgsaSwqnLmeKIhsuawqzigKbDpg==", 
+  "xZPiiJHCtMKu4oCgwqXCqMuGw7jPgOKAnOKAmA==", 
+  "wqHihKLCo8Ki4oiewqfCtuKAosKqwrrigJPiiaA=", 
+  "wrjLm8OH4peKxLHLnMOCwq/LmMK/", 
+  "w4XDjcOOw4/LncOTw5Tvo7/DksOaw4bimIM=", 
+  "xZLigJ7CtOKAsMuHw4HCqMuGw5jiiI/igJ3igJk=", 
+  "YOKBhOKCrOKAueKAuu+sge+sguKAocKwwrfigJrigJTCsQ==", 
+  "4oWb4oWc4oWd4oWe", 
+  "0IHQgtCD0ITQhdCG0IfQiNCJ0IrQi9CM0I3QjtCP0JDQkdCS0JPQlNCV0JbQl9CY0JnQmtCb0JzQ", 
+  "ndCe0J/QoNCh0KLQo9Ck0KXQptCn0KjQqdCq0KvQrNCt0K7Qr9Cw0LHQstCz0LTQtdC20LfQuNC5", 
+  "0LrQu9C80L3QvtC/0YDRgdGC0YPRhNGF0YbRh9GI0YnRitGL0YzRjdGO0Y8=", 
+  "2aDZodmi2aPZpNml2abZp9mo2ak=", 
+  "4oGw4oG04oG1", 
+  "4oKA4oKB4oKC", 
+  "4oGw4oG04oG14oKA4oKB4oKC", 
+  "4LiU4LmJ4LmJ4LmJ4LmJ4LmJ4LmH4LmH4LmH4LmH4LmH4LmJ4LmJ4LmJ4LmJ4LmJ4LmH4LmH4LmH", 
+  "4LmH4LmH4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmH4LmH4LmH4LmH4LmH4LmJ4LmJ4LmJ4LmJ", 
+  "4LmJ4LmH4LmH4LmH4LmH4LmH4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmH4LmH4LmH4LmH4LmH", 
+  "4LmJ4LmJ4LmJ4LmJ4LmJ4LmH4LmH4LmH4LmH4LmH4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmJ4LmH", 
+  "4LmH4LmH4LmH4LmH4LmJ4LmJ4LmJ4LmJ4LmJ4LmH4LmH4LmH4LmHIOC4lOC5ieC5ieC5ieC5ieC5", 
+  "ieC5h+C5h+C5h+C5h+C5h+C5ieC5ieC5ieC5ieC5ieC5h+C5h+C5h+C5h+C5h+C5ieC5ieC5ieC5", 
+  "ieC5ieC5ieC5ieC5ieC5h+C5h+C5h+C5h+C5h+C5ieC5ieC5ieC5ieC5ieC5h+C5h+C5h+C5h+C5", 
+  "h+C5ieC5ieC5ieC5ieC5ieC5ieC5ieC5ieC5h+C5h+C5h+C5h+C5h+C5ieC5ieC5ieC5ieC5ieC5", 
+  "h+C5h+C5h+C5h+C5h+C5ieC5ieC5ieC5ieC5ieC5ieC5ieC5ieC5h+C5h+C5h+C5h+C5h+C5ieC5", 
+  "ieC5ieC5ieC5ieC5h+C5h+C5h+C5hyDguJTguYnguYnguYnguYnguYnguYfguYfguYfguYfguYfg", 
+  "uYnguYnguYnguYnguYnguYfguYfguYfguYfguYfguYnguYnguYnguYnguYnguYnguYnguYnguYfg", 
+  "uYfguYfguYfguYfguYnguYnguYnguYnguYnguYfguYfguYfguYfguYfguYnguYnguYnguYnguYng", 
+  "uYnguYnguYnguYfguYfguYfguYfguYfguYnguYnguYnguYnguYnguYfguYfguYfguYfguYfguYng", 
+  "uYnguYnguYnguYnguYnguYnguYnguYfguYfguYfguYfguYfguYnguYnguYnguYnguYnguYfguYfg", 
+  "uYfguYc=", 
+  "Jw==", 
+  "Ig==", 
+  "Jyc=", 
+  "IiI=", 
+  "JyIn", 
+  "IicnJyciJyI=", 
+  "IiciJyInJycnIg==", 
+  "PGZvbyB2YWw94oCcYmFy4oCdIC8+", 
+  "PGZvbyB2YWw94oCcYmFy4oCdIC8+", 
+  "PGZvbyB2YWw94oCdYmFy4oCcIC8+", 
+  "PGZvbyB2YWw9YGJhcicgLz4=", 
+  "55Sw5Lit44GV44KT44Gr44GC44GS44Gm5LiL44GV44GE", 
+  "44OR44O844OG44Kj44O844G46KGM44GL44Gq44GE44GL", 
+  "5ZKM6KO95ryi6Kqe", 
+  "6YOo6JC95qC8", 
+  "7IKs7ZqM6rO87ZWZ7JuQIOyWtO2VmeyXsOq1rOyGjA==", 
+  "7LCm7LCo66W8IO2DgOqzoCDsmKgg7Y6y7Iuc66eo6rO8IOyRm+uLpOumrCDrmKDrsKnqsIHtlZg=", 
+  "56S+5pyD56eR5a246Zmi6Kqe5a2456CU56m25omA", 
+  "7Jq4656A67CU7Yag66W0", 
+  "8KCcjvCgnLHwoJ258KCxk/CgsbjwoLKW8KCzjw==", 
+  "6KGo44Od44GCQem3l8WSw6nvvKLpgI3DnMOfwqrEhcOx5LiC45CA8KCAgA==", 
+  "44O94Ly84LqI2YTNnOC6iOC8ve++iSDjg73gvLzguojZhM2c4LqI4Ly9776J", 
+  "KO+9oeKXlSDiiIAg4peV772hKQ==", 
+  "772A772oKMK04oiA772A4oip", 
+  "X1/vvpsoLF8sKik=", 
+  "44O7KO+/o+KIgO+/oynjg7s6Kjo=", 
+  "776f772l4py/44O+4pWyKO+9oeKXleKAv+KXle+9oSnilbHinL/vvaXvvp8=", 
+  "LOOAguODuzoqOuODu+OCnOKAmSgg4pi7IM+JIOKYuyAp44CC44O7Oio644O744Kc4oCZ", 
+  "KOKVr8Kw4pahwrDvvInila/vuLUg4pS74pSB4pS7KQ==", 
+  "KO++ieCypeebiuCype+8ie++ie+7vyDilLvilIHilLs=", 
+  "4pSs4pSA4pSs44OOKCDCuiBfIMK644OOKQ==", 
+  "KCDNocKwIM2cypYgzaHCsCk=", 
+  "8J+YjQ==", 
+  "8J+RqfCfj70=", 
+  "8J+RqOKAjfCfprAg8J+RqPCfj7/igI3wn6awIPCfkajigI3wn6axIPCfkajwn4+/4oCN8J+msSDwn6a58J+Pv+KAjeKZgu+4jw==", 
+  "8J+RviDwn5mHIPCfkoEg8J+ZhSDwn5mGIPCfmYsg8J+ZjiDwn5mN", 
+  "8J+QtSDwn5mIIPCfmYkg8J+Zig==", 
+  "4p2k77iPIPCfkpQg8J+SjCDwn5KVIPCfkp4g8J+SkyDwn5KXIPCfkpYg8J+SmCDwn5KdIPCfkp8g", 
+  "8J+SnCDwn5KbIPCfkpog8J+SmQ==", 
+  "4pyL8J+PvyDwn5Kq8J+PvyDwn5GQ8J+PvyDwn5mM8J+PvyDwn5GP8J+PvyDwn5mP8J+Pvw==", 
+  "8J+aviDwn4aSIPCfhpMg8J+GlSDwn4aWIPCfhpcg8J+GmSDwn4+n", 
+  "MO+4j+KDoyAx77iP4oOjIDLvuI/ig6MgM++4j+KDoyA077iP4oOjIDXvuI/ig6MgNu+4j+KDoyA3", 
+  "77iP4oOjIDjvuI/ig6MgOe+4j+KDoyDwn5Sf", 
+  "8J+HuvCfh7jwn4e38J+HuvCfh7gg8J+HpvCfh6vwn4em8J+HsvCfh7g=", 
+  "8J+HuvCfh7jwn4e38J+HuvCfh7jwn4em8J+Hq/Cfh6bwn4ey", 
+  "8J+HuvCfh7jwn4e38J+HuvCfh7jwn4em", 
+  "77yR77yS77yT", 
+  "2aHZotmj", 
+  "2KvZhSDZhtmB2LMg2LPZgti32Kog2YjYqNin2YTYqtit2K/Zitiv2IwsINis2LLZitix2KrZiiDY", 
+  "qNin2LPYqtiu2K/Yp9mFINij2YYg2K/ZhtmILiDYpdiwINmH2YbYp9ifINin2YTYs9iq2KfYsSDZ", 
+  "iNiq2YbYtdmK2Kgg2YPYp9mGLiDYo9mH2ZHZhCDYp9mK2LfYp9mE2YrYp9iMINio2LHZiti32KfZ", 
+  "htmK2Kct2YHYsdmG2LPYpyDZgtivINij2K7YsC4g2LPZhNmK2YXYp9mG2Iwg2KXYqtmB2KfZgtmK", 
+  "2Kkg2KjZitmGINmF2KcsINmK2LDZg9ixINin2YTYrdiv2YjYryDYo9mKINio2LnYrywg2YXYudin", 
+  "2YXZhNipINio2YjZhNmG2K/Yp9iMINin2YTYpdi32YTYp9mCINi52YQg2KXZitmILg==", 
+  "15HWsNa816jWtdeQ16nWtNeB15nXqiwg15HWuNa816jWuNeQINeQ1rHXnNa515TWtNeZ150sINeQ", 
+  "1rXXqiDXlNa316nWuNa814HXnta315nWtNedLCDXldaw15DWtdeqINeU1rjXkNa416jWttel", 
+  "15TWuNeZ1rDXqta415R0ZXN02KfZhNi12YHYrdin2Kog2KfZhNiq2ZHYrdmI2YQ=", 
+  "77e9", 
+  "77e6", 
+  "2YXZj9mG2Y7Yp9mC2Y7YtNmO2KnZjyDYs9mP2KjZj9mE2ZAg2KfZkNiz2ZLYqtmQ2K7Zktiv2Y7Y", 
+  "p9mF2ZAg2KfZhNmE2ZHZj9i62Y7YqdmQINmB2ZDZiiDYp9mE2YbZkdmP2LjZj9mF2ZAg2KfZhNmS", 
+  "2YLZjtin2KbZkNmF2Y7YqdmQINmI2Y7ZgdmQ2YrZhSDZitmO2K7Zj9i12ZHZjiDYp9mE2KrZkdmO", 
+  "2LfZktio2ZDZitmC2Y7Yp9iq2Y8g2KfZhNmS2K3Yp9iz2Y/ZiNio2ZDZitmR2Y7YqdmP2Iw=", 
+  "4Zqb4ZqE4ZqT4ZqQ4ZqL4ZqS4ZqE4ZqA4ZqR4ZqE4ZqC4ZqR4ZqP4ZqF4Zqc", 
+  "4Zqb4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqA4ZqcCg==", 
+  "4oCq4oCqdGVzdOKAqg==", 
+  "4oCrdGVzdOKAqw==", 
+  "4oCpdGVzdOKAqQ==", 
+  "dGVzdOKBoHRlc3TigKs=", 
+  "4oGmdGVzdOKBpw==", 
+  "4bmwzLrMusyVb82eIMy3acyyzKzNh8yqzZluzJ3Ml82VdsyfzJzMmMymzZ9vzLbMmcywzKBrw6jN", 
+  "msyuzLrMqsy5zLHMpCDMlnTMnc2VzLPMo8y7zKrNnmjMvM2TzLLMpsyzzJjMsmXNh8yjzLDMpsys", 
+  "zY4gzKLMvMy7zLHMmGjNms2OzZnMnMyjzLLNhWnMpsyyzKPMsMykdsy7zY1lzLrMrcyzzKrMsC1t", 
+  "zKJpzYVuzJbMusyezLLMr8ywZMy1zLzMn82ZzKnMvMyYzLMgzJ7MpcyxzLPMrXLMm8yXzJhlzZlw", 
+  "zaByzLzMnsy7zK3Ml2XMusygzKPNn3PMmM2HzLPNjcydzYllzYnMpcyvzJ7Mss2azKzNnMe5zKzN", 
+  "js2OzJ/Mls2HzKR0zY3MrMykzZPMvMytzZjNhWnMqsyxbs2gZ8y0zYkgzY/Nic2FY8yszJ9ozaFh", 
+  "zKvMu8yvzZhvzKvMn8yWzY3MmcydzYlzzJfMpsyyLsyozLnNiMyj", 
+  "zKHNk8yezYVJzJfMmMymzZ1uzYfNh82ZdsyuzKtva8yyzKvMmc2IacyWzZnMrcy5zKDMnm7Mocy7", 
+  "zK7Mo8y6Z8yyzYjNmcytzZnMrM2OIMywdM2UzKZozJ7MsmXMosykIM2NzKzMss2WZsy0zJjNlcyj", 
+  "w6jNluG6ucylzKlszZbNlM2aac2TzZrMps2gbs2WzY3Ml82TzLPMrmfNjSDMqG/NmsyqzaFmzJjM", 
+  "o8ysIMyWzJjNlsyfzZnMrmPSic2UzKvNls2TzYfNls2FaMy1zKTMo82azZTDocyXzLzNlc2Fb8y8", 
+  "zKPMpXPMsc2IzLrMlsymzLvNoi7Mm8yWzJ7MoMyrzLA=", 
+  "zJfMus2WzLnMr82T4bmuzKTNjcylzYfNiGjMssyBZc2PzZPMvMyXzJnMvMyjzZQgzYfMnMyxzKDN", 
+  "k82NzYVOzZXNoGXMl8yxesyYzJ3MnMy6zZlwzKTMusy5zY3Mr82aZcygzLvMoM2ccsyozKTNjcy6", 
+  "zJbNlMyWzJZkzKDMn8ytzKzMnc2facymzZbMqc2TzZTMpGHMoMyXzKzNicyZbs2azZwgzLvMnsyw", 
+  "zZrNhWjMtc2JacyzzJ52zKLNh+G4mc2OzZ8t0onMrcypzLzNlG3MpMytzKtpzZXNh8ydzKZuzJfN", 
+  "meG4jcyfIMyvzLLNlc2ex6vMn8yvzLDMss2ZzLvMnWYgzKrMsMywzJfMlsytzJjNmGPMps2NzLLM", 
+  "ns2NzKnMmeG4pc2aYcyuzY7Mn8yZzZzGocypzLnNjnPMpC7MncydINKJWsyhzJbMnM2WzLDMo82J", 
+  "zJxhzZbMsM2ZzKzNoWzMssyrzLPNjcypZ8yhzJ/MvMyxzZrMnsyszYVvzJfNnC7Mnw==", 
+  "zKZIzKzMpMyXzKTNnWXNnCDMnMylzJ3Mu82NzJ/MgXfMlWjMlsyvzZNvzJ3NmcyWzY7MscyuINKJ", 
+  "zLrMmcyezJ/NiFfMt8y8zK1hzLrMqs2NxK/NiM2VzK3NmcyvzJx0zLbMvMyuc8yYzZnNlsyVIMyg", 
+  "zKvMoELMu82NzZnNicyzzYVlzLVozLXMrM2HzKvNmWnMuc2TzLPMs8yuzY7Mq8yVbs2fZMy0zKrM", 
+  "nMyWIMywzYnMqc2HzZnMss2ezYVUzZbMvM2TzKrNomjNj82TzK7Mu2XMrMydzJ/NhSDMpMy5zJ1X", 
+  "zZnMnsydzZTNh82dzYVhzY/Nk82UzLnMvMyjbMy0zZTMsMykzJ/NlOG4vcyrLs2V", 
+  "WsyuzJ7MoM2ZzZTNheG4gMyXzJ7NiMy7zJfhuLbNmc2OzK/MucyezZNHzLtPzK3Ml8yu", 
+  "y5nJkG5i4bSJbMmQIMmQdcaDyZDJryDHncm5b2xvcCDKh8edIMedyblvccmQbCDKh24gyod1bnDh", 
+  "tIlw4bSJyZR14bSJIMm5b2TJr8edyocgcG/Jr3Nu4bSJx50gb3AgcMedcyAnyofhtIlsx50gxoN1", 
+  "4bSJyZRz4bSJZOG0iXDJkCDJuW7Kh8edyofJlMedc3VvyZQgJ8qHx53Jr8mQIMqH4bSJcyDJuW9s", 
+  "b3Agya9uc2ThtIkgya/Hncm5b8ul", 
+  "MDDLmcaWJC0=", 
+  "77y0772I772FIO+9ke+9le+9ie+9g++9iyDvvYLvvZLvvY/vvZfvvY4g772G772P772YIO+9iu+9", 
+  "le+9je+9kO+9kyDvvY/vvZbvvYXvvZIg772U772I772FIO+9jO+9ge+9mu+9mSDvvYTvvY/vvYc=", 
+  "8J2Qk/CdkKHwnZCeIPCdkKrwnZCu8J2QovCdkJzwnZCkIPCdkJvwnZCr8J2QqPCdkLDwnZCnIPCd", 
+  "kJ/wnZCo8J2QsSDwnZCj8J2QrvCdkKbwnZCp8J2QrCDwnZCo8J2Qr/CdkJ7wnZCrIPCdkK3wnZCh", 
+  "8J2QniDwnZCl8J2QmvCdkLPwnZCyIPCdkJ3wnZCo8J2QoA==", 
+  "8J2Vv/Cdlo3wnZaKIPCdlpbwnZaa8J2WjvCdlojwnZaQIPCdlofwnZaX8J2WlPCdlpzwnZaTIPCd", 
+  "lovwnZaU8J2WnSDwnZaP8J2WmvCdlpLwnZaV8J2WmCDwnZaU8J2Wm/CdlorwnZaXIPCdlpnwnZaN", 
+  "8J2WiiDwnZaR8J2WhvCdlp/wnZaeIPCdlonwnZaU8J2WjA==", 
+  "8J2Ru/CdkonwnZKGIPCdkpLwnZKW8J2SivCdkoTwnZKMIPCdkoPwnZKT8J2SkPCdkpjwnZKPIPCd", 
+  "kofwnZKQ8J2SmSDwnZKL8J2SlvCdko7wnZKR8J2SlCDwnZKQ8J2Sl/CdkobwnZKTIPCdkpXwnZKJ", 
+  "8J2ShiDwnZKN8J2SgvCdkpvwnZKaIPCdkoXwnZKQ8J2SiA==", 
+  "8J2To/Cdk7HwnZOuIPCdk7rwnZO+8J2TsvCdk6zwnZO0IPCdk6vwnZO78J2TuPCdlIDwnZO3IPCd", 
+  "k6/wnZO48J2UgSDwnZOz8J2TvvCdk7bwnZO58J2TvCDwnZO48J2Tv/Cdk67wnZO7IPCdk73wnZOx", 
+  "8J2TriDwnZO18J2TqvCdlIPwnZSCIPCdk63wnZO48J2TsA==", 
+  "8J2Vi/CdlZnwnZWWIPCdlaLwnZWm8J2VmvCdlZTwnZWcIPCdlZPwnZWj8J2VoPCdlajwnZWfIPCd", 
+  "lZfwnZWg8J2VqSDwnZWb8J2VpvCdlZ7wnZWh8J2VpCDwnZWg8J2Vp/CdlZbwnZWjIPCdlaXwnZWZ", 
+  "8J2VliDwnZWd8J2VkvCdlavwnZWqIPCdlZXwnZWg8J2VmA==", 
+  "8J2ag/CdmpHwnZqOIPCdmprwnZqe8J2akvCdmozwnZqUIPCdmovwnZqb8J2amPCdmqDwnZqXIPCd", 
+  "mo/wnZqY8J2aoSDwnZqT8J2anvCdmpbwnZqZ8J2anCDwnZqY8J2an/Cdmo7wnZqbIPCdmp3wnZqR", 
+  "8J2ajiDwnZqV8J2aivCdmqPwnZqiIPCdmo3wnZqY8J2akA==", 
+  "4pKv4pKj4pKgIOKSrOKSsOKSpOKSnuKSpiDikp3ikq3ikqrikrLikqkg4pKh4pKq4pKzIOKSpeKS", 
+  "sOKSqOKSq+KSriDikqrikrHikqDikq0g4pKv4pKj4pKgIOKSp+KSnOKSteKStCDikp/ikqrikqI=", 
+  "PHNjcmlwdD5hbGVydCgxMjMpPC9zY3JpcHQ+", 
+  "Jmx0O3NjcmlwdCZndDthbGVydCgmIzM5OzEyMyYjMzk7KTsmbHQ7L3NjcmlwdCZndDs=", 
+  "PGltZyBzcmM9eCBvbmVycm9yPWFsZXJ0KDEyMykgLz4=", 
+  "PHN2Zz48c2NyaXB0PjEyMzwxPmFsZXJ0KDEyMyk8L3NjcmlwdD4=", 
+  "Ij48c2NyaXB0PmFsZXJ0KDEyMyk8L3NjcmlwdD4=", 
+  "Jz48c2NyaXB0PmFsZXJ0KDEyMyk8L3NjcmlwdD4=", 
+  "PjxzY3JpcHQ+YWxlcnQoMTIzKTwvc2NyaXB0Pg==", 
+  "PC9zY3JpcHQ+PHNjcmlwdD5hbGVydCgxMjMpPC9zY3JpcHQ+", 
+  "PCAvIHNjcmlwdCA+PCBzY3JpcHQgPmFsZXJ0KDEyMyk8IC8gc2NyaXB0ID4=", 
+  "b25mb2N1cz1KYVZhU0NyaXB0OmFsZXJ0KDEyMykgYXV0b2ZvY3Vz", 
+  "IiBvbmZvY3VzPUphVmFTQ3JpcHQ6YWxlcnQoMTIzKSBhdXRvZm9jdXM=", 
+  "JyBvbmZvY3VzPUphVmFTQ3JpcHQ6YWxlcnQoMTIzKSBhdXRvZm9jdXM=", 
+  "77ycc2NyaXB077yeYWxlcnQoMTIzKe+8nC9zY3JpcHTvvJ4=", 
+  "PHNjPHNjcmlwdD5yaXB0PmFsZXJ0KDEyMyk8L3NjPC9zY3JpcHQ+cmlwdD4=", 
+  "LS0+PHNjcmlwdD5hbGVydCgxMjMpPC9zY3JpcHQ+", 
+  "IjthbGVydCgxMjMpO3Q9Ig==", 
+  "JzthbGVydCgxMjMpO3Q9Jw==", 
+  "SmF2YVNDcmlwdDphbGVydCgxMjMp", 
+  "O2FsZXJ0KDEyMyk7", 
+  "c3JjPUphVmFTQ3JpcHQ6cHJvbXB0KDEzMik=", 
+  "Ij48c2NyaXB0PmFsZXJ0KDEyMyk7PC9zY3JpcHQgeD0i", 
+  "Jz48c2NyaXB0PmFsZXJ0KDEyMyk7PC9zY3JpcHQgeD0n", 
+  "PjxzY3JpcHQ+YWxlcnQoMTIzKTs8L3NjcmlwdCB4PQ==", 
+  "IiBhdXRvZm9jdXMgb25rZXl1cD0iamF2YXNjcmlwdDphbGVydCgxMjMp", 
+  "JyBhdXRvZm9jdXMgb25rZXl1cD0namF2YXNjcmlwdDphbGVydCgxMjMp", 
+  "PHNjcmlwdHgyMHR5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "PHNjcmlwdHgzRXR5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "PHNjcmlwdHgwRHR5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "PHNjcmlwdHgwOXR5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "PHNjcmlwdHgwQ3R5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "PHNjcmlwdHgyRnR5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "PHNjcmlwdHgwQXR5cGU9InRleHQvamF2YXNjcmlwdCI+amF2YXNjcmlwdDphbGVydCgxKTs8L3Nj", 
+  "cmlwdD4=", 
+  "J2AiPjx4M0NzY3JpcHQ+amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "J2AiPjx4MDBzY3JpcHQ+amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "QUJDPGRpdiBzdHlsZT0ieHgzQWV4cHJlc3Npb24oamF2YXNjcmlwdDphbGVydCgxKSI+REVG", 
+  "QUJDPGRpdiBzdHlsZT0ieDpleHByZXNzaW9ueDVDKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDpleHByZXNzaW9ueDAwKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDpleHB4MDByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDpleHB4NUNyZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MEFleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MDlleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTN4ODB4ODBleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODRleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4QzJ4QTBleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRF", 
+  "Rg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODBleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4OEFleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MERleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MENleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODdleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RUZ4QkJ4QkZleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MjBleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODhleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MDBleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4OEJleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODZleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODVleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODJleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4MEJleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSkiPkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODFleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODNleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "QUJDPGRpdiBzdHlsZT0ieDp4RTJ4ODB4ODlleHByZXNzaW9uKGphdmFzY3JpcHQ6YWxlcnQoMSki", 
+  "PkRFRg==", 
+  "PGEgaHJlZj0ieDBCamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDBGamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEMyeEEwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVs", 
+  "ZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDA1amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUxeEEweDhFamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDE4amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDExamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDg4amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDg5amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDgwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDE3amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDAzamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDBFamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDFBamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDAwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDEwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDgyamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDIwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDEzamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDA5amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDhBamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDE0amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDE5amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweEFGamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDFGamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDgxamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDFEamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDg3amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDA3amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUxeDlBeDgwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDgzamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDA0amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDAxamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDA4amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDg0amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDg2amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUzeDgweDgwamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDEyamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDBEamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDBBamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDBDamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDE1amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweEE4amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDE2amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDAyamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDFCamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDA2amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweEE5amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgweDg1amF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDFFamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieEUyeDgxeDlGamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6", 
+  "emVsZW1lbnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0ieDFDamF2YXNjcmlwdDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0iamF2YXNjcmlwdHgwMDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0iamF2YXNjcmlwdHgzQTpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0iamF2YXNjcmlwdHgwOTpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0iamF2YXNjcmlwdHgwRDpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "PGEgaHJlZj0iamF2YXNjcmlwdHgwQTpqYXZhc2NyaXB0OmFsZXJ0KDEpIiBpZD0iZnV6emVsZW1l", 
+  "bnQxIj50ZXN0PC9hPg==", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgwQW9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgyMm9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgwQm9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgwRG9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgyRm9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgwOW9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgwQ29uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgwMG9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgyN29uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "YCInPjxpbWcgc3JjPXh4eDp4IHgyMG9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT4=", 
+  "ImAnPjxzY3JpcHQ+eDNCamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDBEamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEVGeEJCeEJGamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDgxamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDg0amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUzeDgweDgwamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDA5amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDg5amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDg1amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDg4amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDAwamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweEE4amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDhBamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUxeDlBeDgwamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDBDamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDJCamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEYweDkweDk2eDlBamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+LWphdmFzY3JpcHQ6YWxlcnQoMSk8L3NjcmlwdD4=", 
+  "ImAnPjxzY3JpcHQ+eDBBamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweEFGamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDdFamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDg3amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgxeDlGamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweEE5amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEMyeDg1amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEVGeEJGeEFFamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDgzamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDhCamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEVGeEJGeEJFamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDgwamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDIxamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDgyamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUyeDgweDg2amF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEUxeEEweDhFamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDBCamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eDIwamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "ImAnPjxzY3JpcHQ+eEMyeEEwamF2YXNjcmlwdDphbGVydCgxKTwvc2NyaXB0Pg==", 
+  "PGltZyB4MDBzcmM9eCBvbmVycm9yPSJhbGVydCgxKSI+", 
+  "PGltZyB4NDdzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyB4MTFzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyB4MTJzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZ3g0N3NyYz14IG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZ3gxMHNyYz14IG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZ3gxM3NyYz14IG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZ3gzMnNyYz14IG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZ3g0N3NyYz14IG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZ3gxMXNyYz14IG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZyB4NDdzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyB4MzRzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyB4MzlzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyB4MDBzcmM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MDk9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MTA9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MTM9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MzI9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MTI9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MTE9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4MDA9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmN4NDc9eCBvbmVycm9yPSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmM9eHgwOW9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZyBzcmM9eHgxMG9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZyBzcmM9eHgxMW9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZyBzcmM9eHgxMm9uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZyBzcmM9eHgxM29uZXJyb3I9ImphdmFzY3JpcHQ6YWxlcnQoMSkiPg==", 
+  "PGltZ1thXVtiXVtjXXNyY1tkXT14W2Vdb25lcnJvcj1bZl0iYWxlcnQoMSkiPg==", 
+  "PGltZyBzcmM9eCBvbmVycm9yPXgwOSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmM9eCBvbmVycm9yPXgxMCJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmM9eCBvbmVycm9yPXgxMSJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmM9eCBvbmVycm9yPXgxMiJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmM9eCBvbmVycm9yPXgzMiJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGltZyBzcmM9eCBvbmVycm9yPXgwMCJqYXZhc2NyaXB0OmFsZXJ0KDEpIj4=", 
+  "PGEgaHJlZj1qYXZhJiMxJiMyJiMzJiM0JiM1JiM2JiM3JiM4JiMxMSYjMTJzY3JpcHQ6amF2YXNj", 
+  "cmlwdDphbGVydCgxKT5YWFg8L2E+", 
+  "PGltZyBzcmM9InhgIGA8c2NyaXB0PmphdmFzY3JpcHQ6YWxlcnQoMSk8L3NjcmlwdD4iYCBgPg==", 
+  "PGltZyBzcmMgb25lcnJvciAvIiAnIj0gYWx0PWphdmFzY3JpcHQ6YWxlcnQoMSkvLyI+", 
+  "PHRpdGxlIG9ucHJvcGVydHljaGFuZ2U9amF2YXNjcmlwdDphbGVydCgxKT48L3RpdGxlPjx0aXRs", 
+  "ZSB0aXRsZT0+", 
+  "PGEgaHJlZj1odHRwOi8vZm9vLmJhci8jeD1geT48L2E+PGltZyBhbHQ9ImA+PGltZyBzcmM9eDp4", 
+  "IG9uZXJyb3I9amF2YXNjcmlwdDphbGVydCgxKT48L2E+Ij4=", 
+  "PCEtLVtpZl0+PHNjcmlwdD5qYXZhc2NyaXB0OmFsZXJ0KDEpPC9zY3JpcHQgLS0+", 
+  "PCEtLVtpZjxpbWcgc3JjPXggb25lcnJvcj1qYXZhc2NyaXB0OmFsZXJ0KDEpLy9dPiAtLT4=", 
+  "PHNjcmlwdCBzcmM9Ii8lKGpzY3JpcHQpcyI+PC9zY3JpcHQ+", 
+  "PHNjcmlwdCBzcmM9IlwlKGpzY3JpcHQpcyI+PC9zY3JpcHQ+", 
+  "PElNRyAiIiI+PFNDUklQVD5hbGVydCgiWFNTIik8L1NDUklQVD4iPg==", 
+  "PElNRyBTUkM9amF2YXNjcmlwdDphbGVydChTdHJpbmcuZnJvbUNoYXJDb2RlKDg4LDgzLDgzKSk+", 
+  "PElNRyBTUkM9IyBvbm1vdXNlb3Zlcj0iYWxlcnQoJ3h4cycpIj4=", 
+  "PElNRyBTUkM9IG9ubW91c2VvdmVyPSJhbGVydCgneHhzJykiPg==", 
+  "PElNRyBvbm1vdXNlb3Zlcj0iYWxlcnQoJ3h4cycpIj4=", 
+  "PElNRyBTUkM9JiMxMDY7JiM5NzsmIzExODsmIzk3OyYjMTE1OyYjOTk7JiMxMTQ7JiMxMDU7JiMx", 
+  "MTI7JiMxMTY7JiM1ODsmIzk3OyYjMTA4OyYjMTAxOyYjMTE0OyYjMTE2OyYjNDA7JiMzOTsmIzg4", 
+  "OyYjODM7JiM4MzsmIzM5OyYjNDE7Pg==", 
+  "PElNRyBTUkM9JiMwMDAwMTA2JiMwMDAwMDk3JiMwMDAwMTE4JiMwMDAwMDk3JiMwMDAwMTE1JiMw", 
+  "MDAwMDk5JiMwMDAwMTE0JiMwMDAwMTA1JiMwMDAwMTEyJiMwMDAwMTE2JiMwMDAwMDU4JiMwMDAw", 
+  "MDk3JiMwMDAwMTA4JiMwMDAwMTAxJiMwMDAwMTE0JiMwMDAwMTE2JiMwMDAwMDQwJiMwMDAwMDM5", 
+  "JiMwMDAwMDg4JiMwMDAwMDgzJiMwMDAwMDgzJiMwMDAwMDM5JiMwMDAwMDQxPg==", 
+  "PElNRyBTUkM9JiN4NkEmI3g2MSYjeDc2JiN4NjEmI3g3MyYjeDYzJiN4NzImI3g2OSYjeDcwJiN4", 
+  "NzQmI3gzQSYjeDYxJiN4NkMmI3g2NSYjeDcyJiN4NzQmI3gyOCYjeDI3JiN4NTgmI3g1MyYjeDUz", 
+  "JiN4MjcmI3gyOT4=", 
+  "PElNRyBTUkM9ImphdiBhc2NyaXB0OmFsZXJ0KCdYU1MnKTsiPg==", 
+  "PElNRyBTUkM9ImphdiYjeDA5O2FzY3JpcHQ6YWxlcnQoJ1hTUycpOyI+", 
+  "PElNRyBTUkM9ImphdiYjeDBBO2FzY3JpcHQ6YWxlcnQoJ1hTUycpOyI+", 
+  "PElNRyBTUkM9ImphdiYjeDBEO2FzY3JpcHQ6YWxlcnQoJ1hTUycpOyI+", 
+  "cGVybCAtZSAncHJpbnQgIjxJTUcgU1JDPWphdmEwc2NyaXB0OmFsZXJ0KCJYU1MiKT4iOycgPiBv", 
+  "dXQ=", 
+  "PElNRyBTUkM9IiAmIzE0OyBqYXZhc2NyaXB0OmFsZXJ0KCdYU1MnKTsiPg==", 
+  "PFNDUklQVC9YU1MgU1JDPSJodHRwOi8vaGEuY2tlcnMub3JnL3hzcy5qcyI+PC9TQ1JJUFQ+", 
+  "PEJPRFkgb25sb2FkISMkJSYoKSp+Ky1fLiw6Oz9AWy98XV5gPWFsZXJ0KCJYU1MiKT4=", 
+  "PFNDUklQVC9TUkM9Imh0dHA6Ly9oYS5ja2Vycy5vcmcveHNzLmpzIj48L1NDUklQVD4=", 
+  "PDxTQ1JJUFQ+YWxlcnQoIlhTUyIpOy8vPDwvU0NSSVBUPg==", 
+  "PFNDUklQVCBTUkM9aHR0cDovL2hhLmNrZXJzLm9yZy94c3MuanM/PCBCID4=", 
+  "PFNDUklQVCBTUkM9Ly9oYS5ja2Vycy5vcmcvLmo+", 
+  "PElNRyBTUkM9ImphdmFzY3JpcHQ6YWxlcnQoJ1hTUycpIg==", 
+  "PGlmcmFtZSBzcmM9aHR0cDovL2hhLmNrZXJzLm9yZy9zY3JpcHRsZXQuaHRtbCA8", 
+  "IjthbGVydCgnWFNTJyk7Ly8=", 
+  "PHUgb25jb3B5PWFsZXJ0KCk+IENvcHkgbWU8L3U+", 
+  "PGkgb253aGVlbD1hbGVydCgxKT4gU2Nyb2xsIG92ZXIgbWUgPC9pPg==", 
+  "PHBsYWludGV4dD4=", 
+  "aHR0cDovL2EvJSUzMCUzMA==", 
+  "PC90ZXh0YXJlYT48c2NyaXB0PmFsZXJ0KDEyMyk8L3NjcmlwdD4=", 
+  "MTtEUk9QIFRBQkxFIHVzZXJz", 
+  "MSc7IERST1AgVEFCTEUgdXNlcnMtLSAx", 
+  "JyBPUiAxPTEgLS0gMQ==", 
+  "JyBPUiAnMSc9JzE=", 
+  "JQ==", 
+  "Xw==", 
+  "LQ==", 
+  "LS0=", 
+  "LS12ZXJzaW9u", 
+  "LS1oZWxw", 
+  "JFVTRVI=", 
+  "L2Rldi9udWxsOyB0b3VjaCAvdG1wL2JsbnMuZmFpbCA7IGVjaG8=", 
+  "YHRvdWNoIC90bXAvYmxucy5mYWlsYA==", 
+  "JCh0b3VjaCAvdG1wL2JsbnMuZmFpbCk=", 
+  "QHtbc3lzdGVtICJ0b3VjaCAvdG1wL2JsbnMuZmFpbCJdfQ==", 
+  "ZXZhbCgicHV0cyAnaGVsbG8gd29ybGQnIik=", 
+  "U3lzdGVtKCJscyAtYWwgLyIp", 
+  "YGxzIC1hbCAvYA==", 
+  "S2VybmVsLmV4ZWMoImxzIC1hbCAvIik=", 
+  "S2VybmVsLmV4aXQoMSk=", 
+  "JXgoJ2xzIC1hbCAvJyk=", 
+  "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSI/PjwhRE9DVFlQRSBmb28g", 
+  "WyA8IUVMRU1FTlQgZm9vIEFOWSA+PCFFTlRJVFkgeHhlIFNZU1RFTSAiZmlsZTovLy9ldGMvcGFz", 
+  "c3dkIiA+XT48Zm9vPiZ4eGU7PC9mb28+", 
+  "JEhPTUU=", 
+  "JEVOVnsnSE9NRSd9", 
+  "JWQ=", 
+  "JXM=", 
+  "ezB9", 
+  "JSouKnM=", 
+  "Li4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vZXRjL3Bhc3N3ZCUwMA==", 
+  "Li4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vZXRjL2hvc3Rz", 
+  "KCkgeyAwOyB9OyB0b3VjaCAvdG1wL2JsbnMuc2hlbGxzaG9jazEuZmFpbDs=", 
+  "KCkgeyBfOyB9ID5fWyQoJCgpKV0geyB0b3VjaCAvdG1wL2JsbnMuc2hlbGxzaG9jazIuZmFpbDsg", 
+  "fQ==", 
+  "PDw8ICVzKHVuPSclcycpID0gJXU=", 
+  "KysrQVRIMA==", 
+  "Q09O", 
+  "UFJO", 
+  "QVVY", 
+  "Q0xPQ0sk", 
+  "TlVM", 
+  "QTo=", 
+  "Wlo6", 
+  "Q09NMQ==", 
+  "TFBUMQ==", 
+  "TFBUMg==", 
+  "TFBUMw==", 
+  "Q09NMg==", 
+  "Q09NMw==", 
+  "Q09NNA==", 
+  "RENDIFNFTkQgU1RBUlRLRVlMT0dHRVIgMCAwIDA=", 
+  "U2N1bnRob3JwZSBHZW5lcmFsIEhvc3BpdGFs", 
+  "UGVuaXN0b25lIENvbW11bml0eSBDaHVyY2g=", 
+  "TGlnaHR3YXRlciBDb3VudHJ5IFBhcms=", 
+  "SmltbXkgQ2xpdGhlcm9l", 
+  "SG9ybmltYW4gTXVzZXVt", 
+  "c2hpdGFrZSBtdXNocm9vbXM=", 
+  "Um9tYW5zSW5TdXNzZXguY28udWs=", 
+  "aHR0cDovL3d3dy5jdW0ucWMuY2Ev", 
+  "Q3JhaWcgQ29ja2J1cm4sIFNvZnR3YXJlIFNwZWNpYWxpc3Q=", 
+  "TGluZGEgQ2FsbGFoYW4=", 
+  "RHIuIEhlcm1hbiBJLiBMaWJzaGl0eg==", 
+  "bWFnbmEgY3VtIGxhdWRl", 
+  "U3VwZXIgQm93bCBYWFg=", 
+  "bWVkaWV2YWwgZXJlY3Rpb24gb2YgcGFyYXBldHM=", 
+  "ZXZhbHVhdGU=", 
+  "bW9jaGE=", 
+  "ZXhwcmVzc2lvbg==", 
+  "QXJzZW5hbCBjYW5hbA==", 
+  "Y2xhc3NpYw==", 
+  "VHlzb24gR2F5", 
+  "RGljayBWYW4gRHlrZQ==", 
+  "YmFzZW1lbnQ=", 
+  "SWYgeW91J3JlIHJlYWRpbmcgdGhpcywgeW91J3ZlIGJlZW4gaW4gYSBjb21hIGZvciBhbG1vc3Qg", 
+  "MjAgeWVhcnMgbm93LiBXZSdyZSB0cnlpbmcgYSBuZXcgdGVjaG5pcXVlLiBXZSBkb24ndCBrbm93", 
+  "IHdoZXJlIHRoaXMgbWVzc2FnZSB3aWxsIGVuZCB1cCBpbiB5b3VyIGRyZWFtLCBidXQgd2UgaG9w", 
+  "ZSBpdCB3b3Jrcy4gUGxlYXNlIHdha2UgdXAsIHdlIG1pc3MgeW91Lg==", 
+  "Um9zZXMgYXJlIBtbMDszMW1yZWQbWzBtLCB2aW9sZXRzIGFyZSAbWzA7MzRtYmx1ZS4gSG9wZSB5", 
+  "b3UgZW5qb3kgdGVybWluYWwgaHVl", 
+  "QnV0IG5vdy4uLhtbMjBDZm9yIG15IGdyZWF0ZXN0IHRyaWNrLi4uG1s4bQ==", 
+  "VGhlIHF1aWMICAgICAhrIGJyb3duIGZvBwcHBwcHBwcHBwd4Li4uIFtCZWVlZXBd", 
+  "UG93ZXLZhNmP2YTZj9i12ZHYqNmP2YTZj9mE2LXZkdio2Y/Ysdix2Ysg4KWjIOClo2gg4KWjIOCl", 
+  "o+WGlw==", 
+  "2q/ahtm+2pg=",
+  "eyUgcHJpbnQgJ3gnICogNjQgKiAxMDI0KiozICV9",
+  "e3sgIiIuX19jbGFzc19fLl9fbXJvX19bMl0uX19zdWJjbGFzc2VzX18oKVs0MF0oIi9ldGMvcGFz",
+  "c3dkIikucmVhZCgpIH19"
+]
+
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index cf66ece0c30..d0892f5ae38 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -1087,4 +1087,114 @@ mod tests {
             assert_eq!(got, token);
         }
     }
+
+    // returns a vector of:
+    //   (expected_token_discriminator, strings_to_lex)
+    // expected_token_discriminator matches a given token when
+    // std::mem::discriminant returns the same discriminant for both.
+    fn blns_base64_to_statements(base64_str: String) -> Vec<(Option<Token>, Vec<String>)> {
+        use base64::engine::general_purpose;
+        use std::borrow::Cow;
+        use std::io::Cursor;
+        use std::io::Read;
+
+        let mut wrapped_reader = Cursor::new(base64_str);
+        let mut decoder =
+            base64::read::DecoderReader::new(&mut wrapped_reader, &general_purpose::STANDARD);
+        let mut base64_decoded = Vec::new();
+        decoder.read_to_end(&mut base64_decoded).unwrap();
+
+        // NOTE: when successful, this is the same conversion method as used in
+        // noirc_driver::stdlib::stdlib_paths_with_source, viz.
+        //
+        // let source = std::str::from_utf8(..).unwrap().to_string();
+        let s: Cow<'_, str> = match std::str::from_utf8(&base64_decoded) {
+            Ok(s) => std::borrow::Cow::Borrowed(s),
+            Err(_err) => {
+                // recover as much of the string as possible
+                // when str::from_utf8 fails
+                String::from_utf8_lossy(&base64_decoded)
+            }
+        };
+
+        vec![
+            // Token::Ident(_)
+            (None, vec![format!("let \"{s}\" = ();")]),
+            (Some(Token::Str("".to_string())), vec![format!("let s = \"{s}\";")]),
+            (
+                Some(Token::RawStr("".to_string(), 0)),
+                vec![
+                    // let s = r"Hello world";
+                    format!("let s = r\"{s}\";"),
+                    // let s = r#"Simon says "hello world""#;
+                    format!("let s = r#\"{s}\"#;"),
+                    // // Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+                    // let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####;
+                    format!("let s = r##\"{s}\"##;"),
+                    format!("let s = r###\"{s}\"###;"),
+                    format!("let s = r####\"{s}\"####; "),
+                    format!("let s = r#####\"{s}\"#####;"),
+                ],
+            ),
+            (Some(Token::FmtStr("".to_string())), vec![format!("assert(x == y, f\"{s}\");")]),
+            // expected token not found
+            // (Some(Token::LineComment("".to_string(), None)), vec![
+            (None, vec![format!("//{s}"), format!("// {s}")]),
+            // expected token not found
+            // (Some(Token::BlockComment("".to_string(), None)), vec![
+            (None, vec![format!("/*{s}*/"), format!("/* {s} */"), format!("/*\n{s}\n*/")]),
+        ]
+    }
+
+    #[test]
+    fn test_big_list_of_naughty_strings() {
+        use std::mem::discriminant;
+
+        let blns_contents = include_str!(env!("BLNS_JSON_PATH"));
+        let blns_base64: Vec<String> =
+            serde_json::from_str(blns_contents).expect("BLNS json invalid");
+        for blns_base64_str in blns_base64 {
+            let statements = blns_base64_to_statements(blns_base64_str);
+            for (token_discriminator_opt, blns_program_strs) in statements {
+                for blns_program_str in blns_program_strs {
+                    let mut expected_token_found = false;
+                    let mut lexer = Lexer::new(&blns_program_str);
+                    let mut result_tokens = Vec::new();
+                    loop {
+                        match lexer.next_token() {
+                            Ok(next_token) => {
+                                result_tokens.push(next_token.clone());
+                                expected_token_found |= token_discriminator_opt
+                                    .as_ref()
+                                    .map(|token_discriminator| {
+                                        discriminant(token_discriminator)
+                                            == discriminant(&next_token.token())
+                                    })
+                                    .unwrap_or(true);
+
+                                if next_token == Token::EOF {
+                                    assert!(lexer.done, "lexer not done when EOF emitted!");
+                                    break;
+                                }
+                            }
+
+                            Err(LexerErrorKind::InvalidIntegerLiteral { .. })
+                            | Err(LexerErrorKind::UnexpectedCharacter { .. })
+                            | Err(LexerErrorKind::UnterminatedBlockComment { .. }) => {
+                                expected_token_found = true;
+                            }
+                            Err(err) => {
+                                panic!("Unexpected lexer error found: {:?}", err)
+                            }
+                        }
+                    }
+
+                    assert!(
+                        expected_token_found,
+                        "expected token not found: {token_discriminator_opt:?}\noutput:\n{result_tokens:?}",
+                    );
+                }
+            }
+        }
+    }
 }

From 0150600922ee8b3e67c9b592338e8832f446685b Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 29 Mar 2024 11:28:33 -0500
Subject: [PATCH 128/416] fix: Impl search no longer selects an impl if
 multiple are applicable (#4662)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4653

## Summary\*

If the object type is an unbound type variable, impl search currently
just chooses the first available matching impl instead of erroring that
type annotations are needed or similar. This can lead to confusing
situations where the type chosen is chosen just because it was the first
impl in the stdlib to be defined. This PR prevents that.

## Additional Context

This PR depends on https://github.com/noir-lang/noir/pull/4648 and
should be merged after.

~~The `hashmap` test is currently failing because the `H: Hasher`
constraint on its `Eq` implementation ~~is actually unsolvable since `H`
isn't mentioned in the hashmap type at all~~. It is solvable since it is
meantioned in `B`, although solving it so far has lead to errors during
monomorphization. Previously it was fine since H was unbound and the
first/only impl was just always chosen. Now I'll need to change or
remove H to fix it.~~

This PR is now ready to review. I've been debugging a bug with
monomorphizing some HashMap code for a little while but it turns out the
bug is also present in master. So I'm considering it a separate issue:
https://github.com/noir-lang/noir/issues/4663

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/hir/type_check/expr.rs | 51 ++++++++++---------
 .../noirc_frontend/src/hir/type_check/mod.rs  | 40 ++++++++++++++-
 .../noirc_frontend/src/hir/type_check/stmt.rs | 12 ++---
 .../src/monomorphization/mod.rs               |  7 ++-
 compiler/noirc_frontend/src/node_interner.rs  | 47 ++++++++++++-----
 noir_stdlib/src/hash/poseidon2.nr             |  2 +-
 6 files changed, 113 insertions(+), 46 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index fb66bdeae6e..b56e2dce2a9 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -126,7 +126,7 @@ impl<'interner> TypeChecker<'interner> {
                     }
                 }
                 HirLiteral::Bool(_) => Type::Bool,
-                HirLiteral::Integer(_, _) => Type::polymorphic_integer_or_field(self.interner),
+                HirLiteral::Integer(_, _) => self.polymorphic_integer_or_field(),
                 HirLiteral::Str(string) => {
                     let len = Type::Constant(string.len() as u64);
                     Type::String(Box::new(len))
@@ -418,23 +418,28 @@ impl<'interner> TypeChecker<'interner> {
                 self.interner.select_impl_for_expression(function_ident_id, impl_kind);
             }
             Err(erroring_constraints) => {
-                // Don't show any errors where try_get_trait returns None.
-                // This can happen if a trait is used that was never declared.
-                let constraints = erroring_constraints
-                    .into_iter()
-                    .map(|constraint| {
-                        let r#trait = self.interner.try_get_trait(constraint.trait_id)?;
-                        let mut name = r#trait.name.to_string();
-                        if !constraint.trait_generics.is_empty() {
-                            let generics = vecmap(&constraint.trait_generics, ToString::to_string);
-                            name += &format!("<{}>", generics.join(", "));
-                        }
-                        Some((constraint.typ, name))
-                    })
-                    .collect::<Option<Vec<_>>>();
+                if erroring_constraints.is_empty() {
+                    self.errors.push(TypeCheckError::TypeAnnotationsNeeded { span });
+                } else {
+                    // Don't show any errors where try_get_trait returns None.
+                    // This can happen if a trait is used that was never declared.
+                    let constraints = erroring_constraints
+                        .into_iter()
+                        .map(|constraint| {
+                            let r#trait = self.interner.try_get_trait(constraint.trait_id)?;
+                            let mut name = r#trait.name.to_string();
+                            if !constraint.trait_generics.is_empty() {
+                                let generics =
+                                    vecmap(&constraint.trait_generics, ToString::to_string);
+                                name += &format!("<{}>", generics.join(", "));
+                            }
+                            Some((constraint.typ, name))
+                        })
+                        .collect::<Option<Vec<_>>>();
 
-                if let Some(constraints) = constraints {
-                    self.errors.push(TypeCheckError::NoMatchingImplFound { constraints, span });
+                    if let Some(constraints) = constraints {
+                        self.errors.push(TypeCheckError::NoMatchingImplFound { constraints, span });
+                    }
                 }
             }
         }
@@ -560,15 +565,13 @@ impl<'interner> TypeChecker<'interner> {
         let index_type = self.check_expression(&index_expr.index);
         let span = self.interner.expr_span(&index_expr.index);
 
-        index_type.unify(
-            &Type::polymorphic_integer_or_field(self.interner),
-            &mut self.errors,
-            || TypeCheckError::TypeMismatch {
+        index_type.unify(&self.polymorphic_integer_or_field(), &mut self.errors, || {
+            TypeCheckError::TypeMismatch {
                 expected_typ: "an integer".to_owned(),
                 expr_typ: index_type.to_string(),
                 expr_span: span,
-            },
-        );
+            }
+        });
 
         // When writing `a[i]`, if `a : &mut ...` then automatically dereference `a` as many
         // times as needed to get the underlying array.
@@ -1218,7 +1221,7 @@ impl<'interner> TypeChecker<'interner> {
                     self.errors
                         .push(TypeCheckError::InvalidUnaryOp { kind: rhs_type.to_string(), span });
                 }
-                let expected = Type::polymorphic_integer_or_field(self.interner);
+                let expected = self.polymorphic_integer_or_field();
                 rhs_type.unify(&expected, &mut self.errors, || TypeCheckError::InvalidUnaryOp {
                     kind: rhs_type.to_string(),
                     span,
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index bb42ebf68fb..5bda4b9345e 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -37,6 +37,11 @@ pub struct TypeChecker<'interner> {
     /// on each variable, but it is only until function calls when the types
     /// needed for the trait constraint may become known.
     trait_constraints: Vec<(TraitConstraint, ExprId)>,
+
+    /// All type variables created in the current function.
+    /// This map is used to default any integer type variables at the end of
+    /// a function (before checking trait constraints) if a type wasn't already chosen.
+    type_variables: Vec<Type>,
 }
 
 /// Type checks a function and assigns the
@@ -127,6 +132,16 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
         }
     }
 
+    // Default any type variables that still need defaulting.
+    // This is done before trait impl search since leaving them bindable can lead to errors
+    // when multiple impls are available. Instead we default first to choose the Field or u64 impl.
+    for typ in &type_checker.type_variables {
+        if let Type::TypeVariable(variable, kind) = typ.follow_bindings() {
+            let msg = "TypeChecker should only track defaultable type vars";
+            variable.bind(kind.default_type().expect(msg));
+        }
+    }
+
     // Verify any remaining trait constraints arising from the function body
     for (constraint, expr_id) in std::mem::take(&mut type_checker.trait_constraints) {
         let span = type_checker.interner.expr_span(&expr_id);
@@ -333,7 +348,13 @@ fn check_function_type_matches_expected_type(
 
 impl<'interner> TypeChecker<'interner> {
     fn new(interner: &'interner mut NodeInterner) -> Self {
-        Self { interner, errors: Vec::new(), trait_constraints: Vec::new(), current_function: None }
+        Self {
+            interner,
+            errors: Vec::new(),
+            trait_constraints: Vec::new(),
+            type_variables: Vec::new(),
+            current_function: None,
+        }
     }
 
     fn check_function_body(&mut self, body: &ExprId) -> Type {
@@ -348,6 +369,7 @@ impl<'interner> TypeChecker<'interner> {
             interner,
             errors: Vec::new(),
             trait_constraints: Vec::new(),
+            type_variables: Vec::new(),
             current_function: None,
         };
         let statement = this.interner.get_global(id).let_statement;
@@ -381,6 +403,22 @@ impl<'interner> TypeChecker<'interner> {
             make_error,
         );
     }
+
+    /// Return a fresh integer or field type variable and log it
+    /// in self.type_variables to default it later.
+    fn polymorphic_integer_or_field(&mut self) -> Type {
+        let typ = Type::polymorphic_integer_or_field(self.interner);
+        self.type_variables.push(typ.clone());
+        typ
+    }
+
+    /// Return a fresh integer type variable and log it
+    /// in self.type_variables to default it later.
+    fn polymorphic_integer(&mut self) -> Type {
+        let typ = Type::polymorphic_integer(self.interner);
+        self.type_variables.push(typ.clone());
+        typ
+    }
 }
 
 // XXX: These tests are all manual currently.
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index b97a4530999..fb57aa75f89 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -71,7 +71,7 @@ impl<'interner> TypeChecker<'interner> {
             expr_span: range_span,
         });
 
-        let expected_type = Type::polymorphic_integer(self.interner);
+        let expected_type = self.polymorphic_integer();
 
         self.unify(&start_range_type, &expected_type, || TypeCheckError::TypeCannotBeUsed {
             typ: start_range_type.clone(),
@@ -233,15 +233,13 @@ impl<'interner> TypeChecker<'interner> {
                 let expr_span = self.interner.expr_span(index);
                 let location = *location;
 
-                index_type.unify(
-                    &Type::polymorphic_integer_or_field(self.interner),
-                    &mut self.errors,
-                    || TypeCheckError::TypeMismatch {
+                index_type.unify(&self.polymorphic_integer_or_field(), &mut self.errors, || {
+                    TypeCheckError::TypeMismatch {
                         expected_typ: "an integer".to_owned(),
                         expr_typ: index_type.to_string(),
                         expr_span,
-                    },
-                );
+                    }
+                });
 
                 let (mut lvalue_type, mut lvalue, mut mutable) =
                     self.check_lvalue(array, assign_span);
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 2223773948f..e0d86592d9f 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -1003,7 +1003,12 @@ impl<'interner> Monomorphizer<'interner> {
                     Err(constraints) => {
                         let failed_constraints = vecmap(constraints, |constraint| {
                             let id = constraint.trait_id;
-                            let name = self.interner.get_trait(id).name.to_string();
+                            let mut name = self.interner.get_trait(id).name.to_string();
+                            if !constraint.trait_generics.is_empty() {
+                                let types =
+                                    vecmap(&constraint.trait_generics, |t| format!("{t:?}"));
+                                name += &format!("<{}>", types.join(", "));
+                            }
                             format!("  {}: {name}", constraint.typ)
                         })
                         .join("\n");
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 09e0cb04d26..dcfceccdb57 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1079,6 +1079,7 @@ impl NodeInterner {
     /// constraint, but when where clauses are involved, the failing constraint may be several
     /// constraints deep. In this case, all of the constraints are returned, starting with the
     /// failing one.
+    /// If this list of failing constraints is empty, this means type annotations are required.
     pub fn lookup_trait_implementation(
         &self,
         object_type: &Type,
@@ -1121,6 +1122,10 @@ impl NodeInterner {
     }
 
     /// Similar to `lookup_trait_implementation` but does not apply any type bindings on success.
+    /// On error returns either:
+    /// - 1+ failing trait constraints, including the original.
+    ///   Each constraint after the first represents a `where` clause that was followed.
+    /// - 0 trait constraints indicating type annotations are needed to choose an impl.
     pub fn try_lookup_trait_implementation(
         &self,
         object_type: &Type,
@@ -1138,6 +1143,11 @@ impl NodeInterner {
         Ok((impl_kind, bindings))
     }
 
+    /// Returns the trait implementation if found.
+    /// On error returns either:
+    /// - 1+ failing trait constraints, including the original.
+    ///   Each constraint after the first represents a `where` clause that was followed.
+    /// - 0 trait constraints indicating type annotations are needed to choose an impl.
     fn lookup_trait_implementation_helper(
         &self,
         object_type: &Type,
@@ -1156,15 +1166,22 @@ impl NodeInterner {
 
         let object_type = object_type.substitute(type_bindings);
 
+        // If the object type isn't known, just return an error saying type annotations are needed.
+        if object_type.is_bindable() {
+            return Err(Vec::new());
+        }
+
         let impls =
             self.trait_implementation_map.get(&trait_id).ok_or_else(|| vec![make_constraint()])?;
 
+        let mut matching_impls = Vec::new();
+
         for (existing_object_type2, impl_kind) in impls {
             // Bug: We're instantiating only the object type's generics here, not all of the trait's generics like we need to
             let (existing_object_type, instantiation_bindings) =
                 existing_object_type2.instantiate(self);
 
-            let mut fresh_bindings = TypeBindings::new();
+            let mut fresh_bindings = type_bindings.clone();
 
             let mut check_trait_generics = |impl_generics: &[Type]| {
                 trait_generics.iter().zip(impl_generics).all(|(trait_generic, impl_generic2)| {
@@ -1189,16 +1206,13 @@ impl NodeInterner {
             }
 
             if object_type.try_unify(&existing_object_type, &mut fresh_bindings).is_ok() {
-                // The unification was successful so we can append fresh_bindings to our bindings list
-                type_bindings.extend(fresh_bindings);
-
                 if let TraitImplKind::Normal(impl_id) = impl_kind {
                     let trait_impl = self.get_trait_implementation(*impl_id);
                     let trait_impl = trait_impl.borrow();
 
                     if let Err(mut errors) = self.validate_where_clause(
                         &trait_impl.where_clause,
-                        type_bindings,
+                        &mut fresh_bindings,
                         &instantiation_bindings,
                         recursion_limit,
                     ) {
@@ -1207,11 +1221,20 @@ impl NodeInterner {
                     }
                 }
 
-                return Ok(impl_kind.clone());
+                matching_impls.push((impl_kind.clone(), fresh_bindings));
             }
         }
 
-        Err(vec![make_constraint()])
+        if matching_impls.len() == 1 {
+            let (impl_, fresh_bindings) = matching_impls.pop().unwrap();
+            *type_bindings = fresh_bindings;
+            Ok(impl_)
+        } else if matching_impls.is_empty() {
+            Err(vec![make_constraint()])
+        } else {
+            // multiple matching impls, type annotations needed
+            Err(vec![])
+        }
     }
 
     /// Verifies that each constraint in the given where clause is valid.
@@ -1227,12 +1250,11 @@ impl NodeInterner {
             // Instantiation bindings are generally safe to force substitute into the same type.
             // This is needed here to undo any bindings done to trait methods by monomorphization.
             // Otherwise, an impl for (A, B) could get narrowed to only an impl for e.g. (u8, u16).
-            let constraint_type = constraint.typ.force_substitute(instantiation_bindings);
-            let constraint_type = constraint_type.substitute(type_bindings);
+            let constraint_type =
+                constraint.typ.force_substitute(instantiation_bindings).substitute(type_bindings);
 
             let trait_generics = vecmap(&constraint.trait_generics, |generic| {
-                let generic = generic.force_substitute(instantiation_bindings);
-                generic.substitute(type_bindings)
+                generic.force_substitute(instantiation_bindings).substitute(type_bindings)
             });
 
             self.lookup_trait_implementation_helper(
@@ -1241,10 +1263,11 @@ impl NodeInterner {
                 &trait_generics,
                 // Use a fresh set of type bindings here since the constraint_type originates from
                 // our impl list, which we don't want to bind to.
-                &mut TypeBindings::new(),
+                type_bindings,
                 recursion_limit - 1,
             )?;
         }
+
         Ok(())
     }
 
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 5b97d809896..12bf373e671 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -1,7 +1,7 @@
 use crate::hash::Hasher;
 use crate::default::Default;
 
-global RATE = 3;
+global RATE: u32 = 3;
 
 struct Poseidon2 {
     cache: [Field;3],

From a0f7474ae6bd74132efdb945d2eb2383f3913cce Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Fri, 29 Mar 2024 15:19:10 -0400
Subject: [PATCH 129/416] feat: Sync from aztec-packages (#4670)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat(acvm): Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
feat(acir_gen): Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
refactor: inject fetcher instead of using global
(https://github.com/AztecProtocol/aztec-packages/pull/5502)
END_COMMIT_OVERRIDE

---------

Co-authored-by: vezenovm <mvezenov@gmail.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: jfecher <jfecher11@gmail.com>
---
 .aztec-sync-commit                            |   2 +-
 acvm-repo/acir/src/circuit/opcodes.rs         |   4 +-
 .../acir/src/native_types/witness_stack.rs    |  14 +
 .../acvm/src/compiler/transformers/mod.rs     |   7 +-
 acvm-repo/acvm/src/pwg/mod.rs                 |  96 +++-
 acvm-repo/acvm_js/src/execute.rs              |   3 +
 compiler/noirc_driver/src/lib.rs              |  17 +-
 .../brillig/brillig_gen/brillig_slice_ops.rs  |   5 +-
 .../brillig/brillig_gen/variable_liveness.rs  |   6 +-
 compiler/noirc_evaluator/src/lib.rs           |   2 +-
 compiler/noirc_evaluator/src/ssa.rs           |  74 ++-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |  24 +
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 520 +++++++++++++++---
 .../src/ssa/function_builder/mod.rs           |  33 +-
 compiler/noirc_evaluator/src/ssa/ir/dom.rs    |   6 +-
 .../noirc_evaluator/src/ssa/ir/function.rs    |  43 +-
 .../noirc_evaluator/src/ssa/ir/post_order.rs  |   4 +-
 .../src/ssa/opt/bubble_up_constrains.rs       |   4 +-
 .../src/ssa/opt/constant_folding.rs           |  14 +-
 .../src/ssa/opt/defunctionalize.rs            |   4 +-
 compiler/noirc_evaluator/src/ssa/opt/die.rs   |   4 +-
 .../src/ssa/opt/flatten_cfg.rs                |  24 +-
 .../ssa/opt/flatten_cfg/branch_analysis.rs    |  11 +-
 .../noirc_evaluator/src/ssa/opt/inlining.rs   |  44 +-
 .../noirc_evaluator/src/ssa/opt/mem2reg.rs    |  12 +-
 compiler/noirc_evaluator/src/ssa/opt/rc.rs    |  15 +-
 .../src/ssa/opt/remove_bit_shifts.rs          |   4 +-
 .../src/ssa/opt/simplify_cfg.rs               |   6 +-
 .../noirc_evaluator/src/ssa/opt/unrolling.rs  |  13 +-
 .../src/ssa/ssa_gen/context.rs                |   8 +-
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  10 +-
 .../src/ssa/ssa_gen/program.rs                |   5 +-
 compiler/noirc_frontend/src/ast/function.rs   |   1 +
 .../src/hir/resolution/resolver.rs            |   5 +-
 .../src/hir/type_check/errors.rs              |   2 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  |  41 +-
 .../noirc_frontend/src/hir_def/function.rs    |   4 +
 compiler/noirc_frontend/src/lexer/lexer.rs    |  10 +
 compiler/noirc_frontend/src/lexer/token.rs    |  12 +
 .../src/monomorphization/ast.rs               |   5 +
 .../src/monomorphization/mod.rs               |  61 +-
 .../github-dependency-resolver.ts             |   6 +-
 compiler/wasm/src/noir/noir-wasm-compiler.ts  |   3 +-
 .../github-dependency-resolver.test.ts        |   8 +-
 cspell.json                                   |   1 +
 .../execution_success/fold_basic/Nargo.toml   |   7 +
 .../execution_success/fold_basic/Prover.toml  |   2 +
 .../execution_success/fold_basic/src/main.nr  |  11 +
 .../fold_basic_nested_call/Nargo.toml         |   7 +
 .../fold_basic_nested_call/Prover.toml        |   2 +
 .../fold_basic_nested_call/src/main.nr        |  16 +
 tooling/acvm_cli/src/cli/execute_cmd.rs       |  21 +-
 tooling/backend_interface/src/proof_system.rs |   4 +-
 tooling/debugger/ignored-tests.txt            |   2 +
 tooling/debugger/src/context.rs               |   3 +
 tooling/nargo/src/errors.rs                   |   4 +-
 tooling/nargo/src/ops/execute.rs              | 196 +++++--
 tooling/nargo/src/ops/mod.rs                  |   2 +-
 tooling/nargo/src/ops/test.rs                 |  14 +-
 tooling/nargo_cli/src/cli/debug_cmd.rs        |   8 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |  28 +-
 tooling/nargo_cli/src/cli/fs/witness.rs       |   6 +-
 tooling/nargo_cli/src/cli/prove_cmd.rs        |  11 +-
 63 files changed, 1228 insertions(+), 313 deletions(-)
 create mode 100644 test_programs/execution_success/fold_basic/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_basic/Prover.toml
 create mode 100644 test_programs/execution_success/fold_basic/src/main.nr
 create mode 100644 test_programs/execution_success/fold_basic_nested_call/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_basic_nested_call/Prover.toml
 create mode 100644 test_programs/execution_success/fold_basic_nested_call/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index ad4ef635e17..540b447693c 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-a18288d9b8f3057b9e79362d922da656dacf22a9
+bb719200034e3bc6db09fb56538dadca4203abf4
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index 064a9d1244a..68d28b287e6 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -99,8 +99,8 @@ impl std::fmt::Display for Opcode {
             }
             Opcode::Call { id, inputs, outputs } => {
                 write!(f, "CALL func {}: ", id)?;
-                writeln!(f, "inputs: {:?}", inputs)?;
-                writeln!(f, "outputs: {:?}", outputs)
+                write!(f, "inputs: {:?}, ", inputs)?;
+                write!(f, "outputs: {:?}", outputs)
             }
         }
     }
diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs
index 9592d90b014..a9e8f219b3e 100644
--- a/acvm-repo/acir/src/native_types/witness_stack.rs
+++ b/acvm-repo/acir/src/native_types/witness_stack.rs
@@ -32,6 +32,20 @@ pub struct StackItem {
     pub witness: WitnessMap,
 }
 
+impl WitnessStack {
+    pub fn push(&mut self, index: u32, witness: WitnessMap) {
+        self.stack.push(StackItem { index, witness });
+    }
+
+    pub fn peek(&self) -> Option<&StackItem> {
+        self.stack.last()
+    }
+
+    pub fn length(&self) -> usize {
+        self.stack.len()
+    }
+}
+
 impl From<WitnessMap> for WitnessStack {
     fn from(witness: WitnessMap) -> Self {
         let stack = vec![StackItem { index: 0, witness }];
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 18f49c154f1..1ba261b09a3 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -142,7 +142,12 @@ pub(super) fn transform_internal(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
-            Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
+            Opcode::Call { .. } => {
+                // `Call` does not write values to the `WitnessMap`
+                // A separate ACIR function should have its own respective `WitnessMap`
+                new_acir_opcode_positions.push(acir_opcode_positions[index]);
+                transformed_opcodes.push(opcode);
+            }
         }
     }
 
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index 0fd733a6336..3cedcfc0399 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -49,6 +49,12 @@ pub enum ACVMStatus {
     ///
     /// Once this is done, the ACVM can be restarted to solve the remaining opcodes.
     RequiresForeignCall(ForeignCallWaitInfo),
+
+    /// The ACVM has encountered a request for an ACIR [call][acir::circuit::Opcode]
+    /// to execute a separate ACVM instance. The result of the ACIR call must be passd back to the ACVM.
+    ///
+    /// Once this is done, the ACVM can be restarted to solve the remaining opcodes.
+    RequiresAcirCall(AcirCallWaitInfo),
 }
 
 impl std::fmt::Display for ACVMStatus {
@@ -58,6 +64,7 @@ impl std::fmt::Display for ACVMStatus {
             ACVMStatus::InProgress => write!(f, "In progress"),
             ACVMStatus::Failure(_) => write!(f, "Execution failure"),
             ACVMStatus::RequiresForeignCall(_) => write!(f, "Waiting on foreign call"),
+            ACVMStatus::RequiresAcirCall(_) => write!(f, "Waiting on acir call"),
         }
     }
 }
@@ -117,6 +124,10 @@ pub enum OpcodeResolutionError {
     BlackBoxFunctionFailed(BlackBoxFunc, String),
     #[error("Failed to solve brillig function, reason: {message}")]
     BrilligFunctionFailed { message: String, call_stack: Vec<OpcodeLocation> },
+    #[error("Attempted to call `main` with a `Call` opcode")]
+    AcirMainCallAttempted { opcode_location: ErrorLocation },
+    #[error("{results_size:?} result values were provided for {outputs_size:?} call output witnesses, most likely due to bad ACIR codegen")]
+    AcirCallOutputsMismatch { opcode_location: ErrorLocation, results_size: u32, outputs_size: u32 },
 }
 
 impl From<BlackBoxResolutionError> for OpcodeResolutionError {
@@ -147,6 +158,13 @@ pub struct ACVM<'a, B: BlackBoxFunctionSolver> {
     witness_map: WitnessMap,
 
     brillig_solver: Option<BrilligSolver<'a, B>>,
+
+    /// A counter maintained throughout an ACVM process that determines
+    /// whether the caller has resolved the results of an ACIR [call][Opcode::Call].
+    acir_call_counter: usize,
+    /// Represents the outputs of all ACIR calls during an ACVM process
+    /// List is appended onto by the caller upon reaching a [ACVMStatus::RequiresAcirCall]
+    acir_call_results: Vec<Vec<FieldElement>>,
 }
 
 impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
@@ -161,6 +179,8 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             instruction_pointer: 0,
             witness_map: initial_witness,
             brillig_solver: None,
+            acir_call_counter: 0,
+            acir_call_results: Vec::default(),
         }
     }
 
@@ -244,6 +264,29 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         self.status(ACVMStatus::InProgress);
     }
 
+    /// Sets the status of the VM to `RequiresAcirCall`
+    /// Indicating that the VM is now waiting for an ACIR call to be resolved
+    fn wait_for_acir_call(&mut self, acir_call: AcirCallWaitInfo) -> ACVMStatus {
+        self.status(ACVMStatus::RequiresAcirCall(acir_call))
+    }
+
+    /// Resolves an ACIR call's result (simply a list of fields) using a result calculated by a separate ACVM instance.
+    ///
+    /// The current ACVM instance can then be restarted to solve the remaining ACIR opcodes.
+    pub fn resolve_pending_acir_call(&mut self, call_result: Vec<FieldElement>) {
+        if !matches!(self.status, ACVMStatus::RequiresAcirCall(_)) {
+            panic!("ACVM is not expecting an ACIR call response as no call was made");
+        }
+
+        if self.acir_call_counter < self.acir_call_results.len() {
+            panic!("No unresolved ACIR calls");
+        }
+        self.acir_call_results.push(call_result);
+
+        // Now that the ACIR call has been resolved then we can resume execution.
+        self.status(ACVMStatus::InProgress);
+    }
+
     /// Executes the ACVM's circuit until execution halts.
     ///
     /// Execution can halt due to three reasons:
@@ -281,7 +324,10 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
                 res => res.map(|_| ()),
             },
-            Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
+            Opcode::Call { .. } => match self.solve_call_opcode() {
+                Ok(Some(input_values)) => return self.wait_for_acir_call(input_values),
+                res => res.map(|_| ()),
+            },
         };
         self.handle_opcode_resolution(resolution)
     }
@@ -400,6 +446,46 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         self.brillig_solver = Some(solver);
         self.solve_opcode()
     }
+
+    pub fn solve_call_opcode(&mut self) -> Result<Option<AcirCallWaitInfo>, OpcodeResolutionError> {
+        let Opcode::Call { id, inputs, outputs } = &self.opcodes[self.instruction_pointer] else {
+            unreachable!("Not executing a Call opcode");
+        };
+        if *id == 0 {
+            return Err(OpcodeResolutionError::AcirMainCallAttempted {
+                opcode_location: ErrorLocation::Resolved(OpcodeLocation::Acir(
+                    self.instruction_pointer(),
+                )),
+            });
+        }
+
+        if self.acir_call_counter >= self.acir_call_results.len() {
+            let mut initial_witness = WitnessMap::default();
+            for (i, input_witness) in inputs.iter().enumerate() {
+                let input_value = *witness_to_value(&self.witness_map, *input_witness)?;
+                initial_witness.insert(Witness(i as u32), input_value);
+            }
+            return Ok(Some(AcirCallWaitInfo { id: *id, initial_witness }));
+        }
+
+        let result_values = &self.acir_call_results[self.acir_call_counter];
+        if outputs.len() != result_values.len() {
+            return Err(OpcodeResolutionError::AcirCallOutputsMismatch {
+                opcode_location: ErrorLocation::Resolved(OpcodeLocation::Acir(
+                    self.instruction_pointer(),
+                )),
+                results_size: result_values.len() as u32,
+                outputs_size: outputs.len() as u32,
+            });
+        }
+
+        for (output_witness, result_value) in outputs.iter().zip(result_values) {
+            insert_value(output_witness, *result_value, &mut self.witness_map)?;
+        }
+
+        self.acir_call_counter += 1;
+        Ok(None)
+    }
 }
 
 // Returns the concrete value for a particular witness
@@ -469,3 +555,11 @@ fn any_witness_from_expression(expr: &Expression) -> Option<Witness> {
         Some(expr.linear_combinations[0].1)
     }
 }
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct AcirCallWaitInfo {
+    /// Index in the list of ACIR function's that should be called
+    pub id: u32,
+    /// Initial witness for the given circuit to be called
+    pub initial_witness: WitnessMap,
+}
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index ac71a573e64..60d27a489e2 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -113,6 +113,9 @@ pub async fn execute_circuit_with_black_box_solver(
 
                 acvm.resolve_pending_foreign_call(result);
             }
+            ACVMStatus::RequiresAcirCall(_) => {
+                todo!("Handle acir calls in acvm JS");
+            }
         }
     }
 
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 151633f9e33..86d4cd1510d 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -3,13 +3,13 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
-use acvm::acir::circuit::{ExpressionWidth, Program};
+use acvm::acir::circuit::ExpressionWidth;
 use clap::Args;
 use fm::{FileId, FileManager};
 use iter_extended::vecmap;
 use noirc_abi::{AbiParameter, AbiType, ContractEvent};
 use noirc_errors::{CustomDiagnostic, FileDiagnostic};
-use noirc_evaluator::create_circuit;
+use noirc_evaluator::create_program;
 use noirc_evaluator::errors::RuntimeError;
 use noirc_frontend::debug::build_debug_crate_file;
 use noirc_frontend::graph::{CrateId, CrateName};
@@ -484,7 +484,8 @@ pub fn compile_no_check(
         return Ok(cached_program.expect("cache must exist for hashes to match"));
     }
     let visibility = program.return_visibility;
-    let (circuit, debug, input_witnesses, return_witnesses, warnings) = create_circuit(
+
+    let (program, debug, warnings, input_witnesses, return_witnesses) = create_program(
         program,
         options.show_ssa,
         options.show_brillig,
@@ -494,13 +495,17 @@ pub fn compile_no_check(
 
     let abi =
         abi_gen::gen_abi(context, &main_function, input_witnesses, return_witnesses, visibility);
-    let file_map = filter_relevant_files(&[debug.clone()], &context.file_manager);
+    let file_map = filter_relevant_files(&debug, &context.file_manager);
 
     Ok(CompiledProgram {
         hash,
         // TODO(https://github.com/noir-lang/noir/issues/4428)
-        program: Program { functions: vec![circuit] },
-        debug,
+        program,
+        // TODO(https://github.com/noir-lang/noir/issues/4428)
+        // Debug info is only relevant for errors at execution time which is not yet supported
+        // The CompileProgram `debug` field is used in multiple places and is better
+        // left to be updated once execution of multiple ACIR functions is enabled
+        debug: debug[0].clone(),
         abi,
         file_map,
         noir_version: NOIR_ARTIFACT_VERSION_STRING.to_string(),
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index e42b2787f73..b93693d9c79 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -373,8 +373,9 @@ mod tests {
     use crate::ssa::ssa_gen::Ssa;
 
     fn create_test_environment() -> (Ssa, FunctionContext, BrilligContext) {
-        let builder =
-            FunctionBuilder::new("main".to_string(), Id::test_new(0), RuntimeType::Brillig);
+        let mut builder = FunctionBuilder::new("main".to_string(), Id::test_new(0));
+        builder.set_runtime(RuntimeType::Brillig);
+
         let ssa = builder.finish();
         let mut brillig_context = create_context();
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
index 05978c2c6ab..c9f1cd1e247 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
@@ -323,7 +323,8 @@ mod test {
         //   }
 
         let main_id = Id::test_new(1);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Brillig);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
+        builder.set_runtime(RuntimeType::Brillig);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -425,7 +426,8 @@ mod test {
         //   }
 
         let main_id = Id::test_new(1);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Brillig);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
+        builder.set_runtime(RuntimeType::Brillig);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/lib.rs b/compiler/noirc_evaluator/src/lib.rs
index 70751d3e541..54376963338 100644
--- a/compiler/noirc_evaluator/src/lib.rs
+++ b/compiler/noirc_evaluator/src/lib.rs
@@ -11,4 +11,4 @@ pub mod ssa;
 
 pub mod brillig;
 
-pub use ssa::create_circuit;
+pub use ssa::create_program;
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 01dc50a7119..59f2bdc6f84 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -14,11 +14,11 @@ use crate::{
     errors::{RuntimeError, SsaReport},
 };
 use acvm::acir::{
-    circuit::{Circuit, ExpressionWidth, PublicInputs},
+    circuit::{Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs},
     native_types::Witness,
 };
 
-use noirc_errors::debug_info::DebugInfo;
+use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
 
 use noirc_frontend::{
     hir_def::function::FunctionSignature, monomorphization::ast::Program, Visibility,
@@ -42,7 +42,7 @@ pub(crate) fn optimize_into_acir(
     print_brillig_trace: bool,
     force_brillig_output: bool,
     print_timings: bool,
-) -> Result<GeneratedAcir, RuntimeError> {
+) -> Result<Vec<GeneratedAcir>, RuntimeError> {
     let abi_distinctness = program.return_distinctness;
 
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
@@ -72,7 +72,7 @@ pub(crate) fn optimize_into_acir(
     let last_array_uses = ssa.find_last_array_uses();
 
     time("SSA to ACIR", print_timings, || {
-        ssa.into_acir(brillig, abi_distinctness, &last_array_uses)
+        ssa.into_acir(&brillig, abi_distinctness, &last_array_uses)
     })
 }
 
@@ -89,30 +89,80 @@ fn time<T>(name: &str, print_timings: bool, f: impl FnOnce() -> T) -> T {
     result
 }
 
-/// Compiles the [`Program`] into [`ACIR`][acvm::acir::circuit::Circuit].
+/// Compiles the [`Program`] into [`ACIR``][acvm::acir::circuit::Program].
 ///
 /// The output ACIR is is backend-agnostic and so must go through a transformation pass before usage in proof generation.
 #[allow(clippy::type_complexity)]
 #[tracing::instrument(level = "trace", skip_all)]
-pub fn create_circuit(
+pub fn create_program(
     program: Program,
     enable_ssa_logging: bool,
     enable_brillig_logging: bool,
     force_brillig_output: bool,
     print_codegen_timings: bool,
-) -> Result<(Circuit, DebugInfo, Vec<Witness>, Vec<Witness>, Vec<SsaReport>), RuntimeError> {
+) -> Result<(AcirProgram, Vec<DebugInfo>, Vec<SsaReport>, Vec<Witness>, Vec<Witness>), RuntimeError>
+{
     let debug_variables = program.debug_variables.clone();
     let debug_types = program.debug_types.clone();
     let debug_functions = program.debug_functions.clone();
-    let func_sig = program.main_function_signature.clone();
+
+    let func_sigs = program.function_signatures.clone();
+
     let recursive = program.recursive;
-    let mut generated_acir = optimize_into_acir(
+    let generated_acirs = optimize_into_acir(
         program,
         enable_ssa_logging,
         enable_brillig_logging,
         force_brillig_output,
         print_codegen_timings,
     )?;
+    assert_eq!(
+        generated_acirs.len(),
+        func_sigs.len(),
+        "The generated ACIRs should match the supplied function signatures"
+    );
+
+    let mut functions = vec![];
+    let mut debug_infos = vec![];
+    let mut warning_infos = vec![];
+    let mut main_input_witnesses = Vec::new();
+    let mut main_return_witnesses = Vec::new();
+    // For setting up the ABI we need separately specify main's input and return witnesses
+    let mut is_main = true;
+    for (acir, func_sig) in generated_acirs.into_iter().zip(func_sigs) {
+        let (circuit, debug_info, warnings, input_witnesses, return_witnesses) =
+            convert_generated_acir_into_circuit(
+                acir,
+                func_sig,
+                recursive,
+                // TODO: get rid of these clones
+                debug_variables.clone(),
+                debug_functions.clone(),
+                debug_types.clone(),
+            );
+        functions.push(circuit);
+        debug_infos.push(debug_info);
+        warning_infos.extend(warnings);
+        if is_main {
+            main_input_witnesses = input_witnesses;
+            main_return_witnesses = return_witnesses;
+        }
+        is_main = false;
+    }
+
+    let program = AcirProgram { functions };
+
+    Ok((program, debug_infos, warning_infos, main_input_witnesses, main_return_witnesses))
+}
+
+fn convert_generated_acir_into_circuit(
+    mut generated_acir: GeneratedAcir,
+    func_sig: FunctionSignature,
+    recursive: bool,
+    debug_variables: DebugVariables,
+    debug_functions: DebugFunctions,
+    debug_types: DebugTypes,
+) -> (Circuit, DebugInfo, Vec<SsaReport>, Vec<Witness>, Vec<Witness>) {
     let opcodes = generated_acir.take_opcodes();
     let current_witness_index = generated_acir.current_witness_index().0;
     let GeneratedAcir {
@@ -124,6 +174,8 @@ pub fn create_circuit(
         ..
     } = generated_acir;
 
+    let locations = locations.clone();
+
     let (public_parameter_witnesses, private_parameters) =
         split_public_and_private_inputs(&func_sig, &input_witnesses);
 
@@ -137,7 +189,7 @@ pub fn create_circuit(
         private_parameters,
         public_parameters,
         return_values,
-        assert_messages: assert_messages.into_iter().collect(),
+        assert_messages: assert_messages.clone().into_iter().collect(),
         recursive,
     };
 
@@ -153,7 +205,7 @@ pub fn create_circuit(
     let (optimized_circuit, transformation_map) = acvm::compiler::optimize(circuit);
     debug_info.update_acir(transformation_map);
 
-    Ok((optimized_circuit, debug_info, input_witnesses, return_witnesses, warnings))
+    (optimized_circuit, debug_info, warnings, input_witnesses, return_witnesses)
 }
 
 // Takes each function argument and partitions the circuit's inputs witnesses according to its visibility.
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 7e951cf4e00..bcd62e3b062 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1757,6 +1757,30 @@ impl AcirContext {
         }
         Ok(())
     }
+
+    pub(crate) fn call_acir_function(
+        &mut self,
+        id: u32,
+        inputs: Vec<AcirValue>,
+        output_count: usize,
+    ) -> Result<Vec<AcirVar>, RuntimeError> {
+        let inputs = self.prepare_inputs_for_black_box_func_call(inputs)?;
+        let inputs = inputs
+            .iter()
+            .flat_map(|input| vecmap(input, |input| input.witness))
+            .collect::<Vec<_>>();
+        let outputs = vecmap(0..output_count, |_| self.acir_ir.next_witness_index());
+
+        // Convert `Witness` values which are now constrained to be the output of the
+        // ACIR function call into `AcirVar`s.
+        // Similar to black box functions, we do not apply range information on the output of the  function.
+        // See issue https://github.com/noir-lang/noir/issues/1439
+        let results =
+            vecmap(&outputs, |witness_index| self.add_data(AcirVarData::Witness(*witness_index)));
+
+        self.acir_ir.push_opcode(Opcode::Call { id, inputs, outputs });
+        Ok(results)
+    }
 }
 
 /// Enum representing the possible values that a
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 8390f480e3a..96f959612af 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -25,6 +25,7 @@ use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
 use crate::brillig::brillig_ir::BrilligContext;
 use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig};
 use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
+use crate::ssa::ir::function::InlineType;
 pub(crate) use acir_ir::generated_acir::GeneratedAcir;
 
 use acvm::acir::native_types::Witness;
@@ -178,31 +179,45 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip_all)]
     pub(crate) fn into_acir(
         self,
-        brillig: Brillig,
+        brillig: &Brillig,
         abi_distinctness: Distinctness,
         last_array_uses: &HashMap<ValueId, InstructionId>,
-    ) -> Result<GeneratedAcir, RuntimeError> {
-        let context = Context::new();
-        let mut generated_acir = context.convert_ssa(self, brillig, last_array_uses)?;
+    ) -> Result<Vec<GeneratedAcir>, RuntimeError> {
+        let mut acirs = Vec::new();
+        // TODO: can we parallelise this?
+        for function in self.functions.values() {
+            let context = Context::new();
+            if let Some(generated_acir) =
+                context.convert_ssa_function(&self, function, brillig, last_array_uses)?
+            {
+                acirs.push(generated_acir);
+            }
+        }
 
+        // TODO: check whether doing this for a single circuit's return witnesses is correct.
+        // We probably need it for all foldable circuits, as any circuit being folded is essentially an entry point. However, I do not know how that
+        // plays a part when we potentially want not inlined functions normally as part of the compiler.
+        // Also at the moment we specify Distinctness as part of the ABI exclusively rather than the function itself
+        // so this will need to be updated.
+        let main_func_acir = &mut acirs[0];
         match abi_distinctness {
             Distinctness::Distinct => {
                 // Create a witness for each return witness we have
                 // to guarantee that the return witnesses are distinct
-                let distinct_return_witness: Vec<_> = generated_acir
+                let distinct_return_witness: Vec<_> = main_func_acir
                     .return_witnesses
                     .clone()
                     .into_iter()
                     .map(|return_witness| {
-                        generated_acir
+                        main_func_acir
                             .create_witness_for_expression(&Expression::from(return_witness))
                     })
                     .collect();
 
-                generated_acir.return_witnesses = distinct_return_witness;
-                Ok(generated_acir)
+                main_func_acir.return_witnesses = distinct_return_witness;
+                Ok(acirs)
             }
-            Distinctness::DuplicationAllowed => Ok(generated_acir),
+            Distinctness::DuplicationAllowed => Ok(acirs),
         }
     }
 }
@@ -225,17 +240,33 @@ impl Context {
         }
     }
 
-    /// Converts SSA into ACIR
-    fn convert_ssa(
+    fn convert_ssa_function(
         self,
-        ssa: Ssa,
-        brillig: Brillig,
+        ssa: &Ssa,
+        function: &Function,
+        brillig: &Brillig,
         last_array_uses: &HashMap<ValueId, InstructionId>,
-    ) -> Result<GeneratedAcir, RuntimeError> {
-        let main_func = ssa.main();
-        match main_func.runtime() {
-            RuntimeType::Acir => self.convert_acir_main(main_func, &ssa, brillig, last_array_uses),
-            RuntimeType::Brillig => self.convert_brillig_main(main_func, brillig),
+    ) -> Result<Option<GeneratedAcir>, RuntimeError> {
+        match function.runtime() {
+            RuntimeType::Acir(inline_type) => {
+                match inline_type {
+                    InlineType::Fold => {}
+                    InlineType::Inline => {
+                        if function.id() != ssa.main_id {
+                            panic!("ACIR function should have been inlined earlier if not marked otherwise");
+                        }
+                    }
+                }
+                // We only want to convert entry point functions. This being `main` and those marked with `#[fold]`
+                Ok(Some(self.convert_acir_main(function, ssa, brillig, last_array_uses)?))
+            }
+            RuntimeType::Brillig => {
+                if function.id() == ssa.main_id {
+                    Ok(Some(self.convert_brillig_main(function, brillig)?))
+                } else {
+                    Ok(None)
+                }
+            }
         }
     }
 
@@ -243,7 +274,7 @@ impl Context {
         mut self,
         main_func: &Function,
         ssa: &Ssa,
-        brillig: Brillig,
+        brillig: &Brillig,
         last_array_uses: &HashMap<ValueId, InstructionId>,
     ) -> Result<GeneratedAcir, RuntimeError> {
         let dfg = &main_func.dfg;
@@ -257,7 +288,7 @@ impl Context {
                 *instruction_id,
                 dfg,
                 ssa,
-                &brillig,
+                brillig,
                 last_array_uses,
             )?);
         }
@@ -269,7 +300,7 @@ impl Context {
     fn convert_brillig_main(
         mut self,
         main_func: &Function,
-        brillig: Brillig,
+        brillig: &Brillig,
     ) -> Result<GeneratedAcir, RuntimeError> {
         let dfg = &main_func.dfg;
 
@@ -282,7 +313,7 @@ impl Context {
         let outputs: Vec<AcirType> =
             vecmap(main_func.returns(), |result_id| dfg.type_of_value(*result_id).into());
 
-        let code = self.gen_brillig_for(main_func, &brillig)?;
+        let code = self.gen_brillig_for(main_func, brillig)?;
 
         // We specifically do not attempt execution of the brillig code being generated as this can result in it being
         // replaced with constraints on witnesses to the program outputs.
@@ -537,15 +568,40 @@ impl Context {
                     Value::Function(id) => {
                         let func = &ssa.functions[id];
                         match func.runtime() {
-                            RuntimeType::Acir => unimplemented!(
-                                "expected an intrinsic/brillig call, but found {func:?}. All ACIR methods should be inlined"
-                            ),
+                            RuntimeType::Acir(inline_type) => {
+                                assert!(!matches!(inline_type, InlineType::Inline), "ICE: Got an ACIR function named {} that should have already been inlined", func.name());
+
+                                let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
+                                // TODO(https://github.com/noir-lang/noir/issues/4608): handle complex return types from ACIR functions
+                                let output_count =
+                                    result_ids.iter().fold(0usize, |sum, result_id| {
+                                        sum + dfg.try_get_array_length(*result_id).unwrap_or(1)
+                                    });
+
+                                let acir_program_id = ssa
+                                    .id_to_index
+                                    .get(id)
+                                    .expect("ICE: should have an associated final index");
+                                let output_vars = self.acir_context.call_acir_function(
+                                    *acir_program_id,
+                                    inputs,
+                                    output_count,
+                                )?;
+                                let output_values =
+                                    self.convert_vars_to_values(output_vars, dfg, result_ids);
+
+                                self.handle_ssa_call_outputs(result_ids, output_values, dfg)?;
+                            }
                             RuntimeType::Brillig => {
-                                // Check that we are not attempting to return a slice from 
+                                // Check that we are not attempting to return a slice from
                                 // an unconstrained runtime to a constrained runtime
                                 for result_id in result_ids {
                                     if dfg.type_of_value(*result_id).contains_slice_element() {
-                                        return Err(RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack: self.acir_context.get_call_stack() })
+                                        return Err(
+                                            RuntimeError::UnconstrainedSliceReturnToConstrained {
+                                                call_stack: self.acir_context.get_call_stack(),
+                                            },
+                                        );
                                     }
                                 }
 
@@ -553,22 +609,23 @@ impl Context {
 
                                 let code = self.gen_brillig_for(func, brillig)?;
 
-                                let outputs: Vec<AcirType> = vecmap(result_ids, |result_id| dfg.type_of_value(*result_id).into());
+                                let outputs: Vec<AcirType> = vecmap(result_ids, |result_id| {
+                                    dfg.type_of_value(*result_id).into()
+                                });
 
-                                let output_values = self.acir_context.brillig(self.current_side_effects_enabled_var, code, inputs, outputs, true, false)?;
+                                let output_values = self.acir_context.brillig(
+                                    self.current_side_effects_enabled_var,
+                                    code,
+                                    inputs,
+                                    outputs,
+                                    true,
+                                    false,
+                                )?;
 
                                 // Compiler sanity check
                                 assert_eq!(result_ids.len(), output_values.len(), "ICE: The number of Brillig output values should match the result ids in SSA");
 
-                                for result in result_ids.iter().zip(output_values) {
-                                    if let AcirValue::Array(_) = &result.1 {
-                                        let array_id = dfg.resolve(*result.0);
-                                        let block_id = self.block_id(&array_id);
-                                        let array_typ = dfg.type_of_value(array_id);
-                                        self.initialize_array(block_id, array_typ.flattened_size(), Some(result.1.clone()))?;
-                                    }
-                                    self.ssa_values.insert(*result.0, result.1);
-                                }
+                                self.handle_ssa_call_outputs(result_ids, output_values, dfg)?;
                             }
                         }
                     }
@@ -587,30 +644,7 @@ impl Context {
                         // Issue #1438 causes this check to fail with intrinsics that return 0
                         // results but the ssa form instead creates 1 unit result value.
                         // assert_eq!(result_ids.len(), outputs.len());
-
-                        for (result, output) in result_ids.iter().zip(outputs) {
-                            match &output {
-                                // We need to make sure we initialize arrays returned from intrinsic calls
-                                // or else they will fail if accessed with a dynamic index
-                                AcirValue::Array(_) => {
-                                    let block_id = self.block_id(result);
-                                    let array_typ = dfg.type_of_value(*result);
-                                    let len = if matches!(array_typ, Type::Array(_, _)) {
-                                        array_typ.flattened_size()
-                                    } else {
-                                        Self::flattened_value_size(&output)
-                                    };
-                                    self.initialize_array(block_id, len, Some(output.clone()))?;
-                                }
-                                AcirValue::DynamicArray(_) => {
-                                    // Do nothing as a dynamic array returned from a slice intrinsic should already be initialized
-                                }
-                                AcirValue::Var(_, _) => {
-                                    // Do nothing
-                                }
-                            }
-                            self.ssa_values.insert(*result, output);
-                        }
+                        self.handle_ssa_call_outputs(result_ids, outputs, dfg)?;
                     }
                     Value::ForeignFunction(_) => {
                         return Err(RuntimeError::UnconstrainedOracleReturnToConstrained {
@@ -625,6 +659,32 @@ impl Context {
         Ok(warnings)
     }
 
+    fn handle_ssa_call_outputs(
+        &mut self,
+        result_ids: &[ValueId],
+        output_values: Vec<AcirValue>,
+        dfg: &DataFlowGraph,
+    ) -> Result<(), RuntimeError> {
+        for (result_id, output) in result_ids.iter().zip(output_values) {
+            if let AcirValue::Array(_) = &output {
+                let array_id = dfg.resolve(*result_id);
+                let block_id = self.block_id(&array_id);
+                let array_typ = dfg.type_of_value(array_id);
+                let len = if matches!(array_typ, Type::Array(_, _)) {
+                    array_typ.flattened_size()
+                } else {
+                    Self::flattened_value_size(&output)
+                };
+                self.initialize_array(block_id, len, Some(output.clone()))?;
+            }
+            // Do nothing for AcirValue::DynamicArray and AcirValue::Var
+            // A dynamic array returned from a function call should already be initialized
+            // and a single variable does not require any extra initialization.
+            self.ssa_values.insert(*result_id, output);
+        }
+        Ok(())
+    }
+
     fn gen_brillig_for(
         &self,
         func: &Function,
@@ -1373,6 +1433,7 @@ impl Context {
             TerminatorInstruction::Return { return_values, call_stack } => {
                 (return_values, call_stack)
             }
+            // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions
             _ => unreachable!("ICE: Program must have a singular return"),
         };
 
@@ -2327,3 +2388,338 @@ fn can_omit_element_sizes_array(array_typ: &Type) -> bool {
 
     !types.iter().any(|typ| typ.contains_an_array())
 }
+
+#[cfg(test)]
+mod test {
+    use acvm::{
+        acir::{circuit::Opcode, native_types::Witness},
+        FieldElement,
+    };
+
+    use crate::{
+        brillig::Brillig,
+        ssa::{
+            function_builder::FunctionBuilder,
+            ir::{
+                function::{FunctionId, InlineType, RuntimeType},
+                instruction::BinaryOp,
+                map::Id,
+                types::Type,
+            },
+        },
+    };
+    use fxhash::FxHashMap as HashMap;
+
+    fn build_basic_foo_with_return(builder: &mut FunctionBuilder, foo_id: FunctionId) {
+        // acir(fold) fn foo f1 {
+        // b0(v0: Field, v1: Field):
+        //     v2 = eq v0, v1
+        //     constrain v2 == u1 0
+        //     return v0
+        // }
+        builder.new_function("foo".into(), foo_id, InlineType::Fold);
+        let foo_v0 = builder.add_parameter(Type::field());
+        let foo_v1 = builder.add_parameter(Type::field());
+
+        let foo_equality_check = builder.insert_binary(foo_v0, BinaryOp::Eq, foo_v1);
+        let zero = builder.field_constant(0u128);
+        builder.insert_constrain(foo_equality_check, zero, None);
+        builder.terminate_with_return(vec![foo_v0]);
+    }
+
+    #[test]
+    fn basic_call_with_outputs_assert() {
+        // acir(inline) fn main f0 {
+        //     b0(v0: Field, v1: Field):
+        //       v2 = call f1(v0, v1)
+        //       v3 = call f1(v0, v1)
+        //       constrain v2 == v3
+        //       return
+        //     }
+        // acir(fold) fn foo f1 {
+        //     b0(v0: Field, v1: Field):
+        //       v2 = eq v0, v1
+        //       constrain v2 == u1 0
+        //       return v0
+        //     }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::field());
+        let main_v1 = builder.add_parameter(Type::field());
+
+        let foo_id = Id::test_new(1);
+        let foo = builder.import_function(foo_id);
+        let main_call1_results =
+            builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        let main_call2_results =
+            builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
+        builder.terminate_with_return(vec![]);
+
+        build_basic_foo_with_return(&mut builder, foo_id);
+
+        let ssa = builder.finish();
+
+        let acir_functions = ssa
+            .into_acir(
+                &Brillig::default(),
+                noirc_frontend::Distinctness::Distinct,
+                &HashMap::default(),
+            )
+            .expect("Should compile manually written SSA into ACIR");
+        // Expected result:
+        // main f0
+        // GeneratedAcir {
+        //     ...
+        //     opcodes: [
+        //         CALL func 1: inputs: [Witness(0), Witness(1)], outputs: [Witness(2)],
+        //         CALL func 1: inputs: [Witness(0), Witness(1)], outputs: [Witness(3)],
+        //         EXPR [ (1, _2) (-1, _3) 0 ],
+        //     ],
+        //     return_witnesses: [],
+        //     input_witnesses: [
+        //         Witness(
+        //             0,
+        //         ),
+        //         Witness(
+        //             1,
+        //         ),
+        //     ],
+        //     ...
+        // }
+        // foo f1
+        // GeneratedAcir {
+        //     ...
+        //     opcodes: [
+        //         Same as opcodes as the expected result of `basic_call_codegen`
+        //     ],
+        //     return_witnesses: [
+        //         Witness(
+        //             0,
+        //         ),
+        //     ],
+        //     input_witnesses: [
+        //         Witness(
+        //             0,
+        //         ),
+        //         Witness(
+        //             1,
+        //         ),
+        //     ],
+        //     ...
+        // },
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        assert_eq!(main_opcodes.len(), 3, "Should have two calls to `foo`");
+
+        check_call_opcode(&main_opcodes[0], 1, vec![Witness(0), Witness(1)], vec![Witness(2)]);
+        check_call_opcode(&main_opcodes[1], 1, vec![Witness(0), Witness(1)], vec![Witness(3)]);
+
+        match &main_opcodes[2] {
+            Opcode::AssertZero(expr) => {
+                assert_eq!(expr.linear_combinations[0].0, FieldElement::from(1u128));
+                assert_eq!(expr.linear_combinations[0].1, Witness(2));
+
+                assert_eq!(expr.linear_combinations[1].0, FieldElement::from(-1i128));
+                assert_eq!(expr.linear_combinations[1].1, Witness(3));
+                assert_eq!(expr.q_c, FieldElement::from(0u128));
+            }
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn call_output_as_next_call_input() {
+        // acir(inline) fn main f0 {
+        //     b0(v0: Field, v1: Field):
+        //       v3 = call f1(v0, v1)
+        //       v4 = call f1(v3, v1)
+        //       constrain v3 == v4
+        //       return
+        //     }
+        // acir(fold) fn foo f1 {
+        //     b0(v0: Field, v1: Field):
+        //       v2 = eq v0, v1
+        //       constrain v2 == u1 0
+        //       return v0
+        //     }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::field());
+        let main_v1 = builder.add_parameter(Type::field());
+
+        let foo_id = Id::test_new(1);
+        let foo = builder.import_function(foo_id);
+        let main_call1_results =
+            builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        let main_call2_results = builder
+            .insert_call(foo, vec![main_call1_results[0], main_v1], vec![Type::field()])
+            .to_vec();
+        builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
+        builder.terminate_with_return(vec![]);
+
+        build_basic_foo_with_return(&mut builder, foo_id);
+
+        let ssa = builder.finish();
+
+        let acir_functions = ssa
+            .into_acir(
+                &Brillig::default(),
+                noirc_frontend::Distinctness::Distinct,
+                &HashMap::default(),
+            )
+            .expect("Should compile manually written SSA into ACIR");
+        // The expected result should look very similar to the abvoe test expect that the input witnesses of the `Call`
+        // opcodes will be different. The changes can discerned from the checks below.
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        assert_eq!(main_opcodes.len(), 3, "Should have two calls to `foo` and an assert");
+
+        check_call_opcode(&main_opcodes[0], 1, vec![Witness(0), Witness(1)], vec![Witness(2)]);
+        // The output of the first call should be the input of the second call
+        check_call_opcode(&main_opcodes[1], 1, vec![Witness(2), Witness(1)], vec![Witness(3)]);
+    }
+
+    #[test]
+    fn basic_nested_call() {
+        // SSA for the following Noir program:
+        // fn main(x: Field, y: pub Field) {
+        //     let z = func_with_nested_foo_call(x, y);
+        //     let z2 = func_with_nested_foo_call(x, y);
+        //     assert(z == z2);
+        // }
+        // #[fold]
+        // fn func_with_nested_foo_call(x: Field, y: Field) -> Field {
+        //     nested_call(x + 2, y)
+        // }
+        // #[fold]
+        // fn foo(x: Field, y: Field) -> Field {
+        //     assert(x != y);
+        //     x
+        // }
+        //
+        // SSA:
+        // acir(inline) fn main f0 {
+        //     b0(v0: Field, v1: Field):
+        //       v3 = call f1(v0, v1)
+        //       v4 = call f1(v0, v1)
+        //       constrain v3 == v4
+        //       return
+        //     }
+        // acir(fold) fn func_with_nested_foo_call f1 {
+        //     b0(v0: Field, v1: Field):
+        //       v3 = add v0, Field 2
+        //       v5 = call f2(v3, v1)
+        //       return v5
+        //   }
+        // acir(fold) fn foo f2 {
+        //     b0(v0: Field, v1: Field):
+        //       v2 = eq v0, v1
+        //       constrain v2 == Field 0
+        //       return v0
+        //   }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::field());
+        let main_v1 = builder.add_parameter(Type::field());
+
+        let func_with_nested_foo_call_id = Id::test_new(1);
+        let func_with_nested_foo_call = builder.import_function(func_with_nested_foo_call_id);
+        let main_call1_results = builder
+            .insert_call(func_with_nested_foo_call, vec![main_v0, main_v1], vec![Type::field()])
+            .to_vec();
+        let main_call2_results = builder
+            .insert_call(func_with_nested_foo_call, vec![main_v0, main_v1], vec![Type::field()])
+            .to_vec();
+        builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
+        builder.terminate_with_return(vec![]);
+
+        builder.new_function(
+            "func_with_nested_foo_call".into(),
+            func_with_nested_foo_call_id,
+            InlineType::Fold,
+        );
+        let func_with_nested_call_v0 = builder.add_parameter(Type::field());
+        let func_with_nested_call_v1 = builder.add_parameter(Type::field());
+
+        let two = builder.field_constant(2u128);
+        let v0_plus_two = builder.insert_binary(func_with_nested_call_v0, BinaryOp::Add, two);
+
+        let foo_id = Id::test_new(2);
+        let foo_call = builder.import_function(foo_id);
+        let foo_call = builder
+            .insert_call(foo_call, vec![v0_plus_two, func_with_nested_call_v1], vec![Type::field()])
+            .to_vec();
+        builder.terminate_with_return(vec![foo_call[0]]);
+
+        build_basic_foo_with_return(&mut builder, foo_id);
+
+        let ssa = builder.finish();
+
+        let acir_functions = ssa
+            .into_acir(
+                &Brillig::default(),
+                noirc_frontend::Distinctness::Distinct,
+                &HashMap::default(),
+            )
+            .expect("Should compile manually written SSA into ACIR");
+
+        assert_eq!(acir_functions.len(), 3, "Should have three ACIR functions");
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        assert_eq!(main_opcodes.len(), 3, "Should have two calls to `foo` and an assert");
+
+        // Both of these should call func_with_nested_foo_call f1
+        check_call_opcode(&main_opcodes[0], 1, vec![Witness(0), Witness(1)], vec![Witness(2)]);
+        // The output of the first call should be the input of the second call
+        check_call_opcode(&main_opcodes[1], 1, vec![Witness(0), Witness(1)], vec![Witness(3)]);
+
+        let func_with_nested_call_acir = &acir_functions[1];
+        let func_with_nested_call_opcodes = func_with_nested_call_acir.opcodes();
+        assert_eq!(
+            func_with_nested_call_opcodes.len(),
+            2,
+            "Should have an expression and a call to a nested `foo`"
+        );
+        // Should call foo f2
+        check_call_opcode(
+            &func_with_nested_call_opcodes[1],
+            2,
+            vec![Witness(2), Witness(1)],
+            vec![Witness(3)],
+        );
+    }
+
+    fn check_call_opcode(
+        opcode: &Opcode,
+        expected_id: u32,
+        expected_inputs: Vec<Witness>,
+        expected_outputs: Vec<Witness>,
+    ) {
+        match opcode {
+            Opcode::Call { id, inputs, outputs } => {
+                assert_eq!(
+                    *id, expected_id,
+                    "Main was expected to call {expected_id} but got {}",
+                    *id
+                );
+                for (expected_input, input) in expected_inputs.iter().zip(inputs) {
+                    assert_eq!(
+                        expected_input, input,
+                        "Expected witness {expected_input:?} but got {input:?}"
+                    );
+                }
+                for (expected_output, output) in expected_outputs.iter().zip(outputs) {
+                    assert_eq!(
+                        expected_output, output,
+                        "Expected witness {expected_output:?} but got {output:?}"
+                    );
+                }
+            }
+            _ => panic!("Expected only Call opcode"),
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 0726b557616..e0e60b737ad 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -17,7 +17,7 @@ use super::{
     ir::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
-        function::RuntimeType,
+        function::{InlineType, RuntimeType},
         instruction::{ConstrainError, InstructionId, Intrinsic},
     },
     ssa_gen::Ssa,
@@ -42,13 +42,8 @@ impl FunctionBuilder {
     ///
     /// This creates the new function internally so there is no need to call .new_function()
     /// right after constructing a new FunctionBuilder.
-    pub(crate) fn new(
-        function_name: String,
-        function_id: FunctionId,
-        runtime: RuntimeType,
-    ) -> Self {
-        let mut new_function = Function::new(function_name, function_id);
-        new_function.set_runtime(runtime);
+    pub(crate) fn new(function_name: String, function_id: FunctionId) -> Self {
+        let new_function = Function::new(function_name, function_id);
 
         Self {
             current_block: new_function.entry_block(),
@@ -58,6 +53,15 @@ impl FunctionBuilder {
         }
     }
 
+    /// Set the runtime of the initial function that is created internally after constructing
+    /// the FunctionBuilder. A function's default runtime type is `RuntimeType::Acir(InlineType::Inline)`.
+    /// This should only be used immediately following construction of a FunctionBuilder
+    /// and will panic if there are any already finished functions.
+    pub(crate) fn set_runtime(&mut self, runtime: RuntimeType) {
+        assert_eq!(self.finished_functions.len(), 0, "Attempted to set runtime on a FunctionBuilder with finished functions. A FunctionBuilder's runtime should only be set on its initial function");
+        self.current_function.set_runtime(runtime);
+    }
+
     /// Finish the current function and create a new function.
     ///
     /// A FunctionBuilder can always only work on one function at a time, so care
@@ -78,8 +82,13 @@ impl FunctionBuilder {
     }
 
     /// Finish the current function and create a new ACIR function.
-    pub(crate) fn new_function(&mut self, name: String, function_id: FunctionId) {
-        self.new_function_with_type(name, function_id, RuntimeType::Acir);
+    pub(crate) fn new_function(
+        &mut self,
+        name: String,
+        function_id: FunctionId,
+        inline_type: InlineType,
+    ) {
+        self.new_function_with_type(name, function_id, RuntimeType::Acir(inline_type));
     }
 
     /// Finish the current function and create a new unconstrained function.
@@ -491,7 +500,7 @@ mod tests {
     use acvm::FieldElement;
 
     use crate::ssa::ir::{
-        function::RuntimeType,
+        function::{InlineType, RuntimeType},
         instruction::{Endian, Intrinsic},
         map::Id,
         types::Type,
@@ -506,7 +515,7 @@ mod tests {
         // let x = 7;
         // let bits = x.to_le_bits(8);
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
         let one = builder.numeric_constant(FieldElement::one(), Type::bool());
         let zero = builder.numeric_constant(FieldElement::zero(), Type::bool());
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dom.rs b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
index c1df0428c64..bd1481a7474 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dom.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
@@ -252,7 +252,7 @@ mod tests {
             basic_block::BasicBlockId,
             dfg::CallStack,
             dom::DominatorTree,
-            function::{Function, RuntimeType},
+            function::{Function, InlineType, RuntimeType},
             instruction::TerminatorInstruction,
             map::Id,
             types::Type,
@@ -286,7 +286,7 @@ mod tests {
         //     return ()
         // }
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
 
         let cond = builder.add_parameter(Type::unsigned(1));
         let block1_id = builder.insert_block();
@@ -395,7 +395,7 @@ mod tests {
         //     jump block1()
         // }
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
         let block1_id = builder.insert_block();
         let block2_id = builder.insert_block();
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs
index 360f5710113..011bee36661 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs
@@ -12,11 +12,39 @@ use super::value::ValueId;
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub(crate) enum RuntimeType {
     // A noir function, to be compiled in ACIR and executed by ACVM
-    Acir,
+    Acir(InlineType),
     // Unconstrained function, to be compiled to brillig and executed by the Brillig VM
     Brillig,
 }
 
+/// Represents how a RuntimeType::Acir function should be inlined.
+/// This type is only relevant for ACIR functions as we do not inline any Brillig functions
+#[derive(Default, Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub(crate) enum InlineType {
+    /// The most basic entry point can expect all its functions to be inlined.
+    /// All function calls are expected to be inlined into a single ACIR.
+    #[default]
+    Inline,
+    /// Functions marked as foldable will not be inlined and compiled separately into ACIR
+    Fold,
+}
+
+impl RuntimeType {
+    /// Returns whether the runtime type represents an entry point.
+    /// We return `false` for InlineType::Inline on default, which is true
+    /// in all cases except for main. `main` should be supported with special
+    /// handling in any places where this function determines logic.
+    pub(crate) fn is_entry_point(&self) -> bool {
+        match self {
+            RuntimeType::Acir(inline_type) => match inline_type {
+                InlineType::Inline => false,
+                InlineType::Fold => true,
+            },
+            RuntimeType::Brillig => true,
+        }
+    }
+}
+
 /// A function holds a list of instructions.
 /// These instructions are further grouped into Basic blocks
 ///
@@ -47,7 +75,7 @@ impl Function {
     pub(crate) fn new(name: String, id: FunctionId) -> Self {
         let mut dfg = DataFlowGraph::default();
         let entry_block = dfg.make_block();
-        Self { name, id, entry_block, dfg, runtime: RuntimeType::Acir }
+        Self { name, id, entry_block, dfg, runtime: RuntimeType::Acir(InlineType::default()) }
     }
 
     /// The name of the function.
@@ -129,12 +157,21 @@ impl Function {
 impl std::fmt::Display for RuntimeType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            RuntimeType::Acir => write!(f, "acir"),
+            RuntimeType::Acir(inline_type) => write!(f, "acir({inline_type})"),
             RuntimeType::Brillig => write!(f, "brillig"),
         }
     }
 }
 
+impl std::fmt::Display for InlineType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InlineType::Inline => write!(f, "inline"),
+            InlineType::Fold => write!(f, "fold"),
+        }
+    }
+}
+
 /// FunctionId is a reference for a function
 ///
 /// This Id is how each function refers to other functions
diff --git a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
index 3cae86829ed..5d743e953a5 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
@@ -74,7 +74,7 @@ mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{Function, RuntimeType},
+            function::{Function, InlineType, RuntimeType},
             map::Id,
             post_order::PostOrder,
             types::Type,
@@ -112,7 +112,7 @@ mod tests {
         // D, F, E, B, A, (C dropped as unreachable)
 
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
         let block_b_id = builder.insert_block();
         let block_c_id = builder.insert_block();
         let block_d_id = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
index b737c51d145..6d556e86cb5 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
@@ -77,7 +77,7 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::RuntimeType,
+            function::{InlineType, RuntimeType},
             instruction::{Binary, BinaryOp, Instruction},
             map::Id,
             types::Type,
@@ -100,7 +100,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::field());
 
         let one = builder.field_constant(1u128);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index 06ae4bf5202..88948331960 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -283,7 +283,7 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::RuntimeType,
+            function::{InlineType, RuntimeType},
             instruction::{Binary, BinaryOp, Instruction, TerminatorInstruction},
             map::Id,
             types::Type,
@@ -305,7 +305,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::field());
 
         let one = builder.field_constant(1u128);
@@ -361,7 +361,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::unsigned(16));
         let v1 = builder.add_parameter(Type::unsigned(16));
 
@@ -415,7 +415,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::unsigned(16));
         let v1 = builder.add_parameter(Type::unsigned(16));
 
@@ -471,7 +471,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::field());
         let one = builder.field_constant(1u128);
         let v1 = builder.insert_binary(v0, BinaryOp::Add, one);
@@ -518,7 +518,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::unsigned(16));
 
         let v1 = builder.insert_cast(v0, Type::unsigned(32));
@@ -562,7 +562,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::bool());
         let v1 = builder.add_parameter(Type::bool());
         let v2 = builder.add_parameter(Type::bool());
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index 1f09a132132..ca6527eb0ec 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -13,7 +13,7 @@ use crate::ssa::{
     function_builder::FunctionBuilder,
     ir::{
         basic_block::BasicBlockId,
-        function::{Function, FunctionId, RuntimeType, Signature},
+        function::{Function, FunctionId, Signature},
         instruction::{BinaryOp, ConstrainError, Instruction},
         types::{NumericType, Type},
         value::{Value, ValueId},
@@ -304,7 +304,7 @@ fn create_apply_function(
 ) -> FunctionId {
     assert!(!function_ids.is_empty());
     ssa.add_fn(|id| {
-        let mut function_builder = FunctionBuilder::new("apply".to_string(), id, RuntimeType::Acir);
+        let mut function_builder = FunctionBuilder::new("apply".to_string(), id);
         let target_id = function_builder.add_parameter(Type::field());
         let params_ids = vecmap(signature.params, |typ| function_builder.add_parameter(typ));
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index 4c7beff0fbe..df89dcb716d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -169,7 +169,7 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::RuntimeType,
+            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Intrinsic},
             map::Id,
             types::Type,
@@ -199,7 +199,7 @@ mod test {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::field());
         let b1 = builder.insert_block();
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index 46f1e7a2765..e731a7952a6 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -167,7 +167,9 @@ impl Ssa {
     /// For more information, see the module-level comment at the top of this file.
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn flatten_cfg(mut self) -> Ssa {
-        flatten_function_cfg(self.main_mut());
+        for function in self.functions.values_mut() {
+            flatten_function_cfg(function);
+        }
         self
     }
 }
@@ -839,7 +841,7 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             dfg::DataFlowGraph,
-            function::{Function, RuntimeType},
+            function::{Function, InlineType, RuntimeType},
             instruction::{BinaryOp, Instruction, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
@@ -860,7 +862,7 @@ mod test {
         //     return v1
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -914,7 +916,7 @@ mod test {
         //     return
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -963,7 +965,7 @@ mod test {
         //     return
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -1024,7 +1026,7 @@ mod test {
         //     return
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -1114,7 +1116,7 @@ mod test {
         //      ↘   ↙
         //       b9
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -1271,7 +1273,7 @@ mod test {
         // before the first store to allocate, which loaded an uninitialized value.
         // In this test we assert the ordering is strictly Allocate then Store then Load.
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -1370,7 +1372,7 @@ mod test {
         //     return
         // }
         let main_id = Id::test_new(1);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         builder.insert_block(); // entry
 
@@ -1423,7 +1425,7 @@ mod test {
         //     jmp b3()
         // }
         let main_id = Id::test_new(1);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         builder.insert_block(); // b0
         let b1 = builder.insert_block();
@@ -1533,7 +1535,7 @@ mod test {
         //     jmp b5()
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
index 59bee00936a..adb6d2871e5 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
@@ -114,7 +114,12 @@ mod test {
 
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{cfg::ControlFlowGraph, function::RuntimeType, map::Id, types::Type},
+        ir::{
+            cfg::ControlFlowGraph,
+            function::{InlineType, RuntimeType},
+            map::Id,
+            types::Type,
+        },
         opt::flatten_cfg::branch_analysis::find_branch_ends,
     };
 
@@ -134,7 +139,7 @@ mod test {
         //      ↘   ↙
         //       b9
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -195,7 +200,7 @@ mod test {
         //        ↘    ↙
         //          b15
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index aff06af9921..7c7698d236d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -11,7 +11,7 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         dfg::{CallStack, InsertInstructionResult},
-        function::{Function, FunctionId, RuntimeType},
+        function::{Function, FunctionId, InlineType, RuntimeType},
         instruction::{Instruction, InstructionId, TerminatorInstruction},
         value::{Value, ValueId},
     },
@@ -94,12 +94,13 @@ struct PerFunctionContext<'function> {
 }
 
 /// The entry point functions are each function we should inline into - and each function that
-/// should be left in the final program. This is usually just `main` but also includes any
-/// brillig functions used.
+/// should be left in the final program.
+/// This is the `main` function, any Acir functions with a [fold inline type][InlineType::Fold],
+/// and any brillig functions used.
 fn get_entry_point_functions(ssa: &Ssa) -> BTreeSet<FunctionId> {
     let functions = ssa.functions.iter();
     let mut entry_points = functions
-        .filter(|(_, function)| function.runtime() == RuntimeType::Brillig)
+        .filter(|(_, function)| function.runtime().is_entry_point())
         .map(|(id, _)| *id)
         .collect::<BTreeSet<_>>();
 
@@ -115,7 +116,8 @@ impl InlineContext {
     /// that could not be inlined calling it.
     fn new(ssa: &Ssa, entry_point: FunctionId) -> InlineContext {
         let source = &ssa.functions[&entry_point];
-        let builder = FunctionBuilder::new(source.name().to_owned(), entry_point, source.runtime());
+        let mut builder = FunctionBuilder::new(source.name().to_owned(), entry_point);
+        builder.set_runtime(source.runtime());
         Self { builder, recursion_level: 0, entry_point, call_stack: CallStack::new() }
     }
 
@@ -350,8 +352,12 @@ impl<'function> PerFunctionContext<'function> {
             match &self.source_function.dfg[*id] {
                 Instruction::Call { func, arguments } => match self.get_function(*func) {
                     Some(function) => match ssa.functions[&function].runtime() {
-                        RuntimeType::Acir => self.inline_function(ssa, *id, function, arguments),
-                        RuntimeType::Brillig => self.push_instruction(*id),
+                        RuntimeType::Acir(InlineType::Inline) => {
+                            self.inline_function(ssa, *id, function, arguments);
+                        }
+                        RuntimeType::Acir(InlineType::Fold) | RuntimeType::Brillig => {
+                            self.push_instruction(*id);
+                        }
                     },
                     None => self.push_instruction(*id),
                 },
@@ -517,7 +523,7 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             basic_block::BasicBlockId,
-            function::RuntimeType,
+            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
@@ -536,14 +542,14 @@ mod test {
         //     return 72
         // }
         let foo_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("foo".into(), foo_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("foo".into(), foo_id);
 
         let bar_id = Id::test_new(1);
         let bar = builder.import_function(bar_id);
         let results = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
         builder.terminate_with_return(results);
 
-        builder.new_function("bar".into(), bar_id);
+        builder.new_function("bar".into(), bar_id, InlineType::default());
         let expected_return = 72u128;
         let seventy_two = builder.field_constant(expected_return);
         builder.terminate_with_return(vec![seventy_two]);
@@ -585,7 +591,7 @@ mod test {
         let id2_id = Id::test_new(3);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let main_v0 = builder.add_parameter(Type::field());
 
         let main_f1 = builder.import_function(square_id);
@@ -598,18 +604,18 @@ mod test {
         builder.terminate_with_return(vec![main_v16]);
 
         // Compiling square f1
-        builder.new_function("square".into(), square_id);
+        builder.new_function("square".into(), square_id, InlineType::default());
         let square_v0 = builder.add_parameter(Type::field());
         let square_v2 = builder.insert_binary(square_v0, BinaryOp::Mul, square_v0);
         builder.terminate_with_return(vec![square_v2]);
 
         // Compiling id1 f2
-        builder.new_function("id1".into(), id1_id);
+        builder.new_function("id1".into(), id1_id, InlineType::default());
         let id1_v0 = builder.add_parameter(Type::Function);
         builder.terminate_with_return(vec![id1_v0]);
 
         // Compiling id2 f3
-        builder.new_function("id2".into(), id2_id);
+        builder.new_function("id2".into(), id2_id, InlineType::default());
         let id2_v0 = builder.add_parameter(Type::Function);
         builder.terminate_with_return(vec![id2_v0]);
 
@@ -641,7 +647,7 @@ mod test {
         //     return v4
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let factorial_id = Id::test_new(1);
         let factorial = builder.import_function(factorial_id);
@@ -650,7 +656,7 @@ mod test {
         let results = builder.insert_call(factorial, vec![five], vec![Type::field()]).to_vec();
         builder.terminate_with_return(results);
 
-        builder.new_function("factorial".into(), factorial_id);
+        builder.new_function("factorial".into(), factorial_id, InlineType::default());
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
 
@@ -741,7 +747,7 @@ mod test {
         //     jmp b3(Field 2)
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let main_cond = builder.add_parameter(Type::bool());
         let inner1_id = Id::test_new(1);
@@ -751,14 +757,14 @@ mod test {
         builder.insert_call(assert_constant, vec![main_v2], vec![]);
         builder.terminate_with_return(vec![]);
 
-        builder.new_function("inner1".into(), inner1_id);
+        builder.new_function("inner1".into(), inner1_id, InlineType::default());
         let inner1_cond = builder.add_parameter(Type::bool());
         let inner2_id = Id::test_new(2);
         let inner2 = builder.import_function(inner2_id);
         let inner1_v2 = builder.insert_call(inner2, vec![inner1_cond], vec![Type::field()])[0];
         builder.terminate_with_return(vec![inner1_v2]);
 
-        builder.new_function("inner2".into(), inner2_id);
+        builder.new_function("inner2".into(), inner2_id, InlineType::default());
         let inner2_cond = builder.add_parameter(Type::bool());
         let then_block = builder.insert_block();
         let else_block = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index 0a49ca4ecca..f1a38585bd6 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -414,7 +414,7 @@ mod tests {
         ir::{
             basic_block::BasicBlockId,
             dfg::DataFlowGraph,
-            function::RuntimeType,
+            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Instruction, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
@@ -433,7 +433,7 @@ mod tests {
         // }
 
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
         let v0 = builder.insert_allocate(Type::Array(Rc::new(vec![Type::field()]), 2));
         let one = builder.field_constant(FieldElement::one());
         let two = builder.field_constant(FieldElement::one());
@@ -474,7 +474,7 @@ mod tests {
         // }
 
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
         let v0 = builder.insert_allocate(Type::field());
         let one = builder.field_constant(FieldElement::one());
         builder.insert_store(v0, one);
@@ -508,7 +508,7 @@ mod tests {
         // }
 
         let func_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("func".into(), func_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("func".into(), func_id);
         let v0 = builder.insert_allocate(Type::field());
         let const_one = builder.field_constant(FieldElement::one());
         builder.insert_store(v0, const_one);
@@ -567,7 +567,7 @@ mod tests {
         //     return v2, v3, v4
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let v0 = builder.insert_allocate(Type::field());
 
@@ -647,7 +647,7 @@ mod tests {
         //       return
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let v0 = builder.insert_allocate(Type::field());
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/rc.rs b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
index 4766bc3e8d2..7b5196f2004 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/rc.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
@@ -166,8 +166,12 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            basic_block::BasicBlockId, dfg::DataFlowGraph, function::RuntimeType,
-            instruction::Instruction, map::Id, types::Type,
+            basic_block::BasicBlockId,
+            dfg::DataFlowGraph,
+            function::{InlineType, RuntimeType},
+            instruction::Instruction,
+            map::Id,
+            types::Type,
         },
     };
 
@@ -206,7 +210,8 @@ mod test {
         //     return [v0]
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("foo".into(), main_id, RuntimeType::Brillig);
+        let mut builder = FunctionBuilder::new("foo".into(), main_id);
+        builder.set_runtime(RuntimeType::Brillig);
 
         let inner_array_type = Type::Array(Rc::new(vec![Type::field()]), 2);
         let v0 = builder.add_parameter(inner_array_type.clone());
@@ -245,7 +250,7 @@ mod test {
         //     return
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("mutator".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("mutator".into(), main_id);
 
         let array_type = Type::Array(Rc::new(vec![Type::field()]), 2);
         let v0 = builder.add_parameter(array_type.clone());
@@ -294,7 +299,7 @@ mod test {
         //     return
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("mutator2".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("mutator2".into(), main_id);
 
         let array_type = Type::Array(Rc::new(vec![Type::field()]), 2);
         let reference_type = Type::Reference(Rc::new(array_type.clone()));
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index a71a42d5757..1eb1e20d41d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -20,7 +20,9 @@ impl Ssa {
     /// See [`constant_folding`][self] module for more information.
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn remove_bit_shifts(mut self) -> Ssa {
-        remove_bit_shifts(self.main_mut());
+        for function in self.functions.values_mut() {
+            remove_bit_shifts(function);
+        }
         self
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index a31def8fd98..b9675d99c90 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -154,7 +154,7 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::RuntimeType,
+            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, TerminatorInstruction},
             map::Id,
             types::Type,
@@ -172,7 +172,7 @@ mod test {
         //     return v1
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -228,7 +228,7 @@ mod test {
         //     return Field 2
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::bool());
 
         let b1 = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 645adb6b350..92ec1e8f1bb 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -48,7 +48,7 @@ impl Ssa {
 
             // This check is always true with the addition of the above guard, but I'm
             // keeping it in case the guard on brillig functions is ever removed.
-            let abort_on_error = function.runtime() == RuntimeType::Acir;
+            let abort_on_error = matches!(function.runtime(), RuntimeType::Acir(_));
             find_all_loops(function).unroll_each_loop(function, abort_on_error)?;
         }
         Ok(self)
@@ -464,7 +464,12 @@ impl<'f> LoopIteration<'f> {
 mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{function::RuntimeType, instruction::BinaryOp, map::Id, types::Type},
+        ir::{
+            function::{InlineType, RuntimeType},
+            instruction::BinaryOp,
+            map::Id,
+            types::Type,
+        },
     };
 
     #[test]
@@ -503,7 +508,7 @@ mod tests {
         let main_id = Id::test_new(0);
 
         // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -605,7 +610,7 @@ mod tests {
         //     return Field 0
         // }
         let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id, RuntimeType::Acir);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index a9a707ca8ed..569e543ce40 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -12,8 +12,8 @@ use crate::errors::RuntimeError;
 use crate::ssa::function_builder::FunctionBuilder;
 use crate::ssa::ir::basic_block::BasicBlockId;
 use crate::ssa::ir::dfg::DataFlowGraph;
-use crate::ssa::ir::function::FunctionId as IrFunctionId;
 use crate::ssa::ir::function::{Function, RuntimeType};
+use crate::ssa::ir::function::{FunctionId as IrFunctionId, InlineType};
 use crate::ssa::ir::instruction::BinaryOp;
 use crate::ssa::ir::instruction::Instruction;
 use crate::ssa::ir::map::AtomicCounter;
@@ -108,7 +108,8 @@ impl<'a> FunctionContext<'a> {
             .expect("No function in queue for the FunctionContext to compile")
             .1;
 
-        let builder = FunctionBuilder::new(function_name, function_id, runtime);
+        let mut builder = FunctionBuilder::new(function_name, function_id);
+        builder.set_runtime(runtime);
         let definitions = HashMap::default();
         let mut this = Self { definitions, builder, shared_context, loops: Vec::new() };
         this.add_parameters_to_scope(parameters);
@@ -125,7 +126,8 @@ impl<'a> FunctionContext<'a> {
         if func.unconstrained {
             self.builder.new_brillig_function(func.name.clone(), id);
         } else {
-            self.builder.new_function(func.name.clone(), id);
+            let inline_type = if func.should_fold { InlineType::Fold } else { InlineType::Inline };
+            self.builder.new_function(func.name.clone(), id, inline_type);
         }
         self.add_parameters_to_scope(&func.parameters);
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index a39df14d60a..3fe52f7f0e5 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -14,7 +14,10 @@ use noirc_frontend::{
 
 use crate::{
     errors::{InternalError, RuntimeError},
-    ssa::{function_builder::data_bus::DataBusBuilder, ir::instruction::Intrinsic},
+    ssa::{
+        function_builder::data_bus::DataBusBuilder,
+        ir::{function::InlineType, instruction::Intrinsic},
+    },
 };
 
 use self::{
@@ -52,14 +55,15 @@ pub(crate) fn generate_ssa(
 
     // Queue the main function for compilation
     context.get_or_queue_function(main_id);
-
     let mut function_context = FunctionContext::new(
         main.name.clone(),
         &main.parameters,
         if force_brillig_runtime || main.unconstrained {
             RuntimeType::Brillig
         } else {
-            RuntimeType::Acir
+            let main_inline_type =
+                if main.should_fold { InlineType::Fold } else { InlineType::Inline };
+            RuntimeType::Acir(main_inline_type)
         },
         &context,
     );
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
index 509f778f3b0..9995c031145 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
@@ -12,6 +12,7 @@ pub(crate) struct Ssa {
     pub(crate) functions: BTreeMap<FunctionId, Function>,
     pub(crate) main_id: FunctionId,
     pub(crate) next_id: AtomicCounter<Function>,
+    pub(crate) id_to_index: BTreeMap<FunctionId, u32>,
 }
 
 impl Ssa {
@@ -26,7 +27,9 @@ impl Ssa {
             (f.id(), f)
         });
 
-        Self { functions, main_id, next_id: AtomicCounter::starting_after(max_id) }
+        let id_to_index = btree_map(functions.iter().enumerate(), |(i, (id, _))| (*id, i as u32));
+
+        Self { functions, main_id, next_id: AtomicCounter::starting_after(max_id), id_to_index }
     }
 
     /// Returns the entry-point function of the program
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index 3e8b78c1312..10d962a23f7 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -108,6 +108,7 @@ impl From<FunctionDefinition> for NoirFunction {
             Some(FunctionAttribute::Test { .. }) => FunctionKind::Normal,
             Some(FunctionAttribute::Oracle(_)) => FunctionKind::Oracle,
             Some(FunctionAttribute::Recursive) => FunctionKind::Recursive,
+            Some(FunctionAttribute::Fold) => FunctionKind::Normal,
             None => FunctionKind::Normal,
         };
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index a6511a6b0fb..ec149dee96e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -942,7 +942,7 @@ impl<'a> Resolver<'a> {
             });
         }
         let is_low_level_function =
-            func.attributes().function.as_ref().map_or(false, |func| func.is_low_level());
+            attributes.function.as_ref().map_or(false, |func| func.is_low_level());
         if !self.path_resolver.module_id().krate.is_stdlib() && is_low_level_function {
             let error =
                 ResolverError::LowLevelFunctionOutsideOfStdlib { ident: func.name_ident().clone() };
@@ -991,6 +991,8 @@ impl<'a> Resolver<'a> {
             .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
             .collect();
 
+        let should_fold = attributes.is_foldable();
+
         FuncMeta {
             name: name_ident,
             kind: func.kind,
@@ -1005,6 +1007,7 @@ impl<'a> Resolver<'a> {
             has_body: !func.def.body.is_empty(),
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point: self.is_entry_point_function(func),
+            should_fold,
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index fe9cc9ea2d6..6c28aabe0fb 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -312,7 +312,7 @@ impl From<TypeCheckError> for Diagnostic {
             }
             TypeCheckError::InvalidTypeForEntryPoint { span } => Diagnostic::simple_error(
                 "Only sized types may be used in the entry point to a program".to_string(),
-                "Slices, references, or any type containing them may not be used in main or a contract function".to_string(), span),
+                "Slices, references, or any type containing them may not be used in main, contract functions, or foldable functions".to_string(), span),
             TypeCheckError::MismatchTraitImplNumParameters {
                 expected_num_parameters,
                 actual_num_parameters,
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 5bda4b9345e..c5a04c33883 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -173,7 +173,7 @@ fn check_if_type_is_valid_for_program_input(
     errors: &mut Vec<TypeCheckError>,
 ) {
     let meta = type_checker.interner.function_meta(&func_id);
-    if meta.is_entry_point && !param.1.is_valid_for_program_input() {
+    if (meta.is_entry_point || meta.should_fold) && !param.1.is_valid_for_program_input() {
         let span = param.0.span();
         errors.push(TypeCheckError::InvalidTypeForEntryPoint { span });
     }
@@ -539,6 +539,7 @@ mod test {
             trait_constraints: Vec::new(),
             direct_generics: Vec::new(),
             is_entry_point: true,
+            should_fold: false,
         };
         interner.push_fn_meta(func_meta, func_id);
 
@@ -597,12 +598,7 @@ mod test {
 
         "#;
 
-        let expected_num_errors = 0;
-        type_check_src_code_errors_expected(
-            src,
-            expected_num_errors,
-            vec![String::from("main"), String::from("foo")],
-        );
+        type_check_src_code(src, vec![String::from("main"), String::from("foo")]);
     }
     #[test]
     fn basic_closure() {
@@ -627,6 +623,19 @@ mod test {
 
         type_check_src_code(src, vec![String::from("main")]);
     }
+
+    #[test]
+    fn fold_entry_point() {
+        let src = r#"
+            #[fold]
+            fn fold(x: &mut Field) -> Field {
+                *x
+            }
+        "#;
+
+        type_check_src_code_errors_expected(src, vec![String::from("fold")], 1);
+    }
+
     // This is the same Stub that is in the resolver, maybe we can pull this out into a test module and re-use?
     struct TestPathResolver(HashMap<String, ModuleDefId>);
 
@@ -660,15 +669,15 @@ mod test {
     }
 
     fn type_check_src_code(src: &str, func_namespace: Vec<String>) {
-        type_check_src_code_errors_expected(src, 0, func_namespace);
+        type_check_src_code_errors_expected(src, func_namespace, 0);
     }
 
     // This function assumes that there is only one function and this is the
     // func id that is returned
     fn type_check_src_code_errors_expected(
         src: &str,
-        expected_number_errors: usize,
         func_namespace: Vec<String>,
+        expected_num_type_check_errs: usize,
     ) {
         let (program, errors) = parse_program(src);
         let mut interner = NodeInterner::default();
@@ -676,9 +685,8 @@ mod test {
 
         assert_eq!(
             errors.len(),
-            expected_number_errors,
-            "expected {} errors, but got {}, errors: {:?}",
-            expected_number_errors,
+            0,
+            "expected 0 parser errors, but got {}, errors: {:?}",
             errors.len(),
             errors
         );
@@ -724,6 +732,13 @@ mod test {
 
         // Type check section
         let errors = super::type_check_func(&mut interner, func_ids.first().cloned().unwrap());
-        assert_eq!(errors, vec![]);
+        assert_eq!(
+            errors.len(),
+            expected_num_type_check_errs,
+            "expected {} type check errors, but got {}, errors: {:?}",
+            expected_num_type_check_errs,
+            errors.len(),
+            errors
+        );
     }
 }
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 56543e8185c..a3bbc9445a8 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -124,6 +124,10 @@ pub struct FuncMeta {
     /// True if this function is an entry point to the program.
     /// For non-contracts, this means the function is `main`.
     pub is_entry_point: bool,
+
+    /// True if this function is marked with an attribute
+    /// that indicates it should not be inlined, such as for folding.
+    pub should_fold: bool,
 }
 
 impl FuncMeta {
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index d0892f5ae38..c4b6bb288dc 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -726,6 +726,16 @@ mod tests {
         );
     }
 
+    #[test]
+    fn fold_attribute() {
+        let input = r#"#[fold]"#;
+
+        let mut lexer = Lexer::new(input);
+        let token = lexer.next_token().unwrap();
+
+        assert_eq!(token.token(), &Token::Attribute(Attribute::Function(FunctionAttribute::Fold)));
+    }
+
     #[test]
     fn contract_library_method_attribute() {
         let input = r#"#[contract_library_method]"#;
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 4432a3f9e07..f8378cdd84b 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -427,6 +427,10 @@ impl Attributes {
         }
         None
     }
+
+    pub fn is_foldable(&self) -> bool {
+        self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_foldable())
+    }
 }
 
 /// An Attribute can be either a Primary Attribute or a Secondary Attribute
@@ -486,6 +490,7 @@ impl Attribute {
             }
             ["test"] => Attribute::Function(FunctionAttribute::Test(TestScope::None)),
             ["recursive"] => Attribute::Function(FunctionAttribute::Recursive),
+            ["fold"] => Attribute::Function(FunctionAttribute::Fold),
             ["test", name] => {
                 validate(name)?;
                 let malformed_scope =
@@ -537,6 +542,7 @@ pub enum FunctionAttribute {
     Oracle(String),
     Test(TestScope),
     Recursive,
+    Fold,
 }
 
 impl FunctionAttribute {
@@ -565,6 +571,10 @@ impl FunctionAttribute {
     pub fn is_low_level(&self) -> bool {
         matches!(self, FunctionAttribute::Foreign(_) | FunctionAttribute::Builtin(_))
     }
+
+    pub fn is_foldable(&self) -> bool {
+        matches!(self, FunctionAttribute::Fold)
+    }
 }
 
 impl fmt::Display for FunctionAttribute {
@@ -575,6 +585,7 @@ impl fmt::Display for FunctionAttribute {
             FunctionAttribute::Builtin(ref k) => write!(f, "#[builtin({k})]"),
             FunctionAttribute::Oracle(ref k) => write!(f, "#[oracle({k})]"),
             FunctionAttribute::Recursive => write!(f, "#[recursive]"),
+            FunctionAttribute::Fold => write!(f, "#[fold]"),
         }
     }
 }
@@ -619,6 +630,7 @@ impl AsRef<str> for FunctionAttribute {
             FunctionAttribute::Oracle(string) => string,
             FunctionAttribute::Test { .. } => "",
             FunctionAttribute::Recursive => "",
+            FunctionAttribute::Fold => "",
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 4f633cbb350..7d20c2bcfee 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -211,6 +211,8 @@ pub struct Function {
 
     pub return_type: Type,
     pub unconstrained: bool,
+    pub should_fold: bool,
+    pub func_sig: FunctionSignature,
 }
 
 /// Compared to hir_def::types::Type, this monomorphized Type has:
@@ -245,6 +247,7 @@ impl Type {
 #[derive(Debug, Clone, Hash)]
 pub struct Program {
     pub functions: Vec<Function>,
+    pub function_signatures: Vec<FunctionSignature>,
     pub main_function_signature: FunctionSignature,
     /// Indicates whether witness indices are allowed to reoccur in the ABI of the resulting ACIR.
     ///
@@ -264,6 +267,7 @@ impl Program {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         functions: Vec<Function>,
+        function_signatures: Vec<FunctionSignature>,
         main_function_signature: FunctionSignature,
         return_distinctness: Distinctness,
         return_location: Option<Location>,
@@ -275,6 +279,7 @@ impl Program {
     ) -> Program {
         Program {
             functions,
+            function_signatures,
             main_function_signature,
             return_distinctness,
             return_location,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index e0d86592d9f..6aa0abce152 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -129,6 +129,18 @@ pub fn monomorphize_debug(
         undo_instantiation_bindings(bindings);
     }
 
+    let func_sigs = monomorphizer
+        .finished_functions
+        .iter()
+        .flat_map(|(_, f)| {
+            if f.should_fold || f.id == Program::main_id() {
+                Some(f.func_sig.clone())
+            } else {
+                None
+            }
+        })
+        .collect();
+
     let functions = vecmap(monomorphizer.finished_functions, |(_, f)| f);
     let FuncMeta { return_distinctness, return_visibility, kind, .. } =
         monomorphizer.interner.function_meta(&main);
@@ -137,6 +149,7 @@ pub fn monomorphize_debug(
         monomorphizer.debug_type_tracker.extract_vars_and_types();
     let program = Program::new(
         functions,
+        func_sigs,
         function_sig,
         *return_distinctness,
         monomorphizer.return_location,
@@ -271,6 +284,8 @@ impl<'interner> Monomorphizer<'interner> {
         }
 
         let meta = self.interner.function_meta(&f).clone();
+        let func_sig = meta.function_signature();
+
         let modifiers = self.interner.function_modifiers(&f);
         let name = self.interner.function_name(&f).to_owned();
 
@@ -284,9 +299,20 @@ impl<'interner> Monomorphizer<'interner> {
         let return_type = Self::convert_type(return_type, meta.location)?;
         let unconstrained = modifiers.is_unconstrained;
 
+        let should_fold = meta.should_fold;
+
         let parameters = self.parameters(&meta.parameters)?;
         let body = self.expr(body_expr_id)?;
-        let function = ast::Function { id, name, parameters, body, return_type, unconstrained };
+        let function = ast::Function {
+            id,
+            name,
+            parameters,
+            body,
+            return_type,
+            unconstrained,
+            should_fold,
+            func_sig,
+        };
 
         self.push_function(id, function);
         Ok(())
@@ -1351,7 +1377,16 @@ impl<'interner> Monomorphizer<'interner> {
         let name = lambda_name.to_owned();
         let unconstrained = false;
 
-        let function = ast::Function { id, name, parameters, body, return_type, unconstrained };
+        let function = ast::Function {
+            id,
+            name,
+            parameters,
+            body,
+            return_type,
+            unconstrained,
+            should_fold: false,
+            func_sig: FunctionSignature::default(),
+        };
         self.push_function(id, function);
 
         let typ =
@@ -1468,7 +1503,16 @@ impl<'interner> Monomorphizer<'interner> {
         parameters.append(&mut converted_parameters);
 
         let unconstrained = false;
-        let function = ast::Function { id, name, parameters, body, return_type, unconstrained };
+        let function = ast::Function {
+            id,
+            name,
+            parameters,
+            body,
+            return_type,
+            unconstrained,
+            should_fold: false,
+            func_sig: FunctionSignature::default(),
+        };
         self.push_function(id, function);
 
         let lambda_value =
@@ -1586,7 +1630,16 @@ impl<'interner> Monomorphizer<'interner> {
         let name = lambda_name.to_owned();
 
         let unconstrained = false;
-        let function = ast::Function { id, name, parameters, body, return_type, unconstrained };
+        let function = ast::Function {
+            id,
+            name,
+            parameters,
+            body,
+            return_type,
+            unconstrained,
+            should_fold: false,
+            func_sig: FunctionSignature::default(),
+        };
         self.push_function(id, function);
 
         ast::Expression::Ident(ast::Ident {
diff --git a/compiler/wasm/src/noir/dependencies/github-dependency-resolver.ts b/compiler/wasm/src/noir/dependencies/github-dependency-resolver.ts
index 8b08b6f0dd8..39ad0d802fb 100644
--- a/compiler/wasm/src/noir/dependencies/github-dependency-resolver.ts
+++ b/compiler/wasm/src/noir/dependencies/github-dependency-resolver.ts
@@ -12,10 +12,12 @@ import { LogData } from '../../utils';
  */
 export class GithubDependencyResolver implements DependencyResolver {
   #fm: FileManager;
+  #fetch: typeof fetch;
   #log;
 
-  constructor(fm: FileManager) {
+  constructor(fm: FileManager, fetcher: typeof fetch) {
     this.#fm = fm;
+    this.#fetch = fetcher;
     this.#log = (msg: string, _data?: LogData) => {
       console.log(msg);
     };
@@ -56,7 +58,7 @@ export class GithubDependencyResolver implements DependencyResolver {
       return localArchivePath;
     }
 
-    const response = await fetch(url, {
+    const response = await this.#fetch(url, {
       method: 'GET',
     });
 
diff --git a/compiler/wasm/src/noir/noir-wasm-compiler.ts b/compiler/wasm/src/noir/noir-wasm-compiler.ts
index 1ec3af1fd65..1fe3c79eae7 100644
--- a/compiler/wasm/src/noir/noir-wasm-compiler.ts
+++ b/compiler/wasm/src/noir/noir-wasm-compiler.ts
@@ -72,7 +72,8 @@ export class NoirWasmCompiler {
     const dependencyManager = new DependencyManager(
       [
         new LocalDependencyResolver(fileManager),
-        new GithubCodeArchiveDependencyResolver(fileManager),
+        // use node's global fetch
+        new GithubCodeArchiveDependencyResolver(fileManager, fetch),
         // TODO support actual Git repositories
       ],
       noirPackage,
diff --git a/compiler/wasm/test/dependencies/github-dependency-resolver.test.ts b/compiler/wasm/test/dependencies/github-dependency-resolver.test.ts
index e7fae8afe8e..505b2269cd2 100644
--- a/compiler/wasm/test/dependencies/github-dependency-resolver.test.ts
+++ b/compiler/wasm/test/dependencies/github-dependency-resolver.test.ts
@@ -31,7 +31,7 @@ describe('GithubDependencyResolver', () => {
   let fetchStub: SinonStub | undefined;
 
   beforeEach(() => {
-    fetchStub = Sinon.stub(globalThis, 'fetch');
+    fetchStub = Sinon.stub();
     fm = createMemFSFileManager(createFsFromVolume(new Volume()), '/');
 
     libDependency = {
@@ -50,16 +50,12 @@ describe('GithubDependencyResolver', () => {
       },
     });
 
-    resolver = new GithubDependencyResolver(fm);
+    resolver = new GithubDependencyResolver(fm, fetchStub);
 
     // cut off outside access
     fetchStub.onCall(0).throws(new Error());
   });
 
-  afterEach(() => {
-    fetchStub?.restore();
-  });
-
   it("returns null if it can't resolve a dependency", async () => {
     const dep = await resolver.resolveDependency(pkg, {
       path: '/lib-c',
diff --git a/cspell.json b/cspell.json
index e50940fbd10..16de9757fb8 100644
--- a/cspell.json
+++ b/cspell.json
@@ -6,6 +6,7 @@
     "words": [
         "aarch",
         "acir",
+        "acirs",
         "acvm",
         "aeiou",
         "appender",
diff --git a/test_programs/execution_success/fold_basic/Nargo.toml b/test_programs/execution_success/fold_basic/Nargo.toml
new file mode 100644
index 00000000000..575ba1f3ad1
--- /dev/null
+++ b/test_programs/execution_success/fold_basic/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_basic"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.25.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_basic/Prover.toml b/test_programs/execution_success/fold_basic/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/fold_basic/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/fold_basic/src/main.nr b/test_programs/execution_success/fold_basic/src/main.nr
new file mode 100644
index 00000000000..6c17120660b
--- /dev/null
+++ b/test_programs/execution_success/fold_basic/src/main.nr
@@ -0,0 +1,11 @@
+fn main(x: Field, y: pub Field) {
+    let z = foo(x, y);
+    let z2 = foo(x, y);
+    assert(z == z2);
+}
+
+#[fold]
+fn foo(x: Field, y: Field) -> Field {
+    assert(x != y);
+    x
+}
diff --git a/test_programs/execution_success/fold_basic_nested_call/Nargo.toml b/test_programs/execution_success/fold_basic_nested_call/Nargo.toml
new file mode 100644
index 00000000000..1b3c32999ae
--- /dev/null
+++ b/test_programs/execution_success/fold_basic_nested_call/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_basic_nested_call"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.25.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_basic_nested_call/Prover.toml b/test_programs/execution_success/fold_basic_nested_call/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/fold_basic_nested_call/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/fold_basic_nested_call/src/main.nr b/test_programs/execution_success/fold_basic_nested_call/src/main.nr
new file mode 100644
index 00000000000..6d02b734727
--- /dev/null
+++ b/test_programs/execution_success/fold_basic_nested_call/src/main.nr
@@ -0,0 +1,16 @@
+fn main(x: Field, y: pub Field) {
+    let z = func_with_nested_foo_call(x, y);
+    let z2 = func_with_nested_foo_call(x, y);
+    assert(z == z2);
+}
+
+#[fold]
+fn func_with_nested_foo_call(x: Field, y: Field) -> Field {
+    foo(x + 2, y)
+}
+
+#[fold]
+fn foo(x: Field, y: Field) -> Field {
+    assert(x != y);
+    x
+}
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index b76d0eccc29..86e7277451f 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -1,14 +1,14 @@
 use std::io::{self, Write};
 
 use acir::circuit::Program;
-use acir::native_types::WitnessMap;
+use acir::native_types::{WitnessMap, WitnessStack};
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
 use crate::cli::fs::inputs::{read_bytecode_from_file, read_inputs_from_file};
 use crate::cli::fs::witness::save_witness_to_dir;
 use crate::errors::CliError;
-use nargo::ops::{execute_circuit, DefaultForeignCallExecutor};
+use nargo::ops::{execute_program, DefaultForeignCallExecutor};
 
 use super::fs::witness::create_output_witness_string;
 
@@ -39,8 +39,11 @@ pub(crate) struct ExecuteCommand {
 fn run_command(args: ExecuteCommand) -> Result<String, CliError> {
     let bytecode = read_bytecode_from_file(&args.working_directory, &args.bytecode)?;
     let circuit_inputs = read_inputs_from_file(&args.working_directory, &args.input_witness)?;
-    let output_witness = execute_program_from_witness(&circuit_inputs, &bytecode, None)?;
-    let output_witness_string = create_output_witness_string(&output_witness)?;
+    let output_witness = execute_program_from_witness(circuit_inputs, &bytecode, None)?;
+    assert_eq!(output_witness.length(), 1, "ACVM CLI only supports a witness stack of size 1");
+    let output_witness_string = create_output_witness_string(
+        &output_witness.peek().expect("Should have a witness stack item").witness,
+    )?;
     if args.output_witness.is_some() {
         save_witness_to_dir(
             &output_witness_string,
@@ -61,16 +64,16 @@ pub(crate) fn run(args: ExecuteCommand) -> Result<String, CliError> {
 }
 
 pub(crate) fn execute_program_from_witness(
-    inputs_map: &WitnessMap,
+    inputs_map: WitnessMap,
     bytecode: &[u8],
     foreign_call_resolver_url: Option<&str>,
-) -> Result<WitnessMap, CliError> {
+) -> Result<WitnessStack, CliError> {
     let blackbox_solver = Bn254BlackBoxSolver::new();
     let program: Program = Program::deserialize_program(bytecode)
         .map_err(|_| CliError::CircuitDeserializationError())?;
-    execute_circuit(
-        &program.functions[0],
-        inputs_map.clone(),
+    execute_program(
+        &program,
+        inputs_map,
         &blackbox_solver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
     )
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index 105ae337793..3b47a7ced3a 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -56,7 +56,7 @@ impl Backend {
     pub fn prove(
         &self,
         program: &Program,
-        witness_values: WitnessStack,
+        witness_stack: WitnessStack,
     ) -> Result<Vec<u8>, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
@@ -66,7 +66,7 @@ impl Backend {
 
         // Create a temporary file for the witness
         let serialized_witnesses: Vec<u8> =
-            witness_values.try_into().expect("could not serialize witness map");
+            witness_stack.try_into().expect("could not serialize witness map");
         let witness_path = temp_directory.join("witness").with_extension("tr");
         write_to_file(&serialized_witnesses, &witness_path);
 
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 854e284dd43..5a42ef36e7e 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -12,3 +12,5 @@ references
 scalar_mul
 signed_comparison
 to_bytes_integration
+fold_basic
+fold_basic_nested_call
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index f0de8d5d1c8..ba12a20460d 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -381,6 +381,9 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
             ACVMStatus::RequiresForeignCall(_) => {
                 unreachable!("Unexpected pending foreign call resolution");
             }
+            ACVMStatus::RequiresAcirCall(_) => {
+                todo!("Multiple ACIR calls are not supported");
+            }
         }
     }
 
diff --git a/tooling/nargo/src/errors.rs b/tooling/nargo/src/errors.rs
index c743768bee2..ff238d79a46 100644
--- a/tooling/nargo/src/errors.rs
+++ b/tooling/nargo/src/errors.rs
@@ -64,7 +64,9 @@ impl NargoError {
             ExecutionError::SolvingError(error) => match error {
                 OpcodeResolutionError::IndexOutOfBounds { .. }
                 | OpcodeResolutionError::OpcodeNotSolvable(_)
-                | OpcodeResolutionError::UnsatisfiedConstrain { .. } => None,
+                | OpcodeResolutionError::UnsatisfiedConstrain { .. }
+                | OpcodeResolutionError::AcirMainCallAttempted { .. }
+                | OpcodeResolutionError::AcirCallOutputsMismatch { .. } => None,
                 OpcodeResolutionError::BrilligFunctionFailed { message, .. } => Some(message),
                 OpcodeResolutionError::BlackBoxFunctionFailed(_, reason) => Some(reason),
             },
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 370393fea09..6d328d65119 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -1,5 +1,7 @@
+use acvm::acir::circuit::Program;
+use acvm::acir::native_types::WitnessStack;
 use acvm::brillig_vm::brillig::ForeignCallResult;
-use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM};
+use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ACVM};
 use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 
@@ -8,73 +10,145 @@ use crate::NargoError;
 
 use super::foreign_calls::{ForeignCallExecutor, NargoForeignCallResult};
 
-#[tracing::instrument(level = "trace", skip_all)]
-pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
-    circuit: &Circuit,
-    initial_witness: WitnessMap,
-    blackbox_solver: &B,
-    foreign_call_executor: &mut F,
-) -> Result<WitnessMap, NargoError> {
-    let mut acvm = ACVM::new(blackbox_solver, &circuit.opcodes, initial_witness);
-
-    // This message should be resolved by a nargo foreign call only when we have an unsatisfied assertion.
-    let mut assert_message: Option<String> = None;
-    loop {
-        let solver_status = acvm.solve();
-
-        match solver_status {
-            ACVMStatus::Solved => break,
-            ACVMStatus::InProgress => {
-                unreachable!("Execution should not stop while in `InProgress` state.")
-            }
-            ACVMStatus::Failure(error) => {
-                let call_stack = match &error {
-                    OpcodeResolutionError::UnsatisfiedConstrain {
-                        opcode_location: ErrorLocation::Resolved(opcode_location),
-                    } => Some(vec![*opcode_location]),
-                    OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
-                        Some(call_stack.clone())
-                    }
-                    _ => None,
-                };
-
-                return Err(NargoError::ExecutionError(match call_stack {
-                    Some(call_stack) => {
-                        // First check whether we have a runtime assertion message that should be resolved on an ACVM failure
-                        // If we do not have a runtime assertion message, we should check whether the circuit has any hardcoded
-                        // messages associated with a specific `OpcodeLocation`.
-                        // Otherwise return the provided opcode resolution error.
-                        if let Some(assert_message) = assert_message {
-                            ExecutionError::AssertionFailed(assert_message.to_owned(), call_stack)
-                        } else if let Some(assert_message) = circuit.get_assert_message(
-                            *call_stack.last().expect("Call stacks should not be empty"),
-                        ) {
-                            ExecutionError::AssertionFailed(assert_message.to_owned(), call_stack)
-                        } else {
-                            ExecutionError::SolvingError(error)
+struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
+    functions: &'a [Circuit],
+    // This gets built as we run through the program looking at each function call
+    witness_stack: WitnessStack,
+
+    blackbox_solver: &'a B,
+
+    foreign_call_executor: &'a mut F,
+}
+
+impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a, B, F> {
+    fn new(
+        functions: &'a [Circuit],
+        blackbox_solver: &'a B,
+        foreign_call_executor: &'a mut F,
+    ) -> Self {
+        ProgramExecutor {
+            functions,
+            witness_stack: WitnessStack::default(),
+            blackbox_solver,
+            foreign_call_executor,
+        }
+    }
+
+    fn finalize(self) -> WitnessStack {
+        self.witness_stack
+    }
+
+    #[tracing::instrument(level = "trace", skip_all)]
+    fn execute_circuit(
+        &mut self,
+        circuit: &Circuit,
+        initial_witness: WitnessMap,
+    ) -> Result<WitnessMap, NargoError> {
+        let mut acvm = ACVM::new(self.blackbox_solver, &circuit.opcodes, initial_witness);
+
+        // This message should be resolved by a nargo foreign call only when we have an unsatisfied assertion.
+        let mut assert_message: Option<String> = None;
+        loop {
+            let solver_status = acvm.solve();
+
+            match solver_status {
+                ACVMStatus::Solved => break,
+                ACVMStatus::InProgress => {
+                    unreachable!("Execution should not stop while in `InProgress` state.")
+                }
+                ACVMStatus::Failure(error) => {
+                    let call_stack = match &error {
+                        OpcodeResolutionError::UnsatisfiedConstrain {
+                            opcode_location: ErrorLocation::Resolved(opcode_location),
+                        } => Some(vec![*opcode_location]),
+                        OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
+                            Some(call_stack.clone())
                         }
-                    }
-                    None => ExecutionError::SolvingError(error),
-                }));
-            }
-            ACVMStatus::RequiresForeignCall(foreign_call) => {
-                let foreign_call_result = foreign_call_executor.execute(&foreign_call)?;
-                match foreign_call_result {
-                    NargoForeignCallResult::BrilligOutput(foreign_call_result) => {
-                        acvm.resolve_pending_foreign_call(foreign_call_result);
-                    }
-                    NargoForeignCallResult::ResolvedAssertMessage(message) => {
-                        if assert_message.is_some() {
-                            unreachable!("Resolving an assert message should happen only once as the VM should have failed");
+                        _ => None,
+                    };
+
+                    return Err(NargoError::ExecutionError(match call_stack {
+                        Some(call_stack) => {
+                            // First check whether we have a runtime assertion message that should be resolved on an ACVM failure
+                            // If we do not have a runtime assertion message, we should check whether the circuit has any hardcoded
+                            // messages associated with a specific `OpcodeLocation`.
+                            // Otherwise return the provided opcode resolution error.
+                            if let Some(assert_message) = assert_message {
+                                ExecutionError::AssertionFailed(
+                                    assert_message.to_owned(),
+                                    call_stack,
+                                )
+                            } else if let Some(assert_message) = circuit.get_assert_message(
+                                *call_stack.last().expect("Call stacks should not be empty"),
+                            ) {
+                                ExecutionError::AssertionFailed(
+                                    assert_message.to_owned(),
+                                    call_stack,
+                                )
+                            } else {
+                                ExecutionError::SolvingError(error)
+                            }
+                        }
+                        None => ExecutionError::SolvingError(error),
+                    }));
+                }
+                ACVMStatus::RequiresForeignCall(foreign_call) => {
+                    let foreign_call_result = self.foreign_call_executor.execute(&foreign_call)?;
+                    match foreign_call_result {
+                        NargoForeignCallResult::BrilligOutput(foreign_call_result) => {
+                            acvm.resolve_pending_foreign_call(foreign_call_result);
                         }
-                        assert_message = Some(message);
+                        NargoForeignCallResult::ResolvedAssertMessage(message) => {
+                            if assert_message.is_some() {
+                                unreachable!("Resolving an assert message should happen only once as the VM should have failed");
+                            }
+                            assert_message = Some(message);
 
-                        acvm.resolve_pending_foreign_call(ForeignCallResult::default());
+                            acvm.resolve_pending_foreign_call(ForeignCallResult::default());
+                        }
                     }
                 }
+                ACVMStatus::RequiresAcirCall(call_info) => {
+                    let acir_to_call = &self.functions[call_info.id as usize];
+                    let initial_witness = call_info.initial_witness;
+                    let call_solved_witness =
+                        self.execute_circuit(acir_to_call, initial_witness)?;
+                    let mut call_resolved_outputs = Vec::new();
+                    for return_witness_index in acir_to_call.return_values.indices() {
+                        if let Some(return_value) =
+                            call_solved_witness.get_index(return_witness_index)
+                        {
+                            call_resolved_outputs.push(*return_value);
+                        } else {
+                            return Err(ExecutionError::SolvingError(
+                                OpcodeNotSolvable::MissingAssignment(return_witness_index).into(),
+                            )
+                            .into());
+                        }
+                    }
+                    acvm.resolve_pending_acir_call(call_resolved_outputs);
+                    self.witness_stack.push(call_info.id, call_solved_witness);
+                }
             }
         }
+
+        Ok(acvm.finalize())
     }
+}
+
+#[tracing::instrument(level = "trace", skip_all)]
+pub fn execute_program<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
+    program: &Program,
+    initial_witness: WitnessMap,
+    blackbox_solver: &B,
+    foreign_call_executor: &mut F,
+) -> Result<WitnessStack, NargoError> {
+    let main = &program.functions[0];
+
+    let mut executor =
+        ProgramExecutor::new(&program.functions, blackbox_solver, foreign_call_executor);
+    let main_witness = executor.execute_circuit(main, initial_witness)?;
+    executor.witness_stack.push(0, main_witness);
 
-    Ok(acvm.finalize())
+    Ok(executor.finalize())
 }
diff --git a/tooling/nargo/src/ops/mod.rs b/tooling/nargo/src/ops/mod.rs
index 55e9e927800..2f5e6ebb7d4 100644
--- a/tooling/nargo/src/ops/mod.rs
+++ b/tooling/nargo/src/ops/mod.rs
@@ -2,7 +2,7 @@ pub use self::compile::{
     collect_errors, compile_contract, compile_program, compile_program_with_debug_instrumenter,
     compile_workspace, report_errors,
 };
-pub use self::execute::execute_circuit;
+pub use self::execute::execute_program;
 pub use self::foreign_calls::{
     DefaultForeignCallExecutor, ForeignCall, ForeignCallExecutor, NargoForeignCallResult,
 };
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 8cf2934da4d..45b1a88f99c 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -1,4 +1,7 @@
-use acvm::{acir::native_types::WitnessMap, BlackBoxFunctionSolver};
+use acvm::{
+    acir::native_types::{WitnessMap, WitnessStack},
+    BlackBoxFunctionSolver,
+};
 use noirc_driver::{compile_no_check, CompileError, CompileOptions};
 use noirc_errors::{debug_info::DebugInfo, FileDiagnostic};
 use noirc_evaluator::errors::RuntimeError;
@@ -6,7 +9,7 @@ use noirc_frontend::hir::{def_map::TestFunction, Context};
 
 use crate::{errors::try_to_diagnose_runtime_error, NargoError};
 
-use super::{execute_circuit, DefaultForeignCallExecutor};
+use super::{execute_program, DefaultForeignCallExecutor};
 
 pub enum TestStatus {
     Pass,
@@ -33,9 +36,8 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
         Ok(compiled_program) => {
             // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen,
             // otherwise constraints involving these expressions will not error.
-            let circuit_execution = execute_circuit(
-                // TODO(https://github.com/noir-lang/noir/issues/4428)
-                &compiled_program.program.functions[0],
+            let circuit_execution = execute_program(
+                &compiled_program.program,
                 WitnessMap::new(),
                 blackbox_solver,
                 &mut DefaultForeignCallExecutor::new(show_output, foreign_call_resolver_url),
@@ -83,7 +85,7 @@ fn test_status_program_compile_fail(err: CompileError, test_function: &TestFunct
 fn test_status_program_compile_pass(
     test_function: &TestFunction,
     debug: DebugInfo,
-    circuit_execution: Result<WitnessMap, NargoError>,
+    circuit_execution: Result<WitnessStack, NargoError>,
 ) -> TestStatus {
     let circuit_execution_err = match circuit_execution {
         // Circuit execution was successful; ie no errors or unsatisfied constraints
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 1f448105ee2..4f3e2886b2e 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
@@ -187,7 +187,11 @@ fn run_async(
             }
 
             if let Some(witness_name) = witness_name {
-                let witness_path = save_witness_to_dir(solved_witness, witness_name, target_dir)?;
+                let witness_path = save_witness_to_dir(
+                    WitnessStack::from(solved_witness),
+                    witness_name,
+                    target_dir,
+                )?;
 
                 println!("[{}] Witness saved to {}", package.name, witness_path.display());
             }
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 022bf7b761e..697f6d7c1ea 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::WitnessStack;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
@@ -91,7 +91,7 @@ pub(crate) fn run(
 
         let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
 
-        let (return_value, solved_witness) = execute_program_and_decode(
+        let (return_value, witness_stack) = execute_program_and_decode(
             compiled_program,
             package,
             &args.prover_name,
@@ -103,7 +103,7 @@ pub(crate) fn run(
             println!("[{}] Circuit output: {return_value:?}", package.name);
         }
         if let Some(witness_name) = &args.witness_name {
-            let witness_path = save_witness_to_dir(solved_witness, witness_name, target_dir)?;
+            let witness_path = save_witness_to_dir(witness_stack, witness_name, target_dir)?;
 
             println!("[{}] Witness saved to {}", package.name, witness_path.display());
         }
@@ -116,35 +116,37 @@ fn execute_program_and_decode(
     package: &Package,
     prover_name: &str,
     foreign_call_resolver_url: Option<&str>,
-) -> Result<(Option<InputValue>, WitnessMap), CliError> {
+) -> Result<(Option<InputValue>, WitnessStack), CliError> {
     // Parse the initial witness values from Prover.toml
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
-    let solved_witness = execute_program(&program, &inputs_map, foreign_call_resolver_url)?;
+    let witness_stack = execute_program(&program, &inputs_map, foreign_call_resolver_url)?;
     let public_abi = program.abi.public_abi();
-    let (_, return_value) = public_abi.decode(&solved_witness)?;
+    // Get the entry point witness for the ABI
+    let main_witness =
+        &witness_stack.peek().expect("Should have at least one witness on the stack").witness;
+    let (_, return_value) = public_abi.decode(main_witness)?;
 
-    Ok((return_value, solved_witness))
+    Ok((return_value, witness_stack))
 }
 
 pub(crate) fn execute_program(
     compiled_program: &CompiledProgram,
     inputs_map: &InputMap,
     foreign_call_resolver_url: Option<&str>,
-) -> Result<WitnessMap, CliError> {
+) -> Result<WitnessStack, CliError> {
     let blackbox_solver = Bn254BlackBoxSolver::new();
 
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
-    // TODO(https://github.com/noir-lang/noir/issues/4428)
-    let solved_witness_err = nargo::ops::execute_circuit(
-        &compiled_program.program.functions[0],
+    let solved_witness_stack_err = nargo::ops::execute_program(
+        &compiled_program.program,
         initial_witness,
         &blackbox_solver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
     );
-    match solved_witness_err {
-        Ok(solved_witness) => Ok(solved_witness),
+    match solved_witness_stack_err {
+        Ok(solved_witness_stack) => Ok(solved_witness_stack),
         Err(err) => {
             let debug_artifact = DebugArtifact {
                 debug_symbols: vec![compiled_program.debug.clone()],
diff --git a/tooling/nargo_cli/src/cli/fs/witness.rs b/tooling/nargo_cli/src/cli/fs/witness.rs
index 52b5c385e5d..613cdec28da 100644
--- a/tooling/nargo_cli/src/cli/fs/witness.rs
+++ b/tooling/nargo_cli/src/cli/fs/witness.rs
@@ -1,21 +1,19 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::native_types::{WitnessMap, WitnessStack};
+use acvm::acir::native_types::WitnessStack;
 use nargo::constants::WITNESS_EXT;
 
 use super::{create_named_dir, write_to_file};
 use crate::errors::FilesystemError;
 
 pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
-    witnesses: WitnessMap,
+    witness_stack: WitnessStack,
     witness_name: &str,
     witness_dir: P,
 ) -> Result<PathBuf, FilesystemError> {
     create_named_dir(witness_dir.as_ref(), "witness");
     let witness_path = witness_dir.as_ref().join(witness_name).with_extension(WITNESS_EXT);
 
-    // TODO(https://github.com/noir-lang/noir/issues/4428)
-    let witness_stack: WitnessStack = witnesses.into();
     let buf: Vec<u8> = witness_stack.try_into()?;
 
     write_to_file(buf.as_slice(), &witness_path);
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index 272f2fa8e5d..b9e4bca9e69 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -1,4 +1,3 @@
-use acvm::acir::native_types::WitnessStack;
 use clap::Args;
 use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
 use nargo::ops::{compile_program, report_errors};
@@ -123,12 +122,14 @@ pub(crate) fn prove_package(
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &compiled_program.abi)?;
 
-    let solved_witness =
-        execute_program(&compiled_program, &inputs_map, foreign_call_resolver_url)?;
+    let witness_stack = execute_program(&compiled_program, &inputs_map, foreign_call_resolver_url)?;
 
     // Write public inputs into Verifier.toml
     let public_abi = compiled_program.abi.public_abi();
-    let (public_inputs, return_value) = public_abi.decode(&solved_witness)?;
+    // Get the entry point witness for the ABI
+    let main_witness =
+        &witness_stack.peek().expect("Should have at least one witness on the stack").witness;
+    let (public_inputs, return_value) = public_abi.decode(main_witness)?;
 
     write_inputs_to_file(
         &public_inputs,
@@ -139,7 +140,7 @@ pub(crate) fn prove_package(
         Format::Toml,
     )?;
 
-    let proof = backend.prove(&compiled_program.program, WitnessStack::from(solved_witness))?;
+    let proof = backend.prove(&compiled_program.program, witness_stack)?;
 
     if check_proof {
         let public_inputs = public_abi.encode(&public_inputs, return_value)?;

From 301d4beb6a5de2b5fe56bbf95d0eef5bbc8cbfa6 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 1 Apr 2024 15:13:24 +0100
Subject: [PATCH 130/416] chore: Use is_entry_point helper on RuntimeType
 (#4678)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…y clones

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I just noticed a place that a spot was missed in inlining where
`RuntimeType::is_entry_point` could be used rather than matching on
`RuntimeType`. This is also better cause it stays in line with the
filter for `get_entry_point_functions`.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa.rs              |  4 +---
 compiler/noirc_evaluator/src/ssa/opt/inlining.rs | 13 ++++++-------
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 59f2bdc6f84..52377d36b36 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -174,8 +174,6 @@ fn convert_generated_acir_into_circuit(
         ..
     } = generated_acir;
 
-    let locations = locations.clone();
-
     let (public_parameter_witnesses, private_parameters) =
         split_public_and_private_inputs(&func_sig, &input_witnesses);
 
@@ -189,7 +187,7 @@ fn convert_generated_acir_into_circuit(
         private_parameters,
         public_parameters,
         return_values,
-        assert_messages: assert_messages.clone().into_iter().collect(),
+        assert_messages: assert_messages.into_iter().collect(),
         recursive,
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 7c7698d236d..63c78b99cdf 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -11,7 +11,7 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         dfg::{CallStack, InsertInstructionResult},
-        function::{Function, FunctionId, InlineType, RuntimeType},
+        function::{Function, FunctionId},
         instruction::{Instruction, InstructionId, TerminatorInstruction},
         value::{Value, ValueId},
     },
@@ -351,14 +351,13 @@ impl<'function> PerFunctionContext<'function> {
         for id in block.instructions() {
             match &self.source_function.dfg[*id] {
                 Instruction::Call { func, arguments } => match self.get_function(*func) {
-                    Some(function) => match ssa.functions[&function].runtime() {
-                        RuntimeType::Acir(InlineType::Inline) => {
-                            self.inline_function(ssa, *id, function, arguments);
-                        }
-                        RuntimeType::Acir(InlineType::Fold) | RuntimeType::Brillig => {
+                    Some(function) => {
+                        if ssa.functions[&function].runtime().is_entry_point() {
                             self.push_instruction(*id);
+                        } else {
+                            self.inline_function(ssa, *id, function, arguments);
                         }
-                    },
+                    }
                     None => self.push_instruction(*id),
                 },
                 _ => self.push_instruction(*id),

From 656665e86f685ab664ffb9f21f27e6365bcfd336 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 1 Apr 2024 22:57:53 +0100
Subject: [PATCH 131/416] chore: remove last traces of nix (#4679)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We have a lot of tech debt from a partial removal of nix. As it's no
longer in CI we cannot guarantee that the nix installation method works
so we should just remove it so we can clean up the code.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .envrc                                        |  20 --
 .github/scripts/acvm_js-build.sh              |   1 +
 .github/scripts/noir-wasm-build.sh            |   1 +
 .github/scripts/noirc-abi-build.sh            |   1 +
 .github/scripts/wasm-opt-install.sh           |   2 +-
 .github/workflows/test-js-packages.yml        |  17 +-
 .gitignore                                    |   6 -
 .vscode/extensions.json                       |   1 -
 .vscode/settings.json                         |  11 -
 README.md                                     |  20 --
 acvm-repo/acvm_js/build.sh                    |  39 ++-
 acvm-repo/acvm_js/buildPhaseCargoCommand.sh   |  42 ---
 acvm-repo/acvm_js/installPhase.sh             |  10 -
 acvm-repo/acvm_js/package.json                |   4 +-
 compiler/noirc_driver/build.rs                |   3 +-
 compiler/wasm/README.md                       |  14 -
 default.nix                                   |  13 -
 .../installation/other_install_methods.md     | 160 +----------
 flake.nix                                     | 260 ------------------
 package.json                                  |  12 +-
 release-please-config.json                    |   3 +-
 shell.nix                                     |  13 -
 tooling/debugger/build.rs                     |   3 +-
 tooling/nargo_cli/build.rs                    |   3 +-
 tooling/noirc_abi_wasm/README.md              |  14 -
 tooling/noirc_abi_wasm/build.rs               |   3 +-
 tooling/noirc_abi_wasm/build.sh               |  39 ++-
 .../noirc_abi_wasm/buildPhaseCargoCommand.sh  |  39 ---
 tooling/noirc_abi_wasm/installPhase.sh        |  10 -
 tooling/noirc_abi_wasm/package.json           |   4 +-
 wasm-bindgen-cli.nix                          |  43 ---
 31 files changed, 61 insertions(+), 750 deletions(-)
 delete mode 100644 .envrc
 delete mode 100755 acvm-repo/acvm_js/buildPhaseCargoCommand.sh
 delete mode 100755 acvm-repo/acvm_js/installPhase.sh
 delete mode 100644 default.nix
 delete mode 100644 flake.nix
 delete mode 100644 shell.nix
 delete mode 100755 tooling/noirc_abi_wasm/buildPhaseCargoCommand.sh
 delete mode 100755 tooling/noirc_abi_wasm/installPhase.sh
 delete mode 100644 wasm-bindgen-cli.nix

diff --git a/.envrc b/.envrc
deleted file mode 100644
index b2f868b1898..00000000000
--- a/.envrc
+++ /dev/null
@@ -1,20 +0,0 @@
-# Based on https://github.com/direnv/direnv-vscode/blob/158e8302c2594cc0eaa5f8b4f0cafedd4e1c0315/.envrc
-
-# You can define your system-specific logic (like Git settings or GH tokens) in .envrc.local
-# If that logic is usable by other people and might improve development environment, consider
-# contributing it to this file!
-
-source_env_if_exists .envrc.local
-
-if [[ -z "${SKIP_NIX:-}" ]] && has nix; then
-
-	if nix flake metadata &>/dev/null && has use_flake; then
-		# use flakes if possible
-		use flake
-
-	else
-		# Otherwise fall back to pure nix
-		use nix
-	fi
-
-fi
diff --git a/.github/scripts/acvm_js-build.sh b/.github/scripts/acvm_js-build.sh
index 95bd1efc8b9..e79967e3a8f 100755
--- a/.github/scripts/acvm_js-build.sh
+++ b/.github/scripts/acvm_js-build.sh
@@ -2,4 +2,5 @@
 set -eu
 
 .github/scripts/wasm-bindgen-install.sh
+.github/scripts/wasm-opt-install.sh
 yarn workspace @noir-lang/acvm_js build
diff --git a/.github/scripts/noir-wasm-build.sh b/.github/scripts/noir-wasm-build.sh
index 48e3ad73769..6c0336ee0c5 100755
--- a/.github/scripts/noir-wasm-build.sh
+++ b/.github/scripts/noir-wasm-build.sh
@@ -2,5 +2,6 @@
 set -eu
 
 .github/scripts/wasm-pack-install.sh
+.github/scripts/wasm-opt-install.sh
 yarn workspace @noir-lang/types build
 yarn workspace @noir-lang/noir_wasm build
diff --git a/.github/scripts/noirc-abi-build.sh b/.github/scripts/noirc-abi-build.sh
index 23b8393088e..99de474eb75 100755
--- a/.github/scripts/noirc-abi-build.sh
+++ b/.github/scripts/noirc-abi-build.sh
@@ -2,4 +2,5 @@
 set -eu
 
 .github/scripts/wasm-bindgen-install.sh
+.github/scripts/wasm-opt-install.sh
 yarn workspace @noir-lang/noirc_abi build
diff --git a/.github/scripts/wasm-opt-install.sh b/.github/scripts/wasm-opt-install.sh
index cbdeb8f2bfe..218778edac6 100755
--- a/.github/scripts/wasm-opt-install.sh
+++ b/.github/scripts/wasm-opt-install.sh
@@ -5,4 +5,4 @@ cd $(dirname "$0")
 
 ./cargo-binstall-install.sh
 
-cargo-binstall wasm-opt --version 0.116.0 -y
+cargo-binstall wasm-opt --version 0.116.0 -y --force
diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index b3908ee5d3e..06a96ee8932 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -66,9 +66,6 @@ jobs:
       - name: Install Yarn dependencies
         uses: ./.github/actions/setup
 
-      - name: Install wasm-opt
-        run: ./.github/scripts/wasm-opt-install.sh
-
       - name: Build noirc_abi
         run: ./.github/scripts/noirc-abi-build.sh
 
@@ -76,7 +73,9 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: noirc_abi_wasm
-          path: ./tooling/noirc_abi_wasm/outputs/out/noirc_abi_wasm
+          path: | 
+            ./tooling/noirc_abi_wasm/nodejs
+            ./tooling/noirc_abi_wasm/web
           retention-days: 10
 
 
@@ -100,9 +99,6 @@ jobs:
       - name: Install Yarn dependencies
         uses: ./.github/actions/setup
 
-      - name: Install wasm-opt
-        run: ./.github/scripts/wasm-opt-install.sh
-
       - name: Build noir_js_types
         run: yarn workspace @noir-lang/types build
 
@@ -138,9 +134,6 @@ jobs:
       - name: Install Yarn dependencies
         uses: ./.github/actions/setup
 
-      - name: Install wasm-opt
-        run: ./.github/scripts/wasm-opt-install.sh
-
       - name: Build acvm_js
         run: ./.github/scripts/acvm_js-build.sh
 
@@ -148,7 +141,9 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: acvm-js
-          path: ./acvm-repo/acvm_js/outputs/out/acvm_js
+          path: |
+            ./acvm-repo/acvm_js/nodejs
+            ./acvm-repo/acvm_js/web
           retention-days: 3
 
   test-acvm_js-node:
diff --git a/.gitignore b/.gitignore
index 5f41566c94b..9a829afab8b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,12 +17,6 @@ pkg/
 # Noir.js
 tooling/noir_js/lib
 
-# Nix stuff
-**/outputs
-result
-.envrc.local
-.direnv/
-
 # Nargo output
 *.proof
 *.acir
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index 1fb1def7ce1..efb17cb0085 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -4,7 +4,6 @@
 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
 		"mkhl.direnv",
-		"jnoortheen.nix-ide",
 		"rust-lang.rust-analyzer",
 		"redhat.vscode-yaml",
 		"esbenp.prettier-vscode",
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 171d36f4e04..fb8ea527881 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -2,17 +2,6 @@
     "direnv.restart.automatic": true,
     "redhat.telemetry.enabled": false,
     "yaml.recommendations.show": false,
-    "nix.serverPath": "nil",
-    "nix.enableLanguageServer": true,
-    "nix.serverSettings": {
-        "nil": {
-            "formatting": {
-                "command": [
-                    "nixpkgs-fmt"
-                ]
-            }
-        }
-    },
     "yaml.schemas": {
         "https://json.schemastore.org/github-workflow.json": "${workspaceRoot}/.github/workflows/*.yml"
     },
diff --git a/README.md b/README.md
index 5c93512ae26..adf68b290ef 100644
--- a/README.md
+++ b/README.md
@@ -56,26 +56,6 @@ Concretely the following items are on the road map:
 
 This crate's minimum supported rustc version is 1.73.0.
 
-## Working on this project
-
-This project uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. Please follow [our guidelines](https://noir-lang.org/docs/getting_started/installation/other_install_methods#option-3-compile-from-source) to setup your environment for working on the project.
-
-### Building against a different local/remote version of Barretenberg
-
-If you are working on this project and want a different version of Barretenberg (instead of the version this project is pinned against), you'll want to replace the lockfile version with your version. This can be done by running:
-
-```sh
-nix flake lock --override-input barretenberg /absolute/path/to/your/barretenberg
-```
-
-You can also point at a fork and/or branch on GitHub using:
-
-```sh
-nix flake lock --override-input barretenberg github:username/barretenberg/branch_name
-```
-
-__Note:__ You don't want to commit the updated lockfile, as it will fail in CI!
-
 ## License
 
 Noir is free and open source. It is distributed under a dual license. (MIT/APACHE)
diff --git a/acvm-repo/acvm_js/build.sh b/acvm-repo/acvm_js/build.sh
index 24af149bcea..fe0b4dcbfff 100755
--- a/acvm-repo/acvm_js/build.sh
+++ b/acvm-repo/acvm_js/build.sh
@@ -6,13 +6,6 @@ function require_command {
         exit 1
     fi
 }
-function check_installed {
-  if ! command -v "$1" >/dev/null 2>&1; then
-    echo "$1 is not installed. Please install it." >&2
-    return 1
-  fi
-  return 0
-}
 function run_or_fail {
   "$@"
   local status=$?
@@ -25,23 +18,29 @@ function run_or_fail {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-check_installed wasm-opt
+require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
-export pname=$(cargo read-manifest | jq -r '.name')
-export CARGO_TARGET_DIR=$self_path/target
+pname=$(cargo read-manifest | jq -r '.name')
 
-rm -rf $self_path/outputs >/dev/null 2>&1
-rm -rf $self_path/result >/dev/null 2>&1
+NODE_DIR=$self_path/nodejs
+BROWSER_DIR=$self_path/web
 
-if [ -n "$out" ]; then
-  echo "Will install package to $out (defined outside installPhase.sh script)"
-else
-  export out="$self_path/outputs/out"
-  echo "Will install package to $out"
+# Clear out the existing build artifacts as these aren't automatically removed by wasm-bindgen.
+if [ -d ./pkg/ ]; then
+    rm -r $NODE_DIR
+    rm -r $BROWSER_DIR
 fi
 
-run_or_fail $self_path/buildPhaseCargoCommand.sh
-run_or_fail $self_path/installPhase.sh
+TARGET=wasm32-unknown-unknown
+WASM_BINARY=${self_path}/../../target/$TARGET/release/${pname}.wasm
+
+NODE_WASM=${NODE_DIR}/${pname}_bg.wasm
+BROWSER_WASM=${BROWSER_DIR}/${pname}_bg.wasm
 
-ln -s $out $self_path/result
+# Build the new wasm package
+run_or_fail cargo build --lib --release --target $TARGET --package ${pname}
+run_or_fail wasm-bindgen $WASM_BINARY --out-dir $NODE_DIR --typescript --target nodejs
+run_or_fail wasm-bindgen $WASM_BINARY --out-dir $BROWSER_DIR --typescript --target web
+run_or_fail wasm-opt $NODE_WASM -o $NODE_WASM -O
+run_or_fail wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
diff --git a/acvm-repo/acvm_js/buildPhaseCargoCommand.sh b/acvm-repo/acvm_js/buildPhaseCargoCommand.sh
deleted file mode 100755
index 6c710bc938f..00000000000
--- a/acvm-repo/acvm_js/buildPhaseCargoCommand.sh
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-
-function run_or_fail {
-  "$@"
-  local status=$?
-  if [ $status -ne 0 ]; then
-    echo "Command '$*' failed with exit code $status" >&2
-    exit $status
-  fi
-}
-function run_if_available {
-  if command -v "$1" >/dev/null 2>&1; then
-    "$@"
-  else
-    echo "$1 is not installed. Please install it to use this feature." >&2
-  fi
-}
-
-export self_path=$(dirname "$(readlink -f "$0")")
-
-
-NODE_DIR=$self_path/nodejs/
-BROWSER_DIR=$self_path/web/
-
-# Clear out the existing build artifacts as these aren't automatically removed by wasm-pack.
-if [ -d ./pkg/ ]; then
-    rm -r $NODE_DIR
-    rm -r $BROWSER_DIR
-fi
-
-TARGET=wasm32-unknown-unknown
-WASM_BINARY=$CARGO_TARGET_DIR/$TARGET/release/${pname}.wasm
-
-NODE_WASM=${NODE_DIR}/${pname}_bg.wasm
-BROWSER_WASM=${BROWSER_DIR}/${pname}_bg.wasm
-
-# Build the new wasm package
-run_or_fail cargo build --lib --release --target $TARGET --package ${pname}
-run_or_fail wasm-bindgen $WASM_BINARY --out-dir $NODE_DIR --typescript --target nodejs
-run_or_fail wasm-bindgen $WASM_BINARY --out-dir $BROWSER_DIR --typescript --target web
-run_if_available wasm-opt $NODE_WASM -o $NODE_WASM -O
-run_if_available wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
diff --git a/acvm-repo/acvm_js/installPhase.sh b/acvm-repo/acvm_js/installPhase.sh
deleted file mode 100755
index 34ddb8155e1..00000000000
--- a/acvm-repo/acvm_js/installPhase.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-export self_path=$(dirname "$(readlink -f "$0")")
-
-export out_path=$out/acvm_js
-
-mkdir -p $out_path
-cp $self_path/README.md $out_path/
-cp $self_path/package.json $out_path/
-cp -r $self_path/nodejs $out_path/
-cp -r $self_path/web $out_path/
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 55345a2ddf6..44d99f13c31 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -34,9 +34,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0",
     "publish": "echo 📡 publishing `$npm_package_name` && yarn npm publish",
     "nightly:version": "jq --arg new_version \"-$(git rev-parse --short HEAD)$1\" '.version = .version + $new_version' package.json > package-tmp.json && mv package-tmp.json package.json",
-    "clean": "chmod u+w web nodejs || true && rm -rf web nodejs",
-    "build:nix": "nix build -L .#acvm_js",
-    "install:from:nix": "yarn clean && yarn build:nix && cp -rL ./result/acvm_js/nodejs ./ && cp -rL ./result/acvm_js/web ./"
+    "clean": "chmod u+w web nodejs || true && rm -rf web nodejs"
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
diff --git a/compiler/noirc_driver/build.rs b/compiler/noirc_driver/build.rs
index 73a56142075..2ed109398a4 100644
--- a/compiler/noirc_driver/build.rs
+++ b/compiler/noirc_driver/build.rs
@@ -2,8 +2,7 @@ const GIT_COMMIT: &&str = &"GIT_COMMIT";
 use std::path::Path;
 
 fn main() {
-    // Only use build_data if the environment variable isn't set
-    // The environment variable is always set when working via Nix
+    // Only use build_data if the environment variable isn't set.
     if std::env::var(GIT_COMMIT).is_err() {
         build_data::set_GIT_COMMIT();
         build_data::set_GIT_DIRTY();
diff --git a/compiler/wasm/README.md b/compiler/wasm/README.md
index 52f7e83e19e..fd534722622 100644
--- a/compiler/wasm/README.md
+++ b/compiler/wasm/README.md
@@ -26,17 +26,3 @@ for (const path of files) {
 }
 const myCompiledCode = await compile(fm);
 ```
-
-## Building from source
-
-Outside of the [noir repo](https://github.com/noir-lang/noir), this package can be built using the command below:
-
-```bash
-nix build -L github:noir-lang/noir/master#noir_wasm
-```
-
-If you are within the noir repo and would like to build local changes, you can use:
-
-```bash
-nix build -L #noir_wasm
-```
diff --git a/default.nix b/default.nix
deleted file mode 100644
index 9e230590a61..00000000000
--- a/default.nix
+++ /dev/null
@@ -1,13 +0,0 @@
-let
-  lock = builtins.fromJSON (builtins.readFile ./flake.lock);
-  flakeCompatRev = lock.nodes.flake-compat.locked.rev;
-  flakeCompatHash = lock.nodes.flake-compat.locked.narHash;
-  flakeCompat = fetchTarball {
-    url = "https://github.com/edolstra/flake-compat/archive/${flakeCompatRev}.tar.gz";
-    sha256 = flakeCompatHash;
-  };
-  compat = import flakeCompat {
-    src = ./.;
-  };
-in
-compat.defaultNix
diff --git a/docs/docs/getting_started/installation/other_install_methods.md b/docs/docs/getting_started/installation/other_install_methods.md
index a35e34aaf9c..3634723562b 100644
--- a/docs/docs/getting_started/installation/other_install_methods.md
+++ b/docs/docs/getting_started/installation/other_install_methods.md
@@ -1,6 +1,6 @@
 ---
-title: Alternative Install Methods
-description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains other methods that don't rely on noirup, such as compiling from source, installing from binaries, and using WSL for windows
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
 keywords: [
     Installation
     Nargo
@@ -12,10 +12,7 @@ keywords: [
     Linux
     Nix
     Direnv
-    Shell & editor experience
-    Building and testing
     Uninstalling Nargo
-    Noir vs code extension,
   ]
 sidebar_position: 1
 ---
@@ -86,146 +83,7 @@ With `noirup`, you can easily switch between different Nargo versions, including
   noirup --path ./path/to/local/source
   ```
 
-## Alternate Installation Methods (No Longer Recommended)
-
-While the following methods are available, they are no longer recommended. We advise using noirup for a more efficient and flexible installation experience.
-
-However, there are other methods for installing Nargo:
-
-- [Binaries](#option-1-installing-from-binaries)
-- [Compiling from Source](#option-2-compile-from-source)
-- [WSL for Windows](#option-3-wsl-for-windows)
-
-### Option 1: Installing from Binaries
-
-See [GitHub Releases](https://github.com/noir-lang/noir/releases) for the latest and previous
-platform specific binaries.
-
-#### Step 1
-
-Paste and run the following in the terminal to extract and install the binary:
-
-> **macOS / Linux:** If you are prompted with `Permission denied` when running commands, prepend
-> `sudo` and re-run it.
-
-##### macOS (Apple Silicon)
-
-```bash
-mkdir -p $HOME/.nargo/bin && \
-curl -o $HOME/.nargo/bin/nargo-aarch64-apple-darwin.tar.gz -L https://github.com/noir-lang/noir/releases/download/v0.24.0/nargo-aarch64-apple-darwin.tar.gz && \
-tar -xvf $HOME/.nargo/bin/nargo-aarch64-apple-darwin.tar.gz -C $HOME/.nargo/bin/ && \
-echo '\nexport PATH=$PATH:$HOME/.nargo/bin' >> ~/.zshrc && \
-source ~/.zshrc
-```
-
-##### macOS (Intel)
-
-```bash
-mkdir -p $HOME/.nargo/bin && \
-curl -o $HOME/.nargo/bin/nargo-x86_64-apple-darwin.tar.gz -L https://github.com/noir-lang/noir/releases/download/v0.24.0/nargo-x86_64-apple-darwin.tar.gz && \
-tar -xvf $HOME/.nargo/bin/nargo-x86_64-apple-darwin.tar.gz -C $HOME/.nargo/bin/ && \
-echo '\nexport PATH=$PATH:$HOME/.nargo/bin' >> ~/.zshrc && \
-source ~/.zshrc
-```
-
-##### Linux (Bash)
-
-```bash
-mkdir -p $HOME/.nargo/bin && \
-curl -o $HOME/.nargo/bin/nargo-x86_64-unknown-linux-gnu.tar.gz -L https://github.com/noir-lang/noir/releases/download/v0.24.0/nargo-x86_64-unknown-linux-gnu.tar.gz && \
-tar -xvf $HOME/.nargo/bin/nargo-x86_64-unknown-linux-gnu.tar.gz -C $HOME/.nargo/bin/ && \
-echo -e '\nexport PATH=$PATH:$HOME/.nargo/bin' >> ~/.bashrc && \
-source ~/.bashrc
-```
-
-#### Step 2
-
-Check if the installation was successful by running `nargo --version`. You should get a version number.
-
-> **macOS:** If you are prompted with an OS alert, right-click and open the _nargo_ executable from
-> Finder. Close the new terminal popped up and `nargo` should now be accessible.
-
-### Option 2: Compile from Source
-
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
-
-Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
-
-#### Setting up your environment
-
-For the best experience, please follow these instructions to setup your environment:
-
-1. Install Nix following [their guide](https://nixos.org/download.html) for your operating system.
-2. Create the file `~/.config/nix/nix.conf` with the contents:
-
-```ini
-experimental-features = nix-command
-extra-experimental-features = flakes
-```
-
-3. Install direnv into your Nix profile by running:
-
-```sh
-nix profile install nixpkgs#direnv
-```
-
-4. Add direnv to your shell following [their guide](https://direnv.net/docs/hook.html).
-   1. For bash or zshell, add `eval "$(direnv hook bash)"` or `eval "$(direnv hook zsh)"` to your ~/.bashrc or ~/.zshrc file, respectively.
-5. Restart your shell.
-
-#### Shell & editor experience
-
-Now that your environment is set up, you can get to work on the project.
-
-1. Clone the repository, such as:
-
-```sh
-git clone git@github.com:noir-lang/noir
-```
-
-> Replacing `noir` with whichever repository you want to work on.
-
-2. Navigate to the directory:
-
-```sh
-cd noir
-```
-
-> Replacing `noir` with whichever repository you cloned.
-
-3. You should see a **direnv error** because projects aren't allowed by default. Make sure you've reviewed and trust our `.envrc` file, then you need to run:
-
-```sh
-direnv allow
-```
-
-4. Now, wait awhile for all the native dependencies to be built. This will take some time and direnv will warn you that it is taking a long time, but we just need to let it run.
-
-5. Once you are presented with your prompt again, you can start your editor within the project directory (we recommend [VSCode](https://code.visualstudio.com/)):
-
-```sh
-code .
-```
-
-6. (Recommended) When launching VSCode for the first time, you should be prompted to install our recommended plugins. We highly recommend installing these for the best development experience.
-
-#### Building and testing
-
-Assuming you are using `direnv` to populate your environment, building and testing the project can be done
-with the typical `cargo build`, `cargo test`, and `cargo clippy` commands. You'll notice that the `cargo` version matches the version we specify in `rust-toolchain.toml`, which is 1.73.0 at the time of this writing.
-
-If you want to build the entire project in an isolated sandbox, you can use Nix commands:
-
-1. `nix build .` (or `nix build . -L` for verbose output) to build the project in a Nix sandbox.
-2. `nix flake check` (or `nix flake check -L` for verbose output) to run clippy and tests in a Nix sandbox.
-
-#### Without `direnv`
-
-If you have hesitations with using direnv, you can launch a subshell with `nix develop` and then launch your editor from within the subshell. However, if VSCode was already launched in the project directory, the environment won't be updated.
-
-Advanced: If you aren't using direnv nor launching your editor within the subshell, you can try to install Barretenberg and other global dependencies the package needs. This is an advanced workflow and likely won't receive support!
-
-### Option 3: WSL (for Windows)
+## Installation on Windows
 
 The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
@@ -235,20 +93,10 @@ step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup)
 
 ## Uninstalling Nargo
 
-### Noirup
-
-If you installed Nargo with `noirup` or through directly downloading binaries, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
 
 ```bash
 rm -r ~/.nargo
 rm -r ~/nargo
 rm -r ~/noir_cache
 ```
-
-### Nix
-
-If you installed Nargo with Nix or compiled it from source, you can remove the binary located at `~/.nix-profile/bin/nargo`.
-
-```bash
-rm ~/.nix-profile/bin/nargo
-```
diff --git a/flake.nix b/flake.nix
deleted file mode 100644
index 1cb421a49ef..00000000000
--- a/flake.nix
+++ /dev/null
@@ -1,260 +0,0 @@
-{
-  description = "Build the Noir programming language";
-
-  # All of these inputs (a.k.a. dependencies) need to align with inputs we
-  # use so they use the `inputs.*.follows` syntax to reference our inputs
-  inputs = {
-    nixpkgs = {
-      url = "github:NixOS/nixpkgs/nixos-23.05";
-    };
-
-    flake-utils = {
-      url = "github:numtide/flake-utils";
-    };
-
-    flake-compat = {
-      url = "github:edolstra/flake-compat";
-      flake = false;
-    };
-
-    fenix = {
-      url = "github:nix-community/fenix";
-      inputs = {
-        nixpkgs.follows = "nixpkgs";
-      };
-    };
-
-    crane = {
-      url = "github:ipetkov/crane";
-      inputs = {
-        nixpkgs.follows = "nixpkgs";
-        flake-utils.follows = "flake-utils";
-        flake-compat.follows = "flake-compat";
-      };
-    };
-  };
-
-  outputs =
-    { self, nixpkgs, crane, flake-utils, fenix, ... }:
-    flake-utils.lib.eachDefaultSystem (system:
-    let
-      pkgs = import nixpkgs {
-        inherit system;
-      };
-
-      rustToolchain = fenix.packages.${system}.fromToolchainFile {
-        file = ./rust-toolchain.toml;
-        sha256 = "sha256-rLP8+fTxnPHoR96ZJiCa/5Ans1OojI7MLsmSqR2ip8o=";
-      };
-
-      craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain;
-
-      # The `self.rev` property is only available when the working tree is not dirty
-      GIT_COMMIT = if (self ? rev) then self.rev else "unknown";
-      GIT_DIRTY = if (self ? rev) then "false" else "true";
-
-      extraBuildInputs = [ ] ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
-        # Need libiconv and apple Security on Darwin. See https://github.com/ipetkov/crane/issues/156
-        pkgs.libiconv
-        pkgs.darwin.apple_sdk.frameworks.Security
-      ];
-
-      environment = {
-        # We enable backtraces on any failure for help with debugging
-        RUST_BACKTRACE = "1";
-
-        # We download the Wasm version of `acvm_backend` in the barretenberg releases for the ACVM `blackbox_solver`
-        BARRETENBERG_ARCHIVE = pkgs.fetchurl {
-          url = "https://github.com/AztecProtocol/barretenberg/releases/download/barretenberg-v0.4.5/acvm_backend.wasm.tar.gz";
-          sha256 = "sha256-xONt5pTKWf/YbVnX/NXl/VNBbtKd+CP7CLkB1jf0RHw=";
-        };
-      };
-
-      # Configuration shared between builds
-      config = {
-        # x-release-please-start-version
-        version = "0.26.0";
-        # x-release-please-end
-
-        src = pkgs.lib.cleanSourceWith {
-          src = craneLib.path ./.;
-          # Custom filter with various file extensions that we rely upon to build packages
-          # Currently: `.nr`, `.sol`, `.sh`, `.json`, `.md` and `.wasm`
-          filter = path: type:
-            (builtins.match ".*\.(nr|sol|sh|json|md|wasm|txt)$" path != null) || (craneLib.filterCargoSources path type);
-        };
-
-        # TODO(#1198): It'd be nice to include these flags when running `cargo clippy` in a devShell.
-        cargoClippyExtraArgs = "--all-targets -- -D warnings";
-
-        # TODO(#1198): It'd be nice to include this flag when running `cargo test` in a devShell.
-        cargoTestExtraArgs = "--workspace";
-      };
-
-      # Combine the environment and other configuration needed for Crane to build our Rust packages
-      nativeConfig = environment // config // {
-        nativeBuildInputs = [ ];
-
-        buildInputs = [ ] ++ extraBuildInputs;
-      };
-
-      # Combine the environmnet and other configuration needed for Crane to build our Wasm packages
-      wasmConfig = environment // config // {
-        CARGO_TARGET_DIR = "./target";
-
-        nativeBuildInputs = with pkgs; [
-          which
-          git
-          jq
-          rustToolchain
-          wasm-bindgen-cli
-          binaryen
-        ];
-
-        buildInputs = [ ] ++ extraBuildInputs;
-      };
-
-      # Build *just* the cargo dependencies, so we can reuse all of that work between runs
-      native-cargo-artifacts = craneLib.buildDepsOnly (nativeConfig // {
-        pname = "nargo";
-      });
-      noirc-abi-wasm-cargo-artifacts = craneLib.buildDepsOnly (wasmConfig // {
-        pname = "noirc_abi_wasm";
-      });
-      acvm-js-cargo-artifacts = craneLib.buildDepsOnly (wasmConfig // {
-        pname = "acvm_js";
-      });
-
-      nargo = craneLib.buildPackage (nativeConfig // {
-        pname = "nargo";
-
-        inherit GIT_COMMIT GIT_DIRTY;
-
-        cargoArtifacts = native-cargo-artifacts;
-
-        # We don't want to run tests because they don't work in the Nix sandbox
-        doCheck = false;
-      });
-
-      noirc_abi_wasm = craneLib.buildPackage (wasmConfig // rec {
-        pname = "noirc_abi_wasm";
-
-        inherit GIT_COMMIT GIT_DIRTY;
-
-        cargoArtifacts = noirc-abi-wasm-cargo-artifacts;
-
-        cargoExtraArgs = "--package ${pname} --target wasm32-unknown-unknown";
-
-        buildPhaseCargoCommand = ''
-          bash tooling/noirc_abi_wasm/buildPhaseCargoCommand.sh release
-        '';
-
-        installPhase = ''
-          bash tooling/noirc_abi_wasm/installPhase.sh
-        '';
-
-        # We don't want to run tests because they don't work in the Nix sandbox
-        doCheck = false;
-      });
-
-      acvm_js = craneLib.buildPackage (wasmConfig // rec {
-        pname = "acvm_js";
-
-        inherit GIT_COMMIT GIT_DIRTY;
-
-        cargoArtifacts = acvm-js-cargo-artifacts;
-
-        cargoExtraArgs = "--package ${pname} --target wasm32-unknown-unknown";
-
-        buildPhaseCargoCommand = ''
-          bash acvm-repo/acvm_js/buildPhaseCargoCommand.sh release
-        '';
-
-        installPhase = ''
-          bash acvm-repo/acvm_js/installPhase.sh
-        '';
-
-        # We don't want to run tests because they don't work in the Nix sandbox
-        doCheck = false;
-      });
-
-      wasm-bindgen-cli = pkgs.callPackage ./wasm-bindgen-cli.nix {
-        rustPlatform = pkgs.makeRustPlatform {
-          rustc = rustToolchain;
-          cargo = rustToolchain;
-        };
-      };
-    in
-    {
-      # We use `checks` to run `cargo clippy` and `cargo fmt` since we disable checks in the primary derivations
-      checks = {
-        cargo-clippy = craneLib.cargoClippy (nativeConfig // {
-          pname = "noir";
-
-          inherit GIT_COMMIT GIT_DIRTY;
-
-          cargoArtifacts = native-cargo-artifacts;
-        });
-
-        cargo-fmt = craneLib.cargoFmt (nativeConfig // {
-          pname = "noir";
-
-          inherit GIT_COMMIT GIT_DIRTY;
-
-          cargoArtifacts = native-cargo-artifacts;
-        });
-      };
-
-      packages = {
-        default = nargo;
-
-        # Nix flakes cannot build more than one derivation in one command (see https://github.com/NixOS/nix/issues/5591)
-        # so we use `symlinkJoin` to build everything as the "all" package.
-        all = pkgs.symlinkJoin { name = "all"; paths = [ nargo noirc_abi_wasm acvm_js ]; };
-        all_wasm = pkgs.symlinkJoin { name = "all_wasm"; paths = [ noirc_abi_wasm acvm_js ]; };
-
-        # We also export individual packages to enable `nix build .#nargo -L`, etc.
-        inherit nargo;
-        inherit noirc_abi_wasm;
-        inherit acvm_js;
-
-        # We expose the `*-cargo-artifacts` derivations so we can cache our cargo dependencies in CI
-        inherit native-cargo-artifacts;
-        inherit noirc-abi-wasm-cargo-artifacts;
-        inherit acvm-js-cargo-artifacts;
-      };
-
-      # Setup the environment to match the environment settings, the inputs from our checks derivations,
-      # and extra tooling via `nativeBuildInputs`
-      devShells.default = pkgs.mkShell (environment // {
-        inputsFrom = [
-          nargo
-          noirc_abi_wasm
-          acvm_js
-        ];
-
-        # Additional tools that weren't included as `nativeBuildInputs` of any of the derivations in `inputsFrom`
-        nativeBuildInputs = with pkgs; [
-          # Rust toolchain
-          rustToolchain
-          # Other tools
-          starship
-          yarn
-          nodejs-18_x
-          # Used by the `bb` binary
-          curl
-          gzip
-          # This ensures the right lldb is in the environment for running rust-lldb
-          llvmPackages.lldb
-          # Nix tools
-          nil
-          nixpkgs-fmt
-        ];
-
-        shellHook = ''
-          eval "$(starship init bash)"
-        '';
-      });
-    });
-}
-
diff --git a/package.json b/package.json
index 049c1634dd2..30cac607010 100644
--- a/package.json
+++ b/package.json
@@ -17,19 +17,11 @@
     "test": "yarn workspaces foreach --parallel --verbose run test",
     "test:integration": "yarn workspace integration-tests test",
     "clean:workspaces": "yarn workspaces foreach --exclude @noir-lang/root run clean",
-    "clean:root": "rm -rf ./result ./target ./packages",
+    "clean:root": "rm -rf ./target ./packages",
     "clean": "yarn clean:workspaces && yarn clean:root",
     "lint": "yarn workspaces foreach --verbose run lint",
     "spellcheck": "cspell '**/*.{md,rs}' -c ./cspell.json",
-    "install:acvm_js": "yarn workspace @noir-lang/acvm_js run install:from:nix",
-    "install:noir_wasm": "yarn workspace @noir-lang/noir_wasm run install:from:nix",
-    "install:noirc_abi_wasm": "yarn workspace @noir-lang/noirc_abi run install:from:nix",
-    "install:from:nix": "yarn install:acvm_js && yarn install:noir_wasm && yarn install:noirc_abi_wasm",
-    "build:types": "yarn workspace @noir-lang/types run build",
-    "build:backend_barretenberg": "yarn workspace @noir-lang/backend_barretenberg run build",
-    "build:noir_js": "yarn workspace @noir-lang/noir_js run build",
-    "build:js:only": "yarn workspaces foreach -vtp --from \"{@noir-lang/types,@noir-lang/backend_barretenberg,@noir-lang/noir_js,@noir-lang/noir_codegen}\" run build",
-    "prepare:publish": "yarn clean && yarn install:from:nix && yarn build:js:only",
+    "prepare:publish": "yarn clean && yarn build",
     "nightly:version": "yarn workspaces foreach run nightly:version",
     "publish:all": "yarn install && yarn workspaces foreach run publish"
   },
diff --git a/release-please-config.json b/release-please-config.json
index 217a86303a1..0ba192754a0 100644
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -13,7 +13,6 @@
       "include-component-in-tag": false,
       "extra-files": [
         "Cargo.toml",
-        "flake.nix",
         {
           "type": "json",
           "path": "compiler/wasm/package.json",
@@ -82,4 +81,4 @@
     "sentence-case"
   ],
   "bootstrap-sha": "690cfc0468de0b9aee53ccfe832c71c16e61e5fc"
-}
\ No newline at end of file
+}
diff --git a/shell.nix b/shell.nix
deleted file mode 100644
index b72d4a4697b..00000000000
--- a/shell.nix
+++ /dev/null
@@ -1,13 +0,0 @@
-let
-  lock = builtins.fromJSON (builtins.readFile ./flake.lock);
-  flakeCompatRev = lock.nodes.flake-compat.locked.rev;
-  flakeCompatHash = lock.nodes.flake-compat.locked.narHash;
-  flakeCompat = fetchTarball {
-    url = "https://github.com/edolstra/flake-compat/archive/${flakeCompatRev}.tar.gz";
-    sha256 = flakeCompatHash;
-  };
-  compat = import flakeCompat {
-    src = ./.;
-  };
-in
-compat.shellNix
diff --git a/tooling/debugger/build.rs b/tooling/debugger/build.rs
index 26a8bc64b0e..ebdf2036894 100644
--- a/tooling/debugger/build.rs
+++ b/tooling/debugger/build.rs
@@ -7,8 +7,7 @@ use std::{env, fs};
 const GIT_COMMIT: &&str = &"GIT_COMMIT";
 
 fn main() {
-    // Only use build_data if the environment variable isn't set
-    // The environment variable is always set when working via Nix
+    // Only use build_data if the environment variable isn't set.
     if std::env::var(GIT_COMMIT).is_err() {
         build_data::set_GIT_COMMIT();
         build_data::set_GIT_DIRTY();
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index a796eeac326..16df29e6985 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -16,8 +16,7 @@ const GIT_COMMIT: &&str = &"GIT_COMMIT";
 fn main() {
     check_rustc_version();
 
-    // Only use build_data if the environment variable isn't set
-    // The environment variable is always set when working via Nix
+    // Only use build_data if the environment variable isn't set.
     if std::env::var(GIT_COMMIT).is_err() {
         build_data::set_GIT_COMMIT();
         build_data::set_GIT_DIRTY();
diff --git a/tooling/noirc_abi_wasm/README.md b/tooling/noirc_abi_wasm/README.md
index 77bc1f5fae2..2b0cf9b74d4 100644
--- a/tooling/noirc_abi_wasm/README.md
+++ b/tooling/noirc_abi_wasm/README.md
@@ -1,17 +1,3 @@
 # Noir Lang ABI JavaScript Package
 
 This JavaScript package enables users to ABI encode inputs to a Noir program, i.e. generating an initial witness.
-
-## Building from source
-
-Outside of the [noir repo](https://github.com/noir-lang/noir), this package can be built using the command below:
-
-```bash
-nix build -L github:noir-lang/noir/master#abi_wasm
-```
-
-If you are within the noir repo and would like to build local changes, you can use:
-
-```bash
-nix build -L #abi_wasm
-```
diff --git a/tooling/noirc_abi_wasm/build.rs b/tooling/noirc_abi_wasm/build.rs
index 3b96be74ef3..7a6eb861de2 100644
--- a/tooling/noirc_abi_wasm/build.rs
+++ b/tooling/noirc_abi_wasm/build.rs
@@ -1,8 +1,7 @@
 const GIT_COMMIT: &&str = &"GIT_COMMIT";
 
 fn main() {
-    // Only use build_data if the environment variable isn't set
-    // The environment variable is always set when working via Nix
+    // Only use build_data if the environment variable isn't set.
     if std::env::var(GIT_COMMIT).is_err() {
         build_data::set_GIT_COMMIT();
         build_data::set_GIT_DIRTY();
diff --git a/tooling/noirc_abi_wasm/build.sh b/tooling/noirc_abi_wasm/build.sh
index 24af149bcea..fe0b4dcbfff 100755
--- a/tooling/noirc_abi_wasm/build.sh
+++ b/tooling/noirc_abi_wasm/build.sh
@@ -6,13 +6,6 @@ function require_command {
         exit 1
     fi
 }
-function check_installed {
-  if ! command -v "$1" >/dev/null 2>&1; then
-    echo "$1 is not installed. Please install it." >&2
-    return 1
-  fi
-  return 0
-}
 function run_or_fail {
   "$@"
   local status=$?
@@ -25,23 +18,29 @@ function run_or_fail {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-check_installed wasm-opt
+require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
-export pname=$(cargo read-manifest | jq -r '.name')
-export CARGO_TARGET_DIR=$self_path/target
+pname=$(cargo read-manifest | jq -r '.name')
 
-rm -rf $self_path/outputs >/dev/null 2>&1
-rm -rf $self_path/result >/dev/null 2>&1
+NODE_DIR=$self_path/nodejs
+BROWSER_DIR=$self_path/web
 
-if [ -n "$out" ]; then
-  echo "Will install package to $out (defined outside installPhase.sh script)"
-else
-  export out="$self_path/outputs/out"
-  echo "Will install package to $out"
+# Clear out the existing build artifacts as these aren't automatically removed by wasm-bindgen.
+if [ -d ./pkg/ ]; then
+    rm -r $NODE_DIR
+    rm -r $BROWSER_DIR
 fi
 
-run_or_fail $self_path/buildPhaseCargoCommand.sh
-run_or_fail $self_path/installPhase.sh
+TARGET=wasm32-unknown-unknown
+WASM_BINARY=${self_path}/../../target/$TARGET/release/${pname}.wasm
+
+NODE_WASM=${NODE_DIR}/${pname}_bg.wasm
+BROWSER_WASM=${BROWSER_DIR}/${pname}_bg.wasm
 
-ln -s $out $self_path/result
+# Build the new wasm package
+run_or_fail cargo build --lib --release --target $TARGET --package ${pname}
+run_or_fail wasm-bindgen $WASM_BINARY --out-dir $NODE_DIR --typescript --target nodejs
+run_or_fail wasm-bindgen $WASM_BINARY --out-dir $BROWSER_DIR --typescript --target web
+run_or_fail wasm-opt $NODE_WASM -o $NODE_WASM -O
+run_or_fail wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
diff --git a/tooling/noirc_abi_wasm/buildPhaseCargoCommand.sh b/tooling/noirc_abi_wasm/buildPhaseCargoCommand.sh
deleted file mode 100755
index 1188d00953e..00000000000
--- a/tooling/noirc_abi_wasm/buildPhaseCargoCommand.sh
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-
-function run_or_fail {
-  "$@"
-  local status=$?
-  if [ $status -ne 0 ]; then
-    echo "Command '$*' failed with exit code $status" >&2
-    exit $status
-  fi
-}
-function run_if_available {
-  if command -v "$1" >/dev/null 2>&1; then
-    "$@"
-  else
-    echo "$1 is not installed. Please install it to use this feature." >&2
-  fi
-}
-
-export self_path=$(dirname "$(readlink -f "$0")")
-
-# Clear out the existing build artifacts as these aren't automatically removed by wasm-pack.
-if [ -d ./pkg/ ]; then
-    rm -rf $self_path/pkg/
-fi
-
-TARGET=wasm32-unknown-unknown
-WASM_BINARY=$CARGO_TARGET_DIR/$TARGET/release/${pname}.wasm
-
-NODE_DIR=$self_path/nodejs/
-BROWSER_DIR=$self_path/web/
-NODE_WASM=${NODE_DIR}/${pname}_bg.wasm
-BROWSER_WASM=${BROWSER_DIR}/${pname}_bg.wasm
-
-# Build the new wasm package
-run_or_fail cargo build --lib --release --target $TARGET --package ${pname}
-run_or_fail wasm-bindgen $WASM_BINARY --out-dir $NODE_DIR --typescript --target nodejs
-run_or_fail wasm-bindgen $WASM_BINARY --out-dir $BROWSER_DIR --typescript --target web
-run_if_available wasm-opt $NODE_WASM -o $NODE_WASM -O
-run_if_available wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
\ No newline at end of file
diff --git a/tooling/noirc_abi_wasm/installPhase.sh b/tooling/noirc_abi_wasm/installPhase.sh
deleted file mode 100755
index d9b94f2d171..00000000000
--- a/tooling/noirc_abi_wasm/installPhase.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-export self_path=$(dirname "$(readlink -f "$0")")
-
-export out_path=$out/noirc_abi_wasm
-
-mkdir -p $out_path
-cp $self_path/README.md $out_path/
-cp $self_path/package.json $out_path/
-cp -r $self_path/nodejs $out_path/
-cp -r $self_path/web $out_path/
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index e93a8e6a5e3..14e528c3b15 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -33,9 +33,7 @@
     "clean": "chmod u+w web nodejs || true && rm -rf ./nodejs ./web ./target ./result",
     "nightly:version": "jq --arg new_version \"-$(git rev-parse --short HEAD)$1\" '.version = .version + $new_version' package.json > package-tmp.json && mv package-tmp.json package.json",
     "publish": "echo 📡 publishing `$npm_package_name` && yarn npm publish",
-    "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0",
-    "build:nix": "nix build -L .#noirc_abi_wasm",
-    "install:from:nix": "yarn clean && yarn build:nix && cp -rL ./result/noirc_abi_wasm/nodejs ./ && cp -rL ./result/noirc_abi_wasm/web ./"
+    "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
     "@noir-lang/types": "workspace:*"
diff --git a/wasm-bindgen-cli.nix b/wasm-bindgen-cli.nix
deleted file mode 100644
index 7c3910f032e..00000000000
--- a/wasm-bindgen-cli.nix
+++ /dev/null
@@ -1,43 +0,0 @@
-{ lib
-, rustPlatform
-, fetchCrate
-, nodejs
-, pkg-config
-, openssl
-, stdenv
-, curl
-, darwin
-, libiconv
-, runCommand
-}:
-
-rustPlatform.buildRustPackage rec {
-  pname = "wasm-bindgen-cli";
-  version = "0.2.86";
-
-  src = fetchCrate {
-    inherit pname version;
-    sha256 = "sha256-56EOiLbdgAcoTrkyvB3t9TjtLaRvGxFUXx4haLwE2QY=";
-  };
-
-  cargoSha256 = "sha256-4CPBmz92PuPN6KeGDTdYPAf5+vTFk9EN5Cmx4QJy6yI=";
-
-  nativeBuildInputs = [ pkg-config ];
-
-  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [
-    curl
-    # Need libiconv and apple Security on Darwin. See https://github.com/ipetkov/crane/issues/156
-    libiconv
-    darwin.apple_sdk.frameworks.Security
-  ];
-
-  doCheck = false;
-
-  meta = with lib; {
-    homepage = "https://rustwasm.github.io/docs/wasm-bindgen/";
-    license = with licenses; [ asl20 /* or */ mit ];
-    description = "Facilitating high-level interactions between wasm modules and JavaScript";
-    maintainers = with maintainers; [ nitsky rizary ];
-    mainProgram = "wasm-bindgen";
-  };
-}

From 96b811079b0e7c0345210cfc705c00345b0b3334 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 2 Apr 2024 14:49:25 +0100
Subject: [PATCH 132/416] feat: improve optimisations on range constraints
 (#4690)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're currently not making full use of type information when optimizing
out range constraints in SSA. I don't think makes a huge difference as
they should be removed in ACIR gen but it's good to catch these early.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/ir/instruction.rs     | 10 +++++-----
 .../src/ssa/ir/instruction/call.rs                | 15 ++++++++++-----
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index dd190c112f3..a887b279970 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -573,12 +573,12 @@ impl Instruction {
             Instruction::IncrementRc { .. } => None,
             Instruction::DecrementRc { .. } => None,
             Instruction::RangeCheck { value, max_bit_size, .. } => {
-                if let Some(numeric_constant) = dfg.get_numeric_constant(*value) {
-                    if numeric_constant.num_bits() < *max_bit_size {
-                        return Remove;
-                    }
+                let max_potential_bits = dfg.get_value_max_num_bits(*value);
+                if max_potential_bits < *max_bit_size {
+                    Remove
+                } else {
+                    None
                 }
-                None
             }
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 5b268de239d..a2847146087 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -240,11 +240,16 @@ pub(super) fn simplify_call(
             let max_bit_size = dfg.get_numeric_constant(arguments[1]);
             if let Some(max_bit_size) = max_bit_size {
                 let max_bit_size = max_bit_size.to_u128() as u32;
-                SimplifyResult::SimplifiedToInstruction(Instruction::RangeCheck {
-                    value,
-                    max_bit_size,
-                    assert_message: Some("call to assert_max_bit_size".to_owned()),
-                })
+                let max_potential_bits = dfg.get_value_max_num_bits(value);
+                if max_potential_bits < max_bit_size {
+                    SimplifyResult::Remove
+                } else {
+                    SimplifyResult::SimplifiedToInstruction(Instruction::RangeCheck {
+                        value,
+                        max_bit_size,
+                        assert_message: Some("call to assert_max_bit_size".to_owned()),
+                    })
+                }
             } else {
                 SimplifyResult::None
             }

From 669f1a0fa47ad9093888a8ce8e525cb02bcf19b5 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 2 Apr 2024 15:20:34 +0100
Subject: [PATCH 133/416] feat: improve SSA type-awareness in EQ and MUL
 instructions (#4691)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds some improvements for SSA generation for programs such as
in #4688 where we now make more use of information on casted values.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../src/ssa/ir/instruction/binary.rs          | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
index 36f3ae8620b..e491807995b 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
@@ -130,6 +130,12 @@ impl Binary {
                     let zero = dfg.make_constant(FieldElement::zero(), operand_type);
                     return SimplifyResult::SimplifiedTo(zero);
                 }
+                if dfg.resolve(self.lhs) == dfg.resolve(self.rhs)
+                    && dfg.get_value_max_num_bits(self.lhs) == 1
+                {
+                    // Squaring a boolean value is a noop.
+                    return SimplifyResult::SimplifiedTo(self.lhs);
+                }
             }
             BinaryOp::Div => {
                 if rhs_is_one {
@@ -164,6 +170,22 @@ impl Binary {
                     let one = dfg.make_constant(FieldElement::one(), Type::bool());
                     return SimplifyResult::SimplifiedTo(one);
                 }
+
+                if operand_type.is_unsigned() {
+                    // If we're comparing a variable against a constant value which lies outside of the range of
+                    // values which the variable's type can take, we can assume that the equality will be false.
+                    let constant = lhs.or(rhs);
+                    let non_constant = if lhs.is_some() { self.rhs } else { self.lhs };
+                    if let Some(constant) = constant {
+                        let max_possible_value =
+                            2u128.pow(dfg.get_value_max_num_bits(non_constant)) - 1;
+                        if constant > max_possible_value.into() {
+                            let zero = dfg.make_constant(FieldElement::zero(), Type::bool());
+                            return SimplifyResult::SimplifiedTo(zero);
+                        }
+                    }
+                }
+
                 if operand_type == Type::bool() {
                     // Simplify forms of `(boolean == true)` into `boolean`
                     if lhs_is_one {

From 0d3d5fda9659a563ba9c2014b7c1af9e1d332ab0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 2 Apr 2024 09:44:05 -0500
Subject: [PATCH 134/416] fix: Last use analysis & make it an SSA pass (#4686)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4685

## Summary\*

Fixes some issues with the last_use analysis and makes it into a
dedicated SSA pass (after all other passes, only on 1 block acir
functions).

## Additional Context

One case I noticed where we don't make array sets mutable currently is
in parallel if branches:
```rs
    if array[0] == 1 {
        array[1] = 10;
    } else {
        array[1] = 20;
    }
```
Will produce the IR:
```rs
    v137 = array_get v0, index u64 0
    v138 = eq v137, Field 1
    enable_side_effects v138
    v139 = array_set v0, index u64 1, value Field 10
    v140 = not v138
    enable_side_effects v140
    v141 = array_set mut v0, index u64 1, value Field 20
    enable_side_effects u1 1
```
Note that with this change we can see the second array_set is mutable
and not the first. Fixing this isn't in the scope of this PR but this
could be a good future optimization.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa.rs           |   7 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  66 ++++-------
 .../src/ssa/function_builder/mod.rs           |   4 +-
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  16 ++-
 .../src/ssa/ir/instruction/call.rs            |   9 +-
 .../noirc_evaluator/src/ssa/ir/printer.rs     |  14 +--
 .../noirc_evaluator/src/ssa/opt/array_set.rs  | 104 ++++++++++++++++++
 .../noirc_evaluator/src/ssa/opt/array_use.rs  |  57 ----------
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |   2 +-
 9 files changed, 154 insertions(+), 125 deletions(-)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/array_set.rs
 delete mode 100644 compiler/noirc_evaluator/src/ssa/opt/array_use.rs

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 52377d36b36..a45cf3af608 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -63,17 +63,14 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::fold_constants, "After Constant Folding:")
         .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
         .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
+        .run_pass(Ssa::array_set_optimization, "After Array Set Optimizations:")
         .finish();
 
     let brillig = time("SSA to Brillig", print_timings, || ssa.to_brillig(print_brillig_trace));
 
     drop(ssa_gen_span_guard);
 
-    let last_array_uses = ssa.find_last_array_uses();
-
-    time("SSA to ACIR", print_timings, || {
-        ssa.into_acir(&brillig, abi_distinctness, &last_array_uses)
-    })
+    time("SSA to ACIR", print_timings, || ssa.into_acir(&brillig, abi_distinctness))
 }
 
 // Helper to time SSA passes
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 96f959612af..46b0318d5de 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -181,15 +181,12 @@ impl Ssa {
         self,
         brillig: &Brillig,
         abi_distinctness: Distinctness,
-        last_array_uses: &HashMap<ValueId, InstructionId>,
     ) -> Result<Vec<GeneratedAcir>, RuntimeError> {
         let mut acirs = Vec::new();
         // TODO: can we parallelise this?
         for function in self.functions.values() {
             let context = Context::new();
-            if let Some(generated_acir) =
-                context.convert_ssa_function(&self, function, brillig, last_array_uses)?
-            {
+            if let Some(generated_acir) = context.convert_ssa_function(&self, function, brillig)? {
                 acirs.push(generated_acir);
             }
         }
@@ -245,7 +242,6 @@ impl Context {
         ssa: &Ssa,
         function: &Function,
         brillig: &Brillig,
-        last_array_uses: &HashMap<ValueId, InstructionId>,
     ) -> Result<Option<GeneratedAcir>, RuntimeError> {
         match function.runtime() {
             RuntimeType::Acir(inline_type) => {
@@ -258,7 +254,7 @@ impl Context {
                     }
                 }
                 // We only want to convert entry point functions. This being `main` and those marked with `#[fold]`
-                Ok(Some(self.convert_acir_main(function, ssa, brillig, last_array_uses)?))
+                Ok(Some(self.convert_acir_main(function, ssa, brillig)?))
             }
             RuntimeType::Brillig => {
                 if function.id() == ssa.main_id {
@@ -275,7 +271,6 @@ impl Context {
         main_func: &Function,
         ssa: &Ssa,
         brillig: &Brillig,
-        last_array_uses: &HashMap<ValueId, InstructionId>,
     ) -> Result<GeneratedAcir, RuntimeError> {
         let dfg = &main_func.dfg;
         let entry_block = &dfg[main_func.entry_block()];
@@ -284,13 +279,7 @@ impl Context {
         self.data_bus = dfg.data_bus.to_owned();
         let mut warnings = Vec::new();
         for instruction_id in entry_block.instructions() {
-            warnings.extend(self.convert_ssa_instruction(
-                *instruction_id,
-                dfg,
-                ssa,
-                brillig,
-                last_array_uses,
-            )?);
+            warnings.extend(self.convert_ssa_instruction(*instruction_id, dfg, ssa, brillig)?);
         }
 
         warnings.extend(self.convert_ssa_return(entry_block.unwrap_terminator(), dfg)?);
@@ -463,7 +452,6 @@ impl Context {
         dfg: &DataFlowGraph,
         ssa: &Ssa,
         brillig: &Brillig,
-        last_array_uses: &HashMap<ValueId, InstructionId>,
     ) -> Result<Vec<SsaReport>, RuntimeError> {
         let instruction = &dfg[instruction_id];
         self.acir_context.set_call_stack(dfg.get_call_stack(instruction_id));
@@ -523,7 +511,7 @@ impl Context {
                 self.current_side_effects_enabled_var = acir_var;
             }
             Instruction::ArrayGet { .. } | Instruction::ArraySet { .. } => {
-                self.handle_array_operation(instruction_id, dfg, last_array_uses)?;
+                self.handle_array_operation(instruction_id, dfg)?;
             }
             Instruction::Allocate => {
                 unreachable!("Expected all allocate instructions to be removed before acir_gen")
@@ -721,12 +709,16 @@ impl Context {
         &mut self,
         instruction: InstructionId,
         dfg: &DataFlowGraph,
-        last_array_uses: &HashMap<ValueId, InstructionId>,
     ) -> Result<(), RuntimeError> {
+        let mut mutable_array_set = false;
+
         // Pass the instruction between array methods rather than the internal fields themselves
         let (array, index, store_value) = match dfg[instruction] {
             Instruction::ArrayGet { array, index } => (array, index, None),
-            Instruction::ArraySet { array, index, value, .. } => (array, index, Some(value)),
+            Instruction::ArraySet { array, index, value, mutable } => {
+                mutable_array_set = mutable;
+                (array, index, Some(value))
+            }
             _ => {
                 return Err(InternalError::Unexpected {
                     expected: "Instruction should be an ArrayGet or ArraySet".to_owned(),
@@ -744,11 +736,8 @@ impl Context {
         let (new_index, new_value) =
             self.convert_array_operation_inputs(array, dfg, index, store_value)?;
 
-        let resolved_array = dfg.resolve(array);
-        let map_array = last_array_uses.get(&resolved_array) == Some(&instruction);
-
         if let Some(new_value) = new_value {
-            self.array_set(instruction, new_index, new_value, dfg, map_array)?;
+            self.array_set(instruction, new_index, new_value, dfg, mutable_array_set)?;
         } else {
             self.array_get(instruction, array, new_index, dfg)?;
         }
@@ -1028,16 +1017,18 @@ impl Context {
         }
     }
 
-    /// Copy the array and generates a write opcode on the new array
-    ///
-    /// Note: Copying the array is inefficient and is not the way we want to do it in the end.
+    /// If `mutate_array` is:
+    /// - true: Mutate the array directly
+    /// - false: Copy the array and generates a write opcode on the new array. This is
+    ///          generally very inefficient and should be avoided if possible. Currently
+    ///          this is controlled by SSA's array set optimization pass.
     fn array_set(
         &mut self,
         instruction: InstructionId,
         mut var_index: AcirVar,
         store_value: AcirValue,
         dfg: &DataFlowGraph,
-        map_array: bool,
+        mutate_array: bool,
     ) -> Result<(), RuntimeError> {
         // Pass the instruction between array methods rather than the internal fields themselves
         let array = match dfg[instruction] {
@@ -1075,7 +1066,7 @@ impl Context {
             .first()
             .expect("Array set does not have one result");
         let result_block_id;
-        if map_array {
+        if mutate_array {
             self.memory_blocks.insert(*result_id, block_id);
             result_block_id = block_id;
         } else {
@@ -2401,14 +2392,13 @@ mod test {
         ssa::{
             function_builder::FunctionBuilder,
             ir::{
-                function::{FunctionId, InlineType, RuntimeType},
+                function::{FunctionId, InlineType},
                 instruction::BinaryOp,
                 map::Id,
                 types::Type,
             },
         },
     };
-    use fxhash::FxHashMap as HashMap;
 
     fn build_basic_foo_with_return(builder: &mut FunctionBuilder, foo_id: FunctionId) {
         // acir(fold) fn foo f1 {
@@ -2461,11 +2451,7 @@ mod test {
         let ssa = builder.finish();
 
         let acir_functions = ssa
-            .into_acir(
-                &Brillig::default(),
-                noirc_frontend::Distinctness::Distinct,
-                &HashMap::default(),
-            )
+            .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
         // Expected result:
         // main f0
@@ -2564,11 +2550,7 @@ mod test {
         let ssa = builder.finish();
 
         let acir_functions = ssa
-            .into_acir(
-                &Brillig::default(),
-                noirc_frontend::Distinctness::Distinct,
-                &HashMap::default(),
-            )
+            .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
         // The expected result should look very similar to the abvoe test expect that the input witnesses of the `Call`
         // opcodes will be different. The changes can discerned from the checks below.
@@ -2659,11 +2641,7 @@ mod test {
         let ssa = builder.finish();
 
         let acir_functions = ssa
-            .into_acir(
-                &Brillig::default(),
-                noirc_frontend::Distinctness::Distinct,
-                &HashMap::default(),
-            )
+            .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 3, "Should have three ACIR functions");
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index e0e60b737ad..d3e5e506111 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -310,7 +310,8 @@ impl FunctionBuilder {
         index: ValueId,
         value: ValueId,
     ) -> ValueId {
-        self.insert_instruction(Instruction::ArraySet { array, index, value }, None).first()
+        self.insert_instruction(Instruction::ArraySet { array, index, value, mutable: false }, None)
+            .first()
     }
 
     /// Insert an instruction to increment an array's reference count. This only has an effect
@@ -500,7 +501,6 @@ mod tests {
     use acvm::FieldElement;
 
     use crate::ssa::ir::{
-        function::{InlineType, RuntimeType},
         instruction::{Endian, Intrinsic},
         map::Id,
         types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index a887b279970..2b23cc1c1e8 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -189,8 +189,9 @@ pub(crate) enum Instruction {
     ArrayGet { array: ValueId, index: ValueId },
 
     /// Creates a new array with the new value at the given index. All other elements are identical
-    /// to those in the given array. This will not modify the original array.
-    ArraySet { array: ValueId, index: ValueId, value: ValueId },
+    /// to those in the given array. This will not modify the original array unless `mutable` is
+    /// set. This flag is off by default and only enabled when optimizations determine it is safe.
+    ArraySet { array: ValueId, index: ValueId, value: ValueId, mutable: bool },
 
     /// An instruction to increment the reference count of a value.
     ///
@@ -363,9 +364,12 @@ impl Instruction {
             Instruction::ArrayGet { array, index } => {
                 Instruction::ArrayGet { array: f(*array), index: f(*index) }
             }
-            Instruction::ArraySet { array, index, value } => {
-                Instruction::ArraySet { array: f(*array), index: f(*index), value: f(*value) }
-            }
+            Instruction::ArraySet { array, index, value, mutable } => Instruction::ArraySet {
+                array: f(*array),
+                index: f(*index),
+                value: f(*value),
+                mutable: *mutable,
+            },
             Instruction::IncrementRc { value } => Instruction::IncrementRc { value: f(*value) },
             Instruction::DecrementRc { value } => Instruction::DecrementRc { value: f(*value) },
             Instruction::RangeCheck { value, max_bit_size, assert_message } => {
@@ -416,7 +420,7 @@ impl Instruction {
                 f(*array);
                 f(*index);
             }
-            Instruction::ArraySet { array, index, value } => {
+            Instruction::ArraySet { array, index, value, mutable: _ } => {
                 f(*array);
                 f(*index);
                 f(*value);
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index a2847146087..1187ea8cb07 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -339,8 +339,13 @@ fn simplify_slice_push_back(
     let element_size = element_type.element_size();
     let new_slice = dfg.make_array(slice, element_type);
 
-    let set_last_slice_value_instr =
-        Instruction::ArraySet { array: new_slice, index: arguments[0], value: arguments[2] };
+    let set_last_slice_value_instr = Instruction::ArraySet {
+        array: new_slice,
+        index: arguments[0],
+        value: arguments[2],
+        mutable: false,
+    };
+
     let set_last_slice_value = dfg
         .insert_instruction_and_results(set_last_slice_value_instr, block, None, call_stack)
         .first();
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 6ef618fba6f..fc13ab7307a 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -176,14 +176,12 @@ fn display_instruction_inner(
         Instruction::ArrayGet { array, index } => {
             writeln!(f, "array_get {}, index {}", show(*array), show(*index))
         }
-        Instruction::ArraySet { array, index, value } => {
-            writeln!(
-                f,
-                "array_set {}, index {}, value {}",
-                show(*array),
-                show(*index),
-                show(*value)
-            )
+        Instruction::ArraySet { array, index, value, mutable } => {
+            let array = show(*array);
+            let index = show(*index);
+            let value = show(*value);
+            let mutable = if *mutable { " mut" } else { "" };
+            writeln!(f, "array_set{mutable} {array}, index {index}, value {value}",)
         }
         Instruction::IncrementRc { value } => {
             writeln!(f, "inc_rc {}", show(*value))
diff --git a/compiler/noirc_evaluator/src/ssa/opt/array_set.rs b/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
new file mode 100644
index 00000000000..cf61d7fd73f
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
@@ -0,0 +1,104 @@
+use crate::ssa::{
+    ir::{
+        basic_block::BasicBlockId,
+        dfg::DataFlowGraph,
+        instruction::{Instruction, InstructionId},
+        types::Type::{Array, Slice},
+    },
+    ssa_gen::Ssa,
+};
+use fxhash::{FxHashMap as HashMap, FxHashSet};
+
+impl Ssa {
+    /// Map arrays with the last instruction that uses it
+    /// For this we simply process all the instructions in execution order
+    /// and update the map whenever there is a match
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn array_set_optimization(mut self) -> Self {
+        for func in self.functions.values_mut() {
+            if !func.runtime().is_entry_point() {
+                let mut reachable_blocks = func.reachable_blocks();
+                assert_eq!(reachable_blocks.len(), 1, "Expected there to be 1 block remaining in Acir function for array_set optimization");
+
+                let block = reachable_blocks.pop_first().unwrap();
+                let instructions_to_update = analyze_last_uses(&func.dfg, block);
+                make_mutable(&mut func.dfg, block, instructions_to_update);
+            }
+        }
+        self
+    }
+}
+
+/// Returns the set of ArraySet instructions that can be made mutable
+/// because their input value is unused elsewhere afterward.
+fn analyze_last_uses(dfg: &DataFlowGraph, block_id: BasicBlockId) -> FxHashSet<InstructionId> {
+    let block = &dfg[block_id];
+    let mut array_to_last_use = HashMap::default();
+    let mut instructions_that_can_be_made_mutable = FxHashSet::default();
+
+    for instruction_id in block.instructions() {
+        match &dfg[*instruction_id] {
+            Instruction::ArrayGet { array, .. } => {
+                let array = dfg.resolve(*array);
+
+                if let Some(existing) = array_to_last_use.insert(array, *instruction_id) {
+                    instructions_that_can_be_made_mutable.remove(&existing);
+                }
+            }
+            Instruction::ArraySet { array, .. } => {
+                let array = dfg.resolve(*array);
+
+                if let Some(existing) = array_to_last_use.insert(array, *instruction_id) {
+                    instructions_that_can_be_made_mutable.remove(&existing);
+                }
+                instructions_that_can_be_made_mutable.insert(*instruction_id);
+            }
+            Instruction::Call { arguments, .. } => {
+                for argument in arguments {
+                    if matches!(dfg.type_of_value(*argument), Array { .. } | Slice { .. }) {
+                        let argument = dfg.resolve(*argument);
+
+                        if let Some(existing) = array_to_last_use.insert(argument, *instruction_id)
+                        {
+                            instructions_that_can_be_made_mutable.remove(&existing);
+                        }
+                    }
+                }
+            }
+            _ => (),
+        }
+    }
+
+    instructions_that_can_be_made_mutable
+}
+
+/// Make each ArraySet instruction in `instructions_to_update` mutable.
+fn make_mutable(
+    dfg: &mut DataFlowGraph,
+    block_id: BasicBlockId,
+    instructions_to_update: FxHashSet<InstructionId>,
+) {
+    if instructions_to_update.is_empty() {
+        return;
+    }
+
+    // Take the instructions temporarily so we can mutate the DFG while we iterate through them
+    let block = &mut dfg[block_id];
+    let instructions = block.take_instructions();
+
+    for instruction in &instructions {
+        if instructions_to_update.contains(instruction) {
+            let instruction = &mut dfg[*instruction];
+
+            if let Instruction::ArraySet { mutable, .. } = instruction {
+                *mutable = true;
+            } else {
+                unreachable!(
+                    "Non-ArraySet instruction in instructions_to_update!\n{instruction:?}"
+                );
+            }
+        }
+    }
+
+    *dfg[block_id].instructions_mut() = instructions;
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/array_use.rs b/compiler/noirc_evaluator/src/ssa/opt/array_use.rs
deleted file mode 100644
index 0bb8b0112b6..00000000000
--- a/compiler/noirc_evaluator/src/ssa/opt/array_use.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::ssa::{
-    ir::{
-        basic_block::BasicBlockId,
-        dfg::DataFlowGraph,
-        instruction::{Instruction, InstructionId},
-        post_order::PostOrder,
-        value::{Value, ValueId},
-    },
-    ssa_gen::Ssa,
-};
-use fxhash::FxHashMap as HashMap;
-
-impl Ssa {
-    /// Map arrays with the last instruction that uses it
-    /// For this we simply process all the instructions in execution order
-    /// and update the map whenever there is a match
-    #[tracing::instrument(level = "trace", skip(self))]
-    pub(crate) fn find_last_array_uses(&self) -> HashMap<ValueId, InstructionId> {
-        let mut array_use = HashMap::default();
-        for func in self.functions.values() {
-            let mut reverse_post_order = PostOrder::with_function(func).into_vec();
-            reverse_post_order.reverse();
-            for block in reverse_post_order {
-                last_use(block, &func.dfg, &mut array_use);
-            }
-        }
-        array_use
-    }
-}
-
-/// Updates the array_def map when an instructions is using an array
-fn last_use(
-    block_id: BasicBlockId,
-    dfg: &DataFlowGraph,
-    array_def: &mut HashMap<ValueId, InstructionId>,
-) {
-    let block = &dfg[block_id];
-    for instruction_id in block.instructions() {
-        match &dfg[*instruction_id] {
-            Instruction::ArrayGet { array, .. } | Instruction::ArraySet { array, .. } => {
-                let array = dfg.resolve(*array);
-                array_def.insert(array, *instruction_id);
-            }
-            Instruction::Call { arguments, .. } => {
-                for argument in arguments {
-                    let resolved_arg = dfg.resolve(*argument);
-                    if matches!(dfg[resolved_arg], Value::Array { .. }) {
-                        array_def.insert(resolved_arg, *instruction_id);
-                    }
-                }
-            }
-            _ => {
-                // Nothing to do
-            }
-        }
-    }
-}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index 8f98b3fb17f..479010b1ed8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -3,7 +3,7 @@
 //! Each pass is generally expected to mutate the SSA IR into a gradually
 //! simpler form until the IR only has a single function remaining with 1 block within it.
 //! Generally, these passes are also expected to minimize the final amount of instructions.
-mod array_use;
+mod array_set;
 mod assert_constant;
 mod bubble_up_constrains;
 mod constant_folding;

From 6ee645ad0d0d4f5806c137d736cd787d453a02fc Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 2 Apr 2024 18:37:45 +0100
Subject: [PATCH 135/416] chore: fix clippy errors (#4684)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR fixes a bunch of clippy errors some new, some old.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../bn254_blackbox_solver/src/wasm/mod.rs     |  2 +-
 acvm-repo/brillig_vm/src/black_box.rs         |  5 +-
 acvm-repo/brillig_vm/src/lib.rs               | 75 ++++---------------
 .../compute_note_hash_and_nullifier.rs        |  4 +-
 .../src/brillig/brillig_ir/artifact.rs        |  2 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 15 ++--
 compiler/noirc_evaluator/src/ssa/ir/dom.rs    |  9 +--
 .../noirc_evaluator/src/ssa/ir/post_order.rs  |  7 +-
 .../src/ssa/opt/bubble_up_constrains.rs       |  1 -
 .../src/ssa/opt/constant_folding.rs           |  1 -
 compiler/noirc_evaluator/src/ssa/opt/die.rs   |  1 -
 .../src/ssa/opt/flatten_cfg.rs                |  2 +-
 .../ssa/opt/flatten_cfg/branch_analysis.rs    |  7 +-
 .../noirc_evaluator/src/ssa/opt/inlining.rs   |  2 +-
 .../noirc_evaluator/src/ssa/opt/mem2reg.rs    |  1 -
 compiler/noirc_evaluator/src/ssa/opt/rc.rs    |  8 +-
 .../src/ssa/opt/simplify_cfg.rs               |  1 -
 .../noirc_evaluator/src/ssa/opt/unrolling.rs  |  7 +-
 compiler/noirc_frontend/src/lexer/lexer.rs    |  2 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  2 +-
 .../src/parser/parser/literals.rs             |  1 +
 tooling/debugger/src/context.rs               |  7 +-
 tooling/debugger/src/foreign_calls.rs         |  2 +-
 tooling/nargo/src/artifacts/debug_vars.rs     |  4 +-
 tooling/nargo_fmt/build.rs                    |  4 +-
 25 files changed, 43 insertions(+), 129 deletions(-)

diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
index 10b1ab22a8d..3c867ae48dd 100644
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
@@ -45,7 +45,7 @@ pub(crate) struct BackendError(#[from] Error);
 
 impl From<FeatureError> for BackendError {
     fn from(value: FeatureError) -> Self {
-        value.into()
+        BackendError(Error::FromFeature(value))
     }
 }
 
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index ab4358739e9..bd33b5ee8fc 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -256,10 +256,11 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
 #[cfg(test)]
 mod test {
     use acir::brillig::{BlackBoxOp, MemoryAddress};
+    use acvm_blackbox_solver::StubbedBlackBoxSolver;
 
     use crate::{
         black_box::{evaluate_black_box, to_u8_vec, to_value_vec},
-        DummyBlackBoxSolver, HeapArray, HeapVector, Memory,
+        HeapArray, HeapVector, Memory,
     };
 
     #[test]
@@ -280,7 +281,7 @@ mod test {
             output: HeapArray { pointer: 2.into(), size: 32 },
         };
 
-        evaluate_black_box(&op, &DummyBlackBoxSolver, &mut memory).unwrap();
+        evaluate_black_box(&op, &StubbedBlackBoxSolver, &mut memory).unwrap();
 
         let result = memory.read_slice(MemoryAddress(result_pointer), 32);
 
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 0f430b0d5b2..65654e24720 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -16,7 +16,7 @@ use acir::brillig::{
     HeapVector, MemoryAddress, Opcode, ValueOrArray,
 };
 use acir::FieldElement;
-use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
+use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
 use black_box::evaluate_black_box;
 use num_bigint::BigUint;
@@ -593,59 +593,10 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     }
 }
 
-pub(crate) struct DummyBlackBoxSolver;
-
-impl BlackBoxFunctionSolver for DummyBlackBoxSolver {
-    fn schnorr_verify(
-        &self,
-        _public_key_x: &FieldElement,
-        _public_key_y: &FieldElement,
-        _signature: &[u8],
-        _message: &[u8],
-    ) -> Result<bool, BlackBoxResolutionError> {
-        Ok(true)
-    }
-    fn pedersen_commitment(
-        &self,
-        _inputs: &[FieldElement],
-        _domain_separator: u32,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((2_u128.into(), 3_u128.into()))
-    }
-    fn pedersen_hash(
-        &self,
-        _inputs: &[FieldElement],
-        _domain_separator: u32,
-    ) -> Result<FieldElement, BlackBoxResolutionError> {
-        Ok(6_u128.into())
-    }
-    fn fixed_base_scalar_mul(
-        &self,
-        _low: &FieldElement,
-        _high: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((4_u128.into(), 5_u128.into()))
-    }
-    fn ec_add(
-        &self,
-        _input1_x: &FieldElement,
-        _input1_y: &FieldElement,
-        _input2_x: &FieldElement,
-        _input2_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((5_u128.into(), 6_u128.into()))
-    }
-    fn poseidon2_permutation(
-        &self,
-        _input: &[FieldElement],
-        len: u32,
-    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
-        Ok(vec![0_u128.into(); len as usize])
-    }
-}
-
 #[cfg(test)]
 mod tests {
+    use acvm_blackbox_solver::StubbedBlackBoxSolver;
+
     use super::*;
 
     #[test]
@@ -662,7 +613,7 @@ mod tests {
 
         // Start VM
         let opcodes = [calldata_copy];
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
 
         // Process a single VM opcode
         //
@@ -706,7 +657,7 @@ mod tests {
         opcodes.push(Opcode::Jump { location: 3 });
         opcodes.push(Opcode::JumpIf { condition: destination, location: 4 });
 
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -763,7 +714,7 @@ mod tests {
             jump_if_not_opcode,
             add_opcode,
         ];
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
@@ -811,7 +762,7 @@ mod tests {
             },
             Opcode::Stop { return_data_offset: 1, return_data_size: 1 },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -842,7 +793,7 @@ mod tests {
             Opcode::Mov { destination: MemoryAddress::from(2), source: MemoryAddress::from(0) };
 
         let opcodes = &[calldata_copy, mov_opcode];
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -898,7 +849,7 @@ mod tests {
                 condition: MemoryAddress(1),
             },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -981,7 +932,7 @@ mod tests {
             .chain(cast_opcodes)
             .chain([equal_opcode, not_equal_opcode, less_than_opcode, less_than_equal_opcode])
             .collect();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
 
         // Calldata copy
         let status = vm.process_opcode();
@@ -1276,14 +1227,14 @@ mod tests {
     fn brillig_execute_and_get_vm(
         calldata: Vec<FieldElement>,
         opcodes: &[Opcode],
-    ) -> VM<'_, DummyBlackBoxSolver> {
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+    ) -> VM<'_, StubbedBlackBoxSolver> {
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
         brillig_execute(&mut vm);
         assert_eq!(vm.call_stack, vec![]);
         vm
     }
 
-    fn brillig_execute(vm: &mut VM<DummyBlackBoxSolver>) {
+    fn brillig_execute(vm: &mut VM<StubbedBlackBoxSolver>) {
         loop {
             let status = vm.process_opcode();
             if matches!(status, VMStatus::Finished { .. } | VMStatus::ForeignCallWait { .. }) {
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index fd538dc578b..1f5681ed470 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -127,7 +127,7 @@ pub fn inject_compute_note_hash_and_nullifier(
     Ok(())
 }
 
-fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFunction {
+fn generate_compute_note_hash_and_nullifier(note_types: &[String]) -> NoirFunction {
     let function_source = generate_compute_note_hash_and_nullifier_source(note_types);
 
     let (function_ast, errors) = parse_program(&function_source);
@@ -140,7 +140,7 @@ fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFun
     function_ast.functions.remove(0)
 }
 
-fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) -> String {
+fn generate_compute_note_hash_and_nullifier_source(note_types: &[String]) -> String {
     // TODO(#4649): The serialized_note parameter is a fixed-size array, but we don't know what length it should have.
     // For now we hardcode it to 20, which is the same as MAX_NOTE_FIELDS_LENGTH.
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index d10dcf13d9f..90a5d54ae59 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -108,7 +108,7 @@ impl BrilligArtifact {
         self.byte_code.append(&mut byte_code);
 
         // Remove all resolved external calls and transform them to jumps
-        let is_resolved = |label: &Label| self.labels.get(label).is_some();
+        let is_resolved = |label: &Label| self.labels.contains_key(label);
 
         let resolved_external_calls = self
             .unresolved_external_call_labels
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 46b0318d5de..e3dd4c33986 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -2502,16 +2502,13 @@ mod test {
         check_call_opcode(&main_opcodes[0], 1, vec![Witness(0), Witness(1)], vec![Witness(2)]);
         check_call_opcode(&main_opcodes[1], 1, vec![Witness(0), Witness(1)], vec![Witness(3)]);
 
-        match &main_opcodes[2] {
-            Opcode::AssertZero(expr) => {
-                assert_eq!(expr.linear_combinations[0].0, FieldElement::from(1u128));
-                assert_eq!(expr.linear_combinations[0].1, Witness(2));
+        if let Opcode::AssertZero(expr) = &main_opcodes[2] {
+            assert_eq!(expr.linear_combinations[0].0, FieldElement::from(1u128));
+            assert_eq!(expr.linear_combinations[0].1, Witness(2));
 
-                assert_eq!(expr.linear_combinations[1].0, FieldElement::from(-1i128));
-                assert_eq!(expr.linear_combinations[1].1, Witness(3));
-                assert_eq!(expr.q_c, FieldElement::from(0u128));
-            }
-            _ => {}
+            assert_eq!(expr.linear_combinations[1].0, FieldElement::from(-1i128));
+            assert_eq!(expr.linear_combinations[1].1, Witness(3));
+            assert_eq!(expr.q_c, FieldElement::from(0u128));
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dom.rs b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
index bd1481a7474..15fa3bad38d 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dom.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
@@ -249,13 +249,8 @@ mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            basic_block::BasicBlockId,
-            dfg::CallStack,
-            dom::DominatorTree,
-            function::{Function, InlineType, RuntimeType},
-            instruction::TerminatorInstruction,
-            map::Id,
-            types::Type,
+            basic_block::BasicBlockId, dfg::CallStack, dom::DominatorTree, function::Function,
+            instruction::TerminatorInstruction, map::Id, types::Type,
         },
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
index 5d743e953a5..d95ec451779 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
@@ -73,12 +73,7 @@ impl PostOrder {
 mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{
-            function::{Function, InlineType, RuntimeType},
-            map::Id,
-            post_order::PostOrder,
-            types::Type,
-        },
+        ir::{function::Function, map::Id, post_order::PostOrder, types::Type},
     };
 
     #[test]
diff --git a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
index 6d556e86cb5..0409f0e6a49 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
@@ -77,7 +77,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{Binary, BinaryOp, Instruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index 88948331960..6cac8c91bc3 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -283,7 +283,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{Binary, BinaryOp, Instruction, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index df89dcb716d..d1b3e1e83f5 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -169,7 +169,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Intrinsic},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index e731a7952a6..07771397ce8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -841,7 +841,7 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             dfg::DataFlowGraph,
-            function::{Function, InlineType, RuntimeType},
+            function::Function,
             instruction::{BinaryOp, Instruction, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
index adb6d2871e5..ce54bb533f7 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
@@ -114,12 +114,7 @@ mod test {
 
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{
-            cfg::ControlFlowGraph,
-            function::{InlineType, RuntimeType},
-            map::Id,
-            types::Type,
-        },
+        ir::{cfg::ControlFlowGraph, map::Id, types::Type},
         opt::flatten_cfg::branch_analysis::find_branch_ends,
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 63c78b99cdf..ead3cac071c 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -522,7 +522,7 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             basic_block::BasicBlockId,
-            function::{InlineType, RuntimeType},
+            function::InlineType,
             instruction::{BinaryOp, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index f1a38585bd6..7b87142d824 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -414,7 +414,6 @@ mod tests {
         ir::{
             basic_block::BasicBlockId,
             dfg::DataFlowGraph,
-            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Instruction, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/rc.rs b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
index 7b5196f2004..1561547e32e 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/rc.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
@@ -166,12 +166,8 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            basic_block::BasicBlockId,
-            dfg::DataFlowGraph,
-            function::{InlineType, RuntimeType},
-            instruction::Instruction,
-            map::Id,
-            types::Type,
+            basic_block::BasicBlockId, dfg::DataFlowGraph, function::RuntimeType,
+            instruction::Instruction, map::Id, types::Type,
         },
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index b9675d99c90..f524b10f1f2 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -154,7 +154,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 92ec1e8f1bb..8110e3469f1 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -464,12 +464,7 @@ impl<'f> LoopIteration<'f> {
 mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{
-            function::{InlineType, RuntimeType},
-            instruction::BinaryOp,
-            map::Id,
-            types::Type,
-        },
+        ir::{instruction::BinaryOp, map::Id, types::Type},
     };
 
     #[test]
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index c4b6bb288dc..cb21f58e58b 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -1178,7 +1178,7 @@ mod tests {
                                     .as_ref()
                                     .map(|token_discriminator| {
                                         discriminant(token_discriminator)
-                                            == discriminant(&next_token.token())
+                                            == discriminant(next_token.token())
                                     })
                                     .unwrap_or(true);
 
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 7ecff12163a..cdfa16400ae 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1242,7 +1242,7 @@ where
 mod test {
     use super::test_helpers::*;
     use super::*;
-    use crate::{ArrayLiteral, Literal};
+    use crate::ArrayLiteral;
 
     #[test]
     fn parse_infix() {
diff --git a/compiler/noirc_frontend/src/parser/parser/literals.rs b/compiler/noirc_frontend/src/parser/parser/literals.rs
index 32f4f03de2e..83d7b832d27 100644
--- a/compiler/noirc_frontend/src/parser/parser/literals.rs
+++ b/compiler/noirc_frontend/src/parser/parser/literals.rs
@@ -105,6 +105,7 @@ mod test {
             Case { source: r#" r#"foo" "#, expect: "(none)", errors: 2 },
             // empty string
             Case { source: r#"r"""#, expect: r#"r"""#, errors: 0 },
+            #[allow(clippy::needless_raw_string_hashes)]
             Case { source: r####"r###""###"####, expect: r####"r###""###"####, errors: 0 },
             // miscellaneous
             Case { source: r##" r#\"foo\"# "##, expect: "plain::r", errors: 2 },
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index ba12a20460d..1acd581b2be 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -128,9 +128,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         line: i64,
     ) -> Option<OpcodeLocation> {
         let line = line as usize;
-        let Some(line_to_opcodes) = self.source_to_opcodes.get(file_id) else {
-            return None;
-        };
+        let line_to_opcodes = self.source_to_opcodes.get(file_id)?;
         let found_index = match line_to_opcodes.binary_search_by(|x| x.0.cmp(&line)) {
             Ok(index) => {
                 // move backwards to find the first opcode which matches the line
@@ -631,7 +629,6 @@ fn build_source_to_opcode_debug_mappings(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::context::{DebugCommandResult, DebugContext};
 
     use crate::foreign_calls::DefaultDebugForeignCallExecutor;
     use acvm::{
@@ -647,8 +644,6 @@ mod tests {
             BinaryFieldOp, HeapValueType, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray,
         },
     };
-    use nargo::artifacts::debug::DebugArtifact;
-    use std::collections::BTreeMap;
 
     #[test]
     fn test_resolve_foreign_calls_stepping_into_brillig() {
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index aae2212fd54..f11ac22cd75 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -65,7 +65,7 @@ impl DefaultDebugForeignCallExecutor {
     pub fn load_artifact(&mut self, artifact: &DebugArtifact) {
         // TODO: handle loading from the correct DebugInfo when we support
         // debugging contracts
-        let Some(info) = artifact.debug_symbols.get(0) else {
+        let Some(info) = artifact.debug_symbols.first() else {
             return;
         };
         self.debug_vars.insert_debug_info(info);
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 8e5c2bc46a4..6a42a4c3311 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -36,9 +36,7 @@ impl DebugVars {
 
     fn lookup_var(&self, var_id: DebugVarId) -> Option<(&str, &PrintableType)> {
         self.variables.get(&var_id).and_then(|debug_var| {
-            let Some(ptype) = self.types.get(&debug_var.debug_type_id) else {
-                return None;
-            };
+            let ptype = self.types.get(&debug_var.debug_type_id)?;
             Some((debug_var.name.as_str(), ptype))
         })
     }
diff --git a/tooling/nargo_fmt/build.rs b/tooling/nargo_fmt/build.rs
index c356b403ae5..6f41768c1dc 100644
--- a/tooling/nargo_fmt/build.rs
+++ b/tooling/nargo_fmt/build.rs
@@ -58,10 +58,10 @@ fn format_{test_name}() {{
     let expected_output = r#"{output_source}"#;
 
 
-    let (parsed_module, _errors) = noirc_frontend::parse_program(&input);
+    let (parsed_module, _errors) = noirc_frontend::parse_program(input);
 
     let config = nargo_fmt::Config::of("{config}").unwrap();
-    let fmt_text = nargo_fmt::format(&input, parsed_module, &config);
+    let fmt_text = nargo_fmt::format(input, parsed_module, &config);
 
     if std::env::var("UPDATE_EXPECT").is_ok() {{
         std::fs::write("{output_source_path}", fmt_text.clone()).unwrap();

From 420e56d6ea3478301c2ff2f1adb3bcc9df6d1892 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 2 Apr 2024 18:49:01 +0100
Subject: [PATCH 136/416] chore: check for references to private functions
 during path resolution (#4622)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR pulls out the actual changes to path resolution from #4491,
omitting the changes which add visibility modifiers to modules.

We now determine whether a function is private (and so a warning or
error should be emitted) during def collection. This is necessary as to
properly determine whether a function is public or private we need
information on whether all the modules in the function's path relative
to where it's being used allow its contents to be used from this module
- information which doesn't exist in the typechecking pass.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/def_collector/dc_crate.rs         |  23 +-
 .../src/hir/resolution/errors.rs              |  13 +-
 .../src/hir/resolution/import.rs              | 231 ++++++++++++++----
 .../src/hir/resolution/path_resolver.rs       |  24 +-
 .../src/hir/resolution/resolver.rs            |  81 ++----
 .../src/hir/resolution/traits.rs              |  17 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  |   7 +-
 7 files changed, 243 insertions(+), 153 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 0c53bff4a54..90aa4baee7c 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -4,7 +4,7 @@ use crate::graph::CrateId;
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
 
-use crate::hir::resolution::import::{resolve_import, ImportDirective};
+use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
 use crate::hir::resolution::{
     collect_impls, collect_trait_impls, path_resolver, resolve_free_functions, resolve_globals,
     resolve_impls, resolve_structs, resolve_trait_by_path, resolve_trait_impls, resolve_traits,
@@ -56,8 +56,11 @@ impl UnresolvedFunctions {
             for bound in &mut func.def.where_clause {
                 match resolve_trait_by_path(def_maps, module, bound.trait_bound.trait_path.clone())
                 {
-                    Ok(trait_id) => {
+                    Ok((trait_id, warning)) => {
                         bound.trait_bound.trait_id = Some(trait_id);
+                        if let Some(warning) = warning {
+                            errors.push(DefCollectorErrorKind::PathResolutionError(warning));
+                        }
                     }
                     Err(err) => {
                         errors.push(err);
@@ -281,6 +284,13 @@ impl DefCollector {
         for collected_import in def_collector.collected_imports {
             match resolve_import(crate_id, &collected_import, &context.def_maps) {
                 Ok(resolved_import) => {
+                    if let Some(error) = resolved_import.error {
+                        errors.push((
+                            DefCollectorErrorKind::PathResolutionError(error).into(),
+                            root_file_id,
+                        ));
+                    }
+
                     // Populate module namespaces according to the imports used
                     let current_def_map = context.def_maps.get_mut(&crate_id).unwrap();
 
@@ -299,9 +309,9 @@ impl DefCollector {
                         }
                     }
                 }
-                Err((error, module_id)) => {
+                Err(error) => {
                     let current_def_map = context.def_maps.get(&crate_id).unwrap();
-                    let file_id = current_def_map.file_id(module_id);
+                    let file_id = current_def_map.file_id(collected_import.module_id);
                     let error = DefCollectorErrorKind::PathResolutionError(error);
                     errors.push((error.into(), file_id));
                 }
@@ -409,12 +419,13 @@ fn inject_prelude(
         Path { segments: segments.clone(), kind: crate::PathKind::Dep, span: Span::default() };
 
     if !crate_id.is_stdlib() {
-        if let Ok(module_def) = path_resolver::resolve_path(
+        if let Ok(PathResolution { module_def_id, error }) = path_resolver::resolve_path(
             &context.def_maps,
             ModuleId { krate: crate_id, local_id: crate_root },
             path,
         ) {
-            let module_id = module_def.as_module().expect("std::prelude should be a module");
+            assert!(error.is_none(), "Tried to add private item to prelude");
+            let module_id = module_def_id.as_module().expect("std::prelude should be a module");
             let prelude = context.module(module_id).scope().names();
 
             for path in prelude {
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 3c6c0582292..d5b0c612f90 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -25,7 +25,7 @@ pub enum ResolverError {
     #[error("path is not an identifier")]
     PathIsNotIdent { span: Span },
     #[error("could not resolve path")]
-    PathResolutionError(PathResolutionError),
+    PathResolutionError(#[from] PathResolutionError),
     #[error("Expected")]
     Expected { span: Span, expected: String, got: String },
     #[error("Duplicate field in constructor")]
@@ -72,10 +72,6 @@ pub enum ResolverError {
     NumericConstantInFormatString { name: String, span: Span },
     #[error("Closure environment must be a tuple or unit type")]
     InvalidClosureEnvironment { typ: Type, span: Span },
-    #[error("{name} is private and not visible from the current module")]
-    PrivateFunctionCalled { name: String, span: Span },
-    #[error("{name} is not visible from the current crate")]
-    NonCrateFunctionCalled { name: String, span: Span },
     #[error("Nested slices are not supported")]
     NestedSlices { span: Span },
     #[error("#[recursive] attribute is only allowed on entry points to a program")]
@@ -290,13 +286,6 @@ impl From<ResolverError> for Diagnostic {
             ResolverError::InvalidClosureEnvironment { span, typ } => Diagnostic::simple_error(
                 format!("{typ} is not a valid closure environment type"),
                 "Closure environment must be a tuple or unit type".to_string(), span),
-            // This will be upgraded to an error in future versions
-            ResolverError::PrivateFunctionCalled { span, name } => Diagnostic::simple_warning(
-                format!("{name} is private and not visible from the current module"),
-                format!("{name} is private"), span),
-            ResolverError::NonCrateFunctionCalled { span, name } => Diagnostic::simple_warning(
-                    format!("{name} is not visible from the current crate"),
-                    format!("{name} is only visible within its crate"), span),
             ResolverError::NestedSlices { span } => Diagnostic::simple_error(
                 "Nested slices are not supported".into(),
                 "Try to use a constant sized array instead".into(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index 9c8418daf80..ade97e2cf42 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -1,10 +1,11 @@
 use noirc_errors::{CustomDiagnostic, Span};
+use thiserror::Error;
 
 use crate::graph::CrateId;
 use std::collections::BTreeMap;
 
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleDefId, ModuleId, PerNs};
-use crate::{Ident, Path, PathKind};
+use crate::{Ident, ItemVisibility, Path, PathKind};
 
 #[derive(Debug, Clone)]
 pub struct ImportDirective {
@@ -14,12 +15,30 @@ pub struct ImportDirective {
     pub is_prelude: bool,
 }
 
-pub type PathResolution = Result<PerNs, PathResolutionError>;
+struct NamespaceResolution {
+    module_id: ModuleId,
+    namespace: PerNs,
+    error: Option<PathResolutionError>,
+}
+
+type NamespaceResolutionResult = Result<NamespaceResolution, PathResolutionError>;
+
+pub struct PathResolution {
+    pub module_def_id: ModuleDefId,
+
+    pub error: Option<PathResolutionError>,
+}
+
+pub(crate) type PathResolutionResult = Result<PathResolution, PathResolutionError>;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Error)]
 pub enum PathResolutionError {
+    #[error("Could not resolve '{0}' in path")]
     Unresolved(Ident),
+    #[error("Contract variable '{0}' referenced from outside the contract")]
     ExternalContractUsed(Ident),
+    #[error("{0} is private and not visible from the current module")]
+    Private(Ident),
 }
 
 #[derive(Debug)]
@@ -31,21 +50,26 @@ pub struct ResolvedImport {
     // The module which we must add the resolved namespace to
     pub module_scope: LocalModuleId,
     pub is_prelude: bool,
+    pub error: Option<PathResolutionError>,
 }
 
 impl From<PathResolutionError> for CustomDiagnostic {
     fn from(error: PathResolutionError) -> Self {
-        match error {
-            PathResolutionError::Unresolved(ident) => CustomDiagnostic::simple_error(
-                format!("Could not resolve '{ident}' in path"),
-                String::new(),
-                ident.span(),
-            ),
+        match &error {
+            PathResolutionError::Unresolved(ident) => {
+                CustomDiagnostic::simple_error(error.to_string(), String::new(), ident.span())
+            }
             PathResolutionError::ExternalContractUsed(ident) => CustomDiagnostic::simple_error(
-                format!("Contract variable '{ident}' referenced from outside the contract"),
+                error.to_string(),
                 "Contracts may only be referenced from within a contract".to_string(),
                 ident.span(),
             ),
+            // This will be upgraded to an error in future versions
+            PathResolutionError::Private(ident) => CustomDiagnostic::simple_warning(
+                error.to_string(),
+                format!("{ident} is private"),
+                ident.span(),
+            ),
         }
     }
 }
@@ -54,27 +78,49 @@ pub fn resolve_import(
     crate_id: CrateId,
     import_directive: &ImportDirective,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-) -> Result<ResolvedImport, (PathResolutionError, LocalModuleId)> {
-    let def_map = &def_maps[&crate_id];
-
+) -> Result<ResolvedImport, PathResolutionError> {
     let allow_contracts =
         allow_referencing_contracts(def_maps, crate_id, import_directive.module_id);
 
     let module_scope = import_directive.module_id;
-    let resolved_namespace =
-        resolve_path_to_ns(import_directive, def_map, def_maps, allow_contracts)
-            .map_err(|error| (error, module_scope))?;
+    let NamespaceResolution {
+        module_id: resolved_module,
+        namespace: resolved_namespace,
+        mut error,
+    } = resolve_path_to_ns(import_directive, crate_id, crate_id, def_maps, allow_contracts)?;
 
     let name = resolve_path_name(import_directive);
+
+    let visibility = resolved_namespace
+        .values
+        .or(resolved_namespace.types)
+        .map(|(_, visibility, _)| visibility)
+        .expect("Found empty namespace");
+
+    error = error.or_else(|| {
+        if can_reference_module_id(
+            def_maps,
+            crate_id,
+            import_directive.module_id,
+            resolved_module,
+            visibility,
+        ) {
+            None
+        } else {
+            Some(PathResolutionError::Private(name.clone()))
+        }
+    });
+
     Ok(ResolvedImport {
         name,
         resolved_namespace,
         module_scope,
         is_prelude: import_directive.is_prelude,
+        error,
     })
 }
 
-pub(super) fn allow_referencing_contracts(
+fn allow_referencing_contracts(
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     krate: CrateId,
     local_id: LocalModuleId,
@@ -82,27 +128,40 @@ pub(super) fn allow_referencing_contracts(
     ModuleId { krate, local_id }.module(def_maps).is_contract
 }
 
-pub fn resolve_path_to_ns(
+fn resolve_path_to_ns(
     import_directive: &ImportDirective,
-    def_map: &CrateDefMap,
+    crate_id: CrateId,
+    importing_crate: CrateId,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     allow_contracts: bool,
-) -> PathResolution {
+) -> NamespaceResolutionResult {
     let import_path = &import_directive.path.segments;
+    let def_map = &def_maps[&crate_id];
 
     match import_directive.path.kind {
         crate::ast::PathKind::Crate => {
             // Resolve from the root of the crate
-            resolve_path_from_crate_root(def_map, import_path, def_maps, allow_contracts)
-        }
-        crate::ast::PathKind::Dep => {
-            resolve_external_dep(def_map, import_directive, def_maps, allow_contracts)
+            resolve_path_from_crate_root(
+                crate_id,
+                importing_crate,
+                import_path,
+                def_maps,
+                allow_contracts,
+            )
         }
+        crate::ast::PathKind::Dep => resolve_external_dep(
+            def_map,
+            import_directive,
+            def_maps,
+            allow_contracts,
+            importing_crate,
+        ),
         crate::ast::PathKind::Plain => {
             // Plain paths are only used to import children modules. It's possible to allow import of external deps, but maybe this distinction is better?
             // In Rust they can also point to external Dependencies, if no children can be found with the specified name
             resolve_name_in_module(
-                def_map,
+                crate_id,
+                importing_crate,
                 import_path,
                 import_directive.module_id,
                 def_maps,
@@ -113,45 +172,60 @@ pub fn resolve_path_to_ns(
 }
 
 fn resolve_path_from_crate_root(
-    def_map: &CrateDefMap,
+    crate_id: CrateId,
+    importing_crate: CrateId,
+
     import_path: &[Ident],
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     allow_contracts: bool,
-) -> PathResolution {
-    resolve_name_in_module(def_map, import_path, def_map.root, def_maps, allow_contracts)
+) -> NamespaceResolutionResult {
+    resolve_name_in_module(
+        crate_id,
+        importing_crate,
+        import_path,
+        def_maps[&crate_id].root,
+        def_maps,
+        allow_contracts,
+    )
 }
 
 fn resolve_name_in_module(
-    def_map: &CrateDefMap,
+    krate: CrateId,
+    importing_crate: CrateId,
     import_path: &[Ident],
     starting_mod: LocalModuleId,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     allow_contracts: bool,
-) -> PathResolution {
-    let mut current_mod = &def_map.modules[starting_mod.0];
+) -> NamespaceResolutionResult {
+    let def_map = &def_maps[&krate];
+    let mut current_mod_id = ModuleId { krate, local_id: starting_mod };
+    let mut current_mod = &def_map.modules[current_mod_id.local_id.0];
 
     // There is a possibility that the import path is empty
     // In that case, early return
     if import_path.is_empty() {
-        let mod_id = ModuleId { krate: def_map.krate, local_id: starting_mod };
-        return Ok(PerNs::types(mod_id.into()));
+        return Ok(NamespaceResolution {
+            module_id: current_mod_id,
+            namespace: PerNs::types(current_mod_id.into()),
+            error: None,
+        });
     }
 
-    let mut import_path = import_path.iter();
-    let first_segment = import_path.next().expect("ice: could not fetch first segment");
+    let first_segment = import_path.first().expect("ice: could not fetch first segment");
     let mut current_ns = current_mod.find_name(first_segment);
     if current_ns.is_none() {
         return Err(PathResolutionError::Unresolved(first_segment.clone()));
     }
 
-    for segment in import_path {
-        let typ = match current_ns.take_types() {
-            None => return Err(PathResolutionError::Unresolved(segment.clone())),
-            Some(typ) => typ,
+    let mut warning: Option<PathResolutionError> = None;
+    for (last_segment, current_segment) in import_path.iter().zip(import_path.iter().skip(1)) {
+        let (typ, visibility) = match current_ns.types {
+            None => return Err(PathResolutionError::Unresolved(last_segment.clone())),
+            Some((typ, visibility, _)) => (typ, visibility),
         };
 
         // In the type namespace, only Mod can be used in a path.
-        let new_module_id = match typ {
+        current_mod_id = match typ {
             ModuleDefId::ModuleId(id) => id,
             ModuleDefId::FunctionId(_) => panic!("functions cannot be in the type namespace"),
             // TODO: If impls are ever implemented, types can be used in a path
@@ -161,22 +235,37 @@ fn resolve_name_in_module(
             ModuleDefId::GlobalId(_) => panic!("globals cannot be in the type namespace"),
         };
 
-        current_mod = &def_maps[&new_module_id.krate].modules[new_module_id.local_id.0];
+        warning = warning.or_else(|| {
+            if can_reference_module_id(
+                def_maps,
+                importing_crate,
+                starting_mod,
+                current_mod_id,
+                visibility,
+            ) {
+                None
+            } else {
+                Some(PathResolutionError::Private(last_segment.clone()))
+            }
+        });
+
+        current_mod = &def_maps[&current_mod_id.krate].modules[current_mod_id.local_id.0];
 
         // Check if namespace
-        let found_ns = current_mod.find_name(segment);
+        let found_ns = current_mod.find_name(current_segment);
 
         if found_ns.is_none() {
-            return Err(PathResolutionError::Unresolved(segment.clone()));
+            return Err(PathResolutionError::Unresolved(current_segment.clone()));
         }
+
         // Check if it is a contract and we're calling from a non-contract context
         if current_mod.is_contract && !allow_contracts {
-            return Err(PathResolutionError::ExternalContractUsed(segment.clone()));
+            return Err(PathResolutionError::ExternalContractUsed(current_segment.clone()));
         }
         current_ns = found_ns;
     }
 
-    Ok(current_ns)
+    Ok(NamespaceResolution { module_id: current_mod_id, namespace: current_ns, error: warning })
 }
 
 fn resolve_path_name(import_directive: &ImportDirective) -> Ident {
@@ -191,11 +280,11 @@ fn resolve_external_dep(
     directive: &ImportDirective,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     allow_contracts: bool,
-) -> PathResolution {
+    importing_crate: CrateId,
+) -> NamespaceResolutionResult {
     // Use extern_prelude to get the dep
-    //
     let path = &directive.path.segments;
-    //
+
     // Fetch the root module from the prelude
     let crate_name = path.first().unwrap();
     let dep_module = current_def_map
@@ -218,7 +307,49 @@ fn resolve_external_dep(
         is_prelude: false,
     };
 
-    let dep_def_map = def_maps.get(&dep_module.krate).unwrap();
+    resolve_path_to_ns(&dep_directive, dep_module.krate, importing_crate, def_maps, allow_contracts)
+}
+
+// Issue an error if the given private function is being called from a non-child module, or
+// if the given pub(crate) function is being called from another crate
+fn can_reference_module_id(
+    def_maps: &BTreeMap<CrateId, CrateDefMap>,
+    importing_crate: CrateId,
+    current_module: LocalModuleId,
+    target_module: ModuleId,
+    visibility: ItemVisibility,
+) -> bool {
+    // Note that if the target module is in a different crate from the current module then we will either
+    // return true as the target module is public or return false as it is private without looking at the `CrateDefMap` in either case.
+    let same_crate = target_module.krate == importing_crate;
+    let target_crate_def_map = &def_maps[&target_module.krate];
+
+    match visibility {
+        ItemVisibility::Public => true,
+        ItemVisibility::PublicCrate => same_crate,
+        ItemVisibility::Private => {
+            same_crate
+                && module_descendent_of_target(
+                    target_crate_def_map,
+                    target_module.local_id,
+                    current_module,
+                )
+        }
+    }
+}
+
+// Returns true if `current` is a (potentially nested) child module of `target`.
+// This is also true if `current == target`.
+fn module_descendent_of_target(
+    def_map: &CrateDefMap,
+    target: LocalModuleId,
+    current: LocalModuleId,
+) -> bool {
+    if current == target {
+        return true;
+    }
 
-    resolve_path_to_ns(&dep_directive, dep_def_map, def_maps, allow_contracts)
+    def_map.modules[current.0]
+        .parent
+        .map_or(false, |parent| module_descendent_of_target(def_map, target, parent))
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs b/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
index 4c5fa3bceef..e19af3c732f 100644
--- a/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
@@ -1,11 +1,9 @@
-use super::import::{
-    allow_referencing_contracts, resolve_path_to_ns, ImportDirective, PathResolutionError,
-};
+use super::import::{resolve_import, ImportDirective, PathResolution, PathResolutionResult};
 use crate::Path;
 use std::collections::BTreeMap;
 
 use crate::graph::CrateId;
-use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleDefId, ModuleId};
+use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 
 pub trait PathResolver {
     /// Resolve the given path returning the resolved ModuleDefId.
@@ -13,7 +11,7 @@ pub trait PathResolver {
         &self,
         def_maps: &BTreeMap<CrateId, CrateDefMap>,
         path: Path,
-    ) -> Result<ModuleDefId, PathResolutionError>;
+    ) -> PathResolutionResult;
 
     fn local_module_id(&self) -> LocalModuleId;
 
@@ -36,7 +34,7 @@ impl PathResolver for StandardPathResolver {
         &self,
         def_maps: &BTreeMap<CrateId, CrateDefMap>,
         path: Path,
-    ) -> Result<ModuleDefId, PathResolutionError> {
+    ) -> PathResolutionResult {
         resolve_path(def_maps, self.module_id, path)
     }
 
@@ -55,17 +53,15 @@ pub fn resolve_path(
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     module_id: ModuleId,
     path: Path,
-) -> Result<ModuleDefId, PathResolutionError> {
+) -> PathResolutionResult {
     // lets package up the path into an ImportDirective and resolve it using that
     let import =
         ImportDirective { module_id: module_id.local_id, path, alias: None, is_prelude: false };
-    let allow_referencing_contracts =
-        allow_referencing_contracts(def_maps, module_id.krate, module_id.local_id);
+    let resolved_import = resolve_import(module_id.krate, &import, def_maps)?;
 
-    let def_map = &def_maps[&module_id.krate];
-    let ns = resolve_path_to_ns(&import, def_map, def_maps, allow_referencing_contracts)?;
+    let namespace = resolved_import.resolved_namespace;
+    let id =
+        namespace.values.or(namespace.types).map(|(id, _, _)| id).expect("Found empty namespace");
 
-    let function = ns.values.map(|(id, _, _)| id);
-    let id = function.or_else(|| ns.types.map(|(id, _, _)| id));
-    Ok(id.expect("Found empty namespace"))
+    Ok(PathResolution { module_def_id: id, error: resolved_import.error })
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index ec149dee96e..f2b8212db7a 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -25,7 +25,7 @@ use std::collections::{BTreeMap, HashSet};
 use std::rc::Rc;
 
 use crate::graph::CrateId;
-use crate::hir::def_map::{LocalModuleId, ModuleDefId, TryFromModuleDefId, MAIN_FUNCTION};
+use crate::hir::def_map::{ModuleDefId, TryFromModuleDefId, MAIN_FUNCTION};
 use crate::hir_def::stmt::{HirAssignStatement, HirForStatement, HirLValue, HirPattern};
 use crate::node_interner::{
     DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, NodeInterner, StmtId,
@@ -56,6 +56,7 @@ use crate::hir_def::{
 };
 
 use super::errors::{PubPosition, ResolverError};
+use super::import::PathResolution;
 
 const SELF_TYPE_NAME: &str = "Self";
 
@@ -677,10 +678,14 @@ impl<'a> Resolver<'a> {
 
         // If we cannot find a local generic of the same name, try to look up a global
         match self.path_resolver.resolve(self.def_maps, path.clone()) {
-            Ok(ModuleDefId::GlobalId(id)) => {
+            Ok(PathResolution { module_def_id: ModuleDefId::GlobalId(id), error }) => {
                 if let Some(current_item) = self.current_item {
                     self.interner.add_global_dependency(current_item, id);
                 }
+
+                if let Some(error) = error {
+                    self.push_err(error.into());
+                }
                 Some(Type::Constant(self.eval_global_as_array_length(id, path)))
             }
             _ => None,
@@ -1327,59 +1332,6 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    // Issue an error if the given private function is being called from a non-child module, or
-    // if the given pub(crate) function is being called from another crate
-    fn check_can_reference_function(
-        &mut self,
-        func: FuncId,
-        span: Span,
-        visibility: ItemVisibility,
-    ) {
-        let function_module = self.interner.function_module(func);
-        let current_module = self.path_resolver.module_id();
-
-        let same_crate = function_module.krate == current_module.krate;
-        let krate = function_module.krate;
-        let current_module = current_module.local_id;
-        let name = self.interner.function_name(&func).to_string();
-        match visibility {
-            ItemVisibility::Public => (),
-            ItemVisibility::Private => {
-                if !same_crate
-                    || !self.module_descendent_of_target(
-                        krate,
-                        function_module.local_id,
-                        current_module,
-                    )
-                {
-                    self.errors.push(ResolverError::PrivateFunctionCalled { span, name });
-                }
-            }
-            ItemVisibility::PublicCrate => {
-                if !same_crate {
-                    self.errors.push(ResolverError::NonCrateFunctionCalled { span, name });
-                }
-            }
-        }
-    }
-
-    // Returns true if `current` is a (potentially nested) child module of `target`.
-    // This is also true if `current == target`.
-    fn module_descendent_of_target(
-        &self,
-        krate: CrateId,
-        target: LocalModuleId,
-        current: LocalModuleId,
-    ) -> bool {
-        if current == target {
-            return true;
-        }
-
-        self.def_maps[&krate].modules[current.0]
-            .parent
-            .map_or(false, |parent| self.module_descendent_of_target(krate, target, parent))
-    }
-
     fn resolve_local_variable(&mut self, hir_ident: HirIdent, var_scope_index: usize) {
         let mut transitive_capture_index: Option<usize> = None;
 
@@ -1473,15 +1425,6 @@ impl<'a> Resolver<'a> {
                                 if let Some(current_item) = self.current_item {
                                     self.interner.add_function_dependency(current_item, id);
                                 }
-
-                                if self.interner.function_visibility(id) != ItemVisibility::Public {
-                                    let span = hir_ident.location.span;
-                                    self.check_can_reference_function(
-                                        id,
-                                        span,
-                                        self.interner.function_visibility(id),
-                                    );
-                                }
                             }
                             DefinitionKind::Global(global_id) => {
                                 if let Some(current_item) = self.current_item {
@@ -1920,7 +1863,7 @@ impl<'a> Resolver<'a> {
                 }
 
                 if let Ok(ModuleDefId::TraitId(trait_id)) =
-                    self.path_resolver.resolve(self.def_maps, trait_bound.trait_path.clone())
+                    self.resolve_path(trait_bound.trait_path.clone())
                 {
                     let the_trait = self.interner.get_trait(trait_id);
                     if let Some(method) =
@@ -1955,7 +1898,13 @@ impl<'a> Resolver<'a> {
     }
 
     fn resolve_path(&mut self, path: Path) -> Result<ModuleDefId, ResolverError> {
-        self.path_resolver.resolve(self.def_maps, path).map_err(ResolverError::PathResolutionError)
+        let path_resolution = self.path_resolver.resolve(self.def_maps, path)?;
+
+        if let Some(error) = path_resolution.error {
+            self.push_err(error.into());
+        }
+
+        Ok(path_resolution.module_def_id)
     }
 
     fn resolve_block(&mut self, block_expr: BlockExpression) -> HirExpression {
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index 04da558a642..a7669f57e33 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -21,6 +21,7 @@ use crate::{
 
 use super::{
     functions, get_module_mut, get_struct_type,
+    import::{PathResolution, PathResolutionError},
     path_resolver::{PathResolver, StandardPathResolver},
     resolver::Resolver,
     take_errors,
@@ -274,7 +275,15 @@ fn collect_trait_impl(
     let module = ModuleId { local_id: trait_impl.module_id, krate: crate_id };
     trait_impl.trait_id =
         match resolve_trait_by_path(def_maps, module, trait_impl.trait_path.clone()) {
-            Ok(trait_id) => Some(trait_id),
+            Ok((trait_id, warning)) => {
+                if let Some(warning) = warning {
+                    errors.push((
+                        DefCollectorErrorKind::PathResolutionError(warning).into(),
+                        trait_impl.file_id,
+                    ));
+                }
+                Some(trait_id)
+            }
             Err(error) => {
                 errors.push((error.into(), trait_impl.file_id));
                 None
@@ -362,11 +371,13 @@ pub(crate) fn resolve_trait_by_path(
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     module: ModuleId,
     path: Path,
-) -> Result<TraitId, DefCollectorErrorKind> {
+) -> Result<(TraitId, Option<PathResolutionError>), DefCollectorErrorKind> {
     let path_resolver = StandardPathResolver::new(module);
 
     match path_resolver.resolve(def_maps, path.clone()) {
-        Ok(ModuleDefId::TraitId(trait_id)) => Ok(trait_id),
+        Ok(PathResolution { module_def_id: ModuleDefId::TraitId(trait_id), error }) => {
+            Ok((trait_id, error))
+        }
         Ok(_) => Err(DefCollectorErrorKind::NotATrait { not_a_trait_name: path }),
         Err(_) => Err(DefCollectorErrorKind::TraitNotFound { trait_path: path }),
     }
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index c5a04c33883..926dac30bcd 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -434,7 +434,9 @@ mod test {
 
     use crate::graph::CrateId;
     use crate::hir::def_map::{ModuleData, ModuleId};
-    use crate::hir::resolution::import::PathResolutionError;
+    use crate::hir::resolution::import::{
+        PathResolution, PathResolutionError, PathResolutionResult,
+    };
     use crate::hir_def::expr::HirIdent;
     use crate::hir_def::stmt::HirLetStatement;
     use crate::hir_def::stmt::HirPattern::Identifier;
@@ -644,12 +646,13 @@ mod test {
             &self,
             _def_maps: &BTreeMap<CrateId, CrateDefMap>,
             path: Path,
-        ) -> Result<ModuleDefId, PathResolutionError> {
+        ) -> PathResolutionResult {
             // Not here that foo::bar and hello::foo::bar would fetch the same thing
             let name = path.segments.last().unwrap();
             self.0
                 .get(&name.0.contents)
                 .cloned()
+                .map(|module_def_id| PathResolution { module_def_id, error: None })
                 .ok_or_else(move || PathResolutionError::Unresolved(name.clone()))
         }
 

From 24f6d85f2467a109399d21729f8bb0f97c5ba6db Mon Sep 17 00:00:00 2001
From: Cat McGee <hello@mcgee.cat>
Date: Wed, 3 Apr 2024 07:15:11 +0900
Subject: [PATCH 137/416] feat(docs): Documenting noir codegen (#4454)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

WIP, waiting on https://github.com/noir-lang/noir/pull/4448
# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: James Zaki <james.zaki@proton.me>
Co-authored-by: José Pedro Sousa <jose@aztecprotocol.com>
Co-authored-by: josh crites <jc@joshcrites.com>
---
 .../getting_started/tooling/noir_codegen.md   | 113 ++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 docs/docs/getting_started/tooling/noir_codegen.md

diff --git a/docs/docs/getting_started/tooling/noir_codegen.md b/docs/docs/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..d65151da0ab
--- /dev/null
+++ b/docs/docs/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,113 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 2
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.

From c5a7242f6d43eb3a7e74995a6334e38cc3c45ba5 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 3 Apr 2024 11:29:56 +0100
Subject: [PATCH 138/416] chore: remove conditional compilation around
 `acvm_js` package (#4702)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We previously had acvm_js wrapped in a big conditional compilation
statement which shortcircuited it if it wasn't building for a wasm
architecture.

This isn't ideal as it prevents a lot of IDE LSP features from working
and it shouldn't be necessary (as shown by the other wasm packages).
I've then removed this and fixed any issues caused as a result.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                 |  2 +-
 acvm-repo/acvm_js/Cargo.toml               |  7 +---
 acvm-repo/acvm_js/src/black_box_solvers.rs |  2 -
 acvm-repo/acvm_js/src/execute.rs           |  2 +-
 acvm-repo/acvm_js/src/lib.rs               | 47 ++++++++++------------
 acvm-repo/bn254_blackbox_solver/Cargo.toml |  1 +
 acvm-repo/bn254_blackbox_solver/src/lib.rs | 13 ++++--
 7 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2f85b26f974..2371ef6df05 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -93,7 +93,6 @@ dependencies = [
  "acvm",
  "bn254_blackbox_solver",
  "build-data",
- "cfg-if 1.0.0",
  "console_error_panic_hook",
  "const-str",
  "gloo-utils",
@@ -606,6 +605,7 @@ dependencies = [
  "acvm_blackbox_solver",
  "ark-ec",
  "ark-ff",
+ "cfg-if 1.0.0",
  "flate2",
  "getrandom 0.2.10",
  "js-sys",
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 65c072b1d96..8319c38aee2 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -16,20 +16,17 @@ repository.workspace = true
 crate-type = ["cdylib"]
 
 [dependencies]
-cfg-if = "1.0.0"
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
 acvm.workspace = true
 bn254_blackbox_solver = { workspace = true, optional = true }
 wasm-bindgen.workspace = true
 wasm-bindgen-futures.workspace = true
 console_error_panic_hook.workspace = true
 gloo-utils.workspace = true
-js-sys.workspace = true 
+js-sys.workspace = true
+serde.workspace = true
 tracing-subscriber.workspace = true
 tracing-web.workspace = true
 
-serde = { version = "1.0.136", features = ["derive"] }
 const-str = "0.5.5"
 
 [build-dependencies]
diff --git a/acvm-repo/acvm_js/src/black_box_solvers.rs b/acvm-repo/acvm_js/src/black_box_solvers.rs
index fc0e3b28ebf..188e5334ed5 100644
--- a/acvm-repo/acvm_js/src/black_box_solvers.rs
+++ b/acvm-repo/acvm_js/src/black_box_solvers.rs
@@ -59,7 +59,6 @@ pub fn ecdsa_secp256k1_verify(
         signature,
     )
     .unwrap()
-    .into()
 }
 
 /// Verifies a ECDSA signature over the secp256r1 curve.
@@ -81,5 +80,4 @@ pub fn ecdsa_secp256r1_verify(
         signature,
     )
     .unwrap()
-    .into()
 }
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 60d27a489e2..4c23acea5db 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -106,7 +106,7 @@ pub async fn execute_circuit_with_black_box_solver(
                     None => error.to_string(),
                 };
 
-                return Err(JsExecutionError::new(error_string.into(), call_stack).into());
+                return Err(JsExecutionError::new(error_string, call_stack).into());
             }
             ACVMStatus::RequiresForeignCall(foreign_call) => {
                 let result = resolve_brillig(&foreign_call_handler, &foreign_call).await?;
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index 88afd1767c9..8ded77a4e22 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -1,31 +1,26 @@
-#![forbid(unsafe_code)]
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
-// TODO: Absence of per package targets
-// https://doc.rust-lang.org/cargo/reference/unstable.html#per-package-target
-// otherwise could be reorganized to make this file more pretty.
+mod black_box_solvers;
+mod build_info;
+mod compression;
+mod execute;
+mod foreign_call;
+mod js_execution_error;
+mod js_witness_map;
+mod logging;
+mod public_witness;
 
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "wasm32")] {
-        mod build_info;
-        mod compression;
-        mod execute;
-        mod foreign_call;
-        mod js_witness_map;
-        mod logging;
-        mod public_witness;
-        mod js_execution_error;
-        mod black_box_solvers;
-
-        pub use black_box_solvers::{and, xor, sha256, blake2s256, keccak256, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
-        pub use build_info::build_info;
-        pub use compression::{compress_witness, decompress_witness};
-        pub use execute::{execute_circuit, execute_circuit_with_black_box_solver, create_black_box_solver};
-        pub use js_witness_map::JsWitnessMap;
-        pub use logging::init_log_level;
-        pub use public_witness::{get_public_parameters_witness, get_public_witness, get_return_witness};
-        pub use js_execution_error::JsExecutionError;
-    }
-}
+pub use black_box_solvers::{
+    and, blake2s256, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, sha256, xor,
+};
+pub use build_info::build_info;
+pub use compression::{compress_witness, decompress_witness};
+pub use execute::{
+    create_black_box_solver, execute_circuit, execute_circuit_with_black_box_solver,
+};
+pub use js_execution_error::JsExecutionError;
+pub use js_witness_map::JsWitnessMap;
+pub use logging::init_log_level;
+pub use public_witness::{get_public_parameters_witness, get_public_witness, get_return_witness};
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 396e4aa0146..8658c37420b 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -17,6 +17,7 @@ acir.workspace = true
 acvm_blackbox_solver.workspace = true
 thiserror.workspace = true
 num-traits.workspace = true
+cfg-if = "1.0.0"
 
 rust-embed = { version = "6.6.0", features = [
     "debug-embed",
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index be0e60ada96..231594170e3 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -20,10 +20,17 @@ pub struct Bn254BlackBoxSolver {
 }
 
 impl Bn254BlackBoxSolver {
-    #[cfg(target_arch = "wasm32")]
     pub async fn initialize() -> Bn254BlackBoxSolver {
-        let blackbox_vendor = Barretenberg::initialize().await;
-        Bn254BlackBoxSolver { blackbox_vendor }
+        // We fallback to the sync initialization of barretenberg on non-wasm targets.
+        // This ensures that wasm packages consuming this still build on the default target (useful for linting, etc.)
+        cfg_if::cfg_if! {
+            if #[cfg(target_arch = "wasm32")] {
+                let blackbox_vendor = Barretenberg::initialize().await;
+                Bn254BlackBoxSolver { blackbox_vendor }
+            } else {
+                Bn254BlackBoxSolver::new()
+            }
+        }
     }
 
     #[cfg(not(target_arch = "wasm32"))]

From b55a580388abc95bab6c6ef8c50eae3c5497eb3f Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 3 Apr 2024 16:10:04 +0100
Subject: [PATCH 139/416] fix(ssa): Do not use get_value_max_num_bits when we
 want pure type information (#4700)

# Description

## Problem\*

No issue as this was found by @jfecher while testing in debug mode where
we get overflow errors after https://github.com/noir-lang/noir/pull/4691

Resolves
https://github.com/noir-lang/noir/pull/4699#discussion_r1548634192

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../src/ssa/ir/instruction/binary.rs              | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
index e491807995b..9099268ace9 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
@@ -171,21 +171,6 @@ impl Binary {
                     return SimplifyResult::SimplifiedTo(one);
                 }
 
-                if operand_type.is_unsigned() {
-                    // If we're comparing a variable against a constant value which lies outside of the range of
-                    // values which the variable's type can take, we can assume that the equality will be false.
-                    let constant = lhs.or(rhs);
-                    let non_constant = if lhs.is_some() { self.rhs } else { self.lhs };
-                    if let Some(constant) = constant {
-                        let max_possible_value =
-                            2u128.pow(dfg.get_value_max_num_bits(non_constant)) - 1;
-                        if constant > max_possible_value.into() {
-                            let zero = dfg.make_constant(FieldElement::zero(), Type::bool());
-                            return SimplifyResult::SimplifiedTo(zero);
-                        }
-                    }
-                }
-
                 if operand_type == Type::bool() {
                     // Simplify forms of `(boolean == true)` into `boolean`
                     if lhs_is_one {

From 463fb7712b74c3afaeb87597a700121619850386 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 3 Apr 2024 16:13:16 +0100
Subject: [PATCH 140/416] chore: simplify how blns is loaded into tests (#4705)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Similarly to #4703, this PR simplifies how we load in the blns file for
tests.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/build.rs                  | 15 ---------------
 .../noirc_frontend/src/{ => lexer}/blns/LICENSE   |  0
 .../noirc_frontend/src/{ => lexer}/blns/README.md |  0
 .../src/{ => lexer}/blns/blns.base64.json         |  0
 compiler/noirc_frontend/src/lexer/lexer.rs        |  2 +-
 5 files changed, 1 insertion(+), 16 deletions(-)
 delete mode 100644 compiler/noirc_frontend/build.rs
 rename compiler/noirc_frontend/src/{ => lexer}/blns/LICENSE (100%)
 rename compiler/noirc_frontend/src/{ => lexer}/blns/README.md (100%)
 rename compiler/noirc_frontend/src/{ => lexer}/blns/blns.base64.json (100%)

diff --git a/compiler/noirc_frontend/build.rs b/compiler/noirc_frontend/build.rs
deleted file mode 100644
index 53ae9489168..00000000000
--- a/compiler/noirc_frontend/build.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use std::path::PathBuf;
-
-const BLNS_JSON_PATH: &str = "BLNS_JSON_PATH";
-
-fn main() -> Result<(), String> {
-    let out_dir = std::env::var("OUT_DIR").unwrap();
-
-    let dest_path = PathBuf::from(out_dir.clone()).join("blns.base64.json");
-    let dest_path_str = dest_path.to_str().unwrap();
-
-    println!("cargo:rustc-env={BLNS_JSON_PATH}={dest_path_str}");
-    std::fs::copy("./src/blns/blns.base64.json", dest_path).unwrap();
-
-    Ok(())
-}
diff --git a/compiler/noirc_frontend/src/blns/LICENSE b/compiler/noirc_frontend/src/lexer/blns/LICENSE
similarity index 100%
rename from compiler/noirc_frontend/src/blns/LICENSE
rename to compiler/noirc_frontend/src/lexer/blns/LICENSE
diff --git a/compiler/noirc_frontend/src/blns/README.md b/compiler/noirc_frontend/src/lexer/blns/README.md
similarity index 100%
rename from compiler/noirc_frontend/src/blns/README.md
rename to compiler/noirc_frontend/src/lexer/blns/README.md
diff --git a/compiler/noirc_frontend/src/blns/blns.base64.json b/compiler/noirc_frontend/src/lexer/blns/blns.base64.json
similarity index 100%
rename from compiler/noirc_frontend/src/blns/blns.base64.json
rename to compiler/noirc_frontend/src/lexer/blns/blns.base64.json
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index cb21f58e58b..265b9e4b5a3 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -1160,7 +1160,7 @@ mod tests {
     fn test_big_list_of_naughty_strings() {
         use std::mem::discriminant;
 
-        let blns_contents = include_str!(env!("BLNS_JSON_PATH"));
+        let blns_contents = include_str!("./blns/blns.base64.json");
         let blns_base64: Vec<String> =
             serde_json::from_str(blns_contents).expect("BLNS json invalid");
         for blns_base64_str in blns_base64 {

From 386f6d0a5822912db878285cb001032a7c0ff622 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 3 Apr 2024 17:06:49 +0100
Subject: [PATCH 141/416] feat(acvm_js): Execute program  (#4694)

# Description

## Problem\*

Resolves #4645

## Summary\*

In order to have a recursive `execute_circuit` function we now have a
recursive async call. This requires boxing a future and having to making
`execute_circuit` immutable in order to attach the final main witness to
the witness stack. In our normal execution flow we could move the
`ProgramExecutor` after our recursive async call to execute_circuit, we
now need a lifetime on `self`.

I also switched all `execute_circuit` methods in ACVM JS to use
`execute_program` under the hood so that we do not have a breaking
change yet but can still test `execute_program` using all of our already
existing tests.

I then added a couple extra acvm js tests for multiple acir calls and
full witness stack (de)/compression.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 acvm-repo/acir/src/circuit/mod.rs             |  36 +--
 .../acir/src/native_types/witness_stack.rs    |   6 +-
 .../acir/tests/test_program_serialization.rs  |  93 +++++++
 acvm-repo/acvm_js/src/compression.rs          |  40 ++-
 acvm-repo/acvm_js/src/execute.rs              | 232 +++++++++++++-----
 acvm-repo/acvm_js/src/js_witness_stack.rs     |  71 ++++++
 acvm-repo/acvm_js/src/lib.rs                  |   7 +-
 .../acvm_js/test/node/execute_circuit.test.ts |  37 +++
 .../test/node/witness_conversion.test.ts      |  15 +-
 .../acvm_js/test/shared/nested_acir_call.ts   |  59 +++++
 10 files changed, 518 insertions(+), 78 deletions(-)
 create mode 100644 acvm-repo/acvm_js/src/js_witness_stack.rs
 create mode 100644 acvm-repo/acvm_js/test/shared/nested_acir_call.ts

diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index b5d6348d34f..cb846bdaffa 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -216,25 +216,33 @@ impl std::fmt::Display for Circuit {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "current witness index : {}", self.current_witness_index)?;
 
-        let write_public_inputs = |f: &mut std::fmt::Formatter<'_>,
-                                   public_inputs: &PublicInputs|
-         -> Result<(), std::fmt::Error> {
-            write!(f, "[")?;
-            let public_input_indices = public_inputs.indices();
-            for (index, public_input) in public_input_indices.iter().enumerate() {
-                write!(f, "{public_input}")?;
-                if index != public_input_indices.len() - 1 {
-                    write!(f, ", ")?;
+        let write_witness_indices =
+            |f: &mut std::fmt::Formatter<'_>, indices: &[u32]| -> Result<(), std::fmt::Error> {
+                write!(f, "[")?;
+                for (index, witness_index) in indices.iter().enumerate() {
+                    write!(f, "{witness_index}")?;
+                    if index != indices.len() - 1 {
+                        write!(f, ", ")?;
+                    }
                 }
-            }
-            writeln!(f, "]")
-        };
+                writeln!(f, "]")
+            };
+
+        write!(f, "private parameters indices : ")?;
+        write_witness_indices(
+            f,
+            &self
+                .private_parameters
+                .iter()
+                .map(|witness| witness.witness_index())
+                .collect::<Vec<_>>(),
+        )?;
 
         write!(f, "public parameters indices : ")?;
-        write_public_inputs(f, &self.public_parameters)?;
+        write_witness_indices(f, &self.public_parameters.indices())?;
 
         write!(f, "return value indices : ")?;
-        write_public_inputs(f, &self.return_values)?;
+        write_witness_indices(f, &self.return_values.indices())?;
 
         for opcode in &self.opcodes {
             writeln!(f, "{opcode}")?;
diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs
index a9e8f219b3e..7c79e3db431 100644
--- a/acvm-repo/acir/src/native_types/witness_stack.rs
+++ b/acvm-repo/acir/src/native_types/witness_stack.rs
@@ -21,7 +21,7 @@ pub struct WitnessStackError(#[from] SerializationError);
 /// An ordered set of witness maps for separate circuits
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
 pub struct WitnessStack {
-    pub stack: Vec<StackItem>,
+    stack: Vec<StackItem>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
@@ -37,6 +37,10 @@ impl WitnessStack {
         self.stack.push(StackItem { index, witness });
     }
 
+    pub fn pop(&mut self) -> Option<StackItem> {
+        self.stack.pop()
+    }
+
     pub fn peek(&self) -> Option<&StackItem> {
         self.stack.last()
     }
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 8b04292dfaa..a5b683c15e1 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -362,3 +362,96 @@ fn memory_op_circuit() {
 
     assert_eq!(bytes, expected_serialization)
 }
+
+#[test]
+fn nested_acir_call_circuit() {
+    // Circuit for the following program:
+    // fn main(x: Field, y: pub Field) {
+    //     let z = nested_call(x, y);
+    //     let z2 = nested_call(x, y);
+    //     assert(z == z2);
+    // }
+    // #[fold]
+    // fn nested_call(x: Field, y: Field) -> Field {
+    //     inner_call(x + 2, y)
+    // }
+    // #[fold]
+    // fn inner_call(x: Field, y: Field) -> Field {
+    //     assert(x == y);
+    //     x
+    // }
+    let nested_call =
+        Opcode::Call { id: 1, inputs: vec![Witness(0), Witness(1)], outputs: vec![Witness(2)] };
+    let nested_call_two =
+        Opcode::Call { id: 1, inputs: vec![Witness(0), Witness(1)], outputs: vec![Witness(3)] };
+
+    let assert_nested_call_results = Opcode::AssertZero(Expression {
+        mul_terms: Vec::new(),
+        linear_combinations: vec![
+            (FieldElement::one(), Witness(2)),
+            (-FieldElement::one(), Witness(3)),
+        ],
+        q_c: FieldElement::zero(),
+    });
+
+    let main = Circuit {
+        current_witness_index: 3,
+        private_parameters: BTreeSet::from([Witness(0)]),
+        public_parameters: PublicInputs([Witness(1)].into()),
+        opcodes: vec![nested_call, nested_call_two, assert_nested_call_results],
+        ..Circuit::default()
+    };
+
+    let call_parameter_addition = Opcode::AssertZero(Expression {
+        mul_terms: Vec::new(),
+        linear_combinations: vec![
+            (FieldElement::one(), Witness(0)),
+            (-FieldElement::one(), Witness(2)),
+        ],
+        q_c: FieldElement::one() + FieldElement::one(),
+    });
+    let call =
+        Opcode::Call { id: 2, inputs: vec![Witness(2), Witness(1)], outputs: vec![Witness(3)] };
+
+    let nested_call = Circuit {
+        current_witness_index: 3,
+        private_parameters: BTreeSet::from([Witness(0), Witness(1)]),
+        return_values: PublicInputs([Witness(3)].into()),
+        opcodes: vec![call_parameter_addition, call],
+        ..Circuit::default()
+    };
+
+    let assert_param_equality = Opcode::AssertZero(Expression {
+        mul_terms: Vec::new(),
+        linear_combinations: vec![
+            (FieldElement::one(), Witness(0)),
+            (-FieldElement::one(), Witness(1)),
+        ],
+        q_c: FieldElement::zero(),
+    });
+
+    let inner_call = Circuit {
+        current_witness_index: 1,
+        private_parameters: BTreeSet::from([Witness(0), Witness(1)]),
+        return_values: PublicInputs([Witness(0)].into()),
+        opcodes: vec![assert_param_equality],
+        ..Circuit::default()
+    };
+
+    let program = Program { functions: vec![main, nested_call, inner_call] };
+
+    let bytes = Program::serialize_program(&program);
+
+    let expected_serialization: Vec<u8> = vec![
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147,
+        24, 109, 227, 191, 93, 101, 50, 123, 255, 35, 172, 99, 25, 83, 17, 250, 99, 14, 250, 224,
+        97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 57, 108, 14, 91, 248, 202, 168, 65,
+        255, 207, 122, 28, 180, 250, 244, 221, 244, 197, 223, 68, 182, 154, 197, 184, 134, 80, 54,
+        95, 136, 233, 142, 62, 101, 137, 24, 98, 94, 133, 132, 162, 196, 135, 23, 230, 34, 65, 182,
+        148, 211, 134, 137, 2, 23, 218, 99, 226, 93, 135, 185, 121, 123, 33, 84, 12, 234, 218, 192,
+        64, 174, 3, 248, 47, 88, 48, 17, 150, 157, 183, 151, 95, 244, 86, 91, 221, 61, 10, 81, 31,
+        178, 190, 110, 194, 102, 96, 76, 251, 202, 80, 13, 204, 77, 224, 25, 176, 70, 79, 197, 128,
+        18, 64, 3, 4, 0, 0,
+    ];
+    assert_eq!(bytes, expected_serialization);
+}
diff --git a/acvm-repo/acvm_js/src/compression.rs b/acvm-repo/acvm_js/src/compression.rs
index 18e9216297e..8114e0d57d2 100644
--- a/acvm-repo/acvm_js/src/compression.rs
+++ b/acvm-repo/acvm_js/src/compression.rs
@@ -2,12 +2,12 @@ use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use js_sys::JsString;
 use wasm_bindgen::prelude::wasm_bindgen;
 
-use crate::JsWitnessMap;
+use crate::{JsWitnessMap, JsWitnessStack};
 
 /// Compresses a `WitnessMap` into the binary format outputted by Nargo.
 ///
-/// @param {Uint8Array} compressed_witness - A witness map.
-/// @returns {WitnessMap} A compressed witness map
+/// @param {WitnessMap} witness_map - A witness map.
+/// @returns {Uint8Array} A compressed witness map
 #[wasm_bindgen(js_name = compressWitness, skip_jsdoc)]
 pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString> {
     console_error_panic_hook::set_once();
@@ -21,6 +21,7 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString>
 }
 
 /// Decompresses a compressed witness as outputted by Nargo into a `WitnessMap`.
+/// This should be used to only fetch the witness map for the main function.
 ///
 /// @param {Uint8Array} compressed_witness - A compressed witness.
 /// @returns {WitnessMap} The decompressed witness map.
@@ -28,8 +29,39 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString>
 pub fn decompress_witness(compressed_witness: Vec<u8>) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
 
+    let mut witness_stack =
+        WitnessStack::try_from(compressed_witness.as_slice()).map_err(|err| err.to_string())?;
+
+    let witness =
+        witness_stack.pop().expect("Should have at least one witness on the stack").witness;
+    Ok(witness.into())
+}
+
+/// Compresses a `WitnessStack` into the binary format outputted by Nargo.
+///
+/// @param {WitnessStack} witness_stack - A witness stack.
+/// @returns {Uint8Array} A compressed witness stack
+#[wasm_bindgen(js_name = compressWitnessStack, skip_jsdoc)]
+pub fn compress_witness_stack(witness_stack: JsWitnessStack) -> Result<Vec<u8>, JsString> {
+    console_error_panic_hook::set_once();
+
+    let witness_stack = WitnessStack::from(witness_stack);
+    let compressed_witness_stack: Vec<u8> =
+        Vec::<u8>::try_from(witness_stack).map_err(|err| err.to_string())?;
+
+    Ok(compressed_witness_stack)
+}
+
+/// Decompresses a compressed witness stack as outputted by Nargo into a `WitnessStack`.
+///
+/// @param {Uint8Array} compressed_witness - A compressed witness.
+/// @returns {WitnessStack} The decompressed witness stack.
+#[wasm_bindgen(js_name = decompressWitnessStack, skip_jsdoc)]
+pub fn decompress_witness_stack(compressed_witness: Vec<u8>) -> Result<JsWitnessStack, JsString> {
+    console_error_panic_hook::set_once();
+
     let witness_stack =
         WitnessStack::try_from(compressed_witness.as_slice()).map_err(|err| err.to_string())?;
 
-    Ok(witness_stack.stack[0].witness.clone().into())
+    Ok(witness_stack.into())
 }
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 4c23acea5db..0e58ccf039c 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -1,5 +1,9 @@
+use std::{future::Future, pin::Pin};
+
+use acvm::BlackBoxFunctionSolver;
 use acvm::{
-    acir::circuit::Program,
+    acir::circuit::{Circuit, Program},
+    acir::native_types::{WitnessMap, WitnessStack},
     pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM},
 };
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
@@ -9,7 +13,7 @@ use wasm_bindgen::prelude::wasm_bindgen;
 
 use crate::{
     foreign_call::{resolve_brillig, ForeignCallHandler},
-    JsExecutionError, JsWitnessMap,
+    JsExecutionError, JsWitnessMap, JsWitnessStack,
 };
 
 #[wasm_bindgen]
@@ -42,8 +46,16 @@ pub async fn execute_circuit(
 
     let solver = WasmBlackBoxFunctionSolver::initialize().await;
 
-    execute_circuit_with_black_box_solver(&solver, program, initial_witness, foreign_call_handler)
-        .await
+    let mut witness_stack = execute_program_with_native_type_return(
+        &solver,
+        program,
+        initial_witness,
+        &foreign_call_handler,
+    )
+    .await?;
+    let witness_map =
+        witness_stack.pop().expect("Should have at least one witness on the stack").witness;
+    Ok(witness_map.into())
 }
 
 /// Executes an ACIR circuit to generate the solved witness from the initial witness.
@@ -56,69 +68,175 @@ pub async fn execute_circuit(
 #[wasm_bindgen(js_name = executeCircuitWithBlackBoxSolver, skip_jsdoc)]
 pub async fn execute_circuit_with_black_box_solver(
     solver: &WasmBlackBoxFunctionSolver,
-    // TODO(https://github.com/noir-lang/noir/issues/4428): These need to be updated to match the same interfaces
-    // as the native ACVM executor. Right now native execution still only handles one circuit so I do not feel the need
-    // to break the JS interface just yet.
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
 ) -> Result<JsWitnessMap, Error> {
     console_error_panic_hook::set_once();
+
+    let mut witness_stack = execute_program_with_native_type_return(
+        solver,
+        program,
+        initial_witness,
+        &foreign_call_handler,
+    )
+    .await?;
+    let witness_map =
+        witness_stack.pop().expect("Should have at least one witness on the stack").witness;
+    Ok(witness_map.into())
+}
+
+#[wasm_bindgen(js_name = executeProgram, skip_jsdoc)]
+pub async fn execute_program(
+    program: Vec<u8>,
+    initial_witness: JsWitnessMap,
+    foreign_call_handler: ForeignCallHandler,
+) -> Result<JsWitnessStack, Error> {
+    console_error_panic_hook::set_once();
+
+    let solver = WasmBlackBoxFunctionSolver::initialize().await;
+
+    execute_program_with_black_box_solver(&solver, program, initial_witness, &foreign_call_handler)
+        .await
+}
+
+#[wasm_bindgen(js_name = executeProgramWithBlackBoxSolver, skip_jsdoc)]
+pub async fn execute_program_with_black_box_solver(
+    solver: &WasmBlackBoxFunctionSolver,
+    program: Vec<u8>,
+    initial_witness: JsWitnessMap,
+    foreign_call_executor: &ForeignCallHandler,
+) -> Result<JsWitnessStack, Error> {
+    let witness_stack = execute_program_with_native_type_return(
+        solver,
+        program,
+        initial_witness,
+        foreign_call_executor,
+    )
+    .await?;
+
+    Ok(witness_stack.into())
+}
+
+async fn execute_program_with_native_type_return(
+    solver: &WasmBlackBoxFunctionSolver,
+    program: Vec<u8>,
+    initial_witness: JsWitnessMap,
+    foreign_call_executor: &ForeignCallHandler,
+) -> Result<WitnessStack, Error> {
     let program: Program = Program::deserialize_program(&program)
-        .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
-    let circuit = match program.functions.len() {
-        0 => return Ok(initial_witness),
-        1 => &program.functions[0],
-        _ => return Err(JsExecutionError::new("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit".to_string(), None).into())
-    };
-
-    let mut acvm = ACVM::new(&solver.0, &circuit.opcodes, initial_witness.into());
-
-    loop {
-        let solver_status = acvm.solve();
-
-        match solver_status {
-            ACVMStatus::Solved => break,
-            ACVMStatus::InProgress => {
-                unreachable!("Execution should not stop while in `InProgress` state.")
-            }
-            ACVMStatus::Failure(error) => {
-                let (assert_message, call_stack) = match &error {
-                    OpcodeResolutionError::UnsatisfiedConstrain {
-                        opcode_location: ErrorLocation::Resolved(opcode_location),
-                    }
-                    | OpcodeResolutionError::IndexOutOfBounds {
-                        opcode_location: ErrorLocation::Resolved(opcode_location),
-                        ..
-                    } => {
-                        (circuit.get_assert_message(*opcode_location), Some(vec![*opcode_location]))
+    .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
+
+    let executor = ProgramExecutor::new(&program.functions, &solver.0, foreign_call_executor);
+    let witness_stack = executor.execute(initial_witness.into()).await?;
+
+    Ok(witness_stack)
+}
+
+struct ProgramExecutor<'a, B: BlackBoxFunctionSolver> {
+    functions: &'a [Circuit],
+
+    blackbox_solver: &'a B,
+
+    foreign_call_handler: &'a ForeignCallHandler,
+}
+
+impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
+    fn new(
+        functions: &'a [Circuit],
+        blackbox_solver: &'a B,
+        foreign_call_handler: &'a ForeignCallHandler,
+    ) -> Self {
+        ProgramExecutor { functions, blackbox_solver, foreign_call_handler }
+    }
+
+    async fn execute(&self, initial_witness: WitnessMap) -> Result<WitnessStack, Error> {
+        let main = &self.functions[0];
+
+        let mut witness_stack = WitnessStack::default();
+        let main_witness = self.execute_circuit(main, initial_witness, &mut witness_stack).await?;
+        witness_stack.push(0, main_witness);
+        Ok(witness_stack)
+    }
+
+    fn execute_circuit(
+        &'a self,
+        circuit: &'a Circuit,
+        initial_witness: WitnessMap,
+        witness_stack: &'a mut WitnessStack,
+    ) -> Pin<Box<dyn Future<Output = Result<WitnessMap, Error>> + 'a>> {
+        Box::pin(async {
+            let mut acvm = ACVM::new(self.blackbox_solver, &circuit.opcodes, initial_witness);
+
+            loop {
+                let solver_status = acvm.solve();
+
+                match solver_status {
+                    ACVMStatus::Solved => break,
+                    ACVMStatus::InProgress => {
+                        unreachable!("Execution should not stop while in `InProgress` state.")
                     }
-                    OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
-                        let failing_opcode =
-                            call_stack.last().expect("Brillig error call stacks cannot be empty");
-                        (circuit.get_assert_message(*failing_opcode), Some(call_stack.clone()))
+                    ACVMStatus::Failure(error) => {
+                        let (assert_message, call_stack) = match &error {
+                            OpcodeResolutionError::UnsatisfiedConstrain {
+                                opcode_location: ErrorLocation::Resolved(opcode_location),
+                            }
+                            | OpcodeResolutionError::IndexOutOfBounds {
+                                opcode_location: ErrorLocation::Resolved(opcode_location),
+                                ..
+                            } => (
+                                circuit.get_assert_message(*opcode_location),
+                                Some(vec![*opcode_location]),
+                            ),
+                            OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
+                                let failing_opcode = call_stack
+                                    .last()
+                                    .expect("Brillig error call stacks cannot be empty");
+                                (
+                                    circuit.get_assert_message(*failing_opcode),
+                                    Some(call_stack.clone()),
+                                )
+                            }
+                            _ => (None, None),
+                        };
+
+                        let error_string = match &assert_message {
+                            Some(assert_message) => format!("Assertion failed: {}", assert_message),
+                            None => error.to_string(),
+                        };
+
+                        return Err(JsExecutionError::new(error_string, call_stack).into());
                     }
-                    _ => (None, None),
-                };
-
-                let error_string = match &assert_message {
-                    Some(assert_message) => format!("Assertion failed: {}", assert_message),
-                    None => error.to_string(),
-                };
+                    ACVMStatus::RequiresForeignCall(foreign_call) => {
+                        let result =
+                            resolve_brillig(self.foreign_call_handler, &foreign_call).await?;
 
-                return Err(JsExecutionError::new(error_string, call_stack).into());
+                        acvm.resolve_pending_foreign_call(result);
+                    }
+                    ACVMStatus::RequiresAcirCall(call_info) => {
+                        let acir_to_call = &self.functions[call_info.id as usize];
+                        let initial_witness = call_info.initial_witness;
+                        let call_solved_witness = self
+                            .execute_circuit(acir_to_call, initial_witness, witness_stack)
+                            .await?;
+                        let mut call_resolved_outputs = Vec::new();
+                        for return_witness_index in acir_to_call.return_values.indices() {
+                            if let Some(return_value) =
+                                call_solved_witness.get_index(return_witness_index)
+                            {
+                                call_resolved_outputs.push(*return_value);
+                            } else {
+                                // TODO: look at changing this call stack from None
+                                return Err(JsExecutionError::new(format!("Failed to read from solved witness of ACIR call at witness {}", return_witness_index), None).into());
+                            }
+                        }
+                        acvm.resolve_pending_acir_call(call_resolved_outputs);
+                        witness_stack.push(call_info.id, call_solved_witness.clone());
+                    }
+                }
             }
-            ACVMStatus::RequiresForeignCall(foreign_call) => {
-                let result = resolve_brillig(&foreign_call_handler, &foreign_call).await?;
 
-                acvm.resolve_pending_foreign_call(result);
-            }
-            ACVMStatus::RequiresAcirCall(_) => {
-                todo!("Handle acir calls in acvm JS");
-            }
-        }
+            Ok(acvm.finalize())
+        })
     }
-
-    let witness_map = acvm.finalize();
-    Ok(witness_map.into())
 }
diff --git a/acvm-repo/acvm_js/src/js_witness_stack.rs b/acvm-repo/acvm_js/src/js_witness_stack.rs
new file mode 100644
index 00000000000..59f2dbc051e
--- /dev/null
+++ b/acvm-repo/acvm_js/src/js_witness_stack.rs
@@ -0,0 +1,71 @@
+use acvm::acir::native_types::WitnessStack;
+use js_sys::{Array, Map, Object};
+use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
+
+use crate::JsWitnessMap;
+
+#[wasm_bindgen(typescript_custom_section)]
+const WITNESS_STACK: &'static str = r#"
+export type StackItem = {
+    index: number;
+    witness: WitnessMap;
+}
+
+export type WitnessStack = Array<StackItem>;
+"#;
+
+// WitnessStack
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Array, js_name = "WitnessStack", typescript_type = "WitnessStack")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsWitnessStack;
+
+    #[wasm_bindgen(constructor, js_class = "Array")]
+    pub fn new() -> JsWitnessStack;
+
+    #[wasm_bindgen(extends = Object, js_name = "StackItem", typescript_type = "StackItem")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsStackItem;
+
+    #[wasm_bindgen(constructor, js_class = "Object")]
+    pub fn new() -> JsStackItem;
+}
+
+impl Default for JsWitnessStack {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl From<WitnessStack> for JsWitnessStack {
+    fn from(mut witness_stack: WitnessStack) -> Self {
+        let js_witness_stack = JsWitnessStack::new();
+        while let Some(stack_item) = witness_stack.pop() {
+            let js_map = JsWitnessMap::from(stack_item.witness);
+            let js_index = JsValue::from_f64(stack_item.index.into());
+
+            let entry_map = Map::new();
+            entry_map.set(&JsValue::from_str("index"), &js_index);
+            entry_map.set(&JsValue::from_str("witness"), &js_map);
+            let stack_item = Object::from_entries(&entry_map).unwrap();
+
+            js_witness_stack.push(&stack_item);
+        }
+        // `reverse()` returns an `Array` so we have to wrap it
+        JsWitnessStack { obj: js_witness_stack.reverse() }
+    }
+}
+
+impl From<JsWitnessStack> for WitnessStack {
+    fn from(js_witness_stack: JsWitnessStack) -> Self {
+        let mut witness_stack = WitnessStack::default();
+        js_witness_stack.for_each(&mut |stack_item, _, _| {
+            let values_array = Object::values(&Object::from(stack_item));
+            let index = values_array.get(0).as_f64().unwrap() as u32;
+            let js_witness_map: JsWitnessMap = values_array.get(1).into();
+            witness_stack.push(index, js_witness_map.into());
+        });
+        witness_stack
+    }
+}
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index 8ded77a4e22..d7ecc0ae192 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -9,6 +9,7 @@ mod execute;
 mod foreign_call;
 mod js_execution_error;
 mod js_witness_map;
+mod js_witness_stack;
 mod logging;
 mod public_witness;
 
@@ -16,11 +17,15 @@ pub use black_box_solvers::{
     and, blake2s256, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, sha256, xor,
 };
 pub use build_info::build_info;
-pub use compression::{compress_witness, decompress_witness};
+pub use compression::{
+    compress_witness, compress_witness_stack, decompress_witness, decompress_witness_stack,
+};
 pub use execute::{
     create_black_box_solver, execute_circuit, execute_circuit_with_black_box_solver,
+    execute_program, execute_program_with_black_box_solver,
 };
 pub use js_execution_error::JsExecutionError;
 pub use js_witness_map::JsWitnessMap;
+pub use js_witness_stack::JsWitnessStack;
 pub use logging::init_log_level;
 pub use public_witness::{get_public_parameters_witness, get_public_witness, get_return_witness};
diff --git a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
index adee3c15312..32487f8bbba 100644
--- a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
@@ -6,6 +6,9 @@ import {
   WasmBlackBoxFunctionSolver,
   WitnessMap,
   ForeignCallHandler,
+  executeProgram,
+  WitnessStack,
+  StackItem,
 } from '@noir-lang/acvm_js';
 
 it('successfully executes circuit and extracts return value', async () => {
@@ -157,3 +160,37 @@ it('successfully executes 500 circuits with same backend', async function () {
     expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
   }
 });
+
+/**
+ * Below are all the same tests as above but using `executeProgram`
+ * TODO: also add a couple tests for executing multiple circuits
+ */
+it('executeProgram: successfully executes program and extracts return value', async () => {
+  const { bytecode, initialWitnessMap, resultWitness, expectedResult } = await import('../shared/addition');
+
+  const witnessStack: WitnessStack = await executeProgram(bytecode, initialWitnessMap, () => {
+    throw Error('unexpected oracle');
+  });
+
+  const solvedStackItem: StackItem = witnessStack[0];
+  expect(solvedStackItem.index).to.be.eq(0);
+  const solvedWitnessMap: WitnessMap = solvedStackItem.witness;
+
+  // Witness stack should be consistent with initial witness
+  initialWitnessMap.forEach((value, key) => {
+    expect(solvedWitnessMap.get(key) as string).to.be.eq(value);
+  });
+
+  // Solved witness should contain expected return value
+  expect(solvedWitnessMap.get(resultWitness)).to.be.eq(expectedResult);
+});
+
+it('executeProgram: successfully process a program of acir functions with a nested call', async () => {
+  const { bytecode, initialWitnessMap, expectedWitnessStack } = await import('../shared/nested_acir_call');
+
+  const witnessStack: WitnessStack = await executeProgram(bytecode, initialWitnessMap, () => {
+    throw Error('unexpected oracle');
+  });
+
+  expect(witnessStack).to.be.deep.eq(expectedWitnessStack);
+});
diff --git a/acvm-repo/acvm_js/test/node/witness_conversion.test.ts b/acvm-repo/acvm_js/test/node/witness_conversion.test.ts
index 41291c894ea..c6dccb4c83d 100644
--- a/acvm-repo/acvm_js/test/node/witness_conversion.test.ts
+++ b/acvm-repo/acvm_js/test/node/witness_conversion.test.ts
@@ -1,6 +1,7 @@
 import { expect } from 'chai';
-import { compressWitness, decompressWitness } from '@noir-lang/acvm_js';
+import { compressWitness, decompressWitness, compressWitnessStack, decompressWitnessStack } from '@noir-lang/acvm_js';
 import { expectedCompressedWitnessMap, expectedWitnessMap } from '../shared/witness_compression';
+import { expectedCompressedWitnessStack, expectedWitnessStack } from '../shared/nested_acir_call';
 
 it('successfully compresses the witness', () => {
   const compressedWitnessMap = compressWitness(expectedWitnessMap);
@@ -13,3 +14,15 @@ it('successfully decompresses the witness', () => {
 
   expect(witnessMap).to.be.deep.eq(expectedWitnessMap);
 });
+
+it('successfully compresses the witness stack', () => {
+  const compressedWitnessStack = compressWitnessStack(expectedWitnessStack);
+
+  expect(compressedWitnessStack).to.be.deep.eq(expectedCompressedWitnessStack);
+});
+
+it('successfully decompresses the witness stack', () => {
+  const witnessStack = decompressWitnessStack(expectedCompressedWitnessStack);
+
+  expect(witnessStack).to.be.deep.eq(expectedWitnessStack);
+});
diff --git a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
new file mode 100644
index 00000000000..ce91282a681
--- /dev/null
+++ b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
@@ -0,0 +1,59 @@
+import { WitnessMap, StackItem, WitnessStack } from '@noir-lang/acvm_js';
+
+// See `nested_acir_call_circuit` integration test in `acir/tests/test_program_serialization.rs`.
+export const bytecode = Uint8Array.from([
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147, 24, 109, 227, 191, 93, 101,
+  50, 123, 255, 35, 172, 99, 25, 83, 17, 250, 99, 14, 250, 224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 57,
+  108, 14, 91, 248, 202, 168, 65, 255, 207, 122, 28, 180, 250, 244, 221, 244, 197, 223, 68, 182, 154, 197, 184, 134, 80,
+  54, 95, 136, 233, 142, 62, 101, 137, 24, 98, 94, 133, 132, 162, 196, 135, 23, 230, 34, 65, 182, 148, 211, 134, 137, 2,
+  23, 218, 99, 226, 93, 135, 185, 121, 123, 33, 84, 12, 234, 218, 192, 64, 174, 3, 248, 47, 88, 48, 17, 150, 157, 183,
+  151, 95, 244, 86, 91, 221, 61, 10, 81, 31, 178, 190, 110, 194, 102, 96, 76, 251, 202, 80, 13, 204, 77, 224, 25, 176,
+  70, 79, 197, 128, 18, 64, 3, 4, 0, 0,
+]);
+
+export const initialWitnessMap: WitnessMap = new Map([
+  [0, '0x0000000000000000000000000000000000000000000000000000000000000008'],
+  [1, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+]);
+
+const inner_call_witness: StackItem = {
+  index: 2,
+  witness: new Map([
+    [0, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+    [1, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+  ]),
+};
+
+const nested_call_witness: StackItem = {
+  index: 1,
+  witness: new Map([
+    [0, '0x0000000000000000000000000000000000000000000000000000000000000008'],
+    [1, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+    [2, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+    [3, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+  ]),
+};
+
+const main_witness: StackItem = {
+  index: 0,
+  witness: new Map([
+    [0, '0x0000000000000000000000000000000000000000000000000000000000000008'],
+    [1, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+    [2, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+    [3, '0x000000000000000000000000000000000000000000000000000000000000000a'],
+  ]),
+};
+
+export const expectedWitnessStack: WitnessStack = [
+  inner_call_witness,
+  nested_call_witness,
+  inner_call_witness,
+  nested_call_witness,
+  main_witness,
+];
+
+export const expectedCompressedWitnessStack = Uint8Array.from([
+  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 237, 145, 177, 13, 0, 32, 8, 4, 17, 117, 31, 75, 75, 87, 113, 255, 37, 44, 196, 5,
+  228, 42, 194, 39, 132, 238, 114, 249, 239, 114, 163, 118, 47, 203, 254, 240, 101, 23, 152, 213, 120, 199, 73, 58, 42,
+  200, 170, 176, 87, 238, 27, 119, 95, 201, 238, 190, 89, 7, 37, 195, 196, 176, 4, 5, 0, 0,
+]);

From 079cb2a99d2d50b50688bfb56fa014acde3e3d71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Wed, 3 Apr 2024 19:32:06 +0200
Subject: [PATCH 142/416] fix: Field comparisons (#4704)

# Description

## Problem\*

Field comparisons could be tricked by a malicious prover by decomposing
0 as either (PLO,PHI) o (0,0). Now we reuse instead the assert_gt code
by extracting it to an assert_gt_limbs that is shared among decompose
(to check that the decomposition of x is less than the decomposition of
the field modulus, that is, that the decomposition of the field modulus
is greater than the decomposition of x) and assert_gt (to check that the
decomposition of a is greater than the decomposition of b)

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/field/bn254.nr | 37 +++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index 765f8a9d849..d70310be391 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -21,11 +21,23 @@ unconstrained fn decompose_unsafe(x: Field) -> (Field, Field) {
     (low, high)
 }
 
+// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
+fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
+    let (alo, ahi) = a;
+    let (blo, bhi) = b;
+    let borrow = lte_unsafe(alo, blo, 16);
+
+    let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
+    let rhi = ahi - bhi - (borrow as Field);
+
+    rlo.assert_max_bit_size(128);
+    rhi.assert_max_bit_size(128);
+}
+
 /// Decompose a single field into two 16 byte fields.
 pub fn decompose(x: Field) -> (Field, Field) {
     // Take hints of the decomposition
     let (xlo, xhi) = decompose_unsafe(x);
-    let borrow = lt_unsafe(PLO, xlo, 16);
 
     // Range check the limbs
     xlo.assert_max_bit_size(128);
@@ -34,13 +46,8 @@ pub fn decompose(x: Field) -> (Field, Field) {
     // Check that the decomposition is correct
     assert_eq(x, xlo + TWO_POW_128 * xhi);
 
-    // Check that (xlo < plo && xhi <= phi) || (xlo >= plo && xhi < phi)
-    let rlo = PLO - xlo + (borrow as Field) * TWO_POW_128;
-    let rhi = PHI - xhi - (borrow as Field);
-
-    rlo.assert_max_bit_size(128);
-    rhi.assert_max_bit_size(128);
-
+    // Assert that the decomposition of P is greater than the decomposition of x
+    assert_gt_limbs((PLO, PHI), (xlo, xhi));
     (xlo, xhi)
 }
 
@@ -69,17 +76,11 @@ unconstrained fn lte_unsafe(x: Field, y: Field, num_bytes: u32) -> bool {
 
 pub fn assert_gt(a: Field, b: Field) {
     // Decompose a and b
-    let (alo, ahi) = decompose(a);
-    let (blo, bhi) = decompose(b);
-
-    let borrow = lte_unsafe(alo, blo, 16);
+    let a_limbs = decompose(a);
+    let b_limbs = decompose(b);
 
-    // Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
-    let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
-    let rhi = ahi - bhi - (borrow as Field);
-
-    rlo.assert_max_bit_size(128);
-    rhi.assert_max_bit_size(128);
+    // Assert that a_limbs is greater than b_limbs
+    assert_gt_limbs(a_limbs, b_limbs)
 }
 
 pub fn assert_lt(a: Field, b: Field) {

From 8fea40576f262bd5bb588923c0660d8967404e56 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 3 Apr 2024 19:32:23 +0100
Subject: [PATCH 143/416] fix(acvm): Mark outputs of Opcode::Call solvable
 (#4708)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

No issue as bug found while experimenting

## Summary\*

We should mark the outputs of a call as solvable. Otherwise we can
potentially have more than one linear term and the outputs of call will
not be used by the transformers.

The new test `fold_call_witness_condition` would previously error out
with the following when `nargo info` was ran:
```
The backend encountered an error: "backend_binary: /home/runner/work/aztec-packages/aztec-packages/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp:57: poly_triple acir_format::serialize_arithmetic_gate(const Program::Expression &): Assertion `(arg.mul_terms.size() <= 1)' failed.\n"
```
Now it successfully calls nargo info on main (we still need to update
fetching the info for every circuit).

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acvm/src/compiler/transformers/mod.rs  |  6 +++++-
 .../fold_call_witness_condition/Nargo.toml       |  7 +++++++
 .../fold_call_witness_condition/Prover.toml      |  5 +++++
 .../fold_call_witness_condition/src/main.nr      | 16 ++++++++++++++++
 tooling/debugger/ignored-tests.txt               |  1 +
 5 files changed, 34 insertions(+), 1 deletion(-)
 create mode 100644 test_programs/execution_success/fold_call_witness_condition/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_call_witness_condition/Prover.toml
 create mode 100644 test_programs/execution_success/fold_call_witness_condition/src/main.nr

diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 1ba261b09a3..003cd4279a1 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -142,7 +142,11 @@ pub(super) fn transform_internal(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
-            Opcode::Call { .. } => {
+            Opcode::Call { ref outputs, .. } => {
+                for witness in outputs {
+                    transformer.mark_solvable(*witness);
+                }
+
                 // `Call` does not write values to the `WitnessMap`
                 // A separate ACIR function should have its own respective `WitnessMap`
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
diff --git a/test_programs/execution_success/fold_call_witness_condition/Nargo.toml b/test_programs/execution_success/fold_call_witness_condition/Nargo.toml
new file mode 100644
index 00000000000..cedaea348c5
--- /dev/null
+++ b/test_programs/execution_success/fold_call_witness_condition/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_call_witness_condition"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_call_witness_condition/Prover.toml b/test_programs/execution_success/fold_call_witness_condition/Prover.toml
new file mode 100644
index 00000000000..8481ce25648
--- /dev/null
+++ b/test_programs/execution_success/fold_call_witness_condition/Prover.toml
@@ -0,0 +1,5 @@
+# TODO(https://github.com/noir-lang/noir/issues/4707): Change these inputs to fail the assertion in `fn return_value`
+# and change `enable` to false. For now we need the inputs to pass as we do not handle predicates with ACIR calls
+x = "5"
+y = "10"
+enable = true
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_call_witness_condition/src/main.nr b/test_programs/execution_success/fold_call_witness_condition/src/main.nr
new file mode 100644
index 00000000000..5dc75e4a99f
--- /dev/null
+++ b/test_programs/execution_success/fold_call_witness_condition/src/main.nr
@@ -0,0 +1,16 @@
+global NUM_RESULTS = 2;
+fn main(x: Field, y: pub Field, enable: bool) -> pub [Field; NUM_RESULTS] {
+    let mut result = [0; NUM_RESULTS];
+    for i in 0..NUM_RESULTS {
+        if enable {
+            result[i] = return_value(x, y);
+        }
+    }
+    result
+}
+
+#[fold]
+fn return_value(x: Field, y: Field) -> Field {
+    assert(x != y);
+    x
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 5a42ef36e7e..4507aeb8545 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -14,3 +14,4 @@ signed_comparison
 to_bytes_integration
 fold_basic
 fold_basic_nested_call
+fold_call_witness_condition

From 68f9eeb54655dc87b6ecaec75c93b20d34ff8bad Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 3 Apr 2024 19:51:53 +0100
Subject: [PATCH 144/416] chore: simplify how `acvm_backend.wasm` is embedded
 (#4703)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We only need a single file to be embedded into `bn254_blackbox_solver`
so we don't need the overhead of `rust_embed`. We can instead just
assign the bytes to a const variable.

I've also removed some build dependencies which are unnecessary.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |  16 --------------
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |  20 ++----------------
 acvm-repo/bn254_blackbox_solver/build.rs      |  14 ------------
 .../src/{ => wasm}/acvm_backend.wasm          | Bin
 .../bn254_blackbox_solver/src/wasm/mod.rs     |  13 ++++--------
 5 files changed, 6 insertions(+), 57 deletions(-)
 delete mode 100644 acvm-repo/bn254_blackbox_solver/build.rs
 rename acvm-repo/bn254_blackbox_solver/src/{ => wasm}/acvm_backend.wasm (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 2371ef6df05..906e49df6ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -606,16 +606,11 @@ dependencies = [
  "ark-ec",
  "ark-ff",
  "cfg-if 1.0.0",
- "flate2",
  "getrandom 0.2.10",
  "js-sys",
  "noir_grumpkin",
  "num-bigint",
  "num-traits",
- "pkg-config",
- "reqwest",
- "rust-embed",
- "tar",
  "thiserror",
  "wasm-bindgen-futures",
  "wasmer",
@@ -4037,7 +4032,6 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rust-embed-utils",
- "shellexpand",
  "syn 2.0.32",
  "walkdir",
 ]
@@ -4048,7 +4042,6 @@ version = "7.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d38ff6bf570dc3bb7100fce9f7b60c33fa71d80e88da3f2580df4ff2bdded74"
 dependencies = [
- "globset",
  "sha2",
  "walkdir",
 ]
@@ -4469,15 +4462,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
-[[package]]
-name = "shellexpand"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ccc8076840c4da029af4f87e4e8daeb0fca6b87bbb02e10cb60b791450e11e4"
-dependencies = [
- "dirs",
-]
-
 [[package]]
 name = "signature"
 version = "1.6.4"
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 8658c37420b..1ad5103d2cb 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -19,15 +19,8 @@ thiserror.workspace = true
 num-traits.workspace = true
 cfg-if = "1.0.0"
 
-rust-embed = { version = "6.6.0", features = [
-    "debug-embed",
-    "interpolate-folder-path",
-    "include-exclude",
-] }
-
-grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = [
-    "std",
-] } # BN254 fixed base scalar multiplication solver
+# BN254 fixed base scalar multiplication solver
+grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
 ark-ec = { version = "^0.4.0", default-features = false }
 ark-ff = { version = "^0.4.0", default-features = false }
 num-bigint.workspace = true
@@ -45,15 +38,6 @@ js-sys.workspace = true
 getrandom.workspace = true
 wasmer = "4.2.6"
 
-[build-dependencies]
-pkg-config = "0.3"
-tar = "~0.4.15"
-flate2 = "~1.0.1"
-reqwest = { version = "0.11.20", default-features = false, features = [
-    "rustls-tls",
-    "blocking",
-] }
-
 [features]
 default = ["bn254"]
 bn254 = ["acir/bn254"]
diff --git a/acvm-repo/bn254_blackbox_solver/build.rs b/acvm-repo/bn254_blackbox_solver/build.rs
deleted file mode 100644
index 4269c86aba0..00000000000
--- a/acvm-repo/bn254_blackbox_solver/build.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use std::path::PathBuf;
-
-const BARRETENBERG_BIN_DIR: &str = "BARRETENBERG_BIN_DIR";
-
-fn main() -> Result<(), String> {
-    let out_dir = std::env::var("OUT_DIR").unwrap();
-
-    let dest_path = PathBuf::from(out_dir.clone()).join("acvm_backend.wasm");
-
-    println!("cargo:rustc-env={BARRETENBERG_BIN_DIR}={out_dir}");
-    std::fs::copy("./src/acvm_backend.wasm", dest_path).unwrap();
-
-    Ok(())
-}
diff --git a/acvm-repo/bn254_blackbox_solver/src/acvm_backend.wasm b/acvm-repo/bn254_blackbox_solver/src/wasm/acvm_backend.wasm
similarity index 100%
rename from acvm-repo/bn254_blackbox_solver/src/acvm_backend.wasm
rename to acvm-repo/bn254_blackbox_solver/src/wasm/acvm_backend.wasm
diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
index 3c867ae48dd..f4f6f56aa99 100644
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
@@ -76,10 +76,7 @@ use wasmer::{
 pub(super) const WASM_SCRATCH_BYTES: usize = 1024;
 
 /// Embed the Barretenberg WASM file
-#[derive(rust_embed::RustEmbed)]
-#[folder = "$BARRETENBERG_BIN_DIR"]
-#[include = "acvm_backend.wasm"]
-struct Wasm;
+const WASM_BIN: &[u8] = include_bytes!("./acvm_backend.wasm");
 
 impl Barretenberg {
     #[cfg(not(target_arch = "wasm32"))]
@@ -287,7 +284,7 @@ fn instance_load() -> (Instance, Memory, Store) {
 
     let (memory, mut store, custom_imports) = init_memory_and_state();
 
-    let module = Module::new(&store, Wasm::get("acvm_backend.wasm").unwrap().data).unwrap();
+    let module = Module::new(&store, WASM_BIN).unwrap();
 
     (Instance::new(&mut store, &module, &custom_imports).unwrap(), memory, store)
 }
@@ -299,9 +296,7 @@ async fn instance_load() -> (Instance, Memory, Store) {
 
     let (memory, mut store, custom_imports) = init_memory_and_state();
 
-    let wasm_binary = Wasm::get("acvm_backend.wasm").unwrap().data;
-
-    let js_bytes = unsafe { js_sys::Uint8Array::view(&wasm_binary) };
+    let js_bytes = unsafe { js_sys::Uint8Array::view(&WASM_BIN) };
     let js_module_promise = WebAssembly::compile(&js_bytes);
     let js_module: js_sys::WebAssembly::Module =
         wasm_bindgen_futures::JsFuture::from(js_module_promise).await.unwrap().into();
@@ -309,7 +304,7 @@ async fn instance_load() -> (Instance, Memory, Store) {
     let js_instance_promise =
         WebAssembly::instantiate_module(&js_module, &custom_imports.as_jsvalue(&store).into());
     let js_instance = wasm_bindgen_futures::JsFuture::from(js_instance_promise).await.unwrap();
-    let module: wasmer::Module = (js_module, wasm_binary).into();
+    let module = wasmer::Module::from((js_module, WASM_BIN));
     let instance: wasmer::Instance = Instance::from_jsvalue(&mut store, &module, &js_instance)
         .map_err(|_| "Error while creating BlackBox Functions vendor instance")
         .unwrap();

From 62423d552beca749b6f86b1330555aab18db58d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Thu, 4 Apr 2024 16:19:56 +0200
Subject: [PATCH 145/416] feat: Allow slices to brillig entry points (#4713)

# Description

## Problem\*

Allows passing slices to brillig entry points, since ACIR knows the
initial length of the slice and is fixed at compile time.

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_fn.rs     | 19 +-----
 .../src/brillig/brillig_ir/artifact.rs        |  5 +-
 .../src/brillig/brillig_ir/entry_point.rs     | 60 ++++++++++++++-----
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 46 ++++++++++++--
 .../brillig_slice_input/Nargo.toml            |  6 ++
 .../brillig_slice_input/src/main.nr           | 40 +++++++++++++
 6 files changed, 139 insertions(+), 37 deletions(-)
 create mode 100644 test_programs/execution_success/brillig_slice_input/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_slice_input/src/main.nr

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index 92027026ce8..617e400b92f 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -70,7 +70,7 @@ impl FunctionContext {
         function_id.to_string()
     }
 
-    fn ssa_type_to_parameter(typ: &Type) -> BrilligParameter {
+    pub(crate) fn ssa_type_to_parameter(typ: &Type) -> BrilligParameter {
         match typ {
             Type::Numeric(_) | Type::Reference(_) => {
                 BrilligParameter::SingleAddr(get_bit_size_from_ssa_type(typ))
@@ -81,26 +81,13 @@ impl FunctionContext {
                 }),
                 *size,
             ),
-            Type::Slice(item_type) => {
-                BrilligParameter::Slice(vecmap(item_type.iter(), |item_typ| {
-                    FunctionContext::ssa_type_to_parameter(item_typ)
-                }))
+            Type::Slice(_) => {
+                panic!("ICE: Slice parameters cannot be derived from type information")
             }
             _ => unimplemented!("Unsupported function parameter/return type {typ:?}"),
         }
     }
 
-    /// Collects the parameters of a given function
-    pub(crate) fn parameters(func: &Function) -> Vec<BrilligParameter> {
-        func.parameters()
-            .iter()
-            .map(|&value_id| {
-                let typ = func.dfg.type_of_value(value_id);
-                FunctionContext::ssa_type_to_parameter(&typ)
-            })
-            .collect()
-    }
-
     /// Collects the return values of a given function
     pub(crate) fn return_values(func: &Function) -> Vec<BrilligParameter> {
         func.returns()
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index 90a5d54ae59..8ce15ba4e73 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -3,7 +3,7 @@ use std::collections::{BTreeMap, HashMap};
 
 use crate::ssa::ir::dfg::CallStack;
 
-/// Represents a parameter or a return value of a function.
+/// Represents a parameter or a return value of an entry point function.
 #[derive(Debug, Clone)]
 pub(crate) enum BrilligParameter {
     /// A single address parameter or return value. Holds the bit size of the parameter.
@@ -11,7 +11,8 @@ pub(crate) enum BrilligParameter {
     /// An array parameter or return value. Holds the type of an array item and its size.
     Array(Vec<BrilligParameter>, usize),
     /// A slice parameter or return value. Holds the type of a slice item.
-    Slice(Vec<BrilligParameter>),
+    /// Only known-length slices can be passed to brillig entry points, so the size is available as well.
+    Slice(Vec<BrilligParameter>, usize),
 }
 
 /// The result of compiling and linking brillig artifacts.
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 1d823ded718..db872487fcc 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -1,6 +1,6 @@
 use super::{
     artifact::{BrilligArtifact, BrilligParameter},
-    brillig_variable::{BrilligArray, BrilligVariable, SingleAddrVariable},
+    brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
     debug_show::DebugShow,
     registers::BrilligRegistersContext,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
@@ -83,24 +83,56 @@ impl BrilligContext {
                     current_calldata_pointer += flattened_size;
                     var
                 }
-                BrilligParameter::Slice(_) => unimplemented!("Unsupported slices as parameter"),
+                BrilligParameter::Slice(_, _) => {
+                    let pointer_to_the_array_in_calldata =
+                        self.make_usize_constant_instruction(current_calldata_pointer.into());
+
+                    let flattened_size = BrilligContext::flattened_size(argument);
+                    let size_register = self.make_usize_constant_instruction(flattened_size.into());
+                    let rc_register = self.make_usize_constant_instruction(1_usize.into());
+
+                    let var = BrilligVariable::BrilligVector(BrilligVector {
+                        pointer: pointer_to_the_array_in_calldata.address,
+                        size: size_register.address,
+                        rc: rc_register.address,
+                    });
+
+                    current_calldata_pointer += flattened_size;
+                    var
+                }
             })
             .collect();
 
         // Deflatten arrays
         for (argument_variable, argument) in argument_variables.iter_mut().zip(arguments) {
-            if let (
-                BrilligVariable::BrilligArray(array),
-                BrilligParameter::Array(item_type, item_count),
-            ) = (argument_variable, argument)
-            {
-                if BrilligContext::has_nested_arrays(item_type) {
+            match (argument_variable, argument) {
+                (
+                    BrilligVariable::BrilligArray(array),
+                    BrilligParameter::Array(item_type, item_count),
+                ) => {
                     let deflattened_address =
                         self.deflatten_array(item_type, array.size, array.pointer);
                     self.mov_instruction(array.pointer, deflattened_address);
                     array.size = item_type.len() * item_count;
                     self.deallocate_register(deflattened_address);
                 }
+                (
+                    BrilligVariable::BrilligVector(vector),
+                    BrilligParameter::Slice(item_type, item_count),
+                ) => {
+                    let flattened_size = BrilligContext::flattened_size(argument);
+
+                    let deflattened_address =
+                        self.deflatten_array(item_type, flattened_size, vector.pointer);
+                    self.mov_instruction(vector.pointer, deflattened_address);
+                    self.usize_const_instruction(
+                        vector.size,
+                        (item_type.len() * item_count).into(),
+                    );
+
+                    self.deallocate_register(deflattened_address);
+                }
+                _ => {}
             }
         }
     }
@@ -112,10 +144,10 @@ impl BrilligContext {
         fn flat_bit_sizes(param: &BrilligParameter) -> Box<dyn Iterator<Item = u32> + '_> {
             match param {
                 BrilligParameter::SingleAddr(bit_size) => Box::new(std::iter::once(*bit_size)),
-                BrilligParameter::Array(item_types, item_count) => Box::new(
+                BrilligParameter::Array(item_types, item_count)
+                | BrilligParameter::Slice(item_types, item_count) => Box::new(
                     (0..*item_count).flat_map(move |_| item_types.iter().flat_map(flat_bit_sizes)),
                 ),
-                BrilligParameter::Slice(..) => unimplemented!("Unsupported slices as parameter"),
             }
         }
 
@@ -134,13 +166,11 @@ impl BrilligContext {
     fn flattened_size(param: &BrilligParameter) -> usize {
         match param {
             BrilligParameter::SingleAddr(_) => 1,
-            BrilligParameter::Array(item_types, item_count) => {
+            BrilligParameter::Array(item_types, item_count)
+            | BrilligParameter::Slice(item_types, item_count) => {
                 let item_size: usize = item_types.iter().map(BrilligContext::flattened_size).sum();
                 item_count * item_size
             }
-            BrilligParameter::Slice(_) => {
-                unreachable!("ICE: Slices cannot be passed as entry point arguments")
-            }
         }
     }
 
@@ -457,8 +487,8 @@ mod tests {
     use acvm::FieldElement;
 
     use crate::brillig::brillig_ir::{
-        artifact::BrilligParameter,
         brillig_variable::BrilligArray,
+        entry_point::BrilligParameter,
         tests::{create_and_run_vm, create_context, create_entry_point_bytecode},
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index e3dd4c33986..d4760c29eda 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -21,7 +21,7 @@ use super::{
     },
     ssa_gen::Ssa,
 };
-use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
+use crate::brillig::brillig_ir::artifact::{BrilligParameter, GeneratedBrillig};
 use crate::brillig::brillig_ir::BrilligContext;
 use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig};
 use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
@@ -297,12 +297,14 @@ impl Context {
             let typ = dfg.type_of_value(*param_id);
             self.create_value_from_type(&typ, &mut |this, _| Ok(this.acir_context.add_variable()))
         })?;
+        let arguments = self.gen_brillig_parameters(dfg[main_func.entry_block()].parameters(), dfg);
+
         let witness_inputs = self.acir_context.extract_witness(&inputs);
 
         let outputs: Vec<AcirType> =
             vecmap(main_func.returns(), |result_id| dfg.type_of_value(*result_id).into());
 
-        let code = self.gen_brillig_for(main_func, brillig)?;
+        let code = self.gen_brillig_for(main_func, arguments, brillig)?;
 
         // We specifically do not attempt execution of the brillig code being generated as this can result in it being
         // replaced with constraints on witnesses to the program outputs.
@@ -594,8 +596,9 @@ impl Context {
                                 }
 
                                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
+                                let arguments = self.gen_brillig_parameters(arguments, dfg);
 
-                                let code = self.gen_brillig_for(func, brillig)?;
+                                let code = self.gen_brillig_for(func, arguments, brillig)?;
 
                                 let outputs: Vec<AcirType> = vecmap(result_ids, |result_id| {
                                     dfg.type_of_value(*result_id).into()
@@ -673,14 +676,49 @@ impl Context {
         Ok(())
     }
 
+    fn gen_brillig_parameters(
+        &self,
+        values: &[ValueId],
+        dfg: &DataFlowGraph,
+    ) -> Vec<BrilligParameter> {
+        values
+            .iter()
+            .map(|&value_id| {
+                let typ = dfg.type_of_value(value_id);
+                if let Type::Slice(item_types) = typ {
+                    let len = match self
+                        .ssa_values
+                        .get(&value_id)
+                        .expect("ICE: Unknown slice input to brillig")
+                    {
+                        AcirValue::DynamicArray(AcirDynamicArray { len, .. }) => *len,
+                        AcirValue::Array(array) => array.len(),
+                        _ => unreachable!("ICE: Slice value is not an array"),
+                    };
+
+                    BrilligParameter::Slice(
+                        item_types
+                            .iter()
+                            .map(BrilligFunctionContext::ssa_type_to_parameter)
+                            .collect(),
+                        len / item_types.len(),
+                    )
+                } else {
+                    BrilligFunctionContext::ssa_type_to_parameter(&typ)
+                }
+            })
+            .collect()
+    }
+
     fn gen_brillig_for(
         &self,
         func: &Function,
+        arguments: Vec<BrilligParameter>,
         brillig: &Brillig,
     ) -> Result<GeneratedBrillig, InternalError> {
         // Create the entry point artifact
         let mut entry_point = BrilligContext::new_entry_point_artifact(
-            BrilligFunctionContext::parameters(func),
+            arguments,
             BrilligFunctionContext::return_values(func),
             BrilligFunctionContext::function_id_to_function_label(func.id()),
         );
diff --git a/test_programs/execution_success/brillig_slice_input/Nargo.toml b/test_programs/execution_success/brillig_slice_input/Nargo.toml
new file mode 100644
index 00000000000..a1c8cc3242b
--- /dev/null
+++ b/test_programs/execution_success/brillig_slice_input/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "brillig_slice_input"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_slice_input/src/main.nr b/test_programs/execution_success/brillig_slice_input/src/main.nr
new file mode 100644
index 00000000000..09a9d9aef9d
--- /dev/null
+++ b/test_programs/execution_success/brillig_slice_input/src/main.nr
@@ -0,0 +1,40 @@
+struct Point {
+    x: Field,
+    y: Field,
+}
+
+unconstrained fn sum_slice(slice: [[Point; 2]]) -> Field {
+    let mut sum = 0;
+    for i in 0..slice.len() {
+        for j in 0..slice[i].len() {
+            sum += slice[i][j].x + slice[i][j].y;
+        }
+    }
+    sum
+}
+
+fn main() {
+    let mut slice = &[];
+    slice = slice.push_back([
+        Point {
+            x: 13,
+            y: 14,
+        },
+        Point {
+            x: 20,
+            y: 8,
+        }
+    ]);
+    slice = slice.push_back([
+        Point {
+            x: 15,
+            y: 5,
+        },
+        Point {
+            x: 12,
+            y: 13,
+        }
+    ]);
+    let brillig_sum = sum_slice(slice);
+    assert_eq(brillig_sum, 100);
+}

From 5e7fbd4e706b1691ba2dd960469cfa3b31dfb753 Mon Sep 17 00:00:00 2001
From: SamiAlHassan <150172180+SamiAlHassan@users.noreply.github.com>
Date: Thu, 4 Apr 2024 17:47:10 +0100
Subject: [PATCH 146/416] feat: improve nargo check cli with --override flag
 and feedback for existing files (#4575)

Recently, while working with `nargo check`, I noticed when Prover.toml
and Verifier.toml files already existed, running `nargo check` would not
update these files unless they were manually deleted and the command was
rerun. This was a bit frustrating, as there was no indication of why
changes weren't being applied and a success message was still output.

To address this, I've made an enhancement that improves t he user
experience in two ways:
1. If Prover.toml and Verifier.toml exist and `--override` is not used,
`nargo check` will no longer show a success message misleadingly. This
clarifies that no changes were made due to the presence of these files.
2. It introduces guidance to use the `--override` flag if the intention
is to update these existing files, making it clear how to proceed to
apply the desired changes.

This makes it more intuitive by removing the need to manually delete
files Prover.toml and Verifier.toml

### Changes:

- **When both files exist without using --override**: The tool will
alert you that Prover.toml and Verifier.toml already exist and suggest
using `--override` to update them.
```sh
sh-5.2# nargo check
Warning: Prover.toml already exists. Use --override to force overwrite.
Warning: Verifier.toml already exists. Use --override to force overwrite.
```

- **When no file exists**: It proceeds as expected, building the
constraint system successfully.
```sh
sh-5.2# nargo check
[simple_range] Constraint system successfully built!
```

- **When files exist and --override is used**: It overwrites the
existing files and rebuilds the constraint system.
```sh
sh-5.2# nargo check --override
[simple_range] Constraint system successfully built!
```

- **When only one of the files exists**: It creates or overwrites the
missing file, as needed, without the need for `--override` for the
missing one, but warns about the existing file.
```sh
sh-5.2# nargo check
Warning: Prover.toml already exists. Use --override to force overwrite.
[simple_range] Constraint system successfully built!
```
```sh
sh-5.2# nargo check
Warning: Verifier.toml already exists. Use --override to force overwrite.
[simple_range] Constraint system successfully built!
```

- **With --override, even if only one file exists**: Both files are
re/created.
```sh
sh-5.2# nargo check --override
[simple_range] Constraint system successfully built!
```

**override flag in --help:**

```sh
sh-5.2# nargo check --help
Checks the constraint system for errors

Usage: nargo check [OPTIONS]

Options:
      --package <PACKAGE>                    The name of the package to check
      --workspace                            Check all packages in the workspace
      --override                             Force overwrite of existing files
      --expression-width <EXPRESSION_WIDTH>  Override the expression width requested by the backend
      --force                                Force a full recompilation
      --print-acir                           Display the ACIR for compiled circuit
      --deny-warnings                        Treat all warnings as errors
      --silence-warnings                     Suppress warnings
  -h, --help                                 Print help
```

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 tooling/nargo_cli/src/cli/check_cmd.rs | 43 +++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 8 deletions(-)

diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 897073f4e20..2b729e44b8a 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -34,6 +34,10 @@ pub(crate) struct CheckCommand {
     #[clap(long, conflicts_with = "package")]
     workspace: bool,
 
+    /// Force overwrite of existing files
+    #[clap(long = "overwrite")]
+    allow_overwrite: bool,
+
     #[clap(flatten)]
     compile_options: CompileOptions,
 }
@@ -58,18 +62,29 @@ pub(crate) fn run(
     let parsed_files = parse_all(&workspace_file_manager);
 
     for package in &workspace {
-        check_package(&workspace_file_manager, &parsed_files, package, &args.compile_options)?;
-        println!("[{}] Constraint system successfully built!", package.name);
+        let any_file_written = check_package(
+            &workspace_file_manager,
+            &parsed_files,
+            package,
+            &args.compile_options,
+            args.allow_overwrite,
+        )?;
+        if any_file_written {
+            println!("[{}] Constraint system successfully built!", package.name);
+        }
     }
     Ok(())
 }
 
+/// Evaluates the necessity to create or update Prover.toml and Verifier.toml based on the allow_overwrite flag and files' existence.
+/// Returns `true` if any file was generated or updated, `false` otherwise.
 fn check_package(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
     package: &Package,
     compile_options: &CompileOptions,
-) -> Result<(), CompileError> {
+    allow_overwrite: bool,
+) -> Result<bool, CompileError> {
     let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
     check_crate_and_report_errors(
         &mut context,
@@ -81,27 +96,39 @@ fn check_package(
 
     if package.is_library() || package.is_contract() {
         // Libraries do not have ABIs while contracts have many, so we cannot generate a `Prover.toml` file.
-        Ok(())
+        Ok(false)
     } else {
         // XXX: We can have a --overwrite flag to determine if you want to overwrite the Prover/Verifier.toml files
         if let Some((parameters, return_type)) = compute_function_abi(&context, &crate_id) {
             let path_to_prover_input = package.prover_input_path();
             let path_to_verifier_input = package.verifier_input_path();
 
-            // If they are not available, then create them and populate them based on the ABI
-            if !path_to_prover_input.exists() {
+            // Before writing the file, check if it exists and whether overwrite is set
+            let should_write_prover = !path_to_prover_input.exists() || allow_overwrite;
+            let should_write_verifier = !path_to_verifier_input.exists() || allow_overwrite;
+
+            if should_write_prover {
                 let prover_toml = create_input_toml_template(parameters.clone(), None);
                 write_to_file(prover_toml.as_bytes(), &path_to_prover_input);
+            } else {
+                eprintln!("Note: Prover.toml already exists. Use --overwrite to force overwrite.");
             }
-            if !path_to_verifier_input.exists() {
+
+            if should_write_verifier {
                 let public_inputs =
                     parameters.into_iter().filter(|param| param.is_public()).collect();
 
                 let verifier_toml = create_input_toml_template(public_inputs, return_type);
                 write_to_file(verifier_toml.as_bytes(), &path_to_verifier_input);
+            } else {
+                eprintln!(
+                    "Note: Verifier.toml already exists. Use --overwrite to force overwrite."
+                );
             }
 
-            Ok(())
+            let any_file_written = should_write_prover || should_write_verifier;
+
+            Ok(any_file_written)
         } else {
             Err(CompileError::MissingMainFunction(package.name.clone()))
         }

From 59fb83291063d48496b57f3b1f986376bc8f56a4 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 4 Apr 2024 22:46:39 +0100
Subject: [PATCH 147/416] chore: remove unused env vars from `Cross.toml`
 (#4717)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Followup to #4703 and #4705.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/Cross.toml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/Cross.toml b/.github/Cross.toml
index 6520a288d5d..d8516b9ae09 100644
--- a/.github/Cross.toml
+++ b/.github/Cross.toml
@@ -2,8 +2,6 @@
 passthrough = [
     "HOME",
     "RUST_BACKTRACE",
-    "BARRETENBERG_BIN_DIR",
-    "BLNS_JSON_PATH"
 ]
 volumes = [
     "HOME",

From f21129ef05efb76c5df6ee15a134f1ea535d8e90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Fri, 5 Apr 2024 14:36:09 +0200
Subject: [PATCH 148/416] fix: unknown slice lengths coming from as_slice
 (#4725)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4722

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 compiler/noirc_evaluator/src/ssa.rs           |  1 +
 compiler/noirc_evaluator/src/ssa/ir/dfg.rs    | 24 +++++++
 .../src/ssa/opt/as_slice_length.rs            | 71 +++++++++++++++++++
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |  1 +
 .../array_to_slice_constant_length/Nargo.toml |  7 ++
 .../Prover.toml                               |  1 +
 .../src/main.nr                               | 10 +++
 7 files changed, 115 insertions(+)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
 create mode 100644 test_programs/execution_success/array_to_slice_constant_length/Nargo.toml
 create mode 100644 test_programs/execution_success/array_to_slice_constant_length/Prover.toml
 create mode 100644 test_programs/execution_success/array_to_slice_constant_length/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index a45cf3af608..4b2f1060c88 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -53,6 +53,7 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::inline_functions, "After Inlining:")
         // Run mem2reg with the CFG separated into blocks
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
+        .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
         .try_run_pass(Ssa::evaluate_assert_constant, "After Assert Constant:")?
         .try_run_pass(Ssa::unroll_loops, "After Unrolling:")?
         .run_pass(Ssa::simplify_cfg, "After Simplifying:")
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
index 870b5e602f1..6b950c327cf 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
@@ -378,6 +378,30 @@ impl DataFlowGraph {
         value_id
     }
 
+    /// Replaces an instruction result with a fresh id.
+    pub(crate) fn replace_result(
+        &mut self,
+        instruction_id: InstructionId,
+        prev_value_id: ValueId,
+    ) -> ValueId {
+        let typ = self.type_of_value(prev_value_id);
+        let results = self.results.get_mut(&instruction_id).unwrap();
+        let res_position = results
+            .iter()
+            .position(|&id| id == prev_value_id)
+            .expect("Result id not found while replacing");
+
+        let value_id = self.values.insert(Value::Instruction {
+            typ,
+            position: res_position,
+            instruction: instruction_id,
+        });
+
+        // Replace the value in list of results for this instruction
+        results[res_position] = value_id;
+        value_id
+    }
+
     /// Returns the number of instructions
     /// inserted into functions.
     pub(crate) fn num_instructions(&self) -> usize {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
new file mode 100644
index 00000000000..69eab1da0ed
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
@@ -0,0 +1,71 @@
+use crate::ssa::{
+    ir::{
+        function::Function,
+        instruction::{Instruction, InstructionId, Intrinsic},
+        types::Type,
+        value::Value,
+    },
+    ssa_gen::Ssa,
+};
+use fxhash::FxHashMap as HashMap;
+
+impl Ssa {
+    /// A simple SSA pass to find any calls to `Intrinsic::AsSlice` and replacing any references to the length of the
+    /// resulting slice with the length of the array from which it was generated.
+    ///
+    /// This allows the length of a slice generated from an array to be used in locations where a constant value is
+    /// necessary when the value of the array is unknown.
+    ///
+    /// Note that this pass must be placed before loop unrolling to be useful.
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn as_slice_optimization(mut self) -> Self {
+        for func in self.functions.values_mut() {
+            let known_slice_lengths = known_slice_lengths(func);
+            replace_known_slice_lengths(func, known_slice_lengths);
+        }
+        self
+    }
+}
+
+fn known_slice_lengths(func: &Function) -> HashMap<InstructionId, usize> {
+    let mut known_slice_lengths = HashMap::default();
+    for block_id in func.reachable_blocks() {
+        let block = &func.dfg[block_id];
+        for instruction_id in block.instructions() {
+            let (target_func, arguments) = match &func.dfg[*instruction_id] {
+                Instruction::Call { func, arguments } => (func, arguments),
+                _ => continue,
+            };
+
+            match &func.dfg[*target_func] {
+                Value::Intrinsic(Intrinsic::AsSlice) => {
+                    let array_typ = func.dfg.type_of_value(arguments[0]);
+                    if let Type::Array(_, length) = array_typ {
+                        known_slice_lengths.insert(*instruction_id, length);
+                    } else {
+                        unreachable!("AsSlice called with non-array {}", array_typ);
+                    }
+                }
+                _ => continue,
+            };
+        }
+    }
+    known_slice_lengths
+}
+
+fn replace_known_slice_lengths(
+    func: &mut Function,
+    known_slice_lengths: HashMap<InstructionId, usize>,
+) {
+    known_slice_lengths.into_iter().for_each(|(instruction_id, known_length)| {
+        let call_returns = func.dfg.instruction_results(instruction_id);
+        let original_slice_length = call_returns[0];
+
+        // We won't use the new id for the original unknown length.
+        // This isn't strictly necessary as a new result will be defined the next time for which the instruction
+        // is reinserted but this avoids leaving the program in an invalid state.
+        func.dfg.replace_result(instruction_id, original_slice_length);
+        let known_length = func.dfg.make_constant(known_length.into(), Type::length_type());
+        func.dfg.set_value_from_id(original_slice_length, known_length);
+    });
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index 479010b1ed8..f37f45b30bb 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -4,6 +4,7 @@
 //! simpler form until the IR only has a single function remaining with 1 block within it.
 //! Generally, these passes are also expected to minimize the final amount of instructions.
 mod array_set;
+mod as_slice_length;
 mod assert_constant;
 mod bubble_up_constrains;
 mod constant_folding;
diff --git a/test_programs/execution_success/array_to_slice_constant_length/Nargo.toml b/test_programs/execution_success/array_to_slice_constant_length/Nargo.toml
new file mode 100644
index 00000000000..b338cf9b6ae
--- /dev/null
+++ b/test_programs/execution_success/array_to_slice_constant_length/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "array_to_slice_constant_length"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/array_to_slice_constant_length/Prover.toml b/test_programs/execution_success/array_to_slice_constant_length/Prover.toml
new file mode 100644
index 00000000000..a52e9d3c46a
--- /dev/null
+++ b/test_programs/execution_success/array_to_slice_constant_length/Prover.toml
@@ -0,0 +1 @@
+val = "42"
diff --git a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
new file mode 100644
index 00000000000..e81dd4a0c5f
--- /dev/null
+++ b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
@@ -0,0 +1,10 @@
+// Regression test for https://github.com/noir-lang/noir/issues/4722
+
+unconstrained fn return_array(val: Field) -> [Field; 1] {
+    [val; 1]
+}
+
+fn main(val: Field) {
+    let array = return_array(val);
+    assert_constant(array.as_slice().len());
+}

From 0dac0934d1cc646f87d266b2c54d8d505756fa68 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 5 Apr 2024 14:18:37 +0100
Subject: [PATCH 149/416] chore: remove docker CI flow (#4724)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This set of workflows aren't really usable currently due to lack of
caching. They're not being run on PRs so it's constantly breaking but
putting it on PRs would blow up our CI times.

We're likely to move instead to earthly (#4696) if we are moving to a
docker-based system so we should remove this.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/docker-test-flow.yml | 808 -------------------------
 Dockerfile.ci                          |  30 -
 2 files changed, 838 deletions(-)
 delete mode 100644 .github/workflows/docker-test-flow.yml
 delete mode 100644 Dockerfile.ci

diff --git a/.github/workflows/docker-test-flow.yml b/.github/workflows/docker-test-flow.yml
deleted file mode 100644
index c8b4f53fadd..00000000000
--- a/.github/workflows/docker-test-flow.yml
+++ /dev/null
@@ -1,808 +0,0 @@
-name: Test Nargo and JS packages
-
-on:
-  push:
-    branches:
-      - 'master'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  build-base-nargo:
-    name: Build base nargo docker image
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Get current date
-        id: date
-        run: echo "date=$(date +'%Y.%m.%d.%H.%M')" >> $GITHUB_STATE
-      - name: prepare docker images tags
-        id: prep
-        run: |
-          REGISTRY="ghcr.io"
-          IMG_RAW="${REGISTRY}/${{ github.repository }}"
-          IMAGE=$(echo "$IMG_RAW" | tr '[:upper:]' '[:lower:]')
-          TAGS="${IMAGE}:${{ github.sha }}-nargo"
-          FULL_TAGS="${TAGS},${IMAGE}:latest-nargo,${IMAGE}:v${{ steps.date.outputs.date }}-nargo"
-          echo "tags=$FULL_TAGS" >> $GITHUB_OUTPUT
-          echo "image=$IMAGE" >> $GITHUB_OUTPUT
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to GitHub Container Registry        
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build nargo base dockerfile
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: Dockerfile.ci
-          tags: ${{ steps.prep.outputs.tags }}
-          target: base-nargo
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          push: true
-
-  build-base-js:
-    name: Build base js docker image
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Get current date
-        id: date
-        run: echo "date=$(date +'%Y.%m.%d.%H.%M')" >> $GITHUB_STATE
-      - name: Prepare docker image tags
-        id: prep
-        run: |
-          REGISTRY="ghcr.io"
-          IMG_RAW="${REGISTRY}/${{ github.repository }}"
-          IMAGE=$(echo "$IMG_RAW" | tr '[:upper:]' '[:lower:]')
-          TAGS="${IMAGE}:${{ github.sha }}-js"
-          FULL_TAGS="${TAGS},${IMAGE}:latest-js,${IMAGE}:v${{ steps.date.outputs.date }}-js"
-          echo "tags=$FULL_TAGS" >> $GITHUB_OUTPUT
-          echo "image=$IMAGE" >> $GITHUB_OUTPUT
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to GitHub Container Registry        
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build js base dockerfile
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: Dockerfile.ci
-          tags: ${{ steps.prep.outputs.tags }}
-          target: base-js
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          push: true
-
-  artifact-nargo:
-    name: Artifact nargo 
-    runs-on: ubuntu-latest
-    needs: [build-base-nargo]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-nargo
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Artifact nargo
-        uses: actions/upload-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release/nargo
-          if-no-files-found: error
-          compression-level: 0
-  
-  test-nargo:
-    name: Test nargo 
-    runs-on: ubuntu-latest
-    needs: [build-base-nargo]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-nargo
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          .github/scripts/nargo-test.sh
-
-  build-noir-wasm:
-    name: Build noir wasm
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-wasm-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: noir_wasm
-          path: /usr/src/noir/compiler/wasm
-          retention-days: 10
-      
-  test-noir-wasm:
-    name: Test noir wasm
-    runs-on: ubuntu-latest
-    needs: [build-base-js, artifact-nargo, build-noir-wasm]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: Prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download noir_wasm artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_wasm
-          path: /usr/src/noir/compiler/wasm
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-wasm-test.sh
-
-  test-noir-wasm-browser:
-    name: Test noir wasm browser
-    runs-on: ubuntu-latest
-    needs: [build-base-js, artifact-nargo, build-noir-wasm]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: Prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download noir_wasm artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_wasm
-          path: /usr/src/noir/compiler/wasm
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-wasm-test-browser.sh
-
-  build-acvm_js:
-    name: Build acvm js
-    runs-on: ubuntu-latest
-    needs: [build-base-js]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/acvm_js-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: acvm_js
-          path:
-            /usr/src/noir/acvm-repo/acvm_js/outputs/out/acvm_js
-          if-no-files-found: error
-          compression-level: 0
-
-  test-acvm_js:
-    name: Test acvm js
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-acvm_js]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: |
-            /usr/src/noir/acvm-repo/acvm_js
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/acvm_js-test.sh
-
-  test-acvm_js-browser:
-    name: Test acvm js browser
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-acvm_js]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: |
-            /usr/src/noir/acvm-repo/acvm_js
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/acvm_js-test-browser.sh
-
-  build-noirc-abi:
-    name: Build noirc abi
-    runs-on: ubuntu-latest
-    needs: [build-base-js]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noirc-abi-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path:
-            /usr/src/noir/tooling/noirc_abi_wasm/outputs/out/noirc_abi_wasm
-          if-no-files-found: error
-          compression-level: 0
-
-  test-noirc-abi:
-    name: Test noirc abi
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noirc-abi-test.sh
-
-  test-noirc-abi-browser:
-    name: Test noirc abi browser
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noirc-abi-test-browser.sh
-
-  build-noir-js-types:
-    name: Build noir js types
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-js-types-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-          if-no-files-found: error
-          compression-level: 0
-
-  build-barretenberg-backend:
-    name: Build Barretenberg backend
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi, build-noir-js-types]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: /usr/src/noir/tooling/noir_js_types/lib/
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/backend-barretenberg-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: barretenberg-backend
-          path:
-            /usr/src/noir/tooling/noir_js_backend_barretenberg/lib
-          if-no-files-found: error
-          compression-level: 0
-
-  test-barretenberg-backend:
-    name: Test Barretenberg backend
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi, build-noir-js-types, build-barretenberg-backend]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: /usr/src/noir/tooling/noir_js_types/lib/
-      - name: Download Backend barretenberg
-        uses: actions/download-artifact@v4
-        with:
-          name: barretenberg-backend
-          path:
-            /usr/src/noir/tooling/noir_js_backend_barretenberg/lib
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/backend-barretenberg-test.sh
-
-  build-noir_js:
-    name: Build noirjs
-    runs-on: ubuntu-latest
-    needs: [build-base-js, artifact-nargo, build-noirc-abi, build-acvm_js, build-barretenberg-backend, build-noir-js-types]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: |
-            /usr/src/noir/acvm-repo/acvm_js
-      - name: Download Barretenberg backend
-        uses: actions/download-artifact@v4
-        with:
-          name: barretenberg-backend
-          path:
-            /usr/src/noir/tooling/noir_js_backend_barretenberg/lib
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-js-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: noir_js
-          path:
-            /usr/src/noir/tooling/noir_js/lib
-
-  test-noir_js:
-    name: Test noirjs
-    runs-on: ubuntu-latest
-    needs: [
-      build-base-js,
-      build-noirc-abi,
-      artifact-nargo,
-      build-acvm_js,
-      build-barretenberg-backend,
-      build-noir_js,
-      build-noir-js-types
-    ]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: Prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: |
-            /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: |
-            /usr/src/noir/acvm-repo/acvm_js
-      - name: Download Barretenberg backend
-        uses: actions/download-artifact@v4
-        with:
-          name: barretenberg-backend
-          path:
-            /usr/src/noir/tooling/noir_js_backend_barretenberg/lib
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-      - name: Download noir js
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_js
-          path:
-            /usr/src/noir/tooling/noir_js/lib
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-js-test.sh
-
-  build-noir_codegen:
-    name: Build noir codegen
-    runs-on: ubuntu-latest
-    needs: [build-base-js, build-noirc-abi, build-acvm_js,  build-noir-js-types, build-noir_js]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: Prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noirc abi package
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: /usr/src/noir/acvm-repo/acvm_js
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-      - name: Download noir js
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_js
-          path:
-            /usr/src/noir/tooling/noir_js/lib
-      - name: Build
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-codegen-build.sh
-      - name: Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: noir_codegen
-          path:
-            /usr/src/noir/tooling/noir_codegen/lib
-  
-  test-noir_codegen:
-    name: Test noir codegen
-    runs-on: ubuntu-latest
-    needs: [build-base-js, artifact-nargo, build-noirc-abi, build-acvm_js,  build-noir-js-types, build-noir_js, build-noir_codegen]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: Prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: /usr/src/noir/acvm-repo/acvm_js
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-      - name: Download noir js
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_js
-          path:
-            /usr/src/noir/tooling/noir_js/lib
-      - name: Download noir codegen
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_codegen
-          path:
-            /usr/src/noir/tooling/noir_codegen/lib
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/noir-codegen-test.sh
-
-  test-integration:
-    name: Integration test
-    runs-on: ubuntu-latest
-    needs: [
-      build-base-js,
-      artifact-nargo,
-      build-noir-wasm,
-      build-noirc-abi,
-      build-acvm_js,
-      build-noir-js-types,
-      build-noir_js,
-      build-barretenberg-backend
-    ]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download nargo
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: /usr/src/noir/target/release
-      - name: Prep downloaded artifact
-        run: |
-          chmod +x /usr/src/noir/target/release/nargo
-      - name: Download noir wasm
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_wasm
-          path: /usr/src/noir/compiler/wasm
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: /usr/src/noir/acvm-repo/acvm_js
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-      - name: Download noir js
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_js
-          path:
-            /usr/src/noir/tooling/noir_js/lib
-      - name: Download Barretenberg backend
-        uses: actions/download-artifact@v4
-        with:
-          name: barretenberg-backend
-          path:
-            /usr/src/noir/tooling/noir_js_backend_barretenberg/lib
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/integration-test-node.sh
-
-  test-integration-browser:
-    name: Integration test browser
-    runs-on: ubuntu-latest
-    needs: [
-      build-base-js,
-      build-noir-wasm,
-      build-noirc-abi,
-      build-acvm_js,
-      build-noir-js-types,
-      build-noir_js,
-      build-barretenberg-backend
-    ]
-    container:
-      image: ghcr.io/noir-lang/noir:${{ github.sha }}-js
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.github_token }}
-    steps:
-      - name: Download noir wasm
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_wasm
-          path: /usr/src/noir/compiler/wasm
-      - name: Download noirc abi
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: /usr/src/noir/tooling/noirc_abi_wasm
-      - name: Download acvm js
-        uses: actions/download-artifact@v4
-        with:
-          name: acvm_js
-          path: /usr/src/noir/acvm-repo/acvm_js
-      - name: Download noir js types
-        uses: actions/download-artifact@v4
-        with:
-          name: noir-js-types
-          path: |
-            /usr/src/noir/tooling/noir_js_types/lib
-      - name: Download noir js
-        uses: actions/download-artifact@v4
-        with:
-          name: noir_js
-          path:
-            /usr/src/noir/tooling/noir_js/lib
-      - name: Download Barretenberg backend
-        uses: actions/download-artifact@v4
-        with:
-          name: barretenberg-backend
-          path:
-            /usr/src/noir/tooling/noir_js_backend_barretenberg/lib
-      - name: Test
-        working-directory: /usr/src/noir
-        run: |
-          ./.github/scripts/integration-test-browser.sh
-
-  tests-end:
-    name: End
-    runs-on: ubuntu-latest
-    if: ${{ always() }}
-    needs: 
-      - test-nargo
-      - test-noirc-abi
-      - test-noirc-abi-browser
-      - test-noir-wasm
-      - test-noir-wasm-browser
-      - test-integration
-      - test-integration-browser
-      - test-noir_codegen
-      - test-acvm_js
-      - test-acvm_js-browser
-      - test-barretenberg-backend
-      - test-noir_js
-    
-    steps:
-        - name: Report overall success
-          run: |
-            if [[ $FAIL == true ]]; then
-                exit 1
-            else
-                exit 0
-            fi
-          env:
-            FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
diff --git a/Dockerfile.ci b/Dockerfile.ci
deleted file mode 100644
index e0dc030980c..00000000000
--- a/Dockerfile.ci
+++ /dev/null
@@ -1,30 +0,0 @@
-FROM rust:1.73.0-slim-bookworm as base
-RUN apt-get update && apt-get upgrade -y && apt-get install build-essential git -y
-WORKDIR /usr/src/noir
-ENV PATH="${PATH}:/usr/src/noir/target/release"
-
-FROM base as base-nargo
-COPY . .
-RUN .github/scripts/nargo-build.sh
-
-FROM base as base-js
-RUN apt-get install -y ca-certificates curl gnupg
-RUN mkdir -p /etc/apt/keyrings
-RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
-RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
-RUN apt-get update && apt-get install nodejs -y
-RUN corepack enable
-RUN apt-get install -y jq
-COPY yarn.lock package.json .yarnrc.yml ./
-COPY .yarn/ ./.yarn/
-COPY ./acvm-repo/acvm_js/package.json ./acvm-repo/acvm_js/
-COPY ./tooling/noirc_abi_wasm/package.json ./tooling/noirc_abi_wasm/
-COPY ./compiler/wasm/package.json ./compiler/wasm/
-COPY ./tooling/noir_js_types/package.json ./tooling/noir_js_types/
-COPY ./tooling/noir_js_backend_barretenberg/package.json ./tooling/noir_js_backend_barretenberg/
-COPY ./tooling/noir_js/package.json ./tooling/noir_js/
-COPY ./tooling/noir_codegen/package.json ./tooling/noir_codegen/
-COPY ./compiler/integration-tests/package.json ./compiler/integration-tests/
-COPY ./docs/package.json ./docs/
-RUN yarn --immutable
-COPY . .

From ff0b5bc585520d26d9dc2ac63ff31ef435597c1d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 5 Apr 2024 14:18:53 +0100
Subject: [PATCH 150/416] chore: remove `FunctionInput::dummy` (#4723)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This function is unused.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../acir/src/circuit/opcodes/black_box_function_call.rs     | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 8a0c4692282..c955e435b37 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -10,12 +10,6 @@ pub struct FunctionInput {
     pub num_bits: u32,
 }
 
-impl FunctionInput {
-    pub fn dummy() -> Self {
-        Self { witness: Witness(0), num_bits: 0 }
-    }
-}
-
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlackBoxFuncCall {
     AND {

From 70f41d81cbd7f1eccfc12c2dc12f2eb8844818fb Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 5 Apr 2024 14:58:31 +0100
Subject: [PATCH 151/416] chore(ci): stop updating version list before cutting
 new docs version (#4726)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

When cutting a new version of the docs in release PRs we're querying the
list of released noir versions from github and updating `versions.json`
before we cut the new version. This results in docusaurus thinking that
it should already have content for that version.

We can then no longer build the docs site in order to do all of the
necessary preprocessing before creating the new versioned docs folder.

This PR stops the automated polling of github on every build to prevent
this issue.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/docs-pr.yml      | 8 +++++---
 .github/workflows/publish-docs.yml | 7 ++++---
 docs/package.json                  | 5 +++--
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index 5d0b72c6ad8..1f9ccdd946b 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -75,9 +75,11 @@ jobs:
         run: |
           npm i wasm-opt -g
 
+      - name: Query active docs versions
+        run: yarn workspace docs version::stables
+
       - name: Build docs
-        run: 
-          yarn workspaces foreach -Rpt --from docs run build
+        run: yarn workspaces foreach -Rpt --from docs run build
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4
@@ -126,4 +128,4 @@ jobs:
         with:
           message: |
             FYI @noir-lang/developerrelations on Noir doc changes.
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml
index a56583b34eb..8896e613608 100644
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -28,10 +28,11 @@ jobs:
         run: |
           npm i wasm-opt -g
       
+      - name: Query active docs versions
+        run: yarn workspace docs version::stables
+
       - name: Build docs for deploying
-        working-directory: docs
-        run: 
-          yarn workspaces foreach -Rt run build
+        run: yarn workspaces foreach -Rpt --from docs run build
 
       - name: Deploy to Netlify
         uses: nwtgck/actions-netlify@v2.1
diff --git a/docs/package.json b/docs/package.json
index 78560707795..4bbdf254c50 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -5,10 +5,11 @@
   "scripts": {
     "preprocess": "yarn workspace @noir-lang/acvm_js build && ./scripts/codegen_nargo_reference.sh && yarn node ./scripts/preprocess/index.js",
     "start": "yarn preprocess && docusaurus start",
-    "build": "yarn preprocess && yarn version::stables && docusaurus build",
+    "build": "yarn preprocess && docusaurus build",
+    "clean": "rm -rf ./processed-docs ./processed-docs ./build",
     "version::stables": "ts-node ./scripts/setStable.ts",
     "serve": "serve build",
-    "version": "yarn preprocess && docusaurus build && docusaurus docs:version"
+    "version": "yarn build && docusaurus docs:version"
   },
   "dependencies": {
     "@docusaurus/core": "^3.0.1",

From 66835dae8adcb5e0e375a2ded87a8a891f3bee60 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 5 Apr 2024 15:16:24 +0100
Subject: [PATCH 152/416] chore: update from vulnerable version of h2 (#4714)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This fixes a vulnerability notice in cargo-deny.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 906e49df6ce..170b23be189 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1983,9 +1983,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.3.24"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2c4422095b67ee78da96fbb51a4cc413b3b25883c7717ff7ca1ab31022c9c9"
+checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
 dependencies = [
  "bytes",
  "fnv",

From 94952db604b70a1ec18115b291de3c52565a641e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 5 Apr 2024 20:11:21 +0100
Subject: [PATCH 153/416] feat: add `remove_enable_side_effects` SSA pass
 (#4224)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The `EnableSideEffects` instruction can hamper dead instruction
elimination in the case where it's not covering any instructions which
have side effects (and so are affected by the `EnableSideEffects`
instruction). In this case we cannot perform any DIE on instructions
used to calculate the predicate as the compiler sees their results as
being used.

This PR adds a new SSA pass which delays inserting `EnableSideEffects`
instructions until the next instruction which would be affected by them.
This means that if we hit another `EnableSideEffects` instruction first
then we can omit the previous one, unlocking more DIE opportunities.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 compiler/noirc_evaluator/src/ssa.rs           |   1 +
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |   1 +
 .../src/ssa/opt/remove_enable_side_effects.rs | 167 ++++++++++++++++++
 3 files changed, 169 insertions(+)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 4b2f1060c88..9ecf6960333 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -62,6 +62,7 @@ pub(crate) fn optimize_into_acir(
         // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
         .run_pass(Ssa::fold_constants, "After Constant Folding:")
+        .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffects removal:")
         .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
         .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
         .run_pass(Ssa::array_set_optimization, "After Array Set Optimizations:")
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index f37f45b30bb..4452840a28c 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -15,5 +15,6 @@ mod inlining;
 mod mem2reg;
 mod rc;
 mod remove_bit_shifts;
+mod remove_enable_side_effects;
 mod simplify_cfg;
 mod unrolling;
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
new file mode 100644
index 00000000000..8535dc2661f
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -0,0 +1,167 @@
+//! The goal of the "remove enable side effects" optimization pass is to delay any [Instruction::EnableSideEffects]
+//! instructions such that they cover the minimum number of instructions possible.
+//!
+//! The pass works as follows:
+//! - Insert instructions until an [Instruction::EnableSideEffects] is encountered, save this [InstructionId].
+//! - Continue inserting instructions until either
+//!     - Another [Instruction::EnableSideEffects] is encountered, if so then drop the previous [InstructionId] in favour
+//!       of this one.
+//!     - An [Instruction] with side-effects is encountered, if so then insert the currently saved [Instruction::EnableSideEffects]
+//!       before the [Instruction]. Continue inserting instructions until the next [Instruction::EnableSideEffects] is encountered.
+use std::collections::HashSet;
+
+use acvm::FieldElement;
+
+use crate::ssa::{
+    ir::{
+        basic_block::BasicBlockId,
+        dfg::DataFlowGraph,
+        function::Function,
+        instruction::{BinaryOp, Instruction, Intrinsic},
+        value::Value,
+    },
+    ssa_gen::Ssa,
+};
+
+impl Ssa {
+    /// See [`remove_enable_side_effects`][self] module for more information.
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn remove_enable_side_effects(mut self) -> Ssa {
+        for function in self.functions.values_mut() {
+            remove_enable_side_effects(function);
+        }
+        self
+    }
+}
+
+fn remove_enable_side_effects(function: &mut Function) {
+    let mut context = Context::default();
+    context.block_queue.push(function.entry_block());
+
+    while let Some(block) = context.block_queue.pop() {
+        if context.visited_blocks.contains(&block) {
+            continue;
+        }
+
+        context.visited_blocks.insert(block);
+        context.remove_enable_side_effects_in_block(function, block);
+    }
+}
+
+#[derive(Default)]
+struct Context {
+    visited_blocks: HashSet<BasicBlockId>,
+    block_queue: Vec<BasicBlockId>,
+}
+
+impl Context {
+    fn remove_enable_side_effects_in_block(
+        &mut self,
+        function: &mut Function,
+        block: BasicBlockId,
+    ) {
+        let instructions = function.dfg[block].take_instructions();
+
+        let mut last_side_effects_enabled_instruction = None;
+
+        let mut new_instructions = Vec::with_capacity(instructions.len());
+        for instruction_id in instructions {
+            let instruction = &function.dfg[instruction_id];
+
+            // If we run into another `Instruction::EnableSideEffects` before encountering any
+            // instructions with side effects then we can drop the instruction we're holding and
+            // continue with the new `Instruction::EnableSideEffects`.
+            if let Instruction::EnableSideEffects { condition } = instruction {
+                // If we're seeing an `enable_side_effects u1 1` then we want to insert it immediately.
+                // This is because we want to maximize the effect it will have.
+                if function
+                    .dfg
+                    .get_numeric_constant(*condition)
+                    .map_or(false, |condition| condition.is_one())
+                {
+                    new_instructions.push(instruction_id);
+                    last_side_effects_enabled_instruction = None;
+                    continue;
+                }
+
+                last_side_effects_enabled_instruction = Some(instruction_id);
+                continue;
+            }
+
+            // If we hit an instruction which is affected by the side effects var then we must insert the
+            // `Instruction::EnableSideEffects` before we insert this new instruction.
+            if Self::responds_to_side_effects_var(&function.dfg, instruction) {
+                if let Some(enable_side_effects_instruction_id) =
+                    last_side_effects_enabled_instruction.take()
+                {
+                    new_instructions.push(enable_side_effects_instruction_id);
+                }
+            }
+            new_instructions.push(instruction_id);
+        }
+
+        *function.dfg[block].instructions_mut() = new_instructions;
+
+        self.block_queue.extend(function.dfg[block].successors());
+    }
+
+    fn responds_to_side_effects_var(dfg: &DataFlowGraph, instruction: &Instruction) -> bool {
+        use Instruction::*;
+        match instruction {
+            Binary(binary) => {
+                if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) {
+                    if let Some(rhs) = dfg.get_numeric_constant(binary.rhs) {
+                        rhs == FieldElement::zero()
+                    } else {
+                        true
+                    }
+                } else {
+                    false
+                }
+            }
+
+            Cast(_, _)
+            | Not(_)
+            | Truncate { .. }
+            | Constrain(..)
+            | RangeCheck { .. }
+            | IncrementRc { .. }
+            | DecrementRc { .. } => false,
+
+            EnableSideEffects { .. }
+            | ArrayGet { .. }
+            | ArraySet { .. }
+            | Allocate
+            | Store { .. }
+            | Load { .. } => true,
+
+            // Some `Intrinsic`s have side effects so we must check what kind of `Call` this is.
+            Call { func, .. } => match dfg[*func] {
+                Value::Intrinsic(intrinsic) => match intrinsic {
+                    Intrinsic::SlicePushBack
+                    | Intrinsic::SlicePushFront
+                    | Intrinsic::SlicePopBack
+                    | Intrinsic::SlicePopFront
+                    | Intrinsic::SliceInsert
+                    | Intrinsic::SliceRemove => true,
+
+                    Intrinsic::ArrayLen
+                    | Intrinsic::AssertConstant
+                    | Intrinsic::ApplyRangeConstraint
+                    | Intrinsic::StrAsBytes
+                    | Intrinsic::ToBits(_)
+                    | Intrinsic::ToRadix(_)
+                    | Intrinsic::BlackBox(_)
+                    | Intrinsic::FromField
+                    | Intrinsic::AsField
+                    | Intrinsic::AsSlice => false,
+                },
+
+                // We must assume that functions contain a side effect as we cannot inspect more deeply.
+                Value::Function(_) => true,
+
+                _ => false,
+            },
+        }
+    }
+}

From 46fc01dc4cf1a43896862f8cc9ed6e852f4a426b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 8 Apr 2024 12:44:02 +0100
Subject: [PATCH 154/416] chore: update JS publish workflow to upload build
 artifacts correctly. (#4734)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This does some fixes to the publishing workflow to account for #4679

## Additional Context

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/publish-es-packages.yml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish-es-packages.yml b/.github/workflows/publish-es-packages.yml
index 470db3b78f7..819be308169 100644
--- a/.github/workflows/publish-es-packages.yml
+++ b/.github/workflows/publish-es-packages.yml
@@ -44,7 +44,9 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: noirc_abi_wasm
-          path: ./tooling/noirc_abi_wasm/outputs/out/noirc_abi_wasm
+          path: | 
+            ./tooling/noirc_abi_wasm/nodejs
+            ./tooling/noirc_abi_wasm/web
           retention-days: 10
 
   build-noir_wasm:
@@ -113,7 +115,9 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: acvm-js
-          path: ./acvm-repo/acvm_js/outputs/out/acvm_js
+          path: |
+            ./acvm-repo/acvm_js/nodejs
+            ./acvm-repo/acvm_js/web
           retention-days: 3
           
   publish-es-packages:

From da27e3469b08e9b77aa9bda383533707489106bf Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 8 Apr 2024 13:04:56 +0100
Subject: [PATCH 155/416] chore(ci): replace `yarn build:js:only` script
 (#4735)

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index 30cac607010..3cffdf4c802 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,7 @@
     "lint": "yarn workspaces foreach --verbose run lint",
     "spellcheck": "cspell '**/*.{md,rs}' -c ./cspell.json",
     "prepare:publish": "yarn clean && yarn build",
+    "build:js:only": "yarn workspaces foreach -vtp --exclude \"{@noir-lang/acvm_js,@noir-lang/noirc_abi,@noir-lang/noir_wasm,docs,@noir-lang/root}\" run build",
     "nightly:version": "yarn workspaces foreach run nightly:version",
     "publish:all": "yarn install && yarn workspaces foreach run publish"
   },

From 753851e1ec74892ca76319255c3277cca9e96a15 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 8 Apr 2024 14:40:46 +0100
Subject: [PATCH 156/416] chore(ci): fix cutting new versions of the docs
 (#4737)

---
 docs/package.json           |  2 +-
 docs/scripts/cut_version.sh | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100755 docs/scripts/cut_version.sh

diff --git a/docs/package.json b/docs/package.json
index 4bbdf254c50..f9e95fc02f8 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -9,7 +9,7 @@
     "clean": "rm -rf ./processed-docs ./processed-docs ./build",
     "version::stables": "ts-node ./scripts/setStable.ts",
     "serve": "serve build",
-    "version": "yarn build && docusaurus docs:version"
+    "version": "yarn version::stables && ./scripts/cut_version.sh"
   },
   "dependencies": {
     "@docusaurus/core": "^3.0.1",
diff --git a/docs/scripts/cut_version.sh b/docs/scripts/cut_version.sh
new file mode 100755
index 00000000000..4000707328c
--- /dev/null
+++ b/docs/scripts/cut_version.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -eu
+
+cd $(dirname "$0")/..
+
+VERSION=$1
+
+# We assume that the new release tag has been made on github, so setStable.ts will add this to `versions.json`.
+# We don't have a version of the docs for this release however (that's what we're doing right now!) so we need to remove it.
+jq 'map(select(. != "'"$VERSION"'"))' versions.json > tmp.json && mv tmp.json versions.json
+
+# We need to build the docs in order to perform all necessary preprocessing.
+yarn build
+
+# Finally cut the actual new docs version.
+yarn docusaurus docs:version $VERSION

From dbb86acd43de5d34905c8e7cb47cff7afc8a6071 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 8 Apr 2024 14:58:42 +0100
Subject: [PATCH 157/416] chore: update condition for clearing warning comment
 on release PRs (#4739)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This is not triggering correctly atm so I'm switching to a more explicit
syntax.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index badcd3af2dd..d27fac0e039 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -131,7 +131,7 @@ jobs:
           # We need to specify the PR on which to make the comment as workflow is triggered by push.
           number: ${{ fromJSON(needs.release-please.outputs.release-pr).number }}
           # delete the comment in case failures have been fixed
-          delete: ${{ !env.FAIL }}
+          delete: ${{ env.FAIL == false }}
           message: "The release workflow has not completed successfully. Releasing now will result in a broken release"
 
       - name: Report overall success

From 50d2735825454a8638a308156d4ea23b3c4420d8 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 8 Apr 2024 17:41:13 +0100
Subject: [PATCH 158/416] feat(nargo): Multiple circuits info for binary
 programs (#4719)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves  #4697

## Summary\*

The `nargo info` command previously assumed that we only had a single
circuit. In order to display accurate circuits sizes we should display
the circuit size of each individual circuit entry part which is part of
an entire `Program`.

For improved debugging I also had to exposed names in the
`GeneratedAcir`. This prompted also refactoring the context that we pass
around in `ssa.rs` when creating a circuit and a program. Two new
structs,`SsaProgramArtifact` and `SsaCircuitArtifact`, have been created
to clean this up.

Example output from `nargo info` on `fold_basic_nested_call`:
<img width="847" alt="Screenshot 2024-04-04 at 3 54 46 PM"
src="https://github.com/noir-lang/noir/assets/43554004/95a827c4-766c-4d7d-b03e-fb9428cfdb2a">


## Additional Context

It isn't necessarily obvious how we should display foldable circuits for
contracts which already have multiple entry points. I have left this for
follow-up work: https://github.com/noir-lang/noir/issues/4720

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/gates_report.yml            |  2 +-
 compiler/noirc_driver/src/contract.rs         |  3 +
 compiler/noirc_driver/src/lib.rs              | 21 ++++-
 compiler/noirc_driver/src/program.rs          |  2 +
 compiler/noirc_evaluator/src/ssa.rs           | 82 ++++++++++++-------
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  6 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  7 +-
 .../fold_non_contract_method/Nargo.toml       |  7 ++
 .../fold_non_contract_method/src/main.nr      | 18 ++++
 tooling/nargo/src/artifacts/program.rs        |  4 +
 tooling/nargo_cli/build.rs                    |  2 +-
 tooling/nargo_cli/src/cli/info_cmd.rs         | 62 ++++++++------
 12 files changed, 157 insertions(+), 59 deletions(-)
 create mode 100644 test_programs/compile_success_contract/fold_non_contract_method/Nargo.toml
 create mode 100644 test_programs/compile_success_contract/fold_non_contract_method/src/main.nr

diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index f3f798fc5ea..ebf17f7374c 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -74,7 +74,7 @@ jobs:
        
       - name: Compare gates reports
         id: gates_diff
-        uses: TomAFrench/noir-gates-diff@e7cf131b7e7f044c01615f93f0b855f65ddc02d4
+        uses: TomAFrench/noir-gates-diff@df05f34e2ab275ddc4f2cac065df1c88f8a05e5d
         with:
           report: gates_report.json
           summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index 9a0e25a321b..bd78cb23cdc 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -51,4 +51,7 @@ pub struct ContractFunction {
     pub bytecode: Program,
 
     pub debug: DebugInfo,
+
+    /// Names of the functions in the program. These are used for more informative debugging and benchmarking.
+    pub names: Vec<String>,
 }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 86d4cd1510d..8fa2d9680c8 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -11,6 +11,7 @@ use noirc_abi::{AbiParameter, AbiType, ContractEvent};
 use noirc_errors::{CustomDiagnostic, FileDiagnostic};
 use noirc_evaluator::create_program;
 use noirc_evaluator::errors::RuntimeError;
+use noirc_evaluator::ssa::SsaProgramArtifact;
 use noirc_frontend::debug::build_debug_crate_file;
 use noirc_frontend::graph::{CrateId, CrateName};
 use noirc_frontend::hir::def_map::{Contract, CrateDefMap};
@@ -423,6 +424,7 @@ fn compile_contract_inner(
             bytecode: function.program,
             debug: function.debug,
             is_unconstrained: modifiers.is_unconstrained,
+            names: function.names,
         });
     }
 
@@ -485,7 +487,14 @@ pub fn compile_no_check(
     }
     let visibility = program.return_visibility;
 
-    let (program, debug, warnings, input_witnesses, return_witnesses) = create_program(
+    let SsaProgramArtifact {
+        program,
+        debug,
+        warnings,
+        main_input_witnesses,
+        main_return_witnesses,
+        names,
+    } = create_program(
         program,
         options.show_ssa,
         options.show_brillig,
@@ -493,8 +502,13 @@ pub fn compile_no_check(
         options.benchmark_codegen,
     )?;
 
-    let abi =
-        abi_gen::gen_abi(context, &main_function, input_witnesses, return_witnesses, visibility);
+    let abi = abi_gen::gen_abi(
+        context,
+        &main_function,
+        main_input_witnesses,
+        main_return_witnesses,
+        visibility,
+    );
     let file_map = filter_relevant_files(&debug, &context.file_manager);
 
     Ok(CompiledProgram {
@@ -510,5 +524,6 @@ pub fn compile_no_check(
         file_map,
         noir_version: NOIR_ARTIFACT_VERSION_STRING.to_string(),
         warnings,
+        names,
     })
 }
diff --git a/compiler/noirc_driver/src/program.rs b/compiler/noirc_driver/src/program.rs
index 6f527297dcb..9ffd2d70dda 100644
--- a/compiler/noirc_driver/src/program.rs
+++ b/compiler/noirc_driver/src/program.rs
@@ -27,4 +27,6 @@ pub struct CompiledProgram {
     pub debug: DebugInfo,
     pub file_map: BTreeMap<FileId, DebugFile>,
     pub warnings: Vec<SsaReport>,
+    /// Names of the functions in the program. These are used for more informative debugging and benchmarking.
+    pub names: Vec<String>,
 }
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 9ecf6960333..fac7a7c0829 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -88,6 +88,29 @@ fn time<T>(name: &str, print_timings: bool, f: impl FnOnce() -> T) -> T {
     result
 }
 
+#[derive(Default)]
+pub struct SsaProgramArtifact {
+    pub program: AcirProgram,
+    pub debug: Vec<DebugInfo>,
+    pub warnings: Vec<SsaReport>,
+    pub main_input_witnesses: Vec<Witness>,
+    pub main_return_witnesses: Vec<Witness>,
+    pub names: Vec<String>,
+}
+
+impl SsaProgramArtifact {
+    fn add_circuit(&mut self, mut circuit_artifact: SsaCircuitArtifact, is_main: bool) {
+        self.program.functions.push(circuit_artifact.circuit);
+        self.debug.push(circuit_artifact.debug_info);
+        self.warnings.append(&mut circuit_artifact.warnings);
+        if is_main {
+            self.main_input_witnesses = circuit_artifact.input_witnesses;
+            self.main_return_witnesses = circuit_artifact.return_witnesses;
+        }
+        self.names.push(circuit_artifact.name);
+    }
+}
+
 /// Compiles the [`Program`] into [`ACIR``][acvm::acir::circuit::Program].
 ///
 /// The output ACIR is is backend-agnostic and so must go through a transformation pass before usage in proof generation.
@@ -99,8 +122,7 @@ pub fn create_program(
     enable_brillig_logging: bool,
     force_brillig_output: bool,
     print_codegen_timings: bool,
-) -> Result<(AcirProgram, Vec<DebugInfo>, Vec<SsaReport>, Vec<Witness>, Vec<Witness>), RuntimeError>
-{
+) -> Result<SsaProgramArtifact, RuntimeError> {
     let debug_variables = program.debug_variables.clone();
     let debug_types = program.debug_types.clone();
     let debug_functions = program.debug_functions.clone();
@@ -121,37 +143,33 @@ pub fn create_program(
         "The generated ACIRs should match the supplied function signatures"
     );
 
-    let mut functions = vec![];
-    let mut debug_infos = vec![];
-    let mut warning_infos = vec![];
-    let mut main_input_witnesses = Vec::new();
-    let mut main_return_witnesses = Vec::new();
+    let mut program_artifact = SsaProgramArtifact::default();
     // For setting up the ABI we need separately specify main's input and return witnesses
     let mut is_main = true;
     for (acir, func_sig) in generated_acirs.into_iter().zip(func_sigs) {
-        let (circuit, debug_info, warnings, input_witnesses, return_witnesses) =
-            convert_generated_acir_into_circuit(
-                acir,
-                func_sig,
-                recursive,
-                // TODO: get rid of these clones
-                debug_variables.clone(),
-                debug_functions.clone(),
-                debug_types.clone(),
-            );
-        functions.push(circuit);
-        debug_infos.push(debug_info);
-        warning_infos.extend(warnings);
-        if is_main {
-            main_input_witnesses = input_witnesses;
-            main_return_witnesses = return_witnesses;
-        }
+        let circuit_artifact = convert_generated_acir_into_circuit(
+            acir,
+            func_sig,
+            recursive,
+            // TODO: get rid of these clones
+            debug_variables.clone(),
+            debug_functions.clone(),
+            debug_types.clone(),
+        );
+        program_artifact.add_circuit(circuit_artifact, is_main);
         is_main = false;
     }
 
-    let program = AcirProgram { functions };
+    Ok(program_artifact)
+}
 
-    Ok((program, debug_infos, warning_infos, main_input_witnesses, main_return_witnesses))
+pub struct SsaCircuitArtifact {
+    name: String,
+    circuit: Circuit,
+    debug_info: DebugInfo,
+    warnings: Vec<SsaReport>,
+    input_witnesses: Vec<Witness>,
+    return_witnesses: Vec<Witness>,
 }
 
 fn convert_generated_acir_into_circuit(
@@ -161,7 +179,7 @@ fn convert_generated_acir_into_circuit(
     debug_variables: DebugVariables,
     debug_functions: DebugFunctions,
     debug_types: DebugTypes,
-) -> (Circuit, DebugInfo, Vec<SsaReport>, Vec<Witness>, Vec<Witness>) {
+) -> SsaCircuitArtifact {
     let opcodes = generated_acir.take_opcodes();
     let current_witness_index = generated_acir.current_witness_index().0;
     let GeneratedAcir {
@@ -170,6 +188,7 @@ fn convert_generated_acir_into_circuit(
         input_witnesses,
         assert_messages,
         warnings,
+        name,
         ..
     } = generated_acir;
 
@@ -202,7 +221,14 @@ fn convert_generated_acir_into_circuit(
     let (optimized_circuit, transformation_map) = acvm::compiler::optimize(circuit);
     debug_info.update_acir(transformation_map);
 
-    (optimized_circuit, debug_info, warnings, input_witnesses, return_witnesses)
+    SsaCircuitArtifact {
+        name,
+        circuit: optimized_circuit,
+        debug_info,
+        warnings,
+        input_witnesses,
+        return_witnesses,
+    }
 }
 
 // Takes each function argument and partitions the circuit's inputs witnesses according to its visibility.
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 1d05e998b13..b43110b2f5b 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -25,7 +25,7 @@ use iter_extended::vecmap;
 use num_bigint::BigUint;
 
 #[derive(Debug, Default)]
-/// The output of the Acir-gen pass
+/// The output of the Acir-gen pass, which should only be produced for entry point Acir functions
 pub(crate) struct GeneratedAcir {
     /// The next witness index that may be declared.
     /// If witness index is `None` then we have not yet created a witness
@@ -58,6 +58,10 @@ pub(crate) struct GeneratedAcir {
     pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
 
     pub(crate) warnings: Vec<SsaReport>,
+
+    /// Name for the corresponding entry point represented by this Acir-gen output.
+    /// Only used for debugging and benchmarking purposes
+    pub(crate) name: String,
 }
 
 impl GeneratedAcir {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index d4760c29eda..9e597dc8e9a 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -186,7 +186,10 @@ impl Ssa {
         // TODO: can we parallelise this?
         for function in self.functions.values() {
             let context = Context::new();
-            if let Some(generated_acir) = context.convert_ssa_function(&self, function, brillig)? {
+            if let Some(mut generated_acir) =
+                context.convert_ssa_function(&self, function, brillig)?
+            {
+                generated_acir.name = function.name().to_owned();
                 acirs.push(generated_acir);
             }
         }
@@ -253,7 +256,7 @@ impl Context {
                         }
                     }
                 }
-                // We only want to convert entry point functions. This being `main` and those marked with `#[fold]`
+                // We only want to convert entry point functions. This being `main` and those marked with `InlineType::Fold`
                 Ok(Some(self.convert_acir_main(function, ssa, brillig)?))
             }
             RuntimeType::Brillig => {
diff --git a/test_programs/compile_success_contract/fold_non_contract_method/Nargo.toml b/test_programs/compile_success_contract/fold_non_contract_method/Nargo.toml
new file mode 100644
index 00000000000..ff64bbb6f1b
--- /dev/null
+++ b/test_programs/compile_success_contract/fold_non_contract_method/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_non_contract_method"
+type = "contract"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_contract/fold_non_contract_method/src/main.nr b/test_programs/compile_success_contract/fold_non_contract_method/src/main.nr
new file mode 100644
index 00000000000..2e00ffa1381
--- /dev/null
+++ b/test_programs/compile_success_contract/fold_non_contract_method/src/main.nr
@@ -0,0 +1,18 @@
+contract Foo {
+    use crate::times_10;
+
+    fn double(x: Field) -> pub Field {
+        x * 2
+    }
+    fn triple(x: Field) -> pub Field {
+        x * 3
+    }
+    fn times_40(x: Field) -> pub Field {
+        times_10(x) * 4
+    }
+}
+
+#[fold]
+fn times_10(x: Field) -> Field {
+    x * 10
+}
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/nargo/src/artifacts/program.rs
index 046db1cd8fa..9e660cbd359 100644
--- a/tooling/nargo/src/artifacts/program.rs
+++ b/tooling/nargo/src/artifacts/program.rs
@@ -34,6 +34,8 @@ pub struct ProgramArtifact {
 
     /// Map of file Id to the source code so locations in debug info can be mapped to source code they point to.
     pub file_map: BTreeMap<FileId, DebugFile>,
+
+    pub names: Vec<String>,
 }
 
 impl From<CompiledProgram> for ProgramArtifact {
@@ -45,6 +47,7 @@ impl From<CompiledProgram> for ProgramArtifact {
             bytecode: compiled_program.program,
             debug_symbols: compiled_program.debug,
             file_map: compiled_program.file_map,
+            names: compiled_program.names,
         }
     }
 }
@@ -59,6 +62,7 @@ impl From<ProgramArtifact> for CompiledProgram {
             debug: program.debug_symbols,
             file_map: program.file_map,
             warnings: vec![],
+            names: program.names,
         }
     }
 }
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 16df29e6985..bf97dfb3e96 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -244,7 +244,7 @@ fn compile_success_empty_{test_name}() {{
     let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
         panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
     }});
-    let num_opcodes = &json["programs"][0]["acir_opcodes"];
+    let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
     assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
 }}
             "#,
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 49924622392..72784013e17 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use acvm::acir::circuit::ExpressionWidth;
+use acvm::acir::circuit::{ExpressionWidth, Program};
 use backend_interface::BackendError;
 use clap::Args;
 use iter_extended::vecmap;
@@ -24,9 +24,9 @@ use crate::errors::CliError;
 
 use super::{compile_cmd::compile_workspace, NargoConfig};
 
-/// Provides detailed information on a circuit
+/// Provides detailed information on each of a program's function (represented by a single circuit)
 ///
-/// Current information provided:
+/// Current information provided per circuit:
 /// 1. The number of ACIR opcodes
 /// 2. Counts the final number gates in the circuit used by a backend
 #[derive(Debug, Clone, Args)]
@@ -114,6 +114,7 @@ pub(crate) fn run(
 
     let binary_packages =
         workspace.into_iter().filter(|package| package.is_binary()).zip(compiled_programs);
+
     let program_info = binary_packages
         .par_bridge()
         .map(|(package, program)| {
@@ -134,10 +135,13 @@ pub(crate) fn run(
     } else {
         // Otherwise print human-readable table.
         if !info_report.programs.is_empty() {
-            let mut program_table = table!([Fm->"Package", Fm->"Expression Width", Fm->"ACIR Opcodes", Fm->"Backend Circuit Size"]);
+            let mut program_table = table!([Fm->"Package", Fm->"Function", Fm->"Expression Width", Fm->"ACIR Opcodes", Fm->"Backend Circuit Size"]);
 
-            for program in info_report.programs {
-                program_table.add_row(program.into());
+            for program_info in info_report.programs {
+                let program_rows: Vec<Row> = program_info.into();
+                for row in program_rows {
+                    program_table.add_row(row);
+                }
             }
             program_table.printstd();
         }
@@ -223,18 +227,20 @@ struct ProgramInfo {
     name: String,
     #[serde(skip)]
     expression_width: ExpressionWidth,
-    acir_opcodes: usize,
-    circuit_size: u32,
+    functions: Vec<FunctionInfo>,
 }
 
-impl From<ProgramInfo> for Row {
+impl From<ProgramInfo> for Vec<Row> {
     fn from(program_info: ProgramInfo) -> Self {
-        row![
-            Fm->format!("{}", program_info.name),
-            format!("{:?}", program_info.expression_width),
-            Fc->format!("{}", program_info.acir_opcodes),
-            Fc->format!("{}", program_info.circuit_size),
-        ]
+        vecmap(program_info.functions, |function| {
+            row![
+                Fm->format!("{}", program_info.name),
+                Fc->format!("{}", function.name),
+                format!("{:?}", program_info.expression_width),
+                Fc->format!("{}", function.acir_opcodes),
+                Fc->format!("{}", function.circuit_size),
+            ]
+        })
     }
 }
 
@@ -243,6 +249,7 @@ struct ContractInfo {
     name: String,
     #[serde(skip)]
     expression_width: ExpressionWidth,
+    // TODO(https://github.com/noir-lang/noir/issues/4720): Settle on how to display contract functions with non-inlined Acir calls
     functions: Vec<FunctionInfo>,
 }
 
@@ -273,13 +280,22 @@ fn count_opcodes_and_gates_in_program(
     package: &Package,
     expression_width: ExpressionWidth,
 ) -> Result<ProgramInfo, CliError> {
-    Ok(ProgramInfo {
-        name: package.name.to_string(),
-        expression_width,
-        // TODO(https://github.com/noir-lang/noir/issues/4428)
-        acir_opcodes: compiled_program.program.functions[0].opcodes.len(),
-        circuit_size: backend.get_exact_circuit_size(&compiled_program.program)?,
-    })
+    let functions = compiled_program
+        .program
+        .functions
+        .into_par_iter()
+        .enumerate()
+        .map(|(i, function)| -> Result<_, BackendError> {
+            Ok(FunctionInfo {
+                name: compiled_program.names[i].clone(),
+                acir_opcodes: function.opcodes.len(),
+                circuit_size: backend
+                    .get_exact_circuit_size(&Program { functions: vec![function] })?,
+            })
+        })
+        .collect::<Result<_, _>>()?;
+
+    Ok(ProgramInfo { name: package.name.to_string(), expression_width, functions })
 }
 
 fn count_opcodes_and_gates_in_contract(
@@ -293,7 +309,7 @@ fn count_opcodes_and_gates_in_contract(
         .map(|function| -> Result<_, BackendError> {
             Ok(FunctionInfo {
                 name: function.name,
-                // TODO(https://github.com/noir-lang/noir/issues/4428)
+                // TODO(https://github.com/noir-lang/noir/issues/4720)
                 acir_opcodes: function.bytecode.functions[0].opcodes.len(),
                 circuit_size: backend.get_exact_circuit_size(&function.bytecode)?,
             })

From 464591438e9f1adf22e955763ffcbd7f3b2441e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Tue, 9 Apr 2024 10:17:49 +0200
Subject: [PATCH 159/416] chore: Remove the old Value struct from the oracle
 docs (#4738)

# Description

## Problem\*

We removed the old Value struct that added the objects with "inner" on
the JS side for oracles.

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/how_to/how-to-oracles.md | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index ab225b9421f..8cf8035a5c4 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -138,8 +138,8 @@ Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` d
 
 ```js
 server.addMethod("getSqrt", async (params) => {
-  const values = params[0].Array.map(({ inner }) => {
-    return { inner: `${Math.sqrt(parseInt(inner, 16))}` };
+  const values = params[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
   });
   return { values: [{ Array: values }] };
 });
@@ -147,27 +147,23 @@ server.addMethod("getSqrt", async (params) => {
 
 :::tip
 
-Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a `inner` property *as a string*. For example:
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
 
 ```json
-{ "values": [{ "Array": [{ "inner": "1" }, { "inner": "2"}]}]}
-{ "values": [{ "Single": { "inner": "1" }}]}
-{ "values": [{ "Single": { "inner": "1" }}, { "Array": [{ "inner": "1", { "inner": "2" }}]}]}
+{ "values": [{ "Array": ["1", "2"] }]}
+{ "values": [{ "Single": "1" }]}
+{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
 ```
 
 If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
 
 ```js
-interface Value {
-  inner: string,
-}
-
 interface SingleForeignCallParam {
-  Single: Value,
+  Single: string,
 }
 
 interface ArrayForeignCallParam {
-  Array: Value[],
+  Array: string[],
 }
 
 type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
@@ -243,9 +239,9 @@ const foreignCallHandler = async (name, input) => {
     // notice that the "inputs" parameter contains *all* the inputs
     // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
     const oracleReturn = await client.request(name, [
-      { Array: input[0].map((i) => ({ inner: i.toString("hex") })) },
+      { Array: input[0].map((i) => i.toString("hex")) },
     ]);
-    return [oracleReturn.values[0].Array.map((x) => x.inner)];
+    return [oracleReturn.values[0].Array];
 };
 
 // the rest of your NoirJS code

From ac1c33e10148df263429dd42a2493bcfecb025af Mon Sep 17 00:00:00 2001
From: josh crites <jc@joshcrites.com>
Date: Tue, 9 Apr 2024 04:42:34 -0400
Subject: [PATCH 160/416] chore(doc): Fix broken docs links (#4606)

# Description

## Problem\*

Resolves #4598

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../modules_packages_crates/crates_and_packages.md            | 2 +-
 .../version-v0.19.0/language_concepts/06_generics.md          | 4 ----
 .../modules_packages_crates/crates_and_packages.md            | 2 +-
 .../modules_packages_crates/crates_and_packages.md            | 2 +-
 .../modules_packages_crates/crates_and_packages.md            | 2 +-
 .../modules_packages_crates/crates_and_packages.md            | 2 +-
 .../modules_packages_crates/crates_and_packages.md            | 2 +-
 .../noir/modules_packages_crates/crates_and_packages.md       | 2 +-
 .../noir/modules_packages_crates/crates_and_packages.md       | 2 +-
 .../noir/modules_packages_crates/crates_and_packages.md       | 2 +-
 10 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/crates_and_packages.md
index 744de72bb2c..23f60855c30 100644
--- a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/crates_and_packages.md
@@ -23,7 +23,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/06_generics.md b/docs/versioned_docs/version-v0.19.0/language_concepts/06_generics.md
index b700bd5bc5b..a932d7b47c2 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/06_generics.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/06_generics.md
@@ -107,7 +107,3 @@ fn main() {
     let array = [MyStruct::new(), MyStruct::new()];
     assert(array_eq(array, array, MyStruct::eq));
 }
-```
-
-You can see an example of generics in the tests
-[here](https://github.com/noir-lang/noir/blob/master/crates/nargo_cli/tests/test_data/generics/src/main.nr).
diff --git a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/crates_and_packages.md
index 744de72bb2c..23f60855c30 100644
--- a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/crates_and_packages.md
@@ -23,7 +23,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/crates_and_packages.md
index 744de72bb2c..23f60855c30 100644
--- a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/crates_and_packages.md
@@ -23,7 +23,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/crates_and_packages.md
index 744de72bb2c..23f60855c30 100644
--- a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/crates_and_packages.md
@@ -23,7 +23,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/crates_and_packages.md
index 744de72bb2c..23f60855c30 100644
--- a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/crates_and_packages.md
@@ -23,7 +23,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/crates_and_packages.md
index 744de72bb2c..23f60855c30 100644
--- a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/crates_and_packages.md
@@ -23,7 +23,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/crates_and_packages.md
index 760a463094c..95ee9f52ab2 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/crates_and_packages.md
@@ -24,7 +24,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/crates_and_packages.md
index 760a463094c..95ee9f52ab2 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/crates_and_packages.md
@@ -24,7 +24,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 
diff --git a/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/crates_and_packages.md
index 760a463094c..95ee9f52ab2 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/crates_and_packages.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/crates_and_packages.md
@@ -24,7 +24,7 @@ _Library crates_ don't have a `main` function and they don't compile down to ACI
 
 #### Contracts
 
-Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/contracts).
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
 
 ### Crate Root
 

From b8dd77043fddb20f02806ddfd639e72e61e9291b Mon Sep 17 00:00:00 2001
From: Savio <72797635+Savio-Sou@users.noreply.github.com>
Date: Tue, 9 Apr 2024 07:01:08 -0400
Subject: [PATCH 161/416] chore(docs): Fix link in the Data Types page (#4527)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Existing link in the [Data Types
page](https://noir-lang.org/docs/dev/noir/concepts/data_types/) to the
generics page opens
https://noir-lang.org/assets/files/generics-ff7aa43d69e6cca523a1f2e74064a062.md
in a separate tab, instead of the page in the docs.

### 1. Click:

<img width="995" alt="image"
src="https://github.com/noir-lang/noir/assets/72797635/9c5abde8-5ceb-44da-8c8b-ff9ebf6c7584">

### 2. Opens:

<img width="822" alt="image"
src="https://github.com/noir-lang/noir/assets/72797635/e3db4d33-995e-4400-b107-eb2200bb7c16">

## Summary\*

Fix link to relatively redirects to the generics page.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: José Pedro Sousa <outgoing@zpedro.dev>
---
 docs/docs/noir/concepts/data_types/index.md                     | 2 +-
 .../version-v0.23.0/noir/concepts/data_types/index.md           | 2 +-
 .../version-v0.24.0/noir/concepts/data_types/index.md           | 2 +-
 .../version-v0.25.0/noir/concepts/data_types/index.md           | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/docs/noir/concepts/data_types/index.md b/docs/docs/noir/concepts/data_types/index.md
index 97b3b2cb094..357813c147a 100644
--- a/docs/docs/noir/concepts/data_types/index.md
+++ b/docs/docs/noir/concepts/data_types/index.md
@@ -79,7 +79,7 @@ fn main() {
 }
 ```
 
-Type aliases can also be used with [generics](@site/docs/noir/concepts/generics.md):
+Type aliases can also be used with [generics](../generics.md):
 
 ```rust
 type Id<Size> = Size;
diff --git a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/index.md
index 3c9cd4c2437..f09bca0ee04 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/index.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/index.md
@@ -79,7 +79,7 @@ fn main() {
 }
 ```
 
-Type aliases can also be used with [generics](@site/docs/noir/concepts/generics.md):
+Type aliases can also be used with [generics](../generics.md):
 
 ```rust
 type Id<Size> = Size;
diff --git a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/index.md
index 3c9cd4c2437..f09bca0ee04 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/index.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/index.md
@@ -79,7 +79,7 @@ fn main() {
 }
 ```
 
-Type aliases can also be used with [generics](@site/docs/noir/concepts/generics.md):
+Type aliases can also be used with [generics](../generics.md):
 
 ```rust
 type Id<Size> = Size;
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md
index 97b3b2cb094..357813c147a 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/index.md
@@ -79,7 +79,7 @@ fn main() {
 }
 ```
 
-Type aliases can also be used with [generics](@site/docs/noir/concepts/generics.md):
+Type aliases can also be used with [generics](../generics.md):
 
 ```rust
 type Id<Size> = Size;

From f3eee6c00a9b1ea939c5757d91faac693e909301 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 9 Apr 2024 14:59:19 +0100
Subject: [PATCH 162/416] fix: correct ICE panic messages in brillig
 `convert_black_box_call` (#4761)

# Description

## Problem\*

Related to #4687

## Summary\*

The error messages here were clearly copy-pasted without any updates so
this PR fixes these to match the actual black box function they're for.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen/brillig_black_box.rs     | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 874be06b86c..36b5f8793cb 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -246,7 +246,7 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                    "ICE: BigIntAdd expects two register arguments and one result register"
                 )
             }
         }
@@ -263,7 +263,7 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                    "ICE: BigIntSub expects two register arguments and one result register"
                 )
             }
         }
@@ -280,7 +280,7 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                    "ICE: BigIntMul expects two register arguments and one result register"
                 )
             }
         }
@@ -297,7 +297,7 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                    "ICE: BigIntDiv expects two register arguments and one result register"
                 )
             }
         }
@@ -314,7 +314,7 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                    "ICE: BigIntFromLeBytes expects two register arguments and one result register"
                 )
             }
         }
@@ -330,7 +330,7 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                    "ICE: BigIntToLeBytes expects one register argument and one array result"
                 )
             }
         }

From a9766c5e9650160bcafc693f2617e441ed47721a Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 10 Apr 2024 17:25:32 +0100
Subject: [PATCH 163/416] fix: Update commit for noir-gates-diff (#4773)

# Description

## Problem\*

Resolves [<!-- Link to GitHub Issue
-->](https://github.com/noir-lang/noir/pull/4764#issuecomment-2047911499)

## Summary\*

This is the noir-gates-diff PR this commit update references:
https://github.com/TomAFrench/noir-gates-diff/pull/3.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/gates_report.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index ebf17f7374c..be55236c40f 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -74,7 +74,7 @@ jobs:
        
       - name: Compare gates reports
         id: gates_diff
-        uses: TomAFrench/noir-gates-diff@df05f34e2ab275ddc4f2cac065df1c88f8a05e5d
+        uses: vezenovm/noir-gates-diff@f80ea702d579873ff80f0261c62e2bae5203748e
         with:
           report: gates_report.json
           summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)

From 606ff4448571b0cfe4b92420c766c4239a4b23a0 Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Wed, 10 Apr 2024 22:38:26 +0100
Subject: [PATCH 164/416] chore: Release Noir(0.27.0) (#4632)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.27.0</summary>

## [0.27.0](https://github.com/noir-lang/noir/compare/v0.26.0...v0.27.0)
(2024-04-10)


### ⚠ BREAKING CHANGES

* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)

### Features

* **acir_gen:** Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* **acvm_js:** Execute program
([#4694](https://github.com/noir-lang/noir/issues/4694))
([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
* **acvm:** Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* Add `remove_enable_side_effects` SSA pass
([#4224](https://github.com/noir-lang/noir/issues/4224))
([94952db](https://github.com/noir-lang/noir/commit/94952db604b70a1ec18115b291de3c52565a641e))
* Allow slices to brillig entry points
([#4713](https://github.com/noir-lang/noir/issues/4713))
([62423d5](https://github.com/noir-lang/noir/commit/62423d552beca749b6f86b1330555aab18db58d0))
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
* **docs:** Documenting noir codegen
([#4454](https://github.com/noir-lang/noir/issues/4454))
([24f6d85](https://github.com/noir-lang/noir/commit/24f6d85f2467a109399d21729f8bb0f97c5ba6db))
* Improve nargo check cli with --override flag and feedback for existing
files ([#4575](https://github.com/noir-lang/noir/issues/4575))
([5e7fbd4](https://github.com/noir-lang/noir/commit/5e7fbd4e706b1691ba2dd960469cfa3b31dfb753))
* Improve optimisations on range constraints
([#4690](https://github.com/noir-lang/noir/issues/4690))
([96b8110](https://github.com/noir-lang/noir/commit/96b811079b0e7c0345210cfc705c00345b0b3334))
* Improve SSA type-awareness in EQ and MUL instructions
([#4691](https://github.com/noir-lang/noir/issues/4691))
([669f1a0](https://github.com/noir-lang/noir/commit/669f1a0fa47ad9093888a8ce8e525cb02bcf19b5))
* **nargo:** Multiple circuits info for binary programs
([#4719](https://github.com/noir-lang/noir/issues/4719))
([50d2735](https://github.com/noir-lang/noir/commit/50d2735825454a8638a308156d4ea23b3c4420d8))


### Bug Fixes

* "Types in a binary operation should match, but found T and T"
([#4648](https://github.com/noir-lang/noir/issues/4648))
([30c9f31](https://github.com/noir-lang/noir/commit/30c9f3151d447de8c7467ccbee82e32b8c46a396))
* **acvm:** Mark outputs of Opcode::Call solvable
([#4708](https://github.com/noir-lang/noir/issues/4708))
([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
* Correct ICE panic messages in brillig `convert_black_box_call`
([#4761](https://github.com/noir-lang/noir/issues/4761))
([f3eee6c](https://github.com/noir-lang/noir/commit/f3eee6c00a9b1ea939c5757d91faac693e909301))
* Error when a type variable is unbound during monomorphization instead
of defaulting to Field
([#4674](https://github.com/noir-lang/noir/issues/4674))
([03cdba4](https://github.com/noir-lang/noir/commit/03cdba45ac073fd6fdd91549736f36f1abaef15a))
* Field comparisons
([#4704](https://github.com/noir-lang/noir/issues/4704))
([079cb2a](https://github.com/noir-lang/noir/commit/079cb2a99d2d50b50688bfb56fa014acde3e3d71))
* Impl search no longer selects an impl if multiple are applicable
([#4662](https://github.com/noir-lang/noir/issues/4662))
([0150600](https://github.com/noir-lang/noir/commit/0150600922ee8b3e67c9b592338e8832f446685b))
* Last use analysis & make it an SSA pass
([#4686](https://github.com/noir-lang/noir/issues/4686))
([0d3d5fd](https://github.com/noir-lang/noir/commit/0d3d5fda9659a563ba9c2014b7c1af9e1d332ab0))
* Slice coercions
([#4640](https://github.com/noir-lang/noir/issues/4640))
([c0bae17](https://github.com/noir-lang/noir/commit/c0bae17e70f55ebf4b1639e0dfb075d8c5c97892))
* **ssa:** Accurate constant type for slice dummy data in flattening
([#4661](https://github.com/noir-lang/noir/issues/4661))
([b87654e](https://github.com/noir-lang/noir/commit/b87654e2b4761dfacc916dac70d43c1b572ec636))
* **ssa:** Do not use get_value_max_num_bits when we want pure type
information ([#4700](https://github.com/noir-lang/noir/issues/4700))
([b55a580](https://github.com/noir-lang/noir/commit/b55a580388abc95bab6c6ef8c50eae3c5497eb3f))
* **ssa:** Fix slice intrinsic handling in the capacity tracker
([#4643](https://github.com/noir-lang/noir/issues/4643))
([1b50ce1](https://github.com/noir-lang/noir/commit/1b50ce155cf95193937729c2a23f34b0ade42ea0))
* Unknown slice lengths coming from as_slice
([#4725](https://github.com/noir-lang/noir/issues/4725))
([f21129e](https://github.com/noir-lang/noir/commit/f21129ef05efb76c5df6ee15a134f1ea535d8e90))
* Update commit for noir-gates-diff
([#4773](https://github.com/noir-lang/noir/issues/4773))
([a9766c5](https://github.com/noir-lang/noir/commit/a9766c5e9650160bcafc693f2617e441ed47721a))
</details>

<details><summary>0.43.0</summary>

## [0.43.0](https://github.com/noir-lang/noir/compare/v0.42.0...v0.43.0)
(2024-04-10)


### ⚠ BREAKING CHANGES

* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
* Rename Arithmetic opcode to AssertZero
([#3840](https://github.com/noir-lang/noir/issues/3840))
* Remove unused methods on ACIR opcodes
([#3841](https://github.com/noir-lang/noir/issues/3841))

### Features

* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir_gen:** Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **acvm_js:** Execute program
([#4694](https://github.com/noir-lang/noir/issues/4694))
([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
* **acvm:** Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add support for overriding expression width
([#4117](https://github.com/noir-lang/noir/issues/4117))
([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove range constraints from witnesses which are constrained to be
constants ([#3928](https://github.com/noir-lang/noir/issues/3928))
([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
* Remove replacement of boolean range opcodes with `AssertZero` opcodes
([#4107](https://github.com/noir-lang/noir/issues/4107))
([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync `aztec-packages`
([#4011](https://github.com/noir-lang/noir/issues/4011))
([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
* Sync commits from `aztec-packages`
([#4068](https://github.com/noir-lang/noir/issues/4068))
([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))


### Bug Fixes

* **acvm:** Mark outputs of Opcode::Call solvable
([#4708](https://github.com/noir-lang/noir/issues/4708))
([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Remove panic from `init_log_level` in `acvm_js`
([#4195](https://github.com/noir-lang/noir/issues/4195))
([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
* Return error rather instead of panicking on invalid circuit
([#3976](https://github.com/noir-lang/noir/issues/3976))
([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove unused methods on ACIR opcodes
([#3841](https://github.com/noir-lang/noir/issues/3841))
([9e5d0e8](https://github.com/noir-lang/noir/commit/9e5d0e813d61a0bfb5ee68174ed287c5a20f1579))
* Rename Arithmetic opcode to AssertZero
([#3840](https://github.com/noir-lang/noir/issues/3840))
([836f171](https://github.com/noir-lang/noir/commit/836f17145c2901060706294461c2d282dd121b3e))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).
---
 .release-please-manifest.json                 |   4 +-
 CHANGELOG.md                                  |  38 ++
 Cargo.lock                                    |  52 +-
 Cargo.toml                                    |  16 +-
 acvm-repo/CHANGELOG.md                        |  82 +++
 acvm-repo/acir/Cargo.toml                     |   2 +-
 acvm-repo/acir_field/Cargo.toml               |   2 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm_js/Cargo.toml                  |   2 +-
 acvm-repo/acvm_js/package.json                |   2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   2 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   2 +-
 acvm-repo/brillig_vm/Cargo.toml               |   2 +-
 compiler/wasm/package.json                    |   2 +-
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 142 +++++
 .../hello_noir/project_breakdown.md           | 199 ++++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 102 ++++
 .../getting_started/tooling/_category_.json   |   6 +
 .../getting_started/tooling/index.mdx         |  38 ++
 .../tooling/language_server.md                |  43 ++
 .../getting_started/tooling/noir_codegen.md   | 113 ++++
 .../getting_started/tooling/testing.md        |  62 ++
 .../version-v0.27.0/how_to/_category_.json    |   5 +
 .../version-v0.27.0/how_to/how-to-oracles.md  | 276 +++++++++
 .../how_to/how-to-recursion.md                | 179 ++++++
 .../how_to/how-to-solidity-verifier.md        | 231 +++++++
 .../version-v0.27.0/how_to/merkle-proof.mdx   |  48 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.27.0/index.mdx |  67 +++
 .../version-v0.27.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.27.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.27.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  77 +++
 .../version-v0.27.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 251 ++++++++
 .../noir/concepts/data_types/booleans.md      |  31 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 155 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 170 ++++++
 .../noir/concepts/data_types/strings.md       |  80 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../version-v0.27.0/noir/concepts/distinct.md |  64 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.27.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.27.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.27.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.27.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.27.0/noir/concepts/oracles.md  |  23 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.27.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  99 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  40 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/bigint.md           | 119 ++++
 .../noir/standard_library/black_box_fns.md    |  31 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 326 ++++++++++
 .../standard_library/containers/hashmap.md    | 569 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 151 +++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  98 +++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../cryptographic_primitives/hashes.mdx       | 331 ++++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/scalar.mdx       |  33 +
 .../cryptographic_primitives/schnorr.mdx      |  64 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  88 +++
 .../noir/standard_library/traits.md           | 408 +++++++++++++
 .../noir/standard_library/zeroed.md           |  26 +
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 119 ++++
 .../NoirJS/backend_barretenberg/index.md      |  58 ++
 .../type-aliases/BackendOptions.md            |  21 +
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  | 132 ++++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +
 .../functions/ecdsa_secp256k1_verify.md       |  28 +
 .../functions/ecdsa_secp256r1_verify.md       |  28 +
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +
 .../NoirJS/noir_js/functions/sha256.md        |  21 +
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +
 .../reference/NoirJS/noir_js/index.md         |  54 ++
 .../type-aliases/ForeignCallHandler.md        |  24 +
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 +
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 +
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 +
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 ++
 .../noir_wasm/functions/compile_contract.md   |  51 ++
 .../noir_wasm/functions/createFileManager.md  |  21 +
 .../functions/inflateDebugSymbols.md          |  21 +
 .../reference/NoirJS/noir_wasm/index.md       |  49 ++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 .../version-v0.27.0/reference/_category_.json |   5 +
 .../reference/nargo_commands.md               | 381 ++++++++++++
 .../version-v0.27.0/tutorials/noirjs_app.md   | 279 +++++++++
 .../version-v0.27.0-sidebars.json             |  83 +++
 tooling/noir_codegen/package.json             |   2 +-
 tooling/noir_js/package.json                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noir_js_types/package.json            |   2 +-
 tooling/noirc_abi_wasm/package.json           |   2 +-
 128 files changed, 9428 insertions(+), 51 deletions(-)
 create mode 100644 docs/versioned_docs/version-v0.27.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/tooling/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/tooling/noir_codegen.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/getting_started/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/distinct.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/bigint.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/scalar.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.27.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.27.0-sidebars.json

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index d4cc095c484..7579928c999 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.26.0",
-  "acvm-repo": "0.42.0"
+  ".": "0.27.0",
+  "acvm-repo": "0.43.0"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c4bcad5840..0ab84df44e7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,43 @@
 # Changelog
 
+## [0.27.0](https://github.com/noir-lang/noir/compare/v0.26.0...v0.27.0) (2024-04-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395)
+
+### Features
+
+* **acir_gen:** Fold attribute at compile-time and initial non inlined ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* **acvm_js:** Execute program  ([#4694](https://github.com/noir-lang/noir/issues/4694)) ([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
+* **acvm:** Execute multiple circuits  (https://github.com/AztecProtocol/aztec-packages/pull/5380) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* Add `remove_enable_side_effects` SSA pass ([#4224](https://github.com/noir-lang/noir/issues/4224)) ([94952db](https://github.com/noir-lang/noir/commit/94952db604b70a1ec18115b291de3c52565a641e))
+* Allow slices to brillig entry points ([#4713](https://github.com/noir-lang/noir/issues/4713)) ([62423d5](https://github.com/noir-lang/noir/commit/62423d552beca749b6f86b1330555aab18db58d0))
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395) ([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
+* **docs:** Documenting noir codegen ([#4454](https://github.com/noir-lang/noir/issues/4454)) ([24f6d85](https://github.com/noir-lang/noir/commit/24f6d85f2467a109399d21729f8bb0f97c5ba6db))
+* Improve nargo check cli with --override flag and feedback for existing files ([#4575](https://github.com/noir-lang/noir/issues/4575)) ([5e7fbd4](https://github.com/noir-lang/noir/commit/5e7fbd4e706b1691ba2dd960469cfa3b31dfb753))
+* Improve optimisations on range constraints ([#4690](https://github.com/noir-lang/noir/issues/4690)) ([96b8110](https://github.com/noir-lang/noir/commit/96b811079b0e7c0345210cfc705c00345b0b3334))
+* Improve SSA type-awareness in EQ and MUL instructions ([#4691](https://github.com/noir-lang/noir/issues/4691)) ([669f1a0](https://github.com/noir-lang/noir/commit/669f1a0fa47ad9093888a8ce8e525cb02bcf19b5))
+* **nargo:** Multiple circuits info for binary programs ([#4719](https://github.com/noir-lang/noir/issues/4719)) ([50d2735](https://github.com/noir-lang/noir/commit/50d2735825454a8638a308156d4ea23b3c4420d8))
+
+
+### Bug Fixes
+
+* "Types in a binary operation should match, but found T and T" ([#4648](https://github.com/noir-lang/noir/issues/4648)) ([30c9f31](https://github.com/noir-lang/noir/commit/30c9f3151d447de8c7467ccbee82e32b8c46a396))
+* **acvm:** Mark outputs of Opcode::Call solvable ([#4708](https://github.com/noir-lang/noir/issues/4708)) ([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
+* Correct ICE panic messages in brillig `convert_black_box_call` ([#4761](https://github.com/noir-lang/noir/issues/4761)) ([f3eee6c](https://github.com/noir-lang/noir/commit/f3eee6c00a9b1ea939c5757d91faac693e909301))
+* Error when a type variable is unbound during monomorphization instead of defaulting to Field ([#4674](https://github.com/noir-lang/noir/issues/4674)) ([03cdba4](https://github.com/noir-lang/noir/commit/03cdba45ac073fd6fdd91549736f36f1abaef15a))
+* Field comparisons ([#4704](https://github.com/noir-lang/noir/issues/4704)) ([079cb2a](https://github.com/noir-lang/noir/commit/079cb2a99d2d50b50688bfb56fa014acde3e3d71))
+* Impl search no longer selects an impl if multiple are applicable ([#4662](https://github.com/noir-lang/noir/issues/4662)) ([0150600](https://github.com/noir-lang/noir/commit/0150600922ee8b3e67c9b592338e8832f446685b))
+* Last use analysis & make it an SSA pass ([#4686](https://github.com/noir-lang/noir/issues/4686)) ([0d3d5fd](https://github.com/noir-lang/noir/commit/0d3d5fda9659a563ba9c2014b7c1af9e1d332ab0))
+* Slice coercions ([#4640](https://github.com/noir-lang/noir/issues/4640)) ([c0bae17](https://github.com/noir-lang/noir/commit/c0bae17e70f55ebf4b1639e0dfb075d8c5c97892))
+* **ssa:** Accurate constant type for slice dummy data in flattening ([#4661](https://github.com/noir-lang/noir/issues/4661)) ([b87654e](https://github.com/noir-lang/noir/commit/b87654e2b4761dfacc916dac70d43c1b572ec636))
+* **ssa:** Do not use get_value_max_num_bits when we want pure type information ([#4700](https://github.com/noir-lang/noir/issues/4700)) ([b55a580](https://github.com/noir-lang/noir/commit/b55a580388abc95bab6c6ef8c50eae3c5497eb3f))
+* **ssa:** Fix slice intrinsic handling in the capacity tracker  ([#4643](https://github.com/noir-lang/noir/issues/4643)) ([1b50ce1](https://github.com/noir-lang/noir/commit/1b50ce155cf95193937729c2a23f34b0ade42ea0))
+* Unknown slice lengths coming from as_slice ([#4725](https://github.com/noir-lang/noir/issues/4725)) ([f21129e](https://github.com/noir-lang/noir/commit/f21129ef05efb76c5df6ee15a134f1ea535d8e90))
+* Update commit for noir-gates-diff ([#4773](https://github.com/noir-lang/noir/issues/4773)) ([a9766c5](https://github.com/noir-lang/noir/commit/a9766c5e9650160bcafc693f2617e441ed47721a))
+
 ## [0.26.0](https://github.com/noir-lang/noir/compare/v0.25.0...v0.26.0) (2024-03-25)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 170b23be189..a31c415c77e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -23,7 +23,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -37,7 +37,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -53,7 +53,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acir",
  "blake2",
@@ -88,7 +88,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -231,7 +231,7 @@ checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "arena"
-version = "0.26.0"
+version = "0.27.0"
 
 [[package]]
 name = "ark-bls12-381"
@@ -432,7 +432,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
@@ -599,7 +599,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -618,7 +618,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -626,7 +626,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.42.0"
+version = "0.43.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1732,7 +1732,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2353,7 +2353,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.26.0"
+version = "0.27.0"
 
 [[package]]
 name = "itertools"
@@ -2738,7 +2738,7 @@ checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
 name = "nargo"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2765,7 +2765,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2820,7 +2820,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2832,7 +2832,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2905,7 +2905,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2940,7 +2940,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -2966,7 +2966,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2989,7 +2989,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -3006,7 +3006,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3023,7 +3023,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_driver"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -3044,7 +3044,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3062,7 +3062,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "chrono",
@@ -3079,7 +3079,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "arena",
@@ -3105,7 +3105,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index 46ccb401fbd..5dd453415aa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.26.0"
+version = "0.27.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -52,13 +52,13 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.42.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.42.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.42.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.42.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.42.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.42.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.42.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+acir_field = { version = "0.43.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.43.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.43.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.43.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.43.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.43.0", path = "acvm-repo/blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "0.43.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 arena = { path = "compiler/utils/arena" }
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index 33cc83d7dd9..9d9ff539559 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,88 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.43.0](https://github.com/noir-lang/noir/compare/v0.42.0...v0.43.0) (2024-04-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395)
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955))
+* Rename Arithmetic opcode to AssertZero ([#3840](https://github.com/noir-lang/noir/issues/3840))
+* Remove unused methods on ACIR opcodes ([#3841](https://github.com/noir-lang/noir/issues/3841))
+
+### Features
+
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir_gen:** Fold attribute at compile-time and initial non inlined ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **acvm_js:** Execute program  ([#4694](https://github.com/noir-lang/noir/issues/4694)) ([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
+* **acvm:** Execute multiple circuits  (https://github.com/AztecProtocol/aztec-packages/pull/5380) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add support for overriding expression width ([#4117](https://github.com/noir-lang/noir/issues/4117)) ([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955)) ([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395) ([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove range constraints from witnesses which are constrained to be constants ([#3928](https://github.com/noir-lang/noir/issues/3928)) ([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
+* Remove replacement of boolean range opcodes with `AssertZero` opcodes ([#4107](https://github.com/noir-lang/noir/issues/4107)) ([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync `aztec-packages` ([#4011](https://github.com/noir-lang/noir/issues/4011)) ([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
+* Sync commits from `aztec-packages` ([#4068](https://github.com/noir-lang/noir/issues/4068)) ([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144)) ([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+
+
+### Bug Fixes
+
+* **acvm:** Mark outputs of Opcode::Call solvable ([#4708](https://github.com/noir-lang/noir/issues/4708)) ([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Remove panic from `init_log_level` in `acvm_js` ([#4195](https://github.com/noir-lang/noir/issues/4195)) ([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
+* Return error rather instead of panicking on invalid circuit ([#3976](https://github.com/noir-lang/noir/issues/3976)) ([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove unused methods on ACIR opcodes ([#3841](https://github.com/noir-lang/noir/issues/3841)) ([9e5d0e8](https://github.com/noir-lang/noir/commit/9e5d0e813d61a0bfb5ee68174ed287c5a20f1579))
+* Rename Arithmetic opcode to AssertZero ([#3840](https://github.com/noir-lang/noir/issues/3840)) ([836f171](https://github.com/noir-lang/noir/commit/836f17145c2901060706294461c2d282dd121b3e))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.42.0](https://github.com/noir-lang/noir/compare/v0.41.0...v0.42.0) (2024-03-25)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 368f49258f9..99095ad3f61 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index d63a885bfd8..7a260ea1fa2 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index d0ea52e859d..e6554d3f773 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 8319c38aee2..4635dc8663e 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 44d99f13c31..63f12942018 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 8f5ff862360..d093b24a129 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 1ad5103d2cb..318833180ea 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index d3f082fda86..463f6286d6b 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 95675469479..67e16c21d8b 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.42.0"
+version = "0.43.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index 6d11a5ba5c8..3bcf60afbe8 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.26.0",
+  "version": "0.27.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/docs/versioned_docs/version-v0.27.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.27.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.27.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.27.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.27.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..743c4d8d634
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/index.md
@@ -0,0 +1,142 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Two additional files would be generated in your project directory:
+
+_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+
+## Prove Our Noir Program
+
+Now that the project is set up, we can create a proof of correct execution of our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Prove the valid execution of your Noir program:
+
+```sh
+nargo prove
+```
+
+A new folder _proofs_ would then be generated in your project directory, containing the proof file
+`<project-name>.proof`, where the project name is defined in Nargo.toml.
+
+The _Verifier.toml_ file would also be updated with the public values computed from program
+execution (in this case the value of `y`):
+
+```toml
+y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+```
+
+> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the
+proof file.
+
+Verify your proof by running:
+
+```sh
+nargo verify
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the
+corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..6160a102c6c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,199 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
+  files, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Verifier.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Verifier.toml
+
+_Verifier.toml_ contains public in/output values computed when executing the Noir program.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
+prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
+verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
+constrained by the proof of the execution of said program (i.e. if the condition was not met, the
+verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
+public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo prove` is executed, two processes happen:
+
+1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
+   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+
+2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove -p OtherProver
+```
+
+## Verifying a Proof
+
+When the command `nargo verify` is executed, two processes happen:
+
+1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
+
+2. If that file is found, the proof's validity is checked
+
+> **Note:** The validity of the proof is linked to the current Noir program; if the program is
+> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
+> _modified_ Noir program.
+
+In production, the prover and the verifier are usually two separate entities. A prover would
+retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
+verifier. The verifier would then retrieve the public inputs, usually from external sources, and
+verify the validity of the proof against it.
+
+Take a private asset transfer as an example:
+
+A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
+public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
+and submit it to the verifier smart contract.
+
+The verifier contract would then draw the user's encrypted balance directly from the blockchain and
+verify the proof submitted against it. If the verification passes, additional functions in the
+verifier contract could trigger (e.g. approve the asset transfer).
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.27.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.27.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.27.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..3634723562b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,102 @@
+---
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/_category_.json b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/_category_.json
new file mode 100644
index 00000000000..55804c03a71
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 2,
+    "label": "Tooling",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx
new file mode 100644
index 00000000000..ac480f3c9f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx
@@ -0,0 +1,38 @@
+---
+title: Tooling
+Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
+---
+
+Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
+
+## Playground
+
+The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
+
+## IDE tools
+
+When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
+
+The easiest way to use these tools is by installing the [Noir VS Code extension](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+## Codespaces
+
+Some Noir repos have leveraged Codespaces in order to ease the development process. You can visit the [noir-starter](https://github.com/noir-lang/noir-starter) for an example.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/codespaces_showcase.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+## GitHub Actions
+
+You can use `noirup` with GitHub Actions for CI/CD and automated testing. It is as simple as
+installing `noirup` and running tests in your GitHub Action `yml` file.
+
+See the
+[config file in the Noir repo](https://github.com/TomAFrench/noir-hashes/blob/master/.github/workflows/noir.yml) for an example usage.
+
+## Community projects
+
+As an open-source project, Noir has received many contributions over time. Some of them are related with developer tooling, and you can see some of them in [Awesome Noir repository](https://github.com/noir-lang/awesome-noir#dev-tools)
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/language_server.md b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/noir_codegen.md b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..d65151da0ab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,113 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 2
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/testing.md b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.27.0/how_to/_category_.json b/docs/versioned_docs/version-v0.27.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.27.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..8cf8035a5c4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/how_to/how-to-oracles.md
@@ -0,0 +1,276 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("getSqrt", async (params) => {
+  const values = params[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+:::tip
+
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
+
+```json
+{ "values": [{ "Array": ["1", "2"] }]}
+{ "values": [{ "Single": "1" }]}
+{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface SingleForeignCallParam {
+  Single: string,
+}
+
+interface ArrayForeignCallParam {
+  Array: string[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.generateProof(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => i.toString("hex")) },
+    ]);
+    return [oracleReturn.values[0].Array];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.27.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.27.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..4c45bb87ae2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/how_to/how-to-recursion.md
@@ -0,0 +1,179 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit, backend)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.27.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.27.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e3c7c1065da
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,231 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo codegen-verifier
+```
+
+A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+
+```
+0x...<proof bytes>... , [0x0000.....02]
+```
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
+Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of
+the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.27.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.27.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..003c7019a93
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+use dep::std;
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.27.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.27.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.27.0/index.mdx b/docs/versioned_docs/version-v0.27.0/index.mdx
new file mode 100644
index 00000000000..75086ddcdde
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.27.0/migration_notes.md b/docs/versioned_docs/version-v0.27.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.27.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..efce3e95d32
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,251 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..69826fcd724
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,31 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
+> `false` in _Verifier.toml_.
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow) and
+[Assert Function](../assert) sections.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..a10a4810788
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..357813c147a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..1c6b375db49
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,155 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo prove
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+use dep::std;
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..828faf4a8f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,170 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+use dep::std::slice;
+
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..311dfd64416
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,80 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging).
+
+```rust
+use dep::std;
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/distinct.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/distinct.md
new file mode 100644
index 00000000000..6c993b8b5e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/distinct.md
@@ -0,0 +1,64 @@
+---
+title: Distinct Witnesses
+sidebar_position: 11
+---
+
+The `distinct` keyword prevents repetitions of witness indices in the program's ABI. This ensures
+that the witnesses being returned as public inputs are all unique.
+
+The `distinct` keyword is only used for return values on program entry points (usually the `main()`
+function).
+
+When using `distinct` and `pub` simultaneously, `distinct` comes first. See the example below.
+
+You can read more about the problem this solves
+[here](https://github.com/noir-lang/noir/issues/1183).
+
+## Example
+
+Without the `distinct` keyword, the following program
+
+```rust
+fn main(x : pub Field, y : pub Field) -> pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    "return_witnesses": [3, 2, 4, 4]
+  }
+}
+```
+
+Whereas (with the `distinct` keyword)
+
+```rust
+fn main(x : pub Field, y : pub Field) -> distinct pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    //...
+    "return_witnesses": [3, 4, 5, 6]
+  }
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..2c9bc33fdfc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../getting_started/tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../getting_started/tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..ddd42bf1f9b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..60425cb8994
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         |                  Types must be integer |
+| >>        |        Right shift an integer by another integer amount        |                  Types must be integer |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..2e6a6818d48
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/oracles.md
@@ -0,0 +1,23 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..ef1445a5907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: dep::some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: dep::some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b8e71fe65f0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md
@@ -0,0 +1,99 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..04c1703d929
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use dep::ecrecover;
+use dep::lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use dep::std::hash::sha256;
+use dep::std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use dep::phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..67a1dafa372
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,40 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── src
+│           └── main.nr
+├── Nargo.toml
+└── Prover.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.27.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..da6a7cdfd81
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/bigint.md
@@ -0,0 +1,119 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L16-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L16-L21</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L20-L28" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L20-L28</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..be8c65679c3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,31 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..ce4529f6e57
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,326 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..91604af765d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,569 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a pedersen hash
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Pedersen>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<PedersenHasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..fcfd7e07aa0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,151 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..d2b42d67b7c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4394b48f907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..c2c0624dfad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..695c7d9406f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,331 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+See sha256_slice for a version that works directly on slices.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::sha256(x);
+}
+```
+
+<BlackBoxInfo />
+
+## sha256_slice
+
+A version of sha256 specialized to slices:
+
+```rust title="sha256_slice" showLineNumbers 
+pub fn sha256_slice(input: [u8]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L16-L18</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+See blake2s_slice for a version that works directly on slices.
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L22-L24" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L22-L24</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake2s_slice
+
+A version of blake2s specialized to slices:
+
+```rust title="blake2s_slice" showLineNumbers 
+pub fn blake2s_slice(input: [u8]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L28-L30</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+See blake3_slice for a version that works directly on slices.
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L34-L36" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L34-L36</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3_slice
+
+A version of blake3 specialized to slices:
+
+```rust title="blake3_slice" showLineNumbers 
+pub fn blake3_slice(input: [u8]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L40-L42" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L40-L42</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+See pedersen_hash_slice for a version that works directly on slices.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L78-L80</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_hash_slice
+
+Given a slice of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash_slice" showLineNumbers 
+pub fn pedersen_hash_slice(input: [Field]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L85-L87" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L85-L87</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+See pedersen_commitment_slice for a version that works directly on slices.
+
+```rust title="pedersen_commitment" showLineNumbers 
+struct PedersenPoint {
+   x : Field,
+   y : Field,
+}
+
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L45-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L45-L52</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment_slice
+
+Given a slice of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment_slice" showLineNumbers 
+pub fn pedersen_commitment_slice(input: [Field]) -> PedersenPoint {
+    pedersen_commitment_with_separator_slice(input, 0)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L56-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L56-L60</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input. See keccak256_slice for a version that works
+directly on slices.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L113-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L113-L115</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L22" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L22</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256_slice
+
+Given a slice of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`).
+
+```rust title="keccak256_slice" showLineNumbers 
+pub fn keccak256_slice(input: [u8], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L119-L121" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L119-L121</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/scalar.mdx b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/scalar.mdx
new file mode 100644
index 00000000000..df411ca5443
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/scalar.mdx
@@ -0,0 +1,33 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplications over a fixed base in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## scalar_mul::fixed_base_embedded_curve
+
+Performs scalar multiplication over the embedded curve whose coordinates are defined by the
+configured noir field. For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+```rust title="fixed_base_embedded_curve" showLineNumbers 
+pub fn fixed_base_embedded_curve(
+    low: Field,
+    high: Field
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/scalar_mul.nr#L27-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/scalar_mul.nr#L27-L32</a></sub></sup>
+
+
+example
+
+```rust
+fn main(x : Field) {
+    let scal = std::scalar_mul::fixed_base_embedded_curve(x);
+    println(scal);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..b59e69c8f07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..a93894043dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md
@@ -0,0 +1,88 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+:::info
+
+This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+
+:::
+
+## Example usage
+
+```rust
+use dep::std;
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..68a9dc3d54b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/traits.md
@@ -0,0 +1,408 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(input: Self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(input: U) -> T {
+      T::from(input)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L102-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L102-L106</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L17-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L17-L21</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L33-L37" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L33-L37</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L49-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L49-L53</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L65-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L65-L69</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L79-L83" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L79-L83</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L95-L99" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L95-L99</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L111-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L111-L115</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L127-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L127-L131</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L142-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L142-L146</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..f450fecdd36
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/zeroed.md
@@ -0,0 +1,26 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..b18c1926b93
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,119 @@
+# BarretenbergBackend
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..c146316a915
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,58 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+## Functions
+
+### publicInputsToWitnessMap()
+
+```ts
+publicInputsToWitnessMap(publicInputs, abi): Backend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `publicInputs` | `string`[] |
+| `abi` | `Abi` |
+
+#### Returns
+
+[`Backend`](index.md#backend)
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..339353b9862
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..45dd62ee57e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,132 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit, backend)
+
+```ts
+new Noir(circuit, backend?): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+| `backend`? | `any` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the underlying backend instance.
+
+#### Example
+
+```typescript
+await noir.destroy();
+```
+
+***
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+### generateProof()
+
+```ts
+generateProof(inputs, foreignCallHandler?): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a witness and a proof given an object as input.
+
+#### Example
+
+```typescript
+async generateProof(input)
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Instantiates the verification key and verifies a proof.
+
+#### Example
+
+```typescript
+async verifyProof(proof)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..cca6b3ace41
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,54 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+***
+
+### ProofData
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..c6d8125eaad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.27.0/reference/_category_.json b/docs/versioned_docs/version-v0.27.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.27.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.27.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..218fcfb0c8c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/reference/nargo_commands.md
@@ -0,0 +1,381 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo backend`↴](#nargo-backend)
+* [`nargo backend current`↴](#nargo-backend-current)
+* [`nargo backend ls`↴](#nargo-backend-ls)
+* [`nargo backend use`↴](#nargo-backend-use)
+* [`nargo backend install`↴](#nargo-backend-install)
+* [`nargo backend uninstall`↴](#nargo-backend-uninstall)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo codegen-verifier`↴](#nargo-codegen-verifier)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo prove`↴](#nargo-prove)
+* [`nargo verify`↴](#nargo-verify)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `backend` — Install and select custom backends used to generate and verify proofs
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `codegen-verifier` — Generates a Solidity verifier smart contract for the program
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `prove` — Create proof for this program. The proof is returned as a hex encoded string
+* `verify` — Given a proof and a program, verify whether the proof is valid
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo backend`
+
+Install and select custom backends used to generate and verify proofs
+
+**Usage:** `nargo backend <COMMAND>`
+
+###### **Subcommands:**
+
+* `current` — Prints the name of the currently active backend
+* `ls` — Prints the list of currently installed backends
+* `use` — Select the backend to use
+* `install` — Install a new backend from a URL
+* `uninstall` — Uninstalls a backend
+
+
+
+## `nargo backend current`
+
+Prints the name of the currently active backend
+
+**Usage:** `nargo backend current`
+
+
+
+## `nargo backend ls`
+
+Prints the list of currently installed backends
+
+**Usage:** `nargo backend ls`
+
+
+
+## `nargo backend use`
+
+Select the backend to use
+
+**Usage:** `nargo backend use <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>`
+
+
+
+## `nargo backend install`
+
+Install a new backend from a URL
+
+**Usage:** `nargo backend install <BACKEND> <URL>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to install
+* `<URL>` — The URL from which to download the backend
+
+
+
+## `nargo backend uninstall`
+
+Uninstalls a backend
+
+**Usage:** `nargo backend uninstall <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to uninstall
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo codegen-verifier`
+
+Generates a Solidity verifier smart contract for the program
+
+**Usage:** `nargo codegen-verifier [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to codegen
+* `--workspace` — Codegen all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo prove`
+
+Create proof for this program. The proof is returned as a hex encoded string
+
+**Usage:** `nargo prove [OPTIONS]`
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--verify` — Verify proof after proving
+* `--package <PACKAGE>` — The name of the package to prove
+* `--workspace` — Prove all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo verify`
+
+Given a proof and a program, verify whether the proof is valid
+
+**Usage:** `nargo verify [OPTIONS]`
+
+###### **Options:**
+
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--package <PACKAGE>` — The name of the package verify
+* `--workspace` — Verify all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..12beb476994
--- /dev/null
+++ b/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md
@@ -0,0 +1,279 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.19.x matches `noir_js@0.19.x`, etc.
+
+In this guide, we will be pinned to 0.19.4.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to *anyone* is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```nargo new circuit```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```nargo compile```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+You should see `vite-project` appear in your root folder. This seems like a good time to `cd` into it and install our NoirJS packages:
+
+```bash
+npm i @noir-lang/backend_barretenberg@0.19.4 @noir-lang/noir_js@0.19.4
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It *could* be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import("@noir-lang/noirc_abi").then(module => 
+      module.default(new URL("@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm", import.meta.url).toString())
+    ),
+    import("@noir-lang/acvm_js").then(module => 
+      module.default(new URL("@noir-lang/acvm_js/web/acvm_js_bg.wasm", import.meta.url).toString())
+    )
+  ]);
+}
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch(err) {
+    display("logs", "Oh 💔 Wrong guess")
+  }
+});
+
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit, backend);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const proof = await noir.generateProof(input);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verification = await noir.verifyProof(proof);
+if (verification) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.27.0-sidebars.json b/docs/versioned_sidebars/version-v0.27.0-sidebars.json
new file mode 100644
index 00000000000..b16f79cc176
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.27.0-sidebars.json
@@ -0,0 +1,83 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 1eabc6a1398..569841b2c6a 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.26.0",
+  "version": "0.27.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index c8d4873e095..838f317c622 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.26.0",
+  "version": "0.27.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 251dd80c2f4..11ef9248853 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.26.0",
+  "version": "0.27.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index eadb6f49665..316612a7c51 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 14e528c3b15..0e4aaceeae3 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.26.0",
+  "version": "0.27.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From f831b0bdbf99cab1bcd24d494c4546a36309465e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Thu, 11 Apr 2024 17:08:49 +0200
Subject: [PATCH 165/416] feat: Unroll loops iteratively (#4779)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4736

## Summary\*

Instead of trying to unroll loops once, adds a meta pass that tries to
unroll as many times as necessary, simplifying and doing mem2reg between
unrolls.
- For the cases where the program unrolls succesfully at the first try,
no compile time overhead is created
- For the cases where the program does contain an unknown at compile
time loop bound, it'll try one more time before failing, since the stop
condition is that "this unroll retry generated the same amount of errors
as the previous one"
- For the cases where the program doesn't contain an unknown at compile
time loop bound, instead of failing it'll do as many unrolls as
necessary to unroll the loop.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 compiler/noirc_evaluator/src/ssa.rs           |  2 +-
 .../noirc_evaluator/src/ssa/opt/unrolling.rs  | 65 +++++++++++++------
 .../execution_success/slice_loop/Nargo.toml   |  6 ++
 .../execution_success/slice_loop/Prover.toml  | 11 ++++
 .../execution_success/slice_loop/src/main.nr  | 32 +++++++++
 5 files changed, 95 insertions(+), 21 deletions(-)
 create mode 100644 test_programs/execution_success/slice_loop/Nargo.toml
 create mode 100644 test_programs/execution_success/slice_loop/Prover.toml
 create mode 100644 test_programs/execution_success/slice_loop/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index fac7a7c0829..ce4a9bbe9f1 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -55,7 +55,7 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
         .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
         .try_run_pass(Ssa::evaluate_assert_constant, "After Assert Constant:")?
-        .try_run_pass(Ssa::unroll_loops, "After Unrolling:")?
+        .try_run_pass(Ssa::unroll_loops_iteratively, "After Unrolling:")?
         .run_pass(Ssa::simplify_cfg, "After Simplifying:")
         .run_pass(Ssa::flatten_cfg, "After Flattening:")
         .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 8110e3469f1..c6bf7923fa8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -34,10 +34,41 @@ use crate::{
 use fxhash::FxHashMap as HashMap;
 
 impl Ssa {
-    /// Unroll all loops in each SSA function.
+    /// Loop unrolling can return errors, since ACIR functions need to be fully unrolled.
+    /// This meta-pass will keep trying to unroll loops and simplifying the SSA until no more errors are found.
+    pub(crate) fn unroll_loops_iteratively(mut ssa: Ssa) -> Result<Ssa, RuntimeError> {
+        // Try to unroll loops first:
+        let mut unroll_errors;
+        (ssa, unroll_errors) = ssa.try_to_unroll_loops();
+
+        // Keep unrolling until no more errors are found
+        while !unroll_errors.is_empty() {
+            let prev_unroll_err_count = unroll_errors.len();
+
+            // Simplify the SSA before retrying
+
+            // Do a mem2reg after the last unroll to aid simplify_cfg
+            ssa = ssa.mem2reg();
+            ssa = ssa.simplify_cfg();
+            // Do another mem2reg after simplify_cfg to aid the next unroll
+            ssa = ssa.mem2reg();
+
+            // Unroll again
+            (ssa, unroll_errors) = ssa.try_to_unroll_loops();
+            // If we didn't manage to unroll any more loops, exit
+            if unroll_errors.len() >= prev_unroll_err_count {
+                return Err(unroll_errors.swap_remove(0));
+            }
+        }
+        Ok(ssa)
+    }
+
+    /// Tries to unroll all loops in each SSA function.
     /// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state.
+    /// Returns the ssa along with all unrolling errors encountered
     #[tracing::instrument(level = "trace", skip(self))]
-    pub(crate) fn unroll_loops(mut self) -> Result<Ssa, RuntimeError> {
+    pub(crate) fn try_to_unroll_loops(mut self) -> (Ssa, Vec<RuntimeError>) {
+        let mut errors = vec![];
         for function in self.functions.values_mut() {
             // Loop unrolling in brillig can lead to a code explosion currently. This can
             // also be true for ACIR, but we have no alternative to unrolling in ACIR.
@@ -46,12 +77,9 @@ impl Ssa {
                 continue;
             }
 
-            // This check is always true with the addition of the above guard, but I'm
-            // keeping it in case the guard on brillig functions is ever removed.
-            let abort_on_error = matches!(function.runtime(), RuntimeType::Acir(_));
-            find_all_loops(function).unroll_each_loop(function, abort_on_error)?;
+            errors.extend(find_all_loops(function).unroll_each_loop(function));
         }
-        Ok(self)
+        (self, errors)
     }
 }
 
@@ -115,34 +143,29 @@ fn find_all_loops(function: &Function) -> Loops {
 impl Loops {
     /// Unroll all loops within a given function.
     /// Any loops which fail to be unrolled (due to using non-constant indices) will be unmodified.
-    fn unroll_each_loop(
-        mut self,
-        function: &mut Function,
-        abort_on_error: bool,
-    ) -> Result<(), RuntimeError> {
+    fn unroll_each_loop(mut self, function: &mut Function) -> Vec<RuntimeError> {
+        let mut unroll_errors = vec![];
         while let Some(next_loop) = self.yet_to_unroll.pop() {
             // If we've previously modified a block in this loop we need to refresh the context.
             // This happens any time we have nested loops.
             if next_loop.blocks.iter().any(|block| self.modified_blocks.contains(block)) {
                 let mut new_context = find_all_loops(function);
                 new_context.failed_to_unroll = self.failed_to_unroll;
-                return new_context.unroll_each_loop(function, abort_on_error);
+                return new_context.unroll_each_loop(function);
             }
 
             // Don't try to unroll the loop again if it is known to fail
             if !self.failed_to_unroll.contains(&next_loop.header) {
                 match unroll_loop(function, &self.cfg, &next_loop) {
                     Ok(_) => self.modified_blocks.extend(next_loop.blocks),
-                    Err(call_stack) if abort_on_error => {
-                        return Err(RuntimeError::UnknownLoopBound { call_stack });
-                    }
-                    Err(_) => {
+                    Err(call_stack) => {
                         self.failed_to_unroll.insert(next_loop.header);
+                        unroll_errors.push(RuntimeError::UnknownLoopBound { call_stack });
                     }
                 }
             }
         }
-        Ok(())
+        unroll_errors
     }
 }
 
@@ -585,7 +608,8 @@ mod tests {
         // }
         // The final block count is not 1 because unrolling creates some unnecessary jmps.
         // If a simplify cfg pass is ran afterward, the expected block count will be 1.
-        let ssa = ssa.unroll_loops().expect("All loops should be unrolled");
+        let (ssa, errors) = ssa.try_to_unroll_loops();
+        assert_eq!(errors.len(), 0, "All loops should be unrolled");
         assert_eq!(ssa.main().reachable_blocks().len(), 5);
     }
 
@@ -634,6 +658,7 @@ mod tests {
         assert_eq!(ssa.main().reachable_blocks().len(), 4);
 
         // Expected that we failed to unroll the loop
-        assert!(ssa.unroll_loops().is_err());
+        let (_, errors) = ssa.try_to_unroll_loops();
+        assert_eq!(errors.len(), 1, "Expected to fail to unroll loop");
     }
 }
diff --git a/test_programs/execution_success/slice_loop/Nargo.toml b/test_programs/execution_success/slice_loop/Nargo.toml
new file mode 100644
index 00000000000..09ad90c4187
--- /dev/null
+++ b/test_programs/execution_success/slice_loop/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "slice_loop"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/slice_loop/Prover.toml b/test_programs/execution_success/slice_loop/Prover.toml
new file mode 100644
index 00000000000..089a1764b54
--- /dev/null
+++ b/test_programs/execution_success/slice_loop/Prover.toml
@@ -0,0 +1,11 @@
+[[points]]
+x = "1"
+y = "2"
+
+[[points]]
+x = "3"
+y = "4"
+
+[[points]]
+x = "5"
+y = "6"
diff --git a/test_programs/execution_success/slice_loop/src/main.nr b/test_programs/execution_success/slice_loop/src/main.nr
new file mode 100644
index 00000000000..4ff3e865b1f
--- /dev/null
+++ b/test_programs/execution_success/slice_loop/src/main.nr
@@ -0,0 +1,32 @@
+struct Point {
+    x: Field,
+    y: Field,
+}
+
+impl Point {
+    fn serialize(self) -> [Field; 2] {
+        [self.x, self.y]
+    }
+}
+
+fn sum(values: [Field]) -> Field {
+    let mut sum = 0;
+    for value in values {
+        sum = sum + value;
+    }
+    sum
+}
+
+fn main(points: [Point; 3]) {
+    let mut serialized_points = &[];
+    for point in points {
+        serialized_points = serialized_points.append(point.serialize().as_slice());
+    }
+    // Do a compile-time check that needs the previous loop to be unrolled
+    if serialized_points.len() > 5 {
+        let empty_point = Point { x: 0, y: 0 };
+        serialized_points = serialized_points.append(empty_point.serialize().as_slice());
+    }
+    // Do a sum that needs both the previous loop and the previous if to have been simplified
+    assert_eq(sum(serialized_points), 21);
+}

From 2bd006ae07499e8702b0fa9565855f0a5ef1a589 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Thu, 11 Apr 2024 11:40:07 -0400
Subject: [PATCH 166/416] feat: Sync from aztec-packages (#4764)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5619)
feat: add return values to aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/5389)
feat!: storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
feat(acir)!: Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5572)
feat!: contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
feat(avm): integrate AVM with initializers
(https://github.com/AztecProtocol/aztec-packages/pull/5469)
feat: Restore hashing args via slice for performance
(https://github.com/AztecProtocol/aztec-packages/pull/5539)
END_COMMIT_OVERRIDE

---------

Co-authored-by: sirasistant <sirasistant@gmail.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: vezenovm <mvezenov@gmail.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 .aztec-sync-commit                            |   2 +-
 Cargo.lock                                    |  30 +--
 acvm-repo/acir/codegen/acir.cpp               |   4 +
 acvm-repo/acir/src/circuit/opcodes.rs         |   7 +-
 .../acir/tests/test_program_serialization.rs  |  40 ++-
 acvm-repo/acvm/src/pwg/memory_op.rs           |  15 +-
 acvm-repo/acvm/src/pwg/mod.rs                 |  28 +-
 acvm-repo/acvm_js/build.sh                    |   7 +
 .../acvm_js/test/shared/nested_acir_call.ts   |  14 +-
 aztec_macros/src/lib.rs                       |  69 ++---
 .../compute_note_hash_and_nullifier.rs        | 155 ++++-------
 aztec_macros/src/transforms/events.rs         |  10 +-
 aztec_macros/src/transforms/functions.rs      | 246 +++++++++++------
 aztec_macros/src/transforms/note_interface.rs | 135 +++++++++-
 aztec_macros/src/transforms/storage.rs        | 254 +++++++++++++++---
 aztec_macros/src/utils/ast_utils.rs           |   2 +
 aztec_macros/src/utils/errors.rs              |  18 ++
 aztec_macros/src/utils/hir_utils.rs           | 206 ++++++++++----
 compiler/noirc_driver/src/abi_gen.rs          |  59 +++-
 compiler/noirc_driver/src/contract.rs         |  15 +-
 compiler/noirc_driver/src/lib.rs              |  56 +++-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |   4 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |   3 +-
 compiler/noirc_frontend/src/ast/statement.rs  |  13 +-
 compiler/noirc_frontend/src/debug/mod.rs      |   3 +
 .../src/hir/def_collector/dc_crate.rs         |  14 -
 .../src/hir/def_collector/dc_mod.rs           |   9 +-
 .../noirc_frontend/src/hir/def_map/mod.rs     |  52 ++--
 compiler/noirc_frontend/src/hir/mod.rs        |   2 +-
 .../src/hir/resolution/errors.rs              |   9 +
 .../src/hir/resolution/resolver.rs            |  23 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  |   1 +
 compiler/noirc_frontend/src/hir_def/stmt.rs   |   2 +
 compiler/noirc_frontend/src/lexer/token.rs    |   7 +-
 compiler/noirc_frontend/src/lib.rs            |  10 -
 compiler/noirc_frontend/src/node_interner.rs  |  12 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  13 +-
 .../src/parser/parser/attributes.rs           |  23 ++
 .../src/parser/parser/structs.rs              |  32 +--
 compiler/wasm/src/compile.rs                  |   9 +-
 compiler/wasm/src/compile_new.rs              |   2 +-
 compiler/wasm/src/types/noir_artifact.ts      |  61 +++--
 package.json                                  |   2 +-
 .../fold_call_witness_condition/Prover.toml   |   6 +-
 tooling/bb_abstraction_leaks/build.rs         |   2 +-
 tooling/nargo/src/artifacts/contract.rs       |  24 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noirc_abi/src/lib.rs                  |  58 ++--
 tooling/noirc_abi/src/serialization.rs        |  34 ++-
 tooling/noirc_abi_wasm/build.sh               |   7 +
 yarn.lock                                     |  10 +-
 51 files changed, 1272 insertions(+), 549 deletions(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 540b447693c..ec4c854ef2b 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-bb719200034e3bc6db09fb56538dadca4203abf4
+ff28080bcfb946177010960722925973ee19646b
diff --git a/Cargo.lock b/Cargo.lock
index a31c415c77e..e62f966b8fd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -541,9 +541,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.4.2"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
 
 [[package]]
 name = "bitmaps"
@@ -1602,12 +1602,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.8"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2564,16 +2564,16 @@ version = "0.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "libc",
  "redox_syscall 0.4.1",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.13"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+checksum = "09fc20d2ca12cb9f044c93e3bd6d32d523e6e2ec3db4f7b2939cd99026ecd3f0"
 
 [[package]]
 name = "lock_api"
@@ -3128,7 +3128,7 @@ version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
@@ -3582,7 +3582,7 @@ checksum = "7c003ac8c77cb07bb74f5f198bce836a689bcd5a42574612bf14d17bfd08c20e"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "lazy_static",
  "num-traits",
  "rand 0.8.5",
@@ -4069,15 +4069,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.28"
+version = "0.38.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72e572a5e8ca657d7366229cdde4bd14c4eb5499a9573d4d366fe1b599daa316"
+checksum = "0a962918ea88d644592894bc6dc55acc6c0956488adcebbfb6e273506b7fd6e5"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -5534,7 +5534,7 @@ version = "0.121.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "indexmap 2.0.0",
  "semver",
 ]
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index d7ef849ab75..e4203b579b0 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -1074,6 +1074,7 @@ namespace Program {
             uint32_t id;
             std::vector<Program::Witness> inputs;
             std::vector<Program::Witness> outputs;
+            std::optional<Program::Expression> predicate;
 
             friend bool operator==(const Call&, const Call&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -6173,6 +6174,7 @@ namespace Program {
         if (!(lhs.id == rhs.id)) { return false; }
         if (!(lhs.inputs == rhs.inputs)) { return false; }
         if (!(lhs.outputs == rhs.outputs)) { return false; }
+        if (!(lhs.predicate == rhs.predicate)) { return false; }
         return true;
     }
 
@@ -6199,6 +6201,7 @@ void serde::Serializable<Program::Opcode::Call>::serialize(const Program::Opcode
     serde::Serializable<decltype(obj.id)>::serialize(obj.id, serializer);
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+    serde::Serializable<decltype(obj.predicate)>::serialize(obj.predicate, serializer);
 }
 
 template <>
@@ -6208,6 +6211,7 @@ Program::Opcode::Call serde::Deserializable<Program::Opcode::Call>::deserialize(
     obj.id = serde::Deserializable<decltype(obj.id)>::deserialize(deserializer);
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    obj.predicate = serde::Deserializable<decltype(obj.predicate)>::deserialize(deserializer);
     return obj;
 }
 
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index 68d28b287e6..d8204132b3e 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -39,6 +39,8 @@ pub enum Opcode {
         inputs: Vec<Witness>,
         /// Outputs of the function call
         outputs: Vec<Witness>,
+        /// Predicate of the circuit execution - indicates if it should be skipped
+        predicate: Option<Expression>,
     },
 }
 
@@ -97,8 +99,11 @@ impl std::fmt::Display for Opcode {
                 write!(f, "INIT ")?;
                 write!(f, "(id: {}, len: {}) ", block_id.0, init.len())
             }
-            Opcode::Call { id, inputs, outputs } => {
+            Opcode::Call { id, inputs, outputs, predicate } => {
                 write!(f, "CALL func {}: ", id)?;
+                if let Some(pred) = predicate {
+                    writeln!(f, "PREDICATE = {pred}")?;
+                }
                 write!(f, "inputs: {:?}, ", inputs)?;
                 write!(f, "outputs: {:?}", outputs)
             }
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index a5b683c15e1..8b9160ccf6a 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -380,10 +380,18 @@ fn nested_acir_call_circuit() {
     //     assert(x == y);
     //     x
     // }
-    let nested_call =
-        Opcode::Call { id: 1, inputs: vec![Witness(0), Witness(1)], outputs: vec![Witness(2)] };
-    let nested_call_two =
-        Opcode::Call { id: 1, inputs: vec![Witness(0), Witness(1)], outputs: vec![Witness(3)] };
+    let nested_call = Opcode::Call {
+        id: 1,
+        inputs: vec![Witness(0), Witness(1)],
+        outputs: vec![Witness(2)],
+        predicate: None,
+    };
+    let nested_call_two = Opcode::Call {
+        id: 1,
+        inputs: vec![Witness(0), Witness(1)],
+        outputs: vec![Witness(3)],
+        predicate: None,
+    };
 
     let assert_nested_call_results = Opcode::AssertZero(Expression {
         mul_terms: Vec::new(),
@@ -410,8 +418,12 @@ fn nested_acir_call_circuit() {
         ],
         q_c: FieldElement::one() + FieldElement::one(),
     });
-    let call =
-        Opcode::Call { id: 2, inputs: vec![Witness(2), Witness(1)], outputs: vec![Witness(3)] };
+    let call = Opcode::Call {
+        id: 2,
+        inputs: vec![Witness(2), Witness(1)],
+        outputs: vec![Witness(3)],
+        predicate: None,
+    };
 
     let nested_call = Circuit {
         current_witness_index: 3,
@@ -444,14 +456,14 @@ fn nested_acir_call_circuit() {
 
     let expected_serialization: Vec<u8> = vec![
         31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147,
-        24, 109, 227, 191, 93, 101, 50, 123, 255, 35, 172, 99, 25, 83, 17, 250, 99, 14, 250, 224,
-        97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 57, 108, 14, 91, 248, 202, 168, 65,
-        255, 207, 122, 28, 180, 250, 244, 221, 244, 197, 223, 68, 182, 154, 197, 184, 134, 80, 54,
-        95, 136, 233, 142, 62, 101, 137, 24, 98, 94, 133, 132, 162, 196, 135, 23, 230, 34, 65, 182,
-        148, 211, 134, 137, 2, 23, 218, 99, 226, 93, 135, 185, 121, 123, 33, 84, 12, 234, 218, 192,
-        64, 174, 3, 248, 47, 88, 48, 17, 150, 157, 183, 151, 95, 244, 86, 91, 221, 61, 10, 81, 31,
-        178, 190, 110, 194, 102, 96, 76, 251, 202, 80, 13, 204, 77, 224, 25, 176, 70, 79, 197, 128,
-        18, 64, 3, 4, 0, 0,
+        24, 173, 241, 223, 174, 50, 153, 189, 255, 17, 214, 177, 148, 89, 17, 250, 99, 14, 246,
+        224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 217, 109, 118, 91, 248, 200, 168,
+        225, 248, 191, 106, 114, 208, 233, 104, 188, 233, 139, 223, 137, 108, 51, 139, 113, 13,
+        161, 38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42,
+        65, 82, 46, 57, 97, 166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182,
+        54, 48, 144, 235, 8, 254, 10, 22, 76, 132, 101, 231, 237, 229, 23, 189, 213, 54, 119, 15,
+        83, 212, 199, 172, 175, 79, 113, 51, 48, 198, 253, 207, 84, 13, 204, 141, 224, 21, 176,
+        147, 158, 66, 231, 43, 145, 6, 4, 0, 0,
     ];
     assert_eq!(bytes, expected_serialization);
 }
diff --git a/acvm-repo/acvm/src/pwg/memory_op.rs b/acvm-repo/acvm/src/pwg/memory_op.rs
index e51797707a7..672c13e11c2 100644
--- a/acvm-repo/acvm/src/pwg/memory_op.rs
+++ b/acvm-repo/acvm/src/pwg/memory_op.rs
@@ -6,7 +6,9 @@ use acir::{
     FieldElement,
 };
 
-use super::{arithmetic::ExpressionSolver, get_value, insert_value, witness_to_value};
+use super::{
+    arithmetic::ExpressionSolver, get_value, insert_value, is_predicate_false, witness_to_value,
+};
 use super::{ErrorLocation, OpcodeResolutionError};
 
 type MemoryIndex = u32;
@@ -80,11 +82,8 @@ impl MemoryOpSolver {
         // `operation == 0` implies a read operation. (`operation == 1` implies write operation).
         let is_read_operation = operation.is_zero();
 
-        // If the predicate is `None`, then we simply return the value 1
-        let pred_value = match predicate {
-            Some(pred) => get_value(pred, initial_witness),
-            None => Ok(FieldElement::one()),
-        }?;
+        // Fetch whether or not the predicate is false (e.g. equal to zero)
+        let skip_operation = is_predicate_false(initial_witness, predicate)?;
 
         if is_read_operation {
             // `value_read = arr[memory_index]`
@@ -97,7 +96,7 @@ impl MemoryOpSolver {
 
             // A zero predicate indicates that we should skip the read operation
             // and zero out the operation's output.
-            let value_in_array = if pred_value.is_zero() {
+            let value_in_array = if skip_operation {
                 FieldElement::zero()
             } else {
                 self.read_memory_index(memory_index)?
@@ -111,7 +110,7 @@ impl MemoryOpSolver {
             let value_write = value;
 
             // A zero predicate indicates that we should skip the write operation.
-            if pred_value.is_zero() {
+            if skip_operation {
                 // We only want to write to already initialized memory.
                 // Do nothing if the predicate is zero.
                 Ok(())
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index 3cedcfc0399..bb98eda2689 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -377,7 +377,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         };
 
         let witness = &mut self.witness_map;
-        if BrilligSolver::<B>::should_skip(witness, brillig)? {
+        if is_predicate_false(witness, &brillig.predicate)? {
             return BrilligSolver::<B>::zero_out_brillig_outputs(witness, brillig).map(|_| None);
         }
 
@@ -448,7 +448,9 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     }
 
     pub fn solve_call_opcode(&mut self) -> Result<Option<AcirCallWaitInfo>, OpcodeResolutionError> {
-        let Opcode::Call { id, inputs, outputs } = &self.opcodes[self.instruction_pointer] else {
+        let Opcode::Call { id, inputs, outputs, predicate } =
+            &self.opcodes[self.instruction_pointer]
+        else {
             unreachable!("Not executing a Call opcode");
         };
         if *id == 0 {
@@ -459,6 +461,14 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             });
         }
 
+        if is_predicate_false(&self.witness_map, predicate)? {
+            // Zero out the outputs if we have a false predicate
+            for output in outputs {
+                insert_value(output, FieldElement::zero(), &mut self.witness_map)?;
+            }
+            return Ok(None);
+        }
+
         if self.acir_call_counter >= self.acir_call_results.len() {
             let mut initial_witness = WitnessMap::default();
             for (i, input_witness) in inputs.iter().enumerate() {
@@ -556,6 +566,20 @@ fn any_witness_from_expression(expr: &Expression) -> Option<Witness> {
     }
 }
 
+/// Returns `true` if the predicate is zero
+/// A predicate is used to indicate whether we should skip a certain operation.
+/// If we have a zero predicate it means the operation should be skipped.
+pub(crate) fn is_predicate_false(
+    witness: &WitnessMap,
+    predicate: &Option<Expression>,
+) -> Result<bool, OpcodeResolutionError> {
+    match predicate {
+        Some(pred) => get_value(pred, witness).map(|pred_value| pred_value.is_zero()),
+        // If the predicate is `None`, then we treat it as an unconditional `true`
+        None => Ok(false),
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct AcirCallWaitInfo {
     /// Index in the list of ACIR function's that should be called
diff --git a/acvm-repo/acvm_js/build.sh b/acvm-repo/acvm_js/build.sh
index fe0b4dcbfff..4486a214c9c 100755
--- a/acvm-repo/acvm_js/build.sh
+++ b/acvm-repo/acvm_js/build.sh
@@ -14,6 +14,13 @@ function run_or_fail {
     exit $status
   fi
 }
+function run_if_available {
+  if command -v "$1" >/dev/null 2>&1; then
+    "$@"
+  else
+    echo "$1 is not installed. Please install it to use this feature." >&2
+  fi
+}
 
 require_command jq
 require_command cargo
diff --git a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
index ce91282a681..1b745ab6a79 100644
--- a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
+++ b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap, StackItem, WitnessStack } from '@noir-lang/acvm_js';
 
 // See `nested_acir_call_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147, 24, 109, 227, 191, 93, 101,
-  50, 123, 255, 35, 172, 99, 25, 83, 17, 250, 99, 14, 250, 224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 57,
-  108, 14, 91, 248, 202, 168, 65, 255, 207, 122, 28, 180, 250, 244, 221, 244, 197, 223, 68, 182, 154, 197, 184, 134, 80,
-  54, 95, 136, 233, 142, 62, 101, 137, 24, 98, 94, 133, 132, 162, 196, 135, 23, 230, 34, 65, 182, 148, 211, 134, 137, 2,
-  23, 218, 99, 226, 93, 135, 185, 121, 123, 33, 84, 12, 234, 218, 192, 64, 174, 3, 248, 47, 88, 48, 17, 150, 157, 183,
-  151, 95, 244, 86, 91, 221, 61, 10, 81, 31, 178, 190, 110, 194, 102, 96, 76, 251, 202, 80, 13, 204, 77, 224, 25, 176,
-  70, 79, 197, 128, 18, 64, 3, 4, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147, 24, 173, 241, 223, 174, 50,
+  153, 189, 255, 17, 214, 177, 148, 89, 17, 250, 99, 14, 246, 224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105,
+  217, 109, 118, 91, 248, 200, 168, 225, 248, 191, 106, 114, 208, 233, 104, 188, 233, 139, 223, 137, 108, 51, 139, 113,
+  13, 161, 38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42, 65, 82, 46, 57, 97,
+  166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182, 54, 48, 144, 235, 8, 254, 10, 22, 76, 132, 101,
+  231, 237, 229, 23, 189, 213, 54, 119, 15, 83, 212, 199, 172, 175, 79, 113, 51, 48, 198, 253, 207, 84, 13, 204, 141,
+  224, 21, 176, 147, 158, 66, 231, 43, 145, 6, 4, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 3ee6f9c21b9..48c30ab6ffa 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -4,20 +4,16 @@ mod utils;
 use transforms::{
     compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
     events::{generate_selector_impl, transform_events},
-    functions::{transform_function, transform_unconstrained},
-    note_interface::generate_note_interface_impl,
+    functions::{export_fn_abi, transform_function, transform_unconstrained},
+    note_interface::{generate_note_interface_impl, inject_note_exports},
     storage::{
         assign_storage_slots, check_for_storage_definition, check_for_storage_implementation,
-        generate_storage_implementation,
+        generate_storage_implementation, generate_storage_layout,
     },
 };
 
-use noirc_frontend::{
-    hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
-    macros_api::{
-        CrateId, FileId, HirContext, MacroError, MacroProcessor, SecondaryAttribute, SortedModule,
-        Span,
-    },
+use noirc_frontend::macros_api::{
+    CrateId, FileId, HirContext, MacroError, MacroProcessor, SortedModule, Span,
 };
 
 use utils::{
@@ -39,16 +35,6 @@ impl MacroProcessor for AztecMacro {
         transform(ast, crate_id, file_id, context)
     }
 
-    fn process_collected_defs(
-        &self,
-        crate_id: &CrateId,
-        context: &mut HirContext,
-        collected_trait_impls: &[UnresolvedTraitImpl],
-        collected_functions: &mut [UnresolvedFunctions],
-    ) -> Result<(), (MacroError, FileId)> {
-        transform_collected_defs(crate_id, context, collected_trait_impls, collected_functions)
-    }
-
     fn process_typed_ast(
         &self,
         crate_id: &CrateId,
@@ -90,15 +76,19 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
     let mut has_transformed_module = false;
 
     // Check for a user defined storage struct
-    let storage_defined = check_for_storage_definition(module);
-    let storage_implemented = check_for_storage_implementation(module);
 
-    if storage_defined && !storage_implemented {
-        generate_storage_implementation(module)?;
+    let maybe_storage_struct_name = check_for_storage_definition(module)?;
+    let storage_defined = maybe_storage_struct_name.is_some();
+
+    if let Some(storage_struct_name) = maybe_storage_struct_name {
+        if !check_for_storage_implementation(module, &storage_struct_name) {
+            generate_storage_implementation(module, &storage_struct_name)?;
+        }
+        generate_storage_layout(module, storage_struct_name)?;
     }
 
-    for structure in module.types.iter() {
-        if structure.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Event)) {
+    for structure in module.types.iter_mut() {
+        if structure.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(event)")) {
             module.impls.push(generate_selector_impl(structure));
             has_transformed_module = true;
         }
@@ -139,6 +129,7 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
 
         // Apply transformations to the function based on collected attributes
         if is_private || is_public || is_public_vm {
+            export_fn_abi(&mut module.types, func)?;
             transform_function(
                 if is_private {
                     "Private"
@@ -185,24 +176,6 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
     Ok(has_transformed_module)
 }
 
-fn transform_collected_defs(
-    crate_id: &CrateId,
-    context: &mut HirContext,
-    collected_trait_impls: &[UnresolvedTraitImpl],
-    collected_functions: &mut [UnresolvedFunctions],
-) -> Result<(), (MacroError, FileId)> {
-    if has_aztec_dependency(crate_id, context) {
-        inject_compute_note_hash_and_nullifier(
-            crate_id,
-            context,
-            collected_trait_impls,
-            collected_functions,
-        )
-    } else {
-        Ok(())
-    }
-}
-
 //
 //                    Transform Hir Nodes for Aztec
 //
@@ -212,6 +185,12 @@ fn transform_hir(
     crate_id: &CrateId,
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
-    transform_events(crate_id, context)?;
-    assign_storage_slots(crate_id, context)
+    if has_aztec_dependency(crate_id, context) {
+        transform_events(crate_id, context)?;
+        inject_compute_note_hash_and_nullifier(crate_id, context)?;
+        assign_storage_slots(crate_id, context)?;
+        inject_note_exports(crate_id, context)
+    } else {
+        Ok(())
+    }
 }
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index 1f5681ed470..1b6630935d9 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -1,48 +1,43 @@
 use noirc_errors::{Location, Span};
 use noirc_frontend::{
     graph::CrateId,
-    hir::{
-        def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
-        def_map::{LocalModuleId, ModuleId},
-    },
-    macros_api::{FileId, HirContext, MacroError},
-    node_interner::FuncId,
-    parse_program, FunctionReturnType, ItemVisibility, NoirFunction, UnresolvedTypeData,
+    macros_api::{FileId, HirContext},
+    parse_program, FunctionReturnType, NoirFunction, Type, UnresolvedTypeData,
 };
 
-use crate::utils::hir_utils::fetch_struct_trait_impls;
+use crate::utils::{
+    errors::AztecMacroError,
+    hir_utils::{collect_crate_functions, fetch_notes, get_contract_module_data, inject_fn},
+};
 
 // Check if "compute_note_hash_and_nullifier(AztecAddress,Field,Field,Field,[Field; N]) -> [Field; 4]" is defined
 fn check_for_compute_note_hash_and_nullifier_definition(
-    functions_data: &[(LocalModuleId, FuncId, NoirFunction)],
-    module_id: LocalModuleId,
+    crate_id: &CrateId,
+    context: &HirContext,
 ) -> bool {
-    functions_data.iter().filter(|func_data| func_data.0 == module_id).any(|func_data| {
-        func_data.2.def.name.0.contents == "compute_note_hash_and_nullifier"
-                && func_data.2.def.parameters.len() == 5
-                && match &func_data.2.def.parameters[0].typ.typ {
-                    UnresolvedTypeData::Named(path, _, _) => path.segments.last().unwrap().0.contents == "AztecAddress",
-                    _ => false,
-                }
-                && func_data.2.def.parameters[1].typ.typ == UnresolvedTypeData::FieldElement
-                && func_data.2.def.parameters[2].typ.typ == UnresolvedTypeData::FieldElement
-                && func_data.2.def.parameters[3].typ.typ == UnresolvedTypeData::FieldElement
-                // checks if the 5th parameter is an array and the Box<UnresolvedType> in
-                // Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>) contains only fields
-                && match &func_data.2.def.parameters[4].typ.typ {
-                    UnresolvedTypeData::Array(_, inner_type) => {
-                        matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
-                    },
-                    _ => false,
-                }
+    collect_crate_functions(crate_id, context).iter().any(|funct_id| {
+        let func_data = context.def_interner.function_meta(funct_id);
+        let func_name = context.def_interner.function_name(funct_id);
+        func_name == "compute_note_hash_and_nullifier"
+                && func_data.parameters.len() == 5
+                && func_data.parameters.0.first().is_some_and(| (_, typ, _) | match typ {
+                    Type::Struct(struct_typ, _) => struct_typ.borrow().name.0.contents == "AztecAddress",
+                    _ => false
+                })
+                && func_data.parameters.0.get(1).is_some_and(|(_, typ, _)| typ.is_field())
+                && func_data.parameters.0.get(2).is_some_and(|(_, typ, _)| typ.is_field())
+                && func_data.parameters.0.get(3).is_some_and(|(_, typ, _)|  typ.is_field())
+                // checks if the 5th parameter is an array and contains only fields
+                && func_data.parameters.0.get(4).is_some_and(|(_, typ, _)|  match typ {
+                    Type::Array(_, inner_type) => inner_type.to_owned().is_field(),
+                    _ => false
+                })
                 // We check the return type the same way as we did the 5th parameter
-                && match &func_data.2.def.return_type {
+                && match &func_data.return_type {
                     FunctionReturnType::Default(_) => false,
                     FunctionReturnType::Ty(unresolved_type) => {
                         match &unresolved_type.typ {
-                            UnresolvedTypeData::Array(_, inner_type) => {
-                                matches!(inner_type.typ, UnresolvedTypeData::FieldElement)
-                            },
+                            UnresolvedTypeData::Array(_, inner_type) => matches!(inner_type.typ, UnresolvedTypeData::FieldElement),
                             _ => false,
                         }
                     }
@@ -53,77 +48,33 @@ fn check_for_compute_note_hash_and_nullifier_definition(
 pub fn inject_compute_note_hash_and_nullifier(
     crate_id: &CrateId,
     context: &mut HirContext,
-    unresolved_traits_impls: &[UnresolvedTraitImpl],
-    collected_functions: &mut [UnresolvedFunctions],
-) -> Result<(), (MacroError, FileId)> {
-    // We first fetch modules in this crate which correspond to contracts, along with their file id.
-    let contract_module_file_ids: Vec<(LocalModuleId, FileId)> = context
-        .def_map(crate_id)
-        .expect("ICE: Missing crate in def_map")
-        .modules()
-        .iter()
-        .filter(|(_, module)| module.is_contract)
-        .map(|(idx, module)| (LocalModuleId(idx), module.location.file))
-        .collect();
-
-    // If the current crate does not contain a contract module we simply skip it.
-    if contract_module_file_ids.is_empty() {
-        return Ok(());
-    } else if contract_module_file_ids.len() != 1 {
-        panic!("Found multiple contracts in the same crate");
+) -> Result<(), (AztecMacroError, FileId)> {
+    if let Some((module_id, file_id)) = get_contract_module_data(context, crate_id) {
+        // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
+        // escape hatch for this mechanism.
+        // TODO(#4647): improve this diagnosis and error messaging.
+        if check_for_compute_note_hash_and_nullifier_definition(crate_id, context) {
+            return Ok(());
+        }
+
+        // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
+        // contract might use. These are the types that are marked as #[aztec(note)].
+        let note_types = fetch_notes(context)
+            .iter()
+            .map(|(_, note)| note.borrow().name.0.contents.clone())
+            .collect::<Vec<_>>();
+
+        // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
+        let func = generate_compute_note_hash_and_nullifier(&note_types);
+
+        // And inject the newly created function into the contract.
+
+        // TODO(#4373): We don't have a reasonable location for the source code of this autogenerated function, so we simply
+        // pass an empty span. This function should not produce errors anyway so this should not matter.
+        let location = Location::new(Span::empty(0), file_id);
+
+        inject_fn(crate_id, context, func, location, module_id, file_id);
     }
-
-    let (module_id, file_id) = contract_module_file_ids[0];
-
-    // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
-    // escape hatch for this mechanism.
-    // TODO(#4647): improve this diagnosis and error messaging.
-    if collected_functions.iter().any(|coll_funcs_data| {
-        check_for_compute_note_hash_and_nullifier_definition(&coll_funcs_data.functions, module_id)
-    }) {
-        return Ok(());
-    }
-
-    // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
-    // contract might use. These are the types that implement the NoteInterface trait, which provides the
-    // get_note_type_id function.
-    let note_types = fetch_struct_trait_impls(context, unresolved_traits_impls, "NoteInterface");
-
-    // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
-    let func = generate_compute_note_hash_and_nullifier(&note_types);
-
-    // And inject the newly created function into the contract.
-
-    // TODO(#4373): We don't have a reasonable location for the source code of this autogenerated function, so we simply
-    // pass an empty span. This function should not produce errors anyway so this should not matter.
-    let location = Location::new(Span::empty(0), file_id);
-
-    // These are the same things the ModCollector does when collecting functions: we push the function to the
-    // NodeInterner, declare it in the module (which checks for duplicate definitions), and finally add it to the list
-    // on collected but unresolved functions.
-
-    let func_id = context.def_interner.push_empty_fn();
-    context.def_interner.push_function(
-        func_id,
-        &func.def,
-        ModuleId { krate: *crate_id, local_id: module_id },
-        location,
-    );
-
-    context.def_map_mut(crate_id).unwrap()
-        .modules_mut()[module_id.0]
-        .declare_function(
-            func.name_ident().clone(), ItemVisibility::Public, func_id
-        ).expect(
-            "Failed to declare the autogenerated compute_note_hash_and_nullifier function, likely due to a duplicate definition. See https://github.com/AztecProtocol/aztec-packages/issues/4647."
-        );
-
-    collected_functions
-        .iter_mut()
-        .find(|fns| fns.file_id == file_id)
-        .expect("ICE: no functions found in contract file")
-        .push_fn(module_id, func_id, func.clone());
-
     Ok(())
 }
 
diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
index e7e39ed29ba..4f2b70453df 100644
--- a/aztec_macros/src/transforms/events.rs
+++ b/aztec_macros/src/transforms/events.rs
@@ -16,7 +16,8 @@ use crate::{
     chained_dep,
     utils::{
         ast_utils::{
-            call, expression, ident, ident_path, make_statement, make_type, path, variable_path,
+            call, expression, ident, ident_path, is_custom_attribute, make_statement, make_type,
+            path, variable_path,
         },
         constants::SIGNATURE_PLACEHOLDER,
         errors::AztecMacroError,
@@ -38,7 +39,8 @@ use crate::{
 /// This allows developers to emit events without having to write the signature of the event every time they emit it.
 /// The signature cannot be known at this point since types are not resolved yet, so we use a signature placeholder.
 /// It'll get resolved after by transforming the HIR.
-pub fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
+pub fn generate_selector_impl(structure: &mut NoirStruct) -> TypeImpl {
+    structure.attributes.push(SecondaryAttribute::Abi("events".to_string()));
     let struct_type =
         make_type(UnresolvedTypeData::Named(path(structure.name.clone()), vec![], true));
 
@@ -172,9 +174,9 @@ pub fn transform_events(
     crate_id: &CrateId,
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
-    for struct_id in collect_crate_structs(crate_id, context) {
+    for (_, struct_id) in collect_crate_structs(crate_id, context) {
         let attributes = context.def_interner.struct_attributes(&struct_id);
-        if attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Event)) {
+        if attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(event)")) {
             transform_event(struct_id, &mut context.def_interner)?;
         }
     }
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 9844abc30fe..a3064ecdd01 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -1,10 +1,10 @@
 use convert_case::{Case, Casing};
 use noirc_errors::Span;
 use noirc_frontend::{
-    macros_api::FieldElement, BlockExpression, ConstrainKind, ConstrainStatement, Distinctness,
-    Expression, ExpressionKind, ForLoopStatement, ForRange, FunctionReturnType, Ident, Literal,
-    NoirFunction, Param, PathKind, Pattern, Signedness, Statement, StatementKind, UnresolvedType,
-    UnresolvedTypeData, Visibility,
+    macros_api::FieldElement, parse_program, BlockExpression, ConstrainKind, ConstrainStatement,
+    Distinctness, Expression, ExpressionKind, ForLoopStatement, ForRange, FunctionReturnType,
+    Ident, Literal, NoirFunction, NoirStruct, Param, PathKind, Pattern, Signedness, Statement,
+    StatementKind, UnresolvedType, UnresolvedTypeData, Visibility,
 };
 
 use crate::{
@@ -45,13 +45,13 @@ pub fn transform_function(
 
     // Add initialization check
     if insert_init_check {
-        let init_check = create_init_check();
+        let init_check = create_init_check(ty);
         func.def.body.statements.insert(0, init_check);
     }
 
     // Add assertion for initialization arguments and sender
     if is_initializer {
-        func.def.body.statements.insert(0, create_assert_initializer());
+        func.def.body.statements.insert(0, create_assert_initializer(ty));
     }
 
     // Add access to the storage struct
@@ -85,7 +85,7 @@ pub fn transform_function(
 
     // Before returning mark the contract as initialized
     if is_initializer {
-        let mark_initialized = create_mark_as_initialized();
+        let mark_initialized = create_mark_as_initialized(ty);
         func.def.body.statements.push(mark_initialized);
     }
 
@@ -113,6 +113,92 @@ pub fn transform_function(
     Ok(())
 }
 
+// Generates a global struct containing the original (before transform_function gets executed) function abi that gets exported
+// in the contract artifact after compilation. The abi will be later used to decode the function return values in the simulator.
+pub fn export_fn_abi(
+    types: &mut Vec<NoirStruct>,
+    func: &NoirFunction,
+) -> Result<(), AztecMacroError> {
+    let mut parameters_struct_source: Option<&str> = None;
+
+    let struct_source = format!(
+        "
+        struct {}_parameters {{
+            {}
+        }}
+    ",
+        func.name(),
+        func.parameters()
+            .iter()
+            .map(|param| {
+                let param_name = match param.pattern.clone() {
+                    Pattern::Identifier(ident) => Ok(ident.0.contents),
+                    _ => Err(AztecMacroError::CouldNotExportFunctionAbi {
+                        span: Some(param.span),
+                        secondary_message: Some(
+                            "Only identifier patterns are supported".to_owned(),
+                        ),
+                    }),
+                };
+
+                format!(
+                    "{}: {}",
+                    param_name.unwrap(),
+                    param.typ.typ.to_string().replace("plain::", "")
+                )
+            })
+            .collect::<Vec<String>>()
+            .join(",\n"),
+    );
+
+    if !func.parameters().is_empty() {
+        parameters_struct_source = Some(&struct_source);
+    }
+
+    let mut program = String::new();
+
+    let parameters = if let Some(parameters_struct_source) = parameters_struct_source {
+        program.push_str(parameters_struct_source);
+        format!("parameters: {}_parameters,\n", func.name())
+    } else {
+        "".to_string()
+    };
+
+    let return_type_str = func.return_type().typ.to_string().replace("plain::", "");
+    let return_type = if return_type_str != "()" {
+        format!("return_type: {},\n", return_type_str)
+    } else {
+        "".to_string()
+    };
+
+    let export_struct_source = format!(
+        "
+        #[abi(functions)]
+        struct {}_abi {{
+            {}{}
+        }}",
+        func.name(),
+        parameters,
+        return_type
+    );
+
+    program.push_str(&export_struct_source);
+
+    let (ast, errors) = parse_program(&program);
+    if !errors.is_empty() {
+        return Err(AztecMacroError::CouldNotExportFunctionAbi {
+            span: None,
+            secondary_message: Some(
+                format!("Failed to parse Noir macro code (struct {}_abi). This is either a bug in the compiler or the Noir macro code", func.name())
+            )
+        });
+    }
+
+    let sorted_ast = ast.into_sorted();
+    types.extend(sorted_ast.types);
+    Ok(())
+}
+
 /// Transform Unconstrained
 ///
 /// Inserts the following code at the beginning of an unconstrained function
@@ -159,9 +245,10 @@ fn create_inputs(ty: &str) -> Param {
 /// ```noir
 /// assert_is_initialized(&mut context);
 /// ```
-fn create_init_check() -> Statement {
+fn create_init_check(ty: &str) -> Statement {
+    let fname = format!("assert_is_initialized_{}", ty.to_case(Case::Snake));
     make_statement(StatementKind::Expression(call(
-        variable_path(chained_dep!("aztec", "initializer", "assert_is_initialized")),
+        variable_path(chained_dep!("aztec", "initializer", &fname)),
         vec![mutable_reference("context")],
     )))
 }
@@ -172,9 +259,10 @@ fn create_init_check() -> Statement {
 /// ```noir
 /// mark_as_initialized(&mut context);
 /// ```
-fn create_mark_as_initialized() -> Statement {
+fn create_mark_as_initialized(ty: &str) -> Statement {
+    let fname = format!("mark_as_initialized_{}", ty.to_case(Case::Snake));
     make_statement(StatementKind::Expression(call(
-        variable_path(chained_dep!("aztec", "initializer", "mark_as_initialized")),
+        variable_path(chained_dep!("aztec", "initializer", &fname)),
         vec![mutable_reference("context")],
     )))
 }
@@ -205,13 +293,11 @@ fn create_internal_check(fname: &str) -> Statement {
 /// ```noir
 /// assert_initialization_matches_address_preimage(context);
 /// ```
-fn create_assert_initializer() -> Statement {
+fn create_assert_initializer(ty: &str) -> Statement {
+    let fname =
+        format!("assert_initialization_matches_address_preimage_{}", ty.to_case(Case::Snake));
     make_statement(StatementKind::Expression(call(
-        variable_path(chained_dep!(
-            "aztec",
-            "initializer",
-            "assert_initialization_matches_address_preimage"
-        )),
+        variable_path(chained_dep!("aztec", "initializer", &fname)),
         vec![variable("context")],
     )))
 }
@@ -223,62 +309,66 @@ fn create_assert_initializer() -> Statement {
 /// ```noir
 /// #[aztec(private)]
 /// fn foo(structInput: SomeStruct, arrayInput: [u8; 10], fieldInput: Field) -> Field {
-///     // Create the bounded vec object
-///     let mut serialized_args = BoundedVec::new();
+///     // Create the hasher object
+///     let mut hasher = Hasher::new();
 ///
 ///     // struct inputs call serialize on them to add an array of fields
-///     serialized_args.extend_from_array(structInput.serialize());
+///     hasher.add_multiple(structInput.serialize());
 ///
-///     // Array inputs are iterated over and each element is added to the bounded vec (as a field)
+///     // Array inputs are iterated over and each element is added to the hasher (as a field)
 ///     for i in 0..arrayInput.len() {
-///         serialized_args.push(arrayInput[i] as Field);
+///         hasher.add(arrayInput[i] as Field);
 ///     }
-///     // Field inputs are added to the bounded vec
-///     serialized_args.push({ident});
+///     // Field inputs are added to the hasher
+///     hasher.add({ident});
 ///
 ///     // Create the context
 ///     // The inputs (injected by this `create_inputs`) and completed hash object are passed to the context
-///     let mut context = PrivateContext::new(inputs, hash_args(serialized_args));
+///     let mut context = PrivateContext::new(inputs, hasher.hash());
 /// }
 /// ```
 fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
     let mut injected_expressions: Vec<Statement> = vec![];
 
-    // `let mut serialized_args = BoundedVec::new();`
-    let let_serialized_args = mutable_assignment(
-        "serialized_args", // Assigned to
+    let hasher_name = "args_hasher";
+
+    // `let mut args_hasher = Hasher::new();`
+    let let_hasher = mutable_assignment(
+        hasher_name, // Assigned to
         call(
-            variable_path(chained_dep!("std", "collections", "bounded_vec", "BoundedVec", "new")), // Path
-            vec![], // args
+            variable_path(chained_dep!("aztec", "hash", "ArgsHasher", "new")), // Path
+            vec![],                                                            // args
         ),
     );
 
-    // Completes: `let mut serialized_args = BoundedVec::new();`
-    injected_expressions.push(let_serialized_args);
+    // Completes: `let mut args_hasher = Hasher::new();`
+    injected_expressions.push(let_hasher);
 
-    // Iterate over each of the function parameters, adding to them to the bounded vec
+    // Iterate over each of the function parameters, adding to them to the hasher
     for Param { pattern, typ, span, .. } in params {
         match pattern {
             Pattern::Identifier(identifier) => {
                 // Match the type to determine the padding to do
                 let unresolved_type = &typ.typ;
                 let expression = match unresolved_type {
-                    // `serialized_args.extend_from_array({ident}.serialize())`
-                    UnresolvedTypeData::Named(..) => add_struct_to_serialized_args(identifier),
+                    // `hasher.add_multiple({ident}.serialize())`
+                    UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier, hasher_name),
                     UnresolvedTypeData::Array(_, arr_type) => {
-                        add_array_to_serialized_args(identifier, arr_type)
+                        add_array_to_hasher(identifier, arr_type, hasher_name)
+                    }
+                    // `hasher.add({ident})`
+                    UnresolvedTypeData::FieldElement => {
+                        add_field_to_hasher(identifier, hasher_name)
                     }
-                    // `serialized_args.push({ident})`
-                    UnresolvedTypeData::FieldElement => add_field_to_serialized_args(identifier),
-                    // Add the integer to the serialized args, casted to a field
-                    // `serialized_args.push({ident} as Field)`
+                    // Add the integer to the hasher, casted to a field
+                    // `hasher.add({ident} as Field)`
                     UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
-                        add_cast_to_serialized_args(identifier)
+                        add_cast_to_hasher(identifier, hasher_name)
                     }
                     UnresolvedTypeData::String(..) => {
                         let (var_bytes, id) = str_to_bytes(identifier);
                         injected_expressions.push(var_bytes);
-                        add_array_to_serialized_args(
+                        add_array_to_hasher(
                             &id,
                             &UnresolvedType {
                                 typ: UnresolvedTypeData::Integer(
@@ -287,6 +377,7 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
                                 ),
                                 span: None,
                             },
+                            hasher_name,
                         )
                     }
                     _ => {
@@ -304,10 +395,11 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
 
     // Create the inputs to the context
     let inputs_expression = variable("inputs");
-    // `hash_args(serialized_args)`
-    let hash_call = call(
-        variable_path(chained_dep!("aztec", "hash", "hash_args")), // variable
-        vec![variable("serialized_args")],                         // args
+    // `args_hasher.hash()`
+    let hash_call = method_call(
+        variable(hasher_name), // variable
+        "hash",                // method name
+        vec![],                // args
     );
 
     let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
@@ -591,11 +683,11 @@ fn create_context_finish() -> Statement {
 }
 
 //
-//                 Methods to create hash_args inputs
+//                 Methods to create hasher inputs
 //
 
-fn add_struct_to_serialized_args(identifier: &Ident) -> Statement {
-    // If this is a struct, we call serialize and add the array to the serialized args
+fn add_struct_to_hasher(identifier: &Ident, hasher_name: &str) -> Statement {
+    // If this is a struct, we call serialize and add the array to the hasher
     let serialized_call = method_call(
         variable_path(path(identifier.clone())), // variable
         "serialize",                             // method name
@@ -603,9 +695,9 @@ fn add_struct_to_serialized_args(identifier: &Ident) -> Statement {
     );
 
     make_statement(StatementKind::Semi(method_call(
-        variable("serialized_args"), // variable
-        "extend_from_array",         // method name
-        vec![serialized_call],       // args
+        variable(hasher_name), // variable
+        "add_multiple",        // method name
+        vec![serialized_call], // args
     )))
 }
 
@@ -625,7 +717,7 @@ fn str_to_bytes(identifier: &Ident) -> (Statement, Ident) {
 }
 
 fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the serialized args
+    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
     // casted to a field
     let span = var.span;
 
@@ -638,7 +730,7 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
 
     // What will be looped over
 
-    // - `serialized_args.push({ident}[i] as Field)`
+    // - `hasher.add({ident}[i] as Field)`
     let for_loop_block =
         expression(ExpressionKind::Block(BlockExpression { statements: loop_body }));
 
@@ -657,66 +749,70 @@ fn create_loop_over(var: Expression, loop_body: Vec<Statement>) -> Statement {
     }))
 }
 
-fn add_array_to_serialized_args(identifier: &Ident, arr_type: &UnresolvedType) -> Statement {
-    // If this is an array of primitive types (integers / fields) we can add them each to the serialized_args
+fn add_array_to_hasher(
+    identifier: &Ident,
+    arr_type: &UnresolvedType,
+    hasher_name: &str,
+) -> Statement {
+    // If this is an array of primitive types (integers / fields) we can add them each to the hasher
     // casted to a field
 
     // Wrap in the semi thing - does that mean ended with semi colon?
-    // `serialized_args.push({ident}[i] as Field)`
+    // `hasher.add({ident}[i] as Field)`
 
     let arr_index = index_array(identifier.clone(), "i");
-    let (add_expression, vec_method_name) = match arr_type.typ {
+    let (add_expression, hasher_method_name) = match arr_type.typ {
         UnresolvedTypeData::Named(..) => {
-            let vec_method_name = "extend_from_array".to_owned();
+            let hasher_method_name = "add_multiple".to_owned();
             let call = method_call(
                 // All serialize on each element
                 arr_index,   // variable
                 "serialize", // method name
                 vec![],      // args
             );
-            (call, vec_method_name)
+            (call, hasher_method_name)
         }
         _ => {
-            let vec_method_name = "push".to_owned();
+            let hasher_method_name = "add".to_owned();
             let call = cast(
                 arr_index,                        // lhs - `ident[i]`
                 UnresolvedTypeData::FieldElement, // cast to - `as Field`
             );
-            (call, vec_method_name)
+            (call, hasher_method_name)
         }
     };
 
     let block_statement = make_statement(StatementKind::Semi(method_call(
-        variable("serialized_args"), // variable
-        &vec_method_name,            // method name
+        variable(hasher_name), // variable
+        &hasher_method_name,   // method name
         vec![add_expression],
     )));
 
     create_loop_over(variable_ident(identifier.clone()), vec![block_statement])
 }
 
-fn add_field_to_serialized_args(identifier: &Ident) -> Statement {
-    // `serialized_args.push({ident})`
+fn add_field_to_hasher(identifier: &Ident, hasher_name: &str) -> Statement {
+    // `hasher.add({ident})`
     let ident = variable_path(path(identifier.clone()));
     make_statement(StatementKind::Semi(method_call(
-        variable("serialized_args"), // variable
-        "push",                      // method name
-        vec![ident],                 // args
+        variable(hasher_name), // variable
+        "add",                 // method name
+        vec![ident],           // args
     )))
 }
 
-fn add_cast_to_serialized_args(identifier: &Ident) -> Statement {
-    // `serialized_args.push({ident} as Field)`
+fn add_cast_to_hasher(identifier: &Ident, hasher_name: &str) -> Statement {
+    // `hasher.add({ident} as Field)`
     // `{ident} as Field`
     let cast_operation = cast(
         variable_path(path(identifier.clone())), // lhs
         UnresolvedTypeData::FieldElement,        // rhs
     );
 
-    // `serialized_args.push({ident} as Field)`
+    // `hasher.add({ident} as Field)`
     make_statement(StatementKind::Semi(method_call(
-        variable("serialized_args"), // variable
-        "push",                      // method name
-        vec![cast_operation],        // args
+        variable(hasher_name), // variable
+        "add",                 // method name
+        vec![cast_operation],  // args
     )))
 }
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index 01d0272088b..0514155824e 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -1,7 +1,11 @@
 use noirc_errors::Span;
 use noirc_frontend::{
-    parse_program, parser::SortedModule, ItemVisibility, NoirFunction, NoirStruct, PathKind,
-    TraitImplItem, TypeImpl, UnresolvedTypeData, UnresolvedTypeExpression,
+    graph::CrateId,
+    macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
+    parse_program,
+    parser::SortedModule,
+    ItemVisibility, LetStatement, NoirFunction, NoirStruct, PathKind, TraitImplItem, Type,
+    TypeImpl, UnresolvedTypeData, UnresolvedTypeExpression,
 };
 use regex::Regex;
 
@@ -12,6 +16,7 @@ use crate::{
             check_trait_method_implemented, ident, ident_path, is_custom_attribute, make_type,
         },
         errors::AztecMacroError,
+        hir_utils::{fetch_notes, get_contract_module_data, inject_global},
     },
 };
 
@@ -24,7 +29,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
         .iter_mut()
         .filter(|typ| typ.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(note)")));
 
-    let mut note_properties_structs = vec![];
+    let mut structs_to_inject = vec![];
 
     for note_struct in annotated_note_structs {
         // Look for the NoteInterface trait implementation for the note
@@ -80,6 +85,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 )),
             }),
         }?;
+        let note_type_id = note_type_id(&note_type);
 
         // Automatically inject the header field if it's not present
         let (header_field_name, _) = if let Some(existing_header) =
@@ -138,7 +144,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 &header_field_name.0.contents,
                 note_interface_impl_span,
             )?;
-            note_properties_structs.push(note_properties_struct);
+            structs_to_inject.push(note_properties_struct);
             let note_properties_fn = generate_note_properties_fn(
                 &note_type,
                 &note_fields,
@@ -167,7 +173,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
 
         if !check_trait_method_implemented(trait_impl, "get_note_type_id") {
             let get_note_type_id_fn =
-                generate_note_get_type_id(&note_type, note_interface_impl_span)?;
+                generate_note_get_type_id(&note_type_id, note_interface_impl_span)?;
             trait_impl.items.push(TraitImplItem::Function(get_note_type_id_fn));
         }
 
@@ -178,7 +184,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
         }
     }
 
-    module.types.extend(note_properties_structs);
+    module.types.extend(structs_to_inject);
     Ok(())
 }
 
@@ -245,19 +251,16 @@ fn generate_note_set_header(
 // Automatically generate the note type id getter method. The id itself its calculated as the concatenation
 // of the conversion of the characters in the note's struct name to unsigned integers.
 fn generate_note_get_type_id(
-    note_type: &str,
+    note_type_id: &str,
     impl_span: Option<Span>,
 ) -> Result<NoirFunction, AztecMacroError> {
-    // TODO(#4519) Improve automatic note id generation and assignment
-    let note_id =
-        note_type.chars().map(|c| (c as u32).to_string()).collect::<Vec<String>>().join("");
     let function_source = format!(
         "
         fn get_note_type_id() -> Field {{
             {}
         }}
     ",
-        note_id
+        note_type_id
     )
     .to_string();
 
@@ -443,6 +446,34 @@ fn generate_compute_note_content_hash(
     Ok(noir_fn)
 }
 
+fn generate_note_exports_global(
+    note_type: &str,
+    note_type_id: &str,
+) -> Result<LetStatement, AztecMacroError> {
+    let struct_source = format!(
+        "
+        #[abi(notes)]
+        global {0}_EXPORTS: (Field, str<{1}>) = ({2},\"{0}\");
+        ",
+        note_type,
+        note_type_id.len(),
+        note_type_id
+    )
+    .to_string();
+
+    let (global_ast, errors) = parse_program(&struct_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some(format!("Failed to parse Noir macro code (struct {}Exports). This is either a bug in the compiler or the Noir macro code", note_type)),
+            span: None
+        });
+    }
+
+    let mut global_ast = global_ast.into_sorted();
+    Ok(global_ast.globals.pop().unwrap())
+}
+
 // Source code generator functions. These utility methods produce Noir code as strings, that are then parsed and added to the AST.
 
 fn generate_note_properties_struct_source(
@@ -581,3 +612,85 @@ fn generate_note_deserialize_content_source(
     )
     .to_string()
 }
+
+// Utility function to generate the note type id as a Field
+fn note_type_id(note_type: &str) -> String {
+    // TODO(#4519) Improve automatic note id generation and assignment
+    note_type.chars().map(|c| (c as u32).to_string()).collect::<Vec<String>>().join("")
+}
+
+pub fn inject_note_exports(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+) -> Result<(), (AztecMacroError, FileId)> {
+    if let Some((module_id, file_id)) = get_contract_module_data(context, crate_id) {
+        let notes = fetch_notes(context);
+
+        for (_, note) in notes {
+            let func_id = context
+                .def_interner
+                .lookup_method(
+                    &Type::Struct(context.def_interner.get_struct(note.borrow().id), vec![]),
+                    note.borrow().id,
+                    "get_note_type_id",
+                    false,
+                )
+                .ok_or((
+                    AztecMacroError::CouldNotExportStorageLayout {
+                        span: None,
+                        secondary_message: Some(format!(
+                            "Could not retrieve get_note_type_id function for note {}",
+                            note.borrow().name.0.contents
+                        )),
+                    },
+                    file_id,
+                ))?;
+            let init_function =
+                context.def_interner.function(&func_id).block(&context.def_interner);
+            let init_function_statement_id = init_function.statements().first().ok_or((
+                AztecMacroError::CouldNotExportStorageLayout {
+                    span: None,
+                    secondary_message: Some(format!(
+                        "Could not retrieve note id statement from function for note {}",
+                        note.borrow().name.0.contents
+                    )),
+                },
+                file_id,
+            ))?;
+            let note_id_statement = context.def_interner.statement(init_function_statement_id);
+
+            let note_id_value = match note_id_statement {
+                HirStatement::Expression(expression_id) => {
+                    match context.def_interner.expression(&expression_id) {
+                        HirExpression::Literal(HirLiteral::Integer(value, _)) => Ok(value),
+                        _ => Err((
+                            AztecMacroError::CouldNotExportStorageLayout {
+                                span: None,
+                                secondary_message: Some(
+                                    "note_id statement must be a literal expression".to_string(),
+                                ),
+                            },
+                            file_id,
+                        )),
+                    }
+                }
+                _ => Err((
+                    AztecMacroError::CouldNotAssignStorageSlots {
+                        secondary_message: Some(
+                            "note_id statement must be an expression".to_string(),
+                        ),
+                    },
+                    file_id,
+                )),
+            }?;
+            let global = generate_note_exports_global(
+                &note.borrow().name.0.contents,
+                &note_id_value.to_string(),
+            )
+            .map_err(|err| (err, file_id))?;
+
+            inject_global(crate_id, context, global, module_id, file_id);
+        }
+    }
+    Ok(())
+}
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 10f44d01bb4..0bfb39cbc71 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -1,4 +1,4 @@
-use std::borrow::{Borrow, BorrowMut};
+use std::borrow::Borrow;
 
 use noirc_errors::Span;
 use noirc_frontend::{
@@ -7,33 +7,53 @@ use noirc_frontend::{
         FieldElement, FileId, HirContext, HirExpression, HirLiteral, HirStatement, NodeInterner,
     },
     node_interner::{TraitId, TraitImplKind},
+    parse_program,
     parser::SortedModule,
+    token::SecondaryAttribute,
     BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
-    PathKind, Pattern, StatementKind, Type, TypeImpl, UnresolvedType, UnresolvedTypeData,
+    NoirStruct, PathKind, Pattern, StatementKind, Type, TypeImpl, UnresolvedType,
+    UnresolvedTypeData,
 };
 
 use crate::{
     chained_dep, chained_path,
     utils::{
         ast_utils::{
-            call, expression, ident, ident_path, lambda, make_statement, make_type, pattern,
-            return_type, variable, variable_path,
+            call, expression, ident, ident_path, is_custom_attribute, lambda, make_statement,
+            make_type, pattern, return_type, variable, variable_path,
         },
         errors::AztecMacroError,
-        hir_utils::{collect_crate_structs, collect_traits},
+        hir_utils::{collect_crate_structs, collect_traits, get_contract_module_data},
     },
 };
 
 // Check to see if the user has defined a storage struct
-pub fn check_for_storage_definition(module: &SortedModule) -> bool {
-    module.types.iter().any(|r#struct| r#struct.name.0.contents == "Storage")
+pub fn check_for_storage_definition(
+    module: &SortedModule,
+) -> Result<Option<String>, AztecMacroError> {
+    let result: Vec<&NoirStruct> = module
+        .types
+        .iter()
+        .filter(|r#struct| {
+            r#struct.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(storage)"))
+        })
+        .collect();
+    if result.len() > 1 {
+        return Err(AztecMacroError::MultipleStorageDefinitions {
+            span: result.first().map(|res| res.name.span()),
+        });
+    }
+    Ok(result.iter().map(|&r#struct| r#struct.name.0.contents.clone()).next())
 }
 
 // Check to see if the user has defined a storage struct
-pub fn check_for_storage_implementation(module: &SortedModule) -> bool {
+pub fn check_for_storage_implementation(
+    module: &SortedModule,
+    storage_struct_name: &String,
+) -> bool {
     module.impls.iter().any(|r#impl| match &r#impl.object_type.typ {
         UnresolvedTypeData::Named(path, _, _) => {
-            path.segments.last().is_some_and(|segment| segment.0.contents == "Storage")
+            path.segments.last().is_some_and(|segment| segment.0.contents == *storage_struct_name)
         }
         _ => false,
     })
@@ -117,9 +137,15 @@ pub fn generate_storage_field_constructor(
 ///
 /// Storage slots are generated as 0 and will be populated using the information from the HIR
 /// at a later stage.
-pub fn generate_storage_implementation(module: &mut SortedModule) -> Result<(), AztecMacroError> {
-    let definition =
-        module.types.iter().find(|r#struct| r#struct.name.0.contents == "Storage").unwrap();
+pub fn generate_storage_implementation(
+    module: &mut SortedModule,
+    storage_struct_name: &String,
+) -> Result<(), AztecMacroError> {
+    let definition = module
+        .types
+        .iter()
+        .find(|r#struct| r#struct.name.0.contents == *storage_struct_name)
+        .unwrap();
 
     let slot_zero = expression(ExpressionKind::Literal(Literal::Integer(
         FieldElement::from(i128::from(0)),
@@ -136,7 +162,7 @@ pub fn generate_storage_implementation(module: &mut SortedModule) -> Result<(),
         .collect();
 
     let storage_constructor_statement = make_statement(StatementKind::Expression(expression(
-        ExpressionKind::constructor((chained_path!("Storage"), field_constructors)),
+        ExpressionKind::constructor((chained_path!(storage_struct_name), field_constructors)),
     )));
 
     let init = NoirFunction::normal(FunctionDefinition::normal(
@@ -157,7 +183,7 @@ pub fn generate_storage_implementation(module: &mut SortedModule) -> Result<(),
 
     let storage_impl = TypeImpl {
         object_type: UnresolvedType {
-            typ: UnresolvedTypeData::Named(chained_path!("Storage"), vec![], true),
+            typ: UnresolvedTypeData::Named(chained_path!(storage_struct_name), vec![], true),
             span: Some(Span::default()),
         },
         type_span: Span::default(),
@@ -239,16 +265,51 @@ pub fn assign_storage_slots(
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
     let traits: Vec<_> = collect_traits(context);
-    for struct_id in collect_crate_structs(crate_id, context) {
-        let interner: &mut NodeInterner = context.def_interner.borrow_mut();
-        let r#struct = interner.get_struct(struct_id);
-        let file_id = r#struct.borrow().location.file;
-        if r#struct.borrow().name.0.contents == "Storage" && r#struct.borrow().id.krate().is_root()
+    if let Some((_, file_id)) = get_contract_module_data(context, crate_id) {
+        let maybe_storage_struct =
+            collect_crate_structs(crate_id, context).iter().find_map(|&(_, struct_id)| {
+                let r#struct = context.def_interner.get_struct(struct_id);
+                let attributes = context.def_interner.struct_attributes(&struct_id);
+                if attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(storage)"))
+                    && r#struct.borrow().id.krate().is_root()
+                {
+                    Some(r#struct)
+                } else {
+                    None
+                }
+            });
+
+        let maybe_storage_layout =
+            context.def_interner.get_all_globals().iter().find_map(|global_info| {
+                let statement = context.def_interner.get_global_let_statement(global_info.id);
+                if statement.clone().is_some_and(|stmt| {
+                    stmt.attributes
+                        .iter()
+                        .any(|attr| *attr == SecondaryAttribute::Abi("storage".to_string()))
+                }) {
+                    let expr = context.def_interner.expression(&statement.unwrap().expression);
+                    match expr {
+                        HirExpression::Constructor(hir_constructor_expression) => {
+                            Some(hir_constructor_expression)
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                }
+            });
+
+        if let (Some(storage_struct), Some(storage_layout)) =
+            (maybe_storage_struct, maybe_storage_layout)
         {
-            let init_id = interner
+            let init_id = context
+                .def_interner
                 .lookup_method(
-                    &Type::Struct(interner.get_struct(struct_id), vec![]),
-                    struct_id,
+                    &Type::Struct(
+                        context.def_interner.get_struct(storage_struct.borrow().id),
+                        vec![],
+                    ),
+                    storage_struct.borrow().id,
                     "init",
                     false,
                 )
@@ -260,28 +321,33 @@ pub fn assign_storage_slots(
                     },
                     file_id,
                 ))?;
-            let init_function = interner.function(&init_id).block(interner);
+            let init_function =
+                context.def_interner.function(&init_id).block(&context.def_interner);
             let init_function_statement_id = init_function.statements().first().ok_or((
                 AztecMacroError::CouldNotAssignStorageSlots {
                     secondary_message: Some("Init storage statement not found".to_string()),
                 },
                 file_id,
             ))?;
-            let storage_constructor_statement = interner.statement(init_function_statement_id);
+            let storage_constructor_statement =
+                context.def_interner.statement(init_function_statement_id);
 
             let storage_constructor_expression = match storage_constructor_statement {
                 HirStatement::Expression(expression_id) => {
-                    match interner.expression(&expression_id) {
-                        HirExpression::Constructor(hir_constructor_expression) => {
-                            Ok(hir_constructor_expression)
-                        }
-                        _ => Err((AztecMacroError::CouldNotAssignStorageSlots {
+                    match context.def_interner.expression(&expression_id) {
+                    HirExpression::Constructor(hir_constructor_expression) => {
+                        Ok(hir_constructor_expression)
+                    }
+                    _ => Err((
+                        AztecMacroError::CouldNotAssignStorageSlots {
                             secondary_message: Some(
                                 "Storage constructor statement must be a constructor expression"
                                     .to_string(),
                             ),
-                        }, file_id))
-                    }
+                        },
+                        file_id,
+                    )),
+                }
                 }
                 _ => Err((
                     AztecMacroError::CouldNotAssignStorageSlots {
@@ -295,9 +361,9 @@ pub fn assign_storage_slots(
 
             let mut storage_slot: u64 = 1;
             for (index, (_, expr_id)) in storage_constructor_expression.fields.iter().enumerate() {
-                let fields = r#struct.borrow().get_fields(&[]);
-                let (_, field_type) = fields.get(index).unwrap();
-                let new_call_expression = match interner.expression(expr_id) {
+                let fields = storage_struct.borrow().get_fields(&[]);
+                let (field_name, field_type) = fields.get(index).unwrap();
+                let new_call_expression = match context.def_interner.expression(expr_id) {
                     HirExpression::Call(hir_call_expression) => Ok(hir_call_expression),
                     _ => Err((
                         AztecMacroError::CouldNotAssignStorageSlots {
@@ -310,7 +376,8 @@ pub fn assign_storage_slots(
                     )),
                 }?;
 
-                let slot_arg_expression = interner.expression(&new_call_expression.arguments[1]);
+                let slot_arg_expression =
+                    context.def_interner.expression(&new_call_expression.arguments[1]);
 
                 let current_storage_slot = match slot_arg_expression {
                     HirExpression::Literal(HirLiteral::Integer(slot, _)) => Ok(slot.to_u128()),
@@ -325,22 +392,123 @@ pub fn assign_storage_slots(
                     )),
                 }?;
 
-                if current_storage_slot != 0 {
-                    continue;
-                }
+                let storage_layout_field =
+                    storage_layout.fields.iter().find(|field| field.0 .0.contents == *field_name);
 
-                let type_serialized_len = get_serialized_length(&traits, field_type, interner)
-                    .map_err(|err| (err, file_id))?;
-                interner.update_expression(new_call_expression.arguments[1], |expr| {
+                let storage_layout_slot_expr_id =
+                    if let Some((_, expr_id)) = storage_layout_field {
+                        let expr = context.def_interner.expression(expr_id);
+                        if let HirExpression::Constructor(storage_layout_field_storable_expr) = expr
+                        {
+                            storage_layout_field_storable_expr.fields.iter().find_map(
+                                |(field, expr_id)| {
+                                    if field.0.contents == "slot" {
+                                        Some(*expr_id)
+                                    } else {
+                                        None
+                                    }
+                                },
+                            )
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                    .ok_or((
+                        AztecMacroError::CouldNotAssignStorageSlots {
+                            secondary_message: Some(format!(
+                                "Storage layout field ({}) not found or has an incorrect type",
+                                field_name
+                            )),
+                        },
+                        file_id,
+                    ))?;
+
+                let new_storage_slot = if current_storage_slot == 0 {
+                    u128::from(storage_slot)
+                } else {
+                    current_storage_slot
+                };
+
+                let type_serialized_len =
+                    get_serialized_length(&traits, field_type, &context.def_interner)
+                        .map_err(|err| (err, file_id))?;
+
+                context.def_interner.update_expression(new_call_expression.arguments[1], |expr| {
                     *expr = HirExpression::Literal(HirLiteral::Integer(
-                        FieldElement::from(u128::from(storage_slot)),
+                        FieldElement::from(new_storage_slot),
                         false,
-                    ));
+                    ))
+                });
+
+                context.def_interner.update_expression(storage_layout_slot_expr_id, |expr| {
+                    *expr = HirExpression::Literal(HirLiteral::Integer(
+                        FieldElement::from(new_storage_slot),
+                        false,
+                    ))
                 });
 
                 storage_slot += type_serialized_len;
             }
         }
     }
+
+    Ok(())
+}
+
+pub fn generate_storage_layout(
+    module: &mut SortedModule,
+    storage_struct_name: String,
+) -> Result<(), AztecMacroError> {
+    let definition = module
+        .types
+        .iter()
+        .find(|r#struct| r#struct.name.0.contents == *storage_struct_name)
+        .unwrap();
+
+    let mut generic_args = vec![];
+    let mut storable_fields = vec![];
+    let mut storable_fields_impl = vec![];
+
+    definition.fields.iter().enumerate().for_each(|(index, (field_ident, field_type))| {
+        storable_fields.push(format!("{}: dep::aztec::prelude::Storable<N{}>", field_ident, index));
+        generic_args.push(format!("N{}", index));
+        storable_fields_impl.push(format!(
+            "{}: dep::aztec::prelude::Storable {{ slot: 0, typ: \"{}\" }}",
+            field_ident,
+            field_type.to_string().replace("plain::", "")
+        ));
+    });
+
+    let storage_fields_source = format!(
+        "
+        struct StorageLayout<{}> {{
+            {}
+        }}
+
+        #[abi(storage)]
+        global STORAGE_LAYOUT = StorageLayout {{
+            {}
+        }};
+    ",
+        generic_args.join(", "),
+        storable_fields.join(",\n"),
+        storable_fields_impl.join(",\n")
+    );
+
+    let (struct_ast, errors) = parse_program(&storage_fields_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (struct StorageLayout). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: None
+        });
+    }
+
+    let mut struct_ast = struct_ast.into_sorted();
+    module.types.push(struct_ast.types.pop().unwrap());
+    module.globals.push(struct_ast.globals.pop().unwrap());
+
     Ok(())
 }
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index bdcbad646c2..eb8f5a4156d 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -67,6 +67,7 @@ pub fn mutable_assignment(name: &str, assigned_to: Expression) -> Statement {
         pattern: mutable(name),
         r#type: make_type(UnresolvedTypeData::Unspecified),
         expression: assigned_to,
+        attributes: vec![],
     }))
 }
 
@@ -82,6 +83,7 @@ pub fn assignment(name: &str, assigned_to: Expression) -> Statement {
         pattern: pattern(name),
         r#type: make_type(UnresolvedTypeData::Unspecified),
         expression: assigned_to,
+        attributes: vec![],
     }))
 }
 
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 48186555eff..9aead1756f9 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -11,6 +11,9 @@ pub enum AztecMacroError {
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
+    MultipleStorageDefinitions { span: Option<Span> },
+    CouldNotExportStorageLayout { span: Option<Span>, secondary_message: Option<String> },
+    CouldNotExportFunctionAbi { span: Option<Span>, secondary_message: Option<String> },
     EventError { span: Span, message: String },
     UnsupportedAttributes { span: Span, secondary_message: Option<String> },
 }
@@ -46,6 +49,21 @@ impl From<AztecMacroError> for MacroError {
             AztecMacroError::CouldNotImplementNoteInterface { span, secondary_message } => MacroError {
                 primary_message: "Could not implement automatic methods for note, please provide an implementation of the NoteInterface trait".to_string(),
                 secondary_message,
+                span
+            },
+            AztecMacroError::MultipleStorageDefinitions { span } => MacroError {
+                primary_message: "Only one struct can be tagged as #[aztec(storage)]".to_string(),
+                secondary_message: None,
+                span,
+            },
+            AztecMacroError::CouldNotExportStorageLayout { secondary_message, span } => MacroError {
+                primary_message: "Could not generate and export storage layout".to_string(),
+                secondary_message,
+                span,
+            },
+            AztecMacroError::CouldNotExportFunctionAbi { secondary_message, span } => MacroError {
+                primary_message: "Could not generate and export function abi".to_string(),
+                secondary_message,
                 span,
             },
             AztecMacroError::EventError { span, message } => MacroError {
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index f31a0584261..c4414e6419b 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -1,22 +1,43 @@
 use iter_extended::vecmap;
+use noirc_errors::Location;
 use noirc_frontend::{
     graph::CrateId,
-    hir::def_collector::dc_crate::UnresolvedTraitImpl,
-    macros_api::{HirContext, ModuleDefId, StructId},
-    node_interner::{TraitId, TraitImplId},
-    Signedness, Type, UnresolvedTypeData,
+    hir::{
+        def_map::{LocalModuleId, ModuleId},
+        resolution::{path_resolver::StandardPathResolver, resolver::Resolver},
+        type_check::type_check_func,
+    },
+    macros_api::{FileId, HirContext, ModuleDefId, StructId},
+    node_interner::{FuncId, TraitId},
+    ItemVisibility, LetStatement, NoirFunction, Shared, Signedness, StructType, Type,
 };
 
-pub fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<StructId> {
+use super::ast_utils::is_custom_attribute;
+
+pub fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<(String, StructId)> {
     context
         .def_map(crate_id)
         .expect("ICE: Missing crate in def_map")
         .modules()
         .iter()
         .flat_map(|(_, module)| {
-            module.type_definitions().filter_map(|typ| {
+            module.type_definitions().filter_map(move |typ| {
                 if let ModuleDefId::TypeId(struct_id) = typ {
-                    Some(struct_id)
+                    let module_id = struct_id.module_id();
+                    let path =
+                        context.fully_qualified_struct_path(context.root_crate_id(), struct_id);
+                    let path = if path.contains("::") {
+                        let prefix = if &module_id.krate == context.root_crate_id() {
+                            "crate"
+                        } else {
+                            "dep"
+                        };
+                        format!("{}::{}", prefix, path)
+                    } else {
+                        path
+                    };
+
+                    Some((path, struct_id))
                 } else {
                     None
                 }
@@ -25,6 +46,16 @@ pub fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<St
         .collect()
 }
 
+pub fn collect_crate_functions(crate_id: &CrateId, context: &HirContext) -> Vec<FuncId> {
+    context
+        .def_map(crate_id)
+        .expect("ICE: Missing crate in def_map")
+        .modules()
+        .iter()
+        .flat_map(|(_, module)| module.value_definitions().filter_map(|id| id.as_function()))
+        .collect()
+}
+
 pub fn collect_traits(context: &HirContext) -> Vec<TraitId> {
     let crates = context.crates();
     crates
@@ -32,8 +63,8 @@ pub fn collect_traits(context: &HirContext) -> Vec<TraitId> {
         .flatten()
         .flat_map(|module| {
             module.type_definitions().filter_map(|typ| {
-                if let ModuleDefId::TraitId(struct_id) = typ {
-                    Some(struct_id)
+                if let ModuleDefId::TraitId(trait_id) = typ {
+                    Some(trait_id)
                 } else {
                     None
                 }
@@ -69,50 +100,127 @@ pub fn signature_of_type(typ: &Type) -> String {
     }
 }
 
-// Fetches the name of all structs that implement trait_name, both in the current crate and all of its dependencies.
-pub fn fetch_struct_trait_impls(
-    context: &mut HirContext,
-    unresolved_traits_impls: &[UnresolvedTraitImpl],
-    trait_name: &str,
-) -> Vec<String> {
-    let mut struct_typenames: Vec<String> = Vec::new();
-
-    // These structs can be declared in either external crates or the current one. External crates that contain
-    // dependencies have already been processed and resolved, but are available here via the NodeInterner. Note that
-    // crates on which the current crate does not depend on may not have been processed, and will be ignored.
-    for trait_impl_id in 0..context.def_interner.next_trait_impl_id().0 {
-        let trait_impl = &context.def_interner.get_trait_implementation(TraitImplId(trait_impl_id));
-
-        if trait_impl.borrow().ident.0.contents == *trait_name {
-            if let Type::Struct(s, _) = &trait_impl.borrow().typ {
-                struct_typenames.push(s.borrow().name.0.contents.clone());
+// Fetches the name of all structs tagged as #[aztec(note)] in a given crate
+pub fn fetch_crate_notes(
+    context: &HirContext,
+    crate_id: &CrateId,
+) -> Vec<(String, Shared<StructType>)> {
+    collect_crate_structs(crate_id, context)
+        .iter()
+        .filter_map(|(path, struct_id)| {
+            let r#struct = context.def_interner.get_struct(*struct_id);
+            let attributes = context.def_interner.struct_attributes(struct_id);
+            if attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(note)")) {
+                Some((path.clone(), r#struct))
             } else {
-                panic!("Found impl for {} on non-Struct", trait_name);
+                None
             }
-        }
+        })
+        .collect()
+}
+
+// Fetches the name of all structs tagged as #[aztec(note)], both in the current crate and all of its dependencies.
+pub fn fetch_notes(context: &HirContext) -> Vec<(String, Shared<StructType>)> {
+    context.crates().flat_map(|crate_id| fetch_crate_notes(context, &crate_id)).collect()
+}
+
+pub fn get_contract_module_data(
+    context: &mut HirContext,
+    crate_id: &CrateId,
+) -> Option<(LocalModuleId, FileId)> {
+    // We first fetch modules in this crate which correspond to contracts, along with their file id.
+    let contract_module_file_ids: Vec<(LocalModuleId, FileId)> = context
+        .def_map(crate_id)
+        .expect("ICE: Missing crate in def_map")
+        .modules()
+        .iter()
+        .filter(|(_, module)| module.is_contract)
+        .map(|(idx, module)| (LocalModuleId(idx), module.location.file))
+        .collect();
+
+    // If the current crate does not contain a contract module we simply skip it. More than 1 contract in a crate is forbidden by the compiler
+    if contract_module_file_ids.is_empty() {
+        return None;
     }
 
-    // This crate's traits and impls have not yet been resolved, so we look for impls in unresolved_trait_impls.
-    struct_typenames.extend(
-        unresolved_traits_impls
-            .iter()
-            .filter(|trait_impl| {
-                trait_impl
-                    .trait_path
-                    .segments
-                    .last()
-                    .expect("ICE: empty trait_impl path")
-                    .0
-                    .contents
-                    == *trait_name
-            })
-            .filter_map(|trait_impl| match &trait_impl.object_type.typ {
-                UnresolvedTypeData::Named(path, _, _) => {
-                    Some(path.segments.last().unwrap().0.contents.clone())
-                }
-                _ => None,
-            }),
+    Some(contract_module_file_ids[0])
+}
+
+pub fn inject_fn(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+    func: NoirFunction,
+    location: Location,
+    module_id: LocalModuleId,
+    file_id: FileId,
+) {
+    let func_id = context.def_interner.push_empty_fn();
+    context.def_interner.push_function(
+        func_id,
+        &func.def,
+        ModuleId { krate: *crate_id, local_id: module_id },
+        location,
+    );
+
+    context.def_map_mut(crate_id).unwrap().modules_mut()[module_id.0]
+        .declare_function(func.name_ident().clone(), ItemVisibility::Public, func_id)
+        .unwrap_or_else(|_| {
+            panic!(
+                "Failed to declare autogenerated {} function, likely due to a duplicate definition",
+                func.name()
+            )
+        });
+
+    let def_maps = &mut context.def_maps;
+
+    let path_resolver =
+        StandardPathResolver::new(ModuleId { local_id: module_id, krate: *crate_id });
+
+    let resolver = Resolver::new(&mut context.def_interner, &path_resolver, def_maps, file_id);
+
+    let (hir_func, meta, _) = resolver.resolve_function(func, func_id);
+
+    context.def_interner.push_fn_meta(meta, func_id);
+    context.def_interner.update_fn(func_id, hir_func);
+
+    type_check_func(&mut context.def_interner, func_id);
+}
+
+pub fn inject_global(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+    global: LetStatement,
+    module_id: LocalModuleId,
+    file_id: FileId,
+) {
+    let name = global.pattern.name_ident().clone();
+
+    let global_id = context.def_interner.push_empty_global(
+        name.clone(),
+        module_id,
+        file_id,
+        global.attributes.clone(),
     );
 
-    struct_typenames
+    // Add the statement to the scope so its path can be looked up later
+    context.def_map_mut(crate_id).unwrap().modules_mut()[module_id.0]
+        .declare_global(name, global_id)
+        .unwrap_or_else(|(name, _)| {
+            panic!(
+                "Failed to declare autogenerated {} global, likely due to a duplicate definition",
+                name
+            )
+        });
+
+    let def_maps = &mut context.def_maps;
+
+    let path_resolver =
+        StandardPathResolver::new(ModuleId { local_id: module_id, krate: *crate_id });
+
+    let mut resolver = Resolver::new(&mut context.def_interner, &path_resolver, def_maps, file_id);
+
+    let hir_stmt = resolver.resolve_global_let(global, global_id);
+
+    let statement_id = context.def_interner.get_global(global_id).let_statement;
+    context.def_interner.replace_statement(statement_id, hir_stmt);
 }
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 7fafa719186..86f10818dbc 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -2,10 +2,11 @@ use std::collections::BTreeMap;
 
 use acvm::acir::native_types::Witness;
 use iter_extended::{btree_map, vecmap};
-use noirc_abi::{Abi, AbiParameter, AbiReturnType, AbiType};
+use noirc_abi::{Abi, AbiParameter, AbiReturnType, AbiType, AbiValue};
 use noirc_frontend::{
     hir::Context,
-    hir_def::{function::Param, stmt::HirPattern},
+    hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern},
+    macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
     Visibility,
 };
@@ -109,6 +110,60 @@ fn collapse_ranges(witnesses: &[Witness]) -> Vec<Range<Witness>> {
     wit
 }
 
+pub(super) fn value_from_hir_expression(context: &Context, expression: HirExpression) -> AbiValue {
+    match expression {
+        HirExpression::Tuple(expr_ids) => {
+            let fields = expr_ids
+                .iter()
+                .map(|expr_id| {
+                    value_from_hir_expression(context, context.def_interner.expression(expr_id))
+                })
+                .collect();
+            AbiValue::Tuple { fields }
+        }
+        HirExpression::Constructor(constructor) => {
+            let fields = constructor
+                .fields
+                .iter()
+                .map(|(ident, expr_id)| {
+                    (
+                        ident.0.contents.to_string(),
+                        value_from_hir_expression(
+                            context,
+                            context.def_interner.expression(expr_id),
+                        ),
+                    )
+                })
+                .collect();
+            AbiValue::Struct { fields }
+        }
+        HirExpression::Literal(literal) => match literal {
+            HirLiteral::Array(hir_array) => match hir_array {
+                HirArrayLiteral::Standard(expr_ids) => {
+                    let value = expr_ids
+                        .iter()
+                        .map(|expr_id| {
+                            value_from_hir_expression(
+                                context,
+                                context.def_interner.expression(expr_id),
+                            )
+                        })
+                        .collect();
+                    AbiValue::Array { value }
+                }
+                _ => unreachable!("Repeated arrays cannot be used in the abi"),
+            },
+            HirLiteral::Bool(value) => AbiValue::Boolean { value },
+            HirLiteral::Str(value) => AbiValue::String { value },
+            HirLiteral::Integer(field, sign) => {
+                AbiValue::Integer { value: field.to_string(), sign }
+            }
+            _ => unreachable!("Literal cannot be used in the abi"),
+        },
+        _ => unreachable!("Type cannot be used in the abi {:?}", expression),
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::ops::Range;
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index bd78cb23cdc..a33a9b809d3 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -1,14 +1,20 @@
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 
 use acvm::acir::circuit::Program;
 use fm::FileId;
-use noirc_abi::{Abi, ContractEvent};
+use noirc_abi::{Abi, AbiType, AbiValue};
 use noirc_errors::debug_info::DebugInfo;
 use noirc_evaluator::errors::SsaReport;
 
 use super::debug::DebugFile;
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct CompiledContractOutputs {
+    pub structs: HashMap<String, Vec<AbiType>>,
+    pub globals: HashMap<String, Vec<AbiValue>>,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CompiledContract {
     pub noir_version: String,
@@ -19,10 +25,7 @@ pub struct CompiledContract {
     /// stored in this `Vector`.
     pub functions: Vec<ContractFunction>,
 
-    /// All the events defined inside the contract scope.
-    /// An event is a struct value that can be emitted via oracles
-    /// by any contract function during execution.
-    pub events: Vec<ContractEvent>,
+    pub outputs: CompiledContractOutputs,
 
     pub file_map: BTreeMap<FileId, DebugFile>,
     pub warnings: Vec<SsaReport>,
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 8fa2d9680c8..6fe44780484 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -3,11 +3,12 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
+use abi_gen::value_from_hir_expression;
 use acvm::acir::circuit::ExpressionWidth;
 use clap::Args;
 use fm::{FileId, FileManager};
 use iter_extended::vecmap;
-use noirc_abi::{AbiParameter, AbiType, ContractEvent};
+use noirc_abi::{AbiParameter, AbiType, AbiValue};
 use noirc_errors::{CustomDiagnostic, FileDiagnostic};
 use noirc_evaluator::create_program;
 use noirc_evaluator::errors::RuntimeError;
@@ -34,7 +35,7 @@ mod stdlib;
 
 use debug::filter_relevant_files;
 
-pub use contract::{CompiledContract, ContractFunction};
+pub use contract::{CompiledContract, CompiledContractOutputs, ContractFunction};
 pub use debug::DebugFile;
 pub use program::CompiledProgram;
 
@@ -432,18 +433,51 @@ fn compile_contract_inner(
         let debug_infos: Vec<_> = functions.iter().map(|function| function.debug.clone()).collect();
         let file_map = filter_relevant_files(&debug_infos, &context.file_manager);
 
+        let out_structs = contract
+            .outputs
+            .structs
+            .into_iter()
+            .map(|(tag, structs)| {
+                let structs = structs
+                    .into_iter()
+                    .map(|struct_id| {
+                        let typ = context.def_interner.get_struct(struct_id);
+                        let typ = typ.borrow();
+                        let fields = vecmap(typ.get_fields(&[]), |(name, typ)| {
+                            (name, AbiType::from_type(context, &typ))
+                        });
+                        let path =
+                            context.fully_qualified_struct_path(context.root_crate_id(), typ.id);
+                        AbiType::Struct { path, fields }
+                    })
+                    .collect();
+                (tag.to_string(), structs)
+            })
+            .collect();
+
+        let out_globals = contract
+            .outputs
+            .globals
+            .iter()
+            .map(|(tag, globals)| {
+                let globals: Vec<AbiValue> = globals
+                    .iter()
+                    .map(|global_id| {
+                        let let_statement =
+                            context.def_interner.get_global_let_statement(*global_id).unwrap();
+                        let hir_expression =
+                            context.def_interner.expression(&let_statement.expression);
+                        value_from_hir_expression(context, hir_expression)
+                    })
+                    .collect();
+                (tag.to_string(), globals)
+            })
+            .collect();
+
         Ok(CompiledContract {
             name: contract.name,
-            events: contract
-                .events
-                .iter()
-                .map(|event_id| {
-                    let typ = context.def_interner.get_struct(*event_id);
-                    let typ = typ.borrow();
-                    ContractEvent::from_struct_type(context, &typ)
-                })
-                .collect(),
             functions,
+            outputs: CompiledContractOutputs { structs: out_structs, globals: out_globals },
             file_map,
             noir_version: NOIR_ARTIFACT_VERSION_STRING.to_string(),
             warnings,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index bcd62e3b062..53d9e2530cc 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1763,6 +1763,7 @@ impl AcirContext {
         id: u32,
         inputs: Vec<AcirValue>,
         output_count: usize,
+        predicate: AcirVar,
     ) -> Result<Vec<AcirVar>, RuntimeError> {
         let inputs = self.prepare_inputs_for_black_box_func_call(inputs)?;
         let inputs = inputs
@@ -1778,7 +1779,8 @@ impl AcirContext {
         let results =
             vecmap(&outputs, |witness_index| self.add_data(AcirVarData::Witness(*witness_index)));
 
-        self.acir_ir.push_opcode(Opcode::Call { id, inputs, outputs });
+        let predicate = Some(self.var_to_expression(predicate)?);
+        self.acir_ir.push_opcode(Opcode::Call { id, inputs, outputs, predicate });
         Ok(results)
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 9e597dc8e9a..9f2cec5c949 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -579,6 +579,7 @@ impl Context {
                                     *acir_program_id,
                                     inputs,
                                     output_count,
+                                    self.current_side_effects_enabled_var,
                                 )?;
                                 let output_values =
                                     self.convert_vars_to_values(output_vars, dfg, result_ids);
@@ -2716,7 +2717,7 @@ mod test {
         expected_outputs: Vec<Witness>,
     ) {
         match opcode {
-            Opcode::Call { id, inputs, outputs } => {
+            Opcode::Call { id, inputs, outputs, .. } => {
                 assert_eq!(
                     *id, expected_id,
                     "Main was expected to call {expected_id} but got {}",
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index dea9fc0f3d3..753b5a31d32 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -2,6 +2,7 @@ use std::fmt::Display;
 use std::sync::atomic::{AtomicU32, Ordering};
 
 use crate::lexer::token::SpannedToken;
+use crate::macros_api::SecondaryAttribute;
 use crate::parser::{ParserError, ParserErrorReason};
 use crate::token::Token;
 use crate::{
@@ -107,7 +108,7 @@ impl StatementKind {
     pub fn new_let(
         ((pattern, r#type), expression): ((Pattern, UnresolvedType), Expression),
     ) -> StatementKind {
-        StatementKind::Let(LetStatement { pattern, r#type, expression })
+        StatementKind::Let(LetStatement { pattern, r#type, expression, attributes: vec![] })
     }
 
     /// Create a Statement::Assign value, desugaring any combined operators like += if needed.
@@ -405,13 +406,17 @@ pub struct LetStatement {
     pub pattern: Pattern,
     pub r#type: UnresolvedType,
     pub expression: Expression,
+    pub attributes: Vec<SecondaryAttribute>,
 }
 
 impl LetStatement {
     pub fn new_let(
-        ((pattern, r#type), expression): ((Pattern, UnresolvedType), Expression),
+        (((pattern, r#type), expression), attributes): (
+            ((Pattern, UnresolvedType), Expression),
+            Vec<SecondaryAttribute>,
+        ),
     ) -> LetStatement {
-        LetStatement { pattern, r#type, expression }
+        LetStatement { pattern, r#type, expression, attributes }
     }
 }
 
@@ -568,6 +573,7 @@ impl ForRange {
                         pattern: Pattern::Identifier(array_ident.clone()),
                         r#type: UnresolvedType::unspecified(),
                         expression: array,
+                        attributes: vec![],
                     }),
                     span: array_span,
                 };
@@ -610,6 +616,7 @@ impl ForRange {
                         pattern: Pattern::Identifier(identifier),
                         r#type: UnresolvedType::unspecified(),
                         expression: Expression::new(loop_element, array_span),
+                        attributes: vec![],
                     }),
                     span: array_span,
                 };
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 71e0d44b478..67b52071d7b 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -145,6 +145,7 @@ impl DebugInstrumenter {
                         pattern: ast::Pattern::Identifier(ident("__debug_expr", ret_expr.span)),
                         r#type: ast::UnresolvedType::unspecified(),
                         expression: ret_expr.clone(),
+                        attributes: vec![],
                     }),
                     span: ret_expr.span,
                 };
@@ -248,6 +249,7 @@ impl DebugInstrumenter {
                     }),
                     span: let_stmt.expression.span,
                 },
+                attributes: vec![],
             }),
             span: *span,
         }
@@ -273,6 +275,7 @@ impl DebugInstrumenter {
             pattern: ast::Pattern::Identifier(ident("__debug_expr", assign_stmt.expression.span)),
             r#type: ast::UnresolvedType::unspecified(),
             expression: assign_stmt.expression.clone(),
+            attributes: vec![],
         });
         let expression_span = assign_stmt.expression.span;
         let new_assign_stmt = match &assign_stmt.lvalue {
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 90aa4baee7c..463b8a4b329 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -256,20 +256,6 @@ impl DefCollector {
         // Add the current crate to the collection of DefMaps
         context.def_maps.insert(crate_id, def_collector.def_map);
 
-        // TODO(#4653): generalize this function
-        for macro_processor in macro_processors {
-            macro_processor
-                .process_collected_defs(
-                    &crate_id,
-                    context,
-                    &def_collector.collected_traits_impls,
-                    &mut def_collector.collected_functions,
-                )
-                .unwrap_or_else(|(macro_err, file_id)| {
-                    errors.push((macro_err.into(), file_id));
-                });
-        }
-
         inject_prelude(crate_id, context, crate_root, &mut def_collector.collected_imports);
         for submodule in submodules {
             inject_prelude(
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index fcb20c740c7..6fbb3b67546 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -102,8 +102,12 @@ impl<'a> ModCollector<'a> {
         for global in globals {
             let name = global.pattern.name_ident().clone();
 
-            let global_id =
-                context.def_interner.push_empty_global(name.clone(), self.module_id, self.file_id);
+            let global_id = context.def_interner.push_empty_global(
+                name.clone(),
+                self.module_id,
+                self.file_id,
+                global.attributes.clone(),
+            );
 
             // Add the statement to the scope so its path can be looked up later
             let result = self.def_collector.def_map.modules[self.module_id.0]
@@ -455,6 +459,7 @@ impl<'a> ModCollector<'a> {
                             name.clone(),
                             trait_id.0.local_id,
                             self.file_id,
+                            vec![],
                         );
 
                         if let Err((first_def, second_def)) = self.def_collector.def_map.modules
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 157227f763e..7c0090ff95b 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -2,13 +2,13 @@ use crate::graph::CrateId;
 use crate::hir::def_collector::dc_crate::{CompilationError, DefCollector};
 use crate::hir::Context;
 use crate::macros_api::MacroProcessor;
-use crate::node_interner::{FuncId, NodeInterner, StructId};
+use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId};
 use crate::parser::{parse_program, ParsedModule, ParserError};
 use crate::token::{FunctionAttribute, SecondaryAttribute, TestScope};
 use arena::{Arena, Index};
 use fm::{FileId, FileManager};
 use noirc_errors::Location;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 mod module_def;
 pub use module_def::*;
 mod item_scope;
@@ -217,20 +217,37 @@ impl CrateDefMap {
                         })
                         .collect();
 
-                    let events = module
-                        .type_definitions()
-                        .filter_map(|id| {
-                            id.as_type().filter(|struct_id| {
-                                interner
-                                    .struct_attributes(struct_id)
-                                    .iter()
-                                    .any(|attr| attr == &SecondaryAttribute::Event)
-                            })
-                        })
-                        .collect();
+                    let mut outputs =
+                        ContractOutputs { structs: HashMap::new(), globals: HashMap::new() };
+
+                    interner.get_all_globals().iter().for_each(|global_info| {
+                        interner.global_attributes(&global_info.id).iter().for_each(|attr| {
+                            if let SecondaryAttribute::Abi(tag) = attr {
+                                if let Some(tagged) = outputs.globals.get_mut(tag) {
+                                    tagged.push(global_info.id);
+                                } else {
+                                    outputs.globals.insert(tag.to_string(), vec![global_info.id]);
+                                }
+                            }
+                        });
+                    });
+
+                    module.type_definitions().for_each(|id| {
+                        if let ModuleDefId::TypeId(struct_id) = id {
+                            interner.struct_attributes(&struct_id).iter().for_each(|attr| {
+                                if let SecondaryAttribute::Abi(tag) = attr {
+                                    if let Some(tagged) = outputs.structs.get_mut(tag) {
+                                        tagged.push(struct_id);
+                                    } else {
+                                        outputs.structs.insert(tag.to_string(), vec![struct_id]);
+                                    }
+                                }
+                            });
+                        }
+                    });
 
                     let name = self.get_module_path(id, module.parent);
-                    Some(Contract { name, location: module.location, functions, events })
+                    Some(Contract { name, location: module.location, functions, outputs })
                 } else {
                     None
                 }
@@ -283,6 +300,11 @@ pub struct ContractFunctionMeta {
     pub is_entry_point: bool,
 }
 
+pub struct ContractOutputs {
+    pub structs: HashMap<String, Vec<StructId>>,
+    pub globals: HashMap<String, Vec<GlobalId>>,
+}
+
 /// A 'contract' in Noir source code with a given name, functions and events.
 /// This is not an AST node, it is just a convenient form to return for CrateDefMap::get_all_contracts.
 pub struct Contract {
@@ -290,7 +312,7 @@ pub struct Contract {
     pub name: String,
     pub location: Location,
     pub functions: Vec<ContractFunctionMeta>,
-    pub events: Vec<StructId>,
+    pub outputs: ContractOutputs,
 }
 
 /// Given a FileId, fetch the File, from the FileManager and parse it's content
diff --git a/compiler/noirc_frontend/src/hir/mod.rs b/compiler/noirc_frontend/src/hir/mod.rs
index 00bcb0cdebf..727a6596df1 100644
--- a/compiler/noirc_frontend/src/hir/mod.rs
+++ b/compiler/noirc_frontend/src/hir/mod.rs
@@ -26,7 +26,7 @@ pub type ParsedFiles = HashMap<fm::FileId, (ParsedModule, Vec<ParserError>)>;
 pub struct Context<'file_manager, 'parsed_files> {
     pub def_interner: NodeInterner,
     pub crate_graph: CrateGraph,
-    pub(crate) def_maps: BTreeMap<CrateId, CrateDefMap>,
+    pub def_maps: BTreeMap<CrateId, CrateDefMap>,
     // In the WASM context, we take ownership of the file manager,
     // which is why this needs to be a Cow. In all use-cases, the file manager
     // is read-only however, once it has been passed to the Context.
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index d5b0c612f90..71e3f3482fc 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -76,6 +76,8 @@ pub enum ResolverError {
     NestedSlices { span: Span },
     #[error("#[recursive] attribute is only allowed on entry points to a program")]
     MisplacedRecursiveAttribute { ident: Ident },
+    #[error("#[abi(tag)] attribute is only allowed in contracts")]
+    AbiAttributeOusideContract { span: Span },
     #[error("Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library")]
     LowLevelFunctionOutsideOfStdlib { ident: Ident },
     #[error("Dependency cycle found, '{item}' recursively depends on itself: {cycle} ")]
@@ -303,6 +305,13 @@ impl From<ResolverError> for Diagnostic {
                 diag.add_note("The `#[recursive]` attribute specifies to the backend whether it should use a prover which generates proofs that are friendly for recursive verification in another circuit".to_owned());
                 diag
             }
+            ResolverError::AbiAttributeOusideContract { span } => {
+                Diagnostic::simple_error(
+                    "#[abi(tag)] attributes can only be used in contracts".to_string(),
+                    "misplaced #[abi(tag)] attribute".to_string(),
+                    span,
+                )
+            },
             ResolverError::LowLevelFunctionOutsideOfStdlib { ident } => Diagnostic::simple_error(
                 "Definition of low-level function outside of standard library".into(),
                 "Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library".into(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index f2b8212db7a..08b12069d76 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -19,6 +19,7 @@ use crate::hir_def::expr::{
 };
 
 use crate::hir_def::traits::{Trait, TraitConstraint};
+use crate::macros_api::SecondaryAttribute;
 use crate::token::{Attributes, FunctionAttribute};
 use regex::Regex;
 use std::collections::{BTreeMap, HashSet};
@@ -617,7 +618,17 @@ impl<'a> Resolver<'a> {
         match self.lookup_struct_or_error(path) {
             Some(struct_type) => {
                 let expected_generic_count = struct_type.borrow().generics.len();
-
+                if !self.in_contract
+                    && self
+                        .interner
+                        .struct_attributes(&struct_type.borrow().id)
+                        .iter()
+                        .any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
+                {
+                    self.push_err(ResolverError::AbiAttributeOusideContract {
+                        span: struct_type.borrow().name.span(),
+                    });
+                }
                 self.verify_generics_count(expected_generic_count, &mut args, span, || {
                     struct_type.borrow().to_string()
                 });
@@ -1167,10 +1178,19 @@ impl<'a> Resolver<'a> {
         let global_id = self.interner.next_global_id();
         let definition = DefinitionKind::Global(global_id);
 
+        if !self.in_contract
+            && let_stmt.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
+        {
+            self.push_err(ResolverError::AbiAttributeOusideContract {
+                span: let_stmt.pattern.span(),
+            });
+        }
+
         HirStatement::Let(HirLetStatement {
             pattern: self.resolve_pattern(let_stmt.pattern, definition),
             r#type: self.resolve_type(let_stmt.r#type),
             expression,
+            attributes: let_stmt.attributes,
         })
     }
 
@@ -1183,6 +1203,7 @@ impl<'a> Resolver<'a> {
                     pattern: self.resolve_pattern(let_stmt.pattern, definition),
                     r#type: self.resolve_type(let_stmt.r#type),
                     expression,
+                    attributes: let_stmt.attributes,
                 })
             }
             StatementKind::Constrain(constrain_stmt) => {
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 926dac30bcd..cdfc19b3a33 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -504,6 +504,7 @@ mod test {
             pattern: Identifier(z),
             r#type: Type::FieldElement,
             expression: expr_id,
+            attributes: vec![],
         };
         let stmt_id = interner.push_stmt(HirStatement::Let(let_stmt));
         let expr_id = interner
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index c5e287b393c..4c9a33d3dc0 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -1,4 +1,5 @@
 use super::expr::HirIdent;
+use crate::macros_api::SecondaryAttribute;
 use crate::node_interner::ExprId;
 use crate::{Ident, Type};
 use fm::FileId;
@@ -26,6 +27,7 @@ pub struct HirLetStatement {
     pub pattern: HirPattern,
     pub r#type: Type,
     pub expression: ExprId,
+    pub attributes: Vec<SecondaryAttribute>,
 }
 
 impl HirLetStatement {
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index f8378cdd84b..357b1ead593 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -510,6 +510,7 @@ impl Attribute {
                 Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod)
             }
             ["event"] => Attribute::Secondary(SecondaryAttribute::Event),
+            ["abi", tag] => Attribute::Secondary(SecondaryAttribute::Abi(tag.to_string())),
             ["export"] => Attribute::Secondary(SecondaryAttribute::Export),
             ["deprecated", name] => {
                 if !name.starts_with('"') && !name.ends_with('"') {
@@ -604,6 +605,7 @@ pub enum SecondaryAttribute {
     Export,
     Field(String),
     Custom(String),
+    Abi(String),
 }
 
 impl fmt::Display for SecondaryAttribute {
@@ -618,6 +620,7 @@ impl fmt::Display for SecondaryAttribute {
             SecondaryAttribute::Event => write!(f, "#[event]"),
             SecondaryAttribute::Export => write!(f, "#[export]"),
             SecondaryAttribute::Field(ref k) => write!(f, "#[field({k})]"),
+            SecondaryAttribute::Abi(ref k) => write!(f, "#[abi({k})]"),
         }
     }
 }
@@ -640,7 +643,9 @@ impl AsRef<str> for SecondaryAttribute {
         match self {
             SecondaryAttribute::Deprecated(Some(string)) => string,
             SecondaryAttribute::Deprecated(None) => "",
-            SecondaryAttribute::Custom(string) | SecondaryAttribute::Field(string) => string,
+            SecondaryAttribute::Custom(string)
+            | SecondaryAttribute::Field(string)
+            | SecondaryAttribute::Abi(string) => string,
             SecondaryAttribute::ContractLibraryMethod => "",
             SecondaryAttribute::Event | SecondaryAttribute::Export => "",
         }
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 6ce6f4325e4..93d7960faf5 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -45,7 +45,6 @@ pub mod macros_api {
     pub use noirc_errors::Span;
 
     pub use crate::graph::CrateId;
-    use crate::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
     pub use crate::hir::def_collector::errors::MacroError;
     pub use crate::hir_def::expr::{HirExpression, HirLiteral};
     pub use crate::hir_def::stmt::HirStatement;
@@ -76,15 +75,6 @@ pub mod macros_api {
             context: &HirContext,
         ) -> Result<SortedModule, (MacroError, FileId)>;
 
-        // TODO(#4653): generalize this function
-        fn process_collected_defs(
-            &self,
-            _crate_id: &CrateId,
-            _context: &mut HirContext,
-            _collected_trait_impls: &[UnresolvedTraitImpl],
-            _collected_functions: &mut [UnresolvedFunctions],
-        ) -> Result<(), (MacroError, FileId)>;
-
         /// Function to manipulate the AST after type checking has been completed.
         /// The AST after type checking has been done is called the HIR.
         fn process_typed_ast(
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index dcfceccdb57..ffd760d6d7f 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -146,6 +146,7 @@ pub struct NodeInterner {
     // Maps GlobalId -> GlobalInfo
     // NOTE: currently only used for checking repeat globals and restricting their scope to a module
     globals: Vec<GlobalInfo>,
+    global_attributes: HashMap<GlobalId, Vec<SecondaryAttribute>>,
 
     next_type_variable_id: std::cell::Cell<usize>,
 
@@ -480,6 +481,7 @@ impl Default for NodeInterner {
             field_indices: HashMap::new(),
             next_type_variable_id: std::cell::Cell::new(0),
             globals: Vec::new(),
+            global_attributes: HashMap::new(),
             struct_methods: HashMap::new(),
             primitive_methods: HashMap::new(),
             type_alias_ref: Vec::new(),
@@ -647,11 +649,13 @@ impl NodeInterner {
         local_id: LocalModuleId,
         let_statement: StmtId,
         file: FileId,
+        attributes: Vec<SecondaryAttribute>,
     ) -> GlobalId {
         let id = GlobalId(self.globals.len());
         let location = Location::new(ident.span(), file);
         let name = ident.to_string();
         let definition_id = self.push_definition(name, false, DefinitionKind::Global(id), location);
+
         self.globals.push(GlobalInfo {
             id,
             definition_id,
@@ -660,6 +664,7 @@ impl NodeInterner {
             let_statement,
             location,
         });
+        self.global_attributes.insert(id, attributes);
         id
     }
 
@@ -673,9 +678,10 @@ impl NodeInterner {
         name: Ident,
         local_id: LocalModuleId,
         file: FileId,
+        attributes: Vec<SecondaryAttribute>,
     ) -> GlobalId {
         let statement = self.push_stmt(HirStatement::Error);
-        self.push_global(name, local_id, statement, file)
+        self.push_global(name, local_id, statement, file, attributes)
     }
 
     /// Intern an empty function.
@@ -838,6 +844,10 @@ impl NodeInterner {
         &self.struct_attributes[struct_id]
     }
 
+    pub fn global_attributes(&self, global_id: &GlobalId) -> &[SecondaryAttribute] {
+        &self.global_attributes[global_id]
+    }
+
     /// Returns the interned statement corresponding to `stmt_id`
     pub fn statement(&self, stmt_id: &StmtId) -> HirStatement {
         let def =
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index cdfa16400ae..0a21465fe87 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -158,14 +158,17 @@ fn implementation() -> impl NoirParser<TopLevelStatement> {
 
 /// global_declaration: 'global' ident global_type_annotation '=' literal
 fn global_declaration() -> impl NoirParser<TopLevelStatement> {
-    let p = ignore_then_commit(
-        keyword(Keyword::Global).labelled(ParsingRuleLabel::Global),
-        ident().map(Pattern::Identifier),
-    );
+    let p = attributes::attributes()
+        .then_ignore(keyword(Keyword::Global).labelled(ParsingRuleLabel::Global))
+        .then(ident().map(Pattern::Identifier));
     let p = then_commit(p, optional_type_annotation());
     let p = then_commit_ignore(p, just(Token::Assign));
     let p = then_commit(p, expression());
-    p.map(LetStatement::new_let).map(TopLevelStatement::Global)
+    p.validate(|(((attributes, pattern), r#type), expression), span, emit| {
+        let global_attributes = attributes::validate_secondary_attributes(attributes, span, emit);
+        LetStatement { pattern, r#type, expression, attributes: global_attributes }
+    })
+    .map(TopLevelStatement::Global)
 }
 
 /// submodule: 'mod' ident '{' module '}'
diff --git a/compiler/noirc_frontend/src/parser/parser/attributes.rs b/compiler/noirc_frontend/src/parser/parser/attributes.rs
index 4b256a95c8b..47add6f82e0 100644
--- a/compiler/noirc_frontend/src/parser/parser/attributes.rs
+++ b/compiler/noirc_frontend/src/parser/parser/attributes.rs
@@ -2,6 +2,7 @@ use chumsky::Parser;
 use noirc_errors::Span;
 
 use crate::{
+    macros_api::SecondaryAttribute,
     parser::{NoirParser, ParserError, ParserErrorReason},
     token::{Attribute, Attributes, Token, TokenKind},
 };
@@ -44,3 +45,25 @@ pub(super) fn validate_attributes(
 
     Attributes { function: primary, secondary }
 }
+
+pub(super) fn validate_secondary_attributes(
+    attributes: Vec<Attribute>,
+    span: Span,
+    emit: &mut dyn FnMut(ParserError),
+) -> Vec<SecondaryAttribute> {
+    let mut struct_attributes = vec![];
+
+    for attribute in attributes {
+        match attribute {
+            Attribute::Function(..) => {
+                emit(ParserError::with_reason(
+                    ParserErrorReason::NoFunctionAttributesAllowedOnStruct,
+                    span,
+                ));
+            }
+            Attribute::Secondary(attr) => struct_attributes.push(attr),
+        }
+    }
+
+    struct_attributes
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/structs.rs b/compiler/noirc_frontend/src/parser/parser/structs.rs
index 0212f56783f..87e58f69efb 100644
--- a/compiler/noirc_frontend/src/parser/parser/structs.rs
+++ b/compiler/noirc_frontend/src/parser/parser/structs.rs
@@ -1,17 +1,15 @@
 use chumsky::prelude::*;
-use noirc_errors::Span;
 
 use crate::{
-    macros_api::SecondaryAttribute,
     parser::{
         parser::{
-            attributes::attributes,
+            attributes::{attributes, validate_secondary_attributes},
             function, parse_type,
             primitives::{ident, keyword},
         },
-        NoirParser, ParserError, ParserErrorReason, TopLevelStatement,
+        NoirParser, TopLevelStatement,
     },
-    token::{Attribute, Keyword, Token},
+    token::{Keyword, Token},
     Ident, NoirStruct, UnresolvedType,
 };
 
@@ -35,7 +33,7 @@ pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatement> {
         .then(function::generics())
         .then(fields)
         .validate(|(((raw_attributes, name), generics), fields), span, emit| {
-            let attributes = validate_struct_attributes(raw_attributes, span, emit);
+            let attributes = validate_secondary_attributes(raw_attributes, span, emit);
             TopLevelStatement::Struct(NoirStruct { name, attributes, generics, fields, span })
         })
 }
@@ -48,28 +46,6 @@ fn struct_fields() -> impl NoirParser<Vec<(Ident, UnresolvedType)>> {
         .allow_trailing()
 }
 
-fn validate_struct_attributes(
-    attributes: Vec<Attribute>,
-    span: Span,
-    emit: &mut dyn FnMut(ParserError),
-) -> Vec<SecondaryAttribute> {
-    let mut struct_attributes = vec![];
-
-    for attribute in attributes {
-        match attribute {
-            Attribute::Function(..) => {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::NoFunctionAttributesAllowedOnStruct,
-                    span,
-                ));
-            }
-            Attribute::Secondary(attr) => struct_attributes.push(attr),
-        }
-    }
-
-    struct_attributes
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index 9e6fca1126e..de157a1fe20 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -30,11 +30,16 @@ export type DependencyGraph = {
     library_dependencies: Readonly<Record<string, readonly string[]>>;
 }
 
+export type ContractOutputsArtifact = {
+    structs: Record<string, Array<any>>;
+    globals: Record<string, Array<any>>;
+}
+
 export type ContractArtifact = {
     noir_version: string;
     name: string;
     functions: Array<any>;
-    events: Array<any>;
+    outputs: ContractOutputsArtifact;
     file_map: Record<number, any>;
 };
 
@@ -218,7 +223,7 @@ pub fn compile_contract(
         noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
         name: optimized_contract.name,
         functions,
-        events: optimized_contract.events,
+        outputs: optimized_contract.outputs.into(),
         file_map: optimized_contract.file_map,
     };
 
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index d6b382f669f..c187fe7f3de 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -146,7 +146,7 @@ impl CompilerContext {
             noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
             name: optimized_contract.name,
             functions,
-            events: optimized_contract.events,
+            outputs: optimized_contract.outputs.into(),
             file_map: optimized_contract.file_map,
         };
 
diff --git a/compiler/wasm/src/types/noir_artifact.ts b/compiler/wasm/src/types/noir_artifact.ts
index 935c99043da..f241b539dc7 100644
--- a/compiler/wasm/src/types/noir_artifact.ts
+++ b/compiler/wasm/src/types/noir_artifact.ts
@@ -1,35 +1,55 @@
 import { Abi, AbiType } from '@noir-lang/types';
 
 /**
- * A named type.
+ * A basic value.
  */
-export interface ABIVariable {
+export interface BasicValue<T extends string, V> {
   /**
-   * The name of the variable.
-   */
-  name: string;
-  /**
-   * The type of the variable.
+   * The kind of the value.
    */
-  type: AbiType;
+  kind: T;
+  value: V;
 }
 
 /**
- * A contract event.
+ * An exported value.
  */
-export interface EventAbi {
+export type AbiValue =
+  | BasicValue<'boolean', boolean>
+  | BasicValue<'string', string>
+  | BasicValue<'array', AbiValue[]>
+  | TupleValue
+  | IntegerValue
+  | StructValue;
+
+export type TypedStructFieldValue<T> = { name: string; value: T };
+
+export interface StructValue {
+  kind: 'struct';
+  fields: TypedStructFieldValue<AbiValue>[];
+}
+
+export interface TupleValue {
+  kind: 'tuple';
+  fields: AbiValue[];
+}
+
+export interface IntegerValue extends BasicValue<'integer', string> {
+  sign: boolean;
+}
+
+/**
+ * A named type.
+ */
+export interface ABIVariable {
   /**
-   * The event name.
+   * The name of the variable.
    */
   name: string;
   /**
-   * Fully qualified name of the event.
-   */
-  path: string;
-  /**
-   * The fields of the event.
+   * The type of the variable.
    */
-  fields: ABIVariable[];
+  type: AbiType;
 }
 
 /**
@@ -60,8 +80,11 @@ export interface ContractArtifact {
   noir_version: string;
   /** The functions of the contract. */
   functions: NoirFunctionEntry[];
-  /** The events of the contract */
-  events: EventAbi[];
+
+  outputs: {
+    structs: Record<string, AbiType[]>;
+    globals: Record<string, AbiValue[]>;
+  };
   /** The map of file ID to the source code and path of the file. */
   file_map: DebugFileMap;
 }
diff --git a/package.json b/package.json
index 3cffdf4c802..8abaced7bdd 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
     "docs"
   ],
   "scripts": {
-    "build": "yarn workspaces foreach --parallel --topological-dev --verbose run build",
+    "build": "yarn workspaces foreach -vp --topological-dev --exclude \"{docs,@noir-lang/root}\" run build",
     "test": "yarn workspaces foreach --parallel --verbose run test",
     "test:integration": "yarn workspace integration-tests test",
     "clean:workspaces": "yarn workspaces foreach --exclude @noir-lang/root run clean",
diff --git a/test_programs/execution_success/fold_call_witness_condition/Prover.toml b/test_programs/execution_success/fold_call_witness_condition/Prover.toml
index 8481ce25648..a4d6339b661 100644
--- a/test_programs/execution_success/fold_call_witness_condition/Prover.toml
+++ b/test_programs/execution_success/fold_call_witness_condition/Prover.toml
@@ -1,5 +1,3 @@
-# TODO(https://github.com/noir-lang/noir/issues/4707): Change these inputs to fail the assertion in `fn return_value`
-# and change `enable` to false. For now we need the inputs to pass as we do not handle predicates with ACIR calls
-x = "5"
+x = "10"
 y = "10"
-enable = true
\ No newline at end of file
+enable = false
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 52f7783851a..e055d7a3a5f 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.32.0";
+const VERSION: &str = "0.33.0";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index c0316a6d1a2..868fb4404fd 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -1,14 +1,26 @@
 use acvm::acir::circuit::Program;
-use noirc_abi::{Abi, ContractEvent};
-use noirc_driver::{CompiledContract, ContractFunction};
+use noirc_abi::{Abi, AbiType, AbiValue};
+use noirc_driver::{CompiledContract, CompiledContractOutputs, ContractFunction};
 use serde::{Deserialize, Serialize};
 
 use noirc_driver::DebugFile;
 use noirc_errors::debug_info::DebugInfo;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 
 use fm::FileId;
 
+#[derive(Serialize, Deserialize)]
+pub struct ContractOutputsArtifact {
+    pub structs: HashMap<String, Vec<AbiType>>,
+    pub globals: HashMap<String, Vec<AbiValue>>,
+}
+
+impl From<CompiledContractOutputs> for ContractOutputsArtifact {
+    fn from(outputs: CompiledContractOutputs) -> Self {
+        ContractOutputsArtifact { structs: outputs.structs, globals: outputs.globals }
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct ContractArtifact {
     /// Version of noir used to compile this contract
@@ -17,8 +29,8 @@ pub struct ContractArtifact {
     pub name: String,
     /// Each of the contract's functions are compiled into a separate program stored in this `Vec`.
     pub functions: Vec<ContractFunctionArtifact>,
-    /// All the events defined inside the contract scope.
-    pub events: Vec<ContractEvent>,
+
+    pub outputs: ContractOutputsArtifact,
     /// Map of file Id to the source code so locations in debug info can be mapped to source code they point to.
     pub file_map: BTreeMap<FileId, DebugFile>,
 }
@@ -29,7 +41,7 @@ impl From<CompiledContract> for ContractArtifact {
             noir_version: contract.noir_version,
             name: contract.name,
             functions: contract.functions.into_iter().map(ContractFunctionArtifact::from).collect(),
-            events: contract.events,
+            outputs: contract.outputs.into(),
             file_map: contract.file_map,
         }
     }
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 11ef9248853..e592ed440ee 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.32.0",
+    "@aztec/bb.js": "0.33.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index d0dcb373963..89a60b0ed26 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -10,9 +10,7 @@ use acvm::{
 use errors::AbiError;
 use input_parser::InputValue;
 use iter_extended::{try_btree_map, try_vecmap, vecmap};
-use noirc_frontend::{
-    hir::Context, Signedness, StructType, Type, TypeBinding, TypeVariableKind, Visibility,
-};
+use noirc_frontend::{hir::Context, Signedness, Type, TypeBinding, TypeVariableKind, Visibility};
 use serde::{Deserialize, Serialize};
 use std::ops::Range;
 use std::{collections::BTreeMap, str};
@@ -515,31 +513,35 @@ fn decode_string_value(field_elements: &[FieldElement]) -> String {
     final_string.to_owned()
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ContractEvent {
-    /// Event name
-    name: String,
-    /// The fully qualified path to the event definition
-    path: String,
-
-    /// Fields of the event
-    #[serde(
-        serialize_with = "serialization::serialize_struct_fields",
-        deserialize_with = "serialization::deserialize_struct_fields"
-    )]
-    fields: Vec<(String, AbiType)>,
-}
-
-impl ContractEvent {
-    pub fn from_struct_type(context: &Context, struct_type: &StructType) -> Self {
-        let fields = vecmap(struct_type.get_fields(&[]), |(name, typ)| {
-            (name, AbiType::from_type(context, &typ))
-        });
-        // For the ABI, we always want to resolve the struct paths from the root crate
-        let path = context.fully_qualified_struct_path(context.root_crate_id(), struct_type.id);
-
-        Self { name: struct_type.name.0.contents.clone(), path, fields }
-    }
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "lowercase")]
+pub enum AbiValue {
+    Field {
+        value: FieldElement,
+    },
+    Integer {
+        sign: bool,
+        value: String,
+    },
+    Boolean {
+        value: bool,
+    },
+    String {
+        value: String,
+    },
+    Array {
+        value: Vec<AbiValue>,
+    },
+    Struct {
+        #[serde(
+            serialize_with = "serialization::serialize_struct_field_values",
+            deserialize_with = "serialization::deserialize_struct_field_values"
+        )]
+        fields: Vec<(String, AbiValue)>,
+    },
+    Tuple {
+        fields: Vec<AbiValue>,
+    },
 }
 
 fn range_to_vec(ranges: &[Range<Witness>]) -> Vec<Witness> {
diff --git a/tooling/noirc_abi/src/serialization.rs b/tooling/noirc_abi/src/serialization.rs
index ed838803fab..4f91d9b7dfd 100644
--- a/tooling/noirc_abi/src/serialization.rs
+++ b/tooling/noirc_abi/src/serialization.rs
@@ -1,8 +1,7 @@
+use crate::{AbiType, AbiValue};
 use iter_extended::vecmap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::AbiType;
-
 // This module exposes a custom serializer and deserializer for `BTreeMap<String, AbiType>`
 // (representing the fields of a struct) to serialize it as a `Vec<StructField>`.
 //
@@ -41,6 +40,37 @@ where
     Ok(vecmap(fields_vector, |StructField { name, typ }| (name, typ)))
 }
 
+#[derive(Serialize, Deserialize)]
+struct StructFieldValue {
+    name: String,
+    value: AbiValue,
+}
+
+pub(crate) fn serialize_struct_field_values<S>(
+    fields: &[(String, AbiValue)],
+    s: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let fields_vector = vecmap(fields, |(name, value)| StructFieldValue {
+        name: name.to_owned(),
+        value: value.to_owned(),
+    });
+
+    fields_vector.serialize(s)
+}
+
+pub(crate) fn deserialize_struct_field_values<'de, D>(
+    deserializer: D,
+) -> Result<Vec<(String, AbiValue)>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let fields_vector = Vec::<StructFieldValue>::deserialize(deserializer)?;
+    Ok(vecmap(fields_vector, |StructFieldValue { name, value }| (name, value)))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{AbiParameter, AbiType, AbiVisibility, Sign};
diff --git a/tooling/noirc_abi_wasm/build.sh b/tooling/noirc_abi_wasm/build.sh
index fe0b4dcbfff..4486a214c9c 100755
--- a/tooling/noirc_abi_wasm/build.sh
+++ b/tooling/noirc_abi_wasm/build.sh
@@ -14,6 +14,13 @@ function run_or_fail {
     exit $status
   fi
 }
+function run_if_available {
+  if command -v "$1" >/dev/null 2>&1; then
+    "$@"
+  else
+    echo "$1 is not installed. Please install it to use this feature." >&2
+  fi
+}
 
 require_command jq
 require_command cargo
diff --git a/yarn.lock b/yarn.lock
index a39ae9921da..0fdad4ad2ad 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.32.0":
-  version: 0.32.0
-  resolution: "@aztec/bb.js@npm:0.32.0"
+"@aztec/bb.js@npm:0.33.0":
+  version: 0.33.0
+  resolution: "@aztec/bb.js@npm:0.33.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 0919957e141ae0a65cfab961dce122fa06de628a10b7cb661d31d8ed4793ce80980fcf315620ceffffa45581db941bad43c392f4b2aa9becaaf7d2faaba01ffc
+  checksum: 16244a52ef1cb5efca582e863a3521d04f0fb66b02cd584b904e6e65f684e392eec56679439d1a831127e126d117bf0e116166fc4b24efdd6e1ebe9097efed06
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.32.0
+    "@aztec/bb.js": 0.33.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From f14d913768294009c264dfaff364e325f33c6e18 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 11 Apr 2024 16:50:00 +0100
Subject: [PATCH 167/416] chore: create placeholder version of 0.26.0 docs
 (#4782)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR copies the 0.27.0 docs into the 0.26.0 directory so that the
build passes again. I went for this route as for some reason the 0.26.0
commit is not building for me.

cc @noir-lang/developerrelations as there may be changes between these
two versions which won't be reflected in these docs.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 142 +++++
 .../hello_noir/project_breakdown.md           | 199 ++++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 102 ++++
 .../getting_started/tooling/_category_.json   |   6 +
 .../getting_started/tooling/index.mdx         |  38 ++
 .../tooling/language_server.md                |  43 ++
 .../getting_started/tooling/noir_codegen.md   | 113 ++++
 .../getting_started/tooling/testing.md        |  62 ++
 .../version-v0.26.0/how_to/_category_.json    |   5 +
 .../version-v0.26.0/how_to/how-to-oracles.md  | 276 +++++++++
 .../how_to/how-to-recursion.md                | 179 ++++++
 .../how_to/how-to-solidity-verifier.md        | 231 +++++++
 .../version-v0.26.0/how_to/merkle-proof.mdx   |  48 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.26.0/index.mdx |  67 +++
 .../version-v0.26.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.26.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.26.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  77 +++
 .../version-v0.26.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 251 ++++++++
 .../noir/concepts/data_types/booleans.md      |  31 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 155 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 170 ++++++
 .../noir/concepts/data_types/strings.md       |  80 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../version-v0.26.0/noir/concepts/distinct.md |  64 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.26.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.26.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.26.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.26.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.26.0/noir/concepts/oracles.md  |  23 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.26.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  99 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  40 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/bigint.md           | 119 ++++
 .../noir/standard_library/black_box_fns.md    |  31 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 326 ++++++++++
 .../standard_library/containers/hashmap.md    | 569 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 151 +++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  98 +++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../cryptographic_primitives/hashes.mdx       | 331 ++++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/scalar.mdx       |  33 +
 .../cryptographic_primitives/schnorr.mdx      |  64 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  88 +++
 .../noir/standard_library/traits.md           | 408 +++++++++++++
 .../noir/standard_library/zeroed.md           |  26 +
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 119 ++++
 .../NoirJS/backend_barretenberg/index.md      |  58 ++
 .../type-aliases/BackendOptions.md            |  21 +
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  | 132 ++++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +
 .../functions/ecdsa_secp256k1_verify.md       |  28 +
 .../functions/ecdsa_secp256r1_verify.md       |  28 +
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +
 .../NoirJS/noir_js/functions/sha256.md        |  21 +
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +
 .../reference/NoirJS/noir_js/index.md         |  54 ++
 .../type-aliases/ForeignCallHandler.md        |  24 +
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 +
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 +
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 +
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 ++
 .../noir_wasm/functions/compile_contract.md   |  51 ++
 .../noir_wasm/functions/createFileManager.md  |  21 +
 .../functions/inflateDebugSymbols.md          |  21 +
 .../reference/NoirJS/noir_wasm/index.md       |  49 ++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 .../version-v0.26.0/reference/_category_.json |   5 +
 .../reference/nargo_commands.md               | 381 ++++++++++++
 .../version-v0.26.0/tutorials/noirjs_app.md   | 279 +++++++++
 .../version-v0.26.0-sidebars.json             |  83 +++
 108 files changed, 9257 insertions(+)
 create mode 100644 docs/versioned_docs/version-v0.26.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/tooling/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/tooling/noir_codegen.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/getting_started/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/distinct.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/bigint.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/scalar.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.26.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.26.0-sidebars.json

diff --git a/docs/versioned_docs/version-v0.26.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.26.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.26.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.26.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.26.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..743c4d8d634
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/index.md
@@ -0,0 +1,142 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Two additional files would be generated in your project directory:
+
+_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+
+## Prove Our Noir Program
+
+Now that the project is set up, we can create a proof of correct execution of our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Prove the valid execution of your Noir program:
+
+```sh
+nargo prove
+```
+
+A new folder _proofs_ would then be generated in your project directory, containing the proof file
+`<project-name>.proof`, where the project name is defined in Nargo.toml.
+
+The _Verifier.toml_ file would also be updated with the public values computed from program
+execution (in this case the value of `y`):
+
+```toml
+y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+```
+
+> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the
+proof file.
+
+Verify your proof by running:
+
+```sh
+nargo verify
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the
+corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..6160a102c6c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,199 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
+  files, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Verifier.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Verifier.toml
+
+_Verifier.toml_ contains public in/output values computed when executing the Noir program.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
+prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
+verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
+constrained by the proof of the execution of said program (i.e. if the condition was not met, the
+verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
+public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo prove` is executed, two processes happen:
+
+1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
+   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+
+2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove -p OtherProver
+```
+
+## Verifying a Proof
+
+When the command `nargo verify` is executed, two processes happen:
+
+1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
+
+2. If that file is found, the proof's validity is checked
+
+> **Note:** The validity of the proof is linked to the current Noir program; if the program is
+> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
+> _modified_ Noir program.
+
+In production, the prover and the verifier are usually two separate entities. A prover would
+retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
+verifier. The verifier would then retrieve the public inputs, usually from external sources, and
+verify the validity of the proof against it.
+
+Take a private asset transfer as an example:
+
+A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
+public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
+and submit it to the verifier smart contract.
+
+The verifier contract would then draw the user's encrypted balance directly from the blockchain and
+verify the proof submitted against it. If the verification passes, additional functions in the
+verifier contract could trigger (e.g. approve the asset transfer).
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.26.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.26.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.26.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..3634723562b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,102 @@
+---
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/_category_.json b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/_category_.json
new file mode 100644
index 00000000000..55804c03a71
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 2,
+    "label": "Tooling",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx
new file mode 100644
index 00000000000..ac480f3c9f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx
@@ -0,0 +1,38 @@
+---
+title: Tooling
+Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
+---
+
+Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
+
+## Playground
+
+The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
+
+## IDE tools
+
+When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
+
+The easiest way to use these tools is by installing the [Noir VS Code extension](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+## Codespaces
+
+Some Noir repos have leveraged Codespaces in order to ease the development process. You can visit the [noir-starter](https://github.com/noir-lang/noir-starter) for an example.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/codespaces_showcase.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+## GitHub Actions
+
+You can use `noirup` with GitHub Actions for CI/CD and automated testing. It is as simple as
+installing `noirup` and running tests in your GitHub Action `yml` file.
+
+See the
+[config file in the Noir repo](https://github.com/TomAFrench/noir-hashes/blob/master/.github/workflows/noir.yml) for an example usage.
+
+## Community projects
+
+As an open-source project, Noir has received many contributions over time. Some of them are related with developer tooling, and you can see some of them in [Awesome Noir repository](https://github.com/noir-lang/awesome-noir#dev-tools)
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/language_server.md b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/noir_codegen.md b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..d65151da0ab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,113 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 2
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/testing.md b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.26.0/how_to/_category_.json b/docs/versioned_docs/version-v0.26.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.26.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..8cf8035a5c4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/how_to/how-to-oracles.md
@@ -0,0 +1,276 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("getSqrt", async (params) => {
+  const values = params[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+:::tip
+
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
+
+```json
+{ "values": [{ "Array": ["1", "2"] }]}
+{ "values": [{ "Single": "1" }]}
+{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface SingleForeignCallParam {
+  Single: string,
+}
+
+interface ArrayForeignCallParam {
+  Array: string[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.generateProof(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => i.toString("hex")) },
+    ]);
+    return [oracleReturn.values[0].Array];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.26.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.26.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..4c45bb87ae2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/how_to/how-to-recursion.md
@@ -0,0 +1,179 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit, backend)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.26.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.26.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e3c7c1065da
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,231 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo codegen-verifier
+```
+
+A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+
+```
+0x...<proof bytes>... , [0x0000.....02]
+```
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
+Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of
+the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.26.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.26.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..003c7019a93
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+use dep::std;
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.26.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.26.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.26.0/index.mdx b/docs/versioned_docs/version-v0.26.0/index.mdx
new file mode 100644
index 00000000000..75086ddcdde
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.26.0/migration_notes.md b/docs/versioned_docs/version-v0.26.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.26.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..efce3e95d32
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,251 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..69826fcd724
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,31 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
+> `false` in _Verifier.toml_.
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow) and
+[Assert Function](../assert) sections.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..a10a4810788
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..357813c147a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..1c6b375db49
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,155 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo prove
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+use dep::std;
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..828faf4a8f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,170 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+use dep::std::slice;
+
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..311dfd64416
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,80 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging).
+
+```rust
+use dep::std;
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/distinct.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/distinct.md
new file mode 100644
index 00000000000..6c993b8b5e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/distinct.md
@@ -0,0 +1,64 @@
+---
+title: Distinct Witnesses
+sidebar_position: 11
+---
+
+The `distinct` keyword prevents repetitions of witness indices in the program's ABI. This ensures
+that the witnesses being returned as public inputs are all unique.
+
+The `distinct` keyword is only used for return values on program entry points (usually the `main()`
+function).
+
+When using `distinct` and `pub` simultaneously, `distinct` comes first. See the example below.
+
+You can read more about the problem this solves
+[here](https://github.com/noir-lang/noir/issues/1183).
+
+## Example
+
+Without the `distinct` keyword, the following program
+
+```rust
+fn main(x : pub Field, y : pub Field) -> pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    "return_witnesses": [3, 2, 4, 4]
+  }
+}
+```
+
+Whereas (with the `distinct` keyword)
+
+```rust
+fn main(x : pub Field, y : pub Field) -> distinct pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    //...
+    "return_witnesses": [3, 4, 5, 6]
+  }
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..2c9bc33fdfc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../getting_started/tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../getting_started/tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..ddd42bf1f9b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..60425cb8994
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         |                  Types must be integer |
+| >>        |        Right shift an integer by another integer amount        |                  Types must be integer |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..2e6a6818d48
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/oracles.md
@@ -0,0 +1,23 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..ef1445a5907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: dep::some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: dep::some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b8e71fe65f0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md
@@ -0,0 +1,99 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..04c1703d929
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use dep::ecrecover;
+use dep::lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use dep::std::hash::sha256;
+use dep::std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use dep::phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..67a1dafa372
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,40 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── src
+│           └── main.nr
+├── Nargo.toml
+└── Prover.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.26.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..da6a7cdfd81
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/bigint.md
@@ -0,0 +1,119 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L16-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L16-L21</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L20-L28" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L20-L28</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..be8c65679c3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,31 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..ce4529f6e57
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,326 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..91604af765d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,569 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a pedersen hash
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Pedersen>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<PedersenHasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..fcfd7e07aa0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,151 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..d2b42d67b7c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4394b48f907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..c2c0624dfad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..695c7d9406f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,331 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+See sha256_slice for a version that works directly on slices.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::sha256(x);
+}
+```
+
+<BlackBoxInfo />
+
+## sha256_slice
+
+A version of sha256 specialized to slices:
+
+```rust title="sha256_slice" showLineNumbers 
+pub fn sha256_slice(input: [u8]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L16-L18</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+See blake2s_slice for a version that works directly on slices.
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L22-L24" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L22-L24</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake2s_slice
+
+A version of blake2s specialized to slices:
+
+```rust title="blake2s_slice" showLineNumbers 
+pub fn blake2s_slice(input: [u8]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L28-L30</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+See blake3_slice for a version that works directly on slices.
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L34-L36" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L34-L36</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3_slice
+
+A version of blake3 specialized to slices:
+
+```rust title="blake3_slice" showLineNumbers 
+pub fn blake3_slice(input: [u8]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L40-L42" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L40-L42</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+See pedersen_hash_slice for a version that works directly on slices.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L78-L80</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_hash_slice
+
+Given a slice of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash_slice" showLineNumbers 
+pub fn pedersen_hash_slice(input: [Field]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L85-L87" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L85-L87</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+See pedersen_commitment_slice for a version that works directly on slices.
+
+```rust title="pedersen_commitment" showLineNumbers 
+struct PedersenPoint {
+   x : Field,
+   y : Field,
+}
+
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L45-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L45-L52</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment_slice
+
+Given a slice of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment_slice" showLineNumbers 
+pub fn pedersen_commitment_slice(input: [Field]) -> PedersenPoint {
+    pedersen_commitment_with_separator_slice(input, 0)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L56-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L56-L60</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input. See keccak256_slice for a version that works
+directly on slices.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L113-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L113-L115</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L22" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L22</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256_slice
+
+Given a slice of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`).
+
+```rust title="keccak256_slice" showLineNumbers 
+pub fn keccak256_slice(input: [u8], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L119-L121" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L119-L121</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/scalar.mdx b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/scalar.mdx
new file mode 100644
index 00000000000..df411ca5443
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/scalar.mdx
@@ -0,0 +1,33 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplications over a fixed base in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## scalar_mul::fixed_base_embedded_curve
+
+Performs scalar multiplication over the embedded curve whose coordinates are defined by the
+configured noir field. For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+```rust title="fixed_base_embedded_curve" showLineNumbers 
+pub fn fixed_base_embedded_curve(
+    low: Field,
+    high: Field
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/scalar_mul.nr#L27-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/scalar_mul.nr#L27-L32</a></sub></sup>
+
+
+example
+
+```rust
+fn main(x : Field) {
+    let scal = std::scalar_mul::fixed_base_embedded_curve(x);
+    println(scal);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..b59e69c8f07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..a93894043dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md
@@ -0,0 +1,88 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+:::info
+
+This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+
+:::
+
+## Example usage
+
+```rust
+use dep::std;
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..68a9dc3d54b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/traits.md
@@ -0,0 +1,408 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(input: Self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(input: U) -> T {
+      T::from(input)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L102-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L102-L106</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L17-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L17-L21</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L33-L37" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L33-L37</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L49-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L49-L53</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L65-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L65-L69</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L79-L83" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L79-L83</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L95-L99" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L95-L99</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L111-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L111-L115</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L127-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L127-L131</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L142-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L142-L146</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..f450fecdd36
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/zeroed.md
@@ -0,0 +1,26 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..b18c1926b93
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,119 @@
+# BarretenbergBackend
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..c146316a915
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,58 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+## Functions
+
+### publicInputsToWitnessMap()
+
+```ts
+publicInputsToWitnessMap(publicInputs, abi): Backend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `publicInputs` | `string`[] |
+| `abi` | `Abi` |
+
+#### Returns
+
+[`Backend`](index.md#backend)
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..339353b9862
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..45dd62ee57e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,132 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit, backend)
+
+```ts
+new Noir(circuit, backend?): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+| `backend`? | `any` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the underlying backend instance.
+
+#### Example
+
+```typescript
+await noir.destroy();
+```
+
+***
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+### generateProof()
+
+```ts
+generateProof(inputs, foreignCallHandler?): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a witness and a proof given an object as input.
+
+#### Example
+
+```typescript
+async generateProof(input)
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Instantiates the verification key and verifies a proof.
+
+#### Example
+
+```typescript
+async verifyProof(proof)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..cca6b3ace41
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,54 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+***
+
+### ProofData
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..c6d8125eaad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.26.0/reference/_category_.json b/docs/versioned_docs/version-v0.26.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.26.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.26.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..218fcfb0c8c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/reference/nargo_commands.md
@@ -0,0 +1,381 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo backend`↴](#nargo-backend)
+* [`nargo backend current`↴](#nargo-backend-current)
+* [`nargo backend ls`↴](#nargo-backend-ls)
+* [`nargo backend use`↴](#nargo-backend-use)
+* [`nargo backend install`↴](#nargo-backend-install)
+* [`nargo backend uninstall`↴](#nargo-backend-uninstall)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo codegen-verifier`↴](#nargo-codegen-verifier)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo prove`↴](#nargo-prove)
+* [`nargo verify`↴](#nargo-verify)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `backend` — Install and select custom backends used to generate and verify proofs
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `codegen-verifier` — Generates a Solidity verifier smart contract for the program
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `prove` — Create proof for this program. The proof is returned as a hex encoded string
+* `verify` — Given a proof and a program, verify whether the proof is valid
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo backend`
+
+Install and select custom backends used to generate and verify proofs
+
+**Usage:** `nargo backend <COMMAND>`
+
+###### **Subcommands:**
+
+* `current` — Prints the name of the currently active backend
+* `ls` — Prints the list of currently installed backends
+* `use` — Select the backend to use
+* `install` — Install a new backend from a URL
+* `uninstall` — Uninstalls a backend
+
+
+
+## `nargo backend current`
+
+Prints the name of the currently active backend
+
+**Usage:** `nargo backend current`
+
+
+
+## `nargo backend ls`
+
+Prints the list of currently installed backends
+
+**Usage:** `nargo backend ls`
+
+
+
+## `nargo backend use`
+
+Select the backend to use
+
+**Usage:** `nargo backend use <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>`
+
+
+
+## `nargo backend install`
+
+Install a new backend from a URL
+
+**Usage:** `nargo backend install <BACKEND> <URL>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to install
+* `<URL>` — The URL from which to download the backend
+
+
+
+## `nargo backend uninstall`
+
+Uninstalls a backend
+
+**Usage:** `nargo backend uninstall <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to uninstall
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo codegen-verifier`
+
+Generates a Solidity verifier smart contract for the program
+
+**Usage:** `nargo codegen-verifier [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to codegen
+* `--workspace` — Codegen all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo prove`
+
+Create proof for this program. The proof is returned as a hex encoded string
+
+**Usage:** `nargo prove [OPTIONS]`
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--verify` — Verify proof after proving
+* `--package <PACKAGE>` — The name of the package to prove
+* `--workspace` — Prove all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo verify`
+
+Given a proof and a program, verify whether the proof is valid
+
+**Usage:** `nargo verify [OPTIONS]`
+
+###### **Options:**
+
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--package <PACKAGE>` — The name of the package verify
+* `--workspace` — Verify all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..12beb476994
--- /dev/null
+++ b/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
@@ -0,0 +1,279 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.19.x matches `noir_js@0.19.x`, etc.
+
+In this guide, we will be pinned to 0.19.4.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to *anyone* is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```nargo new circuit```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```nargo compile```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+You should see `vite-project` appear in your root folder. This seems like a good time to `cd` into it and install our NoirJS packages:
+
+```bash
+npm i @noir-lang/backend_barretenberg@0.19.4 @noir-lang/noir_js@0.19.4
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It *could* be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import("@noir-lang/noirc_abi").then(module => 
+      module.default(new URL("@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm", import.meta.url).toString())
+    ),
+    import("@noir-lang/acvm_js").then(module => 
+      module.default(new URL("@noir-lang/acvm_js/web/acvm_js_bg.wasm", import.meta.url).toString())
+    )
+  ]);
+}
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch(err) {
+    display("logs", "Oh 💔 Wrong guess")
+  }
+});
+
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit, backend);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const proof = await noir.generateProof(input);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verification = await noir.verifyProof(proof);
+if (verification) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.26.0-sidebars.json b/docs/versioned_sidebars/version-v0.26.0-sidebars.json
new file mode 100644
index 00000000000..b16f79cc176
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.26.0-sidebars.json
@@ -0,0 +1,83 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}

From 90ee4792c8e7115e55a3b1dadd1e43066ad8ac66 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 11 Apr 2024 14:35:48 -0400
Subject: [PATCH 168/416] fix: ArrayGet and Set are not pure (#4783)

# Description

## Problem\*

Resolves #4600

## Summary\*

Array sets and gets are not pure. Listing them as such can cause
constant folding to fold away enabled array gets for ones in disabled
contexts (enable_side_effects_if u1 0). When used in disabled contexts
they will only ever retrieve from index zero.

## Additional Context

No reproduceable test case unfortunately. The ones in #4600 all require
aztec as a dependency and the ones in #4717 only trigger with the
remove_if_else pass added there.

I'm going to add a SSA unit test instead where two array get
instructions should survive constant folding. This PR is a draft until I
add that.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/function_builder/mod.rs           |  6 +++
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  8 ++-
 .../src/ssa/opt/constant_folding.rs           | 51 +++++++++++++++++++
 3 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index d3e5e506111..75a427397b6 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -326,6 +326,12 @@ impl FunctionBuilder {
         self.insert_instruction(Instruction::DecrementRc { value }, None);
     }
 
+    /// Insert an enable_side_effects_if instruction. These are normally only automatically
+    /// inserted during the flattening pass when branching is removed.
+    pub(crate) fn insert_enable_side_effects_if(&mut self, condition: ValueId) {
+        self.insert_instruction(Instruction::EnableSideEffects { condition }, None);
+    }
+
     /// Terminates the current block with the given terminator instruction
     /// if the current block does not already have a terminator instruction.
     fn terminate_block_with(&mut self, terminator: TerminatorInstruction) {
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 2b23cc1c1e8..641d971af3c 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -254,7 +254,7 @@ impl Instruction {
                 // In ACIR, a division with a false predicate outputs (0,0), so it cannot replace another instruction unless they have the same predicate
                 bin.operator != BinaryOp::Div
             }
-            Cast(_, _) | Truncate { .. } | Not(_) | ArrayGet { .. } | ArraySet { .. } => true,
+            Cast(_, _) | Truncate { .. } | Not(_) => true,
 
             // These either have side-effects or interact with memory
             Constrain(..)
@@ -266,6 +266,12 @@ impl Instruction {
             | DecrementRc { .. }
             | RangeCheck { .. } => false,
 
+            // These can have different behavior depending on the EnableSideEffectsIf context.
+            // Enabling constant folding for these potentially enables replacing an enabled
+            // array get with one that was disabled. See
+            // https://github.com/noir-lang/noir/pull/4716#issuecomment-2047846328.
+            ArrayGet { .. } | ArraySet { .. } => false,
+
             Call { func, .. } => match dfg[*func] {
                 Value::Intrinsic(intrinsic) => !intrinsic.has_side_effects(),
                 _ => false,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index 6cac8c91bc3..5a7134f3486 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -607,4 +607,55 @@ mod test {
         assert_eq!(main.dfg[instructions[4]], Instruction::Constrain(v1, v_true, None));
         assert_eq!(main.dfg[instructions[5]], Instruction::Constrain(v2, v_false, None));
     }
+
+    // Regression for #4600
+    #[test]
+    fn array_get_regression() {
+        // fn main f0 {
+        //   b0(v0: u1, v1: u64):
+        //     enable_side_effects_if v0
+        //     v2 = array_get [Field 0, Field 1], index v1
+        //     v3 = not v0
+        //     enable_side_effects_if v3
+        //     v4 = array_get [Field 0, Field 1], index v1
+        // }
+        //
+        // We want to make sure after constant folding both array_gets remain since they are
+        // under different enable_side_effects_if contexts and thus one may be disabled while
+        // the other is not. If one is removed, it is possible e.g. v4 is replaced with v2 which
+        // is disabled (only gets from index 0) and thus returns the wrong result.
+        let main_id = Id::test_new(0);
+
+        // Compiling main
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
+        let v0 = builder.add_parameter(Type::bool());
+        let v1 = builder.add_parameter(Type::unsigned(64));
+
+        builder.insert_enable_side_effects_if(v0);
+
+        let zero = builder.field_constant(0u128);
+        let one = builder.field_constant(1u128);
+
+        let typ = Type::Array(Rc::new(vec![Type::field()]), 2);
+        let array = builder.array_constant(vec![zero, one].into(), typ);
+
+        let _v2 = builder.insert_array_get(array, v1, Type::field());
+        let v3 = builder.insert_not(v0);
+
+        builder.insert_enable_side_effects_if(v3);
+        let _v4 = builder.insert_array_get(array, v1, Type::field());
+
+        // Expected output is unchanged
+        let ssa = builder.finish();
+        let main = ssa.main();
+        let instructions = main.dfg[main.entry_block()].instructions();
+        let starting_instruction_count = instructions.len();
+        assert_eq!(starting_instruction_count, 5);
+
+        let ssa = ssa.fold_constants();
+        let main = ssa.main();
+        let instructions = main.dfg[main.entry_block()].instructions();
+        let ending_instruction_count = instructions.len();
+        assert_eq!(starting_instruction_count, ending_instruction_count);
+    }
 }

From 305bcdcbd01cb84dbaac900f14cb6cf867f83bda Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Fri, 12 Apr 2024 04:46:40 -0400
Subject: [PATCH 169/416] feat: Sync from aztec-packages (#4787)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
fix: avoid huge unrolling in hash_args
(https://github.com/AztecProtocol/aztec-packages/pull/5703)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5697)
feat: Variable length returns
(https://github.com/AztecProtocol/aztec-packages/pull/5633)
feat(simulator): Fetch return values at circuit execution
(https://github.com/AztecProtocol/aztec-packages/pull/5642)
feat: Brillig heterogeneous memory cells
(https://github.com/AztecProtocol/aztec-packages/pull/5608)
chore!: remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
END_COMMIT_OVERRIDE

---------

Co-authored-by: sirasistant <sirasistant@gmail.com>
Co-authored-by: ludamad <adam.domurad@gmail.com>
Co-authored-by: vezenovm <mvezenov@gmail.com>
Co-authored-by: Alvaro Rodriguez <sirasistant@MacBook-Pro-de-Alvaro.local>
---
 .aztec-sync-commit                            |   2 +-
 acvm-repo/acir/codegen/acir.cpp               |  58 +---
 .../opcodes/black_box_function_call.rs        |  11 +-
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |  10 +-
 acvm-repo/acvm/src/pwg/brillig.rs             |   6 +-
 acvm-repo/acvm_js/src/execute.rs              |  56 +++-
 acvm-repo/acvm_js/src/js_witness_map.rs       |  38 ++-
 acvm-repo/acvm_js/src/lib.rs                  |   3 +-
 acvm-repo/acvm_js/src/public_witness.rs       |   9 +-
 acvm-repo/brillig_vm/src/arithmetic.rs        |  68 +++--
 acvm-repo/brillig_vm/src/black_box.rs         |  14 +-
 acvm-repo/brillig_vm/src/lib.rs               |  71 +++--
 acvm-repo/brillig_vm/src/memory.rs            | 234 ++++++++++++---
 aztec_macros/src/transforms/functions.rs      | 277 ++++++++----------
 aztec_macros/src/utils/ast_utils.rs           |  29 +-
 aztec_macros/src/utils/errors.rs              |   6 +
 .../brillig/brillig_gen/brillig_directive.rs  | 152 ++++++----
 .../brillig/brillig_gen/brillig_slice_ops.rs  |   8 +-
 .../src/brillig/brillig_ir/entry_point.rs     |   4 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |   4 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |   6 +-
 .../noirc_evaluator/src/ssa/opt/unrolling.rs  |   5 +-
 tooling/bb_abstraction_leaks/build.rs         |   2 +-
 tooling/debugger/src/context.rs               |   6 +-
 tooling/debugger/src/repl.rs                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 yarn.lock                                     |  10 +-
 27 files changed, 647 insertions(+), 446 deletions(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index ec4c854ef2b..9ebd1dcccac 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-ff28080bcfb946177010960722925973ee19646b
+10d9ad99200a5897417ff5669763ead4e38d87fa
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index e4203b579b0..7cd9fbefba0 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -159,6 +159,7 @@ namespace Program {
 
         struct Keccak256 {
             std::vector<Program::FunctionInput> inputs;
+            Program::FunctionInput var_message_size;
             std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccak256&, const Keccak256&);
@@ -166,16 +167,6 @@ namespace Program {
             static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccak256VariableLength {
-            std::vector<Program::FunctionInput> inputs;
-            Program::FunctionInput var_message_size;
-            std::vector<Program::Witness> outputs;
-
-            friend bool operator==(const Keccak256VariableLength&, const Keccak256VariableLength&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Keccak256VariableLength bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct Keccakf1600 {
             std::vector<Program::FunctionInput> inputs;
             std::vector<Program::Witness> outputs;
@@ -275,7 +266,7 @@ namespace Program {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -2582,6 +2573,7 @@ namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.var_message_size == rhs.var_message_size)) { return false; }
         if (!(lhs.outputs == rhs.outputs)) { return false; }
         return true;
     }
@@ -2607,6 +2599,7 @@ template <>
 template <typename Serializer>
 void serde::Serializable<Program::BlackBoxFuncCall::Keccak256>::serialize(const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.var_message_size)>::serialize(obj.var_message_size, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
@@ -2615,49 +2608,6 @@ template <typename Deserializer>
 Program::BlackBoxFuncCall::Keccak256 serde::Deserializable<Program::BlackBoxFuncCall::Keccak256>::deserialize(Deserializer &deserializer) {
     Program::BlackBoxFuncCall::Keccak256 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const BlackBoxFuncCall::Keccak256VariableLength &lhs, const BlackBoxFuncCall::Keccak256VariableLength &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.var_message_size == rhs.var_message_size)) { return false; }
-        if (!(lhs.outputs == rhs.outputs)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxFuncCall::Keccak256VariableLength::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::Keccak256VariableLength>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxFuncCall::Keccak256VariableLength BlackBoxFuncCall::Keccak256VariableLength::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::Keccak256VariableLength>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxFuncCall::Keccak256VariableLength>::serialize(const Program::BlackBoxFuncCall::Keccak256VariableLength &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.var_message_size)>::serialize(obj.var_message_size, serializer);
-    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxFuncCall::Keccak256VariableLength serde::Deserializable<Program::BlackBoxFuncCall::Keccak256VariableLength>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxFuncCall::Keccak256VariableLength obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.var_message_size = serde::Deserializable<decltype(obj.var_message_size)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index c955e435b37..d9089578739 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -81,10 +81,6 @@ pub enum BlackBoxFuncCall {
         outputs: (Witness, Witness),
     },
     Keccak256 {
-        inputs: Vec<FunctionInput>,
-        outputs: Vec<Witness>,
-    },
-    Keccak256VariableLength {
         inputs: Vec<FunctionInput>,
         /// This is the number of bytes to take
         /// from the input. Note: if `var_message_size`
@@ -183,7 +179,6 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
             BlackBoxFuncCall::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
             BlackBoxFuncCall::Keccak256 { .. } => BlackBoxFunc::Keccak256,
-            BlackBoxFuncCall::Keccak256VariableLength { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
             BlackBoxFuncCall::RecursiveAggregation { .. } => BlackBoxFunc::RecursiveAggregation,
             BlackBoxFuncCall::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
@@ -206,7 +201,6 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::SHA256 { inputs, .. }
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
-            | BlackBoxFuncCall::Keccak256 { inputs, .. }
             | BlackBoxFuncCall::Keccakf1600 { inputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
             | BlackBoxFuncCall::PedersenHash { inputs, .. }
@@ -280,7 +274,7 @@ impl BlackBoxFuncCall {
                 inputs.extend(hashed_message.iter().copied());
                 inputs
             }
-            BlackBoxFuncCall::Keccak256VariableLength { inputs, var_message_size, .. } => {
+            BlackBoxFuncCall::Keccak256 { inputs, var_message_size, .. } => {
                 let mut inputs = inputs.clone();
                 inputs.push(*var_message_size);
                 inputs
@@ -306,9 +300,8 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::SHA256 { outputs, .. }
             | BlackBoxFuncCall::Blake2s { outputs, .. }
             | BlackBoxFuncCall::Blake3 { outputs, .. }
-            | BlackBoxFuncCall::Keccak256 { outputs, .. }
             | BlackBoxFuncCall::Keccakf1600 { outputs, .. }
-            | BlackBoxFuncCall::Keccak256VariableLength { outputs, .. }
+            | BlackBoxFuncCall::Keccak256 { outputs, .. }
             | BlackBoxFuncCall::Poseidon2Permutation { outputs, .. }
             | BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(),
             BlackBoxFuncCall::AND { output, .. }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 6ee926043cd..e7ed402a8eb 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -95,15 +95,7 @@ pub(crate) fn solve(
             blake3,
             bb_func.get_black_box_func(),
         ),
-        BlackBoxFuncCall::Keccak256 { inputs, outputs } => solve_generic_256_hash_opcode(
-            initial_witness,
-            inputs,
-            None,
-            outputs,
-            keccak256,
-            bb_func.get_black_box_func(),
-        ),
-        BlackBoxFuncCall::Keccak256VariableLength { inputs, var_message_size, outputs } => {
+        BlackBoxFuncCall::Keccak256 { inputs, var_message_size, outputs } => {
             solve_generic_256_hash_opcode(
                 initial_witness,
                 inputs,
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index bcf736cd926..81e752d5656 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -206,13 +206,13 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         for output in brillig.outputs.iter() {
             match output {
                 BrilligOutputs::Simple(witness) => {
-                    insert_value(witness, memory[current_ret_data_idx].value, witness_map)?;
+                    insert_value(witness, memory[current_ret_data_idx].to_field(), witness_map)?;
                     current_ret_data_idx += 1;
                 }
                 BrilligOutputs::Array(witness_arr) => {
                     for witness in witness_arr.iter() {
-                        let value = memory[current_ret_data_idx];
-                        insert_value(witness, value.value, witness_map)?;
+                        let value = &memory[current_ret_data_idx];
+                        insert_value(witness, value.to_field(), witness_map)?;
                         current_ret_data_idx += 1;
                     }
                 }
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 0e58ccf039c..c97b8ea1a66 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -13,7 +13,8 @@ use wasm_bindgen::prelude::wasm_bindgen;
 
 use crate::{
     foreign_call::{resolve_brillig, ForeignCallHandler},
-    JsExecutionError, JsWitnessMap, JsWitnessStack,
+    public_witness::extract_indices,
+    JsExecutionError, JsSolvedAndReturnWitness, JsWitnessMap, JsWitnessStack,
 };
 
 #[wasm_bindgen]
@@ -58,6 +59,44 @@ pub async fn execute_circuit(
     Ok(witness_map.into())
 }
 
+/// Executes an ACIR circuit to generate the solved witness from the initial witness.
+/// This method also extracts the public return values from the solved witness into its own return witness.
+///
+/// @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
+/// @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
+/// @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `circuit`..
+/// @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
+/// @returns {SolvedAndReturnWitness} The solved witness calculated by executing the circuit on the provided inputs, as well as the return witness indices as specified by the circuit.
+#[wasm_bindgen(js_name = executeCircuitWithReturnWitness, skip_jsdoc)]
+pub async fn execute_circuit_with_return_witness(
+    solver: &WasmBlackBoxFunctionSolver,
+    program: Vec<u8>,
+    initial_witness: JsWitnessMap,
+    foreign_call_handler: ForeignCallHandler,
+) -> Result<JsSolvedAndReturnWitness, Error> {
+    console_error_panic_hook::set_once();
+
+    let program: Program = Program::deserialize_program(&program)
+    .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
+
+    let mut witness_stack = execute_program_with_native_program_and_return(
+        solver,
+        &program,
+        initial_witness,
+        &foreign_call_handler,
+    )
+    .await?;
+    let solved_witness =
+        witness_stack.pop().expect("Should have at least one witness on the stack").witness;
+
+    let main_circuit = &program.functions[0];
+    let return_witness =
+        extract_indices(&solved_witness, main_circuit.return_values.0.iter().copied().collect())
+            .map_err(|err| JsExecutionError::new(err, None))?;
+
+    Ok((solved_witness, return_witness).into())
+}
+
 /// Executes an ACIR circuit to generate the solved witness from the initial witness.
 ///
 /// @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
@@ -127,6 +166,21 @@ async fn execute_program_with_native_type_return(
     let program: Program = Program::deserialize_program(&program)
     .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
 
+    execute_program_with_native_program_and_return(
+        solver,
+        &program,
+        initial_witness,
+        foreign_call_executor,
+    )
+    .await
+}
+
+async fn execute_program_with_native_program_and_return(
+    solver: &WasmBlackBoxFunctionSolver,
+    program: &Program,
+    initial_witness: JsWitnessMap,
+    foreign_call_executor: &ForeignCallHandler,
+) -> Result<WitnessStack, Error> {
     let executor = ProgramExecutor::new(&program.functions, &solver.0, foreign_call_executor);
     let witness_stack = executor.execute(initial_witness.into()).await?;
 
diff --git a/acvm-repo/acvm_js/src/js_witness_map.rs b/acvm-repo/acvm_js/src/js_witness_map.rs
index 481b8caaa2d..c4482c4a234 100644
--- a/acvm-repo/acvm_js/src/js_witness_map.rs
+++ b/acvm-repo/acvm_js/src/js_witness_map.rs
@@ -2,13 +2,23 @@ use acvm::{
     acir::native_types::{Witness, WitnessMap},
     FieldElement,
 };
-use js_sys::{JsString, Map};
+use js_sys::{JsString, Map, Object};
 use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
 
 #[wasm_bindgen(typescript_custom_section)]
 const WITNESS_MAP: &'static str = r#"
 // Map from witness index to hex string value of witness.
 export type WitnessMap = Map<number, string>;
+
+/**
+ * An execution result containing two witnesses.
+ * 1. The full solved witness of the execution.
+ * 2. The return witness which contains the given public return values within the full witness.
+ */
+export type SolvedAndReturnWitness = {
+    solvedWitness: WitnessMap;
+    returnWitness: WitnessMap;
+}
 "#;
 
 // WitnessMap
@@ -21,6 +31,12 @@ extern "C" {
     #[wasm_bindgen(constructor, js_class = "Map")]
     pub fn new() -> JsWitnessMap;
 
+    #[wasm_bindgen(extends = Object, js_name = "SolvedAndReturnWitness", typescript_type = "SolvedAndReturnWitness")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsSolvedAndReturnWitness;
+
+    #[wasm_bindgen(constructor, js_class = "Object")]
+    pub fn new() -> JsSolvedAndReturnWitness;
 }
 
 impl Default for JsWitnessMap {
@@ -29,6 +45,12 @@ impl Default for JsWitnessMap {
     }
 }
 
+impl Default for JsSolvedAndReturnWitness {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl From<WitnessMap> for JsWitnessMap {
     fn from(witness_map: WitnessMap) -> Self {
         let js_map = JsWitnessMap::new();
@@ -54,6 +76,20 @@ impl From<JsWitnessMap> for WitnessMap {
     }
 }
 
+impl From<(WitnessMap, WitnessMap)> for JsSolvedAndReturnWitness {
+    fn from(witness_maps: (WitnessMap, WitnessMap)) -> Self {
+        let js_solved_witness = JsWitnessMap::from(witness_maps.0);
+        let js_return_witness = JsWitnessMap::from(witness_maps.1);
+
+        let entry_map = Map::new();
+        entry_map.set(&JsValue::from_str("solvedWitness"), &js_solved_witness);
+        entry_map.set(&JsValue::from_str("returnWitness"), &js_return_witness);
+
+        let solved_and_return_witness = Object::from_entries(&entry_map).unwrap();
+        JsSolvedAndReturnWitness { obj: solved_and_return_witness }
+    }
+}
+
 pub(crate) fn js_value_to_field_element(js_value: JsValue) -> Result<FieldElement, JsString> {
     let hex_str = js_value.as_string().ok_or("failed to parse field element from non-string")?;
 
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index d7ecc0ae192..66a4388b132 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -22,9 +22,10 @@ pub use compression::{
 };
 pub use execute::{
     create_black_box_solver, execute_circuit, execute_circuit_with_black_box_solver,
-    execute_program, execute_program_with_black_box_solver,
+    execute_circuit_with_return_witness, execute_program, execute_program_with_black_box_solver,
 };
 pub use js_execution_error::JsExecutionError;
+pub use js_witness_map::JsSolvedAndReturnWitness;
 pub use js_witness_map::JsWitnessMap;
 pub use js_witness_stack::JsWitnessStack;
 pub use logging::init_log_level;
diff --git a/acvm-repo/acvm_js/src/public_witness.rs b/acvm-repo/acvm_js/src/public_witness.rs
index a0d5b5f8be2..4ba054732d4 100644
--- a/acvm-repo/acvm_js/src/public_witness.rs
+++ b/acvm-repo/acvm_js/src/public_witness.rs
@@ -7,7 +7,10 @@ use wasm_bindgen::prelude::wasm_bindgen;
 
 use crate::JsWitnessMap;
 
-fn extract_indices(witness_map: &WitnessMap, indices: Vec<Witness>) -> Result<WitnessMap, String> {
+pub(crate) fn extract_indices(
+    witness_map: &WitnessMap,
+    indices: Vec<Witness>,
+) -> Result<WitnessMap, String> {
     let mut extracted_witness_map = WitnessMap::new();
     for witness in indices {
         let witness_value = witness_map.get(&witness).ok_or(format!(
@@ -44,7 +47,7 @@ pub fn get_return_witness(
     let witness_map = WitnessMap::from(witness_map);
 
     let return_witness =
-        extract_indices(&witness_map, circuit.return_values.0.clone().into_iter().collect())?;
+        extract_indices(&witness_map, circuit.return_values.0.iter().copied().collect())?;
 
     Ok(JsWitnessMap::from(return_witness))
 }
@@ -71,7 +74,7 @@ pub fn get_public_parameters_witness(
     let witness_map = WitnessMap::from(solved_witness);
 
     let public_params_witness =
-        extract_indices(&witness_map, circuit.public_parameters.0.clone().into_iter().collect())?;
+        extract_indices(&witness_map, circuit.public_parameters.0.iter().copied().collect())?;
 
     Ok(JsWitnessMap::from(public_params_witness))
 }
diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
index 3d77982ffb1..2107d10c093 100644
--- a/acvm-repo/brillig_vm/src/arithmetic.rs
+++ b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -1,9 +1,10 @@
 use acir::brillig::{BinaryFieldOp, BinaryIntOp};
 use acir::FieldElement;
 use num_bigint::BigUint;
-use num_traits::{One, ToPrimitive, Zero};
+use num_traits::ToPrimitive;
+use num_traits::{One, Zero};
 
-use crate::memory::MemoryValue;
+use crate::memory::{MemoryTypeError, MemoryValue};
 
 #[derive(Debug, thiserror::Error)]
 pub(crate) enum BrilligArithmeticError {
@@ -11,6 +12,8 @@ pub(crate) enum BrilligArithmeticError {
     MismatchedLhsBitSize { lhs_bit_size: u32, op_bit_size: u32 },
     #[error("Bit size for rhs {rhs_bit_size} does not match op bit size {op_bit_size}")]
     MismatchedRhsBitSize { rhs_bit_size: u32, op_bit_size: u32 },
+    #[error("Integer operation BinaryIntOp::{op:?} is not supported on FieldElement")]
+    IntegerOperationOnField { op: BinaryIntOp },
     #[error("Shift with bit size {op_bit_size} is invalid")]
     InvalidShift { op_bit_size: u32 },
 }
@@ -21,21 +24,19 @@ pub(crate) fn evaluate_binary_field_op(
     lhs: MemoryValue,
     rhs: MemoryValue,
 ) -> Result<MemoryValue, BrilligArithmeticError> {
-    if lhs.bit_size != FieldElement::max_num_bits() {
+    let MemoryValue::Field(a) = lhs else {
         return Err(BrilligArithmeticError::MismatchedLhsBitSize {
-            lhs_bit_size: lhs.bit_size,
+            lhs_bit_size: lhs.bit_size(),
             op_bit_size: FieldElement::max_num_bits(),
         });
-    }
-    if rhs.bit_size != FieldElement::max_num_bits() {
-        return Err(BrilligArithmeticError::MismatchedRhsBitSize {
-            rhs_bit_size: rhs.bit_size,
+    };
+    let MemoryValue::Field(b) = rhs else {
+        return Err(BrilligArithmeticError::MismatchedLhsBitSize {
+            lhs_bit_size: rhs.bit_size(),
             op_bit_size: FieldElement::max_num_bits(),
         });
-    }
+    };
 
-    let a = lhs.value;
-    let b = rhs.value;
     Ok(match op {
         // Perform addition, subtraction, multiplication, and division based on the BinaryOp variant.
         BinaryFieldOp::Add => (a + b).into(),
@@ -62,21 +63,26 @@ pub(crate) fn evaluate_binary_int_op(
     rhs: MemoryValue,
     bit_size: u32,
 ) -> Result<MemoryValue, BrilligArithmeticError> {
-    if lhs.bit_size != bit_size {
-        return Err(BrilligArithmeticError::MismatchedLhsBitSize {
-            lhs_bit_size: lhs.bit_size,
-            op_bit_size: bit_size,
-        });
-    }
-    if rhs.bit_size != bit_size {
-        return Err(BrilligArithmeticError::MismatchedRhsBitSize {
-            rhs_bit_size: rhs.bit_size,
-            op_bit_size: bit_size,
-        });
-    }
+    let lhs = lhs.expect_integer_with_bit_size(bit_size).map_err(|err| match err {
+        MemoryTypeError::MismatchedBitSize { value_bit_size, expected_bit_size } => {
+            BrilligArithmeticError::MismatchedLhsBitSize {
+                lhs_bit_size: value_bit_size,
+                op_bit_size: expected_bit_size,
+            }
+        }
+    })?;
+    let rhs = rhs.expect_integer_with_bit_size(bit_size).map_err(|err| match err {
+        MemoryTypeError::MismatchedBitSize { value_bit_size, expected_bit_size } => {
+            BrilligArithmeticError::MismatchedRhsBitSize {
+                rhs_bit_size: value_bit_size,
+                op_bit_size: expected_bit_size,
+            }
+        }
+    })?;
 
-    let lhs = BigUint::from_bytes_be(&lhs.value.to_be_bytes());
-    let rhs = BigUint::from_bytes_be(&rhs.value.to_be_bytes());
+    if bit_size == FieldElement::max_num_bits() {
+        return Err(BrilligArithmeticError::IntegerOperationOnField { op: *op });
+    }
 
     let bit_modulo = &(BigUint::one() << bit_size);
     let result = match op {
@@ -136,13 +142,11 @@ pub(crate) fn evaluate_binary_int_op(
         }
     };
 
-    let result_as_field = FieldElement::from_be_bytes_reduce(&result.to_bytes_be());
-
     Ok(match op {
         BinaryIntOp::Equals | BinaryIntOp::LessThan | BinaryIntOp::LessThanEquals => {
-            MemoryValue::new(result_as_field, 1)
+            MemoryValue::new_integer(result, 1)
         }
-        _ => MemoryValue::new(result_as_field, bit_size),
+        _ => MemoryValue::new_integer(result, bit_size),
     })
 }
 
@@ -159,13 +163,13 @@ mod tests {
     fn evaluate_u128(op: &BinaryIntOp, a: u128, b: u128, bit_size: u32) -> u128 {
         let result_value = evaluate_binary_int_op(
             op,
-            MemoryValue::new(a.into(), bit_size),
-            MemoryValue::new(b.into(), bit_size),
+            MemoryValue::new_integer(a.into(), bit_size),
+            MemoryValue::new_integer(b.into(), bit_size),
             bit_size,
         )
         .unwrap();
         // Convert back to u128
-        result_value.value.to_u128()
+        result_value.to_field().to_u128()
     }
 
     fn to_negative(a: u128, bit_size: u32) -> u128 {
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index bd33b5ee8fc..73981fb0625 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -20,7 +20,7 @@ fn read_heap_array<'a>(memory: &'a Memory, array: &HeapArray) -> &'a [MemoryValu
 /// Extracts the last byte of every value
 fn to_u8_vec(inputs: &[MemoryValue]) -> Vec<u8> {
     let mut result = Vec::with_capacity(inputs.len());
-    for &input in inputs {
+    for input in inputs {
         result.push(input.try_into().unwrap());
     }
     result
@@ -63,7 +63,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         BlackBoxOp::Keccakf1600 { message, output } => {
             let state_vec: Vec<u64> = read_heap_vector(memory, message)
                 .iter()
-                .map(|&memory_value| memory_value.try_into().unwrap())
+                .map(|memory_value| memory_value.try_into().unwrap())
                 .collect();
             let state: [u64; 25] = state_vec.try_into().unwrap();
 
@@ -151,7 +151,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         }
         BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
             let inputs: Vec<FieldElement> =
-                read_heap_vector(memory, inputs).iter().map(|&x| x.try_into().unwrap()).collect();
+                read_heap_vector(memory, inputs).iter().map(|x| x.try_into().unwrap()).collect();
             let domain_separator: u32 =
                 memory.read(*domain_separator).try_into().map_err(|_| {
                     BlackBoxResolutionError::Failed(
@@ -165,7 +165,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         }
         BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
             let inputs: Vec<FieldElement> =
-                read_heap_vector(memory, inputs).iter().map(|&x| x.try_into().unwrap()).collect();
+                read_heap_vector(memory, inputs).iter().map(|x| x.try_into().unwrap()).collect();
             let domain_separator: u32 =
                 memory.read(*domain_separator).try_into().map_err(|_| {
                     BlackBoxResolutionError::Failed(
@@ -185,7 +185,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         BlackBoxOp::BigIntToLeBytes { .. } => todo!(),
         BlackBoxOp::Poseidon2Permutation { message, output, len } => {
             let input = read_heap_vector(memory, message);
-            let input: Vec<FieldElement> = input.iter().map(|&x| x.try_into().unwrap()).collect();
+            let input: Vec<FieldElement> = input.iter().map(|x| x.try_into().unwrap()).collect();
             let len = memory.read(*len).try_into().unwrap();
             let result = solver.poseidon2_permutation(&input, len)?;
             let mut values = Vec::new();
@@ -204,7 +204,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
                     format!("Expected 16 inputs but encountered {}", &inputs.len()),
                 ));
             }
-            for (i, &input) in inputs.iter().enumerate() {
+            for (i, input) in inputs.iter().enumerate() {
                 message[i] = input.try_into().unwrap();
             }
             let mut state = [0; 8];
@@ -215,7 +215,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
                     format!("Expected 8 values but encountered {}", &values.len()),
                 ));
             }
-            for (i, &value) in values.iter().enumerate() {
+            for (i, value) in values.iter().enumerate() {
                 state[i] = value.try_into().unwrap();
             }
 
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 65654e24720..26d5da67576 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -289,8 +289,8 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 // Convert our source_pointer to an address
                 let source = self.memory.read_ref(*source_pointer);
                 // Use our usize source index to lookup the value in memory
-                let value = &self.memory.read(source);
-                self.memory.write(*destination_address, *value);
+                let value = self.memory.read(source);
+                self.memory.write(*destination_address, value);
                 self.increment_program_counter()
             }
             Opcode::Store { destination_pointer, source: source_address } => {
@@ -307,7 +307,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
             }
             Opcode::Const { destination, value, bit_size } => {
                 // Consts are not checked in runtime to fit in the bit size, since they can safely be checked statically.
-                self.memory.write(*destination, MemoryValue::new(*value, *bit_size));
+                self.memory.write(*destination, MemoryValue::new_from_field(*value, *bit_size));
                 self.increment_program_counter()
             }
             Opcode::BlackBox(black_box_op) => {
@@ -348,7 +348,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     ) -> ForeignCallParam {
         match (input, value_type) {
             (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(_)) => {
-                self.memory.read(value_index).value.into()
+                self.memory.read(value_index).to_field().into()
             }
             (
                 ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
@@ -357,7 +357,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 let start = self.memory.read_ref(pointer_index);
                 self.read_slice_of_values_from_memory(start, size, value_types)
                     .into_iter()
-                    .map(|mem_value| mem_value.value)
+                    .map(|mem_value| mem_value.to_field())
                     .collect::<Vec<_>>()
                     .into()
             }
@@ -369,7 +369,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 let size = self.memory.read(size_index).to_usize();
                 self.read_slice_of_values_from_memory(start, size, value_types)
                     .into_iter()
-                    .map(|mem_value| mem_value.value)
+                    .map(|mem_value| mem_value.to_field())
                     .collect::<Vec<_>>()
                     .into()
             }
@@ -584,12 +584,9 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
 
     /// Casts a value to a different bit size.
     fn cast(&self, bit_size: u32, source_value: MemoryValue) -> MemoryValue {
-        let lhs_big = BigUint::from_bytes_be(&source_value.value.to_be_bytes());
+        let lhs_big = source_value.to_integer();
         let mask = BigUint::from(2_u32).pow(bit_size) - 1_u32;
-        MemoryValue {
-            value: FieldElement::from_be_bytes_reduce(&(lhs_big & mask).to_bytes_be()),
-            bit_size,
-        }
+        MemoryValue::new_from_integer(lhs_big & mask, bit_size)
     }
 }
 
@@ -627,7 +624,7 @@ mod tests {
         let VM { memory, .. } = vm;
         let output_value = memory.read(MemoryAddress::from(0));
 
-        assert_eq!(output_value.value, FieldElement::from(27u128));
+        assert_eq!(output_value.to_field(), FieldElement::from(27u128));
     }
 
     #[test]
@@ -666,7 +663,7 @@ mod tests {
         assert_eq!(status, VMStatus::InProgress);
 
         let output_cmp_value = vm.memory.read(destination);
-        assert_eq!(output_cmp_value.value, true.into());
+        assert_eq!(output_cmp_value.to_field(), true.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -725,7 +722,7 @@ mod tests {
         assert_eq!(status, VMStatus::InProgress);
 
         let output_cmp_value = vm.memory.read(MemoryAddress::from(2));
-        assert_eq!(output_cmp_value.value, false.into());
+        assert_eq!(output_cmp_value.to_field(), false.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -742,7 +739,7 @@ mod tests {
         // The address at index `2` should have not changed as we jumped over the add opcode
         let VM { memory, .. } = vm;
         let output_value = memory.read(MemoryAddress::from(2));
-        assert_eq!(output_value.value, false.into());
+        assert_eq!(output_value.to_field(), false.into());
     }
 
     #[test]
@@ -776,7 +773,7 @@ mod tests {
         let VM { memory, .. } = vm;
 
         let casted_value = memory.read(MemoryAddress::from(1));
-        assert_eq!(casted_value.value, (2_u128.pow(8) - 1).into());
+        assert_eq!(casted_value.to_field(), (2_u128.pow(8) - 1).into());
     }
 
     #[test]
@@ -804,10 +801,10 @@ mod tests {
         let VM { memory, .. } = vm;
 
         let destination_value = memory.read(MemoryAddress::from(2));
-        assert_eq!(destination_value.value, (1u128).into());
+        assert_eq!(destination_value.to_field(), (1u128).into());
 
         let source_value = memory.read(MemoryAddress::from(0));
-        assert_eq!(source_value.value, (1u128).into());
+        assert_eq!(source_value.to_field(), (1u128).into());
     }
 
     #[test]
@@ -869,10 +866,10 @@ mod tests {
         let VM { memory, .. } = vm;
 
         let destination_value = memory.read(MemoryAddress::from(4));
-        assert_eq!(destination_value.value, (3_u128).into());
+        assert_eq!(destination_value.to_field(), (3_u128).into());
 
         let source_value = memory.read(MemoryAddress::from(5));
-        assert_eq!(source_value.value, (2_u128).into());
+        assert_eq!(source_value.to_field(), (2_u128).into());
     }
 
     #[test]
@@ -1120,7 +1117,7 @@ mod tests {
 
             let opcodes = [&start[..], &loop_body[..]].concat();
             let vm = brillig_execute_and_get_vm(memory, &opcodes);
-            vm.memory.read(r_sum).value
+            vm.memory.read(r_sum).to_field()
         }
 
         assert_eq!(
@@ -1359,7 +1356,7 @@ mod tests {
         // Check result in memory
         let result_values = vm.memory.read_slice(MemoryAddress(2), 4).to_vec();
         assert_eq!(
-            result_values.into_iter().map(|mem_value| mem_value.value).collect::<Vec<_>>(),
+            result_values.into_iter().map(|mem_value| mem_value.to_field()).collect::<Vec<_>>(),
             expected_result
         );
 
@@ -1459,7 +1456,7 @@ mod tests {
             .memory
             .read_slice(MemoryAddress(4 + input_string.len()), output_string.len())
             .iter()
-            .map(|mem_val| mem_val.value)
+            .map(|mem_val| mem_val.clone().to_field())
             .collect();
         assert_eq!(result_values, output_string);
 
@@ -1532,13 +1529,21 @@ mod tests {
         assert_eq!(vm.status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         // Check initial memory still in place
-        let initial_values: Vec<_> =
-            vm.memory.read_slice(MemoryAddress(2), 4).iter().map(|mem_val| mem_val.value).collect();
+        let initial_values: Vec<_> = vm
+            .memory
+            .read_slice(MemoryAddress(2), 4)
+            .iter()
+            .map(|mem_val| mem_val.clone().to_field())
+            .collect();
         assert_eq!(initial_values, initial_matrix);
 
         // Check result in memory
-        let result_values: Vec<_> =
-            vm.memory.read_slice(MemoryAddress(6), 4).iter().map(|mem_val| mem_val.value).collect();
+        let result_values: Vec<_> = vm
+            .memory
+            .read_slice(MemoryAddress(6), 4)
+            .iter()
+            .map(|mem_val| mem_val.clone().to_field())
+            .collect();
         assert_eq!(result_values, expected_result);
 
         // Ensure the foreign call counter has been incremented
@@ -1622,8 +1627,12 @@ mod tests {
         assert_eq!(vm.status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         // Check result in memory
-        let result_values: Vec<_> =
-            vm.memory.read_slice(MemoryAddress(0), 4).iter().map(|mem_val| mem_val.value).collect();
+        let result_values: Vec<_> = vm
+            .memory
+            .read_slice(MemoryAddress(0), 4)
+            .iter()
+            .map(|mem_val| mem_val.clone().to_field())
+            .collect();
         assert_eq!(result_values, expected_result);
 
         // Ensure the foreign call counter has been incremented
@@ -1698,7 +1707,7 @@ mod tests {
         .chain(memory.iter().enumerate().map(|(index, mem_value)| Opcode::Cast {
             destination: MemoryAddress(index),
             source: MemoryAddress(index),
-            bit_size: mem_value.bit_size,
+            bit_size: mem_value.bit_size(),
         }))
         .chain(vec![
             // input = 0
@@ -1721,7 +1730,7 @@ mod tests {
         .collect();
 
         let mut vm = brillig_execute_and_get_vm(
-            memory.into_iter().map(|mem_value| mem_value.value).collect(),
+            memory.into_iter().map(|mem_value| mem_value.to_field()).collect(),
             &program,
         );
 
diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index d563e13be2e..feeb3706bde 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -1,11 +1,13 @@
 use acir::{brillig::MemoryAddress, FieldElement};
+use num_bigint::BigUint;
+use num_traits::{One, Zero};
 
 pub const MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct MemoryValue {
-    pub value: FieldElement,
-    pub bit_size: u32,
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum MemoryValue {
+    Field(FieldElement),
+    Integer(BigUint, u32),
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -15,53 +17,147 @@ pub enum MemoryTypeError {
 }
 
 impl MemoryValue {
-    pub fn new(value: FieldElement, bit_size: u32) -> Self {
-        MemoryValue { value, bit_size }
+    /// Builds a memory value from a field element.
+    pub fn new_from_field(value: FieldElement, bit_size: u32) -> Self {
+        if bit_size == FieldElement::max_num_bits() {
+            MemoryValue::new_field(value)
+        } else {
+            MemoryValue::new_integer(BigUint::from_bytes_be(&value.to_be_bytes()), bit_size)
+        }
+    }
+
+    /// Builds a memory value from an integer
+    pub fn new_from_integer(value: BigUint, bit_size: u32) -> Self {
+        if bit_size == FieldElement::max_num_bits() {
+            MemoryValue::new_field(FieldElement::from_be_bytes_reduce(&value.to_bytes_be()))
+        } else {
+            MemoryValue::new_integer(value, bit_size)
+        }
     }
 
+    /// Builds a memory value from a field element, checking that the value is within the bit size.
     pub fn new_checked(value: FieldElement, bit_size: u32) -> Option<Self> {
-        if value.num_bits() > bit_size {
+        if bit_size < FieldElement::max_num_bits() && value.num_bits() > bit_size {
             return None;
         }
 
-        Some(MemoryValue::new(value, bit_size))
+        Some(MemoryValue::new_from_field(value, bit_size))
     }
 
+    /// Builds a field-typed memory value.
     pub fn new_field(value: FieldElement) -> Self {
-        MemoryValue { value, bit_size: FieldElement::max_num_bits() }
+        MemoryValue::Field(value)
+    }
+
+    /// Builds an integer-typed memory value.
+    pub fn new_integer(value: BigUint, bit_size: u32) -> Self {
+        assert!(
+            bit_size != FieldElement::max_num_bits(),
+            "Tried to build a field memory value via new_integer"
+        );
+        MemoryValue::Integer(value, bit_size)
+    }
+
+    /// Extracts the field element from the memory value, if it is typed as field element.
+    pub fn extract_field(&self) -> Option<&FieldElement> {
+        match self {
+            MemoryValue::Field(value) => Some(value),
+            _ => None,
+        }
+    }
+
+    /// Extracts the integer from the memory value, if it is typed as integer.
+    pub fn extract_integer(&self) -> Option<(&BigUint, u32)> {
+        match self {
+            MemoryValue::Integer(value, bit_size) => Some((value, *bit_size)),
+            _ => None,
+        }
+    }
+
+    /// Converts the memory value to a field element, independent of its type.
+    pub fn to_field(&self) -> FieldElement {
+        match self {
+            MemoryValue::Field(value) => *value,
+            MemoryValue::Integer(value, _) => {
+                FieldElement::from_be_bytes_reduce(&value.to_bytes_be())
+            }
+        }
+    }
+
+    /// Converts the memory value to an integer, independent of its type.
+    pub fn to_integer(self) -> BigUint {
+        match self {
+            MemoryValue::Field(value) => BigUint::from_bytes_be(&value.to_be_bytes()),
+            MemoryValue::Integer(value, _) => value,
+        }
+    }
+
+    pub fn bit_size(&self) -> u32 {
+        match self {
+            MemoryValue::Field(_) => FieldElement::max_num_bits(),
+            MemoryValue::Integer(_, bit_size) => *bit_size,
+        }
     }
 
     pub fn to_usize(&self) -> usize {
-        assert!(self.bit_size == MEMORY_ADDRESSING_BIT_SIZE, "value is not typed as brillig usize");
-        self.value.to_u128() as usize
+        assert!(
+            self.bit_size() == MEMORY_ADDRESSING_BIT_SIZE,
+            "value is not typed as brillig usize"
+        );
+        self.extract_integer().unwrap().0.try_into().unwrap()
     }
 
-    pub fn expect_bit_size(&self, expected_bit_size: u32) -> Result<(), MemoryTypeError> {
-        if self.bit_size != expected_bit_size {
-            return Err(MemoryTypeError::MismatchedBitSize {
-                value_bit_size: self.bit_size,
+    pub fn expect_field(&self) -> Result<&FieldElement, MemoryTypeError> {
+        match self {
+            MemoryValue::Integer(_, bit_size) => Err(MemoryTypeError::MismatchedBitSize {
+                value_bit_size: *bit_size,
+                expected_bit_size: FieldElement::max_num_bits(),
+            }),
+            MemoryValue::Field(field) => Ok(field),
+        }
+    }
+
+    pub fn expect_integer_with_bit_size(
+        &self,
+        expected_bit_size: u32,
+    ) -> Result<&BigUint, MemoryTypeError> {
+        match self {
+            MemoryValue::Integer(value, bit_size) => {
+                if *bit_size != expected_bit_size {
+                    return Err(MemoryTypeError::MismatchedBitSize {
+                        value_bit_size: *bit_size,
+                        expected_bit_size,
+                    });
+                }
+                Ok(value)
+            }
+            MemoryValue::Field(_) => Err(MemoryTypeError::MismatchedBitSize {
+                value_bit_size: FieldElement::max_num_bits(),
                 expected_bit_size,
-            });
+            }),
         }
-        Ok(())
     }
 }
 
 impl std::fmt::Display for MemoryValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-        let typ = match self.bit_size {
-            0 => "null".to_string(),
-            1 => "bool".to_string(),
-            _ if self.bit_size == FieldElement::max_num_bits() => "field".to_string(),
-            _ => format!("u{}", self.bit_size),
-        };
-        f.write_str(format!("{}: {}", self.value, typ).as_str())
+        match self {
+            MemoryValue::Field(value) => write!(f, "{}: field", value),
+            MemoryValue::Integer(value, bit_size) => {
+                let typ = match bit_size {
+                    0 => "null".to_string(),
+                    1 => "bool".to_string(),
+                    _ => format!("u{}", bit_size),
+                };
+                write!(f, "{}: {}", value, typ)
+            }
+        }
     }
 }
 
 impl Default for MemoryValue {
     fn default() -> Self {
-        MemoryValue::new(FieldElement::zero(), 0)
+        MemoryValue::new_integer(BigUint::zero(), 0)
     }
 }
 
@@ -73,31 +169,32 @@ impl From<FieldElement> for MemoryValue {
 
 impl From<usize> for MemoryValue {
     fn from(value: usize) -> Self {
-        MemoryValue::new(value.into(), MEMORY_ADDRESSING_BIT_SIZE)
+        MemoryValue::new_integer(value.into(), MEMORY_ADDRESSING_BIT_SIZE)
     }
 }
 
 impl From<u64> for MemoryValue {
     fn from(value: u64) -> Self {
-        MemoryValue::new((value as u128).into(), 64)
+        MemoryValue::new_integer(value.into(), 64)
     }
 }
 
 impl From<u32> for MemoryValue {
     fn from(value: u32) -> Self {
-        MemoryValue::new((value as u128).into(), 32)
+        MemoryValue::new_integer(value.into(), 32)
     }
 }
 
 impl From<u8> for MemoryValue {
     fn from(value: u8) -> Self {
-        MemoryValue::new((value as u128).into(), 8)
+        MemoryValue::new_integer(value.into(), 8)
     }
 }
 
 impl From<bool> for MemoryValue {
     fn from(value: bool) -> Self {
-        MemoryValue::new(value.into(), 1)
+        let value = if value { BigUint::one() } else { BigUint::zero() };
+        MemoryValue::new_integer(value, 1)
     }
 }
 
@@ -105,8 +202,7 @@ impl TryFrom<MemoryValue> for FieldElement {
     type Error = MemoryTypeError;
 
     fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_bit_size(FieldElement::max_num_bits())?;
-        Ok(memory_value.value)
+        memory_value.expect_field().copied()
     }
 }
 
@@ -114,8 +210,7 @@ impl TryFrom<MemoryValue> for u64 {
     type Error = MemoryTypeError;
 
     fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_bit_size(64)?;
-        Ok(memory_value.value.to_u128() as u64)
+        memory_value.expect_integer_with_bit_size(64).map(|value| value.try_into().unwrap())
     }
 }
 
@@ -123,8 +218,7 @@ impl TryFrom<MemoryValue> for u32 {
     type Error = MemoryTypeError;
 
     fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_bit_size(32)?;
-        Ok(memory_value.value.to_u128() as u32)
+        memory_value.expect_integer_with_bit_size(32).map(|value| value.try_into().unwrap())
     }
 }
 
@@ -132,9 +226,7 @@ impl TryFrom<MemoryValue> for u8 {
     type Error = MemoryTypeError;
 
     fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_bit_size(8)?;
-
-        Ok(memory_value.value.to_u128() as u8)
+        memory_value.expect_integer_with_bit_size(8).map(|value| value.try_into().unwrap())
     }
 }
 
@@ -142,11 +234,65 @@ impl TryFrom<MemoryValue> for bool {
     type Error = MemoryTypeError;
 
     fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_bit_size(1)?;
+        let as_integer = memory_value.expect_integer_with_bit_size(1)?;
+
+        if as_integer.is_zero() {
+            Ok(false)
+        } else if as_integer.is_one() {
+            Ok(true)
+        } else {
+            unreachable!("value typed as bool is greater than one")
+        }
+    }
+}
+
+impl TryFrom<&MemoryValue> for FieldElement {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_field().copied()
+    }
+}
+
+impl TryFrom<&MemoryValue> for u64 {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_integer_with_bit_size(64).map(|value| {
+            value.try_into().expect("memory_value has been asserted to contain a 64 bit integer")
+        })
+    }
+}
+
+impl TryFrom<&MemoryValue> for u32 {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_integer_with_bit_size(32).map(|value| {
+            value.try_into().expect("memory_value has been asserted to contain a 32 bit integer")
+        })
+    }
+}
+
+impl TryFrom<&MemoryValue> for u8 {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+        memory_value.expect_integer_with_bit_size(8).map(|value| {
+            value.try_into().expect("memory_value has been asserted to contain an 8 bit integer")
+        })
+    }
+}
+
+impl TryFrom<&MemoryValue> for bool {
+    type Error = MemoryTypeError;
+
+    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+        let as_integer = memory_value.expect_integer_with_bit_size(1)?;
 
-        if memory_value.value == FieldElement::zero() {
+        if as_integer.is_zero() {
             Ok(false)
-        } else if memory_value.value == FieldElement::one() {
+        } else if as_integer.is_one() {
             Ok(true)
         } else {
             unreachable!("value typed as bool is greater than one")
@@ -164,7 +310,7 @@ pub struct Memory {
 impl Memory {
     /// Gets the value at pointer
     pub fn read(&self, ptr: MemoryAddress) -> MemoryValue {
-        self.inner.get(ptr.to_usize()).copied().unwrap_or_default()
+        self.inner.get(ptr.to_usize()).cloned().unwrap_or_default()
     }
 
     pub fn read_ref(&self, ptr: MemoryAddress) -> MemoryAddress {
@@ -191,7 +337,7 @@ impl Memory {
     /// Sets the values after pointer `ptr` to `values`
     pub fn write_slice(&mut self, ptr: MemoryAddress, values: &[MemoryValue]) {
         self.resize_to_fit(ptr.to_usize() + values.len());
-        self.inner[ptr.to_usize()..(ptr.to_usize() + values.len())].copy_from_slice(values);
+        self.inner[ptr.to_usize()..(ptr.to_usize() + values.len())].clone_from_slice(values);
     }
 
     /// Returns the values of the memory
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index a3064ecdd01..534d24289b7 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -11,10 +11,9 @@ use crate::{
     chained_dep, chained_path,
     utils::{
         ast_utils::{
-            assignment, call, cast, expression, ident, ident_path, index_array,
-            index_array_variable, make_eq, make_statement, make_type, member_access, method_call,
-            mutable_assignment, mutable_reference, path, return_type, variable, variable_ident,
-            variable_path,
+            assignment, assignment_with_type, call, cast, expression, ident, ident_path,
+            index_array, make_eq, make_statement, make_type, method_call, mutable_assignment,
+            mutable_reference, path, return_type, variable, variable_ident, variable_path,
         },
         errors::AztecMacroError,
     },
@@ -74,12 +73,12 @@ pub fn transform_function(
 
     // Abstract return types such that they get added to the kernel's return_values
     if !is_avm {
-        if let Some(return_values) = abstract_return_values(func) {
+        if let Some(return_values_statements) = abstract_return_values(func)? {
             // In case we are pushing return values to the context, we remove the statement that originated it
             // This avoids running duplicate code, since blocks like if/else can be value returning statements
             func.def.body.statements.pop();
             // Add the new return statement
-            func.def.body.statements.push(return_values);
+            func.def.body.statements.extend(return_values_statements);
         }
     }
 
@@ -302,6 +301,51 @@ fn create_assert_initializer(ty: &str) -> Statement {
     )))
 }
 
+fn serialize_to_hasher(
+    identifier: &Ident,
+    typ: &UnresolvedTypeData,
+    hasher_name: &str,
+) -> Option<Vec<Statement>> {
+    let mut statements = Vec::new();
+
+    // Match the type to determine the padding to do
+    match typ {
+        // `{hasher_name}.extend_from_array({ident}.serialize())`
+        UnresolvedTypeData::Named(..) => {
+            statements.push(add_struct_to_hasher(identifier, hasher_name));
+        }
+        UnresolvedTypeData::Array(_, arr_type) => {
+            statements.push(add_array_to_hasher(identifier, arr_type, hasher_name));
+        }
+        // `{hasher_name}.push({ident})`
+        UnresolvedTypeData::FieldElement => {
+            statements.push(add_field_to_hasher(identifier, hasher_name));
+        }
+        // Add the integer to the bounded vec, casted to a field
+        // `{hasher_name}.push({ident} as Field)`
+        UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
+            statements.push(add_cast_to_hasher(identifier, hasher_name));
+        }
+        UnresolvedTypeData::String(..) => {
+            let (var_bytes, id) = str_to_bytes(identifier);
+            statements.push(var_bytes);
+            statements.push(add_array_to_hasher(
+                &id,
+                &UnresolvedType {
+                    typ: UnresolvedTypeData::Integer(
+                        Signedness::Unsigned,
+                        noirc_frontend::IntegerBitSize::ThirtyTwo,
+                    ),
+                    span: None,
+                },
+                hasher_name,
+            ))
+        }
+        _ => return None,
+    };
+    Some(statements)
+}
+
 /// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
 /// appended into the args hash object.
 ///
@@ -328,7 +372,7 @@ fn create_assert_initializer(ty: &str) -> Statement {
 /// }
 /// ```
 fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
-    let mut injected_expressions: Vec<Statement> = vec![];
+    let mut injected_statements: Vec<Statement> = vec![];
 
     let hasher_name = "args_hasher";
 
@@ -342,7 +386,7 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
     );
 
     // Completes: `let mut args_hasher = Hasher::new();`
-    injected_expressions.push(let_hasher);
+    injected_statements.push(let_hasher);
 
     // Iterate over each of the function parameters, adding to them to the hasher
     for Param { pattern, typ, span, .. } in params {
@@ -350,44 +394,14 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
             Pattern::Identifier(identifier) => {
                 // Match the type to determine the padding to do
                 let unresolved_type = &typ.typ;
-                let expression = match unresolved_type {
-                    // `hasher.add_multiple({ident}.serialize())`
-                    UnresolvedTypeData::Named(..) => add_struct_to_hasher(identifier, hasher_name),
-                    UnresolvedTypeData::Array(_, arr_type) => {
-                        add_array_to_hasher(identifier, arr_type, hasher_name)
-                    }
-                    // `hasher.add({ident})`
-                    UnresolvedTypeData::FieldElement => {
-                        add_field_to_hasher(identifier, hasher_name)
-                    }
-                    // Add the integer to the hasher, casted to a field
-                    // `hasher.add({ident} as Field)`
-                    UnresolvedTypeData::Integer(..) | UnresolvedTypeData::Bool => {
-                        add_cast_to_hasher(identifier, hasher_name)
-                    }
-                    UnresolvedTypeData::String(..) => {
-                        let (var_bytes, id) = str_to_bytes(identifier);
-                        injected_expressions.push(var_bytes);
-                        add_array_to_hasher(
-                            &id,
-                            &UnresolvedType {
-                                typ: UnresolvedTypeData::Integer(
-                                    Signedness::Unsigned,
-                                    noirc_frontend::IntegerBitSize::ThirtyTwo,
-                                ),
-                                span: None,
-                            },
-                            hasher_name,
-                        )
-                    }
-                    _ => {
-                        return Err(AztecMacroError::UnsupportedFunctionArgumentType {
+                injected_statements.extend(
+                    serialize_to_hasher(identifier, unresolved_type, hasher_name).ok_or_else(
+                        || AztecMacroError::UnsupportedFunctionArgumentType {
                             typ: unresolved_type.clone(),
                             span: *span,
-                        })
-                    }
-                };
-                injected_expressions.push(expression);
+                        },
+                    )?,
+                );
             }
             _ => todo!(), // Maybe unreachable?
         }
@@ -412,10 +426,10 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
             vec![inputs_expression, hash_call],                                        // args
         ),
     );
-    injected_expressions.push(let_context);
+    injected_statements.push(let_context);
 
     // Return all expressions that will be injected by the hasher
-    Ok(injected_expressions)
+    Ok(injected_statements)
 }
 
 /// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
@@ -452,53 +466,86 @@ fn create_context_avm() -> Result<Vec<Statement>, AztecMacroError> {
 
 /// Abstract Return Type
 ///
-/// This function intercepts the function's current return type and replaces it with pushes
-/// To the kernel
+/// This function intercepts the function's current return type and replaces it with pushes to a hasher
+/// that will be used to generate the returns hash for the kernel.
 ///
 /// The replaced code:
 /// ```noir
 /// /// Before
 /// #[aztec(private)]
-/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
-///   // ...
-///   let my_return_value: Field = 10;
-///   context.return_values.push(my_return_value);
-/// }
-///
-/// /// After
-/// #[aztec(private)]
 /// fn foo() -> Field {
 ///     // ...
 ///    let my_return_value: Field = 10;
 ///    my_return_value
 /// }
+///
+/// /// After
+/// #[aztec(private)]
+/// fn foo() -> protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {
+///   // ...
+///   let my_return_value: Field = 10;
+///   let macro__returned__values = my_return_value;
+///   let mut returns_hasher = ArgsHasher::new();
+///   returns_hasher.add(macro__returned__values);
+///   context.set_return_hash(returns_hasher);
+/// }
 /// ```
-/// Similarly; Structs will be pushed to the context, after serialize() is called on them.
-/// Arrays will be iterated over and each element will be pushed to the context.
-/// Any primitive type that can be cast will be casted to a field and pushed to the context.
-fn abstract_return_values(func: &NoirFunction) -> Option<Statement> {
+/// Similarly; Structs will be pushed to the hasher, after serialize() is called on them.
+/// Arrays will be iterated over and each element will be pushed to the hasher.
+/// Any primitive type that can be cast will be casted to a field and pushed to the hasher.
+fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>, AztecMacroError> {
     let current_return_type = func.return_type().typ;
-    let last_statement = func.def.body.statements.last()?;
 
-    // TODO: (length, type) => We can limit the size of the array returned to be limited by kernel size
-    // Doesn't need done until we have settled on a kernel size
+    // Short circuit if the function doesn't return anything
+    match current_return_type {
+        UnresolvedTypeData::Unit | UnresolvedTypeData::Unspecified => return Ok(None),
+        _ => (),
+    }
+
+    let Some(last_statement) = func.def.body.statements.last() else {
+        return Ok(None);
+    };
+
     // TODO: support tuples here and in inputs -> convert into an issue
     // Check if the return type is an expression, if it is, we can handle it
     match last_statement {
         Statement { kind: StatementKind::Expression(expression), .. } => {
-            match current_return_type {
-                // Call serialize on structs, push the whole array, calling push_array
-                UnresolvedTypeData::Named(..) => Some(make_struct_return_type(expression.clone())),
-                UnresolvedTypeData::Array(..) => Some(make_array_return_type(expression.clone())),
-                // Cast these types to a field before pushing
-                UnresolvedTypeData::Bool | UnresolvedTypeData::Integer(..) => {
-                    Some(make_castable_return_type(expression.clone()))
-                }
-                UnresolvedTypeData::FieldElement => Some(make_return_push(expression.clone())),
-                _ => None,
-            }
+            let return_value_name = "macro__returned__values";
+            let hasher_name = "returns_hasher";
+
+            let mut replacement_statements = vec![
+                assignment_with_type(
+                    return_value_name, // Assigned to
+                    current_return_type.clone(),
+                    expression.clone(),
+                ),
+                mutable_assignment(
+                    hasher_name, // Assigned to
+                    call(
+                        variable_path(chained_dep!("aztec", "hash", "ArgsHasher", "new")), // Path
+                        vec![],                                                            // args
+                    ),
+                ),
+            ];
+
+            let serialization_statements =
+                serialize_to_hasher(&ident(return_value_name), &current_return_type, hasher_name)
+                    .ok_or_else(|| AztecMacroError::UnsupportedFunctionReturnType {
+                    typ: current_return_type.clone(),
+                    span: func.return_type().span.unwrap_or_default(),
+                })?;
+
+            replacement_statements.extend(serialization_statements);
+
+            replacement_statements.push(make_statement(StatementKind::Semi(method_call(
+                variable("context"),
+                "set_return_hash",
+                vec![variable(hasher_name)],
+            ))));
+
+            Ok(Some(replacement_statements))
         }
-        _ => None,
+        _ => Ok(None),
     }
 }
 
@@ -547,86 +594,6 @@ fn abstract_storage(typ: &str, unconstrained: bool) -> Statement {
     )
 }
 
-/// Context Return Values
-///
-/// Creates an instance to the context return values
-/// ```noir
-/// `context.return_values`
-/// ```
-fn context_return_values() -> Expression {
-    member_access("context", "return_values")
-}
-
-/// Make return Push
-///
-/// Translates to:
-/// `context.return_values.push({push_value})`
-fn make_return_push(push_value: Expression) -> Statement {
-    make_statement(StatementKind::Semi(method_call(
-        context_return_values(),
-        "push",
-        vec![push_value],
-    )))
-}
-
-/// Make Return push array
-///
-/// Translates to:
-/// `context.return_values.extend_from_array({push_value})`
-fn make_return_extend_from_array(push_value: Expression) -> Statement {
-    make_statement(StatementKind::Semi(method_call(
-        context_return_values(),
-        "extend_from_array",
-        vec![push_value],
-    )))
-}
-
-/// Make struct return type
-///
-/// Translates to:
-/// ```noir
-/// `context.return_values.extend_from_array({push_value}.serialize())`
-fn make_struct_return_type(expression: Expression) -> Statement {
-    let serialized_call = method_call(
-        expression,  // variable
-        "serialize", // method name
-        vec![],      // args
-    );
-    make_return_extend_from_array(serialized_call)
-}
-
-/// Make array return type
-///
-/// Translates to:
-/// ```noir
-/// for i in 0..{ident}.len() {
-///    context.return_values.push({ident}[i] as Field)
-/// }
-/// ```
-fn make_array_return_type(expression: Expression) -> Statement {
-    let inner_cast_expression =
-        cast(index_array_variable(expression.clone(), "i"), UnresolvedTypeData::FieldElement);
-    let assignment = make_statement(StatementKind::Semi(method_call(
-        context_return_values(), // variable
-        "push",                  // method name
-        vec![inner_cast_expression],
-    )));
-
-    create_loop_over(expression, vec![assignment])
-}
-
-/// Castable return type
-///
-/// Translates to:
-/// ```noir
-/// context.return_values.push({ident} as Field)
-/// ```
-fn make_castable_return_type(expression: Expression) -> Statement {
-    // Cast these types to a field before pushing
-    let cast_expression = cast(expression, UnresolvedTypeData::FieldElement);
-    make_return_push(cast_expression)
-}
-
 /// Create Return Type
 ///
 /// Public functions return protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs while
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index eb8f5a4156d..1731dfab49c 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -2,9 +2,8 @@ use noirc_errors::{Span, Spanned};
 use noirc_frontend::{
     token::SecondaryAttribute, BinaryOpKind, CallExpression, CastExpression, Expression,
     ExpressionKind, FunctionReturnType, Ident, IndexExpression, InfixExpression, Lambda,
-    LetStatement, MemberAccessExpression, MethodCallExpression, NoirTraitImpl, Path, Pattern,
-    PrefixExpression, Statement, StatementKind, TraitImplItem, UnaryOp, UnresolvedType,
-    UnresolvedTypeData,
+    LetStatement, MethodCallExpression, NoirTraitImpl, Path, Pattern, PrefixExpression, Statement,
+    StatementKind, TraitImplItem, UnaryOp, UnresolvedType, UnresolvedTypeData,
 };
 
 //
@@ -79,21 +78,22 @@ pub fn mutable_reference(variable_name: &str) -> Expression {
 }
 
 pub fn assignment(name: &str, assigned_to: Expression) -> Statement {
+    assignment_with_type(name, UnresolvedTypeData::Unspecified, assigned_to)
+}
+
+pub fn assignment_with_type(
+    name: &str,
+    typ: UnresolvedTypeData,
+    assigned_to: Expression,
+) -> Statement {
     make_statement(StatementKind::Let(LetStatement {
         pattern: pattern(name),
-        r#type: make_type(UnresolvedTypeData::Unspecified),
+        r#type: make_type(typ),
         expression: assigned_to,
         attributes: vec![],
     }))
 }
 
-pub fn member_access(lhs: &str, rhs: &str) -> Expression {
-    expression(ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
-        lhs: variable(lhs),
-        rhs: ident(rhs),
-    })))
-}
-
 pub fn return_type(path: Path) -> FunctionReturnType {
     let ty = make_type(UnresolvedTypeData::Named(path, vec![], true));
     FunctionReturnType::Ty(ty)
@@ -169,13 +169,6 @@ pub fn index_array(array: Ident, index: &str) -> Expression {
     })))
 }
 
-pub fn index_array_variable(array: Expression, index: &str) -> Expression {
-    expression(ExpressionKind::Index(Box::new(IndexExpression {
-        collection: array,
-        index: variable(index),
-    })))
-}
-
 pub fn check_trait_method_implemented(trait_impl: &NoirTraitImpl, method_name: &str) -> bool {
     trait_impl.items.iter().any(|item| match item {
         TraitImplItem::Function(func) => func.def.name.0.contents == method_name,
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 9aead1756f9..5d3a61a51dc 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -8,6 +8,7 @@ pub enum AztecMacroError {
     AztecDepNotFound,
     ContractHasTooManyPrivateFunctions { span: Span },
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
+    UnsupportedFunctionReturnType { span: Span, typ: UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
@@ -36,6 +37,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: Some(span),
             },
+            AztecMacroError::UnsupportedFunctionReturnType { span, typ } => MacroError {
+                primary_message: format!("Provided return type `{typ:?}` is not supported in Aztec contract interface"),
+                secondary_message: None,
+                span: Some(span),
+            },
             AztecMacroError::UnsupportedStorageType { span, typ } => MacroError {
                 primary_message: format!("Provided storage type `{typ:?}` is not directly supported in Aztec. Please provide a custom storage implementation"),
                 secondary_message: None,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
index 15a2a531e78..4b97a61491d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
@@ -67,61 +67,105 @@ pub(crate) fn directive_invert() -> GeneratedBrillig {
 ///    (a/b, a-a/b*b)
 /// }
 /// ```
-pub(crate) fn directive_quotient(mut bit_size: u32) -> GeneratedBrillig {
+pub(crate) fn directive_quotient(bit_size: u32) -> GeneratedBrillig {
     // `a` is (0) (i.e register index 0)
     // `b` is (1)
-    if bit_size > FieldElement::max_num_bits() {
-        bit_size = FieldElement::max_num_bits();
-    }
-    GeneratedBrillig {
-        byte_code: vec![
-            BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress::from(0),
-                size: 2,
-                offset: 0,
-            },
-            BrilligOpcode::Cast {
-                destination: MemoryAddress(0),
-                source: MemoryAddress(0),
-                bit_size,
-            },
-            BrilligOpcode::Cast {
-                destination: MemoryAddress(1),
-                source: MemoryAddress(1),
-                bit_size,
-            },
-            //q = a/b is set into register (2)
-            BrilligOpcode::BinaryIntOp {
-                op: BinaryIntOp::Div,
-                lhs: MemoryAddress::from(0),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(2),
-                bit_size,
-            },
-            //(1)= q*b
-            BrilligOpcode::BinaryIntOp {
-                op: BinaryIntOp::Mul,
-                lhs: MemoryAddress::from(2),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(1),
-                bit_size,
-            },
-            //(1) = a-q*b
-            BrilligOpcode::BinaryIntOp {
-                op: BinaryIntOp::Sub,
-                lhs: MemoryAddress::from(0),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(1),
-                bit_size,
-            },
-            //(0) = q
-            BrilligOpcode::Mov {
-                destination: MemoryAddress::from(0),
-                source: MemoryAddress::from(2),
-            },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 2 },
-        ],
-        assert_messages: Default::default(),
-        locations: Default::default(),
+
+    // TODO: The only difference between these implementations is the integer version will truncate the input to the `bit_size` via cast.
+    // Once we deduplicate brillig functions then we can modify this so that fields and integers share the same quotient function.
+    if bit_size >= FieldElement::max_num_bits() {
+        // Field version
+        GeneratedBrillig {
+            byte_code: vec![
+                BrilligOpcode::CalldataCopy {
+                    destination_address: MemoryAddress::from(0),
+                    size: 2,
+                    offset: 0,
+                },
+                // No cast, since calldata is typed as field by default
+                //q = a/b is set into register (2)
+                BrilligOpcode::BinaryFieldOp {
+                    op: BinaryFieldOp::IntegerDiv, // We want integer division, not field division!
+                    lhs: MemoryAddress::from(0),
+                    rhs: MemoryAddress::from(1),
+                    destination: MemoryAddress::from(2),
+                },
+                //(1)= q*b
+                BrilligOpcode::BinaryFieldOp {
+                    op: BinaryFieldOp::Mul,
+                    lhs: MemoryAddress::from(2),
+                    rhs: MemoryAddress::from(1),
+                    destination: MemoryAddress::from(1),
+                },
+                //(1) = a-q*b
+                BrilligOpcode::BinaryFieldOp {
+                    op: BinaryFieldOp::Sub,
+                    lhs: MemoryAddress::from(0),
+                    rhs: MemoryAddress::from(1),
+                    destination: MemoryAddress::from(1),
+                },
+                //(0) = q
+                BrilligOpcode::Mov {
+                    destination: MemoryAddress::from(0),
+                    source: MemoryAddress::from(2),
+                },
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 2 },
+            ],
+            assert_messages: Default::default(),
+            locations: Default::default(),
+        }
+    } else {
+        // Integer version
+        GeneratedBrillig {
+            byte_code: vec![
+                BrilligOpcode::CalldataCopy {
+                    destination_address: MemoryAddress::from(0),
+                    size: 2,
+                    offset: 0,
+                },
+                BrilligOpcode::Cast {
+                    destination: MemoryAddress(0),
+                    source: MemoryAddress(0),
+                    bit_size,
+                },
+                BrilligOpcode::Cast {
+                    destination: MemoryAddress(1),
+                    source: MemoryAddress(1),
+                    bit_size,
+                },
+                //q = a/b is set into register (2)
+                BrilligOpcode::BinaryIntOp {
+                    op: BinaryIntOp::Div,
+                    lhs: MemoryAddress::from(0),
+                    rhs: MemoryAddress::from(1),
+                    destination: MemoryAddress::from(2),
+                    bit_size,
+                },
+                //(1)= q*b
+                BrilligOpcode::BinaryIntOp {
+                    op: BinaryIntOp::Mul,
+                    lhs: MemoryAddress::from(2),
+                    rhs: MemoryAddress::from(1),
+                    destination: MemoryAddress::from(1),
+                    bit_size,
+                },
+                //(1) = a-q*b
+                BrilligOpcode::BinaryIntOp {
+                    op: BinaryIntOp::Sub,
+                    lhs: MemoryAddress::from(0),
+                    rhs: MemoryAddress::from(1),
+                    destination: MemoryAddress::from(1),
+                    bit_size,
+                },
+                //(0) = q
+                BrilligOpcode::Mov {
+                    destination: MemoryAddress::from(0),
+                    source: MemoryAddress::from(2),
+                },
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 2 },
+            ],
+            assert_messages: Default::default(),
+            locations: Default::default(),
+        }
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index b93693d9c79..3e1515b1eed 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -465,7 +465,7 @@ mod tests {
             assert_eq!(
                 vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
                     .iter()
-                    .map(|mem_val| mem_val.value)
+                    .map(|mem_val| mem_val.to_field())
                     .collect::<Vec<_>>(),
                 expected_return
             );
@@ -590,7 +590,7 @@ mod tests {
             assert_eq!(
                 vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
                     .iter()
-                    .map(|mem_val| mem_val.value)
+                    .map(|mem_val| mem_val.to_field())
                     .collect::<Vec<_>>(),
                 expected_return
             );
@@ -686,7 +686,7 @@ mod tests {
             assert_eq!(
                 vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
                     .iter()
-                    .map(|mem_val| mem_val.value)
+                    .map(|mem_val| mem_val.to_field())
                     .collect::<Vec<_>>(),
                 expected_return
             );
@@ -838,7 +838,7 @@ mod tests {
             assert_eq!(
                 vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
                     .iter()
-                    .map(|mem_val| mem_val.value)
+                    .map(|mem_val| mem_val.to_field())
                     .collect::<Vec<_>>(),
                 expected_return
             );
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index db872487fcc..fe3c5e0bb9c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -527,7 +527,7 @@ mod tests {
         let (vm, return_data_offset, return_data_size) =
             create_and_run_vm(calldata.clone(), &bytecode);
         assert_eq!(return_data_size, 1, "Return data size is incorrect");
-        assert_eq!(vm.get_memory()[return_data_offset].value, FieldElement::from(1_usize));
+        assert_eq!(vm.get_memory()[return_data_offset].to_field(), FieldElement::from(1_usize));
     }
 
     #[test]
@@ -569,7 +569,7 @@ mod tests {
         assert_eq!(
             memory[return_data_pointer..(return_data_pointer + flattened_array.len())]
                 .iter()
-                .map(|mem_val| mem_val.value)
+                .map(|mem_val| mem_val.to_field())
                 .collect::<Vec<_>>(),
             flattened_array
         );
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 53d9e2530cc..775571f4a41 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1623,7 +1623,7 @@ impl AcirContext {
         let outputs_var = vecmap(outputs_types.iter(), |output| match output {
             AcirType::NumericType(_) => {
                 let var = self.add_data(AcirVarData::Const(
-                    memory.next().expect("Missing return data").value,
+                    memory.next().expect("Missing return data").to_field(),
                 ));
                 AcirValue::Var(var, output.clone())
             }
@@ -1657,7 +1657,7 @@ impl AcirContext {
                     AcirType::NumericType(_) => {
                         let memory_value =
                             memory_iter.next().expect("ICE: Unexpected end of memory");
-                        let var = self.add_data(AcirVarData::Const(memory_value.value));
+                        let var = self.add_data(AcirVarData::Const(memory_value.to_field()));
                         array_values.push_back(AcirValue::Var(var, element_type.clone()));
                     }
                 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index b43110b2f5b..ba4e03bff95 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -240,11 +240,7 @@ impl GeneratedAcir {
                     }
                 };
 
-                BlackBoxFuncCall::Keccak256VariableLength {
-                    inputs: inputs[0].clone(),
-                    var_message_size,
-                    outputs,
-                }
+                BlackBoxFuncCall::Keccak256 { inputs: inputs[0].clone(), var_message_size, outputs }
             }
             BlackBoxFunc::Keccakf1600 => {
                 BlackBoxFuncCall::Keccakf1600 { inputs: inputs[0].clone(), outputs }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index c6bf7923fa8..6cf155f85ab 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -151,7 +151,10 @@ impl Loops {
             if next_loop.blocks.iter().any(|block| self.modified_blocks.contains(block)) {
                 let mut new_context = find_all_loops(function);
                 new_context.failed_to_unroll = self.failed_to_unroll;
-                return new_context.unroll_each_loop(function);
+                return unroll_errors
+                    .into_iter()
+                    .chain(new_context.unroll_each_loop(function))
+                    .collect();
             }
 
             // Don't try to unroll the loop again if it is known to fail
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index e055d7a3a5f..0f9770c805d 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.33.0";
+const VERSION: &str = "0.34.0";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 1acd581b2be..b211832518d 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -513,7 +513,11 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
 
     pub(super) fn write_brillig_memory(&mut self, ptr: usize, value: FieldElement, bit_size: u32) {
         if let Some(solver) = self.brillig_solver.as_mut() {
-            solver.write_memory_at(ptr, MemoryValue::new(value, bit_size));
+            solver.write_memory_at(
+                ptr,
+                MemoryValue::new_checked(value, bit_size)
+                    .expect("Invalid value for the given bit size"),
+            );
         }
     }
 
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 1c077c6ee9b..e30d519b62e 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -319,7 +319,7 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
             return;
         };
 
-        for (index, value) in memory.iter().enumerate().filter(|(_, value)| value.bit_size > 0) {
+        for (index, value) in memory.iter().enumerate().filter(|(_, value)| value.bit_size() > 0) {
             println!("{index} = {}", value);
         }
     }
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index e592ed440ee..98bfdf1c3a8 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.33.0",
+    "@aztec/bb.js": "0.34.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index 0fdad4ad2ad..38e13814929 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.33.0":
-  version: 0.33.0
-  resolution: "@aztec/bb.js@npm:0.33.0"
+"@aztec/bb.js@npm:0.34.0":
+  version: 0.34.0
+  resolution: "@aztec/bb.js@npm:0.34.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 16244a52ef1cb5efca582e863a3521d04f0fb66b02cd584b904e6e65f684e392eec56679439d1a831127e126d117bf0e116166fc4b24efdd6e1ebe9097efed06
+  checksum: 9d07834d81ed19e4d6fd5c1f3b07c565648df1165c30115f020ece9660b2b8599a5ed894a2090410f14020e73dd290484b30b76c9c71e863b8390fa2b7c1b729
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.33.0
+    "@aztec/bb.js": 0.34.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 9fd91b771fe726e6a4872d16208b64d8b6517b0a Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Fri, 12 Apr 2024 05:47:29 -0400
Subject: [PATCH 170/416] chore: testing that nargo fmt is idempotent (#4765)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4666

## Summary\*

Ensures that `nargo_fmt(nargo_fmt(source_code)) ==
nargo_fmt(source_code)`.

Because we have expected outputs, we can avoid re-running on the
unformatted inputs:

```rust
nargo_fmt(expected_output) == expected_output
```

### Bugs found

- https://github.com/noir-lang/noir/issues/4766
- https://github.com/noir-lang/noir/issues/4767
- https://github.com/noir-lang/noir/issues/4768

Currently failing on arrays and tuples:

```bash

---- tests::format_idempotent_array stdout ----
thread 'tests::format_idempotent_array' panicked at /Users/michaelklein/Coding/rust/noir/target/debug/build/nargo_fmt-14fb91f269fc38b6/out/execute.rs:3418:9:
assertion failed: `(left == right)`'
  left: `"fn big_array() {\n    [\n        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 1..."` (truncated)
 right: `"fn big_array() {\n    [\n        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 1..."` (truncated)

Differences (-left|+right):
     [
         // hello!
         1,
         // asd
-        10
+        10
         // asdasd
     ];

     [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18]]];


note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- tests::format_idempotent_tuple stdout ----
thread 'tests::format_idempotent_tuple' panicked at /Users/michaelklein/Coding/rust/noir/target/debug/build/nargo_fmt-14fb91f269fc38b6/out/execute.rs:776:9:
assertion failed: `(left == right)`'
  left: `"fn main() {\n    (1,);\n    (// hello\n        1,);\n    (/*hello*/ 1,);\n    (1/*hello*/,);\n    (1,);\n    (/*test*/ 1,);\n    (/*a*/ 1/*b*/,);\n    (/*a*/ 1/*b*/, /*c*/ 2/*d*/, /*c*/ 2/*d*/);\n    (/*a*/ 1/*..."` (truncated)
 right: `"fn main() {\n    (1,);\n    (// hello\n        1,);\n    (/*hello*/ 1,);\n    (1/*hello*/,);\n    (1,);\n    (/*test*/ 1,);\n    (/*a*/ 1/*b*/,);\n    (/*a*/ 1/*b*/, /*c*/ 2/*d*/, /*c*/ 2/*d*/);\n    (/*a*/ 1/*..."` (truncated)

Differences (-left|+right):
     (//
         1,);

     (// 1
-        1,// 2,
+        1, // 2,
         2);

     (/*1*/ 1, /*2*/ 2);

     // FIXME:
     (((//2
                 1,),),);
     (/*a*/
-        1/*b*/, /*c*/ 2/*d*/, /*c*/ 2/*d*/, /*e*/ 3/*f*/);
+        1/*b*/,
+/*c*/ 2/*d*/, /*c*/ 2/*d*/, /*e*/ 3/*f*/);
 }
```


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 tooling/nargo_fmt/build.rs | 51 +++++++++++++++++++++++++++++---------
 1 file changed, 39 insertions(+), 12 deletions(-)

diff --git a/tooling/nargo_fmt/build.rs b/tooling/nargo_fmt/build.rs
index 6f41768c1dc..7d5f07c43bf 100644
--- a/tooling/nargo_fmt/build.rs
+++ b/tooling/nargo_fmt/build.rs
@@ -49,28 +49,55 @@ fn generate_formatter_tests(test_file: &mut File, test_data_dir: &Path) {
         let output_source_path = outputs_dir.join(file_name).display().to_string();
         let output_source = std::fs::read_to_string(output_source_path.clone()).unwrap();
 
+        let skip_idempotent_test =
+            // TODO(https://github.com/noir-lang/noir/issues/4766): spurious trailing space
+            test_name == "array" ||
+            // TODO(https://github.com/noir-lang/noir/issues/4767): pre-comment space
+            // TODO(https://github.com/noir-lang/noir/issues/4768): spurious newline
+            test_name == "tuple";
+
         write!(
             test_file,
             r##"
-#[test]
-fn format_{test_name}() {{
-    let input = r#"{input_source}"#;
-    let expected_output = r#"{output_source}"#;
+    #[test]
+    fn format_{test_name}() {{
+        let input = r#"{input_source}"#;
+        let expected_output = r#"{output_source}"#;
 
 
-    let (parsed_module, _errors) = noirc_frontend::parse_program(input);
+        let (parsed_module, _errors) = noirc_frontend::parse_program(input);
 
-    let config = nargo_fmt::Config::of("{config}").unwrap();
-    let fmt_text = nargo_fmt::format(input, parsed_module, &config);
+        let config = nargo_fmt::Config::of("{config}").unwrap();
+        let fmt_text = nargo_fmt::format(input, parsed_module, &config);
 
-    if std::env::var("UPDATE_EXPECT").is_ok() {{
-        std::fs::write("{output_source_path}", fmt_text.clone()).unwrap();
-    }}
+        if std::env::var("UPDATE_EXPECT").is_ok() {{
+            std::fs::write("{output_source_path}", fmt_text.clone()).unwrap();
+        }}
 
-    similar_asserts::assert_eq!(fmt_text, expected_output);
-}}
+        similar_asserts::assert_eq!(fmt_text, expected_output);
+    }}
             "##
         )
         .expect("Could not write templated test file.");
+
+        if !skip_idempotent_test {
+            write!(
+                test_file,
+                r##"
+        #[test]
+        fn format_idempotent_{test_name}() {{
+            let expected_output = r#"{output_source}"#;
+
+            let (parsed_module, _errors) = noirc_frontend::parse_program(expected_output);
+
+            let config = nargo_fmt::Config::of("{config}").unwrap();
+            let fmt_text = nargo_fmt::format(expected_output, parsed_module, &config);
+
+            similar_asserts::assert_eq!(fmt_text, expected_output);
+        }}
+                "##
+            )
+            .expect("Could not write templated test file.");
+        }
     }
 }

From ce1e6624ece3c91f06b0273af9ba88e703c1b589 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Fri, 12 Apr 2024 06:32:32 -0400
Subject: [PATCH 171/416] feat: split `backend_barretenburg` into prover and
 verifier classes (#4769)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/3450

## Summary\*

- In order to prove + verify, we have proving and verification keys
+ The proving key is derived from the circuit representation and the
verification key is derived from the proving key
+ The proving key is generally quite big, so we always generate it from
the circuit, which is easier than lugging it around
  + The verification key is much smaller and can be compressed
- Ideally, a user verifying a proof should be able to simply send the
verification key and proof to BB

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: TomAFrench <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 tooling/noir_js/test/node/e2e.test.ts         |  24 ++-
 .../src/backend.ts                            | 143 +++++++++++++++++
 .../noir_js_backend_barretenberg/src/index.ts | 151 +-----------------
 .../src/verifier.ts                           |  78 +++++++++
 tooling/noir_js_types/src/types.ts            |  20 +--
 5 files changed, 259 insertions(+), 157 deletions(-)
 create mode 100644 tooling/noir_js_backend_barretenberg/src/backend.ts
 create mode 100644 tooling/noir_js_backend_barretenberg/src/verifier.ts

diff --git a/tooling/noir_js/test/node/e2e.test.ts b/tooling/noir_js/test/node/e2e.test.ts
index 8921314e8ea..979841c47e6 100644
--- a/tooling/noir_js/test/node/e2e.test.ts
+++ b/tooling/noir_js/test/node/e2e.test.ts
@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
-import { BarretenbergBackend as Backend } from '@noir-lang/backend_barretenberg';
+import { BarretenbergBackend as Backend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
 import { CompiledCircuit } from '@noir-lang/types';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
@@ -47,6 +47,28 @@ it('end-to-end proof creation and verification (outer) -- Program API', async ()
   expect(isValid).to.be.true;
 });
 
+it('end-to-end proof creation and verification (outer) -- Verifier API', async () => {
+  // Noir.Js part
+  const inputs = {
+    x: '2',
+    y: '3',
+  };
+
+  // Initialize backend
+  const backend = new Backend(assert_lt_program);
+  // Initialize program
+  const program = new Noir(assert_lt_program, backend);
+  // Generate proof
+  const proof = await program.generateProof(inputs);
+
+  const verificationKey = await backend.getVerificationKey();
+
+  // Proof verification
+  const verifier = new Verifier();
+  const isValid = await verifier.verifyProof(proof, verificationKey);
+  expect(isValid).to.be.true;
+});
+
 // TODO: maybe switch to using assert_statement_recursive here to test both options
 it('end-to-end proof creation and verification (inner)', async () => {
   // Noir.Js part
diff --git a/tooling/noir_js_backend_barretenberg/src/backend.ts b/tooling/noir_js_backend_barretenberg/src/backend.ts
new file mode 100644
index 00000000000..d07681dd8c1
--- /dev/null
+++ b/tooling/noir_js_backend_barretenberg/src/backend.ts
@@ -0,0 +1,143 @@
+import { decompressSync as gunzip } from 'fflate';
+import { acirToUint8Array } from './serialize.js';
+import { Backend, CompiledCircuit, ProofData, VerifierBackend } from '@noir-lang/types';
+import { BackendOptions } from './types.js';
+import { deflattenPublicInputs } from './public_inputs.js';
+import { reconstructProofWithPublicInputs } from './verifier.js';
+import { type Barretenberg } from '@aztec/bb.js';
+
+// This is the number of bytes in a UltraPlonk proof
+// minus the public inputs.
+const numBytesInProofWithoutPublicInputs: number = 2144;
+
+export class BarretenbergVerifierBackend implements VerifierBackend {
+  // These type assertions are used so that we don't
+  // have to initialize `api` and `acirComposer` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  protected api!: Barretenberg;
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  protected acirComposer: any;
+  protected acirUncompressedBytecode: Uint8Array;
+
+  constructor(
+    acirCircuit: CompiledCircuit,
+    protected options: BackendOptions = { threads: 1 },
+  ) {
+    const acirBytecodeBase64 = acirCircuit.bytecode;
+    this.acirUncompressedBytecode = acirToUint8Array(acirBytecodeBase64);
+  }
+
+  /** @ignore */
+  async instantiate(): Promise<void> {
+    if (!this.api) {
+      if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+        this.options.threads = navigator.hardwareConcurrency;
+      } else {
+        try {
+          const os = await import('os');
+          this.options.threads = os.cpus().length;
+        } catch (e) {
+          console.log('Could not detect environment. Falling back to one thread.', e);
+        }
+      }
+      const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
+      const api = await Barretenberg.new(this.options);
+
+      const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode);
+      const crs = await Crs.new(subgroupSize + 1);
+      await api.commonInitSlabAllocator(subgroupSize);
+      await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+
+      this.acirComposer = await api.acirNewAcirComposer(subgroupSize);
+      await api.acirInitProvingKey(this.acirComposer, this.acirUncompressedBytecode);
+      this.api = api;
+    }
+  }
+
+  /** @description Verifies a proof */
+  async verifyProof(proofData: ProofData): Promise<boolean> {
+    const proof = reconstructProofWithPublicInputs(proofData);
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    return await this.api.acirVerifyProof(this.acirComposer, proof);
+  }
+
+  async getVerificationKey(): Promise<Uint8Array> {
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    return await this.api.acirGetVerificationKey(this.acirComposer);
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+}
+
+export class BarretenbergBackend extends BarretenbergVerifierBackend implements Backend {
+  /** @description Generates a proof */
+  async generateProof(compressedWitness: Uint8Array): Promise<ProofData> {
+    await this.instantiate();
+    const proofWithPublicInputs = await this.api.acirCreateProof(
+      this.acirComposer,
+      this.acirUncompressedBytecode,
+      gunzip(compressedWitness),
+    );
+
+    const splitIndex = proofWithPublicInputs.length - numBytesInProofWithoutPublicInputs;
+
+    const publicInputsConcatenated = proofWithPublicInputs.slice(0, splitIndex);
+    const proof = proofWithPublicInputs.slice(splitIndex);
+    const publicInputs = deflattenPublicInputs(publicInputsConcatenated);
+
+    return { proof, publicInputs };
+  }
+
+  /**
+   * Generates artifacts that will be passed to a circuit that will verify this proof.
+   *
+   * Instead of passing the proof and verification key as a byte array, we pass them
+   * as fields which makes it cheaper to verify in a circuit.
+   *
+   * The proof that is passed here will have been created using a circuit
+   * that has the #[recursive] attribute on its `main` method.
+   *
+   * The number of public inputs denotes how many public inputs are in the inner proof.
+   *
+   * @example
+   * ```typescript
+   * const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+   * ```
+   */
+  async generateRecursiveProofArtifacts(
+    proofData: ProofData,
+    numOfPublicInputs = 0,
+  ): Promise<{
+    proofAsFields: string[];
+    vkAsFields: string[];
+    vkHash: string;
+  }> {
+    await this.instantiate();
+    const proof = reconstructProofWithPublicInputs(proofData);
+    const proofAsFields = (
+      await this.api.acirSerializeProofIntoFields(this.acirComposer, proof, numOfPublicInputs)
+    ).slice(numOfPublicInputs);
+
+    // TODO: perhaps we should put this in the init function. Need to benchmark
+    // TODO how long it takes.
+    await this.api.acirInitVerificationKey(this.acirComposer);
+
+    // Note: If you don't init verification key, `acirSerializeVerificationKeyIntoFields`` will just hang on serialization
+    const vk = await this.api.acirSerializeVerificationKeyIntoFields(this.acirComposer);
+
+    return {
+      proofAsFields: proofAsFields.map((p) => p.toString()),
+      vkAsFields: vk[0].map((vk) => vk.toString()),
+      vkHash: vk[1].toString(),
+    };
+  }
+}
diff --git a/tooling/noir_js_backend_barretenberg/src/index.ts b/tooling/noir_js_backend_barretenberg/src/index.ts
index bfdf1005a93..f28abb9a658 100644
--- a/tooling/noir_js_backend_barretenberg/src/index.ts
+++ b/tooling/noir_js_backend_barretenberg/src/index.ts
@@ -1,150 +1,7 @@
-import { decompressSync as gunzip } from 'fflate';
-import { acirToUint8Array } from './serialize.js';
-import { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
-import { BackendOptions } from './types.js';
-import { deflattenPublicInputs, flattenPublicInputsAsArray } from './public_inputs.js';
-import { type Barretenberg } from '@aztec/bb.js';
-
+export { BarretenbergBackend } from './backend.js';
+export { BarretenbergVerifier } from './verifier.js';
 export { publicInputsToWitnessMap } from './public_inputs.js';
 
-// This is the number of bytes in a UltraPlonk proof
-// minus the public inputs.
-const numBytesInProofWithoutPublicInputs: number = 2144;
-
-export class BarretenbergBackend implements Backend {
-  // These type assertions are used so that we don't
-  // have to initialize `api` and `acirComposer` in the constructor.
-  // These are initialized asynchronously in the `init` function,
-  // constructors cannot be asynchronous which is why we do this.
-
-  private api!: Barretenberg;
-  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  private acirComposer: any;
-  private acirUncompressedBytecode: Uint8Array;
-
-  constructor(
-    acirCircuit: CompiledCircuit,
-    private options: BackendOptions = { threads: 1 },
-  ) {
-    const acirBytecodeBase64 = acirCircuit.bytecode;
-    this.acirUncompressedBytecode = acirToUint8Array(acirBytecodeBase64);
-  }
-
-  /** @ignore */
-  async instantiate(): Promise<void> {
-    if (!this.api) {
-      if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
-        this.options.threads = navigator.hardwareConcurrency;
-      } else {
-        try {
-          const os = await import('os');
-          this.options.threads = os.cpus().length;
-        } catch (e) {
-          console.log('Could not detect environment. Falling back to one thread.', e);
-        }
-      }
-      const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
-      const api = await Barretenberg.new(this.options);
-      const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode);
-      const crs = await Crs.new(subgroupSize + 1);
-      await api.commonInitSlabAllocator(subgroupSize);
-      await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
-
-      this.acirComposer = await api.acirNewAcirComposer(subgroupSize);
-      await api.acirInitProvingKey(this.acirComposer, this.acirUncompressedBytecode);
-      this.api = api;
-    }
-  }
-
-  /** @description Generates a proof */
-  async generateProof(compressedWitness: Uint8Array): Promise<ProofData> {
-    await this.instantiate();
-    // TODO: Change once `@aztec/bb.js` version is updated to use methods without isRecursive flag
-    const proofWithPublicInputs = await this.api.acirCreateProof(
-      this.acirComposer,
-      this.acirUncompressedBytecode,
-      gunzip(compressedWitness),
-    );
-
-    const splitIndex = proofWithPublicInputs.length - numBytesInProofWithoutPublicInputs;
-
-    const publicInputsConcatenated = proofWithPublicInputs.slice(0, splitIndex);
-    const proof = proofWithPublicInputs.slice(splitIndex);
-    const publicInputs = deflattenPublicInputs(publicInputsConcatenated);
-
-    return { proof, publicInputs };
-  }
-
-  /**
-   * Generates artifacts that will be passed to a circuit that will verify this proof.
-   *
-   * Instead of passing the proof and verification key as a byte array, we pass them
-   * as fields which makes it cheaper to verify in a circuit.
-   *
-   * The proof that is passed here will have been created using a circuit
-   * that has the #[recursive] attribute on its `main` method.
-   *
-   * The number of public inputs denotes how many public inputs are in the inner proof.
-   *
-   * @example
-   * ```typescript
-   * const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
-   * ```
-   */
-  async generateRecursiveProofArtifacts(
-    proofData: ProofData,
-    numOfPublicInputs = 0,
-  ): Promise<{
-    proofAsFields: string[];
-    vkAsFields: string[];
-    vkHash: string;
-  }> {
-    await this.instantiate();
-    const proof = reconstructProofWithPublicInputs(proofData);
-    const proofAsFields = (
-      await this.api.acirSerializeProofIntoFields(this.acirComposer, proof, numOfPublicInputs)
-    ).slice(numOfPublicInputs);
-
-    // TODO: perhaps we should put this in the init function. Need to benchmark
-    // TODO how long it takes.
-    await this.api.acirInitVerificationKey(this.acirComposer);
-
-    // Note: If you don't init verification key, `acirSerializeVerificationKeyIntoFields`` will just hang on serialization
-    const vk = await this.api.acirSerializeVerificationKeyIntoFields(this.acirComposer);
-
-    return {
-      proofAsFields: proofAsFields.map((p) => p.toString()),
-      vkAsFields: vk[0].map((vk) => vk.toString()),
-      vkHash: vk[1].toString(),
-    };
-  }
-
-  /** @description Verifies a proof */
-  async verifyProof(proofData: ProofData): Promise<boolean> {
-    const proof = reconstructProofWithPublicInputs(proofData);
-    await this.instantiate();
-    await this.api.acirInitVerificationKey(this.acirComposer);
-    // TODO: Change once `@aztec/bb.js` version is updated to use methods without isRecursive flag
-    return await this.api.acirVerifyProof(this.acirComposer, proof);
-  }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
-}
-
-function reconstructProofWithPublicInputs(proofData: ProofData): Uint8Array {
-  // Flatten publicInputs
-  const publicInputsConcatenated = flattenPublicInputsAsArray(proofData.publicInputs);
-
-  // Concatenate publicInputs and proof
-  const proofWithPublicInputs = Uint8Array.from([...publicInputsConcatenated, ...proofData.proof]);
-
-  return proofWithPublicInputs;
-}
-
 // typedoc exports
-export { Backend, BackendOptions, CompiledCircuit, ProofData };
+export { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
+export { BackendOptions } from './types.js';
diff --git a/tooling/noir_js_backend_barretenberg/src/verifier.ts b/tooling/noir_js_backend_barretenberg/src/verifier.ts
new file mode 100644
index 00000000000..fe9fa9cfffd
--- /dev/null
+++ b/tooling/noir_js_backend_barretenberg/src/verifier.ts
@@ -0,0 +1,78 @@
+import { ProofData } from '@noir-lang/types';
+import { BackendOptions } from './types.js';
+import { flattenPublicInputsAsArray } from './public_inputs.js';
+import { type Barretenberg } from '@aztec/bb.js';
+
+export class BarretenbergVerifier {
+  // These type assertions are used so that we don't
+  // have to initialize `api` and `acirComposer` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  private api!: Barretenberg;
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  private acirComposer: any;
+
+  constructor(private options: BackendOptions = { threads: 1 }) {}
+
+  /** @ignore */
+  async instantiate(): Promise<void> {
+    if (!this.api) {
+      if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+        this.options.threads = navigator.hardwareConcurrency;
+      } else {
+        try {
+          const os = await import('os');
+          this.options.threads = os.cpus().length;
+        } catch (e) {
+          console.log('Could not detect environment. Falling back to one thread.', e);
+        }
+      }
+      const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
+
+      // This is the number of CRS points necessary to verify a Barretenberg proof.
+      const NUM_CRS_POINTS_FOR_VERIFICATION: number = 0;
+      const [api, crs] = await Promise.all([Barretenberg.new(this.options), Crs.new(NUM_CRS_POINTS_FOR_VERIFICATION)]);
+
+      await api.commonInitSlabAllocator(NUM_CRS_POINTS_FOR_VERIFICATION);
+      await api.srsInitSrs(
+        new RawBuffer([] /* crs.getG1Data() */),
+        NUM_CRS_POINTS_FOR_VERIFICATION,
+        new RawBuffer(crs.getG2Data()),
+      );
+
+      this.acirComposer = await api.acirNewAcirComposer(NUM_CRS_POINTS_FOR_VERIFICATION);
+      this.api = api;
+    }
+  }
+
+  /** @description Verifies a proof */
+  async verifyProof(proofData: ProofData, verificationKey: Uint8Array): Promise<boolean> {
+    const { RawBuffer } = await import('@aztec/bb.js');
+
+    await this.instantiate();
+    // The verifier can be used for a variety of ACIR programs so we should not assume that it
+    // is preloaded with the correct verification key.
+    await this.api.acirLoadVerificationKey(this.acirComposer, new RawBuffer(verificationKey));
+
+    const proof = reconstructProofWithPublicInputs(proofData);
+    return await this.api.acirVerifyProof(this.acirComposer, proof);
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+}
+
+export function reconstructProofWithPublicInputs(proofData: ProofData): Uint8Array {
+  // Flatten publicInputs
+  const publicInputsConcatenated = flattenPublicInputsAsArray(proofData.publicInputs);
+
+  // Concatenate publicInputs and proof
+  const proofWithPublicInputs = Uint8Array.from([...publicInputsConcatenated, ...proofData.proof]);
+
+  return proofWithPublicInputs;
+}
diff --git a/tooling/noir_js_types/src/types.ts b/tooling/noir_js_types/src/types.ts
index 3a62d79a807..456e5a57f40 100644
--- a/tooling/noir_js_types/src/types.ts
+++ b/tooling/noir_js_types/src/types.ts
@@ -29,7 +29,17 @@ export type Abi = {
   return_witnesses: number[];
 };
 
-export interface Backend {
+export interface VerifierBackend {
+  /**
+   * @description Verifies a proof */
+  verifyProof(proofData: ProofData): Promise<boolean>;
+
+  /**
+   * @description Destroys the backend */
+  destroy(): Promise<void>;
+}
+
+export interface Backend extends VerifierBackend {
   /**
    * @description Generates a proof */
   generateProof(decompressedWitness: Uint8Array): Promise<ProofData>;
@@ -49,14 +59,6 @@ export interface Backend {
     /** @description A Field containing the verification key hash */
     vkHash: string;
   }>;
-
-  /**
-   * @description Verifies a proof */
-  verifyProof(proofData: ProofData): Promise<boolean>;
-
-  /**
-   * @description Destroys the backend */
-  destroy(): Promise<void>;
 }
 
 /**

From 1d96937a8e94a91c0c17c97102498d067fca76c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=A1s=20Venturo?= <nicolas.venturo@gmail.com>
Date: Fri, 12 Apr 2024 09:04:08 -0300
Subject: [PATCH 172/416] feat: get last mock oracles params (#4789)

Resolves https://github.com/noir-lang/noir/issues/4652

# Description

This adds a new foreign call `get_mock_last_params` that can be used to
configure mocked oracles. It returns the last parameters the mock was
called with, or panics if it wasn't.

Note that this doesn't play very nicely with the `times` feature, since
e.g. if a mock is setup with `times(1)` it is then impossible to ever
retrieve the last params, as the mock will be automatically cleared.
There's a bunch of ways this could be handled, including keeping track
of cleared mocks and llowing these queries over them. I didn't stress
too much about this since we're only now starting to use the mocks, and
I think it might be better to experiment more with them and get more
feedback before worrying about having a nicer API.

I also moved the mock oracle tests outside of `execution_success` into
`noir_test_success`, and added a few simpler cases that I think also
help illustrate how the mocks are supposed to be used (which I
personally found quite useful). I considered adding tests for the
scenarios in which the mocked oracle engine panics (e.g. if no mock
matches the foreign call, or if requesting last params for a mock that
was never called), but run into quite a lot of trouble getting this
working and ultimately gave up. I did at least improve a misleading
error message.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 noir_stdlib/src/test.nr                       |   7 +
 .../execution_success/mock_oracle/Prover.toml |   2 -
 .../execution_success/mock_oracle/src/main.nr |  27 ----
 .../mock_oracle/Nargo.toml                    |   3 +-
 .../noir_test_success/mock_oracle/Prover.toml |   0
 .../noir_test_success/mock_oracle/src/main.nr | 130 ++++++++++++++++++
 tooling/nargo/src/ops/foreign_calls.rs        |  38 ++++-
 7 files changed, 172 insertions(+), 35 deletions(-)
 delete mode 100644 test_programs/execution_success/mock_oracle/Prover.toml
 delete mode 100644 test_programs/execution_success/mock_oracle/src/main.nr
 rename test_programs/{execution_success => noir_test_success}/mock_oracle/Nargo.toml (57%)
 create mode 100644 test_programs/noir_test_success/mock_oracle/Prover.toml
 create mode 100644 test_programs/noir_test_success/mock_oracle/src/main.nr

diff --git a/noir_stdlib/src/test.nr b/noir_stdlib/src/test.nr
index e1c320215de..e6a7e03fefc 100644
--- a/noir_stdlib/src/test.nr
+++ b/noir_stdlib/src/test.nr
@@ -4,6 +4,9 @@ unconstrained fn create_mock_oracle<N>(name: str<N>) -> Field {}
 #[oracle(set_mock_params)]
 unconstrained fn set_mock_params_oracle<P>(id: Field, params: P) {}
 
+#[oracle(get_mock_last_params)]
+unconstrained fn get_mock_last_params_oracle<P>(id: Field) -> P {}
+
 #[oracle(set_mock_returns)]
 unconstrained fn set_mock_returns_oracle<R>(id: Field, returns: R) {}
 
@@ -27,6 +30,10 @@ impl OracleMock {
         self
     }
 
+    unconstrained pub fn get_last_params<P>(self) -> P {
+        get_mock_last_params_oracle(self.id)
+    }
+
     unconstrained pub fn returns<R>(self, returns: R) -> Self {
         set_mock_returns_oracle(self.id, returns);
         self
diff --git a/test_programs/execution_success/mock_oracle/Prover.toml b/test_programs/execution_success/mock_oracle/Prover.toml
deleted file mode 100644
index 2b26a4ce471..00000000000
--- a/test_programs/execution_success/mock_oracle/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "10"
-
diff --git a/test_programs/execution_success/mock_oracle/src/main.nr b/test_programs/execution_success/mock_oracle/src/main.nr
deleted file mode 100644
index 90fca7993cc..00000000000
--- a/test_programs/execution_success/mock_oracle/src/main.nr
+++ /dev/null
@@ -1,27 +0,0 @@
-use dep::std::test::OracleMock;
-
-struct Point {
-    x: Field,
-    y: Field,
-}
-
-#[oracle(foo)]
-unconstrained fn foo_oracle(_point: Point, _array: [Field; 4]) -> Field {}
-
-unconstrained fn main() {
-    let array = [1, 2, 3, 4];
-    let another_array = [4, 3, 2, 1];
-    let point = Point { x: 14, y: 27 };
-
-    OracleMock::mock("foo").returns(42).times(1);
-    let mock = OracleMock::mock("foo").returns(0);
-    assert_eq(42, foo_oracle(point, array));
-    assert_eq(0, foo_oracle(point, array));
-    mock.clear();
-
-    OracleMock::mock("foo").with_params((point, array)).returns(10);
-    OracleMock::mock("foo").with_params((point, another_array)).returns(20);
-    assert_eq(10, foo_oracle(point, array));
-    assert_eq(20, foo_oracle(point, another_array));
-}
-
diff --git a/test_programs/execution_success/mock_oracle/Nargo.toml b/test_programs/noir_test_success/mock_oracle/Nargo.toml
similarity index 57%
rename from test_programs/execution_success/mock_oracle/Nargo.toml
rename to test_programs/noir_test_success/mock_oracle/Nargo.toml
index b2916487e8c..428e965899c 100644
--- a/test_programs/execution_success/mock_oracle/Nargo.toml
+++ b/test_programs/noir_test_success/mock_oracle/Nargo.toml
@@ -2,5 +2,6 @@
 name = "mock_oracle"
 type = "bin"
 authors = [""]
+compiler_version = ">=0.23.0"
 
-[dependencies]
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/noir_test_success/mock_oracle/Prover.toml b/test_programs/noir_test_success/mock_oracle/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/noir_test_success/mock_oracle/src/main.nr b/test_programs/noir_test_success/mock_oracle/src/main.nr
new file mode 100644
index 00000000000..d840ffaef66
--- /dev/null
+++ b/test_programs/noir_test_success/mock_oracle/src/main.nr
@@ -0,0 +1,130 @@
+use dep::std::test::OracleMock;
+
+struct Point {
+    x: Field,
+    y: Field,
+}
+
+impl Eq for Point {
+    fn eq(self, other: Point) -> bool {
+        (self.x == other.x) & (self.y == other.y)
+    }
+}
+
+#[oracle(void_field)]
+unconstrained fn void_field_oracle() -> Field {}
+
+unconstrained fn void_field() -> Field {
+    void_field_oracle()
+}
+
+#[oracle(field_field)]
+unconstrained fn field_field_oracle(_x: Field) -> Field {}
+
+unconstrained fn field_field(x: Field) -> Field {
+    field_field_oracle(x)
+}
+
+#[oracle(struct_field)]
+unconstrained fn struct_field_oracle(_point: Point, _array: [Field; 4]) -> Field {}
+
+unconstrained fn struct_field(point: Point, array: [Field; 4]) -> Field {
+    struct_field_oracle(point, array)
+}
+
+#[test(should_fail)]
+fn test_mock_no_returns() {
+    OracleMock::mock("void_field");
+    void_field(); // Some return value must be set
+}
+
+#[test]
+fn test_mock() {
+    OracleMock::mock("void_field").returns(10);
+    assert_eq(void_field(), 10);
+}
+
+#[test]
+fn test_multiple_mock() {
+    let first_mock = OracleMock::mock("void_field").returns(10);
+    OracleMock::mock("void_field").returns(42);
+
+    // The mocks are searched for in creation order, so the first one prevents the second from being called.
+    assert_eq(void_field(), 10);
+
+    first_mock.clear();
+    assert_eq(void_field(), 42);
+}
+
+#[test]
+fn test_multiple_mock_times() {
+    OracleMock::mock("void_field").returns(10).times(2);
+    OracleMock::mock("void_field").returns(42);
+
+    assert_eq(void_field(), 10);
+    assert_eq(void_field(), 10);
+    assert_eq(void_field(), 42);
+}
+
+#[test]
+fn test_mock_with_params() {
+    OracleMock::mock("field_field").with_params((5,)).returns(10);
+    assert_eq(field_field(5), 10);
+}
+
+#[test]
+fn test_multiple_mock_with_params() {
+    OracleMock::mock("field_field").with_params((5,)).returns(10);
+    OracleMock::mock("field_field").with_params((7,)).returns(14);
+
+    assert_eq(field_field(5), 10);
+    assert_eq(field_field(7), 14);
+}
+
+#[test]
+fn test_mock_last_params() {
+    let mock = OracleMock::mock("field_field").returns(10);
+    assert_eq(field_field(5), 10);
+
+    assert_eq(mock.get_last_params(), 5);
+}
+
+#[test]
+fn test_mock_last_params_many_calls() {
+    let mock = OracleMock::mock("field_field").returns(10);
+    assert_eq(field_field(5), 10);
+    assert_eq(field_field(7), 10);
+
+    assert_eq(mock.get_last_params(), 7);
+}
+
+#[test]
+fn test_mock_struct_field() {
+    // Combination of simpler test cases
+
+    let array = [1, 2, 3, 4];
+    let another_array = [4, 3, 2, 1];
+    let point = Point { x: 14, y: 27 };
+
+    OracleMock::mock("struct_field").returns(42).times(2);
+    let timeless_mock = OracleMock::mock("struct_field").returns(0);
+
+    assert_eq(42, struct_field(point, array));
+    assert_eq(42, struct_field(point, array));
+    // The times(2) mock is now cleared
+
+    assert_eq(0, struct_field(point, array));
+
+    let last_params: (Point, [Field; 4]) = timeless_mock.get_last_params();
+    assert_eq(last_params.0, point);
+    assert_eq(last_params.1, array);
+
+    // We clear the mock with no times() to allow other mocks to be callable
+    timeless_mock.clear();
+
+    OracleMock::mock("struct_field").with_params((point, array)).returns(10);
+    OracleMock::mock("struct_field").with_params((point, another_array)).returns(20);
+    assert_eq(10, struct_field(point, array));
+    assert_eq(20, struct_field(point, another_array));
+}
+
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index ea67f17af2a..bc91929e5e7 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -75,6 +75,7 @@ pub enum ForeignCall {
     AssertMessage,
     CreateMock,
     SetMockParams,
+    GetMockLastParams,
     SetMockReturns,
     SetMockTimes,
     ClearMock,
@@ -93,6 +94,7 @@ impl ForeignCall {
             ForeignCall::AssertMessage => "assert_message",
             ForeignCall::CreateMock => "create_mock",
             ForeignCall::SetMockParams => "set_mock_params",
+            ForeignCall::GetMockLastParams => "get_mock_last_params",
             ForeignCall::SetMockReturns => "set_mock_returns",
             ForeignCall::SetMockTimes => "set_mock_times",
             ForeignCall::ClearMock => "clear_mock",
@@ -105,6 +107,7 @@ impl ForeignCall {
             "assert_message" => Some(ForeignCall::AssertMessage),
             "create_mock" => Some(ForeignCall::CreateMock),
             "set_mock_params" => Some(ForeignCall::SetMockParams),
+            "get_mock_last_params" => Some(ForeignCall::GetMockLastParams),
             "set_mock_returns" => Some(ForeignCall::SetMockReturns),
             "set_mock_times" => Some(ForeignCall::SetMockTimes),
             "clear_mock" => Some(ForeignCall::ClearMock),
@@ -122,6 +125,8 @@ struct MockedCall {
     name: String,
     /// Optionally match the parameters
     params: Option<Vec<ForeignCallParam>>,
+    /// The parameters with which the mock was last called
+    last_called_params: Option<Vec<ForeignCallParam>>,
     /// The result to return when this mock is called
     result: ForeignCallResult,
     /// How many times should this mock be called before it is removed
@@ -134,6 +139,7 @@ impl MockedCall {
             id,
             name,
             params: None,
+            last_called_params: None,
             result: ForeignCallResult { values: vec![] },
             times_left: None,
         }
@@ -185,7 +191,11 @@ impl DefaultForeignCallExecutor {
         Ok((id, params))
     }
 
-    fn find_mock_by_id(&mut self, id: usize) -> Option<&mut MockedCall> {
+    fn find_mock_by_id(&self, id: usize) -> Option<&MockedCall> {
+        self.mocked_responses.iter().find(|response| response.id == id)
+    }
+
+    fn find_mock_by_id_mut(&mut self, id: usize) -> Option<&mut MockedCall> {
         self.mocked_responses.iter_mut().find(|response| response.id == id)
     }
 
@@ -250,15 +260,27 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
             }
             Some(ForeignCall::SetMockParams) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
-                self.find_mock_by_id(id)
+                self.find_mock_by_id_mut(id)
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .params = Some(params.to_vec());
 
                 Ok(ForeignCallResult::default().into())
             }
+            Some(ForeignCall::GetMockLastParams) => {
+                let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
+                let mock =
+                    self.find_mock_by_id(id).unwrap_or_else(|| panic!("Unknown mock id {}", id));
+
+                let last_called_params = mock
+                    .last_called_params
+                    .clone()
+                    .unwrap_or_else(|| panic!("Mock {} was never called", mock.name));
+
+                Ok(last_called_params.into())
+            }
             Some(ForeignCall::SetMockReturns) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
-                self.find_mock_by_id(id)
+                self.find_mock_by_id_mut(id)
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .result = ForeignCallResult { values: params.to_vec() };
 
@@ -269,7 +291,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                 let times =
                     params[0].unwrap_field().try_to_u64().expect("Invalid bit size of times");
 
-                self.find_mock_by_id(id)
+                self.find_mock_by_id_mut(id)
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .times_left = Some(times);
 
@@ -292,6 +314,9 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                             .mocked_responses
                             .get_mut(response_position)
                             .expect("Invalid position of mocked response");
+
+                        mock.last_called_params = Some(foreign_call.inputs.clone());
+
                         let result = mock.result.values.clone();
 
                         if let Some(times_left) = &mut mock.times_left {
@@ -316,7 +341,10 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
 
                         Ok(parsed_response.into())
                     }
-                    (None, None) => panic!("Unknown foreign call {}", foreign_call_name),
+                    (None, None) => panic!(
+                        "No mock for foreign call {}({:?})",
+                        foreign_call_name, &foreign_call.inputs
+                    ),
                 }
             }
         }

From 2ea92926956658ea99d8fb97734831eba00d3a4b Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 12 Apr 2024 12:30:26 -0400
Subject: [PATCH 173/416] fix: Fix panic when returning a zeroed unit value
 (#4797)

# Description

## Problem\*

Resolves #4791

## Summary\*

Zeroed used boolean values since we didn't have true unit values before.
These were meant to be filtered out by the type but as shown in the
issue, they'd still be used if they were directly returned.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs         | 1 +
 compiler/noirc_frontend/src/monomorphization/ast.rs     | 1 +
 compiler/noirc_frontend/src/monomorphization/mod.rs     | 4 +---
 compiler/noirc_frontend/src/monomorphization/printer.rs | 3 +++
 test_programs/execution_success/unit_value/Nargo.toml   | 7 +++++++
 test_programs/execution_success/unit_value/src/main.nr  | 7 +++++++
 6 files changed, 20 insertions(+), 3 deletions(-)
 create mode 100644 test_programs/execution_success/unit_value/Nargo.toml
 create mode 100644 test_programs/execution_success/unit_value/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 3fe52f7f0e5..fd1a029af26 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -241,6 +241,7 @@ impl<'a> FunctionContext<'a> {
 
                 Ok(Tree::Branch(vec![string, field_count.into(), fields]))
             }
+            ast::Literal::Unit => Ok(Self::unit_value()),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 7d20c2bcfee..d9c33d8604e 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -92,6 +92,7 @@ pub enum Literal {
     Slice(ArrayLiteral),
     Integer(FieldElement, Type, Location),
     Bool(bool),
+    Unit,
     Str(String),
     FmtStr(String, u64, Box<Expression>),
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 6aa0abce152..ed620c2da0d 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -1553,9 +1553,7 @@ impl<'interner> Monomorphizer<'interner> {
                 ast::Expression::Literal(ast::Literal::Integer(0_u128.into(), typ, location))
             }
             ast::Type::Bool => ast::Expression::Literal(ast::Literal::Bool(false)),
-            // There is no unit literal currently. Replace it with 'false' since it should be ignored
-            // anyway.
-            ast::Type::Unit => ast::Expression::Literal(ast::Literal::Bool(false)),
+            ast::Type::Unit => ast::Expression::Literal(ast::Literal::Unit),
             ast::Type::Array(length, element_type) => {
                 let element = self.zeroed_value_of_type(element_type.as_ref(), location);
                 ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral {
diff --git a/compiler/noirc_frontend/src/monomorphization/printer.rs b/compiler/noirc_frontend/src/monomorphization/printer.rs
index c253bfe7930..ea8f079cc2f 100644
--- a/compiler/noirc_frontend/src/monomorphization/printer.rs
+++ b/compiler/noirc_frontend/src/monomorphization/printer.rs
@@ -110,6 +110,9 @@ impl AstPrinter {
                 s.fmt(f)?;
                 write!(f, "\"")
             }
+            super::ast::Literal::Unit => {
+                write!(f, "()")
+            }
         }
     }
 
diff --git a/test_programs/execution_success/unit_value/Nargo.toml b/test_programs/execution_success/unit_value/Nargo.toml
new file mode 100644
index 00000000000..f7e3697a7c1
--- /dev/null
+++ b/test_programs/execution_success/unit_value/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "short"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/unit_value/src/main.nr b/test_programs/execution_success/unit_value/src/main.nr
new file mode 100644
index 00000000000..f3844e03cf2
--- /dev/null
+++ b/test_programs/execution_success/unit_value/src/main.nr
@@ -0,0 +1,7 @@
+fn get_transaction() {
+    dep::std::unsafe::zeroed()
+}
+
+fn main() {
+    get_transaction();
+}

From 6bdc324a2506a3c8cceb0995066cfd8f3b67ac5a Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 12 Apr 2024 13:18:28 -0400
Subject: [PATCH 174/416] chore: Add Hir -> Ast conversion (#4788)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4796

## Summary\*

 Adds a way to go from the Hir back to the Ast.
This conversion isn't exact and information is lost currently. Notably
many spans are lost and some constructs like `Type::TypeVariable` have
no equivalent in the Ast.

This also isn't expected to be idempotent. Different nodes may be
desugared, `let` statements may have explicit types added, etc.

## Additional Context

This is unused currently and can't be triggered from the current
compiler at all. I'm adding this PR now to split off required changes
for metaprogramming into smaller chunks.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/mod.rs        |   4 +
 .../src/hir/comptime/hir_to_ast.rs            | 350 ++++++++++++++++++
 .../noirc_frontend/src/hir/comptime/mod.rs    |   1 +
 compiler/noirc_frontend/src/hir/mod.rs        |   1 +
 .../src/hir/resolution/resolver.rs            |   1 +
 compiler/noirc_frontend/src/node_interner.rs  |   4 +
 tooling/nargo_fmt/src/rewrite/typ.rs          |   1 +
 7 files changed, 362 insertions(+)
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/mod.rs

diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 4547dc2a176..254ec4a7590 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -112,6 +112,9 @@ pub enum UnresolvedTypeData {
         /*env:*/ Box<UnresolvedType>,
     ),
 
+    // The type of quoted code for metaprogramming
+    Code,
+
     Unspecified, // This is for when the user declares a variable without specifying it's type
     Error,
 }
@@ -200,6 +203,7 @@ impl std::fmt::Display for UnresolvedTypeData {
                 }
             }
             MutableReference(element) => write!(f, "&mut {element}"),
+            Code => write!(f, "Code"),
             Unit => write!(f, "()"),
             Error => write!(f, "error"),
             Unspecified => write!(f, "unspecified"),
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
new file mode 100644
index 00000000000..8ffcbce7d62
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -0,0 +1,350 @@
+use iter_extended::vecmap;
+use noirc_errors::{Span, Spanned};
+
+use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
+use crate::hir_def::expr::{HirArrayLiteral, HirExpression, HirIdent};
+use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
+use crate::macros_api::HirLiteral;
+use crate::node_interner::{ExprId, NodeInterner, StmtId};
+use crate::{
+    ArrayLiteral, AssignStatement, BlockExpression, CallExpression, CastExpression, ConstrainKind,
+    ConstructorExpression, ExpressionKind, ForLoopStatement, ForRange, Ident, IfExpression,
+    IndexExpression, InfixExpression, LValue, Lambda, LetStatement, Literal,
+    MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression, Type,
+    UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
+};
+
+// TODO:
+// - Full path for idents & types
+// - Assert/AssertEq information lost
+// - The type name span is lost in constructor patterns & expressions
+// - All type spans are lost
+// - Type::TypeVariable has no equivalent in the Ast
+
+impl StmtId {
+    #[allow(unused)]
+    fn to_ast(self, interner: &NodeInterner) -> Statement {
+        let statement = interner.statement(&self);
+        let span = interner.statement_span(&self);
+
+        let kind = match statement {
+            HirStatement::Let(let_stmt) => {
+                let pattern = let_stmt.pattern.into_ast(interner);
+                let r#type = interner.id_type(let_stmt.expression).to_ast();
+                let expression = let_stmt.expression.to_ast(interner);
+                StatementKind::Let(LetStatement {
+                    pattern,
+                    r#type,
+                    expression,
+                    attributes: Vec::new(),
+                })
+            }
+            HirStatement::Constrain(constrain) => {
+                let expr = constrain.0.to_ast(interner);
+                let message = constrain.2.map(|message| message.to_ast(interner));
+
+                // TODO: Find difference in usage between Assert & AssertEq
+                StatementKind::Constrain(ConstrainStatement(expr, message, ConstrainKind::Assert))
+            }
+            HirStatement::Assign(assign) => StatementKind::Assign(AssignStatement {
+                lvalue: assign.lvalue.into_ast(interner),
+                expression: assign.expression.to_ast(interner),
+            }),
+            HirStatement::For(for_stmt) => StatementKind::For(ForLoopStatement {
+                identifier: for_stmt.identifier.to_ast(interner),
+                range: ForRange::Range(
+                    for_stmt.start_range.to_ast(interner),
+                    for_stmt.end_range.to_ast(interner),
+                ),
+                block: for_stmt.block.to_ast(interner),
+                span,
+            }),
+            HirStatement::Break => StatementKind::Break,
+            HirStatement::Continue => StatementKind::Continue,
+            HirStatement::Expression(expr) => StatementKind::Expression(expr.to_ast(interner)),
+            HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
+            HirStatement::Error => StatementKind::Error,
+        };
+
+        Statement { kind, span }
+    }
+}
+
+impl ExprId {
+    #[allow(unused)]
+    fn to_ast(self, interner: &NodeInterner) -> Expression {
+        let expression = interner.expression(&self);
+        let span = interner.expr_span(&self);
+
+        let kind = match expression {
+            HirExpression::Ident(ident) => {
+                let path = Path::from_ident(ident.to_ast(interner));
+                ExpressionKind::Variable(path)
+            }
+            HirExpression::Literal(HirLiteral::Array(array)) => {
+                let array = array.into_ast(interner, span);
+                ExpressionKind::Literal(Literal::Array(array))
+            }
+            HirExpression::Literal(HirLiteral::Slice(array)) => {
+                let array = array.into_ast(interner, span);
+                ExpressionKind::Literal(Literal::Slice(array))
+            }
+            HirExpression::Literal(HirLiteral::Bool(value)) => {
+                ExpressionKind::Literal(Literal::Bool(value))
+            }
+            HirExpression::Literal(HirLiteral::Integer(value, sign)) => {
+                ExpressionKind::Literal(Literal::Integer(value, sign))
+            }
+            HirExpression::Literal(HirLiteral::Str(string)) => {
+                ExpressionKind::Literal(Literal::Str(string))
+            }
+            HirExpression::Literal(HirLiteral::FmtStr(string, _exprs)) => {
+                // TODO: Is throwing away the exprs here valid?
+                ExpressionKind::Literal(Literal::FmtStr(string))
+            }
+            HirExpression::Literal(HirLiteral::Unit) => ExpressionKind::Literal(Literal::Unit),
+            HirExpression::Block(expr) => {
+                let statements = vecmap(expr.statements, |statement| statement.to_ast(interner));
+                ExpressionKind::Block(BlockExpression { statements })
+            }
+            HirExpression::Prefix(prefix) => ExpressionKind::Prefix(Box::new(PrefixExpression {
+                operator: prefix.operator,
+                rhs: prefix.rhs.to_ast(interner),
+            })),
+            HirExpression::Infix(infix) => ExpressionKind::Infix(Box::new(InfixExpression {
+                lhs: infix.lhs.to_ast(interner),
+                operator: Spanned::from(infix.operator.location.span, infix.operator.kind),
+                rhs: infix.rhs.to_ast(interner),
+            })),
+            HirExpression::Index(index) => ExpressionKind::Index(Box::new(IndexExpression {
+                collection: index.collection.to_ast(interner),
+                index: index.index.to_ast(interner),
+            })),
+            HirExpression::Constructor(constructor) => {
+                let type_name = constructor.r#type.borrow().name.to_string();
+                let type_name = Path::from_single(type_name, span);
+                let fields =
+                    vecmap(constructor.fields, |(name, expr)| (name, expr.to_ast(interner)));
+
+                ExpressionKind::Constructor(Box::new(ConstructorExpression { type_name, fields }))
+            }
+            HirExpression::MemberAccess(access) => {
+                ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
+                    lhs: access.lhs.to_ast(interner),
+                    rhs: access.rhs,
+                }))
+            }
+            HirExpression::Call(call) => {
+                let func = Box::new(call.func.to_ast(interner));
+                let arguments = vecmap(call.arguments, |arg| arg.to_ast(interner));
+                ExpressionKind::Call(Box::new(CallExpression { func, arguments }))
+            }
+            HirExpression::MethodCall(method_call) => {
+                ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+                    object: method_call.object.to_ast(interner),
+                    method_name: method_call.method,
+                    arguments: vecmap(method_call.arguments, |arg| arg.to_ast(interner)),
+                }))
+            }
+            HirExpression::Cast(cast) => {
+                let lhs = cast.lhs.to_ast(interner);
+                let r#type = cast.r#type.to_ast();
+                ExpressionKind::Cast(Box::new(CastExpression { lhs, r#type }))
+            }
+            HirExpression::If(if_expr) => ExpressionKind::If(Box::new(IfExpression {
+                condition: if_expr.condition.to_ast(interner),
+                consequence: if_expr.consequence.to_ast(interner),
+                alternative: if_expr.alternative.map(|expr| expr.to_ast(interner)),
+            })),
+            HirExpression::Tuple(fields) => {
+                ExpressionKind::Tuple(vecmap(fields, |field| field.to_ast(interner)))
+            }
+            HirExpression::Lambda(lambda) => {
+                let parameters = vecmap(lambda.parameters, |(pattern, typ)| {
+                    (pattern.into_ast(interner), typ.to_ast())
+                });
+                let return_type = lambda.return_type.to_ast();
+                let body = lambda.body.to_ast(interner);
+                ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
+            }
+            HirExpression::Quote(block) => ExpressionKind::Quote(block),
+            HirExpression::Error => ExpressionKind::Error,
+        };
+
+        Expression::new(kind, span)
+    }
+}
+
+impl HirPattern {
+    fn into_ast(self, interner: &NodeInterner) -> Pattern {
+        match self {
+            HirPattern::Identifier(ident) => Pattern::Identifier(ident.to_ast(interner)),
+            HirPattern::Mutable(pattern, location) => {
+                let pattern = Box::new(pattern.into_ast(interner));
+                Pattern::Mutable(pattern, location.span, false)
+            }
+            HirPattern::Tuple(patterns, location) => {
+                let patterns = vecmap(patterns, |pattern| pattern.into_ast(interner));
+                Pattern::Tuple(patterns, location.span)
+            }
+            HirPattern::Struct(typ, patterns, location) => {
+                let patterns =
+                    vecmap(patterns, |(name, pattern)| (name, pattern.into_ast(interner)));
+                let name = match typ.follow_bindings() {
+                    Type::Struct(struct_def, _) => {
+                        let struct_def = struct_def.borrow();
+                        struct_def.name.0.contents.clone()
+                    }
+                    // This pass shouldn't error so if the type isn't a struct we just get a string
+                    // representation of any other type and use that. We're relying on name
+                    // resolution to fail later when this Ast is re-converted to Hir.
+                    other => other.to_string(),
+                };
+                // The name span is lost here
+                let path = Path::from_single(name, location.span);
+                Pattern::Struct(path, patterns, location.span)
+            }
+        }
+    }
+}
+
+impl HirIdent {
+    fn to_ast(&self, interner: &NodeInterner) -> Ident {
+        let name = interner.definition_name(self.id).to_owned();
+        Ident(Spanned::from(self.location.span, name))
+    }
+}
+
+impl Type {
+    fn to_ast(&self) -> UnresolvedType {
+        let typ = match self {
+            Type::FieldElement => UnresolvedTypeData::FieldElement,
+            Type::Array(length, element) => {
+                let length = length.to_type_expression();
+                let element = Box::new(element.to_ast());
+                UnresolvedTypeData::Array(length, element)
+            }
+            Type::Slice(element) => {
+                let element = Box::new(element.to_ast());
+                UnresolvedTypeData::Slice(element)
+            }
+            Type::Integer(sign, bit_size) => UnresolvedTypeData::Integer(*sign, *bit_size),
+            Type::Bool => UnresolvedTypeData::Bool,
+            Type::String(length) => {
+                let length = length.to_type_expression();
+                UnresolvedTypeData::String(Some(length))
+            }
+            Type::FmtString(length, element) => {
+                let length = length.to_type_expression();
+                let element = Box::new(element.to_ast());
+                UnresolvedTypeData::FormatString(length, element)
+            }
+            Type::Unit => UnresolvedTypeData::Unit,
+            Type::Tuple(fields) => {
+                let fields = vecmap(fields, |field| field.to_ast());
+                UnresolvedTypeData::Tuple(fields)
+            }
+            Type::Struct(def, generics) => {
+                let struct_def = def.borrow();
+                let generics = vecmap(generics, |generic| generic.to_ast());
+                let name = Path::from_ident(struct_def.name.clone());
+                UnresolvedTypeData::Named(name, generics, false)
+            }
+            Type::Alias(type_def, generics) => {
+                // Keep the alias name instead of expanding this in case the
+                // alias' definition was changed
+                let type_def = type_def.borrow();
+                let generics = vecmap(generics, |generic| generic.to_ast());
+                let name = Path::from_ident(type_def.name.clone());
+                UnresolvedTypeData::Named(name, generics, false)
+            }
+            Type::TypeVariable(_, _) => todo!("Convert Type::TypeVariable Hir -> Ast"),
+            Type::TraitAsType(_, name, generics) => {
+                let generics = vecmap(generics, |generic| generic.to_ast());
+                let name = Path::from_single(name.as_ref().clone(), Span::default());
+                UnresolvedTypeData::TraitAsType(name, generics)
+            }
+            Type::NamedGeneric(_, name) => {
+                let name = Path::from_single(name.as_ref().clone(), Span::default());
+                UnresolvedTypeData::TraitAsType(name, Vec::new())
+            }
+            Type::Function(args, ret, env) => {
+                let args = vecmap(args, |arg| arg.to_ast());
+                let ret = Box::new(ret.to_ast());
+                let env = Box::new(env.to_ast());
+                UnresolvedTypeData::Function(args, ret, env)
+            }
+            Type::MutableReference(element) => {
+                let element = Box::new(element.to_ast());
+                UnresolvedTypeData::MutableReference(element)
+            }
+            // Type::Forall is only for generic functions which don't store a type
+            // in their Ast so they don't need to call to_ast for their Forall type.
+            // Since there is no UnresolvedTypeData equivalent for Type::Forall, we use
+            // this to ignore this case since it shouldn't be needed anyway.
+            Type::Forall(_, typ) => return typ.to_ast(),
+            Type::Constant(_) => panic!("Type::Constant where a type was expected: {self:?}"),
+            Type::Code => UnresolvedTypeData::Code,
+            Type::Error => UnresolvedTypeData::Error,
+        };
+
+        UnresolvedType { typ, span: None }
+    }
+
+    fn to_type_expression(&self) -> UnresolvedTypeExpression {
+        let span = Span::default();
+
+        match self.follow_bindings() {
+            Type::Constant(length) => UnresolvedTypeExpression::Constant(length, span),
+            Type::NamedGeneric(_, name) => {
+                let path = Path::from_single(name.as_ref().clone(), span);
+                UnresolvedTypeExpression::Variable(path)
+            }
+            // TODO: This should be turned into a proper error.
+            other => panic!("Cannot represent {other:?} as type expression"),
+        }
+    }
+}
+
+impl HirLValue {
+    fn into_ast(self, interner: &NodeInterner) -> LValue {
+        match self {
+            HirLValue::Ident(ident, _) => LValue::Ident(ident.to_ast(interner)),
+            HirLValue::MemberAccess { object, field_name, field_index: _, typ: _, location } => {
+                let object = Box::new(object.into_ast(interner));
+                LValue::MemberAccess { object, field_name, span: location.span }
+            }
+            HirLValue::Index { array, index, typ: _, location } => {
+                let array = Box::new(array.into_ast(interner));
+                let index = index.to_ast(interner);
+                LValue::Index { array, index, span: location.span }
+            }
+            HirLValue::Dereference { lvalue, element_type: _, location } => {
+                let lvalue = Box::new(lvalue.into_ast(interner));
+                LValue::Dereference(lvalue, location.span)
+            }
+        }
+    }
+}
+
+impl HirArrayLiteral {
+    fn into_ast(self, interner: &NodeInterner, span: Span) -> ArrayLiteral {
+        match self {
+            HirArrayLiteral::Standard(elements) => {
+                ArrayLiteral::Standard(vecmap(elements, |element| element.to_ast(interner)))
+            }
+            HirArrayLiteral::Repeated { repeated_element, length } => {
+                let repeated_element = Box::new(repeated_element.to_ast(interner));
+                let length = match length {
+                    Type::Constant(length) => {
+                        let literal = Literal::Integer((length as u128).into(), false);
+                        let kind = ExpressionKind::Literal(literal);
+                        Box::new(Expression::new(kind, span))
+                    }
+                    other => panic!("Cannot convert non-constant type for repeated array literal from Hir -> Ast: {other:?}"),
+                };
+                ArrayLiteral::Repeated { repeated_element, length }
+            }
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
new file mode 100644
index 00000000000..91621c857cf
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -0,0 +1 @@
+mod hir_to_ast;
diff --git a/compiler/noirc_frontend/src/hir/mod.rs b/compiler/noirc_frontend/src/hir/mod.rs
index 727a6596df1..b4804739cac 100644
--- a/compiler/noirc_frontend/src/hir/mod.rs
+++ b/compiler/noirc_frontend/src/hir/mod.rs
@@ -1,3 +1,4 @@
+pub mod comptime;
 pub mod def_collector;
 pub mod def_map;
 pub mod resolution;
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 08b12069d76..9180201fe17 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -502,6 +502,7 @@ impl<'a> Resolver<'a> {
                 let fields = self.resolve_type_inner(*fields, new_variables);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
+            Code => Type::Code,
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index ffd760d6d7f..84eb2d77315 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -917,6 +917,10 @@ impl NodeInterner {
         self.id_location(expr_id)
     }
 
+    pub fn statement_span(&self, stmt_id: &StmtId) -> Span {
+        self.id_location(stmt_id).span
+    }
+
     pub fn get_struct(&self, id: StructId) -> Shared<StructType> {
         self.structs[&id].clone()
     }
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
index 922337cdb74..980d02ee5dc 100644
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ b/tooling/nargo_fmt/src/rewrite/typ.rs
@@ -64,6 +64,7 @@ pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType)
         | UnresolvedTypeData::Expression(_)
         | UnresolvedTypeData::String(_)
         | UnresolvedTypeData::FormatString(_, _)
+        | UnresolvedTypeData::Code
         | UnresolvedTypeData::TraitAsType(_, _) => visitor.slice(typ.span.unwrap()).into(),
         UnresolvedTypeData::Error => unreachable!(),
     }

From d71d5dea097b4a2e4799240c5b8d27df1581da34 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 12 Apr 2024 15:13:42 -0400
Subject: [PATCH 175/416] chore: Rename 'global' to 'function' in the
 monomorphization pass (#4774)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The original intention of this was to store functions and globals but
after globals were implemented, only functions ended up being used in
the `globals` hashmap. We also probably don't want to monomorphize
globals into different copies going forward so I renamed the map to
`functions` and clarified references to it to avoid confusion.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/monomorphization/mod.rs               | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index ed620c2da0d..4e779244d30 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -52,14 +52,13 @@ struct LambdaContext {
 /// This struct holds the FIFO queue of functions to monomorphize, which is added to
 /// whenever a new (function, type) combination is encountered.
 struct Monomorphizer<'interner> {
-    /// Globals are keyed by their unique ID and expected type so that we can monomorphize
-    /// a new version of the global for each type. Note that 'global' here means 'globally
-    /// visible' and thus includes both functions and global variables.
+    /// Functions are keyed by their unique ID and expected type so that we can monomorphize
+    /// a new version of the function for each type.
     ///
     /// Using nested HashMaps here lets us avoid cloning HirTypes when calling .get()
-    globals: HashMap<node_interner::FuncId, HashMap<HirType, FuncId>>,
+    functions: HashMap<node_interner::FuncId, HashMap<HirType, FuncId>>,
 
-    /// Unlike globals, locals are only keyed by their unique ID because they are never
+    /// Unlike functions, locals are only keyed by their unique ID because they are never
     /// duplicated during monomorphization. Doing so would allow them to be used polymorphically
     /// but would also cause them to be re-evaluated which is a performance trap that would
     /// confuse users.
@@ -165,7 +164,7 @@ pub fn monomorphize_debug(
 impl<'interner> Monomorphizer<'interner> {
     fn new(interner: &'interner mut NodeInterner, debug_type_tracker: DebugTypeTracker) -> Self {
         Monomorphizer {
-            globals: HashMap::new(),
+            functions: HashMap::new(),
             locals: HashMap::new(),
             queue: VecDeque::new(),
             finished_functions: BTreeMap::new(),
@@ -203,7 +202,7 @@ impl<'interner> Monomorphizer<'interner> {
         trait_method: Option<TraitMethodId>,
     ) -> Definition {
         let typ = typ.follow_bindings();
-        match self.globals.get(&id).and_then(|inner_map| inner_map.get(&typ)) {
+        match self.functions.get(&id).and_then(|inner_map| inner_map.get(&typ)) {
             Some(id) => Definition::Function(*id),
             None => {
                 // Function has not been monomorphized yet
@@ -251,8 +250,8 @@ impl<'interner> Monomorphizer<'interner> {
     }
 
     /// Prerequisite: typ = typ.follow_bindings()
-    fn define_global(&mut self, id: node_interner::FuncId, typ: HirType, new_id: FuncId) {
-        self.globals.entry(id).or_default().insert(typ, new_id);
+    fn define_function(&mut self, id: node_interner::FuncId, typ: HirType, new_id: FuncId) {
+        self.functions.entry(id).or_default().insert(typ, new_id);
     }
 
     fn compile_main(
@@ -786,7 +785,7 @@ impl<'interner> Monomorphizer<'interner> {
         })
     }
 
-    /// A local (ie non-global) ident only
+    /// A local (ie non-function) ident only
     fn local_ident(
         &mut self,
         ident: &HirIdent,
@@ -1280,7 +1279,7 @@ impl<'interner> Monomorphizer<'interner> {
         trait_method: Option<TraitMethodId>,
     ) -> FuncId {
         let new_id = self.next_function_id();
-        self.define_global(id, function_type.clone(), new_id);
+        self.define_function(id, function_type.clone(), new_id);
 
         let bindings = self.interner.get_instantiation_bindings(expr_id);
         let bindings = self.follow_bindings(bindings);

From e412e6e30910472b9d5f9000370ce5138ad39ce7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 12 Apr 2024 20:15:40 +0100
Subject: [PATCH 176/416] feat: narrow ABI encoding errors down to target
 problem argument/field (#4798)

# Description

## Problem\*

Resolves #3560
Resolves #4778

## Summary\*

This PR updates `InputValue.matches_abi` to
`InputValue.find_type_mismatch` which returns an error related to the
type which is failing to be abi encoded.

## Additional Context

This should help @alexghr with debugging #4778

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/noirc_abi/src/errors.rs               |   9 +-
 tooling/noirc_abi/src/input_parser/mod.rs     | 157 +++++++++++++++---
 tooling/noirc_abi/src/lib.rs                  |  10 +-
 .../test/browser/errors.test.ts               |   2 +-
 .../noirc_abi_wasm/test/node/errors.test.ts   |   2 +-
 5 files changed, 139 insertions(+), 41 deletions(-)

diff --git a/tooling/noirc_abi/src/errors.rs b/tooling/noirc_abi/src/errors.rs
index 687fecfcc1d..4209a9e218b 100644
--- a/tooling/noirc_abi/src/errors.rs
+++ b/tooling/noirc_abi/src/errors.rs
@@ -1,4 +1,7 @@
-use crate::{input_parser::InputValue, AbiParameter, AbiType};
+use crate::{
+    input_parser::{InputTypecheckingError, InputValue},
+    AbiType,
+};
 use acvm::acir::native_types::Witness;
 use thiserror::Error;
 
@@ -38,8 +41,8 @@ impl From<serde_json::Error> for InputParserError {
 pub enum AbiError {
     #[error("Received parameters not expected by ABI: {0:?}")]
     UnexpectedParams(Vec<String>),
-    #[error("The parameter {} is expected to be a {:?} but found incompatible value {value:?}", .param.name, .param.typ)]
-    TypeMismatch { param: AbiParameter, value: InputValue },
+    #[error("The value passed for parameter `{}` does not match the specified type:\n{0}", .0.path())]
+    TypeMismatch(#[from] InputTypecheckingError),
     #[error("ABI expects the parameter `{0}`, but this was not found")]
     MissingParam(String),
     #[error(
diff --git a/tooling/noirc_abi/src/input_parser/mod.rs b/tooling/noirc_abi/src/input_parser/mod.rs
index f66e069d487..024cb06007e 100644
--- a/tooling/noirc_abi/src/input_parser/mod.rs
+++ b/tooling/noirc_abi/src/input_parser/mod.rs
@@ -1,6 +1,7 @@
 use num_bigint::{BigInt, BigUint};
 use num_traits::{Num, Zero};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashSet};
+use thiserror::Error;
 
 use acvm::FieldElement;
 use serde::Serialize;
@@ -22,63 +23,165 @@ pub enum InputValue {
     Struct(BTreeMap<String, InputValue>),
 }
 
+#[derive(Debug, Error)]
+pub enum InputTypecheckingError {
+    #[error("Value {value:?} does not fall within range of allowable values for a {typ:?}")]
+    OutsideOfValidRange { path: String, typ: AbiType, value: InputValue },
+    #[error("Type {typ:?} is expected to have length {expected_length} but value {value:?} has length {actual_length}")]
+    LengthMismatch {
+        path: String,
+        typ: AbiType,
+        value: InputValue,
+        expected_length: usize,
+        actual_length: usize,
+    },
+    #[error("Could not find value for required field `{expected_field}`. Found values for fields {found_fields:?}")]
+    MissingField { path: String, expected_field: String, found_fields: Vec<String> },
+    #[error("Additional unexpected field was provided for type {typ:?}. Found field named `{extra_field}`")]
+    UnexpectedField { path: String, typ: AbiType, extra_field: String },
+    #[error("Type {typ:?} and value {value:?} do not match")]
+    IncompatibleTypes { path: String, typ: AbiType, value: InputValue },
+}
+
+impl InputTypecheckingError {
+    pub(crate) fn path(&self) -> &str {
+        match self {
+            InputTypecheckingError::OutsideOfValidRange { path, .. }
+            | InputTypecheckingError::LengthMismatch { path, .. }
+            | InputTypecheckingError::MissingField { path, .. }
+            | InputTypecheckingError::UnexpectedField { path, .. }
+            | InputTypecheckingError::IncompatibleTypes { path, .. } => path,
+        }
+    }
+}
+
 impl InputValue {
     /// Checks whether the ABI type matches the InputValue type
-    /// and also their arity
-    pub fn matches_abi(&self, abi_param: &AbiType) -> bool {
+    pub(crate) fn find_type_mismatch(
+        &self,
+        abi_param: &AbiType,
+        path: String,
+    ) -> Result<(), InputTypecheckingError> {
         match (self, abi_param) {
-            (InputValue::Field(_), AbiType::Field) => true,
+            (InputValue::Field(_), AbiType::Field) => Ok(()),
             (InputValue::Field(field_element), AbiType::Integer { width, .. }) => {
-                field_element.num_bits() <= *width
+                if field_element.num_bits() <= *width {
+                    Ok(())
+                } else {
+                    Err(InputTypecheckingError::OutsideOfValidRange {
+                        path,
+                        typ: abi_param.clone(),
+                        value: self.clone(),
+                    })
+                }
             }
             (InputValue::Field(field_element), AbiType::Boolean) => {
-                field_element.is_one() || field_element.is_zero()
+                if field_element.is_one() || field_element.is_zero() {
+                    Ok(())
+                } else {
+                    Err(InputTypecheckingError::OutsideOfValidRange {
+                        path,
+                        typ: abi_param.clone(),
+                        value: self.clone(),
+                    })
+                }
             }
 
             (InputValue::Vec(array_elements), AbiType::Array { length, typ, .. }) => {
                 if array_elements.len() != *length as usize {
-                    return false;
+                    return Err(InputTypecheckingError::LengthMismatch {
+                        path,
+                        typ: abi_param.clone(),
+                        value: self.clone(),
+                        expected_length: *length as usize,
+                        actual_length: array_elements.len(),
+                    });
                 }
                 // Check that all of the array's elements' values match the ABI as well.
-                array_elements.iter().all(|input_value| input_value.matches_abi(typ))
+                for (i, element) in array_elements.iter().enumerate() {
+                    let mut path = path.clone();
+                    path.push_str(&format!("[{i}]"));
+
+                    element.find_type_mismatch(typ, path)?;
+                }
+                Ok(())
             }
 
             (InputValue::String(string), AbiType::String { length }) => {
-                string.len() == *length as usize
+                if string.len() == *length as usize {
+                    Ok(())
+                } else {
+                    Err(InputTypecheckingError::LengthMismatch {
+                        path,
+                        typ: abi_param.clone(),
+                        value: self.clone(),
+                        actual_length: string.len(),
+                        expected_length: *length as usize,
+                    })
+                }
             }
 
             (InputValue::Struct(map), AbiType::Struct { fields, .. }) => {
-                if map.len() != fields.len() {
-                    return false;
+                for (field_name, field_type) in fields {
+                    if let Some(value) = map.get(field_name) {
+                        let mut path = path.clone();
+                        path.push_str(&format!(".{field_name}"));
+                        value.find_type_mismatch(field_type, path)?;
+                    } else {
+                        return Err(InputTypecheckingError::MissingField {
+                            path,
+                            expected_field: field_name.to_string(),
+                            found_fields: map.keys().cloned().collect(),
+                        });
+                    }
                 }
 
-                let field_types = BTreeMap::from_iter(fields.iter().cloned());
+                if map.len() > fields.len() {
+                    let expected_fields: HashSet<String> =
+                        fields.iter().map(|(field, _)| field.to_string()).collect();
+                    let extra_field = map.keys().cloned().find(|key| !expected_fields.contains(key)).expect("`map` is larger than the expected type's `fields` so it must contain an unexpected field");
+                    return Err(InputTypecheckingError::UnexpectedField {
+                        path,
+                        typ: abi_param.clone(),
+                        extra_field: extra_field.to_string(),
+                    });
+                }
 
-                // Check that all of the struct's fields' values match the ABI as well.
-                map.iter().all(|(field_name, field_value)| {
-                    if let Some(field_type) = field_types.get(field_name) {
-                        field_value.matches_abi(field_type)
-                    } else {
-                        false
-                    }
-                })
+                Ok(())
             }
 
             (InputValue::Vec(vec_elements), AbiType::Tuple { fields }) => {
                 if vec_elements.len() != fields.len() {
-                    return false;
+                    return Err(InputTypecheckingError::LengthMismatch {
+                        path,
+                        typ: abi_param.clone(),
+                        value: self.clone(),
+                        actual_length: vec_elements.len(),
+                        expected_length: fields.len(),
+                    });
                 }
-
-                vec_elements
-                    .iter()
-                    .zip(fields)
-                    .all(|(input_value, abi_param)| input_value.matches_abi(abi_param))
+                // Check that all of the array's elements' values match the ABI as well.
+                for (i, (element, expected_typ)) in vec_elements.iter().zip(fields).enumerate() {
+                    let mut path = path.clone();
+                    path.push_str(&format!(".{i}"));
+                    element.find_type_mismatch(expected_typ, path)?;
+                }
+                Ok(())
             }
 
             // All other InputValue-AbiType combinations are fundamentally incompatible.
-            _ => false,
+            _ => Err(InputTypecheckingError::IncompatibleTypes {
+                path,
+                typ: abi_param.clone(),
+                value: self.clone(),
+            }),
         }
     }
+
+    /// Checks whether the ABI type matches the InputValue type.
+    pub fn matches_abi(&self, abi_param: &AbiType) -> bool {
+        self.find_type_mismatch(abi_param, String::new()).is_ok()
+    }
 }
 
 /// The different formats that are supported when parsing
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 89a60b0ed26..6ad13500bdd 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -307,15 +307,7 @@ impl Abi {
                     .ok_or_else(|| AbiError::MissingParam(param_name.clone()))?
                     .clone();
 
-                if !value.matches_abi(&expected_type) {
-                    let param = self
-                        .parameters
-                        .iter()
-                        .find(|param| param.name == param_name)
-                        .unwrap()
-                        .clone();
-                    return Err(AbiError::TypeMismatch { param, value });
-                }
+                value.find_type_mismatch(&expected_type, param_name.clone())?;
 
                 Self::encode_value(value, &expected_type).map(|v| (param_name, v))
             })
diff --git a/tooling/noirc_abi_wasm/test/browser/errors.test.ts b/tooling/noirc_abi_wasm/test/browser/errors.test.ts
index 429a2d446a3..0f75ff64a3e 100644
--- a/tooling/noirc_abi_wasm/test/browser/errors.test.ts
+++ b/tooling/noirc_abi_wasm/test/browser/errors.test.ts
@@ -9,7 +9,7 @@ it('errors when an integer input overflows', async () => {
   const { abi, inputs } = await import('../shared/uint_overflow');
 
   expect(() => abiEncode(abi, inputs)).to.throw(
-    'The parameter foo is expected to be a Integer { sign: Unsigned, width: 32 } but found incompatible value Field(2³⁸)',
+    'The value passed for parameter `foo` does not match the specified type:\nValue Field(2³⁸) does not fall within range of allowable values for a Integer { sign: Unsigned, width: 32 }',
   );
 });
 
diff --git a/tooling/noirc_abi_wasm/test/node/errors.test.ts b/tooling/noirc_abi_wasm/test/node/errors.test.ts
index 0d007e64803..fba451b4a8c 100644
--- a/tooling/noirc_abi_wasm/test/node/errors.test.ts
+++ b/tooling/noirc_abi_wasm/test/node/errors.test.ts
@@ -5,7 +5,7 @@ it('errors when an integer input overflows', async () => {
   const { abi, inputs } = await import('../shared/uint_overflow');
 
   expect(() => abiEncode(abi, inputs)).to.throw(
-    'The parameter foo is expected to be a Integer { sign: Unsigned, width: 32 } but found incompatible value Field(2³⁸)',
+    'The value passed for parameter `foo` does not match the specified type:\nValue Field(2³⁸) does not fall within range of allowable values for a Integer { sign: Unsigned, width: 32 }',
   );
 });
 

From 21f9f6fd26bdc9edcfe7ce3ff97d427303b7c87d Mon Sep 17 00:00:00 2001
From: Martin Verzilli <martin.verzilli@gmail.com>
Date: Fri, 12 Apr 2024 22:41:03 +0200
Subject: [PATCH 177/416] chore(debugger): Docs (#4145)

# Description

Adds documentation for the Noir debugger.

## Problem

Part of #3015.

## Summary

Adds quickstart, how to's and reference pages to Noir's docsite covering
both the VS Code and REPL debuggers.

## Documentation

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 cspell.json                                   |   1 +
 docs/docs/getting_started/tooling/index.mdx   |  38 --
 docs/docs/how_to/debugger/_category_.json     |   6 +
 .../debugger/debugging_with_the_repl.md       | 164 ++++++++
 .../how_to/debugger/debugging_with_vs_code.md |  68 ++++
 docs/docs/how_to/merkle-proof.mdx             |   1 +
 docs/docs/noir/concepts/functions.md          |   4 +-
 .../debugger}/_category_.json                 |   4 +-
 .../debugger/debugger_known_limitations.md    |  59 +++
 docs/docs/reference/debugger/debugger_repl.md | 360 ++++++++++++++++++
 .../reference/debugger/debugger_vscode.md     |  82 ++++
 docs/docs/tooling/debugger.md                 |  27 ++
 .../tooling/language_server.md                |   0
 .../{getting_started => }/tooling/testing.md  |   0
 docs/sidebars.js                              |   5 +
 docs/static/img/debugger/1-started.png        | Bin 0 -> 786947 bytes
 docs/static/img/debugger/2-icon.png           | Bin 0 -> 27014 bytes
 docs/static/img/debugger/3-debug-pane.png     | Bin 0 -> 83927 bytes
 .../img/debugger/4-debugger-buttons.png       | Bin 0 -> 12345 bytes
 docs/static/img/debugger/5-assert.png         | Bin 0 -> 512053 bytes
 docs/static/img/debugger/6-hover.png          | Bin 0 -> 292419 bytes
 docs/static/img/debugger/7-break.png          | Bin 0 -> 627627 bytes
 docs/static/img/debugger/debugger-intro.gif   | Bin 0 -> 1260930 bytes
 .../img/debugger/ref1-create-launch.png       | Bin 0 -> 113387 bytes
 24 files changed, 777 insertions(+), 42 deletions(-)
 delete mode 100644 docs/docs/getting_started/tooling/index.mdx
 create mode 100644 docs/docs/how_to/debugger/_category_.json
 create mode 100644 docs/docs/how_to/debugger/debugging_with_the_repl.md
 create mode 100644 docs/docs/how_to/debugger/debugging_with_vs_code.md
 rename docs/docs/{getting_started/tooling => reference/debugger}/_category_.json (53%)
 create mode 100644 docs/docs/reference/debugger/debugger_known_limitations.md
 create mode 100644 docs/docs/reference/debugger/debugger_repl.md
 create mode 100644 docs/docs/reference/debugger/debugger_vscode.md
 create mode 100644 docs/docs/tooling/debugger.md
 rename docs/docs/{getting_started => }/tooling/language_server.md (100%)
 rename docs/docs/{getting_started => }/tooling/testing.md (100%)
 create mode 100644 docs/static/img/debugger/1-started.png
 create mode 100644 docs/static/img/debugger/2-icon.png
 create mode 100644 docs/static/img/debugger/3-debug-pane.png
 create mode 100644 docs/static/img/debugger/4-debugger-buttons.png
 create mode 100644 docs/static/img/debugger/5-assert.png
 create mode 100644 docs/static/img/debugger/6-hover.png
 create mode 100644 docs/static/img/debugger/7-break.png
 create mode 100644 docs/static/img/debugger/debugger-intro.gif
 create mode 100644 docs/static/img/debugger/ref1-create-launch.png

diff --git a/cspell.json b/cspell.json
index 16de9757fb8..bf3040265c2 100644
--- a/cspell.json
+++ b/cspell.json
@@ -113,6 +113,7 @@
         "Maddiaa",
         "mathbb",
         "memfs",
+        "memset",
         "merkle",
         "metas",
         "minreq",
diff --git a/docs/docs/getting_started/tooling/index.mdx b/docs/docs/getting_started/tooling/index.mdx
deleted file mode 100644
index ac480f3c9f5..00000000000
--- a/docs/docs/getting_started/tooling/index.mdx
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
-Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
----
-
-Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
-
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
-## IDE tools
-
-When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
-
-The easiest way to use these tools is by installing the [Noir VS Code extension](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
-
-## Codespaces
-
-Some Noir repos have leveraged Codespaces in order to ease the development process. You can visit the [noir-starter](https://github.com/noir-lang/noir-starter) for an example.
-
-<video width="100%" height="auto" controls>
-  <source src={require('@site/static/video/codespaces_showcase.mp4').default} type="video/mp4" />
-  Your browser does not support the video tag.
-</video>
-
-## GitHub Actions
-
-You can use `noirup` with GitHub Actions for CI/CD and automated testing. It is as simple as
-installing `noirup` and running tests in your GitHub Action `yml` file.
-
-See the
-[config file in the Noir repo](https://github.com/TomAFrench/noir-hashes/blob/master/.github/workflows/noir.yml) for an example usage.
-
-## Community projects
-
-As an open-source project, Noir has received many contributions over time. Some of them are related with developer tooling, and you can see some of them in [Awesome Noir repository](https://github.com/noir-lang/awesome-noir#dev-tools)
diff --git a/docs/docs/how_to/debugger/_category_.json b/docs/docs/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/docs/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/docs/how_to/debugger/debugging_with_the_repl.md b/docs/docs/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..09e5bae68ad
--- /dev/null
+++ b/docs/docs/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/docs/how_to/debugger/debugging_with_vs_code.md b/docs/docs/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/docs/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/docs/how_to/merkle-proof.mdx b/docs/docs/how_to/merkle-proof.mdx
index 003c7019a93..16c425bed76 100644
--- a/docs/docs/how_to/merkle-proof.mdx
+++ b/docs/docs/how_to/merkle-proof.mdx
@@ -5,6 +5,7 @@ description:
   merkle tree with a specified root, at a given index.
 keywords:
   [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
 ---
 
 Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
diff --git a/docs/docs/noir/concepts/functions.md b/docs/docs/noir/concepts/functions.md
index 2c9bc33fdfc..f656cdfd97a 100644
--- a/docs/docs/noir/concepts/functions.md
+++ b/docs/docs/noir/concepts/functions.md
@@ -62,7 +62,7 @@ fn main(x : [Field]) // can't compile, has variable size
 fn main(....// i think you got it by now
 ```
 
-Keep in mind [tests](../../getting_started/tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
 
 ```rust
 fn main(x : [Field]) {
@@ -190,7 +190,7 @@ Supported attributes include:
 - **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
 - **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
 - **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
-- **test**: mark the function as unit tests. See [Tests](../../getting_started/tooling/testing.md) for more details
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
 
 ### Field Attribute
 
diff --git a/docs/docs/getting_started/tooling/_category_.json b/docs/docs/reference/debugger/_category_.json
similarity index 53%
rename from docs/docs/getting_started/tooling/_category_.json
rename to docs/docs/reference/debugger/_category_.json
index 55804c03a71..27869205ad3 100644
--- a/docs/docs/getting_started/tooling/_category_.json
+++ b/docs/docs/reference/debugger/_category_.json
@@ -1,6 +1,6 @@
 {
-    "position": 2,
-    "label": "Tooling",
+    "label": "Debugger",
+    "position": 1,
     "collapsible": true,
     "collapsed": true
 }
diff --git a/docs/docs/reference/debugger/debugger_known_limitations.md b/docs/docs/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/docs/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/docs/reference/debugger/debugger_repl.md b/docs/docs/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/docs/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/docs/reference/debugger/debugger_vscode.md b/docs/docs/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/docs/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/docs/tooling/debugger.md b/docs/docs/tooling/debugger.md
new file mode 100644
index 00000000000..184c436068f
--- /dev/null
+++ b/docs/docs/tooling/debugger.md
@@ -0,0 +1,27 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+
+- Noir 0.xx 
+- Nargo 0.xx
+- vscode-noir 0.xx
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/docs/getting_started/tooling/language_server.md b/docs/docs/tooling/language_server.md
similarity index 100%
rename from docs/docs/getting_started/tooling/language_server.md
rename to docs/docs/tooling/language_server.md
diff --git a/docs/docs/getting_started/tooling/testing.md b/docs/docs/tooling/testing.md
similarity index 100%
rename from docs/docs/getting_started/tooling/testing.md
rename to docs/docs/tooling/testing.md
diff --git a/docs/sidebars.js b/docs/sidebars.js
index f1e79ba9ebc..cf7e852fed5 100644
--- a/docs/sidebars.js
+++ b/docs/sidebars.js
@@ -65,6 +65,11 @@ export default {
       label: 'Reference',
       items: [{ type: 'autogenerated', dirName: 'reference' }],
     },
+    {
+      type: 'category',
+      label: 'Tooling',
+      items: [{ type: 'autogenerated', dirName: 'tooling' }],
+    },
     {
       type: 'html',
       value: '<div class="divider"></div>',
diff --git a/docs/static/img/debugger/1-started.png b/docs/static/img/debugger/1-started.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f764d4e60125cdbc08d2a7fd06de694324ba10f
GIT binary patch
literal 786947
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%0DQ6!h#q@3SuE8L|=L#Yvv<
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%0D&6S?>Y?rTy12u`PsICnRWXe9EK+%jq
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%0DqUd!#CQChK*`
zD-_EJ+A?KI?F>St$<{cDgbFfU!_my5-WywD|DI$d807>}2jHq_rdJE6RaK`Q0i)Rz
z{y4%^OU<^}1(E4J6A}Re<nFoZLxRQZO8($ti(-y;+$zVG_Vy#1HHKiwR^Jh`J6F;a
z^_H%S5H(OKy20y|*pY^ZvoY1GqKLA+2f^d&6dz=1S;>EfXL4%acpC5KK`zvqv^X7^
z9Mvxjpx#9_iD1dZ<DXp4Z_-|kTX&PbUA0>M5I_M!+Yj9jhR!P6=iz!?ApvY}`u&jo
zVL|2|#hm<?fts}|mg<uA@~)HrD5*jlLL_G0%ZNOK&ug@uu8GvXzxB6zJt-QMWPx%|
zhM&3Z`Ti#rd=)bEZ0}p822s=PVb!EieYlr;m+fBFcqMlu5{$|It38H*!+6b-&n{1=
zl#F`ZKIZgSoql5N;t4aUI!vzeft-hQL*Q=PvHgzj<TY}-v%jduj}5K}gWmkK=m*h9
z7DmbHu?MvRIW;&C9KXORPzes?#QzktJRC}``TA2ug|8u#w*woSk+^Fh>g?k3M(OsL
zcyvNSIAkro@HY!wG@^&KUhj>T>0-O=me<=;VB8w6LbaL7J5(E$-#rz(e7?ShS<FtR
z1f-7piD*UiE&mv|$41_qtQreE#uBC&Ovv}%Xb;7nU-&_n0|V*C-sW;c?NrUv=5aUd
zEmeTvicl|?$<DnVrEK#LG(mDA$E8{_6RH!GpHIu@3HNG75_b-j-tA3PqwJ45Y*(G=
z;iTKrSN*5m#Q+C&fQN|ov!KfBw|r$*i}f~)0lBxrpXiwXAg=Gjpb-w-S02Tns8z%7
z!hN}6FljeTDRq2;@6&5W`Uh;Q!F7GYrtj7j81zD2khkf{Fp$g|uPm1tFu*Dt9St)u
z1@iY@;S9}MVq&;I+=oB)Pj0(7P(rar2a;1z{J}@6s)Gv3{C#66uM7{b!G6IC&<p-7
zLMvMc3zTb>(b!+v;i$Ew;%+!wv`6D<9#TMyYgSxTfq}gC-D=R&^2?e2VccDcI@q5B
zC3R_<*&$O97}fs`@=a`QR(~*D#874Y@dWR#_oW3nTr>iQ59I-Vh$-345y!tI8x<uY
zj=^FQ4UT#lEWc%5viQqdQi}nab-{kv*rCIwqZl?+)L~F}AN=|BWYoskQ3{_|>%HxT
zkk86jyT2ca_ksnDNHMl02>pu?Psv3c9#U2vc$r1tuwzcTF`VGFRzyrDqFUX*k)xM#
zmwZAOPiJ0S(P~-SM14BArRLx*DJOqjy7fGlrQqgZ;5pR~c48XKcg_p{F#3k$oO$H6
zSaX+lJu53JWi3K#S$jsfYDFq*76=tus%P~JYZa^j2C{xh?2aO(Upa)&&{&HvL*Ki(
zrCd6U_3k?Tri>IrypU@bo49R$7%4%Kn^0`VCHRlV&cyNnJ-pAKTS*<urmN6eED+pq
z!5gZKz1nV1VY-H&QdIe+n+tH7qv(FT8E`g4RW`3a7LCz1qUb0u)M2%2sD<7Ei9>LY
zq`WCa0(ib|BiOpQU=E3Uj1DC!mHkpK1t>yZo+|(vYA=EBOs(=5FV5Ic7{AC9BJ4Bo
zK|i51W0DePkzN?cKc1Bsy|GW3bI6?4LYg`n;z5u+D;C0|#&B=)vj?rbD4ImS_EnE6
zVv)w7{jOmq0q^gaKe0?zdy6Gs@g;f3$H~eksN+)arrJFGIe(tfsC{G}oc0aTWrybN
z41q_ry!tInZFZxjCe;6p#p}umQNBY$#*>m>uMtUVx143Bt(B+hdjvtqWt1+t&2BGb
z`LZEDwDNDoz<KLx_fmZOR}M<0-6+8V`pdnW-(9hlUU#VRT$~!#i%i@o->$vF=MbBV
z97@aN3j)U5me2LIIF11kvAyf+oG(x2*bk3dSqW+_-Nb~KyyC+~i)ng_o9N64X;e4@
zed1ZcV`W?au`z}*EZ~8fD+!P7nf71P7Aj7@xzKV33ulIun6pzV$G|T9`Np%zsL255
za~}74Vbd{!wuDk;A8%x%*Ow7R6?@7%fitoQ*X0y*_sZG3&lOslKq*Oq9(COkT9Y4i
z&C&NT-w*$6lApQ|nk-!<YSzpKy?0dT(QLK;;KLuI+3TK9KhcM^{lW~E7&Y}yYp+8C
zP^((Lw*BKJkJ#MDrLk!Qh3BK${q7cW_-t?X8Gu<LFLY~HU=6@L`h-Jp9Zw6pNyTo|
zMpEcmHhDIU@uGJS$8>-K5Qn!tK%!CJC(k_2gU2weN6!#vf2{E;3oLvMRrvfo*<{$V
z)aM^|;fiV+NWX4Bu<pHO56hC=><vDWAI=}ss`Pwoe><P!pG#!H6voK*CTMtcNG~8$
z77wGuH?yTk6*fJ)q)g@f2NsF`934p{p%EBf-``Fwth(3@{vio{_=A83#<l;i3UO+P
zaMcVRuU;1K>-m@P*~8Fg0Au=hyG=s{1DaErV#gooYb(+xupyptCA=0AFjdR>yD+<6
zS|vAEX2C9zTMs^@oB&>A9C65F_f`^&1u$DNRJa(5Tj8f&Ap~T|KP=9tS|Px%ETLjs
ziw1mTC0eCT@v<bfdi|#L_IP?oW}EdH>_XKRb;S{;Y#IP_*&5(CQx}T|TpsR2FEN)3
zQa9S{vOGFZM`2XR*z>s$lUb<OskEq+9F}QN3@y>;<WU#~%5<&0%@j!%SuZrM3uvHG
zXf)Wt@5<_ssaSITgoVU#jUkgi97;K%=lX6YtZ$!;aor!-U^&vhQ@rnLL|h%qDt@&)
z8%<Rq%~Itk6NHq}6Nu<;NoaNPl_%(i;sVFEJfmYc`&ZvkUea*RODcNQy<TNgER&k+
zISba|#Q5NmTL2zkrP&OoP>!6u*WS)3>5AS9WJE9+-SRL<hUU_%PeQ{X1lnzH(%il`
z&25i)mc4AlL&Yg@Gj|46C(rh_HtI`Z6FG=*&hcD`#Y9R%b}b}`sAPv;MzO^q4q(e*
zI43NeU#hsDlTV6HW1rD4^AQz6(s{OV3V(yGe-#Z!U8Sr-8V^jup)#2eN=Md&FQCL4
zk5R{M@Bo~Yw1}H)_aJng>7!W?-mJL^L&Twm<i)MR0M^D*O-n1$nlEs}U<+(r^u<th
z4Ypo-2r4|L5^+ZbjXr#>7FYN8EzI<t$`m=fbH5{1wBY<f&rwRF;LR<|)PD8h>g8F*
zJq!RHG{gC)R0Og}SinGV;&G9C*1TQ<Z9S&v7e^cjBe9s2-(u~wxzd}%>9{D=%K!QY
zIMCP3<m6mBtJ?jh8gN5n7|NNwfDbfpr43tJ4-+{{H0rYSqHng8u8e<7zxhh5=Y(-9
zKAJe6Vyr?ch+<5tp-NBODwLTXS#=B#p^gO=Q<e{3#8MTv<`Ev{94{!m{EZeBj`l@4
zN)Kv>E?%(0ho#8vzSEZW@){_;rqcy|rK-ISzt(o!JG5wYHrSW1x($l(tsGZ(lmX6m
z^xCWuQR@vypGA?AM~{?k3{kl`&b0cM+bbukf6|MzQRcbviYwjcYjQdqEk`!2-Lym@
zjk#Sl=fWp^OJxGILPHvXxDum~xMmAENGY{3mS&;ye_@`)k81X&P}w;ec(n-T#>S{_
zWVF6Q;j-q(76%>&F&sMWI$CxCZH*EmX@pVGUD+fxi_3$twZ^yiXP5_p?c3y%j6`5B
z&4pSBd#n52$(Fk34xesAEr1gwklnOhFO0yDzEi-{WWZNs&GCX5q@_N&yga6pvUcT)
z^~+8oY56CI)cN}&jt+6@q?C%HR^Jr3JRXypFgz+@9_SQd<H7>X%}$j`s~YLopFIPl
z1z5zXtD&Zsn^aRM(}%X8IUfRldlNeUK}l*7s!Yw<C33k)1IgG_dL<KIw$y@+!w98j
zuDF|=Me7&P7YVpkPs^=bDra>QUoUkO{^_%jk@(_~YFOoIB(@ovC$KUxI+`|?&(*!e
z%^#u47-xSF+9x8gEofC_F4-9~`Et#2;c@Pm-wa83Ev>wotvY;mK8~Um1S{)X<zZZ6
z!^bN?+$S7P>+_px?fQ_AJ+)ei`0q_0IQHXpKDXy%E<Ho6$xVM)A{d^`R<T^*O1Sc5
z{FX^+wiTyiBx>iI7RBJlpX$Og|LJzx2=Cnvv0ocvvhG3)rK%G*Aoyc!V!zn=UUZf<
zYL%!pMD|~Bg8&n1lALBA`A%6z7)Yl|Z*pMCLYXYuvFVLS^{$va8#gXp`5Z7W(&YvW
zmQJ_PZq{y9!LD`)`;84yaHiXzUgOazZ?#3gj%tEc`5!BJEHR%Daj$@PYPLt7QcLrc
z>@Wqpe3M72+zv$32|ql*?e-6b__?glMYMc&JSNcPP{|4orcrVwg$Qd+;j)yx?UpfF
zH67pe6YRUZ%C7mu(A&?p?4m<k3-IMPc=OT4_q}9~Ncdk>F<oPvHPz+O;CQP`G1$DU
z4D2XGTJr`IDU8naq}V<enNJ|u{mLdjr*y@;Cy+6Bj4s|ZqXgFsx=DtP$ptQET9&TX
zo}tfg;?<u`84s_J437rKJ-3zHx09fsTIGMa_>Xs6f%#EHK4G3LJWwQ$jMwqomsc;Y
z8K~a`#lWei%Z3iQ3zqY&nHhJX+W$=CAAeY*U*ZE{D^fgne~!2Po%U2W{G<K2vGl$-
z7)`UP(4*G=Xm()sMhp~w<~m=3%q(v%`f0UJLei+mZgK7VQNA!qp%+g!XAmpCqz10|
zo{)`$a&pXKFiv&rjb+|d^z=#0>D3+cl!GVKq+6WeB1S@ebA&pxv4xn`6?>^jQ6a<p
z#04wu!ywaB5OD_ddg5hW$!tSC@K2p1GtuQ^uou;pr(kmaMs<>%Xr*uMZU203=6REF
zhnD@_Jz4OVH%4|Ehd-9;x>xuC$Jx(Ro$_*r+E37rOF^<*HJ@UYjL0#*7%1E=8^z?F
z${9Opj~o|8D6a>hiplbL8CM<<H?iclCO&hh<8G{}glEKyY-Z*M_j>uBlo2l*uHZ0N
zmK%WyIYBLjT`s)_a5CLZB!^flB#-%UH1q2#`lJn}3d=68rJ-h@wj;9`eK*5*V?Yro
z9?xcV!6k?Z`5`pqD=ug~E0~W!jxp%9lc&1JD_T323zz*D|0%pwv6`2|^FlG;Vjx(z
zwVYDJn!7gi?Ry19yAnoQ8MNA^?KORa%^Y006rtjE+y0+Kr@6Vj8*BOn(ZRb}=sV(U
znV!>MNJaeq;C3vD{yD8t_{@mgU#-LPWHRw;5+c<QRZc}_^$jUoCw3+GE+;biay64h
zKdGUGtuAlZGK3IicY<y~<K`2&ZI)J6mi1ptQ&XcJn{O?{Bxi^1+1x7r)H;c+BE;uy
zOTLrt)c269d<DX(kTuqOU5yT}#Waq&PFlx?XHWl#DwJVk422IOTOHrpSk+xF^niBA
zzsM<>$QZmIho(T<V6`@o&VAVeFOo<tN)29qJ4Peeg-V4E^UE2i&c7|GB;DBZ%?@C-
zKUG$3);O%!@CQF46AyPl3*Y;Gp_(DbNHd*U9=fPAiDw^m)gAx*36YX&&rghFYoUmc
zM9fwx$DtMR@t){S+QM2=WmY$m^C*!X%NN&CI`fVjJfqmpW_v^ljg7WpV=EX&;7C<+
z<?F>%#WKR0@c3~F`|psAnFqD?fNy`A--PsbNqGIEVCAyqUoU?vX5(fWj6^<s_3$LF
z;BNj7|LTFLa4594)d~Qrxl|(*o^3ZK<4K7ix}Sao7dQUFm>6vy6FzMB7z9q=3CO@O
z2DPA!xDT4NQxePTIIQ(HM+07tAD1cEQhBiMvk@e*D?<EXXXY;`MXA+Ggs8KIHX8?o
ziZ<Eg&x5Kzg+OAkc^;MbHG15IE?!BcXACK3D?aoO4vJH2l0v^+B_bQ*r!pn!&omr4
z$Wl+*&&)?Qn5MHJ&6F<@C3|@CAIn#J+j*`pV^{rn()J^Sx=rgL+`5^Qi2UyN#I)OE
z{g}~HU3Ykg->RhaTeS$Y1xfO1j#-JzZ(KiQ!5-Odk4`BkVIw8xky@zVAD1WZXOdWV
z9ahg*q2{z^9Q3N~zLF2eD=lb%G783?H~Zg3^<6puJTi&`H-ja)ae=v-(%Li8*Zpc$
zN_4QWRGxd9R7=4No>B4wB5+r&+=F3SxoqofcOKB6Fk(h5L<cb094l)<uowQBz<fuk
z-HkCd3FIHsG{#zHOAKqIaH^!hJXP(&v@+I$g*2V0Fp@ppc*>&Jt0x49&`VnJD?x#S
zy2B4Z7aQL{C0D_-9@SwExl{NAHcb6pQZkMvbS@pQXPT~w1~d0oq(<%g&L*Ph$+kAL
z{m|FkL`eYwV%vc`qVcp=ZzZvb%{fHQ>Xs>r6e!AU5_++hqARg3Dycy!7Pk$hCjaA=
zoaDLk*;YuqjZ6uzOU^Ol=)aOV-_gLzdYUr~Qu_{U<3-YurBbjw%E_Sp^DE}PMwxis
zDrCwI$-2SD7={4kwCd>Rpp;J0*itU}ZXR27l!{}5WA?0^9LS$@NsBg~%C!H8WNSj(
zeTk~H?iw(A)LnIK|J3Uc5z2MN{rg6SWeqP!YC23ZYGo(K)^~=lxX~$-+$fO_pRz8J
zfN=;7GaSvIjCP%;bin_Gp8l<jvxf!8L5GI>_%Na<4PZQs6A6R*Gu0!*d>XEmEq?-k
z`qb~!gu)8P*wur(u&aVZS>hoCl|!i9)l%T~dtYp~vSc-_<776nmrfIcz;K+$E<4VO
zyJY2QGQQD>ZjTMC34#`B1Y1<e@Uye*B;~HhHhLN)G;p!1e?JY2-$3IiTvmi}G)2a^
z2t+Vwe0*Cr$qBylkySo-hzgkH!~9Fv{JKlHl-X+3>HC?K)b!CUXo5v?h(jp7{Apa{
z5B~5qAK4VjM(6By#fpZ!sO_5*rw6VNv0qiI3$JVp-pJ{W*CG$Y(0Fx#z(?|!?}1_g
zZB%)TiJbrTT7Id`IbLi>%UQjf<HBF{T1{p=SYxoHs3<-jmn$7Tjy#}g$B0Xr@Le2k
z4{E#Jp@N@<rhSFsA6<4f9n*{^3JW7MSyK@O*pgJ{SPOl>+RjXn>9zlY1mQ7ew1uNv
z$Z{#BvKdsE+EdzY0dIGh$*VXWPH9baK&z5Kkt>7tfkXNSaodf5!x*q|)_npNPMI;0
z6Jxpr{!9U#MmU|4HZFwjx{=Fu{WV-o8_FjD$_C<?yCcWkYqd6SfQvorov8Ep7q8^5
z2vPy=>f3g&ZcW34ydM|t7g*YsBV|JB&K^t^VS+{iK=F}<QTFkYQN6=poF_l6)UH<>
z?DyOTV<;KO(dj#Tf_!#o(#xZA5(+PG1)g1C-{CFrOy15BH93)93wU~!LN}^ylc@tr
zjcPZ9K~ioOI8F(wEAbE`i8fSjCxUOrNOxd9cNe7l=`zcdR5{y2iruWPcs=()Q7;Jd
z=`yiZ0?dZZxGYkWtjI6!SGyuf^PkH|Z8wc9<Y+(?wss$@+EA)?7Q?7aLcZ+IiGQV(
zOGr7P!yGZWM?@xG@2}a5(x^X*zVq4b7j+;;rDMq(>0&V&=p31sOXhjGcnIS{Q5CKj
zTDsyiKvwbkp-+-3ZoXLOg^5JmkdY^|W!M`GdxmkKp$a1hk-Yutm&(4*`p2zT;eR~Q
zc;LHgLyJP{al%Y%k4F;o(P-s?P!lOFJYvy&Yin0$k(e?kA)69I+z5OZhL#0mp$F#n
z6ULXKdHf$rrn^$Pi65u;kPY+<)-Tx=DiPnWXhaSzu|+}ZU}8R`NTNiItNM%<lN+M*
zEBEhqjX+O&m#aNF-`s&%>acgq;>g{S$S~xUUl!@BbJ&EzVH+v0R1F_|>l9TSkN*@R
z(yAqTovSzos<v1D?$~Z+_S|;(7>GKiao}K=3PR&zJIm$B&$fgE-cEQ#^7ma&nG>$5
zw`2FWOm)&9PO7XCOj;4gIIHZ{e_1Wu|INz~JG6g=<}XyjBiM9oomVU)#$$S}P)Gc?
zQ2H`#9t(bY%fx%BXmBZ((?E7u_;bgDPH%+q%g98r66*$JSa$`c`;r)UL-ktTpnWY9
zrC4AN$%c+vULWUMqhy^;qS)N8U`37XGsQ3ss4xxa*^ec-5vQbbha{fmre_9t<$P;d
zG`(Rjh}<nBvV2i`E!pGJi~4H0R=;24J~3&&k(jz9yL*x&JuNdWg^*zEXIpt_{Yq#v
z)dhVM?|KcCw7Wk5NOPN>og7E0qlTL#I$LmQhToBYXTn9eI!q0FO||Crqik&#kcZ5r
zF!)>LHxD^?e=Tl>dtNUC5=-i15RNcPw9%FymCJD2NPa2g_BUD3A&sFQ#kAKb0H<wA
zsVMW=z*S(rwDyF+TZLOTl$1V0T=pOnGjE166}(aFO|MR9cReItItOFnPG@O|CV$^A
z){qFs5ZH#1fU2ITa4TgrW@sGBVXfyWdS&+TddP|4%J75})p3$(OcDNP(eutYDo*$@
z$P{$kRQ>&VbfdN0!%Bs#yh5WM_R5r=bzikY3-+XC2&wKDI2~L8*#(t!+y^O+ab;tg
z$<&0wqf~XQc1ODUeaDie(1d$bKhaxuvOje3)b2fP+;_~@kAFV1-Y#A(uK1yDCs-v7
zB^uD$L#TZZKx|3q<dGe8#^(V@^pjleptj-2%BG^a#ZBO`V@9~i&w$zz>xK$XEt$;~
zmA!mz_{a@XtvV_}K5NV%XO-9(i118`u~@A{R~i_LFV-h2tBWE(&8);qUZ=xvex-))
zQFn9Yc3S7eo%=j>X7|pAj3i6bf0cY6&<evVziNP|7{m8>!J}=B6>PXZ#(cUJE}VNi
zcWiTg0tZgPUB@<Xk>0a4&(<z|^+RHgvJ%p2?pYdxHWqiEJoL4#CuHj?rz?k4!nGcE
zPv$jS7-jn9Xb~G3>pOG;?ib?nb%!=*YbWS#U)Z58OF*Cf%^nh@^qR3S&R<{sy-^<Z
zUl9?Q4}Y96&<?N1PGfiBHD^8FR#`FSO?+LCHoGR)7u2M@c5W?iZY9A04N>q87V?yO
zCFf&%A9d&P-DlPDgtB6n5nS2U6A9|yI(3BA#^V!e!bNo^40s5Vi<A`4@1pm6=2{ad
zEf~mTmcqVA#I5@uysQHOtc5p(ZH+Oq*?Q{|E=4v7e~KI7va>96iOxIj<Xe6Ttttw3
z9UG%Zf6}3yCBV?X<g^d}^{~md)^0rh=eR4impdMt`pSo57X~s<sqB`?Y~1sDR@5@C
zUrLN?J(#b5Yav@nF?LEpg8ID06*^t(mh}$^uN^x(%f4dnw_=TNEdqUN2b9zzA89>l
z)?TIT_;#0GPS2{0Q#hX^2T^kcTu7k7p|ld-ir8x{vCAFgZaC5XTr-od>DfTvE_}!X
zfpXIHHKU!&2<lM@vt5t<t`QMY)m_>}veHvvWV@)5Zv(O6-wisBZ^mC+pD0X8?wMcQ
zDZ-ez!!?DdD`$BN&L7z(=n#Hi3(xY{7}6ehfcR%kq9hR$+Op+D9<&Fn2ZSov4v&6X
zq(f65lB0|7r|fqRBJOT~&%~!!lpZuSJ5MyDW@Rklblkoj_16u+w@r^%b21n>G5jAo
zhLdAIK_7>YyET%RKnEy?jt=PV@gDD3o=t7baPbP{0_u~u-Sr2y3h#qBjayR8?k@KF
z@Lh1OC7khdy#}G87VHw@RH=*xjy|yOu3|sfD?5WznUBVi5ba`(_o#`CZ)>0pFRHzo
z+&)Jws?bP<?ieQ18lmYVuMTL($k!BVqY{DMc*4kJ>thE6TQa`&1dkljGwalt@Rxnj
zB?z?&x3TFOwTD!5s221CwB3yMT<x?=e!`!!`UAzrH&90yKfxM*%0hsQ*+)gn<2B_I
z%^QQvCfWWu$=hJH*x_qRsEh`u>1Ywog;;VSwU7Apbm)A<SfQopa<hpkikzNPB8jvs
zG=RXLaLj8W@!`w;E*qbNIV-<2kuf=l3JU26){Y-ZioJ9xbWsT_S-EBp&|>FL82CU?
zG;KK}6Q(AA+KJUw2Po8KG0hU5D4;E@J(fDE&!_q=1uF~oCf;A{baV|MWpq!j4<zAr
zFY62eiW)GTRELO^m?gyG>hKg9m%A<=v5PxBbXT5I-@04d-WT*aJgNM#C@j|!ySf9@
zxy|idx>iOw5TsAEGX%((!+;pvXYhUQ3bTiWz6fJ}baP1Z?hT2#IMHo!#Vg^EopoH1
z>&iLgD4&NGrj6d-DdCq+Ta+s9rV_IHQnsErf1-f{C>n#+Nhs_{C(BmVv4(g9RyiD}
z?+6mg;xms<JblH#=szgl$mjfi{zh3DCftvy_1`WK^xl*TvSm(gAUjmx1YabpqmqAE
zKHZfr5n<Cc40QQXZCvrdPYiD(K-y}Y=i&gA<d;km3~_P)Ei)#;cX>-RpPWQ{j5WRF
z_OmfLBF&0RF10^AF!*7xf2ktZ2gswuiiGpHds6bv<L@3{D^=~bT2%-t17zD+Ci<K7
zYgmtHxX19<O1lfUU;0QYnxuP3k08x=WonG>8h8`%Y$vYK7zkFEhDT!?dC^tl4=mDa
zcyq@W(;^5yDVgG2Iuy8I{;6y+sdg(R4bn!zkJt(H_&yekEdEcWEzX1k-mkGeJaX#j
zz~cCRAaIBhWc@xL(OM5A`%d2fycZC$H#`11{4hk5o;FSSU~eyZ+>{_+y!4Bpn}s+|
z&4_oulAe%}H`ws%*O$pP`+9~4jImJOJ@ZEt0>bS$ugl2eyl!p{0sNwMML_|V<J@l@
z%8cnZ45Bmg=mq_!*WH2k1t;_obvsF{#waEnpmcSj*6@JG8rI^1LsiBPH*oFSmdlKk
z-NBY?t>tP9QzuwxjU$<bd=bMYa~tdc@`a;P51)A${pLE#-4Qb1qXmd>&Pj1%^KJ0;
zNT4q%68QK|+uyuzshBpl)ROlx+G`ru_KilXGRU5!?2b;{YZbmONS%y(TI|F^$*|-h
z-LZs73*^D6#ZXkORAw6qtWxTE-e9H6>9HR!YafbHIKaDtP<scn<8PZxFjgIpmsDbe
z@*@6Z91?Mv3nM+yIb+31Y>*aZ4^3U2zoGOVl`B%8#Upra50|#AxO%>-+wJ)jM~P#V
zc*gkQ6S&`^L5%CE9W+W(l34<X6{%W4zQ6Bfykz!#r|h#Lm-8c<=NWJK{E15NfVj`>
zPc=c_gddb1{k7uJ^5gY6-=K|YlDI8Hs)vk{gYT}tC9%q}=gFr2`HNFtxKi^%+~}k+
z{+;q*;c4+37de<E4|NB3wl^4{xJZ;ObYH2q<}?WOEI%@)4yJzEXJkx^0E*d80(g^`
zZh&?~NuypQbJ8Mg=5^baM04h(RGC@B>7VPu>*fWTDk_7msiB|YC<pb4YN(hJzY+kN
zitu))G~b1Bu;!o$dlkV4gn-7SXd!!>y;*Wy?0~^{g_SUtRH%or>^oOyx1@4Rdr2Nm
zWy%ad4gz&kfSmbn!Mdv-a^K!WSC%x?n(l!HhU?b)fNE)~_ff<4Sq|W4@>Nu(=Le=T
z{fD7(S|W+IXcAAfyxZ~MZ%v_ogMyO4C?(F|!Jbf(lor<b-_ouL{5<}!VA~fCQR?4M
zBhYy_2`?Vub;t8|XA07#4@^kG^5<<LWEj16VIwRU{`W453E*hJX71;BEI>`I(+U-e
zUEZrEB-<gS8WjLwJZqoeHr`>1?x<`wR%%$t`SLZ<7q<fPak@PoM-xti0Vmck3V}dS
z3LbUKiDD$Jzpwt5r&w1vpUo)NsCMM66vt(A{iLZpc3hddFNc;S^<M}<c!%+NofJ~U
zFtgIQK6_RDz8uHlPr6Q!f&#mxxXi9=e80xFsRfb9$I0C9CIqUDHk|u;|4~;F9iChM
zfQ9s!E9h6~Krzj1hSbe*fB4W26&k*7BP)8(N@c@S)N}1leO-8R)q5GMFNQjsDz!NG
z?@rDg5xKNs9M{KRWG%6{W^c9s7ka{<R5-oTCg+C1(h(Xr#$!{eE>0eW=;=H*01M98
zCCb+EMI{fU0Uc|2!My0B#QmxD1}%AgBU7{bYCGMuYRV<!5gN*}-yebl{qG&(;RN#u
z*X?!d5bIBrS4vUS>0+E&Q&qeVcS)r4cAZby`wh;apvW>rKp{_O_gOoN{L(~d%E;~`
zU@^>`JiHen4>DYy*lZ@hOJo|xmQz?OId<mRyZkLpO%k)VW><|!X{b1d7^*Bc->g_m
z5i>wfC*((d8C4;vW6CsPn2h^NJrJr4p~(UL3EW69V@9qQp6t80VlpZX@8?UO5{cKm
zkk7ncNV&$b4ETgRLDnhZbeL_ihWz8w+Fn;ZAHqAFQs;GwP(bY1{=U(4J&J-pYQq@n
zm71?>h7!si?%M7lI0}{eS4+RObHOLl_^&(-GCkOaIjRmYFg99c5(}v1sVivlyCX^(
zCfiQ<b2$kwEXpZhJ~D4AmBEdLkC#|1c)GAv9HPRtCwkoH9IID0jFkb?bXjt5%~C$U
zf1)+4yrZCw+n2>rovhr57;yQ_<pnG>nxqa{-u~-D*?0jsQ!q%IN@a_xsJ64r$~mrD
zW%oQ89JJZ%qqp|#o4E~ojo&uB$nYHVN7(F+JgFg=VwCR%NUNcB%vMc0S$si~CzIZH
zXnDfd3igClp%x*P{s$WI=vuLEv4q7{)%w@-wMS0ck~y*gk>N+Y`ICsa(W=!oyNhAe
z<As{hwQ14NhhmkV0pPAuN2fb8O+5E^9RbZAIsbPwgM;C|b23$*)rM2qa8x8cjNW{+
z?p+sFP)eStPcP>nY!~>PwHvd~u1s$7HV8=2;Wn8C1sr-TptuBT_W>M2)&jAoM~a$S
zu@ZbZzO+npxEN9CulvAP$vjC3<<fVte`z4SHU#zb2V(*f*K?8&@m^K*hf7{9CY{UN
zxO~o4WMk*2=^lEWakM%pN(I9ogEUy@4VGq9p3~M#Cd>4=pB3u}_}b=}{hTWWhi7z?
z8WbbRDzF(cA0^~sXeqr6fAGtQsb|#NAh4K7QWf>60z<ybn{-v7TAR5jbSp^C5b%Hi
zI>JWqY<~Q{akN6j9U?*<Cr3en=?C1ucVF0pez^5K4W^2=-_h6$l;QGbi9cu##d5*0
z;;n9tB?u?%4V%D;umpZ>m!eJhnk3a+5P6$%1uV6}s65+Z=54>9mK={yZP9HFhB6@%
z(BQfaiFfd*l{!cJ@05*v;|pU9hIQrgQ&vaHyxan@`Z6zE8}wxTH?-PZ)8T|`NxB0l
z+I^~~ECis6irv5ck&9e=J`_R#Xci4Mxy6NCd7*6?(jyS-P@?s%t*WDmpuph_&18j_
z{VPA2ezohg=kfDdlJbkyfDe7l-2{D30|nD!tj@?5Hvho6WKg6dh&A!}x6~D+$9*tw
z8<oHFAq;M25)Y5HvT#Gg7fp|c%K(L3RgGM>$X8Ra({(R{nbZBi1bQKXX_#U8&u-Gr
zfN4;yj*@J_bK)#@By>lpxbd`@ZLHA|x#W~bu}&dhl2-0|=(K0qna?$FBhmVzxyZL>
zF>P)!-PpP~`<_?Y(p0ZibfQMB=r@{WoM-c!InlSWKg=q&?5Rplu){3b@lNzx!x0>3
zwPQFjRPd6nZs$%?thQgb_Oyf-(>klEvO5<~GXb|_mXlv`p!p^|`J)=cbhIAvqP=m~
zeR7Yh&eKY>@f+ML<M**@nIt};SD#<Y*(xhwnFK{gYCrn+Y#q8rmeK81r8muUuT&UT
z`8nJ(^UY~=+P^*`p7zh`wf%|!Jc;Mc$~L_<55;9y(VrE-4=~J>+X!{PCDvG8AgNNz
ze`N}c!XHcp6u&bMJSRQarUSlh7FJ<B&35=pNB#su?#|EXYD}y0#Q_>lnC~FplM_+*
zezubIsrBYDC@?%RMsUEygWsQAst@aZ1~b>K?H`LJajHO(L2<{dxNStCitVN<BG;@g
zw%hwR{iV+T_trM3VGIK1a%0+1uP-Dx?Z-<%JXnmWMdD_5Ev-^mAgBS)Zkg&QH6Lm2
zCaeMsR2#^TfVKyS8ueX;-u@0-UWr{L`akX5FD9U`baHJ=VLkiXiSXrUZ$t%KQf0o$
zb#<O@oi2>L5`JTN>egsr88CA%6bIAm2(vN7h1<uK8kX(!>;zC`cYY!w!7gNa5w&<Y
z8I_TRN=KyfwaU>S0&Mci-S5YExBp-{95nKT*k&&&pH+t!v42j$?0j=k>{tdXj7aG2
z#_G1wLd(31Zi86Y02Ld%MNImA{i{0+#N){L!|m4~2K$9n`AUF<b}4|djePDGG*zR~
zSl_PxlP49hIASC%&J4H<qqZfg9D1ZZW$jU4bbRFb@fR!2VOO>Wz4rHH^g;m>!xfL`
zgkXB}4v4$qIM3opGm@~)n~*zliECxkb_oFzAY1RNI`oyO^oU;4KfRtw3L?C4<WF&K
zvOquRj4J4&kr66qq~V_N20VXfs?&0p#yf+rcThEjCsP#a#OE+C+<XM8Uw-{)h4anC
zn_H7!dSW7<!HoP|siVvv-29lltcU7>ir&mK5uN1s%X(PI`JGdpVMm^Ig`u=)<9$OI
z6R;!8K6zQ+8SJr-?`MyFJ*OjwX+?q~9r!V?G`dIFKLe^E()KuxWDlD*pAA3UVZ{*K
z(zY`x28m()-3@yZb*umKl{GudE#eOjdu!}eJ-g*flz^8s>(8jcKr0Q_EEBwBZ!y&S
z5b3OlC99(pB!ZME3JIeizLX$>q08NJ)1x?4u2XERrq&KJy9dYJ@RbZs${<Rmf*Y|S
zMab}(r3QSTT(NQdI&P(&(9MU9vU_(uz;cn77?wDXW4Slg!~d)}bx-tJ(Lr9Qt#)lc
ziIOMth0{Gu;qDw4t0;rxqI;e1ca5V1uLo|TUfa$~0o=IRRrtl0fhVZ7m~x)e0cv8O
zAyV{b)r3#^@fClJNCWYAK!sBD^L9U+oj8_>+w(g5Z7!KCP#!7_keiUohDUce$2H}k
zjf|pL1P0UlY=mc8qZ-?HcV_s5o3?lnh)}E7cz|uvRR=!5%nK8&Y~7n8AEeB3F>)B9
zZbCp9{VB>b9kbm!r3^kHx(qj?J@O&X7#kSF2_$H$xy(OZswdtOlihPP7AP?f1y)S}
zQmbhjzO8IxKsx&Kc%U;9-e-tPe$AS&WGbWU4=f9kv{=MCeZb}1C6+)~xI6K<$Zx>B
zc^J4VwHSqU9HsEv9}_|7Pi$oUf|$G9!qzKjE|;f3YCC|Ga`|HShT~TMYRs?I%CZZ$
z!(P25Xt1Q>s*mf^O7&Qp<nRCBHg&*($luxs3u1DHb#c!RGQFG;Py3AfltDNRJa?gF
zg94uMxb>Vb^zOB5_k1z<qWk6D+*|GgFhh0nIpQik*3{N(?fm>%eB(M?!T9Za+J+DY
z@&5@g06GQudoy4s-yR_f?{@XQFf5-K9IM72v@T;vjf(lB+l&ie$k?*c+o%53c}({B
z<A|(vRYF=e2_rlV-sMvz@Ge^dgO<ug!n6VP4W=a}hS7xL2Oy21B*kI5JpXv)oKz+C
z_X6@efKHr{Fj{NX^VMiPEulp7@LK|78wa~}a&InHOpneitxiw4k<=mz9$R@h;?dpa
zSnAz#s~cqK7q8cxG!S6Bgd9$c_gb08M@O{;kosrV2PWY1j%8}|YRG=qs{vk#Y3v9A
zs7#09PqF^KwFgS9;p>~2VW&T3X<s$5R-YR7Xy3};kf-}6wj7PS0I_a_)|?3WtsI&i
zPIhqGZkqfcRC3M3SHuf`&8IuwKoRP!8%*gpqS(U{!Uw2Qxd6Y0naHL*?$&;xxFK3@
z?$g#36rp;YSY&ZEnjbMA$sPZEC%6i$u-M%J7H<I!NQ$QG&q!PhawVxW0)L9)j@VAy
zf&)sTW~PerJ>AD2tP{1w(Kvb)c<-gYC>sceMrB5XV8q3LHx$!DLFK2ZM}sp%GCz)`
zy)eakd1E)|i|cSZ?Erm%;3!aJ9N4rI6h$HldQDeDKj7-2rFzUAHjI{uQ%pq_%GgH{
z68#sjKQbGL7sk1*;N8%7Jz5suBjwI3=T7~&<(w~{A=;4E%LDf5c_sGlq{SI8j8XGU
zzL!cK1319I0t5O~>3@2li_Ey$Wm$Fs6ukx%n0rVK=gO|ZRQPoD{=>F5K|)Vup*wxF
zy$3?SXrfX5nFoExlYDW?H?CCs(xHGu2Vqe`AKhNJ=D9O779S7<7iW%?flQpIX<ZXL
zcTb~vL)DJHcdbazlwUxqy23YNgMb3ZJW-`yh}q7`P*$!xOw;W(R99nDLo(18E;l6N
zj^YmZ+L1IQ#6Lsp$xc-hfv8wUd0A!L%X_Itslk<;=~5_gf+!82gapPORVM4DScjCe
z=piG_YX|lwc3HtGCDTv<Sz329rq;c>G3gyLr_DjD?JjCQQhc4lkc=^P7Cmc`qWjid
z#PSl2vg0sH<>h+Q^GiTcDSV_0``u6sn9^R<=Fvkp3`j@oh9mSigU;G1JcBE#0t5x{
zJYR=-e}SCn7nXN-6HLN-xW>fBFGtwNR6%Bugx><PJEEAKxne!a4S>VIn_bul+iqz-
zG^SP9qn+a{OG=6}_qVEEh1EZrv;DG&CC?EBu#S6-omGfinVv1@di3P93vTFj?Kq~v
zGwz&k7~mg#ywS;ky+GCsql)5xQ~ke|{(tnOHZb78KJKY*Z~72kdca3+n8GB!_kx)*
z)ZWE<p!WF=*6){5xu6e|0m-?B!-_irM8k{WX1@+_cvtf9Ti&Z#E+U|1caAY2!QY}!
z^QUETq)w?P=m15GAmoR|N%E98ksnGeLI`Lr*elnIq$4Me-qJ-x;#b<85xcsol@t%-
zc+E6Bq7DaIp`)H{4p(?*zbawAiM6{t-R2irO<92h4dF9bxL=A^Ls3BaD&G0x!N3V~
zF19ZVQme;P*W_yi=ZQj#>MQOnVtmPSZz@gm>k8))v*WPj+9%9l@5vH1r8w&32^%lP
zIKxmUf`l}#8iFdr5#mi~q_nQduA1}fgS(c7V;O3**(&D4FQxt2FmR8-x+l;@1PFu7
zhMQ@i^UK?9H^naHK;IwmqU46V*NsO51aR2pJ=q=ud8E%t72mB82%orv_eqETdgj_}
z4&oLSb2Y<ddt;S33TB(TJO}?+XgI3;DYyM?(o5VKgW-bQ>S;}=aMwfmMWM|AHrxC2
zq0$BH&*$^do|^~rFEbejetTyIm+Z9Bx!*YFTl%8CI`e~HUgq*e|7z7SHuWV;TtJP5
z@rpefWu9->rRvMh`e$R>%@s<+GONeAOMoYnyNQX?x{UVI^pU?}KPw%9*|~W2#<gXr
zyV4d_rzW0o?!`gff%q&3O=;8r`g&<!Yo_7}bg>kX)a;2#Te_?VOY=W&kYY@_NFAd`
zEd~xE#7PLEk@3hUe30tR1hHCu)}q}>OsintpC2GWg9M4Or_1>+PZ-#;KpImHrqjYe
z;3ju+gO&s$SkRNWoPUab)|gd2`6{Y`@v5(Zkw@n(j+$%E*BKRlP8L$9!TgA28A>q3
zf)nWVj24c>{mT3+DsH#t21i#=zyyo=t552q=Z_3#w#&*6%oyobPv|?okANNef_FqX
z5Bo%`XgeGit~g)TCu5O?HWAh?;m)0IS#`FkD9xmoD|DMM;cIG-WyFl`eg=b|{s}iR
zU*D~mobA~Qbn7d<*lEsD)~9Ln{^JS?^hsTOBF-SOV{Q@k&C>B5{j$_Ya&o|y!<K>y
z2}eUV7whMG$EvnL>?SvD+F46%UzB!8BgiLm*dUxXyX&a#6bL92O6n)~R@l-!Ux&{Z
zGvYi<@l*MrsjJ&4)RJQD3zZ&)wI#${9Ypuq_rqaobEQe+d7^mSL%hoG@lKr&-xld`
zp{QA+Co{~}YrUj;7kSt7*u?zD4zz*#^lfDG2gj>&c|oAKyN1CXeU+OU5kpQ7Hw==!
zU@wx-veErwzWgCM3BYWf##A4RGG_Xsgk3W099s1=0P~39Mk%Jt%OT=fA-FNhy}gn3
zHd9<;1E1F;c!c@zN0+rOIEEz-VZa-HzWE?!q0!L8k2K%jl4ZJY%Nj&lB!<R&-FZrW
zZ+cFln+O-_#$M<#{Ysh5Hl9}d;c2mkrY)ELO^T-WXigCGCEY;=74G-M+HE%H2?KyX
zHnA;jR?1#QWO5P!*Vl#;pDRHymLvC7GXtbr<+~HBd|*oGlObP=7)AD-ii0(EK9Jwi
zXnT`TO*2|u_Rb~bHZ1%nzU4cFvmRgnU%#508G0-G{xbqBCf+}EfiD&~2c#(Y7%*R%
zfmZgnw;xps{lARgd+ZX)e^Ug&THbr1Q-Bg1?vutMN!L#fiulMHwP5+bNA9T1t1CjV
zkaji_K<nyui{q-0i4{-{k5<`Z!Veh$yL0K03!uwYzBmN7F#Umyov-#A-gP}Wt?d8=
z`b=rFy&woY-72x0XFt$kd;V7=9*)z1n78@E>9Lqs{;!uuOaKdIjYb(%;L-2Crwwxa
z10ZmdUi?yDER-cU+p?wk>^xP3PtthI8BE62&GYtxq1@5os5LjMBWf0iKh)Wq{f#Xg
zZTb+5K2HdX6S$p}O$9h;mMoxz?_KV02{ZWIecr0<Sat~n_f+9H&A$|_c1>1TBo3Dg
zQ<GHp4u<r5ArHE4-Hgl!6Olu0_Sy!y6FfX(`hySsxtsz}d<Q4j@*jK9OaV&wZF^Od
zHswpONhalL=akLyN@4^Bw++O&ba5cKLDX-yX%*s~Im>i?1liu#niyVzb9}gBD9@c~
zx0xNtO&u|;EIuu%$Dgeu-;MlNc}U&iqL<DHDXHSv4d904MD~B>dT&#|e(?jl`9TRB
zW>UwoJ|K2L0Gi8F*XKA)G?faXh$BOVi?dYzG~l_^@dryXU5(fvYpGV+gjM>Qn%J8Q
za%P()<qnlR8byIrq<bREgU<N2Yg^qx+9_P=_8{Kg-9)gWJHloD9(}}yc`|X{lEFVw
zzA~LNqhCK$e{Ogt)w$~S)v%`L=Nx?)X%8390SavNtCJTp?l_tATQ8Z*GVLr<S~s8?
zYcFz58{1GN!!Vnd+J;#|7O9?(fuYc88$4Cayxj*n#FFFTEID1aHw=V5+#d5%wF6=7
zN&IDoN5c=B?NX6>&Io(e)akt?y95uCkn2DyhggB*#Z8E1a$~AV$-U`B+lP2#*_$tO
z8tG3z3oZm3N^xtKdz3^!N%S6<jSlilV(YdGG_b0LU(2w41(uiE@&8+166B-V#7v~q
zcm!Fn`8@T#{B*1Lig1{7Y6efMP&jn8$;DiF1O*<$f4uYhyvUf;u>>GEU6xB?o-4O}
zY5gzrr4sN}K%~m-*P<NC50mb`QQ^{ezNnzJno&jx98M{T&@9`$>2h1S`*n9}nVu-1
z<f%+=s-}Z*Pa-lGgu4g;ckV57mA?%eclT~>mWX*_l`}32NL4fMaxvrhIYbcohd=n&
zFQs#$v&9Y$iCkvC)GvKO9nv5jz>n|d5B_69n1n0`sf{DY*-O%O{|%=M-$9AJXc$Ol
zAwMOa_0^y(5#vIjo=fAH_|}3nK&&aNz72s1Y5Fprt!{w980g_8rf<_b2MNAT2y6%U
zr=L*Z{}UAQZ_wKRD&7a?J-~?!#tfS$qCpJ~;@$JDEgVL)NsKWTUFdC0Gx!g!|07!;
zGP_eSD@|Pn_-?>=54Y1@i`!Ac0%oShd_RG!-r-qMk2@4g)it{4MPk2OE9$X}M^A|%
zKL_G@GU@3d2Q?j3nr&c(<F_o7Mz(RC$WUiFzGydnaeG~39;N&fwbar;{CQt$7(n_c
zJd_6BwYRS6<AKBxG6#)7B*QH~hy@zy%$NizX(_f^2L&$9%s-BS5+j;jBtma$w|+Rp
z{oUZwJTYyy8Opi-oj-q|SQ=7PG9?fo4fA9*(A-`LvWAtjl0{Vz|B2A3(*Re7S5T%l
z?^4)J(_?HQsA2=EErpl<Nthy=ze*>U3{~N=Ivf*O7mqvgXS@tZyw**b&w-8?IA6wC
zarO_)miI^Q<3c@L@`kU#IG8WC;mT5G9Zf%BTpz82N8qWkFHMIZlrS4U;^p23n*{@Y
z{>3Z02$*Q%<XppS-^1Wi)GAZ1AR0jd^*ueiJ+R$}hai;3BkliY0p#~Taad(|htv1?
zs1~c8L~=War!&;Kt=9l(k-&HwuX@!Xaqf;@^LCghA{0)Ym_yIR+7PomI!M<VQTX$L
z%_W+ZW>S^ku8m1*VH7rW4Q{gF5r0L)-Nn3>;gyh~Z%zhd9cRnf)9$&zPF(+ba_tlB
z_e?2<D7_D;67-m+PrsDPmqF}_<A!oT_RlI`88@5236u(=7Nyu*u`!<HGP|&L;own>
zIuPDt+jMC%pqHyYb9%oEfg-*a9r^D+QA{cMBZUV;Hvdl!X98{u+S_O6$-GbiB{(qB
zs4?wMIuQE1Ti`UV%DBxq!Y;H38%u%c`lcT#&%bs2gLsGQSY?hJ!=KGroxSj48L5l~
z*M_w8f#yShMgBH@dR~PXHH<mYp;u3J?@Yy?;k@F10*V^#F1P?aqKO^fjDQalSKa=I
zuS(K5hKcplq$?rdLTQb07}UcLP}*Tp=JR^;y<L7a(dgdh{}_{zFJ}5Su7AKwR*`XE
z#BjN!dQ8vq9%BLO3N=9f-+}-C)zEiXV3>Y~l~hm*V!?RV<$9{+bm}rw(1IDFf0p|M
zOv&eNz<`W@l7d|S%Uf`I4fj1+C~9P0mU^5dG~xZz6S9oF((eHj=lDKjFoTC2jfy=o
z&^lC}q%6-imUe%x4Wyw6E;88Ry2VI6e38P|f?}bso4ilo>kyS8b8a6%c784WGuZ!k
z#2hgwG7?xwEmj-hl?KK^-<1f59@^IRRuMqBDumgXk5z5}TyJAIwegyKO{K<+SylBb
zU-7rbn;M{fUm6sMK{kP`9@%&qU^X7LsNsW~#sLJwZhT90^M40fI4uwe*3kK|#;jS$
zDD-VkXGBIbs$uTVcx|@rw5_a$Dfn?ADSmMAK|E&+YY^r+9jMc-OI;UdIh~fU^+1DJ
zhZCAo)4rYKAzuikAk(7xeo1sdFfzQ;mh+a`L+@D!r?N**2>6?+i5xw4lsn|Q?hzWv
zRv2r*N&Zb9%CE9l_n&-1H|A~#WBtk4n!7E$v^9K8&&UFiO#Apy^cwHEQb2S^)#~rt
zHY)1Jp0CIN+C2tdHmG*@LWuo#d13D$y>Jo&#3-nap{nLfp3d(pvQJXy27HO!eKEI}
zB)E-WV$*P>2eA`t?v(WpT(5Iu%B_vmZxE_tbW2e$Xf~s4Rw3}ug;L_eT@z69c|3-9
z^Rb(FF<CelS2>kQzMP}M(VlR_hT2%k+U<<{@6f%nD<*TBLVS|bw3;D8MWj)O`b}H(
zO`(?@wweNA8Dy{5X+PTNi0#8Q<uX>LHZgVoSjYWat)ZexUv`S4LtNL$XkDL@rtK+7
z8R5!|7Jkn9=5gb2c3D3%3MPPnJ{AK6r&wj7;wGqYD5l+nd0+wT(es2!bgXdxTr)rK
zWRY&jEAH`fuFd}+Yi}JERolglN{n=a2vUl42}suf0t!f{lr+*Ior4OB0!oV1fFRw{
zEec3?4W%?gNH?5&p2z3?)bl>?b*}F^|8P0Zp1tpNul}vI?tRiVY}CB?xYx5Q$@qXj
zrJWH$2QkC-O~I}BzB5K8HS^KKHKsdrXDnK6);={sQ3g%!q)5Ht#YcxcY{<*S{LdY7
z$Rj;V*xmE9^VP7_4swAbak=ANzrdqU0;jd-QZ!<Z6-Az<(ZrL4_z<i;1-Rc07t$Rx
z3|6=4{I4&aZBmbV_qxXY`f4=I``(oHCPXKWp5FSlxx$cjR{VLocX8l|b;5T>s+K|a
z!{ek3>D~_2v3md0ACJ0{D=?9s+-CZ?b5}#e2`qXs%SG?DxJT}nMsCc1vw!@w`_a99
z553A*H7LpHHEk#BD@@iEpc4-|ex+vj(G!`qsTcdn*BrJ#jdNV>^UwbJDvp#G_|4lz
zz;nJ6dzAF_s!2oWW9t068ZxoduE2d~OR{HZjg>M_LK?5`i4GnpzyBhabNTFmR~;9<
zL?7S-j3|7-o~GpXf5!)kIZ$>$SD10i0_6Fx(-<D?_8si^gL315{sVhfWmMr&`FYX<
z*mIm`xJxn(e&b_A$0Y=B;G3n(6_t)tZ7Z6(_&rFKdNdY2!wq^@2J312_Vy(FhT``3
zXkFE_%gxbM?kyfmf?<ns0t(DtS^L3aZfY6yp{e4ym*nPIvWUX`u2Osk^%$wsx7Wtq
ztV~s?H>!Hmg->{wI?G-uLkWdt8tBo<C8V(2L{)of`WpRThUiN3;*+d8UH;tq@_^Uj
z!POJ$XCLWqI}w-ixi-fa^*b-=+hbh+eoVGQsPI9>CQ`(lpHDg>#{NE=<PC>`hjr&y
zF(OT>zcqDZdUfy9>OaG#qlyj;whrdGd*y=Pj4$Bx`%%X#s@aHZU35HBPn|Yh%>4OZ
zYr2*qS>KMo<D)V3pO0V>wYXw;>jNj`B4+&+`BoHlNV2ypt)@yrsTD4x5mQ=I-_d;!
zkHEk^V&k<W%iGN9)ICOeU!VKh8mL*J-`J3|>UTR%Tf>yY6>tgL<R&kWz&MGB<@Dh6
zx@C>bD4BXIyLItnR+jiw%J1_WJo4~x*yoeNhIm4W{n1^<!I7NdYhY#up!>=Mi51G=
zv@%=Lp@q%{n?uAwuL}H2f_<ulso#@mk!q=WGnLvUs)X6`tcL}*Z{2lEMMM&otTWJ6
z_owzSPE?dtc7^orSV-}!zv)JsWf!zIw4Jvi=@{f)LS9`HtG#w|z`9J<Q|Cp?ETZUi
z(Q|(E0RZ9lDRujos<OVasnWi?97Ej@;1#aGkLdK*i7{L`FEKOF$?^GcH$?o%jT)4U
z#{G|8_!Az@nD?Hn>F){p7M5zY_t!mq<99b%kZGAJyd67+ce8NDf3nJ_^F~(SdbLJz
z7q=97dw9%Rf{=*85<+P6$G0i0$!dRkP)=*&Urcf;5dJ=H_(0Zve|)jKG|C2tP?1!s
zpjJ0jdf@dfpl7OYSxTjwNdzlRsb<`t^CJ{+@ZT`tQt||uG2u~dDBY+{lJIW+5uliJ
zAkn#B7dWw)_rfe^=W4~y;-K&Dn1H0=IF3y^*M*8q%`TfZu?X@&dHBYAWjSKp^jA4w
z<c&~+)Xw+HUdZA7JUR2X6ciRjfNGB=fXk&_=SyRtOD{RtpRc|7qFs&Q`t=BP6x#Ki
z)apti`F}FlPKMXrj1tF`cCDjg4`*(R2OPW_E#SIJf=f>3SLK4=TdAV+@s1&{(=?}E
zsr}Q{r_x<7%56-SoO5-#x_V-}4VbU{UoIc)9b)6)^&JrvOZ{5?;o6~s-Oxorx~+OV
z_q5FWkjA`;8|HG6;+kbXM2AOm8_IH@7HvOiX%%~Go%-#ZI@~hL>dHOorvSm3Rzu+9
zX7X?k1%{skHNCZNNXa;D)63vUPeAEIYBYll`bgmyw+j6{C0FJ(Ib8O?5*SyOJD-2I
zegBGE{hL^5ftTE=Frd?`>kAbGJq~4n;>?+Dqs~(Kf7_s@a?~*!qZO&|b?IeTg(LMG
z@320<PKK*@OBC$$?PIfmEL4o2)Inp$i;h;y2z|85Z{2M(>b*I&)do%_SQE{9tNa%R
zz)G@gSWM^2-1*RE!g=SC$FyYOT19SBY4`0rFEdk_=GIrZyxh#*YwwIJdC$THvrQU<
zZEIeT#hIShZI;mu%g`A1i^c~&RKH*oleVC&U(V4ETo3d0q*qui&}1%<Qwqu1_u80r
zzinscO>Q&%kTMrLv9mRdT`)2%)rqdr<B4z0Yn#E+FS3fwk&fS2LewX$UaqR|otI$K
zq*+j6%B#}icZ4x~ts)sL_B}z%u{|(v?OJ*BiKE(Rss8af`}FwRd##0dFEFEVPV}tr
z7;L2GCMdy6Re4)poEl4f9-C7t5X*@Wv~)-o+vL&itu9;hwHj={kkBlDlvM~MPBT$~
zle+`8*Xrk_#Fu`<fd4sVk@X3xql-!t@v%R~c)Dsq>1lA)^DE(&tPd~nZ-93Pe`C8`
zeG7%Ld}<|AqQuq<YWllnqMfMXO1449ch4O{(aJUJH-&1XKgHJ{^J7HR<}@Tt@6Ctf
zjyKr?CIO3v4SMT_l2*GnIQ37RZcb#L>wJu8%~COv&b#ttFP2dqN&iY*Q&l?UXy)QP
zls&d)w)siW-H%FV1=xw9v!vSgbg@!1yPH8j%H@YoSp2eI^go3@jtlc>*<h-2pCal6
z!0dQ5<*T5Tp)!hq0w!w$pS^7XYApxz4C~&I%xhMk7`-)oRbFT-2|fg<m`5^yt_t%S
znVGkBeW0>Yd`pO@%pP^7x2M)oPqWY(DFg@^4*v@|d3}_l>v(5uZ}<zK^dE7(Bl6eR
z36r@5KMUd4pQ6X51$~CHKWrelAq&%1!?n~!wU`-B1)H6rqwQb|2djY-_2@(ek>=;0
z({+E|wd)2-Q5Jt(2}hnvxYFrx&NL(6l;2wJt;jamv~H-c<ji&4O7HfTD7~^x*&gxi
zWytpWn=;Kz6VY$|Em?J3rB^EKlV3evsXN+Np=o?7SYXNNrErr2J5fO*QDL}ONMW)@
z{pj2UGezB@=Pj@K!_I*5uad%t{3r-13#}J)GRSy&`+ky8v8UjCauWXO1*5f=!+xRg
zCsY6R?e4ci5~u3Z>-D<2NvdNkpKW`5F5cFBU=@>2sY~!a_$Is5SJozMObM|@b@U}Q
z<C+nmqiLe-9h=3S+CS{z&yRNmQ9D<vKh$t?Z)M>NAGzV|(_kCyy#*2~+%>$9Z@Z6B
z`oC29MlTJ@AdbCDH3R{(QrNxZ^5!6C$0qInJK4{dVeqgQ$~Tmt-Y7BuhOBh*IzOd&
zCqQK}OjDRUS#zIjsL+V;!u-PjWM8T)sp0a)xo@9#rTJD3o9j{g8>7R9NZQ)xBrS`2
z;?uDdEcZ8Fa_SFI?Vs-<g+4lpV4|V*8hI;SDKHunUmX|E4QSAREUTA89=l1;kw&^I
zifu!i?yluUMsix=F!?NJZgE>sf#OO*B4IE2*EP|4aPkI`ifJk_XEM<C)XXo+B#|gR
z6JPxP3LWj|DMF<0{+scGGR#h(w$BdH+n=Ypve1nUS^BnkB@}Ww{E=`nObcjpM2K<M
zrakJSGW|RG3JecTFj<ZKx5?=|l5a1!DAakMjTE|teML=T{zqDWQGRe#&N7u(>-Uno
z2@}`mX&e-d`DB(%IQg3kkO3dG)+Xp!BE(3URUVFtfUcJ(s`OIh?mgL}3B{_<7XURc
zaz`!a$0`9agkoVvcXa+@<pZ5HrT?ZQ*q9$t%e+FOu6tv4Jr=#8fs%j<H(eoXCXQ7W
z&9{<@OElfGQ%AdQK`Wi9;|(>+6%H*@B>oGS`xiCDOeF1ZMI=fs4tOmt-(7u!sfv+0
zxB3NH_30df6&Mlq_W6B0OinrIq*UAurrj<^h5%ds$jD_1Y(EpQ*4dNqJU!h1fro$F
z9}-j-%^jMNLaz@o#>S|_p;AEjo6PW-5!k=5D-?DWs1~?lDp6jwUx{tH7_TKdWDPry
zoNLt5SQfyk4<$5{eiK1XQXE7<0wE{H3wtO{zsGZhlT{7^QP<Max+6!9$9{!eU4|#^
zfZ7M|=|xw_)TGfyRPDUt#`gHqv&u5DTCtOq`*e2~YoA;~$7Trn?T;`8gW7D&vv6#3
zVl;FJB!kiB^6%FK^+K@850iwmc^-<%O218sg`V+Rv8wS?5VK;h7G`dx;1aX`(0X<J
z=Z$}P&g-&Eu;3*Bv6s+?;9i&`sd<dQFXB)&2nxH%f3l_M0So?tP0L6e%YMu88C3e#
zKC43y>eu3fE)2h~>;IOD*D<ddkQ$mdMcGw8y@J9TXwf0kQ#rRKozO9Hw-;O0{|6nj
zieQ->R27VB#F*IR<WG&^1b<w8P7HRFXkoTKBqi;k|Ek6dQF_)sPqQu!xKwm>?T%*8
z?7G2&jkHTJbfV_$h~G%~Wxv4YRAc|ht1t{23x`5cTNac0^3N?(2Wz1(dGbRefuEdH
zouB-(lAhkv<M&o9eStm6V1-Z5?nUohhr$`?y=cPz$CFe5DZ<jGWatq2AgDBK1(!Pb
z_p4{kfnZ2pCfpumVZM3S);5e+R@$oympuC-0gs>jEverXTyVj&^u+3Wn8eUaX#e%k
zDJvA-6gg&yixvs!@ltL@`(x*%*}+opiuI^=kMNUceBjoG1?%Bx!qDrlz6maNwqpIE
zN$;G1egg`J2R+8@{<p^vLm4apJx`T&T^X;lfji!;jZKvKeNE2bCQUfFiJWL|A;HVp
z!u|Z@Ns(mPL;||fuCAT|9goyYNLPU{$kc~cOZ``3{-W}ftEp(>l&fct_{SZ<3YG^$
za=$+Z+X`$;^Q3QsldqW!L_k(L>|GiZ3-`wG8fNP$X6rK?^26y=4sr&R+GX?G;QqUK
zUq`X=X3d*KY<+O?bwv5()!#1;dIBU0i#W^!{T>buyIQdp1lNqI>unl1MjtK%=~8>R
zbSI4%o0ydqGr5cF#_ziKi`>oXg4+iyESh0^q1YvREB6nf!z=)*2wxX%ye;03O`dUg
z_lOF&=c|Za96Df-5~cH-U=)MkyO`_$gF#v-1}Un#(x;&qbo(T>_74WNbA$h{#W5(w
z+{K3gRRsmwPc4k$w5|9M+i<9K9GTrSC=k`_%NC9#|6STp3~EH#B@Q7<*(O;)6<x48
z?eEtz*q{{4Ve}~TTLcW9Uzx$wmP@2sOlo0QNeB?a00?2&MR)iggv4MTY8$ZbF&~in
zpv0v}wVLq{aajWYpHy2cpvl0S77T<sb~)P%2akx7mQ^_Gobt+t5ghU#Z^@a#`kv)f
zR_p%p>t8;e0tslM?=ZxG)d8~F^Jv<x|IS6sM8KJcNZyMIA-j-ZVH~2!Tj&rgJna8l
z{k%eo_4L`Zdt2YPT$lU$UsurwPTna=XUf#slP@*vz9Hg&oYBjpU#Y_{;&EDRk0_a5
z8vPDr@-@@z7&RmRKu#{Zk#oDca6vmFyPt|qjEmZ&G)jL@A}crpu)f`D#HNOKdo|#c
z=#a}87i^s1dt4<|x70r@!!I8Xm4K!-W>gcRdy_Dzy{0Umm6Q*~xr|@+fckd!_4f*@
zvGu-#xI+ZPh5dJq4W%Y+2bWCh+1NM&Dm!3$kKFWCAI;RnyR5h^^?cn`HICW47C$bK
zX<C0}pmu3$M9_LYBK$@Cn}ho6HAK6me#0^eBEISFuZ&-Wg~ff7ZBtTyBW!*WVRX%M
z;3Lc0sv5K@6<v1YDi=kEE-$zD+93%QzvFW$p3QPQiCgp9Z0dEdTpAb^2In(z4y?ou
z)`g_lhjWMcE0D8&on)KQ(OD7Jd2N?}@)+9~$Url~^W4T;2hLy&!Tl7jM1A3dhsUBe
z8%g+Mms<Tzzw6=}m53*I%b;vd>Px_Fly~^uQvW6rbSU{Jezl5ys0}vFq#Ez@mx&4o
z?z5AF+Y_ZuGt!J&a4EbFSM@SNSM8+$9XG4)1Wu(mu41rLRC}}J=I};u2kR%NQ;$6R
z4@tNCB*?l3+Z6>6&243^`j+*s-Y@g!!zzTv9DLm-=1Sd0nQI-$iGRd5J@++<Kddrq
zUD%yHUTU3QC{ps>6OF`Aw1BuLK^Qw???t6ym=xD8_BQrL9pOn<BIMD2>SeG2P-^Fc
z)FOjaJ)kXxCb{Qllq}zDL(ttk&|`5~)LxsMQfniXT72U5a87o22e-S4Hf!A{s>aMT
z-aqi~U&@Zrk`2pc!(?Pk&v#2!kz!Ja$oSgIm1lYGRCdZ&05>2Y`mTtH8(g(xBl^4j
z{B;{48Ynloc7^&`lQ&8+H`TFqo%HK=dh9YRJDFR%H>dJsA(|E!=duv=mSot`xqUVr
zbo=vj&sWVi7u^rmXRgo9P(Qj7uIf3lt^$Y4CQc6=572omr3lW6j8}PQP6^^RGr_Hs
zvL7&w+wLwF<Sop9o%P!BH^m{>QqI5bIlUh<tl(q$O=`ztgJ^KQLj9)&g3VrGP$Ql^
zTSAUl1J%j0Vtsy#+d2gIQ`BF9h4?PCUbH(?7KzMX`P8MkymFC3E7s1rcqp<xjYCRB
z6>CoGW-Tuta=JfCqyJ-Rbdgzd2iQ0UA{&}N{QYlIB!Y@VXq?BML7PzKvJMY@An4Yf
z#}^nz(HotDchsXZWi0no{5@=8*c4U#w`OK+Bx(s?<GuS>!i}^a!Tf6v7`Q94m(eC`
zB6nTa4o#`}Hyn`@`IuQv!&4hER^boy!vi<xcuNE3`0@;2>*6ZGp$E;y&E}aFFG}S-
zm$&X0)di%|=<tYIO8@O&VSPaNiADWaUW)NzK-ASs*tO_#zAxN3W=S+P{nn*6OXc<U
z7^`n#pu$r1g_zV-!rWE^F8SNhBZqG^M+=cW-8WMIqZ_|Czu(9Pmh2xD`x$^q!6`>E
zMzDaXc~I$S_0haH1!KF5Uz3Sz-5H8l=xI8I-Y)hTKGvvLl+dr(Rvpi?Vs$p0d{ik0
zL-(J4`&PIb?s5%S&6v~5T}qKemys>km?z4!HFQrhUCui5b;wwYSx+mr+l%j|TZi>^
zmdq(=safBxunPr)LW0_JDQ4zj)F!@dsx;j?q5lM(#FM~c2G?HrP5IEW-o0<c{zjd5
z2?LTK?c{F+p03%b_0^RR-pl$TBI4`T^Eyo2U0&Y<hxp`LA*G2lf7j(70ekTWUib3V
zw5e~J<co4mZoH%KqTxs!+I8kk!2{M~@)hI126Q0OVgc$QvQkV0gMy2(9}{8jA0IOv
zdQSFh0z>0?+hVlvtW_EE=#c{Y$Su#yi&*(CB8Fqh9<|q4+rROx;c9@N!#0II!CxmP
zu7CWj3F^V+&d#Y)z-5xKK92~CzC|H8tn`*w6%B@7>06<gIpK=jYbhI^sW7kCQp|ni
zaBx%2`G`rE8ZB5L=i+Mu|H_Dny>3|crIzGM3AQgUV@m~*b`2-}SM$2UPQZ>$R;Dxm
zyZU2SF#=ah%e2Zs%!*oI6p!%ea9VJ{S&h=kJ|$K7M73KgE=3(97SUy9ty#eL;P>&v
zq@EM^;S8O5#RVj+*nW{@;17Kt`ro!4HyGIJ;66M^C4o;!uzL<0c%vl5XFs>=2xlm8
zSSl$2bUy~T;gj2s)oCntU+C@Ak1-KV@vEf254&o;eN%0AF;lKL;?{hGb^dCWO7iP?
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%0Adzm7s7*Yi$K0xmCZ$7tVe*WCPMnevn)eY$EDg
z!kMuA)l6r`1gOL)L!{cfA$!C=NthK)`+)Pm`iiBi)PU@SS{~A$ARhts><qWJ-Qb7|
zAdyfjG6yPg>wuGtR`quP%URKym}oMjb_aoWZ}z@;J#6XzH=tal)Hp*JR~~t5A}_9A
zZhYbia!CFDHML0CNX(t*PP?S$M4%EHK#m_h?hEb(JUO&u8?*<q<JvYGPKD+3My%<F
zRkyU%7w2}ly}YdO1gbQP7T<)LWoI7iBQk)2%^c*=)^82@mOV;+$Q!y~|BFiJ$O^wr
z1p$Y2b)#xEyZZo5F;P|J&-W}{ixi_z(7LCrqXU2O=tjfdG%(?%hU3IHd&v@0-wNhn
zU2HMq2IS?V=4!mCc&IoeswwO>-H8BJhyQO@hX|bduc3gU)WbGCnHyVp*sG2|abBKE
zu|DA?0huOQ^`kEre6h;=4KC9eXUJ#rN)(bSX`&Q+Ie{`jrx?~Q{%NSI;NjUNy88n}
zOwVV^`W|BRxvE`PU^bx5bmw)>4G|R`>jwqLTXXSE8y@%ViNX&X;32Yq5_7MN4csbd
z+wJs~e5=uWMt6R6Hl3F5U<AG+mQk#{E6^@?%)_L+M-t`t@P0VU;&`}uq04E8+$f%m
zg@jtBZtLN2U?ubqUp@A3;i&4V;3`ojt?6`C+toF@p}2m@hk}w#!s;1Zg|5?{Tl1*K
z4sH<16fcP6L_vJv+angG8S56KqlArM^_4B(8HCc*Csyt91*5q*G(&Z;7=-dI(@t{!
z^|Q&7z5c)gCWA<FYXHM9Tk1)nKrnF&GG5IG+;a2x$64#6RTc@mnhRh=p}g+#hdzzR
z?_1)fzQ>59&85CAn^Y2z_sk&C@<%CgIUPeQKV6E)3hN(7(l>csvPJxDcgzHME<Xb!
zZ~HV?kZRhB{D-)Xx9KMwMi~NZ+-CVoxD^=o?3T98)3sb$SMm{ng629+`t`=+b&|tm
zt~gwU68M_ItQqnzTJXr>KVDk|f8PBBKrrmk5Q}(JGW;wJtR(L6zK{DjhtpDbYlYZG
zu{Mwc<W+<`R@bIGiSCxq1LEl1Flcw7Z<!bJv~07slG9VpH+lv+?GB3M;OSfl6*!-@
zGD@&(R)8hPK28$8PmY0tS_1Z<vwPQ!`+&jFxk|F;@e92nv)q?&VcW(pE@|fjH2=#X
z0*7_L^*4%|%paq6EO$r*<*<;WtA3sR3-I64s<NVE97$_1kJ9-@wM5Yc?mPNol^~(?
z10b`$c}SD`p`fMOJlH<1`e6kTK{&9yI7E48j(rXK(GTb*y!*e42IHbCOPxXUGJ9ua
zkTc5$<91u-OUkt$kL@N7r5(1t8gVl(nzzzy<n_ruIT2-N>myr5&1TvA?}QKj#glKe
zu>VWr<blDGmts76`qpPUUTJg#D_!O+m=0Lvbe*G>cY0hA1$Zol*zLE<wu`&8JosO_
zrv_mA>-f^3+F_XB%GC8J>~z;v<Ghyuk^npUSb8ndGQt3$Em6OmH*)-^L*GXBGuxm6
zAlIkxMfkkc<sp;%#33>mlvamy@C>u0iO{$FOX1Q1j&|$41y+-7XjZB{9Io>e1c9_*
zQthecugU$D<of~lQJK?SJ+QY<?%Hv`t`(3sz3^*9B#UisHu#Ttn$;R0qjpi~{gIQ2
z2cCA1Zu?t+^8H}?d&I)@qRF(y+zp}Sa!ckn3e2|-c^-S`RyHYVVjnT6i;@^b`c^4_
z_(CQ8cQ+#+HZeN$N6JjyqO7%DKSlA=5+xK#fK<q(6gBy5)Vz~39laaD<al)Tx3onh
zv8*Su?q84L<&RpDFOR{vI7v2k4t@y<dFWX`#9U)?(9YHYyG7MoSrSeB<D{6nqH&(K
z*b<q~p(IBHjTKc<<)D+b!<vU8BGTMB#kGpf6y2B)pcg@D(#?2rxk#H^t<?c(ak(?e
zOH7jiyrOMIyGj_;GtC;_p{+9U<8sRj1Q~s3^6M9C5ST2CrEzzvKG)enNv$xZ)!_GM
zun<>1Q2O^|2Elp~uQadV^BqocI?BZQUZf@~lUBJPmiE5j<xYb3ahaSCH^?<2r-t_^
zsFnoA(CS6Vdn%t`9~1X_U!|AWy0Ihs;DHIWJNxldea4&v@D`b7z~%2+Wf>c5r#P=d
z9~pQY@uy!dK1Bs?AOiAdJktHbKY-6{H+g!y>YKr~63!DIyM)D)(4M6M?d#`SC(&AW
zoL<&8^%s?Ci<qTU@=}Rj&6<u~49%Vb)!pgouSt+l+!b<$@NXgj_&+l1>T!n}YN+2e
zHJu==p4mpqC0OeBiY9%O`V^QF@^_-rUrIP-W4A+TDc4XkORXBh&?ZNTsfpDrF_h~j
z==UnC>4s=o-w%OgeJkp(amIV)avgtLOFd`wM49%YxIHmR+6`o7olgO|5eQY0;{Z@?
zTBNQ+cp@RTxpyenGWJxrvl}W@LG??l7nGrxFX(L3ilAAEg@V!$EFU|>rf-Ii4=~Xz
zVw4AVuj8veFe>kZQNI@9A3L}!h%|zP5>Cp@Oy6-bStYdFc;KVal+5OCc_TnDk=Q<f
z{i|pGQ;`uwM-FQQ{s#{2tF~0Td_Eu>aJF3H577r$@aZDV^73kf0Q7j!rmN<9;<V~K
zQh@CDKXB8gm(9YisOV?c_TO31fAdmb7I$=cu*qbshT(iu3vA6Lrd)$wZt#K=leN^%
z%i#}b@PmTip?Q<}dGl1zOg2cul;4g?7{<l!X8W!~<iUP|F5AkETD)bDuyf;U9LYv9
z0BJd*dipM;MY4s&%-}VO5Wn?abh|Wmq<*>FY~qz^33vmn&X;kb`pEVi6R3TMzFlPs
z51<uZ&cPIZyUY_V6eVO>J;d*IPvp!BeY%T$7WLdqqN_-$fGK_8G#w27r<>*tfwRT)
zXolfDWGETHjD%jcJ+1{;V-gB@{%BGMO%*Pn-d~us<#F2SBHys=G8;+^H3ADr`o)F#
z-+f3y@xNwG*RFwPD=Zq&L+{D{ws|gt0wuwU(+A89^$^!R8)harUVgm!-gFyj2`X?L
z?MjgNSQa`X{TK{)hhxmJGY+@m*+vSSeeN&zCW0PWftaflM$>=J{FQ^2GzS>vXUkwU
zxwk1uN1=AtX4m6h^cxn{I~a4*+^rAjQzhg6Y0zVeDg&#61pF1Mu~hoJZ~1(by5*J>
z5WTIg|128?+~U>2#s9)ZKkb7)zkyH*RbyHKTC2n)P80x(b88x_t)#!6%5FwyaUREE
zTdkVomD<bO4x{>o`4URxy$l{7?_&56+8rq80e4hnc*2NT6u_+8h(dQ|p!v~fGTgtJ
z%>?x}%TkY>XQbWU;Fn;pW&nVD5*qg?fWzn?F(Jn&n4waxgv$jM@NzrSk{Spw?P=oo
z;?uT`Esy*+PwroU9+RfTmS6-MzUcBJ$LYEDaCdep1~c%h09BjVZkjb>2m~n#j6x~U
zn<xM@NA5~<awl-4=vDFs3L&K|Ivbl(y0*GXWImkC#`JfdR!8nqn@}BdK2Kw#1|;Su
zsUlYG*s%Uo)zeOX<xmG9q=>$s$(n50F#0_T8CzsJ!1IRQ3`HfT4R;VDd@oi7A#O*(
zaHluZ4%qf|_uz~apO!>&*v73Kp6NmT+JmtT@b&agw7&G#V09(~d4oju^C5tFigBZf
zuM?kuFYv2Vnys9)CXtAAs{}o%eU@Xay)V`jXiYhjzB_@m{0<L)(;MoNLn>x+op?n~
zxprs{3``d)Tb61SDkbsESS>K&@+SLUu-*ZZfwz(BLslia90&A2D}H(h#p`N$vouXM
z6(XJ7+EhiM0~u}Z@7&(^e5Be%suTYAUI1quWWgRmWee{)%m`MfLb*JXSU_cX1%erw
zKW?SX+yJ)sG;&@(_^iY4-9gv0TXs%PHRMNI!k6UanmriEfUf73sKpk>hg+;7vXjW(
zZl`Nx_iz_U&!DQdzbKgv5^0Nnx08T*0tH}@czJL3*|>gZh=zUVyoyJq&XAnnJ@A?k
z1qqs2gO#WHRRp4?I^~UkUWTz3Krp|R(&(S>PZQO>L(wRv$$L{MZ%pUdj{hqCYlOE+
zR&PP}MeZn!6&N#LqIQ~ndYehDe?7xN5UoS`l$AW$8LckIc!7(N-TB$h_VCIjXFjD`
zj)X4HQUY881X`@U*0Df)6n5XaV&iq&$vY~HD^n~$hsPM8n-&!n)xXTGe=ih1k2hAT
z=~00EDq5%e43?W6{KKsj4~xH<COCoeomelebEiyeqt_|i4ImB@h8Z<o?oIT;=J{6U
zdTmRooyGY!bmxA*tO_e82?+_g&c%ao{&=&==_yqwoK<>%zfky%!FNI%9aO5p^_xC|
zfWLRT$jRnvkIb3RIoCW<Nwei4E;3`jW0J47b~3M2{NC~SAj=~Fx-W`_#|_QWdv{cO
zqjA?`D5DN8D=QhT?AOTo)99Z+co5LFy_kl<?Zd-KHui#uJmQR$oUv&mC_V}lWfE?G
zTn;7Nr6!Hos*~X{`+YI!%z_&2jLSBc8gR3VhtBR#SG@|0gJT%Fv<Pbs6=M%ptI#Hu
z%2r6W?>(>g`uXQfRiL;uQ|Gi)i5MBNkWU0UuS|>1FMjVh1=)V(F9pNxd~INPOiRPp
zH8&1X_67~b8=qY@2e26Po?rDNY?nJ<F7=?2!5<uVs$Ot~i7z*@p$P~)UEf5u7=52h
zsPKh$5*$|Bj^uMw+DGOu6ByjlsI?DZnl!tnQXUa@wTP!uP<*(5Y?pcTxZ2|?)oAs7
zejFt=IeucB%D4G8Rjf+zTLKdx3y>_A-2*!VMmN{I?IuRe%;4Y$nAQd9#fD9f@Ptmy
z%GTo9BsMxo(4Jak9}Q5kr=prv&*+&;?HoH%v&w4&J=PkZrU)2>Xmt(GQGog*3)(Jz
zWdFl3f4-hT8H0uOevn6W>K^@KY^1pm-b@;^SdJNJxL_yi=+_+@GTuf@8XwPbt46vL
zWy~YKM7`J#p2A0F3=WU)>-S6VcM0dKkQdR??}DxjZ3A+Cs&fW6d?spB_|-MZF$a$f
zQCxAHoYTeoiG^Z1b^bVKJn+~{9<z1DWXn1bTwpz8(P7t*&hlYlqqYnwJ4vovPU7S_
z==7!Nk?*tT?rrwq-LmD}Ao06=1zT8nr3yDpxuvGni>LZS<D6E9;Mi?r*q0`&-Tj!o
z+CtxYhR0A`o!8C0;|p|b48NplObM6kS422?cFXiXFX046qx6sSrzc%ciutGcO+$W=
z8gfK=0i(3%({;&=BepFSv(5K*IZ7>slnPnsw%ayh)^d!c8uj5MFftqCz7${bGl}v-
zSk$V`Lxn^yNSf>%4Gc#u2=(;lE~gQA>mNUGlrHy7hj7dV$yT&wIL!C&<}YV9Dk;49
zxX71PkQZM~OLENd&elBi`AP1UuAg__WpD+@QTmY69d_{5(WEA(y;o%>p*_M+=kpA2
zsv}%`h*Pik*i7gBJw6M#-LJNo12DJS)adlOsp|sG7d#MXpS@dG7yog4e3NAb_GU%|
z>T4OzX+p!ABIC`ky~KRv3GwLz{)2pofLCrfPl?)A){6s<qmbM=rI#w+nk76BP0<#r
z;|Mh%I~fm`uxj_<XE;J*CiJ!ven8N{Mn$JIHQ7z6Glk`OoV$I(9MuAWZrt)!5B-mv
zQgG9GUHu`N!Z-Fh6ecpsOAc}@J8{<9AhcUy+Y9t}%T2><Mi-D$ra{v<+JCy~U@8rb
zqnPIq&W}^-VD<9&1nM7QdDxHrUI**7BhA!{sN#x%ZLZCgKld~6MzX0Z@w#2$ExqUm
z$ZURVH}CHu?$%rN`sv@QYoW~MtMDlSXx-4N;>$I-Lb=PAlEP!swZB*z2otHZyt>(h
zJ*NwJZiRxxt_s=OL{6G3PICy|__}{zRtRu}sZR+j)Q&z`MM3eDjE&xsovgV2U>jtw
zcxHa_U=>@cG^D$^m3mB?KNTf<k3WGgPD)nWO&-D)%t1$N>7c)ePqh%8FK6hi&F`Q0
zA%nx&p8BONrf}URm~Yl0+LN#!DS#raefpYXTQ9qGVD-@5XWk*6h*#xy7p>8<{D{FT
zmb%bIcFwGv#{HSj-a%Typ<zDg!YlL@It1f8(?b=sg2vh|Ec{*)iG!oPc}Z|z4?j(u
zLJr9;N>V$+@2!d_wNO5*(K1Cf#ryJ6!lpE)7b_f~MsGxn6mPwq#C}IW7X?eo1LR{;
z9=(_*P#X8gu`+G*e)^ZREnvoTZ4*t0*%27JP<LX`$xFl(zGpDQt!5$`gSkwIh?B{k
zo#x^Lgl*gn3eGKR_;Qq9RQu?jp4q%kckkhlVrBdUY;CLTAB@E#B*=j}F<fM6zrfbd
zzp+-bD4eHsRP%v_m{<=Pf6`15ojSH81lab0+H7O=AjCNn?;9}KWN*?fQ1^7z@w-w!
zYIo$e3iBEH*)1H6;;NT|a!oj9Vx^07#SYi`X9S?ogdt$-NZdNSO%x@+qgiROcA{&?
z>-8L``aI@<%)gr*=e5WCo1N*9801YqpeXitVQCGXOG#<%MDs&SJ52Ze5spBe!tU+b
z-TpD$N_CWQqCibePsYL+Bro^WZ}VP62T8@Ik0CqLb%(On1Enq_SC?M?zl&b=0?d0z
z%|^BewssEw5TiR+?yAsJmcNTZ2~>~H6wG8yUC&xt5$kytV&sB?x>vocvczvg>uEte
zGqPgt31K!w{VYgDS?}lp@#r1+tXpsQh|+p+<-5{9V|AAT2d;<zsa~Q*YG20YL8(v!
zJ_O^H`~b6(K`MjyrsJo0r$`!iCw`Kcr@%MOlDZ-Mtlgn!aohaa#UQpb<Q^j#ZC@nZ
z_j|`ZX>FJc_tL1Sd&gZkwHAEA6>UAITh->HUVSMXGwWQ;%<$i+uiur~IgMu79Rvp6
z?#<phE!DpW8aGwicGWG9RVgEgM`jk!#tD?a(tZwm;*e1|WOq2*b(Wq><-|u+q}8rP
zQ+QQHu`1K;Y+@W2<{95T>_GcK@Ir98^GeIL5CSdg-xi<y+$1qL&u?d>PHQZ%=?A}!
zQYPCS$vN-gCaXWRw{LUc@a_9N_eZ~wt?6mf=@w6XAMTomLknegN-xio6&G5Y)kcrx
z6^{*{w3DL<3S<g%N*kMz2}3VN=n7&2&1Wv27Z&!zHiyRKngiRdKL2Z63dwB55`S5!
z7uWCe?vU>Z(kYS|H0pz1j@Xh>O>N33&U9q<gTxVJciJmiWNiG?u{@A>j4HJCv<!T_
zgWQ(N9otFfRC<CDry%O9uFf1>P>j~LoUiLg>2MFrN4h`KJn}<3H71~8LLq9!$(9ji
zg3jeaEzX6kBYUaJMzz#+_ZFI+uV<W%(_9Ix&dlw!#WS-~CDXjttbA9U8rN-fiZ5dt
zHC1JTxzycJLSNXxlYS7Xan+2t!=mXUs>aM_TJ$#va3d)w%DfKXYVXW)4h{3ALllj4
zdz8E}S(l49VF~3wLu|N*Xh;XBqSi;rj~8aePWel^S7$Dz&e$Cvcr8F+c28c`TPVTo
zV{>_<LGwV7fT3tJPKr4`oLcc2HJI$$m50qEgbBi@yITEy`Ks)t9)6AJ@2I3w5AIB{
zw)#>1i?d~QWTKQ9lEUdiQspd<O)Y0k4Eh1v+`ptG_4=(@=mZ4bgaNPKZceOaXxmsP
z#e?`tXesPvi$S7QN(Xo^ml>-$sCHW0LSKdV?^(3nIrerTxzc5xok(%m3sH>^PTNwF
zDN(+s21VCz*g-;(l)2M&aWb4j>KG=3xt1JO)RJff_wr93*u9)qhKf>B9+K~j-BwXL
z$#JLKM*XQ~U>hZ}CA^-Fy#WZ+`l?$nUK~sescTV9fSz+zX4_5^n{D@jD|gu-20J+`
zlesje4@hy7sXoXI(xSZOYCeU0!4{CD?`fDRR{tn0b`9g?!x4M;?B*2u+Jc5zC7sNV
zVK|U5#f9&s^y)ArvVW`Vm^Zh2`E<+h%9ol<RR9T9vcS=iiQ=*0(bnU)M$+~ox*+Re
zuGMUrOZtBESfhBRR9E(_F}2j@HsjW1bfxa8{S}(&Jh4Lj1-I;oaE<Wi!!<N@(O1@t
zy07&1Y99`#I<1CCXwSb$K1|f@!oZ=Z?1gZsj49r(ihFEMUjq$mZ-I#Qhn>X(OE_v8
zi!BIc`;~XEO+6uY{<nyrQTF890lQhFj*T!?R0CfsN6U#{IOMNrk4fYL8u~Ci@AOYn
zk>I#>{-DoXbNPU~?tDqZ2V^%mc>Dn-FGLA_UEOf*GF*P5y_xq+&uw*Eo)>YDP|QK0
z*3wUhv?OC$Y^dH-Z~I0}t$4?_2?+3c?2XA#s<ASlq0t)ZfxpIb5U2CJO$RjDp!&hb
zeg<YR5-;7CMx`4jZ-Q8O0F5TUBV(v%Z|rGnIysl@<zj%?&-Jo>-^~h<NyQAV!`Z@I
zmo|3ebJ?|4xB<nJ5H*v@??3W4gkUY}nCIt>dXPzWf(sXK>GhsxlCo)yJ#ni-Tk6;o
zf>-#phG2+ITN8>DTfve!CfuPb>{d~Cc<mKiEh@FA^PcTM9s8F}NjhB+OQxwjwMA%{
zpHsQp5CBdzT4qqW?vQ#{CoglRY#N0?lx7bd>}=E+*!{zM8Af@{VN6m}p{rnUKNUe5
z*Io=nz92`zPbe_&fSke*eLob6%`XNE4@`mT40s7o3s(<_8(J0RKFeiE;WKfxF|@T+
z6nGwoe|OhBn=Me|?eHoUT7_H(Mm%q-YM1k=EG&-Xn_O`fY1L)R%HKw*tC4~EtO*`t
zy_xBM$)|Vl1Zpz0vZD4xu>WROh=e~dih{skw9AZm6rU?A<{(}|8-OVS=Zf8#pT9<q
z{aLaqPEM&DhO2-r$Ikk6`=b_WumU%Zk~CzPn8w#`FO7w)6{Jr}OQqzj)A-sJDo^k9
zS7XGp!O7{#LH{3FZy6O;{I&}VG9WG8U4wKZ(kY$N-QCjNog&@R-3^k`A>G~GIq+`(
zPn>hs`*A+7ShM%+d*4_7gwRhk9T9*-SRSzdm9eRwEi_?r*=A#y3{yt=@dHV}u(KJ5
zsI{Rebj<3+R~!~N@6QhV0*tH*U1&+myT?BnB$#c>_e8K-biE;v*s7_YnGbf>Tk+65
zjU*LyZJ`oA^g6F_C#N>w8_Vdtv!3&fLZ{rG?=o8@Ka~L*N!CLx>cQ3F37y(NHHL4Q
z>RG=EBn_i@m-CUwQAPgdXjO?3zx~P_;dCh`YMO}y286h0C;kR?y7irPGvsX18{zHQ
zAf!4~LV3Y=^5R$sNgq$|j?6rHT!0)5R?#4$$<_`CD3aGBrHK?aup;Q%W{*{vDwljA
zp>_y;&)Bnx#t<bL(kDnIjonj=<=eBw<Fh})ytnb|#r>b(O{^%R=Eivil{g6q;$si)
z;)37^AS8@VbN3qc0sJFZ1c7`*Pq^FFS+SX~T|wcDKMcc0<WDb7pW0=H@a8dz!#879
z`HMAnY*xgHI9_gE;|Z?)Ch+uXjSNHJZM+mp1l7G(>z7`?Bw!pfn$DLhV<$L{`||Kg
z%nA=wq%QwnlwCRw;p3|PBnwEge_qX3Nwc6`kJKV4Zp7dxX~5N{Rqs2+JG<Z|y?l$l
z|Me1Lg~TCp>dtvN^ak@_%g{skc?_=cjou4*d-a7?D%BI*o(lr3U<-2c_OVFEVx9O2
z(Sv03i>UT@R#k-@!ux<s-S!Z%WsMd?*8q`G+I_`6vp4LpVH0-fQac(TGigF#f|GwG
z5K9t{4=7&=#{_*uOckkqN^*cEJdGpsPT+QZp>KVLF{=(Cef}(pjS^UZmQgBZH03kW
z%RW6k`Qm*><KjCn)^x^^9Wu~q3SMfE1Qtb<?3GJpJyvmr$&39Z@U-H!KghLu9kMNy
zsoa|6BGi<0Dz?1r$2@8zFcOmRA2hPja)`~kUoVlX`Pk3;&vC`oXxVl5Re|)PZwL$m
zIp9Z^AFR1lV`2%ec6b%A;tJf-1fEOpI!uj9)|zB8I<kxd$3DQ;CCeLZ!6tLt3?sby
z#7dmi)kk@w$fE{8zjB#u)$1wbIkW64-R^x3lr$>ZzPY^Sc?L8+Z6wtk1^!I$T`7LE
zXTY@V;IECdK1&G#(O*dy1>?gdT}M`J?D#$j>?`pc`&Q=s{yUB?5_>xvQCeHx%LC)l
z5rb;fZlijqitE$bb#NWe7bM3Zpaw8;KQ6=iw!-oE3kmKkCii_mN8?%k_5K0mBo$r>
z`vn5i|B$N@^EoP3avoYK!T&=5CXI`kkW9^9^0r~xAK`^sL~rf$OUW|DyagG1*N=!*
z0W5o^cTO>00y^{c<lvM$Wl~GknRdP7F(1@b<E~gRRnWU<(g1Y8(m?&M{*1bfW5^O0
z2aEf&NpP3%R`z4!>~A;fe?<?BO~QlL*`V|F&|ZO!&yg#{zfm;uy0|X&6VrI=i30#X
zllSL}6=slbY~@J5an}(B<{;NzsCsJ~mZ;qR$_MXf&86k}Dm`isyRk8bjXt?mS4T$?
z)zFi_$3cifZuNnE)V4+_rh4OqE$T1>s2A>+AN;FytIu`V;e4rF&i--OjrO4>gyUz{
z(eA%C`I(5NPSDwKNP733oSj3QTwINvM!Qjnz3AW_q4l2o>E215K+FmM+o|y{tFuL+
zUkcn*`h~7POed+5PU<8$a!k4$WI_{F<BK{|RnJWHe_dZ*{W8#S`p@{QS^2fYZMO~g
zLca4@M(?BHxb1+H<!pgY1q{_}a?FeSR6v`;lMM)<Txi(=Sbr`{K$^nQdvUrQ-gyh5
zN>x@vr{^1!jZX-G#zT3ly~$1HQoePg`0_ki>h-vFlB`i)8+yN41m&xdtJVIzROL%>
zk@%Dp{so=aW9R*u!kByylO{b0aI$2u^@+1<))ofl$to8?i=&nAXUM^n6L0gIj7NvJ
zVj);tC-X;BqFmuF&CHP$kld-w%ocP#-V+H5Y8NX}3f^9E+KtdjVby4QpOl~fUM}OW
zOT<pm@-<UNM~7a|_&BUs#Ey`EKubUT_&-ZWuQ1SpsNKzHN36!+*=)X*+LZm*D_*b8
zgDHljjdHk^_2>hLBn88t5GwF~-*aal=fkUqy@Lb#_;Cmfh<7On)v0e^?%8Ygr5>_H
zg^;5TKvC1argg_Z=Mr~<{Y=t898@z;l+3`)kOC7-b90Lvm+>A5Yb$gLJ8*L^(4|i`
zjKns(i`<utw>a+hWqH^2o%8a?Ikh`%`?J&F&|iRwK#N&))3qjFF3ts7-!4daSoP4q
z3_?uyg9%1MULIE!3$0l)4Fi8*Vmg<93_?HKtPTI$VA;(~_HILND)j7tKhtskyF_Np
z1#qbxw?d)jHfWyfPUABsGEef8#tu50{koNp8(_UmyW@I2HVMybs`oJ}%-<EYFAQ;}
zH|V{WVjF0<5$i=?+QL64rPKB>gzHj}#x!)A1HWLer0U6?laEbWo5s6kPQ2N^Y2(wx
zZq9R|?KO|Pt$7=~Kl`m4C6)$0!;Tr9t8pR#@b_*8z{!q=%D8RVA=_d5Z=yxU{T^|z
z70auXD6W>(mDmpk75F%6xXZ>s6vwNW>?~f<{)n$)jJ=rU%o(F*>LmiR$cw4vVMqBL
zc~Bkex+`P(rXmWGSiZRyBd*t~BYrh23G|w};a4JG$zSA%TI6{P?erf0fO&S*xCc#F
zPG&22rPbLcfS50>Hxq&~lk5hQRU)m{9}ZAGvpnNg;a=Yi1upisTQJyMO;xEy0-#N1
z@OHVg_9qC;CbX0Duva>sMOQO&u3o8_Hg<~9xV{~xAWp$!daG3F;C0DNVxxwHw0AR1
zw8=c+Qh#>e8_svXE@7X<6@q$e+unahXM#XqoLoAY>alz3+KaSA6l`-}qn<v$CtmX{
zZwC?9ne~4K@^De!8niU`E0y-&r%$TZ5q%%{=iA43d|q0Orgbv}yfrka{#6mge&|2l
zxpot{HJA`<9L!|GkxFJDd#$|of9X4(yKSpu@?Jnq@Hdu1Ifj)<N&~c(jg17n_xHEP
z6U;R~oz@~X%Z0<v)48Sbnw#KioBR2zt_LvK#<zO@mN`6?(8*Z%I>RH3GqjiYlb+0e
z8LjA&vBCrV?LE2Q6c7=zc&`R_ujeO=-B-D%lzY~Ljn>C0PVRLS8CYhHs0eBzAj(C^
zo<GgUx_z0nc|4J0+q0_IFG=FM^oe)Ik7Hg&<1@Q_St!A{Y%aJ*oTVk-34HIqT+c->
zbgk-DuZzfi-a_~^9hjrPb)#3%1vlK^<%1Qp%ymYwVM2Pv^0QzVb3THy*H_Qg`fqyX
z3Qhqb^)9fgm{7cV-ff&ww8MKx=Jg|5K#(^fjg{-sptnOGl8TJbeMyBJGQ-S81Rb^d
zP-UTLb(L&fWwv4aO5-v^^Ct=KDVCbN(8%=c$S#UpyD^2TqP7&a3e(bgaAeE1&zu!M
z&fWEdsN0T^2pr`>CM5{}za?Ar){gNx)fBA~cE{?nj5)sB{&qO|e@qtyaaZgfx}|U7
z(Ymw2TGvQf6AiOG{SH0&+TvB0gJ1*pO)c%7W1y1D=$`GRlg{WmcNW8c257?#nAw$g
zrGXA7i(6%(3AuTbMnd+!#%J4$MK{q&rAJx3INk8=CQ902|9)qGIODFnM{_}!k2C1a
ze~*86h73gEDL%&lPn*|Shxz|$;`onT$t?O?1#pts{?k!_SV@JM%fF_LPTSh4sn!Qx
ztl=4PK;^A}L2~b41yz4l9GRCJc>ZeB#cPt?w|BksDd;Ryob`=z%&ZtF09=F=GLuyf
zFj3cB)9iB-=Wh7_b07R3rN8UI00Mw<ZjSH>fR+`)Gs{ub_)iJea$%4W9${Nkp#|(P
za_`^6y@b;xa}=pwVjMKtW>bIe8~Ji^uP0sOkz{M4v^Uzw?c*3e7k;|(*g>Og1%iPY
zQVz2!s>0t4eY-U<4BY3Tz*H&I#lGIN>YUs~nd^GvMCDZqV1-;Azq@GJ=_5KhnmG&I
z$Z3vI1bmN0a=QJKWQmla_U<UQYE5TjJLFC;h!PE-_{20)@p#JFU{NfYN*Q(AgMGXQ
z!fRO*zce8Zyi5}K`*%NV-#-phcRaS<cJ@W38i_uS;#t+0Z(;*|v_MEW?vE1-sOkCD
z`;>`^PL<xji#k?cIC$jYIu_*UO8sFdApZ{z3t0#bzzQKGGp=IW49kS0gKA7y^)%%I
zW$}G`^RQrm9;MN2{x%tIh;K{|;Dt7o(F>%CYzp^u+#G$1PE5U^s49+}Q1pF&e5}~+
zcQ7LV=WO}8iQB+jtD!Pb;MI6MEt@yw(W=h&^wojzqvafZ?4pw|=Jln|x)&dsnVcTR
z_ZS(!I-`9g7sH@|npmy@vm)G#sMJNB>|E<C*S|y$@W<a@S<Wz376Bi!9|Mu^xf2M7
zbTB--p1-cHsTs9Oz;Pa`%XZ#NlJQ=)(#i|vn0WNFukL-(#`vxykJ}f-fzz3D^~7v3
zHucrF_!S+VT%RQ&9P5@+2mGz*6<ROLKl_?i`$d!2(+A%R&~4EYs)ZH@G#m>vDp)U*
zcYkX_9jHEHnUc(s<dT-`?+7EDX?N`fU~twnh>Ej`sD#hI6ryVrw(a|6Hyy5B|5_tS
z`s@)IXbG2NmZX*kVZjiyuZgVug^hV|L^1DR(0^j|xtc$#7)|83HjF8Wz3AI_Efs|&
z&w_ViS@NBZXuY`9jxA54a+R!Z45L0wF%OM&rFC6HQt`Qtq;HwuPmgpi!nn-F-Fhli
z<T3*S%3Esnf1jNh9%%WxEV<|J0(oKJ)vx_)zR1q1-bzmoz0v|%74yOAPiw<-wb!Ct
zW=woUB~KmA{KM}#>bua8LrjI1d>;p(MOA&bHo9(e>!%3&dfRF6IqX~cF7tYUn&%DS
zMbZI<+0DPwWAmD=;2PIIWaZlJLi;5XsSBw0LB76Ij+7k^r<?;wL^SeM_nQB)mr7!A
zSUv_cs5cpwt-U_s&z<W=g<X8Gpl|x7Hk>dEb*=guX)UurS`=KTYB<uG>8N-<`-5=q
z7Qe)tnMw$XtE^kTL7`EZ)?gEEuh`pr+QyB@H(;<S-k#|=;uGZ4Z|X8?%aF=!H5UI*
zMpDoD(hBzWFAiP}#T-{EGcU4>{Ej5VgmW)CKrx)9^4r9kyPufDcY_Cve(10Wa(yzu
zXU<gPYIMS2dD3yekg%R&X=r$Y-!`yjMPJju#xan9>sdu=2q!e=JF&5nx(JO(U;Vqq
zeRM^4t!;GtEbE+DM~Mmi0Zn*^x?zd7Ahm<lpgYZ?HBGPx8-gi>W>UG@`OYFJC#<Ic
zQEjSg#7s&XqUS=!p4MO-kfwq(^M(DGp>KTYu-B5zo%mp~Bk3dUPInIR(!N+jMy0dx
zTbj*vKaSTDj#2vj`R|#Uy4zXit57nqUP}}iQ!XOH)zj|4&gcByw1ex31U<FDAi}2&
z^7eNz>35kQ&CRp@?;s8z^1ITCs|x!V;1T2q9})FXo~JH4=Zpj;*ljDlV`30Seu2R`
z_a}zu?E{n;Qb$OghjA>xOE!6we5KKHV$cw=#%BXt8}0ru1;zs<f1iaTW7!K$OI+P2
zTlHAIl~~h3A_E5FH3O46Yj>n!@~r6R5zUWwdJVp*Hdn-%r)upWU1TQs*u=Vir}Mdr
zP(oXa7)mfHx8z}J?@}aL=7nYI`l>9g9Ifcm+Sa>>0CJtxFNwL5aSytUx7}SIWk~q*
z@RTB-2h*eqHcG$z`n5d8)=Y__Si?aHBjg|Y(Z?>`Qyw8b@7aA!l{&mBYbaSX+%>nI
zl{$_TzB-3g$d*7p4PIZN3jS-hoaZ=&XL!<a(Wj8-Lbvul$!i-eBv3fQ%*UGr5)3mW
z)x^Qfx@u-!eCp}DsHoHx0!n&)A%DISM?D!ocxEW--!LifF!Z6P$TkK8pf%;YUkWCh
zZPfyCH@1?L7f4a05RpAit`q7ICiIYl%+8~T#XXs>@_cS~<l>s%@${{(kwwbO)tfI!
z6M`!iP2xhUA4h!9v*DvcH<moDJ#WlDfff2;Za^%a;Oh6A3+R|g2bXnQ0}7d2EB*QQ
z>u*2PcC6Sx^flz@_w6fJJ8bjUrMeuiVH*2Y!j_7BX9%WM4$YUERjNHWBl7i9X^WN7
zifC?W$+2GSS!lT~)~G3Q4G3$8q1V0Q8`Sd0cRAyRmexg(0fB%h771Uc`fHesIIb9C
zlR_Jpw%O<t^zH~wk~`5-be~>N^<P~wMi>y~OR*Z)k*?UFLKc!F1!7=my+mjXvM~qi
zUN*NuxXdzoO>&O@#2LoH`Z-M<+4{(4V01e5h}V_=#Z+jAiDtA)r8cy3k;TB<&Qz{c
z0pkbwnwL2JPu!2&u|~M;8)gk(c3T~;joa_DVn@^29pLxIr(jSmp~AWEPSTCszDimL
z1Vk52Z%Y`w*y6XZ^j0^{W2MRxBP~tTSvND#EwUJn>34i>)R(dOuI#2X`HI4sAr;HA
zJUX9~J^ms$AJ0{1O3I}h20xcE)5$$IFH82cw(^$1Ta*2|V;MDJH}%o?`vl#EBo1{t
z6Mur@=Tlu%^{_aJcLuJ0$NsboKcMf<5@qt)HL*igSS?ny;IxI)T#4}yj3M~j4bSbJ
z1s(Si>rD-Ab2kR+YmkT=X2IJhru&A2@WA0ba&XQQCW@XzZ`|x+4+izyTjwQ_%GjIC
z-WrDPhZ|2OM0(LD#_MPW6~P|=J0kp?@98|S6SRdoQ_n9~yUT)W4mU-3S{RrL&vS@r
z<kE_#=SDW`W6d5LAtyYnLjL7o@)jpEk#l|q#TF^aNMh|`#tsQ0fjcg0dEJmYGseSo
z30#5Jqef<7<SKN+1f(QQi7|yr^Kjt@hbuKlq>ibIQ7;@k4qF&0pBz33g+>k`C_J1c
z$AGT7I<`6MY$nmHP1|c-L?&hA(gseVC3+hsA^(bNb`FmYk4M-i=NTAeQw*=<&9AV>
zb9==TuIxfkV->@{9l@(L%|2<W+fd2SHTA3bLBR`mpb(1FSfF@DVjSt9UG6!`$U}+?
z5uv=3Fb4-y8#_z>2_6+}`CxO8?!KOTA1pq*Tr8Ht?pf~`z-PkSjN=zG7M+c8%uyNK
zDbhOhls<3sXU4(Fn5Pu&DDp`q@KAf!tCew)S=sGiI;%I&5T@$<Pu8V;FkGtU_p)Ke
z+byJ23#zN*(h^vCs5xF?1t*Ve_1kCO!^IH(d(M*CHJNJDPhdB~8<+}w^XG!>;Z~x^
zI8EG9rJUCzRaTtw!{f3`U`l>HOhbpDx_m=ZZw~>58f;IVhU`;CVo?myFE)ZpkxNLe
z;!~p9>*DqUi$in}&wEx+EB;3Hp%kQR_~=GkcEzY<i@vRTu#3f$Kkh(56<+6`zXO!N
zDB7*h)9ZQ|Pib?JBlY?42<E4fyTEYdPagRJl^^-2L8p2p&+idX1$>*LtyDg01Hsn}
zbMp3#(#_HBq66P85)O;$*(nfc(OcJO&lPI$Bp05EQTw}iI@tiprnRPZLY46d7n>w8
z`g?uoOL0FC=rSY=&J>!3T;Z33JG<57$Rr#dOnl8$pr2Nch!uD+(LdG|#o=$s<GI$z
zoXqb>X&MtxY|O8iga*+6*ChPf2Scc%Ab2p6R2hAgl!ouJxtag0e!Yyu>*YKVN21sx
zNyxJu-z|M9zLzk74CQ~nL1ItPP1Z<)fT8$SXtINst2&Dfi;BoTC%kFkznA?nAhrpI
zQIDSjrPUED)Zw!~U;zw&OQ6DV5a@z^VK75-W#NPYX#__U7?n-zjAnJYebRmqv;9Cx
zVBbgX-;9aLi$U}48+d+di&rT!ktjA(oqmLz$NO!f>nD6*ko`RQOpaBuo&CwddaaEL
zMbSj%kC18OFoj%gxPE270-s^83;w-Ph!i%T&kIr#oy$)P4#Q922aEcP=4#_eP3z|I
zG(L2b5v+K3tP$6~>7qTZi$gZ?9N~V$TH?$QUfUDl)EEm&U{2a-zA;IK{8ZFQ%+^CG
z*RH^uI$!%v`2Hz2T#4%r9do99t@kJv0*5jd+SXRaT7|<Dpm-K|XX>O~Yt4>;Gfr_G
zik$lKa45*bVHoo4|4?lzznDe-G|z+A^^<mXKtH3bs@-&zJDrdAV7Xs)WsMl&NOmal
z4^u;;@$L26<UT8FOYqxox$nic+8}AzV?1p=BjHFb*uX23KfKJ}GVVwe2f=d}>FSaA
zwr~ZaBN{C;zxu7V4P#mA8}FFsT}zlhbeZs)WCcNuv{@C=O%J^_(CpTMd8@g@f=3q)
zrhAxG>u#!;N>w&#MnZ7!R!GVcr?BD{45B|a7gtGq;&B<n3RE?npJf&QCIkg9EEnGK
z#g~c0HoT+A*>*w=d`4jXF}1j2DF1i&$R>?usk?LL@+QyVmk<lm&HhpEEN=H+5N*(W
z6zgZb9IO6N*r^e3GJbPTiY5!?IEmEP9)fPTExvEQd3BvzBgtf>Q)~4WbQK<H;Xqjg
zZEWaPu;A(SWd%*jw0?M6)QpIKxjFjdLH^ajN&(AN<bAraaJV&XT$ufBX=cyJ1Wy?`
zbHi$QL(?pnSm3+xSj-$>%wR<8V0G0~zGg)PtJ$BQe7JAD?5T4SS9=q|Lr%UkW*S(S
zxSzxlQabg^H)jrcuow_2ZdVti6>`qmYMa-%KYu+@JP!GZta1zCPUvp+(Vg3h0fR}W
zBo0yf72E|sTTQE8F`YFBROp?HA4E=mI6g!qvhXbj9{JAGpPZp;Lh_$)lUBJl_G-RJ
zrGY@`ks6|JTy4Jh1~1G?*Pp7bx2=CoeDrA*)BjCTZ<EJ&?eo~H@S{vy^Kc@8<w*kB
zO8<8?v19wOnr)t1C>bl!>|jsB^k(YkeCxa2$tiB12PWXVXu3Y(p0=9b4+hbLNhi2>
z$Rv=3{9~tD6<s+jE-jB3_LnDo2R0#pkiW}<Ky1{I2;?#!t{Fv)9oZtck{(O+v18{R
zCjz-Yrb7Or)D)CEOBaW#+5*nXdtx+OsZ110Om+qr9`<f?@PrvI^gOEu*X5oU!@uyZ
zRjre-$g1cCe8sHZ!CC(Jl*G2wV3*_8e{(l?Mq8-d?s6LA2>xwHaF>GJZ?S|10{v$Q
zic3&~7a*h`l^L~rDaiUFCBf&ZPy(2<{7hYF>-miWUI?yz`%T3#5*V0Br%$*h5$#It
zdB*m>?~~aFvO}{v?1e}CbuUosU-*<%=CW>%@HMDAZm%O!{fsbx<<96Fbs`2{R5V9=
zIsRhI^ils;*wX3eY82qW77mr6pHy6$zPt-@W>tMVsUm&*&B-UZzjXy$Nd9LP{5K8#
z%`v`y0QSKZ2@cIbq?=nZ88`3(J<8J4e*2{>hj->fSkc#b^jph@{$~(BGm?D3K9CaL
zn#+_9@sf};Cq~fjgHjm667uKK0}AIT4eg_mg@hspyyLi%O`SW=FT_s-+G%0yb_zvF
z89@Lspd<L)sHYC{JsOpACtr>}cAd(3eOK37*z;ameA+acd~h&h@%<Oqu^$|j+AY!4
z(Xd1H1z~IE&$q{1V8s)RI?KWUXdVrI@L=upPrJ_3U~1X25&m*_VqE5GWPod=Kc1rf
z{vIx>KR2+*SXYL;h5?*I(n-L9i<?M0+?cfmH`@NVrYsjteU4%Il`%%(d@VmUP1IR#
zwkb5nuN~e?p%tL6EJV+-wxcgnb=!*{t<3M&J`bj_tSCe*C2~RWBq<_$d{I^ERWx6&
zWaQ=TSx&jLdeRi|edW>g;#D~vKUr$j;X@)=Q{0mXEwHu@4O`pzaw5yBLX<8b)p17P
zA%xE(fG8OgOATbK59DuS$JG_nQY1~318?y>`KCG?{e)zg?**wxzoZQPDsZpWKHJBA
zt}!i_5#NnOF~by}Y{mK8X4<o+41cJzmJ^CAkL=W^-jx>hZS@?l(+bn}gXFDh#>MX)
z0dj1vVu(iDfOvMHQM^NEEca=4AENGA6-YT+WVJ^gN&I^D&+Z>OvLDRIz!047WGMK<
z(G^_VqB}^A-prnv^=E5kMyfuP<0Z@RdeNCQ-&flIiID0};dWT?yKV>%?G_$-*g@~#
zO0`Q}@qB-~jY!OheH3Ly6nACymEBKDg_8@f)%_BwkxTo+n>wZHEF->Ml+HX(d*r4Q
z+L4gw28@K6#=`k97?4U+@9<C3UQQ1B<7O0Bx!|(K{4Jo(wW_PNr2wrbfO`13=~cI)
zO5~VKae0l8=4O$VQFM&EQS+I=8<+A-R>#Y@g&`iEtt(WI?9^v2|Fo#tUFUeZK9*w{
z`*%M_^l0N=uAr(LPHtj>x09(zOvd775>?&9^OP>lEPr_r{bIXGV&PWb;l@T7a)hC@
z!p5g8c*mV9thZW<Knah}G!b4at+~8-%c>N*OUnrb2>4IAeeu0!^brDMp9UO4fNkgR
zFZqfWqE-_W97XYvK)D*~z&Se4DhbtZw64D(z+m6dVP;!mgs4~2URZwgv1yf&tjiHJ
zWQjZggiEgTfuN~rlg$2OQ_}pR(1cFcdnlf!1K`!<y@=|pm-q376<1c^gmeVFl}<rm
z%1CTCn9gAWHCM4<Jy^$4<FilhZU>KuDAH@0)&w)nuT<zf5TYY(+*ol>zDSBqK6R_0
z(BVRbL{#G7i;4S-S*73QD5+3pZ4dlwB91sZZC-Kfrc2hUX*2oK$s~=uFd#tw$h9BC
z;i{p4`QTdjp<0(igS~nFYsME(p~4EWgE+sN!)g48_s{_s^F!Am?aeX|KgT1m>j;L(
zV#oQyA<8j>^%lk(Q^a56Kdltc&RmCE=tw1o2Kd0W4wJ7gH;?8IMpHCZm+p&;WL1RE
zoRv&M?(Yog%@%jo)={f}o#Lm)SQ_`<JP#h-YH~hT*P#;g#b_C=u^7RT#a^glO;?*u
zWT)_2l*q0ckL(5Wdu!#1kFn;Q|E33BjVm?Ee3^7rx<n(CRfzkM^|}1iH8tw6AT(fS
z?sZUXn`uJ(cc-~W>jhReg%5)k=F@8zpC^19F>gI5L)l{tFr;6Pb=-a--iPI7v%6C*
zRF7cMHKjzJ-`;W)qd}blJ~~SWJODjkiu~I@dov|Wpzp{PgmLjWidQ9BT*AxcuQaO-
zMyxX+^G{}DgHK_S?f}4^s+IIz?7v$bakwzQ>5Poev=92fkT@`YMg0YZ(J&|NtU1cq
zB~sBjMpa$6W^7Lu>hSH>ExR&PzD49CUHM%&1QK72{+MMp{Q8wy)h;83po#o#Y<!YA
z3!^lLw4g4Mo15;X34Em_=nn$9ED(AkA}IZ`AE@?GMxyDCc{Yj5GjHm3PISg`pan0q
zTL|#KS=WABqmg3-;b|x|yPlI-&L5em&d-RvbEhUn1x+C*(Ix+$vB)0TgG0>_uF6^;
zsV^A3%Vf(DV5wA(|G6b@^D-sL1SYM56GOD3QB1pAtn#IEK3-EXy+7r{f4)m4P};*5
zFs#xMSi5i)j6T5JkHoP9_XGf@yseebr#tqGCCKp$*qGK32x$m%rg^Unz1k2B42+)F
zBC=TI9-EPVOE7o*+l^Sg6<d#HO~04t2Ly7A)^cqQSRat%r)@1y?+o4sLRzK1QFY;S
zs$8W4^aqpHJ58GR^FH3bwS#`FW3O{D;av^mQ*T;zJaN&WJ4{S%-xLI!y^!lB_Lsh&
zO$s~`&1hViN4geKE>BqnPj{ni9O_Lou1&$8?SV#o5)E@b#z|6?u=37=t6sGgX5)q_
zzYrL>nI`<swG_~o@s_e7a~-36`Lqv<RUGKLIISv3g0KeWc2>n-J~L&(q`yG`R+v0}
zq^N;7M<bk6<8*A<c=-5kF8>EB6Lq|>MgU9MDzXU9n^rQGClfyMiO;DU(PMkmz~&B_
zKQEO!f_Ldt{w-Xr@l<wCpwQcHCu@h*gthUoG5by7{mVBxSN*A;Xt&!>GIP=N=&3oR
zRxBj-Y3rgc81^h55jD#d{<2_U4$6rItz~=MTlh<Dr3#-5g&#$|8ZiE3SS_ux4I|NW
z(rPaXHk&F*o?Q|f6X_0^?INvfDmtmN-TnCxYpbo=)1IWfk=QT&QyieXxZJXx%_B^+
z*_p#W8XM8Yb4GjkAxTpp0N1s-NIEj>Jx`v}?G<O2UC4(`y+qAZ@-)K$dM6-XUl+;d
z@iv7vZo%IBmn+xqVn2ax%lUOVXS#Z5veWsGq5bvD84YFD3b!*I<5|?&wY8UxwrBu!
zTB60{)?AsxTZVwTg1+~kn}C4zIqUu#_-kVmNJo^Y3T2^^$eY2cVv&I?mBrX^-_w}j
zuZaT>^kU*IO?GSjsfoVZ2f2yEv)Cf549{wV6VyL>$&0U*s?zTm6W83)Yjbk;{p4UB
z{8~GUwV5*7g8WybvuAGtpr0~Snv|r=bX*SZ!ms!XR39uCV!5gB7|B9_-)jmhS+3e#
z-Wqth;)jrz<n38jXKVq{TpDLM^XZQs_*KpZF-^O%4bBIL52kave)Cn<zOY<G#?S4Z
z7hkIym}X}lTKejJtbfS{zfKWR@T|*Ds^9R*0tM*`&0lrva;1~4i3-fj>QD^hHopRg
zf832495<RsC84(jFEm;a>+Q&v@mVQ8+l}kOxYLJ8U3^@hA7@fSI^&70DYIMaor#>!
z{~KMNt^fmK-_*KS+Gw-Dv%ex4fhK7I$EcI(L#|7bU^B*GQUnRn^?~?i&t7hdAU&G>
zcL#~fo}`WK%=f8$bz~i$)R!G12)nMwYPsERAMF7<+Zhf`D)IYFbbP(;KgWCqm<15k
zPBFsCj}HevUb3NoO#UBK9RPzKkt4X8#!6L6H!=An(q4Qr-chFBW`Ui>AGts+a!SKl
z>EkZ_!NCd6VBhMc<MyylLcP(Hm6*R3hoE=BGCM8j_qPuSJ*alyWZe76Cg=e=(E}K0
zUmcXoO7F<7?^fy5tG%L#Oow&)3Uc(<R&G-O`tBQ$Vbw-(yq4<*iXW_+3J(Nwl1>7V
zK6X93{FIU45T<zrkf5b{hb2uX#I!K2-c6_F$?V~AH_pU)_)F$pC8~#zkotnv5Bkb6
z4ZYYc?`LmA?r-a9IetemFSTFNnu^5~%lrrOr?Dh_E+c!UEX5K7fZu~mW-Vczsrb2b
zPk3TTo<}q*HCqg?``sv2y#=IeknYHGK}5lRv*$az9jD5C8B43-t~^+QIXS^XQbCYL
zkA$aoasiA_d(|kU%LR5m`-}S?&Z6oziLTLT#<i~E?r1v^e%ZyGrkk1?6+~m#nzPQT
zS7znvEYy9iCTD&lO<YzqQHJ>3xT!M()_)XLYmhTmQ#P_MeN(PmE>78Rv0k$9LDBZo
z_xk!Hm{Z&^U;avzSsu5y?U$F;HhsM%a^YS#g#$vDMKw_EbNrfeS0Ud-M-Z0v4cZuc
zG4vj%YO%}Kf>^`Y0Et|Hy(RF|W7ZHcHUcU(+r7oWp$c=y7&7J%HvKWLSC+6lWC$rS
z%&N3$f&U_JwBx=Hk7QzyVH!9>z~5iK+5loZn%aRfk=^y<J4K`@H8|%^hpSQO>EzH@
z?OH%LCN!C(J1Zbyi|S>vOwH*Bqw-h$@Y46<)L`!VEfgi5Py+R!5Gs+!pBl4;oI1DS
zH9M(=K3K;S1T&j`8tW9kLSv+3K;O688X@U9T<PR=;ZS?oOs<CAgM_10Ne2wb`S17G
zSE2%zs)}nbs&-zE%Ao*gzN&5-&v4X%%_Ho$Yt)*H#H1%fk@nTvy^BvDeX2;Iem8GT
zBkleu{!$8yFgL+;tq0TDmjNsN@s3qyuOxl|<A_wgA;S{gIOs|G+nAd+Hn)AB3bVb(
zt-u0{WmQIv9iGF}L%BFBWJCKMc7twz0JLNuZypY2x$YCeo}3mv-Iy*9+M-u4NL`Id
zM<QFU*I1)UD08ZMQ9|me;X!*QN7G89Q2c<H9Z*Wp*1immj7D2=B{{tDdT82MHYX&*
zT>Z>}MW=MOBC3&S{N6)kam2m}8xF6baIyW1NwI$C`RH%{caGIBN1{yN>PFuq{nNGv
z(K3`YR~`VP8Rxm&mL=lcN)U7zsZW{k*+Sgs_hNX;(RFjLEOm3gvU4_VqVwMS8aR>s
z{B)+}0moR<o1J*z-Yir1iw11IQ2dF<+1jt&eN3RMHiz`(TjEUCXL?A5=+Aj-2~}r|
z9%zpCkL0c5p0V2;e1nT0SCoGJUa1w^D7a2>Al*O{&+2@)?7>XZHw6Pa-$xV!g0S&(
zy9^Q7AH<>^nZ|grkskOlP+sxs&iO|rDT6Z(I;9ez33Mqi!hE6W!C`NF8+iXm%J^S4
zPjKbqSMvbqyaWMx2lmos(D)X!i}wc<cmLi$O`Clsd>;@!3z#Bi-KbIRR6ePZ?D&te
zuiSTqV;vW6Jx0<LiouhgZtn(<sEvn-i0WW6*_XOP^N<0-Z<hsOVDvmWLxjLb4J0)4
z)*1fS$*;A&GA)q+VHcOHFUq)PgN7M}yNJx7<pbujeX9SK!avs9omg&8#rjewXFlCn
zNgpk9BZ#%n^ngtzg&k+}bb}uad5)$bI|6}rB05#zokXx30*gN&6w8*)k<gNVz)24C
z?IZ8)>CTS%Qz;NrA|mD%Z6nlO6gXh8A47pQ-mSE`|8|^LuAwI`{($<PIC7dUixhl7
zyB0<wGOJLd<iHW}fR35*c8{;gK97{X6SO8qj)A#@HUMokADuY%mGWvo+=<o3%J`vL
z5`m=j?J&;eV4)`0y4CQJ(@VfIMkZZ+FziQrNHG};JVK0~YyWSo#o2;X9U@r;!2!11
zs?4}04YsIQYvlT3+6vpepmXV#&gmZ9)wk4^`1W#rGU2VrbvXk0#O&2q9)u@znmI1a
ztq?&2W8y^pbN<yJ#pl+wWT0kvLO5Z2+{g^(1ImP+1@VVL3NdP~Q|Bz;Lgcjx%(=}n
zUEyZWx7dM+f#VVGw7*&n)=A{mT&ywIH*(I!msR4n4?i@q+-)y|leIA7M5zaJ-A@TT
zpoTJgqG5&gXha$u(iAUmQYjR2g;^q}i#(qTq`7J~=GXs8Pm$kmQX4-YIDYd&l`Wb}
z9Gg*gHTnd;xEb}!5*EEs%)I()<+xSEgS*=HeEWzNilV_OTHw)!y%yZ2^|0>ZjI?_L
z+XVc*xIBKiAr)eoauAh}Q0vW^db3MwYKos65ZitDAWtmNKZ3K=(O;#&-+YMMmz0wu
z^N9ZNRJ3Ud+by5X+lz5&eQ_{l6cijX+<?ubBZ|PUu0UEd7}fy-Wxp<B$PM)-J+lw~
zy|Z$-k8<gXe;@fF(|Xme>w#Q!e@q{ev+m%2&*9Ax8UqkaIYX{*9YibM^`4I_;?n(T
z$~llLY)6|N17mG?*-2VJp{Z>)=|P=+8cg_HG`Ibm;rO0FgT-I;=DrC);A)JzBJ1P5
zyQLn;CqW@3^NN4b@P6UA36O|;-P3->{HOuQ-fX6_8v3eZToRn4+Pu1ZdToyHJH8+#
zSxCqC0lv@14YQq5NS5~2ZCTSt%Cj~__#I@!$DZ#Y)E+|q9H<zU@3Aq11V;Ef?vd(_
z=#^?jk2TLj)4&Q`+18$KB);^vb()0~5%n3%xQo&uh+f5O%ky?vu?qfbf#jB^%8T*e
zT;s^yAJ|L=%Z!T`K3Voir^AN-`rCXN7*A7m`N*9>jUB1RxE@0#-Kb8_Hb$=k=JL3+
zjk(&5Ompv2I_CGhgZ}pEyFWvg$_(dSJ5NIBztswD)jLC__G5&peezh>^E3Ku^P2*I
zag`zxQ%rx*Mrrpf`{Tc&O)Nv?Ujn%}5zuE`p2`5Uf8&(TeQ3QOb0=Xy#;(wt|7YmZ
zz>I`rNG%;cX#I~(<v3RAJB%>pf3r$?g%=k<jQ=~N{)w-^hdv7bAb?ZVCdO;Ww0pN$
zYYyjLimTV|6+%JNNY@iEU)6BVI_v1E!{*_ZYq<CXrVN59B*s|l^e!7USl^7kJi=lq
zw3_9`Yz_;=?ez^*76SqQi&kf94S0u+ruNZFop$}G^MLRm3CNz&{CzR04?++8>I?#v
z&Bus!dTqkO{FGBKqD`W`2IPWgsqt~*0BF`in)gl|)=TxMZ_m~dX;D`Vvgxh3ukJL9
zF-W))Uc?T*$DA^PXDdrXZr=rtBA1&;2KmA0=>gE+b682*V+UkQb1$CV;~3hK*%OpU
z4xf&`;ePsgo}+#H_;U+j;HoLxtJzV#vl1URuK+azf3DGW0^aMhV=McQ`FZ(lGKRa;
zY??ZB0LlV>QEqq37VSUNMNEDCE<X+rMEPxXG4y<9ML2c3Y@0T?Wea5~K0BHAheTtT
za3Ug5MyN-pWcj`A*{~vg+=Ao5^0AmN8;)H%g7I0~i@q(28hEwD(-{J1MorIN?AmEu
z{OL-A@=qg~J?84U7Lv`}57d=j>rGv@$Xkle?d*6y(f$06Xc#oi0&raZQCG1#PD$=h
zVTY2CMg#=IT7jp_S-07ji3{)TFP2IzF{@|M-+eXK%|v#=)CeZ<13aeYQ2)~fQ0~HI
zT(&GkJLRa_e2>ZDBp3~6t|-O!VcC(BsB;~?2CaV%Dmjj`LGIu-F?+LwL0VP*=6oHW
z!_tS852IweM2&So!1?0GN94+$7ALh?>)u&xAt;W6mX7x;tX7@^ZEJ??sVX?BSLWis
z%;q7HHtQ#xH+E?`o=zk3mWc6ML=R6M>DVLed>HiF)$nv`))<uq6h68-Y`gqxBc<UQ
z_;*(Wt8k5o&Z@Slq4j6B!wc-H9m5Q}y!2v)<InId*SkN&fc@=#$o+2#WXnMw$|%Bn
z2-Cv-AF|Y<*r?1q1_Z3jL=6Wj@FYRz-;Mk8N28fA2hwdrX`%BmfP~l!0(9epYNZU(
zOeXCUSr_9%fGKAEC3L>Jbj{&Tm7=oNsz#Y6TUT-$Uzb;vv2Y0j4)zS#ozE!W5k%91
z0l8c42<JPH3~8+MIKZ|2AvPBBr!<V}Ys?WOVz6={>CcB+{WEwh^l9~Q#FD7hXXzU8
z<@sLB`zLp14}AK)#l(sKR{dV1tOx#43iZvg)F3g!*U4L<-~>na>4Ay<fre#co>nwS
zM<xg)QEo`++)k75B{Z_}gbX~GLihfFzYtc7ub&<N4ed&GK8r{avq9U9tND7Kuc6Fb
z@9@`!0QO4KDG9GkjK?a44{TBrhJH}z$idXM(M*LJJf7%^QqK9>!Iv0|uJR~_YRi&}
zj_WNch2Il|cgroYUc8qYxxBT#1@q_nbGzxRHna)C8SU(y#zL5A0Y)6!I6Yfgf5ypo
z#<V!-G}R<<Femd?f|{UPQK?YhPCwkNXz>v97KkENivVwVwi*%HB${5B1X3t$Ov-NA
zeJZy9wR!x{*hv8U2YmwPoRU+#vQk;*Nd=3Wt|1h^%$DhEw>u)dX+L1h+rH49sIU`Y
zeu|X?z+k9eC%Ukx0>WbL4hsglLN+SNYVSbBwZr}E?E%uJf{h9Q>YeZ}3G5LlG3xT|
zI1{Oy3{gRM3$&gH2x&9N)GNk65~g{sC&;W<8U+hKqq9NJ0ZX{BeI0dRh0E)oGmV^S
zcUl0t<>+^7t9M?}e69i>_B@?*G(hk9TA~DEv3upJU98FX&9}l~U_f+^*YPx^P^KPh
zt{Z$F`(Cg))%+1N1w}L0kOhfo4ywh`!Vs>M?fbCfXj;oaeXGVl<z<Y&GQ6sDE^0$Q
zv(@j;ri(efElsh-5nd+qt|d*Tni#<x$|IJ@SY4~O*>r;p2RHcZRNiB?`OtkWC^KcX
z?irlQ8Ld*HiJ)9)S=3RR^ZSRw$uB@m5>Yej&86EM=oyoSHPDxpZ5MSJt}xs0VK9KP
zrS+meLj61YX5wl}&sT`2pk-+!t=m@Xf1p7ns0y(tYf8m=uVHS~x8_}W{2i3K+WTXQ
zVp}u`+qESmBUN{3ap@B{Z0L2cdrfS3$IIVg%nnbKg6-bjaC6f>UuXL1?yK7HGob)y
z2SZ!y9W&O__!#XpCd+L~^}V6yi=9qiQSa;Jq1d5f;DZ|ew%LJlw)tcZYpb)B;oVw6
z6$a)FQaa~Z|A~gx<-;YLhH+U=j$mecF<0wPYuD{ThGtX81`P#4=*}~~wA^18azC^i
zsN*|=B?b?C?kl%b*d0nz2Pc1(l0CY|l5SFM1dpb33lL$ynJ$LOsQwi*Wy&nZ{avbo
zT-Jcbc-o`)Y?<{cl?BJkW>rNi9T0$(zTd;A^FVlj7c2ML>2cWFNg(0{7|aGwk|g)~
zgLC|N$;+Q0YM)InM)bXuy6DVF%7gzgHmEK1VCJG<IG8Zn2z>#2bfa_~BZm!j`40pL
z0tIskIi#*hgc0TvryE0=MWkf%qPfF4SK!s$lyb+@-?HV0ZIXpVe1?%Zeshz@sNIbD
z1GYMEW9B>sS=z*&;5cv&S9>fnDro8J0IoaH!CV!e)KA(^=XfgHJuT9>3*JFBwO<eS
zCGYbJNnDuA@+Tf3zok;0MTLZt<)60CPM;lP=EzT58%2*}#*AwYiH8Ef;_3<?QRrC}
zXXBJRs5Ah+vY5>~d&flIs|3#xNjiQ>FT58y4Kq&c#z*kJzU<j<usuZ-f7Z)CzJo*Y
z_%4v~VZAxU_h<M}#>wiOB%%LWy#{i<jT%#rnSsY^!FwpvG41I6iNI67X!Bb$CLt&R
zCs9P-dVDO*iTi1(E~e$Pd*7gVGe&@Z50X20>ntW2HbHnhOCBZ(Y8OtXFuQp9KI$7K
z^-t%!{_B7m$5eEOmv75O@&MPVjH>`b;r#f~?js>!53^SXHW&Maip_AA|KB7@@ymp#
z1O{<LKs%O7)eOv|BM#e3Ov%q_4(^@ck60PK9dKL@>u=P=59>--H{WHpDb)w##xZnL
zy*IaaBg^?eW1&G2RhrTUwR?n9_@4E}Z!e?Qt3gASzAD&1Ug7<+mxIVDkakk~;w*^x
zOOeB>dBP)P1U-jsLW(}oyp>F+vb@p3@JGDB**5U&QBVW6n+)z2Oj>0gI%MdVK!tn{
z*Rp89H4!y)E@u}dEd;e%ESEWjl%d=HLA(WZNh{OL7-ZXHa-U0qXx#98|NhcoEQ{3!
zKbOQyK0_OpryvE|{T*1Rw!xx-`%*!l^PnvX&>c4OV~0n!_}b)ie7mxZmo)ok{Ji#}
zW*<yS2bMIySUp0XnuMFqWKA5Lc`>~pvhurdE)9tWBGmfFs>emMD1<YxnQiQ<Wi;kO
z-Hk-ko7?$#=0BO1g>X^Ze^^CY_VrV7#1Lvxrmwb~#`2Kd##>Ae`uW>T7L*MnfIx*o
zhBP*xz~%x>G?g&F5&~tdyfMV;tg7B$X-_(P*iK457UuqQjM+Jfm@YfkwwDtM{j#pK
z?{#g6V1V7T)Ui_Yyl=5P08zRkyiG0rEqN}yUif@K{`c36oO=B?g^!7lsR@5x(5Sg*
zFDbRU&&qpc7n3=)I?r~%xNxAdnR{}7-!*M8V@i@*_yL~bt9@?B$ZN^u=6r_b->ut?
zi)+@mOKFF+lOOG@HVg@$>)@X5o?!r$SS^ix$x2r*JBzDQw<Aytk<$?Jw0iOBAe=K&
z;O94T*1praBDQ~`*$h=67i*_<vKZS6*R8_FZW3C@bN%nohLP@Bj%dPOcE{}}oze6*
zsN=a)R)$(yo%Rj7QQ`u4XOwKIXrFb<``1ApJU$D`h$MRYGKk%V>%(!M1~9l^8a?4N
zGJCUci$@c3^shUywids<WT9g|;8qZ5_!9r(mwB!iQxGiDoIaehROj(U#vZGIq~`y(
zrOeWaaKQ<4-IqlUSTv1Ed7UoZQf<m|{DPt>J*GnEtJd`g<1XFkgBWA5U)6FkuG}9!
zO(P)r1ayC)S>o*%`r|?BK76siybs01oIeL$W&=lfh_XLJ`@<0!g}mRK@-F*$Y9S*M
z-6^UNwbVw;l53mqn3e}Lkq0-gSUOyT^#xxWt#xr<H6%72Cm+NH06T&Hb7Sw%v_8$O
z3Sd$1q@vK~fYC<!u|^DL%6m>(67Mi|7zrXNwU}^plB@XRuT?a=1=joX!uyet`o7IK
zI5Z{2i#Y6x(i!<C<f(Ar$b$vTor-KT5&yryUTD{=E~27spygin>`W_~PT5?!-=-dF
z+&5x4KA|$$Rb$QQ12Od<^M#72ya+Q<IkO(l439#JQTRpS=!8NFlTLy(?3R^~4j;}9
zt&G=eJ4ijlz{n3Kf4c!M>X8^Cp75#=2zYubx-U3K|1N{6-_ziMPbPD})0?LM`O$*|
zZ+{-?yg(uudCBUw=Wb+y+q$jaeeznmiQ&{Zl@A7VSlgPvyw_Me(X_R5c}Z1)h){||
zANrRla^wkfk=2l9+@{lfFj8`>DA&JOQI0K(<jzU_geQZVT8BqQ3;p>XeIj*dRvBVD
z<m|ZPezY^>oAjPs?)9<C!lAv$2<Xf+i+Nb=#9vEgzVbeGT7=sCwjVh?2Le%uu4?8*
z;|B!UH(ke1=algY10r1%F=3b{R=ua<{si0hC}<><XCY8}>qNxs-9F%~_3H&Vb^l&l
zWcjH7SK<2)TXiBs%JKn0g%Tjx^OP2!2D6KrzZv*zCRcWMGYOKvyIoJ`s*3+)V);ud
zN&LkrSQ=k#^O5xGoKLdc{$_`y$HfIlH`sDL{pgQWu>*-6lbAx>-$k(nlAvW-O63>K
z4@@8*ALIwEaiAsvAUyjK)r40ymtxamvthTAKfgt8o;0^)`ROWDo2?VNx&2a(5a}yX
zHj%P8xwVmz=ZOVI<=FPYWk0M@@8veO!E065VG(Y@LkSyQ!6qSx^^87grB0hsO{~18
zchFn(0r?0tbkId!T1&2umm64tMoc^v@N1|fR?kL?oUJTY+xEgN+Flnz9$xB(fR!!`
zxQzlY3#hlpRv}(Hd;#rW)e($e+ztkX<2Kvz$Fo|3I4km9Cb-?)`2R*E#?tb7+`s_(
z*0;9Ei&9^r%>S@hB&H3o2%9GPeiw~G-An5e<%<-GjoN67aCigAc;$E^!vSE?SDua)
z`&P~lmqQL~+7yp1;BHV!-AzQwC~W*ZV&J@Kp_lh9!n1z<L$q!?Y{-d+V?f#^f;(L1
zFADdaX21VhO}tmSVP&o?^w`S!#B)(0Qxq9B%TjzeM3?~m?#$_}`uZ>T+g9Mr0lPrx
ztVT-KZ+WbII&j$VYca;~=_5jyOFJXz<BzUG8J?)uRr7_axu$uJ;E&qYN3M7l%3bj~
zF|VsyQJK1hvtcEF{GWtLFDSWRpfoG;bw~DnVzLD~E2tgLbS<5=QbY=E!sEb|Wgma-
zjvZUw_D=Xid^g+l_7>>D;8#h5nTPU(*-c;@1ss6&Je+(Krwb04iNRa}aH!A~cNSLN
zH5^U5$G214I}g=$r=IIp3TEuqckzS~QG!FbGfK=HF$FvTuzN~;IbZem8)taZIFcK(
znrdX>xwW<dHvw9J<wlq1vrp8cOGIvV7<yqy`7-BePajDI0e?*TD-i<rI8z(&`e3$w
z(Ffe|<<>>w{6y?1Ut9?l6H%O^!*g=(E9LAjKXA<;A-YFPnwV*5tNkQjGw)Eqh|&Z~
z`kZCMU*Q_|X;>4oRcx_!yZ)YW6=u4s&!T6!vkjjp)4dIhliUHOpRf4?-!50dV>!AN
zbp{aPsFy7q4m=t)Ef9!3)#tg5^qVGK4{f)lcK9LZ*y3710Gn?WE5ZGL%;U=$H5&cu
zgJE_;Pz)B3aj~zra-w#podzDhi!~;w18>Y@<Y?2aF{I#Poh}|&pE>1m*Si@p^)|13
z8Lh|^j|j5ueO2Vvt;58W@QN*A1^vSY;zfUiIUqtRkorI`on<&<e|`?9{?{csja|D8
zwJZ$1qG2NZ4k&6QRzNY~v4Hl+@n>S`81U+Cw%iIFr&1{Cy6m`&oqE2QM;OVTo^?^|
zuuXGEUCY`$C%Dm7t`t*k_rYLvi?Y;<QRxCyq!ez8;#pb{EPwaWw=c}D;~tZ2Mfo8q
z9}pf=DSTXRrO7@PS7LmiZ*?JXs#>Y#PKA1O%9C`l)3_7<U@0jhNQ`iT1!!;^Bb`F#
z>N?lpKLG&;?a&WJjRy+boHC@9AAnpz<=1QO|3QfVNd^4ZhmY$p=!rRkCWooCbW+$A
zNL}qz8%JA}rppkI``7O;POsc@5bt-nxnwTq>u5ZbsGwxVZ0yj4mJeUHc1nK;7Q+XX
z1NI1(b#h>J^Kf~A#pA0dVSZg`f|Zc7j(vn_fs+(u0;|6*!vv<^LP7rM1Ms4@5?|xL
zv^a%CRph+G`i9Tfoe8&lqq?C(i9d(yEp{HVrGt-XS4eNyIzo$eq@RU!^qSPpu@7e3
zT1N9oG$dgJZOTDu(%r%>^a!YXuTLCO$&8fgnrs===O4bjra;M0Ak|hjaP)`d_#wRx
z&GJEh6Dpc7)$??|sv0%@7w0V}D*J;~`5g7N2jc$!G4|F`btg&xa3Hw5y9Wra!5u<?
z3&BHh3GVK0!QEYgySuvvC%C&yu-})N-DhWK=bZP=UxdT$+g)8=pQ;``;3G3PD)j;M
zmigi=CiS>Ov`ER<W_T@6<As5PY0~3~N<9&^1hUt1izX8BW1V$0+c(N}Azzm#>&qSY
zZaf)uyDn1eFVw1h?nO^~QrG!1FT}LUQwU-MOK+XsnGk{2gx>FJS~yjuPhW9pdv!Ok
ztyw%P9jPw^VMU^g^w_&WUjk+_R6QS?=%C65ENU12ge!3I=-~T*)O#$Mt#uUA_W{Q%
zk4;>nV3u&db2C>yYK~RT$m@|{Z}T;|XYVdM-d#Q)?V~rm{=`~k1S7@~0U~JIFjUXY
z1yEj)7qpoH)s9n{;|f}#>1aPc*spl{;72HIEdOFNiC;Gv=jXg`_CsJ;hmy=HkI4#0
zQSkFif`2za*ZF%TK}h(Gdr(=X*Ka`c>B|sP$-cCQ#J;N`p1;+Q3`ISxJ}A($UH%&M
zb|BO9q0ugL&O&rO)a6#tH5+-<k7=t7QfB~J<|OkY|FM0|b%x!YMT|ktZQj@Njn?m3
zRZHyDtlE!Aj7i}iDMX+gulASFt`AgLF43&62GrcRtpi4ZQ`f(AT1f7jsNDhR<_di?
zr~4_Hk)&#*FC4@{Lo8&a&3i_k7z3ru#jC%dZ;92h%n}{qHDQDjED|YK=~h~teSxIV
zMkPv55>#tczPh0lsKRgw-1#GSTHk7wrcvZ%v9T4VW_o-{#=9`{85<xIbv07yylPVm
z3*HO+gU#}b?+;Q_(Jp8-v`Ex)epOb4*|{ty1z;*aUQapk9S_54qhScdu}Y2L&f}tS
zEud$Ae)|Is_0g43Yu*|XKhT2pFoFf>P4bDi#m66tuhR-`HX`%bkt+1@nIa5%4PpbX
zi-Pa20Ik!OfCE&B{7FqYh&7t5lzJ`B57HUl$6F?opO)*>0Ncf`ZUXXjJwKfV2Hl!0
zZ%!|8%f2>}Uea86OoHREUYjluZ*%+nQ5n74o?~Vsq+D*_jgTFEC>n$*7m&G!6ALlT
z$N}mUzNo(9V)FrT#v=rcReE!EPloo_r%F0HI^R@F!_)}bbKL9Wzs+PNB`fk$L>BlB
z_~gyGxWU7H8_P)FgDt>VA1}6JOw_PO>e9rM123>~NuONR0-CiRO?FY!Q&~38O3-24
zv-tE>bvKh3a~kUFG0J61uU6k<SKfQ_)P8rY%pQf$nhl~2cmx1s8+*$Fh|bJ1xsINp
zX_u!%78Wa*nhU>8RuPAMAaF?6>7C<#LZfXF@VH>bPy?gcjl#Oj-T5R!`bGapuq_O#
z^QSw}w?L+%5cQJX?*+o86Wz5Hp7X?>NQ|#-upYCvekf*Wtj_s5W@dtxWx1LigMz;7
zY`jVw3{+oGsl6rj%O@zjyb=Z=fN&Tdj=;&*$>bjtrM3!quskReoa_O9)$AU`r1cJX
zG!Do3*9bD2(&3_wJ6#*L2Y{W}WlZmBPk0uc*nIOPnR4$#QKsNIC~{=~mu1sNKPwi7
zsJYgDZz50sLjZdDkH9|r=8zVQk4E|s%?{I_s>91y?l^^eKL%VSO*U5>K8iejPy6sD
zOXr3ManMXbib;f#=1v?ZixahP&&27S2ffMa4ZKDRjs=2Hz>w{Zhd&x6e4$coaV`3+
zo-|0%_vDuVGA_%vzH0r3^WLBzhT<L+Ae_rf5}>UY51T<l;?htA(Y8Po2tVel?2AY}
zPt(!&=2Tb_vOH!>@R7B&jwOy%%Dc{l_UkfJ3XOvR&^7H=0|f$}(U>aYhsqVUiQpT3
zHd)s^D0S%4{`gF6d(cy>>q}3))_9Feh`Xr!q6jEbB2~84;TIP-LhCF)K0j`|B{#|C
z0Bh$RtcW1>Q&Iqc=+3NtyqkUl<Wc1rLJ<%FD-inQGaLD*+DHf(U+8*?yrJGWSC+I9
zY3i#3k@%AI`KD1P-GglZl(Wl3$SS;G*!)o(owG$De|nn8AYJy?1P~Qd&5b)7!;R{g
zzbMwI;g<N?<=L%ftrx=fV8aS`<IP)!w0QwH8IC&v)>%sY>}1G{Y`sRot${1J+YBx`
z_agWGa{UsybhPNu&nGi$j0lsi@baB}ld{AtO|5+qGL|`+axnQvL*KXi`L23dEXMf@
zYMO%4+87O13oIM8&koFBkY+?7omm65i%^OZLtqQ#KLKiCCH~18(^W(l>VhH*3XLx^
z;mwz>_oQPDBsU7g{IpjP<cF(ogJ~prtJW2vG~5#vLIC|Mv|iGQL)rtuzyBS|WGks-
zael$CLto4>XPwen{!ZRW9;5|E5rQ*)REM!S(Q>qn>HE7#p*EI`iXNCSda*`CC?vFC
zkq4@bxOauTwgjrV<HBD&1%lpnb<nX05nrRHf!ds4s3LxfMjbjf>He%i;BdU&+$smv
z_!&;%0!Y+fOCBMC&)y%2?GDcUaC3n90-DwQfS~8Uzr*FWZKpoeY<Gbdaf#>&-CbN&
z%p&u+^LT_|Wd>uf0^;p!jw5xS*mt!Ly^|uIx)*ZQXEYO4y96dV$iJtD-@V+fI_M6~
zFOZObVrP5G1#7x7emLn)Plm6^6x7S=Gx7Y2=#OtYey88lRI{lL1i+qzQK+V&YGIM3
ze)6C6fwS1V599R8@78N}#WOy4EX^&tmxH<=@6JMtB-0gK9o*4>L!l2PdU`1C7HI;g
zNv|D&H7ic8f=SJngJe}uX7rmY&&}e5=YYm(tl_Q&X=<_*ODszF?G5&;V_uE;YrJ__
zM1iuLT&=)XabJ^C16;9zVmN1&EZ5OK_Af&2(?(M6XE%f2ty$ZACB%<4TO4<V9`CLx
z+}Uw68dcq7N3w9W6g*$M5%_qJXf_^_iIs#Rz|uz2%L#=*f~Tky6w)!`uK9PnBhDi!
zZ4e1#rl(Kk{)eBRp5n0NvP1LQM_Js6MZwD%`Jad!E%70R*pQrm8qXGy^0FE!^5UwZ
zeWNfC5~?3Hk76ixaQU=0Lqcy{FAfL3-1=+6!Ps_RM%*0?@V<XOwy=cMx@omMdp*4H
zc4!TcZH#H%o^6#;q1X=}g_wxYk!g)CUwthkr8jQIyM4al+}bX>BTD}C!>AD7=^9nG
z^syf_uD-F@nd0Pj7+k9>@?4Nclw<F^%W``7j%dDSNh}}T20)#VkPcTFe5thR6hD6|
zJYQIzoWntX&05YIIkqz%Q2T-7o+-A>m15s6w{CzUn>VVZD^PHXJE>)8?a;u>kp1rj
ziG6wwO9%NcPhs&xP9+4chx5uq)DkQ=LLk?@v!<GRU`b6pL^z4?g@rLO><HI`KfmNx
z>G*4ik!vrR3Kx$v13eBK(SQcuh~|js{j>A+zx4RI6bUmt+^5FqdT?S!EhnQJF~e~)
zD_fbspFgI8eA~Xpn!*_wwYXrC@lv+;6i;Yx<6Tj_xqY$>_T=<W+cWoTl~ry3lE@Nd
zqK=NyK$cVyjO_udkA0LSm>t9`%-CRYEH17&DI5lj@9qHdqV%zTMl%l;d?Bq`Lh)M7
z_l)sn=`_;>mB?VNnI!JNYq~(5Wu1E=2o3wOwk-Ox87rfp{4o-K2uOV{0n@sB(}?e!
zM8U)r(bRHC*a<(on1mmq`T=y>tj<B6*TuI{WFiRKJ_{nE6GPMboiwk-zJN^a>&41}
zgj2o)O<1<}0=W!dURcob5>L)Nxs1M0T;Wl7GGE-qnKJ6jOZ7NUj(v*NTLO2P#Z692
zw#{-iRu#RztC`=lhSsl{?9Y7C_K}&HMkKz27-R1une{&SqK2vmmZ8GJ)d8a<MBgQM
z1}w_HBxl(N`Xy%UNkZk%6xk`I(9C@{QvOJub@`$x61vlku>HFyBu*epu=9-Axb*1>
z<jzvVYqh76D_hzc{w_l{)8k^RQTI`F1J%)y(>KWPKot!G^z0+Hn&o6I5Hf^9<>BS=
z%&Yo6q3a04sum3%P7$rrwN?p4VpdgA)Q{<O_`S;#B46~7yN~$AxbFQ&NFAW$YKZQM
z6|I4a8A<B&o6Ry(In|;Z8Q6BAW&s@XWNo$~L}{J-yYDw|wfsUcdHoYfYO5VigMfFm
z$N59`;rp&Q`iv0JzG_^^L8|C<WXP6qKJg$!9kg7}CBng(Eo7t$*HktPvp-eHhs4|l
zkqT2}Ap;gZL&BQnsNnkWR#<EIe0b~Iopd@3-zS8k`!~c1Y<Mo8+a3MA{QTfFPjoWv
z54%g;(^ajwa`@@`tQ{RyNa??MU+$K#&u`nxUjT5M?{ASDIa3dcWd{^NXVqNX4k>3F
zRkpkGwI53~9pAUWJJz4I#~CrEf=a(OWR<-4HS}bpGkni{%OO%=9CJ6<8>dl~WH#0u
z4ru9*33TC>p3lonY^}h9_lM;z#FP6g#u`&NL)WlCRPB<Z<?cFd6m9@NtG!>oGfwcY
z((hght+4kS(%ek$e9Y6Zu?^pfybd35TUz6(Jn>V$G{k^xedL>ieY#$f54AL$>|A-8
zg<}AEZsdcVY#Mm0qazDzvL{_SwXd)6nR*bE2Je*DK~eysZ~ev;aWZMOabq$tO!7n9
zeOW?stO}aqlr2aDYI-_euKXFANBp?<gMWy-fZ#$I<>-(aFi$4<Jy3#KF+aC99W73}
zXdxybgMf;_TvrVEzK`kaXijzY;RTt`4|F&i#`D_@m+{PlA1GC)&A65Vjda!!LSQmK
ztS_5{&n71I9s0I>UBUL|TOyc0=YFtzfB^8#Ch^2*j~|1e(rGj1G&Fh=Vw%Rc6&I5G
z19O4Yiz*}Wfrr*~NAw9Sqpwe#tHH;)*Z>xG)Tm5BAc?b|{={*Fn40QetUMe6#npI)
z;1I^0$q_Y&m!TwlE(bSkr$`Q6K-|5aL~UkL_cYghCW-y5fpI~LOIybR_tWg4M~DuS
zAsYLaD_eK0)bQ3iA<~B#m;%f{l%{CV?2fP!NPE$X7p?_mHOz1V)=}or4wVSHY_F%w
z<ep}|H#7Up5ari|)v2}Enzr<V9~li3CfAc?Ds&z3CjxNlFE@ky_B|=c(12DXh=28K
z9Za2c|4SeK`5$c~a4Fy!CnGzl>}D&W&Ud+Xz|e_1LK#eqia?*jV^1?+)(mVtYWHs$
zEU2nv)QKwg7^~~P#zL7$Q;Cm2Y@a!_NsS;rs%}7T=J@<*Z~b9?NfI$zZ(0OQrozo%
zcgRhOOIsQcFhL?10DXc7fc>lU=t{l-(X~7GFO#pWsJv-xDn)+h`k&mp+n)I4JwVEr
zzi)`b+#h6%q@39SP&+ssDqg+pF~9r;gJ3|Q=TUkd&i<Eu<v~p*Px8L7uQ>9UKs%#g
z!GYxpOK;IPK>=7664Uv@5DZUI3K}kVhrE)4)9!dKTxBfA-@#cXW-xHy-pE;RECT^K
zN%`3<N}M*}OOW~J4NKtnyo>+M=X%5P+SD2fL<jOcCOygk5BbQ3Y0VxNbq2XEFe88Z
zm9}6OUJK9HyK8@f%Zr()#4;H42_!f(DBT5M|8aod*y%|EVAcwwjC@US1oTPD0n<)W
zom8!yj?YQ>pM}8eF&3VIa=0MFh_Ig@O}Afv$dXWe*v~7Ol3>Xz`=58u(iT93&#~Vr
zI9k6uv->n6kA^WZuO#q3Lg6?xNv2y7q^(RE&kAMd<l_)l^Vv7Y<-%YaZ=3nC7z`D!
zI{NNxthAW~%m<GiP<v)u$ReON8{FFD8B<kNoUyb<uWZWI1bZ_~j0x8MjceAZPVzJ}
z(|1*d_u?Z-O#=$3@fL}YEYD%|K<HQ=1kYj!Ct#im2^k;EPVnUm_m4#zW2dqg|G=Sl
z+nSJFa!s`W7HzRDuR43721@ee2tz(0ph^Hcqwk~=8qs+cty|#GkHh>h8B;E!4sE)i
zlw~+#^m`#3oa7qY**9cXj&n+2o+b@veCgdJ0xBPJov{H1PLfhc-uDJHjCq!)%2k<O
z;-wogRd!Er-aF?-PG$d3KNES|a-~lhPF=%+K?RNOoHw?yv|m!Qv3%LV-Y8itXQyu<
z28ce@L76^L8VG?^9@bWqYp{x$6}q@RYtgI}1z|{vi-AxUo;6l%5f7oCEh^PDVBs#d
zF^FvXjCJ=`9U3>5eypFaVo~=coePst0j&v40=7MFOC_*yWCuw-P^+n}e!gH4^vZfd
z-rVu|#BFbaiGMO#*7D@PXBS8neZN~w36xYTMEx%ly>d{1taQ#1#JKN2)ChD_0J+pn
zvFbVz2(3qEc%AkVT0xCT1lJ=#31sX{@KXl6q4_>|5Y~#Hnn-MAkw`cQ)EM(i-r(cm
z`D7FzMH+|CM|l0n^m3_l_{bL*CGSxjpP@52MVy=25pB&r1Eglx`mUS5fdnr2s5kel
zHwDD<hA2z%CZoW9t#=nNJB)y9G}@%(8?pnPJQzSJuEL~+2<-x{J5Z+U<ZFNFjSwU=
zDu&%R0W{AvUdvg}ZgHi_GIzeMv9w=DY%cBw>Zjqyf#<*Kt1(W|ezSbpunRfQlv~Q0
z4K#@2t`5`|;*{Dv_pie-vHt_;UK=HHv(JwAaGL^8sqYU%MnRj%a?M&Seoc`M;Q3*(
z7#9&*bv#AI&wy*KxVhB}$uVzs0h&C+tORmlOFtb>tY~3)=1`QV)|x;Eh1N1z@CFC+
zGcA4j;C(%kB)vCr0`H%<$WIn;k~ZJ+JoTF@#K7|h0xH^$AKs=p`b(khBIlJ4n~Q+Q
zFU+?p`YNF#W$0g4g!c&;W8FT?v>wbq8rtj90WMRd1Q>fwMgqDD_;(`OpDaxr?}_|6
ziA|t5KdxLYJDvS}v==V8h%j-JSpT+NVUuU-Ie8OtX<WIk=(1eZIl!B9CVZwhy>xbo
z#2kblJGSz4dQV4P@?qUOPxwrb2!Ra#=Ahamsvn0Q0(r~7Q-RBQT8!Dn@=}OoF#$eS
z$wY1hI=R}oV)wa65mX_4G&z8ntiv@L_nScZfgkS9Pn4D@t33ynhgEMnX&|ifn&1G_
z!^dOhX_QyJ(7tfB++*11ZNjggC92IXJHtUpbYF&^&6#^-(pk8n2o9hMF#4XtEQN$V
z?!HtQoqs)Fr+BP&Ij&<(zP*h$t)`5gW90Nme#{d)1-tTKGU-v>7WHfebpTFh-)psC
z(cawnI%#t;4*$-r!*TCtHM_}NIYYrbkd@lrGEPDj^7~%2Uvu_RX}F6#X4@#d_flCW
z_|E9vgzZ{nl)L;7b#Ce2kih)6uHkF_<<vgk72T`+SZim39Iqmt<jXxMtJ?(rtST@M
zN1T3tQQGr!BU%UV=~$!2X<<EB`Bj8m?uS-NpCL$SbxsOk?87)hlZ7xbBKy71DUDRW
zesCr!e6nZXDo<14wN)(*@Cx;w=W^pA`Z~Sxwsa1OaiPMR%w~se1zM{Wt{XaUDWugC
zU(L2T{?9@Ldjx%yGfifvsfQ+RueymY!BF)!zxXwc{-32*>b`OAS|VtRG$h9F8!x5q
z&kwo1R;fIW>>;fS1x-Mm&FTg&vL0yW`xE8Q*Qn9xgy_zLtP+}e>mgjQ#rb1KHeTNE
zB<|}&jZ&HMlqmhD_PbNePdI!ssNgssDx(KtxyfHUK)EklpgB2J^5PHHw+Fn@6EBC!
zN`AEot`rRBe0<2?(c~zxBR*Upo-GcDKTh_V6}nY%ub_GZI&{(>@si(s2_$HA8|Bw3
zwBP&qL?G~pJzF;KSDa9G7#iyYq##6GJcB*Q5<SB?2z#b>JKnsI{48AgRb!G`@HzKm
zxZDoAw<D>oHxq2bSQ$^?@#={@gp^`}@I+XD;?lPtI%P?~yyyG$yr{gw`VGWB&^J<4
zt9K}0#E%qDda**{N&p9W;1JANAc&s+_X07bO(5-zUpO)Q2mQ{=gudOnf!}Kv^VBGS
z`5TSQ;MT2^gPhJ2dw=?gh7O{dpGs5vldA{01&MU|YA4z`qv)>t&l*i&){ngdu?W-C
z`XUNiNT3hdy$G{qO}obA^sel;<t2Q(ZEZTR;nn{6#pFW(yn@mU0YGw^-5MSL+U@=?
zP>U78E6gRe)v71y&dGWGB93+42Yfxt%ZH2>Wwo68^3t?p)#k%S*?Fq2zZWpU3o#Z5
zdK60(33{b51QVHrT`#t{JyvZ<6nr05lXAn-3`di3f!P{DsO!Qj0C<5#1x=9PgA*PF
z1kj~*eJ$=E(u=YAG}oncC*Y~omnBkwigQOn`>RL&*KP0Mxt&W(c{%db1ae@P@Zn7<
zbO`hPV9d+L{pFe}J`X?77`g2JOXkRf@JRIM5+3%G6~qoL&$QRhfZpAj4LdVVPVCtG
zHFpfglY%3@R-Lcy4$#2pyPn|97n;79I@uuE!2Gr%CAu(`tSqkETg)Rg-J~Etn7W(M
zYl4(FY3W)ZoU~mOs6ES7s_xCTts&TJY~tLm9PD@5?9Nr_*Q1h8P~`0>*ezJP-%XJ}
zzw-&Yyd~$Duja_)`~8Ws2LiG>h}+q}V~!j{4#4xT=ouZgCSu9;G@+Z4cuO#hs|=*x
zumcl4ypMKI`K|kUp?_El9Z5_KCzkTb4AqBl<wZIX`iHbqAw%z;<oCJ5>&EvC&959D
zOl;x)uANS2%|6HzOp_CrLsl&L4OXRp-4}|@c-}wj-o@I<SIhNL#ijhcauE|;O9t{n
zl~HH4(YW>Ln7i3(3v>jyIp<^eROV#ir+^a5Aq;P=&X!EB(J%;PHo1%JNJSq_kf5o@
zWrm^R3)fcCDEQli?+gP<o!Dxj4{I`e_<p>Io$c*f!fP{or`))0E|?=FID^qRG*@Cc
z!s&i%&jQa4jyGUF#DSvDDX*31PY|EdVI}X9aYV+h)Xv0u8ElLPXFj8@Z1;$Qw53wd
z>+c??f5+UN%aUN@4x=&>%VE%|;iy$PcTdxyr}MdoCjhTbEzYEHIo^O1!TG-I1t|Xb
z42$~Nkd?V>$DJ-0CA|-4*;L;y&}!ZR$g~A!Q^KvcYAj${k8frcG}u4Yb^Uzl6bVeL
zCzqkuD?=ENU%}q5$`zxnkA=a|EoL<x3x2Tv**2HSo@XZmyUL;##qau|;UU*Qr2rnt
z+4%-0yggsj@UkKHxaM8<5@^FsbfH$QA$?EvUJ`qCdgJ^(3KO7O*Tjg`k*>OCzKH8Y
zw`qi3vIc%6GgNWh#W=%U^)&?A6p4gU;)NdJ(N?!tJaDrgT}j%|DdmCp)h(fUh0})C
z14SozKl$gshnl}h4nAa$Tys5*Znl~wR3I6<=y>wNaC-a+OIjYi9tulz=7~`~K4;xp
z)<DSUq2+4btV|RJOTh~Wt)!D{AFJX2fa;mN_fUbJ#;XR(IAyh#R{ubsX$4Ru!l|q@
zhL&M<CdrQ$IHxo?FjF7!zV5#!gHY-r9LCy1uTIv**Emmd1*<()ta-qQ-V31vC*H%p
z<YmKguMe9vqTF-(7c@119U^pkZ`gf;;p4_f5oo0JfjEA;wvwMS2lN1<q=I7X+tjy6
zk<h_XAFDN=k_C4rqXi1??&B0kcx0GqgJkkgBtOtqS#H2CcHywW+YqqQHx>;caZhZl
zc)@|u7Sp)VnQKF%0|5H#n1DGA1JI3n#Nx<EqNQ-N$O6`ifCtNj>5+0_%r_5@T}~N3
z*Sx=Y6tjch=+0%s_=&{fwYKZfU{n4Nq1~Djpb*!bTsI_Hhc=GMfhnD9N2%fjNI;>Y
zoQxK5Ov%mB$0-?JS74yI#QDn#L8*e<Q=~Yo^pB!PbLHO2gw-?!n&K<brc7X&DuWU7
zJ*@R&7zw@>ddriPSi@+#J9Dcy!qfRPh@XiCEKqk|ey5N!GE-JHyRLg~^Qdc}rG4PN
zzq8SBvzyj+7ERi^HtEbhMNk@es~YGKe7fb<O}0tOY<Mt7qfwGc;0*L>Y44u8#@XeM
z;6`zJGN>6w41}51TixEcyV~`-GkL30ukBo5EqS(5x8))dA1wXAtuQE;E{Pa^D;m*Z
z^ouyhx)d7=f11^-TXV(fipx56J{=${y@eS9tH3F$pEx@^GUV@*J@)C$KxChu;FoYb
z{vWplUsD9)HY}fbzaU<8<>AxQOt3Qdse!b&I^R*PslF0Y^`W!+zvfB(+3DduPu}6<
zGq0C|<8pI;)3rTpgn<kxD|__-<xGRJYEJcvl@8YNbw;dvo!@d?(m?h17Lju~?ZY~)
zNJ>*f?kE8ADc@%1nzR#i4AJ)5WTx&xga1g~1ABdN)qT8#tWP9CMzuykpE-A|;U~RY
zuD$=r&gFbmqvp$>;UM&sUu*EZnMwU^CNt%e=kutbVwt>V{xNE!%{kt02O^7zvIgW=
z<0u$S34qh391h<zEGq?NgzO-T^<7y;&Rz?&z(@rk@_c<iyZtE+h)xvI+zi0OC4mxu
zcmo|T^*<QaAVfe$gAj{?3&!bJR=PwwjrX$z&t=anoChBt@y_Z~gN@3aDWiZmNQlC#
zA@T2FP#{@_>nTA)Q+~WH9*-fZa@jHikR(m(=o^hWUvcHH>YOAunk+r6XBmwefX$VR
zBEY|;kHHiX=|;IbLj@<|^>h8;==7j3e!%uapIfYr=ovkn=<)LoQ2Jj3Jk`BlI)wzj
z<bQHDiaq$_2&%o|vJWf{?3tXoI8mxDc(~Z>*=mV-@&D;;e6MHYs|(IDY7O+!--;7_
z{LG61BM0=~NFwlzm{ueKBr+54eeD4HTiZ`?NJs8qcO>JgYnRTZr_<%m`zD8HC?IP~
zRm9$Rqx(9>Fie7oq^@Mu`^V-EP7xyE0y6Lr8Ov5LTc?jtBHGr?|B0jE$m?9l9fU?`
zDiqgO7su7C(dZv`YeoO+;*>mD)hysZK*|nEiNDFB1?2<HuM$h|)8$HDTfj>;w#WW=
zv!6&%(XDK3x~}~7q9{|4B{j6)LqPKPsQ@-N?^0!?2t=H&i933s7mfPJ0s(Zgg-T&B
z$N%LfnJEAXzyaUd`9z}px>x0Mo8AB0{(nfbCip5wf+_1>p9eRN!=w}B$n&b<qu&7$
zHU*HNvMP4^SSbTsN2N^SgV8@I{9M7;p5Fl#5>6IZ10RV#1ei1Ao<`Q)^N2faJiK@e
zlry})oGlX&OK?Jja2Bw@*PjBH(9%)<eoMe6d(ePRiXOCi(W&>&Gz~WQ2&t>Ua4WTt
z1n{Qc_v~wy+~|Yimn>w|zzGL%tr7o$?ti=aPb9Pu0Q9DCVxtLw-n^2dEcnvtAIO2C
z^?I3FTj+fa>qKy}u*i^QlJWG7choKD6YVe0dO|{7^TO$Qt$=>+(4_e98BYK5YX9e}
zQvrs&ivv=AubfHX?C50i4_~Y;2QW$n^=QvrLPR|$Fu<<ViN?wX%?JEE1Md}x?Ncu0
z1AIKXhvSm$F9iM9G||5=*hBhCKvFZJ5LnUIZ_WPx9si#icEKqD5<)atTeF#8`~m+a
zrIGa27X}FmMPX39DoN`aXx{I>uL%=hGYGkVN|^iwxAdySvPppzMXTdlB1NSDwh6ZR
z;w=C7-2pq%_6BxEFSt%GC3yV`qlDbbT1!h6)bJ|@|6@*HfoN}3kL>FL?t#wk|FFQ{
z4!)86=H(~WT#qv^6$<97f`EHpHvCr?<6nOd`$`S8i<92xW%rg=Kfpoh5&?sSQ-C>z
z2=N3r&<3c+?@83@{d&LN9KHoz|FFh??}kMFRgGrPi))Hzzfx1QxweJrA2^Z;APhJ<
zNh%x4z{W8k%0_;fB#6=Ph~Ne!yiqVK0>R%>%Tj=WTNqE#6+a@skg~B+z?LKe2#EhC
z@P8!tKNRR;c)e`~t&=p^p6|f<bo(N{{BH|VqF~qS-S}0joHKtW76Vz~y<2srA^Bo5
zBMs(C6BI$X&b%20e0l?s4|(MO^IJ)xUR4*_FI7!tvOli8DyjwHAC4Uq3oJ<{7Mn{K
z8R!FO7dj%i)Kmo;dR0(lt`?e<<2j(Vn_S1~{z13=O`cGAUPY5fqfv!QoA^~&kR?ti
z&(S3h<B6PYu=)hB!^r`f&0?nl-RHo=!5H<Yn!(qVPH(7CaJ}hQxYtikyy3CsLRi)B
z7Z_MHHOBt$h+MDa<2qU4>KXw|KvCkGLD7-%axei{o-T%Sf(^e{nn183|NmeGSk$$Q
z#pnscO9k{ldcitms=H%jVD(^tni8+`#WGUsLVajUV@S4nC~4JnExys(l>oHC2Yxc8
zAx`1zA!0fapaSoyT61Bf(daPC6n6_BD|RXFuAiRgTp)EEvi>$7{!6U>$JX{2J|87~
zk0^7RjiXdFk>9dH2Z{_IpMO2fG1)#R1bj%<2Dg^V{CxOA8fXb-Ac;2p{lVakux9J`
z;df`Me_`JWeBk8shz8k51N}?z35*#+AB|KfY;C|{;UqyR^hrU0&n|z$%{T-H{GBRT
z_rhO3`*$_>@8QORY_IAyd948#JqZ0(646JH*kN$19gi1rfQJFQZdb=e1O+2SM$7Ha
z@d~w?b5f_9Myst3jy#gWBL=X2cWDEj59Z^)Kbj}ir<i^~IObG3hT8S3_r*M<8fFut
zjW3N*SNei?VK_n@?0Q>{f5FuWvEk!o)JMO!bWGh1az!fZK6x@lbOwm<f7=xl{)6?a
zKA*G7jf!}~r=~{J0e!Pn^fVx;Gj^$0367pO)TH<aTlC**)0^wntaAB{iZFZA0KTJ8
zY!u}klu~iLXaYl6tUa&WohmBk#EiVp`+$3EZj}#F7sER3w0#r@4ajd#b%&1DfriyZ
z7E1up#$LoGv2BBh=svE+fj4K7%DQFk1KR`XUBcfu(b~-!kQJUf9}YbB!See1|7-%*
zA7DqcA=%z>UL_!FXoS6<MbgLu`}>n5(C-Nc^{l1vdeYpg=@!|4kjB4|<W-SazdBmh
zV#)nFz&vW;V|yU!dGplN)QMJCbj3oDqMD@On_##dGN!X&5&99V?#G7oZ#f^n%4dJW
z<SwBshpih~!V>b9#^Xdd6hPdP^63gqkYhHqA?D_gNEFmS$N6arK2<QBi}0}O`J(e!
z1LpL5q>?wKhaH_L;{T2$*#L-jq}440gJBsgoQ8j9hZL^Dy?*>iFtD{sFy4U8SL?HR
z1Ude<p<Vx>$$zeSg9JE5Ph~_)NYBSt<6&<^u8ECX?07f}5l4&pnfCVs^m-ui4!2)n
z2XLAo6>Oe7?p3;=)HX<~n`Ipc7-Y!&&Uoh~poZb`xxhgvm`n);?>C%h+CnI&<!T~Q
zzcCex5kzXwU`a2WifHmri=o4FgR@I6{1j;2|1g_ZD<A<KE28Ksp8T4c4Q|^Ass4fB
zE=bC)=rFy&uwt}1<x3N?*8pVz#+v(IEa%-LLel7T_I^E1OKsxIV_?kfSST<Q<uTYO
z(3$d6$2p9?WEz$;i@plg&I=0+XZo^ji`2#UzuSf&NbpB@5qiOGh9s|FuQtqr23<pf
zf_87QmYG(Cp={*W>I<rPSaM)yX2E$A))$1!O?w|@sCt7HptHIJq4R$PyeAT1H(eN}
zD9$;c*BzkGVBAbmwvYawoerYU;A`8)!2M-buKl~o-n&OO(;^-2n|x+|)kx%A)?TwY
zg68EriD367z>t$@!YW?84`&d=r?rJ~eZYHL7tuXj5$TkMj{F~m{Fu>N>{Y(u)J5#)
z2jlHW0(-&$8G_*m{3`$zo|h}o<TW&#dV}{8hBU{Lb;81u!ov21y^O)vQ=g`bW=hTP
zmoFck9Ic$xJ2IaB8s#KML4kpRfB+{32Rko17RjU^BSn#<0rvq#g0>VS1p3|yuC|qe
znjIj!ecaq05tHCFTU{<Q-cR85KfajR7|NQBwm@ceAb4d<k&ygrDR3}vFF`?)GcXhs
zKOf{bHgNp@qBIq?_S(2`Q<VsiOn!zkF;t}kph%6|nK2GNvK+GL!z+cO7Kkj8UW;GQ
z8BVJL&19vB?i%0;vtRq;!Z`Ww2%-=CWT<B(!dVs&yYGJ?cVy(;Qq4>Zx}?(kv*cWV
zr*aE_XyfrQN)Sk==?rz{4Uk!Ez)pI28T1>){>qIde1D312YT4l#ty9*sCjwvDNPho
zzllm&;n?3f>}k6jvtUEwID%&!{Ox(O-r;MjJksM5Gsd@+DKz~d07)lH2WR1huBWe0
zUBIgX1147(LfJeG85-I(hVJ2EUTq}3X<py;qow39@Ww009Rcn%4{p58-6Uj5V<mMS
zqx6W@-$_G)QW4}uf}!dsi30=iECK<MwI%=|kd&G%3EApeFZino6Or}e=0-2q2NMS2
z(NYp}hv0HLuUZW0_HiIChh&+>b?w^J^X|9ndS{L&3M#50>f{K+g0^YGiZ(Vn`dfjQ
zU8r9xE2xyAO5*V&Cz2T}s98FeR(tb?{OLI&P+UC2r_qmZ-B3ywFlqih3xJTYcS(ww
z({gY^U0A4&o?DG=q+$2ArmTZRz!)Z`|7xEQM4~07Z$Av1@ZAE&=^A{z<+S_o{;g<b
zrZC0+@zMH5bX<hcrn)cwX{01&)}5)GG;ZSM_It3d!LVaBeSNM+@RsxCT~s$s-r3|Y
zUvCD|v58LZ*LDt&TwSSKU_Ja*yxSUVPvN@AfhoZ`E#lcZ*=sLD{Uv<tQ`c)-u~AE{
zSFU3#IX!1A@1*>bN=peZwrE4#oI|`H&0AWC*M7|L)wLxQUG8IQuo&pv`uk?>zjqzq
zJlxGQGE|gszu0|e(V+5m!5$kE6Sm3G?J0eIu)10N#sxEfR&G2Q9{V@MiJC1wLCaLt
z!*=7XNOzO4@XHcCoy#E*ga66SuiQ;R3|tk-{gIeWDl94-FJC!%TImyyFxW%qqpWBE
zIBYNk5qt%)bzX=HRGu_N7BP$~Qfb)jw=2O+i!hFX5swD$3Sx^ZJug3xWvEuzjv0K<
z&8|4|b0QTx5IG49qzSL+ARG8*8Pax`9D|e2r59mK>QwA=b5kd!BUN{e9+@6f&Qx}6
zogc&~r(AF9UPCVCsjJ0;L29aPe8T5u8<Q^cwjR%P9__W{mKOTh7b5T5N&%vz?1>+`
zZ)kTA#jtj1xL8=gxcB?3ZWqeC&DJo#1rn-!t#}Y$-u0%$@G#kiG<vw>?tk%M;z@^^
zSHoMJuoxeBODN#(-$&^i*-Z&o$6?L5V%&x*Z+zat$anK=B<QK0g_MHqIX8&k;7g`*
z`bB`Pf92j<H}WTu?>nTmO6cr*Z08Bqh3eI4_21?Sv4utG+b7lu{m4)x{b7#yD}$fn
zqdcul5}Z!Q-hMy2&8z#M6j!{<5c-@^vtx?qsn6jiqIq5gf&l-^Exf8LaPOZ%g3GpH
zKO0yosk{YE1O-vx6uKFxJP@xwv>T1@6lw{aB%NIDiqfivXJ)STAQO$FUJ+cDGkba!
z#ie9wjv`f5N*S?jEY(|DA7^}?ceM&r>p!jRHYDHV(S38z@c8H|@Dq3zb*7kYmmhIz
zP2h1cv{fX?6?vl20$Z{4r=m$$RjmLnx9H*M!$DX~3-Y^JG`O~misbR#-r<78_9N37
zt|6b89M)uxJ!2A4Ne|p12OE%plNq{f#%d@~h0V0D_HMZ^f1*pu=+)8mSp6t`p0H!k
z4})rl==NKR5T#L6&If03YvO#g;d$J+)$mu-$L+%$!<l%iF_IYZngGr3sg)MPr!cTH
z)QfCobBGyAW+Tm$>60r-F%ItoGd~3vE$jFBFpF<R_2?>Re-o=Qn;Ks;>Xyp|?X5K0
z9pgAun+i3pV2(oBe{0u@OyfR@iF~?kzhT?Ue<qEVh;jKPUnq#{L1=1Djsv^(nCHu7
zV^fS8EDTHuc-{~b5PQH9k<omcj$EcU9PVr=03W-H(gf)If13beY`}t?Ssy#PsT{7S
z{}QCBsJ7Rqu*4U+WeebiM8SpIfX~<0YLSGz5h){NVcuz0*z50QWQC$D9yz$$tmk_`
z74rj^78Y2p1D>(zmn+p{`GR+<XNK+P6We^~US|)CGO{MtzKsy*iu&Q%KGzE)-0A9n
z>x;ku0||Vu5JL?_I>kF!NK71WZ8vh_Et{|!6OI+3x;q^eq~)`a&>G#M7@P2Xvzlvi
z&YjM@{_sVU9GlTD%d@ZWmMA|uqUpJlFzMuq+bz`&VnzosKOcr~85XPAosrXjbW)JE
zA;rLWuL+~|%$3Y&dH-n7<$Q&}2rou*Mv98!2Yy4I(wdeo?}?ysl!iF5dUoA&x;yJW
zV2-kj_J^VUFGl9)dZkk*DK<3*OwU^|A(|j)Rbp@B2qKxu3LVVukF715c#@FiT7hm8
zai)ZqFZ%p%;%M2J^r<S?P%m&*D;`a;)c8SjiifE!dgEv{mh7MAI4Duz2CQ8{rx^%I
z(015ag>DDi!O|)b6m-JgwRh7jK`<;0<KtE~vE;w$;*D}Ob@Y*%97bTHKD*ebd$lx%
zCb4dsiwdi?ofyT#u9KF>V7$-L-cKe*#C?<N(3%quVzOP|6~}#x<}x~UAM{Nj=@-u|
z3@Wp-d17{o8Y#b@kM4*{;panC`U=_9Q=dHB&rm^>#qFF@KPSpOXZqgl&ADewW&7Ci
z50S7q?n99C<~dkn{D&@Un__?<^RKkl8*ayDt)=g>&$9@Fxfg`NV-G$Xcp#C9c(cRU
zq_BOT)FiAeuJs`&2j7!&gMl<w4XGk^_wb^V=J{6IQ*~u>8Sm~pM{nvKdH1SV&->{c
zuW(!qXxt5Px9-`AOHON#TV-WX;8y5bi1n?6XkHx^n=HyRijPK5J%*7un*G>cX?ssy
z!3@CmTFC@X+P_P?meeC`6I?G|AC!<{u+g6<N5Q5a+Rv4Kah*kk4<FtSwhv>AYaL>f
zNNd4FsAZ;an#$yBC;1RujXtq9=npzm3k$hh-D2c|E5@?y=$lz`R-*y;Mh^D+GCNY?
zoM0~V;dDq~=RAR!SR?>k-7yDTX(CUb92WdL9~=6!j!+9d#ve}AzXj|ME+VNV1rGPa
zT%y-S;Z@)wn{HU&DNmPvL1(jgOwuVd8h69}p$)mxa&MIj{yvL@i(&v}L94M&66;rL
zYUgzork{kL?!l2xP;jua1M}X;UHyx%B$J^Ba@T`tAZ^RjAjW|4nXoC@v7fPVTzsK>
z<*|S_(4armRs1}R0D0cI%HK-fhm-<21j@w3>;Fll+2%pOb3;Glux^l-!&|No_myYz
z$n(92zR2!Ug*ny9a&yU%4>G{y$cAZ4;lk%+8AUsiPr+Q;dU`o2VWbpSwd*VL_PUUi
zvTOlA5Fo|i<3#3eGEAHChhn2T0=V_}4dP+okvnS|$pz<1m1}P44VFPGw~ADg<V?J-
z9;<@N6XEZM{vuy)%P@dq=x=?AS7t<oL%@YgM0Q=aL=>W_@JlKBHA6}F+wn#D7CLn*
z(nCWvB`Z_tIJ{7?Exn3|i2oj&di>Ep!DAc|!S3U@a;<{i46>*$)3_GD{EQq%i3q@@
zCEf41)nSE&x*YRf$}Fq~(*~IYKj|YFDyqkxbt-`5{@|)Dw?^8u>zHH^3PBWBdfQFI
zrd|ZJhr_@QK^UIDuRMio16*__6Mjv)7EILS>AZT8vLLqv83`|w2!CXg$2bcy?-i?z
zLMA<23KW0j2%-dD%5M$N9j_&`F$-B{nn-r=8F)y17Mz|0kah|OAr{9I9LJF~;~;K1
zzN+2*Q{)6hR>zylI|&kPRBt|N&hu4PV)(3%g)vlHyg|_n_uFyp&C<76m1t0Zq1qqj
z70g@k<Etnt9E=4!dlLLX$I9{ZuLg5vVUxL1N+R{ZW766e`ec}XeU6C`3#PD;QzTnl
zZdY3z!29BXF_2Xa+k(YZPm$CrsDmR`Edyldr;GK%N)nKHwpCT<>ziL1?03OW_!<J%
z)=2anM#HfgGi+kS?VFj}{qkE{%#P)pE{+%&W3tn39k2*rXhWmRV-aMN&U%9yTSCSf
zjUUW3<6}>$OLoQ)jEOE2+~2dG>)nQLf*J(XG^w`Bb}^6m8}LL4NJybAhE66bWR1QC
z9==3_v=i5wJ?Yn1Ti<>$6}nbu)Z_~}d`az#DR9(ISRv|#OOO~HSNAD{&7;@6CTwY$
zIn^v|b&1>g25OF(!dPJ>+LVj0?FuBMe5cX`g*SJKM8+<8@q3i+k>4^`k&QqAB1_O&
z*fw$Un#W{<EsvW)izoc+gNmR{2epkjv-q2DGj?7>gPz*~gPE0ax`<g`efR>pM4?+I
z{mp31n;ny3T%PwR0+#vTExsw%1I?|)J;#!b9*1moCmNYWIX*vJZ+eo_8ai)Q=f;O8
z0^Q=9YVduJ)NG6UCcZ=r31a-kNxIv6jlCi)hBs@qlR#^JZ1k!W!_plOp$L!!aF-v`
zHT)-ipR{M-m_2N_X$FcnMQCvNobaSosEs}}I9=o15HED}N5>MJ+)or7swhlarPhAq
zrBML1>8rvy@22BcgMVdw5fr$M3ZD8S7TGcG6f2U?s&aX(PP&A%pXaAO_t?eQc;+HN
z@(a}^j+5OJKXc|VK)ED=#XqG%4$BQjxx^C2+46eK;c8iq|1gt{<o{8NZG!FI{UF|(
z+gWk#EI3!Fymx5wHhz>O5|wyNz;22og??`6Gm-mH-P-YI+43H9&-+d;OG$7s6u9U&
zqRc%K-W~mtG?`&fRVJ1gw!^0Ln}ze=5LQ@mW7)-m{^Feci`OIZ0CVm0v!Pg5<_9!j
zdL{W>lYY|eFE^4Vvlm<7+zg@<i_@wOrXH^f{17}$WGpqk%&<KhKfY9uw^#hYD~%Xq
zgaB?p2MS5Iy#V-GaBOggq7fC2rCGnbu(Q25-|b}`v1El!Nr@WsV*A~g8|`-~*g<cQ
zHtb6(5hPQ^9P*R`Lce?9-1>;Wd(j74(A7iKThF)LrPA3F10>Cs{S2GAh*fzVan;!F
z-l}OvvEfL#OwrtXJoCe+dhuoVsB*0*QU&)UxNx~KYF#A?_rJf*RwU?KkibOhwWdc3
zjC-Z8UQ&^ve>0D}O#rm19sh@N1!eP8ALxi@d1dQXI@@Q)AxV;tNtN0N)ZLQTF1JVF
zt<s1Pu!G{x1fwVLDh{5KHYZbHN8AnKv>`eFML#UIuT&v$ToB;u5F0Q+-+_^|A2@yz
zC^A4EJ_OU0G~LDob^0Bk5|HO3zQ2{=>=ft-WIi%twc5-+SC<A}yU@)*P8%D?z{d~$
zVJm(n`L<;}ZL0Xv3Da8V;Uq5r23(y-o+APXkQ4i<x$EIxIZfh~)6o5VxB~n9w4}0)
z6v#5|X65MD$sKnjo%BPhhW4Kelr;;#d~(=pKO2C};rv0KBzdSf#{3Qj5_hU!_q4EC
z@*#X4k0=g{FJU)OC9~9Sh=TiB!xYBG;Ja%i9u{VJ)<gcr`-fBaAQFrgWX0aZAE@3D
zaUc+-kud_pYP{usYG{h};DeSXR>*(R;t#VNnT+BjFixa^F0A_=-1`L$V5d9ANxA3U
zlle+8^_oJR#J$b_6(|KENy&NFv<9LqFS68A{)(Y3=fQR_f{3`u$-(sB@5ByM-TVzu
z?qUqkDkuiSK$&TB6Q-Uc>RedN^r61*?yq8+zD+hn6y3K|VW|3gHph#A@<o;SEkkPL
zkhb&vssz6i@qV>`|Hz_8LPoZA7+-}{W5E%Lj7mrdX=BKVT~h_}W}zR*Pqn{(&Ph>i
zJy+rH3mgJzBN{FqZr=S6u-@8I=2s~d_Cw!aaULXlmd0hE;4y`PL>GVm29=Q_%Z#jF
z);u9ZTw*9)C>MwFe)F{2bA7E+hW5)bpX>3?>io?dSzK6^U=lq|jz0zRJb$UeQH&yE
z_+M;`TgxAor1^HXgg3Am`otM6t0M|EQY`@drd<fIRd{zBW;D`*rwm#fCr`yk@XuHi
z$jVY^!ZZW%?ATCOi8P3v9u2L1^nFmAl!zvd`ewT>E%(bnbYl023|x#ou)4QB7v*e`
z;;=4_BDDa^j#WSmzFrIS?qtv$D$F^u|F{67wL!Oi%MC1tb8<-Q5c5q;QzP)Kno}?S
z?CnrKeoKksBk$X@wJkk^xTtiFuj&})AQVWGEq~V^M-{d;{^K%Q%RCov9FcxWD1O7}
z`${<Uz}L9uKl;|;tm<8FeAwqEduyd!=qh)QQT!FNN53FbO>B%pizArl(>7Na11ELz
zd>F{QB@BtAI?71WV)UuSe6fk@xwE!&a3d@&QLZIMQ;Hl{D7UE}Y*m=Ux;XuvGenkp
zD`acdB$|(#p#=%)o9B&2LBVWKR&uAjH4;j{RRqIXPOJ=ft*j~~%s$a~Y5J41kzgP{
zd-xnKS>WD$EEkyB{*j1Im{7AZik3x!-po)OQRs7IHilG&6y$^sw#wttFv`^GI>1Fp
zLo6sE74kHRlv1D|tN*?v97oQyy-NNidG01*=%bO9G}56GJQR8L=bE3G*hw*s<EEFg
zEB;mDYcaf8G;!nzVpV~g$4hJtmt=fp00KP;TGmM?OF$q=d~g>lSb<wazKfi|f1x3X
zP;U)86-iEOq0*Uqqoec_y-i4dOcL3{ozT994$VpDvm>%ZmKmyK1_Ra#eez4p8y*7P
z$;Wd3+K~~NjFVE*Dv!qHEGwh2hlSJ}ZPQDvh^Ohzx(L4K^SXY-x|=na(ZGb@#@5p(
zW^46{$6W{au9UYT<`ZVJI-1I~L)=u5z)<9`T6SeP9deZ$c3AX$KiX!U^}yq<IO<e?
zDuxT%bv|J2d|i(2n4I60Y||)IyJd|n1;KIK?h39I3u^Ft5=tPY_V~I+plAWPvLm&L
z7ISh8`c&kkYJG94gzrby@1e%iT{c&a9~!K$vC1?WybB9yVr=u7O=imTO~zG7kPkRQ
zT-U`ARTx&ZH#JliB>h8;$~V^Cr#-2snffHI)s=uZQ4I8L$KmEi7_6*nB)mK`vsM9s
zmNfvLajN7lup0z01+*Sm*n~7}6c|Rbnxeq`aQQY}Tv3VswT;H&`6>(ON4KXa@&ukm
zdt>j5xS^_=1!L>mcxq+FUw#D<n+k|2-DK4%bWPXh5gN`mB+|;9`c@9YPO4l!J}Vuk
z{sQ5I{QfaOKYD2#vBmz>LZ*1yIH*w_663uZPTl_0`dE9q*)z7)!92HLW#xYIXjd6?
zG__f{o%>TlbgZ8bT3%?j@U|SNMG<vtFeT<m#woNQB7J?Qc8SY+t43+guoy{3RWYEU
z=I5^L*Dmx~fmU}HyW?NsU(vVMHoBf?nYwQEl;v)xh!24$llhIX?sa6z?>ScnsZ}bD
z)VumVPC$rK|8G3B_LdAK0$Q2aN_j&OP&$GHKuknZ1|bboW2uE)sy@S#c)VZ>htF|T
z|C3VwSX~&5+x3O5w7i$O*liI-=HPbCL9Ugz(ry&F<x|KkcM@6UXHf^~Z2Jk#x*KX<
zX9txT8J^SQ?}b)zs93SWV<%eQ6Nif}el>c@EE!!^<+=&zuzMC1Ve4q&`?~{Kk%s&7
z?N3{q5@UfeIn{P}k8^(Dre`m|FDWH0jmCF*4R*Bs`~%Ob(uI3q$v~1-rmJuoEiR(8
z*;=>312M%gjHd!sL<Qrg+XkOM-dEK|hPRrMW*tGSFmBz#5{JBMZ6LiX+&@cx$097e
zs{LG5K7vNoP#LZp42qn24;_FUIfxmH>&N1!8vW=j%_NXh-hg|LE0ZCRoFFy1QjK3X
z+H>5TpvW=g6DITF@iY{(C1e0q6bqH?zq0tkKny@Z(Ibxx7ICz&?)>6HkmVJnErpN^
zzT-;Dg0V+xm>urXBPJSvUrXf&${YpYA;O*O=wGaFHo$TkgWxV-HL|lC+R{ha-`DLw
z46L5(*pw$OIaQ|=1+LSll2)g<7H<-6A1jM|lV{3ntcNy&((!qG!d=iXiNdx^XZ0qY
z(_0pRlys%I|HR{5KubpMGWS~W*G+VX_PWPX)DR|(+A7;+{^GRNT0b8(r39}77MB6!
z>DWzlDA7z38}D~NeijhWUNay+e6n6p`?Mg>hswr*tiP!yRaD4a1;>AU4r_)p*crXd
z?L^$%HsM)VEJ1VTc?T!sS!QH2-)z>BM%6cc7>n_cL+Ch=wbC@VTO+q)Dl-}%H@3C|
z1DSKsD%dZlbzV7;VL!6745a{8u1JGn@LYc*Cm+DQpMr*`ce8#pZ!<U(8!XQk_F!wu
zs5oNu4E9c}c6Frhs~vCgB+g>UqZ%1gYd5R@@V7<ol;0>iI#?;EQA>TdqRisLcXdge
z-{_^$&{LpRPlvL2!s|{S7Kx9YYqm?qChu$usmsH^%ldw3$KE!`%TCo(K!Ll7XoFug
zLTeJo8>jU_p@YR4a!#6-Hlp*ZjBB=zspY)gnCQN2At25(&A8c{EYBHaXs##rDo%kf
znl0%uUt~Y<2c-=t5jNF=Kb@w^hii267-QH#y_jr8KtWr}#AMB98k@U4UxQkyiVx~6
zmi_Z=!(N_0eBfTYy%!*rdtM&VNiXEu*}lvAoOtm>e<?oLQu|Ut1Qq>8hBW|{r%SjS
zaqM}>7`h#{b1hx3(rubx$E%D=9raw#Dx%Wqc|>Bt|4?7R`U1PKLlVXqCuS+Nrz%DF
z`6_SzX;;YB&}uLh7I<7jPc-6FlY`yU)jkse{!4U@%Gc&c<TipI9zP0~?)j7f9Z#Z1
zW%S5#3jKDn|EJ=+FUvsArNSk6|J3KF<883a<A-+7TT+kvRRnr<R>FO=>3t*_S6;&j
zPNz{xlJmI6us(9%G~cW*g7c<s9^b^>0#R=M;>Y|uMh+45;yXfl6&Z>zucd(n3z@1!
z9KNQ*g=+4Dxd_+UX2(<G60P>r)-jpG#M8rDgv<CL+5UXlll63DUtsh^%3!d|f!Xz?
zZk{a*ALE0yiRH~F{*wjX)507IPT@|@k--(&b$tQz6POlQq@PKRO+`ip=QN4!Y~_!P
zu#mHBmMLRMtKnbzcJVPWgEKr&`-k%}LK;>JiV3v$m-F7v+k!l9$|;rU)$av(Z=JuH
za1|c_QECU?$hWHfX`Z!1=1`@}@ZjLS>n}!$#G@W}G(jk|<miynem+%sMOo&Toh|hV
zx9&hR%*U9bu!om#surypud@m5AV(|aJpTXaddsjj+bwOlh2jo@7Iz2~N|93B-L*h*
z3GVLh#ogUq3KWOp?of)myZd*uXZE+BIo_E+`H_PNNv?ITb=p$k#=s7)(vb<4<Lics
zi5j0fw9`pqx0|5)PYvl14Fno_cLRK)v8`=uCnH?M3L61_yign&GA2;>TGSseECFzq
zohQ2~(Myah#%Hfo&KP0A87J4n85bzqEpSI+ljRUHm#b@PVt^hYP|$S<We}<dZ`3S*
zrmpz%sFcP0*;SQ#vCpnJdLRS+O6(6D{rHze(-nW|LLxqzRKChCCLLB0KbvG#o}>oH
zCN`neEid@iu7n;Y8tF1`A;s|&oUU0Z-VniE*&UKxXrnu$yyRG1bG@T{W-=z5m(xQI
z$y1&8%&kaIkURB<Nc3ycB=(qH_Fj8czXatr>6?C3<j7tf>g6$(|K@osfqDiY%B;B6
z?F!H6QkEMqZt6p583?6FbW@$X(v5XhxbbE<o_@sNd4dRspmf5~i?f#P*-JvTGWqMY
za*VLOTB(+rhGYpC^#qA>>shy;7%Q^dYOA8pnnN|`G)@nAoRZYTC)HL!YvgSY`ldXC
z_f0*^tH9*bvVV-^cBz&enHV2x8v%6HR7dJvJORSrsUE?7WSZ<5%XMqU?|+QH3oGT4
z-HAb&_|;+5vfqsL<CG2T`5>C!e&<p~D!@zJ?~jQw%A{3Qv>lT~1_FZg5ric{3Bz<m
zdp>tHcV^WNU7yGoZiK;E!*HebqhC2P8$;hOGccNVsK6t-TZ{rrdI8uSA$_wP-|4es
zztGY#(l=?rHs9XNk4?R0whskMs$53##fBiAWcmVzTXBbxJ>1wSPWBba7(95GF9*s!
z?^jU2?wvA}D|5Iq#dHL>Vddpa$cuxs%<(PhQvF)}+!^p4bg-Alw6m=GFkGb#4@6Y<
zePwHgylMlFQbVJ_Q+Zsqejy_NZ*xF`ORjS)F2|HnpOnJ4O3wd^GslF>bTHK!KoJvr
zNu~TG@bNiAqr=FY0w&iv%ja+lFZvobq3<}{=gnsy8wuIvUT)QiwWx&m(#*^4IIbiu
z{h=VR&}PhR;~b{nECO7=EX0~dy@E_A&uXfh4;Z2SH!LQ$91Rrq^x&<P=J(Y$sRZxD
z_N-+bH@huIeho6#-3I|AuwODuWj#G?uK9o|fGp&>b@kma9#{95zONvtPipMI%;s~`
z)NFADHDA-Kq)#cWEmRNbn3?sZ*12W37?roq#;ei4%k~!h_)ma%`4y*GSNI&nhw6kT
z0{%7FmdjDa7iL4D3|$QT<HMbX9_j)JF!XpgBFUIFQww#eg{N~qGa}TZsm<_BP9KI2
zx_%2JF=NE{K%1h5#)krL6F~`TIFR_HF!UQS7Or1VVMfPI1hF14nMh_2_ot1)s3A3z
zqWo|-kB}SR>}%?e8WI2Uqea=E(7^WgrY-w~<o<HqE=|)_d`5*9nP*(`%P026hh<L$
zVjT9BFO^8PaSn5o_<2+UKK?L-<jX=GJF}AhZ~<Md2CN2y$@24Il4g}_yFV36IEu3<
zKrImYc)u1czZ#j_6|~QX<z__hH;ZGC>aX|3+DkdD43i$jyNV)ElMfjWowb!URdv|7
zBDsZDr{;hO?u&+~C5*;e4Cf~%JAgTu?D%=YBFii5#n!}5roxVvCr!;M+9%YbXSgMt
z<)9W5Cj};fd%o|1P_Gsxv3zJ@Ww3nsbMR?_UQolp4YF!WMv~^TYOuS}F9w^hHtRdd
zJ|h!z5drDCw@Y^D%ae$dqVwy?dXS5dykd#uJbc;VuLpP3K!XNxe0<f&ix3jvVMd1D
zt(Q{mkHLQ@W<OqWwTzS#5d)`i1A|i1@!=x{z$+3xEUbxp6B6C$i|Q1iaB1YoC1cQ^
z8$_^#kv}o-h_RZt=(sLP?6`6Z@VnoLa#ZG%uL<0W)vUQ24s)kS)0RXGvSWHu0Nm{j
zOuTlRcn}<NP@U0|b=SvF_w}Z4gh^`^SsYOknaRs^JzmkdR$#B2MWagpCi;zaS_O?Z
zYek`zYgbD~YYcG}Z6I^8OxZFqjHccBb(`0df$}EhvJcISsd8^a?B<E)v<T|o7meod
z)m8L3uqKGz&JEmby@V(5RygNIH)4RnU2A=y%P80ot<G-yoUc(<5}!R3%?Nb@#H~pK
z%J!ril8c%Z@l=Zf2A4(dO^?g7>o2%pympA)Y>wm3R>bK6;N)V8O-nYTYvBNf$;d`H
zI|oKCOHOOc{<PzQG4SeHKsiwX5oqlpG=CZ{J~K5MPEy8caJj)~$$E^JIY1x(A;QHC
z_~y`zOW!CybpL_fGpi(nV2&Z96%h!*>Q5O7hxqjexWk-x1f)lHV`l4I)x!jOPG$*l
zxje4YJU{IK_1Iv3-P-!|GqUWSKU7nFqE$xj;5pyTM7sJ7@=Xx8y4}QjKon=D`w5na
zP`?_7Y(zihnusW6HlNzb(DBfN6LIy!M|z0_`aopd=@n5?wA;T1*XUbp60K_4rn_=2
zJeBuPiyVum@w{j*e*YWs4T|vIG76z__tCqD@&SbdSJ%AVBR8wqxflc>M_R|g7vg-i
zKjOw&$WoOcS9LRvhoijIWWJ*vp#=};cGo!Lr06Qvg%=^Qvw6#AL=7|<Xxf8g*8*L>
zX9s1ZB@QXHaUV6I%Tou&3}ZR7y=!RXz6Ep-DptCwHf@XYgkiQ<ouW%6vnMrBDv1LX
z@VjX0w%@6E@jgzX5H6BT#uL)l7w%Fsvk<xQ92;VQ%GO+Vq9(`E(944|GjM*P=}!^%
z^yKz<Hh$N7y`za`JBBFmHb@rykKSsR1gKpcS;4ds-a&4T&aPTt4Zy+Vw6U@u-0G95
z=qEuRX9c*nHsvU##KGAl+>%zTw&P0mjJ7PpJ3Nur_m5h)Ft;7^12B}Ko}sc5Dk|*b
z=J$4=xQG|U{uuC{YXN+#=O^#sJIx6vxA#2G&T{W?zNm#4jf1tQY3he*T6#|hPr>no
z2d<X!CG<pnTDXJcL%i+VepjvaYKOTjU^#AvzoQntr9j-@!ReB-{XIgZ9e}(5nkC-|
z3Gr}$-ykpE&id$PWtj_ywxS5crNPsD(Lf<R)**!~YC@bk1GglUx#wR2Q%Iu+hD;>u
zVh=F%Q4O}Ac)F(~$Eu50G64jt1g+Gc7Mf>ES(d?7SMh}qxQl6PFt}->guI&<1n0?7
zV7}hOD){yb`UGTXHQm{9K6L?NKjzJ|(BxeqEgm8Dgr7L4oft|LNfR%3YSwI2qy<i@
z{K&+Ca$h+b^uVyyF4}UI&Qv?4s5Jckcj-X3CuoRgmAH&5TuFaJ0S7wNKvn>CUE1iq
zh_%1e-&McQ5b-fl@EXQwX}{%kFIQ7HEE#BgQIk+#$`G7&h|nzRTv7vGyr?tM-xiTe
zI`pPbk0QJFnwrLMXgP9V22Jbd{jgGdIL1$|0^pY1D~Syj+B>`#vu6!jynfh`?W72?
zO8eP4Ohn8Y-p6i35M07rov~oI5-D`S*{z-{qkDrlTLdG>X2u-WAIS?2ulU|ICtT(s
zlc&<{UMGE(=3I@S%J-FH3QF<*jglmgmf;e1s1uQt{ge9X=010A8+|8@kccp((~a6p
znl3>FSSE5vq}I5UuAcFM`4)d>2a>3D^qLZFNlpV`bM3=v#@5cu%@^pibPLFX=2_VH
z!)Yu}>d@7Erp*AH(~I_^MVrFq`7M|1`Ky}azIL56G;77O<)l_6X{@A3*-GQP8%wvE
zL-^sf<aBjeL}rD~VaixsNwwvJWx_z88tgol2~5Oq4D<ddrR!~}#<ddT4xe3hH12on
z)75o4tnVl_iE-*O#K<I)YadlWv@w|~^vTVz3#`ZMkbH%D0UG2Fv(Tw?M;#$uh4IoF
zm2!=Al6Frh3|PrJgEzHG*Kzdv1NX_alW!fw_WXStk%xQ{={&S=b)lLWf=_ee?xjt2
zhgHJNFOL6GO!ChqK-)7L8zaE@?}P>%R0kaSPyk?$&S;IcvKkep@0Jm}q`ur;{bZG@
zqXV1_PwU{20LFjV`hV*^6p*0SmDNq>#j7KxLtg9AsE71$$xj0)ZEZ3vI#IrkgKlIq
z2W|T7)s6`iHV4Z{<)`?F?rG9G;2X!&Z5Q5X8$N4B?E^+v@BV)4>u23JeH7UewiKZ8
z@8BW9E7}qH5><#Y)tgp_jK(Uo2h>Vt(;6YL@!u?JS{37tha;XU#2p6Wb%@<yKYx4Y
z$V_^wR4ONwmG9Q7wy#`AHpV{zdvSl@4N_o47278f93RsOc7Dmo?ubfXUHT48j0mjU
z+5S)*b+P&)mwWe=Oc488HY^FNdi@io#Wts&obu1(qCop}X(MiKF^@_)v6}kbJ*hO+
zYJHr6+L@gut{W5a{^$^Pj>|@-fF(1wc5Hp|d`Lvm&fcLTirj<E#Rpjdm_%4ekS`7@
zK7Z#_4&z{cQ;%97$Qru&;?{WA<hXfjD*et2pA$dqv6**QOkm>0NJ*oJlPVhR+#?~i
z!D6?SP)h~U=e4YppCbzXb8)1*cz+Nv0so2uJBZjv`<wUA#^kXGyls3L9Y==-|Mfb-
zzB`?kqHr!}zD>2p|Cy!&FC;V`i;AtKYwt1Ncs*A7>DHqCF-vM+Fb~!?Bhf!+8S9RO
zMIqCjWFEt0EzStGxQN4){8TaTLF=PIp;r7^GZgz@tm3svebH9KaoTbhO0LQSEcY1B
zxX1}lU4G|UWF*%d``JWz7=$I_*0Za9Ps^hK4&kkSi8zbwgGngYf<TTf0%<%Nyx^*d
zP|f!WtkA--K3u03%y*uiM8-b|=$ie$2;hDKPX&CbsTxqJk~K2=e1(Se`;Q=V`ChNZ
zU;;x3O>O(e)@c>|PZJW(hzr<)D7&xhE+2b9*&Tn!q}0{b&AF>$JWL{+EddeXM2?Kg
z7LEN?9tmi?V|KKb*RH^-FKwTal=^TBX;!=kWH$|bX%0jK%$%1*(=h3-KiACE+HF71
z(k&T)6}um?)wj><t@>ns=iALWC&!JrC3LatFYbUKJjPm*R9Yp-<#cpQpC#jQ{esbi
zyvGqC;6H;}26@?Eb51BoWlj}V@;Hv!8$-tSmeb)r%%4b>239E5aY^>jFHCaJHwt@c
zDxji>2@#V$irL<GyF6ZAu@v`5ei!JRZ)aE!VkkU!6wfxN@NcDv>&#Ml&{dcy(JwB8
zVXTmFvTWX3>H2eY_w`kJ^gm=Fug6l19$xk05?oiNTqZ~ob^gi*$2Az8*!6yA>Ksa}
zL^go(dda$R`9AXpc&(9zovHvB?4Pe^UvK@_)?(NroM*~xVxqWsupJXH=-?t!g?)b`
z3U{YDzOKB|IrQ*WdZr9a*fsFE5eu;&*R$JO`z}Qb=H7P}PdnSZUx*-T6PQwzMz7jG
z3-J5rXx97~V<h$WMJ*4)CwR)g7}mID*Mcd522oz7#P`NUY{JKPk@JS)&;|*>NOY0A
z@!)v(vi<oJjpem^yGN+-wM*V*N$yR`iPurFX{A;pF5dLs@Il4$BmTn6_wJ!>P?OQ#
za{T544fnj8=v}kEz-%Q2PJn+~@AUkcn<f2-FagYe<bz`A03yl1zc`ooJ)TLBA8$~i
z<2mvoOn;?FIMBDdEA4~8+jMR}MJjvaFCg~Ci{vyZ(2tsC%OU$~^1Ezt{0SXgfZMAI
zlNX>H{7LT<_)<F3+}5%asZ1D_zW9qD>a_&KJq=)Z8piho8eh38?$zaE)!-zE^Av~6
z>3q89fe^_Vf|AtjaDQuy?sghDq~na4WbVd-{*IVMJkFe-+AvhKh3ZdTk$<rxXAVt}
zLqDT}vNNTdI?^@EM9m#V-L%-QA-5(k$fFSGjB;@K+%SZN&d!HvyLeJf$Lp>&gjSu$
zx^;GgDl4DwotCZxV3KSv<KiZIc_;V|XrtGRf%l?xsr+9ZiOP)$PgT+eee=DHCQ^Dz
z-ES|NOAg;XecPHEaYV1=FK0Ra#{NdoYzU*a?<pF|=y(XNIlc>=eg(kGNl)?-W)fB!
zOz>E#L#R)nr}nSp-;;(UNJpY;<TX6kgN?%M1@e4aEHQvNM#Di`Y-h<~1V-_?QBv6R
zP<si@qvY<aCU2aJRkJ?~>n81timRMdzccDP!`kl}IWYlN`W>9!Qn`(wwwQ2xjrny>
z@tzG5D|aV7Mh5lVuop{;eU_q8X|!YZz`gceFGKmf=lP)mYjp)F3`8Xn97F(dP!txj
zQfSQ$AmUTNK%~pqP3QOdefQZa;LzP;dlTmIcE)PfQI^&5yMPa-S*RoLHU8b($FY^i
z2*tj!v&NGrH|Dv*Czkg?H<_yt1=b_2z_8>rm!<w^?dn6c8yEJr&`HuvvXh45mGoAE
zN$M@*+K+h#0-eJ>?ODKv4uXn-l@TQfWEBMw^3eIE%1O+s$Yt*!GQ%PW{Cz`-K0C`T
zwe!>qSI0mUTm8C%4|eBQy9*#OH(sbptVk~&eEh_Isu}*a<*vi8R`q4f^MB`?zoYA*
zefEEaAqQ|?wF~v?7oF6GQdIEW4DED5nVAIikAhMXk^q#w<v0IhlkR81b`+<P?&ZlD
z?{e9WSQ`3{0p4dot#I!MxW4V)Z<ujASbjw%Sn3}Ff^c0$r9OPo-V(}KM1ZNM6Ps+<
z*t|)Umyf2)lILyR>M6BcJe{{5T^)QV`^yG{M)cG*gdqRZ-xp=UaQ%8o(l7{b`ayIX
zj=Y`RJ<}iRNC?OpD{+Rf=#Sa&{f(md+>geL6BZpBm`f?ZzqhVD-WLBjx*BkTHLU%~
z2>TmK0hsL%=i1N&l8ZDlx##1*AQwu~n=%qm5eW$9AGi+7E42WNF0VwIMFy%m85SCj
z&#^)h@Ifr`$Ho){gB5FNQ@$P!kUM@)@!9E0{Zpe)q^GY>pB(B)2tc)baB&nxwjWnR
zfu6ZYgoEP<^r^hHphQxNUmV`qa|G_d&7#)z7xH}C=UeZ?$1S%$v{KH22=Bi>wDuo=
zaA+%S%m9P=WP#)l-#YN*+lMISe#x;n@3`Fai>kF8?Cpe(&xu3`i89>`>vFwbG?!Lm
z)JI1@w~r$Fx5cCn#`}G}Z$p)6_%vEtHiF5A3%|?Juh5T@Y|Bx~GbO?DF^A)&tV9wW
z+w}0An!W+H(y@9*CMPWy9w*OAkZ57%Y11tj`0eH&7#?ns2JSA}N2o+XSC`GW{wS0L
z*xL*W0FtpDV&GlPb+jdFb-MMLoi<mqg{972;JJof&^xv@z#L@alX-sb+#8M%3|EI;
zQW1{LY?=F`tAQuf^yucfjTR|o^B{$BU?%&KHu-cTLN}v7hV-u-72u0$e?Jp$ImW3f
zcR1PFGg0mIE1rf7`m30?fRj^wn0)^hUO?KX=&HJCZ5*sNX-T*<d9Oe5&~TQJO-O!B
z+(RybiY&wLw3oyy*LNmX{o6Ot^VLV8_Z(B#N0%mVA{GaN6Rj>Qqctj`Z_A&UHwOrc
z_a$%{j_-Ok?G&IPWm&`65+Nbdew|^vwm&dv<6<(7HcHyiqEo{e2F{vCZ(ZGFii-e%
z_wZxNOJsvfn`>a^O9Jul3s~mCFyUCaG6P*p#-fKE=kr}$2DA9`2bInV@r?F5f2cve
zC~B`yn?srS^L7UMZsadZMN?I<wwp00)%A4Yma0kaC#E}mTLALef4Cj`7;sJ^+ooY{
z8$(=QSSMZ@3YAGfFneWPtyBm!tvlwmDe2CMrggL%3*!1NcSG{L>woi8TgvQDwYiM2
z>#hEdEQpc*h5<AcXP(bcE1o<dMto8G<?Mz7+ksyeaIB}`ZisYMGtXMelv93|MMiHx
zVl-_35L0TM4aik_?qL2hOla>aQ~gB*B9y>{P{Hm!r~rKG+B)7`pOPayWp;-K6($E7
zBsZ%JL{ZSo%#w0TU1;}Bs)RePfym7r;bY}X&;QlOpIgOG*N|1C0+RYy>Q7<HlFFU_
zJJVYT#qHe=gg8x#@8dWoB5;n9uw1;ZA8C%$LyDDWOa3A{nAPt98Lvy-CE@MoOf(2U
z2kZ$*Smf%JzWlV{Nh;`t0J1md+glulkJz?E#5_8PiyB)y2h*=LhNaJnM;nTh^R9Jp
zdR`C%lh!DWD)m+((J@!P%o=9-2oOm9adIYPIH1`SQ>wGY%B!vZB1GeHyQ$6P>6)7Q
zt$f;FliKzhgv=RzqAM+mnVWq^@|+Y<B(kRyFxNcj;h39m-e_)4SGKIs0Rk<Eeb<iQ
zR@on+$E-56YAgNxsa+yTP<gP7g~&N8;GIdTHGpD>jfrymhK{I&9_srKxewlJ<$w+b
zm!S8r9Y?rj%;^{%^t)4r$nl*YYe#4E1t|L>B2a>qfB*s%QwO>9Sa@g^t2CjGkJ{sC
z_!2$eiru;6?J915^r^NTzgOm!uR?w8CQu9gRl_;B-_%F!gLkSYs^OhM@V5P4*6Y!0
zVh#w=-ROvjN@G9j?NZOCmU*Ay7etTNAmuTDM8jTVF;qoe61++nlbk~Vib7jH+1gG`
z)4f`Ym(Op1v^H4?UUIfRudeXG+fLVj@WCh@-XR>O9ok!5(!QV84nc31%cUZtxLp1l
z;IUks8tl%e#z4fR_jY8fr##UV8jBJb*;crnsviynsmgp9ci?=2F(@iqS9EM*zff5y
z3iwUxYFf1kG3_?cW@^RC6SD8c)_UsY&8Pi_pB75uJ?kO-lNXLZ$4f!@LqHqMSonth
zGIpbdBIso#_~mGr6dTLokwqI`WcEt9vkc=~<i*Dy)9tashjX!ci@@xV-*g!ESk?9-
zs5~1eh@5y51OHyMS@jU_xERmtWJK!Lr6C3WOVPF@`hXCPIzzMGedpmIZG|FLILy-K
zSjOiB>D=cqvX-T|nzB2gKOYoq-Y$1~-tO;mDHb$cl|Cm0nIEgUs4H&k$f#LJ4V;hI
ztwsxK`LPS||NUt)(Ws*S^I%axSm5)QdZm@}8IpImr2`)nQthQA1o)qQT^QXpyg&@f
zLRU|U9Er<kE2&OrcdJ%cDKQS|F>+ZBAO`hpP{D8v0xkK22ZF7CqR?Jco6QVs+4mZG
zQzn81CyNkI!RFHaBJ^8Y_zd&3i$aEt#bU`*58bpz!G&VmIz+nGnnz!sdk<dzrx>~U
zLW5+zB-R&Et@s!OnC1uzo#HHdBkHvuGxC=;XyBVMB^+pzqQ)UF;ZCwU6k#%EmhuU4
z)0%x%3Ogcq&2qGcC5ID=`emNq|JSiE$Ry57zy|bF?-ZC`h2$|#3?|zZqEuPK@7mh7
zGh3-f=EFq+*rI=Z+0RV1*(Ig=tT|=4VxCd2qq1c8VZo8UyUt6d_@1JhJsDOEfCX)z
zpIwLbuHEH4U!+i1?UI=t`LZfaM>gSCS~u9X)#XK$Wdq{)z{Yd7@PlzhgF7;L2xPKJ
zv4B!xb;{PEaUgob%bQ74OyRSa$>kx77A+oB-K!)w<AH0_;d{RL6H(E*iJ+Fp&N8HI
zg~KnAX6g-uAgX(k3+X-Gk7L4K@$JA@Cfv9^wI(Y)#<|_ue`qd3Qg|u%yp05!-lPjN
z+xs3p+dCL0Mx)&UPu=NL6d-GJa}y0C<d77`VFzqF&pf55Y`JNvb-1(uUkYz2Px>ED
z(;EsnwQ}C1O62drf}I{?2UQ-TU=nD-1Sk$f0Ur#lvkEczY;T3Ra6(qW9^d8bIlafy
zSj<nkc817%7rFa==Lv+su2RoQVXw%W97SU|ez3C_zDkj!=g*Xh?tWYi7ZKaROZ|!a
z$T2RglcI|dQjpTVBI*}WkKRICiy>Y%wt-8*fUslS&(@ib=wx3o5cP8O7<1PJA_Be@
z^ORwdBe)NiN@F0_V2}7#lrE5J-rsWG(Ob6QReJc|vBydHS(#;<Kg0~ulBdtEI`rT_
zJUji_WSbV31hciTBgzbO=(A)fG2Sndv}Hv4$nhOyII-Z*W{%PEXSw}s2=7@NJK3-A
zDXe+=?R$zELws*&8{C-@eRGR`M#^?7gO?AP=aVv~<E7KIp+!n~P8Zh4ZYRT_Nw{_g
zF_8J#2b#bwRzFGnhKFGZ{PIAaE_ovM!3yv84KSLt+!Z83!&Z*`$aC*m3WGpyn~J~k
z_AR}?-mPUKW{9244dsQMQ;7A!8>RD&3jRsU2^jr?-K=fmcC_?O8FBW6O?1n~EZI<B
z{g-%JqMtGQ-%c@Thq*y7pjHI>32J~y%KaKMo`!p3<$en3E*pf($$1Nx6duAkI-YZP
zaH`3<*5R8@>~R&t!@N9fA-R96%?ZH8{kqcVfR+pAslOOCYz9c1c8iRE7Lkj7BNOPk
z4B)-MHm+5Eba01$AR@l`YCY6MsM@AO*bpC=k8en7Wcj60#56Xdvy+s~ZXL={R?~mi
z_|7%)@1B@YoE9|4MM-=8QD4hmL9NxVs^DjQRRb?^1zG@e_mabj>JD{0G3KJoUiI10
zM?QE87?>K?_4gGBApylXF$6|qLok2;O?9)`U2}=u!9w{5e*SN5f`o9#Z^0jNO>~S_
zK76#Ve5b;I2$eN1fB=-LRH_+5kzu`~u<q`5nj!~{7r{kX>R_yd`{hL2akDcUSr2y0
z%BZ1uCi9@nPeivw#QC#PE4FWnfV0>=6q;cFvfzuANPwBUHVU0EFmMCQ)NFI?&uD22
zE%I$7NI;vHU~ivRPdOR<#7g462yRJb2L;kvN!En$HI?|vf#301YeyGiOpI*rJf80K
zus>l$uO;zVfqs*RLAP%WDH3=zd5%293T%ca(&e;Kn5gj;o=_EK&W~zc288yL%qyG@
zV?Y;{)L_Y}zaH|mkd1`WN26hgPF5K<Ioy-T60*R}D4L>M`^O$az^pS}u?*`_(x7~`
zQ0-JK&eS#D78}K_PGl+j*32`Nc^Ld4Byg<84_>W8{3np|Uqb>&z6T?CNX|MQ0=Cv`
zYoil<`(#}3GJm5C{QYN24RQGFEZ41qBIR;y-o03(o2p)^Zl80AX^!}l<>E4L2ON@$
zXWx)O^}jFk-?zXU5eZXxq=NNqMlyCA8sFVeL<`fIjB-pRk+ZXAlS+#I9ANP*&q#l@
zF+NAonxzHhXXMOC#+1OrL^CGIn?(O)$<6)Z4<)Js2fZdBNfnIvL*R5s&L7sFjEOBY
z@<^VF^N_h<2V&<B#Y8*T$YL5%rWbeSi*_m#5+2esYV)w>a+zH}AO{RDqx8*Tv38^T
ze-*a+_`vXpwQt#zB?U(3TU9puo)XWW#VjTn3nf9UXiW^*7=Uh?`UJ8HF~hd4K>NlP
z`Cc#jS>-DJ=J*hrI&3Ls;qRLL(fzjz!S;RIpH`usvht@`<Ug8tMT*mOOGtC{CRYLe
zQVXCSRkCeer(b~qfK0I1kOYhMKcB{$fXIB!2~OXrrRTZ~O{qBUwz2T$=+7s1P{a+(
zOa#)wOh)}23;&?TM`JMvqo*O5e8@j1-@0dtpU=G)XW?5TBR1(^@|NqmAvUzBPrNRO
ztk6y)(C1bB|A$+AZd7TjBKIJAl+{wUoD?LL@dYDO2|N-6{OS#C2ZCo7a6UvM{O%%K
zJ$dh))iDQ;5>34P{-fGE+_bIsTtH~|*+5GBr}<n`WdO+a7vU;#FbR$_Z`24gtH|@?
z?N14I%LhhuL|8|Bzrx7Y+m!g|3!w6XW5@nf24y??nWnjSz>R~gwBYoG+7X=Bo)o5_
zE(s@52%84l@t;-Ov4*xQztqIi2LGzr2$r%IEB5zwhq2Y~++WFu_=pjIt#}$5nx$>`
z<Q=lkq&bTB_XX%fJ?9mKLBseARRR8TuC0keb0nVaM@g^M#|tlKz*F`gxAMOWfhoT?
zw=vc~MM@)XnMsVvt0-V*pU6m#++(-Q;O%z+_hI0;F^fyUc}4yB)H;7*st)=jm%#qu
z6d+0E@Fu^D`ne-yij#%B@RPt>`U=5=HL!A7%>>64?QZgQv0bx#tAyQh8YWQK=PQnS
zvy9iy-Iw#^Sl=Rw-JPT(!Mh*9-I%+eQ2aoInDwzgwbXi^ozrYHD8{}m3hB+YiO0ml
zF(;{5Z1Tv!VEVn5)(I0oI44>+IHL3phT|qD{zcL8%Pt_MgpP)xAl-Rv4VtZS(Gs$@
zMz8thl4YE2TclFzN1GaGkf{U=bMAb&=y8B~fq(JwhAx9?CAHy@chFKk+nf-v$|`?(
zPnK8qw`df~9I)WPW9tWveZz3uO=-5>cqfxFAD~j{t{eM_FgT6>T{<u}(-a#0(%x&E
z0W=WC7#NU$01%izUa16}&grF<t|h{Zj5)wzHdz1xETEYbfbf(wI#^!-9)|EciZDhG
zT3Wm6<%ro!8Y?@}-(Qs?V>?G66P^7-48YiT0HCu_2i6j0@qkv`Ptm!;mdJW!2TI*-
ze(f9k^?k;|>0{HOPKo){KF|ronW#XaP|t1)E-%{P1DOZEhrUzVd8%A4EeEI|33Td5
zz|f$)sNh5XCagM4U@!)nziqg2JLkxsgb3qr8qE1p0E&Yc%?t^4`4VLt=eWT@sYYNW
zS-6dy+|BoYX8};yaojAXNb-x81NJ!!Y>LE8Ha&p$yUibAo(9ty1;ZoP@gLj;@X4IJ
z>cw8u%edPFeZ7Mz6fAWKaAwbzaK*WM=~s1G4D#HY@KAg9M>X12X}>jl96x6#*53#i
zPO_uGXXsNQHFC5yP4tKVz>Egz%T&=s&)tZt44)<@7T_1S5lu-wHwKj5rT1JyT3^{|
zF^<#|DPhp@Ox%fS9;lRf*`HaHPFNC6+i^BHXtvJ%^(+&qTSkK*rN(_V-;!dr7q|tl
z1kUU3x9T-;2Iz8W9Yxr0a@_x5Ja~1bip{HKeoc~NJyAp53A6D}R;^zfF?D3p#Z}=>
z6#m3;`^lDlW)}ldMEZk&Fa7?R4H<dv=|i3in~my=+se;7-W&s5+;+gmD3;1f??|Kx
zY!l;k+Q&4M($d)smPQ&#8o*6;WY{pn^oM#vhQZ|Xw|b(gldJni38GCSPOkk`qIE6i
z7<tUw8Kt$6N5;!){2f2ji#skcl9(faW>|bVZj&MD{e{ZFL;}zYkZ5w?quU6^tbQfk
z9nXtYlA1mf#6)aLH1)l|`*?QuY;B7`1Uu+e>imC61pqeg6a_RTyY&it)2`@X4Nb)$
zKtZqQOy<30Nbyb0U?OI4HUHph3{6rEvAHVc(+2z|qpK|C7SaIrA0AD>3=%UlQ!T9R
zT+^gIAk57nJL?;Dfi1j^D2MQd#tDD{HFM-x(1<U98n$jFm*qN)X>z>v;kWIe&$kKs
z)+HATu?~(z7uOlsCr0*%wP=s&q2&*$tk+aWMM9H@(1_6ryu}~|o59^p7zd<1=H})m
z`NgHzBNUw01Ogkuwyejj`l)n-*G*ZP_7L0OSPg4(kq#WIMQ3-g%;x;_dR^t6c=jMe
z^ZDTydKNMaa2n@tAaHpuHy(di&wJp10z=KaIRW52`nh^o=@>~CYFB$QJ@8+P(e4xV
zMW#V7*q=vc3@``zdJZF06TMF5M5TE@?E!%BuYM`1_6%3xA$ao7@>eY#&B$_vi9<$4
zpw6U?JJh9lo=zke-s<;%irx9B`jPnWu<76eO!g{cpKqLQ-~I2-o@Kedj6NOdosrYl
z+?S}(FxcZGpD?0PShxE=K&WzZDl?!>AGyYnb0ALRHO3iPEBT4G6uF56)b9^vwcWDx
zoPJSHXt%k-K8!VbeZCU8;go)Mb)6>iK>{1DZ!sWOvn<<K+Q6kaGk-%K=+Ew=S`Zre
zH`D^?9T*p6P%jT2cvo4y+zdPX%lCJQTP6^<77Uk-6=;LiWtI;j+AEq*Yrf&i&%ICo
zI7kyyP6?uL^oqM6DSW2no{4@!SdjUF<jq9Vf+pT4M%{;<hef6}okYvoJ;lykb6{~&
z<o0;Ul2}kXa&ki;!UrA;hL1s3OME|<$u1_mM9zK`b5TK2%V6FOAx{29Hj~QnNsSk)
z@qBZ2g#N%@A1!e!>?2_P5=e%tF|^y5aRtW47HT+mOxIxP=yBpjHv{m&Q?2QNyTQ;W
z(Ug0D!s?|z0G7-0yK^*HE_VJQ#d1+ARVw+Okq`YG0~9|W7lF5M`{{Z^IiX*4lWulb
z#N)$#Q{0?B7{=vi@vXThHR#b2Z&Ur4eCeq=aRwe*sfoMt$d#Z1h+urEhu}Z|mJ)fx
zV^bhk05kZDPXHJ3`}CgaIM%~h5C!N_)$H@R!LVhL?eK!?<;qj-S}jSn8T!*dn5F;9
z(Sh>W4CGs6uGnP#$Vd!aEJ$8kzuVi2cl605VDO))<kdU7sgqhB3JHLCyI%Sc{nbf6
zjzMu~oki>3MR%g)1(yKGvr#0^_MR0--2_lI(N6b#WQ=o~doK1Mxa$6=h7--+=vZ|O
zEG(4rE;k8M&^R99Vftt9yXaqyO^OpaQMJ!{3Bn}a7*fOH8?H;IYCXN%QqJnuV(8>p
z?p85be1UNjS!!KcEs->@K3RX!!0gws2nt~8VIhGW?atgu8aRf#JrBz231pWcm9on4
zJO6q-7H6tUkmI|auiX-PIeyU}tJqjhl+;h+P!RD4#Dmp3kn?7>e2afI(sE>A`+r;}
zf4<`MI2iKZ$VecsIS}rm<6p)R_##?;<+6lmeO!SSp7n(t?S@F>E2m#&ADxmg^OMD>
zn2?BY(h)h{%<H4^BGEKyXY)R%$Xa&D;^UzQ-Z`k8*02kUgPm;-C}-`L^hPyi3=fQd
z$QQz$Hjz}$sZN^H0{|}`d1;odHhX>^;0-VruFX33$NRfxZ8!nL#d9-Uw48!C_)adT
zk-#GLzFVYEZ|?R99tpX@5dLyy2IW&DGp_l6C9aUgKK)yebF?6G*y|T-D$x07NbmzE
z{V|$&ur?THT6^H=Dh|NMI(uat4P?OCe0a@wl_>IM(FCL~&()%Tcw8f=ha-uBA_RKq
zqJESqeo>Y-prPXgD_-Gee*N=wMOt1we_o8hl)aj{gZkkY6+^?E$Z}yI@ynpk(@Q^%
zL?ff(?6q6)quOTs*DE6szbd9s(+blrkL|Di(ZBR++t6M(;=I`ciIl>FiT*VVEUEg-
zCYm)foC=Omza=njW2lW>6muNB8xrKA{yfQ#8W|QA79}zGt4#1XXnudwW`!B?k$Bi&
zfx?aL+ofl>x`*~c&WNvX3muIFR0z=?UrlTTU_j^lq{2QV0PVP>HdwV9O^QS{hf9Ux
z(|RMTKUMD6VlJM{Wk$wRESHk%!F^8+EEModtV0yOqTaC<zl4X8=-X0x_SyYwnq^So
zHXUJtlAQ&>T({422<|Oc9~<;WCZ&O=m@t%2dR&r<#RVCcwFx$53pRXnR|WLAjkb_J
ze+IYOcG7(*TwsxNm(P>YtuwL29&Z^O;BeAqOP^J1buK1LYCARJiT7FRUER}X&?@M^
z1Mz1X3^m<iAm;Id?K**og<>(9DbJK2T@SKiRDrnwd8mU^+-^hsYFwO02ABF!03O|}
z?xBY}q{|~Vfs~B-+ytGeHXAGdclhmxjGVzT0EW~u29GLq$w+CZN);n;!W4~8Q)Ch@
zQy>+-PXluuW4O{0NGN^`!_||gI23*;6z~rK`M=xqC_MDf7vtbBbh2gqBvHR#jmV%j
zAA}^&qrceWmD-EU!*i8_07=hKnTYUV@5z3G9Hh}|g9&qyD3WRjopjN{@e5~!jEf9J
zEpyVHjPx)JOGv<M5ZF19av#-o7nkfOUI)HPs`VTxIk#K68*1wXvgeea2IGrEW~H~B
zDun#A0KLS74~!dLowv$Tlil0Y`mt?@_?_jW1d--*aUwNfFy=Rvn3g{{Y%^Q21&m27
z^7_4nc0fqYC_l!{-hGi)K06Z!zBZhJ=!5HKH}Nm)yDH0WHxs(8XeJ#XIL8M=C6uNV
zg@gMB85N=1udkuX?u1Fu-iw@E8U_QjKWz**SeAuN=6cB4GVASjA<~L+5N%#CN)!l~
z2mrsi6tEWfPZMoiIds$Y&tzyY-_F6;O6$G9jE*mda_K5+9{`3?@cL~Dx!z!8d$K32
zENh&2POlNYTy*ru%g-eE+U-Vc*Ef!jb`M<G(h>r*yq=p}(A9yklw1fZr2k_?qIgC0
z1q2AL&`+($Mwvhw`p+^#U@<rm@>RoE@sQZB7<2*tgMueq&NedMz4;$-*0<f?fWf@t
z)BNY3C$cRmp50Q(l%61KzA_~MDU`@s&Ydr+h1NAA-uZ(En3&X*anv2^8Q;Tp^|FrQ
z9)!z&#`&UUq0Bq5dm-r;Jxf)=I}?q?#ol!=5GB~U7S|K~RZS91LhWShI5(IMoe}oN
znor$AxpB)XTrQ8FpL`*G<9h9wlpV7<+9!u>00BlN@LUSZXG}}q<f1OLwpf|W5S?F;
zCWI1X(7)~93Fmr7nyG!!d9StLtfs&NSX5}PMN=y6r?tEko&YD4WQnpUfED0nd7<!L
z7SoEZzp`r)KM*^D*!|459&pAcviu*dtqve6QoKo;W;iG3l}8!buGu=vV+sZDER99x
z`*K!4)-pWS^g%aUbz_(g+fP|2VA8;6rnDCia1Y8H<K|X5^m{<CF(trR{Oh&6lj78M
z*8)d5R(WJ(xl>s?=a0_!5~G&g__1<#tzC*rG$gSfWR{1#85(en0>?2w^#__?Q3&3v
zCQPh;TDD0<$Bu=qD@^XyW`|`z`CG%#LV*UIxe*jA88>2hMXG<F18MGE+y>~jTifYK
zKsO1jd<jHYiB$N;A1PP0vq|;*W+8^$q3^hS!pK@>CTSKO@qBYAK-jGC!c!D2t$Uhy
z=d^}$>qiK=Ttl=}aPF6>zgPb75cQi%Uq8Rcm=3^+RytdEHZ|6}qV4qPf{fLkUg*?x
z^ZiB}3(?qS>E4mg>AIc5EWx7p9@|Sy*mKd*x(@LoMBl5k$4<qiSz+QY6`X(%lcK1q
z@rS?PF<L`sFNcOhz&FKG=j=d?kY_TRVB_MuJpgxz`WnmWS;QVZX0wo<`^V+x-T$uh
zk$&y#P5(+)Crk&uO7GgZ>wc2q<KrU}FJlOYZt5ENVxOKf5qB<4Iukd&hQhIPBa-<k
ziU<k$ciwC<w;;Nk)Lq;LWmwsAXg>h$deg5*OWTp{l~ohcDt+6OcH2+5X-uR)QsIEm
zxvH|lYUj0wX={2R;i1l?xa-;7`g+Iy{e-E{mad#|TyDoEAHF7pXQJDTWh6qB`YroO
z&S?A5co>Lk%P^i1aA_wz`Y~wD5(oe{cY`h+!^uP71Jwky`Uh_&%5frgb`E?oCeP>P
zQzYk#RD{moaye@M6gKh2yb6QGq4Y}#DT10gfr@D44+V#VKHXa-1GpLtz+x%fvH%{Z
z*VtsNDjH#l3&aZ~BlY3_*>tVlpK;-`-HJ*NZEYde+X|#{Eyx)~el-)prU|jkv(I;a
zv7(aOeq*=3su!6p`e18hA6ms*S??hKJ&0%zx^EaYaBZb#e0G}Qv5tUoY0;&)d}(pJ
zUz;24Yjf)gmY4Kr$MdmQOOp1u??N;gJWQmra~RhQ@y{KKIC@>n@~vQGMo;T_9zQ}@
zX4^m^l4w{)VX!qYTU2Gi``;g6apyh1TEcTr_QixXmh7>DsPH*=5P;b`BAOMdZ92<7
zsgUD@MBQFhHHtgxo2275-Amu<!(wA<&QOE8T)*D5Tk21%i6{(=U~txZH69=n!JHtA
zs`tNI@t&oFeYNg*4Fdh~`o)iQyz#=7xJQHSzjsiyPU}~Lf9}@gy@3)~Cm43|6Ue3m
zwxx)Cz(51C-~yU@4B(zTOV8KpBM*hjKR|sqa(P85z3<hVc?~$TtI@tEpis<^2zkHa
z^T+K{49YzRe_EtSB9;c=e~+c1^Z3UqNR>CM?UA@IO{b<RQ2Eu<#rj;klKaVDX=QB`
zR{o-oCgWiE)G@Rj_jc=h?)QqCMT6VtVt7LuhjNU>;p8gMK0TQ?Kspis4XYo<2XupJ
zkNMvD{^%i1<w}5X*>Mvs{AI?$!2z3|awTjWeCD3U#HP2D`6FsstJMfN+2F~iV=VkT
zjYn<R58ERj>A>ZjEInEBt&KC!?GZZLaRESmh?BWhXe9xCFal>G!(})T)x<5>;@}`K
zY@HRFXs=DtZaL3fYHx1<PDP*@5@I3!9YXQ;xpKT=N=(SVv>ge9-A4>jLLAlK7pAm;
zRGa_K?N5U~_1a{k*`Ue(K45>)0mQhE8F^xAPt9S!FN}Dat`#UD4#x9sG^mF>zN=rE
z*2GO;<ota{De-b_I>+*+)=P6QRtf21@Ba6ZUdh{g87o4mimv+Ie^C8iJ6s`JYrCO$
z+AH49*P!izw?4yktLs(IHN4#iU*9Ix8K=z`%L~0s_!V~big;3AKD0y!!e31@swbow
z8$znEYN;n#0{z=Mi8*&tM+ma_$U^_eMe;Ro@8;FV*Yed^v8RIwR-p6CpVlF{(*zew
zaWzDtKwoEbMs_poVU^IQH{tpaF-@8U@5|h{G>!VFIx*ArKDfviVITvN!N`6zZ0*Tw
zZIp2uo!~qr{~;Bcc!hd#G$KFPZ2s5RP@EXT@S?NT>Jhdvg+B-(#J~|n=WQvgD}cWQ
zg=CODYcE?vzyGGm$d>Z)!DuiULsO+rS@^lV^@Qm8{yb}PIB!{B5YB)hBfbI7rM0($
z0kvZ%!2v^<Y0J9To15F&O92r11m;f3oN<t0{Y;%pW2~G!<xl`R0BP`UT_YgWv)TA?
z=K`xEcw!L@pCAsyKIHNt7+_4^Ixq=?cN>ezUpY0vu59CYCJZ=+GcyGh&cBU9{^b7L
zGoao%%DrBFJ`;^W;00(vh=7lJps_hb=&d^bUBC_iaGfrA*2S{;aMWZlaCp%2+EWKz
zv5VH|4pFK^H0Ghd&6ZX6V)=w^@WJi(tj6tvA}{8Xige3Fi&WI~jJ3wK6OQI@z5`h(
z6oa>+-?Xh<F_eiRKC_z{;*RV2Vo%x@V*#~jX>o>ujTm>{1ZNDqHr>G}HMJjc9m_%9
zx(=ITNkGgLvPSItF%ZTJP0aIRg{&M~>f=`}ju4tYSJQ?#eqZylrOajIgSTI%{VSy3
zGi@X^@Z9<IejBXj91S*npb7EQq(cpFL?VmOa6R-7H>V?0co!&9rbP0d+%L>f=4EjB
z-E^iH%@Hn*u<S1KgUAYuF4cfw`z7F+sto-#-p(<UAuoMo&1tJo#QL7yE^J!+B#Bes
z@lna_v(@*PF&+YE>xe{p8bw2|pqed7TjtOLo~nnP(~IyQMS@=BhIEg(fE96@H3kqq
zC$;Z?1yC{-rp{bASw_oUA^&$nfB_5=sylgU71sZ5dH`@7%^$JVpgKC*21eTzGU#4c
z{@{<;Nubd7SyZjMcd`^&F)DoijNgYk;6-k-gylsPG-mp3(=i4p-o5_5>7sMhVnQY;
z$wUbZ8j%3#E@6G9zoTU_Va8{qMYX6tcQES7+@GnfK+fK8#rq3(&wT5>Zsmsw$ZRE2
zvi`HOfuo&pVTQ%{Prz@7#0y;V`Hff`w4j?$*)bXo2hx<;I+;-YTSA)OgMZ`9m_Z($
z$mI+99kd9Cc+yzQ=L2UXS<g7cNui*kwP-!Rjh?2CfcQ5AF%Y*|@gkAw2Hy|l0(wX<
zy=oTae}?D%|8jgnsPl_Dr3RL25}-u<D;cwsDwNVa4n7Q*2^#dI8RK=L)xFKTv(IsC
zWF)`W?DPmFL>slKoW+2&&-RTrN9TERcix1HfjXbb;aU#8n(zNfPg-pk0r<q{146Oo
zokC=o8?H)RCQzO<{*E8;`62wNHCMCK<%<kK*hQezzCmhHbN!lcTniGj$UY3(K3L^r
zt5OOS;u7mp5C?AoahZU#$OsZYUM>VYXW2X248uARufWh&$RyH5kRXt<LjJ-3L)viq
zBEi~Wg(DSJDz?Q}lGSX8sA!5z#W~S#OH26iFj%6ELTk>w3NX+BF3Q828Wda4_3V-#
zA)#M{<{GN&bmea#qEh+MfQ*p0`M>2fG^7GRV2W=>YhbxwIjNfu4P9|8jet)=5nnPG
zj3iuT1uwaAhci0Q>|LV)4)_c7?I<;`Jb)?{2;I;XW4q6MH2eZ>X7pxHwcclm{G>Ro
zvzV9t<^iS<n*C@Y-wo+&p>bFAUkXN1a1}tDA7f-><ti9U()fCS?ChNkP>(AjCb$Fz
zoRz-U0+AU+YpRnM(Y9=UGIkU}PGoXy3w<>&kUnK@0Us<ocL4r#wgg>e@^mrPFxIe%
zp1GLFCaDU%4L2HjrrUr1kZ+48+A=rVr_|W9C{Tio3fM-?WZf`3s|p>tv#%@Y@ZUkO
zK2v@{YVX{v*D5jG-?{0Xjp`u_lFXa9vg;b^<l~TYsF6!jas%6P^hJ+@@z{i68ot@?
zjD++Y7=B1@M|IV=Mt8EeH4wdWVjfV9l;evS;eEc2H_&5K*oMyBX{$1thX=d)`01y0
zRS)iJb^`EL)P#qs&^48a;P{Ra@<UjHL03t+YWq4Gpm2A^eQ!LXo4rP2<T$vTML8pp
z4nU7TO%&hrKC%ey_eOF)a|MR1d<T3=`efLU`hb72?o;uRVz{sc%<I7v(9PkUQ+?-k
z%?E#Ap+8NxLDCtsb>=3nXm`BuUPcadZtq|^csyKz2o*gcl1A4(*fzYYSbK?F{eO9V
zywlc(`#Xe$Z2?ojbp4^a4`9XfQva#=Z21UE<MmKewlFjMLGPA`zb1Txp^Mig2G4qk
zH?o@Ma}vVR;Ux|R?<c(1Rz9MahCyPm>QSpq{lDTFJBX~|Ukx)c^slNK^9B(qDH0tV
zA12Du98IJv=B=b8<Hc4l>`i72AeVU1U=>IO07U2b;dQzP$ct^%yjCE8DDq&To|pM%
zv|DhAW8{XcYi<LG10HtI*Sp9&7%a^P!uM4u`y=1t=z(2L77U{CE%FA#gUKZ14==|_
zz3qXBa7;0Hgqt)3&iN(t80n>$mBq-DjO29NZ8z4%xQk4<x9`yT-n`y)Ai=<coY%5&
z*6HWr5b1QGzQ}79$wk5K{ze7uO0N8U;y00dktlSt`3{3Z<?$StCMjck|G{w>L?Rbu
zBA-P6z~{rfqjfo{Fn|8!Xyo|iW{<m|blO5?NW*D*T(%+8^TAxyDnvUg^YUSxHMQ`7
z^Y7VdK`!Pzc+vd_pN~ZrU)Sa1sbTS4b%aTrCi#(j3W0`~km=77)8lpXtPU=c)Igq_
zLQSI&@r(pV0$Cl6d_MJVwR8N9&*#I11-l_Pt-YF5_aTq7lJik4xDyXqETtKD1`Y=|
zwPrgY@Oa-Y^;!GEj<=AgfyZEbuH7~ca34z;2ldI4BcFX{x*7otVC<RGauivX_ZYI6
zh+S{LFU+|#i#-FmwR-8kL%ejc#m`(v1nssNG^BB#e5|Akj%jzC59}j2TB-RK<L><M
z_Dqp9ei26#Wj(smwBH8%`@oQ`X81N!(H{La=@<j?N6}G(i10fR)^NwKKjYUbd7>?>
z`G^ZLV?3>2NGIOD8(Ig;Wv#fmbbmHksECI&m}@I4DncZO9Zmk`L^np(`anIgJTkPU
zg12V6U(yn+jOgPA^o<PWDY<HDcIEgTv)>*-dusg@;BYXp3e-wR0U>)mdo~tos~jle
z9-VEpC7f++8_a7><A*ZKMJ=>;6Dr5ETN0P>s3fnUiS}JKwU%<7-oBYyp5Q@h)1+&-
zY@Bx=(u9I(I`6|jY1dH{?>gMf?-eDd?w4I*s9iBv(ivCgGMy=p-fB%_{lz4AdK&MM
z=P(mixix)>bUvQbKq;-PtHb}V-`0QMSYh`+-4HCh?kv8C${^v(>cA2S;UQa9)sbsY
z%onLUEd9pGBVo{Ua$#_HVrQ{jfupQ)+(uuk=QENDqk+q8lSEOtd30g~184}zz288=
zll<#uRnD8wM-Ycq3o|$jKJm|=4+zNcSj1oE#NZG=mAqV>$sg_R5<MnN4Ma-hBSxRE
zdQ`GEHXK<-(1KL2$9aEUA2N*>Xk>1251H);T-037SwThuu@j_QwgtWU_<6?D*eKRR
zX(yleN`>2D{W&}b+qYOmS^EaoRT9PB4-tk6xLR3{XZR{w3PY5N)MVV1mESf)5#@Bf
z(Y}6Q?Xz1xUzS#=R9vF#+oz5oj$kKaKFOpWD;shD8&K=xJH#=aphfI3V0&~VsRvoJ
zldLg!G8AmUNYCS+D{H4v|7>1;cnfJ@E{y6#I*GQOVWvvj7r)K@E<Jqx%Z%89(jxFD
z%gP)M+#Dh6TseL@oEFU-*QA8|lSld2)FXY)h@mvN_x%o$4bi==_(==Ad!Lm@DGk%v
zmQNFg@*(X73e_?J=3~XOIi(oD%OpNNZdZ!HKwoq_hWoxl#Jr{&jLXoTPiH(Z)eVb$
zQX|$_<dqagYaM$S>774G*|;CvsZW+2U2z8s5hckpFFajgJ?xZHpQ+2Xy>QpZ?UH!s
zZWRO;8mR7&i)_6SJvp#2DXH<!$b0GPt*LQWH)+h8wNrQfDjSzQS6W!Vp!~6l$MWe}
zF8Nj+62gwI*E+AOuA=OGU64DOKQUlVU3uX7+)@`NrKL7dq_w&$#F2KIfT*eT$)j^(
z!B$9_d;Ht;pv|E7%dm%*_6JJI`Zz}5BMD&Vfk6Q+Udns0$Hv?_lr1ecfe2{wOIS94
z?vnH@)@^NVK$O$)^oJVvmBkaHOBDEp=9Px1QdK;b_q>#udV97}s8t@Pzc%Jtx_=*h
z2jN2T7>TwxKP#D+Axf`SZ{2M=A5Bsr_=d*j#iP9Je&*5G*!TbO_1$qzWn0^dAQDGV
ziYOfc=^!Fix^xgi2}lP45$U~GQ55M&F9GRAklu@;w15E=5UJ98=q)6CJ2T^4o%g%<
zFA{!9&faUU@~pL<b<QP0>7X?{g5z*M^j@qF;Z)2#(Mp2a`e^ltrzi$PGQln6hI%~8
z<>5-r+@KlA|0=2|?bcF^zq3)Opk|gP0R=I1YHbW7*~6RnIfi#AAo40Lho{}#rY)=8
zYFqo)Et75!lT!xC6Tz`R42AESVHydtbJS?Z0(3PsHFNi180U0FR6#4j#3NcZMJ2Tu
z<Ma&y_2fhd!57xPSiLWHr?+yEe)mI%N$E615Z96@H7@y0IJD?9n5dyU%&KWu{kYe!
zzD@0E3q>mpJ-M==h2FDrMrB|spwEb~N9GZ|ShFxo54{$P+$MBK=RyM~wOOvr{4=49
zSOiZQQ!e6l&%-#Q%(lTrW533iSSq4Fda>yHwELrEX!yy=EJSa2f_H`8Qtvdq9DB0y
zy<FirF^zq_Y{E!XehX9L5Yn?DxiqZ58DpfkUp@t8%nA4Xw#@FbQ^Kucu~pjI>qhmr
z(f?)n5qK+!*SRh*OxNJyL&n`7FI~e^BQhMVYTm6|_TRf}Jw|9IBKkm=JE`??tnK)5
zZFcSG^MCwCVBpBb%WRv+j6D699_g@M5b*D~%}HKRNy^4{+3p9OAxBAxcA+-Rl_exF
zP>Sj33S|IvH-PA6=iCkTDz00?LEw>93*NyM8o9aht4})c_ixAKvK(1d<fMu4ZWTEP
z`fFmAv#p%P6`a;GS&deR788w340v*Kx(B$ODqN1}2FNz_(kT1S#-==J%1)70e5OA?
zmqvy9h{?D3a`JXmhuCppEheH!F{Fqz>*?jQjM$El_K)ZC=e|XHioDx@m!>X?>b3rs
z|AIgU?@L4xp04aoYQ{6PJp<~mrvQAcp(oNA{dB@@_Jq{uX_w0zB(=s(81c>XJsF2m
z1Me@Oi-<lOOY2HM&Ivv{umV_GQ$A6IJsXD%vuO=Cp7JB+e{^?jxpC%Si(7Pyo`#E?
zb=0ScOp+bE)F#8aWxi2PzNne&S`>nB_?pZLW3f13Y93B<^O0oXNHTf|2H6!h(PNq|
z6z_~Xu~_|aSzuE7%{>AFJ$+fh=uZ880ri*>4uXVpoI0fpBSkNNXuz15*_TVWj80OE
zRHua>TZ-Il9EpxLwH~f0U+P{NDpKfP{$e$^`JSm_E|kJ~##6>Ulmfl4?^Z+&BjqVJ
zQ2@2sxupSf@T^+FBb)gmygkc_=X!b^3`;%u4KhKsJPpnt<8=l2WT>uaTpx<^9Xen@
z@6$vZ-93%F&u5TMOe%bvBcDSPpMaoepuMxV){P}F#@tw7BtP<0bHP_+%JAU%bK;wK
ztS6yVf)P6K0n>QFCN{!-+F0?%1Et=EK7!laf4~V-4iajHQm*BT#>X<NV@?={h#=<@
zT>gqse<|xQ9>Iy+bAu`B^m}bPIIM-e=1h1Y<XJ+@LPS|y*9-j)-!NxOj>0J+G&M=F
zl1PABB;6SAs!-|czA<ck)tyd~7cy7=foo@iVnGDWWDa-6q6SFWF8px;Mgh4kGnN27
z8x(xf=$u0c0m|JbosIa*V&=4__uNSo`zm5O238|&69<YP&F`qv=s<(=?yn-kd8aBw
z`s!WSo!wS_hUk5hT+PmDwNV%m&2FHNldQb9mTN86Td9Hl$#FvYa!P#rmz8#In15}(
zYctd;2`uoJaJ-IpV!OJ|)Qj<|ITM73q?7cH`j5@wUQIWF|1Z8(p2<iK3cf|bwkdES
zTw&|@P%|r&*`GmqTbzuItvegp{AY}RedjFgO;79!w!;qI=xCf_ASe$@%p{HAlpy47
z5tH4h%dYIpm89CsRZZVc?-SI4@Z9p~b|oUZ#HZ$}AzpvF&vT$Mm>kZ*;I=XpyZNGr
zp!LPjb-~i98&+zpdUouieRO-Jaiwl!R2LdaNqW!$0U8z3bv{2qF#s;g;b($^N%_By
z7bxH)+GUpg<=5?kjUQbG5SXNj)K$^Kv+m<YSj-t%R+}!2?VUF3W%{A8$c^_7A}al%
zSvgZ2LBX+DqG{}vzacjT-o;jWZUGy)<U|RVg|sTWxGVd&ga*4bGWP_y=T1SF27Bc4
z)>pzhfo445+oRL|cbBj8t+3Regn2LQ2Vf1E%ES*M>#?7jh&0Qc30#_QQB_*?##xhD
zUF|3oCj1GI{!+j9cqfH@PYI(+6VIH*BVaL&u9y2|m$)PV;GMJdA!+!)3x*Uy2>d%r
z|5T>5IZxy&KG4^RXy<!>Z+-eK-l}<vPWPj1#gu`uS_RdZWE1ZFz>G$9%Emn~R}a5#
z>%P>R%q(&R&OpSfraaF<ksDSdHjRRBwP#GSb93L{Sd;jc=Pjjy4{14i5~O;)Q|quV
zC@bh!O<~an0E~#%(|+t8?($ty1NVPlaS$GG;B2?Dbm48l0xn$8*zr7pJ;S?#Nxe@`
zZ^A+Dx!2|5q6fZf!Dx2wr!=5Bc+%2mZ?CR;un4n32M52*A8yHBcSIrNyze`R)%#^K
z<oh&5drQkl(C{Ms^{p$%b{#sE;y0BA#~=+dnVFfvG{5QdBqIQ_cROMlH+6tqCq*j&
zxcyB*0-J%l`&=1*OW>NxASft*axR#c0CJn2Sos;A4f}UvUhw_Z&?IWvpHR6;b2_Xe
z5wSUvajWRc;h_aq$||68tak0SZU!xTzFJ02fQpPvaIR|opk587#l43g*p-yj*t^(;
zul~n7fLEJ%U_HjSUW^A*;^N%Q`}yI&Q@x)TvIU~~=J@U*>*ecL?C~LZ=VU&0jvzfp
zIt#Qii^yda4yJ3<+)Yco%fJRuv<4f0{QP}3B0Px}iNPGNdxfz41_-5gtY&WeT<Zkd
za_9M5(ngmkL)FF3#@J1fX}Z5v{m)CbP2eBu^-jo#U>Qug!LIe63jRw}Lb#PK3~(Pd
zFGC3KnuEbY2>D@=lyt`|*U)JZp#g}^b-Y%a3}9z;cOJM>{9Mpq_VjaKxNSxOqny6d
zF3YM?g0tVdyW_&YT?;w`HvhVg5&7kk0Um+;Gdy~ec&7dsJUjv~84D{E?%TApT}Hn+
zw*R=ezYIzOhdHdcmWc55fH$`gFuVBM1p)&-aQ@=66L(2t&mZI=FQdvJ<c38WnMn0#
z!5=gi#OQE}!}R>6+Kqqx@_*h=OM`2OJ$|?Jgb1YBP&~qP1NmP!iLYFM+nng8+N8UD
zrfD<&`6a0!lSi3SFb=SO<{OP(p}3>Frm%tc-z9Z$1$<V*Tw48d7l%|PLot!Tztp5j
z3nW+`kv3)%Fm2hKweX>!VCdGC1_k76KnF00cP~Vu@-Kj`zK(eV|4s9MHRcPRVPGlh
z*V&KtZUb?>?sZx${Z%(WJY&Pfv&e>>1Dfk}JmrlKZ{raZ$pjgPL*IXTrOoD;5hLC#
z4OSu)e&gUjBKr5Mz`I13*&Oo+GI=k21IqM{(v0@^t+yHAV()6#)z5x%a<T;w0_t9=
zpr}KOv?K_@vva+AVhZ3Ii{TXFa=%IXSDCc&<NQ&F@BktfNGvlaQtTk&x4pg=0}6Vh
zrKRP`2j6%2`1p#>$`v_zd9RyDWCT5ED6SOZ5v<1Ff8o3>w0~QM03T9u#k_I^f`3Th
zwchMx{@-QDFbx4eTnb%Gxgg95v`3G9|K9Jb+;k0!C1u+@Ac^LPFIJL`r&?)UAvLaV
z2zeGCKiy_Zq<wl+K(w8}f_a#d!^~Rj_+C#**h@8%W`b2=<~CME>^d(cZ$jGCx}1E7
zimh$9MpoO%i24<4R<~1$mKieIiR?MW2NJYR2@k+JSlpNDoqqSozlu6cF;KFa;tE&3
zTqYFAiyXql`dc*sc&IaH9f-;C37#psHZKfj`l}Qg@$38g?S>o%b1PY?BWluZELS51
zDo}02Wh9icf1ehFK;A7_B?KP=+1HzSOhN{<*X*3U$8XB?>pCtw`hdmSOUk;wlf}i0
zfp%oyFXaQEKrG5_)aMA?Y=jaL`o62IQ(gLqM7DNy@Ut)H*iN>{V~x<S(!|`Fx=Lqz
z$P9GZHV0rtUju;4fE5B&;Z%5TL)i$-@FDAB@P9u#&w8N#y!58_$ab9m9iAEV`<LkQ
z37XiU&@wf$`kMPfFT)DrS26iHX>lLpww!rHlw9wM%$FD{s>HViUM3>eIVE_e{8-VN
z-K4bQ@OVXOca(Q|*}B4P2fn@7`YOWZQEUEUvpE^t=H3@RJdHxUS$S~HNzcJqJYcA7
zXXrxzyUz&>JO{)@4E+`oI0ioK2%e0>^sjBnaZO(e3Z{asD&-T`s#tjT*;Yr=N-~!>
z3iZU)`8m%mN#K-<$G8{c;d&N(Rx{UG;AMfPR+0R0thZar^`LVKl*+A1H~CUeV=Y_z
z1cD)v`&(6Z8dt7V@Vh^S=!b+wU196@0Q&u<BL;gl7|2#eYL5J0i}>}eDN8h(p7X7H
z-pez1pSXZYCcUqx`Ik3F;ERbsr&085v}LQ@+^I%obSZGY?g^^fjC^W>4hAf#wPgvO
z6l`qapO8rPm9MsJx`vaQD<;FL_p3;HoWJK(=35LPO?o1YRx6tpt*Kp~1sj#~kvg(N
zGtmy(?EPf}1LB9=`S}rSn7&%DV&5-L48O17HxD69KCNy?toQ9jU@A_?aY32XzitR9
zr5w+6VNmc&5r=eC>UqT@=lIHN%TMq*Pmhgj)(uy+DT29J9i8tfIwn<FkLu|QwoaP8
zGyPH%VA)-vM`!ewAzS9Xw_AW2N7awSE93n?F2N>(q=Mq;$=!E|!SPP=MUE5v_vLLc
z0pa^~1ZOZr!vF@;A*=aU9Q4c&WIYcleKM(Gzt%6L0t*iLXkIZBg|YzVDo4fq?vy#?
z`Rm)k1aA#oNli>7Q)|^TM0qL~{JFMRiN|aYUdMO6xbQM!!c?2B|KL%fS|(aOvrS7r
z#{X(qpj+njfR9>F-}+}|?}jMlKaRRy#<f&fD@6O2XTDAooi$(^nPvW$tbTnvy$)h#
zlV3=^B=Rb74WqLPsDHVJG|J5!;PSn1`{(c1Diw3ywXA=?UcPGaV`e$l8Ecqu5N30)
zx<J&~=72EQwa{5GQB_TX)#Yk<oFAe4H`{{{3ZpC>jw67`d|cFgATz`YwZ=2SBgnWF
zxLdx7UviFszLk_$S4icv^S0}r&nbaQ`&^&Xd}UMT`F~mbZ*SXlfHQeZXmg=15qOFN
zDiZIfziA8u)D<t|FV~)7bY9uDnbYppAa7pxcKlTLRB_@rTaO{-2am0nN8O^omJYP#
zU9`5QoI}I&5P5c|-)%h(C{&&Ww*~gA3{i#)2SLaS^a=jb*s+Mrs6#Xw@$6!u{RqE0
zDw;nC4<Rmb^2AcFny;&(hx5Oy2}tFnfR7iEG9$yY$El3n^WeyTX$pCHAS*t^)iQX@
z-b-<1#O_gc%xhQ81%FAUecEyB%84OP5GDsVRt$3Nic^Q0&?;n`uzVilrh;R1q3u}x
z@Q{(~@o~(RA4M|n&%?ldJ0K@=pDy&86Okv8AK82@^m=yZN&okg=$yQaM7dVqn8mp2
z$KR#X^W(MIbme4VZ{&Cvk*q3)C(_wm9mn?r6lG@0#o&qOYze?I!8mf1;+3sQv#`Zl
z;;@Y+Z~2}CH6fC39$hB(v{YuLU;Zzu{N=<d0J`gX^5H7}I1VtN!wJOy72VkM&#GS_
zcWuF{)fXM@30@YJz2)(PSxMAq@R5%iXN!ctra)2T*Ag9*ldt#2_tI7;d}_M}>M$a-
z38;gWA?q8puJtCtPi6XCmIylo_!jSpczV{>_oY(<Kgj{ToQ+4oI5WFy<vMhM0-D8e
z+CH4=f3ZHxh@Rab?@gbQ>x{+6f>7I<`6^9N#~SxqH3ulbTdh&a+q>bo-;V)J(y>rS
z@36pSO3U_cil6I_Q36t!xg`-#$STe+XJP`j?qU8f;PgAtct^?rHGL*ccD5E5fZgxO
zg#L<<z-Pl0+a}Hd2Qbc-{(b6^%YltxNi++hC1LlKwcwbGexX5e*7(;g9uUEt6DC|U
zO*cs5=43w%aG@w%@6}ht&y^a`Cqm}i`?S)<J>>I{z6xs09m!+k)mN<XA%cq2xex-%
z`8RsGfe->ODgk=y$wU2R$NTD)VS$(*UPJ&?oJYiwH1lGyXZQ1+>NZ}^^U+McxG1y$
zdO;H@lGqp8ms(ACZy8~*tuXi#o;B{o-+}e-n>nBad&HW{lBiSw*B&c&Jbw2#tAJME
zkBdN|`3n>)XV;=$MR`-TSdLbD6!)gx)!#jNY?YW7Q5v(6j$W+uQSK2*&Z3(!CLe-u
zz+Su#IyixQ_XI?b64Dwc-I={#@A#vszK@o=LFWDEZ<heZFfj?peg*yx-GENdy;vqk
zO#AaHWkSx*Rn4(L`zsMr)?YKL`<9384A~88-X?reda21>5m{y9^XfIb(c~j|d7Mdf
zTz=%3t@$UBpm98cFY+Bq*~iHy{a}29V^NF$bjx{zW9`}RuI4vT&7#nDB<YzzL$*PF
z_U~LlBTamOOuOebQCu7=l6=up{8&F%B|Z-EL@1$eOt<@Jr(4dSH_>F+F!pms?72{P
zilgc}sXQr1Xu)f(9h2C&xUVCfPJ3dSEm7THv;MiZXG>t?c}OtcJ&UeD-Q1EP-zBYl
zGK(HcFj4xUwG!Zr`}L@eA2X}7iK~pAGbBB)c@-4(^*io$xQH{5+`SXtqU`NPYwPl{
z)h4kU$@yr^)}@vLbR}6-Gd1b(A!)QFR6{G>&3>VlqeiEW2HZuZ^%J8~(nrp)xtO3+
z{-`ezqdO7_-^5dGYmSbO3s)t~T_VyO&F5B866K>&6pQ%I7s<l|FiD0(!k@(S8XJpy
zMlJ9NZeF<bi&OYrZSXI@BQw2`L3^S2LR~y?>a|pn50}G<$^M`lSD_LtVRC2|fJM@(
zuqCXD`osWaq%2unPv}Ca7JVu8)Nz0F#%P(}SjJ%agk4AdURvmNlUCNoecP&fo$T{=
zbNd-lDPuHycbSD%pG)#h`pzuny$wL59o4u{<Kf|1e(R5tQ@0&KWHI?z%v9<2?hLZ|
z2I&jD$=%uWP@WHi+0nfz>^$5VMP0=bh%o)5%z+5}aRF#QrUN@zwIz_J;_aPsY`iND
zTu)SeUvkIW3Hs>sdj`Ul#pOt$i#NOWzqzTQ;EA*j8=m=9kKLQS6g!Zb^j+Aecl+!%
zhJS6xnV1X&;nCjS|EC-G@=7HM`PyWoTml!IyHlMe#)_Ug+mT;cSD2cuuEtH*I^e$g
zPS5eHhu?c+78=}`xT?a%wx$~wNG6t-mv1}oW*2=_XxOu_O2=jD_@s^h3Om2Pm7>Ex
z)H0xZ_l+XxAuwd<+8j@-X(%zbMSo^^>!;36R;nyK%nA<z*5?qtAv9s-ZZ$~)?>Ua(
z>~qt-W9<DXZ0RL7;nM(ffYq@PaHc7ee8bLEqi>36dozSO3`Zht##|Gr?~a>Q+I^@>
zoZpN&wXG@F6vnHzF=jls;X9e;@X&AA=+rJ2Y1M4r{PI5~kHFB2b>^9wYHy!AkGzc<
z>*CRqP|<m7U|-2yOJNjmdKgE47na`UT<XThX*s}a@<8X}-Vng1$5UG+vT|Pqk*U$w
zSmFLy$-jI?I#n_SL`F_>bFu`QDXNs&)*TZTR={#FvDdWrt=c#~Cy9wwomMESS3NV+
zqn6S6(>!;dOK-BITDs5Edi$w5EkC{?n2C0R<w9+?TqxCp?VF$&;9$J=duIEqT+iUu
zgIv4o{)>Yvj=4a+bype}zPGHfzakOqHz=*oD;x+i?{qCN4Wp6t9~7XiXe{C<+gT@O
zAB2eq&BZTD@ZXGkz(XEz674HyU1vGu>6SP386RT*IH0kr@%U=0i+bu&&6*kZX@rtl
z34oKai*)phw^TFf6Y70XkMIbdo$V9($KHfU9c!h6ut#g}(Z(Qb6eTH(dWxY!yB8WN
zBev%`5KQN$T-`m)Ti@Ot?ixo)_I=^=8m(7d-o9NhrShirpoWVRYse6Af_Z8=^wyX=
z2p}aWDB>cQQdzWt7)b6>kYD3sUyQ4yiGfSKpY}0{-Rv3abBRbju2`~Ac1P@u?8nx;
zZAfxBZFDb$2>RNUesNR-u)sy_f4bJs07E$Hgkdf_KEuhcpb?uQAt7<wLeZgqqv4Uf
z)yxd3#m5(g_E$I@A3gMUx(IsJ4@zynPd1fgg9gs-Sh7?QhWP-bCUX;fQ7I#N8lHHU
zvJI4`jH8lSRqu=QPI1w&-ZdXl(f3Z-x-<Cd!vWvT%m28mwu|`V+|d34Y3k+Cd4DZI
z?4jAwT5;{X?~}0lzEOF9JOb+46PAlt)m`>UkG_{h7D4jpsmcO~hY<C1%-8Q85s08n
zTfAC$pf3n5&qF?FgYkLc$^jc(;g$Tk3;4Ra_-;$c^8`WO(|rXJ;7S^Rnmry~qFNrV
zZ>{%2w!GaQ5~5FDy^}`P#SPu;F5Vh!uzvJ72SxUy!Y3fmh1H7pe|T25AUxHNoIy`N
zbNfUC*^y9{$ZQm4^zwN+@>-9S);lfK)sby4q-wD+{?KMLVRy)P0TP`2{6N@eL?_Pl
z$;e{{?+<-^;Ees9{#3hNucuG%&G+0~AHq*1*Q4Ai=BuB;dY4cdX0AqHa@}50_mTA_
zpT4yHeq39xcJ810LK_-?oE>Va9kqIzqFr*?UIuyMURCtE`ja72<=$zy(8*T$%;F+y
z*X&|I3J*wlUA<3FHoi5Enbyy27x%X7o@}L`Y$2l-8XE81Xm4k6*A2%9C8-ur_sSIw
zQoaY0^>FDPb&wKCJ17BE)QboZ-mqqhe`x>C2AB8QKOX5EPw`x-^L<0g#pU&<Ah(%_
z1}n8<y#{sVb))54pQo(e`NvHDe*!fC`CtuQ3FEXeuApfn7S<?qd^YAB;r?r4TK#K@
z63%mV8ifpuKU|$WJ~d?k6Yfi&DEOh;3K%AJ19o0+x^&kzQ?w&WY$j(<C+XQJd2)Wc
zVv~AXIvzoU_NS5zBf{h^LgMw<<;qEck)1Df^9w<Phhf8N^rH4FDzVX?y~~)LM)TaT
zm~E+3UH)S7v@b9Sme(Zy+V&WsRV1PWdbx;${P23{0~rE|zmgaJFp;%5V38Ak8Lz(!
zP$yZX3%cach&6Q@);hR0ZW&t-AL_ffIB)A6nT~5Mh+g_Lh>wr$REhCT=Xh1DH=diz
zFiT!$+qv{xWBE7y1Cq-?#y0r(Lk5QF&o~izxrXICh-y1d`HAP4cZTQ7(Miyh$q>Mm
z9=@@WA^5D?%S)HsWb`T7pNy?5)mj53?z*X1XjoX}l>Ca4x5oyx%e$iD?EjympuAY8
zl{wwgn4x=i<a=J1?vy{X&%QlQLTmubiwRG|_ChcW`NWb`wI(emkF+C6d_7iV)z-ci
zubNt4OV`Vt?#wmm{(h-d)X8FN{UHFq_#r@vut14kVEgi-qIfAF5c6x>WNb^m7+PoW
z$d`rrQ~kX-E(4JfASW@*W+*8s=_7jyc*+fw--%)vnfK3o0o2v2wf_kl=X-Jx>RQBw
zv24kUsi!JQO#&@VIXee|s^t2=Cg1-OoTE~pB*UhLR9iZzdDZPKk(*4p7GwsTZVVP`
zan8O8C0>TU*B0^GR^4)&8H{&MNkXCM88og`=jv-46+U3pR7)4-aq1-L**FzcQSPZX
zMC)f6QV?C}O?nWQkZ^OWljM3QK4EClOYXP1n$Io}K_Ky!i)sj7&K5x=C6%VKaw3mI
zDZQi<Ga_!yWu<mr$_gZXUzt7VO-yEQ`I)?Ao#oE&+81DBlU@1xge{&^C*Ju9>A=g7
zZ0G4s9ud#SwK>MZ4m6a&_0RXf1d&<D)$mj=sk78ad$p}4aBt1WZ&P$%xEB?4teqTL
zyp(i$Kumk24r-}3t&M#R)$2eh6PztMucKC_-X9{3t44)*HUd+`USkgUj$Je=<*Tgy
zMcFkX=_R>N*Qa>$)!^?$60<2VUKcKMnzvBU2PlH()Yp$JlGf1HXCb<!Jh{s8{2M6L
zkmUTKNCB0e!i{zt<=ilh6;BiMlPJ2o45x)e)*=&6=VwMEBFa*PVW^5nq*=#rSa$14
z3PXeF#F`8M9Iv3s$k&}ff_AfJxo-%NUiUIT(Mn;RQ-$B6sFIpUYQD>I`o(Rpu8oIg
zS-H775$83t_5EfG>j{ZFdH}E+YQ6O7)ZwAKpT*A<XimKi(8P|>{R)K5mXjg=(+&Qc
z-ez0^MZ<A-?fq2oCb+aSTXl!b2oV*!ep4r((nz?A?YD}~5tNtn&Cp-=1r;<Vg6kJ4
zAY7ybo_)aAg&_=-QTF$Gi&rX~Q4xMJgF__h`zn?4BZ{@3Ym~OCsxIR2-+p67#w#iN
zAUwaiQq9c=r*Si>M{YM(Jh+`jyLHtv_F?bw=#%d>R&gCM-AOFo`VZ{-zp0LAtJFT(
zR@3QZ{XP6~6I?bQrQx){IqB1=y!hEJT!l`|v-bi;nrOUsnh}(Qu1UIK$`$U_=OyXO
zK`n^ou`}?9q5eKmO6R}m&|+o1)ICitc*-b=6=Uio>PCu*%J&#T&f^LcLXy{*)4w0Y
z1Hh=Oo>p~yu1<7o74-)+0Iep(<D}Ku2x=gu35f33yjWH=@!G8sw|0%z5eGx-O2GaL
z9(f*MzrVOtj=62$b5U@y+<1Tt-Z=Sf>VoXIsi%|b$nrz4Pqs%pQ}nrBv#U9}wS>Lx
zt*6#0CHl2r4S84O{W07ah<4Bg%=O2kYu*DtNEHxD6t|D&N6J_p?Z6`^6Gq_hAC8UL
z5h@ADSV`;=Bf`LY8`GD5tb}Rk>vgJ_vTjWYY*|`F!n(|&Fa`_9AQ^ZK@>+or1$CM{
z8SWTo1ypC{_|(XhA6IHE#%9CDx~icf&b4k|X8?Xq;T5sLN%NzZT)HHiu6L$7oWrxr
ztuq(a$A@QQxctg#$Qtj;FZ7-=cb17DT8?1{)kb3mIj)7hj*)xl20!RC)0VWIAPDE2
zF=Os636lMh5tCJ20aQ-L67}QLg!0nUiNha@%N0BeLZPV2pCpNK6P#k|nz+TeHf`vT
zsRp3xpG-KrG-qDI_*v%f`{mfLcL?Sy!(7VU7_<oG-X_izY2T`wQXw_YZE&*2xQs8o
zY#%!CXMNi^Gw5z1TX*G8mIWg!oV5&n%?+X*AN(h=urjb6grK07IWm$K*4&c8Z=$r4
ze#4E<H`#aEzr3*~tS_8R*Yj6of=0JWyWE6kA`OjU9G;t>wFb-kL<*riHeKc`LY5Ze
zy2(n%CwtGc|3|O}ypcn#)Ws-9kLf;KmD9_0$HU=Z{EM7DXrj+fpCg>nE|}&Q@oPAg
zA=oF|Y1Ik}*5S6l!$CIZuHa3&eOSm_z?#7-IzHq-xO*ZOH&>GpNw2*`1em3+SV9yU
zzSMKBp4&SZowA1*=YUR^w6+M*;(IM&g@!(QEiN#YXqgdXM$1jMN!bqfK(TkU$H7ib
z!vH3~6wvAN1W%`9?nbK6y3Q_sA?mADuf&6gqkR(4&7(Ds+^Kb>uvo2Mrj&`v!M%gd
zWI5g0!`+>cinoepr`3FZ!;06xqUO0=oYu;6>4`<%w;f?-(@8+d8i>zcs&lFPT0&=M
zk0{JyU026!_tCUpd$#BGZug$<VI8XU)MaJrx?gXpIJM<)6QBIv1%!y_&(<CCvSXsu
z`%HgcWzY#budkt265!ZoQxpcv5fPr^N;36r9W5S{+Jiccp{!pqY4_(@T2YX0nC~y<
zTk>1(9aAhc6#rd`;V`9oB5e8bGw4E}5e5B-Yw0KFAuGf7%pUvxy?KPk7ZnI0pIKOy
zykKFxZBtGhhb6~y?+b|9Z6hsNJkDC-5r`)3o}42Z#2i-^F^A1c;(^3zB1QbapEcWc
zyvWl8=<SX4M%gwDE_|L|tA7*fG38h3x;!{sw~NIn%&*tF6-?WfyMB^@W-bygv7!xl
zLE*wXwj%opK{vbAJje>d{4Zo-9*SG*BgOk)W#=ESu5Zw>T_7fow+fAPJKXgY@4kB<
zcJmzx)l#T%0w>5FGRo^JWTcHxo<5bCPgYQP<$t3Y^9C6=aji7s2)4kRV(Zf75)~EK
zAFbITh@R#0tDt$eTPsqrUG^*iRtRI#-)Ke4xlA-<!Le|oF4LM6&lXEG$Ld5x4LE)E
z9OOp#;eJpsA<BnotQ$3&ytH-t_~eVT1_q9Kcv_u>>O5XWXil^Zh|>vIsoX4lC*zJ_
zdMdBzIUk<iuaC-ZmFF!uU6aiBruQS^U-V}l^C+#B`1qJ|VNn|1KhmlDTwG94C7uxD
z=DNM>#Psn^nRTn}_x-5eBl{A}qv5~%0BwB)<BZVE_L!(k*R7Q?wE>MqgS%Pv#z_%`
zD6Jqo*xR-WkQW=fujxBzk2O@IFQ=l8b|vI!IdE|74_dJggS4ZS4#mEEeF``QNstQC
z$ddAdCvEYc1DZjd2sFc$5cEZK<HZ{pM_NioH;eDsgCh0W?Ibl_^#Jja*>CT4+LEQ-
zSH(CD7GS+n&yCm<$HJ(eTA(we_FfUir2F78Z-m%+cQ2gL`R^Jcl^JruBE3pS#y)LK
zwv7qblKyzBJ}1s&a#XLut#P<+zr{~MyTCLhO+;%q3lCJn<`?!t7Unq@d+1MjZnxvb
zbI2<pd7kFTS05)#gpUlZD4krS40u#|zwCi}N{zn@a+13v1eM+>RNy1VPSF#J7%)fo
z8QHIRCRW)E4H?3>Kb=}k1<@`v*nd0l$?z6!!Ne`Q-I~!8a2l;xQd;n?sK;!7-$eE)
zZ8y-*<~5nNzS>>As|rfnPb&Qs)<lnfEF$I9X+~bby~CPIH~No`@6xKddst?+HO$r@
z9W)wE*cgrZ7&ZIXf3(GF?H6|I21&msH9{#{d+c$qEEj7G=j-gq8^=El^%%3QECC0j
z$)Q{Hq-2F?t*rUW)V5B7uHDhvEL;)v$c{2H9I@!BDMZKHfLEnwGFcS_!tGgTOPhxt
z#WoQ`n)nyY2FiwC`DM0k8_PUQD|vNv-+d!egREh{@Uo)i-gKX=l7=)@^S6NE-I~*{
zvLyi{*c*2rj!>J$idIu8Bl1R6o+1oZYWpk!aorLS*n8bnm>SC>rm*@9)bTE${a~((
znMO7qi^a1r+_GC3d(%1K58AvQ0;ome)V|QD4FL`z8jZ39T<D%#P{Vxmp1~G=A=-Y=
z8fD<lXL1p}lL?O<%l*>4aJ1Jda53Omb-2h&F#*?}8m!P$5U6S9P7UvGH=rl}e7kgk
z_-De`#*Nc-$0N(W`5FVd+kXDWTh+(L_JufI$1#+t5{K+<ciTl3i)ty|3QRYfd5cl3
z#mg#6&f6j&V~Ud>qs6lFLoeTySXo{z;t3k%=D_t`9LSlWnPp&PSA4m+=Z_Uq^T-75
zF<nFx{mt%+>i2I26iilI#c}ZNmuF9mCOicgE%;_)@u0Iq=V;oGXCxe5v62;e<#z55
z3I0i=fA1~e`Yu12E#ozzph3DB9ptPbgx+t~@ZPQaTz5R#92x<Y)*P(Au^y4#J$M|v
zul~4pBP5$OvsHXWdSD1rLa7j!mxvWr*v(l^yXtX~9M=!Z@LW2V%7gk|sUZQ!l=cZC
zl;2Wa`Wm-a`J5DpDLOS^s7rLa?aWxH5|8n5?n(8N^7;K<-GI|GUME2Z;V&@>5u*gR
zchR7|Fy6l*XgyMsKVQ{h;Y_O|>}mn(qk{zx7(WQt?tM8q)s{|zC-haVJ!}#MBO^*j
zaHO}wAa4;XU?cB}n0P;`=!>)PIIUI6D>kR$t}U(?jG(IGn;MLppYjcez9M={sOWii
zS;Uc~T1~RHL-T3e%8stFA2ByV(k7wn4czL1PK2&F9j`e5r?k#&p_O+ZlU^c4n<R}y
zX0`~YYKiPrGq#?uN!EQ4bI|am+gL}J80zG|^ooEd_^||F(b@I(6YoxG=Bmo}oT`5M
zL_d5Wg8r6uZfCnx`<p$Bl~Y<%J0DY4pN)0_fL^8rdK=CLNCjpoKh&dUa?65DgT=Fh
zB^m}h&Tv()fj{I@sg1sNT_7(>Y&%2Cwu$(I{IKA$w5uzLKSHl9i2ZS9oAc3NQLlo)
zUi%yD+4rD~sm4qb52|rR%==1A6XLc@j}fJBIInUUAIJa9Iitq?l+RDP_lS))a7*8w
z%k2RP{C~3M|N9DbP$jEJz27|#^ucj}%C;OkC&%5#E)7;%`DEL?x{6`sx58@YOt^v`
zkh<}yS@*7OSuvcdj8&EpA3p`XgxPZ%euc?dcB9tq@hFOwvVYY`09ix3Y=3pSF8(8#
zEAHc4l!~NLb7$Xyfdi>7AtY@J<$`D*oD1vimOn1s@_ysv{;CvjYwjNXci*e>;oef3
znic2G09v{x=o<c-2R7NXR^pXyS?qmi2|jrF*7WDazFKv-QuIORcL}>G5X3oE!l_PQ
zdxd8|FAeOk9Wh@p@Sg1LjC=ly7$U5{O9rE-+fBGHcUIvC4Z1AiQmTJq{gk?^tFn1&
z>9s6Qf(KU>vd$a1WdiKa)%c=xDHElR-0HR;AVcrr2Oug`p0T*LeW)P+wD?{k`p%Ea
zL|I)8$Eu}hSv!H{&lO9`ERhlh2?t(3!P5bmW2n^o^yW}yBN(j|Z-eGA+8iFeQ^+nC
z9B%-ST$RoqV(1_#stA?!)b`kvmZP77KqgqFJGqiIqWkpNr}2b`JJsznhCjmc$o+@x
zXpPHT%c0ydjVmz~S}+U*5SHIR03BV76&IlLSQ$b%q0w3nr7bHrmpv!mF7T)Xpmngu
z%^wZ(f284DNR)ASqK$#Y>wzy;zF17yHUb{WsUYkjw=eU5oyR{x6NRGyOw1xCyc$4}
zP@Vq$oAuTdent%1BT+3~|2pOIR;T2Aaao1L^_E*cX7p_RWH9Ujw#|@t06@Xz!DV9?
zNlXZ`o8MRn<YE9cS0y_DK;&!x3WJYjH#t$?m3_GSsby+M8*0`J;d;R9U4gEQiVzU8
z8*Nd3grqhvHJ~cHbUN-^)R@h>HYQ2y|M^7S;>&O=cc>Nmczkx2nX9VmsHONE!RN!)
z&0Xf%vvCP(Q721`B8h1hdTxhBPsv23%=E7EU{!U>Odjb8n1G_&Yk<-+yggrgjgPum
z&7}{Jq^^z%WI)x&%AgYCzGzH&6iDe`E;InVg>*XFq8!UVNxf_GWVaRI=(j^%<0lhu
zlyI4n%Y;U|e=PR15%t_F5!Be)6M)2BHWVuCI;m3qN_0<7PUhpSB>9CzAou=QIjHzr
zpffezIhucD0_H0Y(UxM2y1K0IGR95F;h_dTV$Aocjm`JJ6p&^W`B_j7-tx%#$>pVE
zpC%3pW~K90P<|HAe-a57<{-;!*0e|f#s1w-#k$R^8*7*({PX9>cI5~k?ByJ9&)=pO
z^WQLxg*foW!&ZFOPC__~<%TqVjQv<}!yYaw=xud+;3iLEe*7S9<h;oQ&Ez0o`gDP!
zV44tAy38!Xn4p_;_fTUe(|7Gx5b}jpGE4q1Mdg4JZI#i-6;oN=%xWNxd|gL&-Q*4n
zBrNr(#{XZJa^@^6fZoDHpX@Kx$%4Xw$~W<uH~VJ6ObU?*1Bd(ZA3uJP`yPOPdE~T3
zI2YG_nz$;!#Pp>5-T?+V&bz#3?d8$S1n?2SQ^V?bezOy3X3WEeK8Z*jP<h{clVaf@
zKG5m^rXky>e+;yB(vFz5n>TvEASL!JHfVeB9eYD@M{J6>@#KkVw57n<h`s<-7sjL2
zwB;0;!cwucczvNE_lIp}rc!&&V7|hmKq+<M5wjQL2|OTcPfZX?ZX6|KTRTSp_uET2
zsdY%LZ_Vy-i3)hL(D9mY>iF@8FHh`y`G6YS(`EN`J9OpGAq|*$=X<j3BG{-OV7DYR
zNw=5DoS#-b+UYMx2yuNU#S2(@g=Mu0cJAdQ?^LzP=80)X%`4T7b;4G5OeI?yKyNB)
zX!R?z$R6D70y8hh(&TTEI;x)q{?hj=iT>%qoac^DC2iv{Xjaa?`U5d46|^CxEo)a_
zjGQH<Az#rBaJ}}hV+3`5>aK`eTW<R95!~wz|2yi+d0xFbPkm!G4GXmVKg3O}@%IM>
zP^j>N94%YHTmNfK=o;3(&vc^OaNm8{hGbJRVgD_HZ7R0M9v(1}RNv)`9by;%cM!P&
zcq}*GbK-3PI%*rO!lymI3KB9Jac`MtM0tubG6T<vcGJfQA%eEYMu5e_r%P_Kx7(!)
zPkpqJnBXow>51}pF%l|ay?^(vh!OoFs86jz&VSZ%>^~SNwNtOpny_oI<|_SzTzJ-`
z@ZoDQ!8uwLj|g3>45~88i^GUv+G5M$@qyvg@ETC@SuNdQ1ofh75eZ4myRw_6^laC}
zosyPV+ZL*t#B7TW(N<#3Ca6VK$zA{9n~@w`4+89j(a9C1SEt#)gR+JD{XC5bJqN$I
z@|&n=_|dsS%?ggwmX*oDKv{_}Ad}dR)+i4<=(B$h{RzaxblZl4@X+16)PfksDc+-|
zE~y<-w*K@Nf0Px<5UAsjbh|{Zi7FW_v!a>=XJH|`Ge~@@w#!ho8>tf=GsG~95fX*5
z>>D>=I5sjUL!+|zKUB&W0MlVAZF1mz0CGSbB$l$Tx=4YV-q^&%q|%(f1<Rn~CB1W>
zN(4u#i3t_@7hmfiZw{1+0f{$yn$C*MpE-knnavfnE}p5aY_V36kbV5Ld<ztloo2Ml
z$5Z_>r#np^bpc+Ku-p0~Jk6AUYknx^;5&_#xb^pBqV<HQ6TkqEcaqh|Jno2$4?3Vn
za6>r86LhzP8htV|L1joDMo`&)WD8)F)=i`*6Jp@=c?hoVcg3~aIatj8!SO21(Rvxd
zg2oXM`GcrtuQy_XGz90ttrubpKn7E`7#n9Xr$91ao?p{QIlsurzyPJAJ512#qBrx=
zXcREgV{%sy=R&WK;lT{v-Q_O+yNV7C$14T%)|Y3qpHALJ9ZprZb|E<zl2)HhblHHI
z+p6(&co2|2Dmht6XPH6WuA^zKUE!cOaNcXD`9v_oYmSMCn3#`vsxhF^mv6ECB%=r#
z_3E#&*lZbTdA5T=8h3h=t(SierKHad#~rT@Kgm%}8O>|<0py7UkuOt*cfGyaHku9Q
zPmboebg8h15BBaK2FM3n!jBn|u{y+MhDL8z1rk9Kvr=SXu5k9YyYr)E(NrP5ZWu$Y
z)cX*jNF{_k`+`>i)Ks(oe^IDHaT6(w7pbo}l7VxyzkS($@Dlpg`*L$4`K0N?t+-Fa
z_s~-BW9RwjqXMpqxcRLTeLg<paEW~Gpc^G_PsavGoDTW`T(QS<!UV*24HHHtmmR)8
z5NdFvV|ZJ-X3@-UvYy-O$JB}unG&mE1_R!{nY9u$4<~*6spPJ+z1z(Pt@kH%njVE(
zm03%yi;rrTkci%T`tJR7o650g>wh1~bRO<VLUapxo}!yAR!)u=WsWeYCh;FrV&7ik
z+N89l%Pb>R8#nHHbQU-sAm5y8I7Y)i7(OSaW3)tQ-%<0rW8bQZo$31^=GTIxptzF7
zL2i4Cll<Bc5l?!Alr-IgV(rqK_cr`QNE9qKME4L^oDY{KdoLyG^GetmG(cH%F()Uq
z{<Ec$@8C#(bz++D@$+J~j%qkz_i8BQ8u#^X+r2&3j@$i!@%T_5S@Ey=li%vyo-fV>
zD1vP24QOotHC;nkn=YUl&Bi3J8h>~wOXx#6aT7=#kOsTbP#p{2(zx`;>zlSq>j!U0
zqeNCCjO`lsqbJcNcFW1t{4XZB^cx32=&s+9*=?uhe$_|_h)v<KozI)hmrI!oShH7r
z`c|D8*Mr*$4Mh#IrW=ZV6hZN|4^e8|YM6jMuCCv(Ws<vJq^{*x&IN2~30a3NF-Y)`
zm$bDO#iaQ28O6pSzpt5)Q$TQBjFcA?kBzNDAmopqp76+FyxwgjW+dj^BiQ4$xd|BD
zJvGknbC4#wF0UWHCCUBCU9jhwUXhaCD{`|da>Q(}3T-1(;ICA<C4++Lgf2ycETo`E
zHML@wQ_7E5Uk9cK>O8RkWoh)h=D<Zfm6>i&5ibtoW;)%eopgkA8s<48#w39wzUX?Y
z8$rmH){fA@IJSwvsJ0Y3on1^?a4Nft5`<L&YTD<Ws|uM6jgvX~`5@fEg-^~{dHgX}
z37Naf_F#LIu@EXaA$)5uILdHBi0LhSPu2Ec9KzqtrwU+L3Bn6?mEf-jUHZ&ws$Y_n
zF0<!OANwb|oBbZP^lZWzj<Ox9zJj{pE3nn>X&)250~Jvp<w@F|g8EYGqvShpqg;UA
zwD}mnP8rH}8wm%t<qvpyR(d+LE$0cJ^=z_syeun&AGLsU#5*}RpKGSoi_QD1d0|mX
zS@j>dvG5VojIQne$~(oeG|vKLxkz^^`#}bgG(rcWRGOmjlhVc77<k#G)i8$0mdWRr
zXqj?{@c9w9LAiGnGxZ4ZB*Wy@@lLc>XmGF$=zQ=Dw%GBe5@wc;zLU9nl5}*vZ<(ek
z^l$CmV8oqZowp;}w3x8A?8GMPWIxdd1_<tZ6ymI76-#@Fl{*Pn@84Af^nKeF`ieDk
zOc6a#s}2ZHUSk|eFp?OLs>kQ-vJ#($9&}YDGtsW=tc}^?5v*9T0;+Uw4-6l&eTycZ
zLpDsUa?Yx|R7SdW3?8!r<JFS<y7F3KSWcJa&|yk2xvWKcgq<=Wm}riiZRy)WS`&KQ
zX$Oy09o=*3+?#*RC;zJ(8YqRE5YxN=EjSR3BYnfm9bxJ;&ximywyq98(Y0Fw8l91m
z2OjrY<5kg^9a-%#rX^a_*yn3=5RhtdT+*9A22_{dS|0~1f<fy=BW{3x(1<_Lntv)m
z+^05ab@&qPjccM7776(!Ac{#%wZBqVk8Nu+-EjvBpqSNn$w?3jRTB@|D-2ag_7hG_
zV`h@9*b|!Sy~hO3@2m%LA}D7i>*~GpEGp5UAcHi_E!r>vbuj|%^(Ala-ck&xiGUP6
zw|=7_i`BN;ZbI$^gBPCveq*#2<{H>uK|a6u-Z>)8cy-v`c1P9>!#t@m3-4LJJo$4>
zMTpGNEi=<LIqbIU<^`?!scOXBB1L82-Us`+e871ikq%<y*z{|@V>77MlkoYEF#Sp7
zx&WAbz?A@DriXHB={1<6ZO|)EEQ+a)&{|TyP`T)rHnto#k12R@Vf1>V^q*5~7s!{u
z<K0JYLZMvuqIcw6lQI*OM|4XrXDM4~lN#x-?Iz=k_|Fs+DZbNiEtE<4aOE8_xvO1(
zj`vg&b8h=!u1x)%%G*Kn%B@)H8_4jI$9nVsW7G`)vLo(h7H1);mmR5bk&K_5XZeL+
z65vd{E>g{G$7eMhr1#SR1=z_NmxJ?1Gph$~Uw&w2`PSj!Uur%IX(TKyXp3!sbb6wi
zGR%r&GG*{@eb9o3wFU%w1pp$q#ahk}=No*V$MdMYgWX$O+P{*?rGB#=;mo+qw)9sG
zqUO<*+hdtfR%iVuBTX{;f~dzE6>B37vbqiLOwulqFU_vOYg#RiRF7uia{KvJdJbPI
zDz(dWroQDBbNZfsu@c-d01Sc0*Cv#Y_q}_YK7-`aVmHJ}R(-g~o}EHRr(xW)>}bD(
zJD|IU)~45Oq6;}956~^T``|bz3$7Lb!{q`lcB}C`=^GU5kMwF#hMXpTsn-|S){sv#
zLciwC-|v`rJrx8{>t>tja_BrPpsyLASW6g$)9_(N^!dL@h~)KwARm5Tv^~Hd<!>=*
z6@ENv`(ws>!P`t|o0{zcKp(JWZ>gTdV$EruWmNLjlfz`bsWIn@uFVu@hbb#&1_nhz
zJB)$2HkKb@z~eVW0dfD-QQ&V0Na$AK90bP#q78(t^RCOAj$1S2;Mjdnl$#7ExJG}>
z^X42Ctl-CR9HHu*L)xEyd+}T3{GIv60tL0E_%`Xq1aU<GZV4~xFnS2sBu!U=p>u^u
z3!S&Tb1I^4q6(lrZR$=|w>Nj3Pk*Gin`4c5Q%n_pxOrBo*>SR>+p`auW9^p->P)Wi
z6oD2sZx0_SA-k(a$z~`lEf_{f(=OG9Q3*XZ-w6p=O&4c`LIo-!#coZzt=c2LCz)7c
z-*gL(adA?74av{qFnl9PnPB-h2a&6I!NwS1ld@H&^|ED4x?*aRfP-?rvlEYIb1Bd-
zPmiUOnIvd#Sg%xC>w$CcAG!&mYegR>9r*1Kr4poFy?kImrkL0gcj^i`r$3w(5dgOt
z{R9^L=dp`#tvt(@tUfx)O;b-Gk@WgtcIFM>3OJum@P6A>3AF(8Ko<6#Ysh=^VHzEa
zpPB-n^d26Iznq{oZ|=4=@f+%M-nn#;w5kxf5x)g*w)hX%{(urVh&BZb!+wBzB)CQE
z?F{c$Ex)O)Jr6kfbwhx*`lyVG{m(aix!GpePrS0ZU{dTKYjT<f=AV{3mU*;>;P$Aa
z7bV7J#dmtymslY4hv5){RoJuOTLSX_*JpD&mG|IM(pi^XNY$?Z+F54HO^dz-1}_I^
zk<n`29c#i2=YU<Z|529?GXSv3>6ME({x--I8F=+4E6aeX^KDf%?Io<X<Le7IN(K3=
zOX~T3qMz#CnhpIV$sh%K9z{1B#<}NvbOs$#5rb1LF;ib<DbOsEad~?p<9uL-$jzrL
zYmlv>+J2#7iAXHqWap{jSYBg&8E$yO3bnEG+RzxKTsZ~$YR;`Nam#?!eORm~hw+V~
zuXkjwa;Lc8VzpYv;BFW&oA*skb7X8UHW7G{E=k*^PSUITqO+!Zt>3lP#isHy-n6=P
zKB>;&(cm~Uu(3j?S?OI>54S%#LftsB9#u`X!(lM8KX0P3cKh3cVLlRoxJImb5{)o9
zCy0+lWl=Ysn;|j}bSv0;-`xi;U_x5l-utA4(g-F^7*bR4<cz2(v_V_M+Rc)+KF>`k
zH8X^6_T?Aja*3~xDfbtDoMxo3y_e2faC5DWvRs)0@N1-Ni|l$lw@h$*j!S3b93bKK
zVO(cBO<JN`bx$oSBPf1W5gc$;gsRW|@0oHy2sy6}fZ35n&nvm-2_sU{BWjo&uejB)
z5=ox}heW*{2|-SeWt82$;Cn+z4#}&d0z1w#{~0@yJoli8Y{>;AoUfSC-c4ZaC{yn#
zxwST`DNT7h{+z<ee4AOo%ey}ow+^~4{ciie5uT)+K+?*lW>@-5${3W2=3u=$2el+*
zX<}X-1*(oq&?bZNG`~z!&?m$3X!6ksfV7*<`bXTWmD4p!hl}J(=v7}#dWWnn+NauB
z{ZG#3;m4$si9d_KVBY5f<d1}WdRjaF<*}xhG*rheooaME-mwYUEWE(C_*NGnEH<0V
zzTsb`NgweyFg!V%d~1&-bp_uW4%(2r<>yddd@7Hn9gud(N9$}%XUtkn{96Rmz!9&G
zPwr?~=Wu{WvktruRf4zL<14I1;Y=2^vU<{+;qO|*%S+n{yvs{H&1|8kWMv$z;pw|g
z?EyAi=*_U7xQrE7+#B<e;M!Xi<ad%doMR8ANb9AA^mnObW?EJf%O{EEBi1GBR9pjL
zr{nR_o~pjSez~^GVVX6za`jF2TG`6_YMrYGxB-S&{@4%W_e0&|K4%Dy7>)K*;2t%q
zoyj0OVbI}got+R81@^2<{Kp87|JhY3=`E9V&i^&XctB*4-oNa3&_&BQT@UCIVjgST
zV>^J<*p(?Q9?`Czu6+9gJ|PJm0<{dm2!o`jiCzLmmd}gaws2ISl(-rIy{Q%;w=3(c
zpyGe?{_0Mh%`-3=wZhuuVe63!N~wzC(yifJvfg%%n&R~)lHvh?4<V->ZVy7J7%*v+
zmL#KpSKvs_!=nobyTwCqFvTeWQ?HfGx+!W|J0}2`AY>F82KN^Nl<wbx^lnrMj_qmf
zvm!m)H*3A_y~Xv|;IF+`xk;4bIKO{~5C3S$$dt6gvR25!Tpg<bGHVB=vzEy|p>Za_
zajDE!u^M&1xts$bYf7-YEK3jl1`lnhrY?rQpCv8$!1<Z0c$hn$-akbxsqH$~{$F`U
zTOY3L<M_6y_bWEVKsA}S^*YPx`q-mV%17YGrL|?bmjgO0iJ!i1xSd!^ypQ~DGS~k@
zT*STXiG`i@#Ed*(rpZO3`%bs`VP>l+nggd#sR<B*ptD(TILQkd@UKrmyL~yx>mJJ1
z<sm?Sx-LB9;_s8Uznao?E{@XTYFf|Di<?MiIhPzdwz;ztmvs-Vj5!w2P6Esp&s%7s
z5ieo8to0Q(=sRQa_nPX5>l1b_KyyU`Q5~!GxyK=ZC%RRK`>ME;XyZJ9xj5Erc<o-u
zP7J;H>xojqF$ZYe-dJ_t1+yigj{9EHz-2mAs_)!f&(R%WTo9xU>BrO<%iL4$28mE=
z>h9de=uSt{YC=ab@_yqTFFA|T_YVXZF>VM00&hFu;FgEI0=*)iy~^)d*+ca0y|JGg
znHuC3&r%4GD7E`y)bslDu}D99*~w^sOsL|?`k*1JkEHKuD(MyDFTxlwa<|=jK&a0X
zKU<v9JBdv(2F=_~+ouG_%X^Y1C-rMs2bY?~hFk=L^+46rBdiZS359sF1g}c7=zUmH
zPSh1wN7pps*b?Jb)dbM$)cnkP_xq=B3Gi~SjV<-?Gp{712S>HGH<A=8#asRF=~69!
z#kz;aQ|vNV^DDiq@IhVG+ngmIn2j0J{01j9I+`A)BT-sUxg=M+PC1cJ_EG^iOIiUC
zE4o%s;qN93$rW5v$a2Lh^{zLGz^8<_X~q5tN8N_Jz0diBf~PZ~u$QYWU<B=9f=Yf~
z9-!K@Dy?Ni=uIN5?`5BVJHHU=p#+7#XrIvJO-n2^36DM`3#DyA6-E3#;kW14LQH;G
zEc`xKDrn_0F!l(@h}%n$?k2u-(fI$B=l}X&(*uCPC`ou~7YJ}VWO{kW>7uAMwEUso
z%U5?}qOy&A6dfH407scK_d|~&7{PjZ*IkN~G-_VdYrMMIJ*s$W82G~R%!tus+>}ju
zqj|5J`jgiXP7v_ql|MmZoVOk}&_s+m_+H)pm@}ilJNL$Uo<k`YqM_MhXer{c5q{+k
z;D0iAnyP5*s;dW<Y4a)Xu?!|vxv3IRMRu&mRTiml)GVzK1CFUc2QS+#Sz?+n@WLp<
z+&}RHR_yQyJa)yCyAawEmZmEm4(3ejaxMLvg^B+JB0;fSz{%nn!PZ_9PEpYBef4Qx
zD$;@b2~;RP{{(0x5wyq3#heaZ&VICq;MRm>B5zvCdXbvtGIiq~BRg--U5vbH6fdo7
z<(SXHaYKdx@(|}zeE}?LkPo6_1@`&n)<EJ6n4^Kx^cen!+WzmhT2L%An5<@w5Ik7%
z!g*7N-X%UfiXK>u0-=?fu&CQ{NO*=Ym%=rS>?te#F?3hf8iC_4AOMe{<4L?S%<liu
z_LosrZr}SjtO$ZAf&wBUf<Xuf2-1y&bazWhBi${ibc1wvcY`P$(zyYpYXj2#tlKyT
z`FuU&H~wQh@8Gx(`@YwjbFMkBdChBO;>hnjUNGn#>HFU4_WCn>Lv8%=oXx+xx`qX8
z%Qb8jgdEA5C2ivG!>v>;ty0aPI()TI|FLnmF5zRIOh?}nahW!H<Napk-Cgt$l6y9C
zZth0pR~Aqu0X!!6hQm7QQ1K2ksW`ukWhQ9IqwL1McpGd4l8i-Kg)F0i+!0RDZz{JN
zt;?G=jT!=piHr=Y->{+itYGpD(qTf^a55}q=^jg=Pz10vW?JP|1(0fhl^NyV>j9T=
z@R9ZJ7w2|Zm4PLCp%cQW3J}EDSOwccbF?N-0jxi}yw=1VT}}YB7{H}W*$d*X+5#_p
zg8hkEH5EdkI4vO39SOSaHlSma=#F$&QmI@K;xU3=YCsh8gti%=ZOfei`gVot7rvZ3
zJ-vW8BdwiI8YQ(DUte~Wqzw#ZHSPQwI2>C^l6zSSrZ{lKibn3;QdDHl(7%jERo9lC
zt3Glch(KhkmT^1nTl%5m4xdowAJehTjt;6ksT!@$RV)(*qgh5pouTCa4kJ$bP}2ji
z^g|i4iiEtf$6Vvz{X73twRHWC|65hN;PG1s_aM0nO)o#ca8p-ev@yZBd+1}N$tfxU
zP$LNNiiqg8s}}?>2i_=oM3z|E>0}3uA@xh~41E}bMty%1T7XSf%R{T7k)S;byx}Ry
zTyq>F1t>q++O>|3uJO7bJOR{KE-)lGzizsmdBOdlhV+Jv{_u)5I~^~G_X2O+#3IKm
z8TaArVi}o;U+3ugeSOK^t{(?=%Y0#iIj}rS22B~Q<h?`Wh%pM^nUJE)(NR-q!b&?>
zNNx2JQW&-C9nu7DS0OJ?ZyadQ|J$v3yR*mGpP-KoP=-J-A<%$#7lG{1W@oSGFz5+&
z`eZxE29H@EX74%1Qk**GcD^1+Txx@rY0FaN+ZMTyYZ70_WRrONyDtNEK;*8L3&nG?
zjGG_!NoF0)61RdeCWt^0vAnN`cp0%(6Wu2S#9uG3<$!vA%vib!a-a>tO0(WcacCqb
zws5M`z!<d(O@m4McHEIJ9a-#c3tP?7o<I*aoLI8c<Ny=2%uz;Rp(eM4smY1uODmS>
zXdWno1ndztA(XR$4&WbhnlcX?ExlDhF;oz2&UJq4|83b+D}zGWcK?F8{XI%x0*%N4
z@NgSf@~G1AdkiqD+FHLjc73$utXmyw&jjd=kH_q2jn4crK_3?uBvi^Qm^^%et-qK9
z%E>zS)Lb*Mln1Jlz-;yP&FCF8l^(;cqm8CHX1crpz_HS(^QKT>R|2DSI>vcwWs&0(
zeWlDF_I2oeaf>Fy9g(d+tkI`WN*b@Se^M?prZ`?z+PB}nxhz6yp!=^3;Jq89rX%^L
z8gdX)_l9}sA9bdGU+vdV^-<8yZZ4Ra#6nU|o6P|%oP=OpaijPL%N~edJeErhf<inP
zfl7|%AmR644c`VFlR2YPLB&y|`ZIr#v;YAP*eUMR>#;bGXsT10?wQxcC1+w~(+_R-
zu5WAvdaa#8EZvbOV3sK44TlKBL~Wq}3t%e5QdEf^9HG6F`g*w?>JUL=!P)~EL%)Ux
zBMz7B`*)XKDHLhEp-^S+>rwh#+j(9#?j^x>$^}7yVCDADkN$^ECqXuSR|ei{50MVL
z<;_UWeVFNLxl(+*Y7B92*-(;B8lbp@w5nA<*6og^FJl@bm8x_D$k*y!Yqg@Ua&)$*
z<eG7QLohOs#Y%-8b9`9OeiXx|ZA>t}Msy`l5~ggOx-nU6^nI2gsYB&C$jqeBoz-)d
z7+&rg27!s)(utWuE1h^kVI))sU#Go=)9sBEZr66cH&?5EcI+!i{~2%nA3#SHh=tU9
zBZn((B7oP1#Ig|n{IH7@0vt#M$K2~*;{_TfjVq_Ij!IB$n*H{<`dBmvjGfr7*A8`V
zGU^{y?cnU&e!e@MqpE@|)VPpUxI%CB{i+$D51AhVBtFbk=E@VQ_S#D<T1`Wd7u^cA
z$=X0AdpGvm@W%7+i(Ao$tLya-hHw8AKYGLoz-=JuM=@}PN5(mxo9l*)x!^7~NQ`SW
zpLd@znLk?u80*5W)yErsv}=K?4}VuZ3rv5$6z2pYz#K5J6_hTIZ$y8nkKN#LaOAH$
zEqdW}tmzbM+y&@av9=b)h<nId_TxY{p$%Oq6>n|Qp%K=bsCP(lC>nk8;S&Leq465b
zC|~)t?ckJag}b}ww&m6sh+{1-EM6?bQXo}U`3}h6__cE5c(jnFTq2@V)9jN3pt1Ft
z?T&Icl<zCIb$|YQyLX)%+7-t1@gN+)=vq%~m^sgfHN!G(1_T1r=4Ip1th~zBm8x9P
zb$}JU09of8z3!c|T?cufIuW*-Th+g>(}`zLotKxEXHe%*r0!<uucB*gj0F?4v%=TP
zW$BB^$<=`E@}Z5s=%(CdVYQeJbJlA3mT`TO9PS&&$;HX}7S(1i3l-_X0Yel!d#yAn
zDZF9IE*IJpMdw_<|1qxLPT{f(J$&ucS-)xlkR34i67RbG`Qd<IX!0E}ZnOaf6Qq@a
zI=jK3mI<Mn2m<mybEV^VKpxr_a6;vsC)U)ry}HZcV38+$Z01o=!F7BK5-M4-4(uG0
zZMF6$jv8}xaF}tun3qw@8!=|4|LHS9Kr8J87XJHuiUZ~YJHN2W(|s-(P5G&XoR^cS
z|JN8!br=d*ccPaO6#{2s@j07&FG0BJ@AcV6f)Whyi$a5}H{Zj~eTG%FUgZ+f9eT3F
zu&ugjg`Ten?PiaR<AkI3{lM9uZ`iiI4TgO(^)Fl+@Yu^va0B!HGt&ayc=Ld8@EAZB
z_uKco(o$Q}H@aIutu$x<RVGsiv}MA;IcFY~)Kp<E@O`ACjOhMG#C~ZVKr4@1kZ;DT
z;y;<BilhV-hDGQNZ~dcfHy;$|FOkM6^Z4zL?zgw&i}Ls^s4NwXUH&_cFqH$fsg?M{
z4!{3JIfoOD0KZH6rDjOO1$e%9E~>f$;Eq#m;)r0g^-PX{VK#iI^2)fQ&^#AVG~abw
z<6@13*p~CR2J5??h+!u?IY%{i?>Y+(qHC(q0%=mnhYicJquGN=i{^X-%QcY!wHG3x
zR#Z%@^cMHf(T_bL$4sk(#^01=RSq)Au~vLwgcr%g<1gXjCdHq~`67eN>^d3_l`+`G
z&riCx&+W>YU)Qa`M<&=mj>qXj8SKhN((Z4o{biwDSIePJQtN;m>=Axm)xccpH!!Sk
zf+Gw{H`^#1wG>I24Aq?2BLKQxROKz$eSH)sh+32KC5k5?H=Z#5Eh&l{8aB3sxZyCR
z+c*2X8f#80Y^(wXX`cMV2Z;!RZt<KK7KyIh_drAmsHVMI6>V-7WXLUgnu{L&q==;`
zZe%Y&%ZVlMhD1;mgOY5Xh!ib4mi!RhdM?FGFpYh%v_eweMqbr<{&f%SBSuQ*yYcM|
z1`dh+xiO^3U{1+e)bpt309|3D+eDxEO{3rEm_Z;fR9%#3hALz@Tr4<ou&$71Ry$68
z390EClEzp5F~Ruya7S(!J5V>7dT5jRcV-yjD{$%~8V#9gaseGbLek2>sB@7x|2_r^
zfavh%W9ft|Ef!WS`0dtDqD^!%T@Srub_lxpRIpKRvwgc*7Tz*i@_fQ(_vwhUdfeDF
z_Q*(1`-uLWhj)$?$No2LY(9B?qeHt{`FKLrj~`{?rxxxaRjPD|Pc2U*IOPGyTPI@(
zz5i$0c?Ph=KmcKuJ3hGL^94YL#Hf$q?>iT8+lVkoUET8Ysp-~FZZ3}QXTRJn(;9Ku
zpY!rh&R-WV(8L~j{h7#Gu#YbX7F%hsE4u%p(<dOX;`8dpcX+lWk!;h%QT1yul@6m>
z9Iz)}Wp5k1Wj*VUh#Dqf5po@i=k8Uk^b@e2qCSpXpbQ{<RTYN!yC3+!@ui+0Jg)<y
zSP9B7Br)Utj{BTNauI^ZMF_4mm}e)Gr<S&;uLtu6MllOzhik2!R^uuO+o`^iTEm~q
zaIzY!BVutiCU)0a)ySQLKPEQL8JER9C8IVSeGG;m^f&~%VzXarzs&s9>TK-PHGJBM
zzSh3x?4XwILuLJlgt+yC1wQFpseAgK2;0r_C|G-iO6g-b(BmbD#+-YqGruB&{=Azy
zTm}AQ9kLN80wD8yW<$VE?I0q6*27w+WxFViP5p~^?|sZFTOAKKwR*ngX|)y-@Sq=X
z#LoKMd!Ec+c9Np{fQm!z<ls;a*zwDenBd2U=rckR5`mvS%Z7TkcBW{!%k~x+p}+I>
z4R>b939@Fl>tcl4^!SljhHoCIJjohL&4@%##bSZW58^BfT)7gIJF0_-+J6nn?kP9Y
z5_@FA6r=s42M>A|)<1sim3rK)fR-i~1YSYVZHDIDgP;A?6c9)*`XeBmKsi*Ly;tcu
z8<bAvBm@xj@lb9kp?g<_BHFl#gwI1Yv@Nyb8H0!N02}8jn6|R=@bYTU_cjhE_Ej8v
zY#h>~;dTk>kf)n@%6Q*=A0cuV#v&;%|LU%Be|*X{d<X9psus}iCZI>S0`J<Kt)2PA
zL-(936PpwzIEnT-^>eQMO5QYTQPu=+3**T?8ym|d9%R%lGjX=$ii#@j!!ES%o#+H@
z6V=gXDy))32BM4o{LCdRDw(o58A0?tW_#=Rw>ejX2lVaUy{YTAWMSj0AWO){Af38@
z&biP2>e>cU0P%`gWwd{P`m=*n?~H^1@Lt}={`j5Tm_xy}d+y$yvhn@|U#2sLD1))H
z!rBhdoU>eyyta(TgdCL7D&U#+MC`SmtLANF5fuhihT=uo{n-+79~ktKMlIxZs&|tO
z#|jd%r5w#znVt$D0aufj&i3#kz&$ngKn1F<YyS83nSDcKV{$HV>FF*>w*_f$&Q`^-
z({o=;2_0y@xy%qoPFef><;(Fjc?(>}&b(S@v9Q#Wcm@SBNQTqRH2REC`k%=PuwNoj
z6p>!^grV#~x)pT`m+$;0`~EVJDI{0U>sS%2cBO9YY*Yc5iWbkfFV8tOcLO5_BS|TD
z%IhR*P@IxhhARZNY74^@>6TmHT*_l;G76U|t#00((P__S%4?a+S#Gn>9BLyWB7Om+
zXr4ajva#{Vl<O9ccPh<LEhh*IqInx<HoEZsigmT}H+O~J#pV9S19&r4h{f=*T9O@p
z#l{C@BP8stD@F4)_w~qeLhVGZhXH$y*TOq5RCd-wIe8KHWR!UO8IdoVK)GAkv+cA0
z4Ax^$k?=MGQmV$W9a{2y#-$YC$)!yuYh&Rgz&VwiQBhI*ZFviwoogL78@-yG99Q4I
zeX$5mt=<Yps-n#4lm6+?9EWBfX4b~+$A`YpAO&G!4qQXZ7`%qmw1UV_{zzP1YJyHY
zASE?pIIuvW)L4zm>pK3kUb5BEXhn+K>jS%MnIou9qy=F;a+6e+%a0VAuU@^X-B~Fe
z8okeNaWnP#7+jPVXCV?bHpVP%TV08y@TCyQJ)aPxp7YYP@8x0yvVqbJ(zh<?AT8Rv
z5JP4dFCYF}3*g+T;qU-M*cAaYUln$_H|05%fZl+@x9QBNs`l;3j3$S=-BzB~kznl@
zYe_-5#j(SeK>k)^m3&Q*tHDX3c#m9R?@+mCy6V{Rb#wxuaJOLm$!%J!^hn5bSJ?1L
zzqG44pAt_}?eXl)&0?|8rV2(Y)2`ghP|2#bTv`A6{QKTj2Bk4Sayo<l&?tWPZ{<Q0
zadZN`L#NuS-oEb`+N3jX8mu1b^%yGTFI+W<!af8+dqqj&=AUl)2g136vUf^#b#)v`
z8v_O6=`@TM{g0A!7AN&()DHV==;+~1Xkr2MB+(R4qRN8xWeh%e89L6*u1RPXleCxO
z<7I#U`ZZAhvWK6US@T3wNzNthY%MM0z?2M*HZ!_ZWiM0&?boPS9{dZpUDKsqdmIpu
z=<PR>F{?5nFZIsUyE>-CN&xG9cmcx-OCBfoXcRF`+S}Ik#4*qG1C3^D;r@4E0Fhof
z-LA);LSDgk@?-X!J1tkG)(T4%3Lp@o7MtkYcAZK3IP3j@*RlwPaMjB}hZ&Jr&DppP
z{CnaS${eR_R!VFR;p2pYM}sDyyGIw2sh{e4d;9wi+0yL#0WA%U;Ld7y@R6gvZ@1&V
zJrN0m(A?=!<XvXzDLbYNB^CkES3O)??ce;5GLpEjmOK)Ri7O(JvYNlUzq!^VQ>fSe
z;pIH?M?Vn26@p{QdL&-o1c#DE))g$9>@_|$$GZNUU@aBrooa?hMzaqL#*`}zI(P;i
z%XElf-@GknIOh(94BsKvWCTKf<_-$h)f|4U!!F-B;y8M6=ni`%-u|=Z{Ue4A12tuJ
z%=a%*_8^ErY&Zk!Ps6B3Mo7RSUB75jFPEW9DjyX~EWv*X>A=%R0d-4Pu#M2EO`%nV
zbtQ2uMIjh7C(EgB3KKGF1EsuY!p8UI)abiL!{g$}yK7hnN9pBq@lH50)XH2d^c*Rb
zPKrAAby7<@-?IT5+leLx#nZXP|Myobq&=A^mB(%Or>=qz*NUf!o=cb1Kpb9wV>i`r
ztL5pYy`;Uju>`KH;#alGQ?pT%<^dP%z-*Sc#nSaC^%cWoPj-^PaK~lvl*K0IAFeT5
zdz6^WW)jgDbY%^esxI0{qBG@9nx;9<H68dmx3dtinHYc9gS4MTNZ<cg)DQs=N1s6I
z=^_S24UZVXbEfA2v7?X|E=p@lzDxv6$UC%H9$s0Tt_R)95efAn>B-$7I942%;^bsu
zXY@BEb;Ht2W1J(#lg2JEB{i#OjiX=X2z^u6SyGxM{VtTn*hX<{d#lj$ur4TixL<zA
zSzE^_ID-~m25g@Md{ZoD%2{Lo!^y!lSGg{mYc4CXyi7oU81jQPMyd0{-D|*t_G;0O
zDv<0v-L|%#VUxZM1@{zu@xJjG<*KfyTN}KbR*c{QtZJu>GAgh{Mm2K7rNk)r+Jb$G
zh5lsUcnDRUt<Z^bZT;vy<{2Hmf$Ew9$AvFkky}e_X3f50O3j<!&1d(+n-#~hhk<&c
zdiOiYe>eSqeo~hMTk!v61$tfL82H#E;GvUVBWx$kk-ZSW{UpXjo<U_WkWIp%x*1@`
zMvwGqjDVfw)c7Dx9?j47qT_l}w_1?QV!Mx-2wqAHcKEnP46XeHUQnr7pm6!L_VOsR
z*7~PUO4&63kI$-BG7_427oir?WxEQ}uRqs+9ZDF~(vd}D1m0cI_jHq{d+rKKgv^mE
ze!kWu;^G3w>A`o(eC(t%WpeaXUc)>?zk}mk9)$WK)u&uRH$TW%{YZW$DrGIj%g5Od
z^g!Cn;Ab>ez?E8eoL<0wGT3?(7gsxGv!y60$5M6$9N+o#Jde*g&e>n{q1Hq$)-1-a
zXOklN(<5D|AhYIXGhGrE6_$2&`)LlEo(OFGuBg}`<(#$rrj6qhc&k&ikTL?eeXwd3
z|CTTU{GYSg%i<NM7xKYQEl;K8qQMFk85vD(U{sWm;Ut|-A`ibzL6_~!2wp!kM{+5r
zVK#VRSDqVZpYUw52?7<V*M+*Q$H=#MZ>&R8ZF#{`_s>1CKlH>X?3|e*Ktnx4pW+}8
z7xjJrZ42`-1Rc_J4^h^%Zf$Tf(dLk2-@4V-kGtERyMjN+J`|ee=@;6Brle3c8AT^h
zXuTGK$H$uPc8@<bAmVg0?R)#0c@7QWItM*<cb!OBwprQ7%hCLQw2MD&xQi1jUA82(
z*l<u(Hd~Pb3F(l{>1vLWRZ#U2TcPc;qW=&t(iu<i0OIj(;){##VQH}m>LPZTKT^Tu
z*EbN5u!|_HWOs9qXFK}5<PW#A5lkHSvJJ<pM@Q$4XWcgW1fmAh<h^v9>7I+SRK(F4
zG{D&uzJD{o%$~NJonT2*97Ddo5}c-14I9<@91E7yUNq#tCJL*dOhQoN`o*8Iw{mT{
zpK2pZl}**mZ0Df%Ddm$_1J&-z8LFJGDC0Vu6eQ&+o-sInAE`Q2U+i0cnPkj1r!j{t
z);hY~9y4mz`!21G$lauLr^3M6P`KKsZk1@6=)LptahAj0i1#3q9T6FsV$%eT04Py$
z56eInC^fkkCxuIo@Vvf@_Qq{%ZgPC21v!4SU(yCBknX(eknV(GfkAxzHOzFAZyva)
zen}+EvHj1xmKnwuQ3<+Z$xgHP8};I<d~0i{!i-hAO0R<mTJ#aoZl0X>UVu+_&frFR
z%PU;#<wpi%DpU2$ErRdBOA97{{g0yxMH<i`x!w#jUb#pGWz08=31pHQ5tI1P0!xje
z+8_E0hx_;#a_GmjJdWuK0{Z&-qt6Vw$O{ek5e&v~$WM3U^qM%Gi;S(^k5-GT^c~Q^
zaj&&WQz+SKwSJQQ4xCR+$NjEmJGkM@tM>c8r){OHr_8IGji*Q}te7XxIK^LNT%0Vi
zHSm5M<gWDqI>3-Wo?RUz{#iQk@P8JPw<%xX<O)2Xq7cqWOTP9kEgE|v5R^!>iCjrB
zUD2S@EPS@jpXNwp6y2NQzs1tGAEi~a@{MD@eQ0x%mch4sv}CCrq#RnSW0|#)PRB9L
z*+&0w0j550^sLR8EVEAgP|}#qs3+ZsjI8n%cRkq(|2%nldFkS#Q@q_u4=;Xsp2($H
zuV7Vt6QgBpmeo>BQpT)ZqTc1=&6wQdrYir|12poOor15Y2v)IIPV25JE|787Rld*v
zIq|@$4)y>g`{cWofq$nshOPtpt4{IwJK(Yggqoge0lbQpk4iau2U|o=@_QK+M@G4;
zStZ6J5|r$xO)qD6SKEW<)BHj|e&kNmRAGrrkvw>w;|NfM%#4d^^8cTXtX-p+uS-w7
zht!;1w-$ODUcKP+ypAm#oSl7ll78jY>ItK~wdtuuZ^d(y_GVc26{}Gr5^)S1C7C7|
z^XEGzf#G%hvC%d~G7RLd57p-*QKG97Qc^D*>kF;}y>}2LIMo3PhSK4*DVx>F$z>rO
z{UKrMMf&(PY*3}@QayX2PYI=D2XnG<Cu6-PvtvMUYbX>HEA6WctTHRnkp!#{@fh+b
zOP%*pG*cwpWd~18q#f(B>=fESJ`wMr8uB07z^;WL)`k#$dX4Dt7@Q;F2enx&6coa_
zRd9sGk)ouYw=pb5vpxK2hrH?aYRJp<QdF{rgL^y*wPt}@>A0xMI6pS`%aHH8cfnn&
z_Cj0@7x!sb`I(e$hD(@BFL6SCexZyDQw4EB4hMt&XKIB)4gCD#poXe3ynvId8dMT^
zC0>hljUOWu;#nOf>WnYp+RmP4=-u-pTr!tBRU}n&IM%VH)C|S995@x=uHhTpslz)B
zEaR~20{Q7jX@1{2%OD;eo;y|V-@l*95GZSFc#foVgWU+MYyK79r~h#n<wI{xjP)4<
z?1d{rT>c?%3bQn|em}<IKvr;1Yz&KaYa_Z?_{s_!yOCP_^}&)p<0|kus|%rWA6#N|
z6MM;~xm7Xa)oS=ecz*_b8z?8|mv^5_gs`ewdXYo`Rec2*oVgXkc9<gql9hdhY^R;s
z@%rH-8k#od**H4qmgXW5$!AscCg+~vTEJ13i{0Fgzkej3mO*u{D-p|EpsCER$e!FQ
ztKRI{1U14e#CEw(@&50yzl#eRl-352y18^ir>V~b6`8E&gPBnS<aS(Li>ISSj`m?s
zrMRrDa=S-y(%mgri=#MQyYG?5NgK{bt_w7#Z<Ql13{8KV*7~`64p94hUS(<sjgkI2
zSM-Mv!jG@AaLG`Fe&lHF3$<iDPt8EG{-XHc84epuJ&xK)RHVAx&h?R6^Ca8M?F?P!
z+s@10qO|u6VJCUue83us3fElWsF;ofVexs6`BqyMK^@^TeYVADv*-VZ>S8yK8EAlf
zddt<D*8P~TvDBztI>Bv7d)Ii<162?&J4?+pB6?W(4slrkb4jpPcPzz7WC`!!aTWLV
zyTfwChN~a8iO4G7OTgE^HU>qO49NQfi!OZ(11eiQ8InYz-*;!*$~YX<Rj4RSGo`a+
z+ef=bOH{7oGrs~e1HGe0w~Fyd(?OMVr~0OGbn2RcwP>pCyPF(P%0DMECRoFamaMbQ
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
PA%3cgS_-vtR^a~w>Re#j

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/2-icon.png b/docs/static/img/debugger/2-icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..31706670ccbfd99a6323d1f6c66766e0f2a9170d
GIT binary patch
literal 27014
zcmagF1yo$I);2tYyB8@oP$*CwTHK*XDNb>Bch^CRTY)kZr)Y6^cPQ@eHfV8&e|qnI
z@4fH$e`|ebtxPgWc5+Tmva_FO=Y%WDOJSnDMgsr<m@?85$^ZaR8kR0YL4y6N`Xv$r
z0BA*);^K-j;^H7hCwntX8&d#4I{Z5XSyg3$Fl4M1N|j9uN*_-Jr2~}3EV5B1J0+#z
zg7L(paVi*t-mv{F3^VvB^^t%qk=j^Pq7oC1utGjgRFni6{il&9kp_bKs@G|0{VCs}
z&tdz+QT2`Hjma@UM9l>Kt7Qc>018)0KRgymh)*ijjR{041jWL!nLAenM~#nz!1Ke8
z?%w{`XOc&CJ0>Om{xAA+;lF=x0svpB(>g{rbKm&9CV4}aEsX)N68=fbM1)S)NN!k!
zB7?KhCL^D+`%OkZ+30=pc{qwO^=CwYf>HHH89<yxnEdZu8Y)NW3>0nj1|MLTSn$f!
z6lViUro=qKndtjT6CbZGcgOf=LQYY_gc14pGZ$u+kegj|)T#N#mp#Wvds&5q;UmK+
z4CSf;VVf$m?csZ6PB>F0X$>5XZl9CH7Xmuj$2aE53B6INhAd0`igjGJqT?8J=f0X%
zJVt6g7#CGOUFI5zxNnyjm3mBu*|gs`m(zSu&ZoQ3sJitW#GT+w8;R9o>(>0W5l}7k
z`3FmU@Zk9#>SK%9&DHmrjEpPYR-YuBQXbweeKme>F8>TLJ1HllWD+T4@0jxtpW%Wi
zqSeG3bxO?ix#hj^kBsl+EZU5cLIVr6*;SmM4UvOK*-((7U`z=S3=0tPc)$mP2v6S4
zL9t|#E*)H92F=gLAnqtBV^khBXUn?Tx@*Aa)j8<chV9z4V6f_0^&%2Y=p7--a`H?d
zK9DCmtx<WU#4PHTz66+6oACzMRKZ%s9Th%opd9e35T4us@Hv3C0x_oJl?NOp4nRx<
zAq-I#h)nZlA+p1%0<Q!fF$={8$S;C8kBk+VvyM=REVs_ofKmn~%|c&B#10_92!t3A
zv>@Z-AZ&m*Bm$<XbO%tXz&2ET+gNuZqKd=>=)K}Hae#Oc#%xSQTvfC$BFI@*`$YQ~
zF1SrduHrY@eip=D@V<dcY^eENixunw*!kTUJUB66NQaEW+cf08?$iyZ1~efo?k=JY
z(m%QyXzjuMiU8VB<&V&8CM6dF{8xby;<P^{3TFz%R7r}^zC>Dyx@Ots<QC#iOT8zQ
z6P+4QvQV!P=EEBiHUFue6FKo}KWAUkh5w$biBd4)IfBZ#hK-Pz2m>8INT!RapTJ;<
zEtDNI`FC=2vgoik6Jc@0hfY4jr^?ECf+I8=b~o%gtfh$KJ}iTN2c9&(QMkPj^v+60
zBORa}(FxB9Tp2QV*aH~SeYk0R)^^L&0%)hu4-pO#jy>%Z?pMGeK$S!w5<>})9iUCb
z!NS!-sYeM4M*WF55xg%M1<J>n!~Gpz+w;3es;Az`$?4u{)Cqm(*2#KjXh(iX_xmB_
zL0b9kkA&phUK&(OPAJN+?=G2_NuS@6CI}8Xny`CvHm3N5KL$UFW>DMHj>Yc{m47Qw
zv`;+!=AS2`$fj&S&-7(Lg<gdx&q3Bu;#-zQ$$+W}W0_isszA<sF;BjPQk4>#(kJzI
zYJB-Fa+cC01vVu|Im2H@)rAUuWIVxvKZzBS39wAzcW`z%OyeT*QWQ0(39N9h5NZ?n
zihh<DmE+~b=P3VjlK)r~q5MJ3^jH3`q{7+aRh6grQr=j`SoWj&ytU3=yHUlKMV>`x
z(`YjX(<eo~$_2k33JZ$tzt}7LmjukR&1n=?>KK>znMUKv73CMdm8w>(*1HHGEHN#6
zm0v4%m^CX`%5F<;D{Py6&2lWe_=c~DFN2SPZ^?D^5aUqUWySTbX~~s!zb)(6IC0H;
zE#A^}uA+jxy>hw<{;auQ+}ZX&DSx%=wadR$0w=(BaTXOTStAD1igRr94ta*r8}M%e
zaaZUUEDDrDCmJfl9c#`cx8811;eWtSlF5*X9(<!x^()je-|{<@oU?>vg=xknRujT&
zb7GKTqi5;&8?MfwW?lQJaz7*T$Dx2aTfLQCIqhJ);SXC);|2RXt5+tqt3`tcGXmY7
zju&;KhsifHi=BKU_i<O^q^7BW)GID#E_<61Ti&|wb?!$4Zf$PXM=8g8OWN}nM>mT%
zyozLj<Xn6;ygrUDP6WKOd|3P>e7*d~ZU=cP(Cka2`!D8E)sTzVd)1?qx@5XNELSZ4
zjap6lO%%@LDfS$h+%MygKyF{|x+Ng@Fa8n1Rp0jJY4Ne3W2K$5>8Xx{L(lmO-tMSx
zT|A>6JEq69=T?7Sn>Vqkvun31t@^EgT}>An68a|eN=U)y$~VEs+DGb%>{0Eu_TKmr
z{;B@{rm9AhOzng9`wj+!FCyL`1~!2T>OYooo^kYrw8U6gD652z76B7*oq_o{I9+H9
zgy%fdH19bt=f2K=%|>S=5<;&=)h3z6l}FVl^kaJT4OW+s>FJi9l9n;iP86HoEIcSY
zvpC(Kw6Gj*N&dplZS=wDu5!e&p`oy$+tE1EhwxbAeZ#z=W9O!~?B}Fyrp7u|W6Q-!
z=idZLm5}s^{vN4*%E*^tEJO9memo7-W_(HB&!h6AvSoDc{O-wneT+MT3NErta%7*J
zWEYd(ryYIMNfPKXKWDrxS9w&q&WkDt$)%8aN+L{GgTyGrDhR((B+Nxy<aFV1;%NFx
z*aesUeu~yvYPXPH(S-+nNGpDZDW5ueLN5H*HnNO=owu9mb?A=LZ-pKD9TX?K-IP7M
zA>WL>)SC;mOSI95y6;|$bEQZ6y&A3tA8PmvU6)=5eYmqmn!7I*Y>H`Mab2-LES-at
z`PWl<iOaURJuf~6P(Jz<GQ_dsyt=e=S!p<xx{Q6K<mX<nU95##Q`P_R`sS*nIk9IX
ze|D8=<M-|by0qIfl1>{#>s@b9k5ae1bWnL^@k`lK586?;ZX3O1xrAQdzEo+`U(4}O
z<;x$=Ps^XTBf2xvjNxv(aMeiNxM`QCZn|Pux{~S^d%AG~T{vv4cgwtP`{|o`eQ|R`
z{)c~D!&K*s8;&>I!+N#2QYfEa{)>*U#+Jjx2CEc;RIXHaOr1La7j?=hJ~d_dIcckq
zSXQA`*RBT%=Tg(-0KS=~p9$-^+uM=)oBoaJlp1Sp5q?G2H51Sk%*2o`$wKye#~Ox4
znMJatW#6~!pS2^cWxLDO+9`O8-RsWNh8p89dM@tv+I0t-*=FC_kT)i~IA+;uE_KVY
zLr!W~ZBARrJnjx&tuaFQh{=h{nsf!dM|Ku}99|yEag*7<Uv+6%_><agkC`5m9$lYi
z_raalz1C&yRA_B$!uhQ3=9tl4!`*IK*P;GFZ@aZ^wYPOr$Zl=?spg@a(nL7fqv0BN
zS82nzx8GEuCPVef?%F$jTFI+yt@&kl>Q4bSG7miK%fS8Cg~2oDd3DuZ(^zq+P3S1r
z1D1QM#--7pygxfV(w&)~{7?K$?+-5ZGyGS`qDjbon7y8k<<7LP>ZMi}+O0{^$-U2o
zo}PL<HjuBdrGzJi-FzaRFMW*e%$N7hS<Upd+K~KwFPWc~xT&;zGOQ342f+B>+BQaT
z0Rxo)#U=oVCFP``03+oYo9*Me@R`e)plJ+XntICQA*g01%Zqt3$O8_v7GW_!wt;HE
z&%cli^)0x+ltHgT5Q+GayXJfn73e?jg8ibq`jXaZqU!x;>`s5o8R69f=h+*W@fu;O
zA!8;d2Y3fdqW}<quK|d#6c84KfTaIUO9JTu@c+n%0{}uT0SN!9BM*!JUU9JSSLUBF
ze0&H18TJnk7Cf@x{--ujIt%`P(tt8p89-D;Tt)^Ks~9_(n%X&A*t-OF)*iw#P#vT-
zodEzs+P?uPqfGM$*8Z%es)mb(+-E*xds`Mm6MG|577ts8zwH17JosQqTT>T9kcX{}
zoim?@AoV|L@WIl5vstM@|ES_(El8~)rw9_acQOTWv9PhQQ467gKp+7p6Ei+#3CVwn
z!~O|UTe!G5@UgPGySuZvbF$bwnX|I<^768>aj<f5FvDsvJA2x>7<w?<IluX5BmdKm
zgsHQ!lcj@;rM(^KZ@Y#@_O331)YN}F`uFwE`!w~i{7+AI&i{HW*aNcuEn#J6VPpMw
z+b~gqzqx#hmL8@yni7__urY)6A;ix8Uf>_~|9>U_>G8iLHU1;X$-(pAlK)lme@cFF
zHgyuWw}o}-BJ`iv^)KQ7F8r6E0PEi;|F4nw=P>^x7dFm9XacPNerG~x80gFtu-8at
zDWRYWi(!-OAD24pmmU`W#<1}22P505H!L=lkq}k&03M~kT-d5>uH8JHhtt%TYW1eF
z<$?L&;j~JL(dsZ0MMRO))vWm!ujigApMG&Zqo&8$mS%Cf4b7tkf6Af(W6ZzBb&b=h
z_$Y$WDS;6z5-)VR_tY|XQPO(Do9R2c^Lr<w*6CEwT2Oz^FaBzXZ|`XAPUm(5^7L3e
zRWI`(<^D7U{Z)|BVyNyt*4n;n-Mo{uWH<jI=Bw`^qeK6(dO;|qpGDKoQ603aS9S_f
zfATA|>nr+H_1L0Y4aJM1P3xczw_)+8H-aSuRQ<&4F|llw?U(kx=(s^v_`6#8_ibNA
zx07Prss)r!j!04)GuVquK4!jXCc@S4aB)Q*X`$~llyR5HM)Q7Hn$af)FMmnt-hqz`
zojW2B%y54=p6aLcbKv7|c5U)F<8UxAMJePV;}y3J?#>be0MRaf9N(CsOKBiYze8iu
zX^=)~mP`I&Yf><6%;^zWDH-r%w-Kf5Gga2<&%Q^a%bM;lIJpQ8?-k;3m`@Vwe<qhX
zd~nKTxEhXdwAI?v(X&n30uGqU#Ux>fQ0O)#I1zyCd7F*sqyg{^;nA{q+bwE+E{&~I
z6gjT+<DRdac2#psQ=*Vad|jO))9liW&6An47P`isXQwin6^E#*QopSecI|KW9I>0i
zFW{98BXFyMfjmeinxi___C(NY7x*~u2<Jj8!1;JYdcGj=4xA3Mzrd#{0*@#Zs^TO@
zkECOjtPgM3l~9Ou<Ab<fz7B#mw>|reyYgFY+<9AH(+eQ}d<QA)VM9>-8v8i&8{2vD
z&WlWb8dsHgi`6D6+M!n)LxbCEM_u(!1j6nh8zD=%TcRgO-zfQ!znl^*P%ehNj|{@5
zpG8fDi}S$7W34=+pwWUSaQ7*ePiR&G{^({AG5nmBz77Vbn@9EsKtE+5B-24{$kl+g
zQTwRTqHwP+?&H^OH(v|GtMPoVMbg-y=NT$!mUD+baTu{mecWY!>93j|vHd^^R;6vj
zdID_EWrxw>P%Ff#=gVRZ_;ueu1cN^=Y$Jpw(B)p@c1)^OqVc`P5D#UUhN`1cst!SF
z96A_g<lXHE9c^Z3Yh4O@K64^J*05Y!M0{m84W#iJ6lez@u^Y1L_t5}~F}N(^4ND%0
zGuMznW91WOk-&kGJU+|ry%oPuU+Eyo{CynKPDfdNyHEPOt);C49DJ&;X+o;K5lAxq
zGi|2m$mc0%^`j4|QFF8SCpra})~)B#{k)w#?e%HqI$7f>x}OFKhP`^UtxrrNbno-V
z0NYh>rDTynu`DYxysM5g6c>$Zlo#Qckt-C@IcbpysDtkj*2BIT*;^rFDH#zyvW4jx
z>YgiM`5&-B{L4P_?F{nV31xb3;$d=GT)`)Kl4+s1rBSt)zWr>@$cZ163-v&6ReL`A
zu5T^*xh?VZc-9;~?$DL@6Cc1+bwPgA^3*%7Fyz?FZf|)Si*arKIyvTPi;!CS(nlr=
zAV`4nWnh9S{{^T@A|-fb2roNHcl5^tM_44AeCvH6Rnh|gI01c9dGkgS2;=LWgU*~R
ziAuLTNWx}EB$mcmGa9{>Lz%_js!kUfR6k>xFay}m=SXkCr6lklry%Gz7P`x7IQ627
zqUybN$@)1X+wrN;VT(U`_>;#t{V^__R^)yFymW4q<u(Zy8}^T3%Xj?TVUdH|gucPH
z>=r1r6maEqGFAj&@Xq4mJP{7A09$dDKxLm`t+&$A5q@0Mx0IC};J`{PuLdW;(_v74
zGJtXt5a%=8ui)U(#~P#m6#9ng8(4H7$mN@p#_<w|Txk+wn3IG`b!zelol0`Y&}q!N
z&m(*_6SNWZw%t=_`Bjalva54DK_-qDMZ13*mglE30Z2wY)k{?JAsEB!eF<3oSpm%G
zw9)q)u-zwS%T5YjR?ahgBXZ6wod&ASwzWncK!B(*bAL0P@8-%v;}3k50{{-&3?#EN
zH2Tb6o=42@&Wn7VpJ6435`d_C;`DhdvEKKn`VqMhbz*l#;odbrBxrwS(GUDh<eNd@
zYX)g4AQN}@BLxezOQtd-fw&<DxtOOFd!TYCtVc3T7fcbLw5_E#W(@i1m6M0WPD<+t
zl{tQJ$xZS)kq^H$w<*)qLgr;G8z%iEyYOb#U3mS1hRttU`s~mmvrC$h4BqW-lCr1~
z-u1BLx6$)<6VaA~)~C%ZL6|2w*EP%T<ltrXba+?zIAp>ji4oVpVb)@L(q#}>t^6In
zL8WsLcRL>XEcjDosPsqsZZwWS>{HxpxwyqteHL5_M?|?_v)+K&@w|ke3d4Ag6%N*u
zH*_X*^R!WHRaA3@{24cYcuO!vDAdYZXJK0IH)o<!z<u)A$A`GS`bznTtbkg#tH$&~
z!Vc8HhSfgFPzn$LI|oPgl@Ab0#aw3}kw8CCp8!7LZm_a`?-w@ig9^>=)s(&DBze`|
zq9Md-eu3$P(ijfsO%0lX_77%V>z$`bB=u3v$XZ^L=0(7E*$^2OOuzlKpxd8J2Vq8G
zae+Ii%t_a*;2cUnh=N&LG3j^r;+!cxn4VI`J|lZ}!TZURoZ<{><M(Iv4tO%9?<RZT
z*RXwyN@*E2#;Jm%^5RlMFyv6y<u5TwBWz_dlISU20c_8HvaNtk6UAIZjva-`b(N!M
z@f5WT040F9KL-if?g{|p!$%4HvIlr?+La^(mjjpIW?CPxaGxo?-uL=9mU9g_w%GG^
zuFqU;Z1)v?jE~J13O!J8njf5na5<lQlt?94snQ1bHGCW?dTp-_z)ALd$jCj>?oXEG
z`TNU;z{m>Y<DxW{^qwvavOTdLZDw9T@RSvzMNjCmLiLp+sVH*5l@r-@yp)#88y2GR
zL-xbeqx*~w8VlIO?4=<yJ$>DLJ7Q#18p8lBk5ZpoIeb_EnCQnIreKQbso%->X~On{
z<T2WZE}c+<)u5=5<1tKur6Z(_>96cyFa$axb-tg9y=#WpjYo)!Iyiiq!O8E%8F{E4
zl@|F{{We(B>k{1}2`F-Z&#YNwVC<~+_&Nv#37>^HTB5g_RISWni`W%Uy)6a~$eHqa
z=6D76a7VZo@F;c+bYSZ={Br#%w&4*Ehw_<-@~B~Tx2qsagtsMvWwSZ@tD}gQP$%NG
zMH(mN?kl$8)3Zv9)bm`35CYMjr+=7|LT1=+jf=Lv5Id}{s4>^P4Bm$;tK$obyPJC8
zz|$44G(W&ou~B|jgHGCi*!-F*daCbTLWS`UJU0m$>AadY5uEV}$KuZNKxsQTY?n!K
za~QUjci<YmLgA?C{*I}*MqVDvO1T?M`5Gj}-z>?bE^@#XqQ%*%*m{}9nPH>|VOPr0
zqdQ%JZFeV&WF;hEfd&&gC>Xhy@_J3C8{1Mb7zwoW)Hs5Q^-2Z=<>u`OzCn}4;LW=6
z@FH31cdo{%eH_60fh%?TmAc{LSNijE#|laJ?nnq<NhrtgM1xq&Tv-)odMJ*Ap{%|r
z2Zq3aA6r+j<AaLLkl;WDOnYT)k`=uM3)C1DSjOV#wkeUZR!;c9Z_zqiqA~;CDVPVK
zYw>+949$W{*AOzFbt`oxz4Zw%g0#2FVH15+9xKtI><_F`t3DdRIz%_4j@RRW_fSR&
z3(V4!v}WPIGm<Aax;)%k4jOZ*SXn^=xzFtyi~zPfY58T4+j=sd<X_wD!_^8%{gmKh
z1RrtvUsU4H9R(L8<jDtNC3>tWJDfFS1b8~+=>jlRm@tWOOQXfZM_n?;P<D<u32`0r
z9W}p}i|oW4bJT}sIyt2`NR^1Qvlm@7N#34JcG_#h)|*;^oEm&w>X6I1<cfFPeN#0O
z3u7#9h<56n7+JY4b}{{4SN}Gma_~nncs)TE1V~uHD+KUG;%<hUC{v9_4m_T5?;w78
zYNO9{0*9q+;XAXEkvRqXojufVmD%AtcUGz&yw(@j>@$L=Hd`hD+n%rZM1%pJB9-#<
zE?CluUEJ;>F-uzO;bMrWXv&3gW1ER;PcBWtOxaW-VxJm@oj+kk)=GLa*#g<ND}@DK
zQ5VR^eTX>;;aH?5d_4HHBknEHEv+7vDBNoBHJ|KKTCjExw#AMWj|1<41Mm^9UHSJi
zDNp)p+0oHrByCZ|s6g9mdTNWw5H2jP_v^`J8f-}<z=$Z`P@;1nAI8uh5~|!;+M@T@
zu3~oniTX`P)=VulbKz_|3>PA8YWHvWk3FcTbxwuFLS3^NDE8p&hb(JP`2daOe8>k#
zAZ(`j@RYH&pl#?#1g`3*iY$@J!APv7*1LvO5jqe-`?z@5t&kN&2+~8+Kh-t!tl1{<
zl^iIUqSg-12zM$qEPp>ihmkkN!>RIpz*}PW<^6njQ(s4fwckENr-kf4w$Ny<zxvB{
z(<~A)KT5nbpQZFZMocZnsW^+HJvfdUlm_}z`wc!DNSv(wh(LP@#9cU=G%u=hxxc7U
zGkUc|_K6jB*J60gsYfumX7oc+X|pS&0eRJMf?f*um;_7Ygkdzh2sj|l=$3MQu?J#o
z69JCac9u%A!1p6mExd(L<X<b;3f>m=MeD|8`Wai{GEq2DsZy4g3<|m`$(P1DI<=<Z
zo1G7~?L^jUd$I9@>G{i0`Sj=Ee9kAd4C<|0o45Z!m;RStB%zZQK=!;l;=Qh(H?NDv
zWCDhgyz=q{#4k02L0RA8iCx!AcH~grisY#$f>H9ha&-|SkG3IvVi-;fx$-xQ;!0ju
z7s&|aHNoc5%-&a%ma78rEzYe+Nic=+Uj`+Mp3&0E7;unThpP%RH9ANtRqszAvx!A-
zEF9cutXVdfN+`i4aFq=cexIuI_a8V1ZsoFl^e|KvZYN^PUkFFT3PT@1D=eMBiAWU3
z%|cZLnXBHWG+Qq-nufwA9Cq=X-XU<Hb%$iAP~@p9;@(<+>DN%emJ4;>;@~$xmZTR#
zX?$EW&$mycK$?3(F`@m)(GV^Cjo>V+UN!1N#vZMbpZb&>!p>)!gDKop7KPUzs3JN>
z&e~phP2`tTQ%*E5uKWN_tt?V9$e`GFOM|>n1Wz}&Vqe1()1?DMuB-QE-z~$o97ma3
z4U)&My{q$p7J1)p8uklxl{?5#X5uy~Nd!9QYc`5JSppSvQv7sPRSbmub5X1#ZUk0l
zPP)Y4BhrlENQWIzJ++y$p<3Kso<vC}0LPlf%<YGV|E=i3EjvdMzQ!bAC9d}}6;+*v
zs`b7AkjbIqpK+`#;>zxsW$PMw+%QK@(SAG{rZ*xyoxybcB{Janl0{_&?f|wx7u}Y<
zeO?k|N1*$qulVQpYFRO!=fM(O#OnOR|HrP93{HDus<ZX$4{c8)L>cOHQ^d6rQM3ZQ
zZdsNHTJ}lTxc#UZT%OtYc^7Q$gR1BO%2LLaJ9$2ea}-wH?tiS93s)2wfeb_-F11Y%
z(#bprmisUWj_E0+KE1}D3?sh@{WeFyu~Tjx;^PimU%IJ5A7CaN<cNkGAnluqy&5E8
z4TekmWbHHn;9c7$d#D`QIcIINL*LP=rl(ba!>FT0GBfMv%ytUK92TLmzZ8{*@EAYv
z)W}*~dD4s}7$fvC*T2_sicT$<x$=nkd2~-H8$Gc!3_~6l5jy=ofOEbGcd;_hz!sy}
zJ3!o1$kh$%)B9v6<S%5!^wHLUl7Q-7JQpUu!FbR0*9Vu3FK~gM?&1lt0D0*r%TekB
zi%m%<iOH6`;LO>t6mpep`BCh0TZi)e!l<F>t=qqo1vJ%3q9$m%lk13WE#c#|i)tp!
z08Yl)^2?uvBhx7-vp{v>@Spb&lV*|V*s?Siw$l|n+&NzPB7MlUU2yBws~+^Q72Ftg
z{nS3o80(UTA9dmV+p{m4v-H>hV7IWZb+QV!tym(nRyungu;)SdpgwWeY2_32InK5`
zGkrCGJi#;6C><B~SsV~U%y6CWw!W{rn@Pdwr2+Ao?#SdD-pRE7Chy51-!`_F(I63o
znX;<h>p_9cvCSDhe7L+lK+ig|DT4W1-a28D0Ef%wNgFM`?B@Rh-M$4b@p9L84~31l
zJ`yVZoD1cU2uD6&#48e#_;cHRLx`&0!VPIeA!7>SXmhF6Kg6NTV#C{l`H!^Q{0rkq
zw8K<bMi_hOjjj4<QEXfNUJfeJqO1272^17fh3=-zmRtc&+UZ=Hm?C!XrUpsRM9+|q
z5yJa@SP-Rb@X<Zqo@IY|w-MhFsH#obyDbx|Jp2J~UD<5ig4aOO!33+fl$}YXfq`WU
z8sWN>taBmMl@fPm8P5JM<koQtKUh**iH6HTtCgVvo!h%qJdOuX8>L$9833HjEwR*L
zB#K_O%H?|KdjO4}rTSg#JSJA4G@N7y=u)}tUTO44CP%te_6LgGRiBO3K?5SOsG~Db
zM^7G7;T3*vv7xO$JddtUn*z%1B;}{tO?>JVN+W1uRK;k&hP9Z|b3|y{P-5gw$BYcC
z?$wGQ#s69g2m_qRH1ctcmWWl$(@NBTF<T@BNBADaTmT}ar0qxS39nJOcg~7t_gqpT
zmknSNy@L?MSwg3-;!(>S>#oYautzkDK8nfocP^Oiy7IrR;8s-p$EqLZ;I1$KH)+#$
za+CsFc0#?^H<-42+yF#GFupxl52r(v`V37K^(PqIk3hj=f7TUS`Ptkb?=7wmE-Cvs
zah@>l;t(?=Ynx7i)B0x1PbUa_i#juL2d$F+pph%qGGvBsDA$6d@04gth+<DG^nSC>
zm<Q09!`2@L)26=`p?CWTjkg4(dHVoOZeHMo{iSmAZv7?HQSp+i1oY<i&v~0Y9R7X!
z-45OcuKIYQRV%W=*$bd#GDTs0Y3<#)O7<*agcX7_zH{_AqsXzGj{yvaRv0`CBZF?f
znD49p8?05!M_{^C)QucF^D8X~3pyBWHLv!eg8>2+R6dWn2b_?3#L6=%N64vnmooc)
zudBh)s19!d7oiBb8!oBaQ^6V=Q3qS!>y6(EgS??>%mI7#7H)DX2c3`wEyhCx{?|9I
zDuP-dM4e+~kos?@GzY+WLsNQ+x_jVzwtZ7BDsz#_K!A?598N`SyKTWzL6;;(Xxc-E
zF?7zyjBfy+;!pK32!}9hwujw<-RXp7BcTz286ogkE43eF;)#baupJbzaIS!IxJVW6
zIP%35_f1Q^8%(P()^^$foW#F{3?>T81SwQLU|VW=!ucR1+1h2Q{4S*ciR@X87LNig
zhJu-G5hNWMub7)Lhi6|pLX~vKMG&<6ti8B*EO8cB<k&4cuMDCDtm@ujv*L)!3j=F1
z)zkSUL8ZE_oA!tQi#nP33*DHO=bxRb;ZrT62)m?^-@8L;*s#n#w#-Dpi-c(cKZyfX
z4@Hay<}1)z$wDR0rI&1+YcI8%yNKL;*LGr!X)X>`-+A{;6APwnI@Yz=X{vi+ikLB%
zdA|pEuFwjE1H8hcVe5Nl543gCII~B(mWcFg`j=|m#u>*-LCYucZ$50Cf}hdEvuJ6q
zfMMRuNBe@YYsmQGuQKRbeT7D<fW&wu*p=tBTywd%u8wzpZ`7rKN6BhS)8_Qf9{v;W
z^3#gwHMv-N-9rnwRZWwJ85I@cjz!Nz(gxN~W&84H!_gc);?dad9^%g0(ih&Mq0-)5
zY=4{^Fy?xeVl{*&SdS1Ve(4Y)@+2KrF28artx)xwpPr(l=A3OY$5>{y-31Nb$p7HJ
z(s9R@D79UEbN$Q(Xlxfkwp0MdL0EJ%^zPhGGxS{dgfskJu>IY=PM_>kGwu)6v5KaC
zkscyIWABEAa#5)X<}0;O`G3;nDr>Q#h?>NWJN}L_MEHXEZTTHpUV;BsVHfWJ8?K31
zz-TI%cMO@<Xzuo8+ypb%&m@>UX{`2+W;aGlw!9WfXqZqi(<C(4K?-l}OrG~p1|RoO
z<eYV4hP;iQ`4SH;So>3+e|kT9YWv;uG18xX<>I9NGv!N<xEvSK10&l@>wJY>f$-9m
zm`uV)o&Xwd0Rlk0Ahn8daH~6o0&5Opgb~iqVN*DL@TQi@gE%qtau10FVaQCJd{&%f
z*CNj1C~zTfUmzHa&Ut_S{HmWb4PNq=!_GfKj#u&lMs&0tkQFvB0Pp(do;EMH{P)Uc
ziXJB@UshdUR6e`lSzf>Tm3Z>24pike`WVQ(MO(mGd}B>8A>eyKYX>4T`P*snaTgk`
z$fVm1dP7<KHi=R|2|K1*ZaxWPyw~lRfmx%sciE@nizwiiU~!sOlii0HM<PFLHImfb
zr*1XtoOB=DOg@wSIU-E~*K+iU7}%ncGK|5^<Nzs^(`7!MyPW#A^9uf%xOwpZ(?9)(
zz~>gv`<mY}jiB)tK3ief2nHc)U`=FB`U1e{l>?YiAt_7JTLB*j>0_{R&lQH7rJ^I;
z1WivP#de>*N46#Nw=rk-ub`ITavu`Wxkkaqd)G~hAF=EkntNL6$CZR7r4WWaPnZ$?
z7qR&tfK`7zuN4RjwLbYjA6)Je3DHgL%OW=2fUaE4F?Gx=QhzLEs1K7{wG9RYe;;Z4
zQ^_;h7*@HtHU8mEpUP+EL_fir-AV(-AD~>GSNm04r!8to_i%xAaL#XVeqGhx-SZM{
zcYHor4|UvUx3kV3Mprbs<IujpfSH~b)-?;8(|~aNt-Rlm{OaHJOjehdQ~IeVFDvy5
zl(&Bbr#Q!aY_o+;JIUe-zuKRGbwD|+N^zhwe3Q7?%=iOTj^!0>oM5cz33fb??-3|G
z87FJO1(m$WBTrD72@oQ19SZ&^Uut`TO-^cyi|*%|H`0aFk;Yo8oBieaQdy^jUGSb=
z;D78=Z!7TQaHg-5*V58U_htUv)8yq(qQ`NoQVP#YPQR4LsWBg;Fa8l?Pc$RXti|Jf
zl3yLVis(4@KRKf~oy4L31)c8%sgp$E|Gd%I{S%0pm6N>BDJEU29oRpI+W4gOT$A7%
z-J3u+tK{rK2Jr;xGj4(SpFIDCIyEeYx*I!EowSadVPLIzG@wZZVY|F#XU+4w-m|#B
zy;rxjpJCJ0EMsKRhVb*t)A&ous`J`Xe!0Na&e!K@go_&x@SVMA9s+u<EV<Ip5qm;%
z0g|FSszAWOS)TctOL{{e;p!hf+U%74iZ>n7QwLJFMt8^0k9r8@c(k))A1+Rmmtr3Y
zscDZ~olLNoG*m95k`5<VE|uKJ{>5D|z~l8c9nZFNt@zHdeinY5R4<!7iS)mkzZ`XM
zcfH@T#x6Nf_}JhPeoRV1GZ;OrH1J4cI>RpbtO<U%eQ}SPcA3EC1gh!hXzW!`6r+rb
zA7N<~)5?@B5KbCS#x0)TRcxf`B#Rb`BFXw-nQqOb?S9BI6xqhLQ&_bE^EdtFxSe5>
zwX^L7ku`nQ<%ZRDO!iagvoZDyr8muf=@ik+!Fx*76k+5abWDsf$38H4OZ!i7>rR>d
zbM9(g{7M#m>hY44@3-Aq-0zS|!n?!|GTW_AR=zm9(3t#+AKmZX4}}KL+Mt;s<5(t~
zEqAf})<8AAJJLF3X?(1r1P^QJ+*klOWIYyy8X6C0>@!YkGMgGblqhj>pBeS<&Mz|_
zUQ$~x{V2JOi|p=k<>NfC&d(Q|kIXB_Y>FX}vMg~+%nVV?PzW@YtnNga7Ps4nO>47b
zJ70F4IxOWpR2>0iVNJ6z$m;5eUL})$^5w4413EKijMp-G4GMNyO;kVMC0S2DG_5~E
z20=dXYH<J>nO2V1Zt9;3?8nP%6@2eg{KGEpSbf~&d{u@BSu2lONLK?{mb*;fELAKF
zS4equs#VbYDT&sL9+@Cgp|;|NvUkmIX$xT+gKGUbxNQ;{y*LvQ&bA22B$Y3%6Kn51
zKj(u9F-0VdF;>CrWf_D`yrT})CsvT>=Um}-7<K$lPJT}IEB>~^<NRTMv){S7n-Jb*
z0Cu~x*GuTCp+4C0LKsiAz2xWfqPmSyTMeQE9Cnr*AZkhXHB`wt=5Xdk4x!=J9#QKr
ze5OYFNpjCNmy!fV4H_6BgPUNAP2~69HD?iG)Vz3$Pzr~|kAT;}yW46R<yUH`Yc>39
zp$vwe)lFmKutiQ-U;BlSp2}?s4%J@Yu|EDtfBW+LlEHiY(aerdbQ9vXA%%JIXqw8E
zm0!w4cAzm^R~uBVidsfqLX1v0f^7Wg5*=fb9h@15^lc9<6~Q<fFUGFqdlx3yJv$bE
zAkh(qs-^uRjEgH(ZKEAC_lGB+^T~7YQp#L&p8em{bh@5EQhZ^~7~dIQMQ%W2slja`
zX{Otj%Bg2}pU3*mY38c$nt%Eqp`DR=gaPf*vUzph^QQ$Q?)VNxHsts(T`mmKN&^*7
z#dWi`FrR6gU2H>C2=V32AaixMHl{2RaVqoU5vyrMe5ou|h1o)P?1fkK4VmEEEd#mZ
ze%fNo$aL!v=FN+3RO6lghDF1+c1)3z@-fjx;K1=t(-p6J{#^TR=E57%axGV{&G7yL
z@6`)Z{5FIwGi!ux*bF^3*}G*cqJaT%B)Jlx70;VIq^u3pajL*f4aai<e8<nPbDh8e
z*sE{^6evosCbmz;ut;viKl-5zCAU$uV;`Wri+Y7#=lezn_@RWf^_;QjC|jI@i|LCa
zv^#C47@2mC_+$@eQtl;LG<O2FueAp8gad*yd+tt7y~-qXU(T$t<xgv*0-q<_)Q-(8
z0l94>$fu$|KZrQ?*K6B4alZpOhau8Oq1ND&;Z$7Mobj;f4kiFDXwpl&hdK+$41-iL
zRfi8{0~a^cX5oI+qZJfE1QcS<_wA;1y@WlDTo;s6IGAK#jDOY581Yhob!N9M1_9fS
zdHl^jTu(vjt)5;xvF(0W-?9oayqvsFAJ({hw*zk63PQK4d=FdC5j=Y-E`Xp1%)?Xs
zdoy`ng)enyq_>6m9eAPVGSW2v^28qCsU9d)@#HN+M@JHavP$Xr3K^%@<9I(A>4UYs
zCG;xjZx0a|ydk^o-mx+yWlbb-I6@Xty_F{MbG*!MFtW-0%Pz_tU>o-%Ba3?GgO5MW
zeoQed{Uq6@dAt9EZad%8-JWoImwop)KSF-t+)g=zxurD^+XZ{WQ53$YAiJy85pG|j
z=|K~Lpp+l^du8+1TqNbCbj$byRX=Wq-tg`rY(1_zWjF?iS-UaNs<0j6+Lty$7~G%`
zA^5o8DP+tr3ckr@<g7(1FvD{f3Js$4n{#;y_4B@8oNHTrY)eP_f8c){S~DfeS?t63
z*ok!o^4;^XTIm7-61ufLX9b;~ok*pAUV^dW=$$c~+x0WSP#aS-qqz6v_SthonXTv6
zBVmJ(^VXGnm;>kEY*^8h`*ZZ^nN*<P`d3!%8UKw+;mlRTScIp+0-?I1_HSRk*MfSw
zZ0DT$_wwB|?)v&5>zl3br@}!K7qskfmx>@&DybmKXFyR@PR4yj04)^X%|jrJGHX1>
z@pUK8?;~;xG?TX$O{8V$U5d%r{jRNv>>rL0#Cp`QF7vwtU8-Iad70+w)J@yKHs${~
zVFvbhSR1E=j_afX?H&$`{jhy5;ip<pA4Z_R6@)5_+Ht@7C_akvi*B-K$_Ah>^~_(%
z6N{sT)ZGT7PcQGseTsZ=W@}_Nv#62v9%M554Xmy}_rCw4k;g0do$_q@GZH(|p|7@C
zB)T^72Gt+0_+YYVAd1GWy|KQ%hNr<>>LYrHzlKc1K7O3mQI`o7F<2*Y+XJ?!&T5zT
z!leRFV7KLGGWSMQ|9<nb?B?<QGL-URppA_?D(0_mxc)9^(=U*5jegair^^(bIG6%F
z$vwnyf$a&<`e8U<XexGIIIs?58HT#IGv@X~A^T6L@r{%A6h!Wbwi&8B6L-Pm7q>5D
z4t(1TB*3)T%I9FCGFK9Oy#0v^xJqrI$;N|am~*9(cF~Rv(AcWhud!MG?s@v~WoJ|>
zkm7k;>iBSal|%3u5=(*qoVxo)B!d^^7&t7)7>CMYt7J$0yMjotE6kubc$I={y$UH$
zkCnAF4?INuj#H(x4}OY4L}K9UNB(0&tcO3@P0eq~Mur~K5(ujUUt>{B3NpIf;iY+%
z2`WUyNir{&$LKnom;%n1@oc$aCua1DjhUBV3b4W+wW-4##k!<?@pRws^uhl(1!~ir
z-weFo<cbHTzPsB9O!;IQ@lV_QgQ#eju{~ZH#4|9kzGk!B#`)`5?tsr8-{dXa-{Mm#
z@JGNV9WMM`64%Lku{7X>`e}b7!^^7yr`zIuqGb*~2EnxUupi2MllS(NhiXu3yQNQq
z5?iEfZigNU*j6&-AA%k@za$CbU6vQ<#v=G$JHO0PqTVmR$>e+Y%snYXH_%%!Fa5e=
z>$)tJ?A`F0Iw?8UM9SJ^K|PBXsahPa&()M&A7S$KuKghjWh9fur`lEc3O6YMuJh+w
zgUi|6Q-y)DN?Bq<6Y;W2q>d*mtjum09x}XIv=#(3)(hyn(^8;%^~Scjd5tJMm!$W#
z8RNeEFwe{oy7WHHIC<!>m(y<zpg=8(z0;||w)A;8$ekAnT>^GCbONg=cq-3y?TvH9
zv2no2T#8@PWsi*bUUC}l{{#zFh^b&i?a}p92nbwJ6?U^2IqL~Onb9c3P!Sq_yK_oe
z+uqu2p!wrKX||G7;5sF|fx_P-4uJ6-32lf)P(ql&_faN>2*!=+Hy@t$yb-ncSz(nI
zzWoU)54nr%r}*(aRsM2**#ohQvS&M$k3*7d9Yz8I5Hj3nxgFq>;Ag-_*H{Y8&R#Ij
zwSq>WbOxi-BtJ?pVj)#pr17}XHW?dS);I@b<9(N<X-(mrXH>(>AC=Ggfb(+&ghFsI
zJ>mE)H$*hnC$ttg(0x!l=LK-G_iWo3g0yba9evC47t+=Aq}gA4+4J}AengOeroj~I
zJrT~e{D}4k2&Rs%<F5A_9_Ll$fw_;e7=Vgg*Kj#Kzw8%m4eFkeg#sh{s=CRTFUyd&
zlUS!L3#=(a50%ntI!ldlpTZrm^hQV$6y5q!a%+p#A8lbct&Y#O>NR*-HQ&B)A`*rW
z^E16K+8O9b@|(W_8lS&5YS3}lwJ#ran7z(HtmDx_t^rGbgv&<j4%^eai2Qh#{3@#k
zSELq;CL{{8c>K4cG>v%^f@)ckpSAjJSJ`RvqhplGGet<0hA)+pfE8qp`S4RYaG<2u
zHP+5er0x3jB>_6)-c~t-Dok3c|F9Um_OsKuZL1D?;(vQF72EPSW6HT_WJe=%K+6R?
z*<+%gY`wHPn^wR=ZQgcvtcRieYpQi2r2n@|=J`9!kLR7kmuw6e0kaqUm&-wrALPLw
zCR4r<7yUt%)nfHcF@11HLY)oO=<M4qxxIRO?t;q6^qP5##k6ML3w9Di>ldaQH$O-T
z&PQ;e_|#|WvTLv1<NnfInD?o_{`|(so_>sbcsq~PulF)!?m2P>GAn&QA$&i68MAg*
z3uW*|*q5}pLI}4fpvy9HMkYb|Z0C|*SmBnD8>sgzM6>>G02SwmAyl20mg_t@`ei~^
z<F1Q>+1P<)U;5uf%s|;=#jk>~s9v9liT=N?^T+kCLcivG=?R@I1WvP;U}vgs=Jr6x
z3;<<B&(&krD(sJXT&<@;FXBJ#z5G{0Ib#K%@1W$@>$h~z+t_VT>m`WdUk5vKfiPHp
zUCiFrPfK<lmo|!$&4E%hY?T6AoIeCtwc-^hOXO1kG9OfTDk+FWwK3y0ypUDkq5$RP
z#qGJ_D3Y=;2S@(wEYlW+=ew&Vt9lgDA(Gg;ZOu9D{>jr*7+v{~djg(kb@`-6k3IEK
z3anmyTl;bHu<qZUO>wG3vfEBXdX5Bw7qxTl67z!_Bm?-ASM<aMAxpO0p;i-1L?lrz
z_yPgCFK_%k@127%;5<mY(+pkQ2vm@?YcAGl_&Klsz}fv}Uyz?X4T2H3t_$W9jcdwb
zX6RouYws?yDJ=46RJ!LkMm}}(JhFEOnG-tSH!qN)cpAQ(--=zv5&jW~+<mqc((D&~
z6#WQpcy{jk4<q9k&%~UKc)M*G8-|j_1M|yUPkmEk*3wu?%L!(dyT$v$>hGOO!4i>6
z@ywa5X;;?Tg>jv-gmW1A%X%~SFjRWw>spX0cXNxsb7UjjG-PSoQ10oTM@p=wD92>(
z>IHV*`Q^p$(~uPa!0!0>!0B;1YD3;f&%MZ#HaXTB(9e~Tw-#{JaIcAi>BB4}qDjRh
zXkX*IXBJLGIi^_{;mHl>gr^KkkYIYM;&J0;O7yM(cY&|S5g}115#Q(wLHw=bBP}mC
z`Y&F^ZPm-pc5B`b95;;33SU~aTfZo`m!0~o@tVix#0VUZx)3qM3Y|^Y*e)f}rXClx
zJH+hOd0jQprfyaAsFi4Zi{U-Lb=fQzqAk^TuQz-Py=Jb@M`wNZxL?d8%1!4#CAQ+s
z?8?Df%D@sf@opLub<g#-U;W0l;%vTHvlj8bI>PvLzL5{+28wlgsC$}Z*2a>aTWjI<
zJ=>(r!}foya@k9leGrB|aoc`cYu+TaG&9rHsx<n}x<p|an|NK(-smB0NioYwzWa3%
z!&L1qnWdDC*C#9V7){cly@c}z;yX7AZf^;lDdRNaRcem6w$ofvket!2I}NhH#-DQJ
z@Uv}yA}4G2USiX*FM7x}%9AZ-e0$5R7wR}X<dv`YfxLqpa%Rrz2-}^=6iM=)mn6`P
z2XeLvn(~+4S}3Rfqhix}k-dV6aP&k_%zRRepqIASK73t44)z*Xbn%kWn*YW53^d+;
zB$rjcj?edLO<jT9n4Jt|Kz7Osew%_(%_)+|K@$my&d$3HPmM%Nu{mj-{toLlxlh+A
zib{yt1p(*dFbPkb^?-=}(mNqgSe?s<@ttbU!wD%=?S|Qx3Qs%so%2}uXW@LT3#lbW
z^G3C3yq2!Fq#mpQ^kbSl<ZYVb_t_)5m~o+GF6}OTzuHsP%C;HIx-1t_oy_@ewoX4m
z^c|tOEXK$39s@}(=Z@M_gZ*|g-lO<ab+7e>U-CXY-vpMQ@VY(rs<{Ef&wQPi?8@UN
z^1sWlWkJR|7?_)zDLcUUG@nGo!NG}dkUxXOIfBL=<@~Y*L&l+X0F149N-=!n1DB<%
z(3r1vVTkQ~Q$~i-{D&mcN`2U@y&q#NIOpngm!-J8L}GMOps!?c<BHWra`{i@h1h<K
zke;TGK1QoAF_`fP*fk%UJ;d6XYqk5G0`*aFE;66*(xJj-Z9XExR>Nf*>~5cYHp8`#
zPLGqM)cJ*<Y`Lx!(%NUA%VZ#a?iu^dk-v`HEvxm7`cair=ivCqE7EH#*^{q6v!L{v
zjfI;~))Q#1f8Y5)@rfx2sn1}TrG+gcn}##Qu!zi8V~37c>P!Gg^N@1}|Eb3EVs9{^
zK&tmAt0~2Rvng3-o;g5uGN=({RG0q>an;QS`@=bG=m+wC=v7Vw8vRyQkvi4$?EM}#
zT_$KV-{CJhUoBovu02oH*sX+6i*NO%`hOGhf0n}ZT9d6`b;~(4a9-bi$nQ_{&}w=R
zy0JN`w`&!AT3IOPUP_I8?CckKNB*$hpX)4iKL_ngEn_@y3V2D&JiA?*gcd9(Vb$Fb
z5#>Do>1Ujh5^81f-EUcWd3LxFl<pc=qf%k$2>d=cUg*;EIjK2Sgs5s0auwEdyZVmx
zSOZUrjFPbIS{RPOg)9j0MoxS$%Y}LZ@-18H+LobCNPV=dHcU?sDHDzQkP>sYVv4w=
z*}C`a%~+T~%M85JZPTz!QzC$Y=cNAhZRYQf`gf}Ln=j8q_LQ)D<@<9W<G0rg$yM;X
zPOEWUI<9S~Q7_d>m*<5>xeP0{YnfQ++~&m=ptIa_L&#q$R3>F&JyPoJ*?9ccyX{HA
z+X1O3(&hrsZpgW$Ea&KeyUvT*{NnN-C$?YjK0B}DEs+?f5;hAH)m4@74PhdFzk4<C
z4m^V>PzIrn4HySt^biV*p!$X++DJlQO&&<6KaWZh?P`3teg7eeW<O^<lpR%6`mk-W
z>T4VGYa&<O_ma${D<?o+FWdZCrdJ|m3(mG)C!G4J2vTy}){qQ)ZVe%uf_`Bc@3mtJ
zyn;;qmxRlVn-|T+O5?{B%jILgQBJ)Cta%@cv);VhwYI(Xd?|{XT$g2WO7(3EK>W*}
zSbshF<Qu`;m`nbG)f5Wv#}i+?jcTG&nNvY`-==e^X5{$PW0vbz*U!wSMq6*?YAtQ|
zs>?C$(4ia-pFzb(mE)5+n*C1SZN79<L6{<%*W$DhBKIKm`Sx31co{<GB1#{L>CR0v
z*{sQ+rDskjvxwE4IHu)OoBJ9-)4Ql4_e32(r5kWm?flNHGLYtNU;>%E%Zk&nf`1~{
z>S30o&$aN=$NMt{zwrS{*Xt#BXRl7@RfE`qeYuy!klx@I?l#wN>7Um2QZZwXTGlVM
zr^2yU_}*Rq92$EW%7B){mMK8=Yenq+Vt!!C$EoW$YHEF`ep{-;ZoEg^0(q;2%7rmL
zzzJ$>W#qRfly#2Mu)y5xu;EPH+%61$#qGTVs40FkDDRgIzpgQjlD=DX_M`Z+Xs2AL
zQ`>7ctcB{BFq+ZxY<T_nz?56#227@tz$=@C2VxJGB6~pauX9`uwrji!xr}jt>EuZO
zu0;ABM#C3Ol__ENM?V}(m-AdCt@t?|?S>_6^RKq6H(fV<*PRKxMrNtBtqH9EOk}rV
z^+vmTo(E71MMR%RBmAzP5f0xQYbKPO%9oqPN;hSb2K=q+K%xg+mV2*OHlm1^8&|N-
z79S{*@TFdIT&s_ThMtGyCmYgU>C`VPEyaE=y>E@`uN0}0TQ0$AKBZ>0I#ytbF6@Wz
z2~)<DSEO&8`!Av>Ynmsf5(@;+?x4@1!Y;Y8m{QB>es@2(PwQ^Tq~88`<)Lt%PB|av
zQ14wiv@1vYgh1k6$?lYPAd(CxKAxXOh6)ILv(;U!6~9AKC2@8Okc9t<Cni)_Eoa9k
zfebk4>?T~%u?qXHp&V1fE7ZSP9e>pT6ot>olLDYGqZGBwP<+7I&F^BLA^idy(OM4Y
zIM$CMMz68?4sfAovAoXv?LWEKoWz?>?yd7vm`}{+P7P;AKaf!gcb}-W-+MYjn(K7m
z9oJ{H8Y-RI9U|~@R?iB{h)1D*p6I?O=-DyWT$sfgwL+9rveCr=mPTT4ZcKgPi|=H4
z*qK<FdaA+<fMEU_DUWzPPBl#ccmLMv#GR5sO#V(#!M#>9*?N$DEI~!-GjZQ-3YPQE
zuS#9?c}9ghQ7&&NkoV!WoK2-FFdS9jk*YmOUT6b~KW54j!V~Scum7C?*dM(|rhn6w
z`m`139A2*>v{s+`!CuI^`==lsgGgD1rhR7ahIgZ>cme|X{LXhaU7OS8A&#H)HCKz6
zU(<ffPIOVQ!`UG6y^Y|hh^dU@P;k5a&TU#-YNYa3_;N9R&H0j@gp?O}GF)1xM)CR;
zU!CW<gg#fcxOMy_yi@#_lyNf#`18B=yZf563}ktpgvK8m@9#&eH=l-uea_^d46zi?
z^W)2s8a(B(zJ9h|Q_Z3NSiWsiv>^V>-nx-f7!8VmQWTAuq5+(~&B&_a2#10ZLQ#Y&
zH@6plY$d->7y?R(*Sk7+Xh_Uxn5{pTEWd^C4<+{aMoEB>u(x%Q6_X`K>MslDK>zhm
zuMD1N&g^Z(JC%KEB;_wU_YT90#fY@dsx=D-6miw1;{^A47y}T&ml4a%gNY1={127T
zq|*Al`lp*U=Le~Ul>_e9^AN;`;Ncz_Ig79xkp9iJ@8lf><Hckm*zhd}JjjuV6f%Fy
z#PtaX`y3@)W!p|QV3;aN^k1K&M4N~Ahd_%Q;S7YNjSnk^6eGigve>1wHXAbVTI6*4
zW5FNNigY;t`8~>y{N@@z+{*99ADd{O4N0b5ZD&q_|6dzl;TPq*eLDk4NJ}>eN`rK#
zlypc)cMjb>w30)ogh+RHcOyA~fV8xvwD<LU&iUQ*yPx|H%)B%2exAM8+H0+n<g|#p
zN~GbO#|N?5hHFpl(N><rS$`~n+R$QPpSs?`A+izQ_S<_X0UjEoV%Yrp@!LAaAM2e^
zn%A6Bc-ua{<0w!FA4^x*kg?hb8Wz1u$_!BcdIP1?YQ|~q#kGPDrE^@#%ZV(?B_6G=
zTrnnVmU=lqb1U<ZBZ%`!;doAVal=G(&jLSFTb#}i51FZlYb%9=Lb0El)v%^-yXO$*
z8~TdJ>ZS_}pUOka#lTz<C9PvmnOI6wz6*9yZJ<w%JKigH4vJ(8Td~^)Mc-WxBQHz4
zzWercJ(J5Bh|T2Ip*`}s&#YoyVI8OJ-thRM*HK@Hp7Y(-obyC{La`4o0IcQhW&5fX
z@>O#ku|?=2DL{vnY9Edb|5EkhR!V>EqeSU^!bs1-a@PwY>)4saM#z7z$LG|GM=fl}
zM*hps@O;i0yXO5Cw<JL>E7ukK-vfO;eFnEWbCgAHO9iU7_=g+=9i{KarQ2)3ZDw(6
z>9K*+4?)B^)!vH{*QBYvY=^v#^+SG@?d5=sx7~ySilOqZA)X5jAwd9>3k-N?M%U)B
zvM|DKc&TnI4sC^HLITmhUe~@CjKOo>^cR&%ptOhQ&hhEAI$P7gYa$*dgfcxix$wru
z-LfRhlEv&|s011u8S58T4Y7w$B99~kOF-vqC=}U~!jGC}R<$_LekijRL?w=Y^U7u&
z^N;7z%`B5A+*7yx_jk>Gic>o=%9|Oh)p$e8z`Zhk%k`U!1hJO;U{NB0YY{oceh-l*
zSBUNB%8W5bT)M?}IvFV8bLaE(ACv5o$*E_@1vZT}@&R*OXVh!rLDE<+km@+nX&X56
z3U=ddv_Yi-pV=*VZcrr+M~4L8)EXCM<TF!hOO`DyPrEcO{`(M7!bZApR^58zo#}le
zcgSpfu6TUEE<VjG-rad_ZZmA%BGYX?T~nRd8MU_ouzEXW^QKo{csH@@4be2tukvH1
zG3iV)Z!{e&`UvB}ViI(o>io{e)ba9B;x}VY&vbsGvqdT)&m?h5MVWH8><C8iBra3h
zXI&m9e*H47_A8{mUc_kG`6-LhWbw|584cwCWZtHW7@nMqV%|X9wtNImpUESeQWzq?
zJ25aA-3(j{W1c<jvfwT!M1VPZPlaE8n_~IC_~q<1W|tbdSj!Lk`UA3ol}uXw=im@n
zaSxskYeo*|BRu)lr1Y(h5~V=swnpe{hNm@TKj)dFZ0eo#5E^SdB14=JD*5D5`Y3KO
z(DG13(;ln%ArczOEwiC^VGS%O;!JqXWh0bbgqmKz_}zGl5cL`R<s+7tmEh(NcI8@q
zyd~j1Y^|ay|4jO!D?5$5S#5|))m;>5R}yqin`4;ybl!pfTk$JM;Aq7URovdf-c66m
z@jy6zC!qBuQgs><vo0(hbG)2Hb;2brm)pmC2fnK#zEhaM7wdL@#*fu}L>Le~PC><h
zE#rPc>QrvFeMT@Xe2~bPH<8B4XlI4cz{89MPY+BS_@#_Jym81$zpoD79!+MR%@A23
z!<-U4-q|<29|+kr`m-B$tt3R1HY>d2)^CFSuIT9weNJid>FB`iQld(ENW|%>vql!$
zACt!SxOVLp=YOIoE9R|4;z|SZKI6MqWDmR$wTQlT_;EN{Ip+%F7g(Mox|0eD&fhg3
zQLx$8IQqu+m*&0xOY^F33Y7n)c_X?kbwBtXk-9~bZ0U_b+-@UD--c3hq=$UTPf-~*
zRfKD-FVBlwj8f)aS&Ua=`0wNi%23T8fCX$VcBze+pyVlcBiAuMu$$ONHCup&KHK)R
zfq5`lGWhu{|0GcVtm7s@r6^VSF|hFMbxv32Yj(fBgUjKFBe|)7nb`W?C$e=DM>AG#
z>Z-f5Qnx$it$WTfq`i_nJafMf(hcbslSN+>R^T9{X*{wH`QjVQyL$fO%Y|}@L5-y!
z_w5L?@Uvujthnaj!uNf4pao0(q3$%w7fmnyeI-3&I?QS7%SXt0wj3~X_T{mM_ZRHS
zuhfyZX;9YLMeex+Mx_(I?%STC{L_z>4wN;w#QL>6Zz^n7m-$PwFXFqDtscLH?VosN
zb`3fFLQB2-ZA*v<>uR=<zH8WP5@Y9>-yAp97u&7tb(p!~U3gam#gY(zgEOT39<e(w
z3oyp<JmU)vss{0UwUF9aI8pn3LN@}xVj)0GXfBs#k2~dQsDDLFBLit~^z5=x2&^X=
zV&6Mv^B&HtGt3rSMxxeb;DNGoDHyc4bk_IS5zVcNLS&LDVfk8?Smy;8at|&WWk%N?
z_Xhi3e@<Ml@41YgmaX>Q%qGS1AN6>6KlX06J!1Lte;2j%`X=zlChiXZtep?|0oVC4
z`*1GaN#B#_@GNRf+rQ2z2}`nd3^XEdDOObYv1476)Wj6co@h0q)3Umspx`hfArir+
zH^OtZ{uVV;DY2pxN{*D=XB?1-WQXXxndMYkp?PubEJ4p<;}G>Y%`q1YQl*DwM3>Ei
zj8&%+#B=GX$F1Fnrp6U^yr)M2M|rWX6Z$%p%365!qUck_rrmLVIMWUO#Cp!fuG?B$
zrv+6`qTAEqA2HB~5f8aXVqv)sGF6a8=F0t?OPLjp`5>xd10c-%feN3IHO5zvG?Hlw
z2OL$xP_i;sp-VMRKmApaikUC|_FHeL2I31Wb~c_#4(}7ukF>7aGb>Lj3CIhZtRlMf
zhGq0aN)TQY4bA49&$z80xXxxw@rXUfxm}BO4g?(f)c(diqq?X&Qh&tpCGODsMaHcn
zbRunYikUcYaHle3gdxs$^Xht<eSF~PGb%E&@7F?brVV7ZW?qdnw?%<A$k|dWR<>!9
z85EkvBW@#UjO#YNg>B9<ESb6mlgo}^ZLEHaCUSqp>{e}eXz4eNLnzv*Tu|#7)4_mz
z=T7$MVA6i(9j1aktP^G6z$z^s8<PLp?<%fJ@y}gJ-7LGqO}f<E!#4Y7-@B_J5k3l^
zU$}3taI)RzqGs0)i|!HD;(NjwfY%-6o`_68oP6a9^X`<2r0&ix!+4Q5y9o~;vJk|i
zi*CIUH`jVoP8|F()O-)VUX#x!E0I~i^WrT*XMm9^r9HwxEr|HVc7#rP%z)<EA@NxN
z?Rb(=KSffq6CRI`xN^N>A_*&xxH5w51V&E&)Av7jPOV2mL@QNfja`~C5$UIaHzBiI
z%08C5b%T^L<QlPE>twSX*SB}XQ3e`-=aJ}%Bj;u$>^!%b*Yh=^W3yBKp;TD%);p$<
zk@blFcPcPEY8?%%s)Hn*zxu%;zZj`#biL${5}$HIDBZljBh*dbH*1db7xWg2`pd8k
zyq_RmxZqBrJyM&qqWo4gsU-fP!p26SFe7E_?=YqJnbBPV4VM4IE287{CJcQ_iJts-
zQeJh))6n7r_2aLDvE$nNNw;4?T}fEq|8#n|T3vP9LimaUHhKe<=|#@px6O{9stNB-
z*B#Ar=a5%_X74ctxzteN{~q#lx<mYl#P*`6kr!Oxjt(DaWM}<dLXEmkF3T5Sy%L=F
zEZsN+*ZJ1q^ADWLZH*ylTqKkc-gsu}x0GLqc`gnvW~|drtT|;mMI3#j=CCw@$*`Cf
zEj#rQEpVX7;rj15Q1z{!P~jPD>&H!e;A7jR|GiCU2=>j+<#<uo%ZkzyTNPn7uJ7J^
zv6u02Kot*QcP3*A{z#o6DeC-ABd|`zbF^CzY*c^7k$MCYk-4&fY7MAX+Sh)DA}{8r
zAj)}7)kaF>Ln6J9$?lCv^1oSeQ4!cj9iuT+N;isy#w!Op;HYKk)aGH`PGkGyTMl1W
zYcHiwzQw7Z96wTkF~!Egf<`#@i{Wz$gcpuGwUqyZ{0PJme2T<wUrnSgZJIOi+uEW~
zdFl8hbQCpDt=+%lR*T8ey6LxCO9c)XQ}A|Sn^Cf|SNB7}hp<8Mj=#^#Ue;|UdMD$o
zZ<>FDJov7biD%mF%lR@SlC3W27f!gM4pr56!=McikKH@(bOXdU5Z&fs6`q%F#+Ehd
zMwndiGRFxF&F*O)8Oh1`Gir-i-qsd16tbv<`$!^3++jiv98Kx1FES<WNzp#X|I^i^
z4tVGydemn73eNH=&*m<>^C_2vX&L<uPT|fGU9z{g=#xr%O;}G07}U2%vxW)Ef_GE9
zkB5^<Lz0LtHGn4ESKBQh5jnFlSPO*AMbCnOG>^<KiX3<TM0p8CQ%Rwg_x>w$G~p~K
z7Zwffz<1&gvQ8L?$2R2>ecuolw`b;zihy-&`!JY_d%4^YVU$U~JKVzcTKKT@ywomc
zeUy6_;*LGMq-Fj5Q5}J92AMABE|lo&AJ?VZfDa-LOl8_tH4$BbuO83+DXpjE*JxMm
z`#PVfwv?J4UamTAP0bRl|FOIS)NL8R+P9h!<T`h6%VzuH9ya;w1P%#FVNqvcEfXP|
zz(|h3rbik=*(72_kp-0wH$g9JPeK%Z?U_p6M~lFJK&$V+k124;RBxB}YJFLYQyj;B
z|A36~BbxW`L{1ZQZ3Ns#fu=N<a28YfA$@<jI$4!6<Um6Cd?IKvq_Guc8^X*T7El6q
ziJaS;#}{k)rG1@<?#tS(!p1^JO>|06#9MG`&{HL37f?Uu;Tslx{U=c|7~J89tZcIc
zm@APDI#IZh<aAujrK%#`QSvnQMf5;XP8VK;o&6K`n+mC?27%jslHD)0Vr@2gX)m36
z*uAa2zkJQs9jLG%rf>h2Spje;_F;w70DCpis_<mJ`0P60Ah3;CY<WOsCi+k9b9+d6
ziODDfJ`U=en@Ay~mTRo^@o)t4IC1|^7P+7Y;yQHpXj#>ss0|@A!B$&%^|3dC<hAS;
zN|L$J&?Z3Z4#9lMVF^LP+Jk4&zf4KT!OyCE{>0l8SyenB87|M7{@0veqeH(u)!Etd
zXK7IfRyv??<b_?EHN%;Vz~VIeFN(FV*A1+KId@=i!12{;HTIRku|hk)B86NYURrQr
zo`$kq*Z9<4@X?AoBuaF%J|(Se$Bagmwsv<SgVQ3qwM{GUP=<2t6fEFpuuFFgUSeAb
z^!=u^UqX+)Hf~dqB6Dh%W0bjec@lP?@ZBe6^*41*6vg}RR}S)0@UoAfl7@(2rm;f~
zYh~!PimnWD6!F-$Ocv<XWxsq4NrARp8Lj&ro~dT}C~wA$La?a(V20-fx#B1Xk~Dn8
zC;(QnE#Sp6qKaKtab@3zV%|pCHg^a-!a7HUqe7MM#>BoT3hQ^Px)t2Lg|>6qvYDKm
z1{wofF?a)U!9BToRyE`jLCD@|q?;qCyl!N*$haU~61`JKQwP_xE3XN{LOJ+?y02`M
zG4!Ob^8Bp|wMJ#}hM3N%7l|Q=2CTQjL}}h<_AF_Kk7-@a<yLwXk#oT`RZoN(CG{6c
zTo>!((}e@&dls4zy{R>rsM}iaBeIfbsSlRR{5a`7%XPE~;%R{e42q=*gc-oTuO)xx
ziz@JzWvNGY#=*gW+Nusr7z%)n59DeSjeeRwuSNU3yDX{ZGr#)R;>U{m|D_mx#Ie{Y
zI*+b*tk$wXqXjykLC*kV_WSh35x$AaNi%?iMj&jrXnm8(L~ln(hLX$MF|vx%7%aV$
zn&?gjADOTPtbZi!OLI(jTm(WbOMgruIyU9{nR#>{Rm8CM6j#VCDq6`B--<^ePy^&4
zeeP`izsSQ|N;+5d`f24EV1gfEQnH=}xOPeV_MzCz$o2MDBG)&peV87Jm;cbmUVjYt
zmk+hrY>^+97RQeA(+@Lp{N0Vuyzs?ciuaMEK~80Rn5UYoBQE0%AyJ7T`k)baUd$U!
z-j<RqRC*cGXrgmcQx3zQ5lv~R|3wli10><cVt^zReSQ%iYgWov3XtP}(F9PMKHso}
z%zb?}Y?=!3sCWa#e)9O#FY)XJT1>eu$o>Y_O9OFt6DJ&jgn|;2<K+#GMn=gd4Az=O
z9AvfK%v58ejUG-~0_k7it;7hrL{$BKMRsm<AqLlYg8R0;5Ip1Zd~;d8aC-DS!ea^X
z-o|@5T$j!JsHNFiHi2Dl7p7r}Ek<C$)H$A9H0Z&adwlnQNx^T3E)VLfiw+A9le3Pi
z$Mo;A$j?5Je9u~<kcR4u)U7GQ{Ge@s@0kajJ38$~Gf~0PcU{$xtc{F9x54^m!2{A4
z{%x9lnge&GzSNAyBKznk^XXl^Ec?LqFkxIkB(b|F$9-CD5Co?(K0-zs|1a}LwN*Oj
zkq}b}3@(P5B|IY3Rz|gme5>)3UJu7@$0G0A_ip~RxL6W#>VJ+4J0qtvhd;z(=gUKL
zm*Kf+M@NDDv|)pEg?)`E#1FCciB?vzh}~%m=2-lstra1Ch%}`yX9&RpblXk|YZ*!<
zJM|ZSew09Vj5UxQgN(irl}L9kQ*qXo|CWg3fP6pSFAZJBR)XZbhXwf+aC8>UCle@P
ziR`N+9<#fb8V(95jt*T}p695uAD*TIMhVt0n$tYXWGzs|4_5p#;z)agggTp%n~RzK
z;b`~^U-g|}_Gq&<Y3@AAAPh@QjLY#@q6$*lm2Sl?D=HN<+Xy`}6jSY_n+C(_UNNjt
z+GCCYj1Z5^9JV5qoeGNl0Wp><_*~3?S~gHRt6w$*M(DGf2cFi}9_kO>)CTpotjxrm
zpLFlrEWc&DlIN)T2kSe=-TpvUYcqNDm&{iTqG2H?SEk$;j==5i)v7_FxZ^A;f15nN
zAsa<LS2CAv4we^M{YFiOSAX>hE0WaK=_5yJkO;VGvPPALaYEBuBb>p4JZ?Y5p=tyN
zI<8t{O-<rc!?xrN0XA4i=ZZx~z*G5*+=WI!l<29NUVZjEN~zxy7Afm+*OSk=pUJp<
zcJJGxeQUo*>gc(6?>JLMdhi;PvlqyxX;+r2VmbncJMcjgGuixH%HkRIQEV+qvwx8x
z!18!;t8UCacNrh6b+_b(0&Zn<Gv0l&FT~}`v0<IJ9l^&)(QI=-hS=>ldteVcmvI$T
zqHHIjFK`Ssfhc@08!x9(AS$v;`z~{VyA(|`&-6OIZx7r?nk;8h+4VkmKAm1jt#I}}
za0ATT`q!4)fN}b%Iq)zCLx~o3A~kioD+eAZR;TPp>A2e&6XM17(Qv7ilwGC(%l}rE
zZN?_+Bi`vn3w_@$Geq@(jAfO-9_I+&ck}QY;SY_mly^z$A65>ff2cX^OcstIXvNpQ
zLrPfRqJ{DdCCpW~F;7{RqEUpxAr5)NEb@2bZ^qMx^+~rXf6uQx>E3!rp*ORK+J!k!
ze$savDq4l7D-`>uhCF7_divQ^FOqvoIu|}pC!wK#M3a>PFSL+Gc-TMT=7ve4BS!59
zf;0^W%fjguC@GvPRO5z1ybufE;+XOl;vBNJkI5&66PQ!z#|~YSsb~D$M-Vr>fd}sr
z){ZqX&53UWam;yVdStqj*8sL{B*>6lM|6oC$jE0DO%DnFO?X-wh8?+ePYncSj7Fn}
zNFY;yHkC4SdHHrpb7}c=le2Wr*jS?UUyNpPli0o)^H}PHPYVs@wm|XE=4y#i^O4SR
z<~RfD&v3l_6TZrTktF04^w8riNUeYMM<S^na4>$e1F4V5bG80^lL$;MJ|igwZ-r4>
zCaLg$<LO?-Y#vYGvH_Vma#)g3m!;i^9*f;+^&wksGLnZ{oQeYz7plc*=TB?dKqAh|
zE(iVb=K#^s+S2u2^h5D24F?s~T6Vssz#{a^1Fh*cnB<aS7+UoZf$YDp&vU4NJ^Ufn
z+9d=y@Ky6Jjri17NBQB*4@e}LTDe<VSOUKrCKErL6fsMJ4wno~Gcm^%C(>Fp5Wjp|
zq?V|E{{ExEy|l5Q1rDyuulcl5Ohg+$Z9aCe?A@(q+o09Z@kP+0*;#E4hlTpWB$BP2
z7CEeJ8ADW|2xXfEojV4Y6S>P8{Or%%t+WlDKlI9CQrI?LphG#IRbO>*(<`h+2erfV
z4Tfn@KOA!ep-ATSyQ*5?NLU5-uFGEjEZC{RMGR9zP)_PGO06n3(b`*-97ViMa~N~@
zG{FYm%X5JY^I)yiZ`+N>nzcw<Kp#wIE0_~;Cn#aGgqCcZKuvyV*xAef7a`R{A@_aK
zXZ|^^`ISuS;K8Q$fD1<+>5R3zgv_sb&o&YxV^X0`^^py*oP<W{M#F~;m7oGoARmV_
zwZKtj_@fp{4>{!8{b#VM|Ba$HfS;QT%_@NV9dNa!Yv%@xqol$+{oU0sF()fdtGxTL
z5$OAR0Eul#$PXF7<ru2+6DEZm-Xg8PDlGAxArk!V_qNVva|@dtnoKo%&6(iMngu2c
ze0$8hO#z^Uy!_C9q$juR>^Qf9sx5W}ca;Sm4n<dB;Z#0b!23Kq<VtQt*?vFP0Ex-O
z`zoQ7x&+?=A)MiowHg*9u%MKJ2aYIQET!Tkx;7J8@u!AH&1Qt~P|=F1^@Fgv@|l?5
zwDN!%l86<iT}lp-jaoSl6b?V`qfvW4jhM93zkd~z#?(+gX>hj$obG?HD?ra0mRi^o
z=X@n;f2TqCI;3iP=wF;pE@x2p`$KXl|K}hULml+!7ZIYFBMajtc>3qY1B%XdYxBaG
zgo$}EyjT}OG@HdZ?ZdeuxE?)aqGk*9?_|_ZN(lmMfhsXS<c`<G9{!YKvqXmZr&pf^
zJtzdP!2TYCo{h*Pb!7?Qyk;b_sP=K#hVu3H2td6y4HPIc2*u}b5)q6g6;rny3^wno
z2MEO_O|T%IMtOM6UmOOfWHpA3$w1{>V?<|%ymzbW_wMc?kCd<wJ5H;2*uw(stF<n3
zfAxVMY>d(lVN9n~&l!1y&(DeJK9Y5++mcbH?yr^X7*Jg*VJAk?e3X+rcvQG;@POG~
zLN*cv)40aJKBszv9>*JG`T>N2hJe}_W0h{G_)<BwI!OZHS>|!A9DhTz{9|4>0{Wpd
zbymB+yT39&M`h=9jP{b=m`XeX!WjAz4AelX7pe8ZS)iT_7cb4Ceo4x@GqKjtWcDMq
zm&o_QvHxOAn2mNLzwwAd4rZ<TH@zai4Tb{(@#b%mIn#EOK%m;($-;CDz@raUO}$^H
zglVuY*77W%%}`zR>|^KRHLL3FXD=XlNTCt2_jUUt(fIfZa~~4}_(uy0MR@yMc>3LG
zMgo?Ps<fy(#!WG*?dn<X>0m1M5DWFyn9bmOhXKy1_#*Wjt@M|W&3fIvJyKt_Yy*nR
z|F;_3x}svj7(kpjIAqBzRY~G6$S9wK&`v*KEw^P39cI5V=t~`s<rJ0qjfB7Wa)oM7
zL*S9Ij~r#x^ex4C9)>@@+?<ERUcrnvDwxRfa_50yNH*<R^e>C=*Z5>E^@9M1x}{|$
zZ-70_NCZjG*g`6C#2<Ra8|i4AMOXG>8X<SHKGj)5Ap-3R2cP1T)|Y1i@aOQE(A47A
z2YY+nW`+dY*wF_#vXb36b6N2O+gpMMNjd}0dm8n+Ujp!-yd`O35FVpRt<H}s6zA3#
zWBKAH1q*7N2Ms9O#mVU*?I_#ig!Uw@zh1OmWO6G<!kfXwEU+sKLU3@k>+}uj@~1M_
z-r12Ca}1|82)(&-&uC1;x4amBB2}}*`n}<O>P44s*~Tl18=yhjkhmHBFM8mN7%$u1
z$a|j0MZ%#%(QHx+D4Ty_+bq+Xlp320%CDU#<<K$0L0&EZ&!d%LuofGjdzp(YxO5Mh
zpS&cStB8BMXdX>35}Y?(6{f|f1*hS)Cn!R0J!;KKLetx;LBwrL!+P-7T_f6NFoP_&
z2u>;9sx5qW%nB{Y=>Xc&-{m<lCvO($E`%G1n{tq=leqNjSk;A4I~3XHT%Dh3sQZ3W
zM1g~YTm7)*p2MQi+sJ1rmIz8;+1f4BHh`hv4_N$gW5pdUSy*f>l%t0@eKg{lMm9%!
z%e7pva=8}M@iw;X-#nfOb&-Cxg>B`3a5_uEKRA8batb|dV?RZic@*7ASh7)*C8E&O
zV<YSgBr+heN-}%T1A((mH&hNf=7sUQvt$c%H0f5}wpP7*tJ;Sg_9Tp3TJ@VM&+d3`
zZ(rlO*a|ocRz~@sSb?j${r%W-H85ZBb+NuHREItrOEOX4|Cj)cHs+k0>RaHz;gUb3
z^`_AC;!3kD9*u1Iz#CTBVAP4htCpTKCH<@POIjc(p$^@CWk$6a_ro9S>Ow`5{F6$}
zpUchpJ|fhz731XFBGh};)??Eae>F&m3Gbn2?jyAa3@C66=;#B2WKAvt{iX-)+io38
z$1}vF>T$qn$l#BmS)d%4y-@mBfK-r*<ewDHbNW16mr?@P<2;qhoXH!DQh{@>4`S!P
zaspne9Adlj5kHwZXC>P^afR`8qSj3gPC;jFY>X2X9GT($lIw0PrLIJpgafON&k@U4
zy@Hhq`Z6O|gL%&_^n<Go$H+~}LSdW$sK!Dxt4NJ=31Tz#V5!hsX;^MuM65N8F#y)Y
z-v^%QzdqrY*c2Gn<gz=egL5^;IODx?gd=dX$<R*G3pm`{hWOU$WSI3!+Tq|?+HKW?
zW;dA~u1CSB%Yq3<+eEEt!4S!!7F)kvrj7%L@dwd@Pa+gtW}?+0Doxh<BLs^wj(!DH
z2EazTgIB{2cs(8FV>2ee|E87qgLO7cuYLLF0t;_{sILha?H}C@6-Ie8rYQ<D>N^H5
zuW#mgVj3K<<-f4m`d_d)=dbGK%Y@oOX&Z+CQauBd^tqW6LU5a{uC>dNN$rU(`(?7<
zInZUc?Rd&8{*FV%eANWSf9-!ufc>v)&h3Y}FqC&^TMnd3E0R*5V%`#ES1!Q@-EIwq
zsQ@99qc%8il352w!#qAae<lCm>K8j;_3F?WF<21%64pJzyI072VDikn#7Xf=X8wQI
zgEYO|gEf(;E%6@vN<G$)PupG$hN>>(%5u*KR!aT13S*VnUvIuQ#+o}#1xS)g4ND9)
zg3L&kl)it{15-%G*xvD|DFp@mj(>@f`p3jcJ2MPBXUivo(OEI3$PZPi*;X-@sRN}U
zwK8XW3ux9`i&jkb*uy0$c1xt_urjNK6~NC2K0)9E^~mopmYKK0uUnEW`troBf<x34
z_+6{=30mU1txq;?e{K`z<7r(6qou7N$aBUe^!15}zv?P4FMY_)A2KJuNsd#{N{N@<
z9_K(cQ0da;+0Vc+69l>q%Vd2iC2Y15eqK-ik5(n|^Hv{wk^5*VwEy#oYM+o@9>;ik
zEIbHE&k+{lQUwtw41#6e>fK=AV<Ww1dTF1B)oi|!_s4StTYlMFR22JQ^96}N9D}fz
zK=tifF;C~0(TE?+B2>YEXOF{<Jr)}~hMi2B<o~H2Fm$fz_J@dE5(0yINx4FNo7ywZ
z2;=aWW6xzxvh_>Ns(!ORw|Rc>8>+80?m8C5(o$5@#B^|HIu*1vtR|EEK0}xJrJfyU
zmr(qI|0qs|_@hG>Zz2jBF(0e7u!l{`IAuQoLj&7)PS^jXAwenXfnB`c*&b0pK&q}z
zRtbwm==%qWYCq<{O7Q<D1vO<$r)rz$r}C%tLE>K;hQ(_5==P(;v)tL9@Y{F%ZPN;!
z(eFSDoW%KZ;k@?WGQI*R!94kOJ)msbkYsh`@+TB>m@$@s;2k!byLS{c^q^r_heOT>
z>3#V)S$$A!i5sJNnXcbte$+l6IT_cuGiex%kM$3(5o-D=3*?_hcDz?8G}fYBtKKv$
zBrc%31U|R<wQCCSEf+Ja%tI4oe1*)F?JSsnAD(&mvO%Pc=uqXtX+W~k@BfDA04BPg
zOo_|Ug?X=}z8t~J9jX?&BIlRN?Ldl-*T^$o1|K7WV+Zo#H`zAkhQF0!ad!#~+f|lq
zahW3#dczC+6(nXh0M`5O2Hghu6IoYkT}gopS*uU3=a@Wm*~CK1nypJZN&g~&7_7^H
zQwq!1QT&5ge9mdebG3w=^3g8LN0_pojDc<3S&kcy*%_EdZ$hwzwAuP7Xk-d|%f%)!
zoXJ&#HT;FSY>RV@d_rgz8o$Qdt0tRWctodHdzG&u%wxaOXfd+8i0Cr%WK{R{#a75>
z>N47kxZCpao9YSHA7I9X3O>Hq)W%?p8F^*BOI6g!>VK;(JeEW^M@7eN<bAF4(=be5
z!6I@y8)eC`gBI!E=`uoppxD^h(bOs;VrJ{agXBeCzXFmym_FFZECP2y)x=x|FpjY=
z)w=yqA_cj87GpU1A1TF4aL6=SC}^j40y|`EJg*>j-kO*5#)3w7zHeKUO*sO&@frz@
z3jfx9%T#N6@ZJ2xW5M}|<OKGo{iJbnr36<@hEcJXGL$fhxL}N%Q4JQZ|I$(b7i+D2
zM+`_{3)+vSPPW|WAv%x7X3_9nDrIR+MLQI9w5$NB3ra5`;qol4(e=lCAyo!spf(us
z&oG93goRWAQy;P3R$Hq#8vhKoILlVu*0r}yxxw2-@vMk{Ya_6Kc)yGr0T9W^qOH~#
z02bKP9F3WwRYGkufL+bA=09j}l-EHy1%#+j)8x=Cj#ImAhJgLcx?BYM7ESOT?<pG7
zm*Bwk{qSSI9)zVareI8aPIaEP5oT(BYn|l-$QT@F$jLnHg@oHW=laP_{l*bp=G~(=
zj{lo_u-N;Gx7}?3DVIVV_DRIUq2=>BBfGS5R^6}o5EA{P?9}7p4`~qE)$o~(e1qOI
z?gCOn#Om;Jeq`h>STn)?3SO<<(JQh%3#Hv+5>Gn-;XP5kf6Zcvv*|hlB!7e6Nh?cL
IN*V|MACM4BAOHXW

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/3-debug-pane.png b/docs/static/img/debugger/3-debug-pane.png
new file mode 100644
index 0000000000000000000000000000000000000000..24c112da96f0548d80ae3cddfe1c76493bf79d42
GIT binary patch
literal 83927
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
P-|pPfxS4<BQQ-dqS4RWb

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/4-debugger-buttons.png b/docs/static/img/debugger/4-debugger-buttons.png
new file mode 100644
index 0000000000000000000000000000000000000000..64c1e05be8ab54a7162656088fc660eb2db96ce6
GIT binary patch
literal 12345
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
DXcfs2

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/5-assert.png b/docs/static/img/debugger/5-assert.png
new file mode 100644
index 0000000000000000000000000000000000000000..0bfed6562afb529a940c2064fd4c2c25dd0ea79f
GIT binary patch
literal 512053
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%0D~?iWdwxpqtquq-$yH*
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
G;oLu;zLaPH

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/6-hover.png b/docs/static/img/debugger/6-hover.png
new file mode 100644
index 0000000000000000000000000000000000000000..20579ec461ea26a541dfc0d0033043ad591d7b4d
GIT binary patch
literal 292419
zcmZ^K1zeQb_xB7SQi`-7B@zlqBMpOsbW3+PNH+|iA|Tz}-QA6J*U%u+-ObE9uDk!$
z{rSR&;m-5iKJ`84p6f3wE%E@32n_%LJP;EVk_P}V5C8x~G8AO^lXHwn9smF>-}KEJ
zS+O^7$YpJ<jZ7^J0RU0|sF?fj6lU;04L5B)O`{@D8c85e0?5BMNkbWHdn=0Y0sFP+
zqf$EGXH4n2pLK*qgmH-@Df9(}${rx#mr92U3KHH&PuFuHP(d<YbUi4lIpE%L-)Xto
zt+-IVFxUftlnl^6nwC-kwh+pm4-5z5<2(`RcmPDnB@aPhGPW!K@MUC#96UX6>*VHz
zdGvO-dd;BF%L}G0<=@}G0swrZNNgQk$$aKcMEHz2O%wxQCXoJwo&cSujzl*fMeNbH
zW-;mb^)NB%SUtAbV}BHV3dwr_8NCW&F+ixvXX*ZR%BMD>$tddRweG<7*B=(f$60Gp
zQiP^)j|ADq4BTDYoovFP_^g8X5rfj<NA@ojK3%LEqmED4!8UAettDh426lD7V91yE
z2w0RGtqxqvvmzMMi>f?g>2TkVgyGUi+&(jojrjT{L6>2UN4ENvrQiq#&9R4SIj5dd
zC&o#+d%LkpBo_4?om{8E0FydfLkT6jd^XLAO8KQrFV-k);$VmxQ-^BaH}495$vB4a
z55315sJD$q7iUqE$;oG$P43YaMVwsi+Dbfbue_4M%uiV9-bO!(+1O*<!Fh2)5YS}c
zhC2S*5ZcHl5SJW9!k|v~mcM7FDy^JVQuqFcAtsdjTi^#mAPf`o$0OeCIsq<RE4{B{
z3EMTW1YW30>XUPP5z$BGRI)Rzo~k|vNG?LQhQC=ZP4InqcT_QpOzC%pk1`)S>4O90
z3`(q%Unn&Ca{0Uvm|B(m49if)T)_zy@pDfJ052DjL<b=0O;vg?xE0SCf$S0BH3;eR
zJqh4_%4aiyt+u7ug^2f3Q7nKwpnKEzANpi0Bjw(gTBff>DF#1DMW4Ti>5Yrw6QhIM
zcpv8x(l>GzA@7N&nms7xV2h{Rs}HY0g0hcs(Z9YC3k8IO=+Yj@V!cCC1l><H+a%b;
zu*a%Lc6f7<=4tZS716^-jtMopeYTXD7c;v9gY!`^IHpzXJ$2&!jgEwGwzX*d4>{Ti
zzCAhAR6%R`&@Bs~@{<?dN~4#v$Hl?(33x-5E|fc&`}!SWKAK{nnV>_eRYqnm)`SQf
zzLenjNVJJ^r2sefprCQOaz@}N-e$(;TYH}CSM_9k0nmV_`jt%hj|ni)aeT$v>AP`t
z`k4HfAH?>@HpB`JxY6Sm1hBVp>)w@>P2=vOSui_dRzI8z*z0<z)BT<^k$VVX;}d#Y
znT?(X(28K6b04AjKF8-9a7@R}ise!BC1)d`g;e{Kz$bx_gEoO~nMb&&Z;=RIqj*d7
zP(?m^h^2;7gW~%EH645O!{*yB<k^oPSpEK0o&B96oi(<$w%4{pw&-h@w&rVnYtnt1
zQ9Cg=qVm*n5wV$HDN#*Xw@~t;>{CvoC8?i8@b%glFuSnU#k>38ez+A(rm&_O4&Uf2
z2`h=TjywqS$^ywU$?H6)SL{)EuE3e~UP4zWEY+m2=bZsvu~OkX-i+x2&TJvMayc|P
zab;R1?reK0Q&GYki^AQE0mUI@{#<u47qCzIW7$~ThlYr2kJeZWLj$tnWmP9|&9Kgp
zsv@}a(+l-Vu(QH5<nwH$h4TaC*_90Qvh$*IrwSGo?$|`!9_l}|9?IsbvU6SkQec|z
zl7BRTHn}~qpYI``lXsJwlW(nPE$>z6J;el3$t}~+FX=K2!jj6*E}#~vkgd=<@y0JS
zEXK>OdcBi6B~`?1Nn$BrnRd>wCo%hsJD)q5`vv!$!_W@Kj=cSX!&Uv91LJ0MYTn4>
zN;WmFqNG>(IawPeG^0GJkUWkw>vXcb7OfU(SQ&5>Y!zx!x{x}kGa(CMntq?98}tqF
znGe>&^BI#IIls}`GJl)OqqpCwzdyxc$B7n877OZqrcj>eXPRvqwMD{ONVq^hX%V6t
z!)39rlWd`7>e-J_{l0QpeYb2gIWTUASDC5C%&LT{H(WQ)QdNJ(I?D{tplUI{cYBhz
z!^P&LdT1y1Vsf^Pd+<8+?9CIy1VF;stCz2=Ee0*Qs-vo%c6%I~9nE*+_q68Jr%!e-
zW-qv8iG4_3aaVG=+t}OUa!qkR<RRq#%CqOVou#mqcB*%+X#Axj=7eaYVu(zWShJJi
zjKQl;tv<V+)Q%+Hnk9t;HgXH(@ZhMP19If?4Du~{v@}e-8TQ?iTRWN<Z;jY-nLgp_
z_!8F6Ipn-%xJPwtc1UDg&!o((-Xyo^x%hE0iNB9Oj319*#{JAA!rk0m<c|1O>9Xot
z{}%DC=K7+%Qk7VV-JGrUg^nV~jr;`@Zz;v0X{bx+^IWRO4<Di|;@_Hhk0P}BWIuY;
zjy8jT%sD~H#(E0*IQ=mVosNJXy#iI8a0*KrRU6-v{?_AzvXEG3hv>Mdn1Ooa>xq@z
z?c5`igUvA$(}BiVMP?2?cD<{zL7Upz+}aKs{Xlp8Jr%avX<eJP6*mdV=vDf<>Ua94
zvtxGsxY1=XNdeuRBHd(xuz`oV%4OZyDyR)OZ@DCgq=zJmX`FbRVmG?z*7#)XCFrGy
z#cd^KquCO7!!)9K+l`OuE=v?{70$E1<b28`6}yYZPg05rmI;v&cqWUVi8jk>&tl6`
z{}I0(A&qUE%1&fG_qnV+CwiY+_#}NcMbM~}f8OeSF|TSjN5gZ!HMxG7wdZRnwpQ!$
z8&-WD$r}k5CupZ=Ljl!Mu5^&1UG1+b4m#|W+`0~PM851-=E#uiBEI_IS_X#&>zyJ<
zOtDwZQ`a{V&5qF7TW_*k&)gTGjF0e6t?U<S4@6EwZpnB!W-Mo`w#=W_9J+=%$f=HQ
z=t&=)rC4~<!nWqtI|q}ff~nkUbZStl=jXP|&P?*;O|`aKtCuZ<=1k|%Yg*>YEV`>$
zZpuA){CTK&vepFG1{*M(EN9N@DC$<MvXl)Mtcn&A977Ji?QhNO)YUkqoHwU?q@15z
zT#y{{jHnoDC^|lJW4c+ccq8Y>?U@bJ@KE{we)Joo2$D#qNJntBGLND%**Le7JR(HY
z>{AFM|Dr?tjgVcD;hs15WPN(Xa^~u4p!SMaoidrql4F2p{(0r-*206xPwj7WnQLq+
zU(|`s63@+hP%lfW2bxQClqj{3auqmLA1C(Jg`aeuTy3;y_B1d}(OQty#oF7XTB^=<
zNHE9jS29{0G!i>sZR0J`#c)3+At<ib<Z~Nbn~mE!-I3xTwq{$jubnwe=&*i}6r2=P
zlW4{6#N||FKYYNy^nKLssQO}$&Pm0|YF_hw&5hP-Q}g22rZIl2rIEYJn-Veufmr9-
zbF6i_Z~9-m4P`2m-`!cAyCqG?xfU-qz}CkPb1?67A~M2yuD_q?Kv|C~$~WqV3;Znn
zh92HLbZSyL)jP~OT<a8VOA+_l_cXlTKGjb4S|AQ0ByoS~dbcNaq<&T-vN+RX{sf)G
z?U?`WuG9J3{WDAvfiVF`_W<aryWW-Y{Khe(k+xbhvZu%C%ey&_r|O-_X7^-!z&K&e
z-v+S&J!JsddH^{?{C-XjMm!XgNqAY{$bOj5Fc>gFF>Y|<TREBP`f|+I8G(E$z@&%x
z8>$Wu&rIx=N6z)B7<xGpC?GC#$!`CPkJq$4CQNe?me^+S&h2pcN_*H23GasW=ouWm
z3K^=18A(Y2XyIiP00IyjfCw)E;lBVsQvlLmWdML0{vQB9NJaSP2?jzc;y-0XvL7$0
z9Bd-sRqmO-Q?XZ(lH}I6wq(#Xu+}qVaJGE^qXK}}nHyfTG_=<xceb>!vg3B<qxh=^
zH@y7gF(U=}UsdeQ`6yJRWXa!H+ZvL;VqjumqToj(Cnx8%H8A3q7kc}5bNDwt3KM(#
z_uPz(PEJk?POJ>pw#JOiTwGj?Oe~BnEHB|TUfQ`>+3PyLw6c5lvy*@N5i+#Xw>5ol
zZ)$Bt{-a-AJ!=PhJ_?E-1O4C6&w1LL8vQ$xmEGUVf-jKq#~Vgw1}4ToH8XTJ{r@!k
z@#bf<zt;70INl$fam(168p0?1V_N*oynhYw+p~YC$NQrfZdp@jLkkrlQ%gfDyB}>>
znK;;Z8UOg|k4;toZOXyL^=r#t-u&H?m+{9&{jzaCsq)uTI9d47cp3kX#QbQkEfjnJ
z00<x^B>2u5xVwO^qoJ5|d9=iPVl_r>DZZ42EB@jDLW`-YG&4CVOrQ+X5mZS@P4!7F
zD1N?z=s+-`88zvECp2=`P#my=D7$*ckabUdjxFR>NVe42s}L9H@WJBzfTR&i93^XS
zQry9)z0p43#k?JVgh6{#%Mw>|aB#4*wswlWqocTpNQuSl1jWS?EZ5%Y0_`3U=@AI<
zKOgJj<jIaJm($s0G-3|BmN*cb;G@rw9U1Q6929ae00D(ub{nBgr4xhss0Os{%r_+w
za;K9V!Y7s=Jsq99u`9i6SAF>TN4>u)|Mu~b;E;^hS=QCnHM7Vvgco{gRCmzqM~OWe
z=#Bfw$vk==2%>29;^wnOfJvI9baNyjb0Yse<p33s0PMTX1~dh#8A{w}-7?j}KIVHH
z=saRi@;|GBuhbix;P7CfL0L_mXYHGxcBsJZH@R?t`0WE@=ReIgi!M|YUla*S6EdZr
zesdb=^Y@b0sC2xbZjvmZ^%g97_T5hKgyoEuRF!9S^|argS6zqZ%)`yS)=Q%ucAwNa
zkrJ#infu48-~y!bduLP!C-wOd`+t^cq(FXk0A6juwB34>?kQb|RL3Sp^5@Np4Ffy%
zM>}3E96;&QWKG^auwnWm8Bhj3fhZnXZyW2ggYyz>kbYLmqDZAfkYvMm6VZcxz@sq(
z@BL|8P{^735t`G|W`|GD9<0{lZqi=_k3ap5%KxxQG(ujRlYeTXKQp$2e27Ev$emWn
zuuJc=zvmPg2ky@B2QV{ZicwvCyyGnsa7iHzcTURv&K5PjVet*?PecSFq0ucbR2Y|Z
z>Xo%8f1JYl0|!3>rGgOR5Mg@}hI7iP`y=#!4_K=LZh4?_yFSAH$L-6eTz>GeU4a|i
z_vdxXenCKj;(c#;oAPteo*IxIUfR*iIWIcNYOh<l#<%|~Oh4GJ4(qUsra7L2gKwqq
z&pk6qc@MNfH4qZ1Y5aa}rR*_69L%xQFUfMrIW}*C#EZV<&nwm8Mp)b;?qvRR$IGNZ
zgu8_ktr47`EAA5nxA66S(=__>r}|a|<XEkH2aoRF{AnRNk~*{%d(v6^)2Pn>$O0AP
zBLajg38<72_)i@gk}os*GP4N%al6IekwbJ~8aq+XaXMb73f;qJ_$;9*rT6~6pHTg|
zGxihbSJbi!RAci7ForL0g&p_XO)>mvP%=?AhfxK{UQjmvk?^fq2$Tr5r$K4z|D6x6
zFBq~D_30CLUO_<=5st3192RcN5)CP4+ncY4&`}X5)J|6E!319Y5|UOkWxM3L5N_-Z
z=bO<P>pjA`8k_G0`$TL_f&gzqRQJP`&xuaK{$^w^F9g=3Fc)#{wT?MyOH=t7mKwMy
z&6TM=jXm!kwz%(f&r^I$$h<`g7J!Pfn#hbT?Obb+gp=WT_0vF$oz8iTdP{K5y3dc7
z5Fg$PflnADhra2h{gy(GkPx+3Fv6kU3kKZUnPV(dDa`E_-uR6JyydZ$X`S*KBfcR1
zM^3y|adV4{!`Ii}npz|>YFWE357Rq-RCo#oDR~Qxm`|DQ3Z;HP>hhxBk`e6UO~58%
zeG{ibu7C}mnxaH|Nr|X}aq9~T03&-)V*}(Jj}U%zpE`hadP4r_P+hyKYI3S7RfV3R
zsp%%Opg<Y<{$TjK|0r*7E*x?!ouN%G=KrdnuQbaiR|Z$dU&~G8GA3P`uH2SeQ{(Wg
zM&@rxqD|P$25||3SXecVni@`>_wUL3o{uBOL|o96;HL7`TyPa2P<DlDFkW2>JxG?4
zYTdwdnR|lGTDmie$+s3&tQDS~O&!-%eN`KlkA`)E#kyt-fxIr)wOp|iMQn07cM`us
zm5fAM77fK%7R}^W8VZpx)R#o4vN?*oNB#Dim!)y|*&DY3##U_Tb5-q^<&7+p=_4ie
zuPKH}o}a49&v{*~MUOs+Gd`7(0+b5OCE_8<tBbqu8z$chlnI=1YW*d-xDnvt+xwx#
zx497C`~tc`v(U-)GI4wc4IK{$rweg)^&AJj+}JK*?f)U>zQ`YmiGV%<f%N7p_GhM3
z=ol$Y%`9DK<`|c#K5YK*tR2ll`~(G837j(c`qB)19Ylta!*;hXbB{&}X#@$OrH+V4
z&xij-9>SS}jm!9sp6z^nEWIjj3>EtK^3qWx@+TE(x?%fGr2S5F(jm9!SSh?sy>zPy
zSwzRQnmXl_fDM#zpoRZ>1V#Bu$?Njvp4@jFG}xxZG#(gx7d^>Ao?EW7jFw&~;*}pf
zQ%JPwju{J9R#Mic9quxlix!@>%*D_T+WnOM`Ddv(eA5wpABs@P&v&;fls;+H$}0O8
z)=&rJmZZ?Ue7QHa)Uw1!l0);G+=AjzLQ!O?t=T$+{-cs~s1dlw=e8&N3#skbVZp)D
zs2?d<O~duEKsw?GtPi$RwvH6G>7yc$*kbRjhXeX<7(T~#z6c9hzz!Xp8|Y$T+&-Sg
z(L1h&h^#Tn1c@_+5@z-d3^mz`&0lk`nS`M)5l1x{IUX<ZuSD^9eT&(%tRSvRs7tVL
zhyxXi0i<grm<g8)y?DsmT>O{r7@^8p_PmkTzS$MEj9h&5eklSJ56tD2xos@M$$Y6z
zjeAXXcgz=rpB*2E&>C!5`(o1_3!p+EpWSWOc4>gQMNs6M5f+b>b!tM8GFcyQLd$vZ
zPZbL?0wz65FE9_;orBOw#4uDVp>eK!o-EfFX<*kCTF;mc_#JY{q5!dhXlddJzilJD
zPGl&^78^XYKQ%gPS%f0{`i;T!zbyISAi4qc*2UC#p}I)3{oBN6`4Y%8KeA?)qW#uZ
z!I`Q88q0=+SB0<Il9q1md(iZpuFo<`KCM=hU9Yu3Q<iQS9IB%s-_>y5yPb%%mwQUB
zt9H|jtBgE~L0`m;^19r~o!1QqLhnR8xtKU-<aQYeyz{7moD5mf7^xN4%CRYUIhO@E
z!wz!+5Wm&W=x;L}w@y7D77z{6l9CaJSHYMl)IC*R>|t&O$PLW|Y?QUlQ{8+~MNQRv
zcv6vQ08TCyN#<FW=D|juziJ+#gY%kB@jZK=&(YBjRjUhC*9Qwo5<st&Lo)w^MF)Zb
z{(y?_1FHW8z|Y0KudnONp47RW@3OKspW&}@Zn7cl6FhI<>?KTP(3+<-hZKvNr&U$4
zzQk(%e$@BrfuCXF&bbhnDsVS$H-d+ZN!dW)y7+UVl~D)m5`r)`sm{+jyF&|zNg)WM
zV+{DrJy3b+P7%}0PT_S^pF4m0vgLMPx58U~3IT@-_~k>VTG$)q*!O+Sz>oo%cxLUI
z7&R6!>r|x33Ef8Q1x9~-O>m|~@_u0aS7xrQdO=lajHk<PSA4oUN$Sw;Y_7C8!sQZQ
z1;Lk=YVp-{qni_L0n~WkaSsB{hkscK?>d~%2^MA5)zYR`R^i#%$U8*x&vEgSM1B4-
z>3=hhtg|=oywwYL8ZN~D>Tr~SX7I3(O0ini0C(A9D;28F`4Zv~9Pww-z27clzMA29
zeY{n2vvv^@=?QSt4C<+|!sxZxp-%R=t&3?qJ`L2`+C37@LG2=8V%29f`w~d~j-Iux
z+&CFGVm<pbGcNne<_hwp{kYDHpza2eWvyB-fXDhowVD!Kz)uh<<3&#2k16I3yWNm+
zw_S~|ZM-Tp>GPN1B5Yk%>^)M(?CrCYG!pv6GQAhID8)Zh(Q8e52mcb*ch6>Y21YkH
ztaX>4Tj;7U>hm4@d1W44yV>^9Ag>(_D@*W3v311FH<;d(_9%3|ls-h>8kV`DERh1Y
z8vRgX-l$0R_2;5Yn>9+vBj#cWubL=EO|W2cOl_PqUw)IrS}Cv)pr+~B>HYuMW?&2o
zy>_z-EiD2I8yf`)$pXU`-og(gBQBEK%)n6NNkI=gnTvJ*#<PA=gbI53RbJPq4!WMh
zN(0>8JL%zTIqHQi97H5Fl;4ka9o!$6{?a=)?BAyi6@F*`5t!pV&@7`(7(Kf!lv+~}
z(mh5nLJ2<b<cDLD>}FU!Hkca7du%br(f?dzU^Uady|6DWi#QzExNbGlOGXx%mE$LJ
z4;!<iNo(e^NPO$EVlQm^neF?UZuc3_J?zjJ&v#Ghw8)}6pq@fzG1=7T#K-ZaiSBo)
zyjQ{z7@_rabz;fSemVjmf3(UPr#L(yg1n;QQ&*|HtgH+nk-pO3#q9#F+?SIte3Jho
zo#e|z-rL)>s+GB;+cN5NR-;*qFHp#rm4Kf73)e#i+sc#_D`ZZJ=e#)6o@1Y4HJl_s
zTJ!OwrHOe-dNbK=H`>jw=xIo!Nb%ecQrwTPV22V*&|Or(kc$4g`dwO1;}pbZ$Ne~K
zr+rEsIOOSZ+tWai-W7R_^*$W%P&?|nfk_=3oPqN)!vLJY@FW^!nI8sqsktK%oVi_!
z!X_Np+h8I(?g@7DE&mP?RCQbYY*9<W?rXY5sO$gn{#stiyTHukA>ECC+!yh8pc0a*
znuF*nb7fUXWPQU$-}17oe{i(!?_SgXqvu5p;`>Zl1pn3DxJ@9tiX@~`>m~4q4xxAW
zcTf5Nk3g;L2n3o0k(NbUz#6)k&NY#m5338XM_3P%8KZ3X@UUF&%rjne5WcFY)IRwL
z*0@*$4T%9>JcuP2Zd#2x;a7Qj0UhP=R8~tDR{KaXd)SOlaUB1BEaG`K>xT@?kX{j~
zbfFhfag;#Lhte#qjAW89t?T8lSfdxIxZ-Nq;Hzra)d=?TBY}KdX#`OlCPApWm)g_e
zMKwe0w+iPy#}ysr+tve^+*!}>i2@k<YJ#MHutqT!%14SZNX^oAh@E9Gds4=;-_{C3
zMf;NAmX9RT6Z$)+{7~%T2wEk|L{B!<yLT7nII{Hfeu&&E#mH>EI@_p;I~+2HEK!!J
zNG3b$Da@Yx-d8YAlP*{ud%(DN*vC_x7i!Lk+5gd6`avip3Zb};jUp%MQN)vGqR=6}
zuSr;?W~Lep(1r<evj_FiO#<KJWgOO&jP=%3m4fHFb6h!DYW1gkDe^VN_0K5|T9_!}
zIc+A5eUCTo#yQ3*!E*ux;q^pe`F*wXr)1tQ&b}5!70`YqQm}>Ds-lwDHS;@#15d9K
zhQ;r+)M|A!A{&%wz00=*=(29&;+81PuB2q!jo7^-il5+G%iD=GnX5SR5r>X|Y+$5x
z-Zk9aPd6{P4itk`-u>m5#lmH~Muv!JyU<*M$7#PDnqU?FW;*CM{X-7-C^P%Z$1S`&
z{%0doGm%b>iXf6ABxoNERWdN)q6G#e-#g!%v&IJQs#4IHs~J;US?(nks>$s^w2L@A
z=*Tho_97CBANKovngD%|2np_mdD;o_p9Fz#*V9f_`vMJ1m77^9nr+H<V7BVyjADRZ
zWY}#9kjp|?@}Xw(cC1FubTW?^VD_LdwTFYBB;Jwb2O6n%`nELdy`L3|F*3Rq)^CN<
zchT}V{0)AWA-5R7Ed8q(@`&ta3yBo+<x$hRaivf=b)jG|bo?9y(z;U>KF%iOJGfK;
znZ>;8yOzK~RcouSCANWnZhYU+JC*vkN&%^&Vqk`-6i6T=c+x%9Iaq|26AAbV{{)lX
z$B$Ghj6OQ^+NHb`;N+xiaCB%OA}N?(Or~Ys=^e`&tW#uoU$nUBK}cgqduVFv84q_Z
zC2@lPXHTCide_&hnVTRY-WPZH`~@AZ^xuDMB}+N&t5d#LWB`UFS!DOg&~n?|D3@UN
z6Vi08o=}_WFkxvYyz6h0ffRq~UrLPQuBb0YIILKbVJy?NQP5btzMeP_7in=xfWQZB
z6sRknOWC2nDDkq~R>@AlVB$w@CA=Y|`Dy@dtlg#ao|&B!i2yb`=!;rG9YLfnjvD9w
zteeE7?1anTwJVe*rmd9{M<@Xif$!w0thzWSzDGG65Q`B)hHem8CU`s=l)dmH-z*V_
z_jPq1lt*oRFgWp27G-0*;P|S5+>ibf#6Nmo3xa#3re<c3n!1E2Ky7tgz`w!4KzVBr
zho>k*!)~K0zxn$3#||u)VK@F4@K~eCI+|T09(-59pFX)9`;yI5bdxqP)F7g16u|wM
z#_uG`{pWi{_xN!JH{O7S!0yk-kpGJ~s3>I>6bysj8e^sXMOR!U9qSYk{`dN_4DNRC
ziW_+8@r=$dR@2)KXh`uQLOiI*pJ*q0hFaMsR2<!g+db36k0GRE#*w@$S*k%S?0zNv
ztv6iQ=4$zC*b8F0Mnyl#vF^1LIQLmS^rwEuX_(&&fMYRE?~|-hq~+<&*rBE|q{N(c
z8P0~B)7)MFhx;TYAT~q%B`WAC?>eOC+kvPQ!pPpj@TC+5m_I?wKiJuzp9IhLcGACv
z46({a)zwHv%}ZdPVD419P3|9jC4}(i%{7OhFDE26Aa}<e?;oJhL%W>a>bRF%+<sbQ
z?V-fbbgF;6nK5j%cVltTNy~Bc5uKoi#K~Q8s)&cJ2GJ-j`g|+d&5DXp2fy&d1`Qi{
zoF@9@H>LU${C_pUHRDY5GpWb6)rBK}FzD&M{p&25<mt^Q^<wm1tOA_2CD)-fzs|K_
zM!(gigX4au{qsQN$%ZE41_oxj+VeAr*J*D-kysqCf(@M9M0&O6JFfmwC%QiNh|TSW
zk5wEwmL65dX?VAVfbf2NchHq6!uxs!3;}&<Z5me$vQtsvj$LT^^wnHyp~ubV2?nX#
zTSo4uuPIuEtg+{QI>XO(fk|;nfp$T8AN=}8{#IP6Uyz_zDN6#?*sT@AR?)K06UR3R
zUYbQt7R0DJID9%wPWIp;iIK?4&b}%)8brI=cWNQG_PS9lcR4AjBUU=(9<QP`=$<!G
zR8@T{aMcSbI>6M-yHjp)CAUW6PZ>r!ZZVzR<LU)iJ9lK2TQ9X%&b>JGrb)7|EYxgZ
z*%;?N9Z?utT#Qq=`yQe#VCvHa-}kk=9Ic+brq_xTSgEq*m4UyjUN9&O?efmC)qql-
zl$DWSYfh*J3zUj<uR0ENbt0hg6rw>CCb2|>B_m&0U1wxH_}Oa~mAP)Q@L_2Ik7-Un
zeLk%)TxSx2Z@Y7hyx0+?5S(M;RJ}wR+=|MZ9O@_$4Y-?$BLFO1kvG-dR)t}#&GsPL
z^&BWY{uq_j3d}9}BtZx~GHpr}LQ!Uq;rq8g9T^6q)Pp@(*3hTTNMn8Xk38#oR}67G
zSlBCT9HDOQ4Zci;`JgY-YhRB!OqDI&t|uLjr$CJglj8WfF6JTqmNg!IYW`cDI3c!D
z6s`6}M%!U~&Kzor%F4l1{_qopz6TucRCABAD@*z`a#O@8z{!#kK)A(jc!jk*z$z1c
z;BkO%WcX!X`PpJsf%=dD%*@nsA!_nuLLnrI>~<M{)F8-$iuhswT8x(l^fZU2LXmEh
zAMVcfNqqk=N8_e|joFST>P*$$pQU!g!J(sfMhO4FfP5uyQNqQ-MJ~pJ2RRlHRrAH;
zXjX;lt-$JP2AAutLDRWF4`1m-mwu<a<Bgmq+aFG=iJ;k|1JoV;V^}jkMaoSG__i;L
zb)iHX2j`%6`o@@Jm>x@K#9h6ylJDZxTS?+$0hoHKNdzGA;CpX4P>n}EO_?#Ue=h}H
zOfzWQ=WcrOFH<J|q8KTZTV9I`;byM!c;u|gc0~mFYeI)dspxizR!-atfqiQUP45g>
zIY}P}8`M3SJFO(!4&r~}=)zRXg(yF$l|MAD`Zu-y3V6P6YVD;Vd%1KqB&8sZFe3O;
zwOn++`DUuH7XVkQLzIu*ZN?}8mNF5KD#>CrY>RlWR_6;bKosC+oZo|Vsgg)OZJ?q4
zchRV*Kcg$Lh`<sEU7XP;$z-5FoqF8%wR_$Dk2E!k^uuHxLv+?nEYDN!bcD2EvlE0>
z>^(RAkWa$C3tli$vyq}FT{XHzarnG>r{^w4jXvJgz{HC*9r=Q_6E=00)^7z0IKpgL
zI_^(Vbs9yl8mA1v_XRX~3J|C4f*IRfv4LF)heZD<z~AG#*)$^)Y}(DRJ4XLv*HXAl
z+rsWb*5*eHW11}K375aHGDM1Y4h%)U+uqqJi~^XM7pz4oJNCde!27Yq(;VZJJA!i0
zJ6$C&t&93VgW=?PB{VT>(`$86q}XN>5sH8I`!D_yraJVOX_S%Xzj|D^TfURk;^ifG
zw(v4Z6Alu-#OC&&pG()+`+NRnf+9;nEpdW3+X;xai(Fb)mu~HP#ilv9b|kY=YaEzY
ztNsMoZLMictlq<?LGjNCb;=#Z5Mm`i-(BJN#G)`U@(EHcZDjHNO4)zc{T$O9ZYt%~
z%^3r4Zco%#qt&g3U6!rg=AIPlI~amNttrtcsi=V2W_&4@*uuT8E>}7%&`m~n7)t1g
zx}fmyoqFe?%)jq&TWdOK8sT1rn~Dgh#_w+^5hd@9Oz<7|u$Nmcq+xT|NY)p+sL$=c
zs0KOwY@f}r%+7rJfco>4MhHXv*yIk@UHYoB4%{|U0#_j^Q?@vV1}d49_(OXtX1_Z!
zzsRbj6gl(D@rmG!SHGKdP#B7a(?Y}A-GSGJigk+X_C3PKoJ{BOG!f{R?pms~rK9;K
zwt&@69FCsjH9tvDa`vCrAlAEeCA-%BVm;J-wfysCHx+`3-fXj{&z^CsdZZtBFF@VN
z$m>81;dx(84J9|9wIRJF@f*JR0P#1v{~N~m2@yl@1B;v2fnn6Y1LYbt_tT7+enn+X
z-l-;@{mVM{;|Q3UQ5DCiZ)D=V^wC(};~v(rxjAc+@05szDuOJaq0jGr1S!LjUZ<5}
zJbaktVF+~($eA417kT?y>}B-gcnjAvTG-7X7T4P5Y3eNB4exQX%>A_x8C#c{)5WV^
z5jIs8fEXa+iG0R;gcBtp1tQ2K;H{{dIP<rAzwh4v*_%*CZ<`a*wSt-3nu=m>h9_ov
z<<;EObUqY8f_8}X`(b=oVdq#Ojl7#tQumwInQtUTuMXlCR>JxzYzOi~iLFSL+1?uH
zHX%=TW*N8A74dnx7{+M7+DGY$J_n`MhgL0Y<6-5gl0<K>VWGYfrkZ}l+7u{JyF~Mh
zkDt)&q+f8nrEMzxD!PYT%kfu90{8d{+%jB^_%V=VkfZ8+(NmM52>Tp`aX1S}CJzca
zOYa5HB$l@Ex*BW@X^xvk_`<i|+ZJ!S+|X}RnL#+BY`^K^n?`=LP*OZ?n3t!Q$`Bt9
zd+Ze9JYtC3nnDe-!BXqI#(jtDw(s+3oV|c0c*1I-W}N6DC900q62TCId=1N)Q%n^R
zXhj{D;&*BISIKzuqSf+m-{isrNX7ir#%w}{rr+K3^7FC1$e$mLR+VC+i%?=e?Cm)$
zt=yZT!%S#BzkkzoywWyPhgGd>s4~QFBs8QUK+zvFA*yItghczGU@PT(83pG#HmQHl
z$l>Qo2aKMSSIRwiPv{KBhi1f3a<%ZnuDTyc+?74e<H^+WiE>y$N0z!cy|wXw8?+><
z^7>5&OKF45wbaseazSJpKE%s>^{5-1{R>|{=L1RsYS-iYyO7^vw?6**CD}k6nG<@M
zA(;@5F~Xct&Gq=N1$uv<`noCs`D8e=a+*7%TLEZ~vBvCKXgLRd1XC?jBHo^D`71sn
zb#JF@a5LJNbuMdquv9zF=)mr;C2&VUXGY0(d@^8eMaM>x6pu1;M}I+doFPH?i(LQh
zUH!#~pn7mYNo#W+Gp+S2Z5n#>=zw@`oLg&#fo^+JH@jyY8L)T}oC(sAl35~E4lnP*
zMFH|B-1Tb&P5gBbcf9h(wMbpAi`A!GHgAgFO|py5n-3Z9k8Tx)GH)yfim9O>Az<g`
zMQ7ko^v5gSUyF^pS=*3#*Uy-oOK)&t(58(c@!kBb!8f@F@`~y-i(nbvSw?*Vj$jHc
z)JsWukd!QKkoKO>Re9@ak@*?_%#BIbu18_%9o^=#De*77z=B`9ogcWCLDu9h38n-y
z2Q>2bCSsH>su8AUW$`g?q+<PGBkyDE!?^zBg9dVn19t6eclVj{K{^QhM1f>)4QF{_
z9ycZ{aAj=l8`cBo90PpWga%K=>7C`cVGVb6uPYrF9>rH(24@Mc(^*ezZoB9kG{EKS
zme1sydg{3JQd0Mz?TH0|g&eW}55uNzB55R`9G-uat1IQAEl@7T#t|zyI-~Yn&;V7Z
z@3Jpy!Hl)yOKML#cftZbxpGz2tKlO%idNN`o{uNDYs?G4z6jP`I{4a7&k7rz!%}-?
znEX*)J?41TUZBms*eg)2*H~E}HNR-eZ&uQBlh0z~u$OQUmfZKuoh6Qhl^+&9RdqfO
zrRTSZYx40qr^Bu&+{Hx;aj{C?3KC`&4B>Yj6ktC)E5BVe%Zpv2Ztkl+<u#e2$oY*^
zMp4|C5ea%7AWd$CEtJ47a;s-z*#_Y6!8~Kv!>uGdqR2gTuY!J96Do$(3K%?UUQg6|
znI7}F1;*Mke~s7@`%$hxJ@H0a?rItj%QQBJz+-Q0bPX$M@D8@mI8ddv!OKe_8-Q>U
z^0{xeg)EFJ=i^s>&kyMxq+6a{jJ^wm<-tY(S!Mx-9frqZrn;r$bWQ4)by9-=e+4T7
zRHjDQ6bBHz@>?5G^ot{RvkP<HO%6fTf)FT$Hlb>9_ydV1ioa&GovT$A$9;s2Oq#DE
z%uxHTLsgrVkw>Bc4Ez!i0Q|W-);8$*Rh9Mntx=c9&M34Stro%ySirl8C%u1bJB>AH
z8)o0P{F&o`4v{TB3c!ZC9NMA$d6<By04El@Rkx>swA1?-vRSP%Z(eVC0T0zM;**ul
zPnbu=*1Z_%?*qII`6Yl4zPYz}vxvTSy|ctR1<!HmdX9EXsld`&)@{ZD7OA$jrt9G{
z#r?tmsg+33{oP#m<2&8FUM2#O3#}0M+XA4=?$s^wPQB{kxbmm9TaI{DiLR)uL7S^~
zk#^hjJm#xIg27B?*R&}3m|UoA#Q0HJ#-F;kw~;{I9`8j-uigz#SG)6aZI9_5Dd#}n
z@82e=J|K5c;FlKuAJ_D6{s0NWL+h^aw49XaacLg8A+8M!m(?)0^5mQ}-Q+45Jas0t
zx_Uu%2j47b2OAii@86#QcR{wJ{KV%=7RKRJDVh#2sDUzjpC^x|I-GD4!Ag`PiZTIq
z1fn%A?)<7vu2qd(^AtROKU8>G0BiYtDGR-q({U)V<21z%akg7_Z1tc^RfuD{&sK~}
zb_1Ir$QNY)6;NbEg|Vqn(RDFfHE6rv%vYY#Pm|z?Y&5~RvAnIQt9lr(TY=pwe?-)B
zxfy^obtOf$6W@RgOZf1iHa6jN#$EM(vT6qttaE_W8iZe@`Sh8`9?SezjPJ|h8zq}h
z1OKGL{Iv^@y`5TaNRHtU)Ox_@hZ6GP|DlA25)~qVYUr+3L?Uo_5umE`t^I0jL^k2o
z2NE7fG0Jcvlw!!#L)HSVV8)vZOmSo5gUdnTqxzxFCC~Nz(%V78Jbedl*o}zCF=NeD
zmUT;=k}~z$DULp21R&fG_GvubwzrP-stsmaG-fk;ko64GX;7!Cnx571jM4I<ukEQZ
zV@NN;pp*^Q@ks3i<m*}#en?~exH>+aW##RxWa4Rb=zx0MrN_9tyijxsNp$tiiJkV!
zNDF#zfZglfdHC^xay4{<5<&JCJN7Tsg)3DGtdScS>{KQtl;_|!KJk6KoV=zcm+7#!
z^EbmEFx=39@{DLJ^Zt6C&(3}<+*s3gGn&7uSl=0tCaNyxXc)-gXD>PHN<qF=2VP_}
z>`DR~vg@arFGz7v$Rcr~8NwkX^ZM|(2<t=(w~>(aysWVj3DX@b@a#IP7j0^$=(*d?
zx`u}FG$h$9wdpEl|6-f9Ab$pj{Y)|yiu%NCZFefHkqUv0m>~S4$RL4Ns=S`u+)FE`
zF{APZJ-xd<gL`{Tu{$u*2+K6sc+r#!JTZ*?ais7QBE$FHp4dS8=TO0)(Z(O*)|!L>
zceOE(du6n^rnr6xrqNpOr2&9%tE`(;mnzSC?k!7eVIyiH5}eY~I=$f^jl#d+ncnSh
zZi-1D9lAD69ZViYsjKq@vS2MoX6PT+VSY3`dcC8k*H`-KlW_BUHxP7#ze3zBE(%lQ
zaj$77<W^q@9_MMHN2smvj&*sz>aiiR+O#f_!XtdZI)DDAC5m2`;Yj{V>#d8;RSey;
zbbrcTVdaI(i6Y?D$#_=N_NPVCX?wS<#`A37-i{a?e%|Nav$Qi%FIJQ(jvAa-8qD<O
z!%xIa)wOxu)T4ynoZp34CRzMS-+!$v5J`iUiIbB)M(din?q*-z@b0>!{M>eD3cqeO
z+<dLodt#?V6|?VT=vJtEBTr#xpu8-HqcgL-cnD3bMj4Sw@I=X=rA~*JD5JRTYzlpc
z=-A})dh^V{Z4FRidFoJVm7K_2q7E%(WMIS$wn{Ye3emt1V+|n++pfQI1hs5^f@lbb
zsQ02~1Z}_Al|(XsGq78s%*I5AWa4q6X1oFUfc#SN#BBA;8RBt+F`c2r&A?(X8~~eg
zItt})<Ifqb^F~KriJV|oZmNpdVMz)&bePD0JbSHxS19F}4x*=?tg4dtvJW}sQ+VoI
z#JZDW8vlz*1|YcL*Y1|L#K?GE=a(soAw15Aour8i2L^M!jQ|c<RFv!|PBy=1`OEq{
zp}TKXJf%~$aA)MOJnK8tMpdb(4_Q*)E@@g%U&AU$qKlmoQP<Ur##ASacsVD|<II!b
z<GNtg93sv4YC+PYxPgMAyC|@qUAt%4;$Y@_<=jK+<omHe%|{`!?igY8mE*l9Z){I$
z5N$UY!^>ZEDbssHG-YlKH#`JYuOR+}d5!C~u(AU(ILC{u#(5QlAL1%2z6wO^7lS<P
z8)NM-eO=UoDL!mBFC*$}bB5gHCiDxB|I6(FAl~E0oaELn{cZz^M>8cAejVQ`QHzb#
zM--hTUQKiwsD4M_!PfL$D>6S>PZ`|_xz>@g5+GW(;v>Tw&o`>TTPv=ZRj)Woh#^f;
zj(({@K6@_N&s@+^e)_0ls@ynoQ0UwoyLEa%JY$378+85Mb^CsO*R5OO0Fr`o%@*jC
z{KU(nUeC0OxPtahuWp7tOJ4t4xu$k;0AR>as{YuuHVIdE@YGs5dtt<G77I385__ix
zo76w;rv#{YuIE7{X%uTJwJI&qes#ZUC6>uxN0zqVgOo!Y0)D7zE|(Qb#MAThkR;e<
z1||oqRtb^Y;NJ;%h339u7_M=L0$wXIfyL<2hS*?vws`Wrz5vQdv1A5qi;=!s4O=Tp
zeQXem|B$EGzIN6SIHj>gBYEkv?R^&|c=gEZR8v>AsqnNV$Nm#ESRiYuQq9&?1$zAC
zej(V?YjX9WBD%iq>emk2p^I~4NraJ1-;HLiD9M2n3Y_=U<+SBi<C=ejl*hD>{DlmA
z=+_eWBz6WIY$hY={gl6Erst2bjOsW%D6c_;qj62`1h0YWT7RP&pP8b;bN(IV_`3<>
zyl>}5j&5|@TGkYbecu#s2CCx*x9u*&OW!F@sxhBB3bjnW<k1!6$<$UF1znG(!pc6o
zH55bk<24~j3p<bL1~rR2Vn~=ohIUtKi%}jG#v8j!HgxsenoFCt#Z@~b$k}L_X`j_?
z<+zka;3Rs?y7j9z5XJ=b(dKFK8<@%cYDrpOA`oc17rUQV_)~&K$UKzx>vv)z7^Gqj
zpa-*)R5#}jRvTv0Er-RBo%hUTLgBFzbK)nj3ag+AJ5kDN0gf8>a6e$4fyp(kdv77r
z%M>ArkF@TaInd?!p7J0hd}{c$^>oGXvvsxlFIq&&r}jKfQ8kbo#xIg)nRxs<+jqB^
ztPRx3<Ng|IrVDAzTsyc;<S9*?v}ixlJ!BT*NhwqAdRAr&E+mrcv(()2?i(KE<t@Eo
z57f8q>%LEAw2rv#ImOsO_CWN&s3q?Sfz(5k*vUjh2l%0Zno7J(@Rz|THm%eX)D~V(
zg`mlyOOO9gk||uv_OyTtuz}HW#9$D)$-Qj#H|)yU?5PVv89Oj`-i2M(v>l^8{Rd`{
z08%<Gko9eB{S@EuXsct9j?WCd8UaR6fH<Fyk)ff&I|MvWI&cSfj02|Nuzt$Yc4k$_
zcKn&Vo29GK7<S=M9DjU$w)MG6WgsbP{43>G*;>vi(lWkMSV#8<HPK&gr{A&O$+4Dj
zg(O3`TiS!HASZ5>0vVHMqq}T@2%F6DyvulA!XO``-QNO|@BLZ>@FZ5V6ZkFeE<TKB
zKpNMbuO>^ZoV12!zdzuZ*P|jIm_^NTPM@7M<GMSI$abC>C~#}a0|tnYR4JVw2t03a
zx)^A*QTxmIJV*7uf$l~OyLT`m-aoC^bs=bqycu&WA#U+JPPLSJJUyk<Y}6nBUEUbK
zXfTVOm5#<l^MpoJHToH56@%jj+j-u^V4h%%Qb63?Bcj|A*6R}Zp@pg(S5<~q1bW$J
z<ma=fdgEhdOH8EIxDv&{<c!#UxycI1&6_=!GNXeJiKxGty?^;tT)I`!A0P!}jcC?3
zUKoAC<vQMtR2H&0KH5F{$SX*pCJ;G)u4*6y)r7-u`s|FnqMN^m9_dkJHt!dEU5|;=
zVQZSFCYXhwt4z-s&FX8tsb@@QmE-FY4SJLC<C(a#zF9-|^%Dt&rY0$K$r>cdC;SCo
z*)N;ivZc1K^s5smi}ALs55_fzbawOWH91`E`R?t=UED~*5Kd@XP>rjG1%CDMW#4<J
ziaAbYYW1xmY`;@fWOn(gnky&wE!cCQU6$)dOo}NF<mMKGfsrXf<M-N#d)tNzKd^UP
z#+tB3akbUEt<utJuCxM<BO6zuGB9N{)Ss|<?{aw2kqg}1)uL$BICw_ioSgC89XAd8
zQS<F6!|2GvC@|TQ?L$>*iOXe6=GL|FIlf9!fLx#p&OPb#McLc&H$2PD@kF_>l?%G8
z@87_Qhu@y&Y4cTxfgd`$u3cFxi9r-xYEfD5Yj||&Yj-|7xjVn;*Jk_-|BJl~78=-^
z8`$t|kZ^%A*j%{1KKPe1|CahRTOE{**gZ9kuOO|SFS%2i@dm6MRob9NEqDd|M5`&a
zyCx)@u901>J7xf)FV;22QZ51=PIGLA>=_|SiH%%-Lr1wKMT<emD<&zD;=b$|&5J7)
zMpGOmdk(-tC3~GI@2NfjQDVyD&oj(}EVG}g^EM`rx-q~I^Ep#JpCPD#WBKaFx{6!K
zD{R&}#MuDou;?~*L9xqkNo=i&==P5LVanPIFZ@WVZ3`Las;l4^JRs9MGp;M=g!|vu
zTMUueS8SsLhc_b7D(cm22}w!CJbQoSW9lS=9e_sj)ngtrb90Q>Q4*s|YdntjtMZc$
z4zmrswrwIlwq0V(b;n7Lr`O$9sG>Vo9xX3=5kdqG;O8_Y+R&pS9FZ&7t!K*oS;4V%
z>hxmr&4u(tr&G+y#cc44LgF%gwBp{Sny<Hw)&(-8x3Wd_u!7J+ZW>DTDVdi~b!s7W
zJf0+xMFM%Do2y*B#aXk~pYD$KD6~1*!Z4WTl1P|2?5$?E!Up$;trIMXhW>b0qBRk9
zV&a{|n>U(M@LPOjOgPF}GVW1lsk{gFiWIHMp(0an2Me|9p@lD$I2%y4Y7i#a54AJ)
zi_&$WMDxW*ThuBG^%rS8`u_Ds2~ilS4g<JyeBb7+LsfEm4rPYHGQlGaG)7Y%mYRV$
z64p6LCYMcCl{ajTo&`1Bq&JWGrnYOG>~X_#celu%BrbHZK_6VWP!gd^w34w=XIqYQ
zkvK^16|N+DRbG(V4b^7TPv7v(TJI&~ne%Z-&^r&zwtjmr+U~LD;cJN-djA*utnoAz
z_SB{A9;63;i-*>aw7z{?!NVh|@uDduyhvSLV^pNZ{<U#nGyK|&Q5BEp$<mjcBu5`H
zq+BwdgKR1FtcnWbU3QtjxVcYa8J_HPJfa|Y6xVMvIx6vbjVg4`q~$clbLO&Kgde*2
zneEjygr$R;ad|RH>nfzd{n)R&_U(*$G0@znw|u>`YSG`m#^Rz+6zjf;3|p~A&5ju{
zbB6&#hm2aXo9Q}agNDx^oo;g*z;l4Erd=hWU%qnoG|o%t-Kopu>n4HFP5bFWdgjV*
zI!&2t!x&X5orC`M4Vz=@4k1Ja&nc^8hYean_|Y1*d-hjK;J{u}yVz3F>cK}bItAdL
z^rtrkfl9eS*u2L@QMumN@WN;C^wj@5My%3$>QqmQmFm%{?=#e~f;sIEILf38v`J#u
zMw~rsFGn6p$niHH8JaY5Yr(m&BGKD^`}(OVne;?5gNb<vY5>_Q?{kMwQa9P&=dNC@
zyxVs?C7(vkl~3PYcW$+~Y!{-XB94%I+#u8?(K6}nckRxzp43nn%zlnt8^7~L!&xF@
z-#8+ou`64&A9{F5#?FLkrtj3gXmr*|d9QPTS*Zq&p5(R(w%4c=0)7QB@cT_N!&)a~
zkq{Nwk;`UUe^#Dp^Vw}XdP!J}_Tsl_t7uID_>G}^=-6Ta#>T^dDxWtqx=cE7b6)}0
zDlB8zl&n~YBNZ4Nk6zX#iiJjBC})1La0>AVdTFTtiGUJl03xi}f?!?=wM5eg^uxV8
z7gIlFdn<hL*UNS=(opNASiW}c7Kjz}e4vDjW=PF_m`!)ZP2j9w;Li6dZBQP56=Rj>
z;{DwX$WQqd%xNt)atQLS={dDrMeWq*xE|36Wbrx^meweB;cbt)JO1IAkHw-R9Ddb9
zmWA#?evbdD)n7`_9lbRo0QQN}3w4sn?<bSMF@B9Kyu6eS>{aW{*^3LKU@x5X;tS5f
z7`){Yhz|Sq;%u(>wpwD`t^>7a(x?_$RWpf+0530nNo=*Tn$`?nXj&K+>V#5)LcFv|
z%BlJMl|!&clA$PsrqtC)lcO41c5Q~)xm$5<Vl+zlu$OL+wPloPdOhZFB=p_XQ~<=D
zJUgkP!88SO+I2qB9D9;*M|4@@dk7DvI=WU4ueV9tGR?Kaqw~|;C(yXAANf-Mp1_EB
z@9%4kw!#_?nx&MA)M$f(9vpusTcSO1-|#c+kG6E-#gSU02z`O7^Svv^aIShv<6+K2
zxapJy0B_V}fJ6*C)Mw#y=dY@=aOHKBYeY^1!x;{LoJ`MQ-r24RW0^<!AF;Eku1UZM
zLpS>Eqi+mCtl<G9b~?S|n4E2?kEiK$^cpv7U<~4AH_Jxp0s6(lUf|k0<bmN}&tLiM
z|6KB8no`d@qOF6alosTinK1*_2AK-ghjh%|@$uVbQGnUGpXm+U?camdt-qRWZUe2|
zzvGQTI6|vDpE|-NZ27CNmg&J()Uzk}(-ly4AZ#6>5joF%qVa`NY>P|r({tDH!FWwC
zwpA@(NRg`=WS8yR<vKI%UXz>QxS(5<cO1FZJXUCRuqT&U8}IlR51@w38Z+zG&P?Ko
zxr~(ZfTMzl@hZgQ9DgUyzn)`Z9C0uvZYaM=U-nfsrBNVTRF2|9D|AuVJ}^(SwAJ>g
z^OSfNM*+7VcTl@@xP)<F7gqnOJkMyaDmmV(@B^SiszxLoey*bZaDRkZ;TI+ZwOS%1
zCAqEopchv|_3hXCveH>cmmDB1s=a^&j+X7}{b&m>7Ahbw?6$w$!_B-mIL;e>h34D6
zw~RJYTSBfy^!%<QCgS(y3E`m{@#Q(E8(|!T;(AVs9Y|-Esi#K0D_{8*Udg;!I8t?0
zd|(6aXy)f1`O6$l473NgbGgLL+|-IjV>d}8q%Q6mNwT9YWOU7nzfSP~9O>tgt?-PW
zDp{#<1_T!Z6O&vV8dISNKymYRcHze53PA~8Ql*?SvWZ!|3`MJiFX@$Ci;NQ4G-K2m
z_2GOSbf1?<nkQFFGYQ~GhqUA~m5`xUn2<yrs~Lg(8u7klg4QTpimEGb)?^as3<vWC
z#|0|PyzyyTwVrJazBp}zLK3wj0FrD?cqa#^8i*%SK49ri>-F83Hbmd-L9`!@?S;YK
zL3k`)Up@1ZmUQZk(xLkCr8?KT?+atSc5X8Qm@Ae9$0HIp@-y`hw{_RgmZ88c4$Ftt
zLycb9!oPXfxFDU2ebNYw_d)Y^!<OalS5H~Ipu7<nhb6Y7!emiW30f~&2~Am4$?dRP
zC8$wTU)B)~|8tYZyAiGNGGBQS7MD6{l;y&NJ}giDsP-a+f0VI_n3T;9IY@`y8#kd}
zggnO0sBYo~8S~r!+@AO;*Wf4jGzb>%L?Td1)0!lp>E+_QZK-$zB^4WPg#bsK%wq2g
z>K<*x-K2Eyo$J0ugJiCTc3qdQ%Cqj~xDw>$#2sjmAeYe^kZW&M{OB@D262}iym+d2
zIx%Gdn<91dWp8VqA>q(JjK=`%l}rV}Z-oqGBih2cMl%r>_&drE>d^AEs$^)T^RT^2
z+m9>SZ`jwD3j9&mZ-)xs&oZOSkPYHIfI=w$AA4^Z5Y^lDjn2T(-GX$70@BhA(n=#K
zDM)t@UDDDBNJxi(bfeNGDGk!y9cP>WxP6{;zwh~aJ~6}0?7gmat?RdXZMgSbBrgNS
zJ~uv3-*RX6zD`-#<M~@o3k;#foB;IW?0!VyGM!MZeEj{V_t4Os*jhdkc&ns&-{c@g
zJUf(w`$Pv`^VSl$y~6+UF3a<+ygmOn!#)IBn`WqIoSdCj+s*E_Zu&V?1qjt<;*lef
zS63_Cs!<`4b2FL8#X@i7Mg9=`L8jWvBD)q13=BjWKEu`eRzQ*JIF_%><6D4;8w3SH
z_`3XS(RwEr*$)RP3)RUONr6hNyp-DOVj~cmV)d@J*1N5-YlR9*Xj0Rx3=Av5elgSo
zXNWXX+{nEL{d`%s*(~Lp5eURD0m;Cw%nPfBFLWv#txA#d#(@jG9lzt&SZj_j@sy<e
z(&~6xm!t)`CQ{sZib>$$kj_GUs#l%x#eUCh2O|w@vks6)(e}83e#n}v>n0>{_W>PF
z&jM3i)=+dFw0N28-W|~3xTo`U%4jZ&Gt=_P-w$ZZH4IQP+I7CFXIYF|=J33tH$|Pv
zdG?(1dpz@tDR;d$NMfvA?h$A}pjtvpOB#m0ygFuwQmGOKaz?QIRI1~L=-T8!9ZTt1
z1S)n#mvb11{)3-BnfPbj>P<{Q$K8qt>T230P%*P|rIP_0fH_!ZGaly-q(XEAblLqD
zxo`%_xc1j4<@thVL#xN@Q^#m=rmcL(-fMu*w50S>lD4X=U&PkeUuRk_*IzA$$ea(Q
z7Z^?Tyr!gG5Walo*mWaSZ+>BbFgwM*l|q_m<#Hr@8bDQkyv$rXT=@q0%~7&AG!3CJ
zdozwJ#J_FvIH~Dn+LWOhd>K35RyHVdRB<Nz?c20Ds_4Dot=T%|I<h=`%io>T-xcRa
zs=?XW=QOZu$Y8CF4fCZ4z9ve#R2!9j)J#OTWCkSR*!uvVe7Pf;DV4@xRxU7px2dzj
zxIHzyFqTA6ysab-`K^NgQpUh51{fz?&u&`hhO>O6#apXfJyLG)Iu-0S?Vujjg#3eX
ze9jNEX>lLi4CI^0swua!*gntEMOs-#?{1&;D7qb_L-d_RmpU+1dz`(VGGPb}G5L8S
z^qK(fx?*#$GLDP2G3}cDYdPTX_r0z8U}QEA<v;j9T6^uxdGJ+8HRW{xg8+ugqt(XI
z&nMzR#A}<}h1hq5aF%wD-9N6fTk~!-IQ*IgP`{qC9{&iFbxINk?!(B#!8z-QFEp>4
z3*N;bArJFu{j5;_ZUy^@B3HiOjz?jx(Q?||d8eTK^eGk4yRN>J9UH;C^t|Wob}wKX
zcK5#~F*a-w25JqJU{;>>RrZK?C{%h*(k%-AbT8=5eb%omS@$2X%hJ=EOY=tliG_e)
zX_i=L5!Syl$F>z$fqv4te#mS5rA;!ws0g=Nh#ng;(W|5A%Q4lPC{zp#*~>ItSC<wR
zj1#z}kA66MuX@L!j$F4SI)V@D9lzB_koUx^$-ZCL%V;w-89ROIbBi4zV@Cb#f*__U
z!tWrr4-ddStuK|zmwFSK73Ubv7e-~vP!8f@CdZ)OSbf#FGe56bRQ-PIl77kF4J3mK
zQ4tp#X?Um8o|aF@>+U6L=v6frPqWHwDkJ_{j4%@7)^u%;41CSy&Xm#qB5i(gas0RX
zLLi$I*@dI{;+_vye;?*I-G0~`_Ia|-!ix8UCU6veP+@p|B>Amqi=-LHsPXbsVonae
zXGy<l;?8@*8QvxYRevvZ`F+oMc<{KCyEPa1ItAlm`NmW5OIfZSdg&xx57Xjj+?OeL
zlS#keU_IyVf+<CHH5zWsXyDK|gFu(K6<{xpH=PI6x*rsZ*`0m9E-!z;h;p|V^=f6s
zT(McoX=lHOi3I#*;t9*sNz;TYec2YsF+%ok67sjQoPuSsC+}Dp0fpU2LA-O=)k&I;
z`u==*KEf3+RqL;1tCk-AJ#xLI4iqzpF*ocHeb2rOWlHAf=f~XM>^@!6*{#zhb>FJJ
zN-ILu>Ujm(I~q<ASJ(euMPEUcG2R%wl1^gL|0ACvypBxmdr4Q9%QbZJnbW}N@AmNT
z!-$(DJS6UE0lk&=6ErN++hHP_7n%~eQGPrK^7g&TrIh@8P+CSz|MG<E;q8^hw*s{|
zpu}0)(J{y4w4S@?d9Dt*rzdRAgHFvm0RyX?CUl*?aK~d`95O9qKqlZcWpXH#dCiR0
zJ`wTRMhN)JRLUCvi*Jci0H}SQU`kVivLhwcaWnsBv;U^?Th(Zz`{lQGTD)7EZibF-
zf@T-XejO{bMAOlky7v-o3pSIs*VhO}<0V#_fagi<Jbm$KYV6Qr=;r8TN7llciwhUP
z-WU2d=znwJfvh?%9FSy>Lt!pchffr0)-7qi!H)sGJ(HBmda%B;^Bx<_L4FDp5l5Yz
z^fOe6eyg}6zlF*7xyGS^pP1S{YYN#|YPPQYHAKS-M;iS^(MvGSOTlT{=rY%idE<{#
z7{yrTY~7rMx^Mn{gZq;4#?;Njw@P)tWm16@8x3~ITUCCW`FV}0LbdyN*U3d@*w7Qx
zxu)8r;2}OugfIU>1f?sO(x$p$;2<4z4|KA4p9}9}n4wFS8TW9x-kc`@11-2?Agl;C
zsn}r1TUyqkq9$FIR#)ZN?4Q+sIaC?m2y%k^-iy`&;@AczeqB@D9>h<7*=zrB@e@N@
zsw|7u_8Q?A6mx*0RTNsQ#db}<lc!IeH7z&0L9uvrNWz!w>H&D*6`8cdf3CmcUPjN<
zI)U*8OkJJm!&fz$C&GTgo`R)o=7>Oy*(MeWznYZu=&knFR}aC+^V+n7*58G;G~@t{
zMvOQ#m?i~1Tt9Zv4r|atM(c<O=eO#i$MfkRb=O4~@_5ggTIzKS4|E%?a#Sw&5JZl;
zkJtCdayKj-y&GruEH~<+EDTv#!1_}8d{Zu^XKH`=efLuYHjX99LLVR4gL%Km9!=BN
zj7;jx(Ex@c5V{FA%AY6R*#L})n23mybw_>th|lwv_WiYT`1i~@&tF(t*7prqnSH)U
zM&0|wtxF*<e^@cLy*-n_nNPmi>N>fu`EF6}riV!}k;Csd9{mt;VFpBE?<+SX$W<oO
zqa`=23fxb9cQ9>&gfDXHj%q^o9T#b9C~Hqc2=YY;PEMkuJ8LewIu3r>kTQ>jO?ON4
zY*r9t<q@UjA<|nt4U{cs*I(abUv}&+aDIap;d4Y4HF#q{(y-B`mH>+<VW5SO;V0<4
zs)XL09)52NX*}B1;Z%@^sku6c>}kgk+D`T|h`W4>g$loPG9_e91H0s<vS874^x4Tm
z?W(ECr!D;@d#`khx?b}EJG;4$-+zb<(8Pp)FOQ&cjf2%@u+HG=6F);%#2Q_40hfOC
zwjQaD?W*^U8uy~_MMcIx|1}?B`aUM2%f~b%=40#dbz1P68T)N`%w$u&>Ke)SwY-5a
zGWvcVWK{&r)|^~Z>o*Ew^}n#Kr3i(8ujT8QK&7(6LzA(A*X#aPaxgX*A#qgE*N@dr
zn@?wf;xxmEDAmGv<5GTEcjqm$gl`)AWM?})hutnY39*c_Mec|P{~uBhU=%j4My*{w
z2RFBj=_={^_BK;178^B?k%}VC78-hadm{a*6fxr|j%9WUvi>egkYOf4!mkK~(gloQ
zdPmXO@?8=$^Nbq@957%xUGLtN{01Do;u-n*t=dn`V@gVNztmP3(#qTZ8iYbVF9Uw9
z(t}2W8`|jui!d`7hja-Y_2*#V17f;>5t~wOS)vQnu!hklDTRu)Xu?+VxXH5o=O)a<
zT%MAZVS|sJ;e>$TR#za1a$>@;XV^YBCW5-`RMtRkS4hg3rVpnGG!9J5^$g>OWaN-%
z6oQuckTP(!?|d)I6*hnaTD2<_GR70X^`?9mV_^nlR%N%HT}HK9O$o}!Ci4T~p;})d
z4PSK+0l4|Q84iGbw{}LUbu%8ZwvG-1?<E8{w<b@?9pCB-xUXnBR~$19Np8qBt67Zs
zv}P!J2r^@sC>xRepylJe3?}f}YNHOe_uaM4k!Fl1r{Scm3+*Gf%t>VoPTz@nl_5+%
zpHNVMyg3=8Yxr+ff~x@K^9-oSG5$AEp-;&1!;<1aCz_ttFJ91hKNx%tk<rulXh|zU
zX5G(I_Pef3)6oQq#7bXuC`>cD|6Ef`ILt+@mG`IB7@&aw=F-}C-&^IS_iMM8*Nh3g
zNfCy3zYA+V(mf4*J=xC|vTora|EMznVoN;Vh5(q#_Wa`IFI>Pa7FJg;9d(w6Ai`fu
z@S*cY2s0qbkroLF5|VS0v)HpiJGAgJGTW^C?i2xK5sh5~sxsv-f1sexBL3ij<@MFr
zfUOQ#SZExl@Mh`Y6e@6|EqH66uRNW6MEY%8fVm8AX!-Bn&6>B>R&m6h{9EA3>p{*3
z6_;fM|Jp;Ja@;$_#4$iH4QTs)9Dkor+zB{AF8sRj_^3p{2%W)<#xAdwx4Ke(kYVrm
zZKnp^$hCy{BeK)3i)SRCe&wxLEnrSeoetKY_#LrtlQmmjSy<j5u3D-vaua-Q$o9Vd
zJHY!q!ymkz)o!}NWO^uH%CP>P<{u#l0M!iOG_W$tn*MH7{*cKbz!G=t?v&OjC}0E%
zee8!K{3587WMJ~aUP+Si&$(_#=K0b3rCI9kztbtqR<l2$6M9?ShW}GC=>3HcR!a}3
z1tSlWUY|`X%<LY~ULWdh(u8_?Y;d_-KYO}J9P-sA@cX@>fY}wn$i!4+@yJd7KX%v!
ztOlWPcwqWFtoKuRGU$QY^t{T-${sAKqIlOs^PJk+#~Nde^m8)2I+ZX)F5F+_u97y)
z*n~Z%i*E9d*-B9}loZO+J!kj9-uX;$JdR=bi4i}#xRo4Wz6zz_z$TvAKO}nu3OU?E
z{k~~F4n8X@w40OBJ463xw3)$OT%PtskZh~nrX;UCWrEE{z{cC&TjPO|V2C0GB{J->
zR0BA1<2uImx)c(d#y6#&Njva!W%_k6wccaA>7y5kx<~ec*A;^AOVXGU*lZh#?{+Rz
zk9_x<>3PA|shUk5?>IO)H9W^Hq}}fSn{}*wFhz*0eEq4vmHST~0@01N^)D93p2r);
zPxSQYe1wGocPoBjL1`!=1lVPM7$R-%F9jf+aFc^L@R2l~Fl!p`jQ5kQB$z9<)8~ui
zt=TIszXD3bn4L$i{I=}<tM2CEBV5?&Q~6WdhHRFymiOPq44!TONaNEZ_;hz?5ZiT9
z=9iRI1{OX7^>b$1-4QbU=d_b)@_9hX_x3t(PY?24{AIrWdR2l2wD|*y=aGa&%f|4{
zHG=U#nkO3%&sMVFXDo<}GWj9kxYu0w9&<#KH<rj4mk8O43P0aqWBehPG7{wWd(9Ed
z0(styz&6)?&G|e<qUSgM9X)dBGJJ03<x#RrN+yY>0m;|W(m={Mntd+m{|i;VVdO`0
zVM^f#4YEhSy54^SbOPd;hoD8*sYDo2hZ`=sRFUx<=L2%0a2aZB&d7J~uK7hkJ|2j2
zxRpXp+r7tclTqg@Wu8E(T7Q;C?%*c!oXxFUyOlMOOr$r>2vRx%jl>aD-^V4nA_Ltb
z`<I@X<9<LWK~g>RDAEAvL;Eph$Ls~wk386KQXnS4SO%zO){6MQf$>#@u%lz#HzjQN
z)nngH*)KrG^wmoU_!Q9yqqExY7N_DSmljs8LEwEF`{dT@XRV~jiW9kpp66*&KhJh2
zC9CaxBk8N_-JOsan9tQy+u7+%!zaC~a@OoU8505Dn5Fatn472V=6?DJKw(W9yS(gA
zpY;Et4tVAB3>cgQ<WnD9{JW_T8U|_5E#=@CNzz;}2bvva09$2D&K3e+yC$E>L_@`D
z3-zMB@LJ694x)IhUM)BMR#~W;H)N9k=PWOuFW8;S);mYMNxs+bJCdqmA*@e#X;#0T
znrX(2+rB&|p@^6MOY^N1Uz%^BN5|U<8ZYC>XD-r)SbnbXM_mPr&xd5oWlk%}e-j84
zxM2?7ZFWCBd8+4X76G)=03G}JBG>(ILX1GBVS*+lDcXjayh&5C0x{}8`OkU@v(A3O
z=h;czvb*)3Y<RP`sBvV>^*ghE3HM)H6#$GU%h>yr`sdsr45ArG&kfoPzn_D!Yg&>r
znZE>W5wFKVfCI)!nuj%r{`3jgQH(B86|6bW?fE^eH{y@#aMGC?t<0bP`oh2UQY|(x
z%Bp1PA<GYY;V*K&zhcK9oNo{xY#L6*=}kz+oQE9bj5|lj^7A^rzMm9n+y8ZB@z;qk
z5!1g~btqYt6JowJb#=Se9uWVZ`o9`LA)o;671V#-?8jSNC1JlKTJ#Y`dH6vq9ud!^
z$gb(ftBJkt%GC-vGb2>L*{6Ko+o#H8p91u2ZAkt3R?`eXXCU7kf!iNh-hvC^XkoDj
zHQ_8Jr29j)>s~#aU`?RP|K(?#<91#pZG8(VC9#ol+j^e-G~NCV3;@k7+Q6I-R)URG
zoPY85hc;<I;Sq5kmPfSVeRb{v6dV6s^t=gpb=T)eFa{K5^;?7fQ{9DX0>}B8*XbJH
zANS@t3=xROmbDoNX!R3?4iBDz+Crx6BIbW>$cm``m8sK;AW!;r(kbs#dyAg@zJC;C
z|FxXnMqo#PeCZ(U-w(rYY7XwrLk{JMKco}m^4LCsI`ura$YfUV0Mv&5FVdDMS-+U>
zeXykV?pM^7J(as9{xW6!XPH98)dJQfiZU$t$7R{m&O=U(F~$_p@q5#7qn?xZKV;kf
zVHE<5?~Mm+jPs?{r9*c+D)YZq@V8g<R)BdpeSI^?_vgis&qFSa6%hw<<Z;D$jv+q$
z4k^Ey<H+UpGY2**LkYQgym5@CyCna31x$KM;0~c{eVK)Sl;B>u7NnaLehU37R}*{(
zo+eJ+pJQWMwvc(eVS9HpAAUD-|0PGjTfo*9hqitB%=SmlFyl$1!>77EfyyFCRR6?P
zatZSDLqTH%mVe;vZ$Zp}K%^n`KHSk1e`C;J(8KEKvoGRH4KFtrL-oV`NtE^3PhYqH
zLeT%Oi5tIu6o3z))L>iXzhWsrJ{EqAWQ0sf{V*eMR+RTUf+{V-BncMEdUT><{3hxL
zQvH1U86Z%a>VIlq%tpqvN!(~<`tv^g7SI*77QX7-)vZ5n#~)YzYdJrE!HNg$=-W(*
zzenx<%+Y@k|JPSmG+K5~5mstYQop$g^dvsg)GyH9Hd#GhM-7esMu9Q?U~}^n5ohy2
z&t9Kt=YLSD#0As-M#Q3MXifUd%OszF27rKX3qMDO_>JZ~WR;9lh2nwB56b=sH-BdG
zUvz$Z<%|T(B`P`foBeM%^Djnye;cI=h-nf3)<4a-f8OMO+p!j%Z&NHcuQRy+gAISW
z-5>sEgh!4=&V<4DA3pp4us#2#%_ac=yd5{8HMBpTwEu!EO*m;tXLq~8|F+KmjhJZ~
zKsD9RVz~X%Hvh#v|M3-JH9%zle=+#~#o+(57@W<FlKh{DVa0vS$POCP$Rrlemjfs3
z4}XT5l=1gm_@8;Z7I!dkw}1gz6^=#$rduvqlh6E2Sp2_(6W|3CU6F--K>`h1`hERz
zY7<d>#1FK3Wq|%5PKp*j0-c3a;NmT*->fdWt<>Kctl!$;--rF@2SAi1SiH^N{#pMI
zFILzG!odJ|YN6wIx%HZ0UI&<bLlXcTFP8rAz!3-zs@D$rgT94Zl+Xc)d(~dwd*}ZY
zqI}pegF6hd!=h1@;H^2u#51-4q@lmG1_LwE{x?AR>(g!tVLz&$LDW}u&=S-ZQ{DXL
zo|k|ImWIr`|92MwF6YCBHP|BkGkCO24qWA7L(fYrpM!5EK*OB3<R5K-|Fmkzm1tr1
zU8Z{@h*@HX*yO$;rjH%LynX3(GwdB9m>d>i%9dNxUEX;M-nm<4is(+#awInKXS+J?
zyNp^nqavz~YlA0q0$#<Rjd67fiVL2kWRA>cA^JvXMEj!>ia)zbUv2EKU7hxfO<9sm
z>saO8C7rXk+jX5gJr^9f_KtK7d<mjzL1cybzxWdanz#!Rg8%tTJQVQFcA>^;ifIp`
z3I`++QE6z0XCMJfA94pQ3H?9)lL1TznguZ~S*|`}|3;hA8?5=cCS=b`*MpZWo{=CN
z@XqDaUL2$UtBZf51|$G8ZG7h!X+FpSpxYDGys5reV+bQLOdQknOV_slmM0SrVMYs7
z;plQ1pS|L?#uwGqZF(I!!PTDST3=fa4AZBqjEVJZY}40)xYQv3Pu!lk<C8(I_hKKM
zRjk|O5f|biIkbTKjd7G9A=v+xl2;Tk*;l&FUiX88k$sXmuUds#PzqEYlP%!l&-#wM
zlH+k^##4A*hiEH>v&$E73<X9XxqcR#-+5fzyCZq>o<EUmThYfc3C)+!<bU9-53&!m
zu#ny3<coN$z2{+HlFfo>K^I$U7a&7;1mI(4yN@4zO#A;!i4xAI#3a#yoqS)4A)g|V
zyqypXrg-DEI9#PuMDMMC%P>*3P5&XC$GWPik)R9#8)P6(?f)n?kd3fqmh28G*`Il7
zLq?8?y=d)(kA=mVh^UWG!`y<XqWw)GZFdC*QvW+q><0O0y@!2cJ*S3=bJwKov|-w#
zv$NOd>MplLQ$+=ii)%gD6<rA#3vmsHAOW#ZeJAk42V7&PTBO)xzAhYL85wx$)Fzee
zch%4D!p1SG`U2znTKY*kLPsQB#91*Jd^$n9&D^(5hjmKSN;TMjUkE<=UJEQpAp&%s
ztgeA#ZiDsf^kh6ES8A-|URqje4R^of@75g8!y=c8B$bC2s+We;AP_N{ea<dH3<?Tr
zdn<prWY^sSdj{)qx}#%^9YhG0%<!dX5r-l>wY%2+cjBbvgm^?Y2=8|KJfEm#d&*h=
z_9hn7nF9$Mn_0v}GJ;Vr)P;&LL&1gh!x)C2Nnd75>zkO)(C}ioBh3moj3SLDWky}A
zk`k-_Hf$lZL}^g-&4FU{r`b$n4jx`L->20(xV7QYk-!r!KnJMvD?4rCP|6vkk`I50
z4jvMi669d*em9N87G=5++`!(5{6Z+hRk2u_XHOeg(hpb>LxjMcx29MNf&&7o_4`ws
z$pr-;smiTm>EB$9M#aQ1AL!`l%uiX<h1s~c1Q(!7tesZdudWQ1>LDZwUSsgsuVm^H
zD(FLYq#)DU0{iDI=gxhb+;%pR@5;1=JH?@Pwka-A-&ytw4Q6z@P}Ho3Or>NIl#8zC
z>+5kGdACvJQ&kb%jxKXlbUbW60UO1k3^TiY&x(_6>7O|*973s-BV%kf%|q-f=F!^G
zp`$@psx^wm#%@nRC2;rizWvgkW{roYy@qP0-@B|&BqU6J)zy4Fs>QxzEQQc4WxSR?
ztQt)l6sr{iVL>l8rTojW;wdMNjTpjEoPHgBAN97@u6(vAUw81c$2Jw1C0V2FPi%54
zL+OqBynACCRdhiIcGfKy#|Zj8EA5M#4}wqxWC`8B8jyM6GfzNBc)9#{1d_YbV1o6P
zvfc_^9kpwz>2o8{u71bj-|7PQF4%jno^|yaCO9wuy|~;y%_hnGAz1;4NXW$C7k)6_
zgTY2>X>V867xss~w{UJt_qO`b*!GmNSQ5?Kwy&>|ITl1O5{dvh%V>omBexE%1?u&%
zahFgO1s{SasVqXzEK0+D8I)Jp357FSZ)XM&IV{h}kG9w{Ro=R+A82ZnEm=%Y^|Qp?
zgbpL&fJ6OA$MF#T1L1`S(nx@Q`O&rjwDvYYrk2UT*52HCgzFfB;GF}b&bX1GnGm~F
z7(p=UJlO`#XJ4Jy<TX_+(~J#hs|s&L7efx#1GPCtBK}9!=pT3?a*2+X;TlG7<K*;N
zjGAXcUEwZA4GDExBPw52M{AnEe%t4`R97LmK_1`g1imxXQ;^;8HRxtI&fE-1IVRZv
zES=ctQ(1Yhv&qT(dD~zb7M9pmfxB;gN*IT6*7%fxGvoo~eNJV;1`e$=!EW-GX`UrQ
z{{ClO6_YQ!Z+mVgt)f7fgm{!Tje!F_`-ZDayxlF~cj3x*c0J1+d$8{C<lT4hD0|Zx
z5sv1UpzDQb(x>gCVail!llU(TEMtHfZQL!820i&IRyP;uB)?PU3_`+eV*6nhsPI4>
z9sv(K+Ri%OnZYOG2o|=u4O?gnz@26)U@m(kJy^ZweQ^XQ0+Zq9xZy9VJx#baRZW6=
zXArB?ER33&S=FZtgiYkpsE3uOSIT*`#@{gVmVj8}E-B%GXe~J`kBjT5SLsO9Lc|Uq
zWY*Ie#^ZcBWw1m?`3|2GPkA?U%lh!6(;0qO(U;I1#Od0scP471k8D3%JU8ZJAkgk1
zAgU}uW6ql>#XUfeN=-zs9xCSQf{i1E?oE(qIOM2^Ixo$R&LkpcKmyud3L}vZ=3W}I
z=ItsER;jY=e{nX$(Nbx+EtZW3y@F3^(9C$;%P=sv3QzYb<X>kOiigNEPn7;DjErm;
zr%fqZ$F;_&fRKfS+ib85ox=(nY#NPg)6CEmivaD+Q$j>O0v`nH2SYN#Fi6H~$wS%(
z#$gM1`H<yyGRL6@%pA9Qb#E}|cf-eShj4u1o*=!;3k-@Kjpk8;d)M3F<TdA>K&=QG
zXl9kB1xHEwr+aCmY~Ie6t};*-sexXmvx3}C%)#MA0b)IBLudI2>Lo@<lpz$sT~p%I
zL*ml1eZGO=8^L16&eVD03-)gFE%|mLowknlfe3t@*u#9@f@l%M4=v0JOorW#t&omp
zB<_^zRE)oH6@w$<D7xRks6-mgNp0aC*lnkEE;T=98BQ==@9e5qd^IPZ2L7R~fX$FL
zos5s?R_&i#W#%7g-`mY&I`F@AtV08@aq4@g!s6z=9!N2dKm287fm5iI@?-q^rZ~nj
zn313-;KPH1R;<R5n3{TZzX*~PXv*E~IkTb*>$w}URQ`M}c#$*+5qAW(qnUL)BB)qv
zl)#<rmCM!y;WR=4HNV6YuQ2=vHjCnvMAQcDm@t*dXX$=^#_pBNXvuY0^7_K150vts
z<UAp%t4|^D50Gr#S4OaDe*E=gmI{KtfvJ{OQ~=&q{vA)O2(Je35VYqjF9S}m!Q!^9
zcOPVyPD4mc8m|s;%G{1k9)`odgg%7uI=%2=c@VNTxfWWRiNAWfGlS){#e+CrvaF#U
zgkp|mWB1@nRM`8grQ0WvCF(;Jrxr3bPg&<DOyl+kJxiDDnNFT-qt}n~fSy{x1n<K-
zj(el;%gR6)`z0ciqq1eY^R%6va>~p0{#a$skkr>bEDN2p@0Rx;{D)}{^@bAgAFEg+
z7QcBXO=A#abAi1z=Z#&Gt>ag?K2A<{KgQj?-UoxRCUzCdWoftvlC5CIKs^c^r^5)s
z>v3+oaJ<Z+?LHp8TU<9TDzV*-KIzxa=Mp8QHr{1-*_RSv!>*S#v#9buR4IZk5<EM*
zBaFO9-6Ti~lf{mdFxX!3>9w;fB&V*KV5DWWUBvdx4h3mLy+qrO-$7YH12^L>21!5W
zqZXt`u(Q(G6#Uftr8_j}f=DR5sEvBYfbucI1~J5W^I5>9K9U|wVXk%YcJlDXlT_&(
z7=TR^vulweyFpH1)*UURquH9d%hGT^Y86aL=088Tgfnsa(mGy7;;j2G8{vmu=7rfJ
z$rzznMgM6ObYp^bu!Rj4?k93?Dh5XiAy7$WzUinUij0VRd|Kdss&*iagU#G&z+iK6
z<jR29mogsP?&`{|-|E|JusJ3+zqyHI-SiOtG?HKB0Cn$+sZf?rysVuoI-o`feRvHX
zu$G<1<|x2Ku`*$#fx9`epwmjHYhNVWrdGx^*>CA_B-BzAv;B#vY4ppBvT(&pTI0@%
zO(3rj9kwUoP5M0$m~~_Vu&8K7%nSC#?imXxFBr7DwRey;LpmbqS_~r_KN*3P^$ELV
zA0~j`Z^9AvI_7C3MZxH^Dkiy5v^sr2H?Ci4OG|5F#0JHw$H2TgW|-+4#esn}7j2*5
zii&Xp<Fj1im&|pl;(sk8p`2e|2$R7{Ha*&z;j^LLPb7(m3HqCr^$X^p*Az-DZ)pJ%
zAuGMQG_NYd!v|6DF7?tlRB~Q6SghJklr4a$^?-+UP{5r5#_mM(E_IRiJCx)MI;a=y
zB;v9$?;sI>wt!ZB0cxSz4%e7*tu!6Bu((SZzZxY7ll1v>P5ApIvDo}c`8A=T`>Tc7
zNGN9_txdj|^ZsMa8)L=b4#iZlob!WRkfL~WSu&UnAI>Gib$=00y4ejaTzbu&w{w66
z)Urwqs6>~?85c_u&<})2FpgPRVTO-vU_)p=`M*^04?+-elSDVlP9Q5ZfrYQ~Nt|GP
zaKHSC^-G8_9IvBQ_C-BT+|ISs;qK=gq~2TCMm9~BRA_dnwP^`7LC;m1IO5~8x$FJi
zXvBy2esKnHKObP)2wPMO&Vr>;kD#g3_iExj@#fUSn@v?wRb1k8LWDoPM`)Q6Yh>P&
zDh1ikvOs^DLc$TB9@sxe54&WfgdruhQfl_1F4-h`oPWfhD&(zs2jku|dna|vCF!Hi
zu?kqNr4qQ3l2M!HY>;HQ8(ib7*SLmgs7HQ6x2X|JJD|#PPxy=DyJ2ZFTjP{vGvF5{
z!ZY>Ne)-CDU#;U&?&;K#>bfo~vvcyKV3m18K1F&Xo;quP6t=f7Z70yX2YU3z`(%rz
z%winNWijMt-tUtrHAN)Yw116hN3S6f{`{QVR;ce0W2mH7M0<m4p%R@!)||t!Iljk1
zSLEJ8(7@tpVg)&D!_9@6%k6b-RBBOk0u%QKz^_OpXU!WJ&dV)Qb<}ITG3~62w;CRD
zcRLeK-^mKEdcJD}y3Z?_+d}vfY5-XiUY+wkonH{MsBMW9VvcSn)`!SZ0Ot)(&+`~x
zr9_+1d<->k&MO5ulK+5>G}R=rz=X}ZGm6v~A{_MW!2_(llc}$^(R)c<ys7z-EyvR-
zQLkM|rW-5Oj*n%N6!I5UZoG713WC~d=;ng-ZqHyom#j5wr=&etji-faM^F^D@F6k=
zZ#Z|4<H%OH?}Yu!5CVb~K6W9XXi(>8p4woqopYZyQ5O-Pn^s3vm2NMqHepS|B-|SB
zb5~em9-Hn=*SR{!yPb^ZLs=oL7a==?d5>%I#;f%#-mo@1D>g`MPdugI6)#k#lO|OY
zWQ0!@bi^vrYi7tzLXKK4m6ayy?CuT-4#qT~NWZr%B^ihe=Te@gr~6@e81MA(YI(uL
zbQR2yPJllfKP(5gmc*Oz3RyF$HgAIL<)t5bTf3-=3Yvpynpqji<Zf6nB0S3xy|8#3
zWGjO|3T!@(?yuYUwA-fla^2c54U`R|GW&`?T|{|#&8zp)mgJ>tK?40)y`t<scaqCV
zdA@mS2LP#fh(7(>LBfrBE3~F^%)1r#Z1Z*-4=0?>vXp4KRNuJgE?{crM$;eYO*>6A
zxyR)%7Bn;okOq|v)=_THZF{%AJ8LZPATU+GbGUZf_1wES8Mccd#BN$81DjDilI-xE
z_EIify6~*y6jpbEij#jXsXGFa6{iGQ^X)O-hjd=@Q&VQvg9Y`L;Td(@Dfd0HjK~}|
zhk3}}DH_&C?iZR6Iz=*I%E(9gI9C=?-MEVKVG4F8`H|*Ck55YPD03NBP4lALp2Fp2
zr$xvRt1n!ARJK`M@~R2Dy@w^6W+=8z%wG=Yw4+nlomr*DwaI)pq0V<U+c77Dm5f<O
z!T*pzLG*LL8QXQrAj#d2GcyfuWP^gp-&)CftU8Y{i3XM_q)uYozPRxVf42Un9jQuE
zf2lBn)ui*jOJ2|o(Sp}LdYQ-h3u^aE#5Mf;TCjRv=dmAInYGX22BR~O^*r{e7?TQ{
zWA9nzK~S8wCSZzXg~BYxSOqrgvx|}wU9h~)78K8p$Cqh%LSw9xaR-CYM~hOjXFHRt
z9IP3(flB>{N6<XY!qGwk^sk@Lf(Y5Y;zAGKCn9<r4awFZEYoVeao_LbK8${mxhqnd
zIAh}|nW2KE@$MND(8S0(v>L~xnK$qKc=UFmJ=fr1iIDY$2KPw)3uaVR>o0cF^jC$*
z&-|P0)k|l=ulcxf<~oFK8<0=7`AVM3xxkU{M#UHzFSn?2OtiKkPGcYf$5etdT$W+A
zWiVM@wX-{T*KvEcStah~#!OEO+np9xB_3Xrv~+24X<YB#oOroYgaehP9MxVgyEPSi
zl|ZHS94hcstneVDcoM{9t2lcm7#Q_Z6J*-maXpJp(0lWMdCKTcQ0$%r^{_c2JlY0)
zx)<-Gn*#x_D^y^))oRu4c%Zfoc-%0E@SPYbaBhL>{0DG&SV6ZcaYnMcYE8Uu-CL5K
z=~`GM)5rpArW@h<dRHF=#uz?z;Ca2dqH!bzEx{Bx3sYpXKE9$o=m(?W_C*|+c}w$3
zL^C#If1&<wM|YYVk^T{gBVUvnbf<h$!8I~+-A8SQqucC@S?l%T06{BWrHgg(bd4>J
z$$%C^1K44ANKS=}vyLxYyT1i?hQlI-Y4|`qEjSbzFaGK|d2KECVBD!I`R2};jIOTW
zhmSO(Dl<wp#Ve>06He4sBtaiS4$8>n#iMOhI=w-+(b)?ICXeHKx?&+%l9`*M!a00W
zA`!vCs3MB#t9!4M!|xf0UGh_paJ$0OV;DgNJ>T!la9azaUY?|>D9X{9Z0$Z_bh;#k
ze=<E1hxpJDGdBXme7bK~!^ERvL<O(k5WqZSe_?4Gp0jiF#_2mLybRS+f!u)+mI!S-
z*PHs=LZ9MhMSUwR;o<!WEk5hJh0i0p^1p9?b{q_fd;CTB;cPTUGxD$rKSuTL8dKti
zlW@>UcU>TEw&SJ-j`ehgpB&&9zMev>3Pn_+qDD?7=0xUetPl6CSdC~Ob?A9D7tFs9
zia+<LL7*_K@IXjs`ju<94gI3x=Qobt)Q^^0c09e?$8?xpNrV!s^$%!JiGbgWt8K0b
z47J%&e0V*9X2I1Plmhp*kyi79c=P0Lz(6H47IgB7TcVmEd-p}Fk7I^JYzgJ_0Uxwy
zsofsNHPpAXudbD9^adUb7Cok$F;YzprjWlYh={iF-sjxggEp9;0EXBA@*-Hc-x2DZ
ztM21CMKbRf5`eju>($y!)&MImHQvhkGSK0$4JB(K-P>vL;?vP(6XXFQr-SpjMrer+
zpNdRXm<6YHZi)6of{;DVmk~i;PoGbdd0&;6Wed3-6-sE4-QCW3#U}Z3txyVve88*P
zdQS3l^9grwFj$776nyV3*4}|#kZHQ7IIfIhGraxEl~tu^9HaTNf*ZW%9iM}Umf6OR
z`T16tqhu`t^HF49-Nwlbwp*vs%Fb>fhU47{+dJhI_CwH6Tb){<Wdqiec&MG;Q*j-6
zTSxGG38ZNnadNNg5c;OP&hg>5SnVgQ2`KeOgeCkuU;0UPmu?qmISp~Iqs{TtE@br;
zGK}|aBib4eM$rfZ32@`kdIY~%uMRK;X~~)M!^-&{IrLy8UY_ovD!*-DWFPvvsL;AL
zRGJmQY1h>M3>j>yPWR?W5&7bL9ECh1klTNJ+_Waiyj?@r#?rxYR|&}~i>9R|S#Vyd
z7CTia4ju@raj1P<S)Xz){e-rOCOJjJCfuBsMM1Ar(Ip4B-ckQ_HOSz&PVeQ|*YEN1
zUxB9IUZ!M519^rl3=e(+WUgP!M@H=;)ZXZ|PWil|%((q(2{Sg5a7f?h<|>qDB8`cx
z2IrnFEmf?IsSH#IaOc7Ah8sG|ZyAmtO1Riie-s1nixHZ<xs3QS|J}tc|1o$03eM3p
zpLCV#qS97rY+GSPc<NfSJUWI4IT~V_u#eg(;RV#9f*{=L1bYV#e!X(no{j#H@F&!@
z@+`pFTm#Z{v|MuYVoTA+XVv-&3TX}G;}2B0`npYxzI-MbEONz-lBm%jmYrE6!t@q3
ztZ7%eO#SrD+krAbv^Y1x%*<A0MiO7{8WaS6y)$u2Sbrxh8<*K&Rj(0V#om@BW*q#a
zh*-db&Ew&wM2-EpTiY9sz(sAODQ1$OOx1Jzz2V*T4AmziEB7TRWFx~js)OpH<$W5s
zvooZS-Q(irfuMHE&H1U~eaf6yANYxh8N*E9nwY)PJq!qdGdp6`!z9j2r4|o#wOg7h
zd%pQ>qP)W6=|TL;2lYz{{na-ztojW&4Qy{Q15X;lkwZ7$&9cmb*Dh0Dl5#y~%h0fp
z;N;CALqXh=m`P6`#7U{wUFEh~@`EL^prTR9i5eQzslV}WI;&5Ok1y#hzqC2s*<O0^
znb&i^#S|^(q2Rd@SEbnyrnYTka#|YFaPC0Drfmx=%#w(~)&!Q_%GJ57Pa1_7o8=_N
z-pwUTuxEl!J$h>hjwveMR}RUHX$n^BS;pXq61e`FU2Yc}x}z#Lm?uw;n&|*XP=lY_
zF!Wk1&>;{CBC92#M5CtFl4Oo&vi%ldKEfoAv;j;M&X;$td}m_8l}v(-&uw772SI2e
zTLRJe^smlN4OV)c11v7~_L9p@p}lg4%%Om1iP@=hmjpM4_@UjCC{XbIu4hC(GC*MJ
z({_6+To-5wM6+qm>~b~{-$<%4{FE~|%0@_<HwhW;`~p=~we?A;c27T4kH8b@+Fc0j
zNJZ4sDESrsa1sq=@N;U@6MyaC{~;{|eNCm0h6H{4xzyXjRWiFJ-R2^On8h4=ul9ED
zTFd2frlVzeSe5?acmauq5z~PLiPYoGXo>qzKGW5P-736pqVEJrSSl7sAvl{Vy?f1%
z76pL=W}hH)n_}q}=;5m$z|VipdW={bfRC;C_0Rx?1>WfSg9i+78zW<PauJb^1LWBD
z-f$5yzSU0a1Z_`tbXPxbzktn?)+Fx;hr9V=1JbH`2~VkgCuZWppe^M?mrD<NNEdqt
z5S1_()DQQSy*xQiLexjpP%wlr^1$S)Gq-#mwO6HAam$D)%T(<C7{2Kobze4y#<qN-
z$)oSI;J_H`%{$_dDWu#1Qs%H7iS#AUiKyi>wZ6J`NtJTuP^A=s`UsBa&ztDCpS+&C
zy+FQCY|-VEO}w+cjL|gfqtvX+M7`wNB_GQjOwi#89yU?<;7oSdY+xsW<Krh))$)ew
z=`yxM)#}2EA9C&}1#f14cLj{*D%t5-5bNry^Sqr*jCO|xw1NJf-lgBW7piW+T;xM3
zbBm#J!UA6ZxO7EK@kPxiaw;h2)|s?!#=+rMa6ysVN^va3o%3E_g&)CW*cW>Sakaj+
z3{#~>=T=vwcHu`2e>T-+xI4W-@j#9i_SM)-LCrO}_nq1F{9|;?tx_*wVnhS%;LP!n
zgB0Ap^W)Qn89Voi+bjFJP>7O-M(|icLYrxNUtF=w<%OHb?TyZSIQOTnY>>CN9x!Pg
z%<*DEomrh!IPYn71b;7;)FN68DDPX8Ra$o!4)9WKwv$hsRZ4n&o>A;=mi8C`QFKwg
z&O4eJ8YDKxg_z{l%GFkLZKuKfg&Ug6HCmj`HSVj-+Re7!w*tl{CSNNWNz+_1)6bfy
z!>)mcuw@Mnl*6;w8`DI>KB;9lWo`?_n{>8fc>OImqQn8|Mj?cTfF$ahB?^{T)X*rY
z+L!7=LI^0R#43gc3sk9G_FD0kDoij*&y3o3W^P-@iZ2KIDx2cq>{!O?91YE88wBgV
zA_o|DVC!#B7Dq+tH%dUBKxnHCN4)*uADf8?+|}tP{?K&#RT8tLvse0fV^&yB;ZX#c
zqA>odJOg8ih{z}f>!6|npWD%^s{_TY`6|nlU^0HYU2*#_^{0q+V}eWx)e=w}x~oT4
zv*HOcW)IRnfQ#cWh$qmBDI|i)CcEQE<_F(=?bNuz&~#B3Cp5fGs!P|YuWEH4LG<;z
z{@6NSpnBU@=eTlTkZ^O;OL4Bomf+>xQ)Z9LZTCgZjLYL57G?dVPW6xM&tKd$x;a8w
znq0)Dr5F$Ayy@omJLtp|6uKIti0;a|%9WBXGDw3soXVT#mve1}%*>fxAD#=(!XA_#
z`ZOTbxbpf1RWC1rFZz*+zoM8%=x~k7=dTuP-ZG8k<H4#9HnJjF3XY?P1^QRm7Q8z<
zhwrj2_l=D$+}B=MUZ>k|cgrB~mqCw8b^@b+1^Yj+73Xf|6r=pGQWaDm$-~ptE91ws
zp0Mzwe1BJnC_Oj#g!~MixyjC6-daP}FylcC4M|K2x3#cS#B(M;pPDYc8J0U94X_Z>
zBu(`}l6_+y=LL?cjM)sF@Qo`|rlM?<bynXZxhTv}GLKIrkP$f)>=$<lU~bIvgZ3Os
zw9tZaMeQ4G7(^T~pB0c8H+QeLj*h}oZg60hBzF1IHsb2a2^v=FnA6dd%Msrh0*ik>
zcd4`!N4QwA<>D0lX4L*l5B|s!`h<o<-%~>;^HRxF)w5ou#oCkH%p9fnfqHv-g2Hc!
z{V6aUF)dGahOtc)^h_#FWXs>Q2wT5nek;hvZb#1Dag~;z^R=tH`=jGES|#HeY6Osi
zJgl%T1&Oo@0{P9pT^TKW+<C#m;-!sI3rylA6mc#a+Y;n7(vljMM2oWX17Ub_lq>lZ
z$<Tdj#v+SfvjAdGgYTzc+)WL$qQnw0>DPd7mvRV%N3-bpB2G#Ef>FH$6(@}hk$rEs
z;|W{K*nKJemKLtXhgOsKu<@^|u-2?&0=`EukbHn=lM<;^HaVQ%yK;88dsT0VB<Eqm
z$Y}cfWFX{D*-5(Ieo^UGvuq$*GNQ66KgK!t@qlv9dEC-_$HO%E6zj=6<>(O52)Sl*
zB;UKc{dyy*rbJuWh#>@Jjr?#}&}3<TXYI;Lt6><#LM$|@peD*Wi%C8*UVWH*8dnln
zZo{Q^NT*%lea{b1a)eiDvZUnT$x1<wlkU9`I@z;eMcduCWDiVXV^a>VDi*>XW*EW8
zGIF4KNb{Kf%DVj!hmv9NOuExuR1*`t=Jj#Rk^v(Y@ovRxW4I}Gmt8V$#$l1M^w}4C
zeF1*<4T1C29OX+2oB2JHqa&j)nz19KdW1fi<Ykwv8z%g#kk~=KmNMPbTxSs5vx!=J
zi;2qT>W|48hj|qRj#)?Y-Uy)3>Ex8?NVP8am^UUBs<SV2kP);WEZ?^1dH4C2mFYjQ
zB1kCMYrbuSiKV?Rm0LBCUlpH?GU`jd|7372?h#1x4TICC;-}S0ri*ItrWW8sgFsl?
zbo|E*xU-DVQd7m4V}sD~g1V{%Q%4trt<|>6QEq!BI@EE>(~7IhT|u+qw_qZed?d%s
zK#^R9zJ2az>3whI+#(ePIF)AWsoSY4Oj$(4sEohr^qSy&4ZH*96Z;m?`4(i>R^T)z
zHXgMcX!naV?C94}?NAF?&$$JjP8E}Kxl=EZcXq|cxbKZ|b0cWS3rFf%nQk*6;JASy
zyiD!7Q!BM_zDkB8C(QuRUbVLvmL+ixhoY9*lTG*}eyFgz8iCC@Hv=Vk@_;r#<t$q2
zB7~gb$a=a4M{h)k{i5x7(n7I4Lu4kqU~ehbx^<<`eTfH7@aD{TZSYM}>R9do`?I1j
zd{3G?6?X9Oq;AqURI+;`V+-y3-CLAF-nZAXDkly&$6cPzGj#$6XM3~3qvEzMnJ*H{
z=qP#)3_mr5SmmKvd)%o@Z@#X=)^wcnt*_U5lPnD@2T{r_B73`PvNch?AFu@Lkh2&(
zU_z28<c-XKGEoSxIlA<AyRdW?d#5$;y&pm(Mc4tF-xA^VEKdL?V#%__15BgV+leOo
zsI-`3^^W0jyv&r$!l$PNZmxmYq8n!-&pa5XTg8;zvC8!w7M{T{-j2rxiHEL&Z0(5G
zvG+b?#V+$Oykya4gAK$;0=;Qn02pf~Hj0VWa<_QWVTbjO`RL2B%bhqPdiok91Ptqd
z?Rxdi##DEgv%F6>*OJV=iI;CxM%PA%hLF-oud7nMH=QUv9vH?DtHTp<zre73deSE5
ze0-Xy@-_pr<8%(6c#f!X|B>+vpSY^~@@xB2dVbyLM3jD3X$MV8voUz~^Ky$1W}Z>b
z7TMC7eJKjF>3dNIqQxdO9Inc7IWrE`&%NcpYC5~SHoj>a9PuL4yzZd`_CBB$-W2L=
zXEO2RaUJbGBnmOtEjS>VJi^1r!x?zpQrr8n?E0!W55D_%smYJR3II9Fo<fRfz=Ps>
z5!6%FA49JB7_7oJfjX9qTPW8vy$WV*^k9EIQuG{t{`c^hPoBufZiM+N%b3Ia*PG+g
zH8f~byoX%Sch{hfQY?F5AH38*w523Sn=I0dJuw6!Is?sa-PO))!q@OxG&k3m3R+8O
z&=rXoAOBcQ_JsCZL3g5X=^A8MF6-uFD*hk{6iAota~q)%LQl?5clqG%YmMP;cZ`+7
zxjUs}8r(#FheBCQ@+>wW_K244peWis0K_TCZ$`kf1qo(^lys<MS1`SojW1rI-=$y>
zjp4lO<)drXmA;q1vWRZ<V%4r7U%({)?ZRf37+veg`T&Z=y>^-x>B$Z^5RdciFxG{2
zh66$o6&FL><^fv5S^Mf``V!;ZuSp%7tmbE%E)kgzOMxrF&+rNPF2(A-_@er5Ql|A%
zCiK=wCq3H)t<U<!JEHrd%dMUr-S0c4KUWJi!L27T*d@OKxvD3gUgol{3{{JB36vHm
zpF+L4ERL~IM*-iZMGY~7o%PHn{u5tI5DTtor{@}p{#emz6fQqzS2gzwxD+!wN=j5T
zZOP1XFLEM+KFm*?7-WKAasH}+hJ)@{JN8O7ZgH3>6n%050hBri!ho-5cgN|I*{8v<
zbsFLj`VH;iJM!?7k2>x685&}uC|`6$+<&9nXk#$yeS4E7xu08JQj+W_=mpm;Dzj#^
zuZOLZ<6R);_{iZfoA-0v2_F%sXgU5Yi@G{N#y&B>i}qOklL!i-TUw%hrl^8Yru80`
z;tlGy+FDoI-3RNGkG-jlSe2dACAxDRazy0W@MXy;ouVYX3`LKpsw|Nm20AU;N_2vZ
zrqM>DZDLsCyQ7-$*UzFc$LhSvuulRHvbkQ3mwN=h`l=LIsD9eooWgbXvaY57HNs==
z{Yti}opz&~bZL;0c8nm)%M=rPHV|QH>RB)DRsSIW98NUm-n#n0BwT9^wG}2-_QnVj
zP=6sO0?7~z#Mni@JRxasmTDJY8C3EfdG`Y5{g4GMVYi%IgTJ@4)WS&qA$-t88O1fT
znRKO!K9DD@Nq6#g*J4G4(6PbfK%tGX-(gx8ch*a)zUBRrSDK(Fsjk<)y=-W_3!#<<
zi{4E!DU$F;V$rZ-+7+r-ZBXXZ;^$>9`wl=QkXARqw)4kX@S$RLkwQ0WEP68J61UEC
zo(hU!-R^{v{(gnQYHK=!cg>!cQb+f$WtWQ@-CSK;rfbPyuICAH7!Sww*ysH)Opw(L
zKXv1AHi`wU><vk=5UPI2aq1ESY-exbbV0-W2UWr>#j*+ggH&K#$Cr5TNL@2sR+6d>
z`cpAJw9(Si5_f^pDG28|JNx_NDAp(6bJmSs3ME0xyuDM&!5WJnMXj=Z5en*feAOMd
zMaOW7YsalxTJPr$b*C7>JB^KMPc$w-IIIZJXKz-fiWdD*9I6YVVvWx}j*V!@u(51+
z)8Ju2i!M`QXJ^Ppslay%#qbvqj!3CkK7_|n<y@=v)r-t@e%jk4)63xF*sf5F-#IKX
z?UC8aE>iS|D_1a-d6xM!uY3Td@TP$JLCG7~jw}?-@b|oqC0r}PVdcQj#l&62&Wsm0
z!U&AV^mDe0%_!)OYBHFX<PGk`aCIIuJ*0rU?g*4`3*Y_d`^uoC;nmzbOK$;e=qssl
zTIq5`^a3~`mPDBFyOlv!uLBt?R1NwJv;^*OojnxcG1vt$y6}7}Ci-WLm==>B83~$<
zQkZjm@kr*f3cp;~>#Ug_h~~UfGD1fOp4+)P{9-0tek!ZoVUmib)(8KKeYs_GLUeQ*
zY_-J<7-6etv`=D7J%%!&F(k{-*mllL`%5satIqrP+O;t>IN<3)S>K26Oxc8ujDq>E
zYHGwEzK|ErZ;AFxqwfq0WG0-iuO$*gtG1d6Ji`gZ2*@9($qHe^f`0lW4zk#RBp3t6
zuqgS>kq91U)9JmcLTuRw*xnbQk#I9cH|l_WS~R{z-JSR+#9(1*B@#`|G_QIL;v0eu
z2~Hff<LBgnj`I1)WTMIWHa6H^#sAZwoGKlGi&=}ynP-=}+WW`TZA%a4$0gF+*|X*n
zQp~3^xnIF!L3tbe0&Vf{on!01W+lOc=XAdgzZ*q>d`ST_$P<DJIt>P)$I0j|`{J&5
z`uS43W84_VL&)O<oGEl&`1ekSU0@5zW|Bid*gPKhIUy&cLoNs|=lh~}hH|gm5qNCK
z(c^9n;k^3S7GB(34HzJ%$xe!P@~o~6`57%c8m9yV1OSsR(cgF|hVDzm;om2kpHz2m
zs<T-z7f=KRPSWOVr+aDn@{+boaACnDbA(_?5~Ibj>}YdYrDDV&__`j(gTn1+8yG}a
zL;Ka@L}ex-1x`ZA@6iu?Uv8tA&D6bPd*naoZcRBT6*Dn0TfWH8@cQ;}V1P2r>#)6z
z^i}A(&YYV?LycZ`Zz*m;wb>BS$aQjP=;`pFXwAy0S9>6dS>IF3v)%bt<AZCj{g084
zF`hS;GpL?5->P-Hu~SJlP~#5fz>FXe%F|Hz<wr-)C}CL8j+BzojK8rZq=ad>KC#d9
z=8{&MO_<DPat%A%?+`MWtR#!;qHHki5asw>a9l}_H__<+4%c5c;fd`HMvtu<GcaB$
zJD83xcj5YhSD+QfKoq|XDrWxI4l*G;H%Dv=$!@wA1FvNRqp9dx15grjjOrU>_Ip#{
zxc9ycVsdq|zq;QA%Jyd8Pa0T0<%3y--)Ng|vedxnvhrbjP?kY1MBV2v>Qb|UL%fxn
zo3OT|B5@@^Wd2qva_n2G$@Mn88#6jXHUYoPq!0b<a3DN*+){NEhYlMqN&2E6fEl=W
z>j?jMavnQ_hGXX{H7?O53}#R&u{+r+oGstXk}_m4kXSM^^HGxzLYYGLks{m1c=JX}
zE#A&h?@LEJ#;Naa^Q}fCM3`kX(5N?&f|2REn=Lxp0LWak%wtsF1VY|RA;8y(%A7af
z@TzjxcJA*sT}n&9WF(Lo+Pi)Yf2T2a^(K<jkD?6{E>eq0zJ<1+$m0pP==hw9X%IxF
z_(h5`&r7iO|HIZhhDG{-|D$PZ^X9EK*Jf<oJh{m>w#~Nf&9-gZwr$&Pa%aBBzw<vY
z=gnN#T+egebANarzhz1BkR;x>yJqDMSRm83DHbI%=?}Kuva}mdp^-yM!Ty9)3vRP#
zn;>ay(Rez79|C2uNI*rOZizG<3_Vf^==ttkQI!19uF~m*bzNy}@X5C5D%RTw#HDwT
z0{#I=JAhW#mC!gD+nwl;PG92%&>>tQh!Njg1rc+KM9FqUh7dktnm0;w!4pbx09gdD
zzg~sninm%Gt7v#QSeIP_D*MV*`$hoDZxFr9O;M!j$3R8TsGO%n-mAbK6Du~gcI)P>
z`kUPQ5RvBwF}x49gaay4!`eenaJFe4TuG~X4)R^%MC<55e$6mE2<pR&<UhY0z>+r5
z%O5EsM^qd}gL~F0fa>gjF%kY}^w$RWp+aRlndKDNqOTIQyRk_ISiWx^jN#hFHJF)#
zL=J?x5tZyKLO&qc&U9)^b<hRP1x8+oVjxSE=V)}}g}p^A<I2BFC@82!Q;b0=$q<u}
zF^|4$mRN7l#z4-_u@P#Y=mZAC`8Gv$&iYz)#6~U^t7~5hlF|*siy(;`_~hqf&VY52
z1id%=ci(pC_NUoz_r%wj(GA{0vC%d_nZ$O6VR*3R089>aL&1P0!iXc2RhIry6PE%y
z!;{k%8ZxeTHy+4KtIYzgeD>lWjPTSdbA;^F`jY4bD^gxj(X->)Q3F?jbH*rR1OLwD
z7)NXEzqZ68LnSd}1qRfK?I#XH3l~VB*tO?FfBEuUt#?Oc$6@dm{14}m{A0m<xDN>A
zrVN&(oo=_qQC7uoQZt_M2J?i~ZtqjOb*5=5oQexnV&8qyMSboU`7^b@WV-aBF=#E8
zx5aC}ylw_^Ug31ZVIb~gmijQSRrZ#tS_cUQM~>;6Etc~|`%dnDr9Q0E1jWfkFE&&%
zG)Nw;dA{&`bq6uTVC@(1m{-d3{1R4v1Fs0hyM?4#o{t1?H$!Gha@w?fvo9*@Ln`(;
zY|-TTX>|@KbYH(-vo$+~hlKd>x?_XA#~Q(6EsY7Q%nr(gQM9jYN-7d$`uS5lEJ);m
zTGSbp^_>Ll<){|xPhsi=RN5V147nErLZ++Yv%Fp~A0|&n$RP|fF@KglwmH3raB-vJ
zlS9gJ_S)?B&s<M%SW7O1IyM+|KHeh%<B*Y&`@1^2wtL_-b9Wm>U3EtDXgBOhD=ju!
zA^ua##%sY5(KL=}=x*9xrUF(#2-rD(N=<=va=LSgZ1Ap2>Z(8n=9{+DIIA`|gdsRs
zFK<?ir}nlc0Uke71;xc3JFb4tN^{x}Z)PtIH(KJ8n&u~k!VvpPPbp;aUHmzgdw3-}
zm?PZS^1kY2Z+J~q>U49oCNCDr`#AQ$e!J`2zMInZ=?2^l$`$ZE|7SzPgL(7tms=`N
zJQce7s_9%YJ$HkEQjQ#j<O&J=d%CqX+goel)-ZGaug2vx-VyN(aoDC7C#D=oz@6x$
z+q~7+X!$yTxD!pnyZsKzQl$=$y{#h$i|?4~4c_pB#2tTT5c|%m_$yu@Pqw-cJMXQc
zONW<a`CQde6n(S|<+uJ5=KiSz73z$bJRTO(dPzIQyFZ65l>t6P`T1Hgv7sIbho0Bl
zzv|yU;K1yI)y`<B7B4uq@hQ;eBz@3$68JJFOSvPtFJ`A<3w`e|W&jZ@61IqtcnwDG
zq=bYz7%Qn+0GsNre{<gZF*(Llk5FWsGXMao>bFAkC946PC+*)&yxV(1h=}ijWxhXu
zpAbUr%bbr;ZULaiDR-x<^!i$##=S#9M!#x9DaRQ3lrB$-8uB4wr|n>dLqAjWlSt|#
z8GoxR=*ElFQ&4ILo`;_)%<n%OMhJ@YWJ1M62qGnpwZ|eBMQQau-Xa|)IsSE2npQ!e
z=aCA@&z6OI9NGm5{GGKG=OJSBIv!EzA~z7|(ybaQC~lrb{5ZTA+nJ83V1^&rm_X!e
zAPQLY!W%Ih*_EBLBKxzjb$3t?ZL(187<OsL!&M7!v0f`2c?MhTt-zNQ5WhL4%R?_R
zkT47b`LQZ(E|Je19BC2E5@NgSQ)Fa<$r^469dis1K-Z{luw21#I#;Kqz-`wEP3Rc~
zp?9V5s!tMr&IfO6NVl2ZJ##P)y9Pml_b8~^$h`Qlq{;3VZyZQh_32?~@pF?Pl^0V*
zA<6iYb-i!t5>KdhcG9#x;*Q1ZLEfL3i!qnP0zbR?F$qs)^Vut!!jnxddZgb@gsRQ2
zxSH+QaJ`3U1#JF&*Kl=HVGH7F_!}>D#Pt78ll-5XDlFPH>b0No5GV;GT`Xsy^wr~L
z!Nvc;5u*Tl_x|2OYwh%K^{3ZEsi<C>20nW`1`lgJnFg*@@TX^cH#-4l4wgdbW0}<x
zAnp;3q9ue7QbOYP4sj;8Itb#Mc2(gfiQoKHLOosm&m<ZV$pbuP4oqZ+W&p((>@O7C
z$beKN>WJUFnM`_H<?7^Ww^U|V=oh_a!w^HZ;VmtO#{YV^bo0U`^oPfXV+vKz%Y<Q*
z?@#-hb*ofd9&YXYi!v{fKS764ZuV2%zoJ!9NK>bszeqldWjkE}zH^-m@Oaw<*BQsk
zKbzHwOr?f}VIa8{L-+Rw^*rz>eOGJ4Nl;}yB0H2LiDKw*Yx*`d6S8--GbN%q4Up|@
zF-!N(A_ll`N{C$3o@n^Vt4qbu1%KQQVSayog3EQsTRYyV>bt+vVNBRj>g`x>1<`>N
zgWXX~CJkiM*BKw@OnD5X8?2NRvsumeqYSsY%ciDaM(!?z-iP|?Q!wPI$DFz-6T^+S
zywix=ouK984~0UXju<m*^Gl^ie?+cDiaLspSq{uwLgK_t4d2uv!MrR5h=ST7r+=dm
zt|*-Lm0)1gf?V15m^H2&E?=L_+?X??$j2;ge9)*QVIBu^oPFSBu4j)0UFvn8A5fU=
z_GwMvy;I6zKEPW~PoZ?1+|Z#}%r=F7hU3|y%0h<|J)BIY6pRAH&p=Dy`i8dNKqzPN
z(wr`zd*Ur!3%i+;EQ6?<(4q?tab8wc2fIk6HI*E?JuXvr*>UJ3_;&e300!mcc3Tal
zu*gE<gReNJJD7$5vw1iNdNE(TLdpS~h{G7fBMG#)&6|tuThRmV=E(AVkINAE04BN1
zV5s}bA4J};Z*T4L)V~4c_T~$-nQLVTNj3ovRpNTuvFGPn{q)dTsuwN452Q1=aQ*!1
z`<-sNY<C0^(s|tl#`C=1#c^3$;cjk>(e}3Tjbhqs3Fwo9cT;=5<mNSy^O25<Cyqz`
z;G|A!V*MjK70r5hFxE9-EYsF0BhebLANL94n=29)1SPh*mTi3AhpOApmNuA|rL;v@
z<+@b2Q)W%s6Sh~l%R7Ip58frfR4#KFi=K&$@M6YqCz{SRvj_-dgTfv6SM%aJla1G~
zoW~1JdRkgIa2^UQp5gSf{ra_%%>m&IGJATT(Uc18oKvY-MbT{h@vSx9a+TGm$Dcdr
zZw)lqhKucOyeqHz*lxBOhGQK-A;}JZD<CY4yc6TYgE74sZ)dHjJQ7K|FW@Wwt+O)|
zs!Z2gn+*S*iA{=`^mdqxSH6o43e;}3eYLGZ&TKj|UU=GQhK2b4>WtZ6*xU^BbkWo$
zf?s%Qqcb3!UG-Pm3?51twm9fTZ-p}@5wpoO#ZDS#cziqv$SB=FO<b^{CfMux_7|7Z
zS&}gw5xcyfv5{O!?o&Y~35v+;H)2KJCxuAhSix1NCb^Cv|I_vtPHkra0B-*ysZ$a8
z{hmNr3^ZIM5V$MB*yIn(8ytGhAND06{&|?pb0>_^D>iqa^>WkmJE5mTY$>uveK_Ge
z*LdbTp9A=XoFr>>01n4fZ;_$t<&>TT1lUjK^yNL-JyL#jo9HgPfxM>a(0uSl$J!$K
z+o!TMGca4U&2hfk4ImH_OMZe$W0HTk`&hZQdnU<z+GA9kHG9OhC0i;rc(lI_RHU;$
zJ}{zmgYq$`<+y)-GZTUPUY?a=v@ys`{fZwqkBI9e2}K;}q;1YjZF-tyEObXodl{BE
zIj>kw*;r3bu$qe=6zP}`2EKhQcc)(%I$-E@@5qoYL9AAl=3SuSgzLtPvTcpVL9<=Q
z^>f)aJ2diLDC%T)cV##YI^5XgW9-uXW(;>FTMZYdOD5q2QT<owBe1E$p3;Z!-JKW3
zF~)-!c!tgUXQ}gH*G5Q!#i0R)R_Gx#O*EL^GP*n)Q=wJ2`pMi7J%}wJQmH?Yhd>;W
zwDs|v3+hAbu|mf6ooWN*+T{t$aeKEv9zTD_1Uf?1TTcf0{3DPE;jY11EdNxNX$@nD
zV*HsE=!(eaUnKgT)gB_44@U|w$A|d;^A|Dr?YditOq<rR)mGmz;bf`ObcuD;K{KGP
zu3->%*ptgMlvz|WT*L~xVR!_+i<7##8!@+qJ^Uc92Ok*F%Udae92#TbZ)h1W{tDar
z6i<h(VLmtSEFUlo5gBRlB-qBU81EFS5gdO}rZn?CcVwKkQ&naDF$5_(KDks3Ci}5e
z#WA2zJbStJxmxE=SbRFXqP7|RmrsEQDL@xZKQmXzF5<6f-r&ym*%4%xM}2qs?$Ys)
zJD^V#FYt$~tm=#m3c8BS4}N3x@Zw@Q7xdTo$8n9Ol3;QY<K$nSDI;#_uAju&O2dWf
zF#}JviTm-w%Z=_7_0|irNCQihU%49akv^@KGV>DWzw75|j;eh8i~r_*>T`UGa=8;L
z@>%Ro?#n*mt}YEjMb}@qJ21B$BDRTc8Ozoq7A({2c?gm)<APn|4HUJA-#yq-Eft1P
zu$UT_8n{FC{)Oc1T+v%*r=^hmI8EQsE)E)x|4nvN0KN>N70~&*KAnuA2Y~Szz8<^<
z>Ajsm+k8X*ozSRMR!E?`+p<@%!3!Gty8Hu@+2F0KMfuM=3f$B2fM79NaUqQ4CL}D0
z-nNngE?qcXvaOXBp;YoUp9g4TD3=wt=<OX;m91D5gFUZ;Lqhv0!HcV4bH47H5AO5F
zo>i?#4MWIc6ES3Ne?BRy%2oI<J{_d{7lU3(E+Rjhc#7AWxUVG+>~IHB2E?|4y@g+&
zUazvc$0YA~SHQA+4G2JZEZ+I?VtkWx9fENdpeKPKn{rElhpsIoP!@=}8S+E|pAm+N
z%M6L-)X=JCpyqJ7j+!Hx#I8`o+!8DJ@ehp=m)t!X6o5jII<`mpUc#U)I%10;mtwi*
zC3c`b!7`U8=8lC1aQgt~&HNH*k47CM9;k7c(5jn^{{>03I!mBK;IesszMqt;-=8hv
z8jZWC=A%&uw$qJglr73DDp$u1Kj3p-Q_#G3`Ha5CQu^e^LKc4@iqpuQ0`raYzusEu
z<t+MjWJqlo^%2XKfz5e&1B9yj`e)mG5kXWnRvT7t471VUrhxo)8D<9))te9S@Al*+
zg*b>qSq?-j0pqnfJ_&S*OId#2Z>g*$w7ZW_L>JcKM4#W#BUrgoCsIZ7yvlIe?<Oq-
z0+`qiYxLp9?8)}N&&$Zj5cUtG{6t+UQ$-v@N!U7CYqCbV=l<<js^UDP)CIO;FVjMa
ztO1*rR^sbyXU259y!4SH-L^XO{A^3d^ONW(-~lP%JJ7U&YgW_|Y6`7_7IVNjz6AdK
z^D0Rwxy2kDtb*mx6bTp<ZFHa7tdY2)l5!m&<MAl-0J8N)t8Nrbw#A+IXIfr3)UVPB
z`1fL`V<rU=C??h5J83e2H(Z{WEH(_HA+XhZA0BYBDxNZ>H-?sd#12Zm5t>P-+j9+a
z%W1q^*AzZG<X*q)&q>o+wEa8D$9k>)Oc6CG6uO?IC`IHY-*Qmq4JMi8S`~8h>Lu>t
zJ3T>oV4k)1t#*Nbcg(bq86I!Jx+wJOQ?{c-3i~|*_@1m%TJ8zQQL>BXh_`zfd}x!(
zJdDwsHLSz&lXmfgu6#-I*@22kzQ`Ao%?&&)^Af^h1cVVzd}32cqQ1V6Ls-J?ll*yj
z(XEI7PHO$t;olz_Z2GhUQb_TGkP$*}2~QKdGp8Id+Dj-fUu-A?`y2#ha&O>HT`Zzm
zIR9_2@Bc&YcJsni8XldfCy;)zS6F2S$<ySzyO>}>SRhxnwIvcuyXUbo7;ZIQPUSwz
zb?vi94on}RT&9VWQaef7YU(5yd_A3;R->9Ay?bi>@x4(56!KEYOAaKzLQ_~zRHc|y
z*c!Z!o=pIS4BFv*#w;z?qALt01!&bL1^iCAz6Oqd1nmd)mIcOPpi!ue(n2}*`hzcs
zvIa+g<FEg1ssT*AboUQxD4@A*5J9|?fSk~r{z%q1VQBQCS4vmV{FZ=!(Cz6Df!lJj
zbq4$wv3SX%+v*{DuD9Ap{<+dFP8BApf3oaE>^6*?kW1lYxzHZG{&-Rs?E4iW_MER;
z2SL!pCct7vSEimgI$$#xlqcc^^n*SFlo_q^72L<R&!$^#%zk9LxjZErIK!@~xSc)#
z%xen+Cb>3UA1K54A|r#mX$u}tIy=~H3*THHo^hEjZ&3A?vqSv$1-62PmzP_dk@1uj
zXy1XB@%Ig-agQ1A8cuFN=b;N0sDhwwU;PB1_;+v365ci?r%N@FHU{~^HA$EEmkS!`
zxCZm!UfL=i!-wmiQZ7=JLgqDkeL8Y65L9vHkEj5~Jz@0deDBXmh3V3=SsD+sQ>?Pn
zR9Y<sdlD`2qY%0U+CUzr_P1NgQSyHwA#wwj1S!95<4?7p50XBMNFn9C_c?u$^kO$v
z)!}0xU~_c>enp`Q7k`4bHmY6k2<y+gkY64>MXif*ahCukvRGKkl2zdq80R;*3V1sO
z&tCU4QXQsMS}pKcVcy?d&<pR8;&EDR$#6OanSEw+8-!t_hanFS1qV@dzjH`u!7zc?
zJfdh)I?(O)X(~Kc<4Bo(3ed5!$#K{WX1tDMDiU5b8ph8UB_d*+<6>E#NFNl_%?%8s
zQ(%Z26!SzOVBl1fa$&3LL5t0{@j8UAa!iyJ8f<c&#){8D$Yh3plUrWWr~aEK2diX0
z9e!pf%?vtHY_7y;IL>%0J@f~Mjn+$QanTqKQ1`teDxW~{UvWCK@o<FqU%D(-__-Rw
z#ZD;Xs53J)#-K(W%=^S5`_sx}6B3a3gF?TLk+Y)KqWt{jAg$8KWPhR2fL>wM&|u!w
zTW=b7VDJ|?Ev~-aA-kq-85@$L$?UjQ`dwMX)B!-#Vo_%qg;mwC)>Mx_Kak-`0axE*
z)US~yWOx@kKX9>?`Vy&}PRyK(=HPiv;=ozOSG`)d_2x`r$&e15t$jj%xY)ZuttXBR
zpc}keziYx|bLp@@VlQ90#z(^E5tytBzVvT8S0fpU8oCP3)D|7a-peCP>m8)`9(h*q
zIXt++Ar%RX?b=rdNLYMd(?AG4yY$2#S3_w-Olx8c&S?e`1K-`~ck&}0iK(M16aN&@
zS&vmSp!wM-xmhsH<Ls;zipcJm`re*!uz@*R4ZB%}YKOBJJ3s1MaWE4>?ogjlR!~^V
zQLrEG?mKo2BxcGkOh1p*p^a6H-Tw{u|FI?gXHuFLA!eh%=*(z<8sz7I04cCaU{K2H
z1gs=Goh2@gwp#I0^Ie1)=cJk|*P9$h29wk$#@SgoCzPuyh9P=?;xt<Q>YS_vqi{_w
zaJvT>x~xYx%Q0%yu`ALz<I`xSvlb|@s~=2?oUK2SQtq*xsajh*|NA%ngPkie8@(ki
zPBbL*5gmL)wSbiPdmlLu&(|zX)EH@U9~Sr#r@)*VTO7)FEd?4vmmqwL-Cox|9WrF>
z!+yIEpPDO&)huR;duKy&n3-X@AkqmrT(hf5f<8-{QoHIO#ByauNZ~|zH9B;tIJ&S}
zWv+gR8ltMPfaA_80BzeNIX~kYrp^yg;CIRh$NB3ez14A?>u1)_55;&_uwD$6pUgON
z`K~eGEx{dj1e;H;QxKZ>U9oO3LvM)ij2@{<2gD-0C~y{U5|Wv3oFoRu=On|!G#yv2
zwWG2+&Oq^$vU&=RtJHN0SFuJ)5@<;;zMkG_Id!%Dq)SA-Sm%wWXNSC(iyZwlNTZyz
zNC{U7!LStsEikYafPs3y6tob2_8j`o|3RPxrHc~lH4y+$HpBcP`rDOxhIC$>qtHs5
z-qrqQw`=EkCJy#27RL`5_W@UD>`i<-A_=%VeDFnL&>)*7gjxVfj#U?yj?_|cCf(oD
z<uzNZ)=Q>4OX?irv6aF#K00KlyR0=zADDQ&sjIary;~6*|MkJV+1oAmW|V7`pT7>r
z?Mg0}AP=R?oIVBO(zbiPdU1wjw!~t(dj=iz(Sk2AAZxy6@p*REs<j{-<=u=|jj%vy
z+&g!P4aW~d#8;AAoXUjr;K=h9RE{T<jWFH4j>x%`0h(L_qiC0IXF-YRm@nMX{fVt{
z3TcL}Y>i!dR+)p3q~i;DEqEG~w;!VFd|%d^D!$2?FRhj;TMd!Ip#1p9qRzm0)k@>N
z#y%$uZXaPWB!y6BeJm(4n->qjrs(N`6txRWvWT1pRA7_{kV46&>kx(v|Dj!})+-t*
z6z@s*vdI4u<p5z=I-ALB=xt+a=5g?=%Kk`&$^Nhnq~&UEJl$-|I-bS<h0xohmN>%1
z{<jh)j8&Q(?DcgCST%XZ<~TdOq>KN8q<npE`{l??#)howez^neY4I<N;3^Fgy4=Y~
z*HTisPWYlQjsCg`jh_I7?c0x4c^0%PmIFNCmF|a2jj<m)VvUxaSX9r2Q4{<OSgK@P
zEkd?ol;zJkt~zJ>+1hd%eK;L+F=~NUc?o`*v$|X~s=}=VcUxR+zcCU(xTe;?7{IHv
zdM?w*G*b;IBrTY#GL8sCl*)o;F~M%F<rH)-Cizg#0<T+yY)pN)hEZm42>5>)0NYPB
z_Dtr7b}2~T@bO{y20=~#kfM|0p_DQo`-az!6KE4PD{C>I!EVGB6NTIp$9S!3Bxu)`
z=iXMH3koI2MXKU8x8L=RiQ=&NCTU4UI{d4xUAc`#>uHWoD)>rNW@)Vt$A9L~BD|yb
zbDT9L7kh)mAx=&P6LuV4=|WsOdvCpfdJj|la6WYPaByYF%Rji1eMXsru)@=^G7+pc
z>F7dA?9&PYAUwSb^9=w1pGWS8^OZ51=UUSO`rF=G>notiOl>8P!VC9W!(4q022H#B
zk*&#ACnVlDpm3R&)5n0|;Eti-uHlUYfN=J~<-QVRWJ^Hr|Iy+Bo1dS_60dD!TA$Pk
zmO!SPhW7p<<yUW34PjJ!T!1K;3$dkJM=oM}yGSUm_b5T&c(YTk*4?0Xs4xt1!TGbe
zoy%p3tYK{5F`9L^>Q*P+rtH2z{2xGxh1Xr-#iS`cft@m?aZ52LH2=M)Q(ZSR^MN)?
zKlSOonOp5T#}^u9I|vR{MuF?--TgoxzWcWeUX#u4_|l%gqQjcd?-#Ky&A6bidl%{i
zQ(SKopr6UzhhetxqS@qV*-PO=u<L#}q8ozNG%vg{iZA#a4OgTu6z61t@!yEt&#}PK
zyU4fq_tz_3!8#-ViA?%Aq~2aZ1AQCJEig@?9gd)mrz$a)7*YNcYC4%><2x84#&8?9
ziNGiAYssYl*0&R10^b@uExnN_p66v&FZq|UP-^;;a~h1A#k3*;h7i-sT3Qk+zB<m|
z?zvk`=d3mi!glkM&o3@~UrhJ}De0LNB$aB4eg9(CE*YDEE<crC(5*Wj=y+aCyw#d*
zu;?`EVgD7|@r(0ye#RL4;0(%qL3N&Z4dP@5uz_!f{&B@I=D_u<FT;s}xrRO6Q4a6;
zx{6q;O#5{*OSWeC*j6F-v7=6Z=;tw~uztJ{RJFbs{mSwAiljpA2(4!kI7yS!;3*q-
zFv@i|o)Q+F?twK_y0Mk}Oi7vcC?gb9<9xw|Ab|>T&)a0VMpCD^+IYdwI=&(GpxI_T
z^=o~LidUPx&c8hhk=6X3`1HoH)-9->kk)iWc=kQr^-5zwT3pWZc+Rt4*-@g@rsXHp
z(~E0Qx%CzewZ)&OzG081KV;d((8L3t=KGJ9XLPDm90rcBBm<9|9o&LdIt1BX?^GU;
zPJ<JEG`j~n3g`0``ejd>9byygB8*)W6#G`xEQ;m=y=wdcP4&yaR76uUQ%hA=l@4u}
z-C$asETLJ9+Wn^r4$aNh8sCQvbidjkc|p`in=MyY5<~yTZ?!Uy)^tKwl3+f1Lh}-r
zSK7`-MRjqLQx<B5C+b$)hB0k^SWP!NBN^l$bk}qMZSF)*+V|%K`xHp9Z+j``=xJnv
z2@m@>wDn8GXv9Vj62&1~1<8K0wrKy%8DR5_?*a;|ME`?ODzx=~1gCIxG2;uo!WUQh
zJMIZX)~JtwkYbb%Kl|qLwi0WlbP~F-CMOFy0_b{14U7kd9UPQsDYaVMR&o~=6ea~W
z{teoxb8yTdl54<dk~LM-ix%{+rFu2f{V)8G5)W9~g%y`*r~3yHpqAG7tJ-4)CCyK@
zLPObPSzMpDsrnjQtKH<&-LxL1%XaT4p^gd`5eEm(@JNl-yD^HewKa!LHyb~Yp;7wG
z*&S1XxbRif-SP66+PD4tvPO!Q>u=K#RTy`2$mtF;=HP&YrliO1wM5W^%8uoe-Rj@t
zr7pJlh)PIIeg`T@m5O!4dVEHYMR600M~UCRxLhWuh5lTgD>IqcaPJ`Rji(r>H9EA3
zY!P*hZ}}XNae^znerEbRdS7Aau-<b`1I2}Jd+w_~{W3c=vO(XCe|yo5?B5kCX5@h&
zp<X{<aa5|(jGM6gKm@B_k^im&BBI58o#KKBc7|^<U=!}c+__V!<FOTHCw;4Aqjloo
zL&OY8eQ>D%?iEobzEx#2zYJD*3ob>XhVczk$$}=y{%jO}aq~<R_M1(!Qvrh<2fbQp
zRn?2mcIvXa`Qa0m&mQZrE~b^tf|PyN9yLvrVjuL#(NCdQeoETixZNSP{v+~5TKbX6
z2?!#_iRa9!st*>bh&;fMcuf4Hs%ZD-w_-FG96qm-Z>jSv=R3#a&v4rljAanoWB$<(
z&tRtul>Q(OdC=M3-WPBV8MggtcgQGMw@l?<={Q(@RI=R|j=+CzW~c3DOFh)$WSxIn
z>9W$MmO)5}wF>X*Qo&UmWjt*lKeBr~ca7`I<xB{g#_bFscxW<T@-}MY_2yGQc<8bC
zf{#foR4kzltth=%j0S^28R@rJfuCn*<(N=gUgAa(V_Y@$O^?%X)cN}5Y-)H81raf5
zByK2FR%a9W9?1@=^TRE3q5nsV05|+M+`F@ts_y<8#qK#F{eYS8xIXcpBN#pkVw4x7
zBFVm)5LR2AhLkKc&w4JdEq!oA;m|LH5>iswq3=bqy5E+}m+l|JBYyw^{v#{m&9=dC
zMDtYd;Fz=A+eD+)287$a2?eb5E2n1DX<Xkwmv4lG2yA9B|71;yyX49#QB@8EI-iY5
zknk6gfrvW)^@EVlz3I<<45ISW;RF@pv;O;*DWF=h3R@(T@?lBL^Us6HaFlVn%iBG>
zL#Ow%s_TOuRW9N67du!X+~7u5#jS5B0?vTum03jpI1ZI*)tw$DIJIkGK+=$~bmY^W
z#y>_-O?(W7<3fQOM<!4CX_#UDAd-l@)nan<O43S-pI2TH@~-x9Y`qaNB(v(u_uCP1
zKN8gV5U?CdYq5T!;?7Qr{|yNM=gohBOCzvqYm<@wTtryRGyL#?lA;}X4R#Y4eMV}I
zwaDaAoamsL|Ho>r+~3xU|MbPRcYvi3H+^xk==TBe#Ot$XqS|t)beA<xHL1Lhih^R{
zO|nRdj~k!Ewxa=`&0v6vTTGI;E!hKG{JEXRje|HO(kz!0>RU+nmTa56!;S*fw;q5h
z4Y!g!#f(v41F3pOO{0!!yy|4sb!(VPJYCEf7id&^h}NIN(gyec2xa__h{h;_Z*DYX
zvCNhio}g>nV@<W&g4NEiITd?iJ70rq621?=0l4YL)2`wRt+7!Ia)?r*Z`+3Uq+n3(
zY*hH6_eXw68~vg7x_TD1Lj;__^!8?~w=haM5(*pibDx?oBoAn#u2BUuD2Ma&QeWY3
zgaS`W0SHeixQ$zF<hA`*i0nY^)OPfpfZ^Zd)YPl*6mbc^=PJ>}Wn_X=SQ0gPMHPOi
zy(~H1)HL3PU>y1K(SeAdz^Yw$D)OB&23c5EAFOoz+`2qT8r{4mO#)%HUDgV0aC8@a
zCTx{VvahjZD({t8P&-W4l*?wJgjoJPqq-0UouEJ2_Hz+G3!-FNVu#*BtE<r%E)Do8
zNc^i<Lx*}Z4?Sn6cN16-+4xfe(iF1Ph!x!oNPsnS=vda66}24`551h1agq_WO{)WX
zGT++Y-U}pi-MPBhuHyhgZOAV)9@u~|)el?3ZZC!@U$gsx&avE&<-U1O?Z*;-0N=rZ
z#@uv^kR+HECNM6=2lMQoQTH9ljQl$Pj5A-5<8XYk5|x5d5NY-}i@Z8{i`qXw9F7+&
z=)vu3p?WBI^90z8ANY;d{D1704IH)6NkcXN{$b_DUo!K;vzE`y97F~IFHUvtZY#&I
zPxErk&Wvz4bz<#naL_v{?K<{vrZ7!rH~*C|8zzABn9fgccOx`*Lh2ELFAYb=CX3};
zHc?bKKc(Fe#BVgI7fLzv#2Sot<G|cQUvSqybLu%Ay7-3+dMTZx&dfU+DUU<@>swav
zO>rlu0cSEccw&kRp7EC*>9o$MHGKBM!M$U(FS)s9p;1ba@zY@MUL_`$>Mi>1hO^{O
z!;)wS$eI*dJOIM5hyP<40*4`=CQkS%C%6>=y2PvX(J7?q;fsg@A3+E*XxUOCYakaC
zM(hpXTO6&?H}>J9D+mTS7_c1AN#BJh=~Q8rQPMi=(O~}u?O7a6ykZVh#Mtc}dZklN
zmAsJxGHE)W4=qz*01OS8u7{T3&NTIlEh0E@I3=-qQ1m7_*#_JKQS$WH^4%}-R8@&2
zisVon0-b$k!ptu$%{K$51VSexy$oOx#$@2HIrx2aq_*OLXF%@W4|ufKGfnw%PqN%$
z4Na&0OyI$Jr<@iCVM6TeP~NFp>t|bbwkY02Z}zzy(&2z6SZ-!IBLe?xW<q)E;T83l
zf5R+vB1@*@RRUYERw{Sz=l`tw``=knxyG;J1`xF`qUd3ZSwj(5*7r=H|DXUm);(|-
zPoZcsLU<YbGX}~osZx5saItceEck-g=GiVtN`pAiN|nPn4S5BeJasWEfJKz!1dS%p
zr8Q`yBU9)~1h+j!^;fl0{^nYpoQ$rjf)hu;SenVDh(QSt=>Y$R^`j|MAo|Wu&tRc~
z*~t#t>aTSEB5xBdGw7Yj|GZobXw6={np6pKe_QT3z3hn6r9<O}@NqZQRD_c-9HE-5
z&DmJXXv61^F<HJpv>I#2Gh1)WHtJVb$MnCwomHExIB+h_)X*T|Kehj863Mm<+Y~V?
z6p&gYU5KN3e>qZ0fLhS+(}9MATYE>5e5b0Kz;l)ty;-5s7D-vv`^8-14{L`q<#rA{
zcI76l;?0A<N1emh0e(p5=Q?Tw-=ebxGZB#BJKAEJpf;i~K0L+k$oOTwhT>+yO;+)+
zP$VDDJ43Pv+Y>cGKnR2P&lq6j^}*CZ6b$i>*l5>mYWi&F>m|mDU6+z5C^a_sAydqa
z7ZS3wRpfpboYu6{5Dj`blc<$r1PTi$W70h~&>bqA3*h8HlCDVzs@zWi#s4jS&u*zb
zyro~5Vp>8u06#Ry&NuL<PBiKoBK}P9(eo=`a81B}jXXhDUAhK9d$8s0YHFIXi!N9+
z;-#nCcdB=_L6evs86@pcKIi7v+BceDKQnC_FU>?<COSMey=1TB8!mO>6}*qzjS8R7
z7%qbD)7!jzFi)QR@Qz>Vyj+XtZh9|CC_EJT4#W3$4VTPeO<}R#EUQ*TDVrw&?l2No
zyHG8Z|IKiTq*0Q^$OC<R7!w?_QkT@->iD8V93r>W?iy}|wSyd6zE`DQ2hFQU7jTsI
z`6D*2p^MQC>$mTJ#7(dHLa=YgP_e_ZM0Fd&n#0KDw|J&<a5rA>u-Fz|jgCV~8pWbK
zH5-rBx=jzel9Sl@Cinzv_e@^VH5?T@Y8vx2=`@x@iXFl5z%2jgcwE?7d)e>_*e_@i
z2-xb(__NAN-{x|)NhWy0&#(Lbx86AF=X)>_-ypOgB{*3Q-Sy6nB^ueEG#PH*h&SoE
zF`2>bOv1~C@A0-UZXgur<WP!K(JCUe8-n@UnHdYUtAS2_)uWhj7v3>#-iIbKhy&Mg
ztv$vWqp~2a@w8C0sQ9LWTNT0ZGk1~Esw4f!gQz62#yKa<8lBnV#Dt<U1BdLE-Fm10
zr{J6@>gWL;he@ywWMZg`fAXRomn)C>?=s%{7#1cQL{#H=mAj%TSD_S3`Q^-nebdW*
z0^fdcBnegQhfPh1yx%XjmTaHYQVV;lVC6v0|JC3g?vp`G90LiaCjme9B@BF4>Qsv3
z(eigH!S!Fcr$M2|**zCN!;r@4^$3s(oaU7d#B7HnIsl0)@}Ve-5T^>$Ji4)2UoQ;}
zY#Ln`M9C*KG!k%;to)B+EMu*FVcj;F>~-PWg0fOx9L~N-sORS|(V3aZ;KsS;q-}_R
zft$Ufdz6+6f?BY*Cm_%ii-bYD-yeAK7+2bI3xLXo%;IuH8%Bf$TD&tYH!Zmx4CK04
zViMpzF|s!%rc3DS|L;|#-RLlhRqv2GZjX{J$J?Fyfg-Y;0+i9N(q(Fb*rOv*trYG<
zmsUE>&SlCHljE~AI42Hz>~73E(bZl${H+O8_&RNntp7~)8#4>OoG#5>wkc-V<Ai&6
zfvaWmZZc1EO%+-zmFoz}Gr6ryRZH#a`8zBooSE{s>PR!<E04Y6<ELHHSdXbVvfK`!
zqIca*C7R%ZM>b+|^7X}KYB+$suUqx<l)vb1)1{_<QI7x>V!bhNu=<g1{R9Z%8_(<4
z6{VD#6Z75KI$W+^XFb5yL$y$d3bf#dR^+%rOuw+lGu=v^%npd*xMrMYmtWvyo(p#S
zYh_UKp&v#j#}&)Q-%=Na*cZ<Z?KY#{IG@sJ(%n-H<Sy@e!fi&a=JMeNx~Cx`^K8>O
zHTh;cLpYbGoy}^nZ#|6W^~t4|u}dl;;nk!wcFDgsIZVXA(KhG&{Kxgp4SEH;X>L_?
z*?FaC1aY0gH$zuvXH`QbtV*pGW<0a{jQ6b=GPvQ3Ih|p!+}qpfDR#h0{S8YQ@xg^K
zF_*%Po^fhAM`%cIz1bNC8wDld&v0}mlkG0m3fWgzUzdl4qCfM+s*;#hu~zNX*FQa2
zK*~F4V?*2k2eGRH#>lk7)70SsdoMTq;Wz~m^xAXp(|OJt`APR~pGbhpD@BPm_xBEq
zLUH+L@EgmqnGA`H7qG{t9{uzxBO!rJ?t5<0$E6~SqH@{=7R6y60M0@Rvxds8>+o>j
zeHBEzht`OeYV>bh7mqQqw?V_ceVXNjB4vde`_9N^w5rhv2dQ5Hbgky<FQH&}?WQ{K
z1UR}=dJ6WbqGr1EHuoA&q-xL#l!k(vWF#Pb!9lC+u$m=#plY2Q$=IhXUrEDT)mp(m
z^>*78A37q1h6SA(6Y>Z|mBv1yY*R<*cYbf02~tuBJw^B{$&6*<uVE-Y?dBZB9Na|z
zMQ?(g*=&j}Hg<3AVm+I!=_A}L&q^1!1Zl;U%UX-$@7NeGUnsZ1ZXZ9}iwk9KDN3%=
z5@PUM*XHdQu?uUM&hwr%bAr7-9z4phIze*E&2knxb9+GV&%QxH3K6lf#fS;kD#m4m
z?CR*S<|!P-Pdxrhko<pE_U=uz>L8@(Xd8HN+XiGsN?=%DVNuozbe8vHu-pg3DbFja
z3F5CBy<9GJL9IpyG5Iu_I=7LL69D!Zkfaw4)tZddpX8(e%Zj2;12kDIm%2%nU+^RO
z(hS%4801m^=-AGrBz%pG3i5W`d8E6cJ`r$h>{es7375lnnE)uWC~`RDc>@Ey%{xX$
za){KS88YJ&(tPzgDz)Z67;eAmqhqCXI%e+ruhBBlj3avCs3oM`45{8)Ob`h%HLHG{
zou9)@q>7DtqQ?aO9}#NFZ^MEEAALhkfIj!db5m<Jnq2rx4kA`HUTM9Y^zg3>Un2yq
zJ1CJ7m4Awgv8#&u#!rTkNvckO>mX~kcgvp%36@_^c3CNxB8oS@iLYp)M~EoR>8SkV
z1tEW%@eOE)$4vMNc!>J32LE5t&_6C@YJ?ilFbe74z0V+&^z78Lp1w58b^nt?4b~F`
zaL3WUV93)C+}l(-9I8B@$|FPyc%L98@Km@dLIDuE-4R>QfK5tBJ{RsPng)(ZnIp%;
zg}H?9&L_-W_``o}vis4#-nStVb;^CMz~A__jN=OFayLfv&3U!;&e%U<1xTtccLjD7
zvs!7%h8IiY)1wVde~XJ{2x%zH-`>a(vX2w?VbGo@Z^+<A{*=K#m6Xt|H6ZYKIiamp
z;6%d#FaB$}Y*(tf??nCm!s60BE%q9A^6KLvgyPh&AJ4`(VEC+g{~ZtSYaC^i2+z@R
zME6PyjYiOt>=L~TbjLm?r|BjqxTJ1oB5^MQUu;ZI6DHp{e)Z*~XaE)n5icf;W*+z`
z5K4M*gWDQm@so6R+W7OMVEgEZzHk#9Le2&Jad!NN#N>Ht4$frC&d3QzZ$2^nr0fQh
zgR2K^X`6o}NqW}S2;4x6Zg6c5CkU|x;b&LhQvQH0f8W#?xPX&Vg0cj(+y8C;yYljE
zJ4acnzu>#kubZVxh__WH6c0`=4kz%7mm2#|J2hD^wRUxG$_e8$l$*UbGcS<T+<!zi
zH5KvDk;?Nt=bKt1fSY5I#uR-}eyDx-jRpLf&bDH5EKP&~Sgicg-wZfgvQ9p?8jAGy
zQ`VHrw#AUNI{k-4+##M;KAsYLHFNfVbpe1Q%E+$8)7BB+<ogH`KK*+?vN~RU;&R)G
z_&*9ZAjPgaKr{;Z@KmIK1_b*z&Hsi2!+-uXdpod3$8f(2t?~Pkk3iJ{+H}7nh|GJ-
zx=Lr^VBv0SQhmI9yu7>CaC+gn+uT^`NVx*J(nti-92Qz*0wKgu2s!Bc3N8;EMsZgf
z^{hpmaF@nj7&8-TRY%e#=RQv>6w5-6no$W+tl7P142;z~wlzDo3{7Xs{V6f*9^2t3
znLm7a-RBqvkK4H#W*O$6k|Ks~HryLsOSOv{mlj#(*c2ub#B<`BtaOi3$B6&ONuh7L
zP)^J~u)F3ni^ms(-`~V;Z-Vs=(@ZmT!Wwr!le#u7tWKBe23c;iU|qHxWxY?l)hUe|
zda~Y<O8`d3&@HUl^g9(AhESj0E#301O2C;-tWX@;VVek6DoqSB2Yd~MapblIqqUF9
zJ(l*J9~uJgU)0)+(n4NkJC+q2BwS5r^PQGKiuq;<43<AMmz;mZ#VHy@G^%`#Ig*1~
z@#M_ldXGCBiV!X`h^rFyhh#?ETgoa<PmC+XrslIJ?oZ2xp3Z{d#M2s)dBWJO6eJ0~
z_VH-p`&h_AV=_Bde>>SrXVhDPuaE<XHGJjwVBP&(DlfgG7KCJ`Ul5a|ZalI!n6IN0
zay%BYMKVkq%-IvYI;`ym6%}Mg2Bl9ZQGe6IAf<EKYw*3FKKpR0r_DDg@*6`3qg=6s
zn8(CHIP820o73R3Q0r1ogvRM4d~79e(@1xwiI;|6%{{jCC&ZC<s~(HVgEM$+zj-tn
z&vH-oc^qTx*jS1B5XG}{D;hR0a44~xEf89D-|ZinR?*OZPx;P%>KQEJ{-yafvCGYE
z$;PM^mL^$;hOiUldbb8X6s+iZ#PHP{b)<pD|Eq!ec5A1x!E)M&FA!oCvHMjhbo3#L
z{IHB10{>!B^OI_1r09I+-<0uGW`g0^;_opNba3N=Wx6d0@O*1nK8Sr`Iux0~H1dx7
zNw@%*g~u>jPWuJiqBsa+)Ug}vLw30I$TZ3I(?<F6o9>bj-fmCrymf#7Zj90U{Dkeg
z2hKWHjHp9#G?D&7Nyr`HJIkSveFg=a?^p^NQ?;J|bK6tWY?-RDJJbGiim?|yGd(Q^
zIz||0Sr$*qIZ_*3J&qqF^h-147Zh`*_BLS&6C1`OqRFzW9Pf|2C}yuW%Ei4AN}^lU
zHQX!?>lBvr%a*>B??uqmMY1F2SG)`#YH{>y;!xLJ`OX`T4JOu1V99mq^~#%QS+dN#
zBRrf@y;h}A3MkD`Y~pqU4(!n~*K&=K`T+RQ#QE`lW&NNECdo|u^^$jXzT(48(*?j{
z&=PNTyfY&Gw97)2fT>m9emQ#`xtroYTo0e+m%3`+gSQttby0dv;c>0xdD>=~BvL`f
zU;O1A-$|uhrV?)U?$<e;I&e5x@oYnxB^C29<}`fES;!6gdK47yW~tF2X%wMJttiG2
zL&3r^{01~9e-<{|6%}p5iW)Nydlwt;V_0Q=Kk&4!5rfXcz>pj^Oxiq8X#)3&Of|b3
z+|=S`rqLcXTw1kq$(TP2v>|P_F?!%cBPPi>Tg$jPw9VEt$@Q{K@W(3E)@wPgWK8DS
z_HBpBemvBgYi-qC=5~A!pbhgFTI#qnRA`jizY}Ugd`a^OuitN(GggqonJVG9>bnR&
z`JY$3ba1NUAQKtasI1!`JKzPse!OZycj$85p%O?S8%apeFmyd%K(tu>LAA%=rY`NX
zSS@el`8X2zsYX)KP>04p9u3ARq77a;TF1vT7`0Z~8q6KA_vYW+7fKH%94qcM<z@^W
z)TN=QZX}_6H>Ve2{B5d4bR4F+2zXrP>u-~>-_$nA!|TnIw<Lc2n#noAzEICGs*sp%
zcO@tb{-V8epTaWux2|O{DYble>z@vynm+nBu#Y1BC=TMhRW_rxpD<qX)hQaCVpjIY
z$=s1giF#dZU8Xw#gVKQ;m->b8!rpY1>ypdRfSV3{5AciX_WsBov;O3FI6xJ$v+b9D
zZkF-xk^Q||BW;bd#8tNsA!ptr)0K@5k33k*{mQf~2dG%b&GYBIbORPpEiS=kr@g;a
z1}AA=S)jH~)x}cP+H6YKAD{*_?_|G^FJ~o$IdZ$zTB&BY!i?-J_7OkP%inui;hOx#
zvcG|5v!Ah=`(Q_Ft(#)C>fF^<kM74BxsaRx^ZE12gT<Ex=X1&^zNc8N^*y&KBQ{(S
z_o8813X+^=hhL7KPo1AG8jTKJi%#0$38L2E<XZ$6k-C6CdPU@>UaC}Ts@mhqVBnR%
zP_-uL<vG>GGXkY(91+d?I_tH^Ma$#^U`J4@aFN-3ex-JO+`$AQG=C}SfLOl|hH*WK
z%e|F+^<HTPwbzu8iA9d|q4MK98tS<02pOwOhkk5*>M-$^EZ7&G00u%2q|R=yxafz@
z>Pdt|PZSGBtGwUCDb)r1-@v4UIO|8RF01czK~iRXRj1nk%bB$|qBP-fg#L{Z4V-AB
z^_C%Ct4FW>)Q59dn-Df5p<XPP=-6rl#(vw?X1v>j!qgNsb<dLid1-4Lr$a{D6`{#g
zZRWz~^U<fl2a5G>O6Ee$LKz2FTJu?@Z=rGjyiUY<Na`|^<*F*l+{N?dQG+>0i`W69
zx9jws&cnErF*##r@Vp>@+)MLSC;t8*z7TYkW|I{Sj&6G5aE<=Zr9&iZr%@JP25D8-
zXEV?vgN}A-oTY1TXsnHh{{ToDSw%MbvHEyCBeU8lZT|0Wh{!ngPGHfEA5nE|il4}`
z@_?|x$oXP*P%BRQb&X=3OG*sF_l-i1H50W+Dn-F=>wU@a`J0aW1L73wDxEb`log;Y
zN<u;cIdMLXeih->c`E|3q+;{O^kwn-N=d7n&N&(YdYBDb<MSzn-7<6C{YqCF#9q_!
z9SdqOKnf8F&mrY)k0^?ZJ_$VeRwbZ*o3%nriG!VWiEl4U-boyrE~^g88cL^2RfZJM
z>ke~7hDVdUxGPG&nod`dLd>Sie>wFvVCwbD6lF3JRWi=pV}qHY>pc7TW`v>X@!q=3
zB{cvZMvXXCXLLI3imi^9S4v$Xb11d0V|a5B)*599lTs`;a}QC;Y1<)_<Q>zU{T5_e
zGyK);X~Yk$j;R`9^=31`P|CtDgRjs#?`!IHRxu0o$r}W^A-llBfh_(}xGX-LC$ZE<
z8vD8KEp=Yh<+ar&@1mBTx@E$NdHaM>wt_7Rj*!OwuFq~OT+rQ;p8wUuVH~$ymucP|
z`MPbTdQ(3PM!xtAX$k%J<G>hAD;K5BkL#1}%jx-<cej(Ca*a5rI~ql}A&LJv<OtEG
z4In)8RZ-6QNf|qtgfCl;m`k*aLLDy(WwRa+VU4)U67JONRE94%;0(J=W3;OVP9FLt
z62>GpT9pfyM2>*;82gqu7lD7Cs!wkBmRlb4n>`ozwDrxvzG1dIXCpM~zaN9;s#U32
z^Oc0bD1>#DELqIFUrm5aOC{(S7*akSu}YN+GNCDncjvJdq*|;s+siX?;BRr;Y`F7r
zq%Vnd^)B{*jGV4FwVV--&EN)w{gg5B^9L(-7wkRtbZYB7G)i>(t&xm-tO&Vqp1tLD
zRu}A?wxo85DNf9Qc0h$%jd~*eh6#nYiQt5fdFvQX)+c7oi*&eNelCz5mm0eA#OM+}
zzmccOVFXs)^i=r2%hb#?OnSF+Ck|dj_Ma4NIVH|fzPSQZt8QIgNVp$`SpUkGQW}oA
zKwCHE&mA_a_1{}35Pnyx6hvaVST%`TS?h24W*oL&t3H|}W(~={X=t!sBwJO%%$yf%
zrx8we&}n;3zQNCw|5Op;eRUQuKv<|a;C4Qyy~B|XHQTU3v|Mi&JY;xN=Sp{$Zx-p5
z`Ft1J^pSp#T-1T^3+*)0^?0p4XRp$9!m>Q+`lM)bV=n^z=uH65bvF5p_D(p<TCZR8
zJg*VWK^bq{z4fII|N47A^f5B&5+{1GKNZ!v7k=jR_^35Lzwp_);L7c689Oo;eDX&;
z<iU9N>`FK3)#|g2JQd~({maVSAMXp!zo1Nd6?Bn^(}x1VmeNd6HA5M%rd0B8VL0lq
z{ZiYfo5uT7paSue`Km8dUaaMNdDfw$_*q9=Fc2WfC<5*Qm_^x`PESS$S(G0i&qpbR
zjz=waJAnk{&o9mejeK5jPeAo9ue#^7HVyHyTXzs)bWxTUn~nR7)I1@g*X!D6T+^1<
zBBw5^`69sU<wUV8;Zr)TQGM=gsfs><R<(MUd3}w5-J(5&1>xPDk|T0JyDA+olgAZo
zfVrv)=}Pdr(C*Q`cU)Lv(PBhxJqK+?vDmUKaaHvx%D#&dx@?QCG~1@dvlIQ4Mxl}?
zeQ3YhbW#Zxi%2za3$U=T6g}g$-UQ`dm9d$#r=AfvR1E%pXcA%-*^(_9cSLQ&dSlRD
zP1*k>l17bh6W+q`em6In6>q*c8~{!8f7}#mdATwcjefo?>EAx>fyQ!0XzA*}*iIr0
zJ0g8a4rku+R&z!zA?FapPoV^Gw`h4jtpA<E>yDCaP_f-b5-XLM?xj;NHY;8r8ZkOs
zuFi`=)Ivo*sa(~EOvp1!p0V-Aa(9xuDjq!h(*}7Wg;&Y%!23QCJj|yd5hYwP2aemL
z#QRQK0!`P$;nE>YN&<cVP%Eu!Wzyq?CTGF|@e8|UYHDRKACoszIupMjo<x@y?|xxg
zC95`4(H22MU5*ysG{azJTV+)pD3h0aB*R(9xOHa7FVH_W7>?Eb3B02^cs-ecoSL>i
znoW6m8yZ@|RkYhm-Jf<o<Cb(k(@cHyid$~96hE$mxescFGN+CU5!P>uJn1VgR=mUy
zWwpo%+>2lnjbVkGTK?+1_<l)QacZw%@qAR{tcqwk(O|x4Uu^;rmzXlNPo{Irp!`@j
z_k#<SxX_5$&qahwPTMKrfH~hw=QK|L!5@>_VlI2fKc#+M7x(qg)}NZBlrAc}G2zvh
zY}gG@+rFqf7VYq-Z(C+eLK%)4I9Tfz>$J1pU5`CiA?Zz7tfM;pU_3!^Ri3uu3kE96
zG^(X~6*@T{SS_`m1h+43-tg<|d~*l29pwx*z$)KEQo&q{%~o)SwvDrZ^JKjetJ7Oj
zA!Sf~8sdw_y7Q~z?cKaytydrOT&s9(g4%S>hREzkduFDmS(DSA*P;7>fA81-Hy*|O
z3W<FG0qW|Er>#2u+aQ>UN2Q|1r9D0FM&$=<WWL?>6AC7QfctSQm?%7vKFt|!B67?$
z6)Brz36H&;#83+HLW8xt%P2x(QE2GF+K@gqoKOkep-zs^eqJ9-<##wVR=?4PGORae
zFPt~XHsKgGPYlyxR5gO;#Hmk*kOuIz>49o<B8r|!bK*97bbCH<?f;jeLh3^(JEdbO
zJ!ZXTIC-9+hsxNoNx^zTx|*A%{J*jHo?%UH+uAT7qKJrsf`AmIsR$?p5a}w?t4ME3
zC-hDNgrcBQ1p(<uZ=n|<grG<-q4yAw-U8A>OL!mGKI@#l-23czfBWZmy?=5AlFa$c
zGUgoP9`_gnlV|)asb1q((a7%eHZljVJDy~lZYINrg`E+bEuv>Bw7_9|oBrEX!vnAt
zEn9fIU71gHp$A-Eg9W5G(~Ks5;6sv*O-ftWh#VBbx;XHt%lpuF6A|PR)db#!ejIF|
zE)7|a7D}6LlAx<9H8CjEDdEeB>9n#TWNbv8{G{uraGh$E?K;epyHM{XP*mEMXL{Op
z;i{K9dbNzA|J>Pu<67vC`3Hwb$D<a6R!gG(%eKARXH{*wb+1;DZ_Aj4gr=zZ<qXv5
z#6zNp?CVg`k#tHw>Bg<2X4jo2X$8zgPfDTPE18X?2zaPazi^o+;T5m5x-`#K@>e%C
za=wWjqOiFNrD_E*=0p5vB+1D_&Z`P{)m@YmVe)O;&rnv#vqki&RJLYshI!pwWSeT=
za*-?XkS}$ds|RZ=3vU9K?Jp!?=k6tp2R<<8PLA(ki&K{-l=AeUJU3P|qcSo(u<8;&
z*`AN~%T~f|>s;==<fUt7Wb@mNPz=X{4N$PA?TXV&BVe9$mu|!_r9rz~nFQyn-&Xgr
zl7b56#;w_0;)}F$GMAf;tG;#v<ySs!qHf_j5?TG%;OK0xP5v}|O6%SMl*0RG3(W!^
zh2q5!fPkR{?hu|0RwTrRwyTA~>%rQy^z#|wo#4%z8)tu@P6<ulIWY?-y+aQXCP@DC
zF8%2C^wSelUea3@+;rRUCXAOUAEdVi*rk_fD5pn#jO(jD7&;-lQ{2MZgU%Mg&4?MT
zZm`qi<Q!wf(Df4Dl4X82-}_U$4=Z}78}=li`+}7bFGgIGy4}!{XS$DfpQ8oC*#l&V
z*WRu@4LCWj_`cW<c&<GdrB3*k<lj!et>3629eD!to{)aLfm~w<lNKLNOJGRbY}lEI
zwljim<ZzO`&Y$n0JZf8(#GeeGJoM?c;CB+<Y?e-Rd|wg&?xEup$Y=h;DNkv`wr--h
zSAoRd$6CwShC3fb!EqY5e5vmB4}Hl${9y3ej&Zzp#~Bp1v}OsqOh}&H?1YP+d=*2l
z9@cnt^^R~1d<AzMJhuuDuX-!&L}*>eBwd@3EJv)5)pd|tWMi8{_SO0-eB|9^zkH~y
zpAKK{D@oXM=BBuKk@+yt79-$_e?wa2!)@zCj%)Hy)vtJZhxg`e(^ttfOAib9ieHBQ
zoM*4Q@o6SisY@&Bcve!s(*K=Mqy55-wS(1RMZ|fNdUv0?PEO`*-Dly%?-r(Q)@$J_
zEX+H9sd5{*OTKHh;DuEa9@W=Tj$(!9nCDsPbZzcKj_?i|v;h=#>dE!mK&7@1j$obr
znjb5NA8l9sTi&a3+ct*VuAqu3e<;w>t>SJx)*x%rUu!+RQp9tXIt?u#M<-h~eEdE)
z4z{t^q!w8gC2-r>IQ9%+klsUhu~fy}UANqs+X>kdw-{>IcO73S_)6k6HLhFL7Ezsh
z?sZ1R^gV2Y941451hgS{D=D*sv0eaS!?Nq9_)8nJ53IEA9Se5tG%{2x?M@NWfw&8Q
zy|-8okH55Jd@rlb@2+)ku0z{&tN&nhSD2I3-2@Ym!bI(cC6kLHRX}+{d3yDg6vj&V
zu6f4h4aGn-Bo$-4o-K~A%6N%vl(3sJ>yKaFi0NM&pD2>$(w+HI)0+N4(5e3^&lQ<b
z@MK}KO0sb0`0L{_wNy3FTzRI4;Hh)4LnohQ9PAOEB?w~U>?A(5zsp)K67P0$@N&G&
z_6=YOKd$l$S-;yqB)jH+^7=5f%DPA;S+aA;+(#SXg^J2DxcTjIzoT;ORnUR|+P+7H
z-9}LUDpMHx^|40P-YJdrF>IjvIjo;m{1(^K8$zX(HB-qSIH~ZB*Pj7!-l?P$ZR;7e
z)58J=61>+3kp@OpF~6g#cVXV$RR?MGwOR0!bJvXblfbMo$D62r3CH^|w>TR8_3!Uu
zxhZUdC?#P1Q>778G4Ac1FS)xvl{f7^z29Etc>0#|!Y0#$b|b@l)Iz+po+QQV@f2Y(
zMC3yF8eaKfZ3g5u)Nfb3kKc~5<cr~oXDMCP2@rtrl+D0yDBljrkMP>uxwjhGe4!Sp
zE_FCkMJxr9yT1m_7mnIV5q6=mx3}tTe;&(MZp=Ilc%C;fO*gwgSMq89Ab+zCaHhus
zCHvY|>zX7@V;Mmie$x#(np|Wjc+_TBn&k1qG!(X=$oX@$g)lv=(;uv4;!A_vpD^p6
zPsC$kYO6y9tOM7dDk;4m4r@;JlKOzN=3M@iNRJ|GQK9*qqZH?SNd|qBN6j0yq?@nN
z3i9-gOYt(Hv##SeHt5=239|r_O!tCV`ZlU<W9hq|*SY${26!M;l0c?Xr@rCChT;6W
zl~$I6&We02Rqsol=cx&gH;5hkPfkuQGLn*Sr^y)cklA$2ZldrG@h_SQ(e2wIJ7W~_
z0;b^l)Wcw)hS5&ix-mRgno<UK9_!LZ2ZVGQjJ_<vHu?N$uQI&5ajnU?3c;sza=tsM
zx?PE6tn4MY#zP)t)qQoxe1$T0;fut4sP;+wyuT_~wD?9j?NQr!;$Q*8wD7WYKH#PN
z@HD{G%o8_pj}1n2syoz;QhHoIqeDvwNfs%Mx!F7|5<AE*bCBQ?RjMbfK2bHaepn^w
zH2b~kgL_Eh^`j)C{!N|17q0G-8_O;5*(~XO@~OPau(Ha%%%0ii;~bU53%!C#V;M*;
z^0<XXJ@J}N2LpAbV~$p23P!FPIx&hx+U`MSL|p~uSV!iV1=sodM+1ZYQf>OGJE=qe
zY2~SE^i5NBLD76BMfgNq&f_-&T3^Xw45G#po6^ott8#q(?wK^0)Hva%=X(?U7ttQn
zR-^KdA8XEO0;C^?*zd1j#YF3Muky({)q@8Drq?H(f>3)_e*X6$sWzL_Pez_V$#0uB
z0s)vBp_wC<6m;3w!z|2Qru1ys8`OAjTLLC(E`Fd;2TdaP{%ZU=m|tAOUh7tqML;^t
z;5J6U-hnIOz;DRs+rc5R<K|ov`PR%6T`}47$_b8_;b+bQHPW4_PMq3dn5>mc;G)@6
z|Anva36%_eGJ6l`q$*h_lzbxW_Ogw}l@^H>nZsM1U!OoN21kY~%$J@)<KCj>BUwM@
zoqB-3TYl?Fk%ToYb5zO&4+$ZhFxIZy@7}JR?&KT`y{N|I4il}3eum#YDu2+sG&6om
z9G?rbVqo-Rlb^8ibmX;>9w#K8pJ;QB)y|^Xpp;>LcK3OG&>nOqz}DSv?a~f2W|yea
zEHCS-681($gI30W?QDjAW!3k|@auNq&ArvV_mDWR>BGmnns5Uy+y2aQpq|cGPHi@!
zj+HeF!V#aQ6AuR!Zme7$huAFDVfO|s0>H6JF_0n40;UVS#3BOgvKQf-jH)oGL$`ZY
zLhdn`c$*I)z@xZA_XLOjOw;<VWis%HJqR|qcM)M9RCh_E-aSUx^we<@bs8;P3~xOb
z_sC-alH1Qp{w)r$5z?2R)WZ7ZQdOHTzT@741s5Ase_eS|s+pzy4em(xeo4OA>&vy%
z-Ml3^wh20!1pbX;?+P(D`mjcUb=r<*lV|C|pKl5m-0Wxw<u%-!uIfmhA#TD@yhm?y
z=d1D2jiQkKhK|B|Zh!aXzRr5q?0q23X82;X9yi+sn;9T)9*u~ifmagR%!BvYjykNq
zC#lAtptIwHyB$nn%ry4pJ^!XUdA=zs*Jkb$aiDVPaG=J)e20<wrBwO^bB8haBKMwA
z_D_Bwog0fHi9e|IN_!ibOX~RyQH>D4Q@5!G3BU~@;W7L)M1c!=_+ez&2WPJb9oMg<
zS5BAm>Xc_A40e9m^}3QHtpq!mwcc6S3fkl7HW8Srlzw+BUk?8~uc6KFV5{Fb*)2D;
ztKEbC{+TBs;SVr#7o+3(o>xxS*pJ^SZ9FP~Ua=l?nC%_$pg(`TZ-KTaqT87(tJM0-
z#?{@Goh5-T&mbU2h{dr8)dWQt&sh{ciuKXWN}l4FO4L;GFs>6}I;}+89pMO5l)91v
z-!SDDZ&Od^fA3akvHNNz4LP|0r%8+HWjRtnh%h8cj|J0_?c*k28k}L`C>pU?_mhB5
ztEW9Bk=%sqrG9WoiM?V@(X}1tmIGbtQeo&RU~oH0tH;PG=XK1lNPnVg?I4Z^&h_g>
zBtLvwvJ6cY+l-F}aQOK=#iV5hDas!(Q>57*Szm>|JeUO^xrexyAI^CC#^&2oJb!|6
z&+1+<efd7pzU4-uh}*}Nv_t0^L0P&%@n^{K*f`oMf3-$zrIy!-9H2J<mdPJ4fhQap
zfg6?9rB$qlOZgT4oU0XXOT=QQ+ido-(DP&EStOi67F*RvTfzO?%WNeH2Gw_!wX|Ho
z2eDDDA-?gEtdcLeD5u<&od)d;uUQK~@i$@wPzU-o4peNMnN(i&8HvMm0T|wvcs}TS
z7ESBJ$(O(SZKn=YHPm@8b^APf^xeyA=<o3k;HPX?$+zDJOzRMrlQXwlm*iAwIDK+-
ze(KUtUyr&9Vh!UM`1I*zb8E8vzN4gQBo{QQ2~iDTCm_;eb#c1t(NM)$EAcrTkbe+4
zSasE8AQ1%Jzh(V!DxlRef<>HbYW<Tc7J(0V$98<ju%`5<lYT^?o9-{H7xdHoU~6Wc
z#tXy9f1PXs+<_wQy^Fi3f$)5BN5A5WVp&~}(dal|1an@?4}chl;na1AQ|4c>_-aE%
zBo5?j@>vgjyhD`(*?SNC;Q%(MbIn=!Anyn&7r&!35Un=UDmv{C&F@aB8`6*ZHTF}o
zH%y>qmK%Htr%|aKAhHOi;W)L_2|ZJaiJ+r_oT9lBVeX#C!<o{L@0_2n3Bcsoj}O?2
zuDT-B631bOojKV)$B(oss%p`#!eO-?xi6-rO_-{R`Kb-Gy*%9xnq0;kAhqig6<7;#
z@mR(!%8$ZuY=VGp%gKxY*Bh#9B5)p@2xbFUVQ_AnFNrrRDPN=9SGYi<@%>@sZO7Hx
zF83~kYSrYVUVMe+-OgE#bKTH3qif+6HiQ_Z_!`<7(7Ty~pByVC1(HJA`5G_oek`&#
zcyRk3Pi&N7>DRAMjs>eW-Mzk(x$rtKw>uW$e)>yAO)><$=Lq=wOYcxc2HNM{zDtqO
zLE@PRa{1tUim7T!Q%wfJxvup*0*=zyg)WitB66vO+aGQNFeJAmwAy14OxtAWbg>eW
z<;=Y}8>p3|)c#x@d)Km)TmPLfc+|d2+X3MTwypLrhGSLJ<LjQ;RO!C48@}8A()<)}
zP0>|u&Li}KLFYY9U~FEb;WbG&?)qoyKj!lDx&8(=d^o!fo%oRO-qCT5+j^mk0U7aR
z0=!sjLb5*hgOL=~6vM@#syvlb+;LRfE{YA01N@@x>e4-z9bQ-Y?1XIBq6iaqFR>>0
zv2wcHgwSOOSJ~(+paNBJYgF0TaOCMvzM8MDenaF*Z%_upF%k6HV4E2tfDYXQ@;Zo8
zi|NL}PB^OZ0I>t#0aP0OF}}<Zbx{zhT2+>7tA0i~p(K__Ky>bn;%gwx&H}~MP$0?2
zsGt|_0^TBo>XXdl#|Gc@9oZnr3Dt$gK$KVEXXFU-2shX3U3ErXVmoAokptdy>~&6>
z7pfxQQ)gVoQ<Gc@8+slwIt~5y9=fB_9ryv1dSi?c(GDd8QpgD=T7Gc4HIFoaf}fHF
zj0Qg-uXr-kl$Isv*X?@ed1JPAsjg<>$Xy<5we&cLwI_xwlU1$>!yEyg4kbG@I91eW
z)Ox;ogVS8!EFm+h!Jw-8lm#K8AC*!(_qmzTNm#>hPQ6sl|MWqMl45)+Ld1~fRHF4S
z2HD@vr*(RuoM~CZ?l+CPH5_rE;)Nu5hv^IUv-$Hwmvy5=3EOfWAhkpxd__l=?pNt$
z4nO`4vptYmX_@;9MG;Sc_XV@j>B}Y{DU_%rkIm&qsS2$s-PbsVn%-S*5T(o-oq9;3
z6u?IQ^GvK@FLN<`$+-XgO5Jv*Q0~vlA?kiA8G0FgVg9o~6;C?eK2zROSlGoIV_3**
z@$1xNjdPLGZ<2f50m<ee3#DO;1>Dr;yo?zJ)$d0%`3!4Jq)wc_tWT#h2~=5ziCl*$
z0nmOnP#H|C!8^z%D%rE#@KoB`;FWQ$W0CFHc1k#tuqsf4j|-rSL=1`taI*layl#cr
z*SpXcX;)-2NGPw~F>U-RbavTWO#2ssA(t!(1JCh(rKN(8ea@^dm3ZselQmv7_suCE
z7~ei#`C0X3Evg$SeyJnP;oQRf&nmVou^00D!GJh^f6RWUZMVsAxZul5#ZmL_?<EvC
zm>-ZL?}$T3lz8uFyTlHaVCZPyCym@(YtQkUG!*p>yT)tBMV|8Tif<|$P*w-(RnM$U
zmS#=)=$hJ2XO^t=Jb?G)X>wS1<OR3s!_};cJ?l_a+-L6TSIG8Cqslpxn6Y&));R-G
z#djPzSnDif+3-b@;dWwPI2C^hiAc)7t-cKDahm5$_eC|(&u+n&&#oNWT3so4v5|7f
za(BBAOK0&#@lxMwk_%*KWzC2umK9b#&+6u59JQ)!KD-TWfa0ZAFvlYLNQn9Og-^in
z#sxIKIM1W4_ct|*Gl)JrItrCm9zdN0%I$G$bCs+!JSoPu-GI-YI>&WkTPt7VCfy8b
zVi)J#o@82}B?e?$OAu~wm}F%XvZ}9~{=m^@xjlb&WS<$7|4Yw^0|GZ&6VWnXuie(-
zw1zgm<uop_=dvBF2&;T6vi%4=?QJbF5r|6_s4dBx=t3KUfKoTouc8(wDm{Gp1|rpY
z1))T5MUl3|L9UHeXSK~l!p*;&nSXIk0bXg9Uv4FxrsD-&cM(zOn!bD~{Fx_k-|qEM
zPS6qp3G(yb1>j9__XB?}sM5;(y0d*wVE`GVoz1EfD2+v^{9$JlyqQio&eJM%e`i#L
z@8{ro8cPdY$$xg+PgOjjp@4(ll~v){<|KKFZjCuq01D!~6Lk4;4*-THb3E2^wMtD?
z3-rnx;<AxGJDxkDGj{<mWMlaCpRp-7mAToF+cz$dtxy4Fu=Ua)tEpvFCB}$h5UnOQ
z>2#|Z<q8Q`QBa^-HbHnQw;y?KlFYUCyzip8`S{XXN?-@tlG2h2s<yrVpGW$~cQUPK
zMT)UEOHoIuAR#2Fk@rimE%x&}YYwI@HvVNSa%QTo$a3`~SA}bf6@LB;>j=9q+0VHn
zuI%mqYD**F>{}=PCIP8X$Lejul$#SrARq`93Qa8Yrj5RgcTA<+J@A6Wx`{JffSq%p
zhU6W|+2g&X<$pY@{@Aj=Uf2`JK>?<0=`aylgX$6i)uf@AdXFNdVY`JKy$73oH<0BB
z@Dk~Gm2E<?3Gzie|G3%SjcDZ;*0ujQJQ6bft9q5(Rn@Rl?kxRQ)TO!e>>AGG4Z0tw
zdR^SI|Je`z{GUwP<%gc@+1*KX-ymbx23SdH>7FA3)z#E)E@MM}T}*%KfPcON&M*1M
z8?m9RN4np$#9ZgSzaMr#B?%1Tles1H)t?{+`G;Tpml6py&>l>dbR&c2!r#O8|Fw|-
zfRepW`n0j;1|yl+O^t^<p5LT?@A`il`u!cd*Vzl#?tVmEGu!;zz~;+Huzq3}dvU-#
z%b!&sZ`XA64EgKP_2&lub0+@hQyJX(%NG;HaqHLqSSLLB0j^6Dx*twLR?fhFg?+zu
zo%GMy`29itydeI3^gttq+uCn6J{!TV<p0ruOyq?vOhVSw`bAQ5SG@pJ{NEn(_uu_5
z?YC2tI$TSP|KRo{&F|K)0nCSxV4-!Nd!??(u=D&Hr=r9DoBtWfzkVmff8i>>$`=j(
z?Mm>kRSUdvbw*s^T>1DlpyBr<sCBnDsi}W-^WW0`kCXM^T}1DYy}59O|KrZ;`jtQC
zE$=LdGGMbIMaLQji0L5NNd?;0Wk2-4fAGIAz+b;|nT}MI<hIcl1(lkfXMjKjHgIZy
z1YU&H|2t3hTPM+sq#Kk0oB`eK<(GiFEenv-p9h7S*8gJD{&k53?*Mw*1M42QrQXi*
zO6!HGI=5aB#ow0ut!UumHy0Ag1HNS<N&j%`1l<CpLe?ioOzq$9z?Y2azJ9jCOWrFo
zv1Fi|0of#Mv{`>lyN{Mk@ac25Bod9=>LVYNZU)FKo{eOczGbPL;3d+BX!D3k@ttBs
z!vnKpEF}<XVtz_$sY?4QT?JQYNnMqa2><qUMa!SnI&&v%zJEfK@4ufrFo=8WurFag
zJ`j~KkkhFjI$dVcB_W?73HB5HAt{!qOnG59FlK3*R{Q+_vU&eHk$+0apI^THh3uGS
zJ?50!M>Fz<<R|MZtttm9BgLjE;608j?4!%$5B|xi@z;&=+gktaPnl>L6E%uYkHFdY
z^aO?TC&WbHHjx|eSpMa``7gHl<(z=ji+y>cGIxw_gB@l7G*q=Su3&lnP+O_O9#b>I
z80Bd;ng$oNo!GKrh#Gh0B>Ns7PyJWR=3g}b*D+Yg$;6U29^v+i?Y|k+dZE{H+>WJs
zJuk6L^8h4<LLpYCGy2M5Z)>x18vpG!f7=G%>i`*WA(CnN{r6J;xg`I3!T#&hz#y()
zCqD!!X7C?2@bK56+G{FP81-)~=Rf(1Mj5#R`E9*YQF(xe_n%C|<s~v;l@6&C_Ws3n
z{jW~w3-Q11`?bAAoByzZA4UOB10KRi3#9&|0R+f=rDea8VTPQ(!S^3FkU|xG{_>Il
z`>_1K8tCsr`#(G6wjMBtSBpoJv;H19`v0(#-ns>5hBZplE``ecT86*|j=t5-7#+(?
zY?x%PyK<_3bS-#KBVWU=@!rzT#ldp2e;n#%Q8G%(g3;Z%+;7@f|FQG8X8=bS8e*qk
ztQS;eJ3cJLSNrU)Zt?7RHL4^n(dE7t=+deJkhStZnu6^wP4OFG%data21@qc=%|MA
z#DC;Ho=#h`^SjHX-%8x|Nh{KQcK74NknOV(GyVTeSV+lz$(DLkWBcc%D`QA~E4RDz
zxk-WIR=gFKll2nM^SZUOZAO{bEUY9)emVXwpTB(j`CYSHvH$zR$*`j-QzSg53I|sP
z@A#BB{<Gs-K|RB!|J4d#40vb5f&?Cb5t1o+(ONrq5<{L5Di=l4$dI7<pN%K5n`*3s
zgeqR8<K$U|PtVCm@(j=$gW3k7kqC3S*#EUnc6F*TNit3zww}SgY}bF3eVOP0gnYp3
z*D<nT_xaMP`Z#2yV1Z&1|JQc^=>`D!m%vF!gh+}p{f7<s@&gV0zbE*AbMXJ4eK5Cg
zqr?^WL5Gh&`t_@KF3^kGHv&(%HGl(_lRLiMDKsu;u0W?c66846YM-SMUqjc^DHlc`
ztJ5Q{m^iSIrJrJXxm}kGASEpp&AnR+o<*>ynIao>z5I8UkfX1e{w*y{=H$XvJIwZx
z+fPG3yEHcPdiPac2G6>wM;`$#y(4-P8xxVNyBPXp?)v4ohNRRd4aC)R*)|_uZ4Y}n
zwF9y1Zo7I+L*SPi*y)w_^7PJ%IJfnFBOg|GOtV&=jyV{crxo*u|7L!kF0J0ke+51O
z&`_)=x|}4f)?-p#SZqe-ed`KOS$eB7%!^)R1zxPj)oOilwria3uA8&iu3}5^_~FCO
zl;the=naR0HoH<D)tF$;DS%^d9JGj*c24_=yV}*R^T@E*qNvCUzh^(BpAm)KKzVDk
z{N)Y<JYziSEVYsRVuv<TQc9Po|MKatTWh;0Ktu$b033Mx?C7%!88)PkbS?=;U2w;Z
zwH4@pe*7j|ew0^%-1+Hs8Fnvn{&m+kLnY(w6NjZGJ_?OBF{BNo8|B6N<AT>Dl1JU1
zIL5!fR`^Jf#DHc4nQe{;vsmrcOtXu-{b8PwhUt#x)NwHH@)*P&IiN_^=iqMdRj!gK
zr3FOIGgozdNurO?G-A<^DzN`G-iJf2)CS6V`wWH%Cie}e`7S3@9!7SandWs4V94LJ
zd7sBBC-C11c5LK)zV@tg;CS=Ithaw&SH9whD2$V3@!#48BxH=gG|4%u;t!EBuU=8|
z1n4nfDjXaXipFh|Z*$6BfMP>hXlVzngkF=7)!n-9v8YgBQXM%2;u{>z*HNdq<gF0m
zi_f)DJ~&&>d6k#dbqrDx_Tp#yxoYcxZ*QnN5{1eqI40%Toz55Qqn<AErEqSb*Y0pB
z$Hy~+7@Kx4mN}i4G-!S$(+NA-HICMkkcF5I+_Wm4Iky=JJXR(U?!vKspY9*l?6OP~
z?QP@2l#jfIib@H01pp^W7r+`=X!<O<NNl%#{SQ|+yG#>vAWIoZ?B(`+nN8MFr6PKU
zhedu4L7}3KCM)64bG;n{*DAAByZC$O_1#*<nlA$UFWmW*M{)O_G{TfiP)DQ%FDgF|
z6`Porux({r6dt_rO0X%?IC(z0Zp<F9odK6ZCy7c~3G{}Kn_D(5c!^J%R(pP~YgeTY
zIP*=Wk^a;D73Ly**rnXj2+r7x_m}HK7s5W5b`sAZcJ^GBT7u^g>;jE<e;V-k@3gJ)
z$|HYMsJ0VinvdWM?;C4FZw#TIH^#Me<%X(wsVgYl=BJrHq`6{xt}!fLE%x1Wl$*dR
zBdhZ`Qma<&IoKdhsk(Rx1Fh}Mwr#eUjk%L%*&H!cJl!-^>V134-umd5Jw8_cWMuDT
zp~$MMP?&1o{*mN{lrMHCjTPcy?gZPdJs*)GhNz^dm^*mn^+lWieiUFU7l$IxdAKIH
zEgtNzPu@(fEvaFh^eRpevTnwTpLd;vnI-rh4a26ABkUg97;3_8=#|u@Y*kK~Jb!L4
z6e?iDoId78OuTDEpU7=?tWO~obJ47P026&1ZFS?f#SSF<g^~sOADX*uy$QS8(HGJd
ze)?FaIEkkkEL@RhyC?d@_g=V6H#ukq)?PMb5ilXltjISg-sGW+6?hVg<hyex?^O-9
zp?(%G<)dRDjFNfJAaF-HzULzyPgF~BVbLgm3|{I`+IGA+%N|>&IpSo*TIpB*l6*U}
zNj(-73n;&ezl2b<k-`{nSY%BSL+VN#?i9eDZHr3%Sc*!yEF^<uRD5@@$%)u5)&09B
z&(1^cxiNju^L`@~X8dShS@cSV++d_uj;kFz3W~WU_YLbfl7YLl!5{zlO~d#ZgV3;g
zQ#y}ZG6mTcfqR~#&C<U9lW97<+gWX=>Q>#1bLku5x<y)Tj5X&@kcpFn1oXIv?{MJ=
zwM1jaXklSN>2y(_>*|oA&*`AGWwPS=^LJ$(CkFhjl=^BiF>2Xh>t8H2;P`noFZpA-
zrV&=C3+EX%KFru%^^9l`Jzx}b-OYer3HfdJUA|pLHe1?#Rgd<PgebX)gFfF;1|T2P
zw0!}mpRp(hE|Q^wVLi~znffAJf>Q{R<4zuxj$l9yXO;JO_zh?vz@X-MZXMZKPAKOf
z-%e`!UVt@}JY&>1OM53y`<dgHeNk?p{ANFzg3J2scC**lpL0A5lb@^T<105)`j9`9
zrH5YM`CU<+&u-EjG$1w-#B+dPt~AU@VSgWJ*Hoc55jLwd8IK{e?nz^4%-h^|fWD#L
zD$y<vsl(~&RH>EUP0Dtb!-{A7W9YXJ`xq+yMC<%~bp)ur2-1h1-zQzhwTKG|)BMKb
zd+5Hk%uNh-`jpM*XOH~C_jg&01_^I|pPTk5vNt<(vMwrrJmEM`2I(o_49M*%Dvq#w
z+*GZL;Q=o1uEx|dE<gijmoXctniX{GjT%V-5TTBYHP(1nOWw2hI<obswu~=>U)KB+
zi+(=5=^NMc$DZ0>oUhnwpkB1Q<6j?nBqQYEFCD5lw7S+=RGmmZbe`Qfewvi(uwx*y
z#);woa&NN6+Ud5yjr5v$*v2&)g$~-B4ZD^WH-K6!ltOOC_K9`PLs!ZyY8wD)|1!HW
zf%NU7l4Q$g?^3J5wae>23h3%<X~kHc24X4(-CgRS=$bMC*PlPQ<j!=hyDoOyf+e96
z%XQAP-_qg*)lww5<)cEJ;I}G0s3vM9;ToU6EqXKS@Ab_Mhe<#_J79^%75;OA{qaQ{
zaeycMZ4K>bIYZ@#kag$m7Pt?Sw=SRu39ox;J*ghj%Jh!evp?0X)AA7WlyEo(z%D^!
zm$Y(g!>)w8FGd)poz0?Bq+)-BhcfpajS83g9B#kJwoiQTdgT7zmdm?#eZ2NbjROsi
zY!C&{j>!QW{9|&2-ZWLX;hvpGPK_;TPMIwq=gpg%`=9Xry%@u7ZRPJr6Kltfc5xG~
z%Ue?8jpkYFW7QoMWl?vQ^-Vb@C5HJ3BXLjQp1H?TgMMpk*&fAaCOm#LsUorqp;0%=
zR_pziS~FI2#NmZ25S=LfC{wK0(V@7vO=&TvOgko4JsZ&o3)J&{7IsZFI!TyGFa0@T
z3g}_HK|oZmG!}Nc5@EemGcc+9<?u-A(CPreO*&&zpqrOC1jjrrL2jEIdLBSE{Y;u2
zM1=;!=<jd?qEAl<*ST#v43V~_dd94p8RQw9Z1OX$tM`)|ksloQ{X6YIv5WW`GU=1X
z<H&T0yRmtM8T%3yAVI*VPmt*$M|*sdn`-fUR`bK{xYV9Cs1XW0z<cCVq?=c8=$L=k
z02_P`|K7iMYU!+G`ij^fKM;%^)!Abrm6zW2k>6=b`5|I>M?M=}mxi@7#6}fRv~}Z?
z8(R%);9=fRI>%+3WbXBvLyUxrMr)^=AyQH<KRy*;Nq1NpZ#`dncZ)^_U-)M(0J-;i
z7*{~4z@E?-S`k>s>itsJCy>K-FQjM6DnK2l$9Is}$NJ;r^D7+l>vffjxf;@IqLUH8
z$+7df)T;B2(B5tR%#S|m!tn;etI61eykhjnG<4RXicX1k^Y{Xgc`+5A;SUoo#ts~r
z3~go@FXCG=a|Tl_31`Z^X^!w$db~}J_}}I>{%lZr{J^b*KiRXyGyS;m1>BraGq5Qn
z+2$Z@jB*m)?8r!i>`rAEcj=1K5FE#l*5Hy<>nW7<UNz-W58Dw`XbF}adOWp?w~l?b
zq<D7c@WtB4k5|_!i_)>r7oE@wTmx$bNWNjv5(B|;1XVs#Y^b7c`{91#Ur~Ob6q4(L
zl5*CwYD?VI!h<5?L_tL$4%aVH7;GDle*m~NS1@j7?Vi10jPZzr9<87;&rrS&dWu8k
zVq&dX$9%NyJ~{PBi9t@JB-6pKOGNPHc3+dvit5nXE(h%7yMA$gT{<9Hs<z`NWOvd&
zLC^z<wiLUc@_ITO0dk$6F9bUWsGOdcWT6@lOZVOkl$jJoha~Mvx#aCYyT03E#k-b<
znqn4K@Yy$px{CHGE^7nfW8)2K9Pr}`u2?1IISPk`Ric+TzIwwWNpyu>k*muaCp)?0
z{p>fSAcLLqJK&k2cwscQcfoeDzQ|_ALPP9T5CxCwscd{{3bUYL@Ky<8)gQfE+UO_w
zYOAG1vLtS2a^HERpJd)k+JA(x_FRR5C{!G0O?@8MzoBG1SQxhKtkKUIuu!zvx$Kf2
zN=-xn226?t1$8HEc27Q7WFgUWut~m{|B*)~1)||((Y*JB_ZY)pZ71U1iaEnz>>UBs
zrWZ)QY2FH(Rau)Vk8+oghRa2xLmF;8h&DabxhLEgFTeXuM?=ix?znrPn0{{W4aNt0
zNL@VXVvw1<HQlD)Hf&^D^mNs$xBQV1jPap;kX7g<7*DQj6Vb1}ZO_l6=Nev5_Fd9P
zTJ0+4VJDckx@XeNPR2maV9o##x6@l3C3T#zK90ZuhQpWqHsOIx+jG_<;%t)ULHF_E
zb3{^VHN;r)U|$tG-M)w5W|rdf(5|4C&v5iXZQk6*gvo8=M<z`B)%}*9>r)nFBiIjf
zn(pTSvUfhk+dYJZ#*Ca5Jl*8e2pUL%=Et(XQ_yAG(d&@o_yBwg4vM58nz}7Wjx4Fu
zk-6((!AxK1k24u61O%5(c;(J86XYBc;3*t*+<tTqG)`LAU~8NKw(MACrxQ)cCkK<h
z*_dej>c<t1)X|kkgH%B*H}a2<&_z)PMbQp(FH|#|d(Oa??45c~(&v}%%nHnaGq$;q
zB?-CQA8s!1<YK8}bE#v+c3?Hrx(R!A<Kz2Z(orJmUkiG@O_=)7O#xk-+uF9R>ui>t
z;aAdZAH_g=>qah=ToUZFtl1o6pX)j1n5xrEa7oZhX#>5>9es1=DP7XHYpUzaBHK@R
zXC$Ts_uc)}O`r>Y+yPZVl6U6yQFNdJ%a!-zH+KYuWQ}nR3zX>1%c>ulPg-Dtm38?e
ziI2=brieq;fDl}P997yk+-H1$MsS~beaiaYuK5ameS3r2QuPW>Ob!17LcD&uqoH5n
zn+vS~e~F&**`ez_062IHT}~#VNT!o#psi8kU11s}^0zI}J|wpL;u6tI*2)h4?p;f^
zM=}MY!QohWEZ|bly$FvrrWzGOxnY)2@1BQt01CiDjck-YC74K9-aKT39d+*b+fNo2
z8BOg>Gy(CE(ti8b6CXf}Vb5>QjeDfMTNH)iPDN-4Q~ob$qjr5WP^rO<rn{nFi|gj(
zV&l67ke8)XFYiKDvEW+l!6%RA31kd6%3-2nLh{|qzhZTP68AC`Nz^4h(zW3RveUk9
zZ&i|O?oWaZ0gf$@4W>>&8&TMBjH?xNd9_UF4PVzTWw49(X}K^gQ6%i(on}2HnMt}V
zYYBv(%ErQNSyavHQOnqV9ICV{4sOrnSNKYJcfnKy`7^eo&9XJ+!Obvg=Do%#x5>fW
zn{T+&d?rXVFcYdhSWE$u4QgfeigTo`)*35<7JlWhYyGogMW<N|pke7Km^FxG#0|<Z
zD<5u8>Izm*+L7)76j&E&*owV6^VdGsd-3oTK6N4y6K(PF8MQ(3TH#>I0^{$%bq4zd
za``K5?_SqrK(Q?9ipM*U5LL3iC;b8CyhqdAxF-4I%cBl@RtB|OHEAx@l#hl+^n>5;
zKb%n`>$3#up-n5Y9ElEgYrS~vUbsiYYz&Dz3-u+Z;fC0{_B{)QwG*PlMAtdhC{T~z
z2mS$9*&WcqqsknYW)as>KG+9}Jp*t4t4FnYe4ch?{gSnWVfQ!sozmj#Unr)h{0Ggi
zoayQMWY&dnJglUA@5JUQUY_)M6Lk(pL<|Y@`G+c#_4y?z-361i5N~4;Pe*%f7foVk
zI4@#Q+_w2hlYp>YlYYW}olOS7z89&~IoPo6tEF(luL$4&0nR!e(fP6GmI+^YcDMW>
z+>X75V&iNz$b3{z5_EqvP&~Z`0xHWpPOo$`Bsy4IPF)}o4m^e6hB8a5xpS{R;M@3K
zb-i}d@g(b-3=05BAL|%O;xW);Z1-`t%FwXw^t|ty@0ArK(_X9VOIg*(`pw9^oJ6rm
z=eCR`D%H;V1>F@MzlCo%$#Gg}JdRz@*oK&S2gtI*WRwo+rA+tEUK_pN0jr(fI=AMR
zIrl-yGri5-6eDiREoyX}{8o{qK4rhct<nd+YjmaYYD^lYq=Kx6gNt<e=qS~BJg4@=
zwS*egVzX!yHcaFs*<hL5DK(9>+PlXm<S=5ha}-ro^BLO`TyhLwIn4BpuVJjJ0IZ{A
z%HCnl76nwTyUD4PXvZ(aCzHU6Tpvh&5<?QSnlbq5C+o%9(r`6&^=44G&QP^)Vuj-N
z7@er~vdbh3!N{;3^Y!tf*MRD%H0>wy4B^4eXMWQA_bCSqKt6D%P1%>&=K7O2#{9K0
zGsV})PP<Zf!V!0UW^3!XFRUK2Pk9xqjiSVHh&d;##ARZ`2uj$A@xVrbHsE-S@wZF#
zElpr+#G0NW350t8b0~#Ut>bL)ijW&nm^lulNaCfO`e?WqrHXL3rQ3HJ3b!{6E+TMs
z7|FZiGjVCy21SD`gMD|01;W;cEozS{r^zmpAs?duJfgQuvM<Nn6nft<4gDz%C4IP!
z4V)~b{TvwIbnTW(H+*i8)h(ekiB3z%%W3_l(9Re+QiOJ>`MWFK7Mr$~O7kmeRbs0h
z!4&$rmMux|@gMG$zZ1BO463IL1<~i?K)1hN*yh)Nl<hf7Ty`4%LAC<xP`%kj!?ss$
zL$&SM&ptgZSz0MCiDueb<)1j3E0HwB#1_Y2uPAcd4^h6V9s_lR3Es~)Hq0IlMFHl@
z_=UHTa?vR;(}^bm_2<SX2RE#ZMTBxRgLQP8Tr@};8vU6*E(%P<;3R8Lg<oa9g{Cr>
z99HwZHC($<Wo(?c$t4=%j$E16@uXQ>E8wF#4({F?!?TUC=%Gtej}*hKY~csiUa3Jf
zdGPNvH@3{oGJ{5hmmg>EgPap=jUO5Hk2n$FJZly8e0b|o6VqTJ;W1shD?v)0Y0~Q(
zH20S%U@_5+u&Q&E4#sV!AlVMg4+PZT)3FPQS!Ws<IYqG@HWnMFCq2!1Cw7J(C0-Us
zT%WL3AEbMa^0+RUK#oiY9WLPv)58m;CStp<<;ur;^BtKq&Mmg7c1eGx)Pdl(VN#&W
zjgw~yJ14WN)}yC>;?QYwMrjuX1<c-5#@9VrEcFCk5Xz=0m!bvibY@lwP|}m$_U{Gt
zWxSG9UtY^b<1+V#*iAM_dGb@7APW66Lm8Rr5gF#AZW}&u#927)Fi7>`77wY7ItdW|
z<2&P}q0QVg^LPSsXffCoOAkl04+;gOsaF=+TrTBKJVJ{e`3x{8Lt=YOcL@V%a<e>L
zkS5%+vX41ecCF=y<n^lbVwJ9l&7k5T(dp4)88>{yY6kiXtGV@{TMV}}I7$Uai^CUl
zU;U-MBlCq)n3ou>mrxhy_nq7v6xAc9<oF0n_Nk>XFPl=s{*NULyVq20GJp5lqnc90
zy5=K98*571EWHE)>K-L8WribWm44_)3wR!N%5vkt%k~+UHJXj>OQ#RKK2&9Nt#5)o
z0tL_@#-%$LN5Ni1)^oq`94ZyEpwrD&XC(DQ=C1Eeii29n8l6png--2l_0A!0M>bQy
zJbto@bnQ8bw)OG&rXO4UnFa>rcGwbjGIrb!pWU7c!~3vKJR$oP;`4VR0kFdOH9#h$
zC7{4$;)pH-Un+l>Zf_jl<cPlPhX_^nm)3OQn&rMPmhKzYuG`mNPT>~!ba2hJy-e`p
zn64zF+<3P!;V#;x8Yc;@os3mcj%M&N*pjj!^W{-hrheu|FL-8LUlfX9x?Dh7gsX6G
zu}^&H@#%)N|Mw&#fTP3PRQddPS`Ex@=l(K**J3^@y<WFxfA(|pv}a8L904x-Y#icy
z8gD<<FaV?osbp=7BW!LJ7m+qWPN?YBJ;_*wS7d|vl10?0wuYJx{rwz20#O;z5gMlc
zutbBA64P65i>LPtYfD8LIMD{1dCCHfU)_wD>`MY=f9aA{1@`H=d`k$!Tf_Y7p}zR|
zC1kNA#qKgBhcZB&ia3yAN-&y#+K<nmc#R07C{#@q)3QPzchu$Q@pT%#ij<em^6ak%
zo8eZgsWudWP^|i2mY<MntkbioV-?TM@kN!<r|Hw&W+VR8!%987)w>Dn#BjTqXLN&*
zIs}ko<%$2v3hxrKVDqJ)F-UKScrO9;PGutIFqf|=^#yS4^*%GdpOKE*l=o-XHTBH1
z>Dpj=>b+;_m1xWMsMO69CsJU+2zD#j%+p-l5&No0mT%Vklc4%at%r#^#d!5N1K^^-
zN1GC_-=86>tgMwmFt_wkFYAVr!W-$24$)n5*slHKj*`56S0Vo&8vUEM`6enNxeInz
z{j0CtD;2%H?b?rz0iyW~gVIIZ+!d<##!Bk8S<&v)eM6kcYekF6oCU@@VLy*j`!<5Q
zBq-?;@JKlkdn48u1%|L4y%&R>ABiE(43eQyjHfwEDY}E4cFSVl2nac-WRes#JVnB1
z3JFn&5}1gq_2+S%u4onGCa4(MLY}&wOZF7y3s~FC2&X6bBL{aw=7<~B4s8^NzU{nX
zM6pC55yCI^7~+ZQywHH`=RD&pwR=qr0s^hv&1x$MMB~z4@1|rexk~0u%0X|~f@$wg
zDGICh;1h`a=assvMk}R@AX#qXonj-$PQizM*>gC*)*q5Kqc;)hZbt}q-aYA5S77&G
zl0K{2Pgd|e>1uO*d5rG?AhvE*^c5h~jhlBCt{E&cf@Q^7+$N}6By<eQw*z>7F*>wS
zz8e3@e^GppKo~9ld8no?4TK%9Z|dJ2Sz^RDZoEAH;<i>>=hr)k-bcrxD*bg?g^dTm
z{jBvApRiJ%EFMYRv%SV!ZVI>3dfga~eKXz}hV@{})<jG0!@P=xC{c?}S9X}={~CD6
z4rKWo%o7kCZ9#W9`MU)lLM5xMNhE`82OIF>g09+J%Jj7{B&);9Na+fjemkGpH|kt1
zMsw|vnbg-;ut!8Qf)3xKu8)Zv5(t~&dm9G9&=8Y68eM)HwxoNdvXc{EzVD|pXIt%6
ztsO!LD7&~vneWKP_195rm`MrO-2f<Pu({61cW)JxkQ>p9A2K!`{dCOyQ+t0MV}-=w
z9(mb#l@DKUonL9T7*0CtDiVdwav4qiP3H%gmdfn>bff@4%sW9=jX1F&69O%N<Iht|
ztqLmEf$QJKC(+Mh;4OArUGnJ!Kw*H4ko0kNS-t1JFt$+7yBS+64QXXk6(mJSB8(l-
z6+tzPL>#pc&f%*ly+_gWqVl1_@xJleOZQA3JppKI--I@HSFXl>x<5s}eJ_r=6!x8R
z%XYd7slV^WV>42zl@h*tpA^s3Fwg%a6vfAMae*Je+oE4)Nqq#DHjEB3HE?sQJP6eA
zG%JR(oR&3OyEEf5;lkisvPzwIYym4tsK_6)*y~(;&Q7~%bG#+bw9%|uZ9VOa7xvQO
zeyG<%4KtgYfzXJVm7k4rYdQaf9Rg*!4TPl%29`{RMg0n+-1PTG+f~;9&cGBq4<WcE
zf{qlVphU+!wJ`G;DR>Ze8bY4NZ!D!el1RV0iJWs%E2T_w&Iqh#Dz-}i5Wlry2P>y(
z$aI581m)JAzm#wv_^{B&wQ0x{%3G$Kpyns}j%2)!56V^!85uDMi8xXy5mbDn%2Zt~
z<(70kV=&0TwIdR8a(|I-?MErpkZGMT9-RPZ6`E4ynAomMqYF0J@+>WFX1Xl~fXite
zxTp8g;Sz$Gd^E=>D&dt?Aawx5F2D4RzcfyS5;OsUnD9d+Mw2#8yaHCU3z{uQ8fHcc
zK$j;m%I_((!DdIj#<rs2yHHs=1OP5sL0AvN2HgVu^K7Em0Phn%+5+#RBI+-9Iw^VF
zH?tBYeO$XDG6@}2M89CW=&$BjPps|5HyXI(`r0mR*NP5Qxrn1(z>hQ17znb<lPZFf
zp^Nz5(oI6>4oe~F62x(6$GJ)_L023fAw(b&RuQ5-+zqJUOpKLI!XW<jG<p5<H&PVm
znG+o#a@fv{<{smC!l{t3?Zka`+5ku8-~izVInJMNsjXp;9;J@vChwVqRY|Mf>%&GJ
zNzU@)cC_zJ2jl!K@y?FE3>J&mFR@D8h53Dh`geDGy1KDQ%KKUp2p<fnBomgY`-2xn
zr#D0ice3p`S}*N$2Cs^}>ex=qL@DkbPw)#Dj#i#aT}qKcKNP=oy?q0_cvLrx#Q=4{
zjCUpSVZ4CfOgeRwUbVdsn}p+3$3Mc&&hbPhZ3e;gm##vOG<Wbfe!K74rOsOQ8rfrN
zf&A0Vl_?hiLmPJ3h0#L!t5TVN4T{?yP)@frqz&L}=&S0*B9>&JLy!`E<mWovi!mVn
zFV|8OE%+!CpK^&!(IK4MA~&(GL=_#~v7_2-VnENAx~NFrXKO6JAG`U?3R|5FfM%f5
zC(91bFrb#*X7|UGhmBSdlgjBPqS-oVBiK-@fn5^xO%iBUfX$DX!kPYPHvPtq3)0H>
zFlTxVD=R*XpQvG3ldK$ZFk<q)=V2%O!O(y2lSjHO0O~IqtlllUk_RAe-`A&O^IicN
zH2&&WxNJ@KX0EtV$78Z~$3$X4#{i>9f-@h84?G83p^hAs>3{wD2d<@fwp`k8rK$vo
z^FNE>&y^?T(@ivE^iob{GGe-_#}Za=tK5sr<Z};C+{%H*SnC;<k4|4%&)kzL^{~-R
z+duL4cAOrXtY{fZ%z7L{GS&7O9>ezYtll&8jJ1PUlBvnz08Oui9KbH}Ku4}Pm%p-o
zcbO^r>MpU8cWYzI>nYT>uWgiDLujC4|Izr*si|SQ*N#rOpm#TcXC>IoR3jXZ#@%am
zrn?((xBxSP1Z;m#8Tf2pq&j(&?HTM<lmQy^2#*hM`ypgdq9TWus*)RZmNVQUY$uPV
zjLJhroD<fk;-QFgrV$bi)%`wpNxlhj8LC*{t6_q${*Td|BzXVEgT>)!nPvK(0SJ$a
zz#8iaCoPON0P1hTGLi<Kl0%yUZq2#0dB%|@bBA$>(s+nRQiq2wX7jKcjHUnphuwz;
zwYxP>bC#UE09#QHFkJYagdi8vIFoKK35@%(4yH*@@tv#@K`*<~$)k0m+%n%e;x?I1
z@uQw}7wyyM_Vj}Z1Yk`2pa-r!^)37Pdq$rhzd(CuUm>I+jz@ST6-~gZ1263EyW%)W
z$M#Z%PI(S(w`)i8xf|-}y4EcPkBshi93x94@4e;~vWnVkxD=)mV+FDNw4&IOPCjGG
zgTMw8H`-oF@Svz(X`XtI<r4P?EfO*^MawX#Ja<M_@(ZIJAGv94XakKqkNn$~cT*(L
zV|(Wzy;P{4&?w?VPRgc|BJQ6yu5S=uVremhm}W>M3_oWr2`tj##ou_t-}9P^^_3Um
zbhVfl2cT{=k|2$G4{?Df=bmRi%{)0odnq=DR2T0pqD^lKG#;Sr)yeuI&}nQFBw^FB
zw)3k!`U!*JT4IHnqMZf`Rv)QbsDZg);DsJs`|SCn>08e8smkKn5kACgm9B1bWMf_j
z^{B~DnfBE?xh}6&_1C`|i6+IijTRjX=hm9;EQ`qWigsKB5C{hng;)|1djnS22C)aS
zv3&KOtLeBbS!1U&FoRmk*pO#m)Y2v<%T26pVbgN1a~`Nzl=K5VN9NrxE1$*9(+g6Z
z&Dj3pv;$;qK3B%(`T08i<lA^mzCRcpLzj1HC;V7GGBMsY0shH6Xm-$`xKC#IjdHFJ
zeYJrtfv8$Hm)n-Q0>CK0F7_C}buKno6}LRT6NEs7%VC&?@Fq7DsdvL~_=@@*(fn}i
zfecR!u^TV3|FFr(q}02oDbZ0-PBEpDF5C*B)O`U}n%qrCAz;{C_sFOb-NRdPs*Usz
zLYJM)Lit>1%cZMB@%$GO<28F1WJW(us20_97Rw2+d)Z;d*N-&}d8HuttObr%*0T9j
zC*^{*Hb_*V27Nnt?%NeQ5kss3Rciyy@|PZkRqq)e44bg*?%XJ_AFKLi7lCzLkvlU!
z#YLaqzrp<lYYejS3Zyik(H&Kg%>b@cuhds!#qd`=-1J_an(YnJl?WT!_Jem%ZaMD%
zN<Zo|L9=-4)T7sxPu2B(BmIY8T&7z+y_Gwlm2bxWBG@+&T$uJQv=o}qC7C{~0C+tl
zkRL$KO~GjZj`ZRQ9pPJ?U=HuYrB}w!=mJlWQ3s>LBgw*gI>D{g%XJMvp?aRnLi9`J
zB8@wr{E2%K*9vR|Kuj~GNGY3gr|9uD8!(a4wjYL0+qk8=Q7xxb-}rnmH{?=54+cm)
z@HkV*ZDIA0`*6wJTB7zGz+70-mPJKX8h9q-@-eavNR_BFPr99+5F(ZZASMQ=2S=L*
z)F;NZE{QOqw4Ztn=Oo47&MK(+GJG#P^6?*p?mI+zM~*hZj;C_Z#ZE(2(Y*UWlCcWs
z*;{EFOG7@~k_Qc2lfK9mO>V7mn?}Pa$&eR?dXfV_Mj8m`ypmB5)N>IxsD3-wzo-9U
zRxcz-C&;tbDZZ!Yd&PBTSyLrBp6K^ToH9c*Yhol2or;)Jy7$oU(Y6P+`|gS#kArXV
zFSosFmBTQ`F3^}~1mL9Hkbi*oWl0p0K9DNtU3+DK$1^zeVEEg*C5wYY_dl(r7mV6^
zKwdqj?2n%jbuxAkh{sh<i=VW`ntI2(iSjQbzI+ByB-U0|nxv&Cex^KXv{}s>l}{G2
z;{j~ss~!<~u7ZbO8n%1c7QAR0W~NTVwP8sAoVLQKYeh?mA<ZhAvvot}4%rYvn%`~m
z6#90^ckN4~dIBPKX9hrHdco3zyi8vf`De*MzYI%TMgxKCdpI9>Wg$h7t&E<=J2}j*
zUKqV1qAB-S+TGi<4<|V|WbyUKo!&X`M_&ii;&#RqgiRR|CJNm^a)u^e37n?9D4frJ
z8O6I?-N-Lw!ye<Aq{d;nwGrLj*hMOv&0&IF-OeIUaZ}bSxj_h3dv{Hxd1`l~T2k37
zl&<jdXsWhmqwh8K;Tn6xB}N+2%*pcF72KjQeYz$*SUO*q?iTBpHT}9`bk8s9$tZGm
zbu~RLb#mKDoPG}CU%y`nO{EX~MeN|!>FL@xW|8<JTIgUGbsMLJO9*hngYab(i;h6z
zImtVYKm~Rmukm`m`nf*(plz)JLximYZPVNGU=D6l8v=OPen#w~*LJdXh?50U;PRwj
zEHAM83*(*};wp+})zvBh2zk%QEWK?chwk;Nsi;Fkbew|jggawue~d*839f!mfV(5_
zb>(V|rO=KxtqhQVAu&Ez%jvFN-*%OLR%*SKXA|sFi6P>hggaVVg{;R?XF$QKwrFib
zx{UY!=O$ziu<bFEQNzw^ehl9Wi9gFQJ&VV}T0gxAY12-*eI|;xco;*mUW;g<+1f-A
zo?2Kko3x8IXoW|sA6<hW-;-EMD{W>Ld8T%LM*#isH)ez{r47lcvVb2qQxls5nxrL+
zr+qF8dnbZ<wEU9i{`%1CAU!V9u}rFj*CPLiz4wf3YTMR_X?761(p3}$M5Ke1pa@7u
zdPk+#00Aih0v1rJbm>TM0qLC}y(7IR)P&wb3rWbkJm;Qs_u2dGd-uKf)BF4Vzrk8r
zYt1#+7-Np{jAxFKF;w;109s*fw(-nzocU*)HX$T-9J^O-FU7M2P@P<O?sjYU9R#m^
zs(6?(kap-a6Xv+aqbDidrreXv41w$(H8F)r7%}v`tdwK%k_T!86tlPYV&#V#`xU_w
zHlC-MG1eJ(>nW{}8TG$%CE5!&R=B&p{uN9D*p0PP)B9&rZwgGyP^OZOw!1gw{hB?$
z^%^M<2TN+8@e<+_WlxZRf1Vw!1g((_OWMvHa{dmjx!9ftq%mY`zN3p&edu^J+87#h
z;QO)~Dshh_1z)yYj8L`TD06JNUB^@_lwE6W|Lv}DS6N)Tl3M{>{PUej8z&U<eL+CQ
zbjb)+m+cxlj+VZc5FX93K(yNoZsM!2x4!UrGh&3yf`s9y?PHlt%de@l8y(1X2)`?n
zp%rwYpgoS?^7&c=(xtb?acB6u#Hr;jz?5h6@zQUf@v%|Fpf1A3rl&tKK8}rBU7ut!
z+CFAR;eL>qcef1Q<EJ~>PjDU{(~_0eO#32b>|d<9ZbUx5G#m{PSZjL|XIog+UaChd
zcxWOz#?Nh)5zJFnuL5t2JC>N0<Y}1~*RIjjQ{5+aawf;c-5R)&QkL)Ft;sKchQ7)q
z!|El6dR0z#z{g;R8q3Q3XWDcUC)h96)q+2gs8Ufd6CZ56wamks58qz6jvC*;=sLk;
zZiKRqpUymY=J==a=eO&VX8V%GF1U3U$`3R6LErg31t2(C+2GH|LUsYH!xgTZTR=F>
zM46diy*yTrKY+;+Lg<{99$5IVnLn7$TiL&KwZ{0{PkDsW=MfLK^@~RQ&iG24--9b(
zRG;rmyk&|I%)xN~Znvn^$&Ifd*vGo<rtDoj3U#+N@OsENKfw2VM_5sHdoh&d${nRw
z8q;B0<jrB(_u)W2ZpNk*6DCZPMzd$94J5md$G-tJnLHvdCVM<7`8&Db1O3P<)Du^c
zt&^uKz4tmc$`^n3DZV7Of4x-b^xnp&O7oL6`M8-6mi39^lJ>*sp(4`4I>P;pJis3<
zbmgv6Y(Gg}LrjV_u^y7-PH=;iqLT^@#_#p(>}oXH9Vrtk;pc?AYtT=;_RjFV>5)?}
za)4M5rR5L9hcr23irC(6p`LQBd54a2*L0+1YP`4L|2?zUkAn45z-KaKs-t%%;pxdh
zou_<5OcZg=i#U_uOiEIPve`P$M=bG63{A71q&`oI9jU=pRs(pz;iC&Jjw|ZOF>zLM
zbU?3+f}3rBrcx2vH}2FdUi6ahtT*1RbC&0XtMcOU`^f1p+7Mpu>#@-m%6*m0@npqs
zmc--uOrN);LJp7hm<|v+L<v4K3p~9N_@;8>PiEc{b%N`#z4<=B&6wrlxT>-gPShI6
z4oY--j4tFD!wdJ9-#&$LalArL@62!Iwiw?Lt277m*QOBtQs@m&dbiyQ78BNyu?}F&
z=3b<Wi>P<lGE|1=ldTgXpx_*C8RT}e9iTj>NtUq6Vc%}QzJ9f*P+rw`j3>lh>16A)
zk%&f$<<M@u5drgQT_g+#b=W@Ke6uCC(Em~C$~cX7(PKKJF(R_Fqb7Eb{=owK#m){+
zUcJ!-D#vjJil5pYCFxdohXPV0+1;iI?ysKZu<0+;uzBxQFY9QBJ=Rc8GnVy9c%Eko
z$aMHY?1+ab(dbL`@hZOI`RA4byEL-G1T2OQ<m^Ba0zn_yA|#0I&A&IXKdu1Hnxmts
zw*x@a^g?vEd5gcwQ&btn3m1XsfLbrQ#xP<&Bfy?!vMD(R*nbj-gD##^+B4=r%Ll))
z4s=gSY7kY7Bm9_TBXvw8U{%zotOTaYALBkh{r2Z`d&AC0t%3JF-z~Tv?<@qAa-Wl`
zjE!t}<6O!ZagW;631ZF{x>aejK{1rDZid^JASop6bdx6eJ&hnUKug2Kwa<?yhOIlk
z3ybe}tbZ~N7+5^x2GmwZNTGs$McJvww-Vy~iNK!X0+F@f5wI6;l7snixTTzuIT3}Z
z7w0Dws-2@LDZfkK=xIA=*_U`=r_A%_df7a9pzJ%Bh`2;h)5jr-PFFor#h?MGsCVr7
z7agRhVH-ex1%N!}3eQP(_XKUDMdVb<ZkY|^+mCi%=U_#rjlOhuIS`7>wJWaYyUG!d
zKseHR{h7MyQP-l{3629KbSvXUVA_K`{gDW}&Y0=@Vvpn#>lPalT0D5F8&+^jtsKIw
zPM@K%c8Vot2Cb`6FJ7+yYOqp73uD}fqoKAq&HvsS;}wLEe&rhy5<)xf4KGLFhzQ~Q
z(Yi>DJI0i;TeXK8=z|27uK1{X3tgU(cU3=J2QAGJIxWRneJP>_F4VgQsTudVdSfkq
zc%^XJNu&%ZT-9FOU@yGlMQWhAs&Fu=KP~BwvQ&=klW=BJ_7|4_l+BPB;T&c9nlj5P
zUo+!Mq^aB%o<EG}@luvdG_4nEv$~kjQ#CNO>(6CLHg<NlO!#wlG+AiN_PEiDcr&HL
zkS!wIV}6CS%ho%JlQn)hrdaGX{>2GBKuap#`pCtp^sT*Xhvr7Sf7M+6%bP9A408(X
zYH;VQy{M~{RJX~<&q|R|T=FIR`=6;5XCDG}LI_w848;IKEQZaUAh#smIMg`>rgV(L
z4dQsb<{~Yot6raMd0=CpT;!U4XB#8*D|VG@6DCz|i47fABtO~S3}tj))UWp<d{wfP
zpA&H=Ca-XKwMUm?R1y#;gW2k^qI#TJTc&zwiV$uzc%hX!XA!%ku#oIM<wY6l_*H%A
zW@ynQVku)QbBtLShVM`LoOqLo&&sYmvV(Z%cOxdF&|+6}<D&RbU(F)s(?OWsfpOe2
z(;esvkviW_iy*npNT2xFs-7dAKta~YCriS7eJfI;g8;N-v@%g&gfC6Q_a<nyJ1j1C
zn)+deOJWt3(Wz#)f7XJYyj{N{;<dWh*|_CN82H|Uo<gc8fD<b0r{d<M+Y;ua+Y|gK
zWp8nhttzaI+V^C$5FywU6Ffg;Wmo1<^9LSxZKwSB9T)NV;?8J*YuL309&;r+!52}a
zJ@K255_!ba+=?E^G1IW4I|hj8>R6veB5~Xx&GieNq+K1|D$VnQO~J>~FQLcfm2st*
zzOR)x>u!a%k&?^|!-XHrztY{&K=#5;dUSd}2DKt$MLL%k;5nD%q9nc9wH1h)_TuGL
z(ZZ>=`WYdko`;N92b-v5;auV|btgmCAi2-Z8aM&Jc@Wd#BaG<InY+qz!ip^ilQP2t
z4jzcQKG79^Xd>9(6Nm54NfizIoE{Cx=Wfmj+?EG=fj^b>xYWYvd!15Ja5ZEri3J-Y
zv&nQ8el8r?Qxi`_YF~8%^j*NRFZqCGHcPpB!~lt>%-wbhd4T+iFUURu&Frm*8<*f4
zYFYTth)b8*6sRrIlP}|#VY}VQmm5!pA@}P`z1uz0LGXus?z2{^D=4o1Ghv<E@7Uh^
z(u!}3Vw>4dMyx0buW_^s>neDb7#YB8ZX0;cGlIO9t8g3r1k=P+nUCifh}W*m(->*y
zI%oMa$7TFh%Kt9#U9zuQ14Ga$Co532>d7K6m{1cP&MTF#&D~p|7ukEX(@exS?2qzc
zM~Y4g7Nf(1JU*RLG(KpfWjSX!S=6t_Z$7`?$V=3%aaL*Lg}z#zbqY70+Q5lSg*UU&
z^~&8SRY0vlV6PpL_kGf%PZ@e_8HM4P_kunTg=A0mW3puM&QbG)frX}?;QiZI+h<;}
zg``}6v04%hjvHA+o?|Qp2?!sfr}{k?zW=~MYoC<SwBPtoMg0$*{dw)&@V7fsY958&
zc$MV48!OLIGc%R2@v_=1X-*Z69{Em1KIif0sI|2$ZY~YXhRQgl>=o+^T#rl^vK6i6
z+pd-j7FtFQnoFL_sz^RFZ}Z}-Ex13ylQBG^?%GI!fP246XhKM3{1hbl3U1Z)0uhv%
zuF>v*u1H`ONS70Gj~w9T7`@0W&;^w3)(5cy1&Bk#+h^Y6>L4s2k6{{z`G)L9nQttZ
z{uE`7(`%Y0s(yM3ajgnR1`2n>EL6L-OgIbzC&2Z@#FX~7;CP$Oy8X*TS-pa}-E1L<
zJNb8{IKRZAuB-AnWtwuk@Dv<zd>l(5Ht|zD_#wjTKtJ!JS`R(d9dH3Nq=0nV(&CxR
z_$2Y2^hwh>dJ9WOu{?D_l{({Y&S2kFRqqL4^TUsnvZEtbk{jpsyZ{!DZ6MwRk-~;~
z-PjF53KI>(2U4P4ymS;*ccp^`*KSk?oSz1x>0rud4YBK3l;E1s!*h%fn9F&()@n@2
zMt27$NrorEoC_1*4?6~{pBA#=UzYG5;U9F2o$0%ws@_g1OJ=DW*IvIRs~Ds6Y}jYK
z#6E<Sjkj)1pwj>g3-?rsjYtkVMPoAQDWVn_G$$jXY(`IIiU&+$*+bc<EFavLDEGEE
z?~0qWkXrq{l_sO;yrNs}9Elr@ZNL<f{mfG4!ipiVKZa@0J$i2%4$4z30YdHd?@D6y
z&BMA0Vs8ta8XthyF2vSF2woR9+d;DkX6L=AGjKOex=Ojz$uS}V*7DP`#heLk$K7Ff
zEUMp+5~jt@NjY)^p+vBfs^N8xa(oWYM|>oOxt*y;5#VNpE1Nsp;$NYKF$YkWwKdUi
z)sMd119Ax#XH$Jy15_`57z>Nces}RbABE#@R+oPWE!ElKq&vRil-<~}y7!71ix16z
z@F%MSEMKd}7yM3y9!*VpDR(4xo%k)lhsSlD9IWMA<b{PXaB$SBhn96V`(0xw^3XYF
zLJ6kC(+Z2Zft|rg#i$?rU##3Os&=BViNydjp)v4OwuEZUrmrzZWhNvB+ry@w7h5dF
zn<fx@S6$X6Q!$nqIr|C%mf8!1ikQNF`o8o7T7og2CpZLy1R4)}ASfX><iQ=tMn+lo
z4G%RZ8uBJeQ={6wo}hF^%%*7b`g!lj<E$vq(g-N_1&6l(dE}R(t!mG?h%o}ZaH19#
z0QNF1Vv#g6q?Y!zNPdU5&-#ejkwGE*j1tswnT#I8S==aXe<Agg88jW=i(GBytoun~
zuGm8cYOUSYK}X5Xs`;6LBUwQfcNC`1kHmX&A9`pH8#|lI7kF@--13km`zhsn+({~?
zx~{k@Pz!v9n%qJO8a7em4KLDU+3(?OX2Ex)Tr-N1YmIB+wXORO?Z1ItP0a4u5YCnu
z>;5^1W?=cWw^y`XSY^C6v+!{}Hl1;*7?QrFg~~E@TxKY5Z#JO2=;~eBAm&4G?3z_H
zFE%K$dG{#xvhO_8935}Xyzv&Z+hHv9G})DMSD#%hOgPMY??NuVD-|f&Ncx6Dh9MS>
z)hoOKpQWI(%P&|iulTN?w-lXJoghiHv>ShV=3s92X}bNFw92KU(?KdqEgxUA`YMc_
zx-37hMt4>-FOfrf@bi^F*gUl%D(xcVIvu6g7-1#FXAp90cv5wZ0sK(NgmfIK#ZU3Q
zF$V6%Z>mKG?Q;+e`>H%p7bo1#Z?UM!AW-go@DU8XDCZM-%!I_Pr^DvpO`?w+-O+os
zfqYbI_rQJ7(P__x_sGBtE79*=384m(W@v7AWP)i`M#?EgxOmDSuT9G}>`x+Mp*PM<
z1&c`ljlQqkD`dF-O_Rkxt$J|=`hH=1?y=KC&7u>kgnQ$=-Oy+>I@ADk?UTxB2H4S*
z2_NWq0ukRVH>C1vujdenJD09S)l_0>;&@TiD;f1qSL`2p<Ci6M8}cFbVzPcRYg<Ti
zvcd`;i8ny+u#@=r#cbpP-6GkMU!Uxw>rBiaG}z{L088Xl?&C?1V;z(LUfkTw;~f*4
z<Bnp+G+`DBvQKtDMi5Y&u%#DMH8hHp3NtM3vyfzVB%)*GBfgo1Ksi)zyQMjpaa8|i
ze<~LR6<_kClh6%!o0CyADFyLYR8Ai?1e-e1x~%`a@9?w3arfA35WhBFoDVZ5Y}Mkg
zqIGz@Kzwx<736p7-MqyeeMaJ!m+n#e+3dA{dVN(rS*L6mbEChObn?EoBug7vZY1q{
zu<@Rm<hF@qta`gVTWs-Te%;t`Zv$gstU>vXo~lCjl=>5&qaUc=)n0>hKNYB0ypLcR
zQS+`!T#SiNMrNNvS9XOd{mF*1rfq=YFzXokk0B9<)4SyS_Fde$8eNf_jh4F}WpTo~
zILB3=Gj)ga=<?yuZf<?<iG7I@*3(`CS^I)p^!)efbdLI3Nf)_%@{|ZGJPi@AskI19
zyC%6?E8p-SOP`aTv69oHm2M0Bho}3B^lNW#*8*#QrPJqXd}tVzwxq`qF+~`4`~#I>
z+TQH1+S_vmbtslg(937M!R<Xmy(~PP(D4F#5GP7hDYe`ZO0Qe%+PNwhEUx8hg_-~r
z@F^Hi-hAjWLK9P5wEGQ)IISul`^fk)!ec)hJ-8I)Qw4Znwxc|JZU_u3$9+$_xlSuq
zow$5HocEy*XY>IC!=MctAg4oDUlCGp>9;oV|4?CAfmx)hzx2`@JI@uC0Np&YTIGWe
zI>lDL8w4AB-*qiu6eDLP>wl~+OSZ(fJ&<=rgMI3FAx{tCq?dYf7KAEPGn&j&o^t&1
z4i>w>@KEHk-lLq4HMbQ9MG_zT*+lW515pe-{fCtPGmNl_X^a;%=m8O$D|`3HR0V*J
zfC31@Qeqwh`PtE?%%Vj>s$U+Hc44{%tM7x>y(KPGmuHAd2iYCFv#HT%1uVHRDj&Pd
z`+rPwL3|uGJyab-)pj~>&9>^m46UMo&M4xjui-;ICMPRy8i0z%e)p4J&8TF>IA4gV
zTVxKL)?rK`ET_mMLui@Be0~y!U?+ai2c{qgL;A>*c~o|LEFfviV&B*HHi3HWRc=L3
z(P2I$RB&5M7!=DGzcpgBtj}>*!Pv9DZei%<;o_}7hDf7lhcoXq&S!$DsL3;a`fM?=
z@b@DaCESNHA+)SZFV_4Fc;*1-z_Km~zva_Y=8$x7>CP#2jyeUO{rSV*E!e@9hEvDd
z8W7TXWts`6IcM1Kln7HO%+T*0{gg(4eU4fXHI*tGiq<GWiZ5~p(Rc2<bG++!(KbwU
zCC*r^1d4_uE0&7A2ag!kcQ8|;9(+~Q>Ef3$>cM?CQ~HW@B~S(x{P0;W=}R7ZeK)q+
z#h09GZ9Wu^kqs&EgnC9Z&)_|}J_~0?z?y?=d&Uq%9oh5mU(N#_I02}xP5I-1<t+W>
z4mH`pw3qqMUg!Z~6Y~Ybl#TYm>tGLL9g9LzjPRD;7|Ik~kA1fKwHEt&OYAK+^V$LY
zvTsu-w4s*b(`ixAt{-Td=5<<>iPnuOS+c-|km`P$$cRPkvKGH}Q;#p-+ptY<?|yV{
z!V|Iib$arST9~Iy<h=!F2mK}o-5m%C==GGXsxx}Fk<H{Z$HcYzeJ1bqaMI=Nw>%YV
z!rY~?!ZmPhxuae#Rd-p{lot{SB7}o%pdFm3DJHqM;fF4*>W){>a;_gAuj^BqO>sQI
ztp_8CyLn<mC*(nkJfuT4-Z7NTz4%pdftjIa+H>eVy2?_d!e?O+@CGgSI&AAZ3uv=0
zc9PAWQvER#ozcy!ti3T_K2XI)KK%qwl;xuTpi}qqNro@}CuNFjq#2q=Nfr5lZf`|m
zoZo+WkxnM@tYJEfzWhQY3;tQ#jtCH(@?2RXM+QE>+Sd0XDSn<#cXPLaAO2STqEiSN
zusz<?=Xe+vM;Y)oc0t=GaejWZT!S68UgVV)EtF;!Sh^e9m$DtK5%DDh@#Eg0rlRZ9
z;{KsxQ!#9=Dxz|{TVsrPIF`IaJ$F9kgNlsW8L<&g%dQYv?~GgxhXZXz+t;HGy6Z*9
zG2oBI&e@-jejh-mT3^vc_|y)VaDQeDwBCQ|Cb;8xeB)8)rkV}f)h*yXen<YBSZskV
zwqk1rNt5nW!*SIjL8iMz>@lP{;1JV*O{^wn(RxA}p0+cUS|TltQ}8Y?RYLRjz2+>>
zg7S&ntiD?kCt)&ls^cP@^~4E&6QLAb3n{b?&PXcT52kSLOv@}fM(GwlPJI6#D8zpn
z6@gO}uGVM2yOG|a_`hH4fh#eBhW6G6`t7Dmnt=4^v_{(#8_)f9Fk5gfQs<3ZG;&d1
zyQ`q^!J{$C;;1kqo=SBosB2#&x^HT*`<e~iGY-z|X!j5fxyew*8L)PN=ahz!3fF?7
zC{RTWuYsLRKy25II2>G`sdZbkclhd5NhiixwTDi-Uj)SzRfQ!KN2Q<ElqAI=1pA5T
zfMj*ljsDxSX)7b9zTpum<2UXGTs#xqx72HF{C><m8QGr%TJvxeu`^3l`_yBwofgNp
zB0JPzls#;|`+XX*rN$2%P)w%4-+^&-13<#pDRCJ!jyJV;?<*WiRAW|O!{C@xB(&aP
zb_D0gx^~IqQ~YixSc{=iEm>pqeRV!qBlhl0_E@8)?nZ$=US+nj;fxXMeHd4Y#~#eX
zSUp*Qp`HL)-IE7@uZ*SRbxEu4tSzc5ZodrYydy*CORC9y*Po0tCVBTHkrIV(yEVd8
ziFg`8^)~fn*QI^o6epM`UWXXXQg+_|I^Eif0ln8_VEt9DCyM6|Cgp|k#ufG=_J<xg
z!ge@u^IOT{OS;VQ>(VZzD`Uu2euLWApR?C%N5q^*gs-VFHxSXZRD-2M8kgSQ@2r}3
z51OFm^06tWgnx(t&o+F8w${rABJ1n7poNx(&Wp?B;Eyrd7CDx;9c$gDxmm8IoW=+3
z+`1;rU4BXBv~9D0=wXaugU}a7y8IQMhkSt%?8j@_sLPUC{0Q^Lo%EEGeB1`=xI4-(
zq$@QHwhW6e^2YN}ZfVNOYOwVQZ4|D2Q9y{VfcIB@;J3fO#-4|a1Qn@nJx$)3N|J4p
zFSHuDto)@a!b{Ymr%1xI2}RsPQFW=q{Yzf$bj!B+@U2FKr^J{xEVZ3c?}xi|&YJF&
zjA_V6T^`o!=Wh@vDz>19!cM9&#iVlxV!GROW&dr2(jZh@Qbi#d-y5c65|$}O=Z-Q8
zJ7zwPJQ!qoOtH;&LF-^q{~Y^gOHJ=P4W2i(%hZPrz@$mANnTHQhwehf1g%9`n0BGw
zD;_RugHZ7ID5{Y+Mru9SGV7_yY4@RwH;-rxv2ZY<3qMmuL!PJCNA-&RNZR{!<!0o|
zp^M;C@U}W<wRcCK&i~$(jz3H8fr0gNhdq~sGoDElq1!l{{t*NBKKimlHwHHp11;zt
zHGaH+5y!C95=7+>r-QBCZrGnq<weCBlX9!K3R5GwJfdM+OkwfaFd}LbzPmX#iT!xB
zKr07vyusrMVf%sm?pURduQ#8v!8WIyMB<KEVG;T-g&pX1JWt>I*w9|(boJuzhjm*G
zOtm_AN$SheHxf2kJt@E7z6^*s<07s9`U&A#hVRKR&wEPozy&`ji0<t1+D+IcH6frV
zfK{}cZax`%e>bhi`7Y4$3hA6-g4v{93&LX~JGo?S+?RdFSmMlATG%Y9<muhY?Eb`U
zZO{wol?uN{h9W7i4R6bI1)xZ^LN8u%wKjF@JZe>cFx>#D2Y;QVH|a=~f<<T{SE>5z
z_tK>ZIG-0z#7;}nl=$%+NQLG!hYuacBEROBd1ONJ6%&c>ovQ)F5!&f!x<##%WHHHA
zPz<$>ez{%Jn+3_Wh$V>EN9)6{2PU3G44Md_x5KYFB9R_ztS2U`simw-V7lPN$Q0sy
zK6)tSsMNP9KPsv@uxrj8NMJ8<tynUfSdV&~-#2BXyvfmsgkstW2uF9kL03y5Z<s`(
z{h-I*DX?I~_lTmd^F)rVj<qVJs;(xp1Zh{5A|NuD>yncns3|Z-eb>7Q+s2)qWAmvl
z`*2IR2eGdU7Q8`RiZDe+6oYv>9^##iG>S0E-kV|o<&Blj|M47V;P4<HgRqRR%pvBP
zAU9wKdpf;xEGNywra7U<Ki?xPeF#{XDwBpJtSg_v?B1(2Mtk$G=^(mq=2z+9^}L6%
z;n|Uo+V{kHJh^Cdrc2WJ+<+AZ2RqOmKG?7H2`|>~XXKgT^Dj*+nc(i<aH^$Y@R?Zn
z2ri0eA+Dq9b~lSOxRgFsYR}>FEHl2z*WPOZ9HeI@+IP+|II=mV<cO5jL}{mfPpd$3
zm!dGF&Ii(IrmscUl}kEvSUKd686FB5m22O;hG#U?5%F7%=Kq*2*mpe=wGmMDdL*Fn
zQsez5$=`c>0<IJnVjChxF1=dm64l$GJ_O2+cS=4CGWFauDYi+jUKlN76>1#<(7>S{
zyxRz#z1jsAfp8_&UUBM4PC;y+;^~u9N*J}yW_coP-(`=E!yuyPZnqg*R>of~SO1Ku
z_2TdbK~Z*7-AIV-CZxXsZh`M}waB$>47axv3N)y2Z*Jdk&yg@zFnk>#E~EmVJPIS7
zcz~4-AQpR{a&w)0pptbX5D;;#h=K0%?LP#M<Yxsg<#^jSJ_IWSuA7iHP4IzpyYHCg
zGCByv6hf(}&)wzXXXi}{BR2bH5_)9&gB+v8_q)Mg`y~%rhowH$DXJtt?tXZ9I=A3n
zoDf6y=@$(<^$0;0;w+12vd@{RX3@$i37%M0Nvx~MIZ@8p3q^z$pecyxY^OM9Vrcz3
zM+oZi!lR*Y-Wa>5>g}1^4;CmnL}cX^``^3qmVikYu`?{B^rG#F8m$D~mv)ERc1M7F
zfNc_@zSdTgBTHF7%Mq+tt>^zpdv1hHFfibnS;`^xBW)-b@AJ;%5XD}_BG+y0>Q4uo
z^TwqU2ClPp*|VY!doG8Liw)wTUTbGyU}j<mOFJK<+P&RXVoc>5DIt#o+?HqlHO52n
z4O9&Gi`gpbSHB!?i$zz42P@)v;1dQEo&gKsPAHS;A4oZadag>ZV$7aIcXN4^p^-e_
zBVpvTL-0Xe1TCFF8$#*)P#9=GrQzo8vjut1x-MOsZ8Se&fLP{L+;!acWouy<N`zYm
z*L}+O`}yk2KWYJZ-I|9}IV#s)Y?zCQBB>^d+X&ekuPhat;Lk6mOXr_ysh7)a&VA%F
zW3VrqFQrTO6IO+Y?_hwWln2yxhT5ags1ky}0+*u4)X9^WmJon)kj#?SIpjnuoO``s
zf;8o#P3BdRWy6Kw#aX&X4ign@u05OMLIJkaulhe$=A99?H`-91&D3EH_fs#vYns}g
zLg@E>olMOMLetrM9k!cr3QZ2XvesXZx9F{EC&4?p=*XA7wG_(oqBe1}#1wftv2myz
z9ocdswTy}9h9%N?$8bYpy@C;y8dCek9zJsFV}=Cd!Cr1D8jte6<5e|_y2;a)62&dD
zOJ9>3zoaDk*s7HaPBGhMQDpc0kKpE|7gt3*R=?s*V6ktdA|xZB;AXVBjFF|O_Xa#W
z_{6yr4d=R0(|*1G$2iK1V}qJYXBwAWeWm}f`zFG4FShJj7xx%3GPt`w49GEv@2EEL
zc6Pju>`C=YSC#`y*0`=!oCF>|De~Zi`xK7QUiy~=*xy~xcT}sRm!!h(m<w<)s>X>-
z8G?wRzLj2wyyj%L!?qP;5lc)LIj#5C_*<x%ML4e;2D<GQCMuWhWr{bbAPz<~zZ^~<
z|M0!zt8y>AVweUwQ|+>nR<!=$ehh=fbkaA+f>#QNx^~4m$CD-k@;hvk?))^YKRvnf
zAeWqW^8m>%p8nayGoPn}p^}=s-~o5FSznzAPGP*X5W&7sPlfWuw6ZQP-Ax!fKci~g
zi8zKM9`k3TtP7J|B8AUhv%i!|{;fLMxjJeF^105UDq;;Olz44E|GsB7gAjaM=le1e
z?zVWIM*ZPUpt&PD;H2^k7hF-NZUrioEP-u!5u<+BXFnvHu!ZlNdWY0?d6e)V#cRU=
zwgP>SBD56K*u``}Zv-@eSRbvtlDTZtJh71vNfug@xL=rHIRid@!19_lyF%SAn%tNA
zm9ZCYr{MJCgLfI&9O_`Rg7iJ*-Qf3SHcxdYbZ{D!F<jdH*t!u?8{2);1T#ar@OJUr
z3&DQLgRU3)p><I{{mBwc*sk4Ek=dK&$kj_*^=k{^vhv3VDB~jrlRL%*rJtdX3{RWY
z%C_@BPwQz<i>&k7FSxgyi}l#te+x=1gxq<5nW1l{>(le#U3szo7md+&{qz3v&Y+8|
zPy~?65u~gmNWK}Tf_4;b>3DK=S9LQgzBF`gepuuXHHNV}O};z%s9A`k9TN$lFMNE2
zW4Dt@{_(1QlaXin6dz>lV<^wK;r$I?H_HeYM7fwVvYGk<j<sc!FrT}pYoEr64Ih9?
zts2u;vtVk=ZU$Cr8#>WkE>jqA)d2GYV7$fq>*X`c@QbAY)aFzB{5%eN2<G8TR(~{E
zVVZ>N5=K~U*5Y~j-5YZ{j$d-sGm5?K=s3%+!j!ewVr^Qr@~B;SxsAmVabxYB$V%vW
z$icb?cDe{Hla$wK8e0$UiT*y93RS^l`eR2WL-;Onx`|$mW^dXz(fk^088#q<sxr?s
zIiNiVUb=VY;wGQIAXiFDHK|pccy}iK=V2U=QDVR!!Z9F;782r{I1fja4U=r``rEMo
zCaor)I?=L28?ax}?SUw1n`tnT8-m+{w~AshcV_d7sJ*whnN<hGb6#kSJ~#VZ2ke+~
zQ$90PZ@_}OE%lxi0Q39ukCN_tG{l~Q3;b-=V6&Uaf{QwvAttssI$r42Xj)ICMO&j9
zB5#IN`eq**0~LADTe0*-g<I3P35SIG;A;j6!nT`G>ew_(N%P!$n?@I$Ixau}!d6HF
z569PT{<p;_Xi+lJJBF#w?f#Mm$BWKL_bY?BroteTw;Pi~iBDXo*LNF6N-=>t4`U<1
zhnwC6ktuiPr@uBBU371w)sdj(X;t_IDXz?A7Rwzr_(TAmn~Ysf_C~M2cwBh&VY0#+
zaFMKD_a){^&~j~7^4za~pS;r#aD?jvYz4IR2{*M~b)4BGM$w7c*sSLL^7Jg$4$5;;
z`-q{QA_lXEBh?T$NFV>3fx|n^e(J%@5s%u<s8X+o3_Glhe+xoHv~JcL1U+m{h(p$&
zcDH|rM9;TgumCWV&(Ww69CN&fq35xyr|Tw5UA{KO@(d((WiT_KdYMjleK(j@F}L|$
zaXTq`Px#hhU%BDU7Vpzd_n)RZMe*BDRbXG=8)%n*$LaL@uPU{FF0uCKW7@YTgxpnj
z|7*WL|4UH(D9)AHO>nx(tc}t@=5s061<p}~bX`i7uj6Gdu{byVc1XJ6uEpTF;q%va
z?}q%kgX1}umFZ@$;{lK&(~}iCJ!`E%!@+OTmRPZrV=mbJOAMP_sAE)vU#L$Q3nVE{
z#3xH4dR)5=1nz}BDn9yj_78ExKd1pxSEwFSy?A%`5AOktQ;nPA7KLVz*T!_E`NqAE
zQBtW5=Ynqu{W#oA+|w|ub7z+J&G>eOg^HdWNC(lz@n@^Xt021`T=9s7ZJ+eVTc+UO
zW?=Bi6321Bf&~CTZT+V8q+oANY?zw<@!*M)UH)}B;NjHlm;Z>3{+p%lAH<8luRGNK
zWB|wUZ^!(e+<%POFo^>&#D~$xFPqupNH{3zjS$$t{vy+)=_BKsS7pvpTgH^iEL%Je
zi+Vktczya~^5CDa?4Lh+n4FxNe0BDIc+2r^$G!2VzY?&Y*$<YBr9ZdJf4Jl;wQ&2p
z#mrsEM$1GN4DmYmjLksW$MC1Vz&bqbmMqLrSwKxC>a_bw6mp<Bt9u0mv?ob?F3>{$
z7ask4F>0)(idSYNZEIQm<BS@D3P=V2n0CbnC}YvRSji9C=iKKqSrW<_Visu>$^OmS
z{U2`{64zLL!IID}29xwS!x0k4(0}@mBa*VeWHnKu#d!yAP^q|4I^=Tp`(3Fak1=tM
zzXbvU>J(hs2zw!WBXhRUdgR`wVB_90a?E9QxVOv-IcQkzIbm4k*vBYd)?T1r+gO0A
z8a8b3st%8sE&lWQ{>Q8RLs<W5WR>5O`I9LxNMNJ>CILS?&LxUM2J1?XmSj(&#F>8|
zn*8Z~eiH=T{mDrEn}7c|e-6|B5)X_~xcZ;Z^<TL!7sWQsUm5bB-)r?V85hOy(9~V{
zpa15+pZ1@N=U$!txd<XB`@f7vO5$?krPO5P4eO8p{C@xQQTef{l1clrk<O9*C*t|P
z7!@!v{$%@m6)(8{H!|{%VGDQwhEV{gN=EjNBmaw`+*VTsOm9whrHuaXapwQYE2ef{
zwer~6#j(+nlPSNK%D-VB-}Zj@?|ShEz4_;GQ%|3r_LyQtH?>YC1$pg^w0kQ6jkNN}
z_3x4Y$x`w0vX!2$<1^{MGPVxY+1==F^zM=(j`9k{pWN`$gRfH9cSW-l|2Ji!%98~I
zBkvog?Vm6ASBChniwUqKHvzJ)Cc<C%`xAe(g#VQkYlcX5=gq`1{OdGvPykr!E6;=V
zEmDIsu4JMbs<Fx__CFo3As}>B0^`4RHKn4@io1|3l}SF$gxal{${E7!XIQSfLKXM_
zOuW_BsN%;wDdbsxdl|i$AK*1*1(OvTR=-I;UV;f9$f0rnz1jG!)cIZcwM?AbuDbSH
zDUiQZg_mHFm%%o5gM<KZQHf}A=C|kn`<Z#+FV!6bSDF&q=xJ5F*#iKtJtO%#k)Ny1
z7XzR1)bjMda3NwEeSMmhSimx5ouNhyy?Nyq);TKv`-l8i6r?Uw=~p_~0x_HQ@gdWj
z<3l<d&x2)fq4gB9<5FW+bbf5_L}_+!u10%rVSR%44AaV1;uG)b)440${$zqg&limU
zIki%z>_3aP)F9hGnIX6?b1YEJZepAz7L!l@H#uQbt>cZ3SOWM`{FbVjKBbg@T?ALd
zrAjS&duIL8dlz?vzYefw$7^#NV7!9Sz4~7dHlE;M^%8Q)Lu{zk093tOkY3rIVCmb1
zHxS(JQlgV4_MSi4NJf8s{<BxZpExXrKgple-+buP$|zD*o3@hELIhX~FVmaWfil5p
zIIdr759d<qj3W8dxg~7Qc;fr_r@=mEh3<io(NPL@%?gsVhn&e$<%rgKjlSqh4-(1D
zO~fsj#9VkQdwfz@+>v5D@vL%(n0mF1%f#!PONHPI%CvLc(yt=Mc$owoGgxqm)d)Uz
z6=n{ctlRYQcRGHXJeK}Ae)e9mAY)EZmAg6i6!w#brkiyemqFoEZg!8k#(Ii2sGzyF
z3g(6|u=!V8_TB?jCj(f*Rwem~Hg+q3>e*j04LO1o%>gO`Th%zqEXzZm`|NNS>NQe<
zqPd4Dn?>kCOoI(lk5FQH$uW1)Ju(z9J{g~{nDkz~#cTJDPS~?1r4K$esy%%v^~xa&
z2>pbF%NW<9k@j^)!MZ-^Wtp}Yp71vu?Jiswrpjp%dw7pk5R7b6O7beD6L|GuWeEBO
z9QSsvNfff&AqkKlv`c%iyU@MyAJ5Y6*(p(soZK*FE0sT`VSG!>GoI8F2Ewu2*E4;)
z{BuHSN8EyT9n@rSBQM2z=$IZ%m!n}p`e9@-mfUNxGbr5iF$j}Djne1B+gv9Q55>_i
zew{)?-lDn_vjQ_o$F1z1?QaXpYuffbhdzY+B!(c!>*}>B5$l}n$A`!r-k}X6>82c)
z6fw6+6Qn)RGamhOuKwlIJZHOt?C&7=pH?I!P@aZs;!<kln12b7$lkL=9OaG0)Tl>W
zE@VZs{%kYY{CVI9@N3m>0<K$buow`h(k*zTSt0AH!=Fy5`kb&t<3*~j{->J!xt;ZU
z!u~TIY62OvXAzP<6QWFzpRC-nb4Vb5i4$;$@tBKdiL)0QWA_PDzuR&t^_r*Q1we&T
zyQrR&ZJ9~#d;{?%J#oE|@!Z%1f5@~-QciHr$F&wA%z>-{-Pz`_b*c>aQ6R_$0Yxpr
zUp2B-&1ie#;_u!zxADeb;hu7t!0QCRz>&fOB*FR>R@bZQ04k>iK*u>j?b(9)LGA>T
z9w30Fc)hw2P<M%zg%7EEfVR)?-IOp`-MDPSR<AxfTFL4GoeM%2Wa}oY4qpyWtBj5t
zn=w!J*ql0GpQ1V!%<KWTo~cppyA?p2^va>O^Q&Sk&v9TCz-sHKYhYGI0zSS*r*YNd
z$hbdyZqT@&)MqLSBUqRTf-|KTiuriO)Rr+ezu_xlTUgdkGYkOUx&Tt=Hz#pM)xQ*L
zqy|&@Q!|=M9yOqN?WfARJ!2u5{;$o+?<;_PAPEcXVP6;8Y4M@AGUW!VHQa_WHE4&b
zODi{~n_bohx%iSdld+v)pj|nO)>V(>r;TB~fQe>p);hlJPZrJANBp&d+<TsC8=H*Q
zU?IVj@?+o{ym?Ikhy0867TsBw?S}*Lg0^Vr4Pql@3cwfHTd3JSiTC`<x!LpefEh(u
z7je7Qikdv{h%e94mczVTx;8prrzn2NQU&-}p?I1G+sTSURcri2dxKR2u^IMQE_Ac<
z$C`tf&Cxx`%<vS^rP6AELfSVC^@<<cI1`4`5q?nFaEpsATDTAhZwI()6B6=uc7AR;
z=k7HG`<hv?gK<-D3-b3iy5EAznfz(!FzvA2#g{-1ygzEg_&K$o9hF1fi7_H1@A$g3
zuRvyX^2?Usm93qSd(2gsNOU*qD9vrx<_Q_}uPr&3Za=o3ra?E<GVi<GGoT8cVgZmI
zK1H2AUVzmk6w6~$5&&_4x@=iysaCftF^UaAL?(n-*E4oXgPRC@H%)e2x<V}zi}rwE
zgi|>Y|0}kB@u_j0VN;QgJP`yN6+an{?LDCs(<oMy#}$Y9{3zA6)#aW&UU7SM_Dfpx
zMXHjkRm2$D3>9V|SR*WUk{$z1bL5%UrYyhXmYZSAT&sY|ng&c(qz7(4CA+V5NZ_1O
zvg7-Kz{?TJ2|8_>i(m`cu*555Y^K4*>4p1ZxBadXUPLt_yq7Kj4ky-6M9g*F#_W?*
z_xd4jKR<Yd`4__&(SVbIpnE!{#yyF5Sbc$N8Am8gWWUc0lsYPSZQm$jvrSIw^s9u5
z0zT8a5k<|E9Amu(8{-A2TJoQx8^19jQWR7UHFG`?EDfz$%RN<Mw@$tJ4W1NJpdDDG
zlO&4V2;0O3;w|d)=u)~RJY?v$v5_TLDe2dJyifN=lDI<}6W`g3?e&wcrNnR&(>*f5
z9e)#KsoUo$dV4zNu4-KNUckd{KBoBj`Pb%+Ey6O3`s*6kjc7i`7ffb=dvo^E@<cjN
zAfqr6rWA-k;RZ;5`*A(KBEbZ4)C^=1{8e833arm5-E#9@ox8~cWi3y!wQTvmlk2R9
zoPa9<c524l;3)-ro!j@8H7cKlT9|2}p|x)K(>5}Gq!DlWJ9&;N_@2EFQ4D5&G6j|8
z_6Pt1lX96xIB424vqD|o<}Z0~nqg8{G<PrMp%>@i+1a1r-soD;$r<c?e%MWOs#(cs
zMx{r3C;qrmT2kMyos$wvTW+i4y<UWH5Z^D-uZT`3Wp7)sM{3rL6tk$hk>Y2C2I|dI
zf8C4uH-qeu^Sw^KdwE{`uPhIL`lM9<vw(Lf&GY`>Y;pKE5B;tG_ZvwfquK=`+S@F5
z`u^3+|7+U)pWd;}Cm<FT+~a$3{{Qq+w^;y1|9?~S?`Hr1P0gRG!vC9^|KCiFRU8i)
z=ARIe)F9RI;g*Fz?bd=E6y4)dYBhk)06+Emck=&VM>~G9ia_upi?{K3{C5aO%Kpmo
zNPa1uu)`}(r`~u$0OtK4#Gd~&pi({*z1TB%sQziyfM9*BaHDszQ##^vu<k#9_b(>(
zzdWiO^$YIZYsHTL{Vn|zt}c)7(DU0*ZY!W-{^sHQsjdF^H>PI-j3)gIm-41xyfD~e
zvdlV8xT(V4AOT1i+#rml$?QuaYzwWE4y(_qJ@K>XjgJFPMl-*Rexr75P}!GqCNHW^
z7GmJd`X(eQR;nDE-ZisU$Pn&1mLRmjy+x_Rai9&?&q^*<khj{aw6{tb2G6Lg@;q=b
z_^zEIZ{KTEA#5A1IJlB#lq4{)e6%V7k_Bm5%jH587j9x~R;NXxBF;%O_b<L+?l+6r
zyS(c@_`I}zti=4nP@Y!MI=Kyj8dpr<`9#q5X*;+$Tpjb=Q;}J<^uZXjN1dS=|3YS8
zuUS+0ZSq~yFLI)=ml%t|Uq}9VBe|r6BpOTlvtL-a4)3dBEK0Kec=jFDPe+<vt3iaO
zqsta@U~hG#b8mT|bGdRcT1WdUmrkLDIluMb?V)N2z5r92q+9$ZVFE#NuNX2HMdoUV
z@w=|7fp_7VKrfI8z3;EmMWF}J^fs@v5B_)$jW0A3TcoZ5qh6MRQN@X`6(mHx+*w#v
zXCi=2MG5v(7q4B<ycSaX)*cKXX6r;(K5bsR&IoSw_FSaL!tg#H=S%%Z#&vdmNwu$3
zlAc%=8uy+Mmx46g9&SvQ@6%k_W114-F=>d{QYX=|sWQL01{C)xMYnwBKY=hli6ZIk
z%BqkR1zT@&_=oMGs*$~2(Nn#Cl+oN*r^ixv!LyCbo8N-Hy~CEYUlm0Ya-K-Z((@fe
zJPqzrSb7h%*|K!(bdwr0fe|~Ro^7Ig@jZn`ay_3edt;6C-7x!!ocI<+^R}G@%N}IC
z9Pvr^CUe&5tKzSu-1se&V5sqDb~hhQFOOUvQC$9Tj<UYwp&LZs+`lW-xhsl8x^9_)
zI`8eq6T6E{PhJjh1lnJ?;aYm$P{2kLln$1)my9+!wm8@VX&)TE^pnf~Y%r`}8&A-^
znj-V#v(;E($ja~vJ>sE`7;$d}Vr;+)6EhM{>*K!V_VlJ2Ms^`D`iahlZTZlMu?}K&
zI2VgVO(dEM52!{-<`Ht<+9e3VudIaG-fhf!xuVHJYWZA>Cg6fr642wUVHn@Y#$5fb
zg=2JEDASk2+!!8|{%8dZe_-F+5nd7IIZ|MP$X@1^_Quj1YykFSWfcA%1$)UP3`QQ;
z_3MR_y{%LBP(OXHE5NcpS=h3#h2iRbP|N~6W1%3EkfS+JsDemvUgrSW)J=|t(+{aJ
z`Jj7n@47`=Giz#J6AGhI7u85QF#6a){u8+6y|CB?<!s<eah0S5A08T9)*VvLOnjf%
z&HA@%nJ$fY52A#pD!~iH^8MX?Etq(qkmKds-H!6yOL7v-t`2m@&JVgW@YR9I#RZoZ
z>5t`^`@QJOhx<o#wK07gUQ8Jf%%kHCRMoyIIx^blgOKA2HKbL_Cpb%k%d~qSm+QnT
zf@qj<zLjH!x2@!1_~c|nJ3mT}d!#xpH-Gc;>U7smKfGGA+9hg3g}yPo>FfUKydV97
zwr{VyfH*Ge^&j1QWO%^#?(Iz%Z}^!T>EEQGP+0xl`dj($1hWYGZxz~?2Y`ZW>(Aok
zi*4IOr9F6tTGE2a?ycHUGmK6Fo$UFyT$j$@ZZ#z?T~Y3dp1LH}#=`VO;1-3;`gp|y
zX<te28cz?nNnjCPsW$;*O#B8TZ6XiHh7zi*7L3tbich@`H=7%FT@5pD8|8e~R-RRm
z=T^vYY<MkQCvOzZVpLOhNIFfky5gp!by48$d*3_Ko*uGv_UYS8;#r4fZ|zT<wRiG&
z9u=Fr3eu1Zi11Lx7!DR1t(7oPX!3(r#kQs@^H+wlgFu(Awm$PG<Ag-R<{t<v@>;hA
zhv$|&#d&nc5OYy44|9fjN5J%UJlfju$rV-fbEBfqy2Sm>nbsVpV$=4gr0Ptv5nUO|
zS%5SDXm#i9mgJjIM$u@je)QGCcVA9Zw^mNOniW0=E*RlKIDecdUsEfni{J|N!kGD5
zE;W4&I>kT{mCl_*$P}vTBKsUgF9b${BjbuksO<E2I2T+BDCxzKRlJb$%jGz`1Vwug
zok9+^nD?<)f%_V-nueWDBnv-6Gn&TxIHNm2#2g+X;~`_8{>E%=lv1=?qFh*0GKXpW
z=NL6|Y4&OP(Bbit?6%S#&+4?*qlwTq+{GM7=>UJjK&^y9=M$Z+=L)Sh`T6}<qTQk%
zWv<NrxN7WO#Zy5M8T?I<`CjYy?^e{xvi^LFA?Zpv2d_{KMg$kx{jKYWsBgnzYKaQA
zl6S%|tk=X%!aNMya&X7<G^%>Y9r+Mq&B~XjZr}Q(qrzmvHZg}9@4#8Fr&+xU6765j
zC@$!+%I@t1n?j!-7?^#?_B6nWhkjvMP*VuVZ71Xm4*?1%U8|!|tM6nbndY|Dmt}$|
z6lLPHW|qP^;SZ$s+7qIRMwr#SoF7NQl~eIubN!=mylL3$$aWd-hGA1?aF=T#vVeL|
zASUM+*+(Z=?-cTSW7^}vXkt3Fe)ngU6D6^l<FM*Lu-|oWnWNNZ<RWVMwwEL!fpCj0
z0`De)mXo;b>VSrFm-m(PvQ6}BB?g=8m9&E6K!FxIo49nFJ;)5Z7K;br$j^s4Fb}$<
zro15Cx@wqXpDtNs<fjT5w;j8Y)h&~>)=*5q4_D*pmd?La#8zjHR?8nij4Xo9s|5n5
zvim~Nqq=L;&V87gd$|xJ`klk>B$j3l>pg$6-JHQnaAl(z0MO;Xq?0o<Vk_Fv7El}d
znjse!YBAsPL+`p|kjH2hGOa(E#?#MsrY3r;y!<Ov;RjdfoyMi^r>B%WQl2ZYruGdC
z=QexMo}GA8<9vTIKbzj^DjW6gnOCJoTp!QSj9dA>-I?zdjSjS9Oqbo?-?it#^E>B1
zHK93rWYRFBA^GXxS<#P)2QQy`Z<IIJl_d&x$JleZzY*c=(-&tmzodo!7<f%={uafD
z>+%A(Qakh2wS6B5z(csbig7O$WFpyU`b5d!=&dAtdA30#9DJbT)RFlCP5@;2EWr61
zQ^ZxMnTkVE&UWS)HrA{+GX2gt=kJLf+Q`mNFU%*hl<|Rl6`VpL(RC_ZP1m|LkgtKg
z;5l|bQ^Y#qKuuU--A+u=7&JPa`@xO8pe35dz-#o*bQD&NIpbUHNNMDhp|r0Z?xlJ1
z$=(KFo6_%XbsiwgD>99YY{B=8JtMlpIN38l<aoA614=~0vvjxIBk1xH+^+4NjS1S|
z@(aqJUFlppo7*}&9WnlP9*Iwc8H)WEoEj)sr>CidBn<4BW4~o43Rl^u+F7gNc%-2r
z?|V}alGy_Z!TVWCbn%erXZsU^Y-~#>GC@L?A*$Zhbo{bM%<(0ez06|}tLsuT2C_{P
z$7dFI=8riRo$#4jJ_$vk7Y>=Co1Dx1HX^$(jO?v6i_1NTla&+-ZmT!9gY#CJcUM>l
z9^C;&uxtox@Jzi~o8HFWA1F)~vUkr=cRVsa=4P!4XT{@OaReO0U2I0%Q$zN1FL%aG
z)%AyORiKrfMJw-yMYjL_;#EV51Z`L->*|GWYdwU|3_+{4wD)SYQ!Y!MkGs%-NOjw=
zWiR~(+%fO1>)z_OMY&zm3UH2g*qC|}mn<O4+*mL3&?ep(b8B-HA1o?KnLDNPkSMng
z*}&!?hsMKJ8}04}gxVB2pnQJ1A)~krhn+&Wl@o*>&bq6Z#sk~1b0E2p^oD$WNo_?}
zhe4uYcT({~#k4YRR|jiCo~vuIt3x#!Vgz`Qk3yOberZRpHHAN!j(4jx2T?y<r=<!|
zm4bN%Q+1)Cdtui=&3C~!cRlZ?pYiYx<?k?G_;Oe+jMO!SjZSMLT^2do1M7^nG%^Zq
z9QbDUeW{Zhd*7kBygwG!rN&%gOu0|fiB*d_W5;o=Cs~5c^qD$SStNTuE_vBV<_sOw
z&~4@{cGSR@b)mFQQ&g6Y{Dr8Rol)!C)}p1#8xO~qVQWGcYoiBu*NTdE;lt%kzSlUT
z9JuslUZZ<nqLbW&+75JWip*`rGs9TPWxh*5Lp4XvN-fnM;><st-kt&TvPy+8KDZCE
zac(A7Y_N8UrN)@s0py&m>mof*{mt@J`xC2Q@yOd}n!z^8rM>U7Flma=^$EO<69(6t
z_~aH2%ocTB<eFy>!>C7f36k43m(pBOJBhLs&mYe_euL?APv&~hd;icDw`<QKeUriV
zaFb>Wc~ZD!FFN_o)0l(7ilS`y%EOkiBGdv@eSH*OAA3{m*!b#<fc5^>Xjsq<`#{a_
zj?E=0@~NYfBa7|+ZW$v%8Pl(H@LgVz5wSFvYNB((6}mBnl}`JhoIXtx*SV%3A6S#W
zYvr$RXLgtiiCoGZSIC8kxjCc^u)Gw@`3CptH2J}|?rq|YS{VvR5QU6BKX8i5vXdp-
z^?k&%<S=Ct*s>Z1)MI>90(#VMtN!3((D9spv0T2A&E581%=vuDgJM(5;Ny3%?}P<>
zzIRwVx?9zDXRKgiC1fI_-C(Z_=m)pG7O<FH=f!KC$uOnrwB@|mArG5YmF=GhUYy=;
z-8eJV7$|-EG+&=nd!x&A4AUH+G*NqGNHNCl<#*~kAdB1b>r!yQF}t;~>OYpCS*uT6
z_}&p7u_`CZ9ib8S{YU6=?m`>QHjQcXm@HA-D-R)fBl}n+@$d}I>RkW6nZf61ab_98
zIMec&_FTyOEiFijjRqGj$ClN_uIn6P9k*|%46)Lc1cZ=X%WmtLs<5Z)SjbBUSG|rB
z?l12{R6;=;ku1&6Bk)GHxR<K3NmJWCk$I5o27rs#+O8Y(U^w7Qdn8OXa}Tm~kF(2N
z%YO6*cl@bU*-S%~2S5a}Sfm@fB|nVTA{n^4a6C&gIA1?K7Qq6+a-i)vOuILU5qXgA
zfqwIc-QF7I^{ULOC&Vaq3|mUPOYm^D^^N_Kn~Wnlv6?r(_Icw&PhY#JDeo};U0D0!
z>;8<1(~71t+R}by)Eh@T?<qJUb`NS?YgyS}QId1*Nq1%I`|yV*N_tDGJpTV^`p$SZ
z|1azo)qzf0Th*raCPvMo_6QZLsJ+D=RW)kGruN=qkBHGyd(R-TM+jo?(I>zE^E@xS
zA)oK(EB6`Kxz2T;vvhpj>b>JPN~Luaqh%aTrYRGomIc^hYs)72ThxE%!$Yt&TT>}q
zD#G3s;d_0C-`=}a-E{t2)<<gn@l@ve*tc@PeOp(ZR|)Yruy?6kclT^xO7)BNgP=l{
zrg_<*O2V&Qv<m0@Qk%ZZGjE&Z1}3!BJXj<e^8Vl)QEdSct)oE9H#3$E@P0<O*t;J!
z&!e0G$nQ8F3FTA6%)@m(;WpZ>uKY{zCUyG4SX{8!<LG9k>$5IM%R7-v5>0zQNdV$h
zDZLz*OlOu_Ptv|*wtvK2NJH|M^;vVCALT~3wzqCX(@Ryq3jG?127&yTIZMihD#8Ns
z@jUmfG-Z`8f9~#<$^pU<$V&?TZFO42)Qc=0Gt-=*abcz`Ef1TacjnbyVd_0Tf15eD
zN;C5sQ;!PTCs}3d^o2jM#?HSqi$nWT1WmOhmUEUk8NOnieopc(Onxs?!uP~;s;al}
z6TP~C-n#1H)sCW%LQr~{7IxM>(HBWNKdmYuHPH8|=j+jp#?!bzp46KBlI+~dyq$u0
z8onk2q}S(k>KkpW+?uvc<!v7`)6*rvj*gPklIc2`<$fh+g;zypAz#?Ac6d|6Rv4#p
z)t7=Xg&u7?j31)bOQd_|)4X)ALEf%M>-A_M)t+?>#Bih~8)M|3vLe(Lbs+G1!zXw$
z;-O~fy$Fa07=OAat5=r=H^n8AnWfwuM5(5PUBY$fP9zB7xl=6q4YpSDJ)(J-g`ck;
zJ|GR!h2R7o3!cgO{u>`oRW`g)5l5|wY<WHMq@g#n(q%PhMG2-o%u#)L!<We9T!e^H
za2%*hxbPn?w4f{J0jxY81>S5FO?It($~XbzUIWon-_x6#sK(kTUmdG*h^hPtz}O#b
zxqi{q8QV+sQSb~`s@eH%_)ddut3r=c1Up@j{aO}@=J5xBtYO2nQ6fliC9bp?Yi}U*
zocXATAf}j@%!V`^HX9z9Pxe84lrboa9Tcu;!{It6?W61HwvoznfU&X^@VHIO+FgD`
zR5#nUT_NwT{e&OnPqOV*0@9I4RTY3Tu89MC84YJeaM6K^HI8o0k8_$R;qR;~Y!ec{
zi{?w#ZFh<S7)v%P{RJs!Qi1<zq1_xZ{-aZBk*@2C!Xc`i&zHw?b6%za#QP?dr{sPT
zDJn;3J*~|vr0l|%Jp)NNG+1cNK9YXYd~`($3~G8g%F(^&>b09PE)D7mQU+K_Eat0H
zdA}y2y#LWaI_q?e9QcvK<W-EGz=x|d<gY;*CnRo$De!3CNgkiuwnRCX^F1X1EWaoZ
zgrZ)gE|0;pr2_L|mzyqZPCqEWO=IXT^=>roW~<F0OPWa&IW*1F1Z8>(UdO|N(RoqM
z6!ZS7FB2K0zG}BOom-}7OP5}1dd8;6uoc<~rrJk%T-`O<&+Q{#L2Kf74i{A`?LHQ_
z^7)?WpSzoyD9bmY_$0xf${$)6Mk_}$2PO6<kWN<}9pKmplhN2bAUo#n7JjL$r`2p*
zk=MWHnn=Y*K1rtq2y$(FAozQS^6al_A+wH&kBv8KIY2~pY|(2ibxKeXvMIzm`L=Ez
zt`*^qd`+UF`t*GMA(fVkU?a`^bi=hmLLcPz3VeL!iO)}~wd9u=hK>5>{j`Mc{WGQR
zi1`7>t0}0C-;4&Lr`*RJi)si+|KsxxNR<by;xZP$Eg?w;t7N9%*m_RE45XT7S>pTF
zKHs<LjR{_~uy(c|RQ*BvWJ6Uep#=ITeIA2z7QRieyh?TXKL^~>?7Q37+>5(a1f~$-
zlU_rg+ru2KydDHd7LQ7@RX5wvoDidKs42=M+v&Haxqf(ZU9+pa5Z|l9WbLO&TNY-d
zNyiFh2*Ke<OY-$(d}ZX(h9SOX_|+}4k>&(==S*X3oiuD8dJoGVPuCB@o@;PiD^0;R
ztbtCb=3ct4M^uL})OwWcnki<<HfktB?}3=tLG$glQ=xS(SzumIkArm5K4mdNKf?i7
zuDX~ji>w$JI{WO<zqamj?pu=NAFY_8g~o`kGrmWla;{1u-#GEseT{x9La5c2HvC*#
z%`~y2!rETce!UC;vmXB%2)3c(0s)b0E1Z{cH{^HBwkw{M|ErcL2HF3m^xSA(QoQjE
z)7k-55||=$l!M&`JI&#gR1+5mL%;HG$QT_y3qo3Oh1@lNgRY<OqKKHONKOK!mEJ$S
zHRZx5U@ov@>5_&hv}#&Rcsqd0++gFvXTn7bU1TsdZ(Is?yzo}e9M$!kf|-@|-*Ev0
z>Pz3Z$y=D0tyD6<veaC`{r`O|W=_z{#2?4qKqB<COOh}-u)w*rf59&SiWS@ycEG~{
z0b*jufx&EMj#cve;Th#}6-$FDPNP@1Hnp-3aygDVU%mz(p!_P;vJ-Eo?h{8&P&Ix}
zC=PGVyKlxu)Z(q+tzsPd;*n0;e{QioZBYQ=`O1&yoUOz`*c?B+^Zh7nb@1%XNV;RQ
zt*^IdHg~Cir5xh}4xj)}rIJ1YUJ|3mNMjB&Z&yO?hF@bf@YjK<Yol+uLyi61%x{}Y
zcGBtgM+B=630^YC>IAq)BOG29`c*rxe7&wKL*hK=A@Prb_tZjo)sGYT+`LZP{{&AG
z{uKg2aY&p?ETfz;sNkp>QwdVQ8B9Msjl=c(i`Ntnn-zSuY$w)L6XiCh@8k0w7tG)B
zF~$ae^ULEcaTY<CyR`50uU$TJY1bl{N+E(U*(43&Mo4rQ@taWT8{Zmfrqw3Vo2f?*
zL~0Jg;fJv6b;T6I>uJVVolL_Rj|RQteoF#Vn9ci7<(9B_mf_VUBg42~bd?)%hS5Q-
zH-cn-0E{1Tb|xoCYvFFma4$U|+Q81z8tA%_iCqwH{@~A|6@<Tkr;%>>w5Eb|;%-`S
zT~Q^*q2ckAZDzW=R7y>SZJ-UR<1>MBrP~Jagi)oI813Aqg8=t?hWo&Ee-Y)<r8@jR
z9y|>yUn~l294PFz;V3*JgTt~!ObQpSFG{AxfTRESAXk6+zlMYV9W;1qkMpB<hQGYh
zf6#x^2u-?}4j*D!;lbtGK~JUOY&y|er{CpK%;1fmG9(TJcrK6nFgnKfDy>a*6z*N>
z%~r28>`k#rY~$Wdn`<qdwObECB?aN*X2uqHZGBD|+)<uY$&HpRf6=TmyxlxeV7av#
zkp=9z2j#1a3S0GY{pm~B`Qh!GAjTte=tcfW$V1ak1;H~)PT{)&4vyNpw!<Duswoqt
zE)ougtR7ZP+T3~pal9bqm#jcT4P*F1;n;K|F~=p-Wrmi9>ker8+DyI(bT007@I$z-
zRpNQU>@+c6+yOq`gXgS@0aJe?S}|eKqfb8St$u*JD>dDcc{e-Jwwukqs+r%`92i>J
zK`r6nKgn6Sd=9lYV5#m0664ViK5waBt-V6NI6J;$GE;mhMm|mFxyJofDn=%sirX7i
z_$Q#@(Wf-h-NF85<0tqViGB{I(UBo6>UEV9MMqyce+-d@bXv-_qv@qK8U9`><F1lv
z80`TbO#ZVi#&(?YZbg)iEuNHp{ZQuTi*{-Pb|Z8svS>xf<A7of&4I{OyP*9ek{=jH
zmk)EUuO+Z;7$IpgQ`!43-OlYtz^9)EY3-n@4?*oNrrY6tW<SVIZMwuhpJgoAR@e=v
z8D(YlTzx;$-aU0`oPxQqz9>TdcLe7N?D*6T7pxLlSEz{oJ3-kwXQYx~!(u<q*h*l|
z%Z^KkGX!c`Qqi|loNO>$lvD6Q(*R-^muF7x^rAK@F3Ao7rMa=JShw7pDy>^|Ewj4O
zeZ1-wSaa^)RQb7q$5uq;u}p&G(QEn#wuLHB`oo@O^YucqM@q-I?eabZe>WZlR?NOW
zu*ELcEuI%nRWfbX{bX+G;*hr>O5bS)9DjUl<cDmqGhcTw9=yb4(uum(e!Z}*)>>+t
zU=<op7d~(QM>u-1H{X5yk;W2S7Ne1v^4orhG;GITW644CF`8<_XhWT|)Rt+NO~9~M
z%bTV3T~M@a7Rf2VMSiqWX>mONx{&Lah)Zk-z|AX<i7e+Qb}JLSn|dv-t@v-Ekb~*P
zgeUZd^_lUJSWZmvs&1B!sKL-ZU!}(bt}d19z3=-6y=Mgpw4^zeV*avJJ1#hOWWFu5
z`H6YzP5;c-DVolFjigja-OKs6|L1A5OX7ai!Q9z&`$PmEJO7lUMwo)ixA{iH#vOKl
z5V*Lqw+dF2R8`GF7?NnWVNZlZfjrBlmZun+uNMcB_wlC+QcH<50iu;&g=eitdbxRx
z-!a5?8aZOJw;>yYO=Oh1`OnnhViys1oKo{bF_@Q0L=DXB@QS~OrtGqYN!^YnY7xC5
z>_9E_XUrw8!2O_rEAWC#2XD)*M(fAhWkQh{O2a2j=sIt;!LM7;_Dsyk!GJ$ZJ6W=v
zm$chV{<L`@R3-#Kn@#Qw=u_THJKGbKoSCOHX>;9(km@OGbOpuL`d^=IA5ap3njC?s
z!N@0Xib*PNDxLMFOa^9z9;ve;?F68ecV$^@P#kd@Z|f{4BPBdsK7&Ew;Jm}q)Jt~o
z5QF_E!#?tM)!@c;mlOr8KL+(S+o#g)l-5Yp|0?5}zdCU9(*Y`$USfE2_(QK=i}W6G
zQ;bIvE&hwm%MSrV_<f?P0q&+=@Mzcwr{aIna`{|4vZHV9Pm>l07@F>x*lFH7(L())
zv^cPIcxR@~b&FNj7bsv{LAKMdIz66$306VbMK0iIPW6}@a*OHI9n^9{&vjB&_MpBV
zAZD6ap7z;9Rg#!+YT0^#CYrgomXf#7YO&1a{K=xW^05}P2MgHe6q7g}UazEO$!PhO
zW5v>7&&3mo8z+S8R(1UTQ8coXCB`!DIz%Om9mY5eKO?<T*V~;VO>r2*buO;q;vUoj
zI|xM%zGpP^gM{Zzw(sApiV8Zr(A>n1%gz$%iOdnbaXd=8?d)B<nfZH)<Aw1C)8}?9
z9=(gp?OE+M{KEOqu1eLXykFd3RyOqHDDmIqk~{Bt+=E7OGj4{&>fRB*!xnE1vo-e_
zE|ZZAzr+twc8`{QE>d2$CyM0D(UL5*?u9<~^>QAyL@vRObF57B$p|T<)czLZ@S#Bp
zZ1A<ZxfEBUb`kOLW$MvbjrVbThFNXqlsFA<9^_wT*isc`5k5eiM^L~1uc;u=v$WwR
zHQK6ija^nDYKuywvT%u=o)SPQRMBM6V5|5iLZ(bs5EefyUGj3f={z<*0ifIbx*gY~
z=z0Dd&$W@SBL46*m-lwz222eNU<syYtMc56)zg@MP*z;=J%gCAkTgrxn;A{=Qmk~O
zfE43kSes})IQ=@2J_L>`Cw-E%l!$c=KZ5MYJIvLtk{IHc78}PF8xZ?1pQjWgufLea
zwKTujAA>r2!5Y%&p3wpvpVC$=JR9R2TqD1~qojjvRNVpkC>-t)1xRC17kwpeRQl7l
zw2*7&!o&)(xri&Nl{2U2g?veH;tP0UVjds_*=+gIpo0E4uIc0;aOZ&@=?YqM35@Ms
zi{}dkEdEwD2Qw(1v6ZPkp43~KB5PpFKZ>U+nz|KnSRTm?_D^@FFrCbCi3gb%VP08M
z0qb0F1zWxf!@1;TO^`YcT~6Br2bF$^W4Vf%`C>Trbb#<DZ*1TEr3izx(0KzQluvk%
zyzo<epl*TzRW+Z1wbR8<+}1xj)7s8fOSbbu_44ZTE^F0~v;O}qfQSQS!|s^U1Uk;?
z8(e9KpI@YbPR{?&+V22*d(YPoLxnZ$z)-tKIcMl!{FlhOmCGjQteFHK%}clPq#JCB
z+u9_vlu)(p6EJQtb{@S&#(zjPM61%z3wM#@&*eC9foq2+N7`Gis=^<Y4c(Ucq#T&4
za)p!~#A~nEbv=8>t;~Ld`ZMoLeoG5zPWi=auJb;`o{fGum6xyT#W&yVlF*tF6>ok3
zJ*Y%c{#-KJQmTT7`Wz;3&v`96A79x?6QQiM7fN*$7TF^7)7;j6Buk<Pn8k^sDz~?n
zI(*+6q;2UiX@pxd;Q^-}53xYwJ4iUVzw6D{Kb{xpZvn6yZ`}7Rd}a_0&jSEU1a!WO
z<EN02k8vKP(;Yq%X#^f}c?l;b>J+KdVX5Hj1CwIKKac%FbssFWe*4{!N=NjuozDH{
z;zJObL;=Vo+*SJQdV}ks#f97LDZ?$_dCQIhK`V<Tq;4gOxY2@G&}G$h={Nv-z>eG?
zGp4l|VB=F5xBY;7jvrs(mr~#NZq}vZFogFP$<egT)%9))eym<eSR5$dj~0$m{re~f
z<nY0}(V2x`P=q}=)AeW6enoC5w#NVZPy9gce_htl7Du1!Q#+nzFr+3sTN)}Rf|x#?
zfI`D=QX}2i&{Mrh-(7eeEEf>BLaXdbEw7*vT@Kefo}k>3Xq7U*6`Xk!#}7)}<w@dN
zFdw>haJm5t^0Clkt;XqlJvjBPFF}(@PrLu0_B!~NFp^hR<w;(kwGT;;U9B}MVtXT*
zQc&R2_+CNBa+lyQ#Dksn1)y@FYO>S4Rgu`5mB_gs2Yf>ovNPJSXT?d+_jtvHz65g6
zwZsUyx2B3^-&p_Db28+<tYK>^uk)wjYu8-ZiO5hQ<6tj_wh0Bob7C+0*FwhF)n|SB
z*G@s`vb%IKuzn6r1zDp-YJ#dob^gst1ob<EU~$9!mWVjMmwjZ#RKO|8OWp`&OUSfJ
zfIU0dQS=H&c<2hLPtPx4m>`HRnLE&cSF#WO2A*PVea{SI&5Su8fgMkmWZKqyi?q<M
zkL3UU4`e->?s?N_eB{MB1Jg8-Ej@;5y69oZ!H#?dlXb8A{{km#w({e8tvR$FC2Q#<
z@_h&R7>-|pB4Up4n4ET?*3KW#CzS~(y^;#k$-Hx>-^P-r)c&OG|F60v7GbLZunw?(
zP*$N#jPJ}NWnB1BP$Hu1)sm^_?Z{#A6I~)=cbl5rLc%@AwxNayw&xwq5&1eoO{O82
zG;s+v3iDT|OC#Q0>M)eH(Rkuo)zQv=WXQox;sVtyR*I-|3{yd{RepXfqmpcUWUMTN
zCHUIdOs24uM#gp(!t!Jf1~T-AL$|0#ShW5UN0xixhWQ2y2T(ElJ);4JX=Y_t_Dxn1
zQ(T>?a$J*LJA?;&>CY%vvCl@n;hsYZURG9IcHz2JTKfIv<QkJjB!j6#QqIfG`?*@@
z8oh(3-<S#y+I%58?(&JBhan*c$t*62k80rjR_8Yy19U1Wj;A}!m09sB1t+FEJkvNm
zM-&gyYx@BW`zO7;9=qSZ-Pe{Jy}r^rVHrOzr5(4GvBkG0%PcvQxyW(}+@A+C^7P|&
zo6a)juHgV==TF7i5*5o1PP<6|ET|FEmm`t*F$j8=ws^QbiN0-2YRyJom)wp0xQS;n
z#6u)rhaII8>v!f|DI|mp$g;}{O24$ysK+^2;kcmC)BuOsGp-dY*0Uz!uORNuf&4;N
z#aVY&sR4aN1TkHcql9T-?dc<dQx7oCQe6EjFb_+d*fn7ljg9kQ%rSNz+-LZK!809r
zt7fRyZF5}?s<W*2FZzPqZpjiuXbrU&j#NU#gppJyEr9mgY^0(dmB;bsEk()?GR8c;
z-<lmJPp<WFFWvjCi%mZ2HSgM-FC*DJ>n9WXnUvDE1}hQHu)}zRZe=_{GcUF2ay~rX
zFLOF5y6Qa>cStR9m{kgG|KqAm@335r_Ydaw3tWG7hGi`8>Cusb$M8q=uYHjY82ZN~
zaC$R4g`Czj37?<m({UZ7qv*E@>Gb<@Tz0kYkzum-8G6{dItJ3vfxk7mSvg)m<cS+v
zQk8%pRB&`Ff+xAKb#j2tr0%#8Yp84JJy%<a&F#Bwu=Bh=e%82DE={R2mGM^)QU65b
zon}TkFa;|ed_#W8j`uL#C%|4A46S^&_b^rt2h!fF)Oj@hcdl(_xyzaw$z(-<Q8};i
zu#M%bh9J0mzk6blpFd`5!#+j#L<H;@fWpzlLWN?&{}5x(^J4$YH!h`m+#v1IwT91V
z1^*X?BWQ(ggMRZVSmC6jR_Hw~)41B)a=Dxjnru-mc}nWQTqTvxudh@SiRrS0xHOti
zcRYP*ho2U5&DEj9i$NZLfuMT)mX@#R5m|$zC%UoC!3r2>uFv&z+8|Zm=V}YTk(%cE
zuNqRg<b?|gO}8Q@bawJQpZ9Xqk@Dw@J@<Kt^&LANI7Z>5dCEQ~E^CB@q}sTgwBMG_
z8C2+Fxt>e*ZkL@Hv%b!M$I7Oe8%afaKa^mi^sOBNd&Io)G)#udY5Kcn(4W4jdyDsh
zX2$3)+WYy?pJK0RzilI%(&Ie;mUx!zbURL!v{Pup5|USXa+%$__&n_Y-Gh*EG+tk-
zM<jYMJ@a?F;!v0a0#N<S?f!5JzrYoNY2?1hrRL17rh<Z2L6)$S|8ksRqrIae+~Lcz
zey)^GBaHU;1Y1zCqn2D+F<sCxpv!>+E9I$LPMm1PL53wgn%Nf&-!GlJBOJ0;O&lNG
z`5k^emZof1TkO^yo%7`6#$HC<?<8^EIQ3kdBaac=aY}kntAohSGSO={Y}`FQ2J>3V
zT`2Hj+}heopPDo|rWBh}JT>U(&<*Hi6V|y?<V}+C*6-XG^pjk2Y6DghuSO6H1FIG(
zO2VcB#)Q8D3&#IuMrqVGbfGTdXA$REpE+O#yP+lEm1TwxIy2#Tv60&0L-#g2@lQ*r
zhufmu=A#^snw@R^fj;*AuAX<Id3`?0{si96bx#s)&HKJ_*#Axz{4OSv>m;QXpko|m
zn;^LHKZjQK55<hKL$=iYZ790S19Qdr(m#AVN;SGv*syIsnsTU{Lr(}-bd+3mhW0lW
zj;JQ&j;PjE`$p44?4mjavw)HYEdnhuQ^zeYvEm#MxC2u+Q#W(N4(M_3T2|ydVs;KE
zaKJAXaD3S$^}LzqBp8rID1*})R{K&uB&NFG7yJ(wqWG`sY!PbduW!^G03PLlcu~pM
zCwTT<%r%_#B-A76n1}E$DWy%l>&^=0mMuL}VsB!4Lr0sKq>3KL(M`VJ&1x_A*+S2s
z=zS@_(&aFjud!Lsw$wo-{rC_5j#!j+w1Ri;<f87mGaPwQ3VQ>FJF(N+nH;?`mwJz<
zTWflV@;AkH`H__vBu)t6ZT|Dm^m1hv1r>I8j_B)3XY@~zvA0s6%X;W~BPcmc?Y%W9
z<C}ny=7T{5$p;K557oT?Amn3i#?8VZx^4op7Zu4nAkiX?s|sT3*#&!K@`7j?^&gmn
znQ!J%!)n<B-1pb<VE(twYY#{OlqqiU_53IaVlB$D(15uC$CLp2KSSM)C3Ja@VVA4#
z&%H4yffakOqnO-@aRMK~b3A{6qa$1S0e>^udo*tH2#bX3`0uU#p-H3Q%J&70_H)^M
zlo}t(f0mR~r+K-uBng;`J1w?UM36<8%rrzurCaOb0qajJDkDiHo!Y=Mix!yM{zwp$
zobd<LNaUg_t{JgC=0fsv;2KJ*$H;dVD@?bqGbeBCP<fQ+ScLawrBjuOji;sjKI=%E
zZylN_bCmf@zUNm_cJA=uP!eB0F3oO6NDx#riiA-`h~ubiRasxuK=}pqT*f=NDI(Eo
z1ay!XIqA}0B8^`g62YuyBzx~LVqhtx$B<*?lxuZek%YPZY`!dl(a?sHpScoMl@9&f
zAYn>i`s&>S!KCst@nkKh!bE_bsMKdkSmQzqc<4YGdQ=&I8cuj*Ni2*Lu5fn<O<BQk
zzB#aZ#f2VS+Cn73vIG&LNxFP*Da7iVoTgrKS-Bcffz>kgy|wh(-f0@;POBC~q4eb{
zPEyosDM~ls(9~mF{1(DozRk&kSPU~zz#wN0m#{z4%#>+q{jK`(QB=k<gN)+sd*jx^
zf~2qZi#0CEX<>x|`;Ea#qwA{mpm&9Gp3+`8HcEaPF*i}{gSs`|2r0s?JQ#zHoNXS{
zRpCJDKehoXncL5|N{1I?xd{})37V~f1Y=5UoGO>}wt2=qlUQXnM~m*p$x^pTQryq`
zUE?;iOM^P-fpLQkPSOzDuwWOxxO*H%;#L1W+0L5VsjzJA6dgg;BSG6xRc)(1SMwqy
zj^2NYTzcyC61Oa3@<-pA&Fgt>I<5-$3Kv6)rXR?Ee>m#?O{^DObC#>W$;ufD0Iyg*
zalnUjd{vmPd&TnfF=HotpVD}LlC!}|)?kBrz^6%isUm~fHlHfDJvYV%-E5PAKCEpi
zWj=1zlH0hYj?TQ!YioN6P>N#6uxAt?i&+lm>tn{|C2qm$7JkL9t|iZf_pQmWO-sgB
zxJ@_qBJBT~Hn$c7eEkcKL;8r0s2Qb-?*GrJjkU|&x*QOU|Do8qs!~70O-O{f;SLzO
zX|OKRGjOot@1Gf8BC0!V(Er#lvDqJ4a-0NE$V@L%%}oDlcAoY*(=J;a*_avtO<$rI
z98hSiUz>t;AC{krHKi602xl99%1|<v#eLquK9kCQJ1M4W92=5!RammOWpFv_(AI4D
zXbzC5M8UQTc35axIIE4SO#E$BlNG&SKJO_(u+zj`(wV781K}vMH<Gs%tj}j3Yd#d*
zaE9hJiP$f;a+gmO5uTxv-smVb4}@*3mYmZV7s@1@7y9seNE~qN9jWP5*dsmOI^#5b
z61Pc|>%TtbDe1D=kERKVHI&IL<L!reeSYlL=EYlCkkbr;g!*vr%oIjH?W7r%A;s<N
zZXhu%golzliku}dyoHEi30kAX&-O>#zefVpT3+f!fJd1cOrBlxBI?-bT4<ZeJZ`Tf
zf@(Ptr%GAcZA_!eIBrr&-Y)t+>PWggu;jj-e1f1;2d8Dprw6{>Z25$OdG%?dMXJ6M
zqofc0%nPgE{fJgS-3B8_o+W-b1LY!}Vbok!MA49g%g4=2p)ytaaW({|=HpG9l%cwL
zLt||lY)A(aOe*p7sY5osf$`T<PgEih5qk6ejeJQY+PixD!@9(JNR)#)8C8{UCbPW}
zy;O_9K%L36J&aF3WW!4q6I>Rc^Uq_gr>%V)#_U>fkgDp9Q#t2m<yxjkt#64n{Hg4F
zq_*dmRL-ublW6^bwqdTz-^@3<(M7MpxeJa{^>IZH>}sQhoVm~!k;K$S3_=^jp-GIv
z;I!+Wu3Mufe|lLPVad}f6t4jA@c@mv>)NyZ!Eb?^Lvca8Y}0F>4>^?RAuLM##-P*K
zUQ5vC8QFAW3a?G0&-;;tFl2aPRP+YigxA5;GirUJ(DdI22X4D?sISv}J@@odTrdT2
zzFtXu$QjZ*$0F5}n`ocv(+5$78PS|JPTytnS$?$LPzf1Vp4o4$V{4qKf%YRtGz<+n
z{1*L=n}6E|v^46|L*A%BFLp5W5QJf7IV{7^tpK0!gs095BA5n`U>I<6eV3p*#jF{K
zpivooErfMBG6!k(hm?oi%#z|nizhg;TbXNVO8XP;`gUz2)2K3VPl;!hWEp01u}!@A
z3e8tdCsv=bFVHy?xf0;BGs9_%namxjyxA%Fzej*fWNL0fJ+-cy4z1|_uHlnu*Ac_`
zUyFMhrG-vb=(y0loxmD4low7hF%gKrC{UJ<h*5-OolP=!KR`@gjOQ2EK7AAdd>Wf_
z3<_4%ika{>j0<6byeCBvMNzgDvWta?|JEFc{ZI5qB7BuU0qjS+0Btos3p|fi>CCb?
z9qEcd!=T)o8KfJ#!bLlRCBIZe#jp~5DHh5c$lmC#P;JSn+P~2FAiYOp*^98flevTW
z|D*}R&efM)x@R4JqQ0L6=2kXsyg59`$n6bG_cyZYdROfiPFVfClD><$O!=gGUGj=}
zgGQ_{xT5l{kM~v|Q?dF(36v#Auv@q077X{)=CYKse2dlTX!{^qiO;ASEaC0cy}Dro
z<kEvhhNGP`<febVtA52H)T|fMkg3X~Z1gAu*Qg6}ovzUm(ScPdQ8$5-av_O1DevdL
z<g?jQK|4-VX@`v}Nx|8+#yTn+p_pgFOTzl3#Uv_uA~s_a#%n(LkSFO=yomCu)x;Ot
zr4C^Q$nR+c;H2<G$WywJ6TB>fR}_z1BL3L+8jcn!{dHRF8-n~A7!tB?b6nf#{ghwo
zD&ZtiU%o>xmArFHE$TW!-9J&Ul{wqy%fj#D-l0QL>Rv)pHSN1OV)Vw^iDQY&uyOj>
zOAL?%nl8kaag@H=$M%`mVf;zz4cNLxB>5rQ=+DrNSzJH1G_<4b<ktjFB%k=uNE11g
zX%8NqyLAo(z7o&_;rmQetXwsEAJ_8+Kx??Evgg$hCQ^LM&sX~5w2i&1hj-4A8vXWN
z88$$cE<wZhIR2!|oRH6%L)U)kch4H-Q>3|)eWU|E$9_@o)C2`+?F(O8QyySVY}<N{
zFSCQJh!o!h$J=dGyM$O~pWrwOb8Sap*b)r0sFV<zN-H5&sAi)pQ)#hHxmBpPIg4BT
zsfwvMg7xg5s^T;ugPwe*>b5t&m?^UW@wO?~NWh|W62P$o8tTwC4I|k@5q9ZNG_&t-
zsVlg7Fxg%Iz$tEzNzk1fgUI7~TVjJ-Ber1J%Zilfj`)<Lt<~;yw-F||%lbTvl+YNx
z6k$hvk^cXq6A$3*h$^qO>7-wt&=e1_#1stIXyzAQ5a1H5Dyy+*2xMAm(d;c4eAgC-
zQ`GDfa~F>Mob!sG*Fp=$7L1StXsXtXki7i(kG(LP>irw?L1k@K4~Q6!i#*jpV@l&Q
zMmaOIj({3yAs)`g5eL`Md!68eWtYifb;J~+gzR1gy|kC$J;b#E=DVk-n1?-;$W*?f
zVxY93GtWs^rbV<C>5QDZPp5*7gl2p(`+}rj_7|z-vHZl_;wYZ=VW^%Q{&%y&LtHVp
z`N>${yWPyYlQ2Ia<4v-2tx3m8Q>Ar5bNY|wC$S-F%5n=PS-k~-=f-WnZ}0ZN9D4T0
z(G;LXY=QhmdgGHP1NqS2*Z$fo0Gcz`*D-@d^dowp_bl*eHzSE3nq3DQDZnWmtqsu`
zGK1()l6utfiW3JQXg^fdwgdNQFTA@wdZJzgU469dpQ-#a4d_JZt~L!shY(p3^Y9gh
zzc>GebWDH#v5L@k$=gbHpv#QcCLw4vh9>OBl4AolE65%n7bX${#AjQVTsbOwxnx1V
z%^_%y+g5WX+PNo`G@15jlxgKLz#l&?hr9S>56SfWHktDpuOsp@&caYbp)QS}A+LoS
z5uq;xszLTAgb^M!62^5Uh<Eqw8NZ>`ceKBZ^JutkT-!(Z1VsH~><`s3s*pU*mF*pF
zKs+U?n9X(7!e2J)`oQ+j7W|500@ef8WJAJ^V@;raDrFoieweJmCiTp8h(;|MhwcDf
zOU7594t)pAp>Y{kwm3n?VNZkFMzlZ%Ez*<r<X_$S;+`w=<Gd$?iQ}{ALk_g*pk`K$
zL|q+xG<($3rvo8bXZCg1B|bPlsW9I;(XG*9e~`|1j9{GD6vKRtYKFS?G2egQ8uW$i
ziEfB0hwR*p&N4P2oNKViDDSluQ&a>_fA@l1=hX9-fm<!u@1fsonp%un3%VUqaOl!M
zt<;v~A6*khAEq>#-BHo)GEHNs>y=<*I8jqU9A)q5F<fus@$at5oKFz$Jy&l%3buj3
zm*b~;>h1D+1uW8FTv=2rn3%RLHTcL=>RD2L0j&7_j8f`*-+V62A99~8?Y5sT`WilL
zu|3J7^Q*2r-$*Iupm+-xfiHD?<QlaKuEM%`cf>~Jdr#IM2XcQG#jcIf-;<TY>-+Vi
zYd6It3nSqxL=Ct<-+4K`NKZ){$q#_5zZ~l+dWGp`yGwT((aV#cXZ8`05J=1Sa{N&z
zewHV`ChCUNMgV{<6<@El0Zk(9Mk}zsf`1pi+s?Pcn?bELa6R=YlNrB-oDWL4KYuw*
za_->A`c9u098NL%ybpuVK;EIshTIAVBb@Cqp9GAl=b#6uR$-31taPB&<axJSIX!@Z
z=Dx;{`Ivj;F_iesz`mh~qva=F<PqlNTj}w{Ax6Rc!g;Mu3m%fdoW?gkyMAJ$3cm&O
z7(C<dm^;M3HtTuTGMs1$5A>Avdzj`zr6C3?EjUfcGfD>K7w*;&-Jb2?^k+Wn^zq^j
z)ik{Ne+6-h3=z}VC9jkO$W;v8zM?nphDb|frfw9`PG`4c_Q>Q5X9iH+Z(YWpv<c(i
z1N5V+w-0ycw%>kU-do2rZ;tpqFmg|hMra8DZxgv+{Yu&>;vI7iYhJ*=>jhr?5+;?`
zdaeYI+CTB0pqw0bivn~MzCBJ)A2@JHOjTvN$l#>oJ1di06WFWY4z|;^_#pn72VC<J
zBR1ihDJLh85Sy^DMUEA!VXhKgUA7eWr|%MOIQ}-+Wi<3D-M!*r5Le%{QBJRqPre`L
z7zs|ctB9O+ovRIzjkyQd7|B#@>$u&scouBFg}hsI`M1(l+;)t1db)+Wa|Hf7i$H%r
zEQw$6-2Al)Bm8Nrh^JvXX7>`18J@@790JSoaF6!=rA=>$R0|MUfY)}YR2lS)9%#JF
zoA1$36}x}3q$`j$gH{FY<3+<mKa=;&#DOTrljwK66v!wpx+D8u+`CM#x1EmHUw83X
zFe_FQr$FC#8=kKFwG*H?o=>NCx{kq<P=>}_`JhK|s(3c)oiP*Lxl8ski2%Y(1_r;Q
ze(WC-uj5)vCzAEOKhZKQd51F2x<jZ3l>2<6su)_Yx8e@|XLDIWZZtR9M%JSlzi8QO
z!8@2#RHR=_Tt}P)&kx4sr$P3gzR-}Hvr!+HF^!uG-b5r}@gzocvXJZlS@9S5i4Bxd
z&LP(!XePip&%BAo{ZAt{)dg?CxY@b9*KzVd?M<NgTMO}?Brh!M^&gsN0K=9I%`@p5
zE8R@Aa*8hTzEa-;?nW<1Pbpq)RYz8!ucqcew1+76*^!Tm_g=q!!8*K3LX<{MVP<bh
zlq>hGk59z;jZCBm!6+Kin7STtpdVYAhI(9m9aVNZns}spO_gCE++5^LW!y>?qos8+
zN32P_KK$-W=KlRmvz$>n@>jWZEp9fW{@lpl=Np3;;xePV1g4Yx;?J9je%-(9CXT%z
z)KL=R(xrY<R&U0fB)D`?yKjFEoD(}5z>R~yr9~&Hw=6MA$gGLn&*2gJ`5>mW^i1S_
zs)yMwg#UN;UA@$dF*fjeZ|?Wwx2~`GEX$}%_c7D(+|Gfi;9Ld;Qp<#$p$W-uy*Xh!
zD^bK@`6mt%y7$^M#h<jzJ8#c);vV4M7g~JG@);2)v~9F<*tqh}+nLbs;H`HtWA$R2
zZ&wcc`i6Ef^l1RXfA!1$7rpc2uRi`pvE>WAnh4=}T!h@JAz2H*#B5Jan$>GgW)-ST
zX7a}!#tmM|E-v4$Y;$o<S)PBG@IMA*=NrAb+`*`4TaEq&tim*_5K3zzziGwl!5X5i
zaYm$*UfXZ;!K))baobGaU?;3bD^VX;NIjRjDtmq8mSa0aooAxk@rT9l|Lu5FFE8MD
z{_z%Vl;h$#^wKmhW<7>8r9;PGL6@SriY}6vWE?^x@?7-UAGZ~xqid!>oi&Pc=gx!I
zh1czP$5W7?MH-?S{TL|ezTHk)dz#YIA7(1Tyh3mQ3Cy6F2ui;OQ$K$GLv3`CH$|FV
zmwGoHGb*;|`Eq9q=Q{NWvaEDL<K>jz7^BCY<2;w~o3IKgn7Hx3lgX*ykH6JUoem4{
zI>Pg<9)4#i>8Z8!Z1Xtfb8v>_DZYvO8t55Bn@;)40f+f_KcD|EFx!-KHh2d0z<b=r
zsp^h70=F`+jz^Y4#Hf&x5xmPIN_BV|QRYJer~Wj(aQBs8xbRWbBZu^ciU(j)aVEWy
zCwAEZmtHekgGuHWZTUdeGga4ZFxT^PhDd#Mlskc`b6sZoo?!Syw;+HSW3A_U9C&*=
z_tr-R^;WbTa1NqJklF6BmUx2;7Xt49?UryA0h<kXiI{IxzruLkZ@g;4X~1%)(M`4&
zDGtAPV#Zfcw;YmD$u%~_Z+}$`XWc4rYDVk{nT2P6jq0$S{vvK?Z?>d+6pI)c#opJ}
zZu+uuSz|r^JxKO>$AaW$niHNU(yNnf!hc6oGLYaRIlU4q`tN#4{p!tASFNJ$DJGx4
zyrF%WLXh7FZP9A?ik9^I>Uo6_=eu*{3KHdT$R+j_tg|2wu951xxuy2j;;mV%&F0pC
zzJ0J_ecZe4>2i}u3+@a=k<^oGk$T4QZ`aFQ1K*uG+FTE!(f${-f<L9;xwHL?-hJ)R
zW1r{FmQbOA={&`M?EweNO7Hn&V*S#2y!w<;>d5;}f4+;>WWw!PmMg?2u|Ls8^piv2
zL)0VSx#7zNHV*{}I)Boo2BP5GcWU<l<C)_7i*1t3>RnEB5)q0|ict|{PA=q(O|)*o
zk2K1G+`Lk<2B9DMp;)`v+@e?GUaHbQdXprSkn&dl&Cil8yiK&g(32lLf`+;jvxTaN
z@$9$MN;lpc1I;7Dl`IW^9t+Ds9_I*nl~SFMXWI?`_2$~q@I7~=jv_eGB`3VbU>`nE
z$>2fM(%etxGSbgWE(x~=bbcYVTF5zcJVLeJnfHo`*Cekq8>$aU;2ERZZ^wpTA1&T-
z;rp7`o^K9waERiC(}v|Zp2!GqxqLkW0X-^xv+SO|->$V6VBTq^5?D0KiZo_b?HIhO
zmtaw?BcnivzZ#|CyjsZV{nhWb7pH*$AU4(}EazC&H@$_eTj2m<yQxH@(c!W>tnVsp
z`gt@2WeWzE2`Jn(GTb9d!uD=%4%;i<OPukbAs25};FSO1@+*TzzS7!=S?assD{XVu
zo_Az~gR0zr)6nVz<AS@)X<pNJP%0{BWe+}oM-#VEm+vn5$#CzB;V&$jq@Pw%3(6>z
z-KsUWzQ(_`-tk84`>X@2s7{AqzoRn-O4rxwxJ|qfMh6Dr5oFZ?v$M{k4t#cG<2LdH
z&aHfLrQ5#5ayvpd(22j$afb28a6a3Yku<6bOG2Y;z6EW_#!994BYDhfB=$kZ=u|I;
zc~*Kq$N2m5UxKx`T1Eo6vX$712AN(sM|*r7ww0n2e(GgV)oP_qDk#Nil3BaFhlG6T
zf!U0%i^0E=XMLi=E<w2Sm^ow8t{UwPEY-T!HU@{WpK6^~P_xH>d(EAv?z(Ol!5^TG
z3=%Voyi6Pd?v8J&1_GA?#P3L|Ed#Gb+tI7A_K(vE>VT$z+reB}L&9StpY6_&^xRy{
zaat;D`p4gvKyeRz73Fe0`JP*pdYU-5;hElOjQc15r2t>3o;RS>0rV=m7-!U{D=t$C
zFfr)c!AZ!UL62Si6r$8?EOvIV@-2((|IG2aZGXWx<6>cX!HDJj4fnu)&hnSl0e{iw
zTOJ<>P`styj@L5)XTDm`libL_ixrvoeX4&Pxf2(Rj>}ra)2&;d-z4#S2KT`G-Hyc`
zwpF!lTFhkax~e4qrLmj6<l<bp2$o%h?>kahl(yV)_)trW#wR$AnNvsn${VD_reAHs
zT;%Ekl~R(T)sg#8Aq>NAiqlpcdhclo^4EW<XSI?~=eK1uWbKgXa#FxQKn{VKYyd<n
zIP(~^T}xcXkDeu=%pUS~e6<4uLqLZp+i(T`T-#H3XuX}+U+LQDtGTpkOA)L}i{=Dw
zB{}9R+YOS;9=Bt7(y$$X8#3oy_#ucz{awDzBY2G1V153erN+&irq688B+KVn)+N#E
z8lt=t#qkJ(1C^`TbfMe}DQDA!%U|B^(RVIy$#uU=&V8L`?5VROcE7#ycN6!pfWs6a
zd52C*AQ+$H5RXJAD9ng?&u?#Dgw|&C6Gzof_Y3FVf;J+#!+8w%I4&N3u-}>KE6K7Z
zS_)KOAGvZV&F`TRUsbzTe;&!L*8MJTmH1#K3~5fNt((1PesANNxP8=vR4A%op=7Te
z%$7}uhxLR#g$?ib-@!m@$E}a@$x)Ri9jKlA;QsHuF{&YILL&3)w{x$&iNB$4Z2aD2
zIdKff!i?-&ja#IPz&pv^u5ed{{~_TVBG(4-&H0azB=NkWC;AmNul!&UlcL9O8WRP7
zwuEaL3;jeV%R~J{4^h^424Qz0up$RW_jByp;^pzSf`WlWFBi3q0<0Heq7+3MGoE0_
z=y$y7Tre5@aINLRMSG=ezb!DyH}8;rD~SV%3yxH^quF$jsm=Dwvpu`-()ezuLD`Nt
zCkNWzj2K>h#WGn!HRM9FknEb0&Gy8F<FDPQje!qJ8}U#a^w+RC`z*Z0+a7%MDWQCh
zvsdVC&vp#!ZN74&TBeoW+^w2`WSMbf7A^+w(~d?zSCcZ|8!B2T*!l|%l9`Y3++^!J
z^e9_RW$>wwqaODDUsOafqham&DlP9#3g*+Rs01W`0T2sjVasnElviQ-`_YbLYeVa>
zuL4t|qe)zYIbv=xxbWM*4g*)AXC!QKwGzYUQDym4kEm9{cZzVjH}Drqk!ffCBmL&w
zcc$UG(>&A+jzEffU(bL7V3PxOAJ;+d=BhNI6ZVK$n1bjKK#d})a%RV|T13$op$_i7
z`IAxkm)`<z4r5aJ_{&S7HCc8%DY}gq38eI|mXQpYq>iOlf$7%v?%YZ%>DTf8m;kj!
zanI0bics1_*FW8BSEnMwg``xVBB|M51Pl<Eo7L`DPJDo$8YsBBe(OLIESOZxadL5n
z<S>8!ysgiJJz|0S_!)EZnQ)Lt!0GhdnD;Yt2IPkyC7-~e_|*q%0qRC!zu%2j7`*b7
z`|{?UVbMV;QJ8?mvnci2jCMav+GFqV?^fp&$Oujo+9iswD3Rv4t3@A<h3(kxp7W)p
z&4qQY{_l+m#N1y00_qfAx}n=Ckf)FG<*yA_@%daI)Z#|SM%wZd9(y~c9M>B`UrSs;
zxI7&%FI*Z*RL9~SoLw%DGL>C_dO-tCW|Fi4!jf;?Z3<XN44a@aWTIfq=UvZny0OIc
zF<IDs{!g@<r5-JAXw7OWq}{a^xjkNh?L?*FGk&lmvk8sjxEBrU>+*ae0W4*0l`+k;
zMbi#mzuqkK`E!)prhSx?ILv&k9k|~5l!9DzW}0J?@WdKwZ$95>CX1@^vbDXSGCSI&
zF?ugBIxJgpb;~uDFMjrQ0`TV7jK^YFAoJl0hJn6~Fa-i%sy>PD@|0WaN)_-gBobJZ
z&)S)Eg3^*x%&K<WQ9jsMrG?XcWda5c#`IbyY}LGX-53N1(OTgOs?{o8G)!J0(%nFQ
z%+_j=YwUvY2t<9fXId$87ByirV<ixQzRJ;Y%HkSZ`?LuIkK&5>vXp=p4Z}CqelNYb
z%)5-r%UZGw&%IuaR>o{afeG%lPzg`u2Nrv0&c(j!pBM>yiC+FQ9K@TI$#Lno(&^n+
zAC5`kT8JR)9E;q0=U^VLPY9v&5bqzs(@(kr(2B+xK#ilhx11JRZCUw@CnBlLtVszM
zv1+g7Mm)%(<S73<{vG`&amvFjx+KU$z%0Xfx8w)2$$}zIeU90<jejjTr`i?W%qQW`
z&6`ILHv44H5;YKfiqd*aZO`&H?@@=>;Q*Ygr<?9yGk1YoJAL5I+TB>{82md$+Tq=8
z@rNJ%kE~w5G-CKAV6DO49Jy=bT@KoRBGIBRE$;9M?oqiv_f+4X<r{x+Ns&F`X2BEv
zrDxIK>YGJzalqehKh2VTkp}+Pxzv83F3h{sIif#_ZkH;?M#!eBJ^!PA=;Gb2)4Al8
zwc`H4N+v8))f+tW;~M+@xA?yO6X!wC_EoBV1tuFjZsJH#R|_KxONR7Qx<%cO$vg4y
zw-mztju^3E6X7##K@+P(m$u|TKa=Lc3EzDOB5yJOg2d==*9&&(Ac=(SI49Z>ElC^P
zM1`7e%7IU+-RL^W(^SCwyIo|{_zf}S4R>-C<jG$*bLW`dFfT^}u<k9<6+=R50^E(*
zZS*|#FB&9~SW0As$Jd-$ROE=1>T>gx{4?U0ubg+NNlz1~hO|LNdyxbhz+7E!n7*6z
z1+|M?rgb`M;CT|K`N>1T{lAq2Fk+@@jeqtLm66o<V*|^!@ImiE-lG8Fy%KLnO1?P+
zQVqgy0QEqJjJ@&FQ98qVd!H_sV6k6((Q1Hq-o`X%{^QNjJzFD4wKW{yR55-D{kgi_
z;_2jP>~p+X&G3!N{%M<n-h4CfDr_CM{InBlcw(K;+j87E`Jbh#4!QX&Cc7K7e{7I4
zLE5x(01!>Z<D#%X&<Q-i)y$ln<ROY#W4Nkr??fa4m(~Bv@<%pbCS2<?d*GdJy|66g
z-&9hZP20Ag8lGC!H-^@i{3CxU>2)wwzEG^Le%|LaakSy|U_8u|;6+>hN9#@6UfuHK
zA3Z*S7hPDLVBJ=b5zB+9T;7Yk0N~tU9!ZZ4U0^G}vs}1Sw_{fH<ae4Hybxf#*{^;n
z?HCaUp8oKEg&h(-2e_S7O$=T45+E<Yu%9l!^DeXh`SA$M)W11cXx;8uI6Dn2-so^;
zYPY*T>bKukX_k07SGV*C88I%ZFv<8srzcF^_07Q<mb1e!gtu&n?>8emg&L2?K-#?)
zywxJra+$Q6K{vIN;|9Am_!k{s9p|J@Y+m)X-?{LUFDX!i@H4^Rt~)yzr*;*W&qK63
zt?2Rm6!R*$d2h=ic46mLKCk)EaMO``;QSl**QgT7nh31`#)hguPM9=sYdo{sZ0d<*
zd!V0Tn%ZuRId{>)!qwFd|DWW|!#*XPlN?J>yMFpyYw^MQ{XW;32Hg@GrwGcxkk^|2
z$rxK+><)J#gcBtx4JNluuZ=QNQ%1-E(7r2TZDZ|X9?$t4Fax|lnd{~QZm(`r^B)1W
zCe=NQ#ZH4b*4A+MF}c6=Wl1O{>~|ec_zG1hD2Rbd?d?|pL;6JlE*&@$G}P8_1{00W
zH##`H-#KvyB}XiLx~Q=OqF~P{<<FGkNnS;$4;3mUmcwNr{j=ul&*_ZYYhM$#We2tk
zyHhh?;Vpd@KD?DP278iqN{jY4hqEuk4PyEZ?Ao2qj<@g;9|jy$W}FUD@7*I7UXAXN
zWT+p<mM5TP_=Qx5(gX($6%>=3^2>gCF!;VKM5+zJjU-;XM^amuu*hg@SqKS#ychbs
z-R<#FQs#98jy13FSbRXKzUHaqq~=VB5ZNEg<y=vVYAv5Lvio=U5n}t0@?+T~D45V*
z;&UK1mq3#W-A;Va<E)h<wJ45Vr^nGhQeH9sRr90T^{m_9$c&^tety)k^uUK$0JD<n
zicC98=GTRKT&|&D-52?Ww0=?-riLX*RIR0cw*49;e-ekH8@NN@FWx>(RLVQ#D`84;
z+3vZOgctVY4yMUv4f?S9m}bn4pBFK07Gl-r336)@Kve@^_TW=lEcM)aH=7lDq&awR
z57{;HfH`nR^CUGyt;W|VNAVCO^(+6UH`kKPc5TGC4$@VfGTPH7E0PAsaBLr2?8-@A
zT3CGo4*58}cKU=-cN?bl-AwbXKfcI{L|?s2${yW&7GPEA()W86763qG7SHhFFcL>3
zWs8f`gf-5`n|_{x6hK;mX?ADf0ti%oX74!&fOu27>vu`7Q8(y$#TBakDDl0<d}-fV
z$$Q+caUn8(z0fh9`hbfAo9DSVme$K~>+x1+vxGnU32GV5FDVO$v!y&^Gv&*kNzT&V
zZNkW%ar?h~O&|3{S9DXpW1AnZ(oi;=-LsPxvhE|uBnRvPJIDT^U{q&?vzM30!d(m0
zQ7?%6mF2!h{SMcNsWn^ag#B4+rC-D9%V$aPfYc&n{H{(K{#O3blsxKHoM3$Y?<Ze&
zVhmjesw-zogphHA7xBE=#h#}p?2$Js&jM=~?)!{mT_CSKQuK9cH}j?G;fa_fq0%EB
z-#pzp4{bDU%I1~um-=n1+ni$uo$UQY>9mA(T8MGGKic@}DS`aE3#8?*J}zTw`P=SC
zbKv!wW0uT1OAD>}R&UE^R{6i;g`A9OSf}-RjZ;E=quM54nm-J-H~cd~zAPMh?6<_j
zzCs1CQmYNt`@Eop$h{8yckUVL$SZnzcTFUV!1+#S(J&FU7^w-X0Ado?;x>K~_47&~
zIk|WMOq{*9|90tTRlC@$0RDK)#$D4=7SS7rp{D44vKXHwKR1t(N8%?34^8B`OkEy+
zT1G<?o`$&av8tpW5F>0x!CxqCbKHW$9hHs<mf~@4nZ`yWq6@yWdMOcbzHs@eHzGSA
z4f7v0d_UA5KQ+_LeF4{D4@rIN#;MQa^n1VTUdRV8t*fKKNm=o^*k|6+`{bejm}~TZ
zt^e*%m2h2`Sswa7?7ih%8$tg!iWO+lK!FsuLWSZUTuZUi;@$!UiWPUKIHY)yK#@YB
zxI=LF;O-V6xI1V2ljr;a&wbvVH(c3}<l3FxnfcDgrnK91P{c)+yrXACWnU9@-dKR_
zVK^5U?qO;=%PQqxdIrY_Y}7^y*ds1Y3c?2g`l9)#J%ZI{nU(h6+nIfB+kUNt(6QGi
zNhe>yT(2E?xXB##s2#OC$_N6LCD)gk<cCr-%GRj-wJ=U_@2`h2pl#QjuX5R`33spX
zzW2IrD!J=uiwI0UO7IOuMu#A0kI`VE_XU3n?~NXuMaDl)2QCjJqx>`PW6_CZHf7UW
zaDUbjIEDFVLPDgp65{o{m%VQmRr(S=qAWI8RSlIJGn}M((}Uh!SpitL?@i50onQl!
z!&fNfa&;hTT4<2DE0W5(ZJw!bEdS$JCQn{nqO<7*)m-vZWNq`qo%-*$OU`{QtSb5h
zO=No5B`x!bLd4gQ&5E89FyD*=r}nYUi#Qpm*?UEfu}2>9`g^Qea4%}nda6uuZ{|}N
z@xysdhKbHEy-ObK&fClf({B1|$A`TdKtwO7;<7K2(6a_e+#)76ZlrnlBjSyk{=4+F
z2oc{Lx@{#I!IXjk(SlE=PM4F;DPM_(r(fM1AXtyxoa)ET5Kwzw3Fx3M+3}-`;hB2L
zFWLexDvDV=PP2KI^#6O5NmtC668*P+N{XFLwIc!M|C4zd$Rw6<VO?gNaJAM}f{t$|
zdU{J<VQ<@*(r2;jHE8>_r6V0}I&;R)o6WZ{g}b4<N<N{FlcM3s`cU;7*f@tSLb<zg
z=xn}z3Yzj084%>8v%Qvy=gJcEuV8paH!U$)lm0q=?oo=Om5J%6_(YSo61dv1+d__&
z4kvxX{pH$k23g`Dxg58wE2gd4Hny`*r#}*jT^^30Jo$zt;G)b!*{w5WFn?Y6^GMK}
zXLB_L&tOE^5d8NG225L|*C}Fo2XT?|M$P9D4Mt?f<il$3zdT=D%gbOVhzcv@78GjP
z-Id|>T5NpRwuRIEl=@YuV5omA>Q|us-O*aF9M0xU1L->*f#YWpbYR9qq%eA^w!^u#
z5GGUP!}(r>9mw-|J)xzCk;-$-(6PbuB1|ZXhD%1HPkwnk->MN%<#%!)H+G_thLA)T
zqvIu4G_{uXy}I9`6xH-vkPA1#wfL}(MQp%xvCDMTbhW8JFnql|M&Xi}>DWauMC;YB
zbE<G1eX`fx6LX-PTxm16GrdZTr>wLY!JIZU`ax6XZzVU+o^V&;KUOi*4$T|tNa4%&
z6V6RuKJ$XaL}0LI$VUvM=uVU>wtJ%hZ2a^{{(0)>fnDJ>n4rDT<N9%{!`RBLvJIDj
zci!VNixzNw(T`gr@`>GLB*{<OpU?HQ;wxF8n?vZ3x=l5LB3#fGdQ#~yW>&PFY@$Av
zqxtfl2`v>70b1u~<!g%TO`sch2&c+YpFYDOvL%GM%nOazIZlx>Wp=%Kwn8*=iQB5;
zu0Cf;y(X5iK*!Y~jR-+6vI7W5O(pCg)p~gK)uh?+#7j(4{I%OFw;!alwPyW0Ke{ac
zLY5e6(ND&>6;8FWt33KEVYJV+rskGhY``BF^s===Lb6R<VQ9mTmM`@_B#;S;DI}Sh
zh(!Y>t=p6vyLad(F)N$_`Q)T>mJMO_7K-MZef<`?xG9GbvU+YlXCCB2naQ3+u?q}M
z+nlLIKN;X&19cnCW`ROG8IUHkD^KzPUE;5y@K;A0o4ljqBmL8%L%o3Z7Q3<uV}haT
z)PM|<`6zlDWfoV8rUvsc<R-)T?cM*>)2B^NI?BIh_l5t}<7;)fH7I=qpEEhoJ;-GX
zn{Ig)K`nfdII}r#Xiw-vUY1$JYmrO3cw8G=FvmO<o%JCMz)UZZhpK!ZdAaMUfCLM&
zG(uq)<N1GE+cZsk<booAQt-2R@|Gj#pkkBzdo+^FQ9fZ;l=)~tCb!z9@l)sDg)X0;
zUS2dmq+N@2y);C8xxn*OTCaj0SvBJXms>Aro=T@*P&?B7enE)W9ewp|Gc*2fHR9u^
zr_vwgXJZ!Vu1EAo9deA!SKpZm&8;Q$yxUEA&-+^z)0KcDd=m2b$~#*kL)24Lf4J`>
ziE)lxvoxJ$Exh(h(1lZF>;uJCS&snywkY1TA~PAH5!jNkkzQ&mVHo^_hS7^4<4WbT
z%v+x(gJOF=-qbHGDE>Y{smw@5N{3{bpcjy@%+4)q5yE7pxCtzF4Od^zU>to7dZ~S;
zNAhDTSx~R5jr?KG7eu~Ut8F3oC*siL)nxe$<VQ(Ov9u4(_t(~0k&>QV76DU7w6bF_
z%vuZWOf=yYrM<7T)@k(`;h<d({n}?<96m2UDF398F3pKIWrM|+{GIZ;?iEn|=um|?
zX%&BM1Y7}I(eEhHES?P^L~{9N>S;|g>@=k!#lcd3r~O+@-8&s0#f8;6OWY|>(Fm7;
zxDLm^+eYDF7OH^-la#{1k0L7HU(8pKI6gAXWJ79Xl>NAfEWFtl9jT3Y%hT+A?L5z$
zp2s6WhaAEr&^=UjnPbMFIk{&%`MkBWHBy`Y_2#^)F^Wp-=MEm7_aXa-m*sEZ7aNTf
zOK6wugdnrntup+to&A@QQ2Q|^yM&3M<QH1zD=R!tV%-EGOV^VTLwJEbP3*5{eh8J&
zWF3hF?bIEN<*nr&6`#!G5Z#`&4AWZq?)J1scj|=EJn9L#A7(XZ^vJuIYED;jX74GG
z{#Su|UjT$%gN-J{oDsnX1PZzr=kpx&2uRl#ip0-4ibuF8z3v`#w3OF`z<CjTKXYly
zG_FuasvXv<vB%h^{G-h25X#yL0DzaA+qP#p*3a<axl3|VN<pT0jha1UW?9?f(VSIT
z16VobLS#77CH3B?#vJiLQ#P%RU+Q_$XQQRN`|@nFYYPX{Gwax4DBy{lEST{a)c@I9
z=S`+qR^7J_2{5KpWO_cGiChNs#Tn^J6fT#`j=Wy8{;O95-E;?F86Ek$Tk!|S(PEEP
zMA)>fFX>rAC>mR7*+$;>ftoChDrSlc=qS<tWWBfl8+^Ip`+a5ofb-(XnCivPjFlMI
zeX2LtR6QhT8Rwv@bnzkc!D|DsLj1Muq8FH5Cee%+k79_RaUkDwu|c4{X=NcSz-e#x
zP6o4oTJiU7%l69Qih(qo-0P?l@f#o49pA=`N`yRGS;{>P$!U7L17?u$<uDwmaj+#`
z*^m16S8}UNHEBkUUG2?aT2(S_s{5MlxUlQ~E@$5nus5hw{idfR?~^P_9+&qrnG(gZ
zoVX0fWw7POCKVMIp`jH~KxavWPossk=H0r?-=*(P$Q3vs{20`d8S!@9i)UG}N9)e6
zi-RGt=~#pG8#f`Bb_n!D6qv-^OG_`AIn|GmRSJ6rdgMwTa;YV)Ok($L=4?Cog#2vt
zi3ww2ZMenfgqUoUH^Q*0XC-RYMS~7!N;&c;-oRFgpXe14j~{*nW>Ul}9?CskaK{e*
zf?t-Z$$Wz#KvwH#i@C9@*vjIkDmCt_iA>4nh&B)YBte+fz#XoWay>}J<Yf4>yW2oG
z!XYen3&(jUxwGa|uPJLrET-I3Ez{`9fox;kGuNIA@L6kjU!M=QdzM{=UNr36=kDaj
zH(@;wTdC7;NPTSGgdEdRQ*`kzXv=ppP@C<I6_?6nTJtP@(Rt~Kl3%a2E50baFd{9*
zo|Vh+SLwMe%Qj6oNV9105a-j7PPJ^<6QOWVS}@ib3v~Gzx9VlJ70g$OLzIqns;++#
z98K;XNQ0)`?|q^?$zu3D`n-@}34T$l{+_5SW~=Pw*8)Sk)NT9RlX>CIx=}NYyqMyt
z;V+bSJcvgECO54yz_2t|l4(Oq=usFGJr~Vl=@pJ-$sCQgvdQgE9&$v{GK`u{L|F*z
zSn)*F0CNu<8(u%@D9`t~!x1H~8;y2mG8;z8#lKi>qg+_Tc1-g8uLahh<b7OXOndA*
zAmLi=;O?TPa}mr$pOp`EWC0iN4?f0eUFXhlS3B^m)Ll;uUM6ErAG|H?;mnALu%N|_
zm`Un6!;g>_rJQaNrCA5M&dDZkD$o8Tj&Q!m*`!(JSCpz<PxQp6n^Jn7vVf|5(t=UB
zG{V(%{=#Oh=gl_F-w$VCkf~0KV91Nq85=C=^;eJA3Zz4-f!|I>2r$n7`l0fL8G|Q=
zHg(J5A9ADtbEc=KEWzwFtTkq<tEXktQ1r$v<qWgM@BR#7z`VabnHbLOY7%=1P;7Cd
zad8*4t956m`4$bd)EbJ7xS_~*HTnmkA8a&0#E7DB<K_l8TT#J+L=WJQ3{m7NlV4o`
zd`MHa)W}ez=6}Bvj+}&KVdVWtc<uV&>#U_~?v2Q}vB}d$@|a5*fNxB^LXZ9^$V4&3
zzKr1veJb67M`zMTK$RE*`VA<R!@a%|!*-dXnIf4OmsVHat%ic;uh04exW?&-WEgim
z7#&`M7DG?JG;<t0Dk_cgQo~7MR?;lir;cFm&a$TxU5T45wpx=lW*J#?i#hka-kq@v
z3VzV5F5ICJEPctTn?m*aZO0m&Pp$ULSE>2L@@QFFF`WF#>9(rt3S)9Kb72y&a%0F+
z>C!7xQd2$C`HRIl^7OgA=OjWZXuIVad^U>>4yDpK4(GjbT7Nb3k9n~Clck`_PI+#&
zq<;#A>OsU&N%HEvhP03bY66U{rqBXaQ(G4ZSJ;Vis^)h{Cw5Bq`<jmvkLSlli?g@v
z^?Oitvc$xQHvyU=B^DylAwE?^=tuK^RCDyAONVDJ|NRTv=w|D_tM0%HG_{;y1X50W
z%i0Tgo!AXDx`@jwAxf+cN2at+M<%v{G)sBES6j*wI@L2Rp~GMYcu5fG!sx++o9A;`
zBNN&Now(1wX53|J&ylt2-*Fo(?Oo>UXL>8l&&h?M)IxODd9#g8hSk=e4g!g)^G3T-
zQ_a{1E)3Hj?sZ20Qq*Jn04rKozcqm3^$@>zD|=7V$A-m{ObZ`{dlA{NLTVPkJ3#c`
zbEiay1G2kDpq%8a2a<m$w9FgaOJ8PZ6aSGWw|*TCkQDoS(`D>c?yBh`L}^#-SVJWf
zFtq9WI{<GEGzT{0DstWEgSFbhaM9`h{l52Nvjw1A$_jn?Pzy9L1qyw{jjN%IFlh6C
zvjE~f8*qu~OqQBzq>*EliOaQv(P{=tS>5dCvjesjZnkCj6j2oIign!)es0B1{cAM-
z9`*lTM!Y=-;4o`1ry2vGMZ=NRRx$<u#ED&gZnj(v|9<t~yOVqvHw>nz0_8I&LjS*7
z2j{?4G(Fekt$eUoqeWPi@uJ<E)t|m2!Cbe}qDgB=$dUK9!SAbkE)W`Xc7M~XinV4g
zYhf*5HAz)QUXc(Lrbz=I@uwTPgbE}Ypt0-M&cL0vHFM*X8q|+Dz`|V(00qD2PZqY-
z0Z^9DDTXx|e)zXAkC}8?)$AnFJQ}r~&Xz|=<DeOt3&9IL?<e(6q*$BG`WGqZh3!|v
z)6lRjwsLSWlzReX)0a#a-A^`|H4(ND@Xk`h75$M<OhnHUh-)#bOgd3v{530DU~sf7
z@lR6^wtzr8!y|p8ocNMAxS?GUXF(PXV8cF9L#)unj<ns;-*b%%@F`Z|5Dx7hY^l*T
z8$PNOqSq@q`g@WRA~o7Zz*km&&#%c!h)i)1>uGW*)TDin-X{Z&Yrvm@CO!PHf5b=+
ztUV!%pg(zVpkeDnO&`b+gI)5jbKik`;bv>V^dWKDnPFzdBQzkK>uK;H5JSKF#-P45
zgv(bq$n`?wiatTXtUtj$v5z+bE%+#jV`-bgYc=d0?`~%V^5Wm_7c)2l`fyRXnVIFq
z#%@u@vo(>A@~6fr4_#Dt9a&_78?H;RgS%^#9YHg!AVVFCC4m+`W(4}^b-rtMIauqA
z`cwqZT6QyopqKWe`M#6-#fG6_)>@9RY0{U0f*+O|Z~nNVCbNIAUujOp{7AK7^+O_z
z&H*4yUw)#%B$$!2?sQrvM9zsVeGaRspyDx>%$n?bvM35kMfW-Xma#mJwm%PB8Y9p$
zE4nThOGsID_JmjwvFP=$9FaXKprzjW0?qjAcf+0paNs5WwniTqNR;FxL<F8Ct^ZxE
z>#g1TnhK1*Z<ZjdbsJ?Ldrg79A7`)7^eR0yGNQQp88CPpH!`Kqb?>`+p5HEQp|ofb
zUGEm*u0>__8ut7cc1=QmLz1XLxfLXMx|SfVioS*B2br!R9W><@QO5a-%d7R?2$gd_
zyegmo*lKh;D!914;)puMg}k^$HPhmwy0pQ0)Gk=>Nidw5hMheMsi3(#fp$_;U`!y;
zI8qw1*hqzu9h)F|*BrbQiJCePI1?^#4Q5(?jaN;^;*yaf?yJ(%ZjWWb2&63KxNZ$6
z(ndepeHvu)W+)J7Zd<H+6{z!?r1xr_@~;Bn?(cpUUSRi;OHP*hQ3I^aK~En1+5n%z
z2!+$>PQ#C>W5D=GBPYiz78zFTL;+m;ZBv}B5FOLT9~|J|6LqI!2-ir$KJeJ3F1fDO
zU4dW9ivkZG;o6II$p8Bl00}o?miN0Y%c7Q&z{U0NBHn^fvEipZPsf4d-_A}us+SQH
zW5flv1Uzz-G7s#A!YyUEg+wz2Kp2g~zwq*=0SK=bT>?`ISBV~DwT^T;-{U!hF#|ni
zP0MgTF_;G<tDDQ!kCp?AQci+*k+Y@15cjEs#HltKn;97fjSTQ!tIEeXR&w-_wGNje
zLnYiGp#Sj^2T6Dm6N{eTNJXRVJ&XGq2Aspc(?e&V#|rZMzc}#M$6D+e%*6kX{Mdh;
zjf55P4<-q#dMN_Xf94d?8Gb<hsL_wPJ`n!jUhV&Bt|Cc^Xtbj3Cwwyhfj0c_%NE0M
z!0PFKEA)SLJO0lJ0{5d58(j#aGWYd3@qg^HuW)-n^gxgJ4?R5S48xRI>$t-y#qXv6
zW0$?oL@)2>6&Wx6AG<UE{{#7-x!?a^J&-M1g97FkUl8dD&_o9yi7{=->!bFZ#1ITJ
zcb|WPO-vjmfcEuWf<c~rSKoop1w6iHY(p3r4JZAxjA*jt#nZkx6bmd~8rbd63z&0b
zF?n8yO~zhXw{$w%@TLe+AZ)Owa&+Z;9nA+lvb!@rRNxL|i094V{5dB^-!wegbk-uz
zymQ<PZ59wslZ7fX&6gOR3R0%Q@1Hi!jHX8AQmk+cFeO|AQ$_R_X5bGt5`b`6-j9mZ
zJXQ}uJ&htV8SNkgW~G9xqfbgZO<7gx^&sVv5|ou_R`+RB(MhzMEzBZ!YQj1Fue+_s
z(xkh5eWCD(QpsP`>CgKw3-vr}T7LoG%(z~St<JO+pd9u9Xa+hxqR*jKt_NN7NI+lR
zx%hBzXInk`jGR4fYOc<4LA?LL?%;HLd+`L>9A5w>+5r?oo`BkR`;F1PX6^gK)9r{w
zz&XRNVKgD-<+kWyWmq~a!s_(a?dn+L(3Zm!Xlu{rf<4LM`!%`?oV%-L(QodThwcZh
zfq9KUpxcGdO;M{#@$4aC0!0*&tEQd>wMPdC+hbj?)pf5o4v8+>WPM5{5c$?=1E|tP
zS-yCk(29DH53g4&0+gO-^X;*4Urxm+E+DPVw89f5tg*h;l7SAMw{}In_V7Hn#x>(<
zat7p>F4jwii>EFAHJIJ=yZOBUV2vqul%-}2Y_vr(z9djx>v3j#0N6u*r-!H=hLc5L
zJae;ufp?O6n$%2v7JI~b&3S8ozAF%L;q&achx?d8WODp_EM<Dv(h0J}qr@-)X*X`R
zv+=CN@Q(6u2r0U5mBCDTA(`(5tRFt@vV2GG&sH^c3s4LD++MoBC|PW{`gL@$#+eo8
zZg#Z#s1cB6QDR4;tpR0{o-W-79H~@+lASkzn)Hjt7Lo0|+mGbDox#1isdFItolY}w
zXm#|r-tPia!dmN@w#5Ps#en9{mHCM9riXi}gZ+i>eCI64r*!P*WFF+;VoCG8@UpoE
z5<0Hj{L$A){!~$rRoN!eIndSZV&RRXrw`tCj1cpIJyPWwuHEUJ66m+Z_3W4Zn2E#R
zojP4vY;w`bF&xV(PS&ffY*?ltOsKca<YS{=4Q;NO-L0@=5#Yg3zM|fY9$-jSvYKS0
zDSXrDb64-W+A;ASVYHcisMEzI;&8MohJdBi(-dkcC*>Dca}RF-MNK<B#sGSTnD?_{
zla?DVQo_DqD38FG{mXui5{#ys`is@?OZAZ!^AvjySO2O_D?G$^+ellS6w|$cx@BOE
z$Rgm?p`|=0m^cBkOrNvP3+swIvcZdDt+6dH4)03cQ!P3JvbV#mM9)(hjZ7|httJa4
z*xktcw$JY>9Y;(kxzF?|5XxQlB<{tVb-msTxqofO%q)vo#e`?Y5K%SNkmm9toB9*l
z-@1LD3+yp|1q`NYUF7EOyHS<IdsxUZU<*ANybZGd;3&5W-kjZQ!L9zogr-6OcP%-{
z#CIhP|HWw8pE%JPaMB<NO5^h)h*V-AcX8d-rUEM!Dn;f5wp{_~gQECNeaw;Xs%;Hu
zz+-2MChuJViQRmG(tT54+pUCl#?oBrC-=~WI!A%F^JQkv{4o1!m%T&qk-JfbJw2tW
zoI@IKv_!*~!PrFrukcVzWK*&={zisFvlV0KKuI7W0FF*n{-*{lO6}$G^=kh~Y}Dih
zcU@^4{FYg;dopXNa{6;pI<D8T#zt>UulAemtfIMLh*5plbXK=g&yyw77$BmO?|Z-6
z@@$o7qvu7sX`(E71xz)GO^4X$AcdcC;OjUb;UF>Ng%3>pbq(%H_im1MjAU18<IDtF
zW7>A1elx>irE~zVh`IMDzTG{s?(x!^kJwo3*4tEI!;o=^=eb-iNL;1%kaI_hP(=}}
zYFOvct!Vq3uxqp4+1n)P>Ljk2;n1cD1f+1_0`d%NM+1>5`W4rB{N0d`ABydJTbxhy
zPi(<{##r5Sh-J_3ncyy+xRguH{l!LxZ`6tp#lIWj2h=q8J!#*ux{N(nI}$3tQZ?IN
z3!)?kU@4m`g4LNN^qCni*KkW+_R3ox+uxxX-M|*zOlno_`ArskZbwAs*iDAG-kRM4
zB*?;?Uq)Gn2$7+JIQ%h;^k6G{DwD0jWqb7d$`YU<YI6ZLM6g+<!O-`HMVQPUOqKYe
z?f|^2axM^+)s6nNEY5z|q!4`)T7LchqwE4V=UF%{LA{T>kw?%X7dOL*onQiV420&5
z?FcKZ1f)M*H0YeuHFNem<4&L2^*7gm?aq|eosIWWwe>#VweNOC`X3_1jZWT(#oOIo
zZ!`jE4<R-B0=^&yXGV|_OD{tM#fjc#t_}pWng(ct0*&w8L|fRG>Lhsg&t=Z-j41!B
z1Eh&i%#cuizQey(c{eO{LcQr<T+IK{cb3oTz1P&B2;Qui@BJ6u^Fxo19;}0oJfG<5
z^WFD}nZL6~#&s<OYsUP&3Z}YtMxEUa-VSWGkD6UECS?%07b_T$pYdQTjp{-rvnYDD
z<H{yU8`XT96eXsZ^DIc+PS<<?W_lSXDGCE8A@%$&#m!cjU(6L4EWZL0&AEH`l*u<W
z%1L~2Qyv3<z?~u#_suRg%$S$cLqE@z+w9${tVkC7PG~~uH(BC)WTOTaguh(d;jg;x
zazdWqXCI+Te1iAbnwl>bCtI}LBnwI6`(>{~drv~>Z1J+YI$xFhl(q~ohsiDj(lfA}
zV}-4GdRF9I^TXcHR`P%fM1Xxtlz6!4Q#&v^EyP8LhuiSWnyydWqeoAJ&0-OP0Ny6a
z->jrV`LG<gw=zV3rMmS<?$R+3rZ9;U&Gp*D$lIAEhNbLx$Il$=&y2f1P@kJO?yZka
z2w5fsw>ZyPxWZ`RGk?vtL5trd?UFk%O5nBs7)eu)XN(((cTJ!eQ3MF>JH2mpnGiO<
zLd3;((Kro-f5K~uGeX+=w0a5Dra*Jd#W&j0oA!A}sElN=K(Stp$TBqVBY{tt%5K~x
zVJR^>5&e$yY&0g=)(a3Yf5Y)>@Ng%}(gFNneBYGn<^q>ko*(H0YQ(jy!Kv9c$1w{W
zbH@A2#0-EmPDr1Nv^Si)#3tD&R62%b!yVs}#?%b(XyiiC2#pS!o8NpqSE8Jv5@08~
zGNFxT^T^g(KG+(`r-hiBKF61~R85hlGP`Mg!yhD^1)!ckzm6w&39OVHG}gTNk(_}e
zoU8af(8{!`S^46UJ@;9zSrw_!csED_V4^<Pd75o=ZCh%bW{zvs;InyHr_iolb2r8H
z+znTJ5W-qE8lbCiTC-f6^=3RN0fa~7j@2k%s|W}N@kr_wa|~Mr3HFspQdKImL0h^g
z6%K^TbfTS-m=H(sfs0ky@vCyXl!yS{0zJOJn=QWt!Qz{K$K<iblcCLlUxc|cJ)gjF
zxAzzDc9?Fg#mM@gFfebk^CQ|u1QDQLwv8W0z5MvC(o-iKy^+otRTjMyGlGeAdWl_e
z=^7fvEG@sFhC<sjo0NpI)l3o#DEX|TO(&g0kNaJ&Usbd`<^6PXm6Ilm0nXA+$~`Lz
zVO$dQQBd*4nVaoA#r){GtnSUN7#|QqnG!ZpTond%1HB@Sh0#G&;_rS3u99mwn`rds
zbUZp{<2n=@(ggC6EQvoMV<Z~QiT?>f#ijiC&CNwdbdhgp`8PnWKwqGu?>5)qzVR!{
z#3~IL$Ytmn7M^vnFG|Q1@cHK^B@v58qt}&QW?S7rK$ZbrxM^hKyvI-CGCaR+&yQUq
zNjBRjB#UPa9KqUVq%n^7$4S|lZE0I)FB<mvM|{ZtR0N%sBhnvl$gG`RIFM0x!x73d
zMeawd8iFsSELv*2RoFI($?!scs^xGri_pl`2GJfpT~9S83BWWwXLBK0P|F7c0L5pw
ztMy_jsMr}40^KUBqs8s`^=*obse*yRpzedMR!+TcSRp1|=~y_~on4uCQ4vxwuKYcU
zW!=+ds^0fO0sQ@WubV%OgSD)vGg#+rqkjs0DVZjYs17>P1N8HQyR#D3zy|$Z6<~m)
zXo|pO!!C1a^TQ1B<INVydiMc{&;shm^|f6GzmuZBL0y(Bt%2r^+uNSDBk2}ixUsYB
zp~y+>jbB;(NAqKOdF=)ji5y1Yo`Q(B7cqgs*sL;<GQs!zaL2HrN*6;I5mQUF>A)kU
z&#XE2ELrmvq>->?beW0+DaPrpm3DaWC1yRbi(jDlKbfp2lJAnR9@3uF(xw8aD4tyI
zjrkt4+^9TI`?y{n4ly(-dj6S`f%894ZZA)`1<*r*q|fp$jF$%wVzm2ME%Trz^Ajm@
zWAQ6ftpijE!s9@b*s}%yfx)BD6>S{Q7;j0tSJayskC-&BbrwZ!>9{P@t$S{=t-S-o
zSwzzxiM!hJ74v@)r7%1ik%y3E@A3Eosuuemrjg_?za=!D6?bwb{bkBL39>6=`NX;z
zr<&1(%dzred9mgs7sg|VyWc^Futz2pE-fn!iEvq3hjoqpC_>i%qiIrf3l8-+9jZkv
zcVzM~?*M)0>-mj|yU7)8VB^*biOt*2r$@q!2P9beUkeIcfu+q?BGV*_DD$<Cr?zC2
zH5nR7`ZiNK=OPNluk^G&2#vUrygJj*J{T^sD9WQ1$^RW?CEBwL3_zmQfB73OW-2H$
z=Z)tmjtB*Jf6q{a(MtZQV@}uOs0N7U6y)UGlJnFgzrm!EA<EJtUGb3B&1iCH)EQb*
zJxMXORaKQhP>t8gsHSx(u~dKdLaldtdCf#)3|mab_H)Z*W~e=?=te;8D2(MREA<-y
zZ6#sfot+vR3gd0pJYvJ1h|$KXhM^IMLTOT;)I=fEWK9@{h~4Lz87(+<>K!(s>z+cg
zg0jV@$q@!l(PpQ&l8|o_D+hpsthMdvc$m0f^Zck4SP(c^yxr8XVXfd&lg-?YGi-3%
zi+iIlLLB8OnUI=KNQq<s=K(YytNyqHMP(@CqlH;g&8*KnFFUuGUP~&L7?~rvHjEmt
z`S{-LtaWpE+=3Jy$zJ+n+I7#i3t(P%*jvQ{u7-t1Jqpp3n%j+}-A=POqTh^iAKVpA
ze}=p-y8-up!d;H*LB*-S>dED>KCQ~G>o-NLDY5Oq9}A5xHcd1xB`yg%>@PLHoTSEo
z(kj@CCYCsIjZV|%$$9BSW3G1kdH$1pM29<}m+gXw#RLhA@goC5MRkd8HS-h_?NVL#
zTCMu(T-@hYq=0!P5~;>&LePx?`Q(RBULC1aImJue;drwZhMdj*<BhaguN%HN<@LR2
zr}_KKe6x%NbcJVv1eQetGI=b3?3pV_A+-j6kVI}UIp}(G-fm3j{;Gp?QGNVJS5XO|
z%<kQHeU_cUE{MUV%gcc~Q2M%yw8iA>jwbliQ^Vw>;kZ_c6=-o};L#eeJZyi#(M24-
z*5qw>F&Y3_t~5VBw!Xdu_S0LTPFNZ^`4=#;R&)4n)6X)7KPJ<H$#<8&#`|V=adR++
zi%j@sR;AC~Su(@@5D)817{qk}<?MBx9xekl{N`a+5J-!f3`q%|dWji9OHk0b?5WNn
zniY4G@gM}E>}*N;wn}N9C91%Uwq&&_Y@>4cXq~qPcF0U!VPIf63+KFOJ8C5;h)onf
z5WbD^dsiJJe$q(FS{$@waw^GkL@4v*3!$Zvz{Oz9fhfvg%ilmJQW)?QLO6A^@qZ47
z0PA{Xva)Ook$`MlpuUSLE%MOBLHs7z(ws2^!4}#>5TC7{9h$Byud6_SjBjCQEjdVr
zP#*14&wXyBccI=vj=L?L!Jy-w+GNv-utkGy9i`#GZLRg^#k(Di^VzR7|K>FxB0kAA
zUDQj+bx41eb5XZ}<0tl@J*-nj#vXDJ7#f(RY)y4?HpZ#Hak!V;($JE#61wlz)nuNb
zSX@2w$7NA2y`RbwnBR;l-T_)fn^bnI+>*253&2D3m{*e1$VnYYo&3_kgcex1>k>vO
z1HxdFf~%m(44vG)|41591#X3hK`W@L#s}k0sRCclfdfRu@0_@_x1#X3w;ljNUI<>R
zi#k*FF9nk8P{M8(U8T`I_39`Wnoa5rL6g`$FPjit@@)6$5{6&-C5rM-Q^8?V$-q?h
zO9v+^Lli=@OBmbu8uy(|)^nfh?eyt3(#n>Om#-x&tc`TcKYuzo@D(Qm&lcjvqyFM(
zoD@lM1y60}u#A{^dR7y9R4zsTu@#h?OqPK<XU*Wb`;vmfu2@d;)M?SHL!Du0%QRs6
zYs$JZs&-%(0u%0nImSrI(B(E2wQ4WL(-mejcDX{Ga0QoFf`IP!fXH{6hDRdPc4|4k
zdKnE1A+0i~3ziD*v><OMj|)8w-AxM#aVs`8=J_(~w2Of-V@R+gjFyyP7YH*Do)%jF
zTQc-hk<@ivZxYLQ{U-U0047LJ<;LJrVGo=K-IABI>8)4ZhZHQ|9N)1^94lB)+TmNz
z-8p#uOo?2j&)nAW^_l0V<tGp#M8Hx#-0v6DJ4dW<{XDFlt$2o^F-(tfgk0n<=ay6m
zg^)8FaIc}&imfu3s5Xu$e<qQQ6n3>Ing_Y)Y^b`pJO?a?qr~uJpkO5%THSpKvU^yA
zQb>nz(=l^S1Gv*d*{|pEYmi9Vd4rn6{5TP|lv%aw7_R2)9qZLwA{_KCsYy3_FzL|U
zL!~n1S8QkFN;z(jwUANOSNj4cv<qdDsHtYF1fU)2`{+>1b-TqXXpAm6{<(1^YZ<>j
zQzuuX#IxX}-t2>tYX)XtpN$u}I?Uy|7hBBJklI`t;6w>9XgzFj$m6vJvK@7c?^6wn
zqg#$%@{tLY`7l$KWOP+cehkGY;i+*h!hyvOuEmf=Qrj2?ol&`j-0fC0V%|InV81Tx
z52Z!r$@fltF-;V&PWV^9HL0Gw<NvLf$o`t>>h{KY*aYy>SjRtJ-(<N=DOz$kP`y5=
z<vYn~E?O)BVg0O}9T{@N1ucdPqQCz#Q+~;g_977A$Bk-fcNk}$nEH&d%suwAVgW^s
ztGE$>9?vUx{pfA-S?juMd4GwN`CSVu=@EJ&Qk`!8S``9%xe#6Yb!n`Q*y4$Qy#;mq
zV}UmN52<1MPA6aHx9Gal?Q?m|i;3Pyfj;3_#|O2%0R4%em7m$H&v*{7Yibi(<mjf{
z)O>qEyTP~NY{=AaPKt4A3&Naim83C-v9VC}*YC&}Ddxgp?y)2Xj@zSeINT}l_07>u
zt(E}fOZMGWirg<NktDmva;7efPoBo;CIq$o0nrZ!7QrQ&1KVp#NYVD5ze^_)H`|Sy
zVveMo))`ZlQRWZx@V&3I^Rg(OkxyH)s8Ep6QyB#%1NV)UEbZIwc_0ql^~Ga<HKzCf
z`-rKuX`cQJ3NMbrL!W#-Z`0>{*}C-D&xQ18YEdD<YD=&Aa#fwPgnH2udLw3u9C}eM
z=qO9wz2FX06=fl+OfplqIEIP)j->_5L&7b0<@$(5+@5gOi;!dOEY}V5NP<Vx&~_=9
zen4U2yTnrTxB|7Q23m{m3m$ouNXzup;K*Vqrav%9KCY{OLB88$0zogETd$3^@cJjQ
zV8^gAMA=VSk78&v_}tCCN1JCvac9Z9s&8Egf-GJmCPZA*vZWBT6d3>gWVpz=l1hGR
zx;t<1beFqJWNL}r+5cjgSTwO06#E1-y*%vuD3Iuc9W&~~PV+nQyU`Sg{tfrD^imu`
ze9y;qLj?Ob#8pqFOH8`iyUAS_yv%&Fx7wefeQIN_-mG$E=bUnWilNN-ULfkG()oN>
z(DQhKd@gUl+?|**H}9Y`oK6J%aNlXW6GCi(<`1A0m?dg;??z0_a5W?ea7!ns%aav)
ztb1(5BC2wgMzX0EKqcp|dim3GXlw3YInS9bAg3>4hh*0j{%p<u0c|lN8oh7SIK^S%
zk{ZwZObQwAh%wS}i6w0|`Z@#W!KABL5>Dm0vHhOD7w}83*zc;T-DS0wRNL^q)pU4i
zc$rL0$IU8!%S~#>5Y73J*k*mS)UTIVDL^#GS*C*a^lATH7I*0u*JBL>Dn1PG{EUjF
z$OEtdeb;p}+y;nbFnt{BNiqy7zE~O)gN5uWnoLR*c*7D<)`wkG_O$ya)+4n<@A}4g
zF_eL@C4TtrQIZiOa=Ng5SNCimu7|Dj<F|n>^?ae*>Q3N1|BZTyd-4B#eE3pu{p;3J
zHIGDM&+JN`rGCB<uh^6Lvq%xF*~UpyH;nGs8%X^&cC^FQw|Jf_rPH4PK^{%+udrNK
zY+dBOZ_)iDU6T$&dDz4dH7}Hn5J^H?H1aw+dH-#x!CZOuuE)WQWNFBQmGL*5-g%<4
z*=2l>sVoJ_ysq2O&V*u{`5S#fj?+IrfRqn_(9Iix6`z}Iy9>&CM*uVmVD@x!?@ZKA
zYnFWQYF==VtWcVGE{^5gCl+fBBBbQ;t+~z{?bjr&Gb`Uee;63Zs<^Xv0|4n?J>gk(
zGtTt^jdk+k+zi#(EoFB!q^m&O97VXP`3{?h=~40{e^s#=z8B$v7=3QDSx*6)8CuF|
zZj)_4#-5RFMU75S!%#Mne#Jjb+ms}u<IKcclUcN89k^u=zGEL-JDjUr3*Q=PrX%Mt
zB<|tej@a&b>+EG7rWAnQ+V<VC{ms;mzdFO54yC>kse@tY*lO4mY(J@FK6vp&e!#_+
zjnDFW5U|lDv)TeIcid4=Op+DvwX0rn7v_Y^Lko`NyMkdmKR9MOyIp=rtR$FOTZ%7<
zQAEvI<YYu32~Bv$+}Teo86lMJl&n{co&x8<oIc8_&2#(2<hfPE``wz6HFae#ifvLi
zoCX}4cA!9#y6;K+W7ZU-F&D2+OB22VHEzdvbPJM21w4vbWX&(EOMEIxfGp09dc1&Z
zj>wQlC$pH#l07<KYJM2!6*>!LN2v4&R(vsdId0S-;LmN{uIl1(3&>^pcLXhJ;IENc
z-EOK?QMB?!L{Zrzs0jw3N;FU(^JVIXFDVNM!2Lk><?lYHwbO+ycT$rifA;{?sRv>&
zdBy*Z5@wWFf@p{6P>&96tCIjMH%9e{lV~pCB${QR@kVeObmo7x?cLED`C=K^<(FtZ
z-pgn6BNvLvh4Q!LFF5(e@i(}E4l?VA&1v<b!*R{6G78zHmvq<f()2v9Bs%l}bYL?Y
zMw;Xam~x}G9R?Z;y6aC>QjpgdL4Zt5W6r{B-huDb?qKm^4Vv_7&a?x>aiPe&4^5r)
zSk)d3s-o4(s|Et6TKqRZQHL&5d?fJnY4iFWIiz+fh-I_$=xAP$ceM^gn*ylGB6qCS
z>)DFVc$+8JAPByCY3sAmU4MDL``Od9XY06!@I@RtYeWaFERR}WUv8CE(%Jd0j(85+
z3KK$fbbP#sRxeTyy|quQ*hz?*aeBwOH}?B)6z3xV$2I}dK7b+M9mkhk*<Gk;%Sm_a
z^P@Ks#M*HranD_mXb?K@5cE_9nWWYimhq3<MerX4thL45*f8#o){=0Vo!i#scx}5R
z^(^NrISxWUHQGq@U>Iw#7B!e(FPgV0<-CDN?E+~D>$uBkFFYdAwuMFI>_(e-MzVb~
zjK2l9N@-q0A1+^_TsB1`8MS5HP(`)3->J=5tiT^W2MG^_f!_&{^GE5YUwse~i0Rx7
zV(41y9u&4*^@;#xDS-WQdTUu!CqbCxZa-lK<K{avjh=x*1W>Kwj+z4K!oVd1B?7Ix
z{&_l;KSMgzr`Cqs6T}4p`*KfsrV}V6Pjcn4SZn5MMY@*1Kx9?jPnBP|)B~31dvjo6
z68HwVggJ5-N?pe}`3nT>??z}1l>c9dm#b%x7qeB0CXPZ*FO;cB>-PZ1-}Vo~Cpb8e
z7*>wwy=*=F1F8`@ueEG(h5}z>BHM*NadmY9!x1K}PxD(o(hRNB>4Vkk(KW%-%rC?L
zv*?-W{;f!H3h-+w$^TMQ{>7}BZYsdTZtG3DXMbFLvt@NUqY^lm3gmTJd1LazZc1w-
zt-46BhD~3-EPEp<KkoZy9)VmDN1^p9?l9-)PI1o9BlGZ~St|HXXUe_R!xsMTs++02
zqO6Hg5~l#9G-I0Ssf&(B5b*J=T4Nn*--3)|<l(zv*j1*2>%PbnXT`1l9TjI3j2Cf+
zVi<9w%c~x}6x{fFO2>c4)IR~D?g35@NfL!Lks&NPJGD<yuoB&J<l2$9Wd;2Jc5OS8
zTn^h713%nC9ZUAM)|e<dUX}WU(!Sy3R_S!SSq9WSL?nZN?#J@_-Ppg!`m_!9BGnM}
zk{i+aa{qiUS6=gC2daM$pE}3ZrPc!E$7lg$0W~%aDe68an-h%y3`j=W7JJO+9OdG3
zxpJ<XhDOXC)uP}TmI!QfQF>wd@gP>Cq^N;qX#oxmF3$#>f$lT+$BT__mEr;g^Y5QC
z)%(%g*|8#4>*4RYvvQqoxw4KJX#@!=yGz^1BJI<U6~J{QlDh!^ePzl43z2;b5oV6?
zw>3>2O+fq!$m(WXSYQ@qgd6Ltu_8!C$+s75kp@*?73k;osU0xBEj<bBMu^R&qJAtV
z{zVC>$pEV@yEiImN>T=aURihi$)Pz%_cwYb&{{xJm><fnj?visa9_=t@;g7i$6hvy
zN?FH|IV-R6SCH4Bimq9lo2}0Jyu)f8JEKlB5X%*}_#JkRD`lK_hPr8eylW+lkpH#Y
zK&A7~#@yW$rl4xVesr^hL@K`0>*ga@5x=okh0+t9fBrO64|HA7>%O*6asHgk5Zk9~
z73LuX9~btLR#e@47w<;bJAYJI>`+;EMTrX7Mq-FQEwW=lQizhH?$pLi$|kQiiuC}7
z^Lk}JuD@*Q;w8yurm9YAOW5m(+`5oOTFfMS=Gm(e`8ny3ivl1HhR(-~b@OeHmCf6I
z;l4jEqK{0RTDpWt*t8%1l>cF)EU}X@8!?~!$c%Y0VyTP0`SRw%F1!dqvNc5bHE~?E
z5J@XoYWXb!4PW^YwUrdG&ffopdX)i4?<55uJMj5??N(_`3UU}WY(J7AMae4=kw>v+
za?e`nqPF|9ZS+z0HqUXl&{YNMMSxtwkS`=~UU>Z{M+EYP$Ejp52h^>YPK8Bl>K~bz
z%R1-I_O~BE*OoGDV9096%BT_zo-guf^eic1sj=ke^CIreI-IiZHmvxTocgU0QfUlE
z{nQRqyb@G?{;?caZZTswFjIETe(D?TY8pX21PA-Q@b$(bNqTJ5=z&ldI?uKmxLoZ-
zW%7f1Cp4W-M%qFF#^1*jD1~&^X*}K&P#8Af^L_i`CK5_5^I$yeg3^Rgb9{B{)GZ*6
za!u`0lc@k(`1)#tnZheo16T%Jj=(OZ8nmFo_kN`LGu_keNTKx=PxIG<(`A@u@DD+L
zTV;?_+`YRMB6$0d$q3maqPq|_$Fm(6y~iOZQIv=9e^pxjwZ+HY<up$$yBpjcKhOCk
zS<aQ4;RU{p(fceL^ZII2%=?-<{%>fg|7xI&I&Kqe$=8=bGk2R#@IA1RmirbLn;Ro$
z_ER$wsQz236Ot$Psag!#41f6&-YYc#G*T&IfM?kbi9m8pN-TMs9Ue&4C0_74f<98n
zXZ77)uF2kfSaIyagh)^4M;p+0INHd>Avzt+`4P&rWZv!*hG?Jf4Uz0#mWaJk=S@8J
zyJdC#iDjrTVC$apd+>kk1#TB!f88`VKzGTK+OfI-*oTjFk!-p9l}y*b?%}RovkHc@
zee42=^hR8FqP?6!_b?H~Bsqv`oB4t<p1U*iLI^Y&2_(P2Zn04br2*FqH##DVS%>Hr
zXg0~&ep2+kQb6!bSugyk3%*rn@yB!nC*x+zN51?a84pNKXn|O#Z0ZsX)8#^!aN3ID
z?IjcWr%B@64`o-HK5u%3#4e5J-up40&JE;8HhFf2%LcZAYxSFbN{$w$u!-<hE;TP;
z3&@$I_7gyw8r+cP&V<5k@@ie&P70r`jQ(5#9j*p^w+^_ZR!oIfWjAzJ%X(fVkFjMl
zu9!<xMByc*ei?`ipkR?&nmw^wCvtkE06D%C>0Sp#Q8AA~SL+s#b%i!rC}1jp0)(BZ
zPcH39)U!ZI?y{428YzLr^1ofP2ED}j5Rbx6nJEv%qVg_m>mY}E7;QhX5O*sf5v}t}
z`n_UONaqr|-=b=~>A^})23Ddxjz#8x4{uq&fo)T!f8T66Gt;VaBcMs&yR1A~?G!v>
zFq`bQKd=FS$+>Esm&F3V`$u(En^jS|s9s72Gi05P^H7K9)oXXsfG6QU0H#CqlwXF$
zIRPe}%+3Dm(78rQ#QR#;8cz<Z0*D%V^kkg|Gn=80cp*oneLV6@u-cZjIo9#&-rd~=
zg>*X|oGk(d<kl`U@j69+rd=6T(WthmLglZ`^DVnlXbrl2+SIYe^93RvGPgu*MOhvM
zqaztS@jhKUj#8r&|MbeLGqFa#dLgr>7)<S5FSEv0?tMBEJze~&vbk_dw9njyVj0@Y
zp~eV!;y^yBsLTE1#tItr&|T-9@rg`(p=di<1H@C&MEO{YX@iZrL)Uf2`(+_P$mdGz
zyLfwCG}#f8t1{Df$5E#%P^GrmCVRHsx|f5J<AX`(sXkS%nv8TRrGO(kOg7*AM$Oci
z{6+!n48X9yrgMZ${WBv&7MKoL5i|-hqxXmh_awIDUcOa{NjvVnxeFJiRz<pp!}jmP
z?|BaDz_Z4cF$q6dw`*Pv;SYo@`ihJBwrnTA+58K5QE?@ETR`NSN`M4_%gdAjW6j*;
z7q(ru#Vp@075fbA^&unOeUB?C?KX>BJY1RIWM{#(rd9{<ZWC^U-}EwcWZ8Ae0QaU{
zy+a_@;Q1gS&pMr1OK6k-UZOU{at>h93CzUDR2*;b4qP{m<37=hcz<jd1t9}OXvmi2
z-E>l-v2bJoXeFx1WQ?Rdys<s1S4&pj=^p}v&isU=+;(9!^T<4XY$BUTG^<}BR!9a4
zr1z;s55D65W(bjmdIybe#kj}9qXQT&{$-aC%?{iQWGAwPQFkpPz&>;6651S+8Esw@
zIe^~=I-Z<nfIG}O8zw|2G77WHwsXRinb{D`V`qXMQC;B+6}{;-pz^#rPWnb*wbT?P
zZS}nJnK}REGfA{>w<;-Ga|hLcmH6jKu{R=(DdYZhOx?zzz@h<aO&Jvd81RtglVw0=
zp|se_(bkBfG^(Ktzm=$|wL1H?a08qB^qY)xPjwI06R$x>0+Plbtd>CZa;r|#X5CSu
zzzrUaSo9W4nWhBiAMX6HGbT9TJH(CRHAtNF$b#8O;N7(;>7W>Xi~+RQXTn)Qt2x5C
z$W*}Mk28cm5l9hEd$O(O;9Rq@^Cu)C13-bPc``^eocfiw%PS|x4unqGlyl1g;oIE!
zL_Je}^Itp8O_#ZMmMKzL>aGmQC|o@X_IYYSg3_Ld50IA}S12Wsem=h}nD~R&V87ps
z{5Nbq<y*ES>AA&ajdcRiK#+%8JinHtswcpllUOAt^VYp{(^H^(%^6Gw{;<;8&zvg5
zJEfrL9&xkj4WLCx<JNVGlZugSiv}XQINqV3a-XbK)wvR{&gV{kH>>UcT88wrtxOhK
zwRI{n(rGDp9kg@|Gb~9rL2Pq+Um?J*IwK}^v_ECiBO2Q1g1cS!FJ-;@rBwf!ERRK-
z3~o1m^R6{EIGF8|ZZAdu9B`#_f1=Z=0>=3U3k_!h{3-nELn%wjv@!lsyB&_S;y$!5
zq{6th#V|P3G<ThDT%1i@;bJ$`h2Qvj9(y%kZ7OYdQhtPb1I&(ACWB3^S~`qlFAY|^
zW#nn=2gEicZ&xyYF9zH@-xRQ;OP7^I1fu0fInowv?#rCE17`6HW77d68kqFHznQwn
zo2_dFToA>`C0<I<b7czv?v;TkaB)R{<dqKzX8_FzwdU;Gim)upv{N@UZ03I{hq2k|
zjZ|pPz+~^&{+8qzdkJg&xx!@`F<M6ZOmYxt98e3Am;pLM^E}}|^%0OH6o{sD1Comc
zV+nC-0~$7@p{MP>cT-0(yo#sbR*`oek?Fekg_h5>ffYrn+9=afsHi97nvd?c+e`I<
z$1RcI0MN4jm&+$Z>)8%poLpUUm4P8=Us*ND=#cl|(<1a}D%TWcVo4!MKYfKDd>cP*
zn1x9?{@oz)v9bDdQQ!NBB*(l19+@@o965!x)w+=_>sTbaQImy5x8mkgcaN8*+Mck8
zGW5OZR~i$Ly1k$-KE&R4mEja*mwb25pyQgI);@*G;km6MmVPVf&yf1Xb&N&B5+r;4
zpKvTIR3x2pgUv_NIsNAP%&rlL^BB9iJ!#}Z(!!q``FgY9V&Akisc-9_PKVgVpT4LQ
zrYu+Pn;7|+0vQABD%GQJDBAmn7M!2e?utxxNgzQOccMbsOTw@H&=$vJB)A?2o&Z6?
z$r;k}<W760@-1a0Q{F1-LgX^a0V`=D3hO(ynTd4=j!sOS#C34xUbdXE+^LeaU_-VB
zMu}vneZamhWwi8X{>;xDz4lGmkr@>S&%O4#=2t?%*c4>*k#`9E#lH8RHVb@zjdBcA
z!^kE-V@m(E)peKv(;kAs7ytQ%{-8O-Jd}j+#et+Q&)rmueKOI{N?%zo;1)|`?#@^;
zP*AY*Fw>CVFrh>LOvRM6x$IM6!P=Z&oDf1A0`jFBwT0}-Q^c|wkky;edmk0Bq#_R`
zgrNVtA)*tb>e1DAB-mDNs)x#)RGB&NunH@Yv7$W%b%p-8{xKMvrc$THm+4nS!GF`0
zgT!P~_LXISx72WMGhbWY&29;ZCST2)MvDK-$-yU0(}L2`Eq>4XwxNlBq>mQ~N()EI
z(bvQv<%;^n9h)g)wNAMHrnK{)<`x4>(;Q(u6EC}iSAmONF6Dn`6DyAoxn0c_BdHhc
zY;><GQTvw#fj(~J*kQ&Aoe0j)9asOD8B!SoAD*(X0kXZ*Mb9}YF+2_?kbNi(rPz(N
zQ7wdgYTo=>=6RO>2M3DJHu8}<xAmGd=p!aUpA1gH6VvlLG{B^Ql7YJ8PWbvx6m(*C
z3w-UCL~Rb9!gQvEx>d4Mq)AqmRIol409dI3yRXv*&yD+<pzECcxG}&3z~X0~ljwW`
z$W0(&U8MHO$PxLQ@Pl8*%{Z-I%XyadEXT(pX-}pT9t-{cN)n|dTk7TxOrI6GfI(Ll
z;LrIy-hXqsK6SDd1HmotzFDFG@YHzE%&nXEZ|H^Pm`7etaP5-X1td{jZmQrP+IMIb
z-j&Td?%Gu>^Ur9i9*WsmLi!#Mxdh6&rG<8hN)!l1OnO}VReKkOXda8oxn?8+11|Lz
z`Pe~Tf+C#VLrFTf4h5h;)i#?zIVE?;+iRZH{l_&mtNYc-{2yoG3eX?bC#6;}2Bfv}
zCsq;k1zD*Zv2e0|DyB2Fm#ovrBP!r~4Q1Q8C<gBd57aB@XQ2<2@_i;)OO2k{3LGQw
zy-wq5q3VwYeVp*2S4bs^U0f&d<LM!EjU8LXnL=6g+0ci+Ki9Inv{B(K7HQ5f*TpdT
zpHiSRz$e%k#cR`^{HN-UCz3amzDosd6W&jQ&;H)0;?6B$UG4!1cWX9~Y%FLn)Yd%J
zrfvfg`aLgbFZO?9SqB<w7HU(!2%G9AFI@QxXq~bzIw|r<fIw$xXSZSuiTmkWgJNlu
znCpo3&gr4VM>n9kiW<sJ$^Q7>59;KW@`i?xSTT1lmi$)&pu0sCc8<~m4WaHB3d%}S
zFTB8H#{6cK#?lKq9PCJ@D{1#n@`brW2Jp!cLaG5vFOoYqKrHfeWT(+n^`A5HW&D)a
z&f(zyL)u#gwHdZ+yFe*WMO)n6i(8PEq6LDx6!%b^;FLm(yF>8eP+WqR;_fcRHNjo>
z)3xT^d*+*2Klb{5WTrEe@aTPCa$d)|zQzXI57Te-jt!t)+=~uKTWwT%Q9TlD%{Z6M
z2~TueIR`jabBeF?lKp0%$qba9omnq7h9UJd3=_^l2;5hrFiPX*IP>rnt;|Lw$!eSD
zc}b(jE|&D;b!N|R;b@s>v;KzPP_P9D=U$}uG9B1m05%KXU%no@Z@+!Z8R>RGO+xAy
zo-6x((t+a!?$9Pm3V}lmv*cGAJO(o<lb8p2n!L|)dm2!!<B+VL;iIlSMlJ;gmH-zI
z>ae*+?KueW9DTI3VhP_r>`o+Aeot*QJ1`j%Pv)G9-0+?lhP9|%GeZ_ij$->Gjtko(
zNz!ZfR{@&T6CcQ;j{g$HtPT@%W#<z=x^#*ZwbSp;SSq3R4=*y8t1Tso8fc0*R%~;Q
z#Z+_0agTWchN?@`I%kvG!^`XQPVD-gouDjP$Wdb+BhFdJ>+s-*3&hf%NNcJkUy(ca
z$d{<p?F(E-$1je>r}b8#57o~|qHHRVFCT7}y&Six-J;w3mKo)eHUm|!LB7u0V>>`J
zgMV(SwlW3GiO;H2Im4Am%f((`W{KY!yW@O0wqq02I!o*t)>mNQDwImwiCM-SiRiXU
z`<KA0h)+ScWTM8|7n0rW%X%PQ3D9zbsNwa0Q#Fw?*+!5&{JJ-OkN5T|u2gv`yrF<h
zTLyPk(evTXoLwGP$NGy)mM7-y;3?w%b|sQ|;D@&{555;F@u2?S=~cmU+WrOlPdNoq
zzh$XBbx$qrw4{0W>gdKiCh-;7RB<cE_&*%{^VJwS3hL|F9B}uvBkj(c`RRa8!_W!&
zR=5*!I<nYBa0yQ~l7u_|pa{Dh$ve^yhXHEdS-A7IaTeS1+Xdmb!oM5lEwlTil>zdg
z%3XR_OBmt0ie1=@s?oC~aT6RE;}iUh6{T?c)>}mYfxD&z|HxIEs(-z-`BY=S0K^-7
z94OaYEEB1Zl|BSZ{*)hScmMFuv;*zNmrNKPhZ@7dEAHLS)yaUGXpW8<eY)j8=MfT<
zRBtxA>h-VedTCx7Q5?f-jT*Q^9LVv8t;RVIjm8D^k=ljz{-Zc)5$}J5nCAO_Q_&v(
z(dCGkZX9|6*2eBrpPok(B_o}4#wEQrF+{0<x{6E{`F-(0YuwaZkC&hT@$_}T9BM)j
z?xxc~>d*ZBwH<OfLNexcV9sBUfJ<X<E5-$^n0+Fdca%<0T?)UNeFb4m!oWBohRyvo
zzF#+fk4P)qR1VK@^#{c<)1{21_?PL^O8>;@L;5n9mW(g8^|#e-TW<|0f?fh<$N4VU
zB%Qx~$<NkF25RhEIuZyK#p#4lzhF~@Q2%Ya8wdzk>`cd#5p_H6laHsDMe*x(JV^g0
zNg)!D{Aaek<8EsRb4#@d2xSTE@}Gxn^A9**`~IWZ&Nlt5fJJ8*JiGaf=Mqy}($c4O
zp<S@dT=ELxZc6~7DG_yD0YVb890S;PqSyL?>Vebb4CmP?E>(e*e@YFbY*IpS_{w?R
zSVIZsv~HA<_{~-^po`o<_h(ZaeQ~B=*Yeco>UIVB8jTas2tros7&h?%k#ByZZEQ(e
zLP^@5(2(=~d(EazCqXw2jB@S~_V1H}%x`?;EQdvAE`F9fp?2HJDD-)aGQGXm|J%Yr
zYpX>(^3^5{=zqr0qTGMb1xk~4dU|yiK3DH3TBZfDlieL7A_vbM$(N+8>M6UY%H@2@
ztw4KoP1a=e1Q?_Ym1Vs6<IPWL<Jx+0p9-iHC7;blz6aFur5ji{2Vh*=;KQ9a@NCLj
zDk{(L&!uS;xvA@xpzR(?&fpqTkvD*|)h~dmS)_Aj6}@vYX87@)gX%|&pD%fr@@P?l
zlj}-{W=l+EsI@Mf%y|N3=4b&dVR`Dudzr{|>~Ok0f#*`g=1BoS{gmfR*5*AwM1M}i
z*<zm8ct@5ZhkXHq{hxOTDHTj)68DuM&PYW2A@|58`{D(FuH8{|)x<<AuO@O${2S$3
zLtpY*gof#Q(Z031|L2nP_6Nl5CswU<;SuARr&nU#j|{lb8vq+533sb{7w8Rl0^qh|
zDoLDv0|d{ah&cc1zvFXd<b9~2m5j^Y<Dky{O@E=vbM}3QYwwC99In#ej*-H#YBDeU
zOvc@^7FZ#cbi9{G62LzF1Vih>72>}7;9seZ$FeJz;5B>nIBu1@xV;XPqkn=nj?#UM
zdO}V^B8&tg{UgBu&P*{;auSyL?oYr_dC>tD70Km}e`*y#5|Ee{MSLLvfL|G0jQ-V@
z1y6F@7RDrbhOsU_Gk*O5fQ_+JjS<!GD!I}klLjkBGLKLa+@vXyxe-NScgJavz_a|D
z@{n#?wxvqKCF_~F-$AFpugk69>{nQhOyi@pPxj%0_6)_j&*w*Qfd=5DUwJJIYof0F
zeAQ(if$ncgdBcjQ)P$aBvW*%y8dsTyBhpOkoTP|w2cK!bm1_e^(zr^9*)T-Sqr&Op
z#bpfmg;W%-yz7MN6cjSaok33xj11DLgDU2_rC?GfLLSiB|F8h&aN@5@^a^Vz*PbI0
zbxm%|G~4B0XEnA6i%LS8IgRkTctb&90%HMBVpI~0TM^YuQP2f4)Wrvv+YTSf`|@Ca
zz)qk-iNvz12>=+p-(<>u0N7^{B;RrhEl|VQ3lx7R6MxUD>g)RW-v^r0gT?56AmzR%
zZt9pMrQ=09m;Wh@eHLDZC))JG1zF$HDL*$&Dl=5IdD`FTq6#>PL@e+0TR;!{o1%=j
zvL(k7hX!$fxEQ!(^X(HOM9tPrd&<#+@5jn5puEE$xEIb-CY$jkIDc?l|Agv$l$MB_
zChYZ~0OQT51d^t}miefI51Pp*za-Us)Ehh?0XmaAa~Oh(*+OI})Lw){nQmDxyMHVn
zU8*#HU*g#EWb>HEE%>Wp4LSpctU3^aQNLNT@aJDRI1<VjbgFI4vh;O7ZH`ZslsFR<
z^JJSZS&t5|&fTfB0&5HyO@01@sIXy|<2)Qb+ylBp885YuTxe~7))!xk$n8_=03H@n
z5Py1igRYHJAs}OJysUWi{1TnOv?Zvlu47l%6YhaPnU_}j<D3R~GffGi&Wc3h)&vwT
zxAwhWl}G{j>p_0d&0RGS*{9bIOP<LrdX`gK(#UuX%FBOr>B8mPoMQ{C=4Hds8H)wU
zFWa+~0}*pMvPo}xTEp7@?eVE1ls^yz;w84QPyU_mD-j|We^EZCqbLjvMvB+*pxim_
zPfr20*nVU@JIoe`Vn_v4?**7Qm|4Nnf|PENArxuZJwS|bNGZB*pG}6!vWk@E0%!r%
z0eJPZXf|<5D9t2#Rr7s4R^2kI?)#4Q)%BS|k<MBHhb)7in-FN6hjc9I8H=6=UO;vb
zbjZ(668<FWXC^aA6i#_qcgPQG8JmxCXF~$pB(7-h96IX80de}+j_FSdXO}ksxqfV8
zqLSiY;uh&TW~y#_F&BslHX(jTVT#KV64lLZafc&n;Xe_eSAN%#xG^zt`MmaSs>C8<
zML(sl=gWv8;P4GposGI6jUypTY)65fVmC|_n}<L;p&C~Dl!DX(SfX1O+H<60V%qcw
zaVZaFBUa@%3Vv<_onQ!<_f`)i@VkB=G-EG5W{{97*}k;&61shLT=W6E)buj78FT(_
zIRCPyO3agH<H<Uff5$e!R++3K1?#3Q?q4FskKNFJ4U9vy>bNeo%0l;l6c1jvFY$j%
zFpYfQm;#_qn$LC?O4efoq@r3y)s4i?{4A1`h94g;<APWU6ejvI7OuTdmui#p_?ylf
zM&wv{`fY(n3UEB=wg1X0NkmLl|M>&P*{4DFAxQkurySzj8rtk8WlMTk+BXHB8GzWc
z-6;6`7k=)2OZ)qRANUeHEe7S&G@gu^j8?GyKvf?oAS#^j@M+=E$KQv!p%7lNHia;#
z{nuy!gO_asM2ixb;xrBqH7s(5!A-i>Iv~R}ff*IgmJ{Q@V6>we16}RF1%O9Uyn#ja
zU$zbS$BU5T#pd_fPzc3`!&Xku(o70Qd)UG>E?GUEgDtDxJO=~#f*;97(?A*MD6pjI
zG5*%8L!iihW2KUIew>dPdq)3h9l0xe*&tKJgn(Ps$}NDbFg|;JE4JMXw<Wq;lWL}@
zA7t{I5YwAwh*g}B*2?v6;}`qHOK~nw&Kr6BgM2r69<ZSJJ$gy!Y13lq(2QGA5sJ&h
z*O=TJO&jU3)CN3CIsevBUgxcTJW&1~P4iA=N-K#*Svi>?FoXBDzul47I~;FTjE|Gr
zt3y28F2oKaLOr1m=oNFn3(tN9l=l?kwNB@?w#1O8q+3K!$m`1i&dA=J$PHDPFVNNQ
zUwLvVB-gftgn2;l<j)Q80g<aqkD*IJN_7*IV@&<<>_Dfo{i&Ny#y0J$Z`zNK3u5Fd
zccL%F!;B&xbpcI~-58gzz)g_1{}@az9X|GTsD&Z296x9TZeAPsP@S=|dX7MYYC<nz
z5w9*kMsa*Ne|ReznMC2^<*W~gj>hW0?+wTt(c!10USmZ5)i{5CUR!RY_O2`}A0+m*
z`eeR#z{EV(x8ZdA;mRvH-j!`8mQ2b3mOA-MDvSm;a$f*G&A^P^<C<yj6GZz`CVvKi
z;@-RR${a7=K!H}Vt)!&bL?F?4rm*YO-I>^O>pfHS`u!lvtmxdJOpF(DB?>d5!3Tcl
zKA?r%xHSR988jMTu`!Q(UPJH*-HgdTq|b48ylf+!&ya8BHN2n231+n@U3KlOr8%Vw
zhEIDYvZYXxqL-4Imr30N;LT;g;>u4sSm>1#-)r>$rp;{*{MdE_sKRG8Ta98&wLHLV
zhOcL-Eo@;JcLJs<WD#>{txc$V0touGd1lJ=NN$&cDa+q`FTX7VbR*B=Pn@07UUyan
z4FU>)*DrINUPMuKMv!9TWqwGDqHK%xaM&Gx`b3J5Sov$cwXxgvNxjJ-D=9AH@un*m
zE>MahurGN{!WjC?UcXnfPEjW3mx$X`G5y8JyK(h{4*`@4=^cOQTG=7-R?gra&wta|
zpQ5BZgMQ$<eK0l~K)DcIaURR%R6QKL+!;I7?wn_S(i34|Z`rTC{&@X__VRo`iE)Xf
z>0(3f?19aNDpy0!c7`KD%BBezfI!||pDfhAwSN)%IZeEPIS89#k)Y(JH|CUfZcGLw
zfN?A9`(s<_^@u?|2PFOC%JJ-;r0;X8F?L6LS7amrNA`B;OjCLPMnUf@6R?wlyiMcY
z9x8gR;$pu3)AqOp^ZIYY5_6|qZulYd{97%KLXv<tz7C99uqxzkvoJ6a(=hBgdA2hV
zxE>FzSYo2;4iuMZ2Z#n$<V63}7Rmd~A?g($cV`A{zOpZy6?H?I!1(N(Ghu^)q~|He
z#n^P16TmaIi9{)XQocZWQGE*N@qqG@ml3Gm5b%k#+@IzPRQe!udVhKFN3dbT$LU~J
z9eXKaBvaAZ8-I}-SlnAO_btwV%ID^|FA&cM18bbr`uVsAPYc164dySiSKBw|CpDx~
zsXm(jDxV-yWD~NfDWtBixVgf%B95^D3{3mAbYf~ZoU)Y9J!{FcrQF&ZIJkoXk|zL6
z*un{0U<Zc#Zh?n3YjPNr)8n~YIShq}$S8Q}(#!Zi_i;Sk>P)643;WhO_J##ir>vs&
z&ag$e^~g#qn97nh`M?Vy6xX9yzlKXST^d3<*JLhzO-fBj%Oa2=<Sfefbs_kb<9bC=
zkqG3t^1-l84D!bjz)^lUq%Ot{wh33GH22N!X9T>;n#D+Z+DG~GBm#V{Pj;-rx8Y&o
z<uQ6O#s|JgfU<<MjtO-Q0m$Ga{}$LNitl4Xt!pQl#bI#!T$yDGNzqmnHZx1&PIFp5
zX9V7>nTKG!XMi<^R2f=(#O&>~-fnj?lgYB5Uz+=^0r6lyE;95X#SsVsDrxNg3iofE
z^oY1qyb`4#9$$`yLH*&f@6-!_zF2GIL)FP5IbQ4ol&7VlNYlvldhLzZ`0>s=&j8fe
zBukH9eTMyw&*A)%w)3KucV(LCjWOx<D0&ihvc+GzqvIYClVOuB!|^e`*G_~l;`%3D
zUtLEy+A!*AR#x1mtF0ummtg3O1!zR%?W{T8dvayGzVCSblt@5R=MQ=F<V!(ZQR$3>
z$hMu~tKn|uCvcA+6ls*0S{2>b>vi@qF}A1ROD{BxV>hRWzC*9u%QkZ7tvY1mHZ}z)
zLTdG+SoO9h<iYXI&9$aPtLMoFy4pT|-VNXJVYGj4F}TV7-5W_phOdMe>40J&0}1#)
z#X!VW7~(3U<^G~yyW4pi@`ns+Dj;&wnc+aUo8fIFbqbK7_J$aN@?)v|x{Bg?W_G9X
zvK1cuTs>saVXsf5sp**I-#h}SX1}eX7S;giCLfW)tpJ?0Fi*4COS?AnCGy{VDxYvT
zu;|7fGsO^mwTuU3SoS<45xOb9KcT?LsX-&HXSioEi>T5XNZ<odi5j!ZGC17(XnTZG
zMLSZh>~TaD^Z6t#>bE<=ShD_8wn2-{eq$+)4`mMV0;g`}Xe<0De9&&FLg@6CZ=vEX
zPU?TTI%scXz#?BfFdzjZi4^CR$ZD`V*J*ZhqueflPP$iAQ0TuZ5Fn(BkP02?ZO%Eq
zqA>ub=z6D>MhVv&<W1l^bJeGF+AIF%meKB-2ae^`fOE_+HepzaR+tax$0#8b#zkN<
zUnWYB{e~%QCm1j;JzMNrDk}PWXa-k^vXi{%V}yTrxB|wzJilWjU)J@9`*Gq0Z-lpP
zkUVcb9sc<xYz*|7$S;k*i;(ZMKfVz=%8_<~kvOeA6L8howBL}`v%Ah*>9y*$F^{t^
z9DqE5{7K9?AAh@Yku~UQ{yR<JJ2~p26(CCsA5H-*vUacvVZbW01UN~2UkWP8sp7nQ
z1cYfpo?ii!-SjQMeh7+mZXL-ix?Y5KYz>wCn^f-&3Pkd+z*UGm;NBKJk+qVM(H{^0
zJVPNK5vcrSg-m@i;!c}%JuM~X{*b8QHdF5U{&S=NrjB;68{sER0Z}EOI)_t&eLqv8
zHKz2OLgP=Be;~Qwx1CWyK@+;!chk|}j{z)}p9<aYfIt6TNm$3+rD6tOR2tr{p5MdJ
zt+vGd%YhV#3uUL$kbu2ON4e0LJGPAdj4Z=pNG~12n~vQfVV}eA8|T6bWY6N>66mp3
zer6OKahW037aA&vWH@a&G`+W)tFmHLznl~NImi7wg7orxPQvYp<McQX&5(F~BlTx-
z<Jtah1;We<hJ<ZT_c$*hGd^X$ay8DjNgEZp=5N3E1;(Aj^lQCyj&H1*b-`vy(j&G7
zjNtym>A*WRV3l1eFLfUCcq=@#G@%RrX1_4)xtPU)Ue;SBCHWR6E<V1AO9bHUS8@p1
zzA$*Qp=d_vbU7~!IrEK_IsS6bVi_~_IhzfFLNJ5#wD3>anOcfd!WA6Qt$^G3Shb7*
z&>qPGd}G|=cVA@KzJ?h10$Xi%0CDhaYd-`I+QxE+kX~oRYiqmYx&nj4^x-tp#Q3PL
zj}KNQ?t09b>IIE%$mKW+X&Q#gA<e|Evm2j87+T^QEt0tYIShPvc0>R2s{O}>ypTxB
zQ^+le^u+~y?s9Q^zD-f=R`+gkgURjBmm&Tg8WU;V+gKY5{ibeAQi1Yh#}_?0#}7M1
zm=Qe3H4}@C&cA!(J_a6NI}fN4O7r<WoOUb&wlGQtIQqXnD_O1X3)6gV*Pf2feJt~`
zJrX8LUTk|bI}$;DJe!q~J)7+@COi9)b$`9>CArQ)W8Yb@i0<&`{pk6yx$)g_#$R&x
zCiy6ZSp#S|vJ0_9sxQm%;I41DJJ6}aIaK%CEzh8Pupkpb5i6iTzS@6z^WTOV#zLaj
zcd3?5N+sczWa3|NOpVO|(^l%Jcif2%W&~#ML_CQ%<I-O$h*U)qfoGBL05k??tCdH=
zeqm>|)r&h^8H%gVx*zymXho|f%-YhJ_fL$|!xTxqBU{5{wxC-~Fx%)tH-eGFbpgO>
z&60O@6lmtpYfta)HUvr@Sp3F*S#pT}UoIyd0t2nW*W1m=cToy{4jz47VFISaUwHo{
zzk4QfHCAr0--+Z`x~(&|D~%nb?7CV{U_GvE=h@W@A9AeuSw@s$nkV<Waaikdm8FNP
zkTdP!Zu?1gH3e>py`l9CCU$V9!#sf$a{FN{SIw=iL&)jfIq|Z1!|@0{tlD8^p#^YP
z_yaL$z(G#TDn?P3Ph_y>ZfFFQ9&+$fmn3agKu2u%ea6<Wc4D}=?%2ayMJ)#Nwz-6E
zdKk=BukgqHLMSFGnVr5PtyKLiryS3AHfIk35<P$hIj`)kWq9JuPuBZ*R^am&VLvDo
z`ZMq1yn=q_+i@d#&9`O%!(ZNx>tuLUzH=&e?*a~&`K-Mjr!T3oQNx0YHNL{mQJBB!
zybvCFc5&DsDcF6D@I>33eHGo<BKO&CZ?fi^m_mp4Yt(xC7C>txjtTrCXdcl|M?+}T
zEJ)`6dvQc0v>R{+fpfw{#9;g7rdgNAWAJ2<SU}vJ^n1^8hBKvIa2Uc0kl?DEEAWbm
zkrW`uuXtt@<ws1NUQ!y&<&**;)xJz;8F?!W31xTQK|<bfoJP{LCyh{py{)LA`a*~+
z$=Ul01m%|4X(G1xBE&bi2kxHh9=6nb4KzVe3)}61P~b1nDtk+G#Xh8~o|In;^LV$&
zVk-*x_r$eTpnnR-ZqK==;9P1ks)o;OZ0QctY_~n$ib!H#0Rm*}ozzDE>}vqllC3(S
zZ~FC5&Ti*-u$LY4fC>3m!WS+Vbi*6KxM;l}DTMa<c-!5km5Bx*q2O~7dnaK1M1D5!
z&ucU$hz|ON+{dSNuU_JSfTUTCE58vey3rx@JCZI=GqSKuZWjRHiwX$uhTv-j{@~Wb
znA=SQ>YVt}PV{J`KEq#GzB%A&!-Sld?!w7Kg4Y9INq>?v4e2_4yc;pC6h8I+Y*p*J
zpQ>F4OzideZr^_qbyM^ua8p27$m2y^)>~6xM!@k^!#S(!X5D(|K1{DXTvU4r-3=jF
z?kbPY?u1mBjK1-{YJqp-5%^y?uCc^j`BH$0gp^cd#u2nSu3;3nJ3lCTWTGs*IdrPt
zX*VCrcm#Gw>uBGZ)9gz}Wxu>T24ef49&44hXAMr9IUnc34~L>Ny(5<KI(BBe=o&ZS
z$YD!i;d?+k!=y!gU5C_f<O#QONJrNmHTw10P+^+og<|T<fBmn(V-d2ySnH@SpV(7;
zJLt?zTc!TjyLctC=q1-yw6JXcLg&@Gj8&0r)q=FphL`|}iJ=dG=j}07iHfnk?mP|<
zzoNMBs2lt!3)n0}tip}!GcDgO0~%WI95N&aohh9TT_x)bplS~zcxDawjN_OUrF1zn
z#%=#}^Z4@QJHJ=t?P|xw>cYXJ56unfdbeUPCQ%NZ(9<R;<E8+7uko4WBM@CR0P=Rg
zd7XF|9Pax>EF?yJ_zl}?CDBMd(UZHp>;5d75&W0*ac&DjfM{(bVoy3jkn8mO@^8AE
z1g2BD-K*n)03{RGwd60Sxkl}k9pU0{nNltr;kyk$w!mo!5)b!p^Lu>6=%AnoYJLfO
zl+GHG8VMc@zB4WWgou|!r*hUyP5J*w=fTad17*-G&)moF41Rfa+^sH$CND~mH@8(}
zTaNS0lpDOAwntE_;R`j&$}f1jpKc}OZ`T1>(ZuGQo(B&yOwsAGf8&K0#05Drl<{{b
zcFWDeqeT^w=38ku=QEZjGY6DM6fT!;?WkL}cMPjI&dk%`tJVd0^Q<d@(06PAV)BgQ
z4A9&K7k?G+TycEI6XFJ#YeP<X-00*5?u-W#1z%SxJl+Mg23f(ne^H1%YXdp1$*W!r
z+QuvDQaZh$_M>YN2W*K)OUq`3@yy}@^)_)S`QnRB!mZ*R?{IHZnETe?nesb^T-wju
zC=bcs#~%mfp1liDc(xMMmeTyQ73dQyTg{NEMdkvjdG36p2ja@3JSJBW`|T7ixu_@e
ztm0iZ^TT8HrA4KynKjHP?`<dzy?kC_5MC`(?<aRcN`LuaKcXCA<7J_LcoKHoal!j?
zkjVEm-1y4a?nz((s`y!)sQ*}C-CxwZjewr^h9zmZZ82P!m523GUB1X5=OQEiqbi<U
zOux%rAQU0$2>H`eX}COaD}n+w6>?nr!?_mbyq503ys70nX%w@rB*)V44%AxuPN>#j
zFs@5omK=(3VDh;2i`1)h-^Cb+yAu<;hnN{f?LFb1!5^tk*!JYD$mOCtcUBy)N*~!<
zkQc_iX`OC>-7L9{i?s92)?Uu&NmJ~P$<;^kyC2syZY?Ar7hSkV<r}NR&ADdO2KB+j
zD~&cK2VC6^mWq+GXWI-y(swueC5Wv$BliQU`3KLp8)zHsTN{10eDXXu60wYYeCW?R
z%t$cQ`at+0Kf~$T_NbbkpQ!X$zq^P7bKHdbYH&WPTp!re(qexw_Tke;dQR7#CN(Zj
zy?JP#YNQY&yDZm#1|BVmB*_x@bn#Nwx(vz<L3yQ=6tfsoF1>x!v;U;TP$X0M)-i70
zP0S1G!aJ|mh;bwr@r-I+1F9`c?BG&x7CB`WzuZWo5T;rjb08ZtcX2dTsPFYyZb16s
z`M9T6-nnWJX#V2_CvDVbZ?2i%6DifnP;NBk%+2Z%4tiL)Jt5Sk#d;QOCJNqjYgIB#
z%;|RUb<UO+QbL-%lHLP{=0S`;J^wN!OR}SoqfO2Ex9K%A9i5^LSU+EyxvT^^Z6l|7
zabj1Bh02XF-BWIho^^2$#>sK(vuZ}cp5_=)(>Ro+|43HTcsRDz<gS9@Q$Bu_!eflx
zjNn2v&EGd*J)Z+j!!5NJ_iv_0XG3q7ID%Y#O03dl*QHceSamvG3+P$aOQq#en<5=r
z8#O1Er$mzCnamZe8KGOQ3Fn9Ra*0z(qjUw~*Sv|eozI!0nl^0?So<zhZi<@-0UX=&
zel=1KMqEU4L^*xbDLU~KnJ_O|)1PWfho7$p#Q5Ke{xtPcex30x;W_F?r3bXMU9obt
zUo%wl#Xu<NZ7{didsY56H}-==1Eg7m%ubqAn~F5bP^wI$<GOK{!o&`Z>npidzC$N7
zZ41V8%#A;0)Uo?q+ODIQEn5wXyu7?P9|vNN;lNe-A*3Sx9YRcEIez6I&UU6)?4V}Q
zhG>x^VN}l4kfzqb<Aw$4R`!f;)k&x69T+HT>hg4FTn#I_arO@eh1Um%7wl@?W}XG*
z=WItUhElI{#B5dY%$(Apw<K(N@&<25PV5;_`7jDuPc@`<H!S9HwXns!kCsU?JDst1
zUdSEV6sf<is>HGUNTDZ5G0<>{SX3q6*8aiGg>EHb@F9av?yo+6OBGR35^ol>1DER0
zuoDozt6grN4*BWH=0Kq&>jG~tg@9n$>nu=LAD(vHuyuU(pPpCyaIeds?P0o`8_x*)
zQ;(+oYnngvHgWi@_L4@vq*+sq^}=<xn?EGM^gEyWa;0w&h%lc&TkVJ=83D0K1|Cj(
zc+Hy-O8J^KKiIR$cc1nvP5Q(#vR`%zAZ)@v^lxVxy#~R0HcRRaroXwN6KsmQ?s?ke
zqHS=&oF;uD`xVpl@?-OdG&aJSkh@c=C7+rYRSR#<D@HI3yGp!%e>!A|QuU48hqD{C
zg1lqM8xl8`*hhjX{k+9Ilt}u1fjDiBxU60B=(cC<i;{qhjImX#|5MC8)v34N+1ND|
zjr6>p_rqP8@}sIe*&aM!&idt-^?uhzacFF_&t&DvYGI+s$trQu9#^DD_wsTfC1iVw
z+rIo$-j(ZRV~EHTdq{#pNloJv$rMN5K<U1@>`JF~4r;Qh`59$G&P$BkliK|{IwU*~
zYWDffCjE>#Ez;m-SnC@hzDmzfoOz3(sQKN+-|wE6;!$k6_p}jFy;QQyLtgr(hHj1A
z9v<5nEv@6eWv9WtagV=LLjC1dG`O3T{pbcf<kZP0wGv}i%k)fD;Q00v5+@<}UXtBU
z_joM1*nWh4Ak1e=D|E7tEn4QW<Dj;t*l>htYeE%%&n?E$wV9s<>}L={OJxcgd?L0O
z2U9o<nn*nsRd2O8<*toXJSGjhS}>Q^;|4h=)q+*L3WQ({mu>TyL%Ta9@#8g7HeRlx
zZl0$@ORbi76kckbo8KlhUJZowXI&VnkdqJ_?qp;&(#@d8F*|#DP74(Ncx>gp9;~40
z^*QPw_FF!voQvNhBnAhuay!RfdXIx@8c%;z*EL!%v#JR21ZCEb{ykrg$PRyyCtg=V
z2pzb#I@^=XCC2qT<c@EzJbG`3s%a8~oj6IBzBk-UB^Y$yspx0ak`q__I~zF|_LgU{
zr*RqgOfI9uC8861<QAg=8($P>+;v<aertW4VS|gka{f-vjNO{zX6n>iFaO_ra{)Da
zsTUh=E@u(b<9(vt?G8zGnC&_$WoQZ3dQEnvQ!5j9R>-jBb;i^(?u=hT2xU<WFL7o9
zSLr5xZDd&Hn=N_mG9EJ6``a0!PTS~a4^|d$Da|{IvvA@=oSpPCaQ=3SO{!j~r<_ZB
z>!L%kLD1@Uf741e_=_PsAEoft=@Jpwgn=?t-VlG<rG8!;2f{Q@;ngH=y40(CiLQbZ
zZXRb?2Sn4%w*+jARQ};3k~VLMjVeuaR=E`LEkm8gmRdmXoK!6JPuMpTN|*Bn*WZDf
zIerxi?B8g(L{1cRE;k?CpC`ujc)E-qN>Xe?&0}Ps;X6p9%~vnaFb;E?o098P0$XB9
znN<pQlk0Oq#X||-;bnR=K@6+;cT=)l)JqdhSI%jc@`h;VVz7*i7t5WVus_^=tC~9T
zW_N|}6`(viRc3No@l?nrs5stcm$G5VVcx}ipE~Y0ya%UU?E88jVV}<oa#}M%bn?6M
zmnIJm-I>iksdEw>h-PU0#MTzQ_A;<#pV|R8#1-jcv?31x=`VvpC3{|4!D2c+R2UeV
zPnUHMv7V^ffs4bprz_QFre;Rr+G7Nh(!~yZe0*xev^IHmTKoc2pAK{9BMQKlU&XSz
zD^KVQw&6$$tT)-VFoEF`Wbbb=*>%AuPo6tKx*Zd*O-Vm}b>yFbDJm&FHPyRtbR5{j
zKD#K#LIgGM?t}N67-I<&@{hCgq^ljbRWfh>g!sJo>m5EFli9wzg+-L@6>-rJ)2HOg
z0n-=KgIpO8VW44gRGp1VgG};`%35Ula_3%W;nJvkYAZQkqQHuhg_qG=*RH+WVxLKm
z+&y|zj)hV70qErGmdA$<<;f@K6O&@auWa(oa-{bb4B7rj1iP=j6MJA&aUt!?q`4_%
ziy+*EtJ}l3dd--!>hw2@4oaU9kI0wbty?*76LW6y*8^{j_jV#@iOz_BIHxbMfa$%|
zFlFNiDK`SoI>XiZF=gL6qLJd%Y*1!fdlP8qK1}vZH>`O-dJ10|77;#MipM_>14*k`
zN7w^*<1$<0X3BfJE?A#Uojtl|I<_as^R@1EGZ9+N$&z($lQqg^gn--A=Rt0@e9T44
zdr%DL!xLd+o&L9~OlmUAN+-W)9U`G|4D07(Kl3`=n1y4hMt?{Y^fxfTUz3x(jtARG
zt40ID;28Di;}^#k#86(kD@92Zs6P2`jd&0XZ%cD@8ePTti=qa|UWdaze)NZBAnK8P
zqp_kj*03j)`kcI7K8sB*Z6I*e27NwzXzI`6a*Jd(zXBQGGrFj9?#Q7yGg-fb*<pEH
zRpH?^m10$t7vz!>@_r<YRdED}H!<A96IB`Y<Vk$Ezsv`O9UdRp19EbGUK#lct&!^F
zU3Oa}Q9~d5z>%8#eM~alLUdTXH2$EQ-`4aSV_!Q=CZ1Uh`iZFySB*A0EE1gqn(qO@
zk3Zz^p4&q}q!(;#0ZMkx160HA5Mp)aYAm!~4_ty4Dkln4oi4yN%H)~Lnm)EYq;do&
z|BXx*{(^q1bC{PeQ;{}W22)fQo}HofCrr%C$BC^Bj{B6KKTi~6^Tlap%&4iN3QkfP
zz$Mas`kPkJg}U>A8KRL}F=c7lbsfP^2J^>6(5V>rbe~&(%;lvG_C=-CS-?OmpoMv&
z3e>UJIZv0sTp{xBOh)CnIk4kSgd0tJJdwRI_N^vs&40s<^WMz?x^lj1OAWQxCswjY
zX^AK&+Vq<7pyH3jXvsf>RKGMk7r5q-XjCNUYtm7f`<*+S<J!f7J}~L}gCqtz*AEUp
z5eUB|+fU-30WQ)fJgX^wt!1-w-!ZSP^BMQ21N;(D{v_P?!NK$vp^1}=!@z_eLY^}j
zqF$_OLS&OrbTfhiepOuhvq6?!t#0}>flJI7XET=~tPh7U0*&`7+;8T_S`7`7ZcvT9
z9rJP4+dDd1m3ftfmbG_&;2ruRh4UYJ*Y7f<DMU6y91i!@)rE(0U%o0kPgpH>MoHBg
z1BK4ZpT7^=>8a%pv8&A;8tRV7O_j-tn_tW+I?2%ERq1C9MB#>IumB%&8U84Vg28jD
zs3EVPf@*GP8IxNl8EN-Ie|xuZcIcpXug6Y?KYa8*nRPSkOI;9kv9isI#=-O--PGW&
z`sMR@FX?M_yO-tXio63#OwRQ!3-vt*Ln%p7lq(v?cIAC**y5n?s=5}b8PHXeBu8jz
z%^RU5I9t~$5WQmHJ0V(Y_IpirO*Y)0QAKt2tw)lReh7BT^mZCcOHX%-seT>MgdY5T
z<|zg}$;SwJRhPTf!0N`_zK;n@kqcJN3&-WIkPN+|A%OH6SZ@iQYFKDt1!pQ<%lFU*
zF=<_%pL;MW9h9Z7-CZv%52fWMxW1)|{^n0WdOjRQdKn$i2Q*iXVIXK?UPEI4#LCJ(
zxp*twWM@@VsULO%661<lK@GgRzv{tcC8HEeKT?7<@4;eSu_o#LK{QdWlsInu3I1f?
z3VrljJk1ZFoCZyLKb*5>@oUCj&oA;f>8SHj{YqX~<c4sqG@2{t4{`%J&+ZP*`mRTe
z*WYJsTa7@}@;8&yCOWd+1mb)>ta!;5{qF}BfOe><Ym$o0uO^wBIY01Ouij7!kH9_Z
z-gjT7v!R&hwW6X1<O)pQyQ)kfX)oK{k&ZZPEm%nLQ2sBg?H1td?+M|UY|s_j_f)R}
zx;WO|KH{eh{Q0B)8AbV<$-5J)ICCLv)D5n-oQGnKrGPazzsKVKGG+0fSUMF1y&rmT
z8eDA$;eLLLQHYwcg(lZuTTO2qO_pWbk?-O@sQj@55+VLqiF!d2thJ3>X~X8Uk`By!
z0L0<XQi7)el2s}e7$41YD(&yW%K91@M1W2ZbfncLyj~x%k4F1e=;N=6So#X}9PYV=
z1>?r~y6?6nTuCu8w*e;>%Z14#0<mLz<pyb>N>$a#sELA#@8EtCbUYjhiqrGXm>zU&
zVjVnu<rPIGEP_L+^$W;H)i;wsY~TnD6Q#9Bn6!0<A#dI~r|ESst%=mXERNS<Ks5uA
z8vq|pCr(g67icCB#Bp~j^=cefd(a+Wy6(cB{?`xKqF#XOlSw{fDZiAFcf<mD@gMq}
zPsy&1Nx!YGdLCP4kp5kL`zTT;;X_D9cTXntWRHQqYJ0@;zyKI$MN$?Mp%!L2w6*-*
zrHG-5PH10CI4)L}$DohGrU)n8%fN#U-b^~`lL1#fQepj2Rkk_;h2UJ$j}FU>o~q(e
z^-sddN}YY+@_cQ}dq2V9Bc6Te+aAZ7#;|oUw`q+UAe~AeXO51DC~6bNJ=4qg*8eyT
zAK*tzPECE*N*%_O#w{G@4;vyCkQP<Uvk8|~nZ3Eu^fWLyEL*h-ODA}s6iqD+-z@|y
ze+0a;<(QshMUsbR&Ci)rMa?0_Pm+N}pc|ivJmV<$Ldk=azw{UoTdvnfiB?Ka9Ott=
zhyus)NWt07s$Xgk5xOkCVIOdZ2z_I&^#B%plApjwcf<Y_T9|t|Ce$v1F<du~`j_^<
z#eM?xbi@7)T9^ifUXa7GXS364`$#dn&+@puAW#`!ppTc2c_AfXXqSg|e#R`nvqfR`
z#RzttuOBm`md-qJ?}Kc45}-xxDDHLflaZAj551pi6v18o1LZ`S8JeEP%4mWCM6z)*
zDJtmEJxnZr?Exm_al#me57dvC$pNr`5lj!@!y@?j`T8V3fE&~27mM=zBFl@!`Ai9(
zg~jr6^M`taq!lBdzjE($!t<~+dm<09X!;D`7gX;cEc<%3;Wug)w>Z(?Z>LJMFibxl
z5>+Y>b4-^X9{((`e3HTz*xU;CJBiDEKgO+^)R9et7EPth3nbuND!_-<i9k|fjM3Ax
z>0T%>={>2MLeZfCuxom)h}%#yj3VqIS2m$K>mv0;k@4ds=+VdXxBlTX+{T}7@vJU^
zb)nKHQ`E-rQ`XYI>u8H))|*d~fDf47#$wNqN&3ITo~HW6^o)t76WC(J9gj>@3@Hhp
z2DkxRciqHNPI*{{1Q@LK`Hn{@Bw)>?ZARb75-)4$aPW3mW1Ep`-AC#yE!o2`wbJuJ
zR}~FiII#Whn{tH%8`tL0aO**M*cJ=*Xbx~q-?nh6zd(D6E7AP|O^yr4N(Bvwly)Mr
zb#a(}pl}=F$c6?;paTC7jY<_A{W(p$JLEkTGX|Rd2NX$v{zesbd^8+?6m%*SR4fUU
z|NsA_Li^PIzx>tz{F=lqPCHJP58@49(Et88fG@+r^|$<AoWXw%1NhscO6WhZMwQ&d
znm+tre33*CK5#zkl&C2Gn+y7%!;uid1->N%@z(YK=BfllGWt_X^oXOO{9oK-lz-1G
zwS>qL``+{a-Ba@4Cq)hh9=S+Abd>*`<NxY*AASVB#jQzi^3DJMr}h8)!@@9>U=;F4
zER_F?8;ycK9|C;Kp-X)s>;L)%0uIRqg!&Ry_yHH?e|0_n^Y+%@2bdqK&uNzIvsN^(
z0fneZuVa()sp7iAy@{ok#k7=^Q@}*wR?5|&%!A9oV4%6NF=^R-rIvC34Qt}l5qZ`s
z12$LPR&O1uFi$1fO*{#TflWA(ybMK}J7E&L-rn_+n1frQduFy$nyqa7WmtGp&op}q
z{|x=_rcWqPmyr1SWrTe>?2QjAm#@k)PnB6n_uAQ^xZbiHlMvOr5l`!d$ZD#nP4V7d
z)9dgd;&}s#Ay<NHy}WSSNXxF!&7zV5p|H8Rt48XrC{@}`l>ccpqIwb#DS#f0rv?Vs
zGnzXyi-W;!M=-IB3&YmCa_V7#veG<bxPZHnk)D3SzyR|yHH}-|*)i)h?Hf&QuQLDC
zT)#ZOU#2@nzL*9CE?&USFCg|Sk8FRs?4k}rUaHpw%NR&PP7lSoZ+A!7wq$2NWF<E?
z3Lytm^imRDYE~HT?g|;U`9{pl)N?bP-kg75?h121(d3yp2JF3_Aujt93|fD0vbKVT
zJx5@QjNEl&mB=<f!Oz*I-8}`(j9?fP;8a8OI)fE(K7n?CbSJ?Qd2^2W;H-+MHbkoO
z3b`MxeraLrXa$PUd*b-7s?CQ-7Zwf=mqgAwk5{|^0qOD2pN3{E6;m5r6H<3ya88oH
z8&;Xd^yn%{_2=FM1qS*o2fwmy4hYbApO#m*xgNzi37ehEx%hNHfIyUI`4zd3P86sC
zo+mshD>5u<_tXi@PoFZkDk=_LnOk_R6!xpuOu7~;Fu&hl%73uKljJm8Y}}<UrCG04
z4vTl3U({{23t{vJO;<6iQk>Q_*7C7hd;*VzuHI_fH+27)#7s`J1xe>sX9`x%Ok9@E
zYee7zAn;4XvQPR>T3zxyCqflS6`+`}?VjCOnA~1(Cvjg^gi^U~^lG+&HT<kJOh1ya
zvha|L)OB($*Xy270JX)3hK-NE(l0V^zLVU}|H|gvd0}g?o74tMu+o?Ek)ObvPF|iU
z;CU}DSW*4#T=aZ-Owj-4cWecnsZ_7&JR_BX?*><@R!Og^%i)QALU@JF1itqtn?cQ$
zh8NcH8o&c+=P;1yT7+uQ>OBJYJoi0t1k?mM#+d)pJFQF=a8s@E6jnGD8mpRw;c<K8
zNmIfQ<jgF|sIoKpZ4!tNJAgoOKk)t03qlB|XP`g12){>(mb=VJNxcgG&i3$9aT5J(
z!AbtvPr3@3)B^)qN&n^LHv!|`%Gt?&K-!Q`iY9Ap6o<tC@EaLp#$kOGMvC)5KjGjs
zL+hdbGNd*Qs6*YxQJ;2WB3kqIO-;cqfb34ng0LPS+h9IVQX%H;sOUQdT-2lwU)S}i
zRgX7UZS=3s*Vz#tT_9HuD7`q7Um6V>5}zyB&DXe5eCU5v-ErV`oLOlrHbKu?t9Mvg
zHE0u?KWd2AkV`js{;ZDd4`m@{F6a{q^X>e3bSya5t+U)g7g`e)p_hnuI;wmQ1#D*C
z8*JjY*t#PYakTW84pXmMoajNjAwU*3hOM|ikQ*O13F+M#R#Z96?V|;M1H>@L{0@lA
zg;~Su#x1S>Th-z5TOPTzJh3g9Xj=2%za3ee8*iC5Klau4E5uG3C2(cWzsQ~4q+pap
zsfF)h_Ar-GulF|GE)G`Iw}uzkI}hwUnb?vR7uBgB$Bd+%xj9MBA6lxl&8>LZOoPbT
zhd4}9YLXUlVfGcaGB2GSWq1ETV62NGS_@r?pX`8rLV;3+mjDEGCM}KN+}ruUoi*Fy
zWl9hkya0^<sb6{-JuT$4APwBl;AjP2VQXz)9b$gSLDWI++&0|RmbVUUzCBRQw*8u+
z#e*wt9!J6sxDZ6%_|l?}rwcZ1C9aEi^_G4|24t?Kd-=km-hzJ(np`T%x9yx?ZD~0%
zHzqlLP*?TS1?+NIn_ZZfRZvfeq&R&^Pl!es`d~q^J%vq09BKR-E7)>~GQG(8{m$?8
z7^f6BVy<!F%fQ%P5|rZOO8(7OLQGU_tIS9S{1EmN;fc#larsc}wMHN!;`+e!l&0!`
z3~Yq3T=J;fTYV%0@N7jPCn&7>Ux5_}0oIiA%8oj<%I_PQF<N=!(IN~z(Y47R^*p!9
z_faK@P@^f)0xM3^bD@99<+fUTA9x~1u)UYj7I$eKd$BWiSo!?Y1pi!r;Og_lPw!w9
z7Lk4&iK>gek_FlXc9-y2hAW^1LCz%7Eu|k_-(8qzss5Z?RaVgFMjEG<mc<C}08sw3
z5I$w@J~QQ_R)wRFK#M4qChyxsuYcAS6~8)`SwfFID%T57t^Ow&q9M$i$$~+KZ)htb
zbj<Zbhsvo@PJV#8K`{0fo%>W#FNJSW^Tn;+#7m=vKCuDTu{BPcq3uVCFbwhQ4U;7-
z^%KvVtu(l|!~KA1SmJ>^wUYc70PGXN4t}m{W1CALu=sllB0slR?`zw(0x^tIFPH3&
zalCA_K0gO?E@Ge0^NS{#Z*SVWPV6+Tbr$rAtF4>qKNZhVLewcU!2R(y;B!Ujqi^%t
zwfl;c%<Je0EGeS+n5NdYx2AhY<j|cW7Z=ymD2{~b`<v=E=QEfguq<?ap~S@0!d(Ao
z-E+y?O|y=A>-*<e*-!I+B|96n4coipa!VXPiEp;tO%Et=tnbrj=poS~R-}p1fV8pu
zIJ(CZY|waH)t{@!+86wCajCZsczg^JTVF(xFX+sy$|)uCV#m_|F3oWPswx8lXoX5D
zLnEYgJm^fS-A2vHpEj&y?Bcw&NF!C&0YE(SsZ8*bw*N#N|7UnB(THB0Te=A=FqfY}
zuK?-5<pNt$t*RJXd4I8*_m7Cd2|T1-qf`nHjqdjr+G!&R+Ifr2vC#(>ZbXm=fY9ko
z)uh4^AtVenFbuT|0x`#M=HdD?B;^vU@K)wn=1;}JhJej`UB<C60*#7u>)+14-UAj5
za^s+ts*H252ljmxXJN(I!QtVj#w&*zu}1bY8?k9-f;nH#xk;igJ)!1_zw_l%)jiiE
z3|bvWYM(~18ShO%+EUr#f7ctcRCq;EitGIvh$g%N>Rva<!(RebhYOgjuKK_F=>;8A
zPG)<5F}y!_vV2eBOk1i4lp_hjKQp+AoD=BOM{{N30xngh@<Mois_1PoK)KYtSZG<G
zj4lb+e7hCBAXSENd7J8GUoUW>QL*<PCi8QDC}EoE6t;%f&6F0ch1!nRcJ*zcML~b;
z`<e0lPfxH1Ab!%_fhR`*xBZ2)>`_?w_b&vkU&9H*Y6kfQ<P>vn+T|iYrD8%A<XQB@
zHn>RZJ!Lkno%a*cTr=mv#0Bu(-HD>Cmf8hyZQP!%-@|q3B`_CIKiWfSghj)+m!{tR
zq^>e6Qp-%97{L-s$4rje0)F$f?`&?8vkB;<sOPy@%ER>5U+nGA0os;pF9!$PDRbhu
zy%e{&)_OjrJT4lk&`?z~4Fa}$q}5F^4-d(Rj^>2rRKtFn0|HP2ui9-~rS4^O^SRLy
zSH<;D3;sDMy_p%Xy_s<{tPTf};B`IHM0N2D(MGx16S!*F>!}lHix}l@{{8Ek&BVsg
zw((_mT+7Dn%k9N^M{*g>5wARn^bFh^sEtQdO)nYcg%2b%^=I{#`7hf80oLpi8GQIo
zg^k4R|9mR{-=O*_-VT!_3bVvQ=;j&|7;@74Q;vfk+5n*LGqU?w6eaHWv@B^7M)^?l
zkEU<bga8u6$*Wh>nC82gFJEk^oKJu`yIG<&xa+S!q!+kdR^^q(()9_hJ3L+}tZuqF
zIkC6_*n1tR4HX~AGFch3%|czrpy4yy=d9L&uugo&i|I+VINZ?TQQ2!F{Bmeq43}CY
zgFn5Vn<|XQ5~7KyC7=dIGVnl87*<++(w^i7F$F0oDt!_%@S~-@^jS|2_^jHexjbq%
zTfef5#Zar55_YWh98dK~A@*m%cC6VcZwCWCu_!h+g~G>HeEc`+5)4!CyFWn2zZEpw
z*E#jGMxB={;uopN_nk+E%rnw&369u69s~n%HY(+xLrbfyy7GYyW!i%@;qOHKisnKt
z-FafwPMKcrd(zFi5^hxyPZzyHzal2Ge*x%Z+n2bL`R<}vM(DN{yv)2dd(ZD+3Et>b
z*vz*_jx(jjmEv-6xM2GJaYkcLRj){_^rp&fzS1<%!NYZ6nShOUU4yRIBSET!ee=I|
zZFsnqvjNTZG|=_D>lbS(<e!;5?FuuKKDbFwSj$P<_`AZ77CpFsd-ZUC9ICa-<j_mP
zGp-#p|GSV^Na%1E*&Q*K<>0%~JFQG9Vc#%sK+Mm%MMv)>L?#;>FCZuE_u%$<mXlT{
zV%u5)LLGNw0Z|oKm8L3#ZGiqB{k6}wv1wKc&&?4E=GJA6l@#44A$0ArZh|LansV2r
z_ep4a1H!v{`63PqF_69~I`CL#wC{9Mfa5#-%{=y}U0Vf?^QX|#={FoHuugVBMC^6C
z-$4Dn3f&f=us8u%SN0b<CG(rI9V-Y+>pR8urn;D>ErT<|_{FY##k6URvFG}x*9~_O
zb@hSaJbsfq995M6Q)1iuDJ%CSs@nk;>-YXnp!z!hoZ>n7zK=1<dxYaV3rsCvqRMeS
zHTZ8gAGPc8TE=H(efb&bfKUCpKz;qx_kO=Rrr!|iV8Tkq87v2S$Sbo=Kk=D&5*B^b
zb2u#LLKB3Z*t}Co`xXH@l7arMa4(HN!X}^B?OXFynEVq}mc>aQ%Guh0=fS{_*?0R`
zq&9Oei!mVCKcuQ2-yxApC*>&Rq?~LGE#cV((wYD^1`YXlJ+%`R1fu!zx@O~|cwkjA
zH0UN5;^5?C5f;4^U7x|&NdOQXN`ca(lBn0KhSD%UbQO!oO*W`t%5xPN{z2J{8E>Ka
z*m8?NHBu>>zt>ziJ2KXOCjVSbRk&tCU`7A@4NGyTizlTK{NmkFvJGh?i<443wLcB1
z?3^;pU_JirR8#_PhHqCF-9lXD+}rc8aN2d1k**I80}ES;W0-C!qgzcMPs%1RhkGgp
zbHl8h4{v~J19Bpkg@ti8+jQyRXAIT~lEEY8sPLOVls+!QUdWcfH^^<0{kdPpWsmk}
zvt$&vCCF8veS)knlg!?UzcHM?gy11ND}(B<URSc3rpw-Q+{aYm6Ori~n4)J{YK-OE
zncsR^D)R=D3Qz>!6heH7dsu9~#s?ifl-(q$1f$&iBqu4p7@|+g^l=mVp}d(`=CdaQ
z_puhpY>5Q%Ura(y<*UL$4B6`9VBC{J2VJ-#k7aydGy?Hu60f>q89--uCh&u=dHvSv
zprIrMZfaxEUS4q4E@r%HvR@5y-6F_VxVV{M7AV%-CwJcT528|TX5oFe2=swz*N2Ys
ze@c3yVePSJ-)pvUNfb1H7{u|mmp<co#SfP=BsLgvs!Q?{XoHuBtb@fGiBdrmbf?*p
zoe<4wYGq+mD5hKId%t^ECt82DH<PE3@9v2T*4*7n<uh(m))ox&xw-oqO3P)jN;uYE
zr7$q?0q^JuOjwEr7!N&FE{hGSu6=IW<MxfgCJkyJHxdM5pqFa3z|pQP79r@8+ivz1
z&A|1KjKNf|&lq<T=zEa`dbuDc{|FiP`mIzPXOI3F=`70L|H4dN9cKz0dgCaK;+CSC
zQ>#V-j_7SrjNA-jP}WS-LpH?%Y7}y#4Y7?%+0^)iBncIJ$g<~bkHcKma9odRTwXMi
z1U1=5)uPqoxLoIzZ@mL{{Y-WSF01e|U%A#Kc_sDxtQ7P~%|4;88N7xk0J7}Edh*3X
zp*izv&$-Id-3bkZk@-%BUVuA+#--6zNTnx#DH!yVUizU5i-11L$A{Inn8{Kq)6X~G
z!YlVxXri6WakNU3E&AvF(aZdB^n(pyU#?qTh`9{*sGCoL@7Wmi(Lj~dpo=W&|6%Vv
zgPLr+zF$Q|R1gtR=~4tj6_6gfp{P{pRi*b%2%(CiQl(3mCMERV0xHr%?<EkF-Xoy|
z2<1J!_FV7tT=%|x=bm}?hdq1t2WOa!DQC_j>saf*{_A%v)iGM89p&&s6D|Iv;s%Qo
zF<Ow`8xY5VEn>f!4D|LUj}4Z6t8Th9;_olrqP)NQzG(2PY%$knbHqhQ#Y=BmYNek;
z7&}Etsa55|$e%Q3LjPs~l)iO^G4lDoYA@OCPp4N5JGL3XTmv!NYuoLwud^pCLNH-D
z!|P+Sm|wpd2l=~kpVhh*O&wl7?zm9<@-0{hZ5FS{`TR1`{hM6Rm{t<r6$#y^C@e|&
z(5Z(MPS-EfH=ku{v<0D>9tUKRT`uM|zP;`Hq+(Fre$GTONL-^)=$({%?t1rRd|Zdm
z7=y)mW2kqjTXDLWJuPi?_P1JVDz2)&5-4Bf@t6H5J_}}?0f{cESK&F!^o-KJNmDIn
ze4f^#u-JT5$GiFXWW~$IJld#HgZT6)CUU&;ra!OZCo&>9{>B?t9lNwg3-|4XQIDO^
zwarko>>+v*{tr|a9=V}9IW#iN7X>M#qxiz)XmMN(TI}=_hrD*_6UC|%GV1E;Z^*ot
zI~@`IAG7-r(4dYmptyL&X(+%}^E<xlbfo7${e!mU$q`&csDcEXme$qQtD32SL6-hH
zbWBWpG~c%$ZH3Kz?tTc0p9%vGM|a-+onIAFImRT|?L=y$62C!_>;lg{Jm$uFhFvo`
zn60Q;HB_~gCKg|#7?}gNBO|3F_f_V~f7}u(h?17(dDUvwlSq;=W!C(07f=#7Wm3N>
zY|yF2-pL1``ya=&1D1wdCrTp|Ds%eRxFtHebBfN^5mMY%Q`ckdCLAh|bEb*<I<)d!
zmNlx{iShF`JUnWtjiS5yGX#SEm~@^(kg^(PLb_|JaJQ@HV}IU*dF^TVu_r1TI5HM~
za%jg&fmV;nD?!~XuG1HqS}IIG+-}02bP0MCf_)P2N5@K_3m{bQakjpIWn$Q8k?$_-
zsrpS=v6b#?a1rA$yptVLDiL^=XvnuUAwrrk{5qZF3PB;%bGl50NUK|yP7t<drrRn%
z5r4n%hIh(G(upC=ow|sK&X~g4D4=}<Qt0Th_i%79o{i0=FzK6ZzP~6a;jmbds7r~f
z*K~5;8hc$g8M+o5SHJ4H%q0OE#A`sIWAfj}OE$FWDKlgPr4C87jZ1Q&Z^`CNqt}+3
z(@%ITu1~xhUe1z<MJH9_IZYFX5v=ck79U<8Z%9er2elh^NA>4pt)%PdIE@<I8?Zj#
zuOGjU%rI>-^To`pM&zrTKB2k#g<oI|IF%-nkaQp(ivmtFcriRLyrReym!rtkR&1ok
z)c3J=I<_9$`HSXz+0<5!yEF{<P-d3`zQ;c<{4zF;*RFX?-CkKF3Xb2l2<#PL5E<{+
zUv!u165myZVBAoz{&y<;j|xt1<<{z5#S7@R)@BnsZ2@i&xVA*xX~j*tV~Q}J=z{TE
z)u;r0`*LDgL5%^B)W${ni2BBAoOgv&ZndP4`y9YxG5g#zC_P(c6UW)^f<Lp*e(5uL
zJzI<`&21_Sx6d!<6?df?5T=eE5A|$VIn|dn!5eINcJ00`ZBC_<NB6|Z$L)1SV@s)7
z-h=^~tp0f4w-gbiwcuf-MT<Wn^m(jQ{Lxz)<6vR?z)?}Pr*^FNJ&D1n?Q|(IpSb|~
z8y2QhQ(4!2Z)_3nzL6(+m>J*;ve(ac3R?x*?8_fG6&ShNiK(`J0wQa$LK8K^ZSHOr
zdEBZ@mEFd(L;$D)D2;47>2aK8$Jcm|Fw9v*PmJW5;({Seh_tX+<%Cskx<Y^6k?TeM
zp!>4>m(*e@vmG>Rtkpy+-{RV7QH9ufy0K*UeFW6b#C)QEg<rrh`)pX#b~lnfCu={K
zr^`o38%TAZX$hGD+f0ewmiDlW>sCzP)GIK@LIhY(g64iSw;K?j))T%9s3uS6?(D4Y
zuvE>RJZ`9LvRD4NMlV0tg?r_wtO|%xY@ruOD))Jm=??rWy>)K~?u5H=_t@Q8^pg*@
zK<K?8n6E1*S5VUy1n&0L%!Jk0ZCI})$@g#1rgG19AGB2W(4CjZ#k+HI_C#{zSJ2ZM
zeax*WERfj_C4XTN4CsfcijN5pV6{P*Rt#&3z%qW~+tR#U-W{UEADU5=DmjaE%=K7Z
z#<B|On!vuNTdWJc%p$vmKTQ6yn*M8z8Ke;>^7i*!Gan11(aq!8is7Uuw`@|SdUolO
zuD~Qt(}EKgte(1jrJ)Tq(blGWf3bSW%RRt+PUM+3b&%NH%oacl&FUci!mk;|oDvZo
zPWobn&%$uuZ=+=P>myGywhLn#F%+BZF7_iMRR^EHB`qP%%_^RTr9P-jh|lu@EwPJr
zQ)NboJ&paAyD<w8ykP=i92&9akp1$dz>&{2UYX(SR^HYb5kzZkv3DHQSkc!iw8*ST
zaR+Du81$L{k+$^yb{Al%ZcG9~5+!=j$#T(*C5Afpgf)*InS^@UWufI+)uY0R%4u$y
zc1mE4nQ4_Z8|{0?t1RU8<4fY83}o9iPLM$a-Pys>`*LYwPrsL>CMTNd4f3J&T2)aq
zP;b4N>{{gsmk%za7jjlvJcV?O+~h^{mFU0C_5V>IWb2VrP>mB^6zrP?RrQV4y{3++
zs)gBWs6DnPTjkC}&((Y`W^WaGt$*Ie?thNXi0|_b=wT}lIHfx`_Hc=$41z1swgYtU
zuc0JYx7{EmJ#lA%1(EkVsodOHsX|Nk$He44>7x#MDaHJH?=5*tVj{TTb5GA~>l02L
zm0+GOi{J;sx8H#KrSd_>OmP?{I0M(qWA@6ATsC|hIJL!#YBQ5Jgn*)(ikVdX^1p8k
z216cyDynEw5ztJkc?l8mY#Psr&k_;m(|FDSs;+HrLrFEM8YWcbrQN4^XnoI=>V3+O
zl=O6A2=t^3d_@|5`#|CIdl)oZ`g*}aCv=PpC*$(~*v!;OuKh?cFs*a;%Cm)#*TeBz
zYi2{-oO^fn9D6ksjJGcbc0CXgSx|fW6y~d>R^UsRthYjMAaOH|G&i~#peEy6*92TV
z0FL^@=M1_TC1031uV_=(B?tq@6E&8BTiWzL6!>n$4Zq#+;$HVV5T&JB#n4j(O1{mw
zC{2~ieNmsOhSUCKneU^@`!M1Jt*G=pKZlpw?coyUdNf%UrdD;^b<Jkxt!5t_s(^C)
z&J8Ap8)I#YdW=@_^BN;0;M{5l*?f*nf^jG~ETK>P=XYf#ruzK;YW@%|3+nsHumeYq
z2M>G>UBBUl^wWy(MRz+>;0&t4dUJw}m#pfdg(N>{#hjLYaLWMqHg@Y;r)89G@u1=m
zP7gkv6&+ux6?C}W{wRTGK|C&(8irdGsY+P`e9ocdv;syQZ5@EW&?iO4b(Bgzl^$aC
zvz8?q(qjR0DxIESKD7<}Ro*pdyZ~+tJgx=oMWd<7g-(iFoKKwMwX}7lrnw5YL@XpZ
zT*d`i8Oxw?PV5EP%d|gYiip3riOx?jNszf>75Cp+J~=%_ifE1PrE_8rkGF?*KS7%$
zqBE#w5oIlOs@|_&xfhyy@2wuB3_olsaM6y;v+aF4@EMlqAY@FR>*$167U5@=;Nm$_
z<il(L2*T}TiO!Myk$~I*f^`iJA*kKt+(^N(CZi%_`KfGUOgPJ}vZ5kizIrSdNT-_%
zfXpoHu@60N5`(+jlDa=JnsIP?^OGXUqgZ()bUxNnj61BdMKx1~56eiUpINZAbq|PQ
zkXeaZ`9C#+Rj+!!W09MTYvnkc@%;585yhT)kS^&pJ7O8jF&?4MO&+iz(8E50gh!vg
zN363S4h|Xtf`nEbofFcT2ij@+4m|Tn?I8-i`CE8ntaY5ag@p#<ZEcOGX@m`JqehS;
zizOv~oNv59Oiy+ua)EtP%qv#^njDVAJ|76mu;1Mx7-kVUrFT{nE!e~TgldsP4d{6)
zO6YTH_Z?&hEFoRb&-xPPAA;aNzonxZk)N)z!(WL#W)cIME1WUDJa0`K+yzJ>B@X4}
z7neB`zLBsegsk(<w44^aB>m*rcplz&Q!ea+s--rN%vQ%Oeos)|O5%KEd^9S<(OpT+
z?Tsx}f(;4+!p{xl_5GQRv*y!-43tN<1$(|B2C2Hfv<wu(YCyOFdk5@~>6&M8G3Y9W
z)d4%YcQ|QD5=*pwcoZX=QgQ$o@pGWIQlJ$oT{Vmy3O?IYPfzjv+1&%x5()w9xsc%u
ztX?FBB`Vj**2d)bdtfnC9*y4u$Ci=%;~9_5wK)d~?EUB*#1|}G&;Fk08%)l^!hqjG
zd#8w&@{Bv3=|}3mgH76NR#IN;MtxEO@hm^D37K7f6QOVTF)!PyIRa3XMApUBn8nw9
zp!C4-1pBF^|Bt=iUP|B>AdEIie=-L;j{8~{5$!Tdw;O4RZKosd4KzL=PAVfcM(CGC
zMCjNYPA*)wHf|Bj=44U401*a~P`$poWC?w#vm)mB#Z;YZpS9+E^EKuQ8aBm4wo)Pl
z={*OiuMVpVJ(l%YwpJO^UGO^Q5E+_S-1{^n{4yySYUtm<rd<0bOiOltqpVCx$>DfS
z!~FVEq|s1aTKe9WskNl1ErL^-i(`!`@N{2gQ4Ar~|4ESde&kpeX&aN`u(yAz^Ykc|
z5oite^liyuYNQ>8@j*@>L%@<Dk7NuME09Zqk&a!@mHmn0YMo72Oq*_F(<}gKau8oC
z!N2jbM53i@&O2sD{i7^5u0{LypQ?Y&`-7CB7kKnT$uF8f)PWp~sGA)YlJv51cy~qM
z<mzW`4w!wyEz4>4`+Vq|a*zANyKl<Hxwr00Dbu|i`o1)G(pN{mOA{mSCF%O9Xr@eP
zNf#qZ^k5|>Hi-ICB(8x2wsZ<cvE@p9E-+VnKFu_!yA4<=n}OwTBlD)=#<QS|*2-8i
z(HTu_N}9JcK6$qZ^}duPh|J{%Q?b&@An~s;#I9MtsRfDH^jit#9P>BH`lr2?l};vu
ztCQYSb1D+ECY{R6z`THmHL}-SAEv}~CkGRPdnhL4-kQD1efd_miVh}w1L4td?M~4O
zV34)QTvPJmQe?to=jNxFQ~=W`y-%5=P7>?E6V-*93GYKQu1pwEtlt;D^X$&z(1%~(
z#R`<d6RWPA>3g7{WcISJrIpC3B)q;;ME0$zp-4+EeGTVLZ$6->6yvsON$oy!FeFM+
zy{pVeK~@a3L3ymiAs0ZbEDO3}K(_cM5%pn5XnMxA1mR#u_%g;8Cor_kVPoY!d_|Of
z_%x9vy3f%gr&Mo_;y7-82XHs2-KH(-{@BS5;sbR4Je4<|5U#46xnzsIRIdn?Q;L1X
z-nxQg&h;yIFWV9rwi=r~R+KaXBV!rv**^VDtD14Ph2`4s8_jg@6nLnf1yq{0!$1d?
z2;x^|wp`Yt+UN78Usyt7$^U3cr8EH1k+G?xV?Mw?!W*6tzovF;4(ROMrOncXS#H|r
z7Zw_73`wfROTsgeyh?O7n(<dg1ZshjNQnuN`=OKjde!JQ&bE|ot*qmNm8Q+`_N-#d
z&QY8Sn;TMpv7Cc@YOYp`klIjUYUx)o0Hl{09{hi*mg$1;r@MYVV9zXtde_n=j_;Fj
zXjrZc=u0OzDP2lg?2BDg>s0SRd_+bry}Vj%K6gj^AkMAxl(102*$^PTIop-a9x44`
z<p%WIqsN`FhzmN56RFdSmWM|@hD(D#Q*H`t30Es(CO02!XZ4<i@k9d)4%|5PIOQO>
z89`m~5;CUJDXoF@0_jgzN;8MHU??|xp2$U*x&-;^%@0S?mxA@!9(`wg_T3wFq(X^e
zrwvG#<{3z<VcL0`q0|cL$;rMs*`bKz57?S+u6UZ$_<bu$yOrZ)Ki`%q>{}N6fvD&j
z(uXqY)pL|V)#nK*KXFG#tAo5F2-C<QH-`YuV2SGp#C9a9DnELo`@L#xo`x)vftI#=
zu>#%N(BMkULmN+LCBM|_cVyNs?&T}Vo3Dyi2B|f5`1xL;USqjUD+aBDwE~OHi)TMr
zt;E)Y{C)o+Q1sv%-ihjWG_04cODTkw3o#`Qr%|sj9B%-=%e}}GeH|WLTWr+GVYI5f
zMc`h}X>h(9=njHUKb{g6T_^n}^<-J>eJ4C_;xxg%E`0_|0%z`NzggazqcdOltVZd=
z@>3vY^Z4^QIgH<pVWpUy>zAxc<69Io8xt;h2jZ{;v!hl=HwSisf*O6{QRPwl9eqEG
z&_g#6eo8-H1x@<9H!71*QFQ#po#{EJ1azp*FXJ_MIV)+)0GKT^PR4y)>hJ2B5my=B
zIabnrJs3$pq0`Z0xmoA268gmeb(gPU%T-^0KRqsw3Bo+`SN1vtO~?H~Hye~7uCyDf
zrOiwdK!lw;kKs3IaWrv=y8x(}R(r6LM!~BXJZ+;|yAvD*&7rmgRgFctT{+2FU*Rr-
zEP?D(=?_ep&e!kj!)DXp6+<1z{Zro6aQd|W8qR|oh9ekO#%J|>%PhH{zW~Y+%rP*x
zI22avy1Q&U8|!3s-75ao8&zDT?c2;m)@<n`OAV6^z=%{d9|{6~JRc{S;;cSt-p<eU
z;+8aLOOAJjGlkl%BW&8$0Y}q>E?5(p`|)}F%UPRgengiQ9?1g9Y3?q8XRJKMyj_Z%
zV+ZEyILng9dRy&t)?q*6-ztGT>rpg{ikE`tbuqT&T{$Z}Wh~L#muARdy|<RSOY)ma
zy|>2np+11WD8W?7m#`T3gq)_HeMBkdn+pq1C!);vcW%@epXGSz9+G}DesPvxpbKyi
zpd~XSu5Xh(*7G)m0F9q6pHYudGTH&as4+I>*aHN#&f#UcTT7?ISJVe;X>kURQVFX=
zxp=PSDziEAjq!aLaM08Z+75)N|8Adjz+&ER)((Sz5-<)h7LBQDB6@m*-jU*00;4Q%
zm#z66mv^R*HHTyU3ez)}SrN|(Xxjqr)zKK@u^oY~J4bz{*o_rpSJ~RPEdA&$4a)SU
z_B)ZzuJU}^?t|R2-EKPw=AhTheqII+F-@{m6tc|+GS;h+8<T(xGV8`NA%4C-MhL!D
z+2N@+42z6Nak2|A<><1Y^Ih9zjn=i^uF{{aa(y!A=g~*liKfu)SRCzGr`HFa^wBxu
za=-95fPFm)CnV>A7`$HIr&qU4`b)SL(jNrs3~uG#{X>wG`@%AqX2`pe+h^v*NdufL
zqn~JmY?LAuaaw1)zYND`d>s2Rv0t#BNQ0Vr4vCAfo*z6B70-3@cDVIp?hO5mPuCoV
zt%?JyHK4i<&Wh$|PxOSR99BTShM4$GcE}9a4D-~``TJF9W!qxUE>GSg$fXCW*C_Kf
z%*7BDt<I(qVASgJ>X1E5ySLtzWm6E7(3zZkr((sfTCuXZ<69YF);>-rvNQ{G285rx
zT(%QEBfb8<bJKRNt~J;<zDdYJ>nYJ&cA-1*WQq@Ioq)p)pZ=hnE4Df1(`EvCOLVwJ
zAD~h7AqiFN<>)yB<Pt;!2z$0UUk42?fZdqt-~RKML@w(RtKNrBQm*^X>yEI^YcYHa
z$g<iYJ+l-sqWX^oky^}O9`y@`Y8L(a*=DSGjR1&g6fl|ENTY-~Cx@Co^>sD?!Ihzz
zEJRfAD`M_RNnkh-5^^5l3T&vdYMzb?_hd8dau=&S2#(7L7Zn2)uKMi-=QNC>jm((q
zPednL`2C}QOCga_QSh=>z$0<Zz;ueQA;G<d-fMFxCqFpfi*|Z?%Xvx8L7oH~_Q-W}
z@`i(h3`7~~S4eAdGYgf}tZhBV`ebbOKx@H0vPE?XV1xT6&J=_moUtap4gIFH$HoQ`
z4<}U?^U6fBuJh4W<=EJ!{pt}=_FG8ICl8NCL^F_bU6a$%Zq*&ak&rA~nOgX+hcqoT
zYIQ0(d29p$b8_6y^g#B!CIcUnzFwD$p8+Q8S$vcmD}O{~_KchX)6EB=p~s3edYQEe
zu{~4BQoX{Bml?A5G##Ut{?Kd;kC9WRBjWNa*%`NYF5)NvYU5DDl9R?TT|+ja0=aYQ
zT#j3=(iwT=3z&$j7oply<j>M*l1k)Cgit;Qze`@wO_Yc4EthxOxeW~(fT*rZW~H+N
zw7N%q5Mrp9>9R%j`Cb>b19Kr4PAF>+rqexus1yup3@J$)StaXxkm1gm&B^hZPM2rs
zEPGMw@eO*h&;$j`2MYjSJn#7U+cln-TSCo&=kHgPR&71y!v<L{FY23@_`>3b<F{Ry
z1j@QB*l_LJSVvf~@6;XLd{7s;k<-*?HQmea?g&_)s$38vQd#En@olsxeV+Y;3m3&`
zDwm<&+1ZA17^#k4ztV%QnB4{(TAk4kem%hNchUp_0y4-3ZqwuQ(QZhnbhzpuxJ|^N
zSt%9$QA=uZ)e**9*B9Az9t(#ZpO?%{GYjFiu-FnoVolnd94bs%p#OMufXHe$EC_AG
z#2mN`)MTwM?>Q<bc(gh#tW&qno^nJEbZ49pZ^CUJKiO3)vS1%M!Zu03x5^mUCkH-J
zE5tqWE#d<;w{PR^qS0d4SJYcM6a#5XQ*v>wC%7;d;$OXvMFe`0+8iNEzh?rb%{~+G
zmGq*a=tVGsB}n7GCpTV7raCTR2ABol{+7K|VdUO&AM)tvaA6md$hYxIbl5vBE7r<Y
zN(lGm*+YHP5V*!}1mzL}HZ!!vvasIy;SZZ6U|`Put2!v1aD~aww)p$oY9Hd3;3ALP
zQ}*0Ae+(1V?h2T<R9B{Se)^<Mdfn@4Jyp7wu<~X#R{#69f@nh=`#?q?wRS0ou_N0h
z&?(K@zCj$Kw$6g~f$cn}T`aDGqdvhGu7CKrM><2HE0uj90*{SO9Yd8NRN_`rOb$xK
z<aHZ1Ar;SCpH!KASTqc@Qvc96@Ceau;o>4*^h%stK`z#^C#m~<vHO`o_*+rho8Z6}
z&}e9>DLS?1<`=7Ia7vR-ze|2kj@sDWoGElA{}Y&NXB2rtn-%e|)H#!<dAy=?HYIep
zf&t$}72W=ooTZt<v^L&)t!LTsh4K0wmxYKPIF;9eD!cYKmS``oGIZ5*JrwY2jHq*G
z7T<a%mztVru(5>ogjHizVw_4%okuIPFPYT4c1DwxS5?BdrZZ5LP50WJBd@M$IOR_B
z)ih{nK{hwuO=A;HU1s^89IalO$Vmvy+*oCM^1ee;xTiuj3bc{znyFjol9=o42D5w}
zuxX$>zSnmK<V#@M>icTj^(9epl=3-(nfV&|iutZNJ8!&24M5@kAtT<K&Wjbk8{zSt
z_J!@dh0?l@7)}9S#97mB!Y8DA=gN%BuoBMrDS2GdFu#!VfbxUD_>;5PKTV0GtAAo6
zyJ%un02r^qr^yci*^Ng|`T-(gZVUlez-Y($dX!K<=d%@>(t8T!{8?Pgd;5`G91TvV
zBzFnunx__7GCuQ030(#9X^RRk8q%5FMP#WoJX8T<(h$q9gX9Q_-~_4VGRw9gv@<wj
zsmZ^n#WIT(DKaH{CRa}rC%{j)TDE=FPWDEgoaF{IKKQxKZZY)KWXgSsYu!(kqioiF
z#zvrMMsH43RMar$#h7j-;J;qz9rI4U7oDudAqljVUdCpbP^w}qm+sH7@3Y7dHr=_|
zE--E!7@Fq!L(0O!7GEfnz2jC!pIDE&xIp2x&9jXndX1Dp{Z5(BHh^0lpY&me+ZaEE
z*zT^4ucJs?Dz0uYEU4)h?6TN5qaIt<ds5uWo}(`X@{Q`S%AVGe$~=&T-`3+7CBS_f
z!A<9x?FHlUdFJ{@Bd5;gyOn8~LFn^(zawYvw<JYhH#d7uXbPXbLOXY}L31qWeL9xX
zQ&Pyc+y|(plV3uXn)mg@hvQkh@&t(n*JfnOYo-0C#T7C;NH;55*?D!mbrhI#3gYX?
z0gDgcV<yD?#42`JxC4H##4a$7J4F?d=l#KLIofEeFiYkSGQKS{QKU#1dd29aLy;;A
z{AHJ3*MvL}bUG^?hJl>**YI?*B~j_;56q(V8EFe7{R>exa9<*AAyLd1%bTCB8cSa(
ziGQf|GG8e!F{OI4x^Pa0-F-^;-p9Z*d+AMOrkUqC@yv^-Xm+)2u%Gw~J*v~9fR3AT
zS0>H&fAb(DuJS@GjJ=m=K!}(1s0tb_Tztant8VIM**q?X*o=K}D8uJ8*1)ZmCrhHS
z%1clhqMY?-z>F}tc69{1suH<(6Pp!BY8`dj=03aCG%O+}VQO3@3$+-24Eg=VG^q{T
z!if(UFyVJOK*ZB#n!1<?^Jq)l`o@9C7XG)X4-;~w#;L)wOC&xuqg0m;jfBTB2j|l{
zJ@-3Fh62cr=A^k_K9<ca+24c#R!(lo_?6Oe-lJPi&hC08AE{u)m;~188GF0Pq|vi_
z5Z31l&_z^)a0{7bEDC*n@rWrUGTN)PCz0PYWh1p<hjwJemDw0x%wAf3=}PVQts=*X
z$@eW&Pv^83SYl&}Ex14b0K5=746e55uCCLrv!ZTh{6-X-dv0b1>NdrLrtxZb=3I#I
z;l46zD95z%1@z($&Y&5b=$d-#PJ^?lxvk?w<akW|r(43cAra^WABC?cTJI@{A&UQA
z{Cplmxk{>dVOAK%jRB@bmk&VITi+k;EpGkzk)nAf1+9cjVXEz%3X1DJLWL?~!@nFJ
z?uM}hUDKw1N5DJKth%SOuY6581Txm5`221I{i}mA?G9y56reUVVbe;V<%O+n33Pwm
zU+T%SmD={?+H#*DTx1Bhg^pHuT(Er4lmL*G`|MYtuH{9KN*Q6z(STTT&CRj>YSCc3
zz^jD!?^m)AgThCLZbEqngTePp>nm46MW7l;I9}<Tab(H4)KK6t(-NgYpla;m(*6V@
zM%40o-1zf+3~aMN617r^fEG7V{2pCt#dPBey!EeXC`o9BI%&T{S@c#yv6?Cu*XG-$
z-bZ@RH2DK+Brun6WW_&rgm!UhoC?{macB#55A$5&CMyW6@L1_U?Fh{i))9!9(DH<*
zm-+53Tn>J!^^~*62e6V*Z?hhM(OMFn2GWIhnhsd3C5$(xPtBvwG+7s&q`YS6{}%8)
zCU6(<LdLsOM$gO1H+3^M05xxl;f~rD#<wG4h1o>a+F|Q$V+ixWb8eU2<>`w40*l2L
zfqf~k{2RU*W6DpC{b_YGIwXK`1nwpsy=mK+gpkuWO;Bb4a;r=0k>I`6Y;Ab@TuMz{
zNqM(?_Yogkw3ZGEaG~7hiC)5#bmY09Mem~6b3W-k{;RiFGyF`^^bec<pc!#uwZ2!?
zgy`c21G6uA473Tk53Jy7x|pG%&Bu$1il<p4wy${9hJ*HjVH7`?Uk=hRUk(wDAL=OV
zw61QDgP*5|I~eHiOm5sbMAwM>`8e3dj$u~#dB~a=Lk*eUgk2MvoimRl`Lt`TwVbHD
zz?IiizsevPE!DusmQid6oEr^BJz!CbO_EVdL8zD3eSWy)sclC4b23cqC8xl2NxVs3
zI63_{5)*IJef7Eo`z`-%_hj5^27-3Oce$xC@vZuj`utm9Pn2h(zrg(h%Gr~HQ7qLz
zjihf2&9wW_bE$Avrf>`C#s(+s&9|H6DvSeTKK{`)RWZ6A<fdijWzy&4B`?||fLWm<
zGd**qMEyM_%Vyi`$es;LT7jxQzHEw_!|gX7gUg|?>IEat9*ZF-=V=1AR@RW_bsuc(
zyiPhAfgBh~Y&?wyJQuH9l6qkqr>Mf9V-_K<2TD=<IOws=exBn31H^>kE~ylQfvu8r
zpvzcMLd9I4c6{JMWYG>Zr?F{)sWjrDBxbf15I6=u1E;;c9Um#J_qUB~m=wCBn}M6`
z79p+1kNpKC1KBX+?lQgY1#b6Do@E|NK9tc-Ge#m-sp_eB=t)D^hn<reTN4G$QBH@=
zy+2OBlp9?2i~yvtfF_n~><o;$Frqk>4_oRTtKCp0l?duqOf30T^uBOy&DN^4fJ$ZO
z{1i_CD?`?{0T$AxR=-J)E1@}28+%TG*Lv5ixxjs#xJXKiwo`@bZY{K>-VavSWLBLM
zpCghLxH{;nGW4Juw(o~7EKt2q+YMZdbveGB?+NI;$mq@RdR1d-Y%NO&&Pt+eJ?Fip
z@mFK7m|;lD-ncOw3G@r$Lj8wB(FgD=6gToEn%Q<yzZ5e{)rLJv@W~O}boW7Doo4Qq
z#m}uC<`R}5X!Vp{28PWlvCBQNd4MKA=2%vj#S1Hj_CF-#K8k+?E2x9MfzE%&Xb#yM
zFIbAj3%<MziwGKit(MLo?M$%X!R5ERDDMwd#Cp~6z=roXYGT}+=b{e8c`w&yWfk2q
zNJsn674SP}a&T*8NOm%Y|1Kw>@cf>7f?u6BvjH?iv~Fglb?h;aC-PSIjeQK8MzXJc
z3Fc$Td&KB*dK|+3R%v+%8r;&o<+*QvfYXTrvIH-llT+tR9(y3CQ3I&4o7Y=Zf7i}~
z%H}P8b~<{shQuaTyMU)^na><EDQ7y6xv?|NU0V*>UvkX9!7Yv|d@~&jSd&F`;_G;<
z1EU?9Iv{kQX>?~(Pwg{e2)%1(-ONekxQMeuQibExaF>JFlC2|3)O+kOlQqOzwaenR
z{ZX_$6M}3PWl@v6%x}lgEus?U(KtGj@@61WzoRWLp(+u2R*+_-#r>zw!XQ7fB(UF$
zeb+6Xu66SNF@{DOrl?F;gEj@h(Rep~)yZ@+=m56VWv&G?Li{m3_jQWrtr?lp^du4a
z!mA|sGK>h&jbp2Z4`i?a0lF`PmA76M{jh?7ZuRH-_}!qjMepLIbcZQ)L(dfI(O=fX
zQ&IAu;G}imnBaFgYx{@f((L9el;ZWboE~G>*hODBy2c?+_A6sRRBZghvKwc2m9M;~
zRZ+gp8%`?{F+0{r*YMt9VZUBr%j$|%J>ivbPfynIdt5~fvvDF0-+r#VeLLZm=GK49
z{B_X)RF^;JW3tn4%XAB&wCEmBA|QxyS}wl8twT?bMS>N=Blu$Jb|yO=3`0p&H$a#8
zCaO*=ETmr9@^ZKNn1KE2?TMe$(>JWtPV~eo6BuBLR<;LCt?=*YI+rR=2&dTlob3tV
zwwJ*I%^E!i`Z9bNVNWB9oRt78vW7M+9;yJcP8pqRMR`d3r}{?*j44gowTJPa&yFP>
z4oI6>0iE=5t{~M01uTnHp)_#(g!IAZFXeqLqE#az1|Pm!r1<h1>!DqQtR@JM4ghG_
zLP48plK=>+_8#Huz^oNV;DNCqC+?#<Q@Ept)#$+jGc(z=4D7%Q4H<jtUQ}_*Si%6E
zX9AX#ENs`*9x2+n?H}H8-=CoR6C;z^;b~&ERlkr^JAjui%IMu!OXnEQ=y*GWWvkf-
zG{5(fv)P!>g!!|vrXRo__BNYnH5rDVJr$Wd{7mKsP#?C=#D{(|_&IFY%4#f|EKe{B
zkM0&%+=?{pmVd>Nw3_^Ifo^0(pf}4aa7=mh@U5z(465tPW*MF*xuWdF+HhXsabhjr
zl>jb%S)cvO39xzg-{N%u@BPL-t-BuY^$i{x^~np;f9SmXfL64r(pHvDtDPmfy(?$3
zNIHDJEFe66IHJVCITr)1B+JFXY+MS+f44KG{S1)&gc+l#qMRw~6%q7|xs=B6QnOIT
z9vHT}lrD>c2SmO7FO$qa$FiqW<t*y-xBUIHrso=VC-wKtn7KSs7;)<*09AydGeivl
zaUD_xA+4dmcrLwq$aJz5B4Ue~sH?10eOwL<rIi+Q8ot{-YxO65;%uK*R|VF|FV3~L
ztj@e@!dm_v3rbrd(`zfWtU(zUOP+w_sXnL3#m@r=5>AfzJ7#%#+Y0UB1JB1&7_`@c
zL?$L>E9KYk{s9-!n{^f|bOAd>z7X+b1zRr*cNuuOhdxEiXu>i&-ftkSfi^*UM^t#q
z@y0uC@rQ)<Q+xL=q*%)9@z>?xy$#8lO__7tLnz*PtjZ7RQBTPIQT*Og%Ct#u12%=h
z@^``#bZ150Pk~e^MYA*Z%}?f24T!Z90aB~)&Drmku?o?w84=O4*R#PYg%F@eJ^I=l
zvj=b0=ZW^EIL9UBvxdt+xAnRfkn8u}APaIyiB<;YcFY3(ZAP~TYbzH8J!8{&w0UD#
z<ImV9igtHbM!q5k;q2=H1^y4WY^F!pqV3+duP8G~3q*p$a+`^I<oek`<N=32k4907
zr7wPdR&(&T7+$1&I!bW_5dV_xbpn7ZUh2Nt&5q=mgJb1x8bT<=JqPY1yi<#zXdqAM
zW63g?%JgQC8b3r@-EmzX6=`+K!1AEc8+>dF`>VO=w-NbqJC)NW`cZ)F=!LiQ80nVd
zSyEye>CV|U)p9C@-FRrWyN=kk5Vcpnzgtx$aLEcH6_(arcCgbUQ1)?b5PQp9QG2fI
zI92TSM^e;CT>&cgYcMtGR<0i)ZZW?F5MirBMK3B)-syUiE8#{=3?__IViR>$EjGC3
z%<TRN6gs;_6*v+4v1wZv5R;hp5WV=mX168G5896(KjOIr*nVYXY-^hH@Vu?Zwnxjh
z{E&4S5ozb1e%(>B8SuG-K0E$k$zUGPD2cAz61fa<)SU7jm5Pk!qJwB#5IxH^6?1yl
zD&TaEb2(c!9`NF2VI!4TEsyk|j<f)Beoke&7CN_kNzT<gkqy$mIu4r_>-6|=a7Rpc
zEhEh2E^Kr*mgS@L0VDLv(mmxs=h&FR33GFDC*YvV904>BQJYwI=CpC-5~@3b0m9{;
z4~t%xtEuDE2<<7qu467~AJN~RW0gR=&ueEs1Aj)y)&|BPb)ARMVL+F=Q9b_3zxOI#
zB(1)4u~XnFTvx`)Nksl&Okdv~T-VLEo~39UB0E7Uhni2~w@O`1uwfAMJDI8yJAGeT
zbZ44<;(_SFL!nd-4gi;$CL4%u0=!gQIUGc}miz-Rk0Sw{aUCYB;~Gi>tJ5dlQ&OGy
zp!fb9s3Bg5>2g^@zdej+`5GqO9d{2t%M0uj2S97%Hj3?y1?Z&;XhekQ18W0E!xq=I
ztdNc3!#Xh6NIz>11O5cCmM;wr*}_J@ixmo9RAU03RkF;qK8slKXbTnj`Y4BxCh~+S
z@9?J*;$0&*Ev-MU8xoi;d_-s_gGCe>Q=)SxS=dC?l-ARKVkpuT(<-^;0V~i<-ieiG
zB{(Vq{ENKbn&+mK-=gn$$)-urW!g!ThFej!S(2!mzksn$c~jFoOIn8hUY#<#i$$gq
z_l3;lD?VLM=UuR>ZqRaiK`Hi8w2m~a#9Rr;e3Jotk&^#F52*kOu%6un<{CgT7FPhf
z%aIWi%!<?xFw3d1T}Vh$9txN!CC_Rs+DdfyPT4zjJEWhMsm*_j)lO9&t&GP6?xtQ3
z-n|HK&A8})zN(=l3jkvum-eanw!}u976>3VKDa#|&fSTI<G)4GSbofIG3LpIwT1GC
z2yuikfFyao<x73O&vt>f<o`-t+L=PYwV~j~n6k~LVt+c>34@Yp<-V*{X*+!6e!$7e
zZqNIUx~<9){`^Q!<JS@SB^J{skUr)-X@Mh_{{l(;qd*F7hy0$<@!YVsUT%(-k;K|%
z7icvCBjwM<f1oLH)#=z}-CnwMg(Njs+3eh9T4CgW43qYPpihF51k5=aUp-0MCdr7T
z1I;|qlEa?@*vR__sHE@ZZTs%l`bKg0wYj|8T2sNeo19BBrXkuX-8O2Z8@`)+z|gAy
z<v9R?S+oRxOtJl*-55ZUHFRjU_2qkY7dMO8Xpv6j9w5rLN!9L#=R`aj{(OZZWArXn
zA(>iG4QdfK?ZC|)sC|hXRKK2_)LG%HidWHkkn2cAqs6v9$v$9{gAdIJ7jM7bT}fuJ
zXr*1*I*7a5E{BeFEsq{Us`y4=cv61!vC2wv0@Nx27g|{HfS#Xv`ZfBVEex`op2<xA
zT+YTtyTR=SqIkSX1DI#Kl=oQ)OA8w463!-zpV!V2nvW7jKbr)zERYy=x9(>!5=N^V
zbm>ZluYB$+!Nj#!z6OuC#zATta0(1d($edjlKByOfxtjh2J70Q8n*_Cue}S6|2>D;
zI%_G`7?cD6Z;g!c%)wcKZ{qoC{9tD)ZzKEX)(LTY1B+9~3(*5t22|N-#|^#%Geo;*
z$7LFvjeG1X`ttiY(Bt|1OtUZs_=ADE4pA>gyOE>aI)%9k?cxa^)s*;-doran;@e?e
zMeht%(?nO%CKi`fJC<gA??v;+xQ}m0uPjG&S$NH}goDE@kZv|@4aMfPQUL&Rbl{QB
zd#UJ-pw#5B*d3t_lf@IQ<o#U7KlS}S?O*+i#FPRiOTB^0QC_3*ip$8VgF*n-RmOf3
zFq}s9Li_Wu<p>~_uyM}B#`9qx0#jbs6)ez4vd61w*usrBNYGB@deMg_ZEa!IxER$0
zi$1{<-xiy??JpxW%}74ON_J8Q-uCgr!sK3jK36I3<>cHPJ=gk^A^8rrNDghfbmMF5
zz-Z+I>U}w?(i9zj1yJ_TQQUUYmE5Cum!*R@3ot1c0svcoQm1k<N4=Lbh_MG=x!9?W
zqfTvqplro!Tss;FB_n1^j-22H8J+<<_2#qkw4k62n3^ZbBQJ6P#yDJCsIdEo_)-ut
zWTiiw(EJy(RLx8SaBha(ipy6o;g3clXIu2gbicy2ne^1qw$x<+N+Q<aBF{R>JwU%O
zvN6u@&gnw<f4K7kP*~%p)AdwwN(j-Xl*Q~x>o$)sYGPHpEu}97S({%H!Z^;a^-tId
zsi!_+7EgcuPz(w@clGwzGIv;La|p#>5Yk!EqJg5b#`uCby02?eI{wcisfvwizMUJd
z1xg8ApEmN3e*E+7XWJq`;?#(ZAg6Kqq8_FRJ@%Y@FoZF8F?8A<91N=S+GzZc)e8PD
z<{qS3HlsdclL3mP1Py1hQuaqvB1sK6v@H3<Q>TR>YNO&Y9c2$?vJ0|c2>~Jp?uWm|
zHEZ_4_G!6OsK%_v;ykfWB9SUeUM`Dw6&5UyM<$)dZ4J6|E;YW<i|IT{9lC}qfV0pR
z*T(F+bA{9&9mTB#ypHKiW~hxn?V{mZ@b=d)Hdv0XVlH)T1Twiusti=W<aMiF<}nGz
zrhkO4|F$OvL)1UzkY5aIsY`jMTVV1A;jQ>C@M!6sEX%C;HF>0@-GwtwSqY==Y?X_5
z1TclgRTqHyBJHTZIKj9dm70kF;tcs4qO$+!j^w94JraPK8i#HSkm^p&0rRb>VO!u|
z^q-qkQnOiI2bq2VSe(Dd^hJG@Cg;FJ>t)EDj#9a-K^a5@AAm8SxqE#YZ5YKVmr6en
zDt%o!NHj?l`ZGhOfAiMrsHi@w=j{!0Lg;mbqKaktul)(O_vE(~t{C$Ge36~VizGb8
zi!}i(G!r~DFS3@db`5p?=63GK3r1!y)Wl}l6}*zr|InFsL8AHLZ`!5R7hdBI-IeCh
z3swWn311V0{ut-SIm<m=UC(8mmh9ElmY!v}bkuYUM>Th&+GYneTd~12b)<(Z-5z^)
z%uPU+x13zd1r}@cuG!;4A+O}vh;X+#%f2cqIw13&B<WT5RL%T`h1lqs%~@MdpTlCI
zeft{|K7<3O8?3fnh^BN)u*cT)CHS+?R<QRoP0#{>+83`cd5f5iQjQ7n`nRbn@pfp?
zv`kI3Jw@b;B>QYD;IC(3Ea6jY!f4g6ZzkQ}(h@|WFX}zU7l~~>5XHbhUIU}MzbTTy
z@xSbvCvz1RNa$jh=v>@U^G-cW8P}!X=uQ1x!DoqN7bCv5lF?#k?9vOAK1ZF@a$E!v
z5P?n3rei7)rlJ)#kpq%}d~jf0(~GOP$&>-+nrl?6)G#u0FF}XCc(*Zw6*K^q$ioS3
zK6@RjRA{)X9J&5A;7?)ix!bLKta4F=qQM!!KY9anhHh8gc@%Sjg9FEN<w^2Ur>x8>
zh3Ei}2+zY)z)rd~Qb86RN}SuwKhXKxqS*&u8=h65Ub4{89KHeR^#Q<_G_-CSY&mJb
z2@&u*m*|Ejp_1Rdr1>!|5((x2pVBSPF5%!GpL&TuC@%``wzUPnq543+0%Uxb+Vktb
z<(c4t*?hMqDSIg=XXV*#h+9Q<0|45amp5a-Q!$A)@pnOojcq%{WuF20p#OabsK)U=
z0DE~IF#=3|Ws6BjB(&U%TD2u=Yuf<R#!srNIo_+P^1xhSPU~Yte&eq)?CG+oQt`;h
zCIxtsykRk>>M=t6E9$^egLUE2CVH>gK>MklM>uKh`q*JXRbQH{kk|a3KXmMGu7Zhr
zB(bsKO)p`l;VE2k-*$i|fn2g=8QwrG*1;V*Q3{|gQWC7Kt&zZ(%^fI9{HP#tZaM$b
z1xS*(>vNAt8-?K2?L_>-!IM}T3$BInGvN5ljOI_bDR<<CNWPagHSvf?zCRw?Hp7`%
z7bj_4fb}v56T^7VCAQ*)RcHZ3Qfk25R#si$`LfF8mW+%ed_ew#LTGw*!~SY{8O_zf
z<>BSpd5@_=FQZMTQpOiuEuB<U&w?+?QHC8O^t`Twp-)c{-1z|G@?9m*<;p=pVrRgK
zyFJH@XXAF>`%PzR*j}Hsxj4=vl9$wU5yqP&katJpxnPgQPW3X|5hNisuaEJrf$oHx
z`Y0^c5z(U9))1a1do8J#?vLuzd*TPgU2YRj6wca*fqS;YarpsipSmsdDDApq?_)Bg
z6%(>GB}+d&XSotQG<0<?<n(pji#9r!g$@xjbMxpsV)7{q57nec6P43_{7wuZOqsHo
zpkjUko<bKe6s`iZ`o91tC4aHswRJF2m&E}*3T$oD88bw@CzCW02<eXz>kx791%uEK
z+5n}bL0V%w52*zifeu7&UtfT}okvyGLYFO3cwJu!_md4N9g9bRy9=(70S+gLc>y4+
zHo$--PK#tu`IVd=5nUS?m~{U!YKg9uciEc8e3E5Yab($mr35nICjFMv1O<ZId7@$6
zj~LBcB9zlbnoEq{{yI1kA)p(Ik8%ojE6M-3uy~2e7{q^79p@xm?_B_(kk?H@4o9AV
z9Ji*KTmZUyYKkvqreJ3V5YBvLkGh9G5vwsdyi}*WsB)7lC8(Kju;&Q}EC6H~YuP<6
zN-!bY4>o5&)-n8TycLfLz8CuqF!%>6ckb-0^wmG?A9?{e6fDIUU{5>Vn;c!`GK!+k
z+S}&rqx#ghq-wwmM6kG7)#(|_w626qxu&`Xq4Ejws20_g<(3`__UzXoSLzN)!b1X%
z1VRL}0p&<}@g)^8j>-T~M1MTYHtm%D(0MX&;ePdvVDF?(A(h*p1t7yX^Km)m3Ie{^
z5;R84;;ewIHvZ~=+Y$fqCr~AlT{Jog=%cueKMu2b77!nt#Ajw)bS1c5Lk^Q=W4-KW
z@!mZm@V2ac=}n?`AV`N>sH)zyg#aK<9t_R;Xd!TY>d0LaD9^3cwY6&z<Q$xWnvU%R
z#dOK=3%E%`d@ADq$o#8j{rv%UN;NtE6h{AjJMUi}l_LwjFNmHZ`^Uxok)H8~?r@OY
z^;-a^@UqJ_-9L;M{z>clm+a#^fIGYwMTY*<miwQ5N<I|;4tTp6q;vI8Yx$po+rNB>
zzpwtLGVn6uLXLkF>i+P&f0l*S_kQ1}U!OJa|Ih9d1Mo8QUFD4bqe~im1w=aAuc-<N
z|Iugv`<wXZ6#<XB0Wb58t<C#?c1i#LqWRN${(t+TktP~m`I`msAO5uext9JvxqzM<
zULObP<OK)wWqIlSMoYV#`zX4u_9S^=kXI(EZnwGp9Y5pcp1ZqSUCq<B<hf;l^ev)6
zK+^xsFOn<x%ZBn9m5X<&S0~Zge(O<S2qNIf{qt)?zRJJ*=?#L3OiiWxqzt2kk??t}
zPwVdXfa3iK6WNW^%yWFEZ&lTf#lw&dQF!2a^cjzf71U*EaxHlUbABjr=HTM&Tw7T(
zavOl(+CkGc{*Rl_KX2yWSM~R!gO7-K^osW|5@*=g{ajXO=PT!gB(KN|o?lic8L?$&
z%jR#Qw#<eWw$P_Ww#NA-&;Orz$F@|w&+IIZqRq*^%h^n-pCr@t?K<36gGMuboxmG!
zW+|MREpkNf0r6_JRR8|J67b~siOQOBVRhDOflC@@*H!-YlKyWI@bCZdoyuUgsnL36
zjQ);&?HJm1|M+NdJ4+3%xRG94Sv<o3@!x!ri!2Wwlw+zA&TXte?^1VG{QX*ge}8{?
zvtWqEr#h(GDxG;t+HOb3_M2J}qlWVzN;$lYHJR@&FnTpL82sz1=u!lpqT5CK{N;R%
zn6z|4zDm@8dSiKgiICDS6oarW=lui>fq%?Pz_9Y6?pb>VEkL9Tc-tWJuW!cn8epsT
zAVnNVxUHlEW!9wqB@GR2F8-%GR<JG60+mG;V^5M7?9wT{0-CPG(V#U?D=})imA7xK
zbo&THSd*FpGxqnk%%86BI%B8yc<j_w&Hnlvw!%d8O=9qk#%21Ix59Yv>5^L6p;~8?
z@=Eje(%O?_jO^lQLLR1#vs!j-&5anS1%j7vts1wC)0;K0iLWh831YWL`<C^Bs^mZ2
z2-ZKj(f#9xl5D46=6rj&9kx48*(>V#9e@t)NEG{wEk_cMZ@EHw>wi}iT(MtJ3DOvz
zvR=YuN^&yJ3_$2w?!^Bdi2hVatXI5>3pgHup6o=`V7AZ{%|Lf6?sJAYCr}l48Mn5`
z9yALJ3p9`93v_M|ROPg`4gd}_ajyBPDiC(20g)WGv0=Q#2+)oI#DC7j$jFvyYrq6y
ztgNM1M-LMMoSpp>piOSnX&kk@ZEDi@ne)e+YU&M3p6)Q8!&}-SK-iycotShf3M9SQ
zcAlin8m#M|-H&RqU<a{*36n1eKTk1}IRp{(f~X@i=FarK>z?=TU(GFgqAt=O8t2_?
z*um1N-UyC!pKk=&v!V&Y+<A6qs*loxSH1TnZUT2&F8tQ2(eTn~i0OIWM2#gx697sO
z0+#@K0RKSX!CPSrmN~P>Z;TFmvbraPH9y~S$M$n=X;^<?ApQMaSrWnZ7=N9e@||nB
zCN^Mgkg^izb3P*iRkW;0Cc0r*O(KA&d;D0o>=4yHN1#fjVtgFj6DsF$%b=yXN1thG
zQQsM3psaKOzdd_xu|~w<Y02MV)m99MjXcd~XZs2E(NUPTo1YXyE(7oQl*pykf6};?
zcc(f)Gohk_6Z7W!#D?AmJ^<?k5Mht-)1{`yepUyjn5il@uV|3(3NVn22eA8hjEl)i
zQ9{Ik;+2D`bvlmP1Jg3(iV%zYxaI>E5iOVYu<|<y3?^f8qXKFhu@)(I<FFHYIh7gg
zvuN6q)-M=_0*onUy9b+7bfXp+Im~tHU!9$qzJTcRwaK@pLZKG`05;E^Z7pCvt8Fx6
zFbSC0`@0@?be8}k{Bk-N_EjqIEXDM6u(F?L;o@m``6EZq&8{vdYzRfmw|n;<h12}^
z->0W&@D&Od*t3y==7d=!&CTCi1M+&32EZp4%LtKm|Mj}gf8z{QVRU$KvXZs0Zmjz7
zrRHnOpf5#ffxmY1G0|q}J7+%wWq(L>O3LL+yO;<N-z)FBdU9|aSof0nUVGmFlmCZ}
zuv53T8KnzFL9zjB$n)tmd`C+XCXmqT39n<WO%(hRcouz@TnF>9`Le#gRE0S|$Uj%)
zb|z3T?gpGOpSAtC3j&``$)4L_7L+NTCCFQo%01t?b(nd!Y3|FT=iO=c!-hF<@wDuG
zS2lWfu9uNB({K6otV4FsH>u<x5m`AyKt{^$p3V2S+FR3z-ywc^)fVUO?hf`2jAfLT
zMl`pyh*TJ!K07oU*(PC{cqv?QiRikD+<>bKcKs7@ls0~to*rHvR8yE?bnS}w_Zzae
zgTy3#nc0H4SrhLK#t@Geui+aTmkD2iUhIjA%um-g#;b3_w^fJ$=<_a;3V(bpw<l1O
zHC-%)Dq?MIrGZeNPF&L(Snl57Th{C&_{=cc_$C2^X?b4P0_y0PE{o2_7iKW$t*wDH
zNQPBo;}ge}H`Yv-=%2n$u<YCMC0SXHl?sa4SqY=rv0w-g8_ax=k;`m*VYkValtHRi
z*7fO!<yRTtWJg=l=hTC04NczUVzW2Dq&1}n(5U{vo+9x?Z;n=d2?9AJ0G5dfyCQo&
zd+$|Hx1{7TdjiXsj>t=xxzi@u1445RH#5Kj4^g=u`0EPR2WT6O6L38q%MV3b0eN9R
z;GhccKt>m@HHUT>FTNH*e1l<f?er+~+-ctSlB6Ex9ZO61<=%JrA!Sa7{yvibzUt&Y
z?ULF?Y_9KDVX{tLbom38P-a+)^Zvl~(+%14J7*u!o>omw<u6WeV<`gg(F&;|Hn8n)
zce0$)Yqbfwt2en&0Qo~t>+;zmv-Hkcxa=B!`CW>AP9blZQOz)+^ZYOxY&e&?*Uf3u
z+<MZZ(Z~H4meeRrZVp$2fo}vF6^@w89$v>T;it@T5Za46+=~LmMn_2e-07(uHuGfa
zF?Q&Y*YHSx)y<x!0|wmjI2m#N_J(n4<2B<@C`<~<T+C31{UL}Qi4M^EYb#rIB)Sx`
zadI`)K65y)!UN9)9eGs}xI!;{I))5fIK9$#?xy*+?n=Pssr6nNQdvOhPO*C0T_Vw7
zuMN>jMDRD%;bG2TtuK%EH>1kjGn;x2Rn;vGIlS-I^wF8=%vf(<ACRRT!zoYNmmKo8
zOij;a;S(1*m7S1tN50s08Rl(rv54!UlXoL3$S*!q<lHkmW4Zca@G5)!P11|E6jTec
zLas7CBku^Rh=gOeHaC!Sr~7>d!m-}oP;VD}7~iam%R_FBVKF*Y;az0@U818fsXhJX
z;tfaOTo=ARue_(A+x7POls`znyz+3bghF^T`q7l945yEqw%=Tczi{~RvQUv8@v7N`
z#)RlY(x5L++&eI1i(2z3k%uB%$J(E6z87JFI(Je>DEjdN=VMg{%x}4Re1AL1B+VL`
zt4ZpLAPs_2`kcN0#58QA#yb+fVMcl3c9B04IHg*1mePWfYHNbjlbxs>cOzRI`oGwE
z$LL7gty?%r$K5eI?pWP%$LiR&ZQHhOCl%XHI<}39Z988*d%xc~XY6<Xs~V$5jr+PU
ztu@!2Yf7Y4?QbG->M!}1m8q9@WM+Od7VT~NMkVBYBj)VPk>xlmH_Pg&SPB3{J73V|
z|I~1vX|ihfTC^XI?Q-0UGoUSh<w5fZi;RfKLz8BUr!r65Wr}ZXYGV8=S)Yg9^Yewo
zbG;=X%H(k%Vrfg!ei=n?v7#@kRw2^Vm=y5}z5h{Bmdp2VPbRxgm>2?YcAB=^zJc%?
zUG8S5Lu3||D?X7ye<-+Q9#I_6n{AhfHhwP3G^{BkGXxHJl&>%!$v<E5Twy)0CphQ3
zFKxpk8eJ4mfrq+nJN}%<0j+d1fS)vEvRB&Hvn^@NZaderoE)U9HEyl7eZGm?V4Sr;
zb$7ETghOT2(AV|%hd5?)%bSPU)Z!a10D1H5d5WUEW#qFTc00tnn;X=|wIQ{~)t#hI
zZiuGK#_@c$jtpFIT^)5LEYXjA8PFs7@u9R_O`GGy8+og)DBz3vyiPV8d@sQ(zGJ$T
zuJy0Q?U5-0svq{clE+vAjt$OZ_^Q271Tvi6DC*p4zG$|6HD-~Y8doL}Gd9QFaQEik
zxVFSwILb2X=ymQ10zUWnRK(PcCDZ0E>3F{R_VKZ*k|5JUAn|;V4hUu>zhlz9#c8`9
z==6p&-uxV>0&}aUVjpcteTvZTF2rhntJh+5GLGV-MD|@6SzZPiN?Ov^p3jV}Fjclr
z#uDF;fJgDsp5mGN$bqBm>Xkx>lQ}stKJ!l$OmU-#ii;=LKu6aomS+j`34(=#?Ql~J
zw%(qmq+Hm-Yf&Rx+xa-CC_;W+b?@4DJt`3HL4c42+e$v#C<GGD8XE00$QM1o!=IKt
zTpW?<LlnVZq^ILF%>IB8AY=i(G(?fyt}egdHk<p+nyM*}hoDblHr?+*dW~KSWfN!k
zB8}a&KVoz`-I=y2+Ncx;r+Z-@u>#rxdFklpi2geGb5bwN&yUk?&>6MUSzc=l@p!qT
zt|q5acI(_^%>3xB9g<E=1k0Vj?n9!9OeESY$kgk5QDfJe&{2ZqYcrc87d7;uG^W*T
znU%HVJ0OW>>nFN);BReB8*Ef-G)F_Ki%v>nX)qkY*@Y1bI-aAD_x5hW(2<Qb*?Qdc
zxUHZ+pZU-AXbOoa2}w;YaWqG#Q?ye5D;Z2wY%;fArZf8l*SxgEl|o4=MZs8DW_0q*
z?0Xq9Q(_X<Oo*i27N3hZ2KbJ_K9bgL%AmY}!B#jJSX)~Y47aDi_jV%kGYZMlf}I<J
zyCa$hk*qK8{<-f4Lx_3&0qz!*|Jo0H!zkF<bAr!QfTWL#z^%&ratw(`@qCoh5cS@#
z;$4<Y)?mo!7PvSpd)DhK0m&83KQmN=TCdKQaYcOEI-=##CfLt&*Ol9jGojlagV^*h
zO&jN6WwoaQDpEGQUXf-(O(7p>AgkK%{ve&o$MD<}mQOV|*LL1`Xw<zR;mm8>%@2MY
zV0j7GyJwpZ<D@#$7YP?D2q~zw8(Dzk_&pGT{mD;|5Ea!W6xr~itgfoMs>z1?x&TO0
zra0y}<KqWQmId{fQqw6Z-r3=X5wBm{kXBui5~~$+Yiv{^cvNlwIs?HB@eN#calXm`
zCDb?^ASd?_0Z#dBVZey*f#7JiK?ok#61~X$`?sus05|U3nT!8&o~e)ha%bpD0Bbrr
zK7Lz@w<{)c<+Q+eRnAXX-4MXvzxatMY7?8i>EY>dadCn8(Ed(GLs3yTlQOb@qoR$~
zS69s-5s^W&X>PjNG4R8}N>1+kc5#*sB%fsni>Dl1ZegMSru(TwlXTKEx^z518ec*n
z<RK~l$sw3hL40c$vYp%(RHU|+fCJMjL3$DW^9PUr8SEDoRkqqhWMML<2R^;oEG2;6
z3dfZ{{r<FhMn&fxvU>ku>T^XFnf>i*MtM1vL10)6rANGn>;69K?&I}Vbi*!JrP>nU
zNuS;Iq@S0n`3l-b|Mxij*Xii@1=(-E+&kCrU3j)vV9=w1fD;OR@AV*Oeqmv{{E|zU
z<?MCK@8Uu3h7&rt8f#$IYbq_7+bs+$TUFqYK&4Lx>4~Iix&3Yy4bc^k84UFIe2;&0
zH3tn#|3-{qiXLWp)fLnFUwBYOQ`N1ou(#NJeFq*RoRMVXFKT%OwKvNt8GTn$QNreZ
z0<EEco(RvcE*_PdiaOq#tE!wJC3%d{pWK*WL8-j#)CuedGS;DG<xgbPuRQ(!u4Eq#
zPP<<U(6%{Pe=lluCnuAOj4d)S*g@_ipTCiSjRmQxwbJIb=E8LC?-zYAouI>zLJ+n6
zW@T;rU^s~kMAIg>DE`+i(S`;gCszY*)O}Z0U2QZP95nvNyETtlMZti2il2cGv;;^g
zK)t<csyL@@`#8#ridLTd)(J!V>XGQ{eQxk@Lum^Kn38@*j9KN3^PT3-S%Ag?Lk_`Y
zLhy?UJTXbBO&J1Ae`Ev>)wZYz<8CK{kTKqCYYInJJT$xx!K635JK;-h4(IK6b#EZi
z1-7i5+<8(ah~^316kKzfmYB$AW_Iz7+j>n|G{>{92fN!%3mTC&cYK`LyDa8E=My}t
z2RyQ;o$w>1OYMrFv1vto%zCS&vK+8<z$IN|wAzDnb<<Abi!1v@?DoI}Zu~{$tCoHI
zd(G3@ZQ1f9Slr!+e+!@Bd5RfbyXEh>j^;|O^OUIhs9Dh5fc7-;vWQSzZfm(Ur_ygH
z?sC;-xvlEzftiWJMYOqA#&tay);Y57&|H(v%gx=3vVGo}sHMy%oqL)MY|tgV)gzqS
zRFvK{Z<*T__6326+)z5N)nn5L$!8Vk(r<%_qxxP>ZYCZ|ww9cMVfCgkG~|Jk1guWg
z%q&iX6kT$5uD<XiDKk^Jv5^IOW|SlVu?9IbLSoruq-LOJ6i$bx_5tq-c7ADzAtDh#
zrq8Mi5*Qhi5@x6>XlWgjXGj<Pd#b-d>_p>~C|Xsv<5#pverb~xx}rt?Zl)noRbGDn
zr|~qkEHN3=MUuY_J&F%Ygedx46k3Ha_m3o&jk0Q4N_@PilqKguTU&6=@TF;<*Xu)m
zM~7s&s%kq(|1m{s-;QxS^aaY7&_`3OW{0riOH=+SkT(Z(Q&B;G_f`dBY1!4jpa0_E
z5SJ%kt}{wWo$u@Res|`$o6b{ydb;j2yI8-hbkHGaz~DsJRe@xqBpXj>3Dfp|Cec}O
z%>17)=KqOmY{7`YpnToFZWbeGD9?)3|H_Ya#0I~;z{$Wl3K4QRe$6?+fnM$?=Bm->
z&_n^d;`vZ#+&6BRg;N+uvaK2PoKnJ2R9*@2)?DcvNj*R2d4IXjheHciBgUlD9wI1#
z(KuZFpVvkV@g5JY@Tagd>o&jcS*tc(I4ij#rm*+}OF|{fvfDG8JuhsujQFUs`W(q!
zs|mbK|6eO}3+xZrEu0EuXm}{##|Vj;)BfxiSn!ScszAO!{+)~box1!i3~?Gf5k#@A
zUw))I7d0KXIsSq;Vigh!N=%qbQ0i}5#l^xJdPyTcdv4>XnXamAc>N<f1Qh{>-XTZ^
zc1Aiqi<(N7t~<8){O`N11ex9ivZm<RZhVkfHm3y_?8bb*h7V=_m<3{6DA&apF^l&e
zOZf*2g4110%x11}6K+s~L}XO4Mf58f6Q&`x7iMzGv`^Plj)FW5ZJh{G^5Hj}&Gv4T
zCi_=%_nqCP(xS%K?-gv%dj)Cy9GAd9n{I~^!iA=Fs~3xN0eZ~NXY@Ec9lQhmJ*ocB
zo@=wSqk|Lb>7XonwX4&if_ZRYU=~Fr5^#3r7#<U2u=hw1*&{QELulyAdQnm!3Bf7z
zx?;i$SpiuC3M5`$PKCznyk9X!eJvauB82u}hQNZMar>=m)r?;6#}1W#@5IKmXLHxL
zEU~>PKvGi2yX60(ypo!X3#<o8ADX61<N{I|ARSWh&#3A3`}x#s^#jrsbN)G<{^Qty
zA%bXkwgD9Dbbu_!arj{NkqZ6a_~)6Lkyuz*WsQ`+D=8+++Z|i0-`%PxDrh)?5%0B+
zTx45&jlohsTolVwF*PQUM=_41&d6EaUD=Et#q%0ZuU2mA@Ifl6vW_^u-xq7JY}Dw%
zSS{Bm&_Jk$n#!n%5RunKk>6Pt>a9p6W-b5ueqGtWSu|5sCc3JKBZRwbqh-gu@Oxzs
zlhrERa3tottjrh23`*A8q}jA}<A?0BiYl0-g~wc@c7vl3e1`eu9c^oQN!$q>MUm&y
zpNV}Z>8NX?Cj)y6Lb7&Nr0*>x$;nv43PiZ@1=#`h>87x+2&0yOw?xb`>qz?5&g4dq
zkt*ym8)qGn;gclGu99D6VTDN^6Lt*IQAtBcRRwv_la{9j(E306TnDmEUknAfJgzMZ
zIND4|iiY68X{p&4t(CrcOnE8t9-eofs%rTxUre^0Z|!Y6=Z!b#nKwFaE=YH&;t74H
zvT{6N_P{-@k2YgY1V_d~WZm0hU^ZSi#G!X3Eh;jZ&E8lud!FK*M!G$ecT>~FY`lW-
zI@1$jkTBdlZ8Kl_V^IFcw+b;<j~2}q92}F*_YC!pz_=USIA(eca)nvA2^y3*w?m6*
z8r5okF`;&-F)vR}%gT@`7?jNC7Z8@K_V<pYOyd*saG3$z)0jQSLp4}S=@x1?ytX7v
z7JYm{0ysXzQBY9@b=KGvrJul;RZtdTNca@mbierGc&ff;UPmyImA98LebR&bxV!(J
z;M%ry<zBDC&sb@6Fxej@sYisx21mAt;okg+eY`huSWzCq2+kB3j4s%f;Yg};u&3hr
z;pZh=mfsl^ba#PUJ+rz%<CPrb?Ks?GSJ6%Q=L<Aq{@FTLS$SoVmB#Ox6AT*Dj}AJu
z9Qa62cGF?m^y>&TDvD}~A``<JB<)(oG1$zKOHk+8<J%bCLQs2}mx`q$fgzmdIMboU
z$_Dp+`|4wlhtXn`kjUDd?oVd|C8c1X{5f24Ciw<kiLdLYp`r0iSn;Zbdb$62y}_EY
z`pw)QhT&o#fdw2Yf?KJYaIoj+PP6rvuz0Ra&-eR7MeScc{Wqe8UqB(I-_w)e*O1>$
zOhQUZLAkJeiLtTs+u>l83GK<r#t-~UZdyZgR|cM*{wzqKsG}C??SP3r=1^pPO%xXm
zZRp@r)BwSko=JwJ{%lDXWCa@gM3fv;_X7#hfJs!jMmyrh*TI3Q0>=OB{FQ_q7N)k=
zZg3eF9|6J!sqc>`TK#M&qpuWh*NuxD%(q-*Unf+TRFQQ`h}3i8H9w6+Kit*vHT<J{
zzi;E+vA7czTKP74*7x^~gZEqa4j#;}abBN%h}CGTut7MgD+4SRMuPade(d;5(oQHS
z+>tz`!4ZcgG<%RIvOG4dCqW$fKt6(+z%S&UlNOeij<hg^5?jzqtE+>CsnGP1VEcrI
zd6E~?#&>Q$h>szwz=5udz$|Js#{Lh$pa&;R)5nE~ja$0{TQ-AW2+s-%;yaANFT6p%
zJN|j7cSr&33&O~+Er>0_aBw4M+4QfVs62pQa)A4EYMbZK3)TPz?}dPn(>3RjY^cNJ
zjNz*R%b?o)SEoTQNF(@liB!628_x-a7MrKezA>e#yu^^#(UI$$tewoi)1PQ)36XYa
zkHp;}zH~K6{d#yzL%OQphTay8HA!Nt7@%{{v)EzuBB7iCLbsyZZC9;$B2x@YSkQSm
zObd+T-rw8UrINaNb9P^Ly3n%RqrIy)RYZZyszAM4r0Sej9@9?_1x+M}m3;l8mCtjQ
z`Yh<(>_?}XRKyQeVVowdjJPEpq|Fc>n<`!+!c%C6jqqBMSUZyWQ;Tu5nVHS*89hrE
zCKbq-$jMR^*l&ItXYcOR9z2uCi?%8g99aafS1cm@-R#$z)Wdaf<Agt-CmFJ^UFWat
znDcdgF_?F9!I_Pgv0u#hiD@d@UF{v1Je3<okRE}xEkwxeGVJ@NznxvZ>q8CKn2G`9
zGuJ~hfc-JnX%`^W1GjGq%9-72!!@(5uHQW^#VG&AIver<f8AkKO--Ql#rl|x7NN@p
zt$o&_)Za=CmpNbX&Zt7wkZiYuZ%q=tnoS?fIeI4Jsr}hlXZPUFKajPQmD63tJsuLp
z4^P6%_)sy7E^`5Zd*_c4im#FGHzubjB+#ZpU^cqPw*Lo?`JXtZ2RsyPbH!?<Y48c(
zcfv*`fjeh-jcn4(7*Ht93bK~TZY@X*eqiB!qZn+SL1RssfpRgPoy_kcB-lvVyqC}R
zewjHF3VpW2qjMwld9&hpyNc7Q&TkXO0f+MY_&(vd|3rN<A$l+Ui=s3LQ7_Q31@ocv
z;rcQ`3vHa=^>cq%J={nfy6m(yhSaB@AHi`!PcX+iwBQhv(`R|xEict}rG+|uz1Xkw
zZa43MAwj*A2;+l1eX*M-w+*xK_gtj{4VBQ3jYE2~9+N>nVIsZ$7np-0<V1+|mbs9n
z*-%Xf%YK+o2jDQ{iPOxox&N%+(anRNCwbq=V-8@(8h{PvGLpBDIFLxu(P|oey1$zh
zR)rv0`?r#~$CuQDX8NFsoZ9B*y>42=i-YlPqB@@{f~o+YX^~t^lcC*@+ML*QW_5ak
z*EQ`K6le;{LLzI~i*q0t_CF;|wIqJrA7$w$>iF0^#BI-7SU;v+@XBnOP=0@sBo)l}
zUIO0v^80V~w&2^}y3e5~#F*@DMBUA_(~0eOUEiQZF27;QT-XV&(Y3xP<FMMLi)f0Q
zb0A<dXQFgW<u;ZlPXh@%R*2HvNEIP`mmG~N;Rx-OV4%KI(tpEci1v27SZFvJsy;p*
zx=>E|epsCC6lB1L6zJbeWuiSOQ?x5>d@e=<AsQQa4;lDU@9h+)BwW1-bq74mF7o(%
zp)@iwNNfa+1>O%2iShj=2W#%#g&jyibO!W1<PN^^&B~x;`5ATNUb~Tom?L?p=?KUD
z(vzbZw|M&%G5@pu8FSRcNdf;PajhOpA@IAfh;)XuR3x+Ou9J%VOg6W<{O+6oSQYc^
zE~FV9*Dm^yBW$MUJoE41Orrs;%Z=T#F6Ce%ZWA5b+NsPmwUt>GG&CDv8(A*LVw0kR
zl|)qI>3C0}UVe-3+hL9mRs9>w0*Q>=jP?V#eYQvo;xue1tnV2#<2M(gPT#;V!e(p)
zR2h+W#osyp*j8=7R~s!dfYiD8vaY*`%2lA^*n~_J39SCHr8d+L;0S-PRIqsgqi`E+
zAa-VQve`mLO3cm9F89(+$rn)zDyoUIfII2p6Kump$=@y!g><C-?tV*XOJyxB(-<QY
zwXuk>kZ=m5#vXk+Do{&5BH~o~yGC|%zr~q$Xqy(u16tr1+i_tSEzHX#;r%?36BL$T
z8q3Poqp+zEE>JWbF3QRazN@wVEoomBP7G=*p!1!N=py4l#uZf4$9qgkJkulPI5bhn
z7Us^MGBG)<)qUlUz%ZI8qoP_M68-Z`!8AwyH7Ny4!OAL%dQ=wv55WbfqSm|EI(gr_
zOuQMx!jhyYx2?gB@aUzVFDWmg))W0mNO9)s^@K7i)dKM2h#mjZ3jC4;#F*V>7gn4G
zW2kRhd~Ri*zh@cZ^w#1dw`n~1o*2{>{))cqEG<oEK`VrJK@r>e$XH}y<An%v2vAs&
zA%DAi>p=2D*OaeYqJYEjlI|en#|~iR7Y^<aX1yev|GBa(RqRh?!^z$-mNsosEG-r{
zM8P@89rxX>=1aufQ^3O)!n0Zb7=#Zzbb{E;?1%xp116damWR~s`g8p%*%yZF0vWc2
z7#%EPhl`*(VLOJZ)<+l74(mKTrdG+jV%aG(O=q?k+0C%X$lvHxHH$}*Ar?O;d8M8B
zeVpuDK8_x{G)oS0WUHA5?1oD}RFT{z0&1&TmY-KN6N5ZLtDjLe=l6U(k#9Mle=xB&
z7Y}hD8lVjd+)-$vv5soR#{9nV;6^{SsF-NgPgi)CqqDJaD8A#6Btf=@)J^)NyX@lg
z;dnK7?oOW?CPBgxolEP@m`Z-9#PC_|Hy|bRwNa+a%VB-}y$%i@Qt$Fy#;JdFWL*lI
z+f>kbSX1Y7Ga{n4EI`oZz{<>AYgZLgh(~X~$Jg|$te{9@sj*qL`?<C%huedCe}84F
zz?;cUjNUl%9pRf;*Sm9AN+Le)+XSmbi40+d)r5^Y(R+@^h27n8F>vl^CZJS>?)6<p
zO%0<`y-}=;NCkV#kBTbnEN%X^UPfCRQ^p)`!i2&YvU0Oio@x&ZOQpud_BIVtoEX$|
zzH4(uG)OU*=f6Ox|Ku{&u(pf7OOV@<C8aUB7KD<;S`f#)OqEI5PhQ`P$X-9MkSE)m
z3ePGk6ge)~1`Rh4LC$s}#@vgy0gN$AB2j!Qe{y}?>s83W8ncONK7obQ!h_YAl$hq!
zw{QJ<PL7*DSfa(jq}dT~@<WLLokr$RQpcyIkVJrO?|GIXn6T_(PBT^f4c>xv0XW~G
zTN2u5AbX{MEDtto!nv+3RiBg+1hSFeat?r!B=mawO5`y#FLOCN`RKec<EM|xBiFq)
z?N4o!gpcc}tzf1TGh2SsgB&(v{>RM_od;P6WV_yoS(=Ya>uy4e0j|6U8TJ=Q0X1;K
z%}#bo!c2!5gw1^JzqjuAf=FBsfC5zCbZl{0AGe*KqvH_IqwSpMXEbJuVTag-JeQ?s
zso52XtLHwj{R|PsF<j3TA*jBq@|54$T5suEGcP(me;|>8vHYY3zF#!8!ybFFBfnoh
zkCFT{_~-nz0VP!er~T!pT>Ln;>O#R{InP2XH|5;|lp{(=z6w-)(I(scA{%5IKFbqP
ziiCEhoiYch`1trDSc-_-8iI0E(jv)Ou|R&q2jQCdcz1U2FrXM5pClqgOTw496;hK|
z0w(@V2s7pNm0mGzlVCk9N=^X6*??a~ddAvV0M|hp*I%N2K#?28)D4$t0X6s)n>VCe
zODDEJZKTC^b&S*eJLK24GE^`dI$nQREKfp}YMK<BWfY5h&8E5J1XN#YxFyOMsyp{~
zoB6vJP2nER@|7hJDSE$Qn>!*lw77#d(xjy;^J=8ePB69k727}()8oKi9yD`3F+4Gh
zndmhO4R3hjT;IR{o(T<!5Q)`LkmpK5?q}Y92(Y}ccmofXMZdyJ*iYw&19OO-bBa|+
zH|e6a;4DHCN@XPjqgZM2c5{37USizFX6j=oW^ZIj)FYaI)W5{Dx4&88ARTJaaettd
zO$_~`rhhmBfB!Z&b2=_dgoQ;x^Y+Itw-eC<N#}B#e$k+^_~K-%Y5k$1dLub+&J3~*
z2ZBt}?r}uMsDQ-;&ztt%V2WTJ;dCR$n1C@ZXI2{!_&U2psD9YRCDH7Tx|CwIu|*@1
z66JAPIVJX1s=V{1@~J{CL_!>_hWc~e;d177s$1mq<FOr@3Lm~|JqjPUBM<3U-^BG%
z!B9QBx-!IatpVLc*6SDU*E2l#gEaQLi*_9bs5|lQ9l<}`=y>Ad)NcpJp^yj&QFjk(
zI`jh!xH?=g1TO0+@u+-GPL*~O3mi$wqvzO+h1Kc(93kuc0bIaV1J+Q!jgy6pLfQ}l
zY8rLXxEH~HmF)f>tn1$eJ<T6mS@(z39<OLgiI2G!1fs=<7t}@bq__NyGE>IxX8^{w
zx6N;57B#$Gjol4ZRNG74Jbf=ciV6xc)twJQOBE$mNy0r)5be|?2oZOj)CDE+8{I3B
zlDr(%aV=0jp={}D>%fs&ua;k%a{8W*xLMrd%E45n=lnqHsG|II(Qu=}7YO0E%Y;SA
z_f%qkT-H37F9;LKKYv@%M&;)?56Zf6*Y^*@-o>)h*QYJ4WMNc`K_NIEh_+@oN})6u
zx_q;uiO~;-{K-sREfybg7vUl__W=LcN5{r58@`3e37I=t^Ol1>C%o+RBU>-Oty!5&
zwH^MdrB5x3eF&D5*|U3N6Em^6w>EynW%p+1rpS<3Pa*uspThO=?dsIdaY@LDnI4$w
zqn|d@1<cWqY34=~X%FAf+p07>)OyoEvVYY!9&z4n!x$Xe<{#IWjo0I*_b2X%UCT67
zsgJ?Y_+1&7KRa6w+s%ich%woEw6us9_*Qe$Xtay7+Di)*0MFI=%$pBbpp#oxU(sP_
z-MGdkqmK_caz0;{)JStG5;orN$VE!v+|n)AEbM$?eVpZP)}%JBeWS!}hY76$w8ba?
zN|zBD-!Zb(<hs`<w9oa8?Sqy7SogQ#(Q_Rk1g}W|a{*<k4Q_qZ-qiR@m1^W!A-jg-
zsdjfEyzBU=Gl$t8b$XQ-I}z3SYW32l&Ewo2&T~#n>^jBHUtNCazV(Y$0GA)hE25K=
zl4Z55ei|7X*LkN~-qR?p*AC_MB#KGL`{Ux`n4X^~HF%vGFS^{AUeyFpku8u@{CIx^
zP8Qr-?0ZCiZG8#GRr{<L1Fvyz^qw#$cOY9(RKev$zcUnvdw)S9q69xfvfjkXk#i6B
z{EXx>j9h4VY2&DNtyF7W7e8FAuXIL35F^kdn~J#<z%5hx7mj)a3#qu{fPZ>u+h}=)
z0(Vwpcs4O>$9AGNaqy?snn?A9q$2!yL%lUv$?zk<Nj^4N*Gz{rH2+*QfCFlWNPyh1
z>AM9=<Ru_Ut0FB62<M9pMGQF79l^%#!TBwkav+Vs#hZx9hyaBc7f5t)DcLRV`Dh%4
zvo|04t>V?SUDiTXqk^>xJk-FHHF~`lm9?UUBq~9`y$}U|F;LbSTsag*3|%@iWZ=&F
z9WY?ie$iq~`E@_nCT-7&Q#&!@R9!_SN?o=0NPyZ|xsVX4Mv`@Lx`|6Sj3*EuhiIwc
z8=>C(L`+MKZ~#4}wgNgdF|jjc?~6bM%}y+))vfU{wimdCHV7O@Q?Kgg+Thk!YU;5@
z&N^IOmd3*v^vc^TC_%e`iA=%%3IbcAJ+fJ#?bOH;n;MwE??PM(<lmbNkByHTW9GQH
z!8^d#9;W;*(AgpQ`)+x`s0%bmEvKd#<0jQzf=cp?d5vlQ`hD6&PKDyoSTlrnQ+V8@
z1!<f?TFEzpp4Q$YV~$8<L+;BiHae6YckWeSE5f5u&2EAM?iyNfEvEALvnOH&gG~4m
z%(;Jl|HZ}{egynbDqLD#_8cA!;a@(=j?|WsKYoPH{XOb60DyS(nJ?3wNs?;x2SwG=
zQ%99Dj6)bJ*2%NT&yYtkyZ|+m9Uhh?#3n-zE@A;d^L>oQpKgvS_XLxrp6-~b$`;li
zNCxDCruDQu#ycOw|5O=2px~)i>$?v0YcS=9G+M2>ig?T++b|(`ZPY|`DpW=1gd>}&
zA2QIUiZXQEBZ<>6axG%&fpo0(jbP3ww%Tf{D?g`-C46$l0z~8vx;B(@UFltpAC)~t
zJnZdfk9Q*WA2ZGI`IKR1w44S8Zq#Y1s9XzhcZZNnrs5yk<%YAF4kb#5Co)`S-<~DR
zM$vEI^&A}&^(uKX+aYvQAmSRL84wn4RjM~>7b-zWL1nYWN`1ncHNRwHLPGBW&a2nm
z!+DUtWASU=u<xnoN$DKkss9rz@NHf7u?#M^!SB$LCnXw(B{Z2<t?z&g)I^BMSh8U@
z%-(n7Vq-u*R_AlIQ6uW3XXz6Ps@41U2=YI0>i_w=g$wSfbm`b^q=NqblE>_Rv&a~3
z1gYDC@+JMK_mier=aVIiJJ8u3qfgndAR4Ey;l}FbU{0nRtEsL*H;Ru9xx_3o7my75
z;x0kk*~!>TRN|4GAe!*XJiQRILipF1Y3yke9USnG1V_z#7Fs0Ioe)OV5gGZU%wgqP
znPTrooo@g=%$W1WkakeZ!P)u`%7967W@BXNZG)KnOoxwz8h%c6d7Kk3M&G3;_+c;j
zGt0h4s;;LBw)>TBWAf<lkPC#WGPYFAxJ({&aO+XD?vpkfKpp<m-2o58UFec@Bjz2z
zQ#=LfvCx2=yVM8Q`!eD2I<d;XN9f|b_Rrz%#&zL0KIQS=kL%n=C+L&F<Iz@+nsgTC
zDrJTg)RH3W*Ej-Fy^o$qiuMS*A9d1iUzp^VZLGZlp_zhw`83tcP&RxH7vz)8n52uC
zCcBm49USZj-Im1r!=WGYF0(c0igr5NE6<?3pl2ssxPN$YH4)=;QRLW_7DD>Qq<y;I
zNvrqrB!?o}`*^GYE0B&r7_`}0VCg>z|A1leXR2DUnBJ-KrzFznGpjr{?}+{)?iAZ2
zPLAOCVUD{mMRWA0=e9$HD@0L{2w}@e_^ByU1xw$oJ|&({TK1UeMP6)L)<!GcK7W<3
zg&t%^F@aBF*Zav=I6&k$ZQI2l5Htu<D!jl@2f7YHc#XCv3irJ(4}?FF*mffeOEV4M
z>nn0U+mA8Z9^!S>4)aZxZ8LJCk)E1AFQ8XDW>#>p(NT=E>DOd6k&PT#Kf6CZLPe5v
z+z&yN%atyxuNyu~Rs?4L2ql)(33cQm#o~vcSOk<?(MN}q@*uz4cK4-mLTo)RXwvCs
zo{I{Bjn@)M+7ZWz%QI3_y?vnyEf%7uK>jNBjn2@X3>;bZT5fqRsTSl!GcMltPWzR(
zjCHoq#G63Bx=~hHDXAkF@`I?_pRJ5zVbsgPfdm5sL%fj86XchDLDj(dw?<e?Te~d$
zbl%~Pfl?)OGD9BbY73O-&Jad~JLB#tFz^m%W?qHcZtX`+XQWf}X5`v{a&(M=@0_cJ
z0Aq2z-mEK&P2nO-t@0)`FLWo2S86&KtDiJ9+r@)&=OOZiIcOLXcV4<w4{nr&xk%S6
zp@eaIVS}r({a@I&UP}6<<}omVZt9vokzb_)g(3-ifGK@1aEqZrhk{#}yY20S{iboE
z5j@}(9AjyL`nR25PROFsT4bKzeOtp~hK|ayU;DiyYZa9;%SuZP9g;gH|M>V}nDGn>
z3jfKY_68w2giv=<lsTcPdAxuB@?55r5Q?^Wy5Rr9cvm~0!_E*Kh`hN$6@frY*?xe9
zf{(_Z3b^K5|Jl2g3AjLqgo3hpM5}_@OLw55t2Bs~wKuh}_?;-0`|V)QmfP0LwR?zt
zRYk)Bw_xk}FN1LzqX0wk^-J(B>^?dL8CWgtoyHy9H39l=-~Nzlb@b!WQ2s3ZpzZa?
zol1)BIB%Y|iL&zOF7~Qn*DL)JF1E_(C<F;bS<BURM2NsP1^T4h28z|0VxR{Kq7i3Q
zTG!a2#ZShIPrk(^&0mXmCv60r10||gcP}L<N8+#@FXzR~g(`%jCZlS$wP$LlF7;Ea
z=-~M)?&0k|-Z$h*^g@EoRoPJ#KCaJpCyh2Rg<9T=v)2328IztWdd)*(()#&tk;jRE
zPQAY1`+7lN%g<gIpekr(FO*3!+wF)xcn?%K0J}OVGsD3|2)U(cv%5aMTS3WPV$YD6
zG2rc&{ZKSFkGzX?A|0`py*;tUWf9W=<Fi`&lH*33Rev=JI>97}0eW{m1e~eTI=IzW
zS7+ph^QDp4;wbpE!;<9f<7lj^>Xj!Bi*fl-9vhn$`A-n{-xRy67~jgj7ra)g3U3|1
zg00=SlGLTR!3ruyLYSxVQ=9?&l{LT9I{TxF946TpsSW1<S`C(IOm5@ih1@uPzk+)p
zjO9N5HZvXrBjP>duk|K;q)?ceyQYfzo5YiE+}NUtb|Nmals0u#LDnL=d#|MK20=En
zv=rR})=azBZVC{5Z{$r1JvrUdWU&{WtvZZC;4|=_vwyMu?fuFiecwvfZn&E&v?D`f
zv``_O2rHtBUk{7K4SjwY@bo>_v8M@dxT%WZC142ou3}Eb4B*SfJS57=q47U<Axk8k
z4Qn~8<8F*5f}`#PiiL@^v1NNdBn4x5WjpS^BoT;%g?c>6u+mG|`Ke9rGp>0+e!r?A
z0Z8aybf21w!GXoCtzZs)J|E^3Ic`eteAm+*yf#svaixm<T_z4D3f3C)_S~$j?mGFl
z;55t5d%Wg@{fIN<0(@(B{FTiYwoMqbE=>3Ns>h)E`bYwKHS@ltqPdd?=}VrRj6S!~
z{fWQfc%CF50fK7PM~FWG_oqj_yqm|MA4pDp>@qab1a}fhm~bNC@feknB2f^Hg(`o1
zb-8>1y_Gu$Ue6qFm-~H1xnBvID8*SWkml+8F?C{c*@n88txl1`x$m&H7F(L}=KQ#e
zPOV=Uf;HrJ^|pCN1xH~6DEBHQV_O9eC)9rq`?ot=k;LwM#VzxpqW>&SKYx@GL>|L>
zCnNLVN(4iWX@nHDD09+RmBesC1+%lI(*W609Lf41w+q2U++}K#1-k@y!_<qzp^{dd
zhfg-po{OzI65sxL?hT8DX8dKlJxO{uD*iW=sS;|feUT^z^z4o-EDOQ+c28@kvch`X
z(jf3+7>WupaCK+r?*ry8Q#UK^0uPd9CyJ*RCUU;$yaK7+A2FCEO)|*>wt0*tEyuFI
zk=Tc0G4>PQX1pW|i^^`X&0Zr%(RN~Dj3Y4bT})Xelm^r}D~)lxhJ7%Z^Aif?h8B?<
zAdF$wU$BC@p{Qsi{EsGJ4#iL-$uQDGoh)zAaYtGWTStiutO07&bSE|JdL=`_MVU|A
z2GIZ>9h*ZS%ou4c4%wjqgb2*9n2oc#SjTCgM>EW2j6aN<*;fkq92BM=sfk09G>(KH
zXPdQoi?$r(OsbkRVOcqOT^hrnvKs00JZicyyH#+?%g?Td-io3fy{roOf<R|S14x1w
zpv3&JGtPDutAgX1*%_p9uxINIh5F>C6wGce*z}4xnDr@s+4ZP~8x@t<po=wuj;3aB
z_H~EPBj||U6-%otKCCarSdm6bMBvjttOD^Zy*zZLWWMm&LvT&0YFp!S?doN@W%9h!
z|DF7{si~+)I+4wt^m6a8Ddq;^y){^6yuTs5NpoF`w!Pgb9M_FW=P^xX{-6Tab%B`)
zTT=S=csS&=9ZeH@<={2{zxj|LFwd_C1@?l*Yiqw{^m^bg+soK3mE&#DZz}tTc@Fhf
zs&ws~(~P~-GT&dxN2?Yx275uG1<FLUT-W_;S{1=<95~=Eu)~hHmu|^t(Rq0*4_{Sd
zZzIgdJ^03pu3WIqy26^CYbNOq?hmkxgljKbDLqVzOjb5;%D3l&@S%y;)}o=ffV@7U
z0H5)upE1$;R{l4>8Y)0M{_0;6ju{<&vt-nP<LW^*D|#4aCj3D~+(%t0yGK<KC#gw9
z3aU9EQshmcu=`VEPi0&rwpXfR0n(-$KL?gf*XxS`$HNm-e=g!R5+QeQ-Af3B1h$#!
z<78#DQJ?rHR3t62dXkg4>-hK_8B}PF&r2{0s6jay%iktzZHxX#TwT=n1cg}y3r6ZN
z8B#-{-5&-NbAwJa9i!(LD4;$Yxga8JxSIN{G>_eyuyp>@-5k=o@pYQ@6hWHgF_T>?
zG4K195A-%K@^u0^p&6OTXWQlET7?6}6p-MF>HVBaW7}~23GQx#RYyY1<E|#mE_8Tu
z#ObVCp4<zS9>VD-BZ_jC3j}5flPM&GARn21sUZg?bSNh@Q77FWUEhIMDQzt+GBpWl
zNy!`W`5+d#wZ>;s=+$G-S3W_EC72ojLc9?XVxZ!Je`WXE$uHKrKY^LJkTl2&=cnj;
zs$wch9DAC1yaDoJQ`u0-y2xiO3sy9-ZoY(}8q$-bIjgra5)x=6K5J7d<^+@;q5a0H
zZpyXFKQ%lQkp0fe%EX25OnF;T9$|-jvyK&MYYPIKyS|Rs5S)L5LUs67SMBz*Uj5`W
zodhw^&YE4DEU<k5PkCFYyt}8k{Je0x>8JJFcDCYB@}&IgffFWNzNgmIZofAXK%nCV
zFHfERkwu38`3DP2fEdFoeq!i4+xlF-y?-i9xWP^|aqokKoN<k}PN3&JFq?)X(nH$|
zlVvOk=&wfsr36mA{Ng0cb4O+u>Cnal!u^!e@>1viMiG9aZn1kv?~^*IN(0m%5TZoM
zRxk;<^}Z}Hu%KIDue(?;;kQuKLfa9<WNKiHzpSdoBQC%?%0QYgXMQw4eoC-rdHRWb
zflu?_EC+h;plohHJe*M#u{(5~&6`KGZxj%xrBOLvv<|sdDtLBCeZ)i|yk$hF^osX`
z7}2boGdEj85sS7qvO|gJ*IMulMYB}}u(o$IyJkJUo67B1o39acn01fb_l|GZ36+Ns
zT&H**XL`cx!3b-Wck8z^BDZEBYJRCqPBzzY&$OqF9yI?$agO)YV&@HK&d$zO<mUYR
zyn=9WX=qd{X16U(wQAHH!G8-FY6yv^i_pP+FUxbtWu=9`YB8@hQD>#Bw1TLWb{is5
zI6Y0Prv_mkZ?{5PC;NU%3?K?MWGEO9h6#CtytRD9^_SypPSw9yTKbW1*NH<`MuneL
zh8h8EW~x6cjoaZYDdD__sVkzHPX@+X4r-{~kJixtMnm{<*z%&~pSLyBU+O_2yz(TB
z%?f5y&I(=Z+I}0olU|M^OEtNy45Qe)H2>8WQZYU~-jsD&W!)D|a5oG>*ydL5&x#6G
z!pG6q!p(`!#dX)J9hSyvp{mupVsqT_cwc~HS^2QB!1f%)l%TIXDU%Bc2o@=Gy(B~B
zy|ZroIexS3!vah)Y-{jLPu8!Kw8R+9W)(HC{_;HlgmTwdyZ#ICJ`t&!zX0hRsd5$C
zo3Qev7F_r6h=?OUm<vR+39O$laaX4oRY7WPUi;6Vkn`U>1w&DIer*T*ZAhyxMEdhq
z5WGOA21ooI00e8bDS)Vfh$a-Rww05UyF1OW$)ouEfL&M^-E$)G`@lknn5ew*{Eq))
ziqkrX2gGR$_K!;UUa2E9kL6i{6@~R(H);QkM6*tmOF^-w%)w85FI3ZD6f_6}f#RLn
z03(k-$gEU~xR^4)Fo~-+r%_2nxSJ^^xZ0d+6!wfgd>dwTMej4DJ3K&*f&`D!g-4qf
zL8{nLw2LoV^xHXmzgf=7sYs@L#=Mii>VDrhq6D_*H7r$RU^WHHF?Ny98x3wJpVq~@
zKI>vOm`*8I^^YAXx;V05({O?$PD#-*>@E+63*EH}j4A;ph9}6Wj@n*X`kJDgb07oK
z_LacO-2BLpIQ%^m5^uq7BY`yF&iGwvw#;&(Z9?FOXs5KS_x31hXdl}TYJ!quyNd=1
zC>fK*jj9|?!t64G=#xo!{ZeWwtldDgUcyJvHp)Wd{FVFOMPH-fl8xkmTt&9JZ-M8M
zUJlAFpsD93G8f&BE_}#b_TJDYos21~BImegv|DA*ZubobNN+(VAFg{+!t|#WHg%3I
z!ny6lHF>r$UQK5(={(}Umv6^S9F_?*R)ZkGXHIzb^bpb$_a;kp938KO+ujzqDMU7B
z%$KS<KkA+$RhG85Q?Wdidn61&sv86X&sdBIcThJw)&>WYIFtuM!Ulx@zZbwkM$TMm
zv9y5&FPg>tD+s=?#V;6L_JEmkJKBxuF8CqvG7GB8tyDRNoxLL^POmPzr+!yjYfS-h
z%G1u#RYgdIhc8DY#5*pdjg%&PcW>`Q1>Erq|F^8>AB?^W<tVZm*k#eLPw4S8&7Mi)
z_=)7q3gX@PL>Nw&{~?@4y3SlvLqi6n>rQj30!8~5p*^AN<Q$)|IMkv}GLSJ*j^6ui
zwkF@QINO3zj3i0<+CFy~_7yj<`7I&}%&6AXbQd;FSC#fZjJBIK49r}krO3}RHYH<n
zRL##sYuYGB6Gsves88N$pzkD;F>rFvYzJJYuuQtD3d+#8X@2fZUsN5<<Ad!GZ*(4=
zhg<PyVOB;J76W67XpGmwDSPJ^8Z1o?D#~v+Sk2Rll;dpiB;9)VMox{oNrgYS+qr-C
zhT2CwzBEJT%+)ui1_{S-|9ukk^Og=q<ee8l*$R1fKnQ~Ph{x|QJhgH6#YuH4#$RLo
z4i7%&^O4<TrF|&U7JYF6tEk-LZ>tN>0TM~XrX%dktYB%<20e3*jE_1?)|tI?;MiZ;
z(paze_Z=Vik=Nq?4mUk7OS-$2`FeaP#2d$(4<O_7;6e_Ki9bwQ#RM9Zh4^}b@9!H$
zhl6d-p4vu%A<O<;;6QoP%~Q)9;;-rREb^vAq{t^iT^WU~G0hqt#DCTnlWa&rm%~Dy
zd}pWRF9ZPUV+JoUY@amGWt#AT2PvB7#f@InVe^FiN{xk;@j$DQtiu2y8y|Qa^Un9i
zwFXt1cpGjV@KV(>K~)Tt`8g~<MXBoS@})mfmnFA+wPzLX<@bR>#&hEJ9)<MDtxAwR
zlNk9oumw2^c6NCTldW{M9so(y#MT)I)?Gu9CPl3;ujwX=LSS~5$}UK@=3fRe)li5=
zFICTN&iK6CxSwW9&#r<SpFNXhD?L5RDV$;a|9(^H@I}>BR?g0&3~Gcxr@Fdj6%J{x
z1USzBBqK{YCrGqhSkh^gK35(h_OWtc`uFZUsJ1$f5^2v$JW*_wwh(5KQsGspmMJ;R
ziB>ZShBk`qUe|>s-66PUfo`W-0H&618nh5xV1WB;=(LwMgQ(+2(y&`|vn4zMTxFgE
zk#k26Dj)on{&qMqf*d^<5DW}AtTd4+m6emgH$^||xzgwLObYVROVl-s-tPQA-re!p
z*^)s)WY%S<i_A4!bZyVKDeB^2uyi!#g{+&Y5+<1peMI*p-=^R~@PGRsOuiEo6Ih?G
z{tV2a3wdw|vA8&R_AkbYfrD$>MyS7pe3;ZpEPDU%&}dI&n4=If--lE<(1-BpSKAR*
zWTu{t$J3>c&-6vgkk&QF2?stltRNHPXXhLZggn^RaOmQV8+No1OWfUL86<~Oi=`ZU
z*f|k>lS;w0KwEG!ta=Acu(oRaQA*F}{Q+A#Pi{7};cz(oO4!dpV4RoKjtjd2WNI^6
z@}_F`(E@}IkXa4-1hwRL(b>k{S+PaM{fe9fZ+l^)?tY<vxX>1TE{`!`XQQ*?L758q
zx*zG#8n)*tl|p^vj+`@bdxgD|)b0ZvTwLN!16)dKEYT3!0hL5e`#0IyW@}Q{`;AvR
z<GG-iAuS0th>5iRl;wI71U;h<DrnukDIm$3iM`Uki$WbI{0iU`6SM1a`p)dA+T%9=
z4P{5g=f_Rl>t)eUwikb0Xw)k&4QEIl;9wfWd-^Rez_69@_$fj-?xrzZ*=Y^hVu{T_
z<wJZ{Mn{||z8csPLk;B5OuS)lJG(alrqCxi{4y}bzC?H{Auz^a?=oVr;m&n_yIw4Q
zgk4o<XKg-sFwLeG=pDVT=-&7eL)7fg#td;$#Y*JYGJ}#GKHa^3eNWFJ76vhAzys4N
zBr%of(q>i6y0yLq;pY??@v|}+Oo0_+DUdgrTJE>3=Nk$TA_>dVJ!$KxTDvzM*T0f*
z3M;(p#JL#pt~&CY+H-A3M}H$Kc(sEI7lcWxOha5VLwCXIAv@3LW3fqxDwBgIf2bR9
z?T~2Y$-&%*wf5SoLTF;QI&w1fG3vXsmaPg+B$kp=lI4X|5~D8HfV*!s96j()Z+U+H
zxGZWcs!I<X`j@%6>qu*zPu+;5OC&~Tk{hxyDIeIO%!6|2ywE<bU(_RPW0tqF!;aER
zjRJivpN@MROp37OyW|&6KBv$=Mz0!urH`^iOMM{Rs@j@Eo1~_j$aXSOEioZ|dnVHo
zFz(VTM*-s9drpx^!$1c6ipT2I=(1O;*8ZUXp(l!uWrEApgMDG6DJheJKvAMZO_$Q`
zR|IhGA_ilFCXVYWD+^YxS}#$~Qv0aRo8o!(GoH*e9N6D)yu_96_I^&T0FZxPl2-JG
zQ~a7d5M%xgO(%j<F7v<TQ2)qhBKT4iAzSWu#5r!JAJhykMpf>v`b1P0%1cX42$eF-
z_J%){u^;bF$ao_U4~$ihad6U2H#mTc8LfDroHh{6Z!P*p5yI3MnB<}&BqwHtRA#QL
z9RHw1#9K5F5PDf@ZBr$gn>D`kDHNiNh7OjA=Zv1JIL)_vi+l9pRyz0#T>98`89%3J
zhTXE*FD>8%R{1SUQ(cp0f<Rs5pBjag!yIflc$tI>dQ!NB`*a)X%1c<f2)9doIRIsf
z2AAvf$Dm7ccbi%hc?L2W+HcNs?cQXMy(41|6L*7}l_*atvm2P;-&lfQJ;5StfilhI
zp3P|mX-2X$&-Hw`y*!RD4m;AYqV4Vj#6D_VJFFF27bwBLDWA8n=j*j;((Jp8{t&(i
zU)c4Adku~@ySpT1xSd(+`#&lb81WaQP$+-FYxa_mFiDu(DH)MjZFGpi-@3^6R*Z16
z54T;!>&!$o1Et<!5aSbl`|m*dq0Fyzd0`@wd22Qu{E@TXys#zk#_A|NNV*&xg|MM}
zZm`hXQw=3FSOusKk`Zq#_WAVL+kMUs4h2H%G11X_yC_YztRvYqE!3!f?{OOSb@o5i
zoExRa@`=d81Z~GVXJ&5F|4!}#i{mrj4(Syj%WSvAwoaZJS%%+1f|$yZ3R>0!1mtQV
zc|Bue#QI+?eQ^~;2@hdfUq1u2V+nLE!6)HZi|LsfZ+%#eI1ZTw-cf*_`v^vvtJXey
z$kBR~r(43w>QilPJwuo_;bi*HlrZpo#Ck1FO=SW}>HRN`4LX}peyON@TWl_lSsTg4
z(YV$xb?!OkoFQx}=Wm;X>{gFRm1Wed=rgqr(cug>_y^h*aJfXPf6*86*p}rGrw*jW
z!HDQG9N3+i>#Dz>P;Gvib1&42j+X-lS~I)>JAemHiq?+<=3=hAZ+$F*bwy>g)X8$n
z%4g=@n758X-R=_s-?6d|a-ua&g5g!1I>Q-iJHx>|vo4yVrAIS2Z_4iPlchr}ARkO1
zg&)3)Dul!|rmGGlz9cNa8uBzr;V_0PTLMMDvR2g1n#yd!CMGM3rXg}rR!dMqgzh=|
z>>gfie_3uPuwLdjk9LxmCvL9KC0eRp@T74_<??zR70y<!y8Ec|7)#cYWN1u3e=^0n
z_J`mH0Y@5RqntVIrRLJo!G=e+m)eIe2Oow)!ulXJkwjVfnh*PrkDBT0|8~m}DZ)Ck
z3;B*omjV=uSCTPnBevoj@yDaTVYF%QU8P8cN=rr-;99fINr<zv(b4sZN5I^T(fP<q
z=T0$0;79WL7;E{+0<22GL7mTa;stYTA{`n4yp4pkH)Ct2FJ(9WR<(hIqwH_F&^Yl6
zf?laC-bwv2w?OHtLYf0Z)I{VCcF!G8H#6eSI@-9wGf-%1Ym9a;X?^`9n$|n~u_RNL
z&+AR4;TmwJCCSh4C=22G=HbC9$?yx^dwb22vOh>s*sQ=Zi<6?sM0DS!uqN(Z<LD#-
zx3H_mz1*{MV_u}Of)L|eM~oDJ56QvmWG}8T7z*2ogrh68zjrYAOSs|j02TF(#%;b9
zX=jA$I62gZ%hLi(BSmAS!@Vn=Gvw;a%I6h{i5w8T4_mL4;$D|fPblP8qN+8@+hO1=
zHkmFNMf&q<yWl9s=S@O1ob9v%?Hf%MmZt6ZiEJ<Tb|XxT^E{gBH>LJ{NSfT%QmU;A
z&L*3r8$P(LE>4@IzpD-qM!uZbt%Q%mk!aF|C<Tal{#{;FR3i@BN4%yrdB|5F4zHC=
zoUk^lfkgY)V+aWQ-901?qtT8zsIrpsnjB&<nnr4VghTUGg<JlPOVbc7aCrqQp_~4G
zL1B(+#<DzWx==&M#%x*Q*syo2U^0VY7ki?=AkihEP1fuaVjn!WElgc*hD9$~Iq726
zpIC@Il)dSW4$nn`+xu^!1+pA|`MxKTvuRPyxWwtAp0>o+{-Na5;Uz|8hxuGAlN)Zf
zOY2#dkEM!2n(Mb+iRci$!&X20T?967a;pPKd+}-SIJHCw2+vU9sdl)b_VaIUW_1Ug
z+C5L|5i2?`>3(6?m2nuqw6Q*5W%`@Jgw8zaT?i6FJQH}!{P7B`T?=L<tJWQTNTFD$
z@wL2!^z~?KXjqojwjKQ%#BBFXb}rCh{M%3_V38B=5Icn5HUu@4jWw6Ms7Pqz20su@
zdOOvJ!#nGEzOJV)J!Ah7*)${}UVtcm;&sBixavS@3Dz%aU(2Afs7VYY<l=z$Q+$YY
zUyyvoH)UE&JCCv9k}7yb1l&e*O_mLk%}M813bmWjt+k4@Zy|$-Th)1QgE=Vm_2-um
zy<*>_eyR3Ojf&R?=4lHFWiNf_1jqA!qNK@UMY`F+htMIxLg({qbI`J{d#eOAEjIt9
za%KTZ%}d-QB^_nM!O+ORHRD7d&br-VY8?8x1|yyiEy_KpJFPWs_!%yl{kOZ-SGWh<
z?^hA5?d&{9+e-?g*puI({87gLN8MY7#kFMn!?<e*uEB##a19~B-95NVaCZ;x4#C~s
z34z8tcyNL{!J(m>e`n^-+%t2|+<U*h&-<mHy}Nhss#;d7R;~3by4whc2;KuKXpE>J
z87D(Pd7T6T-8?_2np}@kLaYeV%MhRCP5nSDwmvZ+|7tTwr6rWc<3hzA;XOR#t9ut^
z4&7$%;rmytp7?m)eBZt7+F+)apTD2bf5n2Wyn(QqUw)5zgIvjM&r&$NfE0ab95?It
z!rsKo<7=^_A@iE2JG@V(?INfPU*-C8wI6@_S5SRw57FMvwI?A0XoRstX{iMzzs~8-
zokU=G{ROX(7X3;kou%1c<y(q<bGr9Q)Z(p_yKvaBZ14-Ux)S%F_<ZLO1i`CS<(74#
z!Xs24$$XxOuYY#2>lm*MB_}418V)0`-{mX=jLPqh=7ngvW@kEwk;%(iz0vi$oJ(G&
zCLL95($S$@7Pq#B?{z~eFG3<yQq%<>CYr246Wh|=fOwHJ!krJefkr}(^P^K20ZQKE
zRpBf726GuxV&}>H-zz1VX{yd@R~&L}<3CX4pwQB1rOgC0(*)~y#vdz>_Ys9i&KOBZ
zG?t)Ho!P<ILYOjT?20PCAy9L$Y<Rm&v%RF~*|k^V7yY^tI)t(f-^lL#MtZ&Q*rs@)
zvGK*&%LQE-nb*T-u$69RsR$OW<N3S7J}HDAE}Nbi+RnakfTZz52dNuT<;Tcnihv6n
zZ+|u?QqKf8R~o#Vm$N~>FODGSLwKLG&=@0L5}r34b@chD%N?`>=OEL$oE(4;2@;bH
z{S-nyZPCd&p3z`b?DbM*itH?s%$b~?CaRZksu{uE?WPnc+sXvx6&Ipq;gyPv<Lc5J
zbS5Y4Oib4mlHX8$*N+NrVL$0Rk8QJ4czuOtTh7yw8EcdNM6RCvwB#>F9Cs=B&Vqk0
z|EzIJ{bCp^Yjl+N%gbY5N7+UjL&yC+ku5*WeE}>VEs|fF;aH0(WRWNzTU@qf_PO7w
z-pWCt*1bM6{m2k;oHrpc{GLC2O==<@(s4eV?EgN%^YD{}{@9vF)w<nXE8egI=VjmX
zEMIfTYd6XftmBDXq0cA;mp`|*OsqiHg9lAO|6l0nGYg9=#|(YMaMCa{T?h1vWHRSH
zd`cK5wk@=RH*?k}J;61utaQ-n>-u|Hyfp$dJ$*DWgR>@^a%0$Ob3G1H=R|Le1n3S}
z2E_&NVpUR)>Gwejh=x}T4#zl@dw3AgR5vz8^>H*Nb#JED_YB88W+(wY?6=Hx{D*vM
z=oXCAT_|b$YM=|*Cu#UK|BCLOb#9lWgPV@twjK0#s@%8G<V+M|xE_3y=Wf<snR~xX
zo@eEDx1nj*MZ${f3y`Ob{`2+bP8$b>m^(%L85m<($GVR;{Fgr#m)x;;J$AYKbcf8D
z;mZ|)&T!zakYZoznrhR4Y%*@Lf(mYqv>Bp@wUQ<j+r-&lWC*ZK=r&X;?R`?CeJF@L
z6A41nlR-*z_UlnT%iNG^^nW2Oa4J)!`%K9R;>h0uVG$j1QzUkI*r(21n-V+<eXY^I
zrCIa4dVf88XCymxb9&x4r5f(Xppppj_~bNJHrPoI=W{nwoE{^;V&cwktFNQ;mR%T3
z3%<=7uP9l{%QrDGrIX0lj_4HhIf=Y1qDo0M4e-P@Z@+nG9Mu)-j+@u<@`?x_zw@yS
znPwqUX!4|dMZ*4sohUthG1;LHtmFzHzmw@3O^!$VkTc~1Lxn@hE*24dqM@dCc(eF}
zQO{`b>3pFA!JUs*L4(&UGEL?ayF^?C!p9`BL;zt0<%Nn$BXw5aHT5*kgV0z@^GK*r
zqTQi7vc`ZS-5bH(!;$*%aBqvZ+O#3>IZT2T__y6uj%!*!mu*YA$-7f0R2f53gw#z)
z*sHq8HCVu>JGkR}j(mz5t-s!fYt+Rj`?lmAi5#UcBycdoMDBbrxnfCyQKw50H@j@E
zPs`2Adkvl=m-Sqp5~gP;lOAeIUww^wOwF)$^R1~uEKJSKPV3Rwl4sng2fE6z>Bxxx
z{24u#CxnRMyq#t^bfHdE3R;g3QitOJy!NTtR3~l04mFujHxD;abgA^=A1vT6X{E{8
zbt|@OG5C@ZpiWHQFoiMH4r@+15x@FyTqT@aS0qMk;6`>kUn;&ex1X=9&(QMZG@?HK
zecu2($fb0mkjzwztjS@c+E8M=wYH53G`HGTq5tC)s|#75b6cHxJ$=8RTDWsNJ$?EM
zIGh9uKh-D?*InoP=(EbV!IHQ@43BhOii-DvpO+Mv6xnr9xa0~toF$(PrFNPv%}vTM
z>}j;VJ{ZvaF_H*>IKdrnelE7-7^De@4BQ&BE&e{543OR@_k%;kn7%n(`HX}qD2>th
zq*fa9<(uTAo{d`z7?Q~_Hahz8Jic4(YO7N**PBtvfh=SVlZu8W>@>|>EadGc8hzPU
zs$n-#e=hGY!2JQlJ$PX^X$*!YwjGbt$xXQQMwc-ddMM=`C@w<N`OaN5)^wWaXNWDy
z>`S0$qr;1U4oDX|ZmkdmNrMh3Zlw|k_QFd19NCz^q+(4aq6)3gbYkW=G38lcHX7-c
zw9ayg9X%h0dv+cuuSn?8SG6S%vcdY^!4wmxE=rE0y_52HW#WEmj9<O}@S6UCn{5Vw
zh+a^SIbUV%)YwC3<u5_GtlPv1gPNQEhO;-;!CV&RaFmxo56$O$NZmKprpZLi_TbbB
zZ#D*)uM(>&vr47xqJAqXQ!-^nTSOFR{WrF0GVd`cc$e!*to%1q3K^6A4*G%lE8WIC
z<nG@ZG#i)7j3lr6Am0VC+x91)A<4rE&HIzI7Kv*$Av_X_!?NyF(6A6*wCi~Kvplr=
zuh&?ozUPv^<Gkl?-9j=Y>o&RwnjhSz_rVgS+}vJCo@+5xCgz0a(`Di{xUG?{+-bhb
z3P`cs=!J(#WES8gJ1$+8MEwwgImXWVy0jOJtgR6=|6JJPQ|)pFt5c@b2YGr^Zfan_
z3X9%;dzJ)aJCoxyXQ*Rh>TK$Rn*!TD=!;iPD(d^@@rP%-)a}@qGw61uPWY=^e^4xp
zbW&oHsy1nAdip&A;+;9$3TlMVG@2OpmAjoy(&7k}iO?iq{qo8wLCe&{Zb<*crr^a6
z7+2r?c=r|*nf{7m+M+?2lWo;swC}?C<6BBIZ%0Ks%Bme+#|J?!vMzQr%WMK96}E*W
zq9RGSx@E0|QfTnTmdE(ez?I1%QmsK+Ufx)iZpegp9D9a;q4hCD?VOYGIVD|6nwDT)
z5l2(~k~&^3o@rRy$on|El+Ift*cVIUlSv_YT2|Ju^os!<gXWS9(bd7s%q3NhVL^P-
z*Kc7M4&*97$2pkUsxC>CWtGwZMe6KHtMb931vJMmrW)rA)H&QeyRb6gHNFa7dW5Tu
zzt7hg6f81y7_Y9ZG`p+wqrB(B+0-n}c4d0d$dSsqd}j^FR|AA8$7KG@n0;z_2L%kJ
zBD+$Os^NaiwSNaY9IMQKt))11K20;0P?xj>{~EAJg5{=_YCm`Lp32;9sJU{>j3fHH
zP1oE5EY~~-PrT?x9}dyHC5{5Q=z@(pu1}h`j2HXbSC%i&yK97pc}=y=7<VyeLO(|C
zZpPkg8ZrQ7@JhWAfD|6IA{Q5syUE+?CX0sF<#TxP8ULGkCE?}xz{*Mz-F7E@pM8q}
zN)m1hlps4JRn-A^IwtdIKvYUv+C<74Ud=^E#VBvq7Na)mw@&a^bR~6(sNSbbhUHET
ze<K4`RmFPE{B%pwkbzp52nxZNp5uW>ipR{>hK8l`BCEsoA{>Hx569O&Shn>emjVKZ
zuHWB!HQVcbQFE>{PNt77gznsUegk~_u|dGitwz4mX*F%5+q?Q^EbPMm@m6HP0RxBM
ze%X_R(}W6IX_YuOR*BLDBMuAK{`st`&i{oH=Cg4`EES`?y1M#ose%v@{jR!}mXb1u
zxX>r?{c1D@DX*O+5I7*RIGMpIlhk6DSyR2O!ueN#YQJ}WYH?8}vy~Tzyy#DIXC>m-
z)IXqpx|IuaO#3#|1018Q7I8Vk`R&*@;r>t|e($RlC~YBJ9q@tMp2>|uvo>cFQlji`
zf<Di4Q*iWQgJ2ZNa+DptClxaXO*PwE3;)sTWa7B3fGpt^Uc*?%O#s8)QKMw%5l5Fo
zdR$E*sp!}*X0cbDvBSH334LpLIb#^_f8-rW%e{i9+$_jxu&Dzlab|F7YO$4U`{X&8
zlV=Ln>M_DeHr0Ax31H3%0nT3f5I^h#*@smOLe6_Fc@{ofo<-EnKBPmYqH{le)w$kX
z^$?DH9~ILKh1wXbb|pW2&9<zt(&kVQED9fM^7g3nWLf9{nw+(#5<6boHApk@dh-~#
zQ35T#4c*$BOdqeX&U|x|v2=a2|Lh{m78Xk!K&z30KMURJEq2QJxEPvsBwKm?*7aTI
z&m#KGj~%Ca6NKBEf!IpqP1iX&CNHRFxEdK>ac0^GMHQ<X8h%g`zR;p<!4$R`iY^J=
z2s&E#0^<vwZ;e;)8F@ZvG#^AD#vIVcKWGN~<-IJG=Q3aBydEI4e4l4LC^d7GIzDel
zvESj<NUh*i!EN1SRo7i|PrMI~&hxxyr?^xU+ZX=qd5(L?RZ!hLr-~5yIlfHA6syEs
zj-YFTm7&T!wBzLm`Ov{Qbmh+S3J0+$2lZvoih@*pxndW;LR=I=xFZLcLg-v$F7X9J
z(^x=;L<%QRBdJ9V0u7Q9w~$MpwzLE>JH8!Y5FrQ7?+GFy(D<_KW4T>Og})`q{zdjv
zLk5S-_^_*q45eB|=2i$kp+r8o{K+>E6x7X@^w}x58@EZQN`#S+R_+=RH{b*f1`+lw
z0qNW8b&6~5gwf+8;YakDa=)dh`_CL|#{DOJBWfzs?^MM%cZE(>`?ot+aPQ#UFY8lv
zs2Njru-#NaGN!h=ZHjb9Z&8O(Jz}sc3**#?+w0Vp6n&qv-pQaYqWpxAouOY7mfc`U
zlPxW2=l=kTKoQ2?#)?3Wrc<{$*Q2qvMTR56lg3in&CM)TIzJF$)7o>TtB?HFsZQK2
zQ4gr%1tSX2yE2mp4MZmR4j3RPw?`tiNr!_PN;i1`VQKX<ZL-M8PoFN?q!m#IIW59X
zp?*;p7CKfCGzFEsW$Ihcs7#)+Ho&{0$5d!oz8bH65H!9Kha_Axi|ZD=<>c36zZqV}
zjjw(B(7_EbHY}?rYgl75ROGfaWUvgAZ!@nNLnI0jvRQT0lgefDMd@#RPUTi=LhI-M
z^}UN7Mcth_I+|(xK<5_gvC&ki0S=fcoXkt$P)1I7=_9}ldnJi-Y(cTEBJ1DX9Va+E
zJht(<{Q}!@7YaQcE>iT3WG5gGY2g-%Q4vFljTaADP%+Uxi;qq9;E?1Wb92rQfY9Xn
z-OAsRnFnlqj!Nt^SeWPeE_CiIlgvQ5Mf;WJ1e#_t14Sih{aU7wEzaJ1FX{u_f;_;|
z29&vLOJoAnQLgN&tmY{Xp$GQ}f#&NJKLS&4Z-Rp*6sP!Aa(0Zm+|f_hPpj|aLn|s|
z-dMz(8>F>4veRyo#)Jf;jBVC7Him1~txqW3sQh&)*>X@I7-1Fb)qsV9oI?q~k*#P#
z{qdF8L%3Dv;kot6fPi*|U_R6-`>ujg{_SytQs-@l%;hBd)}tTy80%$6cBg@8Z&sdQ
zN9Y-UXYhv|!Q?l{93>&g^qMkTn)plX-Nh*G&Uc*n*ZFFn4{biIpJ%cxCYI$c^yS5!
ztn@1_Nl_P;gypfXCTwQcG&DEO&}*90waz3r$ysT)y7(bm@Z$aQ%4#_tLp^1X(oMzq
z-qiE8mb($M7b#1UyEwwahRi4}ZMdYam|eN3`>Kfe)9m3;dujo?=davD&@73SHf0yP
z`uvCQJwSkpj)qYGk40YXfjUAI9qU6K*Kv_&F2k+My)up}pF82}!nZGWjLH3;&I2eC
zqsiP3eqML2P?q$<Po($wfiS;pY=E(kRyOX&jo1(*lb{*=3Hc-dDC#bcfyXvDPO|Ji
zR8nyJ$@b7usZU8uKY);&?@|9XyI9A4rQYEHV54y5`3WP|t-d$ZbueS7%!Lia12iGi
zVsm+x=&YXehmFH-Y+JpeZE6>lOe$0AWQU^!J7T52B-Fu_R+RY?&~wieD`HoOPwy=r
z-FH_PKO>eGkU7=y>jmf7<vt;qWE=R<A9PpcI9;-+53FWh3RTZzq~}fZ4_Fi-_(}28
zoQ}>e_gF^#{c2K}bAIldU1>q*Wmid^vxzIVf~7L>j3D+x(`L4p>cYmFH^U@9L{e5k
z&h*=c)%N~^w~2Lw@AFfX@nXOxm5e_JLqzdPv})H;tJ<fK{WFw-k$JB-a1iKjVVjsN
zbq(oP)|m=ga_t?DZE-S!C}yf)OEWW4T3=t7Ju$vUNv=dM?3H5@KC_bH4?3@3adQKx
z_9D%<-+3!4Dg}wN4!g%thDt6md55Yn^mbv_A);tj4qa6;S#r?=XEUYdJH=82>e+A&
z=xAyq*>Y>RHO4R7Z#z1Aw7DKZMFEw?x+Ac#gLrbSH0WxyIOHI>wovA956ixCvmkdE
z$5o$h%Ab+$*|fSItUUXkj5`@vT<Rt~k=E@ItDRh>EX<wP*LLr4kxfI6aFB-Ly1Un_
z&pMKLoH<!Rv7WJCLJPNEm2Mb;+xH5qEXDwjMIp|a{J{P!9(O90M;w+x23lG<obv6Y
zm&AK`so$}j?NpQOV&6<?IK9Mv-`?E~XJO8h9*g}c&f3I;BYkCzP<l>9){08_bFpR2
z+7W*!h_-(JliDj3OGvKZ2j~J3<0faX4`1*-6-uZ#<gnbWw0k{hORtuv4SB|&v!)}i
zb>G9S?KNkOp4bA}5efXA#+WD#zP_Sm++a7>Pkvsx^Y_$@iIZabuc#9CDGm9mt%n+b
z>d^{sUKVu-yRC0~-84MXIN__oMZU;0%7ge~r9N={YINFW0y)(5=&^x@Zvgqbc#(Jh
zpkW$_Uj#?I<SPs()h&!LPq)dEF;}%Sj}2Cyk)JIsH#Y8vWZ%xu`-~K!wWSp=&s<*|
z)WR0V93AO;@1`nc%%oZReW%dw2{<gljwQ!jWuohcd!EX@eKcp3&-pZrA+sc2{jMFX
zEbh6R8n2Uk3u3Lzv=0z*TsHw7F>eSN-M<LE>;>Oif_@D?^d@=5lJeIF*3-awv|~Y+
zI^<&W{~-(CiUF<><RcV@m?Xkm8Vm6^CB8Yd#{1HG5?6RkAzub^*EPW^rVy-wnl>C^
zxO~UxqS+5~s&>T>uV|yz7URi`KCCc*B#&j}EKTLwGA8D!=kmP#5~Ch4K8I#w+&GpA
z1+8t8lJSyXqT(LVqzb+^h)L;Nh@gf!!WrU!1Kpq`>I+Yc^yA7zr00EcYaxUrZvEDE
z!!f?ZqJxMti^3p50(+`Cia)9v+{V3&IKozItQXUG8K@vj)+9MZN+)x0kEh?nEw!|W
zVc+{8oqQ75+S-zdKjeV1*lnrTd8sw~FqE(MOq=|Me3m8+i5|P?Mk6n64Lo{SevfX+
zGxP1|?bB@kHQ#T@N%!;-$*SAA{p~x*c=fiCMO5G}I6zn|U1zkG%MfdD%eUaH+*GMl
zZK`{fCfn+iF!4w1X3l4aU($D|RkIQ2y=GyK>+M;*wR&&ik>cyWB4JUCMvgz%Pr=`?
z7*mS3IvN1oN$O?#>*t;ixG6~%Y_c;_CpAB;hunY}Kk&M5x9{dX1w&ky+&pGVVt&A&
z@9f6B3?sZDjwuLR!<UR`-xUjBM|!yKgUoD04K78?j2WlN1SRBNX<MJx-ci3Vi2{<$
z(5m_2^so`-2|Vz4aE46TdPGP{DAo5ccpCF^Ngm&h5NTD4YLu3i-ZO!%Mm{(qKs-FB
zC_dNviG-A-ys<HOl-ZKDgm%nW2(}zy>TbWAPCBt?JiyRy2a%W(%d4&(g4DTr$(-q|
zLQZpAqD<RlMTB;DmR&au1;`p+wmsW~?O;R}n-+0BH)!4|3o}WGcn-77FBF1272xOP
zW&>X4LM(FHID9+w+AMh1d{)jMDuAZ>--1$btQRm*`%JIoee~mRt-4#vKIXRRQNvv3
z9pqHke7;!44hw4M@7nnKwN`HnYbGdTocywq!29joT9?-PWnS67RD$-ruZ2EolkAxh
zF}}4p^`0pq${PWJhwu{bk+<y~X9rJ1_V3?U%xTWCGL)sibq_0qX@ePW7{J{ruxTYY
zuEe5MsTQ((UyTyd9o6cLEWwUqLLEiw$H2-um@(_*_l-XfsAW`L&X^8jy9|+z>-^Zu
zy=ao_Gx=5<pY`I>{o)}bKSX_h=evLMH%mY;BMKeLMc${*yAv{q9~Ji|Nfd(1i6QJ)
zDiB>Qc3<C<9JgA5k$B=eT676xR5Yrb>+t<^akHwlu`hvhRf})^t3uso*L%92N{_Kn
z3m9n)(POX+ximbi-ch+B{M22=hmmCx@gX1rzp&@ShgP<%X2Ypa?Y1(o4pW`Le7w_&
zi6S13k3C2_fJQTjP19Zy?ctp;CS{_&59EcHf~-bzu2KLdWj}Twj;vwK<+|MShkAdM
z2k^7s2Jk6|{cXQ#uas3VRtP~t<k@vju&J>zC-J!fFZ_@LU>s`&4Q%#j80qRZv#;L4
zUI{IL^dDZFV>z*R(8UYN#dEyG;zTm_chl|S<>9I4w=CkG;##3ZGk@=f5u*NSqCX4X
zCGsc`kS8KE{}JFa0ks;RT+X6CdRC$>5gAogGLc;gAr=Coj|C^}_ns`u!cB5!9TeQr
zPLJbIR-dP?V6`4Q*f(gNRy!wsJZ3^%^2)ZcM81wdW8@Fb9U+TDN@C!+l_R7Stex8c
z@c84SY};2}yB~`8(7ZP&!ZMZ*z__>WcOF$z5*iZ=i^Z}1(tRNNk}^?0yEd|UAfeGy
zV62u76oOlnl+vWUygX*1c5Q6I{PqV3icF<XcyU;Uj=}uoyAOp~l?3gwm(A)q`b`bn
zt{kNB1)cYuS150>)?_<vqGo1hT0_CI981fy9JE&fO$<kBhKBElhIZ}BHe-jq=d<M#
z9<MIBe)wjNniV(LS~6{zK%faDWp2l<B#Q+51MRTz-m}ft6M-4O8ayYnSVMciKryoa
z$}tT^3i{3w1y_ykQzmt1q^C%Oyo|j(v@3Fu^*CEmDCkN%0aI0y{2Rm(mRfo7<=c36
z>Cz3wG^2%=9I8D>zx)q+S}xxBl<%hjY;<qPXuWZsH7>=Je%CN~_$8M5BJDLyN#R^K
z_yl!^z$*2G=u8D{A#X_97k8LDkgUBaNtz*A$`=}$Qo4Aai7z`JF~w6;_1r6??F>JS
zDG+3o{S|+R%Jr<EaP+CS!5eeFmE-HU=*-@I%xeQp+>f`o3a(GIK9GT_8tgs-sbh~&
zcgVwij~3Bek#y)ei>+aVqFHpD&bbHmF5=8xZzUTOh}c1om_&Q?TLl?Yhwlit)MmMU
zSCF#b=__f0K@=n+3r~?h69W-95zp^7{3Vi0C!C{iQM%6Kst&fQ9KL+QE7SSpIcnRi
z($Hy5htdyE_V!6@^jTlhMGfx@R#11wdcC^<t5IX%hq%mdL)uao@K%h~y*j}yW$$o*
z)H|?(FVeD6(#{1Q$npCl_9s{@XFe9-f5U>&SrQlqzCI6j>@AJo@L7C4hURlxvVU-C
zySv6Ju09wqghSB#aEUH>+ivu$pdc=OHGqB1^>OWGO+wy#;|lA;t%{-mXzr%G&ZZOz
zw?nX0cX@k4%88F5K6gAY!!DP%jc0mnjBde;BhMd<BxteHRQ8=yADN;ZCF3qj<^wDm
zRdhSueFlQ6?@OL5QwYp77T1#iBk4EJA!?<|&$()}8$Z4@V$;4$h?;9wP>B7|p0j*~
z;bjcwp`nqAMhF_4ZQ)e)qf_%uTI9_;{E8Qhy#g)5!hpjEkkP@qJgG+<E9<Y`oO>m>
z&1MdHoYglWpxC$bu0o4XNz%%Pc+hG)nuZ{}Av=4YC6O*G@zM%?n@)HojH2V>b~O&`
zX_iZGZOgv)l)xHKjt0SG3@?oIE^Y<gxaqSqvPFVl+(dIxw%=+LO|~z7vprQ8qtH}s
zOve?R!AE~qo)PcLSsA|S6k9gUZxg2eG^j@sT2(BRM{sAa_37xxuI6D?)tuOO??9(m
zA3=d7b$*^JDgGo8+{GW-=UG&wRt9h~Muvvn@%>e|N)P&*FA=FlC9M_6L;&(?!o%lr
zc>x?)LjZ>QV_W8p?5oiId(8LmVzk!J^l*!vVtyC#e*@VBJmRA4KFz8e%U5d@Jnaj&
zt(YS73H~IY!<p%TPEea*Whz>?1~L`g>25xe#pQOs&!541UIe@0UmfERc@?L)CJn~t
z+DBkmer^(@1C@@h(phGWM0V!dZ#@CqPbVg&r$=2s##m=84KRZ+!-NhRu#Jvw=8v3j
zUbC<m7e6PlsnxA@eMaq5=4Zs|emv81osp4ha7%j-dCkh2$=2<}%c|cFMaeKAj5dKw
zQ&Cl&$~zo~p8{}i3SgqW+KNLKt`z|k7b6JX{)n;@Ved0qZ>{<M<4b`^qnqJh6<HME
zCg7s59;>9C-ke|)YR;%^lT_bl30io8f-sgfURK7ZryV$)R#aWBHrDI$No)D{Nq(HJ
zCF<P1dc$N+@Yo}u4S0s9nRsr02iepHpgbv_4Z2-4+c>@nYCan`E(=sz0L;!mk5g&a
z-|epJCW`BgPv)ZemQ<OKVFFnd3$w*!EO+dTUQf2Onya|7Hsw5XRv{m4kALa8Y8#pn
zF#<8j@pujlr~9^jx@sGqQK<H7r|6%oSf>IYZ!Kq#46l9_&`g6O2QzYO(kJL7<{o4U
zH)c*{ztYQnSnO(O_B8O^%YPQV<MY0G=p!Zgm78TS%96b9H5)cJA*$|H`nbR0P$p0(
zrZ6-y#!-Fa5`kT2tI1Z1eBPS|g)I3R5^IXv)P6Ae({!C%X;lt;?J+=oXv7Ypk4m%a
zcL`y>-fF@Ypa-86@mT?QwQDZaxn6K@7F`xn_7-N>3gzl(U_Y4-;$d&dvI}1kE_e9h
zb<r!tMI$K0=K9opyQM&Zcw0=ereKBMFi(kne%(5ejFPHozNyRp?1d`gyCI@Dt*)vs
zDdzV~uEE7T2GQ4%K?Q@^@20l{T59%u#;>60sfP^_6u)drP}8a%JAQgsRwUtf+SuCk
zL|v2g+B|S|g1%m93lTQ?w9GUBeI~0Vg<a3ruIIJ`Oof8&jA>Q&AIqk9!O0}KiZp5f
zT{_?1eLr3XWPVPa4h3Ka=XMGX&ML{0<_^1e=y4!CDeQDGZ34$A_>3b6E=#r*sbiyt
znVH$Rc)SN`T9?+ZYZ5pskf;OS;2p&qQvYKa8s-|x!Puf;DT<zoosp!9_Aazz5Uchl
zAUJ!&;S$X^xctMdnx{JX>#~idK-=QWjIl8qT=^vl&0;u6eXFikgaJjjSZIM5b#Asl
z21~<ssD5iK!I6=EHvoIV-TMrE_hyePL;!S@y=%7?NjYLlo!1X{hv%g780XElfco$;
zclA-kjLEWmVZd)5_p+htt;)1RpRGwTq8E-V-F?`C*SVvK02P&xfRT_Ie+jl_M(3j(
zG|6?7D#tuRueI$0DRh3z<ovEfr;fL1W78jd5lkAXziJy6;~L>L;Y;Cq77{e#`niuU
zQ#m-KFqGere>@a%p2;-t(j!1<-_eM1m~G>#Pe-g6Z-ohzYlCyd$xY^xrPkv{^in^>
zrxb1X3Gd8}zHjQFOj~Q)kOv?MY#1~$+HbtaJ!ZOE=X;lw5ro!;=B$q-mIgf^W2IuG
z$xvF&2nrS29lNiOC5E(2kXP3fukB-8h7tqsuyRy4r7dR)w&>n416o248~9x+sZ0}S
zfLIS7SiXZ%5*URiHG@c)Bh788Sor1LW1~ThUD$;3;uq%e@hL^Vdj8X9(}Nrr3ok}k
zJLo|xq97}OEr;OR?7wnC4$@F0G043Ofo;Zjoa5jotTq{KJobqaB(YFEBWZnSRZIh)
zQU!e*v*Hz7O6jt&D&d;E`=p}nH*i7J9B$DvvcsQuzxL?CPu9+Mi5D0_59IJr*5z(#
z{-BJj1_K4Yc-K`K%%F3pX#eVjBO&>RY=eq@xSz(znhvoH)la^A6$0g|wU9$}j0wBK
zyiwMaA$Q`ycSJ|+w)yh;A%#rJ0!rpW@E9Xjy#7?Pe2pM{O{o{|*!`aZ-0RC-!J8|u
zX@;9Wc6K_y?&&<uEXWr2)8{teT+t+Xy!!m9+05@3QQX0zL>r_suMh#Z&X?ewBk(wb
zun~%NL85tg@x_UqrW)M7=~8JS8B==zMaCr6oU|df4(hsMdtg-%9cvZ!-<~gPd;>xK
zK7u_S36F$X_IB`tnyjo~lPJYF#}7ql>Om0{9aFhSf_leXko*ygNETY}QIfOj8yywP
zE!rs&1RD)^yvT+wotErNzTkzTuCYXLE>ua7xwPc^YeeOZ=fS`*AbU6*sr0%rm)CJs
zT#wJu*&y~l6oJI=fd42pUumhs>lwK2*Ds}V0!#K>Mkq~FtRitvMWqpq!Wax^avrU%
zoR2tXd5+j{7aqN<Q(sspji;VKui;(y>eZ{%YmhtJ`rfUqvkcpA(ndG1XXUk!(Bm4;
zF9!&BVKB;^nJ3R{!&6D8Yp31kwJ+|32lHih*Zd{%)?pQJ_Cpl`ytRvlq&XB?e)dE!
z)gfo%gw370-Vs=DFvY5V6?eBE|Fl7dd-^r_Vsd(m9j4}vz3)k~_kL>|H1@3>r<@SZ
z2H%}Wr`1(s^2ID|?&_+3c3=dELz@S;%C+0SG=Q>v)WN3E?QrJ|#PKzYG(@*!Ug^>2
zT@6+peQ@S^S7q{7bus_tzNWe8$}ts%W#-&KJ(oM>d~eNXca1xHfmf{j{B!k>?}Kk0
zbu8)CvjXTRtFWq|Z|#4nMLXU*5A4h0sL4}1oT8e4s9QdYXQQTGw%CvC?k2NO9a}b9
zY6p4Da`-5VCHF1|q*tVa48HjL&jA%pK}~1T3|0Qmm13Wd?n=BQ>KoPZ!sj={G{7P!
z(G8i89AdUSiZ|!RJk|=aN?-?%p?m!YA+^}0`GB%aa!-%kz$ysj^(jCEl54%7CU&l(
z!rEMYYuuPNw{N1chTlIIbQ^HAq3`d1bcKW8on;C#u&cF|KKJu6WJL_y4IofXzk6JZ
zzfwqtW;i{vbg}^kTX4k-Am|9le2ERF5mrJV#1-<B>7uC1arW`k1)e#HoAaO94xRmH
zrxnls>)l@Q)dpSj4kBSFRDm#X|Mjsc2y0~Y_?f5U4DDK-60zIXMR_}7pC}k+&SoXP
z8&3j9++Gx+HcT87jqE%9UR64Ca+Y|VVXf@Z-P9SLXlZ&CsQH9JWKoURs*AQ<%T&%r
zE0A)#H|2PF&A9W%VW6j^!zd+ZM96UeWrNDl<;M6G##<Qlh5I>OoIp5!XREqHjeR0T
zjLr7etwOhG`&k)w)#Sn)=!rlK6{ECW9uB-c*NT;%PEH$&D(o-dYH_3$Ws`R00=RoB
zXN?ryTdmWBj;@XUYSCo1`z%@x%?%b4u59>VTyO$Af%$QMI;T{Dc_Kb52(aZ*6HGXP
zp)hc}=;bmoXIzPf3Kr_g&~*L=I-W0TJ^HB=%s;y-#XODy>ylPHIt?tT{P+k3%Zoet
zU$RcRP7JHu&90eF-_`ibSBk;yQBm?7rl`BYYCS`0K+<ISI<vs#)IRQcgZ7XL)6-#<
z?aICY{dpz(%BuXklM@zH3_F`nJ7wj_as!D<JoO@Xb5-bIpbQA~K{Yco8(lPFPs_;I
z<1&#HLq&ZJ?i%PhE8LT+g0On;jC|5*wadM|Bky8e?B>@Jhk-@F`LB<lVJ79DF>B58
zN+FX1?_63^g)rVLnoER4?@o=6YZ7QO^xXG-)M;McsJOC*4jhF_`56(*;xzG;IJ?*{
znXPod-DbIGEC?o36W#pwNSSs(fvK;tq!lGfUsTWt4m>_(&@-uL0c^{eP<ysNb`G7S
zF{N!au=GQ@abtk@3nYVfe+BIti=3+CeF@&omNVAqR1E8UZ+apP;K%isV3<m7ox##~
zXn*T2Np+y^+b-9V^%*_&D(hr2^b{o6l-d+KhZ6U<^?W)%^npTfC~wGM{VjQOEJt&H
z5K1d4;Rig!*fW&QoKMb8G0E?=Ilg}l9mIDcgsp9*ksJZ^7V;f9I$qx8mqa)e6if_?
z#k}Dwe5*yEY7Io`@@EUtPt*$T=b|i9@e5!H<M6jhZ~s6$SOk)C@vtD6I$sLf8tTtx
z+W9jYHxxabYjiIu!E=(m`u)5w*#?U7pu{eqK=pOIf0rI(apUgzU}GJnFIefCnt=LF
zziI67HpK7}<l(=Jpq!2|dn(kiH|(>U(pxq<CPp|?C+0^lusmjwR$+d8%LNWfXZgJI
zDA0uA#r2!>RR|DyUD~7FvAM3hitw{Jw787`F@W+1q~8oK_=JXl93d+%jyF0cXzi_o
z9OdQXBj@Rv0?Qzhn|g{#rAf>qFq0vRz+HqQfUv3&xRH4V+97IVMx0~IM0Izcaoy!P
zK>z)welP-8OKMH4<A$Sm$HsvH-xhnH{$}UY0qTDX(%+u54nl*6y+ju_1IZb4UERJR
z7WvMjmooLpEpC{Pw{uNp9r;^?zVjpYg4d)jn;)JRb565Z-(i#ArR?|qs+yVN#k@fc
z<*{W`XsMY1<oHzNxJ}U|d2uPIswqnQ``5mSk4#MX?sTEN!t|7#q(qjkF;1A()J+4m
zL^p>0Kw!JXHh>auLj9bQ1YQ!#DI1yo@o~L5W`2HopRg=VHWn5Zj#HBD(^DEI9P#3l
zjjv&04@ud2oh}NjnA4|hrsOCI$wlt)9|;lLd=fB-V1?kGrkX<}aDS`WKaJhLT)D9*
z8&d_67=5|*TkENd7)$0W8}AsbgoN#f=k{Lyj8`z*wdfP<wP%a}{r^oixGM+~CQ|#)
zRbP7v@A(gY!b58Q+COOm>@Mk13dkgQeu_zFBa|54s_u=tdR+}Yo@%IsL;pFa7gSZ(
zTd*D%8}#aT`*RGi*lNmwSqC=kzj2<Nos)W)##j*0(9q<AzLf~oSFFLPvf2np!UToW
z^q)_JU$J!j7Q=rL-hbYD5Y#`PmgWjEu@QJ(=i<yt`U}nD6YTE$Nb4tQg`HaceZYY&
z{e>-}jn?sP_nzt6S{gZvicyPjuyY%xw0c1`*^9DvD^oMY*7f$geRMV}&`hg)4bgmX
zqqUoQ1ZKq_TJDcUxV&`!wzvp<3A5?>gDxpE^A$0%bzHV`5qfb6-7x@a6T}B!Y<gG>
zdgrZT{wLCl58^lp;)t&~H1K9#itCpsS`*2xBL03_JQtm|wDJ_DvYk#mH@+8wwb_Qa
z5$*l(fGmBN2QKk4iwWh6e}S#UF5vnx{bapCMv-=Saf9@u*&mp!u0kawBsV8_8e@)y
z^6Qex;9Fq<mC;;Px%3Ks^55*>N08s>xx7ElKdJa9@|GLHO&rx30Yj$$E<DN%a9$k(
zji1&o1v_{N-~Tr+3fK^3Wo2pE+1uD6`k}Ki3~U?jrbp?DFcVVrUrQZShfolNNe4un
zKmVcA|4Byw@{u=0uyC*>6Gb~8{__a_z_tJG?LV$aLSTYmVt>ANiT}&@|L>i_{17M}
zh;+r+f%_-Y{f`a*qrXAJRN_?Prk-P~H2+CR{uA~7F45v4xKua=1H!Tn2>)uw{xQUV
zwDg~TE#O4)<O|Q<p}<v!lZuzjq>4sEr(+XEfBDY=1qtFv3rrVd)sE5q=IcMd|9w@!
zh9LM2N!q_x%0NHMmik}J%HK#DD@!FN)}^w>&Zo!J9|!Y9`@hrluUWDA0S*DKeR|NO
z{I7ribJPF!Twor+@gG<KC^#tn!2g-B|HH2iwBl5Oq#`Wg|5394x6TB?JYoEQMu`8P
z4}RU@jplF4->855x#dC2@qOdx0Rg)%tCHwN-k>*hPK1GN5<ge-8FAw?G9Du!OdpAn
zGD^gY8r`#5|C9Xwn>hd5tvDW3x8nRUf<v-KJ4|Z{u(7erq?Dn>dPb9egNL_oBnw&*
z3JbpuL5qQb&UX~2wziD=$gl{j`UUn8+J`ee$^L{rkGBaM1dxh-0jmr+SVKc+%SHDs
z^NaJsjd+G}BbnEjSK%GZ|Dsa=)`x$)Ey#kZfjVA&Wm!bTdznYxHD)(&85x<9<yj(F
zgcJ1ZlX(?GPvcI*hcV{-(ZaB*YhmQS=|Ky#lUx}u7cc!+r|IHVVK`U}YP0{%H2k6I
zATFq-9b@5_fC*wkixIf8xVXH0lhgBYdL?!F;;WN0rX@A?*JAT3X)sem11E^{AB}!z
zZLg5G!`J8{+_m{Pef*zp1GCX_P?VJ@KKj4SgU+X^LRnu6zd9dRNEXy0yuedCI-1cZ
zgnF(S{fX}Yw5&V^!Xk1ZpH*8-RR{5ZUH?ju@^N!$=NrlWo15`})H5EaQj22_Xtu7r
zm)jrNvu9@ZAvyiKyjUs2kuEr-jWewNC^(DC{>0*BzC!Q<Z*#vLmgj#O#h*-wJECm*
zN{in6SAVeeJT%{_`;BVPajHBZqmZJ1knaEb-d*&18u16wIqE=h5uAgSwkizbWj*h^
zGnP}K=A^By7fW>tL~Hf_5zvELRk6rpJov|cudmK>jKe{3xw@p6@W{8{K`gu}ncU22
zjwx$h*qKc{xBh3vO|<ng1r^VITJ{OIxyxe$`?++idVrAuaD@3ZaNKNZ3%?Z9fG0IR
z(iARZx1#AREGnb<)T`SI-eM>lUMSRP#voZ%^1eNzw_gFsihm6J2A~^>v+pvWjJ|0!
zpLH(-aq?Z>-X@LLc8GW09<U^;OwutHSG>f>m;2xyUR+u{-Z@WdKA_Ymqo`Q>kb<^h
zux6QlmTPtrs#16+((T2KisrziqqF3E-><UN;TQkZWSnic(OC8MlMXKmDrQ=uX}H|;
zTfbrhfcEI<RBBDO$4In!l{t7LyF~JlSj6ud=i-75Z0mkCZ0}6Xxzvc>1*r8Gb!S(d
zl+Y5T#8$#47QKA4HoE?Op=OEp(3<$R(r#=nKQ?k?k9QXzpC#|Pi<V5tP=$LIn85t}
zr0zL@w7&T>FZWs~htNa+HfLhyN<+YEmiI$Aw%GjMoY8(=!p@Fsw)5ZDfd5Cm^C0+j
zu<RxgCA1OP71v{6$Jen{Xbt)mV0a&8x8AA>blLO{!m{_t6l7&$Nol_a*Y?4PkRU)a
z;B|$Ch2_mx+RoF***bvA=koM#SfoWk_cDhC3J{MJsGqh2*4Y@(cARKf+3A+C98ptx
z1~}w$hvoYUD;auUs99!dR!w%B8%4G$9TtD$=@4V0|61C2XZS2>qANM}?ep-`9JqB;
z$?M{f&wgwY(dO%oU;O$jnkh0Hw#LU^FR-T9{h4KPef@|-kNHoi8Gc2mFK9^FW}bU<
zacN#<HcV5eO}MgSu(bb9X^jrPr2yH;h%)<Fn~+SzSH4uqPns(?BXYINNXZLS5+SJ&
z*_M8LE<)=f`d~=mYtw01ledO#^jx@KgKe|*plvjW?*(NUPaan8%4l{|KC_1vyXZ~n
zQ|m9F^GXKuJ{VFmxNqWMdJb;c-{3~9{!yi7es<|g7TYJ97C-L~SlcKnvbK8ArCN9h
zs7>xQes$@3&IWSo<0oQhx}{jS!YA*(zFc!&$Qa<AJj;S4vFLO!m*&9zg~<-eA|&G3
zf*S>T_<zaBqD;I%lY`tZs4J_dSXNU-{K*(VH9U|M#j|sOh;$yOr^oNxc$F)cQ&Hz9
z2Lf2;AZQqC#8J*Nl@y^sQDp#$PoYP-7u5MQ`b~3f@wmE&3WjI1!b9Jd4@G=Fmcpkq
zRO*dd1aE~~cG~3wb`ui@G;CBUb7nO4*zZ6UY!2XCb#Kvko~JE?Mzg$XR`{{@IPQ**
zM3HkA7AvS=+`yU*tUFB|=UMKu9Pxnl$Mz`8v8Fmv)iblJTk@3=`@7YT=dNAmJQuzv
zhUHmdP)(U9Q>@87V*{2gi0eCj!C^f(taUiO$unH@5^u~w5uH)m{KMq&N0-qKVeXFZ
z)pBi5@g<_L$SM1!8bk+by#7R;8?`{<{hOVR7-FxA9HBiDKg64-U||`cbXw?kg!$p+
zIUP51PhJf4&<N!#I99z6V=nCSv(Lii%)cl6G*%z8{W$m+IGYS2K5i+ur{nbL9>?p3
zXPx^tUJpah#7ONX4<A(6*+0*(nCeN%jcX=)ceNKqIp0eM=d}rIw>fl~w=TqCpNUZ)
zFWMz>?#HDReB4I96Ic>x{J5@qxL(!ddbln_Iopm}wA-|_ao}||Fn%t|st}Tu(NyX&
z|D2cmNGrx}wCrKSY~bTM)1$Ehuv}+o)Ax!0N#;V&Pb<yVZ5J$H>kX6^dtIefoqXSp
zaDn|Rz4g?zW%QY~<b9RZJ0Ypetb^H0-G>LnB&U;hGNCLgDXbxxj~@e@XNDK6lsqox
z+~t%<fg4H|-Jtp$J`mIEY5(<VwU5a#_QB7woynD2LJZKAp%#`^7fkak989O{c{!qs
zS5zmZWpY)1eA8l$d{>sYDAc%RZHNvkf6a~%z_8(b)13Tp)t35#cx_ctK_{`StnAjZ
z%x>OG!}Q!M8(0nm?l%GR6S2tkvLkeN@50cvMz`a8)poC#eG1Xwe$D5F$Ram2nnN1C
zjk&+|`3oh1%0fMk@>>|bRSp^NYb$o3Ft=V(((iS?Ivn^hCPk&ph*kkEWcSzf+U0f~
z<yh2?>E>U|;0~<N*;>TQx3?D(o_G&6ZIYhovsF@yL6<9+=VqrMx^P}I9IJA;x^C}y
z<3=~%C)7-?2hOO^+=>Lbp6kSyJ8Er5cpY^e7Qw#PKjV|KvcAmHGL((iv`u`!I{LU%
z4tu$Le0OBN;dhtq`wMdC-CK+8>~gu2W_!kqxn1TMkgC+{v%*oV$FO0WHCKz)XLKEf
zV3oYALBijhuRztmQ;|*zRkhIjGD>e1h+)gLYuv-LI!FI!N0Bdg^R4fyF(|#VSd3c7
zRwV=ST}K5#4TATU+q@m;w+tBOd-ATI8D|xdDqdUfQFop5Ok3s=>=e*v0UumzpFqjr
zjeMKn$F64|ov&G88N<8V+cf(|T!y{*+(3&QweyVX=jw{FoE-g*o8{*tphPOPD#&8e
z$-68x%Tv^btX2`K#dAbTwDjY-e4-zT&b$cYle5per<C{X_QJ~6%j*wk*+tB(ih{M%
z*z_G3xh;<#udKfyD)3ChsaIy}wnmma5Gv-2Q3<PmkPJUQ&0p%&65IO^%3etiJ!iGT
z8Fc8Uz#w+N=~ntN5RYN(S-;mt%Nf{|g@7~~+Msql0BAj8*^liq6n#2*-4g@<XQ}BY
zM?^tz3MnhqWEZvlHZ;T5n(fQewj~qi;3S8E3mXAfmhWHbdb*%k2b`uK%I7oA+S%JX
zG~Wx!_kS`lF)i9Htsu;bo*O%h7Zueg-FOJ@h|=q&6j5!3Q`ow|Q&m=`vI*{#-Ag^4
z<a6Ko&Uv_66Y`pr%uYY7S7uhc;~+X}uT&L^<#D%u+kUd#E5*)Dd9vZ6eAcxs;{^_}
zoP6&*-h6z51m}9VpyF7BC7Q_tNNAfV*SODbfA$)u?gH>k@0;T}FnW}D@Zj*EJ~jAQ
zlAQTm|CqIhgH3rZZ&Kom@mr3?CJBa7FLCyTjPmUal$DY$FOSd7T{U>r9Hq^FyQ(<L
zsC0&yFXpg=k!}{0SeclT4%H~Rz{IoY&mvA``=%ndpe(H}7~z>FJ3_n`y#Bmoog26I
zn7_q7|HPg)-1{qF>`aTT9<g9^+Z#s;CTvmu_vlFX%5x?%Zn=WZ$8_5tjI4=17^{5g
zzMG~|Ed&D%J3VLYU(9!>8sZc78SO#1<bZk<o{<sqJ!h{kZkZmJ^==*~u^nZ%qWINj
z{rx`Z<e3O+4!{`Z8LF!5o2f~?T|><g^RH}<VSCK`E}W#aH<6N@IfdLN-*IV-iotQ#
zZlIjOe(v{F-XZs=b($3poOyoao5+<<ec8%*F7vm^7XWM-S(`#$l{RhathN;18X-A#
zN!vk8H@ihO!4|Riw<pg4WksZ*a9WO=w9lArS3hVRS1{o?_`I)T1)Ohqw&|$)f$DQb
zQisK!E<HlM0013Pcy4MY>lfn^=7sz@`dYoxo#K~?0r0R-PkyXbW;1mA(dp^whPR89
zwx>w28Kfsm9YFPs5}!lKHD&u$Uu@R)!r~wIZ+#nXea5*ki8+;99hb~?)DO3zX54!<
z4yoj<tG+<lXh^JDr(9tc67m??=8<V`B9TNU>N!`M%cR`JxU;*?<PRwkOLix<4&%A;
zB{QfK+=c3EC3jwB&dTE)h4W-=I<aEz!;dQGlky8-c1MtqaK4gQ9z)qRTeh|%g^&40
zx~<WRg%4TFuc1{>vd@Q^M*1x0Cj#oE>ANI<xu$sI8Dw&L)q1!7Xc*lByo$g+r@_T7
z8Gzxon5eyiPBzW7vmW^i*slaTW4|$wHM1><e!ff0Ge9OD%eL(*f98LNf4$Hv)uO1P
z((nRrez;TH`O5jaQRI<#^k9~K=IUtE%%XCQD$v0IBp1;tf@!Y>?h#K?I|)d$vyv`d
zhO=*miLL)Go$VivAuL6}2L4*QY8ZqjYCYTeSs@i<nD@6h<saMw@ppe)ljj{=6c;T=
z;2VwY)iA%W5&g*SX0`H;ErUbD*KdqISy6D`+iQ2t2kL|NufI-twRsE2sw+u!_652^
z&2$FS_Dl@E6MKn`t)xcJz@UYVpiJq|<uf)q#j`4*V!UMY=3)5^Chav}TXju-J||AW
zyRz0ag_Z&srH=ctt7|T7borL-VA-_%ph{4!u5y1|P1lXfT#)Wf?{k5u_tL$LsoD0%
z^9YD1`=)V>VooxD!Bm;KyUm`msz>+pjafhoSNB~XUP=wQhS-tt`1NB_A4?N2K#%YI
zO|`J&tT=Od#lGpe?mTN%?7rF>XPQSZnvK^{33AH@v3Z}k|Gh<T^}S#0;Oy$p2j8a)
zB`ko^29qEXPa?V=;9$_(W$~>*1>$Bq*QDnjyiU7Qi9)*VqFux5qCXjd-*z@AoW6iw
zpzj%?KYP|+mcOn=O*7b>3tO99mY>I3Q9<nH-Zff*y6gbx*g8ITBzh-h-`LtC4s$GX
ze?)t;<dFTN)_L>0`#Vae*=d`ZUZ(NM@wAxaWeM45`WC8{-VnVTRLIaW8_eglNlq=&
zbt$Z_ev1ZPH?|-cq*7hrwaBh(89Zz_reN6u0D$=K!I^SqXw2bAT2yGixO(N<r$cMQ
z!ztVM;<SqE;qvj?{pcN63wQsNNK2D<oxd>_PB~pr0?syXu7@JG1EJnD#~j*yV&Wt%
zXTu5ndh}F<<4s40SNJO(MF{&y8x{hit!>_jgJ_4wF~Q!u*+=U^<VbG~`kTYWae5qR
ztUVwL4s9a2a(?VisqZ?WJTL~{2YVFMlD&JLN@@nI1uGg=(u33qv9VB-vd?o^2Bk1L
zs}GFU`=NmdczKqUW(U(|VdrvJA>(o0Gyv*FRGJQS7Px`B&(&GK6}wV^rA$$)OSc;`
zAb)XjF}-pQomSR;PEAD|&--)p;(IO@%ee3@ueIx@KnYluyCdE0+urLM$Trzm@6ok7
zDuqD*x`+2)E6V;;1gMjNOgS;{j>MS8J#}CS>Xk%<FVBS{3dIUxE$&TLtW68qbmi%l
z-r9GLUus;je3l0o2;DWkRzqCt!l)-j`L1{j5F{7up6!$t&ArMAjd(BD+#1qf+e513
zI{Bg8pAg}mFR@jZW8|$6aKU*;RJ3=dRsnmQI_}@OXZ0PfwTYbc`m}Rna%kwB&yUDl
z;POCv<&>56Sl~my0b&*}rjvK0yVo7j%a_`QZasD5K<={_CLJ{5U*^%45edAoU+bOf
zubF9I9i7K*QYyF7L=m6;8YsFvR+5|00gF)e8+G0tQEM3mM0G=c%4fEnpl3cT7rh{!
z*LU1LD4+)kpKpEQ+TX`E+sXKu3hHRoeq%`KAU|#e)+YZ(9>up)!ySbxv+$nx0qO<w
z5<0(qs~}8Ch%sKlmgfuckBY=tT(Kz5PkDyye-b%A_|26fpK|tHLO^T6LXdftpGcE^
zT|KOepO;_^{2y01|HX@fFR10Y0hU0BN*Wt@#npCt`sZao{GyDNm2&RdQQX?GT`f7@
z+El4LezONhR9CVFRnUW(57@5FMP%OaRI%QEUpE+L!qeea)b9H|n$&6^ka6&=A3sn0
zPyW%WejqvQ>L%=&SUVK*;G`=4jbLMo{{$=?rVN!JG~Op<lk^C3YhCFkAz2zNE}mN>
zXmbzWo}q5ZihrfE&&mV_$0XnL)vlPR9IyUdm=rqU_1zA;+x-rq;d<C(mPCa4A!id2
zybksrJE_}9u%z(U(PU)@&kPvqY3z-OB4Y_?l&*6w?F}08pb8tTzzNXNDWF}B!?A&|
z_}|YtyogJx%dh*w#2^H9il#ihHOMTrl7Rqk;o6a|%ZGLo;i>CSqyLYyw+xGG%eqE^
zKyVFCkf6bXCpaOvyIX(&g}Xzr5S-v{!QEX$@Zbf6!d(l3J9T$Xzx{Tf)8~Hu-TRMS
zc`Cd1UTaMmW6U`<;`3pvwOt|+;o)Yt;L!Y>?&i8r9i5BNo1bl=x2kSx1KPeXfyAOf
z`L1K;MRAzn2VqMS0>Ev`<SbW;>h;J&X+_`uy@3ly0&5{t`U@&8kmS4@6Lik`{+*le
zk25hf4U94E?qgM_>ITA4jE+)*<%jyriL+DZ3#W!OZ_CdQeIei8(lki;`(VUhYuwQX
zG{R%e1|Wk5E~am@S+fXNo&eb7P(SO4!knflN%>6KMH09YezwFtCKr!f=k|?-mt?KY
z&->8jcfO$u)cwTZYQJgDq1UOU74j<vpD>7-N5AFOA5*n&y_0PRd@E2kG?u)$XwwmM
zilu7_|19V>lWuJ^kFMA%1)q@MGimQ+b4RV$(%Ydi$0JW(R1DsV;+0l&1}l<jLja(*
zddP@1g?L1NhfZojR$l1LGmMahmnh!U+fFO!HtbTd=0U={J|w$PD@OMpPv6cnhsGSn
z1%9hNHex!g#=`_x;?0UYnJr>2+ov^uwoqEPmntbyPiREhHFYOYxU|9neXL(%MMH=B
z58%wV7o6|%4m#ZUA~&XuscdM9p$#htjo6IxGv1_>8+2)_PBAT;LnatW{u;`&Afg~v
zcNbTM4#Y>3ewt-rnTlly5*5dN?Ljr>!2ITor_*$l63Ou3YxdaGRJvS~7q_S}D*|e#
zXHfswC48mddz4mKaV}Kj9|khGRDp!{<s>V$Ej_pl_3}!DLxGJ#pyk^^TdC3k)yLrL
zcb>Po$!04@Puz}w-SuUI;4!10z{lY!N#8}=o;%NA!6P?_qDYlksV&Hi&DvVu0#MR8
z03``gYDE_0342}avBeh|+FA0R)o5+~oJ15){Tc}bTQJ|pNEayRK5%IAAwjFt>;&Yw
z`ZzaYty;m)9%0K10ma{mJU3fJSX9{&r}_4-Lw$Gxp_l$q#qZUZuYND3{%()vaG(_%
ze^e5_(Lo2SHizj`xd=k@9yk&bod(%F`joQdi+o=m6~CP<%v){#hT{s#1%ch4mC3oj
z3qS36N5P2q?SdP5)F!#Oocrey7`D?>O1lAYOReY0T%R)Si<^G994s1v<qCe3yNFYD
zTUM+T`v)QZ*m*uh-<!>AoPj~|dQ9KUOREQCpCS~9!8&hF6nZ;|NkJq$+t%!DM&3;i
zhRvRJ#CsEsMUlk(GLQ3}s@r4UO5t+h6>Sq|LAOy~94!pZ>pbGnS}mtr%XnvN@(A<N
zntsu!h+$mDB^M>jllsSJO!<CRXxJ}O3!Sn^PETgd_Iaa*{;C@08#y|Z`103;u(j|-
z0&cBa5VUfpl#C$Xczh&P4v_~lafCgi5J|?R+N$#Q@cuZ@_f3n==_5l-x?6I!-Osk2
zS0ubYo2|t@`m3RW12x#v9LkEj2}be}$Pyj^mt{V7Rb}O`8NpKaM)EIjzMC;1JekF<
zl#FyH|KmmI`w)o`9?v(olHFSf5CkU0f^Xlbp}q69Vf*l!W#R%es8KEf`QOa|*HLe2
z-WDE}D@MSTK4+gul;tIE*L<%?BC_t}xp_q5w3)+E+&ecX#n$eVH?36+bggel>}NgJ
zs8|-c7~aDQf&=H=KSZ@LXk(x6u9<$K9(lwhfPJ9OJFL<+n{RB)irL~ZaMjP;*(l{m
zm{YQ>!|~is48<@4-TxZ((K)$GJ5}TYxAdM_&2y^W-}{t4fR+Wp4##GH4=LxYp#Vk9
zXXZVD8iiz_dCqV3T%xg=<O0^Wz?^Bw2j?&>$alXHaD%hR2+#?viR}r7If%2}72@tt
z=BiS$qcrJ;Q;mgC{XAHg{IM3jP)6FJ*}TTDoPKA;aT;Aw0i^Zp%)V>Sb2|Eo7cwDo
zJiEW>*qZ}T@6HzC%x!L(nFuiVVr}Z|cw*!SGAQnTsj0(`52bst|NiKh=%pHi2;&na
zp=tfisVlLEf!BxjyE)F!XA`w1J8iLB4raB0BuhKH$StNB+MinZ5$k~8`{wg6;+DgE
z0oy=0mW5ISx<bRd;Kmmrbt}cXS)&~P#;E{_j;JXS6;3y%A41+&*`_pZY@WyK7iTYy
ze~VD^@@f;M0t1;1$(MX+7#a7r#i8OH_Er#X<?*(CQQHvfRPZ~<r<8Jr4fnm}5=}ej
zr8EVnX^rWv@fA(d%DI+wC==7Cr(0%B(-xtMwwOW{Mt4dr0=VBBZ8g@AS3}D+VU(|$
ztJX+oQ`wgIb&2LT5B6_<VthwJO7s+FYu0Zu@bK^&JfQpm_VZ78XjyLXt!lr53~Xgt
z7|h3J#awi>n089D8fl7wW|(A`J<fzZ&!ET{RU8)CnmwuNzhy%Ik;hF`BMHOqwQerv
zrp6ET8p6SW@bq%Zu?JoLj7pAoV-37Bwz}>d2@P{@DAn>HSI-f!SbDW>>LC=x_?SOw
z2i)(tV%W>v9+~DLvX?<-1G%}q9nm0KVa<Y|-H#Q1Fi~;p2~M|7%Z7Ld7aI^A7EmLj
zkGswVvcAuQ5G#`SUz*wSg&K>e4i_6Bf=3KV1#V?e&Wj(_gYWP4dwIZiD1ZXiTL#Hk
zyYMhWex$s2!+E^5P<45KUf-=JQ!#Ve5M5JcyfqKMA{Cq5$4+9j_^)QNTe5qhFgVbQ
zE=O3Jc)}vVL|!WTh+}hzN|_RgldF!7n|qMEzWUVyHZpnC%|wqWKoMTTFK;L<vRo}b
z)PCL8U=s17?QzIT6NKPQj{z(cc;1|n*T{LJp!U~JL4#Xa-SWM<BBep2gpG9ZnFw<9
z(>?iYKh3f`3-hF|zLU%=1y`3h9X=!dPyndgooNa!Ho!VP8*!_C#rHWp4CkWs<;=xd
ziKUN5iTn1Adcn$Y#@Y3cJ6h^m8-jv(lGM``n4o4Vo4oDP+D-eztkzVS*2NPa&5A{R
ztL)(nhyJ*!nSLgI3+;DYo~`clME*vW0uetT-pzT_=eK?jZ9|{AZVx=q#6Ys2Saf$6
ziGS?;ivF8T@DWIjuh%1xRQ2^)cCrNIb(^B&?vArrfcDQd#mCMd8tA;m-JAS0u&tt>
zA3PqI`$q;(2kiVH)M+Sx;eu163bM7el`>5IO>ftAUsOSM#oag}_ebiFo?Zd-Axfk4
zG%OO2XvC-7JQ<CyJESt#?zxST@r<ANrAT;^z7AZ1s(h!YTPun+9xLKIL_eXLR!w*M
z|7x;h@~^m&XtXgZfI2L`yS*Z(6KccatXH|&QaL+!EFFgTl_G-_M?yH(M(mBg1b*{D
zwI^iV$@Y$~x3jv>@cg-YaylAgzqjLdG$AFzOUd&1z^qeqYcb7qS)u0|$IR9$2L|12
zZ*Fa|3bkRz`PXx3F%W>@(LrAXM{;m4BDdKe!4nmvUt?mb43mnGaDXri=fHsB{3(p$
zokU~OwwqrxxP!5*P#5kyqtGX53)>mLk$gAT-Nl-i!^Mu}+MjDRx1Q4S{L~<QR#V8r
zQjZDv7rOaY+KsBdYU9teUaWsth5g}TR*imVt*cUEz9>^QzU=d@rWKa~>Nl_#{zoZg
z4cIOSm|q2Re2FFA=5(Ud(iQ9nz$v654#wvCnr#`SGd;iL8uy_R8TD2$BHt+I2m)lC
zx>%IFipxz$g9{6CmF@e_Q|}&BhX!BzuU`c`8NevQCbrZU>sQ|EPtEq%rUgQl7XfKq
zvZLR6Hy6(a2HBm7G(5C=$B1c%7*x#%W|w$vXV7j*NEqlw-(NjVm(&%5iS=WDx`GND
zSEZKxNc6Q^sU301R8w@l_h|#Nt9=a>+0RM|58ha^cZ#+O3PKGUJCq(yt%8oQGu|TM
z>rDe*^Gh@kVBp#`T}Sk9d`bn9PRF_c$duDzu*54qFONFaZ8}I**_f<4m(R&z6>EHF
z!9MA;*O$NdSa9$bh}%DO@{yh-3<jh2Dy(!Y`okIk+_=1aD(qtHTxEtAwC)Mg%?l2Z
z+&3s5T3<7njLS%)GAO4{FGHPPs5d}FLq~t7(8^m>Nv@PQy70(Zfo88$xgW2#UQpaT
zxCq|6N&s)v`pgKb-5D+^)nOw3tkHEl)ZKCMFI|Im`t{%>yt0{Sahe?*!SF3cTDyNh
z=xaX<2<5Hllu8cx#LL8G-(#cGWR+^@w;J2%F-cp4`t-GJw|45?nYUM4>}qXD(~l6Q
z=C?xViE(OpoAK-x!&^j(T!@q}y`4{|1M$k;8D72|<U@il=7nUzIbHAC-RwqKn0=d{
zOI70PD9b_8%1^Z3Awz(_wG?2}Mn=G>(^Y^`LM`%B`^MA0ItGWlOYwVTIY@rI$-ESL
z1a(+OxcSUgRLM#^%u~NB<t+7NE&@R1oe}#bD~~Zg1;4lGI95eQ;^f65*h~&4<9-V{
zB;w+~b+>=AAlfJ%y3d`p<q()qjPn}PdOMoB*fs|AO?8pJ4Yb*WAY7Qp+LVo*W|Msw
zWQ2q&Bw0<*cF_va%-4Q4Mcgmwt~!HpMjnhd9VL%c5i_r?y(mls&w%zpr=70+F0Tw(
z#x)kqAJ5MYoED({*ixfA4OV0{Rb7tR_Z^SUEq7VgW&q)`%@leJ>Pv5LuMO(~aGOm`
zTOVB9{=^T@-B#%d=pdmt?BgB_uOJIYonl#Ddtx<)JVrdADQ;!E&NKcSze$GEiD~zd
zg1HR)*K-*y$29_*BiYNz?!ulbpJKQlqdA-Q7P^ub-NvJ~%lCYjNCyI_Di68N%#!d4
z@%QJVt#Ikw7ro;>EaR_Or;(BsVu@D#rfQ29H|C5yR+L3NwEd@V3|d{e6W#YAVus!@
zo!=BeZsu2c1tChQxiZBT=4>U`ewF2x%+~s3#wL9$%hSb;s*#$nTgbR1iq(V7(`Plr
zyrF-6?f<h1qAdtU{vFzW_b1qD>Abe@&DOt9kJug$4-4JFYW6Bk@6_bY4fwCPz~t)j
zOARi&#f~T0m9R$Zm0363oFz9m@>edpa;fBPb0h%gWDc9s^kSdVY-&<WDw}MwpPT+r
za9w}?>=PB-+0Dwh_nc30mtNIkc4}hbTq-tOmvP!ViF#fO1u^(+zl(OCUtJ6r$!LVH
zitg_Prxnq++r6}ykCmp}@K8Xcr9_lUf_d5YM*sjm$6{7zJuYe6lRdSH<SIsxVcas+
zH9XMB$#$FXrtCluU91x`^gr(Ulx&Xku_Z=9FDV`S;;OrQDs%Dz0U4Rn_pzP=F(<8f
z6_wzliKo)G+6)^S?O)Qx0R&;;a)0}ZpwA7`tlKk81RdU3JRM;3na$0-^|v(`Xw}aZ
z-7aNrT!$=@B%aeK+an2kz`R@RhToy0F&RL`6>j}kdkz%XN5od#4(d*KvdIA9`J~ix
zlFC<P%Qlni)Zv-^gWt@0WtT}@evt*JtP4Li5G61u9fC>!%4M7CY^h0ZGn{!~uYpGL
zJboo<l+!mwM_s*9ZJ_+BGtqtJM$>-B4%z>qMiMN0PtKoQ!IY=DpIv5~nwFTzdgFNm
zK_2hJBPA^Nb<k_fQ}n#D%2Hkd$UnhrunW|Ej(bQjwFF8POAR`8IU969#p3Y0PR&T5
zw$>uauG`|#U)qU7@*n((YOc2&o$gT>Ny?=khZnCPK#OQ4A~3dG<(bjec#PYy@No+Z
zK}d0rsj5??cQJqJ7$6Logish19WKsPk~2Kkv|EloY<&0Cup_79hCZg-2Fj|pRf*h*
zb>43ZxLV3CDedJQ)4pf(ULCSJ{V306LEhPQey(@A@J+;ae`yN{UE9A9dU)ZiK%^;!
znxg(>H~z7Kl~LhsALvvB-lWIt#+Ee3>8|;&mROLo&2`$k>(u#usgHnuc)8N*9K~2Q
z_B)L<oV#3cOETXcwuNPxj?K;7i3zl|l?|<=>g@5B4VTGWY~z#b@QSVI6OvBp+qG{y
zIyWx5H!ydYL;M}mO{ThlE{h<VCPNW%Fw+I<0QOKWjez-GWfz^HKw~nvS&5c1{_{2~
z=8SKH#?1^fvw-+|G&KH6sQX|Nv~1I?(Dqlr+IJ>1Ffn*Ms5R>iCYeh#g$+l}v1RYo
z6Hq8nK~C#DE!$BBe0N;?H>*5`0}qT|IR?UuN_CO#ei8;XD5TVY>XLks+CYHhi7@~X
z{U|#9OGIY;B8M<5i*xI3%gy%4*4;7DPz3u}(&1s+%G$(xl#9z)(T@Q8Ehr?^P(d&v
zd|2~54U%?JM!C$1gsz?B94YEcnBun+aXKpi*+27(W=P?)H*D1Xd}DZehQ7Jz*fi2s
zN0FqM`F^wy!t~N`s$A!DR@GR~*|;x@MGX0SNN#s6<wZc#*1Ju51q9ZzrPJ$ZGKyGl
z$_@j`j5q3(U9IDV3PA7KnX)t)Bv5e}Y&IS?x<rVN|Cuxh4bOpBqiK9D%UkIw<{pE|
znz@J(h$t8kh}e9J#mTlrLqoAQJc-6}Upf6Oczfu-RlgSPp7oNE@e5to;|q&S=TD;z
zhXmkrfVdppPtv%$DLw$QD4F{wvO&JXWHC*IeI<soC8>RN4V7FwnGXmfMHwq9N7p_-
zu2z073%FaEUM0nl%hl^C{<}u*Uv@J}L3H${Ydh`4X*>0aLQ__3EX!Gin@6Qge6N&S
zDxq2J{b8d<M06f~H6H+w>FZX2E924@MH~<DJJ^)dQ<mywJ{O;{0MnPgJfES@p9@XM
zSIB5eK0O`D&cVTZZg<QLHOyQHYd#lXqqG&PKu{AYdo-j1bP1dltM*GZx)NOq2W*9N
zd*Wm98H+5_?;h#=eJY@(w$FFoR~&|;7wNg1443W9wwM}C9~`P^Nz3j#+9C%P6q4f{
zW-0f5BPjFdMMS8#p6+!q0%<(JYxdAt&#_mYYpBQeko2<Q5O}N&C#1N1H*t47LAF7F
zFNZyUEtrb-C$pG?i;6)qrS;)QvmOxP^DbR9%w@5g_G83LQTi$Xb@EG}X%APJ<cc8f
zC6iNtRz`vH-TcDi<n1@4kekzyJf*Fr7|Ll)He>4a2JD+#)@nDXCdr%ir#dZ8b@_!^
z_4EAo?UM|21;ZgbE3BYzeujp7$Vt%<BI{>A+>c&UjSJm<x!>PJo&_OCPtw>YC<$jV
z3`EnVx{)Y9Ypzf;co$`EK_X(@KoS479m3dSsCvbJb~3lw1@n}jQk{nKa3qk&D8<<e
z!&D42t=cNeLDvr%+2*iiaeA)aFinyR{YU*)*~%1;_<Y(T-5Jt4fH~icfYFR3S8y5*
zQd>~0B*@t(-{04=nzOnGS6fz63g2|2pH8+JN#ECOK<v=Ww^LJffZ1V$slpc~Z(O>s
zd+dDl1N}NL0szU2E39&G?)#ZzU$g#<)a;N=r~!baIKKAaD;uo2K2uN3#U_C)Y;#{+
z4R{|XL7$sUfBZX{7oa;0`{;_(eX_v_N#3oaV}+VkpyDUvkDPq({d7<w^B~j;^kGV2
z2D|6oK*BGWwzfaW0YGre@cDAb2wZyN#YPMzcYVo-e3)CdhRmbij8TRxRN7u~7z)Lv
z#A&$ok&r<$EnXr$%DByAocLDzz{dL0bZl`h<2I{GM>_!!M78L9&-<<q8|cqeB3kV+
zoST&7AQNonXdX3Xv{!W==ymP6cNj<@3omy%&Cmh8yq)bi&($V9$7ah6sGb+Zr#7x+
zdRlM1_=`H07^y!>zyKTJ)f_N+V({)*gw?+N<nz0C++0L_!|n@oZe(=g(B*nvr1khW
z<LPXqUv0aJ8&xsvNJ}fm$e93|KQ77f?LzoTHLWFOu(|o%a;SYnS@#TSgy@G4jf+0h
z(;A&i<BwMn#ah#a0h|uXN_&7>716Tna~b0uGWPeOETK^IrIm&HB~BZL6D=1N*D*PE
zKaiIOxUuknA+r738l7GH`?TIxcf$v1@JMRC>ls#y&$p;Ta_rWNL+XxO01>RlIk`AX
zY^FJJ+EmW4S+3S#LVE|)PM0Oi0>K+t)9v^rM@3$rk)ETG@2|8Rg;=csgnci93v&v0
zh4T`(q?D6E<|&qY(>JcGj8htV0i8M?DU2`Ix;w>dcav8npqe>T337IP*nK5ezx^kG
zsU}sJ(h9MPb1Hq<+lkJ6B`czdEYJky*o2zv17zQY!BQ<Cx?vZ*_*9%+HWjmS&$O?h
zRw68toz}VoIdb=vZOy3p?)XblVk0byHR`s(hVQPI@~6TOUa;w(&ip^H%K%A6V{*jU
z6m3$(974xZXub8ZWY}ycWrIA;r!4zaf|-6!=yH?H({u6)B1|&D<#XR)!yNL%MT6F$
zkLIau<Q6|ui7StKAiX|DYmj{J286CHJ~N4skZsVkcQ~Q?$sw~^fm-M?r_1UaJb(ab
zeA2YRhyaqfwf@~z<8~EZTtvXFBEHC|)$sQGIa|<ec7Z~-z10~8i<0F^V^IdrDW^{J
zIr_*th#b~o5>}$*%<!ARQ2Amm5K(sefZP<WYdJp8?R1SaRnh^a=Gwmp(4e8Qu?Yl5
zr+jnyJE!Bh$qQ;4-8ZFiyV4ukPi9_eEu;qgh5uh|?|!or8EeveJLEh*8dueMJ5xgC
zw&U#{lN1eOUJ>d)zWf>~;wKG`0KN!RxPA;Q=&Io97`B(Ol|TUPd}K{;OgAKGs3`WE
zi|)uXtdy@jQiDnwzxlG1XsY2`LWOn!&UF^(kVeWV7KOKnXa22|E0-7063HIcZxgPs
zI36z&CZ6ddzP&oG^!3~_Z+1~s%xWa-=KI9?A4%08!4Wqv`~ekQ1I<|^38jo|_*u4I
z+Z0e_*1-9GmsUKvN6h5YeG;@ENgO~(Y*7$VP_g*xwNfht=6)u$=!to?I_^B-c?<$#
z7owF;eW>1ioqb(#vh3(vnga1Q!>Ox;H3;Gr7O!ua%wra0-L<dJyp6g{G9(14)^1vL
zdPH21mcF%uH|!DrO~Vz5o7VL4R7sWf6L{W7dW$T_65$sj@@?1$*&zhhel;!Gr)aIN
zNA_wRerLzEHaG50oLmZ30&;DYXrd)Hpk<c+HAbf9ZhmvC0OY>}>H)*3K;?C!MOKU4
zn82~T=Wec+8SIfJ@t}KD?-|PKHg@dVAFw5uJz$qmWvWDOKD3EskLND8A|@v0oN{rX
z0L7|guh#UyF8NZ%0tKAkeH}())9SwittzY6i&T)p|4X|1kIU6Ughnwqt3s-eo15qS
zZC^KJq~xCs14>$8)OB&Oax}$)MX`X7S+bRCYg&dK`_|4*nr45K)=qdWvF(;y1GS$*
z(L-qCyndd9i@?drWkcJr@7XWH^<yGSekthBa{4c2<On}XWQ=3oc1^}WM>lar<@E*#
zs`WA#{?=8}wmY}5#aC*8-b>wR5+ZvyfQR+DD72_i&0S60*Uqr9cqe~<<{&0fWH>fp
zWAjj@f2peXEj7lD2H)3yzw2E#K;crhoVYa}T)N^vF{^BE<GQ-B!8}@TK)@1@=6CJc
zBLzTAHaaW@{FgkNnWNXYx7I!A$%An#UA!52ZZ9mCYQN^no3F25EhMP?Ihm(2#vdFU
z#OJYK10+t$91g3DKpA}9W<`^5vinNr*9Z4%$2mdqji(7OaB|><<n54tv)4HvkP1Z{
zA}}asjR+rV<+puqJIt&EG_(ud$RUG2<|rFj;^vQi>;~KTxd342^cR<VTm3>{AVTWv
zQ`vv6+Nzik=90yS?ZE-c2eX$nL4T7f0JuCJKq)B4!z_NJureqnR5%%GQAou=6B}!m
z4h;=wbc*m8ITT{;mTKc&6B+%liw_7JRh}(YOqX;>4Sw=}j0IBJSq-*Ph9X+avWX&D
z<>^{-Jn*|yMlB(hI$=L~wU?7sb6*ccTg;}QUWVjm9|}g$?H4~Vp<_oR2^4l37i(Qz
z_TOE}f^_2yD=SOryYv)`wGx4#Ufx!5n*KV5#4~l-ko;xn+;ZDMwdqIKU!Oq9MzKZ9
z`e~24Tq`&z#`8CYtp2(mn1$Ikzza;s4buTz!S}d8K#0O>oL6dfy^5-uuOO_`<(UeA
zlF~7DL1y<ULvC#g?Y0F=PH2BoNem-`!(r2fqp^V8hQ9aH1#{U%w2!Z^+3oodr{6uv
z>1t5b;3v#6<VZ4pr>__RaCYa_#7w{Of6*m0?ih^Z)mW<E@<gY#t!KaekRok?w4q(r
zyMcGIb=xMlN%f$7K;lsA@p$Yiu*;-xV7n*xwmTE?{{Deh>(1Fyv8wYv^(NN+Z+s09
z<YbEa0t<z0I&gG>^#r~VdcSaV25EGzXbfz95QUq`E>oQfd#zITOOKw1!~d4GDn)Zz
zNii(>N|=`o1)#E82fC`R#pokD#wMaj$AjEQ<7gbcX=%6=bo=U?1UP(0TP1Eihe{g7
zkPHo%oemO6YJIQx-*{NIaoYkB#ioC>0?tQ>i5L<=alH!q$7(D@6ih2NcST<n@8|>C
z$7?a$tB<^#%`oBz$aat^Pj%~WzOMkNZ`He*obw@h@ZEwKU6@*6q1BV)sVfJyQjWN6
z@WiAaG4t`seM|3?{!L}MCPt4FyLA?8dCEj>y*sTrO;i4hO#fF^_ZJ|VfHqtW-Rxx3
zVGFrL1cxAz+3>r9n2r1&N_`%01U=V6uxY13Jx1cDeB(I(ZtkK!LP+_zS-zjw@&!ho
z$Da-gjYG<utWtG5vV#GBiuld?r+&rmhrgwCjDH^!X@$`VH-u|xfX_IHnz%HuHeXED
znkOHhB`+ff(j;4dh6VCAC^Gg>XmQ{-U*sm)<E-Ap#?xud9c(Pnho&)&kON-UMB$E4
z^N2!#2ndjMZvEl}t;3A0{W!o?+7A&?b^ApzZvOjQFIfR#y@N@BLG99-9=bs4Zmto(
zqeS*f)868Ebw?umCv&CSyvTx<Y}c{{@vX|U-LhKK-Xq_1v)_sSt?CL)8##!WRGnH)
zTbpWmSy(ai1gc~&FcU5Luhi|2zswPwci56v{Ee8gMSLRU)6DKx+_emNRL1zNKMP*|
zB&+o}F*0Z1&7lG6dMA1}HUB_~L7K)(`%zOh&H~ewaM6|O`ufxnemYE5U9aS1>o?LA
zt+ni8%f`BN?x^NR%#(q(hfX?1E`JFe{$(PS1%A5?1{fxSbV(-sYtO{U_>#D<6^#_D
zE8iU?HQj(%t;0oC4^@QuE}t6}gHyeX^TJ63(tg2i>v~sbz>C|?v~jyRlInC(088Yp
zXybQnO@pg)V|>ZP>(|%?=rd3;ESYFNDLR#AzlYv?qKm{~ro&#<!%pw!Hm78o<OVK_
zh=<9|!F3NVW6p6IajV5L4a2Z0gy-c?;AhK?^b3TE?k`*FBdv-$_+JZl<>$X^JkqD>
zXvK8<*{{;q&*~2n!xy3zWPzwWQ@df;od|}U{548a_6z`nU0UvrQcrua<u*%-3S|yv
z`(aNb!a;1uop-@3y7g}<{O>W}_zAY05|s>C0L6AOlvv{8zXMI6<lDLHRszfn2&@#z
zf9mDwy^}R_3HI>x8a~Rr+suwypj-QSqD$%Gr224+S2PRXO!c3P<R7nlVi2i32ySXh
z9jDtyM!GoL$c|F5UHo^D;Q{i#gqaTNSzI2i*wpF59>o{R)8{uMA|jt{Y6N|w9%zI5
z{n~rRS-qlDNN}9ai;Bx$Ra*rHq&XN5dP<#q>il1Z#>X41GyutPoru5W?G*`KuTnY{
z=)%`qMxoiL{!lJG>@LYRnGL4cXeIDU-)Y%)iiJg1P{@{uK(%a^Qi-3%2==RRN#kOM
z7<P4m?j(CPZC2hGFK#RvTdZ+bp$2&H!<nqLMW9RWejQUubAI!;Y48zpiB%XLA*mIp
zjDFw#dVsjyxGEk`z?X=CVE8Uu@I`$8irKBFdYiCzp(!fzX6VhaT-(nh4K&1;Y-~wQ
z%Uwoef*Y!=-DZ(dU63K;$GCB`l>pYH<Sn3d^WW)^95jTH<f?ebjml(!<95wL`4;KB
zV^1aVKhpdc;);no+5SdA4<QQ`n9w{<oYY+9Gt&M{?%<*xA#ky1Xk&-`0}%nCtp5EY
zX$N8E-<p?y9)~CcWAJD6@5}FYZr5u!W9${g8JUL5*u_hyUjJUYX)XmZxPj=*VpabP
zGkl=565pQEh;fR(Ny~k`tHxr-sYh&-HqTSeDzD<`cneA+!?0c-b|;meL$%U^#iCo%
zsoQjDnf9Z~4Ntjjq73yuQHEkYH>xP4e(F|*aql~a%Cqg6d@pw;&_LL3absL^vME}0
zapZ{(#0+K<G(d&|Rzx}@@-I#1nGPfhthdMs#KTj1p18O;Jbys$_|Iqfhl$~)4k*fM
zRjX`%ALuub&I^r2XKyzc2c$BSU*iSu4h`~_p#{J|u;C!=PHOKfidrqGrn&hDQS(eS
z3CsV>{{6QbbbrQu*!;nToJPgTSzFKEDuNdXr+?*~t65St@)3}{G6K1TbZNG&z?^1T
z86M*#ea%3s;mm$9MOH?lZ>^-(Z!HC<@;`dr{3|RH9YwQQXp|Zgfr&URxe^W6TgCsD
zr91Ta0b;vxkuC<{uokpGToOV2ue59}1jLJ66F82%m8F7KYyV<c|L!u8NW0S~zFe<K
z95{i$^ACM})h&TFj6ZF*KXS_)cvPVDas-*uhi0SSfF0O<buC<!l=dwTmt_j@@W524
z+7kC<1O)iSEg25Q|NQ<x64d|Q#oe+w#l_OgK4;dR>tR<7RB)PPP3tcr{`KJh^H-Gi
z>fjf|RKXj+-?j><!m*>7%oQ*9x!D>y{lPU&_qw@6!Pl1^D8lX(dC~tD-~4Z@^Uwb{
zfhH#q9&nb!R$>JIxuz2yNPgEQVHuv=t`~FA!+-Vy;B-HFPlgDTcDEeXI-5`C%|oyd
ziWb0gJHX@apG}+C{N1blkI$5=kgx`zUz)FdKWX`V3-A*9@bu5Wmzy`Bz8<4xCu?UD
zVtpLn8@gd@CqkW<+IX=3mD74w4e!}A6E!1B^!9^|9O7sH`Ro7Yaj90Z5ZW$na4x9-
z0_A}H0|=OBt(jpfRMUk9%xZ=Dw1$TLt`|}<!U|8Zk676|U+W3q9ZE5>v6VFOnLqdJ
zAg6!whw=Ywe}}&;?B8AHcp(7FYEI{EmQ?ON!ueL$CIt(C(jGRAS)yO@Ics&<n;I+Z
z?8FCrj8PWi#{Z8y{Jv{3K>&2&Y6yvFk)G>A`){cr@7&>ZQTqM)w1CsqlG^w2@wvjz
zN^}&&;sb{6i@(I#|88CX?iv318OQ+GxZ1+^zw}51F1>Ef#=C4QkD*Z3re&{?AK9=@
z42s2p!cMl|caih0{5vk>@0RH=pD7msjW*~9UFU?Tri;d76B4-7YwB$mQ~?Q(MCzL}
z3RFzY+LEe>-`nqP=HK<y_>ax^mmB=P1TzO@`{^=SWb#OK!u-B0IU4w!XzSGP(vXPw
z<uBbrSZHx_cpF*>|L->1UvD7VK_D$R5(|60@@%=?hYhdw4%qaQ0L`a>#{aQDvV_ES
z8zX^dr~sY;B$o!rG5>i&|3CfJ9MV0UNM^p+Ot#f=wJmL8@?|tdDw6mmI-$=?U{Aj^
zG;9!IU0L|>?oarDXa!0=R&?Ah{aT@QpE><dO}vaor=9WKi}f`tSoRfC$w?e#SJAMq
zGc^KA0{iN-Wm%uE5CNNn4)4SSe8Sh|0Dlf_w{e8!EW;_j(g>^1EfP1ibdL7E6l|vd
z<&1O}{5}e&_h*!Y?Vcl>^A^WRh8_H5x7Zlx$)Oaj62L4=R&3$xIGdHuab=@;k~^*t
z&}sPjpZ3xE&K3<eW+wIHawmNhdlPH9CY9**Pd$nHFt1D1%Sw&7d-MRfOPiPC-2@2m
z<jB&46LQbp61_bl@XZVP|M$m_A_Q)UJh0D(ULOv}m}{NB5E_U7FH0RIW;_t>>$Dcq
zG{ggxnYk~yW){Q20a{AL?J-}V{n?|Yp*K`b1s;(n6WIP%YfP8NYio?c%ffL+%4Z^o
z8qcYVUgV&&=-)?=vU7K+3TU@mHVEE)_Xeoh1>6*XhJ16p?kvv((4tOrqu6plU4Ld0
zX4P&*OcoLB<5U+u(YO)4vvB6ZFS|GaP89jWO!}P*8Lq@FBCkQAmBys<cE}3p(5si6
zt)jL<l$2F?jEuO9ESD2i2HDtP525<p(rg{A{IE=^T`{;fNG+!eJzWNqtiH{n-9`(g
ztWCu~k%U^bh?e(}_2okLvFZQl`jzuGAfif8=@UrLw=^Lwj!kJ1<`c5hY#Q{vTwTZ8
zCLP0OvX}dwv4dgwL2d;fYUFg}ArMLOzi#fIR^w0BC4dPX-|9?8_;y!7r`|F|@B*C4
zxxR9YK1%N8?LDNxXTW4Skj0j)?^Fb+e^Saoo0*~?Nlhwzii9Du)lcrCk_?xg%2`S~
zpPVxJa??R*GXPDL48Nm101&e3xtAxk-}iHHG@piNsAwUmsI0B;?Rlu00lh~KK$do{
zOK#)~(h-`Iw<+mTpGLljJ9>4#psa^ZNWw@+-TIAzr0TTy@oJf0YD;!*x3+6MF9_Yt
zD9(tc+4-uu4}hxotHM+axa8rfDtb@pxT~eX-@Ou@&;{ujr}f<Eu15~!Xy|kVDql)i
ziEv%TD7;emQB_>g(pfEylv&Sd!R!-*${0I>TsTN#peSo8`o+UDDY{7-U4L-wDq&RW
z$!4<uTeH4pD#pr9!RA*msy9s=%DxyYP~AeLcldiZ`xN-Jl!=E+Wfyj6(UcQ0nL?jW
zui{TwY5L~sSfqE#fKDHDUET9+i+KjlB1R;0)NgP3&=U!D^WC_NC{L#7zY|%(u#^Ue
z;)8VFoF3G?(^2V#nP{eK3q!b|c#H46LZ8ZIR~uU`a4UD&^F)__qYfJxOUz{8+NygZ
zMaRL{#T%+sG)GD>qpui&!WFreT0wAJ_@%=d7|AI$pG^SMT>4(+x)-b?Zea$XWn!r3
zWIy!)1v)tAXlQcOr_MBt0tII#KNTYaN;86O?*h(n`Y&M;X}zfaqGKxOmRRa5lLW!j
z!3sPI3Q+UP&!5Crvn;`)a6z(9MqT!PN{tEZc-bPu8Kn!HPtd=(0g9bRQrrr)KKkdB
zYjdp>0=2PJtL>uWhU8lzL;zLNemZPXYq`esKPUd9H4;U-gS;dtesA;{tit>1ijk1u
zd5$5I_G%lZ$?0sZG~)#Qk$`MP`qoIdn@)5oG)e12?V~~w!_Z7ne4k-PIvNVfDSMm=
zIRFQj3EMCrE2^`_Zk<wC9GI%N!Lta|8;-ZFQ?c76o0Z>I${I9S;Zdpa*C*lXil({h
zW;o>aAR@S++c7n{TQMw&r|GT~GFAn`>w*H{_j%OQi8}>o<g%t4Jr>++okZN-1gbW^
zNqM`)t$i7N9-S9Pn7OQjj;~x5#`@Ll2#6FLuBtcjTiCSw*7^>rso$cbc@|qpsZo92
zdX<5S_)=cL?wU($@d{v0S#W<VzMF`ohZW;Bq?!h;D!fvUwuUK88}3EeFwI=NY3=^@
z^#1SJ&Y490k=~?!dV0DAZK9ke<aQODD=9Q)GPG+btd#Gf56D`2I^?-g__|{4;NaLr
zkCa+j55aV-U1y;$&jv}|bqOhAxia1eG`8p*%$r&T)E#z|gtz}APy=Ulr!H|GDi$}n
zOYodLuKSftNv7|LJRHnkrhz@?X*M>@ZDL%Cs-ErY9lGevyc*<FHd4{rB04l;m0(-M
z6ur<%1WTk7`v(!iz3OIq+rs4A()$KP=OZNsciCS>-#1SBQ?62{VW?iWvx672;qZQT
zvTzCSXrcLQ?sDE<Cq?};#EBgHl=R=;jEV8r$TEQ!)yJ;Jl)lv@A@ja3qlt$h+y5oT
z017m6Sr@g9)TE_j0fnA|(@CG{flVh%0G#XfG%k=KKSNXoDyC(I1~#P^4P{>YNvCn6
zei__m%?B7JH+PKU-Zf_{M3;c?-|-(({->ge3Ga2nA+z_h2XpWCu1x|j+2mq<k_E0M
z0EX3t!oI1gDYQLN2WOX#4_zfRb7woHZztFFe!Tg9c2_tL^fk>yb)&x?>8A<6OWvnp
z?M2IXHmkIfLhu%NnsVoKE?jHtFFteHONM#VI@ms26?#5P-_N(5kS}3juOPtaT~7du
z`LHA1+{k}#HQH;IBVim2p<C_iTxu}>7^SM5%1Xb_Q4U!%76*NLK0X>BoFS+-p;*=p
zrxFjFLA%-JmUeEgS3tknpWtv-3G$*OAz<_EeM<@!a^wQqjh-R2xg90~wmF3jm@?VY
z-JM36c~IqWZk9*8lP~8Xx_3NM0}TbRL$42Bzgs^3$)Wt|vKq$&fE&#cd6hPj^w^Sn
zg6_cc!QK%sQn3bNC>djfZz)lmQncRBZx2xV$J0pRu|$A2Q+_)b*UD*?-f;kpWMWEy
z`98#b2TJl1l0OLMTQmj4W%^Djl1uz^$weOsm7NQTY_Y#I`Nza=$}ji_cDAsn3O8To
z)MJgz*>7H|gef8;wAa$g`pv68$h7le$W2vMVc~K4n4J#T(g_WWC|7dALlogaSAqHQ
zTgX(}S-USNI187IJ9dq|+VeL*?B2BU?~;(3Ia~3(=uEAOv3lFCVE%+j`Re9zxwn@0
z&FFUJHV7uhtBw9NWxlA)km%Ve!-k$@SgG^ex$~mq4Kt&}BmWmB26Qy&a(^=N#%44d
zR309F`{`W0^$gV$_%sjip^hbi6#Mw!;C8oFK+N*PTW}difqCfckc5F$x?PKgLw@nx
zWaRh$cikO-(|_cjFXMM8UE3W_a3Ilfd%j0cBZ*PGRYt}>SE^Ajc(X|kdHs}>`Ej&l
z2nM|S()*ho{<e!sw))JFt$pT+Yy)_aF1Wp^nkqxB-?i=jxB2;nBn;Vmn7=VSZMCE=
zlz%R+!?OTbojb*<in<Y*zl^jJRY%-}_pwC&*N^z{Vn}3xnAiA-63UZZXz#TU6Qf^#
zR>c>??R&~3dn|+)7b}almwB9p$|X=o*CyjO{W{blbz$V#E_Es6v>&_Y`Yum^(+MhH
znX>=E2BWW#p_eXZ6FkxL_!Qw_lSc97hF0+6EbWu5%8+4o{Fc=(4VYiFl;s%J7+#|F
zwE7C~Q`hZj`eCje?dH|rZ4AGlGtj`>B=Dc_V}AXjlD*L?yeFVj!`w>KV8H%F<~7@;
z$G+Flr$!i>`Ax;T9E5o7g;A0wb-kV|FXHw1=gFXUz8fYR_g^PBBfHS!ig!<`LOhjB
zp2wvnv-6eV&RGQa1V#AP)L_@3KEuTwTn!3AeFab7jfjDIPvEM~0rVjj!)!Hyo{)dS
zYzh9yKc&DuGe(gA_<y+2PVJujY9SgkjN|PsAfLuf$n`-Gfry452?;4gyY2%zknTBe
zZf<J+#GA*-`KD~m(AqKJpx_Y>!+KN=#QoUFzLU~jA(>-3K)CCw=Us2Vf)PbJC;r8O
z*>_Ks8;g=Z$e``9Cvl{P{tF_~&HLTz<+NLR1#zAmyCvNSjtFjZr|qf^DTl{<f;W1M
zbG%T!^+&0GYHjVf7PP+leCwfRhfBOh+vPAhA~wBxdLkl=#W(M%fX*?PBL0*fUNa$?
z${uo`<wTo_H^3)#udk0)@>5klfwRjSl~LM{b2%(0TS@Mp_^heSk%xpxywBjyr!^un
zr2s1BVBv>{&mSs3oGFeerchljHCRY_c+Dn`?GA5QK7ZrzJe|+SzOk!<6kJ;tvh3@f
z<KA`j3;R4MxrsqvKl2L<J~GX>s@21xv)A=7;!4R>KSKz}md90}@(SVHCLz~`UBTnS
zigV9|cgvJ0?P5mw1P3=d^uRn<!y!6fp2B$vo}sFBRlA<~v2BxH{!o^E6TZ{8!=@f>
zSn{m<Irp!jAdg`h`Wf7{FvaVmVuts9f(5wNQF~C$j{>>{xjJyrCOAKen?d$+x(Z-4
z3A$o`^QucE7g~5Eb3^in(f!7xjPXh}SFnM6q0E{H=MXBUk1Jm<d2em?nc0odLwbg~
z#)-O7h1j;WK%fFCd~s_c)BJK*N#R3Sa73DqxjCBsVz<djr$W}rI6C%CQ{eXqc7yZk
zcW!<3AWZoEX1%EjNE0L8c*IvmD^k<g4-|HiUm4WrMjOw{g9HNa^S7oCR+pyNv=<8$
zT$dC>$`@uvk=&PjLpkSS7W{fr?j&=xvh9B1R7I%`jIFjQh^$98Gvs+sc+*F}9bagZ
zzH&~c$*WcXKU_7LODb1Dc%^oZ$R}zQxPoV};e{B!et%dUGPS7LY4Vr#?b?EFgoMQ`
z2YH$F{JJ;`X!8)>`FsaHSf{v7dxdqoG1padb>-VEW@5vFue<QMMjVHQI>h77t9NJ!
zmt@`d+zUjSM`QY{*S%|XaSxp^>O<MxkLsrv6ZXGscPCm{1HbcEg?*-SQF<6S>MA&X
z<{Ip%Hb=oPh13N*O&&Uy+K<w{^8uUcG24!E&F$oO^^>h1oi-VGUqnQ0lZU9xq})k$
z_vE@<MRETmV(#MQFZ9c;7-QgJcrr9^^~;U1v&*{3-TrG=blhp>x;J=t@`>oUZ^LsT
zFDwQn^(b%Ji`Lhpi2wZz16IJ;7r|}aULrTQ#}dMgp^yd+?U=A`cUTMe(3i}=PG{bu
z(QK^8^(QiHcA(d7n%#dGJm7a+7u+88#x4pO6O%wELr~{FNk4P7bWZ0y!_58h>$oR7
zQIG++`AhoMy{!NqYk<Pby{}>q2oT<#DHAGG=pq7|;`PPF@a^+`IbCXP>WNH!7BxE*
zBIMQhL?|*WS&O{=>WJS|gFyB2o>}QDY;`%UMH;@qWaE}tu$(f9)sQ)%#0|7RL!x@`
zf7xdh7uVUUujuVLCvm2!z+nS69_n6?$JSg6wP*DfNju*}jBIg#4H6*sOSr!F3gbb@
zY;Ek_fL&GRD>wYw!rrtRH5}SCnI}3Xi-d0MutvRc*`)g6v)-pl#+H)V9Q-u@{BoJ0
zil*G;<?gn)(XKuzH=4%Sfl{t^!|qJXdAeg~0%G9)_C|yhjp*=cZ7e6u&;-R;R>EF+
zg!>021-iF@ZG<R?CPS_|7VQhpdEDtPG;!5WYiC+nQZW7;34X&)=BLpO4I8R$x8JC8
zEH*F%CumTK@G?%ipkkk!KP;!$^YlMoW+PDZGI|ycL%NkqI<4nT3*Bsem6y`^;zwSC
z4Ec|Ht)w#!E?T_4)M8Bd!HFE|;A<Xr5~^6Sf%(@KWlBpBrS><=3HNyjwB|<1b%|c&
z7dv8RMEiL!)c4<)u5O}wJ$<qXq+$fBNmY#NRKnv%R%Lf_k1emb6@HACF)q~23nL&r
zob0N#-W}wAefr|%YthuI@ovN2r7ng-Ax^S0LvO-d%(n^r?37Bmk;_kyJ8Saag;=##
zd0FhiM9~g!-%3_wwl)j|sr8#~v{q<0eQQ_cW;E!!-*(<*xt%F3=!p5+GT2;abtbtx
zU&OrKeu^RN>0glFT_w`QuVn4L7p0T-Fm%C9zce2A1#YQsC+sDul6*#3^H0Q<ux-%D
z-4E3Gqn@Dn0qbp=udDQ<r0+9cP5nHbajWq+T4WoOPxAFA7uEdGn8DMmd*_2eU;Q?K
zbu0rTM{31eE3B*zj6<a^=uhEy*oim5sbMvSlS4hW^HvtWwXHrWN%|=~KJ+Ec__=dG
z7!YXf1;24-AW=WQ-J=xb1A1b`JbmH-|KB|2AHFt4G?77+;&LF0EHIUep+{?%j5Ho#
z6Il$~u@2_!rNjcDuAfPR@pIM6-qzdb2TNXr<2-kG@+j<9Z0k<^(hDcGC_|;JkqGn#
z@!MDlJlY`{Fb5#w+F`FM?y;ao=x6JXvDs(8uKQ76ziD|%kW4d9&8Kw0x-dC;8*VWi
zoMDVG^RYYjMaQoL`;jQXZYL{+3&x0W5E}WPCABt7=2NCQRpqJM*@)L)F=VIGw&yqU
zX|g6Z5KbZvs&&!59fnR@DD*H#WbyqPEMD;+K1b$w3~0l|zqnW!x|z8BB&+X~`8cEF
z5pB@AoryO<-&cyQ#R5JCO}DqTk&$v^ae)wxZPq)3?0O*zaw=LLq#qc`;8l%bPPMZr
zs}lrTf(@OWDl~Aa6Gq(hq%blPQ)9%OuE1Bvf;OI<&od9=O+<&*nIdt7i77+oqzrgK
zh&d~5CH`2gd@S={TX_Z!=U964aX&sn_FM7aXTB;Yo^8Az-YF2Gd}v4+=KD42Whvq@
zKdP?wbxU#GbJf_$OTxSX7Y_6O0^WY~+D!YcX|mLFC^^o$%AsdQe@n`9gRHf3NOBaM
zZ2$Z_4@|9*5>?3wm8%LxD`Wuy7hK68P#BBY8||e^{(MT@r#`~pyai;!mBGsnHy~GS
zw?w_K5EN0v=Sy0Ctw%y%WlvqO1$-|}oz#MuN$|>HcB#OFx|)*iJcbUeZ_I3WA^X&?
zE4bi(K`M@UliLuAV*iW|l~H#(1w<1X2Z>j0O<%tI+}crb#AW1hLGpwK?xH<`g1LRl
z{qX(bOWiKkEn7$7{%uD4)Q0i)_Jfk*M*>&jo%l-2M(|WqF8w$O5a#_~`2l6TfTN`a
zlY!_h?dnyXcu6?$%JlS;vmK>gC6S7Elxsgn3EvLGrs+3L4hB+xHgZ3!k{{{0e&M-0
zRS4JP7xE2-%1B<0Uz}RfLxnf|^j$*WkKRG0<#4jF<JGl*mG@^-BvZuPni3IPb`H#5
z<~$z4d|DN%mNxeUxWjq8Uhb5i#-MjSeFfT+!1zQID-uR&>B#;g5k4BandYl*(#Y^8
zw+K8G)RO_d;~x_*_wfmqy2G9kIb236qq#Z0O>b0~DE^|@(r#WR>EU)6<N;e^=LSDQ
zyb;f<t8A+hLPMTX=Vx`rb&+O%94vlKSEcw|&_g$~V#4M4Q7Hcg?Gzoy?*#(Kq+^__
zYF!e){S?@ExIWZjw@Zhxf|Zej<is)TbE^|U3F92yafKO+D8;?`-eem(y$}a{nTP>9
zkyT~>HTPvFZdxsOF3!!d5i+hf4_5x*N{$Ng+k;T)EM*={*1_Q5r;HVN-*tP(jXq^o
zKUyz!B1y~05~}iBFV~`uWwyK|(%9vp5mGzd_tFTa4DTStw(qG9`$fAT9n26%M>U9z
zF5;u(@!eOEt#<xm<N|%7S;n$uV5PyD(l8Td)iS_%45x7KRI{EtLfUuN#nx&%M!0lf
z=pXGVZtCbgjiKPE9!`U0=q90`_JlNo!<%mij&UtMw)Qm%7KYv;{!K_B!4o4A+#oxz
z@Q1xOm#^8VpJhb3CMEQyBX8%JEAuX9vb3ev^`+Doeaq9OrVe<P_wIX;95prkmUzeM
zM3+QbEpP71XQI%)^<Zt02Ih!_EgzQD(6M*q^P=q+8yO*nHx?M-1L*5-MDJ*Z#_Hn7
zGTU$cZ;P_$cd=h&xlC6ArGz$Ctkbu2(&Nk)q3d;{Lqr?lmhc042G!Sm{>sa$sAXiu
zR$eL|)8-`<h>!ykS8^G)E)E5am6p2eLtmBP`ZHAt5fq|qU!FcwKVRHEi@agAhx8)0
zyqu>J0>!&KbDcuSu`aA6_~akIahGm^)LAZ}LLURfZv*pGzBGTn>l1ZkCn9=QWf$H}
z<sW<6s%w(niJT$eE4KJdQu->@1y-cl%`kqcRw(p2QLbwulFs5KFpJu`G-TH0*UH!C
zq!h&PS2(lPSuQZytW(x6J3At*vw0Es;wq108G<ot1LM>}tWPe!1r{JLk;UPPTJ@1$
zr2>tK&^YBa&^>QNeAij<p2bbnx^jg?c%w?9?LRiYro6bGm0ei>VP$L4clPU^#P+3<
z7u(cXOMM)%Kjr{dCfG-bhgWh5D4`p7H?`fY4Hu+*@J^vO%zcfc=DCt-{?y0(|D44A
z!!^M@E51eay4e4$QAU`wZ(oAhx8kBzssFJ=&8Y8a38rlxPp(V28i0F4yjYgAxWR+P
z`gUVNUr<<>sOw&h%*f8Ydy<RbYn~BDT>_cPC~5bI+74=xTT)V1B=W$xq;%|TP+I1%
z?me9WDKBnYFjm*md?XADTB-BOgHOI2B>-DEqeA5|EUM#^6s0GURuw49L^66mbj~ol
z)Wgz$Hy2mC4n(G^I+dUjA6IF*uckYG@__8pCl!&c1+kewW!9|xS-M%K8i;>Yq~Jv{
zr{?NSZC_Z`A)sXf7WJsRz?ao1kxamw4hi%V6U)ud?{eDX|2{xZy0pBsas2I>l1Moi
zlhQX-M*L&j0Ja)LW&Qe#TFRL}Y&v0xMD<smqgtHW7Ij2rzI?-W9p=w^zx1ij##h_d
z9y5C3-|#f#y+G849+2xrSt({ZC+D;LUqVD<hTlt-W;ed8Y=pBZgnXL|{U*-h8Bh13
z7mgF<Ro}Agh<Np@9LHy}QCo?z#!w4&&jDsR7~$KJ$2#On%l1~7Q!AF?k{v|A{t2#-
zu><qcK`{QH$Tc0DUd(Q!z9nn^kB8-EOBa;UxFktQ_~~1Q)!rp|$z-5rNs5y~S?lQa
zQCO278sca!A^+*X9qs$~SHP%AF$l!;!zSbf-3SHQ<(=`_3-(O{e32{gvuUrPYthkN
znVMOmE_4;Xx|aq?XEm0_le?44bKDA5v~NhF9&@Z*xM;{c23^_KZH7ifgpP2=qYC`5
zNjz?n7p8c=b17v?XjU5YZ^gZTO|3QMTpU0gPx1ZC(<H-*c1oj??L>EO$UrSSqr!U(
z#PnLN044VAy`{;!;-nx+Vdt5P8AgR;1A}&<0=flM`@P4pXv@{@@U?a4J{2FzF9pgz
zyj`xkWpK=M8coa{a%1+>>N=MJ`Ra#6*h#gxRCEt>+Z{BniiFQ8y$%h{a~3o71$iAm
z{R($@0%YPbQ39Gwu0f#}y+9VFd79v1)x)wyk$j5!R>y1XT#If)Zg_;#($eThM%f+3
z|HIf@Mpd?DOTs|nlDNCOyF=pc?(XgmiMzYIyE_SqyOX%PyYrp<s;c|e_qzMlPsZ4T
zv*D~YC1ylShS$xVIiJGU91UCU^UGh3iXAoTw_q){>ot^#%op6Pzl{3J{84(O5?XMz
zC>M>(820Mh+w3nB6iZ~IFr3Imqp`^_CCkPaEwt9n_-Z;@OWTR)#iWMH?>7WeIzclN
z3YbSO_A6<p#PHTK)U>iVtL>(1zr^7mG|_!n@b9}QtK$eCV5YlN4cQ?eAiQ5T%re--
z;In7;7t<qna+9*09~Q2iA7}PC2mZ5+Zf}Kb@8}5nfvc>y+F}!8GOo*P0UAeh4+{em
zxqWn0y`{oY+&Hj1NN+G#gnqr{Hw<?wGg-dH(ANq%Pkv}%>{mT6|KVyfnP>pa+w-*n
zEVaZ<^qC?1R8VD<vM}9Jn96cTt9^8FQv1gzmd*_W1K1oZ4Aw&!XTc2z{1LNKZ_tBG
zz7X>MWFCrElTG<CDLXq-f!GxAoP6L_>qoxAHu>P$OD$jief1@jVn{9(&*&L73-0?>
z*>!}cLL;vtA3NDv>t+84Fml~?@sp&o@YiJ~zC9<8B4+>KBA5Z(DW!+Y&#t<PgS!Ll
zMGcvZuCC9k;MV%*i-QbDr}VE+z9L4DyvL%Z`;e7T&7VJ;uS!q3tV&OCLY_L|neqH)
zix7b(B_#E?d>e(BKXlx-@<*M9SOQ!h8tUH#s}cKJ3Uf%YfM?8WW1?nZB_lpw0VR=t
zS1W%bBT5ku{rHM3WyZ)iM@}6*Y!{X6!PKwU?aAyAz%ya6-}sPoj>xObgZ$_%P<s{w
z)x9RZpuUCg;Ij{ge02fJ@0oSu#_J(?!Gu(A4_aO<lQD_NS`%J;DKdiCclcvW1#kU+
zfq{gZ1)K8=+wBuzDEFrvbC-HDTxB&cr?1O43P2So0})TS7fAXfR$!!FZxHU=?W?<m
zKtR0J;QP8~-(v{HLkQckt{fj66FD6S)6eWH6TjMge(gG(GH0X^iss%TLL7w{0&hv|
z@18&L@%s~*Lr>_@r*%coC>i43Z5l&uyN1%t`pgH1FYhhjpqBr0Q5v1HKt3K32x>#>
z;NWD_Y81Iwv*Y13XsExlmxgoKt8Wk43=8nxeq3hz?Viy)hjiWZZl4_Cr*>M_00(dp
z5BK-~_^YZ6=V_AjbB+mUX!R6el2!3~DGgIEi2^Fa--wlK|H3R3?YwPU>Y27)%TGqp
z5yZ=F<A0f<Iq}t`D?EeW`uN%1d!>Y)F1>c@EiJ1a18tS-!I`31Qxl0c4IyHbNXkhG
zMn9!ZV8*%}!IwMHWj*=+`oxhTIrXnR_dj5o>x!V_;eKzA)7SfnPZp0CmzNQXmFWE{
z$7B_xsvPXTuP4j1g~RU77oO9TXX>+GsKTO_F8$(v{9bO^xA&CJujTQM0w6?pOLJ8T
zNq)C6tG92Y{d!qxAsIIn1-j*NCKdXY5qa2DY%dI?HOI=>Qd(MDGSq16kdx&5gufZx
zh#mtem1aH4k>__cyDL%qHemNO6?g*xRN~W%A9_kK<CvxMu#nw%%N;Tndv9;aM-a!%
zN{mN`v2V7826lFLNmwm5I_k?y7Hi(0ca#X^;)nJDn9@u^^Hicucbz`Yira5>C6Sjg
z^Wuu@nE)d!yEmB(_9ULriVX2lq8r`f6kVUro%?X7(*noR)UMJyv`V~lK%K-CgjDb*
zbHE$RRgzr2_)(Rdg8FA7`f07E8^dc0vKTWvw%TN4^}>8v_bH3w%-ib;!w)anrEBi~
zY>ogKKPnc)qcr89@?%r|)@u|TpYIaP{4|%?P0%@lxCLiP6hxj%q#&;hjqhUse|iIx
z9ChBiI<UckMDlErcYzw-^1%MKsrS_G!mQ0xn-iDxke##zL+LGoh1Kb%XL^vEdKO`%
z(Z`~w>d0smr#ZOblN`C$e9G4^2>ZLvY)*K6y?F0^8AoSh{S?7tlHGYKb<$lU>om;i
zTB8HFtyMxmFFjU|8|Wz}$cUNT5b^lq^G=<*l+7FV@e%{FlJGtV6JRV`Y*3H!mi{uG
z+aYV~h<=h0KO6#tMWDhkKRzvm43|gdG1!XYR!}#S>vm7m&ulq#x41S7JfF!b-_lD*
zgk^l(r|1fTi0(23SfF{MM_WHTnA_~AQR0rr86mDp^7`a}jMpw^OQyrGeoskJ;7_U1
zx@#4M$B#3`-V4EEWAN^i)?+qqXlDm+>9%A2r%-DFX^7d9u=q}M*R+4`P1r@xWp(Z|
zW!>yME~_{%%j0Lu^#1Ee+0)}EFY86LiM0!$L8SU;gGed$HL8R!P}wq>Tm$w3=I%MB
zjhH|2{Glb1E4LF(G&AsdcqaITC#J#i7lQXcT$lg4RkoBM#-McoLml&V4%lg4b}&4=
zOZTH}L!CaaD_n3pyK0cH7~I~yL3DnBkQ~_`j<+uFx8qySXSIQ8{C-?RvG^7CB!NF6
z@Nt6S`QNpvyiUvC7`+~iDZ32@ywVs9QtWwfYnxJ$>G{$lZ-ihAQAQqG+B!J4`l#m}
zXQ~7dd)6=gk2x;3GOHQMu|d=W4Jn81U73_E3;7Rg-d=6Aqod_TrKBT%jW)jBtOVZe
zT&PrmO2h+)e9s7*+_D-Npw8y_1zN!wu&tjxEW0Wx&g;j+^<rzHwo959Ruz<(on43l
z^88}KPmwgV$dLb7Q_=fw&MVa#CqIrdDIr10L4p7`2ti9(x?EHJh5-o&Gb^oB8Z!kc
zq2qAUZvwEh7o^0Z>)OCa%+ZJcaFeE_miyV&OGZkTi9<vzWCpoSLGw<f)aBDPQzwyz
z!uxAd=4sQGydR-_P(`JbuGQ4@V)d$;Q#&|zQHsKxf0JCH5VGf#UazV};HF2ze+tqc
zP4?8+t+|`7;N%$PYaeb@6x>A{`he(URnXmenH|&|D^G>*{jn@nBK9rgm*mKbq4dXz
zcsZZA`!ac9pg$Mb&+?eSp4(of3+xe8@b8C3JV!>h))jtM)-2w^f}u3!8jtP<R=k{6
z_nwTuFt5Il{PATMl8JaRtb`TdHxU$YwS$g)HFR+i13QI5!I;kFBO?(9!ipwV-OXKu
zW;~5Kv5%tkrWbytCel;JlZ=G<=QuT`B>bM;6jaLAD_d(U`N^#EQy?u9M%S)XslP~s
zmcs*4t+DBfQ^m0UKpPa3W5lqw=MPe_?{1^3O6=n^853G=Rxb^EWy>;WbtdHC;_k9v
zhJ4k>4-AmHq*wvdk|pt=q`DI?YN(CU%HlkMr=BA!T_ejIHIK{ETR>YEmB}G#K@=+i
zh63zQLQXEm2ztGA_e{Ww@TDUqKIg8I`?d<(b$<@>`xujQ<YH3i?(R+y9wK!2>3;Ql
z^UWM~<Mrmx;*qfhPYHH*Rf&g#_G#FqJI9;J)UEWa2!Ki8JQFM|^F8;<srUU+z3Aqu
znQb&{vT0OKtJ@$ivM80#G3&!vR;%QDj56ktQV|pAOz*G)njKla*OQ;S>rm&+*QfJN
z*Hqug1cLT|h~LYLK)OR7^)w**cacOu3mnvTx1hlD^Jvng)S%PrA`XGrSrLs}VTDPz
z%#eDY6vNMGbFkWO^#m*OI_yGvKmHL#l-L&Jx%urQ>Cx>OKw#w0XjB5QZ&RTnM;&-N
zGR}81tL{mgD+fV(+DeAF>R_*X$A-|3S~wxpFtW@BFJl$mW27O9OD$EQDUuD1y_&@U
z9{GlfvTyWO)9n7-b96w&Qne*1;q((~fd$0n%(9z>pV`Q;yhU7>@8hF8K2BdVzDxO=
zs^K0rq5_$jTv%^Oxs!v#(*6VU{(;k26GUDuLBW=6c4~KJ#W=;snVc6%F^vZ1_~;)f
zyRN5#qGMD-zAX3){*Z59I77issrQ|lNpf=26!khKVUYfLyJW7en!#^K+?wSLfbl^Z
zpBJ=di$w`Vdph>2f;+w`WqMzt4>BCqyO+e9ul~%osi2bI#Ss-{-!wAbsuXc`U{gfI
zf*P)g|E*cj@XKuk?NAYGJl}rV_wuxLZbaRhl&z)&0|DEBm(20otXNLd>F+TRl;`7$
z6hv%1?L9pj-@p{7=qYc%ML%7Uvh&=zP^9p?i{Rna^i$-S6~exI=vtj8Y3V=v0tU*0
zSj0dcah2uYSG-4HkUP%!tS+r>HW3JP=t2A|1683^@p5aE<@~#b=uhTE6);LsZO|gF
zdry2mRX-)idw=p6#PM7&`y~hP1SvX|K@PadsUv`cK2sd*iEN5sbacCwSm$1i2_&br
z$++Vk*C?X--7SdhD`6m}I3g0ze_0ZCBK^q`29%Kea_G16Ho_7g55%C-o{m2~)f+8d
z@wSPl)VK2PpY%R|6qdjxeG2{pR&RD-R8*?jD`?Z(pug1mdV52-zp73CE{b$C9aQMT
zy%8(j{p$RU(vCdhDGY#qNE+ciKSAFA!N8PMGOm7;w$rnlY*UC|6^F}^jL)Yqetmyf
zJ6_g0`^U{e1Kb=J4JJ{6IQ+xz&#ICWfbF+~y7w@Z1l685&bc!`<>}U5Qj@BSj-Vjn
z2!{VZC))p0&dPg57DxB=>3zSAMS&CO##UUtTB%3<agUS1`}NKZsP{*VP|(l<RzIKj
zpjWn>XQbl6*laYTRI9PZCzH;4e8dD1!Nf-(w-aCf9M26o`cRn=P?KMtXTytyVm~_<
z5>JVwEiX4XdkRI9OL;kVG9izQFH_OX3HZG~RFB>i81=^|C)X@+b8$coLi2HfL6Td-
z0=v1P@8tKq+u7scaZR5uV#-#<U$fl$j!+ko{*ZjlwbP|ak}ypfgY+M2K^{{cBDr;B
zarNz8%ZrFY)NHnifgq0^-c^aL`*?y=zn}GfhIqzmqAmC5Nk}0{x#%iF9Mfg@+i`l{
zzjG_{84E#3i6Zl=ZZ4v2oke`!-V{Ifs#{(>Rg`&$<yUiQPASH*I^!7{=fygS_988R
zN2IW3B*Wx8&v3wNyb7aEMg+Q;*A<4Rs8sjlBaQyjk0pt^NGf0<^jSA!3n8Lvf3G?a
zlpAcrp!jHoWMO$98Kr-uqkZa3QNVs9Uf-|!<#NGy;iXj<)~_!+=h%E@=Mp6x&cqJB
zyq4qN8J2Qq(b`f*jIwL;A|+g*q4}+AXZ(%wB!jMNKNn5%S8X;&><NUNWkw8w-q_ih
zhr=>USwAMagC4V-@VB^wFnN$IH<_nT;?%q5dr-$<HQ(lS1l@j<(ecF)6&jj_k2Xaq
zlNpIw;Hn#5fvq<GrFxHnCxY6i*WD8pbRAFU-wS5sdv~<C`tx#D*XLd3Xw`eo?N{Oo
zzzarm-GrDMkG*@Y6CMwk)}I!%OEw=UMpyXxwx&!rlW)?{wUjW7y#_<u2cDK0>+8ph
zDMv=m{f=m>yA$K>B#|BSR@(yyFs#$R3PWY}KTc&xA8VuT9BQh&)jD$uyN4+qerb>X
zXDz+F5meXRlw{Y}CsyFc3H5nm;gQks6jl?nioonQI+$*e=HplimrS;gpmwLNz$!h7
zc%Y7^S&<sGr`jmzuS>8r9ya`do{rwiR5x6%i<H}#-ygJOaha75X=!?Kq3b-=w?Uu!
z%kzmlrxkbFXBP*tMf)5drdehnix~oW*S=*b-uYp!$J-Vz@ggVt`w6HTG+0H@ED8Kk
zV~t6%!9RL@QGgV|iR8*D`%h(Vd;I3h2q;Jp2=m!>E;7^a_uN#s$BHR<h<KVaB1Gl2
zDCAqN*1;=#Uoc>FJ@MZj@fesb9UkCz(%Y!Ul$h~FrulSOr3#rP(FlWTU`+az^959j
z6m5wInNsEu32>Wvc9L~eKi%A@`U@D<7=_%O=_R_>o7k;}3$)|obUU=N2I51&g*QF-
z$V^gfrH!mw9@BoCKM<#q(m$QP%sHJ4>YgEkg+^&-E66Q_r(e4)-zq*)Q|c_;F|r<B
zyOz(yvRvP`AmAV#nb{BqfA&l|izZKkz+QDSsbradiZc&ErnkH19fLJ62FGsR4X)tT
z9Gw#3%XfDMK0H}k>(Vu5`4`Gd>#i5Gf&>v})074&zEclR7oM9k--<6@c`~u$j?;_o
z-jErL?Oxd-{1oX=^mR#`%@43w!p!o;MhzVzde38YC}N<dQfQ4tH-KP<9(&}gz`9M5
zz*?Wqa3?&$jzJ5%0w#~ireq~og1(5A$qLZ8E6Ly5UJD9^+&C)m1aWg?2MEvMc|F~J
zeaYkmKCcM7G?U5T-Q%~tNpw9<X|q`USuswc01#pjlg|Y2F=t?=dDzsLL%57C-lUrq
zf;owSG(+1dv|0drz+kM3t9=faG}R>bXf)rUM+8Jt0DC;TIGh5qSUsu%$JuRRbKn@8
zJ42gB?LTa`7u-RlQfttsrk$?mq~y}q&;B&-kex}ZWbt~960G`nRQDkEMamr(xS3@)
za=EOHNh=xq@1Heae`=ENr$2F9x|Sa-n=^BRvCoj((`uYW%U@jR^;T!eO^b`j3;1xt
z;MW4Nfy$fP7nC5h;W(%?CR^v5KRg@NT8(iSaRxkQYZ5p4hRp?_)U#FniHbgJDah-)
z{&txIMa<}N`c2ZyDg3JS9n>?f;R|=*wa}xI3=;N{UA~6Mq!Rs;{o7s$kD&quzSEtm
zC@-bhhRc)w<igj74<vrq3uP2#)?)ctK&_v8v4!2)1o|0zo=9ZKL5}GY{g>e-OyoE(
zV3J4>d}<cd&+lQd#c+URj4Q3E-P<Wd)x&*i;W(0}EanV7kNL-jb2l7NJv08<oP)+{
zRf&@|;1PEBmP0zDjs;*!P#cLXqCgrRuI@LT2#Go8=rKJN3Sq6z^aq^yMo#xuIWg@*
z&EU~jpEzOsQzub)(GS#Ce}X}?71^T|rpK@8xTpq!c~y{q>$u4uM3INLhC1E60k+Fy
z6D%4abJffNL8Xso1pGLCwz|zK*9K`0X1{XdZWbnX%XZv5n4p>9^2Q2A6WuLe$6Yaf
z%nfF0T1CjKkBGG~ZJI2jV;}f7R@l2#)1JlRrL)+bJr@#1;7cVasBJM4u80^0fYh3%
zM@I*{Fqhu&1jeobi~-Oq`ghR4kVlc)o{gCz3n2j229x5(Yr$c-GV*Y{Jk-o;sVJAw
z$R9IyIxy2+CJKie1-G+BBv8~K@ALJ?5Qs5Co#P4mt4ab=PxBRXV?%@BQz6MC)i;d5
zQ9Cq_%Bb9^=K6;hjLgO^lNOG<+nVyC&%~ermorz|Br;>zyZfYeiiSS%4yLKnoX|%+
zGCnD<*h1?d<o_oH?tdTjRuTZur3J7U8oRcaZ=lSm;cyb$5I}8_8Y~I0*EW{~h*5@M
zr-q*iS0NuuUR6b3KHLs=B&BJ+9|GBs+%%RH`D|JmCPsYX05VxuS7&=Rslm}%k$E!e
z%z+v!fBO<i<e67x)^24*+3Cs2&_t#B+v3PbRfl<Jxf({%?VRvJmO-mjpJ2P5cUh&9
zDHiK0W;VstOeuVBXQcbMVyUO^?(biCqGhLn%d@k<fYcRU%eO_uUa7jw9rCn{!I8!1
z@V#~lpsm5vY_hd%m{LV0B>Wt+D&=u{e$7yAqn~a&eC?@IasSzSlI(X=3!KJCp?kt~
z7Q=zlu^Ul_vd7N%D!B=aw{)}Mtw0eAZ&^<B4bI!qfk*SrqpGr*#^i!Av}H*|fH3wW
zw#G(30lAuCqSKna4RBC>m^QFXcOMj1z4A@G-mj|}w(FAJJ1wGfZ(-p0)BBN|b2)8^
zR)2Cj)Ge2PAp7Y|xlg+rK*kXh334ve`O>l9EqQ3LZw5+HM*v~scW?G^u6mqCh3y6t
z-QIsIjZ-rJY?oI!tBUfdIk4Pf|EV+K=T;u&a+|f73FHGmf?V_cI4AyhmZ7JHo0Q}t
z|JQZreI6qY4i1C!z5ox$fo@wRkuZxnP6!ZUbyZOr&@C1db3>7r_6uKYjXQq&^@uub
z=iB!(-aB}}{769v2!Q*O=}9TT0$V~6lQTgR41g)^I?S8*Df@_I$Ckg0E7?Xe(@%Rw
zJzOkRA`kJ~w<?N&uh)iMVWA98B9%wo&Gv?JW@8wPDz?M@N6<@JAFZ(d-VnY*X$-{S
zgvW&bGB9vYUMQ>abk4Ul?kC<6#ItYSk=O70+E#$xlyPVyJ(hXLmBX{eyW;)e%x0c;
zY5iBD6H_qzrFT9G0X64wS4_sL3od-Mqjo=QHAr^3ul5uuRir?^d`2Rw9?xl;MpxAS
z{uv}Rm2aS%eHonFjsdd}#j?6mgt(RxX~RxHMVTl`pb!Y_+e+7tmkhv45L#|2F7OK%
zjQ22t0>}saQ89!>u53{yqt&`V<F#dyo7Lk(I`fh0!r?=53Y!!mSM@zzJUR2bM}F@$
z#ui`GbF&<DhZLEx;Y4Y)V9v?Ifp?cGWpjS5i|sxgiTUuwECuow{=6^VS?!?q=Bm+a
z+gTJI#i~E05tN5cfD0_|&bSMy&bSlbse=}T*<QDUg5+<AiZ%B>?6b$0vP=!$4ITmX
zKLOzU*rmK$RNSbAthbOi3sn3{*gg)fGn8SaCTnME*ps<Z9X}s|Wr{n1*zFct8pQ<T
zm*jt$4_oT0*XjZtc3neShC@<YzWA=;KYJ|mxhNDD9YKGq$?0cqqoMpk_%ixI9;cA!
z6+P-w+|9@8f}`0w>l<SniQqmx`I*-wq$24xof+}xcHi+g8mHYUm$|&#I<Kj};KN$v
z5<nI`mAAeGw%W<BHEp_aQ~7!}tl23e)BgP{lmC7JuqtC@o{#d+n&R!<T`{B@ch3i=
z6+3-!Ztvw?nM`L28YakbZES&v&+87B_uB)!`pu%)m>UuKj!SM2e*9dErnN&ZCVnpD
zL$}Wtx2Mq>+1^vFG3?HP&F5zc)0EicsHTNhmWRiZC^$Jiy|*m$Z%@R*i|bFL3?`>^
z0KRU@_mE7Ax=GQ0a8@tb(-hvil@6@Ne&Mr{KA&3WJi1(r8?nax7ti>A>dO3~lo>&Y
z#jsA{)V;z{bOhKy^6E?FCITa!7MGFCaa4oizd^4c^sUN;MPOZ7o|7)X+tA5~;k{<C
z+Q#1P41LX<?eBw3cleIY0bGiMT7|2BWGaqAkpZBQxZ9r6($FR>dircP9jEb5M@~@y
z-MOXq^GaeO=b@+FwzwiTW{xU1-cdycMKLcSI0}CRyMz*|8vm!LjPn>y$!c<m_e+8c
zmJrZwjHb@utioA%4oa7_1Z_Scr}sp5NrjE-=jdGRY>Q33qk{+8pQqTH>4MuRjg+2g
zyYf(*dAc8}O^>M1SM=W_2LYT}xDaCcH_LV<_t7tLVbqb4MJk-iHT48O{94>ryGCbF
zND<Fw#V*plvNb@0*KBrXuh#G&y>fH!RBq$Q@Wq#}o!9PQIU<f-T%kwLm5o}!06yo?
zMaTa-q-U=mZEo3sTc76?VSb#YsBXYi5!H73A={IEn`K3^q_td(uq;FI{A5`bJ%!?=
zV>VHcE=})5bW>mmDWDR~BV^CVsaUHrIqrHnhvf6-!nmR?>8M$Z4Z=g*gYf<Pf=0R-
zG^q{~2!Roh)rij%d~mAT4R1UTo)2&}T?i1bcN28K8dKweO_Dn<YX?7oC}%ulI`EpE
zYzSG$#RCnX0QYoMBmY#6FMqw*G?QS@Y%U+G#kaD3wN$PGyucnG^AQw{ce^31=`o+j
za?I9sU*TR7Ef{F()g2`r8}QB%@l03p6vD{bFbveqauO$nLFC&6fCOCNRXa7tQ#cII
zZUJfk^lU(cQktJ%JojQ+z%(u9N4qovAWukj(lNol=>PdKs2=pHRMh-X$)4;=p}hYx
zW2X+s>+-aZSk6d+Gz4UlOekc>e7suZz{>{8kk=3Px7^PlClCQihQqAWTl29o<}GLY
z>;HDB*ATAdMNC^KVOPWM0IUgpW52UwuNBMgQwOoI=1X2>?B1`^`3L1?tpqwRIVsU2
zHZrIzj*nWvKOy=O$G(>Vl!H!@E10j{DL02$fPZt;k$1A;`r6T}hbdr;ATBMf00X2A
z>dLp<_RQb!lh4wX5(cg6_tP4`V$NOQ)p0;woj@bBQIRm?O@P6(>zN%uPfX*G6BdRc
z<FjmA&H9p&5Z;YdOQ96+DEBsHLo$eD^p*+0JdFlL$NRAskfY|~sS4PWNOU^fW|R|&
zlwFcx%mx^@r`D1Wp77V#NXAFyc!AK-h3xhu&9F(?>{j7C7f=XEKRLC8u4lWsie(h9
zzxJ{q9<^su87de5<pn^skN^VMGLlsQ8Mgv6c%|X?d&h6h1zNJCEy(jAKgSL4F}M?(
zMPjNd+K;|HfCzZxwl|*fFLtZBF-ZI54BN5;=^w<>2c8L~?q+~o(S?55aJnB*V33l!
zDw-~%GXXvK0z<tHnoOl0dYdO8OnX;(A2&F&-4;2g*j>UVG!}O(InaSp?tXc9)X4Kt
zx1YfX?QIjTRvv7d?8RGtM%sVF^p1;@-Jk!4eEs@;&njzEZ~RWWD&HZ%Q<l?*;t>|l
zoLPCQz^uEaHHgr^VTURuZJh(9P{;+*`8J5@dhackm~WUXUZi5hwfLY3Q2H}C*tKw9
zVwv}nhW9oS=U5d-A2*T*^hPHAjyfBY)d%3y^@anXV^98o^-lzCx&(#=&7xhe%rj5^
z@lUV=)BNutQO+A?E$cNVnWk;-bRhdsJtP+SiYukA;hxZMr#&{@P5t48rHdk>^MZt$
zfqVNT)dpBD4TC<1DYY$ozbN+vH$Npt&feqVzun9~^-6lY^m6TfZ1;o?jr>8XZQ;sA
zBBwPfrk(1FlA^3%>xb7vo5eV#vN?WXv^&I>>|qH95Du1lqV@Hp+<ITG7LkiJs9OJx
zNmPdj{K~zXMCn%Oawe)?r_Xw9$3k-mSQhh4zLGrLw)jr7isnl6!+e$&fl#^gtRi#o
zuB^jsfZFK)M@PytMdI-LWSYw9R<4=!fDZlb^NPV$SR{y#p>VquJkDAV$Hg7NfAak_
zeL4h)P2cK{FgANN^w-BwVAn_D!p(L69{luhNAwi|IlEMPuUswS@sdSeLh0|RjWbq{
zDTaUwas8uMzrqt{gR!|38Xw@Ru5Q)a*UTK<cN}v1D6sys8qFH*7_bLiS2erxG++M@
z-(kZl?Rr!xzRfaQs^T+t$o?t~_?<^STmw71SO8zw`t1@v(Df7~gPomSuj?}c)#&}B
z`=(xf%c_>HQh`4vQBmPdmWw!44UIQeL#`((?3x<-`|aG<PDC&y?5*0^1Sx>t%!0*g
z<3GL=zf$K4^Z03dOxkLc+LFfi#yBYt@x^QhS#TmB%p?YHk*syuR>>cO#}mNs`c++(
zKm-hsDO=y4&#O@G3BN$bH9WeB@jAGLDx2gjiw^3an?=Vb<u{vXlc0<N=zacyKJ}{4
zxYctredO>?!o~qX&Nf<1)z~Db_$TQ>;63eO$T{o7Sb%&evGq)-9w99-1V&;b)KLEt
zE|o?V1#I}h)Atru1{OIaT&N-+1K6UOMhFybFv&O?*{!C2<5dCZ72W-`SxjweLakMt
z{YySM)tLy9E@ern-{)2(iBoc7Gt=BIiXdlRjR}pwm^LvM=A513+HH~;Dmc(<S!)Q1
z{Zm7S4X5Hb3}EFU)?z$&=2*o>3;7=kDS(_+={Hd$^Ey_s-*Ja|5mQy)Kk26l_4r=~
z<Nz<+Kv-QH$X9awLRy>ic=NbozJNYWuK^utY4C!_&#AS`N=lAfS}T&5Y$sH%Gacuu
z?zSr?6V`wPQD<PHWDtCjA3-Lh1O_Q$-yDbJf!oa%-!Jsutc?rr@>Y?BM@a<2yHb~9
z8g4}|QkcVVSP;s|NddbH9c=b>N+$E0bJ~0sp;42qf4V+=1v4>>I$fhJM=#GhI0vFI
z802vv`V`7U&U1NT6#qt|1GY5H9~CN2%&DW5C{PON6|c^4K<xQ75<r6AwF*rC@gtDI
zWHs=3wei_Ypo2mA<6xK{cD4KAhPr>RJKOko`)eayLaOhF=o2pwH~^$nj-a$0&aHUk
zDgHq+Lh*P(T1!OEtyc9!U#0VidS58Q$;oZ-+5d+?#7hI<X%5%(CZA1v$$auQ^%r%b
za~LkMbeMUXKOiLfY;P@^yQmBl@H_j?Q%eR^Fu*m4TDb6~4(V*L0i+6xqt+r`-lLH`
z;S`V?ymvr%Oe*S-xQ5lKy8m)tT^sob7;yl<qpJAy9$^}dn*1$Omeqj1K3<S~0_nbY
zn{IYVBrx_hTXk%yRG#%%w_onK@%@akc@y8ll*{J!x8bi6@C~@|-Gi=NhGjAH*P~EW
zM6SDAe&BH1siSQjF-jH4lM4OBm^s30YhMyHzW1<RYlmJ=Xo~qQc|4`^w@>}opjuuO
zpb5Pg48`}=9oih+;Bq#%SU|`V6h{Pqnmgf3vPytHUvIS{<Z7k+ov-w0lA%(Gsa8VR
zrt}ALy$@gn=P*4|nsn*Q_siY&^i3Q9B<bpY=Q(?gK)BHaK&xr?+A&;}_dB4-Wfh>}
z4t{fm#Dt-)gmT$VM=~jRr>t_huVjzsv!64ZUk7pw`ub`dFko0nx29ju$VQAB?v43z
zEyg?odyD0JbUKTB8X21n9_(b&I29~cYpu+_A3p6xVH)aXN+~)$*35iw&W&?5T%>H(
zTV#}93q9p^61u1SFYmY{zeyu}K<H|wt`T4*Mk`o;Kwpu-VTBrOo-qeEjKS{suzr(R
zPH+%vJA8b2nx)`X&{FhX?UnPIQr6Ykzb&R1#isQrCM7g=()9tCoAgHcqro|MH>2c!
zM*^69oFTbi9SPi<r-k=rj;$9Rf8F@Rr`0vYn-bm1e~sdQx|`~EDQ?mbKy1l&hu!0N
zjbiwtwDIad!*vZ%<3^DvHk{WV;^RvL7E_l$)F#GG%7p|HA(Dib0h9RlL-zd<eA>)s
zVN0kxOrw5$-I)(pOVU^kH8nVzN4F>Z1!YSFEud4cH=T+2ElE^WTHTTF6Ys?y)k*=T
zzTg--1yaN+jW!B93M%{L+I6`YVlnZDude}ZqFFrE)ZK-S=GDZhL!lB*{YxDB<w@0D
zn&=+9O=1X!!LuMZIPmVfT@M_Uj@riojOTYvD(-<VK$o6n#a&RXXM`iyW^Un@*{lV?
zYPBc2V&g&DduR}sRx^o>9wJ#ixRa0cWkg6#J6_zeCO+L083LJ<z=*$i{8^H3yUJZv
znzK;eL&4vq;5CUcS!aAlW`y)!^fm{)%;*ToxW%S!n}0$o4=%@6w|xHUmzzC%tRWEb
z1Ox*6uK}aKL=^EkDFHujc>8p{;q9O5-o1c4+={%KWH(l&;1%0S>TANi)Xd1qpCMkU
z?nd9ZT%U`cWouYT63@(KNT%pyF_;YV?nh7+ghwz4L@*#{KV0<f{hM6d;dR*Uo^`WT
z=2|+YwLeBZ*BPsNMQ8o?R|xaOGzQU*l$M&47N%FtWSu7c?l_&#=ce>E#mK9Ft+)1i
z8_a}2o67iLrqXGvo^m-`78X$oZvE+5c`YxQP&Qq;c*3f#2)lD=auX=+LmPX4E07}?
z4vA1469%YE{&po9r1YnAh|OmUfNeXgdA)sj8SOR;`!V!U6A~n2&aGUxu~zeJ#_^6<
z6^_E9Z*QRDS32!F8;rbm+P{kbR3`C|HaIn0Kkk-iG@wm#?QM2`$tk(+%sBuyKlYTI
zZ_dgMY*celrKOhg4@GB%1Yhy1=FdX1z;pyN+t%P=Fzzb^17TW3VR2zr_IT@1?t%Uv
z0F|U10i7L+YM-~mjF^V+WhFCXm=HIuY!L|dYPFDz4F)J4R?=>#KXH9O#Y(Xkx^)me
zT^3G-l3noNTd|L4bKro-#%dMcvOC?C-y!b_FR|~M_HBNm35^w_;P$1(xrNcLrD9g@
zGLgxXLQQxd>d<^R=j?iHtq`3+SojbYXLg2s;`3>JB4w~GQtrot#J0+}w1fZ_S!u3w
z7NL84H|@<@#YMpyJ2*KdCoW!QxbosgZfV4r9a;D#J;JlxYs%=#xm~>@1IVq^4}21s
z5nb68yg3yR00+O+F0F)k0hbgHX1(Ex=t$PF&yq)(O>+pi3oT3H$kT~oRjbm{NoKv!
z-O6D)%CY7Ba39YvP?{GV?9tuKK;5<++NhY2A*y&_a~-^?Vx`aJt?`UrpLima&s<y_
zcuppuX2Jtkwc!Sju!g0y;X)nQ0<ySzP!ZA@^a!NuSosQk^8j?;kDij-VorP|BlX6t
zDKQ_>(|Q1xc-I4w@Mjd5WCFY^1c3@q?7|Q}i)mTvP2;B5FI)g9lf+UaxG@@JZ@h0Z
zurVuAfjyIFmCOLjpk9UwlfhbR=iHQ*23mN)T0S!{aIH(!3N0#6aNtKD!D;rRCoF8}
zv69P(8hJ8lcSe3sl)at^1X$_>a$T|(zr)V^ezUZG`vaY{P$?b72mbngZnJe9fXF2D
zH>Way7KAcNg!P7?o6#|-nlwbgq95a}t@yCH6dZ$W*}Tpg`vIUmr18+J^oU}sO}2JA
zO#~6PHhVhlz3k0}AJn_v(vvzlj#gP7d!}%td+<(Y1m6&ic8kmy^s8hn;F=zW%fjwX
z(AFg}B2Rp`*Ig`fKba(x?EqB0*++@d!$MKai;>{JU7faID0$;LlkpblVP1Cow+r0u
zBQ<N-I{TedDkE5ihgq=QtNh37J2(Yds)twB{i7o)4@u)AV<IxTAGdROE)O7cb4n}^
zOC!!#j-kI8bhuz=FhIiapNk(Vu(`M}Ht)D012tAtHM8tQgHp%e2Xjn_f!Zg2{X&$%
zY94sGE_75V)(-rJZ8&jFJ~5@EtQ<B`#iEUV<Z$>dsEy!vM2Do%Us33cW>!sa3@b2%
zA8eRQ^S77(R}heA11tw;>Ca$|99wF~>DJcKDe`EfTaP6YN-lSdqRFC)s12`dSr`&K
zYw~@<#f7dig%p4}->d<mX5;J+>g_;!%6mK037>46Qw1d=n$~}K4Q|UxF?NJjocTE0
z!oMCpO^uHq1#D#dxf?+xrvLSsc)aBX{rPf)0gwui+P$UFF)=cN8Hr7UP@W$hVm%E}
z#)|M;=kg*4v~Fq#X7hj2qNlnS;}1eS`oZSbZp2{Z$B8O{A2*lKYiRs=6;WZzwdv=k
zr!4Aau?pCKSXk&E)z^PqczJeN#*;~`ilULxowD9&`<6<l8=p36GF0PC=jFQ=3Pp@B
z=9uu{S60e-f<rC2YlO`B(o^cd$uqZ~ROH=geRJgQw?nSD0M>3G8{+_G*#4>7m9Xq8
z72MV2cO9vkfB$JanqcPo!RVS@5vU-Qxouxm`Ai(-Tg{dmcj#aH=w%ebz`{Vjh5PXP
zSPpy7xymVgFG0;+@%HO8&Eeq31J4rHUA9huyOSBgEwnT<DW03(9H^R7vt*A4*pMBV
zjSJuDhgQba6#M#eySrH&Vi4)s#As{cvpfovC!Ge7a|nzdY(jxVnx)*{6k-S%y>&GN
zvm9$6p=}tRUhazs<rTsVY=CVsGnqV>7Nfx>t5Qz6=Ofd7fpqTGINzFLjsbPET@P5_
zYLiU?BSRAU`vH0h>dynVmX6ELl%Fm?%D=obOjNIXhsh1z^+M~Ycq){o0GJ(<x!jW#
zBBC1HSf!>Qn@?ix55+}2{*p_fNx}(c0|cR`XgOXUt&UQrgJeCt%uDuxX|e6b*rn}Q
zy(mBUl@<^3T|?xk&9m{nndGk5TD@+l*r-g^U0yOw==Vl5enq7TKlaixbr`)*ph&=)
z1Kwo8Rn@0-%#-vqmd~&2w`s5Vgro|Fyer<{>6eS6>H^jNvMw6wCB5G?0CG`%_53~n
zk1Lo|Wd)&y2S1{Tq2vX~guWDso{(zN@f%}tAr+&eGQWy!s`m9Ov`&c9zug5i<h-{R
zRO%j7g|t|4A3(1tZ0s*_eOqC4gVAD*v5j8>;HbA#aB*RRm*E%1Z4{1YW6*b<PiM5K
zD=L=0DOgFm|CR{c89DA#b)@B#eU}-$w$o8F8n9t49^C6_U!1*G%MIp|Ia)3g#CEp!
z;wFpArWBDn-uyF@*S{N1UB3fHJcNFNNy)|vV*aNKCS>a+>~LpK2Pe1#N#T0o-`@1E
z9|Ew1@+h7n7(m*L7e9oD7yAdCaN(kWs<=icf33Ds2uF&V%&U|w77T{Xoznd=gy$(C
z&^I%Kxb2YVZ)*QdtVHoK{98xVP_gPc&}Wdcb7^6~d_Awask#3rh<0@IB}`8VQ>Ema
zqnn#Z>*X%QPz>!hQ5Ve|_OeO7xa-ajlJ9sNq#o_%l4sQsRu*gdsG6;I0irUeQj+gC
z{V>dwj5-`@kIO=LDKax%D#)OVFrdLVgro&+Y3`%)+xzv*q*RD1BBCiZ<${IsO#o_v
zOa^PhBQAa}fPFM&xV8B$<@>J-sxSfGox$v`J@)HK)GOp>61l4)SYN(PsL}p$KaHTz
zeH5|+q<^|8pg<OegjvZ#$~pJ{;W%o5rToCG>@wn7M2iRdIhX<Bh;W!4ddB$}h8pqZ
zm-7@yM4Dt_u$ZR=;{YE0?znTM0HpWiy@1vN$GD998<Tr4iz7CPrkcHG&UREp*!LJA
zBY0`oBZ+(}BZt4#C<~DsR$`3!et2BuTM041;UDWzeqF=cd;9DbHhczCF9KU~(N|@&
zl1c7L<aRn4UE_45J~|_es%ch^{|^aZfs56&O84EmN20@55MhSNA*9J3-UeP3(i2_G
z?wgp9L+k-HkIGw^Inbu;_YvfX#o2xYCMs%(`u-V)(z^RCq16_vhzD#m%SV}Xuc3*d
zmpe7sF{>W|V#|ovT^G6=stdIu3RsQaRM3O?N#jJVr)OfO2V^;g7hEkVmqyvygGW{J
z*5NTxg1?K!arhmfQ$({1uGRob`$Qr*P;hi?3`OHgaRUrw-yJ4dJbt4a_1jhL4egm?
zF|h?07*YK={t^2CSfNq-dw`chn|HZ0I15V+?G>|C_y?OgMo1a;ELNdzgeNM^<&nfl
zozcX0Xi*dCm&O@DVOZH@W9@KQtRrO7+IskM4{H%g&K0fDa{q1@86T(7^2F*9cfrl~
z;{*JcqiRPEj|U?1Wo9Mi9_;_B2j#n=V2`;)*QvGspk|`RpMN?vvS=FQFHv`+mX=-T
z|DL{gzn@h&UaoCqansgDqF@5zw62hT*@Dqa@_7AirB;6%xg3{hwH}~g0paTCJj5*5
z1JAAoUv5?79^>2cDnb%@eBQ9KwmkHHv^1h|l98Jm%D$OdMQOFx0C9=QDx>5|dRk=<
z+A5&5RC**1d+Zcz80B+)e6{j9Zz+>GHo{`Fjt3u=sdHF9oy8p%y_I4Oq<8qsX5}XT
z?J%#N!I~i79AfLU4rf^I!>AFnR8}_(h`(BiXjk-I{lCv$Sc3(gE-&f<)M`@OqrKSP
zzP~zULu{vHT&||yDYW=j83*KkvFnwqSGyVD#S`c2R<VEV(wE>exblJKe-C6d*ry}+
zY+9rzDm`?W%=;_F_E}US5=<}6GVaU`SO(q-Nauwhj38{D_`SIRX!nF#71uUd9G+PB
zbtPHcPKftyi$O^pV+AWNl@1lqZ=}UGQr&%89lA`y9SQpsyskM_Ru-*DYZ^uq+K7nT
zVb||+v04%%&jnTB7%BE+Q;h>X_HHKz5?)ek^2+|K!!3Kky6{puTo5e+ah>#r%rzQZ
zK`*XUBKw-6{VAFFeO$Dwt>^~L7b@V;hAZdi+K6!ai7sSi{e}1E78p<l#n%&Jx)YT@
z_rtI7kLH-{r^X^NIU8z!g^|bTmDP&^HT}_a-K}gsWi<oJivnxCJrfg6q3nT(t2gn0
zqdR$f{Ph(h3GZ=!t2^rSnWI--NuodgCe4%)2FcDcbn~z*Qrw=Cp-M%w#FeWkV`*Td
zmDL`sq?T^F#D&lF+|#<KZ=%<$%O`J341`6qAby{gs;6BsF#z@Vd09XMBEsXmdbelh
z^G819H*jYW{XF=?sce!c;3WdqX2)pYu@+)+ytB}a8-y0yuc|5`^Vj&@ueHch=p$=d
zVHPonAhE2Og*Bo^v#qBUKX>*F))W6Q>eBd}c*{r&DsSmq=dH#wgmdm|rQm6u9H?a*
zZx}w^07zKKf%ZtTC{b&Q>F4#-|APq-RSeJvc!KK%Lsk{Xff~27CtW{3j;<dW{xltv
z4TgSnId*W$rULQgcnHu^-n7v_h!O(D$OK>|C6m}1F1Tt$1qjHvW{Zp-41fK>{?gml
zb0#=Zyn#zSaK!~JpE6@6kn$7-5{pQi6HyYM&EiIbsETasVT#WU(`;&(Chl54AmOMV
zx#*_jNxRPJ^;$%xmR77{@do4D7O=C}<*cG>Ybv2mh<4)R@P_t7<mo7=3ZKTcULK61
zNK-X(`v6`teG0;$@duKa1sEefwC%UNouo+>x|t=q`SuNN0<ON_8(?nh4$kckbV)?s
z3(IgUIUS#A`UeUZMY2r)-se&f12ciEce-}ozm4Y!ZXlrSd(C6$v)1TMQ|y&3UA0`E
zwZ<o_SjTC1wh(8qUxY19cK%wEddq~Kls;Hu0*!O~k@H5aNKp_#+dZXaMbG{l`M6ZC
zS2?8c7_x`&m-%8BbyhYk?(BW9k99LMXx=1g@ox!ulfr**w*OId2RI^fct4|f-ec5a
z?%hpq{kS_E^kh`t0f_y|>7~d>e(TL&yuXZxao@sppg{P}FC??iR~jLrO-zKwl5=`5
zeCRZH?O~naqX|1D>8>E;-A}YZ{3A{(3xdSTcp(5L_zkCH{nKLluZ2!kTx9S=e~rQ9
zk<}fqv0YlUPts6V5%v$TCL*%EAVv6_jg5_s9xARDL|B<N>Xl#u#UZ6qy>*D6DtgO3
z^H=$o@Hy<E)#!##*(()Zq6#|&;H}21UtjClhP7O}lJ$H@Y(CcPeER^_KfofO^5g#8
zcEd&F<P;)B$2T{f)Ja{mNZ!-7FcmHMcixU9Ij<+Qm9i{`!g`bL_wQZ~n@BR4X8#rd
z$He@jfcd_>Ls2ldW4JvDIMmHx<5E&IdVW<eaI?{YX#C+C2r8>YuX~HNn`vF9_$w5f
zqTQ~`#s2*1UA(@<4qC0{s&<<M8Osqqa(s7f|0JB5!aGx7K|VXJaQoVGlxw4?rD$ol
zRuNjF_dA)n4aY-N$#hbBIp*8WWlaPF_0-W*Z%am2|DQjoyj)w99#yqk!w?oHqitB&
z0YYMaLZ+%*Sy|d7a_=a=q*7L%sX4qp<FaV)l3~$4d7m2vzi|1he-(w(6R{MPmrO};
zkV922OYhc{x1~EEymz|b1%((?Z)+^8VH9x_6EmYymWOkAd&`v*F+ICO6lj$SUO#;Q
zSy>5zlxT>6>H{1a^Ff$%77Td}BT|W`!#d7Eoc0@vtzqV!w{xBHC--R=cS%Gu4rjfZ
zt)YE2`nvFWJ>`#|*u)fhJ<l;ZL2W_e!oxwtr>7zgtWh}^yXPTzhInDb1;^iB=XxG&
zAn)N5BWg=YcdqOCA2KOkw);YkH$524zwj<~DJUi&9>UR_zP#*H4_%6!JJKo6&V+eo
zH6Cj(r!D>-{r;j3*usIlynu;IOD|cwUTp?q3HjS@tXiCoC!B2Qy=CVd9?#d+(FmoV
z@6q(bbX~jik;PDezO+!$WH$OH?qOE~EH>9jtReNI$Wj^q$wWW^JwLxl`}U7>os=kG
zt{!I^6pL;*vu|Z-`h3loQC(bWwj1ff&0@mJIA8806%7nZ>Du!?H<!`22>oXsa6-!w
z+FJWaTzJp=HU{ASaz;^NCL?5h;o99p3I>t30R?|6l+}TU3*K_Q5J}jCcgg@)VHtQj
zSGm`ppo!#}JKW!=s{YHIVs`dMGUwkZW=q7^0Hu^9K%fMB5*~-pn;8$h<nLQqR&o3E
zi4O-0997-yleu}kVboSKHuy(}BCD0<`08}`JHTTtngQ?FZOvS!mkV!`jTIDw>lpYZ
zGyGBRt^^hs`~f?5b0bu!dS5PLn>NE$^lP*5=I#m`kO-*ej99$dkX)vyLVz*^RnmXt
zn|~dYxG}m70nBh55|SoIfrRwH!_0wOpKu6?ex4*<mcwDP2Z6GtM6otFG2I-nUty_~
zqz)4k$3YBDiVnP1?-QL!YK!Ol>Tfx$v^@|zpUmiCc-${E0g$PA3=nsZS4<v$#acaP
zOGp85QuwVWkoVu8_rb6Lby5%sA0u?G-$RLU5n-zppka9pzhfe$&2$0g6=xD|QZotx
zYEsSE8do~INO+B76y5{3nR#mIba=n#e|CLiLfK$Y#-cns3p%8j{w(K*`Cm2OzbGgG
zMDkl2lSvjxfkL7D^Q-61YBNf46$?}Z$40Fly9|29-sSg<0!Ooyt}F-@{RhWbvr(X&
zRsJo_IT6dkkLF*yw(D{K%!UGsMDp_bI+Z;Y&D^^GMc2ynL;~oo1%!XAATq5hsEeT!
zQc|Mo**uqf+Lk0$#sKUMDrceE2tQGw=+|?78p@N1m8TDjo@+OsdVGcvomlGu&n2k&
zQ1|*$VfsX8ZR)yn-Xj{Yoft?@<w6bbw!)!uMm5vQVQw|1hU!k9a+}<KSuTYDEEN8?
zOJCV8=u+(#)aw+VvpM}j<q>@pFy60By97o7)nsi>kF@2~`zRC{7N8GLPC4ikxZtDv
zQ>wyH{($fOeZP|8etg6QAUo_%^p<3-H1Uv=!xXj2ZC)<^0BE0YXMCJUL|i@`KX{@a
zR)lKx&mO1k&lk2{7ZZR7zjz;8P-Ob@ZcTxsZ|c%wqX?@=qp_M&qTui0IHIEE;vsXg
zUlCPn{e*;V+l;Fu%EwPbTl$EfdiC{%4XpEAtAAT*VW`q*ynq0pfGF14B#m3H^79WX
zw2A-bUQ<CE@C`y%d@4U{bnsIKlhu+ywR)AtOv(k9sR+KS%Ng;hq0!0VdRrntwIDi1
zw?Z(QrN$gUWB#GzCbVZuEX7P=C<OG4MEjoyVllqY3ns;IV=P)#$J13cMrC;K*MH@V
zR;+;ab?+!V);ra;mZq&_>Xx5)tr<9+-e^Lh(w&PfHi;jb00K)UP&XI^Z`T(FKnV?N
zhQ1MN`HBJXw!ImBtE{scwtH1!8@=Q0l&QPT``ecU$klyBAlN}pAw)Z6J2jo2#4Id8
z^j!i&Kvwbb3e8c#;<Fz;jLfi)&b#+~flNkVuXuaW&E*v)0C<ji7E+-5vW1;@wsM?`
z>f%`cnKzLLr7W0;F0S=;4iZyPJDd;VcB&SQ$@{wMtdfo?qvR-tb=q&e>;zl^$9$Iv
z5mS)AA2?ZQ;pbnYI1{TQr55d7iYNm-4EFJ3o)YlKN9evZL^;EGHz{dWg)!P4<@7f-
zw6TAyO8*L^mY@MaK_q~!P1If<kAEbd@1{T6+!+-q8%Yomwj-DImOoA7Qd1$QAQEUX
z3q)HCg#58Qs=6ru3h#Z@V*a20i1_1pp?2MgN4Wn+5yK$9KBUH%97F-j^C?||guD-}
z?PVWXc{ne><M7>QnX4(qKC^6O>M?7@)Wl2s_sUfLFEV6q@klVS=sMje5IzOq^ru7t
zGch;P0_4M@-`-+`R8?=DkRbB4FE37Fhv3#Ep%+ivYlcFMmhJS)BWWa$4i5+@Inj#R
z@KP~M6mrL`SuBrH3g?fGj&>XuFaev#es(pTdF`>Uj*153u5H>XbMo!1s+fqfFLNC)
zdo?AbB1=#@Jm1w`A)q=T%3wD`WcPBt3RP=1+fR>JsJ{f${Y-02r0#IRB7x6uH;p)&
zDyA;oraOeGT%I`YV8NA)hk~{SQbTu>fd_C}9Ou0Nr3N9dm=^095z19ANVQf9AdxEe
zR-MCY$M8gM`1um6Je;yk=yxTWeF<s5qn7j0>QvS-8IF*|G5Ytse{8`M6k?bm0_RH&
z1Dnqmbe2FJJb_!Q4J|5Xj9_?Ws~dfhmFyY*x0Fi=64PJ(*<ey@5d~!ahJw5O@pNQ3
zk@kf=`!ylPTFB?>+AN%lzI}2cs3CH?^w5{8*Atl4Hf!%dl_}<9QYR^^JzYmV4`A%&
zNw2ga|F<Cg&u~@27f|%u_`Su-Zc&e-_FrN3Uz+0pXu|7B_FnOLVA1H)$k&HJ21jFj
z?}x=2=yWZ=1Ug*sV|0t#A|Sur34qV&-4Vd?0aMXhx8>2q02INj#v-}=uiDCmrwevT
zX!C|&lTGXP2fdnX*O3N`)tthV>d4|oHC=}*R#;E>C0knT6eZJXmf~jfo<OuCkBYIe
z?l8a|SJ+oDXW_C}h@bfVRzf<nOMdTxkEI9-P@=_UYFTH^)ws}`XuIsLl=s%VyqQVH
z3)zTGWW5ruYd1p^N(L&Dz558kdJ5}w6JP?%iwFwx#lQr6dm)15IlcL2v~21IjEwb!
z?I*dPZ?x)ESglo*<`ed%`#Bu03(Dw?Eg*eqvR|3X_k5Hta=72S74z(lSqR{S_Am-e
z*9cu-#F$8OD}^WMk}s|FmV2~k{rg2=2+#`jw+5Xll~XIkw%zC`f9Bog1#Ij2|0sLQ
zu(;M_ZMboFm*DPhp>YY4pa~8Ef&`b~?(V_eB@isQI|L8zZb2GvyuaQvv(MO>Z_fL3
zvA7l&^_1LoS3OlUGO`1twzNcuh!0!YZaMOC6t8w^#v2SfB(?x=We}JYr@m@6DO-{F
zG}lr~xV-*s$oZcR@1KD6Umx<&;fFn1GBcxoX`GJhGgs1}czJob&)rDR44%fYD3j^!
z$B+r0UtAu<LzB<S)}JX2R(55?l3qGDd)CmqkIUVIRg}i_*Kt)P*Wa;1XfWGFEV4_Q
ziw;njZ-~~WJPd3$_64Alv3YbXHi4(oGE|D}snvk^7oe9FyF}Rud7r41mzmX1{AOX!
zPRR)bxw0*MO$z9VbgAA<XI$sylA7ZC!IhL~MI0bfY3LlE_}oL=#q1^Q<c)P`{Py!~
zO^oChI38p*GMM431n%HYYKi*6K?2iVu`m2!k@B(UZwn*;hD|FNVVt339lnc1l<kYZ
zG?POYXhgE>`O5ir3W!LYE;l$X82DWL{ssvXarvRPvdg{uEl3H7Z~nnv+J6x~7MUuS
z(J1{-egD6-$x6ujM*}E4Erk#<SZ)O<h*IfZHeZ@5Waku@mzD~RpFjNCSr8XAp6mpT
zb8s;WH!hRFOqGZpqfUl+CMIS8)IAqcdkduWo4=sHTE3pIuG8(L8}PfKW1M^mGXmRu
zAnNH`<Erb~d;u4LY<qn=a-bOR7b}c+u)L4XZ+G`mg*{KPr|`jZiSJZ<H$SdFseTE$
zRJ@*xN~~+ofGZ9|&kBEyq%86KMn+~pzrQ#<i3$;)php+?kkX0^A1F@Yb@)EW$rRz!
zu<^UGj(051kp20In|}_A&^};WSm-bi=oqCM%W0>vtov}e@{PGUSz=hxsQatZox|z+
z#V!ajDq7T3mEP+wCyS^Y9PbdxCVu|J!GZm--EzPX^pLbD%#R%k2*X(ZP#QR_ebM)p
zB$yWVD-5Zd@js^Rf0n8Kgob|yQGa=(NdyZW_;PVEqTTGkuRcoZwvI{$*_=rq{y7mZ
zM?-I|4!}aS@n2s91vY8<n}-JY3{eAl=PJQB!-r@YzH{_DXJ?;lX77TTf_Pf|@f&PE
zBU4S9{#K;eYkF>mm4A1_Z@Im>X{ovo(wod1)08wwRtt`b${&(nZevz>6Wtg|4UiSe
zdxHdQUH!~O0MzObeJ+-7`_RE<wP+e1i!zks*SO_<rxtWu%+6&ttjgJ3D=R(yV71^X
zAt~88a=UNHnB3x*6t$1~ug<+fG$1h=kmKznc6%ZmUT?u^e7Y>_;PlJat;ie73>L{N
zkg+o{^<N)VZ%vAWcdn13wCnfZju3ZG6q_lmRmiRtm(|I_GwD@Z1q2iQA8#%GMa0bw
zD2HS)baeP+Fhxa0S}bYp?c~F8tE)Es{j!@=(;Kz!OU~iVPRk!{n_S4uRZEQGjXnY=
zPaaHHcvK>99!!+;4ed14vsX(*weIx~t!!*{mX73N04G+-M$g@nOtqsXHg-rz()RIA
zUh4i$DJQGX^nYZ{OIvR){_xriv6&(3z|c%v`|knuN#9x+%#X(%Yj$1Kbsh!Vgzf%S
z3nY^1B{t#!Ra#z=@Kj_lQ@vo2c&tK_p@gQUemNM2GB<dL!b^b%Hg5t6D+k|nT=v5U
zfs?i6RL}N``K>YfM;`VFsLr8~xtaXG=$!2zIu{YaOoQ7^O2=6Geko+58{_2J4T*H#
zzF4QQT7~P)bXI%v0-u7C63?Q#zh9YTx;{4PFU@zl&l%ZC5wetG<<To$VB+gzpzer9
z?|1{INaL|7c7DJ_Nm&^-^e+5fh%-@~<-;h6hzh5QI9+l7sBG`I7jF9O^khW0rdGuq
z-29si6Uf$D29NL#$RZ<swS;dWyR9o;^cj5U$tcp;@d}#4)4Nixf(&t9ZEpY1ban9}
z@VeKVH?S~L@~V=mIPo+leSyA_{*i&bMhKNm0{yV4umy``;RR)HG~(A^2M1rTdtq$=
z;do#3zHVC@KVxVcX%Rb~I0e6)HBuh{k<@1<t!+!I>e}mMYIX6X?FoT}X%~1(3K^ti
z1Vd9zHNe|y5NSCOhYD849~m2lMgl$@0Dah(_7{AB>?X-_*(?G!uZU43vM|YoP)v2c
zG<aN5gtmbw&@eGG5H=R8J3C=~U+(SQA5ZyJ4SnhBsKhBa5xa*0A21E_TW)cU%+w|s
zC-nL}aACD))2B@${`mSo{i*-_z(AYF0n4-}1CW(9W5}G*hGQieEVPhRQ4wcincuL^
ztDQHia70C|pAD5OysC*Oelw~3bv7TzS6P!%A)T4G?bdc%bZxX_EUxoHOvv%KIKQ!+
zkMyhIj%CO|`!P}K{&C0H_O|GGDhYT<7Hld<^G;PykDa92T1FI)saf%7bb=&z@2#KT
zHbtX=D>fl1n&aAoWNywvKz4S}GCt4*iG&WGiB*Frq^Kk}$bO-#R6t7)|HsYCiirvz
z(!c(f&{7l`#P4nk?fkSUQ-T9_(?X8(C5q4oT`AQU({vC$DASG<)z~-y%6cNXLvoXn
zCS@@eYfZ(UE{3{PKa>bpP;(+`i*h2ulCx<bJ8TwVaCJz3!<B`%BoO#5^Vc)`&w~7i
zH(V;PPB;KkNY}-ng{ro;RSsH8mDR^CGBbLuy1l)D$h{Op_x)b#=F|BjtCciQu=DxF
z@<D#l5C3n{aCh>ho#;-5-VL#GY?fA5!G7QuR6)!(X&x5RM=TOP#9Q)3Hs;Aum9X<E
zAqAaD3TdIqheW9qNoh~<T<rWb-rHfNkikLLd90y#pwP2gxM0urZm~aTi^^v!oY}br
zCl_eLpaUfPitZGBB(JAyb-1gw6_%9rm|A!bAH4VkCOV(`dT*7$Diu`dk|8q1Nj_l^
z?>W#PoBC^_>;?-p99|!9f>VW<If%%RN}O+X2pJ}{sBy82`na(3A4KpM{Yw*sF+|TB
zW%*W7Vf_5i)f~og%HJT#-5t1)vDt@U&^@O^&ihsa>x#L$>^JPA${X6_qk0is*hA^4
zW!(R<l7Ic^-|gqmH)Co3^ihB;a)ZsmEw^5OG1@ug1>Qn?dTGmsP(p2gFQrkTYI6yD
zYilHD^G>8W{$z)HC*CV}&^$-mN<GAlSl|=vrf2`>-J2w1$QHZ535?h)(N+UnN+z1&
z;Z|hk&ldOQAMHWNGZgL$H1OR&F)}}NL+A4}yAmbEN=r+3EVmQWf9&D4&a114#*;k{
zJ@4H_G!%6JLuPLso@VV9n>`vn?dmglhNFY1nZH%Ar0#Ol?)PckDiLGKtGu8Un}vAe
zfTM9ZSy+?+v{L60c;c%N*h)h%kG?tNf?3QCd(~wn$veeMjzKA9GV$wCCim^jO?K`w
z-oJ@RS9)`p#QF{#&mY|;=@Pe`;rR7ITMs7d{yCD^pnN^P&JRl$?t4c=L@=O=UjF$n
zPUue|{+9=H8K^xmF*92v0K~$co^W|}_mYdBKqGPRlOXLt!?UVNKFHSNRPCvG6Ot*1
zC6L$OZ~p=drlWNf50!42m!Ds-X9D6Isz!U3zy>#oJ^;{z+)FZvj~0;SIY@SzU*{NU
zCXT{m5v94wVI7j<V9n2~J0nEHJ3Oqy7+0Dz_(G+aoKgFFqkCW}yNmDlRRFEtTrj}L
z(*O&ao5ZJiXQ5y#QnS<%T}P8u3fMdS{@hR(*vlqS{jwb#`l2F!D@HVzS0;q?p~_34
z?B$@#=;PBN1n<&4;F(CYJ_Aqlt5%BCn~z%OW(nB4N8MXpd$OJfF&%y#L=vz5T`*O2
zHMY6z(XEX*CpLP*5@c@QEMP7gPX%pil?x>z{=vcjciFO~`?n(JZC4=YEwVL*$UzQ|
zvivOZVDcF6Puu1*_r#(b$}S^u?|u)_PmM*NHPBZQk*!->TaUH+guTE<>r<&nBgJgB
zKVI!McUCWneNAk#06?QDd8;gaSp=Zw`C;P&)D1<=q+cOz<pRkDWFr?2Wg)XI&yg+<
zgxgszs9qQtv53)jT#jRWvN#g92K-DU+pH0Acl=BBVE@c-M7eu8Sd<$*Bu`4HI*1#r
zOcIBqGAN2P0DRpO;ToOwx1jb~a5WgV4DMfDu}oevyemabz=kWSx%S4-a=kf>g-B}w
zx&-WQY|q)${|6yWO~CKc`2SMJhw(;iX^}l`=jkhj*h4@yXKjM{<>k}oJ!9U%yI(bG
zOip1Xwu029>>oxKM29@)wJHS7NJ#HMiye}-sQ3=6JeP(F9v>#??_8g~*ds~r-lcLH
zg^D-&A{=m#??=&1zIKC*#c1g#GBOXL-vXVsDYZKvbP7A=pgM!2IEp&AKcg9+oe4Yo
zVO#@`=i?(@DHt$+oYZ-D#!d)?jzKbTs3Lw3C=?{7C2@ufYGcJn{#(SDO71RsB@mxw
z_p*PXa5P`@Ic%!{q3;uXt9r5Pf7g|NP{fa4paDigM~A-se*b`w6}GJ6yMJJ>@;(j_
zWx_}lHGN4Ta!mI!t9mhlKtQmZOi_?;Rw0vj$H^nnt76ELzVJ9S)YC(2LffE9Ra#O~
zO@Pt6rnVM=5=3?Ga25LNl7@+C7=IrPE9U+28YzY1HmdDTUehDaf(qib3Fo`RJqVcn
zm@X7Tlo;C+HpWFE3kwa}0qXroeA_CmUvLGU8wj~*0vm&Ow)%S3Bd$V0yN9sD6-9KE
z9Q6>ck%bVmOCU?OpQ#3%Kyp#Rw*KA6Jzj^=7_ijFdS9~#J%%>of{}p+3^BVgxN~E7
zF7c_<s1r5lVFO(nF&2@?!c9RYxb=ZlL2rzYZ@$lBgDn)sN3QoqdN3%gEl!t=t*pE%
zu*=OCNnYjYn|Af7D8XxecIcG3hH+V!f0wZ-u8{9KqVMuA^ht4+wgtg`IyqwNXF@XQ
zPnS0nTKflLv>;mOL1D!(;r{nH;gN>}>=os;I8$f{^naqbfB)z|y_vxw7JhOqtFGo>
zgGY>QKi#-lMSlBs|2b?crO~4g<9RDVp22DS=jgZQHvk<S1a_A~PhMKC8c<9k0n};s
z*5b9n)4DnCW#i@g=d4xZ5cO>ByxwZ+5=;7;t~9v3j0ojzdRAs~@!<2eyzG2EqbR@z
z2BK-<d0n5#iuXbsxbK6Dq9^}w)IzjgVsVp3kUI|j_M%n8)$hgD_&j&_p%QsU#0NLx
zjDpE1AL<AuON(o3)+?e278jQ#HB5u3&Zp)l$LFH(B!qZjg8A_x@bS$h4J8qoP*i@z
z%q)wTg1Q=x^L+nZ2nNWD-13i;qMAq=cJGOfkAH2<+IFtkAc3mtgC0UT5LIMxV9@2>
z!2NqT{|7yn_-7MZ4(mQ!8=|JBMl><$O+(&vroxeU%nHh{U;ol)U}bpF=JM8`QjjB+
zI1>!wm3j;B?`)(9v^~UCo~P`%v^Xen!17^`gz0J4qfkGti$I}><=TSF<?`(9ubr8d
z0cck<7r<|5Em&Mv=4Pf20>7LVR=tu-o04aGZ>Tm_z<_T}_N&NcaJ@@`NGa%FgYVQ4
z%4~hN{jtDuVCth;^Pb2Jlfx;B<)~ld>T)zSY`0H5b{<eAX`kUAarxmaywutgb@x)H
zY5aQ~z!E_fcy=FO5WiKM8PaagG!pQT6_uUAZ=3Tscj-?Je<HopGkEjUt<gJcztyTt
zL5z*FMD!2m+iimEF48RZ!-A=4{pmOE8`ja<w1yd}zor74r~xG<40nfxlszjeuP(1v
zCRNiW`nX`*z|V++8xBpM;wft3w)PG>{Ud*>Lk$QX%gv~!$vOT<kMesLge+k{)vDEB
zXiz6e&AtO095$%f$YXrn$7MGgq^kY_keZp<Gt-Bq%15PgfQ!Xz_x{r4=fBDadXf^1
zRPlP22-bp&f!U{K#N5r(Y_9EB{uti3_3WF=(aE!*&=`K680mjL^KgGT*xUKWnsewy
zx}L#U>#MbNc0?4Ic6srMZ3R8n2`wLEN_<-eYJVDX7P`L)HxCX5Yz=~cq$=M+*{CXS
zjSdEgqI*I`-%W#ZeH|4lkIUd-ZEtB8yyV9j@;g*FY88z=;}026rK98#`^x}Qo>3Rw
z4mpVhz7%BS`=xRibdS#^c`==00~`D<o--BSzbdd9jkVvJF0TeSVKcJc+UKw5z--fu
zxO{lWW3$?>t1d_KPhQ}!4~P2j97WoF@*9gVo*VX{VE{48$D6pu_^;n>R%VuysHr8a
zN7TfjzY7nm*Z3Wtk<kT2>m5|(2MUv|{=Qv*T^Z0FJW^=9oo(8({Lt#@ZoZGEsxc${
za`<p@0P+voNnV(m7kBLi8`;fDls`w>cUg$8dajJG!e)?We!MNbdOd!h7Wfbxte&=5
z`jxD;vleYkj}rC0%b<oxhRJyL=P~G=D!t=ThkG6g)B0;Hq5Yqv3sHX7y$hAxzk<`Y
z0+I7VNtSF>fS;m`KcmxPJJd7=E|-|oMt{<gUetd!wW96hX2$tPRN7t7DUKl7^Fkg0
z9VXSAYVCU%uX+0^%m4L`9lW5IMU9!-Aj42haP_<AX=<=yCe7c@@8bk~Mh2<z$R*>)
zUsb$RVs`QGl-OBDLZIDWh#m+eA`MObayr7PAD1dT95%9@dxl=WDP@OpD7;VgLr*XB
zMKjywIR6Gn{E>;10i^4kkF99<sV)J`P4i?fHU>zKcJ;5kpEKD%?UQbZ#Rdafa{_Tz
z5Rl}0&#f67J^Nc*Nf*z_NZvP*Qn~Pn!1(#u*VO&8!C#{7{5E}X5)LOP7bdM5{?j=k
zE?4kVk(o<>RmCYY4U4`zhJjljzd18}cx=qqthmA?S`?Vsck19kVu)@ynktF`>?$c$
zOSd5yrmR>2C2iaL+}h-mzAz&I<)#t|tCT^a&r`Vp<AbW|XE-9KS09%!#hFYN*y;Ul
zGdz61a9E^msOxoh)}qKVQhPTJ97uo>(|F2=?ZT@7SVIgojjeU-3=H~Z-<tyQ(qn7x
zi(Wsa?xK!+F2D5>Y3{9>UO=^8bTDSbli@@0kme+f<jEIt?BY_EHjH$rIu7Xy0!E|V
z!o6mldpnHvc}Z1&BkvfSaC%~B9di)=z8AoWg>2F*$N5^X#vJkD?HI9GQwgT}H>=Ib
z6Ysm~yhWPZ!ciLArS!p8Vd=myvg?a4LC8dm#v6-WktpkR71mqcvh?2Bi759Cr_QvM
zqlVFI=0#mt=odF%(cA963`Lc253j&6gdj>pf8%wpSr9FeVvqr<>m!O=>`JN2CI?H(
zkI2+5h@5$Gt#lpCfjvE>Y3b^oUoz6sywDUyetw{T>;^xL!-$>mu2D)Y9%N-!Va#%=
z<cGLm)bLhg3z+RY9&jGbO7aYfUR`z^_i$(v;B*%sys2@$`At=1Nd}E%mNZ-rZ;Tuq
z9rr7q;hse*vGbt$;*+}_tMaikS<?a;En;tq(j!$@g{iNgm54nH<DY7a2~SG;duzxj
zMcUnx{Q4A#4*S&GJvx&ch3lUKVg2?qecDeX&(YiJ!Q+j>YirC=fqT+Or7Pq6i~}Kt
zwN?iIE+Z!Q=6nB!1`MjyUzbwDBT7M)C!gLZi@}7*E-@J4z5SPX_?JkTA`QSe-_SM1
zI$AQ=%+VvG5-qdMk}fgV=>hvK!lJ?`C+jxW@yv~7yRXLQF@>WauUo;6kK10s+T6gF
z)8cSB!veiz`x5C@(7t&?o~yS&?2o~s27e99{*EZ^qGDunT&AAu=SE_!LAJbkLeNqr
z;iAJVp4j>k62_Q=kp}8bMVMs514+ei(@Jq4Z5UC9w>V5ktE$+Wzo+0AWVM{)9v9@K
z6!U$hQkXBAkoEd30k3Cbkv&ZHXUz=!FMY^#`8AvCX+_BiQ2WxU-sUv!6S@*pOSlOV
zxhF=ndp5TXH;wG6p<|Dsn_oDx^P;P;RR=ar(n~ubamD+VTL?C<tJGgq)W`7mbL9iX
z7`XbjV#c_<UDQP^gesB01>ryNs15h#OlM)sv=_(H!FSjDv}mE{VN2wwKJf|+$9d%)
zTD(`!Sf^pUPuou%vbTj6VE&v1fcK>DMWt?l9vTS1N8H?zQ4nr-PxSHSag>l(xJ!R|
zw{hlw!1^wBejfYxCkzdeq(_=S<BKD@#U2@$SM=%IW7ab&aAJ3#D7(ct-ynDI<XJ$S
zy9givn9jI`Nl4Hg6p_LWoN{Jk1D?M{S|qUz_%qO(;l3Fa!n(_&qjxyj<>*HG-_d3j
z^*KB5uz02o0-l^e?;Q??!<@aLb?C2UBp;iX#u-9^)0&W-gQ|u`{vV0KfKXf;=<QS-
ze_R|cM%Y5Tj1f`0vUY@><(CI9gsWebOaAr11<+{peW3JHFg>(Zj=J#WZz;?mqk{(6
zNjAu{IDP8;W#WY%djkDA_k~-tJYr<jkUSNxaA)*O&d|s^@r06Z*?8!vkwk-#<6pj(
zJSKbq<Bvd2lXT-JK69qmsy!0gllg1~!k)bgbg-(+0MdbKidnRhv)9mZPFhwoYNJy@
zB63RZXNxVdt+IATX!tUKSD*VnoHX74@&!`Gb}Z;Ax`iRZcqSORN<u7Y*kjfxZsKG@
zdY%({*xzM$ixH(@gok~8RFR^MLNz%W$&AnwGtSksysl=?KR+rqT+53UeziCwS&;i>
zo_E1@LR0<^uwfa|ZFai`wzxFhlpXDOD(G36eido;rAyH2GiJq~#{IvU9@JO-0UFlf
zV{@B~2k!-Hj%zShMSlbUNp<MNb}B2rQ*45O0)LPNPtG;A%GWFAggfU)T!ml15=!_=
zmP|bMIK&AEG)g@tS&TTh0D?Hi0wsKXYjrAv2>&Me6iKS8Va&wKSDQAmaI^fnl9hh!
z(Pugg5ybxMFN|Q;tpd2ix^EettivqtpAFT2YgE(s0yccrH`MuY0CEgMxyOJZo-C?w
z{e*!)GOEGql&Cj(_}u=KN;6mC;V_96Yez$L_qW5|i{cbhfJWX@SXV*U)*rAOJaLfp
zIeve{AJX2U^f@!r+P7<+z%=4bV!lH>liuhali;AjF*Hv@+gH2uvyKJX*o^WLJAT*k
zlZ@9Xv4dNO%$>9)I4|o{3o{+Gc5fGF@LheKaJswhWgYTrzGiz75fdE3bpSPU;hO3f
zy6tXXL$o8z$RNhoSS`o^TJNXyB&@lZw^Ng&uk28+34~;YUiUz_)n-Wv5&C}N$w9EA
z0Ke1oAx29G4p|)saO9`PCgELl>fHtF+*~iY(yD8-pQfRkmn`h2k>sNoVa*k(gt-Z5
z((}+Y<aATgzyER{T^=ofJ(mKI-|P?foIfvh#R$U0{C9@8TNyboUrY>|8^SNp@%3!3
z$4tHcj&kkd7bCX+&afsFj?wlb1jSm&Nv^F>z|=lB7%<3C(dQm9!U&*jEm`7C@sE0g
zTm#{HzL3>&osIpQu>)|puwX5DpTRnA+81%0`0pzq@XwZ|l->^?S%N)zKA+58?+$xs
zhX6qKS7GC&=z`nXuF$2jKya3k9U4|ulz$!R4dqcR8!kYOlc{WqLjoIXF=UM+I<j4k
zNs)atV0+n#dc%+i2-Ke|kqdI?B!t7j*naKQ>r>DJ>M2lfu(cZ-4zY$FZk3p$lmQiQ
z&MTr5ENzSOBXFhY#4$Lh7q`sPQge0Ctz73^(}s=_d6P^z2K^{r3SdEI?cOMl-!+c;
z=pDv}I={S&e#at9uR63aVBKN5<tfe?&||O_K*$N-Y|scwD&FIIJSW+FezqTB_UAPt
zI9Jx!GTvYc)XvPpOsNE480W4z1uV1|9st0TrEk+c&hO*lC9i`_O7#N0*&nVj!1Fqj
zS>jrM0rJi8Iex$2?_gT)7rvj>>bo!C3%|lV_~2=}D{*(UDqz`KX@t+myTQO7_dimm
z`dgU(S4;Mn0APSGE-so}r(QRrY|~^?u~d@K1aSuCs_@=<2?hnN5qL=0KAR1*)&)LE
zvA!Ak4Lfr5!9i>w0}mD%uJIzImEZ#zr+>-JJ1QYAT>Y%~h9p;L^?7wa>wr8~8{Bh$
zr?OwgbRTC1eN;(A)124&yh=JhelLdan~^@|K{piIIG;-0T?ONm&h4vLWL?PG)2Fb9
zKtf9-`hx@aH(7E+CvnK;sL#45dsP_cqpigO)Ac>$X}E(e2hkyc-+Oh^ER#vJbit!c
zIPWpD&vFJsvF$YG*m^xA0BbULao!Y2I>~dPF;^}$oa+9_KY>A*hU*f1A&DtU<;7}V
z;4X9!;{lM4d2u<u`RoI?Q7J7tX&#8QZY@%WVv2*KdOn?i8|fpuv~+>8abSW2FnW0v
zbw@=A`%x2}h>WbvMw2l5{CVtVY2qiU+`~7qQtPzR#}GyiWEz0)nw~Q%j1iJ0avX{g
z7F>s@L@F3nJhTNEXAwy6_z;aE-cJLl>~nt3M4>*5LMF_3hl)~jIN3De4Xu#;Lihv5
zcT2#!$MvGY*i_l%sYtMqj|f|Amd$4W_k+F1lbC$Di)Vb9Jl(hCkdy-4e@@qVS?)2V
zXBBb(lu4&TLNi5ze0@rWBwhX1KRB59kdy#+e2o8~SSj7%dRTa|&Wy9Dc;B)goA?mU
zbkLBoJnoE;Wdw^9e{xXs*5-EO%oIA~h~e|be0mPbn(<HRB<gUIJt6MC9|gT8&F(L_
zPpvO1&0o0Rm+lFPh;*~>*arvuUThv8U{K_oeH=i~x^%vxPLFZi-}Mk`hX{S;wJ&?1
zBQuB2TAN*=<`6@Cdh+R>TSLgm$XF8EQ&ra=927<Lvt7pI=WlpGA8lxGs|oX3>O{gk
zLW6EGSS2YgHt(&KW;A|o%DkqS#DC=gk^W8zzp%zd+zO5i89j0N>drxeNhyTc)(Enl
z>wH`LPKk16r5GplOBH^j+JtC5sI}~@L*KHSBkMFX-`<j+E?84KE>CwNO|)%{@STNl
zZ-g?Vki&@1II`-h(G0(*zY21B07U>lHkm3K&iYNa;bpvm719X8?fIx9*0Ax_VNx`I
zNvbn#^lvpx?w95bxpNm=|4@b!QL|%_)E(r~`d3>vjc|MdtYi(x_2!Ox1``&eB*|rJ
zt6IJ>h>#=MTkI_jM$H?HZ=vEUWM@Z4#HynMrhUcJ0K#XAA~pCtGvccED86fSH>H<J
z&@lFsuU5!Re(6BKb5P|I#pP@1pWmwByblwnOq*qpH}?ya1f%R{#teyulz!5i#1m^-
z3>>1Qv@Wev*m1E;rRs@wVyy!+(MJ)lf6Sg*>Vs`h+=_&3hgBiZHUpg$goE-?nT`vE
zi=fZ=ecC2cH~{<AxZ{lxcnL){E{Z6W)E|9~hws-DLjZVEMN<AoymOP-vSQ$1q%GGF
z{QVQ;t&@Zg?`gm4{F1d0b2iP<kXcZ5rJRo=t81+wy*(8}$5L)Xd%!rsh>3Z-`aGes
z@q`+3FT3jVdzX19e<KgR#$-FQzh2>duT)$@PWMBUQtu;kR;dak2YUuc`ULk3I8c(5
z+`g!<*#WJomLGr;&w!>MpLVCQ`}?^J#SA}A8XgGAkwk?iq~~B{`YoYCw|?0;+HNBX
z#&y7i>I=qKO%jQwzd=s3EUPO>T)Rqf0`F%oc6j(2<~K(TT5GIjf?rLceSalJyzMm<
z@Vae7#R5DLcKa&CukkdXAkYLk3OT^8R*NS0YpPaFt10Qiuog6@y{nD6w;AIla#q(h
zRZt)y2bSr5UGS&!>t2ZMET`&<e{}nr@{oS%J%LZBR08TdGuCB=M~*`dKCbS%^q`@*
zo)muxDxh(4r8SpY_$$`>SKs~jLifi`_%Ss=_Y4g+K&2Nw*Ve{{TBI(uhKEm6%*C!N
zz7&mSY8u7ey|wq?m{1a*_a(K|A7D=`!UvO+<|0_B^UUl0<H^edk3-zjK_%_#+9%S*
zdy8M%6AoHbDJ>;q^8qUrR|qhB-R_ls>>poH*mp8D45uyZZ4qax)@{V}eLhlA=nx7D
zg-o(}2lD<RO1)ahF+9UwDI|-|cIRcR(Y|=mU2MOw@6<iMf{eEl*>!o5FD_R2CA;&2
zY7^ADNg|c~E+rQ`oGIHcwjXte@U#jJjpwvL<uRwH#{)6K=DlyvucJde(TMt;i9Jty
z(W$k3?>RO-!jp{rIrRm%Nz*Q7gSadnq$U8;`YH<#ILKe@{i`Y7!SJOV;E`T|%%uR=
zAF96E{Wiqpj2VToX8jxm5cnW&u8FA%e>C9Ab==0qRH5nj%n}n}M!UnZIiOeHGa)C!
zF(1M!*&Sb|*bK>_X-)$Hs$U3^nM2sUk^~0Rc05yie;lKxZ~4)3$g*!OJ5VT_Da%~+
zHyMjmy|twZ37pT0>*Y!;fOTasp$4F0EYna!TO<K62(J#DUqy?#v~xZ>v}cfJkmZ*R
zibfkTym%2$X$a7p!QS)q06Ygkl_)WLuNCXeQb3$w^$6$Ak5V&%tq-wvz!5RI@b+!f
z0cwQ4w%2`uRErAF&h~t~V-1?r0M5%z;}d44EzXbwZHAL{s;iv1<e(0qc5nuVe;~1v
zlG=$|g%GUF2N(9Q{AGT*6BfN#wW@&|2XEPM$8-rLyKyxvfX=45b8k)U0DNadv;Dr5
zqI^4s-H()FZ;?qbXypyCcuObDz%oib@2)$-VJ~_XZo<;B#zJfmU{J*oN$tBjzfcQt
zZ$$`g0j(S?soYffZRg?6A9{-&96)N0cmvjao4#8&E!ZrP4n2bXUIOhy{le2+Z8^_M
zr_ql&p{rTmoe|qtH?*PMl^!#*XZJPS-+B2&i9NwF2ikkw)0@(6V);Utgc-lr+tD65
zysm;$n=b~Eb{-s{o7%c44YR<AqV=1O=a;v;8JfKLle>Bp_<~w(0?-knZ$AdZYGmC%
z$*RDi8uJyaGr*_uyr{jMOT0u;j^{Z#)1x<Q{WK*BC!#r(qU<9^a5JZ>V?-;%gSXLV
zsh6t0rlGQiCK%T$SH&XOgxqMmR{h}}!hbVMsKNUC!dG5fzpGkFl;~RTOH1NTURXy{
z7~=P2w;y$x)|bg+M~<cd;x~e{tC(Q1C*wc~N4yMuSmK@R9B0@I8l`Jh46xYt=wLDD
zTZkm22W8u2#6>iU!9SF^m5$Y1g3J1h&;7p20wxCK2R+|#^YP2dEcy-q4GIR<v}W;#
zv+e>S@27j*D$_!oAtdW{)#H^E1W>hZr6qQ6bx(q<z4pZbE=K{3k=*11js)CoHDy91
zAht-j$8;kYI;M9@0#dcYyETWhWJLqGA2T+*sWCR^xyF(=_P^cjmq7+?B*Rp{9fMXU
zhrQgczJ>H8ECVaZoX5yaSok9WyVlNbHi4Y!H6}KkeKC_aK+1bvzCGIZVv1#~(u(K_
zz8jp>mHLH%s)iT2Oen011@}>NUev5wqYeqsE$OUC)f^K{?g+h8cPydqBWd7_0Q}gA
zCL|Fz8Rhkqo0=ADy`Nv^nVf)2qs|v9)+<YOxS+T@4ol0=6}-ZaDGw$I@y%SW16y@g
z(*s{?>nTKcT%fa(70Ye;V!CnxMU)-&Ix8pClf<LA=-(0F%VbSWL5g!&xWk(<s|N<J
zFGZXukcMwNy51N7xX0p9Y|KFRzA7*$;O63z3D5l!QBG?@g?DVQn+Lsh)q=h>I56if
zjg5_5sVKkri%IG!1B+RWH1J@CS9XM|JFi4PdfB32Jd5jJl@uULlvAP-WtnZ9Ub+%*
zeS9ep)&<@7`>6i-&Yr%#PF{#s`RtpXfh^IE`Q!%o>99hckJdCd&K)?|Dlm{vW^G$S
zQ3_ozUoJzBeC6~7&O)!;a%lFk=;Hs<_Oyn4c!sFebWxU!gMxnIR`}@$w342<%Pb8q
z!UEl@B<}7tLLPx#(sIv}CE|iJk!vc~6MH*Vuf_M}w1S5Nv|h+6$_s*V2d!1pX}_%a
zpr0GtnzH|~u~)(&JU4#w=UCWvv_3UwC-i1xrO-;r!r^-g4ce>qbZ_pEs}f>zQh4sQ
zLb~I$+kQ<Ur;pGrof;)&dBm4aXjHW9Xj4fBRA}$x5K#_$a#a@e1pzN{9^OwjdxG8x
zyCjfJvHKj>b?ST6YwadTS6_TmGMeQu<urfvRctuo;{(I>%W$c8<NR*FW{nA=%>|0%
z=5_%O@?gV|Yg{PWLE_!M?ZcSY_x>wkzgwCjgP;C~i*F7Ii7=Qdx`X9-57o|ZGfOkP
zZH@fui3<w&y*OrFVDuVKg0u{E%dMT08lrBig7`Hw=tIE}`j&2IGEI=z{Vv+zZuiX^
z3;h5Iy{m)J9E#JZEp=p!hrt*6JRC6wK0^7e?nSe;ynKcFyS=@OC9XH-i$-eJ7>qif
z0<VNI{Rg*dVH&1@@gB-Qv}8Hr*<@0<2hxOOHJphE6S^sQw4n=o*=S()rGdxBGWsnw
z0^S}R<e6}#ix0I1*6P+1@~Ix@%KZr#i}K?7Q`4-Ftjx<zk6Y4B7iIpN534POT99PO
zLnHAs^<tr9T|e)MjU&6tYW!r!cXFHREL&SRvQ$|#p@bvkQP(?|eV4b!XTK(8Y8_*~
zo2s_mQpay@F{Iz6jiqU;FG=!Pigt2!X7*!?v=l(|`7taDiZT$MM~v^4GA^HP-hrEe
zp`D@YugM2K1n!|Lpk~gNv(<0FWUgSKn@0Fc(P;brlpJ|SVMVP1`{l@*aex#)e6(u-
zP40RDxJ{6kkfW}f38&f4QL(BL$D#+vudvP%;JvJ+4J$1JhV#`z;PLLD2fEGk3f_<y
zYXYuS&(4l8p{QQlwzcmuPLi;#wDYDh6G77Li;Y%;t2Womt=?wi>mkM8zqNO>c}qDY
z6rD)j;+6}w*xYMc?t)L<Y&Xyj-Z5UvCLUNAc}A{<RRoKtE<KX0<Oq9Eu>54D4we<|
zLHe#h-XXyg&UW?0T2BvQn4X#fgn?g$DJhh*DN6Ak@KX#$hocgmK|V=aj+5@JKaD_u
zKQC}qg27Y6xEdfaAOHc?-6#^vAd&fxgSxRbjpQBT-?VNqylsiACVPR-XK|re^a_4{
z^uK(R5Pi3B7)~h5?fuv&nj1B6G&Lk1noHX1iP%^EbbAjbGRFCniv0hLH)S|f)c&Nn
zS4`(uD2P~s_Qu@r=Lq7HQW<uS0+GLbf(7|;sazs~v$CYz@A6ZrSy_$hPEqje{bj3x
z98Z$2zo8>K@0X3BOLz4xwKO#m<HT=6<A<VfXpwruMso;$3fL@S=6=7|8P1$RAVm_r
z@SBv<DYsIALj(uNf+mQFjTb$!_Q&frdzfkiNqG5r3K{u+L9TZ=sX0p}9KD*>Tv*54
ze@o`utrn?~h5(w@==qn0JWkL>!Moq2j4osWyz@hjN|8zf1MG%{TZ0F=-e}@JSKp@Q
zLnDM!s(ms^bc0dMAmBxx^Cyj;&S){p?rItuXmM||S+|yBNKo3rBgcU-=$@am+z*KF
zZc4@9HsktJG2}U#%f*D2Y*HmRIY|#$*+PWOH6bI<pK+_t^d?(-Si2BDlk)`1Vl}sf
z{q_k&+y&X+gyqJS%Wy1`#I&TYr=$2tRm;FisCDDfUTy{1zC@aWkt_H5;kJKnsCag-
z_#pr$sNY%oi$Qt+Rl(*r`jxJ>C)}*Zm3c+Wq@BP+jN>?WDIZ$BaJDT^HE$|&zN9Lb
zEzX|06m|<eXEF9T&*Fi;1p>v45`raGIlp+m){HF#3h!*%*Lv5NadB!V4Hp;UomPe~
z_l<YtCu*D%QZBDdMNSi`$hTN8`0;xN`;jiaQzA5Ci(g;N>E^DT8qnPg@K-EU76tN{
z%K|V87`busg<gHQn;=+#?y&TA#W=s*Oo?8fp62xquE&cu-C%WPqXFbjy?HpTAMu_q
z$i2`|KS6j=RbwXq6c?M(ehQ72W@BmZvqB#|ltlZwoLCY_BIHq|0M@sy-G|s1<E;^E
z{iaRehWa<?mG}t88BD0Xzl*+bNCj&nZ-yXVC<9DCkH`}a<Y%F14ID+JIlM#nH)D!-
z4?;2aB@<J%>^;>R)|r=uVor_RUxK++VW7^%?zdMxzXzbXLnhZ=2sG#0ZWnCv_BEsy
z{aG+%EEVL{PB}I{v2%GR-d>t1U|kVEgvQry$OkcykoI!){JnI<1x*&Drh6B10v;L1
z@h`Wd41K(ib-vJW9ZcUlT=dfCD|-io&f=xl<dxNE>$A0BVqm4XPswxl1SL@-wL_8^
z+c&%%9`FZc=)Wg4^|aT5#!q#2<BSC{la(9pQ>)IW+pOu#I6JwqLNUqcm}kCn&)r*Q
zOvXEz<_dSEG_ZE=L$P=6%Y***SBWyqt?mAV8GkHWW;Po5556s$zjoVPwAQVmEvui8
zuM#%CxeuS2?H(8YrHA1ko1_01L!T0Z*GzeJ$}2uz5zyTbR2<p}?VtRXPfvgs5G(s}
zvBnpB0jR#HiE;Ht#PNw7N`MP2ULT9&!ueiL-Tq?b4em_w4H!I+6TcRZKn8%n+;uxj
zn4&pK?Kl@-uT1KF>>c(pzCcr=AN+mU*!9#*qMkGpVj|Bd-!1-zmHxVy^PN%Ui(yu>
ze&O`cx5+NJ(RCemW_xDmkCQmi&#e^ZZMigJIijLp;#sUbc}^6f%{CYGj3h3ICsyvQ
zhn>amG8d*xfZ|EDpZzuA&yO9ks%QY@r^zTwiIUSbMjWu+h=(0Mx8QvL!7J~K)oK}B
z4}Z>~16jQKew{ndF2VNu(pF>uSw7b$-oD4nI=_K2guc9|$sOA??w$qjO|;%RMkjEy
zm<hJKMXmn)VP8Um^WM9)<l9SVOcjvQ_nqzJVFJWAJ$%~-0~W(}hiOhn&mgo^ZojY1
z?Gwv;XS0Aa^__Y*(3mO|vAr(5+bm>0ni4#TtdTL~oE!}SBxAJRB*jVJH_~&_ijen*
z7Bi*`feH{v5v>c%X9iH$k5;n1+UFQCbBuGW?JatdYLThpJgjmY&++M8<9#*;Z;AFQ
zB6+UQgw0IV-j1<Vt?KQsbp$?_Y~y)``sI*3Uwx*%I`j!3Y5$2a)bWX8|NeIW>4YWf
zlPWWBsC?WVlT-IsH3Ky9VvBkor7pBx8dT@?YIob;7T<AUzqmOYOHn2RaAg4m(HN0F
zcb_5-VyvO`|3q$fc@AW)Q=a&td93DsxCc*aZQTzGdBGir4euB5zUv4#?kVCRQ5Yvc
zAKu^Rf`W&c8-cSWIOo*9`AAocRkYCY$Kt5CT=@(gZ1+3&I8oc5HnP+}aZCGz8o($Q
zX+R<};JD@~2}?Yz)Pk+Qa`4lM*Oh#Fp47=6rOt>fpgC=UupMncmY#Hh{yW#eefW^z
zd;{~us<!ov1v$QRdzV%1<|^#t*_sQs@BI<hfbsH!H_Pv0FpC`>ys9YC|Fp9}bEv=b
z9RKtHEj`&Rd%^H^iNLV3T8AIctEf939%3rw@W|v9;-+0JW+zs4JZ+<vnGITG{E{E-
z3PUQ1g_D=}`mWGE9Iv23sl+VqagF|!H||C8^H7QbHc|CuFEK75Je1neutH7Uvl}JQ
zgCQ6GBDHNRE+T;YOJgp^JX2OqN@#X!D`@ki9F0`Y*5E>3N&NjuT5<wh@)+{;Ud2TY
zEAJ<(>fmY8uXmfCQ>vfNdKuw^@CDtp?8cj2HHtYGo)J6nG^-=#C+fXYFOSO_c8+H3
zC1eQN{j?DC+^ocW+@{dPmXC%k2y#0NNb@suf4;Ubk9cJx#1aEfb+)*;ityoO2MN+f
zpUOITzYS--sU14|&8y4;7#`C%J@c{*6x+_nujXBR%1C4$)J#A9oN=QleD)}n6NHTc
z16(;y()AK+9W(AjztLJvWe|Q0VxDlId+W)dXu2i8>geiv;7kr!G8OyT6iafj@Wzm6
z(d~^Uy*`-%idW*S_-oitQh=8eHPJe&R8Dd;>)P5*^dOpVA4#M1{kLJoI=BRo82k!&
ziuOkLCeLnJ`b;aoeI;2KUeV}$MnS*1`6>f<_{Q+UrC3i@3kxkaH*8n2oICCN^LW)O
zQlZJn2<(&_Gew5HseD?-7Bx4Ij-QJ@A8dj*Nho3<TJ*(^Oh13W58ct;?CXb58C2*5
z@g!hxBKp}M9v^X#Ke94%I&4rXJ`$4ZOd;f?3SIPKMn7DrR}<%385yIT7<YZ<o)h3l
zD`2d>Q?RswA<DiVdkZD?)3tmBcSO^b`Dovza+IJhK`DqWQch7(O%U%G7LiAd{MKV&
zsZpOv%+XB<sJAs&jPN&-!3yQeQVA~oM_D2UOFTvh!052ock|ejlI?8NNN|KEuOA${
z^9|i|-sNrUY9<yb%d=Y_=Yl2Sp=psn5=G0mfriX&Z{4gP1Q^PW`&HVZJqBEfc}Ywa
zl%0O6&H2m?H}{(Svu{#px>6G~)kFU))ekM=3c}LCTMAxhFun_?{Mjy9{t};_or%id
zP{K<w*N$634Qs1H#WbwN^VuPsQuJxqR%+>eX|{e2WQWspb0-AQ*-0U#r_?3nc~~^a
zJ{-dtC>_MtNT8J`DWmEDkdX_4iA1uo(KLd~H}2Uk+1%e}8Mz|iyC&vp#>x$GY>Ejq
zwW*TFEEAPPO|EJ#GgG6Q8aC9ZsMJJ(Ir${_F5@Asz<VLqM>h=U^Tc*d_Lb^KL^Nuc
zM&+0$bOrX?64KVUgRg#~|0u;`jVBJQex5`Uo9Q_h8#JPa?H(xbxUK5=nWh&1Q#Eq~
zo|DJHS<^#$uvKiVuuUI%YTU?*xb>pBR4(rE>5d(kX`+0eWvNLy+<shm*u7De!2RAa
zo(!_Gq8}>4;9$v2;v~i%6LVv)G67G?aJZ@Qng2@l*%>+az4yDHZvNoLhrWG{GyNi@
zVmacQO&7wso&=AxgBjMH`mGOyk}x5!ws*^@qM0h{0?Kn`VZVo|K$*OckHUg?4+%<A
zbSU^Zo7R{M1?*7jLa~A@L(?loQ+1FHIhebza=~**alY>E3+^ZG$*ouH5x{^eieLA@
zhdR)5!vbA*+>vk%4R<nU<Kn@AjN#_A&;u(2{NW)=$4it(-+MJi&(N;-_y$J}Gep9s
z4mNs>ynzi(AJ%dshj<RGkuV-zP4*^lR3n<s8^+NLNIyNM#2HUK5>$^%UV~7y*WF!=
zphUdn=6e|aPSA#MCfk>97PeWEH@ZFc3Ui#u`RO`F!;?{dRc@iYf_puDqrrRpbs))h
zaXd!8bCA=`;M%yfi%JA!B7|b<es;{z*_2_G?#F;rC#Bru4&KD%K{CyjF&~Wg;<Dj=
zwpm|6K>PWFzIN-KY1#KgQl2Z*#%m}<4eDnOToYGmef+R^*JtinE4dK5p4k>5bJ6Vg
zHWtPq;kfI*L6+LTd}4^|4XH@x_87miS>1MNPBx~2&MdRo9Jku`$>*#4%4KJ-EES(5
zMWJxC#EsE1c6I3<vMBKocD>t*ISNq+#j0r3{}e6$F?2kml(9+NfRupBG9MivnRK)u
z@u#N06vPrxn%k5*_$G6la}8G-%tL{`zJ~F+)l2dE)i5iyj=GAWgG*OesPrzev6zYN
zqR!9Z)Lf?#k3Df7^0WNH`uw<wO&c!@9L-mq5rGMaq|WV7J~WStHpC+V=yVQGzU+n1
zVc1Lus?g{xC{VX<W4W%NbT5w3<|}SULSdPi`9X%c|4FIC*!9$0m)aktaj`^tg4{4q
zVB<yU*Cbp6q83`~y#mJVG{6_;YU;a6B$lS&34uIGckKjs+*K%pMs$R=lwNs+kK$Is
zF>3dW0*ljBqd7j}EPqAx3tt2Ot~X!INUFHAGeusHSZ;>)ZeaRGa1)cN#E!RZ0;NOy
zb843HEmnTbLja$zyMsxAKeYkt)`m>7G3keS{t7banp|O38rV&w5tfFK8+p;K^_~h)
zhTgUwA*|*w4M1o~<Wl-qeL9Xr^)E_{Lll$3yPGj>_pp=4g|U>iioLuGP|OM#&Bq`e
z#;h!fb`^&ZnKpgli`d%0W$YNS_fgBdPuJDXkAtg*PD8FmJ$h1~KNyB#bo~`)pOTC=
z8GIPPfrF_98yFp8?~6mu!a|VZUk&HTk{m<*op<3l@xgQC*J|~d0yzTAQl)|-(Q?c1
ztwAr1iM9z#N;XkWsrcjg%NxzInrvu+-T$tEIu_PH7cGSWwmZgUpO*-89-b(b^Ba7!
zQ2Xk6mo6bUB6QD(zY!ZpTx7)8N=(oirN@)6f{qf2k@y@qvDtRJ<rB8oDW!-FHhPOM
z6@Crql$UX`Ptw)T(-Oj6mRR*(H1v*?w#&d#DDUA}{CNavYisE2fQBYZ)RPpmhWnzW
zRt>zdE)-UKHa<{rmvZ}lQVb7T>jb1*E0%~-zI7&5w>#k#{KWon`^sbVCJQ+f6t<my
z?`$|jjDx$<Fmx|8diH)7%=7f1=gGms64cdX=~guLi&#_TKjNjoTYx14)$?)ZzN_Yp
z9K0y-se6T0BCV>n7G{E;g5VNLHi+=R5E04m=Nn#8mbk37efy>nh7G&>Y47tY&r7~`
zYB03Q-Q}yo2?G%So{UHf!xwqyJR?B-`og@E860gAOwnP|G6Wa5iV!n4%0X(-4jx2}
zM<b$pWtJZ4bSec{bLAkLh1an?2%6bDP{df-!y!_xDZ&)oeRM1B>yIns_w+gtBtK;(
zfIZ)P5M5b%gOOEZueH?tS=RLdy?k*V-?ZR-t3FI!7|v}#p#fjF{t%|>ZEH?k;{|1N
z2{Hqi6(=JPcy<DkrY>A`n19N%sCy+`2-)H$@W$y!n5{s8u_DvVv8XjRF2*2Nb|icl
z=A1vhN<fAQ)W#1@QTNEcz8W82FE8fM+`xp_*Zz@}9OUUZ`0ME!Qu~IVlCk7+3G-RM
zr?YD^<$ZU72En;=C@W+5rl6?UBBd&J!n`8Z=#$XtMYQ1sQ4N&I68WHx_=x&GSKQk}
z-kT$lq`naQW8^TeD5=jV0>$@&GPPkDu~2#kT(XuOPe&Ets)2DOG>QIJiknU>b3-Q4
z356Uf;w$3`Ay4hAX{Fbn#|nix?G&LsfE#9DQr7||ShEx7Kgu>@&KfxjX6YX*3~$rb
z8Apw9F!fuin+Vr7z=s5;=R8$>GK@NWekk70ql{9TfGp%fv^;DIN?JLC$#H{j8I`V=
zYb2YyvnIlYx=+(i?iVp0fdGovn_XHmUoiG4@Xm<gh^wgB>0ix%ziS;p_84pz1e^B?
zh<U<(|Asqo$zBxtAXno$`vhVy5zQq`nXj<Y$ny9`SYT0F6ONtM=8#gf@O#gww`C?G
zk;kJ1I59Nv&a+ybp)EC`I^k00zhu5py_I;xrlOX3bXX8No{}u2cR9d~tMNXLxuy$J
z3q?*74)B*KZ+bv9_jlSo*XhtQ(AWR&M(KQ#_pP?8v4PX*F(m^T0E8jr4jN3{=Gklq
z84(b`BO*yS9KP3jTt+l=8BMJW_@P8{J~iegslf+JX8tK<s*BP4cE?Hksn@H<9-L1o
z*P-sC^C`MmBh1xG)3Abv<%2G)6CtCP;9C1i)Z>>%>mS?|7KTgHN<appM|1b%Teh@5
z(N=4voC$T)20RjFbj|z?m8`-eby}pXNhJY0wPasYma3&iQyN-&90}Pf{=9_;*ung|
zcV_3jTm`7!`bF(u=gT$cm#@@F(MAVvI1oIF0*L%DLQPMeqO+&+jM(7AFSOzSYV_N|
zSEWr<a%C0uu+fIyQOxaT)kMX>uX749KlE*4y0nTt%9Y(<Es@)7Bt#E{GeIt)Bm-UE
zJhd7xG~(l(#~*m@k7f${+{wA<X^7WNa<19g-=bmwYKN|3NLsM>D%fso`?y#O=<HIp
zG?0>GsvgM+FqTSEWqCm7z*T)}2AKvoe3-AJ=v{j_FuOOltpOk2g-%msEQ0jc@7983
zAKY8C1dV@GwS+jd%Xn^3ZMY?{RrpUWjdAWu0iq8RHjfx89|#!yu^DTT0i#N6nt<u_
zNqz4eTOal=`?(?=@I|uc6{p2U^$3y1jjrA2S{A2>X4+U6h%K-2bmBd<0YK4&j?*p-
z2cZOb0YE1c#y1xiG14z~jR99XQ+nYLcHW}rZFQ*EnQRaxsBP&7x5tRvgwBn2sag#t
zlU%K@F6lgw)#dj%OeZo=%G2V*u|Od?BAa~acP2!ghY@T4YBI6Y6&GaRdq>{fxw}=0
zgB=z;*sr5!W_%neEdK|v5g<VSu~}9xlcUL0WxhCy0D4E0ZfUnuT93}-Cw4%rG8I3)
zQe6kBxh4Pe^a7pP*Xe8tsV;Y93@k#Cynw-`-0Cn;*AodTv~cx%@i5klv70t-gY$>|
zk;zPG7l6|8MBM5GIs6m{17@tRqJb?Du%GMag1IXEKwXwfQqaH`CcN<Y;3ci-lrc#E
z69HFvDT7wjl3XS(vbs|T-O(|@^IFxe)%Mso4f4dZr-+wQAbDeBejaDI*p=;y;=Y2+
zr{7hj!u;g4D!p^ERO~v%S*csL;V=f*n5#k3hC<+JxY-PZeUG@)Gq&S}qnArPvS_;g
zy7>(*N?z+aD&Y%m<#f_BSyCMx;zjG(K>Ytl+E<6gxg~kylHd^Bo!}N+f;$9vNN^7j
z+#!JkcXtWy?(XhR6WrbPdvoWT-I>|BcQe^P;Gv)HemPaAPRXz2oWDz4_n&(aFF>iL
zczFZ@KN*EqlT0XQ!8$*r5dPv^fG2GfJ=cNqu5gJ(>z&*!noA?M_API9Wj%uFM3!tz
zf}RQ;4)xryd}OZ7JzClOR6o$+EI~s<UhuwRVZr;O@ycXo+xwD|N8@LnTtQN(uV|-c
zttz_$m03eU7nv*N+{hJ<A8j(|1BstL$k5UBhjbV$DFgkSZkF%n!g$a>o#p#~!>jhF
zIXxUYt&e`Zx~OSIGlKa-+=LBveevTKqng5vrQDnIl~&$ccb_5QMs=vNH(Zbv7Rs$Q
zA6w5nv<ko=t|v4`@vp6qXy_?~D*%^;F5aN&-h&MxjnxC3v+_6}KB`v`<kK9#{luhz
zW|*Z81`VF(`4D3$dj^2ltzHu{a!dm6&rH7_6Tp(Zf9nmie8vXkrr%$Wcm$>{hj`ee
zCZy6Qtc1WfX-d(H>aktkR#mmkOaUIVRwa_oJ)KTDoVK<ysJ))+w#>90Ev2Eh_x5wc
zt@Mnl!ZH^rjpQ5If7hDxFU5hFf^7p3GjnFKb7YQSFIh`ic&TX_eSJxHiLSX35f)4X
zNYl?8zI$kyChJnM)YyJfeqL|5Ld{c^Sq;6X46H1(o_0F9G!dW)1S=zPWwDgyw%uT(
zbFt!*Nn*k4K}>^S9Pxl;QOwCi;xSfccNzFRgJ4tR;j0b>ZPh;u5?4$~O{D3^<3Yzi
zfW5k^fe~<bXTw{<a~obeO?^&q@io!CWsS$WGFr@mfwdRk6v{JcuB+eBwB9&8HpiDA
zmSkB!g*)c%Zz}G`b{k?oeJ$U!Q~vzJ0Tma(q*j<1hw-Zqd&AEo!g#1FUg#!KKL)E;
z4`RJx0T0NJjH^_Bm>SD|8jjW`ejKqi9>>&_s+oB`slHJ<Kyy80AmqIuHjUHeoZnPL
zd!0T}L+ZVjHH-Ekqc%WFBw9@iwh}4DXW@IS-b<_Mk*oMz1!D#Ljh!*V!E`P}VukPR
zN^Gu!UWXT=)e#=?Kbn#x;1o1%l8;rYzb&MLg>=MB@R&rsBICJ0bs6pj3WmQ-sBfvO
z7QF{?$(TNd95`{8=(X6?hqvKh=b6c-Tn@3HGUc94QjJK*u9LX6O1?(yQ&v&!bkei*
zHZf_2a0>CjKEmNZd{g|abja@vWL>yNBLR?#R^SHTnC}69$#D{rY5mD$^~7hLILx1E
zJs<W}FWXhK3u{p3EOp?<+Qva1XK5V@*_D|za1+78%-8}qVACyTGxI@3E@48-GT90`
zy`Cl`so(ite;JF{sp`G$at?SYZQ8JekZ;5#l*;f6$`SmWB>k~eaI11et~`<iGRNyP
zuiY9*uH0t9u$O$SD|pK}%)W%QG>iVQrmhYF0<siaVX;C$xsl1nGv)yKwnt{zw3tT9
zly@05YDvKZDE+IlW+ffqgvmEW@d>-7d(l>g7x2P9bGAD)T600(*)Y!#nAx)%$!nAi
zbvB@K+?f{Y+yS@6%ujML;6{Y_NuYs)z*-LndM80Q741A*EI)$ZAMaotAL~44U3aqj
z#hVnSA@$`s1J}m9U{>Y@L9uTs_+jKktKThAXw0(1nK#_KI=f+~+a`EeKYvA5zkVcP
zys=BGtxFg$HF(TP4IAB-8pWjIjiP5ye{rRNb6}wv?pHh@*woacsl+OI`z4c2;^ep|
z=9b6JCnScQ?Tz%87m-K=<mhN?$fJDED4)tB_rf_I?~oswjr1Ci?L6H%u-DdUin2cA
zjF0d-ON}e2n`W<f8-#)2Px-PaiY<VCBd_z7xab6n9^oyLl(4yp30Ip2Go~fSdx>h}
z<EBfl?A+~wn4|{5yZzCs%H~Q#q`nZA(UfK=BCiWSGpZRT?x&0452f|`RJ$f1^Q%QD
zXvQ-(b;=jKolTbekwb?=w!^t|3t8GKD{<uq)QzCI1hvm`ksG7D?m>L(>)V3tLHOy?
zEVZoi1$m0vSG2ik842)$8)kW>d*{geBNY;;4dnI@?iPitvtPpat%gn?vqtY6%#sF4
zvon6UV`2KhM%9MJF)SlkE2(OZ;GEh#yk{-CJre!_q8Td`cuM-BSk)9uDH_4?V)Z9z
z?R*q7FJ%8LxM?c?y^f=_qy(Jfnl=IqKLx*ia1lK)D4MV4nkbpL=-s5KTT0mXOKe5!
zKp@28yWy?}a>!puPCUw1cW1%LaCZ^`FuF*6YC&I3@4ZW$RK?V1Mj@k@SX-V%V;yJt
ze{@U!cQp04ZlQkyslDgXfn;m~enepq?9F{au-Ivs5IGc6RA+`!RUjDdv758@ZB|t-
zVd~R_VkI;QnB2oaA?y2<rEAS<7}*pS*6bdW8}a_o_%6a{g$Hk4NcNnu6a5`rf|C3O
zmCZtdJ4I5ck611m*3;g`GiH64erzRhWW=9>qFxY9D6+8CaENsWhIx7GHkV*y;jyf=
zG*cn$T35A<TEqG1rAa`nj4cG<G%*6@1VNt2ib=vpM$edA6wkt#D(Mw+<{yh@%D?z_
z@#Y8I05Q|*D8g>H*eN|ihANQSZ2a^N=Uiph0(4xrlCx@>duuOfRj&Esf{VyAo*Klh
z?xNQq0(EjP>7?EwJg*;kY_d}sGHq0s)jCDJ=j=bVL$obHQx&iPL;Hh$Hl}!Xxg36g
z4f_T;q#&A(zEOt4I6}FPCHF-n6bYEB!zG-5*V-qI!qB)wfpi{(*7x2EJyL;#i#l*j
zJa5pfkrYI2^FN>lDnNOQwe?6`%iut!rmA_OpRWI~@sLJ^&|as1C77c!eX=-q$7?$Q
zhyA7~O*6@+^|n&yGgumh2^jw;Ns!JWGK6SEzV+PqG<Bnkc#G-p-$GxQagcy9Y|Rd7
zJM&Tssbje|Jk#iK-7Pt^D6TK*sq5)P)~9flxF{JDE@6^}tX=dZkar(y)3W;awlq-M
z^PJml(L4YdR0ND>ui8z_jxTn*PFP3C-F$u`hfIoHNYELd(O&*d=+)NVOC)f$cp=P(
zeQ(*RU*0U>gbkT{$Jt_WuPZwoqM4c$h1~y*24zv0VnlfT_Mxdmb@Y6+hL36cHo-d+
zLM9Y9b1Qyrg*VE>ABgg3iykv@lvbNLRN-7syPJ`hNk+_@tVhqs>!|;5YVR0epNoxF
zf-1?ERT-brMp7GyX(lNqfeOjJE!Y_ugf^<C05dC=?R)Q;qi=Wr)XDm9Bpm45pn@py
z8t2GWap<T<z;O;ToZU^p%4pHuYgV1`W)W!{g2%wf3uZ{sh`-C2y&5;`4#M(!eahl^
zo@YT!Cu81}#fIW~=5~^Cy82!C!Y3Lde|)m-?WvTorn`n*?0|EBpvDdP#c{r^{5jU}
zxH?rSP-P2_%;@A&uIbsPznhRXE-EgCG$eSkRn9?eZMK(n4aTyqgtplDh6DyQ5)L%=
zTlvN5X_}p^m$okSpycK>XQDpa3&2VzX81gp0i~em0E)H^9TQQ^&iatbBgK)`tuX3}
zP0G5nMMYmy;qw@mt@~LoB^;5nrH1Xh3C@Ln>TyhDc`pWDzPR%&yx756{X4J|pf|<E
zw($He8CeePU>qz>PBy0OJ|Ja2$qS~&9MKv{mWjJXhV=Cq+t|5*U3*M5R&Hnhg#G3|
zQg+_JDgDD#NMgb;E=e&@TowbvYVRunqJA!_k&f_iUBE^y#I}*W%V45WzU0YD{kHX;
zh&O+SqS;E#xMALvrE{?St*1U!&`3I4R+=BdLur8WTn%ljdOl4|0+&y#-3xNsi<(-$
zk0w--IL2ciwFwE<t3p?POvAAH`AQG%U}uqhjdJ#K=Q@j@mwg@hD0`umXk#Kd+S>OS
z!6Silv0d{q&708ZgTA<h#d`}NuR1CuEem8!=zk2g=+x>~3{j=JKv`O8VJc<jxt~R!
zMz*ZUl=Aa+X@t!Bv@249CGzeVD92fs>#&D*s-?%bhkAIP<cEGMijJf?8dht1PB1J$
z%_<4#qu$-dezTJ>M$m8_98op>583p35{vOEECQ&Xl^y!@cfrfG`zQ}*>&CJ=Rk5|3
zw+Qe@^csU12bBP$e$ml*Qqw=z(8|@66q3)M?RyNU{Z#NcY0N|DBk(*&Ha{g!B!H}R
zM1Z)ma^&rW&<%@wJgB5;j`a23ad!gx&0`CKF`r9V6HOd4P@`=$nC2%e-r`e#{=MUC
z1mvs5Z!gD*8%yLiH)lsjU&dBm-VQW*2i~i%U3Q=MM;f(0%v75DgPSUx-pUi@$4GMz
zu#7f8V7S+sAr?KX>C}04p=cb&Sc1Tt^=F#IDI5Zj@#8jlgtm5X!`cx!Bn4WJ>zsTO
zBL>8eJr_`G7Ps644G#4}-6Xbj*qHH}G(Lg3xCY@wbFk%iVP&~ScWxu+_@))QYFRq4
z7Cvu9VBC1#QN%k{O0kg<U0)8r9h)k`tyTMoSd?Z953#J0M&eGSJ&S96@YGSvHI`I8
z86C_;=~})Wl`?GPd^{q<Ui!TJVE!YnH>$0BrB2KPK-yT7oR*(+z)Hg8cU*|N@i-h9
zZB9}58QE96n8)y*gVycz?^&_*pW^X%P}ONs-|Ay{w`5G0c^b2%GYKbq3haW{Zw|ni
z&_12M;@Iqh;cVG^1-8V`U&jO4(X8UHdxNXdEWMz{5>Bn8s0D8FQt2}qTSfaZx4p!2
ze87sQ%npU;4Xf}+TOl$#TRz?UuL!GMR>P035J7Mkf`(rW6ZRR5gy7D%c;az{YcI;)
zMA=7K3I@oq@obwU*gmI`!L-{S)N|a^uUgY0Vr&nbDdFH<1T%uR1-M;b%)Y0Y%0`4w
z54iCg5^mybUaaN$%$+YHbAwaH`F2wWcX1CFQINN!UdJX{lr4U-nU>0VRlucr&Z8f#
zM~E(zOGy>{3oe4|u$5QhOl4`A$cM484*_v*-EhZFv{yKe(&>yc@Nr^VccPelvXeJk
z+AA8POUa|3^%i@G-Uz?-L`{Qc%YHr$8`bZ-9JoGxgr#b$sJ3Z$YAyCLljkMAK-WuG
zcuWb?^$F2x^_?Fb2FsE7v{UYN>h`k!_NGM?x_hiI6O1OOktn`v_<p#wa5XhQ3gh{Z
zlz0qT)$_Jw!)XcVkcsh!R9Z^P8sq0<SBgh|_JGz{<~GCNY~%zF#G#ZSM6_Y_60H!+
z@ay;j6tBI<^$Yq5h%idM2PQQ((}}dTnFlNU3@yLJHoU6dyw%295LZ_=*Ff4(uHm=y
zXF~b^&C~zn4*ic8lqAH}H%$E)Y^Kss4GxEhjy11^Tkib1C8W5P6*+*mQ)AiHNp^wG
zXFgtV?S!|eln+@K571#Bkxx5J_?{>a795ndp%|O%AjDQUQSj%8_L(zGE`JtIlTBLt
zRa8hFg<W!{0`qOxh&Cwv%=#?VTM>_%ZGshe+?~DVTI|`eLeldkjp!O(r(JIhbEYgZ
z#`=dCJ@2;E>JCTB_3fwYMk8?El-zuP-`K`1^MK&w=JKXB$SVamk1I?)BFpU1Z?}+V
zmA|%6ugF9Td=d1+?%e3)^gI?@otToXg0oKEb;LMSK6jI(aa%WG7(vb$!ZoU^Ijc`J
zxq`)RwPQYLjkICLuWh0gay7B<HC&y!vyFuZPAn)2>Du%4<=8jEJ++5**h(8^oXcJ&
z$g_|ku$Igj+%sBBPDpED!~y&9$wI7>q7`D=@uk1nY(4_f!xAnhq<yf6LRTh?{+SUe
z7_8Q`iMUosy>TsLQ4^zVJcAET>+|iDXkEMw@(A4vZ=S`{fT#+esIh+UmpUW8qt)Qa
zbDCZ78t*?r>rAv5V#U|$nimaU3){BWtr#sq4vrBML6anoWJafK^JrzK>fe^1a8-68
z%@Cb_=D91(Tv)v^aE%pq#6d4(_VE$m@p{*WTynqg><*^q*YI5+>RJdnO`@dUFNEOY
zEW|hJR<gm7L!;3Ma*aYaBZe{&-N|Tqtsx9e>Ai<*Xr092LP5}x`xJLlo<0ieRb1}w
z`1>=`kX!g?LI}2!nyJq)PX_9SVD9?n9|Vv-3RoXF`7Pa~fz~JN<A@u@bdoz~Co5gh
z)uW=3)@J!|{k_<$!cMq*DzS238xuE{Lt=li85sxwdez&NF7OZ$pDhv-(-RL-x%wst
zf(njRT~cy3lIGoTubFvNFY80bQ9KFwQC`INfkO*^IE6gg2fE<X;W{RMHcCiy)pj#B
z!4ehe($Qg&6*pgOJ*P)_z{W&JGav7&9;6P0;#BZRW){H{7-G4Tzri=TxWTIz*Rdjq
zj)@hPw8e26#Y5RBeKT`s!_hCMXjEJxHhg+^^%*u-9z6I)b+F|*Fd@AlP!#vnu$9Dp
zzB!Fk$N0G3hF|Te782-5@;aHJIynlQ{oMScHEJl4C&caR?Dx^?@=@`$dIu{DpyIT?
zRsEUyz7~O_+Gy1xNS>PQ?f5s|>9X10X7ub46rp*iFwP9;jj&~buR$24K?&jePm-*!
z_7~RNKQwo?cgs<nY^O{7eHH-5L(p;~cI410e_QyYf*#Px|G!w>EwQ!-I=i6|1-v4Y
zo%HcY4Y`zM#(pJ#IQ7>)xhAc&r%k0*$V5aAWKDN>Fm(<?Q6En~G-SW@SGxX?8ZhoB
zz`ssZua&go;zoe+O0rpGUEOppWc>`;#MoUwKR+4gluoNc)9Tg}yk&K?$t&|(R2PT?
zUTQtxh!+<#K;MWv<I}Rd#&2*80!q5r*x1^XCb#TK!F75nqu-dwrDDYf`h&kE0SDR|
zFm#3zS_DnSvF_0I7trD#g{fCr)5g&6i%@UfRh^$s%c$t?_$1J9z-V;{5{U<Dk%aj6
zFVVnHAiY|8VPh@f!$n})xY?|GnNKtNPm+m*pDc@*<&C)uL}dlbp<MgK<vySaBBC=`
z3glYPk?JM!yLgO<r`c*P&LraOS#Sqck@Cc!I@B$24Q#u5B?-6>Al!Gu_jcR&NT2{c
z<3~XZC!75FB=L2n6PLRWhIvJ5q9NEg83)j6`K39r-Ch2)417FVkIhAMW4<qSbf&$e
zrxG%9ZP}j0h0SD1y-O8Ye$>*%%oXI2!6T|*E^ioORZUH2?ys+BVa)0&YnQ06#D2k|
zEzm#3aTrH^0k#3~!=Kk<BbXR%%qV5cb<6Z5%q`#KU3*u5#IhFkH?S20-?+(~2E5Ls
z^MtJMb>uIj8hVtT;Xz<$@jotn(F;JeA5;@dhA+>Dr%Xz|1(0lR-90fI$|v4sO5AzL
zHzCBts6<jy>x-|uvb8w9M}l@Xu#qGqV8sRpJ9aa06S2QGJ1c)$u7Uko5=J22cy<gG
zO6MyDbP{!a3R6S}Ulo+rd&Xv&sKDrDn{K`Z@<}H{!C$<umlhQFauDP&GKvxPW-+%r
zM~#L|43g_hTaj0rn;%GYsh;oxn+VUXj~LdBaZAg+q>;5EKFabdXeE#Koq%^#Ar6Op
zq`of-w;2{SX+btcWZe7LK}`Q*!k9jLr=*})>Sc+W7zhf139qn=?JRzA5l2Kic#UKB
z{G*iuK=;9=DL$U8nqf1$;~p%#`MO*ct~MR+H^lk+qQ&!?F{HP9>ZDu=m~*g7Pn~Zo
zt{!p-1OTpR)+EO85Xw#uYFG!>zNeq1arjJMlTRjd6R(O|Ap-lR!&bETvAq<0$h}^C
zBQ{X79#c@y!X_1eeIs4wF~}g9WWKelK=b(Uc>IxuCdA;o@@U+T`h$h?FqiHmV9><&
zV90Io_MGnSaGZcQq+1wui}goYs?b!QfTP6jObQ7^?FEbGtv8IWR<rCGaaY&1QixKy
z2(PzzD+hb$?0OI>J@FC6CsWARz+HHTw&NB%oM4;vk<f9gqCL5ez@t>f+UN0Mi`O&N
zoY~GmpM-Qa$kRI24KgKu3=2S}x4dIj+OS;=H0^s`9YdGZ^6oY_J%2=;r9Lzv5$4iE
zr_UY?<Lyqx2!IfTB8x?|%|<f7kDi1GK-8O}B`&PjjatF^Y<nSrU)mtcHkU-}8S{B^
z)~c9J^$Ng1BwwPV!=;2clVC1k+p1gVkqEmLB7OrM7xK@it6I}QBXWc7&(mtYtGl^W
zYrrGIP3q;}GP;sBo=Q_MS-hScX(FxLZzTf&ec{p^U;s!#buY+*hGsx4(mZ6b94zFk
zR#J~VcFCN>sf7i`;9|o^3psFJ&mA^H720RVuFG__8ydGzq0H3Q_d~ZsO29;*)aTF+
z)GY#SB_ZLPc^RfMN#ypIp+-k0Pb2e&>UIn`OdY_u#&Os{cc2qM+W;@ebL-}oQa6`o
zRGT-fykz+Hani8OB=h_IE`ag2FB=f~=qz4Wz}YW&NoHhu|C}h5c`J=!yS@FYV?_rx
zBU%*Ql;(YQ1Bb3V(TeM)aIx$u{}pi2X8JC_))H4lb1PvIx7wkn<`PV)tgTJxx-MrN
z6f)=$BbnP%m9(VIzH{djUdw%mR+^vRp3_H_n6qa7(18B<ZF?h;^(PR9iS^Pe+&7vA
zSyx|`fbs-JaSm+!C8fDG|8pMoDeBIrWuu*H_zvfXFF7FCllwm=z5H+XK`>ofd&&9G
z%a%1jWdirBH!7Tn=*60t*#|F$!GU_i&!}c!YsgpE)}Z`gu0OYUthYtDXmui&C>u-o
zzk@^~;-1Vr71S!3*52Nm&V}uw>Uul7^Ks;>K$r`xsNc6BEX`-nuZM)gE*c1iD<=f;
zv!WN4aY-q?@X#k=lhZ>x1zA+Iw6xgnR$kaZ3CH#~+h?zUA3N>n^e-s5xv}i$_2ACe
zLRU`7-1p|TMX;!g%eR8t(a#Su>IS~642o1<Fl|}2it8hG!AuE}p|fXWEC}2A@FkBr
znAS2MTB(zJ6W35aYr>ru1XO5R^u70gex_^?!dY|@m$f}WXsGy#>{$}Bx;_E+MrJWw
z$N1$p8M==?DdLjV@7<gXBZ%%ks|xeF5lmNBiZQp(Tf+7k384w2okPE{2}y>28qr;1
z61N-eJQEhcW+DGPa*Nw0RRuDR88?}pUsiaye(l%8k$ql{4uTZBLd}h#_4EaPFt8lz
z_HSPj`p{fUWqD1r7_3{s@abc=>Wq;&li!DIb~gFBu^w0IUeyd)+!^&53iTlvQ>S)*
z_OF(`!}Ge_TSjcTy+W)$Z(6@{0owk*tFA=6@O(Uk{2Gi9Yq@)|OI~-KdK<}N-?uvN
z<YW(Sf{FOjODm4WU~ydrN?|VW>#NvLTe=6;E67>F<)D)3Ax=UvXl?z>07Jen$PYN0
z0|^EqNxFpAC`Si<qEBT;t&5cwdz`i+7F~>6Pq#g3$ozQwLmpJ4umNMv(_@*(OW*fc
z`koBG7s!RtO1nPql+!mS-Z9G`G~ag%hv}A&b*;o<bHO(6uQ%`I1m$ywZFcE`AWL>%
z0y#AllpR=VQbC*B{Qh0<)TwdSmKOM|-OF82P!OFr;rctnu*}<N>D`Z4Q_$2yj1x{0
zOx?{~t#B8?MA#d-HM7Hwo+z1gs}0-ySEQhvZWDtP`5^S_Odpz&rdNZevkX1FX}ca&
z?PKAz5G!X5ubo}@-C$mVbMJcyHnvck+L7w}Lx~}^rg#ATgJiYWk+qMFsairxN;+<g
zU$*{i+>ZBKs4;Z@oDuPK2h5KtVd#hPa40^GlnVV%V=V^vZ;!@Dq|4`a$AyXcgA>N?
ziTSzhJMy6J9f{TmQxg2@j|f6)fQ!aU_X)?;S&I8Y-5y*PbY`tJ7jX=RxG_;zvCkjE
z!bYMM+{ZP+{TY(Y_louPDqdcX<usRAF}-fvrt<XL4&d)|*d;=N^<m%-SJKGaN1?Ap
z$DwvCuePag{-#Mz-UUqDHIF~tEs*zQ84uoKJqRb+i$LMmsT`*h0h9Q~>TL`Yf)yNW
z>FcZZphU&!=!^>X0paCKg{<4Pj<D&0p$uYZL=AQk?+GUlKv24en4GmrPWdh9H;2Y|
zxy9Vt0+=J~y;{Cqn-;Ndw@8bEir2Uh>T9yE!$|I@X0Z60Z0^tXjxvgMq#dY5dZ{6M
zWL)SX2Vy}^*!B`fElYFPTMrQX@v909&TvSGz*wa@23Ec#o07@O@)7ae{tHXPK-O7%
z_`{VY_3ib;9Uyb{QE6Z9$+!$ozs;L4<%&OjSr5Ak?0<85ci5mL;Ks~C6W>Vv^p1Dt
zpxhstGPEq!vaDI?DIhCY?L)XJ5ygJKw+f%kDD|b2Ynyn5Dw1|@6Uz!1k(pnB&@e|M
zo?}Wavz=>ozHR$L>_;KLhRvIvlkZSyxLb@kEr~Akdd=p3*+pc=CG}fU<P4`Pm~`q4
zBaVF*!P*pI?zRVWE)sGh2jTaxYywBLMYAfCT}*%sO97n^FfnubeNYMRnW6~SBLmO=
zy|{qX)B*}bWm*!+uJvnF2m#4iYt&Vu)j^YxvtWx7OQQ|UEV^`b1m6fSbKDZ=eL03<
z->iCnY0;P?NG4Ks)`Cgu{~aYJh7cnG9HcD$?6&~fH(pmqka7cS)~h$qS68mb1feV0
zFTP5kDvOAs#>_Q-qol0CFqpzXKTqr;4547grN#X47FtA9RFHdO@!c_J-O8e_OPWT-
z=wW5!tdq_09H=SHAuYiqHNmB2^oY<!;5_Xu7`V;Lhm$J{qXmtqW$xf2KG=<1j^+KC
zH)aUnP$*?s&c=^CSMv-6M338tIt?pISn}M57{ZgUUQM4J$MG{orvxXIuP0M|5x5^(
zq*^cLURHATX9oMQ+;C{OqhF%b996vP%cX=^J2f>$ehs<~&Nwg}J{gkd)zEX<YPq{t
zy*X7PynS)Mcil@C&p(sbZy0$k;3a!?G!V(5r$LQ3>v>H6@t%)ku#dU(@+@*~g5kI+
zonxk>UD)ffx{IQ#=3|Y0w@vF+OVe40R!U=h;Q~dO>G6wqj82ql&pfL!aRPQGSXE!Z
zAmE6-|J^U|(U&N2tLH@EU?_rM;82=qOt(pz+@f4RKQG7w&2pEGZT|GQ%Yk?s#m;In
z!q!<FV^KKQa<$j%UlGO3dNlRkU*&YVYX_Fd`O2_KCD)C6_&wF<YKt04$1B@hS1K*=
z(WcvPcLS`~)1cZds>2pCy{D%-`Ee&LmV^g#CMH3#VBFWp0-mi?(;C@j=@MsQSQ3WH
z+2pz8QXeJ4!FT$_Q#m%=q<d_8Q&w24^@vOqK86FV+(VG(e`@d?0{=6*09xzBfni10
zoD(m8e#ScvdT$@Ei5H?l93T_rBL>`y7vYewcI2GY3b;VEOj()8imUxMgX$=jv?MKJ
zu6dV<>_<HVgDBqTFemwe`%g_Y?5Cio7PZn9QgQn;g2I&O+eeN04}inVf9~%u=CbMu
zg7aQYxL^56DTn;S$J?{(Ui8$KmG3WJNJz?7wBXZEnH)|c$Mz@2;Ni>H^OZggiwg<D
z55;=|JMix}=jVp4z6Wp35N5PI`$)tVCK!f-9nLku9qJDhul6s4$a=bnQ3TsOASk0G
z(IVHDX47XB9aKU9yr8jK7FYNur9XG||NlxagxK?f6u92YicCx;HLmmu8h&Nr6W`i+
z%~;{2rW)k1<U&eLu1=aowltp|jS(kVygYDbZI#^f$M<;|nC$N;7Dm|F36FtcH11EA
zZZpz&xQR~8yOvto0sm9DoRx@~n5L4JCu`%N=1|+DPd)|xL6EMGnALRqdVNdzTAACX
zDdK;v?~j$H*TUyLBf9UiU#kZ!dntTJAbcZ;7PUt4hC%G?{Dl$FcT=I`Ha)G;a5+;@
zXd%)p@fW-UBt8|37^UsJ=i=WAKd>BU5&h>Czf4{7zccB-+4YZqfq-){b7)ul*Z=I#
z-@UK~hX8lIJ~z1d^UwUb3;>JgrxYai4&(c1jrGs$`o~576$$B1fRv3jrV(ZRA^-m%
z6~Fj|6J~${_X8jM#^0o%S<73{d*$%~o9{2q>|gM}I}9GsR0hb&i=w}{<bNS@XBh$t
z;^Jt#cL()f-ucCs?lOQvA#z(?V)#7@1dlO^QPQ0R1jNGr=V|#1%Kz)bs|ElCH*=8N
zj=xEPYb}@$So8fYv+G~U%3rXT2pu?1y@Z^#e;nmMJ5+y8%UB~c9MsP8XxKQ}fBxm4
z-?)hfDB!<ptJnEG3Vc@R1&IZZJw1a7fA1i*^+Ev@_#iJ?BB4Zm6Q6`6LKGJI3y%Hy
zGMgCmukPT03ECoEeMPKZ#59r~6ufj&50CP^n9?38%F59aGwlQw?%iHFBZ@(ozbA9v
zVL$ErG_rSEve(r#i}41=>G`=muB11Y!iP+Bqlb7AoWki_#h1V}=cg}oT`~TA>;7`T
zZbH5Lovf?3mv?WswdoDSWgT#!Ryj4RrQ5g`O2C18H|%*uf0y9_e^?J>9#(_Ant^9!
z;bY(un6vq_+RdGEzYlL<C5(Ge_BWo}+Vq=&AwQnf@~zIL%BnHDM)<!?3m6ZC^R7l1
zo)rQF_3M!+lc!6(`KZfgW#w2YNi!eIl^VrV_ouiI`K6QMW-JMYbNY_ZV{bWsQH%Ve
zMF!;N52eD$2jG(L{Zj>=4g~z0=(BvmS{{#-v}W#7Bi@XKQ~CXu2KdWO_*Z&Yc>r|*
z5CRJWgX22V&!^wFXi^boJa0n5&oKRee(LP>bWNj)fPletV&ZE9aIQZW^naoFpI@e-
z0vbg+tf7t#G-mI*2SB6zQ4!o@{ItF2m544ZziDh*$N+O0mwH)H9fZiI$9WG!e_VFa
zs)~k>@!BNWu_fau5pfXV|L}DEs}!w64W|Y-ka2%MAF&zDV-aLfXmC`c&3zKx^OXme
z>qB__<M0HB!B-icM<M1U$cy&U#fzNi*jIZlNdL@%UuK-UG+=)i`H!FJZVHFe?hSCJ
zyrLa2GBQx@+KcwJL-X?UC1<Q3wE3U!_~N!{M1D&tp`0KBcE0H*IVll$^D*q1hBa4*
zbiH@T)PX#W!A<s!jn=d|fgI_7B!_?h@Cq6n0$gMeW1XmC<ejqx-15Tl2p^u&yxQ?s
z&5PznbRV!~dh1y|MInD}r*1}3kJUvf^IUJUD8@*y)>D)GJUXjF?(N^Qd_LCba4$o`
z2e%((UPA0FT6wrOX2Bbn1Om}kjvm9#l|C3i^Tow9>_boC5xRhYfCp4Jg-gX+qdYmI
zfcTJcWp>U*-0s33TE-&f>xt=Y|FBnNu3nv*xq0Em{%;=rCK@J#0p7G15M>%^+;=kb
z<!*lXBP#~9d$CRs;0<5q>!Y}~b#34v<{H*{ZcY0K{R6q`VGY+~Z8l;p2*c~<4EO87
z?9-F&x7;<VE(H7=41Z6qY~bT%T6ox(H%#^%9YNDaj(b~3=<Aar&6fEiinM8TZo{$c
zO|!FF8;8iLF=<N|;?3?GCzI8J-fGqEQMx^U6@vY%M*6!Xz!8rrLE+-zZ6-|<T}J<?
zv%-J-HpA}jM#I{ov=R{&ZcL+|K|3xn*{traErVcUOu>e_aug$OLsG+~Ttuu(J?Qb_
zft-^2tuhz<Z&~pjGYDDPkP5ruwbVC73}NEKyGQVV^tHmijoWqgf;_d&_fMjx<2LSV
z900~oV+W$Ihgf0DMFL>KFCW%_*b7cG!09>Z$Wo!bTg)9BlejM$Twh&P5O&emFC&qM
z`K@OPws8P{$VrF&NdL0U4m&&7WVqAFjik&c-;5h)&zk@9WBKja2FENuxF=p5^DHSC
zr*W-Uos+lW=V7t4O-U2_fHlCv{+4R?X8h^Jf63L+)unqCW8|Oe_3`wO#qNe&IN@uW
zObVO$clnk+1y4?s(%&b+32LatzL0NU4y1XLy<~Ujx3;})LJ;5Ds=<)xku{X+k`o>M
zDzLSm?p;JV;6Px*Sm&2UT?;(rW&|Vrrk8aLS4IZd8wcIDq3$*AK5XplIASQ+*mU1c
z&CsxtHZY(R^lT!apC22QXO(eFNPgd-AHc14n>2f#t5pD|C&B*ca-#M41XDcI7y6C$
ztys&=9p5`1i12?9zW>B4aaa3kU<B@gThv@Eekh@3A3}wv13%H>45&ZGC+6m;DRQ7A
z)xznaMSDdKVE~-&_hc6c1PRY@@`?*14ze_6)R1w|I{%Yp{sVP8J`mptIVt@=|DJ~g
z=p%YKATEYL=>9Ef2L9`X$j``rP3gVN?>?c57>Gz-GGY8?L_|D>{xhcfCjW(*<iGXn
zfArUwFA!AGw<!ewCKm<eF@V69ivLy5@9u-(OTbmF0uyHbz4HeK!S@ajs?-~0Y+%gz
zpIe<j=Zat$dR|FM`11W57Y}W~Ykov!0{b0ZF9_zdLad)(+vi5a$9U{{lN_xU?QGR&
zTzV<f`&$e9DPlrCd>Tocs}VXZ1_RwcaY-jCz(LSTe)@-#@Shx@rq?KdBMf;T7CE=$
z{4JFGG%zqY4!GrxhK4qLqC$v<hCbZ4!=U20P1T})-Ftt}+;BJUC4NvNg*>rfEz>0Y
z@3Gjs7CI7*#jqnDhsAwP1fB`D4qxu4y=p2b&<6ZU8oZWg&4Ga+gzcsn5|lQrvy0!w
z80aAYe|+;`H%`)Z&l~9)3m2CpifSZQa^0kV<q<SkQMyunggy4df5{o#2h6%Fo8~t+
zI+cRSc1go-rb@co@a%Y^O@=ZG0f$rdE*m)(8LO2}1GdI7zqv$PhFDPTq7L)-RAsvO
z3n&<v!DNlu{<8Mm8qO9#H`Bc4X8;uOLZQOL<0A$4>y^8}AlcaPRi<1EmHAC95CiQj
zL#&Oe2f3`QtegX{4iF0Eela8Z%>`&d`}zuP_|qQ6+|*&@dg9^X8G(H0E37B&xSXBi
zCSA0A`VC_<{CfI6m$OpvId~V(-5qUjQz^;u=%KAoZZ?NKjUTpyK|x>>!s7fUqgUwC
zDR)OxJhBFf!Prlq*GF|@CMr7K*p!!->pC9j+IZxAzo@Li!HY7ivp(^D$6_=AUGd?v
z*WXUwL?-pf`|7u127p~V3_g>+X|#SY!EZjz0{I(I$*uB=_KjhqFBk%rMM73R>;}l@
zA?=`l;lNqyyIdmK<2{no>uW<mtWu|PtbUVPYxJEYW|8k{%(G)aY@lAZ1AXhd8IT#u
zlVrYM0Pr(4ZhAi!H?izU@Z-}k8V;%f^|hhDAej8##GBtcn1Z$NL;U-%nG=F1H(GU@
zB^-|zH)5Id1bsI_EsU_p$1GJ?xM&Ql--lSEU04j7gypY97XQ#?{3PM13FPRC{#ttZ
zsPO!@qf6w#3RV$);#c7wuWM|S13CN!(|%d)T~PZB1!tfUC0SxC&G-~om=EXrSBx0m
zT@p~L={eRy!9Zy^y}J2$+L}{QurxLWoChg&)6W@0N;nYUycE(ufoX5#7f`pbeUBzf
z<h5aGHXb1|*sFdomRNvgjqyR`k|Rxd*$~CsMSX^Wa+2@8@cmVTCy4wip2^z(y<x0t
zkbBj}tNkvI&TmM@KacvYy-nN@zwl<Dw5Ks5OkN&c3}cIiscAn5L}wr_#~$tS+TcpL
zvue@B2ME^G_x8C#U}`_(XI->9)00o|GoGEw1vOKBSg^Cz7UZKX4{Gp8T+BWW^SOgY
z?S;p+`wc6)yK%@*GXA01hRq?uu%Ugz*N?@uAhh*sU++>+FNTIsHA5+0Eh<eVHF8Jw
zhv4}oC8r(erp<#`x?b8tTj<Xlx=-^jTpmHkHJ)!_M@o3lnumy7V?|)TNP73v#UZ88
zlv*9SZrH*43#$CG$hrm#8j2Jl9B>RUr4sPWN~t(}$tcQ70IIs|Zky7iyt&$3^CgoC
z4Oniq!kmsY7`KzT^n`pnFN}Lb6DbR4=p%Z1#F~fDVF6PsRPAR~02k4ZZXzwDUGO<T
z)QkuriVX-e-j6eL*|A9jC!8^$^7>PmO2JPTX_*!U9iIdXfmitW(~qM~MbKROwiZtx
z{+QbR;d!NMg54H*8a$N3Td@3Hsv2S`i9m~xul8_N)T@P{G*8I;JrL0s^fYWLaiq<v
zosD929FNJa(c`Y;#ky}<%eZi3b5qpE2ilai!S!>lZYD-@;W_te(z-_FwbpT-zpO`2
z65GCJpckE&9m1AbpT}LzBN0(iT}9AtEt@Ta3+fbYeQJGduT)fX`Y=A>YSrsg%rn#1
zWy^Y5Lq_%?TYf>G%h@nack3Hu6cujH@D+TXMEFY+5b^BO>NX3p{pY-Z5??T7#YG`<
z%Iv}XtX!>8d0c@)j}XO|fX*@%T}`zQ9i-(TtZE@_nQKNjF2%PkS*ct=)W6L@bWMf)
zV~a=OiiTE5DcCn%*Jo4hKEy#ad;jf?Ul9Oz5#l#nT^&s|i^F`L5~15BixvJ(>^3~q
zOkE0F@seNVqY4?CrG5S6rv|ypR4^Z|&G_KjRJ|5Qjx7W3+_WttJrD9Be;(PzP)D1F
zJANGYhYQCk3@(d>92Se7SBC}C6u>glDSVXfmHX4XaQFA8T2$y&_CLCa=;z7E5M=1p
z8a_KsjEyXVT?G9Nd)X-yR8oqf8_~?s<6yB(@A@LL`yaq;C$D^V@;Ez-F)=rB&uU~O
zKE`Y3%bv8JP4H+Uz<dpnj4Whqlok@|D2h8=s(ib0d*V`V$^*vvy(7~gR21!%8Geuw
zGzSI{*TQs-urXVn<VQw_zpuNH7}3?J+i|(=Z6%7n=697t!e24t6nKAtfWu>6@V8iV
z3?0hYFq8wqp!<icKkwh{<0yR5gd=pB{PqRUF#q7Md&K-CC<L!;>PFWlAcR+9f!NRi
zP^EN$E2M=0vlI13utSK<Dh?QNw4V)_&Cx}oDGl?ShK7k22_O-G;397bzzLtt@vQD{
z6E=M9OW3D0TV3j#?yj;bERHE@82Y0C-*_<Tn2(0G<$g}VW-D6yZvZOb);)B|8($`6
zBd_b5m0(Oq|DE-`v<kXv6pb&CcT<w5ZG3Mmo>$0!IYe2dg`gDh`i2n3yksr;ZC}uP
z6XZ!9qp~^EKo1QGK=4v6H^vz&0OD^Q(GDrL>(c87TmmQ@VW8mqBRh%3n4?;ll>kKn
zmHh2nlDk)z3z(>bEv{++)$Wz%5y1ppvK^grBGFK=0a5_w+|QqAq!(fU2wj^6L?`;4
zq_h6H&4OCM8)qxJPd|gAn*#5<Ljv5{S=W1T%F19#LQ*`tkVfg-0>tZ(Uo;`B1i*cm
zl@E6#CVUgOnK`BEYP+*|*ORgAGrCv#{rm<_+6vCfx?b0|^~O(p3kA=pcOzgn^zNE~
z&A&_p6+g=iJ%O`41_y~O4^r4$$2@yJ_yT@M=4?3u8#|7hQV^XRH!9q!*?X)*D#~m;
zDW?NfEm1b?fdf|BS$ERyktRh(T;@-t0B{2X%O^_Qw?uA&L=#tzqY{a46ww721a-sF
zpV2`)??9(svkfyibD)r)cR2T=`{_Gny|c_W1o`5KsvYic$fdw_zG)cB@x`U=_nn5f
zM-utPHqXe$$`XD<0@dm)>lPHEcovqXe$f`|ucsD<=n=z9uSEJ9Am4v@khIp(46#?%
ztPYkcjYVB>Ypv6yDLjok6c;v>cKlj2@FK3D;R<vwQ5@2uiT8Rl7G}U-IAdl#yiKhB
zgHS~9%-uT!HG?4<q;Ln=&W&b7W<c{FFy(vYY#Ej7n%v8OGCi+hd%Go;z*^AdIB=q?
zvdyS>6vz}^9gUO1+4s@hVufG0r7|IXmAHP-U)rc+*8r&8l)6u`j24EiG@5LnKU+y6
zs&1So>4fb+cxfVK?po2+-76(xSf{M2+W!M`zQUqccfP{5@nEi@artomH4=|enYQz;
zrKGHMq<Zmkdb(gfb!qfOBuhWPyE6Z+e!{`b!m$ju(})b$ab{)FVdAhcm*Yj<!9t7L
ziu)#?1yPFGB*82>W%ppR^hgZ2A4{=8P+(|uk3UR5e<ZD&lTrW7Fi+KXr3xM9`t}Hc
z$D~*<l>6<y{lLz9yPT`VjF$6^3=&0kg=`Q0>%o9y`q)P|WJiPv;p*u*<B`PI>r^2z
z+0js3sY$sWUXBACdL=cUaom%KSMCPkJJ^S{^_4zg85!*?HY+lxtnAOS?+g~2Txu;B
z_fkPOBTHnnzZykf@Po7ate{KEuGY!}!x9yB-_b>&mb(IDK9W5ToX1x5y=|&pmcYS%
zSX|Z)RQ<p+5AIYvVxk*XLfUNcb^6`JYG}#Md@Rt{l@Og0^x`f0c#J~{c}%JIW=-;b
zVt_U;5M)atU>W*iJQuQE)o9okNOO_%%2Lh8DD$5^-<da3#p{*GIzNw3LBJ!Kell;6
zw@j(FoH=1}`6yRHw}ed=#wcx9V4{}}fqs<YAu~eo?lqD<9>u#tPU0V3d_&U^$lNTd
z4$Dev__5gZ>23Tufuhl)IqQKrnlB;hwwDns6udoBVnc0G6^YSVXp3|4s^_1Sp1GBQ
zNoAz1@ebO`V?G`OU-Qw~cb{j>Zta!_A2%f4rC(k!nh;dN7|qRA3m{GTavbp-$9qJ0
zY8x<D-*bgXV5jSuj6a2As>bczju7TaRxmbQ)x|>wdwpL+`(U*6`P~BfZRO^X)^S|L
z1iIFF-QM<-zzP}qD5nYpBxJIjxR|JflzC+G_Y^fr*(J5Z{BI9dIs6H`XKiVo3^)m9
zaw;l~<_E7OR+G<1qZ_z`mRv8F?PQWR7E=x1+z(2>OpWc@fD*oppQE-&+8*W8I%;0e
zkb}j>#yu1?ewwxyZB|D4Qkb1OxMNGUQBlYcxwnT~FCSt{74=0&!$CX&@H(RpOFf+e
zhB!?EeKb56?-6$_9_3n2E@;nwGzKAVH}ahOSun)n*)$G}S$&d;&P%7bB+$G&jXT>Q
z8^s%`rBVV6!z)d;3abFjd(hUEwvC?2LY1xEu?NQjmIg4wL4%_8p&MOp^Vjpy=}<@}
z#}P{YvY#{)K<L~gBt3#)(*cR@HV9B(ZK^G_nA&939yOB=h_a6nPWF7obIS8w<aW+%
zKv<Pr3Y4KqW{5EHPVHeE^>IYe6=xqT?)S9wg!P4N6Sg727g~883K5bIz6x3f+g8|_
zX}m9t!@?xuNDlk@m3gC|cvaTtJq<fO3^-?~w5<N~`V#(a^&1>eT~C>TY($|vZ6uHJ
zRy_j5#}ay$6R)Tnos`NLK9^fmu49aCVz5P*dnfi8Wh+?Unu+SD7n?D7$ehsNoVvNH
zXI@8p!kK$clsexJ_0xT^@%_LK78TL&*E{zPgLpmh^Q>H=Fvoe#JoMf<#@!<z!N;2D
zJtZljczbl3XP!qrKU8`|OqMT5wyB_aD~T2pH_I0^Jw2Ugs-oG@=fii)Kb}8p!+_T{
z$Xya)qHgU)4_4&rxpvXOwY6kwZa$W86QW(Nr0fRoqH6(b#~1&4^^od(`o8{R;3a{4
z#4!vwP|2t5G`K1E7VK)ne6e)#sOg;?pH-EIZ7m@(_R=WuAX_kV@o*|#=Q%TW&tBJ(
zv-`lXo$hjy2sBKT%x$h;hOF8qA(Co6XoF%~=t4q<qjvbFO`O%Ul_o<APkMVPd8TdY
zu&2DT*#RfB#bZ`e7{$BTeO}FG@H;(icFPJWa5rQmAyhgrL@sYLFQng=uBY;-A16-J
zQ9h|^!e7v#+O~UlHGNFA6b_NO1W0j+Cg0p9Wasz0#9XN2t&u}46MxKOQb4kxogkuy
zi;R5jB{}X0#aXPEGpBl@CS0eWHUE^ZYSZ4Zb*Od_fQdOpEx<Kd=j*Dg;Y~M>N>fh(
zj+S|dGA58A2SYiduC`R$T9dQR8W24gAN;y=m!Q7A;)Bg+4ApoF{w7_EN>#CJRcWc{
zZiUjEA&t&~jhfwC|H)U?lo~Ow81Bz}i+!N>Rt^`HE~jsc9<Jm!R2#AK(&4led7v;<
z5{pMr+e0G1L(_dW_kjuB1<|e>Jv=+UDof$f!mG66fU4ea$7)O_TT@<ME4X@e*#XKw
z$jk)br)NyWL6a<s7t&{;o6<9>ejm;_`oE3~Q}8yqC^l=3d-aw19BR7g77uwH?AUT8
zddP(04~&x@3z0Y5BnIQNYRf!BzKhy_e%OFyxh}HEmLzGEXa(FQH2jH&17Jj@;dTvQ
z1<+|k!&q1bgOQi+>mz(u%LCUwBP%HA?J#W@Q<|3--Q0MkwTRDa=}n%?_Dt3e0_l}J
z|9Ew_26{GVtkMGEvEv!JXuG`$KsJ>25N^)S$?cmvCA$QJX8&;)yI2}Cj8|hedh9LU
z%i(fn>T>WctuZHTSIMU4Xzk=&Pn#-kSfFvxYHMSo-ze@ObMWv}Hn`s76Ll61E2T#M
z9{pux^|klqeQIpP>pdRBH0%0D?)kDFzBHVB$3=TfqU3DH7xU#twd^~)7>C#NZ%Vkv
z?03GtWqB^BKO5O6s>;=99$CrkWT7-GOFbrvqSQK{OA&_s@vF&^wsi<Cr=p0pNOwt@
zz7tcuU78-3w*{4%kz4h#uhSBj<k!{}v(uT>j8Z1*#wU%orlc><Mq?Sn9g<@A0k^kX
zuZhHh!;=JBwC73;A!SEhB`_$&z_wu3-}h?x;*+pA+c;ggo^usf7J;aEb<3eha*%2C
zYC1}O2{Q}^HZFyqAP0Q(bbNNniah^3E(K$0V69w%)AVIM*}z7veWJj<xzR%`1o+6T
z>S3+?pp$qXBvJM})^0C6>ZRQ|4zyyrY_JWz4)6D_k9YEE*?ntP@BCS`j7{xA9DJWs
z*V}7IbDgSLS{LTq`17v_HInHr7ognkKMhVn)Z5yfV=|hneJ*^O2DL~f_12_-%@D#x
z-LJ?;;Re|X$7ys9ZUC{YbhS>sE9IV18VuEpl(BnpbzZ>;xtDshxmQDH@4L4>f;pLc
z6-c!|_8{2XpEkEa(N3Tn1pzC-(1G;sf((&%vf`F+)(bahogUu)40~o~B+Vof=$tP-
zG#<vcuW~O8sym*~fm=<O%c+v53?Ezs;>n(M$|On+yqN3`KJpb(c7ZNC?+uTS9$gb2
z+rPvm)7o#RF@Av-z3R3iEPb|)dbm;x!}dkBZa#;pSGO39oeKQ1j02~jqC%z;Gp*V?
ztLrLmZXxIHZ@K>N*i%!myE9Bc9}%uB2ISg%c~+SAv=V#S=VoXa|M^S3$+SJaXM5tr
z1lrPsv6R%l7l;oclYMUxl-BV;TL0Lir_p-<26UPm5)nYyEDy4#tMu|0u>jphlCFbr
zwH}Y0pG|+Dxg34-!fUwe)bpZ8rwW@K+|rvo6$I-At(pdaOq*?gz5e7RUGQrBF;h2H
z=J5_;8WTD+yr96YIf<ZgcJQL#{<2<Zuj_`{WFV4pWnzC0NeoFq)_AmOA~vQ5z$Zl6
zIR=^G1nG}>T)PaL2^<tOG+x7o9WY0`kQyXQ?tLRPos=YQO?P3b;^tCVR0L)ZZbh>u
z%fZ6b@V=eTXMu)uR#**6iC{S|Cpp_O=?AQ9-cg)&STs;IeHkGV@CI9TU{>A~wo|d-
zu<|Uhrouy-rge!fj7~DvtJoB{5&I2miOX6=PJ3xLF_?<eY`K2@{vpD<s3R>Yfho%C
z#nO)F<tL_h?a-lb!S-C)YaC#c7WeSfsG{zic*B8fz{~Bfd2j&JRuDE?wTxygz~0C0
z7;{{*feokdp82R@Y~Hp=qrM#lDt#fp)Fxbj?<78>KYD5_<_wXlYUmZ#3hAt#qgxR0
zeNPRu`UknBPc~^IiG0KSg+zsdQ1{bK_V%IG*ih*VnirrPyTKSIN7D*hN!xtho1kY_
zDDb=*UFW@5`T5pQ2mzlRk3rt|$G1`1u1A+=r6zjzI8f<5d5-UHmKljqgK}KNL*A1m
zs!^&rNGy{9C>POX*g@LTi8Npb(ezr4D-TxQYrpaeudxWIo#3~ML+AxSbj(XFW$iiq
zs_%}1@7@X!NNzgxfL0|Sz_~lbf3>jEN0)pxxA<X!W0_N2_E4nkdG$@FPB6Y_1C-gz
zvc=qX$euoYE4gHI;hZZd@HssjFJ8k{bqhgXkNKWrS^$DrY3U>DEoRI(j9@UkP+xfu
zDFjp-kee;);g1S@pjJ!B>*IV!gwl&4LhMZj@51<kt-A79MdJqxWtK~1re*?vEnC~}
zUJvDZ;9ag+)YkPTEZ6kD#M>yHB=9F$O?|->d^&^!33UI4^B&B77ptdA-jj@df|r&t
zPkGSr?w{PwMW((zz7~Z>uHsO!D7+T9b`Wwabkb_hBVOlI=9CdSJP=HEInZNZ9OjCo
zeYF{bMrfM}`YN#=3U!5*|84hB5(v;Fn{#xBz^R_dd%DCLn}$Y5v3cU6ll66=Tbm#2
zET=L)wiiA-P@9b$Ewza2S?N8l3*%4+9Z4KEi@$;jx93y?Rks`O^)p*9RB7>RHE7B#
zghJ`aVoLi}fBW*Xb;n$3X1~&&x3xN|(C2RN+GMcjaAuWIjZ%-{Q49csv(u!Gqh9Z;
z+Dx1;yOga8(0h$yG2RK4H2hHX;A9<5c`YsQq&QmZpkT%fGr{#FR_nm`>%~($vJjmx
zX|H*%EtwEpmbXfc1Y5U67a$>h4M&Rh4S!@}UAR8pA-#%9Yh?$;5POe>f8=tzb8psh
z0Ps`dq#AdF1Lp2ZFfeK=Ns+h8)aS}S^Ar6w6V|d;F?q#Q{>V6`vkgxJdi`22(;~^Z
zhS9%FD&7rFpC8ZcV<SCb`Fx-z^AkiyQBbl)C!>!fH28@<07uuV-&4g?1rv43l*h;!
zl!QgTJs+d(<mywCB>2@*z&yCGqHtpCN5mS~ex2njFQ*^x>Yd&<Y?$%9_{5ff+w;TG
zz{d0<DnWRly02`@t-9JwfJ0;YoFgUAUaG*h;(M{D^l@qFH*^ONd1;@g9zi5&;aRe|
zsex<YZdv*jb5T)yVnKa{dq1v@4q=K)FQUU3l2Bk+DK74Xpm#dvf^yW-G%fLJ7hj>|
z5%R<C_SszLsFaFPZ>otj$MtkY41G%E!#cFTy$8#rQSZ#Mf5p+j|7-2Mqv6`${f`g?
zDH0M9At$;ZB#2J5=s^%>#*nDPAOulI$w||R7F`f^)X@!&=+O;g^xk_n<!;~e``-1t
z>wNE8l6B{=S!-s`?EUOdeV+I0y}1Kq@O>O5(0A-M)xxo>1Ws|8$gnWe(**u-PYA2v
zXDAN$s=Taj8{3&?QY!=yB~~+4{QNS-tBopj3w^@6bVuv$S&5nkKDC)m>*Jm?3JPp;
zUXQ_nE|A15TkG*~g+w=8u&YaOZgICP^zOmvUREqFnDnXV!HobT2t=Lf%=Mx%jub|a
zVIVRF&@V!ASV#xDNQ8Pj0|hU!Jk;V0PUZj-R6mS2O6DAFcf>m*ps{yXMEQpb)>{3H
zdk)fe>?1xn&P+E}AJ|84f9eZ)h*_#)NhZZEAuD=JOxvzId^&y_r@_VfoFewzTvZ2x
zM?^$l*Vu$Re5#0^{sq_uOE~V+oq7B8#QD};pt!UZ7v<FQLy9TvDRzB5;2fBe%&Ua!
zv5&-E?Rc<P8jr{lp~?1=stu~nu9Ldgpzl&l@Oy>1r<4Y}&?;#)tu<^7bHil%O?M*K
zNuDIVoeVv1E(&ubW&>x`FT<A%bCq>DhVl+ii7hPLY#(Xg4YsX|gsq&cc2UZgibNw5
z1l@*7*&e2>%-j<!uy%P81!KT{zN&9mm&y;h%*1e~e9S#SBT?K4sJrxf@?%g@<%9D{
ziAKUN2A+cS<D}qe2{JDJE)j%%{%Z5JoZ#a1YE50EUYt=sU-_#Zpv0KLVZlGh%WFOU
z=VSfiwNE|M6!tQyU}Ob>zH;{y4adVge789J!|z{#!Zo_nWFi6BiVp-xzOHw-;=rEk
zbf!wzA>|!^q92t{6wOLuVu+pHKujO-3QMFZG}1aB(z)V-?Hyk7n#xn0JG)3|vsBKv
z>;+NK9#Pylmi6&)Sp>*oAK_LGc2_W9DO5Z0k^muluV(Fg5YJ9};bQFSSe??dL~U8b
zm}`#SMn5N%{hYAM4WxcxlOQ0CRfywy0PlXYXTBjb>guAI;Z<?S5$8GH>2cq8n(E?3
z6nfR>LSTrxky7~X%7Y)qc`{xomn0D6C)y$8inTgh&nP>wYTfib8HpWS;@(3$zA~*Y
zVt3A)$}QTL_3A(#QiJKanRj-(2xDa4=yd^YpYY*%a)Nf5a$D2OK#Mn@wyGoPEy6!%
z>56ZBzS?W}r!iaoi~RLKzG)EH4-v+w*n^p!XlTM;VkCD#sfU802DS;MtW4KN=6u>a
zg5VOOi!~emFN3chRqk|0f;K7|Hs6oBXuixIo8E7}YP_C$Lf|YwY}TOpd~;F=cfw;6
zOuai}MKB(kz{8=v4%fdGZ{{lvdU+E1Q#5Pf{35EJ8#O2c2{$A$MZ<mi&-Wbndn(Q;
zdK%k0kSKeOq-kNv(8qWk;Y#rq5V<bVb(uQ5I9QHEL|GkDd-y&9ko{QKKYo+4B~~#o
zC050C<No=x)NlT!8o5Pb45}Y0Lca9*!J}6iMTk*Vve@Cpom{kwjIx!9;)xXK$<39S
z@5X=3Gbw+DHaQA^D2kG?(yr^7V&mpk1eA0Ew72g!PX)E6aS)5vl_y{Sr9c5x^Qg+C
zJJ*M6O+sc@Bl!d>6#xwY*d*-_Z4;lBE0u&#(4~bHDzYB_N1N#SiGoL~*T_w6HX|FA
z{34+C(bGBe$xNsV=ov*^^!g-pqPasJ-bD255*Oelsn^$)ypSN0r;$k~5K}$TR)}2O
z$VtjyRVlD+UmMXn7n5jw55|Bn<Ppd-LB>7fUI^iiiboy)$<R4dj?tznC}%OA2#q@b
z+>Q7CwX$#<;5o4Sn%4{yW3R!WgI7b;ZGkahP4|uOEBc(VY*$uMk*aZ?v@tqs1}?4J
z3&K<>d8J^rz>f5+EX8;`Y)whyF!k46h6>P%3Ix&FRNkh5sMbDziMi)RnEc}x38PLY
zC}B<P$H^|%@gd{LV{r$q-66`UX*OPoK8wq8nlAa*7_S+*2^B);ycRz+jG;k(fo3Om
z;isMX+y+l19(1yaflb7h>FVk2IGCysDYf1LBYRw<!)uVY^O-pczj4kK&iQVc6`1?R
zSHz8XgwAE9i0Bb0^aCXE84Xb@=@Ce{?|fT?;6zvr?pC8nzQq6vrgN~<RjHhIcP1gn
zr=0NMXC&%p_GlzU*8{NhPiD9zHK1o|m4$jg@ki;G0+Y6C&i*H=&@$zKTaQW=LgrYC
zOs+E0r$Ryc5G1R!udf)zJI<k29vjT@<(sI=J#C*Pc2>I(*UB#hio5E7gcw}w1ENgc
z2)eeXi%)n^qoJH(2vq!xzp3J2x<sg8XY@|;ZFXL&)Qt2@f^3PD4q;0_Ex~NeC<Uwx
zo9X_Le>Jkv0@#Rd_b92%?Tei}5^;M%<5Z{(a(+B}5U9HbBtG-Np0M`Zd&0E*{KCCq
z2L{crxO`t$x^I6wVT}Y}U+~4Hx(<`5Fk*iFTCqPQ^}_jz6_vX1!p*0Zi+wxht8c?2
ze%6I5D!#*FBwl6tQ#_NauS@doTmn1rR7?%>(Mgg5;OcDA`{XDG^z*rG#@qN7h10=4
zW<g5l5kSXo{}p(tDr4z^R-MTJe$0Ic<J5`j3{Odf<DT22!H*WYx=hwlD~E(PAu`WS
z#;o~{;^T?#CQt`jDchBipjLK;C|u49g`~6VQn|j?hxvWAI1JlLW3(yfKou^&Pe!wg
zfnAdOzvF{SNw*tq5q#p6Cl>vK3?nYg-(S3{ZM6b?fP-$ys5S?G;T7sdE<Cv{RihqV
za9BU+QeG?8{cyQVV5v1q4p_XIvy9q%izkHwdZV76c{$(WZTc48*(;l$e2tAJWbhWM
z#a=ZWBj{GgQQ3yQ(Dc-Zz#qt$4QVE2>6{z6QFu%>|DWeYKV5kERGtdXAyVYiH14>f
zjuDCfGW+As+;&NvJH12s2ocDPeeB;3sU}+$AD3cusm+<mU8-QDda4KIYM8&;a3$bn
z;yJD=ET_~T8oK?Fd-l1xIdg-#8)aIXgETA`{R0ASsf~0Q7(8nO5sj?9vqxZaxLo^+
zXI*t~qGLNdB_I8W6U#NEB-2O|)oFQ3ykB)PcwzxipdN8E@{e_EUWTjee54klzjkdh
zTBg)j({>pv_LCpp+^ke-0UrBFHNn~qd;k7D>ZjjNfy*grH94Kf`wZt>_An)MBVA;a
z>OhV08?^Q8viLFXo)rG*qc$rD)NTlq77r9Tw>O4ZqXWC^jE=2B9IJ9mKNChCujA){
zvTS5~jxG;BU!TdJ(;E)a+;9vr>%${>_|)J6E)QD@Mjy^YZ0ul;u!;WD!Pt11ZcRJc
zD>XH0eO&af9&sk}Rr2E|X0Cli6>3lQFd!1Pid@H~8v7B;hECccR;)2ct_@VM1>dgp
zV`bTuu5&;I?embm1Y4ZzfrujWPR@lHwT+`W%QZ^SE`+@AD}UnB;L6aUE$QX;C)G5U
z+7{F02Qwr7dV#9HfXH@OCCFNrc{1JS?sv8Jo+xxx&y^<uR=@dJ{0)I+#mv%ljU>-)
z3wPq0_H43)bOz-)avS;cy!TVk<DQ&}6)gCO%@6b42vr>$;JD?q*x_-pBS@Xm#kU)w
zR<h&`cN*v~UrtfFR86Q3Pl({=tmcQQ1*&7E*&>rw`~INcJw6F^R;1W?EsEcBa8tE@
z{$Xl6QF6bdq`L+V>@Ln&we^)VBp)C@?!=<k)UM{6fFOE2G~>i-jkwo-fLOg{&P!ev
z&hT@y(0WCk;(RF=#zvCLYx`&JI|$W?bE4!5APLaYyj03??Z!QY^CA5pWI=iBac9S#
z6eSfvN4JhjH5AInYZP#{lz)!6%P)-7ZZQzG&*ldm@#Rj_`H={jK|pcPV8m3j_0dt@
zOql>XPoGP?Qk13lfv@7)IOl%uXB4Gz=y4zO-n6_<RGm4YfH>)^Tpna@OOTPiEGIH7
zE1|i6jm1?Rn`on`SyQeZ#Spb`^le6RqZX5$$4AlPw8L)OO$rDyQ^qyyz(KPtf;~I6
zOZ7l?{id^KzR+RImW+>MXVai+SIAt_j{;CRWZd(>nV+nGV9x$t^wox&4(Oui?UEJr
z)wx~HPTOFHgGFJqY?8MWEP`0mAsFUnLaet?85(!0OqCM*cC-;b^)^sL**xvgwt=K9
z-6y^}!ZO+IUH{xU%Ji#Llj)Do+H2&ruRo=MA)n)m%vn1loHM&)-X4|;&>c-qL5g=f
z%F|O8pT~?WEjN*qz1A;OA3CuyESGYY0O(5l%6)mb#qhi;gt^@7ZgB8=Tn#oO)mez_
zOTC}JT+!Nv6oVK;zU>VO#?`)g0*w<Sx|&zxWAPJ<eARXs4w5+7p`5{Vj>dQy1i8<a
zYH*R^Jd6*My8-F2d6V<XkQ8-Xm%BS^NWDFoFz;D)F#6KzC=idela<QSIbFACmwQ-Y
zb`z%Mq}desC8P~#x`tmr8o=<ERof}7YgNvF-q}6=_APW5##SGaU%gk96`(VdP`*>7
ze?!LULzbauKi~pku`<sBH_%p97ari@y(c>Bsh3%mqYPz`x+6610oFHKdrf0DmFk3{
zi;;-(tV$^?e0KY|k;Z<_5`WB+W`d3d<{CnFuAJ||IIeYR!uigKJ*l3hhA{0U2El)S
z7SxfDB--xiF{U$tqh-F_de$m1n<<y$WRI5n7Uq4r_OU6G?7Rk(uys%@&Nw+2R$YTc
zDwnO}v<4lH)o4hplVo9%8^H(jO!MQ5V=X5&OUoy-Tw-_~<<QuBek1L~vTICN_yF-7
zKpWw>sA+-=83OrlDhW=KkP6bQ{-6^In%rW&6}}rQp%C}wkkB4Xx!1PvE|TATT~g4H
zaiY>Nsdl+AsQY#8my^xUH;)>XROt9iMN{#A+Fop1I9Lsz=o05;Dry!Qxfv&!sn{i%
zF%XSfcPz~OQ=brH7a9>jA@4C}&i`g=CV4Hgh^cv!9Q5avY|QrC`I5sfX(!^*_{q7j
zs0k@ckunv5wrEv6A4=A|EZh}WTagKNy>_cd@L8k|MpS%U4M-d5I@pZ2-Qf^XT|dNx
ze(#>*6s(+n?7qu-3FR3JjD>Rr-8hqR=>C^12zgrC-9)5*ZniA$5Kqs9!C@h>Q1-n&
zE`u*_RVml6-I5)w$*KLhDi|vL4G-_*#ACl*`TDM%nYD&3B)1JaG*#h7wTa)tIe!ZI
z7;$~#&EtWCw&(%3<&1J767PAx-hiF*fVBv{>o0mS(>$ox_SU`5sL@a3l{6oHuAUv0
zoxJ1M_|tQ?j<t@v8@D4i7=<6Q$31r4I57cqV1ZvYp%4g9Wy__ukg*kuy{e32>m|f&
z_VtY@4rmsHq(+Q#AiQx;cPIqa>Z!=~h+FZLLGG#?0zqLJ#LP_Ptphjw^Jv5gdSIX`
z$$T}Ow2zw%PUUszT{<e2A?JTiYgP9OLm!(1(Yh|HZGJ?6m!4^qd+SQ{MQ!2o&O5AM
zHFFTl+q^bC23vx8_tjlheNkgUHv-v}jcLE?<>C>D?~lZPqWxhH>g!Yi9e|}b=DCJ$
z3d;SN?F070-l`J63&w@oz?64QU7_RZ2<zc}eUrLMcQP+U#{j9X6oOf0zy`v4Vvdu#
z*Y3q*X2rGGo~scamgSn=L&<Sf3oY}kMHe;4ay{&Mv&U}C%Sdi2X0i|=2`II9Ee9oo
zw4#*lt#3(-IUJyp$X$)7?ierr5<w|-2V6~HS9DxSrW&wCbWu9_(CSD{Wu4@hYiKuD
zzgs8gKN-emi_O80d@<(X=ZTz7)761<+R9Uwd6Z=iv`^HE*Wz&T+dUKO{SJ44Vn7YP
zP2FkLI*HuY?^3GS9eR2g?S(!*=N>+a(~e)1VUgad(lPNl?JxQ@hxBB{7G-gYr_#iM
zj<wsZVHIfl+rv0%a2lR7^6Y3qii;m0N;j%I${pm}n=DzS>It|V(q;}5qB5QP(lq!X
z;`T%EJAdD2gI{LdSTiJ4X`f_8`F%tUwjGx#4Kt&t=L-<m7oL?%Q^4qJzZ}XUwWAV7
z%G-IUQmVSxWqrODyf)9Ny<qaR`ntxdA<y0ZoF*ZvN#C*&A}gc#L_GeDej+op?ekx1
zFE>MAk`K@Z!lnB&jVqoSmwj(~LTZz7z?u{fUu@xh`bUq~^xR^qA#BPNWD@;sK!3%`
z%2KN*wD#5J0MsPx1>8U1TQ?W;?LakZxZ;Mw<@%ygDV}@WWd$SaFEN%cocw8-WS#=+
z%|w9CCU|9dZLWV?voGK>0GE42<{ew+n^_YGgfvd!7LM;X{YmaI271+*#it6yjdRr>
zv^aO)+jx#fD|{Fc=Ma!leleX!Cr<*S<Ypl63E$}Zfu7lu2i;t;80%&6KtG_ot4!<Y
zZe*qt*Wq;G%%W4dl#^2s$j7<11>!08F$1mDT`d7njGTgXM~H1q`z3H<CM{_JjaRiG
z*k{)m+9oKb^{$*X)|iFZ9COmPJ$7ZkX;6+#p@Aq&GuYJL+?YD3x`OP&whw5LZoof;
z2bM;ysORG0O#%~8V<th*9e*VX_R?tH(#dx%F&u3u!9Cj&B+RON%e3<O3K0Uo1(V9p
z;N>@+Dq#uV?iV{LHR$v}Hurge;G#Wh6e90zOHWSJJa4ymVk%aG<L{RCjeOM8G``V{
zm5f>1Yi6g5o-OR6@L3ElosnBh@6)X^Bdis_I9iU@QvbSdb~xXGaq6Fw?JwK5A@JK<
zJC0e7Z;`FMJp?S07_p^^fE8PWtnA@isqK?*c1re$g1kjE%L~F`yo%Bq?NjJP&$Rcg
zRtff@u9Kpy`U@w|zOH?dTaF_`<M5~1*LDRRd6l}ut$>k1GvtY3b&%BNjx3<D60kow
ze4+5iTxqG^?lFy<HxJ#&MLme>^-k&jxw%Wktz?0YU*N9&)~|0eOYHt7n%U$^O!3NZ
z`J9f9NElE7Hs9>*>|kDA^^Cl{C;R5`@SJ5Q=*;FY{$lGb8+bMF&;%!^1J68GsQsHK
zy1}%X*;i0^<!VKFOeje5#4mHczi>{nvrijj1VzOFxh_CJr_(><jB>ric-|&*Ga$XW
zujmaYN}=Jy01VJ}aJ3o7^V$RocbLJ0U<t4n2t%K1FB_LFVl7ilU^4FTTGiq}GR3vq
zj_DOU7YF_JH;IQf+6&=vvQg=U&sUy^-NJGppa*3`D*3J?H^g3jre%?7tzwqbF)PYa
zT}k%dj>=+Km5hAc_}CnmUNp#ZK0=QkB}W#B$`3GlZ*dS(>*Pob?|O)xDWImNjux6x
zX)n|}ukN9o^Et-wiG7z)ZiW*_q8FJLLh3*xQkUMmIWJq-^r`Gmly_(z4i>D(rs?TH
z>>YL&7We*)f*HXxMr&8M1SrYw9Ut;6#oLTBSYgY&oiGdsD61y}{{i5A?HAWC*h?UO
zLta<v;d9@b+$oqS*&pwz_vbY6qJ8~Od8hqlDq30>1-^&9*i$DExOUK%t1$qdY4yLl
zL$=0v<7Ny`U6NO=2@yTlt!A&}m$dLNApl^~^y-ez_V7=)B|4c}dp|p=GEleMzUfZ1
z+xPT87FPReD&5o#49XzX@2UQ==#s;p;&E_Ax__qk>REt~Din$iP-g4i3YOphb+EL)
zso|8oQF67O^7n(1i?7V5<p8}ku8@q3taOaJxdIgvF|GTv5*`Y|rVEjK<kUZh#{`<f
z%W2#)-n~0-R1N!D{lyl=g1Rb)n*09A!-zxNo|-K7%?J-r5RDgI|AQ(8!_}br&y)FI
zBo9?kAU^A2-&BAjCes;DE!DX8@O!24@sHdSq&7FZ$0Y6rHvMtEvtlG4-gkpcT7Pni
z>-J??*_q`72+K++5)A?*CrhvgaFe>f&CN1t1QYD7k$~gDI<fP?JK<mOiJ0_0H8>#B
z-uQoe4QaJ{?NLddDwVNY0rDx#<T$+MSWlo;)f3f^F<-tI*KRo&+C{9c&iq?Cf2ONm
zWCHHWZqPzK_uupA;%8su+T>F@vO;|_I-WR*%(SLFJCG&C4KQ4kuWWAqeTX(q9t5R>
zjB|^R?IhT*<e<?FaCq-!GHJ-<C-L$pPpk_;@8b|PJ^5?BH_lw*0l=NpfB8z~{`VDn
z#L1cY=m;_kH7cbnPyv==fga&!UlafsB)jRdW`ITBKU?$J_TGn80F;U*P)`!hJ_G)b
z_U93GYId~zO6d8SZrMN8XwXydupwE}QQ2Pz;{S)3$`#N9SgfJ6!1>=K87EhOR&;pG
z<$Lm*rd^Brr_C^@rOEU+W9S6|h;S&8+>!X3x3N|Y==vsm6*unvUJQK;PW_8kl1bKo
zmtQml3<r90Z(k4iP1~?dms8_2{MCB=Zvxu8yr+aXX68lVZ^jTU0QAcO1X%^*_ZqUF
z2?s!!7kGeae-lEj9|9JZn|s<M2ft}t){}cWRqBTZHvFD*4AuX^VBlM67+m(At_(3T
z<<wpXKwsV662gHQS~7Ut-o?;9yNh9fBTV~nxE{Ndlrh;4KfrZFPy~f3wwkass&p*^
zoO@g=AOim!CC+qD9vz(q;QIp>(Zgq_oD)3*lT}4kc6N57A4%Is@7d*!_2^Se5D<Z2
z2_!tiioRyH-{6-s1-NVT#setRa@c=Zx}0S+-joI!-w6H(K96rd*}WM|jp1CZzMC!Q
z&y1`w97rb)MvS~N-8VA))TGM?a?P{P=Uq6<&;ExnXgT=}TBRh<icO4T13zkofspQU
zWak2~o~qT$5TOmLcWk}@^Y^ow=qc`K9g`)a5*lka%wr1d{yUQLHZn5Hav*DZzh~zn
zH#rOV(xtF;Km0>#1SqiW_uf<0X6XrGOvqJKX;SwBf13JU%__qO6gT@j3;>ANzV673
z`oe{x=<GyN&Y*Z6J_AJF(3u6B|6`T`n4xlV4YW)3dL<VB-nDh70H;N$tMzmb&iyn)
z0zAV=RU$5KzW3(x)gr1-9BSUZpBVEFNp!LxE<cr0s|hUr)r><*Z(-M!<cqU<>~l)h
zK;RF?7xv`yG1ifBqYo2pl<gmDIpqzf{Pp1=QqyO`xodWGM;v=JcUxxLvZ6PM2tvHZ
zMhbEypWtvG)2Z2#6RKsH(N&J3M&&LqR3a$I$f+)~$@!9yp7jlPw67Rh-V|Cg(RI<a
zdMZ9}p>ZoxrE&Miz)hLGA@wpT-0R}Wfu%O~1+&+)A@{dh0pC{>5UXhL#C0SXFTiyD
z7ypk<F69Q<P0~Tf?wA7b1qT+1%kvIkXyY<guyO&}X_kVxFYu$-(z;Wtr3Sp}14nR2
zsdWeud~m%iQ(tE`zUTeY#hrfHZ<^|Jpz{F2wGWX?&4&0?6uvcUCg4qUiP+g3j<)*i
zu({fSshjfMdokQnh5T8=_TQ&*NTjhQUu<9zyZN;ZX^1$w(-shb+1&1uesvFVw_!P1
z8E)?K?CO7i{fuwq{Ky}Y?M@cIXMWj+G#XUfUMX0m^Y)HvD$@GKGA`+QKd!)FMV0Z_
zWB&+<y@%t_-mzn`t>{qD5y6x7!X=seS9WGwHr{!mv1`pm4Sp^~2EW#bfU5!?XL5SR
z=oM7y6;n|VjGQ~B!)z$`Wcn)pu)lmNP*4`~L(IW-`b|b3t1ZQuo9DmdbxmFFuH2>d
z>N?@D)hZkZaUt3J?z3D}Qzed$L`Bw15(!!q`0kO-jlUE4t3812DLH8{iFC!B9WrWF
z;^6?*%daz2+4+()hi!VSZ!LGqWBI)K97vx(Z;dCbdZi`*3!Urlvv0bRb!{Pwm>5}R
zS-^2gkJ*^j<c+->cT_Z?gNTaD-fW9&GuN!F=_~2A@8)tQ`}NqUn9gD6n#7&EwMXnS
zf=RGRZ-ned9j&~O2caxME+)H%=Od)Vk~xh29n3S|T%hlqHg1S^H}1=7RTcGQi8I$<
t-Fh*RN6IhR+l&S^ihpIO`FAu9S$dV?!4DEsT}gnKs*;u>^0BG^e*ut**W>^I

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/7-break.png b/docs/static/img/debugger/7-break.png
new file mode 100644
index 0000000000000000000000000000000000000000..aca5121d722eba6a117f9400ec310103eb6e0f0f
GIT binary patch
literal 627627
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%0Ax8}n@Ew`;uF_+XO%=RSXbNiYt*TENV4
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%0DVm6x5+LM`j
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

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/debugger-intro.gif b/docs/static/img/debugger/debugger-intro.gif
new file mode 100644
index 0000000000000000000000000000000000000000..06e3b8535551d67458902c47df27ab4eb4f9f605
GIT binary patch
literal 1260930
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%0A1kgI|Ufi<s&je|P@d%gMJS@RPAQ{?sik3IFb
zVskbnd0uD}h=OmZ1>XamMt^wf6Et?3OEFqWG_q*^`E39Op@GCJ2bK#4?5i<>OtKWP
z3l;8>q>v@|CCOxwr3w<HO422=W92fVC4m$wD_ZL5HGZIgdOaqvahrE_l<(yz|Eo~}
zpa^odwy-j^0HPzJxv{vI8^O%%QlpB25%Fw|Dv;;^3(|H?i?iUTX2z)z3R>G7<fJ_0
zW!!#(K0ti134k>KAU=S8uo3|D2P*+s2L8jz&#*<HkS&!24~{g)j_%g0pKOn}?%H{*
z@z|d0FH<fp^d#A;R8Op&Ot}$t?%`U0n*H&6uQ$$TOuYWQMaj&{PLR&YFDTr%zo_`Y
zL260qp|bMB6_tNnUyV)8|0~zm+}&e>_kLbqOHY=ct~~phs{*dCx9{Hny1w?xeuMwr
z_4U(X^?&2~+N%G9l#X@6{VN&$xdwv5>U^U6ISzSj`gmJ^mdGw^rSIq0bB$xav_&>&
zDyG`yUoBtQ#aGY3m5yK*^c|!wTuzga>e<(?CW^+K*Q+y-g|gYpG_ExO4M_08qLQ4t
z_rAo#6T;G;nMe>K{6JGG3cIkAt!U<+KbPY?^AL=^|1#{RcD0EJ@8DB=5<%kZTRbOA
zPrChAYZP4aXvC#h@!=1zouMosE&AcG`nR0)UoqfUsNbKZMO(j<(f|ZTkut6AkN(-8
z{iP7SWRa&FGf4fJj6U?p3si6E7E+yl2LWk2iyx_e7jN5r2Z0~eTmMK(Kdq<yy~XMe
zfA(Kf{r;=A2so@xPKUqf>R&$kqWk=Z=ZaD1zbdTu4D<fsuu|vR{lj4eIO&LgyuP+x
z4Mf{r`{mE>{=EB-^Go$az&B=eIUJl{P9H@(*M?ZM4R+AkUaSWWbI+)I0ucCheE|^Y
z<9l`Buh$pf5%RcmneDG!l^@sFcMve;i~I`+eD`O!-n31a(((Zy;F<XH{fuwEa^D^Q
zipW1eAU%9K>c9H4e_dbcbi4j*d1BoF156}{kN4B~_br{&Ohi735R@H#EE{H6zDz%L
zi{Oi;>ZHKkie42zO-D^)UewSZFh9M3{L_8m2H8RKaB~pE2SE<@CX1)Ieoi(pn!wlr
zGYSkPFoM900+R|%Eij0{&;!#6j4Uvbz<~Pq0}u=`Fxh^NK``9FBn0yf3_~#D{yY!=
z!@>1${u*ivhdU4$Ru_7-dv_{Bl+r|e<in)y$7`>)=(O*%F5yDczh>Rd(&^5hvkvd{
zbJh(MdHtAm-BG{&m~{u|K7XHeIX>{*zsx$@z2*NKX5GE}^Z(PV`zNO9A7`EHUl!i~
z-U1<a6k~n}j`>sJ3KB?`)8Nz}-#ySM1GTZHCP@u%4z$ZEs<t5fMP1W=o2E6eUIUe|
zmX<Y0gaO$uK&cEOU_gKih;#u-E+EeZgtma_7BOjO5bpxQSwMOV$Z7!rE+C=>B*K8`
z77*0(Go=NDxu|K_gG?Ea<N|_Pz%QK6HUscG_iw(}|Kvx1k7vhkBk7s{1<y`MLXr79
z)@@~A-KoFuEGIXQSI|O8I`0oW%M{>0{EJO=m0@Z8olUfnlr`qVm`R9r{mcmqm*+&9
zAufQNuxle{QKNrh6G2Yc{X^VR^MFlUI+Ox&Gd%g86Bfq7ffMI^{T<J2pKksmoA{64
z@jrdVf5NlBG=2OE3j2FH5d?+(O-|TjTd5ySAAjV8?RPH#c_V*1YG@{aO}xvWe_0sQ
zCgb_%qvn)c)ZUA<KR10m7LSvBnA)KG`pMr`N&aubGueOP*&kJsf5{tR3ZgvLBmO1w
z=wCtEDhe)uGqJHs18h3b#sf{etwkE>iUrI)!N}a!D&5K=(adzOy#vrzn^{_!TUr4%
zw5zRknx&<=oUFaAb*im(y1fm>#E7h>><-#vRTNz;&6BOIQkCVM<)uhgrYWGi$9Vg9
z%{(v#m=MTzmg!1z&h}P&CB<wNWE^EA?4<>*B_&*}to1=9uB^06fbVWGesdc;Lv=NG
zF)=srssM^&EzQGl!Zw0DCN6}1`no;}3M76(7b9bWg9BlA=pILhXn6^e1Bn1ia%0K)
zVnP-kuJM}_2#}&c%M$B4q_T6DbD&=&!N_8?P0r6Z%gQ39v9ZnF)`y>!*ifXVAnXtx
zmhEYB$k-^@!`0K;Ds1P@G$O%b>psKnUN)<3RDEKgu^BNmIQ6$)IV01c!u-n2%<{1=
zb9d9ctvhHl<Jcho1P`aE#fz$GDP<ZuyUGr=#*o7##4R-xe2jHfqP?UapJOKlq-d$x
zo`{k2@r*UpiKxsW6#3|p4DuY~Gj^ER>#F+u`McpIUDCoet?CjwB4opN2LxU?lC-D5
z$)MuYY5Ku~6{9zAM@6I@aFQq_OR{pg=B8gX*K=`nw6L-<O`Pp=F!9#WH)Ta?UZ@qV
zJW_eAtLw!Ob9v=}g?g=!fvMTPgbpu(N^kJ#;X_SUS-Azt$z(g5y_VW$PPQZ)!=$r^
z_=w4o26jO);rlC6O$=4E52Wl$wv<;Ux&^q%mxpY3Fx4?MQm-%c*wfpx(`7$+HlNIq
zXghY^oqjNPe~Z)6{H@2x)PbWRM-JzNILOQH!r9trMfrJ}dl>8t4RH@Rl%XE5T|IfX
zZHP~8nxl5=t{q{fy1_elMA%!{*qf(OQc|Cvd^3vaZ%U@qFBq4{I%j6nlf)Mf2zkZl
z``JqujGdX7UOqc?qf$h&w%9^9GThtM!cLs9C$cx|`l-7D%szePA=m46^ropu={uRo
ztA}_2FT<nfZ_D#3mS$P=i_g^+tSY}voUGZi_s$6&1<S23Z2wlSkNwEfNrKTu#SHO(
z(`H*^MRvHBEg1Hf7Y(`njsF@!2@i@C-pGAVEqERe%7)x>wOCw7KArkKt5B$<bIfG-
zuMvdLU-&(>;8#>3@vMaR_{N&(nPN#vJ4rBtDyXUv%h!WWJiTzxWbfbdDtksdPXBDP
z{he2-iK+#u1?JYj+H6%nznp*f0?73r-rSy2^=jcz^cLffox1lc&1WJbrl3UcE^~&e
zm|{uks`=4NM~vF<Y(i`aJ`|2y`6b*+F2=tHWt*~M0Iwo*%I7aZ*|X(hk!7L&g)#+T
zrIxCq3^L-cRt~|GrbC-d1;&%;2Mh$0K;)5NndCu(x`hC$<u@Iv5;T9+(jGoTf!|6^
z_2gT~oZh<J<z}KC(*8^tg?ttII|Y^`O_BxN%J3cXtwcrYTyr(|;)mthnJXOu<?)Z6
zg-}w|b)VMf7|OL(<;pNEG^8s$4|UGrzq-<-ocoTdh&<bO)$9n{NqOVS*nN)es_9IW
z4y9fzjt;zs-fVN3;Z{L7HB-GXw9`81tTVHM+1S0#^gCm+-KKMnHN5x5ca`>daSGKQ
z&xGw#I9at%D$=n>PpJ7=LCkQM+gvy^t#&S5e@FkL;E>g(mDU$gaW5|_s>ZC}j5r=W
zet2%>!WZM==fUqkT(39_KVJ5_W{G$8=>SpQhQEnX@jUmb$!AA|hdDn6T6$je{ycdV
za{uDgocBfF=`i=PD`W@$5GC$G_o~&3%VC+eF4t9rmexb$wM{j~8Q!m!Pc|>sXtXGP
z)(R|A%fqhUQiG+tK?_zFp1{NdyAm*wU(oLf3>ee*#u6CkJtnXM+Mc_?Ch=NO&<<r|
zD1K)9>AARx8(L62`<C;WyU1seAMd7A*M7L4cF?Q;VctDf0wcLzS?69*#Tx8>e1*uz
zrNnEbe0D0D4!e^cz_xL>cq@GeilO<X&T==iebR$NZ@WG{+yh!L7t0QLYu|4@R=j!l
z>_?R^&xRj*|A;(FdkaypS*o|)e7^o>6gzy&rqSs2g^w7^wXZ)PG#*OgFK*t*zjR)#
zoBrD3#R~gP82a7J?~zBJIDIpP`iXQnCsoY#M9GI9H_lt)G^E_@L$qO!0g^^XeF~_9
zX|5UFvZ5fwfGb{O!-ykqEt?a!xJ61b;ueHpY6Y;*&p*IKLo?C-p-6E<`dPLgQHB24
zEl{~D-k!x~X)7VZ-5@QdL`uc#9x#Q2DDedvgBXFrtJrS#J~uiK)S#ly@l((r=mOGI
zir@~*D-b^&;@qGxX%dWe1{~9zYZ~T<(L<cRgIIUMAk(*kT+S7>#OP)r(K&YmLu>j$
ziV{qUS$AN$t0bdnyjIeYU}?q4iBg+1<?*Cl6J*Fje}pI^a&p5zB9GEUIV!M)>a%YS
z8<S1A>if6n-KKGtuQ-?*`XU0M0712W8cST8Eg!!+g9^0)nL%JBfS19klQ6w+zS-<6
zzyS;mqCq}7PbUGjz2Gv7EA>)r9|0kalVx)D9l4)Q!7#|dI8uDKSYqE9BLY^Qs)kdt
ztR-SmxKI&hIPMxJb*&CYfH7}8n-CmnsJ}ob606(bB00Z7tm$$b64prFcSH5D{q06E
z3t6s}M0m}vZ2lw|I(&8z-8&BC`p++Wm>XjVtl?7e$<nfKN;9E$m|>|SV;D|cg0tON
z2l8WNb#G*Hk;|MXQL+^Z`q0voIU1TA+3fEAf|CVA*6y7sZZZ#BB6*NEa4}bDiGVPH
z26<0YvUMSP_iFrOrqex0kp&#1VtXc^rk)A+Z5p%U${_zzPmv@2F@G#BS6w}(h?l%Z
z+cg5iNa1tvDX>nBFBFCWN|tC%X5ZoM=B%2j9ur&PB&I&9F&k$!^7a(@RM&PBR)uo~
znNuJ5+<S=JY<>uXDZAG8%3L|jVz%g;cc5%YMS@7UPD`n1cS@0fcxSN;&TxcNJO=ZD
zih(Fif`=hUY$%4+$>|mY1!JK@8O-0l*1%2g&tq*>yCcS8d=cuu%HHY6kd7NX4v!he
zj`e2ilKhyLAp*Xc4qxY3XL&M`DVf)sEd?!L^fo$S1=#%=xCT89dL~~HaUU;skm&*;
zCq$ZN0Tf+K)Jhoj1r-4e!x$A92Km(;(L^PG2Eodh;^;5T{;L~QF+5$^*zX`|)tB+T
zPAq66g3FqCjA@-VF5l&wZKS!lg|1KUmb;B-7IAeumvmEOPx|wDTGmIaC6Q<v*Q0#v
z9Ag(24k>)7Up8Wb&RrP#Dm_k|(Qp<nyy?rZjZ%W)ThQiUV4yc~5eq|22T_(7lwej2
z(jp1Q$-~AVn+Lt1PuU^#*0S<mtYwNeFS4BWj!~*)c^phfKsV$vnTBB$M^h?_O+*+2
zI<ZL9*_m@KVjLBoFpX=*{3BX9Oz&vLyUHktNtp(QPH0K66GDfLXw8p}Mn*H62;IOV
znMcx@xo3TOYpL-9jy(+9=nYIeY269$$Jg=_sT1iprJdZkL)R6SIxe;k?+|~JDF|ir
zsPH3o;-Lb|{SI)gEn2)p>tKEagb++ydB+a<F<BSXEYV!^1q|`ox}8Tj4nXR%c^oWz
zF6-SrGd;)&VfP7ujGA3^|M{F+Mn!r*s%C@1pp%+oThxeh5X&-u*$R_lxy-RVJH$j&
zd7rGP%cYOknD)EHuE;X@!uQ%Sb5=pRa9I<YbeM44<Jr|S*U~vGEA{VJOtJ@oXIUe%
zMoriVBDk`FcaL}fW$lUNx5V=kQI$GZ&V;PzR1yT2%kxZyh1gs*1^M+xP-0TWZ#*lr
z*nfkrX;L_R4Erep3sAl^11xp!o-aF@KZmD%4P!B!c^A?#Hr&@;p+h*G@I?3^-#F2q
z>$=31_{Y!|(-Mu9`0lYth)$m9W+p~=^|8pK$!w;plFJ<xG_;`WAk#k2y|;9Ep{z-^
z{nU(<Nw#4M;x*siw;_R+!P?R!Hlf2v1t|EdY{oVk>q8tRfR@4Fj`-YzS$BhL(HN3&
zWR_D5jaaYW5<+TcvQ#V$(|8%xb+V0dDH8t97N@WobhcF-s~V0&3<oPEFptuiO6l-B
zzRcH=CU+p#(-3Rv0(&dO*5b=7=gZVW%{9lstyZFK$*8gg1}iGcgpN_13=f?|<4ACe
zHOBNwzo=ojHyNo<MTF7Z;wDjyF4~*~<TD)00|NUQEIY*=7DB-kVA*@{h=*!O@|I4t
z+?ul!4K6n6W<zmETgj*Nvz#HY3{fzK<buNff`JbV2l*YhQ5h~{nLH@=ad>29yX6u7
zg4l&ZS`u?Xdx0Ju#j2$%hTE|hLidq(sJa(jZ6``o5$ROq_-v8Y8pFA=Y?e&qZ5<9V
zI!uLJ{BanjrfGudflFf%i*j%k(g8KXfhU#4&CYN|3MA2k9>Bqs@CR`;I0FrS+tMCJ
zgX@#`F+lc$J#fo4f~9Xn!ey8#4WS3Y6(`|(lW-Ub4gwuCAh;fdp?;F`))jO@?crH4
zm!lw4lXN5~5Mx+?G&M;X2Uo<GXi%wP3z&rvZ81Wz#-yM4mTu_|3nZ5n5(FPetR2!W
zgiF$y*vt&J4TFphmZLd4u5FZEbGH|uY!ku4S$ej4n~3}Ra!mDe1~_Z4##sg~nUR|f
zE1b=Pav<(^Fg1c1InctP4YuFZLX*+LBhMm!&e9<S62?^sOTqo5Du^2;<2eYYg{XIj
zD*8{DKYCp8k*gBVLmfv{&B#?;=c*{_Fh3|@ZZKWE=Q6C78>4&DgyeBVRjxdBN?NO3
zBKs=mMw3}|ASAICFFj|5Su<7*td0(>?y0I4#u`fWR1e74cyU)>uByIbRfC}zMaLUm
z5~%(tSv~T}d{Ewk$X_!iP(9gEd+BV=Mz+yxNA1W~a`hwmIxp_pCt)?0J`o>znCx7u
zW2^{To~xb<t9fTt^VX{FePR9Gs+!NbwO^C#uQAd-bksi<pfOm}zI>|xc9w?TNxLgx
zVUF0wLqb&&U|0yoO<`nTV{s%f@L9uz1YuG;8)Z@&<&HEe3^Xd;ZInOKfbD6l#KQQQ
znq(9jxyg-MI~xTR8f6BWr1v%H9ceI9XjB_(GEHeRv~KE}Y_>bnB(SduFW6$P*W$#~
z<hHNH<!H+`>lUx)Ej#Wu`5bBS4R6_{&>E1^>Mz(DXx$nS-Ws;q5<S*J7Hq>37(6G@
zDFbaON07$^BowfSQD7mU5|Aa{*g=#T2`bv!37J7iH;BocjHsZn&Jq~ddSF76?I>Eu
zk+BXTDpY^By>6_dR_|!h^Nwokqb*}cj~zMM#dNHl>F80xW3AT5j;9>!K5}f}=+S}j
zqo+5I)mtNmtvfHJbdDV992@8yzuS3pvvX3gYig{WaSd+2hE!ie-W}*_TWdr1m9r1R
zr)doB6sB-rRwLhbcyB!CAc{zU;Mn7gP)9P2Eu4Hjn8FrFg4PuvsfFX(lgHOn5ZY^S
zBmu5XfHQqQ4zKQkFZ95%NSI;|_pV;v)L#DTUcqy{!uNVbkM$yj`o#46q;~bmr1r^G
z_bJ@#ncml>zSgJu89ARKjU!|wZjsTCNyne*6&FE_8+;tEn2xUtBB_E5c56)i6m$}n
z!3{!k+Cb(6IDQSzq6ndYi){f}fj@<xJcY;gNUg!~*wc6tM6x-hSbaMD-09u-PDgz{
zO%^&My{l)2=>%T!#DnMJJXqAg8bW#v@fKpr#)>f!1D)3xLngal-vx!ADD&$`CJJNa
z5%gXH1D=4cC!;$S7|p5B`X)Sg4Ss-xu_s|{PMWd^A<e0*bv?|vYm9gjhDt!=vB=oe
zbN$ul2F{&3fA1W((CLJTGjn<;oZ#@Zb8N53Y(^Axa1Yue44Z6;GOBLhuYc0)9@3V;
zK*S=sDa^@aOyCv)T3%zM(l7x+z2*yy^AO|w8skU$Md|{k0y^$=9TYO44v^8d%}nOL
z=PrJ}1jJ=<1NwjsToZeK&;B!-LMS|$4c^OEhDG(SAs91}9t)W01<XU($vZ;5GuM%X
zg|lWojCPYq!Wz5+f)0|=6}TSNNme*<;3)obJn0m%hk2RGv`jdsjX(9pnobZNHZ~YG
zWjU>^c>Z$rnN?UfCk%eA`n(36`8bZ9Sq<4iWtyil?NdA{y4pW$!(g`7ehNbOQ&`Q{
z7?&YNd&=pfFBqLCS@S<*sQ7F1_)8||20r+*srq)!`(FIEYnUQDl4URw#(Z9-nm)`N
z>IlC7vNc2*iP;gyZq$#}pdg)b=w0LeGoM+i2@KU(Rx$;Rg%EQP<GBUK1LTYAJCWxI
zD0}=VbL@3<`V}eY)TcF!IfSq+WBqC~a`DS`y72hd@Da;Sy3-K6mW;ZEWj*i9a1tc!
ztaDWDzHs0=(s2#Fm%>JdF1~(_ob9=0Pda6?|1_%S!abW_B#r6G0uoLhgXmX=geTq@
zOu%f%ha$!uI1!0-<d<>eL}xb-$4Ml9@@)z#8GPs(6H_tzt__5GG0CnBA(T&Y?Z1hz
zJEQA)jwUpqjlU)O^%hQKN@Dwzl-HC@`jlMll){B6rTHn9uTyxD-_$QmiEQ0K<)@t~
zteG&vBlNeADmAn-VsA69wcGWu;t33vtc_;4+kOVOZIo}@vfgoGz2kN6wpq_Lvju49
zONeygj;F|N@A*5sl&5#vO$UCx<GX#@xNADhYdYfP9rDX*M(lL7@=V-~>BQpc<gS_c
z`RUZ+ne+=Y!Co_Ikuy8yr*oBOGB3<hB4>(T&h8eO%~zf+NS{6|a@&kdzc(<qp(Kri
zajH6^d}t68gd(k>s>vAJ9!8(ZyIpp7TO#kavfk@sMfHf>JHdL7z2{!ng?sFi_s+b$
z$Bw;!vFqNI$ouE)?vL8t9qPJ&x%mD>7j%Pl{*2fBc>4XB3-{+l=BJA1f7`k+e=~Ca
z&e!?*uKA_(2M>zppWK*ViG1*U{=qHQhmS-a-1d4nXZLWS_<p+=>gGz(<i<7z7*P&_
z5U;|F)fN~s7ceSVW;O#TgA+%EnfGlIr)*=tiRC0O?&rV@vT;l(a)@<n7%a$(7;>TG
z6r~^V=pTB-6Z7cv&?5#%Hh%HP5WydRfLo<bYG)DeJ~gZd`LR0)3p8BH5??ay=E_N3
z()U}k&cI?~IUF7=84oTwc|VCEK5?yk5}NsB=YuESgHOCgm)&5?{@%;>#N~rd2osJ+
z%HqnVO;19jmeD0ku@{$wRhAvQIjbeq6S}c651vxKaqWHZG-iQQlWPUJrMBX9bD6Cn
zqM(j*pZ9Xnw-sfMXKanga^ll6L(an&pVhHFOZ@h%v758j@Of(nM@z=@qbeL77oT@O
zz;=Cm-gf}o%eJEL%d2%+^;E{<cEV%c#TRD`UtoJ*_(<5|)mZp5S8Zcfd`wpDyjO-Y
zIB$Mis1#<B&h)ocdjwZ|_D20BU)@ul2E?T3OP0l#ODdeu*M;SbSFIOcG50-Q^%i&~
z`nt~W^*j4#A2MFU8-}&(Uf11xS^w%ayoqCB5^Ku{W&0v-<FVs-><pIU@lEU#+G>Kz
z8XUojcEx@pVObCQa<f1u@tj5%pYu+ru5ZI?;TYi@KBW)~(vJyqYn^e6xW4ZF=Bx2w
z8U)F*zm?sKJv-?QFImT`y*Ux}7T)xR3HFwGeGSFIvZ;bK->WJ<ft@sX&-(2hYYB{>
zAcep~%xjM<>R6EC9}vV3od@0{7bUzNzGv=%_$Fb}-(U~2J{T`bi1vK&+WH_O3h$o$
zsBZF6ui<^-!H+4g#pP>W7ULMS$}}m*x%M3Vh#+k|zsT@~#GFY(6+PV0X!t-?{ltC~
zVf%@pm<BuYkgLXFgUl|`*2ArXgc^^-S|+#-9^4e^F007@)O(35>*1%4y^HEsm?1oK
zaQ$cX-p?nGFB;$<jbJf74qu*T!Ll!XsAFF+n8c75SejmcnGpM$yk&$c*xVLDVS;Fk
z{l~wm#cWO)p$HOe0@Ga5Jq)+$EEV;imXC9;Jp6h}l_3+q^`4#Uqu3`%4Mitpp;$#t
zD@lvSd8{IaIsA@~O!slUcOGu1<{vKJxf+NRa9Xk~mA0!ht#W!|4awk>_^}$xs7$5E
z2g6l6+N|}rr@lf8I<Jr#&5BjV*PNEek66?i<_fwzcRuRU<?U6)z3g<v{Xzyx$aU4d
zFQ_HlOOJNU<8-9rG+D^)mFIx8S5)~~SJ`s|>A9P0Lhft6y(+&QjocT@>~~e^lUAOv
z$D7G>Vejp))_A-PzM0Ot%l^K{yU?i?yVs`Ix4jFS?(({n=Y>z$dT^&V^5NCmd#`u5
z4y11}hzcu4pAyLtv#9gby*}nyteP+CwHcpVU%TU4omVRPMRI*KTFl$v*(;4p2NOTD
zeogtnSm>kk(ED53rr*PB$LoEzzBPXQw1vhKs=sjc5D@Im?YghAfjvYtv%>Lyv}`k;
zj#)fLYPMm}lQv;b*fDvY-9n1P0B$4P!Orcrv}(%hlcT217tq{$^|#=YY8E0I=dhPV
z_9C5nu+l7jmXa@?uUkr2XhvAFROP6T9V3_ZSu5r@zOhz56DV(^atXOZN;aM4gsq0O
z^&8u5Gijl=S`TyH(lj48AF@+@F}&lt{@W#uvF)Fc??#Le((f#^x0uc1M|HV^xJS%{
za&KQXk!&fuN>scOKV+lvgnQ6V9|d9~yY5RlONwpVb_XHra_SD;F=3nQSNHN$)0^g}
zw#_^v-#O*>B<cM&_g7^D_U-|vvJ<R44zQNG2G`rEc!ajSXLXm`(V%4#apK8oGk?BS
zEzkR>dCuIwTC+`i{#LWg8L#o#1nmcLmv|h#Q`ICtdZ)i^su)S%;!*OUpzExCv)K1A
zdFSw5wf4&ss~htxkhSlBC@X)pUm;s#dA7M&pFy|zpoxqwasQ~2ZqPDbXVt&l=QN{N
zWytCMLDxyGx=)MD8Ty=SvmbwYT9wVa8PvGn-XplVBG}TuwLWTe*?+5{bwICUuuCr@
z`@nRHfA_hJjSKS6p>q+vqbm9lvJp0^&zR?;&aIr0-Kq47I&-rtD>JS4vvse7zc1d1
zDIB4aFREA&UGVOe5dBiFzaP!|{w7U)_@k?wp#)QG%lcQ*iO@GU?A_&Za!thw5IMHT
z@4ek3@Ev@Yxly`I<L@4tP5{%_9-T#<WlWlXayd1rAz9n|>7zpvpCTTPm{)(Aad<ER
zA+UG?0_jO6ZccQ}s8S$9DlRXuX7S2rk3n|(v^y|dW6r)|b^@GF(-FafzdbSWtXdPZ
ze?tmS=VWO>%T;2&j<qrBP>76B(gK2ch~ZnIMHrU{(FYv6Tbw-v6b@GaGo-<JAYYV)
z`w-fN4&SVz;xO)+Xc)n0Q(AJbb-{vG8G$HGkzh}z;-CRH;`0p$ae>{no+}{~p52SA
zef&fI13g)SmW!BOxFJsR!my+i4E5+Uof9JGh(n;cWdzQ~AVJ`BznrOm|EfqOsR+MY
zk{zlX7AJ@gia#F?F%>R)tInz0FiC<djKF#B6HuC_SxnpH5R!olh3p3YjD-d$9zYGS
zQWiK4x=XPgpp6KoIa0JXE(;Cf3t4#rID;{l#VI3sIC!kvs(!IJ$0$azxq;m^$&@X8
zA(zxDj`k=(%J$JQJn@{YCOvS$!{i+G)h*vVrg$QkFecC5K$0mAX`-gru-~Kz!OeYA
zI-&DQmK3HnH-CJHBN&@+*bcGkS|TJLEHDc5YcK~@5)Bf1vUn_apu_qD1tdZ&g+k-<
z-zHs^A~)p7ZD859Dv?}Mg|!L1&9x|Ew(+Bd^2DPHn4(#j;C))QZu}xg5OqkFOvzIb
zUc~74gt1R9jEavhR9O_5G76*=XlpevCWWGeDj^$#96w=4!c+66xWStR?2zsFAg4Rl
z3@b$}E+U(Vg|Fp_#*3pBMu>c5QXZ#N1KJdK%tIsT286>gbj~s;U#>!HP%>G$cf%n)
z@jDXUUEZ=)FNmBrP8^=wvbPu@BBK;U8S5hFnG#?`X#$D6oq)t`NQ5$4WAp6&_X4O<
zcC?vY<uB3G)TA)W3^H6|%gOJIR91N+34gE;f_)IOkR@c^Tf<CgNfT6JjTYcMlUe;T
zQ;`|Z@$)O&we_!_iaOr&xzQ;2j8gaesDXAt@6;e1N|X?tf~IJ^8M}^F@i0q!a=q_^
zL?=3f9-Z-a*TdXT5FYtSbuY@m7tS|JN1Kzgc)%X5Jv+#rN6wKp@MChD9pbx6&f9k0
zk1cWbvKT{5fti6nXT|KWtht)?K(#;bnb|9<c`-#n1_6RIvsbmR#vDjEA3*4;yhbh^
zI+$w^D8V;3vfE>8x}^Mkpo~z2iJkY3(guSd1-H2|x2x(c+|(eI#JTG}3~`lL41(1w
z=Eg(J<Br@pAFOp|?nZQ8Tu~gAs>|1WGv;bs-TU)T`>GC1>}80j3B89C`R-2Uo5wd!
z)aaYp$O@YK#WzWB51T2^o-#8QiLYy@(!$e!t7k}PH`^ZWRB`uqn|Z=fmkZ&pXYSrP
zo|n)Wv^`?y%-!juA1I86x%%67r%1i!w^Y6`mFJ>FpS@<jr?33N?qKbEa}#-cPPS~1
z40pSCcjoGz)2A*(MkU_6cgx#MXb&q*%M((~CngTuxe&GI%)R;7d5PzrY>!Tvx%c4X
z)x?YMFGQ!MF2Eo0TDNYMKaQ9xtA2>KNE+g~NY2x~zsR1Sbnf!@^6S#gk37|rhPPde
zIgoh&u^9U7kZi{B*n0gXS&QT`my5B7FW-9zo#E?M#>1Fzr!8~Q&)$f+7+3rD{8QcI
zpKfMmylvpBT_*BvPUP3cH-EmrVxc{7qv^rB7X9?+4sHXts}3X_HA#Qr#y2q2b@6>q
z$o#73CB50viys<KTzDRtm@?PV{l5R4*J^azrxB09+qVKCF;*yT0cDgl#P?t=-y-c1
z&!wcR+7H$b=BF)58zqmqJ$O@b?aQO}l1x*x6gf#KeZ|ZuWvb%AyEcpT=Ps90rq4Wh
ze>^{ZHOMIS?#zP^XRdvHp?YB}^#QZREb`NK^DME_MWdjNQwHDMq};zuao2weNilS7
zj4pj9*1U;2YxseyG`)Z<rtzQ+vk@urEm!B#7qq&O@nQDCJX0$EGh$TaYu0{xXuQ(W
z)A6QbkG@*5pthb)6u!I8nsvyq6uPu^nH4#XUDnUpiv!N;94gHSEnN6i15uM?h|<Jt
zMquDb=raP+!5P-95jG?XzC{>i;Rg%);XK1E24p7IX2XI4g<1aY26v$3IGs~KC?6sI
z7D|M;_qn=r@JnIXlo%PG6Y~iK0q4@i&x3l7S#rBE$p!lr3*ZeSgvT08$oqr21mYq7
zeD0b9E5`=2aYOz1A(7ht!EyrnIL$bllz*CROvPT(<7P3?EHs)dr2I)S0td`T#_!eY
z;eoW>0gVwsjlq5u5kd7qzRkhD&0zucQK797K@GdXpZHWq_&1P4+VHCGk%3Ji-nGu8
zJZDm_D=E*~c$by&uJ_|;SsDA3_zF2$QbuxJuy1vs&k;9L9?+r$`_=$CN^;!c_{byi
zQKh-*6(9*HI<z%9xHUVYIVtuC5D%m#RHp5zOief(;oqpD=&B$?3ioT+<#He@s5LUA
zIWo8@BCsJP;c$9Vt+#toT2g(uA1xv32qm?CZ)#m1jppT^Yi*t?EoBSjF6oK2dm=ks
z9daWB8k6Fx!UG$mByH0Z>pfi$ChR^I<agL_CpFls*3GFfHK8skrYb75DQ@?%-2u%R
zNeyAXwDhE!<oK$+DfN*dO<rzAsfl$7(T5@e>!JdiLj#Wl`Bv`^Xb20SCB;>y#2=0f
zYz*>g%1Ewtcg_tDN%VBf1&SI)5czG9Dkp0P3`drhW)YzYva+Q7y;V7BhxcdKr6*RV
z#PnsQx8zcqPc}C0O)Pb>&x;N#j|=ZiAcME|y6DjIp1QjBimD*b>g2cv50^tpF|?Gp
z>cpt7(15m`ZiUgo?R#R6#Duo*+)?Q4nCIhB92Eq<tU7W?dwg{19&+{G<oZ3))$vhP
zQ6a5CK1X&s7es}&q{NrS?k;zAEa|PU5A$!!Orr&QA8{e&4YakB!`s6BX}%sgvN8@p
z2;}db8WUU)6O|Dfm~3w3svt{xcO5M%U}<TZBqd@?G>o=1@l=o?SrK<Ve!Q$K@1&~Y
zW@fxiRMa(Ly-!BUWxP}A(dyT2>Q-*VqN7v=Q`1l#El(a+qbPgTuTzMft{|l)ti(q-
zq_^TkoTLjW`aq&)w4dFh^P>IdF5768jo!F@Z@=i)Lxwt9$Dy)%O?407!HT1uCna#^
z+J-(!Gu;IJ01X9ii|T}e{Nn07o2+Xm+|Av|QF;D#hwus}B>$A);A~N2%Y8+(^t9N-
zxNN)JG(ytuZ4v%P9^pWc;}V}aD9DqPSXi7pTCp_|5qt38Dn{52vX)7rDdt6gmkh#Y
zFnx=5?x4EE^w{W$wu#?G*ek=*I>q0s)jNJ`BQ;q^J`4X|t)BWpO->Q?T==^9TMGVa
zx4cJH`XyRZ8IQJKzxzuuvTI)9yJ(Fi5hzCbdjra%#B5Xy!ux`*mZ(N_9}7DXa_O3J
z$TwR(<+dLd*q3iLf0SExucUy0$Nr$1n>T=HZS>q;W-<Gk=%+w2qUiHeF;c6Trzb)v
z;zvdJsV2?)CT87fdcEa!yYSE_(Hipt;Kcb#3WFBT)&EKcG4hN80gt}9d=(Td2L>dA
zXx(-&V`x0-n}vnTG5WBYhc4zixD+hr@x5u}<(3GuoRm^391-__Ui)2yefNX!uWI%F
zibAdL)#{%H7bS%a804EBPYuIz`SheZviZs>>Y!TvDt9(_mV4Gvx!fekzjHAIC0R08
z$VjG6P2bk4FjESwa`)+EM;30KNeUD{#h7^{O2JIRw)o5NRV!Dyz#N<O=lt2|*y%9Y
zx@5y#OJh}0ZgX2)mh&?jadG2GL!m;-(<8-KU7tA|${XWsi%S`6?=ayB$F{=Dw>CLD
z9Y&8%<wOq6h1J&gJwJAQpmprU(M#qX@|A-M3WVcVw1lR5H>8g#w3~1)ubygGxW0Od
z&p4vtjC7E`@)=^*Ir+vRP#So4^_ASKo)@Q?8_v#Nt$NirJQh)&zo1;c|DuT%vnm~V
zU9M*UrNJFG^jV}R`aFxpeLjnj3;TP9wHwW&vv`e))N+=6@2{U0tN2oXS*p4-_T-1~
z>eplViTpR$)n?9nUq5=cGcHxb<b0gfmiNgR(~%|KH)$&az!7UJS@Evl?u_%vy(T8Z
z(J>C}!U+Yt5cpGpIuY~lXD{WZtIa8h-4I5VmX$DYl9_!+nQWROKSo%%m!jCy-fmIN
z5CtqTABp&$ek4TREgPS4Xw@&5gDSLWD#;eFyYb}smBxMIgm^Yn`3&K#v!1y^&U#jD
z$ICVeEnIP=TRvOr0gA~BjzcfcJY2W1Q)CxEV0L{af%bxVRHaEMEv@(R8-0AHnbi4;
zFE>P?Nv0A!;;cQ(Ix0*R`w{YWnEU`QR4rO(d?r4ngMbB0-C1RRXZHodT$)nHHn0a^
z<wJW1w}jlY0SR~E;C5eJPJh8?;XXF#9UR)U!KiH_pd{QdAL}6VHx@W6H0gkQ$&b<H
zZ)CY5y#y1{1feH=#`(f)I63YDbz``cz`80L`cltcN+RqCgCr>%^Cnxiq1ZLXKq07-
z!MIV}FneT?7oyXM1L9bpoXa>3O^iNM?5U00?9g+pB_B^CYi60F_>y~;A)ETuT>d6;
z6Za<K-IW%hWimp4)o+w{nL1p~4p|nNo92j*NWy8<hl&_2OspAHvyQt;Yh3Ts!LpZ_
z6u@EE2wA7GZe=C=n8mLRXv$M*R|3SxDY;s!7S!K($owc>Y3L}2q1>EWesZS=mvfe7
z;TQNm_#zte6~`v$WD6Wf8(~&tgko_g%AodqOprX4RXwl@DX=JmYP5?TnM$7?9=Wu7
z%Py-~Qh?#pk>dN*EQuvN+LIzWUI$S!MxaAurj5iS?ORxBEi80W4)dW~oEkL}P;$3&
z5eJdS3wCoze8Z0D#}Y^Lz6|2fWlg3}_-<vAdL&d?9-G4`c6N90=ERlDf*JHFG4dk!
zuF0lhWN*Gj?Qp@2i6zU5BX*BwA8re0se69VJm>b3Fw|p#;)5UDtDM~)Cp@zKQU2{L
z=uihdQ-SZbIJTQJC*1`_*VwnnmeY)Ya@#qCIMuR5`%j^3CrxpI3TiP68WK7#mfqJY
zxY%RVL*bjxh_=I45clCjiP%nJ_a^o7@^g$Pb+Aehhk%(9$xU&i-pR(aXnJ-z|KKgS
z8|NTTLs3+f%k}3-c=nxr&8JWvwGpzV1JheK_u!uA(26n^VYc^eSlUHIywJw^kEV0k
zf{CvV1goJG+853$(BP8hYWGFv;1a_NAttYm?7V-w0n<p&Op2l8@dh>y?AG(NUnX&W
z*yE-g>6?X7C-`jkQIIQFNJ7S09##F?Qd_x}l!xcaw77}Lw_UH(-+q?9&e05K;jl21
zRriH!U!^m;uHpDsrLVti!hQ7`L8Hd8PnepAFvNTT2ZJkSOo5`ju4BS?DY>75D^b1+
z<T7EU$-Mr`A$DSjNi+ZBK3^S#Kol&a`iUQeKP;{QN`={tNm&M^MUZ=7?q1I&xWnMp
z_bz=08cv?P!D%W?L%uPcQYw*8Ji8?aO2$j~w|HkZH}R`fsn@Zp=Z8S_8{F$C+C!y7
zTD#%n?|9-)jCYn2xrQ%n6>C}w+l3w;C-T1OQZ40MRhl8L^BQCnQWd{e=!FuwRV)*Z
zzNbDOzngixIP;2xIpM|5xJGP%j8KywD<6Si%%F<d({mh~JFvbv8`hCKhlD%>BtOsj
zJrg)7@&-g3R?AIYJZ<uZ_Odnb+`WaHV`nbgMRgRNyT9_`L*I@Mt2Djl9%M}7z^>R=
z$@lbqU$o9$_&9$k<?ZK(>g(EcwEgQe{py7VGo3`1?zJ54G;w(S$2PI<(t@_?d)&u$
zE^FLeFL6KrSf=Aht`XatQjMG?nJtG;L{j&g|BJczjA}CN*Y@u;2>qsa4801W2%!i`
z=+)4x5Rfh+AksukLhrq!0wPUR1XP+DiVBD{QL$qgdjUiR)Zu@j^R&I6XYc=d-!Jd1
z`84yv<#M_B-N$vF=TX6t_J_K={^Xv>mFim(FLbZyUq5i>Ko0o&;o8){qIrz3IK=HW
zx<YTpnz4EkHTcHimEQb`luvEWhabCLG3f6;b1>$>rFV;e8Z4aO{`K6hf%m~jbnhdK
zqZLDvKkU8}dH?C-M@QJ@M+2WE^se{4qc2Fx3-#zdy5;b8i2vA3M*RAzOOY3}h`3&L
z#m1=}MLGOcPg$z2(D_)HwAA<y!sqcDPbC`>HgXUGVRiVe;LQ5$0Us0}0c<@!*_f1(
z6~CucbKj?skIRnuwL9d}tJ;^;!1u?#DJ<_?a@9zFVdAsi%9HXzyO!%!H+rL+hxj?j
zY_(J3$%YL5=jKY7$&cnggno<{9$u|BIlQ{*{o|eDk%GCmDWgo2@9a3#W9RQbH@wl`
zhpr<IRw#;<^Bdhc@~0&)G?t7M*@La3@tvccx=Xt<9HdF->}RFpr0Mr9=_fwZ#9C=@
zGml7#FkZ(UK@eyPR*_0$G?h@^LtTujTMYg+2G6phmK9Z^6_Ou=9qTpbOH(z^rS8nq
zEW@SkB&F$QrA=F;O7^DNB}6#1LO3Yh5xduU4Dmfa-HE`Mb5HRJ^*3Bd@mET}B7Ee&
zWkyg|dPvrh@ZOAa-3%&Lwh_wo*G%6Znz=h8^FS8vb+JrRuTZjx{6Uc{PtB|hk<5K-
z>DjGW&o?VG4liT{%4U|V1($hbn`dNIDP{PMr4;vO+n>m;U)bG9$f-V<-CX6>Iwn(I
zoD<)hb?kLc`$G1LV(tm&oC~3Py;ZrTR=GuExs}~HOhR_2NA5_L?r=h$cWK^)NY3Tn
z!#5Xp42a|#YUj^~YTrr7*Br^a@1gy0As_!af3a2T8KFSFH2>wA=IaER?4knFxq^>l
z_$84-jB~+i75-~NA-c3sRSUC$<^Qo(_(7{s%?XW6JUm^M$=X-Qww^6MjOD22Lx>hn
zX%(vtvkFuvUtP-;RW1}~%a<H4D#VsZw`rg~OFCjoltfij`brW5iq+pJ0M$i=R;kXq
zyzXXVspDLU!5ev_d!>|>Qlh>bP+gEpN-f4^t*Xlmy2|XrWF6MabezhZJY`)x%e7<5
zJw#=_`pUQSmHUp%P(>?Lv?>C}rFSP*gx)I(XHy8fS0TJo5hW@etX~N`RmNrG5~?eq
zuFB*$+hW!$H|d$)N>$G5d0wGaHtTsCEmekHsW?hi0h?@*a&@V4#WvAu^QSD8_r%NJ
zh>~Wisha6E<M6igBBv?*r-|?$9GpvoNl;e(Tn(0<DlT0kLnt|!C@KZ<DnJk`1#W^M
zCkXO{AU+D*i-&K7!K-Ptf~1;?K9OcT%%H-Q86JN)jeEHk-GJqwt1fP`9p#li+UdWO
zYY5_rMnd?y7j3j^eefTXJ}HYI_dH&uUy_}DT$NnoHg=qik=ejfFZ3)8HG{ZlUZ3<P
zm$jyTY&M>K0+v{)pCxe)zzrgr4cHB_`KTI!=mxf@oDi;2q#YJ}TVFHeEFFzNMk6i|
z8^KhvnpYz>y0MbP#j^vh$3O&jzPlLcVHB)sa{}#OFK!@8XSJ!9v+Fm9BP`%MXs?iT
z_>jU0Gp`ezNln{}Phf{mnvr;>UEt0cuBURaiUB<R;v|da367_nrb#C)avIY~Ja?KK
zgKA(&9S(OdzUXk#_sk~Ga`LDgEIBU-MKvS+_i_4j9on=>61Q%sA#vfv>`){wmUEol
zQBK^;&8VlGC+@VGZ?t;76+J1)M@m9Ou(vCyw8t1o^q9di6K(D6kmCLJZWSr#HMUhx
zF_UMqCzDRGNY~H$yE9c9B0M|Rd8@{1#8dh@F3fgJg&*gqpwej2ogAnVhFTYkW(_2w
za2PiVN)dlX5oSL{WqEl2^l$@5G!Ff7<4p8S-CM71XBK7SqRz%athst;f80O&=f+t`
zyc22IiT3VfIn;@*?PMS5<b2S{{k;<wKgVZy?!P8RzMsR1cgg%tjO>+Ojqg$!=u&&o
zrG83CWW7sERpT_FTX*wNH=(xMV4!={f4k8Gk$qpf$%Z{<-aQtFdaP=DYzBJl9`rbT
z@1cmFck+(mXW^fqoOiyV(o%HZ=LTQ$s<^Rj=f`{J1HCT<AG#3w_r%DJbi?oq+gN0~
z?hEilT}-IGm^5%P`N74M?-yy}y$r+NH1FPwL%mtGy*UHDc@KIEzW1gXdI@M=RP17R
zU&iiPLZdtT>K^nR``!m0{u>SZo4os*5B0a!_O}o8cRc7n^S!@Qe4xv4py@k$54E;}
zR|(fJ01pk6A~44~6H)lVQSZTPhX%)L2PXywCm#$>eIJ|=zcgofY2N$NokN!vYA@X%
zxOC$bnr#MMvw2^t*HBb}iVCed{JQq?+kwmPA6)+U{qmCdl@-G)tKL_>9=fttdu3zb
z$`92m*cpsAO+tztI@2Zg$DzwVYnkkWOwNZ)?jKB8Vu;V^5SD^k<Pd3v`74UVS&fFI
zz~v}0EMqh*H^>wmv>m)NBtJN;_HbDJ$1vXR%BDDTkOkvPfe3XY9GxTjc_W5{&`ux7
z<l%^^-KbH-C^2G`<TGlJJZe8U>hONVQEk-v;i#+HRd>6qo<>*g@~%=iuX;~j^*6fa
zmp4jHzGf3~E&Rvm-uG9-BCdu`UW<Bo&CBQ7f#mB>oY(v*7~iOf94dQw6vTobV~K(?
z)W*`1$I>>9#&YV$@+ZeK2FKDR#tZDmi}J?G2gfq=#!Dl{k9Ld~J{+%;m^kh;e&YT3
z$>i~t$?-O|iTd~B4TIxn2PaA-Zd{n0xM+9dtkI3Zy7A_RH!6K@bSB>z9-KJU!BT*~
z&}6|OG{Yf8LCp9dgzz_~C2r13+?-3kd8gy%%;e2`MmHDiZr*-)^Rds=OU|hWMpI8Z
zrk+Vmy|$bBG&uEfa_W`c^s>+N=ZNX`!Ra@X(@P!GZz86VJE#9toBk;=gUO%99-i5(
zo0%WvKw$Q@=Cq?VXWI;B1@mW7{<EToXT=^hZrgrB;L@zv&l56_W~FwXP}w<$yE*4}
zzj6D~Ib|;BuJhGdrNg&0^Ka>2x@EL|t}SOyNOGRMbKY$Cyv5;pt9`eOkIvgYnz#OW
zfg*X^Nm85CFXCEp?syKb>(1LY%k5eoLB6M9_e<r@N%`J4Z&RG^JQ9R|ZOySmU~3Kn
zoRRhyXZ+nv1FY~ja0D<BFh{`b0Coh-5!BVT{3{9$psS{+xC?;Dl?hhhk6FFJ0;+2O
zqJj1rpp5_y0^qnh$qE4F?+zQllmJJ5y~zs7Y`=LWsI+ZYb_LWD6xBdu4HVln)LefP
zOgR}_yqY_Jn1EdZjtP*Zn(9_jZSyt?pe|)4XO%6a<pv<8oQ#>Qn9Y{@S7sLw*hq<(
z1IVSLZR=u^1-fm(c7v0&v^3WRd{ais4piElcI~&bH#RW|2JFn-G&DA{LP5@1Rhgow
zXa{6An~yL%RQ*iIWIL-+13f<-yoZ3W%ZYrvhr7Fv7o9}jp)TuUv!nbtL;CD~B^&F=
zgqYghm&<zlu9TLy&z}?YB$fWEtEG9k#W$X4kH34`*8EUlK#~X_iJ-MRJS4%=%1}ea
zou9?vR7Yn-<Q@eD_n7F+soC3Or>sC1F6~HpWJKEYLa`k?eZerWyPdC}XW_;)^2aQ)
zuI|{a44J7@xTD#2*2m(`mTT_N^E{kX>g`rwV{2@(L%pcD(&JFt=t-SIs$P6|bE1uU
zdRi6L-z^thMf*+xKHKCg$xM{KdVL}>RPSNGx^Bdt@)V;;ANih!x|f&u0~{4ICNB8x
zj!lTmG_(zrG`7szFCR?OJwkQabs*W(+!d7Q@Y<f+6}<rtHZkx4<hQ><{M1>dSy60i
zMrLqL`K|k}a$S^yy*w{4r*>Q9?=k^@OqL$b*;WPztrduWyjfySJ}gP}Pdjw!>GRjA
zF;?-HTa#b*>}{=kH^RcmI$=#P_UkSWnK-uF#rjDvk7HZLzFiie{02I5WP*J{VwCf_
zBWpL2pwbo-S`xe~Y=?mvsII-dsyBR$9W>MCMLE)L^;u-b0bDrOO$ZBUwx?Jc9}2<Q
z+W^E23TchmF{Qb)hoUdUt#s`)ByC}0zY_o@2l>=(@<O1K7T|FVXJhw2az;3vQ%*Oi
zsECyM@0)3qv9eUDe{H6<67wxe|G^oz7Kpc+Y2oJjS>D5}Ru>IorGIlqC$3Xp7fUbv
zRgS%Jk*~6+Bjm1s$z|H#nrT^om1Fy)w*iq%Ukvp^g*I3qUT=e&stj{|?Lz*|;?Icq
zsptoB$@?$vztz9R83%ip|IOmh!t+0G{$Bh!IrUdFP4jTQ-={K5TUGO+&R?9de)VJF
zi$JX_pd$Xb#TTqScu=+<mB!wV<5mt`OdYpIY%Tr(&L|SBRD_m@8*9k;wLtt&i$8qV
z{BrTb=XX&xeE*>45w<v^(N~Yha>gvx(n{p51>)ah559{2rGK!YPP$#Q(-%$7an%>A
za0|X>SxJs&D=XtHRxYXta+6c2iW|SqUsHJ6v$%TK__)H}xXX#JtWDo%3s%QE3A{E-
zRdET8&-{pfRgIE=+u{}Tvbx2#w9Dm<Q{^%FtEGi;;YTHpWvIM$iq8AHNM=LFfm)!j
zDWICyE#<QJ)PZQRvNI!ZCQj|T;v}GU#;b3fa{Lb0fE3H9Q&m{EfY?B3ZLW~Z>F~J=
zvD<s<lyCT6@Ms(Q5Va`uB_iZi%_-;p=fSVHJAb;M`l)?VVV*gtM7JrrOkN%+y`pd)
zmySl>q{2*!G$(KCpDI4^2vWb!CEvi9x{Sh$PL{BDM<*9);>1lW(w8d|G_Prh`iz>(
z%b6|NsZ18767|RGoF=tVlmk<WPwl#IBF*U<2c7DY&)KTHM$m+|o4n98y@-7=JTL3+
za?n)6Id+Gss)^YbqPOX)mNc2)1=(e48QOD|>*hI5NWi%%Rv<`NF7^@IPof^#C1O(#
z2f1L;W~Ox27pXW_lC0xXHc1EgSsO&;Fy#bEsvDJ1)cA{P{?P(<dtseIC8%>iMRQp2
zlJ0~W1_|lu^Ur-DK1UF(=26P|15#dCvoT^5&peAb<|zhRzKWuvp?%nS3n5SO`BCES
zRT<c5zsK<z{{4OR!k@9l%U!ZaS6O{%$*RfxGxm~^J``N%N0D!UmR3pfEnE-Ap`~e9
zbbs#HCGKba^oJU}sO3>ohIA1zaE~mDCqv@}1nEIED=2H^3A7}n^?EoFY}t`36pQo|
zhD6^+6%s}0u<#Fg(NtRtQzZn1^LU!3T*jl*IRxvp?!pa3WnJ6cAhQ3Id=(1e#Y`)T
zj|-W}0b(OTI;P8Fm&}k(6*nc#6tV4oPr~`}jY(F}NQ_<zPDmnanPoUfPhd0|dVOEp
z>s%KXpIHV}!~%5{73n=3#YHArNC-bm4;=i&!*ec^C~~nYc%hx=4>+?o&q_j0#Zg+$
zhlNdgZh-DHOZ&<{rhzTVa>u<Wg%*&c<TVmr>IEyt8Yzkn(M|0w&R_}iRb}Zy8;hA0
z4pki^8hFBb*BYx>-vq6m(Is@jw{X{8q@jm|8%LC0L?9hm<Z}=7*y=V()+SqhYL<r4
zNMbIs?+I~I8TL$m#y?VoF~pD!^qZD>>l2V#Eac6h!&6<j%b*uUR3bAv?20hftQ@7^
zuy*P%M0+Ky3_3NX!quE`Tsy3Y)rvP#dpH|;6TM!ulw8@@ZgKF`UaOry5VpAqnEgmc
zF$nJnV=^4*=%IX(-p+I<Ni#vz5DI#q0IT8TQjp6T#Aap=eJ~XlR|dgLA_k2@W^Kr@
zcH*(O82W-EN77)ZDa;C4m<6Bu-u?%17y;!!V#QdH+w_D3(xS+LERLa`Y-wLpE4Z7^
zl4P^|GTEVqM^J_A7dk(`7U5uINMg4$R-}mynotNdLIsUI$)S2OVrQ}br}k=}2!RD-
zbOT!C$8=aYpa>+hSVRn$=hR--ve`yFdiv&eXl(ewBbyHwF=5plX*Y^arJp|Ei=m;z
z@4^Q&_VsenBbE4L9zOY#*c>d5yl-b9u^A@cXQn*l*FI48Kuj+7qE;c->NnaG(KLaa
z#WTs~T8K;viAOKg%UX3VJvGW7_c1Cnz6x$MxzLJXzD7~bAZW&&D2ON0n&+i$=^Sp9
zDPk~cDqvLP?17R=W<IjEkuFk&1BVYPS><4yG6fZzSc_pRxywZV25OagIc#;;0YRIP
zALSzN$QI##7T}8w9EP&a<?cYxj0Di*=(bdaVeB7bpI%&3ozNs%Nz^p<lSXAlwa8i=
zG{Id7d?8p_XpPvU9V)OX?Rp``CZG;h<F^_SoYgXcqBvcRM{kl9#t32vh+i>{Ez*Le
z6fu(@Y2=BsU}5sUkPt9zvATgCzsema6HM2UO(<odao*&F%mmVILeOgQ3A+%*>(z6b
z=X7%L+l$tQS8+~q+pMua+v!CKb6PqFTitiU2C9L4eo@Q9zFhAr$7;-%)5knVB=$jQ
zjq#uP(MQ;fid4QWKA7ZIx>#xy*-+*!{mNL+bUq(G*gYWgNho`O$LV9j$OCD+go~Fr
zhCd$W8GXW^7?<5hoMODcD0f#R?qcq~Vu3xKtjc%Na%=PX#FWeyQHo=ygS3{*V(Xr{
zM^+rdNV03Lvb^xx)bHaB5x!U7<8vJdbtfGi!j|TKyd+HbO~t1)bguk(Mdaz9$$Tt%
zyhiSl*~JwT;b+eoYCGRh+^ue%aQM>h{qwEIbpM@;QwRC>oq9**8CbZ^y=s>?>K@oa
z5#$`X+%vFK>FxT)gNDfdz6U=)CQJ`J{x&6Hy>$59leGaLl1aFVdxSfvF?i?3$-j$a
zIBtC%|C>lgqtfcYZ;{Noss7pT*h%!znK%A7ne-kh>8>SPb1(fbx37<tac2M2=Wtre
z^0@s~u!h$q)~|R1btKgIeY;Kgkso~deA1Wn*gx0q`uSFmmGzDv-`DQ_PK2m!cd|GC
z+&m)iv5dvay7nZ$N&90x-smR3pJDGxl^$+OSvz4<`{klZdt}pQ9G7&$^!$;B47F87
z+KP<)T^c65=m-l|dWaZoa*oC&BAYPJZ;GSyW4DhrvXqw5rPk;;5rzzbA?Ly1;Ug+k
zF;sdPYE{y4w;6bmRM1S*@krH8NPT!Rm_U#>zL;vfmP!;!Blk)e5Yj9X(yXe|Yye?g
zNOM?Aqlf^onC{|{?v{}5QI+o1o9?ra?z@&w70C!7WCVI-1Se#KR%HOf7_pEMxt0+n
zk{LtDjP=NjOUO*9%1r9bOkT)LS<9q}WHAU?Dh)Ad30YZHSvkE~c?($un`>D`BH1N`
zYycT660)nRvTJ&?>lU()t!0C~BLEqjJaU>7a$2i$+Iw?47IMz4<#dYVb`f%W2<a1g
z@WnB{K9AhN(1Rk^VWfMK?d{x}r`tw7gw~%Q=Jr2;eadq^RCr2>mt9tKT1iO5Bmdkv
zkA>d+hu9>;rTj+=Vw9$=$RG*%dZf5;LCEqU-r|C{Swc-1-q%>@4+zSj!gP03OD|ih
zBf(_JJa@Ff^eTasHvwAW;*Y{^Bw%NmR2I?Py@7%<^CaX`XB0#D8Y=`T!<dsAyABlY
zz#~d#!i-+BLoio@Zmu|+pgIu~QDlK4*)?A)MEQrKG}(xoU6zNSQp`E*-uOaj$^X0p
z+yWtYKxLn*1mc%i+leGwSy(q4BNNLSU|uQ_=I@M#(u5LTQp}D9b0g{Ov*4Et%Xy%A
z*lm{LLM=b309%-|rgoR0rOEF@u^U)OfepEQkbUS@*a@W~UTJgFXbYr&9M-?wfep%N
z6aKMgZv3^_%Q_UP8JI&1Xr-{lSC^UjyC8XsPtI9;&@l9oYV-k)xAdg8SAt&?;CSWg
znruNSSwuR2A@(Wz-uNOYsw{(6b~a38qpJE+wn!kIotm938ziA&TEwbZFr+N}WG(;h
zLfxGH(Rt6KcSJLJD4ci0L>^o`n(mM1p&-zk(s_?PkC~3uy{ta=w(r>cd&fSmA6pVV
zzM_9T;C13^;_<cW;~Ra)f80C%=lXF-tR87lkM^o(Nvg-z)Uzk4WcAc@Z`8wL4SWU-
z0$vS5Nev=34PyNb689UVHX3kZjWPy}|D~CxZXmwvTdc+g&Z93oS@Q&;=0qBuVQ~M1
z@x}?FSQFWx$t)*k)3vE7fwO&Bo5jmd*~?5}sCIYOu?k1*b*qzJPi>dk*gSHY&_gE|
zpVp)<oV+dFOpcE7t!WNd5yau4NE<kEqZ!59g2J~%v$w>Dx5ThRu{kY=CR!5NTaOq(
zyf8uxk2t8(nymsK-c*6bD6PDmt@#tJ@dgNf2uXX}lH1;TfE^Me!dYUib?q%RUhPfo
zEwu)1u?B5H2qZs@uxUU<=CtkINF7u@=}JFU(Qqo}+9{8xr`U&15!p`4B04-ZD}?+z
zuIBJv_2ivU;hj!`XOo0()(BkADZ9;nx>WD<W6~+}q0=zpjBxbnF?xrE^cihBJ8ik+
zi#8k<Rq_~d=7WmBYa9MA;k+p!aEi5{!a8o&;H<ji*_SnfJZ}Vk*1&H!;88Cb%N!V`
z3P0}WXEhX&ixd2o1RN~<!Ve@dH~7RKz-)%R((hoN8!(q4|FxVl2QOZEao%mYyc&B?
zhn?$E8sOs;xFDx!D|k_~lh41|p}1RX`Aqs>#@%0_1O>5yQGUj+X=MKZPhUS*KdQU0
zpPL`m4R8~0A7DZ9@b+=s?d#&R+nMU`9<ayDkLv2>?YJk<8}JnW056~2;D0%Jcsc-c
zth<Lj)!)O(*%ExH@Ah>L3f@g|G;?;ba&rf$g6QQ<@%3{F3ihS?d+zpib#u4fMKN=6
zwF=nd?dW9b=wz`c(8tqj7sb)S#nr~w&)Lb@3M|=pc-rp?^z!y`c62iL^rCorIe2;R
z0&?2jzHT9*{=p%>fk8fjLA!TR%&l#VtgOMmhN*`eynGy8-E08UQBv3iQfAgRJ9qDP
z_49Z4-tFW^-2y<nD5ms7#{z?VEv*cEsjhnhcl-D{0kQ+|kgJ=mi>vLINtS>;?n&|4
z9-e>!ng0%{`TKhS$^+n$x3?o8M@}x5zJBh`F18u8=DiU?Vc`M6A%2cdRv_ZE%h43j
zB^$DryQe)MM=1$)RH_GnM+pbBK+FxmBP!KRMcx_EA~0M8*w8jHYiTJbZ=YQUqG%vy
zl@L>{s^kbz5yg?@<ZNr8?+cib896*^-(iZA*)EC&m_c$U<+c_m+Y?FzxrvR(PuN;T
z_6?4jo9T8%$+fqi`*R*+LNa`QNot3d&5fCbJ!i{;uhibpks4}HzjaoWPR}b(G0e^?
z-R)km`2-z*=X7yNgPG0_tE2H1-ts%t{2U$j|MB{xn>F>uX>-7Uvi9j8&7!1^_kh$J
zU^>~fQGirjZ7AWPG!HkQLvMNx*=`4TC8V|@Fen3Loy;<#55$Jq$0pHfjb83ag?o%$
z>8YM^X#j%k4=eKXWw<&;>qiHJL7?D0$+rG+-rmVz<|lhUF2ErKEczsd7&`|g?+uHK
z@WQ19dHC4K>xBCUdj$kg6u__$U?NVgi2-izd;AaW_Kpb(jP`Vo_4iFqjI_^i(eQIO
z3-)ph3r;lj45s?-^>B^yboZwE#_sWtPY9IM3fvv;931B@?c_v_q{_xpRU&rpJQ7m!
zKZ6pK|HH9!C$1O%4rIxV9{87OWHzecma6IR6FyTt$~~>KC;l<vvo($U8<gmN0TVtT
zkOfptwih}){eo|`+m9bS{oo>QcKE36#WRlv5<b8ETOf-=%I;rR#I}sP|9wU5pQe%b
z_AB|_IA%X^Vc+c8$ajx#*4CfNx>C8)N2m)}dJI;?{8A1|etz|9MQmr-^4nh%K7Us=
z{hIKZECv%k|5?@a&$E~ng4U_<g_b%iev43lTS4P8X<u>Q*9~MzgM*T$(kY>h);z~R
zAWN%!?3u6nu)y<N9Wdb&_Wfb&o)G<yz_?3fQT|KS^b3@Hy*VbAAgfjOtklJg?RJ^l
zTfrb#hda0Bcl!nZo<@EdcvW<`xaLe-Wl?R&HRX^r?<ux=nWxDaCyzEu>J{thD94Cs
zBtL%HV)g-+vnA)UmnoiL)i0gIBZp*QS+u9qR_;ocq9xGQ1&#pX=Qmc<gwJ`+5Ur-D
zo-=>bNoik)1zM3*Ez!gYH4@5B5kFzkS*Eul*omjlDD+Gcry&X_>9msB8`6l>sGSm|
z^zFU*ZFU`*3qsXe?_wgj=TDKD_}Gu++t{8Q1&Qo_HE0>@a@O=BU(d-_wtb&%O>e5W
zw2(IWnr2B0d4{`j148qirkorvxXDv&O>FY#JV!r~j`0PyU1O2#*0e<B<`v1Yd<gTE
z<}I0Uyol*T5*xEE%&hIvSD&4mI?p$+Zayo6?k1aVGqX28*5wsz`T(nAYr;OF_}TQ;
zBnnbXfL*4EHTBLj(_H4Vurb%+<e8pw6*Tw2NvX6vVrcE*nfvV3BQqwB&nx#^q0Vk%
zLLa*{a;+^^x7n>l>=csw_%u&8Hp+TcZFNjGUk^MuDU2VS8HFZgiusHhiVzf~`k7*0
zy&zIC>-M}@GFB=|V1!Gf!GXegPP>)I+;dk`BKb$`9w2w(iiWu*Asl*nR9GO5SkEJH
z*vg_x%8A9z#|%P<FHnlP?x8x7NS)I#WR7_u<%BSoJ4<1eA*9j1t6>(AB&n*U28qJV
z)d5pyC9BWqVa)S45G&drMGl3|mP`^M6*vncLP4<^5Ftf~iD9p&rBc9L0c?d-T7-CF
zi71#td~Zylp|GPYNF~|__!)vLa0aKO#6+4=5nKVxbVVyB%VsMC3F2|-q6893fCwo8
z52>)x7!timh9;Q^4*VmG4iS-7MN2_P(;<;1q`cN_w$Kbw&@qaJ0PhVNI3}Og0z#DY
z1&SLct<+mV1gM?`-5NkLih>Xk5afkpqS0i8as)G$6((U3Gju*YiGwIY6R@H7^F%q~
zM6GBL8iM30R2Gyd^EKxjU9-j^3mGLt@`@T^?|?9339?W?5yV?mf`IU(cX>G4!*p8O
z_}(<JMoK1%?X28p>6jQ&sR$wUA_e7$gH)v9eFbTd9y}}>8imxEDL|<(Ut%9FUKZ?N
zvW$Obvg^>8mI*Y}<L?mL$I4B_HaW&2XmOa;Es7<*iiR?r8B$@D$->~J(emJsq!A&B
zx_Z_En23Sur@tSCj>?ZAAPX23A!Np(jvK-l;AbHth}{HY$Z?gV?$BApA$n;XC0Py_
z4*{eiOhjfBr5?OS#TZ+SASFO^oRf+(Sz>bO!zdh9j!OmGL{h;sI1|pZhk;)lqNYNF
zi|s1)WDJUez*RYL@bw<&YKPDwazyO5&{Xl5c)B`r5iLtNMGCCHHT#8$g12X3yB4t!
z=ORWYDh;WCPvcp|p)?`rJA0HVy9AL<a*@a)L}7tq5s(>fILGcbN46QibQW$5)>4J>
zo7{3jn6YD;B6EXp4x6#@gbu+fc)D^Zy^IY@vqE%2l`Q-y^qMpzKt#MT_=>8RqY+h#
z7_3>~`M*=vR2{rNP2y6}<8(H@MY@;|mCYH?KpNm_PmQTq(HV75YaE(G2drO5ogoQy
zLTm{`=%v#%;k?dN<%D{OMH9gj$DH_l+l}+*O_D^*5(9yiM)N>NfzFh{g+)SAOeRqZ
zrdfCO_CWPCLHx`R!(|bg)<&SEI#X4QU2*nR5Svgnk`YV13Uv}wcQT<thsDGPU-ps>
zs86qyES}|48pH6>XfhH^G@f}D&7jg1InXGhC1jb&(mj3^=}nFuM6?vUBkOIkF(F>%
z^u3~ttOdS6nm*pw)Xt{J7E5BgAvumnt4&`qCRReBL>|mA!<r|Mo3m<|MF@w+EPCLi
zIy>2D`fv<iAVQTXjm)r}SoNYIHL92#NPHTs25}>>!(0<^8iivt+3m+!qEn|M!v#V)
zD-EFnh{pNB^$1cGDW4<Yb}A8fyG-s0CwVDCx~Cp}J_Tw$mG=h&2hm3^&{)OrY3SE?
z7y8Xe6>JRp3sDj)S&0#Mb|)<UPykY*UBF1-(m03)*Mvo^*gAI?vCI@=petR)mQj$H
z9FxTdJIs<vrJJ&+Aw*~BUoNPn8N|dQ-8TvQ1m5R0-IZzLpBBK80<8zak<1$1X$5QA
z10bqnvLQNEgpN{g?^I$UE_{HHHcaIGbt2-bfEB{!&1VFD5oyy4Ath)B#XCud(Vh%`
zIpPEQA`{)|Er$SUCc=y!R<Lz_zI4rnBaL}ZoJvOL=RqPwS{y$PLVK~MBGF7PcpXBr
z6fO1V4lMDF5n(UN0Z7Lm!VvYuIyoQ}J0|zz=Qxy@Es|HKo`I=O?Zs%(5us2y6e<JN
z;~_*-J&R{06Uy0ntviy2K#aX-RZxak*j}KG;0Tg2Ohc?Lv0`TEE373*K`b;Nt_0mH
zUwTU?5>PKj=$j&PFhekJ2S=_%nwXOzF0K<btsK2h`ltzO5P768@6P&(Y1A$zl2CQ-
zW*4<-*mLpM-S;8sG<BkhB5j`_6pbZ?vis9m=`;+9jv0y)T|{E=VVuIeA_N$S`_!pU
zqR=6zlQLiiON-F?2(XA19ZO)KiV+ppU|uxl^8r(iSq9rsDux&12;({y`BvQFRXrH|
zjb#Y&I^%*SMli4t9|b}&1o%aXsRq1AWM@*z({$x?cD7`m6a_da6b>2Vo!5cGJoE)-
z?e;WsMg9$xJn<(a^k%ZpYA62<l%#oNVTuVhv+Dc1;nU@s#+xW8H#F;i1tq*CYI?j1
zt*v;#O8x>R9=R71azPrazc*KZIcIP!m-$+(nJ;e?O!y?^Wi;fB_2z*IpQ*LH8Ik-s
zLjJr5Q0eBoBD8H&^S=zScFw^^M)EyZ@XtI7URH@-i7B|%z~b+ihSl8hR-|x+P&glo
z{exV%R#jN`G<PFGoWLrOLV<rQ6tXkqQPxFlT5PE3B5WUy^Ij3UF%!0yjae(=SH`hd
z^W2Lm-qEEbG+vBaDaPH~#;y#@=$9x}mw+^u+PxC>^%9WA($X*0@hsI%EG2AKmm2hy
zf;5)#dMQz~jO@u9MJW5>SY}aOX46+@cdrbju_&VDPWt5_jrDn~z^%F*q_KSNmHV!j
zgEUrvenp^XMKDNXRab=fRYcsYh+GG0tjZYu%4tUyyhSBQV<q)fCf}<}S+AstRx$Le
z(mbm&605SRt8)6P^6pg?tXCC@R+s2kmw8rKBvw~dSJ(7a*WIf=wq9K?TGOas)8tvx
zoLJLZUDIwY*mAz+%z90yXl<8%ZI5T|g~Zz4>e~Lk+QECZm)C1AKGkBfDab{aj3m~L
zRo6{eXCLaWo6^rMT&bH&l&YoH95#g?cnBRkQTvuD(7dAA;iQJy^jDdv(&ctMiY#VF
zJ93<7R?o~3g=cGwX1(4}*jkue4+FhcsPGDf?U6P72CC<b=E}w&)tU8zDD2+a@M|j1
zx+i=|8!n4thtCn-TEovE=(T6<*F}D85}bvFPN&x=M;*n|kKKi8MzGLk8|)?vOSTJ~
zzSm%efCQhzF?-+-*6^Q94sjJD(eQfwY$LR|V`eEI?T^*yZ#>-H01??yjz?pZnv66h
z4)1Av+lLXeIq7r%q;*Uo+pLMNL35y2b8u2~C;%n>%@OyT0VM(BJuwC?v0g24Ni7LA
zEnvbY`F=~vMhgf@G7MVNyjnAoTC-|ebNXBJ9^P*)*k~;hYb!BmD+`C~C~Z|WZ8iOE
zb@$tjZM4;kwKp2HH+i);C$+cMfR&#1j{EIrHrhMIPIVca>hU_oNiV-pa|+4Z*nj`j
z<&9HJv5sMbj#00UYe^mP{RHu4F1F}~F`L#umpbMQPCI6^qxkCQYfgg+pNC2O6C0(I
zNflG=+n#!fc(IH9vB7WcA@p2KdO#cg^cH@_E~#w5uQbBv&@S*MoKG_zN7*CjoFwvH
zjQ^dAz^0hchYjAUJp!K%a#(MOlh_5m8Sqgy%K62!1Z{ag_QG7>`4RuL*A3p!Kr$r#
z7w`Z8!^RdYXq(#GhX5NB&^~P`nna9%o*G!7#Kd+UPALoxOVQoo3Y5{#&inQBT*SqV
zfo@tv1c(B&$z-apZvwC}0d*6wJ^A>=0f7^6F9B0ja0rky1H`c}DCkgBbh@6do2%=7
zB5^lApPq-u0T-A3Mn+!t4j};n30hiCz?@`b8wh-Y`ugtSdynke6|AMTWwBOO1)60`
z;BAtZvlJFG08S}kVIvLoT@Jg<gv1RM6|I4eP+iRdz>N5W+{pcO6BDn92wGHBT3u`t
zCx=F4WEu~*Zp1#u5n6Fve6F^(1C|wUW=0JSrF(nFSX%k(=(spJM*8~2l1M(jesRDc
z4FpbJ-jN66viNxQ_V3RE;wTCwV$YsKRB8e+T3cHOXlpw%QcHk?%El(pc}Gx4Xo{U(
zIB*&!Cgr-j11oi2czDWz0~tX0<mGkH%j<w2HU3a?en7w>clQGnN~nuT7*Jv1@f1B3
zC%mQu05d=$EhcKBrsANkZU>rRAf*Ff31BdQoq#9~fG$!}WNRB^scppYy@yqlZGd)5
zLedy0wSaRgF|okL#-BiNNl45N4`&z{xB>$f)jxrt<8EUU!eErRxI_Yzma(yqk58<J
z$9@Y!fTh0wu3Zs3b~sWTfi%k*XvsajA{`t;fi8=cWjpXTT3CQT(}Q~g6YT7QEiC-c
zB%SjQhyiZL)YNhx%P0eVuYB*~%&f`)mn19o-TQZ?1UMxo9m+nNe6B6_RB>coaq+QG
zi#SiO{p_%2O=JTEDRdw1I&dHhG!G@jNn2QmVyda`6zo@r$J+xM1P~VhW`MeB$N_j}
z2f{)Cxh2I`$w^xQ)@5sF1b7<&S|AtX<DLU>8t55rS9SZ{LQFqg4VsNM7D;I-P2CL*
zex603f*2KE4v^T9q+@`MJ$tnr9(ph=I3D!+K)DX|0P%Paz^G!Ey8x^Lz#|$VV)g&W
zP3_dcEK&OHf-=XUQ_<1ZzunXpMs2?uXry5yg7y~ha4fL-TLbN=jUaQbUEtG01kvJ|
zYsX)}V@m_#bUMTOw0FHLq$EnHY$)l+-5xZz3T$e=MB6JQnw2J7#>{dq5cSx%7?7pQ
zXR9D$E=+SO1<4Sj^LI#tb^0rIVZrt3Gr$F9v2N8OoL#?zd#}j1*P-dE5-E-25no<j
z%l7{M)f#F@eOfw1Bv1JSG`yVAydy<0?EeBbi@z6iTpEaP$>%w;`G32cZefWf-3nCl
z*O$srdX^>E<sxEcSN0DLNGqJBbtm+BJ^=~YgJj5m2OitEUk44eEjKlLx@>W&OK{sC
z6+T;TYIb|%FBjDRssXY1W?D}Tunw){lMoAqGt9_T&K!#*-$sn1%A1ov9g8hfQvKg5
zV2)+9dvP>Y7#zn4R<(x*1f1#LW^m@(=705o>@Dle>1k*i`Ew$eyInWneHXhvyVEJG
z*LX*fqyoCl+(;)-xpL5MK(vR0YX{tFK$at+qvLXY&y)LQ?_3aCah@sQJ;y=2#FFS#
zeED%orOeSOhafhqp~viz<P^CkGP%CQ`;^JgulKBWPbhpz^A0dm;~nI9wD?jpV7#_u
z3|lNAzjIsk`?r2=Q}mKvmIelV2~ZDFGX>|K)N4OPCxC=;O9LV%S`W=y-72HOnhBF9
zc)D$JpCD#t-u005aJ5Bf{8NZI3oX`nARB!ak@1+seITDLL2N^_fO!H02j`1r#O%5c
z<y<9sbNds>;OcfCa)}ZC8j2q`W6epu!37Ccm_fQ2Q6D;!i$^EQl+D?076mCsES=}{
zhl`>}`aV#Gh<@HI#EFrhAw>>~P*I{P6e<}LwD_p*@gc*qx5JM5PL0qPF!5t7&-Qd&
zXKLl=LBxKS(h05-v#1?xcu}0Cny+Hih@=a4&P=561xS#T7sW6+#2_49;!p>k1G!h6
zGQ#3v#5XEhO+&IkGc2M;0jzr9@((X=)n4=$xSTs37STA^2^Gi)a^~pZN`{(zmSj?F
ztyqOuNQGrZ(u#6eeey~c6_}N85Fj|Kn8OA(L&#O7ZsQYT5N3#xiS_2FP3#bgmj;Qk
z&6x6LEVJ`P)w7`5#D(#AEYwMjOsAnFHx`lDx_WdtElnH;XG=yQG23T`c(J$)SBT1Y
zvT6t!!$k4tK@pF6c}!QyMk^6B+m+33V0mN6&;4OJdQ;ZCg;T1@!vL-rRE92l3B*c3
z2=DGCae-GRNh<^wE((cos7EL-(a_NZrjWs6PT*uTZmLKYrqI$TliLx!oD8ha5Cex_
z#7ZtQxF)Eq6oGoIug4JoTtenfiVC0L>ybmvL|At*u-Hzt$-HMAj*J{FN*m4AQ*|Om
ziM=S4bbL$@?s7=)(UxO@$b5I|^XNaQQMXi)n9-(9h-+q%1C3*_6FX7pWFp4SgN|)n
zf?Qh>96NgH$Q8hN#_Vh6<gB>inT$O?WSDaSt>!^ODwvTtqNpRBRftp-r6KNM0-`Ho
z5p(*y;vTAIi^GI+aePh@!+%+soW@S$RG7nA9%Yx$o8|QXfrRv}hL!72(nO+YI93`$
z96OuIUN3_goEc)Rpr*6osi@1ZiSQD*Q5J~8v8|~Xi4d4AxseSLq4Q$#$em+g#=;7L
zsxL}c^zrA`9Rn;Vs)nCPM5)+L<L<c8j>G5W9^0v~T}>o6zSWVX45*Q`Y)hw+#O@cd
zIm&CD9LC8gXlxB-48GbJn;z0AGJ(irLuJ9~G-6z%ARU(_M)(YbkX|GsVrU5O-iGaL
zh*7S31e&NbjFB#SDbxzn(IPmm(@JRwwW4&LgnAx0VTAk6HHk%gG(lxnA^fn@Ff0{#
zS>)V)%T;gqhsEd>Zp1^(`a51EKbncvj4~BS_JXWNSkZBO6J#=*%@1Y<w1zmOY(3t8
z^E8VTSY3V5OvC5|>|-xV7mCCoBsdvoSnn;}j{^IWY7l~INaVV6=NW3g7^B-NQVd6^
z$m|^zrw)+<O`M)Ll`BhpD=H7Ev-?BkzqqNnyQ{9-z0|5*pA2>AuDLt;Qg>i|^JY}@
zwEHu=R|enq^2beeANw}>%2@V=MhbUNJ*)j|0$amOmP0K4;i=aah8wd*1wBoQ_HS&w
zH|8<}be!H7^E&L=xK+=6zSYwHtyAsBe5=FxcK6-I)VwC)j+9$s0Us1%mpD{9n-3m`
ze!{|Uy<GeLJl~mV|2{xmobtLVu(mDweX!y8doxod%_n|p`%}K(UvRLC=(_nK@=)yz
z=6hU6ob<<-S}=IwaIydH&5v;d-yba%=!LW^eM)-p{qfq=#mnDre!3ak@C4%N1r4;N
zLWzb&?5^Hn;i;tz!@<WF6MIJ$9hP&ve>@YJ?!BfrwOsHd@V*pJ-`G~~uJ*?ZrOjP^
z6Yf(h6`L=fs2BE4hDZq&-AX1O?FY$_sn5s0|4xQ{lU!~P|M}W#SO47Sh|ebtf4-p<
z_RqKcb28-1nL|H+Cqo>*cGdoTAG&Mc{@tms7Y2TQh$<X-_{!m1|KF1#-!6au`H99e
zxTxB-uX}&c5~fk_necSN9>WM<_6AXsz}dA_qsz+;`XVp&rq`!xl^-6P=6r3cQ9WBK
zrP*w<lj^j2RKMrxhmOnw?Io%2?_5G~`)CL<(e3N~fzcp~Xe3Dsq8Y?upgJWi=NX%#
zot&e={@;F@(l&)yIFH~YA&8BrS;T^S@ueP&L#>|cPJ6%;sE3{v-e4skh8A6dV+h#G
zt?EDL1y~{e!5yUjKUmU<RNMt9?n_HjuqF+iKm)}yFzLy;K;vGc!J%p&C@{YWT_}Mr
zk`QlRNtamomt=@S0z>I{GGu|FzV<K45JFX|L2s(jLaOnYjQCnAnUH4Y@gI^QN@*mI
ze@%uc39Ba@@&E715RV}JRC+F)>4f0%w3L-<$aG%wihG?{a+fdpH7|&WsPblI{5=`M
z@hcf3gJs41^Mfz~JP02F55gHBMz5~ssvz$MlIlhTi?wNv?P_j7hzlNam6e?cx<Mvn
z67Zk^ZwkoC>+1#?lY#fe*vi@%yi9@x3h+$2i(;az<k(ZKrmW<os^X}=-PP8P3?ky%
z_z=R5J+iV+L{sv&X%5G&=VEv8!fd2x4nB5(3Ku*VgSTSvEkH7`1&_KXa}~iGucL!r
zcg>F8+U<M%%(tt#%E_85D_e(#9FC9Ap`}#$`Nab>JCN5J8+%7aGQ2!u!12$;r47DK
zD3q|KgKeg!ezvwj;F~Kuz0tui$lg9I*gBq~wFi92fUm#Jc@+5l{y+84f3~z2qO1P0
zwEsI#U=Ha*U;n`1rOQ`3OqfmPBfzT!EbU{alUtVdMv+^<(!S+Ydi40X_!Hn&`j4K#
zKQ}*WL4UWj8!1x!N77+go4Wtes}$6SR^KyG_t*Eq-ycNTC2f8^h*~G%dUSp-RQ&Bh
zH2gnmmHvaJ-Q!HgFo=$;$1YHxUoHCUMYKRyeXqhsuhXlWzr0F+e-Yid`|3{To?kDb
zV4`A6YVvKzrzaQ0zU%5F&pv;aomNZ!n5(b+>YAu&(uW^}rQ5>jpes|CzK6pdoDf#;
za<bC$i;-g1bl;++PfO3Q3oY`S$F7@y@S7{#_U-HCne7$TwwtcyC>6xl5P^gp@~w-h
zu+vGVBB$~26LpkZqnR$Zg_TQss*e>1-~Fsst4t|l^KH8CP6Dmck|Twlhfm5H&gt-g
zNoejKCMlmO(fI&@wZjc@5*4!9H<4UK7-b@>)HcR_I^s2dDeR(+<z%EqWfeJDEQ}~%
zB|3>ae4B+%I=Iv@Ol3sfVo}w>jcmcvdl`4gjuwkuuGJxY$RQ;@LU~Bl4@hN1PAD(-
zwR&Me5L(`diXLuEr}e%-NcZAho66oS-9|{@n25^shuKPzHSIAiC~gn@P-RA|LDp&V
z{r<PPoU0SeGfXE2<M3z=Huv1d?$C(NN!@qve|rLzhs{2mACSoU50-W*^MHY+YpS3A
zyQTfdC;lx>Ah5Lm(geO=8u^>0eR&gj0`u_vVxP}P{F23PS=wXlC604?Au;Wf<t)NI
z?^h;uN>?Ip5?*zDo-*3<1a|(!{=*Zf<FBNC+A7y!%M<8wcP{p~EcS1nz^@B||Kth$
z@by8|fAR#T2}iCy%~IU*1peiU)yLm)h+O}pD&)-i%ewfF|3|La69*2gOzM65@p;Bl
z<LBx>T(P_x<2!w~N$@c@zrCp3|L6Ma7EnMm**X5_cQP;Mk@D|1H41)wt&}DI+2@g+
z^*x`tZPQM(#TMHMp~_ew{xMD=h)B!yz@hRHLu^}?_V*54;YCB-NlU3X&IYWd)i7TT
zkj2_Hu)B{93-$j`ve;j)*l3OW2911`W1|WN%h{B?Mu8Tqt14d0IUbXZLKnxbssl?q
z^?!B6%1LoSc$)FXav_bgX=}xgEH+oP{+)>AjQZt@EfQ$@DHVmVuvjUnnhf0bp@n81
zzS3D*Z}#GcLD)E@W~Hod^@XxKn~g(oeOX6dklcsmA}1qSIL{1|1<AbOyRlNq<ZQ-g
zT2BTD-Aa*yNUUh)WU#^K>Y2P|ofhkx;cnd;3S-T>7su@**~zu(&?~)*qS8WDH0ZTm
zi^1LTskr{nN0;(ijKuvJp9G0$%vg)@x5R1EV(D>+tCh%VLt%W>D8zoS#T-39b1hM&
z0nQIKlq0C;JU-RXmC$Ooy+NLVM*jQy8Tj$3t-Te00@}aVZ$5&bqu-`Dw6uT@(3WUo
zrLE%tAQ6Zsg}BQ5?B0_UNqYD0U3A0&U0sLS*=aR36L&K9Xr@j=LgMph&+6+Ny1Tn(
zyR^kb<xNx|pcwqLwDkSQ_nPX)jx!x)hxpbvzN#pj^z~kR_i<fOQRQN-oTQXSkgt6z
zoh~b*uco5oWWDqJ#o-+~1{&&SVxlTt=gzKvUMfqcs;QbEN;>T3;=a22d7G5>`}gm{
zLn8J@B!=!y*3+XXD^f1ip?_Zk;1sYV8h{`9AiD)}P@v@YWs(ErtUwwHpsTMp!S9Y;
zN5>w}MjdTCkOTui*FoqDWX3>943Jh3;sP-<7guXQyL9z-fgqWZk|_v}0S>!1D>KBr
zqOM^D5@>*VNlB4F4h;mu)YKh7gbaXJz-IvtTb+^z*)zbxKr#)mGY~%m8MD+x=cDOj
z0K9_JK}pH%cZy71-8$6ITv*spLfi!KTySJ);2k#avQZq(Ma6c4_?hZ<8zohH08+t`
zp{`*O5_%Z$RuCHl9!Ee1MMaFtGVFYP<Dz%t40ZJw$@PE{13n9~ZSwLK4h|sz<5DQ$
z&QANhy$^y+8eU^7oCe}#3Gq3AhuYhRlF5El|3tkVZh-u1X*mLXslMGlDvAMUvWG{E
zxa1brG$xb4Ed{tRfXHg9_9;h-R8?)bxV58W(gOnGL9`6eVK=u(Gc!LBHq+5@2KNfU
z(BJ}-leGk76U(Z>U=#z&3=Szb58H@+sQ~<0T5jdyjwIGysMYLD?gFsbNjC^Y)Bx)Q
z*H}g5aR7(`-VJb01V9$tTQ)XiKxw_bqbvyiVPOn#v;jDqc%TL_O~5(<<pfL<&`$sj
z!9lh!JP9CgaKM2m8aUtp6b5G>;GTexf)fo;QE=V?ND7WQaJT)>sVWoBK-6NPobTYj
zub&k`&`vzWJ1U*syft$*oF@NQs>(bobA(GUT7|2wv*&mH3>*=vwpu~~YfJc1iqzTA
zTkV2M0o!feR1fzZwf$CKjf2!RLp70EX&l@_Upj1mr>X|>ckq>BC2=-s#O0Bz!dI*E
zzfMf9zv!B(FIMq#++&%cr5N!7qUrU#o9gD|I}B1)9~cD&0$C7ogat!rs_L^J><#e8
z6pQ;gbi<}v+#Hg0N<AxvQ-^^QnHn7U_GxkC_~ty8hR$VG4xEH>#KG_1T#qo1Ys@Rq
zgpE|H;3X1s+lGofYH=%7RYX%eyhK8BIA|ge9C9>}eEwBGbCYL7pgS$iGjPY!s9ACW
zx&e0nX+xITY8U>+&G=XS?4KZG(=IYL`bCMI?wc2-KE<d%{z*9h3o<G&K&nbZ%i@29
zjQ>}z;eS9zuk%>h+=bURXP7Li|0)}{zF}R~d;gu=tzpl7-3!6q{+Ro5xv$SZ&QSf>
z`{I{y-U5B5^Y)oq^^=O1e;pBr#Ff9kRK3+Lz}8h%R_j~;31oHhLir!B*hYBkv{Uz5
zu~-V2j&ds}zaPa45|>^7jO-{IP*#3+?gTy}eR)i&#ZG-#<)YCXpDk9dfPk8PuT>B>
zDb&JegPmvI)QRIPo?$(yslb|cu(*8gQw{@`KMDtOLu+DXIb=t}CiZfaQs52KOr@(m
z$NWoO;^O<W0(BrKvMl8edgn8ER9%YK<t~)GdzOXYag%sU`;7e4nFSSIhtj8P(kaEy
zvb}*pZ651-o_Iweu%{YU7PcXu!<0}IkL^)1w@cuNbtA#}SjH3NxfCQ>tS(~y`2j5{
zxrgkhxtJRJD!7?%IA;G$%I^_A7>Bw#y{c_KeyW@ss#ZJrg*a>6bcocuZB-PC*@lk)
z`mEf}QB-CftjZ@Cnf-}{*6fFtp56QC_E}3gWo$)rwt(<6)H9EApBGV2JR@9;!3G|H
zN9xk&^!T6Hn?;G?q%5RDx`E_XX4cR~6ROuvg-<6zke`_m0xxn2k}2)ZLTQYebX}5@
z+TMVXf$*j`c++T@A%AOP0zCbb5xF#!M%k=eOrzKFgjz*l`AYun5pk)6zWtw$h`G@4
zV7n7ycgL>j_Alp0<(-gtWp%wgwzD9iu5fH+?7Hy=Z$bQz6Tgp$e-X|X<u%DET94a!
zZ5<I!3VP$?4oNGe^_(Y_EUhP;zzxxAcT&Z*t;w~2rMxrmq*{pe4X^tv6}^)u)#Jzi
z<%SUZTs3CbtW`Na8GK*Mcj~Vj!s~O*!sONsaWgWhv{vv(GvT`RR7}n1y8m)Ryt1B7
zy8rpu+9bFk#y6)^Ha`D#M9eV6R_n3$tz_YenGAzfa74V$3&qXmcmYg%v(-XxVzwY@
z^#qQq&C1eduB2wQNy)y=#(iS0qJQ-yKEKT_#K1adZnc?k6Nu3!ZXMfLZ6R{CQ!;Jl
z8^yk~TG_WdRZh$wAa%D<^4neVH)w4WX_;;}RZc{--#(M{<<zrw7LV&TcU(mqJJR)K
zyzKc%>u{RChCb8tZW3P$Tbd|$w71#Ia9C+ZP(DFE%g2l_y-1~q@IDpGxeY0qy7c8N
zZ?%-Y6bCdx{@SG>Ll4q?S1uj(wY#3{bf~56{kfX2J+1bq!^2!}-|qi<zBB)HM2PK!
z`<wT_Ug*7fIx_yogU1_RFEY8#L}h-zafk0)@0k6Wn93UuUmASto5?>D+hY6Zt=Bgo
zMmrOC@y4T%N#6z*xy~kBw|%@)^KJ0L4)vtFHy(fO|8{99|7`Lr+Xn)5MVHrZo=tH+
zl=`zm5A!D%-uQTu^c7<?6L~BE;_hBVyI&moBORY8Z{*9Kdv}<7sxzZj&a7Nyfhn#U
zVaf?%6ny@Glyr$?;(J-4kf3gHxAu^9gFP<^@13~U_)$li?wAbqT9~Aa$qSS|KUqYz
zF~4Jzug@Qt-nwI4sBhU-jfiU!eS6Mw>Tdp3FJb-z*_eFf=Z4-Nu=0tf>rY79?voD{
z>F1Q#4`$Ad*VQDSq(T3D9-_b-bk?soXh}&EaK`~3w3L(yxI4COGm(-s0jHw41W7}~
z8XS)r8aCXp5jQVM8fT2dnc#3+R|9UFiJ*{)xVWLFrZryEMqI)eOay>SN=L^=PTp2f
z$QV3fYin66Dw^x;u$J0JmX|l3Kg%g7Xv8mIASOYAd5yM78A}M`S=e^+^6gZR(SLaf
z#lvgD%WuB91S!jCCHjeNzJkU&b`;PZ4fTvS9}8bT%I$8B>#pAw<|xX}X(}tF$uD3c
zEvhOdp|7H#d#c*4HdU6L(}au1G?^+WAV^;5mf+<lX=<42>e`Bl5w~qKmX<cIt8Ebw
z-~+dqk^)Ig+*ob9t+I-Zg0h_^-V(2AtGRU)JF2Q#16j6+h~YLV6JZe(Jzbj@BYIR@
z(e3Ki^e}N&4s!uPW3X%h!sSYe=6<eZJsqMy703at3gU!4D9)bF&T+BX(NPS8?UEK|
zyOoq}lvN#6RBck}75^W1ZynYI-~Wq`ZW!G#Mt4d`ZFF~|NJ)tZNDIiw(W67UyBkSC
zLO@EzrbHA2P!v$y`RE<beLv@U?(@B_^T+vJzyEe^e{9$O*k12fii_)CyNZ&KGS*hV
z%*m=36p(CTVH_L`e$yaVysm=M)ST=}2M34BiY87@wm|=sj`nU&Zo|pRJ6`Sy=_zGR
zP0fsq481)===j2d{7Tf#Y*tp*#85R2ga?@9=3qn0$(xEx7zhdJNJ;5}?QanwgrbtH
zq?DeYyFOCI4XJXO3$6u16*5v*q9R)76|K}2&nd~uvoouxD{CPUrl8M3PELlO#{>Xv
zUQQWDT{;~_VQ?<!DDnc(4MvUu7grd?S%qeIwA0BBXFZtZ;AGXYHr8y-lN~98ewgOh
zP(gCBYkN3bDatuvpF*GYFkW@DZ^w`e@d3|(I_jDVK-pb|eAd=}$v5O91AZ3Q@^a}(
zidq{RdrnrvijwuxBh|X|pt`!Qoh6#UzyJ{Ol`A)0U2gz9yU;GYH40zqJ+Gu>D<N(S
zm^x6-DtGR(jEtG6h*9LtbQ&5tLPAkSHYET#0k@XtTLw^PccB<Lr9@>w9YVy0jYAax
zLjWOxEdc;V04@I!9#Y|XJe&4&L7sDELc5l^S8<3zCH}*9_wBW%7!(OUE|bK%DJ%~c
zFO#w@O4HK}$2jOu)BR75$!&^+-sblH;kH2n&@<8yzQ`zhvO+UkU*S<)TnjQqiKfNw
z)|Vr{+6mSg9C*U1{AHq|)!WY5TTP(M)zs`DFzDjt&G^DzL8o0x6O+E*+X)PrNXF_2
z<RVWpv<zryCPYZK9&C+Wh7vrZT<`F(>k+hiLdx_U6YZ$mRH<KTG&FD&&%#v(JxXSP
z(g(!zVsE%i^di>p&9EsRiP+a)c6uTuZn!%Tk(BUZ@8$iM!Z<?Q5Q%tZei2Cx3YqK;
z1pWv??->0OrqfX7Np`0m1LvGO6pHs|QSIh$?F2PnaFIAr2qEj>F-(nAZO#{;N{Yu9
z5rZ2ZHN*dmxN1(+(zT7vlZal@luxAFd^0odJ<2>1GB>uJT{jlBsKu1Ojzg$3Y7&d5
zw^p|lIwm?r#6O2IxyMf6A<2{DdspyvQ9#E;20oFi^Bqb#3&>cii?dY?gw<k6Q`kBd
z#*z^zE40XyrX}<yGuhOHoKh0H1c}ism#Y%qfh>}7uo6%0R@K!stS~h6yajuc`&bNA
z8=q%UjZ$nEfud#0c=M3Zs)-9D&L(hL(>Tr7_^v}DLIC4nz5GN2+FA5qDYS4YE>3)|
zu44w`!!-)&WZ*@7=-(}QYMNxm6J^y3L13C8#jZ{XEG6O4BnTs28IHbAjqv^`{#3sY
zBx+n3Lr6?#0>NdK7}H>6ro$i!LwIG7W8x8G2UD=dp#5$F<?^u^fm$}lX_4M{hxa6=
zL_W>QJo5hZ7mDeZ2Ccz(_4ASrfAi;M1G)E~S4@6VOh&BgM-QY@qXUuiO{?eBFPSIK
z890f%&Kq3qYCn4NEypnHspOsKW*pv+hF(4n>Sfax3H^$_2p5i2jn(3g-KLRW3gJ}Q
zKNl%aLn7rNAa>H>PnLR@v&=wBZ!?Q~&-JzXNTxQODVv(!cG=)*=v%~y8VNiafjh~Y
z)A_<*x;p`V<AdUcj|_|dsM!oG9WgfeewzP2{Z^&~4Vvp}n}6!zs`W=}vBXtLB3Ru1
z)w8ebm*~mBx7#sw5M9ps<5Wk^<=i*r5p3rvo*yOl?9&$5%{}@g9^m|gHRC(3&L}R+
zeiX4m8E&=KNUjWqmukCE|Jj$(SxsLQ6Ih&-n+8JYA|=P~6cbH69^bzxCQ0Om=R55-
zvT+Gt+1urg5>Ytpr;EH+ebHbycQc-Iz#v{rgqS7^z(cEA5~GyOj?Wu3;&k}<W^)w_
z@Uq`Irmg-K33}-A8%j2P9ArE$1P^@>uMiI4AyXfY&t!@ylAHbO^wi#Zd%E~4_b+$|
z*T+DSJVf+wph&4@3?UMqhyRU$u9;bAUcC+<y&8nm=wqhE0f$lc#0an6tE{rv#|%w%
z>J~<N*-RvsLZNOmx%er<4Ilu@!i6~{-loZ80+CD_14W049D)O0<XtOjR}PH=rkT4U
zo}TnJv$1SslFv1Y-avg+%wePQXhG^tLvt8U5z_%5ta*C&7FR{?SKSz30VhE5jKhSX
z=<85iEU)W!Ih8bu1|pDwf%n9gF}6?0P)ASZTjG{{)g4EanM1V&CJG+G2#mVir~`$r
zhp|~Eo@YFjLOV}VF(EyXjxZC*>g$sE+r;Ooq(%$$G%6vGyE;V9=83DY@P|CxM*O(?
zaJH%|AYE@lVa7R3j|<UPCT13=v0Oo;s>B*K5<QNgE-Vv`R;IDmsY~W5ba;*OD{rSR
zD6G15Si-LHx+7O-9`;lOx_J#XIyAeOwbX63-k|VSKO7()6B47{$z<W7t1xT)zS^d6
z<u!6~iAI=Mqa!0}+?n8T%`OE8;ukW_32W@jHkn8zk`(Qb`IdJPV`Zycl*GTljS0qX
zH#Ojfdg))PpiER!gQYkUi#Q0g3!UF)BTsyPUp6_Tibl>iuU~tqD3CtxJWt>KR10~S
zvu(wzOqf(%k~m>zyuT}>+jKWEU8>gOJa0V66ZzH#jrB}JT*o2Gv1`a|{T55#I7WzL
zd^nN8I_~{9O@u~m(Y$d_2^5dVplNNf{01AO_fsku06dhN+n^k&Y9|+LOwcyiq`7rG
zAz;*=WIeaZFnByEk?X7EY_P==LtR6P)0ld7ZjSxi@f3pcFkl<D4QD->)-mb;v$)%+
z{<0a9G%0dbR{mJMlUbXEj@;h4S1Y?VaM%YaJ8S-YzodWDpwl{wY;W7g<%cdreU~Z;
zJYH4)c5>f5nY-+Se-{}eRuym5Rlzv#5hv5PWcHolrv{C3>Ri5pM^Ga-|HkM>82{{X
z*B=^mm61q;b%bt9$LWK%wC*N%Lovwm>BGK-?v~*BJ%?|nk47nbe$$}8txX&CbmYzd
zra`Cmbk!QZ_p%2X^g>Th?@tZ-+tYQ*-o7cr|6PObz5UwouNrjZw{L%F(9x{l|D{2H
z-+*cd!{C3{pl^KNg8c^#dhq)ziJuy@j~uaY#ttuTSu<D1_2|!S36O2^1uX77>T}4h
z&g=Y=H?g}_iV>d5*thCFBoGND{7$O$)0N%@pg})taiIFP$U%|eiavXXydm>g^w70S
z{}qiq2l{KYCv_+AANYJFtD0thU=EGF<qLsO;H%+g-CUThmCQu0T4Cs8W2Q|AAhH6^
z7M)bwA8n9I2D30sDCI;QRo-${+6#<3xdziX6Z#5CdT4zUJ7g21sQ>Q8Y2ob>*o(o4
z_sGxj&(j5nhN*`46O6xavSN>?jfW5O?tkC8AHKPeKK!{Bv=i84PuK1bf9bt{_TdKh
z+d9<<_IS$p$KfsP_uVPj=au_Ez6@f|_R~kczc$7?wT}EazCZHg>wWBxZ&)mZDGCg-
z;@d<K{+kB<(@Kw`vq62mE5wkGvMvwA*9lXj4QA1S7Bc>9Cjc5WHjhxCFIs+sROC3C
z!P-M2pVmtzMt055@s*cwc?`u;fE;KiIEJ>2(SPMf-Jy@w5eUN7a+H?vs+r;}-(lP$
z2$yIlr==#RZx6#EgiJ*tA6l}1?B>~t6X`@y8xk`W<w5hNIC*^WDcfT&WW>u!$4jjQ
zElY-2;Dptd<AE+=ShOQ4bv!YbDa1FPj4L6_jBI%<AsI~_cZrcYT8GzIhc-(fq#lJ{
zcA_FdCE!uxiJK<Ul}ATNI*?8z;%_9@)5JBaB_TTFg;2pak?5?$iy|%w_6KP4jnHD+
z#B&*8G#d%xPDvy<XoDDBhK*!Vu4F2wWV*lV+9VJ>Nbv7B7Xabl>;eZDxVFGa#m0_c
zV*?kH3b?jd*%09VVr5n4<V1i&gOO2{7OKF)iezR{VrN$&CP#vB7bUflfPewGZUo^H
z^bE>yE(AD*z>Om&q62OgIYCY)dMRdRWjY2mUTy?EoiZ@fa&aMPXc6QT3aso%E)E?j
zA!P}E5o%floKsC!kei1`+sn(dsHm{2s>05~&{S8YK7mXXA?0XmX{@E<?s3uIQ-_z!
zDCruV0Ivl%hat*WCfT1YK0Yotry@J6A~rS}g$mQv^i)-Jw6U>?Pl(FMOmcNZ#m2-2
z1;mHl@XgN7v$qXQOG|ZjvB}IRadL7F56dnutBgiv)z(%Q6cl7<XD1~khJ_?%WTXbU
z%4S9DBm^qK*z`2D<bj&sfZ=ONr)<vE1c!;TvO;Ih&wJ$OVWOjHV5mA&3<uQyopO$q
z2He?Zp^YKlg-!(^1xSejdLCq>bwEcPI1_+dpsPS!O;z)v4l_5K1oj;S`<(VxG}n`E
z=KUFX*d@l_PD^m&fr}Dcso?hf|CAj6|C<l<k2e<+fyXm>$F2XkJYgKRI*k}NNR|9o
z(3zBd;L{F@iIMWzg*sH-ujL7#>w7KMaJ&1ojpC&y(n>e~3OfJv{Yrh7N8rW5{9*DY
zr|sUksNe^`2c01z^4kIxcS$9D&9-6XWn$}7zhwQ#ue5NP<`$_t`3#E5sn3(z<X1>d
zlV$SeJIoIpEvAx@$I44XCt|45$jp3yE>FB1HRZ6`rA8&u$nA_WEsY|4q6MOV-dth(
zgcR;HA^XvB$+%9<$v=I+;g+g=kM;H)iJ~Zo@RbUGHNq8DGYi3v*UPkV*>+(VD1Fq|
zXA#7*78=pyFM3~U*ig$nGa!^$ze6D!%XcY;EogTmfx%Ed3s(TKh=aR<`sw@a=v%_a
z6<I{!5RZm9CId>|B~(td`)ANu_p!%c8sUCY^1pn)7FM3Ga%}$e{W`|~9&|47sHxv6
z^zM1HbITWaTZ#g_m=Tb`oyY5>mM=nUOQHzh=9Na0dhM3GQJ?Zxq{x!yR3x7ldQ+u@
zWD%^+cWcP34)J>XrWWq^M6j+ZS16;prl!G59n<pmZ6nb|Ea_fT*F&$pW|E5dy_VZw
z-tM)Io=&>AO)y+}*Z%9~`j@W1YIWs(_nKSd@4CMGn}&+Mcn%4+zNZcdv4M9zdmjdo
zD)J`e`wy>t96H`fUK%+4viEUB<Zv&0RERnSGseL6E^C}l(wh?(qAhY@M46y?Fezx6
za&Y&F*WAyW>#g5US^p5+Tuq0wW<MZ%(_c21s_u!%>3u@TDavS3(H|&f-=|A8{j^9s
zV<5AHuy_BwG`--7SyX&=nFgPUcm8v$Aq+ndso%QVt#Rp6^QB6s&R7kL@RHOIRH_gh
z#DX)c2C=S2pM{)`RjEcoc?cagW0GD&CPQx8SCyws^D<}GkzTUBOkZP&g=8$bjm|;H
zGbrzH)()?qgAmjq0Hv{&pXXpkWju$`*r@4E%V5>h;JQQS<*nGXck|6b9IXi^gJGzz
zGx-jUy$MR)Xbnkl8+pig33L1516a;SvJ9sowN;{<P+Bb;<Q>Wz`GjXk3iRmqdr46z
zYDS{VoZ%dHzLIzp+I`nv;(O1UK)>My9<b8SgsC$_ASy$ji6F0O&|Y+#x77={;3kOa
zg9f@`l!b&m<2&e&Wewc+IVy+@WR#A_c?5QO-;4Zsk<4No4;|YUORf<8MP(I%KQ_wm
zWP_%G?8hf+U=nDz%gwQ2Yfw1l1ey|Ap_VP6ks+~^NEiyIDGi|((#lA(O4&qq=s?A4
zCd0Y?94N>#5yqxeQPSV3nN|QLe^&knC4c@&yGY((B?q{<qRU!;>iTTD{6N?D_qeH4
z1!tW3P1pZP$qVwTnRU3@HtO(+Gi&GjnVA?>>T#%sb{UFIWK{u5-g;)%>fb5(%LXR(
zzftnxNxU&Y)|X1oyZbvO|GTVTIyvCE?3exUCnf**o`%1<<%9oD$<Gw3E&k6a`8o}L
zy}wcN!=A((|DBT8TPb|<kCc3vnYq-_FG{{v??HpzQG?BVgH`YBFG}8#qVXps-%)tf
z<YCxo_h|NE&%jZ$Z))R(*Lsfzo*cD=%r`oGoqaTXdej<4;ccr9v*FI6M#a6FC#Ai&
zcK3&#8<ByoJo~*YCp(^w?BWGN>3feC!oGA8YvOrmKds=o;M#F<k`H2`|75x?m*0pT
zO=m=d-;GsSATwFQg|xw-FW@|}WJ_1=-S?pNZ{qqO5@L`N2;_eEQTL4*-0K7t7a-)c
z1K0P30*E#*)LLx7eeBU56q(N-rtw_siy&c|8_ay)0Vw$)tB|cmhHJ}Te^K&Z@4ftS
z`gH^Xc(|W87whpTF}S%H=hg}Ta&y@qk2C##bKN+;1EXw5Yp1NNW&Zu<N^9@-;@@I<
zdVE)Yp*<~lZj0mB&DDWPFmPpl+WYI~GEJG|RXq85a~a>||BLVUay&=>J=_zi{HbRy
z^q8MF*C+j0iGp*GH*$of(btQpg<cmo$>}GwWm3g&x}DR$eA~0>j;5D==}@^j`75L`
zA%hee&2(NT)#rV2eYUzDA^yMkdlCp0z>?v=Jd%d6Geg*SBN$d6c4Q308o*8wd_9J+
zQzUPXF(-KP3m=yqz?*uUpM^y9kl-b*Zz95ahU{2Sb88^gq|DQ%CfEpE6e?VU#@uHB
zE`c^*V=gR!8~UtR9!?uztuQo18p^b&@bswi^_cLS8FFF`VOU^OP*YbC;d73?wwf9?
zpMhFXB;Qx!X|Yo7JICB9FO;Yz*s9No)n)r`2>+%+@y!5s3@|T98c9kD$D;jj+F~6P
z-q=X*S_@#c#adKpPH#G3EtPsS8IKWywW?IdrW{xuwi8XpQ$5ZjQ%-C_X@myDcQyW=
zp6UaC(=X-4od&S8=*Xn<yj3;cAt};F(T-S@12!3*cV}$E&tf|<c=}fI3mv`(M8uFx
zOj<&~T5lN^$vgD3H^)TE_X^tI7;9o7FDh(gY$`zsRpIBl0K#qiGjw;V_+zf}RVHv^
zx5;eHO#c~n{dbRK>a~CJNcQyh{qB(*9UH$hG5MQEa&CU%r$=&S^}(MW$(QRJ|Ll>3
z;F136k-RY7R(>bp|LBpdzGr-eXSzt?Q}z6<S8j`aqn)qgxaDI=pYv_#Wzv#n3N?>8
z0xY$}!y|yfLs{Yz;>&xGg3=flGkO>?LN+Q22fr`!;=La0wf4){`!!cVYfN+R<@pNB
zE4{6kEJL<Foay&T)Q`HpIy^Vm=f^t{_WFE@!3nkNWRCO|m4MLwo%@A~`h0VEU7l(c
zjHM3m<<9Lrx_R+ViJ`UZ`=<_9w_Ye)$bEb%8-d3;Y$kuO#h1!`iNj3c(`&Y3_0mYw
z^GAC$%`Purm?(bzNIVq7scNEh^6AH1<)u<%<!@g<KLeHrBbBpnZ{Kabykw+`#jYO{
ztw(9_!mJ$fsq5Cy<H9@cMnm~l9AimQi)*oTLUajEOm4eeHiY9j`R?~3kn?o)WuRn%
zy=50JAv#QqiGwVzS>i#~(cE5KaGi>jB5#~+AqqOr?X>6#`E6`wJ)0*_IuWTXOP0lt
zO;;{GtNP0VTmg?Sb5S9nuh8Z`o;9LORRwNbbQTgwe3jhLouYPMM}8tWoqzl-U%h&k
z;;0TdE&;1I0*4F!?!>L=rk9nrSSaDZy)xD+1hOhx;0b?0s`Fu4RT+mfA%WmKM}Znh
zk>q$qWQV0)9eIHhnng3b&C|7bykSq!Yr;{u^1dI=EZY%Vm_zGG59z(yLEHwR#v<9|
zx~^&uQjzX8tHHO;BxZGLJ)>=7ue;ZC_Yz6fibmh3@AO<r#OE>a#q0m@P%#nT1m7u^
zaQ4ZbI1kk{LW@B@ANqcTSPqUP6hm*|(GUjT+Mg)8ycmroviFdTC805Y*AAnSV2dZR
ztU|>Q3QV6IOpslAheLG%+O9z))S9wC?(n&6oX#b{32(mt$%Sj9rZ%W}QnTAp{_|>2
z$v#rqw5?At8hecTtYGzyP!xzZ2q8VY%llS*Xn=1FjreL*<C=)N3E*w_2W6ki4T^3)
z3rN2zHxxQ3Y>5+`@I1KxCQ;<k`Z~jc+-9QjW%-p9xyF!@4E|xcS2-^Fvg^t2VkfVN
zZnX4o6(>{fZI|B?Q+Si#7<qoLe(=Zn*Uk6D-t43kT^%gw%NzbyRJV2Z?R^`Ws#4h)
zS)|g(N#T*(xig$Uls=cSs-ER8sYjk+h8_(oXFcBgF@#OtNWZW2zWvsS>&aW|naFSJ
z)*qF=a|V^FoNeC|SN_2<d>@-kB{23h{ObrYfp63c;W8YmsL^kNz9@>W7kFGA5Zn?X
zN?Pv;JSLkld^cYNYs&g}mE%%q&?1TlA44LVulBuZF-8<D<3@BrSSK+EaW+$mYkg&G
zZ!ae(O>B@8;7!09e9`B-%BjC@-RY$BOEl2fq{<=IJeBc-7^mQOHuMz<yJaNrAHeCy
zra2@t4^-Tgw!)X|?tX1+Pu&aUX1jk~^Zoq6`9Qjt?B!Wg$`!Tgkvvo|JdzS5O{QYJ
z5>F6Kz0O;Sj*Rf^O=2$HB5kvd<jiL;d4&sf6@4<Xa=G8PeboeKUt&742NigQu2s%j
zF4W|-gj0yP^cUJLFU$1Ye&z08uRp)vk(YDAE5Xk_=OkN`e^-WFDoZ#2veb(BLU_%^
z3PHmGlg>i#em>ceiutQS)wf=Rlgi&w$o9*W7T8gGZMa;&kk{5(EE>wMWDUO`T2oc>
zMTtb^lWk_i;dP!L-`#a^g%;DHU1jVF0%~#<i*asM<&;Cj8r*gniDm(Ch9M6PsfMKl
z->yoE69FAY_;LncRTZByv7WgdCZ{6+CKlm|a28s*x!6^6)+cE6wS1*`r?OUMh{z<y
zF1?&4kV8w^ODVHqHCUp%{(Xp$#Uri<^);0ZR#;^st4_PLX8%AohchqvaiNFTFx^eh
z<%R8f%O7^TRW|z!X|Yc+S*K06w~)+lGak&E3@zuhGI_#DzmTqto_4o!^b0%lhOJG0
zv5d9(-U#p6waJ(5>4=XLagrQdy64|hQF11tr7rwr!ON<nn%9&6ImRyO!V-?~BC*%f
z>65h{D|q+0M2_IXr%wyN#D<}ouif0^-WbQDXo6XBZLdFk;kIpx4*cM&UZ}gZpsuqr
z85?kbdj3wudGLiMaR?_a?v8)Z?TxFRfmd(6$a2dhd3Uu{?`XjO<Skyymj?uqpOTZ$
z4j(c6I1?A8%*Vq6?ghL0)~GiJQBpGH5Ixh`V-mXC>!EW|_!4bV@p9xbkFA(EsfgRr
zn%_76oxo0OPjLqX_J0CXe<iT_0GN{P#Lce#pM|LAeF1;{8jxX2Ckr96vBjT2h6?c4
zQNLxV)L2g!(GH7^H1mJUP~CWZJ6CHa-b5|IOMnqx%D_r!F6pHnP{>=(p;>>wz{|ub
zjJ8!}qTXG4&uNtf(jKqbGUK;r_xVZCt%c7aW#2G}-^>(r03CqpB|>1P_$|<1o+_!T
zhFEEb0#pWqDFE>JyPkhNMs^DYUumZ*O_nN7lw59yu69yC?W3$n6@NcP_Pn2Zrhz--
z=J}dTae(3gmIHtdU^#@ks;ZhQKy<*Mse(lQhU);311Js-vr$&nM5v!Hj^zbdPFq_=
zUS3B}TSi@7y(vq&Ia9bTM+6|i3%2UbnL<sO!p&L2eB4$55UMJw0Za(YzAzXPBxy{|
zRJpj+MFgxRMQuz>Q~_25cuz<~7Z8&GE&^^6z(oT#EWmgGG*VF`!L+M^bTcr3K%t6A
z!A2#XHc?@1KtKX(EO3jkuqXm#1u!H4le};velBTIF*AAwux??Ag9{-hL(<YI1Cmly
z$QU#^s!*K*sL97=58f-z?;#tbcx?i8a_F4Dhn|V0Jb;?kR{8)*ii>J%Fr3N=@Bk#K
z0v|MnV^af|0nY5LJoYntAMedLQc5*i%9Rmq0LZ+VW^o%+b9AsOAoBnm1;n1hIS>HS
z=Y}JcVS@ma^73c`TnZ4Wrf?eorQ96W01yIP8s&fmXb>PwfF1!>1c($6oPbRPrV`*r
z0X`G}BY~R(0N3>)KEOT#><Y+8;CBEH2w;BzFcrW^5q@WYPI+OrfT{!pq^g>{rV0{x
zC;-+qFp&Xx6(CiBcmY!V33@eQfLH~-5?~Ytq%44=fa3&c77(rg$6m5T0Fw)FRRAap
zSV=&~0{aOtPyj&t&v5kr?W_Mt?9nIut--KrChPY=|GhkkzXx{Q7vxo9eg$^!nEW~Q
zAkB>UBe0WeQ31f{9}R{-iM_(u>K@Qw`1{nupACjaLXrPI_3#_9_m2&Rzb0jWH5iuK
z|7<Y)MeN1=`_u!4C*qfx0tEW6y!<uwU_42T4fmHIJN~rGTd4a#Y%rAF1%Vwcfj_4n
z>Netk5qtlddN_O)1&F<#-CIeJI^s$X!M>k?{@<n^{^GU$W9mUj;5l+xxgV3Af3(OG
zV&PE#N{zcs_D=4?Ws++33sIiHYpb^U%KJ)7;ss()zHCI1LDJ)loa}bZ+Q6U>1yxj$
z%RCdQJSGxjq^O-W^-{jGHXMB7Y>YtqX7lP8F4d?Bv?43ID;818FcF(fKn#t-6``Yx
zA}WsmtW|eD7t1mVk>o+(BI&wjsm1X{%jeQMC>NtiSeRm?Ti8=kc<Eycj^hYL$U1HZ
zZ@1HO3IU-o9<s@dwXTW6VDG*4+6Vqdy!&almg_{{uH)d*)Rn~#@Xtp(cP)CEAn~V2
zEkuTH)c7KBWg*_n!t%@OHO3*Nt8Ex%Hs}2bx>6F0$wa>B_EOW;_IO6tDFqLtYb?3j
z6wza+j@-beqMb>xl|-%I%oL;zDZl4+{;Qe7!usmb?|GdommMBCCW!v$yiT36!Pn;@
zubY>r!@gqQe|;H6BzC<1m%xrHq3#w&TkK>z+ZqIRqz+R54D2}c?NsEcgi<Qyx17Fh
z>iuxK*ES{g?Om7L>b3WMuUo!-xc&9Rw~ya4hM&D3WfVVmaF@UJ`{5iJZ}_K0qO<V7
z1a_VUe*|WV1o0oo|H|vU>;0&ryD}n<O+UDQ4SRO{8ki|mAKeEs9(fsr=r=P3?*Kh6
z<Mb%u`F#{Lr3{}x{~Xp7<aOp?deCx^*I5*2_+Ivxyv~44`M>fy`2vYc`|%_s8?I&v
zcQ{V>6A%WgTi9q~dUhI9;RcEMapH~%Znx@0BM{g*ap@Jz<i)j`gKG@u=JW1&84-?E
zob{oZbgGhIH<*ZVi8IAS#RyV-nn=kgq1xq$_B7C|z#-Ymv9#~|M_`BeL2G&(9cd-a
zn@mySjSNgU5BLAkYx|#wy?^rB{w1&TyVv%W+TE*RpKh&_*UC@TXGUlI^xC?U+!x5a
z(3M&ImX1#e@9})dA70zXe(FeaH-`exEvKEwOei({vN~j)`Z5zuoR|QiqSJ2Vheft%
zXM9|#C3C0KQKlFzjTGw)ggpjcC{8g|<rjv~HhD{riHxmsBpFo`c?-=Go2a3A{4h{}
zlsXZvQKf(IT01I?6OpZ1iC<o6<#AdV^*2i=4nQGEzbu{Z&Lti$rOp=%+?<N9xK)}N
z$MEqQxH**w2$)`Rt2Q@|73Mc}aVQM-&k7GJa=w^vVH_tYsLjV~XkiT2(Dgi=OGB<_
z2Ki-%T+im=*7I;Fv$sa;Xog*|iuLnOyX;sbD5NdGuOE9OCnC7$M&K>4%M~I*7JB-M
zA_C^za6ORT@bj+o_s)w9DefpM_Pdgcx=|4pSRCvRX4><psm}=uS%TIbULJixUem<H
zoXE(uxcD3?Ni*-u)qdW&&JG2EzPa3R&^2@($e`!XgUBDo!|i%-a6)Wkb>Ow!n_;)W
z6n#Ww3hG92Xh6Q}r6M=SlJKBg{#VmLb|*T##N7#Sh!8$rBSAh>VSW<<e%;)hn&zf%
z0s_I((uVT#8cWjz(9mpcb=B6+J3Khw#w^y+AxKx($>(y-6_=WTz<6;{<Iu3A@Su`w
z-r+H^nGzEE4h}v}7Yc*@@{*GCeZA_u-7<syGc1haLa%3gcw7y=UW`CmTUvUir4@R*
zR-QX&VQCx}91y3at)Zx>EG(#NV5Dqpss@80czCqr<jgZNiX#HkTT6<90+Y?myv+>b
zx++R-%+Zeac@B1Ie%Ee>1!hM?MBls_cTUF2z(D_+N5gd=jIUS5&9KUlP;^*eexOfr
zh;NCTQ<3kLT63dV54QkA14ADlR9#-4ysT9~K!~4vyo#z>0y?Ilp?Pp%7#J)E>guwx
z^Mifc{rqF~w8Ilox6YlDiMnyiKsz`gAxld=#M?6@J|fr61@sz4@WM?51^HE#uU@pi
zDK4rb#BVAhVkE$8s;{TDI{`a;#O-{sLO{TzCS4rhU8jrX&KJu8>b12qEQ}F()=vcx
zEdaj%PvFQupb$+Ik(k$CdzAkjg)o02`&*ClFBD>$y^!|j;FRnf*YAT<^Rte>qY(Q;
ze1Jl@lXUL=I|{jq_HKPy?Eixl^eDSBX1Hpd3W8z#ttnMn?rZ~J$?bdjseJQu{hhDx
zJM)XM$7E9PuGEzm8qN=N|3V=~#dRK!9)r~I!ax|17fsFq$JpNnr}~tU_nVvtj<T<{
zT(K?;kVbxddgrIS$nm=EaCgO>*WU&G?aSM(dstR<LWKPJMe+iy0?y4Xhc&o1+`<HP
zm-E|M?RvC31@$zG<1U7j#!sLEkD5HmRXd(-*+QMwe_}(A+Eu1qlbs}}4({N<7Oc*i
zyo%7EP=?_k*qJ&s>~vV2Cv`R4ngq5j<(eepsc(;NBv5z2<Sj5;Ia1r%G|wS=)apEH
z`1F@#mb8;B;sxD|&dEp;vNpEi=+ZiDAKOZ~+*MeEYBIIoDc1VDQBxHDrGFXvo`AHb
zG?oF#i~iMRyA{dsx4V_p)ouE`Y!+UEL~iSlH#J2Z69}dv38(QoKCpXAToKqHR7;+}
zsZNIj#lnPfa1ofLhQ9N&2z(V7bhLGZRARKbpFw}Oh4h%z8!}FF<z1&AyiufWUhT^J
z{AICw@7f*(DONMk@iboTe$l|B+e<D2`_QqSyC)X&rbS=0_v6EFoOl~XtRh4HNzSb;
z)YF5lomd6~hn{zbSN6v@xRk`l%o%8@FOzRsJU1xRd$m7G9~{m;jC+kt@{Y)D{MxA-
zsHWCw(zq!9Qf7NP>FWnA&pse&ZZ~yaTaOR#L@IpzzBs3*+9P?7gy3R;j>h1FE-T~S
z?DiVtbfu+L75201NImiQfnIjP<T5(v!mkEhaIzOQdF0-kYCFG`bP;pU=TSt#tY0Gq
z<T+nA*6Hg@>#^dt7vXr6&+SMx=czX@Ne*MSq&AfM)Vz}mk~cQ14Hb5ZzEy{UCXuC+
z>!sWlC%d%B4_R;PxK}&p{b>Wj_PT0$kMD>+Y8kYjmKqeHrKn0W*%)LLw`z<+;EW%_
z5J(7bEGyNMtNceb)FIQCC3Qus+t!uIo-@ME?_Ra%EIk1gy`>V(bDPs-`**|>h2p&(
zhIIvXZdy=Iu1k$$A>TE*dmKkP>y3p@p6dNrT*u(e@{@5K<8!(qkfZ}hk|x&acb|JP
zUUacSxHw#pSqOwWUV@j8jrho*V?3It&0Jw0L9VwS#iD{B6)Qs$5~wMaHaR&7#!i!A
zRcR&|NL|sq$jusOd3Dx@5($dWSoOSRiYFXD@@z@#p0W5dMdKgvjpHOy)J<rxoTpCe
zS6rp%RU=PqLI_@>(`8eHk1Mn^q!@)mSZ1b>iM~i!I&l&^Z-qw8#!@^l3`I${+j5bO
zfC{n;Hx{F&;dYqFbWSQ~szO8?1uYW<pf?GVtNW6Ox#2F`#3Bs-QW<oa+_j%=80I8M
znZB11^u;2{KA7NW1vO@q`@z&C1Ti*Zt{7rTE-4ac4c!Kb0*0|T^}}8Rt5-;hg<JH*
zxDrG|sU7LarD&u>J+&zDiUT=RgQZDA45mR<^hm)yY`NcvY;C2)fGKL9av7`MD;Oh+
zZ6Xz_(I9r*N0K0QJfPVKB4aRCcE)2NbX|=&L=8-3A&5!SprlF{)+-tFQ5-e<CM$1Z
zqZkb9HB5Yy_#H=aB;q^?RZPr^xP+3W?og1rb(kw$U9FZz*W<a_t+a<uTw|;^Y<FnS
zuxy~?69`eK2{4T>o9&{lsM0YFm8u(G?}A-Aqtp|6i?Jb|s5d^F;UYYU60+E+mMX^8
zGklVPco&<LLegk9_m;tnj)FR76v12su_oF@)p+73!F?+qb=443>x7KcykIe};LGJL
zbc8asJTN~f8>P{O;yDQ?+n~c-TS$<i+7^l!P3R6?+7Sh5I1-m1D}vJ^-6q26a_?!W
z#yJxG=_pIdGW&tFv?hT!-q-Z~(cC&?m9U{vUY)o1UfF%+i<6HL@IHy*97W{azTFa%
zkeQ-W$3;r4BaU0)h*EfW{r3KIUDCq`MnjWdhsBqo2OQlm1>?|;c=xkUo&RzPQmHxm
zG^`cHI7fqjEp-g4k{ENuyg^#)I!-EPgKF$>`fk+M&LBI@sjfs#o^?Et^X%FSlex{b
z{Ju$vp6P_RhZ{`duO{*NbW*Q+XOn!*n?hKXC(-6QLG-1kr8uNMVCJ@+ghEFR(>gE_
z42pt8kEg79q;fmiUWr~Wm~r@Vm{Xb}Bbi<>t18<Wcc*EGsk0wDFB&ObWGeDnA**j8
z$U(Y*v&db!vj4u{i|aW!6i!N|YXH2%i6{&`@T3QpI2Zy7xs+dMo3jk(ianbAjJuib
z_Jmi%q`^<*x@U{d0KfhEIKvl<w{a1Lyzx;4+(M&ot+0C!gmh#1zDT5q3sgLuyrmZB
zSDdNw8A5A4O~BY?q3B+cza}6VB+=qapcYUrUauS792)$#nCTY%EdhKc4<w=E-kd7@
z@f=HO82PDD8oxbSlhLG|NHd_@LvT7;Cyna`zQ`!iyYR0@J?lhp*G>BLzA@)X4f0T*
zTW}JIC@SK%%@U{+vHK!QlEa~mo~aB%$JjS{dE(%vCfhbW7CSROwfZL0dV8DeQpde5
zvQOE;NzT&ldh?nkpY}dn*irs^GUY<~s?7fD>u*9G(H}6Fd(6*;b=<A+#@G6DRfo7t
z84-A~zDJc*5f|(~p89uk1hs$4eRoUthTYPFL}OzFkN3@QPevA62&*oBU`YKo@+|Eu
z22;F8AEWlt{P1hqywkpbpwi|>{nsJ!lKp_%+~=HBMjhr6PA@hTUvXsy!rp~^x_R$>
z98z3)$++-yd3yMg=_SRL&f$=j*I8r^#@TE4Jil}?CcVF&KJfh0@bzJ=@=mmP_$c+r
zagd_Q;q#jBuS%Ow7O*UzD@VHCm|yaEIP#<4@{$`tH{zStj0*NxneWGeb<_8qOH8LL
zm)edxUpjoai5=V&$NDdg{CGZ~`lGoTd#2im{b4NvT%CPVQTTO2z|~ol8AVDg2%3e`
z4x^wU0yOztyRs-MQxwxKKT97fd>O^T#1A&7oTZ|9ba;WQQ#})GPQgXiqS+6lB|K2i
zrrf3Tg{9CORY5WM88J%JoM3b6kUDmYnn_I_s^P&F=Nk*Pj)}P&OSv0cOBBZ@5NCmo
z0h?2enXz_#>|k^1(LtP}JUiH&x^Eiqw#MeM%a*?wcO^f5_8@+4Dc(*X!8e2rY)(yP
zB!tPcfz7FrgM_F)R<JqMZ;FnWX9b&6?d|9k>@iE)F}j&LF*Bb9Y);ksCFZYj+V&+1
zfX%7CXs|gY1~#XdV!-B<4BB5KSGcejRs1#7|1gQkBeaD$uBR@kdO9gHICP*dNrOLd
z_&Av?Gnw)rf{{ydA_RR-K2Qmne6Nr3t`4oJ8Qm4hIJ|aCB0tR}hEzhyR4ojn2@Q3(
z2^j%3A>9($i?!I>Od<<?)O0YbvL)`l>Ck!k6dAwZNhF!IeCm;W?APOT>_$3n0Y|De
zhVV`7A{yg09l;90p`FC+QU_8oXVB<!(2?L!24}e2#IS_QX}eN4Ph`AfO6l&%xH@)?
z-qesMl-l-dhN2&#s2~%wXNG77I{|hqUDK3^#EC^(m*$);(@hLiJ`}11qvrUWMMj-{
z!-)*ihDRVtjN491xRI@Z!Mkk&9gXtP^Q1Nqq?IC}(^i10dqQ*fk(VFmzz#rNGlPgH
zbQEIf^(K?!aqcxgRw500ivu<B&$-tNpx!5W4>K}?1oMXvGPhmxLv~~JUh|{INPVXB
z0kQOcEh39Kp+2PGZh2y%0t2->E=)ogA3=)aC|umnCJZGEa>ONAENm_iNewL=L6Y|_
z;(#7y_C>M|fm^LkcqHrO!qB4eP}FVPqPw9*FVu>r``Kpuixy6b7MY8GADjv;UMnbm
z(qH`Saq)|j;&tYd%|nHfZQGKa(30JM8=UGF3Xm^N#VPpmzYk8$az$GH8k`y^BY*PW
z2B-Kf7t5*aQW=(TX3NQ7VHE;}6+%zqR68n6#sb7xDy6(+wd5;h!z$&ISetSxwcCAg
zmr{edcqxRc$V{c|{Wu=JsVp{w@OY9cJz>~At`cg;kT_NOnpT<>R`0KplZ{n7Zd8-t
z)Yx)SER|LN-lJTIzUNpx*k9x8#dsfDOSx1dk&%s$F1_JYTQ)}SFjgyvQ<qQsx7}${
zKm!E*a)vnCWjWdBT(n7cw9B=(%yqKQgu^v}Byqtq*V#VP$v)fl;;l=zSr@F*o$T{2
z+2&lZ%5=GS%UD0s<znG=AGEz?8n|&?E*2T<-Sl=#alVjatQYBMmwm}DC-i#eCEH8~
zn;a|CIOhw6zE_fs^`Zp%O?^CLT`uMYTuThNmQY{U=47Ai>W~k(2Wd(3Ais3)%jMz0
zVDBfJj8xdsE;G<C>$1bGsE|Y^M#VsX)Fs<I|EmcC0$LHldDdp}7pyWaTIW047hJjG
z(^Z~nW`uHa3A$jN?Cw~qqoeEM;vy@p=j7-tBV%N1YbPgXD<^AFU*BkHX_=Lkqpjsc
zNl8&qkY8WdppI}VDXz-NDn;GMcd$*<L|zZ@N%y~+;^&!ZZ<%9j5zfo4<L-pM5m+EB
z0@k+qob9vSTzyOp&>;b7zMeILf-2Xpq!}1057yt()(C9KOZj>7A`x6%a#p5cs~t2S
zW*EWAYiXgz!)5)~d-uOPL-Gp>L3<VkQBwZ*_N<Daw$85ZKb#@i-owBdQe-^wt37LO
zKFf9C|K1tmSAhOYdzOm~K1?0HuhUUAV+GeNxiHglxh5N2x<$Gx(7Eh$*WbE^O7op_
zq(*&U(`(^}U^G@Hb!P)C?_<dGWQz;w_!pwo>b<H@1GXQwI-W68==X>W-vV<&z!~zB
zjK`AQJ>jZodCsZ1`S!VRGcgSpH!e{wG`e-;&Xkm6)OvY45wQq@ivz?K;uG@txrN&E
zqulRP!9C)0#ic8nN~*ketkiI0@0V$|mKZ*@1P8JDqZji}SFf(&2YjVuaFu^R-hv{N
zTey9~Gufvq9t>=@@ZH(V_AeLMA&0x|gUPKw6nnoM?B2-Bi+s^m@_C=EnTm7d$J>*!
zr%zwDG7g?-D(~|<+Wu&lTSr}^*WrvNuQ|FHM4@HF5V@l3v0*{?Hh3dm@$&RWf`;-j
zCz|JBm187tjlfDGy^u?6l7!oxig?L~=nORBle$VRjwJWHX_t<Ow=vWty4xA#8-458
zATyZ4gOq2*8$6b@&(?9sY&sC5gfd2NUa7JXOWw(MjdvW&3rlsfq4u6w-?=3TL+upd
zjv*(CLuj~&io;Jk2`HlolVT_%7z)#wE{8bXsYn@csuPtu{xrccl(>OM&gfeBhUk(~
zQW9Y<IwMJ>gw%Pey3pr|XZ^m0*KU1&&8%Q!SC5NlQ{jT0u;3NCj`5a$SkfMW#4c&m
z`Ia=eP;_qO`nyif5U!H!cN%_a40sGU@r2KU8gV?QSk&J1ZP;a@pj=grV)*X4do6No
zHY6K^pS{ehiAv8g*bZ6nQs+@SU|{>Bm!f7r8s(5=N?h<9H9?U=8%>a;{A}I_SQ!fI
zvV*&HBR8fdAIQwzxyuqv-of{<q-d5ws!7s+hMpEL&d5+At7EqB!g>t3xG|fwocQL2
zI!dLcG3hDQ1nExu0OI#4l!DW~GIQPdYkKo%GH<%n?c1Jp&TQBWb!T~o!;T*5rZ@M9
zirhSqqH=5%l@npsX7hV;{q@jn&kKJtF}U-dXdfSQ3Ur(j{Sk_bbCL3cJU{ca;^tO%
zLIqD!jyq+je^w&}9%RT%jFgBjDxrV3&RT8Yjc8hG@Z0<*74dgns_+}HyI)7LzgBqr
z;Tu<8?~lQcV{$4=?<YB1l_0%ehi`wJ7e5LAuvDs|d~{p?rt-U)Yo#~7KBd?=!=7Ka
z5B_xg+7~l)w43ZOwEtf9$MC_yp7PDJy1aDNSEt7DQ$G%OIUxl6qc}V7BN?vKLFnX3
z2*apQgaK^$+yZ?hW)jy3ELa)f`D0{0%`qHwEX3+{Qe>IF-h4{sE5O22)GiTAJNB5^
z-7gBS%S25&T$AF8jxdd@SVGGh7u7X1?5I60@;n_J;w^wVClA`Q$S-PGT^?DUH)2%V
z=AuoUE@fPXCo67OMBUa=m!LFFIog2Wu`HrwdrTpe`<e`S=(}eIj;T1)E*y-|DTn;_
zv@iWGc%S<~2Zm{4R8u;Pgc+hj$(@pzavx6eW?EazEF+|<itFU_h`yFHHZ!cLivNUQ
zR*m5mf${X1z=qkZmd_!pf-j1pV;|SDr9-rt?v)&LKbpR%oK$!;+S;c+_rh=otAd0Y
zC|8IT-gV5MkV%%D^n<XhIuYyH;8Ild=X$2$ks4rd>Ahz_f1*_O)aScQHI8w7n9d^C
zgBp4NMMCM@v?Wd%{3=(f??-erl>YckhrsiyL(y~@6DkW7(>#GuLtx~j^Z4rAZ>tl{
zR&^PMb~Au8gv+n1Qt?zk=PJ)~#@)IqK1*ug45`TJpwkeG5KI8h5VEDN8kzw?Bi5>w
zVt8Gx3Om#!X127P<{aj=%q!DC*VXFr+Ik~RDvL^?l6tcoMJw!3LtsaP<y+tG#`zN=
zn^f+H?O$q|+@4d|t?1qA?g%{R6S3#IDfH;hVs}e;zp%qm#iOAPsrr`B!p1m_`eUSZ
zt?`%1oN4V1#%r?LjRQqose~WTJZbO9o!o|<E3mEdVJI$sAi_<?`lP|Rr)$er#H&8w
z$ph!^?w035-Y$C&9v@Dkx-Q0gU02M0erUx%e0J3^TKHK3w6{-8LCoK_;@PW`s{RF0
zl7Py+46x$P{cxy7tE2H^if`{A!--gkApFIFTGj2HK;p2KdzhmRYpxFw;%b}1mtq!s
zhw=NxBMB;Ap5a!F{5T?t!kbISp|#;8RFP1jX>z<FArDi*|A>uYRZ1r@m*-#@-dB`r
z+6eOPyR&yJfnMR-q%N(T;1eTCGFM8Y@04dl@aELhwKp;HPfWJ1)ubAuwmeotrV@4!
zL?eBP&(W!!Lp*H0dPW_ko#F_k5Wv@9m3+lR_E;`<cO346aW%NmfA8V3RDM0zj--C&
zoLdlK;mTafg`VX3QQmjAHk2+XtSBs$KHn<(C_*b|9A}33B3<eU-?e}yu}a<>FH<n}
zh;kic%7c8apjh&_pmV^Gz=2QCH}9f&eSkM7e!50=9&M5}Fi@h>t!pqut$RIee$e-*
z!YMUbdN^#RVS%{$dPMTYPXi3YKaND?C2*lk-_~%}I@_eNn~Zc_>yJf!gR=9UXUGR^
zJXsr-?N+3@qZV-E>2VY8|82A}{crWUR2gql|1H{R{9C&&NH$WRO3t|(eJXUf+L1Lr
z>An81cHIP{&lT2q%UX<f)P26OIP(A4uB&py?dz1SiuhS>_mAzm;m;JKqOqn)j(9M~
zDp0Tc=kPMW@yYBT!^@XWSjxsEYM3V$jQx*Ue1CkdGah<tegE{~;EN+%iSL94*wZIZ
ze|+h?KlH(#^M)~p%E938(Z<H%uXzT8ICPFtJK~pc=7N8Gs{9zfYku=|d20A`^GL)8
zYtGZhUn4&?-;6j&=luRs8++2)diFWE^laxE_Vc~gA4emlKlWQkzHi;fo_<xu9w*$~
zczyH09a5gB;|0Zc!axWXqX;k%=x!7RF^XIOMdyK{Mx*F=qZrXBn&T+uX%v?{ihB(O
z??dsRqrvntXJ0gIEt;D+THrXEg*ZmKFIp_0A%>SJ=6uM{;bjSr7&V(1P8+s*TH=41
zxIryEfa<Zo6gz9PL>u!Y3zKLI<9IvEG%HiIjd`N3RtNy>w&rM4!&Gy_6oA~#3{&(p
zL+mWm;au8Qriq%WR^A>rw3N+3RUJ@|>?~91=@m4U&4F?TI@y4Z1w^cP0H;Kafi4A<
zw$idXAWZ?03`lN3KZC<HulvNC8^wXC4@)aAC{)(nB}DPOIUSuGK(gZEhGvGTSKPvU
zJj1SfhSSo@UUcvQtuC4>pp#cWE-o`BHVa5iK#l@>lC|{}P!j|6CnVAaC}DQ?SAgIY
z9E=9S641AR5EUDjgNG*w#4}x87hT;;Km#Kt7E)9+2GujsF&WV@>ERJ6V2R|?rEAt!
z*AkQR(dazT=n;7{<-DS0P;i{<rJL4fXjC-1=vF-nl|xA-aoI7-)*_jOSsoO%T=fjI
zHBa^S2s6@)gmY>7c%m##(0<+t^z^b30g?QCnpP%BG&JXEXk=Y4<$7Me>2^6N#6QK>
zA_WMdNR?~c+^T`T@y7aLSFT)RV^uNM3$r#$Zft6=Z)gz{6O)t>|G8q~eN$Rm>Y8uR
z_3NO0P62Gk28E#V^Q$v6v-<~ztE+4MultmiRaaKD%E`%!2pa|Y#|!b9Iy<^ww8<0@
z&@<2pH8Y6wbd3zYj`sDA2IrBZ{f+L51W_RiZ%}dK7Gq)%dBHN>+B7LFFxApHL|W3x
z!Z^*;Fxk>HPERXTS2Nht-B(v57|68#KBxen(94eD{=Q*4>LH%4ahAqtJF_5N%_vWo
zTPAuzRwf}ap)u;pX2T7b#)9bHszlJba$eqDTUQBakU+Y7J;9}{jQH!Z^8fbnKPh(c
zQva;j{k7=VxF{9EbE^B_mQTH&pZBHtn{VikQ)MgdD)-OjQytTFdfnh(B`m7%g@1MQ
zxzHH>Qtap%)xq-Vq03Az7y|jF*!{id_cz7v>BS7EnD<XQK+mr-20x36Gt4)%1J!%5
zMTPYA!Nn&kqv0)!HHo=U!`?aGaD}cblpv9kTZ0^ngyY4bWuB}w-cOlQXAsh_VNx)i
znn^l3{v<uT!KIf>FX{+#&-Tx1U!sUl3Dk*@HW~O-A{KrV0VGz(b|RSP`*+AZA-GXc
z?jjTXK!#ioXS?7F<pjhkQDw1=W=tWQDKgR3cNu@uX(Vh=QxFLBswO07rX#^iMDo>x
zj=q{aJrD>?T;*({gHPwg*)S(%UkDO37cFgDn#zwTLm}B5YU<tedOkaW>3}3BFnQVJ
z`MMaU3_;=Je12RD!C&vs!o|?T>-547-?&4fIE2>7<0TheE0U#H>MA|kadK+%2Q=PP
zq^4D|MWX|}ypW}*%x~)%lExc!>VIHE-!yieXKAeN-VxeuZshAvXc^_3*lQXy>QZkf
zqD*cwn{rrv*WoTm_P#4xSwEwj)M+rIYjr{Xt?f(MyH|U+3*~+Kci|yE1MgaTeFpd4
z=zT0c-c@YwG1^GB9QyKwm38C?;T+2-E@L>$7$Lt1%Q&grGv+(;^Lr9HG`-cW>h$~p
zlCIET=G6)MAo9cMv_z51aP`S9$(fr4Deq=QuJ1_YWlX&LP?Gb->(fH|8|G0Q1Sb^2
zGI8h~;M~WgHo9yuwefbzK;^`RKaM<W>VeJc1CmvI-K*t~@KDO!6w_tSUmnl$+zDK}
zf~8N9444p=V;{t1OSU<iXUln*$YZ;L6WjK=rq*L?+w?}6dgg5<!>iVhw@{-Q`x2^W
zG}MwJV-@mhsj46P1T*i);%8;Tb7pol0zWA1)>Uc{B5O5(VkagEYJkgEBA11Uipy^p
zrQGvV+#5-kxpAOD|0zijCG%2=zyF#B@gcq^wbeV3vtn2NiSIObnb#B2m5+!6mkSB6
zY>pF3_;tM;#y8G-nej!XT1{2`OYoW8+R2{iE4=19x|Z#{vTyamQ3}E=IE-j|wkBt~
zFmxG*Ry(PK#D28x0Y2N4ws=ajC|p@z9J3GcV>FZ+F;|bvNYy>Y`$Sy$#6M>edSb@u
zlQ04j^1Ad&E{W=0i{iZ@1pL?lBp!XsM!c%QrdgONsTrmM&FRWz&4j`%3HrGYmZ8Mt
zaWtWDYGGyp9WuJZSk{ocq`IDW>CKnPEPXc<WwU4aIQ-)h46aFGj;Dz+^mmTPH|f>h
zRnVELjh|!b;4&n~r&BndRM&DPPg4To5fVpWc^#cG=W3*6nk2irp2glY)+(brTc8m`
z;7%MPWE~oRz{SIOLC;oDbc;-OVvMqHqFVT^%sqzzd>kgII&OsST#gb1?>cS{Zn6SR
z#8?Vy%AlqpcV^Bj%+>AT9G`ky{k#uH?5!8%wTMwcqib5%^IsY8Yb?|o1P*j^y(`*L
zd@U&AT9H+9%toy6=`r?R#9?RlkMFg7oF)*>8S^sS_J`8!9g7bq&8>*5U#k-_nFbqK
zxYN_~BPmFiQW~VoIELUl>V*>-nO$*=)jPTc1<N_{oz-0|)%qj2D+O*VRk9ahM%RT#
ziVw5HRCwLgxouZUX*%n)-q$KWEm*A-J1R4L&%cn*^1zm`yW!TLkk!+kr5iq$ut<3x
zvk{?(wLun%^f2LuIlU#!a2jmt6ECtl^kE4P#KzNdPp+2Kvh<l{>&mi_V=&*^*xjZ!
zwv)Z-xv%%__PbkDO`Dto<DzgEyPLDlxFp1rO*@-LaSMt~FDo=Iw`V)i29r0(Y3)7e
z+=ftR)v0?~Cc_?L&FDqTd}HC$Z83z4vdEtI!qzm13p2QmL@sC~w}af%mo5B#m<M`(
z$@<XkyD-8+P}GCiyYL;s*lAlJ=4V>Qh>F^z#^~Vlii{C6U!3%RK0h0*cq2znV}1B*
z#2r?`<tTLvI86*@jBR{;@Yw7!_`}wt6afvVughRJbYghKOyf1*JsN$3Y_nk*b)sZ+
zrF3(|;d5AbAm`S;<MgI2fue#?ntW}7xySoTZ^dS;FXP=ONXfMN+AVg*)+rKXdU`71
zb~4m!8dq3qa2&mzF3>-7^@fyYII5m?5qFk7Ln=4D=9TEDrh5)O%=vfbIwZ3~UENeZ
zO)NL<#J2;*j^svXULCP}&a{GZl`nDlo_ChweUJO$HHoEo?5#-Jfs64f0RuG6yZ({`
zOV7h(s%m-P=!!Qk=ZZ1ZNK-T!UO#VL@<XOsP1MUOV_>!B{J93n>bI7hpm*^uZIjE@
zTH6&n!=C@e-dhJ%q4(dvo9<RhKtd1@ke2T5l$4H5ch{yj-CcXrNOy=d2!fOaqKJS9
zN{UJf_oJSCzEAv~xxe|{nR~DQG2<D|;f(IJK5M<#tFJxBv)+m8py#FbsX$Y~jcv=@
zH49@Jq%9c)<+gke6sAKvptiv#4&c_{1s6$2>pi54*Mp8{<hz}sw7Z+h*Pgw{+(Xg_
z>_+-Ocr&AZC*)noeZQxok3MVcKQu4eV~)0bd#(A-KoZk__+I4-<_y6Q8C^j%-?;!`
zn7<Pv*THkG-qo6Jp)t*}gQT3wHM;8r<Fa)5X&L8yESHi2_BsuppEUKp&kGQqy2W&u
zr&+ln7=}OXwVYdYC<fS=CzcUhUxtVuZiWks%wLv%so1O7(&)!~R%Vt{qbtsJxBt|n
zrQvIb`@>I8Cn5_^8NW4`RBYSb#(VWtBD=j+oWnKj%wU!4sDAe0?&qC5%S7Hs4^1le
zLM5A)Zw?hjURma}!#`JoT&5w}mnR}G@v6vM1mYH~7y|r*rO%yNdz~GaC}(>gFf~#!
zP}~SD&B0!iw>nL2Gdrx+{H|kl`>cGn@0((`xb9;-$Z~5)U+;*x8|-#)#H8r)sKN0;
zM%e!QnUM&49*cvxehOjA5x*%(oUiu0F&z6Nq>zEAOR14YtVp@r3@hgGO!$4@p9Ish
z&q4gpzPCh2X${ct&GgA{xKXf(MUkC8A~~mkk$(sdX9z*}CqZMS#)bzCyoBMvJuxZ6
zF_et22ziv>WG(xGjaC)pKj`{7C!7LGO(zt=JI8{V8o{n~lcky(xsMY9L*ZqO#CRT2
zGl(CS8Yxl@)>wWx6)DQ7e+~j+y-H6Rt!Eew;yT0JXydME5Z9R<M_W+FfVj@)cMwP(
zf3%|^`NGQ>cYpQ(1!5R^EQsq&^p*S<u0XnCL&w=0zQlsK4v<e{{NW(3i|>LbF2Iv7
zyRLpZf~Qws=M{*{_K(ZWjmz(f6ZX5)_$Us<b*0!|gWU022RxOz@%Ovp0rs@v_&4$?
zKQdO`GNG;dI#LP`Z8ia9bpw=%LqfliPsei;AODqns+4G;z?pSK={k#*$Ow78khFZ9
zv_hG@DwMnq$fy3vo4Ls!yOOsTl6Q}j_bF4}F5C=B6+(owRIOq{-HlM6rCc1RK&Vnt
zg;UXuQZWNkvGY=KyHf%76pIZL)gq<H64O2{ARL)8w4O@cokp{mMt71%PnAwjm4@S$
z<P)C8_y_rvD*Z-{G3!bC@8r|PG#)DBIv5HC0wV1N!R5}RAm*1;&QuW2l%nESG0K$k
z%EVpC#DZi=*JP^V@T=!#${J;<Ok`=-WSPfh-J8f%I>|J0$Tm^VwiM2?pU8G#%XVYS
zwB5=!V9W7X%+_Mdy1SL7lb2($m1VG%12xJCs>u!!&UQD-p>Rim(x+uG<F|0*5ptv9
zH9`0WAh}zRtZoP)EDs-%m$jIeXOzcBpO2WxD-OsnJ;^I@0Eu0Gqi{YF?6x@MH3=8A
z#O3E26;$LE)Yjy8E*8|q6%5xDjBe$R;1u>L7nBDSjMWt44-|}_6gCGGP6iac0Et~q
zVa8&9D?MJn555QjfkLK*vSEZmmRd~hUc6pYyj_Dv#$Eg&ub8Z<cw@2n>qPMvhmxz1
zl7o|C5&Dv&?vhiSlGCkXw0Oi-SjmUDV%+$Wa~$M{tr8Ly1Wta*##V`lJA$$YLH-fB
zHG#Z(iukgKxPBjHpACVhf+Raduu&s9@{wEJNSynntkfk;#>Hqo$nJ$QiPJJE>T(&8
zayb!)S&KMD6$xcrfxpu`|2+25Rtwiri_lSz04`laB?z=Z)fA(2)M2{nFjd7U4dqZR
zHJFwv_%cRb#tWEjVBo>g4Y1I_a)UX3;8ejTjh1RSfY^XJdj)APduvYsu>p5Ou8tv~
z)Tyc_4VKOSpxFR>tRU^Jt`wrH9tl>|0o(?xpDQU#0@G`5><iMjl$0DyOiW>6BVgx1
z=;q}XPEIatZk(bb?*p~*fZBM2kWNP}9GH1cl?ZJ$n7d0D2dlo7nVYe(nVx2BU|=v5
z3WLM5Y%P3DOq{Qf3E5eBSXeqsNt#DS#ekW02U~v+4{vZ}q@Z9XbjLtPJscJe)7I8~
zG&V&>M(W_;l9G~!L{!7$((czbNlKWNS0Fn(A9QvN>*?!Ch?@!u-UUw;x~dVnYSF%)
z(N54X1!+$rBAx&bZ*fs4R#ru7Dsd$h2|00Hb){$>buSJM6%FMuu;C8g2*9wrp-vnC
z?*RM`fbeLmM(}Z)swxC^mBAEcy^QaA$xC`!-wRSxh_tf`>MRZGtBv(?at{ej($(;4
zM}*er1%e*&;WQ(70VzRL{Xc7W|KIW5|BY!MO`zoaqh?Eu&IIzse}3$<?r&Z7V_5%Z
z%@)u*HIt=PnE#~n=trre2z5XH+p&*yYw2(K;@aaPaCrX5vCnVIslSHxZ<$RQHl&aJ
z4(FN7{hMjeZ%cYg@g@_j_y`P9H2e<d!46ve>#@&v`RaJat$rhD_u&V~>WF-6Q@7=(
z+24<SR({lMFAYRa4mbV2JuB*acy_eEHd!)rrjDRFKKwu_*WZ5`fAdNjD(KS)(Gy)V
zSJTTn3&Bu`Q6MOCXeb;_E76pMZ73L&=qt!rG{f9?a2(h1fmr%@e<a0?3wy?Rl&FQ(
z#KVX1(nNmG_DA=G*K=oMt}IuVro>r3qDjMPmX=Pvz6xK@SYey6iPyTjMVrbk;_yCu
zW^rLX)ifrqFh?)m!Op{G40|Kbncc=l!HqP#GTY@v+_h|(S2Z_Xb?mw~ieW7;?2E(6
zUr`sEQ{RU=cwKaFmgNiJUZqLB8=qO8Z5K~fiI<LK^N3_Q-KtJ!FlMQ#<|6-CQ`6x{
zS@nb7Nm<wO;uS?bu9c;eOV{p4r+bz6Pd+vI)w6Rnk3VjgCP6WLS9et$A7;_=tY>tL
zh?N6T-@%2hv(xE>5i#7gp8SBRYcsn7&J@?S)Igtte@m{%S->jl+VRGxF~%?7&h%-e
z>lpS2oapEGdN0iMV+kaJSDJ>U<qk-LFgSTgDmqcDNQY>j^Q4X8xV5<t6Nz$osF8QR
zQj#{>#%PIP%5mmJxMAyg$<frdWlD42&gS#ynGE(E*Q!rUp9@Of9-dbX<K~~c!uj0G
zOwxV<PJJC6`SpdS?9NwhVam@#3pV{y<1a1r?|s6Az8)N2a<hh^zVfDM4@V&;H9lIF
z#JHrCB7z+euhCAVYel>ZrqCZ+#bgUtB285+Mt2^Mr;ot&yup?E9yQ5*mJsYY^$;S7
z(ws4v+6H1br1hJKH)%%b&Il`S`p5-c^`8yDUPtj>L|RU6FlxK?rG)NP&W+`8+=r4C
zn8U-58qmmO^O{YmsPyRvF{bX6WD?CN&Y<jA@t_ucd(AfzeI&ws5Kgd~k-~BMM)eBj
z+3kAB0HO52?FZ*PgA3AAM}=Ha^pKG1@$dT|NCl$y!p6uFAZcad<SXF}dDa%{`73DG
z&>2EW&h@d`iBZL&O{|XCLxiP|&>@7XXw-(`A2ftAS)*LNOYx8qiS8Nr$J}WAH1P|U
zj|DqgnN_hJ@vJm((=h4ISK=gB2Cr{aj<9>Kqx&CbT<y$FBNJMY3tTIuWL}l$j(1Fi
z29IOXl#h~8b0m=)S;r1xKN6vnOLl21qr;0(6!F9g3UXGXI;0#IC!9}-j#^`wp)9Up
zZs9g7oNuOccqGA_p6<|gqn0~PL0uy~qsWGdQQBct-ZkCF?Z$f<wG(B1*R(8ePur{F
zRH{apY1zpw6__41lboMha`Y2#FoXxl7;dEJKH+2GjjW!sE#A+WwxQ=Qo9J`UX$^SM
z%kn9|=7~+HNA4Rnnmg}Nv4nDO7QQCgU|q6`<(Yz6ZANJbzTrh7b7#QRfZa4LCcd1x
zKh?@fk~>IlGmF7p$j5cQ{Xy?yA{#q*5SxEi244-K8BH3Cbc&O@S}uh~mCAr;3x~;P
z@o98DJH#=_9iqsW!bnTLBFr3}Ksy3M=O7+LXFF3Ty-NMGbAW-!WnYFeS!*r_6{`#q
z9YJc!o=s0Fz@g-#O5=I@EFu1Ly1u%ho<OIrMxaMB3h}^obg8a7nH>~N?lm@DAHG%v
z^m<2^3X?4i1NW9_2zqX<=Pdh#aRWwUz;h>$V@HEF2zg@!Goj^6hwNcS!RA3Dj=PtE
zh7fe}mcE)>)|0D-16G2q4xHOY^isy)%C9Xa>B*#oDDe{wa!zu1JqA6o$&1TxW9?4&
zCeeK-O_n|@v~<g>qQ|J3zTL&_^7K*lNJ_Z2ewx+YKIGzwy!K|+HM^%Keb=jbiG7DI
z<3aUjF8`4CulJIVbl*pl#f7>r$CY<JY$3fJY+doDWxDgh3zu}f-B0W%cAGrs>TzLc
zV)u_oy9O{fYXgW(S<(1}bkR1F3Fv4tv2~BN$@`j0LA;20)3A+pIU`cmxtb(HNQ-56
z<|-t0mdq<^_!6Zlfe&?!s<mcJP>?Lyi>C6*;jx;;MRRThhYi<G*SMAlZ+cq!I`die
zghnMvX4z{-M%_H6yM3O?Ep_jy)Vn7sPCbKc@a>}D-BXvshXHVyU9>we?Uon&KJRGk
zF`nj4c!us2@s)3g_gBq?x)LGKl8U9t^2OXF+JZ^zp~u`kbGtnJ<^4=s%6?Vz*~^5L
zd__g-UZ=t-7j6E)wC|_(JX=2Czn@n2QU8`;|Dey;0AtQi;~T;++UdU5R~39ZDC~JT
zeIn3wgzIERR4_lfyxV-cXdC19gQriXXUVBKx9y3lUcKmOFKVs-)Wu$~gh&?bQs><D
zsOovWu|Zh>^bNIh>zUy01!2Ke+C9Igc5lA15cC~#=7$_!<G;A*v`6J~pMLgWrB+yI
z=<CBzZnw`nH$#uxnYcVmf`a<5hP8JV6&(cKp;@DS>6<M@_xY_*&U)Y_o8yGF=jSXm
z#Rsf@0bUujUU7xDc*N5KWGxyFm*xw3yy?erD2L2q>N-Afrc6l(U96_?eeco;6X^}(
z@>wG8{TMUHb+uXITD{kswdLj0m-p68n^TIwP-BquyhLtU?L#KBx05^Q5m8Cr`a2%i
z@!v1+ruBZX-3?ZZdrMIkGoTx_6LXzlmF#-{DBlHNa#*l^1J}s|t-jAb-C`RbN>83V
zl7ClxgtsX>lY>=`K&jRYiB{^*limh2o0Nwr+ykdidf$EPdK9wbH*>apMi<s|`tTo@
zQ$;UNX8-eYs%HP`OQOt&tzbFz$n4#k=H=<l>F?jba_Y&8)$ji+%c(!;ow?!E)hbkN
zf6_Z;DzTM#u<^AZ>|GI{WBV`ZoyU>9o4!m}vFYg{3jR?_xlt-zQECfO8plyul+iju
ze>3f>LJ-tcRM#vtHev&Aoftd+7-(*cV^@sxLX7Kij5}qlr%<f7VXSXg3;{jFG8ffv
zAr?S8VU+M+racgP*UIpB)Bfcc9@7;YfEEWjwm(e!aV*-(T{$=e2L?fG#^G?sBU$51
zDC5hN;;VCiG-_+B;}N;>Rg?)$(D+tpLj7iZn}0$}ZbEx?Lf3J8FR<<l35}Zx!%B&d
z;fYiJi9-vC53rL4DU<qGlMvXbu0E*V?$}re$Z|CVi#YksX3{EU@>|2?x7f+6z`83X
z?^GvmY$ktVO*z0$SyM{c7E1Y+o4jY3e6*Qza-8yADD^9L>KE43uU#ovRH^6HDVPo^
z*q~rLk&0)OhMSixeaFB{D&h~*-bI3=shEDxGM#Zko;5F>1Bc8JNH>(frnlH2y$$<W
zv{aV+5!A{`2CB#fsL1;PN200_s3IQ#0y{++Us*9NX$co#R-`3dt<3Eeq<xr~<y94e
zRpbL@#9d{?T^#JZWhLE#Beb@#BPSOz(s#DDaFCI3Rh9$6pMQK@4i%+1@Q#Y|mWncd
za<Ud$n$DV<n!rYY_z!C9ZD;MFDC2KzY+`0&Yi8<fanH`h(a+7vUr)#03F>WU<7;nc
z2eo&1b8|Dh=V@zY?`ZG)qhD#@CNJe9a>qV0GEz!P3JVKcOw2eXsX#-+(Zj=CUCjZB
zXsE7kYHIFFOU-0tWZ>c9$<E2FtSs;8?(Oaz2IK}#c6}QQk89N8J}wS&l0k|xKI%%L
zstW#|uECw9J{l@6x4G0+<brs)O%3&(zzhQ&tqc=jrn0C=h`9T^yC}(dbFwQK>c@FI
zJ1EKd)aQBVXj%vf+6>eNdAI~B%Q<POx&{WtGcqW&=5PR`3<{ngs09Y@AN<pQDq0qo
zAdsa6CS{dX)iw8P>*^aCo0^rHe-$lj%z6N(^v?;dex}F&Fu~QQ@_N(~U`l7L*B9S?
z`1omiXLoP^;Pc^^uiuW2PfpLyzh7MbcN1K)4oVX(6@RWCDBHMxeC?1%sA*^(s)Dc5
ztWxVOW7MqtIP=4NrB)fc&2RUHf_(S?W`wQ~m>N!gLq%(Izg+9<Nwtl5^MF8S{LSP`
zJuDnHuuI87Df4z1e&;*w6!<fb5vMAVbY3TmHkfo>cX=u=&2}nLz>iMdc=p3sGDD8p
z!@LOe*+}`;4tej*ZKVe7s=g-$Zm!Q-g7EH~iMD=h5{S8l<^JmU^9Rd<SP8<1B6qi%
zYfRqKT|IN%T|ttU(Den+A1qSIbI%krpYFxK=qxdx7jQm~TYvi2O>IhGZ;+w%dKkJZ
zI>I*=-*6>@oVJ=Sl3386${m}!)FO&f@QWD?$8HlTd+n~_c=YvbB`rA7DrrO<2ld(t
z<Bbm1HHq6}6b5AKQ`NdjCtI6Ll47|2Ybk<@ik9(mEXqWe@!UU_M-xI|1DQJUN=k{=
zJO?+_t~RZpp<Br8zsFE=b=VMwRu2y6JKs05GvzCco5yu`xBO6K+I9dA4(+UmsGJNL
zsuA`JP4*>lou{LO0{kDL1bQ_2P-WfB=h67=hKQO<{yO>^MpFjNF&R%iT{fe8BdJ@J
z<lDp!85tU+qoP%Wyox?G4LvorC1a<m^?ju2w`%MA9M@PkU|AfHNld)iQg*ppoQ+K)
zljC*YytUuZ@XoI6bn^Hc*SBZgNQ=iwzS3MlBksJi`{3G$Fjx0y|KaNx=2B8aednjM
zw@L@*&k}5VJfO%F6g+2wL2UmO>A*vF4i7HQ_5C4$Dea#f?#EYQ7#*4M=NNw!-G-3G
zWUVR;$D@hdZeizi-yfLb_ZsjVX{cMEz`Siu#)r>8<Lourngzp|sTP{^Vi$2H873ea
zKbOMfCKiv=e8}*SUqGmiI2K=OMy>t%xkC{yp-F-a8vY&Fy~8Ju0_Qnc4Ci;!7Yn7*
zd~XT46Gtw|48O5X@aMDITYk9EG)fLr<m^gq-<&dd2fuYVfcqw9M`$r8N@V<XAuN>a
zeHPPGZ+soBY2lC?IlF3jw-9y16I7e~{;>@omgBDN#59NR?LMwm(&(WmiK8-49T@sN
zS+&x5Fq<$mfO14d^ZjeCmelvO1;0jRj3v<z-!G4|Vdf9B)~g!fC$DSwLYcM`E-%jG
zMl|WZA73l|esXdoIexKoc>MyxDv2^b6H3gtf<mOl{e`V52zz8k<eaGo%M~-2z*`Yp
zWrcvmu!*0ftyoBK6P*}77<qjgA7$@RGI8z-x|);>l~%6I<2vr}PuPPb&aem;VoQAf
zItD9O)<G{Q0-I9`%qS3JT*BYG%b3bx({?2hCql4=grrIDa!27RkZ@AsBSh|Vqq4&2
zvF}tzeCX@SVe7HRH&a4`WbdPUHy?1jMk!wP<c_3Y*5(Qb#-ieHN|*c=4QCXKg`iuE
z%f_TcCvng*)=*AVM5m%=@h>y;8TArdg<od$;N4)ob!S4mry;ZQ#(O3Yp%i&u-Yhc`
z+gtZ=CL5ws)xNqjb2`OcH5!x6d9ZG)KV&Es0O89Wii*Ge&O^<H<xs4agORV`<gq<3
zMpn02rNAiJ6S<DEyd~$yyh&SA?w_M_Q`;UfM)Toe`(~sodqfJq3)i??Y-@cuGA2~f
z60WeqSMs9E5>;Yf88$zOQcDAsCUE48`kaD%k-se49&rVpEL&>T1})__R%`2(Dw|t@
zib%h@8EcnW?#b(*s2#|Xm7GcAW5K2;=cpNYtX;{4tl{_gc%vvVqe>#*40Fdr7tt|N
zwa?F<U}~&eaRILp^|_ynIMuDm$F8}1xx<F0nXgY}*<LG0%5E?i_}nl3YmJ@wC%rOd
zSo!^SDLtQ0CMSo_yIYj%ZnfWv`FQ^&(LsA7)#)t@rYkQ8L#vx&2%L@YJe?j<acfSt
zO|@WBH5iY0UzXWEYQrabeZ(_cs`%jtdn1xpbJO;%l>|g)=K03YjXT=k8@cFOKA?Rz
z-yu@*kkij|lIq>o3zFXNoZim2UcVa`ygw?i>y+_;W|j9ya5{v`DdN_>Wv$Mh)^09e
z1F|<ezLgJ_-{AWXU&}j4r{H-dzGpXIyFA|1`4G-?JNP~0+moS+zHj1_9<}*zAFg!v
z+XUQ(y<=QKDXAF1<eCg4JJ0(5IP0c}#s1|Dat_OSp{}7gBzH_>#0o)B#W39qT)1rF
zRe}uv%1Ln^BelBK@}{m)Nh+R1B;y(tU&WXp`QrpH=M37zTo&Mj)VMg-o6x(*Zx8aM
zJC&|8&y-JSBu}K3C6Y4gc8{?2dFs~Hy}z&4J;@Z#o2$)ehh5t>Wz98_^YomAt95bI
zDD+VM1;>Y^+3sm7X})4{)aM<$Mvpu$S~C|<Eu;(NszL?ZG>Gp(<x`^OlKYfPuF*QA
zss+*;NMTUpr){a2i_qKo%ei15#Hd)K&XWc#)3;cB)OBm;iF5sm*duc?>R<0_@A#@+
zMg>v%Br+3z(XLeONNL#_wJ^5q^ELjmXq&xXgn!EQ8}b2_OB9XttAc%p_GV5}7or=O
zvGhajWDH!ce5i{XEI2(Fs1ee~f+TBnemx}3u2F5GB))BHy+rR^!V;IDITmAmcyoK<
zoq4Y?vEn+&vfUG(J$Oew*D3?IcaD>Neci85NP@S)BgnmX?Mw9lI%)<iy^0>Pgn1&j
z$s3N@)r*2Pp75CGbIkRH^9{k<U#B>EF=F=4KS&Yv%>F1^Ui-eOq}el{GySDf^xqaO
zHNLeJykQm=dGPAx^uH}y_O4)Q9$yY!yV!?o_WmqdTHkq=?4}vT^n20rJn?2@z`gU<
zLj=*oO~o125-d8x#}<%l_yeG5dGQrEp>2E3v)_xBKb_FU(E!oK_MM^`JhcHdbfsSm
ziGSgQ`cDW82C6q4&d)YC&NqJ;p}!#{PM0n(J|7Jn(|*pD&$Q$piw*l5LP800W=~sY
zM~qSp`-PAIMhIsdHhKqza^W{4gawBX7>eb}<53_mFq;0U5kf?YbVZ8&iZ59sjkO|P
z*kBrPL;k%J0`aA$KSt$EH9QE!S_m7@Jto>c#ugd_9glHh#dge%alwxD*o^T!j<FGn
z4S>h`Kz}$P@8g&dO1PgAwj(P%uq!qi8y*jZ2MWQHu;HmfaVbLZ%<<SPcx-uRTp>6%
zJdQ);`a+2RN98l{XXO(Jd}(nv;2UHl+{A?4WhGsu#GPa%T&2XErA5_cB|RiXUF0M^
zWF%aq#a+dOp<*KT#zv;VD2NL~WhLF@B*8!8DI?)&Yw08-0cau+abdt;aFP-Ozu(2g
z*tE5^OI!phCFUw1AYf%_EiP=YqiHQC<!NeSDkcP#6m`F=Z%jf0N{yQ0!p?UM474;X
zuU@@lW8tW)0dgHUEv<A^M0Q|sw1kMOuC5ak6N9gBNJd6sWMqPeM}Vn`r>(7DPIi7p
z`F#xyRWPg4*w77w1s4^Tq^DKn=9T8>RoPp+0PAC9Xli0?VrA~);b3lPV9d{d_YS|M
zfxd;aquYaWXKHG35kWf(QwLKcb4RGFgRL8=bE+ypp>|F@+-lltVLw2}s^-$-;6K*o
zo{1SJhqmEeD=scA1AR+_yC%Rh8R#2W+_Q0U@-)zb%7}Z~**NIwm;+yRN5D~2+1A;{
z)YrupcnEn(+ol4jiaZo*?=W2F1sHJBvNCXZc6%PDw4?$EnS_OPL1Ffn!vHxGsHXmd
z&-nkp{NMN!_>buk_5tRj6nfcs8s&eP9=)Du{cCz8CQE<saoeBi(eqlvISatut9@Bz
z*cVUxpbhKCRNNnx&)?D`rNxyulbyeF_x?zaevGvIi}a}HH}2l=BP~Cs;&zt0yh?(R
zqHRVmErZt7OWmXQ*Fbt?KHb~xDKK58x<?({^YxRWt;MgYxF6}!%)E5e$ssK(+<YeV
zMl_x+|9FXH>BH}5l=>FL10|PeDEKQkS71aQ?$Tk{m`W=V_~bS#Vc4h(D^d6ol*p(n
zcJPvD687qMv7fY?-bT}je87aWvXsA#rmWmt^}UsTyqfqjZrm!46)ClrobQoq5hJ}n
zUX=3vozOiT86Bk?VG1l;>n^Gt$LpCLqYDgKhA-^O5{-Ou3bG^v*;t%R%!D`cs^u4N
z<U0pe+7-CRe6uU`_WVW{Wl3l&TNEsaVV4$yX>61ifa_Ro9mX55S(^0FkEtw`MbN%H
zlTgs1BKOqCp_0{MbW1x56{JVL%<RlH)qP*-P!1gi97FJTFH=7{7y<KA-_?g0s_X5r
z#U!wrrLUtLjGz0|?7(yI=<1YU5XSX!1<@C@0dkf*?b<60J017F4x(RKiNT8|f1Mrl
zoZ_AhVz);vRTNpbVHdND|Eb}VYwuN(m)U(9(<Y5QM}ZU9AWpAr<fPB<e~nfOGySmF
zkJ8`v0g1Jy`m~qNrqBbE<RyReD81+x3<|YOXI@IasJhSEK_ebRliVdzV~_cXDu!@{
zxl@Oyg^5fLXT<ZG2BN74aKFq6Yjb-?$usSIQRgVv9(|@?*Q`M8Emr?kjl1w*<fSGI
zB7+;~;?kk&>dY|s$~kgiXwkhfvxCgJaYry;cBJSoj=TG%HtHK^QRLAIv(Z7!Ra2!o
z-$g5SjCuN~%k|i6%r}<5Epdeu&QUg;(5HS#3$l$SvoLhMvmvpyU%H0u)Qh<44nrPq
z)xRv(#&vV&iM`^e>VC&4f9YcVlZ7)%7g@hGd)K~<&v!Z8S;gBJReVfx*oQ)C9y0i^
z{ciJpTahe}pt+Ulc7ZDq+bAKUvNmxYg|6=QrSy)M@a1>NGdGrt!%ya{mmhUsl>yI$
zBuIs!n8MDkL`!}3kP83iME~vlCOeMRUO1ju7KW3eG^VSTKW5?zmdQ;il6YGPMCu(j
z)|H{}NwyGf05`*UCQT5C5hJAc4u2_9nrxXnmgmbf>7}n>DmA(DEvXR(l9x|qDT=w{
zL`+xx65-^mnA-8n4(~4etmHW&s-iT4t#BJRM|Yvk5&C*oR1alG+fzM~mK;{e-@)4m
zNmt<B<wgW37LhCO5A125Nl~S*px!<waj?GvqmM<P3+R1F<yW-{32lmG6e3L*K(h|}
zxE4vUZGmIWeS<~+#o*~P3$$zW;UtwSkF>LEGa)M|BuX%J2K0An4g3aJJgL#dQ4maK
zY*{={oEE}tB$`wz3SqK4+72<9dE6BUrt=C0?Uw<JnYLUOdD}?x72blScow=rs(Qin
zr&gYFYr;M_gWL^XCR<-t^5%~;(sEmiUz6UHSPZxv2vJcjxp;l|j81CyD2WeI5+Q|#
zIxrhUO^;Ie5h6puh>FMmrIfgcwMA$af@R7N!5*(x2-2TRiO?%&D$+-1v6xS-Y%{p!
z!lsgy(VnBjj7t8!TGb_=Jv#79sc6<Tt<`{T)v;a`AE#qwGVZf-_I4e$htTul(;94!
zfpU~wc6~lu{W?dV+N_WFmHTmDD8*SItvPR1mcG(zi5by#lqWHv`uL)YIv$PnxJGY>
znhksXOPSAmrxL6DyMtWuO)!CNOCw{$QQXIkfiAVy1OhMXG`=;{3T$C<U8{a9lGW-Q
z4>2ylHI|6WYOAPt>Tr$v*|QFZc6^t5r#XIu#mnVbpVse6E|LXH96KGI&ZnI2Gf{>w
zKKpiQvb#E`+$v^ZG+=rxzU4I<rJJYmQg!GdS9VM78#a&52O2unK7*pn3o1Fi6A#&S
z<_eY%S`3s{@9hOeN4*>`_UjWp<qEx5{`Pxmb@}J7dkLjZCMaR>fhhs*Na8w+3p?_5
z0!-~Nrq>7@U4LnCoCcHoWJaJl-iz^VKjt}}B?;eV9jzcwIB%WRH{h9819%b#(H0>y
zl#=*;%`nfpwX^-MM>_{j@!>RUy{~e|c|w~!(r9d$Z|6*GzuQkkZqpLq%zZrH%$q%2
z_MS8BW*_sn&%QPs8}C!QrzV8?@>9@OxEqBpClh@R3yKccgcYlLbUXOGp4EL=+V7re
zKjA~zGi^#gs+^25BP_jkr5x|J$lSQJM=?WvfsAgxKz3i7<3~{k^(BSzqHp{zA2~iQ
zf%K?dSl~X63(8rH|MTVv{yKT4PezfIFFL*@X1*_UdMVcPvJs?5Cas^Ci9}y$^zAj@
zTU)dpu52mr5p2zHF>)Xiou)|YXa}wo0u5TK+4|Nw7(y);=KXq|i=gdkQNGW$4aC)n
zLFt%9C%=LX$QGtohc%P7MZwFZZG|WObF}-j_`NHYbAGZo$?kWkPD+Vfgd8@E!$VcY
z_^)&xk4iq>h`AfQhWSWPR+8}Zj9kt-^X1;ugn&klczN#)s(v^z;VMZS%#~FLHZ;jY
zdRTzH%8IwtEf*+}@s^%>QzjOBE+aJ0Dy8tfmvql~?lkdXY2nALW|3#jbX3abUp|`V
z;Ey)a_>S;D*v=Rfcy*v-ZPs{?=YD9A6{vg;=OR$AcU3D+m>mtkAsAPiU@M&5D0t71
zdnw3>Rf>N95z&i-)Rf-!zaFQ}oJ<E@{PIkir}G7WIZpfMo~fAM>G&_{QK(fz)%nK1
z@JyFyrGtZ)*-3;KpRp9qX^{5vn?<?#`Iq0rl~I0h_kNhBAKX2CB7?0vb*wBa5G?M0
z$KCsp9#z8#n=}{)bkO(1!9ok8&~My5)?BdA@^{mu6oJi+LSu+x*#5g``X7}~7I}#9
z_}|ha)y=5j(oh!$R1x@}l~1+m==JqzyWi6zRYMeEC?=-XkIJWiZY;1zV4>x&>CtbM
z&+1t3E)CxZEl4V5T)NQj>Cw;1=WnJ7R6fB%i(!0Tmj(<1!9~R5&c>t7#W#W0XIDHb
zPeKc2LOV2}do#XMDWMLY&_A9qxRB5%lrV~&IHr{NusZPpYhuqr;uK}#qs_#b+{D?1
z#HUJ0uey>Jm584oCym1s`V2+?p5@?xEGOb;mIF$CKMw8GB0!@LbooG$4;1`<b@}u(
zqJUikT|Us$1NA&m?YqgM!N4E`s(qlv2ReJ8!lxjv1KNF{qz77g^5Qz0D&giPzGlY0
zDhj?(8!u49v$JxyweSU{JJ96=9XtgYPteD6u=UW@hy;x|%X>kfwg*t#plj#m9L3C_
z3EFXPP9g5jAu&;D;NQ)`#s{oe&`~Q(h&tI>dD@t}>uE+g*$0AQa8Q}k*Y>@u>*ec}
zVr1Z1kYAl&kc&i?fS#VBjJK1WkEUvfnW>ehhnJ^osJ2>^wY8<4RiMASm$bNDS9v%)
zi;k~n6x7BIm^PEUUZ$o7s)~`~!ZvEkPG0Uw2t-Lvc6m-#xulpya&kgi3PN7mw!ESg
zY(>gT|Hz8;wPGzz($th<Koif#!WG0_in5*_&Yqx*7vk#=W+UtKf<W%Y%WbZ&V>eJ6
z3#=O`JxWT;0tW`{*Dr7JpR=4Kb3|Er#b2|WmcNW<{F&vXm5xvT6{j-Ey|DE9&GP?k
zoC;4CEQKD!8`zTdic|*mA2@L0$C;dOT;h~lpR4{D&B*j8+n6qqBKn5D&r>~D1__Fg
zd)&4qULjwk!rW~~|E$KawNe*kIR+kg`u{-F(PgY6>z6v*E}uOvO2AXjM`Qb3DYRmN
z_NE_ZuCH`JFBLZ&O@eMVwUCK}6^*7u=q}~4Hkm6Ro-EewxiN!ab}8mq^aA6NBuOkT
zBJH1^U8T>cbUtZ!nQa!%X$TRm%3iMYoN*=S6|#6&7jVtI!Pm$B{Zv_wPoGJTPwO)W
z^S4}rq8_^|6^vnhQ0e1C;YS7rHgpezvOl)Bx?T2Nj32)x;6%9fhbipMUL7h4L%)k|
z5rDx0ML16|RD%U;+Htz5D}qtxFu*T+7lVFplRlQ7aQ$5rLpJs-JPrz7jXzS#WlZ4S
zSYu>lAA^>O^3mz6C5cr=GA4;*E>5S2;5yid;O}b<U7{%RD;r^6r(>%Sa#n+(pc-1`
zg<sRw*s{GtSM32tGm>#o;>;_%lL-7rct#6!yOb4k9AB_KA@Y<X87>YUlCCOxpoIb=
zqF%%h5`G^tS`w+k2rX+l9~i>9qG!B?&&7?q#bnPqzr~~%r9A<fpmUGa=9N`yDz1#D
zvgH@BL<}>%;`ltoE74WO4icPGtGWc@x$&}r(w1Ab4UWd!EnU?;>=-w1;C;#=SK?LR
z9x-N&j!1vZJ>2<La4xcCDuzt1{(C@^3>Hn>Cob~!<=h>SLkYuhGHho=W8d8|limIZ
zHes5W$Zbli28e3p2nGuN>`EK=becQAsuaVIEGJ<gyr0a^`7x<7KV)c}o*y<uNP{L=
z`{;t>oeUcHqw_&*wt_CK$q^1qSui6a=JiAft0?ZOeiOay4E-jgZB|WpNRCMUaGUQj
zu_A@s)2)GKGz<=<Hv=>Je2TJMRu%x=MZiDTKE)sF@@**#p(X#!`8L7Pn^>_qG(0|k
zf^UufSQ2rs)fW(GQzGXCH=siNyYX}pcxWwG=@AwI?_CyXg_r&6mIgnRctIMM3UV~C
zuW4*QaO<z^)W9J{mE1nvPDx#nLPdMp5X986#&xzka7||rgKVAfsD4nBH~66cX36>I
zG3%t>!*r>)VqYH|(TVR^Slotxdl@7tdU?DaM<kZE@xV3YWb0|)Mc~fNMPKki?H=TC
z`=y)6$^IvEk;^ZKZ#N*h*HKnoLNWO1UlS{FV^}4HuXE?3rO5W~sJn;bKYlB8!+)@i
zxG9`=WD!f&{|+iD1eJsyxkw3@!KrR?;7Ej_3oY<7wB3&3E4OTpk&;0#)`~fsdxvKv
zhe3Iz*({OU5-*Z<gdqlwYY!PBhtXr)U|)??#V;jGK}X}i5{_vGk;P*Sm#5#gPtajR
zBPf<a)0SVAF>+?47LJOfrwqrt6^TwbBc#YQD1~k1kJ3YjA`Mw@N>M09C284@mKG^Z
zg=dly-qnhsPdrFEYF#0pxxvi9jl9IW+q=5MPo+#Z2*Z}=jwBg#pLmtT8$59T?pZZp
znBfm*BjrZ0Mg8j)1`!wo-Zo71ixRqd$+;H=%WqPZW%L+U9Ve~q*z&GkJOApI|K4ig
zmH_;TEsqpR-<sW>@UKtY&AbZN(QmTN;na9GWE4eu-sE_P!x|8uQT$c!gIEQsdT{7)
z@rN%}MG$JK@QtU17*7(L@Tu`5SW=N@o~+mmjyK|Tz99B`q4Hk?G?QGfAc?+0Q#sh@
zZ>P1D>x!_cq?FHR;nq}e?U1Nh2bSf{^D7WW&#Nmwo`daX$_sw4iHl%=MoiLPO(Vjt
zbF2JWg-msghCZ=gnK7b9=egvM(G0NK@%#vkW^97djA1aE;aOE@_mI%|DSJ_SOO~)}
zNUg^zyTJ+=&FBQ98Rlg#A68a2T6ag9bD}H^MpQP%Ji)gj3(6bi&E`oCakgN*wb-xK
z(c;z3VfVar@kwb#Yq0<xR8}>6F8wY?rFgx8POWi$Q%AdD0H<>W<I<vFMMsA`uB(?5
z7|kGO?fbr?0Y)<l!Dt3Q7|k#NqZtigG(!N4W~iob>2!k8j9oCA@#e>91_c<+xCKTt
zG{9&^5*W=m1EU$8U^HV-W;H0S04JyKvpja_p;PMj&pGrL-y5Y+IV@nrT>}?F+z}_p
z6^u`1gM?#Pmr+d4U^F8ajAk^6@zz=TgVBs#Fq*LlMl))`Xodn9&2R>z8M!oEq0K^8
z9M<l$U1Q5#JjvZ@PidcaRN;K}&<f<RsU+?mR}|(=kHud{+w`7L!`#Y1o|7@_8r=k~
zHuaWXB2j4GRnrSz)gcbMEZ|F+fiF=kT@zp$MpC+asjYC>ZwLxc`-JWm9oE^Wt_qWN
zuk%G7^~Qx#56zB@lT)FG%kk11&*mWb%4=0OL%c2K%ToDo(uEKVs>tN#az$0*=tOH7
zSUvj;X}{5B@lhTTNOl+B8$rY11bG%X-{>k3aI5~)zF<J<!<fCs$fPtuvNQ5A3180i
z%ld62?gxv_+$ffGQZ9~IkcC-6_&ps2%+;>|i){RxoTt>TXO7A1O^wc;mrr(mADq3}
zPyR1>;6Fw)8pzIc&Q~dCy2kEIA0+?F(Ttxsa4?#&RLC>ddty3Paaerz&$1k?erX(Z
zc+aycjj#7jzJD~F>3Q)J2mbw&1<`|rM?bP0+D|I5Dl8gqSjU6!JMJkDUVqRy>RI}}
z>p$~g`Dps6@9g^?jHq{IYZr3aejS2rRsNOb{7+wUz5m9r+uwW%*8cg{&(RFvOYVex
zT-*vr%cTD~ngOz$x$6Uy1+87T#0DZ!DgWew{}W&G_WTMYtnh|mBssp+FC6$k&2o-s
zBu^jp$L#qX;zAH8C{Pq~dRPPk1wg?gVK8(k46Pc5l?x*rhY=sc2%+J4tl?A(uxmo$
z)Rf^g*b#J;5k!XJ_(BmZ$KfF0xt1Go!#{!(9>K&K$uk~7zZoH<#DLB1AIZ-e5kar2
zPVx6sG$;wh0&e(U7Vl9ZS0JINE<aVfqYc8@y41<G)Xp-;)}q|Ww!{@$X=hRHU|r&5
zi?lT_aJDURvO<EtZ(VH4-0iFE&5HE2V)V44fo@ioF;S5*3G~hh4JfuT&$qKEu(K$1
zv_u4WWe59%CHy=$yDD$j^yrYB5Z{~-{~{mPd~cV0Fd**+tqcn+jtnjLajA8&D}x1<
zm>DJp`effT1d|M4wjl^icldke2l?dMn->N7WSbeK#=t6DkO&{Q3?~~T7_+l5P7C%a
zZYn7b4=VO@s&ln3ceSl>wD+?yF9%I1d+U6A%PM$mqQ3{y?p~3zb-5cf%fr4p)W6W*
zBM)rgJKB^uTO;Y|Wh259W5ROfrR_2^ii!)X5+aNBwY_aEa{>bVjr23RtEz1+vjaVv
z1O4Kvvh(z`V{YEiv^6aV3o3?M6}#HQOOX|BuCDGbA^tvaE3+UkcbK?{d17K32yxU^
zT=}@Ir6t`|W$ppV{!b%-|D@XU_5X3|uBrK-tM>7U$A44p3yZJ*uG&XUxBgWF3+{?N
z7>P~B{%;_N=PbjDL=>#L)07h}%;Quta9A!*1U5P$m)FN$N;J915~=HQ3t&G&7K@k~
z+ptHkdag<fi&6iv9_(qgVe3YL@$-*b^%lcJYk;D<&<dSMvvm{%Q+KZ}UkHB3?QFQ`
z;Q4U*&7_~vaz_Xn-nXwgyDP(Rm#bhvf~RgYnMqX;BcSE|WIns~@)TA2#xz3q+9^j5
zKXkrQ7pr_0zy0IOWB@@7F$56AU;sfRFaQuldjLT!)&~$o1pq-T)&&qmMgT!v{sBRx
z1Q0|CZ2&=3EYS+k%7PQ@Z;Fo54<R3(VcO46&IrjSrd~Zhl+B&#FQw*|+9akYMoFK0
z8%{FV6pf89=s$}6Hax;Yp1XQwFq+azYB-99OOFAEGK$g)@4B~80yT@mArj7%oy*8z
z*V{D{&ymi$mh^p=wKPcxRaP;ja}$n&!`6jeE-y)lC3{IoiAWpDU~6+9Ohb++Y0`{5
zX^O&O_TH)>(^Igr&0YF3f}%y>P7fio=~&djSN8cj5a9X(OnGT)jglAnexuSLk(84j
zM)1oWNMnbxoT`&(neGpj-8SVOB7DnSvne6(KRbv~=xK~rdOs;(OAhAS<WN<TeE*|>
z%Q`VSW|5f|TE#$I&qpb1fA=Ars>dpy>IWp&#;~;ZUu|I{Fl)DYt<Q<0nhO~pY`0Ae
zqzyMbR8dWidd6sojwxN9>eBKi8&9oPdgPV#{f&-KcxAU=(>L~J^f>Ktxj8!w^_^uy
zHXcHjtXT31_y_F<uqQuLl;GT%iuWT_G{qSqHP|+~EVQMvI~Xg{0z~Ope=r~s0axQ4
zXDONTc+74x<vB^(kKa1XJ5%WXL=Y>{Yx-z+s`Y`yrL*g-jGwCa+*7)wwicD!1kO)2
z8gYG|m1(HAm)<qsv43H_G~x5oHT2C*a>yfSOnoMtK+xOH9T|;n0F~}wc4UITpRlt)
zVq7z`@i-cxY^^wWm6NX>OL})iX>c_`Rp(A#Hma#2xe8?9_<fp~hLERz^}A@&Po~Sq
zqk+@yC-?1Ukx`_E@w@&jl_e66iJmuHLFO~ukh2}XA&&Ldh~{13ZpGg8gA$iU%jm04
zsY#++o`j*j1$IQdVqd5<iM9_@pj?I&uTmIKFE`(OA~ZY>NuHtp7Evbo@#}kvu)Z_#
zg4^QXrIsZ5UdaTd^ap!V5e;A1-^M{m;fg8I6QOd$Fo?M=Y=xvyQNiRp`#?BRZw~qm
zLuouK?#SJI2$rb7H1R9dD6$*xu+$B?uK038m~D{Vrqwc3`A(5+br$$8N}M!(?y+K~
z*+fp1BMt=GvDB=qZBV!zGgm?!xmqb%B!)btibs6s{ZiBhxV%0sPyD^!=M?pnWBN%R
z3ASHWu?up?R2|Y1T(+NHTdS@Xo}bgSk6NQ$@*X4DZq^JqFDshvl97&4PKf4TPb01w
z7vyP4i#097VxVG?(Meay?!A%9Tcb?l(Q=u=8+e0NmQ9(G#WRzJl$l+<{IS00W=2CH
zF^6>k!e~BSvZJ>m*tll$1V9kC00eO`W75*IDtByz5I_)%Y<bB<hJsmq00a@5O$vWL
zLMYJMO=ItwA+&tX;y%Qtu?+U@x)xbP!pf$7b}Nf^dkMtWgbTdpbp^ilRylmG(VW|F
zEkWenlu~7y4UefrSe=ARi-yleyKa;aw&Tk&vFCxQJ060E)i%8MwG+(_Gik39D9Ywj
zCZv0Fvxqxb=-k)oYig_TqheD#V|<#oTTv<4j;G;;o0IdIpHt%dmJv|xO~mch#*1t^
zqovO(A}VS$p5W@0QD>FuJZA-}on0GD-4y}V&Xvb*=*Re?d853}&Sk>jDRp{#%U34X
z5GO@2b(e%_Z@3OryC|5td-b&}v>oprnn~IqsV`%=Se*%JtzjE<E+xrlTY%x3QKd#l
zi+uox-RQg`Kq0o)ZgN1|8D9lqTefwvaylYQ7oRIsv^Rvr(^@AypPcXL5H4JIN#Gqr
zv9ajv<*aZESIuN6^ked)=VD4cTM9d`C!NsWWz4-re4*?|_N@NVYvSfNGIeV`xtlIt
zgQBDd={d|B;*Co4wPvX{1`K{du0huh%%Tka`X;aL`X5ZDoqjf8vVXl7#%HyF@~CV8
zGZZU=>~(S<uRk4OsQaZD3wIR%jg=t^LKuvhgCrLp1%qB;5QT8uGGRd)lU2hbUe!76
ztmSx=`@eu7Y9+V)mk`7cB1-^*INe$tNz<)3i=2rcAVnOhZT^HHYP6M7{2hXb2EoaI
zl*k9dqPU4yo+1d_s}<Eh>J*$ltJY}0Z}8;f-3O=7o08k>?A4ug{7`TdSxbos2L@1%
zPhSoYb~MGRZ(ChETNnrbn{qCnY}<*REzTx)v{i{aldp@wg)F39&Bu3KgU*&#2s{6A
z>MkJ&S66GGJs@|-<-ytV@pNb3(UZN<Gtswbxt#=`zVAg`J72-p>>Bz`>)vTW&5myV
z+ti)uTLPj|q8JNUa!?@({gMA8>1jyXHP||%V!&hBzR&56uh-cxg(htY5A#x9Z`}0j
zp7IIxD*o{LgHTGqjFXuc0_)AD(#^ohgy}Cix4&=k$DYm>xq3QL9N;N)qoU#td_|>S
z`DC&uvhZN~YjeVzZQDzc#fJ^wT06yeEd4|m2kHDe`rqt&DL#1fsll)JLD8Pyk?3m_
zb3gaNJ@Gxim!fY-G>_YFT^vNm2CtFK9JgO%!0}<V!Vok^!Si26Ed*6C;md&8jL<Jt
zN5LP}`%mU$m%rA629`-m;9PC!w+?&pZHKU+<xhRzy2Hfx{rb;VX8MlD8$&(^xq&nx
z?4;jbV!JG;1*kBF6Lbt*AjUX2A$Sm7u=gAbz5tKYKnMSUpag;#oRa_2#DG5un3Di9
z`3pe_;FEwt3HXzM(*qEc08k0&lz=}8m^}bT2{bVf&;ULO5R`yC3HXx$BMDSB5Ys?a
z1FZ}cGf>q)UIP#%cq|7j%3lf_fG7c!66kEerTi<A65uESixP-$AiICzD1WK&UlJUk
zDFK&~8?YO7BmsyLoX7(fC148yMSkn1E)eD19L5pB$Pm9`AkBe5_xCIS;3)744rDsm
zMg!6uJi`b3<bjuXAlboVd{k(TnPJo&0b6h9T5p#h@*PO_;-X3*tYcy2%=8+~h!R)3
z3Lx>_UH#+Y5+frLfqcKoq?MOh2qe3sB@(D}le<YWl2B10vjAT>kkLRx`@1y)t*jsm
zwKXktcc|9a@dk1nD0QI1!~D_}rS69K<tj^qAC9S>mN(QU-@&TN&Jw&Z{{O%JPy7V_
zL!(G#q^!B@f4xy8!ixj$(KG(QKB*L`{Dyt{*(mxeeDWU~MgE5$|C>h9TLJce)hPN2
zpHyJOLLSp;m{t`0xJL(#q7$Qe&?x!?KG{h~>wdKJ^B!HZuh)iW<7ut=Pxxd|zi8H8
zw#50_@!_Yp=G+i~{<E_)hoO^0SL82fs}UABT$>i=1QM(aW+WQWccxd(s*xsCuA7#|
zw4tnwMhwZ&RRiYY>e9Px4VzZ_oPDfJdOXw6H64NFY9?*r-OV*k@e9^+WmDpjXj%dc
z;dK+V4TZ4`Vz%z}OlpVl+3Wbq%I~u&IHgl_lzUheWt_J8F>}5n9Y`4*Rm$JHYPM~?
zEO>C0=UJ{@QTO#C&u?2KC83z?#DN%WBpZpg#hI+K3GwAOAxV8NN9ACr<Xh4bdfseh
z>H;_`9%$kD6^QZ%JvI-S%vUdJ9##y%(0QvbKRz$VYwo#5a!pQ38n5LpMrFZj!0Z5;
zz!#P0jU<crmr&60wFdFWN-LaQrwFwMu;z*dI9;Ec6>#3wr|G%ZDI9z&3po+<l9O;F
zz1p>vcy^XcZ&Tr97lPNz-DtS9EGUOXXhA&OXZh91gqX$<M9Ao>SK(btgYMy|lKj0_
z>Mu{+BSux@9v?iSkFC2-$(ZB(d4jd7?(<`g&h5{W+>bcCd~VD*A3hQKQ1=5qIb}>E
zfyMb{R*u5u%be29`Y-cpcXqx!)l%gA`b^J&_7$0Ood-I^#AN3kwX<Cs21F`$yQYo?
zXC#K^UVrenY$#-3Zpq9IJ4(v?Wyrg-pv}u2%R=bL&QXjLW!6|(r0TKUE7W&+$C1`w
z2&AY{M^BC;HOupl-WU3TnK(qOS@C*ljw@(pRW+R2`!@UmpM2?h_80i%0M_mE{SgYc
z^Mmo9@X0%S=ZBzC^!-1<ClymX&h{VOzC8c(@^|>;`O)6r;FH*Dh`+%nl?HK*f50aZ
zn0Lkjd~!dM9v}G^_$02u_@D4erD5t<`!PZ{9@BV^|AJ5Aml9vbj?)d29Ke;-N=b9Z
z<yIc<uq)}Tk~#5?!ZTgy1EHnlo#Ufifd>f|_+^weEj2v(9=G9WjBC^~-G!;U^a+91
zq)Yx|BCDewO3G!lIT4S<m*rAYKU=E_Vkk*de@=y~l`~RIj4Oz=1jw^1kzem7UBO2e
z$}TTgPM5+^5B!{gz^`CcRDP_J|2eZ-t%CjEz$aUnt<NgBW0j|@s1I|;)hc;&CZ_BF
zeDWT{75*yaCyu|tCp#yexc&j3lwe9f1n|i!k(U$GzCDLU`-xRzF5Y(x<LQ~AbE^^_
zBdBLWPs`&;-c?Crsc5B9uA0QUQ_*8GVB2D%|0x$B5DbuX$NZEF;A8%;&t~8w|F56%
z;IkQg%mYdB>yth<Ix7;E>*Nq>W$y3i6W`ca*VtI^?h@<l5a;a~>)>bygTdsaEnQq(
z;^Jb>Onv-(lB~=lRTRJ`OmbmifsuZIs-kl^EWV|=TU*0DBR$XDBrGW@URDws83A{5
zb3q~zzFtYKE!~ECfuX?(Ku^d>K!LVkpj82S0=(YQP%49WJD?$$8PtJ#kPxv3VnR|<
z;`%iudKwj=5(Ihg0mUF9XmXQDlj*uD-))myH+96t#ehlx&s{-2IT0bH;5E+MHUFMr
zG7vY&L>?fI<m6<0oa?}gor*#r5CK3;)Mao0@Z(R3P$?v63pFnWFMmJShPrUThXhY|
z;0+Jxg8+|8WhHTdI<&i2=-~>u7-^1B-;X1Bg^^6)nGI^|2cGVLJ^+t)Kq7#*Iv^mx
z+na}7EYJ!-@c_91hID`+1HuTXt{)F<N+Cc_0YUbE;?wf~^WWp&$OU;8@;~Qm{-J;z
zOKA@97_F86lM?yg$b}s>D%W50HQG47|D9Y&pi}>6a=|5B%C)s{zywet2mS}EdiIxG
zaO-{X*ZG>*K)YTrU-P?M*k5a%X6*0#{!=c@^j|6nUSP1U{FDpf*euncfc&3X)vT4(
zKUvkQ3EX3>Yl-|Xez2+=1Qn9QMl-L6h+%H&T$dqtuu)K=*-9mn5JN_#h*9%gA(T+c
zjFQrCL4U6(#40_TeLssk5}N^nQkgDdIgpBt^$s$C&sEf&mhU`f7lqH%Wr2e2T8cAA
zCi7f)79)h^Muna#$9l9aOW~|EW~he#rWA>m?U0kGsnigufx;;nHnI9Eozgd)DB)PQ
zY_=S<*@W~^AyGP)>+h9fdDoc=TNV)!m?Xr__jLf%q)xiku?<zG{DmMo1~)yAv%0R_
zHO>T2k!LkIqqvznQp$kS-pMV$zR`-R9zP^=pG%Gl;#%osgvZ~D*ie5@wLaD;@|?Yx
zgte(j8iNOxus1-czAueS>aN8(h|hFmWLVw8QkRy%fJ2++bO)9(LhiTStl<-Ua4-&a
zL=fZMsN$HzV?V6&_#qb#r?f2<TSwg%I)|t4m`8ie{DoD`gvBls!SYisB)!GZ`IA-c
zxAXNEt2(cpezw`Bs{Y$6=RFLECHF_1N3XqKy8L8SA1wz1R<)lk3WQi{CH#`}-3pw@
z_4r-ftv>&#B#PzzT5hI`<ES)qLd&&$H?FR=B0kFQb>vMUk*$jB@Z+JHAFOKCcesF6
z-6$XMn_Rg0C~)r|<U;Vx$^SLE&{@K0x;xyV@P}NGjG=UE`rj=VrjUewf0YYLBaGC)
z%Y_jZ5rD@4tm-PIQFh~lc*Chb<U-6O0p(6>1CPomrropn!+9uKc=JJ$dtw>Q2c<_M
z7yEuDgK)~7O)|019<258gB7GQ0_o#}aIRDps)xrN<u}-vW2cZ$s9X5Ud!2P$ZC0@g
zQNtq*S5oBP4am~rJT8=SFsb+lxiCR2>l{wsS^nR#s{fD+AMgt3r#<t5T*!RfJO8I#
z_@F!!_&ck5LJ!D=jNF#9Dk&_L*$C<{2yFFg8H&fVF(O}(#LSEoj3OD_Q%d+pBh}&p
z@&6ZlZygl{+xG1a-7s`_4c%Qs58d6}NH;k2kkSmGNH<6e3P_iThzeK;s0fG(sDL^9
z(mS5}$#=)QzHjgKZvS-&D2wI!yUz1>985X-1@#|s_m#Ev?-f;kY=9ZH>f6LsD!^bx
zOlkYEbTj5B3p8<mJ*mTm;6M_vQGW~?0O1Ct)KXFg($WS}Qu=@uFDa=fB%~uP4fN7K
zP1VxUhGIfiVqyj`n1+OezL=18fOi8wzqXK&HbPHFTFO95QjecsQ%1&!AEqlMZ6YOQ
zC@EziA))v4EyBAVOfE9ACISMQU~GX2sELW`2@2^83F(Q58A(X!iivB<%IHf=>&eL3
z%gP$aNP{oHP(l)X4F-ICx^i-+GIEBZqWW9gFJJ;1Lc(xiVT6#N4ll2Upr9^z@rVg8
z1|n@y5!owOuB>)5M|*H=jWKSIlQ~!z0JbG9Ek{zAc~)k+o3pjPnsiyZ(Y*%9-MjY=
z58ovxr&*a8wASRv$SBOs&F1Ch!Gw&CKYZzHj(+*_g|VsU*yzaDuV32QdItsuOiZnF
zlfAREv){cxX{hkqdj9O}{L9IQ(}Kd{_wV0T*EETU8nt&0lqJ$hNSZ_i`!X>rXsFAM
zqDdn{$~ZaIfCd|Z0AI5z7ndeCw>&*Pzn^C<aDM;h=LSk|LoGN9iv;k0yE#^b1-ANo
zHtgM2O-;BgA}F5|#pnEUCW1TKWJF!K3??Hm4T0e(B%t&`FGYY)ESQPFKm;C7z(53s
z9k66oRnY{(D}=6sxTq}{dHDHF6lA@?j00Yiq{Mx|I0N2)z$#H*#sf?`zl}NnGiQ$f
zFlYcyo>=gB=+<~Dfh1dm@)39aKXdYovXz+_#5o}NDYSS|Ot6rhroRpvKJWICaCjPi
zocsu)7LI&~%~<#6NnzU^bTV=spKk=NXQ`b-at)WN<BxX<f+o}PH-xGehO`7E_pt7c
zq;MMmxINfS5)zS!Z_UnEh=<LKGg7I;Hx<wp?SPXv@TN44GG@a~TQ6VQ;eqM4)Fg6q
z{nwzOT*us-rk2a`VAhac*kz-G^MMl9!Olis`IWlSc&|Ib<uw>AiwqQ6B8~}ux;&P6
z`^CE#4r{{j)GSVgCd9((+$;e$?L25Y;nFd%Boc;nqo|EmLTAXy&~!D)G=eX+(;2+a
zX%dNR3Z^L$;*z=~R#+|DSzyrMG75_2g^&r4o6S*&x*}~TgmznA<SVO2Waa?N;1s@0
zi)+0N-ucRlB173>cYHQz4HAoZJVcX}o+e}h5Byj5s@!!kS{EN$;>SnC<Jql?4jkOy
ztqPeHczroy4Z!VVcI__n#+~lJzKX;b+^hMeqek(y?bYSV0v&aM4q#4{So`lcqP^RI
zjymdKzquwu@Svrk%>SUZrK#<ptz+=upuHP#^4@gxulc{}9NKMr(=~GHPXkTD<qG6T
zO5;eoHa}}m2+@#^Kg1^G5ejNgCzKc;Sl3YM?8tnnhy~g3W_~;PvhqvN5RR|IyBl@Y
z%w0DQXP>m*+?W)4KZ;%z5*_>I+;-u{i&LSH2Fzonqlp|k7V$|^?zWIADEpU?X&Ms6
z&>4oa*yD+3-lTi8Y#-vCYB(|jB`@<{?U1yzH!V9^6qoxPwj}*t9^4T&$Mki0yj<E_
zRwW4HSka&tVZW!t|CV)CU(Si;zOgPD%L8+pQKpC1K0%CY_R*}2>&}^PZ8-Nc-poz9
zHz!uG$3Pzpa{A9bd(4@c#_{{0QH77$y8hfy1slSVa1C#9;v&XLK0|Ej!BE@JX~Wgm
zmmjMs%Ou~9!A`epxGppG;Inzk#cDHh`%9ZN+fCQWkq7$f?gfWk^wqHzsIBe5KAdqU
zCD+<HnuPj7oK2b=_!!aaI7<dwBZhay(ne0=9b8B8Vjo1PXhcQ4A7w2u6;m}zBXCQC
zzGzmXesjWi&yrU#u}-yE;OKn%oAP7z3evtslNEaWLhK*@DXK1?--|(5ILwL9m4pdR
zlZD*2;5;xE@|XT(P%R=nsf~0}XV28Pt<URnw<f46kJ3aa@rWN{XB|<dMG56@t3x@{
z)HYT!QjV^WM#G>U0OHnj1BU`b;(48&yf9NcfgXCvSEF0vINCU&?oAy``@UIEcBO&)
zXc=k-%Rkh`NqCzci%v%(#URV;;}-4xmg_RTlox^%>YvV{l@+ot<vY?md2z@<2?mX%
zq;DQyc3_BWl)VM^N}jb_FABbLO3G&^G(5l-Sa@vKThw`zhfl3}!N^#&sQS<bVv4<J
zO59n}M6&@CNm;bq=_u}6dL$@@ecR@kv#g|*SM){GZKuk>GDg2fF)O|$x5^ImtQMWP
z$m(siHt`&vr|y!+YfFCiot0}POp<+!Jwai8ZeTY#IY~6(b3#_NV_5mDZa-78>9==@
zzZ*0#V9@w*6++hXYtV4__Qd}+XqZ}&U8{xWwP^9{-^;fDSjTXuMMrM&UVhxidJeKy
zgs%Ro*hKelgT~@&*^Q5l;(4uxKKl17AAf9;ztd_Qy?DR+%g1IoS(|C5{)0NEPb~<e
zHuLgDKtKP~YMR$(*{uJt4cuwi-f6SGzWA^!?o+!fnb40tj<w#(PaVES?e^=7YlAmF
zb%x}%JHFOmzw!7}SInJu=d;E2u`i#lA;~&i2@EzSnNGV=ciOqAZg0#gp7s>vb$Id{
zJX*9r?M2_|@Rn0*Sq(kyt8v=a)Kub6D?06OG3xZUx&3(U#_2$JUT5HdMf#(C;x?bb
z0X-UHrN>VP+X%<Vx<WDy96P&OhvtpC!pd(uCU*4=uc(yZE-^kkus^%8ai=Tl`t4`$
z;?8bvkzI?KGuS+-JR8|Fx)!&7d-L?h+2~Q;wS?CO&%ZoA8#}*qE$Qs`^B-T%Zb8Vq
zkpzZY*v#kSgvQ`fbZHA;>3jm3-<`$}N_Y<ElMKt<8FEY8<niZIlu{xnUBex!s`F`>
zaZk35umFdr1?}v|)Loqk9!mZ<!@|ow`O#1Np(`8HO<O$$nT9X9m>==vq61k8OI~v4
zl%`#1>nwhSpJ_*i?P4QJ62gz;m4*A4XC@{H8N?eq>DTo4&lXZoCp3_c{$?Qs@=;(C
z1r}1^9|aatpdbb2Q5U;1V}m3h9|h)7;3zdVxCp$YKu7BN(?yB|M$!Q9Twoz}cPx(#
zEd&-)Pp5LA8U^-HU?&9%(wOifAlL!#RzO4=8kl2kmg4S+1|m{m9*vJKwl>R1h%S$f
zDDrZy1oBa!H4P62f3V2M^-6efo|8>QkZ+o!bpd!C0|#0`K6%b|mz->hfH(AF9NONp
zFvP#0zpf}MG~dD)>Eo7ZYZ)IIg0e9OAECnC0i76A>gjwrz$+{ALY}uraBM`ry%lh;
zmV%KM8D9m4Ust>0h>#*s<Z!Ug2a-`>PR+KRw@^<G@oSEXNbavG0y8X_;DCWODy$?f
zvNAoXz{9aBE-dY0R8~+xRBL&TrY3x(<#Nx}!p2Kt=BAn+t|2?O=ybKB8JQ$bK73l~
zq%6HCf>5*G-rkAvRjj^RH#av2Cbh0>{b2b0pE-j4Z~R;T=jrdyXC_*5Vj?r5f1dvS
zpFK1Ew6Ojcl;od1cb)6-U(+8-PxK$uM&-uF+^m{%`u-2Q|DYrf0kzSco4=l!Tv%7r
z(vM#VOOm)OC-|1LnAjuA^EtIXyxEAh-U35yGzGcNN6fr&Qsc=9u8?mCye9E00d(c|
z1uiu&Jd(p_)JPXVNxpRO>NVR%46U!LHrBy)mjnXYJr2z$MCWX&6xP1Aa7sbMRyvC;
zx;BY93RZWKogA@^g4LCCp!h-0JyNI=^xXT?Da~@JS7D_LfyeR%d1{{t8S_aF&~yb}
zoOXppZKde?Let)vh61>Poo7k2S!+odLnu*UxvL!`R~cMFZ`V#MKX$j$sH@p6CvaBJ
zzA|Ld@3l|FW~+~H?7Mw_ANMt|FUiN#->Vf!Rw%1Q$u8Pn&7VzcsGu^dENY~4Yb$8t
z2~}*U5>{;EX{sh~^lji!*N2rhGd(<Tx`vG*Zp%gG-!N~Loq0^#WpS)u+}486%uqi`
z_jMi5EJl2?mm7MN44p07PxYde=bR?laA($_ycc!ThRUOX1NeSkZoM6jS&-0WJnW6f
zW!almTBiyaGMfTV3!LxAE{N3P({tdGV$=IEOuW}KWl4BIC5ePjOi|qJPMNIxeve~{
zT+?uZh}vR=mXwV<t!I`wn&m{x@bbumd8Y7=7cqj|vnNv=LoDIi91uK7J%hbrTuS~W
zj*q13Z$kQfZ~Q1rqco4$>c0<1M@X*<s!~oqv{f2^`@qq{3X6<w<k6=MvqaXY_&b9T
zkw<}2UYX>s9UN!Gp$7L(pXr$;Pm{quV)7=*4AIE5E$#h8O<WXrSISnJ961fGML|f+
zj^NSO`74#tLOfC{@ZEWV&P<|aq=93lzs^n-{c<2#*rP!!Uc;vTs$-pvn$cn$`t|kT
z*=EtM)?xLH_tVW<Geo9@YBvvN<euMSp3p@q67?%xP|?l!`Yd{DJ^JcBDjntT5f3)Y
zUGCurrg2Psp-S6ItJ$5qx`MxuErR(@8ic(1{rv1=!4Ik%MHr@{{@Yd%9ICD75au1B
zNmlXXTKgJY_7*tN>7^9P{u&I#R(<WQVJg|SE53S+8s%zs8t>ERgl4{~q}2uKB3iBl
zGPdx0!$*4JfwjagunDHM<uv)F+A|Ci2Iq{rgz}ek|L~4_oQFw*bg;LU)TU*c*SIj#
zN_dkj2R*aHNtxv2`HX&QZ$zT#UXBv!4r9=DZT>Eah#=e-%&hct3a4H9QQzE{hS9o9
z6+O{J+%MR_GTcz7T1DDezTjleoYUr_O0kXL*+k20>J8p0C>vqsd!dV)5+Uhx^2C#G
zK}Szebj9~1pn=usbY4HdH=r$n_lY1f<6VqyVejE%T&)!()p;*278J4+wlGM7LSkVd
zyd^2SA?|~3u?gT!k~rgrKD|NM1is_at&a=?^2w?mU-p(6ZM_{B9DezGD~>`j_A=-l
zUeQf$k}l0Mj+r&Ae%J4#Twj4PN!%>Hx|7hXrn$C^B)9a!Yix#7yqZeI=BT~x*rNFv
z&n(#ZfycS@o;GcnS$c3uJ>=7#t^m_2D!-&*n`U3{h1I>dt_KbxrF#Z>>33o)Bbr_x
z>=}hV7P(?y(ySt~Z<4HU5$<2oGLtP}o>RGcMU>V`KheKC;lR9=E4xi{;Gm|v?I9v`
zpgk{J(3XOCt%tm=!}}Ap{r$G)YrPLmz-5|4y1mu#Y-`i^{x?_F+SX+N8_W~1!Rpi2
z>&c^xLREw-sM<GR5`#TDRKlJvJdYNdT6)V^DZQnh)Xs&;YFB?hL}>^;US5@HZ+yGr
zZSkh&VecutD={e9UC050DHt3iyCD)x*6`%nkLK%RZz+OO4XU@P=#^$wg2Rj2pT2@z
zAAS@o8gY&L*}i0Rx8T6Li|8lJsYc~DAHO1tnQCV~R4g4iX%&r2tl#`}(lq)`<eFI@
z^Yg>p>tlVu!s=1~{CgYz*pEgsB#v+u7Bzz`zUq<Rmv+~C;zJWPvEpee+}lLqd=qr!
zWEoQ5D#*fzq;^>kGG9Hhq`br+N2_}5Y2L9jmp0TTB6{TKk;_bRKSok^tS9Gnyff=m
z#*C^CX+dfrnv=RhTtPL=y{O~ml=$#MdaPs#fyYaMuZ@e=yCh|O9pxh7jAG_L!dxbm
zY3Y2^RNb8kE1pc^=LY6sX2o<wd^Zn0#F{HaqsICiPda>tMq<#3YfF_lM)Ymo$dxJy
z={lMFtD0huCG(P`8)6NObPeKWN_3EoV&56GFQk#u_u!a9u#j>girm%tBrTL02Nt?K
z4`b{i_1~>{+FtUeFv{<5XRUwZB-OM&W=-0in#a%<m%Nd~DBXLz?$GN}<D+GAlB@N1
zO8qPxgs5Zaa0W-;LIS@$PL9ndbc6@fqmcMTSaNPh;%QMgZ$3NtzuG4;KF)Udw|x@K
z-z=<u7D~SD%HJJcj$RH|I_>ypI9SA7){TABOE(@EOfi-7a1yF9ApfaQ^8L`)<WD%5
z3q~C}e?MhTdK<zEMgFx=0^neOWrKk}$wjdV0zyU{=8cFd^xctNxqs1f|Nc4@30Zss
zA!z#x8*FYA;z;rJ>DQlZu(6}ei(j9e^_-OR|IP+;`6SEXNv-7y!DHC^^3VqPspsnV
zw;nEEH{Yw?KAX9lcvSxU+w=7w=l3oq9%X{xvbp%>6+7mr_~MV(*VVqgfByaKK7b{^
zzWC+r;<xJ;@y{<3$RhzJ@l7W3s}JPfx~@w%jt!8qh9m<iD-$Z2z9pG%KADX$g&CH@
zj!Nc)rLdrrxqVZFHj+hRQiN?&L}97o@~Hy0se&=7A}uMB=v1DTR2AD)dHFQ4p;Rq~
zpOj=p!ZgG4R2E-6CGkj+dj#e{ZA2KB5Rz_htJGiSW+zYSvO(iEl+LV9;2D#FCz+8-
z4gKpH9S5w@e|y~q-c}$YwK4<C?ieuCTNvkAnq~r@tDR-Gy=9iUalVatwu5y6P@jOJ
zH!!w>qO^{hwVh=acoPTuRiJAH&2dYUbPMBrArV91a21y@_<S33FvIzJis$<(Ip#U>
z`z205v1DczU0S;H<nd!CXLk$+1D4~!5$o$2D<G&REu(L05by1l?C%YN#iiKr9MJ7H
zF-QV-SRg=Elv4}#k7H&LjSR{3a=oaiXciWf0bb$rB56Im0)2e_IXJb0d{Zv?#{;J<
zKTMyGU(wzw2LvFXP?eO>77;a7R?t^d)Oqq`gOr4Wh?vjQ!%Iq1nT=IOK+q^MB1vD@
z#MDqG_`-$x`MEB%dX%sHXf?fxiiwAlwwakre+lLN`>Wa6Im=yiySuO7zkl0Q?N?vd
zgn0wza>|S-wW_KrPfPBlUbTf*`o0?D;-aF>XU`BCI{DGOZ;!r62uhDuQp5$T_w)@u
zd-jB!T!df1+{((;+B_4eTY=BDDwQ)NAlcR;*U~uC&N82mPmPC9pOR7rkch>_5j#^V
z{dHM}x^XsUIc|;#@lgeVz6ln_`o3N<;X(0EcEw<$5EYsuE$Jd7t7c_-37B7jVHW_M
ztxRJ<@gL}K`wGb-LK7GnC2h@fz@Gxq&`2NQ=U#23AM0qHtFM#n;Zl|on`&wh<>iLv
zhk<w&=Ij*Y>QHQF9i*t>GumFHqaxE@ktQbWYGWP`Uh0{dmH#&;lK<XM{a@r8uEqI(
zzPelGVMs2s|LYn({54F%riFp31*LiSZ&!DG4{Nf*u@QU_&_`7C!fpFg-Kx%JZJaAE
zrD1YaghMf*pkbopcMHtAYd$~UV#$j6>m^o2r=*w=jRKqJzj3@OUQ`Rf^mE;c336DK
zFQoMkPb6!+y59m`w-e<SNom3i5u6h~WQ^QQ`c?Q_=z(8rbU6WB{W1<YNs-n`UeX*o
znmUT#uI}*lUdo3xq-XGjOP^yl@<xBI(Z8N_PqQKE<+#R_O-z2S(M>fQh$0AYfh8vX
z&?-gkQ}+_&zg?rZj81Q7a%8}EP&{S6J3n8y|9Or6>vj8d52#!51zr|t(N$Cn>b#@T
zF8a~fOJ8KDBk-!k(%SD;sjYXbS7LkM&)4k?fnBs`ncr@OZ&T}TWlQ4DWL3zG6~d~B
zx<?4!^uU_tYCIaV*H=Bmda<wtY1*){v0Nd0b*@w^5F9KmrdB{5@oz25*AVoBlsF%>
zmR1BW`ZZp?F%NHLNx$LO%pIA2(9YF{5fo_eUL$VkC@%7U)1|zlD0prBU{9!Xf==m0
z_YI~e=Cq4((}%snoNr!{-H8(j8rbNH2^x(1L{QP*k({$N__R!kYuKk6*>v5%&cK^}
zmwZ2X<fGuLgFf#&LVP0-h}nfpUw#OQr(sb99;M*1cZ48`#14-V$<%};;wVinmk)7n
z8&J;*gtEBL*g1P0_gu=>Kb(hIIG(gEG#&QNO(Y+NX&*W_94`qi<bGHte3($a+_HP}
z<c|L5Z+=`&xCP^@M7T&TT;(U13ud(_(%#>(bg<NZNEv#kV4Ws8uW&=JPz3tO)uYpb
zKa~YK@#F&ivEG9Sg4fuB9gw=~o7a{w=4a14lHEzT)99B8MUni~_Cm7K?}o@qLWI(G
zFtK4-RA?XP3Ft$2jacN3`4vsPhT<-q*H7!}%7w00(R|r!v<ZnD#uuiog7dL_)OaI2
z%69Xx<%8-yW;~}9Qz8>am2UnzjOxuJRu%IV@_Ef`MWW?4D^q(a$``($d8CWpB!5{f
zMtHuL`HGlSX=LjM$y)%G`eqVpj-X6>>7qqR3e~`14E40IEL|mAu#S+rlv_<@r~M_d
zgvs%RGf-Ff1TncA0d&dL*qZ}Iu(g#+A2W`pUn?)?dnCk?fF!nwNv0*73lt*OWH#QT
zC12y95~8UkF^EiGKqY4|5@GXTJWZ3Cx}h|17R09_TPib{I=-ZM9kFiAq@*$riQy6o
z=4zS@>kY}2rb(qMLu(hJ+zHE%c4#ID$COKs`3e~7Xd-O|l}u-|FI+}Yc-EvU3>Jjd
z&U=`1)TTn)#HlXQG;k>tX>iFG5z5!#64C4F<*Z;Qp{E<Ztu$onKW?Tzdy>YjwNGe%
zez&+K4cG^U1aX>9N=Z23SkM_s+sBfey$!EA?4xcwV|SKc_{J;V2U`+Q2|+*Lgp*1S
z7$~-qR7@^3F2oQSS?c$dJ?wuaQ&nMP8!Tn>?Bnj@5TkKGKK12S()?2QDwg#H!>`=(
zZ&vbAFp6EaC_n6P=D5WO^3A*OiccS3tKNNNl3dn<#{bTyK~1cZRGnKZ9RZW!tW?i3
zFUg`Cg+b}t%w|IS>yck!h&Ozzg*qbjeA*oP7R2MFy$?7Srz#9wD#waerM+ZF_vgdf
z?q`ik)u?DcH!S^>U9+28y&>JEQK)a+C`(hL7uj|cBWRUsHqeF*)U9tCA9l{Rw>yih
zn@;Ip?<p$v@m6U!tf({@C@by6i+rQE{l#>+i}q^hz#FIJw)HEG1J_g=+l8={q%z6N
zy5(tw-OnB`&d^!+<QoY)<ArR@>o0W&E?)8SNqKa~zN2rPs?tXU`|&-+j{YVq27ikH
ztNC7Q(7Xu>;CHZlgb9-w9Q?lS5}wof>}1ex?0aVqD9pQ3ULP7!6b%b%eEMp#ZFpIm
zHlqG(>%RG!`P!&xeQ&!H9B{lMzlg>>;@LbN%;}<*c^`hyq0yq{tfkoKeY}Cy=I653
zu~Sy+qz}wZ-%rjAetdslhAq4$OgS`eqbQ!z-mryd(mFw&PnE`fxq;~GUIh&wDqTug
z?6hv5kVR)cLo-2$qF8=}PgNq;qGRX7?Dd%lrsKRYh)44L(5(CoiTt337p(VN=2Xil
z3sOnzIjJ9M>!?cR6m@vgN(?W+;v`FqcwPw<w=7!c)8_Q$@(PE4)^z@Hk};Xf#k7uI
za-W4(-Vdym>8rqK1Sj>S?Fjp%1Pw3Kj!9MLXuVdEYPriZDV~Kz#w9g{UP)prucl_@
z(UM|<=O^`F<Pz~iiQHHny&>I{-neh{dgy-ju0+cy&z|}v#Rqdh-RhyWZ&lv>uxpIG
z!^7!{-TgSl!Ldl`{WyK6i<N_8%lG_KMLeHU-P{;gjmpdD4CG<H$$P_hFcF<sy$SQw
zBkqYBY;=P9UqnTc+#Bo~{m!8lQq_Og7)8QhnH8>^_S9u^r}lmxYp8|Jrbx#1o7W8A
zCt3_Y|FL`K8P6KRf8WXsZ+&foy6b3x>zg5m>W4|jYOYMxr&_G8Lo=8@rR+<dFK9GU
z=Qy!X3d>tw5@ND(T}ZFI&#FgIalqsk)utJWaa?z02`HDtmus(laMV=A3|Cr-d?a{v
zW6u+)TW5f}H5I5^&xo<`(~)g9DrRQuD_3MqkzLV=6?S(`Mcj`wd#gqd-G1hqO)fjq
zh6jQFT$tydewzde^MB-<>q@t&@1D>8wJ%?-nse)K`9{rRSMzTiFNL)C5C5Kh48>D^
z_b2-p<QtQ3JIt6mbNR6oJ<pL>zxU<so*eIM>YRmKA3ME%_xroPc|A4(e+<feI};0y
z`8V+6pB%5V_epnaDM(z^ahS&iuuYNpF-Sr*l6VM7x`8A=M?x8r|AZg^w7{T|Slw7Z
zd@QArxG}tfJhmx(F)9Co;|0P^3pVyqvI};Su7m<iB2I)8+2NV0Wt;Y=1x62@s$Hk3
zdoLJ!f_R-X&G1ik>rk3;izTOg8d$~trf$_fPxoqwmr=)Q69-FjX`&iPggllZPG;o1
zbOa(ZY$!8yNIIqk5(Q+l8=2`XnXw2|0t%HgBpr{DM-f3$85^kZ7*ydoD)&4y-#06n
zFslfiRlJu~W}8)l%F1rZYCvTt#bg43YjI0<R!ml-e0Jw~Ruv+PS{w^eld3X6T<HqI
zFTeu&QASAaxO^^&YwnzU?xHVb$~Jcvm3s%4w}{BQjm~{IpZf@vHxA349?HAllK1R9
zcgr^a-g(~Z`Mh<8`~%;-H@^83i2VKe{KdVzmGk@$=)AMN+#S@VAA5Np2`_D;@+vv(
zDKzmq+_0!>3dmOq$T`5H7Z%l40Ubvn)D?>ch&VnMP%0FX*%d;w3fWr=$%zW7h70Kg
zipU{F^maw8Sw)-`g%S!y{QE^R!$ktQ0>#koLcaY%d4*!N;bPhSV)BAwZlV$uqGFNQ
z5`(N_xrIWxg(AU)BIVCTh6<%RM5S64K*d^U!dSRTUp7gPaJMUiY7sE1m(kUidHZor
zd+>3FP&;ri`YvdNGCHw!(_DB&6L7>EX-64v$0(%*buwiP%z|<ud85U-JjHoq_t`If
zMq~G(aVh^Uph7@E&H1%}`;%z)6J(|z|C^%}$Vz`{N>hKL%?y$O+6>4_+1P-fR1I*=
zbTq<2*&j$(*xA(p>5PLzRYxPj#6*pQT@A!eY8q8$W+h-P{l!5`2PzmqNuy`b0Pa#+
zIyK-oWn)u?QmIl=tAJ$7%mN3#QfJ2~U^4~CGe#yjfTJN0;HpcTj#dd!(gXywK>DSo
zRD|)t0S-DmIGG%(N=2o{!2xGvQUiWdW)@vWCUp`r6=GsVU_51IQKM&6W(5P0MSzi!
zA;>fO`g+VPI{aMnEyZwPIpyLufl^3G3kVDIs{r+>ms_a2b1)#U0qH5Y{N`kUv9fBY
z$*X})qPnuCmus|~gqodg7$t>-l@==iu>n|{pI2;WHn}j&dbW;kuu7u8Ldefv%-$|w
zph7s=kHgYP<!6|8Q|PHO3=WDjGc#3J*8t*G0zv{413wM8b7^ULMR|2`aYb@UW@BUf
z@bC~SGY_GzJUl#kx$1HXvLGfjVyGbnFx`;8l*Z~@=0;&wrddFVnh{8y5FiVl2~-sQ
z3uD*;56%Ge+d_aaHO0ax1-Ma7jnyrT<U)flHfHmKe15&04xp-qgbdvs3Kv>w=DSo}
zoZL(d5`YF3JS&(Pri2ED2Kgg<t|W#9rW)y9L`KE{_?oJ65Qw{<S1G_@-Ro%~uzUn7
z$p7A0`2U`d_MZbPiN4>2ryjeChvYxpd6$cOEJ_cXfuGux(-rhzLDOcn=F{R6;muG^
zX5IQfYhi;WMLbY;-i+Cot}qA^+2_k%qtZU``vOjhR<}qo`0yLi!;rUj)Cfh(BZKSR
z+fyiNAz2ox0`?Y?@5JKwYV~NCm<Yu-mxlXZ->s24m{)&6_-KFvl3RmQLy}Drpn3Zj
zXnID6@JpgA4`D#Ei$1A${LP_b0Gh`6)LuJBEfb<DfDM0@`M7uS*PZv*{eBI)AWTJl
z1|cKA&`R9TT3Gy}o4TaQ(!?{Uj|b0nOY6V_4uhu`rA{1FGl3P@gSB^sff(F*n<iZe
z(IR&%32{oInA9S44EEgH&g89aN+oN6KnVz@C<%75g-+&nvIDG4CpoZ<CUH^($9|q)
z9q`)`T&j`4Bc*p=e^H3wBVr;a+K!>47ubR~c<cWRs8xDR$rSviSw92nqcYE;tUm(k
zKb>E-zD_M8ec+>=c_{E-onHmYPX2LzHM_6>ug|Z-_008XM^5e2afk481o88_U6Xr+
z8Q!FKFJ*thCM1=I!Xe~{oAADkurI<m_oEEP2OiN0W?Pmc1hEKLqnO99Zx06S5AVm3
zbln`d!gPP=<1+5G8*i4Y-rvg6N5XNx^^%Bpotg`ZPaH5M98G12I(FZJ+H^EelUW2F
z&qflnyzeIu7e2ZC)m!;wA*@VTY*F~;{_(WPTnFE*(CxrJv~+66@f~IUitt-11WvE+
za{823tsop4dzZlt)<-J?98kJq*Kv}5Xp7PPxNH~wY;(;yvy*)zoK@uX5r1Lc>Ep+(
zcTS(o+1-(O8j;Bt{VZlZDta>^6|)=l94T}fy_H7KH$jHQQge=l<=Pv#T|f`yQ4+$g
zpI?<~bqza~qUvT|*Tj!~-V08IK!i{YU5fi1J~Q(|nbV?QIotZ3UkjB>t`hT(oQ*9q
z4ibpbaw}=oO&-tjV~-pyQEQJJ&$Hi3`0xPpG2!EC{FPZlW-2YMPdrYSzJKHo#~KUW
zVZWgK`L);s&996S?pefH4_wsv4}DnizlB+0WiUcWT}c?GZ(+B+#KW;g($fvW7a5O|
z`6tH7RQY5G?ZvsNNXH?Dv$Bj!<Eiu|+05hMw7;ku?*fTBAxA+LRHu=~=Nv-kjY_8|
z*(SbF1t&y8h?7g^(=`R~XfUeqX)X<{Os)WIJ-z}gs*Y_AMo67Wnr}K6)iH`6XBvS<
zV9P>1sm)2Vx#eq91gR)VtZQs&TqUsxO}EIf7vMBvR48%xm!xIgX^d(}?RFk@PTc-t
zD!f&d-2UUdD3)x&j+zwK!=6hL>XTOI=FOUMp*)d>Jld96c*gRpD1_q^&Z{kY68Xo4
zwH*(cNF>uM`g;hkz`RVkdQ!CxDM?zDvp-Xv;Ft}&Vv9mv=>Om_NH1~AHHE)=!U0Jp
z^{qo&2&a<Xh8qc&aOMSmK+38>?o^N00dSxX$9h@D+sI;mG1p}J-tlGOm}D#>B_A$c
z#6<f7HA)OjPySID6Q$kotA=lyS@C8?$cZhpanm2EQ)VMmPQq(B4O`SX<0j~BYpTQR
zVc&#_SBU*-Qs`#(bcGbf)AK(jQzh={eJ)=`j_KzJH5wVHFx@{Lt*PbfY&8<Aw78OT
zsb1xiz$XnR%Ua0`O{dbpV_9j|Sd`yt+{tEH|9IpgU1?hb_kmW=W5t@_(ssK6xNb4=
z+Pu*~M~9M-y>9c`fPYtKaQbCyE2j0y*wU^@vZsztl{PoaKDH;mWp>25eSLz8?m~u&
z@U!3p(=kEW3-OKn9&e&-=8U6yl<^MR6(j6g#ZTL=Xgj!T3Ju;XS_^1W30f0BvKeWU
z4P@{|B3y0{ZeW&W1CAR+Ab}+I&&)*z#*COkQib}rsjmCXs=T`s({A^QFK@UjQgpQ@
zz;0jF=IW?QK2gW*rk7##UYp<F%})wB=NDcdp{wumym!;_k$3qh%tFj=`*!b#ReIOc
z(F<cI?Jm*B*Kciq5kvOyK5rr)azE*uNcOPa!n<xbPCiQufNt#o=w=OoZXNDQ);Iwh
zPGmohW;G0jma}cSSd!jn^_6bZ_O;E3TGQrw<hC*1M_clYNsI!}bky<C+#~m(%w$6`
zX6gzH9o60@5Ks+4KrQ<sQF4LzmB4!2qILDd;y#vEk?_xE&OgHHCxv&l8;6Fyf@#a{
zFSW_^*<q}Llfv^tv%MAW4)?qn=*!(_aZ)MIUP_{~yo^KE1~jD>8LItFX&vs`Vik8E
zdeKVUC-v2R(z;sKMBOAM(ySF;X<q%KzX51U5kWT|1c89M-f&>m-1@Lf^?t=ymN#ZM
zuP+Z|(6ol<wK#oHbT3%`aLtJI@H2V*(#+{m4>jH!FPnw+<u&U5`n+a8izmjpv!4b?
z9v%jLXnC@^MmaQfr!KUZS!+%8tZKFMoovs|XC20}BNZa=W7!v<o?1i4K6DPmeTX-G
z|05cWEqWwIIkIK*SZ?yx?)&uTdfVh@<kQ^CSL}2vcixQ2bV`gh;f9YG)6t*Ky~y*y
zhQ+)TzzCf#n33~0bX|TWYN4>S{qnftX6vr35A|}mYTsJQ;VWg`;@fxoZ`a_s?!^@~
zj28w+)ZQN1_f?dCK+E%-!O&@qiJ;=)wfsK!3s>H_Y8<Rj<n#7iLr^e$-d?(69F^*E
z-Oa;Bk6pDs)2e@z)9O71CFwmV*T(mEgbVRHrs#rO7n-1?>NmC6lEWr0B96IYQ{djm
zp@TR{zRtHsN`<dA>1|y8P^nh*K)wIgtdG;nT9<o!7PqbhUKp_~7X2`7XHx#?zOyJ5
zGypg1)>jDZ>nU-Y2DflXDn7$4EIC)mQ9KQao;>FBvdh@VW|Qv+4wx?+cYh10@tCh$
z6t^(vb0$fFGh_cLpx(teUcH5ZFd+ZV&hzgA>QFMvA9kK!plN45>%Rn4dDqmBDUt~0
zBDqxAm{baHV!ZBu3!462QwmFKsuAp2;VX5;Y88jr52XV+kMsH8K-2%ADRo9baK^Fe
zEYiu$@r2>(-+KQIXnF{h%YdT9h(nUoGxPo)H2rGTrf4Xu<`2+x<wjO)dS;w&cE?6`
z7obefqi{piF>=(UAvgpDkeuQiqLrMR8#y<I<i{Cuv!!xx?d41o=FXvVXIgUa%;$~}
z=FOsWry24d%IDo3%3a^feT2w+0?T`f%3Ev6yN$@-w9S8w&Ie)j`9}VMeE!WC2pVcD
z<_c+cg%B59;&O$2LtXm3ap@cS5;3HJi=zPIS3vOj(s$beV#b0m=mH#~Lg?_N@2CRW
zM+HAxAT;|0l(B`Zeh|{ng>(yrxC%ws!-b4Q1p@npFohzag+h_6LNTHuK7nFUyJDtF
zfkMTFLMDZR@>N`TER_Tds;&TqE0jP&O7JG|5DQT4%v4jxQu75te^bE_Q>e{nKdWI@
zhtJ~Ga*{y>oVjwP=Cx57>i8O1M8UQAPOdC=3w{?KLESzx`XZrMj~M+Q(M9jm^`udi
z$WeCoLqjX5!Yf$fv!G7H3h9qna~SEfh#>bV1!VSEQ~fAIUb5yX&|lgYEM0*9wJr2B
zFZ@wU2D>+)QT^pmjRy`@AW+o;VpZ*E1MO&FSOrQ|pixC=MS~owp=A7<PxYrpRTUto
ze=1dZxb=VYsZvl#feg#UqztU8K!O_J7Xj?4RFpEns%mQ$$jqRmsj1=X6%LH4si{ct
z`GHIo2vouHFW5iY-WvE?V?Et`40YpeEi(1=^nl|O;6rpZVri&l9PC0}oxD6;{l&!%
zO^iGh<-CoJeLY-#flu{%U6iL=C>g1^qN2QvtPF_8sLX;KRGGDPu!Uuyr>AFmX=8SF
z*5JT!Q*%>hMp<1=yFS9Pt@V0wQL(D3JrNPHt!;>hd-#RG7#)pBVIgf{K`R>@pipvf
zb@Byz)v(}1eXSU8k1$|QWoJ_ZURmH-H8fPSGWW;4gQzKn2Ke~uz!S7o<1|&nHC2OR
zLqjCQ9LC!dI60M!^n!t8RY~3th*kBq0zr!JLCa_=8EYt+bYFsI1Tlh02=bt>v*KJc
z2Z)3qih{5V;^EKl&j0`Gf62c9h^yBi42bTUe~mJv>hDQiD5PX&kzYal=|u`_94`ZL
z71WaX454xesGX$7OGFhsm6%n(A2wC4^OIr{;fv4XXj%}1&E<K&-L}u4H#?#o>{AE4
zySZ?*OR3GZGMsJ?c0NgVdJeou>s%-{{*s8~Fl~YfvPc{fHp8D@Bt~@}KX*?Q0Vk63
z_qLFp+#b5#E1O!7TRewtR91BVev2OV;62VoLdn)&_o7i7q_XBe`tN)dM{oXY3;i%9
z)O;~bU1<y`CX>&WCp5CUq=`Pg3I6IDos)3$?EN1Ulh2b%h$gkWV=8OX?<l?RJ?8mx
za{iNI0&2<nd;jNZ$!_5x3IF9j)%MQBuYGER_6IV*mmsdTz65Qd{g=h2f9_L>$dMCe
zj_#)TWv=f~6ZEv8ErcbI*1DTVZCWsijWtc=gB!4>;87L2%LvE9-`Ibh1MWncs}p|g
zyOCvx((Kj5(pB!&^NF^-u1?hOZ$(j=j{9EDcRtw9s4&*wZ*K5rIB2+1*4CEROl7~{
z)~$+xwYK-HJ>Kfb8w2}P{GG+tt`U6ZnrrpM0UZ}RcjFFwzw&++>RXw89oTcv+QGT0
z$~@rhplpx?Lr-g%(7VVj>~>nh7fk_{!v}*;SZ=<X6?)pgy%_L5@MC5C`?2O%x8L7t
zogg_HM-v$yO%yZc9!;hTEFDcny5+QuL2aIv-7=+e>p@bFL&u5n(nuv|m~r;sCQ~IG
zY2pg&cK0&#&MmD$Bpw9z-I07vTE+tZcqj#p+!Kzljvkkox`(*iJ-dRhBf-Ne9l`PG
z0W0pr$A|jQCNzlXBc2TqSbK<^ntBJmja-*bQ#noMe{L(g?$bPa3QrN|nR&`Hns|yA
z_5u@h{W)U=Wh7A=^`_j`)IGP?thOs#;M>&4fxj~{gC)QwhgzB3<?_wPe^qmpN1c!|
z!S&0&T3Xi)oeMF_61Re`ZCcL7XFxR=9uEqo9y)}&O}-z;Y^IEAA9Y#Li-pvDI}vMf
z{q_MGS%`!Cz~+7GhZBEz0UPlZtVE;L7p5wo)}OS0KQk1-nqAwmxSLGhZCrlu^PW(8
zI)kn2Jyl#5S9WVp^*WdDMLX#v-L4m36&pl{@r+~9@e&BHT>bRzbr-&(DJ%do_2qP3
z?Zd)!JiR3$`O#}ETys;sGl4}$ID<xQ%O$+~_0{xYAsUgi*U~lB*$AA+r(ViXWPW<0
zPJ&U?)w+vCndlE4C-5KF;%nlF)J<dSv4;1;%$MD)Nm=Ro5DG+4xaFrEclulBiV|JR
zIj$XbjO!V*l3kP$4wlcTLKx=c@;mdRrtO*iN_D5-n%O1dK4rg3i?~H58J$k!P_v3g
zjBNK5O2+f>81OCV*&i0T^?NRhx9S)<7v&~=e7Pbopx-32n%B5w$7>PWZPgp*`l@$a
z$ZJ;5Zn@WUV1!pxy+X+0px1r)o7arHz>*uWzx$Z*?j)+!FyqRq)j}ZOM2f(j)WY6M
z!kc`uM5l)EVCu3t(pPerSBs&+?U#2u%4F}yUW@FtaDJE2d~-*@Br>wNK%B{0g<=W=
zp%3)O5`vklo-N!BSrn*|T;*3Mnu4V6e9$I#YH?+%>@?Kxw<imN2#PIs=7M|CwYoiB
zbtaL*><{K;+ydH$2S%mt4{A{n`@ObbOe-XB*YgkT_k=t)zw)jG!gQzABvt!9nmp1*
zdtlGZqx6BX=zyhBVp~t0pj91qWP_Cxtw}(om2J?&7AIa>tEojxv|wpRnP3~_a<;W*
z-ax0RjF7{&fAh8K(yoiWZyb-?_(o5xI>NrcY2Fmv(4`#g4ki<J=X|w3!*trF5qVh2
zB=l%RaIiN?QP_K`;n5xU*1qZiD!?D-T`ZzAY*Kk!YTo`>5U6)d;zR<gc%D4Mh_((6
z8c_v@$MdY6tm%z?7b#8=a^!tGI0Og#)YyinEDCuX0;ECV<yG}ypQ<xG+EoAm<S(5E
zZz6g{W4ypVb+Tn-H<B{${%x*zz4SK=-tNa&0OP~5jqaP#_gN?H&#6FM<pyz8jb{rh
zdVUn&`a<GF<<<w$^DeUB_tD(S_1G5Y8gyeJ>5?7WM4>}dlp5lw?_ak@^U>qfs>j)?
z9q#x&Lo>v25;@fY4vbUhaIP_l%&-m*G7wi8dV8|#-q>;CD8O}8!!Ck*(eL11^z&zl
z5?-)R)dc(0sFmWrrD~DzN6OAWBx3=8{21`Zw<aVjLmhWyz7ApT1e1qlzc75IaR2k7
zxYL^}A`!bPO0V1FPWv+Hfmb*ay}~Ce{S$@r{-w@6O0$6a57bNugE%DuTNIP+WQL5(
z7saX!X+u?`E4oTNjdj(8HT+lnzjfSrNERp4L2vm$ygP2qX;7*QujB#YbnrUvflN0g
z&!HRhd{=~IRB}P*p_iKcqdU6;c8RP(el|3Zzs70|V3{6%170MY{ZH3ur&Tnin4cOX
z$=<ln`as7m{#jSG?8p`2_p!Qm>!)l|V;_Qc6F(^33HcG-^(4q8Ij5PFHs(GyU3Cg%
z<jK|xMhiSbcqsM|1m7=ZC^p8GfGy_R3%2$1*jbU2qN;B%VgKn~^xpu;|4}A;i9D}w
z`BPWCQ<MYd#%}=fpZB6)wNM>@CzBPEdk}T^D{`d~0LVv^oX(XjLOA|%FB)T8?na7(
z`j1{Dwhtbre1O`8jWzVIy-2^`i;8_+vw=Lk;g~q6HS=%0NN-3WpRYS6V$SAF{sth&
ze0R^j`2Fb8tzTZG_FLa46K;J!yNmhp6@%HO$KH}NVA#SYEPxOe0PZ-1v;_%H*NNwm
zWMHMbhomA*ra&b#`X<w&k@WM))O*RSL&-D@DLk+grt@T8bP9J%3T!@wb1#KICPmUV
zmHQlsxq(YIMPVaVY%i6354){iLaP=(a0Q>B2BO~rAy`S%Ye_TSNHbtaH<(W|woSJr
zOt+CwcW6mB-%B?k%&^@^H)F`KgJrn-W;pq#yPz@x88R-&X9UG$gwCgj$7DpHGd+hg
z;$kv`Y%_y5GD8T{dFJ#J#t9%t5WHhZZVL+6`W^}&E9(+03r9Vx6qt&9v&zsYw0zc;
zn5_K0titoG%ZTi%maG<r>>6}d6C%5DKD#X@y9=G&BcIb5lT&Y-Gc=z)jLwQ*i2+%4
zQa-oSD!ApZn?Wov$6ow>GYI^%AUFL?Qh!y@0<o+r5YGAl5iL;A0?91!&%zZAfqWJi
zW`TKDP0;{IW`TwFmw7e}sAd6y9GGW;g%+4+85xy5Tmo`(@+rt9!Kb37k*B4l2C7*b
zD|a8y0AQXaA(k*V@dk+o7;J5=?SNj^+!zVew7^0Oq_nDve%jhPrp6v1+$kz5IXgr-
zIz;$*N0}J=DXDteJ0~NPavK|)C@4sSgA<~n(jy`=E70{g*t{92=ANFuyu3@v$@!=Z
zw34hzMn-B_SaeX3w~@ZrK!0Dsr7{Kv`fOAQFwz2_EYQ(9*g5<829l8o%SyT4Xb1@O
z3rX@Ob#w9)7u5#}S|HB_I$AbXHCie`FL!rSBR7z?ObwGLDWsv4a!w8|DvF^7+IqlC
zYh<Jb@}QBvE3nXBM$&4lhXL$?rMauRYM`~{1t6mJb`RH5^NI@c<mEB$uJUkp2*7MX
zIoMSvIzo*M?5!<L;p!TF<$|s*PKR?`!Z4+|M%v^6ZV<%GG}ysr6D%k}5Chx2|0NOR
zf66EM&znI4@{J*he*ug%DCCk4OZY1R%H*<d(Nj2Q`0ig$S9$Jp9M|G#;a8aU`Tq`#
zq|7Fi+?is9YES(EjHImFli->r;D>cZ<^HaqE%xMosf&W?giNz==(rP1{8G@ywz9Ap
z1+pY#H%x6V)@c4DK)qrY)vgw=C`_4uxY}L3nPqhI)J#-q_NA@lONm*n!Jh;u$95FC
za|29(oH5UYWvSlaLYDUQ$HxL)0nf>0aH4M+kL6(4O*X|)Cx0P8-M-2`D)Id*f!)^g
zTWhL6Pgnn22vGlcy81`d`g*T6nbcILRUOaJ`m;MOnQ0G*TIQ~=%7v;!)FGZl`)~*;
zvUNAhwrt<KGGJDKtIX#{R@3E}Bt-L-=-vJ1jQGbyudk+A+fJYp$nE#)pxFyPS95h9
z*VJd}`|qb@s<!PlUM6SQtGbeL;D-~LB6!gHEzy3rsb!G(YMW;-=HQ^?jhP^<b7-*K
zuW|S^ySlUKi{N4O%}vF_p2ri!0=-Lg%^e+gbeNy?ty%{-;5D51za4DAx+!>lE89A-
zd%KLe;(AYIyQt@e|BZJyFPf3O9|>77ct0BODChl{bKX~xTafVdcfDBjPiY2mLx$BS
zotX~BE%^H(Q`0opLsAM8l%G~(iAFp<X7m{f$(ZF~_fqGuZ|LZyODs8*GzmF0n^}^!
zQJ=jn|Kg)I8{5ajK7yo|!qP@AX>Jqu5LGKPD~5fR{R9Z^(TMwE$EGLu&Dd3B9)88!
z;aao1FbX4fG&%iv*EHvf6th?P#~C`lX_06Kw*EWN2<3g#PBwuN%+}d+u@bklEw(EF
zn2F+FhLEPo1s7ry9u2Ec<=c>(;T2lcDpV9Zyc^c!DdG6CSGRurd7rqa1|PrUdRI!4
zrcUyWAYoU?#M>bccuIj9wB-1(k<5LDX6SjB(tGaQ?gyllDp(0R8PlP7jMFbvwQV$>
zt}8)$g+AWY*jBk^&2k~I2ajZUiu~p2&XhMck*8zw*zwIvI#D5qIcr*9A&ze8L?^eM
zzMn@cN(QROeMlWYt}asf@zPZ?n1e%u<0wN2T@y#lQd9Vn14^!MDxQI?Vrp{5BQ$hN
zX77K>@c@EFJ9LzOz+ARvj-pm?K;p|UZIf)lHE(AL;KNDXNihuTnseF^tVS+sESSyo
z#D05LP&^mS@S13lQBR<iG+ljnh<3AQp`%maV|vU(t~Y5C^5)7O%d0K3<vl%lyaC0u
zHl8~2lis=ez4a?c2yvCN+)FDb^;0ifwAE)N9MYv5W;a_9NI;GM%EiOLX(tXhH}@zT
zX_%61T}aU@%Doc7!^O|I7_ZV>a-hg7czb5SYO}qx>oUEt$LB7)RmswN+*cy&jf+nD
z?d4;EYy2M=3?m=)qMs=8NwzmGdFce86C=C_kOFs{&H940=Ml2(QFr`Ti7S&o?)Fp)
z7`qkrT^?2BR}9tWCm6EG+IIBm;_AkhBHXGzlOD%@$%yGB?tol{JoCvjoV(iyCkLo-
zB%CC!BbCdtcK*wzA}g^eO0vI}5Z(e2_OGvT`p8c+!>_CMxV?ZcqE@JKTOC*3{3<%4
z9u_3f>8xm8v3$^o?YdL9=4z3#W!bEv{m>*;@qVs9O$)pTW~MFqpmDIR)mVkr64UUY
zh0e3h`W20JpMPs-n2fpe_k+4gL2He|fsQ0aA^YPr3-S&tbNRe|2aJ{l&@Gunj=r(Y
zvp2hWAY&Z+UC8OPp!qFgI>TfYVF#jk^O>E}9`VRScNu$&g(QKVGHqc`p(;B*x4}NE
zFT%d%Jdf}3we~luQ2ARpG(7B$LV(lN0(YS&?3jClgDRk!7Y(X;yDitpMkzy59qPBK
zqIEzuFBeqv=q0WXi^PdW*zi2tZ)&-*ra~Fj=TP@HELv;xdoXHJXp;hL23Zxw;^Z1O
zKY6!|z8i%m7)0PcUzQuAxgnOs3ly{(Ew_F|LXkL2HCWWP>iDYSDO4S<I1)n>xN+iX
zcs$!gI4zTOyA&BxxmU@;(W-1ex)U^n-Ome#rr#+@WIw9kp>1!T5!Io{^)Revyl<;4
zJ0=kgqSjlWpuPWDqM)ApB`1CJybc?AQ8CM9Ua4VOV^vct3+7k+Q%#H3d}L*P!j+(!
zCk>*O7l>L5AZir=)e}zrt_-FTM6GuumtU}y53LT57tkUd-sf&9bC=%5@fWJ02Ir{k
zEh`zK&^l_?J>~ZboROaWS*#-agcgt0?cg8kguY)j3XfB({_!zUL*(EyP|zO7wyK(S
zy3OmuaXRn^+TB>+m;n{i;M!h$DA|s~hq&o6x_q{zyu$K#Oe(4zr|P*zZ_YdkAaOY|
zeWfaXPI3;)+x4ebshw{>8Qy#%yem88CHyXQedA$<%vsc7M{t;h?6bGzC*Iqv7r1~n
z>2;Fa*jzn?C<Ib-+Hf|OiIbs#06+UKSlHHE$mEOsBoXr|)BJ3qng92yd4CtRY+7-3
zOm3`}FMs^UsP!*gPu~v-xnPgim;V;E#-3}ge1FF=IE8ikH`mi2r>iD^Q$5j-usRZD
z<Wg;&{JU!2=z-1MxMh9_R!KQh$H(OB<0n7<P(5w_QOz?+z@Dx?pEvovnuqzkBKJdZ
zf+K$KkIf(^VZXlU%hTUBgFjB>T(G-Jl5roqB2RB({)}3`D`<a@T0b{~u#1P~el2MP
z0j7|Dd%F6^W{`5;qFovb0#Bg`Nuhv4!SyP(1QraDg58rMh)TiPPT?m^g>a<e)TZ*D
zrzjy()nZa)_EIGfX$pjC+ORYc-!$czH2sZKIfgW0bee^4Dg`ptXg<{%m2Qao8M~a$
z(_G}!%n<2P=V=bGbVpc5%zDN*T$bQH{%mMwD1K(AdnP71)BmNqpj$NM1fiZpCi_I@
zD^66zhCF)#?ZqRyoO2sTYA9t!40jrWBaoUoiGi{7oa3KYQomhLD#&>W3t1`3`kdb-
zQIrSWHy?R94+S}I;AjF@cuI0UigG@H?V%*+2eK5X^(n}Bi-`ixoq@cx2Vl&BsvQib
zEhpnHC*#4wqN*tG4TEW(-6a9=J8;G*E}<tXrY|q!ZewL3B8mWDJ3%2`S4US>1$`cF
zJy7nGk<kZrKVcC)F$qIXPIW^BVD7`k#B_OJ`jQg*l2UpAr6(n+ucxC2AbOd>OfUg$
z0RfZKJ0u=1?))%>t+lz5oUfR$yquJ>tgMNmtgnKcCoi9_i-W6`DZ<gt&C0?|R?>r=
z74GF?a>0R3K~5vsj){*?DKXr9W8>jKfB)FnXlqLg1%+r=S66_SL!c)@PRiTO$<5Z<
zA;`-@UfS1CjbBv}ZeeE5%4NpNVJIuBFDR@pC9WwZ{u8<<uVAOBU??Ldqorl9scvL$
zW-Be}Eg+y`Y-A%UWM!Zm16Nb$;WGyjlao`|&c>XJTg}Vev#CIki%VTu-cM4(X|P(j
zvs{UrTj6Gdo0O!2grsFqNcz&<r-yG3bY<|{+d6A&Ys<^g0f85Whldjrv(L`X0IDx5
zl(wO<)60s-&)4_S0Id+rsxFJOJj;@WMHHdwE+lCAX^8}#p}X8cz{tR*q~PW4=>za~
z53dUkH<?Y<Q^?EsFwm<QBI4Ou`5W@2mF0CXZy`KfVm;M%igI2qPEMShV&Y=%U=``-
zYDPvOKi%mIS9WG$mIg<%lvJwVc=n<ncV`ayY&{)V&4F{y|BnW%|D2PkRp<Xj#gFRc
z?C&e7-$=O+7&TKf7?ggkq<|9_QJnFOv)1oE)U>KHrnYv$pb@O3e#=QBOtuUGZZpIb
zbjmSkNXkLxwcimYPU*T~D@e#hYA(AJqC?zmXBL;5NmY3$?m9r26mUO(r5>i6N(>eL
zX8Xc3r%KYkAMFd@Np_zt`US9yd`40((t^g`TIGdYwKclo(e%;pH-KFN-yyz~udW|A
z4=GH&paELg6BBy;W&>PMjzOcCWFgfBn9yT<>sB}_ZJsf0Mp4K0>5JP}O>V&s>EtEJ
z1l-hf$yu|7&C_{omU?s(e^vZ+C#<mumAYqAA=g<n^tgq!CN;Rs#c^pgZ;Ah0Nnz_g
zLXc~$jFU<Gx)YOMGo6^^&h=EE;p3gu*2q^rC0xzoYHXQh)Prp4v$q1LC9R$9HX&W?
zISf?%n(#dl0-IadG|dpxEY7N!2@P7Cr6T>(pB29Zdc$#gT$wcFEcE}N?yZBOeE9a!
zdwWS2q;u(prBhkDap}e-loAA_1zfse36T;3X^@tXa0w*@TtW#^!46bJP)yFP-zR_X
z^S<x-=bSlbhG7`kKUijmy{^wyGI;!iXi6({rYth<fP5w3cY&Sh*DcYLN~?qfI<{@)
z1RlO%{421)&Y2x`)O#II!w`knhn2qQxLOAm*!f$>2M0q?t-UjE5*q$Xf!&+8?G&Wc
zcE<!;z;@@9Xv=ojtjgQ%ZmOZwyPjqHfOprW+%n$vZbZC&*SDD}^}hdEalre5SM@FL
zZ*2FzeLuK!Tk6Bm-u-|N!v`-~K8*a}o6v^}!lgUVEPDYv{j}+ucqV#P9=IgR=*KlE
ziyDq{i{l6;VS?wZS?4XzlS3hs!ZzPSrUWmwhW3bE)dCCb<Q{}h$xWW=?o{+~{WKRG
zGOFmU?ltu3uKp*kuo(lfz_4550j+yW1AOn4mTi|L_o;S1Zm;h-`_u-m(8RstS|MJt
z5MMieD5)~y+wd;pV&F}g$h?rdyzkf9+%im7k8T~#<<r8#pX5Ilxfl3li;k;p`AE9z
zqk<>7MkBn>3LM;do)`Nt^1LW3=TLuXSVxTxPHwRMR#uhAxAr;+Y}bDqF~B%z*?KpK
zyxse9p7s5W^Df_OhrT>o|KQ8~xCF}dqZ5yrMRooFY9_yD?f~eZW~jM$`_IqIk=iT#
z&C3G64w{#r{QMfcr91U)`)J~??{0Adhd*{7Ko5VKhAgHq|M-%Z%>GTG()4qxc3bcm
zO3b(l`US;)8{yA}WZE=FzaqQxBqt(jry==O6u1H|=}2{=)eLojAz}y4e})G+%v|?&
zn}K~(!2@NJuJ%^q?a|lkSmucS@uL7H8NW;;c6dNV@N+Dn4D@vuu%d;m%*mwI^l5s*
zMD#rmLH2W`1h&4$TiBS7qULx6`)y-G9BwPiw}NI#mkr)(m&@okOUqlJ3LsZQATVFA
zz0K>i<rIP3P)-;R(qu|!-s7ZjZ514{Rwe>$<&)uwe8rS0(@Jj|p{ZI?BOqCRR*J<j
zqedh$(ZoEctB_YnKu=tL=Kj<eb1XSULb<6>k#&ytnpTF$5H8bdmieMi=P6ka)lB)R
zu}fv}(?j?SURTCX0>vB<esZbFshNp{xf|n(*S%;Qe=Qa^jf!3m?w_j=PdIY?pnjM~
z9urtxc>L<-xTqqHWzxW>%PaZM(0i1_6UU4T3fjA2$3r|(vRo`kn1#3=ZZuhtv{j8k
zz}P=G5=I!j^Iw*GVF<l|s=aOXsFaxD7W-nJ{jNWYvY&w&SDRs@t)_TflZlt)(#5v?
z(-PNSYx*@WC3N*P;Ganl?no?GAMb87oO^!aiu&Rw0p+Hvu9CKo#qI@lo@;JxlC&Re
zxOa`Vy~X_=uj9D?U}phq1Q_vqv)FupzSGWGHt?<2BgvJSh3jos2Ak%0%5D$tvWCR}
z^t5SWcbs<Gkxx=~^f;94yQOlcRLFFDo9FGYlu2<*3@ew{u<_bl@wM*CcU-=D<<}Pq
ziv2-JY6+C2YCC(c>z|i76D<l#QtR7Z2EnC)3y})&gU_DyJFkL#!~iB~3L0YE#*~f8
zg43^@zx5CZE#wBCX?z)2K8i<j;2*wsXCE9s3Lx32Zg1k*hX#(yMc?5jeX6<C|Mb+^
z^N(9J_h(jy_w3w42JX23c+q!m{rTDGpWh$PA`V6nsSo2nJQxcWu$6dk)}gcg;3Umk
z)e+WS97$e_$N*dIM}O`}=;QWeatIpb94Qqy-^hnGl-$addLN@n|8&Z#<hF9qM$T~g
zQ;u^blgA8sGDCQt4Gfe_8N@%xA1+@Kz7#n9BD^dA0?#Q4snVHgk&cVqy-y|2uAOn4
z-@UY?;*HJYJVRjnRJvgPguQ*>(Erru-SVyM=U?Yb?}Xpqy?lY~wB`p+|G4{~t^^jJ
z);^-)m%_GJ?NI#6KuTubKSF5%D)YL=>c(R1ykh-VdQa7}Web6ZyA5_oKfS!N<!Y5r
zO(qZhtlG=GF2#pWd&<1cUAS?dS?YRCNKU)qC$9TV#h=<4>fd_2bY8lBeDzx4wf0kr
zgDX?<pGRV4-knBiF5Y{;f8FBpyBOBN2h_^W=1~hdpF(c;7svYsy<I)S?_{mN&t2(z
zD)S-mL)oL}o_!4;hugx8vX1<yOuq@M{NQ_Z=&>MXr~gQ<Y?R{A*5~-Bn?kZ5!x)C1
zJi4KFd!X)Pj#tZ5zP|fIda|-<g+E+G54EHF4BK|Ixrd%hT^JY)t_>oO|8V*iu|H>E
z`SJ2Ot*v*Tzh1YN-Sc}MyJetyWA<UVUFZX?*HbYX%Q?4pn~btv*`H;*-#yZL?c6aZ
z>qCu>G1-Wd`NP{o8k+0jcKg?jhF=Cb*w=9Ld})LY-waE05SYLA`Nm4~hxjY3n=t;C
z(e~UO&5tn=Jfx_Ko`<5B0%P4+PKYqkKg$LvP(7U7*95H*{fd*uuQZP^jTgpS*K7Z*
zvTpx|=e>NR*7xV?mh5*oofsG=w)m(A^H=o-&M(95$1b|_0~>TV9XwQieGJSy^;}Nd
zVfyaRPt_N`yoYK#XgL1*Q1_ul_Hz99rG}BivBL8|nNMvAR}td&#`9YCyC2)Xzo32X
ziQEMz*0S$?T#337A0lQ}F6{Swxlp$o4NZ?Rb08Is#i0AKPn6@QQ!dasN<hiLg$@W?
zR022VJd>{^iJHLoDuLTq@-h|xBYse#o<K>WWPhUcYNG5xB90?TK`lwi@wbCgtpt>$
z{x=6@ls}X;#TKkE`A5X>UmTRKM(4l^6W@|l|Nhi7tEoW;slgm+p=xPij%g85X;Ho=
z=P#wjP6-{kpGM+HPgF}!c1%x=N>49I&jcNmC32~U9aykjrQqKklohKPl?Q)!P_Aa&
zO@SB&1I_(^cTjR<b*W|bIA--mW%ZYU#>uRq)vS?&toD9aG+;EC0^ugRjy!jHcrhD|
zcbo0co<`@)q-QU@%D!iuvy`5*xSD;xBnJ|l^BA3bcQt2&BlnS7?y6(%E8pDbQ@M-%
zIXlL=yJ~r_jq~0c=e;e-dlHrVeJYz90HB2IN%50#Co(dcj4mb94v^{B$Y7uk!<o;l
zp3gGvPCR#F%_Ez2AfIO~pYLlvma{<6DgS#7ZE{V%P-%hWK!NmHf$TtjgBn>*y->-i
zP$jzX=wWnb4FS+vD?I+S5YJhpt6rq<RAd-kWL#QgI#6W3R%H3L2y{^DNzjJjv(Ftx
zQgrB$7!;Cv(f#X1B4@Fuda<`t@#*Md-_m0Lf#Nf3#X(<-gE=pSau$bBE|!q;iAfjL
z5|9cBP+;>CECHHGQv#JQL3orTWR#>xl%!3UWV|lPGAYS7!6ZqPW~!GK(Ue|@F1<8R
zT0C7^_PVsRsq`{USuJN-U36LVTFI4xva9N4*QU$5zLs3uQHiAi`Z#&u9pyu7<s)Cq
zDV!B!>J`IlklQ8|Lu-&@RM<>L#mzNH<t7cNF2RE<ru`~-$rW(iWq^En{%geplgn#i
zO%<zOFOT?Leo<QaW}tF=t#W8Bea9(qXG?ZuGvreS?-!?|7k4l<&r;V^SzfbCpCGF4
zn~3*$F#S|#7YOBj#C`>#Z)spv1!t<NU93{psrFT<!q-*9%a{|182)uk9hv#FVhvwH
zwG5=1H~-2<!RjObDp<k*I1mR-`x9kUkaty(by1La0e9jQ6<npI+@+=6loY^ky2|5R
z73JOKWx$`hE6Tgc<6J;44zhN687EmeV{i>dLDr36WdyQwXGeRGQ{v>D4fHG&<=jAS
z{il51$<~@+Wo;-bPB_Ad1&O`_&ehb+^0=x7FYj?2&ZH%uFFTxH0q0Ue;#pl?i}v6<
zd=4D0GcqwNba!=)jg9T^e*%vIIB8b}ITr>7*%K!Wb&i9^O?$A)o^Zm}&%@9Ff7aT@
zkYHs(Bs$AVI$Xc34zBCS$vQYW*jrc{X&*BLiMy+tt&EJ3Jt&K+oAL{Q(LO!Awy}`l
zF>5Q=lkPs|rjGUX4Nsmt>FMcNTv*J@BZEEj%}q@|fBpzL8yb5)J~SjUF)?{~c(|mb
z)ZZ`Y;lqci>G|wzf)U}-6XO$#@~-9<7WiY1mX`Yb{5n{y>Zw!iSRu2KI(tcRc_$|;
z(9bF^Vg-kB&vhu>s%N656?L??;^kE{Gc!7M(%Hwu`M8#^v!ji-m%EXU?FlPAPZw<s
zWm|t|NnKr2C7heO@<~58Cq=oFdfHA!Nk$S9y5{EKU)b5*)j>tsgpEzf&h`W-9&>Qu
zI5`w0B%F!vF1N3_^i<e@w+gTzRZ&h2B+B3|0VLmX=d3`c9v^1&|5MWZ|HQBTKNE3O
z&3_`|)=wG|Bv^vZ{HtJjx199r2ajpbA0jU4X1d5SYGhzLwJ_DweDAk6^x=#hwka{j
zvj?N&r@PYayYySId^e_rvnO8$Mz8(VwG*&=i$;_E)&1vYzrCU9OPORL=u81!f&jgx
z`PZtfnG(eSQJRd*i=uqiRV70MJ)k%AOIwGdiFq-TRlTw3&!eVq9)Mk<@6(M_S-4Kl
z*pBX<?)x2O6g#%?GCNP6*FS1NP;X!#B;r^005J;&X;;^h!|Kk-^v}O1YtE|Gn5D^h
zpH7~(iX8?gYuc|`E$Q6JX8QVjvZjGk0LDwCdgzM6!6;)=vR$H)$UPn3trU*RQ|_re
z5nz<@KX&bmH5&YFvgSqORimt;Wg$cD&n(Y!_1XR|SpM;bzG9%MONlf8t81q&pOtp`
zl+MYZf9u*g^TZH;gvFRy48gKT)hmyB0lM9Dgt3$>B!#M%RmqIPIzl8-N#E-1Cnf+Y
z1G)aHHh_84rxq%0`nvuUGXYXx8Y=mwq%yJjbz`Hm#AriFW!W23{@Ozhsd8rg`kR*i
z<4!G21D|g^YwP<a*_vO6)ZFe=XX9>anNp#<+LfsxMdez&fxcFI@AMtPjywKu12Z=a
z!C5zhIa9~})q<AyX)U{;V9DeDU95ZOzFE~!^?J+Mq=Uu54>#ZJ)9v`ZU^HjC@rkQ7
zI0pT4FxUd29cwrK%k)fVd27V^kGBVDX5|5<cGlfV#%S~1>AKR`k6_`>{kBe-$qJ5J
z3M<(hjG5FX#mmsuZAA}$jKCgM_wmP13(+#riA8fcUi6|`SGKTF#jMBvy>nsE{rhK_
zcE?wU7Xr~MG$!~6yFlXR#QGV{t?{*f){gg#g+$_)ha4orHK>aTxSg7}+$>_!uDL^k
zKZ<zEplWalLOrmvp(z3=n&?oqCz;yPV+9pNr-SE_pYp#xk!EnuUprD7v<&$5dZ;mX
zj903@?s0fNC93tT?Ypq?@_g}Q-cDI&rc-=fqhNqhF6F~4zX*kaUtcb6Z!RDOFl+p7
znjlzWP1M`p{ND3+UdzQig}=1=Y&ZWI{juBM-*tP8)q`s&dIye9%=+jbU-&0}D&K+q
z%4LQpzrv&0Kq9V3PR?a%IBuV?Njj}Wne88iYEToPG8D?7aYv$sWR>+BT)M#W7KxT+
z3>d5uq$5qFXfSPAdZ!ntIo2d|nG;b9yE-yWK(ZmtDCY17Ax+>JIf-GJjUl3If@`6}
zFa$G($?m5JLqBGUdyHX`qsc<=cW}pS3%ENPj~;jQM7!x@nIAw$ai?Fxy?Ypsm~tfY
z_){}OW}h0-cHYDue9QxuuVNJiQ}l)9qD?t!1?6`WxYc&^bA=xXim5X}33xzlN|+J8
zdCWA1S+F>CWsT&+WE~H-^CYiHIQU`A+)Q0tvqf}Vn@pX$3W~Y9>!fW;&D<XCUhLR=
zE*Z^f?h#*5@>=1Ad_t-DDQo6Sx58csR<D`+NfwmRbiYt6Ewu==EG%afV&NQe;_!|r
ztVmSyQTw!~7WUrYGV3`pbmxF&v}b<h#~!g?J57gowZ^)yg!~Z0f1sI<Wh{z@9($!l
z*G$0fc2~2;itB%wre;{%7O`D(*QGg?nq7J7D&Ib@@yD<fa=a2`L#ffET6E#!Vq2Z8
z+lH~1X>aLbSb)l~#A0YnuU=G914B-Qxs|h7I_-X){<}KM0VKHh##qfm6=oDC1I=UC
z;-LaidqkIA8{;yB4lH=RZF-+snl(smiUL3>_j`BWwR*cypzEe9ePiJPjJ|-|!x)FQ
z=i%*VuD`u4y0Vh;gS8`Zn8SmvoIL(sxzizr+iMAGPeB4*<71=VCj=etct(K#6VEtk
zWH}bd*!RGj&iKiwpq3>kI>VG(0!|?x^d8Pc^vblzxSY*;P}mgFKJ@P0q%qw_MzTr&
z({F)i^3N+gk-ap)Z_^f7&FwY}Rq0=jD+z*;9&SsX8GN|^o>DvL^3i#AAXd3O;-$aS
z{&D)@gzyhzz2BX_-p?BOtjrPriLT@4Zsf^l!`l}Q5ho!>98V(JJ|x^^B_iY;U4F&w
z+z^!Z2({`r(e2PrIUl;k5Fj<mXYY`tXD*8=EE(O7+s@!T<Hp*~F(%XYHp^psjngM!
zLZ!Gk<J^Wc&nFHiu%4wOR@&Pmynm`)L!rQ`?wLqdCRh(`N4{DiDQ**OYd@mUP}X|N
z5WEN^e^V&g7k(lCRN~HQS(dUTtwsqj$~Y%c98&#i=X65Rz`XAb#mc$bm&XeI=Hl%O
z%VBe(_@m#<la7a#(O-L|J*hUFBfEF?DYu`=O8;VjXHUKg9%FfqYYAzh)Of4*wUtZL
za($}x6`Q$QyKZNbws_?NPniIr>KpevausVsE{j-wS~uzYb^V%HAkpJw#{JtPOkIU;
zSBZ+6MkDc`^DATmxeW%_^=njmy?V9-yTK@<Js4%o5ezIWH&{6y*&S}-7tSs5@I;qx
z^W?ktObdgL1a7E~XxDy-i=5i{CCW4eYpa2xNSo?VwK1KZhe>i9h74b(L-;Gp(rqdX
z*|blHNP3WuB_}^+Q9ZaNKOfYq;`@aCP$zoWAfE4H?vM~9qCbT22%WT-EyT)^zWn3z
z$4h;UFOQ#Oq9#?=lpGy4fN6ibY1Rg*Yj31jM8+(X%I?=3)qG>8x)9M>8O|K|QzM}}
zU3f5_44fO*#|3LF+p)mv$}ew=#0=)#p8wQRF8&TBq5DAYS9t$}2k+zAtscYf?i6TO
z5i(Z0$7tFsYZZ^<vo8FI{wDMF8DV61a_#+={FQ2<S!Gz&T|7XGai2f>3eA*GVY0vZ
zZMpoP-q4e2483=U|7+LIzX_Ik|5KFF&$RbHMj3CKe;Ne4cK-5){<l#^U-t}_1Qy4H
zI;IG*8VCdj{E0FG*eNKVS|SfR5o??%GzAq+PXrmS;8dbWe<Dr|kmN{IR0Bj009D5%
zji@BqS4j%!BrTAdgYu+WGX4ONLno>CCmBv9YO5t#q$i%Ki_xfq)c834w^2r8hbnf6
zLrF@&zY_7N)WCz(=+(6NgFi&PKlQvZR<lpkQSA>AUro<FEJ;l<w#hh1FLKN%j><@U
z6{B<uiY5RE5>WLjqXwOMSv>O!N9I-I%=*U6mh{Xf$IQy9%y!?*26WbS<E$=@thT7E
zYra`Sjah>wSvS$y!|7RrYT08Y*`p;{Grn21ud*jsvu~;8bUWr;iGpj?(V#kVkklMx
zN6yBpoXuA`57ly?fE1h~_hl6D44u2(pZn|}=Z$#Yr}W&{2f1I;^Y$9^J{#w~^UeE-
zCPSO@e)Z@6P$M5Y=7C(CCYlUaCo^*9VM@tvb!@DD2^^*QTr>&klndt_n0eJ@Ed|a)
z^%bJ}@+Tq-40iLinF`FR3nsS;=pluXqXp|-T*~Yoh4KYaQZ<E+A7MuzMMeUJiF;6%
zf8~mQt&XKZQbGI;azBudiHg|EO51_r9Z0mmES;>RJs1kC&cSKx;=#Q!Py}?avjVrz
z!EPHct0yaIYigzqj*iPn**QB}gL_)q+J+J$1QB5ads{284@OkPP*>N&-Q5Qyji3if
zTG~+O7})q?gr*Ukm>4%P)fN&m8LqRiv9@h1lsbJ9f0F0`GD)1Yy@a^c#>PfIxu_yh
zFg-0(PtVZK)(Nk7OhHi(+|V+&&;xfr!5L61f;G66bvZ*m;7ky>*S@y4Zfa@|gK@L7
zN`brVuI{$rYCE{#{^aQsaAynLYj0|5l#-C|=xD92t^M)i`||P<xa<zDxnC+S_Vzk6
zJ#{-cIKsun8f1*mpFhK3<Uj(9lX3j;;e(yM>6dvr87UnFd3|MNb8vVRBw*lVS8Ji7
zsHi=-Nh%^@$IdR_U15slm%V+>CfF5w_!<D|;(8wssLcMa^agcE0uqywQ&Q8w`lqby
zoZLKeenDZ;#o|lFf+gh@mn*MSRo7gtt*dWnY-(<4z1G&=(b?7AbG^5(zng1dXn5o%
zWpr$O;@0iSsp*+JvvXtTbgl-@FW<YrvbwhZVB_JV$D3PEo<4j2;^nK?Z{9YmY=79f
zD1Q3m{^u_TUsKox`MkWn_h@*)9G!~niH;7Y>glTSG>p&_NgY^bnt)or@y2h_(o#)7
zwvkD1noYtUNIsbAs=IRu*l?BaG@t`83dA=X(>7R6c}sk3wZQlU>f$jlN9Sy*&%|w&
zJkgj~)C6*+b|%PTEeep8>IPT0>>bmY0aIV;-#I!bsYAWwIJ3UCzZH}AwLiW|`g@QL
z?0s>c{XM+!$KCmRb_*m+?k`UL?tS^=?)*)b{x-X{(qUtk4!S!9Ab|U;N7o+oo?U?o
zqd6>pP(D0uLfB&Gc?Lc$&R*5N!lw~)?#-&Qi&*9G_vi1%hqJEm#DY_vd3Ril?#6e<
zyngqTJN|;($WO{<$m7Q!RJ9Ke&woX2k|Jn~HxmLECV3O-3+jkb42J3VlD?VvR$H^U
zH+sl+TX}7!Vte;I(uG5nJTt_Phk0g7GZuMd;h6V4vz4AGdgZ8%b$jM&m34dN;Zr|(
zk@Z6rpZTe=n5-P;o2tC74t}dHQKv$0>v!rR+PvwxGH2N9Q<s1$pq%@&9dYf9P;Jxc
zGLL%S7sW4z^2aK|>Zz$5L8m{}W6!59`dq2{@tTV+nQaCN@KV%`(=yq-l4!|>&CnY8
zwggjT&X_I)U{l+C-M~mFlMpF+WbN;x9^^lYtcsEJPp=d7^poz)otdr&IzYlCFh;Sw
zcC5MiZ9}54|J%+H^x$aMom7A6u9R6wpmh0Zk5RCf^xK)7?saJEvFyatJT%XW&16AD
zjusbsSYSHaca?IUCx~S^pnZ5rkomntBkhx0H;arr&I<he=7IyZXj|n3XkjG((L=r=
z-*5m+<UNEPGp#tQ;NV^=lEY5i9A{KMvoVVhZ>ZSq?W|*>gVTxQZ!u_;RG7mt`c<Fi
z)lN_p&YYd<!ZX`6dYn_B0l;EXbGf*&yTkZ*oU^oAq*TeHJP%D4Y0PmtOH2npvX-l@
zeo|<i`3uA8j7T4qmz0-$Ro07@@_VJ+dZ=R$Xp$`=($AeJ*cT4zD^Af-CxyTtGieP^
zyY3?R-U&Nw<b<<jDLy=SjJ3{zKfHJuOMZ2$2aA51J82w_QS4CYe_kj|HDEXLPSAK+
zjDN&CtId%Q+n(@V&}Gw5x{QC*c~P1Uu8QlN04G0T5I|jz_;cU$sxcIqTroOMk0{}e
zJCxh-BL4cyK_&$S$}cP6IiDUGAN{d+m;dl*Inj0W*AEAh{4bzqB6RjB1!@R2wNj{p
zawY&-BEbn5Eqxdb$0#kcXX23_B0?U`&)`f>+W$y|>-1xpa;XWtN?TA9v;b=xCPg63
z1LEW;z&Vde73uK+{2KLOyB%qo6CQM4FgUjOX`0~>KeOM`h;XV`h9#Vj<*M(1gtdI2
z{m_$zu115x5P4;T?Hbh)aYNty&g@AIAugl3+sZ1<IYG%sd7d`bsV`cYMhtls?lw*e
zg59z@--NK|g{O30G?G(WnFNn=UNunYGRTef&J=WNI&N)UAbdkuRHt^@!hPzH&U{xm
zS8_Au*Zy6#nhI;ce%jQ&-r5xDdrHdctEtE>>*AK$Q!*K0X0C5SFX7+RNnfBb=c74S
zeCwHrtQ%+9n1~JMq_>Ft6_cyJUDoEyv-!#nr50YYh2;+?7F1vu%aHiOis!8_)R&s(
z&vq#qK8+R227`2L3*D9CH^h#c)ZUFtY`pSo8H0!US0^wl={{Y4sKaz)K81F#97U<u
z6Y(b8R|=`Qy81#%-V~b?T2zDiDXw>Ez$$-t66__#nA)r_kh^;7gySU4<0O_K*Lv!|
z4@g+PySjAwc0<GQQ%49%F_qQKc3OtV{38pRZMSjPo0g&_Z7&PmYvOBYwm;lwu<v#*
z2i=`2pu00*O!EGH^7Ymhbtz|?tM{*0)?W*fVQ_t_Q8uustQ0Z))@QeQWp3wsd+Apx
zqMXp`sC|7$Q3#aC6yP|G>+K{*OMCMQtxYS`cNN>wpH|E&nG3y-tNbbLp)2J)O786;
zsmu8PtXaReTX((f9^DzQtV?T)_hoyBW!yqrT>5r;`_6oo37!_**vhQyzkQ1~v@qb}
zbA?EW`M4nK8Y#C*Lf;LI0Z^2xc?kNu2Os@JM~y$o|5y+y^y1iA{l%6?X&rsT$Y{A(
z8o|e3X=_J5&!OT!ozMHZ+sF6or<@j4niyf*L%FcfsL!NT0#iJ=&JY)Tm?R{<MN#V?
zyIzM&b!ypS&|AICXBnKPS8)l}UMD6d+9@d8`lPp`|JJE!`Rqx-r<^`@w^c@HbI;8d
z@qTiYcyNZ)9zXQpEN$tOf%|FLHggXTDtgK|qBFnRyf|U)VA|^QyCN58inNX3lzVYk
z!8p%`%m;mUZ$5a*lDU^+x6?pSTWC?|kJD;WoO9uirq$Rhe6V^&cU!F<dAhB?<U4wU
z8lNjsQ+@uG!Ix)ubL020-ZZ2F!!i*#-bX+>?zQFlZ%b8-*Bgy2-dLA^TW++x-s~{<
z#(wadLSp>&Rv(ME&JVub@1MWk7CHCU{rk5S3S)0an#Hy!_xIH)%ZNbH!@BL$n%~!`
zxxGCN7VrFBzOS#&_xAS9y$d@3{lO+<U;ihjw;|=<H(pux-B_7>A2Im-;ZAO3){M*t
zSMlCQ2lIU+U*<l<e|PC)JLsdJEQ6!6tK=Ef8phb?cTzQfY+>^HC&d0XywIlxQ2eHn
zeSSQ}9vPT2vIK*4T2CEKLISkncZ&yqJpaABpgj^|*cJP?-GxtCD_Z%g9|ovtmU}hh
zKVI^x{$=hoaxH+T-&k(2+;4XI`Nr`-m^<U%0$4z3g`5iM|M@QXzxI-T|M`LRyO;Fr
z7xP}lE+GA1+?{#<B}k|Js8AMd$RQ{nV^YKiG(_ri=$_5M)sAd-{C#-gQFB#N^DY$f
z&*1?sa8~#9--ZYN4}c2-O%UVa<jp}RA}DBp?nBTx_!r~_)e<EYb8r+_QPBd4lCU)S
zy?hG-KCF;AxQh$g^+5Zeq_i36Bb5K+Rs;ufm6goYm9#;u45}y~N>*02P*pbv(XF(c
z8CVesnis{z^+D(i8u&oeD<)<27kUQ877#0giif)Dab-0#5Iu`XT50QQONdy32v}Lw
zOhVdBT-xF{n3gjE{fk=1Ecr!k1;q$*3MTF+?Li#?1lgeG0Itr0sM^e28-&-QB1Rxy
z2SGUqqrt{P5LJWF95gaYiP?fUd$`^b^hCP2+Spj105uH|)XK@4g2D^vvjmlj)&emr
zD??csV*x>ZaBWxsYq+wqdi&PIuV25~iew!fjP-R-7#SKJIU)y2BC=ApnIYW8sTP4j
zp;c)@WO8AEmjQ^*!Sys5DP0ismnHBY*U~3?I2)U2208Os+vuGpI)icw;e>T%ru@dh
zk%>ACh_jFD=zsv-)XWTo%OL1aPs@;zwjHW9r==D64a)xjeGs*SZc7l>gE$@(RqSk?
zLFEM0Pn?_ypr``s9-sgsE~>Amr>CU~QVvslJ9~LqClINFN|c_S5eUjbln>&5(2@vp
zfWMR|kSBn20%QXI&Qc(408u*#)<HS}f_RWB%yuY)ij$O-9f<xxdI0KI|0{_9|MCO=
zCov?|9eH}_Ke!URM8=ND{wd1%%aynh%{)foJDypBPe^R|=d5lbJI^{E?fvFYQ3mKr
z3~&$>9s2vMF4L1KG6?X0535}h*WV;348lh!xW4w2mji#%^0i_nC|u0+f;;%X@O^nK
zlQJ60AR=h|yVucYniX!%;rP7!H@?r>AAnS!{xhuRR)|VW=n<v<8CJ_Xj!4Cny!j)B
z=s7Z0={<Qyy=rDO3?)GmR?LosdHdV|i!#33AGXVq=>ZGGK=SWi$M0Wup5D>spuyLw
zegca!<htoe3Qjv>n<VOfS7icRv~e@h;VY^jiQZ6rE13lxR<lRDH*SGqNFys3U&KAL
zR7^g{|IOine-lIg6lKug*7-9$@VwYH;=c|L{D)r0%GgZ!R%G5D*z4&2%j8w{e?O~x
zoK4&{HA2!q{z~qjS>1IehSuI@$sBve!^ZK}o;N#h&UZd)4zM3^N7JxTpgU4P%#hzL
zr{VgGX9^;*EVRWw9O2t-Di=dB0+#d|*YJ0&Tb6oFlFQ-1)AfOCeJ;G*sX9+jm!Ik}
zO-PqDeaXE1e(30ExlLa{a~65<0Lhbo6B!8Upr93%0tXPh6*%kTtt=nMoy!ym!xbJ{
zwYLYIhgfe4i9C>*V!1H+0mh#{WXmJ1I?*))3~h(rp&Q-4DxrjV_U3X;(RL9F9>qXn
z38I!J-F2@c?JfGK&-PsM!cV~ME$@imUNW*^Ah7|yInMVS#aQ+;UB$fhSA7o!xK}qb
ztWfJ(@>VKW0w~uC*9{Nk*&ak(I2=g9Uw&4qD;UQeuEJxZxOKfEfn}s{k=%eCSj@UJ
zZN#4|G#m1wA~M&SM<!YJ#!JWp^KY*kK||u3*1q@O-gZpNe&6m{2?BMYmu=tQ4_)E#
z2f@7DkDUqjvp+sgiM9XOomKtt;}g|L4s4!uIQw&d)dzGXZbW|g`DHUr?$^PyOJ{$5
zebvzZ>)UqUhhN`!Cgl!)?5&)=U?BRa{qWb1FCW1CAbk~pGNwSec1URRDk%FD1*rj!
z-DOw7#f(R3op%yBW~-2OSKAq4c9O94)o3H*vEQ@0;^x(~4pU=nH+E8R+12zu#^YS;
zJE`EB8e`<tIN!IOG(3F`<}l58LNFqO(a^kx`O?&csK&<(LUs*HgYhj%=Z~3=vo&me
zQ@3PeK4uZ=uX0Qp-&QF5nC)wRm1||{w#to<Il<Xid0rY%YOH_Ejhem6_hoAG__vRF
zB>Gw`%4ABHYnPmEUMt8xJ!Pn|n@`TJ6&5p@HhnS`R=mN$tT;Vw853$;@}pMV$YjQP
z<V|3`d7Y%g^o-#xk8{_u>!f{5?l?2HtM%4Si=Lal<Nj^;5{14Vmu52S$@QsZ%Di6T
z()8?U4IAmf*m@<m#5;b@pUPHe>s9)u=YnEBm2c8Fs7;#8hn9gI2j&eLE7S84H~!4(
zmNiS<jamOxc`(}mmSe<&v%1|GS;huRhbGiSuDvSsU$eU0uj{LEHDdpq)%8t}Z&=7(
z^j6a3Y&5z#xsVSkR!!1=8g|Ym#p{i>;&so(J^hP?sJ~}*U&j)fmMS&sgB}ey$K&4!
zI&Wk)h(aU{fCQF$(WyqMf=26PE`jFza@c=D5&%H_qq_?{xPccooRl310l@Q`jD(Gt
zh`ofcy|ko_xUhqqq^*nu_+ck0W-TpYBQ0(NLKtmTLl8uW3)_S5@Zur_oV49BRip0<
z(BCIJX$J{WYjI(Myo{}kl!Kg@rH0B$2@!iS!4qP_4&I(IAg&P+IH98GBqL=HzIzMt
zTS|-D>fychbxx@$xE!tmN;qd}32X4Ir={lc2MSrMDY;~2lm+@<I2V#GC*^Rs4F56*
z{j~^)NI9vixPYfZC;PL;`hEn<05fAh3)28;Ndiv9L|Y5=DuiiixPH3}`#KN#eit}=
z2q?%p^ROG)*#s)e+Y1ZWONbIe&L%6!I-ZZt3kyvK@s5Io6^L1mYj`M&n@fpX>1q4q
zWR;~P701Qp9IitT??Iv?vNhG5ZLI=8lZ1<N@JZJQaY=`ygd!P9hm7=#QsS1PBF6Y*
zUW#%K=cBXaq(QVrC@QQ9@FRtXr3&zwYO5LK=T+JeLY(ZwBhF<72c^WF&+|MP`-*}%
ze8^K?R-KfPbGQW@t^oYpCjP#0hI*$hjJ-(lWD!C00&=AQzrDRpsDMhCxK@<Bv{710
zv80&8Nn2ZaQFG8Gqp6^c<uMZ%wqERD+n=KkIunzdQ&L(|EiY+ZkXM!xfV~*Q_iKgq
z%{b%X8rRoF&cjE*;RZ@g$t*55BPKd6=e&-tHqp||ComvIUzezR+|BpY1!+ms#NcC$
zRs(_pMq<K_I4N6h4jmqD2cu)U;>tm$lIB-46#ZQcdMZr(iNwBQw(jn}x~t8`I<D$C
zoZ0bXpQZsvBivlKQD-iFh?5AlTcse;WwRG?vzjC0tjOjdGbzZ#!9Yw`!+Nj`tilm~
zH^oz3)%bCie`82_cTPCW$MN~7z-%k;DNBj-UaY>SVsoOE%gY+1CEe^r^%^+1k4agh
zX#|Aj{n)h&h_-qrCi)hZI+8ZEQW{|=g!SW3^LvWvCh$m~=az{)t;lzB?B&asCr>(-
zCklZ03xsw56C}yPC^BTj(wL=OdU5}uYP!ON@Knd8)%T4OhgZYhD}Qx&H7-=;hVr@1
z^fWCs5WuQwjU}jEp-0=_f)aYlXf2Np+SOFg`DV8)DlG^}R{Xh)C4-i^BM?ufeh13?
zL*VN_%vM_}$0QyKy3dxpt4N7Ly$>}1eR8x$iOr^{Z{^N2z9xZz@-Usb`oB(&#FgJ$
zuXCz}f$RUW^$G^chyGMeOP!n_8u;`Qgd~5qkTyBm0*r19|L*R(D|twBVr1y+b=Z8%
zKOo5!es1b=B?~`)?P$T_4rcGSKLgI@yP1F%U1f#RI*U!}M<|K&CS6b$+)6=&daikM
z)O*{dIr|y2AZRks|AZuhr$k4@pBf`sh+YunGha%!)}JjT`}=rs3(2q6;PlSLNBN*X
zgBd;G#8Fse`L``35Rw$H{+BJJGriN#3W9D+h?ykJ`Mtax^}-L!6LZ?+)D;qP#y&aG
zbW-eGno2Pc70&jJyMjaK&F`Ru|Lckz_vY926%lX1s_EiOjV4!_?V6i9Ot>UH8yNSt
znmfRtgj9q4y#HJ0Yi!9^&Xvk8OA&59`u31%>~~PYO?HN_GeV^5jLnr&19H#QjFAAa
z>^X%8(-Kt`eH%0VS*Fc=4naB!$#hSEZN4JDip?8zFFEHfYf`)4@S&#-*!L32s9!4j
za$daY`nU8BUYJ#(;PTRBkt6RK$*Ry}=?ioKa8PjJ#5*a%5Utm0f;BpaZdVrqV?~%a
z3WqNGpax>CW<rsJ^?hPe`sZ{tY=vPLva0r)?fKFwp1@$QtuexCiam<9T!Sq8rV#DG
zp5$+w6H0)3mJ*zxpva=4$8psAqn?+;^8P)BdAqJfK^h3a1br?~7-fiagg-iZ?@&Qi
z4_J(|64q*Zc3YQ5N=^6yqSQDA4dc}!!+4B)x^&WLywB>=VP0hE-mmpd>?{{5avx$R
zwMcI0x{(7+xJy_xbvyMQ5pMA2G78hfniSU8HAlA#c4QzY2v4%<&?j{7T)7vkb4Oc_
zS!?l*?Xk=S*jkeDnU2wz-Ob5~@Aww{p3lLnn@aIIoV9s%b2q;Rk&m*v9nJlIAZKtF
ze^+b5_*YeiQU1CS=Iiz3VEr`|@EelQrm!<+ZyF~;NL0=`K55XXD0MOWFGymkt!u1X
zMBbE6)8nUOEYNk~Y)}3TNk$8L$L4lYS@RK$X0H-?zjcWCe6OZI3>Tje<ocLyY<~1d
z!M{V2#14f1$0Sw|lCUhaX9;ZZaZIjWQYQZ!BvBBC@w|Lh#I-1Ie`)X^kR)C{QHKZt
zA&IrBlls3v5@9`4F%x|CRSBLJ?~9C8)3E|N0#}C6Oqw7hnZF%@2`RBm^fi?k@SuZp
zI!i5i)0lI>X)s5P#c32stiL95yU$qBL2%}#^*fL?$qZOx2KJeZb>wVzy;6h8oc|w4
zB1-<%Fn3}=SCZvz{r?F`{0j*0!;Zpv6|P6s(`0=vItr~QJp>`irz-$MBOYb?4@mN`
zu_Q%fuNsrn_)kdEXs9}~kQ=ji70b|MY-GAv074RRizZWtnZ@E8dv&;+CUYOtrLy(k
zkfg~na%QRW+g<~np_!0ox?IDx-)L;nY<+2Fxn5(xiICH5+hBUH*?GU&ajx0EZ{}WG
z%zg`zp~Z31^nO>_eyguVi}T9N{oWh<*Mf6eTwj{5+*sdli<)b3|1!g4zk40u{=LP&
zo`~U+wrblEo^2!4n2u_E?sO<`&=aO3&02UPV4c$5s&|}T)>d_2Rp<Am6H&kR)xYOt
zw1*yJmUBa6#PtvnciV4NMAqT6);J6C^dpuJ)(fT2ArRx+rZISY0@f3|h?|;rlv;L{
z5cYK+ZNUE`U}6oC0>`-1rFRO(=#1NFZt+ejtg4cqrz#IJPLEkX!jdJHpOjaVbp#m}
z6O8C<D`6igBb8W;y6CfhsKA<GXxVI9I-7tsHa(8T^NN=6fp`uEEe_yU6SH@N7(TY)
zC)CJ#Re}OD2Yf)uoki#gZ-xjxV@5${$I`G|tQSBEK9YzsXf+=`GJs!*B9e7jl5e5~
z<n3OzkkQ=F%MqLgI-WXY=>wx_(Df3-jU>772(zM`uIMChxTLODVdF{=k7+|w1<@0;
z$ow&8<^nUon{s#)ASvq3J~&mhlXHcJvpW<ac=H|a3eDcr_F~A+6UfR}Nt7O(b0(Pl
znR5s0dc23Af>r026ZX+eS2DHG;^iiIAc6{e{`KZ~c{jms@Y}tP-2e6F*xPk!?mwR#
z10!=A{+t{qE#8OzpC`w@p_djPVjc`;WeoRS+WUQS{QlT76KQ;%OyW_Of*hePz!)oo
zllWbYki`Bmk;<znnk`#QHxDM1-9x}4`X`7FYLnXUL&$nVV0RaP^bFHTNU`R|b0lGu
z$*?2ws3V0@1yH|zwCZ)Ce>DIFi|JFro8u9;SNy@_sN(s(D(;`Jjl@Vx)&IOXBJcnb
zP6Biv$1D$LF&c{NpnIyuAhMXxS1$~|6umbFhvL87c<}Q*Jtdj_^L(Va^yYg~-{1-i
z+<FCTs!|&?pZwlJ601bW;}Re|N1|8>2^@3A2uZ?1jt4f0_RP)i@J)B?fyZ$Wh6Byb
zNbHfsS1@3gaO~meul*bBz%~O;hZ=AsYW?oW4x=yW$-9y7fLhf~7XR_h!uHr1_A01A
zunt`t?qJ*jfD*+3Ivz^wjSq>m3t0Fey#ghf?_iVWaX<Xkhf3&TTFmCTc1`YhVj_RX
z=zD%(R1339hp8n&=n050ABZ9j0^bA}tDp!HEQ<<JBtq!Pu}A>I790f_lSpC!hKkUk
z0I2l1w3h$|2azPhkwjRODvXf;bDIQMHxn4E5IPtLJUC8;0w|IJMjUJ&6(_TUz++Ju
zLL@65CP##bQXukp7%L$bvgx*oM_W?hoD^8|ChQmq{eZ+ENQr%S$)=tipraruILuoL
zviZ`5LK3C`fI`Vg2LMS#AsL7OFCG?3K&VjAHUL5tK#CF|L<hhR0}De#`~U=T6QboC
z$#A#>J>7wpra+W}VLViTk(ew*ML6PNBosoEiqIrL9EeaQGO~yR%7}sRV4!jxFi{GE
z8xLEKj07-IM>mrc@PG^kmShC*65wh(P$44pEFNC5c^*Ll95xx!@hRyz^s`{vQ&iXq
z486HttZT2!arO(!9gGM8T4j8s|5U0=Ff=L{rG`N!1fv3}kS+?!qYB1`MdFFbSQ0ER
z7`8eIsF7f?1R9|o)JrT<jslG^0(hvXKrG$4O_W9zERG0CB%v-4;Q3gj$R=dWD3S(C
zM*`3nHX(W>ga#HBPzAfNi4xmHITGj`ad1NnniPy=rN%`ZqJXfMNk9iomIT#vjC2i#
zS`%pGs7U`!G&eEwQ8-QgCj1!+wvVT|48Y6@$a|Fhb#&^vK0upz1d-3Ey%YI73R8fk
zl_DaqQRu1(P&NYEi~#Q-!c%altHH>NJ2XQ8t!Xe+6o6Edkhui38x`$DrgOza(UTE)
z3^b<$u17`VsYpElZiWM&1FFy=QUQ;$u0lm^qV&k9+)Zd0fWqTZp(KRQ4kC<{uTF(P
zJ76a-#U-HPWC4h42O8f5jf_N;<Kefl@Qh$Yj&bC-Qw%K>xJ58}euwr2meHF6KfXyb
z5)6!(L_)FNvm^}9eXIJH7hfL|Fngp_$PT2WBlUDfaWnyHg++GapjBk}^&MnRFv<pl
z^r52lF^I4ZWDFGo!5~dKpl5M(r?GIcj-ufPn0N;|0gGnVKy?6Uduo=@T7K9hpaH;R
z@Nf|VT!f6yCotv`5M5N1{U%UOpfkkK=u#n+DS(FnktQTWq96iPC}Rg?hz5cPt~luf
zaUdbC;E;0Is}T(+`#NYX2*@O&_A?xVz0+lZ;>(bo6gAe=um(nWXX#5C=o>$bPie6_
z2H`<M?%Tm9JK*{h2AdtU85Wt3K?GL8<*6u4FiIvEnunuHpkCtMOb%NCPH#e0F=*9b
zSRDBJkHf-Dt6(}9v;c`5j)I)-K(bZAd<pQ(4ru7_Hz;HR4txor4YA0qO;i953Matj
zv8e0H@ZuZQ+&H)i4kfz-P2>PHnxZf}P_-(g6&9g}f#RJbABoU=Q(-tN&4*yRY4Q=R
zO*o;MrkGUc9Ao3^408!S@`iN8g$xb91jX*qp%)lyf}xpJ@bXRCYzj?kFftQIn@U96
zP-*dGL?;<-kD)W%K{DcyW;kdYo=&~0z9%}8RstT4L+F!HPFREj0cuZ%brT^XWEdYM
z9F7N6h=?d`S1<wYPq?Z}M*LWZm~|la$uL7A+?PVbO+=U-R>7?|q3Xf0;gir%0PaSB
z<6oZ-M`asg;W1>S6c(Y6y?V15T1=sBpuo&2uzEbY9bmu_b8ZDgGo0FLjjUa{0Hz(-
zX|uKo6y!aL?#zSU_gL6bETBMy1qH)Zb|7j#5E}rB#erY+Nd&_qh(Is_79j-~RYBFn
z!jfMC;TSm2CWMa&VIYE^QIlT~;RL7#rXZS%(g;R|?;z-jFe6N#-6kZQ0y#o}#uMOS
zWVjs>1*ZbR!EgmEi~)R%COnG_=OY3iSI#q1A!gGEUIIcVIP#kvZ5kCuDuy(XAr_mk
z;}rTE9dr?W*Hn}fBl>{NL#gwTD5x=E<OLlxJTmOf_i*V=qyzzGGufX#cwYZf)b;P-
z3{+rEEcSaA6yMQ^#~}<!&|%4&*B=0y6sT$yQUsu5+&ur$tdX7s#Wz(aN1it@>j_hZ
z1p&~tV6^Q6xCI4{!y{`quSfP>Ru_TkP-IodWO1$l3_HHv1yP9|=cXWJ>BqIs2(eSg
z6=%nFq$lJy##P3~oAk!zXJwC;2%S40%N{(Tt2NF}0eEpx)}3*=)(KhZTZ%ZCw$?3A
zt=sakkRT#mT?hS%D%ukOY;lKPXcID6H6cksc$_y1Oy%%T1JG4Kd@B$;J1JZR2;(6M
z=2P)JQ*nnsCNsAuQ+TFWa8sn%sciG<yxGb8im9U3>DcWl6c$>=Gb4zHpa?S;T7kNX
z89^eAAZeOqXQrKgx}##I$MsHc?44e7h+q}na23ruo}m`UXiTLm-kG`HN>_HuhM5H6
zz(VGSW@k5M=XvH9wdNLn%u;7(S7Ybyn$JC$oxATkw<bORXk%`<b?!WQp4tj|y)pl;
z6|(wcmWu@0k-p0neD|Q@?zf@4KVt9BSIoEKX^M!bQp)_#A(X-v&BzuFZ6Fha1%W=0
z>**~Hydl%bCtvtS18M68Sj~dWmL|{eQGv_sLO)qU?U}{qFpr~IM0i;_-W`>ZVdi_s
zC3pA`gJ)ZkPFS+GTAHe6INP~cJi3J3qPGm8y}59C65=Cq45PsSSj1s?c<<44F4I=i
z){&S_yu&;LSktPG3SGXZv*kq`#;9InK1RJ4{E?Pb=N@|WJ~8J$yTCHN{CzgaijvMU
zv&Ra1^@@o6{iRKo`(XX^HH^jZz5dbrf(fhI3Coi5?jItVlLD7Gww7QzYso*Erwy3D
zQZS{wOpDYt+K_u&MVQo|nEc_R&(AT39>aVQ!j#XkJlSMzf5^PHgLznm`Kid29rxg9
z$U4r7!G&oljX?Wi6Y~MX)E$Sh7iAq`U}<q<XSR9(v)T|EeQ;!S^+e}7y~i@5a|01w
zeLvg{Gq%IbYOx}_rP(QS^u@z<+Wbcj)vH<64`~-*yK&6*Se|VQ%mX45622}Ha?kPI
zhL6req}5~kkG}8`W)2pXxg2K2xW}liN3Qt~Y(6eu2z>O+hRHGFk@iP*Oxvd6sE6X^
zCH4gx4v!W7Vhqv}!#&UZ@3l4myvF_|5VNtV6lBb^v#WA)X@ECbP|syyRZ>$qX{3L)
zs`zPP=7Nb~h^1L<Ug|u!+{eYC#e7tOlT)38U7dwRF)L+ELe#t@cU4)DXlZgjH-)OH
z<{cH($HS#ZFiw$`wg&Td%8D);s-EhKCk6NnZ3yR&U}P0#y&^*DBF@#vh25wqc<gAK
znie<hbFwBTWH5l(NOUSljqgv69nML<lbtx7nQ+_9F2~!o+|@2WA$mCKT#JErn7Wde
ziD7tg_Oh#E`U%r8SI3k9pK1+7zhIwhCmoBEqHY`NM2DYg&q<g~jk%?%;(tDL@M7lj
zF}0wAjD--t=D<_U&NgHo9<4I+YH990P(lUI&7#8gGSVl~;zrN;w}6T^57#jzoa6cM
z7E<IupjQjQ?1D8RL0Hfnl$9?;jBs*k`FmCB9P{Vpz{j2I6BRMx;?U*eGSW~#iIcHA
ze(aQrvWtR(9l-(|rwGti_mPuxq@$M%@~X`u%@AFR><RH6PNjHFe}C_y^WjalC(@5=
z1o(SYn;A#AIAoaWL~E*?jtJ}^m`6tk4_I4VxR^^V&Y_+#3yThKcCgIxbS}M8ymh5`
zGc9h+(>?p#*&0=OpVJ-%A^um)^%Kj<k2~vj^>spGLc7uuhR>bux)9avbRsXzzw_*A
zus7{OW%0v=^W7N<Lr&H?J&m8u45GbU>(Bbto%8GRbFDAPS_$$k)z<V)iM@^GH95+x
zDI{pXkHsfM^)WHaGcqWEE&?Hbb2N=ufKLfIb-GDFMD+A6a|>+|?=cVe>?=jjPdXIE
zoueGCqS%;q!UEd4h?6(DSwS;^r@QIrSv1&oq^qm%U>mHj<2~0d)ku~(VIFYCKi=K-
zTyA#R`Iwy4U|D%Fb2DR~b0H~dsh6T6GKB=}gM*TNJ^e+coUT;Xg@tA+D>%tY>u77a
zCnXf}@z@s?RK~~Up7M;f5i=A~3X;%_Tw7av@!|!j<AdcySt&7$)<Z`Keev9&&`=9r
zw7~=J|9FjMktb6Avq0=e;}L56wCisI@t@&8>|Fp{Qute1?jP4!({OS1B<>dQ8r#MF
zw`KaSd5SE`CI8rz-x!4$U^X_mCe`+^TH(VRw;7Xw=HWjEP&Lo8G0*@i`l`69?UvZv
zs+8Z?*s&qm08zi+22dBpB=8#B<JU#8Y;m8vp?o*I?az`z@4Me=xkqlC%pV>b^V4m>
zeqUp=&I$bcHTF+!&HSHh>^NBO858h(nSQC|u2WDXO%1Q?$k~4V+QfZfmumtX$*JRB
z2TptG`mN&6%JtQ>mdA|>nS@PA7{gaqbcm1+@)15A52^$zJe0sfXSKS(MB~AckHcKg
z*E6b*ov2QRhQGiFBK(XALg;DqQ+?@HZ$X_pac{VO7H;{efhxvZ00_h^*Wx9Cou@{k
z9JbH!Ce{~EB?97Bmvh<UJTaF5$0u94Y6H~-LBLo5Q!3^(mR|w(@6;POg(_V!4N`bE
z5l%D|uEAr_!Y_1w9b2A=sdNn!)luD4qh=w8sS5@452-ae-7FLEdfEg@avhNVM$E{_
zb7DfLzJ{h4)kb?*Yhu#<xk%UeI$u$Mj^6G6uC|7m?c`szHIE_I3zfpx(hDkF>=FaJ
z5`o(=Aa5p<xdI!cvA_YF>o__ja8LF9u-Y0OAcDD8MirKVWK;PyZY`222coWJBg#L+
zsaFD_csT<st*tz8hSpX@&qjP(-UB11TxT3?t+YESe)h$w8R@?5-8;C+ZMQ0gl{25t
zgg<KiG_Un#yL*1)m-JryAY<U(g7HcF&_(mBVtQl?x}S#2whn>&_Z)q$?caBee7C<s
zOq2P%>U}Bj^O|qNwa@Ek@<eV^ZTe)sY=o@@et8)6^4b@RGuwynzC0!cSR{<SfycWe
zFa=$-gme8u<fkz?gaRkmq>%QsOL*2Wo&2INg*=i8L24b0%fKR=n7kK3t4-(lx2Tj_
z(9q@^{47Q{guaN;I(X>4rrkid@HeBrL&ir4;LMQCN1CR#r5zTNprNtO3Bm%8i2Pk9
zHK8~>HO|aU@n@8%_y=Zn2LqNL_+iDKUnU>QSq=~O^n{1?&JiD5|Jwf}5HEAT5%e4Z
zxH^P%)vKU&PlgeoKzvUE2^VwZEQ>Qb&jJd>s#BxMG!02l3yC_J0=k&L3&b4xkS<Ul
zp509JY^20c{|LnHjt%1|!<w`Uni$NXU1PQYSH5tirswjR#(x!v5%cY!KrFZ-o`&J`
zU+};7tp>ctUa!mlw`=Slfw-|x6YY%-0|nx&@s4Bf84TiMYm}j{RU<I}CJ+}TAV7iG
z<Xv)Sf%*@mXlZ!5Ma*tt75ynIr3{R<#zc|Wbf!2c5EsA`^G7;d#F+Ct?bmmU`<H8O
zhJpg|BkvFwrYmxP6Nu|x)BPn7e=4Q6vI(*6ViSZV%VcfLbdd;>iw+&@YK8Gss0vR?
zZB5>me(4Y+^mu~nYbS)cm={2WV*pARd~1}IQTLG6XV|6^5i+)kd@`5Jl8-euwueF1
zyWLo7uh3uQy!3=~A=7!UhGXtOUt=YD*-+*{hwcA+*VvVjZ~N^ehE^gfU?K$5tNeel
z_nu)*r~9|}FFm1#-XZi3p?63^3qABI1VpMLAWZ~J=u$%!6)_+xDq>Vr#6my>RMc2d
zP*JdpE%u5$H#)Ot_WAF<&-tI{Ip@_gubdgL;gaz(YpwgU*4NOXH%{i_^cYBES+%|K
z+TX8_(ONB|6g^-DL`Inl0j`21C1I|GGizGaPRvorp86sBy~UJ@5$xW~02pfN21C-B
z&4th;7(%EI0+TdwAp&z&jSF$7O9i#q)z^wu#ZPc3uzViVA&d!^U_%cC7?7YOLq?re
zh7^F%f>;eW;!7W#ekdH0B*{3Fpa?<9hDou~Z64EpKH^-gj*F_427W|ffq`+GW@2UW
zNNoxpErsobi_l=OMiUsaosAKspVhueXTY;!Wwvk`h!8s3hWY?0MJm&fW-}BxFbNHI
zne1yiOpV77$>*QN7MoO}tl3hPI*iESY}T-$C!zJRC>g!A5eAV3j3yXjS@aUxBwc_x
zP^vGRj#TgM!Wm9;QJ%x4O5OxG72L2k$0IefWS0z;!<@ye*-ZEDPVx0U6nS|z)__iy
zP~ao6-E&wFMZ!gUhS8=Z9QFqR;mh6>;i}Qs@L`h%&Kik`ZYYk3n#0*o49osxl-S4?
zLpGdYop^RBx|xBtC6Td4b7ewwNL-0`fH;{hWGo58;phy52^QAh93fD~L7Lh^r3$4?
zh{1))$dj<j&9Oo;1cr1Udx)dfM?foJkqO!?FZEK2p!I}fs3}An?UKRqNaArMv>0(7
zWvateXvCvb%wuth(=bdl1Q$HTL@CqCal7dP7Bq&yu{n}J0u3d}8Idj^ot2QEhiSKW
zNhs?$3x0!2EDd6%o0h%|ixrSiV)nzxGzK%yFiZkhKoC(OaxcLM%*eZ4aLF&OuQl)$
z_gqN?6$S#1u3+put12Rn$HMja)uJ@E@MAI;!(~)s42tE}a41(a+1XG5=|!C1gNWob
z{4vqdSKy#MB%U`jc&E@ltKQe>Q&H}v?t^a*ZBm$%QvWinzMEfu(8DsT_{-?~__sn|
zPf|_|v&QVAHSZFzw&LP-C0PpUt)lv_g4dMGn(ygcHp70_Q(IqM>UiKbPr&{dla<pO
zP1v4${>9mdfy&Vi-8VGqg4nz74KIJb(?8+h)(UHQsJ_GC^2Re^UB-nR+R!(rWQSju
z>Hj+X_tzzbD?k79yr(q-8TQ9zdRnZTz%(O2!$;)L%k-8<1Rf<Y<*AY)P1?wLqJpgW
zCaGeLe}9?&!#cPw6%OGeg%5clV8zIJIHpqo;$bAez{?u(!j$3{Zurw(_}k6+C&73Q
z9P$Xm-*r*&9|)355+hN4xhBPa=Sp73nFzkcu1Lav(ZJJ_6eftlwi9CB2_+_n@!sfM
za7iJ5prRm25j^JI`W)1Ql#k_wjnak2NJ7w@P=^VXwA4`Um@P8tZ-;tYLAMaPLKMP~
zMP)k+gx{{mlHuDBVi`J^SKZKOGw=iaX)An(b?6m3zI{UcKp6fN34d}O{w-7mzp8v{
z0M9#u-`|6Oz^XD(^&n|(LU-1P#D)nsOC1lb)Xb=ctJY#Wa|GX337OOgGixD!b<DXM
zq-q@=w!U0LgpV&kT@~)v#^0q=#Y|+7{`p7q@YQ>2Wv=>)`q$sbhMfz=vl6TC&}-{t
z9gwg(%v(XVSm7}$UN{*aI$TgNRVUc60S&8{@E681Sr8{biQRyHTQ4?TkM3j%oDcoR
z5rsIS-`S!9oe`R1aG_!6J$vw`;dogZPE0YJu|V2X_(jTYOHgZ%oRJ3Jb-gW)Nw&Z?
zIsKZg$#GsUuh~MABLwYbh(E`N%85mWi%)8MLr|-7LyHBqbxO7MU1IBWXY2F7*X&>b
z`Pm3B|24_-8~Fi-5LgIsY!9$MfcgRW4^ZOER#Va(_)kFh0OtuvA7v$~f`WsBoU^<f
zMP7FKioB$>IpBR16`TPm<Y4Uv_#glZ0k;NNA$>pz=>X~%Ot^#rGDuh3Ut669SRohE
zDjQ4sHy#}DK>$?I)TCOPMFKu3Ix-s|Fq*19))tZK1YbbM0D7pVdW$+C1i(H3XeMg;
zni+=!fJj!>8W<AbK=N~|m!{x=nsIkYbh4up_51-?WUL=(s23C;w;^ZUCSXVa-D9NZ
z=jT-jXdnxda6lEwNLvA_$WSk!VBKIKEe#MoA%Sa_X5l1<RbMV4>}^)4DtjzmgBuz6
z%gNc+6kjOYFi!Jb-MHzBy>*<ttX*RC&ho<3u@SB8)(06$y_+gF1MeLXwl*u315l&z
zkSr6!Kr^FALmgi%PJ>F$j|{Dd465J8y1Q*l7hq=`ZBjSaO{uBTnyYUF(TaitGPSk6
z9Bjh!v-Vq=#Uv*d0{933M@owJfTdQHb+@&O)Yl6IrfAK|eR_HxfDg(`KaR%}8(19_
zr)W>NY=Hl$D0op_(~22Q`FZtrmPs4p3Ep0Ap|mO+Q^%!gnU<zbM(!D7L+ZwjwSeeh
z<Q{LRZwF@8#w=-dN-1!~fSoB`ONyfEm9JKNepZrqP*%%qjf+$I>iEur4V3^#+Qj5$
zr*{J=$&DPNwQ2;!3N&hkm6aF3piGFK>Z)!4Q*t540b{u~*7ro41aNV4Cxkv+L`#Z0
z?(EuIn@<KVR59ipV1-C}G>|XU=NV;2Xp|M#fs`S6Wt)eC6R>=MLb`IqaZS=rIT<n_
zdNvj|0Kd9Aam%|)s(=^*tPsG907(RJApr6K!U*s|fc?=-9QW7v0*ntpejKb_0pQbC
zAPpEF;GBWqjtdS3W*ZPmz)=H?2oOoYhsOj30>=xOp#NwxB~UoE7KFG)4Z-=pB0u7i
zS@?iD7AoG+p!>*Q$d7+{QIXPL$d8_hbnwooKan4D3!J}_r8T`j7$85(HN!?WdL&=r
zDC$?s@btyFgE3wA4eGvmEl;wz$*KNs8JfJJSn96&-7*YGO8wn3G_p?qd&^K=|7^#r
zt&+b@=B1Oz-`rn5*Y|hiXWiL>j^D`7pC&Uw@7}V>^gCn!NlEr%PtcBc60V<euWsAn
zw`0Ej+n4tzANQx%I>#73Ho<GD;_{lA-!z|1srWN<Lu7?!$Wj{xLMEi-q<u?c%N5}k
z(_}n6UBzG3(Y%W!Nzph@(kwUktkOL&Jzq0vLw#6lZJD4B*}ba_sJB7uK3Yb8{>8bz
zE#fsH341l;k5*<~pe#?a#QwDT7)x1Ew>P0lp)o6AOX}Ep#a4l<y35GV-lrV}pPoP6
z!FZRW=2G%AxF@<0weMM1O@4L~Ym=p3boT)VTghGeu@~BQHyVxarS6E9+DC4U4o=zA
z<C`cQEZx1Zu%9!sBoN=*KWLtMVBm>>rtILSf0)dL>;;!`X|FI9R&D;a@Z-ft7bw^D
zPOdn5Ghu_+vBw$v4G-PxT6lRpuq?9S1g5rHe9%wxLfT-|Ua!}A?;Jn8J_WW>50+ic
zx&7u0gfZZAkuon84+c_V`6K5H8*dAXE?(s4Wg^ctISU-uyg#b=xqnlkk>;JZc{>SM
zG2FIf({~pHEXdc!^oPA^Rx+zb-gO|Oo6SO3&@^T)ArG3ClRU#LKX{5G4w$=$RF_`5
zMsqj(cq6Ffk;jxoBGX?zEcf({%hAgwvqPACY&|w`%j8V_O75pjhp^^Pce0#q$iQU2
zdV06FVQCjInHZxl;JSR;m-$L<qmHva`met{WVuIw(Q6F#?Rngm*!LAs$gjUXWmlZp
zed=RXnyS_AzbNEH>iWRXV~$VMRK9B*es${e>+j1H@~QoiLV!XJ%4hy~=c0M()Ztym
zl8f(!{QMT%nj<y>3fT*j^SStz$lodC%Hi=dhfRleym<NUv;0OE@f(0b-e+;yX-yhk
z<ibz)zbNFS1G6US{vrj-6f$|-l~Y_WNLV(RKz#!WS@mOAAj=qHl&X2Fy3+PgNDjr}
zhQBCe=Y6vW%B}6O$jpCG$Xl0e)&D?#{;yHU5$_t?CcCw)mMP?Aley~`g}n7$bI)%I
zIb;xwul%Bry;>f1w-Un{tEm)5`G-tZ0cyP3vug-RA&oS+E=g1mVnk}i!;qUGN*)Rw
z4`;w`N>Y*1kPovzg)lq%*l#iusfE{&5%AwlVI?0aDGekzNyI0Ay0*KN>!B)?k5xv)
zmz<eUCBYY;=(jIj3o4~+q)@4H2L6<i8}A#m)=}*?zPnUxPbop^LiZt>ya~2h7ok&$
zOtXQ^u-%vm1BOR38cL=RHcHA)Ak(nWaTpy9KN0y;#B|cAEw&9Q_e8|$H}aEKI!$h_
z0?1Erj4qxURDIl|-FIxC$fguZ&$k=R?F2l|21e$7!}rO#>|Ze}ps8m=YBW$+)eFQb
zRJlo=iz?lV#<{B8xh;M&<=jT7GBrZ<0a`&8Erqa=_pj$l>6;_>OOjvEcfrG}sX2#J
zaqt8yePztKvLji~<&xaJZeQE_slUhPKuYMv+cyV49p%&>Se@u~=l0U=Psau>9Z1W)
zc<0`?Psh2!ed!fmcOS@q9+>dy%iMhN?h`PG%B$_m+T%655b=3%`chxc@r$#s^FN=Q
z6F!(X?sf0o*3YM&`5er@b@AS(!Oy2RB#TjKI<uA18b16>Z^#S$72gC#hg6>@lA+%F
z4@3I7SYJ+Y?AdAYN$y%)XYr?Q1=8X|cEd~T1&r+B`JSvc)u>nFDwhNrMfpdOvZ^B_
zM<IrYnWY9bDWgVP4N*R@mXLSaK;@1JD@oD?BXmLqN;5btc4>e>B21ifWOs=7OsnY(
z$h!HmOp2!oD_7GDC|Rqi1mk$AE}{YC68o6>MGCS&Z(0c>IYAnoOKK{2N@tLbEv!)z
z!G15;YBj+dA=q)X29#CL+wraUwh;0O6gnY5z%426GS1^L=>eT(zBUdoEtcx}<E6W?
zx(g5f_I{I$A>OA3#-VmlHPLX?puCGogw}r2O?wt;0Cr9^Hp4Xv#xP6@A#9hee20Dh
zyaa1|zM8|7N?*gWwW{kKZ5xh&@r#{}H7+%-AExv#vQ%mE=Ux@OBNLRa6#ozsjB}&D
zjrV6s{)iB3F*rxsr;1mTFFlBe{p51byP-E}Jt1l?r#ePhOjWyEZZop}BJu&jmIs3b
z*UpHk)v=CUfblk>p$l2BQi`Xs4?Wl)$nD4R1={iQ0pmWy90%Om9TS90A|C5BvxJ)}
zj&C?>?nlLCDod<aEHfafRPz?4KY$m#68zZZC~38b_sMfc@|EAN8=HMBc3C9&9khiG
z8-3irZpA|6{rp?!9CM1NcZ0DftUWs56YAuOFnv*vyHlpQ+ixry<R(Vn%Q*7c6=kP$
zDx~q|C)2#P4~2FWiCzz$C$yaJHMHN+B5)xz<O}nQqD51T=i_t!yCy?7$qRn{PHFww
z%-!$$K_uDU8SmS;@>$jU<MRu5)@wf)XDh4y^8*qB;QW=pw7st%2{Zt~l06Xlp!G*`
za`*EiQ9WG!XiiiQCz3OTN_F+|b@cM4I8sP}m3CbInIS-SdV7Pvbpl=h$aP=`fES>8
zI{NvNcU5bHQ4N1zD_{`%x9In8F<cqr+TUg{u+8wuR*R!;2EZu*o8al`3haQ3lMAp0
zzfFOjRscZhfiGBg2Rh5{0Mr72?3b6bTbEI8Y7`D08%zvCWo4{^-B40=)YI_?F2Kez
zMnb|&S%qY075lqD0DyYX6#z~_Tis7l&RJ8{7Z?QK8tiN$f%5nB+Mq`81<D`z0$>V2
zdjLTFze@l{dO+|8g$HK=Q?PU$L3IVk>f(S<H`enrHwguTe`y9*wqfk^C8Q@c8FUv4
zvrf^&Ti2u(ZK<CD1_8Wq0E6)3D)1~cE&Z@>JVbNNbzlv4v^?-~&rV4!3JwHsS67@J
zljLQ|z|@c(<G)>j0jE$_cuGYn1lR;%0e(9LU=!A-9|sCwUClknKW*tI^n6%&&C0#t
zQN)b|o|h_sO)%D^0;gc0?+$E5RS6f^1fceTaR43xm<7-a_4iA4w2O9gNzl~<M;HQu
zLD16*5)m-~?!cTF4{8m-FW6cn1=2DZc>^1Z>VI1U6-BDDyj!T2GcX8#?&ZKBP#mLG
z6up2Q05$=50aM)o8xt#F2hbQb;0S;n0A7F|<jcRPlCp9u@B+(?gjq%44uBm1Mqo`+
z7cdt<{CiPX`FSS;_5Kg>50t;1nfu?xzoU&Gko}=<`oIEc8Abrj4=e!C|G$;LiAk`D
zrq^%557a);>VWqLQXj~BP#^#bA5i~5#se1s6uuud?jIr_6b^vS2O=N1gWvKVXnWue
z{-d^+#eMr%bBoIpBEL^@|9U`b{O~tz|IEYd*D3B_IKR}p8qcGD&Mh8YKE-{u<F1zU
z!=A&x=N5lA47dMnL1gVsyiD1b)8T2$bBq6KL1ejM_{W0C?IU}y{k0(S_XniEYkMkj
ztVw^ZV*E1B|GvYrPJQs>i`6ga_b)rF+y8p*?ER(aRW#uV7wb#af8qRoLuVGh*KU-&
zv6i*ORe`=~vlvVBiOV=YXc!7D&n@DY8-{8P<F|4p6DF=I$^Y}*;;l80c)~hrZfs}c
zVyTtY=2})OYX@g1n(JcUCN<Psqmy^CT>8-Q4M|Fy9yPY;o`2Nz+6MQy+1$h9aSK0u
zOG|Ua*pwzY##c_O_4Og@lP$}454M7aVS=Z7-PhfrnU?|1UpTetX<Yv6=h_{GKS9H=
zR61q3VQ70tttw6?DWL$uC+`F}|Fxa12>|Cm(vry|w3lzaA!FMBc0+t4%&x2KQM*0n
zl3lzs$TG<5^cOQeAbviD+P^zKrSI~5LsKued_mWBU%5-K|0P^mH4}X|{K6rmf8+tz
z)27V;IoNvRmHVO5##hHB!y{Lh-jPpued6V@lUrrLX#f~psGBtc@XcxoxRR%8AY96v
z#z24jd4mLh*D~J>;dKa<VSIHK1H#zTD5ELo#iFeYeF{iO0zGQWmU`H=8>28GsBOXu
zMbo)}Xyd+%*EoWCk2QPhEjFp~%v)l(wCfavaU2hMzXnDlFc8X;g-r;E#z};sG&s!b
zW+)y6VFhn|Y)6-#hTk+TTXSqC&zA_BS$+J~r#tE6e}6!_SMd4Q1Jbg#SBdjn*7kj0
z9@JO?ZBOoiecj6sNci%oE?9)|q)q+8dZ6u%zCG*Soc8UxZgR!1hN116np2=*Sh2zv
zGz=dmZFv2sw*OnhFz2K(Xc%twFK!a!h2EbLDS{{c*)S}*U-0*a;by0zKN^NtM!gpW
z_WJH1e966WSA9{C4GDI2z~nguS=)ctF#JQ?3y&cG`whciIRF2qwpTB`r~Pjlh7W~1
zSvvDEzI9r7RmE!rd!0%;eoK>%b-d(CJXJ$Xd~clnqfm$dcd_(1-{x(q-fCZ|<`ph3
z<`!=Y<w;T64xu+C3DqmAd1{!(p+f{Jn~hH}4aQKAo12UDSbXJ{pdeNl=bc#=Xc+GC
z5OeciZWum!*!7j=vG-hj7M^O2d1s@XxlW(=Y{I%pR>w#(KD01=k7aOUMZ5Kbx_qvu
zty$NSjsN5k9j%gw+P6(<%piAF*y0|~)sI<;5F{*ONOhD8xUAlB#JHANIl{>EFB>_(
zQ)2=3PdLAAd)?vxgE;?o1!pgK)xa{&?@EOq&mTJV#{<%g8fxQki!%H~S@0pN>B>>n
zPVI)fsF)A6N(DQ06B{OMa{2IziFJe*hv#=*%Vu46`=DCmK-GcxaQ~bff+wRg756Tp
zda3fA+MNqJ<k#n~Hjdt8E3Sv>V>4;R?BVT#9)_9rnRiNw^Ho2$l#mltXR9ZJ34S^g
z>jVQrD+Va4$D=&f$pp|6wUCDq;d`74!)A;7t<=67P_>Rk@~R|16ZlaR*(w2%)hub%
zi+U4osKe2QW0whK=hMjL8(6O#ONT$Np%%etcWDD=$GW!?J<#oqRVg5!wOK=Hm%Crg
zA*&uVbT7nY#xXgnM=>*RoZrnnsOg<1JeysaAR~USO!6~V=Q6g&M!dqB^}gx}!Bb0N
z1MB{$_=#HvMCNui2VK$83vp72CZFy*BI{+%R^-fWer)=rt8|NtO^(3Y!p4O9{w*y#
ztc!fM#F{1+ZkJQbO`~?eI8VzygsW}5`M%+;0gEKM=dx47YO2r*r#cVhRm<4^NDUte
zs%Y7@T(M+-#aSiqBabd+y#3(f;v*4YS9;yW<R~Smw!tE%`%-I~;C?aj)S4R+1a`>z
zUcby2{VxZ#`&us^%r<>l{UKjxtA0*OvqQ?Rq(PH$$4%W*mr^TT>{KUPJxI{6;;AGA
zK?b6b0F(h=_e-e)nF<8zZ`lc=W*`FP<?VocRg!a+k+BB46a>`D%1*MfHek(LUd}#0
zd!M9~8Ngov2BfIyATD7Bh#zSgOTauyN?YWuJr1a&-%t^NpA58vGn4lLhzh_@3Lv<a
zqsYlR$jVv)h)Pz@8sy&K9v9HYtK)V8P$oBX7sw|SWXLY0Oh=n!Kp=qx5^zp{f(j3;
zD_cKSTRf?)=@k>!9OhfsRCOiLkD0u(V`I(`;GY0ZRb4g=U@1UBX{dP#2<ie}3V>F=
z9{B*1QdT5Y6pR3Hit3UU6;=*FD*#UIXuS`x9>85yGEaj%8PHLyqC1M#4FD|)wle_P
zle3xwP$Xl+Kp(F{_U4Cv-i7AGP!A7R0PZ;1B~v{d^>qV1+|mKU1^BA92?qcp<?Bn<
z)%Nmm%PLrR(!wkj@Ku1v0x@rW8Lxkf0f4LIW$fhTYyl4>A!QDrE1=r}M5UtY2-Ft<
zv+Bz)0bc-EBCyAytl$PnDZoepBC4kJ!s?a#lof4r*7X3`2oPhn#ph)tEm##-0EGs?
zrmWOnz(oO^2p~!U9@T(z0*Do`43S}_AdCgB0hk2~)99MAQ9w-r_W`U2kZr4zIsvo<
z$SMFi0a6M)F#!D*8{Uwbzy@R$prZi!1VANs*K`o!0#d56`WnEtK#B{XD?nmx$UI(>
zJGM(z%bk>ym9Y~5UciX}XbhMdX5Ja#bdu@a3UVaCS^-)M_>}g>S>QXss{{a{Jlt~t
z+NG-ErlH~`Cv91}@i^em02&n$&<J2SX8y^#(kto&A0RIQztyXz86UM3z+txLbO31q
zDr;?AFCfVPfCZqjviwotcQTR=0745uV}K`XtD6G!RYN7u+$_@9qo}fo3m7#(kF5yb
zWTYPe*f>CpZEKvXEIRR@m8w|^7`y9gs{1b~bn8&`h4z0M2LGdY+F8~`ZAv+{`*-ow
z4W)WCC2)1fuM1uJemLB4zEWj&@64}Z@W?|3zqT;8Z@Xdmzr1z#H>EoGM+&{&%G*t-
zS7mca6>k1zc}(03w}Q3lZ)Uj`b(;nZt;Z6P2j=%qQ`wxY6NyHt5ymT3A5OPKzv)55
zy|26}8L+f?;`GYb%qEJo=-0*dIn`%X1LSm`o*sE8e%fOD4hwt#C8_yD71!C|(YlP5
zr0)BHwg%&@5@|y$iD{8Nex4zlu)KwlGT`^Ghr!2mR;D}IBj;+Ye_b-Z9K0>?P?F>$
zG7ir0c7exfcsDv&e!a0?+&_;dx?DVswc7gOVM~-=PUNcB+5bEYe(d>^Z8mk7r|nrc
zZP@KO|45;&aPXc)AEA^UQl9d13T?UYY$wZ2?>Q)*4kmW~QmVg;r)OG{dccJ)J$87<
zzJ-0g#}*cRcAi<%d(qo}Gvx(Hq4&M$`?TUvM7Geb3op7>38fmirRKG~Jahz24(nAT
zD>U{`7Wb5Am;@=r>0ZEU^&Xp}d|VTxQhqU9O<s!*E_B_DAf4pHSCt1POs4WqeM$*>
z<MmbghOx(zqa-nA>GcL07jY}x#|=69f=ElZH#kIINRi}@${x(h7*pKVpD|uUCIp~t
ziiF<9iLjI3omcWpG`UDz+n+fJMu|w5to<}d%c#?P*UW(L0lk!^)c|$UK9JbpY4z&E
z_1`HpK%H(pjQ%Io$;yWEC+c+k)v;AlL;q5#_GvYfR~cIGeWv`UQf0XteSOp%n)dZ^
z+e3laKT~L<Z&evJj!%yMErpIr2z|Nwvaj7v<GagS7=NVDKlp>219(oOc3X<K?$cO{
zZ$g_C(q0>GeN{mD;N5@kql5AUUiWT=@tLNGnt!>4v9zc>|KHle_(ux;zp;h!KUJ!`
zagsW)hn|uo+-@RL3@O%3xq%(kchT0@RiG-u(izsubb=a!i+F8~H<#{)3&>JYUr6|A
zXbuUUgH=)2pi<d)Fyr<y1zdmuMCc@lXKqpv5Jyo7-BI5lu6(%(OA7l)dIbdGMbeAw
zA$AtZBOHlrR4!qR<Ul>55Io%Z4bEjVDnri8oLKu(xZB2AzS0gkBC>J%Y#wR`4sqSx
zg+3%8AQlRG20@8ZF3Rw5IAnxmAf+fmNaj6ZW_Xj&m^)#e^)*TsjIpr>0mTyFl$6q?
zO;3c8N}_LJ&>$Jj#D1ulIN|DJPQ)LAxcPA1acKsO@w8pL3F0PLPzZPmoJ+prjJ0gI
zZdf)NU#Ie;Jk+J!$WeS0Cc<%hfW9^nAP|pg^CT&&?!6{CAQXsNUpn!L&Jt+jmR(#o
zDRye&#%|?=y}o}GPvN9pA(v8;I1wz*lqtRF#eHGpwmqE2<>Kj!8QPwIT|E5@b@G}X
zk^jW0^!aDh$!q39#HYh;mwFSdF3w!eZ!H@5(fc1#X!@@ddW~CSirBrIQ#&6AVcjIu
zG;b-N$C)%3+Q?)oRrt2<{2^EAM2xc@fQKGG^zoHzd-bmrx^RmTNTFwP8*_^uKqTVj
z@3Ts>qrER{-?$9u#VqWz5bFEt{ddu24uwMAa2Qku6c~u|e(A2|gz$Gf2%<lb5dM~7
zAn^k^9{3mqpV}ZZ1c4#=fCC@dASVQ$-5?AEALz?LA{Fd~1%vz$h&1rY`#Ti`ANt^<
z76gMpT7WO~f8sB=j8NU)i?2j?w)fwzK63BWchT|()Yd1VzXhfM_>$l&{}qLH)|!CH
z;OmF*#>QU8##At;2IhLfxE9#k1#`V%{Q=DKZeyx}IWI8L3kHR|YK_5SFWB7zJ6&MO
z*V5VtY_fqRG?KFu*ari@R`7kYu=2LF^0l-C|H`L_rDtO50XEjmOu*eOPa^{gxF8G0
zzQ8iCy_2hzwGYYJ7L2gDyE}rF-tDED<`zDl?&e@03@r8@Xw>Jl7#wKSv$pjH)4dj!
z-o1_b2b%Q3R-380uZ5+LmU;-$)WgY+0%q30ESrV39~fb?v2p;zYhZ`%_bi*0jjuKM
z>Xts*`ZNn`9}DXMQwv`+3vV#sW?)D&G4<8e^TrA28yfpqn_8)B`I=jL`Fn$(46fUH
zfEhP1P39lqL~@{*TY1aLn`vl!y17T0nERP6kI}i>S&@_Dqs%RRyga;A)O}6Nye+J~
zRWySvt-UR+y^M%HdWKYSDQkU0A9FBqX6gx)JAgh+%)KnkeJm}#?Cikx9y=P%$%m}t
z;_M54-~FHX9r6GFH~-yt;6DmXyca~^X3*XLCFTGh;B_Xni>VuA$(rmb!*2O=*#w+`
z)k6uyRlyMYXADeC<6Y{NZP^CDPr%a8Rw<=kgF^_HK0wz!5mtaa3?vEvh(f)1lp2vd
zyxOqI=7WDkp>1po6pc>7nI{pXMrzGce+kS+{W*r14n|nD*l#QH>*V0k7q>W~2YVi(
zxeaO?$MDV9I@4eN!W`~hTdQK{bS((RK{4c1Y$JNLd{2WYbQ-gD%}Ui873PX3`<A{A
zYn)tW>CHZ+GJIQ^s;{vIJKdKr&%9r2kxJSmS{#PW+FJB$*+lCoYdkPMj65Qb{WZ2`
z`r&M#U&g$Pq||a0ii(~au2c@=GjW97JrAl3jy-!&O&rsC_>apo55Wo8XAkR1{~mMr
zeR<};F}C&#b67qB`$rV|KM2f}=eydLqfj6)lXKh)^cH$-w~`n3Ms2NH7MS}s@9P^|
zO407s&CftV$1ebZdFn6BVR_jk?OIjG;R$IE_vI6?2l_$V<JHmWF|_^>@sJmC$7lZK
z3D|8(>)zdr+;_V80u!8o{q*9^&@aqk<Sm&$jNHrM!p#T;AkuRo!30IlYD^qbAhJjz
zQg7N`G$>;65Yjx$AbkQRl#YP(+6-Ri8g<%}gpCjeW}+5L`tL<-zE{6PSbq4i|BP{G
z6ikTn{$vGOfJ$(__PwfM7%4IUeLQ2V$YbC`-w3)0toR>T`u`k-{((9C3xT<eIjk+d
zxQsdc8HN6BY)!q~<?mx_{}7n}FUQuF7Qa0GzacR1FORMLPX*@xr(<jX>zKpEh-H?3
za+gu=b4|`$Ft!$?iYi_nTQkc@wfQx+rrW{Z!uz#s;xm}k>DQ9HN`}_rb0&M8#~tJi
z3yci@uQf9`1c!>?oBl)_fxhwbCV@L`-aces@cH9Qv9s|7T1Q=dc^k^h+tJ5|?BhdG
zP;l|`aRj=@-OI+)+d)mu85|U_v-KkyMu3-2H!n*MFMBsnOFtUP!`qH%5bEk->FrIX
zdRv1d0xn*rCPse2{=ObQb~?)wXCzlo^YDNmcTXD?WpdXhBF)zoK#le`es11oeqK~(
z4^uT|&m6y|sGx9fUx)N`druD%$gmP3lECpc6C?j!HKr!Ue&8Y2&D*j(<Up`jU{*wF
z0L?>{;K~X<yEe2SFR+E;Y1rU*VRa%qCXgN%l#sLbfTo6fmH%LXkIzc4^c9{7V6Uts
zqANXeLnJLS&95xQZ-bwoD<}o#dT(KbbR~qYPVmjDh}pd+Vb|Vz6MAU0JJoi}ic2-V
z!{AjiC4M`|DHg<G_BQd&5$Ec|PK8ldklYO%J+wFYZ%YVVo4I<=rm!Of?ErdYqd75h
zg<tIY71f~u<y6;<bwL%Zn87gb$d$fpl0z~>`~nhUwzWlE*;cByIyBpbl<wuWp?bw(
zl0$NmN6|+A?v*RrI%Dp%#EjBBz>9B8Rq<$keyz2O%Iu)>1|Rmu@NKza)y(K^8?yS_
zBc=+Ynmgz>0{zPUy*E}w?rSbG1ZA~M-`c(=6FMy^Bq%q{tD?-G1KwO$gfwo<J1Qn-
z+8i{wquhFBjGMG1B{6QRx0|QBl5IxH!4<B_6T6I?Yp!jJyFglw7rkoY`uuz{L)=Z=
zDRFMTW@`f(Ru-OnS)}-w#+3mk2@%<<s)18|`sD>9@@npF!Pk$TxR{h&xglP6|H_w4
z@4obuPD2BK9W~psvK@8h=hp-lP|S$C;^vi15)X1tu{S>$+NSAguixCb(_6)+PC=a&
z-+ylWhPk2L){YZ#%I14|j_0R3?~QuZQ!R5<RxnuCH9fPgFg>QGu7~X4U0>)vATJfa
zvhYB&<BshItu$OEe0m=b8(wP4Cpp<wXKSmh9GbrOydsg1lM;uwuIx|x`X4{@WzAA<
zB*pI>um3Nh(%+sxGpcUu>V*+I?A8hVqdzBgUV^(x0<jZ@Kl+brbJ>Kc?X<!CQT1cL
zLM5YJ`}nTJqrcC-zjn)&e0A#R@|xKY<6ww<(rdz<QteM@fHuD6X4a|i>DCj3K+k`p
zVr!JR+^^@)UEkDI6R!3+P`p5Y?&`s9f_gbVCqaMCJ=R!~`3r3{JeJ-Qsk(n|qDeo-
zw;(b330O0$5b1xO)gaK9dOz)$HCQwIjW(Y8+A8^vHM6yeek#k)pI^Yh>Xo4(FmH+e
zYt5{O?r&~RJzM<i`4bGRf@^cjq0;>9$b1Fi=Pln#jn*W!6(#L?s)l;Up2ekzf;F>$
z^O?UzT**yqrb7$i0F!O>bkhZA-#cVhwjkcJAGb!vJ=ZL?pC;53<6Cv>^<xY7?q=Fk
z{i!<XW8qZC<i1S}CS%jO%AyTIu=6_@KldiOJ!!_*ps-<#9u!fhiqy49Z{b;2y{~+7
z7tvgPa%Y<*$e1eCSkHT^%LNeKwFy=G{JM((+PK4QX=`#%UC2U{PL1b6ayRGGf_~TD
z%bp88qq{F8?H|5;VPS9kpJ(59PWmo?<|ph2XW!FO$wbyEwbug=MfP4iG1wko<M8a!
z2pNSQ{hoH}gFGJ`fWNu_;Aur!+VGInhm&u(ILX!gVJi(fcUZtIiilA(|B*h5knlb@
zBK2P3?U11MsdPAgWfXB7oon!J{B4~O{{sGCJNE){T!=IBzH9Q}=*QOfb;I8l+D$Lv
zwC7C5WZp-aUwwDR>-~_Vb9)xoPJPkjs^`Ny2dAhdljcLP62-$;KK*==eJl2<UG^2x
zT)u$F>f^IH+Z{T12)nG$h*FQSpa80oR@)LZ0-;LhK0~D?M6yujI3A8gN#chgG08d5
zD6%FDBby~eZ05vVL<Sx;yF1#<H3>prkXp^@+^6-q_r5-jq}}`SOeBfNM6j%WT0N}I
zy_ffFXlXI;^^p6|JeZKAf3aX`WRcxVg3Heh?=DK*%X@jVKDyxXv4=&4Plh($8+dXP
z5d%G(zV)*JW>oWL@WtQ;kuUcLCEk!831zVd1*g8h{_<tV%Gnpax0qt1U=v~jdZ0l%
zA%^VCkjGN+rUd&5VcNPkh<2p14pY{flOs5J_pLdHdmA+`Bd0?G*S&^eSO}@`#Z?GN
z8j+>4VPaG!Mvh>At3kAARoJ#WOLx&$%BM-PcR<VOSZuYu#i-<aopP6VA=rYbVZ59*
z3EhXUR1jdpBxu7%V^|TjBoaa#&wvC7Okr;}%<KzXI)DdR+&+ZB<4G7K5r*p})UVD`
zm$hQKVdBA<LK1>tOJJJc_OBIYaizso5m+L(9-l-KXeW-NTuf`TqlO<N=_kykA$Z|k
zlCsJS)qEeZUII(Dxa^O?DbkzPQ-@(1bHy$~uoiJ@EViHI6`8|^ZDJMU6nRYHEH)%T
z(9pG-L9WPwkY}P2)NfhCgnztk;ElFJwDp%(KQKkfkw!G<IAiX8hiX&qu0-&YP6+jz
zwV0QZv?Os$<?A#khz=nw6>W|i)_xs)LxF~DFut6KrNF7vDC@zbVj^A@>}lv&vv^F@
z^dSg?eGa?paltV20iv9xBObsjHL;y<O9|=}j@k;VRqNa>ELCd#DhckuP!}S!JvVA6
zz_4G;g<1?CkJ%Fpg2>f1Gq6U(0a!JL3s<^By+u*GTD#i&0Zgp3%fQy846kueB8W&<
z^3yGI?T?kHZlho(I0)=?OP^*sLpVJaC8hJRL2tSk5d<;Cr|FnTI)vogGR0rgF%J#M
zTDJZIa&3&hoJAdkCm&_VU~?*@UPgbv;63R(hqmL8qn$~&6i9Tz@>!-}h%N)M#9|6r
z5}ajM5T_9ZTtSK~Q!t2+rS%Zt?Nh}FlKvfqX4rrNo|L(Y1L1lIM{5gT!qG1(Y<nQ&
z^(plgGMt&S(o9&+-PJhdJ@%Iq$Y>0QoDocf>tmThPZwXvJQbKh^f2o6bl|DEq<e_b
z){Xh;NJ2ONj%}F4kqgxjvWi`dlN?58_p8euB9yKZQblsD&*}7;FuWCGC8)A6BLf&Z
zQ6sxni8_pq_r7yGjgDEerU+2%<8<e`1T%>x=nr=oQn%O=a(ShiyXWG_S$Wu$;GL=;
zdF2rXBjc^s?=T<Ik@}&Td%d$40%t;8lxMnR#wy*UlsUpG*8WSXoVL->v-^%~+?Yog
zQOR1Rd}c$DxkxO_Suu`_v+AE0H=8I`=ptayH|7=Hsqp+MEE6&JK-3a%YJ@$s$wedo
zYNjk%oOTthU&9uK2uSrz?qg>!E{ye(q^mezCgwdSw(Z#msC2GIeS$gVZe1)D02Uo`
zi>K1?pM=`yYAkhjN~)%l5R^HjyY+}r9d|_iCl6`HAYh9oiqqG>N)5N8VCCpgAFiQN
zWR!51%pfUW-VVb_o)vRXM<Co*ED-WKZ`IJby)Ou!zUlIkW_;(q#W`0@4I~jw8^M~+
zmpNHKxC|C|x;Gx+`w;EVwq8H0g@p;ITx27+FUi8iiXC2RnSY;&7#P!%H7ON)87E2R
zF(#}saB40E4=9x-D(wv=Is4v17t@?Yq=`)HC?<YaB}MKh9wpZglL$?B7D?m8C`8S_
z2%R3$Q{uo(Wg|qgvTRkK@Nk~iof4)4WSCm`8tZAUn9V@`%~iybw6zYqg{CRm3wX4M
z`LI~?z)4B;j!kM@$;q76`|#t6Q!3lPUNW#oo7}5mVZ2vf#-EQAjA*!dDd&N(|IcSo
zdM8S=U|4R7TdE$y!_fu^a3yZBTqf~R*#5a`m!1+K#kb`)cna=lE)1bHhtyzn3CmO8
zNzQRs)A7S%guL#xWU&P`{E%en7se7{656!N?(DZZ`UWFn29j*OQ`BX^O^$d77ybyk
z*<E0*eu`FN%ZUB#GKU_FM<-jr9%>8f&%w>;sHCTbM+w;JT*Lr`Rb?|mxL9=>aytjB
zLO{s#3a)I12at+z1B_@QLXT9io`<Ur74#)xp_YyKaU7G64a9?eCzJvgQpe)t2zfzJ
zkqOpKlT?7$LELG@)yx$YrlW4L5H7ThHmt-VHp&c2O@Oc#t_6dek<p}*dJ@WnjS43w
z=fqPt6BtJ6D=!mK@|-L!VwnI2qT`XAC(w;nuwf$*LO|hp*0ql@Yv(X@JY1ZESW}6*
zoQ~S21yf$KSW`tsZj*)=rHeeJRf^M+^ymD$UDiN6lsg#HniFcIV%PIGbq>Jg(CgtG
z2ti!$7o1?1xgJhNoJkkD%UzEd7HHy#jEm*Bq>Em`BiA2G97Ot_e~8`4MsDVz!&%61
zHkcF>xHX6L#22J<H))n3(@3~j8u+GQ)44bbgt?w497e|`5K;96q%IA<c{dXMxh9-d
zXtE2Y%g3%~BWI7TdOT5UMufj_L(<c6l(||D2C|e?ufVTWpG*9@8D{|rOwlk?yjtd1
zeLW{zoQ_Q+B5*{QCm+jTBYo-UbUtbgAGRd~twm@omBqx+(Pnt0I=k-WQdk{x4y}T3
z^u#y0@X*b4>>Bolp93)U#}Jt&Tu;J+)vi_iCOQ$W%4ssg!xwun*^K6|6-bIrlL`yF
znU6h;FB6hOd+=EYT^YuE;V1VX?^1Dg=bN|jo57!%uA~4@Da<CKfI16iM@JvUBLq1R
z!6GA@gbQI|$9tNYJX}2;T~EMniKm97i=;tNHW9%L7qqcLxocre7#oE-a7KE(1sgM)
zhbtl?3c?YdjEy1{$OID3%m%S%2IoP?mJ*v2IGcKV+>|wmLu}(ALbYvXf+z*iKo=cl
z2MfdsJf?}9A|-yF6SU%m?b)0k&<cy0!<we2BrGvdq3N-q>3I=&%w{^;cMhJIm$Ds?
zy-Y&Eu$X!lN-w>mj)V%~p)KcxcH%Ki&IYg#ww+a{$@jkN(s2uHg)wkx5T=NQ%ph!7
z$Ah6gJ0f|QItKDGgk3j>^`T>nd9VRm#TWPFdPpdZ0se;zZKq=|LugMT<`x54%z~qB
zF=xw=w^&HQxz2SALC$%AqNDWa*jo&oD*<a2(Xp6}xJ5%`a66g2olb)&%Wo)!XD#Ae
zTXWlBObFTuL4h>5<5r|5d*}08F!I-3>gg3^d>50{oiT@6A_{myLTV{kJpxQSr6LTM
zYeh&EUVukd3GN|c;+Il(tMiacY*dbHVD015W4WlMIn+6JVD_VQ(BY2f;Vg)IQFOR7
z2ir4<^~m;IOB1X~7dgt<yHyY6gU7m%uq;AuOgGGuk8+`-4|6)=!EpxqUQI6KxvSYS
zV$V)i_mBWCQg2_Ae7o{d6as<^(>-#ILN<5}?Q|h22q}Zdjq`+fd+~1xiEl}XeRD?Y
zcyv#CO?_zvgNKr5yVdXnz&zS|o`8G0fII{%#-oBiSD-Xe$nQd?Y*aNK(aOh!%^loB
zfNe}i`tyb2!VZoj;a}xZ8|iRQ3%_s<GLeG}Vx#up5f&sAnSkm^M>~U6tnY_b;87Qr
zreT@vgB$0dR=(G_;K&t3)E+L!l*OT;;TH76s&j`EIUJ4D!|ihiTRGX(lgPCY+RqMU
z!a{wsMLN?DUEyQAE`sSeR0Qj&JOOiohtg#n*7HKC(%gmV@bx^DGaV<NeoQkm#ONea
zaNA*hh2zcpj;$a<S`ao^8xmt3QPzhXPI_mh;)v%UkI0bHlkn{Cm{tNpm4!)U<jYwe
zU(fFkV)bhZ4q~bW4)9PLWdgPMf}HPy7CDF^+Hp@7((gN(!4}%FE&s!Xlj-`1eW?e-
z($O0f)-*>TF3@qiai_G1kO$|OmrVPJE)>ZLx?9z59Vc`tUFaBHaD0g?I!Hqa4=YHJ
zT~DweJWYW1=?H5S`fTef$ARyY^yvzsDe!$%P%u#9|CHs{APJM_!}RfRI351=ButEE
zCy#gdaT2aVTZtla@j^pax?vOFxO@6xt2l5u5;7k;2(`dIR7dM`g2d8o60;62Zi8*n
zfaLJQ!dys!4>Nb+qJCiM5JsH6-{h{33hk@}-DWY><LkDxJ(6efL@q_>tV+5w)C)s?
z^e;rh^l6af57=5H%(KAlXi4wuW>{%_+tm*gqW2Iod!%_EOa!=ubOf1w4uwA}M~Ze`
z<!Sz7q~07x?mf5W155=E+pjaE!h%I%d_`Cjx=ZqbBGAyTE#MzHEeakMnDSPD4oAHl
zHoH4+x5_;$s>e)vmB!t(Hv~OyR-d+EpSFGnzsbAsAYD_Pc}5D{2S`Vh{GgV}1%fR@
z3=b0KTrB!@@pezF+Ei8c=qBzD*YkI)Zeu5pPhLDZIXTulIWc(=&p=tQQ5o8kr|(wL
zL)zwq0#r5IRUi8k9{ckOARJ8~fO|2={POdc{v!BGcZEEzDqcDI__8qL^6?)RhwfHA
z{!z)FyrOY*^7SdVlP^8)^~Ro649E_eEDML)zg*Gyc#$7<S?cuUF2(iFgszJC1n>-w
zb9;l-vM+wM4^S=4dU)#U)WVqqZ5Jpbh`bTR!cv#j2~zaNv(Td>*X?JoJHEPZyLg>s
zc*9=lhW(<gZjCRV2)P;F@bS6fIBSz&Vehhdqjcqz?<FY0$1&pcltb;5xA0V~;Z3^3
zP1o5eTJ6o412<g_Z+c(4xnl9g>cyMUg;Uu+w|tatMID%$SO;Yvn1VysOX9?cc%iF&
zgcAu~HH)a3oz~z@vt|)h4l~UwW?C*yw{D-=Tsu>5IJ4DZrhRc{yVC9IS2OH2x4Q~&
z*PWi(J9~TYtLe(^(}x`HY^t4UD7-VU{m$U&JA*#(qqWm#4DalmovAXs)Bg(m0I_Lt
zdPI0;U+wJ+N_YDmW^b&Ry;(SW^VOXi!@GxS@0KhTikUCYK5)4AXvMuJh4-Fqzh{*p
zys%xd4lnnzR{ZVky$`ht7ijmtY`_0)h1yfP<l-!TsSpqQDTb(1K%Kdd?U)njP!Bky
z4CBw?Mdk$^=g(xo#ERx6JLZpyLDEI@coA@V=0VT!yz<Za2eV>o%1Rp14`8eZv94mA
zNkt95no{%wxuPoJw-|LXoROoX#p`(oN6A-^pt{&YEfckvcMoOzqzo9EGc5c(8~>0c
z9;o~XVm}f~dknFw)nRe~LvT@+xX6ASdijCj>jzJ_ih-g#QtWX<>?4oj$Kt+EuA2y}
z#3Ibpo{FZanUG}Gjy>LzA(n0=zS8%JGU;jMQpYoP#*?ah&r&jAvh*j7j?bH;pSKo0
zmk~iGyoNQ@J#XrJ-l4p(qYl&UyU<m%(9^N7@61B)y#+Dl=Q7X&>Gc6W{}<X~FZx90
zw|Bfab??QQ*9#>4%aNZiMx$Sj6}@Z`d2#s6Bc}k=(KJjB{e?&;R)YDW^EC{{eJ)c6
zlck|x+*j>=uMXC|l4ZP_IrCzo<Ml$?laVtoU;KQ{SAMg(@1=pV#^p4O23uqS|H^L|
zZ$K2f&3z~q`>Nw7T$vBI=e&^RB4Au}9$V8G|JInlU{B`<^Wn3;h+xL+clX{ZFTEwG
zygTFj#?n{Pr${A-E%Ka$PUQ<<>%&(ugl;U6ULoGRZYtvMCW>%4BG>8s`_ZTZF5>Z=
z;OaTS-RU1r@t!M_5R*h<Q7+~o7jXtJvU~3RLfU(^9UmixK1RKn*LX8exc8FJeP`e&
z^5YDCYdUs<z{ivMt@mDCB#O*)1??HHFiyfVc##>RXcJ!KB3|S%10z}oGp21f=ZVZf
zf>Uy$=JeMqmcFo5zBb-ph`I98i6W{$gob$U67R21Nf#_g7u-M)ON)7q@sn<X1dE-%
z1oIz3bAnZP(Q`DR-E&`L*n$^1A{S{NONZVzEq&*z{1{nUP^|k{^HW`$_$hwvr`URY
zB}uTKEo>0*zT?b?hy2g0S^SxzFSAP=p;_+dqJy7{MPGP}LKoBF!CdqV?PHzOkJn2-
z`NnTrc04A>VeYZM8r^>*_!cr}2*r~ZAu-Y%sTk#OiZ1<{d@|G6Ug!g#t*}idI4P=t
zjCXF4fwZp94GThM@}hzrE?WW~d$t;`I8!PY_{4jw#hQDgTi$DxLo$qRBtGaFt;@Am
z*>!8s^MKtx+a1f~gBOB2gMFtv-7jz3E}`8X%~}XdXrU_a<I`7)$F)?*+Mf#6$5ZX0
z)$nIq(d;VUGlh#kQHo)F`iRB)Dp!x-w{c^&N>1fMQz@Z#QK#LEs;sr@Az5O&<N3hH
ziLMvhY#t4d%ZOerTQO9w6!~ds^=<hLKfP<hKd0S0UFiNw{zoqD6460$wZr>!f*m`;
zZ<Q;r_?ETMFZ$5YChB|6>)F$OhDP6CaUV`y+Tp$<y71W@($G+aO3axwjw|Z&_>P#R
zqMwV4OBf>Q%Yp=lgb;Nhl2J1895P&?lt{s8cXKF$q6Msxjpeub6j3LniHn%~B>wOz
zHy0CEsnGaCt~)&oQWRwpyAQc3tPR4Cp|8kQxhrl&no?EOZ)8x_>s?GeG`HzxdT8$`
zHN7Cc&ASS%dvMg$%kbmQOfTahq}k;CLCGWDW>;LybWN|vAMvp|67}B4=4rRYg!PM2
zGd~CCQ`dC^KOxO&<i{_r>*z0GT+RJmEA+Gc-BrrW54)-F>JRYRyw!XtHUCt9px?$x
za~(M+&7(IQoGmPZgP*!&2ZzQO9tjRh-1X5jJoTK#E%miiM?+&$AAJmst#IJCaw=Ud
zXH-iHJvF*~U#11F+M^^rmECjBG7_;x>Z<#ip<T_9>EoK4Plkvp?Q54+dcldxE!%!0
z{M@6$<Ix+;PFlqjK9tCf*|>C0hR(zk^~My7_T8eF$|#4%_V_lGSkYv6hxu0Q7}<5a
zM*j)u>}<c?rjxbz@U?0qTQ{4K#k=@@N|SD4YOA&k{TR@7%HPjy*pgcwIK;~K>h5V+
zul3D2qG#Why+GSk$xRd)*`{bLHFdl(-Fq-vI`zQOUHPd8F%FMX4~=V`Tz%w<+jl48
zwS<#vj^8i0OFQv&_sO)AZ^rE2gr{CTxprs?ZJ$1j0kQ4bi;7Ru&+Y6^$QW0tu+KcN
zz2{WsMdNY%b(ij(S-I|t6J{FAbJsqdb=}Y1A$uw`@pSgBm<orSnZ!M(bMCB_k(9fe
z`}FkZH&uLxy!i_4GkHJxCXQcsvO>?Sf4ZZ>G5`6VJ!kS?92|Gt@ap)}GaKFvVVnxy
zj%yDUyuae^RQT~$;!xq|`xQ<_U!U%|pZ?^<xYNeP&rgSz#$JDpfl$^YxHOM}aiPPd
z21sa29#gcGj?}a!3xx2BWk%^}ivjYINDi+=1sRKVwWf%-@=CQ`Vg-T+DALDxWyYnk
zLaVHu<!|!Jtwv)-vIm@%Kk+J@ka74jYZo=?tCj99apIfYAx&{_q)%zfYj&Gqu=iD;
zMm%2n{(GGMll`eH3?u|)&CH3dS8EboR?1HexLF>%TD!J%r|^=b`?VHEUGC^g<)?`1
zu?YlZ%3Ha;0Jg&fd5u-!60at;o{TcM)=*y>uc2w<;TdwRar0=rmc<DV-<)erJCLh%
zTx~o9TCX+laapAoe8My2*tM2}rK=29*?2|Vyw-Yrbd^!|39sl+*ESC!6NqIt-f_~`
z+s0iIOj}NPCs<zJa-}rEe3y++O32dnt+z%KERUY>Nz1vu?LIQm`kak#X6yC#r!I-M
zQzv|Lj$PmWrZmxByAmx1VqZzFHtOa2D+LSJI~MP1JH0&tjzI*n5sQhAI00U%UVkUr
z@EJuZpT{u$z{Vd<a<j1YuhwJ04R}lu7dBL%aD$aZOd<u#(@=Ow*w_^Tix>>pdh^C^
zt8>Y|*@J-{pZa$T<U#Vq^MbjoIhgulGQs~spui+W-mh%IAb)GXj(u6Xtxl%|9~}(d
z?nsh;!)Fpp=LOdNn1hASCaQlNxKUNb*!L-DzvCml=KS4KeaUNdQS3Rt{(Dn>7OP+}
z2lIoar_J}9IrIiE?wcMGhxRTNu6gMx#f6(<R|+{Mkp&A#0-*yBdmDpOJewMXbZT06
z9pR4ob4&u%fo^ppQeszKC?4sGm0HbXin-(m3se%03*eb+Q}y8Xq}cA^?Ye?4_(1#q
zkX_#ldfk=0nCI1`gfFZybVNk1c&=u}F<tBtW3x;A6e-=~AGK3g>Ca$D6y+^bFIPnp
z(V>-Ru}Q(H%AW_X#OFEde4x5T`0tO{+W`qQ@RKy|?kiEAQ$1ca2a^;LLP_@r!D!ZG
zjr`O(Dk*lCn>EaQngEynK#*q|zQtuRFt&O0T{Ie`tR?tRxo3K`Y!%tOD<c;7nSRP5
z0amlqAEoqzJ3t;=a!wCtl~dD)M{S9GsvoylLgPfAUfGD<7&}}=vP-UyYoHtbHoUd`
zQ->Sdopuv1S)xbhx(%aISwx|fZZ#=CcDdFQgH1u*WXyg(Wd6lq6GWK0+!$6S!p;!%
zX`j1r<Z+2sc}B5cHxpOD8&-bJMY{6iq*A62I@A(t!bXd6G&(}*8l%F2$i(fKgBw3f
z$Jlb_@mZB9<r_q-7N--FC5x80ffr1I*qE~f3rUEDRu9^WtKcHc!`NuYIVSGVKuOm1
zZ&2=Pxg#r+&?c0(uV^~l6Ul1?BzUq5@vIV^d(?8r+4czQK!zYM53ZlqS%tX^7p(%F
zp{2A8xJMLSs)UX*wI4=3yayLs96Kv9$}MZ_3qmGC6!Q-L8*LY7iR9t4xHf*V`w@mn
z<s3!baTsl4PY};y!_d$8?*!YT#42S+5o|Wr^S<f>QPSx0&1^>=Y$}OXs%Kt@u}p#s
zchD(Mug&3f+M_VaX}XfibMS!p9HFno3LDD&t8e#?Px?GRCpUBZe(reW?zKjq?I*a%
zU{0LWla|uHQ07y;?g#L#a|r!s9E{N;X}P>Pie5l%=7b(WIGBD`;uE{vA>LZrTl%YD
zKuW236hp9r=6o%DxWZ1d2wy-&2!>@;I1}JEwP|OS$~)2aLJ!_&FO6zv%`M?fdYGsU
zbIuwXeqXU(6fxVjkB>4U!;}VcUaWXyY7%v|=1}S})F+4DElVEF`d1>4e%kG<9@Ze>
z@{A#0!9y#5VG9>4D2nxhKRSK67<Jmt^Np21MjTEB2uwyjgjJ#)vD}1}aPvI4=)mFn
zVzeKRX--1A>Nw1+S8LBP&8JJ82MnVLr=0VOF+6jq&Ds$^<nX1GN=L}&!T%r5-Ycr9
zJ^a>Q=^+GIp*JC+cR}ez6M839=>!C%iGZjyHKB$cibyvU=^{nxDj+H#AXpI*!HONQ
z0T#~Md;iNm<vZhy?<N;qB{z)md**zfiOoq>ii2NSMi8h7SKZ5$S)+aGo!rhy6b-Vq
zXQ+y$P~*~|cF@!YgUU)jnxg!%yU~NKToM3FP{tXsx((KlZfw+-yGWi8q}43aZkd7L
zPcfmTY3in$kkNwkx@zpS9ZTWVjrXk++ei&dE)5#oR2}YWnL-)9;PXVea8Iv$NUCNC
zQk05B^E23-*98z)%@wY17%&Wkk)mS=*X3m6mvB?vR8BC3GLPV~L<n#W=;x%GFT)+k
zsY)P%lEg4+lG2MnYO~PlFZTGWV^qUoP9f-B!@FfKHO^V5U*(0J2IvXIn+X7Lx=9|V
z4i{wuqH!=d8zvnGNc3Sf;}}6X&DriZgN7PIG?TLsZ9;wRufXQeB$#+2Osh}Z*(7x)
z5f&V)m>&R>(6tc$g*0O$3~7u*{4mI9F32<&jcOKB?|r{<%UT@ivv^Br7N$uvm)5m7
zZKyO~JHGQU0SH*tSNj5!`U(qIAMCy@-Q%fHQJz+)IZ-HXb-GZecd|8eK>k#%!gWup
zcZG^2Z4*kv^pL1*KHXHMrjFCe$|d|T;u=zmnR*Uy{nlDBNl8(VnOf%pB-E-gHx%kc
z6;6&e&WE9$hE+C2Q#4jldk|KJ$r}4LZ+C0ja5&psHnq8=a=Rz>c3<)BK79MYFNJqm
zHkv>?tEHnq)#in0bJN$`L&fL-1*8*sO7dlTYszhMEdvurA1|JosGpj=G<ADyYU=*f
z^vkK4uTyuB)8nbA(B*XBRaAH>%6-^Y11G~DHT@`cdcJu2asBkdrRgVQ(~CKFHM7%8
zcwFKmBz>uVdYK;ufEmx)?BbnfUJVfsFmVBFxz#}X6C9|g<cx-pbkhm@#&JwQCmQUZ
zX^5J6w#IO3wy#}AYbn*=P;ju-zvKDXUNF;P$I_v`)S<EI4sqg6ZHU9FBTRKAqqZsa
z<C=7%dd42TS^2kjV7sU|t62mG_P_f`0Hj)@|A%TVERY>>ur@rXHrW4cc+j~ZTD`Tg
zS1_&K%GfLP;JL_<hKQhZ;XyS)eih*XHHUnwq7F444y;q(?e0QNgA5MerZA9^&4rro
z=8&cUHGk#Z+^Ffnw916ovyi4iNsgM6eipiG3iK<Nm$Qc^7fBKaAmN&_f|Cr%UQyQB
zP}di7V;??LpOtn-R>~PVvGaDzgKTb)vMnkyZm+tBj+Td?M*-BBg6dK^%o0e@CM9VH
ziJT#=_|8MPnv%PU!U5<2FZM`L>gfvRsawq@rSZqk?K}bUa?7kOf<tL_dv?1*LI+4d
zt{`tyP*CCPk!@vqqB!%ewRvKGR#n)c6G_L57{`ZCo;a6wx=@DXaU{55m$*g3k-n3$
zgFc=oKHTJs@Q}}AmgcA5@pO-cObUDV*xFepX>0f^E7|_Jhv4E?i40;V9V@NM$tcZ#
zC@*8JDDPHUTI1<b^mP((rnuUi5^isE!gznEyK{!6p}}4?->l?OeI0W-8Cps1!<ZwP
z#{2xj18X3U1LS?vQ1$Gt&?QP3A3fYsQ?l}6gmgTztE#g8fXlJC<4j9yJ$A-k19k2F
z28R!a)I|6gnD0+uBwjw?%<yv0IDDww&t4<YFYjo0duU*CT9nGE__OT1Jbr$^u)vzl
z8DxBHTgbsPXA+5h<zhQexyXk8u}A8nBiK~iaHuVopEj8o+wE@e7aCX|;92>oN2-Fg
zuvgtYIev6!1u@oac!)-yX$6D*L)_iM+{|{LjB-33X*55u?*O%+BGcL4G$p|A<l(@^
z(1Yy79xex~j3B?dQztW1lCwht8Yp_PdRl?05t3QyCB81S5<1z;$STlL#nGH%Vy*G<
zI_!M9K<cS$qxH%`e#L&yhMB3g`HAG~wZg#%SrLKlq9ShNb-1r{yTg3z>x=S34mM^d
z`gc~d&!i<=ns~RA(JoxL3{}N4yjoxM1Nkl^5spbNRJ-%E7x4~d4pz1ap7~~`o(ufg
zNC|bZJ%@SiE<oKRsHgOQ?IZEr2|?1{Pw;u2y5BTn*;PMLq~P4*J@MZ<hS$S;folBJ
zEt6%-ihp;Ixmwm6NBC`^b;bYCF|?00JG1MPWiI{a;PX9+*jI1l-1EX-O#Y)|Kvz9S
z0@JEX*Z%f-$A#b8+hcB=+db#DatnM)sfK*su9af2MZVSfJ=8q_fBauQ?>D*jFkJ$+
zuKVrZ>xx&vy&s<t5^tm?Lw%%D(Y-qof2r2GMs#rd|6W(rJZ$p!y5fJT*8bH;`pf72
zzvvkLPkp4W6IRJcjdf5AZ~n^Gu2ulewB|E!s&O5#`<mv`QU8@>NAmnSnXWLSgNkI&
zY1&X6*)CHy3-uv&W<pC%EDh9^rWg4sXR!a1YE6zgTBM)}^^tbh&~I{SnAQaGd%UAS
z>x#a}WQnRM|JP*%LlDw2=p&8M-iE|CmAvHH*Hv+XNH``Gx7>K{*z0&&4j>~HVx9PX
zs}U+Ggib~nI=z%O){;82QllihJzSf!z#&6Oy&M-xHRk0{br~IIHdlxUcaODpXz%QO
z+j417e6svI;hOjD=Bb6A7c{;_J=}|~qCLhFiSfy5Z-!Prbl0@q6X@7ewgv~}kp;#*
zK*w-04%y6xb1Kp~BYP=HV#r>_N+nDWyb~PjL!IFq?niVI!K;+<n$e*z)oY*7KO3Sy
zH_Jy1j-VS$1|xA3qnyA9{QU4JdbzMd_4+ceG<f3&?rYT5wdcyS9LvUM)W#@Cjq4MC
zxJ}pld3sg8kU5?y@21Q|46WTEV^qJ+nhO2p^OnEx^{%bXN6iuW)q)!Ymjfrqz~Nfr
z-HXa;54bL`y?xF_2s~?tRJbSgHrLgk&Lzp^n##VusGq8yE*Sd8Dmev#+970^_{6Sg
zGol8;(G^l(6jUfOHk;Lcv=5oSZ0h6u*bwQl1it1CZP$yxYm2g4VM<=zT+Yb3&f>BH
z)|et|BS!^{&=YE2Mu^9J4^~};^ZK60T@-ytj-f`5nshw+sz=$7;U6%YmQGDHo<o4Y
zH=JFMu)YK24RD{aogeRa=ch-fzu;>82%oP?pVDve-zwZKH5hxZ$k@kpuj5PP+|}7P
z%hDWME?puS%!@Kh@5PNHGR`1yf%HfIlFw`X`<6#|fDJLMfkamh+43c7eAp5$sUVCF
z%Qy-bsWB$@@d_x(&}DKsWZHl%<@vRAwlMs~C;n^IvHqwL@cQo^{^!_<q$mTGR3?He
zu0W>6G|48Ax#Qhs`b}djOD@8aUue&DmAK_>S}fvWsyu5y05IX1ca7WDm=<Gci2`#^
zZI)L-eYLSXu7ZQsUxka^O;PzgFd35p>`nD|9d3gP<F|#Av3pAyF?)VxbAH}qb*8VQ
z&~+qGhGaZ$oIuVoFf5iy*VPp}*2QACJ>YZ;?JAjtcD?n^lT0{l-l;Q=D38e6#byfn
zZkuzJx&w#>@{~5d8*w={Q{4W{)R!hAB5UIwLiE8@n1rQsWo?62uOeH=jE`FVTyDN6
zL?Fg#tn%Rc>juH|cF`@EDtX46!uw^@Q3GG9w`=4LK4wDeihDW@w|_Ys{I;TQ(vF@(
z*@YO>qpDMI{P63}O{NcCP@~LaYptY4FiKR|F4X;6Vb{ADQ(`hNlU=919nz>K>QuYt
zU~oYkYjKE{teUiJu5^LV#!J7Rhs{R6ZA$HQ!c8CB7u)zrli$kMniZ}gKyuJ>;ILK4
zdu|&0={zrTq)a+z4cU-og>RAAq%2;xrkUpjd8a`oz6Xp$q8P;y$(VHxzDmv3XWojG
z&NT@Z$9YUYFf8%1V@^!K^+JS?B^R<Q?aWY@PPSbpR;H7a7O~Q<t^Z-)qjGotGi3gZ
zO;e9MSyIyym%GoekC}X!%_^O*k-^K3yEwpr(48hS(sa7j-Z7i^kC|Ev(2*Xm1R%9s
z0{E2rLbGBf9hMrHb>xncn6njbsrtR7dK74(OiUhaxHQmsMUB#s$o?4lsBZaH%l=(L
z1e1{QA@Li{p$}|sX1-ieP;i%tjP_y`;8L$W*7%%Xdi!yhlreEEi$f6;bMLIGwg*+@
z9hpp1X?w?sdMR+k1)Ia$Zf2Q_oFkjW0CXvqKksf>2PH{#k1VjvjqUf_um=uWg!Czi
ze>$Y70;3}bQ*Y=Z)SJ-H%^7_u9NEQdWY5Hd;&%>Qv@%XMHEqjhiVFiy^pvx-7`Q(J
z4iuos=_p6MI(>wolrBS2Ukq$^;oq6efJdK^G)`kM5pqgyW@AVvRH}G9S_DmJy21dl
z*1l<r_%D$fsOO9^${7Bwu>)Sam=~KmJMo<2AgK7-?3BoyuKn)HX4Kn^r~%o%?hLFu
z0C(jxy%w-flj1U%EYc)$-+Dshg0<@Ec{;5iF`bG2WZ*CKV&Rd4uV(Z44cIGmxs>(3
z<F!RxbDp8g3qvK^<YpgQ&%lqi$6D5XF#6qjoaw`b>Tyi$t_E}A8&@zQCk8NetFM=i
zQg|6ZhU}a_Yrju?R`0JijQJycoG(dA!mzLCSoo1N14A|R=}qHd;(FSVWA_E_#Cg1X
zdN?;RNlARCZ~XGz&jl5WN`#&L{gaK;Yk3!cz0$POn>ysn$I#h&rg<QH${_noahvL!
zy^348iQKW>SfA^ryY)Tt)RyX%eN?nh58U_S{nqTYOV;(;z(b9~Zx<3zO8M*z%s-WR
z$H@Er0p~wZc#8i0P3q9cD2wr#7fZbHQVE}8B@LDa-+dk83HogKaqwBn#_{@#WAiDP
z#K)~hv2{uM&^JwZUIgEqaJaGoHP`0%e*QLn)c1Y$4}HnE?Z@BX{(MnaG&<stpK!KG
z;&R&&BOBv$^Ye8<Uj-VkX!UClo`{WI=(@=Kv?Y<m#_wO_+iG#^QeA(+(_|8|esbNe
z7KS%n7ET%eLp0X_Fq;*N>s9-9Y+J4YDCF|5H%I6{Dh%%yO?v%OAYI#<lLWr?>S4V)
zLN{0L@N!YvzrG$g{r;@f><K~bS?+7Y@TD84l~+y!mZ!fz3KSrs{mERZH|W2Aoc@w=
ziV$~DWeszw19LWw!PUfo%`-&ZU@=sW(6v)CA%u++$q1%{>K=j=4gL%OhC%1uOo9fM
zu@@`TBEVk<CyWW;9}FW_AEu}?VLamu?&TQOZ;VScuG4D~w(f-e<BVNvIy%SE86BKG
zAkw`wjc<i6R(fjueqehCM<Ll=EhK$3I2r6q*U?6Jfyg(q8T%|Vyyt@#Wob!qgpj!8
z<E6>Tx=g#x)UYO|@=kAB?kZCrllkog^LMdyVF+KEdxm^8qD;ZJVl(5MLJYJ5Ubh;3
z-aWH%GrD;mDCx`MvB+%4W{b*a`&ecR$Y)cS*_cOJj^o*#s~K;5vxl)!SNml0opNHL
zb0+7r?Mu_)^Eor)%sGWzL}T{DxZFDmDUU;PM%{CtmPSqq=PhXGy^M=^-6Sm#lNZX!
z{lLt7f=&I5&A-n~{xTo<HZEVZB!4^3=huAx(6@Zxu?Jj_74a$${WgCco5sPB#i^IW
z^)~-mNIoH+#b=cx@Yo4eR=|6?K)j5K-6}8?D3lU$lJO|yJ65RBOqJ*_{BgffP0?Om
zr09uek*0^8(oTHQW^s}JTYJODMT>z&WDjd&z2ZpcVsoo7p|axNsl~Sa;XE994kE>l
zRt3(FZTH8YNqJH1StjrO_{@ooGqef00KF1_r;^|;S&y=k)~=F>c!kKV65syfnEo@d
z9%pGOC2`F%3H@g+dC#7TFLBK*U}VbEJxX0-N|}nXC;LmucT4k{rCB0n+Iz~1Go`ZP
z%TDW+mWP&BJ}x^PP{uAJ*6NjGoXQ(Kh)reXh_3QB5n|a^xejkdSDDl$j|#Ep<$V*9
z1N{}-a}`%JC5J^Szt?0tSyuLMm5s;C^sJ`c_K=z0sx-fwby1<JP_N(tholg#N{Lcc
z9}QdX2i14ftC5{m=oJKlQO)IFja@-}Pz2viRH-woEEycyu<FgSb6al_c5HM<6h|2m
z@qz=fhlqqLA>jV(7mA2IP!LMyu#cj(I<oD_>`xpBfdrU303a7?uu32thp;1_%f{w*
zZ}OH36BH+Tw;$IozeO0+5Ls*ZD9DUY#hn<2N;JqyGTgBPrwn4+XgDSf(K?ICSw`B?
z5NByPAr?p5FwS8X=>T%K(r|WBb#ZKTC5WkHLyM5O6Lf4jo5NwPMn*r#wX8~c9d}g*
zRJI0{@A9fG)T(<T=yZ-K8b@pt=S4c&Oda8@&XKi@ni<9g0$3fYl-15V#6=?BY#4U3
z0~tt$MG)axEW9%jC9;O16H$Rt@Dv=>UgKC)M+LI5tpyEXp7{~m;2C4^eJR+j&ws4t
zocaPHi^x4gho79~aHgX#Mq%hQtj-z^4{*BExW}l-5F)4FGE$Gqd54PYW^;wIusXwN
zNh+rnn=3YoqiU_$nT3gBp*5(;OsK!6&KW!0a>(+WkYlT$f8^fi)}M+<zBN?vGBSD%
zI&(yc(NSj0s3aD)mxT|F;`AHFl#tOMm5|1Cbl@6Fei$1Hz$TWFQdCYeI!b96>q|$G
zmr;_pF`QAHu>evsIbcncu%svYI`g6s4b9wHMqn3E!L05M=}=?!S|148vAdHIb%r#w
ziB~r?eIiLk?xtTd8SKu#)C~+Hc$Gt?x4Vw6wtQI8U2ncDPw1w#k^&5R@Bx*<Vx(eS
zK$@EVW*rv%4W4_ZhrhGu@OueyS@>=mc1Rr`>(%>gyyrf_Z!S1h+!ekX<Q!q)PILC%
zAMc6$DJG+ZFrppgFX+wm;&w8}A}F}}4n*#4uo>HLrXlUzneihAZpfy)da1Q^;JIrD
zCiXZ3EO_fr7)M>8z#2@2iWpf#7|@Z&fPwuT=uysrnhLNkv6r6`4ex|wC?Q<_{Z5@e
zyAK|0S;jIt;5T`()iiAS4izg!#Rh@c699bZ2_g+ZKgou_Z{-Xt?uBYk&176^6fO}&
z&x1Uv0M}JAZlZO_(Q06CCmuV3e=s;GzvijA%$+}spQFRohB<GqVU1?7B{%V!vsfd#
zO3O00W(VF1fakK1ySjX&I#3yO<bFE--Yi!(9apeCdIm&?gTomA-U0(r@w7oJHqu8O
z!ySN;WFu*7SbZ9TN`+H9;K6IxiNo-C8YY^CJwA-2vT-K&uPd=QEjtjYbj|=WXCDg}
zzJ}muUe_}mo-*K@tq?H6!}Zxn1puYp0Y4gnxk5&$vBzv#$d)Mh(Mq@?3u8rxE3=SV
zJ1k@}-Sx>g*zOK4zad1(5O%$Tb3YZsA9p=WJRoA|diC6O&PAL|(k<#NE_c@RxXRd3
zB36-x34G0=td6;$jnSH&eADIQEWly8*1x}lBOBlz@`n1b*CQTHz&nSm*BeYaeH5tZ
z%V@MM6+xrJ^VYC5Dpre%mZhSN*zl!AT-q>H`E*|VFpVte^`dcwld%RJ=q3=Y@?oZl
z1_N@YCdB&=+lu|P0Og~cjiTXuLA~94dc4|*o4kh=hER=kP6IN|a(E(jxPMbTU>iTV
z4D*p^aaj_B5EN{s_uSU6zMpLpgPh3SMD$B&oH!Reo*4FiT}JZ^+;3;@E}GG^R)Eky
zd@tNP|JwMyEsaVt*DhnD`!kOB&8NlxJc8q9@7wPJq*?cW)W8y0Sk(@|z3RcOs7j~9
z5(+F#2pJV%^w5Qf@;NCfLq8lgopk8w!^qzcqjo)tF?tm1^XT}=M{!k;60ST-div<p
z???1q^T|f@sXp`RC;#dcWnGzv`bc@d=UKZR7yjKxD%nLSk9u5w<#FZH$JM_dvwf0G
zgcs_478-t6I>#=wTv=#)y3qc6p<~yRE~6)xe4h0DXCG<k>65F!pR|rn4I3?Dl8?v`
z8pn);#;X<`DHj2jlF{g5D20OyhCvV-^|}`CUU|Cs^y$*h@2AULz-m0~KnW-#xa3;E
z1D`{^%3V6tDb(}(^2f}j89l;Y8}MB}5xWh|rC0y514pGmCUt3DWI0C@{OAL2s4lN%
zK0`1tCpxM)K7puIP{QreuMSY(9|0d(fsY`KI;x7I)MmxbNoas#kt=T>F9XBKu(g`0
z4@9|Busz(sjw-0xj$Ys5yBDx*RB~BJT~+@Na^F?3001o1z%%M1e6ug@|GcD1ymH$2
z%EkAU+o@OX)vr9SzVcpr<@@IqP2zRHzSn`iuf3~zMXEu&VGg*X;&~#Xaux#+IbToU
zV$^~U^bljz5M@TsI)=GIkHWr}J&q%S-&Dbd9WsFEgjQ4#->sf{OyU6I+Y=o)=&Z((
zy$Vp_h1@_H8EB)zZHE&PjsTp*xm$3#41i8x2v30nGL)x*1sq*upy$;4zUub_SO4xK
z{dqqu@nLk|hkyD=<JBJ~uYQ<X`Y<E$p{pZEzTh>Mgan4MfI8~)<U1quLH`j9(1DDg
zB1P0|nd&GPzyQssi1mMmbi_#koJB<V@)CURI4z{32Hpt-cfd1;5l|0$bQHs6VT<VK
zB_T}FtUy5;niD|i&>jLHhU0bSc_Jtq@Xm++E}DgPqBn5B@Wa4+NG+(-0W9hOO4l}2
zo^7b@Y^Y0q*|W3%i>BWf?bBa$&wbIq_Qmkomwh{5$dX@;cYmqt05oPpWGEjoBxIKw
zXh%g>UnR=dawP$rPQ&O-I&3@df|#{R2<tM&5y)-8$gJUU%XiQtfH)4&AcC#Y2)ig4
zlDKZaoOw(RDIJYi1QABFu<ffY*abM8!NGgvTmp!Rp2ZZY*Xncx?TMm2d5f6X3kDED
zJq6I}kFbt9Fe^;2-q~VHZrASLuJ_w+IKAC;ZoB2$cH6V<_MPnx$)8>M+qhY{MLw_f
z5%A&C>to+>@oem}FDJB%vz&*HfQF~k4KJ?Yjb|}q$uQb!P&vw3m<zy|!;V%9iF2zZ
z>;MM=Iwpbr8K9j*b+%{|ufQpxfI2S|ly2Au4<Ujj-){nJoXX{w73!io!}q(N?fijm
z6#wZXaY>k#Qdf-AxpwVK6?S}Xnk68u6hc6tfV^Esr;r?gqh+CZ1u(o^Unc}~14&!(
zWCECHpXULO;w02*+UcK<CYzzHB*h&pJ=6iNTL-19eV8l684DCNjI|mEBb37sz<B8}
z<u4}*3<OwhXnK)2joqoaBAv<U<ar6kLeoX?HW;pVP0_>mtz;U{m{z*~)khL|7E&|(
zJaF=is^85@k1xS9ReA^SuL=ipv!r2PO>#Y7T1bd{Ay_7b7CZ0NY7Zd#z?k|_bQeIa
zb)q|DElBLPRh`su@V&PyyU3LPr^>At@`l<6{GYry`tj+N(-;nqu0tEI{_Z3F-p*v}
zBxgwO|C7NZr5R=0zUguFmf5*ipYt@g&@!`wVhV~x3QB}V9YKl&4v)Zzv8+*?*pT`t
zr|hLD3f}1D+I5UsCDnw-PMmOq*HxzTI=>0N;D%sOJ>e$);8^r^u@lIGTSCVSHEv0y
ze2q2}%QTHK6<5rxA<Lih#*@baSrlspq3p3b=cvIho2}Ila}gw-cn?6%h<Dp+-j+FP
zr}Z@Ai>>x_@t0}+7q<88wdbaaW(<BW^4ahI$<I$U*x~qnk7`Kx=sZV3{C1}9BL&6U
zTkSr~f6tn9{*tp1&o_Pt8|fRdF6JVx=w1H4)EtA|ezMJ+9*52d&=<UqMY?^ARONnj
zGmLBEfSSK-Nj);pZW##TA!|PlD)1@s2su~f_Biakk@iCH<tsg2N4n2H^a#HuAmkM}
zvP;P4=ylZ-UdQhk^*%lF;=Imc!o4$4AL+A?kl(3^-v@k7{J#9dCuKcIo)I8)>Ml<P
zXOb|m|9SWM057><-4|mj%Y6s)_oMX!3oPXN1B>1_T~98yLyNpR<B_fxTz06TKe*z^
zO}#^Bj=e4m$~}$N52>kXI~Y=zZ>}GD{%r6-Xydtb{decLyXQ7B%@=R#zrWe`n)yC&
z=%Ic@=O8li!;LX)`Fo!!`-;Q8SESz@zQtYSwc2%fa8RS=#S`B8A-*~ky>_}?=Eb$&
z>0RXmLJkR^&%LnUuE^U*0%Ll2Ju8pCsgWUYxJQSepOe2GtRE$h*)Mu*8iTCT2(SEl
zL)t}O>S^fY-cNG%59`oxCgu<9wu+YT^w+P>X(d#xJkgs>BM&ez?Bno9f?TCHY)@-#
z!4fl;4&NCZycPPEuj0zj#tI(A9|4^@*XmuEL8n7zY@D8TZVf(5mwBFR?$>$!n%KD{
z`24=V`bgC6r6<0a%fm)@3?A-X{==<H$s5ae|F@m}f6)^_iQwOE0y2~fLOI_*(I6x&
zfYL!I?SleB$X1}CMuk)bP}&D&evraIOxzUG6F?~-lpR9BA>=iHTn3PI01_Ge6Cy%(
z11Ln?CBEOnS_cvwKxrZ*FM!fPX=yV^D`2Sa0BH^^ZS<gs5y}^#lo5&;A@>1vNG~U6
zZ)U9pISWWcV@TG1Ds~Wx4<Y?QOjI_M8$k)8t3#T(t){YqOHOt%)!v+$QEG0f19>|4
z>~@wR+U-{LR8w~Gb@i4axj}&tlrNGbE!>@)t?cw_Gc}-)5{f6Q{T`ByB3x`7l@;x6
zED{yut;@V-#YD_yq^-SN^E|A5j!{|rt&|+Bt)SeIBw-s&tBCeW@^bJg@wo;05n>Ny
z1iME1y9OHR2Q=pH1_^sCOpaMwQv4mlG}JtOtwPLALgSszh98KPm$8tQ&=0abn(o#f
z>6XN@pD6UZqNnYB>_|(E-(t4MrNRR@!mX2aH3KUSPO&_$9-*d``%eFyg`co1EpeSq
z@u~@NI1%Tao$GRq?ozunD6zAMD#)14au{-VPRsCa@%6~cp>^2W8z#hdB-yjoR4x5H
z3oAVzo)1{oRQL7vIG%W->TKS_LxG8IF30K$SZ{e@@xhv&HhWVXE~cD5o08O@oqD6F
zu&Oy=m1=jy!8YM=a9swip6*dynL>hMv&8t!Q$8hv{QDz9s$(K*;*MP2xep5stSnC>
z>zWeta?U{xg64d^nDEB_3Z>Sz{`WToj49-@(%OtuqX)f9F9xsQY}5=ppx9ot=j$Y@
z)o+bm-Fc~h5(;`FgKMCqcB)C_!6mh^Tlb5S_UzZ#YawN{clZ8-e);K<il<{dq0mlP
z$dhWF3P}oTN?$;_g!7*7#zlB+j8u&c%tHc8QsPJFm)?bX8$)SsW(pJXARHHvN>8t2
zo*q9O*fx45x`v-WPh94pXO)+tiJzoa1Cb;hG$P`6P3quPD5?xQSn_|31BGGq{|7sJ
z^<vY%mX~fQ1DYf1|26Nc1il?P@A9|vvh_fNhhV^O>wokFwccUhX!w8h1ZP*J)5}F=
zl3JVFAw2<t)Bf>U;=st?cJ|VhGo7A*si1pb=d0VLdn+!q^&d4At2W6_p9m(tnQOwl
zv!4E2Np$eGy`Hurz|{@S`>GCTe}<GqyM5nzLG!+U=?VUh10g*D6bEjH^F8bifA-(=
zz7ALanfLu);=u8=xt+9Y*G_lG{E}x|v$;YbJ3Fr{hw)*VRd)D>A!KL&Z#{wdKX!J@
z`*KnxA<r`v8k(dW@3pN4q;FqQc;US>74jliEA1ekT=NaABoFp!N?n2~cWC{gWbp}C
zFYBzACdOvEU+YaA6N&@P&1}mGO7Ni*vdp4+_Zy|Im0wH93IN@>Jffkwp**~OtDz#M
zXX|xUNUg}Bsz|}WH{@7&0`(lvZ>vM+n9oI;&e3^Wn$Bg8TCpmR+D``8t?4b)Ti(DQ
z%cP#O=5O(=$s1@6(E!&A`Ru{_VHBgW9o%p$M>F{V9~mDQZqhf2GQBADjm+x6Oo)CU
zcYeZ!^9=H4w;7MgDYNi5s}p8bx=l54nt(cK&Iib$u=-G1FuE+f%AeH*HiOCSxEt`#
z6s4EjY2;5*W0Ba&E>8Nj%>`VC@t_l9H|5nYN7e}Ec}Hc+mifyLJl<?5k}~+oGo8$F
z$A&Q2GpS7Fld{oFSN+WUQr*}RH0?5*EQ$C?zRj;`Ym$U@v2iCbl)($pv-%*h64^z)
z4U~GRnOKX-+_)pC^^wY_`o<c(tNJ6X9R!wP^aoZ3rW!Y$gf3-_A_SZY?uJRe)VgPJ
zT9qY<(Azj}93+-{Yp=`f&H@Lp5wnLXcj8h23(vIBWRlZ`FX>WJ#nfi^VqtLl9Kwi;
z{%WsKYy)}U+TyG#JoC@2^kd$@+fUKcFnUKWAa$FZ+s8e;_j31QA2}I8;{<Yvfql~O
z8~X;06ZuW`KGGH7o8(C72YoS--?&L}x1^u}Z=hqnKkSXt)*|v-wRY#JxWlcl(Ry8m
zHv#DVD+|bc2A?9XT(kI0<T2g(go>^v>-I7k!c)9HG`C+s)KIef^ONYUYVz2zE6-2X
z;NR(E`|%s?Zy)Cooz~1m>!U6*+VDVZ5siay0|SE(3&B2!Qv#^a_7H<a0qAdug-j-!
zL5kF6^6xCNMv|fJ!%$(wZ=}=+WBDSnc#}<ji2(pyD#3}I!k+^JX3|<o-9JrWDOey&
z>yxXCCQ}mHpE;n_L9~KKaOpHN4~Uk){SS)1|8BsDg8?Vn0$w+`t9`!^<;~S81&nuS
zSp52wh>9KGL>IQkkUL0;%cBy4D@ZS^Pa+57DmSnkfQ|XfLS~cSq`rko^5QJ%JPdfN
z@La_(=P>Cof<E%6fn_)Z0zU3E${%x#9Jgr!Hvul~epVY;WDuRiE!DYdnW2A1&O#fW
zKNi;%^}%G~_b(EB{SQqKCBV2gj=KF`GRL;Vmh<0=Vo5!XwhuX4@$L$Uy{L^HJ5SYa
zVmuLvhb_;<;AFCpdeUDvIj$dhevgfz2({spds2%@m2k(gy-Hy$HE~Dc=W;pV>Xvx{
z_e=b<>&XT%q8Za#2BVM=G*h~6otBd<ETnN}7QJzuSBekF-aPnXxTL*NF(vmIl1$o=
zW2s>;lf=ZE38(v5(peisD-@l7m7SByW;6k7K@>R;mSF_QaUrV3?V1wkD+qF>3|EqC
z<3V5eGX4}h%;_x-=)3wQ_d~a<3?^oL?@OhN*>z#2V*=yJnvv1(RK`hz2UrGDcBdK!
zR9*l?>p||KZY$;25-8rsWmRy%e7uZ2d7tIUeC~xTc%&*es-CiA`J6a{7#70$U$Twz
zPee{!AS*F#7^|=*g#Qb27^fD$lVHr$E=wgwnC6OLy=&9#Vaj$0sAlTKbH@}b<a-{Y
zl=OpJX?%>5tj((8Mh?L#H=;4OeN!)4^JYw4NT{#@i{P|@)RPa6o;FW^q5Z8dLHIKT
zSOlG?M}~_JkI^xAucrV)L!a!henIZ6U2>@$9&1r1R2`O%sn97*O=(wP$7J%<cRwr#
zB^$HRE^^PEq}Z)NF<yI~cWJW>fuQG6^m#>i%A^c~t@8JGP0BiON@vzZvm9JgBk=VN
zGV31R<FjdI;)T~G%et}(*@gFSm`%~_zu0lV0Fp2D?+_2mC0Dwl04d$&nYfwm>M!1J
zjDC9DIffptLTwz{_oRO|#qB}OdYck?x9D6>dw1mz+Yn1H(YeA?-NsAeZ;EH*?<JS)
zZQ@Z4NeS7$2M>*H#v~uovGBa7M>$4mAfdIMZ0nH+F1MeUe((Ep`_ZuWUA}%N?i~I>
z88xn+uCvo0zIyYj`yB2m&%eS7aIRPo={)XPolA&Bpq`ws#P*%H`xI00b8&U)KH={4
zr>Xnwr)v-K+|TVkkHo=&4^2N9SNREhyiCVRHH6zZ1GrB9#Po5OsoURQ=1<SB7enXw
zjmiHh@|bz8{=Q)|E9zZQNXV<Fq6c_y@pa{~Dw0g*cZA1>9R3hbAAO^#lHWgd$o@<D
zlV7icnw?CS>0hdCQZJt?njEC~f-JtLZ|>gAASchTqP^eB=<jD<Cp|}~NdH!`eQsY?
z?3?8@f1Ol7L0ji>)8kBy$N(!v6t0O&ap71#aBGgFG`i4kl4=3O4OkhT;$qN;u+6&T
zTIQ!%UVT!ZZub}fS7!vIf#Da(GW>H!;kPyNbE)&I9OHG-xy=Y7{@1#0uP{75y|?N^
z5oT{VsxZFFwD~hUbAX%UxhgQe^c|`9>y5Ky`Q%{mH=BGWVe>Gr7Fz-^KLK6w07*-Y
z{aay_!7q&tzu$T7Y@4jaySXhL{dC>y=RD7~9gE@Je>VJ5f4z3Nw*3g2_kDwY^5Xcl
zUvC_Cwx8_$*}QY@&yPDhe||y;K$vcE_qgWDVR)R>s=UDZ3A$P#-JIga;ZMh}lDKsl
zp>9!OBa+%05rXp!iA@GkI9W>ff13Bz>ZPk}CaYVLKw(~9;grXY4DF_9-A#d?#ryRv
zB@H%Hepn<K!A=^-rCOGzTKA>e&Zq7*PPNySp~Uez3#ZMz!Qz9{HXPGD6-?qV1n)Rr
zVHB^}!?cftbSlX)xGzm>#8I#}T|7BGN;f06Nj%0qWAOFKILk<f=P`+!8T2^uDRodp
zh&lXSM%bO1j*WQG!F;)cj?NQ~5EjlH`HuCjX9l~6ucl}EG-Xa}N5!sY7H@{vjz=Wu
zW}Mf}8Y;=+T*tNaDYk89^$2E@YH(evq)Tzx;w9PQq~in3>}!4DL&7<YdvcVLInj>9
zvA&#Eh4`t>oLS-AySlmR?$Y<;a_38P7y5D+=W~}fbC-qlp6lklbkBPom$zD)_pUGR
z!+hSS&Ac_?{0-gwukQKZ<MKC4^SAr*p)ByvW<DUog0euQ2MZm~!j`dc{Ve=r7WWnl
z6e-}<E8zDi5R5MnE-Mi2FA#rRAhA_I6e*O_D}=H@x%fhbvO=Z)LY2pbYFmX+7Pv<b
z$^whD<BN26%8K;+i=ZrU-&PS>q!`KqO+AW3gLBL?MJ&sTZ66muRydigfk2ba*gpmn
zFnlIdxt<WvaO4bvk%OB%;~Ni}P|rAZ65)&zxTCb*i|n9K(6*5K$QG{c1{acouvH9q
zTFHiYiuO~%RtlJ81-?)R`yUdKH90Er8QzYi@J<}2lY^yL3in5JB7ssC9zKVWDU41M
z!J#@)R~2}S;YD6=K?aAw%f?dp3dhM=uz(7#45L2_k^olu0IdRGbDs%CIMYf@U~t1P
zC5Vx|d{Ll(bR|66#DrZ5s3X(dOLSyPhWmwQN(*f~suudIl-_16P6+4ysCvFL!QUt>
zsuh(az=%R?oRILS-Y^HNEeO;;PSV@z9GEl53Qj93ZZi`>9S7g2gCF#&_jSfVr6BRM
zCNguJh;<}<gu5!H=p0or!Sav=5yKY-8jRr{g&u=DnjpjYzZ_@7M=<O0pq>lT(YTf;
z8vC_5h_t|$5K@b*Vc(*I>+y9Q(eVfz;1CrLfHfL8em;HNWi~kQ2+Ufor6_?$3kBbs
zMS2ermN)<h{d#v%KF9L&*Mft*al-s8m>f0H&$A&op&_KaVRKbF%v11MDCjoZ5ToB1
z>)Cibp)sz!F=3!FX`%7db|YQ1DOtZM)w3x*p@~`Elr_+lv$N2Yx81}NZ7$SrF7|9L
zNoX!DZ!RBbu3TuY-fm`#w$$pk)O)rxB(yY@x3mnjv@Nu>Z?|-awsz^aUh-`1Nod74
zpY3}GHuks5!pg61gL#VJZ~_>i-`d;{p3fwl6=|E<ZkrXoa997rz8X~A<6T5@6{Y~j
z7hi>E>_WlX2UaS3RtlB|z~eOV?IiE>a`59j{+FV71f^X#zWoyp_&Lk-yMyP~Fb@!Q
z0S;?_9tQu615n`|$mkBvnvRw74%qt+FtOvKQag}%kwXKvbsStJUlfdQKSl%b%Ah8@
z1IG!MP6Xx12!ZfUQZ~r<v*X#jF4RgEV!fTT^Q7HjnGIiIUjdE^#8)l+W!Sj{R)BBA
z1m;IDkCehKM=+AvyX0msxkjT}f<W`qFz&f_%bHeou@KCNjFK{FWqimZgWo?J3}<&E
zI-#3Vym)-oYhpL22J(1+8N#twlmfPNKyrnyMm;2rqib(C$Y=$}SEGKU=V<;s+rJ#o
znaqj*aTZl`)^<6I=Fvy<=(weLao=PQe5GIU7R!GWoGIl&&L#K^f)h9(YOMjo!1ud>
zKjdt<qK_DkN)sPRDYr`YvdiSdKxeQqz)A{9(Pzek-Qi%TS2uE{CyW!QQ5G8eneknz
z4?ic>sfi?X5ijb2rBOqOot5mKCP|aoE<k-C9s>-qJs)raUMz5k3`S2TA=a-7YM@Mr
z_zL<}IH@F38BD=m34LGpv{tZVIraM>_|fYUu14}ap|QvcBut_GumAxMJgoq?J0nFf
zNuI0`WOQ43=135H6b&22-~s6*FnQQB$QTj!_!^dg@J0gF;W(~${ZR#@iE&k$0M9po
zM<5*jz8o~^7)3J1&~wD0e$lb5N)%^1W|4@oZHR|{k{5XSP#1S6$7Mn8g*O8(IiT4d
z@Js6`PGcB=u5x}}d)+Evn3M6qt3%lUd^Cw%;zgSQ?P89JjsZ8&E2{Jy&=Y`rf+EM-
zz{@+mH;&taKLlkpJI4Dm663sw;Uu&nK_p#eykJF@kA5~eV&ZT`H-m7?x^x)VIn3oa
z7Ng9onB8#^->ykTX>~*r52bbvftgc7T-j%}Z-aYjxS99tFi!Z9N`ZTWIgaApxacXq
zny%TL8%To=YW7(NJi#NPgX%>%4h|z2T(E@#KJ}TG-ZQV0W>za_-VM!sSe*H^ID=fD
zSycfyre@&L+>HWv-l{Z-&fbw+xzjsBc+$c3aRomE02oyQx@wlke^z*877m-6U75Y_
zIVbqLurfPNy_}>!BxS4*F5!7es(HcbqT~g>l_Xw8BZ9IWNpcr2t556%;od2oxw#tB
z9H4$zw&tGt$i0U#cSkAroMHFX=kAL5-zThJlUunb=zrhx3Q1%aUE7W%c16I|i0?mG
zB0pq$R)ImM1^-%c|1XvZ@xy=PL<l58I1xgH5Ke?pA%qhlsQ7Q92(d&6Dnk4aVu^~f
zju1<P03$>Z|G|k6Nc`s}!P3US!sf5xM@W!rZlz;mX9Tgte<&iv75@Q=rdFDeG8K}d
zLO5}^vI}&FU}gK41r;KP(3HB2jHQFUxtYx#HAOG2J>HvBKu&szw4_a4mIgHB2vI~i
zX(s^zt>cb`&~!Wm49)E{RTNzPT>~U{Sx6Dh4%!}p_@RrPgNvgLWDz~!<aEH=Q&-zp
zQPxF5$|B0+B*YS-!vhE;p0F>a?2Ghq^?>-{vB)+E9x5w3_)-t<GdSpD6%2tyV{0`M
z(Z#{aD%d&F)4}tIV+zCxWu@&x9pWS0PC%GZRM_|*W(d*3eO8JPX3X}u3^BtLAND`M
z5Tb?96#;|_A^OLpH96QFWqP;8d1sw+VMEN&+L9b@m7JGT0Rh8=qn!{lY|7ii@L(?u
zh@Cvv2MI&Z`>#L<G1UDCgbE>Ym~#3I1Q;QHXrOZ_%wsnM4?}{I+?-?c1G@i#hY&W5
zj?692zIW35OmPw0$~;0{%|cAn3c`lc5{3o_)C)!03GtcSJiAj*4l+&*?>s<IZ5T>Q
z*5%2hW}i>xtj96lNf1aR$~!_t5dw*#qMpVS3d9m~Qg39Ox(<QF8}(`sOH4kj4za|7
zlX`mU+7;z>rj%d^CqjU+D%~hQeI`Co1wx4YyySl<;+;0hM?G5Iy^|-8xLfK$TcG*k
z+A-{N-StcfH*<A}BKkULsgMjs)q=(+AK8!$GU>OZ#dUq9^kroIAe;zsMY6srgcBiM
z>CouhljV1H<*y)$2q8q%{cit75fx-~A&}S{{0d@>|A0gbQ<wi|mMC;+dUU+=e^;H#
zUe8rK_^<sOJ-&t!ZNrrRQk~Ws{>Od}bXss`rI~RE^t~|opsA<*FTFYEo?ZX!=iKgT
zq=+MWd#YOb1^>05Lpv#0%n7ZymyUBQ&u|2GzPQDbwu!Wi`)9@d|FEC)pDeNZcL}6A
z?Sok2zn32WH<mbXtniwP5}fsWAXe_L754*1kx8=~ukW=!GN^z4{oC3LAv2!xKa(08
z{|D76I>_`tmmZl!D(~N_(>*_!!N-GESNuM66^~^=s?z|ksH#$s$3JNJQL@raT}P0T
zQ)()p#_N(sR(s8)=Au5bsrlHC?lOQmuDG78iKb9N5t#y5F)p{Xu1K0&ah7QxsmIF4
z$oiiz^^@ucS(rKI%RJiTs*i9~`p8|SLl=x2$;Y{4<t-CGWxlD3hXYO3kqJy|n<xDG
zVqEa8<<+{M-}dmP;Z^+!syrkZy+MuQUw~Dz(kN&$c||O21X%9~yp}n1YAbI)#1gS>
zI2q#$XvSo->ENe<=8IVprf<okmVt_9y+bQ4Z5;6d%H2{E`pL~micP`g2l~h`lK|n^
zWb!=kSETWjk_K3ZO5-fxeF~2<GkYf*Yte(PNd$@A@MRUtURJ=U*vwTJy&wLVlRkp<
zAt_(w&}ci7`6({e&g=p!cC-(^D@L92jQc(c$Zaa0y#+s}(nXd(n5qu=RQ|faFX`+B
zP5|RM)Jc_lsY;U=Xm^MkccBuT()x_2bEb+1#+qEl*LPCLM=PC%c=|yV(;K424~%EA
z{I^U?B~-f~aKJd7?xSU&f(u-F5#vNefl)zs#F52Wj*t6_W0z19JHJ^RLh<@$7Qx`9
zBPP9IJsJp6h`s%Sk6<{9Efl-oXMEx%1)K&#PHCAeMyNv9n9P}bJ*eFhjw`4uoN9ob
z`b!-k5F42M4mnbVHZB;tK$Z4VPwgbTwVtGYu+S--71$?PZ)kjZH~-Hsn1T_VJDffQ
zD~h&s{lGfBpAkO|*v2^C0#q*O0-0~TqA2KlWG&-IHb^Kv71Gpr1V85E_yg_ujN;zQ
zlA@;a3saUw7lMbASII~BRR~es4`F{OjwPW<Y_d14r+8|HK_n5;P*S{?YL|?soZFzf
zv*a{8B5}>vDYM$6XxxXRToa-|-Yb@UW#Fk5Y3B3}&5~7oY(;_)?PGlWEcmjDQ%VO3
z@NpEPofQeB11?zJpi<UH4Vf&P9PBp<V}wS;9T(qXDGJjPl;KVVrNzgExi&O2XzF>W
zk%O;f3ez>8Q%Ote7@&#F1+b0nxtfKoQqlAkuCW3HMbb=o>uL(}VhT^eOLBnxzGPcU
z5sTmQ>%-S9dnK7ToW}X5*kq(j;aDcTS<+5(6;iq4PjuLhE9{Jece!3t<vGO6^wE8V
zB-6sC?keL#4uCJDt87+$yr<f#J&)hHY<j4HVh;2j7U1*h+IG``{jlRBXO}_Zd_9g@
zyV%#t-eg0pj$(}6VZpIVzUW4iF~yzMW0Ci&Kjg^ocD<+J%KeosEMlBk63FW>^|c1f
zZ8DW#U~4;mtrebbGS?{=l!*CSN91aTmL3Zl3cl7W*fm=pn7msu04+UUX~G9s-z#6Z
zPw^ONwtsY2BJFEzV?hDGi>-V?nP7&PI{cm0dR<|l!nbB=4Kpp#=Z;MhvF-$zbw<c&
zc5`WfO0Y(Y>vd_%WYCr5bHh?MVvlQal9uePwO8&hj=B|Y9%+wLopAVJoK_#DMiQKU
zfArMAfh_(K()Cd#n*}AoLvblJ$+>OzV@i*C9D5Y^j7OMg-eyht3X&=>{Ij1kBTxX0
zo2k_ny4-sgdznA8)cO<vDD4o&YVF_MCFd;5EPZ--S<>vIDLtCc`O-uNgNQwh+ISe)
z<_c}Qhw7z{&Zo4UA%0M|jH$D6nl~SFs-szf?y&{$aP^lL&o@P7c6lFHKSMlEi_q<=
zVD;qHh*r@f6W&UdE~b)%o|lgEmSpq7&sh=otFM)un$7#2>|($44FXK5g(@{?i9(T<
z1`prUm@)1OR?{6OtG5@qEBa&^Mx9v)rk)E9Zr)JO>&!W1`{I77kkpY2op~pwUP%1h
zyhY~jV#U|alf<^hE$zDs&rZFRGuWEgUMCedsucck+M0Bq=_-*8ysMhHb(_ZBU3x2m
zb&<6-6=L6A{%Gp8_F&nL&Xbefm9XJay=#|lAJ5BIAjUj3{JC`pm9>|Rv0F73+lKxf
zU#b<FUNtw^o?}&q<Vl~b8L$q#QygjUYE$S|e_!Js_q$8hk$6BcW&3`U{pFSe)9>7l
z$~3m;U2YSq%VZ=Se@M8Z)lRTp@;R+AWVQ>d;q>7>?(hI9O-0+(|32r@)rDCz?&jU+
zE_?{{`nj;DLA$4S`eS6G!NpUPv&vWPA}e@%7gz0j2Od=wAMF15bS<xU=#AaygeO0j
zHfMUT{+RxJ>gUgA08igA#(phX?AJ2Zp>I@ZW-Z;|*9!O-OSE6l^7{2$_)gzVotgE#
z#9uFnJpJPq_8Wy2zg{ZrIP^~*nAs>9{PjxxzgeR0o&K2<GheEI{(3{^8JNwm|5_{d
zbpPDGfxBmCzBU;AeoM_CxZi01t;Os2JNG*S4|`|6wI}|5PvaS!zh!^CMCQte(|QIA
zk7kZ1@iDN6b+{HWdrkmDS3X5MSj#CT|G03wWcQnN%jF6fZ~$2T4CmOr!l?RD^|jmp
z`*wyrbEPI#cu5e?k@O-wCM7lE45><J+#dzcmT`>xV(u~eXvmy3^CjvVf?@PQiwAft
zH1@RV&XrFm?j#n45B?b5$vu^Fr0m>x`le~;1>=O<^(zOT-bXV|Q6xU|2Ox%<;WdAb
z2z2d#dApt;Z-w8n2v|8;L98V%A7K(Y?ttSZ`{f?)9^V>y=|bQOy!i6;e!H>#EGr(<
z-b!`wq^sO^27eXXQo!G3&+;i$AD@wyRNW)`DZ*)9cgE<tKX-wYU>`&LKUpH~7D~!J
zSuQSFp)^^kFIi<iSq)-|!YO-nQ#9REwBu5AOH=gwQVi!)_HCw+g;R}nQ%&7d&Hu#`
z?Ke}Y!f8&rX)f+*XBlyBrD>jhY2Nc`zME+@;q(CA^g#FY;JEaV()6&t^kGI?1T(et
zM|upz65TV7>+TYW%}7{{b|Zr)$3@pco->_Cp<{-$O|EBbTyrN6RNMk~hVh}6d&tYo
ze1)T@H!~15Oe~BWHG*8O0nf#OH6es$jVwO@EFMOdphjk~0>~<j5giB1nP7J*1FJ!Y
zGqS->!onNEZ!^L*cQNQnVP^U0Wp}VLguh|jC0{53=O2V6WVg;UbC%uVFl0^?VT2gn
zsq4cLor5gML65`%<h-;Kk)0uV+yp6b#O35=?<>ND#9pw^0&JUQBK`3>vsnToTqH~$
zf|Qr01HPCIPn8Fs_{SZ`0Cl?gGr|M})Aii^3HUk-K}iN^1?zoam<8x}G#}}h^Rw@0
z3yTX&V&N1);doF{5iESe!p$A<QwL)<GVi(*zN}+U>@5Sk0N@~v=HF3-iY@}k5I+Q$
zqH^JmJgOO)m>L}13Jfv>l{tX#{-A4UfnhWFB?N342VFft&v=65&HTsXxEoEe9B5!a
zAmQ49EV)~P=q#}rM#d<Deu^r)LcxlXSah)B@k|<C4`ije+K@>$PFX2>U{M_S4STeO
z%w4Eg24wPyr!x#jklm}yU(6WOelUuGsNE{7aV#?{i^(q&v(*D%0*SE%o-}ktqHYCr
zSCD$VSoBQsRmX6Hk`gFn#;#`t7AVNV3av<$hL6fNUsr4gR}PO<cr=*odR^HKtF#m$
z{JT-}&nq|umj2h1SlLxg#Z^|;%~03e5W4!7b5m7um6LVbyu<n94o*qYMNamBp{~V`
zJDjqz2ju0b%F3>0X6CA@uI6T@YS5>xhMj|<i<339?PX`}U}0gQqU2(v@8Dx~R7J&=
z>bTFyM90p4zp|o>g}JGPxtXpu)y>vPM%vZV($v^&zloW#ot=@L-Tox^`gGR|)d4dM
zzY+yGs?Pz|ZdIx?)ymze5bES8$~i+1ZD02S?*sX^w#L5h`POzuJ_qtiGNzucOz7Qh
zX0794<try|rzr0Pz2&QEcNOFuWo2zo`;=t3bf_r0D9AfNFYd#K>VC{{8t6GF$+>La
z!F`+JG~a*V`!uJARX~*2Ne3zgD)T_c{E;EGKW1=>vQE&W8>;lgL}mS$0-)*+)ZzL6
znv44X_jk+=9Y{_|O-s*UW@csQ<mTnG3JQyg&y<`kHY=^Dtg1f8uBol7Ki|;U)ZEhA
zcA@=ZM`u^}rOQ3Nef<N2Lsu?qUL6^|K6c~gt?`M;+f&msndNux-n;+c;iLJ-3r`lG
zE<IabdH&+%tJiN<-@beQ;p3;zYwH_dzJB}uV{>c!=da&?b^ruU+_Hl`l7i(^@*eM~
zxt;+^TUT0k*51g51}~r$)&K1kxUqD$ME&2dz=^*bB{o;^*0-^9e~n!EK#daTSd+76
zC;#KXJnWy5E7{Wk7XDA8q{ZlA(1j<xiaSq6|GqE}mj3ka@_GNi7B3J-ZfKz9iknk?
zxmCUA3H~NooLX*U?!3><&WdSSrCz5VqEt|Hw(-qTuge2bXJZ0tQ}}_4d^gauu<z{0
zX;GYowO-VZkB3rzxM?OiMJx{z9tg^wzaF!2_1ryQU$23qt8;d=-M+tgV;(4w>H(6e
zO*-W@SDDUf-vYsJO==x*isjWL%kMW{^%hG2KY#pzt@@$i`wEv%CkM_}lW_39YN98<
zB{mUMvn0jks?f6V{LEn!b>Vsb=kk)c7l`ypGWmZH_uf%Wwe7y{Ob>mAUN!U%p?65=
zoq$L$p$ZC8L_|Ri5PC5*MMMn<ijA&<1rvHxdQlOBqGCf(RIHr&>i4bnuD!pt_Bs2k
zJ+}YpaL^py&vnoFdw!QC+915fohzeyb1+8{uWc<WKa4FYmalCn;FfPDBc!cVrov=p
zBuneI<TaHN<p3vr-@(#sa%XNu4Ra8C94J(BD9IsAaB>&o6LQPVGiqy;!59jQpQa|Q
zAQvCx@lrK1Bjbgv@%d1gn%<%A2${_OT*n%II5F}>bbo0trzk$X4{r}W<Sff}HqI-k
zP;0O+(fdG-Qu66%=bk5D3Vkgvvmxe?+i;#g>Rer}bRJH+m)R?vIU0?vJo}b|<9y){
zvAmXsj;h?I8a!8iTiG<@x$HUN)`pt)WrsIvj!^&t_hsjB!SxFI<-uz-B~^!OXBY(q
zC$nyHaa?#QT)S5(y!BS@?MLU~G%ihU7^Ast)bA}TQ}STb`EifLIGJAY#9fz)MAKrn
zWP}wbn`PASAJ$}#8}n<+cpWJm9F*Oa?{Fn!<&7++PH>6Ep*S3sC~sg@yIPdDmZs2G
zz09qvV9uwlu56&;n>0aFIXO6SmB7O>?NYW7r>fl$PvQ;mwA3@xXew}+Kc4pU)66P^
z@fo;4#FMz}=tZ9wcqZ16grt{6?oo%f_W3=bVuD0KI;fGibR2)C_~|J^ao$of7w?Yc
z(!VUKN*=sK-N#X@;LA#j<<6Hy^ljf>HCCSCTseDg_1l}~0gdl(+f$$SzH^;!G%@LT
z+4cSXi;ZHFwcZ@rAMehu@h}kpgPQyCz7D^covqN;`1+uK(_#HPi1EX!qj8$Qwv>8O
zx9(_6`G5Sf=~JQkL+M~(srmN}MeQHoZ;u9V{i0FMnyD>W^;T`#F-e<EqBUCZXwC++
zw-Yu;xql3Nm9Z!7-)zhfEk}O%b%MqFA|rDfca7Tc0dBF}@k98HzHhD_x42r@vaZC}
zNP8f9#2>C@_tB+!56p8&smL6;P)U`!G|)5ENvBN`q@{&@dUZRS^2k?ukwYSVDt_zv
zKBKk5HwODO{y$2tj6<aG7>7Yi@elM|=Q<gYgD12IA4<l^QgVt8Lqj`1lvY*`i0Gdj
zY64rf${5`BN_Gyz9#x4s8K(6r-WNgnW{<?Pf=E_SryzE+H4YYFt$|`S`J*FGG~>&_
z!_h+i*Sm9ioqt=dBKhTj`=gJ-YaQ<G_WM{h-<zvy($XE1As2dwdeUG@a3rDXV|6zb
zFm|uIy&rB{y;^v|^rgetp@$#OY>r+q|1tzMwtYMc@H7xHj^i2P8w{*VgQdvuc((Ch
zTi{CIZMlhjzkh6j!xP1a{<#HCmR9}8EwJdK^RB<Pz>V{U_b$2~7@j(VF0VD`xkS!!
zoURrB)L`#&$>YTE^m*e?7s>yysQP`n<g<0}lGlylnZ`q(E>n0e`wTeFwpRV6QN8Rp
zH~jA!)teQull!HT?_3W0G7M={E4B~*P*sZ=$4Z%60vYO<PytoGZtc%4^r9=_!417b
ziHNG>cVZ$9Qf=+{yW9NVDQH(J<&Mygw{<tq$hxNHDa{MEafHO~2uTGW+!wy~fT3<}
zUGQjUdznrd1(3aj_gZw!5@ejdxHokqK()KAbG)cA>4MYa*U8$=vr_#)+bwRf&=a@V
zJWY^Ab@4;hm)k2YO^4=27C+zoa%ZimDea}xlWz~dbZy>iI`U=Y$**r;?gG5cRE#ql
zF0skPx;AHsj6(K}O%_<(yhT%VUgGrM>=wP>oNX|=#GAU=gXe9@wR3*TUtp;Lb@F7-
zT>Qrxm|)y4`%L^%%EjwNs70bj`e`Kl_Zpbvye#t{*Fe|3{Rd)Oo++V2kYs2LyfOM*
z16l)ZW^F4{V~9%jp`9lPZ+Z7OQ~9W0@5L9lRlh6@_Zr0u5$kH?R)26Pt@wgRw^=j9
zIx<n?Uw?0bC(;U(?cnz+2NRSAow34Ge4ILjjaq|yuUrSd3Rk$;1Zgg<SkkI+X&U(R
zdhcF&-TF4;cs>huTgzqAq3SSs6LvWSN|dA;!(q8hBV;@PBR|Atc470Qw<fc;#WUc&
z8rOmIQnArHz60~;KexACjg9e7eYDW^`Nrj|v55yv7G4N{>9`ZPH|c`J!W(D}d}Q{1
z-?3W@n_Zugyi9iq1`_}b063bs21DLvBP~)`IAASZBw&dTW7sXG5l^!+UE&Yk>_e=^
z7fMi`O2l>a>1<m+w&(U!dAkmlgE^3YYT=oRw;^28{NwSlA24nTa39B{rpr<e#YiAo
zFmPksR~iaa129fzQoR8CmCJ!|lc#<qHSD<a+I`^L%+>oFm)!2W@jLNtuJ6pJ=F~fH
z0~Ei{PMCjgYdZWUmhaZ|gVp^_22=pr)Mg?qf&Bq6{Luj$I6s3L+HFEv%hbFL=e0<|
zC~aHki2w0ax+$gK?$>(miQCUP;x<Ray4KIW{IQJNerQOQ`r)+V;n$kMDTBc^oafwr
zymsL`c+ct#=VcMI<pX2i`|YGTgY20_Ic`6mN^EV8*zeVb!~VTjN)yln+~H1t!(Iq-
zA?*DNe*a0n5c5Kza)@>z1l}7}7rU!AI;;|+;Hc0GXG3Nn5QcCVqF@M7A(n)Q7{XzQ
zRUxQ^DD~gC7y{2fXbdqdM8^<aLU0N(G6bp+RQ{cmA!3DK8NyhImmzM2C>6q62vi}A
z{WpAu5EUY5h)*GI{Wp$=kQPE|h)*HTg@76YWQblNs)fiJLgPPh4Z$qL#Smgc><m#Y
zMALs*8^T)%r6Guh*csw(2(ckdhR7NM>c1GAG6^B`9}<Ts7^34pqzobOf7dV679Oy#
zwLczpsWIkFSG?L-QtXqI#`kH#XS*2j_G;qC2I~@sVs29JH{evR`Zdj8Nq$tfcw4_Y
z&q?Fd*h>4MdwXv^S?fr14bFe}>GqMa_usdu>Hiv|D^FIPI>uA|zrg6OyUhQH(PQHi
z|3@);>pv7VoxgX=aNp~NKOFt<Z&QAA^wb6NzZW(AgQNd?o8t5jjt(5T4srA!aa`ly
z-lqI6YJ%RT^!!d{cl>#q@>fyQU&-u0ve+?(Rl#3HO|PaJc3cknx3?+3#c}`Zw<(Y;
z_HW7T?f*$I`(O1mDKxMj|MP9ize;8+J^f1@_dA*WH2+>o_x~$d?D5XQ<udYbah%ux
zL0Rmp3yf??7Q1E2E-CXjqzYdWzc_sIa$Q&N?knxHyKRxr*?xh4YqEoczK~fn7nTG4
z&w&>0KN4+d-TwRBfi&5W6#LKK4NaflYHTM+gsrXR_}jbf2uZXdJGQHXlca<hWXIMe
z1VZM^h+y&_KNU!&4GFR#FE%96);Dm0T-cD<`Y)xmuG60prlsworR@wEu_5cUmbRm^
zx)U|Y^N$N#Rl`L~$5mO?@wXA%NlnvPQ4MluI~W<5Z&%m>sj>ffu_14@oRXuS;SR{h
zt*z(wZ-Q({TCGhm(KB%UZO7IpXgTQWJE>{7Ny|c?%Slz;?vEfFa&QyPY)p);iN+?7
z5nEQl4N`UM=|cu^=wmuV7HkcI15U`$$=(sesR~)MA^9~lZU1e~LbLdPd({3n&e{L1
zAzSzNISZX1e;>8bxdKgF=xBikE_AN^XEXP|YvBH0|2Y5U)fJpO!@eXG-v6)6nkaKJ
zv5X4~atKm=mZU95&;G5+uDgyH&ZG(%`Z0YhYqNO(`|`gH$ddq*iqipNz!hsYw{qA&
zo9t3B*_#Y}c0s1D^|F-np8+WV#mW1L@^)BZ+?9?$15)@T(@rqmm?rp^l+pL%_kcWY
zU@t-d5^v92MldR*Ieq@TZa$vsL>%&{<p9)xBMqW#*2epne_dVSW%lI2IO+;<QLF-@
zx=BO97BnG$guFqVk(1txU<-a+dp2_RZ2MbZp`FM?tkrL`=9zLT&XotBDe7&SM51!*
zudt8$2^s<drocKIGHZ%bFp|mS<JtJ^e-6l`=w|%?6`QvHNm6a0{_B-<p6HNmVRWy*
z*|h&LAnT6retogw{H4Ea+K^eZxqnOL&0iDp&DD+<|FcbdP~r01*3o~MHPx>a{4s0p
zQA~W8{QbPp;%}RF=o?Wd_43QBH{V`=1Nk)jRo~y{OLS_wq03$V{?7912xQad^S5Rq
zMIf_g<F|sfZf=9OYdxTy+Ip{`cg%X9=&md4{gMaXt`FdI)IJQ#orw7`q;%oRhheoF
zZ$FF>2Gn#~UfqxRc+c?Vm5=vLzr6kUFPiK&rpR{cpQb&%V?WLK?7I4CHsHX!Pji%i
zY10mTkeoOd`{i-U%d1}&)4puI`vN^^(AZ@E*Ea3y1FQduP5bwQhPl1p-*vof{Jwho
zzt5)48BM1DLSAjKIEr3+V!5G6Ocw-?Vx1Xqk%lWmCwtSm3mHg7dlskPT88LG&^7Hr
z7VjZ4S#pzswX^T$uUexiIoEJ{4|WURT+1R9)^P8#|NWf7aI}W^z+lg|Z)-V3?ppBd
z|4*AXvOM9b{ebbq_2QJ#bKAZQ4w!r0gYEdiMM`V!y(U?wf8@%dB&5j{KMg-5q2?%e
zY<|#M`$KU>`|@|~i$kgk4fwNf>y+#|`$0=bdYyB<ic9FQ>b1lQEst)eAh9MY@b6m!
zRF4C-&*uC-v!MoA2%Mpm7?l08vp0cmfkFrm#kqc$(bj6Jco9^+A!diNV#bDUP*%*<
zji{pJ4%O2_VKNO>C&)*wsp_q!vO`UI2h>xmsNkX?3!U^%P_PWTiK-y)tg7t(r-@cs
zp6u!dwN5)g2cEGZ*;p%7QOU`TY$>Z?2dxD*hH((WTj)g{Ie5lcHRAIqnxN*Rt?s9+
z>?$K?8)|flpycaec{tRjBGKV;+^+NfqyihAeRj?UYKoqEnt>LIak|PuvNHBW(^yBN
z6nh6#54|jsr7l$0y3e&CRJVG!WA#ppOn*bVqh=~meeVJ5_SF5A(YsQNj9fAtyOm{j
zsLOkqYezdenbF)?&N^x4mc%@lVJOGuMb62|ED0eVCz~8O<kEiF;~JD{3$Q656KGCm
z`}Ng=<+i(|BvwGzWm6qGq_$hxs;2np6vta%va&X?b<j&C-a6^CP~tun85QK~6_{y0
zn0A1%O@>%#Ke5le#mB55!t9KIn7)Xx)2~_VPLBkVlUmxLg5AWrDE&GcTcf1CrLInU
zmTz-~1n&=ZD2+C)v$U}+^PVc&aj)F{L6+^n_i>nxj#HL*7Zem@6ccuOI+~hkob`WZ
zZ?lV*d2qUgZ{UJnWzY<T;&m{fh<fNO)tXgWQGPHjd5=$0xQBAbX@fk^_B4~bP+jg>
zs%W6YE<M>$PZOG>i^=(b)ztlGn$FZmxF)(OXK&lK^J-&D=dD|NV=~UxTsV^@-B_XM
z=XGqa;nl+Y%0j=c=&&>XzRAueT3PX0TTf6$K7&Nlpo6>36Ov;0M%drK$S;mJr5&k@
z2s<*?sJt&B+ti4h9eCcvFsPx#E+(3my<1|x8-4z|=1v<eKUYfGq3zv$J#Tw?_QhP_
z<2KzNCU=D{-&3PnP?!P5`x+xQf_$^`(z{R6^!jT!-JR^&H+3jM_P$Q~??>dzDa@@+
z9!9=%xb;Cjbz@&Y*QlUN)YN)MTmRXGB`5m><+-z0uAYDSe&fG9vq8=1g~4_He|=^r
zde&G{vN!?L{=Y9ZQO?J<nTY=Na^TNW!#OEoErB&!sT;m_d9LZNrN+Pc1u+$A5F`JH
zj`*|GaLt~pNZ$i%s2{1={`<P=-kbVyu05Fos(;zA=Sf_+Cx&l3S|iG<HTEnzyN6l!
zR{vgVbghaET`osn+H>vAoWc^`np6CDL@c$Q2Y+o9x^Bv~^<V-zgKIA1gICK8KK?$l
zUGF?yem&nN!c%kS*5BJ_2RqOG57$lq#a2U|p|VL!YAcisDAr9DMuq%!W*bK?5sfH{
zA=&u*7uZCJ?5NN*sWS~v|HYYo&ilx_m1oC@Xys-4uTGR_CS2@QS*f-DkWg72$+slK
z-uU-Y^EH^y@5nSl6d>ajP<yK<>XT$kz2wv7XzR}_Lyvc|PFfuHp`XUrf2E(nln@nt
z_GZ8oPwpE1s_1mYTs{Jg*5Y)p<tvIOgC0T1SB~<$^Dj=tA3xaOD2fNE4OqH36;)eo
zd<k{=Qq^vNt7GdB>mrQlXnFO54E0iDeQQ4PO8ZT5CaR6oU*&3DB+>Fxeb+Zts84-Q
zdeb>=kcqvh%~s=BD5kJbEkR6b(?!?s@31Q};JfC#lk`isI#yL;fQPMqs))W1eyW|#
zv-#BPV)kn)jla)q>~`+A@Xrc=JF^M!Q=AW9iADN8U=Hv!(@0mj0IthJ9mlVH=(#Iw
z+T6$OM2Ge2Ty~5f5pGLUYlO|2UK$eKbdDcG9^=-!e~r^j>yqiS{PsyBkr)<STR=(=
zx@O6>3h#@27dO=B!M!@h<@5awT(itYW!~qUbNp<}nbWaD{9%$SjELj~xj}r>mhJ~Q
z4-I?+*Qbrg1ES;BWjyDMP4p4z{{Cy-&A&$8&OeDf1w$*3gS#Jg&N5XV20DQm%K;`u
zZ8w#-QWM(rW$Ec40h`eD>gz0_<0jW=(DyFvbo{|9C!c7fKVSvBw%*J+dpmBSduq?k
z2i>>c#dZA(dh+cGmI7M7Y=6}Fb9&5sFJVTlfy#nQG*GM%Ey>NK(NzPo7F!=b-o+z9
zT<t<CSy7R%6^UQ&xxruQ__3f;Dj_6=`o7>SPYi>Y^Pp%)*zl<eIp&QnJ=*ryEAG|=
zCY6`5#PRbHlQ+Bt=I-voRhcWT&=1m}HWqIQARVa|kI;^SAvMdGgIjWIOh_geX~dll
zkm9X=&M>)ybD^@X_!gck>0H)KBD$~=hODG=TM$@H`s2L-l>xI1-!6mz2^zwq+1t-O
z9F?OWl*XU(NHEelib31K2`2ZR@micZ*$!ZrpyAIlxV4!8NA-HTv*gUS?^vQuDIur1
zs&-PF+(zB$fflWl!y2<8yMeTia*rH3S80Gtblo$yuJ-3BAx}vT1_byV7k@DCkRF?m
z$WKid8>MIPYytv3DV7KVC0k0;y|QO59og-rkM^0O$fqF%4A+q1-zdklOf3<uGk^%K
z4KcpKLem_aSv>bRh6q;RXkMNy7I!9+LPX(`w@5`1^f2$&42+NrEq(*R-I|A$$coP~
zoTnu7T!XC>n$ZDi>HHnJR)}c^f;-BcC(0g%2*7i0V=^g(1{i|EG!j{X>hO>kh2`jQ
zsTB%Rj0zK29Y@K;w4dYT7Uw=gr{Tl#D2<&Lx#Zl@qH1`gWW+OU5*w~gEIwy=HC?#$
z60_tI3$=UjqGJdV!8;nlsn7u9E}fXh*HIgcuz*LfF}%$+JwL9(ir01=5M{7XcGq5E
zZHH&eW<8tumK)x_P(hxR(nDS2&k+7lg%IzcUe#D3iY+p-`-Pq1K7o+agM5pJqKEKv
z+09u!o~Lo82D?j-Bx^L>DYzA1nykB@wG?EC@*89ncSKn#W>B&n$=w({Xd^R8EKn<T
zhAZT1U{vf8;0gd#5McOaAj|a%NzjE#lk4}rOjZ`b99SW0^W(B!?5?@NKnf#>Y?>yw
zG|v+k<e>sKO?6?eQ*A_a5qRCwwSHB)m)KyfL4hkUuAzBsFE88AVswbLd@7V~p)O{o
zMAW=sI+H081q(e}Lgv@@QQ?qF$2i8bdb|lJIUj1SMSKS$jFGh+#L<2wcEI{%0z{0p
za(I!_V(Kp}!9)HW_H^ceDIs0#2QkmY^ebnDQqQ)Db(DoQ><BiBi8D^fQE`$M^N453
zWi-Q_i8WgYJ&LxR9AQ~G36CgcAh(rYfol*+hb=mKB#g&_?F%eH??FK3?b<V=@!BC0
zc0<B`98g&4<hHR#%Lgo29%^B7?4yt{l?043Rvf7ppH$|+h<3g38ZHsvT|bA<ldNO&
zYNuGsx88oPv4!V2%|Ob8GvUr`B1(d;C!f-sNj`RnbBu`uS_v699<#A!KF5(~*0HA6
zEM7@^hH@eyPs+4gkkoJ;2wclewg~0XJJlrKv4*m4#v{gvh;60u7*fL$@AS5c%J1*s
zswX6Pya!=i0n{9-;#G8QhozV+Ii4i=<5nCc16&Ye-->mPvld@T7lP-+lkqj+R?RD^
zY%t?oWA(G|oEdVZYc>GT&EeH$B^CuDIig^EKKS%I4d_f0N(d%ykfaz&LYpoSU+NJq
zi6;X#kPYT|ykW+@1LJuePxH|>N(eb;=D4&Zj8B1{E*I*Ky!zw^Z+HhnqCXy`4qadm
zurQX-xKB8Al7czPhVeGikq(kSITaY`a&;h_<4QWeFP_BHU7Ra{tr4)Iv!oKKfP-Pu
z2h&Z&1C#UunPogOe4ZrMMadWt2tj}^Sdx2z%z7shzqQX-zO`nxy9TE?TJ3Emzu~{j
zP8thK`ed#i41On~5%|%Fs3q`=4hIThJg4z2-p{UZbS0I`LCJFKiX0A=^zaCO7!fIO
zhLC62fagdYBwkC{X}K)`hMbv!sXwKsCxuawmP}MRkt>h^uak+4X!bP);&xc=7$P8t
z=tzA^;P+hzj^R0j$D=i^xkPd?(s*h+9sOe}Sdyt0iUwTbQTa$fWD{jU&8T3aqyS?L
zS;}@1@^)EJsvXQA0K4#5eq2bjJWU{3MVd+Wh)0;Np~xUMaU8H-!<>#s8c>rUV|qs-
zObWny<FSz-mO#bCvynT-G45EvZw<L@z_EjjRHlZiF%c=_v_y(FH4I)xr|lXDjsq~}
z@hF3Fm@6SCosQo1JS&}zpkYyx6tv+M6Yi6uiDx1W$>@N=tRSC*yR%WE%`mrklnvG1
zfb4Xbh%N&#Z@rPb^#jG?5dq_<`do|+1yQ#g8#9k_TZ8`Ej>Ak;^cuIx8Y+X02xg#4
znP}HFbgPXf^tF~zF=cCLNp^lT6V8L@3Lq4459EyaSoSJmjqwEm1WZ|cQo$e$s(++c
z!txbSmj$zZ;t@|O3t9;r<;-k3B0`yPbe$g<WA9RHhAkN)byn25nQ(ChtSJ-qxC7Q2
zk14}*l!3t?`w;E%C;)n^i|4Rnz<EH_3W`GtZ}bgOdVq@fSx?vW3NegFls-EgM#W^T
zAzPzL4FRn7*3c1RlCJ)yn@=c3_5_FrEMK!Z_)Flm1f*Zm9<>~8zfB}?0Un0uu%MzX
z+3=_}#A!PEFac8<k1QE142#FO0YE}C!W+O00jMK-kqON-4JxnUIHncP;Y$rWK(6p(
zST~pMh$3=@fdH%FcsfuRuLukCt<WQ&PqPt_cAW3x2_8IWGy|?w1}g(l0R(g$fI0wR
zSI9+HFA&O1c$foPH46=ZSS-7;70;=D5ZTT~ls-pLm3>bGSjZu6O5o4{fPDw6{GKCD
zQ?YtLOgQmmFBVhDD4zAOY>htvwbCgQt8?ja1!iS99+vr_T8*OKoL$|#<&bt@4nw7%
zFlV47@EjE!MyMO!JdBDkG6GUT4=H29@u%IHaK95s39=fg41TF|-!Z6wehqoOPX#js
zO-wZV)7c9dFl{QAU_KX+4f6moEFzZ`qiP=&y$7-ajmNf7VO=sXnQz!VFDvYTAX!FL
z9L0aB6=wAr$=35UX-@uhvf70Kw;6OZ6H|-~m6yPix1Za_3FF?R@`d1WyvMz&<PTY>
zguAevj<PYyc!Wjso<tBSibo`mbNcEU3r27zgWT45OvOp8-!Me~h)8j64+b1+QvKQn
z(5dwWx`sReDs`MQ6^~lG05@cl_pD(;#gPZA>iM_m*yM2z4?L_u1;x!gui!|~9Y?w|
z&POwW1o2=)ut7h*A+!p4^d`oNiL9V-=7I4wDh(H^&`|v0kP4zA{=5g_($Qv&HRTfZ
zTg1VKNIY;<joiSGQq^CBs&^4ABE0J+#+`9Fm5zX3ASjf<SmH?Oan#jj@A>?Ck7nSw
zqv0?ou~p!bxX={|#uaTk)`))PDx;iB0PYcgDFM7h9ZnGt$~rQRd?l=zr$Z9-)Kz0#
z={t1EY8-V0D&zecz&X;a&unrb!asexJW%Ce$j0Om&vA_;iqTv0)|yOTC7AnCY^(SK
z0Y_mfOgZ%;x`(vL4@fa#Q$lcENK-SD4U=lNwL!q0t@TJ?<mF!2E*c=sZj+$HJQ2jX
zQY%TkuBTPIn<|W->FrnmGxt|DvbHs0BO})^as;>pu}vq;0y71ik+U{`1hZ{}DS&Vh
z>NQCMoS)bx*L<cqMb%{w+=>hCCK0Lo#(j^Is?K+!?g(tB$@OQ}*SxrN{ipNbNgeQW
zZIWw5c;<EVv+IU?V8ux)vV=A_2_W*6t{k8i`u#@OEm+bmXM<@I$#G39tM<4@fC3Yy
zz|c)BX!AIyy?2MU|FWa*$c=HmK$zzZN#I8L<(uV}ZO%@FixQo9w(G@_V^TRJ%Wq{S
z4g3=9){$^Crq$6aTVX~QJ@lhLsy}^dT3c$=X4xg6-}R7R-!;r-a7sm(q5kEArYHkt
zNJmfi>uqTp|L|0a+HrR-Nwajv-Gwlh)ei{BpB1vtWh+Co)>7@wWpzxUW>F@q$5O3m
zN(Gsz-{YY^D;NCnvMSn&C8rZ2?5uwEqy95XP03MRzCywW)$S0nyH~=r>O6X0YwMR~
zYW9BYLjUMS38-_t?NJIafV%a3`OB4Ix3;C}d6@PYWdhQ83t9FZ&osgnOY3`WeH6+5
zP}BbKfPVi4H^gUU<q+M&cG|O3Y8uG9p=COW+*(N=2@zI^y_vcrR$9BB>6L}`E1zQt
zlo@CIVCkk1wzg{f4#x~=?ij#*JeQNEmy7@?wf(-`@XFgmqAW$Bbj2O~{H<g(Z^>Ey
zkUTBYFmH)ML>~W@AK-2P(2N3`oN>udhpK-_kcr@}H1Kr%fmS;Z{{_SwjKZ}bNdxG-
z20|C)%h%BI6C<L^V1EF=2OAT<1cytb&`ZcL0I1@=$D@ToX<@YS;Nn~GMfJ#t76+o{
z9v2G%(9crI;1C{{5)VF18$(FP0>BuyW_ZgKTyO>h*!PP&5di?;=M4g8U^*G(ISdwG
zL^+euQD_9Ngu9KK!+?Bvm>VZv1oEkaqOss7$#HlK0<ATPBMtxJ1|k`t)>iD{x3?vK
zsDVa@K|=zVw}wIDu%#5RlER77LSfve(Ca9B9^i)VX$*`508t3(82|`EmW+Po29^y#
zmuAo^7Gx2@U>-oZ6pfsi!h~QD?#F}g-OFRnz+uyvrCDsrD26mc<^ht-z&in;j|-QC
z$Lt#vuv!Qv5axniq*1sz?wYy0dvl1EDfGk~3if~_eYPuR+8|Kusv3CqD%f_V3J(1^
z2={oU$B_wA==C|CkOSNk)98?4WJn=Ay+p_50k=BX&I7#U2HNRh$W`#G=`?}B@hRpZ
zLi!Pkg`yIsXSf0U;fM7+KrnTVVFm`TaU*JmIJQcZ6R(2er)AhNU~?eo4W1q@dW@cs
zer1UBQlENob>Z|?QIo5W-g5(Q)lX0Tc!XJ(?zuD7Q{)7%nJxGN-bk9q@c;|zAQw+H
zss*uH$T7+Ty!B>B$Ic^`3IXEMy)^Kb8F+Ve1ipT6j4%aNDexwPjb;n`sJtBOY-BnX
ziF*n(BXSOdWz5H;W+ymfL7~0#3q>Ua0vlEGY}onPsv1gvaadd*3|s@313;yqCpEA|
z3G-Nh@O+00*cJn>R!<_`#}VnvXx#IOyoWq3=v*_<Umaw<150AT1lMuiBcKWSB?pe{
z;NpVx`n~P<UuXwCD{ls~c!BaQ#vF1&x;hr8xru^@aBg2^NAkYR4FYcnKF8u_tq5Q_
z<JFNh6u^Ap)hN2b16)`Izuy5n@Gs${MdZXQzLwYf&dglbz`ecmS{TPAy13YM<P9A6
zgom}*TnzTze{-oA9Bh2UNrH3?&v><J5b2Na2fgmBe$7dGVJiJ%mRF98h<ozu9l!J{
zinPjsTZM<LqH9)PpIHSctMAOg_0?6Z^y*sI>gwM293e{F>8l@tRyTRq-kYzzYJ9)G
z`W|@{TwZ;Tbpx?S-*cW_Tid(#IA~p(1;}W<7rwhbR>CFu+lD={w65I3yG;5ZbN0jH
z()tJkYM;eTfTE&X$8bKsJ{-;Xz@Pq6hJ;YBSqEA3aM*?l)W;n6(e~&z^`jfE9venY
z8%J@xX5c4}EqT}APdzNyJcSFgVf(%3^a=SiR<mw8CLm0PJ!8nc!gGf<e~!`Q&H*1&
z;_$-FGOy@-*O-`;G0cG{=!7R<I!buQK?G#9uE)a<$03jKNl+~|X>prE!AOA+r1{y+
zQ!Sf?+Ywnu<%75QbKSmP4*6Pm_N!Ozwyt$hNfCEi6Bk1TPdxn^2K!bN_l_QnyJ*30
z>kEpozXh~x){lR$r+zKw`+O~q|JE80FYe<_O~L)aT%%8Zq%~t*Yb8yjzYYceB&XMD
zkbY`veV*NV@>2i?SE>0aTf@!k&I!<!=Gi}A^8u&M{uBt|0YD@GYzdRL-W=VU+Ae7O
z;M?Ze&B^ToKnRja%mA8~RsM(eS@odaO7~~BzuRZUJeKWC<z3EruH-$;#CUBZ-)g`3
zz-hOhcdK=Y0LrP__@McC=SRhnD&vCdlE%{)oK85TzYc%h{__5Lj}tQc#mggR>byID
zZK!-w-q{jXa^(3%p*^$JyRKd@8W!IBpgA$C*2Tm-=5eF>+-LcMxtM_36O&nQaIRWU
z<HgD5*^<7kcD$L1fiKp4#_|!T`L5*Faa7mZ*UL&TEf{t09=qh58YES-f9s7<OYGQr
zb^qjdW2znpUfiiNSbflvCvx=g!v4hP{S}%ge*U0-d^vr}-=g?*$LF^bmv!E2Na=6B
zTOLWhTWoH&F4T6Z7bMyA{@5%~cmmn5Eie&tKc>!Q^OSGoGEfNKLME4sc=S@$&TRn-
zrEve0bbwRcl+YuLO<^&)Ep*wII23!lhff(9dYm`demzT`8)gY0kQ7`lFAvadD?nOq
zvD^OJhMgnV`VSlSiSX7T>A)))$MjcD9pn7I(F57ANlz&i-mOC~Dq=NoYc&D^uj)l2
z)S$k1*rGF8fIOSff66;3I$TUs1`p)Hz2+@(@Wr$?8voWx6m<J2&A$d|>9Em8BdXVh
z71(j?*Q)S5jt8(VZ^qA6?SANv!+O{+O?!F<ceFz`>?}Pm-(B_By!_+(^q`X1=a3CM
zPM(sdbfIo?SpArdzHgqTR(~t0^#PhXD(PV>a@f=`{T`g7NT59Uc8d(ZYCr74N&D-f
z@_h38Lp_rQ9E?nXefmq*IM>yk-7fZ1fd+hX`XP}52e!x7Al>)oO;BjJ#IlbkV<AHa
z-~$Wg$n(7zHXdy7;-Bra7QD$mDsOh^M^sci#tZH>Y+z)Nf|M~bdy;VqRRs^1y-4K2
zb$R|Lw+GLc91t7|JL}$+V8da@XZE}-aBI}4uR1RItL+J)1vv(_&h9~<kn0D4EpTCb
zR%Lm}Yo!`q4}u1Z?wRe|{WL^w!glr6wU&hNf7q}wo#D!E`pFS}B4c9_G=NC~cX=MH
zt`VqB2p5TIpYf*dJ-Qy@2J>oudLsBX10e(?)mVkW$A3oRBR_1`C3{M$dveU|cMmT}
zbrnN#6h#X%DL#=}%uQcMpjN!lpyZ|G!JFwphkU*%nEtV07xO3{@9GtUY}jRz7~%`l
zx|SSTZc0Md$1~57fh$6S2M10k_>nW-1{wOYZV9I6&%^M$y&q*+Tt9BImC#N8;)Ac5
zL>t^-T}5Tn2h_RUdA9tx5x_$>19P$&>2+}Iw+*`uW8ND$l%`3Owsmy}BYA4IAIIlt
zsSJQ_?KR-7hKwKV<+kA4-CWQUVugjJBFCc8?V|*|l%x$6mQf_uz>rcgPv@MIX62Dh
z`{sv}^~Hsp1qXDVt#dbX<duY?nj0{x#xO3!VVtlEWW)Z{VHeoa?4wZ_f=4Oicxj<x
z+s1RYEwGBDw5`Ru<86eT@z!Hs3nlNS*y&WY@W?Lm35AM2QbwaSjgihA`D9C#S9lgI
zL!0jcxmyvSV@P-MY~sTFKN4)IzL4@am}zA|rR4fAL)T(Q{W-pNKsM|hSw{r7<1vs8
zTX>6xxTG|YIZWz=#qP=F>W);hlrHjaFSc$7Ai>HR&iw8PT=IBo4LeUiNtnu;M6lBw
zv_BVg#>(cWX9;kfOuZSqgwmYPAn{PinZ{E!d|3@_MpB1`*Ho=Y1VZxLIL5I2mE0+5
zqP<8xKHj<(*zaR0#R-hjzbTx_=f7wlBEF-lYolJCm?5~wxFGq%2SBDm(aB0>I%Rgc
z!Omv4N5xIg^ZGLv-LiIj)*J7<<TZ22yTY^lsTHcR_HAu&{dwd9M$AmD2G}LvAaZ+&
z+ZfNfy4Pk8?1!ND&Doj8WSef{8{@gQ4?7zV-`PV!nfP=I&o<}S#Dogn^6A%~ZP_}O
z^){@8k*hLY%X6YHMxu_x>wfaAtZlAul+_--iQ}{F7i?m8@4V$Vdwup=Q&wzDgo*#d
z+1cwi`eOI)|L!LQ8Jc_XSgqWebY#kG$G}W3k$x-Sh5lUUSk`JwxrCL7WV+05vb|Uu
z7`U1|ck2o2J@LGgxsuv4A2OkvC<miz35H`h9gs5JCc)ok=eo2c-{a4YgE|XycehaS
z)RKxP6<1H-hkUSN3am^`XG>`fu#XrHqbes^GDZ61v-O;Da2;MAu+!2?;dTiBiTPf!
zRRVVcf&OKfig)(07vyYxDlj+SZ*XL9zR;H}+QtDM4GpXaXK7(L@)^_6b}O;8BF$ZD
zI~PAkNrGi7fi9``VA#7~yR7YYgvNmfBdF*PC;ChywK0aH5w`oPW~!g*-FR>>&UW?W
zlIbqvIbYvIbFWm6+Fby5CgwGYnYvx8<Wtv;F~BF&(u10pO?Y_!ShlXu`t5pY!MaK0
z!9+{7QIHGM%|bYI6YJLK$_U03(nymoduO-T-S|mg<2W94;$pfp45-;=e-x%gCn?g#
zG*{mf)0kn|+*Vj%Gl^t6zZ=TEM>M(mwsP@9HS^ulag2D<5dvL%zDio!bujm|+1|uB
zj)!0K_FE1EfbG^z88_h%Jm}KwY^IMi8-1Yj)1A2T>ePgzXlC+O<{f%Ef-#4CpbKOa
zy>YcZ`GhZL)9#1*$^8O#Pq`c{4{~T@^4P>Kz#c~O3<QgH>XvbK2Zyz^*9Qx$@EYC+
zM<W_b@Go+n>kJ&cubH;*^p}N~AD@36%Q8=Ti9WqzXLqx%tSjmKfw>izoI}%Re+Hg*
zc>G%H=(m|`UHgZ^56gaHADZuL1e<ht--g+lbdH=!zJ9|@X3yN<gU99v>UvJE?p|d*
z4!nAx>x-G}z~@vp$|9v(WN|IWF72t%-IRWVu6JDVY0L5!2Zv1_!7B#RUg+KZ`f}CE
ziNQ`=v9UNbd17(ng5BZQuik!DBL#hG$~pYj<PqP4xy8>n1`e<8zq^&X_+|0SUCfcS
zEQ_?KB2P9io?TwAxSRIE;K|o9&7ab|u*0vtpM0AeIP&@0-NUN~o_v3TIl9?rapc2^
zCqG`=LEp#SBcE?P`T0KQ=#S?XN59QI`SoSs=&w(AkN*1dWNQn<1O%BdIVN0}iGYGT
zo=j9Y6P?7w(3seACPy8Uvz^J+%jBMBzPa4Vv%%y;vOqx=PL9Q|%M!3=33{@G!db#e
zED;(@w45bY#}aR6N%XRY-!LVYS=%;P+mYRP!ER}}ZW-NfS?g{&&u;nfZiS?7MOwE~
zdAD+1w@Q1rYHzpNbhr9)x5h@dCbEZMs_{^uM_ac?$GS(?vu8^$yhlH&$AH#jSl(k)
z*P|`hBifp7e7n^oO+z#a3r1o0$LI0_RG#skwWm3&!_*;mkJZ~o+iC@0|6J>8EGfyl
z=5lK~U`ijf&ThWtgzO^=_PNXTdFb~2Fu|%B_O<k6?A@ece6x018}Y}V1;%snV8$Li
z)Fo)+d;1udk2XIA>4t@ikLQYGQQ^%<OG<x+kFC?1O&QS7(*r;D6yU-FydbE?l+?$=
zU_(@(*@nNt77$IxkJ|!7z+WymfPo3GggHgg4hGmlCX4vWfhe`SXiwolvhW@y<S0}D
zrj(5*QbQ}zwoJGiIa`mF9mPoJCIY}3ZOf9K6^e&NC?R9kko-Oa=~#F~F2-pPnM}?K
zTSHp{Sz=MNGE;Q?xSfH&ePBbzj(C*a3d)v()EY;4H)lsTWLS=)><m#sluQ9irqv3n
zdfFkd5*>lfz(oy24${Pk=wP25Tj<HXAvzk!3X7tN;gL~=4thOsTM(TPkJJJ&47v1B
zCA2pM852*lq&VGL2I@>9nK&khopoB0)(~z73}%Hj3_GWwQbcnS@D2b4v)2c`lRDI@
z>(m~e8D&T#86xf2C@l)q*Ee!=)cF>Y8fQw25=Al=9C#V&EV<E$2FHrRoP%UkQ?=cJ
z%ABw@R5-)=<5JdEf$_)=QCbv;xYs*s1v=US!=Xy|LqRkLm@Qz446=6#QbLAMGG`^7
z)uJ$#mFdoFSuqq$N-idto;{R+2Cyj06&GDD_#P!RZ-c$Qs4d{*x@QfUt%m%iL<1U(
z+!$_dfc>$gdy`4o&doG2pPUFfIx@UJI4XN5W$g1??2%C@w1U+K?6O2JXDg92sX4nw
zk>R3FPSk!}J^Ab{K#h#LtTrJi&%qVjhGMwS^*~RfbDDMCMa^#F46&(%Z2a?y`b>nO
z=w!WWhV0Hs`G`q{djvM8hGNAe$epfyZBn&wQf+2Z{rRNEr%6rJ6hUZ8OMXgQZ%W5z
zYD;(LlwQP?{{AV0tSQ5aDWm!+<7-nUeN(10Q)bVn%s)+8pr(mJ(<J$6OTB3;n`!Hv
z(|Jl+Hhl!w_-Xr!X@~l0$7|D0ebde}(=N}aT|Z5`p=QWJGw$*;9(pr7Y-T)n&g?{y
z9Fc%i_>51*jPHJ;PyNh`?s5N_8BWiPz)v#`r^bWt@ypilICxGc^fA_6Xf{HqEp;<D
zjqVX9ZxH@?a`_auFeP_U1{)KRYubz5JHr<raaRC8m#8<l&t@)Z=iL5?x#azG2eRf;
zD&`K>&mD}_unZ8}Q*jr`o;&hs?kH-WDm0%iKcAsDpJ_8s+c}>V;gc<&O~}O_E|T7w
z^UrlD$L_)Aq!0QK_U+6bG|95}pg+!yAY*rDH6EKWLXjU-L_9dY|G|l@2bC2MPS!uD
zy7u5y--GIz2h~#4Z2+2sEX;7h=Jw^<s9~*Wlldz?Sq$sA3T&BF?kE`(^%0fbjCmnJ
zy)yIg>hp(<pB^@$9yJR+YLS1`s`seP=25$if9RU;N3GtB=9wHOmFDv>Ki;pj;So)A
zaBat<u1}Bdq86A!3#^}h*MC0vj`zzT^wa1Qr9gI;{lgslfZWQ3^oE6FJVrSUlNmla
zG`#O?*@bbT#}o38Cx!fbTu#zaz)UQ5HUc}hvpPD#Vygb}!)uQp$@@>69XDrKZehj&
zo_H#oXYmOtXzA1ACwhy|T!Nkk1}*Cay*Rx1R48cWbkNJIi!Uk`m#zi9>swqc3VMHa
z@vT|V`s2lQR50{gcC3Fc-6yvLCY%y1Ob?F!)OzVo7YFkR2bKCWi~3_G_}9JQU+<m(
zXbOBW7-3HNAw<~<q@eb)w_GTgVhU^<1=~pBie$t4DaiY5jw5W$B897w0{)_KHUu2r
zpbGw?3jLxAdW8rlhY0Uo63q?~4+@buvn0|LBKcxz+w79$XF%-p625V1`?gT&&mnU9
zPvta1Wfqs@lSB9z<6@Pt48~K{>rYi1pQevLRbPFo)*q@d8>+<{25g4rXrB)yEQacA
z3)2mHrXTrC+x(fKMy}EIXZow5n%U1xUpzC4oV7qN7lh^vopP@5eb!rmxw9i{U}b^E
zzNg(5%){+f7`05=jr@2pT+cr|zau>SYu2&(<zAEJLDA)0u85^K%f~7)E5>L6Sxj+M
z#H!Qtfz9Q?Q_t1QvgOSpR#d{jeP7^#M!fV_B#INta6|QV2&lg9&wYYFc6%tE2;~t~
zmE0BOTvQdw%JOcW#B3jnA}?aTmu2=2^L!}0Xs8jYuHvb#yaS3VYHK?}S_~CsvaLaq
zw^f$2#eqPpiU6z9AiG=_qY6j8V`S4@AJQ>5;|gzLg{Nh%pCw&aEl^iEL`B(ESJz2h
z)d`A1Le>if85ceE02KufC>9B2BBA&r6pl0|gg}u;ZKYrh4TtU99UROL$jUevX@ryX
zW1tPl-7wF=c)uIzkb_Z51UbRSGSA&2GuXBw%qhy%>S%!VF<(;AkuW=dOM3oZCx2pj
zkWC=P?zo@zp4~elcbcc|w9Gnn*yQN0(w*k{E+&~fEOHJ8dDYMy8j2%N91e^mN4T4o
zcv}|Q>lS*E@+;GbB?tT~4_bJdok|Pv53~-p&^TqIRpexN*55AITBpED^XyLZa!+D@
zMnssK!ATd>Y<s=Zg82QeMyGttPn93udpga-Rlj0~MFB0+-Q6tP(U5*B^RSy)ft}`=
znk*jz!BJUhhmMvll=bX5ldPrY*>lbZign&)*mu>~LLp8l68a}3DznXXw2`8z0#z(H
zY>c2j-$Os@P&d{MH&hGLQ40S#1%slZ0~Z~}n^e`+ZM9T=5ALfl&@wVHB2Bf(K*`8Q
zH;L*B0S~W<98NjSzN5ai0I&3W;Nlp$eY=&Xdm_owP)6GSMzy-SvUje-@Dj@q<kvIP
zH(cq{Cz|fj)!J!qYri@q=tVw?LMb!+m+dqT>~p#VnM~4&eNehI&8hP;<%64M=AP)o
z@logLz9U)W?i8zQdA>KRtIk>|#pUIcT03fqN*RY4S0DCh+e^9_ZCV=|n0%g2h;^=t
zu&VOaJ!bD<2E{<#43F&E6>ug)D!@B0#rWnf{W@Q-fDpY?ce`1_!cLi)X#vJ1O-(H?
z?r>6q$@^0hzmEZ)rkOd^w*GqPh;s^aS2-9^Y)?!axxnXRQdpQIAL3a0kp0}-UMG<v
z7i?FY87=>|hZ{;Ru8zpR`L^|6W)u1MOan;l|5RMiT0e4v!)*{r5cm%luHxWTge7Y`
zpxTu|#Qigy=y+}SkN}V?+#d4JY@(C!6311okxT!$aK#lWzj=|7-<iPII5=|SuigS>
zaru-a_G9t%-`T{LhXQ)>um%&@G|?|h>d%EM`f{l2O4KwGkc8*Ji9b4_Y+`d5m#M#?
zx(AREHT=82?nZkBfAyzZf2lBPLghIJTbY4F=Ps+;HlN;jvpY|Ftmsav@0-OQ|E>C~
zcN#W72C~itZ+V_i{k&Fl>6qKyuAkrkMK%!&-MISCE?k|2ZOhKxmMdN2L(iielzp22
z>z$r(e%#LPr-ehE_RlQkR*=t%Oh5Zf6dMi=f^>6Xv5NdO>FDLsO`HS0jC=nFu-rvE
zI)d!!5&o<qAo<nv6O?S_7nR}1qhFki@=Bo+9nU`iz4!JjzqF3OAN}$)$BeHu-6Yaz
z+4{&+-?}qz9A42)GZg%SaU7+!E9cy#AC_w<qN+;k>5;>y>Ka2HQn)xTGNO~tTt|&m
z1!h#y8_qR)0st1=qEKPb^H&nGf!C9WG`yX^8wpsG0T>n=4#=^(RX`*h<}}XP)a6KT
z>s<5$<S;}su?0Zl>Ft>5d@4*82{>Fu(^82y;R$c9wt&QD1teNf0)S0wT)s@~ty+m~
znJmo(n(_R^xDH^NlL_nK?Tu;WICiSJ2jOsAwF~hW*bV&4`vj?%cV7mW%B)fTD;x2S
z>I+vq8Wpcmfg2&~x0gn)@(-8ZC%+peBki}A)vR0$Hj-?1xH(NW?o737CtZ2!n@-ZZ
z+sSETaMX<cz<fw_zm?^QWi>AFj=FnSAc>q_7=Ko92&%W;O64C*5@|NDihc8Fe3sxH
zF0~tHc7;y}u)oM>f}Bt%FHLg7m~7Nzwb<F?2+*aE<9V#!Gfp9Dd-J{X+hA`t0KD@Y
zx&i<mn+|HITsj_b-+&}c*f?l;B{*r{qdpz3p%vbUz^_CjAl{lZiWs?V{TZMz;Ru__
zOd?C7j+-=R6%5MV=L;`dIejG%e2SbnV`ydKS?<`Ty%6`1cxOO+946W<)JBL;AH*HQ
zyU0@HgZ9I=6ASUMLT?fcS+D^EgoSe1Q#4&t{)2q{6IJZ)Qs|FX*rLdZYN8>QstzM&
zAv&qNaA^<&Ct_NAqyfhG4RObNzS`6!j;*YkO#4kZP;Hr8zA(`Ji35q51b~<3qH4SD
zIOdGW)(}TwK*E}3(qjZ*n2R&|B1X%B=Sk^zDbb^oT=9_P@Mke@AOve&fLY%TBwB-e
zR@SB0bP5?URDFO}BtJyFx432q-tA1lw-|<6;VBL2jB)%iYb*-+VW160Ey_YLb;0H?
zd;aAk)pGWVxJ2$q8lUtO_)uQtJRQy{2hLHJN%_yMv#g(rV{rX~Vv{53o-#rw0HWH)
zCL)4&xnOc7urJ@CB<)je7P2$joVym0nzCa%RGq7h)b5DgYlW9aN&{y~?!{(|;hC1t
ziSxcCMDu()%1F+tKXR+YlMsggRh?U&Xw#0MxQil;6iI#{j9XM%y2WWw*Kp2R(t6DO
zNx_PdR05A#Vu^_Lx93Dqg)R*)SD{jfw?O_o=>hxj?&Y#t<Q;?Q<4kM!-df`77stdP
z+5Ga<=r@IZ@Pp=Vcy+T}+`J*(l})MU`Wj72q4K<xN{B0Ij_C5E+@uWeZ9vf{EI2~#
z(!=?H53=?y82CAF8LO)If>=*JkxQh;Ptv_DSlRtXpqM050;@#QPML5{Un|3Nieh!+
zQ+!z3*QA>bx4rDjxk=!q6(XTWKh4r$l$^Eb23}bdHa>*}C^0qX6rTk|(ed2Y1%pJF
z6@cxRw?#QFMdk^Lz?9DKirRa_4Nl#)y@Q~(TNpU6jvc2*+NOJIH=#muOv{XIx;RCo
z?}#=Mb9KDmmF_?wm-2UA8!;o^AB*C9<;TCBpDh0EV<SN~*Zk1yg;PBH@F%L9h;l~Y
zu$DE3&jw4lVF(Jx<A4ZtdlkYSa38Uv;5mw^-&N^}(AbH05Jf-lo$v#=D@8cRa~vH^
z=<<TJi^p~j5)6MhXVN_IoM!gcfn4n!<~j(u+;yUl^V7`DnNF=y(zldRdJAXoX^|A7
zaoN|q+pKFiUN5&q34H6;fKy={&$C|S-Ud@uIL~4x6dml9>OUyU!L_nfw}3UClDC>$
zkT){hGRB*3s6e|f_>8cN#~$=a`GU9g!V(5^i*|DMBGZyuBKTS@(qpbppwruxFriiY
zn&C%}3#j<<B;F$;*n1LJulU*22Fj)$!ZRt^bue&urahOWoa42IcW*(>u_o!u^XZL>
z8M}auDm;Bqq>bF$m?H`7d}xVn=ES#4J%1gIkbRkl3@w_txZ4XL9)AL+7>$qseixmI
zE7W9a?9maQm@HiLHU-UhV${7^bg%Yf-{kmtQbYELS9S&-mI0%0#p%*$o$6my#>Ci<
zP($LmGR<-CeCvGhyEO`P58wJ|B>9+?m3uW#>O}U9-nQc1dFPF~5{l!ZuIFv3emy;Y
zx%9<{`qGVc!!%+9cV$a}{Cn-r`ycmxJinqV14AFOK2nU6+BDEuzveiJvrLjLOnLb<
z{VS;}m*-cvTrFqIH*4M)T%+R4F7nawNuCU4ov_n~IM;9HNNL}pi8{X9F80+)`(ml@
zws59UXZExXFR+#!NKEDB(EnTv>YbpW!z>&Yf4v27?(@ax-OV*B90qTRSg*DV=RMbi
zf6g$~Upu<xw9I39FeB=*%&S6dHHII>R$pG>h&B^-_X)|a?vmMcSJv7f?t5mTxy(h8
zJh`JhrOs7G8~U#fIvVa#8rSK4lif5J;Gq38hQID(q4(hYxiR{)TT(I(4P9GAXEjhS
z^Cxp4tA*4XN8f0oeE~bSEtYKYKex;Ji5fBk`m0tls*R<a4UW1UI0&ZO?NX$k+7CXn
z4i?0jO(`Bglu&plOg2w|*9>qDdS2PHppbn8x+NXK;x;}{-S9qYL`p%C(s)@EE>?!%
zQU*Xo7=@Uq<nn9V<MgonDan~4Et%>inev1Dp9jFxB7fD_&7~uR$beD~?SRZa(OQHB
z1!hKpDXq|au=qd*jB^~8M4<W_N+0+H+H6AB0z3x;Bg4cbGBZPzq$!`3nkjp^*(hHk
zM>s%>YrrQM;-p3RkL=6Fcwmt%U>6-5%Eo9DvQw3mXj@UZ8n%#?5*TR1ui%l#!vdlh
z93BKr!F+Clr4`qDZkl`8?h^DdGM6<7=VRtFd=wg~V4b0~3>jSmqVa2CO-hO_DNvgo
z{tgysOMyjFv6N=?%@o=5hR{E*(qTgtcM#))=i0%}*6sE~v~XXJl&=JFjUC{pDZyq6
zIFiDjkqf?D5tugwIj9&i1G$$O9x%y$O9@A=EJl_BUJT4`CQ8ImHrC^q*?Pen5*=uU
ztQbgJ0&>Al_B@`>8^X1*l$d`4!53fR{DFQ>JC73<07h>Ye;}UoNn)&npZ{yg1g`WX
zJQ5wvuPBB)(pG$E-CR4b)U&2kW$TrI>`=}VAAZef{wr&W`bOn@*2`4V)$|<7$vC=Q
zM;U)eId4h1Uv0UkFW5l9nK|&2jrgAdI1k?niZcI_A<q9RPIWCb<bkxSvV^>t=ok9&
zftKUy(kEIbjvGvr7VCp5a}n_mPI$FA0AK;t7ZfB{p3*JGwKxc}vBdxvwNoVX)rnHE
zXa({~g9P|{!pTA{k^b?M{||fb8P(*XuI;{Q5E24!LXl2Fk&ZzuNHd{#0@7<}0*VTP
zf`FRPyP=9SLsNQ}4u&F4K)?<bQ0xtyc2K_8Ip<kx?Y-AoV~;b=IKK{m7{H+A2Ryl+
z`?>D2Q?_utm>Qms+YSfSXxwLCIGde&p-nbx8QcRF3s8%=?J)b-vE1v}S$2`^3J<v*
zo&o?HE&T8>EY7Dyh+53c<kMjmclUrdl)(APV%$oxxagj8Qc*=W_<{&VT>z(2!PzYs
zut@<QFz_!<;h_eAo93nbKBYyz2<2tIZ!K_3QjsFQ3~R?f%>%r;pU-8-$ECsdFt`k^
z!FQbu!qdQ~2w)cEN3<5BU}xXEmXdRwzSV*gN}%5>@JB89v<LJ&#s8XvgZHup@w~h%
zycbS^MznH1*u|oq7n8>XUrmDTfFv+ij$1FsP<fE+{5TjJO{&7S7UO=fc`*Ra4SdH_
z$xW(c$y|I70QdLduW>4QS1J+nI5rE{NC%JI2cOX{acf+Hhm|QVf@+v@wJ%mSKs7I^
zx+o5reUjjz3^ud)(A0Cn<$Pxjv61Cfa8fw}hU8+_B)?`K-|7V;egvoh{76#mQV{sL
zvRW?<>{J3BqXp8G!HbJE(xl3B+6tjN_tdvwnokKlQ>tr9!=KoxsXA2s2YBgzXuWcF
z5m$LVe5k%znNTgJAfZGcObQ~H@RGIqW98VHng&O^q*<}X{diQ4gF65u0d&KK-bVO(
zKEWq)9E>Uz#GV&4CQLM{m<v6s1K%ivcMgG{RzYG))A5}RsjwzKW&qC+_7BtMqrS~0
zOk>ey@aOAhE_b}(q0<k}N26j|Di)h?umFAy%iGD#d@-#cH8LW(Rbr|27Eg<mc$*Nc
zP3BGOLlL~3dz*Yr8#cR5d86&yiVZiZ-Py_h+tzK?m_a*P<udcjS=^ozlqIk;*H<UK
zsj~9y!b$KTm;C#^;1ngo_&QPjuz*Rlz#R<pfD`C?9Xw+SR^-#?#IB%rUJ1o_3c;A@
z@)P<howG%IA1Q#(!kyq@O~FXu&YCfnb_AZS6M{`%(1_!Q;p&q+;H}Z850m_{+l~fh
zCNFho)hoST>&{tf%XRNTWOo-7_p~rgik5oHHj++KK#R4WDlER*zSk$Nr$)T7uCI4$
zvA0RQuT4DZ4~@QjY#+Z5cF`Vi4es+v>Ep9Q>N8*>p@_l5xtt{sv&I$42DDE0OJC^c
zZG|P!xE<GEKe-3EH&CZoSPF-$aI0oO$GOki2PHw_aR=ZlDuby8gFcHw*kxET8)eNJ
zc$?ltT}GV+fRk&<UoD%lb3i2nsoOHRm7cKB2jT$u<u#-qox>fHz|#PV)6vz-ND}=j
zK7+F-4Cc&1hLYi8{X<t5xnkzH4T!^X(~S;nnCTkKl02-UTDOY^-_ww+xfv-?GBR;}
z<Yn)OK5sTfV)S!LkD=A*p0D`Av{Cq}QLFxBo6XUyD%Y-xU2}-N=2CLat^b<GgKI^>
z*Ss1=d^TJCJjM>jjs=yB9qJ$R;T{X|*mZ0(X;plD&%W`9&FqsU3X%QevD4wFb@PsH
zjz<wD;zAS>JSI{~CepSxdy@Mn0v9H-JhrnWCi6Td3t}e=OD2o@Cuw^pOQz+@HYY1|
zr>Z=rF2zor6Q8P?mZ|HXl3AE)lDJ;Md%dln)ZuYm^!WAeSW<8Qb)kjpgSsS+#Pq1g
z^jPflM9H-G&grQV;`D=Q?vK-Rx-+*tX0}K(cX)~SN@jkw&ODfwezZCB13&xZA5|Et
zsc)bvjLq3Ki5nkvZ+!B&@g?@gw~`w_`fqGLxbbWA1|T^H*PBCn&T*ZdLzm8B2IhDN
zWFqd*{b(%*)kwm-=Dimhgfpey1mI_a6ay~Im#xoP_6vz<ED(=KOPyL!9#~L)xBz>C
zAxqvIdbzN<H4ksCK>=%+X39;N!LFLneBDxsy0-H?<vj5DOjRsU*m8^dQ&a^|R&Rqh
z_sAYF4EwT+2jG<aR012*Zd*ST*<px7`^Zx7YqRa|VAgj!E7ij7FgXmqke|1k$}tU;
zb3DpmP^LAMPe%H%e!B7_n0zh+e8+#PrjhPc$%1v{TohH3ryS|bbL%_%7L-#=93W)9
z6DaJxm#zn{e7jZe2C9ElPXyCz7`Mxp`2o(Imkd5i^!<z#nL@F=QfqK#O?m9X{S&2N
zA(@Aw2G&WY=HiyJU@{HMG6{wEqXxDGsLe;80@-nxH_Nw+$zUN3hamBc&WK!FfY)vL
z%DQVJ>a}lS@aYe``6$-+;Ok3EnNmnFeX;ZwqWsaj0V&M^zE7Tye|VPfVIST;@EDL<
zhU+gQy_UJoEThYoF@wvzkCyp<ErU`k1pO63uNC1lD<WkpVuLFZk5;69tq`T2$ml<j
z^Ln!V%oD}3C(46QR3AN2|Mi3{^_v9$M#8hpr(&OK4?fj>)V=S~Q;O88f&QwI*Q&{x
zRkN~Hi@{Z^N2@l!R%uet?Dd~Hcs+AE^US5}*_`;I+oNY*zn;;hp8GzU<JWtxxc>NH
z*>f-EbCt3>;V_qgqhOdm7%qh`p}kP>yn@H`_#EyOTzMb^dwHmdaAsDZkp0kpYbdWW
zV?M;j#&1N?KR5?9|56HePln0=*du)DJ3;(3^sn>P`6RsD$9aK)SEW>?3@7|t060+G
zLB`*|74lk_B+r(@UlteYD!b8k1|KyGDoJYE^|-s$y+l*h6<4zJZ07o;L>i$-MDL{@
zb(VkSu|(SQmBP2VXP(cM5grVQcs&$OX(Hqhc^=!~SJc55UU+!R`?rtYzyI}qP3pr(
z{STkKK72Xz;oGD4x#aiXAAR_x|KZu-yH=IQvO|wp25TgrwbJr6;?Nq%T*IuaiICQ1
zVe9=q>kMj%8grd{XkF5BeQaf2t9)@U?4y#;M{ph|5LSfqS(o`hQ1-^lgz?|narV|7
zoCu6x@Q*p!-TP(r_=Q!k5(>@`#k}!UY3a)hu<*U0&SQ}_BEkA9!B$#u{|?Z6$K?Z$
z!F!FuIs;N810sqa2tH?9{mx2Ro|S&}>$Q&0{rzE|4!3^xvipLz|8yAt`6cPA({PEg
z?N>fL_)iKCKop+wH-(4zI|SnYVF-XwICS?9p>T+ULrfe(^N;}G^E4Oa2KWmK|5aBV
z;#Uf>`0a955d4LxF;v|G`2e81e>LR;DoXas3N!_IYc(Z@6wB*SxlFC^2dEmx#@0Yx
z#ZgY)91;fX-03X8-CSA8_C!c4BXU%Gr{D6sucxERe*WB$ku`;`{1p_ex69c0?k%w(
z$53`3f>5uSxi+K_Fxh)tQOUB{^>L2Vt=&7k+^FX=?Ps!SH#ODVo%GXWrLA}DFyF1>
zeJt>@B#Gi;kfNdLdO$xu=0uU7@p%%_L|n|+%Ondr(>J!*b>4aLxOts{#xXksXjb+&
zx715@=})#Bh2#O2TBji14G9KpcP2t;INoAJUnOLpx?djcKHKdX<Q3Sz{g^DtF~fY`
zSS8YaPh!;ZJomlXW>#7|RICd;=ab^I%}owP*w&sl7>uEH7#nK^=~nDFq(W)|XU)v5
zM_kbLf1F((eSiK1ulr{#`)E36Pg!&%8jq6|Tp`ndpy*zRK?ekSLPh~!dSs@{xW10}
zVau|E`^!vqjzfg{SwHryWBae$+(-56AgMsC4hIqvXexO^dl74`{0Q9+TdTvC`X^Q8
z9dhyughlLcxAJ+K9fUZwx3^vFsr22u&Hc>tw(g@Ydwzfn1T>Xo$SY9k{X$oF$HShT
z4LJ&3C7P##^$*$}b2Vm!9*t*bszYjl&3Raj>qp2R5aJSXI4CYIKIX>_01^h^c=yaV
zD;Zd+L)L+e)Iw(~PskGxas0@I3*}Rn@E6N39duHLGy^1Qmq?Ga8kVJ%4msYVJR-Q1
zYN#E5raIV{4e8#l1pUlAy}honIowY@_4sxOnh%d~-j4DX##kDe7)R1w2iXpgKOikV
zZl4|n5&-zxC>okjcJ0`k6eND@;q$U2tDP!_6E|)fs+Z<7j!ib$Cmpe9X=x1)sroP_
zWoe`LY-I21>JtdQXT*<_)$QM1SAq~c<O%qX6kaG(Wa!`MgWIZy@MO~xZ4^D>`oC(=
z;13m9m*)O2eelgo%Jx}i>m7Bs>s|gVq$cGh%0>~Zd^+m?E|GDn(2fsSn)=fo+^2F=
zLf2UEPkS&{I3%2W1Cs<%`2IrEmH5-5mSxjxLeH+dRQmodkqNv}wEs`-*@L-DzqM!D
z>nRhBe%H%9wM{0+JARkQ6jydV;@}tgZ2DiVJ^62i)V;s8XNYC?KMetodfPv~yjlM*
zhJdqjhjKQDm+Vuzf8Ce=6}F4YK%R6wX9Nhl(8!oGyG8@|?}D^v&hlFK6`YLCR+21T
z(K*QmdNm>`5(Od-r0tg=LjYLbEu5q}ruZ~t*Bz*kTI+eu(=6RDe;ESgvhMKKdYx4!
z?aRqA*>j;H#m3~7M5_I7?U^pgr+UvcHMQDa5@0_&ZyM~vx?rYZ{``PXR?j6Hd0?4Z
z0-g?K6-nLa$>s*;=wRulP{L)3cxb{Zn>*|-i#sLB+`IVL?6V-Z+@p@Qu`H9t3uSJn
zIl*QZ?FC;`Do;AR4!Lkhd0s$qomgO)c4q4qJfAx=`jy#b^*j|%HHO1W-lkb14Kqw|
zfC^dQ*W+6xyQ69C&3q0GJb+*{t9_2J+F)2)r;V={!ne-JA$?j{LVTxM-cVK-iQq-_
z_w3XwuXiFpP}YvSy{;<bt4c57R$Ji~{zec?q4@l0l?1w^1oMYcvauhaX%oX4K|7Yu
zjq-{M9xA7HV<|+EQONp9+++H<oWBH?(XtAs2TtSdP(TIhp+)=DYMCl1yAxZ5D$fFb
z(z+gLcfbK-uPRsm!w(c_q74zTi4=(_d&_2E)b0&sFTnX6?|N5;hCRq_%`F7@!x;+B
zJ9c$ayaWXI0+CleK{+65%N&$@Ft0pE-1)V4{5}tKPrDejEuy6?8N14J$3ynk2TC?J
zqGbkPE72TIg@28QE*%Dpuvwn~4jy6mX1y0kXv7Wy4wAd5C+eScviG{XgL?}5sGyXj
zW>p_$O9}}W>*N=Vm-S`CIQ=+M=`O?MsMTnLQN%JDAfk=NDT6AjhIb8sWmDdW6uWT>
zR3K@FISa5&<R8VKV~GM)^rJsO1VBoG#H@~V0(6(N1Q5A2c#V)>1nyHDBK0FOeYoNH
z0&)B0YI1EB(O@mU2lJ5%D3&L{d4?$t(35N!JK?eAW6Bhb^)8GrQ58u+i`XUY41tke
z`IX+=LdIdZ7JZ0BGotu3jcXfM=po0@;TB{LGAS>Fxbu?$fWae`Ec~&=C?m|LJbh*V
za~So-;@7>3EQ3NIo=iw71;WU{Tgr)81V98R+&7d)qwg+FUM7AsKw(w|a_bxlg<U`r
zZy?X}k4A!7W-Micxpb6h7SEYE#I6V*;)`}1(r##v37o+?eH@N!R%E@qO$0-<ybb*K
zX)(X8hXX0hF(f>tt|ur5wa!Qksnk|crA6=dpZE?j17=H3LgLzx$k<&tev^dJ{`5q1
z2nC4Kp2aK6O^8(lums=kr0z?wo9v_*#z&CA1Whw+h6#wSP$AV(j3xYCwzxbQRFo#e
z%V2bEB=*h`;{MfwLil&qTNtNYSX8=V3}AS|iQ!EzheNwv!Q`ZOJdZ8mLmpwaFL)9v
z99cfk!Onp=2RmL3Gp6jq*Oat9_Qa!<Ti^Ijk~Jjaazv__S4KH@@d@p=OQ}P`a$2DL
zTw5BCkeLIj0?C{s1OkPxUz`lR%?v$Cw9WIeQ97m5GXJrhU>+x(uov_v_{YLe$-Lst
z(PerJaR-3~eO9iZ@+}54-^%PqApnH7W};uo8h}~_AZ6z*BB^jh-`+l@*#upz2aHhk
z%~{QG4iBFMdJn9H3#b9}+crnwDyE<_dNlphTP6`;yD_(T%g?~WocYN?s)=9|_mc%x
zz~eBhrKjQ&MP$NzUp?t=g^~gF9*nd_bjRb*<N8C;?lHz5%t9)NyUwN@+_<Yuk8f1W
zK!{`|jxi&)0dc^n)WPdcOnN*nT=G2;K<Xxx96P68Dfu03YzGulqkp1+$7w+<-KmdP
z-#1ovAcqt5;uiX%6H@%7-{8B|Nhtr@`B;<znn`EV*6W3-30ecwnL`+P{aOPLEw1$2
z=ZU)&)c~!qRM}X@n5}sHLFh?8?5RjNawzUY#Izqk|4I~DxG7Q=0>)kY=8JBnR+p7L
zovUG2+3Yb(gUJ7iq`ju%f<QKm(zipPYRf?)eM)|erVp^+5UPaGWmv14hcIFmA}qiD
zbqGsu>DUY+)dIfbd7usgxFOyyT`PxsnHW+yB3bTPo-qxMh5{P-z713pMHYs0J+Qoq
zGpWrGX&8LtMH;+tgJ2NkTK|pagrW#x?V+?ms#k#HLitB`mfya*{R2nMP$@^=B(k#Z
z#UDCRtHQqIrMYqLrqlWiXmG?};QPUOsg#_9Eg`raf;VL^P`@9_6uMWA<qh`7zTFHD
zj_7*6_~pIXz#olbL+iz|D?huS5*dkb-DlKO{S!g5ZJ}pl61tEV8r@VQ5W_kCJhZkb
z!|mJ1SM7`p`4pmTcpv48i;rT;w;bceRh9D!)ctYqBzSNt;PH&u6Z5=b$fJfbyR(~<
zR-N|M{SdCuNEMJ9&7glb%J?!G7yIEQbPcu?&F56(UP_ce7aP6=-!LOi6GI)*g{Y5@
z(j>y(a*>+qMd9rCXMPf`rOlQEKA!x1`{9c?*SJKbC$4dgqKVu-iCO%^4rzs?N63Bk
zPT07p^kwFeCJ{(zsf&+%=d)&dX2K%T3*4?!#T9Ffe$L~2+$(F}qXOyE?z`W}jIN1(
zI5Pi@qU;IYAQ<sx?wD}n-uYxsz{uy?6J3MY9kIZK{TD8uRYH&xIBU`GT%teWI&<Ej
zS<`=gM8S-YIv2Dmy~=g%yxG=!(X%XxlgP)@+?<C#JGODQA>Uy-20r1A)5i4@a+FI(
zQ{L<ch4^M_c<^Tc4stLVv^@`&?AF(b#NWFN7FHeR#-AMd?B;fY!9`-iQoxnKFcC$N
zGRJ_goB>#8-X;q>3Yo&A%uquPYk_WX67mEJXnqkVKvEr4@Bmo)CA-0wGKLdR!CrE-
z|62T>r}0vD^!=aASGo>k@cQT)@Y+JShBG*sk0ca;4oRR*5QwY64v%wvybK;N1Boti
zj&`UE2T)of1kD;S{%#U_K4@OSh6k3sohtOu5dSn%V5VIlW&$66&*Y$1%4^e<qzQ@f
zu#_|x39u_AYpYw_P(<nbddkYs(L52QIl83k$<&e>Fq1Cwq8x0$lUfxdq|OeJ)<~;P
zky33D?Jy-Ye*?p5__HoxU3Xe{VS2BNY`K}N3IoXz$vE1U{&_wKS7AIlfe&VH)5E80
z*@fd*GWOW>qNz5MP$6|qdO>04gKlAeF!iB`q{FtX)d`_*PFXMS356~TPE3IB6u}RL
zS^L)EJBPW?&O^SV^pD-=&fw2&))1`M&aF*=--)c$p#*^;;>&{=!pb?Wo|KB`0^VVu
z_dJ@f793b(iM=AgE`z9^Y~lsMA0jz&Jz(%$x^h^yyb?>cC&z;-@R^K*3aLMniH-z}
z)|Mzn*_CjL46cBD>fZ%FrKBS5kbA?hND@|eo$DAGv=Yr@RvEu(;Y0Z3VVQ765)Uw!
zi>1QlDEP=0u%8U}bFc@9Ahf!^O9XE~XP5H@v|#yi=w81^Qs;XrTq9K~8+RGxqnzi1
zXQR>h0zOh9lF7?EpNASkkDe&t8N+hI3&KR@g8}YP+Ie2)c@iFr%;tW;&W~iF-_kIM
z^?W(7U=RSFv5Vj<xKA{&LJ6E)!=zj&;tDI+Qn=u6Zu@EPg~P+V&ie=@llcHWw3U;u
z&XMPaAy7(%o!|4}u+mBMLUb5z&J|4C7dKd|1lb7QDDpu~);G4Qz)5npghmM*R@g!V
zuZMz<So|O6im>x#7-liNyqFswKY5e6#3NV81I%;4aK^b}*AiC>4#8vt96kWN2!xh$
zuV6b*fqaJw@frn?q3Wlo{F$9tL~B`quwXL_&1RvHVce07LYzhgn+ys^UkpA~aDY{S
zpkj9@f+LK|uVmgmMU~<hxm^rM^-}fJ419hcZ<dO`^eP`WUk18?hl9a=ECkZ00^w7=
zA0rpcQEnK{P@|S0VTIDL(n~x*<XROxj2}Hzg@Tm_6;&q%@!f}fB+8(JHW-N^xV#1<
zi!RHH7Fbi*a8k|r?kv;_-+Mr?;1rm?r3_{sx{!{kMUZOmqq+BJ!k|LxP^gglkPuJc
z>C)H5)uwn};kqzaN9%yPx+zda9wZWwjsToWORpD`$DG>c@X`57Z#_EOuo1)99Iq$3
z)?HO-C@o3`7!7gV4P(9AU)=k<kouNe<DKZnd(i~j^F*D?sJ;j%R1IaN7d&BvdRo*N
zr4YwsXMa-xJZkK**$&Eb0Y?*?vZ5lVO&b7;n$k<~=b`48t-GR_b=+aLO;=8`4}tq4
z5`n`>+bQOjEqcZl;MHjGz?CF!CJW)i#Py}z;~bZpQ0Hpp${%q<<27BiS|y8jl^Cjg
z%}Z1{+~^Yos&8vYZY7H;A8yy~Yu8<B*WYNTh<6z1bQsmwC8Y_expr9ebyzKR*lcvr
z#INM;%dmI9;uLemrTB_l-xZIgD_$E{=;EEeI-UMHB(!^HP;uv>zRr-P&Zj;ZN5#92
z>vTo9cb$ysiYo4kR*_BZ?mDy4#Srg~)9Frd?@o&8PATqAdm|y;)19@^%@Xg)(do%^
z?<t7sDJ<?O>gy@_P2qdk;=L6*y;bhLmtuNrihCgh->}r%w9(rFQFxuc4)?y!n7;1f
zzTUpR{-wUbB_ic(->^>qsC)ldO#ei2|5RW9^iu!qM*p1nz=F=eE%$*tF$4FC2NwGV
z9xM$!+89{g5+8h`Gq~zL_&jFtW%1zazQMOkgYU1m4{Z#7)Vcb}{py#PtKW*R{#fb{
z?7LbyfA!afC@?LvF3#bK<)BMA7zqvR1A%=pg51Mk?rl!`I&p(cY&07x$u>FY+a?ww
zV)_Fld4RH;L)&AA6-$PdGYBL`j*70R2q(kh`*0v0{?rwJ0S(krMgp@tgh>1dDi0TF
zR5w;|7hT;gZxn8abRJbAQ4mh4Fuqs3@91Dp%SaCqbaNfmqaNZ}QOI0N6+NZX-YrdH
zU)ZY(>Zn%Tr|?t|L4#fal-0-&G-k2|eVq(BW<U=(W<vvf*TY-dGJe(yjBXu4QhB~?
z1%X#N*C-@zo>nvfOy)Ki^YQ>2^E}7N!?R?5R4WeNIsuTeFV}DY>zbCvxQbOKK*!KR
zC-YRn9A3bi#JvlI8*^AR)?{Z0SpE%b@PHq&K86^=Wlan0n&V;9u4D1n0nQXWY!Y3*
zEpKiD4J$bmJH6LVQ8pnXrr|umK3B@lDM|%v=`&JAm|6;tQNze0uOMk|25q;~NfZxV
zwtoqlDc_up%;w_sOw{Otu$dbXE7izGk@p}Db9ye$&Vd&va(ZKqpf@k*IWMf%)fF`_
zX5CfSKQHxjo+!B>qqiXExv>58f@1046kh%30z~0=>fPM6b!1r5^QKnmP3?i3x({#a
z|GY_&yk*cx*sFKT<n%4G(pwe-x2VCQRzGjiByZd6-FEQ2?R5IKOX+R5f!iJrZ+rc`
zO_#jmt9QrW^UlH3cY;dq92&S2^6<{lpLaqf@7~4F;|Ij~)b2*<T|H514u;)@uiQm3
z^OLe`9{1hlC*3<R3TnE8%etT<ICLct%*+I%gEP69_YfNQvt|ga(*C3wVeW<d8G87_
zMu7_J{);&L22rM~4y?_@JE(w{8^KmJ!dS>)^J)At+>U_H=7MD!z^0Jv!jFoVxHN`>
z?1n|=?>*}W8J+`Unc&1j5Wa+uTG*wwG9>+W?uIoe;r$u;@Ev~TCwOBZSN|vHRHooP
zT`;`p(R)cj<DZW{>OJlWThci^^(ARSi8QU*`1teuBUS1&<;i0SlV$zn$C2~1{(2*m
zX8El{%T$>u!^6wd%w+&rezZ~^PhDC5ugnz%G1nwmG8BWR`?z>`9`N#Zr29B~)15rM
z9DV)VJiQ!z{ahU!&FMZ)zJBiR9(E9yb#k`w^Y`%ab#->Jc6Fn<xY~GlIygF6czHWH
zI$7G;8wVWp@bh=`^LO{AJJWq!ef?Z~eBJC1n0k3TczQV<a4>UrvGVjf;O1`U<ZR{P
z>FDfYbHKse!4dkhp0+eYcMp3A0DE}aySdxb?2J7;?VMe${R2D#4tmjjp`Xps%iGz>
z+1lJf&)wsI{Q)x<SKCAW<=%AYySTWz**Z9xL;g)ScbeS+lLHQ>_70}13eLWM9tQ)x
zeEeKZ&9rHDCT8Y3o}LG6?Tnn9ZCqSw<`%k;zZK%j2OP~@-ED#o(F23LA%UrnkE@rL
zldr#<EzKB8gS)uc+S!{rI9j@UI5@djxp~+^WEx6tLvR|x(vHp+5Tdp}V6LQKn|QW@
zNHl^}wvJBLXQE0>O!vvjS%e%pNV7Nc3vh!ls*jJeudj=@x1*xGEyS=rJsqHSbWcx5
zDESPb>jMWYps2Hgf)$i@R#$Kmm(&vw*v*W&sI&8+=1vPMlNc3cdqeGG+4eV`_9yS!
z;SJSUdl}}O3NP5BOh2$Y(_%-ggqWe9R;jg4w7R-!T<pb2vo@N&X`<D&LXSH%JHs0K
zhiLu&{mRFZjHW{LFH;P40)5;{T$bgCHpz}dP-yv(MR8@i0u)zHO+I(Rw*J>G6sKbM
zLbLeO0SQS-$1Haa<3Q)uLoPF`eFnN@h(@11ebU1;u(hp2U&rg{k$9*h1ER%{Rkkoz
z!`kw&t;w!v&vWs|c3(bcrzIP>{PO+qwNWoib*hD`vy(@FO&A1d4+Ta#*o83zB@P9|
z9dS8vC^*{AZhyF4dPsmp<UvZ%!59zMD1YB*XUAiw=^pN`;Xa-W7pD^tJ!Se^1v{&I
zdm8(AAEnzV1la|+9<X(F_VA^j40H*hdqw)VdLDL_4i1X&_hou}htuu-1N@GM`zm`n
zcpmf*cd)Y!3^?^4nX9lKE+XN7R<^ZOTPD_f{Y!E8WV-@YNB=)oO<bD{``gO;rcLE9
z=BjdA6|%Cb4X0Xmy*JA|`N!*r*SmHAU1tzjDXafpHR08B<eya&w|mMUE2~=f&i_r-
z#Jj!6WJSGa`+NSjvVOt;X097nRRevI^$)K8X;Sb1{>NX;)vy1{pC)wy#eYdY^Dw!V
z8A#!vW#-?>=OBC8lk$YJc)>I|ZmP4QoT-QmwSpxLFwg}EbgIirs^V|vs`~zOQZi!5
z41b(7dGAREQgSCgbMMDplLmdrec(AEyb>Y1RMB6KY6++K<)Y+W!R=BX3waD_QvR~W
z?oR#{6x*zh^a9e)C@{}nY}a#Yi%8zVbJhX19>$<S3atQPjm9UKET+zt;63lN*imt-
zFQ^?65sE-VO+p&ATEu_6YI`t2iR#{Yfu$IFvV+Ho4d$g01QVlKr*ZiEiU!HuIiSiV
zv8`2QK&q)o{#-4(qt3Wb`SU>=hL{|WVS}PQt)g_%-|sw}N1N7+z%8*f(LXVa?SRV?
zSceG{!z<*BnXyuPobtAJX;RJ9sHy6QpoZcht;1BKxHule^O#*0M%vpq7Gy-i(%&0}
zk>$*XfYGpK%9`@3Y9R_&Uu)2+pYWFQNNSh)7*aksg!<9Mk|lR<=jxHMBYdjwsG^p<
zQyh3BFFr#h++)7wCtrkyq5C2)zMIcg<|BoIm|HX6_hEd+NXCh<<C4<%{uc%%vskr)
zjiVSwt*NsS&o$v0_w0M9fJWARYfLF^5-#s)H#==0m#P`YU!`VzbR*rq0=|FCKaFyZ
z@M*6>ytrT#^|F?c{}Z^7+T1Xgr`r22ZarSk3c_a)d>SdW`pqC@+o$hFCk{WFS2_`2
zLVK;6nYAk&Evt%uW2meIzEfX0I(HsFG|l>u`v-EfTk$^ktu+`H>F}^u1?l&w`Hh-g
zx#R8~1EzD{$DF?`#*d!<x}3b@*SFQXd`l0XUEVM80`J(6`{wmI;WrIyIgQ~4Ix0q;
z(`JqP2npZCc|H>>I^)^=c5o%O;oEK5P1la8ZuXhK6eLiK1heD?VpGdxWcI!1e30vn
zTDDg<6Cgld0Rt-OfWNTvSG6jE?W#~HB!vY$X(p))lAJaJvtjyj-n!X~rduM40{*ah
zxm~x)y?pQC1=>CkZ9iEEUd$OP_(n@@blqm&0S)KMqv=Rk<*yc*u}gXQ^ukuDgDG0V
zyDQc+Lo+HRUO*=GtR$(E)0NK0%UK7z$1<aNtBBVkjSC)Bl19yViQK1(4U`kkncOF?
zQ)DJ{90;UzfB%?iYLV5Uk2);qUQyrNqCToEZ#CTin^x+SQ}4(8HlI;>y7~30i5$wY
zi2$`7;nxwh$IqX6RlS2Ldcl?ON1?6{(n9}IsrP%N*hGZYKKfIu(!!?_^Af!J#}CYe
zMBh}os6BBxX$1^8^GAu=J~?fk;K38U?Q%VDpPQOp0iz2>%l=SB>npWw-AMQ(AiJ@t
zU=GL7lF_$hkOLFc&--!`XV)b^JP1&<gYzE+M=Rj9hE%fHd~x9=V#M6aF2XRP^i#z)
z#J*acMjz0RfEK?eVy0rVb0KNDf@l*uWDxN>u1so_2R}bX=^#0rQLGY?pQIY7vsiFB
zBP5R~#UO8y#YLfW;aUNc4h%!V?6!;-j)z~70`R&d)N`Mr;J~;$X&w1!Lps`$hp+&<
z5LCfS3N$_>mJJUA0HZm$`?j3;tArIkM=dz8xX6kHk+s}RRWp4eix)i#FE{~1BjdQ^
zB`Cx+h(Q|=L6XBAB3|pAuQ?W&f)hJ1N(_F=2GFpDS%t}gXp|cTUMeidBWe~Wi1dXm
zS&)!sb4RdFbGHE^iHE=g6E6~nzr-ZqI)%_Y$NLtUE?<bGdlXzqx@#Pr)I&nQ57neC
zEgfZdafMM&!ItCXLchZHaNtTvgM?L#5o|*!1>1=QzMP5VRs+bVU-aGkAa(a@xDZ-$
znRZvIR#OJTYJ16P=_i0?E`XtI1m^`5R$+j)$b_Ua!2p<$O?b#k(nT(0W~&1H26Py3
zoEXmsy@COT$OsP>@dLFU#iGJe0Dp4CPy>nth@jcG^(P>Gr92=NO7Tyea3bzv8vuoU
zfb1v-RV6~fPH`SGX^bs?Yczw05yC*S?r_2HG2jNgOevNVLW#jC!^S1x{8xy^YXF?K
zwt@*|@B%IX)H4Q16|Qi3LBbxcwK!NFgF9+&n2kLSM;B7Yk!x_YDlL)lfP%z*gCUA2
zznA-5`-z+~JOC5xI7O7BbNHjk2pk%KvrH)1=$1gd!!leRXals?;40mV06LTjYzG;7
z;`IA5UQ{F>jsf>zEC8H8wn;(%VGzp#q2w1#dKF*4n32R%iCL1+u-!0Wl#4%`VqnG#
zkcr3&mG6Ln6p%=`N9Uuy1OUEJ1aDpkk!LO*$!5TDYzjBFP)p!>C<`4#$2e_8F}S42
z3;+^n@ppHh55xk}Z#jq^0Kkn@XNh({AevB^fD4GgA~_hrLQN!O(1KA&2&tF*5C9D!
zCQ=291iAyccgEKq;Gp$EgOMF{6c4z3RbemVu;sFQyjDK9Tna;o+yW@lC{F;9VLmYq
z{8ADH4r4QgWHLc1vt^WSlmR>n3g+<sdJ9nExGX>v*gynqMBwnZSzn7R8CZA?93b)o
zQgkAhBW0NTx%zE+C^gY}axZ|Cv;90;MFIrOw4~cUB!~DAkKBF9!G4U1EAi>Zx^hvg
zNZ|AKRRltWBBZzs+uOid=AIiW!Q}vm6#5UUh~X9~0uzVLV6V!)WUL?{!}d!D^t?2B
z2)h8Cty5vdP(zF_EmX9B8$enMM`fcF*WgBTh=XMK2?p%NwiDLQC^_&1Kt=>Q!*QTD
zoa2F_VlK&pwxK6?(~vG~gbf8LNjs@P1VtDK{bep&4v1~>#?Sy877|H5t%L>y*PyG|
zXw^`_lnCsgp+t!cln-h*8D_JF^aKFKIq2RW#xh0XS+GRtWYd|O&~i$U6;BEUjuHVS
zFcI#85}5-|aNr)xNPRX!9Xz23#-OM%$T(eYrnU677~Ua79mlP%#Sd-A%^{xv0Nywh
zFE`Z@QGSBUCls-@k^*1hH!$`_;&~O<T~VQMbrzschgI!9fn~)bTVXmUxzss;3IjF=
zo%evqZ7yKpJwQDaFk=HfpHa{5AOyNmVnHCB45+UGcz{cS2tB3Z(gfhjWG2Xf|8W;^
zPl0VCBP19oEE|3q4JgwOYXY#hdl1|lgfTsXKO2E#1DG}BiVM=|JU6BV5CBk573n+_
zE;)|BCh-uOgw(ALM1;a=WS9^UG^D}d47ki1Kx|1x(@>XF;P;<-%FqB!7VLlmY&*@K
zmk84qf^~KWN~{3}%MpfTR(d|5K8Lh|{tl)(iqc?6Nc3I<AjmLaIa+6n<=bZJgZhYr
zGfe^dG17bt*9z_t8JyUQl`a4$<zvz1dBi=S*m54cJT@oaewPLc?vrZ{qJ$`J*U^9j
z9i0E&*UjK!!P~C|0rXsyUBRALi0uISC_B@g2f(zTjs$``TQVHzfG-EKCKMuu;7S}f
z1QRLB%5pP?%Z3(MaRYu7e}5WRRdqgT%?}KNa{-=iuMpaua5T99&^lyFgV~XTcCN*7
z4?%CjkBY*LgyFfOn1k|MXbMcM8!j}Ljwpu<kdcDm1yhQ@3Jcz|n@c0~P)<)~APvQS
zbr1~}!oy0Y<zXgdm{Jt7MG5lM(GSYU09(Xk8!&4$Dep;#GtWF9Pq|%;IsStZo`Tx8
zpB28B6z<Br$X|XDVn50>Af*=E>;a#=vfrA=pk#FfQ5WGS!Sz>c+z$)V8lpvr@Fdmv
zCJjY-hWuk6SfK#YS|Ij}5}YsR)?n|yRxYPqq32Vfzfv(X&(H0{mUOJ#(<^u-vT{OD
zReQ0LV5cFF3x=##8o5=OMB_~(s`l1VEEcN>cE&bh)%Hc!H0^4q=xUduYPa5MkHu=Q
zAJuUVW@=oQsv}I$VdmT#RsOF<pYs6UlVsg}4EctPYTH2b-b;O>RZ&yYH<kr+MyQUx
zmrv#y>LT$><(h~p=p0%9?Utr-`i~lxSZ$7WZJt|gL3Ay|T+`Do6)o15{itP&)m69&
z^=sB$imt0Es;ld*Ygnvn`cc;+R^O&w-{Dr@8C~C9RNvcM-@jNt_@ka9)-bHyFzVJY
z7TqvW)G*cCFum9?`=ep*b>&Hs#=n_sQR8B7<AcS<M?V^ur(|Nlrd7A5=N9^Ir<z{(
zHoaYJdjF$oO|1E&cJn8<<}cCB--?=l^fqrUHvjt342ZYDby|?_EnG1z=;9VkUkmS2
z3*SZyDBeoYX%%#D6^>~YDQ*?(`<;B2+Gr(;x5?<VL7C_6F>Q*)ZOVOZs!MI^8*OCq
z_MJNIyWHFNY{j%|75@+B>fT`z(_vQpUzqEiqL`jY&{5@z_qrY;?1~F^TljFLr=`dp
zDhTyq1Zt4H4-kS6cbc}w^j(et);dw7t}yYg2y9mf#9aHjVwe78u5YTZ&^k07g%Z=j
zWiph~@8%imX1)Q_`ULKCEbbwJ6$ZF%J9w96Mqu)C4e^Ft=L5)mR3CnLIX^-JTcrXn
zhvEQYZ;5+%MIUIY1h$5P?E3cl4WUUQn2iONq18la4;;_mr*Z&Tvm1!%n&v?7?MK1}
zrU2mWWY?)efhT0}4^9ulryp+DgV@R*;Jg95$l$Y$ZvAZB%3*MeY+X<cHWh>M#o%Yg
zpjK<|x+VC&zGqXsKYghWT**afbi+fg?p>E}T<%7D;O7o=s8ksOY>2m<53X^QFLp?z
zWC%(-OFS5o+8iQE49n;a%Xtj{&0PD3RUZtiZw`|sMt16s?D81d6FZ_+GNRo-qWfS(
ze{%#1q8R9o8hMPG#EzP&Ua2V_wR$iL#hz&r*X*ro_i0~q`j_Oh*XBR1tp7+phddZN
z%G>IwD%$XAEW%^_WbAlU$#``CxRMXjM4UUoQjqBZ#;byfA>gz>nA|YkNxu%J#|orw
z;?H@s<%SRvV~w*PY)fLdMJ^Fu#*saiz?G^iW*P%uFvv{&)Gq3fWpQVi)pkA~RX=fj
zWc`$Kf2Z`2T71bQamcEjx4Tpq%zq0GH4yqkMlTBr&U416Jp|g9rspJP7T#{_In22|
zU3dL~WP?QY?Rs#@s%3*L`7nflnl^iyA$Ip|+Y1TN#~$MEV!<~J#ID1woovC+svu4k
z|Mh_$4EE2^Bo}}JqTvaD0z6vgh;_;U)t6<J+%GMmXPw+{mDFc<?i%gfHA-l?b#mYS
z&<bfOs##*cP0D~x>VQ?sptLmAI(5)CsoONM-y*5s68e<nKI@c0!?-@vgnpBRKFh>D
z<M=+?)PD0M=tBdP&<e}s0ivY7ie7-6mfz`$QL10|@sg3?0*-rTzg6lmEp5;(Yrr(2
z&pe^uCUev(rQbLKx*Q#}Pam{N9i%1q(ozTPQ~Rw_2CS2MZBqyKAFE(B&75nP%&42B
z=Z!gJaE_Erh816v-{(h?+JC-%F8%W8>8hy{CBxDZ`@J)}%uighh^(b&Uk%FR1Qn0l
zWse8t_1h$Ndu9(gpBwQlxaNFr$Tn-tklA~rbkZnc(CyriL(YU9^gE_s^~&lE%p0^x
z?mt>IY?IvQn$c&GGyvgDcV=VOrNKkRQ{m+^F_)%8&R?}jzUq@V5?g*P@cd|A<G4%4
zU})*MZN{is($(WdR~c2~Y1ISP$-T#mhm~~$lynd7+UKF59S~W3HU9EseC4RJUXT-O
zERsDDS1}TNVLYpGCaiFfRX34zX)L>8BB~5}ScY5}%}TpHAwCLWQ3|7Xe^_N$K~F%z
zutnnF*-Mk&=lb2VhfkDpbdOc)94)uW9P&Fq7Qr5)=a1Sa_t+-&9VzG!Et{fcjXGsr
z^~@bLPaH5!9I#9qu}mNK&E?S2hb$6%Pn1vCW(*%I8nsF3ryQ%GrS$8b?m1gEY7tiM
za<;+wbd70zmsL`KM&$rRULo}B@9z!)T_`3SUU7rL9!;#cno@Z+qyBno<7`OLn0M}Y
zZtHB!#gWsOX3Ud07Ac(khA}0xNT2glQI$8y7LkVD8FB2ZyD5Rm^*2&#C(oAl>sm$Z
z@XEG6)j+c|f(#8(BvS~oo{lVmnDNQ5d<jK6XKE&dW+BJMZdLj&O>>Lg`B0Z<(HVO$
z%fO+^-+qXcvn5gzrXaZU-W3&3vvjDOYM+L0xM%ItAx$geSgZX}wZ8A6crKLF{f__-
zx8(ES--IR?mM<2N{r(HUyL{tcs}TR}ian4gcG05L;>tfllMuk$UK#hFx?+p-q=2ij
z{|?~&KkteSi+i1=@-F~y;Lp(H;m5Q83{4LH1K<s8eEkjZ{*AhzaQCvL{{EGCA{D!s
zSK^5iB(5X~It8sHidX~{F_FRnwuaIcf-)|+O&=TvQT11?l1#cHo0EAI2d6!?`AN_7
zOLh`v;v~@}ITScrFqOkH6g%agV<B_DD)({}6Mhc)(2#}fdRXX&=<%N)f{RGBaNyi|
z!O!7b38%JS@NMIH4im{Re_pt)pOA|0yj@dmrPF)+g`q@JXP~1^%Q6F@jb7%U;k#bf
zAa*3IF)C%}px~0Q7L;2W0M{72$zE#=1Th1TAj#2A&BfRGKAYJ^_1Ll-K^>-tF#&$c
zTCkuy8b5pq8PYZ_J6GjvfhD_;kT5lmaw`&v7mwsU`6>HQ{k@Z@NqksI%P{ZJZZaHs
zA#RN!GEZs6@FQtC!#rXQ>+$lPx5AL3QXISKJ^Rs6@rhB3{qU9h!WoWY6G1COX!jOa
z5?^4-f{EbHpwKuB5u8J5Oe*>$^IL_|Mg)`BV1|6+Eo5#<kJULdkO79QO&>U7i4)iA
zUK<hE5wU_0O!asIQ&-la8Oo%Uu;4QB{c~`nn@CQa^05|HrVND6<7JN&G8AU$`>WIW
zRl3(;+^2NQhg8Fn72|>)%Q8t^Ddgjpl1kvpgd|AW;xI|EA!{j`%r%4S+<dI;)Vn@=
zXC1`!`$OwdaTBmOmCV9<l(IP5U{vxrV29SU;FQmBNw3ij31PaLNN^v09fg#V!&~6J
zb(;F@`Xmf6O@WHcgzbExaHOoG13N|RXuk%Ua5ryZNXF2CW2iY;!%W6Ri-b>O#2FtE
z%4a6}H@;JL&ku`ay{8z9!d+Mh6w+$>7Y^?qYRDZhN9Q7#f8+2eQkdfYbbjOmLsbSR
z!HJjmG>A+S(5C{X0d%-1C!bGdt_FLY2H*>UrXU8B97{|PSf*q4i6q%^WPk)k3Nmma
zcl$&I0y$9*<7FAb-?k(NeO%$+I{OkJ@vSEdqlaK{8uE|Z;}%&f<Ix2)oDy<5&1Jem
zxNG8?Iu{39isr_R7v^%AjR?rRr1A@LOi<+IOx~bM@yCjBd(wcc<NdOTXj-~O#E69d
zF8=yQ260?w%PgE(6^UO7W~|<po#pQ@CwhNE9{Dk+aJp*y-pNUu=#RN<-fBftQTBN=
z|39k`ohSbUcr6*#s)4oU2NpgSpmI&MLnp7Z@+!}BcrTHY&8L0E{wSQVI%t2UcKV=p
z`1a|%XS!wP)u(BH6y2M?WOu1{<}=V%yv%!9YutSH_^`jkbF0Ac*X1_!w)Rq)?_36}
zufS+0WNAx>f^M_Y){RJT^dcWj(Ic+acJ5`k2DhGtfnnQRvytWnc&3#h*1~RLxxGSU
zCKC_OpU;ZECBuIjawS?U<P?3XQnaqMaCQUT+dfs3Gi$9Z<EJhxe!8SJQ)?4Bb+hcp
zr^^&v9WB}7R)yH-8Z+xU`}0$`E@^+RrDfJRT(-Df=k~eIWv0%lYwC7W^yhjy?y&hB
z=}ueGZj!xjeavk6ozC9RjiH(K9xp8J_AY*I^1A@{x|WM&E*tR22%VG40$tXug2fYY
z{F;TVdu!9>t*p!je+A3?Q*K|{3TGM)?!A70Hu_6D8`l{0P&3(6Vx_fGk5ApcUSc;;
zaAnMg%jYv@X>n`uOK0~?<I%|LOOJkh>Ehs;LX#~YJQ4faJz?E+{QUI?&$Yky%w;x3
zT(*4p+U;xay_u$yUDqGJkN(=XjBAb>w|w-m=xhH=>*naY*B^c9g`&Ng&9N^mAOBeV
zI{0m-`OMerkAMC6dKKVnVQ^b5!^OXG&^9e`+oqSfbiNINSuF_)Rx23yZ^I(9ElGdG
zRpUNXjYvI86EL*$opWg)wHFmki#a|a)c5TgIjc1z(CVq!(zh|K+19N5DeI(9QR5W8
zHdeCLs?63&DYHFoIp?QWx9fbLq-C|`UAB6r?EZbqWwx!LYx<db%=hbbzV^a#tLHn5
zzfT9*v=`l-e!i#gd;3giR(r_{s~6f!-)Ey{+snRAztG?KeuKf+!REGpX(0Y%F2$y!
zV%yA16P+LPtgMbI1?yK9?mrd^XFD$Koq1&w^W!FsE6l*i(^msCdW(YJT`Rt@B8*MA
zRnJAK7bUzw-(4hi9lT;>5?k#Rzc|21MHkrU=6J{!-Bp|{Wu*=T98`HWI{Uo2)!cV7
z)4^T-Cg1T+wYDQkic4dUz0A6g#l7_|-gxlRrmOev%=_urmDB$^$HD<5ROx-@&p8&V
z^xiJ-1oe6AYMDTl-q0#oP1Omioz^#?Dk%Ie^n@BS|B_=t8(<p?hK&VNP1O-v!`h#l
zgg(VSdm7sDnwslar;bQU89^sBHnv78DvmZZ!(&00Y*U9iE~qLg(i9bFB$A!EalFo6
zV~XK^nkB>5GEPas&W5&M-@rgk&C%L=znO)hjV)DP-brD*v$a{Qh2{PoYECvOLpEt6
zP!Tw^>{V5CCQ2Jvq>Pv+4}YD-m?jO;(nq0{HMGtCGJ`cW+Y2qmD_GEqc)wlxFf?4X
zpI0!mGV*g*?YN+BXK!*Kb5vc$3fh@>7OOz(cW8fZtOsqyY0%=`J^Pwn${-`UOiEl2
zS}z|8C<zU&I^<s)UOWs<_`bQL$u$#3@k0?6Gp@`Q>#Rv=x$RdtWtTg1=)yRo@>+J&
zv{U}9RdkbM!K|v@L1@ZVRkS}7RZJwA?9%X-)AGOI{7}_AQhl$-_I-ZPu@f|mLGv3l
zl|eI`rTHmnZ2N1h0{;J(|8F0G|2W5rXdZf?==*OKT>pNKRh~~VCK%=ZImiB052_uG
z{eAq?W>j}OnBDZd9@Mh4;qT+0&c?s$K`pzQ9`;$kJlX$S!PO%sR`kvCzb~Tynq!3`
z>A#PEUff{+Sr6Lr-xkrO(L3HPb^kv8>FfINyB<{9rvJBsD_6z#bpW)8PAWFMX!CzN
z$L=T{Ig|C{U+38C=VuGA{@Mb#6n`(GUlyO`f*Ob|->bc3Q*dH}D-;2Xm$bxfJ$p$>
za`|k0vJCUva*AH6*7;PqOCp4{zSbI<kWOP^KQql}he{7wbcC#la)0++7JoU-)Jh#b
zmz^R5cco<uKQjY!0rGv>1RmJF<Xp^5xxclGS4Xvx#>orw=k@jd$0<zfi0w3gr(2gS
ztp-!GOK`4}xrG5@TmiP4PhgCT0`JTNN)PkY*#Sscbhaa^@xlw^U?=|?le7ZIT317h
z(W)54W+AIQA}e61=C4ZcvbrSHQGk8F(&F|OIoJ>}ZQ*daJNO_IN4&>5+&svIg#(-)
z7<kLL*pf=?q!boF6(;`3ZVZ`?V4UnOKpFAt0ilNcq7Nu@U3w`hb2w4nQNtd<pY<O1
zCTR)5KQinlZ>(Wqxve7jmG~WjSDiXd6x%}aHA;Z)d}Eib$Sp)iOE9S9d%tb;m`O2V
z*E5rC(xWR0SJb~R<a2$uyfX@H5^24<9lQy>?{e%w5i{OThGN{MJ|AY!2Gh9!{~9ZD
zFCt(KAr7puV8RI4yvY>uGc9~TcP-?Kx4>OqhKL^d$R8rWr#Z60&WrU;!|;b;pBJ@A
z6FD~kIuk`uPA7e$9+s2)^l(40)vC6{7|(yszv47ta@!7@@Qvb&Mj{D21QL+K=N?;&
zVwq35yKp<WRg-YYbs)(=*XRt5Un^$dVfBT2r<Sh0_gJV^b|4H668-H!^m8~P;cYL!
z{{|&+bpFSB-~g36!1Xx`1mFM2Vs)FX0U96ETcz^8R0nf4_RYudZ}_&#AA{)U#`d=@
zjJ#+5-0-cX4sCwAdu;3Hw-@|?#M)Q>`}MyndA>$K9h+inj6W;AU*-)IW-vjh(mT)|
z!E|VelO0+{nO9Ju*l*m}q=T_P@MooW`#Q_gEM-_&f0e18v0_74{JYZIr%b<QMCuYU
zK%dt)a_bOhBoD-sR0S&t=d}cYo$INz3>n`N#cRq7CNMr&g;19WUiEnP4mWhA@Sxck
z`p~?Bv1+B*-3b%E&UJ>DgavL-!Ps6mwXBoVva|>`B5}=*csj#O8o>iKtz{FFO4tbD
zQxl~TFeWZ#6_Z6_ZDaVO@Kk`hE7d$c=s5ABhm7R=1Br2=)pF%X3g2-$Ach>u?Q^Bb
zzB@jZU9|vk1#x&X>{$W{3y9;{)dpH*ywB8gn7-(<(`yMi?qUE;l@(``k}9C!KU#zy
z+U~)4g+GchDqfUJ)sQC4hN`C^X|z;LJc|K>$nd@8+k?kmSpyllGGDFC^p8P{=#+_e
zB5&b@$ohfnxee{5Xy#?BU#|$fvHl3PSC<VWv_bzf?L=YROT%Bmb_pTuO408x4dm)r
z(L0e<2$GUP3Y{GXCvwT{gEWD2lT4Q!;&w?M!|;lQ!}g;k08neP`w+f@?~063e%kKH
zI)Yf-c(wGtATMDH@X}({Wf^m2W12QT1v6UZhDzVJk?IIUogh;5(3YZ6H2LWW(k`u3
zM<1E_9_6YA)KI<gf^yE8<M|3F^?1Db3oQT<4r&J-ZlE~H>dqNO0WNPS5-Q--Yq<uw
z?{BEHb>Q^aXge16j%K97b~CswCt#+=TR;S5%uW_W_j6EW%6$CRE#d8g18O1e<B1V`
zNX#G#2u<EtTKRFOd&u}`SgMN0GiAB%VKsCp3hueB_ej_OYK~R1=Y0RqbF4?M+|K_x
z#}<UjXvRw6wem-Ze61;_R!<1U-$oT}TGO1Tp9ufYIX1F^rTOvOUvq4~ptQjE2{W62
z%(42>i2v;zyY>IV9LwgrQe$fU+P?V5ts0vvb<Q)do%(*<ZppgR5NQ3zZ3%iTXRkCx
z&b;y3_;HuRcQU3{F{CCoK)#c7vh}=YV*~9lG0V5p{k7teQpLW-d$XOLUGIWnq2g)>
zes*?`TfaYEe4qQdO;^ZV<I%dPzK1?Tu>RnWZ_m$eJo=`dEAgoG!<nll3BUNdq2r&>
zkFm?k(u&=~8sTby;_?cA<hNl3oAosJ%_kx^y2tj;u4lz;J|*(^Oqkky%qiYnRot@e
znR1@}SkSlmjC`(VI?(2iqNUB}S~q%TBWM38+t_?T;qU!F#JzV^lZ&?X{iKH;ii#i_
z5CIV+AiajrLJz$|Kza?mLqZKb^o{{RkQ$ICwjdy=h}ab@0a3ARMK_9__u1}q&fVwS
zd+r_Yd&l^`KM7+bz+fbE&h=Y!E#}*7wu%2(C)!TjtX<eVq4VP<schnQr_IN1j~}mG
zuTR_^Tlm<Y`r|b@Gg{)3&8KUC?i(YGp`PnDm{Fy*B>@Qbp`glE*6nlmBJ%}CqC~0Z
zzx{Ye6*$X5*?zt#ettvy;OfH*o5Uhj?}N!fbMYUSb9Z-ffc)!cpKDzIa^aN!2fov(
zrpC4vl6pTc?ITX2aZkS7J@fOU2IMBAtwfDC6M%A)f4ok-o;uxgpoA$q_cD7LBToSK
zmuGIEq!`~G>ui6?*mw2)?ux{lQORGf<)8nQxLqDLrS~O5Ad_WLVVhcn<Cf%@(U*3o
zeR~7G^VYw^1KNu<dDrb0yzw-2D31E`+x9jfN`-1t;jUC9nkuvi6~ajoSM2#+NzxeF
z32B<uCgK1ds)7Z?#%X)*)AoL*VMVi~G_&@K!oCNp$uP1I<yqO17=^AZD@TM39#D17
zR!_>-tjpFO&(^)4twZ0VDCdWu!Vsh!Q`a10O}G(0$LxNN&F37FXs-QwjwT1@><S=-
z{?cFo4(CA=<NeFTSZ9q}(?%^)Sr%!7=BX^bpgQx^0e$y8%k)8uv>}Vs0np_bB@LLR
zuq@JttkMUqsH2u?gH~DN#>p(pRF-+_ph?mIF@<H6*iQt%OdB#yW)YHDW+_AZ@%^UB
z1Gc$m3=#$i$%Dqp1J;>C#FReslmUF=AR%$UJZ(@nw$F+-rth9_k=%n%?6=4`r5D%d
zkTYhU(r=YHLP+ShOdGOE2VZ*FGL2<H8#78~nWYXAQwOXvhK?4VGEeC>OBry_9dgbc
zvrZc@OC55}8Z-fau$116mPr@-czER*&+LA;>>-m>mK|+4pyYI1<w$hpI6iT}G<`In
z_>^njs8wpeS=uRs*dDWtQK!V?w%HR!oiiZ#>rCwhnO!h)wx*3)Q%7Rzr;FOzc3DGy
z#p4#KeH6y9H+|H<{DMh%OM26}=!$U=L^e+!JX$=W7Io6A=nOt-D7<FUr}#`{`Du&P
zLC|a&C-joZE`CKLh6(*KHQ=9xWt7w(Qh6Tqf@w9wW)Ur<j8i5_EYMKeXAFU64s?)V
z#Y2R|zSPEZ-uc7ENi3g|vn3sD?SOjFZpPQ11&hpWv&TwLTm;eQ)Vhht$}=_@tmLN2
z?3S}(6=%XqSU!al<((H&8zzY9r%Y2=pbd?!W81|a^UOPCoWin78v+StkK(i7uqCZ|
zGOB#UIeVm_^?Y*kjC<i3%ak6osACRUBZaNw{$&$6P2-@$1L5X^W24SV?ZJ$R%Ko|1
z&dIWq(}4v;PFaKWmNBowaeFEYOwFT8Pq}3enuIo_HjFtWwg;7;(+jE(EgAMNU`1Ap
zg;cU57^jnJPCL<9`ayMO!F9C8(|PTaiS_3UJn~(V+wm^hnGF+O*}b4Y&SjoeaxOTi
z?Vrt@%<Y)TYn#M-7OI*?gKoQ`=Mq@jkeS@n&_63LXDhEtmM27m<~t<Rcew5lNH&N1
zAGb732W>Y<Bu52zq$f7oTGBw93))A}$WlVO{?)`V$mjDg`z@M?gKaZKf0&s6B8>l|
zNBF-sF&4vJH~!IJ&`CP}uVMVZF)_6-rY4ep(X@Xy82p{4J$kNZeDLWkW54CUhVdN}
z`!%)yFfm7J7skK(g-r}NT-_<QeDt@`v7pzFOH?$X<{r6YF{Mn<#9S(n-B;@QMLn+b
z^^g8H%Svs4unheEpJDvDQ`_k1$cZn%`wdvvDU&B@pHQn;_mL)le22V$d1fCq6Y>Ls
z7<K{p)^`MxopZ?15U!mVieWa~Sad~@4=>sZ<HukPF=bs004atc0bG1JNf4CQI&Ohx
z{KeUe(08t`x;X4cos(j($PqIxF*uY5375u7L&6+Czy%C<l5>S@+S`mJaB<ivVbMi$
zzLJWj<h4E0>+IE9vii)tQaxS8iu<~Bwjs2g#HPUwaxTvDbBVCBWZI@#NZhe5lDW>U
zO^Ag|wx|6?f%0I2NnNqJg`?5~f4gj0HNy_Qm!B$Sd1PnWB5{w%CJw&a%a~?_^Eu0b
zsXl&q0}xaz-i8({$KffL6-xC3kM_Gnyf0Gl$1fU7mjWurI0Mg^Jhb`r4Lp}unpC0q
z`0ylMKz*8AD9(ogjI`!R92j>7<>Kqp>vxAucA2U|47nqiA84|z#)ieX%;8Bh-tjo8
zSt0v}hSn%dR|Vw2jk8RGP{_I=l`k);!gxZ&WnM_b%OA9e{0!I(IyC2liSVdZ`Lxjf
zCcC@?uZSyjt=((DB&<L9lo2-IAr=Pb+MF!dw-cqfN$gaJWy82Mu``MU62?TK+4aWc
zp)p56xcUn3(41gE(oH<{HfG9F%xR;-^028D#9TU%_qR{WVuR&uK&XLp5h_l_!-Wjl
z+rC>n<eR9M5IiDw)(ZXMeozda8BOIG#wuqY3`jeUcvu&-S5Q)LQKA(pU|h#Wa;N>o
zzl2l!TT!yO=qaQ?6aNIX<480Dt<c-`<?UJF_Ic4GB3RwbizqbnJs@-}4T8lU)6IlY
zn1%v^XK#J`c;@(2E+B~J{P>fmT`3YY1dnPCWIW#>`jtR7W|g)<6JvYf$ZGGv_RsHI
z@4$~wUM7H&EB6xon~9lYBegevnHX8(B)9uU*3KhXq{iGNf67KSR`s$0p-bG4v5_OU
zS&Vd;ySQ^=BNtcP${R%dn~7=VPn<L28a<wm=WWAm=M$$f{VY1s3N$fu(=y(H5;n9p
z%l0`DdF}UL7%#>5v32Hf%KM^LUz8|9s!UnTq}bDVRd;^w()gR!5_IxWVkvr7dnl*W
zLgA?C2Mk{Cgh_D%Z@bMnnrJBYfkC%wm)doC&Q$wDIit8;TGsrsh5LUF<IS(wH+-n-
zvg(lkYZz~S)qUwh&G>xB;l#^Vy}y3==P>?+O6}$OKvP87f-V-;W_~Ty{Z|;TK6d$9
zWXkXV2;&<Z<VG|*`J!4Eb{{_8yipwFnIU;SW$E{p&-0!7TbH-5XMFwr7{J$sM_DXp
ziET2`*6ZFGG$gR-(26PPGLHH@Rp7n}hVfmd8dtzDe)Bk%?<DcBVf>YwH4}e^@j({1
z8vZw7e2?p_1sKME><zZ=ald!vU&HvMYdzjuSMHtv`f-5D*GooO-oGezw{pL3uivh#
z_b+LG`ftK`Gs~r$4WEX)Onm(ut}fl3_%y;Q=?f3CTwcol{~(ONG_vC-AB*~t+j@H`
zyR)ZR=_vAh4g9)^Hm~}NEb-lc(Pg}VIuHjX{?cWJp$$fqR->q6hGC5wq!fH;gQi<P
zA-vHrya`lfhG9(_ZgfpIx?xy@Q54f4w2=_jObBn%4{5-MH0TA_8-+LN1lHrjnhio4
zbOP$Zk6**^My&wwTMfEFO~#QeI^ZM0HH5H6Bk(yx8;m2Gb%W|O1L`#WYgK(~)qQJq
z0vn7Xj~P?izzmiU*{U5-XBbj@G~+lv41BEyognaO8xk1<I)RPa{&fbS4Ovy)2BA$B
zl;+Uf9-BC(Q%X1ZW822Im_{(|;+ox3yYxbvOu`!sL+Xtpnk{469g<GOm-Jf4c34xI
z3_}`i<B#im7aN5(=ma<FhtxYIwwXt_d8W0xrk~s=Vc?y90v}xKozdx%-bo0pGmAXt
znc60&=H;K;7epT*=kzOjR0QVsScg_0&F(b;xq;*kP4@y#|7x?C_OQH@5d}T^p~uw8
z)%51kqNb6Eye?9BwQ+1mQ2t<k^Xbr>PJ{4cG6$T3a(e@4t?EbXjKJU8ug)a0l^D?&
zQ8Gj+>IX$xT<HKPyFjrfg>y?S?@p{ZWfIXGSA4RBIab^}8ecwS9Cl1Es2LyJlwN&G
z%Puvwa?m)u>A(?B)2L>n2xffMm~~8(X;`y;d}C%6%P#SFcI}{5T)SpKePJW`RE>F!
z!v=wkxeX&0mijsMqj;ZU>;VfxIMX||l|U{t2x-!`Nl>&(^Ui2@Noe)TXvcfxd8Zxs
zqaG*4wFYJP62fXdGJArv+Z|);%i7Pyl(CFLYQ54=I3~3E(z?x}TJ*gNt2)kuMPjyb
zEf&G$>aKL_(8|D^lc9ONA-P=<rNgT3g|?LXh`jC?#z<5#D<r=sq+mFr^pp>^JFcKZ
z66cm!+IIvW6kpa8mfwxj@Q_h<&8_ZBXMh8&c3Ry?cH`+o1|fO1{ReeJm5w->5w$?&
zrBC={C;|==bhSvJD6=%BQbJCE<BiDR4p4}J0}N_PGpNPDfdQz_KwSpT4?scpueyxY
zI+gz~y6oso{17*NkNHsh<x078$)1=0S(ka_iLXH!)ITAKxOJFDP0U}yWwGCDilq6W
zqI02Gs>=X>Xxg1uBVoW`;2CYsl^r>n-IS+)YnHO;*wl=MLTSP}X!PE*k~uz;`(><L
z*{v55P$3mjEQSm#;^iSEi9(EcAOAgEwsJK*n{=bfmzTi{$IQu)^5%D35aP}8gU-N&
z!;K@0C!o2+8dV#=73C}oM$oOr<Cb8!oZ_fD*O2x)N6Mv~3#}WxZAwMl#EGAF@_c<l
zim!RM;2bvg#1yeIB95JN@T0;)?CZaU%bE;{p1B*QJNz+zybxjkN%P&9@3d@1$4!ih
zYVz&D%lmIJpafA(d~CL?HW7MRSON<%$JC4d*(`O`;Tqsztu7<yP`G1P&Ik0)*tqhG
z2ZmXI>E4Vz&=Pe`Pci|1$Q8!VBRC#Yx=&p7CS=bfCHCo`_Z|4uj?7}NFsM-eY5369
z{m(WwuJF`yh6u{cx*M|s3nCvNT+-8|IRP;;yFe*I0c(g3!nL6rs+>b#b^uG|vj|~T
zXY*Z^y@s>G6AG<{2Mp3!Ch|6b(KWH>!P|JKj0`Sj4t2EM@1mTAD}x|Su_}DYn%)`q
z#__7EAuU|^wz7?)*4aUBIp;N|nf4J9p;WGPo;-Ch$dgRlue-sV-KncEG>4JcRLK|E
zmN@k8?B?C8<sy5EajrsAR)RDX5p6UHRoN_pAbi3xY(ZPPP{BbJ%H+(h?>n2|lAYg&
z%+7vFc=LW1%QMZ5hVa(lp;?mnDQH&nyb7e0JHdE|33iZr6)w#Jt{&U4pM>qnSJ+%M
zKAy~rHZShjylG);YJ><>_JY7M><#A|u0eexwDm4!_C0dG;-~xml|S%2iNsSMm%_*R
znziRylK>2LI~@;;)gW&{csbjBiH|aFMQA)u*I-{#=o|0*yjnclVe*t=cKFL$l}qH8
zXLUjSU!FH5zWwronSc1}dV6i;*Oy(Ldy_T0$KIxR_Ffe^WBvMU<hS1dnG8Ga@vXP1
z)^pzvf8Uti74`l7oa{haT$-Hsl@E(%N<TJlyF~r?ct2?1$ESyh@BXIC)@q}Eep&AX
z8P+#r?|y#!rOR$TGx{T3{wG~VWJCW5mvf5baYJmHDu|FvFTsweOwy$HXNk^Zx8HOc
z);exT?t8;TH{U!f*np$%(rx8-0d<*;bk5;_)n!wAzi#|Pmr04erxU|{Hx3U?OKblT
zF1Lwv5@+Py|IlTBLK2`ZBl8{?oh4pUX?R~8Z1qRDd`W%cKen8f-j^oLAK$w*H>>}3
z5PSCM>OPeD9N~Y^W#$a)<CP`~C^<9pE3fq0{%2iwZW;L>ki?(5O#Aox#o`mHo&R2!
z{ob^0)v0~&@<PJI@1QR0)O}(8-|Mn2!mcZedD@%5beXKhjl%y2UAF7Xcryq|OejeH
z1CsdBLaO}lA&DN>%OL_O#s4?D>=TP_{ePj$touS;{#lnD{D&^{AiV1T1CpRUmwcGF
zDbn&uv)QePhq|V+)w-Z~6c79rF@=MOY3wic1WF0KUpfA0g}zS-{%E<rPpLk+RL{E@
zL^BP@C7^&ZAeX8UDH`sDs-$#%pJFvvx|T<gj#sfdDNWP8P|v3Xymp26V`zI8;eE?=
zyo&U^3N_pc)re7ea;dH-UCp&n$E!r$tw_hSkl<gf<6W%knje_ntm=}l<5`Sz%s22Y
zw+d!xxECoq(GAJPHsLjdql_aig-6^9R8-70JW4#`>h%07eN&I&{mKmd%5^;Q;|jX;
zyb26_ib)X-THYnmIZQp@GF4KBo=>SoNR@vYQ{TH3PcFgxmb*k(oB5X>O>WflE-?wH
zbcwFj_bD^*D$w^X()BL23@Ee+snhi;K4?XCjj4BxY4l8P^Nz1oSGU9|TdJv9si|3j
zjiOrah4Knk_K~$#p*4D*1s-t?erfHNesuqg6GvR>erZf<$#F1*!a3yS*08j^N)IcU
z2WPYdWVEV#6oG0eEUQ)Dw?Ny65t-Ym?3knCT%hY+WEWZ<oqHTqN#VKOc>hXJD}`rw
z==(C%JqnHeOH6~RjmV{Vzlu2eao>cRg4+IMdYf%<nLfEBHoqgU_EdgNUwTOgwW1eK
zF5V|)8CTe26I_y4*{iB<1!^LP=mwmMMS9V3tB?xkm}XLRvsDlyrKCHH(HWZAqU%U?
zj;^<jsL!eD(RQQ~{1``$fQPaey55CmA=Pg2&FPHZfYcVVz$#srEKSd1x46cjOy&_)
zl2cq$aecq((UQRQ<L15vg$<`X5*mF{+I*6lO?`6Bee;8<ogwK>r7dF)l-ej-y(^_A
zFty1qxlWB39g^MUnb;ha#ROGVJiT2?!7(7UA)&bUz#+Rh`iYFP&iJB%#KO*`qLZYM
z5^ehoZO059yVL_Xm;CB(72EXEmf@_bAx$kSb<=PSVvL%G<sp-pn$}TiS<)dbKNTIa
zo0FQJo{g-gKbUHPVrrkfJ*c5H)O5jM3(T`XF$HoRpo{{OERgs3Q%U_#>WP1n`d{~Q
z)>^}6i{Crils469#=d%Z`P83?saNu4$q8jt6u;M%zhB3?66>Ya{bw&Hh?t7>#Y6r+
zns@qa!xUFS^hJ378qFvDUTVzE^gfhL`N;h%)f%S3b|EmIS-(=Py<Y?V+!5DDR}L6<
zH2yJ~Pf?t>)bU3zXM_BF<45<aE!Jleu2_$UC0z;l*U|j{9x?svj`%t!8)FLga{h^!
z26nCF?MYZ)$;al&t<t4yf>-~xBR;ymT7>)8Ue4f0qR&-1hA`uuFDDr$+`kahkTu3N
z)mx=yjyr4S09Sqzy9VKZ@<6Ry%;|tSa>_{}*9*s!GTu*kaR@jB%fL55Zo36RW0wj5
zI0XqzHl;3onG(Rvxpg7$_MTjK?}1C^!DE~$2uPK)d>+ikv4IU27G+c65+ajqqzr}%
zW=P>=JVHpC1=B3Lw4LIt*cRNH%PY?GokqgtI6VlDuJ_a60vnmYi>H$<<!9t>(015{
zvkMPvv8AA5&5rD>-iH;>t|}9ZS1r(<!`Lk7?s4#TxaFIQT%LW{4WvZ*S(eHEV(G;q
zZR>XGm3^1lty4lPi-Klj=)`K%1F6Q$EU|?-jxn;;Uzm4CnrCb_T)0Y*E*&fK!E%Qz
znK>^dr%ArdWu$tMhcC&hg1eXNp4ATJr(~fyl%f^E6cz9tnkzjv&$`CPKZoVoU(Vbp
zRuv4Uuz7OY!zVFoxTjQp)rYOKy6X87PGXc{z(PoH69e0)^~R6;faN^Xdgmdu5!X&L
zCS_V;qix%IP9Y5J3s(~~p2Q=xHgP5Qi#41OdnBv?bL0?k6sA&%^Mxz!XT;?21qEl#
zDWAaZw}f-2F(ERUw<q)D#avry(1V-QtE(k1_TI)3JXc=BFAcBc^Taw5EO_@TI9%bA
z*32rwc#5`hi|@w)*JLA9qm9H%(^M?bgH|#0w`<#L*8A%1EwXkyh+-kU_EwnO-MSRA
zAyQv+!vbSfbrZ%L2pIm*1fcusXt0z;xW)(ksSjEh+0Ofhfcy*<Cdzc(i36c!3cwSy
z=z!FuqKOPHQIXbcB-$6vwShiJ1W<fwOkRhZB?JoFMsvQE|8))keJB9Y>8<46Zlc2X
za3b@Fs$4p78iW_k`BOc~QK2NkLIfMnwU;q{xB<R*HHj*E5O2y&k1h_-eG0po^h-z?
zV+q=4!5#6xs;Bp5RB%W9mwLKMIHUQORLg2hN~MGNU!+<EP4SF>PPL}5>#}$LO0{~L
zcz&f?JM%U8xbl_E3rc-K#MHYO`771>H|pt@a>M5nnzN^yDBjaeYyU<)$;K@)|BF=X
zuj=Wj(82#fJ^3EYsg_3z9JXH6^!x8pt((#CUx;bwf!#L$1~L7ANVWdg>Z$!7>goS~
z#8hK`g+KN4KaJ+^76u`O{}Ova!QG&Yzm@xd03bNov9!X2o$4Ur2$q)XYTH`d5G<|q
zL6j0C8Lh1il@F7^;&hOs1WVM-t#nN-)UB-vU?<M6i<`&5igi;<4P9-LvZ6b9>QYC`
z*3w$vmW0>Qwkgi51&i5@%vHcXc4JEwu)oH{>Ihgo?r3Kn=+kaxZD3*OX>O@&VXZ^5
zG(RX~OR_bSk+QY5H8eBVG%;7VvN5o=F*Pth=ms_eS!>}GT@>UTafe(St!-WH9KmuN
ztb|33XGWAu8qq>a%ONw=Ce6#y-P@iFcDC=wTF1NPJ6hUXTNr^uD`!$3*i{~7n=8JX
zcu1b)Zs9`->I92*!1A3$+v+gCR)VF1tCbtrc^>1GS8RVS)rJ}Ap6Frganva&)F}=e
z<mtL(m$_Uhx4m+Vd{5IDd(<-8oM;ea9q;Sn8{ib-ZR77_5n^eh6KhkZq~M(Az-sWg
z37%^$a2?EYYda`ymuy%2Xab9uj|w0~`B{hi+6P)%>0z;k33lblUL{p-bNOCfA;e5$
zGqnKszyzzhI`1nUPG#BD=5o(-joFeG#PCSR3?CQIK$ox(muPjn^df7vvURG7VQ`ks
zpr)#~v@Efy7(6ALXJ(^Db2^^x&=MJz8$&5ecCJuYHNV`UWI(`2TIPp%M1Y0x6;4;P
zGb>69TiSg&8SV|*PP7v5;gp0*Wn!G4AFZppHqav|*e*WFswvC6xzX?H4k5#ogq8x|
zt`ws&l1*%r+wz@(LtZ9f5kc*g$b^&>dag^imsetI+bJi9#0=7jjHKF7i)KqxqMaG3
z+LvvsO7)Dc==OP=;ax-4tgmyvm6UT#)gY+!=wQfE+J(jgX6iU<(nM;MkCUmJ#X+i*
z$q^4Te_aiKL#>2t%Zr1oGn(pFCkpp^kqm1}?j%xJM3qEyUwU!nNk5Z{9D~c_6Z85?
zNBSFE(vR-%Dm5{XjtO_bGV-n`hnX_UnqOVon-`3ouZ~+_P?sLPtn?pWxW&mxZZBzI
z{kO3fzX{)b)k&J%L3>=`-(oL^?*E9rz=~;^hQA6oiNeJznr*~?FqMZM8>1!VO;eqJ
z6{`2RH1C0f0p7>I7pjl;d9+SH{#)$zYaF@jx1x^Cub^;qWnH>R|KqIb{neFAN8;yp
zAWsiHJ5{Fi>#V7ZU7J|aUh9c}Wh$-DjQ$&@^4|!zqRfAk`>b5=@!3|vfxAHxtGny<
z|KqIb!;Oy*c93m>uR;GP_gQC#!}R|UZV5YAEO#|j`R4u-ZeM7yReJVmGpPv2Ce78n
z_cP>cIz!WPPjwn{+NCV(9%}B{dv~twavA=oYfb6F1A^Ij>uHRUFraETn+D+B%p?HP
z!9^Zxe>bxVtHT9r<<{CE2dbQ$xdQ8~D=x3qBxybftc1FS8~`lT2aSYDd3f2XAb!=I
zmDXbQ9hFj2_3-MXJq^-z+43O)yb+i1&yHEGwsuz9?R0$E6!*9Qwb!G@?L`%JFP9B9
zTSZll$<@~#S~GBQdxF$`>Pk1GXJlwezVFOZ1BtirbLCam^mFKyd@OD4CeO#JBMXo{
zdw}1D7h@Q-k=_0}eIt9~mVX<0kP_A>_c*VSHjHZeW;pSrO<Zvl)%z`S;^u-*sod_g
zjmgt@-u8gQ-kah|7rtMze203p7Z5vtUwzMSBdeiBisMfRz5VC;qFz&Gz6QQl9>)$e
z{-*iV^APL&$G|ghC)ULj-VJ{pDn5K=Wwf_%SlK~*U|v)FJ8M$$>HN^B*4Wt(qdKVO
zxNBzOC2y};yi*vutS7D)H*8|rNRzv(u=??y_x|5~Mf}ZH?0L5sMujL95svzD<g6F4
z96qMF^@ux(LxZOMzWtjagnRDV*mCw0MU7<&JW}&<^1HsIr-i~cpP$kMerj^^UjH@@
zRgq(iucml-k8=uUA8ozN`}Sk(Wx3K}&6QRc{;!XzV~;hS_T5|f{P0+9%eUWpU-XYX
zn!44$wH(Kz|8=eWRPz|`?7ednFXOho(w+`#_-K6Uk-e__n3_r<;JT^gpI^G$Rn~Ga
z-<j9GExjS<8sPzDJKhvkf(4J30*(riT?g-#k5l1w9IDLvF)*vUfDk1^k)mw4`bIwb
zFehu5KNGe+hUd}8Wl3xvgMh@32$q`tQ=9`B2ZJckMz)Z@AzX%a5uuLD;rHhNaLmOW
zLac1w+Z^<^F9#;hOUXL2hUIk~XTvc!=oZDCZS0((gbhAVHIB)v3j&zkjBMC&D`Zr3
zN?MGK<dNne!sLtvhc@#3tnhHF;B2XWT)q}qXns%h5}Lt=OMvtbKb?lIU^0+o8kZ)G
zCi3`3d8kz@1V_m-KP&`u(d8i9MNLf_$gp~Uf2nOz;=Z>Oh!7`-3(mRBhXbmMtnjce
zT?Ae+GICAl*kOkot<uv^#Y%#w)l6^5=87H{oo4Mb-srr5rLVxzZ0ZrOg8<T)jhdJX
zRI6fV@saU>?n5eEiVX-3LwKdhfabm3G=4M|3jI8V%;VU==#@=^47P?WbsHkS-o~3w
zr)u0gZG#L4ko^=xlo0MZzbGE+tC<DgOJ0l;!vjY5@o-0+VNn8}DMXPqv}MsE#hA@d
zBAaV31kecwAX0QWE({AIKJLfGvqKgrTD)0XachTO@Fe`hZV2qV;W20(z~x^^MJsSl
z5G1-FYv#6DHXj8z-`9Ctx$O%4@aSF)M1afv8m${>x%&ohmi*Z+x|<A>XU$;0vQfae
zAFqhS`aYICwM>O0up!;07L7-HZIWSxE>pE>7H#J`flK-`Oua`k2dztPM&hY~g7~}b
z7Q$jjFxh^&c&NJEU4b=tr(OxOC^QEGtK0z%=Xssowk<S_$l~N5u4B93i)6x1AIKpn
zExBds1GUd?b$m&B&}v79?XqJdwEA1Ea>*C>u43{Y)YKaUG_CMyQC1UUnKrOECMs9d
zSc$tlPnflWk)SJyTlo_9KV0S4#J<&z2C}(0Oqd+*q5_#g<)6QY%EZ$S^51X~xxdPr
zK{4ciEbcQe10c%fpu&Ix=jYO{3r6V!+}fmUBT)!KnDS22Q~@S}_uHwCISF9MaN_OH
z0-7vZrXW7sW}XIDXG4ylY1s(!I9ixwNEMLG7Mo`ZPcf)K>3oh@IDk5VBV_IJgl(%#
z@td6Z;3gT3MtY7<ak;+8wWAnH`H60GAI4J|lU7i|eTa}8k(%+uJaEUHR*NQnlFQpO
z8?5D-!I{#q&Xf6jMK1~`Fz^nSdC4NZ7^Ef<$A8;x5l!{wzwS!lA14)R_WA*%c!UHo
zl}D-9cgNH-U;P94u-(^1VdVgRH*te*KhTC6!yE4vn#_vt=0L`}Ot1@7NMMpAA3&iA
z;QMlSQW}nBiB2nVuVgv<tnjL0jCYUrEv{C496#-N7=2q-7(c%J2$rmYT~&-qxv>2B
zcO?G2q-tU0G@e_Beo<{zxh9uG5M3%kAAt#mh%x}NSSBRM=_*wmBPF1Lqm82kor9}d
zd6J1#2>|$@8ngp4w!N4oD5MMzTx{LdkD<+;;cyA%`0;0t!??ybcteu>AmTv?xycY~
zgWfjb@^~!?&&eELUD(>u`{N7ol6=}tlCJ{frX>8hsfNTUKG`~|;SWmQ5myP``NfNZ
zLXt!mJY>#BDO*;Gyy;8ELM#$Zz`e%={Dkk01U4Iao|4zQz4Bb^30^ktH?E!IE4&GF
zUD$Ozia^J|EM}gtH@Z=vP{-ccya?rlkh5p5dhykD2HI=jl0z`i`-kz9yK68xy~0_@
zjP<YgLI%0D_Z;PtUNqT*V`qUS&^s*f+Faqv#p2^oz=}l6@D<B5?plEejvHc-D|uR7
z5MD3x#cgcWMy`tE=>|a@0dt;}Axe*f3Xx&^k>x0%I1bW>3EQ_oMXEQoUO|#czU)j>
zO8irojKg?nm<Cdf>Ao6(${_&=Iudao#t7oUG2EYz+N{@jUYYS!Hsk}DN@>?DnWQW^
zBA=FuxYA-2Vhc*;@H`_?xC9Yc2IZj%e-{oxq4<vB5O)Kecqlw3?D#S)+9eS=MTYSr
zka0|;0^Tz_9tj>~Ou#{cSbW2HloT^Zoej;zAPw>8Y#dUQfexX-d;y@03GczAzn(t2
z%M6O6ARlv3ad?<J1AUd8V?jYiP>}6RcmM|mun~qVZYLt@3Jxi}4cJ&zrzKJl39Q^u
zQmPOZR=`1OVIX>Jx)B*BMM0^dU_Bc=?i-m%3Qsx%)|P}Ky5#5L!5X2wqnc<T02asM
zZPhGn#zHk2xi;(21bRMiouf1(Z4rws-au*qMM4`WJ$C+S*Wx%z@!d6;TQKb~1MN=c
znO%hC%fSn~;Kf}?bv(3~lv7rRPA5Z`#`#i3xm#Gp1sg~iJP(N+^I8=m!{!daLe#O4
z6X3rk8yZT2DN;*|7kRF;kiNB!vK&+bjyHjV(qjf?=0d;Y5c5E}5d{r^pFiNub_&mU
zlG|O!3R!cMB8Qv*GD?dI0krHGn&rSYi6?-Kw%p*A)k2#A0G(B7#10Xc10=d4Uytf5
zyodR3RFQU9+iO)jx>b|R`M!M;Q@qcIK*0}ic<z&|kTjl?0QWePlEM(Er9$|Fcw(_3
z&eh}~Cc=%)oedyp0K$j`k7aRZV4==(&{{-+j}tN&kET&!o@l;nv$Z_{vVxjdjN_H2
zLLa-<#!+iYETirjs1Tbsl7R>dLT8at8d!J$7P?JDkr=2DHun^zE*T5&tw)it5W1Fw
zJWz0TmQqGWm9f$JFS(>x384T=6w7t;Bp}E@6fdIONa-3Fu53K)P$yE60W6$GYAhl>
zlc1s-h>C43@Y%VF$>`h!STVafhmL%PLKcwG&gj~opV0+)Q~?=vgw-rVfzAh`Wmz#F
zc84@|I1;c;<(Oj$814cl@AIyDRa`!L5z?@Zq)?CEtwnSdAfKD_Y}KP<aj^Uo&@%;Y
z@|?721}Iv%3pji-8-N<a?P^e6B8PkP<*_jax`2(=<B-0`p#U~o@c=ZRfxbY7DlDR|
zK1WDz(8o@+2T>5KdB|QiS_<4^XCQ349X)aAJr<}upu+`=jH4p`aA+f3o!J+_h{8R$
z!A%kCoTDh<AUytfcpn~~)ZLlZ-Py<JOrPjX;_jkqcO`%A?874!?niyvhQaHYsNYFm
z==ab|SpFF{Pw+{Bn#Js)*=*C7ZnSl%3>z^<f%^b3(+z|f1!+Qo^)k@DWY~c#9YI(w
zU;~+x1e*sCnizP`S7ag%Z3+O<6qx@N`0*6v33rcOY6LRA)N>JH!A8F-h|au^6l5c=
zq;xOI!+}NAFso0W1sMa%Z5o{B*@$8c_Y{B#!Xg0{(v6Mk!NT=eu|bQ-_)SC)hFgHs
z=SSf=_zHEMJfP1WXvG_U6oboQdQDl}Gzx5~dq5vw+KPpp-9^vE!m~MPAGhe=;RDgQ
z3OVwi94oeG5vhRd+q>K@WIhl<;c?k0o^C*tZDae_Li=S|-G@mq;nUonWEd`$r(+R0
ztz99FsWPFO^WTSkw?M0dRdyV%6O8g#?T%p2|Ib8(%my8~2(=`k{jNrw3GsH=;F;av
zy?`BQ-azP);T7akO8~Viz?vcsKQqT2$407nz`lo~k`wF>nhsQ8S(;d`q%*t`Ebej&
zGMWs1F+mGY;XX};gN5oue5aBfmobj3lG=H!sEe-6)pTg0`CDgu(L}1nMCBrPOJkRU
zT(&h6@`S^)fkCLZVLGXl=t-}y`(anNYJ~5V$+A&&HgtaiZ`UG1kAv)@a(6HQ`9)YQ
zo@+4BTW=BJMd3P3g6EQ<-rG0?dE;yc3*yc^S4%BRr=r)U;a8Rscbvxr0Yo64D-eeW
zBXP@65K(Nd+m>9G4B%Z4LYBmnu7%Lza9!;|2y+mcBSB~?I-SIALV_Qrp1(5+xR8;Y
zj~5<!T-f5_yZRd8bYgPLk_X#_lm-x2&%iA=qHC#aJqmB&#^k3)q&Nq0lZqB1!M|R;
zu;yf~#X-_paBm#agmF<8e@^Yq)HfdQCUvJ|))b5ZODCU`X93<|Zv=-;P@5iMxJzJA
zd(xoV#b_fAa)gQS#`;F$x$tu#ybKr_xEO^&WB1I4KZC|nx#^UQ?mN&X+*}hmjKV+|
zTS3LQ!!J0nQ8yP6Dc^_6irHz!+#@(-eA<*2r(HH4ag&2M!kP2p@G0VembA-!NmU%x
z)73?%YkE!}R_1!i;a#9~E-?7}4oxfoK;qX<V+Q}r#nUg@SF0KPi5AG=J@aRDx%@X^
zL*?)d4$pBM_j#(o_%a5MSFc#Y%o}rq2fEW(a79*-v8*kp9V&{0Nmkn)0bHIRfH>v4
zN#MhtNE`9u;PMnlBMKC{2;ESC@K8(?D2DRD^&{l4g7yVfrjr00nxcMPhzx)a8c`t@
zSac2!#Y=}6VM;`u+TbIA2s|$ncjN1A2rqSk=ZA|B4%Vv*!<~cdONNPWV~)!=0}6PU
z5FW<GwjDWfJ#lM+r}>sniIXTECdvjB*iegWWxAUv(M5<6W6=l)%VYx*j0FicRDoiW
zV(M&G0#R<Tbt_&NcE0(!*FBR%-?es1m1OAa1>?N~5oa55VeF4J*lS<AwW<nJWdX+;
z?i|71_5X+$#zD%j8VNH1t4B9<6wQX!7qXt!3*i>Bepqv{?v0v|UMk!@wKL}>uS>Tl
zDPrkLKkroq2-<%`0KoCRByo-LP7J)}eZ}GJvxKuaytf$3BagTjHUt((^S3s*UopEz
ztl<ma=igHK?sNE;i-jI3z@QW;g>i3>W*sjT5TF9Qj7Q7c)^SUZ+#d9~5tH5IPd;jT
z_DFaO2rYb^eC|<$6YNb%)vL8foSess0Fp+YRAWAV)qdi|CE!h;P2<RwhIqI7fXAqx
zK>8wVS+8!5@5zcDWTo#hvY&&}Kl()PiHM2wgXTxX)0{gZE6*bytw(UWpFJiXbOrj|
z;OAG+3^%#Mj}iP&0RG2M^p=`)SDFw{?*8_4f6LRxfK}YWqb=*l+ND+E_|yI0uPC>6
zu}EB%SWKce*TiqU#w4y=<mC&zz=$<+#*53J!SCVC)rWoV`<VL`gWsM}JwQWQ5M&PB
zxTeN2;@U8QZkVK;f06e11uX7G#@==6-u0ZHCQ|7)VcWR%td{l6!|R2Q*JT0oBJcH_
z7NDkoz4qsNZvV@)g_rVGFN@#4sQqcew0W5s`SQf$^(yaI1^TbrOJ5y(`>M0_<<R3-
zEdAGG(`(kHONUyQwsCxCoA|@L=SRGj-S<8uXFQuweBKA}KyOSGhA#V)xZdBD;JyXi
zZ~1NM{BI8*|MvLjZ=AhvSM}d6{e-P$yj^d3`|A8(&YB*6YtMn}NxosHJ@4mR9`Sna
z(XxCC&v)kR)xeDB0OnyI>3LVrvcsgr`5}xFTguo^qPvg3Lx;=b@YNZ<`Ps;40E3^c
zH;=GIvfsWxYJ>dxme)$_y+YY8p>3f;?XJDsWmnIfeYe2m9@XPxM=qnHp7))5HqrO{
zfc3IJ<Ba0K&J~<+Dt6c9#XTKGUClfb$x9P0J)OtCo%Yh_^XHs)z5dbR=led&=KDc@
z%|Wg)$>(|U6Zzer!j<O3l_n<V=fBqMyMYsY$iXBkeUd5PDu$pF#JZ^aKBsq2WbOON
zO2wYR><fH?{XMX{bo;Yoeb++&mgsw40lTd(+81<16l?KI%k~%MzOQWtUs-s*SX-%e
zEXHyG(__1<&p_y8nUMJtAwJtL-=nwE%C-Q;x6=lga{_{C+uww4e7pEgXeJ6Xn<;cT
zYHKI$8+`ElnSDQ?lYEO&-|lAqxPR=&(uE%nx1aoYy#0fdxif}|dHMwN%;)E!=%0$M
zKUbdoe7pVg+8`gmg6<#8Qj*-gC9wVVnCNF)!I%XM&<bPYv*34j7!xtJggib8DB}ZZ
z)fhZN;yqnw_tdmhLN5cp+kTB$alpDo!Brq&R&>v<{v0ml=T;4B5s#<q9bVY9=*e<R
zADn$^SxDITNgS;zd81q~T|ZaM>6K%*Q(x%qBdoePTM0!kgt&9>!Y-hT9L-Swty1ym
zqw~3`)hDMy5cOis1^13V$`tr`39+Ycl}9${PX8l&=MBG0B@)*~wp>4~73JR88`x9#
zA#kBtgWHK4t4h7F?>$r^LVG0WuCC&~1or61?eL|Mh$ojyKBzq(J)Iuq{lnw)#`2jv
zS7cgrS;%MCniJJaKYxj1&8OC!Xz@BTwLX{{g}Q!g!u*8dzPEsox8CQsbN4QEYCT?a
z0WQhh%s=Ln{O#S>AC*<M`@M;laznHw-(YrL*0%w}h0n3Li)B#wWp;iQfkfcbSi|UZ
z2l=s#1kL8@qC(=|SjRCuOAtu}&Go(U?x6PQUXklY>jR=(gl^M)neY#NBCxKIS!|iH
zig^`Ox`HVq7+OK(RtZ(6N>?zBo9OOLiD4c#`uf4LWICK~Rd%tL>)Me+DyR0VJ@UWR
zez5v1A5=$@u9O3OT03QHunkvT#6Mf4+H!BpVN~r*b_EREneEF}wKtdT7`C@mno+$4
z$YJMkkJp>tEa(K?#M@fieyoH#z|e-*F-e?O+r7@sJDfbCX4G7~5}$pvw~>V3QMNPb
zo8vB3#f#iD(y+d3tJT04_aFe4q)yt4Wk7FWSkHV>hp?PjkAt4+z7M^xn`n5&-wU|6
zXrrXle}Rk;uW>C{)0AxtKYtnR7Vw^Km@nZ+b>^3-K;uzb8H=qe`Ue45a#kYI4~0)o
z@~yP?X1g9e#6G=NM^Ls2lt8b|wXf}BMvMj2`sD3??xR<d`1n$LSK{q_Tq|l1B{Ht-
zw%Nh1DIqhkS*TW<w?wkg1y|7aQf|8qxVYF>c4@j!I|H<XML!-IVk0lzVeX1lF_dlc
zZeUCmS_AhHS;Z@(Qg`d#UDAm<ccgi@_sei^-WN@>7pI$I-@HzAGL=kd-)Fg0k3?&A
zS^JgSPD2nmE=z))&3+lIy6D+uJH)PU`ZPP|Lls=J+<eYYX5#VcTrYBq4=V3(crbNY
zPx#ChQa@=W|DCw{79e2t!dEHoB3G;k1irs@-yI0u6_ArD@IM&58V!7syd+4{{~}#;
zd8-#B1rt9bK{XZZZ2SBZLkip)V(xot>9>8NSda7oELf#;$JK=;p^VAU2To^gCCj|E
zPE{JW0f34B{%A(`W9n@|#J0p6bN(c{NuK?Cu7!f9u|8L^fckx$CDkUrH&)`!t5F!9
z*|wXCMgcLRC6?=$NDR3inyYCn<z7g8f3q0&L~49eZ(3*vXXf{|#PXMFg$_Q-H>6m@
z2X$Si1Xr<nYDw=49ID=>VNSt611!26SjFA-8rzdVQvZ5waMvaeAafT&_5V&5cz7QH
zti7N0+9d2XG4_|*5i*mw+t%A+4-b6*XGYYTrC@9;amVfh`J&TMk#Wkj>Z`?WV1r}f
z1taiMSr$3Ttjc4&0U{HtbkU|Vl=H^L!+skRo_G16>tr+B7C^I7-7i*;#w(ZYo;Fdx
zRd1xb`UHF080`+0+uwB9b3BP@!N-B1FW;=(qq$q1o9@sg@Kk1R|0Z`l@vx_TF!INy
z$n~#w;Mot>MSgFmeC_#ek9hL)BM5C0$K;mItzye_#OiA^@eF8m+}*Y$&SKEX%7A6R
zJ1y)HdF~CS+pQ%BJeRh8#l$>w)~G8%^}$dK)WRvP+sQmY`xd-qv;1K5f<^Y$O~$K}
z$CY!dTgZqWYlK?6aYu-K^{XD~RaFCgY^Y<0_8sQ6z%s{~P-iXJof7PVtk&&N*O@D#
z{T6FjVK-yKS#9Uh(GjhH9rMc%wOuA`5d9QLnAgV%m-nhNVtc+E@<HghmOZRy<(nu(
z^Xk-`khwd!T~@u<|A5YeCkiz~wKL(K3XN_H38V6jAH#!9&Im7--W~4DH4izk-{tn`
zU0S0P$;_`vC|R?8bnofDu=uNzi=VpopFd!ZP1JdKvb$z{)+CZpyxeqF=HBTCZf|2d
zUN5b4)3Ns&BNJY_dsV$@#Xi0hnIw7H>wQh)(3)CQig1zl$59v7oA{`-u|qyz8+M-m
zI1}akuBc*IsQrS-OXCd0_og3#If91@rl>obnxMzlc8Fb`$~xfrfXgL`#WzaHE6efa
zOB^@d(@!kY)m_~p=TFO;c8RcQemlqR&nV^nL0KFXyLbPR#--@eFe3qptvVHfy>zuS
zU4N-v59Z8Fw__@*&-%+~Jh)5^yH(kt8zArU;EIcPvDS1?fI{Mft3IadT5R3t3$Bd$
zAk)}}J7)vc#~xgZ%8PA!rW>T4ePBoYrP!8_XM^;&9$e1^<0^z+Fk#oyV!mly+m3U=
zrW#8(%JSmc59ozhxGdcSiyBX;oeQx^T)K4(8Q*217iwR-bi30uzT4?ssPov;oq@dg
z-T=KY_j^ls$1cV9$Da%H-dehM0SSgvdf|S%mhaD+CJa@d3lG#-esDc6VYovtBGhGh
z>E5M;(UEfzk%`O8Pmqb@GkTFRwaX7*m?lo#ITx8Qw*2T_UgFtjdQsq|*T-9z63>4;
z7nQNK{A3%M#NI~eQ?hnF<e<!wF3N&Sy&4Z!c1})D1x!EtzTvt`bdM&;WxT)P-t;ui
z`nnOJg;8GABx(LR>59|&m>Qj~LB)N&1s#PF^-~X@$6i{yChHJ8yYa9@_-1m&PQSfv
z0@J#1t%(~vLa-{7L^45!POr8RY~#$nw2&&)L$A^wXt%#abLAP&MaPSsgYN>yf5&^b
zFa~x>bKA>)i>Lfv!LZ#Z;j1Svy|!Tt&w80F-p~f@X+`G~C4dAJfJSE(p~N$!N;baH
zEBecind!S4uYAGBL?$2j(V?1hS@(scPQs0%I|n<=(qB1UNVz-q_~Sr+`kMfQ)TMim
zKaI_%zm31Jo%(p|@zw=Y#zw9|+Ul++pJ&Z7K2%>wd#>^1%k}(>%?^X~S1wP!-kZ(%
zG;$&RZQ_$}m0#X%%@|~SsD1MNg^TU|8y7M@jXnACE<f}8GlR^p_n!RRn$7(A@j~X$
zttZ>tC^jI%h8PcC+0TZ}%a<9k5&rDm%j3u#HoA(<)z0P~X7dblSF`cZvnL8TwS((;
z{+t4gbipn0@qPG75y#0L{*yc7CU@mbil!OvpX3tTgBA)u$Gtcyu{ODPb8;X2B39(0
zqzHkBlC^|664q8Az*`ha9pRx~l&iXUu>GR^@Wn&Z7ZuJDpa9Z@sxv5$3f)gtmYz~k
zojPJXrRq4ft>!<a_U58e8jnmbosOGqXHVwP$IFQqb*;wKH>V8X(|Fw}4XcV9u4kf!
zr;Qz_P4*ZO&X%k{I9oJsR92@OeRSG#+E`<g&{a2G*ELnPZd`(%2{}czSDkS%o^f=X
zaq^#Wjx%vyBbWs9<C!Mz!(1MoV}gq_UTZVn4`)PxOCq0V$Reg*(x%?Jrbn$V31Tn#
z`ClR%Un0i=ZhI8MNu@hTr-WQ-LYzyH4^1P#n?}4bjqs$!Y+j1tHH%T5jrBB(4>yam
zGE3TH79q`+XU(Qg&!*j;O<$YM*qqJWoaGalqe;(|V$Wq66Pq-NRjzYObA>qy1*!Ns
zT+W=p{&FJM>AB6D_#$e42^#$$a5DsCWHSGQk-;fADl0l3KIEifn|xT_QBE2>cjcmR
z&;g`i6yzK<?bE*BfPxT>#t{#B89T|nZc<pc(vo@=C6_{at-DKHgu9H?UK?pC2Q{2W
zbQHa!yt%RAxY8j<9Zh#_4WDm|&_lBJ+snY$>(K27fH6Mc^8!pk&Z)Yp#l<mRUe49R
zEC75DmJoN6+~*`B;#1CO#3{Jo^?W_tqU~*?)RbLb&xn8*npCY54fMQJ4m;^6>t|-<
z9gwsI$(=W|!mc(x@-hzFcOcuh0i{D=eqHJBm%%8jQ95Levq(57<KkqZ)Jj+L_DJ5m
z0`;-itgCI6IpC$M<*lad(9(STfRtxlU5lQ!PgP~p_CrXx|MB9Y8jt|Wiqz~4cx{aL
z3GqFCP{zj7J<i!NG|ZpbkYkdPRM<m)H`4eALp0tXo*ON@y@HTC;56B;6d959XbdAE
zW_qPZVf&$orz6?SIH0G8l@l)c;}+_$QTVNKg1My*DS)n|=wU?+iHT0zzK^!C3>gjl
zzRKSJVhZbReelUS$yi#Wf>|s`8<|+D+L;<2kTlQEDl*eIsL$A!o?4WYK-X3}(w-;M
zkgaU&L9;S6yg!Ofi?FlMR`exDcw4Il*efuLT_2v)B73D9YZ`1n0yI?}w;%Cr-vi1@
z8pC`nW{>j(xNAx852?(=hxz%($I{I7&11>9<S<<+DWi`!lqTwTXU5pw=!TG^%R*d~
zOOg~_LJ9+Y8bed-K3)b|T0p#r$0w%pw<$<T3cetXJl!T*>v`4OCwH-bmy2CacRl&e
zi0oj!+E9aXqFrTBVs%}z(9_cZ)91m3E}Jy^F;jDm+_H8>-GEeUR<=hQwYbgDIjxj*
z$vvt(z$(_+jszlCg-)Y!9@&8|p&@};4wkmzPAQLHekt=ANr|slJz}9}CR0$^9cfYF
zty=}cL?>(OtyQQ5t%TBo7Bkt@^!RbYp%|TmA-d`z*D6yg3a^(n47eEP7)ZzBrKA14
z%j!z+*OuJ-Zy6bZ8#}C^ST3_-tkHjFWVmmCp5&O-{}UtgPb>Rv&=!mI-2uP)bLHom
zBY!)9^>?`0>*_!CjwPwxOs9gqV;88hulRl)z=}Za_nsdgJbGeX%HUsD_WyJ5*sYYp
zf5XU>K9%%&+W`Ij#i4D(W0Cf}-~p^<3neb4Gh6TY%V^tM#bwV5-xps!?sFma%pC5`
zul`*9FoRFOzkYK4!Ub?)`p@36za7AGTkX3umxambFa+UdqFdt5Kj3DO+?AF5jcB>H
zjJH+m{D5rfoRCk>gIl+u-z3Tz@$x4`40)if;BZO~Ej<l^Lb#|Hf-aE(UK)JxG+AeF
zRXfH|9)5s8XsTU<IB>6-66Baz|1y1a0Rsa6?f%gU#0o{a4*pTI9q;=I-O=y@LSfgF
z3f)LGz~{vS3<sN+ofWXtXh{5Ov%`L?l*6y&Qa$xjJP^Cz;z`Z?mzC|>gWj*$YY5Zi
z%RA-DuT*r|)LV$`LD^XxOO-meJsDzTLsShjFZx~;X5LLuwXr()!B}2dy44+{dB(n~
z*JyID{~ODGXU%*WAeb93c33wqZ$#ix;f+(RP_jbTA`TvDcuy|w?P-PFY|I(xX%E4!
z4?Bm66Hj(Jz8z3J@Xf^dqv^Dj;Wl?pp5fIKB7H7{4AY}Xb7|}>4mi6=l5X4!WwW_l
zHm^-`3oc{M3&s~?E+bbwScZ#L9{q;T0dmY~nc3b&4e+|p;?<qiIwh04z}5kyYy4HE
zTH4~$AMn$w3ikakS@SWsb%h;gZytn^P^ylV!z{}?0Ll73yu@qqzQ2G-!V<JzQN5`3
zM(}$)cu0Pd5aWp98sm@NzB6r%aJi-mm<VjD+~xgoD9)ttOxk7qA<N;<1i5$N6&$%%
z`6P{UgE&p&)7sZaH$`?>X&VMx?fv~FPe*BajIJ{F+neEg;A+_T^@Y)(m|g7!W2gwM
z9Zxg>E|<s%OMhkq8;2Ix;EIG&;=J&**^tYTX+Fa{E}5hcLW06-$_7Ux7Czl@0sGEw
z=?tHrhjs|_uNDb>|K0K(46FV5rGWGVzI)ZjD5m<tCkQsv^ac#Z4NjN;wz4lSC-xe*
z5(#`}%f1=Kyng8GAUOHZ=sN;f-(8ArK7>At_B#U57jpq(tFiXjMf$L9fN;pl8KhKq
zOua?E>Fyl-b|_I$QfN9y+E9up@=-`{4bNpkW(vgshI0Bil%oP$csJeTpv@rQtbj+n
z0Dyy^A@EcxT^e8&&_DAfM<q)dm*!(4Zre#NaZG1_qJRiZ0pOvWr_qP|RoMG>a`~!6
zspyNwwQ>+3eH{ji0RT(?LE7?X1aR1`*jj&RH!mscz)(31x#=rj^W9`$6&twW+8Zfc
z4tw&oM%Yknx(47(U4M(hH*E+37xtjPqCZ?E%dBOb*@ITn%e8D9nXcnsIiQMAu@1_U
zu1B3bK@@u+WZ89e*O@s}sTf~#MfX90+pY&-A2*7;)_uiq&zV3n%F808+XT)8Bh{@6
zwo80S723NO>)IV1R3nF`g>EhyNyRKKAf7V?==V+eg$9fC$v1?~u=5l}nf%cWLV}~@
z04Y&CA5yvvxGh&AuEL-x_DRF)=tTfZUO2m7TKpA$`miXOD;&Uc&5%&qvE^vvwXEv*
z4|5e`X!P=(Six)P5Qr$a57aQc`wYP7@Ep2R@rDZZ`WWhZ`qd73RT-|;|3lq-MK!sv
z?cPr+p+5<|C-g48iwV6GdKGEX1PlmL)r1;)Kt!4fh=_;?hzf`bh=__95EaA%%Cw?_
zmEx4|Kb>>E?^<iGwcb6xu@Cm<fWZL+ass*T-*Xj}YcA<AoQ~Ck`0I9PvpU4hrf(Gf
zK3D>Z4JnGSS~=ymRmIMg%LXDMO}(0;_oc5}J4g#b(_=OPhah)_MWjU4j2hIO;6D52
zOZn9N8)Q+N{q@=ldOS1M!h3?bqkSzn&tS;f!D=Oen~M;BYUaAzzFW5<B=??T;yM&Y
z{oIlD-xR)(ai*n?!b&EcMZwduLS05rltQ&7rpP1mm+ZEyM@$n!!#_Ay1xT7awP6T2
z?M7|sCv#?9tbD%RF7c{IS@pPxZWnc4;lAn6?-p7`XNo^sf1wbN+inbSkv@he-k8U}
za^WvL!nXE(NWdI;B~?6`o%c6$^Mh+2(8Yp0I~K2SpW0I3Gf=Vq;W+7g@`|;mIxJ{9
zI_zHFWgRsBTzX^m#xs022LwYziCKL#l?-9wLvj*gsmD3V5Me$`SoGmdu5Ls!t`p+L
zy$~!J?xw%2s&L48S%wy)bC0ul6q)4BaW3(9Ry~=pB*SVrwI%?~)%0@bJOZ1Tr<=9J
z19A3R*+i?@+IL&Sh}P%4u}tzojB}{PF@>|*q&<{am>0?k#aOoV&<`fSR6+D4=S|z-
z2Rx7szZLeN7FJzeE7~nm$%-`D6Ea^VU@s63X;HBfP~1Dj3ZzuYb<U!#X{lw^ljuRd
z3CYvB&**QM<kz}&X%DL?UjiFCcEf57^X|X1qvoEL>mcKkb|#g*MDID39Em3GX4uU_
zNFurX$(`M&SSm{He5qGK@0i@-hIw3yll1VXkGX-S3vgNQNJw^LLBJ0K#cBjpAN;l`
zBU61=+Rlsbd3~1h`U~aF6bA=O_w33`lCrDOoH#U+5q0&)%L84Qi4?v{O|NF#QT>BQ
z&{MRd65CazK?{30E$ML1z?-cUx<#`&+$Qt;8}oQ8b@7)1Vm%wApdDimi<ToG!6U?1
zS4^gPk#ae`Dx}%?3?z-cH=Aw8qhpkET>zr*(cSkR8Z=>rbr9MQOSznr9GmOnLvTLa
zN6h4)7hrVK7+Tw9Y@9OgVeW>$(ZeZ%{jX>DtyubeImq&d2VK3i@Et`I9&AwjQscy$
z^ae_?&|r$}M23ZNyHU3A;2bX@&Qw19ia_m_lF)^w^@+oyb=wl3Cp0bbe?xxd=z74@
z`3x45r@uqvWjC{;&%$@^O{0H@=;_|Ft5;>nlIqZ)D8x=ofQYN{!~N%TY*}MUhKQRt
z<j@O}pNQ}eGCu|fZP4}_`DCaW@LOIaIP1XqK4^%JQiTjfo8bqaIJhac2Ml3@Z^?_1
z;rH?h!l{P&pOO!Vq&bRYVeyGxi0n)s{!E|j@`neIB&2LG0~*ZU^@>jS!8@hI8RH;Z
z9As{k!$Hb%vdiJ=%5m+5U5s*dx^mo^uwPUHOq5>k0=6&=)WGfSn-`HP`XVJSrZ+Ek
zCNF*les_cLmX6<J1do2tORdgF*~SFB<qI$5r;9SPjF>i!8A2iZbE=tzz0BenX6a_D
z?3ra|g%N()pa4+Xs_KIFE`B2ef>}#JgJ@xsQ6X1iqHsuI^H`n%2V}x3?1+M+R}0gl
z!n%EnE~FOqRu}c#MW<dUy0Tg{C|W$A&BYfIJ>1IF=t;cMTRc7%$Y>#ur;BB?R5(Js
zQ6a@suM?(IRcsi{S>{fA<$@S%IDBk3@_UK164si$+dZ$8nvWz95$hLre;C_yoX*oj
zM6Y|7*+fDYA#_J4x^cA3=py9J;wdBVLig>#0{6*0MtqRYy_SH45kn9Zv`iCFNx;&f
z3^u1Ib+<%Xf-Dh}PvdmgV#%!~c(SmggQ$iJ6)N9R^@Awo&N7|NwFJ&!jG9)N@mc~F
z{N2+^w?!vd+E-fFR66ukI?YzPto^q~#yjnhZ_Oe9zC(ethl17)1&dXM8drt;RYizZ
z3Dc@#`l@1QtK!$HXkv#GjSnaJ9p0OEIJM?*df(y9*~9zS4%5Y|vy7{A{HpWPs+l#_
zg?-h<v(=?*)hw}^3geneznZGFn(CUG+P<3l*_xwkH4S35O~$p&ezh%WwXHR^ZGE-v
zv$Y*-wVh&h-Nto2esvep>UwMH`upkzX6vr3)eVZ(4;$By_|=c5)sNNG-|DL$pRJ!*
zt7nTHnKC{y?RVrs+L4)>BaixyT<27S7mk<?iD+)ROFdQ**<4P;;Pa7)qi=nVGFDQR
z6EfbuIr`-kNl6+0?ssgx@7RyoV?T|>xU?YbeB7p(D1r!y&2zMCNnp~2-y1OmNIP-j
z=nOIkZ@RD}2ff_~&ryq@5V;lT1rQA>%LU1%HCn7RFj62<BIpP-G=~trFlW_slqgNv
zeKf^D6^S6C&7npF8G=?hPryk3L2h{nvLvJB2DzvF)ClEOoQM-D;$TD%)ouuUqhOd0
zQiL)Ei70(7NIw`niO%5ag!ri_m%$U<gDtI!J5kHX8Zws>8=7bUZw5Sf*-+{rTEXF1
zc{LoTC+OY+aj=kq5J$=;n`<i-!5NIMW1}jTAt^2B@;r{lMi{Ul3oTR%gxjixfT<We
zG8RQ@B(SgwTIhseER~8o$3`b~a-E`~tmvRyrIkYqp-$xRA!7tt82ez3Fd9|}l+1Rb
zB$pA1^QU1VQjvuz0h4uPgk%FsLU|{89=nH%lxIV6G(<HUo5bQ^&=7_Vr!R>^On=0I
zPDpzh;Xy@=+M?*e=v)0Lfd-U06`@W?7zHB(iAbUr!XTJSTnR=I8#$J-^WsQL8X|w0
z=RB3mm4+a*P9GIM;;t$@a0`(IA*9G>Wdkq=s0h2@Q>HBB&st<K#PytxaU)`hn>368
zj0q+xCW<2t5xJCL<cVP5G2n4-z_>z?AsbpM6r}V+!eGl)3oF=w&?6$lY1l9-@U5bd
z!N9bJc6Y#TzXWYJg@gxpS-nJP4C2z*5Q&W5MMEjTI9}i;oac7FbQ*~`HhP}H5@F0f
zh!0V0+yZgNk&#L?8gdfi9qi2r5WaR8MzG5{$eeOeU-_H}Vjf}5LWt1020Q!qhd|sc
zFgJ-bqQy3Iiv~RGXCU@>nqKM&xO5@oQg7X*{!5nz<}O{?xHKp+Fl;(75->2DF)&s)
zaO={*_}sw6#sFL5@|5Z2>43`*GA_^5U4C@w^5eP7Pd6^lZ%SNwZhB=g;L6L4E3fOW
zyuEZ~Y3|C0jVsF%S3j9v{St8XTgKJZx~uD#uKt+2`g7wdBsqv2$XhZV#JdfCD;mUR
z3UWD#N?ja;C5H%RLxO=r!m;8HJ{gMq5V+Vm^x&qF>PoSDNW`O>{iY$qif)Orjl<jA
za76`2wX~1XMDgDFcwIv{rU+JlOz4ET<w9@=(^5mb3ZvcPkc~s9R7Qdmu9+jQ2@H)O
zS8&{vVf!WF7twI{Y1p)w5YXVA*9x2esCB3p(ENH`G-Q+`c$BL#nWu4dNBbxSaf1_q
zxnMk6lyLp4ajEoUxObG4+keAx4Q;={<apIgYwV-*h%z>BF`1b{B|L;6s&JW;c#*o~
z*?GZMqL33?q+DH)tOXxzha1Nwj;r62WsDu6!6kvWunRoJAvmNy461xP9t+-D7HD50
z)D+_nJKa{Na0-Pq67aWEY51Z#;Y;msWoL&-7cJE7wk+ZffpVRuJ!T$qM|9<8sM}4|
zuA3S|cZx~Zw=LY^2^l#VNSNTkCuL5UlI~zg<9vvbt&}_JU0lTS+Zqgx4^H?lC;Snx
z+Vw-=QE>!mVb~Op+sn91O5nOn;!*6Hz=g0eL;3NfyBIe!%;b;`-eVhLTxnsF*f{Cm
zb(cG264S_*V@!oLPN^atDU-MD5ED8f*d;k0s7ww9yUK!h1Vbc6aL#wN%I^sdO^Ht4
z#SKm3hd4#>@PBi|f6CVBJMYzVOacizJ;yzO4;nb9=sP9L%36W6ot9l9h}!8pCILvN
z=dkAwq-Yufc%r5aP0uk|-z7y!&h^hko{B}hmZqPUElpX;1%&T(>=Qv8PesAqz$Hc9
zYBy1aqNe1bVNJ7jG*+|R{bzO$#Pk4FwD8Jsb|G)xL+Ci{0VGbtCK06h^qi7OByR;0
z6(BrayWL;Mu^Or#AXsNl3D~)#83f#a#rm26Sp!S+Aj$^<P?o;?EId*y9JXk0aoe23
zs402t*e8LAA4u~75Gf~Ty*2@5Bv(sI+i!JCtqqt23=2g06wG5T)N5^zE7o;LQX<EC
zxw+T|(6zU?%1S#?!*Yu94*R)#+Bz9V`bRqlXWKiQ>N+GFxujMHj{$ULXKxzold{EP
zmzIXVp;K~nN=2A6&C}5>*nQ`A&%lI$eclndO6IXz*6|=k7~vUj;FL&Ga4@xzuk;_K
zIy$5{S2F`om$}@O6tner2{;k*JT<Ve!1c0~onDr2)9%QVAn_MuA64Mn4VnWEd9hhu
zBfDMl61=ln+Xn!U1!+Owm|_qHYzz8uB$S=%ekjH@-O+*KYrnnJd*Dc}itZNQ%EKpe
zJWpr1G=(LWt7!RVl{8BlgvDnZ+WJQj(z7$-Q@!uw>;s3gT)R@UYC?R19PD;Q+wW%t
z)qxmYru&g3SC*5DSxG?+Ej}-BS6*PiUUyg8e*c=$6B>d9^Ne(+CE48B)^@LVaamaR
zbeD3bb-%Ayk~JmLK*#_5`H{zcBG#&@F%cQIhH2rU2M$)$Kf9uQyt(_`bpqhRM~Vw*
z@u`)eSISCiJE{(YRG^xwJw;c)C|P5d{jpeo)y;?KWLialcj?2YOJ3I6jA$hh;ea5+
zs>`)fS$PdXR1*b-;LQbe=fR*<TF-$5_gsschl=lkfS!*>HY2@vc<iB{`#})C3vpH5
zrjTf&5(RkZ`TA|fx;wjTb)&;;w<_)WkK9o3Jc8YV|Cf6OT&BbI_UBse)cwf~mF{je
z&*qZ)2X1&$_aNnn!&f42wq#q(lUx754NZ17o$uXs#)BIFw@N9Q6VIRgu~%?;@+ZjF
ziM~1eXSVL&RDJ%h+%W8qQiT7Itur1@pZHZN_2=%^=3G4BhV$2oHf3D@{qB~`6;r?s
zpI6z@(Ls?Ei|JOc`RzZ{affs{+|HF}%S+i&31|kDl_!p5S@GM`+1Z$_f|WVBGO{C$
zxzeGjEGAT$O3juM)_b0Z?6QM7p(ti!?$&7|I3M}Mm(8#c_iHY)=Bi<p8)nfPS>m@^
z!xBFc(R{h`jRb;fkfz{E%iw;!7ILJxry>;AQWHUmGw5ltjOY8(LJKm<<~y7^n^<{_
zfG8Ah$jaKw4f(C8PzB`<HAdMh^2lRt6rIH1xW(YmSW2*D?K5KmZU0H}gGe$5bXZ((
zoN_8_S{2&Iv-u^4vR_Z{bi2@@!Zxeo$1$w4SG&<m7W)Pl+(g@?bC%kUBellG(Kkcb
zk~c3@sz7yw#Z&uztmMb+yO=%KExYyfG@&|(_JJH_^yQW)@8t?u7K4yw_rDbvymgs#
zft#++dGq!b%Q4~blFNO!=7ufuGm{D^Z_Gnsl7PKBEH4-)>vpEmES5?_UUz>-ku^<<
zyHG1#tL!M(v-Ih<)(!Q~;~M!7Zj&v^i$&yTE|r{ed^>fhN=PvhJc&#zhR@fyxKWjQ
zcm&^(OVPXF%bVg~a2gN&&0xhC`qFvJ_YMy1D*+PI9rw_0{MmALB1!g-xPZx0-iO=s
z10{NHv*e=1PJ!^Q9<&<|SrU1_iTxCLB7ilC)QDvhk<L#FUZ9Vx!*g6Kq_30c5EqyY
zQQsLu3BeZYmP#T$agO*AKJrozx7DSk3(w3qmij;QK`Jc?T3HT9J%86%D%C-ElX2W5
z#uN;y(*%k&+#N$1)d|1+nd>(Mq%|BKpK8&_=I*&yi)u*t<bl3NoyX>y!cugn-+z!X
z9_HPW-}86C4{!^|EPk*xM{8m-(L({(_$-V!Im7V~8!fLcTi}HoiG!dVEN?f4KFbR&
zS1>Ug!$sM4@A%7BB_L$J1+&M+W7gl#!ETbymD7L}GNSYG(<~)EEJFt4V0SBf^_m#$
zmVdmD3$nV;I)WH1fWd<r9wt17AV*E=Jo<v0D!Aw7N^I<urL<hg?Oqv<_Vo;)RN1n0
zgYb}oq@6r_2F`FU6AqR1rnKtAa;-G3d|DkBqI2*Pr#u14ctD=9gY`N!JhJ7(-=K%>
zvg$v;xIM?nQ>*Y6zVIEq+Wt6x3q2@^x^LMOC&%T-YQ>NERA@c=#%IjhIJ2-{1aQC^
zt!$)T1H>OS2rff<sPH)i4r<Zn(4un)27{?SNO#A)V+i&f!VibwAk5bU6^FSIIE$^C
zQ;Rb~vIMvij%n#dz|MmSvTw4zp4Y!J+AE#ImqVL>GWB}%a!&YNqNqF*C8WYy$vt}v
zRsPsa$p9{l?%<zxuP3kDv(M)4im6`=wlwln&8huFjGvPs!LzOz;v+}EVSoAg+BRrl
zxS2z&hRo)q=U+bvP>ss>V1Ib~N>4N4JWepFufkM47%7lSK`G87B21DY0cDDC{UeB9
zJs1+K9^@RS(=n+Hh%M~5NLY)(n+icCqE92I-2|x8i^q`KN6DiRILonV;`s_0XN3o<
zxI8{6(HZB!ImI=t(#+G*Tpz;wi34(?5%cWqLO#CrDKOS-<r1qSBk@CbT&x6-V4z6M
z6xRfwH|b55WjN;ftvs}TOo<dOinGFuu~|v!LM<#samsp3T8H=Oo!77|J~{J5deMJa
zin&`!XS(V!ojaU(P0Rp-Wc7p)Gg4#)h=@_(fe>4WNRjqi7^uDxt<D<8@-62&bOs|J
zA}|w^xy~o%NebeH1nP87J!(UT$DbFnVM83+idJP@6s;^D0^7$Td`Na>H$~nI&lT3(
zrzS?hL(6#{f(z*6&Ul|Na9?I3pdCyGWEKp5#W3I88A}w}ol}Fh%6q~HC5G;1tY<|?
z%=v~+1iH6&_nsS5a#Oaibiyktaa>cI?G)01p1IX8Ah>4|6oeacJ*FGmtst_BO#%c7
zl2A)qF_0CN&O@YcUQ%MCpk6lfrO}$(aYmwpo;u4AjC`*MQL1lJ3%7(r*A<K`Ro*UR
z)u$H(m5j)!C5Y};If#mYnK(Y$YeOj4czf^|-ew<~QJF4#ved3kraQ(<ruja%y?(oo
z`&-Q%ap=NCatF80u8O3_`;Axh&z8YU+dumgN2Qr(5Lz+ebtW?~$)F?I`F%{l2G}du
zdp=<wIxhT;qJ$!n8%@mepi#JeTYJ>TXi<=FBVUJ>^$E4DI}Ga~$ajoRfLKL5um{@L
z=(==o!K<tt5omSgT%4j7YSmj7Yg(1nYfb+sS})4>RsIMD?Xd`)Job$+#9fgVrLH&3
ziQRNf+gZ4bRR~T&zEQN`v_U{VGzz+pyn=LDC^XDmd%>HUtrl2bw57M{rHpx(pg4tg
zD5XW>bJrG&4-IH8qhw@C>LB-rhJ1-wB6rHnAn*A6{pNTw7ZTJUKlqT`^=!T!O5N=r
zd9AsPyj3CPqT|!@#P62_nm=-`Tnha_q@SD!#(LXA-nj)&Mm)$Xg4AK8Z$thKIXbdz
z+YiW>mW`nXe{hM!ndgP_ov6H`c9Q=N4!4<w5S;(oc_3mba&uiBw+AuN{QJAhg<dWB
z((+k1?6mhkJBVjltRU^Kd^&vh$4jMc=m{V5FZ_epFX*c#r&4Y&a~!0jSxxK6knGLX
zA(@{m{NX>IZ@ap7-}T4c*sH`lM)u#1+)FxWx6gD_+3x4Q3Vz1Y)lKED1HxSgkT?j6
zA^>j4DN5k%rE@IMr4#5V1OrWCyiZ|>Rx?KNkoXMa^bkY(*Ioh0)`_=Tozvzs3(Z<&
z1WX~a)T<NI6JR)0@Yn@GEzxWfJG}8l!d6j1<KFB-ootj__Az{pMJwYuP0X%3M=CYR
z*$rig;N2>Va7oSet<LrD%?+H%y|;i263x5NhzRw~OPIt)ROjhxhifwO<X1TPy0T)7
z@|70yw7Qf~ZZ1i^`J9tPJS9(v!Vl3Dkd&OvRHizDDU8VH3E^RGDg)d|D140%f}n<A
zCLg1qthaziy8tFJMZ0p4lfw1Bg({@{mg+*)ko>lpLi3?Qg9Z7H*1}Gsq6<+1M^lUX
zeeo{reFEi0jwDM-qUEJ1nGqcRvljnVBRrAJ#372eJ})M?`9h%0drYRhnkmXCgxI>z
zWO4JW_*u~dr-^c?gyM&*%Fl%H=SA_UQSkh7=}nlo*bctI;yFRY&)skyJybd(!nbiB
ze(#I7r<H*~8!rNTgII*@;z2L4nlX^Fp+Om$@za;M072hxz^FBN>p?m65ErDC{k0la
zFovHj?^j8KPw#{urj#R){9ilE6}ob=d<%%1v#@yR!Pi9aYyrZp!TV=;zZzK}Ln^iU
zh))nw1VjlxA{Vp3%*H`R(eQ2>>?6x{eNgrz2lSCvigZhVfP+3Cu7pCtZO`IcsN@Pk
z1koz+3suFw1vEGKK{fw_)Wc!MOyNP<*0GX^8b<6Jf>-ombk|`<T5fhtb+HPoBu%gq
zf(ju>hFT*7K~-?J)LM0Y4P3`5v}Lv?WVNIzy0FNvwh5ran>7F(b`%KWzSQ1F<XNrM
zbiZNrhzSCE*m$_kwySO+y6TKry$C>uHKhO@Uazjdb*gA^w*KL2y=r4V`)1ZuG``mN
zNK;Lj!Q`PwYtrM<g2J0?M^^Dio1*Zq)>0PzXbaJTJNu3<iyeEKaO9I;;TOMSb*aZz
z0XHmQyq`U`XZ4sCrS=J~0VCUh_0PkZ2)?Oln19o7v9|%fl}j*b^!IJFW|Ru|H%i8c
zi#}>JZEYl)G|BrnDW*3mI|!Mun(}>9)YqG|`o*6M9=~x@&fV(x&R%|_{^Mqkj+?I^
zCyO^*m^54YOD$8I?P{AH`kS2|HM^`gQ^ilXo1F0UKjEEz!ngK>fB%WVM<;^TPlO?O
zf=yb&+k`^>TcT=PV)|QRAGO4<w}5P2qRGi5|C4*uPo~zMOz%IL`RL^S^^<h*)-03O
z9RJq5^j2nVYhizD@#dq}()CuB_^Aq$Q<eUws?twY*Pg2FKUM$e)Y0`*4dQK0CT-3B
zZ7u0-t+j1!{cY`!+B(+TI>k?So1E_PKYbznbZ_nH{{GVgk4|4%KRqbkK5WuH;@>`+
z-ab~_eyhKI{89VFdOKVE%#_KQY5y}1($Dnvm*N&=q!XGw3eL>?OUsCN++~W!*mu0H
z?ReYYvGhntd8Xq4Bj*Y7><&^ciGlu73yNxC0P)mVXKfIOZ*QwmZq?ii7&9b7Xyq(4
zCt$362%wx}^Lfp!`DzY@$CY9FY^SFiudY8lM#ei=!&CEhlJ5kwXuRS@FgByxb%=#>
z<Ha_1rlrDan_Q4w2K*F)6yJ3lt?=Mh4vs71zYm@>FA~tgb<sGxF+)tp+wkhGv$nSd
z)cjEoqDa_XBw>qlXi^EPiw|O--D-M1L;FH_fbh5U3rX5lVPfGijv}1%Xct<??jqr@
zJ{ME#E~a0)m^pWG|Hj2fxZW(&-kgBmyo_FEU2ox~-r~95(v4o01W-wRl>vPqTUTAz
zS9__iey;E6Mqh(Of0Jo{b3lJfMt^Hvf7_-0_PPF!js8xFOWps08%hjV1pLVjg&wOC
zp7#GQ-0+>$<p+eLTJ4`U6-8X<2ycjOKO4^It_(m8S3KM*sNwAeFyE}5z^z{4cg!n<
zmCG$ASKBBD%|b5hRlRC3Ik2U?9FuTSv7iIlPWb5vClv|c>O(Hxx;ntvaWZCbr12{4
z778^qgj^WnK@7`29^xAsa_WQmml&q=4Qgh1je*NrKVaxbukN^rzS$W=GXc{L@MkMy
znkgpEBfiy4>i1gM(n-SFOk7wUo?<1gXN(wjjR-AVD5qQ}f+gd|<9?#&1Mnk)QzOdS
zXFYpGg6d)WB?(vh_4t)*@{`wodxwuH7LJv~CrFOUtc*&E-`ME{2WAos`{86siO401
z$B-~XQp7fMjEgJex|<W6x&;6IoF@cqb#!Fzug=i_s-Du=772J5z+eD(ftD#y90h8q
z0I33$%i&ku6zH7-U<?o}&@TmelJ*v=rpXS_O$92T09^yUQvhPATf}a$j<<5q`IBRT
zR;ncWAuV-p0I>kjQX%gGKugzQ4**)gH>IZN4fvU^ed3PYrGTI9OscT4Gn6Mfr{x|o
zbxl%|qiWmIlBr#wyvl!9iJG#<fwW7Yw(1YuMTye1ile&NC~b`flnX#CfVJdIBc&y5
zBlcGLd3d?(pv#iHW6~=37dECRRmEl20J6m>K3)@eS5d)<Y_A&Z5e5(!z-%fi&J5qi
z5U1Gi#A0S(d%SNtU{?|TQ2<ue`rqH-9SA5CAXN_b+jj4(`IAwlx*c|Pu#a*{-RThr
zxD-*rE}ohVNRqF!A2l=!@G4MG1(;SKHQ2-1Nq38<!;YMFHYPD}ALzbva@h*d9VlS}
zB+PSXKJ7qV`St-o96?1^it}NBzDj)uirfccypn;5G1_-`phKu_z=63w<pSry0RLn_
z#qzw)q&pweQ1bwA%gBn9%WB!_kYwSNp6p$?%OQJzU{zMo(IYw1fNxn*BAgv9b6h)j
zXO{1GYXSsIT->X)sLsdE-_3=#IgK>bci30ZSXy&7HM=H0^AIqnMMtKEg&y$sOq^_&
z?X6P>bjr%oGCi%Jwx-G4)MbmwA51IzK$*EpJfK;CYyrNt&1{FgZDhK4W#z%65<0<c
zhie7#=F#@`SqJKLb?iq@7|^YTY*f-33oI`7jx{uPZMTVbwBOAts{zm}Cr+iw`}Nt5
zOWU;dfGKWY$}!-JOQhxdMHjpq6#~^+X-N&SehPq%rC9V>o9ai0G}HG4KJDeY(IgHk
ztQLlpmxd8(yPWf~j}0G606Z)`R4L!~W{`_US%yi3x6b~w!#mte_QszBCc0hWIe{Lw
zz)%Ok7-*%cESU&&G5?Qv3_c|0ncMX*@z_5s;TV_8{oO3R{Ba^CI_A{9le}{PkNujZ
zx3swZ3y+EF|BG4r%Q3saoG0!&z+(>;yROg=|7EM&^@pu4mDoPY%2lnC?CV~*QKkE<
zdg|5R8rR=2e!76p(Eju99(Mjucnr*W{@J(=@L2g~=(7$#jz93&w$1Z$N2B^ay}oyP
z$K5OcewH3BEPBtoBrS42i^pJfI*qU8L~zco-}bPy1tX%Qc*QkOAR!s#U?WA&z_W>q
zq-kYYsAw*TD&V}V%qmvs_Y6yu%R2s|R7w#;H-{DzD_qs^V$CdBvDq*y$@2$!D6S7s
z$2<iNbuaF9mI}|MFV=*Wk{ygatz39}zh1M7>`0EN^+~_LV})~>=7iFS71SEuL$eHW
zhH6eEW#`W~lSh-jq_G-MBvpLlzHUFN1Rv+4AwfvAkky3LUyiJ4;L(e=t6m3Xro56v
ztP=rFJ@%A5cN4c(C~5OigmoA)H`gLqEBx&dk(>Q$&{grCe9CsX^7Jvx5Y1X1YCdI6
z=_a62&^SRbu7&4(!h7<NX0t{o6g3%l6q-(8ccE);zp~g_db(8+m4F-+IfWz^SXZ^x
zu`lDiPP6)c@Cn|r4ZyBOSYHh6IeCIln};j|)srSkNM1{-A}TI}Ed<T4UAOCymRD;o
zmHv`&12ee-j~pi^b(6OkF1{B1JetY60@b@y$58twyKhQvn^wA0c!iQ+VY}GaV|9o}
zubpfrk~4ag>LmZsQ%KO0@&Fxo=PTLofCl>k^cp#c>D&qps`K8DnUuBA_55lvIdO+2
z$Tt5nN_InS26K-pDkWh^$XQ-xDDNycSuf*ux*DabNt=D{H*x7Ny*!vK%v03;@?Hwl
zp@V%x&(v&60b<v$*E}G8Svt4=oHIonDYU`9c}5_dNg;7061HH@C1p`Wah_(B8zPlv
zpU^e$=d>XjYO8&xMb9O&t>@(!i*n!otrjgPqV;7=V?5l<ebdnx%F`=hf8Dw60y0!i
z0jwWPiAB>_H4cme6l$l;cl4)iS(y{b!r6Wld2D~eWEt^iB2Ez7!dkw(n|Qrx-m(My
zCvWE`aiHl(WMxm(e3>U++hfOz?zUhwvx!PL>1aNz;LQ-HotY@;JptLv5Y0Nk&AC9?
zOn-efkHrreW#XD`#@eKj^Gw{39|a73c`C4pWJ#O=CiJ>P$VxoLa*U5dwx98X%**wr
zj^a=S4=3mBKZd%7;!eTqxm!s%X^}VradckdNEv!IjN+@s65$%*P}f?Fs{F)X6ZoEF
zyNB5)%Xv0K0S{#q$zLE(>Npcd@R09_D8@aX%F}!hwIZ)5WWfw5(TPMe0#tarneQ>N
zr1IkCD^VN{j348&=cY+#dE7^tX7Nggb8wHLV28Z<H&wUWang~)3{#$FtPzvR4=p2k
zD(ShH8hV~VawU1Ye3A62rwe>u_+-VxBT)&Fwk>`F3Zmh4ND2~~@7!bvbkad>5fZ=|
zG&J1+9EmoZ?KK!E7~*s!zmDl#s4zBm)`%uwyXS3j9XIKrs3WQj`7a~0APXXS<`uaZ
zR80`9j%i{Rc_M@axTh-RWiVvv9aHG4(C3`RFjL_RCq%5TB!2sWqA-_{IfO*cC!%(i
zrw?+MQX5E%Vs_pN-CoQjA^F8MRp0Bi741REL_xcEeqr6-J;;VL=&oyC3+eEAo$xbB
zabtm;p*~ky?w>tiy(<_q=Y3xI!dbH+G~__W+CT`7sxb>33qtD<LmEiRqi98Xc11TG
zqo90>;${L%_Ga-;hfF$mWfv$wiFFRv!vYb71-m!D;UPyLy<ydCi;5wf#Nd!B*Hn&h
z!`|~_@5gzp)L6njO?^5zgxr<c0KVSmeMmnf-;dQSm`5Jnv>ea*Q)_OqHbr+U98Pf|
zjtO62q0}LHD4dPXeh{3iKd8h}+{tyFYYf|lSoTK`)Cq_;=c3nQEq-uA7Q$!&^}$zZ
zN|H4KsujaB6l@;JBKU6LDiJ-?=`e~HB-oCOsJ!XSzzzP_oF^yI{qsvcS!J8C5~+%?
z+Amq^+iY%@iV+q`MXPEzjySS3x)(p`y%>929zu;}hbafl>WB1qS8d;ut?_G?evehW
z{I6O11d?rRyC<*SCF4!Cc3)23XHNHaNm`30O`LODlEg=Q+Mv^`_;M1ba9L(@Y$hM?
zUV%GNzfq$V+T#9smi{B{_`P3qo|h{vb<sl2e7X@V3#|W%_51qT`jl0kcmAfB`xhqk
zT^_f*3%X|2bmhXQwruC6P>GG1v6eSgz-Fq#v4zXs#h?YDAxFN%ltoYIKs_4oZ8pSY
z2ZYBik_hip7fa`mVjTUKo-||(SUrHCF9*?|qEZDG1@0=hsuPEKa=y3|HzO`KztCg3
z!d9Zkym5NrXegVbBl6Bu1E?*K6?OH|^K)E=j_q-~{WEgJ-r3-;W3CXRn@1HsZ))O>
zC0u6NUMeOU=#G_^IDNwO1z4%6yy@i_UY2Fe5~o;<xv1dxj4v5;s)|e=CAU4i)|3}I
zDkhZXAUMxeo{O}5z2#KLpL3r4mu7CbeCw|JeMvK+&*?d1ukKuilHBe~k6*cb@85&v
z-+Ol>RIB6r;{4_Rp7Z>vkhyK(xyUw!(Q}us*{2LJxzq8tu7)orxQ-oEaDA(|=jZ2!
zyUtn`uIp3pB4%1#FTeG<yZ*<VXJ^^vC5?(iW^ckb!3*dQV9s-Sr0@G6zxn=Y#UIZl
zHdl+4%zxoAFz3lGyYl6v>+hdq+SkLk=zY7|Uj05}b7P+W>gMVV*Poy2Hh;W!y}JJJ
z?$2+RHh*6(yZYmm>*o60=Fim~?(aX}-TZ6Lv&n{r1aqFLbX+x^tC!9*L+4wi!=em=
z5kt_IA)NXL9{Z;`&%dgts<Tvkv()Vvtq-#R64Not{--%l^VMv!XpV(Z&W&$bR;f7v
zj5+k?IQ`e0r%|q_Z?5;>;jy6A++fkXP@}x?KWue*QPqF5)ve~yMDr7k@{?wg!@cr>
zt&SI$oIaDke>I=}%T|{o8g<i?X*jtPJw)@q2yfYJVsfvfpvt+Bqypv`Vf$zzt{kC$
zm?qW5ci30p5x#KOq+n(*;VHS$EClqprGK}<F9gG<S_}0TBJV*^FD<`^DYRigsOl{;
zSlMIbgSUr@N0p^msm0+#vARvg6RX8+(UK{nl4;+P2dO19)g_O5OCHaZJY6lB7cG5m
zRJ!O}`ZBfjb#>|6-qNL+(hsYp%c5nUjLN?FmVHYtTdgiz?=AZ=Q}%PU3=(4@jag_v
z7B-EAt6_2Vv3O=#d}}ONtejw6F6dV-oK`McQ!eh8X?n3-`c3)qRsqBB<tXh6`Lqh<
znhMpv3ia6v%`}k-EqJN3LVK-(UY!c=T%XCYBwRw`*#tfVPWpJSn2`#hBq`hSjgXl!
zEVU-s!OXT-5mcNlaa$|*5~~z6j`ID(R;Nf#t9TSC6z5&COqblTCN`l}M4<57Y9G|K
z7u8P_OfbfOUKWg<#Yf(R!wLjH(LDC~;bX)k-a=9#vtqe^*%^JpSF44K?Du|y#IyTE
z%T#3Y``|-;{{MKTBEgkf@aswiW({C)02RVAG8B1vYZ(~}X=#d_oE3>=DIu{<UfxDZ
ziYz9!Rb1R$R@Pcve5<Q#G>K#-DY;ES!5Z}Y5{cmZ$wVUfW^*YibA5eJC#NXQEiPno
zkhHY9h=@sa%zj~EV__i^Nl9}VnQh9-_R@d+Kr;#@$i&3g&p$z3%~?>;2!{17EOxlN
z$AyKb67U8Qk(sX4sKCIzj*gM8t`RmiLEFfF;Kdjj`<R>ihli)Ty2j|}P(?*dEi8g$
zq%9N`ZFO|qMMX_?bX?8N0~Hi(Jv?@)sX2&>ngs`^7#e!IxkW1}*~!US+S&#OhwOFt
zh>?@E*4C!(Ny<w~X42^glamY5Gm2BwiuUberKJ~vK$*99qK>wwih_r~f3llfyube*
zEiHE!*Ki{v(AT_cS8TegORSyUPEAc$clTW`F3}zyvEkvFk&y?~)xjQyhmY^Bu&{jr
z0ed_>cFW1xnwj}&Yr9xkZ8tUb(bM<Xwrz)!qFrokR?M!9U9p*N?lD0@d&0u^67WWn
z5@bn9a$Fq4*w}Z+j^ypzlXSG*EiHFQh?^T4cpDgasi`@VNEX6E#z8?zy1G<R(XCjF
zx}3aqR1`fTGA%Cd!1nDl8=Fuot56@`-65fSot-1h&3%3SXwlK>;X5<8Z%;Ke^m1?v
zi;F+t=N~U3Y-(#8wtF{y_wMYZ<U(3PPHJjNYAX054-kWl%tF91_NEkM?ki5uC{0f<
z&CWRll6QrL^}x}itM03z><ehaHodTInlT$}^yVD;Z1_s$!6R=*gk_1o_j^cvN3{*K
z{bNF!j^vp(9BYx4b_T|u@>J!lIL$bJ1+rQ2R^y-)*KP&*U~q$jY#<{E{4`U$ZI(L%
zGwiG*K+sP`ff^AK73!wuWEUeXWeXB~AkZf*<q4j)f)E@?v4OlB2*-gW9muJHa2yEG
zDJeLEj2lS9;RUvXP@9NwsF2`xKshADd?ZEep1s?EetrDMD^--kWo+z!yi(ihd))q9
zw)kb@U<&fo0=-HnD9HLr{dJ|D3mVW{DUdz$=U!{9Uxa!_?O)-q=(dtSmMtopKD<>p
z75V30>j&J4uzN#Hg>{F=+5#_bn0rt_`0MTSTh)JDseX$s6AhL{2GJ4iFD6^TvW1i$
z@4JWmrs^Zmr3<s}7vf&r)cB(J@!4QD_sM~b-h}$=JH?GA2Kqjq=REqyE?EEM@Pl)^
z&Wi8*-!O3;z>EGF{-XWl#d+#s6<2*3Tn4Y_?RfkJ7qb7uvc>BLUDdyqEyC>Xj7PmF
zF?!khqSUO`+O~|0oqd{v!pJpoTI{XlvkFn3mWOP(1oK3&`u005o%8St&~Q}E&O?~5
zp{#0%smng(6Kc#ph^*<OiiWVF*;Tt9Aj!4J**DFV=&fRTM^U`Q*ARm*rnLcr9oUWe
znhsIN%Y<*WHe$A#oN6j?seRpo^h-Z=yoOJ_t+_VzQFLobg~O>+_EmbWr#nYCRn-FQ
zMq?)0dtbJ_>+ov)%2ppZ>Z9g>5ZtxYHKurasT%>YmuP3XMzX8|lkn|%;}NIhE{s|`
zvN@0%H(A0Ds|;i9=UPs8bg{*Au2}|-xPQpK&K11-@+~eZ)cqaXum#i|%hIo+MAYgp
zB9GuTEmOwpLXbQxvIP<u9t<JJROcb=C>MDU;fWiB&<OBk8;g{0fY4|nYY2@r3)Z6H
zY`=&>jYfeajOywFgA?1jVtIR=FZP<0y6^m13~MQP5FMGRjphpO3?7tGp;1RMVUiT2
zkZyj88Wi^KaRWjk*o{*_3SwkSW0^m?A>)|}3oN(qyoE&3*k<rGO*bIvwn!G!(4?f;
z6*PbEKqDOzs@6ygHkFsn#-SgR@;Esq=P8ns!R#zS3ejRv^5mG#b!6b!(5>f<R%|jt
z7T1s~PbN27%PZlu);^|-u{ng3r|DKg=UUl=*udhc>)e&&%ULMJ*944!OAo;kZ-*nI
z#Ingmgmh<f(;$499?HRmS-LU0SVC94>BQ3zYAt7_-f6|}+%s>Z8HKarv(ZBFi-z)&
z2GP9rFv8ua0peC3=8A`qJW<0u=LP5}U~(5!hf;~nMOeWE3<r)9PG8PJeqv)3el(yQ
zaR^?%l`Qp6hKT(<sFrLvi>c1Sb1gH3HkDc15XB7~dUS}Mw*o8Xb((nj=3<tT>GHHt
z6mPYKx&=E2`*=_&!-&G~Imsz$_MFQ+iVk^GxhTwGe6;e2;-hZ`8q@|;*KxT30*w*2
zeI7-?4Wb*USp;GO8nhvy`KSn-CmH9Eijh>NF$Cl*Ao0~f4jeUG-M1;_E`gwpd|}lP
zd`<Dh(wK_%i?d;09U(&M;NX(NIX_?%#}euIZ`O_(Pj2H5g4$XgtLDeW?y@(+?R9iV
zx{@`x5lAC4vO1aWo!4!9Wr(w;Fs))|N5rA42`v}6zKw^y!D~MKVP~RtZsIEQ^O3Rc
z!J<cg0_lk(M_(1&ott0VoXGrZueHQoH~;Z-e+yBtZ1Gk$;d%@QPf2SOAJ|{B)6?eT
zC26Al<tCOaiEEIujHXHDewL@KJHFLk_u%BgD`V0eel~%l^HY_?rk3KNd~$H%y`xta
z#g!8dy5>7fH;I2ecHOA$*Rq9)zVZRzu|6BZ{geJ*iF=K3&X$QDxk+E!Y^|+ruB_u7
z>4%!VzS_ylhN80d#))a#Ol!;LymQ?OC%9{n7LqVtO>j|2;)!yQ_8#4Hnb$h@YmYcQ
zxW(#|ebAQu6{kT!X5UavZiAw7DFjuxP<o_`>&<Pl(XQDk@kKlmkKBO?wa8M>l5N#L
z6FciMb9ob&e4+QwnfR33bNOauB%zZ#D&yVMocl=c@1%}I6^oO<i3<rs^bX6X{VdL{
zWFjV6lNFU+aY%9TJnGan3%bAJdxs80HEcIa9WJYJ8Xh?F{DZyA5UW2131boj_AT6g
zw)oA*oAc0a2bLNhX&Ej(`}^4}k@0z~>FN+%+L<<_vcMIvIxPA?%uqLWmUquTE?c;C
z75a?-b)_ckH&cIsdvR{`)wp75%J_>v!e59p8mxS$MOlfpF*}#U3e&blMN>cP=zZOl
zCu8vx>e?;eiSDXwUC1DA?RGHVIj=K30y~*&<54c>Y9EfPDV{Ul^o_tm`cDUre>G|D
z16S(N@8hq`H`eab`Fa{SoL_Tnwz8QnJxwBaUJELnoJ`L9=PT7EWBt!7)%mS^-THK^
z%lS5+J8vbV`tNs^o^OwIe&;{8{-Af_d`HTicR?HL4+r@!bmsqcrMg_`K73~>!gOPn
zU3#JC<ljsj7cRW{{5CFQV{V@BVsC=#VnW@<<JT@1`ybx<u=mo&ljYKj1FxJvrq69W
zU7fgi<@=qF`!_b8LHxag94^aQ5<li~uD!z|6U%v~KNbiPgZ6yH1g0wnEe{V-?3UqD
zxseyb{C#6*#UGcK<*Es8A{aNXPu(ZL@+d4~*izobo1qs>?8-HU!Zle6?LS_T`TN=V
zE?=4?E?dN#r~AS3aEsx{8wZiGkW)ww#<c$1411FY=aKDMJwBwgC_8;Foo{FAMtaE@
z4(RnfSHbGgl63;=@v|u{(;gCOcP~@>rOUw`m4`nb($<>iICeB1mR6sMezqWTcXibC
z=L)NAU{T3+?N-3gPt|t^UK-wAo5%oHD*xrzw%|&w`}w8yuPZgX?{NpXQX^eA9?kvy
z)_eCdxKcNsZu|sS>Xqeu*I!ranCqV=ju&ln6MtT*Zv!^hXYOA4cJc1-AO7n~m0A8?
z^$HT`RoTl|LH`=Lfmps8Z?(u@D+ybzVAALtr%P@Wev#4D|IWkRb>OBAhI9D<4=I?d
z9I`LRYhHx;ariGBkboWj<w*j%HP%fSPZ)#-y%JC>kY^_ytOfPBC8AfL$3jxKNwDX9
zqNi3CM9)H&Lq&pt22s$H$t)Biki!@Ggd$;pgL)7-4~3)%%M@fILbOv-lm&UxvpApw
z1QMO2oN-+-8v|CTRv=e49jVPZ>4rtRB_7c7!LOqAm0`E@kRI?r0ALPF1yf<YRmc*;
zB>N)m8dAl{c{0n85(KG37(p`P{W(YmVscZVdz-Rw3=Xo_<`gl4#e<QS!Ej|1yt^7+
zRf2u(VvmRx*3Q8Cw(ybaEZ#;0sP)yR_=Do|-FAgTqqzbJ3>_l=nm*jV9EDma<R!U6
zY^01fQU;MnpcD;86cOAC3=qY#_yCY?<0qjNL>M<`VmD9HxfY708gnp+64XKwL@eEc
zNQ63zW|iZFTH#x-@d>ZJ^o9yCj6^X;X~XN-_o7)`lchSZ{jfvD<JE8{4w9!9@Kae>
zM6O`({uLwtkZM>*G+)^kX;KC6He&Ivln#4~iqFEI3>nl;&=69Nb1P6TfHi#>PjL`t
zwgSs2fr9r>lCqwx1a0J27org?bVx=2%Y$#KOYO8Oc~=V5C<S%Zkd7G3N*PuNuH-`;
zqN>0i_J=llVXvF1FFOwj4IPpTi9{i?77hOhe=*8EjY4vVvZ{EsBQ=MrED(oBM|u5U
zR*6;d{HD!Y+*mbk!xzCRqN5<6$Vu4iC%b<wB->u3Kt(chmc-~I{QYH$gm7TGCmoRo
z<T+SX1iOG>GEh;`TSMIojQ^P#+9)b`gE>G|Wlw8sYb8bMb{`fvV1Y;8%*fW#ngT56
z8X8`T3O+%;tUS-N9&Yx|u4FS47kN1^BLi1o_X?_;xvj08t(}#+x|fZUj+&a+KHp|@
zOGCzv!^c9|Ud~`n$2G`)kG~hw$%%3#cq%Tkaf^oQ{_R!Z3buAMtZM9Yb1VcGleL4P
zpIr!*8nZJn72HJN2-VSXi;X=H6?zgJr`xn6Hs`P;k`KrS{CQ~nKlhnqlMZEN=j7()
zGYblfic3n%SmhN5D-Ts2uI8z(t3Pt|SVLpe@#YgPCtFXooo+wVakjIo`&`fY3m1F)
z`Y#P!zH)VNX!zR5_0bz+H*eh@zcX={Jvnu6`u>B5GqaE89zS{dY<}VSi^bnwzIy%U
z?YpJ-A3iRxeER(5>$mT#YwH_7e*d`%p|~XNIva+vaRRD=WB+2Y`G0<X__xi$f3nw8
zk2`?NEasN*ujv~7x5XWQU1qM>+HnWZ#=ZCRc*Hiju9uvS)qG-=^pS6>NMpC$73L3B
zq?srb0wxEfs??$q!mgFdDa1P#4dwHR0_zIZbI)u~o2dF=rv>#5<s_onW?ziH^240q
zjEWNbZ!wSB)%skviyJo0m1W*IdVa2)cB|bgj9I>7)jTz^#d?du?>@<kV^)s6WM+mr
zcV!IKWa6f&>gQ~>2=aivnSyY^d|2cO1U<`x$1EpxD2Tcluz2~RJ^f|itJ3t(*N4ey
zkufD^b}lUXOdpngeuQz%)5sxNA$6*eNSdiYDt;hkg=Ae+CR=cB{{B#k-rOr9t5~1*
zJXA~fTjKK^W)w42m!}~(i#K~Um08|GTw`ulOjHkYAKbQgaS$h5*?Y4zZ?T$LRZc75
zO50*JgR3e^HOAFsSJ&L<bJu1KbMp82Fc0l1O_4m3Y>=g-mC-HxG+O^lbZt&4?v`Xh
zHZJD3#&Vqai7dPw{OWk+2VFW=oQM7l$zN|1b)vy!ak#ay>h0vd7DBRRTl<B#Z^3D%
z`mVj_LCm`|zb><ZZ*Sk79mJ|F{aS4P^D-+y4=tTz+uSZcH|5RE;&~8p`u&B+dru3r
zJ<U_&KL5OG*N48>EvG;9FI{-|;nMQxuf^tFA1|-IJpJ*?k8kfjUWMue$%AN-*ySOd
zlG7VBm*LX#HP~lENNpy_Jz;Z1G_oByKvMpgY|dBzG$wyI_R~$}lkJ~wsbBn?zh3WQ
z?B_d1ui8IPn0;URe3#6j@r7+A68B}&ZsUvPl#}86FZZan8egY9ed4~}2b0ZT9|Wen
z|N1ca*l8##<Z#@#*|U7b-@s(^`)_l!8yepqCq0b&{v`F)neR_CzrX+fjLxCCI-esF
zzq-Iw>Hv$)h96e{d9nE^aqJ%#n>*IuwqN|P{;u<e=HF^LUUh7I82J8S<KrO5mj7OC
z{_$zt@Z*oq|8B8)bM;?MHh+1z``=AAJ2fEB+jdasyBM$)4wkhW;!0FN2#+^l(`4zq
z=`^C?Y6H&J&LU`QXO6PdpOek~%eh+rcCtC&ZsgZuvr`k{@Ysmr|AED3usQg+k=sC+
z{%;nW-3cUL6&ppr6G)8jr_F;6JSUXFWV5?ww@OU9C$}m94Aq|wbrzpckDMJ7s0}@M
zZcyQtKO1tL`gC}Zr$tL9+HrJc>hLuuFxk9zD^&AC_4pr?&0_YEs(iK6<1Gd!RI(sn
z-GtLTgJ?9Bj>OH^zfwPGJZV3X*nRHEN6$#JCpTTvn>>zw?TIw`T5vbx?YSfGzPvI+
z^}A*b>mI|te`U^bi=6@%n=#d7gyKUKA2>us6(A&ba1s&Tb6oQGC|f*zvShDkv(j~C
zJNq^_R+C<{s?-}t-5B?3LhuP)jZ=<cwNrJsK(ij^lx>;`RJA_cVj-l0bn2gOGB|%q
zkWBV0^6x{5&O^S8^KFO=wO(g}^iK!;rs{j`kym%ASGzCoJD+<o-e)`RpV=9A+W$qN
zckj_d9lMXb+kUt9;e~XevoXA}z9h0QP832Oa)hv$#+gyRrmn($>fvIhez!~>beChG
zaFNrqxAuPPKK9#EgaWt!-BRImO&VvSeKKb6XnyNybUw37x2T>B{e9?=6Q~0EFJ28)
z0eHv%ewPbq1E2%|xCRR0FKzHkCjgoa{8V~c+ksU0ewQ0C?e7y@zc4jLMurRsHXzj^
zBBllgo<c&#Vxn7BRXhOh25CQluR)Lzz+~`V5AZMG)qsHm`f6=s4G=K^&h8$&00Xz#
z<^y;v5FT-n$F;Rx6%=d$xCUKV-|lb&IRP{YfWYSF0rBy4TiehrTU-GN2cv%gKC3H(
z*J&GIAMyuhPA&5Dr@6bw0|p))vk#DJC#Oh71v?`nUqILMJiB~+c3V5@0~qe$7~$`q
z<mh6SmR`JXU+J#c3>Vi30^Tq<c&{rp8lY@o^a7j~@NE?ZPd|?mvX!a3n?0cAR#rPq
zja_I7xeUfZO%2z`NIIbCj!qPS)`36*yd8jdWko6gxq9k;Km`Gj128YZxw^V;fbjyP
z45SVaPJmGZUGz&JJpi6DAc2kqPXe)|so_PEw*pKRC@Ua)qQk0zaM~T12{<s2MnFda
zB?fRbAjAL9iJ$*#U+{nA)qJ;uAOFw1`oEW$|58QyLH7T(#QdkL>YTr1(?5g`qwckB
zzikkcdx7@1(BZE^zh7l#C~oQYD%8TYUxR-CJE6n%<Mj`Kt146DKZOqe-c>boZr8Jk
z%YX6eEshxjYoA}=`@9#vG_d}iWLvz7pzr@ZXNSSd1HCd=hkhczf+ebN_MY=(NY!&*
z1gV)sw8bPMp5<Wli7Xp&1bx9m%wl@MN+w46Ihj=9X;XmRmnvIG=(1ZV5>10%6ze^R
zl8aEn^^BF+ZXF5>G%j4>pjdh<jk-7w%8%KYe^Vgu%%gZ-x3;f1FYn;&@73&LD%}%y
zSTnAMUA}D!oe!GBwb_UEb@i233l6Q7*L$4ud+9HS^Hi|++uMV6^~julb+qJbS|ru6
zy4lJ)UVQp>qx9@4x#kEVi&Ip_u>2c0?fOU(R1;KN(O7;&8^)3rpvN^3kmKaW!c8ve
zw&CCXs?Kz0=_?5FhjcyW>%#{4R}TO5U+Ow0#aQY-oqP+ZqVC^<dZxX1y+1$mrz(2)
z{^ER|+K1l7U#jTQXwZL9MI7qOf2yM2kVVVGJik<tt(lLoj4^5Dx{wf~Yp}ooeQgwo
zqQrD?cl}Ki)j2Z#?p=5+*`@Q)$$Q-3mnb@LDgG{eyG!{mQKWR{%YP6>`5ND5!v7FO
zQI5HL{*5Tw1ggl4pZ9O7h<^fcy5L`^qWYAhXKx<O*Ia+yd^mpnP3y`3Q57vz*#B4=
zQ#$)UsG|QLqDW-yzsky#fGF}`&JqQp$Z%|kFMT<i$kPZ!(J-NQ`IjiVhRG8GqKKV-
z+c64rP5jYv-XBZM+%pYQ>#)w&Ks$I-Kxaf|uQk%<FICiZhUrq=Bv@{JPQ`zv(09B^
z_~O`g&GeO`V4mZmH|&1RFGo2Y7k@Z5YS6z@LMuKl`Rd;<F@It)o&Ii#xmjMx{-(pf
zSYigEsP?~?n9ZH?xEKm@JKx~_g-5D1CB-$}LLK!)<*^fqc3KM}^k)i4$SbgF{_Qtp
zxa!GjFZ-5<&Bl^ZEfF=JV-)ps!<_HN5`!OQwtO6}sTcQ+ILwhTo00eC)<D-_1&XPJ
z#u4r!#yyB|s}ki?w3}=Ctv$pal7r@(#;o+G0-)L>%Ix>qyIGoo4eLo!mY7f~)7+D&
zS3P8fpt@z+Odpr{?X}Ie|Bt!%jB2u9*L|P#(Bz?4G4u|hcSu6-0qHe#M8KdR9TEst
zN<f+*7!ak2f&wD8fP&pOROy0>1snGED*JK1bFDeoT;=Su$Jl3_uZ-as`GEX?x$di|
zG2spRvQS-v6A$Np-N?ri`0_3nvG9I668R6xzyL@f9iI75l%cQh3{eJz7!YU}7&z(a
zI{gc4=o`8~BmxnKo}MdS$3;)i$w1%P(9lU&*HK5uNl%|_Xy|I7?_^-$VhH_nJ!c(V
z=f9{#L)#g;w@XS`?A&Puu?Ykk5T_UzJ8SDY%E(xWiJH2*$I8juKo@TaC{#6^Rn=UK
zO<m-a$-5N2jZ9n&jGPtKJT$Z&RWw}9E!>pVp(C(4bhn32&=6=q<N`5^nyMFcz=sa(
zf1wI=OondhBElvRtv~<*u?gfihfu}E)lxvf5CRqmB_LE$Rq})`-q1}OA{~fUY;8kh
zVsbn@;~_}V(eX%6Ka`wO0?`V@P-;qE`UYM^D}RVqAgl-qN`lVy5TT@|9fI!C5T`)!
zav-@VaUUHzWh*K=Ku35*Id|wj4;|_uB7;x`;uKm)y}ni;#3{ah2@tusx<$FW?Zs=8
zA^$jpEoNqZ5TrmCZ-}j+Ycs?$knRFug@&3JbiId=M-k@=@e2em5TW?^?EeclAoPGB
z3!)MTLw;*KO25k>Afkb8^3b&$!V`#Vj)l+tJIFw!0|6AoFA&B2g)slWegFTz`C$Je
zWe6DjSCmomJ};k+-{0OTAcws3_iBT`uHv==k8wL%|1lfvA!=c4Z8y{7_t$LjgAyaP
ztet<aL{*xRWfn5>%#1sme_zEfrdfOXeKq`j6+iHv%f;^r3fQUTA~Juz@9_<$yfbta
z-yddGr*|NQ1uJ~|+q<0;fBfC^Y0*DeA@@w5-T6%!E!pP~0A?7L#=3X${NJwPyWB1f
zzk7W1u=;;98~oo^8*C4>eE<5lN>r=e_P^5GZD~l+*fr{xq}nw)FLV{p2km~(2K&UW
z7l{9^ME%=rFs@MLQL#c@>?6n`-TA0g<L_7T$7LTph$vFHbd9`?nW%zYr4%fkBaISJ
z1!=(YO|TlPV^RevyejQAf<(v1wSLj6!9oECUu@J<3LWQ!!t3@tJtD+awOhuhzvO8X
zb>drF_5Qg%LDC1G+C;bXyuQUcmUR#lYn^}6tJ9_^peB}8W*8tNte&i&cf7`@TM$>*
zU5_k06e%ggC4XW4MQ5_>cV-uNI&rgm4}FB$1Mk{q!F&Fuy~ro#y*&M2X)kvTUqY1e
z$jD*9O4H%>ppi+*Z|w!5jHo?4|3(@A&|Y#*G!{RafV7v(VTHf7m!;s#ztF!a1H(gw
zw3ky`V-*K)Q_o<mG~Qho_FZlroD29fo=1|WDe1<<BQD)Ofy#fCUi9|c-TzB^(Hm2I
z`yZv3|A8_Fr{r?~q71_ji(|c?XLg+VExjC$i~2X|WhHhg<I8W#_^rJZXYt?f`tP-u
zqp5HH?`SXoN0iZ1se{+<%wQq^i87=}9R<l$h%#hzEmg(@O$!-Hk+&~--aI_k4^c*!
z1aFMPzf(r)&1*8>w~7e7ZQ!Z@E7}WhJ8n?v8d37^l#y;yp`)80cJbyZ0Pk4lbr#nk
z>7aP1`j-78C)bqHNFT!}E%MauDnq@ETQ=X+y-#me>mJxBBp(s;d+%I#r)|SJ`GS_%
zh$ikI5BR@ynnPdaq1Y7^wStmVE-sEx!pg)1`iB3zvpYJh&duFYTMhb&1(cX_b|pYD
zDkxHgSNGM^4sav|LjEDBNgT>YDJeKZY64Uo<U|aD`p}~(?Jh1(sw(8YQLRvX3o1;9
zn$4j~B26_f4K>gBsAG^<39s#|tnB*vE?Pm!K|#SWBe`B#)funuCok_17kNxw)zd^L
zTuqsrliorwPlzx*N-*5xtes`&Y!F3hhaMsaS7S#f3r|wEi<@P><;^gIMq{-|TNA2<
zUbHmM%0eT~#WdYeBQ(Ie*jK-NkHvAEg0&@yWNl+;XK;XG%hc5fP*Wq@*%_<Idr)IL
zv{Za;)epM4k_@ziqil|Z5UM<M8Dz4xhefU*q1eI6R7cYf3Svo$J9}Fc>Zt|?m{jg}
z=y9@4(NOY&N`#JA;4Q51&iWatHUr+C`=AI`HF++^;5gAq!%`(7%j~L$QNFECGG57F
zNWu_GVeN@InBvx1V1I+Ue-A+?VfGB~_5#-3B`!XWo}S#e*SRIduZU<#ImVFp^$Et|
z?3!7}$?8Qhk=aT67+I-De@&w^T+THItbe-?4|hCFweF(3u)BKB91gf$w)=J_;bKO5
zX^@*nxzl8h{Urz6xIpjn-FCV*cGkPS91kSa6c^MMyWOhxo=&nnL(4oC9JoJ!_mu|U
zMWVufJ^8S+N3_%2>$g`>v|Q$q;0Gr|Uhb6f>Z~h{4EON!b#E+d$s!Mx_+P$z%HUEP
z>5nckUq`>R7_0eysj@Vs1eg5lCw0BtT<sl6O0vGWUVZd<Rgl-h)F`OFp(;P8Gb^C3
zsbu%^dDVlV%6om)qMTC_{L<VVoz~9p*tpE)Y^I~F<`ov2SzT2+e&>FD*!6uzr$fAg
z_xMoVoNV_*92+`+{>?aQdkx!D?^clPXk@IKk(pE!+^MhUI#4No{TO#e!QBYIXc|4;
zNYk*aoRO2C`{uSnbItKcuRX;jxp*~_vAOm3pF6hy<lWqS`aeG4{40D6Si~{23i1D<
z)BLvd^V8!*alHfoEE5RRc*<=Ls|EjECTJPJrL=W+|NQ}<774jl`fm?7Boq9{PV*0&
zD}iFF&;$NkCg5nVUrTkD4LSM%|F;J`XY=&?CwKm4YrAmnAK|O%-?p~@z3^4~R^omC
z?qau}&+<0s&mAkncocnpJAUEqwg~@U-9!(|TcPmP(yNDej=5jG^7F@E5BNWInzP*A
z?d)93!+1>2rtoTgb^YrBf3_!2Hpj4rZYw3n5D(vVfIKKm_h%A9i*}V7hnFay)z9OT
z_hXJ>0VD^?<kJ9vYiIJ7JQ1ef_ZTJ_1kg}0K!U~xT&KVReIyr91Apg0X6~dANLkCz
z=K-!|CMBN<i|l$@t=i5306t1Oz$HQGQY1<=;1vO-NPvyyb74hcV3F+O#~d2P34n0`
z(2mNPQvus{SJNIJEj(#LZjIq?S7<YYoMeq^C)trq48WwL5j*>y|F*S#kE`gLQhV9E
zXQJ_V@9^i5y=T}@Z|^-lI@i6oe?rns<Lsd~87GQxBM#vVNv}I`&Prt<tp`Ir1Vdw<
zr?at7D)3szm%{rx&x;LrzaBDd=u^2MK5+3liZ5R3G}q&tz<mgv>l^~&Ye-)ru-Ogu
zUK$QdvQeMW?0x6Ik1Vob4-+r;j!M4#v00Yz)cGAsNafX5&+Af`r1N5C=A*Zsh5(5p
zpJbSCFH5JsR6{S4g4#zko6>d9*<dmcAT~w+k_q(BV*12;i>GyCUk_?T1wOeKc*k@L
ziMX@WbFY8LW&J5P^b-A2^x>Z$drhw`!my0fcLpoY-w*!MmWkMYY535k>Br`3?w6mR
z+r-Nx6jt03S$bEH+T24cRqEw$he9KA`cE0|TfHz^@tAw)CgP$w{+x&P%Qmb+V=T1L
z9QcwfUrtuohroGNX}|GSxcr<;Itd9MR^CPZhLq&s=?^fW8XrdLA7t&rD9;ekSEX-o
zYoQ2I+86k4TUVZ4TGie(f0kr+2`^?(eP_Xk-nXy+o!!|#3NF2GvbyjQ<^sU6ckVo#
zxEo{s@W|Wfk|j}8(8krRoiy&;eD7~F%9e0RjUfHLmY*RTmyvSusnP0!*Z=?_q)$Of
z`xCDOut?gYEN*r3B3Bp{5FVqTg!<@PZ$y<VVkvIgUb0-<4k|-_{xo^__hDBm{79XS
z2`S!Y;H&VW!GdDAWK?Ic&DSWp>d{fS&htkSIerR)(xW1=A8o}PSTH3`Cq&^Gjdu)J
z%-g_+d=DocUi33EuBNz&Ql?-Ugu<xyaEyK*T}rW&t~d<mQ+f{U;>RHr9Y#?raq?qO
zBPPgUGa9e6E53^N#4QjIFp4yn4-*YQ{UkzEx?(WxlK5~NR+%Dyn7}~-k?=aciznU-
zcfqt#`vcEjYTuTm-VxF#9FCAvJQYhoT&V((cdtk3>QP`yovi{*j9I-Sk#LKNE`%6%
zLq(GU=c8U@n%&IT-c8YSJ;-V_g^$7nCANEXUa-XObdGXgTH^^l8irE#n-JFJ(B(C*
ziG>5i&u{~J>FqeU=J54hy12r;Qeqv-AkR_}1D6-};u58HYG0zzbI~>E)R%yq;p8EW
zh8Zy@V3aF*kw;ZTJw>y6PWqJHxSAXT?pJIt#l#5+acDe49FmAByTHl8AXMCVR8R(n
zH8m&k82VX*A8qmt@U3Vae4geEE8p)30pry`+u=e+$Rp|SFZwS9?us*T8n3XqkVB9I
z!235}c(<94NnBx~Miy&%_N*WklWAtxPHSTAj7hxQQplYi>)3-Q^5$LeF!@uXSi9#y
z(1s*JqEmK<7AtRuLQnpV?HL@e>rE1{DT&lAV`CbMt<eV$Eoqby5T+DTTqWm$z;(*d
zk=U0B2b!GvWpMeXSh(2dIlANw#p6{|qUcThQpj@_s)lu4a!5-3zG>=deGW{_2RA2>
zOygzo!A0U|#ZFmaT)J2-O%vw_lE@MsQyh^mnZnlLlG_2OkVK}ouyS5<Ja?X}2?h0)
zm}aeuGWB<1gP1TuF&#kXCIN&xL&V6#T(y3An#F5KZ~a%^LVdP7_ivSoCZ}O=mT*Q=
z`Z=yhK%k2@E+2X6vF}YlfJWY5oR6C6x_mPQ)kgH_nPu+R@Rq|+M|V-2(K^=-rWZ?%
z3T3P_l-a=c?JjaY?=NNv*?1J$3J_HG_ZbOYCx|%W^VB^1xJ)^+LI+Nt6AD;kxV7gA
zYTX>wB&;(u*#3Nuf;!S_t%agY7AKjCl6pktAsEY|>hH643B)2_mLy1{4G2P?o%|fu
z<lsqC3~4R(#fA&feV`r3wNm{78h5+lAfKV;@($Xfhysn+?@K_adOfO@q>vN=0dC3U
z(aDAhWN$M8Zs8>-tO~&7cwM<9%$v%@Uz0ilw=gaW>&p@>xRO)$W~$jMxTv4ePL+P7
zH>(vrq%x*RS>f@A1Hwc1treg5l`0OfMNDXPH1c$z7NrgKu>v6&1Op5&?e*y0_J%8;
z#w#lXjm<T05d}&87`Nmw?pFM_Ap$Gk`Rkw1KEM)Eqp#4bJ$!N}VNCcrv&eUg$aQ8u
ze`x>fWO*++l;MqUG6A^Q<`3o2Uq_^(7lqM%l{C@%6(L6XKCR51LiA=f6HX5??I=WK
z0HZiBG^wa-j`nsWzcxEz5-G-j0Wr__afcAO)cQuzdE{}Cc;<ldi!~8ncDksVz#(%E
z5nYy=g{i?8gtW_{B-XC)VB%luC$Enw@6%Ki4W2b)uYYhP+iIwB(e#5JiMW0tiUCPT
zAT5mB_bq&9O;UkIr+QtmUxDO)W{J5&4)+l%Od_PUNR7!_%fz*B^G3hT>mGwbp*P21
zUi}D=JUZB;a#d4CHs69n`*<>yI2sW~|Iz~!(q$ozDr3*k(6s=MCjs+u#!71~DVK^q
z3bp@2Mz_ISi9Td46~mP#AC-(e>Wi%H!_YosddP^0qAXul)@>%dcZ1uNgZ(y^qq#=!
z$6*bNxcJ5CcqYb`15*|QbU5%hkh^~a?n31WAi$MU;i_!ZX#(avfKg{_LJr|@d#*Sz
zx#T$IC>3*b3x%h^h%`nX0Mt`>x+pMF1U!$*Q%{cd-eLe-C|n=Bn8|f;KuZ#b0>~H|
zo6D9`*aUEAIUsX83llm_Nd-|zxOLDr8t6X<X5oPYY>Z%7^tZy2*l0@$FD^$sy^D!9
z;UFbxXiy1NPCHOe)diH%N7$IlOoS-`Q%=Jsaj>==uJbr-I6LPkh|wh@XohqauGEzV
z3l~z>WOHR~A@iOhhKi9cv{+3VcKkWgY%8Fz0TDvLOf<my=iyBa;kiu2Wh(jzt)g!}
z+OBWEG6i;e9vex3yR$OfS;%f0lE~(=+$y`^RoNqk?#3bT9JtHcA-Pm^*BU~eP#M~p
z+{MPYFuALgvs#(3J9^2W1Li2T>eE-0CJV-`iooGe-MFl=+A2*PT0jD+e1r?CgS*|A
z+}40zYd~mj6VP8yaC_RqO>yb&Ybb$R)#+?5X$g!f9%g`tD;Ji@+aon`h1~$pZezGO
z$Vi^R#4)oaF2G~hd%M|Oj%zOc?dU5=;QaGyuP&GwJK|7bbpA};873mNv-SuF?f@Qg
z2NBhe;VU;WF)Z$KT)hbnoy^9Bv$={Lq7v;5tWV$qCZeihZQp_XzAyn%8a0&)UqPj%
zBB)_tisl;h=}|6hlpP*5_Zj6*<LYK1+Z0WXf8!1ZfB+5@F-9I`qD@(iJ}1y!6eK`E
zx`Pez_@<NTNckv*%jrD9AP~&t9(jRu;GoWcXxtj=45iU)4OPoV0-*cS_AR763pTWc
zQd2NGimM3*F?+~dgSQ%~RGttrLYLAUwiRUm9En*&702+HP%F<<8||r#U^eQD5_&fq
z#a2CPLPM@fppSVsxe?HUV(4e8HS$G=CHBB#@JHAE5o<4y25WGEIK*yTv$%2v|2epr
zX@rpRQTMHuTYFlbOCU1EQ*J1tK02bb7m-Ew$n^zyRs-}4uhZs**uCcDMdbo$TrsnX
z1QkYiA6oBVJN5wFb_*Ny9lJXko(k}+Q+fLO+Q}nGI~=;6fEjMbD=<&ivocS2A@vO5
zYmQv#I&HDFwpv=N4GY2DojLNf1K(E?G2Nhj7FXr(#k;M;Ewu)V!U;sw?Gxqjyo>3S
zLt<>U?05EYvp8I~EKJ`VQh@@$P>f+B^#eq>o53Bi93;gL<A}o^?}j-7*xqgwp4Iie
z2IaQZ<;Xrbd>Cy_!&p->p&TThi5M9{_RuiIXI;%qB#w+}UMs<E^-P<>QaC5igu^2V
zNHd@(6hxeo+%a5(GQlGQ0QmjVZddZD8{aW~J{Z&UryZG?_ag{(4stjEX-n%_=cL{@
zMaHtuOpG85w|Z=tFjo#zlYNT*0PtpEY{<xU3Ic0}eC^v8%RD8J>79SAFP@B|(lDM6
zV2h1NK2Gm_ul^L;-kk*Gt8N(Y_Fh;9r#FR(!m%)EeMjtfqw;WP0{Tu*G$QFmWwC2r
zHft&VlIE@-)s#7KQK|m-ahb<5F!A+WEb1xmz5x~)`kykub;$LpHQWRo5(O~9J%c-$
zh_IIfIr*KZJ~Uv?M%j4_ssotS+vk<3>XVVRN}z)T6|T>A)fWVIUv%)4auCHU<+j7z
z#$By!5EV<X1L25oy2H#o_ooqv<?H0_13^1EfHK?l(4%2d4yu^Llf=O@0$txIsK36B
z#}VKicU<4=4oeUa>u^<h04_ne@ah4!WG`HO4Sqp*q=Cmi{e1;Jl5}Y=oMm>Y4z9Y}
zctjF+qWGNCTXBQd?H>0_OA1wcjgQvA)G4(JYz1?K>SZb5+#MrTP^s)JyinKS`4Y4G
zkW)mp@<%h{*1Z?5-61C$Tzb)CfjD6LC{n?YcKq5)_=f(a`wGOdCYU!Bc4;r{vjJOy
zYV@q9P((WIb0*uZy|}{B>u{GK7Nwu|Wc18glj_G7m@VBMLMpOe+6vPKcl55UMqG<U
zU;DY+Qqar8?3E_=gRYJ_Oc{qY*+O~R<Mnv;hr{)}%3wBsjyXsomOVYh@bC;8TApbk
zYH&@6q75QUwezEWvWSsodhtiKem+r)U)Ed<AGhVb(Z7G<dwzt+D;*?KUF1`irM$6n
zepj&&9&SBRxPAB9!fyRQ^9k_r7+ugp`<jkTJmHJnwWvRhE%Qy2rEIxLshX2IRtJnv
zX5F^3MQ9+Qz;~KCLVdH%zG3<Hp=wPlag8T(Is;k8E?vsX=sR34`bD35F9zMM`1965
zDS72q1BVY|TBr0rOzW55)mWz7v=btQ2qC=K^@3hn(!y4E1@V9oqT$t8$180y5Fs9<
z@rz`Bb@}#{-6o@BhT0$Q7u()HCw-$oFZ%Pc`X3Q@JERTZbogyvA%-Uh+sx5QO5?7=
z?NS4|!a?49pg^z0-Yrn1mvg#m67Eq5he4s@L?m5E;~f$Vo8oCjq3Khiqf@4^Dc<!d
zkT|8h9W1DkAS8SlRMDK4)RYk76HrhVjPC=_b3kIVVC(>xK@dFW1CDoqZWK_a9K4JJ
zf0=-;2?9`sI=YpcD``gf-3+%!lkjK}%460-Q=$ha6uKsu$pMd&1#78b3Jq*p0}t@E
zD8HLV2t2^HPQg7Mh_|AwcM2Tf6G%4%OM=0I<~jO04nv&V0h?2mokNXsQ8}|H0dyBx
zAcPNS<^zsd2)MH!Wb*;Gy+YO5V2&o(nhl=m1)USX@h@|F0<#r6B@6|Yb~c04@4#QT
zrV&+Kf|HBz(P>Q%3ck)GJ__|zEbi_FdlkTm6_Du)%4LJTnu1H0LI3Rpfu3vuh2WJ7
znv!GL0=@T^5VG!vE`wd1IrO{5Nxnty(Ir|ixakTWrOXKk@F0^g9l-)edch|<1$|wY
zd1T#rlh(fP6hI_`f4&A$A*(S0yS7{f{Mle%A1ILsN>vE_N@(JOt%(sI*^Ex|POeA4
zTNfF9BrGGLp8)Ed2K5p_Wr~1-rI1Ntoqh{wVku~K1tk6gt>1vQS^@?+aHDsRT<#0)
zn|eaNFX=9`;T5vsle6KTgz~$xq0zb#xxOLa`XtEmX=KRL=tKcF^{I{=uab_eSXC-=
zaz4)TS#rp;voP6~q$3BfJhKVIdcvLt=Lq~@KRY#w_yl{dye<2TVJTJD_q^iQbEeD-
zAv&Tu<V7y=MP18_H2RCi)fcKdT+X8}z)`-Ikj+5ZP1)9GCw~dc^}$a6+LY>h)_G+!
zF$uLo<G;jwIdY$;6A(?dd^vDm)ED5oKz=n5@@kd(L}b)U3jRuih#p-PI?m=UBEO!~
z;wtrccK?^)De$$P4mXF2IE8<63iqan@@(nN>loOZYAWK*n>RBRZ>(B3H%|+``t@cj
z=gnfs+r*@|UuE9@xc@eO{q5TwTURYNoatNp9vQ<Qg2-cUc^=8@R=pw0zN1!~A^PE&
z`$-7;7JPf__35{s`a;5IKu#j`B^|B24^;mHbiplXzlGavb9i$5kSMw$UnNJM@LtAU
zIFiC+h66b=A3Y(5J!MIPAINC_pyP>B*cRH)1hrT(2s&0w71U4#kMaThYT)Y4k3p8)
z)KyTiQXt1oV7HbxK!6STqh76#04zjO_5%R_#d+leMf<H|Rd_~SiO*YQfL!T{-yib=
zSwpQ`X#OJd=%cvKXI_ub!Z0p**nAKUbUV}TZVEONz@{@_#lzp>>4-Fb;oQFYT$Y+e
z^@24HG;Zxe%C@)clP%L0puPPXY4u%v^1ZO^)BE~hcnAm_P^6B@81MR#rS%<6gsb9(
z+jl5WxWD{3juOWIoOTasBcNxF{an2Ib9wvW&lT;TtGj+ZvikKT^w-neU(b*I+PwPf
z)x%$JwtsEy+7`yckK;f;0{CT@tYzP}<(gm_jTZ=GvoU$(c31T%*31|kxzmy%?(xW`
zlpkdn??7f<E8At7IFsh_#GzWzwZ-O$=Y~_AX7Ck;#O|jqjRsZ<`3f&MZY|YrFhJ7l
zIl0ZYT*kK1>xJh@*JjHCN$*V#Z>gFWweU`tgr0|lY8sQEflx^tuw6LeoNyLSy3U={
zggfmw!u@n=T;1r+>ZP=TKfe;i`j|QgUzt<yJf^~B%G1qN{xqfo<L2)z+0u21(f7jj
zLMO`V&pqd~n<<N5zA&&k-DPnmXXU%z_TGgKk820Bmp;FmA0$5boUo`*T_4Yss<e<!
zFVV?SxJ;AzIsQl2Y;Wj|mf#-;J0!9?<wZ5-^;4p|HBx+dYUMi1oP<Fzl(-Oo?IfRM
z&1>-`K_pFBr4@;LB#$Sk0~)Y0q%)2TY=hEd;H#tplcsb17N%HJ>uyY0a9atw43i_S
zEEy>?tkh^DNVGe8kR<KVa`1FI4UpP*UB`ZB>XUx^UAahI2iYQpvkvl=HoA_ARm&Wc
z7j4HY%v3wt&pN61o?8?1lw2s13BPT|-zBWyHO?e0W>&JlEsNXK*|vRU2&Yxh<>+u1
z0ialCO9RiX4%Zp~!w8*yeAH}P2ol)L3xEh+?wx<aq$ASi<)$2${G)}auN)$UT<H#x
z5}^R7RAr^Vk$l)HTGk%GhK#@S_S;t@k|!11JUbB(QTxfqf9K4gZ$JT`D4fDIpE4g*
zmHo*tD8XBFG5kb!-GivZifaoI{ZXG6qmK{zEG9N94h1Il_lgFkocoy)e4sb#{w?L~
zk+UJ0Z^!G+cq(LV)q|dQx%V8GRJ9Q@v3aNF`t7#l^>SO5$|y}Guj)jN)z$tn0sA%z
z)8t^Xjxtzv?A_BN8B-eTk5u$?ti^!&_2E&?wBhK(kxs01A)FI?q9Q4NVN5h^@j`+0
z_~Ma*BDnE}!gHI0tsgzQwmVLa#Pyt+Fx}gG{wXB>UPYV5_n)cwav}ZrU897-2hmcr
z>>nr=chHdRN#R}0&8JdccT14>xKMuQ?iGoUX@Cq`bt2sU%D0J{W|TvE%f4T*HHm}z
zqssz#C5^DCiPZkF4Z<l(AJI9t)63H-eI5nueZQa}>E16pDY`fgE1F3H{Lr-6HW{<D
z^&;gfX^$)IS6`kzmPKD3I#y(v@p@HM9Ei&K*8aT>H;DvHq~8U)7OpTzFxX9aw7?-(
z7`rKjUF^;dz6*<s+;?fxe!XTPHT1fQj56nL+|aqB0#vb~22=-tKV<VY4?`jcm-qFT
zBqeY1O;XoHtIrd+cO2y8??SFWs7p0`QOjW{d);2DNs<X_KO^Ai!7%Y6^JFphg~jjp
zQ)T0iB_s2p-}Nygw$Vt1?YhKwyuF3A4*!AJG3iEV5($a30g!D`+cf_dxDz8Y{*N*I
z%p360t$Z5*kf=VJ|7wB^PomMY=a|9m)h9>6xyg#u>k%^N4M{JI`3rK9kzD5n`1IDs
zcweO1`_>3@xf+uMbkj;Re~B6!$+Cq1G`^{<5Y6v;D*tf%p<^Pe<jUYn#2SXK=#w^l
zrQ81ZeDu!nyGZ;wH-Wx7#WaFh{A9&JC_CNQhyvMbJlct)Vr#&ST{KAUy8xFW-K>*2
zVd5I+v;840tE^%d;(}}9(>s_$Py<*ytSl7=L%MXq6%w$+XTjs*(+*GzJh9AO;aV1a
ztw973x5C@B0^D$G!Vl}#EYUT-KiCbTTwD46!iQVOKk|b&i4_Ia*5VN~B~XS8H{(J`
znS*QuH;xx)e7jNEc8`;{nn66tzG;QA$K^y#Uba`h<V@#;&?`kpE)k0BLNQ#gRA(mR
zN(TVQ0r_hOW=^QpcDZNA-M~^i^etws4Aj`7`lhogmTaGf^|-88NV>M0L7>%|n%C@z
z&(P3p@4kY)K^vyNBXhH-Q^)s)d>VN$7~l}%PHJ*Nnfbk38|zy<Cn$fg6F}nu-t8z8
z3|QUI^d!)zWeFMxtwReFiH7GI6_;Zy)EW0fh6b88PVLcqxiH%;I?$S+8Sj2);X&!#
z;F%Medz1DCF1#@ux^(Y#LV?-xs-V&EcuH?#wprjR{K18*<*$<}e*`_Xdoc2#_jGjb
zT9Fj~?Fj~IUmDCGhBRiwumo+mC9(X&$p@F7y6#JVDE08mkl5u9C$zIx4n6#_nR@l}
z%D$YROQEnEzE=?Fty~l@<=5x>QNF}2x|n$wYWvG5c7j@{9Z$ig8js3c*(%g@3Bw%z
z%9cCbmv8Oz(C6sbxc0$!@atv~l1(6n@PZ(k*Tx%#^|?WsOcI?3XuA;UH*KT0t*e^b
zo=6%k-13dHt~q8NrS{<EgslmocJNY^R_el?(3W?#dtUJv2ycjxJ@PztVKsXB3-|UF
z9yq$e3+PPGb6E=@0SXN8Chz%!=s$iGWf4mfGi9crBY7DlROX2`mGjTXJ1>!IJR}yU
z>L-#<UdWFn$PiUCI^9$NVDsd1n@Yu8a<}*8I3G;G^it%&<tsE{55x&Ug1;URw-Oif
zW$^){yvQqLB~piA%j0+<#p6BmRjAR@!XF3U_o13%fG4ti&h%?ucvww5f7B8OojN>z
z*>z9l((*IA)RA7V#FX<(D{l+Wd(7|Lm+@d}HGdHEwZ-Ud=9i_1+e7+Sw_%plJh7}h
zaHF&_kt@_Aa!1$si_)$yJ>62@aC;<nV|Yw8<S}pL^5b3n#y4#(_gC{=e4=dst-BRA
zUEZ<0p{<;DC(QCd<Bh<l1~=00-zZ1ezFdB0Rg}s{vrKLiTX}A8pD|T?CAsoI{tNe_
zjF}UbpW4itH+^r6kmssWPN!a8QQFFwAGbVswmx|JIzDr8_R7Jb^DD3S6<w?wP5d<c
zrSVNljKTc7E2&q$th~*|WUZmB(#FJAw~Fku9*JB{n=o2^S6P(xMA0h!w(siu`WsnK
z4X&o&PhI_R43qub)+%GFe)VIAefFmJ)r`6GtDnvkWxtBD%3OS~`uY5g>^CV_w=-A2
ztbV!5fBQDwD(jKh!>>1<{g|t|n)TG^;kQ4Eaz380%HH&S`2E3+oX>+-v)`mX{P7Tz
z`*qwZ=Y9RdKcCs>exJRX^ZES4pKptD|J<<3{r=$LuP--pe|@@|`|HcY?QIMj5N5*^
z*wFWVgbf?%#YRQ4f6HGCHnxV%)z0P~VDnsO^UkpOp0Ia(Wb-3OLE%vWg;7EMQ6ZaA
zVXsk<$WhVcQ8C6S{7I2``>5o=sMPgQ>6y`;Pex@vj_yK^;e^Lz6~^TB$K-9s6uib1
zBgbCz7#>d>Qxd-H!5mW?7*oGKrZF?7`D9Fs_p<t0zs!fRA$eGo3UUv#KwtXW_VJ5(
zvOKg+3PQ^PLt>#!+fi-9MFw|G1XYl>I67D74&AS)<UWQYG{)P<U^Osokw7xXx=Nm|
zJ}e~&lp>&`)^L+>G16p<E<D@>0JeYw%n?cBp&%Sz(a6g>dk7d&9OHmE!&U(aG%ya_
zL?@)#R7D_cnFwnp;<E}v7?+<|jP!7zlc?wreTI+2xQ05?<av`iSP+to78Iu&A!)&v
ziX3qaVrO9(tI+Xg;Q>yeI|UtWTojb0=YZ4LwI*W)>`F^6OzbT1p)wEzl*w9)4?s)Y
zg6R&!z1WycFQhdGX+<saI%N~ZL6Q290W9=6W`Uzh;dZDvGMa;SraGkDHBSA=h~7e4
z#TI5s(|w+!?Hwvfc!onP+F=X1i$$Zw7esd!gp?umh5>IR5JbiVs9bmNQ;lw5m@zP(
z;)U)G_7&HSEA<iXG^8G(fV72lXCks3Zq@1|>f;%^Pu)8C%GUa;eLND-Wfz2PIg)S%
zp-==JTS(-f6B-J0D229En-dIGlQg|uct!xr(Hf5kVIsVW89p3j%vOuTR|o4YBsZZz
zm{8zDyX{lVaKJkEd!Zv67)2WBXqDTUevGZoLLxwmXt2FlHY^N6pMg#S3)Gp27%I9W
z9>x82eC8v4rX6r#(L+Dd7xgE$5uh`xk4~AtX)9hBibIn8Y>dRw{y3y4-nGPRycIBW
zLDGQXJaq@y`ttpYFu>_gH^KS)Ye?>>uMFEPhh*wa8zd0WdFT02lgo#=qdL*h62@J9
zo7S7|Uu#UG<_l9fXi<XAuO}k{WOUGcQ39C^|1@GpC8PN+VhT8%rctgz4$nA;cb3Dq
z!P)VN!;hK-MJ5FlCj|{Ag={B<y(dMYCPh;w#R?|HYbPa6OiB(;N{vrS&ra^#n3VZ6
zxeGOg6Pc1#oRTw`lDC~w@SakPno>%cQZATMshv_?(cL&cr9M8TF*~KXF{SlsN*gte
z7n#;koYpm%*0Y`7*7u$^h?+J`nKmkzHm;pEIWcWIIBhmQZ9Y3~k$pw%(X<t6hTyt8
z1)MQCkWVrg$ZqhwX2We)Kop_PIMmKKo|thOoN*qXahaWQ-I#IvG~<q%bvH1Uh~O4U
zlhI)5c<vlQQD%KoW_=50{c30ZPs|1k&IXRp2F=a}Z_EZa({;ZZc<t2pTr=l_HuCUu
z5q$J0SD%PrpU8x{m~x-!W}jGBpFPcU(cV6LQ+(ns`y{UTB#h7P+n7sw?L#&2J;3)M
zPQ*9))7*iC2M77+Fm|2?;O=vLtkaK{RV!n)u_KLnNkW_^0nWql^Z6q4dA9R(i}}J7
zzkF}M;;8xU!g9aTlzGPG`J!6CL%s8*vwkJ7=Szb9%J~+UiVI~13q|Gg`<XzdqJD}e
zyXxoskrNAzg9}aL3rA-cnl~0&J}vC;e2{6;+H$eJqDhdOV0Glv!ilKGlPQZG1&hb{
z0(i?8y9XD0#urcZ`q!l_@RZZepqBbXmiiR~p?-mWgQatPO9QrngQ&ov;J|YUOG7D3
zX9||i*Dej8Sh_sBG~By{9S*$sbBT>wzBC?q<>#VAr!U`YI<zl5krH&XcKKF95dS>w
z&I-WK3A!`BeD5{vZc5O-@#VWK%abcX_b&(i@p^eGICwH)<&VqD9NXZjl$Dv;p!pSG
z!60~UaAoxdDtPt8%7Vqp%BPi8k&rbJSk7fm4`uafLdXtk$kPqli-M3BCsv<bUhQG6
zZqBa0dcFE$Fl37_^i41A^?1m8gNN@dLf^PPd}|x}HsRs>Pa)q#LceD}{66^b{R&xh
z?cuLa54TZkfan@bX$@|;hOk>hehvj_Zm5H67%hrT?HU(qzEa4Qu;|XK=_=`Rdvs|n
z`Uf)P<=X2`bo-Ar^-<ebTSe_3i(bcux%RA;MHJ@otfxtZz41eCjfBZ)tatW=y>=*S
zbqGs&6*k`#CL}jAXcD&gBWzCUQ5P2b56j=b%n|-&`ST$a29TIOgi^@z=WLl8Y!ebl
zs@hE`46?2Xu`l)|RFEx-c3YMjYehgVKFA-auMrHn{vbmj<PwAofsn5catxZ{!wfWo
zemejaoz+yxDoXAi#w8SoI(K45h;_Y(Rlb{bZXlt?k5tkV`c6%i>~B+$6JZ}}SL;tK
zkJ}yXXH_2I92-U6?@CDVw#*8$sf;2=xtcM2tP8v?OMOWNxiQu0AwK>@W}tnsj!Kv>
zv6gIJ;$m{x(V*NxzihYFAumFyn`sRr+T##4#a5@>!JyjRtk#=UY^BxYV_BOQ6>hE7
z;%Z*#Zgj-SnAx1=>1EO6W>`x$X|T~dwA-r4i&W%paVRS&(AoHyn@N+0d6l1KlNX`L
zk5C(6v)7kY=3>CK*KYA4mhQGHaWqLQO>~A_j#pdl?Tk{YQUmL=gCUcoqiITQc48~T
zu_4{c+0~*uVhgf0+M66`$Rg^ihCxQhru^)tY*V6P{8XQ^kyf~@oLypcdw2Nj&Wh;P
z0zVC9ui=)1*N*#j1if9qsss56@1CX%#{T-ey$yLRPer{q)`-YRZqQc`hun{l!BP(A
z;p<U!qs!4yC0tV}aA{DqF<?noC5Rf+QSCJYnGcsn2us6SBx_U1Jjt+|fXejW+!9(E
z)+{C8em-tE9JlRim*-Bl78SM1B=<w^%KZ-A`5srC@mW;?w=(R8m@YFG`q8<TW54Fm
zP*$U(`;?!LFG+{G$Evltp{6zX$;on6Pxk~n2SS=(MWRdd0jqv%wPXv`_yY;G?j|{V
zO*(w^%C^@rH}CziCpxYA(2<hB0kURcg#NLH@EZYs2O>>dBEvGR%(Vy>p<y<M1B@zz
zNQZnJ@R{kQj&^Z*IZapFv>{_8<aG=%E2lUxy(}1Erbh}2OXB<vxI5e2>*SA*%Z+!T
zM@6{P_G)J5r1)AD96G3=twstZtA!ZWmF3?^@Ye`4YD^20>#es-h-tUBOi9>V2w4ID
zN6X)iRFU=$f&a2E0r4N_2s_*vy1D;4NBFxhLG8WZ?7w^V&rn=RJb(A>|IPAu+xKsC
zgsF*~k-sGazpSlX`EB`I{sdY6pk(0Z3q9{1{oS*FcH{r0<*(k7=RbS)?{m~rN{7FO
zkNlMkbj;Z1{?BuS{F&fCS^g3d?B|uZJ>Y9}?A&K)V>fb*mH+WwH7orX4mrknpG^)a
zzyuesyGX{VFpGEA4TB|u>BhU&0cqWEqMB%XYpIS5L#~W_#V_3IPSV%)O3pWIWTL5|
zmx8~&ost64V4^<KUF}r?4@S^cbrRzqQln_+0cR5riY9!Mb5XH;K_taE4JhP>%OQ6F
zy;xEe=Bar5qw=NsBTosLI~2mJaA~;kV~EMAs3PgRQ{=;l@lM%R_{yF(;yH0Y(5S{~
z?Ab{}IR4N{0H4v;!Qy^G$E@6}X12S$`KChb=4^+@bYQE*VSpA^;Sa*nQ7$EJ@e6Bo
zY4`<Md7=z7a7R2Z<K;{mWD8C<S~t#c5g*8K6S@$x1Q4z+j8q~%mO*L(lBe-`gbn!G
zYvOPX$A##1`>WQ4=XNzkq)*&W<gA(8Pp<8PulH#Ix#mkRMzKZ%Fd~-`FHKXAqgJJZ
zTF{LqA$Rf6<lwakn#CwM<Jvea9{Cho!C2<K#h*^*(L>RLI4#p;9NF?gI4|Kg=pm(+
zvuKB`cb;f~)4I|0ta9sfH&r>>z@Pie)ZneVnNw(y-YpF+wXu{b<O=*YF>YCw*^20r
z<tzZ^7vElO@KiM<4!uf0)CLdRHYKmZQ^p2o{dkhUTt$4-c>SPlHU2B1Ozg=A!sC>-
zTZE}@0WRP?*6aO{KffkZBVDp)%(_{Ok<wh8OQ1GC{ix2l=*2TbSO>t1;2a-s4Q3hR
zc=7EdO5`$=^G)JRb>V{@Gmg4k_b&3v%87l{-U4~NMhJHRT*`TP*oyKeK7)N=|3)!D
z_<~%KegBNdqWQSOywuDqLa;6$L78BGBxarUl}JQR>VzV-<QR`=->@V($K-JH*B_*T
zA!Vk&{^QKEarLJGNQh?OWV=ldW5%MG8LA{7WYUt28wT)pxE&3U>1~9Qm%?E*NzEE0
z4<^sr8>t~n+8dO)9XHQBF2JwY{ay<DnOa5}CW69Ggm}^W%dIHxLas>mX;AJ^Ak{jD
z>svEHe@LS%y(;c3M;tia3IJJ?`zXsbb2fGP^gl`956PRNLY{eaz}-y+S#Z=GIHdz;
zRbo_wWw#4YZMvQ!!%d0^ZAc@79g(F)=28!#)+3{g{pF|^xUn@K8s8PZxX)V=HVV)N
z;ip@o4+Et-ux*2R@ldyd8Rqk8j~iRAF9|mBH!a@CR_PhM4dv(+>u^0fB<Wxy)0BVo
zAw`ktb=ETqJfOtI?RoLjq%&@17@?WiM=0=ek7%YnCFD((2Uf9!UcI!#kEq_t0@w*F
zSR^3IwN0b2+0x&=#;?Tfu@t_$JJ0H+-TI@3lU{irSg3^%X`XO*|310e4SZ;MnJtqN
zpAUb9U|+H`1daM0;iRZ133n%TrI-2T?*bCeu)aLPlQ3V_ur%>~A5E0amw6|^K`mu%
z_dcHw^#J!tYowP8o&880>jBfG`hm^@j6f`%MW_yAJHTjr+u93@V-GU-9HfR&7@IO+
zy|$GIL&8)O>uuZ3RM{ynh7wSGK=Sp;qlo~f*LsMtc6|H{pm+SDED-ydcpi=udrZ_I
zQB`IcOoPHJ;7h_QN3i=5GdkGmDZz^~%USmxK+x4}sb2@C_q+A+3S&cFch6tnHm$?;
zH9xmz`f4_GJ}){+y4fWO4=SQKCIjM$L{lzc_K}MHNzc=|Tq&}`;X<yrnl}zi8XWgd
zFB{?g#%}rUB`=%kE4xQ9JV{JsDZu0nskdqN(A*NZ`q@VzVZ=%E?MuNQ?~QcSSlW*7
z@9f%!n#Rs8?8pb9CcDG-`8$+KE#*&%eRZ|1@ps%=V5A}V^WBp=wW>K1?yjIfs6wew
zSin!4@bDe==ri)=J+c^GK3*wgL4B{L^;1*7I|mJAci0wNpE<(Zt9n;%u7ImjEIguc
z=Fy%FX$K~kTu-#Vgq;0Bomj&om}P_O)tWZNWwPOpf@AmYDDO!kNna4uSH8Y|PhYmb
zjvw)?>eUyyl)B<ZTipwLPR_|qCOa5;g!AGNta7x(Iome#7&cNw&Qa?%L|LHRHRN9H
z?3;$d^g;Cpyn8!875nTuYkfjks~se!9KWbLRjkq|+m>xWG+zN(JFm~VR_yKM*WJu#
z1k9l(HHq<>0u<#8+(g|uLb0nrw6#sgeV-Dgw#%Ep=LlN_Y-+Ga!NiCkOO$W<lFPUv
z^SmF+)v5@DG^G$9DY>#`c^59jVOS~<Y47fT3BwW?r1mx*pV{;5A8iQ5fz}-{Y4dEc
zD`N08S)rV-d1Dgy*TN_hm~w!?OT&kiW(H{mIsmv;HlrkWdGXga$h+ex2W??9`a~H6
z8roUY6ggo6X7kqRccl(2YOt{SehA@YH<^|%L5AU+F~nJ*Fm>0@7a=-O&k{Lblp?a}
z_mCSS$Np3i^YbO;AARdH>jI0PbPs$v{qr@o@<(Ki?3a<HpKsFsxVZY|{+BC1e!itW
zti+)o)=DLqZ55v>PEV-|ey!AE;gsTB-+04g_lvc5gh>}|*Td$UQi{^59S+Y`N%^90
z>Zgv{S2B?Kyb0sgIDfb7xgx#qhwt)S&oRo#Fn?P!<lZhM9>Q{pvN|@azELbJ8}fS4
zxl@7X$k)wvi{E|gn_rN~xbv3oLwdz;mM{PseSTYI!2NK)G~><B$wC`urGO`}wsT9l
zbSG9f_d9?4FN)PT<J7es05x20^NYZ?5s1J7-;F>_CwRJ#cA5%yFlj=QJgC+kaC&aK
z5!avVd;o!8KvwoORR|Op=-|+Vs-par_;~tvkj3)0M^!Y~;5D4=K0(1T0@%*U<sQxB
zui|^l0)-uTkwjjud2<~csMZONZ>5;d?~)1MiCkxBdgQ~aXc>6$noa>ifFGVz0Q6-j
zIDkPn!8ZgjLIo7`D-?17X9?JywG4G**^wA9A%;&*wg4%+1NjaMC+0bKf*F2bHnteR
z(NXJ#0GUt37}Q-WEc}{G-)^A0HDE!39Vuy`<kw>Cy8_BQ80*Iu5le?BnYI)&{>Ur#
zD=GoTa<E}pN~2toX&~li-U0xe!wQnHrD$0`TP&c01>{6CD~5C79$0{bHXP;p002Mm
z;3p0!KU@T`X^q9;HF_yBi7_0D(I`GN+JM6m_`k9h4Ayf1JpTty*_?`?=*{vkMIh^D
zg+)vbicaUXuXvJL36S}}(<<?;yinizFBNM1c;)ZD^&>)u^-R$o%GgmRycHp|&cv8d
z%X~o5=qk}96ETyjwWmS%Y+X^K(deoe>06<>u>#89z}p7}@sXyAdlK9WOavz5#KK~=
z(?em~v4VXZU9NPHIOuD1E4_spL-en)ORsS_QsZ=?#$}<#?OP35qSn)2pvJiN==pS?
zt|-+bP~UoO$hX=j>oF9Qy2x}1Ke_Cv3sfaMT#p8Psjl;T2JEJy@C0}nrk?x&D8^%q
z$UtgIy?qhdfyS-7g*=OB(5Xk0@Z5$pR8dL8t{8v_V5vBGF4vJ=MR02h79gXLc}H|&
z01(Hm0m3V}8hJ1<`#!8T1=Uf~2!8;Su(=}f=z6Xu#Cf<m6YyNCAAXT!M?eLU;a9#j
z@zx`_*WeaZ`1w6Y-#z7O?88jGI6C9sJeS@)f24WwLi6%M^Xj+eHHnr-+a@hf{9B%;
zw>&@6QteT@xzO_F+wVET_a?`nEyB;~$G#pp_8podTsZdY+c7|r1vh2=)(bOO*hUuj
z2#a@-wc|Srlx&5z2!#V$MKfB(8(SrzIl{$OneVMQ$u_xvpCfE+QyXd1SZvdR<_IN^
z>zW?d4>)d^aoo7^xaq&n5w_c9{BO+>QY24?Lvw@yC!?L3T~hvOj<8fZNxUPuw24aY
zNOO`AeI{^(*^#Wn#J2JPxXzqX;XCzUQ5;y(co@D7<Nx6YZjn1lqdXA;d_1G22pBKC
zmG4(y24W!}{;m_Q!w&^@s!ThpH-#ROK~ei6<U2Y*<Lfa6Psj1?>Vzs6`PWsz`<%{u
z#wYtsMc#kqdx+<4R0Bsdz@Eh&x3~q4GrO%}V!OooGB>+{z7DER4=St|lf*#2D?P#8
zOA1T6wxu+uR=J4J$A%@Xu}<^1@-Wm+yTCdT#4~lp-Ee_3??=x3xp?M*VaG4YKDb#Q
zGO!Pw*@x|s0h;=Fm-=@6=mVwt1<m?}1N%iY`^B63B`@|%FZIj(=*LN&l`}i55O`K8
z^Q=nKS+$F2HI~k5{Wy!4I;U%PPCxLR;r+~W#!cr;FP<}BI%oOg96@S;WHw+EIAE7K
z;LtSSbaB9CX~6Br09k6#(`?WyaL^}n(64DQ;NoD=US|H6!7~pA!+RtT8V_-g(xaP(
zC}NnEs*^9?l?p4tv`)$=zHCOYcmBzic-V0wU0oo|OgK|YFwXZpD2wA+I-dRVJh^H3
zHtf9G?cvMs&fDKWCmfQl=o$JwM;LhgqGWp~l@*nldNoe)*wU^OFC~t@6l^t%NgKZ4
zuHG%yKjJ=l!60d5da@^;c(HzRB<oqPh5+~vi3bLtfZYEusrOf^6OwEoy#`WhAe9G_
zX`r|!l<kBPo{($-g*iXn#XvbvNYhbM@qhxHkgNlZ=_x6=Kv7R9@Tsom0jWGt;1kMo
zLP~_Xs)vT!Zh2X#Mlv1}H8fOqLs3sikAMUbNS=VQpis^eN_axqP91fBNHbDUa+FuF
zS5|h>R`Z1-omTpLR8(DD+z3bg*WBDmkd^_-6OLM$2AaV-8vZu6Mv!9S>PpgA4K4S$
zA8Fd0W<9u5mf+xM7D%jy7VwgtPgU=pHC2l?)s4vZ9H7`S{j3fdYlrWN&ZzfY^e2@#
zIa?ei&wG%vGcB(88&t~6`btaM#aXo5=^yxf4~<v$uL-zAHqU{=q6FonB9H4%7AZx}
zH?t2Ot@fSj2z=Wb{B)no@hqodSHmol(Oy}cT|@A^54ot!agu7&?QK;+vc!Af3nFbB
zybO!2wf2*oG>iQ&cZa{-ZC;!hpJz!T(w(omx;Q%-)Sj%=fD)TCXZXwgZf>ul{e6N0
zd=Efr&j_mqM^_VFT_;GR3GylVHG__IYRvPzXkg&1uIOce57t!nmXz{LGVim{j0-ht
z_`!h<Ht7pX7(waK-Q>jN#44KgsON6`mI8&kuxl<(aRkdycd}JNxa-8d$(2E2FMFNh
z!n&}~v~c}qTL)rqUw?M2+FrkuOlYow%%bH~+S}}jHfS|5v8rU2baeLe^O;Vb)<_Ou
zTtBJz><V^&^4?gN46>tRoKc6VVW7J^0ZNCqGj}HhXu7KwmL61!^p0t0ID9N(+SlI|
zN`&SH9@)RA4lf_%Z&%Pz)|{Wyk?K>PpWr%r!tu=wp`{D>lF%LvHM{+8<w0(mpYFhY
zocwOL3m(oUUb=eKSU$?m*4~HgF&Ou=Dc9TBL~U<Egn_Q_`ub|d{@mgc8Wik|@KDUn
z%f5CZ>hY)^6znwAF!}oHXLC(^9c>@QX^*KDDLJ7r$R=Fhz&t##IX0x5meIQXC*S`l
z@$id@%!oQl@s;8JbE?x8e)#z#)=-1-Kc_l3K^uj(f7CMktrD~QpCz8Zr8-|tn?z4{
z|4cu(c4(0Lc!x!dX#MiVzsjH92AAhR5|7L9mMyzbNIm4PpZ24P-?a=uDOFK_jTQVK
zraJ#Bf2v%L%~%M6#tI%@$;5a%6)Gle@A{j>qjCB8|HGtSEF|$LL8;Ea*E0AuWmu-j
z(i!4D$*o9vY_cp-2jGMe<+-ot6J(@6LgRX83FMNUbt-Z;qF9B;1OvgE<3)&+*wG?0
zx$Ck3QBXCq3N9=0q(~PE3m5Vg&hO^+Bqcv~@^(v6Ox;D4n8JVs4I9qtTHa5sV;Vn&
zH41q<Di$LyFPtRohm&K7DXS(*#h#lNI_hzQ9s&(~0&3)X?Wn%%wyKY2o_kfc3|ub(
z$i|aJg>nHxmBn_9*p6n=nT-N{HUON&PHw3Zy9<S(_Cf5nq(B2+pUCV*24lGZ=94N;
z!9K1dJ*6F<?W-80oc;n*)sE{YiF*%r6%zJo?tOGxuaTR!6ZkqxJ~E1yLJav^26Bq#
zxd%=S@f`__ClXoTUh)F?cML-M6Il!?-9f;^b<fQ6mxOQcU#jzdlyTWNg0k?`PD6=3
zkvk>pnpZWB2y+1&ZZL@`z!d9+B2H>>)1<JIW*otIVc~mSO3M0YNxS-7m}1GL=A63%
z<zdHf>umvW!1~hc+44jCc?fp_8hGROQuW;ltjjqfcIKdD<hcpncbv15@x!$113~=y
z6L$%j&pr?jE%r?i_X-VM;}w&!cm>9Q3@%^|w!NhT7*E4qPar*<dI`R)Bwcl&A&e<C
z2!I8IQIK(7P(t5jf}kQaaDh<h$xAqg=L`Erv;k|-KqT&6-FalTt~{}VpYh@0%567L
z5V>bE^(A)PV|sR1e*O7pmw0MyNXNt?5ky}eo06d>8Ewu7xr}!@*G?ve<x4JxTam#_
zR(v$k2kt!VO@zSvesQ$L<rj(%c_J;pzd-<2#FLNS7*C`2v^+wO^(kbX+VMW(X5gbw
zT4?y1;Q!+7y~CQy*Y)p}LK6C-BO(TnqM`;w>6lPM4@e22g(4jVq&Jh$LJvhc7<z|*
zNLND@5fIy`*gzTkIA9kYd6zSLpFR7Wedc%e?|t9HmH$X`C1Hi@em>v(x$hAKt!p!8
z&*->~K-E2{KXE84EsB%`e=*@!gso)^!D0Xo0nPIm)mM02p+|Iw$y~qEGVdCH0>D+Q
z)f&!%QRC4SvcT5OB_4q3n~K<we~EHHr%HD_V8@UEo4_*1hyYoEa)9{lscON-93#B<
zAW}44&u_)pQ5+-MzYfnyr^o0%cjOqwfmoR-lzA>31VB{CwzOn`_<%5W<I+jqHRjch
z2iG}6roc^D?B?0jPT9fT5$+Ro2nR`YJBppyW{cJmMM%7rH2$Cy!s{|BQ*Sh5gqB1G
zY;JGDQ#m6lynd%>dzsRAl#FwtSUdNYFki^L9n;|>U=#hAV!+b4@BS0f3|Z`K=#U{@
zR!lyYB!`hzCIUkMls^pza;Xb+_p{i`+Z7K^?*?6FUV7+0e~QYS;R=lxV7!P%+XGj&
z;HP?vFkfXV4fr1)pwrknC<~*p;54h>MEt6FBE~iJ%G2t2cje`FUQ^$F40TYbF>QW+
zP540;3l67wh>7_Ulv`%$jR&3ew-d#eTv#mA)$)Zzy8dd@*x@_kz?IN|1L(IC%q1U%
znucWwexLSd<5&^@^@gsgXWB|5SP@{>PpTnvFEo46%b!1WYT$G#ad<o2b}&Dewu4%j
zH+DYUcEV5WA(b(Fw;H=l(>0K_P5eDQFx*J&jVVY-fdMJW)howeEYP`BVZ=4UJV0cf
zti-W)hupX1?Yn(|{h9;!{&^tIm8Bv&fDKXnMcp}3008Gm@vqwPACH+cww5Gip1!Ka
zTkEg}YeKPozx_h8_bW_!|3pws{ehV9+dbN3I@Trp7d(xsiZcZPMn|>s&NvSMcN`nO
zE)ID%0c@1&7(7e%V?XG*J9w}kJ38SL-GbEH@lI%`{E3^Wz7e}IDS6xwJmHla_*VHW
zHk?|0T}=<1ak33UUhB~jDWWpOH<Etgp~W<b57S@UU|;{XA1DEH`Q6e;68_!oMz>dn
z;rN(^gnQA~tXSI4FN~ghK)6E<)Q*Z9ver48$MvIQgIM7z(aZrq6N-F=l^ZTlLC=l?
z&0c9986%{8Srxl53$~fwp1!)cZBKU!zQOL$aLjl1v-&Q0Wvkc8U!<~azCr3-#gLf>
zrclJFN$;A4S?otrp2py_ZMT><lDJ!CFqV!kB3`A=cf;>{nv9ZeKz_kbS!nmAHS5I9
z!zBY4elm!#DloHV5Z<&vWd)yThZRbF3g%2SLNdliZdr|^9Y69FBX**zMZ9sQxV%@>
zyI>7s-sN^BdBvfRrwa6j50T3E-S#PHZbB4#M7h+bYndVM32uZLbMwT!_L@vceCf#)
ze*1*+ZE!%a4r`>g;Y|;Wkk2t7A_v35x@qF_OUhK^avM>qoyjtf{ca=h&2YN(ea5*I
z%&^p32L>w&yKXjno@K*=ym|3Yg)FAOCYP}~#N-ccWqlZQ6YZgIh|BMa*0I3HZPc*D
z6i^qx;1#}u`My)n&}}-G>);M`dOtth@0s;M^>Jvb+HXIL5fYBVQ@{xR#%1J}JI#%T
zQETAPn2@@TRlb^Zuh$yWE0ee^9Qv_atM!G!<ya$`Up|hc{=Dx^-{?aX-<RjV8fdiq
zHoAhgi|ZC|fDlijz1Y>yV@u~ZShue{QT$t3!HGN%GcjRKK#C#x^VlC{1u1y>rTjU&
ze^lxP2+O7{egCN4mZ@2u^Y!7o#(ignGk<ltjyct@yFO`WrPvGuPH8{-e7WGeMd^Xx
zUbdud{$$QHJ$pdp^~pzBj|!MupC$_m)$%TX>)N^1a1YzjL)tVN%f0yOmfd$I@*MW{
zuA7SB$kyhQfQ`gDH?+6USxs<q?bIWwU3&GV8+}JHL)dmR3CSitUU{0uO}`zt427jr
zR3;2Fe9=Nfbitwoi*d9<90S+u4lF4tWH5L|1KnWCK`wqeqQU!Bjd!(*7sjL-Yrz20
zVR(e&0d-#d^HZinSS%~;9$M@a4txRtPr!6wDNT0+?Wmn@6PWJOnobT(_s|C2$?-NA
zo?}$-SRe#U_{0l&T=61JBrq8V&I97vcraQOjH98Eb(wLhV03wA;+=$AJob=-Ah0g@
zh{m@<;uVq?IJ-p>(ZYk1U?x%>)5_&Xs`DV~vM?f9Pz5ZT3|5m7)w5Zs4MY<&8@Va~
zSLca-F0e+;9>s#4fnYNx{s<dPjl=%(3>4$UH*nH~R<q#hSpW_LfP4T~kk=lGx`qH~
zLTpgv5F3mh5=>F$yEB`ehUJUH<y<os?8E*jyYE}!c{s%HiRFJnj=#kOk8yJNefV;R
zz$$Z*DGV^94RP??sa9S%T?hd3;Hz1S+Tev1eq><*+=6vY8~jq9!+~l+afN6L@JhJw
zT|5Ytf50OSUBL^Uj7!)U!q%bF`L1QaSNQ;T5m;F8^-e)DP5_~fS;2uVTiB#Q46w=;
z0@wlow+OYGrK3~A6Oow`2VMlU&&8GS73MU$6e+jy^RE_Vh8G;zofR=#P>0WIVu#Gd
zu?F!{RkH#U&x+yk{5-r+e_tuU&XTeK#lB?m?*^~X@(=_;M6W;>^b*q!CRh}`C1TsS
zfpBj@;X)z!YLPIk*zGRFvG|&n(3vXWuVk=xR%pT;G>QjX*sN$BkoW}=JycT7ETijy
ziz_@4m&-URr%?{PeZ%E~<LDRy-^3j-KRy@k&EG`=m+n-Eie&wYEm3P@@x90zZp}yQ
z<Sfo+-Q^S_RtrDjz<Mm-6LNk%KKu;23J!<Qkp-r=Xyv~aiH^qqz=Z~2R)h{Hbh(sk
zk&FLQJN&$`AuGF@Sc$C5?jj~W)WObB1u`c^zhHn8ZE%(=dgBhL_o4(%FR{2=gH|s`
zC{%rz70p=BKx|~t0RVlMuZx6`2^N*nt>1157P%%j0d+itI*$N;o?c<Ne8YZkew?o8
z;bl;#z2SHOzec6-Rj|>hQkW5|sB$?~rw(SB-Do`$t1~1XL<(Ec#0ec_^TQ}&w;SPa
z8;|ztYEFv<wKP2+Z?d;<;#-Z-)fCZi0YmmQKO;0Bg~je0cRQXPM?My=pdMKl9T}aF
z;F=9Si~;L!wWLv6v&>^MDtCrgwqDyBY|Yh8%HM1~FV$8=X)8@=E3a&;+-$CTnOL&i
z*7>Q89h^|F+uoee-dfqdBmz%^4iz`sIWir6x*h$Lj)8=ZF7wkvBOPPQ9Tzq`xH6p+
zP;5V?b0(p4wz6|>q;r0`b8)kCNv7+%Zr4pp*G~yucPhJ<N4oAWcRk$fT9N5~tlPat
z>3*8f{k*dK<w*DI<?c6|-Rm+vZ*_a#Q+hro^n9-D+58>xeBbN=w*Lw7RB`x5|6e1X
zt^aGplh~dc1bW>&=c6~^=QiN~Rh-Nk2&j_&xs~_$=s;>jTDYEcML3v`8?-O15{^((
zxhsgaAB@{8Q5){qfE6$zgAD*Ms+u-I18G&YzzU{yWsv?=e1gMQpbEAx@sen#D?0=_
zu;2hM@B*tyrt<Mz<F5=K9HHd`T%OZ8;v@j5asw+yh2SFms6*h{aA*gK!51+IVA%i(
zgM<zD?iDAoi$<=D*6V>`B%@3g&q5ApZVAp~fb#%w2Mg9w$1ZPu6|3L}YS?_rcPf%-
zqe&qD3p`!?IXJ-&^w7XJw5-*=;ur1>ovjk8!Gc+dj@ftB8dyUDb-9RDO#V_GU@`nj
zPdp(+5nIShyT^@K9n8m$^Qe!DTT7bHakmRd?OZ>xvsx-tdm?rN{yJb{&)9_8{fYhG
zCUCNooca(A_sPRaliJmjx?_|2_a_a%P2y#zjP$2W+^5Wvrij&3mSa=a_or;XO_5}$
z9rULi-KU+CrpeXQl(A{|`_rDX@=Kqlee`Gi+-Ll)BQ=v|g2!e;@6R0nHWMy;DN_GZ
zl>4Qaq)TztmlDP<CEdSdSUr;>JIm0YO>>{kNSb9<&t|VAU3!5J4d^U?M1d9QUoNo*
zi$gD$>4T>`FBj!ru9?4lMh&bGn5%V%)w+WX0zj48T-*J*ZrQnZfh)bCb8PD?ouO9-
z-RGKeuf*E#pogYfz$NlKMblpdZC{d$M{l=#c}2ZyKK1oHLtw#Yd|vn*c(WQj-`anD
ze*3%8*``adhq8;94PecE@oCcH^XkQyV~elvFTVM<xGsD3={(PaCBe5zS3l1$a`rBM
z6NtaZ-#K;f>dngY$ZHE9BLt<cEg;X!VRj^MjDje^o%{x(D77U8ktLN^<1Ka96s|30
z{~7v0|B|4F(zM^RSgGDFo?cE~RA+A=GS!>x<4f`Jb@lK(3iVP_y<NS1Ts^&<y{Im}
ze(tUmJ2!U+H+Or;2L{n3A73}JtBt#dgRh?(#m(ODn5UzY#W8;mcaNh~Z|EUTBzqH2
zFGmkgCkn)bNG4PtvfnZHqmD!;XA8e$ZXVFxovolOHdl(h3)#lr!OVqh?dwNzcCm7$
zkjSpK9-ht+igY2{lI%@gA^#Z37-D*^Zgyl>J1=i1A0M)(mkSh3=HpAIxH-6cI9gch
zI~*lCyI4cS(%!+;g>2{T<LvBWLv|&3`%;eidwO^}*gKd*V3SI9@%Ev(xgYiRaS1ub
zhUg`PIw@{PA#|y#Y@3$ChOnm>)ph@F=d@Gxsmbh=xN3I~Cx@dJp<(_<orn<m3=D$u
zT@ClD*i+m|5XOXXsF}I0oxO<#!5t!;39(EFldA1@pe0n>l8obHvb=nph!zH(RL8jJ
zOeICj3|c(|NZmc`!^2XPl%Nc|3P$poOj=tey)`YR!C$A&g>03YT<45uLgdrlfxxo6
zp@?<BYlbAnR5&@?Sn0+d-tFz=WSwp@YoVS%&<nHI$l9^fSO@1DVcv${6YgbHoM1Rw
z?0l1e*YYElBw7qryFPN&E>0lzq}xuN_PES+nQ$PSYI1*FQ+m46^Un1y>F~hD=C;l_
zXBOE$>-#N~xP(5Gl(#Y>TbH$a>j7$_$$0AW6;`}%U-^NqWABX3Osvd<PaZEavplS)
z?S3jb-`wh8wnz6tb<>>8GFQv}P=H;1o<o3DTqrpfvV6tIo`9n3piDYOm>QW#$)TNO
zW~X|P)53!@{f~wmwXt?_ig@$(S4aD(kf2ks{zh)DClh_;yzNz~o{53S5+R6ZZ{tt(
z45K(XMtI;n9Nhwrr9j9oJ=iIftQhWN4PCzp9^?pjMj%-;#Ce~Ot6!M!DL>zEGTAMF
z97=Zf^YKk`adC$TXBg$cF`p!V-((NBh@&LCzl44~0p5R=_@31(yzoz1tpBnHr~OvL
zba(KB<r~Vkd#IBdH&q8Z@1FfV@%=}XTfo_gzh$vPQEpfMp7?G(#Q7g2zH54&YW|BT
zHy1rV+uIWVO&05cE`KQTeU~r&2lV^)Vc*jm9hpH*jT;}<3ojJ>5#?sHXg7N5$jSF#
z<YO&pAgtVTzv+hkl9cGRYphgwv=*2uXc5RJh~`Jt5m3jay$Qidg{yeb=MF0q*{pqw
z`FlgDN*(42zGBF9HCL&Z`NZNvc$yqdqyBmpeuvL4MM5bUzf>qIxm%<dkkzp;+O9iW
zPcI@}26rg&MJWQVLj4wbRt}DQfQ6(VwG80sEGhETMLJ-mf_zw2dIKi@CUI}?F6D(w
z-fS@`pPIU)EZrn3lA8T+cu7j@Z~{wJ`I?12o1Z7rl9-v~BVKaw4R2u+A0^vCQQ%se
zrFD?x+6zLY?pE4Md}IG^unC^0z)GzpBlj4qE>cLUcKgLUI(Jmmlgg3m9j}Z#fpBHu
zD&JJL>W!z{L@VkUB{bs1n>nzT_nK=L1CeggZLC#Uxzr)#ltbzly_~}u&7Zi(Ixl)I
zSfu9j@hM(Hk?5MYYL#4CpfM)reMh!m;UUqB65e~3N&s>ai{k|caYhsSU*mu|g%XSL
z9fB6D3*hPd;2b=?iX|hX($1O^OirpN$P9;)uzNzTT%X)-uTMIsCN;&Mr?@+@^P0pL
z0q%9=T?^6zPuHf%dB88S)0n`&cF0)as2<qrebVn7!QHs=9O0GFltO(`e;4Zka&=$7
z`D4?ql6}VCB^@mY=QSLk%fkibel|`P60l!Idsma{_%+tF2|L_U#2zCFa)poOJiZq_
z7cac<Y2d;4#)dP(x;J;wQYmTOxzE4z`uvikM`<<+?(AMO>J`@1%jEfp#J&lB`o{5P
z%kMonsnbdCZ@N6%cI~Htp7R9qi4)h~zfb-xI<z_Q)XsU{yn>}iE_-E*H$}%!6@EkY
z9uRvQaoq7E@nhB1I~nh<T<%c4Epl}{?IgTS!two65#(mU;RmlUV-NjVjq+0r{`fn~
z4ijpv?|-GIzDT=S^0xgqdt@+wos6a7Y%!O<r1^8=Z30I1Amb)!m*RU1A+P5$uX)p;
z<I4K5t!8m9ow&Hm{60}Mes-z_)0;(7<NsbyoZj;z@jbUdzi)PW3fb@<iSItm=KlYY
z_-<;rwty=t(z$rkepjrfo$MoWss3B22M5YxMO)1Ny$467KF?IQNI5pH(efc3^d-KP
zKRVWE{Iu?}?V<??d^UZ5xK->3pWpV{T+AVX!a3(sztcY9O=<-A71!k=#dBj#`}Y=I
z@z@kqxCt1mowAtE=oAHfh);1+L32zXC?Z?+>CWw!_otE0R_YZ$-Djl)-VcKr7#=iL
z6mMNP{1E{xXwH^>BTq$++$c`8R@A*&0csjH`l=_XM0t8|N!9R9rEdy6&s<YpV#vH_
zhrQk|{VRRxP|C)xFWSs~NCigId<0f%x)m!=FguQElsKq^CYbQiA~9<ycrP0G?#+t9
zAo<{T>xptK){dL+n=!pXwmbSzFl}U$6znA?FhQg~p%DXT(oGFn;K4CK9)Auaiiw0b
zDW^3oA*Re@3PCXe69jrU0>Bf%KGCTTU>0Gey1Ph3mW|bso^=zsp2o<fVxvtlJbXTx
z^v^5u$Z{^eT$go$&jf)OVs1;of>N4nh1lQlFuW0<Ok5L0Q~+`#e9o!XG=NwAH37Gm
z#midh3^c_!zj#td;XIN5xXa=IKtdt6<kxuNK^aC<mY}9KQu+$<72a`=h)J3svN)OH
zV9KSz*ikTmIDVAB9ssZ_ZPFlsY1X}aq@Rnub$&lkz85Ho0e%?ujrFnQR|;IjegHt~
z<7mQ3SO5n>V7_`d0?7tMpo}35NE=1r0W{|XAd96btkK{{%8eY+8gQZN6>JF!54&Im
zgCPkV5ey#9;xM3;6QCd&f0E}bOuT;(D;o|Va-kriC|aBH8vyRJk_s1x;6DHpe7V;Z
z{f&JVc@2PtVp*`bIQZ-W4RC~BRiFz8L&8h!;lP!&xCmf{2Iz;U3aerfSl|^e27e6t
z0&IcaAVz8eYyI`Ly4VUQ%woUpJ-P`4dt4iHMB;6L5^1UtZb6;^@CS+{k&@icL?KBK
z*amQs+f|{l8H(a0%5ztgU?>1c6D(ihefFUj6oR^!J1GcN0FD@gfCq@>7u<$V^uW<!
zBpA>vM-&ka0k?6mNDB;|R{-ZJ1SF1$U>Us3yfl6QKy>WKpyoLARBgzoIn;430;G#*
zv*!es#s#QY5UUNt$O2(PDDY7#lG-j7_euy#T;n5e2eet^VCgz^1$o2actAv%OHR|r
zBKOV`cp*=xcqf;q_|TA;CIC|^U+Ka^F@8QY2K_$JwtEYp@i*eZZ6t4=02V?+3<gx)
zr1Qr#V+@guyy83cQpfQcK|Ju6O!m!A6mK_$zSo_KUB(tl63wIp0WyGnDHnm~m0S9i
zr+)?Jm;vMS=fG2?u?X!Y0>8i#d>iS@YcnMb&p`Ka_^wqLRSA!JTni>3RuDVl0E`+3
zE}^<I1E|6gLKBGXCM!tCR<3ju6>czAhcJnQAtm1&1+d<LE`F+&-ysc=TZ`RE>&Ba{
zlNF(6HG%L{UOpCD4$ppV#m0-0@lVn<S5Wax7+kdnP?*QwlL(|^G(q^KJ{pS8oFNDH
zF(gTJjH320yfYjIRNaI^-!a$%Ls@XGF)Y7s+&G95rM*^Qe=U%h<=cZz)5rM;Gib=Y
z5&KcqPXe@&FhiAV0XvV0#F~N$D86blk+gFT=xai`G-nPzx(G!P0+9RHT>#K!J_a~%
z4lYH*WLDtwlE<OQEz~+ak_SMsVP}-U2p)<!2MO;5zD9!x=!#f}J8|FwAapG`z-S1m
zSRld)6y_o%*>Ft&`AiZ9vJeE^DM>tXKQ(QS3-Hb*N{|4fMk5pf%0B2{I4(j2gmTCb
zi=}Z#!yQ&*V5T&XpXNZKhKb-2x-^6&7SxA!DA{m%4w4`G5-tHI>o7Dfiboz{n9hU}
z77&u3U?{HRuAu}HfOwYydr=k%uwf`X6V8Dv;<6C(@WoP8p(8p1g_@np_MLL#i4Z`G
z1fuE~k_3xj9$-inoWg;(p^#c*<SRu;=wyoFGY*0P4DY)e&6DE-UW~~FSh+BKYT|Qv
zjX9Wz;W0GL(;UduS~*Ijp;lr*F%ZxtA_TdBwKDXm3^*Mo$D%xng-hUI64MCu03GjN
zupteY;^4n&dk7Iwo^0ThBvob|*vm!oae>$-xb;jX4+vNv4#Gu)L&~5v2{;n&@*M;0
zVZ*I(u*1_ZRe#spl7K%I)W!jVAZ#Zm(;x4s1_DxB{s=xcU;zM!amZa*$h8F1#(~Bp
z0CIG~BZ{d?a0CuW#9-2J7@l6rdv*KEECIa@LDVX0m@Goih}uoab=v^8eUedG3UR(A
z;%u?=D^=(zD2(&wKgSV`hy%TN0l&*qXw3F~Tv%8P@dFowB$UGo%LLO!!!DaXWR>r_
zCg`Jy&DW_Yajn?Zi<9=NNKG?3(pZuGUQ2DQqJFoCo@Qn6dz0oit7|2d_Tq%j-NY~N
zEBkb+`dzCA;;V)#sz!#Z#_m=@b}sI=>It3dDc9<m`04}#X7;XGYj5@9m+GZ$HP>~j
z7j*u6U)Qc)lcyE6FNbSi|Ff^_bD_n@|ADV7yRjOS*$G*@UfI`4{=2@eU`d~CA|j_7
z3^yC_GL1&MjV6?T-`ADU99a2>udBZBW^=eqOQdc~6s095p(U=eC1Io`X}Kk3v*k2F
zkk&3)q|=(AtJpXt@;#z8cWb#7B7Q6xi1_V%f@_P4;4g)sAD`UBidbHh4L?kX2i9(I
z35>j3j)VzT?GbxsB8-w3Si^#)ns&Vuu!GdmF(UrX1S~}Y53udyOKq)4;2RCR!x5xR
zgX>ht@7Wf#=cF55NFx@#$_8imfJ<{H^|d-B>e`31#Y%Uz3iAMoRB#5U5ZK5;(A$x{
zLXQ%}@@axzCSA9Jz*Rh&{gS`e6uf`{AVMzpp<C~o`fnp(pDO2Qp)Ih|jrrZzb^C=K
z_<!f?y7n)jU*fh~q~CpASGJjt{_g7v+2$$o&%UmE=RCijqi!GgJM^nd4<85~9SFTQ
zaQy246tcS|GZ^)%U&3jSMrn;3mH1^`EGM{W!%^h(@L*a;A78p;rrS{Vs0ccw;ncl>
ztgpS{H1T4+;bD2H$ljsK(cx-0>60M?59eguhrtbQcMZP?Y_Ig0z2N+^XqR4P&pnZ^
zY_R!?NpFsbn5o3zc4B1wh+yH!+O|JgyLg~1qC`03cgkbKJWnc^-nm_$lsAd@VOeL4
zT4#>gWR4QT8+OVOY%<62;f=P;^H6J!HS?lv*0`;mv3>pwF@4N3V+=A#S!bTNVO}sx
z8@0_kZ;^4{mU#i<8kQLstkXv<(?^MEqc&L=teNMnpy$luIuuM>W?rB*&4!eY2bRxd
zwa(gRj~}p%vCQP!FfV$ap0>*zBe7;|b0<tvN6phlTv9r%GN5O^5LP=+2yb-A9S^LU
zBlxf!b1&Lvj@V|7?vy<O*@1kD#@&l1DXb~Gj8VtDi9P1gVPzMR>ZY?h7eXp$Ow+jz
zS!0ov+@$)MjOI)B+1$vg$&=NS$I53}otIM^ro4+MvfD2ouf7~pJ>i;v;Y8I;e*3IV
z=7orwnWIIQjOasFX(Lv#t@??BRxvHaj4_*x5%YBDU5`;{T~?W+_Rt&5o3ex6KJ=Mn
zj@cDV+h>hpW%cEE8oA{R8Z*Y+3eE==pZ6@8@+!Ds6@JDf^}Jv41&6$;opMJs2tk=$
zOYwEH#heB2vdj6+;|XUb{YxjQP-Z~W9L_2xw{0e_hFj8qjZ!@0U&>|mEK&-mQ(NXz
z8>ds)lhHNfd0h(`4P5WiO9kBv`CW6t)$?{a<8B2P@xDbC8C>&>iwyQfyR3`39dqsl
z7f;q-B{9dco4E4IKlqy5elmp2AfiW3YBM-~hLSzzlrxsuG3Ssq;+a2;r;U)Z$4*vr
zZ8AqJ86!psJ?2qO_)|lXWh2DYVF>(LS{oeF@uamb#5G)H)K6r$Oj$C=gGwjKtjX{*
za}i}1%rnO=)6W-lFXne#F7I2Y=$kiBJ8zRQX3rco@yd;4FC6kM4J;gqu3I?Wbt$ps
z>Jf*;qnSe~^^>PNXI%0pPn=nRfFr~cot!Nbt43@{1SfoM&@uNzYF?c_?<^0MSQ{jk
zCz0+C?{_!LFJ!PFa26lQNQ$XUOQ}2QUpG|ccG879+ve;~t$BMz2--$fRIof1U!6&B
zgZ3c(Y=fb7%)g{O683*dc`VL0|BooopSJh@I<WuWq&)pE{*A!?|F+lf4{O)+8y!Ea
zU7ImZw}#K0IZF3Sj@r2W{UG~40{cHoZ3E$V&Apu0EpB2>5NaRLxEpZ}+`l#MNOC7L
z^`qkIRF>IB=CN<18+STvHVsitP62N%c_T2?CwbaWTc6|~p5ZFyN6>mN<)B_XquF8(
z_dh0B&D`7-5%qdC6OECk0&pivn-YAxUyxF%*YR+ra+i-jsbyY_tR}P)P_*lW@N!h6
z@pH#RErjU(5-Jvn6HX{ztTmMYoDh)V)@7#9=sbd0UAU|u(+GxvSqIP59S${`!Z1-w
zG?cU~i@r@vT%M*NA{w-$)1Gh$C4YdrRX>TSl6^;Osn=x92x&`4grN2ds87l4)P5_t
zy-;lf8X8IJOi-*dymk9wu-8O*$7_7LG@Qc<_T^K(6C80!(}-8g4M#`r4kzl;c?I>a
zFUSXWh6DS&^hIWbDzWxC*e6kiMsf?*MJ6)-_gOH_15}Z0QF}};6B`z%_hy>fCSoOh
zP@jf4q|0Q(l<&R<89VIQ)CrhLNqw56yq^OaRsWe|r9ff!nTp!JXI(-I3Piv~{c`)J
z1mx5hlOm6NUPn3q%y-mMyv9);DOiYSWGZFOhr{{U&#4v~cGiUq2~Aafn9v^LlXO%l
zmqq8>jV(4&QUTxQitnRsF^sV0^BeD1$hTM)DzQWKabD*7IM3nSY6e<NMSsGakHp%T
z7I&9^%d4`3R5x*0eC?$XApCj7T59ONPmXvo(Hq5+4D8ol9kTkFCNsYTpwAXHu3wgL
zx=F~^$~jq=tKJ~3PE>Mfr4bO-`0JTF%~-Tnp4%i13(39A@Kn(RCT>z{92t@L=C$6f
zIh<$QGD9-`d9St79z1;(X)Df{fIDN&R9Wlv{eE;_gP|!U+f^i=W-!tKHziCR#~9#Y
z{9_zCO4dGIpWK;@b+_EM#-SM(Qemcd@POtLQaTPA;8YpAiB#CpxD~YW9R{DMNO~ZY
zIEQ;)!oOu04#O~4(S3mo9y3<DJ-NZhhQCfcO9Qp7WSs<(VMsVOo8NtfB!wA=j;zh>
zBzy(WvJl9r&(pSH>cFztIFAONp{EH$s^f2oe<F%|%yJQE%o@*Oa27E{W1-0aT#`kU
z!bQUPIo$0++$KSHHmls)PeCf2&Qrb$3jpz8{p=;qP^(glpCAZXWZ*+ZfGG3ly<WQ^
z%Hsg%bT;ja-Axyr1q6ndh`aX|%{7Rh)#KA<?2Y6Cs9h@+yn)JyNMIolidp(8N?Efa
z-X_rUWYsOwbXJDNVl6;`2@wN^CQjQ%cSE(tel2=G>)1v8B!+pS)?)bS^48Uq&39)2
z!B#x_Wkr(cdp3qg2q!wXlmWFJgUNX~Mayg1l=t=03$12abJy|{-Zx+c+la!OjfIu(
z8&z%EEM4ZVm&#q*u^;O73$VOVx%|Fad!fxXcJ4;)=KB`BU^^+(@@BovhgPCZyF=MX
zm7)5FHd0=@V~gdjcFKo#;&15={n<_*O;$RTR@?DYkbX-^NA!rG;|1Ew^e^v%^V0Vc
zmzG6G`lh;3<9m&tTMCsuk8X_IVNG@QaW42Kp%C0f^oiCWXUoQ5b8Kb}M}mtS^&5Ld
zdqb`Eu)%qSw6pFToyIc!%c<`rfa23Z-g<qM`VvWn9w%bx4u|F0t!BRg!SS%;M||9t
z;rM=mLUf|?$myRXdAhm3gu0`P-09C_<gcdhGppQwtH^A6$fRz+b>+Q#snk!3*N$QQ
z&vZQaxazBLD$p`sYxzN2(TCBJyq=_IR*yE9KVA5|(3A4%%A@a_pDqGI92(ks1-|_=
z7h}s|NI~0sdY{L^kC+I>+)>`6pC_ajIT>2>-nDNVCb2@jOmpkUqE(-#RBd~+UFIK4
zj((oT<@e@_Ei<>>`#ht)*qa|a|3vQV=Sz5@K31mnn!@%kvqamzqO$ol<$_n+Z1ej{
zT3%NK;D?1B7yC*F=YQUx_~i;!=xlk=yH)k7FY|%6XDe^dKRrD9Wosck|7`U$>u0+6
zzAVNqo~`{f|IF~~m#Z|Pem2_XxzYB`C8lkEz0|^UGri4gto;5)6`L29ZkyN37yFyF
z7GBsUZr)%Eooh9>dFfEKd9&5_Tsvg#avt5h#mPU{8DR5@a&Pmep~Z9Eu?w#}zi!^<
z3Jq{FyQl-AU+>J?4)i65J~*cL6|$lX^tagj@?(4N&Wx&l-@-4)6TjYD5gHu2Wb-Dn
z>g)aIwu2+L7v98-etoc>KREWx=GTOKUmt#69K7&p;n$R}UmpR&LtM1&I%E5{6^z}`
zgw*1ChTgYTuwZCP#dagx?b~DNt3xwdiyQfg-=1KFhiA=g-xgJUTT?x1H$3OE__lQP
z+t0Xy;rRgDca`_PJ=MNCycoOquJ)@tcjo)>l5nK3YfjDq!o{fT!u8pWYRPx(c8=U^
zv5nq#X7DBX>c~%nhCg?lOy1{d7j#Et$DedI9Mah-(A1s*007jVy-&?aS=re@+YGA5
zh6*iJR7g;9^*%Lc=+qRl#zXyz`r4*;*^^NHBh-HRW5>eAz@c#d^Ho0RL=jrBa45KJ
zYllB#OfWPi*jb*kwLAr_2-svz+A_!Ovc^d{Qx=&MR?JE07_+}(uYtBX)Rtvs5hpKi
ze>||6WOWJ(Z7?-IVqwZqQE{=eq#2nRLr1ta*;8t&PSA;~xrLtG4m=~N7E*+ch4Uu@
z8%<KV&}k>6y^fVmQy3hhh(>b$#88b!%n71>_IPo!;&81Rr1gW3RVBw(Kq}4D;AoIv
zTYlGkc-53w;kZ-DRp^+v&F4*K`e|scz^9CQ6koDV=!OP{w5FL@_9e^M4oHJS>OcKd
z<6g6qC&FU1^^ZZ46k7FwKCb_7f6!Y{jc;mNdPXKQD?2AQFTa3QSX5kcy0okuU0zjP
zQ+tM8SKrXs)ZEhA*51)6%-G%8+gGi6c3^O5cw}_!{Dq6$@rlW)>6uHjm*=j`FDzbN
zx_14>&09a+zH@i^-u(v;AFZrDezNxS(`V0LynOZgmp8wzZ@hi?{=>&lpTBH={r21U
zEoj?QmdIg`r((qRxX*IxCNn`r%W7h8{dA7>!Qj6-P5hxV1N4snxfrUy^;*NfTp^e)
zIoWYL!s5bzDu(KXZ#|qlhVuSV?fBz3@e`}r;+*q)8=~)e+x85)gsp(Ey6;JtT#H*$
z2%qv5qgN>tNp`boKdK$&Y-IZLZ|GX4<|_<W_*z$<pElE3MKFa2PCR)i2&WytkB$1Y
zxKBUlmj~R`XW!Wkhx+a!bc9nM3R+=A6!f)c->^qNi71T4eq!$c;?OJRQ9I=^X>sVC
zeVM@3`#P6^lG8qfn>+AZ1fewStb`oY@<3x?RWXSV(pSbM0CyY{vv4<nH~PCt%&IkB
z_AxzPKxje^qmOa$VYta^cwzWtH0bFU@tNNH!FjSIXuFPu%L^rGuVN2^jFtRda&IRw
zd=z=+7G@{+xs{)csMybx9Ws52z!7S^l7a$f=w|^U>hp~f+X+V{@!Rr|kFl1@qV)(s
zT%IT?)Ht+)ab?&)t$iG&dPd$zjh8EyO4OFGPG`Dcau}hPo;9pGemNuW66(sNX9V8%
zWdlgQbgUgqg;>feZO@B-BflIde_q7Ljg_goNvFNM%u6c}sce6Bi0sa4Zx3I@rN+t&
z@N)&^nK}sZNae3`)xYUrI~n49jpN;J5fS6)wJ&$Nun$lw?PzQuT6s7%s^j?3c{<lK
z8HlEJx!Ai?d+J0UhV)=JKkk*k@EtXOLOg6SWc?svwrG7^K<}N*USX}@n;k<pwx*>6
zIyYuyV_$Dv!e+iMkX9)B&()6a<~48sQSJC{QUBAAYR8-#CjTgq#(Amz^8N<NeBXzg
zjxIJ)H=F~yKKx|y+w_Oq)ZYuF^<1s)$|vT1Tn?40@w%s8jECPpXikkqMqN@He|XrD
zL01t4MdKb4#(j7ts#Up0{3hV{J~)3AE=_)$c1j;y+K<H8mF(7Cx|&9-#XQbBz#e~k
zT1qtaS<*I;f2{?<8h^yFzM#9mKk=r{-qDlS^%m;4kMpfnBEt0!UOd|^v9?22K8b%$
zi-7<vtuOw>Kj{mmu3vj~h$bK0z#wc1^Qp3uK4D$h-{CWZK(hL<6oc?hZ7-ph=X1jW
z3o_~kzGCZAT-A3Jkqehur(vww@V_XK#;NZ5%KoE3dTGxcy*fUZ*$GLgKpK}@_uo`I
z{{PkN_@~oEsmrrwx^D|vxsCs|KYFW}EzqQD{?7%{BX3W0a+}lwEUr+N-<A%|H|>wT
ze8qF~Z5daf8JB4>?<4cBJWgl3M%i8Q@9OU=mU5dlTPzlWWhSG4x;Y~<P_b}4;a$~=
zEISWxPYY-GRHtEUbdu|AZP_PlS_4%S*4i*{#^2R~<I0fGyxRHv>>oPQ^7qq3j7_VN
z)ZcVwUaN`9ztoxLme-5^q%;54A01$M7Ps`5I&<!3;-0gA)|uq3g?8t`xm(@3y8)_T
z2l<laPkogiIs<JwD3g@a-Kqz8RkiW(pDb^WEPv?sb;{s(l$Ta-2T+mI9aOXxnPZrW
z$h;3j!`<%8=t_3&x=Ryq;=pDMKlYXLpnXzTon;+<>MIuv^KNNlOfNe1w;tLH=Z;X2
zori&LC9#9C(3u?$4-74I9gn?o@8RahL9XC_B$7*$dGK*y`1~)LRVxhfF)FZ>*B#Yj
z_24Dt)5x8L{ZWD(k2gYGV1?&Et_-NDtjR?pi9HFouRQ!X^6C6Kq%(QfX(;Fj<6{^t
z`BjLQSvjp-T$T2_&MZ3$@?bc0sd*~==*o|fQ?XQpzBgaohd+d7?xo8X%KxNO_#vGV
z`#TS`OzO2}4B5~JEE72vKW;q+0p*Z*F{ETzCHI;qa4eJhtf2eY;4PE;EE0Q-<9e)V
z1JL@VMM95dVvkvT4>6Hrn>uWf)MvvOGKuFv`UT>I5H>W9?f$gLzgN}X1iDXBukEQm
zqxfE{<UaF+UbA?PX+rOAWjmvo9zrZ9vUqTxiUYLdX-LV0n3zk(uyyiT+vFaL_zv^L
zKFt&DMB3nym>y?FuW#--3oAp*#4dY!zhQJYv;LyKe>pLsM?b3DJOR4(*wN3KC!O_V
zo^#9Sw@mDV%w*Qqh94Kukhu*qX+hR8v-ob8^g(Db)g-n%ym-js)VY*1<DNMq#N>Ya
zl(W993l!!6B-|n^ricj~<M^KB>I;zX%`~pZG_;nO+;=SZY-rJWzx**$>Oe^GC}dEB
zBwk|Wm~~3uiNXQMzGfEJ<CHq!!W^bok2=%3C~18*$-REreHKX^NC}!Ia@<q9Lr;&B
zQ~My3oK-@%Ze*uxYOiB#Lvs0mNA@rz{akZK?b1j5i!RzSM)sLRKt4Px`cQ1e1^ts<
zUU_5A@r{NjI||ySAcSj`*bR}iV+F&$xkIG%kv&Ey%wjqM@&~LKL#byj?%VAcoOd>}
zaU9Z;K1>cocLNH~%kMOWlxA+rR8TP&^6(i3RAe>H>?VZeHgXAZ9MxSmJ9e1q9r6py
z?bAEx9e(=4iQ*A!V-E#+_ai476Do&~#BgFuhb`iJAPJdRK4KnLYn9k%65kh7GGH29
z8CN}dz$_xQddMQ_Y)0LAX6>N)i8Bt-XRH!BA;+G1V7X7$x$L^369s*?32iw|lSgA4
zi#n!{<qbi0KuX%VW2}p|$=zoDr;it$4JsUoE$UG>@K3Cr4l5jm_@};g4BjO*z4n5J
zdqHXn``}?WNH|04*w!)y61>T=m5>Vlf%|C9@i9z!Wy|5(1CXgMIK&SUu#n7zbStEV
zA<?R~*AWu4kV=KL>R<A}KXlp?v!inVb=A{%uKItO2OeW`_J=%_)jas4z%%51=k@gG
z5Dz@ks8rVf@;0Yu#6OVo^!1&gldm2wRIP=jUNk`cYV%hO++W|Us)Yz|@%(yzES|k~
z^>-fl^~?*X!1I8{g<y&I*ZLlQRj7-5{rTr-Vks->I2Ij|Y(%2f?v};^zrom80!pEr
zjo%XVqhN#;kU1fHzGZl2zzx)wQYGau`0R_W(%39<KFw7I>O-biHZUZ~NFIt-#YXCX
z4=gM&x-K!1>n#6;RV1dq+m~oAWad{G`OBr^Vgc{?)2CHe%N?>kvo)1Y8>YvzDlqa)
zzx3@v6-|}=yO~eTPAWUL;A1`CThxkeyzqDQEvjfV-u-=BNu8v8_L55W$dqbrP`gAc
zTio90g_--nl!__kZE>r4ad(NW4sI7I7~b049^Bs27yPoFGqJ^o5LlZ(d#^d;yVM>d
zoXokl9_Msc8)>v2nJ)>CQsDOe(ZIbwhtPi|m`zY*hBtWh`us+5YKV^rxqc8%!qZ?V
zkOUif-Q00}6j}YMd-Sa{J{^49xBb`QjgR#h?J|^m>5vla<dn1m9^^{%p;tJQ+f9}@
zlTvCp1{{(_co7ly$~ru2c4K-HhGT6&<)2t19vNxl9YeP^Zm7;5t+O}?AdCCw<<qHz
z37$5lEDdggX4~vEyn~B^Y0UScrBA+BPZfViwV#o5Bd4a}lvV4d5W8nd*&>pmbTe5Q
zH3e6-&{R#)OyscST9Hkysy*xB(;-qVrE;s{9bxpi%up>)e8ROyd_V6Hc`Wbbd-=e~
zb1qz!QBB)GZAa3~1@uDMcv!)m`YWK@6po)aKj{gdiu)8kQ&E7;#v^vhit@>Ks<Mz^
z{>n<<@eF?JZBOJ(MYDJ9tzOEMqTo4z<Z6k=gm75YahkX%=Q=~8_-3yWf`)Xk=I499
zG_!q|xDNrR;qE;ncr(1nSRB8rK5PB+DbpnLRI)>^6yLhB01Jfew)Qz$K07WE1Hwev
zaPhEKxXi>leVZm0-bOSN{$XBNs}sQEjrXNoW9-FGh&mAoyxQvd&TGG>yWM?cMpVZ*
zKIaO@e#T1|ts@Ru`$*4mC--kna8l*nC&aW!#u8KG{J435hee#xl*H+!?_-OWhEFSN
zkka=otqLlr!Zpbe7tclTWjx42?rG)FP-<MU+o~{8A5v!MXBv+S$(R?nnypE0;2{DN
zX!uHoMeYQ~u)JJ!43E*Rmgjfnzz=<9(Isv^=G$MLulDr%Ud`pSZ6i1uFYYHs;2m$o
zK7gT9w4SYHGAUrfHrBwv_(X;t3#eho)${9ek5{u{upydo909gdU{a_Sldj1G2c*LZ
zVYRvb-m`1~t`C{UTJflCe5$`YTR^;(pk#(klQXG<A6_D8OoV63Xf~h>u&#1y>wq7b
z4QSrU;7JSL%8<^Th`m`+rNXnP$h(k7T9nf~DZLJ4?#3bn$j=c96b-SG*GTadgrLSc
zEvrZkklaB5%%BEbh-2PkB2XzR3+KT8CIFj(R3*_WXF8gBhJtKQj2wWk^#h+?@3sxo
zy;)no0vG4vmA&`0+U%K;mS)kADE#j{kPOMRvwP^)Ym7GPha6=_IM62txw9adc6;up
zf%-!j0(n|z;t!b?x6lE_nM)yg3VLXQoz&iUE^Xp5943#IirAGq4;veLSxuLH?KSSs
zQXrYO(CM$GSF=0(<JlN{*+BEJrzeX(_A9%p1-o2X{%PdnIZj?zXn@td<*nt91OKGc
zy2CTA?mw3KG&F0|9a(ne{!`uC1NF&o_-k~<${$#dTs{9Ly4ULdFOi={rQjz*d?T9F
zvZT%)zmXMNxc1<kWY)-=yc71zUs=M}TrPMgi~r68mDj|-3*y8?HCBLAx1mx!oUpXR
z3bYc4BjIq~;1~<#GBrWjz?&+EgMun+<9w^(<_gxJurYE9l;6NBV;?hH$x6ze#GHdx
zp7|v5E@?wsH2BVk$)4;!Bu8ZJj(oyeBNNqy__M|I`~Xc?1=GVAgZ+_yt8dEXt(rr^
zYpp@IyXCu_O2fZ<E*GkX1kA_|zdbGXB>zTb#g>BiVPf^Pz%okj3HD^h!5WVcropLC
zlDs16XZ{@?=xg=V{vSN>?!&=<#RG4rUAgds2im;$+5QI)EL(W(|2H1^E8puNhzA<9
z9Ud6`-{XN>f6W8GJ;Mu+EM?lhuiyULbE4hI^|HnH&3eDRAQk-Jfgjr4e*1$5E`BJk
z8u%m4%QMQo+yfh+GP-<w@uQX9b6$;HqS*4AVwW2a)UZRN4|N)TfmS^az5Sf%@_PU0
zCh)>K(@x*#ZgX6F<KPCXU~En0Z>yeH$DV3k{j!+&{T*BQ{2!~H-`}^|oqy@_r&Uk8
zugmwoe;k4?%h;=5AAW_>;)E|iq2S*hZ{PYnYj@#o+0}1P^|rn&6<qi|&C6|T^Ul=^
z9|y1g_9k)b>xzp|e3Dl2v-PU2Z_n*6Zr;B7{p0AFVJ{ax_`@^5ec745qjK<+shpSS
z_g}qKKgULHsz`LNo&rT^2knFTv}lRmG@ex&W+M)(P8Yfs%X5kLzKm`$e)y0-9l1)!
zjK?X$7_F$ln!~Y)bjFo&m<^kuJr2Wysj@UP80^o%GiWGyCgJyKgb-Xw2&pnYamF~j
zPMg9cgj5@aR^fvybtsuyqy&6$6(O|RAh1%;zrrx6@<>pnVNeAjq|zv~+9;$F8d~%M
zDvW}wOv0*7!t0HKD|L@Szpc>^C_fTZZ5(!n5L$I4xY8JU!jLL$zj7^CreR=(QAm|R
zP?ddbLr7*DDXPXOxWXW?f}Gq+2r4_`mFt;Q?~&4EAJ=RUP(}zWjn40)rgjrgobjZ!
zYg00V)0z_tdopW=jKb=*e9JYx%S=x+X#15}M4T}`e#R)QR>!|e`&hYIcmpByj8SNf
zX+)iVK(#?Yl~HhwUO=Vw$p+i#dgIV)^N9K*fz|r{(95effNnvRgrEw8fQqpEeuvm5
z!@#QJ8LiggHKxaFjY7}p1y<Qc)*K0`H4Lb<jHq{tt#eLl^-Za_kFLwEK9^M77r<!n
zNNzDdUQ0dIe8ipU6yIbTTIoY;OgY`>pUF9v-enzJ;+E79nBJ*n7Z;G);Z1M%OYQVY
z>n4Ss4$WvuE${cs?9Qkh2+rzbR-KJ6I(t03GbE?)WL{@<UPo+hOHS=@3}j0!?uaSu
z$A__Pqigm2PODQ(4FYN$PF89Al$)KX(ef@c4ywWjl<spY+D9oeKEXDLs3Qbbngo?t
zgjEqE8xB)X@02x6ts1h8Y1(TTSkQQZbh0+>bdO_FhjUyVIiW4Ryf3YclU_0C6xXVv
z>t_?$U>Z{65>pqD*6cxVr<`iTdlyhrI*4IquJKKJ-o?<&Mx{4-#8vyG_b4eln}(D_
zblo++E+oD6L^}IuboGz9G_df9Yesh6NI~tOO-RY<rqPh}_K2*`aAsR1>s&-`Pf%t@
z607w9iAG5{lTtq9o!k(W-$@FuI+@2wEb2&Lbw!s9_|e!&#obB8{q(ZFjEX*J63(a{
zVbu*m6SB5_0))8L54mcYgzQlvL6eE%E*oepIUd+VOQ<2@$<Vm+V=M`3hGq|FEP)0R
zXbyoWIy9U>Gs$01Be1C}v%UW{TX=1z6!*VBjr_aW!m0c_|7*6e?fH=pukJv>Gk;_Y
zPv-nBc;;{Jgs-30pIkX(cQGY4>EpXskAw#w$U)Xo)fF0260;(Q`5wTAzZy#2mZIdu
zJrno~vxtB~`n9fR$i_VP&N!1ayQ(^G9av9}@MEPTVOXvL95yB0fE4eSR?Iz&A~ocz
z%{<2=b(YDBxuP`2lv-1D>n;}@`5FPuk69vM;Eq8}l9DDtKO<D7!|@0q43&X6CQaoc
zCQL-=r{UEv0JwuDm5w5?`_^h)Urg}H?5D!VvG#Z@7nWALVlMA*qC>#!o_$P^Iw<~j
ze0Rzamk#x-`dW*bmbW1#+`oC7@oTM-%xdDADH3vRsy>s_=1W_>a6T`}5*Mbf{bWW=
z3=5<kIt)Zi$^_Bu1vNt6%U_atqB=o9KyZn%Hx1{*hYA>boF^R9{&JrqZOSMc6uDD~
zQHJZU7-^qUTTfNgV0xR1yRpS)(Rop4>7r63c$U<;T<=Mt6YLG-wu7v*HY#a=@r3fz
z`?xEE;#$*t4!Kb|4EZi?meIlZ_gDmP=<Et0l*ja)RM(-M9Y<SgQ_*Tu+Shnc;zW6(
zP`cXVY57t7*-3=tQr*Iogi7Acg9fb%Sr~Ke$Qh+1?I+WU>MX9YK*f7|v`T`>WTvK>
z_%);bKc~Uz7_`Y3n(~sgMwZx~R_^4!fv4Vl*DXJ78Hi&Iv}rsT<(n{brSqK|=`#JH
z+zcrDh=37qGf~Wh0%X?-2k%;|Pw_bK=S(Z;-xo0xHGB`5YK^dwm`5p>-rUf*kHtSn
z&^vvsB=%q?P*P5>fh&g{*ExKOL7LvPJIq$r7Y-Hli;TnIX*i?;xPr@*iJnq0;5(>U
zWHi`Uc2P_KTTMMCd5FU$@ShwDPlp}ozY0UD1xC=(UR*dYO0)G5|4o-BAPUQiTAG04
zaG59*DrkT)+cg_-fo~a!qAt-+OLJ*^c2JS1R#CL^on~GPfOKJU`JPf~B7GKsvTO+;
ziDMw#xuRq2aZ%O4ak-gYLeyDC?p6kIO5q_9Pz(g}b7xHi%c(FK?IPh8X)#ANZ-6{s
zFF80ny+7evPAzsqHHk2-F@Tg%Ql-g6vuKCg?eoH{X+jUlH0|rX`NxxdWur+9!^i5d
zJJK23{uMRerFc*NvL)qhQTcqMvexCxwh3?l2hdn;mqCn0f%`v0<5}xwjk3%0{<{Bw
z#*}xJcjlW94_;pA9&4;x5opoAWU&}o`L6nT?xNO>%Zo81?`qa_TlAk<TuoShSNnPX
zKe-eBM2#tB(Hf9DK`F;rvAs6S0dgle@oH-P!=3OS)c6HKt^IoG->LB)lHdP{8aM0y
zlRM$ZH1Y!)Cw%DmPtf?sG&1s`D?G2m{n?+Uk-6I!Hb4A6ji9aWOvrrXFl{=0q^>~F
z_+u|CuhUP(>h9d%r;#gn7ZX07Weau%np-Vjul(5GYSZ<fr;*A3^EC2l_@Ah8cg*0G
z2X7KSjjjmx#9gv___p%X*mIkIqQ?JYcS1fVO~rbZ&+YH-gjJ!$&;P=mAZpw?-JGOO
zd!|m6;lDEjn^C776YynWB3U0e$ML{Fblo4W(?2M){7$@~XRe`F9^R+$5HTF@TL>8z
zHAzW_NlB1wJ48w{@XS3z%`^1MKSIqv;+1De%|ApuVd#}>;FYK6kt4s8py!^W>z*Tz
zCFr>2Xu0KRyJa8oEjmQb()GwS@W_TvoV6%9rpJo#)O=m{T-(r61J69`zyc#*7Nirj
zC|L&XOnuLME!Qk9O7;<NmW~@!-y>JWnyy31CP$RI$Fp@k^Yp#))txi-Jo1z@J#mid
zkfI<^bKIiJ54z+K{7N8E0Z9mbD(etA+t7yv!Q7+AOKpOS{8E~9-Lnq4W*tkc(xVn=
zyXOQY*94^09CFPyq~?aFpV_P9bHpp($gfD-4SItGR)Hn{Nj18Tw2YEY^MF!wzx=e4
zE{BL}QgESlV3C1mPGovL!7DE!y;0jePtQF!irJKu+iDe5Y8O@+pH**lEQeXv>l|5a
z8&(#T)!`Xk<{DLP=$R9j(-xQA>=aq$a=b9R>a4zdmaapJcRX9iF-6xdUd=wuJF$+M
z*ofU}Oo^$b7q-jqvT%>B@l2?<@Xk`v^7f6Z!0sey*d@80EZ4J7^h<6Cpf`KQRt3@O
z4!We{j%FAgD>_6<*7eLfOiIT47W*Z!50i64)7!nHOVu5j;pxp$S*`iC14sOd^*nPl
zoU;zOFb%v}i3Ob|KmL>v^rG&RqMo?C4hE|wIOWV?v(Qt89j9^|4Ba3F)RR%#V--?n
zA6}JK)@SIMr{$cPThX0a+GTg5RM#y}-z{^WMa&T|rbAe<z6-<BpXD0EHuEns_9^sE
ztR+X5yPd2ec;{;v`np81y<*Q;`Y_#Ms;qsp%)Qb>l530E=d5jxSOl=b=w}?mOZ`*W
zAxULHsjXzF)i$*TvRIHpOTyASLKzLwxjl^h#*~7V-72I58e}zHpM5w7D5a8UX#gp=
z(11pWq(k%^a$-QD4pMZGmV-pyA6gE=<q$WA6dmNj2oGxfe~5eUpr+b}+k5Yw9s-13
zh0r^M-XTEfE%Xin>CGTWkrqPlp-B}&5m8ZN#ex!=U=MZ?HQ4)&y`h}kPkEo`?e96?
zne)x$4>FS(CNn#G)?U|I>&KUK{0s*FyU|j1|JS<iFKGZ3e!A~pyUb6|1N#3~*EJCT
z%8c-9uWr(gx^Q&Q_1%9mBRr1%`$55f?iSM?U-&=n7XM#OonGFTebVmCUv-^*H~!bL
zXYV?%#I%*hZ~XZD*_WOHehUWvJ}5|KNRr2>D)8X35UWGt1P4$)S97{*Q|h<a8fAvt
zqgvGi*Dfg${9G34k{)?Y+Nc}(bkIVUA3e2P?ow&8`<;(qIzV?FP@TY|sCq+n<asdH
zivYmzURs=v5J!sI4xATZ7a$fW^9%?*Kmm7z<ep6EiqBy?wb9Pb&kLH+NKXZfaIEM3
z@{_cgepn!-3?`_1Xa<lPXO;D<;bvSA^zgDW0SOxp|C}&~?nB9Xlt3+*t7vgm&<f;f
zjtGue(FHvkn9pIjt_^OLQ0Sr(1~>6dWI^0l`Upx?Zj48V39rX76jf+cCnZ^VcFOMU
z#o^SLx(0t2nR#&s6xPawUWS$>Q(y+oH6#eOBRLx>T+4ZnF-}Uqj!-^(W9x#9crs}Q
zroe-$%&A_64N8Of_qs>Xooa$QHu=md(UlR_MMPFZo14Js*!x+eB3r~q-;Z^8K~8}L
zI1;ic#vIcmlNLv56CR;jr}+|aPStV_s1md$cCTHH39_!%P-SriMD@Gau7b21;M^wr
zNqWQS)bz3%S+6lXDCQxp>?Pn!GzNvL#FgD;C@ZU8e+tNH)jgkZpH`wophmsT4NG*?
z5PhS~$!L;e<S9tv4dOJfjvK->C^Y3J^d%alT35H7`3e&p$aFW23iNjnkKiqlaVa_1
z>sE4h_jj0_Jh4_bv4?!b!R$=YV5OA*i5ZOK#hlf7O*TQP9tGpDs})olIGlcsd`E-=
zBYp|O9jkGe)@rX|oO-nqU@9oFYvczg{-j39QT*_DEJNIT^2015v)u`?NiIjpO+)L%
z>N(v8n<Wl_vp|~dpdma|WBKMH8N=lwEmUJgBwzHycYUblx5#{@c;%bq*DAEwJXjbH
zMkJBS1n4|O{E2C)XhW3o9362K09n!;P?^W^u_MBe9(YW|i)m_K4-3E1IfH=ERA1p5
zI-f-eU@iEK$Qrunu$wN5OhOfr%7jNOoJqDM-<S~qp+JN5t`X2ExgpucYbX^u;7w~#
zk?(W`aYRy6{^T{dJ^==%LyR<>s^4A`R;7Xt)Od|3OPySFGWyWcY(hfoAF3Zge`vK2
zt5A`o175lWkVU3z+G9L?nnc?%L^a5*+rv*8=-3-cS0~Bf05ZPqM2>*co3?)&23QPK
zF=+d%uG@7;^)F$7f9SfugaQ7h>wJ>BpLy-Jx{U#H4*x4%7nh}Bx4LKJYVqGwr+?}?
z6SHep|3w<$T<B&c#Z8N@`$haKnMX&IP0{Wm4F8VNqe?1Kd)$0Im~BJtqsAS3Na^7L
zJ0bdR%QJg?%T5LKNd}EMnZEMvxNu`sU1AUAZAxIdcF-OleirrE-r($0LF2*4hN;et
zS97lU*S8-VPy6l?`d3}I^L6s5$*kDziT=?8xwhW;?~GfMKMo%(;a>><o4T(0(y_nj
zy2iWxH~;Q3U%ZsP!Tnb*^OH{q+N@LMD&J+s?Lq$4W&Y1}ol+L;|B<fyd+IdF>#^*A
zn>w}rexCAY>eTD0cEtA!q5nE{y5RN9=x?dh&fc;^2fmN}C3X4`8n*m@m^%H_WsWe*
z40g9~zMQ_}=<wZ7<HiO3mmej3eY!(FQS^AwnKv0uYInIli_vPQg?aQ|gMT(9iTpKe
z%HJXqe63~`P-+uWVI5L#6H;!?|09rY9aLuQmTeVSW*tPg3M{n=t*{CzGqg`M_b;&w
zpj!r%nwWUn1eaO!KM>5Y4ym*XVi>y6Y(lHd{7OuGi;axjO-(&a_=+mH+|aAgJb-TG
zTWlLz$^X#?q_!AQ=!QN;L_-e~Q!j_en&9+i6Teb^sLH~>)Gn;bDzwtfub2<kGBxqw
zCnn7NOM+4w!)a~C4$0PmrDpzRmVtD;;4&jhv8g}ZJdkb?SmqW}$rss{!4;0twK3az
z++u4jgXpf*I`g11zM?Xwl%$ppn)sDj`WG46Cz<(`DwDFU0*cJNauf4*m<N_7<hMIT
zRvLH~nFf@)Q>#iEhA7D`-ib}dl+rDw-8yc0I_?FT^qtO8l|-Ln|D>9bEgc@4>lrP3
z^gN1!(_1Y98G&id?s0VynN1$?O|~KQ+{%IQ%+|>4PTz$3ZIweVk!94aO#VYcLG6f7
zY;DbseR^KoH|Mk^Y~Q)Hg2lJhY(guIy^D<fiVb~B8O^(j8+XO!_qkCk<8pWKVd9%}
zcTjV?V)J@JGn!2NOKiictpe!Lw5IabF%w_9v9Wi358FPp+$xx1X69{X=0PhTCK`Gf
zn^36PT@hP*a;io$O1o@=N@!($4iV*r4ZAIa%4*ui93!f>RrGi!Hg2!k8JO1L9@pTR
z(&n|f(UZ!^uO7AzVW<+r%mT_Rf-3`3>-<t$LNgnE5^5{k_IV^U8wV6In#L^LvW?ub
z%Uk!AGe<o)Gvo7iL}Yi`hL*dA@h_P2l>8m07M^k2c4+E&B^LE27WC*Ec*Ny&8u*kL
z`xe!89nf$sa0zGlCpE?Ab%bu|q;6|XFWzb9y*;zEmsUQIR6LMd-kqG=%<MbBsOwKJ
z?95^eSO=8k*RTj`0an)D>e>|BkkXRcfucH=OGt5cNvED;hNqXkjt0fhHA`1J(9~_K
zQ*hzeEBwH*1JN>?pV_fCiThLIIz<t6!uU@Je6jnVi`O_O30SwG=ir;W#`XWf8g_{G
z=G?W-m;QMe=ao&h&p)E90WB~4|1MrTBoVYL)Enc}e_ff%m=pgC@NDAmNmeP9hf{pu
z*@J!Qe;LLp|Ge+Sp~nl%?7dy`C;zvBXaC-m?0r@LKQtxJ{uA&FK;}o;b3`<GWg7Dz
z+ZbrGP}y=J7tPfQ@!;guKPyv8o-r9OR;zVvfq9sv4fRp2=IGc^9p&hqI3ddhP32nR
zBiN(H;Ln6b1nkp`$IZ5~R8F&_ESCgxkhBCag5p{u&8}u)vj+U3*Bb`1XjVA@$#Z~C
zYHk6k3nH%V+OgS)#_38Bg23*C?X{zD+0c~T{(*1!%2ZUIa9IEaCycS=8wfKj6bUGU
z38fRf0VB7MWe}DeJ12t2$pVlcYYl?DXf)E!ydB!&5(jy4kUCzvg*=KTY_LfHi*VRc
z4@FpmWcMX6K?bEb9(I#DeGO)I{l;_!qCK29M;sXELYhfLLqJc_F}daVy&eyWX(!zQ
zE2A`dXkI{IkpqgMSLhycF%*J>bVGxZi{aR0Y=apOU0yCVvpC%-syHX>D0TKk+d17+
zG()7^gA0kQ%msN-7j!t`kv9f+hw7-A0}LW9b@@6_&KsWH2o|k~2qHx(v+fdPrXf;+
z$m9F0w8a^QcnXh;QmWErWX!oezi~ya&*TtUx&1~NL#}A$@I~3MJJU00wKql>tvX!@
zjYY;AF;pTO9ytmu62KXy>~+vZBKN3hlOnUouv)=YW5YJ<n(n5yDtrWmh$bYDfr5%5
z?5$3>GHS}oE&WY~7L6`9@K>?ZXomAh0bTBMWN?Lwm!d=DbdCJoBKEZ4=qJH%Z*=cF
z)SBRR*<}j#eN;j1U8;U$lf$~%kU*7q7RE5TivfvxdTl<3-9sj73VYL)szu0mM4e=7
zHANW4_ZNLu9v<Bi+^i{D@!L`2^&7wQ64i^4r&3AHM>m7LY!wfEFCyIJ0tE^xDwoIy
zqJU_6WfqBrJb$NLp~w*9b`%gQqLqKYw&2i80nu3LcENax5bh`)^8E%P3HTbV&}n4A
zTA2iyj?f2`g`Dyo3H>ZB3=V`jd?Ud(9&yVx?{Gw>iRA)Ti{v)SD%2`14#^Y75Njl`
zY%d+g4h0be0w8e*gvSjEA&A-)JwG0eLijQ?fet!S7ErPT*-wM>P2S^JTYUm(k@eCm
z-bkzqQY$z5F5;7DbR9`10HROcw<y)ZK@x@T5#9=PsdChe_qcln8@2U*dZJ+&<}SdY
z$}zpvoRh%@_z5EzJ7<@!82)0|j1la}h?;(Om}l4pSmz%vnA(3!vi_H*<UfnoKTXL$
z#p~Zq$s~srrT^BH{4>gW)P#q2CoBFV%6b#l+!#GJEC^}=<T`xojvK@83{yM<m%9pC
zCi=S0?p`rH{oOrtqb8=pKJJIFSD!H1&3(DYtpXdkhCenYXtmd=W^dq#i|dF*&>nY(
z)PPq14uWx|Ymo1&8~?wUlKy0+|4~HZKNGM2*G<WV@&&<vG9|CxR8ardm8t)$;`OhU
zDdPXUGBrFgJI^=!mA=CfSbm{J_uo@<J-tZ$DMKHMJs*c_W994Z?cnKU$1gJTmju0i
z9NoQa_^lmlE1v}FNMdX!pPRy;)pPMQ<IfTDrwsXc6+?ZBwWTjnk56PF`BF%H{tBPS
z;^t-H>S;mL2_btJdwDr{cw4)9TDf=|ySSVGiC1xq;FDLh)%}9}ynTF}+&yhn3EpH+
zBfcf(=5D2>=}Yl-b#gP}7m~bu?9&qlY^^AU29(WSw1%qAEun?#Dt>W+iMkrW{$5_8
zeu4Jxnvp@Fd6aeybuUA`PzMh^9}ibP@kLe5JtKZN+$SR3BPPf*C^R4-m{PSpr!z5d
zi?6o}pDX+M5;`F~DaI#Zi*H4=A2q<o+r&FR*Q-lj+Eq^{kQx%>?q<)2n&kL4Gs1=j
zsrP!KmSQ|oQbV>TP_}q_kXn2%RFrm_n?@yj=cV};)`lF~8c|XmGpZo(Rph_3AYey9
zR6}}bZgccRo&Tvye|CN4j_uz4&7o&%y*X_mmxFx*5<}9W1EV{l&b5Zj@uLLhrXIcJ
zN><J)nO-#p+Cd?X)eaVE-67Y!tqaSddrN#rvO_EObaq*2#b*Q*=Z4ld1<aHM?y3$S
z7Z<fRB}Np7cU>4Y=&P@ea7naxBz4Cv(jp6z6LSNIwc8>p!o!QK0*VtHd$tBuHN~-m
z19SIKUniwEJUp#RRFCj-@kohC=R;*1yf3F(?TQR;%AqwYDmiU0s2v<SqVJNm*`>qZ
zC9t_}CoMBC+N`rMx2-SiuCrrWW9$Cy+Xj|T$~Dz=rFxboxfW6582xeAsw)O^0_z!G
z`-7Z~O&sNJA5f_)n|IUQzRh#|?A$GSG4l}nbcV-Z>Sji9{*KW)h3Q_!wwh}+|MFDV
z3i(a8jg9>|4u}1`X{Gu7S~~6=mYJP_F+G3M+1Mz`*KVxI+0DwJBr7s1c*nNVzMP!i
z&W@21YTI!4<MaSRNuu_%XK#H;i33gT#j)}QX)gZ$4pqs7?U}K;X|Y$B^h+H%H;*{~
z=OU8dhZ1d+mPtxpvG|XWDx0w;@lSZJ-T#bKk$5%B<^H1&MND)27Y9_YOKG)o|GyED
z{B^~@JD{~0@BUm@H1LVw<JLCu*A-(sT!i^ZmA{BcK2jy!zgp=3D^jI+!eKz+qujro
zZ0DVLAKbg~)938u_m6*`Y;Sz@^!zHiI=tf{)9&ZbZ~T+(t5g5dyO;bcQibL9MehZ#
z9Pgs3RO;oG9GhzwsdBzbJ~R2Mw^VDpR06jm*{|wL&d{SeZANmOTlP1AE=-yvsQ{#L
zf(oFsb^^lNh{ETX_7A>6Os5Mkz!uvp7L;ahtchxqT|Ob9iNqZnZih_ojtEnsm#RQ8
z(o)^QfTy{u(dpT@_(sZTcS4Va&r7FfJ9dEvuoXJV=-{7}QyL3}a^iR7{jhx8qO-2a
zZHmWQK6T8f>!$3&9qZmR+U~O#zk7hOeb4UU*6sLFf$yYxi`k>EUJ;L}ZdlBY8?)o#
zcDmB7PDqqIN9W+#-^;H-%WtXa$i*M0(u7VcU)-m3<x7vlp;<ni{V2y{U;3fjSnF|i
zm2}+OV|VO0<Hu%Ot>3Y43|-7Pyjo}d_Q0HM?<{QbQQ^DE3(67WQ;+xRj8APq>-19(
zjRf8t+j!OU_SCtddiLA`GE#3&BxdFH^!-um_s2GE88<v9r&wgTDA8MVm?Iuy{eDsH
zi0<Kwy4jH#LRFE&I60fImyl+d?S>0n-S1Rqvw<g@oj|W_w#jwMJ!<)NU#E<1pa6~c
z35rZ=Ja#kEc+;1g!PdpIP<-3vW4EF<UpBiFH{58t9DC8*{BC$Qn=V+Gx1nc#uV{0W
z=?wuU;p<9?qQd7J^7Q@r%N6zekKM>N-=FuiqIu`{$2|*C^aqi0zmGkxn}|AoeTQ%3
z@mqV$&wjr-T6$&T`gp)wtJS0Cb|)Vcl$U&aa^(5_Pd5(E?);28vo<sP;gZy>%YH;O
zYu4`d_^dGA-;jKiY=_TY)KFy-X8>do;WzN2nMudI>0O&fBc+MIkw^lS1EAZvoL_RE
zn$Lp2PRFc2G6#O#Z7zB*Hvo!~AjzXZnH)*+hqAQ2ESk*^GseL16b?L>SOStc-{3?J
z+GVYr04MwsCBc-qK(Xu-Dni17B<Z+Xi9X8P5DIl%KS?cz(PIQQzCE7?n|vAQ^?`L9
zk*o-{)WUUH8!t5MfA}%09+$^p#rRVK*LYR_UR3c_l*7iagCLRUfN&v!U&?qT#BZea
zNUjTB-mgxhox0(Z4B!_<;BSUWzwd-Fe!6o3eS#|VA{oLGj2hE)2|wUO28Qhm)S5V8
z@NCethX8&w9#(*9mOpu0R$z0d{G-q(Mo#i$d^HzoNjQcN;th$fq|JYQM5`7)3c#~S
zFf^V3!1-3{9=Ako<yD3#odl@Dr{QLr43dche6B*>M2-T2CY)ZiE|R$*{)(U(6}n0W
z_|GaR$B{ws%8gO8kFGEq_#lKqCn0cz4TfT}16*kFp|K!=j(K5#gw$dYJT0FBEDxqu
zGX|c}qQi^mq5vI+mgZh9J<fs$vNh~x!_Jz==M2lu!3b{DODR6$JLlhw@jpNp;jLnH
z8=sRuYhA4^2>=B4zw~zJE@3DvRPPvw+0?_8F1p?&v8ad;zrdAlCm@@p=Y*~SfXxX4
z>wP-MS1R?=z?F|(TbVEdiCZ2&GzeE^!nDXtKyy(^!Zw)>JDLI@zjc5@dg_Qr>{_uE
zrEXh%8KL!ixu9cPU%mG{e>$+@^cMi$5%l`^6L-jZ#8F6v0B!c9fLAY+VSnProi<TC
zqWeTUu9QcYSqwILZSdKucL@vf($}iC1U{CGuBj2u`Cb>_R|eNLd55Y=p<~lmr7Hjz
z^V~I%7&!>tLBMq7-QW}^h=q4N7Zd?1v1~dzgyjHfv!XO}L?lB1Z2<*8q%NflersMo
zMvTKCO~%5XIU5M#x%dB&y?)AYj3an}1eYYRPKCJ91g;b!Zltz>WWcFP4nSx#ClDHh
zas}#|GldFa<zD<zx|y^pxx#~Y(r4jt)+5yw7Mwyyh&(8)lw(Q>)95qk)Hi{zmFZKE
z58dqhMaJ*qLsMaHjsh%doF<1P#NT8T5XC>pP|m;bpkhXnP*e{0l0FkiE!%W~Sw*-(
z-w>kV9Ry^VF_LT+J?4$F$YG54W-KTK<j<f^EHxUoI|w${WC~LOtlf!Ni7~Yoo*JZ=
znW;w*;(X{bS_$${RTcs6I2xUzz>QCkdJSo$;d&+xYqA}+56!@T!YA+e(hcPjDl{5I
zDuOf~!%sf=Y#VfX`PSLog1trkWeuF##BV$S%{7MEH3yB#c!n%T;(-2Ze3EPpPh@+S
zR*VP{Zh0dXt<El2L%*-t@>NNAn;XE=^Mk879f9<Kc`<k_QieVx!r?dxD!k9M;;@9a
zOT%TT?1rHAG9eYVlOlgFHTKI%Fhz5AMvjg$hDQo^hE}S*z$0tL;#RkABv;7%$k=N1
zDf@aOXJ+fiujNMV)3}6WNVAVn!(X}-4kKhOx;_AO+d(mLH$aoVgtp-q;7Gekh@%vw
z1%(CA(=1o}!2~LFCgGg`XEBPJW3kAB=K?3>$=vt!Er+{^V{jQJQ0^KzgbA_-1!wF&
z5P4-U^YaT09jGY2E)qK90|~Ughx_9h_^lSx!qlcp^KnSJGathF8zS*1SZj?0Cslp0
z{8UUFIv=3R#&HvxepB(O{P<TDzS^FuBpjRUsL)ER@u(OQPCemZC`YQGNZX5>uuUL!
zpsMyZh?J0a)V#z*8WV<|nH`A1q&A_I+ous{Hi|by#nY;I_GTw(OeYZTSM{z_34NYE
ztCGwMjZ14gHcD0#4*o8BSGoG`WlF|_HQWn!1a=i+!_2@h+1_14`OqWlztW3b99019
z7K%4O!lXTe&eJi0ETkG2o`^^4<D*N=7%c!Qkb*o-L?lvRuC54uCSZ?8ZCyj@15mgr
zyv-FeLP4tFVV&ww*IJPY1=&wWB+?){6?u>Xv;9^cKtT>rFckziK*wfLkg*g@;~F-V
z>5azcb&`-#0BQ@7k;O%cQDKR6gen(^;8hrLA!QOWhXA?0z|bj3cPhZ5A<yPice1L_
z({LJ0IEGT*MMR5j5UWqKeJVm>jvR(Ey0o8#7*#LY9E#}#gp-NrBqBVXh7n@|Obf7Z
ztX7{>D_>Pn+y(#f1<mA7DzI_301%7EaMrM~Bt-gGq$$aZ#fGU<YEN_FXIxP%%{uip
zWG!{eM>5#UsnR2YY&O=K2Ti*|u@qkp8=Jz8oc{#c^KZOvNC!^Bxj87G2hZmr6^UR7
ztI-<(vH)x;5iCsb`s#+=aDhruKne*WP#V|oBt1g|QB;gJ0sy|F!a2+eUX7Sr`nTud
zh3u9+bFdq{QtkJMN-9=0tW~|BRkOQQ+p<+N46V{F&<oP7jZj)^xK|`k)J9guF(zil
z8TXqYNFc$s?M8|5_nvP$TUNt+iRds2DvSVgV4)J$U~Wu?DLZ817Oa?#-b#T}))>7s
zjN2OA|1Lb4inJ!8v(7=*yW1PN?O{Zy=qaR3M2FJh>%p*G0OiE$Fa=<}Ydf~FVZC%r
zWEi}Kid^Bfi*Y-MT*wif*Gz$TkuWq8CPE99L+>odBayYpVhT)v3%Id@+}5_&;L+tY
z$o6?Rh7QkX!<={w(=||>h6>-c!wKjyrNKsInw{{N3OYKEgjPnU8zDo{B(R-`PGs#c
z0(vv?u9M%v^{PHGRv(eovFAIZi`{;Zgk@}WBQ$tjdh{(UpjzIH;l_o{VtTgl`ncx-
zT|BJid#E81-iPAP(F!E;FzP(OoI~Dr8+C<*%qL_DS0T?6(Lz}C&k8`Cgao)KnIKrm
z+CazzY%>*!?DWO~kToUMnUHmbjlo#KyNF0PLKP8@Dd*vm!eA<?NM{-<kuY3NfQ6=%
zLY(j+y5JOXgj^?h=#l72DmIdWj%1H`Ess!MwNjQx{9ldu{1~ZZ3V2%W(%0JMpNfqk
zNVkLZ)265lF7^YJjujEQNf%h<w*8_A<GXO8n!ch|mF^r`A`4;5M$Efz%Ot{ksYrVg
zqQ$amjDk!CfTRr)wwTfr1|YIX+mcAgauOUMB9DZXsME29+fk0}FoC(<``9=M3Z|I8
z{dq7Zfrt>~?J4qr)%Mg|6Dz}ky=nmVgGHGH5xv4iU8G}HD9Ahj$fUz%Zo}vV=pqvr
zKtecjVF?tJ0JA;-!0P^h?c?rtq@ngvFecP`TRbX)x`)Bs<HQ`hD!c#sG9)8~K2OEH
z+q0KQ@)A8Ywiy7dIncFmlr8~!^$H?-9Q^VFl*!xgOoxkK7;2{=C$!-N);>iNLXm|y
zPu;9Y+SWospn7q&L`3)AgGAbaEz~U4in>8IRzVsCkWg#@jiDYSQuk1asf-P>qv{&`
zJ`HCh2Y0*^>BGY?0id4`M51Bx*a!w4IYLERI8)9YJ(@-3-@wL9BjD!D`Yv_?C5>Iz
zgWC)sl8MLkLXm4$Nb}dj_S&!^BF=y9I86uPx-1$lyDM;cm;c^f`GpgaOaZUG6JFZ*
zke-Q%QzN4+c+YhD3ji+5MQ+f9qv;S%2|Ga(7-D5S+zbnGX?L;oMc(7zDXGjgQ~@3y
zx`wL2HyQ%y0v_tCYRZ)kQ~?L)u!cNGg^GCaaQdlQ3jcnIIZ}vJrz4`+4l2Y`1zfl)
za7>ViNaLZ>c<@XnTAc!)IgQxPJB6W7dar>+OjN?g8a;<}%9{!lt-<$fONnB`YI(?W
zOgQHv&cYOOW+NHW9S43QugaZiUPJBRpr&1?mR=)&o`w;bh>@RgU;LEM8t4FE(kQ19
zkx&j79YqAWp=TJ$2USUvz5phbHO2Le@;ixiC!Ue@YEr!cY@<%6u7TD(J^%_PM?8C8
z2Y7zbUy+U|;)O~Okzam-5-SJ-Z<@)3TfaeV3-?mx!haSbHxmT75xXx-bd+)t&%TDL
za_v&*!qi!aC;;Y6m|yBeHc~O3>(s=Cb3)^&kT;Mw6{9jfBNha2<e-e$=Y%bQTpVX+
z_wh6x>?8cdmb4Lz!4XFNMCAqt3$RA~wNFG6@S_0GAb(;80LtagkJA^sY|i(*hd!?1
z`Z$=YEa8^d_-K4&*H4T91x#5xT6WA$4e&N3fkp(M=Q+9KAz;U?fXVbgh-LrkN#Ki5
zAVh-N%|JQAMHMz^NCb^&(2g&m`ZP$4a5?TNpvFm<N(ZjuAOZ<&p`y03Q2X7$_R)AF
z+Q9Nr@W)4|LC+NbYT%geW!K!xT{#eemOEbqS0l0v0Z4-h+$_3msN?;p9r$qR^6f|v
zQ4Bp)<<35V^qKb8PRtM}pb_2e7H$bm0mTWI#WR+oklv!Utmon|hZ-&h4|}~HDo9yU
zAwuRGYasr<s|E>7a0!R);`%+MVEB5S;H^P}F6#Oc_FpZv$wYH+2nE>_YJiD!?sF6H
zV%lzfQp&~N8vznGZcm1NP~}=h-8?RNjlj8Lr+qWSb8(CHgifr$DDC`PDwbG#-uKi9
zK;0A(e)}W`d&}^AgAM*I0C>G>-KKXQ=7+BNdHyL)=s88`W|in{$4TL*o26?z&|HW=
zIN*I5=)IrRv*}{#=i$Pe&HelPb_;q7aff#oxAeXZF=sE^ryd;C1N!en-Zscg>Si=|
z*}kp?&0d}}S+-w>`n??&el727L^!bThQ183{}D23d*9{d%F^4A!j9#`n<!rMcj+6u
zR(>U~jM&~Q>sVg;6?*pm@chVwbG9o3XYLm7TGnHQpAoz-L|u7xKk1p^;=Z7jFK<Jn
z3hsYNeNZaFTNdPT$t&yoFEcLPs#+Jlz!V7AK3}GT53{=CZH4dE#pV2(c+250vEX~t
zZ$o8#irH#Es801adGHZqjwi#IfSW4d7Wmk#<grDQol*Z|^M1hY%41T=<9E7{ztm%g
z%qP}oA6xu>>~i2SYz-`cKk+De;`#1zK<3kck|$wjpV%}#^^SfTlKC|7z+*3;rx8NW
zJl;KZQ+*~n@+@BAS%Sjj^xw~roa31nZ)IK<ogv;)%G^|~hd)VQrT<z5xI*qdyCgTF
z@94YZ$BB2^S0>J90abL+iVp55dD)fua!0I8PyfsQ-!FFxy&Cd)IV|+5Bl=bQ0eFAO
ztL`hW#(ZA2zk7Ai?)BJ}mwgJad(Xby@AG={_sfZrmmT`Adoo{7pM5o}|9Vd0)$uE@
z=lWk?`Td5g@b;SB+basMAL9`YS*rl$cH`N%<$`VHmlqrQMp_!q2mctMA2=@^{ca&v
z+rUv_`$dFw|LuPH7hOg861m%rZx*9o2~`R`Qb}3m{eBm?iiZCo9=!ZElC${G4*%iZ
z8a)%+bOjr1bv}}Jezkv9-iN@WhzM?7YXeUNz1kI+IuT%X{w?ixcls`==68~3?+{8w
zZfy|o##5r#xcE~{QPWbqwShSDAl_D3)ZwbklLLz`rJtgDR^3WJg?QYN68>m7C8}s3
zQcA*~rAiJ{@tb1sVa<FD#Ao!<=YGFCdHWW-`#!l(?Fver2<`czg8A&X1@ClFqJbc0
z9wU*bC{}P#ivRqqdh!#!d14g*&2{5z&Ze)-L!XQMK97LXqWY^EzrQi3-nJ@!Zx(*h
zdi8e4)LVcJUpR!uD+!bgeyb6dcmRm)j`?9NB1kb5=r_dd{X-_8S$4!gG*0p731QhI
ziXw#WpJz9Iat7p2Pf5%wuAeJiUmRG!FtvW^;rbPOk<Rt?H%mY787f~Z{dH&HSA+=8
zabs{4>ma<W_&ctwZJWdI`v$*X4E%mI_501k-|tF)xvu^G5F_>8e&dU<lq_xI$3w~Q
zQyagVC4oVZLt-EV706u_CBQ&nlU;?h-y?FJgkJPqm)~QTrcHdn5#C=_%uvC*pWN;L
z)ME!8aXd#8_spxuG~>Zs_jO*KCc(K%HHG|~GUVKtTT~GE(tp%@r=8m3b^eY3Wq<U1
zo%qw!<56cy5QT@I`?Az#`<)9-wdPYc-P=_u7jodrp?LQz^SzzV!p{`{`h7XPb8i@@
zQqc2BVcX5vbB!Od3hsB_$Dga!iaFO;p!DQ$kL~kgxQ`b*ukP}G{$!l@F6CB?(?r!K
z>-3FRHxFkR7oQ0fq01l&oy50CSWuT+s}&cze~we4VBIR!3Q<2^n#pu%;J&cEo!+62
zz{cz-H)kJSzdYbN@PN0i;ex-ugLLGtq9314kGR&P50^B4!2CXBKmt*70#oHPAgQY=
z{csftrC5R2hY9>Rpx3w@PIMGBe}dnS!8|e;#)o~_<s{}yem^7}_DI`VDyE`kmqhil
zo{QX;x%UJ?8#K#Ru@r9Prc|x^!BxN!e+^P7{6sykJWyfep|yMDu!qjUIU`TKi6@6W
zb@g}{KwVt3rdIy>DgOETm#x=4&C3F>Em$<;V$b7W;doc9VXSO-tA}tCiUUgRD8*^x
z82rcy<5mBF%e9m5&kb#Y9phc_s6I-qlF7f6Q-u!>jl+nGzvrO+^oXW`;`)@EFo950
z#}=ogUB`kWw#=I@?NN>p-!CJZA+GFgRiidptG-_pA+8IE`3Mw|l;8qQtS@LnM}lOH
zf*&Ub;UXWVR3UTr^DWsl6NlI;=aCersI;6VXEE0iOY{2$QVy#Ekzb!q#FTDS2527+
zG(K?qKndcOUo~qFW9J`D8O9#s%ar&^iDlvkgks=Qe3R59P|&2PA;gJmfLT29C)jqa
z3dc0yZzrgXfUc6B>4#h-!+wXZiqqBsYHL8^p}Ue%x4IH`)PRYnQg#m<_rG1Xk!E~H
zr{Xp|S1E!~rruTE9AtSRDX9AyBDSIcJfGBp8I=w4&~lbBYybWfow=a@Gu;4BR)4GL
zM2r&&E3!~to7SVv_d3hI2fC6!02~RG^rg)^)aap(Qelq3GjW%OP}$TaSB;%1d){iF
zc(pIsTZ~>IaagS`zw1twWQ685!W&H|;_3ZnJDy&zPD3xlWFj9-Kb1RO_#{gDVa%eB
z#8h$o_hvt;%k&Q!6Cy(daLI}nOo<P3`ru5@N{BRO<iY_OU@?!r@40)b<R`|qn0RyQ
zR1b?PQ8!}-u+hnZs(C?=qP8u!V7xyqLYh>v>71BQ0<~Q5SZH*AG=C=p3B?NOpyhb*
z=P(hWcW6&4oLCfV0(^TUUJ^PZb%}OHBA+8sN}J;&&}*giLHDn)I6mxr*ZTX^Qk1~0
z4e^<p49!8<vo6>>N7oSp-85Mvtx93-`O^Zyk0l>c5&CoAgwj5{iPW7?20RR_sodc$
z_HX<yx*Xc`=CTOl?Z-;>L|Pr|GFS4k%AktLQk4<esroT-_9D-M>|%DUWvi(4tEQT{
ziv2H@-q5QoCpDb4-|IJYqlYECzZ#~eFQ5o8nF*6`=ZV_~#Z&vD(MCy*D#<?e##|?r
zPt0m}uehWmp=HQ*yrA#*RpC-#)L;V;3VHFm<!XgGzWz?Pd)&s;)Ua|izKF0#%kCw@
zl|MP_m|r0UC*<AK9+r`K@11<vK_;PG<zk|PSJvh100p)*p3VcsPsE8zeS_@$IKvWN
zj$4D^GpfO?3(00T1}VMj(|c1cd(6PY(3b*UjC@vgt{{nA!qV0EO0&zpynu#3EG2(R
zDASJCX4&q2B*lDEwsh%_LG$^S`;|S8)jB%Y>YW^$dM7zzVae_VyW-}WdICnxBq-M2
zQNEsHH<GRP^m=r(28BEeJg`+_uYcp^2DT^!Q~(Ho-wWgao1;Ri;gU)^p--(sdMng{
zocXlqEvmQnnN+L4y`Dxzr0txRyv0_3^xFFYsv}7L)}f7NHMh9>!!^|=l7~Cz(>+x8
ziQ5IM%620%k`)h!E$z5<6k&9sCh_o{2KElZfNe&)pi6iU)8+WYyxzO5rz0K=9iNy&
z97tnWM?SKvJU;K7xix4c@|jtl`ogx%oLvHR6$_-@^?CgU);<v%@j1u4h%M3k(mK2<
zZclFAba3;jtmrRxnrGxKT??P4Eq|3wIP-D-50TfN?MI&7o(f8PU5fCEQ~`21C>I(-
zVv>q9zcVddMf4exj>X<vu$4GRt1_L870SCatBB01akhyQ?YuLm;gVHn9jPKQacAD3
zDyt#EX0z<=JLk;LWi@S^+^q2R&Vtb4x6PF{{NdZXi>@vkTU$FO<JHaYp7*WV+P=#s
zK|AE`g^+VwcO08c(9gSjF$S64HE)y1pB}rE<dWTUb28Cv;_l@wRoQ({ZIY~R-@TG|
zF1!EpWRl(2yH`t*Is7N>WJjrGZnaC!ki?l}7xU$%=Bk_#HQN-AkmYNg=W<3(&!qU|
zEngo%ZX0v9P4(|wzOmb7+uoovslgM=HxE{A8&9xJ3%|X5YvSCt1KZA|@s}lTPa$*J
zmA2_|QuppGxa1!0IFp`ee(&zps@$WyY%@~7deCp4%RPSVOh#tjy?YOlc_-#=Gq-l$
zTX}wN?bwpulY?q=p+fJ49WNZo9G{ytdB$}EUp6Wf#yH<sk6k#sfhc)R5MJS-T=Qon
z&eE#PC-3R-YSiWRL*U-)hwj0FIpLwKN@@{7VdC3w3m;}3j3p^9yQm|$^+QI}^ZQEn
zkIXfpt&AGzS@t~1VGL|bTv;It^bpOE*OVD1PbB^3zEwyugc+Y!o)fhVoZ|aGl#@3B
zQi+RB3<|Tr=GS4BuiNW5J|D+$@HYs{!aFz5<{qEeH1CmD7@J}E^~CM_@A4K3AACNW
zclPW3KT1(WJcNDzjMRg*YS*Gi5>xr-%pbgOt}c3_W?yh2<iUr|g`#JsQw3M@9()`?
z6~Az{-+rz0!KZ<T-(LnzZND|~;Pb)i;x`HQh0C`ee3@7%ez&Q0WBdKD557*JO4cgv
ziylcm{I=j)@}Xm@=$ZM$?^kaZP7T@@zY2Ny<Mu+ymt#}Ev^)oXK17v%tIoE5pIx&a
zlJfO)j8KPLPz2_W>eBV6_N6~=Km7f5q4f7--<FTY2@ix)?AzU@>ZLh@V+?#f9Zf(Z
z8XDm_98?7d-Oj;`aIi-?0u>yg8ff-~{pmKkFnk&>J}sg;Eow3?MxGXjJ3uvv@D~R!
zg-&&7auQYOvPY-o=BDLuOmBKJt?+4DadKL+$YHo^IzO#}E?`CooKcIPQNQ7!)X)Ts
zpjF|V`0N>-xfxxYqg0Wd-lrJ@I6td)R)|w(^oDM1Gix*l9y0NoHH~-Tzl=;~&HJ28
z#%IlPoUA9EEE}9G(j6+x>5u7j2h}-8lQ}2y964~#IeyMXm#lt=ROwkJ4$$34$eu^%
zJo?DqBjgh=$TgHQN+9SZ?(DDY>?uC)N1mscI0r{MhxE+_G&qNOl?A3d`;FM?aOb0*
z%twEkkAa_~il2*Bb&1xU+DtwdpEDjznLOZ0Ow!fg2IwRo6-f+qalLmcvh7^>MVH$u
zRR_`klw$d3Mkt>JO4JQB&<Qfs3pDY_(b4eN*XF+sR#*1dRHbOC2kB}C8WTe{?g1)_
zKHBR3=EmV&oh)6gz{s$i^(D~MJC9@=)84kzNI%fbDA+(JL`}(COU+kVF+@orOjRlL
zCl}hd1LIfe4Riv3T!n0{Vp?1JGQ!oIND11Sp?X>&-><-|&8b<LH6el9HpvAxH}x92
zZFP4|Xlm#Z7mrDcA8cvqRwjgR+=m<Lh0wMX^z{zwk!i2z#Z3$%Oue?*5c!zOXnu_5
zWRL9c>u`P?r-G*8M2cys@7lNthWbXE8u~{^6vV}psH=noxfocPhiRxq)l{`p{VW(|
zb#=8JLH_CCA=$ciNsp$K#uHvA#nXFx20mW^z1&kjT@olMuF|tlJ~t#>SF<BIcG$-&
zb>jx$?@POVT$vy7v9|JcB`4+Q)?V1BbN>YX#tDc1oue)urf<%P-9Kybe3lUHt!1Da
zxv`3f3Z&-e*B|LI($%8ujd^EIbXHMv>S!O}hlJiNh|i8_yV}|Jln{tIo|cAD#f5d@
zA$i$ZbtBc{gEhqB48LB6k%y(;P_4x#8MkfOjA(CujNI{Pk4=KV-e5ymMY>5WHGN}6
zG9lcG+1wEvnA}rAQdf!oxr7Q2O|`KM=_(LyFLhK^NpZDvCtKR5#U*A$djz<U(jqjo
zsRq8Wm4#_G`j#=JTm3w|Z1(Ow_<2cxX)jQbWuFpa7?s&LPJQ24phvGC3Qn#`PuTT#
z7HTde)fdK6yfZp0eL5pA+6NRKOZu6T*Xr+8e)WJ9$z5k(H#M8yb8M&6_R1b|P=2%D
zVpW>-K+Ij&$nt#Op2sIaHxH|+F`pm5e)EGzcD^|kO(Vg6l*)+FGb1+fkvsWesj7e@
z{Ls?IJ+Z8?Qum0Gd#98$earnly`4f!3&UIM+xHZ1>rM&U+7xqaV-*N@kKxCg62g)b
z?0Z#o1EPW=<V_PiTpcS)yJi+{ds-Lx8C30TsBI`epOe{ko2|nSyPWOP`7cu}(ul2#
z|It3fF3%3b=nH)XM(Y1(^oX$5k}G?U)g=ET#S+z&^2h&>5nAwOz<%eSqrRv9lOCV_
z{jaSP?;di3)X{(2XSkmGi2PsBBOa(8{P2%`hJn2LKN+DrCoce+vjZFJKO?^%zpeyG
zh6cltb)y{850e*EhDPxk91zGf;X(osP*x?N%TjU>7-s`;9e@P^lA?h_H46R~+$y<f
z3nrv?_5{B-#?YiRXpUM?YUSg*VjXcKC!l7-%sXWy9aY}2iy<;Bu1UlHgfiSgRy@8*
z(}*?<xu?#>HflrW@{a2_78ZJn`b<Xr(&QzQJhH3AlXhbF5AJp?G^$AIFV+`N?g!Sp
zTLzIYYc+u{Ca=b9zc@oq9++>y>aO~?L_Z{a&sw4zhN<GOyE(<UWzVh$YN%1MUryX^
zA=3>dk#XdHC;T44)mO{|6A&kj{HDuz=^!Lh@5dHAl+8Q@*Gj`5IrO4#-x1jU3nGVR
zG{rL<&KVW@D@YYwOm)e$fk>(_?+X;K?U#Ot?3GLr6PN_Lu!2sX6png3ete?CH2Wwo
zPCKM^`835+S}C1-R@m_M7BUxmquP02cpBaY>uxNfFMQuRlk5pG0Yx#E03D^W<iRzU
z@*bxghxwf*I?tVYgP)C1%{jOLJOPcZu^OIxFCpIJIOaqc)fo8d?}VR44<6xO!#SK;
z+iMv!C$xZ`Zb&<>Tiw2Y!9^hF4-T@d7eAZi#Q#|oO@6=vVL7T_@8>_<IsZVAzEKsr
zD2&g+0k71>F)}q>>y)tu=_f)?VNOoocYzz_%%_OPD5eEusfRZL;xAL~y1NPiCha)Y
zQ{=vgH?K+k5gEDUJ{a}TbM%@0%>4kp3IFtL&ku{ImbcGRuECTxn6EKew#E~XtsUMb
z%z6v{CJ_3N`Nd0uI{lSbZSecsllm9{|6)L~1bhHna*9(LwxQT7o2%B6#T4e&U)#(^
z3Yng2tGR(2nk<L!4~M<KODd`sJ!Y$u4V8s~!mTFAvrVdE6$Ajeh(8FDq`Oqmf5<Bz
z!Kuer;L55o!(W)`gUp;05pKAoIPlBewJLKsB$PEayXgxFX>BtgxUnr6ELh)9@MAeS
z9e59gd65&Au6H}qLymIw*h-r6HB${=Eg2L)f@Q>l)b8Z@@*>0fAmc@8Ox$!C>wOF=
zWwSg;YA74`Q!W@&aU}0{#hR(okuM)}ur+42lP$`|@-<f1+C>c)StwiTL*ZiS^9qtA
zq!H<%iotg$?{|;nyXKyJSLk+k+wN<a3DCs>E>uPy@)kNzCRbgzV7&2Fn%U|?zLdp@
z^d@hHgYg~}FGb?8b8(#YniKl1i<+|JPMo2-^9Tw^HJVG|7O@^{U-JTV{nc!fD=k1m
zc?A7K(aY2GdH~0c5K53;;>4TOffd;+LlPwBwEnfFjXH%-#DS&IB;njc0y3fe-KXA%
zCp|>>b}}!d@B;(pN{)>(>RX3K!k;<BX}Z?F@g0Uu-^4l8F*89z)gd=k_XH!qUwY)>
zi6S@isqWUqkzwii<a4Czmh-MZj!4{nv0LZ}tv(KKDt8)iG|U{Vk0LusU0@}t-@lEG
z5_gi4ltvlXDV5K|V+j~FjJW+dnVz8$nM;c^!u55Hp2r<!CN$~N?MuEgCXe?{ut{d@
z)vM4Ay@Ru%+Gan(=*gO!r9LHVtM;an=WUcq)!j+5i&nBn`r&df0g@q>h>QA^E${F-
zUHHW--;tSZQWsv7Ay)DP64_T-&(l)<wm96**;pCcH+IYiY0)A2fT0Q#Tzl)9s}or!
z{&iv@0W0=94qbMKs=hPB#TZLm&Z=3Jyqlb1|FQ>h<C@b>=g&zN-DT%LJw3ATRLzLh
z>W|rABFtQ1Of+HF^@dMh+GS3olgz5JnqnKiNWyN;6Vv4c69bJlJq9?$)MTf=8Hr*^
z?tD%m{rb5pQfl8$(1O|1LEgu6<!zJo0Mg1bLwobSUpEl+>Oq{Xyjfc(Zrq_hODNGK
zsQ<1-b*1U0$DA6ldg#*gf~!B5y)OWAmni27E*8$7bveA~g~)2&tt*Y3_&C77B!!kH
z61>dHFTT7OYh4{mH`ur1Lh`$M>2divvp?_~HJQ1_eFDtHd+~QH$+`o4dPLI4FxI|p
zc8fb<`*$denF_?Y9hLra+}zpt)KYE9UqBM>_S?5qsUIEv<B_@c^T+xFU);u=jZ#P2
ztyFgVxa~FnlOC~ba+?4G(Aul;fJ6W-4S;a!>u4uF1Ca{g`sqN7T%jS1$`LMUsXL_5
zJKnU21F8516Vfzr^-B}2Ev+}@k5#lOFZcNEBaxk|L;96sXwYN2QKg7}`|;>uWzFHT
zRDdV0&D=Km{32@p*oaJ&yEy>IS8P53q1GOJT_7W5<k54ha3zx9*-e?D+BWw@PoSj~
z_>J8LvJ@Pwa6_+^MSjwam)dX@?j#ZL`j!#K95c8Me*_X7DKgYOLF`0BZzS9npP37v
zili3<AdY^^akmh+9`<Hb<8Nzmb{)^O6JAP8Tiu-S5#OKv>oqlH*2zX6zlr|qjcbY!
zd9vw?LOts(ZKLt7%*>avOSbPareMCWn!cV5c>1nHxX91{lh(A{Z~j``<fEwByh;-V
zpgCspi7=FZ+ShJv`v3;DeujIo@T`jFLAO<m|M#oC3c#+A#Yw@|?bYkNPXkjwUr4py
zEi(bWoJd+^B=Wxn(^h%^)iZ~ZHd-_+RmW$1OPuc5fgL6>-?M~E$Th;hUPU}qxq56m
z``|{4Aa3rb0BFDQbxZ$R6ZJIVk>W<tmV=^5n~imt2pzEC7Dd12{YGR>k*-_?syL-w
zfJ9)E3Ggg55Q=ZvU2;E5LDLXKGcwTrc)2n{uN3CRha%`b9l)1aG3n@~6o3o9C*W5C
z)UjO(Ki3dibWzDTrPyNxoo^68&|xa$Ki_7+R<nHQMF<BS45j3yIX?D!DO^NYoyNEx
zn<Wy912}XI!@REqJb5uqP6Hpn&a%Oy#;W-s9V8!4dv13H`h5zw-5UZu@03@(p03b!
z!ynYBlp^A5>3nZaxQ+#rJ|S|8fVU@AU<QH18pU{#iqw4hK~#~ZArM)k43Dh_Hn{rw
z1c7igT4t>XMa27A;H}5-86Q&O#!SM8U^2HnpxCO4(3<(I8n;8B+#t#ikI@pv)Vtx;
zufuIL@mq!fh*lEogx|DQg&eFKb5r=xA!<b``aFSOaKp>vD^$?HgRc!gQKdx`6|=k&
z{wyAhn$>C1a16v|Pp65oK!{fjz0WtB$dR1Lxrc6i{-QBycj=l%^C$GCuK}_T^6H?h
zx*yUdpT9K&GEB&l2@hi;3z+C`CiWx~cb6&jor#xe5w&a)4{Lb?Hc0M~9Ry?!x3zp}
zDNra-+=*{h{Vpy}X`Onns2P?dCnNRfcq>t+EzhvkD6Gxwe5%hzUR%Hf_yLt}Ww{MU
zhbho<+`hK??gq~T0;VDDE?PM#ssMwE6<}@g*2=-HVNytF3sOf=K{h`OkVz4!=Cnr@
zWI;UeEC6(oiW3UbQEZ4t#RyYMGEQzm5)e;F7=KR3HkmD6Y}^75_5D_-lsUW&5BGHM
z!kU8w7G$}n>v1jsqXEsB?yD}{9Vy*CC%gOZcK4qbG5OwIJi!<W>lrQR8SC!Zd$MQz
zZqI@5J?w5mhRA=z2<0CrT{ziy>F&QULU-N>`_CDn&kFiq{1YRzH#c+5a^O?gz?Xu7
zZ~p^EC|-7u4+s?xAC%laDE;3uLa~K!z7CB}R~dy5n{6Mq=oz*;HEg5Zhi1W4*S6a3
zl>`X@hK3rWVVtZa?6gL3V7kjGI1Mi(#2)ce0_2FGJ)vB}Zv?}JAK@2LnAwows55n!
z-D=J(2x8X&Bpu)n637FfIvw3N0}8X1IJb)OQ~65<fILYDWTxAbP|A2nh=))E0FMm{
zytZ!CW+_Juz!~L(20X}-1!(c0NLnd}03<Wfb!-NjA1UT<6mTIN9qG-38$#)D9@xl)
z=~BSqH8g`OaGf6#1rStV$ma<@C{&zN1z_o*I~#VGfC(ZYar`t19+`m$qeuWiL0EHO
zvP2M10}r!dv3S@fJgSe>1_8SW6pRoHzJ-Sgq@c(g^cE7fmj_G2?y>M2$C6;ic#J3q
zE=UJeIY@CXG8hk<GeHdkwgnF}=HHx|5PznDfBq^+<Ch$RIc5M=3*yIX^65|t9o0jD
zE7PHD*02U%e0~{pUqj$%kRKI_=OF1Dc&s%Mf$jxOXdsq~FkS<MnGiqorbmJa;$c~1
znUo%&oCm1kArCqfP82*!fTG#hY}&!ytRZ)%_>Vd;kqg=ok7!VlHfsog2D{M%iqb#~
zfOg}-BdL%m7t|wwf&|cwqr(0HHj(xz5ujWaVl#kgPCfXo=O8B$2qnOABv5b-CQb!H
zSSWECLXZSPbc8G$=oi5C)FX=6C*dSe!~zeJAYT^NnF1=&kYpZAhyY1YAoAM2`imzH
zGU|^?T43pAI7&JM>Rb)UXJesCu8<lB5~3ZHpn#|4BtaU0=7RM+AjkuM&H4=0a7=E4
zpAaS@&+yJ9#sWn&K!F3sB%DorFGF~7w*S4%hcwy2u&HmoQ$J2mt>2saeNpP`&nbux
zEQsVFi#X^$4tA1*Tj2<;bMW%hqBhgwk$hKeTDosqc5+&NWm;i<njk-;Y%`-8Iip@Q
zquDp3JvpPhGNZpfLzJI2vY9oBoHZ+&wdk9*nw+&+nYCM=CCSe@+RTw7=Uj^B+|tkb
z^vrpsi(B8GqsY(u+sxk>ga;PQ%R7ud!N|U^pBHct-s$Hljy>nPH1Df)4ktSmUxZI=
zkT7_OH^ho8B@U*g<1-qh5Ad)Gv8a2PQhC1xMAkyobcKnwsCxB4NuLP)p%*?;m!R#p
z*kB`(Z8K22f@h558E+Q7-NdwCiZE(Kw&Q?guk#k~=K$Jy?XnB_*bDL?=11819dG6-
zZz>MU&qPx$e*2zlJ$SKVaQ<X9CMEY^*7U{1)r<9D)80eaK-Wtiv6tQ)Li>ma!3-^$
z4Ur+!mk4E-jaSiaMWU9w5%s%I`#ryabU=trUwRrLdc{k6&<j7#6?xq!_TEPP?D%DA
zC3J!VJQloCWq8$p(0YZp>CqbrZo{RuHzGIsWWO}X3hb1|>=*l^NW79Q@$Hg`prFKF
zlC*>%a7|bGpXU$$O><3InQY`r<J)q^?pyy_VdIzA^ekieMw+pEHowkh=(0uMGFn5~
z*VrvfpPb2e1o;Iwe!ETAG2O^@3*RNu)bQaOU`DQ4d<To)chl7fB06u;ame78)VzI2
z{AC0^r%WyTG=6i9Uu`pXqwzasDuiGUZ`;q8kcI}n{H7bf2lp?vI6b>Whk$&dZm^DK
zfP#W6zxc+l#o737BZm}i+(T%o`RQtgY+Q%<<v4yrZG8zcbWZ>NzgT<kpe7f!U;9Z9
z{RuVngx-Wuq=QK)h90VPLy-;wqJW?zp#`J_q!$e=R0PC;NVA0^A~sZ(B3J;iH*~oa
zMdf?e+WS54e!tmg&zw2u-~5r8%w(SAzV7>X{cZvqvoH(y44S(YL>8e8ot~y2-P4(o
zT%v6kf2gR=$=wu6#>MTePCHO%L`_t)ipk1vatS_QY#0m$=&~~!e4~p4e7vAMU9fLJ
zjDIqOKX>{vOpJW@dQ~?C-*$1aGjmA`PAH8Dj^E{(?(OE5v7=Z+({*?3i4w01DS`Xj
z7z>=x9)EY=c=z0+;S1RwEs1_v47Ws95U)P`YE94-l$et<-s$V*uBYpj7};jytbQ!=
zsjYW*Nnk(pozqeGA#IC=LUx+A@u5Nc4*IkOdxk<`J#&+guJHHeo;M;=xpjWGx&9O7
z0p}IvovOmlGrVK+N_gp^2b#lgo13{p@w!T{D-il}4?ma{TAGwyvzuN(XXI!5)VCIB
z#YG=zioELK>iB3>p}w9Mu_KJ_)dw|w9So~8F>%$iiz}_}^7BbA^zSK&=u}qpu(gQd
zRyO%C@_J*|(s!5nlM8n_HMoc8^V<8Mv|43U|I{%<DADHblFSXdl^@R2CIwuWyg$;c
zpX^#(6LHCByYG>xJN&xCQaJlPE<Nr}PEM4#ibE}AJI3u(1ZS&^NFNg`-I)Bm%8&qV
zYD!i?UQ>3!;np(Fo6EQWlX56?r?2Nyny!@|rj=}SGTOE|%qjl<uth)rd_}>vZN_Gs
z^GGOa2jN>yqa89bq5e+B+pV{DRM7L1DVmxLH-m$mf};-~t~?#rW@m($Zw=Y_^=oq(
z38mh$k|NT4>!U-DLQoUJe*cmAi3k1L#@O_>|L9~z93}qK-4zwd`QN#_6b;?34gSUa
z5-*my4W)SP-}lG!mhP|7mo7s3gSxAkf9nsvMqdv6OMd_**WCZF^#^+vo*!{L3h58_
zj^&+BRJG$oRli&M-#J<TMSpPR!B1_%-p8VGg!BcCP68w_!uv=7wm=*C5lnypT%zM5
zD4-T>xj-2JSIEkr*IFrZ;aT)TM7AZTB)>&xwnR@@g9zC1b-1MxO45<#mMc0@lG{=^
zQI+rm__i`5wZ`ZwDxCL}B88TJT84ABim1F}X{n@|+tX1P*}z!Qbov8e-e^i%(Z1Fk
ztM}Di3hi(DdoDw|qsYO0eyIwFv4Syq`*n#`vPEBN;%KgfQe2w|C84^bTD%MHP`l61
z<G=@iP^u&OE}e5!l9eE&EONO$!ANxP$J^~<ZJQC2JYkec)hXl{40mcYd@j*77Hj70
zFd#dL0{XzoF7j1zX*Z)}TJ%*t1SN#thqZH~pTQ{q_I60|fqX2b+ONi48UBt44x)Z%
zy*q}iiY%sHkwt!JKrOpnrLK$n83CJcK`%K9o`44GS48wFo!9}A0f2wKWvo{VX-qk0
zFnQT{SiGi>0@Lp3y>#XL$K4Z{w$Rz>m;y2hh%rdw&Y<7n`pH*J?sOX?gb+f&ZSl`n
z9Je6^f6QLRW|UAmt{cxz0@M5ZD6Iggg4}`6INKvvVsq3;`V@*hBK6S$JS%!iQb^?w
zA4L}(#DyCflt|HnLGlBo0uFiGt<4Zn(?KM|9lHLrOVR+YFTT}`@_WZsf@`YH%4Ldv
zcA13#Oq#ryA)@i}Sv}RBs|XN|Sg0T={T4twf?tX+kT9Imz~Y)XN`qS8|G+=Kc@SI%
zqQmI7cjEnqdLP1pb59T+7r57eKp(n>YJE!2XQA8TU&#V>jbhdD_7q5&p)SoK!4DXL
zN>^J{Z*RpWcS)*>1CTvUX!WSz=hruvwrzfYs`~5mb`UO0%F_V_(SkZS+YzA_ozKw)
zK+$6C>B!bNWrtzD8Ia+gjm^$q2YoKE&cjl22+Eq+9V6`Nwn(&43%-fP%|^lfQLlK^
zxxHJhqRXUTN@D-m6jvK(5fFP0K83%MOcUxol^Td?bOeRcOVr`y!bqmt810HRFu*6U
zr0U3V7F?S-3O!VM`nBy42pw~Hk3qVQ$6RnX<rJX~RH2T_UCEzK5a%{bo}R9^GVv+!
z1lAN>r}<20Lmt32V5+OiUv&w%Q&m;dAt$;r?Ez=N0Kz03HcJM$u3O-^MW>eSTxoHn
zM7=r<zs-`%TXrXOGaGv0_s0*t@)qs$qkU7d04cCD*+{GB)Y<LZgC$LJkg%OpHp+qJ
zcavL$B%2?z0wepqvv;;k%C`VI3o_T5iPxLSHM-n)L8inz9S+alr}kBCS!Lv#a1>kP
zH*X|q-6Uk<F&!CkAlsy}0{1H18@r4W5f#A2@B%=Ae7jV92`P0p&e=%8yUd)7M65G0
zCJEk^t^+U;d{K1nZSfMuk_<3^*-`5y*O2T<cT1d@zQ~<Aw#7gU-iM;_0xsqoh@HS%
z1>i9&H(B7E7-eFa{Fw&IJp5P+fL-J|SFZUFN^7790<hFJ+xv?c{92)neCMVAnSI1~
z0Nm*dBlxohY6&vxPeV`W-6P66Rywa!F&0B}LvUWxtsZ%xNb3yS&rm*MdX7A7&g~9L
zt`zQ51D0O<1M_DHsasbfEfj-F7|R1Ec9lr0(OJTdejSqK?*KhuaemX809RlNu=XS-
zmdk@nmXqaUmRPj#xgnL=Evde)jai_htR4=nFLY-+%Qliwsk1<yCkN$cK;2@RoM^Gg
zg1`hS!B(B72asqiD-YtDHBCvOTG%7^YYIYWV(-(e$Ls+);7?6j9xm-s(ZJ9pz&Vvl
z^=7EIu*A?+N|Z7#=c}X!2Zd%9qS}{O8t}2mLVhNUyIjh#B)(l)$gv6Kiq<zwDyo!%
zT>ua!J%#`pC`dHGQjs8t0MlbM;u1_55FpfNS?T~U-{d6~p$;(hyVjs4WHNFzIbB?j
zUS!}W5Yam(I<KZC<kIqqXr?@!XCwKfeBi;R+RNxO)c5qTbLXur%%@poTNqYy)e=5)
ziix%)awVjBFkf(5dWOJN%Ze1L1wN6@=rC*xQ)m<bqyajhfFL6yDz00hBl8tnkbZB3
z4;Acy+f@yWs-2#?CE7_sX*rVbI)P)SV05$ueq1X2;-AOs`M?f<i9~?o(kd4K^4chN
zbe)Ms`iR(JCqWrbMr!1#Mpk*ZrZ+e(3Jr;p_{LctgDOq_$WnWoEfmCo3&{d33G5_X
z4G)v&yQ2V0xUd_ZChts#v9Rq{3|iI^fS+1orlcm3Nt?u(q!p=ltOx~VjfdPxmBmgz
zMMSWsMc8Rg8A<?QQ=4|xTRa_76|1SKe!CKNB)v&$^0{ec_VnJ1dm8hUo{37*L}E<x
zUCTD+y=PfO{DlIYRO%yuW+wBQUZiQmhNR?V*-k<Mu4M@tNd?I;dP%@i)>XGoa?Q!q
z)W_2=7jK<J3Z*K-^rDv$W;e$~zlX-r{l*`-b+R8~2)jI22^d^$C)QlK&?JtGK;U3f
zO3NjK6F)x{v)Gu6DlARt#84HRb;m)18B80Kf{&ad)93{{1vyLjKgr@s#%v{nh<mkw
z09)PibT8xAS2l67B3Zu>P5+Lh0vX8C(}~1k*((4CF5f{YcztaU#+Id^Y{}?HADX7x
z0&YUd9d+@gyN<#l+*6g=wtyJTZ0LP4Ic0I%K9kjeU;VqbZJZWmp|2C(Fr1YYqHzxe
zVh%WQHDe|`f+;!11ecjeEKcS#h@Hj>2ZErEd_iiQ#GiE8B|1UJTlFPfjk8;FD;&3#
z{cVV?jE50Wz;f)th%r$KoaiUMyct$5qRs_M?AovAlN(%kt0*5rzOeT}=RjFFU;GpS
z;YkBM*9+jdLLV&Phb{Ex6#D5Pg!tO8Zev}haf~>;Igbn{0&#Igu?<Cts-n30q9knb
z?yRDWK;=2Ul!XqMiIvIGk<Z2#G4UMsuriFqDZ(q5k-)+%PT4%CVpB&tJWl1fGqDnz
z*}4Ma{7RbUrMt}~-!m270>Gi+k|#xS?H|S9#-$y@r6p~pJ?o|WsyN8yQvST+Qw!Ye
zUfjq_g@M3BtohwQs&H!GA(1hJ<kF#OyxcZ!+4Vrk7F{-rFTZ11KGz@@Krf$fC|?*Z
ze>h+MI8OS&TDh3FxahLR%CzKiR>h&zitSYuZ)u`$Y0~f4%hxzyBfiqYxN?2C(!Q<o
z$9kpJawTAeBb#vXL@v6KyM@JV$|@Ijkr53l5s#OS_{2ryswyq3KyNNGzDoFH)i$Dp
zj1Z9bvI=O-K~pLaZPiM+60C92Fr)gTr5eB}l^m<WZW>pkj9Kup!zNcN4YDO^>xUNu
zD=n-*XO|k+2kOmeK!C@&Uj+?M*7yb024vR;j!5@6)C%D$lmxI)`8qLH)!X4(W#bY_
z<63x{_9CtBE~gGnL72^|r#FJBy11}N&{`K9A%NK@!ymq^`!H6wt*-(e(SW?I&M5&o
zBMm~{6yGt-7=vkr6%s}k*<Y=f$!dJ0)9`K#Q}7Cm!HP=5szr_K0d7sqD^X;X7K+v6
z;sVA90XcWD29eDOmdJfg%z^2;@cDXVTixB4jc;L1__RYJ5lts_!L=-j!^5@aC18JG
z<#WqsX(W&dZ=81l%gOnS>AGBQ{ejK-#*K&;+_Ls<A~<~#oEZW8ITC1Z#4NeuwtPLD
zCE+!41Yk6qEfqc@w!oJQ!K|<mQqjQ4^2t}4-@oA|8A-TmPKbPs&}|+jqORHslnbt6
zNokcaKnXG;TNk4#-|%F(HZrOL^$~bhU7}?T7L&k`pk`q9C@C0mk{dBMi<QYBg0fmk
zpy(Krnc2`d-@to=Ya&zX`$sy&mzz*ym=!`b0BZS^f^*CcfOJHebmT!?$7|LxTUZ-5
zqE*KFx5%qt_;+q*_Hjhj@uaSrl<&vWtxseGpU|ds>}xuKGOpRb|2TT##4lnSv#b2w
zNhzQUl(+1J`*b>Nemo(`Iw5V`Ub>)EHX~JReX=0|=bL@9apB~V?<aW*UG3Ig9l>44
zgK@R{ySfx4TSmK{RdtbY&AkfReCuxhFc0J1JvdrEx?l3uSzP~U_nX_@<H0>s396I(
zduFl6XBK*HCaCWI+H=SH)Lif>>*WqN%Hex6<-Yx=W@+M&6?#{!dsi1^7lM0VHub(9
z?cM&d?Ctm7HHFiktWSRqKK*6?UtH|_ex>2j)4#r-1{C>l8$L3GkIvy^oB6`$_@aw^
z@eMwx*e7YzCmqr!o70DH?o&9|r?l9ove8FS>{qkt*9hs?%IVi>?$<llZ?M>JxY18i
zJY!;W#w_HF`DV@;%jPrI=g!zJp0VFJLslH1+6*{`3^?Zu(3%Ha&keXQ4tQ=1&=t@6
z*qrqXIUA63Hn90@@VT?0i)X_(&N37SBW(twLk44V2IHCs6V44LEe@t^45lg$rP~Z;
zgbeM=8OmxN+J9~+cX8<8#?aUO5=@)nf{@{;oXVo+;nH)%WsAc}Rq$i0!x@xAmkA?*
ztaf}KqRvfb@2dty91=xAHY-Zg*dvH4Z9Dei5-Z$x(kKNchKXqE$p#aHK^qd1=LU}G
z50U<qSu+LC>Vuc`L4GrMp%b)U8nvgC!9TVO<IZDnr%){M84>BNWD()MRD(~*Gl#(6
zrq$Xv4}n)hF4&A!b-0MIMbP7M;2Srv>l*mf?V@>FuPE_?Odn#-26P}?a=NX4%&nw7
zPD2Pcg2ExsUAvTwyM+BA^L|v21grn;xgfTx=%?OT2(DQ6{}uCVnRGor>Hcui^T$7#
zpI_+ZfZWT0EtiAOUk-hEIsC_EhSF4|?NoH=R7~zvT+39#`KhFbQz<{DQkAZx+g`~C
z?Yj#Ou|uxx&z(qQh|TIN$&{VR%T*D!?azNZRoo)U%Ildn>6;c=o;Giu&UrXx#1K2&
zGp^6Q+I0SE%lWIo>{Xu9OuOw&hwV(g?PTE(ekVtADfP-i)ukq^1Y>z-l$Fq0HNy}Q
zPl8=j8@u)z)>}$(*vh(gqwU&U-1Y0r*N(8RBPiEQLL`Xp*E`0p&$L|^AznL0ydGC1
zJNr=bUzr>LT^}>yMSu4sL3el%jr#|RgCHD4;Qq2nc~T&>_7Cs|;X2421%WpkD^Cd8
zK|l_|Z;(OC+06n1Y!Fn7VRS%@4MJ<sWfer%{-K+4a5XlDu$)%FLC#TKO`k0e$q*;=
z+{w~br-vkPAQ}e|GB=NH+4)TnErTGOZ*&oa(;yJ2r|kpLxS*K)@T5aQK7K@^BgD-7
zy*(jX29Yx_FRF==&kk=+K}Ea2J7iSf5#|?CR$LEZvn@J)5GTv@u7x-mYeyRd$)dcH
z89q@EIn&qmhLlvhbLzMOW8Pja5HqU}pN14u5EX;?);1U2nBcfw{)uX8z7WcSt`c?h
zJaz|X2gR4A9ca)aC%Sl8=O5z5gtrDnvAjH;AV{_`i;B;vPNC<!x{$+MVlB)<ATU<$
zd6VmPCCV)|$R(^e^rW|&J0x?;r5~vZy{Mw>S{po_5Rj4S-k2472y#=ERG+B#zf1PX
z%*bolYU;w-(HHNPb)-NoH?yJC=Uj^a0g^%B=0g<6Ls017ZD&K*)^>X|DxXj9&(Et3
z^v{3}6C(n{A%4aVYu)@Eu_u)2>E>K<sQIw}Oj+0&=O8A;(p;=FLxVF*3v0I;2j^s$
zRMd9Gxg3CqT6y5efv{TF(0ofrLb7X7ZS7GjkG&9DbJ}ikIO06S+YGfr5`t18sAftE
z7@L}(KBg0A-TvmX6a?5bY~rf8O-?&<Y%O=@(T}%v479c!qfjV2s2nf%-Mb?4Ai$Or
zQ0wMtbLSKxJ~mSx9|(~)NPp$x91p>^J*k{jw_}jb%EO6fYaY8RrJQ2NNDR_-BF90<
ztuR^3&nE?PRu$*B?se?H(5wu>wzJI^+bv9><GK3s`|3u4r+Y_=4vrtr+h#}FYONi|
z@G^o3oFmQT1lN0Dcm^VH%VWA$TcX0e$xBaO3XYNYM`}Yr?m)8Rjl=sPAZM-@nHZa&
z6n!LaR}(Yq*nebl(#lrj|LzV?lS)wx`yZ{XvD7X0`NGPs1OKfg{oAL%<r|qWdou7$
z!lRk9-S<y>FEW+g277`!!ftkj{mtYOFOUD1Pv0l{*wE>}m84Kf&EHJ!Uu;tUS4?hq
zZTI<q-r*UBfqV1kdjEY-(yy4xFKbUtHPoRyyuWNx7^B3$ZBl{sZF!KA)Im#WI(VOO
zsh@kkO$op(Ah^@$g#=mykD{oj(N=(9(c22qEUbWoV$Cm8^`V=)Vl8&u3RU4E?Kej)
z4(Tb`bPyjZu}N;YV+)v>(Ea^cHLK)ue2|8Nzm*VBjocDXKP=^<3)V>l>Q>jGvV*{e
zs5;%4-Ol!LbPMXij9Tw$ft7bl!flt>UDVaa6J+DFR-lShm}VJ167-9s7JrGJq90O_
zE~Jz@4<MWmt4Qm5OXF*FY0b`auPA!!*;O`xG!>^K3EQOy><8!c9FB@_u2N)$3WK?)
zgtvAf9a<g+<9bD5A>b+Gp9x$AbQ*N~J{3Hdw7pqapRRHazLvE8w4|SdQv<eU3&jmD
z?dZhEni;wraLp8_EjN5VPA;?;Cbt6yHgqL`u14?tZa&v3Y$-i=`gGA3{Zo`cf*GGu
zqajK@78siFihP=In=X(LiB6+5;tM{KpQRhjjsuou-1G3gNwWkEo9KQrPHs*d$k!=I
zr*7S(ztlq}r*mf{i9WL`63flLqaQE4NufyU7nG9gvSz{F7vhs8b4X<bSp`dhF*VWe
zM$@J*nD}t-hwUja0Ah?X-jTN=NQcNLL?^dW)3%8Tl-?C==FU##Nv&p5_jK5TT6CWB
zdvbwjv=Nm#R1V%t1T(%mjz2c0cZQ30xH{Co5GFrDKM?ui6EF5P#l*4V^ZV96w9NDY
z&YCxF7GQ+UDz#boSppWS8fL(Nu<7loaw$LE3qa_8)7i)d<2~;y>)^n9c$>im@~DX8
zc84aTNoQ)hs97QT62Z*l8RCXg!dc9&W?SlB=veyV+cVp|NAeMj0mtizdh#rqner?m
zjgD1yq<Vuy0El1nRsb}zz_^Z5f`>2mei?vs<W}UvDTS-pPnVdry9tEQY5jF@=%Ea9
zXW4qFu%^$@6EWmI#K=T1N0Yn5ubi-BiAdRe4-VO!Zzpa~il7|lIqrTG5%bhFk^;5~
zUJ;|kb$g`6F(x86T0i8TPmiD)P(~BazRnfapglrITxQQN6HIG<mr;UWV&!%dXW~Gf
z8oW$Ic-1o<%jiMg8A;ocQUSlpqsk7QWfA%bt=%%foh&XbKr*+tX@y!e1ZJn1NW9n|
zeNRu*v1oER3ey(tV3`d%Td(F}U$uxmyH_P8DGAUT6t`>!a)UD7REvMx<@5<(iz}c&
z{-bF*u-g5W8H+giIciF_9oY^eqh8re_UD>&RiQbx*pl{bIEef4cO0;4fK>wcH}iAv
zhQCtc;NS8~QiWI3gvL~;7cDlqA1@zHgU4%Izl+xaIx5Bgkm4x+V%%Vlzc~VT(V>`B
z%>ut*;d?u@DbG%F3&kg!8fnrOgf(Y_4}3T((&p=c^0|0us+V9WwsgV3n%f{ec?>Mk
zqKGb6OX~bVxR&HZv5w&Gf-{hYG>&(9aAU~BNWv|Rk~=lbTZfcH0qNl`-~R6)X`f?Y
z@Z}aa^wlbUu;X!w%U!{WpH4bd$uwEO3RIDBEKn0cP$zICa)alLA8r-X2ACo~I5-Jk
zz>mjLQvIB`Ti8zRI##jF3~TVn9St$W$5(Rp1n{ElBt}>$Nl#Rg-2vwf)ZAvv?pqyY
zlwa;?|AgHYyHc#ZDH;teTA!0ebKF%Q)}n#=aq>72n%_e>*|60>7cRn-Uw`h7U1nuu
z1Hfya$x-dG_tb<4@SXVNIgvKQER@OPO3n_oXEHAP&z%eZWbQbMir<}4!VW{+K!U{1
zZt{^?5f;-Ngu@(!_ASE!1QRVtel84Bg)gVqp}iRIchjX8pBIpaj$htlf*?k)4FU;!
zWL{H}LY5`H&}UGuPLo9qmbDGmdx>#rgq9HK*}#)yVPWMqu;BHqDE*VBAAORpb7i;<
z#1@(U>iV~h7D~~o$SO>DYMZ2<_SB3!`evmU+xL8~nw9yq$&NuKX_G_Wu1lqvG;L{r
zK3)*CN!T5JrsYLX6TxBf=DuF9Bd@N%u;2K0iz#mA$|1a@J}sOr^8D-p+Ql82B;PKQ
zy-dNk*6#wyirf_LG1D9Ix7XR4H(x?c1^uszI^*X$?XQ_hQY$;?3mT_A&-RFXTCQEw
z)aY||v5mQr*vLP5Um(7({Wjs>wYHw{c$e_>veLbqgI?*U-lbR+EIt+=^6nzOPjB9M
z_|kJ|^u9+mgTL|Us0;G^i)0-3j^g|W0qx?pJI`738;{?Zn+nPgBpja3Sz4Y#kHc;d
z>UhKVBq<*q#V@WsPns}Y>K&f4xcRXn=f~59iY{{d_qcqH((1iU!|bcDwOxRtx&lUi
zioAOJ6MI_enR`qH<%<q@MA7ku$hS<YEQ@>asgk939<3#I<&Q|lgi<wO`m_uc`u?^M
zCQ|#)pAq+Ebxs^nWFc!!4}N~4@rdXaTe9WLPql;RfBU^{c$9L_liR7S5k@tl<)Pcf
zS=jS$9|qm`JYE5E)C=CgM@Fce_aACS9B-6ie(arw0eKG#)_$Z;t30#k4sb$O+i9&e
zDEJ;$F7*!P>bcd{yK9F(dlT%_r{AF1UG2@x6`}plRS9XF17(kAsw!;(=MUu<PXDs*
zvvB!DtR@_lE11bLq!k`{@HO906^PyTtLIE5_<qmMjU|aoo9kD+etr69YwOwFB4q=4
zKi4WR{dnQkdQYzP*Xv*B96wiX{@U2w1n^9_B@-FQL}xLv4NPI$LG=M<@||sRlzrls
zD#y%OvRN#A1506;r8KN8HOnI4*(WIxYWO&fK(<Z;TW^?cFwZuO!&iJ|n^@+X1?HP)
z<y$u7TMy^|lgZ%=sFnqefd$T41+<0&*Wm*9`2q;Y(eZ^omW6(Sg#lTGfenSh!-b*q
zh2iUk417_fWl?lsQA}1*TtiX9a8c5HQObHzD!w?~vN$8Kcwbg=Rzvar;o{u+;)CnO
ze=#{r4s=sjl*QpRa7u^&!Q|FCTzpBjWl2q7NnKV+Lqkc^a7oL2$&vLE9=^2Qva}<x
z^mtZjXG3Y%aB0tcY43U|AAhLd@({$~2D1(gHyj!rK6HNm(8cvb0;vBwFyi4eX|gtW
znFby;FN<OAzs|vb`Lm2eQN5!hb8~3V@Bd(Ov_sN!<xBXA#OGyWv<fvM%j`DMm<IM-
z2Fsk25NSfkhs&ZOGU1d;>9K5phh1rq8vzatnaf?yD!)ZTK97?=4*=^l@bY{GGD1u&
zP3$`Kvoa=<j^o0svN6kC>{#WSS*Yhhq%$)Olg1{<%Um5I>Rqh>__^BOs!1gYPvj1p
zL3eoBhb=c74_l8MwtaBe{@Y=)d=1sA#xbbIIlG3|SmQcU<Nlz=^IHvFzShU8_Mc3y
zu{L<5HuOPl__tbyd|jkfU35@gOm<ydV_m{XUDAWPly7yZ^7ZLf^%+6+`?Bk^8teCu
z)aO2^KlrVlDc``hYA6V5D9Uc&G&YouG?YDPsQA{vm2a#bDfqRf(i@TeD6Ubuk9#;9
zY_Mu<deC?<KCc^JzBL=xnGHi$HFaNYLR2+%eQW9r0(*5q{)47I-R2P?VCZBszy;cL
zo5rnLCLg3pHXc?DYU!zJ5&u~EYA|u;B={0+O@XzxPPLe)wY<7#{Rmd6(wE?R+prxq
z-fE2l|J$<+00?L@hAx}|0Dw+a)YYAcL<e<sM@2<@6%~qxhLeJVos!Zv0)a{(IH;*P
zDJzqq2~|~<qNun{Rh6ot;jF2-T}7F!q-3wEx=mSm8<`w#w$;zqH<3yWmzTFyBRUZX
z6crV+w6vwZzN?#CoPoZFtgMx-ZJ?48*~)4M9&fvSdz7<tl$Te6wRI4c%Fxkqk(0AY
zN@DNbTauMsW?|u{tLtK7;>Bbg-nK2=(=#a`AdN=b<?bHu?VS`GdoV04&DS@@#Kbo=
zG}F^F#?=*iH-?2pfTw4ip^;~N`~h#DIP<LmUiA2=s2l|admL`7rlzyJyuF#3cT7wU
zgRw6rHrK~DK~}~pIyxJTGH`a@xpU`UAD;vR1NU7qS>fS(G&O1JYEIk8K|~@IkGD})
zf<7rlRfTF{;csm0siI;Z7M5XbOpi}En2?y0np&`D4`=u8{5=^(nOUV~=I(|@?tAwZ
zA2`U(Jy33HN;fq0va<~_+~VQn9A;!hv$PCKPRR=n-s|g^7#*D(7M7*1=4@)}8x)+P
zq3%p1I9Xc-#l#$Nci+W`*cTnWPZDS8?Hv~todtqh?d?Ou!cw)gwtIOchKFZ*dnc%>
zP<HIt9k2s>k(QX4XKd^(CT6Owy`4e{x3>=r4b4zhaqtgFa&!!{vDuNFoEI3BYGUH;
z;1FSM;jw!+)6~p8ExlmhzLJc+oV4`9)U={~nI#Z1Iha?yKc^xmw=_GubpQT}qN4iz
z{90oZm*V0E3oCa+LsvTsYc*}Uw!R0{%ds(w)YI~<t33i;6rGCtU}6;TazgI+0iu<$
z1%yM+9ob@Q=a~@ko4HA_yn>mkx~CS=OGDc=K04IR#jQTil$~M@P1_-Xd(>4uh$?|P
zTEXgsAmc688bsf=aypb}-05lLMxkn|M+MP$LV3od5RI;`UMO-H>0=fjO5N@llN_X_
zsTK%D5uwzZt7ATt!h_;<s*0`(@&REXX#^!-D2u0}>@O=D2}!i2rNbnp!v5oAEcI%3
z?B7nt<Nl=LZ=X<i@ALi7hrWJz^~{M|N6CLp#u>5QR(o<k3KPrfjmq~F$^0+R@*}-;
z8D^*1XY8u!4F%@T@R5H`#;H#wL$}7t$Q6v`UWGi%e^17WpY@Umrm4unS2BNjmP<5M
z+>Z3j?&yw%=P&DaT53PL#e))R7rwsQ%E}OeC)U;tB$kCqU)=9;Ztxu|Bc!n5uAT&w
z0dy%}&OSH%@#*y8TR)pNmLf;4)_BcnLf0yHGJZ=@!cuu=x9*o~Z^A$;$g`Yy!8zHf
zN#Q%xAbjOU#Q+*$eEQ3?{6ziEChf-T&a9)NkY`zHtb@Q7HUEca`G1vl;PFH;+zOGR
zl8#*|Rxh;#OSIc{=p59^&gDa-DV?WfX7}QrmRmmWd|F}q1uE+xqjgugj<WHqRWz-W
ztJUu2uT~G!opqnp_yxp2s|}1f`K&H<->YZ!lu^v{hUmKZ=Z$g4Pd;x-8hrJ<Idw|+
zMN7uL_!q5N&riNMlKbV=i=#}m-b>zYszY33q)OMz_U(5Bo!d9S8Xe%WlAo?~{nS>k
z?TxN;CmoL3H@#3ga5kXzWc%^1u7id>uU~ibr#4-Ky7w=rb4~m0T@qbkpI^T@EkNtP
z<xhTJSi&NmW@eR#SNF&C%{uF!It|xZVkp3MyXi)Qme-#4YI*3V@ZlV{-}E0>Kj;SD
z_UiWl7+^64Si56$8bIlg-@}meZ@Mv}->Z6C5s=sfg;-LgT)IS^orKTXGXOl?j7bJm
z30(5&T}!|uLiFwiOj-mII3k~Y5ss2O18pEfUWkU$udmsSjf>%jL74bSrs(bwwI3w*
z#ouMqsL1H`stGx7gLDVXu1*F*#KZP>H&R-s4<RSS;jx9LW(>^ZaM6r>IbWrZRM|L3
zdKyd!3r=m}NfTJ`s-(6;DYezj>dVM>4P!UqlJjbX3Xy&U7GU%ec1Xfl$)`X+*o^*u
zzQK3jxUMI6O(4M>CNW|7&-@8Efz;0ul8`pxi2BnQ7&#-qH$qYhNPe*<HCN3Arrg4s
zL<dfC;aH)$KG+NbUjMBn#uPV+Oq?ErW8~*?rJ{;~l*?$3VTK6K*R~q25d}33!fl6*
zp$mzm6#&);R^=-|5)!tdekh$OZbuftxT}h{9baT8mk8unW`zhe0JWn5hAm4iCJzur
zA5SpVGX!V@1EP>V*-1)^3-}Ah;AqB<aZzST_#6u<GAq#RARw{a3Mmu_z%#K8B7B0l
z65i?ZCW8mZ)&O$E&M_QaP^3xbp^T>|49ytAL1jdsrqfBtnZ$;z&%h`Rj&cEHj(9Fb
zJd2DJGFwK8i*k!oSFb6EwgLO($%qrvfV3GwMB_RWL1j4U>ZBHKb7w=<Bu<)ia=xKi
zyO@KH!-%w?&^;8A_i^B&k4Z@3nl@}EFMn}`HZv@`gt+vbte^xkk)QxBoAnH3y96Mz
zcz_DY0lP%tAp8XI_%#5LyOjwiF<>&_1X4T|hFBw`H3<{XTwOc{XW#7jnhqdlF84;H
zABG`00z^V8P%6Y|n9sNmC_&94yk$U(7PR%n)!H<%Ljat_lzSJyiQZRKegrsGYImsC
zB&Wy#fF<7zTQ!|6a@B7Gj|o#Zg_t{W1?@8a56A|i-nH4%Z8))$wEt=lekUU0qt}`%
znDF1rIO!gnAd}o0?V~mJ$}g#@`%_%JZ^CFX`3Lb%;i&5gGY`G`Pi=F@g`X>Wmh0_U
zCvx*>XFZKCmm2p9cY5=YD$96U;E3zJ{-!^B;yk*8p{BX2r1n#(e+o(5DV!T#__J5^
z(@96>(s9Jf){gM7L#KXym$TwrCioC~BGs#ZFMP-%SPgTOWfSiS3>{BP5S@;q-TtLP
zICy3s4{_|T2H_l;oBKNyddicj4E>O%%`fePeQdUN>b1qH)Zd2kPIXg4H$s+5Z}cbW
z_NM7}KYV8WS6PQ)MdY3;lNy+r)H<A^MFQW8uL><FbC4ZSgYe_4XVr{vQ}K+)25p1d
zH!jn1w?x9&wrv+esE(A+Io01(qUD6WdsQc;gNm6Vml9Tt0A`cSa(e+18}Pf~V-ko5
zCr?i(bMjoMi`WnG6UeJ5CpHi%p)GUa-;{M+ni(^{*;kQy{i({v`W3QxKeyO@RZa2R
zG|jWW<U-r3*8gal>xJTiwL{mR8D`3Mg@37&L`rs%u9aSmx%s;Z06aH4_igiE%R17t
zb)keBG#Oj9m;5}#!-V;)N`9Z^c>WzrbGG?@n_Dr^q3!X?HRSu9hMNP&EpEK>%=vzo
zCw{hbyT@yv=I?Wzo@cvu{FPAq{yV?oY)`Dmn_#!&xWSuedoypm3E%h*O~!-#;=h{a
zHs+^22m9-9yp6HhcraTrIPlkG9I~-6e{*nf=*GL0oQ=gL@uA@>9{)WV-*~_8+{UA|
zilOr_JU;AS+<3fxbLisN8y^mCY&-!Zh6NbUHMZi9C9K!*xZKUPqNr!1_qSlBl{`O|
zhWuDLrJ_G&VXtYo=lmA4sLZf5QMt{gT!Q7M7TUq~*T=fz?aGEm(*euv`D2mmgr9-a
z5pvZP4R0ou(IelS9xwmFyMF#<@;4Z;7Qyw@j8cTNtnZxiSveVU!Nu{?Xeh1s&u)->
zAxz@j{1wkH{mnn$#(AAvxPSA@;JKggQY+6reBt?Zbn)l=tXt<Ef4%wj;>OPpOo{VL
z7_as5e<sxAZmmz*{QAhPJin^#^=&5P*QbVC=bu~L`gSwt*B?BI3oo~OeZSNE>vN~q
zh1WZ7eZP0^*Pr~#3vXk+HWn6teHpH#O^zJE3cow}=!6}o<Z%wTvZJF+$=Kep=E>UE
zi?zgCr%S!}<Z&O{AQe#&2S+oT+xBLKYykX&J0Hn$)!*K?;os5WtSd?!%;ydMv^CE7
zV$+^G*Z=hMnnccr`*|D(F!HAyjCm(UC-_s&30d@9JyY1y_W_?-8heoFBtGFRKEqR$
z!N-UVYYne3bJAH_wR<m4VUYhibHD*4a1dVn_sjvU;-G(*P?0sXT7x!i&>qeRx;)>u
z1FBW?^rS$|EZbddp!FMNTY!fL8Cua98u&x2I2W2VR6eYw89;NfF*I=1*7AUS7|_YO
zzK*w+rkj?AyS}cEuC~_}JwIqk26d^ZYtRh!{at7_HkQtiGsD?!tG13CROhzMEKWm<
z2JPVvW*>2MHPP4eHZ};_qUWnbBu82`)9F+*!%$DCTn1`;(e-k)Oo8f7T#a(Pyc}Kr
zt~ItciE=PbHPG@U+a?D)aGcHeSdbWM#O=9z8xrk~+vz7pnze>IR9P5A#M&JVwCA{4
zWkHwZrn+HHPL{bo1JFe})HvheLCvR4_&6LW@|dEN3cR-+Bxyqha*kQf15o+PKFV3>
zxIM<X5!wj)Z!NLXi>BKgV0vC~wclIrcca>WF46r+`u6S+iz;u6{KNG7rQ2^F$ZXx?
zbuxQTZLaHZU_hw5S*|T9mg=z8)18v$+L=b}mXbHuRrk&%Um$CyIqPRdQyM~Tt1?om
zYr|$tO<kCd<3#}@neO~R<H`iDoH+B2Ag>^bewx2sfv2aVo2Ol|-$X)eCM&nKEnlI%
z+&Ex|XC$pA+`0T{$VzT_HM`&d+x|*(`2C28z}R?3zF(IH(JRO$x|ct2y1Ar2=t1vc
zoxOf#X#s2pXL6c#Uzyj9rohLCf+usVFBLM{y>yGN948eVJP{h|X=iKXPuoFK3vt+H
zoEctJ3|;Gc#dy)&)^CYavU%a#6Yus(w0Hd0!C2`Gdtc#pH*v>ad3leUC)I~rt<4<e
z(mYBdT&p5oQoY=rncgS%gdI$cr8-f<s`o2J`z5gBR4OVt7cO0BKjdJkzRT6cA#VpS
zF)6Ad;9_>}zKRI`&fo$`S^tcrj{26yxqi~ps9Df<<CSx=yHjIx>8<4<gN5X4cGkYL
zcWzY_UVlA-J00_9*pAAw=<Xff+^UkJap7H2{zemRMjr0=_n)k0?mivwsUGdEQ(YL-
z&ZVU8%G<k-^B-ppak2P^)3?E?%70T3Xmy;H1``xEsYLwi%u&<1z1%?jp25GgTkpDA
z(BAdWZ5(3)o|=i9@b8Pe`;VEUAoh%`*~Z{M3IhFKRn-g5<iS4t)$Ou8kx+RYAOxzf
zT;aOiD|H`9pZJX}pE!7Z<P79K#6^ZH{B6Y$iSoQLdiKqIhDA6j8b0`Lad^+Aw=V;S
zK0FaXGWjj%|DHMYci#N3ZQTD!L7<W7iT~N{a`6FB2NeYV|7MQP<szkhP(dJ}NN0tk
zQ5W}jLEuWM!Qe|ZJO}_|WuPCf@KD`1)^CB@9GH5!=>li0Ld}>Kona4`kCt{&`F0yk
z1ZF92DzpLUkD?HfTOr!YJ6w-+TG9aQeqlSxqaq7nSPd+l*}Pkp$3ml+02QXO>Ow_o
zyq!JX0v~>L94&wT!SQBQCKz|5;G!-WjS<9aAK4?hUjP?TN(DOP-|{D#6|i6ejEG&1
zLl>g=$HLP3^#ri=ip|$CXqNTst`i!$spCRbqfKM*->em0{)YPeTCbaLJ<8;3NONJW
z`Q{4oyv}>CyU@u2Ipof(DQhhLM3Mgc;ng~~_XCSf-S0==4!(JRZfz<g1={rmJuO#r
z<()?AyAT|jo5U6Q!%Z>!neESI^$mwVrHE*rGtrshkALdDrZ=pTv^2(-#^@nN<agU9
zVc+dD0Iq&Aw=ubL_ef~psDcu33<`TGy*zf8IvUSwyw|0B>Lc}a%$UQ3bxNPJx`+PF
zX9}SM{fIMeyQ^InhUbg%Z_j<G(fPLV8bfm256riT>rc3wJ|myt-*g@oU{nl9?+12|
ze@{9^wQxO!Apx7XiB|F<w-aIyt*@CrOuuEF)Ruus`FdMU<aG?z9ICWjR++WVdX(&&
zGSc4s<l&jea0C8WZM!TZ{}g#KY*27_>h1H_#}W-PVa5&6ss7-~7XI?y{Y#n8>NgC}
zbw-;0c#SsbAWXpU9o&3mRX>w8amS61IFF%0RRXtPFvk{656phL|4fe0`g|WU^#8G%
z&UFxm_Z($^gHIoYkIUW<*?LiRfqC!CGp@mPs;J~gxpk9|1s@{-sY(I)kvS9N7)Y07
zugRi|3Sr_&WQ6(>6|@xa#dH!7e{KM1D*u9b3i*K2JYhYOjM}m$K<L>jpp%$r-Dv_+
zb%~7K6eh7vr6Z6%;{vopA#9k%%W)HB4Hf7Z${bum*ksLre+V$G%XTB_mMd@#5MkB;
zLn}NS!^{AHS=on>n6gE*<r+-vx_1#n`nPY_@#dO_UWKY6^%zIzGj>OeD~&bARbmKw
z>~A=vj#9{T4FSyC#h61_XNq<TgjLSBm22zNsbXIB$*pi1ih(ehP6kqxG$zxVRe)rW
zQCe8<+FrsqMyXiWy*v?S5ICh`y@qrgUJ+7avQceoTaF}?F;fL_bm~>4Xs0ADYmIzu
z9|2)L%oZjxkLx!;7CKi}p3omp8rxIPN{DfpB7GG51sF@-(GgBqW8&O#n;fN=zEVHS
zYS7WM1%Z<=@jmP%<_;HSlT8qF1jgYRj8gL+awsv7A}Y&=g8&5+#2+INN7-TkQ6z})
zyYTbbQX5)Co7l6XXj?vedkqn3vK~j%4(2%akYhw|Xk+_%`7#X^Z8mFU(TwjF{vKvx
z)-(rai>}+^(6p$|XNe1Y7t0g?*ian@Ii$c(lEaqR*{KnDxv5(Qq+oX5fXmTH-aB~9
z?TL0|S@~dKndR3paYq}3`&+3OoE0&iWrgh(upQ@!V$R?LKEw5X#hp1co}nXDGvi0#
zQ=~HE#&NSV?BC4iu+CW43v&ii`Fu*Y{`xrSIyaxPsl!G$VPP`ju1IldHZBA|WwrbH
zMRB|ZmsJYG3`4QwGDwa*>nLU0ht%$AYqb3XsUF7=eqzGLjE7P1F^c9#(wJhwz@+T)
zbB_YbfD5nxY@3^NQSUCKC92FSID99m=TIHts3n0CUjZR2nuRQpk`am_qqMIRP)P!|
z>=zQ-im?oO0u<#URz!^ufD{SLm(1X!w@E{BR&u_aK`uvwFA$1gIH?7aI1!+_P#9;e
zKy!9f=^;fbnK6bAWks45kO%ShtO}{yFg*|<etgZLppT0s!3pA%OB8X2CQN6bT_!Qk
z2@Gv3Q0pWj@!SH%KnB8I6tOAdvMx{#uDS=dG~nX`k2d)(vD5~}52+HU`r<5<1XgV-
zd7at3Y*0Y>@eL`-K$J?QA=M@*l9C3Guv1_(;tz^Y9<<DqZ7q-rRJeO$oY}F=<!JR#
zgvq2rc@hhym;X^YP<&j`42H2cW1%=aif~QYid`8?BAm1)7egqCz%J8m5x*(?;9Znw
zv>(m`3nj&GqXNo^QpMP@qvpK)T@5+%=GaxZB^SLVZcNAkJ0@x}R%$WOE<q<b$)T5y
z8$JoaoLb8tGG!GS@_E?AtS{4%OC{DCYJHn2mowgwil>k44*wkHbMf<5@TZpJ<K@m5
zc0q~4WWiGR@l854yV!{hHnfX6Aq7%Xv!zlEE6e0bhY~OPVBaaijC-epoEfX!f<G>j
zSHS{pQ_)(fpO8v)ghUK<(k2=y+Vm1W5Jh5J3l`C*fJx;g61?@v_{@&om*s;aL@9AF
ziGWzP)(;Zea(ztV75sVMA{k+JzHQPyHAVCuh%_7hF00KM!%0>Z;P4bFrocgel+N55
z*Z3x9$sxcFcSt>h^~y8$GB$Jzl;yr4mTNgK9Ly>wG*E>jjNnStAZuAHTVhXEfdbqZ
zF}Fv6DE<J<!-yMFfI+R}?(x;%c?DKIaBRS>$%k(aifl7rAcJ)#aB920N%t^cy3+GE
z3Dw-3t(IyiC{8&%fx2$Tpv)-|#!2u#7}4>s=O;^JiBx9OLGV<CY7CYFlV_18psCg~
z;R+slHy3ejYaRsvt}O}maN|wRz$chO+I5Hx3(*jQ{rmf{K{c2Y0Jt$x)w4+XKx_}4
zt<6dJ!)fcAIZqY17h(YXA%lWc74J<M%7VT24UE(6UZ;4-a6YDI3GGQoYZFir1W|e_
zl9GuWuZAhDA>(E-eq@9`AH7|Gz7~V_!Xv#H*$HbXbpWZhuV9i_u!{%7nwlH%(3B+<
zHWL}ePjZ9`ABv#e9x7)IvLqti0gUTQw1+d|*j9r#b=U)&#f4rxRB!`wUnjbqfWU(#
z+d-J(63WK{5z9xL3Q%=%G3`v}aDtGpT<P{DrXwS}nx9n3Lp9HrRP#}$0%Y}Yv9-2v
z_B<^8Oo|r|otj#t%q<NOz$HnCPH|E%uA>BjIaTwR(51q-S#(0GNCSi8$>fMl!Hq$9
z{tIl}T;ahb)aX2>Y8{=xN5^KtMHomN(=*i)5yy|gL(L2Tc5^#ifzFV<he>9lu>scj
zHSF=(iUcMm;!H};tTV8N+77k7=)i0RVJ-q#3Bq13Uf7Ho4tL>-IwQilmT#tzJ+qj~
zr9x#FgcpE$9mty5V<w+zq<F>1VzU#}<)YusipPUECB7GP&7tpj`isLbya08$9?m9b
zHO>Y%F2#l{p_2J%`mEnsZS3(i><17V#Y36$&=7R>7NXNS5db7E;8#-xHOJ{lM<&L|
ztiW1;oFHJ~Yqi&(GuXU+swC`g7o<4}+eAiwSaLZ9)a$Roj`LBvsrD*7bUqKoUPI;2
z3VW@I`(|Ut1;{KYHkXYyUJ4jrLgEBSU=4eOTump5y3?&338HKUgyV#~)@qVx*#NJu
zUbm^E5oyd%3|$fmVOHmia70qMfWXNXK=!>tl1cFNOtdQR&=p+^+DKw7zv;qIOL%Hy
zY5bmw&2Q#TyxkgPcB_0#6Th`I6@4wc0fPZ{Ght*?UuUjRm^7jR0CK^4Okj?GBYMv1
zXgeGc1Bzf3L_TQ(COjmQiv$4d`h%k$JVYf^D3K{fBI&K}YfDTO@fSkP$-o?Eon*i2
z;0Y~r&jRrKMPhkE6S_%MPMS&JPGFVj@!9jtB>0Ie@tGij>x+y4^8A?oruzZ=L8Os1
z+y%ts%_1ovCXI)slIam^!uFF}kbALtd|@9ty5cI<6+9Nm!{YhLVfzne@{v!*J3PCP
z3!k^9%nF^J6{_GK)FmT+&LO**$5OsyT-RV_YnUdm(?hsZM1YO`Y)#k%5pDuRDIXQW
z2SP`MV>19Vo_GZpk-H$YvrByMYitgPDHdRb>rc9_p?M2J6|c~q3FsL5$>xQVKD@5I
zGYC~Ka*_`{5YeRq`2Nvdr>hYZJ~BptO>{ib%It1kKwWG)0h0;z<abk-qE7R7=XD`5
zyv_)R9#>&~BKIVV02>`e;^{qC7EqJlg<aQdEgX7g6tHHqLV1i6&$iM%@fbH=Dytnv
zBG_4R5!0FgNdUhr+>_BI?wX331Ul2cZxzkKHaDGiONCQ-J;6nWie$v30E-9vDwbf&
z3w=Kpwr%Z7Beegflqsott`nY$iOn!nWaOq!!>(*TgH8PjONJwq=q@X22)jjlqXI9>
zYcSwBjG~WtoxhF1b5te-?Ys*!cQaKa!?k%Hwr|cTcQ{4~&`t??ct)rSAF*I+NFc!E
z_gIq`&k*<skBtEoe^7%Dn>wq1wDXK=5lo$IstgXQ&;iNRP}^=tVk#*@#AWJtn7`s6
zu+KW+4eWH(_FrlgRl?a)#Ub;MZAKYz6TaQ@`0y{w?d>K&#Ku7Mn~|Ul_z^Wg0~|Dx
z9>fbu)(0picVWpJXX@U-jxEAWmPS;f&PW2uKf83j_n2Y;NBLBE$+aP6e)?JJkTQUf
z2L=u-rk9+9y*Pv5cia1fg!A>!zuq+28WZ`O#fXvrovo52;9<Lq+*g}2tnIZGo%(j$
zf=~LVSIkrT4cyKclth`?Mp=s7bxSqTY411KJO_}VpD#Wtct{ro7@RgS;=}b72m%Y=
zqaq;e+c`iUgxL~M8ldIH&jO_%TAlruBp#kt64k!=S?Bk3gVTTNX}#6Lfv_we!H|@;
z@!RoJhZ#Q<4c=elfY-+c+D*nye*5`dzmYml`yl|7jMCHuH`UCL6JzjWmu&NOZ9;Vh
zJ_-DC$3LiD{KD4qrzp%Xr|A-5)qm*OB$=kz8g_3?ZO<RTli}|+rjE2<{9$g;#-=74
zTv;C1TIx1L%xb+vPN%!W_iaXMKa(`Qe9o}U)}Xj-x+c^(^2fG#HjW_J{VMW2_o?15
zeWQVubMN{QRNBll$(iTrx{7B>`}=Lm=L{Rtbu*<5GexIsKk3Vpu0HkAO`N#K>46<N
zr`zdnD0#*}5GvTyZ`c)Ty*Q!uLDI6;_Qq#5(3mZ^nF?*1u0DKAbcV}lW+~~<-uPo#
zSo9;;#uy{Ux>>Z0jc3(4jbT>H@YnZ>z{f&Gi9$%&E&H)sqOeTN@-1A%O#rxcoB)=P
zaIbU0C_ozi2o!rK=|{S?)Q0sW;YxW}<e0Ne6_N=^jgurR37|q4NW1`Qis5vVar!@T
z$7jJUk0gT$pz9_Hq>^W)f6A`^zy*>dcM@b{X2CBl;4j;oqJ3z(@f@*j4wrTtS2c?<
z7PV5Am$)Dmw}vYOq)ZQhM#4Z617xRyA~%F}DEEX}ceQTcb>4z=PX=XWamjYSk44<W
zQ$&%s?~35ih}%d>++B3q?^|FP6EPt7lq6GGvbY?K@BpK?%**01aPRr_8?tYEBwa}l
z8d@JDR?Rm(dT`>l#u4R(S(avd*usrI#PQaJt_uq*W19NQ3wp4{9=pYXu*G9r76)4w
zM=va%f3$e<=b}LQ;kcdFu$^SE$;0W^hcg!*URPFdn0+`KCU;Bu(cA^uyJ3&!m1Xa@
zK6-dVW^wb;qa{0;C(4g=U<)Vh9<R2_Jx^YE+4}hX7U_3CAAfoz_0jIhm!Fb<9(eNo
zl;pPyPkx0-{`~m_E-nePU-E>(ytzxl2Y>4dTk@jh|M64ok0lZ5@a2nSAyvVGxS=#J
zj4hJ<q<u-^7->bra|H}vQ2Zrj#Q?LC!8bP^Js}IJF_C7TPt(cRM=cW4RV%i)S1@gk
zq5R+B#MMVX#m+3jX-8H~>=$i+Nf{jgzbh@DAz)mNtf~oCBfQbS_Wtg<1<d6xlkA`Q
zzlXc^F4H3rUWQ=2II#ZeiL>W3|M2IElA`vvSE+5{t-O=)G>nh<3)h3si16oz5iiic
zq;}gsPv3mJL?^xk1TPT>U#5w_?DlxMB@IBd=@uG-%XAcjjyiJl)qUGnerW)b^143!
z_4l8z&U(Bu?1KS}*S(Kl9<$eYVFQ{FUUpQ#!nv=kZoD@52(zZ|g|{L6zs}|W2T&gm
z!-)t$fGQy)Rmkx3;cB+_$m8#&kKc3x_$v$IKrruCl0Z1?Kn|jB{(Ek68PIlDTy1+Q
z?qaW`5(%8~Z$C)Tg2OPFC7}u?HV6ZVnuFmaH20kl9QWakr`j3;_u;0bSp(b{Scnw}
zOSs%W#klpu_71=k!c-FUJ#p{oIFUR_CGrP=^a)s6IL?O(0-MYTpf7c;{2(y2$w%)7
zZ$G~HQN;xQ{@^<?;ycx`Kg6owwwGYnfBytG7QKrC^!I_b01%V>+46%1ai^pb|ERUk
zpNKx#|3}<=2Q|6({knI0A;2AaQ3$<?L69aTp@t%a-XT;0Q3ImV)P&x|P*i%CBB+R{
zG%@rlf+7mI6cx*|g3E${vhUU2y`E=3@4L^OIWy-^XZS-IVEkQtug?_*U|d+(#Jvyj
zcO5_+&<q{$TzueYqUdZw9NGcW7GCHxXS{VlU&=RtK2m>zjBp%5_Pq-~Dc{2PS;6rw
z0O}xQ-W&U`rJr0QGk=wzUOTz-3&s&9OcFBOxhBZ|o_9yKmId%FeXqR5SH<Ojy9Cr9
zTE}wMFWg#hxwYP~^}T6pz4giZg{}4WlN%kC8#fMZbUAGFNN+UwZ`|72s5-sQmEIgN
z*%&g}Xxq6tT)BDa^yY;0k2@wm#_nw1J@jMZ^pE>n4x0m&KOXP=@$|`$XInp(w>Gce
z;(Nm3e>(m1!>wOs@4}YITT3KS<vheuIszJN;++O|uONVcF<&TDNmy^BQUl;=yn=M*
zD903$1u8g2GBg7RGQ|`OQo?3rhf;RaB7(#6O~*3%cg81r$Wi4pRBflWWjfZ`=NkHl
zZq8Tj8>*&A2MVn_2U*qPI3MIMv_Exjay@MsQt~;%xt^{f;``=a)16C<hJ0b~>k)G`
zyIbt?<=|sJT`9n$p;Gsce!WoJ1+~p%h0&kND{WaOb}0SGgKhraN;aASdvGpD5{1>z
zZ~L<Ci<yYT0zY0=Ly{f<?1l*!Yhqa2C68{soK(H^h<3_=avC@ne(%G@(rX8WcM!m^
znOduCVC>wt&|enfveoWMx07>=zlKQf7+tcjV8yR~ym%67yZHTx|N8!yTj|pNKcTkE
z`zMvsT)2;c>}GZq0@tl5*GfU~n?oVs4FOcKO=ER^eiR{((CSOWr3u;aHNV^SQ0FSL
zXn$^AeZI}4_(e2AeY7@Bpq@;*{);+&ujM>Jxq4_D?+Q#*I<RmRFQh|7p=fF9pYUou
zGcQwp@H5NBq7|!y1>ud!?+sKhCRU3npD!COH63l0y^e7q$w}?K+ZQkqPNyB-3y-Y3
zYQN{>pq7Ktx8<u2CR=~BUCzt^+qTv=?wG(tgWDagq*H}7J(;i(F=nGUhK2v}iOUg6
zDo!z*2t*Kzoa;2rg#{a<FcPjzAhp0Na0iU`Faq~7-!S%b^@E3mBGR0ve(^JbDC26!
z>zEeOK!IZm<=#9k4GC-)61fsWbdVsv6m`LeKV<`#p3g0sVqYI626%-HiaW$+nqL>`
ziBgpG9{=$b75_dpg?@4irN>}n6gwDZ#Jw>yG||wGfOK5p`E8CGtiB?fcjA#)Ck^oa
z0AOQuUcfb?@hK*JvO1M*3%pL-9w>+<u?+`t!zGNQCbaa?hga&;?j?G3zKDpJM+5es
zmUdiM^J6I#ijo2r!iBb?apyS}^wy+sb0-z~;(hq<nt)8F{mU@{{5(=5#^v>0VKl2}
ziZ380vjNjq8HohCByl$wx3<uR%s$MmRl5GVZ7erkbYIVEx<f`sf7a=yks_{gG3E-N
z^^3__8yZg)TF_qqMY@VHj8f(m!I>%PHm-hAc3=uNG>5czxOo;C@i2`bT^KSa=q;N$
zCnD4nIauJ^BIZ<(kUnD}W=_wz(&bwvswlJzPc<)k;W$0?s~STxK`gYxTIrB4fITk;
z4JHf<zrp?9cKLW~YiU66jBV7&7KQ=v46;XIRe_ayX)>yym{X4F;o5cjE7Pxt{H7$4
z<tj@ZW*=?~-~{5Ybo%aY>C-BEpR><6c`sb&VV_Fll0aFN#lun2-EuRns4nFcU4WG(
z8kr>7!+5M*_%yTmltZL4SVJy)${Qmux7|L0ecz8^j_9FCX3&Ne!PO-BT?pYvqt8A^
zrkd<JJCn2TQNd5}n{+B}`qZJ6T7PT?Pf!e3>=X&3q4VP0A&#tOX*MInG!!mv$0jUu
z(o_|he1K1XXdI0dkqF?0InM+uJCN@fn0^bLyApLpXJ)(#6+U8j3K)mYtz4?Y@FecX
zw*p+n=$V{ALxjkqQOlm;`$=ApKcVyzEpLprW*&=8Ca8kvIJ0MX0&;4^Iy+t<&o-H>
zS8vUfJQ!5`IXikwXLzRc34wvhg`EmBAK+V7PJaP+o-#3A2@)_w?WkJKj7q$O7JP_S
z{>02Y7#!}Sumal=K}Jb?02q<A?U8PUca9%Lh~5vYBc#^x>=VN!3ZwFcC9Y(P*aZ=r
zC>B~riTDt%t&W>mxV792!6odu=ws_4D@jMiQ~?HYfq}+5;dcr@DioKR2&JbQ%(4z>
zMJ<^}IEgA{9e*gN{dGEBlL4qudar7I;aIr6)lZdt^c?S8WXkWtNuLjX33FeeMo6`~
zMGd6^{=EBT8m3Rx_C@OCiJ`z(g%2KZ(R<><pd9t$wmvT^|3TC{9y*9KdSuqR^>kbU
z?+1OS8dBP3!`Xr23FV^X5xWCF)Wfc}yNO?M^{g|x7&el+aOdpVYqhTL_q$7a&(F<W
zZx_B8?)=tk;nUoWh93vQd?kGz3b@~>KF)eN*QmUua=-JAFGo3d3AJ-u!0FsJ#9Nmj
zRz7YSqep@9F{`qql({{)*L{ei4HCbVJOJ{vDG9=@zpSYOH$R@ic_dK$QIELz&p$r$
zzHBa$#IB(^lvWttX9;%oSl^;A^CXdggLR+d5_+M3%F+`2kbCduft?wWKK?vcbqA$1
zG&8L>1BA{M4Jq2MW?QR26Rs2+)*g<^K1_Hn(fx2(_3>(s_oL@h7|-GN@3+|eOZ~Tg
zQXh;t*iU1~T=JeZ23&+2&0}{o$55ycMp*d-C2!cc!liNl>#SlWR<h=~?~`E_tkQ&#
zX}zn(Fpr~JXP-uf@??l(qBN+bLyNDBZhfC(DaMpMw|l+k9P7@36Q9rBk9=ij)pa-R
z=iy?R17W+o4eqfuv}^a=4mYp$yj?T(TfMkZxa*DeiOQp2&O2TV*V}0@7p!r(#^Lx|
z7u&9>p0C<fhm2CKNo>9mOP%c{JRzaFdvaC8`cZXI+r@ox;lY1yyI3CUy1(O~h~DBa
zACG<j*JP8ozk?=PhmZCC@&k7K+u{@6f^U*rGpmP^ME_{JY@3HcGqjJM@~6iRDj2UK
zc9%U99f=*@-5ZtYy}2~L6gz5R9G!pi-g5=3xN+Cs=(BHMETbL-OoSL8F1fe)Vr!0i
z8(I~qIK25XhsX3zs&P!sZ=0{Of8*k^dSmK!jh3yB#m}BM{?aJPe&aq8KUZuFTs-#6
zTYpT#!y)6NZRdV@x6dkJ;g7b9ujWWc_RU|6k9Gakc9BNIZ~onO`FNB;_`B`0mN!uj
zwOx9qzDq%E7r&R7#v3pG&$dg0)$up~x$Sb~)>gvf|Gw>#e&X}_%GFed|7yED{l@yE
z?J{I?;?ub&o3E@+uHV0P;_HnkKmM)l^5xdapWmKrZDF{85EokVgllsV=3Jx;7X?jm
z{#)B+kV}~5@-B1vK6C%Q?c&lW9NZ@o(+Az8iWT;W*Y*8-+XdNA66%+c@0Zo?mox8|
z|Fi89)321$uUy!#QrEBA{zuzowtvTRzsB!vmjSZSfTsKa6mrorAJBFg*xDTo#asq-
zQwH=32lVR(4B7|w3=SAZ8pqK)4^0o4AO|VtR7vn(+b%JKRw;wDLi6|Cm#hnW{aOd@
zW(W7?+_ZU@ja?d~LrE9;At&u2=NxnKhb&$W%q3>XJ!QzFaLBW6$g6$GdvM5S_TSnr
z!-3kvK~USpWjG{wI5cK>U&?S;;c$4}a76p?{=wnM+2I4r!v{YPA3}~Wg+`*}N20Yy
z4x5j}xQrYL9yuB_ax7&ews0h_ZX~{aBw=tQadzbR^2mwLBPWrgETK`h{AiN)XtMce
zipywf@Mu~L?Q3lcZ`^2R-RM?U`)KyyXwK~DspZk!&!b5Fq;4kb^kBz+l66*XYIkc&
zL7|=>W2~Mh{gWiCxNfYZeXMkFtZa6ye0i+m^H?Qvyh>=inlSF4g5f8P*SU<J4<4_N
z8E=>zYnezNz*^&w$+aotEwkenm&Y$HkNNf3)O{YmB0tflJyC(QZ84m<7Cdo%cD!B4
z_D11EXPs?(Vv$^<4VOE?9kpfR$1c2^;3G_Q$xrsnPqri3So-8p@Z@mJ<VecoXyN2o
z-Q;-t<iz0Q<m}|+XN$N-)*a;SX`$OQ^0)75-@a#ld)DRl{ovbkF}EKi?)5hZ1gmZ@
zwBKGFy!~kQ_Akq~AAi2>_yjq%BsBFDdY*0$`BA2pU8Y_HPrZzpdX+Nux^U{(x~VrV
z_C2jr?`Ef7CXRjhJZ14H{iD#Gq2`oZ&FQN?z0T7ezqOlx>A88v{0=JWjsXGtPqP7f
zYyEX)6cJptKcwalQNI#e!i3a%$l-@H`^b<=$mEBVe&_}%BDfMN@IW_6Zl-C_Rg#*L
zBXq;Atmpt;tRL7{=WUv|^#D+mvxV-640L_;w0z}B_O6sH2g8iefU_oh7*GReYYBDc
zOojAzTTi#6QOpFI-Vx5};_#qKt(~4eZn+-RT#B*3x{Blekc!fh8cVGlXX7kcX%{V(
z06mSM^wcvni;%S`43zQFBwLe6=3Bo2+UmYOo=4PF>^JVfUfdG&_Kb3JIB+VbC^MsQ
zYk@yBh;46A@wLi;PT)OE&Ul!da;BuuG-DxO-9{&GuR)=MUhz9Fu=Nn28>v%`gN+UR
zQV){17U57<$j11XriRDy#8g+O!;iYjt0VBYBQiJ2)U~y33ku4uXa)?cvkv-c%8GV7
z)vcXO5`y<0@big}45>L1#_%&c>tK8E*wIW!ljLY-=ImvGsx;co3OR4rTn1gs)Wprw
zY~RTUt-^SpYv;tHeKq?k@I~<yPJ*$UQR&KUWebgp<t{*1+heD?ivc;{-WA24_u!g4
zJOcJA%91>9Ra*@<8ZHm$+u518I)_tq_U|IQ*4MYl$yr4NSO3x}p{?m&Sy><AU+eCY
z)|9X5V5Vztb~1>On4Fa9XW{E=oaJbkXKw0ewp+VAMLvSTu-7@0n2;Sp54qUV8XuPx
z;T#$hMDa4;zn604<i32?KGN+Lg|bAx;*;uk+ca~cMCv(CfdL1?gG(mP!_OQ)*q9rd
zA1m+Xm=_k*km%!`8l_;XS6O;|kBLU<`n2HIg1oP}|JEY!i6AQ)#oL{FCM4i&q^ERg
z^6{-rzNC=AXE%V9P{;B_r)=htI6t?ngSIp?pXyW(13lM{ieoRkfq`0&_d`6_%M65s
zbtW${3f%71_`S%m8-tG4*ro%iuAL|2D&zNF3DPao*D|8*jI}WLI%Iv`Ni)qv<shAI
z7G_)>>z*4+>B#oK6do4u>Ol8!@$&L^IJl?z-ou5io}QfKk^k|^NN6k!*-ES(`43k{
zz)`HcoFGeL7b2?vA7(?lvRyg66PM^N+c48WueJHpY>?lb56cHt<}Nb^vVM2|=Zk^6
z%Ae!^*x`IWUcTpWx)Xah?rz;*X2WUuT1BPBo+QEFo&PBBQ@g^WZv#tCdk1s1_CKEN
zJZw|G9cTH~u1nj^x!(CV!YT0Tn+GP=D?1R~M_uYJ9caE@*L~yAjfB+?Vc)tt4kZp3
zm<*kA`@{J!9c*&#`ttVS)&K1L_ukxq%!Y}|-`hLCJO5Aa{OgqwR<UvEPqSfu2K|@W
zAnca(-(DF#`-j<JekAFCn+@_Og$TcjVk{531?TV3hXzO_f&m49&_iNV+-;V)JOEQ4
zL_n9HT!fGz0F8Ik$0&I@b>EZDxmSoQQ3IXyl@Np+73vuwy<$bc9uDr45GI({Q$q12
zV9Ch}91G2FNNzw7f<dJa=+Jt)GMrhA4v}bl@fvZ)rV0k+dwJ2%`^p-qq6B)jIQ0cW
zE}U09nIdDU)L5Mo`sH3Jq`KKn0q=LFBdUe(E>FnLwzS^4ByoUhi?;5&cE6(VqBkG(
z^WAargxW#&QvsKQ*^lutm#Bs-OQLdwiyY3moijYF9^R*tdA-7`wmW-d=QqwZ@|{<k
z>3S|AgaM*_1nyq{)jUVxn%G4iW;51tX@J7UFSmB0<1)#kLifpFA71>?^eFKfaJn0F
zaUyzBcpjke5S}JF3IbIm&K+J~QiK5pmq_f_+Q_(!CtC%_n7#z%d8j_hGhk2QHkaMh
z{iJp^)5G%Se1Io{yxUAvDJ7{ubiXQn9)JE6sNjZK*iB`M#vC)vl;1MtJVBh{{WdQ&
zws(321IxW(_D-ly%OU}K*jPD^TwSH`S@9C@YA=+wQ=T<)V=TS~GdifB!MZrp?L69@
z)QkrE(?<A<xtwvJPJ{E(oX17k^aFYMDngmRZqEqv>51ugT<LbcXATB2&@YpSJ$%4r
z!I+zO95Md%kMsTPyglt&g}SCM>mJ8jP(+a{2KaXWnO9`vU#5A;x;yd=S?jk?nm?$0
z_zWQRCh4iOcCLAuYY@5Y(aXCq;aTsorpYPVQ>2{O^4rLM>}&CqZI6E=AuB_7VS9Py
zd`ckyvaN4yHJS8+<x6dA0JZgyaC9-t;^((KZSHdte@l_+)@v)-jos$kU;s<cqs;(c
z)UxgUy-G@~h#s))K++tPdfAR;N$bdGfS+q9gIE@iPl}Y`%KS&>X!5VA7ZF0ZMJk>K
z>S+ufNSDmm&SPr9rVnTDQ>Gzc9IATX?Hqs!Hx*!GQ$FX)*a}GkI<dr$zU2HJGBw#b
z9UR=dr_xZD&SLF`aq{TQ5lp6)XgE}C$d}*mS(m|U<diEy&nLa0ZI|U~oA5YWd)mmB
zrg2Z?w6Bi*Ie2yLT3r~2Cp1z<(?`aX<z_f^?bBIQfYqu%|1D7oB<hlS29jPis>wH4
z47Ao$m5KIARflCtBJ+McgXYb4$=g2`YM_kY*aBT8mVJC+6l0~pHa479ne$tP2}+e1
zW0z8SH+Xc<7i$hH^stNwYSzqVzNe<jOv+*7wS}=)L$X3k#aAJm5l@W>PT7I9XgBdP
zNAZF-(urhXF5X`#>TG3khg5kX1GyrmW$&j_uL0#3x99J`MA|x273P1~2sEA<pKZWE
z!#D{B=24!mx;!D7-_kzcFX&He4n<je-WzxOt>xOqo}^}<Bgtj!Wrr@s-fs3=wHaRj
zEG(O>Jt`;p=|Q?7`7BoDou6oPer6l8939dUymJ?|$>k{N+>i}JI=W|Uigu-f_o7Sa
zcTTIU^3|H(&4!7Exh^+_bAYLnzpeL^Ejk?4VL`2lm{@$!z69Tq(NAifUwn3S7$?o5
zXkT(PeQt103*_|e<dSn<8lSUbP#j{Ui5aHyNd*sh5BZbm1e#b7{)zDAc){9~D1gN~
z)e4J!VEg2B%u^+ho+i6aLLHg=c8kg8YIeN!1tj$}z>K8rvYI?^r966QN!fy-t!a^V
z1AY8IKOT2)dzz;Q>)fS`iqf)s)}Z}~B*hv)X)x1>=hlXtSJ}Lw?*hdZ*M{{Vv%#_d
z^7g;XhWUFzNj@-H^X-uH-xJin>-!izx2>?j?uDxN_i>NmX0l%23k_+~1jBgrBbe{F
z{g~dQjEYvt)t21da>ZMugJ$n@?^9ptbbHDNl^-t3Hsr`ZDYmvcO6UdGUztjl+(>-<
zz+yA;_3viGPJ0$gac{UE1u`4lGDdfuB3bS+7bLG_-#9Bje3UOZInZaoKx*VyFq0!s
zL{nN&Z6o#a@^e=!GTv+0j<~(OKS#+MVeqzffoooEx*(0917m3k1|z_y`Qfg*ptH0j
z^+-9*#=HMA1;ItC=vM~eOc(YS*vd*D{%ZeK540ukkzb`>?bQ5yzk5C8Ax>Pm`qk~a
zyrxCja#zo5FDDLdEALRioQvqw{QRM+@Gg=3RM}d-cV!cJ`s|aU^|sFx(1`h*7e13b
zYT*}^&NP(4ZGkg86rcT?Up67QL^d1yV(_xA)mx@yIt6Z;k7K9EZF4IgF+}f*NfA2!
za{X7X9KJ>-4XhTP6tSQ|JB{90b8MpWsA2HIyo-_w(zKKOA@(p9{v{j`Y}7a9g8`3$
zMY$W(xE;`>V={BQ?6H%X#sJ8Z{jQw!4V!RmYN$;>ECE`#9-W6V(vE*NBU#dDYQRb?
zdz&xm%;`khN;#)TZTTYx)=i=8jD4%#l!T)GFwJ7EC9ORrox`w9&~2yF2YWxu)lezU
zjy%t_g9Bu(6R9ux^2QNMUqhQPAG(83End_wSQV<W*Om8K*sV20XSYf0J<h_ulcb+T
zhFerlB`3c1lk7Lp$jtCo;=5U2Nq9IC*k#W#stT1462oe!-#L-QEZ=mjKJn(kiI>$!
zft8~?QHRB54g+)^p!FnDPvbk{_)ZxlCJ%{*v98|$#q_}KVr>3=^r0az;Z@v?737YY
zlca}-9xH+oD@mzWlF*KVB3vFaGnqUM;K;xOVf9^&E++rc`ByeS{Stlcg%k2yN(~CX
zpTy(CMRkXyw%<oOSK;>p7~+f6i|3KQEb)X*!$ZQ-nqR=~ulU(bryVTv(juW4Ts-vu
z{v%>uQY)~HBWOteFF3<k1b{h8REn~v6d3_*aS37MjO-4NV_5WMG8U5m<If|XaBx@1
z=_QR`Ad9yaqWql9YCU%;5G75<G!$jkSm3$$;Z@k|3Rgr&M)vhToc|5BbuZ-n>*Wl3
z<P68=j27jLcjQby%$ZvIdxz8G)LiU8b~x95cmAL0<t}^VzKqR%U6lK#Blq3I+z)HH
zD`KZVLG2xn(_dpxuN9qM?>N2r@bu6B2kjk^xID4qJc-V{ZS#3j-}6Y~`Lg=?@}BvM
zarw%{`Kq1y>ht*;kn=BIuuK1ccK*k<?>$x+j>@s|l(Zi%fXsihe5TX9$d=m~kH4LN
z<TF5f2^;w9nF=am+X}jijQ(zQHpEfcSd6I6!RNISyy)k2i}&X|1-7lAIDtg%74#Sj
zCQE{61AsmW%%&81h~u51->FT*!XLnb;K2527*ri;W?^%2#S$w@r{`e_pNblvsR>RK
zQdqD61~!d?qS8@76~cwW`*@|GW*IyH2uCsCF(6#=_cIrmdn=L#ojQORUub_g4kgG?
zOqfU8w!-)*$O9lg;geDZ1#xs5Axp=c<e=P`7#9$2x;2gU<e-*VXPhv?LKL_q6MmKn
zuVEq#+Ijp)7!L~k3<KxKglo3K31pbZG+t>5rNRYD>Bs_-8j8*1T7}4FB1bux6o7Dz
zj!7gT^;s|~_bgQtX2HOVx1u0CN~gf|RuIt)<ggnqqzb1%M{6uO$xz_pD{$x%MTN_&
zKv6|j<4j3#0}etCN*$5mRsg_S!6i;(U&R%ah!O=p2?;QedaZC3Ixc~UaBoGKG2yx(
z^tZ)YFtHMJqz1iMg9G2mh0#f%#}d$B3g&Qd5~^?>4knO}x=BHq0_eLGXcif66L-d3
z6Bfck<bVi|61d(LH&PcsY0%M;$FO{@s7Ea5QwY;+t=D8$%8+5@)?h9Z<JAfnad<4U
zU^l9;4gjyiG?ueevJEe!*b3ucL1b`YW)xV#65fo0OlQD>=YZKX%AbPtT|w;Rw5XAh
zB@`71kL0dkyf}#LB~0K-i4~=&0^oVdMDmcEDUPs0CuKf5tO0Jd>;>KmQY$qD4|&2)
zkm34tRB97K5)T-W8sY4uXA7cyRcO{ULaY^=3Y}kVTxRE?+gFeQAoBZ#)*LEAoQZdv
zP83~C6lfMxV6i0sf861WBA&M-o?-rDhtoI-#*j=-l<Y`S6Pk}GwAN3-bN<@l%-!hV
zNOtD$=`8f_Je$y2RN8sYw(-;|0a)r(fOR<sz=CDEQ2o$MIh;fWn!3B1C%RfCyW943
zw|jSAPw4I_?e6OC?pf^a-RN%LAoNtp<<3MK5+kUgFgOV~*xEDswr5)MCKTJ5^}acm
zaPwj5&4uopj}~t}&c0c+#ek{Pg=4Y>UhoJGmIm>H0B>vW+lgKnc<a-iTc5peeNFgB
zduQVou#Nkz87{)Y{KoFV%p~z#iM|s8Tixh||D(OLYRi4TD0z^SD$>{Kj0)l-+!Fh{
zz4N8H?{ziTL8l)Yo&72~p!!F9N6e0k?(xI=kdP|_<dp#=#58>dDe8mNG62W;eTviK
z(V$(+pyRe7d-Xy3=Ai55fP3VSQ_heJ1jcfPJnaDQmLcECA;#oTP~vcC8Nf^G{i#eq
zk)a*Vk)w$tC?*h}2ps7dNwgbDh#X-PMw1OkQX@y>AC07MC630Gji$UC%^-}O+8oKV
z8!Lz$%jp>{i5x3v8O`q*DI*d3R!*bo<MoN-jb-Cd*{UT6Xm~V!DRTVc=J-|hiEBRN
zH+sf92@~y;&_&C{m7Iz0cN5p`Ci^2NyS72Bak9r}lDj!Mlmjd<qknb)bBVVfmfc?H
zx&7$T?Z=z9m$pqkGn{&82reg1z3#c4yy*QiOBm<v|FK7GH8JGa3h}o{w{M$*-_?n%
zRzWvWfgkTgQn&&eiC`SFjyLK~y1oFHL`2+_ou-KJ7zupZCvoHkD0)#Ki6Okz5-XH<
z<Z=Le?n>-%9-(B0C$}0KnCFY7@&-G0BoWbyGI!Zdt2oRR0$;#AJ~lxb7K3{)sIeCm
zzb(q)kWn|qFTawKKOhu0J(abJS?%Mp+0$dNdtFhj+V91cjY#~wGG@Hnop_0E$HAZj
zAny*)g(UyaX;Bz}1Wx{o%m~3oXh{Xq5+S7#auOk;2+4{6)!+F;W^{)<M+iJBE80U4
z5}FW&2qa`XLXsn-Jwn1Gq&GsgqoRTx1R)_N35~Kqo+BhPLQqIi&Q4L*5fULG!x2J}
zDhhPSb4*J;qork2R8*OrRb*kKrLP$%Cua@Kx6o|$pw*UL>Yk9FD6e3pt?DoS`<e?y
zQOO1h<#<zbOFVxGGAQFX&p=|MD<y5WhA$*SI#N$4tJs>G>p(i8vDQ9)wU9!$xxEI7
z$IPx-?v5doZES1}eY|5V^`ji@&8mG~SZgFW(5d!XCyzT_qnJ_2ie7={XEW``GTnP!
z3^T)xY7=d4BwG(Ktn%pe2&&G0Ya2sIdrUCuHBma0=`x%_n<(>tK$6<4ujf(dJCbZX
z>S><tqLa}S^v>1g;MRS(jq%ZNo6<n-GDvb{nq5#+a5;Xg3>qhG^jSIMGh?C==|)e5
zqCaVVb<s|lhYqE%={IAnFIs5C=xTfIP;<7~eI_Czu)^cHkce)s&Ak}=W=N}qB*z$E
zcCt$|R7!HEJ8A85f@I9)9=;mJV?X1wL4onmlqbb7V4JM5qob7@IcIAD=WgR2L62wJ
zoL|3#*uC4<$||rbNwWIX?w|lSU(0>rVaMa+vyL3eIJmFc)YKocDM#verKiL(4KB}K
z5ria44_BWZYW6j?=Y>Tb1DrzaY$F0}_j`Hog}lfoJz5T`sYec+zgVEW^#o~TOiqhb
z`!Iy%<<o*%MGiDOKhIQ(iQkp7bap}|R1P{*SPreb#_rRD?8UpSI%gATQ%!<_bd^&<
zmpIAQkUN>}ef7kNJV=4ei`^a*b!7IzTx}NpdYPuBd3dDzu>|kD;{katZuS%-H^V*d
z<`lQya>?FG%e{sgy7Ix^Zn=@c<<}y9ydP6GAnP3u^n`TCq-2hsp~>R%yMtaD<5N?R
z2+7GyhqOmXb&Loqtvs6v(a!%7GxEEJxlpr&0AV;aaGP~o-B^LL^97%=w(}F`$U);}
z`d2e8+4{(Mg7tq5sQfW4ib<Nh5?WQl-c#@wW`w3ijhgak{f*v#VaBUrn3tOpF^&s2
zm=I>P)eRL)I>wW9@psI4w(BSUr#Gc(l&ypLb6RwWl*wvGEu~UQ)1`mMj8|XPkPb;a
z+UWcv@vS9vihQ|G@<PzWS+%h12a-s>PafZfFk`#qku51c?ha@`W#2)erX;6Nucm8l
zN5ta)Utq>HN#n!UWS7|gg&9M+hK;_UfLqv8I?+!LOqGCSMvC}}f0r5mi5dSMP?3vA
z{#5>JK;`QXcCZ(E{64?iwzIKG6dMVlzI;`SOocdSI6Z{wez56op==C}g2S+x)36A9
zAvE^12~bLbNlJrRgcQAj5)CKqt0WYEPc9~80`PL#m13X-si4ZKCF*5y>Q3X4@bgTm
zl<;~0ROJ*O$YQ?O#&h($LY{J6R=;g?mS;uNrQxk{Qj6P%#$@V60gDuOzb27EqQDQY
z`vm1*RHunvf$eHGH#O8aSJ6=EhZnD}cCnpjMpe!11V|AO15)DNQM`j4-<nGj<TU`v
zI$MqiAeKN!QVFJ<?w!hgDP8!^J)B#}i?*OBJhf>j^{b9HR$xmfarz>UD1pqyQYTv}
z8}Qa-QzAX_5LJqQHe^J=Ga!|+Cz8q$UV<|R#{^!;;{i%z&lQTQTzjejygX6MjC?5X
zH}eH_WDrOG2h7aE5S(rAf&WNKGd+k!qNGzu=8>ic0kvuHxz6%#(?n(D&_l#+CQ>Lt
zU{D7*bjWC00G`>GE{Z3r^>23(+(PP514*BcnQC;9IIXM)JHW^Ma)m7uk%unQgwL$*
zJwQ!EfFVnm9alyu6#yxf;(W+Q$Flk~A7#6*p7zj{3V%CrJF@(-HsEjWqJ7I?mn!`d
zZ(sdq^I44m&s9uRpoM7Jw!#Fe(YBaXTm%0z*aysgR^}UI$N`Ql(4s)^uM{oZJqe##
z9r_L6YJT|!$ipboZW|Q3eFb9LKyZo2<;M?TN&5LC=ANY3%Zac^sBA6TYx#(M0$$v=
zecVc!Et7(I$KAdGtQgPS&L(*-dGkq7byHU&Nw?*&KUx9cuz1Sh^ls56Y<~Y5aT!E)
z!h~X%nj|QFm{?`(m92^qo$Ug3L~y?RbQL;JV3b0#?WVmP)dBS~2r?A{$(uej&RgNS
zkcuQk-}*j|#w-bI2t7{|8RF?4M1s@neEIq_oL36fATr>oS;h+^{Ez-!!)@@MNRI{`
z0Se(pfxkrY5<*K81oi;{tVfqafHU$=$zvA?aEx8-w9ny|N$TJO%!Y6ZRJEkpKXkvA
z@{S#iS%oWL1je-J2NB7?RZ@H0bb@Y1lO(lA#Wmcn=Tyt&^En1~L>?g;xuhKQR(ooS
z4hP{(qKw;XwwN7`r6jU^1YZ2iv@vx=8qPZEu$hDze87p6sw2+Gc~E;$EaDP~9dl0N
zXSQxxvYEfdx3)_Yqn{<KkOYBQA)0VR20eB3suREpF^jH2J!ERh%*bJ-c%rourOeAv
z)?z>!!{jKuir87IVCGU{3z%O%g2}5~AGX?YOkg>${vB0d*PB*~V-u~nfToAsHJe!k
zOXuxNvc}wPml!`ql1i<i;`6TExKGAZOnOim4^06sDZgx~MhUaaP0cUbry+<2!+g35
z|M@O7{Jz*T?N?N$>;0@UuKB%;FIxOHc07*iqh|gO+=0(Kd04JAuP1%8IToZ#@R?dS
zLHN|MIsqBKB3Q>-eg3gW)e&@V1OG#|OEU~c_$23J`i8_gtHMs;cT_x`WCJd3m8Sr-
z7Uxl^yVQB%K{Pxs)eF08cN9)nsU?IaiO)}d{pA9ItB`SptF#kqYTg0Qd~6AoYuM_?
zI%{56nLhk=(K|pCm{7pVc_eryi@gmzw04Q=)G49}XA$8uF!d;`^V^rAGO_RACkEuZ
zO=E753|Nf#MS9w2Df!NZN3NGaft!dY-vV5@hkCHla8&YDl0@$cB_4bh{8LC{e1)F?
z-&4rBrY7?<UeomG#HADZ?@EMJc9<F-RmkM4JGI+5BL`*ryi#ahrl^gPD=O#ha<i`e
z>lfS4pOp(<2R4l@+DtiJofJ?P91@1Zu2O6Q1YDW=3JyE0OYXdTp~e4dD^HpITj>s=
zv^2V<-RS|myI|p~_O$@omxuVs2HAbpEpfUWU)+1;wh-NquWFR~G+CO@o@6YaRnSVn
ziQiM?%myw`V~f=R^Ea<=Ya1kKS%;Y$?iFyelAqz#FK>o%(^A*;WU{d3RK`WnR~lJd
zDl+PIM1|;QCI3LA=}40}B0ObMBEf8a+03pf!qm8K0dM{OD(+c?O{kabZK(_!6;tbj
z^&*Sqei`k&4>_i~%XiVM6=%-<A|APMopjvoot^wmFzE0e<%WZ_^W6r-6S~2R1aZBa
zcLc)Pw-w4hO`{3WZgbxId6W7SX~Vp-5y?9@pRZl1a|A2;;-oE>Nm~w`<L(tT%2zjE
zJZ8%XQFwnVS=@Z7cc*h|Cg@YS(rasD{;uhC`_DY@YhKeFy6&Ev`pow<iPRF-HM@QL
z{U+}pZ#+z9ZeE@G(z)FImhsns$^+%4(BB7Cq(l|2{&?>cl`y$vf2`O1xZ*<NzYVCw
zqV%tl(syps9`Ua2SMHU6{d@xpv=Wll2c!j0Bw8eOehVfKkm9B{&BB!6od+&_9Mc<p
zW#KOneD~wi2#4dZac%K){wab&4GC{}oi=Wk#wmn;+4#V7H(}8s%VWh7n{w#D*QfU$
zuL<ejd|YnAd1kh?4$m`My>jPAQv0)wr9-H#>28M;0B33Q#Yt?L_}Zw|xX}-M{)upV
zvAna}>snVXC(Px>+4CK}K++S5`o8a|7Be_a0UUP*x3}XEVlgTVf!^Wp_k#P8GJAPP
zWly>Z5n=__+(GcD8Cr%V+Clo54pQbsi;sbxbYmh7Jhu|?Qzr><N-8Dp%1bAsqx^tY
zq>EzmdCS8IDFWKBldm@fnM2c}Vsft;d{{Q0{p%EKng9__aDhT^)AD;{;ST9M4zC2R
zqW~8s3K@k8#HM*rQK3a?NOoH2Xc~c?c83H;W~4D2qa*baknHq5{VB**Au5ay;h5$!
zgDWS2nv4uI5dr0X(mgVGpa>)~Dgz*80!tYxy66&?{2MY@4**jzV%$D~SpX<k2Hm-7
z7Ic9oY$j1Aa}EG@kic^Q4xWb&Cuinifg7)rIAHc%RV1=6%ZbB#ts|SPi>Aq*<gdnU
z1`9~dFcEoJye8Bu=RrJ0KI{N{miV!-%;Cmtd{p*10AO=5g?eBUWk1yFt0rewwdRht
zg3rUikFlAya2|L7&-LlliX@N_yHB1-h<=?mrw6W4_?whLoIbd|#Jje{dnOj7T?O+1
zz>x&zO~bE<;kaQShl>dU(-AXyXc@jpCKTAQn4@QmyY265h#t+5hh|BAU#H{Ph=naK
zywy<vlIEt@KokzRO9OdSz;X`u1vl$KWA>NPLb&7pZZX92H0XxJ2z&1TO$@=J=i#V1
zuHoPnY_w*${LdN$AkJ?rET$;KX}}WK=^$TtAv%B`;mC)bfqRReMN#t+GMP_2z~92a
z#A1-G0(w`S<Iz29(FSX6<tq~qg3mL{mv|mgz@z%0tS3nIBo?%0+fNr`VOW672bbY%
zR|bo5K)nihCF2a7%IBtyLlN;1X=?AxRck1^^eh@B6S`j?Y-EAwJV8!aCcL`z2#&~N
z5^yuQYyf~_L#r9!J#p+vD~~3rw0flsS}Da>7fPp>nQrZhL&G=}8Q${PygrXYp}q>V
zX8GMrP&u;*MXd~IDqPYBuZW>E8I|fv6=t#sBn5c9EZ6`5fno?{Yr&>p%MnBrxL)-J
zl0j8L(4bn-rdnLJTK!z5Rlcewtim1)tEGW}mq5@`^@DSnHaApXdIG8JvyQO>CrBqg
zFl%+Q<UW&y;Z;gnUIIVXYE2F5%)RO?<LhW8bv9jfb_;d(>veRA^QJWj1B$nk!O`U3
z6y3Yd`z)OITR+dhi~5V!2Yc1a-%Sq9IucY;Z}EypbFiK%(ZGM#CfcjvXnaF#iAY#U
zL*n?6YcmZjiN+*@#uTr{wD`u1lE$pAM(B;$n7iJ{k!Z>{Xe#t-Ivd|qRMJ$^)l~Lx
zxu5t8jU^W@bX{m!xNvFxLaRh`n?ZBCSM&Aw=8lr)uCC^uh34M%X0Aj_zd_3&l>3Qq
z87*m<TP^rK_p{zIEphSB+|OM6#fK#q7rHJ!TDbUl{o>M}xgW1fFXR8p{k&Va^x^-^
z{bb2c{$F!Hw#Pn@|0VY`CSd~r8B(^Q%W*`~p0>8AwrB>Zmfhw?tx!m?KoGBLO@P#`
zV6c{TRijy$Iu0ItRtt}6+aoFRV~xeH2TpOp+Y}`d(2j%gBLkps_^W26Lb9#!UEZMe
z{sN#CXT7KhU5@d{5U`HCL-cF3J~*NJI>5m0-Va73D4{g*J4(Ue?CVaBE*SPTxXg8Q
zUOPsn9bn!7=r#9QH>|7AR|;T&6(m~bM(%#%k?f8T830SYiYC^%?CB_6?5x=6tdi`i
zNs#<u&{dz%)mYkfp}VVPvFp;te~THpl0E%<dIr6Fq8+=2OMAw<dnOlqrZ)b<jN0s;
z**`EN#`M$zgc&z(F3n2zKHJl~?A`k^q4#xZ@0;%4cZ<CrHhNbi{}X21bK%4HTkw{P
zN?|gO7F$s2(yyy7;S9MZFS&}!(ko3p-k}vjnkO!_U*>HQlQAWFbO=lLFnOwuUaZO?
z2lQFy@uOhZa)$xUwmzvxy=22?1X=d|G^nNCyjxvXcM{Yu6ZygFv+Ww#`Dp-r2kzz!
z+SpydGY3`MxE6so?F}KWC^<-p{YD?MUc;?Mb$GpNK4UFyBz`5RN5I`qKz3v3MBh+}
z#6OmT;Q$U=?MnJ%wJRXdBOuVzpWzl5<P{L;9uVl|;c3qZ@MHvdFaq2?JRLkd_xdy3
zy?q?LeVm}%I_M(FpW*81MfdY}3kvoMgoaxk&3*k`JiQ!TT&>+b?7V&GUfzyw?zX`p
z-afw0e*UiR9(&!~?Vv+ES2r71H(NJ%8!vBqV34<mCmjMvPR^EY9=6UdRt|J?XBTTn
zCyTJ~fWRORXJ|0W!`{t(uZyb<#LRqrT^#6UKE93+lk@bl_wd>aowkLA2L=WEgoOGr
z0^I!k-F^L>Jv{9oO6TR{;OcJc<V<sMwM{-=%Zjg{J6bx>Ey5!L0|LE6_xbtyI|qmO
z`ZGNI{9Rn#?A$!|rktpCbh7gCb#ibthmaoK=`ZXDjgvtz&(oWplvt&twAazeOmnBF
zm9;^{{*ZlP{`<lLef``50-+CZ@?*FK1bBq*W2h=Q%FA0PCDz6t%YtCx$+!w=2n{+~
z{F4qsr;F+;PF~(lCt}N-Tr7`7rzy!fI67Ony6rVLU>fcUfjFY2S%3#MlS97;jd*R|
zh3TmUrP>Uib6>FD70b{qt@U~3qL)dt(~GuliZDD+H#zQaS_lC}@oh#_)u=MRd8(OF
zJnhDD$Ch16K6G-{_U(=#*5|TZhajMsOc{wY>MrmZOLpyqQbgyg$_opMqQdK2f>w<T
z{7j8Cua{`dwaacjLRTekA8$}d^R0h*lbDj6keyz9*fA^7H}6JA*VzQU+8mPr+JPen
z^IdJ+ysd)v(rC~=+4Sr^`rbnk4v9Jz;%`Qj4!NB?>X!@+jJeSF9*K$%q$?d`)<9$n
zN_IQYDd|iFH)m$F_epP$Bdk!V<B>*w9%-k2Z+JU-L39c_c5}Dfwa+P<Zg0hK*yrX%
z4|WX;52gh&jz@S#J33MPyyFJz{o?iou!HTO^GT++;y%Za2x#m%$RyZB$JZ;G?r7rS
z>=f_o0Rb&PUmIU9GZ$x1Z_h~RB#`N&voH8CG~D$+f-bQM#-snR6de7KYoQK-F6*oH
zw@dX7L#tg{&&n$PSPK64hR*+93jU*^^Y=a7)xTG}{sdh&{#@<)dnuUbKR0yl$DRG-
zp6>V6E@&xu?;opO&dq**tah~qO;r586uj8sSULfLuHRR?c%<$Br`4`K4t|gSrE7iY
z${mV6;up!mdsZi?8^~3qS%2`(iPWDm@}p+3XM>g0PrO(z``zwQ(L}rfsxn!~c!**1
z!8ewX798dAlp)xA<f)m=C6}5Y2^gm)3w3dgo<-J(siA1>(te(<Ebi>2Y6xd#+Hrh7
z3tETR_0#3h;@>MMr#g;3H($T61fDc=k{`){ABR&oSnJNELPBSwqbgd#DX&;EFH_ES
zEnr@Ono3(f4=sFoPRsf9sx(ld9=q?W6s~@jR}Nkimo`h1U3*rY2E^0PNLu8dH#4Ey
zOe=^gtkab-`fZ_f4qv#6d4*ve*385@kgl+;NuMKEf!|urqQptnsbpiu9GfW(>o`hN
zuWb8Uo0}rq_!eMO`|Vkv(SXwoT~xf0gF7a0YI&mq>6Hs7Z0@(+*C<v4=0sf7i?)~B
zPAkuPy;bSJowDKd2wqX8-$3)?vYLKV9jxj?z2C!;S&6QzvtG-Cv-*jrlIW-K`gZh|
z$HtL`H#K2BV5`vKFVCsmq<8dD-taQ#GoWBfR5rpW5NG<K1`lvwxNW;zV08Zxr|y`P
zeC1Vy=A*+@l%R{;33=y1Ez2;0L0kjR4&Uh!y>8_rrYbz2qs%mNV@XPR!8`H>h35C|
zHf1alF0^8Hx2fefkdeF125R2UOeh{`<EV%|-P#*y3V&-&e+2)2d-`sg$>2A~?B-tz
zEopp0-|e;De5)&kpUF^o3HREjZeb<aE<5!-PD5`_-DL1PCD24Z!balS2fcR%_l-8*
z$B*T1eCQE;VDpiS*}1tg*o@MS3l_axcGL7X^bU(VYNsW7L6qNdi_DXS?H02pG0nce
zocw(AbM=AC0@bjB%Rem(4&7f}U-=mPX%h46j=9a%R}P#n_|?l$y@5~#U}#*p#0m>*
zR|OXx<)RH%*kDc-Qi;~LoB@{;l^+vV9qr?b2aWEpRbj1Y{Q@P-<L~!W<K0L5MY>i}
z$vM@8eY63Ig_ShD$!fl1qXS>^E~QflHQ-h{ZBSNXHG^jN%u%*(P|+Yt=Hvcqof0O<
zFw{(6$dHK*yxa5g6kXDj@(g_nJFI3LoTH&$E6&Cao3s#R71pbfi))rrcdz8ePS#3!
zDv#WGPfQXtAYRAb)js)SHQ6-#8Fl5@C|uDrsA_tUqIV_Jh1P%4e*ZFZ)mbiqZ7OGQ
zuMT%36fB#uE!4v!fj0~RJ6~Se%jV~ki^K|Ek3}1_8(M29wAtpid^pP`)RWV#Cx<Br
z_G=Pt7t!=|pyJ>u^p(K4#HZOe>CbQuRVkDT4tP*Nz7#&AXsSGu6LnTgekW}dC6I5Q
z(jqAH-jHS}+7A~QOyLphQ=)mSY)xUtWo5mE#&)#9Sm6ZoN|EAMrbnq@n&O}YQpU<u
zKAsOc39Jza!Ag+uKxT!rJd8$z3Df|oe8FfOj>QM=x|=q;gwSAQ@QJYU2v~WvSqF_E
zu#zWiSOp`uX6z+CgQH0)_4~)GDDiR11q=l60>lb2VZd%uu&^aF!xhGH#VMPM!NoBE
z*NYRRog#_POS2FbAhb)#i^<@^3EEIGr;34q=c)Pf?7GWSSas=`a0Ut>yC-7-z;8`W
zRF>rq<hbzIdSLlXTiyAYOP7zlpzuSH=j|Z35!J~e+A~s$`~Y0heHJn20)o$F3DE3d
z!F84pv0I9RZC5N<*a&ZTd3h?yuZqgwb|D$d5&@(<ny5M}Y+M)&$o|5jXwY5cm~5ER
zL%`R83;XrW63m6cGUDk^k|LOrG^#FAr06hVq%dIDF+eE+_M+`;i{WD!fD`WuwDgmH
zASt{CyNp8sKpaPHHJzq|Hw2J<H=<ju&;SBqs0+wdvG4$N10b~2i4td_@r*m-!Lb7{
z7A%u@7m~Lf1_C5Nq=gIvlmWCO9d4$q&Otn4Tn8Efkyh?rj93-QPk9tBL;_?%7@*?8
z0xSVQWgGNIfP#d#vUy%pu*S+<7$G`ox8XcV3=2clsih!DjIBvwk56!BD_bwP3S&U0
z@MbLmKo5X-*BixQ$*=@3##j)Siks!Yh%qD>8q0PUuY%#kgmEelDFomV01YgmOh;Mp
z;T$+TW2uu}WhOWZu++6>cmmY#=n`c4&rbyxBQoJ;$kzFk*YPA#+CT!2>>L}qEfscc
zrWPImZ8DNcBT^YV_yU*wu_^OPG5~mK1@SVJ0SK|$2zIUTWF!S`y~f6rY^0%)o@fQ-
zV^kz5nYdYnaw(!<(O?h>tdS9V_!hej1o)s&lQY!2FXN))1cPDLls<vzX*hm!3GD{3
z044(gE-j(_ELvc093&`KhY8=p_EXV&e#tAXLa@ZR{MsB~8yP_8d9cwX`%y^jAPyI$
z%NLf57C|ylQdL|$lL-*3C<qIHg4;IDl7*Z>S6T*63ScS8Gf=u*F1~_$2q>!Niy<Kd
ze{$dKA@><xmBJbx45R}~2*4qPrpYJ3NDc!;_i!_8v4L|*oHL|FG1@cn=ry*UkUUzC
z%P?B{z{XO>F;o_w0I=j&Vn`wk3hnmABq7=_uMjH0OH?4d0FP{ZqX+;}E3D}5D!8l%
zn+LtL!rsP3@RR#Q3^^?6BGMy6R~Xif<;;F31Z+2<;np=cc%bT$-%=B=0T+&(^nvMo
z)Y<|peLx9$B#e>{gEOmAY8OcuxF;9BtqO)IT53HACVWdU0k`?UP$nx#PhI%>tAlFH
zqli^Zz%266h}88ou$wASUKPYEgMv_wFc~0FVBy0@@BwUiwGZ5pA4yFj5cwc>hpSFP
z2OI$C+KB3;ekPwf7FgmW$+4Y?ORg{wMubk5bP{A3VAmYXZ)pDsO32*46g1mOkeh6r
z;huaSw)quK0X;FAFc<})K>;T3!vFxnGl1gKJ|q`bY6*(B!bl9bKotTF!r-k)1Ez;6
z2k}A#*aLc}E5H@Mf&65^WDQ=X1YbD^-%bbQz!L~f$XX|(gTC%#9|h4X_UI+xTsmSm
z3kJ`FiLU?(ttjZtqyr+$#Deya{g94uUIt7FL@)tBj+`QKE(-v$cGF0gLR2sZ#j7WE
z4dh3yvebw?0G-bf1(a9$PynDH4CLda;b(I0JOuB}F`zG-C3-BPng_EQiF|r0B^`W(
z%~jU)d#S{bB_#ozTue1nmX3I2&K}SKUn_&V=?E+e&?OxqWq=Z(i$*J8!?Cv|!|*ql
za@<__D*WwdpPfwL%NjC#4Jp@Z|FsTbjV9_cfghjY6lmh2ifI5cB$<E=4si(s2t5q?
z@$iUD9LxuZ3FYQvs*oSI>JUnl;}Q(G?n?d%w>%vn@WNSE%u4oaYL1#CkDrV^;b|eV
zdM~|GSdoFacqM}7NhRnLy??dKt>yO%C;kNg(a;GO4r@Pq_iF6He>8LkukgptQ;IZ&
zqNlAA{%+_1v**mClGC7uj*3Xkbdik<jiW-rXceE0D?YXAP}EsmHeX!vy?7|ux=O#K
z&a<RGuH@Ft*~ZS2midxP-%DD>OWX8I+dWIK$CY*zmv(iQ_RN>|elO*Um;K(*@hlsL
zPGpM9#yiU<=gX$PmraY8-_<Xl^(>!@D}PvAzR+3zXukaM_wpt2if3E;70aF#FXJj+
z7gxOLtavwH@!@;Lig@KG{mRdtm0#m3*NQ9GJ1aNmD}R2k1SG29231I}Ds+4mwxkN*
zRYh2+;#;o*C8`Ass)f9&MdGW)N~$Hgs<$mvORZOvBx+<0YUI6Y6ys}@OKMcRYSb5M
zG}ddLM%iKVEXWZe$u6~eCA9`!wT26|#_P2di8=^$9qPlH$BRI$OS@W5B##f{NJ41x
zV54|!-Uv-qDf7tiqp0UyyM%5Pf_IqJ7qms<^##T_p!LG}Jy9~3nZ$q#^}6gLoF;$K
zJ$@&A!=64DQb1ieM7%BtTaPz{uQ&V)==%8oA?UhL8ol29PtY~q)iU{i16_5Vd!PLQ
zx(F9aPEhGm#AAr4`qytNZfSw}+5*3+62D1YUhlfRx$sxlTG5~pG0TsvE`C96t*>s~
zE|bF_(fareALS`@2Yux<>`Gd|6`Q_GT6I_8gRSPUwudrpJ+<f8&DvyOm){EhgMs|>
z*ym5D5W3=l-sWE>G0;05dbS^nItR&x&|@6(3nA_SkqSsLJP})d{8$OZOdv1<;Rw2;
z1w>9DrU79P2x~aI&>&_4kq`($Ko|r%`GM$%qmwxVKp=_&;gKCG&h8$z5dDC_2*fm;
zoUOFApviN4=oCm*(Fp<_5Ufy9uvb@dhB%C(Ed6&j;%)~WwzyK$AjSesl|%T&(a91L
z95?PDAWi}i7zoQixW?NoAG#$`RoyEqWv49fsH)-!;gR4F=%H=lV3_XX6{D-=3*DPI
z8)rk3qB|uA@)V)=uBtM9YY9!>X$8>_2$Cqt+e4n>kGn94x<D9YYe6tAwE$}HI2aUZ
zkv$A_eIa{t_bxYik^{xaA39(O-RBRH4M?VhSWQQnhOJIMWHc5PRePA6-L~CYTFQcI
z93(4CgG$HYLDj|v{$4KGYg4G*JA5?Nq1Y1SU%G6~1CVnG!5qk;Tp7VYo~4t+!Lrht
zw_G5KnV6MXxNE2Dk68pH7n0RHwiaQKNy)7sPBr1~wJAUDQ7TR_PGjzvy~Mjbpy%n%
zG}9=DJV<-vIM)7MFM2@>GapE5gse(0_t+QRfUDzS2oyl4NsvS7PR;r{3D?zzT0|b_
z;>8<I`wZ37(<36&BkUpBF)dOuF31cD5it*DEOzYp(|r^a(t_kjNSdsvxp3!_va#;|
zw<EHU3JC!mGoxerTE_2(@UG7L?J36~@zLMv>`o;gAGgzxUg>M@7ayAqNtS_h`A<`7
zkgB-YMS(m*ZFTd7YvLa!6f8~LAW0DdN^~<_NM2;vDf`)L?hmeD9!iKinhEKTkcJ2;
ziRCE@5W9d3NJx={m<Hq^LP{beAVNYUq%%UsAtXdXmSlf}4x~|bR2&U-(t%`01O2^_
z$Ou`IkjNNh8wM$lP5HYRz6l}pXvm3N=1Tnc3?y(!OhhZ<KQWMeMkU(~IV^8lcm6L1
z^7paNeDL2LVVBnv^?y5s6=H`kb^OIZ_-;qEJ?1u`g0lYX2s3%|Z)WQJ$v{qd-+1X+
z>=)2le)R^lT>ig!d#|Xb_jTPr2`z+{P(u$$ZvvvyN$8!>izr1vKt!5S#Uum>J@gKt
zcPS#$2@oJODWYNrMa41|6cH=u=Ui*;J@-0m?S01imm3BbFkryV_bKo5iG2&fW&pIL
z8S;^<2`#lKm6E*Q9*EZUXSaTPAj*B$_<ZVrdmwSoJoAql-2Br6As4cZjsA}wh}HXB
zw?>A(eAxJl2V%73TRsBNl9<>E#dGydzDWIXJ*rcD^zg89lVt<PczMkVDEk~#<6tL9
zPw<;++Z#k)87Uv<pU&n!DK=^`H7Wo5a``{XKH6U-K(SKB;;AQL$zD0qVE5<bHdYIO
zmh`~iFVC8JeJkJmNjN;!)L#B98|(s;zw<+cQ-QIILjfPrO~P0v%T1>KMUkRUDbp1x
zc4H<`<g`1s;xgyfnJTu$AZ%3@a;*WQ%Bzhn<JlBw#w2n}NnCM9uE6;OOg+f)Bu>W3
zD#p*;?D*0iL60LD-+Eh`#go%pP0XCOW*ibE4|x@>Vt%u5Z*WE_8Vwotp6?XQC7(BG
zka2!z-pbwkGB>MlO$kfYUkkRlX?y;>iIeVI1m9i57xyqvU3gV0IkL*h0}M6g*q&3t
ziuR&HqKXdJR}6b+s`D=^Vyjke4ZgE@|0MPTl>xDjZU6ji=!0njx3&FsPP?`CVQ9DF
z@>rXsREilZo6`b@_o&j_8;nd9O`=Sq59O+}+S^w~j_?V$%?`eQ*iDb%<W;{08!tbG
znYb39214FzKI%4QseqU}B7b4UQ?=T-C{h3F=hj;cS{GKtM)u=wU_A04EwAvMt61rE
z$Xm1@iR2hrmQmmfC*SsQb-H8{#^d3z#<y}fa?Iqacp16xBv)?$O`hX)?|qBi+}n>u
znDm#~dF+3wSdfnve5HGPIKA;###i-VYV*Z%A6mCA!rz2mdZhG}#ZD^L^ZNHza^;QN
zWy=5qFuVTEvZO|{X{7q%_N4T@82>X(fxR1siBAUW%`{quus0Wu`aMM?v)$@9i9}Z9
z;ch=vv7h+X5ad^JpJ5}l`gZhB?01e!AC^Dy{QQ<XXZH1%o}n42%4qxC@!YL!+3X}(
z3+Dm<;m@TLw<oGCpxX+p3N*s2@C^o5N%SIPx^E)Y+sK>=#N9*0yI^WgY4nf3i|R^N
ztzX<xKQ`I6rkbMZInNQPNfG$ClZqCx{0iVPX_9#}sq(Ysh@m8!wDxWqHnWzu$$Toy
ztux(iL6R!hJf+fSntX=+$T?dHMzylsBc~ro7}L2KPUO{Rak)<jjuoT-&@|49ZkZDK
zLNAy3xO+7!#$1k9QlH-Ii%R@am-42$Dgi2$o9^c;B`a8_h31yXwC0jl$IRM>zT{T)
zc*Hz;Q$+W{7OOJ%i$h3^1<UM8epf*zJR33ZA;f&SZ=pdYdUpQIv--kO_C`zWc-~^6
zA6ZPWRyESxIzJ(}wAbE$IvZ;qc+0d*BAsZ23t9|ynJwRlvI4pL&V`kIs@S$}(zf88
zxHR~waz`Ug?YW?U|LP}+bz;+t#@Iu<Cup4c(DthfVpx;VY^i+69e;JPSe|%pzq725
z&Gp3tm(%y4HHgJ#(`3WttZVfZ1Mix7++VNcmF?A!t!1z>arYD!!5dVwg0lMM;G{mr
z`iL~rkWe2vXV%GB<HBq)NY%-U<3=+yh!=S^y*9niI26(%>{wSquXFEFJ6ZB3zd4Af
z-j>$p@l(tu_SG7t;CMS9><v05wPY*}-jQ#;?yzYod4s@MCne8dGP>_F_;NW$3#??p
z_|}#2>x=Ycn|9xUk4pe9kX=~kJYEi+$6LRlCQk`bT14j>f>0FpKj;di0wOy~hUM;~
zSB4M;mf0$^>kxU2llKt!gF}aUMhkONkWSCT6pD|PcwVsGD4FceOY55&2ytBvgKs68
z^f8Br8YX5aqz?8;uQG82OZS|vh>AY)w9x!AN8YJ)IakzXmN^3~?+jkG4h20BJ1WF2
zQ<dpz)Og{8(PdEXcmAzmt%3GLLBfNJ>_o~gN3BS!@1u9<FMX1NJ9a<X5WmD2sSGvm
z^QC$@O!iMme!0<Qp|8ZfPQamfPmoAFtLw5Y`?8--D_JxvIta%1PF1ZnW?AHU%N1P`
zy1lMuj-0fbfVm%0((TDhjk+U!es9qBZ#RX~&u+}Q-Rdd&O-quMJ%!!>D0t<YgIdxt
zSb$5DE@)>?BmUDNFXS}~DC~8BzKlbT4<)kldf=TjTFlZ*V`j>cQhFf!gNiu)D3z9)
z?a;n~6(9Cv^=I9uEzaAo7X6);#5Gt}l_K3}#6h#qe-J`F_POPsXh{#h-R=MXotAX5
z<4v;8k4<<^KTY;;v?S!x-#Nm=w>b{`gAG+8R>{L#wTD_-bC|l1g^`UfRPM1aoVERr
zvd?k-PyRVR#(GZ&jE!BjLA*cZFamK#*|*@dmr}1S$Jo~D#EM%Se=56-#hvQ8_W4@;
zPoV7c-SVC6<<;Jrcd4<vrXri9Ye~*WFD}s~K@=8zh!0F}Gj1kJm0{qIW6UNSAt<KR
zFWAqbM@%=A46AB*M|9$MJTU=sfa%tOS-TFgaO5$SAghrn@E@x5LM|}QHl&WbVk7Oj
zK{gZwFGj_{p@BY2TErMI=u`7F+MznS_nefI!96=kMhE8RiSAgeGTngD;S2te80bC-
zcg*QSd={<-mGp%<oTtY13*reonMLT(s9%k26y=M0zCQcrSe3kq$QC<j`Md%M#6mz4
zVBxZ)BV`tF3wD~|4khu<7sP%ptOR>3of-?GGBWr$GTEEObulriF=cddF^pezb>V(H
z6J8LhnD^0lA{lO3$8r^gH|oYS1hQaGz-0nm7)p3QOTz^Nx#bQBS?7|hBv{y95;Qf1
zkFO`0?k1t-cmb3!+MZ~-%>$r>*Jg+^ul_&g2!HrL<OtLK4Q6<4i_@>IbAQ@HQ2H*i
z-4VPI1GoN?4#lg4+(~utMQ|4Kj>M$59?xJ=;~MObcudY*Xy(4#b&(04wW^u5_D?s3
zZdst6Ea0Z_{(9zn85n~mG@w44Q7w9SCE+oGEq8@MOM}&HJezGZ+rB#i>&Gf&lK5@g
z_?N5bD3xz(Mr6em!I~z(@|BP5%?&0A)R_qJd`0i~bMwXWfxjY`n*6Ws!w*%j=#S?l
zZ|2N(=WdzCv8t0#{FPqC0Ac}Mfe`=9!2xa+0HFeyRJxj`4%ySrg-g!)3jm(TA&X|8
zNwd$IGLC9C2`Cg7)-}1*g3X$C$esZbZR3Cf$Lwi<p=)4>QC4zs%mF?(w6xMQGm3V|
zp<AcZtTU!;GicbXDLXqf5GC7ZPupkD*k{pB=S?}~%s3Y;IAl!$6f9X;tRtE3o<Hl9
zIgZVkv`C+_&X~5zoU+ZFHaS;lmpNq`Pza>b<`w`f%LvG$U9-lo)XiKdo3<qmg;g)6
zwJ+veTZpZmb|KT<a%WtMmW?m90Ou(dmio#{&XE<9b_ty+tqY{)S^v^GzoKcMg6Z6z
z<<kXpzw%oFC3L5($>f&#%=QJ_j45EO1<1|6EWv=k!<FiZ+-vifs%L^L7t`A2OZskS
zwarCSX3iE&5}N22N@<alc^C3jZud%R)6AKod7t9B^A+>%xzlDOnq%g8Rtqh<@wRp5
zj6){P!qQMt(OFE!=0>TqxQGG92yJe1SwaGf(T_c<?4onh*u*eGTG~Zc##I)8eJMLz
zr;Q)CiaCJ^$nUyEYN4B+&5fvEO>Us!o9E3^C(@f}2`#trO^Y!ND`8dhxW>7H-qq}`
zRZn7%M^X>IVFsH;4=SO>)-Cv!ErwE-Jqzc&@+X~hXWesYn8@by<#XrC7tU8NVY6sf
zgh6-m)am5w#OC?1ikaNbrIhwn$GrLQ+GR)JKb1M@m^tZOcq_YU0-HHyXK!+&L>4GH
z0Fo9cDgcK;07pwy!VG{SUo0NOH{Z%=UoP&NE$N)~DxSB^p262pO-WPHwX>Hfv+?x{
z3H5W4wM&_uOQ#AKtO)(?1@mDwD-K!o<2q-QE#s_X+g(dn73`C2FE#pR4}0Z~Szqlv
z>Y9E!{bp9@Qhw_MCTTp7JP23~fPt{T$Y!LA1<Z$=<qCD#=yRTmO@m9JfenB~AS!MI
z*a%@k&0#?e!T#kzel6z$eE@Y2^bKMzk$~wPz}ZM66$3X$fXg8(Y5#o%00V%)P!aPk
z%6Jl#N5PZcRWq3iKVn&7-d#JDA@KcQ=HUN0`1pGc4qI#fhX%C#Kgq%O<tRP>H#zu=
z`I7%32QTj)e$XHJ_V>ZZ-*Rx3hvLA&NB+N~SC!oy%QzIb8wH5D+qc`imVjNE=N3=q
z1)6I|)APT)`n@Z2_0A6t|Ba`(;tn)I{L_dLuq$KAoXG$;mHYdy4DTBR630>0WOh7b
zd6`O*JfS+CcH{)=SsG9Cwq%A%c3={ROs(dTEY;O@sw4@-Q;OpeT;B|hL-`san5F(k
z%=ODNG5)%he*+y!N-^Se0$WWZ_RNZu{V6ue*QF>p2x~#u%d$WjEK50S$^C%xh*6vg
zOGuSqQ$_fjuMnlj=tc+u#OP2!IP#Trw@5(Z!DDWv1RN71leGu6q2v~P5?aC!0yprk
zZD7Et7?ctC2yP`!9u;K?W)#C7D$GMVvf-1;N(Z<ZZxKSvV{S)HwJA6%LDHm+*Bgxi
zH_;4@+mK3BQ(@HFGV>9ouH7UagfZ0^sY@Y@H^>?<PjERXp_1e%a?6k-%3+kY%S5<S
zXXn+Cq%@>%pf7~I0}aMBA6p2U5S-dWP4>@HYFI^@q-trb3sIX)(g@93k~(}%RfXSZ
zm|zXB)AUK>6K9toDmvEpD0+`PD}Su8q`L}+c3T?~n;MNjvL070S(#*q<J4!Q4ZGk>
zCq=Pj>XAICnkCZ9Z8t?$jl7Y@iZKTp%h^TwOtZ*RscAx==GymNN=b-W5n1B1DIT$|
znrXpn1&|~@y_iEZP1@4wW3q5SR2YOw%sO(46IFtq;zW9GrW~_DuCnXsCM@H5<f?Jw
zEE^%8K0c^-ZMeu=gAO-j$<qZ-a?zqBW&~BcRvAP><s><U{3t8d?6P!kOQa4v`#3vd
zjf_K{LHe@8#~D{lS)967!OYbRYPYr<qPgzqv>C5}8IfyLqHq*8*Zhq`43(xHRlrTu
zC?aE+;B}k`CRycPRS46((71@k3Zp94mpu$QEug!@fMVZd1j0U{(Q&;G?qvB=RU=ki
z7O*<KhFu&!!B@6JL_#G*^srQ+>1C)i9R)QYfe|P$tCpOPcU3T$>zOJ{tc1eq>Nd%F
z=;6b5O2d#Zs)UiJ)_$B#dsmKZ32qEPr25Nyv#2yDDFtp46oAOxIR?X*?L$z59^p6|
zh7r(l#t9hX7_TESqE46$gcLd}JZ4hyu4;O(-foVmJ4C5IrX}<=j6n*8k>H7y=MF<b
zc-M_#bL12=p&mzs+*Sh$Gz$&GF-Vyk37#Rh$v{39=nqVT&vfBjicsJVPjrQ6X`{<T
z52Lg>n9&b4uUUvHqGtNT96<ADWH$JZVR3S`yKGL{pJd}SjS<)|5HI!<Xnmpa#LZHh
z^AVrQH)xF~yEi$M^gdN+&f<=nkK-;6=7YINuNa=l+a2k@4gFYuPXDp{;ZnRlsG6N_
zdThmFxqKUp6f_TH;`hK46$)xN{kIK|!0gj)_iFe$s7bK7mF&2^I@Di?xzeYPJM^sL
zdo=(J2oQ5EZ<jsTYt&q9v5kIHQv7kR3C+=pO|@LB75dz4Zqw>e{4MXQ_0}2dtX8Kc
z%R8-N$yk@gR+pP|cdo^KZu917bDQ})F_-Ce@#@^&zQNBOVOedSuPpBk0>s?kyE0$q
z?u~x?+=;WvB+IR4Q|AiAQj+BfU1jUj+WXz)tad+HtNU{v`#oLvr&LrQ+Ka}xuvFM^
z*_m@+KT>kHmk~2zW(X%Ne=`-;@v-3VL4i3AH)>Jwfq$4sfViJX(r$u4?|C9op3GVN
z(%fVmbRYCEjrX2}(2hkE3n8fx8a)V!y=K-W>`89!lYOLY9#dnLy9=R;vhFg0Muk_m
zQmByE8zknJ!lGx`O^4oUsaWMHLfE!^q~7U46O)g5mz5N^|M>jDgszs$a8`y24_7ts
zSM<R<9Y``gp(o$3^8!I7rQbX6VBV?vO!*zi3%krlwUu*!>vJ8DOzE<5ODN+Nr%hY0
zP}4XFXV0Z*3Je6Qy2WK8l%;5NhWopQ<dD3Fm+zshIV}nbe~{T7zoPb&gChRu;!J@L
zpj=<FaWBtv3pVvhc%?u~IeK0SThR^|LRB7z>m=j}uYY9*IHDyTJ?9Sh+;u(&SzHQ7
z2MV##mL)8%pD*P(hTp3d$oLn;Tn~+;pS}MLG52Aaf^R=S%oWX-+xbn*-M1A~{CC7$
zVIuPGZ(?qia7g6;V`A>V(SSdIL8$?{neE5C@*i7re;$0?`dBpd<ArL@z{0uz)PT{q
zK2?4H@e2L7gO6I_pZ_@cXw>=n8k;k?)@1v+_0;1>wj*)QfClU+P7o)mnce$M%#Duf
z2pF?0MooO~)oJ)6^e@ERrze~~-HIN6CkndyVd(!wV(!w&`{<?bPrm>9LggCWNwxd&
zO!)AC{^9$B{G}f+bq>ES=Zx-|>0?1oUYcRmzw8;PKi|h6e&664J3N@N`}MK>@W)1z
zZOjAh9CZ5zWIJc<$1A(5Uky^$;p129pLc@|sbjxDNF0Qec+^Ku-v`H1bCng3>$=M+
zypza)#B<BxkB{SEuW)cpyih-WmxWh&nMWLokXR2!9$XcPA;=wEF?1!!uM<RKSioT{
zhO%4<6v$OokY-7ec7KxYdXoM@68g_w8O;*LWVpDY8CT*mOA-oXd+^U1&`u5tp`5_&
zBs1+MpOb(C2Op?QoH#TnxIZOiJtg!YB@CGwp_v-xmKwSaKN~0%i*$!}F+q1yaYzzD
zlSDj7O$_9GxsjUOPs&^;Wh=>%PQlX>HKXp|6e}#@EpEPImz#ENm#d;VjY8tBMyA)h
zrFW>Mlate*{53>V1;}MsNX(xC$|iXTn?8=dK(Qtc+7Jh^nG?X{`8N$XX~2d!fVog@
zn=*{?&awr*EOXL2dDu2($eK7{pE+Sg9I_w`8G2{iqzqdo4cR0Q8+vD1Bn?^+2CRsK
z)<odTMojSocBw<AR|hQd{r0INHpwIQDZ_RtLuR-^ldFSv$-~CDLEEH0QsdN>>Ty7?
zStSi*w#}L22W*o19n;3l@q^ZcKHt1a)7UOk!cauXDB3#{Nb#J~Mu7Lf1@I%1`d!n9
zFP8x4NH^R_H_ZqGLB%ve-IQ<6m@T2tIdvqdX5v)NxJyEdBWc(%d&(ng%prBqzmOJ~
zH)??!JYPx&+RK1=jI5foCiL482aK)^IAly7{3)X@7Eb`u5(oiLWe&Kf580<v(`rYY
z)5k8B&@AzTZrN1ZG%64;TEusqN*_$B8M8?m!civ49doXk)HAsgah2oVSwlH3Q`nS&
zVDe4(j3GPXP)yk{mNa6WJY*T!7*sTMCTj>NJcr~DIi(I*UTQj%H<8^$OK+I;${szJ
zJ8G9S;C7`oAfIYayos+K39Y1u7L7-jQ-Qj*UI-<maP(sNjD2!{V8KLoD?O@`1|*FB
zIYa0x{fU($5oMD=)B9Y}#KnRE-IyEb_?yv`IY0%wr4Cu(hf^pcQKi(R+6i;q&GZ&}
za_zVUZpb!yEVYS#rDi&%Va6zN08lHL^`pf48T&LU#wRPOaW1=g#)2>c1eX^0A*0jj
zwuC|RxE|;93Hyxk<a(Na?x1zj$eE0rR`Ffl`4f&wH*AT6=W<8liu($?mn@=N3fm@&
zI_I6@nop-(_sXZo*U&5zx_rn~U}zz{2>9N?u##~%LZ^9nowyj<fkcfhAF(6e^iAuD
zsGN<fn<v#zTqzr{3atjDdeW6zpr)>85~<>l1jMOVV=Kj^ZRD&I6-_T4HNOP(%mHDJ
zHpF1`oo|#X1^Lxp3~T^O-GG1sQop~+E<k4i670VfP|QO<|0+cLF9Pa)=wI=_|0e<p
z80P%HDiZ(C0_x8q@m~ehe_JH}rx5LL0_x9UP6L-CKfgy@*?h2qPD(!HU|gqO<%iP6
z@f<q>D7=tHGamQzIMj#Oe*nQ<Iq-MOmp`f-Mg=ny1F5Ov>6(&hl6g?y^rKOl;~6}<
zsOJo-VyZ_30-EbKv(-x{P55EvWE=!0h4O=#a=T0A8L3#*Gg`v5AS_2jO6&8?4TJo^
z=;lrK9PdG6x}swo9F5>*q`WK>S@V8bCh85xF$m+}Aa;{5N+WOSBl2QdFgM7M1?-1L
zvmh!;Iau!yUpHG4ts^Hn65!Zm5u!F6Q+w5EHK`N<r!w;J`c2Y~NYwk#IHVK8XsWqk
zhg4h{JFn5C05%4TKN&$?o;(szK%K6mm8}^ci|SXMh7o#q87fV9H>v7N*7oD9Oh6T$
z?K%=~A!qM5ktsn=fLke6d4r4qdML(F<;D6YO(a~z-WaOwt<J(ZwXe7;+0NcQ!R1Vv
zG!qv^9m__D)o)Dj>cc@y{O!<jw1_cogUVh<lO*!=pnHhi$zf=W#91V_G27X-?iuc$
zYh4!Xli$uqn$6@9rdVUw@lYt1hGCb<tPi8{29kF=*t9(%EHDXUlo6k@#xo4u+^yD-
zjpEcpghqkTsqB(&$1>Yx*Qn_lT94oLnb^>lQ;@Pa5DQ8&VRu2yf8#J0A~GKWPFJX{
z$ek0&-SZ`IIrNejgk`W@7-nG*I7`&1egz^nh>|pvY;B)FGajdN+djP5B(@@{MqdV3
z_IXCYxG%$V&ERq(HH#{lNN#qG7SsxakFx|mBcriLNoC+<M1%P&`z5Btl@}lxoO~54
zhER519ESZN<=VFcc9Z82IJ+he55KX7NrtEPLP(0*Ym)S%+2q@4s6b={Gt3grq%eoe
z3em`c=&dJl)b4OdD}nh#0~w{~u*_!05-jzakTLqqc=AC_{P{8rcR?;#+>OA*ip4{3
zY~UH?d>LUB5P}nvrL&G>QUaNMx~l<!VyS-jku>&06eU@zi^^<EPZnkdXL4#IB#77~
z^}7Xlwq|(<9EU4Y2?HxLgCOj5G-DzPto8^DG?~%NAU>S?4SO42x3i#rC|(XZ$t<He
z&GW?^9{Na<jS=bx1^~kl-c>SD3M6roLdOWHlgXL&M})P^ks)Y=)H+K13o=KRi~&*D
z8|2I^<{ZjC7S!-E3s!Yy+k|q9<s)%QEL}K{TX{u&!~V(wVOE|WBY;<4gHm+tyv6Wj
zA>F!By?AyZK>Jhaa%Q7Olf`1N$EUJC1=Q?fXdED**qbzGEN(^oJw&@Vd+YM=5G}Jw
z_m#y`+=EY52MbO5UuF-N62E<_25~f_SuB?cLVFabO|zlE+;WQcUJX2}*;v+cCEa7M
z772uCC;xW=Wz%9Q?3k0%>m+sbN|2%7;OajF)J5Oqq~7Pcd+RNi36>5~AZoK2U#ml`
zp;Lk6XC0f4W*NzkYwtac8k|r6O95rm=5g;|3aBHNnIpdi6i2%^i`Dvs&_2*qZub?K
z|7QVJve+JQa{m6Uxc%!Cj*dVxs|TxP`@PNo80Or+(UsK^a?a}EgTn{=ef^6aq0#dX
zpM2ZDN#(c}mTL9rnb4Phy3MtS;`v7}wZ9Ai;bByh)#EoFUk29~uU)=5|M-2}m!S=g
z&X^giCm+kc3~$?X#@(BLvOoA`WGAaL;g!|XZx6nV9xQeyewlyz>)V$x5N8*T#d-rG
zd_aZTb`b;?Hkfq|#^KprL|N-i*r|gF<gKohlM9=i@duMA&Tf*K^)v4B1Dc#|ce?As
zGyb82Db?)m%yZVyh5kOw8NKja?C-;zsn%PP!e8m;w!kpw!j_EAe;wxhdx#eQb>5rv
zddZCSOZ9R9U%{_#b9>?Ci6JdM1!yxz${r!-<ioGG0$U<8J})fcK>s=64hAs*+e)NA
zUy7ol2F4K$rqON2k&R+v2Bxv?MiC9-;s)BzSGBxzghepMQB7K2WYd^-F;N2)O5Y@^
z(Im3bII;<F8^pxXz?)J(v>uMo<KxpeifFXD++-NpWEkGSFQ5nbum)ibrm<}%VKw>}
z>!rlhIT41Ki*-if^*R^og@pCZV%kkFwV20t7=+cEL^hx=Hli=qW5OFw22+wN2er@F
zS;sV6Tx!CE)tg2&xe>at@vS^Onh}B47cx8f_;k&qTaCjT^e@yo#Wfm+HzJWboNxmX
zVLjjE4zs96<A{1O;FphV@FaF&V;c2?D@8=~4I>%>V^>^UKcjBcMBh+K+RiDlLtIo}
zR20p@WdvhK!`O`wJjUES7$G4v53d0)A4URYAb>QGkv0mp7t}q8mXOeQH9-jrsK`pH
zsj1oPD2b{aHIg}^B_^!t?&!$Gs;4M(LPAiHnaxC4SSKjsx|ap7kCmWdNY$mtl<4To
z_4SmzJo5RVc+F#ITyal)asMfNn`uN{U|OfEovCGXdtBj-$eb>DS*#n@(e>&zL;r#V
zFFv=#mhvP?FDJA`WNoaM$OUqLcxDGKP)OG)(J#ICYH1(7VlXzpE23b?o6tH|#dYGO
zyK!U-DbCP`)N2yalzo{$vv$zau|Q1B{9H=&xy-)gvL5V}Yrd)7!P$KVfn^5zUXGEK
zX_SGKtJf}FCRmsRT9}9EYI;>wm!A)cZK|0{BBY*jjkUA!Cld0w*wu5ho4mX|&iZ*5
z7ge~qU-0n?^F4#Fs3@aUH&e<cQc}qI`GqYlT}lep_F?6ByLqE>d$aNOUc|O?oOnG+
zMD1*qM?(Fnqz)j}0N&z2u456?W**;pJg_FAbVxs>wyXGfUh`yoiSu=et&a26*|y_W
zvF$QO5ohrYK<;wZqtf_X@!<|g4RhYeCr4V^T=NWB$D8aBQ)6kVXBS!$5lqo@!YNwD
zp7*N}7S>hMa7(MWUfep~d}GGcF#2L(BjDHn?Y;Qlz7#nb0w2-Ck4*oI33nA8el(7P
z29=5V{Pm?+;GdEridY`U5=o`(f+5VHpw8wyZNRqD<KK0wWD$gSv*C8Gkmg11ug$8T
z+aCVo<ZL2~X><of%@oAhJ+8fgU%q>7bCUFX!d<h*v^)L}I_7!`56Ipfdh*Y0r6r0Z
zvmDu%9j6n?-}P076V$+6X7sm{v#GkN1H5VNM4@IbGS}kz2F54ZH&oGU6wd$Y)v|P`
zM$hv}9#zlYg6$qu6J2%X&$?COu^AXwfhL2ij0y6&(ER+EPzW&LF0cXu*{OywD}d^s
zn<I$fz039o#~ZDH3HNoR8I#g-ivPJ7l!+M<Zx6r9c^T>`E|#)hYJH|3Ltt^Z6jeb|
z>f3&n0dH{w@v|jRYNG{W!M`Wm`yXZPJnpZ}G3F22iZO)6Zsl2@5Uk3xHI;u+P~~I(
zqR=hC{T_>FBIQM~cZ&SW62GFLm!*M?15%Pq63-gT!lvb4RYctldQ}<ovgK7(!v5=5
z)i`E_Z3>Y;c)Nxq)4E-odE(7>9obajb$x+L@au+>fY#TI6_?+<Zla_pylLL=HhR<2
ztm2f;yRV!3rmf}f;js+$jws06j@qiod9fK(K70Mg4TW~2kMBORsjzXjwKvu;8)m8w
zmkhq^EzHYf6OWa{{Lz<p*U0kdD5#G8=9a!?y3&pHXGy&;`ZDC?C%1FW<lm>vHlF^X
z5SOhMzddfI_L<o_P_K)|Z7q(1WqOSsRa0u7WW*>r>AfoGNn$Yujz=P^E!y*Ekob3n
zbb;J=+(TjAX+6_!f!3>Yp`{6@z=nF{1{TN-CB&TS_qE756|PHDdWBf*tnQ{1MT5!O
zk+QdHWAM25wu7DMr90LJr_(wL<CH!b@@eiJGe0}zyx+?e)dObZY{q55m^HnrkD_ji
z62Q^(%3mJG&L1ukU{~*ToP0vm@$QG&H%BrR@hV1Nw!ikkBsC*v{st$TEEGirmx*tD
zeFf?7(%Obd)eNvzWSkjfJz27&^{Of7+Q4g-3Sc?4Ips>;`-NSVm3yF)@z;_fnac!b
zZYqcgyl|3h5-Ox&hh|ZO!^b%Ul)@*Nl$9_bxjfYsJmac(80IsN$TArGGP(;QhM9RP
zp{=z=r7??E)J}dw>>b5Rw>5(gIlY-o*ujkHWJYcWAJ*VN6mKz=CJ{;ny;SptK5tIq
z<WwaX)<0uBP9}2df(;@{*<(5lePW6>v#gP|ta6$JxGx+G&jc}YuhZnJzzob#G;^CO
zk^N9f4d%E`5zLR7LK%Wd2G%>w2r?Dwf*N-XL9smPC$fetC&_P7SwFG?L)mH!f|L!$
zHZqO5Xc;UMGRZAO!AoR=2oi1>9>?u*SmO>SuQ3|_0A$P+9F~Uhe3q_?LUWewz(g0&
z(5w=ogf$f;#OMo?_FFzmYgXkCHsmpfPsl;S!HU*CJdT<W7$}^`7UB(SR5j*u@*$zx
z(dkVkV5t;r61pG6atxa+^^2Mnuw5sp3WXf+rGrE=H*)u$)oaXL&y<H^Sj_uDC?QOe
zcBU_P^EyqTT7tpZ(@^NrHb#_F4I)Ctu@2S)`!T9`WCcpRGmO9&fIZB1m4h&?foM!f
zI2h^eE3{J4XjuI`U7iucaGXX|I0GlyYmCFR`>7}1EEA3lOTwOP<0S*&jI8V4Fg(eS
zmn;B=1fqFL`x)h!)fj{pC@d)Y3+50qBZu`k9~*~4<g?r~sSOYd7If~2w`!W8XDvct
z8?2ulMlhgA@-*Vc72j;k8Ms}7pF}+c2ZuosAscX;gGu&Zpfn8SS?dWTUPcA4Q}f`)
zi40OLqZAd#LqfxO`oU7hs``i@g$%NAB5R&1QDy-IH&=b<)o_!M#~R0Qa+%6{A`HSI
zh3Pp?rHO}triaQ-Xk;AV_hhgbh$@aj#9QpVEE+d|sE+G10ug{M68ytem$;4#%Djp5
zxO<`ALNch$pyIcsYgM4jWf|9^>ewDH23=#iy?E`?4dK%$kPlOX|Fsx_I!^u{-k`s{
z6t{n3BofISae?QD4@}s#9&B<l9oz(i_CH)@Q1WI1^@EvCsNz{NHz49A<6HDjVmvYV
zyY0VxDP9a_k$FF>6cv#JuZwYV-bvSYus%DvSNrFLJMdCWepxev=IkN=`<LR8*lCx)
zz7&sv_E5k}vDD<1=Jn##nwKYJ{SG}tv#;m7>cTl@zut<uEO@l*W1H@)V%|i~UJ8rN
zwxRI1Ws+@gtwsBUNq&pIYH)9ztj%lt?txV&W@KYWCWV-7yjmXWs;(jW#-aS%TC?qq
z*57rj;;q$d*~d$LLkdIb->!ikPIZJodRFt!=U&#Jk#V3N!ftE}$<$(^4C;DEq$Z*0
zp`UVYn!Lk@jZ0`l(0zF2ZLi4q;bqjE@TjPPx=#6{XBRjut45?^y1q+)&^I5BRsVor
z`!4zAW!KK~W1drT^N)UT9$+@Cxd|WEH6V8V69Tt(QvPAJCn{vy|9FN1AD=clyZb#b
z;on*9(brD=X|-QO&Yu9bmHsEI-J($$u-bubrKQ2UH*fu|ZY66sGilq>oqyUPzyR1*
zy0zao^z)CfzgX={|Fo@iFd_VFhh#VWOkn9?I#pgEJ4d&~NBQgAsb3#UmWE%RT>5$|
z{?{i8*T}Y+-M7{9Uwh4VBX3-nzTF-A^|>o&<lQ;D?++gS+VB6X)vmwnuafW)K6XI2
z8~s=eSna9x3b#I3cR4|RZl5~*hM5vH-pBu(wpNkie?R&kR{OTy*tdI!7d*PeHR@dq
z?sP!dLH&n6K2_WFK3zKe^<8|uX!j~aPH93F#~g!$mf&FhIQDfM=K&55SnZm4UN<~{
z3?5nX+iDkC$BP}{QAmQMCPB)LAOl$KB?N_jg3>xc<$$1yOj6fO(r`;U5tF1zQutc*
zU#xaxH=-%9tyDs^>?c~U6aT|%FETvm6qD>$lI+o+?75zN<{;S{nc_=FvY~jHG~-5-
z;6cFd{VM#<$rQfbD`9Q|(36PU_hN8;@c01u!#)vWSbQj4(g6gz8W<lz7hx9Q4#&km
zDu$;5e8Y>H@SGTU79Bpj0>40wpPm+cAPYZH2j9GxoJ7Y3VAD6$(%F5uqHyUZ-I~^c
z=NLAbyXeG35GaJo3?L5%`!f<9NW%viZU|QDdTgRvCifR8kI(tbf9*DbK)^vM1plYt
z0?t?by~}{36o2mu%-KAQU%t_~Vr5x}0G|q<)47I$B`S(83UW3+rz!({N`w4r0({B=
z6`-Qv<mXi?FKeUkn<p!6X>UvL@hl4Rt3KybYH&7RRms)RFF(Mi(lD@C$2-^0t6V|R
z4C7yL(i!i4s_LW@URmDxh?s?sXR(J95qK>lk=oi`WN*)^<m5u{Q$>l1*?K;CCyqPW
zg;i>J=D1w0(elm*&R~F*UGv~#<G>=rpfWVtMNZ1r(j=m_=1wKhl(HcJ*BW}Z@n>SI
zRE}C|YdfT+7ZZ|luOwzB6?7`eImTtT7zPv?>YfJ_B5;=?BViMNso3{wql0zac|66!
z!pFcTThE((j?jF{IW05!=H$>$chl39D?N7>4;LoCugo5%mR{FX_lhDl^6_bzg_K8!
zldt4nGcgD|cGSbzKfjvNtnXK-qv7M~a^Z4xDk-ff>QV}UkQ)=5#>;a;U&|lkn{y@}
zIN-smyJtmR%z?vCXr0Qmxlp9%mVDMT>(Yf<kIUsQF6WBL6MdaqJ#9}LDp%{vmJ2ed
zH`-rZ2*|G~n+Fhtv($sZp0~p{UZoTIYReZY3+65mn;mVggaucGUcj5210<EfrK}DG
z1v5L#Xa<P<>C>SBS8G_I3b9dz7lKIY>h=x}Ay=Y{apXo^e3^4pWoX(p`_Mwn*#cQ9
zM->(OyuAE->-Qc%ew>|CmYSLmg^I_;XLy`CA09!pvkUU_x|o$+c6fLwCS=0NA)~Ht
zspOn)8<^`DUIJ_v>-iQ1`qm8h{!yAc=jT<8i)$LY`F?Tg$K3eWs-ijE<?aV7hY8Uw
zq34PdBAbB9k*cy?4rL&-qSwYeYGPvi<;yKo6DO;HoVRb^*qFuy`ITb)$Ymw9=lm~f
zI3;zL6Wk+94wip6&(LUNYioV1opWMBLP|>N($eD9t9V;$o2jYE$f!64y`UU?<!QGv
ztFxJYUWHhjU{y68XKZrgwJ~S=?12iPh=*b4!lZ>u0Al&S6<o;Q_bodt|B9LQd(2i4
z!T#6#784cNe|DR0%iR7OGwbta1!)K*)$)&x4`;3O|Js^w(O&#JGwa`MeEe5yp7YT&
z>({sIfcqBFeCEu1mM^`7#@C<wK5UQ7_(^12>pEiAwNQJ3Hz)MbncTOdv6yf+p{Pev
zvr@0<U0O7?PIrB*)|U^+59^1kpXXWfPFbl)&8nO*nfya$GpX9{>N8OtjUT-`j+WUj
z`_8j7{Jc`9pXEn?Zs{!yjb28ia`#fPB<_KC5N`rkVK_%1)R%t$ig~XpJIJiRo5&>)
zM|VzD=rg}9YDL3vaCDaR5as0c8$~iy_UWhD%-19)$(If`p68l-+?^0Trx9zGZSh-h
zIk^N$`;>aNG}wDaz4k9Y(7@tLI11zgn9i2P29){NrZtv@whqWtgqOKDRbE`3eOVDV
z7yGI#{@3ie@~be9?V5N_%k7dQp|1ly570XpwE_ni9;R)sM*WN6sxJx#1Xp8gYirqw
zFWYSwI1cSIp%9XH8&sTzn_vX*y?NV7WmbIGHF6pKuA45?_O55)#M^g0Jlh+=-tWgf
zp2FcIG_~*HOCeC_67#b0b)GHN(Ejblw)cbYm{AupbXScjH&lJd$~PZR@BGnK{wuh>
zlc7ru-N_K;9R@I}hg-%O;65gTJgSf0(|BDg-VbHlf{UkJAG9ftJ|VEZ137A_?SOc!
z@rEFVA6+R@*mo=AT#nYeMl4#^xrRLP^<*PhOlG&?QG@!ONh-f=$KL9w?>nF2y@?lU
zql`q6cc6GOVTQ|C0}ql9(NH@EKil3tBUZ(TAo9s;5J(dKpiOhQBDH$~eoxadjV~T`
zxVZNe=cRjL%^-Y%j3crU|Co6Mp|sIKL%uMO|JDuzd+FX|b+~Uk9)vgp4bN0}A#N@R
zBtd&fl4mv~rls=|)L3OsvV?yBV_sX-K?zjA#3P(`YDn|Wz<Y%d7Ws7skchfp-o&f{
zXxv&bnu=f+@kc|l1V*gwO*IPTxLJA0o)ac;FO3L|_wR0UwZHc|zVg`cqcD+x{>;XB
z+!)HP0fv2iEB*_bH}+M67RFi%GK7_of9h=|^2nnYZffX~^+Mf@&B6SS;Mu%C&POh}
z84I|Ck&LmD+<tE-B$)9~Qz(WV3uO?<12dmh^@SZqRC8Wr8O!N9D+6<)GakxNahZ&{
z5=KgrCP-DxA)bcU3-T>cpm#jOaJq?xO(`mD+ytXQT=_A^(k>t-322S5Jlt4vkjiX_
zgs`vT7?6}MLV)f>NaDj9vC_Ln*+0VM&DJbXNhgb2+{3(RLLk`3^){J$6qE5=cbMP)
z^)ox~a^=zEx1vs1n7-f5=X?9yO=vkEBg7a3f5f`Otx0w^r4{nwrSsU`O|F~{cXvP$
zR0N8;Kv9b<9NrAVByT0joz;Abwak!lOa6J>I7~}W#HwD-IFr08@pY&Xt&QSmDpObQ
zT@a9zJpn!u0ufHuOj5+6iG@r!@L#O?J*UR0TIoZZs`efvpFD$Ifn452$!-+W)=Oh}
z2|T#bL86Bj3KL65B&nFxShAkG;|tu+2U@~Vch(x!3l(e-n>-u1<P%-05RlZuc_`^W
zyG;!(vo2G&tG-2ner~}q$GOdeN2i)OTd3v)7(#Q4SYwCSHfk>EWcJ)>b(;$2q!lE!
z1Kp-Yc_z8l+^mqWB+=wROk_IsKf6sZS5OpR`#-u(&zzOb{YjuxgcUQU%c!-rmxdLC
zysa)aOl+@d#vX9CkT4_u?hPhgV=(T7(#CbvL3<zu?y;hR>uosR5iGErbeF(?qxtlO
zKrT4fjYEy+GUq@zhKRP@2?yFu)crdaxbKMUpm$x&7zHQko<{_Y=p!)EdXvp(>s)9T
z3FSh%==*Ut_jU&U56jbn0DcJ)Ljk=s>5N->i~n@(9_W4Y(fG&01i=Lg-`mR0I1cI)
z7o`m@3K(M7Se{#xZrq(N0bm^+AHS868sgqH(TqW`x%W;A2tXNGdMU{eB#Mz=6-P1?
zA;81DY0O<{l7%XRK>a$C2fSNMDV)LA+?yt~fn!rbLs-L5H0_sEuqT;eW&4Os5)&)o
zwBbfNHtLAAKRr+SqaP7@payL47@|aS+13n2yTWF)0zah+mz1*bH$zZ{O867Pltb95
zbuf!A3J+PMFw>|Q4yACMkkcmf#SNU$ns=I@E{4X9Visz}ofFxkF!QhDrI*p{%FAuD
zBD3O+2<{ib0Kvg*SRF)(!Gc1x2N)2?&9m2y>*qeKmEPJOLBI4ShPg}LXih%*9!0+3
zG|3(SVr0wg3SeD8F?yiD674=j_*yB~DOCpXRy6aG9V)vk%1G`BmDMQ(k32@ku^4uN
zj{B9foNP|vF{Gr0v_YsuUiR>C^$(D?`X_<25gl9+Z%G?I$lEYxo&zd`EyM>f;&(YT
z?U^{&aXgECXbu-lilXkg(6~346$WCr_4Hv0ZYJ<7cQA1_`?6Rcq8WHV5}Asc7&h)M
zumpXBAlBlcbg~%M&f4=SpFNx;3?AeesQsWENxN6!HpK(NFgy2CnD3Sh0L}p8k$xP@
zo#{R?&2fS(naXs^d*Y;K7lU(eDQnz1fyd1|C80!uQK=s<<gJ2-tK#`~Uvjo*tViZC
z_I%(1|F9DZ*~<z^V#j%#2)j{Peby<kyZsOaDCUyk4u&fjG|k_KWwP4XV3kmX@O*@a
zvMr#dM4Fiee_<J97KWL_y>wU~z#+%U44|yJ@Ai%D-&^2fLn5rqi^|?1$G5>Ot*A-P
zU>q}lvjnduTu-PqoXJ@g&%~^WJ5KLr(7Jt}f!QtjP_Tl+qNh5}Y>i9gE1@RI@@{bW
zL8o);AAFbp`D<LHCRI>#Ie^Xl3{o?U$(q7^d;?NLWi<5$+u~pW0LO>Q=!|2~-C$%x
z!Zrgye&<;EsSHJ347OB8TNF4BSSe{{Rq2A+f-Zjk!ZUo6;A9^~y@|l%e3{8C?mHY(
z6s8Mg7TtiP59h$K*a#XfqGFlZ!#gP!=gUN4y12u9Z0Bs5H&_G<I#I%edc`QSP1rNM
zItWfWkWFG)hRK;iNTx}C&_w32v)mNl^m8C7bc#mI*{7-aofj#7&8+R@kfN88$_E1V
zjmff`$$irZd>DwI>_sXeefI|)qmZ%>NhFaSq8){RLn1xh(s(3DKc*48%M2_#X%u97
zt!6rf&QKqd-W-@7h&^TA<6Y8>xB?aYa*`z6&AN-?ln#Ro#6X7KAfo_E{2*hvIRn6E
zjX^VM+Zodb8PBNcoh7{24l>bd8Rc@nnORJjEasJq>+4yC%~?$2Sx+>xKR2a4G|%2{
zPJW5Ze!ZSOax<GzBKy5&PA4RXK_X`_kbmhj_xF+<BshC_I|uSr0Ti3V5KH!OAVcsu
z&=#JNWpZK-8AK(+-E%+t<Ul0c`CBBvcIAR_xgZKa&O*)|%aa7>@do7~H(_eKWVy{e
z4kF^`I{cW0xm-)0<{_&Xw|t(~{rtA>e0>X~mOueNxL_TbWn3zSn$5SkUr-*N&({L7
zvd_1bKc9J9`TON;XZie7Uj?x8+<g>j^I1O8`-RTk1-_f&WVIqsH728=B2%A&C3;Z^
zYw;tA;>&5=&PBye_~L|8MEuucAAHeWw_?IqQ7`wBl-QE?+>*?%C1+T{5HhHs6j;yk
zhm9AI2TEhq80o59oba-muaHmF(#BHcM{-%KJXZ@mqZ0}fkl@fplr*vOJr4smK5}oA
za@)Bm4+-)rhQWeVD`=(6S9Z!Ja+&E`e2S_ZPCFIL@)h%}h*3dAZyKEIQYFK<+wC;O
zq84oVYem!HGRw95l^|>-5}f}sjb{;<{fMo2E6@GlD|%Op`|0bd=kC?4m_pP_(6<)E
z7s0BpU#r>hRck?TW=o1Zg0jL|4f{s%8mD|<t&zcB<kjXb+28;+KAvE?28*Qy%1}sE
z#hbp0jBo~tvRZp^-fpbhL5in>5Vz8sTv9&IrvdJh-^!0EWM!1XA<R5tG<e+(oWB(@
zjj7>w&o#pFjwYi`gz8MR&N~+r%A|2YRygEVz|bvAdP4&vSeMljZU<{%%dLmU)~ka(
z>#^`pT8*5WjfVqu^RG|c+3<vd^Z8*-elSEta22fqtECP9(A6Zh(sX;)=F@&XlCPO~
zSeE9HUYM1Ru%R~RzJd2hLg?g{J_5U(M@v;1PZEx`R=ZX3TT7!QPaU>mQVVuI4j8lL
zu3KhlEo1HwDhLIEF7332A=)PIvy57{8Cx(g)Km?&^4~^P%*Dd$sIBnXyknbOEZv+e
zcn$^xn}Ko1ln3{1GOUHn+!6+R<k6;Q(S9tK<NhG`!!no?8FmG9?O9p=ulwBVb2_hr
zxm(JZ-#)n3vUBZoI(*fVXWP4KMxo-7(6yg&U8wN(ZWyS}y9@dq4t~gu(5c*nxAnlT
zwNTr+hPnm9JKG+#i3s=b`gD(a^!yO&DQiK<v(>CEvldgppS!^7Ltw5hu*0EzkLLLn
zhq4wrx<Tvvbw)KtAvE|v5>&$4YhIpZWTmTL-m9h9YixDiR_6xDyU{7W%Y{ubE9^!}
z?hQ{i#E<)xXTG=G`gS9o0SpXm1-JFFlEG-UI<5?`(NJHoFgWylpVs-KK~^^}XWX>Q
z=!;SWU3q&`vh5~br@!+fl=u*tGJi9=ygy?enKjf$8X}|%55%esT>9Rhqt42j%UQyP
zj2QZjZ2uh1UXvkE7vJCbHmj?2@Lcy`Hro)3;!uOt(9hNZ!o$J-x2=Px21dTOj?E8s
z9&n78UyRflnrUn68yc9OAD)dLT6#OQ@^+XDGkjaPdU0rozZ-J@RQ2TH!+iSAh%RDu
z>ut-+@`C5_qiWqF)cH}rH>2xpV-gBudk>odY*u{P*f+L@*AK@OzKwxA$8c@KDw_2S
zKlpxFnHQH+&vsKe*=yhxnns9mU$t@Kbpif%DwEO(ZvvuoXdEp;m29t;@|<|^aQyDW
zc)rXDNBp?Tqe|5u3d$mr#;zlegmsUHOdcgoewd$}kDWlb*C|v?8YxYh{FpTJEI&3(
ztGG|IWiQ2wOl4|K0h5X@2~!F3G!M@y3*E8PKZ-p?rhVT{dRtFlE}aS-E({)?w!J?c
zT2XLTWahLMfXylduvs>xGjY}hVUK1szs}%7@(9+_9J=(A_H@!=NN&O~UEx06qh~VP
z^Qf2Z?4^+DqJ`;_irI_9vlU7+RX=7iEp$D?V68O|Ibn{abgos2+@2}L_XFCaG~Y4I
zUGF*nI%dA#I(u+<{>l3MXl7QY$ilYf0!=r2I$_~)$--Ph7WL6W$-%-hJ84ySQN?ZX
zu4i`PyR1LRi|peIPplUoiro4|THFfBuSvM|KJeBXYt46$ZtZ=%wZpEsp}Vx}va~Ov
zdr-0TzT(yorG;NVmhQ?eDMXxtjKCSMEIZ{b!<41JKU&WIxD4-*=GI$rnONrk;|Q{H
zMWts&q(f5d=L*tcMY5ydx#y~)`KnyU3b<0>mMWs+#;P%RM(yyifB=q_1Akk+lCC@=
zbhZCBFJd)hlLP&e$551S*JI7JX4O);R`&7Q`yXpq(Iq{-JBZVFTx?eKMHnuY-eDWL
zv)9daW(4v6Var*YC5w=|=YGnK&EF{jJD(o8E3|Sq3t=Czc)R}8%}`On4IG>heGkKN
z7dIm9Kf?1uYyFJ;dU7rw$DMoJ5_d^@_ku+4iyph5jcF-Rt_u>qmyW+*`bTrDa)0p8
z`<4TDs%##dCfzB7a{WkHYgQJ#_VWRGe66QLu=n&sb{BTuu7|_Qpt`Jw3f%HSs*h-T
zz0@m@=#`J=POnJ}Kf3kv(X!~{RlUb+ryt+F@_4=S@q;TfizAPp9R7T~A^PN*-jl7<
zPhMVmvR(P)&B&8?m5&}QKiLs|`cd!c-sz{3@$8KuPrr>k{j~7l$D%+Q89w**DPv+8
z<<thWY6GVK^y|n*ECyD^2Fl*p;JsB+HFSfoYEwT5D)eMi?AInr?3twgGpYBBk5507
zt9qs|`b_D`GnHS@RK=dF-&)$zetx4A#<a=Fz4>(MkDA&QrW0aYn&In)XSPIyH%zOx
zEJwFqotLuywY7?5#Qs7oYrJrI&v&%)Hv49cvp)RfTUOqc7wl?Krd=2${5pfgOYJPA
zB9;rb^D<2ARfPVls57rFC%%fQdKEYND&fhi#9yy)V%r4$?YLi{-IPY2!}0qNOuIoG
zob>A<VVp@wwY1Rvby4E$lB(BbqpvHTysrB7nj-e5R{u@?nKzAzZ>m&4@a1?tA%xW+
zKqh#@gWpaZXA*}$z?Z)r9DO_d<n8FMw^Xrr6Z-FHXWmUGzN1&Yo3sTBEhEdrc!ddI
z4h+BtnC=aQXX(R7XOo2u;k@3+zU;Si`tP^SynmVae!J@Z8<lqpzXa97{N#6U3m_OE
zD51^K_XkxUzKwqP@#MqwllQ`cjZEF(yzmdd5_h20JFu~xan7Aja(~Q^Gd)3pG`@rQ
z4X*Q7?;@*rk1Jjm8QT^5uq%G_qk!E<X|G+0oR6{w9~GYNDsz2QS=v<_Uizrv^-2EX
zC&ipk$ErV_%=x4`_DPp(&yeer!PqWj`JG2Q7ad+EvjaKm4XJ$%vO9#>AN_12{@Lat
z1bej1<8aU3;IrG|-l?TM_ruSw7x&M80NH%_T+6y2VE5Vc!(PzS&(0tAt&i@zdF@}g
zx*y&7Id*BkZuSe_;7i2e{-vV_=MBCPE`APs`X!y~AX9ulap`lMK^bS)sB6_%_0ya$
zQ1HsmuN3ibwFckny}qUHer+6k);#w7{P4FS!M_YvL4dA(A|&NcL;ti}?iu%dcbBv?
z?s@J`S)Q)sGwx(}#{w^Rvd<~NUN6*kOLlWC(Dh8yc25D^b|3(dmNxNp&2e=su(3?A
zvAm+=nRd)N`j~ahNwY{`e@MqOUB@HU)*?aM9r$=f$35kwYqFWXvzue)<?!s2=8-2|
zh(Ji7<(91Nk$TK2N%s`V-8sw4qrk%%`02Uoj!8P6B%lXy+&SsA8(Gr@uj!Ve?VcQd
zfq2q9LdPS;7!!HiDapk?@1$!=SP0QOx<c7DF*pFH?MgW9mIoBVH0|Pmq`}xH>p~Dd
z$S+S)$^xSwb~&|1-6`4EGbjFX0ZQD+%Pk`@yV2o7q22i+4d+y4EJ0SvD(YgI%f$k1
z*EEcGX8h$`MVmxl&*F>ci2-q?7H8AkoH9KxRbaf*Ezjj0v%h-AJvS^Q)j1?5IwI$K
zMWl^If}2BvlO5jCj;M+y=y@b7+b5m%K5yoibHbUBl;0K=n&KIrXX2F-L97lq8xo4I
zF!M~o2Iu+56kUlaNG<Ack1Pu&G+YkLyprAO7G8ox>PC}l6Vj^FujEFArb(H^C1f<6
zbiAtNkZ2W@7oO6nb2|NeLaE;WV(q<ynr_r}?O!S(w9rEjMS2NEq!W7Yy$6uqi*zBO
zCe%=+DFG3|f&oS821Eo!4OURphz$`m`dUC#PTsZ4T4#UX-e=Ctnc<Hx!!QGc3|!BB
z-&bfg*0V(0DaYNpFpGTJ*uPZAvpBJcY9Cc?=v{)(Iu`0zmzq#{$g@~o$<rmKCeWLt
z<Wy)FP?3>ZSX@7llTj0OwEK`xd3YW*?+8W7FjCL0sJio_6`mv^Y3S~FG|1;zc6zmn
zl7pI>t#4dyXh6+SdwO(Oy_}50A=g|dy8`Dh(vj4<==`pX<g(bqN7b>Oh4~EzwrO?5
zrl_#?(7=}BCR%C&ImoYVpdkrony8}}=;u{yY?vPG-#B(MFUY^z&$Bqhm%`1hmK>Ss
z?wH9w%*bL)-5e{N9rA<y3vOTEyK>=8Py1ayl(~sPbXi$rNmf;uUp|ZVsjB3PuW$VF
zGQ-h2{di|zQO;Rfqja2y7=_X%C8pVZcD$wbT1}4TGrCxyhm)z1ovTZ<jkT|vi^q}7
zVh8)kn5feK5$Fpp{x?~Br;6Ute;w`qzbY&LKhD~JY>yrJ@VMso%n6sLDOaAzMXrC$
zcflLZUovuAby>p>t}irpCAm<>zP!sSNeES9NFM3FRzFL;Gd1+}BlBA1{%=ioS-JPl
z-LqjAbWQjEk+pZb`e!riF>~VupHk!ReIU@A3k@E{Q;Dca6uYdf{~8X3Kfr|Zz)?8M
z68)r#@Hh+(&5qd%;O5JtM*eC^Rsb`)L74KK@JcLvG@=URZ_uCxeo2zIFrMEy8KZkS
zHqvq*RVruUg1B_MF1YMoeWUaGYhs0E?T$Myv<*S82ObEV!Uq>}-fL3#eb3N#6zV<I
zDp6+WD<U)Vp3(_hHl!T?Q15V(#I?K52V7TIxPwzXbM0;SiT81Dt$TmXyTg!U<c;1k
z80R`g@x6h2-TJN^?9|zS&2{@dU?a-0p}6u`|G{ZQ13x%!UqRg9j7a%A&vOyT24kS9
zo$K_7baVXigFJgDdya_!IFTj&r(4IDkgvBcEk9RvPngF<7Q>&$GtYA}v-UJbpSMUP
zkF9M|HODtMF@v0&$r3JyyFBB!V;9Q%w=4zh_3m1%qIEeqL{UpKGte+9c9v6gi8jkC
z<GctHyoDd)MunxO%}W|!wc>x23#Zeh-vqsyMt-}s%&(3`fgzf&fWMYBD=>d8@l6Kn
zLJU7RU*ptUtIj|ey<!1NS{G5Ai_Z67Z`ddb64EVIQ!?lHOxNly5o#nB{W1PNZI%aL
zftlr$*-D*7@^zvhJYj;fj>2*Uz;_P0IrnT1mCk+YEKgoGz$sYgP!iwkayC=abIi5I
z{UO>W!baF<31f-M%9*m_Fg9^7R}1;Y0$#+}%Yk_sXzO&bDDN4VXuFB0gPMB5GYhp4
zeBm`@^h%ng=sAV7>q^X;B}V<cU;?UhG2!7ai@WcHOl@<@O}=~;K6nT9TIe?yU1oS^
z#!leahITn3{sMdRK7o7qx}ek=s|;O$@R-Ns8893$X9%-pf>mf+HCG0a;~X7S(GQhg
z!ovcTdpL9vbC`1|uGs@0i*1*suVN!+@a`|UVo^jjq&5Ujq9WUsukq066&k@WIkJ?Y
zx^r}*#nwv!8O*GTB0oacL=NHFY9YLzmkLo+un=~j&Y~S<;YtiDB;6k(jUmpc3fPpW
zd_e3ddLTq{z<dPKj2L`*T7zLB7(|-kW>GoJpkV$2Hp((WLHyjq1<l#W$&vw5#S{y>
zQmm9VmdV1w?C<&(z?GLu()Ryck0ZCg;+-|E`UT>PWI?$iuw+lXETRN;P3{qnLn+Y$
zQOYQlFUFK(gc@LaIH)lDa&-SF6WT$6NtdRU+nuuzZlGET3lZVMnN*HC22A1DqM$?a
z1^F3z$@Ao0gmo|omD5_L)PRC0LD~6jT#x!3K(b0*hw!3HHOKMg=eIG?L&~Kxoj8(?
zJBX_SxGr3b+b<KNVPNL?d1=D+rQ(}&Z4$2+WPVYKd0RD5Rm#@|=WsBa&X=52YO%B{
zv(#?Kg3r|51{HyaE3v})sRkDBtQlpF1rhLOY>6E2%ThyB1b-Ft8n>@I!p56H#U1Aq
z8F*AL-wPy484!6=Ss?KxB0`Q`f=Hy1B{~TRwUtstv_+W%J7um<1M$<p6NJ7pA%{k<
z@mb@?BziID^sx|^7%Y+t{!Me`!;-s<pEn1^2c}AU2HDd07e;-DNbL}ikBrI<l^@X#
zOC8^~B>2vX3kvI^uSvOwmrUff9LPU)*sd^*D8#6awlv;es(qq=|IGIhZhMU-PYhUc
zpN3~|o@_f<CQuwbt&ucZDMXV=_-EEWcwOYN0MLId`Lu*UX>`3j{kk>$auxAo1b$-e
zn`X|`(`TP6A5XsF`ILKwi)(ZI%DA`VBVA*;XFr~Zsy;ffdGyCb%daoZR{=Aw6t4BB
zfW)X8MA4qew}d~Zkb~h$rj?%lf+t$%%tr67==@d-<jx;emHfC}VW-Ys?r)t_&Z;B}
zcdm=5otgzkX;rXv?&^M!{6SlUsaeA-)mi^}U0xm6LiN{jkg^3^*DtQV+~Eg|0~|j;
zd|c4w{HDZq_pq0yvfi0aVTFv{TdJRRT5kjkXgBUIVYD-<a?9Sf^zZK5L1J|STNA@|
zL>=zPbZ1nXPezuZgzm~O>ry~28>N$D3{vPqx8UvA67}(A3Y-9=rxNu1pWM@Qckex<
z!H-{=<q$#~>6c(aTswZsZrH=+eQ(FxcD{N*3nl5FnW@rW8Rr=(v^|%7lyYdT7@dpA
zqK#lnuZPnP9US|t3eXZmgI@D^plmt&Oq29UmWxGM`gYVLM7-aGnD5fO+sab?q-WdH
z=bFTks|7Jhk<e$)L$6Ha@+8IG*n9HV^CMIDH9i$w6Mz07^m@&2o)3Xv!AOLgfzYs3
zs#ggewn8Az9SDW`9W1z?%pN5FuD4jFD-J~>U^isqsuXh9l%@CGac!^jXAT}MGkNSY
z%ppQcS26zrd^62;_YBQY58_9g45V>p7E;=N1jnNb0-a);DOgm9tci@_$<L;!zIPI@
z<wQMibk)AAcEfG{c&76>py5kR!qF`<d|pS<EG-_*yIlsqA@J7q$Jh_>$Fh$lBI)!W
z(}MCYIUJc%;{0$7`Z>!GZOJsB<>Tfv<BoTSpk`6!b2k>&sze=SdQ!O#mRfLKPzDX@
zYQ6Kep5Y30zozY*#%-ZIeVv7wvi_NtXVFCGavUua4b{rmIo-owey9}FL@!rnP5;2_
z|5k-+lKc=6KNgfSWI~6K8l~O*fw<qFPlmlQ%b8|f!2RCeIN6l(QPAcSZUKZM4Q1cz
z=(=^py+q)x+ddY$`P=9D{OoCZ(VtJVLOXs@7!HVyJHZBkfN4iS=)<}{j$k|?_U{ts
z@5N$h0PjM&b<B}cU!rJi2A6V%9!J*Q&qywdV$yPCdUU2-PCCRdRy8MU@=?s>_hK|V
z=xtjf9a~}(4H6kGHZq7bSs|MJD6teNHM1{O@dc@7m)hG$IOb#`S4yS7mpUt#d5xB0
zW6M;cO9T4L6z0ng`b&RfmU)574eiUNqsy&G<$gJt8uW5`_OjlW^3;{`e9MX>2I1*B
zDmkqcJbmR*Mnz!`o}f%BLF3tKI-biFvJs@p{n4;$fBD)S(syAp(Vh&CCO4AE4^ELg
z5qR<rc~7{qCpL_LE<2Uu*FvfsKzN^Bsr>Y<@-qlV>lYmMuNps6IcgBX4pEIgteV~k
zprflTj#SNURQjXKZ!9>^k5(_WR>y2qQ}n9Yn^mSOWe<1kAGFr^Jg8nHSv=pVAq&>7
zFX+AYuboL}Gkw*kqqQ^lYCkU2KJKsn+^@RnUssV{x1+51bF|LmUfrJ^d0}kbGMZ8W
zu7mF$K(tYuhbi3e<$+y_gh0K(Dn=-vo-4f`&57Y1t4H6fmtMqR#2P?46iYNwfwP`5
zTCUP2C%)S7`EvtyS6aug@q>1Q{=SNgL0cnhsL^Cm`rvNkI)9TTr?hoI(^^`S{jMa0
zv&=~hW47D$lE2w=RmwY{nbF<kKPC}4);zM@9BL?m7i+nY)_mAOGCH?qw7w<YK_YRr
zg{Iw-nk$}ec<hwNu`EOJoVH`#pIZvZ;)T1%`uJOm9mMkkT07HPNdsb)W38>rt+jDt
zE&*lr?^~dY4b5W`rEP7ULv5Xlt!m_kF0us0u)WTsy>AuW-_~CBvhAFM7<;$70Yqw7
z?1;*3I~Ln<A)Gui&~av_WBR=~d$;?lSo@TN;DT*uhDFECHt{6~(ZyT=&BvXv&z<~3
z+=(y256A-7#?Y8legy6Kv;DE-d2yYubC0oiyWiwy-WWJ>g1_UVA({}I_IXw8uYfLU
zIQc8Ni<+Ccx7bxD*1pe4ZBU^?pR|n{QaOyoevDDumZ_=QMBbbHsBzIR*lvmLE_9w4
zo9Q<%cS{?Iv3I-cK_p+xo&%K~=SV%}pe}WB(MEEO);RjC;mH_}llp-oFPLCKJYcqY
z5=5mMI-=XC++0+^{tUncz_HlgY7br$)G1H#Q;P3;ee+KFx1S39PdlA>Uxd-$cDm@i
zzS#D@`0>8PCw<93|F+Ym8=cPlcRStbyz$coPfi#9{QubL#4)e-Y5gIxh}w9Oa)E&+
zBZ&d`fuJF1>;Gt{%hx_WD1H{CKQOF%_PP66AyCFB+fJvNfBVtD+v)1NGv|zi=53EF
zGsHg81(#RF+VDIO?D+?Q=l=&g-LrV)1SYG`lmE#o3WP_cu|tOh(KG;Lg8}|^v>R+p
zg9g#y`7}fa4LL#MeoEstrr7{+pG~w25-=g~zlal9!Jwe2C{8?z0|2%i_+^|#)0kjW
zJ9*WKVfClOntQ`oiHkbM7xjWJ>hI@YH0Zc!<a7~E0|al0C9?#?<xt=9Pyhm$M*?@_
zQL9;~(>kI`30cO*Bi=zHzWF2m9V3DH7vWUEd=DKKgc4N~xQXQ#n?QY16@UYx9up(U
zdzVusuB01Z3H~rbdCBE+OP-_tiuy|#&Tf^O<;$7IqoqNk<@uvJPe;OoD$=L`2L<3j
zjn#DkO=@F}Tw@JRW6d37?FnPYZ;f?GjI~#d_3Vuua~ePWVXQBI?2N?t0N42Ws_~Og
z$A^L@s7~V-^CvC`jSo+ZkKLM>*c+d$nwSonYz~45d<egiCh{E5g&+Vt*!a79lR~H|
z9_-X3C(wO1h-GW)5~iLm1Wi4untC=d#RE*=SDSttH2orI>SfjRn#9zH57Y0tuC7i@
zze|{ARRNn$)4NZnpF2%`zcqa~fBLH$oulCD>wNkzWBQj5S3%rUdrz;zoaq8f^zOIZ
z_i<!-8c2E)B#)Yv;hvQ<nU!6eQ4F4yE|`^fo>l%eqt1Ozb#hjBYgQxpnzs5iE$3^-
zo!3kXuIX-F)9;)$t-fYEc};<P&R%`aY-!HUdCpPtx)Jx>jlk<{n(yCvJ<z%IJMDVt
z7Ha6nbzT1X59oh^TTu2AUjew}A8^apgXHH)_HeH9aw7(KSNphE$jMoIxt95PR``2X
z*xO{YX;x2-wt;7Xp-&NechA8(`~DD$jlm2&^4*=Q484oelFH=dYz)1QvLmlb3XYyG
zr8;&g_l8jZUX{Kc6$jn(^*!=ET}t%aa%C}=`c_G<j$|Kq64oxoBB%uGoWl+}>bmCm
zdX^|C*dDY_)^^DW@UA-Fpq3b$FD+y7ce3<=V|sE$eWCK5eq>h_wxKNA&y%z@&--kQ
zZ*5fIbUijDI{fVn>O`eBwNCfJFrTjnIV-Kw!piKR>k$oyBYQu07H{5MTU*P{AhVN}
zZ2ILHTWRQ7VB}p89GU3qn4eMHQBc+67*U~U66YIV#Rg-^aRmWhH9>wAsy6Av!y}QQ
z<iF8Z8k<fvvD<2CNyY3quAvXnEvh2+aCSyYX;NH1KC?MGBAd<jWc9p{l%7b5Cno0B
zhNaiXW>hA|63zXI3bFyVVP&K|l98d8zPd$aWwmQ`m7GyXWKNs0AF-ykq2u_8jLf3A
zye2c>qlTuAa)<oqZ!BbG<%UG0gvaL`vi6USPkQv|{=-KP&YU?P8k6o7oc`wR+vU4A
z)6&v)Z~?~FUQZw2|MYPy>Tuld&NmGUyp6phuZ#@_>*Rqi$Sv=52`M1fp7IQi&&?$J
zCe^cXV@l%DAn)?HqsNQu`!99I>bkOjOf~V*x!!K%ToN_Nml7TpZ53E(7eWa1sZJ?u
zb+*q5^HDmSRc~x=?BhYUc8fOE3vzI<w6!y8Bbnh$ldU{+z1+&x6+K8z{pafy^&K+?
zo0amiYCK&sqwzJtDb-pI$sd314@7*FlXhT7YQ5d+*hJIZIKkPzObl&Q(>7>lnXRSj
zZD;PA7+Xpr*0HIipr8?@>$0Ows)n++gG~{V$8@|m<xFFwzjw~q@J2_&qL!A+VBgxw
z&btd&f7FzX73W>h*Gpv6tVehD6=ij^lDioT`vnnV3i77xVrgh-G8=latA!Vi=|8?G
z`9H!f)V>31gYV>jmsb6IiLa^bUxy@&C_Kw2?Hj@8yDts=ds=nm%s=aa7ycU~-Jw%`
z<2iqA{vV8V|4gg4+M55XkuLAkvq%4Cq|<+TbT=_Y^Yq?Ht{bb|!-D9^L)Rnc8$W0a
zPL8qbfhV21T&IjS6UWXcyqIobr&a%Tjh#ItQK+Y_#(H(_G3>X^-kzx_Lx9y?v=5$V
zDlrM7Hq0^*MgdU_0#^gTp*zoT%u;O|ED;1c+!|gYQXkn~DpbDU35DVN!vRS%jvkWw
z3F{uRc;Dzf)3er>BdQE4zpj&&jYz0;NUk!40<1v*O3$;_NH=@W7};tGBZREIZ))G`
z27lkL3U!jMaST1^ZBU=ZOXml*k$&QjdaXjERUWk{Wi2u!B6WmjaNqGQ(eVl6oWh;j
zj^yQo@EHiMnM3T!>G1rY@B1x{=ikfQ+^^1cJ_U7o6@DC&Htv72t~}7am)Krv8%@2_
ztm^;$_QSXCafADTf&(56bM*70fr@AQtGDxn&zrU!F5wXu3R1VYp!)WMb-lvd4{$||
zTa67>m*E@bk^qoo@l^kk#g!+8#`9NRJO_F>1L^qL@y)>mFgI)d!{GS#w8W<=*7(^^
z(;o#ClHB(_^$?!-n!GgtXW@eS*`RQgxAXy`ayXq|Tm8X^vK;OnNHV(sfFA&GWdc3Q
z-NhI_e-{0w`jxFOx71I|W{6`S|00OJHCz((^71HXxN8qe5}XIesta&QXLF}>067th
zT7hiQJExF$$TuM|1N=c4uXEZFc(B{c5yXY2ZTf0VMNQTdUP2O4hiK}#Y~c1;vh5j@
zKk2KzL&knJQAdOzw}`3MD|SEzoRqqTl%ty3AY?DO%p!T6pU<xLL*;A`<SQDM+?_EP
z@H<{YvIST1Vv@(fEzTrKn$59HIu|;J8{qB{n&lMi$m}7jFk0&^;9gDqBxFqt%2Fi2
z`M3=xdc&h!D5g$_OH0E&O<!2H-@RN~c8*XXt<azP>%qWDLyzH-AwIFK{6=rcJr2a-
zTM85d4+p_YtjBeMm-#mEUIMquVK*qAEuEmdm-{BpaG#@DsoZ1|)T)a`*>iV~A}|Pb
zMz>JTPKo|&6h!wyw{Vd^=z_0-$j)&n+5>NK*4~1{8rRKPh_OaXT7Xs9t9^3*mYVyQ
z8O5j#qVRd9jW~d>5+?C-`}ISlqdhnbCD-}1Q8O~$?nq($OOXKPb>RpK@qm4|aDQa@
z+=CoJ(cxb7I(1Ht$}F|_2BC_SsgPrs3XOA26p&-9xkji|JBQ0rONEFiqrgG^M5H&}
z^6hIH)EA(mH2h~|UNefh-MeA_?hpyPG2yA2UT01f7+{%3wkwbmbn1ub<Y*&RSRP0`
z?z-|NCj8KY8I<<UYY~xw8B}mBlx-SQp;KT$f46XeKauaaeVN~qWz)B(TypjS(q6-_
zMNaw82(42P#uPc|-AiTC-c-v&lM!4Y58zr42r#8}XC77DbCx7#AME>j9oer85osZm
z8O`CS#n=*rH3J#+>y+r4WZfaZbc9tkFCYQ{B41Guw)j<OnH|);j4M`KiXdq#mr3{%
zD%AX0V&a*&AKVsT3pAK7ojxn9!>abEmJ_WYfq+3;DM|c@YH~1HN4!FxJ=z5pGr+vl
zSvYt`d$8W<pcUINSGv%>oe_{Qv%yPrMyC33dQHyC-b0{C(muuxKAg-)m+xLa&yx^y
zt36aUn``@F^I(X)w7KAwyH;!Kttl>vUhC}*y#6?7(9^&ta>fCJK7(oXw-X;S6jzrG
znT?e^+aBnu27_};;C~yE2y8y?JEBptoe;GLSnLCqmqvMRTKnkK81yo)T-_$55<9>z
zvk0Tt4}MH-Jj))ExH6`)a6YqW`04vVKi!8@gIQ{g&$jb^96hk^`D@xK^akbf<c7^s
z?)_WOXU<)jVtsSUe&zIHYU#?f<rq*HmHy)Q<zCJ|Q!8b263k}oNqQAeO6PnP6Mo^%
z6t5Xl(O>7~vC^JdXfZZ7i$8odcJx}X;Y#5i*SbJP+1%3uP2?BF>%tSQsxpN`)%(3n
zwDt<-d^+NJ^ipJNfx(R)&osw-pHXr@(8}h?3$;J;ney^u^Ah7}*5=H^)0YfPjBr(Q
zXO<e(*l^3}Z@6XBh-Skr;o|gpH2ARIgyH@Hhr)}U9>YMe0+l0Y{x1%&-aE4!hb3qR
zL@LKoaN^D`Lu+?lTIBYIDdy+0x?zQyqD!0~6>=|3j#RI0S|8m>gohwT`iG#*%3tO8
zqvPNLnuHSHSA>Vp?a!&h0U-F?oEP`9))}XsP2FJT<E!&CQaRjxv0LMcQ}8TW#nG+k
zAcfVNB9|}9t{Y*`2Cm*3)EU$m-j0)a{bZ%(@|7Fgs8qX-)z_}smLjY&pMsaqw*Sly
zJaqZwkvoG{UdW!Vqnyv%3&JRXLB##-6kWm2`*1#1ABeGC5~T1_OLOF!68N*>q2Oo2
z`@?&Ryo72Fe@RI`@(rtxZ|fU>EphErh;&isFj+wbK9sSc)8&`2fR$hoWeV&n{}P8R
zi@>K7=3vw*Tizpad;{TXi7LQUQ_uE_WW<*AKV`su&Vgo7m|4E!mtUK3$KiOse2M3T
zZ*X)tI>gRF<0FcTc4K`z@-DwDR)DJxM+Hgy+www-5e22a??WzJ7hJ)W`1coc$GF2*
zU*x5c*FwO$qa+1@33b9*vOA`n%&2on1qzW{4-Xe>{akvzsz1Oex8SvK#8%a%LR<$Q
zx4?<iO5M%~o<!xNtFm_~Sgf_6fVn+7!u+%45@_r4jj4}Z=YCf1gvt(enJoHf=gf9R
ze7(iTdS*(gzSPw#au|PYUy|GH_tu^$*cbp;@XK+pJN5o{y<j8y+!dl@@{%(HYg+3_
zsoR=^f^D!+2Zq4MA1Us3M?6m>^%!tJKl~JhEej$%_Y)YwK@w7lXf)T)cVR~v9D=a|
zuV_e3Y_Y-y7)p?z`9TZ`$0(;lH8;4XQO2q}vHTc_I~dIF306d>r##~397?@0Ut+Wo
z!9|TW%t;@*oM3}EkRX!ou#xCwkZQFO<FSzLWnX5i9OY*at&&}0N-cZwCOybNAS6c)
z!zznZj`4|&jN6G$Ku0BQM5nM#6QUJ<+7))O6=CHS`2Gsr`HJl!-ohPWg0gf5mK5tj
zdM`^NZ3tKHuaNA%lPC+34F+T#Uvi6mX+SI4w44l<JKEVQbOK!|rC$kqDb<S(>uaq<
zT&_Ha#t-gP?g>{7`-fffuR1eI9`&ze!!6#ds_E8HHr#r1uzGGMWIm_*X>;|>oRFn{
ziA0q6ZM5)RgPJj)nn%ikD`@HdV>LQMHP3f^ndn;EgSD?0T;Ar?o@}b!?6=)osa5-0
z%TiYTVo+D-S@(TIX{WU=V7TtrsKTF}Is*X;cu@`-K#@(SAPi-ZV-(0e3NKj(C04(!
zT`x2yEs|URzP?^OS6Xtl{>|rljG?rgVZ%$02E|<|<+g^WLk;S2QkuIB5BM8(RHXC*
z8X5a(jRx-}jm8>pE;pX(HZmJP;S8I`J(_F-B<$OoE)F$0i%GcdHl1g~tub*n+!{!0
zE}tR!iwOj-HlO<3j5idISQWEeZH_W*Il+coi(+iJ)&999l`O`FTP<w3<sim}TMa|U
z3OL2saI2QTwK1*5-=Vd53{7flB@eY$=b~$OTg&*{8Vu1*0d2&zw$@$I_OZ63%WWsd
zM5(#xGrCy3VS6`Ow4aPFS7|=m)}Ha1Eu|A>OX*TPIxeq@u%&bfLmiWCB5WyL41ecr
zfCyVk7n#<%ASS|=(v_}M-QjFxOX+kCk1NW;AB>6JZaW@0bbO60{CoiQ*M1g1hKl<A
z{WzNcgsg?k2B+ZWF8@=;3GL4(GCy<1J9K^76=F;2T!y-SsZ>7N?Xrt2eU~e)twiM^
zR=_H$kej7o8kPG@6I8r=zMCraL_)+!!Ys8LT;HwNjf@I!myG9^HtHGn=ut#Uu%&e8
zhI%^EsOsa%f_Z3bfs=|ad-U_f*;2Z2!;^g=O~cJD6GuU|l<ozZYU|iy-`?Bh(d)b^
zz{LW=v8TMn0o2dlu5PYNED(%w3Wk9^B7ptl#UBH_bE$o?NZts8f5I(=<@WUdBitJA
zuiiH*uV(a9#0MIT2ATo~TJi>3+XveJ4Q>VUf8QNor&W6c&-CS;>2GIuyjt#!veT+(
zXyRvwjm};QJbO9s>}dPhaW>p~a(4RXzr(G$z;p9ATkTWN{Z}JhyTAp%^M!p}iuS<T
zlk?Aio@a^=t{V-${)drnqkV95d~oZ@;K!eXtoXrKi{eW&5`waa6T}5}#rZ!+>Tyv-
zeVH&j4Des!)*cNdF(hC-Bos6xl0SrgO0&a)_Tt5-nfzh6DE06JMA|8^>@YDL=6O^8
zzkyp57fmKE!Z8pMzmA>7AzkeYRo%mCk1sk-TylPT$#w6NyTpiL0sy0l$>a;+<)T0=
z)G!`pM?*zyirTA<91gl1oqsvD<FZ%K$Zdnm@&5t0^qfZS$HH_d0FnX}oV|i%U13L6
z^PgTR;`*C!5vxWk5=IMxMoXTKR&$Njsf{+C9j)pZZE+fF4H|3vFxoLO)+sU8rZ!3q
z8b3BM+AT5Or#5z`YW%FzctI7Hlv>prfD4j3!Tz`_L7?$l6O(5r=n|6<=EQ8!<fzl+
z*xtl^$K=$+<n3FNH$P0?mYBM?H+dsyY9e9kp3~Gq)zsr#Q!80PpobW~=PNwC;nQ&9
zG@^U@!&%f;KI)SiYD3~G%;M@-W7KBC)sGXXA8J>Bab5j0arM0#opbprfTwdf(;@Z9
zl_zxGUv$)#AdV(l`0ljC6G1DCs92(i@RGnYB_S#GfqjgC#4oyx<czopTHZwDK(H7H
z^v|U#0D!WK(}n*)QEbx0W>0PoMY6J%&i1)-@;2@c1U6K1wk>dVD3q14V51@pH7|F^
zLU%`khhw3KQ?WHJosEqgt&7#wykzC99M}(3y!D*3HC24rjc6$;Gc{$egD$!3p0lcw
zr-Fi`rkanYU519Lx0slbqMWO%eW8+qyN6Q=R>Mc-fQKmBkUb})@0Q2b17a|i+73so
zO+7Vnaa!uWY{I4IoTclObvPo$$u>VRE?+^x&e`thA>Cj(d0V#G?|`g}jz+*CeZ07s
zS$@Xl?qjcn1&wtyeT@u)mE_%JG1k6b8Jfo7%8ITwrk<+SX>7Bfyo|Ggylr|~Ayz9;
z%NVbR^^eVJN{a4Dk3Z8?`Jlh+gOajic5$1NeS(mXzKLPH0H1-LcBq9<zMa*P;;L@8
z<HFV=F*WIEL0*G_eo%O5ftg8UY;=aLRdi@jzPV9?r(3GDjCpSISY`2SO$no??M-#b
zLR0mv@PL*!%A@-7yK&)NUCl27y=snT50?~-nwmuArH&Gguo=qu>CO)_6809Rhm{m<
zj64gh%nuvt#X?~aQ^Qb8|3WX<LN26c%;8*oSgeU*WT0QJs;X;V+3}E&#OSER_?Xhb
zgxd7fN|*3*Pxsu!oTkdg{-_9|x~f-NK~q{`o2^9#h0>~~<nQQYrmO8CBV*+qU2bij
z;b?m#IibSYIYJU`>*HR84@+-rJLM2eaC6LYb12kM_ezXyA3XWFv|z5TVlE-FKQfS-
zpM5?v<>Zl+3sGTh`PqZ9VJF(^?{_pj^L4L?2&*Z|nJy}<B9p6gvP+8z%^K=%xkXLc
zN9yb>ij4H}u1?8X#t|NlMV6L<2h5X)I|A`(^+`#ovQiGg{)EWX>ay&j@MN;0wx6wC
z$k76FUtdqlu|_vHH)p#%BO}Af$#E?$O))W13mtrrNouIwk@C_ud;h$Ig5xqq@m?<F
zIG2oQ|59h0vhTN%#>$Cpi9MbNW7FMAW>35K)@qqs;w(%O25Dn#9L9!Xf1@aXCHwy`
zh4@Etdgwn<l!8^UqSu+=#eZ&^zIAHS&-mw3l`uKuKg59lL{V&=tnWXTsuGrZbY*jI
z=Oq7c#c8|ZnzKhVpH1Za)v|W-(BQLa0)$I?%boJ{DtIX3z|!AhK%m9qBPnP2&8@oA
zc=l42?!%iW*kVAJ@vjz)zQ4tQ<LsQ(zoDqh+fV;DDa3!-G!2Tba(y-ge<MEVXICj6
zacUbmQo@!(m_?Jz-reGgF7cSmtFdvG2U9{fF8#2QVO9iGuqY)OTiGr7;9(&dtF4;v
zHbjNbQ4IN5DLOUf8|-?Ctq|qwQmLf=C0RQeOW*Jcg%<mVMLrI(>y?`t$_!C;n)0h^
zy+^UHY7Cw%@TndCx*;#tTM9rxe=k+l+bjN?6ykNG`#*})svcIg{(l~TR9Gg=H^=x{
zsAAYb1pe=(s)4udiI?BM?fCbls(_fbfVYc{P?b*iTL3{7ivveKiR%Z<B>%Bgb+aEf
z#J|$qn-@Cwj*}4m6X+I^bfkAir2{1=*~Mwq0g8TKge^yVmNmHmx!?XC=nxry3+1L7
zg4($;4QByvds&-7!5ypx54SVntPn9(mN0zvgzEOC2R&`7DYCZKaqdc(*A<qlBG#of
zLw6k2PABMKtyL#<+^?acbue~(IV^b&h-8yHn8WN6Rf{{liFrXI%bsO3EomLJJ<F|?
zcRn8FeKTO};-e>V?K^`+M=oPJ#Ze)c&V+C<gyhO4)7hJwn8YRqr_^+6x2;xb=VvSa
zR1E);3~}u#>n`r@F01;5<D}sA_MR$jjzPeE5oM)!(u#|lsa7f#L8o2AW-N8zPzYjq
zR>+(?tWA>E`wHTa&SrUVKeV`^aitxeb6`FaGI#0BGAv|2e(?Gg@y{+QOTEkUqGN#}
zPz1$$xJ<?6Ydwc{IQM6;x;1wXOgO%=o=d7u!Q{tAx-LrufjLTN@NtAw7?<H10`;7*
zgF~oI1pq&RlLD}Omgnp)<$scdVfoRYc0-2l#ebxO4+6not`E}FF;LBbwe)%E(qG-z
z<;w8gRWjKREUfvx6Nf6b>9Io`YrQvK(B9`Q)2}4oR7(2LZk$RWZG0{U0W=Csjv|LB
zM$O4NQV5Y-a-8^`GVB)?#0+Wywx-Xjicqn;xh(ImuWCLl>CBRwSaM2w_DJL5*<}om
zJ0U?3(nRUko1sG04O%7r>EOZ<LIre1mTNx{M-ZShD-KYs+RPTLy<RRV4=6h*BWKH6
zp&&V$ngf^A@b%-tX@*)RkN<4y5v8`M@eBciP!mi&YWqw`Tw;%;)VH~ApyxpUD|=C{
zFV`!#hGY-?dL@!grKr@-QG}Oy<pMS+!m%D2;nlJXZrq|{;FpHhrC!BD<VC|1@v&z7
z*R(FtE2`FNWUD3@j{HQ_n@`uupG&k?Kag(or0sPRwk=96WUL;wGpt&F_(XeCsw!HY
z+4`TGrWtJ~zbFiBmWzb+^%@H-zOr@)1e4yDHrFm8WTiZ9s;YGlOnyCiP`kk#jTCfo
z#LYo9A1R}~dyx0~!GgUr`)+aAZsgCc)8?RYx57V-RIsqJ;P){`x#okey>nn)l8TFM
z2xnyg%idI=;Z7yqOIg-`!6*ZKv$RxKrQ1Ly@Ja4q%L*O#A5w^$4<P!t2e=ZMJRo1C
zUhyFrhv8OAU1)EwV=MxN^aKI!8FB|S7T6CSR638GLA0rghF`lEcoeFwyAlUyx2Cxd
z(_x3~69RRapy4wQ&n4W(1>AOg#6O3Jru%&0Nn{cyXCIyyLlcv->?(Bq51)itB*xsy
zMRivm?o}h7ar2C;?>p1m$;YYa6pbyu)ADdInkNZwhxNNSkAWvnCBQ#cK9=ZT7w<${
zgjwa6DD6`pK@Q=Pk|Obt8O_tZ{x*nBqd?S6FmRE}Leqn<c&!R8s&LC@AzNAJS!L73
zaba!EG~o~R@4y(Lzbp{hE|$S1P~Fi3Z7?N+dJ;NzmjB8(T-d?18to?GD;Ha@$Hk=a
z@EKSNc2W{V$5VM$+aE%-?dS48wX^ekJ=56_T|6%)pgt+i&2l)LI&^9Wbt4`+C1G(m
zQ?~eJ1z}WnZV%yZl^0QaZfC;W@RQ>_i>#It!R_V_E8t&S<xX7}9J-!#aPTELJ{Am|
zNu3cM_kg?P;Dk<&&c~%0gGK!#BmjG;5`e8#&4vIMbBZ(6&$b9;%w5BE6WeFxBPsSX
z`xr240j=)A^EC7olI*XcWZO-Ck|%drJ9SPNVDN}Gfo`OqFE<{qCuzn;2n8x?D9r-|
zL*odMr>L^TE;?DKn%@6|>qyv>a}92zuaKH(E3s&8upL0Xe<o*E*;~8Vy2(QL#74O)
zz=DeA;GvIc(106QuIa$_k&`*I)C*X!D+G7>>Sb$VYnSa?nFm4Y-Cxm?;gEp4vkOrh
zwxR}~p&qF{;%8`c#(K*<F4(6qdHWwtDTK%9HKriYKd-L7{2u#hm-CC1g=n-#l0c1t
z9(pwEvZ=;XbSCjpP%^f5S26_{9hcZEoDBeBtE^Z2rlY53g{`}hE{s)y_I)&QF}(ee
zqv)?U)ebpbf6BL;=UySTSx30%p4IZRx9CpdM@D`4As+s-f|ruN2nxs|J@l*uwKqQS
z%oF~yPL$_ANh?)0p^~HZt_hOSL?vr&NNYz3wmoE#`@8s)`%f@5{ZX~LTk$FP=JDJi
zXxOA%P~h0jmgi&7@{`4u-aKDd<c`sDd*X91VY#^TJV*40#68E|38UgK7mpOYeq*#d
zJx-PC|DCyRS9I+9S?Cpg`@ff}@*drN`22j`(ajs1dCz`+H|0>8ig6BWfaR2YnQpnj
zmO>Ql!evh1(3<{I@hPD-+2p~>!>Q1mum<m(NchU#>F-zW{zD3}_M?3N>x~y8Wfx#@
zvjasoJzX7Zjq|@YWsrMZI{T#$_T`&Li>$xiMg8$Qrts$m>hN~~5Ly7%FTfHlLiS5P
zh!IS=OhA#uc+f<l6-hyVqV8wat1k;*rxDRRLKj%X(0YR0itv39Kj*MeBesyeTBT_q
zsj*XR^%*WIE2cvdlFlhHe#xz=om8NQL4-#?tuI0KbHywpZPO6CvMMuP7%5z-QEVzg
zn*auv9V+HMl~%0VU8Xowc41D=7hR?{L*%e1=Ls*5u;&kHhM;j^VRukBs-oK+#6tkN
zQ^DN~fCpER*<X>jQ(m}Jk&h;otgxjJq*4;8td&%<QK7KU0OXkEDI`)On$&1dZq6YQ
zV#ysl6>S^j${ljP^55NQ5(&^~DUVT>PauInED#7)HH-!%QY$XzRE@His+6l}tyNR~
zRR~%Y2m_X)ffZO)v!hiqgzCkW>N`8^H_(8xa4NO()N<vJJ$Tf=N|gp;tW+aVwL=?~
zqa@Jl)+z+Ea)t!Rp@1!eYI7>Qk_vv;5Bg|O{ZYC0$4c!FG_Z*VR>SKqqA6EerC@Os
z2$?e6PZ_eOaH>$a+NAEq);th#NF1$N+o-wIUw6U3R*h9Zm;;?bSIyXiRdJAROx3T}
zS_eD~K>%N00f8t`Edrp%gi-ftP<Kotm<+=1g3ZWatYM=T4Gdy{92g*pRH)fv9S<kv
zg#pD~tl2Z5`JzF+kXXFPYWa9;{hbw%768`CZ4x)EmSRBKD4gfn-)jnIG7UU~Xi}iT
z<EV&(4iFrQqX`eTqqf+w;OA*A7#5sL0IAV94ObCTv|2O{LS=G0;UMv2oa_<G1SWR^
z0FGd`;Fz#DCM?yVxyP`5+MvdG2xd4`9Kh+If>C1+;XY}t3T>-K13VP~PXr23U_kUR
zRr&*nI07^=6>6G_u)~4h<{&HxAafdLC;_YouwRgn2^1dEE<}|H<Dqa;3E(saQjP-c
zV1NBi01^j)5datmAgL^fI|C8NKqO<pPBhNXE628IPzUzZ3ynL)u%TCs>P>F8_278e
zD$vA2omoW5j<$OaH4lx|Wc#<!5#Swnlv=9ICIS3m2VBAAW<UGTEch)3;$U0Lc?QIT
zfxK(jdWQmUN=3xs!4d>OZ<9Nj!v2ekQvm?m)8Hwo(BnAHauz&|#+erfi>LD@U^zXo
zCz`OF<zsLsJlKNKb_dlC9zVsfrz#N3BxQ|t!%KMEMNm(g1(CHl3NJwA-N@y;<<Ou-
zhu=bRCZs|Y8OUT5Y?;m*O6gi<AeRAX1&!N<25q826DUx<eF6vpv?=0X$9CDHv|w`v
z6a&EG+c<q`+#NX1I}AuD4ZcN1XpKYTn7xLJ{aLMW-_+V*@v}E$+grmCQAWb&(cM=J
zIwnYf6iamz3sn|lf0C-JW1Kh!RE`Bc&p?zD&LlHo@c=aMC(?<+X-na3LUB;>r_?B%
zPAnvb1@fhWeOZ++`@tSGD1hQvrEyo{p>e5*3wS6MXmvut?c*<`;Spa~AaSWsA=R_c
z{N_vT{P?`Hck0i^KB-yUY4{ERUod>2RGSzE^us8az6#RAH+E2Zd?|1z7QB+y(?N&Z
z)3~Vs(8L(XS%qw|;0a6^2B5s#-)XSB$!#zWy~BccP~lV@=Yh>OYCMb`DZaymq49_&
z2GS^y=AJ;a<A;r*gkt+?+WHy7kPaSW+L%2!hQ=FF1;`Ni-eX(-*uyHQ^=LXgjS6?6
z!foSWQVhg$D#C>cPa{BU0BDN)F;ymf8O2e_>>phL*{4F4@i2Q9IE@AO#dRg5BD5Hw
zWg0x51rBAxmYHxn9A_K@f?+m!1kpmr#V=QmIHvUtxAom#fhsedXlQV(ajh1%3PWj{
zjt4ssKys9cgJWO^0K72<UIvhrRbV}baaB%m%@|0hjr~L@cL1QNyC7u%D#Zdh5Ws4T
zwzho$b}(T4RQ~vxeED-~-Mn12FAW+1qpDB0>VK|G@9xwh7*pT&rmrkiBN!bYSB4ZE
zAloa`6BDhkgQhw1rxj+EiiStf3?L+*?y*?Up$-PC&v+zEBc0`g*Ma-2nfpwDAIBTK
zI{u+*M!9oVwYus?D_z1w_G~KXF7}$9$u+HlYm_1A8tt0N<hAzC#n}o_&2T5Q#hd}R
zkO2TZqRlxc^4N9qA7`L=+Q&Jxr97OS+_nUa81Ue=>q(Tk&LQn%pSjo>xlnrnO7nF&
zBHV~EpIi;Er->P}V8b--aJqjaKbJ$=JZJX}u9+Lj1k}0*=Too<gE}uYGoQS_HJ>&q
zW<}**q;X~!Nb&@t)b>y@oyDY1!OF=6BgR52d&7Z_SfRje2{&f>Vd5T(&xaOOmKUqI
zZyxgiFA#XE37l<&oEmM85&&466IiCBysJ^RiJawxQYnkF!C-#c(n6;;lu1War}Dm~
zz_n*3ZMRS!)SI`?3Ep0tA5IjjQ|Eo<j`U*aNzUGW<}CQ)*J8T!jYTZ%4T_VJ>hU3%
z*b8vg(eD1@=DNfX>jyZ8P`sz;pdY`80xZBJ70i8`!Qq~9d<Hgz39ww|o0cv8p$_6_
z(A(2xyThUJ-98@mw~dI)q;t!I?_IU*IgG-cf){S+rH%Mk-P7AwDmh0L(8Jw>r!4|3
zxLzx2HF$9|SfIUt0Z^A)hfQp2P*z7#Z3I+RHxb-@C*ECvWAu)F$bHQPQE5{_#~f4~
zQ($I9L$lyo!1)IUNG9OrTUOQ4NZE(bo-&st{sGImipd8^i~F&^i%Y2j8A&Kb_eJ7w
z<heCeQO#q8?#B)#E6A6Rgh2PJLj)?%--EroQ5}Adt9yy#{IVpERmgcdhofL09$9~0
zKmq{HQovl#7)mS#`A~>o$dkq)=oc!_<)crZP^j^V@L^MtBmyU0YONK+Nm_b3^-Q>)
z0J%A})|$%s(k8DT%YO^IBpkk`nTEs>pBYT9t<^w=_E~Ga9AG0;fk)5ypKPPnQ`at>
zgR~MLN%Z-oR8E}*_-{J5xW{wVdhR#G7njnID+D-D3-Kbry|Az^=kw9Ok%!y)f4T6#
zCGfvH|6H2*4C2Z(!onI-Uvhjb7MbGbN#=iv;^)_Vi6K5)p<g#heJPgA)NCCWoM%QE
zt(UUbBnBa1S7t2jW%OwT$IBv<JNz=5s67@+=Z>&VEzv>~#oB)U>G&%h<$Ge<uTg2Q
zVU}+=!rxdAiui}3ybGVN@i4tmFRr_+2iC7`*KmeyJv%)8);x{V0K>^HP8(2Py~{^@
zzx_6Vh=^e!E-~H}x^f+=c_$`&zgQC`L096~r)*Syd{XvY8q>`yV75Af<v~5$5KQB1
z8RU<dT4{U!UVZ3&({^zl^L>i;s)o&`ip7Ti)N)|WyIv^)x0+2v_-2RP2RV-w@DMe@
z^+R*=2aRrCO5xh%#}C{dq0{X8^ogx@X^_g%&6|I=go#@Wvu%Fa?FWV1+~Mq(k!_Cd
z?X^GK&;M*cmHsHSfmwGIeqH$SKD#^pXY0}(2=&p&<9|MWxwHK>^wUb=rybXAc6XZb
z{L`PoE#NBuO97VH?X9A}R^e`2kgKfW=PX{gP1Gk8Oy)Dm^s`9Hdv<ZUZ2Gfg-8<?1
z&l9z*e2p)Exqj(P{-X3^Yh>_?+KbHx(W{#KDZ*Q3f7RE1=}!KuIP@>07f(%I{B`R0
zU%0y~mgZk`LcZz^qiy+|4L)r-75%0D;)C0#zg%8?@w)KbzUbSn&ToNN7lU7Xi~scv
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

literal 0
HcmV?d00001

diff --git a/docs/static/img/debugger/ref1-create-launch.png b/docs/static/img/debugger/ref1-create-launch.png
new file mode 100644
index 0000000000000000000000000000000000000000..0b6cb8b3ec6e271f98bde89cd142fe4362c2064d
GIT binary patch
literal 113387
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

literal 0
HcmV?d00001


From 791f1c8522d49972dad4eb940f9cad437e28b25b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 15 Apr 2024 12:17:16 +0100
Subject: [PATCH 178/416] feat: add `NARGO_FOREIGN_CALL_TIMEOUT` environment
 variable (#4780)

# Description

## Problem\*

Resolves #4772

## Summary\*

This PR adds the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable which
allows setting the number of milliseconds which external foreign call
resolvers can take to return a result.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/noir/concepts/oracles.md     | 8 ++++++++
 tooling/nargo/src/ops/foreign_calls.rs | 9 ++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/docs/docs/noir/concepts/oracles.md b/docs/docs/noir/concepts/oracles.md
index 2e6a6818d48..aa380b5f7b8 100644
--- a/docs/docs/noir/concepts/oracles.md
+++ b/docs/docs/noir/concepts/oracles.md
@@ -11,6 +11,12 @@ keywords:
 sidebar_position: 6
 ---
 
+:::note
+
+This is an experimental feature that is not fully documented. If you notice any outdated information or potential improvements to this page, pull request contributions are very welcome: https://github.com/noir-lang/noir
+
+:::
+
 Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
 
 Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
@@ -21,3 +27,5 @@ You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
 #[oracle(get_number_sequence)]
 unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
 ```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index bc91929e5e7..33767314a37 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -167,8 +167,15 @@ pub struct DefaultForeignCallExecutor {
 impl DefaultForeignCallExecutor {
     pub fn new(show_output: bool, resolver_url: Option<&str>) -> Self {
         let oracle_resolver = resolver_url.map(|resolver_url| {
-            let transport_builder =
+            let mut transport_builder =
                 Builder::new().url(resolver_url).expect("Invalid oracle resolver URL");
+
+            if let Some(Ok(timeout)) =
+                std::env::var("NARGO_FOREIGN_CALL_TIMEOUT").ok().map(|timeout| timeout.parse())
+            {
+                let timeout_duration = std::time::Duration::from_millis(timeout);
+                transport_builder = transport_builder.timeout(timeout_duration);
+            };
             Client::with_transport(transport_builder.build())
         });
         DefaultForeignCallExecutor {

From b46d0e39f4252f8bbaa987f88d112e4c233b3d61 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 15 Apr 2024 14:57:18 +0200
Subject: [PATCH 179/416] fix: proper field inversion for bigints (#4802)

# Description

## Problem\*

Resolves #4578. The fix for issue #4530 has also being merged back so I
also activate the related test case.

## Summary\*

Field inversion for bigints had a typo.

## Additional Context

I did not consider biguint256 since it was decided not to merge the PR.

## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acvm/src/pwg/blackbox/bigint.rs          | 2 +-
 test_programs/execution_success/bigint/src/main.nr | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/acvm-repo/acvm/src/pwg/blackbox/bigint.rs b/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
index f094bb1ba20..a47afa5049a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
@@ -105,7 +105,7 @@ impl BigIntSolver {
             }
             BlackBoxFunc::BigIntMul => lhs * rhs,
             BlackBoxFunc::BigIntDiv => {
-                lhs * rhs.modpow(&(&modulus - BigUint::from(1_u32)), &modulus)
+                lhs * rhs.modpow(&(&modulus - BigUint::from(2_u32)), &modulus)
             } //TODO ensure that modulus is prime
             _ => unreachable!("ICE - bigint_op must be called for an operation"),
         };
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index db269d63ac0..908cab8accc 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -10,11 +10,11 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
         assert(a_bytes[i] == x[i]);
         assert(b_bytes[i] == y[i]);
     }
+    //Regression for issue #4578
+    let d = a * b;
+    assert(d / b == a);
 
-    let d = a * b - b;
-    let d1 = bigint::Secpk1Fq::from_le_bytes(597243850900842442924.to_le_bytes(10));
-    assert(d1 == d);
-    // big_int_example(x[0], x[1]);
+    big_int_example(x[0], x[1]);
 }
 
 // docs:start:big_int_example

From 5b231714740447d82cde7cdbe65d4a8b46a31df4 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 15 Apr 2024 13:58:34 +0100
Subject: [PATCH 180/416] feat(nargo): Handle call stacks for multiple Acir
 calls (#4711)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves leftover work from #4428

We would error out on calls in non-inlined Acir calls, however, we would
only use the debug info from the main function.

## Summary\*

There is now a new `ResolvedOpcodeLocation` that wraps an acir function
index from the `Program` as well as its opcode location. We then build a
call stack during execution that is resolved upon execution failure.
Both `ExecutionError` variants now contain a call stack of
`ResolvedOpcodeLocation`.

For the `fold_basic_nested_call` if I make `assert(x == y)` fail I will
get the following now:
<img width="811" alt="Screenshot 2024-04-03 at 4 53 17 PM"
src="https://github.com/noir-lang/noir/assets/43554004/9c50bec5-4f85-4fe1-93ed-0527f9511f2c">

On master we would get an error in `main` at the first call to
`func_with_nested_foo_call`.

For the new
`test_programs/execution_failure/fold_nested_brillig_assert_fail` test
we have this output:
<img width="859" alt="Screenshot 2024-04-11 at 9 50 34 AM"
src="https://github.com/noir-lang/noir/assets/43554004/58ef8d8f-f67c-477d-9af1-cc1ccd89be5e">

I then also added support for call stacks with dynamic indices in
`test_programs/execution_failure/fold_dyn_index_fail`:
<img width="774" alt="Screenshot 2024-04-11 at 9 51 16 AM"
src="https://github.com/noir-lang/noir/assets/43554004/1066a05a-78db-4c84-83fd-77c17d83cc81">


## Additional Context



## Documentation\*

Check one:
- [] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 acvm-repo/acir/src/circuit/mod.rs             |  10 ++
 compiler/noirc_driver/src/contract.rs         |   2 +-
 compiler/noirc_driver/src/lib.rs              |  10 +-
 compiler/noirc_driver/src/program.rs          |   2 +-
 compiler/noirc_errors/src/debug_info.rs       |  79 +++++++------
 compiler/wasm/src/types/noir_artifact.ts      |  10 ++
 .../wasm/test/compiler/shared/compile.test.ts |  13 ++-
 .../fold_dyn_index_fail/Nargo.toml            |   7 ++
 .../fold_dyn_index_fail/Prover.toml           |   2 +
 .../fold_dyn_index_fail/src/main.nr           |  10 ++
 .../Nargo.toml                                |   7 ++
 .../Prover.toml                               |   1 +
 .../src/main.nr                               |  26 +++++
 tooling/debugger/src/context.rs               |   6 +-
 tooling/debugger/src/dap.rs                   |   2 +-
 tooling/lsp/src/requests/profile_run.rs       |  19 ++--
 tooling/nargo/src/artifacts/contract.rs       |  10 +-
 tooling/nargo/src/artifacts/debug.rs          |   4 +-
 tooling/nargo/src/artifacts/program.rs        |  12 +-
 tooling/nargo/src/errors.rs                   | 104 +++++++++++-------
 tooling/nargo/src/ops/execute.rs              |  73 +++++++++---
 tooling/nargo/src/ops/optimize.rs             |  33 ++++--
 tooling/nargo/src/ops/test.rs                 |   2 +-
 tooling/nargo/src/ops/transform.rs            |  45 +++++---
 tooling/nargo_cli/src/cli/debug_cmd.rs        |   2 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |   2 +-
 tooling/nargo_cli/src/cli/info_cmd.rs         |  12 +-
 27 files changed, 345 insertions(+), 160 deletions(-)
 create mode 100644 test_programs/execution_failure/fold_dyn_index_fail/Nargo.toml
 create mode 100644 test_programs/execution_failure/fold_dyn_index_fail/Prover.toml
 create mode 100644 test_programs/execution_failure/fold_dyn_index_fail/src/main.nr
 create mode 100644 test_programs/execution_failure/fold_nested_brillig_assert_fail/Nargo.toml
 create mode 100644 test_programs/execution_failure/fold_nested_brillig_assert_fail/Prover.toml
 create mode 100644 test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr

diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index cb846bdaffa..9c858617acf 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -86,6 +86,16 @@ impl Circuit {
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+/// The opcode location for a call to a separate ACIR circuit
+/// This includes the function index of the caller within a [program][Program]
+/// and the index in the callers ACIR to the specific call opcode.
+/// This is only resolved and set during circuit execution.
+pub struct ResolvedOpcodeLocation {
+    pub acir_function_index: usize,
+    pub opcode_location: OpcodeLocation,
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 /// Opcodes are locatable so that callers can
 /// map opcodes to debug information related to their context.
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index a33a9b809d3..d6c3dc6205d 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -53,7 +53,7 @@ pub struct ContractFunction {
     )]
     pub bytecode: Program,
 
-    pub debug: DebugInfo,
+    pub debug: Vec<DebugInfo>,
 
     /// Names of the functions in the program. These are used for more informative debugging and benchmarking.
     pub names: Vec<String>,
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 6fe44780484..8a554879e9f 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -430,7 +430,8 @@ fn compile_contract_inner(
     }
 
     if errors.is_empty() {
-        let debug_infos: Vec<_> = functions.iter().map(|function| function.debug.clone()).collect();
+        let debug_infos: Vec<_> =
+            functions.iter().flat_map(|function| function.debug.clone()).collect();
         let file_map = filter_relevant_files(&debug_infos, &context.file_manager);
 
         let out_structs = contract
@@ -547,13 +548,8 @@ pub fn compile_no_check(
 
     Ok(CompiledProgram {
         hash,
-        // TODO(https://github.com/noir-lang/noir/issues/4428)
         program,
-        // TODO(https://github.com/noir-lang/noir/issues/4428)
-        // Debug info is only relevant for errors at execution time which is not yet supported
-        // The CompileProgram `debug` field is used in multiple places and is better
-        // left to be updated once execution of multiple ACIR functions is enabled
-        debug: debug[0].clone(),
+        debug,
         abi,
         file_map,
         noir_version: NOIR_ARTIFACT_VERSION_STRING.to_string(),
diff --git a/compiler/noirc_driver/src/program.rs b/compiler/noirc_driver/src/program.rs
index 9ffd2d70dda..ed7ddb29f59 100644
--- a/compiler/noirc_driver/src/program.rs
+++ b/compiler/noirc_driver/src/program.rs
@@ -24,7 +24,7 @@ pub struct CompiledProgram {
     )]
     pub program: Program,
     pub abi: noirc_abi::Abi,
-    pub debug: DebugInfo,
+    pub debug: Vec<DebugInfo>,
     pub file_map: BTreeMap<FileId, DebugFile>,
     pub warnings: Vec<SsaReport>,
     /// Names of the functions in the program. These are used for more informative debugging and benchmarking.
diff --git a/compiler/noirc_errors/src/debug_info.rs b/compiler/noirc_errors/src/debug_info.rs
index 09117bdc3b7..54e2521e413 100644
--- a/compiler/noirc_errors/src/debug_info.rs
+++ b/compiler/noirc_errors/src/debug_info.rs
@@ -46,6 +46,49 @@ pub type DebugVariables = BTreeMap<DebugVarId, DebugVariable>;
 pub type DebugFunctions = BTreeMap<DebugFnId, DebugFunction>;
 pub type DebugTypes = BTreeMap<DebugTypeId, PrintableType>;
 
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct ProgramDebugInfo {
+    pub debug_infos: Vec<DebugInfo>,
+}
+
+impl ProgramDebugInfo {
+    pub fn serialize_compressed_base64_json<S>(
+        debug_info: &ProgramDebugInfo,
+        s: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let json_str = serde_json::to_string(debug_info).map_err(S::Error::custom)?;
+
+        let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
+        encoder.write_all(json_str.as_bytes()).map_err(S::Error::custom)?;
+        let compressed_data = encoder.finish().map_err(S::Error::custom)?;
+
+        let encoded_b64 = base64::prelude::BASE64_STANDARD.encode(compressed_data);
+        s.serialize_str(&encoded_b64)
+    }
+
+    pub fn deserialize_compressed_base64_json<'de, D>(
+        deserializer: D,
+    ) -> Result<ProgramDebugInfo, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let encoded_b64: String = Deserialize::deserialize(deserializer)?;
+
+        let compressed_data =
+            base64::prelude::BASE64_STANDARD.decode(encoded_b64).map_err(D::Error::custom)?;
+
+        let mut decoder = DeflateDecoder::new(&compressed_data[..]);
+        let mut decompressed_data = Vec::new();
+        decoder.read_to_end(&mut decompressed_data).map_err(D::Error::custom)?;
+
+        let json_str = String::from_utf8(decompressed_data).map_err(D::Error::custom)?;
+        serde_json::from_str(&json_str).map_err(D::Error::custom)
+    }
+}
+
 #[serde_as]
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct DebugInfo {
@@ -130,40 +173,4 @@ impl DebugInfo {
 
         counted_opcodes
     }
-
-    pub fn serialize_compressed_base64_json<S>(
-        debug_info: &DebugInfo,
-        s: S,
-    ) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let json_str = serde_json::to_string(debug_info).map_err(S::Error::custom)?;
-
-        let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
-        encoder.write_all(json_str.as_bytes()).map_err(S::Error::custom)?;
-        let compressed_data = encoder.finish().map_err(S::Error::custom)?;
-
-        let encoded_b64 = base64::prelude::BASE64_STANDARD.encode(compressed_data);
-        s.serialize_str(&encoded_b64)
-    }
-
-    pub fn deserialize_compressed_base64_json<'de, D>(
-        deserializer: D,
-    ) -> Result<DebugInfo, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let encoded_b64: String = Deserialize::deserialize(deserializer)?;
-
-        let compressed_data =
-            base64::prelude::BASE64_STANDARD.decode(encoded_b64).map_err(D::Error::custom)?;
-
-        let mut decoder = DeflateDecoder::new(&compressed_data[..]);
-        let mut decompressed_data = Vec::new();
-        decoder.read_to_end(&mut decompressed_data).map_err(D::Error::custom)?;
-
-        let json_str = String::from_utf8(decompressed_data).map_err(D::Error::custom)?;
-        serde_json::from_str(&json_str).map_err(D::Error::custom)
-    }
 }
diff --git a/compiler/wasm/src/types/noir_artifact.ts b/compiler/wasm/src/types/noir_artifact.ts
index f241b539dc7..6ecc3ccd56f 100644
--- a/compiler/wasm/src/types/noir_artifact.ts
+++ b/compiler/wasm/src/types/noir_artifact.ts
@@ -151,6 +151,16 @@ export interface DebugInfo {
   locations: Record<OpcodeLocation, SourceCodeLocation[]>;
 }
 
+/**
+ * The debug information for a given program.
+ */
+export interface ProgramDebugInfo {
+  /**
+   * An array that maps to each function of a program.
+   */
+  debug_infos: Array<DebugInfo>;
+}
+
 /**
  * Maps a file ID to its metadata for debugging purposes.
  */
diff --git a/compiler/wasm/test/compiler/shared/compile.test.ts b/compiler/wasm/test/compiler/shared/compile.test.ts
index 52cef14968b..f9e37530cbc 100644
--- a/compiler/wasm/test/compiler/shared/compile.test.ts
+++ b/compiler/wasm/test/compiler/shared/compile.test.ts
@@ -5,6 +5,7 @@ import {
   ContractCompilationArtifacts,
   DebugFileMap,
   DebugInfo,
+  ProgramDebugInfo,
   NoirFunctionEntry,
   ProgramArtifact,
   ProgramCompilationArtifacts,
@@ -15,7 +16,7 @@ export function shouldCompileProgramIdentically(
   expect: typeof Expect,
   timeout = 5000,
 ) {
-  it('both nargo and noir_wasm should compile identically', async () => {
+  it('both nargo and noir_wasm should compile program identically', async () => {
     // Compile!
     const { nargoArtifact, noirWasmArtifact } = await compileFn();
 
@@ -51,7 +52,7 @@ export function shouldCompileContractIdentically(
   expect: typeof Expect,
   timeout = 5000,
 ) {
-  it('both nargo and noir_wasm should compile identically', async () => {
+  it('both nargo and noir_wasm should compile contract identically', async () => {
     // Compile!
     const { nargoArtifact, noirWasmArtifact } = await compileFn();
 
@@ -90,7 +91,7 @@ function extractDebugInfos(fns: NoirFunctionEntry[]) {
   return fns.map((fn) => {
     const debugSymbols = inflateDebugSymbols(fn.debug_symbols);
     delete (fn as Partial<NoirFunctionEntry>).debug_symbols;
-    clearFileIdentifiers(debugSymbols);
+    clearFileIdentifiersProgram(debugSymbols);
     return debugSymbols;
   });
 }
@@ -113,6 +114,12 @@ function deleteContractDebugMetadata(contract: ContractArtifact) {
   return [extractDebugInfos(contract.functions), fileMap];
 }
 
+function clearFileIdentifiersProgram(debugSymbols: ProgramDebugInfo) {
+  debugSymbols.debug_infos.map((debug_info) => {
+    clearFileIdentifiers(debug_info);
+  });
+}
+
 /** Clears file identifiers from a set of debug symbols. */
 function clearFileIdentifiers(debugSymbols: DebugInfo) {
   for (const loc of Object.values(debugSymbols.locations)) {
diff --git a/test_programs/execution_failure/fold_dyn_index_fail/Nargo.toml b/test_programs/execution_failure/fold_dyn_index_fail/Nargo.toml
new file mode 100644
index 00000000000..e49a82cf0fb
--- /dev/null
+++ b/test_programs/execution_failure/fold_dyn_index_fail/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_dyn_index_fail"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_failure/fold_dyn_index_fail/Prover.toml b/test_programs/execution_failure/fold_dyn_index_fail/Prover.toml
new file mode 100644
index 00000000000..caf3448c56f
--- /dev/null
+++ b/test_programs/execution_failure/fold_dyn_index_fail/Prover.toml
@@ -0,0 +1,2 @@
+x = [104, 101, 108, 108, 111]
+z = "4"
diff --git a/test_programs/execution_failure/fold_dyn_index_fail/src/main.nr b/test_programs/execution_failure/fold_dyn_index_fail/src/main.nr
new file mode 100644
index 00000000000..b12dea630b0
--- /dev/null
+++ b/test_programs/execution_failure/fold_dyn_index_fail/src/main.nr
@@ -0,0 +1,10 @@
+fn main(mut x: [u32; 5], z: Field) {
+    x[z] = 4;
+    dynamic_index_check(x, z + 10);
+}
+
+#[fold]
+fn dynamic_index_check(x: [u32; 5], idx: Field) {
+    // Dynamic index is greater than length of the array
+    assert(x[idx] != 0);
+}
diff --git a/test_programs/execution_failure/fold_nested_brillig_assert_fail/Nargo.toml b/test_programs/execution_failure/fold_nested_brillig_assert_fail/Nargo.toml
new file mode 100644
index 00000000000..bb7d5e20dcc
--- /dev/null
+++ b/test_programs/execution_failure/fold_nested_brillig_assert_fail/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_nested_brillig_assert_fail"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_failure/fold_nested_brillig_assert_fail/Prover.toml b/test_programs/execution_failure/fold_nested_brillig_assert_fail/Prover.toml
new file mode 100644
index 00000000000..11497a473bc
--- /dev/null
+++ b/test_programs/execution_failure/fold_nested_brillig_assert_fail/Prover.toml
@@ -0,0 +1 @@
+x = "0"
diff --git a/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr b/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr
new file mode 100644
index 00000000000..0a5038c179b
--- /dev/null
+++ b/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr
@@ -0,0 +1,26 @@
+// Tests a very simple program.
+// 
+// The features being tested is using assert on brillig that is triggered through nested ACIR calls.
+// We want to make sure we get a call stack from the original call in main to the failed assert.
+fn main(x: Field) {
+    assert(1 == fold_conditional_wrapper(x as bool));
+}
+
+#[fold]
+fn fold_conditional_wrapper(x: bool) -> Field {
+    fold_conditional(x)
+}
+
+#[fold]
+fn fold_conditional(x: bool) -> Field {
+    conditional_wrapper(x)
+}
+
+unconstrained fn conditional_wrapper(x: bool) -> Field {
+    conditional(x)
+}
+
+unconstrained fn conditional(x: bool) -> Field {
+    assert(x);
+    1
+}
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index b211832518d..c8ab544fa70 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -331,7 +331,8 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
                 self.handle_foreign_call(foreign_call)
             }
             Err(err) => DebugCommandResult::Error(NargoError::ExecutionError(
-                ExecutionError::SolvingError(err),
+                // TODO: debugger does not not handle multiple acir calls
+                ExecutionError::SolvingError(err, None),
             )),
         }
     }
@@ -374,7 +375,8 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
                 }
             }
             ACVMStatus::Failure(error) => DebugCommandResult::Error(NargoError::ExecutionError(
-                ExecutionError::SolvingError(error),
+                // TODO: debugger does not not handle multiple acir calls
+                ExecutionError::SolvingError(error, None),
             )),
             ACVMStatus::RequiresForeignCall(_) => {
                 unreachable!("Unexpected pending foreign call resolution");
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index ea3204ebbbc..8dc3c541540 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -603,7 +603,7 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver>(
     initial_witness: WitnessMap,
 ) -> Result<(), ServerError> {
     let debug_artifact = DebugArtifact {
-        debug_symbols: vec![program.debug],
+        debug_symbols: program.debug,
         file_map: program.file_map,
         warnings: program.warnings,
     };
diff --git a/tooling/lsp/src/requests/profile_run.rs b/tooling/lsp/src/requests/profile_run.rs
index 89719947689..7d06bc87c85 100644
--- a/tooling/lsp/src/requests/profile_run.rs
+++ b/tooling/lsp/src/requests/profile_run.rs
@@ -84,9 +84,11 @@ fn on_profile_run_request_inner(
                 let compiled_program =
                     nargo::ops::transform_program(compiled_program, expression_width);
 
-                let span_opcodes = compiled_program.debug.count_span_opcodes();
-                let debug_artifact: DebugArtifact = compiled_program.clone().into();
-                opcodes_counts.extend(span_opcodes);
+                for function_debug in compiled_program.debug.iter() {
+                    let span_opcodes = function_debug.count_span_opcodes();
+                    opcodes_counts.extend(span_opcodes);
+                }
+                let debug_artifact: DebugArtifact = compiled_program.into();
                 file_map.extend(debug_artifact.file_map);
             }
 
@@ -94,14 +96,17 @@ fn on_profile_run_request_inner(
                 let compiled_contract =
                     nargo::ops::transform_contract(compiled_contract, expression_width);
 
-                let function_debug_info: Vec<_> =
-                    compiled_contract.functions.iter().map(|func| &func.debug).cloned().collect();
-                let debug_artifact: DebugArtifact = compiled_contract.into();
-                file_map.extend(debug_artifact.file_map);
+                let function_debug_info = compiled_contract
+                    .functions
+                    .iter()
+                    .flat_map(|func| &func.debug)
+                    .collect::<Vec<_>>();
                 for contract_function_debug in function_debug_info {
                     let span_opcodes = contract_function_debug.count_span_opcodes();
                     opcodes_counts.extend(span_opcodes);
                 }
+                let debug_artifact: DebugArtifact = compiled_contract.into();
+                file_map.extend(debug_artifact.file_map);
             }
 
             let result = NargoProfileRunResult { file_map, opcodes_counts };
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index 868fb4404fd..83bb4b94f82 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -4,7 +4,7 @@ use noirc_driver::{CompiledContract, CompiledContractOutputs, ContractFunction};
 use serde::{Deserialize, Serialize};
 
 use noirc_driver::DebugFile;
-use noirc_errors::debug_info::DebugInfo;
+use noirc_errors::debug_info::ProgramDebugInfo;
 use std::collections::{BTreeMap, HashMap};
 
 use fm::FileId;
@@ -68,10 +68,10 @@ pub struct ContractFunctionArtifact {
     pub bytecode: Program,
 
     #[serde(
-        serialize_with = "DebugInfo::serialize_compressed_base64_json",
-        deserialize_with = "DebugInfo::deserialize_compressed_base64_json"
+        serialize_with = "ProgramDebugInfo::serialize_compressed_base64_json",
+        deserialize_with = "ProgramDebugInfo::deserialize_compressed_base64_json"
     )]
-    pub debug_symbols: DebugInfo,
+    pub debug_symbols: ProgramDebugInfo,
 }
 
 impl From<ContractFunction> for ContractFunctionArtifact {
@@ -82,7 +82,7 @@ impl From<ContractFunction> for ContractFunctionArtifact {
             custom_attributes: func.custom_attributes,
             abi: func.abi,
             bytecode: func.bytecode,
-            debug_symbols: func.debug,
+            debug_symbols: ProgramDebugInfo { debug_infos: func.debug },
         }
     }
 }
diff --git a/tooling/nargo/src/artifacts/debug.rs b/tooling/nargo/src/artifacts/debug.rs
index fbdf59805c9..496896468cc 100644
--- a/tooling/nargo/src/artifacts/debug.rs
+++ b/tooling/nargo/src/artifacts/debug.rs
@@ -121,7 +121,7 @@ impl DebugArtifact {
 impl From<CompiledProgram> for DebugArtifact {
     fn from(compiled_program: CompiledProgram) -> Self {
         DebugArtifact {
-            debug_symbols: vec![compiled_program.debug],
+            debug_symbols: compiled_program.debug,
             file_map: compiled_program.file_map,
             warnings: compiled_program.warnings,
         }
@@ -133,7 +133,7 @@ impl From<CompiledContract> for DebugArtifact {
         let all_functions_debug: Vec<DebugInfo> = compiled_artifact
             .functions
             .into_iter()
-            .map(|contract_function| contract_function.debug)
+            .flat_map(|contract_function| contract_function.debug)
             .collect();
 
         DebugArtifact {
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/nargo/src/artifacts/program.rs
index 9e660cbd359..67ac9f53ec8 100644
--- a/tooling/nargo/src/artifacts/program.rs
+++ b/tooling/nargo/src/artifacts/program.rs
@@ -5,7 +5,7 @@ use fm::FileId;
 use noirc_abi::Abi;
 use noirc_driver::CompiledProgram;
 use noirc_driver::DebugFile;
-use noirc_errors::debug_info::DebugInfo;
+use noirc_errors::debug_info::ProgramDebugInfo;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -27,10 +27,10 @@ pub struct ProgramArtifact {
     pub bytecode: Program,
 
     #[serde(
-        serialize_with = "DebugInfo::serialize_compressed_base64_json",
-        deserialize_with = "DebugInfo::deserialize_compressed_base64_json"
+        serialize_with = "ProgramDebugInfo::serialize_compressed_base64_json",
+        deserialize_with = "ProgramDebugInfo::deserialize_compressed_base64_json"
     )]
-    pub debug_symbols: DebugInfo,
+    pub debug_symbols: ProgramDebugInfo,
 
     /// Map of file Id to the source code so locations in debug info can be mapped to source code they point to.
     pub file_map: BTreeMap<FileId, DebugFile>,
@@ -45,7 +45,7 @@ impl From<CompiledProgram> for ProgramArtifact {
             abi: compiled_program.abi,
             noir_version: compiled_program.noir_version,
             bytecode: compiled_program.program,
-            debug_symbols: compiled_program.debug,
+            debug_symbols: ProgramDebugInfo { debug_infos: compiled_program.debug },
             file_map: compiled_program.file_map,
             names: compiled_program.names,
         }
@@ -59,7 +59,7 @@ impl From<ProgramArtifact> for CompiledProgram {
             abi: program.abi,
             noir_version: program.noir_version,
             program: program.bytecode,
-            debug: program.debug_symbols,
+            debug: program.debug_symbols.debug_infos,
             file_map: program.file_map,
             warnings: vec![],
             names: program.names,
diff --git a/tooling/nargo/src/errors.rs b/tooling/nargo/src/errors.rs
index ff238d79a46..fa44bcc459b 100644
--- a/tooling/nargo/src/errors.rs
+++ b/tooling/nargo/src/errors.rs
@@ -1,5 +1,5 @@
 use acvm::{
-    acir::circuit::OpcodeLocation,
+    acir::circuit::{OpcodeLocation, ResolvedOpcodeLocation},
     pwg::{ErrorLocation, OpcodeResolutionError},
 };
 use noirc_errors::{
@@ -61,7 +61,7 @@ impl NargoError {
 
         match execution_error {
             ExecutionError::AssertionFailed(message, _) => Some(message),
-            ExecutionError::SolvingError(error) => match error {
+            ExecutionError::SolvingError(error, _) => match error {
                 OpcodeResolutionError::IndexOutOfBounds { .. }
                 | OpcodeResolutionError::OpcodeNotSolvable(_)
                 | OpcodeResolutionError::UnsatisfiedConstrain { .. }
@@ -77,81 +77,105 @@ impl NargoError {
 #[derive(Debug, Error)]
 pub enum ExecutionError {
     #[error("Failed assertion: '{}'", .0)]
-    AssertionFailed(String, Vec<OpcodeLocation>),
+    AssertionFailed(String, Vec<ResolvedOpcodeLocation>),
 
-    #[error(transparent)]
-    SolvingError(#[from] OpcodeResolutionError),
+    #[error("Failed to solve program: '{}'", .0)]
+    SolvingError(OpcodeResolutionError, Option<Vec<ResolvedOpcodeLocation>>),
 }
 
 /// Extracts the opcode locations from a nargo error.
 fn extract_locations_from_error(
     error: &ExecutionError,
-    debug: &DebugInfo,
+    debug: &[DebugInfo],
 ) -> Option<Vec<Location>> {
     let mut opcode_locations = match error {
-        ExecutionError::SolvingError(OpcodeResolutionError::BrilligFunctionFailed {
-            call_stack,
-            ..
-        })
-        | ExecutionError::AssertionFailed(_, call_stack) => Some(call_stack.clone()),
-        ExecutionError::SolvingError(OpcodeResolutionError::IndexOutOfBounds {
-            opcode_location: error_location,
-            ..
-        })
-        | ExecutionError::SolvingError(OpcodeResolutionError::UnsatisfiedConstrain {
-            opcode_location: error_location,
-        }) => match error_location {
+        ExecutionError::SolvingError(
+            OpcodeResolutionError::BrilligFunctionFailed { .. },
+            acir_call_stack,
+        ) => acir_call_stack.clone(),
+        ExecutionError::AssertionFailed(_, call_stack) => Some(call_stack.clone()),
+        ExecutionError::SolvingError(
+            OpcodeResolutionError::IndexOutOfBounds { opcode_location: error_location, .. },
+            acir_call_stack,
+        )
+        | ExecutionError::SolvingError(
+            OpcodeResolutionError::UnsatisfiedConstrain { opcode_location: error_location },
+            acir_call_stack,
+        ) => match error_location {
             ErrorLocation::Unresolved => {
                 unreachable!("Cannot resolve index for unsatisfied constraint")
             }
-            ErrorLocation::Resolved(opcode_location) => Some(vec![*opcode_location]),
+            ErrorLocation::Resolved(_) => acir_call_stack.clone(),
         },
         _ => None,
     }?;
 
-    if let Some(OpcodeLocation::Brillig { acir_index, .. }) = opcode_locations.first() {
-        opcode_locations.insert(0, OpcodeLocation::Acir(*acir_index));
+    // Insert the top-level Acir location where the Brillig function failed
+    for (i, resolved_location) in opcode_locations.iter().enumerate() {
+        if let ResolvedOpcodeLocation {
+            acir_function_index,
+            opcode_location: OpcodeLocation::Brillig { acir_index, .. },
+        } = resolved_location
+        {
+            let acir_location = ResolvedOpcodeLocation {
+                acir_function_index: *acir_function_index,
+                opcode_location: OpcodeLocation::Acir(*acir_index),
+            };
+
+            opcode_locations.insert(i, acir_location);
+            // Go until the first brillig opcode as that means we have the start of a Brillig call stack.
+            // We have to loop through the opcode locations in case we had ACIR calls
+            // before the brillig function failure.
+            break;
+        }
     }
 
     Some(
         opcode_locations
             .iter()
-            .flat_map(|opcode_location| debug.opcode_location(opcode_location).unwrap_or_default())
+            .flat_map(|resolved_location| {
+                debug[resolved_location.acir_function_index]
+                    .opcode_location(&resolved_location.opcode_location)
+                    .unwrap_or_default()
+            })
             .collect(),
     )
 }
 
-/// Tries to generate a runtime diagnostic from a nargo error. It will successfully do so if it's a runtime error with a call stack.
-pub fn try_to_diagnose_runtime_error(
-    nargo_err: &NargoError,
-    debug: &DebugInfo,
-) -> Option<FileDiagnostic> {
-    let execution_error = match nargo_err {
-        NargoError::ExecutionError(execution_error) => execution_error,
-        _ => return None,
-    };
-
-    let source_locations = extract_locations_from_error(execution_error, debug)?;
-
-    // The location of the error itself will be the location at the top
-    // of the call stack (the last item in the Vec).
-    let location = source_locations.last()?;
-
-    let message = match nargo_err {
+fn extract_message_from_error(nargo_err: &NargoError) -> String {
+    match nargo_err {
         NargoError::ExecutionError(ExecutionError::AssertionFailed(message, _)) => {
             format!("Assertion failed: '{message}'")
         }
         NargoError::ExecutionError(ExecutionError::SolvingError(
             OpcodeResolutionError::IndexOutOfBounds { index, array_size, .. },
+            _,
         )) => {
             format!("Index out of bounds, array has size {array_size:?}, but index was {index:?}")
         }
         NargoError::ExecutionError(ExecutionError::SolvingError(
             OpcodeResolutionError::UnsatisfiedConstrain { .. },
+            _,
         )) => "Failed constraint".into(),
         _ => nargo_err.to_string(),
-    };
+    }
+}
 
+/// Tries to generate a runtime diagnostic from a nargo error. It will successfully do so if it's a runtime error with a call stack.
+pub fn try_to_diagnose_runtime_error(
+    nargo_err: &NargoError,
+    debug: &[DebugInfo],
+) -> Option<FileDiagnostic> {
+    let source_locations = match nargo_err {
+        NargoError::ExecutionError(execution_error) => {
+            extract_locations_from_error(execution_error, debug)?
+        }
+        _ => return None,
+    };
+    // The location of the error itself will be the location at the top
+    // of the call stack (the last item in the Vec).
+    let location = source_locations.last()?;
+    let message = extract_message_from_error(nargo_err);
     Some(
         CustomDiagnostic::simple_error(message, String::new(), location.span)
             .in_file(location.file)
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 6d328d65119..76f6da7c1bc 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -1,4 +1,4 @@
-use acvm::acir::circuit::Program;
+use acvm::acir::circuit::{OpcodeLocation, Program, ResolvedOpcodeLocation};
 use acvm::acir::native_types::WitnessStack;
 use acvm::brillig_vm::brillig::ForeignCallResult;
 use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ACVM};
@@ -18,6 +18,15 @@ struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
     blackbox_solver: &'a B,
 
     foreign_call_executor: &'a mut F,
+
+    // The Noir compiler codegens per function and call stacks are not shared across ACIR function calls.
+    // We must rebuild a call stack when executing a program of many circuits.
+    call_stack: Vec<ResolvedOpcodeLocation>,
+
+    // Tracks the index of the current function we are executing.
+    // This is used to fetch the function we want to execute
+    // and to resolve call stack locations across many function calls.
+    current_function_index: usize,
 }
 
 impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a, B, F> {
@@ -31,6 +40,8 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
             witness_stack: WitnessStack::default(),
             blackbox_solver,
             foreign_call_executor,
+            call_stack: Vec::default(),
+            current_function_index: 0,
         }
     }
 
@@ -39,11 +50,8 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
     }
 
     #[tracing::instrument(level = "trace", skip_all)]
-    fn execute_circuit(
-        &mut self,
-        circuit: &Circuit,
-        initial_witness: WitnessMap,
-    ) -> Result<WitnessMap, NargoError> {
+    fn execute_circuit(&mut self, initial_witness: WitnessMap) -> Result<WitnessMap, NargoError> {
+        let circuit = &self.functions[self.current_function_index];
         let mut acvm = ACVM::new(self.blackbox_solver, &circuit.opcodes, initial_witness);
 
         // This message should be resolved by a nargo foreign call only when we have an unsatisfied assertion.
@@ -60,9 +68,26 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                     let call_stack = match &error {
                         OpcodeResolutionError::UnsatisfiedConstrain {
                             opcode_location: ErrorLocation::Resolved(opcode_location),
-                        } => Some(vec![*opcode_location]),
+                        }
+                        | OpcodeResolutionError::IndexOutOfBounds {
+                            opcode_location: ErrorLocation::Resolved(opcode_location),
+                            ..
+                        } => {
+                            let resolved_location = ResolvedOpcodeLocation {
+                                acir_function_index: self.current_function_index,
+                                opcode_location: *opcode_location,
+                            };
+                            self.call_stack.push(resolved_location);
+                            Some(self.call_stack.clone())
+                        }
                         OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
-                            Some(call_stack.clone())
+                            let brillig_call_stack =
+                                call_stack.iter().map(|location| ResolvedOpcodeLocation {
+                                    acir_function_index: self.current_function_index,
+                                    opcode_location: *location,
+                                });
+                            self.call_stack.extend(brillig_call_stack);
+                            Some(self.call_stack.clone())
                         }
                         _ => None,
                     };
@@ -79,17 +104,20 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                                     call_stack,
                                 )
                             } else if let Some(assert_message) = circuit.get_assert_message(
-                                *call_stack.last().expect("Call stacks should not be empty"),
+                                call_stack
+                                    .last()
+                                    .expect("Call stacks should not be empty")
+                                    .opcode_location,
                             ) {
                                 ExecutionError::AssertionFailed(
                                     assert_message.to_owned(),
                                     call_stack,
                                 )
                             } else {
-                                ExecutionError::SolvingError(error)
+                                ExecutionError::SolvingError(error, Some(call_stack))
                             }
                         }
-                        None => ExecutionError::SolvingError(error),
+                        None => ExecutionError::SolvingError(error, None),
                     }));
                 }
                 ACVMStatus::RequiresForeignCall(foreign_call) => {
@@ -109,10 +137,24 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                     }
                 }
                 ACVMStatus::RequiresAcirCall(call_info) => {
+                    // Store the parent function index whose context we are currently executing
+                    let acir_function_caller = self.current_function_index;
+                    // Add call opcode to the call stack with a reference to the parent function index
+                    self.call_stack.push(ResolvedOpcodeLocation {
+                        acir_function_index: acir_function_caller,
+                        opcode_location: OpcodeLocation::Acir(acvm.instruction_pointer()),
+                    });
+
+                    // Set current function to the circuit we are about to execute
+                    self.current_function_index = call_info.id as usize;
+                    // Execute the ACIR call
                     let acir_to_call = &self.functions[call_info.id as usize];
                     let initial_witness = call_info.initial_witness;
-                    let call_solved_witness =
-                        self.execute_circuit(acir_to_call, initial_witness)?;
+                    let call_solved_witness = self.execute_circuit(initial_witness)?;
+
+                    // Set tracking index back to the parent function after ACIR call execution
+                    self.current_function_index = acir_function_caller;
+
                     let mut call_resolved_outputs = Vec::new();
                     for return_witness_index in acir_to_call.return_values.indices() {
                         if let Some(return_value) =
@@ -122,6 +164,7 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                         } else {
                             return Err(ExecutionError::SolvingError(
                                 OpcodeNotSolvable::MissingAssignment(return_witness_index).into(),
+                                None, // Missing assignment errors do not supply user-facing diagnostics so we do not need to attach a call stack
                             )
                             .into());
                         }
@@ -143,11 +186,9 @@ pub fn execute_program<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
     blackbox_solver: &B,
     foreign_call_executor: &mut F,
 ) -> Result<WitnessStack, NargoError> {
-    let main = &program.functions[0];
-
     let mut executor =
         ProgramExecutor::new(&program.functions, blackbox_solver, foreign_call_executor);
-    let main_witness = executor.execute_circuit(main, initial_witness)?;
+    let main_witness = executor.execute_circuit(initial_witness)?;
     executor.witness_stack.push(0, main_witness);
 
     Ok(executor.finalize())
diff --git a/tooling/nargo/src/ops/optimize.rs b/tooling/nargo/src/ops/optimize.rs
index cfaaf27ea98..a62f4696328 100644
--- a/tooling/nargo/src/ops/optimize.rs
+++ b/tooling/nargo/src/ops/optimize.rs
@@ -1,25 +1,36 @@
+use acvm::acir::circuit::Program;
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
-
-/// TODO(https://github.com/noir-lang/noir/issues/4428): Need to update how these passes are run to account for
-/// multiple ACIR functions
+use noirc_errors::debug_info::DebugInfo;
 
 pub fn optimize_program(mut compiled_program: CompiledProgram) -> CompiledProgram {
-    let (optimized_circuit, location_map) =
-        acvm::compiler::optimize(std::mem::take(&mut compiled_program.program.functions[0]));
-    compiled_program.program.functions[0] = optimized_circuit;
-    compiled_program.debug.update_acir(location_map);
+    compiled_program.program =
+        optimize_program_internal(compiled_program.program, &mut compiled_program.debug);
     compiled_program
 }
 
 pub fn optimize_contract(contract: CompiledContract) -> CompiledContract {
     let functions = vecmap(contract.functions, |mut func| {
-        let (optimized_bytecode, location_map) =
-            acvm::compiler::optimize(std::mem::take(&mut func.bytecode.functions[0]));
-        func.bytecode.functions[0] = optimized_bytecode;
-        func.debug.update_acir(location_map);
+        func.bytecode = optimize_program_internal(func.bytecode, &mut func.debug);
         func
     });
 
     CompiledContract { functions, ..contract }
 }
+
+fn optimize_program_internal(mut program: Program, debug: &mut [DebugInfo]) -> Program {
+    let functions = std::mem::take(&mut program.functions);
+
+    let optimized_functions = functions
+        .into_iter()
+        .enumerate()
+        .map(|(i, function)| {
+            let (optimized_circuit, location_map) = acvm::compiler::optimize(function);
+            debug[i].update_acir(location_map);
+            optimized_circuit
+        })
+        .collect::<Vec<_>>();
+
+    program.functions = optimized_functions;
+    program
+}
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 45b1a88f99c..b216fff827d 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -84,7 +84,7 @@ fn test_status_program_compile_fail(err: CompileError, test_function: &TestFunct
 /// passed/failed to determine the test status.
 fn test_status_program_compile_pass(
     test_function: &TestFunction,
-    debug: DebugInfo,
+    debug: Vec<DebugInfo>,
     circuit_execution: Result<WitnessStack, NargoError>,
 ) -> TestStatus {
     let circuit_execution_err = match circuit_execution {
diff --git a/tooling/nargo/src/ops/transform.rs b/tooling/nargo/src/ops/transform.rs
index 274286a46e4..b4811bd5780 100644
--- a/tooling/nargo/src/ops/transform.rs
+++ b/tooling/nargo/src/ops/transform.rs
@@ -1,21 +1,17 @@
-use acvm::acir::circuit::ExpressionWidth;
+use acvm::acir::circuit::{ExpressionWidth, Program};
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
-
-/// TODO(https://github.com/noir-lang/noir/issues/4428): Need to update how these passes are run to account for
-/// multiple ACIR functions
+use noirc_errors::debug_info::DebugInfo;
 
 pub fn transform_program(
     mut compiled_program: CompiledProgram,
     expression_width: ExpressionWidth,
 ) -> CompiledProgram {
-    let (optimized_circuit, location_map) = acvm::compiler::compile(
-        std::mem::take(&mut compiled_program.program.functions[0]),
+    compiled_program.program = transform_program_internal(
+        compiled_program.program,
+        &mut compiled_program.debug,
         expression_width,
     );
-
-    compiled_program.program.functions[0] = optimized_circuit;
-    compiled_program.debug.update_acir(location_map);
     compiled_program
 }
 
@@ -24,14 +20,33 @@ pub fn transform_contract(
     expression_width: ExpressionWidth,
 ) -> CompiledContract {
     let functions = vecmap(contract.functions, |mut func| {
-        let (optimized_bytecode, location_map) = acvm::compiler::compile(
-            std::mem::take(&mut func.bytecode.functions[0]),
-            expression_width,
-        );
-        func.bytecode.functions[0] = optimized_bytecode;
-        func.debug.update_acir(location_map);
+        func.bytecode =
+            transform_program_internal(func.bytecode, &mut func.debug, expression_width);
+
         func
     });
 
     CompiledContract { functions, ..contract }
 }
+
+fn transform_program_internal(
+    mut program: Program,
+    debug: &mut [DebugInfo],
+    expression_width: ExpressionWidth,
+) -> Program {
+    let functions = std::mem::take(&mut program.functions);
+
+    let optimized_functions = functions
+        .into_iter()
+        .enumerate()
+        .map(|(i, function)| {
+            let (optimized_circuit, location_map) =
+                acvm::compiler::compile(function, expression_width);
+            debug[i].update_acir(location_map);
+            optimized_circuit
+        })
+        .collect::<Vec<_>>();
+
+    program.functions = optimized_functions;
+    program
+}
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 4f3e2886b2e..6a3f0094a08 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -232,7 +232,7 @@ pub(crate) fn debug_program(
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
     let debug_artifact = DebugArtifact {
-        debug_symbols: vec![compiled_program.debug.clone()],
+        debug_symbols: compiled_program.debug.clone(),
         file_map: compiled_program.file_map.clone(),
         warnings: compiled_program.warnings.clone(),
     };
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 697f6d7c1ea..a353065491f 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -149,7 +149,7 @@ pub(crate) fn execute_program(
         Ok(solved_witness_stack) => Ok(solved_witness_stack),
         Err(err) => {
             let debug_artifact = DebugArtifact {
-                debug_symbols: vec![compiled_program.debug.clone()],
+                debug_symbols: compiled_program.debug.clone(),
                 file_map: compiled_program.file_map.clone(),
                 warnings: compiled_program.warnings.clone(),
             };
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 72784013e17..77a84de07a4 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -97,17 +97,21 @@ pub(crate) fn run(
 
     if args.profile_info {
         for compiled_program in &compiled_programs {
-            let span_opcodes = compiled_program.debug.count_span_opcodes();
             let debug_artifact = DebugArtifact::from(compiled_program.clone());
-            print_span_opcodes(span_opcodes, &debug_artifact);
+            for function_debug in compiled_program.debug.iter() {
+                let span_opcodes = function_debug.count_span_opcodes();
+                print_span_opcodes(span_opcodes, &debug_artifact);
+            }
         }
 
         for compiled_contract in &compiled_contracts {
             let debug_artifact = DebugArtifact::from(compiled_contract.clone());
             let functions = &compiled_contract.functions;
             for contract_function in functions {
-                let span_opcodes = contract_function.debug.count_span_opcodes();
-                print_span_opcodes(span_opcodes, &debug_artifact);
+                for function_debug in contract_function.debug.iter() {
+                    let span_opcodes = function_debug.count_span_opcodes();
+                    print_span_opcodes(span_opcodes, &debug_artifact);
+                }
             }
         }
     }

From 25ad018a55b61dd861e899f050c48200f0a00430 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Mon, 15 Apr 2024 09:36:05 -0400
Subject: [PATCH 181/416] feat: lalrpop lexer prototype (#4656)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4655

## Summary\*

NOTE: I've added `CC0-1.0` to `deny.toml`. Its purpose is to release
work to the public domain.

### TL;DR

[`lalrpop`](https://github.com/lalrpop/lalrpop) generates a part of a
parser for our grammar and the `noirc_frontend/experimental_parser`
feature can be used to run it alongside the existing parser: when the
existing `chumsky` parser succeeds, the `lalrpop` parser is run and the
results compared.

### Detail

Run with `cargo test --features=noirc_frontend/experimental_parser`

Originally investigating lalrpop for _lexing_, now for _parsing_:
- lalrpop doesn't handle string literals with escape characters well
  + this is due to how LR(1) parsers handle context
+ I realized this after discovering that all of the larger examples
(solidity, python, etc) use the lexer to handle strings
- pivoted this PR to use our existing lexer
+ this entailed a version of `Token` without `String` so that e.g.
`Token::Str("hi")` can be matched on. (which is essential to lalrpop)
  + currently using a shim to minimize impact to the rest of the code:
    * conversion to/from `SpannedToken`
* lexing the whole input into a `Vec` and using `iter()` to feed token
lifetimes to lalrpop
- current state:
+ WIP parsing use statements (missing support for recursive statements)
  + unit tests for use statements test lalrpop parser
+ feature flag `experimental_parser` enables running the experimental
parser on every part of the AST that's successfully parsed with the
existing chomsky parser

Changes:
- Now rejecting whitespace other than `\t \n\r`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 Cargo.lock                                    | 122 ++++++++++++-
 compiler/noirc_frontend/Cargo.toml            |   7 +
 compiler/noirc_frontend/build.rs              |  28 +++
 compiler/noirc_frontend/src/lexer/lexer.rs    |  30 +++-
 compiler/noirc_frontend/src/lexer/token.rs    | 150 ++++++++++++++++
 .../noirc_frontend/src/noir_parser.lalrpop    | 164 ++++++++++++++++++
 compiler/noirc_frontend/src/parser/errors.rs  |  14 +-
 compiler/noirc_frontend/src/parser/parser.rs  | 151 +++++++++++++---
 deny.toml                                     |   3 +-
 9 files changed, 625 insertions(+), 44 deletions(-)
 create mode 100644 compiler/noirc_frontend/build.rs
 create mode 100644 compiler/noirc_frontend/src/noir_parser.lalrpop

diff --git a/Cargo.lock b/Cargo.lock
index e62f966b8fd..dec9cf7ad4f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -268,7 +268,7 @@ dependencies = [
  "ark-std",
  "derivative",
  "hashbrown 0.13.2",
- "itertools",
+ "itertools 0.10.5",
  "num-traits",
  "zeroize",
 ]
@@ -285,7 +285,7 @@ dependencies = [
  "ark-std",
  "derivative",
  "digest",
- "itertools",
+ "itertools 0.10.5",
  "num-bigint",
  "num-traits",
  "paste",
@@ -374,6 +374,15 @@ version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 
+[[package]]
+name = "ascii-canvas"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+dependencies = [
+ "term",
+]
+
 [[package]]
 name = "assert_cmd"
 version = "2.0.12"
@@ -1178,7 +1187,7 @@ dependencies = [
  "clap",
  "criterion-plot",
  "is-terminal",
- "itertools",
+ "itertools 0.10.5",
  "num-traits",
  "once_cell",
  "oorandom",
@@ -1199,7 +1208,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
  "cast",
- "itertools",
+ "itertools 0.10.5",
 ]
 
 [[package]]
@@ -1255,6 +1264,12 @@ dependencies = [
  "cfg-if 1.0.0",
 ]
 
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
 [[package]]
 name = "crypto-bigint"
 version = "0.4.9"
@@ -1526,6 +1541,15 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "ena"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c533630cf40e9caa44bd91aadc88a75d75a4c3a12b4cfde353cbed41daa1e1f1"
+dependencies = [
+ "log",
+]
+
 [[package]]
 name = "encode_unicode"
 version = "0.3.6"
@@ -2364,6 +2388,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.9"
@@ -2534,6 +2567,37 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "lalrpop"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca"
+dependencies = [
+ "ascii-canvas",
+ "bit-set",
+ "ena",
+ "itertools 0.11.0",
+ "lalrpop-util",
+ "petgraph",
+ "pico-args",
+ "regex",
+ "regex-syntax 0.8.2",
+ "string_cache",
+ "term",
+ "tiny-keccak",
+ "unicode-xid",
+ "walkdir",
+]
+
+[[package]]
+name = "lalrpop-util"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553"
+dependencies = [
+ "regex-automata 0.4.5",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -2856,6 +2920,12 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
 [[package]]
 name = "nibble_vec"
 version = "0.1.0"
@@ -3087,6 +3157,8 @@ dependencies = [
  "chumsky",
  "fm",
  "iter-extended",
+ "lalrpop",
+ "lalrpop-util",
  "noirc_errors",
  "noirc_printable_type",
  "petgraph",
@@ -3386,6 +3458,12 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "pico-args"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.13"
@@ -3470,6 +3548,12 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
 [[package]]
 name = "predicates"
 version = "2.1.5"
@@ -3478,7 +3562,7 @@ checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
 dependencies = [
  "difflib",
  "float-cmp",
- "itertools",
+ "itertools 0.10.5",
  "normalize-line-endings",
  "predicates-core",
  "regex",
@@ -3492,7 +3576,7 @@ checksum = "09963355b9f467184c04017ced4a2ba2d75cbcb4e7462690d388233253d4b1a9"
 dependencies = [
  "anstyle",
  "difflib",
- "itertools",
+ "itertools 0.10.5",
  "predicates-core",
 ]
 
@@ -4603,6 +4687,19 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9091b6114800a5f2141aee1d1b9d6ca3592ac062dc5decb3764ec5895a47b4eb"
 
+[[package]]
+name = "string_cache"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b"
+dependencies = [
+ "new_debug_unreachable",
+ "once_cell",
+ "parking_lot 0.12.1",
+ "phf_shared",
+ "precomputed-hash",
+]
+
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -4845,6 +4942,15 @@ dependencies = [
  "time-core",
 ]
 
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -5266,9 +5372,9 @@ dependencies = [
 
 [[package]]
 name = "walkdir"
-version = "2.3.3"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
  "same-file",
  "winapi-util",
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index 03b92e15032..e39ab2fe106 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -24,9 +24,16 @@ small-ord-set = "0.1.3"
 regex = "1.9.1"
 tracing.workspace = true
 petgraph = "0.6"
+lalrpop-util = { version = "0.20.2", features = ["lexer"] }
 
 [dev-dependencies]
 base64.workspace = true
 strum = "0.24"
 strum_macros = "0.24"
 tempfile.workspace = true
+
+[build-dependencies]
+lalrpop = "0.20.2"
+
+[features]
+experimental_parser = []
diff --git a/compiler/noirc_frontend/build.rs b/compiler/noirc_frontend/build.rs
new file mode 100644
index 00000000000..eb896a377ae
--- /dev/null
+++ b/compiler/noirc_frontend/build.rs
@@ -0,0 +1,28 @@
+use std::fs::{read_to_string, File};
+use std::io::Write;
+
+fn main() {
+    lalrpop::Configuration::new()
+        .emit_rerun_directives(true)
+        .use_cargo_dir_conventions()
+        .process()
+        .unwrap();
+
+    // here, we get a lint error from "extern crate core" so patching that until lalrpop does
+    // (adding cfg directives appears to be unsupported by lalrpop)
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    let parser_path = std::path::Path::new(&out_dir).join("noir_parser.rs");
+    let content_str = read_to_string(parser_path.clone()).unwrap();
+    let mut parser_file = File::create(parser_path).unwrap();
+    for line in content_str.lines() {
+        if line.contains("extern crate core") {
+            parser_file
+                .write_all(
+                    format!("{}\n", line.replace("extern crate core", "use core")).as_bytes(),
+                )
+                .unwrap();
+        } else {
+            parser_file.write_all(format!("{}\n", line).as_bytes()).unwrap();
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index 265b9e4b5a3..2d1ebf530e3 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -2,7 +2,9 @@ use crate::token::{Attribute, DocStyle};
 
 use super::{
     errors::LexerErrorKind,
-    token::{IntType, Keyword, SpannedToken, Token, Tokens},
+    token::{
+        token_to_borrowed_token, BorrowedToken, IntType, Keyword, SpannedToken, Token, Tokens,
+    },
 };
 use acvm::FieldElement;
 use noirc_errors::{Position, Span};
@@ -21,6 +23,21 @@ pub struct Lexer<'a> {
 
 pub type SpannedTokenResult = Result<SpannedToken, LexerErrorKind>;
 
+pub(crate) fn from_spanned_token_result(
+    token_result: &SpannedTokenResult,
+) -> Result<(usize, BorrowedToken<'_>, usize), LexerErrorKind> {
+    token_result
+        .as_ref()
+        .map(|spanned_token| {
+            (
+                spanned_token.to_span().start() as usize,
+                token_to_borrowed_token(spanned_token.into()),
+                spanned_token.to_span().end() as usize,
+            )
+        })
+        .map_err(Clone::clone)
+}
+
 impl<'a> Lexer<'a> {
     /// Given a source file of noir code, return all the tokens in the file
     /// in order, along with any lexing errors that occurred.
@@ -94,7 +111,7 @@ impl<'a> Lexer<'a> {
 
     fn next_token(&mut self) -> SpannedTokenResult {
         match self.next_char() {
-            Some(x) if x.is_whitespace() => {
+            Some(x) if Self::is_code_whitespace(x) => {
                 let spanned = self.eat_whitespace(x);
                 if self.skip_whitespaces {
                     self.next_token()
@@ -560,16 +577,21 @@ impl<'a> Lexer<'a> {
         }
     }
 
+    fn is_code_whitespace(c: char) -> bool {
+        c == '\t' || c == '\n' || c == '\r' || c == ' '
+    }
+
     /// Skips white space. They are not significant in the source language
     fn eat_whitespace(&mut self, initial_char: char) -> SpannedToken {
         let start = self.position;
-        let whitespace = self.eat_while(initial_char.into(), |ch| ch.is_whitespace());
+        let whitespace = self.eat_while(initial_char.into(), Self::is_code_whitespace);
         SpannedToken::new(Token::Whitespace(whitespace), Span::inclusive(start, self.position))
     }
 }
 
 impl<'a> Iterator for Lexer<'a> {
     type Item = SpannedTokenResult;
+
     fn next(&mut self) -> Option<Self::Item> {
         if self.done {
             None
@@ -578,10 +600,12 @@ impl<'a> Iterator for Lexer<'a> {
         }
     }
 }
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::token::{FunctionAttribute, SecondaryAttribute, TestScope};
+
     #[test]
     fn test_single_double_char() {
         let input = "! != + ( ) { } [ ] | , ; : :: < <= > >= & - -> . .. % / * = == << >>";
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 357b1ead593..86f26fd1c97 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -9,12 +9,105 @@ use crate::lexer::errors::LexerErrorKind;
 /// smallest unit of grammar. A parser may (will) decide to parse
 /// items differently depending on the Tokens present but will
 /// never parse the same ordering of identical tokens differently.
+#[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
+pub enum BorrowedToken<'input> {
+    Ident(&'input str),
+    Int(FieldElement),
+    Bool(bool),
+    Str(&'input str),
+    /// the u8 is the number of hashes, i.e. r###..
+    RawStr(&'input str, u8),
+    FmtStr(&'input str),
+    Keyword(Keyword),
+    IntType(IntType),
+    Attribute(Attribute),
+    LineComment(&'input str, Option<DocStyle>),
+    BlockComment(&'input str, Option<DocStyle>),
+    /// <
+    Less,
+    /// <=
+    LessEqual,
+    /// >
+    Greater,
+    /// >=
+    GreaterEqual,
+    /// ==
+    Equal,
+    /// !=
+    NotEqual,
+    /// +
+    Plus,
+    /// -
+    Minus,
+    /// *
+    Star,
+    /// /
+    Slash,
+    /// %
+    Percent,
+    /// &
+    Ampersand,
+    /// ^
+    Caret,
+    /// <<
+    ShiftLeft,
+    /// >>
+    ShiftRight,
+    /// .
+    Dot,
+    /// ..
+    DoubleDot,
+    /// (
+    LeftParen,
+    /// )
+    RightParen,
+    /// {
+    LeftBrace,
+    /// }
+    RightBrace,
+    /// [
+    LeftBracket,
+    /// ]
+    RightBracket,
+    /// ->
+    Arrow,
+    /// |
+    Pipe,
+    /// #
+    Pound,
+    /// ,
+    Comma,
+    /// :
+    Colon,
+    /// ::
+    DoubleColon,
+    /// ;
+    Semicolon,
+    /// !
+    Bang,
+    /// =
+    Assign,
+    #[allow(clippy::upper_case_acronyms)]
+    EOF,
+
+    Whitespace(&'input str),
+
+    /// An invalid character is one that is not in noir's language or grammar.
+    ///
+    /// We don't report invalid tokens in the source as errors until parsing to
+    /// avoid reporting the error twice (once while lexing, again when it is encountered
+    /// during parsing). Reporting during lexing then removing these from the token stream
+    /// would not be equivalent as it would change the resulting parse.
+    Invalid(char),
+}
+
 #[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
 pub enum Token {
     Ident(String),
     Int(FieldElement),
     Bool(bool),
     Str(String),
+    /// the u8 is the number of hashes, i.e. r###..
     RawStr(String, u8),
     FmtStr(String),
     Keyword(Keyword),
@@ -100,6 +193,57 @@ pub enum Token {
     Invalid(char),
 }
 
+pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
+    match token {
+        Token::Ident(ref s) => BorrowedToken::Ident(s),
+        Token::Int(n) => BorrowedToken::Int(*n),
+        Token::Bool(b) => BorrowedToken::Bool(*b),
+        Token::Str(ref b) => BorrowedToken::Str(b),
+        Token::FmtStr(ref b) => BorrowedToken::FmtStr(b),
+        Token::RawStr(ref b, hashes) => BorrowedToken::RawStr(b, *hashes),
+        Token::Keyword(k) => BorrowedToken::Keyword(*k),
+        Token::Attribute(ref a) => BorrowedToken::Attribute(a.clone()),
+        Token::LineComment(ref s, _style) => BorrowedToken::LineComment(s, *_style),
+        Token::BlockComment(ref s, _style) => BorrowedToken::BlockComment(s, *_style),
+        Token::IntType(ref i) => BorrowedToken::IntType(i.clone()),
+        Token::Less => BorrowedToken::Less,
+        Token::LessEqual => BorrowedToken::LessEqual,
+        Token::Greater => BorrowedToken::Greater,
+        Token::GreaterEqual => BorrowedToken::GreaterEqual,
+        Token::Equal => BorrowedToken::Equal,
+        Token::NotEqual => BorrowedToken::NotEqual,
+        Token::Plus => BorrowedToken::Plus,
+        Token::Minus => BorrowedToken::Minus,
+        Token::Star => BorrowedToken::Star,
+        Token::Slash => BorrowedToken::Slash,
+        Token::Percent => BorrowedToken::Percent,
+        Token::Ampersand => BorrowedToken::Ampersand,
+        Token::Caret => BorrowedToken::Caret,
+        Token::ShiftLeft => BorrowedToken::ShiftLeft,
+        Token::ShiftRight => BorrowedToken::ShiftRight,
+        Token::Dot => BorrowedToken::Dot,
+        Token::DoubleDot => BorrowedToken::DoubleDot,
+        Token::LeftParen => BorrowedToken::LeftParen,
+        Token::RightParen => BorrowedToken::RightParen,
+        Token::LeftBrace => BorrowedToken::LeftBrace,
+        Token::RightBrace => BorrowedToken::RightBrace,
+        Token::LeftBracket => BorrowedToken::LeftBracket,
+        Token::RightBracket => BorrowedToken::RightBracket,
+        Token::Arrow => BorrowedToken::Arrow,
+        Token::Pipe => BorrowedToken::Pipe,
+        Token::Pound => BorrowedToken::Pound,
+        Token::Comma => BorrowedToken::Comma,
+        Token::Colon => BorrowedToken::Colon,
+        Token::DoubleColon => BorrowedToken::DoubleColon,
+        Token::Semicolon => BorrowedToken::Semicolon,
+        Token::Assign => BorrowedToken::Assign,
+        Token::Bang => BorrowedToken::Bang,
+        Token::EOF => BorrowedToken::EOF,
+        Token::Invalid(c) => BorrowedToken::Invalid(*c),
+        Token::Whitespace(ref s) => BorrowedToken::Whitespace(s),
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
 pub enum DocStyle {
     Outer,
@@ -126,6 +270,12 @@ impl From<SpannedToken> for Token {
     }
 }
 
+impl<'a> From<&'a SpannedToken> for &'a Token {
+    fn from(spt: &'a SpannedToken) -> Self {
+        &spt.0.contents
+    }
+}
+
 impl SpannedToken {
     pub fn new(token: Token, span: Span) -> SpannedToken {
         SpannedToken(Spanned::from(span, token))
diff --git a/compiler/noirc_frontend/src/noir_parser.lalrpop b/compiler/noirc_frontend/src/noir_parser.lalrpop
new file mode 100644
index 00000000000..c8d293fb72f
--- /dev/null
+++ b/compiler/noirc_frontend/src/noir_parser.lalrpop
@@ -0,0 +1,164 @@
+use noirc_errors::Span;
+
+use crate::lexer::token::BorrowedToken;
+use crate::lexer::token as noir_token;
+use crate::lexer::errors::LexerErrorKind;
+use crate::parser::TopLevelStatement;
+use crate::{Ident, Path, PathKind, UseTree, UseTreeKind};
+
+use lalrpop_util::ErrorRecovery;
+
+grammar<'input, 'err>(input: &'input str, errors: &'err mut [ErrorRecovery<usize, BorrowedToken<'input>, &'static str>]);
+
+extern {
+    type Location = usize;
+
+    type Error = LexerErrorKind;
+
+    // NOTE: each token needs a terminal defined
+    enum BorrowedToken<'input> {
+        string => BorrowedToken::Str(<&'input str>),
+        ident => BorrowedToken::Ident(<&'input str>),
+
+        // symbols
+        "<" => BorrowedToken::Less,
+        "<=" => BorrowedToken::LessEqual,
+        ">" => BorrowedToken::Greater,
+        ">=" => BorrowedToken::GreaterEqual,
+        "==" => BorrowedToken::Equal,
+        "!=" => BorrowedToken::NotEqual,
+        "+" => BorrowedToken::Plus,
+        "-" => BorrowedToken::Minus,
+        "*" => BorrowedToken::Star,
+        "/" => BorrowedToken::Slash,
+        "%" => BorrowedToken::Percent,
+        "&" => BorrowedToken::Ampersand,
+        "^" => BorrowedToken::Caret,
+        "<<" => BorrowedToken::ShiftLeft,
+        ">>" => BorrowedToken::ShiftRight,
+        "." => BorrowedToken::Dot,
+        ".." => BorrowedToken::DoubleDot,
+        "(" => BorrowedToken::LeftParen,
+        ")" => BorrowedToken::RightParen,
+        "{" => BorrowedToken::LeftBrace,
+        "}" => BorrowedToken::RightBrace,
+        "[" => BorrowedToken::LeftBracket,
+        "]" => BorrowedToken::RightBracket,
+        "->" => BorrowedToken::Arrow,
+        "|" => BorrowedToken::Pipe,
+        "#" => BorrowedToken::Pound,
+        "," => BorrowedToken::Comma,
+        ":" => BorrowedToken::Colon,
+        "::" => BorrowedToken::DoubleColon,
+        ";" => BorrowedToken::Semicolon,
+        "!" => BorrowedToken::Bang,
+        "=" => BorrowedToken::Assign,
+        // keywords
+        "as" => BorrowedToken::Keyword(noir_token::Keyword::As),
+        "assert" => BorrowedToken::Keyword(noir_token::Keyword::Assert),
+        "assert_eq" => BorrowedToken::Keyword(noir_token::Keyword::AssertEq),
+        "bool" => BorrowedToken::Keyword(noir_token::Keyword::Bool),
+        "break" => BorrowedToken::Keyword(noir_token::Keyword::Break),
+        "call_data" => BorrowedToken::Keyword(noir_token::Keyword::CallData),
+        "char" => BorrowedToken::Keyword(noir_token::Keyword::Char),
+        "comptime" => BorrowedToken::Keyword(noir_token::Keyword::CompTime),
+        "constrain" => BorrowedToken::Keyword(noir_token::Keyword::Constrain),
+        "continue" => BorrowedToken::Keyword(noir_token::Keyword::Continue),
+        "contract" => BorrowedToken::Keyword(noir_token::Keyword::Contract),
+        "crate" => BorrowedToken::Keyword(noir_token::Keyword::Crate),
+        "dep" => BorrowedToken::Keyword(noir_token::Keyword::Dep),
+        "distinct" => BorrowedToken::Keyword(noir_token::Keyword::Distinct),
+        "else" => BorrowedToken::Keyword(noir_token::Keyword::Else),
+        "Field" => BorrowedToken::Keyword(noir_token::Keyword::Field),
+        "fn" => BorrowedToken::Keyword(noir_token::Keyword::Fn),
+        "for" => BorrowedToken::Keyword(noir_token::Keyword::For),
+        "fmtstr" => BorrowedToken::Keyword(noir_token::Keyword::FormatString),
+        "global" => BorrowedToken::Keyword(noir_token::Keyword::Global),
+        "if" => BorrowedToken::Keyword(noir_token::Keyword::If),
+        "impl" => BorrowedToken::Keyword(noir_token::Keyword::Impl),
+        "in" => BorrowedToken::Keyword(noir_token::Keyword::In),
+        "let" => BorrowedToken::Keyword(noir_token::Keyword::Let),
+        "mod" => BorrowedToken::Keyword(noir_token::Keyword::Mod),
+        "mut" => BorrowedToken::Keyword(noir_token::Keyword::Mut),
+        "pub" => BorrowedToken::Keyword(noir_token::Keyword::Pub),
+        "quote" => BorrowedToken::Keyword(noir_token::Keyword::Quote),
+        "return" => BorrowedToken::Keyword(noir_token::Keyword::Return),
+        "return_data" => BorrowedToken::Keyword(noir_token::Keyword::ReturnData),
+        "str" => BorrowedToken::Keyword(noir_token::Keyword::String),
+        "struct" => BorrowedToken::Keyword(noir_token::Keyword::Struct),
+        "trait" => BorrowedToken::Keyword(noir_token::Keyword::Trait),
+        "type" => BorrowedToken::Keyword(noir_token::Keyword::Type),
+        "unchecked" => BorrowedToken::Keyword(noir_token::Keyword::Unchecked),
+        "unconstrained" => BorrowedToken::Keyword(noir_token::Keyword::Unconstrained),
+        "use" => BorrowedToken::Keyword(noir_token::Keyword::Use),
+        "where" => BorrowedToken::Keyword(noir_token::Keyword::Where),
+        "while" => BorrowedToken::Keyword(noir_token::Keyword::While),
+        // bool
+        "true" => BorrowedToken::Bool(true),
+        "false" => BorrowedToken::Bool(false),
+
+        r"[\t\r\n ]+" => BorrowedToken::Whitespace(_),
+
+        EOF => BorrowedToken::EOF,
+    }
+}
+
+pub(crate) TopLevelStatement: TopLevelStatement = {
+    "use" r"[\t\r\n ]+" <use_tree:UseTree> ";" <trailing_spaces:r"[\t\r\n ]+"?> EOF => {
+        TopLevelStatement::Import(use_tree)
+    }
+}
+
+UseTree: UseTree = {
+    // path::to::ident as SomeAlias
+    <mut prefix:Path> <alias:Alias?> => {
+        let ident = prefix.pop();
+        let kind = UseTreeKind::Path(ident, alias);
+        UseTree { prefix, kind }
+    },
+}
+
+pub(crate) Path: Path = {
+    <lo:@L> "crate" "::" <segments:PathSegments> <hi:@R> => {
+        let kind = PathKind::Crate;
+        let span = Span::from(lo as u32..hi as u32);
+        Path { segments, kind, span }
+    },
+
+    <lo:@L> "dep" "::" <segments:PathSegments> <hi:@R> => {
+        let kind = PathKind::Dep;
+        let span = Span::from(lo as u32..hi as u32);
+        Path { segments, kind, span }
+    },
+
+    <lo:@L> <id:Ident> <mut segments:PathSegments> <hi:@R> => {
+        segments.insert(0, id);
+        let kind = PathKind::Plain;
+        let span = Span::from(lo as u32..hi as u32);
+        Path { segments, kind, span }
+    },
+}
+
+PathSegments: Vec<Ident> = {
+    <lo:@L> <segments:("::" <Ident>)*> <hi:@R> => {
+        segments
+    }
+}
+
+Alias: Ident = {
+    r"[\t\r\n ]+" "as" r"[\t\r\n ]+" <Ident> => <>,
+}
+
+Ident: Ident = {
+    <lo:@L> <i:ident> <hi:@R> => {
+        let token = noir_token::Token::Ident(i.to_string());
+        let span = Span::from(lo as u32..hi as u32);
+        Ident::from_token(token, span)
+    },
+}
+
+Bool: BorrowedToken<'input> = {
+    "true" => BorrowedToken::Bool(true),
+    "false" => BorrowedToken::Bool(false),
+};
+
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index 43a1f96f13f..895d4e07bbd 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -110,25 +110,31 @@ impl ParserError {
 
 impl std::fmt::Display for ParserError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason_str: String = if self.reason.is_none() {
+            "".to_string()
+        } else {
+            format!("\nreason: {}", Diagnostic::from(self.clone()))
+        };
         let mut expected = vecmap(&self.expected_tokens, ToString::to_string);
         expected.append(&mut vecmap(&self.expected_labels, |label| format!("{label}")));
 
         if expected.is_empty() {
-            write!(f, "Unexpected {} in input", self.found)
+            write!(f, "Unexpected {} in input{}", self.found, reason_str)
         } else if expected.len() == 1 {
             let first = expected.first().unwrap();
             let vowel = "aeiou".contains(first.chars().next().unwrap());
             write!(
                 f,
-                "Expected a{} {} but found {}",
+                "Expected a{} {} but found {}{}",
                 if vowel { "n" } else { "" },
                 first,
-                self.found
+                self.found,
+                reason_str
             )
         } else {
             let expected = expected.iter().map(ToString::to_string).collect::<Vec<_>>().join(", ");
 
-            write!(f, "Unexpected {}, expected one of {}", self.found, expected)
+            write!(f, "Unexpected {}, expected one of {}{}", self.found, expected, reason_str)
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 0a21465fe87..1bedf904da2 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -35,7 +35,7 @@ use super::{spanned, Item, ItemKind};
 use crate::ast::{
     Expression, ExpressionKind, LetStatement, StatementKind, UnresolvedType, UnresolvedTypeData,
 };
-use crate::lexer::Lexer;
+use crate::lexer::{lexer::from_spanned_token_result, Lexer};
 use crate::parser::{force, ignore_then_commit, statement_recovery};
 use crate::token::{Keyword, Token, TokenKind};
 use crate::{
@@ -47,6 +47,7 @@ use crate::{
 
 use chumsky::prelude::*;
 use iter_extended::vecmap;
+use lalrpop_util::lalrpop_mod;
 use noirc_errors::{Span, Spanned};
 
 mod assertion;
@@ -59,6 +60,9 @@ mod primitives;
 mod structs;
 mod traits;
 
+// synthesized by LALRPOP
+lalrpop_mod!(pub noir_parser);
+
 #[cfg(test)]
 mod test_helpers;
 
@@ -77,8 +81,79 @@ pub fn parse_program(source_program: &str) -> (ParsedModule, Vec<ParserError>) {
     let (module, mut parsing_errors) = program().parse_recovery_verbose(tokens);
 
     parsing_errors.extend(lexing_errors.into_iter().map(Into::into));
+    let parsed_module = module.unwrap_or(ParsedModule { items: vec![] });
+
+    if cfg!(feature = "experimental_parser") {
+        for parsed_item in &parsed_module.items {
+            if lalrpop_parser_supports_kind(&parsed_item.kind) {
+                match &parsed_item.kind {
+                    ItemKind::Import(parsed_use_tree) => {
+                        prototype_parse_use_tree(Some(parsed_use_tree), source_program);
+                    }
+                    // other kinds prevented by lalrpop_parser_supports_kind
+                    _ => unreachable!(),
+                }
+            }
+        }
+    }
+    (parsed_module, parsing_errors)
+}
+
+fn prototype_parse_use_tree(expected_use_tree_opt: Option<&UseTree>, input: &str) {
+    // TODO(https://github.com/noir-lang/noir/issues/4777): currently skipping
+    // recursive use trees, e.g. "use std::{foo, bar}"
+    if input.contains('{') {
+        return;
+    }
+
+    let mut lexer = Lexer::new(input);
+    lexer = lexer.skip_whitespaces(false);
+    let mut errors = Vec::new();
+
+    // NOTE: this is a hack to get the references working
+    // => this likely means that we'll want to propagate the <'input> lifetime further into Token
+    let lexer_result = lexer.collect::<Vec<_>>();
+    let referenced_lexer_result = lexer_result.iter().map(from_spanned_token_result);
+
+    let calculated = noir_parser::TopLevelStatementParser::new().parse(
+        input,
+        &mut errors,
+        referenced_lexer_result,
+    );
+
+    if let Some(expected_use_tree) = expected_use_tree_opt {
+        assert!(
+            calculated.is_ok(),
+            "calculated not Ok(_): {:?}\n\nlexer: {:?}\n\ninput: {:?}",
+            calculated,
+            lexer_result,
+            input
+        );
+
+        match calculated.unwrap() {
+            TopLevelStatement::Import(parsed_use_tree) => {
+                assert_eq!(expected_use_tree, &parsed_use_tree);
+            }
+            unexpected_calculated => {
+                panic!(
+                    "expected a TopLevelStatement::Import, but found: {:?}",
+                    unexpected_calculated
+                )
+            }
+        }
+    } else {
+        assert!(
+            calculated.is_err(),
+            "calculated not Err(_): {:?}\n\nlexer: {:?}\n\ninput: {:?}",
+            calculated,
+            lexer_result,
+            input
+        );
+    }
+}
 
-    (module.unwrap_or(ParsedModule { items: vec![] }), parsing_errors)
+fn lalrpop_parser_supports_kind(kind: &ItemKind) -> bool {
+    matches!(kind, ItemKind::Import(_))
 }
 
 /// program: module EOF
@@ -1512,33 +1587,53 @@ mod test {
 
     #[test]
     fn parse_use() {
-        parse_all(
-            use_statement(),
-            vec![
-                "use std::hash",
-                "use std",
-                "use foo::bar as hello",
-                "use bar as bar",
-                "use foo::{}",
-                "use foo::{bar,}",
-                "use foo::{bar, hello}",
-                "use foo::{bar as bar2, hello}",
-                "use foo::{bar as bar2, hello::{foo}, nested::{foo, bar}}",
-                "use dep::{std::println, bar::baz}",
-            ],
-        );
+        let mut valid_use_statements = vec![
+            "use std::hash",
+            "use std",
+            "use foo::bar as hello",
+            "use bar as bar",
+            "use foo::{}",
+            "use foo::{bar,}",
+            "use foo::{bar, hello}",
+            "use foo::{bar as bar2, hello}",
+            "use foo::{bar as bar2, hello::{foo}, nested::{foo, bar}}",
+            "use dep::{std::println, bar::baz}",
+        ];
 
-        parse_all_failing(
-            use_statement(),
-            vec![
-                "use std as ;",
-                "use foobar as as;",
-                "use hello:: as foo;",
-                "use foo bar::baz",
-                "use foo bar::{baz}",
-                "use foo::{,}",
-            ],
-        );
+        let mut invalid_use_statements = vec![
+            "use std as ;",
+            "use foobar as as;",
+            "use hello:: as foo;",
+            "use foo bar::baz",
+            "use foo bar::{baz}",
+            "use foo::{,}",
+        ];
+
+        let use_statements = valid_use_statements
+            .iter_mut()
+            .map(|valid_str| (valid_str, true))
+            .chain(invalid_use_statements.iter_mut().map(|invalid_str| (invalid_str, false)));
+
+        for (use_statement_str, expect_valid) in use_statements {
+            let mut use_statement_str = use_statement_str.to_string();
+            let expected_use_statement = if expect_valid {
+                let (result_opt, _diagnostics) =
+                    parse_recover(&use_statement(), &use_statement_str);
+                use_statement_str.push(';');
+                match result_opt.unwrap() {
+                    TopLevelStatement::Import(expected_use_statement) => {
+                        Some(expected_use_statement)
+                    }
+                    _ => unreachable!(),
+                }
+            } else {
+                let result = parse_with(&use_statement(), &use_statement_str);
+                assert!(result.is_err());
+                None
+            };
+
+            prototype_parse_use_tree(expected_use_statement.as_ref(), &use_statement_str);
+        }
     }
 
     #[test]
diff --git a/deny.toml b/deny.toml
index eff233687e8..db7e53cad24 100644
--- a/deny.toml
+++ b/deny.toml
@@ -58,7 +58,7 @@ allow = [
     # bitmaps 2.1.0, im 15.1.0
     "MPL-2.0",
     # Boost Software License
-    "BSL-1.0",
+    "BSL-1.0"
 ]
 
 # Allow 1 or more licenses on a per-crate basis, so that particular licenses
@@ -70,6 +70,7 @@ exceptions = [
     { allow = ["CC0-1.0"], name = "more-asserts" },
     { allow = ["CC0-1.0"], name = "jsonrpc" },
     { allow = ["CC0-1.0"], name = "notify" },
+    { allow = ["CC0-1.0"], name = "tiny-keccak" },
     { allow = ["MPL-2.0"], name = "sized-chunks" },
     { allow = ["MPL-2.0"], name = "webpki-roots" },
 

From 5b352d6266c40522f5626f79d2f36a409b482aaa Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Mon, 15 Apr 2024 10:46:35 -0400
Subject: [PATCH 182/416] feat: Sync from aztec-packages (#4792)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
fix: primary_message typo in errors.rs
(https://github.com/AztecProtocol/aztec-packages/pull/5646)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5725)
feat: Proving the rollup circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5599)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Santiago Palladino <santiago@aztecprotocol.com>
Co-authored-by: vezenovm <mvezenov@gmail.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .aztec-sync-commit                      |  2 +-
 aztec_macros/src/utils/errors.rs        |  2 +-
 tooling/acvm_cli/src/cli/execute_cmd.rs |  7 ++--
 tooling/acvm_cli/src/cli/fs/witness.rs  | 47 ++++++++++++++++++-------
 tooling/acvm_cli/src/errors.rs          |  3 --
 tooling/noirc_abi_wasm/build.sh         |  5 ++-
 tooling/noirc_abi_wasm/src/lib.rs       | 11 +++++-
 7 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 9ebd1dcccac..f99c7ec7e49 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-10d9ad99200a5897417ff5669763ead4e38d87fa
+1dfbe7bc3bf3c455d8fb6c8b5fe6a96c1edf7af9
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 5d3a61a51dc..52ee5587559 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -23,7 +23,7 @@ impl From<AztecMacroError> for MacroError {
     fn from(err: AztecMacroError) -> Self {
         match err {
             AztecMacroError::AztecDepNotFound {} => MacroError {
-                primary_message: "Aztec dependency not found. Please add aztec as a dependency in your Cargo.toml. For more information go to https://docs.aztec.network/developers/debugging/aztecnr-errors#aztec-dependency-not-found-please-add-aztec-as-a-dependency-in-your-nargotoml".to_owned(),
+                primary_message: "Aztec dependency not found. Please add aztec as a dependency in your Nargo.toml. For more information go to https://docs.aztec.network/developers/debugging/aztecnr-errors#aztec-dependency-not-found-please-add-aztec-as-a-dependency-in-your-nargotoml".to_owned(),
                 secondary_message: None,
                 span: None,
             },
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index 86e7277451f..4e36dbd1f22 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -6,11 +6,10 @@ use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
 use crate::cli::fs::inputs::{read_bytecode_from_file, read_inputs_from_file};
-use crate::cli::fs::witness::save_witness_to_dir;
 use crate::errors::CliError;
 use nargo::ops::{execute_program, DefaultForeignCallExecutor};
 
-use super::fs::witness::create_output_witness_string;
+use super::fs::witness::{create_output_witness_string, save_witness_to_dir};
 
 /// Executes a circuit to calculate its return value
 #[derive(Debug, Clone, Args)]
@@ -46,9 +45,9 @@ fn run_command(args: ExecuteCommand) -> Result<String, CliError> {
     )?;
     if args.output_witness.is_some() {
         save_witness_to_dir(
-            &output_witness_string,
-            &args.working_directory,
+            output_witness,
             &args.output_witness.unwrap(),
+            &args.working_directory,
         )?;
     }
     Ok(output_witness_string)
diff --git a/tooling/acvm_cli/src/cli/fs/witness.rs b/tooling/acvm_cli/src/cli/fs/witness.rs
index 2daaa5a3a58..30ef4278f4b 100644
--- a/tooling/acvm_cli/src/cli/fs/witness.rs
+++ b/tooling/acvm_cli/src/cli/fs/witness.rs
@@ -5,24 +5,29 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 
 use crate::errors::{CliError, FilesystemError};
 
-/// Saves the provided output witnesses to a toml file created at the given location
-pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
-    output_witness: &String,
-    witness_dir: P,
-    file_name: &String,
-) -> Result<PathBuf, FilesystemError> {
-    let witness_path = witness_dir.as_ref().join(file_name);
+fn create_named_dir(named_dir: &Path, name: &str) -> PathBuf {
+    std::fs::create_dir_all(named_dir)
+        .unwrap_or_else(|_| panic!("could not create the `{name}` directory"));
+
+    PathBuf::from(named_dir)
+}
 
-    let mut file = File::create(&witness_path)
-        .map_err(|_| FilesystemError::OutputWitnessCreationFailed(file_name.clone()))?;
-    write!(file, "{}", output_witness)
-        .map_err(|_| FilesystemError::OutputWitnessWriteFailed(file_name.clone()))?;
+fn write_to_file(bytes: &[u8], path: &Path) -> String {
+    let display = path.display();
 
-    Ok(witness_path)
+    let mut file = match File::create(path) {
+        Err(why) => panic!("couldn't create {display}: {why}"),
+        Ok(file) => file,
+    };
+
+    match file.write_all(bytes) {
+        Err(why) => panic!("couldn't write to {display}: {why}"),
+        Ok(_) => display.to_string(),
+    }
 }
 
 /// Creates a toml representation of the provided witness map
@@ -34,3 +39,19 @@ pub(crate) fn create_output_witness_string(witnesses: &WitnessMap) -> Result<Str
 
     toml::to_string(&witness_map).map_err(|_| CliError::OutputWitnessSerializationFailed())
 }
+
+pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
+    witnesses: WitnessStack,
+    witness_name: &str,
+    witness_dir: P,
+) -> Result<PathBuf, FilesystemError> {
+    create_named_dir(witness_dir.as_ref(), "witness");
+    let witness_path = witness_dir.as_ref().join(witness_name).with_extension("gz");
+
+    let buf: Vec<u8> = witnesses
+        .try_into()
+        .map_err(|_op| FilesystemError::OutputWitnessCreationFailed(witness_name.to_string()))?;
+    write_to_file(buf.as_slice(), &witness_path);
+
+    Ok(witness_path)
+}
diff --git a/tooling/acvm_cli/src/errors.rs b/tooling/acvm_cli/src/errors.rs
index 923046410ea..8bc79347159 100644
--- a/tooling/acvm_cli/src/errors.rs
+++ b/tooling/acvm_cli/src/errors.rs
@@ -20,9 +20,6 @@ pub(crate) enum FilesystemError {
 
     #[error(" Error: failed to create output witness file {0}.")]
     OutputWitnessCreationFailed(String),
-
-    #[error(" Error: failed to write output witness file {0}.")]
-    OutputWitnessWriteFailed(String),
 }
 
 #[derive(Debug, Error)]
diff --git a/tooling/noirc_abi_wasm/build.sh b/tooling/noirc_abi_wasm/build.sh
index 4486a214c9c..58724dee02c 100755
--- a/tooling/noirc_abi_wasm/build.sh
+++ b/tooling/noirc_abi_wasm/build.sh
@@ -25,7 +25,6 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')
@@ -49,5 +48,5 @@ BROWSER_WASM=${BROWSER_DIR}/${pname}_bg.wasm
 run_or_fail cargo build --lib --release --target $TARGET --package ${pname}
 run_or_fail wasm-bindgen $WASM_BINARY --out-dir $NODE_DIR --typescript --target nodejs
 run_or_fail wasm-bindgen $WASM_BINARY --out-dir $BROWSER_DIR --typescript --target web
-run_or_fail wasm-opt $NODE_WASM -o $NODE_WASM -O
-run_or_fail wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
+run_if_available wasm-opt $NODE_WASM -o $NODE_WASM -O
+run_if_available wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
diff --git a/tooling/noirc_abi_wasm/src/lib.rs b/tooling/noirc_abi_wasm/src/lib.rs
index ce15f6d502e..fad5abaebba 100644
--- a/tooling/noirc_abi_wasm/src/lib.rs
+++ b/tooling/noirc_abi_wasm/src/lib.rs
@@ -5,7 +5,7 @@
 // See Cargo.toml for explanation.
 use getrandom as _;
 
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use iter_extended::try_btree_map;
 use noirc_abi::{
     errors::InputParserError,
@@ -113,3 +113,12 @@ pub fn abi_decode(abi: JsAbi, witness_map: JsWitnessMap) -> Result<JsValue, JsAb
     <wasm_bindgen::JsValue as JsValueSerdeExt>::from_serde(&return_struct)
         .map_err(|err| err.to_string().into())
 }
+
+#[wasm_bindgen(js_name = serializeWitness)]
+pub fn serialise_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsAbiError> {
+    console_error_panic_hook::set_once();
+    let converted_witness: WitnessMap = witness_map.into();
+    let witness_stack: WitnessStack = converted_witness.into();
+    let output = witness_stack.try_into();
+    output.map_err(|_| JsAbiError::new("Failed to convert to Vec<u8>".to_string()))
+}

From 645dba192f16ef34018828186ffb297422a8dc73 Mon Sep 17 00:00:00 2001
From: just-mitch <68168980+just-mitch@users.noreply.github.com>
Date: Mon, 15 Apr 2024 14:27:02 -0400
Subject: [PATCH 183/416] fix: catch panics from EC point creation (e.g. the
 point is at infinity) (#4790)

# Description

## Problem\*

Presently noir programs panic when trying to add points not in the
curve.

For example:
```rust
#[test]
fn test_addition_with_zero() {
    let a = pedersen_commitment([1]);
    let b = pedersen_commitment([0]); // returns the point at infinity
    let result = a + b; // panics

    let expected = pedersen_commitment([1]);
    assert(result == expected);
}
```

## Summary\*

Ideally we would check if one of the operands to the ec addition is the
point at infinity and return the other operand if so. This at least
prevents it from panicking and returns a nicer error.


## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 .gitignore                                    |  1 +
 .../src/fixed_base_scalar_mul.rs              | 46 +++++++++++++++----
 2 files changed, 39 insertions(+), 8 deletions(-)

diff --git a/.gitignore b/.gitignore
index 9a829afab8b..2c877a4d02c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@ examples/**/target/
 examples/9
 node_modules
 pkg/
+.idea
 
 # Yarn
 .pnp.*
diff --git a/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs b/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
index 5e68c7d4030..cd91c290f49 100644
--- a/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
@@ -47,17 +47,29 @@ pub fn fixed_base_scalar_mul(
     }
 }
 
+fn create_point(x: FieldElement, y: FieldElement) -> Result<grumpkin::SWAffine, String> {
+    let point = grumpkin::SWAffine::new_unchecked(x.into_repr(), y.into_repr());
+    if !point.is_on_curve() {
+        return Err(format!("Point ({}, {}) is not on curve", x.to_hex(), y.to_hex()));
+    };
+    if !point.is_in_correct_subgroup_assuming_on_curve() {
+        return Err(format!("Point ({}, {}) is not in correct subgroup", x.to_hex(), y.to_hex()));
+    };
+    Ok(point)
+}
+
 pub fn embedded_curve_add(
     input1_x: FieldElement,
     input1_y: FieldElement,
     input2_x: FieldElement,
     input2_y: FieldElement,
 ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-    let mut point1 = grumpkin::SWAffine::new(input1_x.into_repr(), input1_y.into_repr());
-    let point2 = grumpkin::SWAffine::new(input2_x.into_repr(), input2_y.into_repr());
-    let res = point1 + point2;
-    point1 = res.into();
-    if let Some((res_x, res_y)) = point1.xy() {
+    let point1 = create_point(input1_x, input1_y)
+        .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
+    let point2 = create_point(input2_x, input2_y)
+        .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
+    let res = grumpkin::SWAffine::from(point1 + point2);
+    if let Some((res_x, res_y)) = res.xy() {
         Ok((FieldElement::from_repr(*res_x), FieldElement::from_repr(*res_y)))
     } else {
         Err(BlackBoxResolutionError::Failed(
@@ -72,6 +84,7 @@ mod grumpkin_fixed_base_scalar_mul {
     use ark_ff::BigInteger;
 
     use super::*;
+
     #[test]
     fn smoke_test() -> Result<(), BlackBoxResolutionError> {
         let input = FieldElement::one();
@@ -84,6 +97,7 @@ mod grumpkin_fixed_base_scalar_mul {
         assert_eq!(y, res.1.to_hex());
         Ok(())
     }
+
     #[test]
     fn low_high_smoke_test() -> Result<(), BlackBoxResolutionError> {
         let low = FieldElement::one();
@@ -103,9 +117,9 @@ mod grumpkin_fixed_base_scalar_mul {
         let max_limb = FieldElement::from(u128::MAX);
         let invalid_limb = max_limb + FieldElement::one();
 
-        let expected_error =  Err(BlackBoxResolutionError::Failed(
+        let expected_error = Err(BlackBoxResolutionError::Failed(
             BlackBoxFunc::FixedBaseScalarMul,
-            "Limb 0000000000000000000000000000000100000000000000000000000000000000 is not less than 2^128".into()
+            "Limb 0000000000000000000000000000000100000000000000000000000000000000 is not less than 2^128".into(),
         ));
 
         let res = fixed_base_scalar_mul(&invalid_limb, &FieldElement::zero());
@@ -128,7 +142,23 @@ mod grumpkin_fixed_base_scalar_mul {
             res,
             Err(BlackBoxResolutionError::Failed(
                 BlackBoxFunc::FixedBaseScalarMul,
-                "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47 is not a valid grumpkin scalar".into()
+                "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47 is not a valid grumpkin scalar".into(),
+            ))
+        );
+    }
+
+    #[test]
+    fn rejects_addition_of_points_not_in_curve() {
+        let x = FieldElement::from(1u128);
+        let y = FieldElement::from(2u128);
+
+        let res = embedded_curve_add(x, y, x, y);
+
+        assert_eq!(
+            res,
+            Err(BlackBoxResolutionError::Failed(
+                BlackBoxFunc::EmbeddedCurveAdd,
+                "Point (0000000000000000000000000000000000000000000000000000000000000001, 0000000000000000000000000000000000000000000000000000000000000002) is not on curve".into(),
             ))
         );
     }

From 0adeb08fe54ea98129c637f4ee672e8938a56edf Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 15 Apr 2024 22:33:47 +0100
Subject: [PATCH 184/416] chore: optimize poseidon2 implementation (#4807)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR removes the usage of a `BigUint` from the poseidon2 solver. I've
also wrapped all of the config in a `lazy_static` to avoid having to
re-instantiate it each time.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |    5 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   15 +-
 .../benches/criterion.rs                      |   21 +
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |    5 +-
 .../bn254_blackbox_solver/src/poseidon2.rs    | 1386 ++++++-----------
 5 files changed, 494 insertions(+), 938 deletions(-)
 create mode 100644 acvm-repo/bn254_blackbox_solver/benches/criterion.rs

diff --git a/Cargo.lock b/Cargo.lock
index dec9cf7ad4f..0f2c1894e15 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -615,11 +615,14 @@ dependencies = [
  "ark-ec",
  "ark-ff",
  "cfg-if 1.0.0",
+ "criterion",
  "getrandom 0.2.10",
+ "hex",
  "js-sys",
+ "lazy_static",
  "noir_grumpkin",
  "num-bigint",
- "num-traits",
+ "pprof",
  "thiserror",
  "wasm-bindgen-futures",
  "wasmer",
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 318833180ea..448642e1a9e 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -16,8 +16,9 @@ repository.workspace = true
 acir.workspace = true
 acvm_blackbox_solver.workspace = true
 thiserror.workspace = true
-num-traits.workspace = true
 cfg-if = "1.0.0"
+hex.workspace = true
+lazy_static = "1.4"
 
 # BN254 fixed base scalar multiplication solver
 grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
@@ -38,6 +39,18 @@ js-sys.workspace = true
 getrandom.workspace = true
 wasmer = "4.2.6"
 
+[dev-dependencies]
+criterion = "0.5.0"
+pprof = { version = "0.12", features = [
+    "flamegraph",
+    "frame-pointer",
+    "criterion",
+] }
+
+[[bench]]
+name = "criterion"
+harness = false
+
 [features]
 default = ["bn254"]
 bn254 = ["acir/bn254"]
diff --git a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
new file mode 100644
index 00000000000..eb529ed2c11
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
@@ -0,0 +1,21 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::{hint::black_box, time::Duration};
+
+use acir::FieldElement;
+use bn254_blackbox_solver::poseidon2_permutation;
+
+use pprof::criterion::{Output, PProfProfiler};
+
+fn bench_poseidon2(c: &mut Criterion) {
+    let inputs = [FieldElement::zero(); 4];
+
+    c.bench_function("poseidon2", |b| b.iter(|| poseidon2_permutation(black_box(&inputs), 4)));
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default().sample_size(40).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = bench_poseidon2
+);
+
+criterion_main!(benches);
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 231594170e3..6a16043ae33 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -10,7 +10,7 @@ mod poseidon2;
 mod wasm;
 
 pub use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
-use poseidon2::Poseidon2;
+pub use poseidon2::poseidon2_permutation;
 use wasm::Barretenberg;
 
 use self::wasm::{Pedersen, SchnorrSig};
@@ -112,7 +112,6 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
         inputs: &[FieldElement],
         len: u32,
     ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
-        let poseidon = Poseidon2::new();
-        poseidon.permutation(inputs, len)
+        poseidon2_permutation(inputs, len)
     }
 }
diff --git a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
index e0ed5bcd053..65058e15099 100644
--- a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
@@ -1,9 +1,20 @@
 use acir::FieldElement;
 use acvm_blackbox_solver::BlackBoxResolutionError;
-use num_bigint::BigUint;
-use num_traits::Num;
+use lazy_static::lazy_static;
 
-pub(crate) struct Poseidon2 {
+pub fn poseidon2_permutation(
+    inputs: &[FieldElement],
+    len: u32,
+) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+    let poseidon = Poseidon2::new();
+    poseidon.permutation(inputs, len)
+}
+
+pub(crate) struct Poseidon2<'a> {
+    config: &'a Poseidon2Config,
+}
+
+struct Poseidon2Config {
     t: u32,
     rounds_f: u32,
     rounds_p: u32,
@@ -11,929 +22,415 @@ pub(crate) struct Poseidon2 {
     round_constant: [[FieldElement; 4]; 64],
 }
 
-impl Poseidon2 {
+fn field_from_hex(hex: &str) -> FieldElement {
+    FieldElement::from_be_bytes_reduce(&hex::decode(hex).expect("Should be passed only valid hex"))
+}
+
+lazy_static! {
+    static ref INTERNAL_MATRIX_DIAGONAL: [FieldElement; 4] = [
+        field_from_hex("10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7"),
+        field_from_hex("0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b"),
+        field_from_hex("00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15"),
+        field_from_hex("222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b"),
+    ];
+    static ref ROUND_CONSTANT: [[FieldElement; 4]; 64] = [
+        [
+            field_from_hex("19b849f69450b06848da1d39bd5e4a4302bb86744edc26238b0878e269ed23e5"),
+            field_from_hex("265ddfe127dd51bd7239347b758f0a1320eb2cc7450acc1dad47f80c8dcf34d6"),
+            field_from_hex("199750ec472f1809e0f66a545e1e51624108ac845015c2aa3dfc36bab497d8aa"),
+            field_from_hex("157ff3fe65ac7208110f06a5f74302b14d743ea25067f0ffd032f787c7f1cdf8"),
+        ],
+        [
+            field_from_hex("2e49c43c4569dd9c5fd35ac45fca33f10b15c590692f8beefe18f4896ac94902"),
+            field_from_hex("0e35fb89981890520d4aef2b6d6506c3cb2f0b6973c24fa82731345ffa2d1f1e"),
+            field_from_hex("251ad47cb15c4f1105f109ae5e944f1ba9d9e7806d667ffec6fe723002e0b996"),
+            field_from_hex("13da07dc64d428369873e97160234641f8beb56fdd05e5f3563fa39d9c22df4e"),
+        ],
+        [
+            field_from_hex("0c009b84e650e6d23dc00c7dccef7483a553939689d350cd46e7b89055fd4738"),
+            field_from_hex("011f16b1c63a854f01992e3956f42d8b04eb650c6d535eb0203dec74befdca06"),
+            field_from_hex("0ed69e5e383a688f209d9a561daa79612f3f78d0467ad45485df07093f367549"),
+            field_from_hex("04dba94a7b0ce9e221acad41472b6bbe3aec507f5eb3d33f463672264c9f789b"),
+        ],
+        [
+            field_from_hex("0a3f2637d840f3a16eb094271c9d237b6036757d4bb50bf7ce732ff1d4fa28e8"),
+            field_from_hex("259a666f129eea198f8a1c502fdb38fa39b1f075569564b6e54a485d1182323f"),
+            field_from_hex("28bf7459c9b2f4c6d8e7d06a4ee3a47f7745d4271038e5157a32fdf7ede0d6a1"),
+            field_from_hex("0a1ca941f057037526ea200f489be8d4c37c85bbcce6a2aeec91bd6941432447"),
+        ],
+        [
+            field_from_hex("0c6f8f958be0e93053d7fd4fc54512855535ed1539f051dcb43a26fd926361cf"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("123106a93cd17578d426e8128ac9d90aa9e8a00708e296e084dd57e69caaf811"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("26e1ba52ad9285d97dd3ab52f8e840085e8fa83ff1e8f1877b074867cd2dee75"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1cb55cad7bd133de18a64c5c47b9c97cbe4d8b7bf9e095864471537e6a4ae2c5"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1dcd73e46acd8f8e0e2c7ce04bde7f6d2a53043d5060a41c7143f08e6e9055d0"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("011003e32f6d9c66f5852f05474a4def0cda294a0eb4e9b9b12b9bb4512e5574"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2b1e809ac1d10ab29ad5f20d03a57dfebadfe5903f58bafed7c508dd2287ae8c"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2539de1785b735999fb4dac35ee17ed0ef995d05ab2fc5faeaa69ae87bcec0a5"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0c246c5a2ef8ee0126497f222b3e0a0ef4e1c3d41c86d46e43982cb11d77951d"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("192089c4974f68e95408148f7c0632edbb09e6a6ad1a1c2f3f0305f5d03b527b"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1eae0ad8ab68b2f06a0ee36eeb0d0c058529097d91096b756d8fdc2fb5a60d85"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("179190e5d0e22179e46f8282872abc88db6e2fdc0dee99e69768bd98c5d06bfb"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("29bb9e2c9076732576e9a81c7ac4b83214528f7db00f31bf6cafe794a9b3cd1c"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("225d394e42207599403efd0c2464a90d52652645882aac35b10e590e6e691e08"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("064760623c25c8cf753d238055b444532be13557451c087de09efd454b23fd59"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("10ba3a0e01df92e87f301c4b716d8a394d67f4bf42a75c10922910a78f6b5b87"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0e070bf53f8451b24f9c6e96b0c2a801cb511bc0c242eb9d361b77693f21471c"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1b94cd61b051b04dd39755ff93821a73ccd6cb11d2491d8aa7f921014de252fb"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1d7cb39bafb8c744e148787a2e70230f9d4e917d5713bb050487b5aa7d74070b"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2ec93189bd1ab4f69117d0fe980c80ff8785c2961829f701bb74ac1f303b17db"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2db366bfdd36d277a692bb825b86275beac404a19ae07a9082ea46bd83517926"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("062100eb485db06269655cf186a68532985275428450359adc99cec6960711b8"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0761d33c66614aaa570e7f1e8244ca1120243f92fa59e4f900c567bf41f5a59b"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("20fc411a114d13992c2705aa034e3f315d78608a0f7de4ccf7a72e494855ad0d"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("25b5c004a4bdfcb5add9ec4e9ab219ba102c67e8b3effb5fc3a30f317250bc5a"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("23b1822d278ed632a494e58f6df6f5ed038b186d8474155ad87e7dff62b37f4b"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("22734b4c5c3f9493606c4ba9012499bf0f14d13bfcfcccaa16102a29cc2f69e0"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("26c0c8fe09eb30b7e27a74dc33492347e5bdff409aa3610254413d3fad795ce5"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("070dd0ccb6bd7bbae88eac03fa1fbb26196be3083a809829bbd626df348ccad9"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("12b6595bdb329b6fb043ba78bb28c3bec2c0a6de46d8c5ad6067c4ebfd4250da"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("248d97d7f76283d63bec30e7a5876c11c06fca9b275c671c5e33d95bb7e8d729"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1a306d439d463b0816fc6fd64cc939318b45eb759ddde4aa106d15d9bd9baaaa"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("28a8f8372e3c38daced7c00421cb4621f4f1b54ddc27821b0d62d3d6ec7c56cf"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0094975717f9a8a8bb35152f24d43294071ce320c829f388bc852183e1e2ce7e"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("04d5ee4c3aa78f7d80fde60d716480d3593f74d4f653ae83f4103246db2e8d65"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2a6cf5e9aa03d4336349ad6fb8ed2269c7bef54b8822cc76d08495c12efde187"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2304d31eaab960ba9274da43e19ddeb7f792180808fd6e43baae48d7efcba3f3"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("03fd9ac865a4b2a6d5e7009785817249bff08a7e0726fcb4e1c11d39d199f0b0"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("00b7258ded52bbda2248404d55ee5044798afc3a209193073f7954d4d63b0b64"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("159f81ada0771799ec38fca2d4bf65ebb13d3a74f3298db36272c5ca65e92d9a"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1ef90e67437fbc8550237a75bc28e3bb9000130ea25f0c5471e144cf4264431f"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1e65f838515e5ff0196b49aa41a2d2568df739bc176b08ec95a79ed82932e30d"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2b1b045def3a166cec6ce768d079ba74b18c844e570e1f826575c1068c94c33f"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0832e5753ceb0ff6402543b1109229c165dc2d73bef715e3f1c6e07c168bb173"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("02f614e9cedfb3dc6b762ae0a37d41bab1b841c2e8b6451bc5a8e3c390b6ad16"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0e2427d38bd46a60dd640b8e362cad967370ebb777bedff40f6a0be27e7ed705"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0493630b7c670b6deb7c84d414e7ce79049f0ec098c3c7c50768bbe29214a53a"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("22ead100e8e482674decdab17066c5a26bb1515355d5461a3dc06cc85327cea9"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("25b3e56e655b42cdaae2626ed2554d48583f1ae35626d04de5084e0b6d2a6f16"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1e32752ada8836ef5837a6cde8ff13dbb599c336349e4c584b4fdc0a0cf6f9d0"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2fa2a871c15a387cc50f68f6f3c3455b23c00995f05078f672a9864074d412e5"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("2f569b8a9a4424c9278e1db7311e889f54ccbf10661bab7fcd18e7c7a7d83505"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("044cb455110a8fdd531ade530234c518a7df93f7332ffd2144165374b246b43d"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("227808de93906d5d420246157f2e42b191fe8c90adfe118178ddc723a5319025"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("02fcca2934e046bc623adead873579865d03781ae090ad4a8579d2e7a6800355"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("0ef915f0ac120b876abccceb344a1d36bad3f3c5ab91a8ddcbec2e060d8befac"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+            field_from_hex("0000000000000000000000000000000000000000000000000000000000000000"),
+        ],
+        [
+            field_from_hex("1797130f4b7a3e1777eb757bc6f287f6ab0fb85f6be63b09f3b16ef2b1405d38"),
+            field_from_hex("0a76225dc04170ae3306c85abab59e608c7f497c20156d4d36c668555decc6e5"),
+            field_from_hex("1fffb9ec1992d66ba1e77a7b93209af6f8fa76d48acb664796174b5326a31a5c"),
+            field_from_hex("25721c4fc15a3f2853b57c338fa538d85f8fbba6c6b9c6090611889b797b9c5f"),
+        ],
+        [
+            field_from_hex("0c817fd42d5f7a41215e3d07ba197216adb4c3790705da95eb63b982bfcaf75a"),
+            field_from_hex("13abe3f5239915d39f7e13c2c24970b6df8cf86ce00a22002bc15866e52b5a96"),
+            field_from_hex("2106feea546224ea12ef7f39987a46c85c1bc3dc29bdbd7a92cd60acb4d391ce"),
+            field_from_hex("21ca859468a746b6aaa79474a37dab49f1ca5a28c748bc7157e1b3345bb0f959"),
+        ],
+        [
+            field_from_hex("05ccd6255c1e6f0c5cf1f0df934194c62911d14d0321662a8f1a48999e34185b"),
+            field_from_hex("0f0e34a64b70a626e464d846674c4c8816c4fb267fe44fe6ea28678cb09490a4"),
+            field_from_hex("0558531a4e25470c6157794ca36d0e9647dbfcfe350d64838f5b1a8a2de0d4bf"),
+            field_from_hex("09d3dca9173ed2faceea125157683d18924cadad3f655a60b72f5864961f1455"),
+        ],
+        [
+            field_from_hex("0328cbd54e8c0913493f866ed03d218bf23f92d68aaec48617d4c722e5bd4335"),
+            field_from_hex("2bf07216e2aff0a223a487b1a7094e07e79e7bcc9798c648ee3347dd5329d34b"),
+            field_from_hex("1daf345a58006b736499c583cb76c316d6f78ed6a6dffc82111e11a63fe412df"),
+            field_from_hex("176563472456aaa746b694c60e1823611ef39039b2edc7ff391e6f2293d2c404"),
+        ],
+    ];
+    static ref POSEIDON2_CONFIG: Poseidon2Config = Poseidon2Config {
+        t: 4,
+        rounds_f: 8,
+        rounds_p: 56,
+        internal_matrix_diagonal: *INTERNAL_MATRIX_DIAGONAL,
+        round_constant: *ROUND_CONSTANT,
+    };
+}
+
+impl<'a> Poseidon2<'a> {
     pub(crate) fn new() -> Self {
-        Poseidon2 {
-            t: 4,
-            rounds_f: 8,
-            rounds_p: 56,
-            internal_matrix_diagonal: [
-                Poseidon2::field_from_hex(
-                    "0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7",
-                ),
-                Poseidon2::field_from_hex(
-                    "0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b",
-                ),
-                Poseidon2::field_from_hex(
-                    "0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15",
-                ),
-                Poseidon2::field_from_hex(
-                    "0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b",
-                ),
-            ],
-            round_constant: [
-                [
-                    Poseidon2::field_from_hex(
-                        "0x19b849f69450b06848da1d39bd5e4a4302bb86744edc26238b0878e269ed23e5",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x265ddfe127dd51bd7239347b758f0a1320eb2cc7450acc1dad47f80c8dcf34d6",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x199750ec472f1809e0f66a545e1e51624108ac845015c2aa3dfc36bab497d8aa",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x157ff3fe65ac7208110f06a5f74302b14d743ea25067f0ffd032f787c7f1cdf8",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2e49c43c4569dd9c5fd35ac45fca33f10b15c590692f8beefe18f4896ac94902",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0e35fb89981890520d4aef2b6d6506c3cb2f0b6973c24fa82731345ffa2d1f1e",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x251ad47cb15c4f1105f109ae5e944f1ba9d9e7806d667ffec6fe723002e0b996",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x13da07dc64d428369873e97160234641f8beb56fdd05e5f3563fa39d9c22df4e",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0c009b84e650e6d23dc00c7dccef7483a553939689d350cd46e7b89055fd4738",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x011f16b1c63a854f01992e3956f42d8b04eb650c6d535eb0203dec74befdca06",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0ed69e5e383a688f209d9a561daa79612f3f78d0467ad45485df07093f367549",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x04dba94a7b0ce9e221acad41472b6bbe3aec507f5eb3d33f463672264c9f789b",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0a3f2637d840f3a16eb094271c9d237b6036757d4bb50bf7ce732ff1d4fa28e8",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x259a666f129eea198f8a1c502fdb38fa39b1f075569564b6e54a485d1182323f",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x28bf7459c9b2f4c6d8e7d06a4ee3a47f7745d4271038e5157a32fdf7ede0d6a1",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0a1ca941f057037526ea200f489be8d4c37c85bbcce6a2aeec91bd6941432447",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0c6f8f958be0e93053d7fd4fc54512855535ed1539f051dcb43a26fd926361cf",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x123106a93cd17578d426e8128ac9d90aa9e8a00708e296e084dd57e69caaf811",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x26e1ba52ad9285d97dd3ab52f8e840085e8fa83ff1e8f1877b074867cd2dee75",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1cb55cad7bd133de18a64c5c47b9c97cbe4d8b7bf9e095864471537e6a4ae2c5",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1dcd73e46acd8f8e0e2c7ce04bde7f6d2a53043d5060a41c7143f08e6e9055d0",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x011003e32f6d9c66f5852f05474a4def0cda294a0eb4e9b9b12b9bb4512e5574",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2b1e809ac1d10ab29ad5f20d03a57dfebadfe5903f58bafed7c508dd2287ae8c",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2539de1785b735999fb4dac35ee17ed0ef995d05ab2fc5faeaa69ae87bcec0a5",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0c246c5a2ef8ee0126497f222b3e0a0ef4e1c3d41c86d46e43982cb11d77951d",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x192089c4974f68e95408148f7c0632edbb09e6a6ad1a1c2f3f0305f5d03b527b",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1eae0ad8ab68b2f06a0ee36eeb0d0c058529097d91096b756d8fdc2fb5a60d85",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x179190e5d0e22179e46f8282872abc88db6e2fdc0dee99e69768bd98c5d06bfb",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x29bb9e2c9076732576e9a81c7ac4b83214528f7db00f31bf6cafe794a9b3cd1c",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x225d394e42207599403efd0c2464a90d52652645882aac35b10e590e6e691e08",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x064760623c25c8cf753d238055b444532be13557451c087de09efd454b23fd59",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x10ba3a0e01df92e87f301c4b716d8a394d67f4bf42a75c10922910a78f6b5b87",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0e070bf53f8451b24f9c6e96b0c2a801cb511bc0c242eb9d361b77693f21471c",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1b94cd61b051b04dd39755ff93821a73ccd6cb11d2491d8aa7f921014de252fb",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1d7cb39bafb8c744e148787a2e70230f9d4e917d5713bb050487b5aa7d74070b",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2ec93189bd1ab4f69117d0fe980c80ff8785c2961829f701bb74ac1f303b17db",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2db366bfdd36d277a692bb825b86275beac404a19ae07a9082ea46bd83517926",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x062100eb485db06269655cf186a68532985275428450359adc99cec6960711b8",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0761d33c66614aaa570e7f1e8244ca1120243f92fa59e4f900c567bf41f5a59b",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x20fc411a114d13992c2705aa034e3f315d78608a0f7de4ccf7a72e494855ad0d",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x25b5c004a4bdfcb5add9ec4e9ab219ba102c67e8b3effb5fc3a30f317250bc5a",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x23b1822d278ed632a494e58f6df6f5ed038b186d8474155ad87e7dff62b37f4b",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x22734b4c5c3f9493606c4ba9012499bf0f14d13bfcfcccaa16102a29cc2f69e0",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x26c0c8fe09eb30b7e27a74dc33492347e5bdff409aa3610254413d3fad795ce5",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x070dd0ccb6bd7bbae88eac03fa1fbb26196be3083a809829bbd626df348ccad9",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x12b6595bdb329b6fb043ba78bb28c3bec2c0a6de46d8c5ad6067c4ebfd4250da",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x248d97d7f76283d63bec30e7a5876c11c06fca9b275c671c5e33d95bb7e8d729",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1a306d439d463b0816fc6fd64cc939318b45eb759ddde4aa106d15d9bd9baaaa",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x28a8f8372e3c38daced7c00421cb4621f4f1b54ddc27821b0d62d3d6ec7c56cf",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0094975717f9a8a8bb35152f24d43294071ce320c829f388bc852183e1e2ce7e",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x04d5ee4c3aa78f7d80fde60d716480d3593f74d4f653ae83f4103246db2e8d65",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2a6cf5e9aa03d4336349ad6fb8ed2269c7bef54b8822cc76d08495c12efde187",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2304d31eaab960ba9274da43e19ddeb7f792180808fd6e43baae48d7efcba3f3",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x03fd9ac865a4b2a6d5e7009785817249bff08a7e0726fcb4e1c11d39d199f0b0",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x00b7258ded52bbda2248404d55ee5044798afc3a209193073f7954d4d63b0b64",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x159f81ada0771799ec38fca2d4bf65ebb13d3a74f3298db36272c5ca65e92d9a",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1ef90e67437fbc8550237a75bc28e3bb9000130ea25f0c5471e144cf4264431f",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1e65f838515e5ff0196b49aa41a2d2568df739bc176b08ec95a79ed82932e30d",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2b1b045def3a166cec6ce768d079ba74b18c844e570e1f826575c1068c94c33f",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0832e5753ceb0ff6402543b1109229c165dc2d73bef715e3f1c6e07c168bb173",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x02f614e9cedfb3dc6b762ae0a37d41bab1b841c2e8b6451bc5a8e3c390b6ad16",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0e2427d38bd46a60dd640b8e362cad967370ebb777bedff40f6a0be27e7ed705",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0493630b7c670b6deb7c84d414e7ce79049f0ec098c3c7c50768bbe29214a53a",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x22ead100e8e482674decdab17066c5a26bb1515355d5461a3dc06cc85327cea9",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x25b3e56e655b42cdaae2626ed2554d48583f1ae35626d04de5084e0b6d2a6f16",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1e32752ada8836ef5837a6cde8ff13dbb599c336349e4c584b4fdc0a0cf6f9d0",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2fa2a871c15a387cc50f68f6f3c3455b23c00995f05078f672a9864074d412e5",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x2f569b8a9a4424c9278e1db7311e889f54ccbf10661bab7fcd18e7c7a7d83505",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x044cb455110a8fdd531ade530234c518a7df93f7332ffd2144165374b246b43d",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x227808de93906d5d420246157f2e42b191fe8c90adfe118178ddc723a5319025",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x02fcca2934e046bc623adead873579865d03781ae090ad4a8579d2e7a6800355",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0ef915f0ac120b876abccceb344a1d36bad3f3c5ab91a8ddcbec2e060d8befac",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0000000000000000000000000000000000000000000000000000000000000000",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x1797130f4b7a3e1777eb757bc6f287f6ab0fb85f6be63b09f3b16ef2b1405d38",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0a76225dc04170ae3306c85abab59e608c7f497c20156d4d36c668555decc6e5",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x1fffb9ec1992d66ba1e77a7b93209af6f8fa76d48acb664796174b5326a31a5c",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x25721c4fc15a3f2853b57c338fa538d85f8fbba6c6b9c6090611889b797b9c5f",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0c817fd42d5f7a41215e3d07ba197216adb4c3790705da95eb63b982bfcaf75a",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x13abe3f5239915d39f7e13c2c24970b6df8cf86ce00a22002bc15866e52b5a96",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x2106feea546224ea12ef7f39987a46c85c1bc3dc29bdbd7a92cd60acb4d391ce",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x21ca859468a746b6aaa79474a37dab49f1ca5a28c748bc7157e1b3345bb0f959",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x05ccd6255c1e6f0c5cf1f0df934194c62911d14d0321662a8f1a48999e34185b",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0f0e34a64b70a626e464d846674c4c8816c4fb267fe44fe6ea28678cb09490a4",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x0558531a4e25470c6157794ca36d0e9647dbfcfe350d64838f5b1a8a2de0d4bf",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x09d3dca9173ed2faceea125157683d18924cadad3f655a60b72f5864961f1455",
-                    ),
-                ],
-                [
-                    Poseidon2::field_from_hex(
-                        "0x0328cbd54e8c0913493f866ed03d218bf23f92d68aaec48617d4c722e5bd4335",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x2bf07216e2aff0a223a487b1a7094e07e79e7bcc9798c648ee3347dd5329d34b",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x1daf345a58006b736499c583cb76c316d6f78ed6a6dffc82111e11a63fe412df",
-                    ),
-                    Poseidon2::field_from_hex(
-                        "0x176563472456aaa746b694c60e1823611ef39039b2edc7ff391e6f2293d2c404",
-                    ),
-                ],
-            ],
-        }
-    }
-    fn field_from_hex(hex: &str) -> FieldElement {
-        let bigint = BigUint::from_str_radix(hex.strip_prefix("0x").unwrap(), 16).unwrap();
-        FieldElement::from_be_bytes_reduce(&bigint.to_bytes_be())
+        Poseidon2 { config: &POSEIDON2_CONFIG }
     }
 
     fn single_box(x: FieldElement) -> FieldElement {
@@ -948,7 +445,9 @@ impl Poseidon2 {
     }
 
     fn add_round_constants(&self, state: &mut [FieldElement], round: usize) {
-        for (state_element, constant_element) in state.iter_mut().zip(self.round_constant[round]) {
+        for (state_element, constant_element) in
+            state.iter_mut().zip(self.config.round_constant[round])
+        {
             *state_element += constant_element;
         }
     }
@@ -982,7 +481,7 @@ impl Poseidon2 {
             sum += *i;
         }
         for (index, i) in input.iter_mut().enumerate() {
-            *i = *i * self.internal_matrix_diagonal[index];
+            *i = *i * self.config.internal_matrix_diagonal[index];
             *i += sum;
         }
     }
@@ -1002,10 +501,10 @@ impl Poseidon2 {
                 ),
             ));
         }
-        if len != self.t {
+        if len != self.config.t {
             return Err(BlackBoxResolutionError::Failed(
                 acir::BlackBoxFunc::Poseidon2Permutation,
-                format!("Expected {} values but encountered {}", self.t, len),
+                format!("Expected {} values but encountered {}", self.config.t, len),
             ));
         }
         // Read witness assignments
@@ -1017,22 +516,22 @@ impl Poseidon2 {
         Self::matrix_multiplication_4x4(&mut state);
 
         // First set of external rounds
-        let rf_first = self.rounds_f / 2;
+        let rf_first = self.config.rounds_f / 2;
         for r in 0..rf_first {
             self.add_round_constants(&mut state, r as usize);
             Self::s_box(&mut state);
             Self::matrix_multiplication_4x4(&mut state);
         }
         // Internal rounds
-        let p_end = rf_first + self.rounds_p;
+        let p_end = rf_first + self.config.rounds_p;
         for r in rf_first..p_end {
-            state[0] += self.round_constant[r as usize][0];
+            state[0] += self.config.round_constant[r as usize][0];
             state[0] = Self::single_box(state[0]);
             self.internal_m_multiplication(&mut state);
         }
 
         // Remaining external rounds
-        let num_rounds = self.rounds_f + self.rounds_p;
+        let num_rounds = self.config.rounds_f + self.config.rounds_p;
         for i in p_end..num_rounds {
             self.add_round_constants(&mut state, i as usize);
             Self::s_box(&mut state);
@@ -1041,3 +540,24 @@ impl Poseidon2 {
         Ok(state.into())
     }
 }
+
+#[cfg(test)]
+mod test {
+    use acir::FieldElement;
+
+    use super::{field_from_hex, poseidon2_permutation};
+
+    #[test]
+    fn smoke_test() {
+        let inputs = [FieldElement::zero(); 4];
+        let result = poseidon2_permutation(&inputs, 4).expect("should successfully permute");
+
+        let expected_result = [
+            field_from_hex("18DFB8DC9B82229CFF974EFEFC8DF78B1CE96D9D844236B496785C698BC6732E"),
+            field_from_hex("095C230D1D37A246E8D2D5A63B165FE0FADE040D442F61E25F0590E5FB76F839"),
+            field_from_hex("0BB9545846E1AFA4FA3C97414A60A20FC4949F537A68CCECA34C5CE71E28AA59"),
+            field_from_hex("18A4F34C9C6F99335FF7638B82AEED9018026618358873C982BBDDE265B2ED6D"),
+        ];
+        assert_eq!(result, expected_result);
+    }
+}

From 1fa510ad3b8a27aa56ab1312140900d5a0772be8 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 16 Apr 2024 13:37:11 +0100
Subject: [PATCH 185/416] chore: run clippy (#4810)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I'm fixing some clippy warnings which are popping up in my IDE.

This PR also runs the nightly version of clippy and fixes some of the
issues where appropriate.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/parser/mod.rs    | 13 +++++++------
 compiler/noirc_frontend/src/parser/parser.rs |  8 ++++----
 tooling/noirc_abi/src/input_parser/mod.rs    |  2 +-
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_frontend/src/parser/mod.rs b/compiler/noirc_frontend/src/parser/mod.rs
index ea96dee8a47..80c5f47f07b 100644
--- a/compiler/noirc_frontend/src/parser/mod.rs
+++ b/compiler/noirc_frontend/src/parser/mod.rs
@@ -97,14 +97,14 @@ where
 /// Sequence the two parsers.
 /// Fails if the first parser fails, otherwise forces
 /// the second parser to succeed while logging any errors.
-fn then_commit<'a, P1, P2, T1, T2: 'a>(
+fn then_commit<'a, P1, P2, T1, T2>(
     first_parser: P1,
     second_parser: P2,
 ) -> impl NoirParser<(T1, T2)> + 'a
 where
     P1: NoirParser<T1> + 'a,
     P2: NoirParser<T2> + 'a,
-    T2: Clone + Recoverable,
+    T2: Clone + Recoverable + 'a,
 {
     let second_parser = skip_then_retry_until(second_parser)
         .map_with_span(|option, span| option.unwrap_or_else(|| Recoverable::error(span)));
@@ -112,14 +112,15 @@ where
     first_parser.then(second_parser)
 }
 
-fn then_commit_ignore<'a, P1, P2, T1: 'a, T2: 'a>(
+fn then_commit_ignore<'a, P1, P2, T1, T2>(
     first_parser: P1,
     second_parser: P2,
 ) -> impl NoirParser<T1> + 'a
 where
     P1: NoirParser<T1> + 'a,
     P2: NoirParser<T2> + 'a,
-    T2: Clone,
+    T1: 'a,
+    T2: Clone + 'a,
 {
     let second_parser = skip_then_retry_until(second_parser);
     first_parser.then_ignore(second_parser)
@@ -140,10 +141,10 @@ where
     first_parser.ignore_then(second_parser)
 }
 
-fn skip_then_retry_until<'a, P, T: 'a>(parser: P) -> impl NoirParser<Option<T>> + 'a
+fn skip_then_retry_until<'a, P, T>(parser: P) -> impl NoirParser<Option<T>> + 'a
 where
     P: NoirParser<T> + 'a,
-    T: Clone,
+    T: Clone + 'a,
 {
     let terminators = [
         Token::EOF,
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 1bedf904da2..5706c3ef12f 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1587,7 +1587,7 @@ mod test {
 
     #[test]
     fn parse_use() {
-        let mut valid_use_statements = vec![
+        let valid_use_statements = [
             "use std::hash",
             "use std",
             "use foo::bar as hello",
@@ -1600,7 +1600,7 @@ mod test {
             "use dep::{std::println, bar::baz}",
         ];
 
-        let mut invalid_use_statements = vec![
+        let invalid_use_statements = [
             "use std as ;",
             "use foobar as as;",
             "use hello:: as foo;",
@@ -1610,9 +1610,9 @@ mod test {
         ];
 
         let use_statements = valid_use_statements
-            .iter_mut()
+            .into_iter()
             .map(|valid_str| (valid_str, true))
-            .chain(invalid_use_statements.iter_mut().map(|invalid_str| (invalid_str, false)));
+            .chain(invalid_use_statements.into_iter().map(|invalid_str| (invalid_str, false)));
 
         for (use_statement_str, expect_valid) in use_statements {
             let mut use_statement_str = use_statement_str.to_string();
diff --git a/tooling/noirc_abi/src/input_parser/mod.rs b/tooling/noirc_abi/src/input_parser/mod.rs
index 024cb06007e..4cf66820b8d 100644
--- a/tooling/noirc_abi/src/input_parser/mod.rs
+++ b/tooling/noirc_abi/src/input_parser/mod.rs
@@ -139,7 +139,7 @@ impl InputValue {
                 if map.len() > fields.len() {
                     let expected_fields: HashSet<String> =
                         fields.iter().map(|(field, _)| field.to_string()).collect();
-                    let extra_field = map.keys().cloned().find(|key| !expected_fields.contains(key)).expect("`map` is larger than the expected type's `fields` so it must contain an unexpected field");
+                    let extra_field = map.keys().find(|&key| !expected_fields.contains(key)).cloned().expect("`map` is larger than the expected type's `fields` so it must contain an unexpected field");
                     return Err(InputTypecheckingError::UnexpectedField {
                         path,
                         typ: abi_param.clone(),

From 46870bd09c00277817cbb0e8a6fabc80fea8d43a Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 16 Apr 2024 19:22:44 +0100
Subject: [PATCH 186/416] chore(ci): fix alerts on msrv issues (#4816)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We weren't checking out the repo and had the wrong filename so the
github action couldn't open an issue properly when the CI started
failing.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/test-rust-workspace-msrv.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index 0b2855fa834..49550ba71de 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -112,6 +112,9 @@ jobs:
           # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
           FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
     
+      - name: Checkout
+        uses: actions/checkout@v4
+
       # Raise an issue if the tests failed
       - name: Alert on failed publish
         uses: JasonEtco/create-an-issue@v2
@@ -122,4 +125,4 @@ jobs:
           WORKFLOW_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         with:
           update_existing: true
-          filename: .github/JS_PUBLISH_FAILED.md
\ No newline at end of file
+          filename: .github/ACVM_NOT_PUBLISHABLE.md

From 053d5e8879865c25ac2bfcfd206a6b729d328b9c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 16 Apr 2024 19:29:05 +0100
Subject: [PATCH 187/416] chore: fix alerts on rust msrv (#4817)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This workflow was failing due to the checkout step being skipped.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/test-rust-workspace-msrv.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index 49550ba71de..cdd7a064a8d 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -113,6 +113,7 @@ jobs:
           FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
     
       - name: Checkout
+        if: ${{ failure() }}
         uses: actions/checkout@v4
 
       # Raise an issue if the tests failed

From d817d819038923c3118d2101957d071c2cf16728 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 17 Apr 2024 11:38:14 +0100
Subject: [PATCH 188/416] chore: delete unnecessary Prover.toml file (#4829)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This file is unused.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 test_programs/execution_success/workspace/Prover.toml | 2 --
 1 file changed, 2 deletions(-)
 delete mode 100644 test_programs/execution_success/workspace/Prover.toml

diff --git a/test_programs/execution_success/workspace/Prover.toml b/test_programs/execution_success/workspace/Prover.toml
deleted file mode 100644
index a0397e89477..00000000000
--- a/test_programs/execution_success/workspace/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "1"
-y = "0"

From 23e1f3b78a4895a8b9c742fa7eaecd7b4b3f3abc Mon Sep 17 00:00:00 2001
From: SihanoukSolver29 <150921296+SihanoukSolver29@users.noreply.github.com>
Date: Wed, 17 Apr 2024 11:48:07 +0100
Subject: [PATCH 189/416] chore(docs): fix wrong Nargo.toml workspace examples
 (#4822)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves #4805

## Summary\*

This PR fixes the issue found by @iAmMichaelConnor in #4805, where the
example Nargo.toml content for [workspace] has
 members with wrong paths.

Since the structure has Nargo.toml inside the `crates` folder, then
`members` should direct to folders inside `crates`.
``` file structure
├── crates
│   ├── a
│   │   ├── Nargo.toml
│   │   └── src
│   │       └── main.nr
│   └── b
│       ├── Nargo.toml
│       └── src
│           └── main.nr
├── Nargo.toml
└── Prover.toml
```

## Additional Context

All nargo versions I've tested with, from v0.19.0 to v0.27.0, return
`Cannot read file /home/sihanouk/crates/crates/a/Nargo.toml - does it
exist?` without the fix.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 24 ++++++++++---------
 .../modules_packages_crates/workspaces.md     | 24 ++++++++++---------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 .../modules_packages_crates/workspaces.md     | 22 +++++++++--------
 13 files changed, 158 insertions(+), 132 deletions(-)

diff --git a/docs/docs/noir/modules_packages_crates/workspaces.md b/docs/docs/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/docs/noir/modules_packages_crates/workspaces.md
+++ b/docs/docs/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/workspaces.md
index d9ac92667c9..8168793fc80 100644
--- a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/workspaces.md
@@ -10,16 +10,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/workspaces.md
index d9ac92667c9..8168793fc80 100644
--- a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/workspaces.md
@@ -10,16 +10,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/workspaces.md
index d9ac92667c9..8168793fc80 100644
--- a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/workspaces.md
@@ -10,16 +10,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/workspaces.md
index d9ac92667c9..8168793fc80 100644
--- a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/workspaces.md
@@ -10,16 +10,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/workspaces.md
index a979ef9f0a5..8168793fc80 100644
--- a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/workspaces.md
@@ -10,16 +10,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
@@ -36,4 +38,4 @@ default-member = "crates/a"
 
 Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
-Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
\ No newline at end of file
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/workspaces.md
index a979ef9f0a5..8168793fc80 100644
--- a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/workspaces.md
@@ -10,16 +10,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
@@ -36,4 +38,4 @@ default-member = "crates/a"
 
 Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
-Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
\ No newline at end of file
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md
index 67a1dafa372..513497f12bf 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/workspaces.md
@@ -11,16 +11,18 @@ For a project with the following structure:
 
 ```tree
 ├── crates
-│   ├── a
-│   │   ├── Nargo.toml
-│   │   └── src
-│   │       └── main.nr
-│   └── b
-│       ├── Nargo.toml
-│       └── src
-│           └── main.nr
-├── Nargo.toml
-└── Prover.toml
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
 ```
 
 You can define a workspace in Nargo.toml like so:

From e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 17 Apr 2024 14:45:49 +0200
Subject: [PATCH 190/416] fix: issue 4682 and add solver for unconstrained
 bigintegers (#4729)

# Description

## Problem\*

Managing bigintegers as ID makes it difficult to handle them in
conditionals and also when passing them around unconstrained functions.
As a matter of fact these two use cases do not work, the first one being
documented in issue #4682, while the second one was never implemented.

## Summary\*

In order to solve this two issues, I modified the bigint representation
so that it stores its byte array instead of an id, allowing it to work
directly with conditional and unconstrained functions.


## Additional Context

For simplicity, I also made the byte arrays of hardcoded length 32.
Since the moduli we support are of this length and since custom
bigintegers will be implemented differently, I do not expect this length
to change.
The barrentenberg interface has not changed and we still use id for it.
The Id is constructed when required by doing a call to from_bytes.

## Documentation\*
The traits have not changed, I have simply added a from_byte_32 method
which takes a 32-bytes array as input.

Check one:
- [] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 Cargo.lock                                    |   1 +
 acvm-repo/acvm/src/pwg/blackbox/bigint.rs     |  74 +-----
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |   4 +-
 acvm-repo/acvm/src/pwg/mod.rs                 |   6 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   1 +
 acvm-repo/blackbox_solver/src/bigint.rs       |  99 ++++++++
 acvm-repo/blackbox_solver/src/lib.rs          |   2 +
 acvm-repo/brillig_vm/src/black_box.rs         |  64 ++++-
 acvm-repo/brillig_vm/src/lib.rs               |  12 +-
 .../brillig/brillig_gen/brillig_black_box.rs  | 105 ++++++--
 .../noirc_evaluator/src/brillig/brillig_ir.rs |   8 +
 .../src/brillig/brillig_ir/entry_point.rs     |   1 +
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |   3 +-
 docs/docs/noir/standard_library/bigint.md     |   3 +
 noir_stdlib/src/bigint.nr                     | 225 +++++++++++++-----
 .../execution_success/bigint/src/main.nr      |  34 +++
 16 files changed, 484 insertions(+), 158 deletions(-)
 create mode 100644 acvm-repo/blackbox_solver/src/bigint.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0f2c1894e15..754a1c3d1fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -60,6 +60,7 @@ dependencies = [
  "blake3",
  "k256",
  "keccak",
+ "num-bigint",
  "p256",
  "sha2",
  "sha3",
diff --git a/acvm-repo/acvm/src/pwg/blackbox/bigint.rs b/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
index a47afa5049a..3c05fb2761d 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
@@ -1,53 +1,23 @@
-use std::collections::HashMap;
-
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
     BlackBoxFunc, FieldElement,
 };
 
-use num_bigint::BigUint;
+use acvm_blackbox_solver::BigIntSolver;
 
 use crate::pwg::OpcodeResolutionError;
 
-/// Resolve BigInt opcodes by storing BigInt values (and their moduli) by their ID in a HashMap:
+/// Resolve BigInt opcodes by storing BigInt values (and their moduli) by their ID in the BigIntSolver
 /// - When it encounters a bigint operation opcode, it performs the operation on the stored values
 /// and store the result using the provided ID.
 /// - When it gets a to_bytes opcode, it simply looks up the value and resolves the output witness accordingly.
 #[derive(Default)]
-pub(crate) struct BigIntSolver {
-    bigint_id_to_value: HashMap<u32, BigUint>,
-    bigint_id_to_modulus: HashMap<u32, BigUint>,
+pub(crate) struct AcvmBigIntSolver {
+    bigint_solver: BigIntSolver,
 }
 
-impl BigIntSolver {
-    pub(crate) fn get_bigint(
-        &self,
-        id: u32,
-        func: BlackBoxFunc,
-    ) -> Result<BigUint, OpcodeResolutionError> {
-        self.bigint_id_to_value
-            .get(&id)
-            .ok_or(OpcodeResolutionError::BlackBoxFunctionFailed(
-                func,
-                format!("could not find bigint of id {id}"),
-            ))
-            .cloned()
-    }
-
-    pub(crate) fn get_modulus(
-        &self,
-        id: u32,
-        func: BlackBoxFunc,
-    ) -> Result<BigUint, OpcodeResolutionError> {
-        self.bigint_id_to_modulus
-            .get(&id)
-            .ok_or(OpcodeResolutionError::BlackBoxFunctionFailed(
-                func,
-                format!("could not find bigint of id {id}"),
-            ))
-            .cloned()
-    }
+impl AcvmBigIntSolver {
     pub(crate) fn bigint_from_bytes(
         &mut self,
         inputs: &[FunctionInput],
@@ -59,10 +29,7 @@ impl BigIntSolver {
             .iter()
             .map(|input| initial_witness.get(&input.witness).unwrap().to_u128() as u8)
             .collect::<Vec<u8>>();
-        let bigint = BigUint::from_bytes_le(&bytes);
-        self.bigint_id_to_value.insert(output, bigint);
-        let modulus = BigUint::from_bytes_le(modulus);
-        self.bigint_id_to_modulus.insert(output, modulus);
+        self.bigint_solver.bigint_from_bytes(&bytes, modulus, output)?;
         Ok(())
     }
 
@@ -72,9 +39,7 @@ impl BigIntSolver {
         outputs: &[Witness],
         initial_witness: &mut WitnessMap,
     ) -> Result<(), OpcodeResolutionError> {
-        let bigint = self.get_bigint(input, BlackBoxFunc::BigIntToLeBytes)?;
-
-        let mut bytes = bigint.to_bytes_le();
+        let mut bytes = self.bigint_solver.bigint_to_bytes(input)?;
         while bytes.len() < outputs.len() {
             bytes.push(0);
         }
@@ -91,30 +56,7 @@ impl BigIntSolver {
         output: u32,
         func: BlackBoxFunc,
     ) -> Result<(), OpcodeResolutionError> {
-        let modulus = self.get_modulus(lhs, func)?;
-        let lhs = self.get_bigint(lhs, func)?;
-        let rhs = self.get_bigint(rhs, func)?;
-        let mut result = match func {
-            BlackBoxFunc::BigIntAdd => lhs + rhs,
-            BlackBoxFunc::BigIntSub => {
-                if lhs >= rhs {
-                    &lhs - &rhs
-                } else {
-                    &lhs + &modulus - &rhs
-                }
-            }
-            BlackBoxFunc::BigIntMul => lhs * rhs,
-            BlackBoxFunc::BigIntDiv => {
-                lhs * rhs.modpow(&(&modulus - BigUint::from(2_u32)), &modulus)
-            } //TODO ensure that modulus is prime
-            _ => unreachable!("ICE - bigint_op must be called for an operation"),
-        };
-        if result > modulus {
-            let q = &result / &modulus;
-            result -= q * &modulus;
-        }
-        self.bigint_id_to_value.insert(output, result);
-        self.bigint_id_to_modulus.insert(output, modulus);
+        self.bigint_solver.bigint_op(lhs, rhs, output, func)?;
         Ok(())
     }
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index e7ed402a8eb..e6b3bb574bc 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -6,7 +6,7 @@ use acir::{
 use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256};
 
 use self::{
-    bigint::BigIntSolver, hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash,
+    bigint::AcvmBigIntSolver, hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash,
 };
 
 use super::{insert_value, OpcodeNotSolvable, OpcodeResolutionError};
@@ -56,7 +56,7 @@ pub(crate) fn solve(
     backend: &impl BlackBoxFunctionSolver,
     initial_witness: &mut WitnessMap,
     bb_func: &BlackBoxFuncCall,
-    bigint_solver: &mut BigIntSolver,
+    bigint_solver: &mut AcvmBigIntSolver,
 ) -> Result<(), OpcodeResolutionError> {
     let inputs = bb_func.get_inputs_vec();
     if !contains_all_inputs(initial_witness, &inputs) {
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index bb98eda2689..8f16316f318 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -11,7 +11,7 @@ use acir::{
 use acvm_blackbox_solver::BlackBoxResolutionError;
 
 use self::{
-    arithmetic::ExpressionSolver, blackbox::bigint::BigIntSolver, directives::solve_directives,
+    arithmetic::ExpressionSolver, blackbox::bigint::AcvmBigIntSolver, directives::solve_directives,
     memory_op::MemoryOpSolver,
 };
 use crate::BlackBoxFunctionSolver;
@@ -148,7 +148,7 @@ pub struct ACVM<'a, B: BlackBoxFunctionSolver> {
     /// Stores the solver for memory operations acting on blocks of memory disambiguated by [block][`BlockId`].
     block_solvers: HashMap<BlockId, MemoryOpSolver>,
 
-    bigint_solver: BigIntSolver,
+    bigint_solver: AcvmBigIntSolver,
 
     /// A list of opcodes which are to be executed by the ACVM.
     opcodes: &'a [Opcode],
@@ -174,7 +174,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             status,
             backend,
             block_solvers: HashMap::default(),
-            bigint_solver: BigIntSolver::default(),
+            bigint_solver: AcvmBigIntSolver::default(),
             opcodes,
             instruction_pointer: 0,
             witness_map: initial_witness,
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index d093b24a129..1d6629c8223 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -15,6 +15,7 @@ repository.workspace = true
 [dependencies]
 acir.workspace = true
 thiserror.workspace = true
+num-bigint = "0.4"
 
 blake2 = "0.10.6"
 blake3 = "1.5.0"
diff --git a/acvm-repo/blackbox_solver/src/bigint.rs b/acvm-repo/blackbox_solver/src/bigint.rs
new file mode 100644
index 00000000000..5b19f03a238
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/bigint.rs
@@ -0,0 +1,99 @@
+use std::collections::HashMap;
+
+use acir::BlackBoxFunc;
+
+use num_bigint::BigUint;
+
+use crate::BlackBoxResolutionError;
+
+/// Resolve BigInt opcodes by storing BigInt values (and their moduli) by their ID in a HashMap:
+/// - When it encounters a bigint operation opcode, it performs the operation on the stored values
+/// and store the result using the provided ID.
+/// - When it gets a to_bytes opcode, it simply looks up the value and resolves the output witness accordingly.
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+
+pub struct BigIntSolver {
+    bigint_id_to_value: HashMap<u32, BigUint>,
+    bigint_id_to_modulus: HashMap<u32, BigUint>,
+}
+
+impl BigIntSolver {
+    pub(crate) fn get_bigint(
+        &self,
+        id: u32,
+        func: BlackBoxFunc,
+    ) -> Result<BigUint, BlackBoxResolutionError> {
+        self.bigint_id_to_value
+            .get(&id)
+            .ok_or(BlackBoxResolutionError::Failed(
+                func,
+                format!("could not find bigint of id {id}"),
+            ))
+            .cloned()
+    }
+
+    pub(crate) fn get_modulus(
+        &self,
+        id: u32,
+        func: BlackBoxFunc,
+    ) -> Result<BigUint, BlackBoxResolutionError> {
+        self.bigint_id_to_modulus
+            .get(&id)
+            .ok_or(BlackBoxResolutionError::Failed(
+                func,
+                format!("could not find bigint of id {id}"),
+            ))
+            .cloned()
+    }
+    pub fn bigint_from_bytes(
+        &mut self,
+        inputs: &[u8],
+        modulus: &[u8],
+        output: u32,
+    ) -> Result<(), BlackBoxResolutionError> {
+        let bigint = BigUint::from_bytes_le(inputs);
+        self.bigint_id_to_value.insert(output, bigint);
+        let modulus = BigUint::from_bytes_le(modulus);
+        self.bigint_id_to_modulus.insert(output, modulus);
+        Ok(())
+    }
+
+    pub fn bigint_to_bytes(&self, input: u32) -> Result<Vec<u8>, BlackBoxResolutionError> {
+        let bigint = self.get_bigint(input, BlackBoxFunc::BigIntToLeBytes)?;
+        Ok(bigint.to_bytes_le())
+    }
+
+    pub fn bigint_op(
+        &mut self,
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+        func: BlackBoxFunc,
+    ) -> Result<(), BlackBoxResolutionError> {
+        let modulus = self.get_modulus(lhs, func)?;
+        let lhs = self.get_bigint(lhs, func)?;
+        let rhs = self.get_bigint(rhs, func)?;
+        let mut result = match func {
+            BlackBoxFunc::BigIntAdd => lhs + rhs,
+            BlackBoxFunc::BigIntSub => {
+                if lhs >= rhs {
+                    &lhs - &rhs
+                } else {
+                    &lhs + &modulus - &rhs
+                }
+            }
+            BlackBoxFunc::BigIntMul => lhs * rhs,
+            BlackBoxFunc::BigIntDiv => {
+                lhs * rhs.modpow(&(&modulus - BigUint::from(2_u32)), &modulus)
+            } //TODO ensure that modulus is prime
+            _ => unreachable!("ICE - bigint_op must be called for an operation"),
+        };
+        if result > modulus {
+            let q = &result / &modulus;
+            result -= q * &modulus;
+        }
+        self.bigint_id_to_value.insert(output, result);
+        self.bigint_id_to_modulus.insert(output, modulus);
+        Ok(())
+    }
+}
diff --git a/acvm-repo/blackbox_solver/src/lib.rs b/acvm-repo/blackbox_solver/src/lib.rs
index dc798bdab32..0f57f2ce7da 100644
--- a/acvm-repo/blackbox_solver/src/lib.rs
+++ b/acvm-repo/blackbox_solver/src/lib.rs
@@ -10,10 +10,12 @@
 use acir::BlackBoxFunc;
 use thiserror::Error;
 
+mod bigint;
 mod curve_specific_solver;
 mod ecdsa;
 mod hash;
 
+pub use bigint::BigIntSolver;
 pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver};
 pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 pub use hash::{blake2s, blake3, keccak256, keccakf1600, sha256, sha256compression};
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 73981fb0625..600e9d96b08 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -1,5 +1,6 @@
 use acir::brillig::{BlackBoxOp, HeapArray, HeapVector};
 use acir::{BlackBoxFunc, FieldElement};
+use acvm_blackbox_solver::BigIntSolver;
 use acvm_blackbox_solver::{
     blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, keccakf1600,
     sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
@@ -34,6 +35,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
     op: &BlackBoxOp,
     solver: &Solver,
     memory: &mut Memory,
+    bigint_solver: &mut BigIntSolver,
 ) -> Result<(), BlackBoxResolutionError> {
     match op {
         BlackBoxOp::Sha256 { message, output } => {
@@ -177,12 +179,57 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             memory.write(*output, hash.into());
             Ok(())
         }
-        BlackBoxOp::BigIntAdd { .. } => todo!(),
-        BlackBoxOp::BigIntSub { .. } => todo!(),
-        BlackBoxOp::BigIntMul { .. } => todo!(),
-        BlackBoxOp::BigIntDiv { .. } => todo!(),
-        BlackBoxOp::BigIntFromLeBytes { .. } => todo!(),
-        BlackBoxOp::BigIntToLeBytes { .. } => todo!(),
+        BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
+            let lhs = memory.read(*lhs).try_into().unwrap();
+            let rhs = memory.read(*rhs).try_into().unwrap();
+            let output = memory.read(*output).try_into().unwrap();
+            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntAdd)?;
+            Ok(())
+        }
+        BlackBoxOp::BigIntSub { lhs, rhs, output } => {
+            let lhs = memory.read(*lhs).try_into().unwrap();
+            let rhs = memory.read(*rhs).try_into().unwrap();
+            let output = memory.read(*output).try_into().unwrap();
+            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntSub)?;
+            Ok(())
+        }
+        BlackBoxOp::BigIntMul { lhs, rhs, output } => {
+            let lhs = memory.read(*lhs).try_into().unwrap();
+            let rhs = memory.read(*rhs).try_into().unwrap();
+            let output = memory.read(*output).try_into().unwrap();
+            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntMul)?;
+            Ok(())
+        }
+        BlackBoxOp::BigIntDiv { lhs, rhs, output } => {
+            let lhs = memory.read(*lhs).try_into().unwrap();
+            let rhs = memory.read(*rhs).try_into().unwrap();
+            let output = memory.read(*output).try_into().unwrap();
+            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntDiv)?;
+            Ok(())
+        }
+        BlackBoxOp::BigIntFromLeBytes { inputs, modulus, output } => {
+            let input = read_heap_vector(memory, inputs);
+            let input: Vec<u8> = input.iter().map(|x| x.try_into().unwrap()).collect();
+            let modulus = read_heap_vector(memory, modulus);
+            let modulus: Vec<u8> = modulus.iter().map(|x| x.try_into().unwrap()).collect();
+            let output = memory.read(*output).try_into().unwrap();
+            bigint_solver.bigint_from_bytes(&input, &modulus, output)?;
+            Ok(())
+        }
+        BlackBoxOp::BigIntToLeBytes { input, output } => {
+            let input: u32 = memory.read(*input).try_into().unwrap();
+            let bytes = bigint_solver.bigint_to_bytes(input)?;
+            let mut values = Vec::new();
+            for i in 0..32 {
+                if i < bytes.len() {
+                    values.push(bytes[i].into());
+                } else {
+                    values.push(0_u8.into());
+                }
+            }
+            memory.write_slice(memory.read_ref(output.pointer), &values);
+            Ok(())
+        }
         BlackBoxOp::Poseidon2Permutation { message, output, len } => {
             let input = read_heap_vector(memory, message);
             let input: Vec<FieldElement> = input.iter().map(|x| x.try_into().unwrap()).collect();
@@ -256,7 +303,7 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
 #[cfg(test)]
 mod test {
     use acir::brillig::{BlackBoxOp, MemoryAddress};
-    use acvm_blackbox_solver::StubbedBlackBoxSolver;
+    use acvm_blackbox_solver::{BigIntSolver, StubbedBlackBoxSolver};
 
     use crate::{
         black_box::{evaluate_black_box, to_u8_vec, to_value_vec},
@@ -281,7 +328,8 @@ mod test {
             output: HeapArray { pointer: 2.into(), size: 32 },
         };
 
-        evaluate_black_box(&op, &StubbedBlackBoxSolver, &mut memory).unwrap();
+        evaluate_black_box(&op, &StubbedBlackBoxSolver, &mut memory, &mut BigIntSolver::default())
+            .unwrap();
 
         let result = memory.read_slice(MemoryAddress(result_pointer), 32);
 
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 26d5da67576..a2380aa4652 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -16,7 +16,7 @@ use acir::brillig::{
     HeapVector, MemoryAddress, Opcode, ValueOrArray,
 };
 use acir::FieldElement;
-use acvm_blackbox_solver::BlackBoxFunctionSolver;
+use acvm_blackbox_solver::{BigIntSolver, BlackBoxFunctionSolver};
 use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
 use black_box::evaluate_black_box;
 use num_bigint::BigUint;
@@ -81,6 +81,8 @@ pub struct VM<'a, B: BlackBoxFunctionSolver> {
     call_stack: Vec<usize>,
     /// The solver for blackbox functions
     black_box_solver: &'a B,
+    // The solver for big integers
+    bigint_solver: BigIntSolver,
 }
 
 impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
@@ -101,6 +103,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
             memory: Memory::default(),
             call_stack: Vec::new(),
             black_box_solver,
+            bigint_solver: Default::default(),
         }
     }
 
@@ -311,7 +314,12 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 self.increment_program_counter()
             }
             Opcode::BlackBox(black_box_op) => {
-                match evaluate_black_box(black_box_op, self.black_box_solver, &mut self.memory) {
+                match evaluate_black_box(
+                    black_box_op,
+                    self.black_box_solver,
+                    &mut self.memory,
+                    &mut self.bigint_solver,
+                ) {
                     Ok(()) => self.increment_program_counter(),
                     Err(e) => self.fail(e.to_string()),
                 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 36b5f8793cb..1f86d66fd4e 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -1,8 +1,11 @@
-use acvm::acir::{brillig::BlackBoxOp, BlackBoxFunc};
+use acvm::{
+    acir::{brillig::BlackBoxOp, BlackBoxFunc},
+    FieldElement,
+};
 
 use crate::brillig::brillig_ir::{
     brillig_variable::{BrilligVariable, BrilligVector, SingleAddrVariable},
-    BrilligContext,
+    BrilligBinaryOp, BrilligContext,
 };
 
 /// Transforms SSA's black box function calls into the corresponding brillig instructions
@@ -235,10 +238,17 @@ pub(crate) fn convert_black_box_call(
         ),
         BlackBoxFunc::BigIntAdd => {
             if let (
-                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(rhs)],
-                [BrilligVariable::SingleAddr(output)],
+                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(lhs_modulus), BrilligVariable::SingleAddr(rhs), BrilligVariable::SingleAddr(rhs_modulus)],
+                [BrilligVariable::SingleAddr(output), BrilligVariable::SingleAddr(modulus_id)],
             ) = (function_arguments, function_results)
             {
+                prepare_bigint_output(
+                    brillig_context,
+                    lhs_modulus,
+                    rhs_modulus,
+                    output,
+                    modulus_id,
+                );
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntAdd {
                     lhs: lhs.address,
                     rhs: rhs.address,
@@ -246,16 +256,23 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: BigIntAdd expects two register arguments and one result register"
+                    "ICE: BigIntAdd expects four register arguments and two result registers"
                 )
             }
         }
         BlackBoxFunc::BigIntSub => {
             if let (
-                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(rhs)],
-                [BrilligVariable::SingleAddr(output)],
+                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(lhs_modulus), BrilligVariable::SingleAddr(rhs), BrilligVariable::SingleAddr(rhs_modulus)],
+                [BrilligVariable::SingleAddr(output), BrilligVariable::SingleAddr(modulus_id)],
             ) = (function_arguments, function_results)
             {
+                prepare_bigint_output(
+                    brillig_context,
+                    lhs_modulus,
+                    rhs_modulus,
+                    output,
+                    modulus_id,
+                );
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntSub {
                     lhs: lhs.address,
                     rhs: rhs.address,
@@ -263,16 +280,23 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: BigIntSub expects two register arguments and one result register"
+                    "ICE: BigIntSub expects four register arguments and two result registers"
                 )
             }
         }
         BlackBoxFunc::BigIntMul => {
             if let (
-                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(rhs)],
-                [BrilligVariable::SingleAddr(output)],
+                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(lhs_modulus), BrilligVariable::SingleAddr(rhs), BrilligVariable::SingleAddr(rhs_modulus)],
+                [BrilligVariable::SingleAddr(output), BrilligVariable::SingleAddr(modulus_id)],
             ) = (function_arguments, function_results)
             {
+                prepare_bigint_output(
+                    brillig_context,
+                    lhs_modulus,
+                    rhs_modulus,
+                    output,
+                    modulus_id,
+                );
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntMul {
                     lhs: lhs.address,
                     rhs: rhs.address,
@@ -280,16 +304,23 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: BigIntMul expects two register arguments and one result register"
+                    "ICE: BigIntMul expects four register arguments and two result registers"
                 )
             }
         }
         BlackBoxFunc::BigIntDiv => {
             if let (
-                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(rhs)],
-                [BrilligVariable::SingleAddr(output)],
+                [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(lhs_modulus), BrilligVariable::SingleAddr(rhs), BrilligVariable::SingleAddr(rhs_modulus)],
+                [BrilligVariable::SingleAddr(output), BrilligVariable::SingleAddr(modulus_id)],
             ) = (function_arguments, function_results)
             {
+                prepare_bigint_output(
+                    brillig_context,
+                    lhs_modulus,
+                    rhs_modulus,
+                    output,
+                    modulus_id,
+                );
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntDiv {
                     lhs: lhs.address,
                     rhs: rhs.address,
@@ -297,16 +328,20 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: BigIntDiv expects two register arguments and one result register"
+                    "ICE: BigIntDiv expects four register arguments and two result registers"
                 )
             }
         }
         BlackBoxFunc::BigIntFromLeBytes => {
-            if let ([inputs, modulus], [BrilligVariable::SingleAddr(output)]) =
-                (function_arguments, function_results)
+            if let (
+                [inputs, modulus],
+                [BrilligVariable::SingleAddr(output), BrilligVariable::SingleAddr(_modulus_id)],
+            ) = (function_arguments, function_results)
             {
                 let inputs_vector = convert_array_or_vector(brillig_context, inputs, bb_func);
                 let modulus_vector = convert_array_or_vector(brillig_context, modulus, bb_func);
+                let output_id = brillig_context.get_new_bigint_id();
+                brillig_context.const_instruction(*output, FieldElement::from(output_id as u128));
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntFromLeBytes {
                     inputs: inputs_vector.to_heap_vector(),
                     modulus: modulus_vector.to_heap_vector(),
@@ -314,23 +349,24 @@ pub(crate) fn convert_black_box_call(
                 });
             } else {
                 unreachable!(
-                    "ICE: BigIntFromLeBytes expects two register arguments and one result register"
+                    "ICE: BigIntFromLeBytes expects a register and an array  as arguments and two result registers"
                 )
             }
         }
         BlackBoxFunc::BigIntToLeBytes => {
             if let (
-                [BrilligVariable::SingleAddr(input)],
-                [BrilligVariable::BrilligVector(result_vector)],
+                [BrilligVariable::SingleAddr(input), BrilligVariable::SingleAddr(_modulus)],
+                [result_array],
             ) = (function_arguments, function_results)
             {
+                let output = convert_array_or_vector(brillig_context, result_array, bb_func);
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntToLeBytes {
                     input: input.address,
-                    output: result_vector.to_heap_vector(),
+                    output: output.to_heap_vector(),
                 });
             } else {
                 unreachable!(
-                    "ICE: BigIntToLeBytes expects one register argument and one array result"
+                    "ICE: BigIntToLeBytes expects two register arguments and one array result"
                 )
             }
         }
@@ -383,3 +419,30 @@ fn convert_array_or_vector(
         ),
     }
 }
+
+fn prepare_bigint_output(
+    brillig_context: &mut BrilligContext,
+    lhs_modulus: &SingleAddrVariable,
+    rhs_modulus: &SingleAddrVariable,
+    output: &SingleAddrVariable,
+    modulus_id: &SingleAddrVariable,
+) {
+    // Check moduli
+    let condition = brillig_context.allocate_register();
+    let condition_adr = SingleAddrVariable { address: condition, bit_size: 1 };
+    brillig_context.binary_instruction(
+        *lhs_modulus,
+        *rhs_modulus,
+        condition_adr,
+        BrilligBinaryOp::Equals,
+    );
+    brillig_context.constrain_instruction(
+        condition_adr,
+        Some("moduli should be identical in BigInt operation".to_string()),
+    );
+    brillig_context.deallocate_register(condition);
+    // Set output id
+    let output_id = brillig_context.get_new_bigint_id();
+    brillig_context.const_instruction(*output, FieldElement::from(output_id as u128));
+    brillig_context.mov_instruction(modulus_id.address, lhs_modulus.address);
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index e5c731be679..4132089b36f 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -86,6 +86,8 @@ pub(crate) struct BrilligContext {
     next_section: usize,
     /// IR printer
     debug_show: DebugShow,
+    /// Counter for generating bigint ids in unconstrained functions
+    bigint_new_id: u32,
 }
 
 impl BrilligContext {
@@ -98,9 +100,15 @@ impl BrilligContext {
             section_label: 0,
             next_section: 1,
             debug_show: DebugShow::new(enable_debug_trace),
+            bigint_new_id: 0,
         }
     }
 
+    pub(crate) fn get_new_bigint_id(&mut self) -> u32 {
+        let result = self.bigint_new_id;
+        self.bigint_new_id += 1;
+        result
+    }
     /// Adds a brillig instruction to the brillig byte code
     fn push_opcode(&mut self, opcode: BrilligOpcode) {
         self.obj.push_opcode(opcode);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index fe3c5e0bb9c..88cf987325d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -23,6 +23,7 @@ impl BrilligContext {
             section_label: 0,
             next_section: 1,
             debug_show: DebugShow::new(false),
+            bigint_new_id: 0,
         };
 
         context.codegen_entry_point(&arguments, &return_parameters);
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 775571f4a41..e49d1427fce 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1261,7 +1261,8 @@ impl AcirContext {
                 let modulus = self.big_int_ctx.modulus(bigint.modulus_id());
                 let bytes_len = ((modulus - BigUint::from(1_u32)).bits() - 1) / 8 + 1;
                 output_count = bytes_len as usize;
-                (field_inputs, vec![FieldElement::from(bytes_len as u128)])
+                assert!(bytes_len == 32);
+                (field_inputs, vec![])
             }
             BlackBoxFunc::BigIntFromLeBytes => {
                 let invalid_input = "ICE - bigint operation requires 2 inputs";
diff --git a/docs/docs/noir/standard_library/bigint.md b/docs/docs/noir/standard_library/bigint.md
index 9aa4fb77112..54d791b82d3 100644
--- a/docs/docs/noir/standard_library/bigint.md
+++ b/docs/docs/noir/standard_library/bigint.md
@@ -48,7 +48,10 @@ The available operations for each big integer are:
 Construct a big integer from its little-endian bytes representation. Example:
 
 ```rust
+ // Construct a big integer from a slice of bytes
  let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
  ```
 
 Sure, here's the formatted version of the remaining methods:
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 39ec40a1480..ee9f8e44625 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -32,7 +32,7 @@ impl BigInt {
     #[builtin(bigint_from_le_bytes)]
     fn from_le_bytes(bytes: [u8], modulus: [u8]) -> BigInt {}
     #[builtin(bigint_to_le_bytes)]
-    fn to_le_bytes(self) -> [u8] {}
+    fn to_le_bytes(self) -> [u8; 32] {}
 
     fn check_32_bytes(self: Self, other: BigInt) -> bool {
         let bytes = self.to_le_bytes();
@@ -47,305 +47,420 @@ impl BigInt {
 
 trait BigField {
     fn from_le_bytes(bytes: [u8]) -> Self;
+    fn from_le_bytes_32(bytes: [u8; 32]) -> Self;
     fn to_le_bytes(self) -> [u8];
 }
 
 struct Secpk1Fq {
-    inner: BigInt,
+   array: [u8;32],
 }
 
 impl BigField for Secpk1Fq {
     fn from_le_bytes(bytes: [u8]) -> Secpk1Fq {
+        assert(bytes.len() <= 32);
+        let mut array = [0;32];
+        for i in 0..bytes.len() {
+            array[i] = bytes[i];
+        }
+        Secpk1Fq {
+            array: array,
+        }
+    }
+
+    fn from_le_bytes_32(bytes: [u8;32]) -> Secpk1Fq {
         Secpk1Fq {
-            inner: BigInt::from_le_bytes(bytes, secpk1_fq)
+            array: bytes,
         }
     }
+
     fn to_le_bytes(self) -> [u8] {
-        self.inner.to_le_bytes()
+        self.array
     }
 }
 
 impl Add for Secpk1Fq { 
     fn add(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fq {
-            inner: self.inner.bigint_add(other.inner)
+           array: a.bigint_add(b).to_le_bytes()
         }
     }
 }
 impl Sub for Secpk1Fq { 
     fn sub(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fq {
-            inner: self.inner.bigint_sub(other.inner)
+           array: a.bigint_sub(b).to_le_bytes()
         }
     }
 }
 impl Mul for Secpk1Fq { 
     fn mul(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fq {
-            inner: self.inner.bigint_mul(other.inner)
+           array: a.bigint_mul(b).to_le_bytes()
         }
-
     }
 }
 impl Div for Secpk1Fq { 
     fn div(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fq {
-            inner: self.inner.bigint_div(other.inner)
+           array: a.bigint_div(b).to_le_bytes()
         }
     }
 }
 impl Eq for Secpk1Fq {
     fn eq(self: Self, other: Secpk1Fq) -> bool {
-        self.inner.check_32_bytes(other.inner)
+        self.array == other.array
     }
 }
 
 struct Secpk1Fr {
-    inner: BigInt,
+    array: [u8;32],
 }
 
 impl BigField for Secpk1Fr {
     fn from_le_bytes(bytes: [u8]) -> Secpk1Fr {
+        assert(bytes.len() <= 32);
+        let mut array = [0;32];
+        for i in 0..bytes.len() {
+            array[i] = bytes[i];
+        }
         Secpk1Fr {
-            inner: BigInt::from_le_bytes(bytes, secpk1_fr)
+            array: array,
         }
     }
+
+    fn from_le_bytes_32(bytes: [u8;32]) -> Secpk1Fr {
+        Secpk1Fr {
+            array: bytes,
+        }
+    }
+    
     fn to_le_bytes(self) -> [u8] {
-        self.inner.to_le_bytes()
+        self.array
     }
 }
 
 impl Add for Secpk1Fr { 
     fn add(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fr {
-            inner: self.inner.bigint_add(other.inner)
+           array: a.bigint_add(b).to_le_bytes()
         }
     }
 }
 impl Sub for Secpk1Fr { 
     fn sub(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fr {
-            inner: self.inner.bigint_sub(other.inner)
+           array: a.bigint_sub(b).to_le_bytes()
         }
     }
 }
 impl Mul for Secpk1Fr { 
     fn mul(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fr {
-            inner: self.inner.bigint_mul(other.inner)
+           array: a.bigint_mul(b).to_le_bytes()
         }
-
     }
 }
 impl Div for Secpk1Fr { 
     fn div(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpk1Fr {
-            inner: self.inner.bigint_div(other.inner)
+           array: a.bigint_div(b).to_le_bytes()
         }
     }
 }
 impl Eq for Secpk1Fr {
     fn eq(self: Self, other: Secpk1Fr) -> bool {
-        self.inner.check_32_bytes(other.inner)
+        self.array == other.array
     }
 }
 
 struct Bn254Fr {
-    inner: BigInt,
+    array: [u8;32],
 }
 
 impl BigField for Bn254Fr {
     fn from_le_bytes(bytes: [u8]) -> Bn254Fr {
+        assert(bytes.len() <= 32);
+        let mut array = [0;32];
+        for i in 0..bytes.len() {
+            array[i] = bytes[i];
+        }
+        Bn254Fr {
+            array: array,
+        }
+    }
+
+    fn from_le_bytes_32(bytes: [u8;32]) -> Bn254Fr {
         Bn254Fr {
-            inner: BigInt::from_le_bytes(bytes, bn254_fr)
+            array: bytes,
         }
     }
+
     fn to_le_bytes(self) -> [u8] {
-        self.inner.to_le_bytes()
+        self.array
     }
 }
 
 impl Add for Bn254Fr { 
     fn add(self: Self, other: Bn254Fr) -> Bn254Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fr {
-            inner: self.inner.bigint_add(other.inner)
+           array: a.bigint_add(b).to_le_bytes()
         }
     }
 }
 impl Sub for Bn254Fr { 
     fn sub(self: Self, other: Bn254Fr) -> Bn254Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fr {
-            inner: self.inner.bigint_sub(other.inner)
+           array: a.bigint_sub(b).to_le_bytes()
         }
     }
 }
 impl Mul for Bn254Fr { 
     fn mul(self: Self, other: Bn254Fr) -> Bn254Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fr {
-            inner: self.inner.bigint_mul(other.inner)
+           array: a.bigint_mul(b).to_le_bytes()
         }
-
     }
 }
 impl Div for Bn254Fr { 
     fn div(self: Self, other: Bn254Fr) -> Bn254Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fr {
-            inner: self.inner.bigint_div(other.inner)
+           array: a.bigint_div(b).to_le_bytes()
         }
     }
 }
 impl Eq for Bn254Fr {
     fn eq(self: Self, other: Bn254Fr) -> bool {
-        self.inner.check_32_bytes(other.inner)
+        self.array == other.array
     }
 }
 
 struct Bn254Fq {
-    inner: BigInt,
+    array: [u8;32],
 }
 
 impl BigField for Bn254Fq {
     fn from_le_bytes(bytes: [u8]) -> Bn254Fq {
+        assert(bytes.len() <= 32);
+        let mut array = [0;32];
+        for i in 0..bytes.len() {
+            array[i] = bytes[i];
+        }
         Bn254Fq {
-            inner: BigInt::from_le_bytes(bytes, bn254_fq)
+            array: array,
         }
     }
+
+    fn from_le_bytes_32(bytes: [u8;32]) -> Bn254Fq {
+        Bn254Fq {
+            array: bytes,
+        }
+    }
+
     fn to_le_bytes(self) -> [u8] {
-        self.inner.to_le_bytes()
+        self.array
     }
 }
 
 impl Add for Bn254Fq { 
     fn add(self: Self, other: Bn254Fq) -> Bn254Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fq {
-            inner: self.inner.bigint_add(other.inner)
+           array: a.bigint_add(b).to_le_bytes()
         }
     }
 }
 impl Sub for Bn254Fq { 
     fn sub(self: Self, other: Bn254Fq) -> Bn254Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fq {
-            inner: self.inner.bigint_sub(other.inner)
+           array: a.bigint_sub(b).to_le_bytes()
         }
     }
 }
 impl Mul for Bn254Fq { 
     fn mul(self: Self, other: Bn254Fq) -> Bn254Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fq {
-            inner: self.inner.bigint_mul(other.inner)
+           array: a.bigint_mul(b).to_le_bytes()
         }
-
     }
 }
 impl Div for Bn254Fq { 
     fn div(self: Self, other: Bn254Fq) -> Bn254Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Bn254Fq {
-            inner: self.inner.bigint_div(other.inner)
+           array: a.bigint_div(b).to_le_bytes()
         }
     }
 }
 impl Eq for Bn254Fq {
     fn eq(self: Self, other: Bn254Fq) -> bool {
-        self.inner.check_32_bytes(other.inner)
+        self.array == other.array
     }
 }
 
 struct Secpr1Fq {
-    inner: BigInt,
+    array: [u8;32],
 }
 
 impl BigField for Secpr1Fq {
     fn from_le_bytes(bytes: [u8]) -> Secpr1Fq {
+        assert(bytes.len() <= 32);
+        let mut array = [0;32];
+        for i in 0..bytes.len() {
+            array[i] = bytes[i];
+        }
+        Secpr1Fq {
+            array: array,
+        }
+    }
+
+    fn from_le_bytes_32(bytes: [u8;32]) -> Secpr1Fq {
         Secpr1Fq {
-            inner: BigInt::from_le_bytes(bytes, secpr1_fq)
+            array: bytes,
         }
     }
+
     fn to_le_bytes(self) -> [u8] {
-        self.inner.to_le_bytes()
+        self.array
     }
 }
 
 impl Add for Secpr1Fq { 
     fn add(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fq {
-            inner: self.inner.bigint_add(other.inner)
+           array: a.bigint_add(b).to_le_bytes()
         }
     }
 }
 impl Sub for Secpr1Fq { 
     fn sub(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fq {
-            inner: self.inner.bigint_sub(other.inner)
+           array: a.bigint_sub(b).to_le_bytes()
         }
     }
 }
 impl Mul for Secpr1Fq { 
     fn mul(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fq {
-            inner: self.inner.bigint_mul(other.inner)
+           array: a.bigint_mul(b).to_le_bytes()
         }
-
     }
 }
 impl Div for Secpr1Fq { 
     fn div(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fq {
-            inner: self.inner.bigint_div(other.inner)
+           array: a.bigint_div(b).to_le_bytes()
         }
     }
 }
 impl Eq for Secpr1Fq {
     fn eq(self: Self, other: Secpr1Fq) -> bool {
-        self.inner.check_32_bytes(other.inner)
+        self.array == other.array
     }
 }
 
 struct Secpr1Fr {
-    inner: BigInt,
+    array: [u8;32],
 }
 
 impl BigField for Secpr1Fr {
     fn from_le_bytes(bytes: [u8]) -> Secpr1Fr {
+        assert(bytes.len() <= 32);
+        let mut array = [0;32];
+        for i in 0..bytes.len() {
+            array[i] = bytes[i];
+        }
+        Secpr1Fr {
+            array: array,
+        }
+    }
+
+    fn from_le_bytes_32(bytes: [u8;32]) -> Secpr1Fr {
         Secpr1Fr {
-            inner: BigInt::from_le_bytes(bytes, secpr1_fr)
+            array: bytes,
         }
     }
+
     fn to_le_bytes(self) -> [u8] {
-        self.inner.to_le_bytes()
+        self.array
     }
 }
 
 impl Add for Secpr1Fr { 
     fn add(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fr {
-            inner: self.inner.bigint_add(other.inner)
+           array: a.bigint_add(b).to_le_bytes()
         }
     }
 }
 impl Sub for Secpr1Fr { 
     fn sub(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fr {
-            inner: self.inner.bigint_sub(other.inner)
+           array: a.bigint_sub(b).to_le_bytes()
         }
     }
 }
 impl Mul for Secpr1Fr { 
     fn mul(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fr {
-            inner: self.inner.bigint_mul(other.inner)
+           array: a.bigint_mul(b).to_le_bytes()
         }
-
     }
 }
 impl Div for Secpr1Fr { 
     fn div(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
         Secpr1Fr {
-            inner: self.inner.bigint_div(other.inner)
+           array: a.bigint_div(b).to_le_bytes()
         }
     }
 }
 impl Eq for Secpr1Fr {
     fn eq(self: Self, other: Secpr1Fr) -> bool {
-        self.inner.check_32_bytes(other.inner)
+        self.array == other.array
     }
 }
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 908cab8accc..5645e4e9e1b 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -4,6 +4,23 @@ use dep::std::{bigint::Secpk1Fq, println};
 fn main(mut x: [u8; 5], y: [u8; 5]) {
     let a = bigint::Secpk1Fq::from_le_bytes(&[x[0], x[1], x[2], x[3], x[4]]);
     let b = bigint::Secpk1Fq::from_le_bytes(&[y[0], y[1], y[2], y[3], y[4]]);
+    let mut a_be_bytes = [0; 32];
+    let mut b_be_bytes = [0; 32];
+    for i in 0..5 {
+        a_be_bytes[31-i] = x[i];
+        b_be_bytes[31-i] = y[i];
+    }
+    let a_field = dep::std::field::bytes32_to_field(a_be_bytes);
+    let b_field = dep::std::field::bytes32_to_field(b_be_bytes);
+
+    // Regression for #4682
+    let c = if x[0] != 0 {
+        test_unconstrained1(a, b)
+    } else {
+        test_unconstrained2(a, b)
+    };
+    assert(c.array[0] == dep::std::wrapping_mul(x[0], y[0]));
+
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
     for i in 0..5 {
@@ -14,9 +31,26 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let d = a * b;
     assert(d / b == a);
 
+    let d = d - b;
+    let mut result = [0; 32];
+    let result_slice = (a_field * b_field - b_field).to_le_bytes(32);
+    for i in 0..32 {
+        result[i] = result_slice[i];
+    }
+    let d1 = bigint::Secpk1Fq::from_le_bytes_32(result);
+    assert(d1 == d);
     big_int_example(x[0], x[1]);
 }
 
+fn test_unconstrained1(a: Secpk1Fq, b: Secpk1Fq) -> Secpk1Fq {
+    let c = a * b;
+    c
+}
+unconstrained fn test_unconstrained2(a: Secpk1Fq, b: Secpk1Fq) -> Secpk1Fq {
+    let c = a + b;
+    test_unconstrained1(a, c)
+}
+
 // docs:start:big_int_example
 fn big_int_example(x: u8, y: u8) {
     let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);

From 6cc105ee441e093b4fccdd5fcc3db922eb28a3fb Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 17 Apr 2024 15:03:37 +0100
Subject: [PATCH 191/416] chore: remove unnecessary casts in `BoundedVec`
 (#4831)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We've got some leftovers from when arrays were indexed with `Field`s
here which we can remove.


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/collections/bounded_vec.nr | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 6d5fbd44247..c789bc386ef 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -10,7 +10,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
     }
 
     pub fn get(mut self: Self, index: u64) -> T {
-        assert(index as u64 < self.len);
+        assert(index < self.len);
         self.storage[index]
     }
 
@@ -19,7 +19,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
     }
 
     pub fn push(&mut self, elem: T) {
-        assert(self.len < MaxLen as u64, "push out of bounds");
+        assert(self.len < MaxLen, "push out of bounds");
 
         self.storage[self.len] = elem;
         self.len += 1;
@@ -41,7 +41,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
 
     pub fn extend_from_array<Len>(&mut self, array: [T; Len]) {
         let new_len = self.len + array.len();
-        assert(new_len as u64 <= MaxLen as u64, "extend_from_array out of bounds");
+        assert(new_len <= MaxLen, "extend_from_array out of bounds");
         for i in 0..array.len() {
             self.storage[self.len + i] = array[i];
         }
@@ -50,7 +50,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
 
     pub fn extend_from_slice(&mut self, slice: [T]) {
         let new_len = self.len + slice.len();
-        assert(new_len as u64 <= MaxLen as u64, "extend_from_slice out of bounds");
+        assert(new_len <= MaxLen, "extend_from_slice out of bounds");
         for i in 0..slice.len() {
             self.storage[self.len + i] = slice[i];
         }
@@ -60,7 +60,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
     pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>) {
         let append_len = vec.len();
         let new_len = self.len + append_len;
-        assert(new_len as u64 <= MaxLen as u64, "extend_from_bounded_vec out of bounds");
+        assert(new_len <= MaxLen, "extend_from_bounded_vec out of bounds");
 
         let mut exceeded_len = false;
         for i in 0..Len {
@@ -73,7 +73,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
     }
 
     pub fn pop(&mut self) -> T {
-        assert(self.len as u64 > 0);
+        assert(self.len > 0);
         self.len -= 1;
 
         let elem = self.storage[self.len];

From 5f02129b7357dc764bbf9bcbe34cf56f613250f0 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 17 Apr 2024 16:28:54 +0100
Subject: [PATCH 192/416] chore: add benchmarks for serializing a dummy program
 (#4813)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds some benchmarks for serializing a (not particularly
realistic) ACIR program to give a sense of how this scales with the
number of opcodes in a program. As part of this I've fixed some issues
in the existing benchmarks which prevented good flamegraphs being
generated on linux.

I've also smoothed out the experience for creating flamegraphs with new
scripts

1. run `sudo ./scripts/benchmark_start.sh`
2. cargo bench --bench serialization  -- --profile-time=10
3. run `sudo ./scripts/benchmark_stop.sh`

The flamegraphs for all of the serialization benchmarks will then be
stored in `target/criterion/<benchmark_name>/profile`

The scripts to start and stop benchmarking disable/enable some kernel
settings which improve profiling performance at the expense of security.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                              |  28 +++++-
 Cargo.toml                              |   8 ++
 acvm-repo/acir/Cargo.toml               |   6 ++
 acvm-repo/acir/benches/serialization.rs | 123 ++++++++++++++++++++++++
 scripts/benchmark_start.sh              |   3 +
 scripts/benchmark_stop.sh               |   3 +
 tooling/nargo_cli/Cargo.toml            |   8 +-
 7 files changed, 171 insertions(+), 8 deletions(-)
 create mode 100644 acvm-repo/acir/benches/serialization.rs
 create mode 100755 scripts/benchmark_start.sh
 create mode 100755 scripts/benchmark_stop.sh

diff --git a/Cargo.lock b/Cargo.lock
index 754a1c3d1fe..4ded5c40d4e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,8 +10,10 @@ dependencies = [
  "base64 0.21.2",
  "bincode",
  "brillig",
+ "criterion",
  "flate2",
  "fxhash",
+ "pprof 0.13.0",
  "serde",
  "serde-generate",
  "serde-reflection",
@@ -623,7 +625,7 @@ dependencies = [
  "lazy_static",
  "noir_grumpkin",
  "num-bigint",
- "pprof",
+ "pprof 0.12.1",
  "thiserror",
  "wasm-bindgen-futures",
  "wasmer",
@@ -2865,7 +2867,7 @@ dependencies = [
  "notify",
  "notify-debouncer-full",
  "paste",
- "pprof",
+ "pprof 0.13.0",
  "predicates 2.1.5",
  "prettytable-rs",
  "rayon",
@@ -3546,6 +3548,28 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "pprof"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef5c97c51bd34c7e742402e216abdeb44d415fbe6ae41d56b114723e953711cb"
+dependencies = [
+ "backtrace",
+ "cfg-if 1.0.0",
+ "criterion",
+ "findshlibs",
+ "inferno",
+ "libc",
+ "log",
+ "nix 0.26.4",
+ "once_cell",
+ "parking_lot 0.12.1",
+ "smallvec",
+ "symbolic-demangle",
+ "tempfile",
+ "thiserror",
+]
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
diff --git a/Cargo.toml b/Cargo.toml
index 5dd453415aa..6a939878f9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -104,6 +104,14 @@ chumsky = { git = "https://github.com/jfecher/chumsky", rev = "ad9d312", default
     "ahash",
     "std",
 ] }
+
+# Benchmarking
+criterion = "0.5.0"
+# Note that using the "frame-pointer" feature breaks framegraphs on linux
+# https://github.com/tikv/pprof-rs/pull/172
+pprof = { version = "0.13", features = ["flamegraph","criterion"] }
+
+
 dirs = "4"
 serde = { version = "1.0.136", features = ["derive"] }
 serde_json = "1.0"
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 99095ad3f61..1702780ba9b 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -28,8 +28,14 @@ strum_macros = "0.24"
 serde-reflection = "0.3.6"
 serde-generate = "0.25.1"
 fxhash.workspace = true
+criterion.workspace = true
+pprof.workspace = true
 
 [features]
 default = ["bn254"]
 bn254 = ["acir_field/bn254", "brillig/bn254"]
 bls12_381 = ["acir_field/bls12_381", "brillig/bls12_381"]
+
+[[bench]]
+name = "serialization"
+harness = false
diff --git a/acvm-repo/acir/benches/serialization.rs b/acvm-repo/acir/benches/serialization.rs
new file mode 100644
index 00000000000..73e3916a73b
--- /dev/null
+++ b/acvm-repo/acir/benches/serialization.rs
@@ -0,0 +1,123 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use std::{collections::BTreeSet, time::Duration};
+
+use acir::{
+    circuit::{Circuit, ExpressionWidth, Opcode, Program, PublicInputs},
+    native_types::{Expression, Witness},
+    FieldElement,
+};
+
+use pprof::criterion::{Output, PProfProfiler};
+
+const SIZES: [usize; 9] = [10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000];
+
+fn sample_program(num_opcodes: usize) -> Program {
+    let assert_zero_opcodes: Vec<Opcode> = (0..num_opcodes)
+        .map(|i| {
+            Opcode::AssertZero(Expression {
+                mul_terms: vec![(
+                    FieldElement::from(2 * i),
+                    Witness(i as u32),
+                    Witness(i as u32 + 10),
+                )],
+                linear_combinations: vec![
+                    (FieldElement::from(2 * i), Witness(i as u32)),
+                    (FieldElement::from(3 * i), Witness(i as u32 + 1)),
+                ],
+                q_c: FieldElement::from(i),
+            })
+        })
+        .collect();
+
+    Program {
+        functions: vec![Circuit {
+            current_witness_index: 4000,
+            opcodes: assert_zero_opcodes.to_vec(),
+            expression_width: ExpressionWidth::Bounded { width: 3 },
+            private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3), Witness(4)]),
+            public_parameters: PublicInputs(BTreeSet::from([Witness(5)])),
+            return_values: PublicInputs(BTreeSet::from([Witness(6)])),
+            assert_messages: Vec::new(),
+            recursive: false,
+        }],
+    }
+}
+
+fn bench_serialization(c: &mut Criterion) {
+    let mut group = c.benchmark_group("serialize_program");
+    for size in SIZES.iter() {
+        let program = sample_program(*size);
+
+        group.throughput(Throughput::Elements(*size as u64));
+        group.bench_with_input(BenchmarkId::from_parameter(size), &program, |b, program| {
+            b.iter(|| Program::serialize_program(program));
+        });
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("serialize_program_json");
+    for size in SIZES.iter() {
+        let program = sample_program(*size);
+
+        group.throughput(Throughput::Elements(*size as u64));
+        group.bench_with_input(BenchmarkId::from_parameter(size), &program, |b, program| {
+            b.iter(|| {
+                let mut bytes = Vec::new();
+                let mut serializer = serde_json::Serializer::new(&mut bytes);
+                Program::serialize_program_base64(program, &mut serializer)
+            });
+        });
+    }
+    group.finish();
+}
+
+fn bench_deserialization(c: &mut Criterion) {
+    let mut group = c.benchmark_group("deserialize_program");
+    for size in SIZES.iter() {
+        let program = sample_program(*size);
+        let serialized_program = Program::serialize_program(&program);
+
+        group.throughput(Throughput::Elements(*size as u64));
+        group.bench_with_input(
+            BenchmarkId::from_parameter(size),
+            &serialized_program,
+            |b, program| {
+                b.iter(|| Program::deserialize_program(program));
+            },
+        );
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("deserialize_program_json");
+    for size in SIZES.iter() {
+        let program = sample_program(*size);
+
+        let serialized_program = {
+            let mut bytes = Vec::new();
+            let mut serializer = serde_json::Serializer::new(&mut bytes);
+            Program::serialize_program_base64(&program, &mut serializer).expect("should succeed");
+            bytes
+        };
+
+        group.throughput(Throughput::Elements(*size as u64));
+        group.bench_with_input(
+            BenchmarkId::from_parameter(size),
+            &serialized_program,
+            |b, program| {
+                b.iter(|| {
+                    let mut deserializer = serde_json::Deserializer::from_slice(program);
+                    Program::deserialize_program_base64(&mut deserializer)
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default().sample_size(40).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = bench_serialization, bench_deserialization
+);
+
+criterion_main!(benches);
diff --git a/scripts/benchmark_start.sh b/scripts/benchmark_start.sh
new file mode 100755
index 00000000000..3e69b3d2c65
--- /dev/null
+++ b/scripts/benchmark_start.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid
diff --git a/scripts/benchmark_stop.sh b/scripts/benchmark_stop.sh
new file mode 100755
index 00000000000..964e5291817
--- /dev/null
+++ b/scripts/benchmark_stop.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo 4 | sudo tee /proc/sys/kernel/perf_event_paranoid
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index 1629ae86edb..111caaa9c92 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -72,13 +72,9 @@ assert_cmd = "2.0.8"
 assert_fs = "1.0.10"
 predicates = "2.1.5"
 fm.workspace = true
-criterion = "0.5.0"
+criterion.workspace = true
+pprof.workspace = true
 paste = "1.0.14"
-pprof = { version = "0.12", features = [
-    "flamegraph",
-    "frame-pointer",
-    "criterion",
-] }
 iai = "0.1.1"
 test-binary = "3.0.2"
 

From 6cefe16deb643951c0cc552d08e22272900ed456 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 17 Apr 2024 16:52:46 +0100
Subject: [PATCH 193/416] feat: implement `Eq` trait on `BoundedVec` (#4830)

# Description

## Problem\*

Resolves #4827

## Summary\*

We're currently not implementing the `Eq` trait on `BoundedVec`, which
is added in this PR.

I've opted for ignoring differences in the storage array past `len` as
while it's not possible to have non-zeroed entries past this index if
you use the proper interface, it's possible to construct `BoundedVec`s
for which this is not the case. Once we allow proper encapsulation of
the internal state then we could simply check that the underlying
storage is equal.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 noir_stdlib/src/collections/bounded_vec.nr | 61 ++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index c789bc386ef..b18a9e9ec5c 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -1,3 +1,5 @@
+use crate::cmp::Eq;
+
 struct BoundedVec<T, MaxLen> {
     storage: [T; MaxLen],
     len: u64,
@@ -93,3 +95,62 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         ret
     }
 }
+
+impl<T, MaxLen> Eq for BoundedVec<T, MaxLen> where T: Eq {
+    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {
+        let mut ret = self.len == other.len;
+        let mut exceeded_len = false;
+        for i in 0..MaxLen {
+            exceeded_len |= i == self.len;
+            if !exceeded_len {
+                ret &= self.storage[i] == other.storage[i];
+            }
+        }
+        ret
+    }
+}
+
+mod bounded_vec_tests {
+    // TODO: Allow imports from "super"
+    use crate::collections::bounded_vec::BoundedVec;
+
+    #[test]
+    fn empty_equality() {
+        let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();
+        let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();
+
+        assert_eq(bounded_vec1, bounded_vec2);
+    }
+
+    #[test]
+    fn inequality() {
+        let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();
+        let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();
+        bounded_vec1.push(1);
+        bounded_vec2.push(2);
+
+        assert(bounded_vec1 != bounded_vec2);
+    }
+
+    #[test]
+    fn equality_respects_specified_length() {
+        let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();
+        bounded_vec1.push(1);
+
+        // This BoundedVec has an extra value past the end of its specified length,
+        // this should be ignored when checking equality so they are considered equal.
+        let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec { storage: [1, 2, 0], len: 1 };
+
+        assert_eq(bounded_vec1, bounded_vec2);
+
+        // Pushing another entry onto `bounded_vec1` to make the underlying arrays equal should
+        // result in the `BoundedVec`s being unequal as their lengths are different.
+        bounded_vec1.push(2);
+
+        assert(bounded_vec1 != bounded_vec2);
+
+        bounded_vec2.push(2);
+
+        assert_eq(bounded_vec1, bounded_vec2);
+    }
+}

From 0f9ae0ac1d68714b56ba4524aedcc67212494f1b Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 17 Apr 2024 14:12:34 -0400
Subject: [PATCH 194/416] feat: Sync from aztec-packages (#4833)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5814)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5794)
feat!: contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
fix: Don't reuse brillig with slice arguments
(https://github.com/AztecProtocol/aztec-packages/pull/5800)
chore: Use BrilligCall for unconstrained main and update AVM transpiler
(https://github.com/AztecProtocol/aztec-packages/pull/5797)
feat: Brillig pointer codegen and execution
(https://github.com/AztecProtocol/aztec-packages/pull/5737)
feat!: change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
feat!: Use fixed size arrays in black box functions where sizes are
known (https://github.com/AztecProtocol/aztec-packages/pull/5620)
feat!: trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
feat: impl of missing functionality in new key store
(https://github.com/AztecProtocol/aztec-packages/pull/5750)
feat(acir)!: BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .aztec-sync-commit                            |   2 +-
 Cargo.lock                                    |  10 +
 acvm-repo/acir/Cargo.toml                     |   1 +
 acvm-repo/acir/codegen/acir.cpp               | 159 ++++++++-
 acvm-repo/acir/src/circuit/brillig.rs         |   8 +
 acvm-repo/acir/src/circuit/mod.rs             |  94 ++---
 acvm-repo/acir/src/circuit/opcodes.rs         |  27 +-
 .../opcodes/black_box_function_call.rs        | 143 ++++++--
 .../acir/tests/test_program_serialization.rs  | 137 ++++----
 .../acvm/src/compiler/transformers/mod.rs     |  15 +
 acvm-repo/acvm/src/pwg/blackbox/hash.rs       |  68 ++--
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |  53 +--
 .../acvm/src/pwg/blackbox/signature/ecdsa.rs  |  73 +---
 .../acvm/src/pwg/blackbox/signature/mod.rs    |  15 +
 .../src/pwg/blackbox/signature/schnorr.rs     |   7 +-
 acvm-repo/acvm/src/pwg/brillig.rs             |  82 ++++-
 acvm-repo/acvm/src/pwg/mod.rs                 |  73 +++-
 acvm-repo/acvm/tests/solver.rs                |  36 +-
 acvm-repo/acvm_js/src/execute.rs              |  35 +-
 acvm-repo/acvm_js/test/shared/addition.ts     |  10 +-
 .../test/shared/complex_foreign_call.ts       |  14 +-
 .../test/shared/fixed_base_scalar_mul.ts      |   6 +-
 acvm-repo/acvm_js/test/shared/foreign_call.ts |   8 +-
 acvm-repo/acvm_js/test/shared/memory_op.ts    |   8 +-
 .../acvm_js/test/shared/nested_acir_call.ts   |  14 +-
 acvm-repo/acvm_js/test/shared/pedersen.ts     |   4 +-
 .../acvm_js/test/shared/schnorr_verify.ts     |  24 +-
 .../src/curve_specific_solver.rs              |   4 +-
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |   2 +-
 acvm-repo/brillig/src/opcodes.rs              |   7 +-
 acvm-repo/brillig_vm/src/black_box.rs         |   3 +-
 acvm-repo/brillig_vm/src/lib.rs               |  37 +-
 aztec_macros/src/lib.rs                       |  50 ++-
 .../compute_note_hash_and_nullifier.rs        |  25 +-
 .../src/transforms/contract_interface.rs      | 326 ++++++++++++++++++
 aztec_macros/src/transforms/events.rs         |   2 +-
 aztec_macros/src/transforms/mod.rs            |   1 +
 aztec_macros/src/transforms/note_interface.rs |  10 +-
 aztec_macros/src/transforms/storage.rs        |  16 +-
 aztec_macros/src/utils/constants.rs           |   1 +
 aztec_macros/src/utils/errors.rs              |  12 +
 aztec_macros/src/utils/hir_utils.rs           | 175 +++++++---
 .../brillig/brillig_gen/brillig_black_box.rs  |   2 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |  41 ++-
 .../noirc_evaluator/src/brillig/brillig_ir.rs |   4 +-
 .../src/brillig/brillig_ir/artifact.rs        |   4 +-
 .../brillig_ir/codegen_control_flow.rs        |  44 +++
 .../src/brillig/brillig_ir/debug_show.rs      |  12 +-
 .../src/brillig/brillig_ir/instructions.rs    |  29 +-
 compiler/noirc_evaluator/src/ssa.rs           |  26 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 100 ++++++
 .../ssa/acir_gen/acir_ir/generated_acir.rs    | 124 +++++--
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 256 ++++++++++++--
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  21 +-
 .../noirc_evaluator/src/ssa/ir/printer.rs     |  10 +-
 .../src/ssa/opt/defunctionalize.rs            |  17 +-
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  10 +-
 .../src/ssa/ssa_gen/program.rs                |  29 +-
 compiler/noirc_frontend/src/hir/mod.rs        |  35 +-
 compiler/noirc_frontend/src/node_interner.rs  |  24 +-
 .../brillig_slice_input/src/main.nr           |   3 +
 .../fold_after_inlined_calls/Nargo.toml       |   7 +
 .../fold_after_inlined_calls/Prover.toml      |   1 +
 .../fold_after_inlined_calls/src/main.nr      |  14 +
 tooling/backend_interface/src/cli/info.rs     |   2 +-
 tooling/backend_interface/src/proof_system.rs |   6 +-
 .../backend_interface/src/smart_contract.rs   |   4 +-
 .../mock_backend/src/info_cmd.rs              |   2 +-
 tooling/bb_abstraction_leaks/build.rs         |   2 +-
 tooling/debugger/ignored-tests.txt            |   2 +
 tooling/debugger/src/context.rs               |  17 +-
 tooling/debugger/src/dap.rs                   |   4 +
 tooling/debugger/src/lib.rs                   |   4 +-
 tooling/debugger/src/repl.rs                  |  25 +-
 tooling/lsp/src/solver.rs                     |   2 +-
 tooling/nargo/src/errors.rs                   |   4 +-
 tooling/nargo/src/ops/execute.rs              |  31 +-
 tooling/nargo_cli/src/cli/debug_cmd.rs        |   1 +
 tooling/nargo_cli/src/cli/info_cmd.rs         |   7 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 yarn.lock                                     |  10 +-
 81 files changed, 2068 insertions(+), 667 deletions(-)
 create mode 100644 aztec_macros/src/transforms/contract_interface.rs
 create mode 100644 test_programs/execution_success/fold_after_inlined_calls/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_after_inlined_calls/Prover.toml
 create mode 100644 test_programs/execution_success/fold_after_inlined_calls/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index f99c7ec7e49..1cb130e7c58 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-1dfbe7bc3bf3c455d8fb6c8b5fe6a96c1edf7af9
+beab8c93857536e07fa37994213fc664a5864013
diff --git a/Cargo.lock b/Cargo.lock
index 4ded5c40d4e..e83c10a1932 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -15,6 +15,7 @@ dependencies = [
  "fxhash",
  "pprof 0.13.0",
  "serde",
+ "serde-big-array",
  "serde-generate",
  "serde-reflection",
  "serde_json",
@@ -4409,6 +4410,15 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-big-array"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11fc7cc2c76d73e0f27ee52abbd64eec84d46f370c88371120433196934e4b7f"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde-generate"
 version = "0.25.1"
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 1702780ba9b..d6990f83281 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -20,6 +20,7 @@ thiserror.workspace = true
 flate2.workspace = true
 bincode.workspace = true
 base64.workspace = true
+serde-big-array = "0.5.1"
 
 [dev-dependencies]
 serde_json = "1.0"
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 7cd9fbefba0..6c7bd347e5d 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -54,7 +54,7 @@ namespace Program {
 
         struct SHA256 {
             std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+            std::array<Program::Witness, 32> outputs;
 
             friend bool operator==(const SHA256&, const SHA256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -63,7 +63,7 @@ namespace Program {
 
         struct Blake2s {
             std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+            std::array<Program::Witness, 32> outputs;
 
             friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -72,7 +72,7 @@ namespace Program {
 
         struct Blake3 {
             std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+            std::array<Program::Witness, 32> outputs;
 
             friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -82,7 +82,7 @@ namespace Program {
         struct SchnorrVerify {
             Program::FunctionInput public_key_x;
             Program::FunctionInput public_key_y;
-            std::vector<Program::FunctionInput> signature;
+            std::array<Program::FunctionInput, 64> signature;
             std::vector<Program::FunctionInput> message;
             Program::Witness output;
 
@@ -112,10 +112,10 @@ namespace Program {
         };
 
         struct EcdsaSecp256k1 {
-            std::vector<Program::FunctionInput> public_key_x;
-            std::vector<Program::FunctionInput> public_key_y;
-            std::vector<Program::FunctionInput> signature;
-            std::vector<Program::FunctionInput> hashed_message;
+            std::array<Program::FunctionInput, 32> public_key_x;
+            std::array<Program::FunctionInput, 32> public_key_y;
+            std::array<Program::FunctionInput, 64> signature;
+            std::array<Program::FunctionInput, 32> hashed_message;
             Program::Witness output;
 
             friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
@@ -124,10 +124,10 @@ namespace Program {
         };
 
         struct EcdsaSecp256r1 {
-            std::vector<Program::FunctionInput> public_key_x;
-            std::vector<Program::FunctionInput> public_key_y;
-            std::vector<Program::FunctionInput> signature;
-            std::vector<Program::FunctionInput> hashed_message;
+            std::array<Program::FunctionInput, 32> public_key_x;
+            std::array<Program::FunctionInput, 32> public_key_y;
+            std::array<Program::FunctionInput, 64> signature;
+            std::array<Program::FunctionInput, 32> hashed_message;
             Program::Witness output;
 
             friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
@@ -160,7 +160,7 @@ namespace Program {
         struct Keccak256 {
             std::vector<Program::FunctionInput> inputs;
             Program::FunctionInput var_message_size;
-            std::vector<Program::Witness> outputs;
+            std::array<Program::Witness, 32> outputs;
 
             friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -168,8 +168,8 @@ namespace Program {
         };
 
         struct Keccakf1600 {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::Witness> outputs;
+            std::array<Program::FunctionInput, 25> inputs;
+            std::array<Program::Witness, 25> outputs;
 
             friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -257,9 +257,9 @@ namespace Program {
         };
 
         struct Sha256Compression {
-            std::vector<Program::FunctionInput> inputs;
-            std::vector<Program::FunctionInput> hash_values;
-            std::vector<Program::Witness> outputs;
+            std::array<Program::FunctionInput, 16> inputs;
+            std::array<Program::FunctionInput, 8> hash_values;
+            std::array<Program::Witness, 8> outputs;
 
             friend bool operator==(const Sha256Compression&, const Sha256Compression&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -922,6 +922,9 @@ namespace Program {
         };
 
         struct Trap {
+            uint64_t revert_data_offset;
+            uint64_t revert_data_size;
+
             friend bool operator==(const Trap&, const Trap&);
             std::vector<uint8_t> bincodeSerialize() const;
             static Trap bincodeDeserialize(std::vector<uint8_t>);
@@ -1061,6 +1064,17 @@ namespace Program {
             static MemoryInit bincodeDeserialize(std::vector<uint8_t>);
         };
 
+        struct BrilligCall {
+            uint32_t id;
+            std::vector<Program::BrilligInputs> inputs;
+            std::vector<Program::BrilligOutputs> outputs;
+            std::optional<Program::Expression> predicate;
+
+            friend bool operator==(const BrilligCall&, const BrilligCall&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BrilligCall bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Call {
             uint32_t id;
             std::vector<Program::Witness> inputs;
@@ -1072,7 +1086,7 @@ namespace Program {
             static Call bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit, Call> value;
+        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit, BrilligCall, Call> value;
 
         friend bool operator==(const Opcode&, const Opcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1151,8 +1165,17 @@ namespace Program {
         static Circuit bincodeDeserialize(std::vector<uint8_t>);
     };
 
+    struct BrilligBytecode {
+        std::vector<Program::BrilligOpcode> bytecode;
+
+        friend bool operator==(const BrilligBytecode&, const BrilligBytecode&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static BrilligBytecode bincodeDeserialize(std::vector<uint8_t>);
+    };
+
     struct Program {
         std::vector<Program::Circuit> functions;
+        std::vector<Program::BrilligBytecode> unconstrained_functions;
 
         friend bool operator==(const Program&, const Program&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -4071,6 +4094,48 @@ Program::Brillig serde::Deserializable<Program::Brillig>::deserialize(Deserializ
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) {
+        if (!(lhs.bytecode == rhs.bytecode)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BrilligBytecode::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BrilligBytecode>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BrilligBytecode BrilligBytecode::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BrilligBytecode>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BrilligBytecode>::serialize(const Program::BrilligBytecode &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.bytecode)>::serialize(obj.bytecode, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::BrilligBytecode serde::Deserializable<Program::BrilligBytecode>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::BrilligBytecode obj;
+    obj.bytecode = serde::Deserializable<decltype(obj.bytecode)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) {
@@ -4952,6 +5017,8 @@ Program::BrilligOpcode::BlackBox serde::Deserializable<Program::BrilligOpcode::B
 namespace Program {
 
     inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) {
+        if (!(lhs.revert_data_offset == rhs.revert_data_offset)) { return false; }
+        if (!(lhs.revert_data_size == rhs.revert_data_size)) { return false; }
         return true;
     }
 
@@ -4975,12 +5042,16 @@ namespace Program {
 template <>
 template <typename Serializer>
 void serde::Serializable<Program::BrilligOpcode::Trap>::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.revert_data_offset)>::serialize(obj.revert_data_offset, serializer);
+    serde::Serializable<decltype(obj.revert_data_size)>::serialize(obj.revert_data_size, serializer);
 }
 
 template <>
 template <typename Deserializer>
 Program::BrilligOpcode::Trap serde::Deserializable<Program::BrilligOpcode::Trap>::deserialize(Deserializer &deserializer) {
     Program::BrilligOpcode::Trap obj;
+    obj.revert_data_offset = serde::Deserializable<decltype(obj.revert_data_offset)>::deserialize(deserializer);
+    obj.revert_data_size = serde::Deserializable<decltype(obj.revert_data_size)>::deserialize(deserializer);
     return obj;
 }
 
@@ -6118,6 +6189,53 @@ Program::Opcode::MemoryInit serde::Deserializable<Program::Opcode::MemoryInit>::
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const Opcode::BrilligCall &lhs, const Opcode::BrilligCall &rhs) {
+        if (!(lhs.id == rhs.id)) { return false; }
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        if (!(lhs.predicate == rhs.predicate)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> Opcode::BrilligCall::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<Opcode::BrilligCall>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline Opcode::BrilligCall Opcode::BrilligCall::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<Opcode::BrilligCall>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::Opcode::BrilligCall>::serialize(const Program::Opcode::BrilligCall &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.id)>::serialize(obj.id, serializer);
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+    serde::Serializable<decltype(obj.predicate)>::serialize(obj.predicate, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::Opcode::BrilligCall serde::Deserializable<Program::Opcode::BrilligCall>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::BrilligCall obj;
+    obj.id = serde::Deserializable<decltype(obj.id)>::deserialize(deserializer);
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    obj.predicate = serde::Deserializable<decltype(obj.predicate)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) {
@@ -6290,6 +6408,7 @@ namespace Program {
 
     inline bool operator==(const Program &lhs, const Program &rhs) {
         if (!(lhs.functions == rhs.functions)) { return false; }
+        if (!(lhs.unconstrained_functions == rhs.unconstrained_functions)) { return false; }
         return true;
     }
 
@@ -6315,6 +6434,7 @@ template <typename Serializer>
 void serde::Serializable<Program::Program>::serialize(const Program::Program &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.functions)>::serialize(obj.functions, serializer);
+    serde::Serializable<decltype(obj.unconstrained_functions)>::serialize(obj.unconstrained_functions, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -6324,6 +6444,7 @@ Program::Program serde::Deserializable<Program::Program>::deserialize(Deserializ
     deserializer.increase_container_depth();
     Program::Program obj;
     obj.functions = serde::Deserializable<decltype(obj.functions)>::deserialize(deserializer);
+    obj.unconstrained_functions = serde::Deserializable<decltype(obj.unconstrained_functions)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
diff --git a/acvm-repo/acir/src/circuit/brillig.rs b/acvm-repo/acir/src/circuit/brillig.rs
index f394a46ff82..e75d335d52b 100644
--- a/acvm-repo/acir/src/circuit/brillig.rs
+++ b/acvm-repo/acir/src/circuit/brillig.rs
@@ -29,3 +29,11 @@ pub struct Brillig {
     /// Predicate of the Brillig execution - indicates if it should be skipped
     pub predicate: Option<Expression>,
 }
+
+/// This is purely a wrapper struct around a list of Brillig opcode's which represents
+/// a full Brillig function to be executed by the Brillig VM.
+/// This is stored separately on a program and accessed through a [BrilligPointer].
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct BrilligBytecode {
+    pub bytecode: Vec<BrilligOpcode>,
+}
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index 9c858617acf..d655d136bc8 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -15,6 +15,8 @@ use serde::{de::Error as DeserializationError, Deserialize, Deserializer, Serial
 
 use std::collections::BTreeSet;
 
+use self::brillig::BrilligBytecode;
+
 /// Specifies the maximum width of the expressions which will be constrained.
 ///
 /// Unbounded Expressions are useful if you are eventually going to pass the ACIR
@@ -37,6 +39,7 @@ pub enum ExpressionWidth {
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct Program {
     pub functions: Vec<Circuit>,
+    pub unconstrained_functions: Vec<BrilligBytecode>,
 }
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
@@ -273,6 +276,10 @@ impl std::fmt::Display for Program {
             writeln!(f, "func {}", func_index)?;
             writeln!(f, "{}", function)?;
         }
+        for (func_index, function) in self.unconstrained_functions.iter().enumerate() {
+            writeln!(f, "unconstrained func {}", func_index)?;
+            writeln!(f, "{:?}", function.bytecode)?;
+        }
         Ok(())
     }
 }
@@ -324,61 +331,31 @@ mod tests {
         })
     }
     fn keccakf1600_opcode() -> Opcode {
-        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 {
-            inputs: vec![
-                FunctionInput { witness: Witness(1), num_bits: 64 },
-                FunctionInput { witness: Witness(2), num_bits: 64 },
-                FunctionInput { witness: Witness(3), num_bits: 64 },
-                FunctionInput { witness: Witness(4), num_bits: 64 },
-                FunctionInput { witness: Witness(5), num_bits: 64 },
-                FunctionInput { witness: Witness(6), num_bits: 64 },
-                FunctionInput { witness: Witness(7), num_bits: 64 },
-                FunctionInput { witness: Witness(8), num_bits: 64 },
-                FunctionInput { witness: Witness(9), num_bits: 64 },
-                FunctionInput { witness: Witness(10), num_bits: 64 },
-                FunctionInput { witness: Witness(11), num_bits: 64 },
-                FunctionInput { witness: Witness(12), num_bits: 64 },
-                FunctionInput { witness: Witness(13), num_bits: 64 },
-                FunctionInput { witness: Witness(14), num_bits: 64 },
-                FunctionInput { witness: Witness(15), num_bits: 64 },
-                FunctionInput { witness: Witness(16), num_bits: 64 },
-                FunctionInput { witness: Witness(17), num_bits: 64 },
-                FunctionInput { witness: Witness(18), num_bits: 64 },
-                FunctionInput { witness: Witness(19), num_bits: 64 },
-                FunctionInput { witness: Witness(20), num_bits: 64 },
-                FunctionInput { witness: Witness(21), num_bits: 64 },
-                FunctionInput { witness: Witness(22), num_bits: 64 },
-                FunctionInput { witness: Witness(23), num_bits: 64 },
-                FunctionInput { witness: Witness(24), num_bits: 64 },
-                FunctionInput { witness: Witness(25), num_bits: 64 },
-            ],
-            outputs: vec![
-                Witness(26),
-                Witness(27),
-                Witness(28),
-                Witness(29),
-                Witness(30),
-                Witness(31),
-                Witness(32),
-                Witness(33),
-                Witness(34),
-                Witness(35),
-                Witness(36),
-                Witness(37),
-                Witness(38),
-                Witness(39),
-                Witness(40),
-                Witness(41),
-                Witness(42),
-                Witness(43),
-                Witness(44),
-                Witness(45),
-                Witness(46),
-                Witness(47),
-                Witness(48),
-                Witness(49),
-                Witness(50),
-            ],
+        let inputs: Box<[FunctionInput; 25]> = Box::new(std::array::from_fn(|i| FunctionInput {
+            witness: Witness(i as u32 + 1),
+            num_bits: 8,
+        }));
+        let outputs: Box<[Witness; 25]> = Box::new(std::array::from_fn(|i| Witness(i as u32 + 26)));
+
+        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 { inputs, outputs })
+    }
+    fn schnorr_verify_opcode() -> Opcode {
+        let public_key_x =
+            FunctionInput { witness: Witness(1), num_bits: FieldElement::max_num_bits() };
+        let public_key_y =
+            FunctionInput { witness: Witness(2), num_bits: FieldElement::max_num_bits() };
+        let signature: Box<[FunctionInput; 64]> = Box::new(std::array::from_fn(|i| {
+            FunctionInput { witness: Witness(i as u32 + 3), num_bits: 8 }
+        }));
+        let message: Vec<FunctionInput> = vec![FunctionInput { witness: Witness(67), num_bits: 8 }];
+        let output = Witness(68);
+
+        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::SchnorrVerify {
+            public_key_x,
+            public_key_y,
+            signature,
+            message,
+            output,
         })
     }
 
@@ -387,14 +364,14 @@ mod tests {
         let circuit = Circuit {
             current_witness_index: 5,
             expression_width: ExpressionWidth::Unbounded,
-            opcodes: vec![and_opcode(), range_opcode()],
+            opcodes: vec![and_opcode(), range_opcode(), schnorr_verify_opcode()],
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(12)])),
             return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(4), Witness(12)])),
             assert_messages: Default::default(),
             recursive: false,
         };
-        let program = Program { functions: vec![circuit] };
+        let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
         fn read_write(program: Program) -> (Program, Program) {
             let bytes = Program::serialize_program(&program);
@@ -420,6 +397,7 @@ mod tests {
                 range_opcode(),
                 and_opcode(),
                 keccakf1600_opcode(),
+                schnorr_verify_opcode(),
             ],
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs(BTreeSet::from_iter(vec![Witness(2)])),
@@ -427,7 +405,7 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
-        let program = Program { functions: vec![circuit] };
+        let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
         let json = serde_json::to_string_pretty(&program).unwrap();
 
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index d8204132b3e..b0b8e286e0c 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -1,4 +1,7 @@
-use super::{brillig::Brillig, directives::Directive};
+use super::{
+    brillig::{Brillig, BrilligInputs, BrilligOutputs},
+    directives::Directive,
+};
 use crate::native_types::{Expression, Witness};
 use serde::{Deserialize, Serialize};
 
@@ -29,6 +32,18 @@ pub enum Opcode {
         block_id: BlockId,
         init: Vec<Witness>,
     },
+    /// Calls to unconstrained functions
+    BrilligCall {
+        /// Id for the function being called. It is the responsibility of the executor
+        /// to fetch the appropriate Brillig bytecode from this id.
+        id: u32,
+        /// Inputs to the function call
+        inputs: Vec<BrilligInputs>,
+        /// Outputs to the function call
+        outputs: Vec<BrilligOutputs>,
+        /// Predicate of the Brillig execution - indicates if it should be skipped
+        predicate: Option<Expression>,
+    },
     /// Calls to functions represented as a separate circuit. A call opcode allows us
     /// to build a call stack when executing the outer-most circuit.
     Call {
@@ -99,6 +114,16 @@ impl std::fmt::Display for Opcode {
                 write!(f, "INIT ")?;
                 write!(f, "(id: {}, len: {}) ", block_id.0, init.len())
             }
+            // We keep the display for a BrilligCall and circuit Call separate as they
+            // are distinct in their functionality and we should maintain this separation for debugging.
+            Opcode::BrilligCall { id, inputs, outputs, predicate } => {
+                write!(f, "BRILLIG CALL func {}: ", id)?;
+                if let Some(pred) = predicate {
+                    writeln!(f, "PREDICATE = {pred}")?;
+                }
+                write!(f, "inputs: {:?}, ", inputs)?;
+                write!(f, "outputs: {:?}", outputs)
+            }
             Opcode::Call { id, inputs, outputs, predicate } => {
                 write!(f, "CALL func {}: ", id)?;
                 if let Some(pred) = predicate {
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index d9089578739..405cd0cef00 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -1,6 +1,6 @@
 use crate::native_types::Witness;
 use crate::BlackBoxFunc;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 // Note: Some functions will not use all of the witness
 // So we need to supply how many bits of the witness is needed
@@ -27,20 +27,24 @@ pub enum BlackBoxFuncCall {
     },
     SHA256 {
         inputs: Vec<FunctionInput>,
-        outputs: Vec<Witness>,
+        outputs: Box<[Witness; 32]>,
     },
     Blake2s {
         inputs: Vec<FunctionInput>,
-        outputs: Vec<Witness>,
+        outputs: Box<[Witness; 32]>,
     },
     Blake3 {
         inputs: Vec<FunctionInput>,
-        outputs: Vec<Witness>,
+        outputs: Box<[Witness; 32]>,
     },
     SchnorrVerify {
         public_key_x: FunctionInput,
         public_key_y: FunctionInput,
-        signature: Vec<FunctionInput>,
+        #[serde(
+            serialize_with = "serialize_big_array",
+            deserialize_with = "deserialize_big_array_into_box"
+        )]
+        signature: Box<[FunctionInput; 64]>,
         message: Vec<FunctionInput>,
         output: Witness,
     },
@@ -55,17 +59,25 @@ pub enum BlackBoxFuncCall {
         output: Witness,
     },
     EcdsaSecp256k1 {
-        public_key_x: Vec<FunctionInput>,
-        public_key_y: Vec<FunctionInput>,
-        signature: Vec<FunctionInput>,
-        hashed_message: Vec<FunctionInput>,
+        public_key_x: Box<[FunctionInput; 32]>,
+        public_key_y: Box<[FunctionInput; 32]>,
+        #[serde(
+            serialize_with = "serialize_big_array",
+            deserialize_with = "deserialize_big_array_into_box"
+        )]
+        signature: Box<[FunctionInput; 64]>,
+        hashed_message: Box<[FunctionInput; 32]>,
         output: Witness,
     },
     EcdsaSecp256r1 {
-        public_key_x: Vec<FunctionInput>,
-        public_key_y: Vec<FunctionInput>,
-        signature: Vec<FunctionInput>,
-        hashed_message: Vec<FunctionInput>,
+        public_key_x: Box<[FunctionInput; 32]>,
+        public_key_y: Box<[FunctionInput; 32]>,
+        #[serde(
+            serialize_with = "serialize_big_array",
+            deserialize_with = "deserialize_big_array_into_box"
+        )]
+        signature: Box<[FunctionInput; 64]>,
+        hashed_message: Box<[FunctionInput; 32]>,
         output: Witness,
     },
     FixedBaseScalarMul {
@@ -87,11 +99,11 @@ pub enum BlackBoxFuncCall {
         /// is more than the number of bytes in the input,
         /// then an error is returned.
         var_message_size: FunctionInput,
-        outputs: Vec<Witness>,
+        outputs: Box<[Witness; 32]>,
     },
     Keccakf1600 {
-        inputs: Vec<FunctionInput>,
-        outputs: Vec<Witness>,
+        inputs: Box<[FunctionInput; 25]>,
+        outputs: Box<[Witness; 25]>,
     },
     RecursiveAggregation {
         verification_key: Vec<FunctionInput>,
@@ -154,11 +166,11 @@ pub enum BlackBoxFuncCall {
     /// * `outputs` - result of the input compressed into 256 bits
     Sha256Compression {
         /// 512 bits of the input message, represented by 16 u32s
-        inputs: Vec<FunctionInput>,
+        inputs: Box<[FunctionInput; 16]>,
         /// Vector of 8 u32s used to compress the input
-        hash_values: Vec<FunctionInput>,
+        hash_values: Box<[FunctionInput; 8]>,
         /// Output of the compression, represented by 8 u32s
-        outputs: Vec<Witness>,
+        outputs: Box<[Witness; 8]>,
     },
 }
 
@@ -201,13 +213,15 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::SHA256 { inputs, .. }
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
-            | BlackBoxFuncCall::Keccakf1600 { inputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
             | BlackBoxFuncCall::PedersenHash { inputs, .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
             | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. } => inputs.to_vec(),
+
+            BlackBoxFuncCall::Keccakf1600 { inputs, .. } => inputs.to_vec(),
+
             BlackBoxFuncCall::Sha256Compression { inputs, hash_values, .. } => {
-                inputs.iter().chain(hash_values).copied().collect()
+                inputs.iter().chain(hash_values.as_ref()).copied().collect()
             }
             BlackBoxFuncCall::AND { lhs, rhs, .. } | BlackBoxFuncCall::XOR { lhs, rhs, .. } => {
                 vec![*lhs, *rhs]
@@ -300,10 +314,14 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::SHA256 { outputs, .. }
             | BlackBoxFuncCall::Blake2s { outputs, .. }
             | BlackBoxFuncCall::Blake3 { outputs, .. }
-            | BlackBoxFuncCall::Keccakf1600 { outputs, .. }
-            | BlackBoxFuncCall::Keccak256 { outputs, .. }
-            | BlackBoxFuncCall::Poseidon2Permutation { outputs, .. }
-            | BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(),
+            | BlackBoxFuncCall::Keccak256 { outputs, .. } => outputs.to_vec(),
+
+            BlackBoxFuncCall::Keccakf1600 { outputs, .. } => outputs.to_vec(),
+
+            BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(),
+
+            BlackBoxFuncCall::Poseidon2Permutation { outputs, .. } => outputs.to_vec(),
+
             BlackBoxFuncCall::AND { output, .. }
             | BlackBoxFuncCall::XOR { output, .. }
             | BlackBoxFuncCall::SchnorrVerify { output, .. }
@@ -422,3 +440,78 @@ impl std::fmt::Debug for BlackBoxFuncCall {
         std::fmt::Display::fmt(self, f)
     }
 }
+
+fn serialize_big_array<S>(big_array: &[FunctionInput; 64], s: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    use serde_big_array::BigArray;
+
+    (*big_array).serialize(s)
+}
+
+fn deserialize_big_array_into_box<'de, D>(
+    deserializer: D,
+) -> Result<Box<[FunctionInput; 64]>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde_big_array::BigArray;
+
+    let big_array: [FunctionInput; 64] = BigArray::deserialize(deserializer)?;
+    Ok(Box::new(big_array))
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::{circuit::Opcode, native_types::Witness};
+    use acir_field::FieldElement;
+
+    use super::{BlackBoxFuncCall, FunctionInput};
+
+    fn keccakf1600_opcode() -> Opcode {
+        let inputs: Box<[FunctionInput; 25]> = Box::new(std::array::from_fn(|i| FunctionInput {
+            witness: Witness(i as u32 + 1),
+            num_bits: 8,
+        }));
+        let outputs: Box<[Witness; 25]> = Box::new(std::array::from_fn(|i| Witness(i as u32 + 26)));
+
+        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 { inputs, outputs })
+    }
+    fn schnorr_verify_opcode() -> Opcode {
+        let public_key_x =
+            FunctionInput { witness: Witness(1), num_bits: FieldElement::max_num_bits() };
+        let public_key_y =
+            FunctionInput { witness: Witness(2), num_bits: FieldElement::max_num_bits() };
+        let signature: Box<[FunctionInput; 64]> = Box::new(std::array::from_fn(|i| {
+            FunctionInput { witness: Witness(i as u32 + 3), num_bits: 8 }
+        }));
+        let message: Vec<FunctionInput> = vec![FunctionInput { witness: Witness(67), num_bits: 8 }];
+        let output = Witness(68);
+
+        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::SchnorrVerify {
+            public_key_x,
+            public_key_y,
+            signature,
+            message,
+            output,
+        })
+    }
+
+    #[test]
+    fn keccakf1600_serialization_roundtrip() {
+        let opcode = keccakf1600_opcode();
+        let buf = bincode::serialize(&opcode).unwrap();
+        let recovered_opcode = bincode::deserialize(&buf).unwrap();
+        assert_eq!(opcode, recovered_opcode);
+    }
+
+    #[test]
+    fn schnorr_serialization_roundtrip() {
+        let opcode = schnorr_verify_opcode();
+        let buf = bincode::serialize(&opcode).unwrap();
+        let recovered_opcode = bincode::deserialize(&buf).unwrap();
+        assert_eq!(opcode, recovered_opcode);
+    }
+}
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 8b9160ccf6a..fb924a7437d 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -41,17 +41,17 @@ fn addition_circuit() {
         return_values: PublicInputs([Witness(3)].into()),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 75, 14, 128, 32, 12, 68, 249, 120, 160, 150,
-        182, 208, 238, 188, 138, 68, 184, 255, 17, 212, 200, 130, 196, 165, 188, 164, 153, 174, 94,
-        38, 227, 221, 203, 118, 159, 119, 95, 226, 200, 125, 36, 252, 3, 253, 66, 87, 152, 92, 4,
-        153, 185, 149, 212, 144, 240, 128, 100, 85, 5, 88, 106, 86, 84, 20, 149, 51, 41, 81, 83,
-        214, 98, 213, 10, 24, 50, 53, 236, 98, 212, 135, 44, 174, 235, 5, 143, 35, 12, 151, 159,
-        126, 55, 109, 28, 231, 145, 47, 245, 105, 191, 143, 133, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 65, 14, 128, 32, 12, 4, 65, 124, 80, 75, 91,
+        104, 111, 126, 69, 34, 252, 255, 9, 106, 228, 64, 162, 55, 153, 164, 217, 158, 38, 155,
+        245, 238, 97, 189, 206, 187, 55, 161, 231, 214, 19, 254, 129, 126, 162, 107, 25, 92, 4,
+        137, 185, 230, 88, 145, 112, 135, 104, 69, 5, 88, 74, 82, 84, 20, 149, 35, 42, 81, 85, 214,
+        108, 197, 50, 24, 50, 85, 108, 98, 212, 186, 44, 204, 235, 5, 183, 99, 233, 46, 63, 252,
+        110, 216, 56, 184, 15, 78, 146, 74, 173, 20, 141, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -72,14 +72,14 @@ fn fixed_base_scalar_mul_circuit() {
         return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(3), Witness(4)])),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233,
-        29, 61, 43, 3, 5, 121, 34, 207, 86, 231, 162, 198, 157, 124, 228, 71, 157, 220, 232, 161,
-        227, 226, 206, 214, 95, 221, 74, 0, 116, 58, 13, 182, 105, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233,
+        29, 61, 35, 3, 19, 228, 137, 60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135,
+        142, 139, 219, 91, 127, 117, 71, 2, 117, 84, 50, 98, 113, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -100,14 +100,14 @@ fn pedersen_circuit() {
         return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(3)])),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 7, 6, 0, 0, 8, 108, 209, 255, 63, 156, 54, 233,
-        56, 55, 17, 26, 18, 196, 241, 169, 250, 178, 141, 167, 32, 159, 254, 234, 238, 255, 87,
-        112, 52, 63, 63, 101, 105, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 9, 10, 0, 0, 4, 115, 149, 255, 127, 88, 8, 133,
+        213, 218, 137, 80, 144, 32, 182, 79, 213, 151, 173, 61, 5, 121, 245, 91, 103, 255, 191, 3,
+        7, 16, 26, 112, 158, 113, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -119,8 +119,11 @@ fn schnorr_verify_circuit() {
         FunctionInput { witness: Witness(1), num_bits: FieldElement::max_num_bits() };
     let public_key_y =
         FunctionInput { witness: Witness(2), num_bits: FieldElement::max_num_bits() };
-    let signature =
-        (3..(3 + 64)).map(|i| FunctionInput { witness: Witness(i), num_bits: 8 }).collect();
+    let signature: [FunctionInput; 64] = (3..(3 + 64))
+        .map(|i| FunctionInput { witness: Witness(i), num_bits: 8 })
+        .collect::<Vec<_>>()
+        .try_into()
+        .unwrap();
     let message = ((3 + 64)..(3 + 64 + 10))
         .map(|i| FunctionInput { witness: Witness(i), num_bits: 8 })
         .collect();
@@ -130,7 +133,7 @@ fn schnorr_verify_circuit() {
     let schnorr = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::SchnorrVerify {
         public_key_x,
         public_key_y,
-        signature,
+        signature: Box::new(signature),
         message,
         output,
     });
@@ -142,27 +145,27 @@ fn schnorr_verify_circuit() {
         return_values: PublicInputs(BTreeSet::from([output])),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 78, 2, 1, 20, 69, 81, 236, 189, 247, 222,
-        123, 239, 93, 177, 33, 34, 238, 194, 253, 47, 193, 200, 147, 67, 194, 36, 147, 163, 33, 33,
-        228, 191, 219, 82, 168, 63, 63, 181, 183, 197, 223, 177, 147, 191, 181, 183, 149, 69, 159,
-        183, 213, 222, 238, 218, 219, 206, 14, 118, 178, 139, 141, 183, 135, 189, 236, 99, 63, 7,
-        56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227,
-        60, 23, 184, 200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 210, 85, 78, 67, 81, 24, 133, 209, 226, 238, 238,
+        238, 238, 238, 165, 148, 82, 102, 193, 252, 135, 64, 232, 78, 87, 147, 114, 147, 147, 5,
+        47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241, 115, 236, 228, 111, 237, 181,
+        178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 135, 189, 236, 99, 63, 7, 56,
+        200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60,
+        23, 184, 200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187,
         220, 227, 62, 15, 120, 200, 35, 30, 243, 132, 167, 60, 227, 57, 47, 120, 201, 43, 94, 243,
-        134, 183, 188, 227, 61, 31, 248, 200, 39, 22, 249, 204, 151, 166, 29, 243, 188, 250, 255,
-        141, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 123, 171, 76, 127, 105, 47,
-        189, 165, 181, 116, 150, 198, 26, 125, 245, 248, 45, 233, 41, 45, 165, 163, 52, 148, 126,
-        210, 78, 186, 73, 51, 233, 37, 173, 164, 147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33,
-        45, 164, 131, 52, 144, 253, 151, 11, 245, 221, 179, 121, 246, 206, 214, 217, 57, 27, 103,
-        223, 109, 187, 238, 218, 115, 223, 142, 135, 246, 59, 182, 219, 169, 189, 206, 237, 116,
-        105, 159, 107, 187, 220, 218, 227, 222, 14, 143, 238, 95, 116, 247, 23, 119, 126, 115, 223,
-        146, 187, 150, 221, 179, 226, 142, 141, 155, 53, 238, 86, 104, 186, 231, 255, 243, 7, 100,
-        141, 232, 192, 233, 3, 0, 0,
+        134, 183, 188, 227, 61, 31, 248, 200, 39, 62, 243, 133, 175, 77, 59, 230, 123, 243, 123,
+        145, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 239, 86, 153, 238, 210, 92,
+        122, 75, 107, 233, 44, 141, 53, 250, 234, 241, 191, 164, 167, 180, 148, 142, 210, 80, 250,
+        73, 59, 233, 38, 205, 164, 151, 180, 146, 78, 210, 72, 250, 72, 27, 233, 34, 77, 164, 135,
+        180, 144, 14, 210, 64, 246, 95, 46, 212, 119, 207, 230, 217, 59, 91, 103, 231, 108, 156,
+        125, 183, 237, 186, 107, 207, 125, 59, 30, 218, 239, 216, 110, 167, 246, 58, 183, 211, 165,
+        125, 174, 237, 114, 107, 143, 123, 59, 60, 186, 255, 179, 187, 191, 186, 115, 209, 125, 75,
+        238, 90, 118, 207, 138, 59, 54, 110, 214, 184, 91, 161, 233, 158, 255, 190, 63, 165, 188,
+        93, 151, 233, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -206,16 +209,17 @@ fn simple_brillig_foreign_call() {
         private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 48, 8, 133, 53, 133, 82, 186,
-        245, 38, 233, 13, 122, 153, 14, 93, 58, 132, 144, 227, 135, 252, 41, 56, 36, 46, 201, 7,
-        162, 168, 200, 123, 34, 52, 142, 28, 72, 245, 38, 106, 9, 247, 30, 202, 118, 142, 27, 215,
-        221, 178, 82, 175, 33, 15, 133, 189, 163, 159, 57, 197, 252, 251, 195, 235, 188, 230, 186,
-        16, 65, 255, 12, 239, 92, 131, 89, 149, 198, 77, 3, 10, 9, 119, 8, 198, 242, 152, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 32, 12, 133, 19, 11, 165, 116,
+        235, 77, 236, 13, 122, 153, 14, 93, 58, 136, 120, 124, 241, 47, 129, 12, 42, 130, 126, 16,
+        18, 146, 16, 222, 11, 66, 225, 136, 129, 84, 111, 162, 150, 112, 239, 161, 172, 231, 184,
+        113, 221, 45, 45, 245, 42, 242, 144, 216, 43, 250, 153, 83, 204, 191, 223, 189, 198, 246,
+        92, 39, 60, 244, 63, 195, 59, 87, 99, 150, 165, 113, 83, 193, 0, 1, 19, 247, 29, 5, 160, 1,
+        0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -306,20 +310,20 @@ fn complex_brillig_foreign_call() {
         private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3)]),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 93, 10, 131, 48, 12, 78, 218, 233, 100, 111,
-        187, 193, 96, 59, 64, 231, 9, 188, 139, 248, 166, 232, 163, 167, 23, 11, 126, 197, 24, 250,
-        34, 86, 208, 64, 72, 218, 252, 125, 36, 105, 153, 22, 42, 60, 51, 116, 235, 217, 64, 103,
-        156, 37, 5, 191, 10, 210, 29, 163, 63, 167, 203, 229, 206, 194, 104, 110, 128, 209, 158,
-        128, 49, 236, 195, 69, 231, 157, 114, 46, 73, 251, 103, 35, 239, 231, 225, 57, 243, 156,
-        227, 252, 132, 44, 112, 79, 176, 125, 84, 223, 73, 248, 145, 152, 69, 149, 4, 107, 233,
-        114, 90, 119, 145, 85, 237, 151, 192, 89, 247, 221, 208, 54, 163, 85, 174, 26, 234, 87,
-        232, 63, 101, 103, 21, 55, 169, 216, 73, 72, 249, 5, 197, 234, 132, 123, 179, 35, 247, 155,
-        214, 246, 102, 20, 73, 204, 72, 168, 123, 191, 161, 25, 66, 136, 159, 187, 53, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 218, 209, 145, 217,
+        205, 13, 6, 198, 3, 84, 79, 224, 93, 196, 157, 162, 75, 79, 47, 22, 124, 197, 16, 186, 17,
+        43, 104, 32, 36, 109, 126, 143, 36, 45, 211, 70, 133, 103, 134, 110, 61, 27, 232, 140, 179,
+        164, 224, 215, 64, 186, 115, 84, 113, 186, 92, 238, 42, 140, 230, 1, 24, 237, 5, 24, 195,
+        62, 220, 116, 222, 41, 231, 146, 180, 127, 54, 242, 126, 94, 158, 51, 207, 57, 206, 111,
+        200, 2, 247, 4, 219, 79, 245, 157, 132, 31, 137, 89, 52, 73, 176, 214, 46, 167, 125, 23,
+        89, 213, 254, 8, 156, 237, 56, 76, 125, 55, 91, 229, 170, 161, 254, 133, 94, 42, 59, 171,
+        184, 69, 197, 46, 66, 202, 47, 40, 86, 39, 220, 155, 3, 185, 191, 180, 183, 55, 163, 72,
+        98, 70, 66, 221, 251, 40, 173, 255, 35, 68, 62, 61, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -348,16 +352,16 @@ fn memory_op_circuit() {
         return_values: PublicInputs([Witness(4)].into()),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit] };
+    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 201, 13, 0, 32, 8, 147, 195, 125, 112, 3, 247,
-        159, 74, 141, 60, 106, 226, 79, 120, 216, 132, 180, 124, 154, 82, 168, 108, 212, 57, 2,
-        122, 129, 157, 201, 181, 150, 59, 186, 179, 189, 161, 101, 251, 82, 176, 175, 196, 121, 89,
-        118, 185, 246, 91, 185, 26, 125, 187, 64, 80, 134, 29, 195, 31, 79, 24, 2, 250, 167, 252,
-        27, 3, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 57, 14, 0, 32, 8, 147, 195, 255, 224, 15, 252,
+        255, 171, 212, 200, 208, 129, 77, 24, 108, 66, 90, 150, 166, 20, 106, 23, 125, 143, 128,
+        62, 96, 103, 114, 173, 45, 198, 116, 182, 55, 140, 106, 95, 74, 246, 149, 60, 47, 171, 46,
+        215, 126, 43, 87, 179, 111, 23, 8, 202, 176, 99, 248, 240, 9, 11, 137, 33, 212, 110, 35, 3,
+        0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -450,20 +454,21 @@ fn nested_acir_call_circuit() {
         ..Circuit::default()
     };
 
-    let program = Program { functions: vec![main, nested_call, inner_call] };
+    let program =
+        Program { functions: vec![main, nested_call, inner_call], unconstrained_functions: vec![] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147,
-        24, 173, 241, 223, 174, 50, 153, 189, 255, 17, 214, 177, 148, 89, 17, 250, 99, 14, 246,
-        224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 217, 109, 118, 91, 248, 200, 168,
-        225, 248, 191, 106, 114, 208, 233, 104, 188, 233, 139, 223, 137, 108, 51, 139, 113, 13,
-        161, 38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42,
-        65, 82, 46, 57, 97, 166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182,
-        54, 48, 144, 235, 8, 254, 10, 22, 76, 132, 101, 231, 237, 229, 23, 189, 213, 54, 119, 15,
-        83, 212, 199, 172, 175, 79, 113, 51, 48, 198, 253, 207, 84, 13, 204, 141, 224, 21, 176,
-        147, 158, 66, 231, 43, 145, 6, 4, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 65, 10, 3, 33, 12, 69, 163, 46, 230, 58, 137,
+        209, 49, 238, 122, 149, 74, 157, 251, 31, 161, 83, 154, 161, 86, 132, 89, 212, 194, 124,
+        248, 24, 36, 132, 228, 241, 29, 188, 229, 212, 47, 45, 187, 205, 110, 11, 31, 25, 53, 28,
+        255, 103, 77, 14, 58, 29, 141, 55, 125, 241, 55, 145, 109, 102, 49, 174, 33, 212, 228, 43,
+        49, 221, 209, 231, 34, 17, 67, 44, 171, 144, 80, 148, 248, 240, 194, 92, 37, 72, 202, 37,
+        39, 204, 20, 184, 210, 22, 51, 111, 58, 204, 205, 219, 11, 161, 129, 208, 214, 6, 6, 114,
+        29, 193, 127, 193, 130, 137, 176, 236, 188, 189, 252, 162, 183, 218, 230, 238, 97, 138,
+        250, 152, 245, 245, 87, 220, 12, 140, 113, 95, 153, 170, 129, 185, 17, 60, 3, 54, 212, 19,
+        104, 145, 195, 151, 14, 4, 0, 0,
     ];
     assert_eq!(bytes, expected_serialization);
 }
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 003cd4279a1..d13fac1672a 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -142,6 +142,21 @@ pub(super) fn transform_internal(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
+            Opcode::BrilligCall { ref outputs, .. } => {
+                for output in outputs {
+                    match output {
+                        BrilligOutputs::Simple(w) => transformer.mark_solvable(*w),
+                        BrilligOutputs::Array(v) => {
+                            for witness in v {
+                                transformer.mark_solvable(*witness);
+                            }
+                        }
+                    }
+                }
+
+                new_acir_opcode_positions.push(acir_opcode_positions[index]);
+                transformed_opcodes.push(opcode);
+            }
             Opcode::Call { ref outputs, .. } => {
                 for witness in outputs {
                     transformer.mark_solvable(*witness);
diff --git a/acvm-repo/acvm/src/pwg/blackbox/hash.rs b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
index 24c835a636a..caa09ea8973 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/hash.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    BlackBoxFunc, FieldElement,
+    FieldElement,
 };
 use acvm_blackbox_solver::{sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError};
 
@@ -14,22 +14,13 @@ pub(super) fn solve_generic_256_hash_opcode(
     initial_witness: &mut WitnessMap,
     inputs: &[FunctionInput],
     var_message_size: Option<&FunctionInput>,
-    outputs: &[Witness],
+    outputs: &[Witness; 32],
     hash_function: fn(data: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError>,
-    black_box_func: BlackBoxFunc,
 ) -> Result<(), OpcodeResolutionError> {
     let message_input = get_hash_input(initial_witness, inputs, var_message_size)?;
     let digest: [u8; 32] = hash_function(&message_input)?;
 
-    let outputs: [Witness; 32] = outputs.try_into().map_err(|_| {
-        OpcodeResolutionError::BlackBoxFunctionFailed(
-            black_box_func,
-            format!("Expected 32 outputs but encountered {}", outputs.len()),
-        )
-    })?;
-    write_digest_to_outputs(initial_witness, outputs, digest)?;
-
-    Ok(())
+    write_digest_to_outputs(initial_witness, outputs, digest)
 }
 
 /// Reads the hash function input from a [`WitnessMap`].
@@ -73,7 +64,7 @@ fn get_hash_input(
 /// Writes a `digest` to the [`WitnessMap`] at witness indices `outputs`.
 fn write_digest_to_outputs(
     initial_witness: &mut WitnessMap,
-    outputs: [Witness; 32],
+    outputs: &[Witness; 32],
     digest: [u8; 32],
 ) -> Result<(), OpcodeResolutionError> {
     for (output_witness, value) in outputs.iter().zip(digest.into_iter()) {
@@ -87,44 +78,29 @@ fn write_digest_to_outputs(
     Ok(())
 }
 
+fn to_u32_array<const N: usize>(
+    initial_witness: &WitnessMap,
+    inputs: &[FunctionInput; N],
+) -> Result<[u32; N], OpcodeResolutionError> {
+    let mut result = [0; N];
+    for (it, input) in result.iter_mut().zip(inputs) {
+        let witness_value = witness_to_value(initial_witness, input.witness)?;
+        *it = witness_value.to_u128() as u32;
+    }
+    Ok(result)
+}
+
 pub(crate) fn solve_sha_256_permutation_opcode(
     initial_witness: &mut WitnessMap,
-    inputs: &[FunctionInput],
-    hash_values: &[FunctionInput],
-    outputs: &[Witness],
-    black_box_func: BlackBoxFunc,
+    inputs: &[FunctionInput; 16],
+    hash_values: &[FunctionInput; 8],
+    outputs: &[Witness; 8],
 ) -> Result<(), OpcodeResolutionError> {
-    let mut message = [0; 16];
-    if inputs.len() != 16 {
-        return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
-            black_box_func,
-            format!("Expected 16 inputs but encountered {}", &message.len()),
-        ));
-    }
-    for (i, input) in inputs.iter().enumerate() {
-        let value = witness_to_value(initial_witness, input.witness)?;
-        message[i] = value.to_u128() as u32;
-    }
-
-    if hash_values.len() != 8 {
-        return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
-            black_box_func,
-            format!("Expected 8 values but encountered {}", hash_values.len()),
-        ));
-    }
-    let mut state = [0; 8];
-    for (i, hash) in hash_values.iter().enumerate() {
-        let value = witness_to_value(initial_witness, hash.witness)?;
-        state[i] = value.to_u128() as u32;
-    }
+    let message = to_u32_array(initial_witness, inputs)?;
+    let mut state = to_u32_array(initial_witness, hash_values)?;
 
     sha256compression(&mut state, &message);
-    let outputs: [Witness; 8] = outputs.try_into().map_err(|_| {
-        OpcodeResolutionError::BlackBoxFunctionFailed(
-            black_box_func,
-            format!("Expected 8 outputs but encountered {}", outputs.len()),
-        )
-    })?;
+
     for (output_witness, value) in outputs.iter().zip(state.into_iter()) {
         insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?;
     }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index e6b3bb574bc..2753c7baaaa 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -71,30 +71,16 @@ pub(crate) fn solve(
         BlackBoxFuncCall::AND { lhs, rhs, output } => and(initial_witness, lhs, rhs, output),
         BlackBoxFuncCall::XOR { lhs, rhs, output } => xor(initial_witness, lhs, rhs, output),
         BlackBoxFuncCall::RANGE { input } => solve_range_opcode(initial_witness, input),
-        BlackBoxFuncCall::SHA256 { inputs, outputs } => solve_generic_256_hash_opcode(
-            initial_witness,
-            inputs,
-            None,
-            outputs,
-            sha256,
-            bb_func.get_black_box_func(),
-        ),
-        BlackBoxFuncCall::Blake2s { inputs, outputs } => solve_generic_256_hash_opcode(
-            initial_witness,
-            inputs,
-            None,
-            outputs,
-            blake2s,
-            bb_func.get_black_box_func(),
-        ),
-        BlackBoxFuncCall::Blake3 { inputs, outputs } => solve_generic_256_hash_opcode(
-            initial_witness,
-            inputs,
-            None,
-            outputs,
-            blake3,
-            bb_func.get_black_box_func(),
-        ),
+        BlackBoxFuncCall::SHA256 { inputs, outputs } => {
+            solve_generic_256_hash_opcode(initial_witness, inputs, None, outputs, sha256)
+        }
+        BlackBoxFuncCall::Blake2s { inputs, outputs } => {
+            solve_generic_256_hash_opcode(initial_witness, inputs, None, outputs, blake2s)
+        }
+        BlackBoxFuncCall::Blake3 { inputs, outputs } => {
+            solve_generic_256_hash_opcode(initial_witness, inputs, None, outputs, blake3)
+        }
+
         BlackBoxFuncCall::Keccak256 { inputs, var_message_size, outputs } => {
             solve_generic_256_hash_opcode(
                 initial_witness,
@@ -102,18 +88,17 @@ pub(crate) fn solve(
                 Some(var_message_size),
                 outputs,
                 keccak256,
-                bb_func.get_black_box_func(),
             )
         }
         BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => {
             let mut state = [0; 25];
-            for (i, input) in inputs.iter().enumerate() {
+            for (it, input) in state.iter_mut().zip(inputs.as_ref()) {
                 let witness = input.witness;
                 let num_bits = input.num_bits as usize;
                 assert_eq!(num_bits, 64);
                 let witness_assignment = witness_to_value(initial_witness, witness)?;
                 let lane = witness_assignment.try_to_u64();
-                state[i] = lane.unwrap();
+                *it = lane.unwrap();
             }
             let output_state = keccakf1600(state)?;
             for (output_witness, value) in outputs.iter().zip(output_state.into_iter()) {
@@ -132,7 +117,7 @@ pub(crate) fn solve(
             initial_witness,
             *public_key_x,
             *public_key_y,
-            signature,
+            signature.as_ref(),
             message,
             *output,
         ),
@@ -153,7 +138,7 @@ pub(crate) fn solve(
             public_key_x,
             public_key_y,
             signature,
-            message,
+            message.as_ref(),
             *output,
         ),
         BlackBoxFuncCall::EcdsaSecp256r1 {
@@ -167,7 +152,7 @@ pub(crate) fn solve(
             public_key_x,
             public_key_y,
             signature,
-            message,
+            message.as_ref(),
             *output,
         ),
         BlackBoxFuncCall::FixedBaseScalarMul { low, high, outputs } => {
@@ -199,13 +184,7 @@ pub(crate) fn solve(
             bigint_solver.bigint_to_bytes(*input, outputs, initial_witness)
         }
         BlackBoxFuncCall::Sha256Compression { inputs, hash_values, outputs } => {
-            solve_sha_256_permutation_opcode(
-                initial_witness,
-                inputs,
-                hash_values,
-                outputs,
-                bb_func.get_black_box_func(),
-            )
+            solve_sha_256_permutation_opcode(initial_witness, inputs, hash_values, outputs)
         }
         BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len } => {
             solve_poseidon2_permutation_opcode(backend, initial_witness, inputs, outputs, *len)
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
index 8f0df8378ad..b113c801251 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
@@ -7,85 +7,42 @@ use acvm_blackbox_solver::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 
 use crate::{pwg::insert_value, OpcodeResolutionError};
 
-use super::to_u8_vec;
+use super::{to_u8_array, to_u8_vec};
 
 pub(crate) fn secp256k1_prehashed(
     initial_witness: &mut WitnessMap,
-    public_key_x_inputs: &[FunctionInput],
-    public_key_y_inputs: &[FunctionInput],
-    signature_inputs: &[FunctionInput],
+    public_key_x_inputs: &[FunctionInput; 32],
+    public_key_y_inputs: &[FunctionInput; 32],
+    signature_inputs: &[FunctionInput; 64],
     hashed_message_inputs: &[FunctionInput],
     output: Witness,
 ) -> Result<(), OpcodeResolutionError> {
     let hashed_message = to_u8_vec(initial_witness, hashed_message_inputs)?;
 
-    // These errors should never be emitted in practice as they would imply malformed ACIR generation.
-    let pub_key_x: [u8; 32] =
-        to_u8_vec(initial_witness, public_key_x_inputs)?.try_into().map_err(|_| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                acir::BlackBoxFunc::EcdsaSecp256k1,
-                format!("expected pubkey_x size 32 but received {}", public_key_x_inputs.len()),
-            )
-        })?;
-
-    let pub_key_y: [u8; 32] =
-        to_u8_vec(initial_witness, public_key_y_inputs)?.try_into().map_err(|_| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                acir::BlackBoxFunc::EcdsaSecp256k1,
-                format!("expected pubkey_y size 32 but received {}", public_key_y_inputs.len()),
-            )
-        })?;
-
-    let signature: [u8; 64] =
-        to_u8_vec(initial_witness, signature_inputs)?.try_into().map_err(|_| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                acir::BlackBoxFunc::EcdsaSecp256k1,
-                format!("expected signature size 64 but received {}", signature_inputs.len()),
-            )
-        })?;
+    let pub_key_x: [u8; 32] = to_u8_array(initial_witness, public_key_x_inputs)?;
+    let pub_key_y: [u8; 32] = to_u8_array(initial_witness, public_key_y_inputs)?;
+    let signature: [u8; 64] = to_u8_array(initial_witness, signature_inputs)?;
 
     let is_valid = ecdsa_secp256k1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?;
 
-    insert_value(&output, FieldElement::from(is_valid), initial_witness)?;
-    Ok(())
+    insert_value(&output, FieldElement::from(is_valid), initial_witness)
 }
 
 pub(crate) fn secp256r1_prehashed(
     initial_witness: &mut WitnessMap,
-    public_key_x_inputs: &[FunctionInput],
-    public_key_y_inputs: &[FunctionInput],
-    signature_inputs: &[FunctionInput],
+    public_key_x_inputs: &[FunctionInput; 32],
+    public_key_y_inputs: &[FunctionInput; 32],
+    signature_inputs: &[FunctionInput; 64],
     hashed_message_inputs: &[FunctionInput],
     output: Witness,
 ) -> Result<(), OpcodeResolutionError> {
     let hashed_message = to_u8_vec(initial_witness, hashed_message_inputs)?;
 
-    let pub_key_x: [u8; 32] =
-        to_u8_vec(initial_witness, public_key_x_inputs)?.try_into().map_err(|_| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                acir::BlackBoxFunc::EcdsaSecp256r1,
-                format!("expected pubkey_x size 32 but received {}", public_key_x_inputs.len()),
-            )
-        })?;
-
-    let pub_key_y: [u8; 32] =
-        to_u8_vec(initial_witness, public_key_y_inputs)?.try_into().map_err(|_| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                acir::BlackBoxFunc::EcdsaSecp256r1,
-                format!("expected pubkey_y size 32 but received {}", public_key_y_inputs.len()),
-            )
-        })?;
-
-    let signature: [u8; 64] =
-        to_u8_vec(initial_witness, signature_inputs)?.try_into().map_err(|_| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                acir::BlackBoxFunc::EcdsaSecp256r1,
-                format!("expected signature size 64 but received {}", signature_inputs.len()),
-            )
-        })?;
+    let pub_key_x: [u8; 32] = to_u8_array(initial_witness, public_key_x_inputs)?;
+    let pub_key_y: [u8; 32] = to_u8_array(initial_witness, public_key_y_inputs)?;
+    let signature: [u8; 64] = to_u8_array(initial_witness, signature_inputs)?;
 
     let is_valid = ecdsa_secp256r1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?;
 
-    insert_value(&output, FieldElement::from(is_valid), initial_witness)?;
-    Ok(())
+    insert_value(&output, FieldElement::from(is_valid), initial_witness)
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
index 0e28a63ff68..bd223ecd0c9 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
@@ -2,6 +2,21 @@ use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
 
 use crate::pwg::{witness_to_value, OpcodeResolutionError};
 
+fn to_u8_array<const N: usize>(
+    initial_witness: &WitnessMap,
+    inputs: &[FunctionInput; N],
+) -> Result<[u8; N], OpcodeResolutionError> {
+    let mut result = [0; N];
+    for (it, input) in result.iter_mut().zip(inputs) {
+        let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
+        let byte = witness_value_bytes
+            .last()
+            .expect("Field element must be represented by non-zero amount of bytes");
+        *it = *byte;
+    }
+    Ok(result)
+}
+
 fn to_u8_vec(
     initial_witness: &WitnessMap,
     inputs: &[FunctionInput],
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
index 7f5381cee91..3d0216fa217 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
@@ -1,4 +1,4 @@
-use super::to_u8_vec;
+use super::{to_u8_array, to_u8_vec};
 use crate::{
     pwg::{insert_value, witness_to_value, OpcodeResolutionError},
     BlackBoxFunctionSolver,
@@ -15,15 +15,14 @@ pub(crate) fn schnorr_verify(
     initial_witness: &mut WitnessMap,
     public_key_x: FunctionInput,
     public_key_y: FunctionInput,
-    signature: &[FunctionInput],
+    signature: &[FunctionInput; 64],
     message: &[FunctionInput],
     output: Witness,
 ) -> Result<(), OpcodeResolutionError> {
     let public_key_x: &FieldElement = witness_to_value(initial_witness, public_key_x.witness)?;
     let public_key_y: &FieldElement = witness_to_value(initial_witness, public_key_y.witness)?;
 
-    let signature = to_u8_vec(initial_witness, signature)?;
-
+    let signature = to_u8_array(initial_witness, signature)?;
     let message = to_u8_vec(initial_witness, message)?;
 
     let valid_signature =
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index 81e752d5656..67faf7f5007 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use acir::{
-    brillig::{ForeignCallParam, ForeignCallResult},
+    brillig::{ForeignCallParam, ForeignCallResult, Opcode as BrilligOpcode},
     circuit::{
         brillig::{Brillig, BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
@@ -11,7 +11,7 @@ use acir::{
     FieldElement,
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
-use brillig_vm::{MemoryValue, VMStatus, VM};
+use brillig_vm::{FailureReason, MemoryValue, VMStatus, VM};
 
 use crate::{pwg::OpcodeNotSolvable, OpcodeResolutionError};
 
@@ -46,9 +46,9 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
     /// Assigns the zero value to all outputs of the given [`Brillig`] bytecode.
     pub(super) fn zero_out_brillig_outputs(
         initial_witness: &mut WitnessMap,
-        brillig: &Brillig,
+        outputs: &[BrilligOutputs],
     ) -> Result<(), OpcodeResolutionError> {
-        for output in &brillig.outputs {
+        for output in outputs {
             match output {
                 BrilligOutputs::Simple(witness) => {
                     insert_value(witness, FieldElement::zero(), initial_witness)?;
@@ -63,6 +63,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         Ok(())
     }
 
+    // TODO: Delete this old method once `Brillig` is deleted
     /// Constructs a solver for a Brillig block given the bytecode and initial
     /// witness.
     pub(crate) fn new(
@@ -72,13 +73,45 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         bb_solver: &'b B,
         acir_index: usize,
     ) -> Result<Self, OpcodeResolutionError> {
+        let vm = Self::setup_brillig_vm(
+            initial_witness,
+            memory,
+            &brillig.inputs,
+            &brillig.bytecode,
+            bb_solver,
+        )?;
+        Ok(Self { vm, acir_index })
+    }
+
+    /// Constructs a solver for a Brillig block given the bytecode and initial
+    /// witness.
+    pub(crate) fn new_call(
+        initial_witness: &WitnessMap,
+        memory: &HashMap<BlockId, MemoryOpSolver>,
+        inputs: &'b [BrilligInputs],
+        brillig_bytecode: &'b [BrilligOpcode],
+        bb_solver: &'b B,
+        acir_index: usize,
+    ) -> Result<Self, OpcodeResolutionError> {
+        let vm =
+            Self::setup_brillig_vm(initial_witness, memory, inputs, brillig_bytecode, bb_solver)?;
+        Ok(Self { vm, acir_index })
+    }
+
+    fn setup_brillig_vm(
+        initial_witness: &WitnessMap,
+        memory: &HashMap<BlockId, MemoryOpSolver>,
+        inputs: &[BrilligInputs],
+        brillig_bytecode: &'b [BrilligOpcode],
+        bb_solver: &'b B,
+    ) -> Result<VM<'b, B>, OpcodeResolutionError> {
         // Set input values
         let mut calldata: Vec<FieldElement> = Vec::new();
         // Each input represents an expression or array of expressions to evaluate.
         // Iterate over each input and evaluate the expression(s) associated with it.
         // Push the results into memory.
         // If a certain expression is not solvable, we stall the ACVM and do not proceed with Brillig VM execution.
-        for input in &brillig.inputs {
+        for input in inputs {
             match input {
                 BrilligInputs::Single(expr) => match get_value(expr, initial_witness) {
                     Ok(value) => calldata.push(value),
@@ -118,8 +151,8 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
 
         // Instantiate a Brillig VM given the solved calldata
         // along with the Brillig bytecode.
-        let vm = VM::new(calldata, &brillig.bytecode, vec![], bb_solver);
-        Ok(Self { vm, acir_index })
+        let vm = VM::new(calldata, brillig_bytecode, vec![], bb_solver);
+        Ok(vm)
     }
 
     pub fn get_memory(&self) -> &[MemoryValue] {
@@ -159,7 +192,31 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         match vm_status {
             VMStatus::Finished { .. } => Ok(BrilligSolverStatus::Finished),
             VMStatus::InProgress => Ok(BrilligSolverStatus::InProgress),
-            VMStatus::Failure { message, call_stack } => {
+            VMStatus::Failure { reason, call_stack } => {
+                let message = match reason {
+                    FailureReason::RuntimeError { message } => Some(message),
+                    FailureReason::Trap { revert_data_offset, revert_data_size } => {
+                        // Since noir can only revert with strings currently, we can parse return data as a string
+                        if revert_data_size == 0 {
+                            None
+                        } else {
+                            let memory = self.vm.get_memory();
+                            let bytes = memory
+                                [revert_data_offset..(revert_data_offset + revert_data_size)]
+                                .iter()
+                                .map(|memory_value| {
+                                    memory_value
+                                        .try_into()
+                                        .expect("Assert message character is not a byte")
+                                })
+                                .collect();
+                            Some(
+                                String::from_utf8(bytes)
+                                    .expect("Assert message is not valid UTF-8"),
+                            )
+                        }
+                    }
+                };
                 Err(OpcodeResolutionError::BrilligFunctionFailed {
                     message,
                     call_stack: call_stack
@@ -180,13 +237,13 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
     pub(crate) fn finalize(
         self,
         witness: &mut WitnessMap,
-        brillig: &Brillig,
+        outputs: &[BrilligOutputs],
     ) -> Result<(), OpcodeResolutionError> {
         // Finish the Brillig execution by writing the outputs to the witness map
         let vm_status = self.vm.get_status();
         match vm_status {
             VMStatus::Finished { return_data_offset, return_data_size } => {
-                self.write_brillig_outputs(witness, return_data_offset, return_data_size, brillig)?;
+                self.write_brillig_outputs(witness, return_data_offset, return_data_size, outputs)?;
                 Ok(())
             }
             _ => panic!("Brillig VM has not completed execution"),
@@ -198,12 +255,12 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         witness_map: &mut WitnessMap,
         return_data_offset: usize,
         return_data_size: usize,
-        brillig: &Brillig,
+        outputs: &[BrilligOutputs],
     ) -> Result<(), OpcodeResolutionError> {
         // Write VM execution results into the witness map
         let memory = self.vm.get_memory();
         let mut current_ret_data_idx = return_data_offset;
-        for output in brillig.outputs.iter() {
+        for output in outputs.iter() {
             match output {
                 BrilligOutputs::Simple(witness) => {
                     insert_value(witness, memory[current_ret_data_idx].to_field(), witness_map)?;
@@ -218,6 +275,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
                 }
             }
         }
+
         assert!(
             current_ret_data_idx == return_data_offset + return_data_size,
             "Brillig VM did not write the expected number of return values"
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index 8f16316f318..652e173867a 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use acir::{
     brillig::ForeignCallResult,
-    circuit::{opcodes::BlockId, Opcode, OpcodeLocation},
+    circuit::{brillig::BrilligBytecode, opcodes::BlockId, Opcode, OpcodeLocation},
     native_types::{Expression, Witness, WitnessMap},
     BlackBoxFunc, FieldElement,
 };
@@ -122,8 +122,8 @@ pub enum OpcodeResolutionError {
     IndexOutOfBounds { opcode_location: ErrorLocation, index: u32, array_size: u32 },
     #[error("Failed to solve blackbox function: {0}, reason: {1}")]
     BlackBoxFunctionFailed(BlackBoxFunc, String),
-    #[error("Failed to solve brillig function, reason: {message}")]
-    BrilligFunctionFailed { message: String, call_stack: Vec<OpcodeLocation> },
+    #[error("Failed to solve brillig function{}", .message.as_ref().map(|m| format!(", reason: {}", m)).unwrap_or_default())]
+    BrilligFunctionFailed { message: Option<String>, call_stack: Vec<OpcodeLocation> },
     #[error("Attempted to call `main` with a `Call` opcode")]
     AcirMainCallAttempted { opcode_location: ErrorLocation },
     #[error("{results_size:?} result values were provided for {outputs_size:?} call output witnesses, most likely due to bad ACIR codegen")]
@@ -165,10 +165,18 @@ pub struct ACVM<'a, B: BlackBoxFunctionSolver> {
     /// Represents the outputs of all ACIR calls during an ACVM process
     /// List is appended onto by the caller upon reaching a [ACVMStatus::RequiresAcirCall]
     acir_call_results: Vec<Vec<FieldElement>>,
+
+    // Each unconstrained function referenced in the program
+    unconstrained_functions: &'a [BrilligBytecode],
 }
 
 impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
-    pub fn new(backend: &'a B, opcodes: &'a [Opcode], initial_witness: WitnessMap) -> Self {
+    pub fn new(
+        backend: &'a B,
+        opcodes: &'a [Opcode],
+        initial_witness: WitnessMap,
+        unconstrained_functions: &'a [BrilligBytecode],
+    ) -> Self {
         let status = if opcodes.is_empty() { ACVMStatus::Solved } else { ACVMStatus::InProgress };
         ACVM {
             status,
@@ -181,6 +189,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             brillig_solver: None,
             acir_call_counter: 0,
             acir_call_results: Vec::default(),
+            unconstrained_functions,
         }
     }
 
@@ -324,6 +333,10 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
                 res => res.map(|_| ()),
             },
+            Opcode::BrilligCall { .. } => match self.solve_brillig_call_opcode() {
+                Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
+                res => res.map(|_| ()),
+            },
             Opcode::Call { .. } => match self.solve_call_opcode() {
                 Ok(Some(input_values)) => return self.wait_for_acir_call(input_values),
                 res => res.map(|_| ()),
@@ -378,7 +391,8 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
 
         let witness = &mut self.witness_map;
         if is_predicate_false(witness, &brillig.predicate)? {
-            return BrilligSolver::<B>::zero_out_brillig_outputs(witness, brillig).map(|_| None);
+            return BrilligSolver::<B>::zero_out_brillig_outputs(witness, &brillig.outputs)
+                .map(|_| None);
         }
 
         // If we're resuming execution after resolving a foreign call then
@@ -404,7 +418,51 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             }
             BrilligSolverStatus::Finished => {
                 // Write execution outputs
-                solver.finalize(witness, brillig)?;
+                solver.finalize(witness, &brillig.outputs)?;
+                Ok(None)
+            }
+        }
+    }
+
+    fn solve_brillig_call_opcode(
+        &mut self,
+    ) -> Result<Option<ForeignCallWaitInfo>, OpcodeResolutionError> {
+        let Opcode::BrilligCall { id, inputs, outputs, predicate } =
+            &self.opcodes[self.instruction_pointer]
+        else {
+            unreachable!("Not executing a Brillig opcode");
+        };
+
+        let witness = &mut self.witness_map;
+        if is_predicate_false(witness, predicate)? {
+            return BrilligSolver::<B>::zero_out_brillig_outputs(witness, outputs).map(|_| None);
+        }
+
+        // If we're resuming execution after resolving a foreign call then
+        // there will be a cached `BrilligSolver` to avoid recomputation.
+        let mut solver: BrilligSolver<'_, B> = match self.brillig_solver.take() {
+            Some(solver) => solver,
+            None => BrilligSolver::new_call(
+                witness,
+                &self.block_solvers,
+                inputs,
+                &self.unconstrained_functions[*id as usize].bytecode,
+                self.backend,
+                self.instruction_pointer,
+            )?,
+        };
+        match solver.solve()? {
+            BrilligSolverStatus::ForeignCallWait(foreign_call) => {
+                // Cache the current state of the solver
+                self.brillig_solver = Some(solver);
+                Ok(Some(foreign_call))
+            }
+            BrilligSolverStatus::InProgress => {
+                unreachable!("Brillig solver still in progress")
+            }
+            BrilligSolverStatus::Finished => {
+                // Write execution outputs
+                solver.finalize(witness, outputs)?;
                 Ok(None)
             }
         }
@@ -422,7 +480,8 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         };
 
         if should_skip {
-            let resolution = BrilligSolver::<B>::zero_out_brillig_outputs(witness, brillig);
+            let resolution =
+                BrilligSolver::<B>::zero_out_brillig_outputs(witness, &brillig.outputs);
             return StepResult::Status(self.handle_opcode_resolution(resolution));
         }
 
diff --git a/acvm-repo/acvm/tests/solver.rs b/acvm-repo/acvm/tests/solver.rs
index a708db5b030..f009e2c05b8 100644
--- a/acvm-repo/acvm/tests/solver.rs
+++ b/acvm-repo/acvm/tests/solver.rs
@@ -104,8 +104,9 @@ fn inversion_brillig_oracle_equivalence() {
         (Witness(2), FieldElement::from(3u128)),
     ])
     .into();
-
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments);
+    let unconstrained_functions = vec![];
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
     // use the partial witness generation solver with our acir program
     let solver_status = acvm.solve();
 
@@ -241,8 +242,9 @@ fn double_inversion_brillig_oracle() {
         (Witness(9), FieldElement::from(10u128)),
     ])
     .into();
-
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments);
+    let unconstrained_functions = vec![];
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
 
     // use the partial witness generation solver with our acir program
     let solver_status = acvm.solve();
@@ -370,8 +372,9 @@ fn oracle_dependent_execution() {
 
     let witness_assignments =
         BTreeMap::from([(w_x, FieldElement::from(2u128)), (w_y, FieldElement::from(2u128))]).into();
-
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments);
+    let unconstrained_functions = vec![];
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
 
     // use the partial witness generation solver with our acir program
     let solver_status = acvm.solve();
@@ -474,8 +477,9 @@ fn brillig_oracle_predicate() {
         (Witness(2), FieldElement::from(3u128)),
     ])
     .into();
-
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments);
+    let unconstrained_functions = vec![];
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
     let solver_status = acvm.solve();
     assert_eq!(solver_status, ACVMStatus::Solved, "should be fully solved");
 
@@ -509,7 +513,8 @@ fn unsatisfied_opcode_resolved() {
     values.insert(d, FieldElement::from(2_i128));
 
     let opcodes = vec![Opcode::AssertZero(opcode_a)];
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, values);
+    let unconstrained_functions = vec![];
+    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, values, &unconstrained_functions);
     let solver_status = acvm.solve();
     assert_eq!(
         solver_status,
@@ -549,7 +554,7 @@ fn unsatisfied_opcode_resolved_brillig() {
     let jmp_if_opcode =
         BrilligOpcode::JumpIf { condition: MemoryAddress::from(2), location: location_of_stop };
 
-    let trap_opcode = BrilligOpcode::Trap;
+    let trap_opcode = BrilligOpcode::Trap { revert_data_offset: 0, revert_data_size: 0 };
     let stop_opcode = BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 };
 
     let brillig_opcode = Opcode::Brillig(Brillig {
@@ -591,13 +596,13 @@ fn unsatisfied_opcode_resolved_brillig() {
     values.insert(w_result, FieldElement::from(0_i128));
 
     let opcodes = vec![brillig_opcode, Opcode::AssertZero(opcode_a)];
-
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, values);
+    let unconstrained_functions = vec![];
+    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, values, &unconstrained_functions);
     let solver_status = acvm.solve();
     assert_eq!(
         solver_status,
         ACVMStatus::Failure(OpcodeResolutionError::BrilligFunctionFailed {
-            message: "explicit trap hit in brillig".to_string(),
+            message: None,
             call_stack: vec![OpcodeLocation::Brillig { acir_index: 0, brillig_index: 3 }]
         }),
         "The first opcode is not satisfiable, expected an error indicating this"
@@ -635,8 +640,9 @@ fn memory_operations() {
     });
 
     let opcodes = vec![init, read_op, expression];
-
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, initial_witness);
+    let unconstrained_functions = vec![];
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, initial_witness, &unconstrained_functions);
     let solver_status = acvm.solve();
     assert_eq!(solver_status, ACVMStatus::Solved);
     let witness_map = acvm.finalize();
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index c97b8ea1a66..2fab684467e 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -1,5 +1,6 @@
 use std::{future::Future, pin::Pin};
 
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::BlackBoxFunctionSolver;
 use acvm::{
     acir::circuit::{Circuit, Program},
@@ -181,7 +182,12 @@ async fn execute_program_with_native_program_and_return(
     initial_witness: JsWitnessMap,
     foreign_call_executor: &ForeignCallHandler,
 ) -> Result<WitnessStack, Error> {
-    let executor = ProgramExecutor::new(&program.functions, &solver.0, foreign_call_executor);
+    let executor = ProgramExecutor::new(
+        &program.functions,
+        &program.unconstrained_functions,
+        &solver.0,
+        foreign_call_executor,
+    );
     let witness_stack = executor.execute(initial_witness.into()).await?;
 
     Ok(witness_stack)
@@ -190,6 +196,8 @@ async fn execute_program_with_native_program_and_return(
 struct ProgramExecutor<'a, B: BlackBoxFunctionSolver> {
     functions: &'a [Circuit],
 
+    unconstrained_functions: &'a [BrilligBytecode],
+
     blackbox_solver: &'a B,
 
     foreign_call_handler: &'a ForeignCallHandler,
@@ -198,10 +206,16 @@ struct ProgramExecutor<'a, B: BlackBoxFunctionSolver> {
 impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
     fn new(
         functions: &'a [Circuit],
+        unconstrained_functions: &'a [BrilligBytecode],
         blackbox_solver: &'a B,
         foreign_call_handler: &'a ForeignCallHandler,
     ) -> Self {
-        ProgramExecutor { functions, blackbox_solver, foreign_call_handler }
+        ProgramExecutor {
+            functions,
+            unconstrained_functions,
+            blackbox_solver,
+            foreign_call_handler,
+        }
     }
 
     async fn execute(&self, initial_witness: WitnessMap) -> Result<WitnessStack, Error> {
@@ -220,7 +234,12 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
         witness_stack: &'a mut WitnessStack,
     ) -> Pin<Box<dyn Future<Output = Result<WitnessMap, Error>> + 'a>> {
         Box::pin(async {
-            let mut acvm = ACVM::new(self.blackbox_solver, &circuit.opcodes, initial_witness);
+            let mut acvm = ACVM::new(
+                self.blackbox_solver,
+                &circuit.opcodes,
+                initial_witness,
+                self.unconstrained_functions,
+            );
 
             loop {
                 let solver_status = acvm.solve();
@@ -231,7 +250,7 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                         unreachable!("Execution should not stop while in `InProgress` state.")
                     }
                     ACVMStatus::Failure(error) => {
-                        let (assert_message, call_stack) = match &error {
+                        let (assert_message, call_stack): (Option<&str>, _) = match &error {
                             OpcodeResolutionError::UnsatisfiedConstrain {
                                 opcode_location: ErrorLocation::Resolved(opcode_location),
                             }
@@ -242,12 +261,16 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                                 circuit.get_assert_message(*opcode_location),
                                 Some(vec![*opcode_location]),
                             ),
-                            OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
+                            OpcodeResolutionError::BrilligFunctionFailed {
+                                call_stack,
+                                message,
+                            } => {
+                                let revert_message = message.as_ref().map(String::as_str);
                                 let failing_opcode = call_stack
                                     .last()
                                     .expect("Brillig error call stacks cannot be empty");
                                 (
-                                    circuit.get_assert_message(*failing_opcode),
+                                    revert_message.or(circuit.get_assert_message(*failing_opcode)),
                                     Some(call_stack.clone()),
                                 )
                             }
diff --git a/acvm-repo/acvm_js/test/shared/addition.ts b/acvm-repo/acvm_js/test/shared/addition.ts
index b56a4286878..820a415acf3 100644
--- a/acvm-repo/acvm_js/test/shared/addition.ts
+++ b/acvm-repo/acvm_js/test/shared/addition.ts
@@ -2,11 +2,11 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `addition_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 75, 14, 128, 32, 12, 68, 249, 120, 160, 150, 182, 208, 238, 188, 138, 68,
-  184, 255, 17, 212, 200, 130, 196, 165, 188, 164, 153, 174, 94, 38, 227, 221, 203, 118, 159, 119, 95, 226, 200, 125,
-  36, 252, 3, 253, 66, 87, 152, 92, 4, 153, 185, 149, 212, 144, 240, 128, 100, 85, 5, 88, 106, 86, 84, 20, 149, 51, 41,
-  81, 83, 214, 98, 213, 10, 24, 50, 53, 236, 98, 212, 135, 44, 174, 235, 5, 143, 35, 12, 151, 159, 126, 55, 109, 28,
-  231, 145, 47, 245, 105, 191, 143, 133, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 65, 14, 128, 32, 12, 4, 65, 124, 80, 75, 91, 104, 111, 126, 69, 34, 252,
+  255, 9, 106, 228, 64, 162, 55, 153, 164, 217, 158, 38, 155, 245, 238, 97, 189, 206, 187, 55, 161, 231, 214, 19, 254,
+  129, 126, 162, 107, 25, 92, 4, 137, 185, 230, 88, 145, 112, 135, 104, 69, 5, 88, 74, 82, 84, 20, 149, 35, 42, 81, 85,
+  214, 108, 197, 50, 24, 50, 85, 108, 98, 212, 186, 44, 204, 235, 5, 183, 99, 233, 46, 63, 252, 110, 216, 56, 184, 15,
+  78, 146, 74, 173, 20, 141, 1, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index e074cf1ad38..722bae8e015 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 93, 10, 131, 48, 12, 78, 218, 233, 100, 111, 187, 193, 96, 59, 64, 231, 9,
-  188, 139, 248, 166, 232, 163, 167, 23, 11, 126, 197, 24, 250, 34, 86, 208, 64, 72, 218, 252, 125, 36, 105, 153, 22,
-  42, 60, 51, 116, 235, 217, 64, 103, 156, 37, 5, 191, 10, 210, 29, 163, 63, 167, 203, 229, 206, 194, 104, 110, 128,
-  209, 158, 128, 49, 236, 195, 69, 231, 157, 114, 46, 73, 251, 103, 35, 239, 231, 225, 57, 243, 156, 227, 252, 132, 44,
-  112, 79, 176, 125, 84, 223, 73, 248, 145, 152, 69, 149, 4, 107, 233, 114, 90, 119, 145, 85, 237, 151, 192, 89, 247,
-  221, 208, 54, 163, 85, 174, 26, 234, 87, 232, 63, 101, 103, 21, 55, 169, 216, 73, 72, 249, 5, 197, 234, 132, 123, 179,
-  35, 247, 155, 214, 246, 102, 20, 73, 204, 72, 168, 123, 191, 161, 25, 66, 136, 159, 187, 53, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 218, 209, 145, 217, 205, 13, 6, 198, 3, 84, 79,
+  224, 93, 196, 157, 162, 75, 79, 47, 22, 124, 197, 16, 186, 17, 43, 104, 32, 36, 109, 126, 143, 36, 45, 211, 70, 133,
+  103, 134, 110, 61, 27, 232, 140, 179, 164, 224, 215, 64, 186, 115, 84, 113, 186, 92, 238, 42, 140, 230, 1, 24, 237, 5,
+  24, 195, 62, 220, 116, 222, 41, 231, 146, 180, 127, 54, 242, 126, 94, 158, 51, 207, 57, 206, 111, 200, 2, 247, 4, 219,
+  79, 245, 157, 132, 31, 137, 89, 52, 73, 176, 214, 46, 167, 125, 23, 89, 213, 254, 8, 156, 237, 56, 76, 125, 55, 91,
+  229, 170, 161, 254, 133, 94, 42, 59, 171, 184, 69, 197, 46, 66, 202, 47, 40, 86, 39, 220, 155, 3, 185, 191, 180, 183,
+  55, 163, 72, 98, 70, 66, 221, 251, 40, 173, 255, 35, 68, 62, 61, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
index 5aef521f231..97b5041121a 100644
--- a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
+++ b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
@@ -1,8 +1,8 @@
 // See `fixed_base_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, 29, 61, 43, 3, 5, 121, 34,
-  207, 86, 231, 162, 198, 157, 124, 228, 71, 157, 220, 232, 161, 227, 226, 206, 214, 95, 221, 74, 0, 116, 58, 13, 182,
-  105, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, 29, 61, 35, 3, 19, 228, 137,
+  60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135, 142, 139, 219, 91, 127, 117, 71, 2, 117, 84, 50, 98, 113,
+  0, 0, 0,
 ]);
 export const initialWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index eb14cb2e9f1..0e3d77f62a9 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,10 +2,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 48, 8, 133, 53, 133, 82, 186, 245, 38, 233, 13, 122, 153,
-  14, 93, 58, 132, 144, 227, 135, 252, 41, 56, 36, 46, 201, 7, 162, 168, 200, 123, 34, 52, 142, 28, 72, 245, 38, 106, 9,
-  247, 30, 202, 118, 142, 27, 215, 221, 178, 82, 175, 33, 15, 133, 189, 163, 159, 57, 197, 252, 251, 195, 235, 188, 230,
-  186, 16, 65, 255, 12, 239, 92, 131, 89, 149, 198, 77, 3, 10, 9, 119, 8, 198, 242, 152, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 32, 12, 133, 19, 11, 165, 116, 235, 77, 236, 13, 122, 153,
+  14, 93, 58, 136, 120, 124, 241, 47, 129, 12, 42, 130, 126, 16, 18, 146, 16, 222, 11, 66, 225, 136, 129, 84, 111, 162,
+  150, 112, 239, 161, 172, 231, 184, 113, 221, 45, 45, 245, 42, 242, 144, 216, 43, 250, 153, 83, 204, 191, 223, 189,
+  198, 246, 92, 39, 60, 244, 63, 195, 59, 87, 99, 150, 165, 113, 83, 193, 0, 1, 19, 247, 29, 5, 160, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index 1d0e06b3c8a..a69ae443259 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 201, 13, 0, 32, 8, 147, 195, 125, 112, 3, 247, 159, 74, 141, 60, 106, 226,
-  79, 120, 216, 132, 180, 124, 154, 82, 168, 108, 212, 57, 2, 122, 129, 157, 201, 181, 150, 59, 186, 179, 189, 161, 101,
-  251, 82, 176, 175, 196, 121, 89, 118, 185, 246, 91, 185, 26, 125, 187, 64, 80, 134, 29, 195, 31, 79, 24, 2, 250, 167,
-  252, 27, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 57, 14, 0, 32, 8, 147, 195, 255, 224, 15, 252, 255, 171, 212, 200, 208,
+  129, 77, 24, 108, 66, 90, 150, 166, 20, 106, 23, 125, 143, 128, 62, 96, 103, 114, 173, 45, 198, 116, 182, 55, 140,
+  106, 95, 74, 246, 149, 60, 47, 171, 46, 215, 126, 43, 87, 179, 111, 23, 8, 202, 176, 99, 248, 240, 9, 11, 137, 33,
+  212, 110, 35, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
index 1b745ab6a79..4b73d01bb01 100644
--- a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
+++ b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap, StackItem, WitnessStack } from '@noir-lang/acvm_js';
 
 // See `nested_acir_call_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147, 24, 173, 241, 223, 174, 50,
-  153, 189, 255, 17, 214, 177, 148, 89, 17, 250, 99, 14, 246, 224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105,
-  217, 109, 118, 91, 248, 200, 168, 225, 248, 191, 106, 114, 208, 233, 104, 188, 233, 139, 223, 137, 108, 51, 139, 113,
-  13, 161, 38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42, 65, 82, 46, 57, 97,
-  166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182, 54, 48, 144, 235, 8, 254, 10, 22, 76, 132, 101,
-  231, 237, 229, 23, 189, 213, 54, 119, 15, 83, 212, 199, 172, 175, 79, 113, 51, 48, 198, 253, 207, 84, 13, 204, 141,
-  224, 21, 176, 147, 158, 66, 231, 43, 145, 6, 4, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 65, 10, 3, 33, 12, 69, 163, 46, 230, 58, 137, 209, 49, 238, 122, 149, 74,
+  157, 251, 31, 161, 83, 154, 161, 86, 132, 89, 212, 194, 124, 248, 24, 36, 132, 228, 241, 29, 188, 229, 212, 47, 45,
+  187, 205, 110, 11, 31, 25, 53, 28, 255, 103, 77, 14, 58, 29, 141, 55, 125, 241, 55, 145, 109, 102, 49, 174, 33, 212,
+  228, 43, 49, 221, 209, 231, 34, 17, 67, 44, 171, 144, 80, 148, 248, 240, 194, 92, 37, 72, 202, 37, 39, 204, 20, 184,
+  210, 22, 51, 111, 58, 204, 205, 219, 11, 161, 129, 208, 214, 6, 6, 114, 29, 193, 127, 193, 130, 137, 176, 236, 188,
+  189, 252, 162, 183, 218, 230, 238, 97, 138, 250, 152, 245, 245, 87, 220, 12, 140, 113, 95, 153, 170, 129, 185, 17, 60,
+  3, 54, 212, 19, 104, 145, 195, 151, 14, 4, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/pedersen.ts b/acvm-repo/acvm_js/test/shared/pedersen.ts
index 00d207053d8..e8ddc893d87 100644
--- a/acvm-repo/acvm_js/test/shared/pedersen.ts
+++ b/acvm-repo/acvm_js/test/shared/pedersen.ts
@@ -1,7 +1,7 @@
 // See `pedersen_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 7, 6, 0, 0, 8, 108, 209, 255, 63, 156, 54, 233, 56, 55, 17, 26, 18, 196,
-  241, 169, 250, 178, 141, 167, 32, 159, 254, 234, 238, 255, 87, 112, 52, 63, 63, 101, 105, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 9, 10, 0, 0, 4, 115, 149, 255, 127, 88, 8, 133, 213, 218, 137, 80, 144, 32,
+  182, 79, 213, 151, 173, 61, 5, 121, 245, 91, 103, 255, 191, 3, 7, 16, 26, 112, 158, 113, 0, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([[1, '0x0000000000000000000000000000000000000000000000000000000000000001']]);
diff --git a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
index 14c32c615c8..a207aa12b2c 100644
--- a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
+++ b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
@@ -1,17 +1,17 @@
 // See `schnorr_verify_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 78, 2, 1, 20, 69, 81, 236, 189, 247, 222, 123, 239, 93, 177, 33, 34,
-  238, 194, 253, 47, 193, 200, 147, 67, 194, 36, 147, 163, 33, 33, 228, 191, 219, 82, 168, 63, 63, 181, 183, 197, 223,
-  177, 147, 191, 181, 183, 149, 69, 159, 183, 213, 222, 238, 218, 219, 206, 14, 118, 178, 139, 141, 183, 135, 189, 236,
-  99, 63, 7, 56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60, 23, 184,
-  200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187, 220, 227, 62, 15, 120, 200, 35, 30,
-  243, 132, 167, 60, 227, 57, 47, 120, 201, 43, 94, 243, 134, 183, 188, 227, 61, 31, 248, 200, 39, 22, 249, 204, 151,
-  166, 29, 243, 188, 250, 255, 141, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 123, 171, 76, 127, 105, 47,
-  189, 165, 181, 116, 150, 198, 26, 125, 245, 248, 45, 233, 41, 45, 165, 163, 52, 148, 126, 210, 78, 186, 73, 51, 233,
-  37, 173, 164, 147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33, 45, 164, 131, 52, 144, 253, 151, 11, 245, 221, 179,
-  121, 246, 206, 214, 217, 57, 27, 103, 223, 109, 187, 238, 218, 115, 223, 142, 135, 246, 59, 182, 219, 169, 189, 206,
-  237, 116, 105, 159, 107, 187, 220, 218, 227, 222, 14, 143, 238, 95, 116, 247, 23, 119, 126, 115, 223, 146, 187, 150,
-  221, 179, 226, 142, 141, 155, 53, 238, 86, 104, 186, 231, 255, 243, 7, 100, 141, 232, 192, 233, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 210, 85, 78, 67, 81, 24, 133, 209, 226, 238, 238, 238, 238, 238, 165, 148, 82,
+  102, 193, 252, 135, 64, 232, 78, 87, 147, 114, 147, 147, 5, 47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241,
+  115, 236, 228, 111, 237, 181, 178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 135, 189, 236, 99, 63, 7,
+  56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60, 23, 184, 200, 37, 46,
+  115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187, 220, 227, 62, 15, 120, 200, 35, 30, 243, 132, 167,
+  60, 227, 57, 47, 120, 201, 43, 94, 243, 134, 183, 188, 227, 61, 31, 248, 200, 39, 62, 243, 133, 175, 77, 59, 230, 123,
+  243, 123, 145, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 239, 86, 153, 238, 210, 92, 122, 75, 107, 233,
+  44, 141, 53, 250, 234, 241, 191, 164, 167, 180, 148, 142, 210, 80, 250, 73, 59, 233, 38, 205, 164, 151, 180, 146, 78,
+  210, 72, 250, 72, 27, 233, 34, 77, 164, 135, 180, 144, 14, 210, 64, 246, 95, 46, 212, 119, 207, 230, 217, 59, 91, 103,
+  231, 108, 156, 125, 183, 237, 186, 107, 207, 125, 59, 30, 218, 239, 216, 110, 167, 246, 58, 183, 211, 165, 125, 174,
+  237, 114, 107, 143, 123, 59, 60, 186, 255, 179, 187, 191, 186, 115, 209, 125, 75, 238, 90, 118, 207, 138, 59, 54, 110,
+  214, 184, 91, 161, 233, 158, 255, 190, 63, 165, 188, 93, 151, 233, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index f0ab4561229..fab67467d9a 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -11,7 +11,7 @@ pub trait BlackBoxFunctionSolver {
         &self,
         public_key_x: &FieldElement,
         public_key_y: &FieldElement,
-        signature: &[u8],
+        signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError>;
     fn pedersen_commitment(
@@ -59,7 +59,7 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
         &self,
         _public_key_x: &FieldElement,
         _public_key_y: &FieldElement,
-        _signature: &[u8],
+        _signature: &[u8; 64],
         _message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::SchnorrVerify))
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 6a16043ae33..25b10252a78 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -52,7 +52,7 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
         &self,
         public_key_x: &FieldElement,
         public_key_y: &FieldElement,
-        signature: &[u8],
+        signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError> {
         let pub_key_bytes: Vec<u8> =
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index d1345351986..468fd88db45 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -177,8 +177,11 @@ pub enum BrilligOpcode {
         source: MemoryAddress,
     },
     BlackBox(BlackBoxOp),
-    /// Used to denote execution failure
-    Trap,
+    /// Used to denote execution failure, returning data after the offset
+    Trap {
+        revert_data_offset: usize,
+        revert_data_size: usize,
+    },
     /// Stop execution, returning data after the offset
     Stop {
         return_data_offset: usize,
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 600e9d96b08..19407da52db 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -129,7 +129,8 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             let public_key_x = memory.read(*public_key_x).try_into().unwrap();
             let public_key_y = memory.read(*public_key_y).try_into().unwrap();
             let message: Vec<u8> = to_u8_vec(read_heap_vector(memory, message));
-            let signature: Vec<u8> = to_u8_vec(read_heap_vector(memory, signature));
+            let signature: [u8; 64] =
+                to_u8_vec(read_heap_vector(memory, signature)).try_into().unwrap();
             let verified =
                 solver.schnorr_verify(&public_key_x, &public_key_y, &signature, &message)?;
             memory.write(*result, verified.into());
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index a2380aa4652..75299670f94 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -32,6 +32,12 @@ mod memory;
 /// The error call stack contains the opcode indexes of the call stack at the time of failure, plus the index of the opcode that failed.
 pub type ErrorCallStack = Vec<usize>;
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum FailureReason {
+    Trap { revert_data_offset: usize, revert_data_size: usize },
+    RuntimeError { message: String },
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum VMStatus {
     Finished {
@@ -40,7 +46,7 @@ pub enum VMStatus {
     },
     InProgress,
     Failure {
-        message: String,
+        reason: FailureReason,
         call_stack: ErrorCallStack,
     },
     /// The VM process is not solvable as a [foreign call][Opcode::ForeignCall] has been
@@ -141,13 +147,28 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         self.status(VMStatus::InProgress);
     }
 
+    fn get_error_stack(&self) -> Vec<usize> {
+        let mut error_stack: Vec<_> = self.call_stack.clone();
+        error_stack.push(self.program_counter);
+        error_stack
+    }
+
     /// Sets the current status of the VM to `fail`.
     /// Indicating that the VM encountered a `Trap` Opcode
     /// or an invalid state.
+    fn trap(&mut self, revert_data_offset: usize, revert_data_size: usize) -> VMStatus {
+        self.status(VMStatus::Failure {
+            call_stack: self.get_error_stack(),
+            reason: FailureReason::Trap { revert_data_offset, revert_data_size },
+        });
+        self.status.clone()
+    }
+
     fn fail(&mut self, message: String) -> VMStatus {
-        let mut error_stack: Vec<_> = self.call_stack.clone();
-        error_stack.push(self.program_counter);
-        self.status(VMStatus::Failure { call_stack: error_stack, message });
+        self.status(VMStatus::Failure {
+            call_stack: self.get_error_stack(),
+            reason: FailureReason::RuntimeError { message },
+        });
         self.status.clone()
     }
 
@@ -284,7 +305,9 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 }
                 self.increment_program_counter()
             }
-            Opcode::Trap => self.fail("explicit trap hit in brillig".to_string()),
+            Opcode::Trap { revert_data_offset, revert_data_size } => {
+                self.trap(*revert_data_offset, *revert_data_size)
+            }
             Opcode::Stop { return_data_offset, return_data_size } => {
                 self.finish(*return_data_offset, *return_data_size)
             }
@@ -692,7 +715,7 @@ mod tests {
 
         let jump_opcode = Opcode::Jump { location: 3 };
 
-        let trap_opcode = Opcode::Trap;
+        let trap_opcode = Opcode::Trap { revert_data_offset: 0, revert_data_size: 0 };
 
         let not_equal_cmp_opcode = Opcode::BinaryFieldOp {
             op: BinaryFieldOp::Equals,
@@ -739,7 +762,7 @@ mod tests {
         assert_eq!(
             status,
             VMStatus::Failure {
-                message: "explicit trap hit in brillig".to_string(),
+                reason: FailureReason::Trap { revert_data_offset: 0, revert_data_size: 0 },
                 call_stack: vec![2]
             }
         );
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 48c30ab6ffa..dff3193a327 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -3,6 +3,9 @@ mod utils;
 
 use transforms::{
     compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
+    contract_interface::{
+        generate_contract_interface, stub_function, update_fn_signatures_in_contract_interface,
+    },
     events::{generate_selector_impl, transform_events},
     functions::{export_fn_abi, transform_function, transform_unconstrained},
     note_interface::{generate_note_interface_impl, inject_note_exports},
@@ -59,7 +62,14 @@ fn transform(
     // Usage -> mut ast -> aztec_library::transform(&mut ast)
     // Covers all functions in the ast
     for submodule in ast.submodules.iter_mut().filter(|submodule| submodule.is_contract) {
-        if transform_module(&mut submodule.contents).map_err(|err| (err.into(), file_id))? {
+        if transform_module(
+            crate_id,
+            context,
+            &mut submodule.contents,
+            submodule.name.0.contents.as_str(),
+        )
+        .map_err(|err| (err.into(), file_id))?
+        {
             check_for_aztec_dependency(crate_id, context)?;
         }
     }
@@ -72,7 +82,12 @@ fn transform(
 /// Determines if ast nodes are annotated with aztec attributes.
 /// For annotated functions it calls the `transform` function which will perform the required transformations.
 /// Returns true if an annotated node is found, false otherwise
-fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError> {
+fn transform_module(
+    crate_id: &CrateId,
+    context: &HirContext,
+    module: &mut SortedModule,
+    module_name: &str,
+) -> Result<bool, AztecMacroError> {
     let mut has_transformed_module = false;
 
     // Check for a user defined storage struct
@@ -84,7 +99,12 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
         if !check_for_storage_implementation(module, &storage_struct_name) {
             generate_storage_implementation(module, &storage_struct_name)?;
         }
-        generate_storage_layout(module, storage_struct_name)?;
+        // Make sure we're only generating the storage layout for the root crate
+        // In case we got a contract importing other contracts for their interface, we
+        // don't want to generate the storage layout for them
+        if crate_id == context.root_crate_id() {
+            generate_storage_layout(module, storage_struct_name)?;
+        }
     }
 
     for structure in module.types.iter_mut() {
@@ -102,6 +122,8 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
             .any(|attr| is_custom_attribute(attr, "aztec(initializer)"))
     });
 
+    let mut stubs: Vec<_> = vec![];
+
     for func in module.functions.iter_mut() {
         let mut is_private = false;
         let mut is_public = false;
@@ -129,15 +151,18 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
 
         // Apply transformations to the function based on collected attributes
         if is_private || is_public || is_public_vm {
+            let fn_type = if is_private {
+                "Private"
+            } else if is_public_vm {
+                "Avm"
+            } else {
+                "Public"
+            };
+            stubs.push(stub_function(fn_type, func));
+
             export_fn_abi(&mut module.types, func)?;
             transform_function(
-                if is_private {
-                    "Private"
-                } else if is_public_vm {
-                    "Avm"
-                } else {
-                    "Public"
-                },
+                fn_type,
                 func,
                 storage_defined,
                 is_initializer,
@@ -171,6 +196,8 @@ fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError>
                 span: Span::default(),
             });
         }
+
+        generate_contract_interface(module, module_name, &stubs)?;
     }
 
     Ok(has_transformed_module)
@@ -189,7 +216,8 @@ fn transform_hir(
         transform_events(crate_id, context)?;
         inject_compute_note_hash_and_nullifier(crate_id, context)?;
         assign_storage_slots(crate_id, context)?;
-        inject_note_exports(crate_id, context)
+        inject_note_exports(crate_id, context)?;
+        update_fn_signatures_in_contract_interface(crate_id, context)
     } else {
         Ok(())
     }
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index 1b6630935d9..4ff97a5dcae 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -49,20 +49,20 @@ pub fn inject_compute_note_hash_and_nullifier(
     crate_id: &CrateId,
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
-    if let Some((module_id, file_id)) = get_contract_module_data(context, crate_id) {
+    if let Some((_, module_id, file_id)) = get_contract_module_data(context, crate_id) {
         // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
         // escape hatch for this mechanism.
         // TODO(#4647): improve this diagnosis and error messaging.
-        if check_for_compute_note_hash_and_nullifier_definition(crate_id, context) {
+        if context.crate_graph.root_crate_id() != crate_id
+            || check_for_compute_note_hash_and_nullifier_definition(crate_id, context)
+        {
             return Ok(());
         }
 
         // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
         // contract might use. These are the types that are marked as #[aztec(note)].
-        let note_types = fetch_notes(context)
-            .iter()
-            .map(|(_, note)| note.borrow().name.0.contents.clone())
-            .collect::<Vec<_>>();
+        let note_types =
+            fetch_notes(context).iter().map(|(path, _)| path.to_string()).collect::<Vec<_>>();
 
         // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
         let func = generate_compute_note_hash_and_nullifier(&note_types);
@@ -73,7 +73,14 @@ pub fn inject_compute_note_hash_and_nullifier(
         // pass an empty span. This function should not produce errors anyway so this should not matter.
         let location = Location::new(Span::empty(0), file_id);
 
-        inject_fn(crate_id, context, func, location, module_id, file_id);
+        inject_fn(crate_id, context, func, location, module_id, file_id).map_err(|err| {
+            (
+                AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                    secondary_message: err.secondary_message,
+                },
+                file_id,
+            )
+        })?;
     }
     Ok(())
 }
@@ -100,7 +107,7 @@ fn generate_compute_note_hash_and_nullifier_source(note_types: &[String]) -> Str
         // so we include a dummy version.
         "
         unconstrained fn compute_note_hash_and_nullifier(
-            contract_address: AztecAddress,
+            contract_address: dep::aztec::protocol_types::address::AztecAddress,
             nonce: Field,
             storage_slot: Field,
             note_type_id: Field,
@@ -130,7 +137,7 @@ fn generate_compute_note_hash_and_nullifier_source(note_types: &[String]) -> Str
         format!(
             "
             unconstrained fn compute_note_hash_and_nullifier(
-                contract_address: AztecAddress,
+                contract_address: dep::aztec::protocol_types::address::AztecAddress,
                 nonce: Field,
                 storage_slot: Field,
                 note_type_id: Field,
diff --git a/aztec_macros/src/transforms/contract_interface.rs b/aztec_macros/src/transforms/contract_interface.rs
new file mode 100644
index 00000000000..4401c867df9
--- /dev/null
+++ b/aztec_macros/src/transforms/contract_interface.rs
@@ -0,0 +1,326 @@
+use noirc_frontend::{
+    graph::CrateId,
+    macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
+    parse_program,
+    parser::SortedModule,
+    NoirFunction, Type, UnresolvedTypeData,
+};
+
+use crate::utils::{
+    constants::SELECTOR_PLACEHOLDER,
+    errors::AztecMacroError,
+    hir_utils::{collect_crate_structs, get_contract_module_data, signature_of_type},
+};
+
+// Generates the stubs for contract functions as low level calls using <visibility>CallInterface, turning
+//  #[aztec(public)] // also private
+//  fn a_function(first_arg: Field, second_arg: Struct, third_arg: [Field; 4]) -> Field {
+//      ...
+//  }
+//
+// into
+//
+// pub fn a_function(self, first_arg: Field, second_arg: Struct, third_arg: [Field; 4]) -> PublicCallInterface {
+//   let mut args_acc: [Field] = &[];
+//   args_acc = args_acc.append(first_arg.serialize().as_slice());
+//   args_acc = args_acc.append(second_arg.serialize().as_slice());
+//   let hash_third_arg = third_arg.map(|x: Field| x.serialize());
+//   for i in 0..third_arg.len() {
+//     args_acc = args_acc.append(third_arg[i].serialize().as_slice());
+//   }
+//   let args_hash = dep::aztec::hash::hash_args(args_acc);
+//   assert(args_hash == dep::aztec::oracle::arguments::pack_arguments(args_acc));
+//   PublicCallInterface {
+//     target_contract: self.target_contract,
+//     selector: FunctionSelector::from_signature("SELECTOR_PLACEHOLDER"),
+//     args_hash
+//   }
+// }
+//
+// The selector placeholder has to be replaced with the actual function signature after type checking in the next macro pass
+pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
+    let fn_name = func.name().to_string();
+    let fn_parameters = func
+        .parameters()
+        .iter()
+        .map(|param| {
+            format!(
+                "{}: {}",
+                param.pattern.name_ident().0.contents,
+                param.typ.to_string().replace("plain::", "")
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(", ");
+    let fn_return_type: noirc_frontend::UnresolvedType = func.return_type();
+
+    let fn_selector = format!("dep::aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature(\"{}\")", SELECTOR_PLACEHOLDER);
+
+    let parameters = func.parameters();
+    let is_void = if matches!(fn_return_type.typ, UnresolvedTypeData::Unit) { "Void" } else { "" };
+    let return_type_hint = if is_void == "Void" {
+        "".to_string()
+    } else {
+        format!("<{}>", fn_return_type.typ.to_string().replace("plain::", ""))
+    };
+    let call_args = parameters
+        .iter()
+        .map(|arg| {
+            let param_name = arg.pattern.name_ident().0.contents.clone();
+            match &arg.typ.typ {
+                UnresolvedTypeData::Array(_, typ) => {
+                    format!(
+                        "let hash_{0} = {0}.map(|x: {1}| x.serialize());
+                for i in 0..{0}.len() {{
+                    args_acc = args_acc.append(hash_{0}[i].as_slice());
+                }}\n",
+                        param_name, typ.typ
+                    )
+                }
+                _ => {
+                    format!("args_acc = args_acc.append({}.serialize().as_slice());\n", param_name)
+                }
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("");
+    if aztec_visibility != "Avm" {
+        let args_hash = if !parameters.is_empty() {
+            format!(
+                "let mut args_acc: [Field] = &[];
+                {}
+                let args_hash = dep::aztec::hash::hash_args(args_acc);
+                assert(args_hash == dep::aztec::oracle::arguments::pack_arguments(args_acc));",
+                call_args
+            )
+        } else {
+            "let args_hash = 0;".to_string()
+        };
+
+        let fn_body = format!(
+            "{}
+                dep::aztec::context::{}{}CallInterface {{
+                    target_contract: self.target_contract,
+                    selector: {},
+                    args_hash,
+                }}",
+            args_hash, aztec_visibility, is_void, fn_selector,
+        );
+        format!(
+            "pub fn {}(self, {}) -> dep::aztec::context::{}{}CallInterface{} {{
+                    {}
+                }}",
+            fn_name, fn_parameters, aztec_visibility, is_void, return_type_hint, fn_body
+        )
+    } else {
+        let args = format!(
+            "let mut args_acc: [Field] = &[];
+            {}
+            ",
+            call_args
+        );
+        let fn_body = format!(
+            "{}
+            dep::aztec::context::Avm{}CallInterface {{
+                target_contract: self.target_contract,
+                selector: {},
+                args: args_acc,
+            }}",
+            args, is_void, fn_selector,
+        );
+        format!(
+            "pub fn {}(self, {}) -> dep::aztec::context::Avm{}CallInterface{} {{
+                    {}
+            }}",
+            fn_name, fn_parameters, is_void, return_type_hint, fn_body
+        )
+    }
+}
+
+// Generates the contract interface as a struct with an `at` function that holds the stubbed functions and provides
+// them with a target contract address. The struct has the same name as the contract (which is technically a module)
+// so imports look nice. The `at` function is also exposed as a contract library method for external use.
+pub fn generate_contract_interface(
+    module: &mut SortedModule,
+    module_name: &str,
+    stubs: &[String],
+) -> Result<(), AztecMacroError> {
+    let contract_interface = format!(
+        "
+        struct {0} {{
+            target_contract: dep::aztec::protocol_types::address::AztecAddress
+        }}
+
+        impl {0} {{
+            {1}
+
+            pub fn at(
+                target_contract: dep::aztec::protocol_types::address::AztecAddress
+            ) -> Self {{
+                Self {{ target_contract }}
+            }}
+        }}
+
+        #[contract_library_method]
+        pub fn at(
+            target_contract: dep::aztec::protocol_types::address::AztecAddress
+        ) -> {0} {{
+            {0} {{ target_contract }}
+        }}
+    ",
+        module_name,
+        stubs.join("\n"),
+    );
+
+    let (contract_interface_ast, errors) = parse_program(&contract_interface);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotGenerateContractInterface { secondary_message: Some("Failed to parse Noir macro code during contract interface generation. This is either a bug in the compiler or the Noir macro code".to_string()), });
+    }
+
+    let mut contract_interface_ast = contract_interface_ast.into_sorted();
+    module.types.push(contract_interface_ast.types.pop().unwrap());
+    module.impls.push(contract_interface_ast.impls.pop().unwrap());
+    module.functions.push(contract_interface_ast.functions.pop().unwrap());
+
+    Ok(())
+}
+
+fn compute_fn_signature(fn_name: &str, parameters: &[Type]) -> String {
+    format!(
+        "{}({})",
+        fn_name,
+        parameters.iter().map(signature_of_type).collect::<Vec<_>>().join(",")
+    )
+}
+
+// Updates the function signatures in the contract interface with the actual ones, replacing the placeholder.
+// This is done by locating the contract interface struct, its functions (stubs) and assuming the last statement of each
+// is the constructor for a <visibility>CallInterface. This constructor has a selector field that holds a
+// FunctionSelector::from_signature function that receives the signature as a string literal.
+pub fn update_fn_signatures_in_contract_interface(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+) -> Result<(), (AztecMacroError, FileId)> {
+    if let Some((name, _, file_id)) = get_contract_module_data(context, crate_id) {
+        let maybe_interface_struct =
+            collect_crate_structs(crate_id, context).iter().find_map(|struct_id| {
+                let r#struct = context.def_interner.get_struct(*struct_id);
+                if r#struct.borrow().name.0.contents == name {
+                    Some(r#struct)
+                } else {
+                    None
+                }
+            });
+
+        if let Some(interface_struct) = maybe_interface_struct {
+            let methods = context.def_interner.get_struct_methods(interface_struct.borrow().id);
+
+            for func_id in methods.iter().flat_map(|methods| methods.direct.iter()) {
+                let name = context.def_interner.function_name(func_id);
+                let fn_parameters = &context.def_interner.function_meta(func_id).parameters.clone();
+
+                if name == "at" {
+                    continue;
+                }
+
+                let fn_signature = compute_fn_signature(
+                    name,
+                    &fn_parameters
+                        .iter()
+                        .skip(1)
+                        .map(|(_, typ, _)| typ.clone())
+                        .collect::<Vec<Type>>(),
+                );
+                let hir_func = context.def_interner.function(func_id).block(&context.def_interner);
+                let call_interface_constructor_statement = context.def_interner.statement(
+                    hir_func
+                        .statements()
+                        .last()
+                        .ok_or((AztecMacroError::AztecDepNotFound, file_id))?,
+                );
+                let call_interface_constructor_expression =
+                    match call_interface_constructor_statement {
+                        HirStatement::Expression(expression_id) => {
+                            match context.def_interner.expression(&expression_id) {
+                        HirExpression::Constructor(hir_constructor_expression) => {
+                            Ok(hir_constructor_expression)
+                        }
+                        _ => Err((
+                            AztecMacroError::CouldNotGenerateContractInterface {
+                                secondary_message: Some(
+                                    "CallInterface constructor statement must be a constructor expression"
+                                        .to_string(),
+                                ),
+                            },
+                            file_id,
+                        )),
+                    }
+                        }
+                        _ => Err((
+                            AztecMacroError::CouldNotGenerateContractInterface {
+                                secondary_message: Some(
+                                    "CallInterface constructor statement must be an expression"
+                                        .to_string(),
+                                ),
+                            },
+                            file_id,
+                        )),
+                    }?;
+                let (_, function_selector_expression_id) =
+                    call_interface_constructor_expression.fields[1];
+                let function_selector_expression =
+                    context.def_interner.expression(&function_selector_expression_id);
+
+                let current_fn_signature_expression_id = match function_selector_expression {
+                    HirExpression::Call(call_expr) => Ok(call_expr.arguments[0]),
+                    _ => Err((
+                        AztecMacroError::CouldNotGenerateContractInterface {
+                            secondary_message: Some(
+                                "Function selector argument expression must be call expression"
+                                    .to_string(),
+                            ),
+                        },
+                        file_id,
+                    )),
+                }?;
+
+                let current_fn_signature_expression =
+                    context.def_interner.expression(&current_fn_signature_expression_id);
+
+                match current_fn_signature_expression {
+                    HirExpression::Literal(HirLiteral::Str(signature)) => {
+                        if signature != SELECTOR_PLACEHOLDER {
+                            Err((
+                                AztecMacroError::CouldNotGenerateContractInterface {
+                                    secondary_message: Some(format!(
+                                        "Function signature argument must be a placeholder: {}",
+                                        SELECTOR_PLACEHOLDER
+                                    )),
+                                },
+                                file_id,
+                            ))
+                        } else {
+                            Ok(())
+                        }
+                    }
+                    _ => Err((
+                        AztecMacroError::CouldNotAssignStorageSlots {
+                            secondary_message: Some(
+                                "Function signature argument must be a literal string".to_string(),
+                            ),
+                        },
+                        file_id,
+                    )),
+                }?;
+
+                context
+                    .def_interner
+                    .update_expression(current_fn_signature_expression_id, |expr| {
+                        *expr = HirExpression::Literal(HirLiteral::Str(fn_signature))
+                    });
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
index 4f2b70453df..b77a5821b81 100644
--- a/aztec_macros/src/transforms/events.rs
+++ b/aztec_macros/src/transforms/events.rs
@@ -174,7 +174,7 @@ pub fn transform_events(
     crate_id: &CrateId,
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
-    for (_, struct_id) in collect_crate_structs(crate_id, context) {
+    for struct_id in collect_crate_structs(crate_id, context) {
         let attributes = context.def_interner.struct_attributes(&struct_id);
         if attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(event)")) {
             transform_event(struct_id, &mut context.def_interner)?;
diff --git a/aztec_macros/src/transforms/mod.rs b/aztec_macros/src/transforms/mod.rs
index 5a454c75148..2a6fef7647f 100644
--- a/aztec_macros/src/transforms/mod.rs
+++ b/aztec_macros/src/transforms/mod.rs
@@ -1,4 +1,5 @@
 pub mod compute_note_hash_and_nullifier;
+pub mod contract_interface;
 pub mod events;
 pub mod functions;
 pub mod note_interface;
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index 0514155824e..4b72759a5db 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -528,12 +528,12 @@ fn generate_note_properties_fn_source(
         .join(", ");
     format!(
         "
-        pub fn properties() -> {}Properties {{
-            {}Properties {{
-                {}
+        pub fn properties() -> {0}Properties {{
+            {0}Properties {{
+                {1}
             }}
         }}",
-        note_type, note_type, note_property_selectors
+        note_type, note_property_selectors
     )
     .to_string()
 }
@@ -623,7 +623,7 @@ pub fn inject_note_exports(
     crate_id: &CrateId,
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
-    if let Some((module_id, file_id)) = get_contract_module_data(context, crate_id) {
+    if let Some((_, module_id, file_id)) = get_contract_module_data(context, crate_id) {
         let notes = fetch_notes(context);
 
         for (_, note) in notes {
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 0bfb39cbc71..9135be32443 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -265,13 +265,13 @@ pub fn assign_storage_slots(
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
     let traits: Vec<_> = collect_traits(context);
-    if let Some((_, file_id)) = get_contract_module_data(context, crate_id) {
+    if let Some((_, _, file_id)) = get_contract_module_data(context, crate_id) {
         let maybe_storage_struct =
-            collect_crate_structs(crate_id, context).iter().find_map(|&(_, struct_id)| {
-                let r#struct = context.def_interner.get_struct(struct_id);
-                let attributes = context.def_interner.struct_attributes(&struct_id);
+            collect_crate_structs(crate_id, context).iter().find_map(|struct_id| {
+                let r#struct = context.def_interner.get_struct(*struct_id);
+                let attributes = context.def_interner.struct_attributes(struct_id);
                 if attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(storage)"))
-                    && r#struct.borrow().id.krate().is_root()
+                    && r#struct.borrow().id.krate() == *crate_id
                 {
                     Some(r#struct)
                 } else {
@@ -290,7 +290,11 @@ pub fn assign_storage_slots(
                     let expr = context.def_interner.expression(&statement.unwrap().expression);
                     match expr {
                         HirExpression::Constructor(hir_constructor_expression) => {
-                            Some(hir_constructor_expression)
+                            if hir_constructor_expression.r#type.borrow().id.krate() == *crate_id {
+                                Some(hir_constructor_expression)
+                            } else {
+                                None
+                            }
                         }
                         _ => None,
                     }
diff --git a/aztec_macros/src/utils/constants.rs b/aztec_macros/src/utils/constants.rs
index 464cd10e2c7..848cca0477d 100644
--- a/aztec_macros/src/utils/constants.rs
+++ b/aztec_macros/src/utils/constants.rs
@@ -1,3 +1,4 @@
 pub const FUNCTION_TREE_HEIGHT: u32 = 5;
 pub const MAX_CONTRACT_PRIVATE_FUNCTIONS: usize = 2_usize.pow(FUNCTION_TREE_HEIGHT);
 pub const SIGNATURE_PLACEHOLDER: &str = "SIGNATURE_PLACEHOLDER";
+pub const SELECTOR_PLACEHOLDER: &str = "SELECTOR_PLACEHOLDER";
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 52ee5587559..4c5411dfe0f 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -11,10 +11,12 @@ pub enum AztecMacroError {
     UnsupportedFunctionReturnType { span: Span, typ: UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
+    CouldNotImplementComputeNoteHashAndNullifier { secondary_message: Option<String> },
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
     MultipleStorageDefinitions { span: Option<Span> },
     CouldNotExportStorageLayout { span: Option<Span>, secondary_message: Option<String> },
     CouldNotExportFunctionAbi { span: Option<Span>, secondary_message: Option<String> },
+    CouldNotGenerateContractInterface { secondary_message: Option<String> },
     EventError { span: Span, message: String },
     UnsupportedAttributes { span: Span, secondary_message: Option<String> },
 }
@@ -52,6 +54,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span: None,
             },
+            AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier { secondary_message } => MacroError {
+                primary_message: "Could not implement compute_note_hash_and_nullifier automatically, please provide an implementation".to_string(),
+                secondary_message,
+                span: None,
+            },
             AztecMacroError::CouldNotImplementNoteInterface { span, secondary_message } => MacroError {
                 primary_message: "Could not implement automatic methods for note, please provide an implementation of the NoteInterface trait".to_string(),
                 secondary_message,
@@ -72,6 +79,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span,
             },
+            AztecMacroError::CouldNotGenerateContractInterface { secondary_message } => MacroError {
+                primary_message: "Could not generate contract interface".to_string(),
+                secondary_message,
+                span: None
+            },
             AztecMacroError::EventError { span, message } => MacroError {
                 primary_message: message,
                 secondary_message: None,
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index c4414e6419b..ae895d2075c 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -7,43 +7,32 @@ use noirc_frontend::{
         resolution::{path_resolver::StandardPathResolver, resolver::Resolver},
         type_check::type_check_func,
     },
-    macros_api::{FileId, HirContext, ModuleDefId, StructId},
+    macros_api::{FileId, HirContext, MacroError, ModuleDefId, StructId},
     node_interner::{FuncId, TraitId},
     ItemVisibility, LetStatement, NoirFunction, Shared, Signedness, StructType, Type,
 };
 
 use super::ast_utils::is_custom_attribute;
 
-pub fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<(String, StructId)> {
+pub fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<StructId> {
     context
         .def_map(crate_id)
-        .expect("ICE: Missing crate in def_map")
-        .modules()
-        .iter()
-        .flat_map(|(_, module)| {
-            module.type_definitions().filter_map(move |typ| {
-                if let ModuleDefId::TypeId(struct_id) = typ {
-                    let module_id = struct_id.module_id();
-                    let path =
-                        context.fully_qualified_struct_path(context.root_crate_id(), struct_id);
-                    let path = if path.contains("::") {
-                        let prefix = if &module_id.krate == context.root_crate_id() {
-                            "crate"
+        .map(|def_map| {
+            def_map
+                .modules()
+                .iter()
+                .flat_map(|(_, module)| {
+                    module.type_definitions().filter_map(move |typ| {
+                        if let ModuleDefId::TypeId(struct_id) = typ {
+                            Some(struct_id)
                         } else {
-                            "dep"
-                        };
-                        format!("{}::{}", prefix, path)
-                    } else {
-                        path
-                    };
-
-                    Some((path, struct_id))
-                } else {
-                    None
-                }
-            })
+                            None
+                        }
+                    })
+                })
+                .collect()
         })
-        .collect()
+        .unwrap_or_default()
 }
 
 pub fn collect_crate_functions(crate_id: &CrateId, context: &HirContext) -> Vec<FuncId> {
@@ -96,22 +85,48 @@ pub fn signature_of_type(typ: &Type) -> String {
             let fields = vecmap(types, signature_of_type);
             format!("({})", fields.join(","))
         }
+        Type::String(len_typ) => {
+            if let Type::Constant(len) = **len_typ {
+                format!("str<{len}>")
+            } else {
+                unimplemented!(
+                    "Cannot generate signature for string with length type {:?}",
+                    len_typ
+                )
+            }
+        }
+        Type::MutableReference(typ) => signature_of_type(typ),
         _ => unimplemented!("Cannot generate signature for type {:?}", typ),
     }
 }
 
-// Fetches the name of all structs tagged as #[aztec(note)] in a given crate
+// Fetches the name of all structs tagged as #[aztec(note)] in a given crate, avoiding
+// contract dependencies that are just there for their interfaces.
 pub fn fetch_crate_notes(
     context: &HirContext,
     crate_id: &CrateId,
 ) -> Vec<(String, Shared<StructType>)> {
     collect_crate_structs(crate_id, context)
         .iter()
-        .filter_map(|(path, struct_id)| {
+        .filter_map(|struct_id| {
             let r#struct = context.def_interner.get_struct(*struct_id);
             let attributes = context.def_interner.struct_attributes(struct_id);
             if attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(note)")) {
-                Some((path.clone(), r#struct))
+                let module_id = struct_id.module_id();
+
+                fully_qualified_note_path(context, *struct_id).map(|path| {
+                    let path = if path.contains("::") {
+                        let prefix = if &module_id.krate == context.root_crate_id() {
+                            "crate"
+                        } else {
+                            "dep"
+                        };
+                        format!("{}::{}", prefix, path)
+                    } else {
+                        path
+                    };
+                    (path.clone(), r#struct)
+                })
             } else {
                 None
             }
@@ -127,23 +142,24 @@ pub fn fetch_notes(context: &HirContext) -> Vec<(String, Shared<StructType>)> {
 pub fn get_contract_module_data(
     context: &mut HirContext,
     crate_id: &CrateId,
-) -> Option<(LocalModuleId, FileId)> {
+) -> Option<(String, LocalModuleId, FileId)> {
+    let def_map = context.def_map(crate_id).expect("ICE: Missing crate in def_map");
     // We first fetch modules in this crate which correspond to contracts, along with their file id.
-    let contract_module_file_ids: Vec<(LocalModuleId, FileId)> = context
-        .def_map(crate_id)
-        .expect("ICE: Missing crate in def_map")
+    let contract_module_file_ids: Vec<(String, LocalModuleId, FileId)> = def_map
         .modules()
         .iter()
         .filter(|(_, module)| module.is_contract)
-        .map(|(idx, module)| (LocalModuleId(idx), module.location.file))
+        .map(|(idx, module)| {
+            (def_map.get_module_path(idx, module.parent), LocalModuleId(idx), module.location.file)
+        })
         .collect();
 
-    // If the current crate does not contain a contract module we simply skip it. More than 1 contract in a crate is forbidden by the compiler
+    // If the current crate does not contain a contract module we simply skip it.
     if contract_module_file_ids.is_empty() {
         return None;
     }
 
-    Some(contract_module_file_ids[0])
+    Some(contract_module_file_ids[0].clone())
 }
 
 pub fn inject_fn(
@@ -153,7 +169,7 @@ pub fn inject_fn(
     location: Location,
     module_id: LocalModuleId,
     file_id: FileId,
-) {
+) -> Result<(), MacroError> {
     let func_id = context.def_interner.push_empty_fn();
     context.def_interner.push_function(
         func_id,
@@ -164,12 +180,11 @@ pub fn inject_fn(
 
     context.def_map_mut(crate_id).unwrap().modules_mut()[module_id.0]
         .declare_function(func.name_ident().clone(), ItemVisibility::Public, func_id)
-        .unwrap_or_else(|_| {
-            panic!(
-                "Failed to declare autogenerated {} function, likely due to a duplicate definition",
-                func.name()
-            )
-        });
+        .map_err(|err| MacroError {
+            primary_message: format!("Failed to declare autogenerated {} function", func.name()),
+            secondary_message: Some(format!("Duplicate definition found {}", err.0)),
+            span: None,
+        })?;
 
     let def_maps = &mut context.def_maps;
 
@@ -183,7 +198,17 @@ pub fn inject_fn(
     context.def_interner.push_fn_meta(meta, func_id);
     context.def_interner.update_fn(func_id, hir_func);
 
-    type_check_func(&mut context.def_interner, func_id);
+    let errors = type_check_func(&mut context.def_interner, func_id);
+
+    if !errors.is_empty() {
+        return Err(MacroError {
+            primary_message: "Failed to type check autogenerated function".to_owned(),
+            secondary_message: Some(errors.iter().map(|err| err.to_string()).collect::<String>()),
+            span: None,
+        });
+    }
+
+    Ok(())
 }
 
 pub fn inject_global(
@@ -224,3 +249,63 @@ pub fn inject_global(
     let statement_id = context.def_interner.get_global(global_id).let_statement;
     context.def_interner.replace_statement(statement_id, hir_stmt);
 }
+
+pub fn fully_qualified_note_path(context: &HirContext, note_id: StructId) -> Option<String> {
+    let module_id = note_id.module_id();
+    let child_id = module_id.local_id.0;
+    let def_map =
+        context.def_map(&module_id.krate).expect("The local crate should be analyzed already");
+
+    let module = context.module(module_id);
+
+    let module_path = def_map.get_module_path_with_separator(child_id, module.parent, "::");
+
+    if &module_id.krate == context.root_crate_id() {
+        Some(module_path)
+    } else {
+        find_non_contract_dependencies_bfs(context, context.root_crate_id(), &module_id.krate)
+            .map(|crates| crates.join("::") + "::" + &module_path)
+    }
+}
+
+fn filter_contract_modules(context: &HirContext, crate_id: &CrateId) -> bool {
+    if let Some(def_map) = context.def_map(crate_id) {
+        !def_map.modules().iter().any(|(_, module)| module.is_contract)
+    } else {
+        true
+    }
+}
+
+fn find_non_contract_dependencies_bfs(
+    context: &HirContext,
+    crate_id: &CrateId,
+    target_crate_id: &CrateId,
+) -> Option<Vec<String>> {
+    context.crate_graph[crate_id]
+        .dependencies
+        .iter()
+        .filter(|dep| filter_contract_modules(context, &dep.crate_id))
+        .find_map(|dep| {
+            if &dep.crate_id == target_crate_id {
+                Some(vec![dep.name.to_string()])
+            } else {
+                None
+            }
+        })
+        .or_else(|| {
+            context.crate_graph[crate_id]
+                .dependencies
+                .iter()
+                .filter(|dep| filter_contract_modules(context, &dep.crate_id))
+                .find_map(|dep| {
+                    if let Some(mut path) =
+                        find_non_contract_dependencies_bfs(context, &dep.crate_id, target_crate_id)
+                    {
+                        path.insert(0, dep.name.to_string());
+                        Some(path)
+                    } else {
+                        None
+                    }
+                })
+        })
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 1f86d66fd4e..ee047903743 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -436,7 +436,7 @@ fn prepare_bigint_output(
         condition_adr,
         BrilligBinaryOp::Equals,
     );
-    brillig_context.constrain_instruction(
+    brillig_context.codegen_constrain(
         condition_adr,
         Some("moduli should be identical in BigInt operation".to_string()),
     );
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index cf2501ab1c0..22407fc5695 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -5,7 +5,7 @@ use crate::brillig::brillig_ir::{
     BrilligBinaryOp, BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 use crate::ssa::ir::dfg::CallStack;
-use crate::ssa::ir::instruction::ConstrainError;
+use crate::ssa::ir::instruction::{ConstrainError, UserDefinedConstrainError};
 use crate::ssa::ir::{
     basic_block::{BasicBlock, BasicBlockId},
     dfg::DataFlowGraph,
@@ -248,10 +248,15 @@ impl<'block> BrilligBlock<'block> {
                 self.convert_ssa_binary(binary, dfg, result_var);
             }
             Instruction::Constrain(lhs, rhs, assert_message) => {
-                let assert_message = if let Some(error) = assert_message {
+                let (has_revert_data, static_assert_message) = if let Some(error) = assert_message {
                     match error.as_ref() {
-                        ConstrainError::Static(string) => Some(string.clone()),
-                        ConstrainError::Dynamic(call_instruction) => {
+                        ConstrainError::Intrinsic(string) => (false, Some(string.clone())),
+                        ConstrainError::UserDefined(UserDefinedConstrainError::Static(string)) => {
+                            (true, Some(string.clone()))
+                        }
+                        ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
+                            call_instruction,
+                        )) => {
                             let Instruction::Call { func, arguments } = call_instruction else {
                                 unreachable!("expected a call instruction")
                             };
@@ -264,11 +269,11 @@ impl<'block> BrilligBlock<'block> {
 
                             // Dynamic assert messages are handled in the generated function call.
                             // We then don't need to attach one to the constrain instruction.
-                            None
+                            (false, None)
                         }
                     }
                 } else {
-                    None
+                    (false, None)
                 };
 
                 let condition = SingleAddrVariable {
@@ -281,8 +286,12 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                     condition,
                 );
-
-                self.brillig_context.constrain_instruction(condition, assert_message);
+                if has_revert_data {
+                    self.brillig_context
+                        .codegen_constrain_with_revert_data(condition, static_assert_message);
+                } else {
+                    self.brillig_context.codegen_constrain(condition, static_assert_message);
+                }
                 self.brillig_context.deallocate_single_addr(condition);
             }
             Instruction::Allocate => {
@@ -670,7 +679,7 @@ impl<'block> BrilligBlock<'block> {
                         BrilligBinaryOp::LessThanEquals,
                     );
 
-                    self.brillig_context.constrain_instruction(condition, assert_message.clone());
+                    self.brillig_context.codegen_constrain(condition, assert_message.clone());
                     self.brillig_context.deallocate_single_addr(condition);
                     self.brillig_context.deallocate_single_addr(left);
                     self.brillig_context.deallocate_single_addr(right);
@@ -802,7 +811,7 @@ impl<'block> BrilligBlock<'block> {
         );
 
         self.brillig_context
-            .constrain_instruction(condition, Some("Array index out of bounds".to_owned()));
+            .codegen_constrain(condition, Some("Array index out of bounds".to_owned()));
 
         if should_deallocate_size {
             self.brillig_context.deallocate_single_addr(size_as_register);
@@ -1503,10 +1512,8 @@ impl<'block> BrilligBlock<'block> {
                     condition,
                     BrilligBinaryOp::LessThanEquals,
                 );
-                self.brillig_context.constrain_instruction(
-                    condition,
-                    Some("attempt to add with overflow".to_string()),
-                );
+                self.brillig_context
+                    .codegen_constrain(condition, Some("attempt to add with overflow".to_string()));
                 self.brillig_context.deallocate_single_addr(condition);
             }
             (BrilligBinaryOp::Sub, false) => {
@@ -1519,7 +1526,7 @@ impl<'block> BrilligBlock<'block> {
                     condition,
                     BrilligBinaryOp::LessThanEquals,
                 );
-                self.brillig_context.constrain_instruction(
+                self.brillig_context.codegen_constrain(
                     condition,
                     Some("attempt to subtract with overflow".to_string()),
                 );
@@ -1549,7 +1556,7 @@ impl<'block> BrilligBlock<'block> {
                             BrilligBinaryOp::UnsignedDiv,
                         );
                         ctx.binary_instruction(division, left, condition, BrilligBinaryOp::Equals);
-                        ctx.constrain_instruction(
+                        ctx.codegen_constrain(
                             condition,
                             Some("attempt to multiply with overflow".to_string()),
                         );
@@ -1778,7 +1785,7 @@ pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type
         (Type::Numeric(lhs_type), Type::Numeric(rhs_type)) => {
             assert_eq!(
                 lhs_type, rhs_type,
-                "lhs and rhs types in a binary operation are always the same"
+                "lhs and rhs types in a binary operation are always the same but got {lhs_type} and {rhs_type}"
             );
             Type::Numeric(*lhs_type)
         }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 4132089b36f..7e37e1da434 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -148,7 +148,7 @@ pub(crate) mod tests {
             &self,
             _public_key_x: &FieldElement,
             _public_key_y: &FieldElement,
-            _signature: &[u8],
+            _signature: &[u8; 64],
             _message: &[u8],
         ) -> Result<bool, BlackBoxResolutionError> {
             Ok(true)
@@ -270,7 +270,7 @@ pub(crate) mod tests {
         // uses unresolved jumps which requires a block to be constructed in SSA and
         // we don't need this for Brillig IR tests
         context.push_opcode(BrilligOpcode::JumpIf { condition: r_equality, location: 8 });
-        context.push_opcode(BrilligOpcode::Trap);
+        context.push_opcode(BrilligOpcode::Trap { revert_data_offset: 0, revert_data_size: 0 });
 
         context.stop_instruction();
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index 8ce15ba4e73..8a4f469f5c9 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, HashMap};
 use crate::ssa::ir::dfg::CallStack;
 
 /// Represents a parameter or a return value of an entry point function.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
 pub(crate) enum BrilligParameter {
     /// A single address parameter or return value. Holds the bit size of the parameter.
     SingleAddr(u32),
@@ -17,7 +17,7 @@ pub(crate) enum BrilligParameter {
 
 /// The result of compiling and linking brillig artifacts.
 /// This is ready to run bytecode with attached metadata.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(crate) struct GeneratedBrillig {
     pub(crate) byte_code: Vec<BrilligOpcode>,
     pub(crate) locations: BTreeMap<OpcodeLocation, CallStack>,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index 116eaa5103f..f8f39f03df4 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -138,4 +138,48 @@ impl BrilligContext {
 
         self.enter_section(end_section);
     }
+
+    /// Emits brillig bytecode to jump to a trap condition if `condition`
+    /// is false. The trap will include the given message as revert data.
+    pub(crate) fn codegen_constrain_with_revert_data(
+        &mut self,
+        condition: SingleAddrVariable,
+        assert_message: Option<String>,
+    ) {
+        assert!(condition.bit_size == 1);
+
+        self.codegen_if_not(condition.address, |ctx| {
+            let (revert_data_offset, revert_data_size) =
+                if let Some(assert_message) = assert_message {
+                    let bytes = assert_message.as_bytes();
+                    for (i, byte) in bytes.iter().enumerate() {
+                        ctx.const_instruction(
+                            SingleAddrVariable::new(MemoryAddress(i), 8),
+                            (*byte as usize).into(),
+                        );
+                    }
+                    (0, bytes.len())
+                } else {
+                    (0, 0)
+                };
+            ctx.trap_instruction(revert_data_offset, revert_data_size);
+        });
+    }
+
+    /// Emits brillig bytecode to jump to a trap condition if `condition`
+    /// is false.
+    pub(crate) fn codegen_constrain(
+        &mut self,
+        condition: SingleAddrVariable,
+        assert_message: Option<String>,
+    ) {
+        assert!(condition.bit_size == 1);
+
+        self.codegen_if_not(condition.address, |ctx| {
+            ctx.trap_instruction(0, 0);
+            if let Some(assert_message) = assert_message {
+                ctx.obj.add_assert_message_to_last_opcode(assert_message);
+            }
+        });
+    }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 4ca1144b6a4..41a6d1873e4 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -113,10 +113,14 @@ impl DebugShow {
         DebugShow { enable_debug_trace }
     }
 
-    /// Emits brillig bytecode to jump to a trap condition if `condition`
-    /// is false.
-    pub(crate) fn constrain_instruction(&self, condition: MemoryAddress) {
-        debug_println!(self.enable_debug_trace, "  ASSERT {} != 0", condition);
+    /// Emits a `trap` instruction.
+    pub(crate) fn trap_instruction(&self, revert_data_offset: usize, revert_data_size: usize) {
+        debug_println!(
+            self.enable_debug_trace,
+            "  TRAP {}..{}",
+            revert_data_offset,
+            revert_data_offset + revert_data_size
+        );
     }
 
     /// Emits a `mov` instruction.
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index f305eb81b01..901ccc58036 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -215,29 +215,6 @@ impl BrilligContext {
         );
     }
 
-    /// Emits brillig bytecode to jump to a trap condition if `condition`
-    /// is false.
-    pub(crate) fn constrain_instruction(
-        &mut self,
-        condition: SingleAddrVariable,
-        assert_message: Option<String>,
-    ) {
-        self.debug_show.constrain_instruction(condition.address);
-
-        assert!(condition.bit_size == 1);
-
-        let (next_section, next_label) = self.reserve_next_section_label();
-        self.add_unresolved_jump(
-            BrilligOpcode::JumpIf { condition: condition.address, location: 0 },
-            next_label,
-        );
-        self.push_opcode(BrilligOpcode::Trap);
-        if let Some(assert_message) = assert_message {
-            self.obj.add_assert_message_to_last_opcode(assert_message);
-        }
-        self.enter_section(next_section);
-    }
-
     /// Adds a unresolved `Jump` to the bytecode.
     fn add_unresolved_jump(
         &mut self,
@@ -488,6 +465,12 @@ impl BrilligContext {
             offset,
         });
     }
+
+    pub(super) fn trap_instruction(&mut self, revert_data_offset: usize, revert_data_size: usize) {
+        self.debug_show.trap_instruction(revert_data_offset, revert_data_size);
+
+        self.push_opcode(BrilligOpcode::Trap { revert_data_offset, revert_data_size });
+    }
 }
 
 /// Type to encapsulate the binary operation types in Brillig
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index ce4a9bbe9f1..760340f1a88 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -14,7 +14,9 @@ use crate::{
     errors::{RuntimeError, SsaReport},
 };
 use acvm::acir::{
-    circuit::{Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs},
+    circuit::{
+        brillig::BrilligBytecode, Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs,
+    },
     native_types::Witness,
 };
 
@@ -35,14 +37,16 @@ pub mod ssa_gen;
 
 /// Optimize the given program by converting it into SSA
 /// form and performing optimizations there. When finished,
-/// convert the final SSA into ACIR and return it.
+/// convert the final SSA into an ACIR program and return it.
+/// An ACIR program is made up of both ACIR functions
+/// and Brillig functions for unconstrained execution.
 pub(crate) fn optimize_into_acir(
     program: Program,
     print_passes: bool,
     print_brillig_trace: bool,
     force_brillig_output: bool,
     print_timings: bool,
-) -> Result<Vec<GeneratedAcir>, RuntimeError> {
+) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
     let abi_distinctness = program.return_distinctness;
 
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
@@ -99,6 +103,18 @@ pub struct SsaProgramArtifact {
 }
 
 impl SsaProgramArtifact {
+    fn new(unconstrained_functions: Vec<BrilligBytecode>) -> Self {
+        let program = AcirProgram { functions: Vec::default(), unconstrained_functions };
+        Self {
+            program,
+            debug: Vec::default(),
+            warnings: Vec::default(),
+            main_input_witnesses: Vec::default(),
+            main_return_witnesses: Vec::default(),
+            names: Vec::default(),
+        }
+    }
+
     fn add_circuit(&mut self, mut circuit_artifact: SsaCircuitArtifact, is_main: bool) {
         self.program.functions.push(circuit_artifact.circuit);
         self.debug.push(circuit_artifact.debug_info);
@@ -130,7 +146,7 @@ pub fn create_program(
     let func_sigs = program.function_signatures.clone();
 
     let recursive = program.recursive;
-    let generated_acirs = optimize_into_acir(
+    let (generated_acirs, generated_brillig) = optimize_into_acir(
         program,
         enable_ssa_logging,
         enable_brillig_logging,
@@ -143,7 +159,7 @@ pub fn create_program(
         "The generated ACIRs should match the supplied function signatures"
     );
 
-    let mut program_artifact = SsaProgramArtifact::default();
+    let mut program_artifact = SsaProgramArtifact::new(generated_brillig);
     // For setting up the ABI we need separately specify main's input and return witnesses
     let mut is_main = true;
     for (acir, func_sig) in generated_acirs.into_iter().zip(func_sigs) {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index e49d1427fce..b94e02e5119 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1464,6 +1464,7 @@ impl AcirContext {
         id
     }
 
+    // TODO: Delete this method once we remove the `Brillig` opcode
     pub(crate) fn brillig(
         &mut self,
         predicate: AcirVar,
@@ -1554,6 +1555,105 @@ impl AcirContext {
         Ok(outputs_var)
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn brillig_call(
+        &mut self,
+        predicate: AcirVar,
+        generated_brillig: &GeneratedBrillig,
+        inputs: Vec<AcirValue>,
+        outputs: Vec<AcirType>,
+        attempt_execution: bool,
+        unsafe_return_values: bool,
+        brillig_function_index: u32,
+    ) -> Result<Vec<AcirValue>, RuntimeError> {
+        let brillig_inputs = try_vecmap(inputs, |i| -> Result<_, InternalError> {
+            match i {
+                AcirValue::Var(var, _) => Ok(BrilligInputs::Single(self.var_to_expression(var)?)),
+                AcirValue::Array(vars) => {
+                    let mut var_expressions: Vec<Expression> = Vec::new();
+                    for var in vars {
+                        self.brillig_array_input(&mut var_expressions, var)?;
+                    }
+                    Ok(BrilligInputs::Array(var_expressions))
+                }
+                AcirValue::DynamicArray(AcirDynamicArray { block_id, .. }) => {
+                    Ok(BrilligInputs::MemoryArray(block_id))
+                }
+            }
+        })?;
+
+        // Optimistically try executing the brillig now, if we can complete execution they just return the results.
+        // This is a temporary measure pending SSA optimizations being applied to Brillig which would remove constant-input opcodes (See #2066)
+        //
+        // We do _not_ want to do this in the situation where the `main` function is unconstrained, as if execution succeeds
+        // the entire program will be replaced with witness constraints to its outputs.
+        if attempt_execution {
+            if let Some(brillig_outputs) =
+                self.execute_brillig(&generated_brillig.byte_code, &brillig_inputs, &outputs)
+            {
+                return Ok(brillig_outputs);
+            }
+        }
+
+        // Otherwise we must generate ACIR for it and execute at runtime.
+        let mut brillig_outputs = Vec::new();
+        let outputs_var = vecmap(outputs, |output| match output {
+            AcirType::NumericType(_) => {
+                let witness_index = self.acir_ir.next_witness_index();
+                brillig_outputs.push(BrilligOutputs::Simple(witness_index));
+                let var = self.add_data(AcirVarData::Witness(witness_index));
+                AcirValue::Var(var, output.clone())
+            }
+            AcirType::Array(element_types, size) => {
+                let (acir_value, witnesses) = self.brillig_array_output(&element_types, size);
+                brillig_outputs.push(BrilligOutputs::Array(witnesses));
+                acir_value
+            }
+        });
+        let predicate = self.var_to_expression(predicate)?;
+
+        self.acir_ir.brillig_call(
+            Some(predicate),
+            generated_brillig,
+            brillig_inputs,
+            brillig_outputs,
+            brillig_function_index,
+        );
+
+        fn range_constraint_value(
+            context: &mut AcirContext,
+            value: &AcirValue,
+        ) -> Result<(), RuntimeError> {
+            match value {
+                AcirValue::Var(var, typ) => {
+                    let numeric_type = match typ {
+                        AcirType::NumericType(numeric_type) => numeric_type,
+                        _ => unreachable!("`AcirValue::Var` may only hold primitive values"),
+                    };
+                    context.range_constrain_var(*var, numeric_type, None)?;
+                }
+                AcirValue::Array(values) => {
+                    for value in values {
+                        range_constraint_value(context, value)?;
+                    }
+                }
+                AcirValue::DynamicArray(_) => {
+                    unreachable!("Brillig opcodes cannot return dynamic arrays")
+                }
+            }
+            Ok(())
+        }
+
+        // This is a hack to ensure that if we're compiling a brillig entrypoint function then
+        // we don't also add a number of range constraints.
+        if !unsafe_return_values {
+            for output_var in &outputs_var {
+                range_constraint_value(self, output_var)?;
+            }
+        }
+        Ok(outputs_var)
+    }
+
     fn brillig_array_input(
         &mut self,
         var_expressions: &mut Vec<Expression>,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index ba4e03bff95..999ff2ddb5d 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -167,17 +167,27 @@ impl GeneratedAcir {
                 BlackBoxFuncCall::XOR { lhs: inputs[0][0], rhs: inputs[1][0], output: outputs[0] }
             }
             BlackBoxFunc::RANGE => BlackBoxFuncCall::RANGE { input: inputs[0][0] },
-            BlackBoxFunc::SHA256 => BlackBoxFuncCall::SHA256 { inputs: inputs[0].clone(), outputs },
-            BlackBoxFunc::Blake2s => {
-                BlackBoxFuncCall::Blake2s { inputs: inputs[0].clone(), outputs }
-            }
-            BlackBoxFunc::Blake3 => BlackBoxFuncCall::Blake3 { inputs: inputs[0].clone(), outputs },
+            BlackBoxFunc::SHA256 => BlackBoxFuncCall::SHA256 {
+                inputs: inputs[0].clone(),
+                outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
+            },
+            BlackBoxFunc::Blake2s => BlackBoxFuncCall::Blake2s {
+                inputs: inputs[0].clone(),
+                outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
+            },
+            BlackBoxFunc::Blake3 => BlackBoxFuncCall::Blake3 {
+                inputs: inputs[0].clone(),
+                outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
+            },
             BlackBoxFunc::SchnorrVerify => {
                 BlackBoxFuncCall::SchnorrVerify {
                     public_key_x: inputs[0][0],
                     public_key_y: inputs[1][0],
                     // Schnorr signature is an r & s, 32 bytes each
-                    signature: inputs[2].clone(),
+                    signature: inputs[2]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
                     message: inputs[3].clone(),
                     output: outputs[0],
                 }
@@ -195,24 +205,48 @@ impl GeneratedAcir {
             BlackBoxFunc::EcdsaSecp256k1 => {
                 BlackBoxFuncCall::EcdsaSecp256k1 {
                     // 32 bytes for each public key co-ordinate
-                    public_key_x: inputs[0].clone(),
-                    public_key_y: inputs[1].clone(),
+                    public_key_x: inputs[0]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
+                    public_key_y: inputs[1]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
                     // (r,s) are both 32 bytes each, so signature
                     // takes up 64 bytes
-                    signature: inputs[2].clone(),
-                    hashed_message: inputs[3].clone(),
+                    signature: inputs[2]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
+                    hashed_message: inputs[3]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
                     output: outputs[0],
                 }
             }
             BlackBoxFunc::EcdsaSecp256r1 => {
                 BlackBoxFuncCall::EcdsaSecp256r1 {
                     // 32 bytes for each public key co-ordinate
-                    public_key_x: inputs[0].clone(),
-                    public_key_y: inputs[1].clone(),
+                    public_key_x: inputs[0]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
+                    public_key_y: inputs[1]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
                     // (r,s) are both 32 bytes each, so signature
                     // takes up 64 bytes
-                    signature: inputs[2].clone(),
-                    hashed_message: inputs[3].clone(),
+                    signature: inputs[2]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
+                    hashed_message: inputs[3]
+                        .clone()
+                        .try_into()
+                        .expect("Compiler should generate correct size inputs"),
                     output: outputs[0],
                 }
             }
@@ -240,11 +274,21 @@ impl GeneratedAcir {
                     }
                 };
 
-                BlackBoxFuncCall::Keccak256 { inputs: inputs[0].clone(), var_message_size, outputs }
-            }
-            BlackBoxFunc::Keccakf1600 => {
-                BlackBoxFuncCall::Keccakf1600 { inputs: inputs[0].clone(), outputs }
+                BlackBoxFuncCall::Keccak256 {
+                    inputs: inputs[0].clone(),
+                    var_message_size,
+                    outputs: outputs
+                        .try_into()
+                        .expect("Compiler should generate correct size outputs"),
+                }
             }
+            BlackBoxFunc::Keccakf1600 => BlackBoxFuncCall::Keccakf1600 {
+                inputs: inputs[0]
+                    .clone()
+                    .try_into()
+                    .expect("Compiler should generate correct size inputs"),
+                outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
+            },
             BlackBoxFunc::RecursiveAggregation => BlackBoxFuncCall::RecursiveAggregation {
                 verification_key: inputs[0].clone(),
                 proof: inputs[1].clone(),
@@ -286,9 +330,15 @@ impl GeneratedAcir {
                 len: constant_inputs[0].to_u128() as u32,
             },
             BlackBoxFunc::Sha256Compression => BlackBoxFuncCall::Sha256Compression {
-                inputs: inputs[0].clone(),
-                hash_values: inputs[1].clone(),
-                outputs,
+                inputs: inputs[0]
+                    .clone()
+                    .try_into()
+                    .expect("Compiler should generate correct size inputs"),
+                hash_values: inputs[1]
+                    .clone()
+                    .try_into()
+                    .expect("Compiler should generate correct size inputs"),
+                outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
             },
         };
 
@@ -539,6 +589,7 @@ impl GeneratedAcir {
         Ok(())
     }
 
+    // TODO: Delete this method once we remove the `Brillig` opcode
     pub(crate) fn brillig(
         &mut self,
         predicate: Option<Expression>,
@@ -567,6 +618,37 @@ impl GeneratedAcir {
         }
     }
 
+    pub(crate) fn brillig_call(
+        &mut self,
+        predicate: Option<Expression>,
+        generated_brillig: &GeneratedBrillig,
+        inputs: Vec<BrilligInputs>,
+        outputs: Vec<BrilligOutputs>,
+        brillig_function_index: u32,
+    ) {
+        let opcode =
+            AcirOpcode::BrilligCall { id: brillig_function_index, inputs, outputs, predicate };
+        self.push_opcode(opcode);
+        for (brillig_index, call_stack) in generated_brillig.locations.iter() {
+            self.locations.insert(
+                OpcodeLocation::Brillig {
+                    acir_index: self.opcodes.len() - 1,
+                    brillig_index: *brillig_index,
+                },
+                call_stack.clone(),
+            );
+        }
+        for (brillig_index, message) in generated_brillig.assert_messages.iter() {
+            self.assert_messages.insert(
+                OpcodeLocation::Brillig {
+                    acir_index: self.opcodes.len() - 1,
+                    brillig_index: *brillig_index,
+                },
+                message.clone(),
+            );
+        }
+    }
+
     pub(crate) fn last_acir_opcode_location(&self) -> OpcodeLocation {
         OpcodeLocation::Acir(self.opcodes.len() - 1)
     }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 9f2cec5c949..02b381d79fc 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1,13 +1,14 @@
 //! This file holds the pass to convert from Noir's SSA IR to ACIR.
 mod acir_ir;
 
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::fmt::Debug;
 
 use self::acir_ir::acir_variable::{AcirContext, AcirType, AcirVar};
 use super::function_builder::data_bus::DataBus;
 use super::ir::dfg::CallStack;
-use super::ir::instruction::ConstrainError;
+use super::ir::function::FunctionId;
+use super::ir::instruction::{ConstrainError, UserDefinedConstrainError};
 use super::{
     ir::{
         dfg::DataFlowGraph,
@@ -28,6 +29,7 @@ use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
 use crate::ssa::ir::function::InlineType;
 pub(crate) use acir_ir::generated_acir::GeneratedAcir;
 
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::native_types::Witness;
 use acvm::acir::BlackBoxFunc;
 use acvm::{
@@ -39,9 +41,54 @@ use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_frontend::Distinctness;
 
+#[derive(Default)]
+struct SharedContext {
+    /// Final list of Brillig functions which will be part of the final program
+    /// This is shared across `Context` structs as we want one list of Brillig
+    /// functions across all ACIR artifacts
+    generated_brillig: Vec<GeneratedBrillig>,
+
+    /// Maps SSA function index -> Final generated Brillig artifact index.
+    /// There can be Brillig functions specified in SSA which do not act as
+    /// entry points in ACIR (e.g. only called by other Brillig functions)
+    /// This mapping is necessary to use the correct function pointer for a Brillig call.
+    /// This uses the brillig parameters in the map since using slices with different lengths
+    /// needs to create different brillig entrypoints
+    brillig_generated_func_pointers: BTreeMap<(FunctionId, Vec<BrilligParameter>), u32>,
+}
+
+impl SharedContext {
+    fn generated_brillig_pointer(
+        &self,
+        func_id: FunctionId,
+        arguments: Vec<BrilligParameter>,
+    ) -> Option<&u32> {
+        self.brillig_generated_func_pointers.get(&(func_id, arguments))
+    }
+
+    fn generated_brillig(&self, func_pointer: usize) -> &GeneratedBrillig {
+        &self.generated_brillig[func_pointer]
+    }
+
+    fn insert_generated_brillig(
+        &mut self,
+        func_id: FunctionId,
+        arguments: Vec<BrilligParameter>,
+        generated_pointer: u32,
+        code: GeneratedBrillig,
+    ) {
+        self.brillig_generated_func_pointers.insert((func_id, arguments), generated_pointer);
+        self.generated_brillig.push(code);
+    }
+
+    fn new_generated_pointer(&self) -> u32 {
+        self.generated_brillig.len() as u32
+    }
+}
+
 /// Context struct for the acir generation pass.
 /// May be similar to the Evaluator struct in the current SSA IR.
-struct Context {
+struct Context<'a> {
     /// Maps SSA values to `AcirVar`.
     ///
     /// This is needed so that we only create a single
@@ -91,6 +138,9 @@ struct Context {
     max_block_id: u32,
 
     data_bus: DataBus,
+
+    /// Contains state that is generated and also used across ACIR functions
+    shared_context: &'a mut SharedContext,
 }
 
 #[derive(Clone)]
@@ -181,11 +231,12 @@ impl Ssa {
         self,
         brillig: &Brillig,
         abi_distinctness: Distinctness,
-    ) -> Result<Vec<GeneratedAcir>, RuntimeError> {
+    ) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
         let mut acirs = Vec::new();
         // TODO: can we parallelise this?
+        let mut shared_context = SharedContext::default();
         for function in self.functions.values() {
-            let context = Context::new();
+            let context = Context::new(&mut shared_context);
             if let Some(mut generated_acir) =
                 context.convert_ssa_function(&self, function, brillig)?
             {
@@ -194,6 +245,10 @@ impl Ssa {
             }
         }
 
+        let brillig = vecmap(shared_context.generated_brillig, |brillig| BrilligBytecode {
+            bytecode: brillig.byte_code,
+        });
+
         // TODO: check whether doing this for a single circuit's return witnesses is correct.
         // We probably need it for all foldable circuits, as any circuit being folded is essentially an entry point. However, I do not know how that
         // plays a part when we potentially want not inlined functions normally as part of the compiler.
@@ -215,15 +270,15 @@ impl Ssa {
                     .collect();
 
                 main_func_acir.return_witnesses = distinct_return_witness;
-                Ok(acirs)
             }
-            Distinctness::DuplicationAllowed => Ok(acirs),
+            Distinctness::DuplicationAllowed => {}
         }
+        Ok((acirs, brillig))
     }
 }
 
-impl Context {
-    fn new() -> Context {
+impl<'a> Context<'a> {
+    fn new(shared_context: &'a mut SharedContext) -> Context<'a> {
         let mut acir_context = AcirContext::default();
         let current_side_effects_enabled_var = acir_context.add_constant(FieldElement::one());
 
@@ -237,6 +292,7 @@ impl Context {
             internal_mem_block_lengths: HashMap::default(),
             max_block_id: 0,
             data_bus: DataBus::default(),
+            shared_context,
         }
     }
 
@@ -307,18 +363,22 @@ impl Context {
         let outputs: Vec<AcirType> =
             vecmap(main_func.returns(), |result_id| dfg.type_of_value(*result_id).into());
 
-        let code = self.gen_brillig_for(main_func, arguments, brillig)?;
+        let code = self.gen_brillig_for(main_func, arguments.clone(), brillig)?;
 
         // We specifically do not attempt execution of the brillig code being generated as this can result in it being
         // replaced with constraints on witnesses to the program outputs.
-        let output_values = self.acir_context.brillig(
+        let output_values = self.acir_context.brillig_call(
             self.current_side_effects_enabled_var,
-            code,
+            &code,
             inputs,
             outputs,
             false,
             true,
+            // We are guaranteed to have a Brillig function pointer of `0` as main itself is marked as unconstrained
+            0,
         )?;
+        self.shared_context.insert_generated_brillig(main_func.id(), arguments, 0, code);
+
         let output_vars: Vec<_> = output_values
             .iter()
             .flat_map(|value| value.clone().flatten())
@@ -472,8 +532,13 @@ impl Context {
 
                 let assert_message = if let Some(error) = assert_message {
                     match error.as_ref() {
-                        ConstrainError::Static(string) => Some(string.clone()),
-                        ConstrainError::Dynamic(call_instruction) => {
+                        ConstrainError::Intrinsic(string)
+                        | ConstrainError::UserDefined(UserDefinedConstrainError::Static(string)) => {
+                            Some(string.clone())
+                        }
+                        ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
+                            call_instruction,
+                        )) => {
                             self.convert_ssa_call(call_instruction, dfg, ssa, brillig, &[])?;
                             None
                         }
@@ -571,12 +636,12 @@ impl Context {
                                         sum + dfg.try_get_array_length(*result_id).unwrap_or(1)
                                     });
 
-                                let acir_program_id = ssa
-                                    .id_to_index
+                                let acir_function_id = ssa
+                                    .entry_point_to_generated_index
                                     .get(id)
                                     .expect("ICE: should have an associated final index");
                                 let output_vars = self.acir_context.call_acir_function(
-                                    *acir_program_id,
+                                    *acir_function_id,
                                     inputs,
                                     output_count,
                                     self.current_side_effects_enabled_var,
@@ -598,24 +663,53 @@ impl Context {
                                         );
                                     }
                                 }
-
                                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
                                 let arguments = self.gen_brillig_parameters(arguments, dfg);
 
-                                let code = self.gen_brillig_for(func, arguments, brillig)?;
-
                                 let outputs: Vec<AcirType> = vecmap(result_ids, |result_id| {
                                     dfg.type_of_value(*result_id).into()
                                 });
 
-                                let output_values = self.acir_context.brillig(
-                                    self.current_side_effects_enabled_var,
-                                    code,
-                                    inputs,
-                                    outputs,
-                                    true,
-                                    false,
-                                )?;
+                                // Check whether we have already generated Brillig for this function
+                                // If we have, re-use the generated code to set-up the Brillig call.
+                                let output_values = if let Some(generated_pointer) = self
+                                    .shared_context
+                                    .generated_brillig_pointer(*id, arguments.clone())
+                                {
+                                    let code = self
+                                        .shared_context
+                                        .generated_brillig(*generated_pointer as usize);
+                                    self.acir_context.brillig_call(
+                                        self.current_side_effects_enabled_var,
+                                        code,
+                                        inputs,
+                                        outputs,
+                                        true,
+                                        false,
+                                        *generated_pointer,
+                                    )?
+                                } else {
+                                    let code =
+                                        self.gen_brillig_for(func, arguments.clone(), brillig)?;
+                                    let generated_pointer =
+                                        self.shared_context.new_generated_pointer();
+                                    let output_values = self.acir_context.brillig_call(
+                                        self.current_side_effects_enabled_var,
+                                        &code,
+                                        inputs,
+                                        outputs,
+                                        true,
+                                        false,
+                                        generated_pointer,
+                                    )?;
+                                    self.shared_context.insert_generated_brillig(
+                                        *id,
+                                        arguments,
+                                        generated_pointer,
+                                        code,
+                                    );
+                                    output_values
+                                };
 
                                 // Compiler sanity check
                                 assert_eq!(result_ids.len(), output_values.len(), "ICE: The number of Brillig output values should match the result ids in SSA");
@@ -2442,19 +2536,27 @@ mod test {
         },
     };
 
-    fn build_basic_foo_with_return(builder: &mut FunctionBuilder, foo_id: FunctionId) {
-        // acir(fold) fn foo f1 {
+    fn build_basic_foo_with_return(
+        builder: &mut FunctionBuilder,
+        foo_id: FunctionId,
+        is_brillig_func: bool,
+    ) {
+        // fn foo f1 {
         // b0(v0: Field, v1: Field):
         //     v2 = eq v0, v1
         //     constrain v2 == u1 0
         //     return v0
         // }
-        builder.new_function("foo".into(), foo_id, InlineType::Fold);
+        if is_brillig_func {
+            builder.new_brillig_function("foo".into(), foo_id);
+        } else {
+            builder.new_function("foo".into(), foo_id, InlineType::Fold);
+        }
         let foo_v0 = builder.add_parameter(Type::field());
         let foo_v1 = builder.add_parameter(Type::field());
 
         let foo_equality_check = builder.insert_binary(foo_v0, BinaryOp::Eq, foo_v1);
-        let zero = builder.field_constant(0u128);
+        let zero = builder.numeric_constant(0u128, Type::unsigned(1));
         builder.insert_constrain(foo_equality_check, zero, None);
         builder.terminate_with_return(vec![foo_v0]);
     }
@@ -2488,11 +2590,11 @@ mod test {
         builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id);
+        build_basic_foo_with_return(&mut builder, foo_id, false);
 
         let ssa = builder.finish();
 
-        let acir_functions = ssa
+        let (acir_functions, _) = ssa
             .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
         // Expected result:
@@ -2584,11 +2686,11 @@ mod test {
         builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id);
+        build_basic_foo_with_return(&mut builder, foo_id, false);
 
         let ssa = builder.finish();
 
-        let acir_functions = ssa
+        let (acir_functions, _) = ssa
             .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
         // The expected result should look very similar to the abvoe test expect that the input witnesses of the `Call`
@@ -2675,11 +2777,11 @@ mod test {
             .to_vec();
         builder.terminate_with_return(vec![foo_call[0]]);
 
-        build_basic_foo_with_return(&mut builder, foo_id);
+        build_basic_foo_with_return(&mut builder, foo_id, false);
 
         let ssa = builder.finish();
 
-        let acir_functions = ssa
+        let (acir_functions, _) = ssa
             .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
 
@@ -2739,4 +2841,82 @@ mod test {
             _ => panic!("Expected only Call opcode"),
         }
     }
+
+    // Test that given multiple calls to the same brillig function we generate only one bytecode
+    // and the appropriate Brillig call opcodes are generated
+    #[test]
+    fn multiple_brillig_calls_one_bytecode() {
+        // acir(inline) fn main f0 {
+        //     b0(v0: Field, v1: Field):
+        //       v3 = call f1(v0, v1)
+        //       v4 = call f1(v0, v1)
+        //       v5 = call f1(v0, v1)
+        //       v6 = call f1(v0, v1)
+        //       return
+        // }
+        // brillig fn foo f1 {
+        // b0(v0: Field, v1: Field):
+        //     v2 = eq v0, v1
+        //     constrain v2 == u1 0
+        //     return v0
+        // }
+        // brillig fn foo f2 {
+        //     b0(v0: Field, v1: Field):
+        //       v2 = eq v0, v1
+        //       constrain v2 == u1 0
+        //       return v0
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::field());
+        let main_v1 = builder.add_parameter(Type::field());
+
+        let foo_id = Id::test_new(1);
+        let foo = builder.import_function(foo_id);
+        let bar_id = Id::test_new(2);
+        let bar = builder.import_function(bar_id);
+
+        // Insert multiple calls to the same Brillig function
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        // Interleave a call to a separate Brillig function to make sure that we can call multiple separate Brillig functions
+        builder.insert_call(bar, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(bar, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.terminate_with_return(vec![]);
+
+        build_basic_foo_with_return(&mut builder, foo_id, true);
+        build_basic_foo_with_return(&mut builder, bar_id, true);
+
+        let ssa = builder.finish();
+        let brillig = ssa.to_brillig(false);
+        println!("{}", ssa);
+
+        let (acir_functions, brillig_functions) = ssa
+            .into_acir(&brillig, noirc_frontend::Distinctness::Distinct)
+            .expect("Should compile manually written SSA into ACIR");
+
+        assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
+        assert_eq!(
+            brillig_functions.len(),
+            2,
+            "Should only have generated a single Brillig function"
+        );
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        assert_eq!(main_opcodes.len(), 6, "Should have four calls to f1 and two calls to f2");
+
+        // We should only have `BrilligCall` opcodes in `main`
+        for (i, opcode) in main_opcodes.iter().enumerate() {
+            match opcode {
+                Opcode::BrilligCall { id, .. } => {
+                    let expected_id = if i == 3 || i == 5 { 1 } else { 0 };
+                    assert_eq!(*id, expected_id, "Expected an id of {expected_id} but got {id}");
+                }
+                _ => panic!("Expected only Brillig call opcode"),
+            }
+        }
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 641d971af3c..04f33d528cd 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -347,9 +347,11 @@ impl Instruction {
                 let lhs = f(*lhs);
                 let rhs = f(*rhs);
                 let assert_message = assert_message.as_ref().map(|error| match error.as_ref() {
-                    ConstrainError::Dynamic(call_instr) => {
+                    ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(call_instr)) => {
                         let new_instr = call_instr.map_values(f);
-                        Box::new(ConstrainError::Dynamic(new_instr))
+                        Box::new(ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
+                            new_instr,
+                        )))
                     }
                     _ => error.clone(),
                 });
@@ -411,7 +413,10 @@ impl Instruction {
                 f(*lhs);
                 f(*rhs);
                 if let Some(error) = assert_error.as_ref() {
-                    if let ConstrainError::Dynamic(call_instr) = error.as_ref() {
+                    if let ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
+                        call_instr,
+                    )) = error.as_ref()
+                    {
                         call_instr.for_each_value(f);
                     }
                 }
@@ -597,6 +602,14 @@ impl Instruction {
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub(crate) enum ConstrainError {
     // These are errors which have been hardcoded during SSA gen
+    Intrinsic(String),
+    // These are errors issued by the user
+    UserDefined(UserDefinedConstrainError),
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub(crate) enum UserDefinedConstrainError {
+    // These are errors which come from static strings specified by a Noir program
     Static(String),
     // These are errors which come from runtime expressions specified by a Noir program
     // We store an `Instruction` as we want this Instruction to be atomic in SSA with
@@ -606,7 +619,7 @@ pub(crate) enum ConstrainError {
 
 impl From<String> for ConstrainError {
     fn from(value: String) -> Self {
-        ConstrainError::Static(value)
+        ConstrainError::Intrinsic(value)
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index fc13ab7307a..d17d2989341 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -9,7 +9,10 @@ use iter_extended::vecmap;
 use super::{
     basic_block::BasicBlockId,
     function::Function,
-    instruction::{ConstrainError, Instruction, InstructionId, TerminatorInstruction},
+    instruction::{
+        ConstrainError, Instruction, InstructionId, TerminatorInstruction,
+        UserDefinedConstrainError,
+    },
     value::ValueId,
 };
 
@@ -201,10 +204,11 @@ fn display_constrain_error(
     f: &mut Formatter,
 ) -> Result {
     match error {
-        ConstrainError::Static(assert_message_string) => {
+        ConstrainError::Intrinsic(assert_message_string)
+        | ConstrainError::UserDefined(UserDefinedConstrainError::Static(assert_message_string)) => {
             writeln!(f, "{assert_message_string:?}")
         }
-        ConstrainError::Dynamic(assert_message_call) => {
+        ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(assert_message_call)) => {
             display_instruction_inner(function, assert_message_call, f)
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index ca6527eb0ec..aa0368cc2dd 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -14,7 +14,7 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         function::{Function, FunctionId, Signature},
-        instruction::{BinaryOp, ConstrainError, Instruction},
+        instruction::{BinaryOp, ConstrainError, Instruction, UserDefinedConstrainError},
         types::{NumericType, Type},
         value::{Value, ValueId},
     },
@@ -93,10 +93,9 @@ impl DefunctionalizationContext {
                     // Constrain instruction potentially hold a call instruction themselves
                     // thus we need to account for them.
                     Instruction::Constrain(_, _, Some(constrain_error)) => {
-                        if let ConstrainError::Dynamic(Instruction::Call {
-                            func: target_func_id,
-                            arguments,
-                        }) = constrain_error.as_ref()
+                        if let ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
+                            Instruction::Call { func: target_func_id, arguments },
+                        )) = constrain_error.as_ref()
                         {
                             (*target_func_id, arguments)
                         } else {
@@ -138,9 +137,11 @@ impl DefunctionalizationContext {
                     if let Instruction::Constrain(lhs, rhs, constrain_error_call) = instruction {
                         let new_error_call = if let Some(error) = constrain_error_call {
                             match error.as_ref() {
-                                ConstrainError::Dynamic(_) => {
-                                    Some(Box::new(ConstrainError::Dynamic(new_instruction)))
-                                }
+                                ConstrainError::UserDefined(
+                                    UserDefinedConstrainError::Dynamic(_),
+                                ) => Some(Box::new(ConstrainError::UserDefined(
+                                    UserDefinedConstrainError::Dynamic(new_instruction),
+                                ))),
                                 _ => None,
                             }
                         } else {
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index fd1a029af26..2a4b5276547 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -29,7 +29,9 @@ use super::{
     function_builder::data_bus::DataBus,
     ir::{
         function::RuntimeType,
-        instruction::{BinaryOp, ConstrainError, Instruction, TerminatorInstruction},
+        instruction::{
+            BinaryOp, ConstrainError, Instruction, TerminatorInstruction, UserDefinedConstrainError,
+        },
         types::Type,
         value::ValueId,
     },
@@ -708,7 +710,9 @@ impl<'a> FunctionContext<'a> {
         if let ast::Expression::Literal(ast::Literal::Str(assert_message)) =
             assert_message_expr.as_ref()
         {
-            return Ok(Some(Box::new(ConstrainError::Static(assert_message.to_string()))));
+            return Ok(Some(Box::new(ConstrainError::UserDefined(
+                UserDefinedConstrainError::Static(assert_message.to_string()),
+            ))));
         }
 
         let ast::Expression::Call(call) = assert_message_expr.as_ref() else {
@@ -734,7 +738,7 @@ impl<'a> FunctionContext<'a> {
         }
 
         let instr = Instruction::Call { func, arguments };
-        Ok(Some(Box::new(ConstrainError::Dynamic(instr))))
+        Ok(Some(Box::new(ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(instr)))))
     }
 
     fn codegen_assign(&mut self, assign: &ast::Assign) -> Result<Values, RuntimeError> {
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
index 9995c031145..b05a2cbc741 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
@@ -3,7 +3,7 @@ use std::{collections::BTreeMap, fmt::Display};
 use iter_extended::btree_map;
 
 use crate::ssa::ir::{
-    function::{Function, FunctionId},
+    function::{Function, FunctionId, RuntimeType},
     map::AtomicCounter,
 };
 
@@ -12,7 +12,11 @@ pub(crate) struct Ssa {
     pub(crate) functions: BTreeMap<FunctionId, Function>,
     pub(crate) main_id: FunctionId,
     pub(crate) next_id: AtomicCounter<Function>,
-    pub(crate) id_to_index: BTreeMap<FunctionId, u32>,
+    /// Maps SSA entry point function ID -> Final generated ACIR artifact index.
+    /// There can be functions specified in SSA which do not act as ACIR entry points.
+    /// This mapping is necessary to use the correct function pointer for an ACIR call,
+    /// as the final program artifact will be a list of only entry point functions.
+    pub(crate) entry_point_to_generated_index: BTreeMap<FunctionId, u32>,
 }
 
 impl Ssa {
@@ -27,9 +31,26 @@ impl Ssa {
             (f.id(), f)
         });
 
-        let id_to_index = btree_map(functions.iter().enumerate(), |(i, (id, _))| (*id, i as u32));
+        let entry_point_to_generated_index = btree_map(
+            functions
+                .iter()
+                .filter(|(_, func)| {
+                    let runtime = func.runtime();
+                    match func.runtime() {
+                        RuntimeType::Acir(_) => runtime.is_entry_point() || func.id() == main_id,
+                        RuntimeType::Brillig => false,
+                    }
+                })
+                .enumerate(),
+            |(i, (id, _))| (*id, i as u32),
+        );
 
-        Self { functions, main_id, next_id: AtomicCounter::starting_after(max_id), id_to_index }
+        Self {
+            functions,
+            main_id,
+            next_id: AtomicCounter::starting_after(max_id),
+            entry_point_to_generated_index,
+        }
     }
 
     /// Returns the entry-point function of the program
diff --git a/compiler/noirc_frontend/src/hir/mod.rs b/compiler/noirc_frontend/src/hir/mod.rs
index b4804739cac..55dc22d6c5d 100644
--- a/compiler/noirc_frontend/src/hir/mod.rs
+++ b/compiler/noirc_frontend/src/hir/mod.rs
@@ -158,7 +158,8 @@ impl Context<'_, '_> {
         }
     }
 
-    /// Recursively walks down the crate dependency graph from crate_id until we reach requested crate
+    /// Tries to find the requested crate in the current one's dependencies,
+    /// otherwise walks down the crate dependency graph from crate_id until we reach it.
     /// This is needed in case a library (lib1) re-export a structure defined in another library (lib2)
     /// In that case, we will get [lib1,lib2] when looking for a struct defined in lib2,
     /// re-exported by lib1 and used by the main crate.
@@ -168,16 +169,26 @@ impl Context<'_, '_> {
         crate_id: &CrateId,
         target_crate_id: &CrateId,
     ) -> Option<Vec<String>> {
-        for dep in &self.crate_graph[crate_id].dependencies {
-            if &dep.crate_id == target_crate_id {
-                return Some(vec![dep.name.to_string()]);
-            }
-            if let Some(mut path) = self.find_dependencies(&dep.crate_id, target_crate_id) {
-                path.insert(0, dep.name.to_string());
-                return Some(path);
-            }
-        }
-        None
+        self.crate_graph[crate_id]
+            .dependencies
+            .iter()
+            .find_map(|dep| {
+                if &dep.crate_id == target_crate_id {
+                    Some(vec![dep.name.to_string()])
+                } else {
+                    None
+                }
+            })
+            .or_else(|| {
+                self.crate_graph[crate_id].dependencies.iter().find_map(|dep| {
+                    if let Some(mut path) = self.find_dependencies(&dep.crate_id, target_crate_id) {
+                        path.insert(0, dep.name.to_string());
+                        Some(path)
+                    } else {
+                        None
+                    }
+                })
+            })
     }
 
     pub fn function_meta(&self, func_id: &FuncId) -> &FuncMeta {
@@ -242,7 +253,7 @@ impl Context<'_, '_> {
             .get_all_contracts(&self.def_interner)
     }
 
-    fn module(&self, module_id: def_map::ModuleId) -> &def_map::ModuleData {
+    pub fn module(&self, module_id: def_map::ModuleId) -> &def_map::ModuleData {
         module_id.module(&self.def_maps)
     }
 }
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 84eb2d77315..153c7e45d4a 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -223,10 +223,10 @@ pub enum TraitImplKind {
 ///
 /// Additionally, types can define specialized impls with methods of the same name
 /// as long as these specialized impls do not overlap. E.g. `impl Struct<u32>` and `impl Struct<u64>`
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 pub struct Methods {
-    direct: Vec<FuncId>,
-    trait_impl_methods: Vec<FuncId>,
+    pub direct: Vec<FuncId>,
+    pub trait_impl_methods: Vec<FuncId>,
 }
 
 /// All the information from a function that is filled out during definition collection rather than
@@ -925,6 +925,24 @@ impl NodeInterner {
         self.structs[&id].clone()
     }
 
+    pub fn get_struct_methods(&self, id: StructId) -> Vec<Methods> {
+        self.struct_methods
+            .keys()
+            .filter_map(|(key_id, name)| {
+                if key_id == &id {
+                    Some(
+                        self.struct_methods
+                            .get(&(*key_id, name.clone()))
+                            .expect("get_struct_methods given invalid StructId")
+                            .clone(),
+                    )
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
     pub fn get_trait(&self, id: TraitId) -> &Trait {
         &self.traits[&id]
     }
diff --git a/test_programs/execution_success/brillig_slice_input/src/main.nr b/test_programs/execution_success/brillig_slice_input/src/main.nr
index 09a9d9aef9d..8403cb7d4a0 100644
--- a/test_programs/execution_success/brillig_slice_input/src/main.nr
+++ b/test_programs/execution_success/brillig_slice_input/src/main.nr
@@ -25,6 +25,9 @@ fn main() {
             y: 8,
         }
     ]);
+    let brillig_sum = sum_slice(slice);
+    assert_eq(brillig_sum, 55);
+
     slice = slice.push_back([
         Point {
             x: 15,
diff --git a/test_programs/execution_success/fold_after_inlined_calls/Nargo.toml b/test_programs/execution_success/fold_after_inlined_calls/Nargo.toml
new file mode 100644
index 00000000000..d23924af083
--- /dev/null
+++ b/test_programs/execution_success/fold_after_inlined_calls/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_after_inlined_calls"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_after_inlined_calls/Prover.toml b/test_programs/execution_success/fold_after_inlined_calls/Prover.toml
new file mode 100644
index 00000000000..4dd6b405159
--- /dev/null
+++ b/test_programs/execution_success/fold_after_inlined_calls/Prover.toml
@@ -0,0 +1 @@
+x = "1"
diff --git a/test_programs/execution_success/fold_after_inlined_calls/src/main.nr b/test_programs/execution_success/fold_after_inlined_calls/src/main.nr
new file mode 100644
index 00000000000..84c81190b9b
--- /dev/null
+++ b/test_programs/execution_success/fold_after_inlined_calls/src/main.nr
@@ -0,0 +1,14 @@
+fn main(x: u32) {
+    // We want to call a foldable function after a call to a function that is set to be inlined
+    assert(increment(x) == x + 1);
+    foo(x);
+}
+
+#[fold]
+fn foo(x: u32) {
+    assert(x == 1);
+}
+
+fn increment(x: u32) -> u32 {
+    x + 1
+}
diff --git a/tooling/backend_interface/src/cli/info.rs b/tooling/backend_interface/src/cli/info.rs
index 8ca3d4dd0a3..6e6603ce53e 100644
--- a/tooling/backend_interface/src/cli/info.rs
+++ b/tooling/backend_interface/src/cli/info.rs
@@ -56,7 +56,7 @@ fn info_command() -> Result<(), BackendError> {
 
     let expression_width = InfoCommand { crs_path }.run(backend.binary_path())?;
 
-    assert!(matches!(expression_width, ExpressionWidth::Bounded { width: 3 }));
+    assert!(matches!(expression_width, ExpressionWidth::Bounded { width: 4 }));
 
     Ok(())
 }
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index 3b47a7ced3a..fa1f82a5722 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -39,16 +39,16 @@ impl Backend {
         InfoCommand { crs_path: self.crs_directory() }.run(binary_path)
     }
 
-    /// If we cannot get a valid backend, returns `ExpressionWidth::Bound { width: 3 }``
+    /// If we cannot get a valid backend, returns `ExpressionWidth::Bound { width: 4 }``
     /// The function also prints a message saying we could not find a backend
     pub fn get_backend_info_or_default(&self) -> ExpressionWidth {
         if let Ok(expression_width) = self.get_backend_info() {
             expression_width
         } else {
             warn!(
-                "No valid backend found, ExpressionWidth defaulting to Bounded with a width of 3"
+                "No valid backend found, ExpressionWidth defaulting to Bounded with a width of 4"
             );
-            ExpressionWidth::Bounded { width: 3 }
+            ExpressionWidth::Bounded { width: 4 }
         }
     }
 
diff --git a/tooling/backend_interface/src/smart_contract.rs b/tooling/backend_interface/src/smart_contract.rs
index f6beeeb09d9..153ab52c83f 100644
--- a/tooling/backend_interface/src/smart_contract.rs
+++ b/tooling/backend_interface/src/smart_contract.rs
@@ -51,7 +51,7 @@ mod tests {
 
         let circuit = Circuit {
             current_witness_index: 4,
-            expression_width: ExpressionWidth::Bounded { width: 3 },
+            expression_width: ExpressionWidth::Bounded { width: 4 },
             opcodes: vec![constraint],
             private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
             public_parameters: PublicInputs::default(),
@@ -59,7 +59,7 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
-        let program = Program { functions: vec![circuit] };
+        let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
         let contract = get_mock_backend()?.eth_contract(&program)?;
 
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
index fd8cf602125..75a6d323e7b 100644
--- a/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
+++ b/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
@@ -5,7 +5,7 @@ use std::path::PathBuf;
 const INFO_RESPONSE: &str = r#"{
     "language": {
         "name": "PLONK-CSAT",
-        "width": 3
+        "width": 4
     },
     "opcodes_supported": ["arithmetic", "directive", "brillig", "memory_init", "memory_op"],
     "black_box_functions_supported": [
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 0f9770c805d..b3dfff9e94c 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.34.0";
+const VERSION: &str = "0.35.1";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 4507aeb8545..40d32072843 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -15,3 +15,5 @@ to_bytes_integration
 fold_basic
 fold_basic_nested_call
 fold_call_witness_condition
+fold_after_inlined_calls
+
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index c8ab544fa70..9b535075484 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -1,4 +1,5 @@
 use crate::foreign_calls::DebugForeignCallExecutor;
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
 use acvm::brillig_vm::brillig::ForeignCallResult;
@@ -42,10 +43,17 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap,
         foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
+        unconstrained_functions: &'a [BrilligBytecode],
     ) -> Self {
         let source_to_opcodes = build_source_to_opcode_debug_mappings(debug_artifact);
         Self {
-            acvm: ACVM::new(blackbox_solver, &circuit.opcodes, initial_witness),
+            // TODO: need to handle brillig pointer in the debugger
+            acvm: ACVM::new(
+                blackbox_solver,
+                &circuit.opcodes,
+                initial_witness,
+                unconstrained_functions,
+            ),
             brillig_solver: None,
             foreign_call_executor,
             debug_artifact,
@@ -632,6 +640,7 @@ fn build_source_to_opcode_debug_mappings(
     result
 }
 
+// TODO: update all debugger tests to use unconstrained brillig pointers
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -698,12 +707,14 @@ mod tests {
 
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
+        let brillig_funcs = &vec![];
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
             circuit,
             debug_artifact,
             initial_witness,
             foreign_call_executor,
+            brillig_funcs,
         );
 
         assert_eq!(context.get_current_opcode_location(), Some(OpcodeLocation::Acir(0)));
@@ -805,12 +816,14 @@ mod tests {
 
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
+        let brillig_funcs = &vec![];
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
             circuit,
             debug_artifact,
             initial_witness,
             foreign_call_executor,
+            brillig_funcs,
         );
 
         // set breakpoint
@@ -862,12 +875,14 @@ mod tests {
         let circuit = Circuit { opcodes, ..Circuit::default() };
         let debug_artifact =
             DebugArtifact { debug_symbols: vec![], file_map: BTreeMap::new(), warnings: vec![] };
+        let brillig_funcs = &vec![];
         let context = DebugContext::new(
             &StubbedBlackBoxSolver,
             &circuit,
             &debug_artifact,
             WitnessMap::new(),
             Box::new(DefaultDebugForeignCallExecutor::new(true)),
+            brillig_funcs,
         );
 
         assert_eq!(context.offset_opcode_location(&None, 0), (None, 0));
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index 8dc3c541540..060945132f5 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Write};
 use std::str::FromStr;
 
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, OpcodeLocation};
 use acvm::acir::native_types::WitnessMap;
 use acvm::BlackBoxFunctionSolver;
@@ -64,6 +65,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
         circuit: &'a Circuit,
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap,
+        unconstrained_functions: &'a [BrilligBytecode],
     ) -> Self {
         let context = DebugContext::new(
             solver,
@@ -71,6 +73,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
             debug_artifact,
             initial_witness,
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact)),
+            unconstrained_functions,
         );
         Self {
             server,
@@ -613,6 +616,7 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver>(
         &program.program.functions[0],
         &debug_artifact,
         initial_witness,
+        &program.program.unconstrained_functions,
     );
 
     session.run_loop()
diff --git a/tooling/debugger/src/lib.rs b/tooling/debugger/src/lib.rs
index 4a25e3417a0..a8fc61c893f 100644
--- a/tooling/debugger/src/lib.rs
+++ b/tooling/debugger/src/lib.rs
@@ -9,6 +9,7 @@ use std::io::{Read, Write};
 
 use ::dap::errors::ServerError;
 use ::dap::server::Server;
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 
@@ -22,8 +23,9 @@ pub fn debug_circuit<B: BlackBoxFunctionSolver>(
     circuit: &Circuit,
     debug_artifact: DebugArtifact,
     initial_witness: WitnessMap,
+    unconstrained_functions: &[BrilligBytecode],
 ) -> Result<Option<WitnessMap>, NargoError> {
-    repl::run(blackbox_solver, circuit, &debug_artifact, initial_witness)
+    repl::run(blackbox_solver, circuit, &debug_artifact, initial_witness, unconstrained_functions)
 }
 
 pub fn run_dap_loop<R: Read, W: Write, B: BlackBoxFunctionSolver>(
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index e30d519b62e..2a92698e5ce 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -1,5 +1,6 @@
 use crate::context::{DebugCommandResult, DebugContext};
 
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
 use acvm::{BlackBoxFunctionSolver, FieldElement};
@@ -20,6 +21,7 @@ pub struct ReplDebugger<'a, B: BlackBoxFunctionSolver> {
     debug_artifact: &'a DebugArtifact,
     initial_witness: WitnessMap,
     last_result: DebugCommandResult,
+    unconstrained_functions: &'a [BrilligBytecode],
 }
 
 impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
@@ -28,6 +30,7 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
         circuit: &'a Circuit,
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap,
+        unconstrained_functions: &'a [BrilligBytecode],
     ) -> Self {
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
@@ -37,6 +40,7 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
             debug_artifact,
             initial_witness.clone(),
             foreign_call_executor,
+            unconstrained_functions,
         );
         let last_result = if context.get_current_opcode_location().is_none() {
             // handle circuit with no opcodes
@@ -44,7 +48,15 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
         } else {
             DebugCommandResult::Ok
         };
-        Self { context, blackbox_solver, circuit, debug_artifact, initial_witness, last_result }
+        Self {
+            context,
+            blackbox_solver,
+            circuit,
+            debug_artifact,
+            initial_witness,
+            last_result,
+            unconstrained_functions,
+        }
     }
 
     pub fn show_current_vm_status(&self) {
@@ -271,6 +283,7 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
             self.debug_artifact,
             self.initial_witness.clone(),
             foreign_call_executor,
+            self.unconstrained_functions,
         );
         for opcode_location in breakpoints {
             self.context.add_breakpoint(opcode_location);
@@ -361,9 +374,15 @@ pub fn run<B: BlackBoxFunctionSolver>(
     circuit: &Circuit,
     debug_artifact: &DebugArtifact,
     initial_witness: WitnessMap,
+    unconstrained_functions: &[BrilligBytecode],
 ) -> Result<Option<WitnessMap>, NargoError> {
-    let context =
-        RefCell::new(ReplDebugger::new(blackbox_solver, circuit, debug_artifact, initial_witness));
+    let context = RefCell::new(ReplDebugger::new(
+        blackbox_solver,
+        circuit,
+        debug_artifact,
+        initial_witness,
+        unconstrained_functions,
+    ));
     let ref_context = &context;
 
     ref_context.borrow().show_current_vm_status();
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index d0acbf1aec5..0fea9b16b54 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -10,7 +10,7 @@ impl BlackBoxFunctionSolver for WrapperSolver {
         &self,
         public_key_x: &acvm::FieldElement,
         public_key_y: &acvm::FieldElement,
-        signature: &[u8],
+        signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, acvm::BlackBoxResolutionError> {
         self.0.schnorr_verify(public_key_x, public_key_y, signature, message)
diff --git a/tooling/nargo/src/errors.rs b/tooling/nargo/src/errors.rs
index fa44bcc459b..ac03330a7c8 100644
--- a/tooling/nargo/src/errors.rs
+++ b/tooling/nargo/src/errors.rs
@@ -67,7 +67,9 @@ impl NargoError {
                 | OpcodeResolutionError::UnsatisfiedConstrain { .. }
                 | OpcodeResolutionError::AcirMainCallAttempted { .. }
                 | OpcodeResolutionError::AcirCallOutputsMismatch { .. } => None,
-                OpcodeResolutionError::BrilligFunctionFailed { message, .. } => Some(message),
+                OpcodeResolutionError::BrilligFunctionFailed { message, .. } => {
+                    message.as_ref().map(|s| s.as_str())
+                }
                 OpcodeResolutionError::BlackBoxFunctionFailed(_, reason) => Some(reason),
             },
         }
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 76f6da7c1bc..97584aff150 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -1,3 +1,4 @@
+use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{OpcodeLocation, Program, ResolvedOpcodeLocation};
 use acvm::acir::native_types::WitnessStack;
 use acvm::brillig_vm::brillig::ForeignCallResult;
@@ -12,6 +13,9 @@ use super::foreign_calls::{ForeignCallExecutor, NargoForeignCallResult};
 
 struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
     functions: &'a [Circuit],
+
+    unconstrained_functions: &'a [BrilligBytecode],
+
     // This gets built as we run through the program looking at each function call
     witness_stack: WitnessStack,
 
@@ -32,11 +36,13 @@ struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
 impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a, B, F> {
     fn new(
         functions: &'a [Circuit],
+        unconstrained_functions: &'a [BrilligBytecode],
         blackbox_solver: &'a B,
         foreign_call_executor: &'a mut F,
     ) -> Self {
         ProgramExecutor {
             functions,
+            unconstrained_functions,
             witness_stack: WitnessStack::default(),
             blackbox_solver,
             foreign_call_executor,
@@ -52,7 +58,12 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
     #[tracing::instrument(level = "trace", skip_all)]
     fn execute_circuit(&mut self, initial_witness: WitnessMap) -> Result<WitnessMap, NargoError> {
         let circuit = &self.functions[self.current_function_index];
-        let mut acvm = ACVM::new(self.blackbox_solver, &circuit.opcodes, initial_witness);
+        let mut acvm = ACVM::new(
+            self.blackbox_solver,
+            &circuit.opcodes,
+            initial_witness,
+            self.unconstrained_functions,
+        );
 
         // This message should be resolved by a nargo foreign call only when we have an unsatisfied assertion.
         let mut assert_message: Option<String> = None;
@@ -95,14 +106,20 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                     return Err(NargoError::ExecutionError(match call_stack {
                         Some(call_stack) => {
                             // First check whether we have a runtime assertion message that should be resolved on an ACVM failure
-                            // If we do not have a runtime assertion message, we should check whether the circuit has any hardcoded
-                            // messages associated with a specific `OpcodeLocation`.
+                            // If we do not have a runtime assertion message, we check wether the error is a brillig error with a user-defined message,
+                            // and finally we should check whether the circuit has any hardcoded messages associated with a specific `OpcodeLocation`.
                             // Otherwise return the provided opcode resolution error.
                             if let Some(assert_message) = assert_message {
                                 ExecutionError::AssertionFailed(
                                     assert_message.to_owned(),
                                     call_stack,
                                 )
+                            } else if let OpcodeResolutionError::BrilligFunctionFailed {
+                                message: Some(message),
+                                ..
+                            } = &error
+                            {
+                                ExecutionError::AssertionFailed(message.to_owned(), call_stack)
                             } else if let Some(assert_message) = circuit.get_assert_message(
                                 call_stack
                                     .last()
@@ -186,8 +203,12 @@ pub fn execute_program<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
     blackbox_solver: &B,
     foreign_call_executor: &mut F,
 ) -> Result<WitnessStack, NargoError> {
-    let mut executor =
-        ProgramExecutor::new(&program.functions, blackbox_solver, foreign_call_executor);
+    let mut executor = ProgramExecutor::new(
+        &program.functions,
+        &program.unconstrained_functions,
+        blackbox_solver,
+        foreign_call_executor,
+    );
     let main_witness = executor.execute_circuit(initial_witness)?;
     executor.witness_stack.push(0, main_witness);
 
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 6a3f0094a08..7cb5cd7846b 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -242,6 +242,7 @@ pub(crate) fn debug_program(
         &compiled_program.program.functions[0],
         debug_artifact,
         initial_witness,
+        &compiled_program.program.unconstrained_functions,
     )
     .map_err(CliError::from)
 }
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 77a84de07a4..67825362f92 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -293,8 +293,11 @@ fn count_opcodes_and_gates_in_program(
             Ok(FunctionInfo {
                 name: compiled_program.names[i].clone(),
                 acir_opcodes: function.opcodes.len(),
-                circuit_size: backend
-                    .get_exact_circuit_size(&Program { functions: vec![function] })?,
+                // Unconstrained functions do not matter to a backend circuit count so we pass nothing here
+                circuit_size: backend.get_exact_circuit_size(&Program {
+                    functions: vec![function],
+                    unconstrained_functions: Vec::new(),
+                })?,
             })
         })
         .collect::<Result<_, _>>()?;
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 98bfdf1c3a8..af9e47a8e63 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.34.0",
+    "@aztec/bb.js": "0.35.1",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index 38e13814929..e9915882fac 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.34.0":
-  version: 0.34.0
-  resolution: "@aztec/bb.js@npm:0.34.0"
+"@aztec/bb.js@npm:0.35.1":
+  version: 0.35.1
+  resolution: "@aztec/bb.js@npm:0.35.1"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 9d07834d81ed19e4d6fd5c1f3b07c565648df1165c30115f020ece9660b2b8599a5ed894a2090410f14020e73dd290484b30b76c9c71e863b8390fa2b7c1b729
+  checksum: 8e3551f059523d9494af4721a9219e2c6e63c8ed1df447a2d0daa9f8526a794758ae708bd1d9c9b1fbfb89c56dc867d9f0b87250dbabfcde23ec02dabbb5a32a
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.34.0
+    "@aztec/bb.js": 0.35.1
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 599243633281e6827f0f4f095fb12d313e0125fa Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 17 Apr 2024 14:16:37 -0400
Subject: [PATCH 195/416] feat: Add comptime Interpreter (#4821)

# Description

## Problem\*

Resolves #4587

## Summary\*

Implements an interpreter to interpret Noir functions at compile-time.
This is intended to be used in the future for evaluation of `comptime`
items for metaprogramming, although there is currently no way to trigger
this interpreter in user code.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 Cargo.lock                                    |    1 +
 Cargo.toml                                    |    1 +
 compiler/noirc_evaluator/Cargo.toml           |    4 +-
 compiler/noirc_frontend/Cargo.toml            |    1 +
 compiler/noirc_frontend/src/ast/expression.rs |    5 +
 .../src/hir/comptime/interpreter.rs           | 1282 +++++++++++++++++
 .../noirc_frontend/src/hir/comptime/mod.rs    |    2 +
 .../noirc_frontend/src/hir/comptime/tests.rs  |  166 +++
 .../src/hir/def_collector/dc_mod.rs           |    1 +
 .../src/hir/resolution/resolver.rs            |    1 +
 .../noirc_frontend/src/hir/type_check/mod.rs  |   53 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |    4 +-
 .../noirc_frontend/src/hir_def/function.rs    |    4 +-
 compiler/noirc_frontend/src/hir_def/stmt.rs   |    2 +-
 .../src/monomorphization/mod.rs               |    2 +-
 compiler/noirc_frontend/src/node_interner.rs  |    4 +
 .../src/parser/parser/function.rs             |    1 +
 17 files changed, 1503 insertions(+), 31 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/interpreter.rs
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index e83c10a1932..b01c22ed75b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3163,6 +3163,7 @@ dependencies = [
  "base64 0.21.2",
  "chumsky",
  "fm",
+ "im",
  "iter-extended",
  "lalrpop",
  "lalrpop-util",
diff --git a/Cargo.toml b/Cargo.toml
index 6a939878f9f..cdbb40f630a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -132,6 +132,7 @@ tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
 
+im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
 tracing-web = "0.1.3"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index fad7c3c309e..fb2f003aa56 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -15,7 +15,7 @@ fxhash.workspace = true
 iter-extended.workspace = true
 thiserror.workspace = true
 num-bigint = "0.4"
-im = { version = "15.1", features = ["serde"] }
+im.workspace = true
 serde.workspace = true
 tracing.workspace = true
-chrono = "0.4.37"
\ No newline at end of file
+chrono = "0.4.37"
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index e39ab2fe106..7a23585bd23 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -17,6 +17,7 @@ iter-extended.workspace = true
 chumsky.workspace = true
 thiserror.workspace = true
 smol_str.workspace = true
+im.workspace = true
 serde_json.workspace = true
 serde.workspace = true
 rustc-hash = "1.1.0"
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 0e5919bf7db..755739af8fe 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -387,6 +387,9 @@ pub struct FunctionDefinition {
     /// True if this function was defined with the 'unconstrained' keyword
     pub is_unconstrained: bool,
 
+    /// True if this function was defined with the 'comptime' keyword
+    pub is_comptime: bool,
+
     /// Indicate if this function was defined with the 'pub' keyword
     pub visibility: ItemVisibility,
 
@@ -679,10 +682,12 @@ impl FunctionDefinition {
                 span: ident.span().merge(unresolved_type.span.unwrap()),
             })
             .collect();
+
         FunctionDefinition {
             name: name.clone(),
             attributes: Attributes::empty(),
             is_unconstrained: false,
+            is_comptime: false,
             visibility: ItemVisibility::Private,
             generics: generics.clone(),
             parameters: p,
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
new file mode 100644
index 00000000000..81050073008
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -0,0 +1,1282 @@
+use std::{borrow::Cow, collections::hash_map::Entry, rc::Rc};
+
+use acvm::FieldElement;
+use im::Vector;
+use iter_extended::{try_vecmap, vecmap};
+use noirc_errors::Location;
+use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
+
+use crate::{
+    hir_def::{
+        expr::{
+            HirArrayLiteral, HirBlockExpression, HirCallExpression, HirCastExpression,
+            HirConstructorExpression, HirIdent, HirIfExpression, HirIndexExpression,
+            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
+            HirPrefixExpression,
+        },
+        stmt::{
+            HirAssignStatement, HirConstrainStatement, HirForStatement, HirLValue, HirLetStatement,
+            HirPattern,
+        },
+    },
+    macros_api::{HirExpression, HirLiteral, HirStatement, NodeInterner},
+    node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
+    BinaryOpKind, BlockExpression, FunctionKind, IntegerBitSize, Shared, Signedness, Type,
+    TypeBinding, TypeBindings, TypeVariableKind,
+};
+
+#[allow(unused)]
+pub(crate) struct Interpreter<'interner> {
+    /// To expand macros the Interpreter may mutate hir nodes within the NodeInterner
+    interner: &'interner mut NodeInterner,
+
+    /// Each value currently in scope in the interpreter.
+    /// Each element of the Vec represents a scope with every scope together making
+    /// up all currently visible definitions.
+    scopes: Vec<HashMap<DefinitionId, Value>>,
+
+    /// True if we've expanded any macros into any functions and will need
+    /// to redo name resolution & type checking for that function.
+    changed_functions: HashSet<FuncId>,
+
+    /// True if we've expanded any macros into global scope and will need
+    /// to redo name resolution & type checking for everything.
+    changed_globally: bool,
+
+    in_loop: bool,
+}
+
+#[allow(unused)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum Value {
+    Unit,
+    Bool(bool),
+    Field(FieldElement),
+    I8(i8),
+    I32(i32),
+    I64(i64),
+    U8(u8),
+    U32(u32),
+    U64(u64),
+    String(Rc<String>),
+    Function(FuncId, Type),
+    Closure(HirLambda, Vec<Value>, Type),
+    Tuple(Vec<Value>),
+    Struct(HashMap<Rc<String>, Value>, Type),
+    Pointer(Shared<Value>),
+    Array(Vector<Value>, Type),
+    Slice(Vector<Value>, Type),
+    Code(Rc<BlockExpression>),
+}
+
+/// The possible errors that can halt the interpreter.
+#[allow(unused)]
+#[derive(Debug)]
+pub(crate) enum InterpreterError {
+    ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
+    TypeMismatch { expected: Type, value: Value, location: Location },
+    NoValueForId { id: DefinitionId, location: Location },
+    IntegerOutOfRangeForType { value: FieldElement, typ: Type, location: Location },
+    ErrorNodeEncountered { location: Location },
+    NonFunctionCalled { value: Value, location: Location },
+    NonBoolUsedInIf { value: Value, location: Location },
+    NonBoolUsedInConstrain { value: Value, location: Location },
+    FailingConstraint { message: Option<Value>, location: Location },
+    NoMethodFound { object: Value, typ: Type, location: Location },
+    NonIntegerUsedInLoop { value: Value, location: Location },
+    NonPointerDereferenced { value: Value, location: Location },
+    NonTupleOrStructInMemberAccess { value: Value, location: Location },
+    NonArrayIndexed { value: Value, location: Location },
+    NonIntegerUsedAsIndex { value: Value, location: Location },
+    NonIntegerIntegerLiteral { typ: Type, location: Location },
+    NonIntegerArrayLength { typ: Type, location: Location },
+    NonNumericCasted { value: Value, location: Location },
+    IndexOutOfBounds { index: usize, length: usize, location: Location },
+    ExpectedStructToHaveField { value: Value, field_name: String, location: Location },
+    TypeUnsupported { typ: Type, location: Location },
+    InvalidValueForUnary { value: Value, operator: &'static str, location: Location },
+    InvalidValuesForBinary { lhs: Value, rhs: Value, operator: &'static str, location: Location },
+    CastToNonNumericType { typ: Type, location: Location },
+
+    // Perhaps this should be unreachable! due to type checking also preventing this error?
+    // Currently it and the Continue variant are the only interpreter errors without a Location field
+    BreakNotInLoop,
+    ContinueNotInLoop,
+
+    // These cases are not errors but prevent us from running more code
+    // until the loop can be resumed properly.
+    Break,
+    Continue,
+}
+
+#[allow(unused)]
+type IResult<T> = std::result::Result<T, InterpreterError>;
+
+#[allow(unused)]
+impl<'a> Interpreter<'a> {
+    pub(crate) fn new(interner: &'a mut NodeInterner) -> Self {
+        Self {
+            interner,
+            scopes: vec![HashMap::default()],
+            changed_functions: HashSet::default(),
+            changed_globally: false,
+            in_loop: false,
+        }
+    }
+
+    pub(crate) fn call_function(
+        &mut self,
+        function: FuncId,
+        arguments: Vec<(Value, Location)>,
+        call_location: Location,
+    ) -> IResult<Value> {
+        let previous_state = self.enter_function();
+
+        let meta = self.interner.function_meta(&function);
+        if meta.kind != FunctionKind::Normal {
+            todo!("Evaluation for {:?} is unimplemented", meta.kind);
+        }
+
+        if meta.parameters.len() != arguments.len() {
+            return Err(InterpreterError::ArgumentCountMismatch {
+                expected: meta.parameters.len(),
+                actual: arguments.len(),
+                call_location,
+            });
+        }
+
+        let parameters = meta.parameters.0.clone();
+        for ((parameter, typ, _), (argument, arg_location)) in parameters.iter().zip(arguments) {
+            self.define_pattern(parameter, typ, argument, arg_location)?;
+        }
+
+        let function_body = self.interner.function(&function).as_expr();
+        let result = self.evaluate(function_body)?;
+
+        self.exit_function(previous_state);
+        Ok(result)
+    }
+
+    fn call_closure(
+        &mut self,
+        closure: HirLambda,
+        // TODO: How to define environment here?
+        _environment: Vec<Value>,
+        arguments: Vec<(Value, Location)>,
+        call_location: Location,
+    ) -> IResult<Value> {
+        let previous_state = self.enter_function();
+
+        if closure.parameters.len() != arguments.len() {
+            return Err(InterpreterError::ArgumentCountMismatch {
+                expected: closure.parameters.len(),
+                actual: arguments.len(),
+                call_location,
+            });
+        }
+
+        let parameters = closure.parameters.iter().zip(arguments);
+        for ((parameter, typ), (argument, arg_location)) in parameters {
+            self.define_pattern(parameter, typ, argument, arg_location)?;
+        }
+
+        let result = self.evaluate(closure.body)?;
+
+        self.exit_function(previous_state);
+        Ok(result)
+    }
+
+    /// Enters a function, pushing a new scope and resetting any required state.
+    /// Returns the previous values of the internal state, to be reset when
+    /// `exit_function` is called.
+    fn enter_function(&mut self) -> (bool, Vec<HashMap<DefinitionId, Value>>) {
+        // Drain every scope except the global scope
+        let scope = self.scopes.drain(1..).collect();
+        self.push_scope();
+        (std::mem::take(&mut self.in_loop), scope)
+    }
+
+    fn exit_function(&mut self, mut state: (bool, Vec<HashMap<DefinitionId, Value>>)) {
+        self.in_loop = state.0;
+
+        // Keep only the global scope
+        self.scopes.truncate(1);
+        self.scopes.append(&mut state.1);
+    }
+
+    fn push_scope(&mut self) {
+        self.scopes.push(HashMap::default());
+    }
+
+    fn pop_scope(&mut self) {
+        self.scopes.pop();
+    }
+
+    fn current_scope_mut(&mut self) -> &mut HashMap<DefinitionId, Value> {
+        // the global scope is always at index zero, so this is always Some
+        self.scopes.last_mut().unwrap()
+    }
+
+    fn define_pattern(
+        &mut self,
+        pattern: &HirPattern,
+        typ: &Type,
+        argument: Value,
+        location: Location,
+    ) -> IResult<()> {
+        match pattern {
+            HirPattern::Identifier(identifier) => {
+                self.define(identifier.id, typ, argument, location)
+            }
+            HirPattern::Mutable(pattern, _) => {
+                self.define_pattern(pattern, typ, argument, location)
+            }
+            HirPattern::Tuple(pattern_fields, _) => match (argument, typ) {
+                (Value::Tuple(fields), Type::Tuple(type_fields))
+                    if fields.len() == pattern_fields.len() =>
+                {
+                    for ((pattern, typ), argument) in
+                        pattern_fields.iter().zip(type_fields).zip(fields)
+                    {
+                        self.define_pattern(pattern, typ, argument, location)?;
+                    }
+                    Ok(())
+                }
+                (value, _) => {
+                    Err(InterpreterError::TypeMismatch { expected: typ.clone(), value, location })
+                }
+            },
+            HirPattern::Struct(struct_type, pattern_fields, _) => {
+                self.type_check(typ, &argument, location)?;
+                self.type_check(struct_type, &argument, location)?;
+
+                match argument {
+                    Value::Struct(fields, struct_type) if fields.len() == pattern_fields.len() => {
+                        for (field_name, field_pattern) in pattern_fields {
+                            let field = fields.get(&field_name.0.contents).ok_or_else(|| {
+                                InterpreterError::ExpectedStructToHaveField {
+                                    value: Value::Struct(fields.clone(), struct_type.clone()),
+                                    field_name: field_name.0.contents.clone(),
+                                    location,
+                                }
+                            })?;
+
+                            let field_type = field.get_type().into_owned();
+                            self.define_pattern(
+                                field_pattern,
+                                &field_type,
+                                field.clone(),
+                                location,
+                            )?;
+                        }
+                        Ok(())
+                    }
+                    value => Err(InterpreterError::TypeMismatch {
+                        expected: typ.clone(),
+                        value,
+                        location,
+                    }),
+                }
+            }
+        }
+    }
+
+    /// Define a new variable in the current scope
+    fn define(
+        &mut self,
+        id: DefinitionId,
+        typ: &Type,
+        argument: Value,
+        location: Location,
+    ) -> IResult<()> {
+        self.type_check(typ, &argument, location)?;
+        self.current_scope_mut().insert(id, argument);
+        Ok(())
+    }
+
+    /// Mutate an existing variable, potentially from a prior scope.
+    /// Also type checks the value being assigned
+    fn checked_mutate(
+        &mut self,
+        id: DefinitionId,
+        typ: &Type,
+        argument: Value,
+        location: Location,
+    ) -> IResult<()> {
+        self.type_check(typ, &argument, location)?;
+        for scope in self.scopes.iter_mut().rev() {
+            if let Entry::Occupied(mut entry) = scope.entry(id) {
+                entry.insert(argument);
+                return Ok(());
+            }
+        }
+        Err(InterpreterError::NoValueForId { id, location })
+    }
+
+    /// Mutate an existing variable, potentially from a prior scope
+    fn mutate(&mut self, id: DefinitionId, argument: Value, location: Location) -> IResult<()> {
+        for scope in self.scopes.iter_mut().rev() {
+            if let Entry::Occupied(mut entry) = scope.entry(id) {
+                entry.insert(argument);
+                return Ok(());
+            }
+        }
+        Err(InterpreterError::NoValueForId { id, location })
+    }
+
+    fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
+        for scope in self.scopes.iter().rev() {
+            if let Some(value) = scope.get(&ident.id) {
+                return Ok(value.clone());
+            }
+        }
+
+        Err(InterpreterError::NoValueForId { id: ident.id, location: ident.location })
+    }
+
+    fn lookup_id(&self, id: DefinitionId, location: Location) -> IResult<Value> {
+        for scope in self.scopes.iter().rev() {
+            if let Some(value) = scope.get(&id) {
+                return Ok(value.clone());
+            }
+        }
+
+        Err(InterpreterError::NoValueForId { id, location })
+    }
+
+    fn type_check(&self, typ: &Type, value: &Value, location: Location) -> IResult<()> {
+        let typ = typ.follow_bindings();
+        let value_type = value.get_type();
+
+        typ.try_unify(&value_type, &mut TypeBindings::new()).map_err(|_| {
+            InterpreterError::TypeMismatch { expected: typ, value: value.clone(), location }
+        })
+    }
+
+    /// Evaluate an expression and return the result
+    fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
+        match self.interner.expression(&id) {
+            HirExpression::Ident(ident) => self.evaluate_ident(ident, id),
+            HirExpression::Literal(literal) => self.evaluate_literal(literal, id),
+            HirExpression::Block(block) => self.evaluate_block(block),
+            HirExpression::Prefix(prefix) => self.evaluate_prefix(prefix, id),
+            HirExpression::Infix(infix) => self.evaluate_infix(infix, id),
+            HirExpression::Index(index) => self.evaluate_index(index, id),
+            HirExpression::Constructor(constructor) => self.evaluate_constructor(constructor, id),
+            HirExpression::MemberAccess(access) => self.evaluate_access(access, id),
+            HirExpression::Call(call) => self.evaluate_call(call, id),
+            HirExpression::MethodCall(call) => self.evaluate_method_call(call, id),
+            HirExpression::Cast(cast) => self.evaluate_cast(cast, id),
+            HirExpression::If(if_) => self.evaluate_if(if_, id),
+            HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
+            HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
+            HirExpression::Quote(block) => Ok(Value::Code(Rc::new(block))),
+            HirExpression::Error => {
+                let location = self.interner.expr_location(&id);
+                Err(InterpreterError::ErrorNodeEncountered { location })
+            }
+        }
+    }
+
+    fn evaluate_ident(&mut self, ident: HirIdent, id: ExprId) -> IResult<Value> {
+        let definition = self.interner.definition(ident.id);
+
+        match &definition.kind {
+            DefinitionKind::Function(function_id) => {
+                let typ = self.interner.id_type(id);
+                Ok(Value::Function(*function_id, typ))
+            }
+            DefinitionKind::Local(_) => dbg!(self.lookup(&ident)),
+            DefinitionKind::Global(global_id) => {
+                let let_ = self.interner.get_global_let_statement(*global_id).unwrap();
+                self.evaluate_let(let_)?;
+                self.lookup(&ident)
+            }
+            DefinitionKind::GenericType(type_variable) => {
+                let value = match &*type_variable.borrow() {
+                    TypeBinding::Unbound(_) => None,
+                    TypeBinding::Bound(binding) => binding.evaluate_to_u64(),
+                };
+
+                if let Some(value) = value {
+                    let typ = self.interner.id_type(id);
+                    self.evaluate_integer((value as u128).into(), false, id)
+                } else {
+                    let location = self.interner.expr_location(&id);
+                    let typ = Type::TypeVariable(type_variable.clone(), TypeVariableKind::Normal);
+                    Err(InterpreterError::NonIntegerArrayLength { typ, location })
+                }
+            }
+        }
+    }
+
+    fn evaluate_literal(&mut self, literal: HirLiteral, id: ExprId) -> IResult<Value> {
+        match literal {
+            HirLiteral::Unit => Ok(Value::Unit),
+            HirLiteral::Bool(value) => Ok(Value::Bool(value)),
+            HirLiteral::Integer(value, is_negative) => {
+                self.evaluate_integer(value, is_negative, id)
+            }
+            HirLiteral::Str(string) => Ok(Value::String(Rc::new(string))),
+            HirLiteral::FmtStr(_, _) => todo!("Evaluate format strings"),
+            HirLiteral::Array(array) => self.evaluate_array(array, id),
+            HirLiteral::Slice(array) => self.evaluate_slice(array, id),
+        }
+    }
+
+    fn evaluate_integer(
+        &self,
+        value: FieldElement,
+        is_negative: bool,
+        id: ExprId,
+    ) -> IResult<Value> {
+        let typ = self.interner.id_type(id).follow_bindings();
+        let location = self.interner.expr_location(&id);
+
+        if let Type::FieldElement = &typ {
+            Ok(Value::Field(value))
+        } else if let Type::Integer(sign, bit_size) = &typ {
+            match (sign, bit_size) {
+                (Signedness::Unsigned, IntegerBitSize::One) => {
+                    return Err(InterpreterError::TypeUnsupported { typ, location });
+                }
+                (Signedness::Unsigned, IntegerBitSize::Eight) => {
+                    let value: u8 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { 0u8.wrapping_sub(value) } else { value };
+                    Ok(Value::U8(value))
+                }
+                (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
+                    let value: u32 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { 0u32.wrapping_sub(value) } else { value };
+                    Ok(Value::U32(value))
+                }
+                (Signedness::Unsigned, IntegerBitSize::SixtyFour) => {
+                    let value: u64 =
+                        value.try_to_u64().ok_or(InterpreterError::IntegerOutOfRangeForType {
+                            value,
+                            typ,
+                            location,
+                        })?;
+                    let value = if is_negative { 0u64.wrapping_sub(value) } else { value };
+                    Ok(Value::U64(value))
+                }
+                (Signedness::Signed, IntegerBitSize::One) => {
+                    return Err(InterpreterError::TypeUnsupported { typ, location });
+                }
+                (Signedness::Signed, IntegerBitSize::Eight) => {
+                    let value: i8 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { -value } else { value };
+                    Ok(Value::I8(value))
+                }
+                (Signedness::Signed, IntegerBitSize::ThirtyTwo) => {
+                    let value: i32 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { -value } else { value };
+                    Ok(Value::I32(value))
+                }
+                (Signedness::Signed, IntegerBitSize::SixtyFour) => {
+                    let value: i64 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { -value } else { value };
+                    Ok(Value::I64(value))
+                }
+            }
+        } else {
+            Err(InterpreterError::NonIntegerIntegerLiteral { typ, location })
+        }
+    }
+
+    fn evaluate_block(&mut self, mut block: HirBlockExpression) -> IResult<Value> {
+        let last_statement = block.statements.pop();
+        self.push_scope();
+
+        for statement in block.statements {
+            self.evaluate_statement(statement)?;
+        }
+
+        let result = if let Some(statement) = last_statement {
+            self.evaluate_statement(statement)
+        } else {
+            Ok(Value::Unit)
+        };
+
+        self.pop_scope();
+        result
+    }
+
+    fn evaluate_array(&mut self, array: HirArrayLiteral, id: ExprId) -> IResult<Value> {
+        let typ = self.interner.id_type(id);
+
+        match array {
+            HirArrayLiteral::Standard(elements) => {
+                let elements = elements
+                    .into_iter()
+                    .map(|id| self.evaluate(id))
+                    .collect::<IResult<Vector<_>>>()?;
+
+                Ok(Value::Array(elements, typ))
+            }
+            HirArrayLiteral::Repeated { repeated_element, length } => {
+                let element = self.evaluate(repeated_element)?;
+
+                if let Some(length) = length.evaluate_to_u64() {
+                    let elements = (0..length).map(|_| element.clone()).collect();
+                    Ok(Value::Array(elements, typ))
+                } else {
+                    let location = self.interner.expr_location(&id);
+                    Err(InterpreterError::NonIntegerArrayLength { typ: length, location })
+                }
+            }
+        }
+    }
+
+    fn evaluate_slice(&mut self, array: HirArrayLiteral, id: ExprId) -> IResult<Value> {
+        self.evaluate_array(array, id).map(|value| match value {
+            Value::Array(array, typ) => Value::Slice(array, typ),
+            other => unreachable!("Non-array value returned from evaluate array: {other:?}"),
+        })
+    }
+
+    fn evaluate_prefix(&mut self, prefix: HirPrefixExpression, id: ExprId) -> IResult<Value> {
+        let rhs = self.evaluate(prefix.rhs)?;
+        match prefix.operator {
+            crate::UnaryOp::Minus => match rhs {
+                Value::Field(value) => Ok(Value::Field(FieldElement::zero() - value)),
+                Value::I8(value) => Ok(Value::I8(-value)),
+                Value::I32(value) => Ok(Value::I32(-value)),
+                Value::I64(value) => Ok(Value::I64(-value)),
+                Value::U8(value) => Ok(Value::U8(0 - value)),
+                Value::U32(value) => Ok(Value::U32(0 - value)),
+                Value::U64(value) => Ok(Value::U64(0 - value)),
+                value => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InterpreterError::InvalidValueForUnary {
+                        value,
+                        location,
+                        operator: "minus",
+                    })
+                }
+            },
+            crate::UnaryOp::Not => match rhs {
+                Value::Bool(value) => Ok(Value::Bool(!value)),
+                Value::I8(value) => Ok(Value::I8(!value)),
+                Value::I32(value) => Ok(Value::I32(!value)),
+                Value::I64(value) => Ok(Value::I64(!value)),
+                Value::U8(value) => Ok(Value::U8(!value)),
+                Value::U32(value) => Ok(Value::U32(!value)),
+                Value::U64(value) => Ok(Value::U64(!value)),
+                value => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InterpreterError::InvalidValueForUnary { value, location, operator: "not" })
+                }
+            },
+            crate::UnaryOp::MutableReference => Ok(Value::Pointer(Shared::new(rhs))),
+            crate::UnaryOp::Dereference { implicitly_added: _ } => match rhs {
+                Value::Pointer(element) => Ok(element.borrow().clone()),
+                value => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InterpreterError::NonPointerDereferenced { value, location })
+                }
+            },
+        }
+    }
+
+    fn evaluate_infix(&mut self, infix: HirInfixExpression, id: ExprId) -> IResult<Value> {
+        let lhs = self.evaluate(infix.lhs)?;
+        let rhs = self.evaluate(infix.rhs)?;
+
+        // TODO: Need to account for operator overloading
+        assert!(
+            self.interner.get_selected_impl_for_expression(id).is_none(),
+            "Operator overloading is unimplemented in the interpreter"
+        );
+
+        use InterpreterError::InvalidValuesForBinary;
+        match infix.operator.kind {
+            BinaryOpKind::Add => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs + rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs + rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs + rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs + rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs + rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs + rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs + rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "+" })
+                }
+            },
+            BinaryOpKind::Subtract => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs - rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs - rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs - rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs - rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs - rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs - rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs - rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "-" })
+                }
+            },
+            BinaryOpKind::Multiply => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs * rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs * rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs * rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs * rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs * rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs * rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs * rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "*" })
+                }
+            },
+            BinaryOpKind::Divide => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs / rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs / rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs / rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs / rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs / rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs / rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs / rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "/" })
+                }
+            },
+            BinaryOpKind::Equal => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "==" })
+                }
+            },
+            BinaryOpKind::NotEqual => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "!=" })
+                }
+            },
+            BinaryOpKind::Less => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "<" })
+                }
+            },
+            BinaryOpKind::LessEqual => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "<=" })
+                }
+            },
+            BinaryOpKind::Greater => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: ">" })
+                }
+            },
+            BinaryOpKind::GreaterEqual => match (lhs, rhs) {
+                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: ">=" })
+                }
+            },
+            BinaryOpKind::And => match (lhs, rhs) {
+                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs & rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs & rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs & rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs & rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs & rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs & rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs & rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "&" })
+                }
+            },
+            BinaryOpKind::Or => match (lhs, rhs) {
+                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs | rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs | rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs | rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs | rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs | rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs | rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs | rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "|" })
+                }
+            },
+            BinaryOpKind::Xor => match (lhs, rhs) {
+                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs ^ rhs)),
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs ^ rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs ^ rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs ^ rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs ^ rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs ^ rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs ^ rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "^" })
+                }
+            },
+            BinaryOpKind::ShiftRight => match (lhs, rhs) {
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs >> rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs >> rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs >> rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs >> rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs >> rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs >> rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: ">>" })
+                }
+            },
+            BinaryOpKind::ShiftLeft => match (lhs, rhs) {
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs << rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs << rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs << rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs << rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs << rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs << rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "<<" })
+                }
+            },
+            BinaryOpKind::Modulo => match (lhs, rhs) {
+                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs % rhs)),
+                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs % rhs)),
+                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs % rhs)),
+                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs % rhs)),
+                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs % rhs)),
+                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs % rhs)),
+                (lhs, rhs) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InvalidValuesForBinary { lhs, rhs, location, operator: "%" })
+                }
+            },
+        }
+    }
+
+    fn evaluate_index(&mut self, index: HirIndexExpression, id: ExprId) -> IResult<Value> {
+        let array = self.evaluate(index.collection)?;
+        let index = self.evaluate(index.index)?;
+
+        let location = self.interner.expr_location(&id);
+        let (array, index) = self.bounds_check(array, index, location)?;
+
+        Ok(array[index].clone())
+    }
+
+    /// Bounds check the given array and index pair.
+    /// This will also ensure the given arguments are in fact an array and integer.
+    fn bounds_check(
+        &self,
+        array: Value,
+        index: Value,
+        location: Location,
+    ) -> IResult<(Vector<Value>, usize)> {
+        let collection = match array {
+            Value::Array(array, _) => array,
+            Value::Slice(array, _) => array,
+            value => {
+                return Err(InterpreterError::NonArrayIndexed { value, location });
+            }
+        };
+
+        let index = match index {
+            Value::Field(value) => {
+                value.try_to_u64().expect("index could not fit into u64") as usize
+            }
+            Value::I8(value) => value as usize,
+            Value::I32(value) => value as usize,
+            Value::I64(value) => value as usize,
+            Value::U8(value) => value as usize,
+            Value::U32(value) => value as usize,
+            Value::U64(value) => value as usize,
+            value => {
+                return Err(InterpreterError::NonIntegerUsedAsIndex { value, location });
+            }
+        };
+
+        if index >= collection.len() {
+            use InterpreterError::IndexOutOfBounds;
+            return Err(IndexOutOfBounds { index, location, length: collection.len() });
+        }
+
+        Ok((collection, index))
+    }
+
+    fn evaluate_constructor(
+        &mut self,
+        constructor: HirConstructorExpression,
+        id: ExprId,
+    ) -> IResult<Value> {
+        let fields = constructor
+            .fields
+            .into_iter()
+            .map(|(name, expr)| {
+                let field_value = self.evaluate(expr)?;
+                Ok((Rc::new(name.0.contents), field_value))
+            })
+            .collect::<Result<_, _>>()?;
+
+        let typ = self.interner.id_type(id);
+        Ok(Value::Struct(fields, typ))
+    }
+
+    fn evaluate_access(&mut self, access: HirMemberAccess, id: ExprId) -> IResult<Value> {
+        let (fields, struct_type) = match self.evaluate(access.lhs)? {
+            Value::Struct(fields, typ) => (fields, typ),
+            value => {
+                let location = self.interner.expr_location(&id);
+                return Err(InterpreterError::NonTupleOrStructInMemberAccess { value, location });
+            }
+        };
+
+        fields.get(&access.rhs.0.contents).cloned().ok_or_else(|| {
+            let location = self.interner.expr_location(&id);
+            let value = Value::Struct(fields, struct_type);
+            let field_name = access.rhs.0.contents;
+            InterpreterError::ExpectedStructToHaveField { value, field_name, location }
+        })
+    }
+
+    fn evaluate_call(&mut self, call: HirCallExpression, id: ExprId) -> IResult<Value> {
+        let function = self.evaluate(call.func)?;
+        let arguments = try_vecmap(call.arguments, |arg| {
+            Ok((self.evaluate(arg)?, self.interner.expr_location(&arg)))
+        })?;
+        let location = self.interner.expr_location(&id);
+
+        match function {
+            Value::Function(function_id, _) => self.call_function(function_id, arguments, location),
+            Value::Closure(closure, env, _) => self.call_closure(closure, env, arguments, location),
+            value => Err(InterpreterError::NonFunctionCalled { value, location }),
+        }
+    }
+
+    fn evaluate_method_call(
+        &mut self,
+        call: HirMethodCallExpression,
+        id: ExprId,
+    ) -> IResult<Value> {
+        let object = self.evaluate(call.object)?;
+        let arguments = try_vecmap(call.arguments, |arg| {
+            Ok((self.evaluate(arg)?, self.interner.expr_location(&arg)))
+        })?;
+        let location = self.interner.expr_location(&id);
+
+        let typ = object.get_type().follow_bindings();
+        let method_name = &call.method.0.contents;
+
+        // TODO: Traits
+        let method = match &typ {
+            Type::Struct(struct_def, _) => {
+                self.interner.lookup_method(&typ, struct_def.borrow().id, method_name, false)
+            }
+            _ => self.interner.lookup_primitive_method(&typ, method_name),
+        };
+
+        if let Some(method) = method {
+            self.call_function(method, arguments, location)
+        } else {
+            Err(InterpreterError::NoMethodFound { object, typ, location })
+        }
+    }
+
+    fn evaluate_cast(&mut self, cast: HirCastExpression, id: ExprId) -> IResult<Value> {
+        macro_rules! signed_int_to_field {
+            ($x:expr) => {{
+                // Need to convert the signed integer to an i128 before
+                // we negate it to preserve the MIN value.
+                let mut value = $x as i128;
+                let is_negative = value < 0;
+                if is_negative {
+                    value = -value;
+                }
+                ((value as u128).into(), is_negative)
+            }};
+        }
+
+        let (mut lhs, lhs_is_negative) = match self.evaluate(cast.lhs)? {
+            Value::Field(value) => (value, false),
+            Value::U8(value) => ((value as u128).into(), false),
+            Value::U32(value) => ((value as u128).into(), false),
+            Value::U64(value) => ((value as u128).into(), false),
+            Value::I8(value) => signed_int_to_field!(value),
+            Value::I32(value) => signed_int_to_field!(value),
+            Value::I64(value) => signed_int_to_field!(value),
+            Value::Bool(value) => {
+                (if value { FieldElement::one() } else { FieldElement::zero() }, false)
+            }
+            value => {
+                let location = self.interner.expr_location(&id);
+                return Err(InterpreterError::NonNumericCasted { value, location });
+            }
+        };
+
+        macro_rules! cast_to_int {
+            ($x:expr, $method:ident, $typ:ty, $f:ident) => {{
+                let mut value = $x.$method() as $typ;
+                if lhs_is_negative {
+                    value = 0 - value;
+                }
+                Ok(Value::$f(value))
+            }};
+        }
+
+        // Now actually cast the lhs, bit casting and wrapping as necessary
+        match cast.r#type.follow_bindings() {
+            Type::FieldElement => {
+                if lhs_is_negative {
+                    lhs = FieldElement::zero() - lhs;
+                }
+                Ok(Value::Field(lhs))
+            }
+            Type::Integer(sign, bit_size) => match (sign, bit_size) {
+                (Signedness::Unsigned, IntegerBitSize::One) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
+                }
+                (Signedness::Unsigned, IntegerBitSize::Eight) => cast_to_int!(lhs, to_u128, u8, U8),
+                (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
+                    cast_to_int!(lhs, to_u128, u32, U32)
+                }
+                (Signedness::Unsigned, IntegerBitSize::SixtyFour) => {
+                    cast_to_int!(lhs, to_u128, u64, U64)
+                }
+                (Signedness::Signed, IntegerBitSize::One) => {
+                    let location = self.interner.expr_location(&id);
+                    Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
+                }
+                (Signedness::Signed, IntegerBitSize::Eight) => cast_to_int!(lhs, to_i128, i8, I8),
+                (Signedness::Signed, IntegerBitSize::ThirtyTwo) => {
+                    cast_to_int!(lhs, to_i128, i32, I32)
+                }
+                (Signedness::Signed, IntegerBitSize::SixtyFour) => {
+                    cast_to_int!(lhs, to_i128, i64, I64)
+                }
+            },
+            Type::Bool => Ok(Value::Bool(!lhs.is_zero() || lhs_is_negative)),
+            typ => {
+                let location = self.interner.expr_location(&id);
+                Err(InterpreterError::CastToNonNumericType { typ, location })
+            }
+        }
+    }
+
+    fn evaluate_if(&mut self, if_: HirIfExpression, id: ExprId) -> IResult<Value> {
+        let condition = match self.evaluate(if_.condition)? {
+            Value::Bool(value) => value,
+            value => {
+                let location = self.interner.expr_location(&id);
+                return Err(InterpreterError::NonBoolUsedInIf { value, location });
+            }
+        };
+
+        self.push_scope();
+
+        let result = if condition {
+            if if_.alternative.is_some() {
+                self.evaluate(if_.consequence)
+            } else {
+                self.evaluate(if_.consequence)?;
+                Ok(Value::Unit)
+            }
+        } else {
+            match if_.alternative {
+                Some(alternative) => self.evaluate(alternative),
+                None => Ok(Value::Unit),
+            }
+        };
+
+        self.pop_scope();
+        result
+    }
+
+    fn evaluate_tuple(&mut self, tuple: Vec<ExprId>) -> IResult<Value> {
+        let fields = try_vecmap(tuple, |field| self.evaluate(field))?;
+        Ok(Value::Tuple(fields))
+    }
+
+    fn evaluate_lambda(&mut self, lambda: HirLambda, id: ExprId) -> IResult<Value> {
+        let location = self.interner.expr_location(&id);
+        let environment =
+            try_vecmap(&lambda.captures, |capture| self.lookup_id(capture.ident.id, location))?;
+
+        let typ = self.interner.id_type(id);
+        Ok(Value::Closure(lambda, environment, typ))
+    }
+
+    fn evaluate_statement(&mut self, statement: StmtId) -> IResult<Value> {
+        match self.interner.statement(&statement) {
+            HirStatement::Let(let_) => self.evaluate_let(let_),
+            HirStatement::Constrain(constrain) => self.evaluate_constrain(constrain),
+            HirStatement::Assign(assign) => self.evaluate_assign(assign),
+            HirStatement::For(for_) => self.evaluate_for(for_),
+            HirStatement::Break => self.evaluate_break(),
+            HirStatement::Continue => self.evaluate_continue(),
+            HirStatement::Expression(expression) => self.evaluate(expression),
+            HirStatement::Semi(expression) => {
+                self.evaluate(expression)?;
+                Ok(Value::Unit)
+            }
+            HirStatement::Error => {
+                let location = self.interner.id_location(statement);
+                Err(InterpreterError::ErrorNodeEncountered { location })
+            }
+        }
+    }
+
+    fn evaluate_let(&mut self, let_: HirLetStatement) -> IResult<Value> {
+        let rhs = self.evaluate(let_.expression)?;
+        let location = self.interner.expr_location(&let_.expression);
+        self.define_pattern(&let_.pattern, &let_.r#type, rhs, location)?;
+        Ok(Value::Unit)
+    }
+
+    fn evaluate_constrain(&mut self, constrain: HirConstrainStatement) -> IResult<Value> {
+        match self.evaluate(constrain.0)? {
+            Value::Bool(true) => Ok(Value::Unit),
+            Value::Bool(false) => {
+                let location = self.interner.expr_location(&constrain.0);
+                let message = constrain.2.and_then(|expr| self.evaluate(expr).ok());
+                Err(InterpreterError::FailingConstraint { location, message })
+            }
+            value => {
+                let location = self.interner.expr_location(&constrain.0);
+                Err(InterpreterError::NonBoolUsedInConstrain { value, location })
+            }
+        }
+    }
+
+    fn evaluate_assign(&mut self, assign: HirAssignStatement) -> IResult<Value> {
+        let rhs = self.evaluate(assign.expression)?;
+        self.store_lvalue(assign.lvalue, rhs)?;
+        Ok(Value::Unit)
+    }
+
+    fn store_lvalue(&mut self, lvalue: HirLValue, rhs: Value) -> IResult<()> {
+        match lvalue {
+            HirLValue::Ident(ident, typ) => {
+                self.checked_mutate(ident.id, &typ, rhs, ident.location)
+            }
+            HirLValue::Dereference { lvalue, element_type: _, location } => {
+                match self.evaluate_lvalue(&lvalue)? {
+                    Value::Pointer(value) => {
+                        *value.borrow_mut() = rhs;
+                        Ok(())
+                    }
+                    value => Err(InterpreterError::NonPointerDereferenced { value, location }),
+                }
+            }
+            HirLValue::MemberAccess { object, field_name, field_index, typ: _, location } => {
+                let index = field_index.expect("The field index should be set after type checking");
+                match self.evaluate_lvalue(&object)? {
+                    Value::Tuple(mut fields) => {
+                        fields[index] = rhs;
+                        self.store_lvalue(*object, Value::Tuple(fields))
+                    }
+                    Value::Struct(mut fields, typ) => {
+                        fields.insert(Rc::new(field_name.0.contents), rhs);
+                        self.store_lvalue(*object, Value::Struct(fields, typ))
+                    }
+                    value => {
+                        Err(InterpreterError::NonTupleOrStructInMemberAccess { value, location })
+                    }
+                }
+            }
+            HirLValue::Index { array, index, typ: _, location } => {
+                let array_value = self.evaluate_lvalue(&array)?;
+                let index = self.evaluate(index)?;
+
+                let constructor = match &array_value {
+                    Value::Array(..) => Value::Array,
+                    _ => Value::Slice,
+                };
+
+                let typ = array_value.get_type().into_owned();
+                let (elements, index) = self.bounds_check(array_value, index, location)?;
+
+                let new_array = constructor(elements.update(index, rhs), typ);
+                self.store_lvalue(*array, new_array)
+            }
+        }
+    }
+
+    fn evaluate_lvalue(&mut self, lvalue: &HirLValue) -> IResult<Value> {
+        match lvalue {
+            HirLValue::Ident(ident, _) => self.lookup(ident),
+            HirLValue::Dereference { lvalue, element_type: _, location } => {
+                match self.evaluate_lvalue(lvalue)? {
+                    Value::Pointer(value) => Ok(value.borrow().clone()),
+                    value => {
+                        Err(InterpreterError::NonPointerDereferenced { value, location: *location })
+                    }
+                }
+            }
+            HirLValue::MemberAccess { object, field_name, field_index, typ: _, location } => {
+                let index = field_index.expect("The field index should be set after type checking");
+
+                match self.evaluate_lvalue(object)? {
+                    Value::Tuple(mut values) => Ok(values.swap_remove(index)),
+                    Value::Struct(fields, _) => Ok(fields[&field_name.0.contents].clone()),
+                    value => Err(InterpreterError::NonTupleOrStructInMemberAccess {
+                        value,
+                        location: *location,
+                    }),
+                }
+            }
+            HirLValue::Index { array, index, typ: _, location } => {
+                let array = self.evaluate_lvalue(array)?;
+                let index = self.evaluate(*index)?;
+                let (elements, index) = self.bounds_check(array, index, *location)?;
+                Ok(elements[index].clone())
+            }
+        }
+    }
+
+    fn evaluate_for(&mut self, for_: HirForStatement) -> IResult<Value> {
+        // i128 can store all values from i8 - u64
+        let get_index = |this: &mut Self, expr| -> IResult<(_, fn(_) -> _)> {
+            match this.evaluate(expr)? {
+                Value::I8(value) => Ok((value as i128, |i| Value::I8(i as i8))),
+                Value::I32(value) => Ok((value as i128, |i| Value::I32(i as i32))),
+                Value::I64(value) => Ok((value as i128, |i| Value::I64(i as i64))),
+                Value::U8(value) => Ok((value as i128, |i| Value::U8(i as u8))),
+                Value::U32(value) => Ok((value as i128, |i| Value::U32(i as u32))),
+                Value::U64(value) => Ok((value as i128, |i| Value::U64(i as u64))),
+                value => {
+                    let location = this.interner.expr_location(&expr);
+                    Err(InterpreterError::NonIntegerUsedInLoop { value, location })
+                }
+            }
+        };
+
+        let (start, make_value) = get_index(self, for_.start_range)?;
+        let (end, _) = get_index(self, for_.end_range)?;
+        let was_in_loop = std::mem::replace(&mut self.in_loop, true);
+
+        for i in start..end {
+            self.push_scope();
+            self.current_scope_mut().insert(for_.identifier.id, make_value(i));
+
+            match self.evaluate(for_.block) {
+                Ok(_) => (),
+                Err(InterpreterError::Break) => break,
+                Err(InterpreterError::Continue) => continue,
+                Err(other) => return Err(other),
+            }
+            self.pop_scope();
+        }
+
+        self.in_loop = was_in_loop;
+        Ok(Value::Unit)
+    }
+
+    fn evaluate_break(&mut self) -> IResult<Value> {
+        if self.in_loop {
+            Err(InterpreterError::Break)
+        } else {
+            Err(InterpreterError::BreakNotInLoop)
+        }
+    }
+
+    fn evaluate_continue(&mut self) -> IResult<Value> {
+        if self.in_loop {
+            Err(InterpreterError::Continue)
+        } else {
+            Err(InterpreterError::ContinueNotInLoop)
+        }
+    }
+}
+
+impl Value {
+    fn get_type(&self) -> Cow<Type> {
+        Cow::Owned(match self {
+            Value::Unit => Type::Unit,
+            Value::Bool(_) => Type::Bool,
+            Value::Field(_) => Type::FieldElement,
+            Value::I8(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Eight),
+            Value::I32(_) => Type::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo),
+            Value::I64(_) => Type::Integer(Signedness::Signed, IntegerBitSize::SixtyFour),
+            Value::U8(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+            Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
+            Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
+            Value::String(value) => {
+                let length = Type::Constant(value.len() as u64);
+                Type::String(Box::new(length))
+            }
+            Value::Function(_, typ) => return Cow::Borrowed(typ),
+            Value::Closure(_, _, typ) => return Cow::Borrowed(typ),
+            Value::Tuple(fields) => {
+                Type::Tuple(vecmap(fields, |field| field.get_type().into_owned()))
+            }
+            Value::Struct(_, typ) => return Cow::Borrowed(typ),
+            Value::Array(_, typ) => return Cow::Borrowed(typ),
+            Value::Slice(_, typ) => return Cow::Borrowed(typ),
+            Value::Code(_) => Type::Code,
+            Value::Pointer(element) => {
+                let element = element.borrow().get_type().into_owned();
+                Type::MutableReference(Box::new(element))
+            }
+        })
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
index 91621c857cf..83aaddaa405 100644
--- a/compiler/noirc_frontend/src/hir/comptime/mod.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -1 +1,3 @@
 mod hir_to_ast;
+mod interpreter;
+mod tests;
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
new file mode 100644
index 00000000000..016e7079886
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -0,0 +1,166 @@
+#![cfg(test)]
+
+use noirc_errors::Location;
+
+use super::interpreter::{Interpreter, InterpreterError, Value};
+use crate::hir::type_check::test::type_check_src_code;
+
+fn interpret_helper(src: &str, func_namespace: Vec<String>) -> Result<Value, InterpreterError> {
+    let (mut interner, main_id) = type_check_src_code(src, func_namespace);
+    let mut interpreter = Interpreter::new(&mut interner);
+
+    let no_location = Location::dummy();
+    interpreter.call_function(main_id, Vec::new(), no_location)
+}
+
+fn interpret(src: &str, func_namespace: Vec<String>) -> Value {
+    interpret_helper(src, func_namespace).unwrap_or_else(|error| {
+        panic!("Expected interpreter to exit successfully, but found {error:?}")
+    })
+}
+
+fn interpret_expect_error(src: &str, func_namespace: Vec<String>) -> InterpreterError {
+    interpret_helper(src, func_namespace).expect_err("Expected interpreter to error")
+}
+
+#[test]
+fn interpreter_works() {
+    let program = "fn main() -> pub Field { 3 }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::Field(3u128.into()));
+}
+
+#[test]
+fn mutation_works() {
+    let program = "fn main() -> pub i8 {
+        let mut x = 3;
+        x = 4;
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::I8(4));
+}
+
+#[test]
+fn mutating_references() {
+    let program = "fn main() -> pub i32 {
+        let x = &mut 3;
+        *x = 4;
+        *x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::I32(4));
+}
+
+#[test]
+fn mutating_mutable_references() {
+    let program = "fn main() -> pub i64 {
+        let mut x = &mut 3;
+        *x = 4;
+        *x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::I64(4));
+}
+
+#[test]
+fn mutating_arrays() {
+    let program = "fn main() -> pub u8 {
+        let mut a1 = [1, 2, 3, 4];
+        a1[1] = 22;
+        a1[1]
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U8(22));
+}
+
+#[test]
+fn for_loop() {
+    let program = "fn main() -> pub u8 {
+        let mut x = 0;
+        for i in 0 .. 6 {
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U8(15));
+}
+
+#[test]
+fn for_loop_with_break() {
+    let program = "unconstrained fn main() -> pub u32 {
+        let mut x = 0;
+        for i in 0 .. 6 {
+            if i == 4 {
+                break;
+            }
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U32(6));
+}
+
+#[test]
+fn for_loop_with_continue() {
+    let program = "unconstrained fn main() -> pub u64 {
+        let mut x = 0;
+        for i in 0 .. 6 {
+            if i == 4 {
+                continue;
+            }
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U64(11));
+}
+
+#[test]
+fn assert() {
+    let program = "fn main() {
+        assert(1 == 1);
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::Unit);
+}
+
+#[test]
+fn assert_fail() {
+    let program = "fn main() {
+        assert(1 == 2);
+    }";
+    let result = interpret_expect_error(program, vec!["main".into()]);
+    assert!(matches!(result, InterpreterError::FailingConstraint { .. }));
+}
+
+#[test]
+fn lambda() {
+    let program = "fn main() -> pub u8 {
+        let f = |x: u8| x + 1;
+        f(1)
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert!(matches!(result, Value::U8(2)));
+}
+
+#[test]
+fn non_deterministic_recursion() {
+    let program = "
+    fn main() -> pub u64 {
+        fib(10)
+    }
+
+    fn fib(x: u64) -> u64 {
+        if x <= 1 {
+            x
+        } else {
+            fib(x - 1) + fib(x - 2)
+        }
+    }";
+    let result = interpret(program, vec!["main".into(), "fib".into()]);
+    assert_eq!(result, Value::U64(55));
+}
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 6fbb3b67546..e3c79e39d31 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -416,6 +416,7 @@ impl<'a> ModCollector<'a> {
                             // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629
                             attributes: crate::token::Attributes::empty(),
                             is_unconstrained: false,
+                            is_comptime: false,
                         };
 
                         let location = Location::new(name.span(), self.file_id);
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 9180201fe17..479f357126a 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -246,6 +246,7 @@ impl<'a> Resolver<'a> {
             name: name.clone(),
             attributes: Attributes::empty(),
             is_unconstrained: false,
+            is_comptime: false,
             visibility: ItemVisibility::Public, // Trait functions are always public
             generics: generics.clone(),
             parameters: vecmap(parameters, |(name, typ)| Param {
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index cdfc19b3a33..f5323cd07de 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -51,8 +51,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     let declared_return_type = meta.return_type().clone();
     let can_ignore_ret = meta.can_ignore_return_type();
 
-    let function_body = interner.function(&func_id);
-    let function_body_id = function_body.as_expr();
+    let function_body_id = &interner.function(&func_id).as_expr();
 
     let mut type_checker = TypeChecker::new(interner);
     type_checker.current_function = Some(func_id);
@@ -424,12 +423,12 @@ impl<'interner> TypeChecker<'interner> {
 // XXX: These tests are all manual currently.
 /// We can either build a test apparatus or pass raw code through the resolver
 #[cfg(test)]
-mod test {
+pub mod test {
     use std::collections::{BTreeMap, HashMap};
     use std::vec;
 
     use fm::FileId;
-    use iter_extended::vecmap;
+    use iter_extended::btree_map;
     use noirc_errors::{Location, Span};
 
     use crate::graph::CrateId;
@@ -601,7 +600,7 @@ mod test {
 
         "#;
 
-        type_check_src_code(src, vec![String::from("main"), String::from("foo")]);
+        type_check_src_code(src, vec![String::from("main")]);
     }
     #[test]
     fn basic_closure() {
@@ -612,7 +611,7 @@ mod test {
             }
         "#;
 
-        type_check_src_code(src, vec![String::from("main"), String::from("foo")]);
+        type_check_src_code(src, vec![String::from("main")]);
     }
 
     #[test]
@@ -672,8 +671,8 @@ mod test {
         }
     }
 
-    fn type_check_src_code(src: &str, func_namespace: Vec<String>) {
-        type_check_src_code_errors_expected(src, func_namespace, 0);
+    pub fn type_check_src_code(src: &str, func_namespace: Vec<String>) -> (NodeInterner, FuncId) {
+        type_check_src_code_errors_expected(src, func_namespace, 0)
     }
 
     // This function assumes that there is only one function and this is the
@@ -682,7 +681,7 @@ mod test {
         src: &str,
         func_namespace: Vec<String>,
         expected_num_type_check_errs: usize,
-    ) {
+    ) -> (NodeInterner, FuncId) {
         let (program, errors) = parse_program(src);
         let mut interner = NodeInterner::default();
         interner.populate_dummy_operator_traits();
@@ -695,14 +694,16 @@ mod test {
             errors
         );
 
-        let main_id = interner.push_test_function_definition("main".into());
+        let func_ids = btree_map(&func_namespace, |name| {
+            (name.to_string(), interner.push_test_function_definition(name.into()))
+        });
 
-        let func_ids =
-            vecmap(&func_namespace, |name| interner.push_test_function_definition(name.into()));
+        let main_id =
+            *func_ids.get("main").unwrap_or_else(|| func_ids.first_key_value().unwrap().1);
 
         let mut path_resolver = TestPathResolver(HashMap::new());
-        for (name, id) in func_namespace.into_iter().zip(func_ids.clone()) {
-            path_resolver.insert_func(name.to_owned(), id);
+        for (name, id) in func_ids.iter() {
+            path_resolver.insert_func(name.to_owned(), *id);
         }
 
         let mut def_maps = BTreeMap::new();
@@ -722,20 +723,24 @@ mod test {
             },
         );
 
-        let func_meta = vecmap(program.into_sorted().functions, |nf| {
+        for nf in program.into_sorted().functions {
             let resolver = Resolver::new(&mut interner, &path_resolver, &def_maps, file);
-            let (hir_func, func_meta, resolver_errors) = resolver.resolve_function(nf, main_id);
-            assert_eq!(resolver_errors, vec![]);
-            (hir_func, func_meta)
-        });
 
-        for ((hir_func, meta), func_id) in func_meta.into_iter().zip(func_ids.clone()) {
-            interner.update_fn(func_id, hir_func);
-            interner.push_fn_meta(meta, func_id);
+            let function_id = *func_ids.get(nf.name()).unwrap();
+            let (hir_func, func_meta, resolver_errors) = resolver.resolve_function(nf, function_id);
+
+            interner.push_fn_meta(func_meta, function_id);
+            interner.update_fn(function_id, hir_func);
+            assert_eq!(resolver_errors, vec![]);
         }
 
         // Type check section
-        let errors = super::type_check_func(&mut interner, func_ids.first().cloned().unwrap());
+        let mut errors = Vec::new();
+
+        for function in func_ids.values() {
+            errors.extend(super::type_check_func(&mut interner, *function));
+        }
+
         assert_eq!(
             errors.len(),
             expected_num_type_check_errs,
@@ -744,5 +749,7 @@ mod test {
             errors.len(),
             errors
         );
+
+        (interner, main_id)
     }
 }
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index c2f6031bf6d..eb4ebf3f913 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -260,7 +260,7 @@ impl HirBlockExpression {
 }
 
 /// A variable captured inside a closure
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct HirCapturedVar {
     pub ident: HirIdent,
 
@@ -274,7 +274,7 @@ pub struct HirCapturedVar {
     pub transitive_capture_index: Option<usize>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct HirLambda {
     pub parameters: Vec<(HirPattern, Type)>,
     pub return_type: Type,
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index a3bbc9445a8..97f4b6a1616 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -24,8 +24,8 @@ impl HirFunction {
         HirFunction(expr_id)
     }
 
-    pub const fn as_expr(&self) -> &ExprId {
-        &self.0
+    pub const fn as_expr(&self) -> ExprId {
+        self.0
     }
 
     pub fn block(&self, interner: &NodeInterner) -> HirBlockExpression {
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 4c9a33d3dc0..37e3651a9b2 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -61,7 +61,7 @@ pub struct HirAssignStatement {
 #[derive(Debug, Clone)]
 pub struct HirConstrainStatement(pub ExprId, pub FileId, pub Option<ExprId>);
 
-#[derive(Debug, Clone, Hash)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum HirPattern {
     Identifier(HirIdent),
     Mutable(Box<HirPattern>, Location),
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 4e779244d30..2cccc18fb09 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -288,7 +288,7 @@ impl<'interner> Monomorphizer<'interner> {
         let modifiers = self.interner.function_modifiers(&f);
         let name = self.interner.function_name(&f).to_owned();
 
-        let body_expr_id = *self.interner.function(&f).as_expr();
+        let body_expr_id = self.interner.function(&f).as_expr();
         let body_return_type = self.interner.id_type(body_expr_id);
         let return_type = match meta.return_type() {
             Type::TraitAsType(..) => &body_return_type,
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 153c7e45d4a..5b375be8d56 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -242,6 +242,8 @@ pub struct FunctionModifiers {
     pub attributes: Attributes,
 
     pub is_unconstrained: bool,
+
+    pub is_comptime: bool,
 }
 
 impl FunctionModifiers {
@@ -254,6 +256,7 @@ impl FunctionModifiers {
             visibility: ItemVisibility::Public,
             attributes: Attributes::empty(),
             is_unconstrained: false,
+            is_comptime: false,
         }
     }
 }
@@ -759,6 +762,7 @@ impl NodeInterner {
             visibility: function.visibility,
             attributes: function.attributes.clone(),
             is_unconstrained: function.is_unconstrained,
+            is_comptime: function.is_comptime,
         };
         self.push_function_definition(id, modifiers, module, location)
     }
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 06e1a958eb1..18f17065038 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -36,6 +36,7 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
                 name,
                 attributes,
                 is_unconstrained: modifiers.0,
+                is_comptime: false, // TODO
                 visibility: modifiers.1,
                 generics,
                 parameters,

From 3d33a33e74c3e7d0fc511059b07f0ef9ddd9b667 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 18 Apr 2024 14:17:41 +0100
Subject: [PATCH 196/416] feat: simplify `BoundedVec::eq` (#4838)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR follows up on #4830 to simplify the implementation based on
discussion in that PR.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/collections/bounded_vec.nr | 37 ++++------------------
 1 file changed, 6 insertions(+), 31 deletions(-)

diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index b18a9e9ec5c..c6a3365a979 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -98,15 +98,12 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
 
 impl<T, MaxLen> Eq for BoundedVec<T, MaxLen> where T: Eq {
     fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {
-        let mut ret = self.len == other.len;
-        let mut exceeded_len = false;
-        for i in 0..MaxLen {
-            exceeded_len |= i == self.len;
-            if !exceeded_len {
-                ret &= self.storage[i] == other.storage[i];
-            }
-        }
-        ret
+        // TODO: https://github.com/noir-lang/noir/issues/4837
+        //
+        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s
+        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.
+        
+        (self.len == other.len) & (self.storage == other.storage)
     }
 }
 
@@ -131,26 +128,4 @@ mod bounded_vec_tests {
 
         assert(bounded_vec1 != bounded_vec2);
     }
-
-    #[test]
-    fn equality_respects_specified_length() {
-        let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();
-        bounded_vec1.push(1);
-
-        // This BoundedVec has an extra value past the end of its specified length,
-        // this should be ignored when checking equality so they are considered equal.
-        let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec { storage: [1, 2, 0], len: 1 };
-
-        assert_eq(bounded_vec1, bounded_vec2);
-
-        // Pushing another entry onto `bounded_vec1` to make the underlying arrays equal should
-        // result in the `BoundedVec`s being unequal as their lengths are different.
-        bounded_vec1.push(2);
-
-        assert(bounded_vec1 != bounded_vec2);
-
-        bounded_vec2.push(2);
-
-        assert_eq(bounded_vec1, bounded_vec2);
-    }
 }

From d5028a613e5a65ad1286dd20ce0fb0313f19f6ee Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 18 Apr 2024 16:56:48 +0100
Subject: [PATCH 197/416] feat!: reserve keyword `super` (#4836)

# Description

## Problem\*

## Summary\*

This PR reserves the keyword `super` in prep for #4835

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/lexer/token.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 86f26fd1c97..b4b785f2c81 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -839,6 +839,7 @@ pub enum Keyword {
     ReturnData,
     String,
     Struct,
+    Super,
     Trait,
     Type,
     Unchecked,
@@ -883,6 +884,7 @@ impl fmt::Display for Keyword {
             Keyword::ReturnData => write!(f, "return_data"),
             Keyword::String => write!(f, "str"),
             Keyword::Struct => write!(f, "struct"),
+            Keyword::Super => write!(f, "super"),
             Keyword::Trait => write!(f, "trait"),
             Keyword::Type => write!(f, "type"),
             Keyword::Unchecked => write!(f, "unchecked"),
@@ -930,6 +932,7 @@ impl Keyword {
             "return_data" => Keyword::ReturnData,
             "str" => Keyword::String,
             "struct" => Keyword::Struct,
+            "super" => Keyword::Super,
             "trait" => Keyword::Trait,
             "type" => Keyword::Type,
             "unchecked" => Keyword::Unchecked,

From 8e39706cbb51f27b42fbe851aaa6a67070d07c74 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 18 Apr 2024 13:24:08 -0400
Subject: [PATCH 198/416] chore!: Add `as_array` and remove `_slice` variants
 of hash functions (#4675)

# Description

## Problem\*

Resolves an issue raised in a slack thread:

```rs
let slice1 = &[1, 2, 3];
let slice2 = slice1.pop_back().0.push_back(3);

assert(slice1 == slice2); // fails
```

## Summary\*

Removes `_slice` functions from the stdlib and adds `as_array` method to
convert a slice to an array.

## Additional Context

Currently failing because the pedersen hasher uses the pedersen_slice
variant.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/noir/concepts/data_types/slices.mdx | 25 ++++++
 .../standard_library/containers/hashmap.md    |  5 +-
 .../cryptographic_primitives/hashes.mdx       | 57 +------------
 noir_stdlib/src/hash.nr                       | 81 ++++---------------
 noir_stdlib/src/hash/mimc.nr                  | 13 ++-
 noir_stdlib/src/hash/pedersen.nr              | 24 ------
 noir_stdlib/src/hash/poseidon.nr              | 40 +++++----
 noir_stdlib/src/hash/poseidon2.nr             | 15 ++--
 noir_stdlib/src/slice.nr                      | 10 +++
 .../hashmap_load_factor/src/main.nr           |  4 +-
 .../execution_success/eddsa/src/main.nr       |  4 -
 .../execution_success/hashmap/src/main.nr     | 26 +++---
 .../regression_sha256_slice/Nargo.toml        |  7 --
 .../regression_sha256_slice/Prover.toml       |  1 -
 .../regression_sha256_slice/src/main.nr       | 12 ---
 15 files changed, 99 insertions(+), 225 deletions(-)
 delete mode 100644 noir_stdlib/src/hash/pedersen.nr
 delete mode 100644 test_programs/execution_success/regression_sha256_slice/Nargo.toml
 delete mode 100644 test_programs/execution_success/regression_sha256_slice/Prover.toml
 delete mode 100644 test_programs/execution_success/regression_sha256_slice/src/main.nr

diff --git a/docs/docs/noir/concepts/data_types/slices.mdx b/docs/docs/noir/concepts/data_types/slices.mdx
index 828faf4a8f8..4eccc677b80 100644
--- a/docs/docs/noir/concepts/data_types/slices.mdx
+++ b/docs/docs/noir/concepts/data_types/slices.mdx
@@ -168,3 +168,28 @@ fn main() {
     assert(slice.len() == 2);
 }
 ```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<N>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
diff --git a/docs/docs/noir/standard_library/containers/hashmap.md b/docs/docs/noir/standard_library/containers/hashmap.md
index 093b6d38d11..2b9f4895722 100644
--- a/docs/docs/noir/standard_library/containers/hashmap.md
+++ b/docs/docs/noir/standard_library/containers/hashmap.md
@@ -20,8 +20,9 @@ Example:
 
 ```rust
 // Create a mapping from Fields to u32s with a maximum length of 12
-// using a pedersen hash
-let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Pedersen>> = HashMap::default();
+// using a poseidon2 hasher
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
 
 map.insert(1, 2);
 map.insert(3, 4);
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
index f98c90a97c8..7329880c7a7 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -13,7 +13,6 @@ import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
 ## sha256
 
 Given an array of bytes, returns the resulting sha256 hash.
-See sha256_slice for a version that works directly on slices.
 
 #include_code sha256 noir_stdlib/src/hash.nr rust
 
@@ -28,18 +27,9 @@ fn main() {
 
 <BlackBoxInfo />
 
-## sha256_slice
-
-A version of sha256 specialized to slices:
-
-#include_code sha256_slice noir_stdlib/src/hash.nr rust
-
-<BlackBoxInfo />
-
 ## blake2s
 
 Given an array of bytes, returns an array with the Blake2 hash
-See blake2s_slice for a version that works directly on slices.
 
 #include_code blake2s noir_stdlib/src/hash.nr rust
 
@@ -54,18 +44,9 @@ fn main() {
 
 <BlackBoxInfo />
 
-## blake2s_slice
-
-A version of blake2s specialized to slices:
-
-#include_code blake2s_slice noir_stdlib/src/hash.nr rust
-
-<BlackBoxInfo />
-
 ## blake3
 
 Given an array of bytes, returns an array with the Blake3 hash
-See blake3_slice for a version that works directly on slices.
 
 #include_code blake3 noir_stdlib/src/hash.nr rust
 
@@ -80,18 +61,9 @@ fn main() {
 
 <BlackBoxInfo />
 
-## blake3_slice
-
-A version of blake3 specialized to slices:
-
-#include_code blake3_slice noir_stdlib/src/hash.nr rust
-
-<BlackBoxInfo />
-
 ## pedersen_hash
 
 Given an array of Fields, returns the Pedersen hash.
-See pedersen_hash_slice for a version that works directly on slices.
 
 #include_code pedersen_hash noir_stdlib/src/hash.nr rust
 
@@ -101,18 +73,9 @@ example:
 
 <BlackBoxInfo />
 
-## pedersen_hash_slice
-
-Given a slice of Fields, returns the Pedersen hash.
-
-#include_code pedersen_hash_slice noir_stdlib/src/hash.nr rust
-
-<BlackBoxInfo />
-
 ## pedersen_commitment
 
 Given an array of Fields, returns the Pedersen commitment.
-See pedersen_commitment_slice for a version that works directly on slices.
 
 #include_code pedersen_commitment noir_stdlib/src/hash.nr rust
 
@@ -122,20 +85,11 @@ example:
 
 <BlackBoxInfo />
 
-## pedersen_commitment_slice
-
-Given a slice of Fields, returns the Pedersen commitment.
-
-#include_code pedersen_commitment_slice noir_stdlib/src/hash.nr rust
-
-<BlackBoxInfo />
-
 ## keccak256
 
 Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
 32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
-`message_size` bytes of the input. See keccak256_slice for a version that works
-directly on slices.
+`message_size` bytes of the input.
 
 #include_code keccak256 noir_stdlib/src/hash.nr rust
 
@@ -145,15 +99,6 @@ example:
 
 <BlackBoxInfo />
 
-## keccak256_slice
-
-Given a slice of bytes (`u8`), returns the resulting keccak hash as an array of
-32 bytes (`[u8; 32]`).
-
-#include_code keccak256_slice noir_stdlib/src/hash.nr rust
-
-<BlackBoxInfo />
-
 ## poseidon
 
 Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 1a61b5e084e..26a9fa6c2c0 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -1,7 +1,6 @@
 mod poseidon;
 mod mimc;
 mod poseidon2;
-mod pedersen;
 
 use crate::default::Default;
 use crate::uint128::U128;
@@ -12,36 +11,18 @@ pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:sha256
 {}
 
-#[foreign(sha256)]
-// docs:start:sha256_slice
-pub fn sha256_slice(input: [u8]) -> [u8; 32]
-// docs:end:sha256_slice
-{}
-
 #[foreign(blake2s)]
 // docs:start:blake2s
 pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake2s
 {}
 
-#[foreign(blake2s)]
-// docs:start:blake2s_slice
-pub fn blake2s_slice(input: [u8]) -> [u8; 32]
-// docs:end:blake2s_slice
-{}
-
 #[foreign(blake3)]
 // docs:start:blake3
 pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake3
 {}
 
-#[foreign(blake3)]
-// docs:start:blake3_slice
-pub fn blake3_slice(input: [u8]) -> [u8; 32]
-// docs:end:blake3_slice
-{}
-
 // docs:start:pedersen_commitment
 struct PedersenPoint {
    x : Field,
@@ -53,28 +34,14 @@ pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
     pedersen_commitment_with_separator(input, 0)
 }
 
-// docs:start:pedersen_commitment_slice
-pub fn pedersen_commitment_slice(input: [Field]) -> PedersenPoint {
-    pedersen_commitment_with_separator_slice(input, 0)
-}
-// docs:end:pedersen_commitment_slice
-
 #[foreign(pedersen_commitment)]
 pub fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
 
-#[foreign(pedersen_commitment)]
-pub fn __pedersen_commitment_with_separator_slice(input: [Field], separator: u32) -> [Field; 2] {}
-
 pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> PedersenPoint {
     let values = __pedersen_commitment_with_separator(input, separator);
     PedersenPoint { x: values[0], y: values[1] }
 }
 
-pub fn pedersen_commitment_with_separator_slice(input: [Field], separator: u32) -> PedersenPoint {
-    let values = __pedersen_commitment_with_separator_slice(input, separator);
-    PedersenPoint { x: values[0], y: values[1] }
-}
-
 // docs:start:pedersen_hash
 pub fn pedersen_hash<N>(input: [Field; N]) -> Field
 // docs:end:pedersen_hash
@@ -82,31 +49,18 @@ pub fn pedersen_hash<N>(input: [Field; N]) -> Field
     pedersen_hash_with_separator(input, 0)
 }
 
-// docs:start:pedersen_hash_slice
-pub fn pedersen_hash_slice(input: [Field]) -> Field
-// docs:end:pedersen_hash_slice
-{
-    pedersen_hash_with_separator_slice(input, 0)
-}
-
 #[foreign(pedersen_hash)]
 pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {}
 
-#[foreign(pedersen_hash)]
-pub fn pedersen_hash_with_separator_slice(input: [Field], separator: u32) -> Field {}
-
 pub fn hash_to_field(inputs: [Field]) -> Field {
-    let mut inputs_as_bytes = &[];
+    let mut sum = 0;
 
     for input in inputs {
-        let input_bytes = input.to_le_bytes(32);
-        for i in 0..32 {
-            inputs_as_bytes = inputs_as_bytes.push_back(input_bytes[i]);
-        }
+        let input_bytes: [u8; 32] = input.to_le_bytes(32).as_array();
+        sum += crate::field::bytes32_to_field(blake2s(input_bytes));
     }
 
-    let hashed_input = blake2s_slice(inputs_as_bytes);
-    crate::field::bytes32_to_field(hashed_input)
+    sum
 }
 
 #[foreign(keccak256)]
@@ -115,12 +69,6 @@ pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
 // docs:end:keccak256
 {}
 
-#[foreign(keccak256)]
-// docs:start:keccak256_slice
-pub fn keccak256_slice(input: [u8], message_size: u32) -> [u8; 32]
-// docs:end:keccak256_slice
-{}
-
 #[foreign(poseidon2_permutation)]
 pub fn poseidon2_permutation<N>(_input: [Field; N], _state_length: u32) -> [Field; N] {}
 
@@ -140,7 +88,7 @@ trait Hash{
 trait Hasher{
     fn finish(self) -> Field;
     
-    fn write(&mut self, input: [Field]);
+    fn write(&mut self, input: Field);
 }
 
 // BuildHasher is a factory trait, responsible for production of specific Hasher.
@@ -170,49 +118,49 @@ where
 
 impl Hash for Field {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self]);
+        H::write(state, self);
     }
 }
 
 impl Hash for u8 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
 impl Hash for u32 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
 impl Hash for u64 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
 impl Hash for i8 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
 impl Hash for i32 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
 impl Hash for i64 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
 impl Hash for bool {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self as Field]);
+        H::write(state, self as Field);
     }
 }
 
@@ -222,7 +170,8 @@ impl Hash for () {
 
 impl Hash for U128 {
     fn hash<H>(self, state: &mut H) where H: Hasher{
-        H::write(state, &[self.lo as Field, self.hi as Field]);
+        H::write(state, self.lo as Field);
+        H::write(state, self.hi as Field);
     }
 }
 
diff --git a/noir_stdlib/src/hash/mimc.nr b/noir_stdlib/src/hash/mimc.nr
index 1fb53701013..6c5502c2fbf 100644
--- a/noir_stdlib/src/hash/mimc.nr
+++ b/noir_stdlib/src/hash/mimc.nr
@@ -126,9 +126,8 @@ pub fn mimc_bn254<N>(array: [Field; N]) -> Field {
     r
 }
 
-struct MimcHasher{
+struct MimcHasher {
     _state: [Field],
-    _len: u64,
 }
 
 impl Hasher for MimcHasher {
@@ -136,24 +135,22 @@ impl Hasher for MimcHasher {
     fn finish(self) -> Field {
         let exponent = 7;
         let mut r = 0;
-        for i in 0..self._len {
+        for i in 0..self._state.len() {
             let h = mimc(self._state[i], r, MIMC_BN254_CONSTANTS, exponent);
             r = r + self._state[i] + h;
         }
         r
     }
 
-    fn write(&mut self, input: [Field]){
-        self._state = self._state.append(input);
-        self._len += input.len();
+    fn write(&mut self, input: Field){
+        self._state = self._state.push_back(input);
     }
 }
 
 impl Default for MimcHasher{
     fn default() -> Self{
-        MimcHasher{
+        MimcHasher {
             _state: &[],
-            _len: 0,
         }
     }
 }
diff --git a/noir_stdlib/src/hash/pedersen.nr b/noir_stdlib/src/hash/pedersen.nr
deleted file mode 100644
index ad21e728945..00000000000
--- a/noir_stdlib/src/hash/pedersen.nr
+++ /dev/null
@@ -1,24 +0,0 @@
-use crate::hash::{Hasher, pedersen_hash_slice};
-use crate::default::Default;
-
-struct PedersenHasher{
-    _state: [Field]
-}
-
-impl Hasher for PedersenHasher {
-    fn finish(self) -> Field {
-       pedersen_hash_slice(self._state)
-    }
-
-    fn write(&mut self, input: [Field]){
-        self._state = self._state.append(input);
-    }
-}
-
-impl Default for PedersenHasher{
-    fn default() -> Self{
-        PedersenHasher{
-            _state: &[]
-        }
-    }
-}
diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr
index 85a0802f630..742bfcaf804 100644
--- a/noir_stdlib/src/hash/poseidon.nr
+++ b/noir_stdlib/src/hash/poseidon.nr
@@ -105,66 +105,65 @@ fn apply_matrix<N, M>(a: [Field; M], x: [Field; N]) -> [Field; N] {
 
 struct PoseidonHasher{
     _state: [Field],
-    _len: u64,
 }
 
 impl Hasher for PoseidonHasher {
     #[field(bn254)]
     fn finish(self) -> Field {
         let mut result = 0;
-        assert(self._len < 16);
-        if self._len == 1 {
+        let len = self._state.len();
+        assert(len < 16);
+        if len == 1 {
             result = bn254::hash_1([self._state[0]]);
         } 
-        if self._len == 2 {
+        if len == 2 {
             result = bn254::hash_2([self._state[0],self._state[1]]);
         } 
-        if self._len == 3 {
+        if len == 3 {
             result = bn254::hash_3([self._state[0],self._state[1],self._state[2]]);
         } 
-        if self._len == 4 {
+        if len == 4 {
             result = bn254::hash_4([self._state[0],self._state[1],self._state[2],self._state[3]]);
         } 
-        if self._len == 5 {
+        if len == 5 {
             result = bn254::hash_5([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4]]);
         }
-        if self._len == 6 {
+        if len == 6 {
             result = bn254::hash_6([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5]]);
         }
-        if self._len == 7 {
+        if len == 7 {
             result = bn254::hash_7([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6]]);
         }
-        if self._len == 8 {
+        if len == 8 {
             result = bn254::hash_8([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7]]);
         }
-        if self._len == 9 {
+        if len == 9 {
             result = bn254::hash_9([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8]]);
         }
-        if self._len == 10 {
+        if len == 10 {
             result = bn254::hash_10([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9]]);
         }
-        if self._len == 11 {
+        if len == 11 {
             result = bn254::hash_11([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10]]);
         }
-        if self._len == 12 {
+        if len == 12 {
             result = bn254::hash_12([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11]]);
         }
-        if self._len == 13 {
+        if len == 13 {
             result = bn254::hash_13([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12]]);
         }
-        if self._len == 14 {
+        if len == 14 {
             result = bn254::hash_14([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12], self._state[13]]);
         }
-        if self._len == 15 {
+        if len == 15 {
             result = bn254::hash_15([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12], self._state[13], self._state[14]]);
         }
         
         result
     }
 
-    fn write(&mut self, input: [Field]){
-        self._state = self._state.append(input);
-        self._len += input.len();
+    fn write(&mut self, input: Field){
+        self._state = self._state.push_back(input);
     }
 }
 
@@ -172,7 +171,6 @@ impl Default for PoseidonHasher{
     fn default() -> Self{
         PoseidonHasher{
             _state: &[],
-            _len: 0,
         }
     }
 }
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 12bf373e671..e5a82a596c6 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -117,30 +117,27 @@ impl Poseidon2 {
 
 struct Poseidon2Hasher{
     _state: [Field],
-    _len: u64,
 }
 
 impl Hasher for Poseidon2Hasher {
     fn finish(self) -> Field {
         let iv : Field = (self._state.len() as Field)*18446744073709551616;    // iv = (self._state.len() << 64)
         let mut sponge = Poseidon2::new(iv);
-        for i in 0..self._len {
+        for i in 0..self._state.len() {
             sponge.absorb(self._state[i]);
         }
         sponge.squeeze()
     }
 
-    fn write(&mut self, input: [Field]){
-        self._state = self._state.append(input);
-        self._len += input.len();
+    fn write(&mut self, input: Field){
+        self._state = self._state.push_back(input);
     }
 }
 
-impl Default for Poseidon2Hasher{
-    fn default() -> Self{
-        Poseidon2Hasher{
+impl Default for Poseidon2Hasher {
+    fn default() -> Self {
+        Poseidon2Hasher {
             _state: &[],
-            _len: 0,
         }
     }
 }
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index 164b4f96cf6..ac542a960ed 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -43,4 +43,14 @@ impl<T> [T] {
         }
         self
     }
+
+    pub fn as_array<N>(self) -> [T; N] {
+        assert(self.len() == N);
+
+        let mut array = [crate::unsafe::zeroed(); N];
+        for i in 0..N {
+            array[i] = self[i];
+        }
+        array
+    }
 }
diff --git a/test_programs/execution_failure/hashmap_load_factor/src/main.nr b/test_programs/execution_failure/hashmap_load_factor/src/main.nr
index ade43f898e1..907c3628142 100644
--- a/test_programs/execution_failure/hashmap_load_factor/src/main.nr
+++ b/test_programs/execution_failure/hashmap_load_factor/src/main.nr
@@ -1,6 +1,6 @@
 use dep::std::collections::map::HashMap;
 use dep::std::hash::BuildHasherDefault;
-use dep::std::hash::pedersen::PedersenHasher;
+use dep::std::hash::poseidon2::Poseidon2Hasher;
 
 struct Entry{
     key: Field,
@@ -10,7 +10,7 @@ struct Entry{
 global HASHMAP_CAP = 8;
 global HASHMAP_LEN = 6;
 
-fn allocate_hashmap() -> HashMap<Field, Field, HASHMAP_CAP, BuildHasherDefault<PedersenHasher>> {
+fn allocate_hashmap() -> HashMap<Field, Field, HASHMAP_CAP, BuildHasherDefault<Poseidon2Hasher>> {
     HashMap::default()
 }
 
diff --git a/test_programs/execution_success/eddsa/src/main.nr b/test_programs/execution_success/eddsa/src/main.nr
index fd1a95ee5fb..012c8466f2f 100644
--- a/test_programs/execution_success/eddsa/src/main.nr
+++ b/test_programs/execution_success/eddsa/src/main.nr
@@ -4,7 +4,6 @@ use dep::std::ec::tecurve::affine::Point as TEPoint;
 use dep::std::hash;
 use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify_with_hasher};
 use dep::std::hash::poseidon2::Poseidon2Hasher;
-use dep::std::hash::pedersen::PedersenHasher;
 
 fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
     // Skip this test for non-bn254 backends
@@ -53,8 +52,5 @@ fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
         // Using a different hash should fail
         let mut hasher = Poseidon2Hasher::default();
         assert(!eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher));
-        // Using a different hash should fail
-        let mut hasher = PedersenHasher::default();
-        assert(!eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher));
     }
 }
diff --git a/test_programs/execution_success/hashmap/src/main.nr b/test_programs/execution_success/hashmap/src/main.nr
index 4d2cbd45993..76daa594a89 100644
--- a/test_programs/execution_success/hashmap/src/main.nr
+++ b/test_programs/execution_success/hashmap/src/main.nr
@@ -2,7 +2,7 @@ mod utils;
 
 use dep::std::collections::map::HashMap;
 use dep::std::hash::BuildHasherDefault;
-use dep::std::hash::pedersen::PedersenHasher;
+use dep::std::hash::poseidon2::Poseidon2Hasher;
 use dep::std::cmp::Eq;
 
 use utils::cut;
@@ -25,7 +25,7 @@ global K_CMP = FIELD_CMP;
 global V_CMP = FIELD_CMP;
 global KV_CMP = |a: (K, V), b: (K, V)| a.0.lt(b.0);
 
-global ALLOCATE_HASHMAP = || -> HashMap<K, V, HASHMAP_CAP, BuildHasherDefault<PedersenHasher>> 
+global ALLOCATE_HASHMAP = || -> HashMap<K, V, HASHMAP_CAP, BuildHasherDefault<Poseidon2Hasher>> 
     HashMap::default();
 
 fn main(input: [Entry; HASHMAP_LEN]) {
@@ -194,24 +194,24 @@ fn test_mut_iterators() {
 }
 
 // docs:start:type_alias
-type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>>;
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
 // docs:end:type_alias
 
 /// Tests examples from the stdlib hashmap documentation
 fn doc_tests() {
     // docs:start:default_example
-    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     assert(hashmap.is_empty());
     // docs:end:default_example
 
     // docs:start:with_hasher_example
-    let my_hasher: BuildHasherDefault<PedersenHasher> = Default::default();
-    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<PedersenHasher>> = HashMap::with_hasher(my_hasher);
+    let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
     assert(hashmap.is_empty());
     // docs:end:with_hasher_example
 
     // docs:start:insert_example
-    let mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     map.insert(12, 42);
     assert(map.len() == 1);
     // docs:end:insert_example
@@ -255,7 +255,7 @@ fn doc_tests() {
     // docs:end:len_example
 
     // docs:start:capacity_example
-    let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     assert(empty_map.len() == 0);
     assert(empty_map.capacity() == 42);
     // docs:end:capacity_example
@@ -283,8 +283,8 @@ fn doc_tests() {
     // docs:end:retain_example
 
     // docs:start:eq_example
-    let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
-    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<PedersenHasher>> = HashMap::default();
+    let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
 
     map1.insert(1, 2);
     map1.insert(3, 4);
@@ -297,7 +297,7 @@ fn doc_tests() {
 }
 
 // docs:start:get_example
-fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
     let x = map.get(12);
 
     if x.is_some() {
@@ -306,7 +306,7 @@ fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>
 }
 // docs:end:get_example
 
-fn entries_examples(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+fn entries_examples(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
     // docs:start:entries_example
     let entries = map.entries();
 
@@ -344,7 +344,7 @@ fn entries_examples(map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHas
     // docs:end:values_example
 }
 
-fn iter_examples(mut map: HashMap<Field, Field, 5, BuildHasherDefault<PedersenHasher>>) {
+fn iter_examples(mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
     // docs:start:iter_mut_example
     // Add 1 to each key in the map, and double the value associated with that key.
     map.iter_mut(|k, v| (k + 1, v * 2));
diff --git a/test_programs/execution_success/regression_sha256_slice/Nargo.toml b/test_programs/execution_success/regression_sha256_slice/Nargo.toml
deleted file mode 100644
index 759c3b20ba8..00000000000
--- a/test_programs/execution_success/regression_sha256_slice/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "regression_sha256_slice"
-type = "bin"
-authors = [""]
-compiler_version = ">=0.26.0"
-
-[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_sha256_slice/Prover.toml b/test_programs/execution_success/regression_sha256_slice/Prover.toml
deleted file mode 100644
index 8a027e9eca9..00000000000
--- a/test_programs/execution_success/regression_sha256_slice/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = ["5", "10"]
diff --git a/test_programs/execution_success/regression_sha256_slice/src/main.nr b/test_programs/execution_success/regression_sha256_slice/src/main.nr
deleted file mode 100644
index 60b0911cf09..00000000000
--- a/test_programs/execution_success/regression_sha256_slice/src/main.nr
+++ /dev/null
@@ -1,12 +0,0 @@
-use dep::std;
-
-fn main(x: [u8; 2]) {
-    let mut y = x.as_slice();
-    let digest1 = std::hash::sha256_slice(y);
-    let mut v = y;
-    if x[0] != 0 {
-        v = y.push_back(x[0]);
-    }
-    let digest2 = std::hash::sha256_slice(v);
-    assert(digest1 != digest2);
-}

From 9cc03a4d6f714a1b2d31c6982eb8e791ba5c869c Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 18 Apr 2024 20:09:13 +0100
Subject: [PATCH 199/416] feat: Allow numeric generics to non inlined ACIR
 functions (#4834)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4826.

## Summary\*

When running `nargo info` with the following code:
```rust
use dep::std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};

global NUM_HASHES = 2;
global HASH_LENGTH = 10;

#[fold]
pub fn poseidon_hash<N>(inputs: [Field; N]) -> Field {
    Poseidon2::hash(inputs, inputs.len())
}
fn main(
    to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
    enable: [bool; NUM_HASHES]
) -> pub [Field; NUM_HASHES] {
    let mut result = [0; NUM_HASHES];
    for i in 0..NUM_HASHES {
        let enable = enable[i];
        let to_hash = to_hash[i];
        if enable {
            result[i] = poseidon_hash(to_hash);
        }
    }
    result
}
```
<img width="739" alt="Screenshot 2024-04-17 at 3 46 54 PM"
src="https://github.com/noir-lang/noir/assets/43554004/fa31977d-96e9-45f7-8001-43865bc4a83c">

When using `pedersen_hash` we also get 10 opcodes for `main`.

Once we get more granularity in our inline types (fold vs. inline for
proving) we can most likely fully resolve this issue
(https://github.com/noir-lang/noir/issues/4688).

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/resolution/resolver.rs            |  5 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  | 17 ++++++-
 compiler/noirc_frontend/src/hir_def/types.rs  | 48 +++++++++++++++++++
 .../src/monomorphization/mod.rs               |  8 +++-
 .../fold_numeric_generic_poseidon/Nargo.toml  |  7 +++
 .../fold_numeric_generic_poseidon/Prover.toml |  2 +
 .../fold_numeric_generic_poseidon/src/main.nr | 33 +++++++++++++
 tooling/debugger/ignored-tests.txt            |  1 +
 8 files changed, 115 insertions(+), 6 deletions(-)
 create mode 100644 test_programs/execution_success/fold_numeric_generic_poseidon/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_numeric_generic_poseidon/Prover.toml
 create mode 100644 test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 479f357126a..01d477e9d4c 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -929,6 +929,7 @@ impl<'a> Resolver<'a> {
         let name_ident = HirIdent::non_trait_method(id, location);
 
         let attributes = func.attributes().clone();
+        let should_fold = attributes.is_foldable();
 
         let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
         let mut parameters = vec![];
@@ -1009,8 +1010,6 @@ impl<'a> Resolver<'a> {
             .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
             .collect();
 
-        let should_fold = attributes.is_foldable();
-
         FuncMeta {
             name: name_ident,
             kind: func.kind,
@@ -1039,7 +1038,7 @@ impl<'a> Resolver<'a> {
     /// True if the 'pub' keyword is allowed on parameters in this function
     /// 'pub' on function parameters is only allowed for entry point functions
     fn pub_allowed(&self, func: &NoirFunction) -> bool {
-        self.is_entry_point_function(func)
+        self.is_entry_point_function(func) || func.attributes().is_foldable()
     }
 
     fn is_entry_point_function(&self, func: &NoirFunction) -> bool {
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index f5323cd07de..b8931ce56b9 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -172,7 +172,9 @@ fn check_if_type_is_valid_for_program_input(
     errors: &mut Vec<TypeCheckError>,
 ) {
     let meta = type_checker.interner.function_meta(&func_id);
-    if (meta.is_entry_point || meta.should_fold) && !param.1.is_valid_for_program_input() {
+    if (meta.is_entry_point && !param.1.is_valid_for_program_input())
+        || (meta.should_fold && !param.1.is_valid_non_inlined_function_input())
+    {
         let span = param.0.span();
         errors.push(TypeCheckError::InvalidTypeForEntryPoint { span });
     }
@@ -632,12 +634,23 @@ pub mod test {
             #[fold]
             fn fold(x: &mut Field) -> Field {
                 *x
-            }
+        }
         "#;
 
         type_check_src_code_errors_expected(src, vec![String::from("fold")], 1);
     }
 
+    #[test]
+    fn fold_numeric_generic() {
+        let src = r#"
+        #[fold]
+            fn fold<T>(x: T) -> T {
+                x
+            }
+        "#;
+
+        type_check_src_code(src, vec![String::from("fold")]);
+    }
     // This is the same Stub that is in the resolver, maybe we can pull this out into a test module and re-use?
     struct TestPathResolver(HashMap<String, ModuleDefId>);
 
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index ec8b54c33b8..6aced6cced4 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -726,6 +726,54 @@ impl Type {
         }
     }
 
+    /// True if this type can be used as a parameter to an ACIR function that is not `main` or a contract function.
+    /// This encapsulates functions for which we may not want to inline during compilation.
+    ///
+    /// The inputs allowed for a function entry point differ from those allowed as input to a program as there are
+    /// certain types which through compilation we know what their size should be.
+    /// This includes types such as numeric generics.
+    pub(crate) fn is_valid_non_inlined_function_input(&self) -> bool {
+        match self {
+            // Type::Error is allowed as usual since it indicates an error was already issued and
+            // we don't need to issue further errors about this likely unresolved type
+            Type::FieldElement
+            | Type::Integer(_, _)
+            | Type::Bool
+            | Type::Unit
+            | Type::Constant(_)
+            | Type::TypeVariable(_, _)
+            | Type::NamedGeneric(_, _)
+            | Type::Error => true,
+
+            Type::FmtString(_, _)
+            // To enable this we would need to determine the size of the closure outputs at compile-time.
+            // This is possible as long as the output size is not dependent upon a witness condition.
+            | Type::Function(_, _, _)
+            | Type::Slice(_)
+            | Type::MutableReference(_)
+            | Type::Forall(_, _)
+            // TODO: probably can allow code as it is all compile time
+            | Type::Code
+            | Type::TraitAsType(..) => false,
+
+            Type::Alias(alias, generics) => {
+                let alias = alias.borrow();
+                alias.get_type(generics).is_valid_non_inlined_function_input()
+            }
+
+            Type::Array(length, element) => {
+                length.is_valid_non_inlined_function_input() && element.is_valid_non_inlined_function_input()
+            }
+            Type::String(length) => length.is_valid_non_inlined_function_input(),
+            Type::Tuple(elements) => elements.iter().all(|elem| elem.is_valid_non_inlined_function_input()),
+            Type::Struct(definition, generics) => definition
+                .borrow()
+                .get_fields(generics)
+                .into_iter()
+                .all(|(_, field)| field.is_valid_non_inlined_function_input()),
+        }
+    }
+
     /// Returns the number of `Forall`-quantified type variables on this type.
     /// Returns 0 if this is not a Type::Forall
     pub fn generic_count(&self) -> usize {
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 2cccc18fb09..20b9c0885bf 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -283,7 +283,13 @@ impl<'interner> Monomorphizer<'interner> {
         }
 
         let meta = self.interner.function_meta(&f).clone();
-        let func_sig = meta.function_signature();
+        let mut func_sig = meta.function_signature();
+        // Follow the bindings of the function signature for entry points
+        // which are not `main` such as foldable functions.
+        for param in func_sig.0.iter_mut() {
+            param.1 = param.1.follow_bindings();
+        }
+        func_sig.1 = func_sig.1.map(|return_type| return_type.follow_bindings());
 
         let modifiers = self.interner.function_modifiers(&f);
         let name = self.interner.function_name(&f).to_owned();
diff --git a/test_programs/execution_success/fold_numeric_generic_poseidon/Nargo.toml b/test_programs/execution_success/fold_numeric_generic_poseidon/Nargo.toml
new file mode 100644
index 00000000000..8c2bc79ea8d
--- /dev/null
+++ b/test_programs/execution_success/fold_numeric_generic_poseidon/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_numeric_generic_poseidon"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_numeric_generic_poseidon/Prover.toml b/test_programs/execution_success/fold_numeric_generic_poseidon/Prover.toml
new file mode 100644
index 00000000000..00e821cf89d
--- /dev/null
+++ b/test_programs/execution_success/fold_numeric_generic_poseidon/Prover.toml
@@ -0,0 +1,2 @@
+enable = [true, false]
+to_hash = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
diff --git a/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr b/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
new file mode 100644
index 00000000000..f9f3e75789b
--- /dev/null
+++ b/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
@@ -0,0 +1,33 @@
+use dep::std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
+
+global NUM_HASHES = 2;
+global HASH_LENGTH = 10;
+
+#[fold]
+pub fn poseidon_hash<N>(inputs: [Field; N]) -> Field {
+    Poseidon2::hash(inputs, inputs.len())
+}
+
+fn main(
+    to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
+    enable: [bool; NUM_HASHES]
+) -> pub [Field; NUM_HASHES + 1] {
+    let mut result = [0; NUM_HASHES + 1];
+    for i in 0..NUM_HASHES {
+        let enable = enable[i];
+        let to_hash = to_hash[i];
+        if enable {
+            result[i] = poseidon_hash(to_hash);
+        }
+    }
+
+    // We want to make sure that the foldable function with a numeric generic
+    // is monomorphized correctly.
+    let mut double_preimage = [0; 20];
+    for i in 0..HASH_LENGTH * 2 {
+        double_preimage[i] = to_hash[0][i % HASH_LENGTH];
+    }
+    result[NUM_HASHES] = poseidon_hash(double_preimage);
+
+    result
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 40d32072843..3b63f8d5542 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -16,4 +16,5 @@ fold_basic
 fold_basic_nested_call
 fold_call_witness_condition
 fold_after_inlined_calls
+fold_numeric_generic_poseidon
 

From 6cfb328d0d162eaa20ad1a118d085e03a52d049d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 19 Apr 2024 13:50:42 +0100
Subject: [PATCH 200/416] feat: add `min` and `max` functions to the stdlib
 (#4839)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4781

## Summary\*

This PR adds an equivalent to Rust's `std::cmp:max` and `std::cmp::min`
https://doc.rust-lang.org/src/core/cmp.rs.html#1209

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/noir/standard_library/traits.md |  2 +
 noir_stdlib/src/cmp.nr                    | 52 +++++++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
index e6e7e6d40cb..2536d9a943f 100644
--- a/docs/docs/noir/standard_library/traits.md
+++ b/docs/docs/noir/standard_library/traits.md
@@ -140,6 +140,8 @@ impl<A, B, C, D, E> Eq for (A, B, C, D, E)
 Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
 used on values of the type.
 
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
 Implementations:
 
 ```rust
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
index dde29d7ee87..457b2cfa167 100644
--- a/noir_stdlib/src/cmp.nr
+++ b/noir_stdlib/src/cmp.nr
@@ -314,3 +314,55 @@ impl<A, B, C, D, E> Ord for (A, B, C, D, E) where A: Ord, B: Ord, C: Ord, D: Ord
         result
     }
 }
+
+// Compares and returns the maximum of two values.
+//
+// Returns the second argument if the comparison determines them to be equal.
+//
+// # Examples
+//
+// ```
+// use std::cmp;
+//
+// assert_eq(cmp::max(1, 2), 2);
+// assert_eq(cmp::max(2, 2), 2);
+// ```
+pub fn max<T>(v1: T, v2: T) -> T where T: Ord {
+    if v1 > v2 { v1 } else { v2 }
+}
+
+// Compares and returns the minimum of two values.
+//
+// Returns the first argument if the comparison determines them to be equal.
+//
+// # Examples
+//
+// ```
+// use std::cmp;
+//
+// assert_eq(cmp::min(1, 2), 1);
+// assert_eq(cmp::min(2, 2), 2);
+// ```
+pub fn min<T>(v1: T, v2: T) -> T where T: Ord {
+    if v1 > v2 { v2 } else { v1 }
+}
+
+mod cmp_tests {
+    use crate::cmp::{min, max};
+
+    #[test]
+    fn sanity_check_min() {
+        assert_eq(min(0 as u64, 1 as u64), 0);
+        assert_eq(min(0 as u64, 0 as u64), 0);
+        assert_eq(min(1 as u64, 1 as u64), 1);
+        assert_eq(min(255 as u8, 0 as u8), 0);
+    }
+
+    #[test]
+    fn sanity_check_max() {
+        assert_eq(max(0 as u64, 1 as u64), 1);
+        assert_eq(max(0 as u64, 0 as u64), 0);
+        assert_eq(max(1 as u64, 1 as u64), 1);
+        assert_eq(max(255 as u8, 0 as u8), 255);
+    }
+}

From 4dfd7f03bc1b9cf57f5829c435a560bed53b7f46 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 19 Apr 2024 16:07:26 -0400
Subject: [PATCH 201/416] feat(experimental): Add `comptime` keyword (#4840)

# Description

## Problem\*

Resolves #4588

## Summary\*

Adds the `comptime` keyword which can be used around certain constructs:

- `comptime let foo = ...;` on local or global definitions
- `comptime if a { b } else { c }`
- `comptime for ... { ... }`
- `comptime { ... }`

This PR just adds these to parsing and forwards the new node types to
the frontend as necessary.

## Additional Context

The interpreter currently _does not_ handle these properly - this will
come in a separate PR. Eventually we want the interpreter to _only_
interpret comptime things where currently it interprets everything.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 aztec_macros/src/utils/ast_utils.rs           |   2 +
 compiler/noirc_frontend/src/ast/statement.rs  |  53 ++++--
 compiler/noirc_frontend/src/debug/mod.rs      |   3 +
 .../src/hir/comptime/hir_to_ast.rs            |   4 +
 .../src/hir/comptime/interpreter.rs           |  13 ++
 .../src/hir/resolution/resolver.rs            |   4 +
 .../noirc_frontend/src/hir/type_check/stmt.rs |   1 +
 compiler/noirc_frontend/src/hir_def/stmt.rs   |   3 +-
 .../src/monomorphization/mod.rs               |   3 +
 compiler/noirc_frontend/src/parser/parser.rs  |  83 ++++++---
 .../src/parser/parser/function.rs             |  19 +-
 compiler/noirc_frontend/src/tests.rs          |   1 +
 tooling/nargo_fmt/src/visitor/stmt.rs         | 167 +++++++++---------
 13 files changed, 223 insertions(+), 133 deletions(-)

diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index 1731dfab49c..d0d7077a946 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -66,6 +66,7 @@ pub fn mutable_assignment(name: &str, assigned_to: Expression) -> Statement {
         pattern: mutable(name),
         r#type: make_type(UnresolvedTypeData::Unspecified),
         expression: assigned_to,
+        comptime: false,
         attributes: vec![],
     }))
 }
@@ -90,6 +91,7 @@ pub fn assignment_with_type(
         pattern: pattern(name),
         r#type: make_type(typ),
         expression: assigned_to,
+        comptime: false,
         attributes: vec![],
     }))
 }
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 753b5a31d32..c46ab39df1e 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -38,6 +38,8 @@ pub enum StatementKind {
     For(ForLoopStatement),
     Break,
     Continue,
+    /// This statement should be executed at compile-time
+    Comptime(Box<StatementKind>),
     // This is an expression with a trailing semi-colon
     Semi(Expression),
     // This statement is the result of a recovered parse error.
@@ -47,6 +49,19 @@ pub enum StatementKind {
 }
 
 impl Statement {
+    pub fn add_semicolon(
+        mut self,
+        semi: Option<Token>,
+        span: Span,
+        last_statement_in_block: bool,
+        emit_error: &mut dyn FnMut(ParserError),
+    ) -> Self {
+        self.kind = self.kind.add_semicolon(semi, span, last_statement_in_block, emit_error);
+        self
+    }
+}
+
+impl StatementKind {
     pub fn add_semicolon(
         self,
         semi: Option<Token>,
@@ -57,7 +72,7 @@ impl Statement {
         let missing_semicolon =
             ParserError::with_reason(ParserErrorReason::MissingSeparatingSemi, span);
 
-        let kind = match self.kind {
+        match self {
             StatementKind::Let(_)
             | StatementKind::Constrain(_)
             | StatementKind::Assign(_)
@@ -69,10 +84,15 @@ impl Statement {
                 if semi.is_none() {
                     emit_error(missing_semicolon);
                 }
-                self.kind
+                self
+            }
+            StatementKind::Comptime(mut statement) => {
+                *statement =
+                    statement.add_semicolon(semi, span, last_statement_in_block, emit_error);
+                StatementKind::Comptime(statement)
             }
             // A semicolon on a for loop is optional and does nothing
-            StatementKind::For(_) => self.kind,
+            StatementKind::For(_) => self,
 
             StatementKind::Expression(expr) => {
                 match (&expr.kind, semi, last_statement_in_block) {
@@ -92,9 +112,7 @@ impl Statement {
                     (_, None, true) => StatementKind::Expression(expr),
                 }
             }
-        };
-
-        Statement { kind, span: self.span }
+        }
     }
 }
 
@@ -108,7 +126,13 @@ impl StatementKind {
     pub fn new_let(
         ((pattern, r#type), expression): ((Pattern, UnresolvedType), Expression),
     ) -> StatementKind {
-        StatementKind::Let(LetStatement { pattern, r#type, expression, attributes: vec![] })
+        StatementKind::Let(LetStatement {
+            pattern,
+            r#type,
+            expression,
+            comptime: false,
+            attributes: vec![],
+        })
     }
 
     /// Create a Statement::Assign value, desugaring any combined operators like += if needed.
@@ -407,17 +431,9 @@ pub struct LetStatement {
     pub r#type: UnresolvedType,
     pub expression: Expression,
     pub attributes: Vec<SecondaryAttribute>,
-}
 
-impl LetStatement {
-    pub fn new_let(
-        (((pattern, r#type), expression), attributes): (
-            ((Pattern, UnresolvedType), Expression),
-            Vec<SecondaryAttribute>,
-        ),
-    ) -> LetStatement {
-        LetStatement { pattern, r#type, expression, attributes }
-    }
+    // True if this should only be run during compile-time
+    pub comptime: bool,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -573,6 +589,7 @@ impl ForRange {
                         pattern: Pattern::Identifier(array_ident.clone()),
                         r#type: UnresolvedType::unspecified(),
                         expression: array,
+                        comptime: false,
                         attributes: vec![],
                     }),
                     span: array_span,
@@ -616,6 +633,7 @@ impl ForRange {
                         pattern: Pattern::Identifier(identifier),
                         r#type: UnresolvedType::unspecified(),
                         expression: Expression::new(loop_element, array_span),
+                        comptime: false,
                         attributes: vec![],
                     }),
                     span: array_span,
@@ -666,6 +684,7 @@ impl Display for StatementKind {
             StatementKind::For(for_loop) => for_loop.fmt(f),
             StatementKind::Break => write!(f, "break"),
             StatementKind::Continue => write!(f, "continue"),
+            StatementKind::Comptime(statement) => write!(f, "comptime {statement}"),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
             StatementKind::Error => write!(f, "Error"),
         }
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 67b52071d7b..3e7d123398b 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -145,6 +145,7 @@ impl DebugInstrumenter {
                         pattern: ast::Pattern::Identifier(ident("__debug_expr", ret_expr.span)),
                         r#type: ast::UnresolvedType::unspecified(),
                         expression: ret_expr.clone(),
+                        comptime: false,
                         attributes: vec![],
                     }),
                     span: ret_expr.span,
@@ -243,6 +244,7 @@ impl DebugInstrumenter {
             kind: ast::StatementKind::Let(ast::LetStatement {
                 pattern: ast::Pattern::Tuple(vars_pattern, let_stmt.pattern.span()),
                 r#type: ast::UnresolvedType::unspecified(),
+                comptime: false,
                 expression: ast::Expression {
                     kind: ast::ExpressionKind::Block(ast::BlockExpression {
                         statements: block_stmts,
@@ -275,6 +277,7 @@ impl DebugInstrumenter {
             pattern: ast::Pattern::Identifier(ident("__debug_expr", assign_stmt.expression.span)),
             r#type: ast::UnresolvedType::unspecified(),
             expression: assign_stmt.expression.clone(),
+            comptime: false,
             attributes: vec![],
         });
         let expression_span = assign_stmt.expression.span;
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
index 8ffcbce7d62..9f9004b5ad1 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -36,6 +36,7 @@ impl StmtId {
                     pattern,
                     r#type,
                     expression,
+                    comptime: false,
                     attributes: Vec::new(),
                 })
             }
@@ -64,6 +65,9 @@ impl StmtId {
             HirStatement::Expression(expr) => StatementKind::Expression(expr.to_ast(interner)),
             HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
             HirStatement::Error => StatementKind::Error,
+            HirStatement::Comptime(statement) => {
+                StatementKind::Comptime(Box::new(statement.to_ast(interner).kind))
+            }
         };
 
         Statement { kind, span }
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 81050073008..54f1c321a3b 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -44,6 +44,10 @@ pub(crate) struct Interpreter<'interner> {
     changed_globally: bool,
 
     in_loop: bool,
+
+    /// True if we're currently in a compile-time context.
+    /// If this is false code is skipped over instead of executed.
+    in_comptime_context: bool,
 }
 
 #[allow(unused)]
@@ -121,6 +125,7 @@ impl<'a> Interpreter<'a> {
             changed_functions: HashSet::default(),
             changed_globally: false,
             in_loop: false,
+            in_comptime_context: false,
         }
     }
 
@@ -1074,6 +1079,7 @@ impl<'a> Interpreter<'a> {
             HirStatement::Break => self.evaluate_break(),
             HirStatement::Continue => self.evaluate_continue(),
             HirStatement::Expression(expression) => self.evaluate(expression),
+            HirStatement::Comptime(statement) => self.evaluate_comptime(statement),
             HirStatement::Semi(expression) => {
                 self.evaluate(expression)?;
                 Ok(Value::Unit)
@@ -1246,6 +1252,13 @@ impl<'a> Interpreter<'a> {
             Err(InterpreterError::ContinueNotInLoop)
         }
     }
+
+    fn evaluate_comptime(&mut self, statement: StmtId) -> IResult<Value> {
+        let was_in_comptime = std::mem::replace(&mut self.in_comptime_context, true);
+        let result = self.evaluate_statement(statement);
+        self.in_comptime_context = was_in_comptime;
+        result
+    }
 }
 
 impl Value {
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 01d477e9d4c..ab0490a80e4 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1275,6 +1275,10 @@ impl<'a> Resolver<'a> {
                 HirStatement::Continue
             }
             StatementKind::Error => HirStatement::Error,
+            StatementKind::Comptime(statement) => {
+                let statement = self.resolve_stmt(*statement, span);
+                HirStatement::Comptime(self.interner.push_stmt(statement))
+            }
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index fb57aa75f89..4dfc896fb29 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -51,6 +51,7 @@ impl<'interner> TypeChecker<'interner> {
             HirStatement::Constrain(constrain_stmt) => self.check_constrain_stmt(constrain_stmt),
             HirStatement::Assign(assign_stmt) => self.check_assign_stmt(assign_stmt, stmt_id),
             HirStatement::For(for_loop) => self.check_for_loop(for_loop),
+            HirStatement::Comptime(statement) => return self.check_statement(&statement),
             HirStatement::Break | HirStatement::Continue | HirStatement::Error => (),
         }
         Type::Unit
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 37e3651a9b2..605f25ebfbf 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -1,6 +1,6 @@
 use super::expr::HirIdent;
 use crate::macros_api::SecondaryAttribute;
-use crate::node_interner::ExprId;
+use crate::node_interner::{ExprId, StmtId};
 use crate::{Ident, Type};
 use fm::FileId;
 use noirc_errors::{Location, Span};
@@ -19,6 +19,7 @@ pub enum HirStatement {
     Continue,
     Expression(ExprId),
     Semi(ExprId),
+    Comptime(StmtId),
     Error,
 }
 
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 20b9c0885bf..477ed3fe951 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -624,6 +624,9 @@ impl<'interner> Monomorphizer<'interner> {
             HirStatement::Break => Ok(ast::Expression::Break),
             HirStatement::Continue => Ok(ast::Expression::Continue),
             HirStatement::Error => unreachable!(),
+
+            // All `comptime` statements & expressions should be removed before runtime.
+            HirStatement::Comptime(_) => unreachable!("comptime statement in runtime code"),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 5706c3ef12f..ba5b9bf1ab0 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -234,14 +234,16 @@ fn implementation() -> impl NoirParser<TopLevelStatement> {
 /// global_declaration: 'global' ident global_type_annotation '=' literal
 fn global_declaration() -> impl NoirParser<TopLevelStatement> {
     let p = attributes::attributes()
+        .then(maybe_comp_time())
         .then_ignore(keyword(Keyword::Global).labelled(ParsingRuleLabel::Global))
         .then(ident().map(Pattern::Identifier));
+
     let p = then_commit(p, optional_type_annotation());
     let p = then_commit_ignore(p, just(Token::Assign));
     let p = then_commit(p, expression());
-    p.validate(|(((attributes, pattern), r#type), expression), span, emit| {
+    p.validate(|((((attributes, comptime), pattern), r#type), expression), span, emit| {
         let global_attributes = attributes::validate_secondary_attributes(attributes, span, emit);
-        LetStatement { pattern, r#type, expression, attributes: global_attributes }
+        LetStatement { pattern, r#type, comptime, expression, attributes: global_attributes }
     })
     .map(TopLevelStatement::Global)
 }
@@ -498,10 +500,11 @@ where
             assertion::assertion_eq(expr_parser.clone()),
             declaration(expr_parser.clone()),
             assignment(expr_parser.clone()),
-            for_loop(expr_no_constructors, statement),
+            for_loop(expr_no_constructors.clone(), statement.clone()),
             break_statement(),
             continue_statement(),
             return_statement(expr_parser.clone()),
+            comptime_statement(expr_parser.clone(), expr_no_constructors, statement),
             expr_parser.map(StatementKind::Expression),
         ))
     })
@@ -519,6 +522,35 @@ fn continue_statement() -> impl NoirParser<StatementKind> {
     keyword(Keyword::Continue).to(StatementKind::Continue)
 }
 
+fn comptime_statement<'a, P1, P2, S>(
+    expr: P1,
+    expr_no_constructors: P2,
+    statement: S,
+) -> impl NoirParser<StatementKind> + 'a
+where
+    P1: ExprParser + 'a,
+    P2: ExprParser + 'a,
+    S: NoirParser<StatementKind> + 'a,
+{
+    keyword(Keyword::CompTime)
+        .ignore_then(choice((
+            declaration(expr),
+            for_loop(expr_no_constructors, statement.clone()),
+            block(statement).map_with_span(|block, span| {
+                StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
+            }),
+        )))
+        .map(|statement| StatementKind::Comptime(Box::new(statement)))
+}
+
+/// Comptime in an expression position only accepts entire blocks
+fn comptime_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
+where
+    S: NoirParser<StatementKind> + 'a,
+{
+    keyword(Keyword::CompTime).ignore_then(block(statement)).map(ExpressionKind::Block)
+}
+
 fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
 where
     P: ExprParser + 'a,
@@ -700,24 +732,25 @@ fn optional_distinctness() -> impl NoirParser<Distinctness> {
     })
 }
 
-fn maybe_comp_time() -> impl NoirParser<()> {
+fn maybe_comp_time() -> impl NoirParser<bool> {
     keyword(Keyword::CompTime).or_not().validate(|opt, span, emit| {
         if opt.is_some() {
-            emit(ParserError::with_reason(ParserErrorReason::ComptimeDeprecated, span));
+            emit(ParserError::with_reason(
+                ParserErrorReason::ExperimentalFeature("comptime"),
+                span,
+            ));
         }
+        opt.is_some()
     })
 }
 
 fn field_type() -> impl NoirParser<UnresolvedType> {
-    maybe_comp_time()
-        .then_ignore(keyword(Keyword::Field))
+    keyword(Keyword::Field)
         .map_with_span(|_, span| UnresolvedTypeData::FieldElement.with_span(span))
 }
 
 fn bool_type() -> impl NoirParser<UnresolvedType> {
-    maybe_comp_time()
-        .then_ignore(keyword(Keyword::Bool))
-        .map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
+    keyword(Keyword::Bool).map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
 }
 
 fn string_type() -> impl NoirParser<UnresolvedType> {
@@ -744,21 +777,20 @@ fn format_string_type(
 }
 
 fn int_type() -> impl NoirParser<UnresolvedType> {
-    maybe_comp_time()
-        .then(filter_map(|span, token: Token| match token {
-            Token::IntType(int_type) => Ok(int_type),
-            unexpected => {
-                Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
-            }
-        }))
-        .validate(|(_, token), span, emit| {
-            UnresolvedTypeData::from_int_token(token)
-                .map(|data| data.with_span(span))
-                .unwrap_or_else(|err| {
-                    emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
-                    UnresolvedType::error(span)
-                })
-        })
+    filter_map(|span, token: Token| match token {
+        Token::IntType(int_type) => Ok(int_type),
+        unexpected => {
+            Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
+        }
+    })
+    .validate(|token, span, emit| {
+        UnresolvedTypeData::from_int_token(token).map(|data| data.with_span(span)).unwrap_or_else(
+            |err| {
+                emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
+                UnresolvedType::error(span)
+            },
+        )
+    })
 }
 
 fn named_type(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
@@ -1236,6 +1268,7 @@ where
         },
         lambdas::lambda(expr_parser.clone()),
         block(statement.clone()).map(ExpressionKind::Block),
+        comptime_expr(statement.clone()),
         quote(statement),
         variable(),
         literal(),
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 18f17065038..074c902ff7b 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -1,8 +1,8 @@
 use super::{
     attributes::{attributes, validate_attributes},
-    block, fresh_statement, ident, keyword, nothing, optional_distinctness, optional_visibility,
-    parameter_name_recovery, parameter_recovery, parenthesized, parse_type, pattern,
-    self_parameter, where_clause, NoirParser,
+    block, fresh_statement, ident, keyword, maybe_comp_time, nothing, optional_distinctness,
+    optional_visibility, parameter_name_recovery, parameter_recovery, parenthesized, parse_type,
+    pattern, self_parameter, where_clause, NoirParser,
 };
 use crate::parser::labels::ParsingRuleLabel;
 use crate::parser::spanned;
@@ -36,8 +36,8 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
                 name,
                 attributes,
                 is_unconstrained: modifiers.0,
-                is_comptime: false, // TODO
                 visibility: modifiers.1,
+                is_comptime: modifiers.2,
                 generics,
                 parameters,
                 body,
@@ -68,11 +68,14 @@ fn visibility_modifier() -> impl NoirParser<ItemVisibility> {
 /// function_modifiers: 'unconstrained'? (visibility)?
 ///
 /// returns (is_unconstrained, visibility) for whether each keyword was present
-fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility)> {
+fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility, bool)> {
     keyword(Keyword::Unconstrained)
         .or_not()
         .then(visibility_modifier())
-        .map(|(unconstrained, visibility)| (unconstrained.is_some(), visibility))
+        .then(maybe_comp_time())
+        .map(|((unconstrained, visibility), comptime)| {
+            (unconstrained.is_some(), visibility, comptime)
+        })
 }
 
 /// non_empty_ident_list: ident ',' non_empty_ident_list
@@ -172,8 +175,8 @@ mod test {
                 "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
                 "fn func_name(x: [Field], y : [Field;2],y : pub [Field;2], z : pub [u8;5])  {}",
                 "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }",
-                "fn f(f: pub Field, y : Field, z : comptime Field) -> u8 { x + a }",
-                "fn f<T>(f: pub Field, y : T, z : comptime Field) -> u8 { x + a }",
+                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
+                "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
                 "fn func_name<T>(f: Field, y : T) where T: SomeTrait {}",
                 "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2 {}",
                 "fn func_name<T>(f: Field, y : T) where T: SomeTrait, T: SomeTrait2 {}",
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index c4f0a8d67ba..31bf2245b1f 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -780,6 +780,7 @@ mod test {
                 HirStatement::Error => panic!("Invalid HirStatement!"),
                 HirStatement::Break => panic!("Unexpected break"),
                 HirStatement::Continue => panic!("Unexpected continue"),
+                HirStatement::Comptime(_) => panic!("Unexpected comptime"),
             };
             let expr = interner.expression(&expr_id);
 
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index ee8cc990e0e..612330ad3a3 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -1,7 +1,8 @@
 use std::iter::zip;
 
 use noirc_frontend::{
-    ConstrainKind, ConstrainStatement, ExpressionKind, ForRange, Statement, StatementKind,
+    macros_api::Span, ConstrainKind, ConstrainStatement, ExpressionKind, ForRange, Statement,
+    StatementKind,
 };
 
 use crate::{rewrite, visitor::expr::wrap_exprs};
@@ -14,92 +15,94 @@ impl super::FmtVisitor<'_> {
 
         for (Statement { kind, span }, index) in zip(stmts, 1..) {
             let is_last = index == len;
+            self.visit_stmt(kind, span, is_last);
+            self.last_position = span.end();
+        }
+    }
 
-            match kind {
-                StatementKind::Expression(expr) => self.visit_expr(
-                    expr,
-                    if is_last { ExpressionType::SubExpression } else { ExpressionType::Statement },
-                ),
-                StatementKind::Semi(expr) => {
-                    self.visit_expr(expr, ExpressionType::Statement);
-                    self.push_str(";");
-                }
-                StatementKind::Let(let_stmt) => {
-                    let let_str =
-                        self.slice(span.start()..let_stmt.expression.span.start()).trim_end();
-
-                    let expr_str = rewrite::sub_expr(self, self.shape(), let_stmt.expression);
-
-                    self.push_rewrite(format!("{let_str} {expr_str};"), span);
-                }
-                StatementKind::Constrain(ConstrainStatement(expr, message, kind)) => {
-                    let mut nested_shape = self.shape();
-                    let shape = nested_shape;
-
-                    nested_shape.indent.block_indent(self.config);
-
-                    let message = message.map_or(String::new(), |message| {
-                        let message = rewrite::sub_expr(self, nested_shape, message);
-                        format!(", {message}")
-                    });
-
-                    let (callee, args) = match kind {
-                        ConstrainKind::Assert | ConstrainKind::Constrain => {
-                            let assertion = rewrite::sub_expr(self, nested_shape, expr);
-                            let args = format!("{assertion}{message}");
-
-                            ("assert", args)
-                        }
-                        ConstrainKind::AssertEq => {
-                            if let ExpressionKind::Infix(infix) = expr.kind {
-                                let lhs = rewrite::sub_expr(self, nested_shape, infix.lhs);
-                                let rhs = rewrite::sub_expr(self, nested_shape, infix.rhs);
+    fn visit_stmt(&mut self, kind: StatementKind, span: Span, is_last: bool) {
+        match kind {
+            StatementKind::Expression(expr) => self.visit_expr(
+                expr,
+                if is_last { ExpressionType::SubExpression } else { ExpressionType::Statement },
+            ),
+            StatementKind::Semi(expr) => {
+                self.visit_expr(expr, ExpressionType::Statement);
+                self.push_str(";");
+            }
+            StatementKind::Let(let_stmt) => {
+                let let_str = self.slice(span.start()..let_stmt.expression.span.start()).trim_end();
 
-                                let args = format!("{lhs}, {rhs}{message}");
+                let expr_str = rewrite::sub_expr(self, self.shape(), let_stmt.expression);
 
-                                ("assert_eq", args)
-                            } else {
-                                unreachable!()
-                            }
+                self.push_rewrite(format!("{let_str} {expr_str};"), span);
+            }
+            StatementKind::Constrain(ConstrainStatement(expr, message, kind)) => {
+                let mut nested_shape = self.shape();
+                let shape = nested_shape;
+
+                nested_shape.indent.block_indent(self.config);
+
+                let message = message.map_or(String::new(), |message| {
+                    let message = rewrite::sub_expr(self, nested_shape, message);
+                    format!(", {message}")
+                });
+
+                let (callee, args) = match kind {
+                    ConstrainKind::Assert | ConstrainKind::Constrain => {
+                        let assertion = rewrite::sub_expr(self, nested_shape, expr);
+                        let args = format!("{assertion}{message}");
+
+                        ("assert", args)
+                    }
+                    ConstrainKind::AssertEq => {
+                        if let ExpressionKind::Infix(infix) = expr.kind {
+                            let lhs = rewrite::sub_expr(self, nested_shape, infix.lhs);
+                            let rhs = rewrite::sub_expr(self, nested_shape, infix.rhs);
+
+                            let args = format!("{lhs}, {rhs}{message}");
+
+                            ("assert_eq", args)
+                        } else {
+                            unreachable!()
                         }
-                    };
-
-                    let args = wrap_exprs(
-                        "(",
-                        ")",
-                        args,
-                        nested_shape,
-                        shape,
-                        NewlineMode::IfContainsNewLineAndWidth,
-                    );
-                    let constrain = format!("{callee}{args};");
-
-                    self.push_rewrite(constrain, span);
-                }
-                StatementKind::For(for_stmt) => {
-                    let identifier = self.slice(for_stmt.identifier.span());
-                    let range = match for_stmt.range {
-                        ForRange::Range(start, end) => format!(
-                            "{}..{}",
-                            rewrite::sub_expr(self, self.shape(), start),
-                            rewrite::sub_expr(self, self.shape(), end)
-                        ),
-                        ForRange::Array(array) => rewrite::sub_expr(self, self.shape(), array),
-                    };
-                    let block = rewrite::sub_expr(self, self.shape(), for_stmt.block);
-
-                    let result = format!("for {identifier} in {range} {block}");
-                    self.push_rewrite(result, span);
-                }
-                StatementKind::Assign(_) => {
-                    self.push_rewrite(self.slice(span).to_string(), span);
-                }
-                StatementKind::Error => unreachable!(),
-                StatementKind::Break => self.push_rewrite("break;".into(), span),
-                StatementKind::Continue => self.push_rewrite("continue;".into(), span),
+                    }
+                };
+
+                let args = wrap_exprs(
+                    "(",
+                    ")",
+                    args,
+                    nested_shape,
+                    shape,
+                    NewlineMode::IfContainsNewLineAndWidth,
+                );
+                let constrain = format!("{callee}{args};");
+
+                self.push_rewrite(constrain, span);
             }
-
-            self.last_position = span.end();
+            StatementKind::For(for_stmt) => {
+                let identifier = self.slice(for_stmt.identifier.span());
+                let range = match for_stmt.range {
+                    ForRange::Range(start, end) => format!(
+                        "{}..{}",
+                        rewrite::sub_expr(self, self.shape(), start),
+                        rewrite::sub_expr(self, self.shape(), end)
+                    ),
+                    ForRange::Array(array) => rewrite::sub_expr(self, self.shape(), array),
+                };
+                let block = rewrite::sub_expr(self, self.shape(), for_stmt.block);
+
+                let result = format!("for {identifier} in {range} {block}");
+                self.push_rewrite(result, span);
+            }
+            StatementKind::Assign(_) => {
+                self.push_rewrite(self.slice(span).to_string(), span);
+            }
+            StatementKind::Error => unreachable!(),
+            StatementKind::Break => self.push_rewrite("break;".into(), span),
+            StatementKind::Continue => self.push_rewrite("continue;".into(), span),
+            StatementKind::Comptime(statement) => self.visit_stmt(*statement, span, is_last),
         }
     }
 }

From 073563568e53f81d8ad0ca71e9e34e03174239ec Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Sun, 21 Apr 2024 01:45:49 +0100
Subject: [PATCH 202/416] chore: update noir README (#4856)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The current readme is extremely stale and contains a bunch of incorrect
info. I've updated this

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 README.md     |  61 ++++++++++++++++++++------------------------------
 noir-logo.png | Bin 0 -> 224467 bytes
 2 files changed, 24 insertions(+), 37 deletions(-)
 create mode 100644 noir-logo.png

diff --git a/README.md b/README.md
index adf68b290ef..3162ff54ab9 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,13 @@
+<div align="center">
+  <picture>
+    <img src="./noir-logo.png" alt="The Noir Programming Language" width="35%">
+  </picture>
+
+[Website][Noir] | [Getting started] | [Documentation] | [Contributing]
+</div>
+
+
+
 # The Noir Programming Language
 
 Noir is a Domain Specific Language for SNARK proving systems. It has been designed to use any ACIR compatible proving system.
@@ -6,58 +16,35 @@ Noir is a Domain Specific Language for SNARK proving systems. It has been design
 
 ## Quick Start
 
-Read the installation section [here](https://noir-lang.org/docs/dev/getting_started/installation/).
+Read the [installation section][Getting started] from the [Noir docs][Documentation].
 
 Once you have read through the documentation, you can visit [Awesome Noir](https://github.com/noir-lang/awesome-noir) to run some of the examples that others have created.
 
-## Current Features
-
-Backends:
+## Getting Help
 
-- Barretenberg via FFI
-- Marlin via arkworks (Note -- latest interfaces may not be updated to support Marlin backend. Please open an issue if this is relevant to your project and requires attention.)
+Join the Noir [forum][Forum] or [Discord][Discord]
 
-Compiler:
+## Contributing
 
-- Module System
-- For expressions
-- Arrays
-- Bit Operations
-- Binary operations (<, <=, >, >=, +, -, \*, /, %) [See documentation for an extensive list]
-- Unsigned integers
-- If statements
-- Structures and Tuples
-- Generics
-
-ACIR Supported OPCODES:
-
-- Sha256
-- Blake2s
-- Schnorr signature verification
-- Pedersen
-- HashToField
+See [CONTRIBUTING.md][CONTRIBUTING].
 
 ## Future Work
 
 The current focus is to gather as much feedback as possible while in the alpha phase. The main focuses of Noir are _safety_ and _developer experience_. If you find a feature that does not seem to be in line with these goals, please open an issue!
 
-Concretely the following items are on the road map:
-
-- General code sanitization and documentation (ongoing effort)
-- Prover and Verifier Key logic. (Prover and Verifier pre-process per compile)
-- Fallback mechanism for backend unsupported opcodes
-- Visibility modifiers
-- Signed integers
-- Backend integration: (Bulletproofs)
-- Recursion
-- Big integers
-
 ## Minimum Rust version
 
-This crate's minimum supported rustc version is 1.73.0.
+This workspace's minimum supported rustc version is 1.73.0.
 
 ## License
 
 Noir is free and open source. It is distributed under a dual license. (MIT/APACHE)
 
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this repository by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
+
+[Noir]: https://www.noir-lang.org/
+[Getting Started]: https://noir-lang.org/docs/getting_started/installation/
+[Forum]: https://forum.aztec.network/c/noir
+[Discord]: https://discord.gg/JtqzkdeQ6G
+[Documentation]: https://noir-lang.org/docs
+[Contributing]: CONTRIBUTING.md
\ No newline at end of file
diff --git a/noir-logo.png b/noir-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..eabb163ad73f2728f914a1bcc06c23b8832c2f36
GIT binary patch
literal 224467
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%0AvRfLbkn+ixBA`qN~Ci5(zobEmQUi+N#_E&OWu=a
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

literal 0
HcmV?d00001


From 48d956388c3bdbf8214cf3fcdfcd4778666dba32 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 22 Apr 2024 13:30:05 +0100
Subject: [PATCH 203/416] chore(docs): remove link to play.noir-lang.org
 (#4872)

# Description

## Problem\*

Resolves #4770

## Summary\*

This PR removes the dead link to the noir playground.

cc @signorecello

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../version-v0.22.0/getting_started/tooling/index.md        | 6 +-----
 .../version-v0.23.0/getting_started/tooling/index.mdx       | 6 +-----
 .../version-v0.24.0/getting_started/tooling/index.mdx       | 6 +-----
 .../version-v0.25.0/getting_started/tooling/index.mdx       | 6 +-----
 .../version-v0.26.0/getting_started/tooling/index.mdx       | 6 +-----
 .../version-v0.27.0/getting_started/tooling/index.mdx       | 6 +-----
 6 files changed, 6 insertions(+), 30 deletions(-)

diff --git a/docs/versioned_docs/version-v0.22.0/getting_started/tooling/index.md b/docs/versioned_docs/version-v0.22.0/getting_started/tooling/index.md
index 55df833005a..16f5f3ca45e 100644
--- a/docs/versioned_docs/version-v0.22.0/getting_started/tooling/index.md
+++ b/docs/versioned_docs/version-v0.22.0/getting_started/tooling/index.md
@@ -1,15 +1,11 @@
 ---
 title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Description: This section provides information about the various tools and utilities available for Noir development. It covers IDE tools, Codespaces, and community projects.
 Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
 ---
 
 Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
 
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
 ## IDE tools
 
 When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
diff --git a/docs/versioned_docs/version-v0.23.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.23.0/getting_started/tooling/index.mdx
index ac480f3c9f5..ec9ccea4115 100644
--- a/docs/versioned_docs/version-v0.23.0/getting_started/tooling/index.mdx
+++ b/docs/versioned_docs/version-v0.23.0/getting_started/tooling/index.mdx
@@ -1,15 +1,11 @@
 ---
 title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Description: This section provides information about the various tools and utilities available for Noir development. It covers IDE tools, Codespaces, and community projects.
 Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
 ---
 
 Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
 
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
 ## IDE tools
 
 When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
diff --git a/docs/versioned_docs/version-v0.24.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.24.0/getting_started/tooling/index.mdx
index ac480f3c9f5..ec9ccea4115 100644
--- a/docs/versioned_docs/version-v0.24.0/getting_started/tooling/index.mdx
+++ b/docs/versioned_docs/version-v0.24.0/getting_started/tooling/index.mdx
@@ -1,15 +1,11 @@
 ---
 title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Description: This section provides information about the various tools and utilities available for Noir development. It covers IDE tools, Codespaces, and community projects.
 Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
 ---
 
 Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
 
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
 ## IDE tools
 
 When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
diff --git a/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx
index ac480f3c9f5..ec9ccea4115 100644
--- a/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx
+++ b/docs/versioned_docs/version-v0.25.0/getting_started/tooling/index.mdx
@@ -1,15 +1,11 @@
 ---
 title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Description: This section provides information about the various tools and utilities available for Noir development. It covers IDE tools, Codespaces, and community projects.
 Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
 ---
 
 Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
 
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
 ## IDE tools
 
 When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
diff --git a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx
index ac480f3c9f5..ec9ccea4115 100644
--- a/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx
+++ b/docs/versioned_docs/version-v0.26.0/getting_started/tooling/index.mdx
@@ -1,15 +1,11 @@
 ---
 title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Description: This section provides information about the various tools and utilities available for Noir development. It covers IDE tools, Codespaces, and community projects.
 Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
 ---
 
 Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
 
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
 ## IDE tools
 
 When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.
diff --git a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx
index ac480f3c9f5..ec9ccea4115 100644
--- a/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx
+++ b/docs/versioned_docs/version-v0.27.0/getting_started/tooling/index.mdx
@@ -1,15 +1,11 @@
 ---
 title: Tooling
-Description: This section provides information about the various tools and utilities available for Noir development. It covers the Noir playground, IDE tools, Codespaces, and community projects.
+Description: This section provides information about the various tools and utilities available for Noir development. It covers IDE tools, Codespaces, and community projects.
 Keywords: [Noir, Development, Playground, IDE Tools, Language Service Provider, VS Code Extension, Codespaces, noir-starter, Community Projects, Awesome Noir Repository, Developer Tooling]
 ---
 
 Noir is meant to be easy to develop with. For that reason, a number of utilities have been put together to ease the development process as much as feasible in the zero-knowledge world.
 
-## Playground
-
-The Noir playground is an easy way to test small ideas, share snippets, and integrate in other websites. You can access it at [play.noir-lang.org](https://play.noir-lang.org).
-
 ## IDE tools
 
 When you install Nargo, you're also installing a Language Service Provider (LSP), which can be used by IDEs to provide syntax highlighting, codelens, warnings, and more.

From 85bfdef3c2d05c73301b82d9acd4639fd2b758cc Mon Sep 17 00:00:00 2001
From: shak58 <150069539+shak58@users.noreply.github.com>
Date: Mon, 22 Apr 2024 15:54:57 +0100
Subject: [PATCH 204/416] chore: update NoirJS tutorial (#4861)

# Description

## Problem\*

Resolves #4793

## Summary\*

This pull requests updates the docs to support changes made after
version v0.25.0. The current docs directs the user to install packages
of version 0.19.7 while calling functions `generateProof` and
`verifyProof` instead of `generateFinalProof` and `verifyFinalProof`
which results in the error that functions `generateProof` and
`verifyProof` don't exist.

Also, for the dev version of the docs, using the packages
v0.27.0@nightly, the functions needed to be updated to reflect the
changes in #4769.

## Additional Context

I've tested the changes using packages and nargo of the following
versions:
 - v0.25.0
 - v0.26.0
 - v0.27.0@nightly

I added documentation for the `vite.config.js` file otherwise any
version >= v0.21.0 would result in runtime errors.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/tutorials/noirjs_app.md             | 89 ++++++++++++++-----
 .../version-v0.25.0/tutorials/noirjs_app.md   | 81 +++++++++++++----
 .../version-v0.26.0/tutorials/noirjs_app.md   | 81 +++++++++++++----
 3 files changed, 194 insertions(+), 57 deletions(-)

diff --git a/docs/docs/tutorials/noirjs_app.md b/docs/docs/tutorials/noirjs_app.md
index 12beb476994..6446e0b2a76 100644
--- a/docs/docs/tutorials/noirjs_app.md
+++ b/docs/docs/tutorials/noirjs_app.md
@@ -14,9 +14,9 @@ You can find the complete app code for this guide [here](https://github.com/noir
 
 :::note
 
-Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.19.x matches `noir_js@0.19.x`, etc.
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.27.x matches `noir_js@0.27.x`, etc.
 
-In this guide, we will be pinned to 0.19.4.
+In this guide, we will be pinned to 0.27.0.
 
 :::
 
@@ -34,7 +34,7 @@ Easy enough. Onwards!
 
 ## Our project
 
-ZK is a powerful technology. An app that doesn't reveal one of the inputs to *anyone* is almost unbelievable, yet Noir makes it as easy as a single line of code.
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
 
 In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
 
@@ -42,13 +42,13 @@ In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
 
 Run:
 
-```nargo new circuit```
+`nargo new circuit`
 
 And... That's about it. Your program is ready to be compiled and run.
 
 To compile, let's `cd` into the `circuit` folder to enter our project, and call:
 
-```nargo compile```
+`nargo compile`
 
 This compiles our circuit into `json` format and add it to a new `target` folder.
 
@@ -77,10 +77,55 @@ Vite is a powerful tool to generate static websites. While it provides all kinds
 
 To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
 
-You should see `vite-project` appear in your root folder. This seems like a good time to `cd` into it and install our NoirJS packages:
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
 
 ```bash
-npm i @noir-lang/backend_barretenberg@0.19.4 @noir-lang/noir_js@0.19.4
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.27.0 @noir-lang/noir_js@0.27.0
+npm install rollup-plugin-copy --save-dev
 ```
 
 :::info
@@ -99,7 +144,7 @@ At this point in the tutorial, your folder structure should look like this:
 
 #### Some cleanup
 
-`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `index.html`, `main.js` and `package.json`. I feel lighter already.
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
 
 ![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
 
@@ -139,7 +184,7 @@ Our app won't run like this, of course. We need some working HTML, at least. Let
 </html>
 ```
 
-It *could* be a beautiful UI... Depending on which universe you live in.
+It _could_ be a beautiful UI... Depending on which universe you live in.
 
 ## Some good old vanilla Javascript
 
@@ -150,14 +195,14 @@ Start by pasting in this boilerplate code:
 ```js
 const setup = async () => {
   await Promise.all([
-    import("@noir-lang/noirc_abi").then(module => 
-      module.default(new URL("@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm", import.meta.url).toString())
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
     ),
-    import("@noir-lang/acvm_js").then(module => 
-      module.default(new URL("@noir-lang/acvm_js/web/acvm_js_bg.wasm", import.meta.url).toString())
-    )
   ]);
-}
+};
 
 function display(container, msg) {
   const c = document.getElementById(container);
@@ -169,11 +214,10 @@ function display(container, msg) {
 document.getElementById('submitGuess').addEventListener('click', async () => {
   try {
     // here's where love happens
-  } catch(err) {
-    display("logs", "Oh 💔 Wrong guess")
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
   }
 });
-
 ```
 
 The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
@@ -189,6 +233,7 @@ At this point in the tutorial, your folder structure should look like this:
 └── circuit
     └── ...same as above
 └── vite-project
+    ├── vite.config.js
     ├── main.js
     ├── package.json
     └── index.html
@@ -209,7 +254,7 @@ import circuit from '../circuit/target/circuit.json';
 [Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
 
 ```js
-import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
 import { Noir } from '@noir-lang/noir_js';
 ```
 
@@ -264,8 +309,10 @@ Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add th
 
 ```js
 display('logs', 'Verifying proof... ⌛');
-const verification = await noir.verifyProof(proof);
-if (verification) display('logs', 'Verifying proof... ✅');
+const verificationKey = await backend.getVerificationKey();
+const verifier = new Verifier();
+const isValid = await verifier.verifyProof(proof, verificationKey);
+if (isValid) display('logs', 'Verifying proof... ✅');
 ```
 
 You have successfully generated a client-side Noir web app!
diff --git a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
index 12beb476994..02044cd2ff6 100644
--- a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
@@ -14,9 +14,9 @@ You can find the complete app code for this guide [here](https://github.com/noir
 
 :::note
 
-Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.19.x matches `noir_js@0.19.x`, etc.
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.25.x matches `noir_js@0.25.x`, etc.
 
-In this guide, we will be pinned to 0.19.4.
+In this guide, we will be pinned to 0.25.0.
 
 :::
 
@@ -34,7 +34,7 @@ Easy enough. Onwards!
 
 ## Our project
 
-ZK is a powerful technology. An app that doesn't reveal one of the inputs to *anyone* is almost unbelievable, yet Noir makes it as easy as a single line of code.
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
 
 In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
 
@@ -42,13 +42,13 @@ In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
 
 Run:
 
-```nargo new circuit```
+`nargo new circuit`
 
 And... That's about it. Your program is ready to be compiled and run.
 
 To compile, let's `cd` into the `circuit` folder to enter our project, and call:
 
-```nargo compile```
+`nargo compile`
 
 This compiles our circuit into `json` format and add it to a new `target` folder.
 
@@ -77,10 +77,55 @@ Vite is a powerful tool to generate static websites. While it provides all kinds
 
 To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
 
-You should see `vite-project` appear in your root folder. This seems like a good time to `cd` into it and install our NoirJS packages:
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
 
 ```bash
-npm i @noir-lang/backend_barretenberg@0.19.4 @noir-lang/noir_js@0.19.4
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.25.0 @noir-lang/noir_js@0.25.0
+npm install rollup-plugin-copy --save-dev
 ```
 
 :::info
@@ -99,7 +144,7 @@ At this point in the tutorial, your folder structure should look like this:
 
 #### Some cleanup
 
-`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `index.html`, `main.js` and `package.json`. I feel lighter already.
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
 
 ![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
 
@@ -139,7 +184,7 @@ Our app won't run like this, of course. We need some working HTML, at least. Let
 </html>
 ```
 
-It *could* be a beautiful UI... Depending on which universe you live in.
+It _could_ be a beautiful UI... Depending on which universe you live in.
 
 ## Some good old vanilla Javascript
 
@@ -150,14 +195,14 @@ Start by pasting in this boilerplate code:
 ```js
 const setup = async () => {
   await Promise.all([
-    import("@noir-lang/noirc_abi").then(module => 
-      module.default(new URL("@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm", import.meta.url).toString())
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
     ),
-    import("@noir-lang/acvm_js").then(module => 
-      module.default(new URL("@noir-lang/acvm_js/web/acvm_js_bg.wasm", import.meta.url).toString())
-    )
   ]);
-}
+};
 
 function display(container, msg) {
   const c = document.getElementById(container);
@@ -169,11 +214,10 @@ function display(container, msg) {
 document.getElementById('submitGuess').addEventListener('click', async () => {
   try {
     // here's where love happens
-  } catch(err) {
-    display("logs", "Oh 💔 Wrong guess")
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
   }
 });
-
 ```
 
 The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
@@ -189,6 +233,7 @@ At this point in the tutorial, your folder structure should look like this:
 └── circuit
     └── ...same as above
 └── vite-project
+    └── vite.config.js
     ├── main.js
     ├── package.json
     └── index.html
diff --git a/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
index 12beb476994..d098827e6d9 100644
--- a/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
@@ -14,9 +14,9 @@ You can find the complete app code for this guide [here](https://github.com/noir
 
 :::note
 
-Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.19.x matches `noir_js@0.19.x`, etc.
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.26.x matches `noir_js@0.26.x`, etc.
 
-In this guide, we will be pinned to 0.19.4.
+In this guide, we will be pinned to 0.26.0.
 
 :::
 
@@ -34,7 +34,7 @@ Easy enough. Onwards!
 
 ## Our project
 
-ZK is a powerful technology. An app that doesn't reveal one of the inputs to *anyone* is almost unbelievable, yet Noir makes it as easy as a single line of code.
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
 
 In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
 
@@ -42,13 +42,13 @@ In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
 
 Run:
 
-```nargo new circuit```
+`nargo new circuit`
 
 And... That's about it. Your program is ready to be compiled and run.
 
 To compile, let's `cd` into the `circuit` folder to enter our project, and call:
 
-```nargo compile```
+`nargo compile`
 
 This compiles our circuit into `json` format and add it to a new `target` folder.
 
@@ -77,10 +77,55 @@ Vite is a powerful tool to generate static websites. While it provides all kinds
 
 To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
 
-You should see `vite-project` appear in your root folder. This seems like a good time to `cd` into it and install our NoirJS packages:
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
 
 ```bash
-npm i @noir-lang/backend_barretenberg@0.19.4 @noir-lang/noir_js@0.19.4
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.26.0 @noir-lang/noir_js@0.26.0
+npm install rollup-plugin-copy --save-dev
 ```
 
 :::info
@@ -99,7 +144,7 @@ At this point in the tutorial, your folder structure should look like this:
 
 #### Some cleanup
 
-`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `index.html`, `main.js` and `package.json`. I feel lighter already.
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
 
 ![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
 
@@ -139,7 +184,7 @@ Our app won't run like this, of course. We need some working HTML, at least. Let
 </html>
 ```
 
-It *could* be a beautiful UI... Depending on which universe you live in.
+It _could_ be a beautiful UI... Depending on which universe you live in.
 
 ## Some good old vanilla Javascript
 
@@ -150,14 +195,14 @@ Start by pasting in this boilerplate code:
 ```js
 const setup = async () => {
   await Promise.all([
-    import("@noir-lang/noirc_abi").then(module => 
-      module.default(new URL("@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm", import.meta.url).toString())
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
     ),
-    import("@noir-lang/acvm_js").then(module => 
-      module.default(new URL("@noir-lang/acvm_js/web/acvm_js_bg.wasm", import.meta.url).toString())
-    )
   ]);
-}
+};
 
 function display(container, msg) {
   const c = document.getElementById(container);
@@ -169,11 +214,10 @@ function display(container, msg) {
 document.getElementById('submitGuess').addEventListener('click', async () => {
   try {
     // here's where love happens
-  } catch(err) {
-    display("logs", "Oh 💔 Wrong guess")
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
   }
 });
-
 ```
 
 The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
@@ -189,6 +233,7 @@ At this point in the tutorial, your folder structure should look like this:
 └── circuit
     └── ...same as above
 └── vite-project
+    └── vite.config.js
     ├── main.js
     ├── package.json
     └── index.html

From 964edffcd11e7589f612b1f28686012af64ed8bd Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 22 Apr 2024 17:19:51 +0100
Subject: [PATCH 205/416] chore: bump MSRV to `1.74.1` (#4873)

# Description

## Problem\*

Resolves #4818

## Summary\*

This PR bumps the MSRV to 1.74.1 to address the publishing issues caused
by clap bumping its MSRV.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/docs-pr.yml                  |  2 +-
 .github/workflows/formatting.yml               |  4 ++--
 .github/workflows/gates_report.yml             |  2 +-
 .github/workflows/publish-acvm.yml             |  2 +-
 .github/workflows/publish-es-packages.yml      |  6 +++---
 .github/workflows/publish-nargo.yml            |  4 ++--
 .github/workflows/test-js-packages.yml         |  8 ++++----
 .github/workflows/test-rust-workspace-msrv.yml |  4 ++--
 .github/workflows/test-rust-workspace.yml      |  4 ++--
 CHANGELOG.md                                   |  2 +-
 Cargo.lock                                     |  4 +---
 Cargo.toml                                     |  2 +-
 README.md                                      |  2 +-
 compiler/fm/Cargo.toml                         |  1 +
 compiler/noirc_driver/Cargo.toml               |  1 +
 compiler/noirc_errors/Cargo.toml               |  1 +
 compiler/noirc_evaluator/Cargo.toml            |  1 +
 compiler/noirc_frontend/Cargo.toml             |  1 +
 compiler/noirc_printable_type/Cargo.toml       |  1 +
 compiler/utils/arena/Cargo.toml                |  1 +
 compiler/utils/iter-extended/Cargo.toml        |  1 +
 compiler/wasm/Cargo.toml                       |  1 +
 rust-toolchain.toml                            |  2 +-
 tooling/backend_interface/Cargo.toml           |  2 +-
 tooling/debugger/Cargo.toml                    |  1 +
 tooling/lsp/Cargo.toml                         |  3 ++-
 tooling/nargo/Cargo.toml                       |  4 +---
 tooling/nargo/build.rs                         | 12 ------------
 tooling/nargo_cli/Cargo.toml                   |  2 +-
 tooling/nargo_cli/build.rs                     | 10 ----------
 tooling/nargo_fmt/Cargo.toml                   |  1 +
 tooling/nargo_toml/Cargo.toml                  |  1 +
 tooling/noirc_abi/Cargo.toml                   |  1 +
 33 files changed, 41 insertions(+), 53 deletions(-)
 delete mode 100644 tooling/nargo/build.rs

diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index 1f9ccdd946b..945ed555639 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -55,7 +55,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml
index 279e90f5f6f..8166fb0f7c2 100644
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@@ -32,7 +32,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: ${{ matrix.target }}
           components: clippy, rustfmt
@@ -73,7 +73,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index be55236c40f..e694e5fad04 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -18,7 +18,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
diff --git a/.github/workflows/publish-acvm.yml b/.github/workflows/publish-acvm.yml
index d17d8f294fb..feb4d4216c3 100644
--- a/.github/workflows/publish-acvm.yml
+++ b/.github/workflows/publish-acvm.yml
@@ -18,7 +18,7 @@ jobs:
           ref: ${{ inputs.noir-ref }}
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       # These steps are in a specific order so crate dependencies are updated first
       - name: Publish acir_field
diff --git a/.github/workflows/publish-es-packages.yml b/.github/workflows/publish-es-packages.yml
index 819be308169..682fed69c7b 100644
--- a/.github/workflows/publish-es-packages.yml
+++ b/.github/workflows/publish-es-packages.yml
@@ -24,7 +24,7 @@ jobs:
           ref: ${{ inputs.noir-ref }}
       
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -58,7 +58,7 @@ jobs:
           ref: ${{ inputs.noir-ref }}
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -95,7 +95,7 @@ jobs:
           ref: ${{ inputs.noir-ref }}
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
diff --git a/.github/workflows/publish-nargo.yml b/.github/workflows/publish-nargo.yml
index e47e1a13053..85010503b00 100644
--- a/.github/workflows/publish-nargo.yml
+++ b/.github/workflows/publish-nargo.yml
@@ -46,7 +46,7 @@ jobs:
           echo "MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx$(sw_vers -productVersion) --show-sdk-platform-version)" >> $GITHUB_ENV
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: ${{ matrix.target }}
 
@@ -120,7 +120,7 @@ jobs:
           ref: ${{ inputs.tag || env.GITHUB_REF }}
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: ${{ matrix.target }}
 
diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index 06a96ee8932..7fd198d9a89 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -22,7 +22,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -55,7 +55,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -88,7 +88,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -123,7 +123,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
 
       - uses: Swatinem/rust-cache@v2
         with:
diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index cdd7a064a8d..c13b0815d94 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -29,7 +29,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: x86_64-unknown-linux-gnu
 
@@ -72,7 +72,7 @@ jobs:
       - uses: actions/checkout@v4
       
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: x86_64-unknown-linux-gnu
 
diff --git a/.github/workflows/test-rust-workspace.yml b/.github/workflows/test-rust-workspace.yml
index 22684de3044..cf35950fa3e 100644
--- a/.github/workflows/test-rust-workspace.yml
+++ b/.github/workflows/test-rust-workspace.yml
@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: x86_64-unknown-linux-gnu
 
@@ -59,7 +59,7 @@ jobs:
       - uses: actions/checkout@v4
       
       - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.73.0
+        uses: dtolnay/rust-toolchain@1.74.1
         with:
           targets: x86_64-unknown-linux-gnu
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0ab84df44e7..a084811fc21 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -109,7 +109,7 @@
 * reserve `unchecked` keyword ([#4432](https://github.com/noir-lang/noir/issues/4432))
 * Remove empty value from bounded vec ([#4431](https://github.com/noir-lang/noir/issues/4431))
 * Ban Fields in for loop indices and bitwise ops ([#4376](https://github.com/noir-lang/noir/issues/4376))
-* bump msrv to 1.73.0 ([#4406](https://github.com/noir-lang/noir/issues/4406))
+* Bump msrv to 1.73.0 ([#4406](https://github.com/noir-lang/noir/issues/4406))
 * **ci:** Bump MSRV to 1.72.1 and enforce that ACVM can be published using updated lockfile ([#4385](https://github.com/noir-lang/noir/issues/4385))
 * Restrict bit sizes ([#4235](https://github.com/noir-lang/noir/issues/4235))
 * move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
diff --git a/Cargo.lock b/Cargo.lock
index b01c22ed75b..35702c8df03 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -456,7 +456,7 @@ dependencies = [
 
 [[package]]
 name = "backend-interface"
-version = "0.11.0"
+version = "0.27.0"
 dependencies = [
  "acvm",
  "bb_abstraction_leaks",
@@ -2827,7 +2827,6 @@ dependencies = [
  "noirc_frontend",
  "noirc_printable_type",
  "rayon",
- "rustc_version",
  "serde",
  "tempfile",
  "thiserror",
@@ -2872,7 +2871,6 @@ dependencies = [
  "predicates 2.1.5",
  "prettytable-rs",
  "rayon",
- "rustc_version",
  "serde",
  "serde_json",
  "similar-asserts",
diff --git a/Cargo.toml b/Cargo.toml
index cdbb40f630a..132ff181e44 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,7 +45,7 @@ version = "0.27.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
-rust-version = "1.73.0"
+rust-version = "1.74.1"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/noir-lang/noir/"
 
diff --git a/README.md b/README.md
index 3162ff54ab9..eea2280c50c 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ The current focus is to gather as much feedback as possible while in the alpha p
 
 ## Minimum Rust version
 
-This workspace's minimum supported rustc version is 1.73.0.
+This workspace's minimum supported rustc version is 1.74.1.
 
 ## License
 
diff --git a/compiler/fm/Cargo.toml b/compiler/fm/Cargo.toml
index 42e4b0c25d7..f556f305c78 100644
--- a/compiler/fm/Cargo.toml
+++ b/compiler/fm/Cargo.toml
@@ -3,6 +3,7 @@ name = "fm"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/noirc_driver/Cargo.toml b/compiler/noirc_driver/Cargo.toml
index a7fe0b4b610..495410b7b06 100644
--- a/compiler/noirc_driver/Cargo.toml
+++ b/compiler/noirc_driver/Cargo.toml
@@ -3,6 +3,7 @@ name = "noirc_driver"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/noirc_errors/Cargo.toml b/compiler/noirc_errors/Cargo.toml
index da18399971e..c9cb7e2709f 100644
--- a/compiler/noirc_errors/Cargo.toml
+++ b/compiler/noirc_errors/Cargo.toml
@@ -3,6 +3,7 @@ name = "noirc_errors"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index fb2f003aa56..aa30eef9156 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -3,6 +3,7 @@ name = "noirc_evaluator"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index 7a23585bd23..84c9393fa37 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -3,6 +3,7 @@ name = "noirc_frontend"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/noirc_printable_type/Cargo.toml b/compiler/noirc_printable_type/Cargo.toml
index fbbe778e561..5140f5a5a8c 100644
--- a/compiler/noirc_printable_type/Cargo.toml
+++ b/compiler/noirc_printable_type/Cargo.toml
@@ -3,6 +3,7 @@ name = "noirc_printable_type"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/utils/arena/Cargo.toml b/compiler/utils/arena/Cargo.toml
index 41c6ebc9a8b..f6bd764ee62 100644
--- a/compiler/utils/arena/Cargo.toml
+++ b/compiler/utils/arena/Cargo.toml
@@ -3,4 +3,5 @@ name = "arena"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
diff --git a/compiler/utils/iter-extended/Cargo.toml b/compiler/utils/iter-extended/Cargo.toml
index c91e5ea6d77..4343311506e 100644
--- a/compiler/utils/iter-extended/Cargo.toml
+++ b/compiler/utils/iter-extended/Cargo.toml
@@ -3,6 +3,7 @@ name = "iter-extended"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/compiler/wasm/Cargo.toml b/compiler/wasm/Cargo.toml
index a20efeeed8a..31ef5161014 100644
--- a/compiler/wasm/Cargo.toml
+++ b/compiler/wasm/Cargo.toml
@@ -3,6 +3,7 @@ name = "noir_wasm"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 0e5ac891ce9..fe2949c8458 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.73.0"
+channel = "1.74.1"
 components = [ "rust-src" ]
 targets = [ "wasm32-unknown-unknown", "wasm32-wasi", "aarch64-apple-darwin" ]
 profile = "default"
diff --git a/tooling/backend_interface/Cargo.toml b/tooling/backend_interface/Cargo.toml
index 2d991f9ae6c..b731c138c7d 100644
--- a/tooling/backend_interface/Cargo.toml
+++ b/tooling/backend_interface/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "backend-interface"
 description = "The definition of the backend CLI interface which Nargo uses for proving/verifying ACIR circuits."
-version = "0.11.0"
+version.workspace = true
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
diff --git a/tooling/debugger/Cargo.toml b/tooling/debugger/Cargo.toml
index 30d11db8cf3..a3bf12f5368 100644
--- a/tooling/debugger/Cargo.toml
+++ b/tooling/debugger/Cargo.toml
@@ -4,6 +4,7 @@ description = "Debugger for Noir"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 [build-dependencies]
diff --git a/tooling/lsp/Cargo.toml b/tooling/lsp/Cargo.toml
index 750e85694e2..a599b096e52 100644
--- a/tooling/lsp/Cargo.toml
+++ b/tooling/lsp/Cargo.toml
@@ -3,7 +3,8 @@ name = "noir_lsp"
 description = "Language server for Noir"
 version.workspace = true
 authors.workspace = true
-edition.workspace = true
+edition.workspace = true#
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/tooling/nargo/Cargo.toml b/tooling/nargo/Cargo.toml
index efd38a182e0..72b412ac5b9 100644
--- a/tooling/nargo/Cargo.toml
+++ b/tooling/nargo/Cargo.toml
@@ -4,13 +4,11 @@ description = "Noir's package manager"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[build-dependencies]
-rustc_version = "0.4.0"
-
 [dependencies]
 acvm.workspace = true
 fm.workspace = true
diff --git a/tooling/nargo/build.rs b/tooling/nargo/build.rs
deleted file mode 100644
index ab2b7579132..00000000000
--- a/tooling/nargo/build.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use rustc_version::{version, Version};
-
-fn check_rustc_version() {
-    assert!(
-        version().unwrap() >= Version::parse("1.73.0").unwrap(),
-        "The minimal supported rustc version is 1.73.0."
-    );
-}
-
-fn main() {
-    check_rustc_version();
-}
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index 111caaa9c92..c20be037e62 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -5,6 +5,7 @@ default-run = "nargo"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -15,7 +16,6 @@ name = "nargo"
 path = "src/main.rs"
 
 [build-dependencies]
-rustc_version = "0.4.0"
 build-data.workspace = true
 toml.workspace = true
 
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index bf97dfb3e96..0ed2d4c07f7 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -1,21 +1,11 @@
-use rustc_version::{version, Version};
 use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::{env, fs};
 
-fn check_rustc_version() {
-    assert!(
-        version().unwrap() >= Version::parse("1.73.0").unwrap(),
-        "The minimal supported rustc version is 1.73.0."
-    );
-}
-
 const GIT_COMMIT: &&str = &"GIT_COMMIT";
 
 fn main() {
-    check_rustc_version();
-
     // Only use build_data if the environment variable isn't set.
     if std::env::var(GIT_COMMIT).is_err() {
         build_data::set_GIT_COMMIT();
diff --git a/tooling/nargo_fmt/Cargo.toml b/tooling/nargo_fmt/Cargo.toml
index 374413ac9f2..05b2fdb7d52 100644
--- a/tooling/nargo_fmt/Cargo.toml
+++ b/tooling/nargo_fmt/Cargo.toml
@@ -3,6 +3,7 @@ name = "nargo_fmt"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 [dependencies]
diff --git a/tooling/nargo_toml/Cargo.toml b/tooling/nargo_toml/Cargo.toml
index c835ddd936c..574972d99e7 100644
--- a/tooling/nargo_toml/Cargo.toml
+++ b/tooling/nargo_toml/Cargo.toml
@@ -4,6 +4,7 @@ description = "Utilities for working with Nargo.toml files"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index b7fe1ef8084..3258ea04c40 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -3,6 +3,7 @@ name = "noirc_abi"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

From 84c990347c1e02b5f5d77a217c119b5f181de715 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 22 Apr 2024 17:25:03 +0100
Subject: [PATCH 206/416] chore: remove initialisation of logger in `acvm_js`
 tests (#4850)

# Description

## Problem\*


## Summary\*

We're intermittently failing in CI due to #4849 however this
initialisation is not strictly necessary. I'm then disabling it until a
permanent fix is in place.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts b/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts
index 3c54fe8e38f..695f6b89afc 100644
--- a/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts
+++ b/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts
@@ -4,7 +4,6 @@ import initACVM, {
   blake2s256,
   ecdsa_secp256k1_verify,
   ecdsa_secp256r1_verify,
-  initLogLevel,
   keccak256,
   sha256,
   xor,
@@ -12,8 +11,6 @@ import initACVM, {
 
 beforeEach(async () => {
   await initACVM();
-
-  initLogLevel('INFO');
 });
 
 it('successfully calculates the bitwise AND of two fields', async () => {

From 19583ba2307afcbe5678b470468175057d1f99f0 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 22 Apr 2024 17:34:28 +0100
Subject: [PATCH 207/416] chore: more explicit `self` parameter in `Into` trait
 (#4867)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR just updates the `Into` trait definition to use a more explicit
`self` parameter.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/convert.nr | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/noir_stdlib/src/convert.nr b/noir_stdlib/src/convert.nr
index 00ac0a0fd8c..d3537df3c5e 100644
--- a/noir_stdlib/src/convert.nr
+++ b/noir_stdlib/src/convert.nr
@@ -12,12 +12,12 @@ impl<T> From<T> for T {
 
 // docs:start:into-trait
 trait Into<T> {
-    fn into(input: Self) -> T;
+    fn into(self) -> T;
 }
 
 impl<T, U> Into<T> for U where T: From<U> {
-  fn into(input: U) -> T {
-      T::from(input)
+  fn into(self) -> T {
+      T::from(self)
   }
 }
 // docs:end:into-trait

From 3614d00d251cb44ffc3bde1c089d84e807e77b74 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 22 Apr 2024 17:34:49 +0100
Subject: [PATCH 208/416] chore: remove `SecondaryAttribute::Event` (#4868)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This attribute is now no longer used internally by the compiler so we
can just remove it.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/lexer/token.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index b4b785f2c81..a00de4f2547 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -659,7 +659,6 @@ impl Attribute {
             ["contract_library_method"] => {
                 Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod)
             }
-            ["event"] => Attribute::Secondary(SecondaryAttribute::Event),
             ["abi", tag] => Attribute::Secondary(SecondaryAttribute::Abi(tag.to_string())),
             ["export"] => Attribute::Secondary(SecondaryAttribute::Export),
             ["deprecated", name] => {
@@ -751,7 +750,6 @@ pub enum SecondaryAttribute {
     // is a helper method for a contract and should not be seen as
     // the entry point.
     ContractLibraryMethod,
-    Event,
     Export,
     Field(String),
     Custom(String),
@@ -767,7 +765,6 @@ impl fmt::Display for SecondaryAttribute {
             }
             SecondaryAttribute::Custom(ref k) => write!(f, "#[{k}]"),
             SecondaryAttribute::ContractLibraryMethod => write!(f, "#[contract_library_method]"),
-            SecondaryAttribute::Event => write!(f, "#[event]"),
             SecondaryAttribute::Export => write!(f, "#[export]"),
             SecondaryAttribute::Field(ref k) => write!(f, "#[field({k})]"),
             SecondaryAttribute::Abi(ref k) => write!(f, "#[abi({k})]"),
@@ -797,7 +794,7 @@ impl AsRef<str> for SecondaryAttribute {
             | SecondaryAttribute::Field(string)
             | SecondaryAttribute::Abi(string) => string,
             SecondaryAttribute::ContractLibraryMethod => "",
-            SecondaryAttribute::Event | SecondaryAttribute::Export => "",
+            SecondaryAttribute::Export => "",
         }
     }
 }

From 1969ce39378f633e88adedf43b747724b89ed7d7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 22 Apr 2024 17:35:36 +0100
Subject: [PATCH 209/416] chore: remove pub wildcard import of ast into
 `noirc_frontend` root (#4862)

# Description

## Problem\*

Related to #4852

## Summary\*

This PR removes the wildcard import of the `ast` module into the root of
the `noirc_frontend` crate. This encourages us to be more qualified
usage of the ast to make it clearer about which we're working with.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../compute_note_hash_and_nullifier.rs        |  3 ++-
 .../src/transforms/contract_interface.rs      |  5 ++--
 aztec_macros/src/transforms/events.rs         |  6 +++--
 aztec_macros/src/transforms/functions.rs      | 15 ++++++-----
 aztec_macros/src/transforms/note_interface.rs |  8 ++++--
 aztec_macros/src/transforms/storage.rs        |  8 +++---
 aztec_macros/src/utils/ast_utils.rs           | 11 ++++----
 aztec_macros/src/utils/errors.rs              |  9 ++++---
 aztec_macros/src/utils/hir_utils.rs           | 13 +++++-----
 compiler/noirc_driver/src/abi_gen.rs          |  2 +-
 compiler/noirc_evaluator/src/ssa.rs           |  5 ++--
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 10 ++++----
 .../src/ssa/function_builder/data_bus.rs      |  5 ++--
 .../src/ssa/ssa_gen/context.rs                | 20 +++++++--------
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    | 16 ++++++------
 compiler/noirc_frontend/src/ast/expression.rs |  4 +--
 compiler/noirc_frontend/src/ast/function.rs   |  2 +-
 compiler/noirc_frontend/src/ast/statement.rs  | 21 ++++++++--------
 compiler/noirc_frontend/src/ast/structure.rs  |  4 ++-
 compiler/noirc_frontend/src/ast/traits.rs     |  7 +++---
 compiler/noirc_frontend/src/ast/type_alias.rs |  2 +-
 .../src/hir/comptime/hir_to_ast.rs            | 15 +++++------
 .../src/hir/comptime/interpreter.rs           | 13 +++++-----
 .../src/hir/def_collector/dc_crate.rs         |  8 +++---
 .../src/hir/def_collector/dc_mod.rs           |  6 +++--
 .../src/hir/def_collector/errors.rs           |  3 +--
 .../src/hir/def_map/item_scope.rs             |  7 +++---
 .../src/hir/def_map/module_data.rs            |  7 ++----
 .../src/hir/def_map/namespace.rs              |  2 +-
 .../src/hir/resolution/errors.rs              |  4 +--
 .../src/hir/resolution/impls.rs               |  3 ++-
 .../src/hir/resolution/import.rs              |  2 +-
 .../src/hir/resolution/path_resolver.rs       |  2 +-
 .../src/hir/resolution/resolver.rs            | 25 ++++++++-----------
 .../src/hir/resolution/structs.rs             |  3 ++-
 .../src/hir/resolution/traits.rs              |  3 ++-
 .../src/hir/type_check/errors.rs              |  5 +---
 .../noirc_frontend/src/hir/type_check/expr.rs | 17 +++++++------
 .../noirc_frontend/src/hir/type_check/mod.rs  |  6 +++--
 .../noirc_frontend/src/hir/type_check/stmt.rs |  2 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |  5 ++--
 .../noirc_frontend/src/hir_def/function.rs    |  4 +--
 compiler/noirc_frontend/src/hir_def/stmt.rs   |  3 ++-
 compiler/noirc_frontend/src/hir_def/traits.rs |  3 ++-
 compiler/noirc_frontend/src/hir_def/types.rs  |  7 ++++--
 compiler/noirc_frontend/src/lexer/token.rs    |  4 +--
 compiler/noirc_frontend/src/lib.rs            | 20 +++++++--------
 .../src/monomorphization/ast.rs               |  8 +++---
 .../src/monomorphization/mod.rs               | 12 ++++-----
 compiler/noirc_frontend/src/node_interner.rs  |  8 +++---
 .../noirc_frontend/src/noir_parser.lalrpop    |  2 +-
 compiler/noirc_frontend/src/parser/errors.rs  |  3 +--
 compiler/noirc_frontend/src/parser/mod.rs     |  9 +++----
 compiler/noirc_frontend/src/parser/parser.rs  | 14 +++++------
 .../src/parser/parser/assertion.rs            |  4 +--
 .../src/parser/parser/function.rs             |  8 +++---
 .../src/parser/parser/lambdas.rs              |  5 ++--
 .../src/parser/parser/literals.rs             |  4 +--
 .../noirc_frontend/src/parser/parser/path.rs  |  2 +-
 .../src/parser/parser/primitives.rs           |  2 +-
 .../src/parser/parser/structs.rs              |  2 +-
 .../src/parser/parser/traits.rs               |  6 +++--
 tooling/nargo_fmt/src/rewrite/array.rs        |  2 +-
 tooling/nargo_fmt/src/rewrite/expr.rs         |  6 ++---
 tooling/nargo_fmt/src/rewrite/imports.rs      | 14 +++++------
 tooling/nargo_fmt/src/rewrite/infix.rs        |  2 +-
 .../nargo_fmt/src/rewrite/parenthesized.rs    |  3 ++-
 tooling/nargo_fmt/src/rewrite/typ.rs          |  2 +-
 tooling/nargo_fmt/src/utils.rs                |  2 +-
 tooling/nargo_fmt/src/visitor/expr.rs         |  7 +++---
 tooling/nargo_fmt/src/visitor/item.rs         | 14 +++++------
 tooling/nargo_fmt/src/visitor/stmt.rs         |  7 +++---
 tooling/noirc_abi/src/lib.rs                  |  3 ++-
 73 files changed, 263 insertions(+), 243 deletions(-)

diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index 4ff97a5dcae..70d05e5c59e 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -1,8 +1,9 @@
 use noirc_errors::{Location, Span};
+use noirc_frontend::ast::{FunctionReturnType, NoirFunction, UnresolvedTypeData};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext},
-    parse_program, FunctionReturnType, NoirFunction, Type, UnresolvedTypeData,
+    parse_program, Type,
 };
 
 use crate::utils::{
diff --git a/aztec_macros/src/transforms/contract_interface.rs b/aztec_macros/src/transforms/contract_interface.rs
index 4401c867df9..5f68ce98c8a 100644
--- a/aztec_macros/src/transforms/contract_interface.rs
+++ b/aztec_macros/src/transforms/contract_interface.rs
@@ -1,9 +1,10 @@
+use noirc_frontend::ast::{NoirFunction, UnresolvedTypeData};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
     parse_program,
     parser::SortedModule,
-    NoirFunction, Type, UnresolvedTypeData,
+    Type,
 };
 
 use crate::utils::{
@@ -52,7 +53,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
         })
         .collect::<Vec<_>>()
         .join(", ");
-    let fn_return_type: noirc_frontend::UnresolvedType = func.return_type();
+    let fn_return_type: noirc_frontend::ast::UnresolvedType = func.return_type();
 
     let fn_selector = format!("dep::aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature(\"{}\")", SELECTOR_PLACEHOLDER);
 
diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
index b77a5821b81..9c8cd826360 100644
--- a/aztec_macros/src/transforms/events.rs
+++ b/aztec_macros/src/transforms/events.rs
@@ -1,5 +1,9 @@
 use iter_extended::vecmap;
 use noirc_errors::Span;
+use noirc_frontend::ast::{
+    ExpressionKind, FunctionDefinition, FunctionReturnType, ItemVisibility, Literal, NoirFunction,
+    Visibility,
+};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{
@@ -8,8 +12,6 @@ use noirc_frontend::{
         UnresolvedTypeData,
     },
     token::SecondaryAttribute,
-    ExpressionKind, FunctionDefinition, FunctionReturnType, ItemVisibility, Literal, NoirFunction,
-    Visibility,
 };
 
 use crate::{
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 534d24289b7..dd7a416b941 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -1,12 +1,15 @@
 use convert_case::{Case, Casing};
 use noirc_errors::Span;
-use noirc_frontend::{
-    macros_api::FieldElement, parse_program, BlockExpression, ConstrainKind, ConstrainStatement,
-    Distinctness, Expression, ExpressionKind, ForLoopStatement, ForRange, FunctionReturnType,
-    Ident, Literal, NoirFunction, NoirStruct, Param, PathKind, Pattern, Signedness, Statement,
-    StatementKind, UnresolvedType, UnresolvedTypeData, Visibility,
+use noirc_frontend::ast;
+use noirc_frontend::ast::{
+    BlockExpression, ConstrainKind, ConstrainStatement, Distinctness, Expression, ExpressionKind,
+    ForLoopStatement, ForRange, FunctionReturnType, Ident, Literal, NoirFunction, NoirStruct,
+    Param, PathKind, Pattern, Signedness, Statement, StatementKind, UnresolvedType,
+    UnresolvedTypeData, Visibility,
 };
 
+use noirc_frontend::{macros_api::FieldElement, parse_program};
+
 use crate::{
     chained_dep, chained_path,
     utils::{
@@ -334,7 +337,7 @@ fn serialize_to_hasher(
                 &UnresolvedType {
                     typ: UnresolvedTypeData::Integer(
                         Signedness::Unsigned,
-                        noirc_frontend::IntegerBitSize::ThirtyTwo,
+                        ast::IntegerBitSize::ThirtyTwo,
                     ),
                     span: None,
                 },
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index 4b72759a5db..70db1ebd336 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -1,12 +1,16 @@
 use noirc_errors::Span;
+use noirc_frontend::ast::{
+    ItemVisibility, LetStatement, NoirFunction, NoirStruct, PathKind, TraitImplItem, TypeImpl,
+    UnresolvedTypeData, UnresolvedTypeExpression,
+};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
     parse_program,
     parser::SortedModule,
-    ItemVisibility, LetStatement, NoirFunction, NoirStruct, PathKind, TraitImplItem, Type,
-    TypeImpl, UnresolvedTypeData, UnresolvedTypeExpression,
+    Type,
 };
+
 use regex::Regex;
 
 use crate::{
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 9135be32443..49fcee9fe29 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -1,6 +1,10 @@
 use std::borrow::Borrow;
 
 use noirc_errors::Span;
+use noirc_frontend::ast::{
+    BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
+    NoirStruct, PathKind, Pattern, StatementKind, TypeImpl, UnresolvedType, UnresolvedTypeData,
+};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{
@@ -10,9 +14,7 @@ use noirc_frontend::{
     parse_program,
     parser::SortedModule,
     token::SecondaryAttribute,
-    BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
-    NoirStruct, PathKind, Pattern, StatementKind, Type, TypeImpl, UnresolvedType,
-    UnresolvedTypeData,
+    Type,
 };
 
 use crate::{
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index d0d7077a946..ebb4854f86e 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -1,10 +1,11 @@
 use noirc_errors::{Span, Spanned};
-use noirc_frontend::{
-    token::SecondaryAttribute, BinaryOpKind, CallExpression, CastExpression, Expression,
-    ExpressionKind, FunctionReturnType, Ident, IndexExpression, InfixExpression, Lambda,
-    LetStatement, MethodCallExpression, NoirTraitImpl, Path, Pattern, PrefixExpression, Statement,
-    StatementKind, TraitImplItem, UnaryOp, UnresolvedType, UnresolvedTypeData,
+use noirc_frontend::ast::{
+    BinaryOpKind, CallExpression, CastExpression, Expression, ExpressionKind, FunctionReturnType,
+    Ident, IndexExpression, InfixExpression, Lambda, LetStatement, MethodCallExpression,
+    NoirTraitImpl, Path, Pattern, PrefixExpression, Statement, StatementKind, TraitImplItem,
+    UnaryOp, UnresolvedType, UnresolvedTypeData,
 };
+use noirc_frontend::token::SecondaryAttribute;
 
 //
 //             Helper macros for creating noir ast nodes
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 4c5411dfe0f..db86012a007 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -1,5 +1,6 @@
 use noirc_errors::Span;
-use noirc_frontend::{macros_api::MacroError, UnresolvedTypeData};
+use noirc_frontend::ast;
+use noirc_frontend::macros_api::MacroError;
 
 use super::constants::MAX_CONTRACT_PRIVATE_FUNCTIONS;
 
@@ -7,9 +8,9 @@ use super::constants::MAX_CONTRACT_PRIVATE_FUNCTIONS;
 pub enum AztecMacroError {
     AztecDepNotFound,
     ContractHasTooManyPrivateFunctions { span: Span },
-    UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
-    UnsupportedFunctionReturnType { span: Span, typ: UnresolvedTypeData },
-    UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
+    UnsupportedFunctionArgumentType { span: Span, typ: ast::UnresolvedTypeData },
+    UnsupportedFunctionReturnType { span: Span, typ: ast::UnresolvedTypeData },
+    UnsupportedStorageType { span: Option<Span>, typ: ast::UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
     CouldNotImplementComputeNoteHashAndNullifier { secondary_message: Option<String> },
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index ae895d2075c..cafa6ed38ca 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -1,5 +1,6 @@
 use iter_extended::vecmap;
 use noirc_errors::Location;
+use noirc_frontend::ast;
 use noirc_frontend::{
     graph::CrateId,
     hir::{
@@ -9,7 +10,7 @@ use noirc_frontend::{
     },
     macros_api::{FileId, HirContext, MacroError, ModuleDefId, StructId},
     node_interner::{FuncId, TraitId},
-    ItemVisibility, LetStatement, NoirFunction, Shared, Signedness, StructType, Type,
+    Shared, StructType, Type,
 };
 
 use super::ast_utils::is_custom_attribute;
@@ -65,8 +66,8 @@ pub fn collect_traits(context: &HirContext) -> Vec<TraitId> {
 /// Computes the aztec signature for a resolved type.
 pub fn signature_of_type(typ: &Type) -> String {
     match typ {
-        Type::Integer(Signedness::Signed, bit_size) => format!("i{}", bit_size),
-        Type::Integer(Signedness::Unsigned, bit_size) => format!("u{}", bit_size),
+        Type::Integer(ast::Signedness::Signed, bit_size) => format!("i{}", bit_size),
+        Type::Integer(ast::Signedness::Unsigned, bit_size) => format!("u{}", bit_size),
         Type::FieldElement => "Field".to_owned(),
         Type::Bool => "bool".to_owned(),
         Type::Array(len, typ) => {
@@ -165,7 +166,7 @@ pub fn get_contract_module_data(
 pub fn inject_fn(
     crate_id: &CrateId,
     context: &mut HirContext,
-    func: NoirFunction,
+    func: ast::NoirFunction,
     location: Location,
     module_id: LocalModuleId,
     file_id: FileId,
@@ -179,7 +180,7 @@ pub fn inject_fn(
     );
 
     context.def_map_mut(crate_id).unwrap().modules_mut()[module_id.0]
-        .declare_function(func.name_ident().clone(), ItemVisibility::Public, func_id)
+        .declare_function(func.name_ident().clone(), ast::ItemVisibility::Public, func_id)
         .map_err(|err| MacroError {
             primary_message: format!("Failed to declare autogenerated {} function", func.name()),
             secondary_message: Some(format!("Duplicate definition found {}", err.0)),
@@ -214,7 +215,7 @@ pub fn inject_fn(
 pub fn inject_global(
     crate_id: &CrateId,
     context: &mut HirContext,
-    global: LetStatement,
+    global: ast::LetStatement,
     module_id: LocalModuleId,
     file_id: FileId,
 ) {
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 86f10818dbc..51fe4986845 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -3,12 +3,12 @@ use std::collections::BTreeMap;
 use acvm::acir::native_types::Witness;
 use iter_extended::{btree_map, vecmap};
 use noirc_abi::{Abi, AbiParameter, AbiReturnType, AbiType, AbiValue};
+use noirc_frontend::ast::Visibility;
 use noirc_frontend::{
     hir::Context,
     hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern},
     macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
-    Visibility,
 };
 use std::ops::Range;
 
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 760340f1a88..3482a8c25c7 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -22,9 +22,8 @@ use acvm::acir::{
 
 use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
 
-use noirc_frontend::{
-    hir_def::function::FunctionSignature, monomorphization::ast::Program, Visibility,
-};
+use noirc_frontend::ast::Visibility;
+use noirc_frontend::{hir_def::function::FunctionSignature, monomorphization::ast::Program};
 use tracing::{span, Level};
 
 use self::{acir_gen::GeneratedAcir, ssa_gen::Ssa};
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 02b381d79fc..8b16ad51ca1 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -39,7 +39,7 @@ use acvm::{
 use fxhash::FxHashMap as HashMap;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
-use noirc_frontend::Distinctness;
+use noirc_frontend::ast::Distinctness;
 
 #[derive(Default)]
 struct SharedContext {
@@ -2595,7 +2595,7 @@ mod test {
         let ssa = builder.finish();
 
         let (acir_functions, _) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
+            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
         // Expected result:
         // main f0
@@ -2691,7 +2691,7 @@ mod test {
         let ssa = builder.finish();
 
         let (acir_functions, _) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
+            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
         // The expected result should look very similar to the abvoe test expect that the input witnesses of the `Call`
         // opcodes will be different. The changes can discerned from the checks below.
@@ -2782,7 +2782,7 @@ mod test {
         let ssa = builder.finish();
 
         let (acir_functions, _) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::Distinctness::Distinct)
+            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 3, "Should have three ACIR functions");
@@ -2894,7 +2894,7 @@ mod test {
         println!("{}", ssa);
 
         let (acir_functions, brillig_functions) = ssa
-            .into_acir(&brillig, noirc_frontend::Distinctness::Distinct)
+            .into_acir(&brillig, noirc_frontend::ast::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs b/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
index e785212f8d2..5f0660f5a79 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
@@ -3,6 +3,7 @@ use std::rc::Rc;
 use crate::ssa::ir::{types::Type, value::ValueId};
 use acvm::FieldElement;
 use fxhash::FxHashMap as HashMap;
+use noirc_frontend::ast;
 use noirc_frontend::hir_def::function::FunctionSignature;
 
 use super::FunctionBuilder;
@@ -33,8 +34,8 @@ impl DataBusBuilder {
 
         for param in &main_signature.0 {
             let is_databus = match param.2 {
-                noirc_frontend::Visibility::Public | noirc_frontend::Visibility::Private => false,
-                noirc_frontend::Visibility::DataBus => true,
+                ast::Visibility::Public | ast::Visibility::Private => false,
+                ast::Visibility::DataBus => true,
             };
             let len = param.1.field_count() as usize;
             params_is_databus.extend(vec![is_databus; len]);
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index 569e543ce40..e591a3d478c 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -4,9 +4,9 @@ use std::sync::{Mutex, RwLock};
 use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::Location;
+use noirc_frontend::ast::{BinaryOpKind, Signedness};
 use noirc_frontend::monomorphization::ast::{self, LocalId, Parameters};
 use noirc_frontend::monomorphization::ast::{FuncId, Program};
-use noirc_frontend::{BinaryOpKind, Signedness};
 
 use crate::errors::RuntimeError;
 use crate::ssa::function_builder::FunctionBuilder;
@@ -562,7 +562,7 @@ impl<'a> FunctionContext<'a> {
     pub(super) fn insert_binary(
         &mut self,
         mut lhs: ValueId,
-        operator: noirc_frontend::BinaryOpKind,
+        operator: BinaryOpKind,
         mut rhs: ValueId,
         location: Location,
     ) -> Values {
@@ -625,7 +625,7 @@ impl<'a> FunctionContext<'a> {
     fn insert_array_equality(
         &mut self,
         lhs: ValueId,
-        operator: noirc_frontend::BinaryOpKind,
+        operator: BinaryOpKind,
         rhs: ValueId,
         location: Location,
     ) -> Values {
@@ -1090,23 +1090,23 @@ impl<'a> FunctionContext<'a> {
 
 /// True if the given operator cannot be encoded directly and needs
 /// to be represented as !(some other operator)
-fn operator_requires_not(op: noirc_frontend::BinaryOpKind) -> bool {
-    use noirc_frontend::BinaryOpKind::*;
+fn operator_requires_not(op: BinaryOpKind) -> bool {
+    use BinaryOpKind::*;
     matches!(op, NotEqual | LessEqual | GreaterEqual)
 }
 
 /// True if the given operator cannot be encoded directly and needs
 /// to have its lhs and rhs swapped to be represented with another operator.
 /// Example: (a > b) needs to be represented as (b < a)
-fn operator_requires_swapped_operands(op: noirc_frontend::BinaryOpKind) -> bool {
-    use noirc_frontend::BinaryOpKind::*;
+fn operator_requires_swapped_operands(op: BinaryOpKind) -> bool {
+    use BinaryOpKind::*;
     matches!(op, Greater | LessEqual)
 }
 
 /// If the operation requires its result to be truncated because it is an integer, the maximum
 /// number of bits that result may occupy is returned.
 fn operator_result_max_bit_size_to_truncate(
-    op: noirc_frontend::BinaryOpKind,
+    op: BinaryOpKind,
     lhs: ValueId,
     rhs: ValueId,
     dfg: &DataFlowGraph,
@@ -1123,7 +1123,7 @@ fn operator_result_max_bit_size_to_truncate(
 
     let lhs_bit_size = get_bit_size(lhs_type)?;
     let rhs_bit_size = get_bit_size(rhs_type)?;
-    use noirc_frontend::BinaryOpKind::*;
+    use BinaryOpKind::*;
     match op {
         Add => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
         Subtract => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
@@ -1173,7 +1173,7 @@ fn operator_result_max_bit_size_to_truncate(
 /// Take care when using this to insert a binary instruction: this requires
 /// checking operator_requires_not and operator_requires_swapped_operands
 /// to represent the full operation correctly.
-fn convert_operator(op: noirc_frontend::BinaryOpKind) -> BinaryOp {
+fn convert_operator(op: BinaryOpKind) -> BinaryOp {
     match op {
         BinaryOpKind::Add => BinaryOp::Add,
         BinaryOpKind::Subtract => BinaryOp::Sub,
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 2a4b5276547..79f7cda4ae2 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -7,10 +7,8 @@ pub(crate) use program::Ssa;
 use context::SharedContext;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
-use noirc_frontend::{
-    monomorphization::ast::{self, Expression, Program},
-    Visibility,
-};
+use noirc_frontend::ast::{UnaryOp, Visibility};
+use noirc_frontend::monomorphization::ast::{self, Expression, Program};
 
 use crate::{
     errors::{InternalError, RuntimeError},
@@ -306,24 +304,24 @@ impl<'a> FunctionContext<'a> {
 
     fn codegen_unary(&mut self, unary: &ast::Unary) -> Result<Values, RuntimeError> {
         match unary.operator {
-            noirc_frontend::UnaryOp::Not => {
+            UnaryOp::Not => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 let rhs = rhs.into_leaf().eval(self);
                 Ok(self.builder.insert_not(rhs).into())
             }
-            noirc_frontend::UnaryOp::Minus => {
+            UnaryOp::Minus => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 let rhs = rhs.into_leaf().eval(self);
                 let typ = self.builder.type_of_value(rhs);
                 let zero = self.builder.numeric_constant(0u128, typ);
                 Ok(self.insert_binary(
                     zero,
-                    noirc_frontend::BinaryOpKind::Subtract,
+                    noirc_frontend::ast::BinaryOpKind::Subtract,
                     rhs,
                     unary.location,
                 ))
             }
-            noirc_frontend::UnaryOp::MutableReference => {
+            UnaryOp::MutableReference => {
                 Ok(self.codegen_reference(&unary.rhs)?.map(|rhs| {
                     match rhs {
                         value::Value::Normal(value) => {
@@ -338,7 +336,7 @@ impl<'a> FunctionContext<'a> {
                     }
                 }))
             }
-            noirc_frontend::UnaryOp::Dereference { .. } => {
+            UnaryOp::Dereference { .. } => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 Ok(self.dereference(&rhs, &unary.result_type))
             }
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 755739af8fe..92c1add80a6 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -1,11 +1,11 @@
 use std::borrow::Cow;
 use std::fmt::Display;
 
-use crate::token::{Attributes, Token};
-use crate::{
+use crate::ast::{
     Distinctness, Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
+use crate::token::{Attributes, Token};
 use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index 10d962a23f7..9816218c5f7 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -3,8 +3,8 @@ use std::fmt::Display;
 use noirc_errors::Span;
 
 use crate::{
+    ast::{FunctionReturnType, Ident, Param, Visibility},
     token::{Attributes, FunctionAttribute, SecondaryAttribute},
-    FunctionReturnType, Ident, Param, Visibility,
 };
 
 use super::{FunctionDefinition, UnresolvedType, UnresolvedTypeData};
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index c46ab39df1e..1831a046f5b 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -1,17 +1,18 @@
 use std::fmt::Display;
 use std::sync::atomic::{AtomicU32, Ordering};
 
+use acvm::FieldElement;
+use iter_extended::vecmap;
+use noirc_errors::{Span, Spanned};
+
+use super::{
+    BlockExpression, Expression, ExpressionKind, IndexExpression, MemberAccessExpression,
+    MethodCallExpression, UnresolvedType,
+};
 use crate::lexer::token::SpannedToken;
 use crate::macros_api::SecondaryAttribute;
 use crate::parser::{ParserError, ParserErrorReason};
 use crate::token::Token;
-use crate::{
-    BlockExpression, Expression, ExpressionKind, IndexExpression, MemberAccessExpression,
-    MethodCallExpression, UnresolvedType,
-};
-use acvm::FieldElement;
-use iter_extended::vecmap;
-use noirc_errors::{Span, Spanned};
 
 /// This is used when an identifier fails to parse in the parser.
 /// Instead of failing the parse, we can often recover using this
@@ -148,7 +149,7 @@ impl StatementKind {
             let lvalue_expr = lvalue.as_expression();
             let error_msg = "Token passed to Statement::assign is not a binary operator";
 
-            let infix = crate::InfixExpression {
+            let infix = crate::ast::InfixExpression {
                 lhs: lvalue_expr,
                 operator: operator.try_into_binary_op(span).expect(error_msg),
                 rhs: expression,
@@ -521,8 +522,8 @@ impl LValue {
                 }))
             }
             LValue::Dereference(lvalue, _span) => {
-                ExpressionKind::Prefix(Box::new(crate::PrefixExpression {
-                    operator: crate::UnaryOp::Dereference { implicitly_added: false },
+                ExpressionKind::Prefix(Box::new(crate::ast::PrefixExpression {
+                    operator: crate::ast::UnaryOp::Dereference { implicitly_added: false },
                     rhs: lvalue.as_expression(),
                 }))
             }
diff --git a/compiler/noirc_frontend/src/ast/structure.rs b/compiler/noirc_frontend/src/ast/structure.rs
index 6a32fa717f3..bda6b8c0b11 100644
--- a/compiler/noirc_frontend/src/ast/structure.rs
+++ b/compiler/noirc_frontend/src/ast/structure.rs
@@ -1,6 +1,8 @@
 use std::fmt::Display;
 
-use crate::{token::SecondaryAttribute, Ident, UnresolvedGenerics, UnresolvedType};
+use crate::ast::{Ident, UnresolvedGenerics, UnresolvedType};
+use crate::token::SecondaryAttribute;
+
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
diff --git a/compiler/noirc_frontend/src/ast/traits.rs b/compiler/noirc_frontend/src/ast/traits.rs
index 775f0a5f2b4..772675723b5 100644
--- a/compiler/noirc_frontend/src/ast/traits.rs
+++ b/compiler/noirc_frontend/src/ast/traits.rs
@@ -3,10 +3,11 @@ use std::fmt::Display;
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
-use crate::{
-    node_interner::TraitId, BlockExpression, Expression, FunctionReturnType, Ident, NoirFunction,
-    Path, UnresolvedGenerics, UnresolvedType,
+use crate::ast::{
+    BlockExpression, Expression, FunctionReturnType, Ident, NoirFunction, Path, UnresolvedGenerics,
+    UnresolvedType,
 };
+use crate::node_interner::TraitId;
 
 /// AST node for trait definitions:
 /// `trait name<generics> { ... items ... }`
diff --git a/compiler/noirc_frontend/src/ast/type_alias.rs b/compiler/noirc_frontend/src/ast/type_alias.rs
index 76a1e5a7e30..3228765170e 100644
--- a/compiler/noirc_frontend/src/ast/type_alias.rs
+++ b/compiler/noirc_frontend/src/ast/type_alias.rs
@@ -1,4 +1,4 @@
-use crate::{Ident, UnresolvedGenerics, UnresolvedType};
+use super::{Ident, UnresolvedGenerics, UnresolvedType};
 use iter_extended::vecmap;
 use noirc_errors::Span;
 use std::fmt::Display;
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
index 9f9004b5ad1..47ca7083ff0 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -1,18 +1,19 @@
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
 
+use crate::ast::{
+    ArrayLiteral, AssignStatement, BlockExpression, CallExpression, CastExpression, ConstrainKind,
+    ConstructorExpression, ExpressionKind, ForLoopStatement, ForRange, Ident, IfExpression,
+    IndexExpression, InfixExpression, LValue, Lambda, LetStatement, Literal,
+    MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression, UnresolvedType,
+    UnresolvedTypeData, UnresolvedTypeExpression,
+};
 use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
 use crate::hir_def::expr::{HirArrayLiteral, HirExpression, HirIdent};
 use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
+use crate::hir_def::types::Type;
 use crate::macros_api::HirLiteral;
 use crate::node_interner::{ExprId, NodeInterner, StmtId};
-use crate::{
-    ArrayLiteral, AssignStatement, BlockExpression, CallExpression, CastExpression, ConstrainKind,
-    ConstructorExpression, ExpressionKind, ForLoopStatement, ForRange, Ident, IfExpression,
-    IndexExpression, InfixExpression, LValue, Lambda, LetStatement, Literal,
-    MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression, Type,
-    UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
-};
 
 // TODO:
 // - Full path for idents & types
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 54f1c321a3b..03839c2f0cd 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -6,6 +6,7 @@ use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
+use crate::ast::{BinaryOpKind, BlockExpression, FunctionKind, IntegerBitSize, Signedness};
 use crate::{
     hir_def::{
         expr::{
@@ -21,10 +22,8 @@ use crate::{
     },
     macros_api::{HirExpression, HirLiteral, HirStatement, NodeInterner},
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
-    BinaryOpKind, BlockExpression, FunctionKind, IntegerBitSize, Shared, Signedness, Type,
-    TypeBinding, TypeBindings, TypeVariableKind,
 };
-
+use crate::{Shared, Type, TypeBinding, TypeBindings, TypeVariableKind};
 #[allow(unused)]
 pub(crate) struct Interpreter<'interner> {
     /// To expand macros the Interpreter may mutate hir nodes within the NodeInterner
@@ -558,7 +557,7 @@ impl<'a> Interpreter<'a> {
     fn evaluate_prefix(&mut self, prefix: HirPrefixExpression, id: ExprId) -> IResult<Value> {
         let rhs = self.evaluate(prefix.rhs)?;
         match prefix.operator {
-            crate::UnaryOp::Minus => match rhs {
+            crate::ast::UnaryOp::Minus => match rhs {
                 Value::Field(value) => Ok(Value::Field(FieldElement::zero() - value)),
                 Value::I8(value) => Ok(Value::I8(-value)),
                 Value::I32(value) => Ok(Value::I32(-value)),
@@ -575,7 +574,7 @@ impl<'a> Interpreter<'a> {
                     })
                 }
             },
-            crate::UnaryOp::Not => match rhs {
+            crate::ast::UnaryOp::Not => match rhs {
                 Value::Bool(value) => Ok(Value::Bool(!value)),
                 Value::I8(value) => Ok(Value::I8(!value)),
                 Value::I32(value) => Ok(Value::I32(!value)),
@@ -588,8 +587,8 @@ impl<'a> Interpreter<'a> {
                     Err(InterpreterError::InvalidValueForUnary { value, location, operator: "not" })
                 }
             },
-            crate::UnaryOp::MutableReference => Ok(Value::Pointer(Shared::new(rhs))),
-            crate::UnaryOp::Dereference { implicitly_added: _ } => match rhs {
+            crate::ast::UnaryOp::MutableReference => Ok(Value::Pointer(Shared::new(rhs))),
+            crate::ast::UnaryOp::Dereference { implicitly_added: _ } => match rhs {
                 Value::Pointer(element) => Ok(element.borrow().clone()),
                 value => {
                     let location = self.interner.expr_location(&id);
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 463b8a4b329..4c6b5ab5885 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -18,11 +18,11 @@ use crate::hir::Context;
 use crate::macros_api::{MacroError, MacroProcessor};
 use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId, TraitId, TypeAliasId};
 
-use crate::parser::{ParserError, SortedModule};
-use crate::{
+use crate::ast::{
     ExpressionKind, Ident, LetStatement, Literal, NoirFunction, NoirStruct, NoirTrait,
     NoirTypeAlias, Path, PathKind, UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType,
 };
+use crate::parser::{ParserError, SortedModule};
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{CustomDiagnostic, Span};
@@ -398,11 +398,11 @@ fn inject_prelude(
 ) {
     let segments: Vec<_> = "std::prelude"
         .split("::")
-        .map(|segment| crate::Ident::new(segment.into(), Span::default()))
+        .map(|segment| crate::ast::Ident::new(segment.into(), Span::default()))
         .collect();
 
     let path =
-        Path { segments: segments.clone(), kind: crate::PathKind::Dep, span: Span::default() };
+        Path { segments: segments.clone(), kind: crate::ast::PathKind::Dep, span: Span::default() };
 
     if !crate_id.is_stdlib() {
         if let Ok(PathResolution { module_def_id, error }) = path_resolver::resolve_path(
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index e3c79e39d31..baedb109967 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -4,14 +4,16 @@ use acvm::acir::acir_field::FieldOptions;
 use fm::{FileId, FileManager, FILE_EXTENSION};
 use noirc_errors::Location;
 
+use crate::ast::{
+    FunctionDefinition, Ident, ItemVisibility, LetStatement, ModuleDeclaration, NoirFunction,
+    NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
+};
 use crate::{
     graph::CrateId,
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
     macros_api::MacroProcessor,
     node_interner::{FunctionModifiers, TraitId, TypeAliasId},
     parser::{SortedModule, SortedSubModule},
-    FunctionDefinition, Ident, ItemVisibility, LetStatement, ModuleDeclaration, NoirFunction,
-    NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
 };
 
 use super::{
diff --git a/compiler/noirc_frontend/src/hir/def_collector/errors.rs b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
index 29daf5d6369..59a3051ac70 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/errors.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
@@ -1,6 +1,5 @@
+use crate::ast::{Ident, Path};
 use crate::hir::resolution::import::PathResolutionError;
-use crate::Ident;
-use crate::Path;
 
 use noirc_errors::CustomDiagnostic as Diagnostic;
 use noirc_errors::FileDiagnostic;
diff --git a/compiler/noirc_frontend/src/hir/def_map/item_scope.rs b/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
index cd4eafdf669..3ca89e56bbc 100644
--- a/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/item_scope.rs
@@ -1,8 +1,7 @@
 use super::{namespace::PerNs, ModuleDefId, ModuleId};
-use crate::{
-    node_interner::{FuncId, TraitId},
-    Ident, ItemVisibility,
-};
+use crate::ast::{Ident, ItemVisibility};
+use crate::node_interner::{FuncId, TraitId};
+
 use std::collections::{hash_map::Entry, HashMap};
 
 type Scope = HashMap<Option<TraitId>, (ModuleDefId, ItemVisibility, bool /*is_prelude*/)>;
diff --git a/compiler/noirc_frontend/src/hir/def_map/module_data.rs b/compiler/noirc_frontend/src/hir/def_map/module_data.rs
index 4dd38f0e3e5..488ccc476d7 100644
--- a/compiler/noirc_frontend/src/hir/def_map/module_data.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/module_data.rs
@@ -2,12 +2,9 @@ use std::collections::HashMap;
 
 use noirc_errors::Location;
 
-use crate::{
-    node_interner::{FuncId, GlobalId, StructId, TraitId, TypeAliasId},
-    Ident, ItemVisibility,
-};
-
 use super::{ItemScope, LocalModuleId, ModuleDefId, ModuleId, PerNs};
+use crate::ast::{Ident, ItemVisibility};
+use crate::node_interner::{FuncId, GlobalId, StructId, TraitId, TypeAliasId};
 
 /// Contains the actual contents of a module: its parent (if one exists),
 /// children, and scope with all definitions defined within the scope.
diff --git a/compiler/noirc_frontend/src/hir/def_map/namespace.rs b/compiler/noirc_frontend/src/hir/def_map/namespace.rs
index 5e349f46e14..6fac6d2b991 100644
--- a/compiler/noirc_frontend/src/hir/def_map/namespace.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/namespace.rs
@@ -1,5 +1,5 @@
 use super::ModuleDefId;
-use crate::ItemVisibility;
+use crate::ast::ItemVisibility;
 
 // This works exactly the same as in r-a, just simplified
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 71e3f3482fc..0fac6f96086 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -2,7 +2,7 @@ pub use noirc_errors::Span;
 use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic};
 use thiserror::Error;
 
-use crate::{parser::ParserError, Ident, Type};
+use crate::{ast::Ident, parser::ParserError, Type};
 
 use super::import::PathResolutionError;
 
@@ -49,7 +49,7 @@ pub enum ResolverError {
     #[error("Integer too large to be evaluated in an array length context")]
     IntegerTooLarge { span: Span },
     #[error("No global or generic type parameter found with the given name")]
-    NoSuchNumericTypeVariable { path: crate::Path },
+    NoSuchNumericTypeVariable { path: crate::ast::Path },
     #[error("Closures cannot capture mutable variables")]
     CapturedMutableVariable { span: Span },
     #[error("Test functions are not allowed to have any parameters")]
diff --git a/compiler/noirc_frontend/src/hir/resolution/impls.rs b/compiler/noirc_frontend/src/hir/resolution/impls.rs
index 72f6adc3770..7efd1eed86e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/impls.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/impls.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 
 use fm::FileId;
 
+use crate::ast::ItemVisibility;
 use crate::{
     graph::CrateId,
     hir::{
@@ -13,7 +14,7 @@ use crate::{
         Context,
     },
     node_interner::{FuncId, NodeInterner},
-    ItemVisibility, Type,
+    Type,
 };
 
 use super::{
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index ade97e2cf42..77e67567f8c 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -4,8 +4,8 @@ use thiserror::Error;
 use crate::graph::CrateId;
 use std::collections::BTreeMap;
 
+use crate::ast::{Ident, ItemVisibility, Path, PathKind};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleDefId, ModuleId, PerNs};
-use crate::{Ident, ItemVisibility, Path, PathKind};
 
 #[derive(Debug, Clone)]
 pub struct ImportDirective {
diff --git a/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs b/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
index e19af3c732f..e423e10b712 100644
--- a/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
@@ -1,5 +1,5 @@
 use super::import::{resolve_import, ImportDirective, PathResolution, PathResolutionResult};
-use crate::Path;
+use crate::ast::Path;
 use std::collections::BTreeMap;
 
 use crate::graph::CrateId;
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index ab0490a80e4..0e69b3bdeba 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -25,25 +25,22 @@ use regex::Regex;
 use std::collections::{BTreeMap, HashSet};
 use std::rc::Rc;
 
+use crate::ast::{
+    ArrayLiteral, BinaryOpKind, BlockExpression, Distinctness, Expression, ExpressionKind,
+    ForRange, FunctionDefinition, FunctionKind, FunctionReturnType, Ident, ItemVisibility, LValue,
+    LetStatement, Literal, NoirFunction, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
+    Statement, StatementKind, UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint,
+    UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, Visibility, ERROR_IDENT,
+};
 use crate::graph::CrateId;
 use crate::hir::def_map::{ModuleDefId, TryFromModuleDefId, MAIN_FUNCTION};
+use crate::hir::{def_map::CrateDefMap, resolution::path_resolver::PathResolver};
 use crate::hir_def::stmt::{HirAssignStatement, HirForStatement, HirLValue, HirPattern};
 use crate::node_interner::{
     DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, NodeInterner, StmtId,
     StructId, TraitId, TraitImplId, TraitMethodId, TypeAliasId,
 };
-use crate::{
-    hir::{def_map::CrateDefMap, resolution::path_resolver::PathResolver},
-    BlockExpression, Expression, ExpressionKind, FunctionKind, Ident, Literal, NoirFunction,
-    StatementKind,
-};
-use crate::{
-    ArrayLiteral, BinaryOpKind, Distinctness, ForRange, FunctionDefinition, FunctionReturnType,
-    Generics, ItemVisibility, LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
-    Shared, Statement, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp,
-    UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData,
-    UnresolvedTypeExpression, Visibility, ERROR_IDENT,
-};
+use crate::{Generics, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind};
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span, Spanned};
@@ -478,7 +475,7 @@ impl<'a> Resolver<'a> {
     /// Translates an UnresolvedType into a Type and appends any
     /// freshly created TypeVariables created to new_variables.
     fn resolve_type_inner(&mut self, typ: UnresolvedType, new_variables: &mut Generics) -> Type {
-        use UnresolvedTypeData::*;
+        use crate::ast::UnresolvedTypeData::*;
 
         let resolved_type = match typ.typ {
             FieldElement => Type::FieldElement,
@@ -1171,7 +1168,7 @@ impl<'a> Resolver<'a> {
 
     pub fn resolve_global_let(
         &mut self,
-        let_stmt: crate::LetStatement,
+        let_stmt: LetStatement,
         global_id: GlobalId,
     ) -> HirStatement {
         self.current_item = Some(DependencyId::Global(global_id));
diff --git a/compiler/noirc_frontend/src/hir/resolution/structs.rs b/compiler/noirc_frontend/src/hir/resolution/structs.rs
index ed7aa86e718..f62e5589d74 100644
--- a/compiler/noirc_frontend/src/hir/resolution/structs.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/structs.rs
@@ -3,6 +3,7 @@ use std::collections::BTreeMap;
 use fm::FileId;
 use iter_extended::vecmap;
 
+use crate::ast::Ident;
 use crate::{
     graph::CrateId,
     hir::{
@@ -11,7 +12,7 @@ use crate::{
         Context,
     },
     node_interner::StructId,
-    Generics, Ident, Type,
+    Generics, Type,
 };
 
 use super::{errors::ResolverError, path_resolver::StandardPathResolver, resolver::Resolver};
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index a7669f57e33..ccae8c6dd03 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -4,6 +4,7 @@ use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::Location;
 
+use crate::ast::{ItemVisibility, Path, TraitItem};
 use crate::{
     graph::CrateId,
     hir::{
@@ -16,7 +17,7 @@ use crate::{
     },
     hir_def::traits::{TraitConstant, TraitFunction, TraitImpl, TraitType},
     node_interner::{FuncId, NodeInterner, TraitId},
-    Generics, ItemVisibility, Path, Shared, TraitItem, Type, TypeVariable, TypeVariableKind,
+    Generics, Shared, Type, TypeVariable, TypeVariableKind,
 };
 
 use super::{
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 6c28aabe0fb..6c2a1945283 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -3,13 +3,10 @@ use noirc_errors::CustomDiagnostic as Diagnostic;
 use noirc_errors::Span;
 use thiserror::Error;
 
+use crate::ast::{BinaryOpKind, FunctionReturnType, IntegerBitSize, Signedness};
 use crate::hir::resolution::errors::ResolverError;
 use crate::hir_def::expr::HirBinaryOp;
 use crate::hir_def::types::Type;
-use crate::BinaryOpKind;
-use crate::FunctionReturnType;
-use crate::IntegerBitSize;
-use crate::Signedness;
 
 #[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum Source {
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index b56e2dce2a9..62330732be4 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -1,6 +1,7 @@
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
+use crate::ast::{BinaryOpKind, UnaryOp};
 use crate::{
     hir::{resolution::resolver::verify_mutable_reference, type_check::errors::Source},
     hir_def::{
@@ -11,7 +12,7 @@ use crate::{
         types::Type,
     },
     node_interner::{DefinitionKind, ExprId, FuncId, TraitId, TraitImplKind, TraitMethodId},
-    BinaryOpKind, TypeBinding, TypeBindings, TypeVariableKind, UnaryOp,
+    TypeBinding, TypeBindings, TypeVariableKind,
 };
 
 use super::{errors::TypeCheckError, TypeChecker};
@@ -717,7 +718,7 @@ impl<'interner> TypeChecker<'interner> {
         let dereference_lhs = |this: &mut Self, lhs_type, element| {
             let old_lhs = *access_lhs;
             *access_lhs = this.interner.push_expr(HirExpression::Prefix(HirPrefixExpression {
-                operator: crate::UnaryOp::Dereference { implicitly_added: true },
+                operator: crate::ast::UnaryOp::Dereference { implicitly_added: true },
                 rhs: old_lhs,
             }));
             this.interner.push_expr_type(old_lhs, lhs_type);
@@ -1110,7 +1111,7 @@ impl<'interner> TypeChecker<'interner> {
         if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric() {
             let target = Type::polymorphic_integer(self.interner);
 
-            use BinaryOpKind::*;
+            use crate::ast::BinaryOpKind::*;
             use TypeCheckError::*;
             self.unify(lhs_type, &target, || match op.kind {
                 Less | LessEqual | Greater | GreaterEqual => FieldComparison { span },
@@ -1202,7 +1203,7 @@ impl<'interner> TypeChecker<'interner> {
 
     fn type_check_prefix_operand(
         &mut self,
-        op: &crate::UnaryOp,
+        op: &crate::ast::UnaryOp,
         rhs_type: &Type,
         span: Span,
     ) -> Type {
@@ -1216,7 +1217,7 @@ impl<'interner> TypeChecker<'interner> {
         };
 
         match op {
-            crate::UnaryOp::Minus => {
+            crate::ast::UnaryOp::Minus => {
                 if rhs_type.is_unsigned() {
                     self.errors
                         .push(TypeCheckError::InvalidUnaryOp { kind: rhs_type.to_string(), span });
@@ -1228,7 +1229,7 @@ impl<'interner> TypeChecker<'interner> {
                 });
                 expected
             }
-            crate::UnaryOp::Not => {
+            crate::ast::UnaryOp::Not => {
                 let rhs_type = rhs_type.follow_bindings();
 
                 // `!` can work on booleans or integers
@@ -1238,10 +1239,10 @@ impl<'interner> TypeChecker<'interner> {
 
                 unify(Type::Bool)
             }
-            crate::UnaryOp::MutableReference => {
+            crate::ast::UnaryOp::MutableReference => {
                 Type::MutableReference(Box::new(rhs_type.follow_bindings()))
             }
-            crate::UnaryOp::Dereference { implicitly_added: _ } => {
+            crate::ast::UnaryOp::Dereference { implicitly_added: _ } => {
                 let element_type = self.interner.next_type_variable();
                 unify(Type::MutableReference(Box::new(element_type.clone())));
                 element_type
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index b8931ce56b9..44dab6dee3d 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -433,6 +433,9 @@ pub mod test {
     use iter_extended::btree_map;
     use noirc_errors::{Location, Span};
 
+    use crate::ast::{
+        BinaryOpKind, Distinctness, FunctionKind, FunctionReturnType, Path, Visibility,
+    };
     use crate::graph::CrateId;
     use crate::hir::def_map::{ModuleData, ModuleId};
     use crate::hir::resolution::import::{
@@ -453,9 +456,8 @@ pub mod test {
             def_map::{CrateDefMap, LocalModuleId, ModuleDefId},
             resolution::{path_resolver::PathResolver, resolver::Resolver},
         },
-        parse_program, FunctionKind, Path,
+        parse_program,
     };
-    use crate::{BinaryOpKind, Distinctness, FunctionReturnType, Visibility};
 
     #[test]
     fn basic_let() {
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index 4dfc896fb29..f5f6e1e8180 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -1,6 +1,7 @@
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
+use crate::ast::UnaryOp;
 use crate::hir_def::expr::{HirExpression, HirIdent, HirLiteral};
 use crate::hir_def::stmt::{
     HirAssignStatement, HirConstrainStatement, HirForStatement, HirLValue, HirLetStatement,
@@ -8,7 +9,6 @@ use crate::hir_def::stmt::{
 };
 use crate::hir_def::types::Type;
 use crate::node_interner::{DefinitionId, ExprId, StmtId};
-use crate::UnaryOp;
 
 use super::errors::{Source, TypeCheckError};
 use super::TypeChecker;
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index eb4ebf3f913..d88b65d1fce 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -2,8 +2,9 @@ use acvm::FieldElement;
 use fm::FileId;
 use noirc_errors::Location;
 
+use crate::ast::{BinaryOp, BinaryOpKind, Ident, UnaryOp};
 use crate::node_interner::{DefinitionId, ExprId, FuncId, NodeInterner, StmtId, TraitMethodId};
-use crate::{BinaryOp, BinaryOpKind, Ident, Shared, UnaryOp};
+use crate::Shared;
 
 use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
@@ -31,7 +32,7 @@ pub enum HirExpression {
     Tuple(Vec<ExprId>),
     Lambda(HirLambda),
     Error,
-    Quote(crate::BlockExpression),
+    Quote(crate::ast::BlockExpression),
 }
 
 impl HirExpression {
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 97f4b6a1616..67b6412a21c 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -6,9 +6,9 @@ use std::rc::Rc;
 use super::expr::{HirBlockExpression, HirExpression, HirIdent};
 use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
+use crate::ast::{Distinctness, FunctionKind, FunctionReturnType, Visibility};
 use crate::node_interner::{ExprId, NodeInterner, TraitImplId};
-use crate::FunctionKind;
-use crate::{Distinctness, FunctionReturnType, Type, TypeVariable, Visibility};
+use crate::{Type, TypeVariable};
 
 /// A Hir function is a block expression
 /// with a list of statements
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 605f25ebfbf..7e22e5ee9c0 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -1,7 +1,8 @@
 use super::expr::HirIdent;
+use crate::ast::Ident;
 use crate::macros_api::SecondaryAttribute;
 use crate::node_interner::{ExprId, StmtId};
-use crate::{Ident, Type};
+use crate::Type;
 use fm::FileId;
 use noirc_errors::{Location, Span};
 
diff --git a/compiler/noirc_frontend/src/hir_def/traits.rs b/compiler/noirc_frontend/src/hir_def/traits.rs
index 16b9899039f..e4959cb3dd9 100644
--- a/compiler/noirc_frontend/src/hir_def/traits.rs
+++ b/compiler/noirc_frontend/src/hir_def/traits.rs
@@ -1,9 +1,10 @@
 use std::collections::HashMap;
 
+use crate::ast::{Ident, NoirFunction};
 use crate::{
     graph::CrateId,
     node_interner::{FuncId, TraitId, TraitMethodId},
-    Generics, Ident, NoirFunction, Type, TypeBindings, TypeVariable, TypeVariableId,
+    Generics, Type, TypeBindings, TypeVariable, TypeVariableId,
 };
 use fm::FileId;
 use noirc_errors::{Location, Span};
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 6aced6cced4..8c6e3d48fca 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -6,15 +6,18 @@ use std::{
 };
 
 use crate::{
+    ast::IntegerBitSize,
     hir::type_check::TypeCheckError,
     node_interner::{ExprId, NodeInterner, TraitId, TypeAliasId},
-    IntegerBitSize,
 };
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 use noirc_printable_type::PrintableType;
 
-use crate::{node_interner::StructId, Ident, Signedness};
+use crate::{
+    ast::{Ident, Signedness},
+    node_interner::StructId,
+};
 
 use super::expr::{HirCallExpression, HirExpression, HirIdent};
 
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index a00de4f2547..ec513d55299 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -412,8 +412,8 @@ impl Token {
         [Plus, Minus, Star, Slash, Percent, Ampersand, Caret, ShiftLeft, ShiftRight, Pipe]
     }
 
-    pub fn try_into_binary_op(self, span: Span) -> Option<Spanned<crate::BinaryOpKind>> {
-        use crate::BinaryOpKind::*;
+    pub fn try_into_binary_op(self, span: Span) -> Option<Spanned<crate::ast::BinaryOpKind>> {
+        use crate::ast::BinaryOpKind::*;
         let binary_op = match self {
             Token::Plus => Add,
             Token::Ampersand => And,
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 93d7960faf5..6c77e3d0545 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -28,9 +28,6 @@ pub use lexer::token;
 // Parser API
 pub use parser::{parse_program, ParsedModule};
 
-// AST API
-pub use ast::*;
-
 // Type API
 pub use hir_def::types::*;
 
@@ -52,17 +49,18 @@ pub mod macros_api {
     pub use crate::parser::{parse_program, SortedModule};
     pub use crate::token::SecondaryAttribute;
 
-    pub use crate::hir::def_map::ModuleDefId;
-    pub use crate::{
-        hir::Context as HirContext, BlockExpression, CallExpression, CastExpression, Distinctness,
-        Expression, ExpressionKind, FunctionReturnType, Ident, IndexExpression, ItemVisibility,
-        LetStatement, Literal, MemberAccessExpression, MethodCallExpression, NoirFunction, Path,
-        PathKind, Pattern, Statement, UnresolvedType, UnresolvedTypeData, Visibility,
+    pub use crate::ast::{
+        BlockExpression, CallExpression, CastExpression, Distinctness, Expression, ExpressionKind,
+        FunctionReturnType, Ident, IndexExpression, ItemVisibility, LetStatement, Literal,
+        MemberAccessExpression, MethodCallExpression, NoirFunction, Path, PathKind, Pattern,
+        Statement, UnresolvedType, UnresolvedTypeData, Visibility,
     };
-    pub use crate::{
+    pub use crate::ast::{
         ForLoopStatement, ForRange, FunctionDefinition, ImportStatement, NoirStruct, Param,
-        PrefixExpression, Signedness, StatementKind, StructType, Type, TypeImpl, UnaryOp,
+        PrefixExpression, Signedness, StatementKind, TypeImpl, UnaryOp,
     };
+    pub use crate::hir::{def_map::ModuleDefId, Context as HirContext};
+    pub use crate::{StructType, Type};
 
     /// Methods to process the AST before and after type checking
     pub trait MacroProcessor {
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index d9c33d8604e..434cc922a05 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -5,10 +5,8 @@ use noirc_errors::{
     Location,
 };
 
-use crate::{
-    hir_def::function::FunctionSignature, BinaryOpKind, Distinctness, IntegerBitSize, Signedness,
-    Visibility,
-};
+use crate::ast::{BinaryOpKind, Distinctness, IntegerBitSize, Signedness, Visibility};
+use crate::hir_def::function::FunctionSignature;
 
 /// The monomorphized AST is expression-based, all statements are also
 /// folded into this expression enum. Compared to the HIR, the monomorphized
@@ -99,7 +97,7 @@ pub enum Literal {
 
 #[derive(Debug, Clone, Hash)]
 pub struct Unary {
-    pub operator: crate::UnaryOp,
+    pub operator: crate::ast::UnaryOp,
     pub rhs: Box<Expression>,
     pub result_type: Type,
     pub location: Location,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 477ed3fe951..74a0dd855c0 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -8,6 +8,7 @@
 //!
 //! The entry point to this pass is the `monomorphize` function which, starting from a given
 //! function, will monomorphize the entire reachable program.
+use crate::ast::{FunctionKind, IntegerBitSize, Signedness, UnaryOp, Visibility};
 use crate::{
     debug::DebugInstrumenter,
     hir_def::{
@@ -18,8 +19,7 @@ use crate::{
     },
     node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId},
     token::FunctionAttribute,
-    FunctionKind, IntegerBitSize, Signedness, Type, TypeBinding, TypeBindings, TypeVariable,
-    TypeVariableKind, UnaryOp, Visibility,
+    Type, TypeBinding, TypeBindings, TypeVariable, TypeVariableKind,
 };
 use acvm::FieldElement;
 use iter_extended::{btree_map, try_vecmap, vecmap};
@@ -460,7 +460,7 @@ impl<'interner> Monomorphizer<'interner> {
 
                     // If this is a comparison operator, the result is a boolean but
                     // the actual method call returns an Ordering
-                    use crate::BinaryOpKind::*;
+                    use crate::ast::BinaryOpKind::*;
                     let ret = if matches!(operator, Less | LessEqual | Greater | GreaterEqual) {
                         self.interner.ordering_type()
                     } else {
@@ -1268,7 +1268,7 @@ impl<'interner> Monomorphizer<'interner> {
     ) -> ast::Expression {
         use ast::*;
 
-        let int_type = Type::Integer(crate::Signedness::Unsigned, arr_elem_bits);
+        let int_type = Type::Integer(crate::ast::Signedness::Unsigned, arr_elem_bits);
 
         let bytes_as_expr = vecmap(bytes, |byte| {
             Expression::Literal(Literal::Integer((byte as u128).into(), int_type.clone(), location))
@@ -1597,7 +1597,7 @@ impl<'interner> Monomorphizer<'interner> {
                 }))
             }
             ast::Type::MutableReference(element) => {
-                use crate::UnaryOp::MutableReference;
+                use crate::ast::UnaryOp::MutableReference;
                 let rhs = Box::new(self.zeroed_value_of_type(element, location));
                 let result_type = typ.clone();
                 ast::Expression::Unary(ast::Unary {
@@ -1682,7 +1682,7 @@ impl<'interner> Monomorphizer<'interner> {
         let mut result =
             ast::Expression::Call(ast::Call { func, arguments, return_type, location });
 
-        use crate::BinaryOpKind::*;
+        use crate::ast::BinaryOpKind::*;
         match operator.kind {
             // Negate the result of the == operation
             NotEqual => {
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 5b375be8d56..b0e68be4868 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -16,6 +16,7 @@ use crate::hir::def_collector::dc_crate::CompilationError;
 use crate::hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias};
 use crate::hir::def_map::{LocalModuleId, ModuleId};
 
+use crate::ast::{BinaryOpKind, FunctionDefinition, ItemVisibility};
 use crate::hir::resolution::errors::ResolverError;
 use crate::hir_def::stmt::HirLetStatement;
 use crate::hir_def::traits::TraitImpl;
@@ -28,8 +29,7 @@ use crate::hir_def::{
 };
 use crate::token::{Attributes, SecondaryAttribute};
 use crate::{
-    BinaryOpKind, FunctionDefinition, Generics, ItemVisibility, Shared, TypeAlias, TypeBindings,
-    TypeVariable, TypeVariableId, TypeVariableKind,
+    Generics, Shared, TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind,
 };
 
 /// An arbitrary number to limit the recursion depth when searching for trait impls.
@@ -822,10 +822,10 @@ impl NodeInterner {
         self.func_meta.get(func_id)
     }
 
-    pub fn function_ident(&self, func_id: &FuncId) -> crate::Ident {
+    pub fn function_ident(&self, func_id: &FuncId) -> crate::ast::Ident {
         let name = self.function_name(func_id).to_owned();
         let span = self.function_meta(func_id).name.location.span;
-        crate::Ident(Spanned::from(span, name))
+        crate::ast::Ident(Spanned::from(span, name))
     }
 
     pub fn function_name(&self, func_id: &FuncId) -> &str {
diff --git a/compiler/noirc_frontend/src/noir_parser.lalrpop b/compiler/noirc_frontend/src/noir_parser.lalrpop
index c8d293fb72f..ec2b4c8ab46 100644
--- a/compiler/noirc_frontend/src/noir_parser.lalrpop
+++ b/compiler/noirc_frontend/src/noir_parser.lalrpop
@@ -4,7 +4,7 @@ use crate::lexer::token::BorrowedToken;
 use crate::lexer::token as noir_token;
 use crate::lexer::errors::LexerErrorKind;
 use crate::parser::TopLevelStatement;
-use crate::{Ident, Path, PathKind, UseTree, UseTreeKind};
+use crate::ast::{Ident, Path, PathKind, UseTree, UseTreeKind};
 
 use lalrpop_util::ErrorRecovery;
 
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index 895d4e07bbd..407b69c818b 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -1,7 +1,6 @@
+use crate::ast::{Expression, IntegerBitSize};
 use crate::lexer::errors::LexerErrorKind;
 use crate::lexer::token::Token;
-use crate::Expression;
-use crate::IntegerBitSize;
 use small_ord_set::SmallOrdSet;
 use thiserror::Error;
 
diff --git a/compiler/noirc_frontend/src/parser/mod.rs b/compiler/noirc_frontend/src/parser/mod.rs
index 80c5f47f07b..9e60383afee 100644
--- a/compiler/noirc_frontend/src/parser/mod.rs
+++ b/compiler/noirc_frontend/src/parser/mod.rs
@@ -11,12 +11,11 @@ mod labels;
 #[allow(clippy::module_inception)]
 mod parser;
 
-use crate::token::{Keyword, Token};
-use crate::{ast::ImportStatement, Expression, NoirStruct};
-use crate::{
-    Ident, LetStatement, ModuleDeclaration, NoirFunction, NoirTrait, NoirTraitImpl, NoirTypeAlias,
-    Recoverable, StatementKind, TypeImpl, UseTree,
+use crate::ast::{
+    Expression, Ident, ImportStatement, LetStatement, ModuleDeclaration, NoirFunction, NoirStruct,
+    NoirTrait, NoirTraitImpl, NoirTypeAlias, Recoverable, StatementKind, TypeImpl, UseTree,
 };
+use crate::token::{Keyword, Token};
 
 use chumsky::prelude::*;
 use chumsky::primitive::Container;
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index ba5b9bf1ab0..603193d1593 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -33,17 +33,17 @@ use super::{
 };
 use super::{spanned, Item, ItemKind};
 use crate::ast::{
-    Expression, ExpressionKind, LetStatement, StatementKind, UnresolvedType, UnresolvedTypeData,
-};
-use crate::lexer::{lexer::from_spanned_token_result, Lexer};
-use crate::parser::{force, ignore_then_commit, statement_recovery};
-use crate::token::{Keyword, Token, TokenKind};
-use crate::{
     BinaryOp, BinaryOpKind, BlockExpression, Distinctness, ForLoopStatement, ForRange,
     FunctionReturnType, Ident, IfExpression, InfixExpression, LValue, Literal, ModuleDeclaration,
     NoirTypeAlias, Param, Path, Pattern, Recoverable, Statement, TraitBound, TypeImpl,
     UnresolvedTraitConstraint, UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
 };
+use crate::ast::{
+    Expression, ExpressionKind, LetStatement, StatementKind, UnresolvedType, UnresolvedTypeData,
+};
+use crate::lexer::{lexer::from_spanned_token_result, Lexer};
+use crate::parser::{force, ignore_then_commit, statement_recovery};
+use crate::token::{Keyword, Token, TokenKind};
 
 use chumsky::prelude::*;
 use iter_extended::vecmap;
@@ -1353,7 +1353,7 @@ where
 mod test {
     use super::test_helpers::*;
     use super::*;
-    use crate::ArrayLiteral;
+    use crate::ast::ArrayLiteral;
 
     #[test]
     fn parse_infix() {
diff --git a/compiler/noirc_frontend/src/parser/parser/assertion.rs b/compiler/noirc_frontend/src/parser/parser/assertion.rs
index f9c8d7aa46b..ed08a4c9922 100644
--- a/compiler/noirc_frontend/src/parser/parser/assertion.rs
+++ b/compiler/noirc_frontend/src/parser/parser/assertion.rs
@@ -4,8 +4,8 @@ use crate::parser::{
     ParserError, ParserErrorReason,
 };
 
+use crate::ast::{BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, Recoverable};
 use crate::token::{Keyword, Token};
-use crate::{BinaryOpKind, ConstrainKind, ConstrainStatement, InfixExpression, Recoverable};
 
 use chumsky::prelude::*;
 use noirc_errors::Spanned;
@@ -74,11 +74,11 @@ where
 mod test {
     use super::*;
     use crate::{
+        ast::Literal,
         parser::parser::{
             expression,
             test_helpers::{parse_all, parse_all_failing, parse_with},
         },
-        Literal,
     };
 
     /// Deprecated constrain usage test
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 074c902ff7b..f39b2ad6292 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -4,13 +4,13 @@ use super::{
     optional_visibility, parameter_name_recovery, parameter_recovery, parenthesized, parse_type,
     pattern, self_parameter, where_clause, NoirParser,
 };
-use crate::parser::labels::ParsingRuleLabel;
-use crate::parser::spanned;
-use crate::token::{Keyword, Token};
-use crate::{
+use crate::ast::{
     Distinctness, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction,
     Param, Visibility,
 };
+use crate::parser::labels::ParsingRuleLabel;
+use crate::parser::spanned;
+use crate::token::{Keyword, Token};
 
 use chumsky::prelude::*;
 
diff --git a/compiler/noirc_frontend/src/parser/parser/lambdas.rs b/compiler/noirc_frontend/src/parser/parser/lambdas.rs
index 48ddd41ab44..2b4a1d547c0 100644
--- a/compiler/noirc_frontend/src/parser/parser/lambdas.rs
+++ b/compiler/noirc_frontend/src/parser/parser/lambdas.rs
@@ -1,13 +1,12 @@
 use chumsky::{primitive::just, Parser};
 
+use super::{parse_type, pattern};
+use crate::ast::{Expression, ExpressionKind, Lambda, Pattern, UnresolvedType};
 use crate::{
     parser::{labels::ParsingRuleLabel, parameter_name_recovery, parameter_recovery, NoirParser},
     token::Token,
-    Expression, ExpressionKind, Lambda, Pattern, UnresolvedType,
 };
 
-use super::{parse_type, pattern};
-
 pub(super) fn lambda<'a>(
     expr_parser: impl NoirParser<Expression> + 'a,
 ) -> impl NoirParser<ExpressionKind> + 'a {
diff --git a/compiler/noirc_frontend/src/parser/parser/literals.rs b/compiler/noirc_frontend/src/parser/parser/literals.rs
index 83d7b832d27..584224fda46 100644
--- a/compiler/noirc_frontend/src/parser/parser/literals.rs
+++ b/compiler/noirc_frontend/src/parser/parser/literals.rs
@@ -1,9 +1,9 @@
 use chumsky::Parser;
 
 use crate::{
+    ast::ExpressionKind,
     parser::NoirParser,
     token::{Token, TokenKind},
-    ExpressionKind,
 };
 
 use super::primitives::token_kind;
@@ -22,10 +22,10 @@ pub(super) fn literal() -> impl NoirParser<ExpressionKind> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::ast::Literal;
     use crate::parser::parser::{
         expression, expression_no_constructors, fresh_statement, term, test_helpers::*,
     };
-    use crate::Literal;
 
     fn expr_to_lit(expr: ExpressionKind) -> Literal {
         match expr {
diff --git a/compiler/noirc_frontend/src/parser/parser/path.rs b/compiler/noirc_frontend/src/parser/parser/path.rs
index ab812c07dce..47bb11991fa 100644
--- a/compiler/noirc_frontend/src/parser/parser/path.rs
+++ b/compiler/noirc_frontend/src/parser/parser/path.rs
@@ -1,5 +1,5 @@
+use crate::ast::{Path, PathKind};
 use crate::parser::NoirParser;
-use crate::{Path, PathKind};
 
 use crate::token::{Keyword, Token};
 
diff --git a/compiler/noirc_frontend/src/parser/parser/primitives.rs b/compiler/noirc_frontend/src/parser/parser/primitives.rs
index 34927278038..8413f14ae4d 100644
--- a/compiler/noirc_frontend/src/parser/parser/primitives.rs
+++ b/compiler/noirc_frontend/src/parser/parser/primitives.rs
@@ -1,9 +1,9 @@
 use chumsky::prelude::*;
 
+use crate::ast::{ExpressionKind, Ident, UnaryOp};
 use crate::{
     parser::{labels::ParsingRuleLabel, ExprParser, NoirParser, ParserError},
     token::{Keyword, Token, TokenKind},
-    ExpressionKind, Ident, UnaryOp,
 };
 
 use super::path;
diff --git a/compiler/noirc_frontend/src/parser/parser/structs.rs b/compiler/noirc_frontend/src/parser/parser/structs.rs
index 87e58f69efb..7da956bdfea 100644
--- a/compiler/noirc_frontend/src/parser/parser/structs.rs
+++ b/compiler/noirc_frontend/src/parser/parser/structs.rs
@@ -1,5 +1,6 @@
 use chumsky::prelude::*;
 
+use crate::ast::{Ident, NoirStruct, UnresolvedType};
 use crate::{
     parser::{
         parser::{
@@ -10,7 +11,6 @@ use crate::{
         NoirParser, TopLevelStatement,
     },
     token::{Keyword, Token},
-    Ident, NoirStruct, UnresolvedType,
 };
 
 pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatement> {
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
index 1e2a6b4d65d..0507dbdbc71 100644
--- a/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -5,14 +5,16 @@ use super::{
     function_return_type,
 };
 
+use crate::ast::{
+    Expression, ItemVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem, TraitItem,
+    UnresolvedTraitConstraint, UnresolvedType,
+};
 use crate::{
     parser::{
         ignore_then_commit, parenthesized, parser::primitives::keyword, NoirParser, ParserError,
         ParserErrorReason, TopLevelStatement,
     },
     token::{Keyword, Token},
-    Expression, ItemVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem, TraitItem,
-    UnresolvedTraitConstraint, UnresolvedType,
 };
 
 use super::{generic_type_args, parse_type, path, primitives::ident};
diff --git a/tooling/nargo_fmt/src/rewrite/array.rs b/tooling/nargo_fmt/src/rewrite/array.rs
index db7dc4701b7..011e775a018 100644
--- a/tooling/nargo_fmt/src/rewrite/array.rs
+++ b/tooling/nargo_fmt/src/rewrite/array.rs
@@ -1,4 +1,4 @@
-use noirc_frontend::{hir::resolution::errors::Span, token::Token, Expression};
+use noirc_frontend::{ast::Expression, hir::resolution::errors::Span, token::Token};
 
 use crate::{
     items::Item,
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 6cf69a2309d..e4616c99aaa 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -1,7 +1,7 @@
-use noirc_frontend::{
-    macros_api::Span, token::Token, ArrayLiteral, BlockExpression, Expression, ExpressionKind,
-    Literal, UnaryOp,
+use noirc_frontend::ast::{
+    ArrayLiteral, BlockExpression, Expression, ExpressionKind, Literal, UnaryOp,
 };
+use noirc_frontend::{macros_api::Span, token::Token};
 
 use crate::visitor::{
     expr::{format_brackets, format_parens, NewlineMode},
diff --git a/tooling/nargo_fmt/src/rewrite/imports.rs b/tooling/nargo_fmt/src/rewrite/imports.rs
index 55eb259bcdd..564ef3fa370 100644
--- a/tooling/nargo_fmt/src/rewrite/imports.rs
+++ b/tooling/nargo_fmt/src/rewrite/imports.rs
@@ -1,4 +1,4 @@
-use noirc_frontend::{PathKind, UseTreeKind};
+use noirc_frontend::ast;
 
 use crate::{
     items::Item,
@@ -60,13 +60,13 @@ pub(crate) struct UseTree {
 }
 
 impl UseTree {
-    pub(crate) fn from_ast(use_tree: noirc_frontend::UseTree) -> Self {
+    pub(crate) fn from_ast(use_tree: ast::UseTree) -> Self {
         let mut result = UseTree { path: vec![] };
 
         match use_tree.prefix.kind {
-            PathKind::Crate => result.path.push(UseSegment::Crate),
-            PathKind::Dep => result.path.push(UseSegment::Dep),
-            PathKind::Plain => {}
+            ast::PathKind::Crate => result.path.push(UseSegment::Crate),
+            ast::PathKind::Dep => result.path.push(UseSegment::Dep),
+            ast::PathKind::Plain => {}
         };
 
         result.path.extend(
@@ -78,13 +78,13 @@ impl UseTree {
         );
 
         match use_tree.kind {
-            UseTreeKind::Path(name, alias) => {
+            ast::UseTreeKind::Path(name, alias) => {
                 result.path.push(UseSegment::Ident(
                     name.to_string(),
                     alias.map(|rename| rename.to_string()),
                 ));
             }
-            UseTreeKind::List(list) => {
+            ast::UseTreeKind::List(list) => {
                 let segment = UseSegment::List(list.into_iter().map(UseTree::from_ast).collect());
                 result.path.push(segment);
             }
diff --git a/tooling/nargo_fmt/src/rewrite/infix.rs b/tooling/nargo_fmt/src/rewrite/infix.rs
index 5d2b387496a..e2555f21187 100644
--- a/tooling/nargo_fmt/src/rewrite/infix.rs
+++ b/tooling/nargo_fmt/src/rewrite/infix.rs
@@ -1,6 +1,6 @@
 use std::iter::zip;
 
-use noirc_frontend::{Expression, ExpressionKind};
+use noirc_frontend::ast::{Expression, ExpressionKind};
 
 use crate::{
     rewrite,
diff --git a/tooling/nargo_fmt/src/rewrite/parenthesized.rs b/tooling/nargo_fmt/src/rewrite/parenthesized.rs
index 3926b52cb73..93e1538b042 100644
--- a/tooling/nargo_fmt/src/rewrite/parenthesized.rs
+++ b/tooling/nargo_fmt/src/rewrite/parenthesized.rs
@@ -1,4 +1,5 @@
-use noirc_frontend::{hir::resolution::errors::Span, Expression, ExpressionKind};
+use noirc_frontend::ast::{Expression, ExpressionKind};
+use noirc_frontend::hir::resolution::errors::Span;
 
 use crate::visitor::{FmtVisitor, Shape};
 
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
index 980d02ee5dc..278457f82d1 100644
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ b/tooling/nargo_fmt/src/rewrite/typ.rs
@@ -1,4 +1,4 @@
-use noirc_frontend::{UnresolvedType, UnresolvedTypeData};
+use noirc_frontend::ast::{UnresolvedType, UnresolvedTypeData};
 
 use crate::{
     utils::span_is_empty,
diff --git a/tooling/nargo_fmt/src/utils.rs b/tooling/nargo_fmt/src/utils.rs
index 94969d45e81..2c5c3085e66 100644
--- a/tooling/nargo_fmt/src/utils.rs
+++ b/tooling/nargo_fmt/src/utils.rs
@@ -3,10 +3,10 @@ use std::borrow::Cow;
 use crate::items::HasItem;
 use crate::rewrite;
 use crate::visitor::{FmtVisitor, Shape};
+use noirc_frontend::ast::{Expression, Ident, Param, Visibility};
 use noirc_frontend::hir::resolution::errors::Span;
 use noirc_frontend::lexer::Lexer;
 use noirc_frontend::token::Token;
-use noirc_frontend::{Expression, Ident, Param, Visibility};
 
 pub(crate) fn changed_comment_content(original: &str, new: &str) -> bool {
     comments(original).ne(comments(new))
diff --git a/tooling/nargo_fmt/src/visitor/expr.rs b/tooling/nargo_fmt/src/visitor/expr.rs
index f9836adda18..18b962a7f85 100644
--- a/tooling/nargo_fmt/src/visitor/expr.rs
+++ b/tooling/nargo_fmt/src/visitor/expr.rs
@@ -1,7 +1,8 @@
-use noirc_frontend::{
-    hir::resolution::errors::Span, lexer::Lexer, token::Token, BlockExpression,
-    ConstructorExpression, Expression, ExpressionKind, IfExpression, Statement, StatementKind,
+use noirc_frontend::ast::Expression;
+use noirc_frontend::ast::{
+    BlockExpression, ConstructorExpression, ExpressionKind, IfExpression, Statement, StatementKind,
 };
+use noirc_frontend::{hir::resolution::errors::Span, lexer::Lexer, token::Token};
 
 use super::{ExpressionType, FmtVisitor, Shape};
 use crate::{
diff --git a/tooling/nargo_fmt/src/visitor/item.rs b/tooling/nargo_fmt/src/visitor/item.rs
index 28aad3c551f..82cfefba632 100644
--- a/tooling/nargo_fmt/src/visitor/item.rs
+++ b/tooling/nargo_fmt/src/visitor/item.rs
@@ -1,10 +1,3 @@
-use noirc_frontend::{
-    hir::resolution::errors::Span,
-    parser::{Item, ItemKind},
-    token::{Keyword, Token},
-    Distinctness, NoirFunction, ParsedModule, Visibility,
-};
-
 use crate::{
     rewrite::{self, UseTree},
     utils::{
@@ -13,6 +6,13 @@ use crate::{
     },
     visitor::expr::{format_seq, NewlineMode},
 };
+use noirc_frontend::ast::{Distinctness, NoirFunction, Visibility};
+use noirc_frontend::{
+    hir::resolution::errors::Span,
+    parser::{Item, ItemKind},
+    token::{Keyword, Token},
+    ParsedModule,
+};
 
 use super::{
     expr::Tactic::{HorizontalVertical, LimitedHorizontalVertical},
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index 612330ad3a3..e41827c94a1 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -1,8 +1,9 @@
 use std::iter::zip;
 
-use noirc_frontend::{
-    macros_api::Span, ConstrainKind, ConstrainStatement, ExpressionKind, ForRange, Statement,
-    StatementKind,
+use noirc_frontend::macros_api::Span;
+
+use noirc_frontend::ast::{
+    ConstrainKind, ConstrainStatement, ExpressionKind, ForRange, Statement, StatementKind,
 };
 
 use crate::{rewrite, visitor::expr::wrap_exprs};
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 6ad13500bdd..8ff0154d32c 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -10,7 +10,8 @@ use acvm::{
 use errors::AbiError;
 use input_parser::InputValue;
 use iter_extended::{try_btree_map, try_vecmap, vecmap};
-use noirc_frontend::{hir::Context, Signedness, Type, TypeBinding, TypeVariableKind, Visibility};
+use noirc_frontend::ast::{Signedness, Visibility};
+use noirc_frontend::{hir::Context, Type, TypeBinding, TypeVariableKind};
 use serde::{Deserialize, Serialize};
 use std::ops::Range;
 use std::{collections::BTreeMap, str};

From 0c8175cb539efd9427c73ae5af0d48abe688ebab Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 22 Apr 2024 14:55:56 -0400
Subject: [PATCH 210/416] feat(acir_gen): Brillig stdlib (#4848)

# Description

## Problem\*

Expands usage of https://github.com/noir-lang/noir/issues/3907 to our
Brillig directives.

## Summary\*

The Brillig stdlib differs slightly from normal Brillig functions calls.
We can insert the generated Brillig bytecode at any point during ACIR
gen. This includes within the `GeneratedAcir` struct itself. We have a
few requirements on what we want to achieve:
- We do want to have to thread the ACIR gen `SharedContext` that is used
for generating normal Brillig function pointers to the `GeneratedAcir`.
Why would we want a reference to code generation inside of our Generated
ACIR structure (we don't)?
- We want to maintain one Brillig stdlib for an entire program. We do
not want to change the `BrilligCall` opcode so we need them to be a part
of the main list of `unconstrained_functions` in a program.
- Function IDs reference a flat list, so reserving some number of slots
would be wasteful if the program does not eventually use a Brillig
stdlib function in that slot.

So instead we maintain a map as part of the `GeneratedAcir` that notes
when we at which opcode location we inserted a call to a
`BrilligStdlibFunc`. The ID at this point will just be `0`. After
finishing ACIR generation for a function, only then do we resolve the
IDs for these `BrilligCall` opcodes.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: jfecher <jake@aztecprotocol.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 acvm-repo/acir/src/circuit/brillig.rs         |   2 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |  16 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  60 ++-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 392 +++++++++++++++++-
 4 files changed, 456 insertions(+), 14 deletions(-)

diff --git a/acvm-repo/acir/src/circuit/brillig.rs b/acvm-repo/acir/src/circuit/brillig.rs
index e75d335d52b..7f87aabf9d5 100644
--- a/acvm-repo/acir/src/circuit/brillig.rs
+++ b/acvm-repo/acir/src/circuit/brillig.rs
@@ -33,7 +33,7 @@ pub struct Brillig {
 /// This is purely a wrapper struct around a list of Brillig opcode's which represents
 /// a full Brillig function to be executed by the Brillig VM.
 /// This is stored separately on a program and accessed through a [BrilligPointer].
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Debug)]
 pub struct BrilligBytecode {
     pub bytecode: Vec<BrilligOpcode>,
 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index b94e02e5119..5e94f60b82a 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1,5 +1,5 @@
 use super::big_int::BigIntContext;
-use super::generated_acir::GeneratedAcir;
+use super::generated_acir::{BrilligStdlibFunc, GeneratedAcir, PLACEHOLDER_BRILLIG_INDEX};
 use crate::brillig::brillig_gen::brillig_directive;
 use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
 use crate::errors::{InternalError, RuntimeError, SsaReport};
@@ -326,13 +326,15 @@ impl AcirContext {
         // Compute the inverse with brillig code
         let inverse_code = brillig_directive::directive_invert();
 
-        let results = self.brillig(
+        let results = self.brillig_call(
             predicate,
-            inverse_code,
+            &inverse_code,
             vec![AcirValue::Var(var, AcirType::field())],
             vec![AcirType::field()],
             true,
             false,
+            PLACEHOLDER_BRILLIG_INDEX,
+            Some(BrilligStdlibFunc::Inverse),
         )?;
         let inverted_var = Self::expect_one_var(results);
 
@@ -711,9 +713,9 @@ impl AcirContext {
         }
 
         let [q_value, r_value]: [AcirValue; 2] = self
-            .brillig(
+            .brillig_call(
                 predicate,
-                brillig_directive::directive_quotient(bit_size + 1),
+                &brillig_directive::directive_quotient(bit_size + 1),
                 vec![
                     AcirValue::Var(lhs, AcirType::unsigned(bit_size)),
                     AcirValue::Var(rhs, AcirType::unsigned(bit_size)),
@@ -721,6 +723,8 @@ impl AcirContext {
                 vec![AcirType::unsigned(max_q_bits), AcirType::unsigned(max_rhs_bits)],
                 true,
                 false,
+                PLACEHOLDER_BRILLIG_INDEX,
+                Some(BrilligStdlibFunc::Quotient(bit_size + 1)),
             )?
             .try_into()
             .expect("quotient only returns two values");
@@ -1565,6 +1569,7 @@ impl AcirContext {
         attempt_execution: bool,
         unsafe_return_values: bool,
         brillig_function_index: u32,
+        brillig_stdlib_func: Option<BrilligStdlibFunc>,
     ) -> Result<Vec<AcirValue>, RuntimeError> {
         let brillig_inputs = try_vecmap(inputs, |i| -> Result<_, InternalError> {
             match i {
@@ -1618,6 +1623,7 @@ impl AcirContext {
             brillig_inputs,
             brillig_outputs,
             brillig_function_index,
+            brillig_stdlib_func,
         );
 
         fn range_constraint_value(
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 999ff2ddb5d..ab5fa0c5245 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -24,6 +24,12 @@ use acvm::{
 use iter_extended::vecmap;
 use num_bigint::BigUint;
 
+/// Brillig calls such as for the Brillig std lib are resolved only after code generation is finished.
+/// This index should be used when adding a Brillig call during code generation.
+/// Code generation should then keep track of that unresolved call opcode which will be resolved with the
+/// correct function index after code generation.
+pub(crate) const PLACEHOLDER_BRILLIG_INDEX: u32 = 0;
+
 #[derive(Debug, Default)]
 /// The output of the Acir-gen pass, which should only be produced for entry point Acir functions
 pub(crate) struct GeneratedAcir {
@@ -62,6 +68,29 @@ pub(crate) struct GeneratedAcir {
     /// Name for the corresponding entry point represented by this Acir-gen output.
     /// Only used for debugging and benchmarking purposes
     pub(crate) name: String,
+
+    /// Maps the opcode index to a Brillig std library function call.
+    /// As to avoid passing the ACIR gen shared context into each individual ACIR
+    /// we can instead keep this map and resolve the Brillig calls at the end of code generation.
+    pub(crate) brillig_stdlib_func_locations: BTreeMap<OpcodeLocation, BrilligStdlibFunc>,
+}
+
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub(crate) enum BrilligStdlibFunc {
+    Inverse,
+    // The Brillig quotient code is different depending upon the bit size.
+    Quotient(u32),
+}
+
+impl BrilligStdlibFunc {
+    pub(crate) fn get_generated_brillig(&self) -> GeneratedBrillig {
+        match self {
+            BrilligStdlibFunc::Inverse => brillig_directive::directive_invert(),
+            BrilligStdlibFunc::Quotient(bit_size) => {
+                brillig_directive::directive_quotient(*bit_size)
+            }
+        }
+    }
 }
 
 impl GeneratedAcir {
@@ -456,7 +485,14 @@ impl GeneratedAcir {
         let inverse_code = brillig_directive::directive_invert();
         let inputs = vec![BrilligInputs::Single(expr)];
         let outputs = vec![BrilligOutputs::Simple(inverted_witness)];
-        self.brillig(Some(Expression::one()), inverse_code, inputs, outputs);
+        self.brillig_call(
+            Some(Expression::one()),
+            &inverse_code,
+            inputs,
+            outputs,
+            PLACEHOLDER_BRILLIG_INDEX,
+            Some(BrilligStdlibFunc::Inverse),
+        );
 
         inverted_witness
     }
@@ -625,10 +661,16 @@ impl GeneratedAcir {
         inputs: Vec<BrilligInputs>,
         outputs: Vec<BrilligOutputs>,
         brillig_function_index: u32,
+        stdlib_func: Option<BrilligStdlibFunc>,
     ) {
         let opcode =
             AcirOpcode::BrilligCall { id: brillig_function_index, inputs, outputs, predicate };
         self.push_opcode(opcode);
+        if let Some(stdlib_func) = stdlib_func {
+            self.brillig_stdlib_func_locations
+                .insert(self.last_acir_opcode_location(), stdlib_func);
+        }
+
         for (brillig_index, call_stack) in generated_brillig.locations.iter() {
             self.locations.insert(
                 OpcodeLocation::Brillig {
@@ -649,6 +691,22 @@ impl GeneratedAcir {
         }
     }
 
+    // We can only resolve the Brillig stdlib after having processed the entire ACIR
+    pub(crate) fn resolve_brillig_stdlib_call(
+        &mut self,
+        opcode_location: OpcodeLocation,
+        brillig_function_index: u32,
+    ) {
+        let acir_index = match opcode_location {
+            OpcodeLocation::Acir(index) => index,
+            _ => panic!("should not have brillig index"),
+        };
+        match &mut self.opcodes[acir_index] {
+            AcirOpcode::BrilligCall { id, .. } => *id = brillig_function_index,
+            _ => panic!("expected brillig call opcode"),
+        }
+    }
+
     pub(crate) fn last_acir_opcode_location(&self) -> OpcodeLocation {
         OpcodeLocation::Acir(self.opcodes.len() - 1)
     }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 8b16ad51ca1..ee236df8eac 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -5,6 +5,7 @@ use std::collections::{BTreeMap, HashSet};
 use std::fmt::Debug;
 
 use self::acir_ir::acir_variable::{AcirContext, AcirType, AcirVar};
+use self::acir_ir::generated_acir::BrilligStdlibFunc;
 use super::function_builder::data_bus::DataBus;
 use super::ir::dfg::CallStack;
 use super::ir::function::FunctionId;
@@ -30,6 +31,7 @@ use crate::ssa::ir::function::InlineType;
 pub(crate) use acir_ir::generated_acir::GeneratedAcir;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
+use acvm::acir::circuit::OpcodeLocation;
 use acvm::acir::native_types::Witness;
 use acvm::acir::BlackBoxFunc;
 use acvm::{
@@ -55,6 +57,14 @@ struct SharedContext {
     /// This uses the brillig parameters in the map since using slices with different lengths
     /// needs to create different brillig entrypoints
     brillig_generated_func_pointers: BTreeMap<(FunctionId, Vec<BrilligParameter>), u32>,
+
+    /// Maps a Brillig std lib function (a handwritten primitive such as for inversion) -> Final generated Brillig artifact index.
+    /// A separate mapping from normal Brillig calls is necessary as these methods do not have an associated function id from SSA.
+    brillig_stdlib_func_pointer: HashMap<BrilligStdlibFunc, u32>,
+
+    /// Keeps track of Brillig std lib calls per function that need to still be resolved
+    /// with the correct function pointer from the `brillig_stdlib_func_pointer` map.
+    brillig_stdlib_calls_to_resolve: HashMap<FunctionId, Vec<(OpcodeLocation, u32)>>,
 }
 
 impl SharedContext {
@@ -84,6 +94,47 @@ impl SharedContext {
     fn new_generated_pointer(&self) -> u32 {
         self.generated_brillig.len() as u32
     }
+
+    fn generate_brillig_calls_to_resolve(
+        &mut self,
+        brillig_stdlib_func: &BrilligStdlibFunc,
+        func_id: FunctionId,
+        opcode_location: OpcodeLocation,
+    ) {
+        if let Some(generated_pointer) =
+            self.brillig_stdlib_func_pointer.get(brillig_stdlib_func).copied()
+        {
+            self.add_call_to_resolve(func_id, (opcode_location, generated_pointer));
+        } else {
+            let code = brillig_stdlib_func.get_generated_brillig();
+            let generated_pointer = self.new_generated_pointer();
+            self.insert_generated_brillig_stdlib(
+                *brillig_stdlib_func,
+                generated_pointer,
+                func_id,
+                opcode_location,
+                code,
+            );
+        }
+    }
+
+    /// Insert a newly generated Brillig stdlib function
+    fn insert_generated_brillig_stdlib(
+        &mut self,
+        brillig_stdlib_func: BrilligStdlibFunc,
+        generated_pointer: u32,
+        func_id: FunctionId,
+        opcode_location: OpcodeLocation,
+        code: GeneratedBrillig,
+    ) {
+        self.brillig_stdlib_func_pointer.insert(brillig_stdlib_func, generated_pointer);
+        self.add_call_to_resolve(func_id, (opcode_location, generated_pointer));
+        self.generated_brillig.push(code);
+    }
+
+    fn add_call_to_resolve(&mut self, func_id: FunctionId, call_to_resolve: (OpcodeLocation, u32)) {
+        self.brillig_stdlib_calls_to_resolve.entry(func_id).or_default().push(call_to_resolve);
+    }
 }
 
 /// Context struct for the acir generation pass.
@@ -240,6 +291,35 @@ impl Ssa {
             if let Some(mut generated_acir) =
                 context.convert_ssa_function(&self, function, brillig)?
             {
+                // We want to be able to insert Brillig stdlib functions anywhere during the ACIR generation process (e.g. such as on the `GeneratedAcir`).
+                // As we don't want a reference to the `SharedContext` on the generated ACIR itself,
+                // we instead store the opcode location at which a Brillig call to a std lib function occurred.
+                // We then defer resolving the function IDs of those Brillig functions to when we have generated Brillig
+                // for all normal Brillig calls.
+                for (opcode_location, brillig_stdlib_func) in
+                    &generated_acir.brillig_stdlib_func_locations
+                {
+                    shared_context.generate_brillig_calls_to_resolve(
+                        brillig_stdlib_func,
+                        function.id(),
+                        *opcode_location,
+                    );
+                }
+
+                // Fetch the Brillig stdlib calls to resolve for this function
+                if let Some(calls_to_resolve) =
+                    shared_context.brillig_stdlib_calls_to_resolve.get(&function.id())
+                {
+                    // Resolve the Brillig stdlib calls
+                    // We have to do a separate loop as the generated ACIR cannot be borrowed as mutable after an immutable borrow
+                    for (opcode_location, brillig_function_pointer) in calls_to_resolve {
+                        generated_acir.resolve_brillig_stdlib_call(
+                            *opcode_location,
+                            *brillig_function_pointer,
+                        );
+                    }
+                }
+
                 generated_acir.name = function.name().to_owned();
                 acirs.push(generated_acir);
             }
@@ -376,6 +456,7 @@ impl<'a> Context<'a> {
             true,
             // We are guaranteed to have a Brillig function pointer of `0` as main itself is marked as unconstrained
             0,
+            None,
         )?;
         self.shared_context.insert_generated_brillig(main_func.id(), arguments, 0, code);
 
@@ -687,6 +768,7 @@ impl<'a> Context<'a> {
                                         true,
                                         false,
                                         *generated_pointer,
+                                        None,
                                     )?
                                 } else {
                                     let code =
@@ -701,6 +783,7 @@ impl<'a> Context<'a> {
                                         true,
                                         false,
                                         generated_pointer,
+                                        None,
                                     )?;
                                     self.shared_context.insert_generated_brillig(
                                         *id,
@@ -2518,14 +2601,20 @@ fn can_omit_element_sizes_array(array_typ: &Type) -> bool {
 
 #[cfg(test)]
 mod test {
+    use std::collections::BTreeMap;
+
     use acvm::{
-        acir::{circuit::Opcode, native_types::Witness},
+        acir::{
+            circuit::{Opcode, OpcodeLocation},
+            native_types::Witness,
+        },
         FieldElement,
     };
 
     use crate::{
         brillig::Brillig,
         ssa::{
+            acir_gen::acir_ir::generated_acir::BrilligStdlibFunc,
             function_builder::FunctionBuilder,
             ir::{
                 function::{FunctionId, InlineType},
@@ -2848,10 +2937,12 @@ mod test {
     fn multiple_brillig_calls_one_bytecode() {
         // acir(inline) fn main f0 {
         //     b0(v0: Field, v1: Field):
-        //       v3 = call f1(v0, v1)
         //       v4 = call f1(v0, v1)
         //       v5 = call f1(v0, v1)
         //       v6 = call f1(v0, v1)
+        //       v7 = call f2(v0, v1)
+        //       v8 = call f1(v0, v1)
+        //       v9 = call f2(v0, v1)
         //       return
         // }
         // brillig fn foo f1 {
@@ -2898,11 +2989,7 @@ mod test {
             .expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
-        assert_eq!(
-            brillig_functions.len(),
-            2,
-            "Should only have generated a single Brillig function"
-        );
+        assert_eq!(brillig_functions.len(), 2, "Should only have generated two Brillig functions");
 
         let main_acir = &acir_functions[0];
         let main_opcodes = main_acir.opcodes();
@@ -2919,4 +3006,295 @@ mod test {
             }
         }
     }
+
+    // Test that given multiple primitive operations that are represented by Brillig directives (e.g. invert/quotient),
+    // we will only generate one bytecode and the appropriate Brillig call opcodes are generated.
+    #[test]
+    fn multiple_brillig_stdlib_calls() {
+        // acir(inline) fn main f0 {
+        //     b0(v0: u32, v1: u32, v2: u32):
+        //       v3 = div v0, v1
+        //       constrain v3 == v2
+        //       v4 = div v1, v2
+        //       constrain v4 == u32 1
+        //       return
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::unsigned(32));
+        let main_v1 = builder.add_parameter(Type::unsigned(32));
+        let main_v2 = builder.add_parameter(Type::unsigned(32));
+
+        // Call a primitive operation that uses Brillig
+        let v0_div_v1 = builder.insert_binary(main_v0, BinaryOp::Div, main_v1);
+        builder.insert_constrain(v0_div_v1, main_v2, None);
+
+        // Call the same primitive operation again
+        let v1_div_v2 = builder.insert_binary(main_v1, BinaryOp::Div, main_v2);
+        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        builder.insert_constrain(v1_div_v2, one, None);
+
+        builder.terminate_with_return(vec![]);
+
+        let ssa = builder.finish();
+        println!("{}", ssa);
+
+        // The Brillig bytecode we insert for the stdlib is hardcoded so we do not need to provide any
+        // Brillig artifacts to the ACIR gen pass.
+        let (acir_functions, brillig_functions) = ssa
+            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
+            .expect("Should compile manually written SSA into ACIR");
+
+        assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
+        // We expect two brillig functions:
+        //   - Quotient (shared between both divisions)
+        //   - Inversion, caused by division-by-zero check (shared between both divisions)
+        assert_eq!(brillig_functions.len(), 2, "Should only have generated two Brillig functions");
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        check_brillig_calls(
+            &acir_functions[0].brillig_stdlib_func_locations,
+            main_opcodes,
+            0,
+            4,
+            0,
+        );
+    }
+
+    // Test that given both hardcoded Brillig directives and calls to normal Brillig functions,
+    // we generate a single bytecode for the directives and a single bytecode for the normal Brillig calls.
+    #[test]
+    fn brillig_stdlib_calls_with_regular_brillig_call() {
+        // acir(inline) fn main f0 {
+        //     b0(v0: u32, v1: u32, v2: u32):
+        //       v4 = div v0, v1
+        //       constrain v4 == v2
+        //       v5 = call f1(v0, v1)
+        //       v6 = call f1(v0, v1)
+        //       v7 = div v1, v2
+        //       constrain v7 == u32 1
+        //       return
+        // }
+        // brillig fn foo f1 {
+        //   b0(v0: Field, v1: Field):
+        //     v2 = eq v0, v1
+        //     constrain v2 == u1 0
+        //     return v0
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::unsigned(32));
+        let main_v1 = builder.add_parameter(Type::unsigned(32));
+        let main_v2 = builder.add_parameter(Type::unsigned(32));
+
+        let foo_id = Id::test_new(1);
+        let foo = builder.import_function(foo_id);
+
+        // Call a primitive operation that uses Brillig
+        let v0_div_v1 = builder.insert_binary(main_v0, BinaryOp::Div, main_v1);
+        builder.insert_constrain(v0_div_v1, main_v2, None);
+
+        // Insert multiple calls to the same Brillig function
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+
+        // Call the same primitive operation again
+        let v1_div_v2 = builder.insert_binary(main_v1, BinaryOp::Div, main_v2);
+        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        builder.insert_constrain(v1_div_v2, one, None);
+
+        builder.terminate_with_return(vec![]);
+
+        build_basic_foo_with_return(&mut builder, foo_id, true);
+
+        let ssa = builder.finish();
+        // We need to generate  Brillig artifacts for the regular Brillig function and pass them to the ACIR generation pass.
+        let brillig = ssa.to_brillig(false);
+        println!("{}", ssa);
+
+        let (acir_functions, brillig_functions) = ssa
+            .into_acir(&brillig, noirc_frontend::ast::Distinctness::Distinct)
+            .expect("Should compile manually written SSA into ACIR");
+
+        assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
+        // We expect 3 brillig functions:
+        //   - Quotient (shared between both divisions)
+        //   - Inversion, caused by division-by-zero check (shared between both divisions)
+        //   - Custom brillig function `foo`
+        assert_eq!(
+            brillig_functions.len(),
+            3,
+            "Should only have generated three Brillig functions"
+        );
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        check_brillig_calls(
+            &acir_functions[0].brillig_stdlib_func_locations,
+            main_opcodes,
+            1,
+            4,
+            2,
+        );
+    }
+
+    // Test that given both normal Brillig calls, Brillig stdlib calls, and non-inlined ACIR calls, that we accurately generate ACIR.
+    #[test]
+    fn brillig_stdlib_calls_with_multiple_acir_calls() {
+        // acir(inline) fn main f0 {
+        //     b0(v0: u32, v1: u32, v2: u32):
+        //       v4 = div v0, v1
+        //       constrain v4 == v2
+        //       v5 = call f1(v0, v1)
+        //       v6 = call f2(v0, v1)
+        //       v7 = div v1, v2
+        //       constrain v7 == u32 1
+        //       return
+        // }
+        // brillig fn foo f1 {
+        //   b0(v0: Field, v1: Field):
+        //     v2 = eq v0, v1
+        //     constrain v2 == u1 0
+        //     return v0
+        // }
+        // acir(fold) fn foo f2 {
+        //     b0(v0: Field, v1: Field):
+        //       v2 = eq v0, v1
+        //       constrain v2 == u1 0
+        //       return v0
+        //   }
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), foo_id);
+        let main_v0 = builder.add_parameter(Type::unsigned(32));
+        let main_v1 = builder.add_parameter(Type::unsigned(32));
+        let main_v2 = builder.add_parameter(Type::unsigned(32));
+
+        let foo_id = Id::test_new(1);
+        let foo = builder.import_function(foo_id);
+        let bar_id = Id::test_new(2);
+        let bar = builder.import_function(bar_id);
+
+        // Call a primitive operation that uses Brillig
+        let v0_div_v1 = builder.insert_binary(main_v0, BinaryOp::Div, main_v1);
+        builder.insert_constrain(v0_div_v1, main_v2, None);
+
+        // Insert multiple calls to the same Brillig function
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(foo, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+        builder.insert_call(bar, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
+
+        // Call the same primitive operation again
+        let v1_div_v2 = builder.insert_binary(main_v1, BinaryOp::Div, main_v2);
+        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        builder.insert_constrain(v1_div_v2, one, None);
+
+        builder.terminate_with_return(vec![]);
+
+        build_basic_foo_with_return(&mut builder, foo_id, true);
+        build_basic_foo_with_return(&mut builder, bar_id, false);
+
+        let ssa = builder.finish();
+        // We need to generate  Brillig artifacts for the regular Brillig function and pass them to the ACIR generation pass.
+        let brillig = ssa.to_brillig(false);
+        println!("{}", ssa);
+
+        let (acir_functions, brillig_functions) = ssa
+            .into_acir(&brillig, noirc_frontend::ast::Distinctness::Distinct)
+            .expect("Should compile manually written SSA into ACIR");
+
+        assert_eq!(acir_functions.len(), 2, "Should only have two ACIR functions");
+        // We expect 3 brillig functions:
+        //   - Quotient (shared between both divisions)
+        //   - Inversion, caused by division-by-zero check (shared between both divisions)
+        //   - Custom brillig function `foo`
+        assert_eq!(
+            brillig_functions.len(),
+            3,
+            "Should only have generated three Brillig functions"
+        );
+
+        let main_acir = &acir_functions[0];
+        let main_opcodes = main_acir.opcodes();
+        check_brillig_calls(
+            &acir_functions[0].brillig_stdlib_func_locations,
+            main_opcodes,
+            1,
+            4,
+            2,
+        );
+
+        let foo_acir = &acir_functions[1];
+        let foo_opcodes = foo_acir.opcodes();
+        check_brillig_calls(&acir_functions[1].brillig_stdlib_func_locations, foo_opcodes, 1, 1, 0);
+    }
+
+    fn check_brillig_calls(
+        brillig_stdlib_function_locations: &BTreeMap<OpcodeLocation, BrilligStdlibFunc>,
+        opcodes: &[Opcode],
+        num_normal_brillig_functions: u32,
+        expected_num_stdlib_calls: u32,
+        expected_num_normal_calls: u32,
+    ) {
+        // First we check calls to the Brillig stdlib
+        let mut num_brillig_stdlib_calls = 0;
+        for (i, (opcode_location, brillig_stdlib_func)) in
+            brillig_stdlib_function_locations.iter().enumerate()
+        {
+            // We can take just modulo 2 to determine the expected ID as we only code generated two Brillig stdlib function
+            let stdlib_func_index = (i % 2) as u32;
+            if stdlib_func_index == 0 {
+                assert!(matches!(brillig_stdlib_func, BrilligStdlibFunc::Inverse));
+            } else {
+                assert!(matches!(brillig_stdlib_func, BrilligStdlibFunc::Quotient(_)));
+            }
+
+            match opcode_location {
+                OpcodeLocation::Acir(acir_index) => {
+                    match opcodes[*acir_index] {
+                        Opcode::BrilligCall { id, .. } => {
+                            // Brillig stdlib function calls are only resolved at the end of ACIR generation so their
+                            // IDs are expected to always reference Brillig bytecode at the end of the Brillig functions list.
+                            // We have one normal Brillig call so we add one here to the std lib function's index within the std lib.
+                            let expected_id = stdlib_func_index + num_normal_brillig_functions;
+                            assert_eq!(id, expected_id, "Expected {expected_id} but got {id}");
+                            num_brillig_stdlib_calls += 1;
+                        }
+                        _ => panic!("Expected BrilligCall opcode"),
+                    }
+                }
+                _ => panic!("Expected OpcodeLocation::Acir"),
+            }
+        }
+
+        assert_eq!(
+            num_brillig_stdlib_calls, expected_num_stdlib_calls,
+            "Should have {expected_num_stdlib_calls} BrilligCall opcodes to stdlib functions but got {num_brillig_stdlib_calls}"
+        );
+
+        // Check the normal Brillig calls
+        // This check right now expects to only call one Brillig function.
+        let mut num_normal_brillig_calls = 0;
+        for (i, opcode) in opcodes.iter().enumerate() {
+            match opcode {
+                Opcode::BrilligCall { id, .. } => {
+                    if brillig_stdlib_function_locations.get(&OpcodeLocation::Acir(i)).is_some() {
+                        // We should have already checked Brillig stdlib functions and only want to check normal Brillig calls here
+                        continue;
+                    }
+                    // We only generate one normal Brillig call so we should expect a function ID of `0`
+                    let expected_id = 0u32;
+                    assert_eq!(*id, expected_id, "Expected an id of {expected_id} but got {id}");
+                    num_normal_brillig_calls += 1;
+                }
+                _ => {}
+            }
+        }
+
+        assert_eq!(
+            num_normal_brillig_calls, expected_num_normal_calls,
+            "Should have {expected_num_normal_calls} BrilligCall opcodes to normal Brillig functions but got {num_normal_brillig_calls}"
+        );
+    }
 }

From 9704bd0abfe2dba1e7a4aef6cdb6cc83d70b929e Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 23 Apr 2024 14:59:03 +0100
Subject: [PATCH 211/416] chore: Delete unused brillig methods (#4887)

# Description

## Problem\*

Leftover work from #4848 that I forgot to include

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 91 -------------------
 .../ssa/acir_gen/acir_ir/generated_acir.rs    | 31 +------
 2 files changed, 1 insertion(+), 121 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 5e94f60b82a..3f5e4129dd0 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1468,97 +1468,6 @@ impl AcirContext {
         id
     }
 
-    // TODO: Delete this method once we remove the `Brillig` opcode
-    pub(crate) fn brillig(
-        &mut self,
-        predicate: AcirVar,
-        generated_brillig: GeneratedBrillig,
-        inputs: Vec<AcirValue>,
-        outputs: Vec<AcirType>,
-        attempt_execution: bool,
-        unsafe_return_values: bool,
-    ) -> Result<Vec<AcirValue>, RuntimeError> {
-        let b_inputs = try_vecmap(inputs, |i| -> Result<_, InternalError> {
-            match i {
-                AcirValue::Var(var, _) => Ok(BrilligInputs::Single(self.var_to_expression(var)?)),
-                AcirValue::Array(vars) => {
-                    let mut var_expressions: Vec<Expression> = Vec::new();
-                    for var in vars {
-                        self.brillig_array_input(&mut var_expressions, var)?;
-                    }
-                    Ok(BrilligInputs::Array(var_expressions))
-                }
-                AcirValue::DynamicArray(AcirDynamicArray { block_id, .. }) => {
-                    Ok(BrilligInputs::MemoryArray(block_id))
-                }
-            }
-        })?;
-
-        // Optimistically try executing the brillig now, if we can complete execution they just return the results.
-        // This is a temporary measure pending SSA optimizations being applied to Brillig which would remove constant-input opcodes (See #2066)
-        //
-        // We do _not_ want to do this in the situation where the `main` function is unconstrained, as if execution succeeds
-        // the entire program will be replaced with witness constraints to its outputs.
-        if attempt_execution {
-            if let Some(brillig_outputs) =
-                self.execute_brillig(&generated_brillig.byte_code, &b_inputs, &outputs)
-            {
-                return Ok(brillig_outputs);
-            }
-        }
-
-        // Otherwise we must generate ACIR for it and execute at runtime.
-        let mut b_outputs = Vec::new();
-        let outputs_var = vecmap(outputs, |output| match output {
-            AcirType::NumericType(_) => {
-                let witness_index = self.acir_ir.next_witness_index();
-                b_outputs.push(BrilligOutputs::Simple(witness_index));
-                let var = self.add_data(AcirVarData::Witness(witness_index));
-                AcirValue::Var(var, output.clone())
-            }
-            AcirType::Array(element_types, size) => {
-                let (acir_value, witnesses) = self.brillig_array_output(&element_types, size);
-                b_outputs.push(BrilligOutputs::Array(witnesses));
-                acir_value
-            }
-        });
-        let predicate = self.var_to_expression(predicate)?;
-        self.acir_ir.brillig(Some(predicate), generated_brillig, b_inputs, b_outputs);
-
-        fn range_constraint_value(
-            context: &mut AcirContext,
-            value: &AcirValue,
-        ) -> Result<(), RuntimeError> {
-            match value {
-                AcirValue::Var(var, typ) => {
-                    let numeric_type = match typ {
-                        AcirType::NumericType(numeric_type) => numeric_type,
-                        _ => unreachable!("`AcirValue::Var` may only hold primitive values"),
-                    };
-                    context.range_constrain_var(*var, numeric_type, None)?;
-                }
-                AcirValue::Array(values) => {
-                    for value in values {
-                        range_constraint_value(context, value)?;
-                    }
-                }
-                AcirValue::DynamicArray(_) => {
-                    unreachable!("Brillig opcodes cannot return dynamic arrays")
-                }
-            }
-            Ok(())
-        }
-
-        // This is a hack to ensure that if we're compiling a brillig entrypoint function then
-        // we don't also add a number of range constraints.
-        if !unsafe_return_values {
-            for output_var in &outputs_var {
-                range_constraint_value(self, output_var)?;
-            }
-        }
-        Ok(outputs_var)
-    }
-
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn brillig_call(
         &mut self,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index ab5fa0c5245..0b04d1b63ab 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -10,7 +10,7 @@ use crate::{
 
 use acvm::acir::{
     circuit::{
-        brillig::{Brillig as AcvmBrillig, BrilligInputs, BrilligOutputs},
+        brillig::{BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, FunctionInput, Opcode as AcirOpcode},
         OpcodeLocation,
     },
@@ -625,35 +625,6 @@ impl GeneratedAcir {
         Ok(())
     }
 
-    // TODO: Delete this method once we remove the `Brillig` opcode
-    pub(crate) fn brillig(
-        &mut self,
-        predicate: Option<Expression>,
-        generated_brillig: GeneratedBrillig,
-        inputs: Vec<BrilligInputs>,
-        outputs: Vec<BrilligOutputs>,
-    ) {
-        let opcode = AcirOpcode::Brillig(AcvmBrillig {
-            inputs,
-            outputs,
-            bytecode: generated_brillig.byte_code,
-            predicate,
-        });
-        self.push_opcode(opcode);
-        for (brillig_index, call_stack) in generated_brillig.locations {
-            self.locations.insert(
-                OpcodeLocation::Brillig { acir_index: self.opcodes.len() - 1, brillig_index },
-                call_stack,
-            );
-        }
-        for (brillig_index, message) in generated_brillig.assert_messages {
-            self.assert_messages.insert(
-                OpcodeLocation::Brillig { acir_index: self.opcodes.len() - 1, brillig_index },
-                message,
-            );
-        }
-    }
-
     pub(crate) fn brillig_call(
         &mut self,
         predicate: Option<Expression>,

From ce5e1a5fa69155420aa404e2bea4b483bac5b9a6 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 23 Apr 2024 13:08:48 -0500
Subject: [PATCH 212/416] chore(experimental): Add scan pass and
 `into_expression` for comptime interpreter (#4884)

# Description

## Problem\*

Resolves #4590

## Summary\*

This PR links up the comptime interpreter with the rest of the codebase.
It does so by adding a scanning step where the Hir is scanned for
`comptime` expressions to execute. When one of these is found, the
interpreter switches to evaluation mode and evaluates the expression.
Afterward, the result of the expression is inlined into the Hir via
`Value::into_expression`. For `Code` values, this means the entire code
block is spliced in (a macro expansion).

You can now run simple programs at compile-time now as long as they
don't have expansion of `quote`d values (macros) since those would
require the full loop back to name resolution again. Anyway, here's an
example that works now:

```rs
fn main() {
    let x = comptime { 2 * 4 };
    println(x);
}
```
By monomorphization the compiler sees
```rs
fn main() {
    let x = 8;
    println(x);
}
```
More complex expressions within the `comptime` block should also work.
Just note that this scanning + evaluation is currently only within
functions. So comptime globals won't be evaluated.

## Additional Context

I may try splitting out this PR into several smaller ones but need to
look into where to make the split more. Leaving this up for now in case
people find it useful or it's not as big as I expected.

Future changes:

Architecture-wise we're only missing the ability to make the full loop
and go back to name resolution after a macro expansion now. Since we
already have the Hir -> Ast pass (although it can be considerably
improved since it is rather broken still), we only need to call it after
the comptime interpreter and run name resolution again.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/expression.rs |   2 +
 compiler/noirc_frontend/src/ast/statement.rs  |   8 +-
 .../noirc_frontend/src/hir/comptime/errors.rs |  53 +++++
 .../src/hir/comptime/hir_to_ast.rs            |  26 ++-
 .../src/hir/comptime/interpreter.rs           | 152 +++----------
 .../noirc_frontend/src/hir/comptime/mod.rs    |   5 +
 .../noirc_frontend/src/hir/comptime/scan.rs   | 207 ++++++++++++++++++
 .../noirc_frontend/src/hir/comptime/tests.rs  |   4 +-
 .../noirc_frontend/src/hir/comptime/value.rs  | 170 ++++++++++++++
 .../src/hir/def_collector/dc_crate.rs         | 162 ++++++++------
 .../src/hir/resolution/globals.rs             |   8 +-
 .../src/hir/resolution/resolver.rs            |  19 +-
 .../noirc_frontend/src/hir/type_check/expr.rs |  65 +++---
 .../noirc_frontend/src/hir/type_check/stmt.rs |   2 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |   4 +-
 compiler/noirc_frontend/src/hir_def/stmt.rs   |   2 +-
 .../src/monomorphization/mod.rs               |   8 +-
 compiler/noirc_frontend/src/node_interner.rs  |  10 +-
 compiler/noirc_frontend/src/parser/parser.rs  |   4 +-
 compiler/noirc_frontend/src/tests.rs          |   2 +-
 tooling/nargo_fmt/src/rewrite/expr.rs         |   3 +
 tooling/nargo_fmt/src/visitor/stmt.rs         |   2 +-
 22 files changed, 667 insertions(+), 251 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/errors.rs
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/scan.rs
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/value.rs

diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 92c1add80a6..5659de46588 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -28,6 +28,7 @@ pub enum ExpressionKind {
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
     Quote(BlockExpression),
+    Comptime(BlockExpression),
     Error,
 }
 
@@ -504,6 +505,7 @@ impl Display for ExpressionKind {
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
             Quote(block) => write!(f, "quote {block}"),
+            Comptime(block) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
         }
     }
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 1831a046f5b..f37c7adc983 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -40,7 +40,7 @@ pub enum StatementKind {
     Break,
     Continue,
     /// This statement should be executed at compile-time
-    Comptime(Box<StatementKind>),
+    CompTime(Box<StatementKind>),
     // This is an expression with a trailing semi-colon
     Semi(Expression),
     // This statement is the result of a recovered parse error.
@@ -87,10 +87,10 @@ impl StatementKind {
                 }
                 self
             }
-            StatementKind::Comptime(mut statement) => {
+            StatementKind::CompTime(mut statement) => {
                 *statement =
                     statement.add_semicolon(semi, span, last_statement_in_block, emit_error);
-                StatementKind::Comptime(statement)
+                StatementKind::CompTime(statement)
             }
             // A semicolon on a for loop is optional and does nothing
             StatementKind::For(_) => self,
@@ -685,7 +685,7 @@ impl Display for StatementKind {
             StatementKind::For(for_loop) => for_loop.fmt(f),
             StatementKind::Break => write!(f, "break"),
             StatementKind::Continue => write!(f, "continue"),
-            StatementKind::Comptime(statement) => write!(f, "comptime {statement}"),
+            StatementKind::CompTime(statement) => write!(f, "comptime {statement}"),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
             StatementKind::Error => write!(f, "Error"),
         }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
new file mode 100644
index 00000000000..d3db7fcaee9
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -0,0 +1,53 @@
+use crate::{node_interner::DefinitionId, Type};
+use acvm::FieldElement;
+use noirc_errors::Location;
+
+use super::value::Value;
+
+/// The possible errors that can halt the interpreter.
+#[derive(Debug)]
+pub enum InterpreterError {
+    ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
+    TypeMismatch { expected: Type, value: Value, location: Location },
+    NoValueForId { id: DefinitionId, location: Location },
+    IntegerOutOfRangeForType { value: FieldElement, typ: Type, location: Location },
+    ErrorNodeEncountered { location: Location },
+    NonFunctionCalled { value: Value, location: Location },
+    NonBoolUsedInIf { value: Value, location: Location },
+    NonBoolUsedInConstrain { value: Value, location: Location },
+    FailingConstraint { message: Option<Value>, location: Location },
+    NoMethodFound { object: Value, typ: Type, location: Location },
+    NonIntegerUsedInLoop { value: Value, location: Location },
+    NonPointerDereferenced { value: Value, location: Location },
+    NonTupleOrStructInMemberAccess { value: Value, location: Location },
+    NonArrayIndexed { value: Value, location: Location },
+    NonIntegerUsedAsIndex { value: Value, location: Location },
+    NonIntegerIntegerLiteral { typ: Type, location: Location },
+    NonIntegerArrayLength { typ: Type, location: Location },
+    NonNumericCasted { value: Value, location: Location },
+    IndexOutOfBounds { index: usize, length: usize, location: Location },
+    ExpectedStructToHaveField { value: Value, field_name: String, location: Location },
+    TypeUnsupported { typ: Type, location: Location },
+    InvalidValueForUnary { value: Value, operator: &'static str, location: Location },
+    InvalidValuesForBinary { lhs: Value, rhs: Value, operator: &'static str, location: Location },
+    CastToNonNumericType { typ: Type, location: Location },
+    QuoteInRuntimeCode { location: Location },
+    NonStructInConstructor { typ: Type, location: Location },
+    CannotInlineMacro { value: Value, location: Location },
+    UnquoteFoundDuringEvaluation { location: Location },
+
+    Unimplemented { item: &'static str, location: Location },
+
+    // Perhaps this should be unreachable! due to type checking also preventing this error?
+    // Currently it and the Continue variant are the only interpreter errors without a Location field
+    BreakNotInLoop { location: Location },
+    ContinueNotInLoop { location: Location },
+
+    // These cases are not errors, they are just used to prevent us from running more code
+    // until the loop can be resumed properly. These cases will never be displayed to users.
+    Break,
+    Continue,
+}
+
+#[allow(unused)]
+pub(super) type IResult<T> = std::result::Result<T, InterpreterError>;
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
index 47ca7083ff0..dd23edf0004 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -9,7 +9,7 @@ use crate::ast::{
     UnresolvedTypeData, UnresolvedTypeExpression,
 };
 use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
-use crate::hir_def::expr::{HirArrayLiteral, HirExpression, HirIdent};
+use crate::hir_def::expr::{HirArrayLiteral, HirBlockExpression, HirExpression, HirIdent};
 use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
 use crate::hir_def::types::Type;
 use crate::macros_api::HirLiteral;
@@ -26,7 +26,7 @@ impl StmtId {
     #[allow(unused)]
     fn to_ast(self, interner: &NodeInterner) -> Statement {
         let statement = interner.statement(&self);
-        let span = interner.statement_span(&self);
+        let span = interner.statement_span(self);
 
         let kind = match statement {
             HirStatement::Let(let_stmt) => {
@@ -66,8 +66,8 @@ impl StmtId {
             HirStatement::Expression(expr) => StatementKind::Expression(expr.to_ast(interner)),
             HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
             HirStatement::Error => StatementKind::Error,
-            HirStatement::Comptime(statement) => {
-                StatementKind::Comptime(Box::new(statement.to_ast(interner).kind))
+            HirStatement::CompTime(statement) => {
+                StatementKind::CompTime(Box::new(statement.to_ast(interner).kind))
             }
         };
 
@@ -108,10 +108,7 @@ impl ExprId {
                 ExpressionKind::Literal(Literal::FmtStr(string))
             }
             HirExpression::Literal(HirLiteral::Unit) => ExpressionKind::Literal(Literal::Unit),
-            HirExpression::Block(expr) => {
-                let statements = vecmap(expr.statements, |statement| statement.to_ast(interner));
-                ExpressionKind::Block(BlockExpression { statements })
-            }
+            HirExpression::Block(expr) => ExpressionKind::Block(expr.into_ast(interner)),
             HirExpression::Prefix(prefix) => ExpressionKind::Prefix(Box::new(PrefixExpression {
                 operator: prefix.operator,
                 rhs: prefix.rhs.to_ast(interner),
@@ -172,8 +169,12 @@ impl ExprId {
                 let body = lambda.body.to_ast(interner);
                 ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
             }
-            HirExpression::Quote(block) => ExpressionKind::Quote(block),
             HirExpression::Error => ExpressionKind::Error,
+            HirExpression::Comptime(block) => ExpressionKind::Comptime(block.into_ast(interner)),
+            HirExpression::Quote(block) => ExpressionKind::Quote(block),
+
+            // A macro was evaluated here!
+            HirExpression::Unquote(block) => ExpressionKind::Block(block),
         };
 
         Expression::new(kind, span)
@@ -353,3 +354,10 @@ impl HirArrayLiteral {
         }
     }
 }
+
+impl HirBlockExpression {
+    fn into_ast(self, interner: &NodeInterner) -> BlockExpression {
+        let statements = vecmap(self.statements, |statement| statement.to_ast(interner));
+        BlockExpression { statements }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 03839c2f0cd..c6d508a581e 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -1,12 +1,12 @@
-use std::{borrow::Cow, collections::hash_map::Entry, rc::Rc};
+use std::{collections::hash_map::Entry, rc::Rc};
 
 use acvm::FieldElement;
 use im::Vector;
-use iter_extended::{try_vecmap, vecmap};
+use iter_extended::try_vecmap;
 use noirc_errors::Location;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
-use crate::ast::{BinaryOpKind, BlockExpression, FunctionKind, IntegerBitSize, Signedness};
+use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness};
 use crate::{
     hir_def::{
         expr::{
@@ -22,12 +22,16 @@ use crate::{
     },
     macros_api::{HirExpression, HirLiteral, HirStatement, NodeInterner},
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
+    Shared, Type, TypeBinding, TypeBindings, TypeVariableKind,
 };
-use crate::{Shared, Type, TypeBinding, TypeBindings, TypeVariableKind};
+
+use super::errors::{IResult, InterpreterError};
+use super::value::Value;
+
 #[allow(unused)]
-pub(crate) struct Interpreter<'interner> {
+pub struct Interpreter<'interner> {
     /// To expand macros the Interpreter may mutate hir nodes within the NodeInterner
-    interner: &'interner mut NodeInterner,
+    pub(super) interner: &'interner mut NodeInterner,
 
     /// Each value currently in scope in the interpreter.
     /// Each element of the Vec represents a scope with every scope together making
@@ -49,72 +53,6 @@ pub(crate) struct Interpreter<'interner> {
     in_comptime_context: bool,
 }
 
-#[allow(unused)]
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum Value {
-    Unit,
-    Bool(bool),
-    Field(FieldElement),
-    I8(i8),
-    I32(i32),
-    I64(i64),
-    U8(u8),
-    U32(u32),
-    U64(u64),
-    String(Rc<String>),
-    Function(FuncId, Type),
-    Closure(HirLambda, Vec<Value>, Type),
-    Tuple(Vec<Value>),
-    Struct(HashMap<Rc<String>, Value>, Type),
-    Pointer(Shared<Value>),
-    Array(Vector<Value>, Type),
-    Slice(Vector<Value>, Type),
-    Code(Rc<BlockExpression>),
-}
-
-/// The possible errors that can halt the interpreter.
-#[allow(unused)]
-#[derive(Debug)]
-pub(crate) enum InterpreterError {
-    ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
-    TypeMismatch { expected: Type, value: Value, location: Location },
-    NoValueForId { id: DefinitionId, location: Location },
-    IntegerOutOfRangeForType { value: FieldElement, typ: Type, location: Location },
-    ErrorNodeEncountered { location: Location },
-    NonFunctionCalled { value: Value, location: Location },
-    NonBoolUsedInIf { value: Value, location: Location },
-    NonBoolUsedInConstrain { value: Value, location: Location },
-    FailingConstraint { message: Option<Value>, location: Location },
-    NoMethodFound { object: Value, typ: Type, location: Location },
-    NonIntegerUsedInLoop { value: Value, location: Location },
-    NonPointerDereferenced { value: Value, location: Location },
-    NonTupleOrStructInMemberAccess { value: Value, location: Location },
-    NonArrayIndexed { value: Value, location: Location },
-    NonIntegerUsedAsIndex { value: Value, location: Location },
-    NonIntegerIntegerLiteral { typ: Type, location: Location },
-    NonIntegerArrayLength { typ: Type, location: Location },
-    NonNumericCasted { value: Value, location: Location },
-    IndexOutOfBounds { index: usize, length: usize, location: Location },
-    ExpectedStructToHaveField { value: Value, field_name: String, location: Location },
-    TypeUnsupported { typ: Type, location: Location },
-    InvalidValueForUnary { value: Value, operator: &'static str, location: Location },
-    InvalidValuesForBinary { lhs: Value, rhs: Value, operator: &'static str, location: Location },
-    CastToNonNumericType { typ: Type, location: Location },
-
-    // Perhaps this should be unreachable! due to type checking also preventing this error?
-    // Currently it and the Continue variant are the only interpreter errors without a Location field
-    BreakNotInLoop,
-    ContinueNotInLoop,
-
-    // These cases are not errors but prevent us from running more code
-    // until the loop can be resumed properly.
-    Break,
-    Continue,
-}
-
-#[allow(unused)]
-type IResult<T> = std::result::Result<T, InterpreterError>;
-
 #[allow(unused)]
 impl<'a> Interpreter<'a> {
     pub(crate) fn new(interner: &'a mut NodeInterner) -> Self {
@@ -193,14 +131,14 @@ impl<'a> Interpreter<'a> {
     /// Enters a function, pushing a new scope and resetting any required state.
     /// Returns the previous values of the internal state, to be reset when
     /// `exit_function` is called.
-    fn enter_function(&mut self) -> (bool, Vec<HashMap<DefinitionId, Value>>) {
+    pub(super) fn enter_function(&mut self) -> (bool, Vec<HashMap<DefinitionId, Value>>) {
         // Drain every scope except the global scope
         let scope = self.scopes.drain(1..).collect();
         self.push_scope();
         (std::mem::take(&mut self.in_loop), scope)
     }
 
-    fn exit_function(&mut self, mut state: (bool, Vec<HashMap<DefinitionId, Value>>)) {
+    pub(super) fn exit_function(&mut self, mut state: (bool, Vec<HashMap<DefinitionId, Value>>)) {
         self.in_loop = state.0;
 
         // Keep only the global scope
@@ -208,11 +146,11 @@ impl<'a> Interpreter<'a> {
         self.scopes.append(&mut state.1);
     }
 
-    fn push_scope(&mut self) {
+    pub(super) fn push_scope(&mut self) {
         self.scopes.push(HashMap::default());
     }
 
-    fn pop_scope(&mut self) {
+    pub(super) fn pop_scope(&mut self) {
         self.scopes.pop();
     }
 
@@ -375,6 +313,13 @@ impl<'a> Interpreter<'a> {
             HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
             HirExpression::Quote(block) => Ok(Value::Code(Rc::new(block))),
+            HirExpression::Comptime(block) => self.evaluate_block(block),
+            HirExpression::Unquote(block) => {
+                // An Unquote expression being found is indicative of a macro being
+                // expanded within another comptime fn which we don't currently support.
+                let location = self.interner.expr_location(&id);
+                Err(InterpreterError::UnquoteFoundDuringEvaluation { location })
+            }
             HirExpression::Error => {
                 let location = self.interner.expr_location(&id);
                 Err(InterpreterError::ErrorNodeEncountered { location })
@@ -390,7 +335,7 @@ impl<'a> Interpreter<'a> {
                 let typ = self.interner.id_type(id);
                 Ok(Value::Function(*function_id, typ))
             }
-            DefinitionKind::Local(_) => dbg!(self.lookup(&ident)),
+            DefinitionKind::Local(_) => self.lookup(&ident),
             DefinitionKind::Global(global_id) => {
                 let let_ = self.interner.get_global_let_statement(*global_id).unwrap();
                 self.evaluate_let(let_)?;
@@ -503,7 +448,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    fn evaluate_block(&mut self, mut block: HirBlockExpression) -> IResult<Value> {
+    pub(super) fn evaluate_block(&mut self, mut block: HirBlockExpression) -> IResult<Value> {
         let last_statement = block.statements.pop();
         self.push_scope();
 
@@ -1075,10 +1020,10 @@ impl<'a> Interpreter<'a> {
             HirStatement::Constrain(constrain) => self.evaluate_constrain(constrain),
             HirStatement::Assign(assign) => self.evaluate_assign(assign),
             HirStatement::For(for_) => self.evaluate_for(for_),
-            HirStatement::Break => self.evaluate_break(),
-            HirStatement::Continue => self.evaluate_continue(),
+            HirStatement::Break => self.evaluate_break(statement),
+            HirStatement::Continue => self.evaluate_continue(statement),
             HirStatement::Expression(expression) => self.evaluate(expression),
-            HirStatement::Comptime(statement) => self.evaluate_comptime(statement),
+            HirStatement::CompTime(statement) => self.evaluate_comptime(statement),
             HirStatement::Semi(expression) => {
                 self.evaluate(expression)?;
                 Ok(Value::Unit)
@@ -1236,59 +1181,28 @@ impl<'a> Interpreter<'a> {
         Ok(Value::Unit)
     }
 
-    fn evaluate_break(&mut self) -> IResult<Value> {
+    fn evaluate_break(&mut self, id: StmtId) -> IResult<Value> {
         if self.in_loop {
             Err(InterpreterError::Break)
         } else {
-            Err(InterpreterError::BreakNotInLoop)
+            let location = self.interner.statement_location(id);
+            Err(InterpreterError::BreakNotInLoop { location })
         }
     }
 
-    fn evaluate_continue(&mut self) -> IResult<Value> {
+    fn evaluate_continue(&mut self, id: StmtId) -> IResult<Value> {
         if self.in_loop {
             Err(InterpreterError::Continue)
         } else {
-            Err(InterpreterError::ContinueNotInLoop)
+            let location = self.interner.statement_location(id);
+            Err(InterpreterError::ContinueNotInLoop { location })
         }
     }
 
-    fn evaluate_comptime(&mut self, statement: StmtId) -> IResult<Value> {
+    pub(super) fn evaluate_comptime(&mut self, statement: StmtId) -> IResult<Value> {
         let was_in_comptime = std::mem::replace(&mut self.in_comptime_context, true);
         let result = self.evaluate_statement(statement);
         self.in_comptime_context = was_in_comptime;
         result
     }
 }
-
-impl Value {
-    fn get_type(&self) -> Cow<Type> {
-        Cow::Owned(match self {
-            Value::Unit => Type::Unit,
-            Value::Bool(_) => Type::Bool,
-            Value::Field(_) => Type::FieldElement,
-            Value::I8(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Eight),
-            Value::I32(_) => Type::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo),
-            Value::I64(_) => Type::Integer(Signedness::Signed, IntegerBitSize::SixtyFour),
-            Value::U8(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
-            Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
-            Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
-            Value::String(value) => {
-                let length = Type::Constant(value.len() as u64);
-                Type::String(Box::new(length))
-            }
-            Value::Function(_, typ) => return Cow::Borrowed(typ),
-            Value::Closure(_, _, typ) => return Cow::Borrowed(typ),
-            Value::Tuple(fields) => {
-                Type::Tuple(vecmap(fields, |field| field.get_type().into_owned()))
-            }
-            Value::Struct(_, typ) => return Cow::Borrowed(typ),
-            Value::Array(_, typ) => return Cow::Borrowed(typ),
-            Value::Slice(_, typ) => return Cow::Borrowed(typ),
-            Value::Code(_) => Type::Code,
-            Value::Pointer(element) => {
-                let element = element.borrow().get_type().into_owned();
-                Type::MutableReference(Box::new(element))
-            }
-        })
-    }
-}
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
index 83aaddaa405..26e05d675b3 100644
--- a/compiler/noirc_frontend/src/hir/comptime/mod.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -1,3 +1,8 @@
+mod errors;
 mod hir_to_ast;
 mod interpreter;
+mod scan;
 mod tests;
+mod value;
+
+pub use interpreter::Interpreter;
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
new file mode 100644
index 00000000000..d4fa355627f
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -0,0 +1,207 @@
+//! This module is for the scanning of the Hir by the interpreter.
+//! In this initial step, the Hir is scanned for `CompTime` nodes
+//! without actually executing anything until such a node is found.
+//! Once such a node is found, the interpreter will call the relevant
+//! evaluate method on that node type, insert the result into the Ast,
+//! and continue scanning the rest of the program.
+//!
+//! Since it mostly just needs to recur on the Hir looking for CompTime
+//! nodes, this pass is fairly simple. The only thing it really needs to
+//! ensure to do is to push and pop scopes on the interpreter as needed
+//! so that any variables defined within e.g. an `if` statement containing
+//! a `CompTime` block aren't accessible outside of the `if`.
+use crate::{
+    hir_def::{
+        expr::{
+            HirArrayLiteral, HirBlockExpression, HirCallExpression, HirConstructorExpression,
+            HirIfExpression, HirIndexExpression, HirInfixExpression, HirLambda,
+            HirMethodCallExpression,
+        },
+        stmt::HirForStatement,
+    },
+    macros_api::{HirExpression, HirLiteral, HirStatement},
+    node_interner::{ExprId, FuncId, StmtId},
+};
+
+use super::{
+    errors::{IResult, InterpreterError},
+    interpreter::Interpreter,
+};
+
+#[allow(dead_code)]
+impl<'interner> Interpreter<'interner> {
+    /// Scan through a function, evaluating any CompTime nodes found.
+    /// These nodes will be modified in place, replaced with the
+    /// result of their evaluation.
+    pub fn scan_function(&mut self, function: FuncId) -> IResult<()> {
+        let function = self.interner.function(&function);
+
+        let state = self.enter_function();
+        self.scan_expression(function.as_expr())?;
+        self.exit_function(state);
+        Ok(())
+    }
+
+    fn scan_expression(&mut self, expr: ExprId) -> IResult<()> {
+        match self.interner.expression(&expr) {
+            HirExpression::Ident(_) => Ok(()),
+            HirExpression::Literal(literal) => self.scan_literal(literal),
+            HirExpression::Block(block) => self.scan_block(block),
+            HirExpression::Prefix(prefix) => self.scan_expression(prefix.rhs),
+            HirExpression::Infix(infix) => self.scan_infix(infix),
+            HirExpression::Index(index) => self.scan_index(index),
+            HirExpression::Constructor(constructor) => self.scan_constructor(constructor),
+            HirExpression::MemberAccess(member_access) => self.scan_expression(member_access.lhs),
+            HirExpression::Call(call) => self.scan_call(call),
+            HirExpression::MethodCall(method_call) => self.scan_method_call(method_call),
+            HirExpression::Cast(cast) => self.scan_expression(cast.lhs),
+            HirExpression::If(if_) => self.scan_if(if_),
+            HirExpression::Tuple(tuple) => self.scan_tuple(tuple),
+            HirExpression::Lambda(lambda) => self.scan_lambda(lambda),
+            HirExpression::Comptime(block) => {
+                let location = self.interner.expr_location(&expr);
+                let new_expr =
+                    self.evaluate_block(block)?.into_expression(self.interner, location)?;
+                let new_expr = self.interner.expression(&new_expr);
+                self.interner.replace_expr(&expr, new_expr);
+                Ok(())
+            }
+            HirExpression::Quote(_) => {
+                // This error could be detected much earlier in the compiler pipeline but
+                // it just makes sense for the comptime code to handle comptime things.
+                let location = self.interner.expr_location(&expr);
+                Err(InterpreterError::QuoteInRuntimeCode { location })
+            }
+            HirExpression::Error => Ok(()),
+
+            // Unquote should only be inserted by the comptime interpreter while expanding macros
+            // and is removed by the Hir -> Ast conversion pass which converts it into a normal block.
+            // If we find one now during scanning it most likely means the Hir -> Ast conversion
+            // missed it somehow. In the future we may allow users to manually write unquote
+            // expressions in their code but for now this is unreachable.
+            HirExpression::Unquote(block) => {
+                unreachable!("Found unquote block while scanning: {block}")
+            }
+        }
+    }
+
+    fn scan_literal(&mut self, literal: HirLiteral) -> IResult<()> {
+        match literal {
+            HirLiteral::Array(elements) | HirLiteral::Slice(elements) => match elements {
+                HirArrayLiteral::Standard(elements) => {
+                    for element in elements {
+                        self.scan_expression(element)?;
+                    }
+                    Ok(())
+                }
+                HirArrayLiteral::Repeated { repeated_element, length: _ } => {
+                    self.scan_expression(repeated_element)
+                }
+            },
+            HirLiteral::Bool(_)
+            | HirLiteral::Integer(_, _)
+            | HirLiteral::Str(_)
+            | HirLiteral::FmtStr(_, _)
+            | HirLiteral::Unit => Ok(()),
+        }
+    }
+
+    fn scan_block(&mut self, block: HirBlockExpression) -> IResult<()> {
+        self.push_scope();
+        for statement in &block.statements {
+            self.scan_statement(*statement)?;
+        }
+        self.pop_scope();
+        Ok(())
+    }
+
+    fn scan_infix(&mut self, infix: HirInfixExpression) -> IResult<()> {
+        self.scan_expression(infix.lhs)?;
+        self.scan_expression(infix.rhs)
+    }
+
+    fn scan_index(&mut self, index: HirIndexExpression) -> IResult<()> {
+        self.scan_expression(index.collection)?;
+        self.scan_expression(index.index)
+    }
+
+    fn scan_constructor(&mut self, constructor: HirConstructorExpression) -> IResult<()> {
+        for (_, field) in constructor.fields {
+            self.scan_expression(field)?;
+        }
+        Ok(())
+    }
+
+    fn scan_call(&mut self, call: HirCallExpression) -> IResult<()> {
+        self.scan_expression(call.func)?;
+        for arg in call.arguments {
+            self.scan_expression(arg)?;
+        }
+        Ok(())
+    }
+
+    fn scan_method_call(&mut self, method_call: HirMethodCallExpression) -> IResult<()> {
+        self.scan_expression(method_call.object)?;
+        for arg in method_call.arguments {
+            self.scan_expression(arg)?;
+        }
+        Ok(())
+    }
+
+    fn scan_if(&mut self, if_: HirIfExpression) -> IResult<()> {
+        self.scan_expression(if_.condition)?;
+
+        self.push_scope();
+        self.scan_expression(if_.consequence)?;
+        self.pop_scope();
+
+        if let Some(alternative) = if_.alternative {
+            self.push_scope();
+            self.scan_expression(alternative)?;
+            self.pop_scope();
+        }
+        Ok(())
+    }
+
+    fn scan_tuple(&mut self, tuple: Vec<ExprId>) -> IResult<()> {
+        for field in tuple {
+            self.scan_expression(field)?;
+        }
+        Ok(())
+    }
+
+    fn scan_lambda(&mut self, lambda: HirLambda) -> IResult<()> {
+        self.scan_expression(lambda.body)
+    }
+
+    fn scan_statement(&mut self, statement: StmtId) -> IResult<()> {
+        match self.interner.statement(&statement) {
+            HirStatement::Let(let_) => self.scan_expression(let_.expression),
+            HirStatement::Constrain(constrain) => self.scan_expression(constrain.0),
+            HirStatement::Assign(assign) => self.scan_expression(assign.expression),
+            HirStatement::For(for_) => self.scan_for(for_),
+            HirStatement::Break => Ok(()),
+            HirStatement::Continue => Ok(()),
+            HirStatement::Expression(expression) => self.scan_expression(expression),
+            HirStatement::Semi(semi) => self.scan_expression(semi),
+            HirStatement::Error => Ok(()),
+            HirStatement::CompTime(comptime) => {
+                let location = self.interner.statement_location(comptime);
+                let new_expr =
+                    self.evaluate_comptime(comptime)?.into_expression(self.interner, location)?;
+                self.interner.replace_statement(statement, HirStatement::Expression(new_expr));
+                Ok(())
+            }
+        }
+    }
+
+    fn scan_for(&mut self, for_: HirForStatement) -> IResult<()> {
+        // We don't need to set self.in_loop since we're not actually evaluating this loop.
+        // We just need to push a scope so that if there's a `comptime { .. }` expr inside this
+        // loop, any variables it defines aren't accessible outside of it.
+        self.push_scope();
+        self.scan_expression(for_.block)?;
+        self.pop_scope();
+        Ok(())
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 016e7079886..1a84dae4a87 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -2,7 +2,9 @@
 
 use noirc_errors::Location;
 
-use super::interpreter::{Interpreter, InterpreterError, Value};
+use super::errors::InterpreterError;
+use super::interpreter::Interpreter;
+use super::value::Value;
 use crate::hir::type_check::test::type_check_src_code;
 
 fn interpret_helper(src: &str, func_namespace: Vec<String>) -> Result<Value, InterpreterError> {
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
new file mode 100644
index 00000000000..89102344b09
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -0,0 +1,170 @@
+use std::{borrow::Cow, rc::Rc};
+
+use acvm::FieldElement;
+use im::Vector;
+use iter_extended::{try_vecmap, vecmap};
+use noirc_errors::Location;
+
+use crate::{
+    ast::{BlockExpression, Ident, IntegerBitSize, Signedness},
+    hir_def::expr::{HirArrayLiteral, HirConstructorExpression, HirIdent, HirLambda, ImplKind},
+    macros_api::{HirExpression, HirLiteral, NodeInterner},
+    node_interner::{ExprId, FuncId},
+    Shared, Type,
+};
+use rustc_hash::FxHashMap as HashMap;
+
+use super::errors::{IResult, InterpreterError};
+
+#[allow(unused)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Value {
+    Unit,
+    Bool(bool),
+    Field(FieldElement),
+    I8(i8),
+    I32(i32),
+    I64(i64),
+    U8(u8),
+    U32(u32),
+    U64(u64),
+    String(Rc<String>),
+    Function(FuncId, Type),
+    Closure(HirLambda, Vec<Value>, Type),
+    Tuple(Vec<Value>),
+    Struct(HashMap<Rc<String>, Value>, Type),
+    Pointer(Shared<Value>),
+    Array(Vector<Value>, Type),
+    Slice(Vector<Value>, Type),
+    Code(Rc<BlockExpression>),
+}
+
+impl Value {
+    pub(crate) fn get_type(&self) -> Cow<Type> {
+        Cow::Owned(match self {
+            Value::Unit => Type::Unit,
+            Value::Bool(_) => Type::Bool,
+            Value::Field(_) => Type::FieldElement,
+            Value::I8(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Eight),
+            Value::I32(_) => Type::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo),
+            Value::I64(_) => Type::Integer(Signedness::Signed, IntegerBitSize::SixtyFour),
+            Value::U8(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+            Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
+            Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
+            Value::String(value) => {
+                let length = Type::Constant(value.len() as u64);
+                Type::String(Box::new(length))
+            }
+            Value::Function(_, typ) => return Cow::Borrowed(typ),
+            Value::Closure(_, _, typ) => return Cow::Borrowed(typ),
+            Value::Tuple(fields) => {
+                Type::Tuple(vecmap(fields, |field| field.get_type().into_owned()))
+            }
+            Value::Struct(_, typ) => return Cow::Borrowed(typ),
+            Value::Array(_, typ) => return Cow::Borrowed(typ),
+            Value::Slice(_, typ) => return Cow::Borrowed(typ),
+            Value::Code(_) => Type::Code,
+            Value::Pointer(element) => {
+                let element = element.borrow().get_type().into_owned();
+                Type::MutableReference(Box::new(element))
+            }
+        })
+    }
+
+    pub(crate) fn into_expression(
+        self,
+        interner: &mut NodeInterner,
+        location: Location,
+    ) -> IResult<ExprId> {
+        let typ = self.get_type().into_owned();
+
+        let expression = match self {
+            Value::Unit => HirExpression::Literal(HirLiteral::Unit),
+            Value::Bool(value) => HirExpression::Literal(HirLiteral::Bool(value)),
+            Value::Field(value) => HirExpression::Literal(HirLiteral::Integer(value, false)),
+            Value::I8(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                HirExpression::Literal(HirLiteral::Integer(value, negative))
+            }
+            Value::I32(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                HirExpression::Literal(HirLiteral::Integer(value, negative))
+            }
+            Value::I64(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                HirExpression::Literal(HirLiteral::Integer(value, negative))
+            }
+            Value::U8(value) => {
+                HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
+            }
+            Value::U32(value) => {
+                HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
+            }
+            Value::U64(value) => {
+                HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
+            }
+            Value::String(value) => HirExpression::Literal(HirLiteral::Str(unwrap_rc(value))),
+            Value::Function(id, _typ) => {
+                let id = interner.function_definition_id(id);
+                let impl_kind = ImplKind::NotATraitMethod;
+                HirExpression::Ident(HirIdent { location, id, impl_kind })
+            }
+            Value::Closure(_lambda, _env, _typ) => {
+                // TODO: How should a closure's environment be inlined?
+                let item = "returning closures from a comptime fn";
+                return Err(InterpreterError::Unimplemented { item, location });
+            }
+            Value::Tuple(fields) => {
+                let fields = try_vecmap(fields, |field| field.into_expression(interner, location))?;
+                HirExpression::Tuple(fields)
+            }
+            Value::Struct(fields, typ) => {
+                let fields = try_vecmap(fields, |(name, field)| {
+                    let field = field.into_expression(interner, location)?;
+                    Ok((Ident::new(unwrap_rc(name), location.span), field))
+                })?;
+
+                let (r#type, struct_generics) = match typ.follow_bindings() {
+                    Type::Struct(def, generics) => (def, generics),
+                    _ => return Err(InterpreterError::NonStructInConstructor { typ, location }),
+                };
+
+                HirExpression::Constructor(HirConstructorExpression {
+                    r#type,
+                    struct_generics,
+                    fields,
+                })
+            }
+            Value::Array(elements, _) => {
+                let elements =
+                    try_vecmap(elements, |elements| elements.into_expression(interner, location))?;
+                HirExpression::Literal(HirLiteral::Array(HirArrayLiteral::Standard(elements)))
+            }
+            Value::Slice(elements, _) => {
+                let elements =
+                    try_vecmap(elements, |elements| elements.into_expression(interner, location))?;
+                HirExpression::Literal(HirLiteral::Slice(HirArrayLiteral::Standard(elements)))
+            }
+            Value::Code(block) => HirExpression::Unquote(unwrap_rc(block)),
+            Value::Pointer(_) => {
+                return Err(InterpreterError::CannotInlineMacro { value: self, location })
+            }
+        };
+
+        let id = interner.push_expr(expression);
+        interner.push_expr_location(id, location.span, location.file);
+        interner.push_expr_type(id, typ);
+        Ok(id)
+    }
+}
+
+/// Unwraps an Rc value without cloning the inner value if the reference count is 1. Clones otherwise.
+fn unwrap_rc<T: Clone>(rc: Rc<T>) -> T {
+    Rc::try_unwrap(rc).unwrap_or_else(|rc| (*rc).clone())
+}
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 4c6b5ab5885..7805f36cdb2 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -1,6 +1,7 @@
 use super::dc_mod::collect_defs;
 use super::errors::{DefCollectorErrorKind, DuplicateType};
 use crate::graph::CrateId;
+use crate::hir::comptime::Interpreter;
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
 
@@ -30,6 +31,15 @@ use std::collections::{BTreeMap, HashMap};
 
 use std::vec;
 
+#[derive(Default)]
+pub struct ResolvedModule {
+    pub globals: Vec<(FileId, GlobalId)>,
+    pub functions: Vec<(FileId, FuncId)>,
+    pub trait_impl_functions: Vec<(FileId, FuncId)>,
+
+    pub errors: Vec<(CompilationError, FileId)>,
+}
+
 /// Stores all of the unresolved functions in a particular file/mod
 #[derive(Clone)]
 pub struct UnresolvedFunctions {
@@ -304,6 +314,8 @@ impl DefCollector {
             }
         }
 
+        let mut resolved_module = ResolvedModule { errors, ..Default::default() };
+
         // We must first resolve and intern the globals before we can resolve any stmts inside each function.
         // Each function uses its own resolver with a newly created ScopeForest, and must be resolved again to be within a function's scope
         //
@@ -312,21 +324,29 @@ impl DefCollector {
         let (literal_globals, other_globals) =
             filter_literal_globals(def_collector.collected_globals);
 
-        let mut resolved_globals = resolve_globals(context, literal_globals, crate_id);
+        resolved_module.resolve_globals(context, literal_globals, crate_id);
 
-        errors.extend(resolve_type_aliases(
+        resolved_module.errors.extend(resolve_type_aliases(
             context,
             def_collector.collected_type_aliases,
             crate_id,
         ));
 
-        errors.extend(resolve_traits(context, def_collector.collected_traits, crate_id));
+        resolved_module.errors.extend(resolve_traits(
+            context,
+            def_collector.collected_traits,
+            crate_id,
+        ));
         // Must resolve structs before we resolve globals.
-        errors.extend(resolve_structs(context, def_collector.collected_types, crate_id));
+        resolved_module.errors.extend(resolve_structs(
+            context,
+            def_collector.collected_types,
+            crate_id,
+        ));
 
         // Bind trait impls to their trait. Collect trait functions, that have a
         // default implementation, which hasn't been overridden.
-        errors.extend(collect_trait_impls(
+        resolved_module.errors.extend(collect_trait_impls(
             context,
             crate_id,
             &mut def_collector.collected_traits_impls,
@@ -339,54 +359,55 @@ impl DefCollector {
         //
         // These are resolved after trait impls so that struct methods are chosen
         // over trait methods if there are name conflicts.
-        errors.extend(collect_impls(context, crate_id, &def_collector.collected_impls));
+        resolved_module.errors.extend(collect_impls(
+            context,
+            crate_id,
+            &def_collector.collected_impls,
+        ));
 
         // We must wait to resolve non-integer globals until after we resolve structs since struct
         // globals will need to reference the struct type they're initialized to to ensure they are valid.
-        resolved_globals.extend(resolve_globals(context, other_globals, crate_id));
-        errors.extend(resolved_globals.errors);
+        resolved_module.resolve_globals(context, other_globals, crate_id);
 
         // Resolve each function in the crate. This is now possible since imports have been resolved
-        let mut functions = Vec::new();
-        functions.extend(resolve_free_functions(
+        resolved_module.functions = resolve_free_functions(
             &mut context.def_interner,
             crate_id,
             &context.def_maps,
             def_collector.collected_functions,
             None,
-            &mut errors,
-        ));
+            &mut resolved_module.errors,
+        );
 
-        functions.extend(resolve_impls(
+        resolved_module.functions.extend(resolve_impls(
             &mut context.def_interner,
             crate_id,
             &context.def_maps,
             def_collector.collected_impls,
-            &mut errors,
+            &mut resolved_module.errors,
         ));
 
-        let impl_functions = resolve_trait_impls(
+        resolved_module.trait_impl_functions = resolve_trait_impls(
             context,
             def_collector.collected_traits_impls,
             crate_id,
-            &mut errors,
+            &mut resolved_module.errors,
         );
 
         for macro_processor in macro_processors {
             macro_processor.process_typed_ast(&crate_id, context).unwrap_or_else(
                 |(macro_err, file_id)| {
-                    errors.push((macro_err.into(), file_id));
+                    resolved_module.errors.push((macro_err.into(), file_id));
                 },
             );
         }
 
-        errors.extend(context.def_interner.check_for_dependency_cycles());
+        resolved_module.errors.extend(context.def_interner.check_for_dependency_cycles());
 
-        errors.extend(type_check_globals(&mut context.def_interner, resolved_globals.globals));
-        errors.extend(type_check_functions(&mut context.def_interner, functions));
-        errors.extend(type_check_trait_impl_signatures(&mut context.def_interner, &impl_functions));
-        errors.extend(type_check_functions(&mut context.def_interner, impl_functions));
-        errors
+        resolved_module.type_check(context);
+        resolved_module.evaluate_comptime(&mut context.def_interner);
+
+        resolved_module.errors
     }
 }
 
@@ -444,48 +465,59 @@ fn filter_literal_globals(
     })
 }
 
-fn type_check_globals(
-    interner: &mut NodeInterner,
-    global_ids: Vec<(FileId, GlobalId)>,
-) -> Vec<(CompilationError, fm::FileId)> {
-    global_ids
-        .into_iter()
-        .flat_map(|(file_id, global_id)| {
-            TypeChecker::check_global(global_id, interner)
-                .iter()
-                .cloned()
-                .map(|e| (e.into(), file_id))
-                .collect::<Vec<_>>()
-        })
-        .collect()
-}
+impl ResolvedModule {
+    fn type_check(&mut self, context: &mut Context) {
+        self.type_check_globals(&mut context.def_interner);
+        self.type_check_functions(&mut context.def_interner);
+        self.type_check_trait_impl_function(&mut context.def_interner);
+    }
 
-fn type_check_functions(
-    interner: &mut NodeInterner,
-    file_func_ids: Vec<(FileId, FuncId)>,
-) -> Vec<(CompilationError, fm::FileId)> {
-    file_func_ids
-        .into_iter()
-        .flat_map(|(file, func)| {
-            type_check_func(interner, func)
-                .into_iter()
-                .map(|e| (e.into(), file))
-                .collect::<Vec<_>>()
-        })
-        .collect()
-}
+    fn type_check_globals(&mut self, interner: &mut NodeInterner) {
+        for (file_id, global_id) in self.globals.iter() {
+            for error in TypeChecker::check_global(*global_id, interner) {
+                self.errors.push((error.into(), *file_id));
+            }
+        }
+    }
+
+    fn type_check_functions(&mut self, interner: &mut NodeInterner) {
+        for (file, func) in self.functions.iter() {
+            for error in type_check_func(interner, *func) {
+                self.errors.push((error.into(), *file));
+            }
+        }
+    }
+
+    fn type_check_trait_impl_function(&mut self, interner: &mut NodeInterner) {
+        for (file, func) in self.trait_impl_functions.iter() {
+            for error in check_trait_impl_method_matches_declaration(interner, *func) {
+                self.errors.push((error.into(), *file));
+            }
+            for error in type_check_func(interner, *func) {
+                self.errors.push((error.into(), *file));
+            }
+        }
+    }
+
+    /// Evaluate all `comptime` expressions in this module
+    fn evaluate_comptime(&self, interner: &mut NodeInterner) {
+        let mut interpreter = Interpreter::new(interner);
+
+        for (_file, function) in &self.functions {
+            // .unwrap() is temporary here until we can convert
+            // from InterpreterError to (CompilationError, FileId)
+            interpreter.scan_function(*function).unwrap();
+        }
+    }
 
-fn type_check_trait_impl_signatures(
-    interner: &mut NodeInterner,
-    file_func_ids: &[(FileId, FuncId)],
-) -> Vec<(CompilationError, fm::FileId)> {
-    file_func_ids
-        .iter()
-        .flat_map(|(file, func)| {
-            check_trait_impl_method_matches_declaration(interner, *func)
-                .into_iter()
-                .map(|e| (e.into(), *file))
-                .collect::<Vec<_>>()
-        })
-        .collect()
+    fn resolve_globals(
+        &mut self,
+        context: &mut Context,
+        literal_globals: Vec<UnresolvedGlobal>,
+        crate_id: CrateId,
+    ) {
+        let globals = resolve_globals(context, literal_globals, crate_id);
+        self.globals.extend(globals.globals);
+        self.errors.extend(globals.errors);
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/globals.rs b/compiler/noirc_frontend/src/hir/resolution/globals.rs
index 9fb31271727..bcda4e75d3d 100644
--- a/compiler/noirc_frontend/src/hir/resolution/globals.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/globals.rs
@@ -11,18 +11,12 @@ use crate::{
 use fm::FileId;
 use iter_extended::vecmap;
 
+#[derive(Default)]
 pub(crate) struct ResolvedGlobals {
     pub(crate) globals: Vec<(FileId, GlobalId)>,
     pub(crate) errors: Vec<(CompilationError, FileId)>,
 }
 
-impl ResolvedGlobals {
-    pub(crate) fn extend(&mut self, oth: Self) {
-        self.globals.extend(oth.globals);
-        self.errors.extend(oth.errors);
-    }
-}
-
 pub(crate) fn resolve_globals(
     context: &mut Context,
     globals: Vec<UnresolvedGlobal>,
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 0e69b3bdeba..8d2cb17189b 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1272,9 +1272,9 @@ impl<'a> Resolver<'a> {
                 HirStatement::Continue
             }
             StatementKind::Error => HirStatement::Error,
-            StatementKind::Comptime(statement) => {
+            StatementKind::CompTime(statement) => {
                 let statement = self.resolve_stmt(*statement, span);
-                HirStatement::Comptime(self.interner.push_stmt(statement))
+                HirStatement::CompTime(self.interner.push_stmt(statement))
             }
         }
     }
@@ -1323,7 +1323,9 @@ impl<'a> Resolver<'a> {
 
     pub fn intern_stmt(&mut self, stmt: Statement) -> StmtId {
         let hir_stmt = self.resolve_stmt(stmt.kind, stmt.span);
-        self.interner.push_stmt(hir_stmt)
+        let id = self.interner.push_stmt(hir_stmt);
+        self.interner.push_statement_location(id, stmt.span, self.file);
+        id
     }
 
     fn resolve_lvalue(&mut self, lvalue: LValue) -> HirLValue {
@@ -1531,7 +1533,9 @@ impl<'a> Resolver<'a> {
                 collection: self.resolve_expression(indexed_expr.collection),
                 index: self.resolve_expression(indexed_expr.index),
             }),
-            ExpressionKind::Block(block_expr) => self.resolve_block(block_expr),
+            ExpressionKind::Block(block_expr) => {
+                HirExpression::Block(self.resolve_block(block_expr))
+            }
             ExpressionKind::Constructor(constructor) => {
                 let span = constructor.type_name.span();
 
@@ -1598,6 +1602,7 @@ impl<'a> Resolver<'a> {
 
             // The quoted expression isn't resolved since we don't want errors if variables aren't defined
             ExpressionKind::Quote(block) => HirExpression::Quote(block),
+            ExpressionKind::Comptime(block) => HirExpression::Comptime(self.resolve_block(block)),
         };
 
         // If these lines are ever changed, make sure to change the early return
@@ -1930,14 +1935,14 @@ impl<'a> Resolver<'a> {
         Ok(path_resolution.module_def_id)
     }
 
-    fn resolve_block(&mut self, block_expr: BlockExpression) -> HirExpression {
+    fn resolve_block(&mut self, block_expr: BlockExpression) -> HirBlockExpression {
         let statements =
             self.in_new_scope(|this| vecmap(block_expr.statements, |stmt| this.intern_stmt(stmt)));
-        HirExpression::Block(HirBlockExpression { statements })
+        HirBlockExpression { statements }
     }
 
     pub fn intern_block(&mut self, block: BlockExpression) -> ExprId {
-        let hir_block = self.resolve_block(block);
+        let hir_block = HirExpression::Block(self.resolve_block(block));
         self.interner.push_expr(hir_block)
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 62330732be4..0bc7673e105 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -6,8 +6,8 @@ use crate::{
     hir::{resolution::resolver::verify_mutable_reference, type_check::errors::Source},
     hir_def::{
         expr::{
-            self, HirArrayLiteral, HirBinaryOp, HirExpression, HirIdent, HirLiteral,
-            HirMethodCallExpression, HirMethodReference, HirPrefixExpression, ImplKind,
+            self, HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirExpression, HirIdent,
+            HirLiteral, HirMethodCallExpression, HirMethodReference, HirPrefixExpression, ImplKind,
         },
         types::Type,
     },
@@ -271,34 +271,7 @@ impl<'interner> TypeChecker<'interner> {
                 let span = self.interner.expr_span(expr_id);
                 self.check_cast(lhs_type, cast_expr.r#type, span)
             }
-            HirExpression::Block(block_expr) => {
-                let mut block_type = Type::Unit;
-
-                let statements = block_expr.statements();
-                for (i, stmt) in statements.iter().enumerate() {
-                    let expr_type = self.check_statement(stmt);
-
-                    if let crate::hir_def::stmt::HirStatement::Semi(expr) =
-                        self.interner.statement(stmt)
-                    {
-                        let inner_expr_type = self.interner.id_type(expr);
-                        let span = self.interner.expr_span(&expr);
-
-                        self.unify(&inner_expr_type, &Type::Unit, || {
-                            TypeCheckError::UnusedResultError {
-                                expr_type: inner_expr_type.clone(),
-                                expr_span: span,
-                            }
-                        });
-                    }
-
-                    if i + 1 == statements.len() {
-                        block_type = expr_type;
-                    }
-                }
-
-                block_type
-            }
+            HirExpression::Block(block_expr) => self.check_block(block_expr),
             HirExpression::Prefix(prefix_expr) => {
                 let rhs_type = self.check_expression(&prefix_expr.rhs);
                 let span = self.interner.expr_span(&prefix_expr.rhs);
@@ -336,12 +309,44 @@ impl<'interner> TypeChecker<'interner> {
                 Type::Function(params, Box::new(lambda.return_type), Box::new(env_type))
             }
             HirExpression::Quote(_) => Type::Code,
+            HirExpression::Comptime(block) => self.check_block(block),
+
+            // Unquote should be inserted & removed by the comptime interpreter.
+            // Even if we allowed it here, we wouldn't know what type to give to the result.
+            HirExpression::Unquote(block) => {
+                unreachable!("Unquote remaining during type checking {block}")
+            }
         };
 
         self.interner.push_expr_type(*expr_id, typ.clone());
         typ
     }
 
+    fn check_block(&mut self, block: HirBlockExpression) -> Type {
+        let mut block_type = Type::Unit;
+
+        let statements = block.statements();
+        for (i, stmt) in statements.iter().enumerate() {
+            let expr_type = self.check_statement(stmt);
+
+            if let crate::hir_def::stmt::HirStatement::Semi(expr) = self.interner.statement(stmt) {
+                let inner_expr_type = self.interner.id_type(expr);
+                let span = self.interner.expr_span(&expr);
+
+                self.unify(&inner_expr_type, &Type::Unit, || TypeCheckError::UnusedResultError {
+                    expr_type: inner_expr_type.clone(),
+                    expr_span: span,
+                });
+            }
+
+            if i + 1 == statements.len() {
+                block_type = expr_type;
+            }
+        }
+
+        block_type
+    }
+
     /// Returns the type of the given identifier
     fn check_ident(&mut self, ident: HirIdent, expr_id: &ExprId) -> Type {
         let mut bindings = TypeBindings::new();
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index f5f6e1e8180..064fefc8ae9 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -51,7 +51,7 @@ impl<'interner> TypeChecker<'interner> {
             HirStatement::Constrain(constrain_stmt) => self.check_constrain_stmt(constrain_stmt),
             HirStatement::Assign(assign_stmt) => self.check_assign_stmt(assign_stmt, stmt_id),
             HirStatement::For(for_loop) => self.check_for_loop(for_loop),
-            HirStatement::Comptime(statement) => return self.check_statement(&statement),
+            HirStatement::CompTime(statement) => return self.check_statement(&statement),
             HirStatement::Break | HirStatement::Continue | HirStatement::Error => (),
         }
         Type::Unit
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index d88b65d1fce..bf7d9b7b4ba 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -31,8 +31,10 @@ pub enum HirExpression {
     If(HirIfExpression),
     Tuple(Vec<ExprId>),
     Lambda(HirLambda),
-    Error,
     Quote(crate::ast::BlockExpression),
+    Unquote(crate::ast::BlockExpression),
+    Comptime(HirBlockExpression),
+    Error,
 }
 
 impl HirExpression {
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 7e22e5ee9c0..48e7d7344e3 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -20,7 +20,7 @@ pub enum HirStatement {
     Continue,
     Expression(ExprId),
     Semi(ExprId),
-    Comptime(StmtId),
+    CompTime(StmtId),
     Error,
 }
 
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 74a0dd855c0..d92b6c65d7a 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -521,6 +521,12 @@ impl<'interner> Monomorphizer<'interner> {
             }
             HirExpression::Error => unreachable!("Encountered Error node during monomorphization"),
             HirExpression::Quote(_) => unreachable!("quote expression remaining in runtime code"),
+            HirExpression::Unquote(_) => {
+                unreachable!("unquote expression remaining in runtime code")
+            }
+            HirExpression::Comptime(_) => {
+                unreachable!("comptime expression remaining in runtime code")
+            }
         };
 
         Ok(expr)
@@ -626,7 +632,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirStatement::Error => unreachable!(),
 
             // All `comptime` statements & expressions should be removed before runtime.
-            HirStatement::Comptime(_) => unreachable!("comptime statement in runtime code"),
+            HirStatement::CompTime(_) => unreachable!("comptime statement in runtime code"),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index b0e68be4868..9d3a79820dc 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -921,10 +921,18 @@ impl NodeInterner {
         self.id_location(expr_id)
     }
 
-    pub fn statement_span(&self, stmt_id: &StmtId) -> Span {
+    pub fn statement_span(&self, stmt_id: StmtId) -> Span {
         self.id_location(stmt_id).span
     }
 
+    pub fn statement_location(&self, stmt_id: StmtId) -> Location {
+        self.id_location(stmt_id)
+    }
+
+    pub fn push_statement_location(&mut self, id: StmtId, span: Span, file: FileId) {
+        self.id_to_location.insert(id.into(), Location::new(span, file));
+    }
+
     pub fn get_struct(&self, id: StructId) -> Shared<StructType> {
         self.structs[&id].clone()
     }
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 603193d1593..858e5c4838c 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -540,7 +540,7 @@ where
                 StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
             }),
         )))
-        .map(|statement| StatementKind::Comptime(Box::new(statement)))
+        .map(|statement| StatementKind::CompTime(Box::new(statement)))
 }
 
 /// Comptime in an expression position only accepts entire blocks
@@ -548,7 +548,7 @@ fn comptime_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
 where
     S: NoirParser<StatementKind> + 'a,
 {
-    keyword(Keyword::CompTime).ignore_then(block(statement)).map(ExpressionKind::Block)
+    keyword(Keyword::CompTime).ignore_then(block(statement)).map(ExpressionKind::Comptime)
 }
 
 fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 31bf2245b1f..ac3d7bbc4cc 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -780,7 +780,7 @@ mod test {
                 HirStatement::Error => panic!("Invalid HirStatement!"),
                 HirStatement::Break => panic!("Unexpected break"),
                 HirStatement::Continue => panic!("Unexpected continue"),
-                HirStatement::Comptime(_) => panic!("Unexpected comptime"),
+                HirStatement::CompTime(_) => panic!("Unexpected comptime"),
             };
             let expr = interner.expression(&expr_id);
 
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index e4616c99aaa..6b7dca6c5c7 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -159,6 +159,9 @@ pub(crate) fn rewrite(
         }
         ExpressionKind::Lambda(_) | ExpressionKind::Variable(_) => visitor.slice(span).to_string(),
         ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
+        ExpressionKind::Comptime(block) => {
+            format!("comptime {}", rewrite_block(visitor, block, span))
+        }
         ExpressionKind::Error => unreachable!(),
     }
 }
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index e41827c94a1..869977d5f3c 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -103,7 +103,7 @@ impl super::FmtVisitor<'_> {
             StatementKind::Error => unreachable!(),
             StatementKind::Break => self.push_rewrite("break;".into(), span),
             StatementKind::Continue => self.push_rewrite("continue;".into(), span),
-            StatementKind::Comptime(statement) => self.visit_stmt(*statement, span, is_last),
+            StatementKind::CompTime(statement) => self.visit_stmt(*statement, span, is_last),
         }
     }
 }

From 6a661388c6bbb1018a51b45325e741bdf0bb3635 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 23 Apr 2024 13:39:42 -0500
Subject: [PATCH 213/416] chore(experimental): Improve variable not defined
 error message in comptime interpreter (#4889)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Slightly improves the error message for when a variable in the
interpreter isn't found.

Since all ids are already given by name resolution, the only time one
cannot be found is if it is not a comptime variable, so I've narrowed
the error message a bit.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/statement.rs  |  8 +++---
 .../noirc_frontend/src/hir/comptime/errors.rs |  4 +--
 .../src/hir/comptime/hir_to_ast.rs            |  4 +--
 .../src/hir/comptime/interpreter.rs           | 28 ++++++++-----------
 .../noirc_frontend/src/hir/comptime/scan.rs   | 10 +++----
 .../noirc_frontend/src/hir/comptime/value.rs  |  1 -
 .../src/hir/resolution/resolver.rs            |  4 +--
 .../noirc_frontend/src/hir/type_check/stmt.rs |  2 +-
 compiler/noirc_frontend/src/hir_def/stmt.rs   |  2 +-
 compiler/noirc_frontend/src/lexer/token.rs    |  6 ++--
 .../src/monomorphization/mod.rs               |  2 +-
 .../noirc_frontend/src/noir_parser.lalrpop    |  2 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  8 +++---
 .../noirc_frontend/src/parser/parser/types.rs |  2 +-
 compiler/noirc_frontend/src/tests.rs          |  2 +-
 tooling/nargo_fmt/src/visitor/stmt.rs         |  2 +-
 16 files changed, 40 insertions(+), 47 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index f37c7adc983..1831a046f5b 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -40,7 +40,7 @@ pub enum StatementKind {
     Break,
     Continue,
     /// This statement should be executed at compile-time
-    CompTime(Box<StatementKind>),
+    Comptime(Box<StatementKind>),
     // This is an expression with a trailing semi-colon
     Semi(Expression),
     // This statement is the result of a recovered parse error.
@@ -87,10 +87,10 @@ impl StatementKind {
                 }
                 self
             }
-            StatementKind::CompTime(mut statement) => {
+            StatementKind::Comptime(mut statement) => {
                 *statement =
                     statement.add_semicolon(semi, span, last_statement_in_block, emit_error);
-                StatementKind::CompTime(statement)
+                StatementKind::Comptime(statement)
             }
             // A semicolon on a for loop is optional and does nothing
             StatementKind::For(_) => self,
@@ -685,7 +685,7 @@ impl Display for StatementKind {
             StatementKind::For(for_loop) => for_loop.fmt(f),
             StatementKind::Break => write!(f, "break"),
             StatementKind::Continue => write!(f, "continue"),
-            StatementKind::CompTime(statement) => write!(f, "comptime {statement}"),
+            StatementKind::Comptime(statement) => write!(f, "comptime {statement}"),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
             StatementKind::Error => write!(f, "Error"),
         }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index d3db7fcaee9..67d9a006b22 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -1,4 +1,4 @@
-use crate::{node_interner::DefinitionId, Type};
+use crate::Type;
 use acvm::FieldElement;
 use noirc_errors::Location;
 
@@ -9,7 +9,7 @@ use super::value::Value;
 pub enum InterpreterError {
     ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
     TypeMismatch { expected: Type, value: Value, location: Location },
-    NoValueForId { id: DefinitionId, location: Location },
+    NonComptimeVarReferenced { name: String, location: Location },
     IntegerOutOfRangeForType { value: FieldElement, typ: Type, location: Location },
     ErrorNodeEncountered { location: Location },
     NonFunctionCalled { value: Value, location: Location },
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
index dd23edf0004..42ee76d29fa 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -66,8 +66,8 @@ impl StmtId {
             HirStatement::Expression(expr) => StatementKind::Expression(expr.to_ast(interner)),
             HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
             HirStatement::Error => StatementKind::Error,
-            HirStatement::CompTime(statement) => {
-                StatementKind::CompTime(Box::new(statement.to_ast(interner).kind))
+            HirStatement::Comptime(statement) => {
+                StatementKind::Comptime(Box::new(statement.to_ast(interner).kind))
             }
         };
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index c6d508a581e..c01c985a40c 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -246,13 +246,7 @@ impl<'a> Interpreter<'a> {
         location: Location,
     ) -> IResult<()> {
         self.type_check(typ, &argument, location)?;
-        for scope in self.scopes.iter_mut().rev() {
-            if let Entry::Occupied(mut entry) = scope.entry(id) {
-                entry.insert(argument);
-                return Ok(());
-            }
-        }
-        Err(InterpreterError::NoValueForId { id, location })
+        self.mutate(id, argument, location)
     }
 
     /// Mutate an existing variable, potentially from a prior scope
@@ -263,17 +257,12 @@ impl<'a> Interpreter<'a> {
                 return Ok(());
             }
         }
-        Err(InterpreterError::NoValueForId { id, location })
+        let name = self.interner.definition(id).name.clone();
+        Err(InterpreterError::NonComptimeVarReferenced { name, location })
     }
 
     fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
-        for scope in self.scopes.iter().rev() {
-            if let Some(value) = scope.get(&ident.id) {
-                return Ok(value.clone());
-            }
-        }
-
-        Err(InterpreterError::NoValueForId { id: ident.id, location: ident.location })
+        self.lookup_id(ident.id, ident.location)
     }
 
     fn lookup_id(&self, id: DefinitionId, location: Location) -> IResult<Value> {
@@ -283,7 +272,12 @@ impl<'a> Interpreter<'a> {
             }
         }
 
-        Err(InterpreterError::NoValueForId { id, location })
+        // Justification for `NonComptimeVarReferenced`:
+        // If we have an id to lookup at all that means name resolution successfully
+        // found another variable in scope for this name. If the name is in scope
+        // but unknown by the interpreter it must be because it was not a comptime variable.
+        let name = self.interner.definition(id).name.clone();
+        Err(InterpreterError::NonComptimeVarReferenced { name, location })
     }
 
     fn type_check(&self, typ: &Type, value: &Value, location: Location) -> IResult<()> {
@@ -1023,7 +1017,7 @@ impl<'a> Interpreter<'a> {
             HirStatement::Break => self.evaluate_break(statement),
             HirStatement::Continue => self.evaluate_continue(statement),
             HirStatement::Expression(expression) => self.evaluate(expression),
-            HirStatement::CompTime(statement) => self.evaluate_comptime(statement),
+            HirStatement::Comptime(statement) => self.evaluate_comptime(statement),
             HirStatement::Semi(expression) => {
                 self.evaluate(expression)?;
                 Ok(Value::Unit)
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index d4fa355627f..2e13daea527 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -1,15 +1,15 @@
 //! This module is for the scanning of the Hir by the interpreter.
-//! In this initial step, the Hir is scanned for `CompTime` nodes
+//! In this initial step, the Hir is scanned for `Comptime` nodes
 //! without actually executing anything until such a node is found.
 //! Once such a node is found, the interpreter will call the relevant
 //! evaluate method on that node type, insert the result into the Ast,
 //! and continue scanning the rest of the program.
 //!
-//! Since it mostly just needs to recur on the Hir looking for CompTime
+//! Since it mostly just needs to recur on the Hir looking for Comptime
 //! nodes, this pass is fairly simple. The only thing it really needs to
 //! ensure to do is to push and pop scopes on the interpreter as needed
 //! so that any variables defined within e.g. an `if` statement containing
-//! a `CompTime` block aren't accessible outside of the `if`.
+//! a `Comptime` block aren't accessible outside of the `if`.
 use crate::{
     hir_def::{
         expr::{
@@ -30,7 +30,7 @@ use super::{
 
 #[allow(dead_code)]
 impl<'interner> Interpreter<'interner> {
-    /// Scan through a function, evaluating any CompTime nodes found.
+    /// Scan through a function, evaluating any Comptime nodes found.
     /// These nodes will be modified in place, replaced with the
     /// result of their evaluation.
     pub fn scan_function(&mut self, function: FuncId) -> IResult<()> {
@@ -185,7 +185,7 @@ impl<'interner> Interpreter<'interner> {
             HirStatement::Expression(expression) => self.scan_expression(expression),
             HirStatement::Semi(semi) => self.scan_expression(semi),
             HirStatement::Error => Ok(()),
-            HirStatement::CompTime(comptime) => {
+            HirStatement::Comptime(comptime) => {
                 let location = self.interner.statement_location(comptime);
                 let new_expr =
                     self.evaluate_comptime(comptime)?.into_expression(self.interner, location)?;
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 89102344b09..d7af4643192 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -16,7 +16,6 @@ use rustc_hash::FxHashMap as HashMap;
 
 use super::errors::{IResult, InterpreterError};
 
-#[allow(unused)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Value {
     Unit,
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 8d2cb17189b..8e29f8f9fce 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1272,9 +1272,9 @@ impl<'a> Resolver<'a> {
                 HirStatement::Continue
             }
             StatementKind::Error => HirStatement::Error,
-            StatementKind::CompTime(statement) => {
+            StatementKind::Comptime(statement) => {
                 let statement = self.resolve_stmt(*statement, span);
-                HirStatement::CompTime(self.interner.push_stmt(statement))
+                HirStatement::Comptime(self.interner.push_stmt(statement))
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index 064fefc8ae9..f5f6e1e8180 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -51,7 +51,7 @@ impl<'interner> TypeChecker<'interner> {
             HirStatement::Constrain(constrain_stmt) => self.check_constrain_stmt(constrain_stmt),
             HirStatement::Assign(assign_stmt) => self.check_assign_stmt(assign_stmt, stmt_id),
             HirStatement::For(for_loop) => self.check_for_loop(for_loop),
-            HirStatement::CompTime(statement) => return self.check_statement(&statement),
+            HirStatement::Comptime(statement) => return self.check_statement(&statement),
             HirStatement::Break | HirStatement::Continue | HirStatement::Error => (),
         }
         Type::Unit
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 48e7d7344e3..7e22e5ee9c0 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -20,7 +20,7 @@ pub enum HirStatement {
     Continue,
     Expression(ExprId),
     Semi(ExprId),
-    CompTime(StmtId),
+    Comptime(StmtId),
     Error,
 }
 
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index ec513d55299..0242fc7e7ff 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -811,7 +811,7 @@ pub enum Keyword {
     Break,
     CallData,
     Char,
-    CompTime,
+    Comptime,
     Constrain,
     Continue,
     Contract,
@@ -856,7 +856,7 @@ impl fmt::Display for Keyword {
             Keyword::Break => write!(f, "break"),
             Keyword::Char => write!(f, "char"),
             Keyword::CallData => write!(f, "call_data"),
-            Keyword::CompTime => write!(f, "comptime"),
+            Keyword::Comptime => write!(f, "comptime"),
             Keyword::Constrain => write!(f, "constrain"),
             Keyword::Continue => write!(f, "continue"),
             Keyword::Contract => write!(f, "contract"),
@@ -904,7 +904,7 @@ impl Keyword {
             "break" => Keyword::Break,
             "call_data" => Keyword::CallData,
             "char" => Keyword::Char,
-            "comptime" => Keyword::CompTime,
+            "comptime" => Keyword::Comptime,
             "constrain" => Keyword::Constrain,
             "continue" => Keyword::Continue,
             "contract" => Keyword::Contract,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index d92b6c65d7a..b130af9d125 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -632,7 +632,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirStatement::Error => unreachable!(),
 
             // All `comptime` statements & expressions should be removed before runtime.
-            HirStatement::CompTime(_) => unreachable!("comptime statement in runtime code"),
+            HirStatement::Comptime(_) => unreachable!("comptime statement in runtime code"),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/noir_parser.lalrpop b/compiler/noirc_frontend/src/noir_parser.lalrpop
index ec2b4c8ab46..9acb5ef8b58 100644
--- a/compiler/noirc_frontend/src/noir_parser.lalrpop
+++ b/compiler/noirc_frontend/src/noir_parser.lalrpop
@@ -61,7 +61,7 @@ extern {
         "break" => BorrowedToken::Keyword(noir_token::Keyword::Break),
         "call_data" => BorrowedToken::Keyword(noir_token::Keyword::CallData),
         "char" => BorrowedToken::Keyword(noir_token::Keyword::Char),
-        "comptime" => BorrowedToken::Keyword(noir_token::Keyword::CompTime),
+        "comptime" => BorrowedToken::Keyword(noir_token::Keyword::Comptime),
         "constrain" => BorrowedToken::Keyword(noir_token::Keyword::Constrain),
         "continue" => BorrowedToken::Keyword(noir_token::Keyword::Continue),
         "contract" => BorrowedToken::Keyword(noir_token::Keyword::Contract),
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 858e5c4838c..6e9f3969297 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -532,7 +532,7 @@ where
     P2: ExprParser + 'a,
     S: NoirParser<StatementKind> + 'a,
 {
-    keyword(Keyword::CompTime)
+    keyword(Keyword::Comptime)
         .ignore_then(choice((
             declaration(expr),
             for_loop(expr_no_constructors, statement.clone()),
@@ -540,7 +540,7 @@ where
                 StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
             }),
         )))
-        .map(|statement| StatementKind::CompTime(Box::new(statement)))
+        .map(|statement| StatementKind::Comptime(Box::new(statement)))
 }
 
 /// Comptime in an expression position only accepts entire blocks
@@ -548,7 +548,7 @@ fn comptime_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
 where
     S: NoirParser<StatementKind> + 'a,
 {
-    keyword(Keyword::CompTime).ignore_then(block(statement)).map(ExpressionKind::Comptime)
+    keyword(Keyword::Comptime).ignore_then(block(statement)).map(ExpressionKind::Comptime)
 }
 
 fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
@@ -733,7 +733,7 @@ fn optional_distinctness() -> impl NoirParser<Distinctness> {
 }
 
 fn maybe_comp_time() -> impl NoirParser<bool> {
-    keyword(Keyword::CompTime).or_not().validate(|opt, span, emit| {
+    keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
         if opt.is_some() {
             emit(ParserError::with_reason(
                 ParserErrorReason::ExperimentalFeature("comptime"),
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index d8a63d161b9..82dd3dad681 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -12,7 +12,7 @@ use chumsky::prelude::*;
 use noirc_errors::Span;
 
 fn maybe_comp_time() -> impl NoirParser<()> {
-    keyword(Keyword::CompTime).or_not().validate(|opt, span, emit| {
+    keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
         if opt.is_some() {
             emit(ParserError::with_reason(ParserErrorReason::ComptimeDeprecated, span));
         }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index ac3d7bbc4cc..31bf2245b1f 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -780,7 +780,7 @@ mod test {
                 HirStatement::Error => panic!("Invalid HirStatement!"),
                 HirStatement::Break => panic!("Unexpected break"),
                 HirStatement::Continue => panic!("Unexpected continue"),
-                HirStatement::CompTime(_) => panic!("Unexpected comptime"),
+                HirStatement::Comptime(_) => panic!("Unexpected comptime"),
             };
             let expr = interner.expression(&expr_id);
 
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index 869977d5f3c..e41827c94a1 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -103,7 +103,7 @@ impl super::FmtVisitor<'_> {
             StatementKind::Error => unreachable!(),
             StatementKind::Break => self.push_rewrite("break;".into(), span),
             StatementKind::Continue => self.push_rewrite("continue;".into(), span),
-            StatementKind::CompTime(statement) => self.visit_stmt(*statement, span, is_last),
+            StatementKind::Comptime(statement) => self.visit_stmt(*statement, span, is_last),
         }
     }
 }

From f267d4205b46317eacb1c247c9dca0e7698d1259 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 23 Apr 2024 14:42:41 -0500
Subject: [PATCH 214/416] fix(experimental): Skip over comptime functions in
 scan pass (#4893)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4892

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/comptime/scan.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index 2e13daea527..50c8ccb4557 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -34,6 +34,12 @@ impl<'interner> Interpreter<'interner> {
     /// These nodes will be modified in place, replaced with the
     /// result of their evaluation.
     pub fn scan_function(&mut self, function: FuncId) -> IResult<()> {
+        // Don't scan through functions that are already comptime. They may use comptime-only
+        // features (most likely HirExpression::Quote) that we'd otherwise error for.
+        if self.interner.function_modifiers(&function).is_comptime {
+            return Ok(());
+        }
+
         let function = self.interner.function(&function);
 
         let state = self.enter_function();

From 50bc32587a837c930ed14175c98ace1530c54bef Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 23 Apr 2024 21:03:38 +0100
Subject: [PATCH 215/416] fix: Reset the noir-gates-diff report on master
 (#4878)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

Opened this PR to test
https://github.com/TomAFrench/noir-gates-diff/pull/3 after seeing this
https://github.com/noir-lang/noir/pull/4848#issuecomment-2070241529

## Summary\*

The noir-gates-diff report became malformed on master as "main" was used
as the program name for each program in `execution_success`. This PR
references the last commit in this PR
https://github.com/TomAFrench/noir-gates-diff/pull/3. That PR changes to
using the correct name for each program in `execution_success` but also
resets the report on `master` by comparing against a harcoded reference.
That is why it is expected to see a massive gate diff report on this PR.
The follow-up will revert the changes to accurately check against the
reference.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/gates_report.yml    | 4 ++--
 tooling/nargo_cli/src/cli/info_cmd.rs | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index e694e5fad04..71ebd342613 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -71,10 +71,10 @@ jobs:
         run: |
           ./gates_report.sh
           mv gates_report.json ../gates_report.json
-       
+      
       - name: Compare gates reports
         id: gates_diff
-        uses: vezenovm/noir-gates-diff@f80ea702d579873ff80f0261c62e2bae5203748e
+        uses: vezenovm/noir-gates-diff@45e9c9a21deb236fa7f38138b42b33ddaf7c0985
         with:
           report: gates_report.json
           summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 67825362f92..3695fb57d31 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -228,7 +228,7 @@ struct InfoReport {
 
 #[derive(Debug, Serialize)]
 struct ProgramInfo {
-    name: String,
+    package_name: String,
     #[serde(skip)]
     expression_width: ExpressionWidth,
     functions: Vec<FunctionInfo>,
@@ -238,7 +238,7 @@ impl From<ProgramInfo> for Vec<Row> {
     fn from(program_info: ProgramInfo) -> Self {
         vecmap(program_info.functions, |function| {
             row![
-                Fm->format!("{}", program_info.name),
+                Fm->format!("{}", program_info.package_name),
                 Fc->format!("{}", function.name),
                 format!("{:?}", program_info.expression_width),
                 Fc->format!("{}", function.acir_opcodes),
@@ -302,7 +302,7 @@ fn count_opcodes_and_gates_in_program(
         })
         .collect::<Result<_, _>>()?;
 
-    Ok(ProgramInfo { name: package.name.to_string(), expression_width, functions })
+    Ok(ProgramInfo { package_name: package.name.to_string(), expression_width, functions })
 }
 
 fn count_opcodes_and_gates_in_contract(

From 4a3ffb7b4c5cdd5fcadb19e7f251b1ee27b0c02b Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 23 Apr 2024 21:26:23 +0100
Subject: [PATCH 216/416] fix: Update noir-gates-diff commit to use master
 reference report (#4891)

# Description

## Problem\*

Further context can be found in
https://github.com/noir-lang/noir/pull/4878

## Summary\*

This PR updates the commit to reference
https://github.com/vezenovm/noir-gates-diff/pull/2 which actually checks
the report on master. We need the preceding PR in order to fix the
reference report to use the actual package names in `execution_success`.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/gates_report.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index 71ebd342613..ba4cb600c59 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -74,7 +74,7 @@ jobs:
       
       - name: Compare gates reports
         id: gates_diff
-        uses: vezenovm/noir-gates-diff@45e9c9a21deb236fa7f38138b42b33ddaf7c0985
+        uses: vezenovm/noir-gates-diff@acf12797860f237117e15c0d6e08d64253af52b6
         with:
           report: gates_report.json
           summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)

From 3ca6d2175f9e7405c8c35605c3b0f06abaf7acf5 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 24 Apr 2024 13:43:55 +0100
Subject: [PATCH 217/416] chore: bump `rustls` to v0.21.11 (#4895)

Copy of https://github.com/noir-lang/noir/pull/4854 but without
dependabot.
---
 .github/actions/install-playwright/action.yml |  5 +-
 .github/workflows/test-js-packages.yml        |  2 +-
 Cargo.lock                                    | 56 ++++++++++++++-----
 3 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/.github/actions/install-playwright/action.yml b/.github/actions/install-playwright/action.yml
index be835a422cc..a70c45d152a 100644
--- a/.github/actions/install-playwright/action.yml
+++ b/.github/actions/install-playwright/action.yml
@@ -19,5 +19,8 @@ runs:
     - name: Install playwright deps
       shell: bash
       if: steps.playwright-cache.outputs.cache-hit != 'true'
-      run: ./.github/scripts/playwright-install.sh
+      run: |
+        # Workaround: https://github.com/microsoft/playwright/issues/30503#issuecomment-2074783821
+        sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+        ./.github/scripts/playwright-install.sh
 
diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index 7fd198d9a89..e6098dd269c 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -188,7 +188,7 @@ jobs:
         uses: ./.github/actions/setup
 
       - name: Install Playwright
-        run: ./.github/scripts/playwright-install.sh
+        uses: ./.github/actions/install-playwright
 
       - name: Run browser tests
         run: yarn workspace @noir-lang/acvm_js test:browser
diff --git a/Cargo.lock b/Cargo.lock
index 35702c8df03..9c9e13b57c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -782,9 +782,12 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
 
 [[package]]
 name = "cfg-if"
@@ -4089,12 +4092,27 @@ dependencies = [
  "cc",
  "libc",
  "once_cell",
- "spin",
- "untrusted",
+ "spin 0.5.2",
+ "untrusted 0.7.1",
  "web-sys",
  "winapi",
 ]
 
+[[package]]
+name = "ring"
+version = "0.17.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+dependencies = [
+ "cc",
+ "cfg-if 1.0.0",
+ "getrandom 0.2.10",
+ "libc",
+ "spin 0.9.8",
+ "untrusted 0.9.0",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "rkyv"
 version = "0.7.42"
@@ -4194,12 +4212,12 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.21.7"
+version = "0.21.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8"
+checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
 dependencies = [
  "log",
- "ring",
+ "ring 0.17.8",
  "rustls-webpki",
  "sct",
 ]
@@ -4215,12 +4233,12 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.4"
+version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -4361,8 +4379,8 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.16.20",
+ "untrusted 0.7.1",
 ]
 
 [[package]]
@@ -4696,6 +4714,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
 
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
 [[package]]
 name = "spki"
 version = "0.6.0"
@@ -5341,6 +5365,12 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
 [[package]]
 name = "url"
 version = "1.7.2"

From 5985e4285de9e29f7c986103a49fdaec59228887 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 24 Apr 2024 15:14:51 +0200
Subject: [PATCH 218/416] fix: fix curve parameters for bigints (#4900)

# Description

## Problem\*

Resolves #4882

## Summary\*
There were typos in bigint templates and also in curve modulus
definitions


## Additional Context
I don't understand how there could be so many typos, I thought I was
being cautious... I triple checked all the parameters this time!


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/bigint.nr                     | 86 +++++++++----------
 .../execution_success/bigint/src/main.nr      | 20 ++++-
 2 files changed, 60 insertions(+), 46 deletions(-)

diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index ee9f8e44625..81dad968bf7 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -3,16 +3,14 @@ use crate::cmp::Eq;
 
 global bn254_fq = &[0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
                     0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
-global bn254_fr = &[0x01, 0x00, 0x00, 0x00, 0x3F, 0x59, 0x1F, 0x43, 0x09, 0x97, 0xB9, 0x79, 0x48, 0xE8, 0x33, 0x28, 
-                    0x5D, 0x58, 0x81, 0x81, 0xB6, 0x45, 0x50, 0xB8, 0x29, 0xA0, 0x31, 0xE1, 0x72, 0x4E, 0x64, 0x30];
+global bn254_fr = &[1, 0, 0, 240, 147, 245, 225, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48];
 global secpk1_fr = &[0x41, 0x41, 0x36, 0xD0, 0x8C, 0x5E, 0xD2, 0xBF, 0x3B, 0xA0, 0x48, 0xAF, 0xE6, 0xDC, 0xAE, 0xBA,
                      0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
 global secpk1_fq = &[0x2F, 0xFC, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
 global secpr1_fq = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpr1_fr = &[0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3, 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC,
-                           0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,0xFF, 0xFF, 0xFF, 0xFF];
+global secpr1_fr = &[81, 37, 99, 252, 194, 202, 185, 243, 132, 158, 23, 167, 173, 250, 230, 188, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255];
 // docs:start:big_int_definition
 struct BigInt {
     pointer: u32,
@@ -149,8 +147,8 @@ impl BigField for Secpk1Fr {
 
 impl Add for Secpk1Fr { 
     fn add(self: Self, other: Secpk1Fr) -> Secpk1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fr);
         Secpk1Fr {
            array: a.bigint_add(b).to_le_bytes()
         }
@@ -158,8 +156,8 @@ impl Add for Secpk1Fr {
 }
 impl Sub for Secpk1Fr { 
     fn sub(self: Self, other: Secpk1Fr) -> Secpk1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fr);
         Secpk1Fr {
            array: a.bigint_sub(b).to_le_bytes()
         }
@@ -167,8 +165,8 @@ impl Sub for Secpk1Fr {
 }
 impl Mul for Secpk1Fr { 
     fn mul(self: Self, other: Secpk1Fr) -> Secpk1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fr);
         Secpk1Fr {
            array: a.bigint_mul(b).to_le_bytes()
         }
@@ -176,8 +174,8 @@ impl Mul for Secpk1Fr {
 }
 impl Div for Secpk1Fr { 
     fn div(self: Self, other: Secpk1Fr) -> Secpk1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fr);
         Secpk1Fr {
            array: a.bigint_div(b).to_le_bytes()
         }
@@ -218,8 +216,8 @@ impl BigField for Bn254Fr {
 
 impl Add for Bn254Fr { 
     fn add(self: Self, other: Bn254Fr) -> Bn254Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fr);
         Bn254Fr {
            array: a.bigint_add(b).to_le_bytes()
         }
@@ -227,8 +225,8 @@ impl Add for Bn254Fr {
 }
 impl Sub for Bn254Fr { 
     fn sub(self: Self, other: Bn254Fr) -> Bn254Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fr);
         Bn254Fr {
            array: a.bigint_sub(b).to_le_bytes()
         }
@@ -236,8 +234,8 @@ impl Sub for Bn254Fr {
 }
 impl Mul for Bn254Fr { 
     fn mul(self: Self, other: Bn254Fr) -> Bn254Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fr);
         Bn254Fr {
            array: a.bigint_mul(b).to_le_bytes()
         }
@@ -245,8 +243,8 @@ impl Mul for Bn254Fr {
 }
 impl Div for Bn254Fr { 
     fn div(self: Self, other: Bn254Fr) -> Bn254Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fr);
         Bn254Fr {
            array: a.bigint_div(b).to_le_bytes()
         }
@@ -287,8 +285,8 @@ impl BigField for Bn254Fq {
 
 impl Add for Bn254Fq { 
     fn add(self: Self, other: Bn254Fq) -> Bn254Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fq);
         Bn254Fq {
            array: a.bigint_add(b).to_le_bytes()
         }
@@ -296,8 +294,8 @@ impl Add for Bn254Fq {
 }
 impl Sub for Bn254Fq { 
     fn sub(self: Self, other: Bn254Fq) -> Bn254Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fq);
         Bn254Fq {
            array: a.bigint_sub(b).to_le_bytes()
         }
@@ -305,8 +303,8 @@ impl Sub for Bn254Fq {
 }
 impl Mul for Bn254Fq { 
     fn mul(self: Self, other: Bn254Fq) -> Bn254Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fq);
         Bn254Fq {
            array: a.bigint_mul(b).to_le_bytes()
         }
@@ -314,8 +312,8 @@ impl Mul for Bn254Fq {
 }
 impl Div for Bn254Fq { 
     fn div(self: Self, other: Bn254Fq) -> Bn254Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), bn254_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), bn254_fq);
         Bn254Fq {
            array: a.bigint_div(b).to_le_bytes()
         }
@@ -356,8 +354,8 @@ impl BigField for Secpr1Fq {
 
 impl Add for Secpr1Fq { 
     fn add(self: Self, other: Secpr1Fq) -> Secpr1Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fq);
         Secpr1Fq {
            array: a.bigint_add(b).to_le_bytes()
         }
@@ -365,8 +363,8 @@ impl Add for Secpr1Fq {
 }
 impl Sub for Secpr1Fq { 
     fn sub(self: Self, other: Secpr1Fq) -> Secpr1Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fq);
         Secpr1Fq {
            array: a.bigint_sub(b).to_le_bytes()
         }
@@ -374,8 +372,8 @@ impl Sub for Secpr1Fq {
 }
 impl Mul for Secpr1Fq { 
     fn mul(self: Self, other: Secpr1Fq) -> Secpr1Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fq);
         Secpr1Fq {
            array: a.bigint_mul(b).to_le_bytes()
         }
@@ -383,8 +381,8 @@ impl Mul for Secpr1Fq {
 }
 impl Div for Secpr1Fq { 
     fn div(self: Self, other: Secpr1Fq) -> Secpr1Fq {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fq);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fq);
         Secpr1Fq {
            array: a.bigint_div(b).to_le_bytes()
         }
@@ -425,8 +423,8 @@ impl BigField for Secpr1Fr {
 
 impl Add for Secpr1Fr { 
     fn add(self: Self, other: Secpr1Fr) -> Secpr1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fr);
         Secpr1Fr {
            array: a.bigint_add(b).to_le_bytes()
         }
@@ -434,8 +432,8 @@ impl Add for Secpr1Fr {
 }
 impl Sub for Secpr1Fr { 
     fn sub(self: Self, other: Secpr1Fr) -> Secpr1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fr);
         Secpr1Fr {
            array: a.bigint_sub(b).to_le_bytes()
         }
@@ -443,8 +441,8 @@ impl Sub for Secpr1Fr {
 }
 impl Mul for Secpr1Fr { 
     fn mul(self: Self, other: Secpr1Fr) -> Secpr1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fr);
         Secpr1Fr {
            array: a.bigint_mul(b).to_le_bytes()
         }
@@ -452,8 +450,8 @@ impl Mul for Secpr1Fr {
 }
 impl Div for Secpr1Fr { 
     fn div(self: Self, other: Secpr1Fr) -> Secpr1Fr {
-        let a = BigInt::from_le_bytes(self.array.as_slice(), secpk1_fq);
-        let b = BigInt::from_le_bytes(other.array.as_slice(), secpk1_fq);
+        let a = BigInt::from_le_bytes(self.array.as_slice(), secpr1_fr);
+        let b = BigInt::from_le_bytes(other.array.as_slice(), secpr1_fr);
         Secpr1Fr {
            array: a.bigint_div(b).to_le_bytes()
         }
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 5645e4e9e1b..c454c2b66cd 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -13,7 +13,7 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let a_field = dep::std::field::bytes32_to_field(a_be_bytes);
     let b_field = dep::std::field::bytes32_to_field(b_be_bytes);
 
-    // Regression for #4682
+    // Regression for issue #4682
     let c = if x[0] != 0 {
         test_unconstrained1(a, b)
     } else {
@@ -27,7 +27,7 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
         assert(a_bytes[i] == x[i]);
         assert(b_bytes[i] == y[i]);
     }
-    //Regression for issue #4578
+    // Regression for issue #4578
     let d = a * b;
     assert(d / b == a);
 
@@ -40,6 +40,22 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let d1 = bigint::Secpk1Fq::from_le_bytes_32(result);
     assert(d1 == d);
     big_int_example(x[0], x[1]);
+
+    // Regression for issue #4882
+    let num_b:[u8;32] = [
+        0, 0, 0, 240, 147, 245, 225, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48
+    ];
+    let num2_b:[u8;7] = [126, 193, 45, 39, 188, 84, 11];
+    let num = bigint::Bn254Fr::from_le_bytes(num_b.as_slice());
+    let num2 = bigint::Bn254Fr::from_le_bytes(num2_b.as_slice());
+
+    let ret_b:[u8;32] = [
+        131, 62, 210, 200, 215, 160, 214, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48
+    ];
+    let ret = bigint::Bn254Fr::from_le_bytes(ret_b.as_slice());
+    assert(ret == num.mul(num2));
+    let div = num.div(num2);
+    assert(div.mul(num2) == num);
 }
 
 fn test_unconstrained1(a: Secpk1Fq, b: Secpk1Fq) -> Secpk1Fq {

From 1b867b121fba5db3087ca845b4934e6732b23fd1 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 24 Apr 2024 16:30:31 +0100
Subject: [PATCH 219/416] feat: Sync from aztec-packages (#4902)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5999)
refactor: using poseidon2 when computing a nullifier
(https://github.com/AztecProtocol/aztec-packages/pull/5906)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5955)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5935)
chore: redo typo PR by dockercui
(https://github.com/AztecProtocol/aztec-packages/pull/5930)
chore: Improve `compute_note_hash_and_nullifier` autogeneration and
`NoteProcessor` warnings
(https://github.com/AztecProtocol/aztec-packages/pull/5838)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .aztec-sync-commit                            |  2 +-
 .github/actions/install-playwright/action.yml | 22 ++---
 acvm-repo/acvm_js/build.sh                    |  4 +-
 aztec_macros/src/lib.rs                       | 13 +--
 .../compute_note_hash_and_nullifier.rs        | 94 ++++++++++++++++---
 aztec_macros/src/transforms/functions.rs      | 19 ++--
 aztec_macros/src/transforms/note_interface.rs |  6 +-
 aztec_macros/src/transforms/storage.rs        | 60 ++++--------
 aztec_macros/src/utils/hir_utils.rs           | 79 ++++++++++++++++
 tooling/nargo/src/ops/execute.rs              |  2 +-
 tooling/noirc_abi_wasm/build.sh               |  1 +
 11 files changed, 213 insertions(+), 89 deletions(-)

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 1cb130e7c58..a159698f8a8 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-beab8c93857536e07fa37994213fc664a5864013
+2e64428af9525bd8c390931061505f7b48d729a4
diff --git a/.github/actions/install-playwright/action.yml b/.github/actions/install-playwright/action.yml
index a70c45d152a..0bd61b38c49 100644
--- a/.github/actions/install-playwright/action.yml
+++ b/.github/actions/install-playwright/action.yml
@@ -4,21 +4,21 @@ description: Installs Playwright and its dependencies and caches them.
 runs:
   using: composite
   steps:
-    - name: Query playwright version
-      shell: bash
-      run: echo "PLAYWRIGHT_VERSION=$(yarn workspace @noir-lang/noirc_abi info @web/test-runner-playwright --json | jq .children.Version | tr -d '"')" >> $GITHUB_ENV
+    # - name: Query playwright version
+    #   shell: bash
+    #   run: echo "PLAYWRIGHT_VERSION=$(yarn workspace @noir-lang/noirc_abi info @web/test-runner-playwright --json | jq .children.Version | tr -d '"')" >> $GITHUB_ENV
 
-    - name: Cache playwright binaries
-      uses: actions/cache@v4
-      id: playwright-cache
-      with:
-        path: |
-          ~/.cache/ms-playwright
-        key: ${{ runner.os }}-playwright-${{ env.PLAYWRIGHT_VERSION }}
+    # - name: Cache playwright binaries
+    #   uses: actions/cache@v4
+    #   id: playwright-cache
+    #   with:
+    #     path: |
+    #       ~/.cache/ms-playwright
+    #     key: ${{ runner.os }}-playwright-${{ env.PLAYWRIGHT_VERSION }}
 
     - name: Install playwright deps
       shell: bash
-      if: steps.playwright-cache.outputs.cache-hit != 'true'
+      # if: steps.playwright-cache.outputs.cache-hit != 'true'
       run: |
         # Workaround: https://github.com/microsoft/playwright/issues/30503#issuecomment-2074783821
         sudo rm /etc/apt/sources.list.d/microsoft-prod.list
diff --git a/acvm-repo/acvm_js/build.sh b/acvm-repo/acvm_js/build.sh
index 4486a214c9c..16fb26e55db 100755
--- a/acvm-repo/acvm_js/build.sh
+++ b/acvm-repo/acvm_js/build.sh
@@ -49,5 +49,5 @@ BROWSER_WASM=${BROWSER_DIR}/${pname}_bg.wasm
 run_or_fail cargo build --lib --release --target $TARGET --package ${pname}
 run_or_fail wasm-bindgen $WASM_BINARY --out-dir $NODE_DIR --typescript --target nodejs
 run_or_fail wasm-bindgen $WASM_BINARY --out-dir $BROWSER_DIR --typescript --target web
-run_or_fail wasm-opt $NODE_WASM -o $NODE_WASM -O
-run_or_fail wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
+run_if_available wasm-opt $NODE_WASM -o $NODE_WASM -O
+run_if_available wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index dff3193a327..17ae999fb8f 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -93,17 +93,18 @@ fn transform_module(
     // Check for a user defined storage struct
 
     let maybe_storage_struct_name = check_for_storage_definition(module)?;
+
     let storage_defined = maybe_storage_struct_name.is_some();
 
-    if let Some(storage_struct_name) = maybe_storage_struct_name {
-        if !check_for_storage_implementation(module, &storage_struct_name) {
-            generate_storage_implementation(module, &storage_struct_name)?;
+    if let Some(ref storage_struct_name) = maybe_storage_struct_name {
+        if !check_for_storage_implementation(module, storage_struct_name) {
+            generate_storage_implementation(module, storage_struct_name)?;
         }
         // Make sure we're only generating the storage layout for the root crate
         // In case we got a contract importing other contracts for their interface, we
         // don't want to generate the storage layout for them
         if crate_id == context.root_crate_id() {
-            generate_storage_layout(module, storage_struct_name)?;
+            generate_storage_layout(module, storage_struct_name.clone())?;
         }
     }
 
@@ -164,14 +165,14 @@ fn transform_module(
             transform_function(
                 fn_type,
                 func,
-                storage_defined,
+                maybe_storage_struct_name.clone(),
                 is_initializer,
                 insert_init_check,
                 is_internal,
             )?;
             has_transformed_module = true;
         } else if storage_defined && func.def.is_unconstrained {
-            transform_unconstrained(func);
+            transform_unconstrained(func, maybe_storage_struct_name.clone().unwrap());
             has_transformed_module = true;
         }
     }
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index 70d05e5c59e..f624cde9969 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -8,7 +8,10 @@ use noirc_frontend::{
 
 use crate::utils::{
     errors::AztecMacroError,
-    hir_utils::{collect_crate_functions, fetch_notes, get_contract_module_data, inject_fn},
+    hir_utils::{
+        collect_crate_functions, collect_traits, fetch_notes, get_contract_module_data,
+        get_global_numberic_const, get_serialized_length, inject_fn,
+    },
 };
 
 // Check if "compute_note_hash_and_nullifier(AztecAddress,Field,Field,Field,[Field; N]) -> [Field; 4]" is defined
@@ -60,13 +63,68 @@ pub fn inject_compute_note_hash_and_nullifier(
             return Ok(());
         }
 
+        let traits: Vec<_> = collect_traits(context);
+
+        // Get MAX_NOTE_FIELDS_LENGTH global to check if the notes in our contract are too long.
+        let max_note_length_const = get_global_numberic_const(context, "MAX_NOTE_FIELDS_LENGTH")
+            .map_err(|err| {
+                (
+                    AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                        secondary_message: Some(err.primary_message),
+                    },
+                    file_id,
+                )
+            })?;
+
         // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
-        // contract might use. These are the types that are marked as #[aztec(note)].
+        // contract might use and their serialized lengths. These are the types that are marked as #[aztec(note)].
+        let mut notes_and_lengths = vec![];
+
+        for (path, typ) in fetch_notes(context) {
+            let serialized_len: u128 = get_serialized_length(
+                &traits,
+                "NoteInterface",
+                &Type::Struct(typ.clone(), vec![]),
+                &context.def_interner,
+            )
+            .map_err(|_err| {
+                (
+                    AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                        secondary_message: Some(format!(
+                            "Failed to get serialized length for note type {}",
+                            path
+                        )),
+                    },
+                    file_id,
+                )
+            })?
+            .into();
+
+            if serialized_len > max_note_length_const {
+                return Err((
+                   AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                        secondary_message: Some(format!(
+                            "Note type {} as {} fields, which is more than the maximum allowed length of {}.",
+                            path,
+                            serialized_len,
+                            max_note_length_const
+                        )),
+                    },
+                    file_id,
+                ));
+            }
+
+            notes_and_lengths.push((path.to_string(), serialized_len));
+        }
+
+        let max_note_length: u128 =
+            *notes_and_lengths.iter().map(|(_, serialized_len)| serialized_len).max().unwrap_or(&0);
+
         let note_types =
-            fetch_notes(context).iter().map(|(path, _)| path.to_string()).collect::<Vec<_>>();
+            notes_and_lengths.iter().map(|(note_type, _)| note_type.clone()).collect::<Vec<_>>();
 
         // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
-        let func = generate_compute_note_hash_and_nullifier(&note_types);
+        let func = generate_compute_note_hash_and_nullifier(&note_types, max_note_length);
 
         // And inject the newly created function into the contract.
 
@@ -86,8 +144,12 @@ pub fn inject_compute_note_hash_and_nullifier(
     Ok(())
 }
 
-fn generate_compute_note_hash_and_nullifier(note_types: &[String]) -> NoirFunction {
-    let function_source = generate_compute_note_hash_and_nullifier_source(note_types);
+fn generate_compute_note_hash_and_nullifier(
+    note_types: &[String],
+    max_note_length: u128,
+) -> NoirFunction {
+    let function_source =
+        generate_compute_note_hash_and_nullifier_source(note_types, max_note_length);
 
     let (function_ast, errors) = parse_program(&function_source);
     if !errors.is_empty() {
@@ -99,25 +161,30 @@ fn generate_compute_note_hash_and_nullifier(note_types: &[String]) -> NoirFuncti
     function_ast.functions.remove(0)
 }
 
-fn generate_compute_note_hash_and_nullifier_source(note_types: &[String]) -> String {
+fn generate_compute_note_hash_and_nullifier_source(
+    note_types: &[String],
+    max_note_length: u128,
+) -> String {
     // TODO(#4649): The serialized_note parameter is a fixed-size array, but we don't know what length it should have.
     // For now we hardcode it to 20, which is the same as MAX_NOTE_FIELDS_LENGTH.
 
     if note_types.is_empty() {
         // Even if the contract does not include any notes, other parts of the stack expect for this function to exist,
         // so we include a dummy version.
-        "
+        format!(
+            "
         unconstrained fn compute_note_hash_and_nullifier(
             contract_address: dep::aztec::protocol_types::address::AztecAddress,
             nonce: Field,
             storage_slot: Field,
             note_type_id: Field,
-            serialized_note: [Field; 20]
-        ) -> pub [Field; 4] {
+            serialized_note: [Field; {}]
+        ) -> pub [Field; 4] {{
             assert(false, \"This contract does not use private notes\");
             [0, 0, 0, 0]
-        }"
-        .to_string()
+        }}",
+            max_note_length
+        )
     } else {
         // For contracts that include notes we do a simple if-else chain comparing note_type_id with the different
         // get_note_type_id of each of the note types.
@@ -142,12 +209,13 @@ fn generate_compute_note_hash_and_nullifier_source(note_types: &[String]) -> Str
                 nonce: Field,
                 storage_slot: Field,
                 note_type_id: Field,
-                serialized_note: [Field; 20]
+                serialized_note: [Field; {}]
             ) -> pub [Field; 4] {{
                 let note_header = dep::aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
 
                 {}
             }}",
+            max_note_length,
             full_if_statement
         )
     }
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index dd7a416b941..24cad05b866 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -29,7 +29,7 @@ use crate::{
 pub fn transform_function(
     ty: &str,
     func: &mut NoirFunction,
-    storage_defined: bool,
+    storage_struct_name: Option<String>,
     is_initializer: bool,
     insert_init_check: bool,
     is_internal: bool,
@@ -57,8 +57,8 @@ pub fn transform_function(
     }
 
     // Add access to the storage struct
-    if storage_defined {
-        let storage_def = abstract_storage(&ty.to_lowercase(), false);
+    if let Some(storage_struct_name) = storage_struct_name {
+        let storage_def = abstract_storage(storage_struct_name, &ty.to_lowercase(), false);
         func.def.body.statements.insert(0, storage_def);
     }
 
@@ -209,8 +209,11 @@ pub fn export_fn_abi(
 /// ```
 ///
 /// This will allow developers to access their contract' storage struct in unconstrained functions
-pub fn transform_unconstrained(func: &mut NoirFunction) {
-    func.def.body.statements.insert(0, abstract_storage("Unconstrained", true));
+pub fn transform_unconstrained(func: &mut NoirFunction, storage_struct_name: String) {
+    func.def
+        .body
+        .statements
+        .insert(0, abstract_storage(storage_struct_name, "Unconstrained", true));
 }
 
 /// Helper function that returns what the private context would look like in the ast
@@ -575,7 +578,7 @@ fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>,
 /// unconstrained fn lol() {
 ///   let storage = Storage::init(Context::none());
 /// }
-fn abstract_storage(typ: &str, unconstrained: bool) -> Statement {
+fn abstract_storage(storage_struct_name: String, typ: &str, unconstrained: bool) -> Statement {
     let init_context_call = if unconstrained {
         call(
             variable_path(chained_dep!("aztec", "context", "Context", "none")), // Path
@@ -591,8 +594,8 @@ fn abstract_storage(typ: &str, unconstrained: bool) -> Statement {
     assignment(
         "storage", // Assigned to
         call(
-            variable_path(chained_path!("Storage", "init")), // Path
-            vec![init_context_call],                         // args
+            variable_path(chained_path!(storage_struct_name.as_str(), "init")), // Path
+            vec![init_context_call],                                            // args
         ),
     )
 }
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index 70db1ebd336..f183c69b27a 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -418,8 +418,7 @@ fn generate_note_properties_fn(
 
 // Automatically generate the method to compute the note's content hash as:
 // fn compute_note_content_hash(self: NoteType) -> Field {
-//    // TODO(#1205) Should use a non-zero generator index.
-//    dep::aztec::hash::pedersen_hash(self.serialize_content(), 0)
+//    dep::aztec::hash::pedersen_hash(self.serialize_content(), dep::aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_CONTENT_HASH)
 // }
 //
 fn generate_compute_note_content_hash(
@@ -429,8 +428,7 @@ fn generate_compute_note_content_hash(
     let function_source = format!(
         "
         fn compute_note_content_hash(self: {}) -> Field {{
-            // TODO(#1205) Should use a non-zero generator index.
-            dep::aztec::hash::pedersen_hash(self.serialize_content(), 0)
+            dep::aztec::hash::pedersen_hash(self.serialize_content(), dep::aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_CONTENT_HASH)
         }}
         ",
         note_type
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 49fcee9fe29..1e3cc011715 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -1,5 +1,3 @@
-use std::borrow::Borrow;
-
 use noirc_errors::Span;
 use noirc_frontend::ast::{
     BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
@@ -10,7 +8,7 @@ use noirc_frontend::{
     macros_api::{
         FieldElement, FileId, HirContext, HirExpression, HirLiteral, HirStatement, NodeInterner,
     },
-    node_interner::{TraitId, TraitImplKind},
+    node_interner::TraitId,
     parse_program,
     parser::SortedModule,
     token::SecondaryAttribute,
@@ -25,7 +23,9 @@ use crate::{
             make_type, pattern, return_type, variable, variable_path,
         },
         errors::AztecMacroError,
-        hir_utils::{collect_crate_structs, collect_traits, get_contract_module_data},
+        hir_utils::{
+            collect_crate_structs, collect_traits, get_contract_module_data, get_serialized_length,
+        },
     },
 };
 
@@ -198,7 +198,7 @@ pub fn generate_storage_implementation(
 }
 
 /// Obtains the serialized length of a type that implements the Serialize trait.
-fn get_serialized_length(
+pub fn get_storage_serialized_length(
     traits: &[TraitId],
     typ: &Type,
     interner: &NodeInterner,
@@ -216,48 +216,22 @@ fn get_serialized_length(
             secondary_message: Some("State storage variable must be generic".to_string()),
         })?;
 
-    let is_note = traits.iter().any(|&trait_id| {
-        let r#trait = interner.get_trait(trait_id);
-        r#trait.name.0.contents == "NoteInterface"
-            && !interner.lookup_all_trait_implementations(stored_in_state, trait_id).is_empty()
-    });
+    let is_note = match stored_in_state {
+        Type::Struct(typ, _) => interner
+            .struct_attributes(&typ.borrow().id)
+            .iter()
+            .any(|attr| is_custom_attribute(attr, "aztec(note)")),
+        _ => false,
+    };
 
     // Maps and (private) Notes always occupy a single slot. Someone could store a Note in PublicMutable for whatever reason though.
     if struct_name == "Map" || (is_note && struct_name != "PublicMutable") {
         return Ok(1);
     }
 
-    let serialized_trait_impl_kind = traits
-        .iter()
-        .find_map(|&trait_id| {
-            let r#trait = interner.get_trait(trait_id);
-            if r#trait.borrow().name.0.contents == "Serialize"
-                && r#trait.borrow().generics.len() == 1
-            {
-                interner
-                    .lookup_all_trait_implementations(stored_in_state, trait_id)
-                    .into_iter()
-                    .next()
-            } else {
-                None
-            }
-        })
-        .ok_or(AztecMacroError::CouldNotAssignStorageSlots {
-            secondary_message: Some("Stored data must implement Serialize trait".to_string()),
-        })?;
-
-    let serialized_trait_impl_id = match serialized_trait_impl_kind {
-        TraitImplKind::Normal(trait_impl_id) => Ok(trait_impl_id),
-        _ => Err(AztecMacroError::CouldNotAssignStorageSlots { secondary_message: None }),
-    }?;
-
-    let serialized_trait_impl_shared = interner.get_trait_implementation(*serialized_trait_impl_id);
-    let serialized_trait_impl = serialized_trait_impl_shared.borrow();
-
-    match serialized_trait_impl.trait_generics.first().unwrap() {
-        Type::Constant(value) => Ok(*value),
-        _ => Err(AztecMacroError::CouldNotAssignStorageSlots { secondary_message: None }),
-    }
+    get_serialized_length(traits, "Serialize", stored_in_state, interner).map_err(|err| {
+        AztecMacroError::CouldNotAssignStorageSlots { secondary_message: Some(err.primary_message) }
+    })
 }
 
 /// Assigns storage slots to the storage struct fields based on the serialized length of the types. This automatic assignment
@@ -438,7 +412,7 @@ pub fn assign_storage_slots(
                 };
 
                 let type_serialized_len =
-                    get_serialized_length(&traits, field_type, &context.def_interner)
+                    get_storage_serialized_length(&traits, field_type, &context.def_interner)
                         .map_err(|err| (err, file_id))?;
 
                 context.def_interner.update_expression(new_call_expression.arguments[1], |expr| {
@@ -506,7 +480,7 @@ pub fn generate_storage_layout(
     let (struct_ast, errors) = parse_program(&storage_fields_source);
     if !errors.is_empty() {
         dbg!(errors);
-        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+        return Err(AztecMacroError::CouldNotExportStorageLayout {
             secondary_message: Some("Failed to parse Noir macro code (struct StorageLayout). This is either a bug in the compiler or the Noir macro code".to_string()),
             span: None
         });
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index cafa6ed38ca..3801ff1cc75 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -1,6 +1,8 @@
 use iter_extended::vecmap;
 use noirc_errors::Location;
 use noirc_frontend::ast;
+use noirc_frontend::macros_api::{HirExpression, HirLiteral};
+use noirc_frontend::node_interner::{NodeInterner, TraitImplKind};
 use noirc_frontend::{
     graph::CrateId,
     hir::{
@@ -310,3 +312,80 @@ fn find_non_contract_dependencies_bfs(
                 })
         })
 }
+
+pub fn get_serialized_length(
+    traits: &[TraitId],
+    trait_name: &str,
+    typ: &Type,
+    interner: &NodeInterner,
+) -> Result<u64, MacroError> {
+    let serialized_trait_impl_kind = traits
+        .iter()
+        .find_map(|&trait_id| {
+            let r#trait = interner.get_trait(trait_id);
+            if r#trait.name.0.contents == trait_name && r#trait.generics.len() == 1 {
+                interner.lookup_all_trait_implementations(typ, trait_id).into_iter().next()
+            } else {
+                None
+            }
+        })
+        .ok_or(MacroError {
+            primary_message: format!("Type {} must implement {} trait", typ, trait_name),
+            secondary_message: None,
+            span: None,
+        })?;
+
+    let serialized_trait_impl_id = match serialized_trait_impl_kind {
+        TraitImplKind::Normal(trait_impl_id) => Ok(trait_impl_id),
+        _ => Err(MacroError {
+            primary_message: format!("{} trait impl for {} must not be assumed", trait_name, typ),
+            secondary_message: None,
+            span: None,
+        }),
+    }?;
+
+    let serialized_trait_impl_shared = interner.get_trait_implementation(*serialized_trait_impl_id);
+    let serialized_trait_impl = serialized_trait_impl_shared.borrow();
+
+    match serialized_trait_impl.trait_generics.first().unwrap() {
+        Type::Constant(value) => Ok(*value),
+        _ => Err(MacroError {
+            primary_message: format!("{} length for {} must be a constant", trait_name, typ),
+            secondary_message: None,
+            span: None,
+        }),
+    }
+}
+
+pub fn get_global_numberic_const(
+    context: &HirContext,
+    const_name: &str,
+) -> Result<u128, MacroError> {
+    context
+        .def_interner
+        .get_all_globals()
+        .iter()
+        .find_map(|global_info| {
+            if global_info.ident.0.contents == const_name {
+                let stmt = context.def_interner.get_global_let_statement(global_info.id);
+                if let Some(let_stmt) = stmt {
+                    let expression = context.def_interner.expression(&let_stmt.expression);
+                    match expression {
+                        HirExpression::Literal(HirLiteral::Integer(value, _)) => {
+                            Some(value.to_u128())
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        })
+        .ok_or(MacroError {
+            primary_message: format!("Could not find {} global constant", const_name),
+            secondary_message: None,
+            span: None,
+        })
+}
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 97584aff150..34755d14ed2 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -106,7 +106,7 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                     return Err(NargoError::ExecutionError(match call_stack {
                         Some(call_stack) => {
                             // First check whether we have a runtime assertion message that should be resolved on an ACVM failure
-                            // If we do not have a runtime assertion message, we check wether the error is a brillig error with a user-defined message,
+                            // If we do not have a runtime assertion message, we check whether the error is a brillig error with a user-defined message,
                             // and finally we should check whether the circuit has any hardcoded messages associated with a specific `OpcodeLocation`.
                             // Otherwise return the provided opcode resolution error.
                             if let Some(assert_message) = assert_message {
diff --git a/tooling/noirc_abi_wasm/build.sh b/tooling/noirc_abi_wasm/build.sh
index 58724dee02c..16fb26e55db 100755
--- a/tooling/noirc_abi_wasm/build.sh
+++ b/tooling/noirc_abi_wasm/build.sh
@@ -25,6 +25,7 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
+require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')

From 7dfa151da95c7ca9e1aaa752347b62f9fafe2c2c Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Wed, 24 Apr 2024 17:14:34 +0100
Subject: [PATCH 220/416] chore: Release Noir(0.28.0) (#4776)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.28.0</summary>

## [0.28.0](https://github.com/noir-lang/noir/compare/v0.27.0...v0.28.0)
(2024-04-24)


### ⚠ BREAKING CHANGES

* Add `as_array` and remove `_slice` variants of hash functions
([#4675](https://github.com/noir-lang/noir/issues/4675))
* reserve keyword `super`
([#4836](https://github.com/noir-lang/noir/issues/4836))
* contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
* change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
* trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
* remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
* storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
* contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)

### Features

* **acir_gen:** Brillig stdlib
([#4848](https://github.com/noir-lang/noir/issues/4848))
([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Add `min` and `max` functions to the stdlib
([#4839](https://github.com/noir-lang/noir/issues/4839))
([6cfb328](https://github.com/noir-lang/noir/commit/6cfb328d0d162eaa20ad1a118d085e03a52d049d))
* Add `NARGO_FOREIGN_CALL_TIMEOUT` environment variable
([#4780](https://github.com/noir-lang/noir/issues/4780))
([791f1c8](https://github.com/noir-lang/noir/commit/791f1c8522d49972dad4eb940f9cad437e28b25b))
* Add comptime Interpreter
([#4821](https://github.com/noir-lang/noir/issues/4821))
([5992436](https://github.com/noir-lang/noir/commit/599243633281e6827f0f4f095fb12d313e0125fa))
* Add return values to aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/5389)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Allow numeric generics to non inlined ACIR functions
([#4834](https://github.com/noir-lang/noir/issues/4834))
([9cc03a4](https://github.com/noir-lang/noir/commit/9cc03a4d6f714a1b2d31c6982eb8e791ba5c869c))
* **avm:** Integrate AVM with initializers
(https://github.com/AztecProtocol/aztec-packages/pull/5469)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Brillig heterogeneous memory cells
(https://github.com/AztecProtocol/aztec-packages/pull/5608)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Brillig pointer codegen and execution
(https://github.com/AztecProtocol/aztec-packages/pull/5737)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **experimental:** Add `comptime` keyword
([#4840](https://github.com/noir-lang/noir/issues/4840))
([4dfd7f0](https://github.com/noir-lang/noir/commit/4dfd7f03bc1b9cf57f5829c435a560bed53b7f46))
* Get last mock oracles params
([#4789](https://github.com/noir-lang/noir/issues/4789))
([1d96937](https://github.com/noir-lang/noir/commit/1d96937a8e94a91c0c17c97102498d067fca76c3))
* Impl of missing functionality in new key store
(https://github.com/AztecProtocol/aztec-packages/pull/5750)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Implement `Eq` trait on `BoundedVec`
([#4830](https://github.com/noir-lang/noir/issues/4830))
([6cefe16](https://github.com/noir-lang/noir/commit/6cefe16deb643951c0cc552d08e22272900ed456))
* Lalrpop lexer prototype
([#4656](https://github.com/noir-lang/noir/issues/4656))
([25ad018](https://github.com/noir-lang/noir/commit/25ad018a55b61dd861e899f050c48200f0a00430))
* **nargo:** Handle call stacks for multiple Acir calls
([#4711](https://github.com/noir-lang/noir/issues/4711))
([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
* Narrow ABI encoding errors down to target problem argument/field
([#4798](https://github.com/noir-lang/noir/issues/4798))
([e412e6e](https://github.com/noir-lang/noir/commit/e412e6e30910472b9d5f9000370ce5138ad39ce7))
* Proving the rollup circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5599)
([5b352d6](https://github.com/noir-lang/noir/commit/5b352d6266c40522f5626f79d2f36a409b482aaa))
* Reserve keyword `super`
([#4836](https://github.com/noir-lang/noir/issues/4836))
([d5028a6](https://github.com/noir-lang/noir/commit/d5028a613e5a65ad1286dd20ce0fb0313f19f6ee))
* Restore hashing args via slice for performance
(https://github.com/AztecProtocol/aztec-packages/pull/5539)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Simplify `BoundedVec::eq`
([#4838](https://github.com/noir-lang/noir/issues/4838))
([3d33a33](https://github.com/noir-lang/noir/commit/3d33a33e74c3e7d0fc511059b07f0ef9ddd9b667))
* **simulator:** Fetch return values at circuit execution
(https://github.com/AztecProtocol/aztec-packages/pull/5642)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Split `backend_barretenburg` into prover and verifier classes
([#4769](https://github.com/noir-lang/noir/issues/4769))
([ce1e662](https://github.com/noir-lang/noir/commit/ce1e6624ece3c91f06b0273af9ba88e703c1b589))
* Storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5572)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5619)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5697)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5725)
([5b352d6](https://github.com/noir-lang/noir/commit/5b352d6266c40522f5626f79d2f36a409b482aaa))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5794)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5814)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5935)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5955)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5999)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Unroll loops iteratively
([#4779](https://github.com/noir-lang/noir/issues/4779))
([f831b0b](https://github.com/noir-lang/noir/commit/f831b0bdbf99cab1bcd24d494c4546a36309465e))
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Variable length returns
(https://github.com/AztecProtocol/aztec-packages/pull/5633)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))


### Bug Fixes

* ArrayGet and Set are not pure
([#4783](https://github.com/noir-lang/noir/issues/4783))
([90ee479](https://github.com/noir-lang/noir/commit/90ee4792c8e7115e55a3b1dadd1e43066ad8ac66))
* Avoid huge unrolling in hash_args
(https://github.com/AztecProtocol/aztec-packages/pull/5703)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Catch panics from EC point creation (e.g. the point is at infinity)
([#4790](https://github.com/noir-lang/noir/issues/4790))
([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
* Don't reuse brillig with slice arguments
(https://github.com/AztecProtocol/aztec-packages/pull/5800)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* **experimental:** Skip over comptime functions in scan pass
([#4893](https://github.com/noir-lang/noir/issues/4893))
([f267d42](https://github.com/noir-lang/noir/commit/f267d4205b46317eacb1c247c9dca0e7698d1259))
* Fix curve parameters for bigints
([#4900](https://github.com/noir-lang/noir/issues/4900))
([5985e42](https://github.com/noir-lang/noir/commit/5985e4285de9e29f7c986103a49fdaec59228887))
* Fix panic when returning a zeroed unit value
([#4797](https://github.com/noir-lang/noir/issues/4797))
([2ea9292](https://github.com/noir-lang/noir/commit/2ea92926956658ea99d8fb97734831eba00d3a4b))
* Issue 4682 and add solver for unconstrained bigintegers
([#4729](https://github.com/noir-lang/noir/issues/4729))
([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
* Primary_message typo in errors.rs
(https://github.com/AztecProtocol/aztec-packages/pull/5646)
([5b352d6](https://github.com/noir-lang/noir/commit/5b352d6266c40522f5626f79d2f36a409b482aaa))
* Proper field inversion for bigints
([#4802](https://github.com/noir-lang/noir/issues/4802))
([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
* Reset the noir-gates-diff report on master
([#4878](https://github.com/noir-lang/noir/issues/4878))
([50bc325](https://github.com/noir-lang/noir/commit/50bc32587a837c930ed14175c98ace1530c54bef))
* Update noir-gates-diff commit to use master reference report
([#4891](https://github.com/noir-lang/noir/issues/4891))
([4a3ffb7](https://github.com/noir-lang/noir/commit/4a3ffb7b4c5cdd5fcadb19e7f251b1ee27b0c02b))


### Miscellaneous Chores

* Add `as_array` and remove `_slice` variants of hash functions
([#4675](https://github.com/noir-lang/noir/issues/4675))
([8e39706](https://github.com/noir-lang/noir/commit/8e39706cbb51f27b42fbe851aaa6a67070d07c74))
* Remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
</details>

<details><summary>0.44.0</summary>

## [0.44.0](https://github.com/noir-lang/noir/compare/v0.43.0...v0.44.0)
(2024-04-24)


### ⚠ BREAKING CHANGES

* contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
* change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
* trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
* remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
* storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
* contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))

### Features

* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir_gen:** Brillig stdlib
([#4848](https://github.com/noir-lang/noir/issues/4848))
([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
* **acir_gen:** Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **acvm_js:** Execute program
([#4694](https://github.com/noir-lang/noir/issues/4694))
([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
* **acvm:** Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add return values to aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/5389)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Add support for overriding expression width
([#4117](https://github.com/noir-lang/noir/issues/4117))
([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **avm:** Integrate AVM with initializers
(https://github.com/AztecProtocol/aztec-packages/pull/5469)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
* Brillig heterogeneous memory cells
(https://github.com/AztecProtocol/aztec-packages/pull/5608)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Brillig pointer codegen and execution
(https://github.com/AztecProtocol/aztec-packages/pull/5737)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
* Change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Impl of missing functionality in new key store
(https://github.com/AztecProtocol/aztec-packages/pull/5750)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* **nargo:** Handle call stacks for multiple Acir calls
([#4711](https://github.com/noir-lang/noir/issues/4711))
([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove range constraints from witnesses which are constrained to be
constants ([#3928](https://github.com/noir-lang/noir/issues/3928))
([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
* Remove replacement of boolean range opcodes with `AssertZero` opcodes
([#4107](https://github.com/noir-lang/noir/issues/4107))
([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
* Restore hashing args via slice for performance
(https://github.com/AztecProtocol/aztec-packages/pull/5539)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **simulator:** Fetch return values at circuit execution
(https://github.com/AztecProtocol/aztec-packages/pull/5642)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync `aztec-packages`
([#4011](https://github.com/noir-lang/noir/issues/4011))
([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
* Sync commits from `aztec-packages`
([#4068](https://github.com/noir-lang/noir/issues/4068))
([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5572)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5619)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5697)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5794)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5814)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5935)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5955)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5999)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Variable length returns
(https://github.com/AztecProtocol/aztec-packages/pull/5633)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))


### Bug Fixes

* **acvm:** Mark outputs of Opcode::Call solvable
([#4708](https://github.com/noir-lang/noir/issues/4708))
([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
* Avoid huge unrolling in hash_args
(https://github.com/AztecProtocol/aztec-packages/pull/5703)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Catch panics from EC point creation (e.g. the point is at infinity)
([#4790](https://github.com/noir-lang/noir/issues/4790))
([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
* Don't reuse brillig with slice arguments
(https://github.com/AztecProtocol/aztec-packages/pull/5800)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Issue 4682 and add solver for unconstrained bigintegers
([#4729](https://github.com/noir-lang/noir/issues/4729))
([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Proper field inversion for bigints
([#4802](https://github.com/noir-lang/noir/issues/4802))
([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
* Remove panic from `init_log_level` in `acvm_js`
([#4195](https://github.com/noir-lang/noir/issues/4195))
([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
* Return error rather instead of panicking on invalid circuit
([#3976](https://github.com/noir-lang/noir/issues/3976))
([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).
---
 .release-please-manifest.json                 |   4 +-
 CHANGELOG.md                                  |  83 +++
 Cargo.lock                                    |  54 +-
 Cargo.toml                                    |  16 +-
 acvm-repo/CHANGELOG.md                        | 119 ++++
 acvm-repo/acir/Cargo.toml                     |   2 +-
 acvm-repo/acir_field/Cargo.toml               |   2 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm_js/Cargo.toml                  |   2 +-
 acvm-repo/acvm_js/package.json                |   2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   2 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   2 +-
 acvm-repo/brillig_vm/Cargo.toml               |   2 +-
 compiler/wasm/package.json                    |   2 +-
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 142 +++++
 .../hello_noir/project_breakdown.md           | 199 ++++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 102 ++++
 .../getting_started/tooling/noir_codegen.md   | 113 ++++
 .../version-v0.28.0/how_to/_category_.json    |   5 +
 .../how_to/debugger/_category_.json           |   6 +
 .../debugger/debugging_with_the_repl.md       | 164 +++++
 .../how_to/debugger/debugging_with_vs_code.md |  68 +++
 .../version-v0.28.0/how_to/how-to-oracles.md  | 276 +++++++++
 .../how_to/how-to-recursion.md                | 179 ++++++
 .../how_to/how-to-solidity-verifier.md        | 231 +++++++
 .../version-v0.28.0/how_to/merkle-proof.mdx   |  49 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.28.0/index.mdx |  67 ++
 .../version-v0.28.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.28.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.28.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  77 +++
 .../version-v0.28.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 251 ++++++++
 .../noir/concepts/data_types/booleans.md      |  31 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 155 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 195 ++++++
 .../noir/concepts/data_types/strings.md       |  80 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../version-v0.28.0/noir/concepts/distinct.md |  64 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.28.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.28.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.28.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.28.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.28.0/noir/concepts/oracles.md  |  31 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.28.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  99 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  42 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/bigint.md           | 122 ++++
 .../noir/standard_library/black_box_fns.md    |  31 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 326 ++++++++++
 .../standard_library/containers/hashmap.md    | 570 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 151 +++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  98 +++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../cryptographic_primitives/hashes.mdx       | 250 ++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/scalar.mdx       |  33 +
 .../cryptographic_primitives/schnorr.mdx      |  64 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  88 +++
 .../noir/standard_library/traits.md           | 410 +++++++++++++
 .../noir/standard_library/zeroed.md           |  26 +
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 160 +++++
 .../classes/BarretenbergVerifier.md           |  58 ++
 .../NoirJS/backend_barretenberg/index.md      |  59 ++
 .../type-aliases/BackendOptions.md            |  21 +
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  | 132 ++++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +
 .../functions/ecdsa_secp256k1_verify.md       |  28 +
 .../functions/ecdsa_secp256r1_verify.md       |  28 +
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +
 .../NoirJS/noir_js/functions/sha256.md        |  21 +
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +
 .../reference/NoirJS/noir_js/index.md         |  54 ++
 .../type-aliases/ForeignCallHandler.md        |  24 +
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 +
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 +
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 +
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 ++
 .../noir_wasm/functions/compile_contract.md   |  51 ++
 .../noir_wasm/functions/createFileManager.md  |  21 +
 .../functions/inflateDebugSymbols.md          |  21 +
 .../reference/NoirJS/noir_wasm/index.md       |  49 ++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 .../version-v0.28.0/reference/_category_.json |   5 +
 .../reference/debugger/_category_.json        |   6 +
 .../debugger/debugger_known_limitations.md    |  59 ++
 .../reference/debugger/debugger_repl.md       | 360 +++++++++++
 .../reference/debugger/debugger_vscode.md     |  82 +++
 .../reference/nargo_commands.md               | 381 ++++++++++++
 .../version-v0.28.0/tooling/debugger.md       |  27 +
 .../tooling/language_server.md                |  43 ++
 .../version-v0.28.0/tooling/testing.md        |  62 ++
 .../version-v0.28.0/tutorials/noirjs_app.md   | 326 ++++++++++
 .../version-v0.28.0-sidebars.json             |  93 +++
 tooling/noir_codegen/package.json             |   2 +-
 tooling/noir_js/package.json                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noir_js_types/package.json            |   2 +-
 tooling/noirc_abi_wasm/package.json           |   2 +-
 135 files changed, 10357 insertions(+), 52 deletions(-)
 create mode 100644 docs/versioned_docs/version-v0.28.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/getting_started/tooling/noir_codegen.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_the_repl.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_vs_code.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/distinct.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/bigint.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/scalar.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_known_limitations.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_repl.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_vscode.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/tooling/debugger.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.28.0-sidebars.json

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 7579928c999..e20b12e68ef 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.27.0",
-  "acvm-repo": "0.43.0"
+  ".": "0.28.0",
+  "acvm-repo": "0.44.0"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a084811fc21..148ecfac876 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,88 @@
 # Changelog
 
+## [0.28.0](https://github.com/noir-lang/noir/compare/v0.27.0...v0.28.0) (2024-04-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* Add `as_array` and remove `_slice` variants of hash functions ([#4675](https://github.com/noir-lang/noir/issues/4675))
+* reserve keyword `super` ([#4836](https://github.com/noir-lang/noir/issues/4836))
+* contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687)
+* change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374)
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620)
+* trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732)
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709)
+* remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617)
+* storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387)
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616)
+* contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386)
+
+### Features
+
+* **acir_gen:** Brillig stdlib ([#4848](https://github.com/noir-lang/noir/issues/4848)) ([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Add `min` and `max` functions to the stdlib ([#4839](https://github.com/noir-lang/noir/issues/4839)) ([6cfb328](https://github.com/noir-lang/noir/commit/6cfb328d0d162eaa20ad1a118d085e03a52d049d))
+* Add `NARGO_FOREIGN_CALL_TIMEOUT` environment variable ([#4780](https://github.com/noir-lang/noir/issues/4780)) ([791f1c8](https://github.com/noir-lang/noir/commit/791f1c8522d49972dad4eb940f9cad437e28b25b))
+* Add comptime Interpreter ([#4821](https://github.com/noir-lang/noir/issues/4821)) ([5992436](https://github.com/noir-lang/noir/commit/599243633281e6827f0f4f095fb12d313e0125fa))
+* Add return values to aztec fns (https://github.com/AztecProtocol/aztec-packages/pull/5389) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Allow numeric generics to non inlined ACIR functions ([#4834](https://github.com/noir-lang/noir/issues/4834)) ([9cc03a4](https://github.com/noir-lang/noir/commit/9cc03a4d6f714a1b2d31c6982eb8e791ba5c869c))
+* **avm:** Integrate AVM with initializers (https://github.com/AztecProtocol/aztec-packages/pull/5469) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Brillig heterogeneous memory cells (https://github.com/AztecProtocol/aztec-packages/pull/5608) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Brillig pointer codegen and execution (https://github.com/AztecProtocol/aztec-packages/pull/5737) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **experimental:** Add `comptime` keyword ([#4840](https://github.com/noir-lang/noir/issues/4840)) ([4dfd7f0](https://github.com/noir-lang/noir/commit/4dfd7f03bc1b9cf57f5829c435a560bed53b7f46))
+* Get last mock oracles params ([#4789](https://github.com/noir-lang/noir/issues/4789)) ([1d96937](https://github.com/noir-lang/noir/commit/1d96937a8e94a91c0c17c97102498d067fca76c3))
+* Impl of missing functionality in new key store (https://github.com/AztecProtocol/aztec-packages/pull/5750) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Implement `Eq` trait on `BoundedVec` ([#4830](https://github.com/noir-lang/noir/issues/4830)) ([6cefe16](https://github.com/noir-lang/noir/commit/6cefe16deb643951c0cc552d08e22272900ed456))
+* Lalrpop lexer prototype ([#4656](https://github.com/noir-lang/noir/issues/4656)) ([25ad018](https://github.com/noir-lang/noir/commit/25ad018a55b61dd861e899f050c48200f0a00430))
+* **nargo:** Handle call stacks for multiple Acir calls ([#4711](https://github.com/noir-lang/noir/issues/4711)) ([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
+* Narrow ABI encoding errors down to target problem argument/field ([#4798](https://github.com/noir-lang/noir/issues/4798)) ([e412e6e](https://github.com/noir-lang/noir/commit/e412e6e30910472b9d5f9000370ce5138ad39ce7))
+* Proving the rollup circuits (https://github.com/AztecProtocol/aztec-packages/pull/5599) ([5b352d6](https://github.com/noir-lang/noir/commit/5b352d6266c40522f5626f79d2f36a409b482aaa))
+* Reserve keyword `super` ([#4836](https://github.com/noir-lang/noir/issues/4836)) ([d5028a6](https://github.com/noir-lang/noir/commit/d5028a613e5a65ad1286dd20ce0fb0313f19f6ee))
+* Restore hashing args via slice for performance (https://github.com/AztecProtocol/aztec-packages/pull/5539) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Simplify `BoundedVec::eq` ([#4838](https://github.com/noir-lang/noir/issues/4838)) ([3d33a33](https://github.com/noir-lang/noir/commit/3d33a33e74c3e7d0fc511059b07f0ef9ddd9b667))
+* **simulator:** Fetch return values at circuit execution (https://github.com/AztecProtocol/aztec-packages/pull/5642) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Split `backend_barretenburg` into prover and verifier classes ([#4769](https://github.com/noir-lang/noir/issues/4769)) ([ce1e662](https://github.com/noir-lang/noir/commit/ce1e6624ece3c91f06b0273af9ba88e703c1b589))
+* Storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5572) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5619) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5697) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5725) ([5b352d6](https://github.com/noir-lang/noir/commit/5b352d6266c40522f5626f79d2f36a409b482aaa))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5794) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5814) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5935) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5955) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5999) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Unroll loops iteratively ([#4779](https://github.com/noir-lang/noir/issues/4779)) ([f831b0b](https://github.com/noir-lang/noir/commit/f831b0bdbf99cab1bcd24d494c4546a36309465e))
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Variable length returns (https://github.com/AztecProtocol/aztec-packages/pull/5633) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+
+
+### Bug Fixes
+
+* ArrayGet and Set are not pure ([#4783](https://github.com/noir-lang/noir/issues/4783)) ([90ee479](https://github.com/noir-lang/noir/commit/90ee4792c8e7115e55a3b1dadd1e43066ad8ac66))
+* Avoid huge unrolling in hash_args (https://github.com/AztecProtocol/aztec-packages/pull/5703) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Catch panics from EC point creation (e.g. the point is at infinity) ([#4790](https://github.com/noir-lang/noir/issues/4790)) ([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
+* Don't reuse brillig with slice arguments (https://github.com/AztecProtocol/aztec-packages/pull/5800) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* **experimental:** Skip over comptime functions in scan pass ([#4893](https://github.com/noir-lang/noir/issues/4893)) ([f267d42](https://github.com/noir-lang/noir/commit/f267d4205b46317eacb1c247c9dca0e7698d1259))
+* Fix curve parameters for bigints ([#4900](https://github.com/noir-lang/noir/issues/4900)) ([5985e42](https://github.com/noir-lang/noir/commit/5985e4285de9e29f7c986103a49fdaec59228887))
+* Fix panic when returning a zeroed unit value ([#4797](https://github.com/noir-lang/noir/issues/4797)) ([2ea9292](https://github.com/noir-lang/noir/commit/2ea92926956658ea99d8fb97734831eba00d3a4b))
+* Issue 4682 and add solver for unconstrained bigintegers ([#4729](https://github.com/noir-lang/noir/issues/4729)) ([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
+* Primary_message typo in errors.rs (https://github.com/AztecProtocol/aztec-packages/pull/5646) ([5b352d6](https://github.com/noir-lang/noir/commit/5b352d6266c40522f5626f79d2f36a409b482aaa))
+* Proper field inversion for bigints ([#4802](https://github.com/noir-lang/noir/issues/4802)) ([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
+* Reset the noir-gates-diff report on master ([#4878](https://github.com/noir-lang/noir/issues/4878)) ([50bc325](https://github.com/noir-lang/noir/commit/50bc32587a837c930ed14175c98ace1530c54bef))
+* Update noir-gates-diff commit to use master reference report ([#4891](https://github.com/noir-lang/noir/issues/4891)) ([4a3ffb7](https://github.com/noir-lang/noir/commit/4a3ffb7b4c5cdd5fcadb19e7f251b1ee27b0c02b))
+
+
+### Miscellaneous Chores
+
+* Add `as_array` and remove `_slice` variants of hash functions ([#4675](https://github.com/noir-lang/noir/issues/4675)) ([8e39706](https://github.com/noir-lang/noir/commit/8e39706cbb51f27b42fbe851aaa6a67070d07c74))
+* Remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+
 ## [0.27.0](https://github.com/noir-lang/noir/compare/v0.26.0...v0.27.0) (2024-04-10)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 9c9e13b57c9..8a8ccfdbf8a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -26,7 +26,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -40,7 +40,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -56,7 +56,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acir",
  "blake2",
@@ -92,7 +92,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -235,7 +235,7 @@ checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "arena"
-version = "0.27.0"
+version = "0.28.0"
 
 [[package]]
 name = "ark-bls12-381"
@@ -445,7 +445,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
@@ -456,7 +456,7 @@ dependencies = [
 
 [[package]]
 name = "backend-interface"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "bb_abstraction_leaks",
@@ -612,7 +612,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -634,7 +634,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -642,7 +642,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1766,7 +1766,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2387,7 +2387,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.27.0"
+version = "0.28.0"
 
 [[package]]
 name = "itertools"
@@ -2812,7 +2812,7 @@ checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
 name = "nargo"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2838,7 +2838,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2892,7 +2892,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2904,7 +2904,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2983,7 +2983,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -3018,7 +3018,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -3044,7 +3044,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3067,7 +3067,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -3084,7 +3084,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3101,7 +3101,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_driver"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -3122,7 +3122,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3140,7 +3140,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "chrono",
@@ -3157,7 +3157,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "arena",
@@ -3186,7 +3186,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.27.0"
+version = "0.28.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index 132ff181e44..108d179b9ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.27.0"
+version = "0.28.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -52,13 +52,13 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.43.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.43.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.43.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.43.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.43.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.43.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.43.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+acir_field = { version = "0.44.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.44.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.44.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.44.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.44.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.44.0", path = "acvm-repo/blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "0.44.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 arena = { path = "compiler/utils/arena" }
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index 9d9ff539559..b7b8ef3c474 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,125 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.44.0](https://github.com/noir-lang/noir/compare/v0.43.0...v0.44.0) (2024-04-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687)
+* change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374)
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620)
+* trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732)
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709)
+* remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617)
+* storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387)
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616)
+* contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386)
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395)
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955))
+
+### Features
+
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir_gen:** Brillig stdlib ([#4848](https://github.com/noir-lang/noir/issues/4848)) ([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
+* **acir_gen:** Fold attribute at compile-time and initial non inlined ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **acvm_js:** Execute program  ([#4694](https://github.com/noir-lang/noir/issues/4694)) ([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
+* **acvm:** Execute multiple circuits  (https://github.com/AztecProtocol/aztec-packages/pull/5380) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add return values to aztec fns (https://github.com/AztecProtocol/aztec-packages/pull/5389) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Add support for overriding expression width ([#4117](https://github.com/noir-lang/noir/issues/4117)) ([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **avm:** Integrate AVM with initializers (https://github.com/AztecProtocol/aztec-packages/pull/5469) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955)) ([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
+* Brillig heterogeneous memory cells (https://github.com/AztecProtocol/aztec-packages/pull/5608) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Brillig pointer codegen and execution (https://github.com/AztecProtocol/aztec-packages/pull/5737) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395) ([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
+* Change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Impl of missing functionality in new key store (https://github.com/AztecProtocol/aztec-packages/pull/5750) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* **nargo:** Handle call stacks for multiple Acir calls ([#4711](https://github.com/noir-lang/noir/issues/4711)) ([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove range constraints from witnesses which are constrained to be constants ([#3928](https://github.com/noir-lang/noir/issues/3928)) ([afe9c7a](https://github.com/noir-lang/noir/commit/afe9c7a38bb9d4245205d3aa46d4ce23d70a5671))
+* Remove replacement of boolean range opcodes with `AssertZero` opcodes ([#4107](https://github.com/noir-lang/noir/issues/4107)) ([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
+* Restore hashing args via slice for performance (https://github.com/AztecProtocol/aztec-packages/pull/5539) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **simulator:** Fetch return values at circuit execution (https://github.com/AztecProtocol/aztec-packages/pull/5642) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync `aztec-packages` ([#4011](https://github.com/noir-lang/noir/issues/4011)) ([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
+* Sync commits from `aztec-packages` ([#4068](https://github.com/noir-lang/noir/issues/4068)) ([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144)) ([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5572) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5619) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5697) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5794) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5814) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5935) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5955) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5999) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Variable length returns (https://github.com/AztecProtocol/aztec-packages/pull/5633) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+
+
+### Bug Fixes
+
+* **acvm:** Mark outputs of Opcode::Call solvable ([#4708](https://github.com/noir-lang/noir/issues/4708)) ([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
+* Avoid huge unrolling in hash_args (https://github.com/AztecProtocol/aztec-packages/pull/5703) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Catch panics from EC point creation (e.g. the point is at infinity) ([#4790](https://github.com/noir-lang/noir/issues/4790)) ([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
+* Don't reuse brillig with slice arguments (https://github.com/AztecProtocol/aztec-packages/pull/5800) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Issue 4682 and add solver for unconstrained bigintegers ([#4729](https://github.com/noir-lang/noir/issues/4729)) ([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Proper field inversion for bigints ([#4802](https://github.com/noir-lang/noir/issues/4802)) ([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
+* Remove panic from `init_log_level` in `acvm_js` ([#4195](https://github.com/noir-lang/noir/issues/4195)) ([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
+* Return error rather instead of panicking on invalid circuit ([#3976](https://github.com/noir-lang/noir/issues/3976)) ([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.43.0](https://github.com/noir-lang/noir/compare/v0.42.0...v0.43.0) (2024-04-10)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index d6990f83281..96ba13e3b3b 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 7a260ea1fa2..fcbe80ded2d 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index e6554d3f773..0061eec5bc8 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 4635dc8663e..b2db54a4e65 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 63f12942018..7da8bf84b02 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 1d6629c8223..893bed38905 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 448642e1a9e..d856a57eb9b 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 463f6286d6b..41c2cebdad9 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 67e16c21d8b..3dcc05c0842 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.43.0"
+version = "0.44.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index 3bcf60afbe8..e8e7c0ab3c9 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.27.0",
+  "version": "0.28.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/docs/versioned_docs/version-v0.28.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.28.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.28.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.28.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.28.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..743c4d8d634
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/index.md
@@ -0,0 +1,142 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Two additional files would be generated in your project directory:
+
+_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+
+## Prove Our Noir Program
+
+Now that the project is set up, we can create a proof of correct execution of our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Prove the valid execution of your Noir program:
+
+```sh
+nargo prove
+```
+
+A new folder _proofs_ would then be generated in your project directory, containing the proof file
+`<project-name>.proof`, where the project name is defined in Nargo.toml.
+
+The _Verifier.toml_ file would also be updated with the public values computed from program
+execution (in this case the value of `y`):
+
+```toml
+y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+```
+
+> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the
+proof file.
+
+Verify your proof by running:
+
+```sh
+nargo verify
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the
+corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..6160a102c6c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,199 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
+  files, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Verifier.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Verifier.toml
+
+_Verifier.toml_ contains public in/output values computed when executing the Noir program.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
+prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
+verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
+constrained by the proof of the execution of said program (i.e. if the condition was not met, the
+verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
+public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo prove` is executed, two processes happen:
+
+1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
+   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+
+2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove -p OtherProver
+```
+
+## Verifying a Proof
+
+When the command `nargo verify` is executed, two processes happen:
+
+1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
+
+2. If that file is found, the proof's validity is checked
+
+> **Note:** The validity of the proof is linked to the current Noir program; if the program is
+> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
+> _modified_ Noir program.
+
+In production, the prover and the verifier are usually two separate entities. A prover would
+retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
+verifier. The verifier would then retrieve the public inputs, usually from external sources, and
+verify the validity of the proof against it.
+
+Take a private asset transfer as an example:
+
+A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
+public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
+and submit it to the verifier smart contract.
+
+The verifier contract would then draw the user's encrypted balance directly from the blockchain and
+verify the proof submitted against it. If the verification passes, additional functions in the
+verifier contract could trigger (e.g. approve the asset transfer).
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.28.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.28.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.28.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..3634723562b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,102 @@
+---
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.28.0/getting_started/tooling/noir_codegen.md b/docs/versioned_docs/version-v0.28.0/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..d65151da0ab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,113 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 2
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/_category_.json b/docs/versioned_docs/version-v0.28.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.28.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..09e5bae68ad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.28.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..8cf8035a5c4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/how-to-oracles.md
@@ -0,0 +1,276 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("getSqrt", async (params) => {
+  const values = params[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+:::tip
+
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
+
+```json
+{ "values": [{ "Array": ["1", "2"] }]}
+{ "values": [{ "Single": "1" }]}
+{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface SingleForeignCallParam {
+  Single: string,
+}
+
+interface ArrayForeignCallParam {
+  Array: string[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.generateProof(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => i.toString("hex")) },
+    ]);
+    return [oracleReturn.values[0].Array];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.28.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..4c45bb87ae2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/how-to-recursion.md
@@ -0,0 +1,179 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit, backend)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.28.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e3c7c1065da
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,231 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo codegen-verifier
+```
+
+A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+
+```
+0x...<proof bytes>... , [0x0000.....02]
+```
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
+Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of
+the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.28.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..16c425bed76
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/merkle-proof.mdx
@@ -0,0 +1,49 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+use dep::std;
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.28.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.28.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.28.0/index.mdx b/docs/versioned_docs/version-v0.28.0/index.mdx
new file mode 100644
index 00000000000..75086ddcdde
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.28.0/migration_notes.md b/docs/versioned_docs/version-v0.28.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.28.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..efce3e95d32
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,251 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..69826fcd724
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,31 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
+> `false` in _Verifier.toml_.
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow) and
+[Assert Function](../assert) sections.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..a10a4810788
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..357813c147a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..1c6b375db49
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,155 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo prove
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+use dep::std;
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..4eccc677b80
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,195 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+use dep::std::slice;
+
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<N>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..311dfd64416
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,80 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging).
+
+```rust
+use dep::std;
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/distinct.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/distinct.md
new file mode 100644
index 00000000000..6c993b8b5e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/distinct.md
@@ -0,0 +1,64 @@
+---
+title: Distinct Witnesses
+sidebar_position: 11
+---
+
+The `distinct` keyword prevents repetitions of witness indices in the program's ABI. This ensures
+that the witnesses being returned as public inputs are all unique.
+
+The `distinct` keyword is only used for return values on program entry points (usually the `main()`
+function).
+
+When using `distinct` and `pub` simultaneously, `distinct` comes first. See the example below.
+
+You can read more about the problem this solves
+[here](https://github.com/noir-lang/noir/issues/1183).
+
+## Example
+
+Without the `distinct` keyword, the following program
+
+```rust
+fn main(x : pub Field, y : pub Field) -> pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    "return_witnesses": [3, 2, 4, 4]
+  }
+}
+```
+
+Whereas (with the `distinct` keyword)
+
+```rust
+fn main(x : pub Field, y : pub Field) -> distinct pub [Field; 4] {
+    let a = 1;
+    let b = 1;
+    [x + 1, y, a, b]
+}
+```
+
+compiles to
+
+```json
+{
+  //...
+  "abi": {
+    //...
+    "param_witnesses": { "x": [1], "y": [2] },
+    //...
+    "return_witnesses": [3, 4, 5, 6]
+  }
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..ddd42bf1f9b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..60425cb8994
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         |                  Types must be integer |
+| >>        |        Right shift an integer by another integer amount        |                  Types must be integer |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..aa380b5f7b8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/oracles.md
@@ -0,0 +1,31 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+:::note
+
+This is an experimental feature that is not fully documented. If you notice any outdated information or potential improvements to this page, pull request contributions are very welcome: https://github.com/noir-lang/noir
+
+:::
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..ef1445a5907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: dep::some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: dep::some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b8e71fe65f0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md
@@ -0,0 +1,99 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..04c1703d929
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use dep::ecrecover;
+use dep::lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use dep::std::hash::sha256;
+use dep::std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use dep::phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.28.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..2bfdeec6631
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/bigint.md
@@ -0,0 +1,122 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L14-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L14-L19</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L70-L78" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L70-L78</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..be8c65679c3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,31 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..ce4529f6e57
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,326 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..47faa99aba6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,570 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..fcfd7e07aa0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,151 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..d2b42d67b7c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4394b48f907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..c2c0624dfad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..87e113b96cd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,250 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L9-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L9-L11</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::sha256(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L15-L17</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L21-L23</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L45-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L45-L47</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+struct PedersenPoint {
+   x : Field,
+   y : Field,
+}
+
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L26-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L26-L33</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L67-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L67-L69</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L22" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L22</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/scalar.mdx b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/scalar.mdx
new file mode 100644
index 00000000000..df411ca5443
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/scalar.mdx
@@ -0,0 +1,33 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplications over a fixed base in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## scalar_mul::fixed_base_embedded_curve
+
+Performs scalar multiplication over the embedded curve whose coordinates are defined by the
+configured noir field. For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+```rust title="fixed_base_embedded_curve" showLineNumbers 
+pub fn fixed_base_embedded_curve(
+    low: Field,
+    high: Field
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/scalar_mul.nr#L27-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/scalar_mul.nr#L27-L32</a></sub></sup>
+
+
+example
+
+```rust
+fn main(x : Field) {
+    let scal = std::scalar_mul::fixed_base_embedded_curve(x);
+    println(scal);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..b59e69c8f07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..a93894043dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md
@@ -0,0 +1,88 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+:::info
+
+This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+
+:::
+
+## Example usage
+
+```rust
+use dep::std;
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..94337e77a3e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/traits.md
@@ -0,0 +1,410 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(self) -> T {
+      T::from(self)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L102-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L102-L106</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L17-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L17-L21</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L33-L37" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L33-L37</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L49-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L49-L53</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L65-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L65-L69</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L79-L83" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L79-L83</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L95-L99" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L95-L99</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L111-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L111-L115</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L127-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L127-L131</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L142-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L142-L146</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..f450fecdd36
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/zeroed.md
@@ -0,0 +1,26 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..d7249d24330
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,160 @@
+# BarretenbergBackend
+
+## Extends
+
+- `BarretenbergVerifierBackend`
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+#### Inherited from
+
+BarretenbergVerifierBackend.constructor
+
+## Properties
+
+| Property | Type | Description | Inheritance |
+| :------ | :------ | :------ | :------ |
+| `acirComposer` | `any` | - | BarretenbergVerifierBackend.acirComposer |
+| `acirUncompressedBytecode` | `Uint8Array` | - | BarretenbergVerifierBackend.acirUncompressedBytecode |
+| `api` | `Barretenberg` | - | BarretenbergVerifierBackend.api |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) | - | BarretenbergVerifierBackend.options |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.destroy
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.getVerificationKey
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.verifyProof
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
new file mode 100644
index 00000000000..500276ea748
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
@@ -0,0 +1,58 @@
+# BarretenbergVerifier
+
+## Constructors
+
+### new BarretenbergVerifier(options)
+
+```ts
+new BarretenbergVerifier(options): BarretenbergVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergVerifier`](BarretenbergVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..64971973196
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,59 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+| [BarretenbergVerifier](classes/BarretenbergVerifier.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+## Functions
+
+### publicInputsToWitnessMap()
+
+```ts
+publicInputsToWitnessMap(publicInputs, abi): Backend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `publicInputs` | `string`[] |
+| `abi` | `Abi` |
+
+#### Returns
+
+[`Backend`](index.md#backend)
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..d7d5128f9e3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier","label":"BarretenbergVerifier"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..45dd62ee57e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,132 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit, backend)
+
+```ts
+new Noir(circuit, backend?): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+| `backend`? | `any` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the underlying backend instance.
+
+#### Example
+
+```typescript
+await noir.destroy();
+```
+
+***
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+### generateProof()
+
+```ts
+generateProof(inputs, foreignCallHandler?): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a witness and a proof given an object as input.
+
+#### Example
+
+```typescript
+async generateProof(input)
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Instantiates the verification key and verifies a proof.
+
+#### Example
+
+```typescript
+async verifyProof(proof)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..cca6b3ace41
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,54 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+***
+
+### ProofData
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..c6d8125eaad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/_category_.json b/docs/versioned_docs/version-v0.28.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.28.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.28.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.28.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..218fcfb0c8c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/reference/nargo_commands.md
@@ -0,0 +1,381 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo backend`↴](#nargo-backend)
+* [`nargo backend current`↴](#nargo-backend-current)
+* [`nargo backend ls`↴](#nargo-backend-ls)
+* [`nargo backend use`↴](#nargo-backend-use)
+* [`nargo backend install`↴](#nargo-backend-install)
+* [`nargo backend uninstall`↴](#nargo-backend-uninstall)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo codegen-verifier`↴](#nargo-codegen-verifier)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo prove`↴](#nargo-prove)
+* [`nargo verify`↴](#nargo-verify)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `backend` — Install and select custom backends used to generate and verify proofs
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `codegen-verifier` — Generates a Solidity verifier smart contract for the program
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `prove` — Create proof for this program. The proof is returned as a hex encoded string
+* `verify` — Given a proof and a program, verify whether the proof is valid
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo backend`
+
+Install and select custom backends used to generate and verify proofs
+
+**Usage:** `nargo backend <COMMAND>`
+
+###### **Subcommands:**
+
+* `current` — Prints the name of the currently active backend
+* `ls` — Prints the list of currently installed backends
+* `use` — Select the backend to use
+* `install` — Install a new backend from a URL
+* `uninstall` — Uninstalls a backend
+
+
+
+## `nargo backend current`
+
+Prints the name of the currently active backend
+
+**Usage:** `nargo backend current`
+
+
+
+## `nargo backend ls`
+
+Prints the list of currently installed backends
+
+**Usage:** `nargo backend ls`
+
+
+
+## `nargo backend use`
+
+Select the backend to use
+
+**Usage:** `nargo backend use <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>`
+
+
+
+## `nargo backend install`
+
+Install a new backend from a URL
+
+**Usage:** `nargo backend install <BACKEND> <URL>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to install
+* `<URL>` — The URL from which to download the backend
+
+
+
+## `nargo backend uninstall`
+
+Uninstalls a backend
+
+**Usage:** `nargo backend uninstall <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to uninstall
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo codegen-verifier`
+
+Generates a Solidity verifier smart contract for the program
+
+**Usage:** `nargo codegen-verifier [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to codegen
+* `--workspace` — Codegen all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo prove`
+
+Create proof for this program. The proof is returned as a hex encoded string
+
+**Usage:** `nargo prove [OPTIONS]`
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--verify` — Verify proof after proving
+* `--package <PACKAGE>` — The name of the package to prove
+* `--workspace` — Prove all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo verify`
+
+Given a proof and a program, verify whether the proof is valid
+
+**Usage:** `nargo verify [OPTIONS]`
+
+###### **Options:**
+
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--package <PACKAGE>` — The name of the package verify
+* `--workspace` — Verify all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.28.0/tooling/debugger.md b/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
new file mode 100644
index 00000000000..184c436068f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
@@ -0,0 +1,27 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+
+- Noir 0.xx 
+- Nargo 0.xx
+- vscode-noir 0.xx
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.28.0/tooling/language_server.md b/docs/versioned_docs/version-v0.28.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.28.0/tooling/testing.md b/docs/versioned_docs/version-v0.28.0/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6446e0b2a76
--- /dev/null
+++ b/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md
@@ -0,0 +1,326 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.27.x matches `noir_js@0.27.x`, etc.
+
+In this guide, we will be pinned to 0.27.0.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+`nargo new circuit`
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+`nargo compile`
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.27.0 @noir-lang/noir_js@0.27.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
+    ),
+  ]);
+};
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit, backend);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const proof = await noir.generateProof(input);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verificationKey = await backend.getVerificationKey();
+const verifier = new Verifier();
+const isValid = await verifier.verifyProof(proof, verificationKey);
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.28.0-sidebars.json b/docs/versioned_sidebars/version-v0.28.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.28.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 569841b2c6a..2a90e9374df 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.27.0",
+  "version": "0.28.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index 838f317c622..c5bb5af9dfa 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.27.0",
+  "version": "0.28.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index af9e47a8e63..a276a29046f 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.27.0",
+  "version": "0.28.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index 316612a7c51..a356a771b2a 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 0e4aaceeae3..701c843456a 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.27.0",
+  "version": "0.28.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From b380dc44de5c9f8de278ece3d531ebbc2c9238ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gustavo=20Gir=C3=A1ldez?= <ggiraldez@manas.tech>
Date: Wed, 24 Apr 2024 12:45:38 -0400
Subject: [PATCH 221/416] feat: Handle `BrilligCall` opcodes in the debugger
 (#4897)

# Description

## Problem\*

Resolves #4823

With the introduction of the `BrilligCall` opcode to deduplicate the
Brillig bytecode instead of inlining it into `Brillig` opcodes, the
debugger was not being able to correctly step into the execution of
unconstrained functions.

## Summary\*

This PR adds support to the Noir debugger to handle the new
`BrilligCall` opcodes and allows stepping into unconstrained functions
by retrieving the opcodes from the deduplicated Brillig functions. The
changes impact both the REPL and the DAP debuggers.

## Additional Context

In DAP mode, the disassembly request is still not working properly. It
seems that we are not responding to the command in an appropriate
manner. We will tackle that problem separately.

## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 acvm-repo/acvm/src/pwg/brillig.rs |  13 ---
 acvm-repo/acvm/src/pwg/mod.rs     |  23 ++--
 tooling/debugger/src/context.rs   | 169 +++++++++++++++---------------
 tooling/debugger/src/repl.rs      |  61 ++++++-----
 4 files changed, 129 insertions(+), 137 deletions(-)

diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index 67faf7f5007..10178465d58 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -30,19 +30,6 @@ pub struct BrilligSolver<'b, B: BlackBoxFunctionSolver> {
 }
 
 impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
-    /// Evaluates if the Brillig block should be skipped entirely
-    pub(super) fn should_skip(
-        witness: &WitnessMap,
-        brillig: &Brillig,
-    ) -> Result<bool, OpcodeResolutionError> {
-        // If the predicate is `None`, the block should never be skipped
-        // If the predicate is `Some` but we cannot find a value, then we return stalled
-        match &brillig.predicate {
-            Some(pred) => Ok(get_value(pred, witness)?.is_zero()),
-            None => Ok(false),
-        }
-    }
-
     /// Assigns the zero value to all outputs of the given [`Brillig`] bytecode.
     pub(super) fn zero_out_brillig_outputs(
         initial_witness: &mut WitnessMap,
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index 652e173867a..3d3c52c661b 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -430,7 +430,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         let Opcode::BrilligCall { id, inputs, outputs, predicate } =
             &self.opcodes[self.instruction_pointer]
         else {
-            unreachable!("Not executing a Brillig opcode");
+            unreachable!("Not executing a BrilligCall opcode");
         };
 
         let witness = &mut self.witness_map;
@@ -468,27 +468,28 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         }
     }
 
-    pub fn step_into_brillig_opcode(&mut self) -> StepResult<'a, B> {
-        let Opcode::Brillig(brillig) = &self.opcodes[self.instruction_pointer] else {
+    pub fn step_into_brillig(&mut self) -> StepResult<'a, B> {
+        let Opcode::BrilligCall { id, inputs, outputs, predicate } =
+            &self.opcodes[self.instruction_pointer]
+        else {
             return StepResult::Status(self.solve_opcode());
         };
 
         let witness = &mut self.witness_map;
-        let should_skip = match BrilligSolver::<B>::should_skip(witness, brillig) {
+        let should_skip = match is_predicate_false(witness, predicate) {
             Ok(result) => result,
             Err(err) => return StepResult::Status(self.handle_opcode_resolution(Err(err))),
         };
-
         if should_skip {
-            let resolution =
-                BrilligSolver::<B>::zero_out_brillig_outputs(witness, &brillig.outputs);
+            let resolution = BrilligSolver::<B>::zero_out_brillig_outputs(witness, outputs);
             return StepResult::Status(self.handle_opcode_resolution(resolution));
         }
 
-        let solver = BrilligSolver::new(
+        let solver = BrilligSolver::new_call(
             witness,
             &self.block_solvers,
-            brillig,
+            inputs,
+            &self.unconstrained_functions[*id as usize].bytecode,
             self.backend,
             self.instruction_pointer,
         );
@@ -499,8 +500,8 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     }
 
     pub fn finish_brillig_with_solver(&mut self, solver: BrilligSolver<'a, B>) -> ACVMStatus {
-        if !matches!(&self.opcodes[self.instruction_pointer], Opcode::Brillig(..)) {
-            unreachable!("Not executing a Brillig opcode");
+        if !matches!(self.opcodes[self.instruction_pointer], Opcode::BrilligCall { .. }) {
+            unreachable!("Not executing a Brillig/BrilligCall opcode");
         }
         self.brillig_solver = Some(solver);
         self.solve_opcode()
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 9b535075484..a423016eacf 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -34,6 +34,7 @@ pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver> {
     debug_artifact: &'a DebugArtifact,
     breakpoints: HashSet<OpcodeLocation>,
     source_to_opcodes: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>>,
+    unconstrained_functions: &'a [BrilligBytecode],
 }
 
 impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
@@ -59,6 +60,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
             debug_artifact,
             breakpoints: HashSet::new(),
             source_to_opcodes,
+            unconstrained_functions,
         }
     }
 
@@ -215,7 +217,9 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         self.get_opcodes()
             .iter()
             .map(|opcode| match opcode {
-                Opcode::Brillig(brillig_block) => brillig_block.bytecode.len(),
+                Opcode::BrilligCall { id, .. } => {
+                    self.unconstrained_functions[*id as usize].bytecode.len()
+                }
                 _ => 1,
             })
             .collect()
@@ -296,19 +300,22 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
             None => String::from("invalid"),
             Some(OpcodeLocation::Acir(acir_index)) => {
                 let opcode = &opcodes[*acir_index];
-                if let Opcode::Brillig(ref brillig) = opcode {
-                    let first_opcode = &brillig.bytecode[0];
-                    format!("BRILLIG {first_opcode:?}")
-                } else {
-                    format!("{opcode:?}")
+                match opcode {
+                    Opcode::BrilligCall { id, .. } => {
+                        let first_opcode = &self.unconstrained_functions[*id as usize].bytecode[0];
+                        format!("BRILLIG CALL {first_opcode:?}")
+                    }
+                    _ => format!("{opcode:?}"),
                 }
             }
             Some(OpcodeLocation::Brillig { acir_index, brillig_index }) => {
-                if let Opcode::Brillig(ref brillig) = opcodes[*acir_index] {
-                    let opcode = &brillig.bytecode[*brillig_index];
-                    format!("      | {opcode:?}")
-                } else {
-                    String::from("      | invalid")
+                match &opcodes[*acir_index] {
+                    Opcode::BrilligCall { id, .. } => {
+                        let bytecode = &self.unconstrained_functions[*id as usize].bytecode;
+                        let opcode = &bytecode[*brillig_index];
+                        format!("      | {opcode:?}")
+                    }
+                    _ => String::from("      | invalid"),
                 }
             }
         }
@@ -400,7 +407,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
             return self.step_brillig_opcode();
         }
 
-        match self.acvm.step_into_brillig_opcode() {
+        match self.acvm.step_into_brillig() {
             StepResult::IntoBrillig(solver) => {
                 self.brillig_solver = Some(solver);
                 self.step_brillig_opcode()
@@ -409,20 +416,6 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    fn currently_executing_brillig(&self) -> bool {
-        if self.brillig_solver.is_some() {
-            return true;
-        }
-
-        match self.get_current_opcode_location() {
-            Some(OpcodeLocation::Brillig { .. }) => true,
-            Some(OpcodeLocation::Acir(acir_index)) => {
-                matches!(self.get_opcodes()[acir_index], Opcode::Brillig(_))
-            }
-            _ => false,
-        }
-    }
-
     fn get_current_acir_index(&self) -> Option<usize> {
         self.get_current_opcode_location().map(|opcode_location| match opcode_location {
             OpcodeLocation::Acir(acir_index) => acir_index,
@@ -446,8 +439,22 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
+    pub(super) fn is_executing_brillig(&self) -> bool {
+        if self.brillig_solver.is_some() {
+            return true;
+        }
+
+        match self.get_current_opcode_location() {
+            Some(OpcodeLocation::Brillig { .. }) => true,
+            Some(OpcodeLocation::Acir(acir_index)) => {
+                matches!(self.get_opcodes()[acir_index], Opcode::BrilligCall { .. })
+            }
+            _ => false,
+        }
+    }
+
     pub(super) fn step_acir_opcode(&mut self) -> DebugCommandResult {
-        if self.currently_executing_brillig() {
+        if self.is_executing_brillig() {
             self.step_out_of_brillig_opcode()
         } else {
             let status = self.acvm.solve_opcode();
@@ -511,12 +518,6 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    pub(super) fn is_executing_brillig(&self) -> bool {
-        let opcodes = self.get_opcodes();
-        let acir_index = self.acvm.instruction_pointer();
-        acir_index < opcodes.len() && matches!(opcodes[acir_index], Opcode::Brillig(..))
-    }
-
     pub(super) fn get_brillig_memory(&self) -> Option<&[MemoryValue]> {
         self.brillig_solver.as_ref().map(|solver| solver.get_memory())
     }
@@ -552,15 +553,17 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         match *location {
             OpcodeLocation::Acir(acir_index) => acir_index < opcodes.len(),
             OpcodeLocation::Brillig { acir_index, brillig_index } => {
-                acir_index < opcodes.len()
-                    && matches!(opcodes[acir_index], Opcode::Brillig(..))
-                    && {
-                        if let Opcode::Brillig(ref brillig) = opcodes[acir_index] {
-                            brillig_index < brillig.bytecode.len()
-                        } else {
-                            false
+                if acir_index < opcodes.len() {
+                    match &opcodes[acir_index] {
+                        Opcode::BrilligCall { id, .. } => {
+                            let bytecode = &self.unconstrained_functions[*id as usize].bytecode;
+                            brillig_index < bytecode.len()
                         }
+                        _ => false,
                     }
+                } else {
+                    false
+                }
             }
         }
     }
@@ -649,7 +652,7 @@ mod tests {
     use acvm::{
         acir::{
             circuit::{
-                brillig::{Brillig, BrilligInputs, BrilligOutputs},
+                brillig::{BrilligInputs, BrilligOutputs},
                 opcodes::BlockId,
             },
             native_types::Expression,
@@ -666,12 +669,7 @@ mod tests {
         let fe_1 = FieldElement::one();
         let w_x = Witness(1);
 
-        let brillig_opcodes = Brillig {
-            inputs: vec![BrilligInputs::Single(Expression {
-                linear_combinations: vec![(fe_1, w_x)],
-                ..Expression::default()
-            })],
-            outputs: vec![],
+        let brillig_bytecode = BrilligBytecode {
             bytecode: vec![
                 BrilligOpcode::CalldataCopy {
                     destination_address: MemoryAddress(0),
@@ -692,9 +690,17 @@ mod tests {
                 },
                 BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
             ],
-            predicate: None,
         };
-        let opcodes = vec![Opcode::Brillig(brillig_opcodes)];
+        let opcodes = vec![Opcode::BrilligCall {
+            id: 0,
+            inputs: vec![BrilligInputs::Single(Expression {
+                linear_combinations: vec![(fe_1, w_x)],
+                ..Expression::default()
+            })],
+            outputs: vec![],
+            predicate: None,
+        }];
+        let brillig_funcs = &vec![brillig_bytecode];
         let current_witness_index = 2;
         let circuit = &Circuit { current_witness_index, opcodes, ..Circuit::default() };
 
@@ -707,7 +713,6 @@ mod tests {
 
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
-        let brillig_funcs = &vec![];
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
             circuit,
@@ -766,18 +771,7 @@ mod tests {
         let w_z = Witness(3);
 
         // This Brillig block is equivalent to: z = x + y
-        let brillig_opcodes = Brillig {
-            inputs: vec![
-                BrilligInputs::Single(Expression {
-                    linear_combinations: vec![(fe_1, w_x)],
-                    ..Expression::default()
-                }),
-                BrilligInputs::Single(Expression {
-                    linear_combinations: vec![(fe_1, w_y)],
-                    ..Expression::default()
-                }),
-            ],
-            outputs: vec![BrilligOutputs::Simple(w_z)],
+        let brillig_bytecode = BrilligBytecode {
             bytecode: vec![
                 BrilligOpcode::CalldataCopy {
                     destination_address: MemoryAddress(0),
@@ -792,11 +786,24 @@ mod tests {
                 },
                 BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 1 },
             ],
-            predicate: None,
         };
         let opcodes = vec![
             // z = x + y
-            Opcode::Brillig(brillig_opcodes),
+            Opcode::BrilligCall {
+                id: 0,
+                inputs: vec![
+                    BrilligInputs::Single(Expression {
+                        linear_combinations: vec![(fe_1, w_x)],
+                        ..Expression::default()
+                    }),
+                    BrilligInputs::Single(Expression {
+                        linear_combinations: vec![(fe_1, w_y)],
+                        ..Expression::default()
+                    }),
+                ],
+                outputs: vec![BrilligOutputs::Simple(w_z)],
+                predicate: None,
+            },
             // x + y - z = 0
             Opcode::AssertZero(Expression {
                 mul_terms: vec![],
@@ -816,7 +823,7 @@ mod tests {
 
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
-        let brillig_funcs = &vec![];
+        let brillig_funcs = &vec![brillig_bytecode];
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
             circuit,
@@ -848,34 +855,24 @@ mod tests {
 
     #[test]
     fn test_offset_opcode_location() {
+        let brillig_bytecode = BrilligBytecode {
+            bytecode: vec![
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
+            ],
+        };
+
         let opcodes = vec![
-            Opcode::Brillig(Brillig {
-                inputs: vec![],
-                outputs: vec![],
-                bytecode: vec![
-                    BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                    BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                    BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                ],
-                predicate: None,
-            }),
+            Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
             Opcode::MemoryInit { block_id: BlockId(0), init: vec![] },
-            Opcode::Brillig(Brillig {
-                inputs: vec![],
-                outputs: vec![],
-                bytecode: vec![
-                    BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                    BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                    BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                ],
-                predicate: None,
-            }),
+            Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
             Opcode::AssertZero(Expression::default()),
         ];
         let circuit = Circuit { opcodes, ..Circuit::default() };
         let debug_artifact =
             DebugArtifact { debug_symbols: vec![], file_map: BTreeMap::new(), warnings: vec![] };
-        let brillig_funcs = &vec![];
+        let brillig_funcs = &vec![brillig_bytecode];
         let context = DebugContext::new(
             &StubbedBlackBoxSolver,
             &circuit,
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 2a92698e5ce..8f908a38ffc 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -3,6 +3,7 @@ use crate::context::{DebugCommandResult, DebugContext};
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
+use acvm::brillig_vm::brillig::Opcode as BrilligOpcode;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 
 use crate::foreign_calls::DefaultDebugForeignCallExecutor;
@@ -68,23 +69,18 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
             Some(location) => {
                 match location {
                     OpcodeLocation::Acir(ip) => {
-                        // Default Brillig display is too bloated for this context,
-                        // so we limit it to denoting it's the start of a Brillig
-                        // block. The user can still use the `opcodes` command to
-                        // take a look at the whole block.
-                        let opcode_summary = match opcodes[ip] {
-                            Opcode::Brillig(..) => "BRILLIG: ...".into(),
-                            _ => format!("{}", opcodes[ip]),
-                        };
-                        println!("At opcode {}: {}", ip, opcode_summary);
+                        println!("At opcode {}: {}", ip, opcodes[ip]);
                     }
                     OpcodeLocation::Brillig { acir_index, brillig_index } => {
-                        let Opcode::Brillig(ref brillig) = opcodes[acir_index] else {
-                            unreachable!("Brillig location does not contain a Brillig block");
-                        };
+                        let brillig_bytecode =
+                            if let Opcode::BrilligCall { id, .. } = opcodes[acir_index] {
+                                &self.unconstrained_functions[id as usize].bytecode
+                            } else {
+                                unreachable!("Brillig location does not contain Brillig opcodes");
+                            };
                         println!(
                             "At opcode {}.{}: {:?}",
-                            acir_index, brillig_index, brillig.bytecode[brillig_index]
+                            acir_index, brillig_index, brillig_bytecode[brillig_index]
                         );
                     }
                 }
@@ -104,12 +100,15 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
                 )
             }
             OpcodeLocation::Brillig { acir_index, brillig_index } => {
-                let Opcode::Brillig(ref brillig) = opcodes[*acir_index] else {
-                    unreachable!("Brillig location does not contain a Brillig block");
+                let brillig_bytecode = if let Opcode::BrilligCall { id, .. } = opcodes[*acir_index]
+                {
+                    &self.unconstrained_functions[id as usize].bytecode
+                } else {
+                    unreachable!("Brillig location does not contain Brillig opcodes");
                 };
                 println!(
                     "Frame #{index}, opcode {}.{}: {:?}",
-                    acir_index, brillig_index, brillig.bytecode[*brillig_index]
+                    acir_index, brillig_index, brillig_bytecode[*brillig_index]
                 );
             }
         }
@@ -162,22 +161,30 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
                 ""
             }
         };
+        let print_brillig_bytecode = |acir_index, bytecode: &[BrilligOpcode]| {
+            for (brillig_index, brillig_opcode) in bytecode.iter().enumerate() {
+                println!(
+                    "{:>3}.{:<2} |{:2} {:?}",
+                    acir_index,
+                    brillig_index,
+                    brillig_marker(acir_index, brillig_index),
+                    brillig_opcode
+                );
+            }
+        };
         for (acir_index, opcode) in opcodes.iter().enumerate() {
             let marker = outer_marker(acir_index);
-            if let Opcode::Brillig(brillig) = opcode {
-                println!("{:>3} {:2} BRILLIG inputs={:?}", acir_index, marker, brillig.inputs);
-                println!("       |       outputs={:?}", brillig.outputs);
-                for (brillig_index, brillig_opcode) in brillig.bytecode.iter().enumerate() {
+            match &opcode {
+                Opcode::BrilligCall { id, inputs, outputs, .. } => {
                     println!(
-                        "{:>3}.{:<2} |{:2} {:?}",
-                        acir_index,
-                        brillig_index,
-                        brillig_marker(acir_index, brillig_index),
-                        brillig_opcode
+                        "{:>3} {:2} BRILLIG CALL id={} inputs={:?}",
+                        acir_index, marker, id, inputs
                     );
+                    println!("       |       outputs={:?}", outputs);
+                    let bytecode = &self.unconstrained_functions[*id as usize].bytecode;
+                    print_brillig_bytecode(acir_index, bytecode);
                 }
-            } else {
-                println!("{:>3} {:2} {:?}", acir_index, marker, opcode);
+                _ => println!("{:>3} {:2} {:?}", acir_index, marker, opcode),
             }
         }
     }

From 0cf2e2a1b8d247bed03ba5b7b1be5cd30f0d51b2 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 24 Apr 2024 11:55:27 -0500
Subject: [PATCH 222/416] fix: Nested array equality (#4903)

# Description

## Problem\*

Resolves #4383 (both examples in the issue)

## Summary\*

We were relying on the built in array equality for arrays in SSA
previously, but this did not recurse on the array element in the case of
nested arrays. I've just removed this since it is no longer needed. We
now use the impl Eq for arrays in the stdlib instead since the built in
version provided no speedup anyway.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../src/ssa/ssa_gen/context.rs                | 108 +-----------------
 .../noirc_frontend/src/hir/type_check/expr.rs |  30 -----
 .../regression_4383/Nargo.toml                |   7 ++
 .../regression_4383/src/main.nr               |   3 +
 4 files changed, 15 insertions(+), 133 deletions(-)
 create mode 100644 test_programs/execution_success/regression_4383/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_4383/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index e591a3d478c..276a8247cea 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -566,22 +566,12 @@ impl<'a> FunctionContext<'a> {
         mut rhs: ValueId,
         location: Location,
     ) -> Values {
-        let result_type = self.builder.type_of_value(lhs);
-        let mut result = match operator {
-            BinaryOpKind::Equal | BinaryOpKind::NotEqual
-                if matches!(result_type, Type::Array(..)) =>
-            {
-                return self.insert_array_equality(lhs, operator, rhs, location)
-            }
-            _ => {
-                let op = convert_operator(operator);
-                if operator_requires_swapped_operands(operator) {
-                    std::mem::swap(&mut lhs, &mut rhs);
-                }
+        let op = convert_operator(operator);
+        if operator_requires_swapped_operands(operator) {
+            std::mem::swap(&mut lhs, &mut rhs);
+        }
 
-                self.builder.set_location(location).insert_binary(lhs, op, rhs)
-            }
-        };
+        let mut result = self.builder.set_location(location).insert_binary(lhs, op, rhs);
 
         // Check for integer overflow
         if matches!(
@@ -600,94 +590,6 @@ impl<'a> FunctionContext<'a> {
         result.into()
     }
 
-    /// The frontend claims to support equality (==) on arrays, so we must support it in SSA here.
-    /// The actual BinaryOp::Eq in SSA is meant only for primitive numeric types so we encode an
-    /// entire equality loop on each array element. The generated IR is as follows:
-    ///
-    ///   ...
-    ///   result_alloc = allocate
-    ///   store u1 1 in result_alloc
-    ///   jmp loop_start(0)
-    /// loop_start(i: Field):
-    ///   v0 = lt i, array_len
-    ///   jmpif v0, then: loop_body, else: loop_end
-    /// loop_body():
-    ///   v1 = array_get lhs, index i
-    ///   v2 = array_get rhs, index i
-    ///   v3 = eq v1, v2
-    ///   v4 = load result_alloc
-    ///   v5 = and v4, v3
-    ///   store v5 in result_alloc
-    ///   v6 = add i, Field 1
-    ///   jmp loop_start(v6)
-    /// loop_end():
-    ///   result = load result_alloc
-    fn insert_array_equality(
-        &mut self,
-        lhs: ValueId,
-        operator: BinaryOpKind,
-        rhs: ValueId,
-        location: Location,
-    ) -> Values {
-        let lhs_type = self.builder.type_of_value(lhs);
-        let rhs_type = self.builder.type_of_value(rhs);
-
-        let (array_length, element_type) = match (lhs_type, rhs_type) {
-            (
-                Type::Array(lhs_composite_type, lhs_length),
-                Type::Array(rhs_composite_type, rhs_length),
-            ) => {
-                assert!(
-                    lhs_composite_type.len() == 1 && rhs_composite_type.len() == 1,
-                    "== is unimplemented for arrays of structs"
-                );
-                assert_eq!(lhs_composite_type[0], rhs_composite_type[0]);
-                assert_eq!(lhs_length, rhs_length, "Expected two arrays of equal length");
-                (lhs_length, lhs_composite_type[0].clone())
-            }
-            _ => unreachable!("Expected two array values"),
-        };
-
-        let loop_start = self.builder.insert_block();
-        let loop_body = self.builder.insert_block();
-        let loop_end = self.builder.insert_block();
-
-        // pre-loop
-        let result_alloc = self.builder.set_location(location).insert_allocate(Type::bool());
-        let true_value = self.builder.numeric_constant(1u128, Type::bool());
-        self.builder.insert_store(result_alloc, true_value);
-        let zero = self.builder.length_constant(0u128);
-        self.builder.terminate_with_jmp(loop_start, vec![zero]);
-
-        // loop_start
-        self.builder.switch_to_block(loop_start);
-        let i = self.builder.add_block_parameter(loop_start, Type::length_type());
-        let array_length = self.builder.length_constant(array_length as u128);
-        let v0 = self.builder.insert_binary(i, BinaryOp::Lt, array_length);
-        self.builder.terminate_with_jmpif(v0, loop_body, loop_end);
-
-        // loop body
-        self.builder.switch_to_block(loop_body);
-        let v1 = self.builder.insert_array_get(lhs, i, element_type.clone());
-        let v2 = self.builder.insert_array_get(rhs, i, element_type);
-        let v3 = self.builder.insert_binary(v1, BinaryOp::Eq, v2);
-        let v4 = self.builder.insert_load(result_alloc, Type::bool());
-        let v5 = self.builder.insert_binary(v4, BinaryOp::And, v3);
-        self.builder.insert_store(result_alloc, v5);
-        let one = self.builder.length_constant(1u128);
-        let v6 = self.builder.insert_binary(i, BinaryOp::Add, one);
-        self.builder.terminate_with_jmp(loop_start, vec![v6]);
-
-        // loop end
-        self.builder.switch_to_block(loop_end);
-        let mut result = self.builder.insert_load(result_alloc, Type::bool());
-
-        if operator_requires_not(operator) {
-            result = self.builder.insert_not(result);
-        }
-        result.into()
-    }
-
     /// Inserts a call instruction at the end of the current block and returns the results
     /// of the call.
     ///
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 0bc7673e105..7b30777c3ba 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -890,36 +890,6 @@ impl<'interner> TypeChecker<'interner> {
             // <= and friends are technically valid for booleans, just not very useful
             (Bool, Bool) => Ok((Bool, false)),
 
-            // Special-case == and != for arrays
-            (Array(x_size, x_type), Array(y_size, y_type))
-                if matches!(op.kind, BinaryOpKind::Equal | BinaryOpKind::NotEqual) =>
-            {
-                self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource {
-                    expected: lhs_type.clone(),
-                    actual: rhs_type.clone(),
-                    source: Source::ArrayLen,
-                    span: op.location.span,
-                });
-
-                let (_, use_impl) = self.comparator_operand_type_rules(x_type, y_type, op, span)?;
-
-                // If the size is not constant, we must fall back to a user-provided impl for
-                // equality on slices.
-                let size = x_size.follow_bindings();
-                let use_impl = use_impl || size.evaluate_to_u64().is_none();
-                Ok((Bool, use_impl))
-            }
-
-            (String(x_size), String(y_size)) => {
-                self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource {
-                    expected: *x_size.clone(),
-                    actual: *y_size.clone(),
-                    span: op.location.span,
-                    source: Source::StringLen,
-                });
-
-                Ok((Bool, false))
-            }
             (lhs, rhs) => {
                 self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource {
                     expected: lhs.clone(),
diff --git a/test_programs/execution_success/regression_4383/Nargo.toml b/test_programs/execution_success/regression_4383/Nargo.toml
new file mode 100644
index 00000000000..2ad8c208f24
--- /dev/null
+++ b/test_programs/execution_success/regression_4383/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_4383"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_4383/src/main.nr b/test_programs/execution_success/regression_4383/src/main.nr
new file mode 100644
index 00000000000..fec63ea64a5
--- /dev/null
+++ b/test_programs/execution_success/regression_4383/src/main.nr
@@ -0,0 +1,3 @@
+fn main() {
+    assert([[1]] == [[1]]);
+}

From e7057674f81e24fe05f35c3e7c8fc2b05198232a Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 24 Apr 2024 18:41:23 +0100
Subject: [PATCH 223/416] chore: delete dead code (#4906)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR deletes a bunch of dead code from `noirc_evaluator`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa.rs           |  9 +--
 .../ssa/acir_gen/acir_ir/generated_acir.rs    | 49 --------------
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 19 +++---
 .../src/ssa/ssa_gen/context.rs                | 67 -------------------
 4 files changed, 9 insertions(+), 135 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 3482a8c25c7..f9fd5f41f77 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -9,10 +9,7 @@
 
 use std::collections::BTreeSet;
 
-use crate::{
-    brillig::Brillig,
-    errors::{RuntimeError, SsaReport},
-};
+use crate::errors::{RuntimeError, SsaReport};
 use acvm::acir::{
     circuit::{
         brillig::BrilligBytecode, Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs,
@@ -318,10 +315,6 @@ impl SsaBuilder {
         Ok(self.print(msg))
     }
 
-    fn to_brillig(&self, print_brillig_trace: bool) -> Brillig {
-        self.ssa.to_brillig(print_brillig_trace)
-    }
-
     fn print(self, msg: &str) -> Self {
         if self.print_ssa_passes {
             println!("{msg}\n{}", self.ssa);
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 0b04d1b63ab..9f305a28c25 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -420,55 +420,6 @@ impl GeneratedAcir {
         Ok(limb_witnesses)
     }
 
-    /// Returns an expression which represents `lhs * rhs`
-    ///
-    /// If one has multiplicative term and the other is of degree one or more,
-    /// the function creates [intermediate variables][`Witness`] accordingly.
-    /// There are two cases where we can optimize the multiplication between two expressions:
-    /// 1. If the sum of the degrees of both expressions is at most 2, then we can just multiply them
-    /// as each term in the result will be degree-2.
-    /// 2. If one expression is a constant, then we can just multiply the constant with the other expression
-    ///
-    /// (1) is because an [`Expression`] can hold at most a degree-2 univariate polynomial
-    /// which is what you get when you multiply two degree-1 univariate polynomials.
-    pub(crate) fn mul_with_witness(&mut self, lhs: &Expression, rhs: &Expression) -> Expression {
-        use std::borrow::Cow;
-        let lhs_is_linear = lhs.is_linear();
-        let rhs_is_linear = rhs.is_linear();
-
-        // Case 1: The sum of the degrees of both expressions is at most 2.
-        //
-        // If one of the expressions is constant then it does not increase the degree when multiplying by another expression.
-        // If both of the expressions are linear (degree <=1) then the product will be at most degree 2.
-        let both_are_linear = lhs_is_linear && rhs_is_linear;
-        let either_is_const = lhs.is_const() || rhs.is_const();
-        if both_are_linear || either_is_const {
-            return (lhs * rhs).expect("Both expressions are degree <= 1");
-        }
-
-        // Case 2: One or both of the sides needs to be reduced to a degree-1 univariate polynomial
-        let lhs_reduced = if lhs_is_linear {
-            Cow::Borrowed(lhs)
-        } else {
-            Cow::Owned(self.get_or_create_witness(lhs).into())
-        };
-
-        // If the lhs and rhs are the same, then we do not need to reduce
-        // rhs, we only need to square the lhs.
-        if lhs == rhs {
-            return (&*lhs_reduced * &*lhs_reduced)
-                .expect("Both expressions are reduced to be degree <= 1");
-        };
-
-        let rhs_reduced = if rhs_is_linear {
-            Cow::Borrowed(rhs)
-        } else {
-            Cow::Owned(self.get_or_create_witness(rhs).into())
-        };
-
-        (&*lhs_reduced * &*rhs_reduced).expect("Both expressions are reduced to be degree <= 1")
-    }
-
     /// Adds an inversion brillig opcode.
     ///
     /// This code will invert `expr` without applying constraints
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index ee236df8eac..6c7d78acdea 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -3277,18 +3277,15 @@ mod test {
         // This check right now expects to only call one Brillig function.
         let mut num_normal_brillig_calls = 0;
         for (i, opcode) in opcodes.iter().enumerate() {
-            match opcode {
-                Opcode::BrilligCall { id, .. } => {
-                    if brillig_stdlib_function_locations.get(&OpcodeLocation::Acir(i)).is_some() {
-                        // We should have already checked Brillig stdlib functions and only want to check normal Brillig calls here
-                        continue;
-                    }
-                    // We only generate one normal Brillig call so we should expect a function ID of `0`
-                    let expected_id = 0u32;
-                    assert_eq!(*id, expected_id, "Expected an id of {expected_id} but got {id}");
-                    num_normal_brillig_calls += 1;
+            if let Opcode::BrilligCall { id, .. } = opcode {
+                if brillig_stdlib_function_locations.get(&OpcodeLocation::Acir(i)).is_some() {
+                    // We should have already checked Brillig stdlib functions and only want to check normal Brillig calls here
+                    continue;
                 }
-                _ => {}
+                // We only generate one normal Brillig call so we should expect a function ID of `0`
+                let expected_id = 0u32;
+                assert_eq!(*id, expected_id, "Expected an id of {expected_id} but got {id}");
+                num_normal_brillig_calls += 1;
             }
         }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index 276a8247cea..fdd17097d19 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -11,7 +11,6 @@ use noirc_frontend::monomorphization::ast::{FuncId, Program};
 use crate::errors::RuntimeError;
 use crate::ssa::function_builder::FunctionBuilder;
 use crate::ssa::ir::basic_block::BasicBlockId;
-use crate::ssa::ir::dfg::DataFlowGraph;
 use crate::ssa::ir::function::{Function, RuntimeType};
 use crate::ssa::ir::function::{FunctionId as IrFunctionId, InlineType};
 use crate::ssa::ir::instruction::BinaryOp;
@@ -1005,72 +1004,6 @@ fn operator_requires_swapped_operands(op: BinaryOpKind) -> bool {
     matches!(op, Greater | LessEqual)
 }
 
-/// If the operation requires its result to be truncated because it is an integer, the maximum
-/// number of bits that result may occupy is returned.
-fn operator_result_max_bit_size_to_truncate(
-    op: BinaryOpKind,
-    lhs: ValueId,
-    rhs: ValueId,
-    dfg: &DataFlowGraph,
-) -> Option<u32> {
-    let lhs_type = dfg.type_of_value(lhs);
-    let rhs_type = dfg.type_of_value(rhs);
-
-    let get_bit_size = |typ| match typ {
-        Type::Numeric(NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size }) => {
-            Some(bit_size)
-        }
-        _ => None,
-    };
-
-    let lhs_bit_size = get_bit_size(lhs_type)?;
-    let rhs_bit_size = get_bit_size(rhs_type)?;
-    use BinaryOpKind::*;
-    match op {
-        Add => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
-        Subtract => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
-        Multiply => {
-            if lhs_bit_size == 1 || rhs_bit_size == 1 {
-                // Truncation is unnecessary as multiplication by a boolean value cannot cause an overflow.
-                None
-            } else {
-                Some(lhs_bit_size + rhs_bit_size)
-            }
-        }
-
-        ShiftLeft => {
-            if let Some(rhs_constant) = dfg.get_numeric_constant(rhs) {
-                // Happy case is that we know precisely by how many bits the the integer will
-                // increase: lhs_bit_size + rhs
-                return Some(lhs_bit_size + (rhs_constant.to_u128() as u32));
-            }
-            // Unhappy case is that we don't yet know the rhs value, (even though it will
-            // eventually have to resolve to a constant). The best we can is assume the value of
-            // rhs to be the maximum value of it's numeric type. If that turns out to be larger
-            // than the native field's bit size, we full back to using that.
-
-            // The formula for calculating the max bit size of a left shift is:
-            // lhs_bit_size + 2^{rhs_bit_size} - 1
-            // Inferring the max bit size of left shift from its operands can result in huge
-            // number, that might not only be larger than the native field's max bit size, but
-            // furthermore might not be representable as a u32. Hence we use overflow checks and
-            // fallback to the native field's max bits.
-            let field_max_bits = FieldElement::max_num_bits();
-            let (rhs_bit_size_pow_2, overflows) = 2_u32.overflowing_pow(rhs_bit_size);
-            if overflows {
-                return Some(field_max_bits);
-            }
-            let (max_bits_plus_1, overflows) = rhs_bit_size_pow_2.overflowing_add(lhs_bit_size);
-            if overflows {
-                return Some(field_max_bits);
-            }
-            let max_bit_size = std::cmp::min(max_bits_plus_1 - 1, field_max_bits);
-            Some(max_bit_size)
-        }
-        _ => None,
-    }
-}
-
 /// Converts the given operator to the appropriate BinaryOp.
 /// Take care when using this to insert a binary instruction: this requires
 /// checking operator_requires_not and operator_requires_swapped_operands

From 7dd2c5ea7cf5f2e63ad41d691112062a5a546183 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 24 Apr 2024 15:00:49 -0500
Subject: [PATCH 224/416] chore: Add error conversion from `InterpreterError`
 (#4896)

# Description

## Problem\*

Resolves comment:
https://github.com/noir-lang/noir/pull/4884#discussion_r1576646720

## Summary\*

Converts from `InterpreterError` to `CustomDiagnostic` and removes the
previous `.unwrap()` placeholder so that interpreter errors are now
properly displayed.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .../noirc_frontend/src/hir/comptime/errors.rs | 226 +++++++++++++++++-
 .../src/hir/comptime/interpreter.rs           |   9 +-
 .../noirc_frontend/src/hir/comptime/mod.rs    |   1 +
 .../src/hir/def_collector/dc_crate.rs         |  14 +-
 4 files changed, 235 insertions(+), 15 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 67d9a006b22..8de444252ab 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -1,11 +1,11 @@
-use crate::Type;
+use crate::{hir::def_collector::dc_crate::CompilationError, Type};
 use acvm::FieldElement;
-use noirc_errors::Location;
+use noirc_errors::{CustomDiagnostic, Location};
 
 use super::value::Value;
 
 /// The possible errors that can halt the interpreter.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum InterpreterError {
     ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
     TypeMismatch { expected: Type, value: Value, location: Location },
@@ -16,7 +16,7 @@ pub enum InterpreterError {
     NonBoolUsedInIf { value: Value, location: Location },
     NonBoolUsedInConstrain { value: Value, location: Location },
     FailingConstraint { message: Option<Value>, location: Location },
-    NoMethodFound { object: Value, typ: Type, location: Location },
+    NoMethodFound { name: String, typ: Type, location: Location },
     NonIntegerUsedInLoop { value: Value, location: Location },
     NonPointerDereferenced { value: Value, location: Location },
     NonTupleOrStructInMemberAccess { value: Value, location: Location },
@@ -51,3 +51,221 @@ pub enum InterpreterError {
 
 #[allow(unused)]
 pub(super) type IResult<T> = std::result::Result<T, InterpreterError>;
+
+impl InterpreterError {
+    pub fn into_compilation_error_pair(self) -> (CompilationError, fm::FileId) {
+        let location = self.get_location();
+        (CompilationError::InterpreterError(self), location.file)
+    }
+
+    pub fn get_location(&self) -> Location {
+        match self {
+            InterpreterError::ArgumentCountMismatch { call_location: location, .. }
+            | InterpreterError::TypeMismatch { location, .. }
+            | InterpreterError::NonComptimeVarReferenced { location, .. }
+            | InterpreterError::IntegerOutOfRangeForType { location, .. }
+            | InterpreterError::ErrorNodeEncountered { location, .. }
+            | InterpreterError::NonFunctionCalled { location, .. }
+            | InterpreterError::NonBoolUsedInIf { location, .. }
+            | InterpreterError::NonBoolUsedInConstrain { location, .. }
+            | InterpreterError::FailingConstraint { location, .. }
+            | InterpreterError::NoMethodFound { location, .. }
+            | InterpreterError::NonIntegerUsedInLoop { location, .. }
+            | InterpreterError::NonPointerDereferenced { location, .. }
+            | InterpreterError::NonTupleOrStructInMemberAccess { location, .. }
+            | InterpreterError::NonArrayIndexed { location, .. }
+            | InterpreterError::NonIntegerUsedAsIndex { location, .. }
+            | InterpreterError::NonIntegerIntegerLiteral { location, .. }
+            | InterpreterError::NonIntegerArrayLength { location, .. }
+            | InterpreterError::NonNumericCasted { location, .. }
+            | InterpreterError::IndexOutOfBounds { location, .. }
+            | InterpreterError::ExpectedStructToHaveField { location, .. }
+            | InterpreterError::TypeUnsupported { location, .. }
+            | InterpreterError::InvalidValueForUnary { location, .. }
+            | InterpreterError::InvalidValuesForBinary { location, .. }
+            | InterpreterError::CastToNonNumericType { location, .. }
+            | InterpreterError::QuoteInRuntimeCode { location, .. }
+            | InterpreterError::NonStructInConstructor { location, .. }
+            | InterpreterError::CannotInlineMacro { location, .. }
+            | InterpreterError::UnquoteFoundDuringEvaluation { location, .. }
+            | InterpreterError::Unimplemented { location, .. }
+            | InterpreterError::BreakNotInLoop { location, .. }
+            | InterpreterError::ContinueNotInLoop { location, .. } => *location,
+            InterpreterError::Break | InterpreterError::Continue => {
+                panic!("Tried to get the location of Break/Continue error!")
+            }
+        }
+    }
+}
+
+impl From<InterpreterError> for CustomDiagnostic {
+    fn from(error: InterpreterError) -> Self {
+        match error {
+            InterpreterError::ArgumentCountMismatch { expected, actual, call_location } => {
+                let only = if expected > actual { "only " } else { "" };
+                let plural = if expected == 1 { "" } else { "s" };
+                let was_were = if actual == 1 { "was" } else { "were" };
+                let msg = format!(
+                    "Expected {expected} argument{plural}, but {only}{actual} {was_were} provided"
+                );
+
+                let few_many = if actual < expected { "few" } else { "many" };
+                let secondary = format!("Too {few_many} arguments");
+                CustomDiagnostic::simple_error(msg, secondary, call_location.span)
+            }
+            InterpreterError::TypeMismatch { expected, value, location } => {
+                let typ = value.get_type();
+                let msg = format!("Expected `{expected}` but a value of type `{typ}` was given");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::NonComptimeVarReferenced { name, location } => {
+                let msg = format!("Non-comptime variable `{name}` referenced in comptime code");
+                let secondary = "Non-comptime variables can't be used in comptime code".to_string();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::IntegerOutOfRangeForType { value, typ, location } => {
+                let int = match value.try_into_u128() {
+                    Some(int) => int.to_string(),
+                    None => value.to_string(),
+                };
+                let msg = format!("{int} is outside the range of the {typ} type");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::ErrorNodeEncountered { location } => {
+                let msg = "Internal Compiler Error: Error node encountered".to_string();
+                let secondary = "This is a bug, please report this if found!".to_string();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonFunctionCalled { value, location } => {
+                let msg = "Only functions may be called".to_string();
+                let secondary = format!("Expression has type {}", value.get_type());
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonBoolUsedInIf { value, location } => {
+                let msg = format!("Expected a `bool` but found `{}`", value.get_type());
+                let secondary = "If conditions must be a boolean value".to_string();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonBoolUsedInConstrain { value, location } => {
+                let msg = format!("Expected a `bool` but found `{}`", value.get_type());
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::FailingConstraint { message, location } => {
+                let (primary, secondary) = match message {
+                    Some(msg) => (format!("{msg:?}"), "Assertion failed".into()),
+                    None => ("Assertion failed".into(), String::new()),
+                };
+                CustomDiagnostic::simple_error(primary, secondary, location.span)
+            }
+            InterpreterError::NoMethodFound { name, typ, location } => {
+                let msg = format!("No method named `{name}` found for type `{typ}`");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::NonIntegerUsedInLoop { value, location } => {
+                let typ = value.get_type();
+                let msg = format!("Non-integer type `{typ}` used in for loop");
+                let secondary = if matches!(typ.as_ref(), &Type::FieldElement) {
+                    "`field` is not an integer type, try `u64` instead".to_string()
+                } else {
+                    String::new()
+                };
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonPointerDereferenced { value, location } => {
+                let typ = value.get_type();
+                let msg = format!("Only references may be dereferenced, but found `{typ}`");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::NonTupleOrStructInMemberAccess { value, location } => {
+                let msg = format!("The type `{}` has no fields to access", value.get_type());
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::NonArrayIndexed { value, location } => {
+                let msg = format!("Expected an array or slice but found a(n) {}", value.get_type());
+                let secondary = "Only arrays or slices may be indexed".into();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonIntegerUsedAsIndex { value, location } => {
+                let msg = format!("Expected an integer but found a(n) {}", value.get_type());
+                let secondary =
+                    "Only integers may be indexed. Note that this excludes `field`s".into();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonIntegerIntegerLiteral { typ, location } => {
+                let msg = format!("This integer literal somehow has the type `{typ}`");
+                let secondary = "This is likely a bug".into();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonIntegerArrayLength { typ, location } => {
+                let msg = format!("Non-integer array length: `{typ}`");
+                let secondary = "Array lengths must be integers".into();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::NonNumericCasted { value, location } => {
+                let msg = "Only numeric types may be casted".into();
+                let secondary = format!("`{}` is non-numeric", value.get_type());
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::IndexOutOfBounds { index, length, location } => {
+                let msg = format!("{index} is out of bounds for the array of length {length}");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::ExpectedStructToHaveField { value, field_name, location } => {
+                let typ = value.get_type();
+                let msg = format!("The type `{typ}` has no field named `{field_name}`");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::TypeUnsupported { typ, location } => {
+                let msg =
+                    format!("The type `{typ}` is currently unsupported in comptime expressions");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::InvalidValueForUnary { value, operator, location } => {
+                let msg = format!("`{}` cannot be used with unary {operator}", value.get_type());
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::InvalidValuesForBinary { lhs, rhs, operator, location } => {
+                let lhs = lhs.get_type();
+                let rhs = rhs.get_type();
+                let msg = format!("No implementation for `{lhs}` {operator} `{rhs}`",);
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::CastToNonNumericType { typ, location } => {
+                let msg = format!("Cannot cast to non-numeric type `{typ}`");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::QuoteInRuntimeCode { location } => {
+                let msg = "`quote` may only be used in comptime code".into();
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::NonStructInConstructor { typ, location } => {
+                let msg = format!("`{typ}` is not a struct type");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::CannotInlineMacro { value, location } => {
+                let msg = "Cannot inline value into runtime code if it contains references".into();
+                let secondary = format!("Cannot inline value {value:?}");
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::UnquoteFoundDuringEvaluation { location } => {
+                let msg = "Unquote found during comptime evaluation".into();
+                let secondary = "This is a bug".into();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::Unimplemented { item, location } => {
+                let msg = format!("{item} is currently unimplemented");
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::BreakNotInLoop { location } => {
+                let msg = "There is no loop to break out of!".into();
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::ContinueNotInLoop { location } => {
+                let msg = "There is no loop to continue!".into();
+                CustomDiagnostic::simple_error(msg, String::new(), location.span)
+            }
+            InterpreterError::Break => unreachable!("Uncaught InterpreterError::Break"),
+            InterpreterError::Continue => unreachable!("Uncaught InterpreterError::Continue"),
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index c01c985a40c..4bdd4eaec9a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -506,11 +506,8 @@ impl<'a> Interpreter<'a> {
                 Value::U64(value) => Ok(Value::U64(0 - value)),
                 value => {
                     let location = self.interner.expr_location(&id);
-                    Err(InterpreterError::InvalidValueForUnary {
-                        value,
-                        location,
-                        operator: "minus",
-                    })
+                    let operator = "minus";
+                    Err(InterpreterError::InvalidValueForUnary { value, location, operator })
                 }
             },
             crate::ast::UnaryOp::Not => match rhs {
@@ -880,7 +877,7 @@ impl<'a> Interpreter<'a> {
         if let Some(method) = method {
             self.call_function(method, arguments, location)
         } else {
-            Err(InterpreterError::NoMethodFound { object, typ, location })
+            Err(InterpreterError::NoMethodFound { name: method_name.clone(), typ, location })
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
index 26e05d675b3..148fa56b4cb 100644
--- a/compiler/noirc_frontend/src/hir/comptime/mod.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -5,4 +5,5 @@ mod scan;
 mod tests;
 mod value;
 
+pub use errors::InterpreterError;
 pub use interpreter::Interpreter;
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 7805f36cdb2..d8839b33ff4 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -1,7 +1,7 @@
 use super::dc_mod::collect_defs;
 use super::errors::{DefCollectorErrorKind, DuplicateType};
 use crate::graph::CrateId;
-use crate::hir::comptime::Interpreter;
+use crate::hir::comptime::{Interpreter, InterpreterError};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
 
@@ -155,6 +155,7 @@ pub enum CompilationError {
     DefinitionError(DefCollectorErrorKind),
     ResolverError(ResolverError),
     TypeError(TypeCheckError),
+    InterpreterError(InterpreterError),
 }
 
 impl From<CompilationError> for CustomDiagnostic {
@@ -164,6 +165,7 @@ impl From<CompilationError> for CustomDiagnostic {
             CompilationError::DefinitionError(error) => error.into(),
             CompilationError::ResolverError(error) => error.into(),
             CompilationError::TypeError(error) => error.into(),
+            CompilationError::InterpreterError(error) => error.into(),
         }
     }
 }
@@ -500,13 +502,15 @@ impl ResolvedModule {
     }
 
     /// Evaluate all `comptime` expressions in this module
-    fn evaluate_comptime(&self, interner: &mut NodeInterner) {
+    fn evaluate_comptime(&mut self, interner: &mut NodeInterner) {
         let mut interpreter = Interpreter::new(interner);
 
         for (_file, function) in &self.functions {
-            // .unwrap() is temporary here until we can convert
-            // from InterpreterError to (CompilationError, FileId)
-            interpreter.scan_function(*function).unwrap();
+            // The file returned by the error may be different than the file the
+            // function is in so only use the error's file id.
+            if let Err(error) = interpreter.scan_function(*function) {
+                self.errors.push(error.into_compilation_error_pair());
+            }
         }
     }
 

From 53d145fd48df4cad82cff30f966a42af20d6e2df Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 25 Apr 2024 13:14:18 +0100
Subject: [PATCH 225/416] chore: delete flake.lock (#4855)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 flake.lock | 170 -----------------------------------------------------
 1 file changed, 170 deletions(-)
 delete mode 100644 flake.lock

diff --git a/flake.lock b/flake.lock
deleted file mode 100644
index 5a9f9470a1f..00000000000
--- a/flake.lock
+++ /dev/null
@@ -1,170 +0,0 @@
-{
-  "nodes": {
-    "crane": {
-      "inputs": {
-        "flake-compat": [
-          "flake-compat"
-        ],
-        "flake-utils": [
-          "flake-utils"
-        ],
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rust-overlay": "rust-overlay"
-      },
-      "locked": {
-        "lastModified": 1681177078,
-        "narHash": "sha256-ZNIjBDou2GOabcpctiQykEQVkI8BDwk7TyvlWlI4myE=",
-        "owner": "ipetkov",
-        "repo": "crane",
-        "rev": "0c9f468ff00576577d83f5019a66c557ede5acf6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "ipetkov",
-        "repo": "crane",
-        "type": "github"
-      }
-    },
-    "fenix": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rust-analyzer-src": "rust-analyzer-src"
-      },
-      "locked": {
-        "lastModified": 1694499657,
-        "narHash": "sha256-u/fZtLtN7VcDrMMVrdsFy93PEkaiK+tNpJT9on4SGdU=",
-        "owner": "nix-community",
-        "repo": "fenix",
-        "rev": "2895ff377cbb3cb6f5dd92066734b0447cb04e20",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "fenix",
-        "type": "github"
-      }
-    },
-    "flake-compat": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1673956053,
-        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1681202837,
-        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "cfacdce06f30d2b68473a46042957675eebb3401",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1695559356,
-        "narHash": "sha256-kXZ1pUoImD9OEbPCwpTz4tHsNTr4CIyIfXb3ocuR8sI=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "261abe8a44a7e8392598d038d2e01f7b33cf26d0",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-23.05",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "crane": "crane",
-        "fenix": "fenix",
-        "flake-compat": "flake-compat",
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "rust-analyzer-src": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1694421477,
-        "narHash": "sha256-df6YZzR57VFzkOPwIohJfC0fRwgq6yUPbMJkKAtQyAE=",
-        "owner": "rust-lang",
-        "repo": "rust-analyzer",
-        "rev": "cc6c8209cbaf7df55013977cf5cc8488d6b7ff1c",
-        "type": "github"
-      },
-      "original": {
-        "owner": "rust-lang",
-        "ref": "nightly",
-        "repo": "rust-analyzer",
-        "type": "github"
-      }
-    },
-    "rust-overlay": {
-      "inputs": {
-        "flake-utils": [
-          "crane",
-          "flake-utils"
-        ],
-        "nixpkgs": [
-          "crane",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1694484610,
-        "narHash": "sha256-aeSDkp7fkAqtVjW3QUn7vq7BKNlFul/BiGgdv7rK+mA=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "c5b977a7e6a295697fa1f9c42174fd6313b38df4",
-        "type": "github"
-      },
-      "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "type": "github"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

From dbfca58a817ee1f1512e3e02138119f363c3d12b Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 25 Apr 2024 15:29:55 +0200
Subject: [PATCH 226/416] feat: add variable size sha256 (#4920)

# Description

## Problem\*

Resolves #4909

## Summary\*
Thanks to the sha256compression opcode, we can create conditionally the
blocks to be hashed. As a result there is no additional cost to support
variable input size for sha256, except of course that we pay for the
full input len (even if we hash less).


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../cryptographic_primitives/hashes.mdx       |  5 +-
 noir_stdlib/src/hash.nr                       |  1 +
 noir_stdlib/src/sha256.nr                     | 54 +++++++++++--------
 .../execution_success/sha256/src/main.nr      |  4 +-
 4 files changed, 41 insertions(+), 23 deletions(-)

diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
index 7329880c7a7..efa52b2c3f2 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -13,18 +13,21 @@ import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
 ## sha256
 
 Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
 
 #include_code sha256 noir_stdlib/src/hash.nr rust
 
 example:
+#include_code sha256_var test_programs/execution_success/sha256/src/main.nr rust
 
 ```rust
 fn main() {
     let x = [163, 117, 178, 149]; // some random bytes
-    let hash = std::hash::sha256(x);
+    let hash = std::sha256::sha256_var(x, 4);
 }
 ```
 
+
 <BlackBoxInfo />
 
 ## blake2s
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 26a9fa6c2c0..ef1cb0889d7 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -4,6 +4,7 @@ mod poseidon2;
 
 use crate::default::Default;
 use crate::uint128::U128;
+use crate::sha256::{digest, sha256_var};
 
 #[foreign(sha256)]
 // docs:start:sha256
diff --git a/noir_stdlib/src/sha256.nr b/noir_stdlib/src/sha256.nr
index 8ca6808568d..d856043fcfa 100644
--- a/noir_stdlib/src/sha256.nr
+++ b/noir_stdlib/src/sha256.nr
@@ -17,19 +17,42 @@ fn msg_u8_to_u32(msg: [u8; 64]) -> [u32; 16] {
 }
 // SHA-256 hash function
 pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
+    sha256_var(msg, N)
+}
+
+fn hash_final_block(msg_block: [u8; 64], mut state: [u32; 8]) -> [u8; 32] {
+    let mut out_h: [u8; 32] = [0; 32]; // Digest as sequence of bytes
+
+    // Hash final padded block
+    state = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), state);
+
+    // Return final hash as byte array
+    for j in 0..8 {
+        let h_bytes = (state[7 - j] as Field).to_le_bytes(4);
+        for k in 0..4 {
+            out_h[31 - 4*j - k] = h_bytes[k];
+        }
+    }
+
+    out_h
+}
+
+// Variable size SHA-256 hash
+pub fn sha256_var<N>(msg: [u8; N], message_size: u64) -> [u8; 32] {
     let mut msg_block: [u8; 64] = [0; 64];
     let mut h: [u32; 8] = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]; // Intermediate hash, starting with the canonical initial value
-    let mut out_h: [u8; 32] = [0; 32]; // Digest as sequence of bytes
     let mut i: u64 = 0; // Message byte pointer
     for k in 0..N {
-        // Populate msg_block
-        msg_block[i] = msg[k];
-        i = i + 1;
-        if i == 64 {
-            // Enough to hash block
-            h = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), h);
+        if k < message_size {
+            // Populate msg_block
+            msg_block[i] = msg[k];
+            i = i + 1;
+            if i == 64 {
+                // Enough to hash block
+                h = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), h);
 
-            i = 0;
+                i = 0;
+            }
         }
     }
     // Pad the rest such that we have a [u32; 2] block at the end representing the length
@@ -53,7 +76,7 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
         i = 0;
     }
 
-    let len = 8 * msg.len();
+    let len = 8 * message_size;
     let len_bytes = (len as Field).to_le_bytes(8);
     for _i in 0..64 {
         // In any case, fill blocks up with zeros until the last 64 (i.e. until i = 56).
@@ -67,16 +90,5 @@ pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
             i += 8;
         }
     }
-    // Hash final padded block
-    h = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), h);
-
-    // Return final hash as byte array
-    for j in 0..8 {
-        let h_bytes = (h[7 - j] as Field).to_le_bytes(4);
-        for k in 0..4 {
-            out_h[31 - 4*j - k] = h_bytes[k];
-        }
-    }
-
-    out_h
+    hash_final_block(msg_block, h)
 }
diff --git a/test_programs/execution_success/sha256/src/main.nr b/test_programs/execution_success/sha256/src/main.nr
index fd5340e2384..d4240ded8b3 100644
--- a/test_programs/execution_success/sha256/src/main.nr
+++ b/test_programs/execution_success/sha256/src/main.nr
@@ -14,6 +14,8 @@ use dep::std;
 fn main(x: Field, result: [u8; 32]) {
     // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
     // The padding is taken care of by the program
-    let digest = std::hash::sha256([x as u8]);
+    // docs:start:sha256_var
+    let digest = std::hash::sha256_var([x as u8], 1);
+    // docs:end:sha256_var
     assert(digest == result);
 }

From 7ea0e914625789e65b0d5908f7f0b76a9fd32652 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 25 Apr 2024 14:41:47 +0100
Subject: [PATCH 227/416] chore: rework workspace structure for utils crates
 (#4886)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR flattens a layer of nesting from our crate structure. I've
renamed `arena` to `noirc_arena` so we can publish to crates.io in the
future.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                         | 10 +++++-----
 Cargo.toml                                         | 14 ++++++++------
 compiler/{utils/arena => noirc_arena}/Cargo.toml   |  2 +-
 compiler/{utils/arena => noirc_arena}/src/lib.rs   |  0
 compiler/noirc_frontend/Cargo.toml                 |  2 +-
 compiler/noirc_frontend/src/hir/def_map/mod.rs     |  2 +-
 compiler/noirc_frontend/src/hir/type_check/mod.rs  |  4 ++--
 compiler/noirc_frontend/src/node_interner.rs       |  2 +-
 compiler/noirc_frontend/src/resolve_locations.rs   |  2 +-
 compiler/noirc_frontend/src/tests.rs               |  2 +-
 {compiler/utils => utils}/iter-extended/Cargo.toml |  0
 {compiler/utils => utils}/iter-extended/src/lib.rs |  0
 12 files changed, 21 insertions(+), 19 deletions(-)
 rename compiler/{utils/arena => noirc_arena}/Cargo.toml (86%)
 rename compiler/{utils/arena => noirc_arena}/src/lib.rs (100%)
 rename {compiler/utils => utils}/iter-extended/Cargo.toml (100%)
 rename {compiler/utils => utils}/iter-extended/src/lib.rs (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 8a8ccfdbf8a..eaed1c08bec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -233,10 +233,6 @@ version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
-[[package]]
-name = "arena"
-version = "0.28.0"
-
 [[package]]
 name = "ark-bls12-381"
 version = "0.4.0"
@@ -3099,6 +3095,10 @@ dependencies = [
  "wasm-bindgen-test",
 ]
 
+[[package]]
+name = "noirc_arena"
+version = "0.28.0"
+
 [[package]]
 name = "noirc_driver"
 version = "0.28.0"
@@ -3160,7 +3160,6 @@ name = "noirc_frontend"
 version = "0.28.0"
 dependencies = [
  "acvm",
- "arena",
  "base64 0.21.2",
  "chumsky",
  "fm",
@@ -3168,6 +3167,7 @@ dependencies = [
  "iter-extended",
  "lalrpop",
  "lalrpop-util",
+ "noirc_arena",
  "noirc_errors",
  "noirc_printable_type",
  "petgraph",
diff --git a/Cargo.toml b/Cargo.toml
index 108d179b9ca..ed0aef0d35b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,6 +4,7 @@ members = [
     # Aztec Macro crate for metaprogramming
     "aztec_macros",
     # Compiler crates
+    "compiler/noirc_arena",
     "compiler/noirc_evaluator",
     "compiler/noirc_frontend",
     "compiler/noirc_errors",
@@ -11,10 +12,7 @@ members = [
     "compiler/noirc_printable_type",
     "compiler/fm",
     "compiler/wasm",
-    # Utility crates used by the Noir compiler
-    "compiler/utils/arena",
-    "compiler/utils/iter-extended",
-    # Crates related to tooling built ontop of the Noir compiler
+    # Crates related to tooling built on top of the Noir compiler
     "tooling/backend_interface",
     "tooling/bb_abstraction_leaks",
     "tooling/lsp",
@@ -35,6 +33,8 @@ members = [
     "acvm-repo/brillig_vm",
     "acvm-repo/blackbox_solver",
     "acvm-repo/bn254_blackbox_solver",
+    # Utility crates
+    "utils/iter-extended",
 ]
 default-members = ["tooling/nargo_cli", "tooling/acvm_cli"]
 resolver = "2"
@@ -61,9 +61,8 @@ acvm_blackbox_solver = { version = "0.44.0", path = "acvm-repo/blackbox_solver",
 bn254_blackbox_solver = { version = "0.44.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
-arena = { path = "compiler/utils/arena" }
 fm = { path = "compiler/fm" }
-iter-extended = { path = "compiler/utils/iter-extended" }
+noirc_arena = { path = "compiler/noirc_arena" }
 noirc_driver = { path = "compiler/noirc_driver" }
 noirc_errors = { path = "compiler/noirc_errors" }
 noirc_evaluator = { path = "compiler/noirc_evaluator" }
@@ -80,6 +79,9 @@ noirc_abi = { path = "tooling/noirc_abi" }
 bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" }
 acvm_cli = { path = "tooling/acvm_cli" }
 
+# Misc utils crates
+iter-extended = { path = "utils/iter-extended" }
+
 # LSP
 async-lsp = { version = "0.1.0", default-features = false }
 lsp-types = "0.94.1"
diff --git a/compiler/utils/arena/Cargo.toml b/compiler/noirc_arena/Cargo.toml
similarity index 86%
rename from compiler/utils/arena/Cargo.toml
rename to compiler/noirc_arena/Cargo.toml
index f6bd764ee62..b94f997b7b9 100644
--- a/compiler/utils/arena/Cargo.toml
+++ b/compiler/noirc_arena/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "arena"
+name = "noirc_arena"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/utils/arena/src/lib.rs b/compiler/noirc_arena/src/lib.rs
similarity index 100%
rename from compiler/utils/arena/src/lib.rs
rename to compiler/noirc_arena/src/lib.rs
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index 84c9393fa37..0430d214d53 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -10,10 +10,10 @@ license.workspace = true
 
 [dependencies]
 acvm.workspace = true
+noirc_arena.workspace = true
 noirc_errors.workspace = true
 noirc_printable_type.workspace = true
 fm.workspace = true
-arena.workspace = true
 iter-extended.workspace = true
 chumsky.workspace = true
 thiserror.workspace = true
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 7c0090ff95b..590c2e3d6b6 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -5,8 +5,8 @@ use crate::macros_api::MacroProcessor;
 use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId};
 use crate::parser::{parse_program, ParsedModule, ParserError};
 use crate::token::{FunctionAttribute, SecondaryAttribute, TestScope};
-use arena::{Arena, Index};
 use fm::{FileId, FileManager};
+use noirc_arena::{Arena, Index};
 use noirc_errors::Location;
 use std::collections::{BTreeMap, HashMap};
 mod module_def;
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 44dab6dee3d..2a1ff1dd42c 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -672,7 +672,7 @@ pub mod test {
         }
 
         fn local_module_id(&self) -> LocalModuleId {
-            LocalModuleId(arena::Index::unsafe_zeroed())
+            LocalModuleId(noirc_arena::Index::unsafe_zeroed())
         }
 
         fn module_id(&self) -> ModuleId {
@@ -724,7 +724,7 @@ pub mod test {
         let mut def_maps = BTreeMap::new();
         let file = FileId::default();
 
-        let mut modules = arena::Arena::default();
+        let mut modules = noirc_arena::Arena::default();
         let location = Location::new(Default::default(), file);
         modules.insert(ModuleData::new(None, location, false));
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 9d3a79820dc..5e4fa3df6c5 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -2,9 +2,9 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::ops::Deref;
 
-use arena::{Arena, Index};
 use fm::FileId;
 use iter_extended::vecmap;
+use noirc_arena::{Arena, Index};
 use noirc_errors::{Location, Span, Spanned};
 use petgraph::algo::tarjan_scc;
 use petgraph::prelude::DiGraph;
diff --git a/compiler/noirc_frontend/src/resolve_locations.rs b/compiler/noirc_frontend/src/resolve_locations.rs
index b5f1b1d0c64..ac8c96a092e 100644
--- a/compiler/noirc_frontend/src/resolve_locations.rs
+++ b/compiler/noirc_frontend/src/resolve_locations.rs
@@ -1,4 +1,4 @@
-use arena::Index;
+use noirc_arena::Index;
 use noirc_errors::Location;
 
 use crate::hir_def::expr::HirExpression;
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 31bf2245b1f..c6cef568ed8 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -31,8 +31,8 @@ mod test {
         hir::def_map::{CrateDefMap, LocalModuleId},
         parse_program,
     };
-    use arena::Arena;
     use fm::FileManager;
+    use noirc_arena::Arena;
 
     pub(crate) fn has_parser_error(errors: &[(CompilationError, FileId)]) -> bool {
         errors.iter().any(|(e, _f)| matches!(e, CompilationError::ParseError(_)))
diff --git a/compiler/utils/iter-extended/Cargo.toml b/utils/iter-extended/Cargo.toml
similarity index 100%
rename from compiler/utils/iter-extended/Cargo.toml
rename to utils/iter-extended/Cargo.toml
diff --git a/compiler/utils/iter-extended/src/lib.rs b/utils/iter-extended/src/lib.rs
similarity index 100%
rename from compiler/utils/iter-extended/src/lib.rs
rename to utils/iter-extended/src/lib.rs

From 1ec9cdc7013e867db3672d27e3a6104e4b7e7eef Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 25 Apr 2024 18:19:43 +0100
Subject: [PATCH 228/416] feat: Add `#[inline(tag)]` attribute and codegen
 (#4913)

# Description

## Problem\*

Resolves #4910

## Summary\*

We add a new attribute `Inline(String)`. Currently we only support one
`InlineType` variant of `Never`. This PR also moves `InlineType` into
the monomorphization ast as its functionality is expected to be shared
across various frontend passes as well as the SSA/ACIR gen.

## Additional Context

I know there is some plans to split the AST off into its own crate as
per (https://github.com/noir-lang/noir/issues/4852). This change
shouldn't affect make the split much more dififcult as the evaluator
already depends on the AST as the issue mentions and this `InlineType`
is pretty isolated in its usage.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 66 +++++++++++--------
 .../src/ssa/function_builder/mod.rs           |  3 +-
 .../noirc_evaluator/src/ssa/ir/function.rs    | 27 +-------
 .../noirc_evaluator/src/ssa/opt/inlining.rs   |  2 +-
 .../src/ssa/ssa_gen/context.rs                |  5 +-
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  9 +--
 compiler/noirc_frontend/src/ast/function.rs   |  1 +
 .../src/hir/resolution/errors.rs              | 28 ++++++++
 .../src/hir/resolution/resolver.rs            | 24 ++++++-
 .../noirc_frontend/src/hir/type_check/mod.rs  |  4 +-
 .../noirc_frontend/src/hir_def/function.rs    |  4 +-
 compiler/noirc_frontend/src/lexer/token.rs    | 18 +++++
 .../src/monomorphization/ast.rs               | 61 ++++++++++++++++-
 .../src/monomorphization/mod.rs               | 14 ++--
 compiler/noirc_frontend/src/tests.rs          | 32 +++++++++
 .../inline_never_basic/Nargo.toml             |  7 ++
 .../inline_never_basic/Prover.toml            |  2 +
 .../inline_never_basic/src/main.nr            |  8 +++
 tooling/debugger/ignored-tests.txt            |  2 +-
 19 files changed, 240 insertions(+), 77 deletions(-)
 create mode 100644 test_programs/execution_success/inline_never_basic/Nargo.toml
 create mode 100644 test_programs/execution_success/inline_never_basic/Prover.toml
 create mode 100644 test_programs/execution_success/inline_never_basic/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 6c7d78acdea..63d1c1b564f 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -27,8 +27,8 @@ use crate::brillig::brillig_ir::artifact::{BrilligParameter, GeneratedBrillig};
 use crate::brillig::brillig_ir::BrilligContext;
 use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig};
 use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
-use crate::ssa::ir::function::InlineType;
 pub(crate) use acir_ir::generated_acir::GeneratedAcir;
+use noirc_frontend::monomorphization::ast::InlineType;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::OpcodeLocation;
@@ -385,12 +385,12 @@ impl<'a> Context<'a> {
         match function.runtime() {
             RuntimeType::Acir(inline_type) => {
                 match inline_type {
-                    InlineType::Fold => {}
                     InlineType::Inline => {
                         if function.id() != ssa.main_id {
                             panic!("ACIR function should have been inlined earlier if not marked otherwise");
                         }
                     }
+                    InlineType::Fold | InlineType::Never => {}
                 }
                 // We only want to convert entry point functions. This being `main` and those marked with `InlineType::Fold`
                 Ok(Some(self.convert_acir_main(function, ssa, brillig)?))
@@ -2610,25 +2610,22 @@ mod test {
         },
         FieldElement,
     };
+    use noirc_frontend::monomorphization::ast::InlineType;
 
     use crate::{
         brillig::Brillig,
         ssa::{
             acir_gen::acir_ir::generated_acir::BrilligStdlibFunc,
             function_builder::FunctionBuilder,
-            ir::{
-                function::{FunctionId, InlineType},
-                instruction::BinaryOp,
-                map::Id,
-                types::Type,
-            },
+            ir::{function::FunctionId, instruction::BinaryOp, map::Id, types::Type},
         },
     };
 
     fn build_basic_foo_with_return(
         builder: &mut FunctionBuilder,
         foo_id: FunctionId,
-        is_brillig_func: bool,
+        // `InlineType` can only exist on ACIR functions, so if the option is `None` we should generate a Brillig function
+        inline_type: Option<InlineType>,
     ) {
         // fn foo f1 {
         // b0(v0: Field, v1: Field):
@@ -2636,10 +2633,10 @@ mod test {
         //     constrain v2 == u1 0
         //     return v0
         // }
-        if is_brillig_func {
-            builder.new_brillig_function("foo".into(), foo_id);
+        if let Some(inline_type) = inline_type {
+            builder.new_function("foo".into(), foo_id, inline_type);
         } else {
-            builder.new_function("foo".into(), foo_id, InlineType::Fold);
+            builder.new_brillig_function("foo".into(), foo_id);
         }
         let foo_v0 = builder.add_parameter(Type::field());
         let foo_v1 = builder.add_parameter(Type::field());
@@ -2650,8 +2647,25 @@ mod test {
         builder.terminate_with_return(vec![foo_v0]);
     }
 
+    /// Check that each `InlineType` which prevents inlining functions generates code in the same manner
     #[test]
-    fn basic_call_with_outputs_assert() {
+    fn basic_calls_fold() {
+        basic_call_with_outputs_assert(InlineType::Fold);
+        call_output_as_next_call_input(InlineType::Fold);
+        basic_nested_call(InlineType::Fold);
+
+        call_output_as_next_call_input(InlineType::Never);
+        basic_nested_call(InlineType::Never);
+        basic_call_with_outputs_assert(InlineType::Never);
+    }
+
+    #[test]
+    #[should_panic]
+    fn call_without_inline_attribute() {
+        basic_call_with_outputs_assert(InlineType::Inline);
+    }
+
+    fn basic_call_with_outputs_assert(inline_type: InlineType) {
         // acir(inline) fn main f0 {
         //     b0(v0: Field, v1: Field):
         //       v2 = call f1(v0, v1)
@@ -2679,7 +2693,7 @@ mod test {
         builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, false);
+        build_basic_foo_with_return(&mut builder, foo_id, Some(inline_type));
 
         let ssa = builder.finish();
 
@@ -2745,8 +2759,7 @@ mod test {
         }
     }
 
-    #[test]
-    fn call_output_as_next_call_input() {
+    fn call_output_as_next_call_input(inline_type: InlineType) {
         // acir(inline) fn main f0 {
         //     b0(v0: Field, v1: Field):
         //       v3 = call f1(v0, v1)
@@ -2775,7 +2788,7 @@ mod test {
         builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, false);
+        build_basic_foo_with_return(&mut builder, foo_id, Some(inline_type));
 
         let ssa = builder.finish();
 
@@ -2794,8 +2807,7 @@ mod test {
         check_call_opcode(&main_opcodes[1], 1, vec![Witness(2), Witness(1)], vec![Witness(3)]);
     }
 
-    #[test]
-    fn basic_nested_call() {
+    fn basic_nested_call(inline_type: InlineType) {
         // SSA for the following Noir program:
         // fn main(x: Field, y: pub Field) {
         //     let z = func_with_nested_foo_call(x, y);
@@ -2851,7 +2863,7 @@ mod test {
         builder.new_function(
             "func_with_nested_foo_call".into(),
             func_with_nested_foo_call_id,
-            InlineType::Fold,
+            inline_type,
         );
         let func_with_nested_call_v0 = builder.add_parameter(Type::field());
         let func_with_nested_call_v1 = builder.add_parameter(Type::field());
@@ -2866,7 +2878,7 @@ mod test {
             .to_vec();
         builder.terminate_with_return(vec![foo_call[0]]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, false);
+        build_basic_foo_with_return(&mut builder, foo_id, Some(inline_type));
 
         let ssa = builder.finish();
 
@@ -2977,8 +2989,8 @@ mod test {
         builder.insert_call(bar, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, true);
-        build_basic_foo_with_return(&mut builder, bar_id, true);
+        build_basic_foo_with_return(&mut builder, foo_id, None);
+        build_basic_foo_with_return(&mut builder, bar_id, None);
 
         let ssa = builder.finish();
         let brillig = ssa.to_brillig(false);
@@ -3106,7 +3118,7 @@ mod test {
 
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, true);
+        build_basic_foo_with_return(&mut builder, foo_id, None);
 
         let ssa = builder.finish();
         // We need to generate  Brillig artifacts for the regular Brillig function and pass them to the ACIR generation pass.
@@ -3192,8 +3204,10 @@ mod test {
 
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, true);
-        build_basic_foo_with_return(&mut builder, bar_id, false);
+        // Build a Brillig function
+        build_basic_foo_with_return(&mut builder, foo_id, None);
+        // Build an ACIR function which has the same logic as the Brillig function above
+        build_basic_foo_with_return(&mut builder, bar_id, Some(InlineType::Fold));
 
         let ssa = builder.finish();
         // We need to generate  Brillig artifacts for the regular Brillig function and pass them to the ACIR generation pass.
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 75a427397b6..013462ed38c 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -4,6 +4,7 @@ use std::{borrow::Cow, rc::Rc};
 
 use acvm::FieldElement;
 use noirc_errors::Location;
+use noirc_frontend::monomorphization::ast::InlineType;
 
 use crate::ssa::ir::{
     basic_block::BasicBlockId,
@@ -17,7 +18,7 @@ use super::{
     ir::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
-        function::{InlineType, RuntimeType},
+        function::RuntimeType,
         instruction::{ConstrainError, InstructionId, Intrinsic},
     },
     ssa_gen::Ssa,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs
index 011bee36661..057786bf5ec 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs
@@ -1,6 +1,7 @@
 use std::collections::BTreeSet;
 
 use iter_extended::vecmap;
+use noirc_frontend::monomorphization::ast::InlineType;
 
 use super::basic_block::BasicBlockId;
 use super::dfg::DataFlowGraph;
@@ -17,18 +18,6 @@ pub(crate) enum RuntimeType {
     Brillig,
 }
 
-/// Represents how a RuntimeType::Acir function should be inlined.
-/// This type is only relevant for ACIR functions as we do not inline any Brillig functions
-#[derive(Default, Clone, Copy, PartialEq, Eq, Debug, Hash)]
-pub(crate) enum InlineType {
-    /// The most basic entry point can expect all its functions to be inlined.
-    /// All function calls are expected to be inlined into a single ACIR.
-    #[default]
-    Inline,
-    /// Functions marked as foldable will not be inlined and compiled separately into ACIR
-    Fold,
-}
-
 impl RuntimeType {
     /// Returns whether the runtime type represents an entry point.
     /// We return `false` for InlineType::Inline on default, which is true
@@ -36,10 +25,7 @@ impl RuntimeType {
     /// handling in any places where this function determines logic.
     pub(crate) fn is_entry_point(&self) -> bool {
         match self {
-            RuntimeType::Acir(inline_type) => match inline_type {
-                InlineType::Inline => false,
-                InlineType::Fold => true,
-            },
+            RuntimeType::Acir(inline_type) => inline_type.is_entry_point(),
             RuntimeType::Brillig => true,
         }
     }
@@ -163,15 +149,6 @@ impl std::fmt::Display for RuntimeType {
     }
 }
 
-impl std::fmt::Display for InlineType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            InlineType::Inline => write!(f, "inline"),
-            InlineType::Fold => write!(f, "fold"),
-        }
-    }
-}
-
 /// FunctionId is a reference for a function
 ///
 /// This Id is how each function refers to other functions
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index ead3cac071c..0b78d47fbb1 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -517,12 +517,12 @@ impl<'function> PerFunctionContext<'function> {
 #[cfg(test)]
 mod test {
     use acvm::FieldElement;
+    use noirc_frontend::monomorphization::ast::InlineType;
 
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
             basic_block::BasicBlockId,
-            function::InlineType,
             instruction::{BinaryOp, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index fdd17097d19..f2cc2ba53cc 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -11,8 +11,8 @@ use noirc_frontend::monomorphization::ast::{FuncId, Program};
 use crate::errors::RuntimeError;
 use crate::ssa::function_builder::FunctionBuilder;
 use crate::ssa::ir::basic_block::BasicBlockId;
+use crate::ssa::ir::function::FunctionId as IrFunctionId;
 use crate::ssa::ir::function::{Function, RuntimeType};
-use crate::ssa::ir::function::{FunctionId as IrFunctionId, InlineType};
 use crate::ssa::ir::instruction::BinaryOp;
 use crate::ssa::ir::instruction::Instruction;
 use crate::ssa::ir::map::AtomicCounter;
@@ -125,8 +125,7 @@ impl<'a> FunctionContext<'a> {
         if func.unconstrained {
             self.builder.new_brillig_function(func.name.clone(), id);
         } else {
-            let inline_type = if func.should_fold { InlineType::Fold } else { InlineType::Inline };
-            self.builder.new_function(func.name.clone(), id, inline_type);
+            self.builder.new_function(func.name.clone(), id, func.inline_type);
         }
         self.add_parameters_to_scope(&func.parameters);
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 79f7cda4ae2..ebde3dcf66e 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -12,10 +12,7 @@ use noirc_frontend::monomorphization::ast::{self, Expression, Program};
 
 use crate::{
     errors::{InternalError, RuntimeError},
-    ssa::{
-        function_builder::data_bus::DataBusBuilder,
-        ir::{function::InlineType, instruction::Intrinsic},
-    },
+    ssa::{function_builder::data_bus::DataBusBuilder, ir::instruction::Intrinsic},
 };
 
 use self::{
@@ -61,9 +58,7 @@ pub(crate) fn generate_ssa(
         if force_brillig_runtime || main.unconstrained {
             RuntimeType::Brillig
         } else {
-            let main_inline_type =
-                if main.should_fold { InlineType::Fold } else { InlineType::Inline };
-            RuntimeType::Acir(main_inline_type)
+            RuntimeType::Acir(main.inline_type)
         },
         &context,
     );
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index 9816218c5f7..9115178671e 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -109,6 +109,7 @@ impl From<FunctionDefinition> for NoirFunction {
             Some(FunctionAttribute::Oracle(_)) => FunctionKind::Oracle,
             Some(FunctionAttribute::Recursive) => FunctionKind::Recursive,
             Some(FunctionAttribute::Fold) => FunctionKind::Normal,
+            Some(FunctionAttribute::Inline(_)) => FunctionKind::Normal,
             None => FunctionKind::Normal,
         };
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 0fac6f96086..70e7a8e40f2 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -86,6 +86,10 @@ pub enum ResolverError {
     JumpInConstrainedFn { is_break: bool, span: Span },
     #[error("break/continue are only allowed within loops")]
     JumpOutsideLoop { is_break: bool, span: Span },
+    #[error("#[inline(tag)] attribute is only allowed on constrained functions")]
+    InlineAttributeOnUnconstrained { ident: Ident },
+    #[error("#[fold] attribute is only allowed on constrained functions")]
+    FoldAttributeOnUnconstrained { ident: Ident },
 }
 
 impl ResolverError {
@@ -340,6 +344,30 @@ impl From<ResolverError> for Diagnostic {
                     span,
                 )
             },
+            ResolverError::InlineAttributeOnUnconstrained { ident } => {
+                let name = &ident.0.contents;
+
+                let mut diag = Diagnostic::simple_error(
+                    format!("misplaced #[inline(tag)] attribute on unconstrained function {name}. Only allowed on constrained functions"),
+                    "misplaced #[inline(tag)] attribute".to_string(),
+                    ident.0.span(),
+                );
+
+                diag.add_note("The `#[inline(tag)]` attribute specifies to the compiler whether it should diverge from auto-inlining constrained functions".to_owned());
+                diag
+            }
+            ResolverError::FoldAttributeOnUnconstrained { ident } => {
+                let name = &ident.0.contents;
+
+                let mut diag = Diagnostic::simple_error(
+                    format!("misplaced #[fold] attribute on unconstrained function {name}. Only allowed on constrained functions"),
+                    "misplaced #[fold] attribute".to_string(),
+                    ident.0.span(),
+                );
+
+                diag.add_note("The `#[fold]` attribute specifies whether a constrained function should be treated as a separate circuit rather than inlined into the program entry point".to_owned());
+                diag
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 8e29f8f9fce..b17cd50564e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -926,7 +926,23 @@ impl<'a> Resolver<'a> {
         let name_ident = HirIdent::non_trait_method(id, location);
 
         let attributes = func.attributes().clone();
+        let has_inline_attribute = attributes.is_inline();
         let should_fold = attributes.is_foldable();
+        if !self.inline_attribute_allowed(func) {
+            if has_inline_attribute {
+                self.push_err(ResolverError::InlineAttributeOnUnconstrained {
+                    ident: func.name_ident().clone(),
+                });
+            } else if should_fold {
+                self.push_err(ResolverError::FoldAttributeOnUnconstrained {
+                    ident: func.name_ident().clone(),
+                });
+            }
+        }
+        // Both the #[fold] and #[inline(tag)] alter a function's inline type and code generation in similar ways.
+        // In certain cases such as type checking (for which the following flag will be used) both attributes
+        // indicate we should code generate in the same way. Thus, we unify the attributes into one flag here.
+        let has_inline_or_fold_attribute = has_inline_attribute || should_fold;
 
         let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
         let mut parameters = vec![];
@@ -1021,7 +1037,7 @@ impl<'a> Resolver<'a> {
             has_body: !func.def.body.is_empty(),
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point: self.is_entry_point_function(func),
-            should_fold,
+            has_inline_or_fold_attribute,
         }
     }
 
@@ -1057,6 +1073,12 @@ impl<'a> Resolver<'a> {
         }
     }
 
+    fn inline_attribute_allowed(&self, func: &NoirFunction) -> bool {
+        // Inline attributes are only relevant for constrained functions
+        // as all unconstrained functions are not inlined
+        !func.def.is_unconstrained
+    }
+
     fn declare_numeric_generics(&mut self, params: &[Type], return_type: &Type) {
         if self.generics.is_empty() {
             return;
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 2a1ff1dd42c..03ebb44fa1f 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -173,7 +173,7 @@ fn check_if_type_is_valid_for_program_input(
 ) {
     let meta = type_checker.interner.function_meta(&func_id);
     if (meta.is_entry_point && !param.1.is_valid_for_program_input())
-        || (meta.should_fold && !param.1.is_valid_non_inlined_function_input())
+        || (meta.has_inline_or_fold_attribute && !param.1.is_valid_non_inlined_function_input())
     {
         let span = param.0.span();
         errors.push(TypeCheckError::InvalidTypeForEntryPoint { span });
@@ -545,7 +545,7 @@ pub mod test {
             trait_constraints: Vec::new(),
             direct_generics: Vec::new(),
             is_entry_point: true,
-            should_fold: false,
+            has_inline_or_fold_attribute: false,
         };
         interner.push_fn_meta(func_meta, func_id);
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 67b6412a21c..57d3038a135 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -126,8 +126,8 @@ pub struct FuncMeta {
     pub is_entry_point: bool,
 
     /// True if this function is marked with an attribute
-    /// that indicates it should not be inlined, such as for folding.
-    pub should_fold: bool,
+    /// that indicates it should not be inlined, such as `fold` or `inline(never)`
+    pub has_inline_or_fold_attribute: bool,
 }
 
 impl FuncMeta {
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 0242fc7e7ff..82e17ac3912 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -581,6 +581,10 @@ impl Attributes {
     pub fn is_foldable(&self) -> bool {
         self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_foldable())
     }
+
+    pub fn is_inline(&self) -> bool {
+        self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_inline())
+    }
 }
 
 /// An Attribute can be either a Primary Attribute or a Secondary Attribute
@@ -641,6 +645,10 @@ impl Attribute {
             ["test"] => Attribute::Function(FunctionAttribute::Test(TestScope::None)),
             ["recursive"] => Attribute::Function(FunctionAttribute::Recursive),
             ["fold"] => Attribute::Function(FunctionAttribute::Fold),
+            ["inline", tag] => {
+                validate(tag)?;
+                Attribute::Function(FunctionAttribute::Inline(tag.to_string()))
+            }
             ["test", name] => {
                 validate(name)?;
                 let malformed_scope =
@@ -693,6 +701,7 @@ pub enum FunctionAttribute {
     Test(TestScope),
     Recursive,
     Fold,
+    Inline(String),
 }
 
 impl FunctionAttribute {
@@ -725,6 +734,13 @@ impl FunctionAttribute {
     pub fn is_foldable(&self) -> bool {
         matches!(self, FunctionAttribute::Fold)
     }
+
+    /// Check whether we have an `inline` attribute
+    /// Although we also do not want to inline foldable functions,
+    /// we keep the two attributes distinct for clarity.
+    pub fn is_inline(&self) -> bool {
+        matches!(self, FunctionAttribute::Inline(_))
+    }
 }
 
 impl fmt::Display for FunctionAttribute {
@@ -736,6 +752,7 @@ impl fmt::Display for FunctionAttribute {
             FunctionAttribute::Oracle(ref k) => write!(f, "#[oracle({k})]"),
             FunctionAttribute::Recursive => write!(f, "#[recursive]"),
             FunctionAttribute::Fold => write!(f, "#[fold]"),
+            FunctionAttribute::Inline(ref k) => write!(f, "#[inline({k})]"),
         }
     }
 }
@@ -781,6 +798,7 @@ impl AsRef<str> for FunctionAttribute {
             FunctionAttribute::Test { .. } => "",
             FunctionAttribute::Recursive => "",
             FunctionAttribute::Fold => "",
+            FunctionAttribute::Inline(string) => string,
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 434cc922a05..dc43f53e038 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -5,8 +5,11 @@ use noirc_errors::{
     Location,
 };
 
-use crate::ast::{BinaryOpKind, Distinctness, IntegerBitSize, Signedness, Visibility};
 use crate::hir_def::function::FunctionSignature;
+use crate::{
+    ast::{BinaryOpKind, Distinctness, IntegerBitSize, Signedness, Visibility},
+    token::{Attributes, FunctionAttribute},
+};
 
 /// The monomorphized AST is expression-based, all statements are also
 /// folded into this expression enum. Compared to the HIR, the monomorphized
@@ -200,6 +203,60 @@ pub enum LValue {
 
 pub type Parameters = Vec<(LocalId, /*mutable:*/ bool, /*name:*/ String, Type)>;
 
+/// Represents how an Acir function should be inlined.
+/// This type is only relevant for ACIR functions as we do not inline any Brillig functions
+#[derive(Default, Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum InlineType {
+    /// The most basic entry point can expect all its functions to be inlined.
+    /// All function calls are expected to be inlined into a single ACIR.
+    #[default]
+    Inline,
+    /// Functions marked as foldable will not be inlined and compiled separately into ACIR
+    Fold,
+    /// Similar to `Fold`, these functions will not be inlined and compile separately into ACIR.
+    /// They are different from `Fold` though as they are expected to be inlined into the program
+    /// entry point before being used in the backend.
+    Never,
+}
+
+impl From<&Attributes> for InlineType {
+    fn from(attributes: &Attributes) -> Self {
+        attributes.function.as_ref().map_or(InlineType::default(), |func_attribute| {
+            match func_attribute {
+                FunctionAttribute::Fold => InlineType::Fold,
+                FunctionAttribute::Inline(tag) => {
+                    if tag == "never" {
+                        InlineType::Never
+                    } else {
+                        InlineType::default()
+                    }
+                }
+                _ => InlineType::default(),
+            }
+        })
+    }
+}
+
+impl InlineType {
+    pub fn is_entry_point(&self) -> bool {
+        match self {
+            InlineType::Inline => false,
+            InlineType::Fold => true,
+            InlineType::Never => true,
+        }
+    }
+}
+
+impl std::fmt::Display for InlineType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InlineType::Inline => write!(f, "inline"),
+            InlineType::Fold => write!(f, "fold"),
+            InlineType::Never => write!(f, "inline(never)"),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Hash)]
 pub struct Function {
     pub id: FuncId,
@@ -210,7 +267,7 @@ pub struct Function {
 
     pub return_type: Type,
     pub unconstrained: bool,
-    pub should_fold: bool,
+    pub inline_type: InlineType,
     pub func_sig: FunctionSignature,
 }
 
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index b130af9d125..b5754897d3f 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -30,6 +30,7 @@ use std::{
     unreachable,
 };
 
+use self::ast::InlineType;
 use self::debug_types::DebugTypeTracker;
 use self::{
     ast::{Definition, FuncId, Function, LocalId, Program},
@@ -132,7 +133,7 @@ pub fn monomorphize_debug(
         .finished_functions
         .iter()
         .flat_map(|(_, f)| {
-            if f.should_fold || f.id == Program::main_id() {
+            if f.inline_type.is_entry_point() || f.id == Program::main_id() {
                 Some(f.func_sig.clone())
             } else {
                 None
@@ -304,7 +305,8 @@ impl<'interner> Monomorphizer<'interner> {
         let return_type = Self::convert_type(return_type, meta.location)?;
         let unconstrained = modifiers.is_unconstrained;
 
-        let should_fold = meta.should_fold;
+        let attributes = self.interner.function_attributes(&f);
+        let inline_type = InlineType::from(attributes);
 
         let parameters = self.parameters(&meta.parameters)?;
         let body = self.expr(body_expr_id)?;
@@ -315,7 +317,7 @@ impl<'interner> Monomorphizer<'interner> {
             body,
             return_type,
             unconstrained,
-            should_fold,
+            inline_type,
             func_sig,
         };
 
@@ -1398,7 +1400,7 @@ impl<'interner> Monomorphizer<'interner> {
             body,
             return_type,
             unconstrained,
-            should_fold: false,
+            inline_type: InlineType::default(),
             func_sig: FunctionSignature::default(),
         };
         self.push_function(id, function);
@@ -1524,7 +1526,7 @@ impl<'interner> Monomorphizer<'interner> {
             body,
             return_type,
             unconstrained,
-            should_fold: false,
+            inline_type: InlineType::default(),
             func_sig: FunctionSignature::default(),
         };
         self.push_function(id, function);
@@ -1649,7 +1651,7 @@ impl<'interner> Monomorphizer<'interner> {
             body,
             return_type,
             unconstrained,
-            should_fold: false,
+            inline_type: InlineType::default(),
             func_sig: FunctionSignature::default(),
         };
         self.push_function(id, function);
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index c6cef568ed8..5d0f2472a43 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1282,4 +1282,36 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         "#;
         assert_eq!(get_program_errors(src).len(), 0);
     }
+
+    #[test]
+    fn deny_inline_attribute_on_unconstrained() {
+        let src = r#"
+            #[inline(never)]
+            unconstrained fn foo(x: Field, y: Field) {
+                assert(x != y);
+            }
+        "#;
+        let errors = get_program_errors(src);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            errors[0].0,
+            CompilationError::ResolverError(ResolverError::InlineAttributeOnUnconstrained { .. })
+        ));
+    }
+
+    #[test]
+    fn deny_fold_attribute_on_unconstrained() {
+        let src = r#"
+            #[fold]
+            unconstrained fn foo(x: Field, y: Field) {
+                assert(x != y);
+            }
+        "#;
+        let errors = get_program_errors(src);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            errors[0].0,
+            CompilationError::ResolverError(ResolverError::FoldAttributeOnUnconstrained { .. })
+        ));
+    }
 }
diff --git a/test_programs/execution_success/inline_never_basic/Nargo.toml b/test_programs/execution_success/inline_never_basic/Nargo.toml
new file mode 100644
index 00000000000..16691770d76
--- /dev/null
+++ b/test_programs/execution_success/inline_never_basic/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "inline_never_basic"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/inline_never_basic/Prover.toml b/test_programs/execution_success/inline_never_basic/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/inline_never_basic/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/inline_never_basic/src/main.nr b/test_programs/execution_success/inline_never_basic/src/main.nr
new file mode 100644
index 00000000000..1922aaedb6c
--- /dev/null
+++ b/test_programs/execution_success/inline_never_basic/src/main.nr
@@ -0,0 +1,8 @@
+fn main(x: Field, y: pub Field) {
+    basic_check(x, y);
+}
+
+#[inline(never)]
+fn basic_check(x: Field, y: Field) {
+    assert(x != y);
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 3b63f8d5542..8f49fe273e1 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -17,4 +17,4 @@ fold_basic_nested_call
 fold_call_witness_condition
 fold_after_inlined_calls
 fold_numeric_generic_poseidon
-
+inline_never_basic

From c4b03691feca17ef268acab523292f3051f672ea Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Fri, 26 Apr 2024 17:55:02 +0200
Subject: [PATCH 229/416] feat!: Bit shift is restricted to u8 right operand
 (#4907)

# Description

## Problem\*

Resolves #4841

## Summary\*
bit shift now requires the number of bits to be u8.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 .github/workflows/publish-nargo.yml           |  2 +-
 acvm-repo/brillig_vm/src/arithmetic.rs        |  4 ++-
 .../src/brillig/brillig_gen/brillig_block.rs  | 14 ++++++---
 .../src/brillig/brillig_ir/instructions.rs    |  6 ----
 .../src/ssa/function_builder/mod.rs           |  7 ++++-
 .../src/ssa/opt/remove_bit_shifts.rs          |  2 +-
 .../src/ssa/ssa_gen/context.rs                | 30 ++++---------------
 .../src/hir/type_check/errors.rs              |  5 +++-
 .../noirc_frontend/src/hir/type_check/expr.rs | 30 +++++++++++++++++--
 docs/docs/noir/concepts/ops.md                |  4 +--
 noir_stdlib/src/ops.nr                        | 28 ++++++++---------
 noir_stdlib/src/sha512.nr                     |  2 +-
 noir_stdlib/src/uint128.nr                    | 12 ++++----
 .../src/main.nr                               |  8 ++---
 .../bit_shifts_comptime/src/main.nr           |  2 +-
 .../bit_shifts_runtime/src/main.nr            |  8 ++---
 .../brillig_bit_shifts_runtime/src/main.nr    | 12 ++++----
 .../operator_overloading/src/main.nr          | 12 ++++----
 .../execution_success/regression/src/main.nr  |  2 +-
 .../execution_success/u128/src/main.nr        | 10 +++----
 20 files changed, 108 insertions(+), 92 deletions(-)

diff --git a/.github/workflows/publish-nargo.yml b/.github/workflows/publish-nargo.yml
index 85010503b00..26a4c701c5b 100644
--- a/.github/workflows/publish-nargo.yml
+++ b/.github/workflows/publish-nargo.yml
@@ -23,7 +23,7 @@ permissions:
 
 jobs:
   build-apple-darwin:
-    runs-on: macos-latest
+    runs-on: macos-12
     env:
       CROSS_CONFIG: ${{ github.workspace }}/.github/Cross.toml
       NIGHTLY_RELEASE: ${{ inputs.tag == '' }}
diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
index 2107d10c093..c17c019d11c 100644
--- a/acvm-repo/brillig_vm/src/arithmetic.rs
+++ b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -71,7 +71,9 @@ pub(crate) fn evaluate_binary_int_op(
             }
         }
     })?;
-    let rhs = rhs.expect_integer_with_bit_size(bit_size).map_err(|err| match err {
+    let rhs_bit_size =
+        if op == &BinaryIntOp::Shl || op == &BinaryIntOp::Shr { 8 } else { bit_size };
+    let rhs = rhs.expect_integer_with_bit_size(rhs_bit_size).map_err(|err| match err {
         MemoryTypeError::MismatchedBitSize { value_bit_size, expected_bit_size } => {
             BrilligArithmeticError::MismatchedRhsBitSize {
                 rhs_bit_size: value_bit_size,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 22407fc5695..8dc7ccb9ac0 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1279,8 +1279,11 @@ impl<'block> BrilligBlock<'block> {
         dfg: &DataFlowGraph,
         result_variable: SingleAddrVariable,
     ) {
-        let binary_type =
-            type_of_binary_operation(dfg[binary.lhs].get_type(), dfg[binary.rhs].get_type());
+        let binary_type = type_of_binary_operation(
+            dfg[binary.lhs].get_type(),
+            dfg[binary.rhs].get_type(),
+            binary.operator,
+        );
 
         let left = self.convert_ssa_single_addr_value(binary.lhs, dfg);
         let right = self.convert_ssa_single_addr_value(binary.rhs, dfg);
@@ -1766,7 +1769,7 @@ impl<'block> BrilligBlock<'block> {
 }
 
 /// Returns the type of the operation considering the types of the operands
-pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type {
+pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type, op: BinaryOp) -> Type {
     match (lhs_type, rhs_type) {
         (_, Type::Function) | (Type::Function, _) => {
             unreachable!("Functions are invalid in binary operations")
@@ -1782,12 +1785,15 @@ pub(crate) fn type_of_binary_operation(lhs_type: &Type, rhs_type: &Type) -> Type
         }
         // If both sides are numeric type, then we expect their types to be
         // the same.
-        (Type::Numeric(lhs_type), Type::Numeric(rhs_type)) => {
+        (Type::Numeric(lhs_type), Type::Numeric(rhs_type))
+            if op != BinaryOp::Shl && op != BinaryOp::Shr =>
+        {
             assert_eq!(
                 lhs_type, rhs_type,
                 "lhs and rhs types in a binary operation are always the same but got {lhs_type} and {rhs_type}"
             );
             Type::Numeric(*lhs_type)
         }
+        _ => lhs_type.clone(),
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 901ccc58036..dc160ce6a66 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -75,12 +75,6 @@ impl BrilligContext {
         result: SingleAddrVariable,
         operation: BrilligBinaryOp,
     ) {
-        assert!(
-            lhs.bit_size == rhs.bit_size,
-            "Not equal bit size for lhs and rhs: lhs {}, rhs {}",
-            lhs.bit_size,
-            rhs.bit_size
-        );
         let is_field_op = lhs.bit_size == FieldElement::max_num_bits();
         let expected_result_bit_size =
             BrilligContext::binary_result_bit_size(operation, lhs.bit_size);
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 013462ed38c..091ab294edc 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -230,7 +230,12 @@ impl FunctionBuilder {
     ) -> ValueId {
         let lhs_type = self.type_of_value(lhs);
         let rhs_type = self.type_of_value(rhs);
-        assert_eq!(lhs_type, rhs_type, "ICE - Binary instruction operands must have the same type");
+        if operator != BinaryOp::Shl && operator != BinaryOp::Shr {
+            assert_eq!(
+                lhs_type, rhs_type,
+                "ICE - Binary instruction operands must have the same type"
+            );
+        }
         let instruction = Instruction::Binary(Binary { lhs, rhs, operator });
         self.insert_instruction(instruction, None).first()
     }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index 1eb1e20d41d..81e3023f3f8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -117,7 +117,7 @@ impl Context<'_> {
         } else {
             // we use a predicate to nullify the result in case of overflow
             let bit_size_var =
-                self.numeric_constant(FieldElement::from(bit_size as u128), typ.clone());
+                self.numeric_constant(FieldElement::from(bit_size as u128), Type::unsigned(8));
             let overflow = self.insert_binary(rhs, BinaryOp::Lt, bit_size_var);
             let predicate = self.insert_cast(overflow, typ.clone());
             // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index f2cc2ba53cc..f7ecdc8870d 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -344,7 +344,7 @@ impl<'a> FunctionContext<'a> {
                         self.insert_safe_cast(result, result_type, location)
                     }
                     BinaryOpKind::ShiftLeft | BinaryOpKind::ShiftRight => {
-                        self.check_shift_overflow(result, rhs, bit_size, location, true)
+                        self.check_shift_overflow(result, rhs, bit_size, location)
                     }
                     _ => unreachable!("operator {} should not overflow", operator),
                 }
@@ -408,7 +408,7 @@ impl<'a> FunctionContext<'a> {
                             }
                         }
 
-                        self.check_shift_overflow(result, rhs, bit_size, location, false);
+                        self.check_shift_overflow(result, rhs, bit_size, location);
                     }
 
                     _ => unreachable!("operator {} should not overflow", operator),
@@ -430,32 +430,12 @@ impl<'a> FunctionContext<'a> {
         rhs: ValueId,
         bit_size: u32,
         location: Location,
-        is_signed: bool,
     ) -> ValueId {
         let one = self.builder.numeric_constant(FieldElement::one(), Type::bool());
-        let rhs = if is_signed {
-            self.insert_safe_cast(rhs, Type::unsigned(bit_size), location)
-        } else {
-            rhs
-        };
-        // Bit-shift with a negative number is an overflow
-        if is_signed {
-            // We compute the sign of rhs.
-            let half_width = self.builder.numeric_constant(
-                FieldElement::from(2_i128.pow(bit_size - 1)),
-                Type::unsigned(bit_size),
-            );
-            let sign = self.builder.insert_binary(rhs, BinaryOp::Lt, half_width);
-            self.builder.set_location(location).insert_constrain(
-                sign,
-                one,
-                Some("attempt to bit-shift with overflow".to_owned().into()),
-            );
-        }
+        assert!(self.builder.current_function.dfg.type_of_value(rhs) == Type::unsigned(8));
 
-        let max = self
-            .builder
-            .numeric_constant(FieldElement::from(bit_size as i128), Type::unsigned(bit_size));
+        let max =
+            self.builder.numeric_constant(FieldElement::from(bit_size as i128), Type::unsigned(8));
         let overflow = self.builder.insert_binary(rhs, BinaryOp::Lt, max);
         self.builder.set_location(location).insert_constrain(
             overflow,
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 6c2a1945283..9678bb8c9b9 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -80,6 +80,8 @@ pub enum TypeCheckError {
     FieldModulo { span: Span },
     #[error("Fields cannot be compared, try casting to an integer first")]
     FieldComparison { span: Span },
+    #[error("The bit count in a bit-shift operation must fit in a u8, try casting the right hand side into a u8 first")]
+    InvalidShiftSize { span: Span },
     #[error("The number of bits to use for this bitwise operation is ambiguous. Either the operand's type or return type should be specified")]
     AmbiguousBitWidth { span: Span },
     #[error("Error with additional context")]
@@ -234,7 +236,8 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
             | TypeCheckError::UnconstrainedSliceReturnToConstrained { span }
             | TypeCheckError::NonConstantSliceLength { span }
-            | TypeCheckError::StringIndexAssign { span } => {
+            | TypeCheckError::StringIndexAssign { span }
+            | TypeCheckError::InvalidShiftSize { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 7b30777c3ba..9b40c959981 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -1,7 +1,8 @@
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
-use crate::ast::{BinaryOpKind, UnaryOp};
+use crate::ast::{BinaryOpKind, IntegerBitSize, UnaryOp};
+use crate::macros_api::Signedness;
 use crate::{
     hir::{resolution::resolver::verify_mutable_reference, type_check::errors::Source},
     hir_def::{
@@ -1129,11 +1130,30 @@ impl<'interner> TypeChecker<'interner> {
                 if let TypeBinding::Bound(binding) = &*int.borrow() {
                     return self.infix_operand_type_rules(binding, op, other, span);
                 }
-
+                if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
+                    self.unify(
+                        rhs_type,
+                        &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+                        || TypeCheckError::InvalidShiftSize { span },
+                    );
+                    let use_impl = if lhs_type.is_numeric() {
+                        let integer_type = Type::polymorphic_integer(self.interner);
+                        self.bind_type_variables_for_infix(lhs_type, op, &integer_type, span)
+                    } else {
+                        true
+                    };
+                    return Ok((lhs_type.clone(), use_impl));
+                }
                 let use_impl = self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
                 Ok((other.clone(), use_impl))
             }
             (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => {
+                if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
+                    if *sign_y != Signedness::Unsigned || *bit_width_y != IntegerBitSize::Eight {
+                        return Err(TypeCheckError::InvalidShiftSize { span });
+                    }
+                    return Ok((Integer(*sign_x, *bit_width_x), false));
+                }
                 if sign_x != sign_y {
                     return Err(TypeCheckError::IntegerSignedness {
                         sign_x: *sign_x,
@@ -1165,6 +1185,12 @@ impl<'interner> TypeChecker<'interner> {
             (Bool, Bool) => Ok((Bool, false)),
 
             (lhs, rhs) => {
+                if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
+                    if rhs == &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight) {
+                        return Ok((lhs.clone(), true));
+                    }
+                    return Err(TypeCheckError::InvalidShiftSize { span });
+                }
                 self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource {
                     expected: lhs.clone(),
                     actual: rhs.clone(),
diff --git a/docs/docs/noir/concepts/ops.md b/docs/docs/noir/concepts/ops.md
index 60425cb8994..c35c36c38a9 100644
--- a/docs/docs/noir/concepts/ops.md
+++ b/docs/docs/noir/concepts/ops.md
@@ -30,8 +30,8 @@ sidebar_position: 3
 | ^         |              XOR two private input types together              |                  Types must be integer |
 | &         |              AND two private input types together              |                  Types must be integer |
 | \|        |              OR two private input types together               |                  Types must be integer |
-| \<\<        |        Left shift an integer by another integer amount         |                  Types must be integer |
-| >>        |        Right shift an integer by another integer amount        |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
 | !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
 | \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
 | \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index d855e794fb4..ad65a4e11fe 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -126,30 +126,30 @@ impl BitXor for i64 { fn bitxor(self, other: i64) -> i64 { self ^ other } }
 
 // docs:start:shl-trait
 trait Shl {
-    fn shl(self, other: Self) -> Self;
+    fn shl(self, other: u8) -> Self;
 }
 // docs:end:shl-trait
 
-impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
-impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+impl Shl for u32 { fn shl(self, other: u8) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u8) -> u64 { self << other } }
 impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
-impl Shl for u1 { fn shl(self, other: u1) -> u1 { self << other } }
+impl Shl for u1 { fn shl(self, other: u8) -> u1 { self << other } }
 
-impl Shl for i8 { fn shl(self, other: i8) -> i8 { self << other } }
-impl Shl for i32 { fn shl(self, other: i32) -> i32 { self << other } }
-impl Shl for i64 { fn shl(self, other: i64) -> i64 { self << other } }
+impl Shl for i8 { fn shl(self, other: u8) -> i8 { self << other } }
+impl Shl for i32 { fn shl(self, other: u8) -> i32 { self << other } }
+impl Shl for i64 { fn shl(self, other: u8) -> i64 { self << other } }
 
 // docs:start:shr-trait
 trait Shr {
-    fn shr(self, other: Self) -> Self;
+    fn shr(self, other: u8) -> Self;
 }
 // docs:end:shr-trait
 
-impl Shr for u64 { fn shr(self, other: u64) -> u64 { self >> other } }
-impl Shr for u32 { fn shr(self, other: u32) -> u32 { self >> other } }
+impl Shr for u64 { fn shr(self, other: u8) -> u64 { self >> other } }
+impl Shr for u32 { fn shr(self, other: u8) -> u32 { self >> other } }
 impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
-impl Shr for u1 { fn shr(self, other: u1) -> u1 { self >> other } }
+impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
 
-impl Shr for i8 { fn shr(self, other: i8) -> i8 { self >> other } }
-impl Shr for i32 { fn shr(self, other: i32) -> i32 { self >> other } }
-impl Shr for i64 { fn shr(self, other: i64) -> i64 { self >> other } }
+impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
+impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
+impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index a766ae50d55..0f8ffcfcb1c 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -2,7 +2,7 @@
 // 64 bytes.
 // Internal functions act on 64-bit unsigned integers for simplicity.
 // Auxiliary mappings; names as in FIPS PUB 180-4
-fn rotr64(a: u64, b: u64) -> u64 // 64-bit right rotation
+fn rotr64(a: u64, b: u8) -> u64 // 64-bit right rotation
 {
     // None of the bits overlap between `(a >> b)` and `(a << (64 - b))`
     // Addition is then equivalent to OR, with fewer constraints.
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index b91ed5c4cb2..d0f38079e6f 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -256,9 +256,9 @@ impl BitXor for U128 {
 }
 
 impl Shl for U128 { 
-    fn shl(self, other: U128) -> U128 { 
-        assert(other < U128::from_u64s_le(128,0), "attempt to shift left with overflow");
-        let exp_bits = other.lo.to_be_bits(7);
+    fn shl(self, other: u8) -> U128 { 
+        assert(other < 128, "attempt to shift left with overflow");
+        let exp_bits = (other as Field).to_be_bits(7);
 
         let mut r: Field = 2;
         let mut y: Field = 1;
@@ -271,9 +271,9 @@ impl Shl for U128 {
 }
 
 impl Shr for U128 { 
-    fn shr(self, other: U128) -> U128 { 
-        assert(other < U128::from_u64s_le(128,0), "attempt to shift right with overflow");
-        let exp_bits = other.lo.to_be_bits(7);
+    fn shr(self, other: u8) -> U128 { 
+        assert(other < 128, "attempt to shift right with overflow");
+        let exp_bits = (other as Field).to_be_bits(7);
 
         let mut r: Field = 2;
         let mut y: Field = 1;
diff --git a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
index a873bcd5dbd..7d3f9459598 100644
--- a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
@@ -23,8 +23,8 @@ fn main() {
     assert((x | y) == or(x, y));
     // TODO SSA => ACIR has some issues with xor ops
     assert(check_xor(x, y, 4));
-    assert((x >> y) == shr(x, y));
-    assert((x << y) == shl(x, y));
+    assert((x >> y as u8) == shr(x, y as u8));
+    assert((x << y as u8) == shl(x, y as u8));
 }
 
 unconstrained fn add(x: u32, y: u32) -> u32 {
@@ -67,11 +67,11 @@ unconstrained fn check_xor(x: u32, y: u32, result: u32) -> bool {
     (x ^ y) == result
 }
 
-unconstrained fn shr(x: u32, y: u32) -> u32 {
+unconstrained fn shr(x: u32, y: u8) -> u32 {
     x >> y
 }
 
-unconstrained fn shl(x: u32, y: u32) -> u32 {
+unconstrained fn shl(x: u32, y: u8) -> u32 {
     x << y
 }
 
diff --git a/test_programs/execution_success/bit_shifts_comptime/src/main.nr b/test_programs/execution_success/bit_shifts_comptime/src/main.nr
index 9184b5bd5e6..6d9736b6abb 100644
--- a/test_programs/execution_success/bit_shifts_comptime/src/main.nr
+++ b/test_programs/execution_success/bit_shifts_comptime/src/main.nr
@@ -14,7 +14,7 @@ fn main(x: u64) {
     //regression for 3481
     assert(x << 63 == 0);
 
-    assert_eq((1 as u64) << (32 as u64), 0x0100000000);
+    assert_eq((1 as u64) << 32, 0x0100000000);
 }
 
 fn regression_2250() {
diff --git a/test_programs/execution_success/bit_shifts_runtime/src/main.nr b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
index ff424c9fbf6..059bbe84dac 100644
--- a/test_programs/execution_success/bit_shifts_runtime/src/main.nr
+++ b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
@@ -1,4 +1,4 @@
-fn main(x: u64, y: u64) {
+fn main(x: u64, y: u8) {
     // runtime shifts on compile-time known values
     assert(64 << y == 128);
     assert(64 >> y == 32);
@@ -11,10 +11,10 @@ fn main(x: u64, y: u64) {
     let mut b: i8 = x as i8;
     assert(b << 1 == -128);
     assert(b >> 2 == 16);
-    assert(b >> a == 32);
+    assert(b >> y == 32);
     a = -a;
     assert(a << 7 == -128);
-    assert(a << -a == -2);
+    assert(a << y == -2);
 
-    assert(x >> x == 0);
+    assert(x >> (x as u8) == 0);
 }
diff --git a/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr b/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr
index f22166b5993..cdeaad7514c 100644
--- a/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr
+++ b/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr
@@ -1,7 +1,7 @@
-unconstrained fn main(x: u64, y: u64) {
+unconstrained fn main(x: u64, y: u8) {
     // runtime shifts on compile-time known values
-    assert(64 << y == 128);
-    assert(64 >> y == 32);
+    assert(64 as u32 << y == 128);
+    assert(64 as u32 >> y == 32);
     // runtime shifts on runtime values
     assert(x << y == 128);
     assert(x >> y == 32);
@@ -11,10 +11,10 @@ unconstrained fn main(x: u64, y: u64) {
     let mut b: i8 = x as i8;
     assert(b << 1 == -128);
     assert(b >> 2 == 16);
-    assert(b >> a == 32);
+    assert(b >> y == 32);
     a = -a;
     assert(a << 7 == -128);
-    assert(a << -a == -2);
+    assert(a << y == -2);
 
-    assert(x >> x == 0);
+    assert(x >> (x as u8) == 0);
 }
diff --git a/test_programs/execution_success/operator_overloading/src/main.nr b/test_programs/execution_success/operator_overloading/src/main.nr
index d61e1da170e..3956ea5c577 100644
--- a/test_programs/execution_success/operator_overloading/src/main.nr
+++ b/test_programs/execution_success/operator_overloading/src/main.nr
@@ -20,8 +20,8 @@ fn main(x: u32, y: u32) {
     assert((wx | wy).inner == (ex | ey));
     assert((wx ^ wy).inner == (ex ^ ey));
 
-    assert((wy << wx).inner == (ey << ex));
-    assert((wy >> wx).inner == (ey >> ex));
+    assert((wy << x as u8).inner == (ey << ex as u8));
+    assert((wy >> x as u8).inner == (ey >> ex as u8));
 
     assert((wx == wy) == (ex == ey));
     assert((wx < wy) == (ex < ey));
@@ -103,14 +103,14 @@ impl BitXor for Wrapper {
 }
 
 impl Shl for Wrapper {
-    fn shl(self, other: Self) -> Self {
-        Wrapper::new(self.inner << other.inner)
+    fn shl(self, other: u8) -> Self {
+        Wrapper::new(self.inner << other)
     }
 }
 
 impl Shr for Wrapper {
-    fn shr(self, other: Self) -> Self {
-        Wrapper::new(self.inner >> other.inner)
+    fn shr(self, other: u8) -> Self {
+        Wrapper::new(self.inner >> other)
     }
 }
 
diff --git a/test_programs/execution_success/regression/src/main.nr b/test_programs/execution_success/regression/src/main.nr
index c56f3ef4190..316c0d6bad6 100644
--- a/test_programs/execution_success/regression/src/main.nr
+++ b/test_programs/execution_success/regression/src/main.nr
@@ -87,7 +87,7 @@ fn bitshift_literal_4() -> u64 {
 
     bits
 }
-fn bitshift_variable(idx: u64) -> u64 {
+fn bitshift_variable(idx: u8) -> u64 {
     let mut bits: u64 = 0;
     bits |= 1 << idx;
 
diff --git a/test_programs/execution_success/u128/src/main.nr b/test_programs/execution_success/u128/src/main.nr
index dc586408795..a403571ea74 100644
--- a/test_programs/execution_success/u128/src/main.nr
+++ b/test_programs/execution_success/u128/src/main.nr
@@ -34,11 +34,11 @@ fn main(mut x: u32, y: u32, z: u32, big_int: U128, hexa: str<7>) {
     let mut small_int = U128::from_integer(x);
     assert(small_int.lo == x as Field);
     assert(x == small_int.to_integer());
-    let shift = small_int << small_int;
-    assert(shift == U128::from_integer(x << x));
-    assert(shift >> small_int == small_int);
-    assert(shift >> U128::from_integer(127) == U128::from_integer(0));
-    assert(shift << U128::from_integer(127) == U128::from_integer(0));
+    let shift = small_int << (x as u8);
+    assert(shift == U128::from_integer(x << (x as u8)));
+    assert(shift >> (x as u8) == small_int);
+    assert(shift >> 127 == U128::from_integer(0));
+    assert(shift << 127 == U128::from_integer(0));
     assert(U128::from_integer(3).to_integer() == 3);
 }
 

From 91062db84a749bf191eae9ce487a2315cc74bfb2 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Fri, 26 Apr 2024 18:17:35 +0200
Subject: [PATCH 230/416] fix: discard ref counts during unrolling (#4923)

# Description

## Problem\*

Resolves #4709

## Summary\*
The issue is due to reference count instructions which blow-up during
unrolling. Since these instructions are only for Brillig and since loops
are not unrolled in Brillig, I simply discard them during unrolling.


## Additional Context
I did not get an OOM on the mainframe, but the compilation lasted many
hours and did not complete (I finally cancelled it). With the fix the
execution is instantaneous, whether the code is constrained or
unconstrained.


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../noirc_evaluator/src/ssa/opt/unrolling.rs  |  13 +-
 .../regression_4709/Nargo.toml                |   6 +
 .../regression_4709/Prover.toml               |   2 +
 .../regression_4709/src/main.nr               | 271 ++++++++++++++++++
 tooling/debugger/ignored-tests.txt            |   1 +
 5 files changed, 290 insertions(+), 3 deletions(-)
 create mode 100644 test_programs/execution_success/regression_4709/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_4709/Prover.toml
 create mode 100644 test_programs/execution_success/regression_4709/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 6cf155f85ab..cfb5cfac326 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -12,6 +12,8 @@
 //!
 //! Note that this pass also often creates superfluous jmp instructions in the
 //! program that will need to be removed by a later simplify cfg pass.
+//! Note also that unrolling is skipped for Brillig runtime and as a result
+//! we remove reference count instructions because they are only used by Brillig bytecode
 use std::collections::HashSet;
 
 use crate::{
@@ -24,7 +26,7 @@ use crate::{
             dom::DominatorTree,
             function::{Function, RuntimeType},
             function_inserter::FunctionInserter,
-            instruction::TerminatorInstruction,
+            instruction::{Instruction, TerminatorInstruction},
             post_order::PostOrder,
             value::ValueId,
         },
@@ -465,9 +467,14 @@ impl<'f> LoopIteration<'f> {
         // instances of the induction variable or any values that were changed as a result
         // of the new induction variable value.
         for instruction in instructions {
-            self.inserter.push_instruction(instruction, self.insert_block);
+            // Skip reference count instructions since they are only used for brillig, and brillig code is not unrolled
+            if !matches!(
+                self.dfg()[instruction],
+                Instruction::IncrementRc { .. } | Instruction::DecrementRc { .. }
+            ) {
+                self.inserter.push_instruction(instruction, self.insert_block);
+            }
         }
-
         let mut terminator = self.dfg()[self.source_block]
             .unwrap_terminator()
             .clone()
diff --git a/test_programs/execution_success/regression_4709/Nargo.toml b/test_programs/execution_success/regression_4709/Nargo.toml
new file mode 100644
index 00000000000..2e0ce3fb5af
--- /dev/null
+++ b/test_programs/execution_success/regression_4709/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_4709"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_4709/Prover.toml b/test_programs/execution_success/regression_4709/Prover.toml
new file mode 100644
index 00000000000..dcfab705327
--- /dev/null
+++ b/test_programs/execution_success/regression_4709/Prover.toml
@@ -0,0 +1,2 @@
+x = 1
+y = 2
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_4709/src/main.nr b/test_programs/execution_success/regression_4709/src/main.nr
new file mode 100644
index 00000000000..1df09c53b55
--- /dev/null
+++ b/test_programs/execution_success/regression_4709/src/main.nr
@@ -0,0 +1,271 @@
+// Regression test for issue #4709
+global EXPONENTIATE: [[Field; 257]; 257] = [
+[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+[1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1],
+[1, 3, 9, 27, 81, 243, 215, 131, 136, 151, 196, 74, 222, 152, 199, 83, 249, 233, 185, 41, 123, 112, 79, 237, 197, 77, 231, 179, 23, 69, 207, 107, 64, 192, 62, 186, 44, 132, 139, 160, 223, 155, 208, 110, 73, 219, 143, 172, 2, 6, 18, 54, 162, 229, 173, 5, 15, 45, 135, 148, 187, 47, 141, 166, 241, 209, 113, 82, 246, 224, 158, 217, 137, 154, 205, 101, 46, 138, 157, 214, 128, 127, 124, 115, 88, 7, 21, 63, 189, 53, 159, 220, 146, 181, 29, 87, 4, 12, 36, 108, 67, 201, 89, 10, 30, 90, 13, 39, 117, 94, 25, 75, 225, 161, 226, 164, 235, 191, 59, 177, 17, 51, 153, 202, 92, 19, 57, 171, 256, 254, 248, 230, 176, 14, 42, 126, 121, 106, 61, 183, 35, 105, 58, 174, 8, 24, 72, 216, 134, 145, 178, 20, 60, 180, 26, 78, 234, 188, 50, 150, 193, 65, 195, 71, 213, 125, 118, 97, 34, 102, 49, 147, 184, 38, 114, 85, 255, 251, 239, 203, 95, 28, 84, 252, 242, 212, 122, 109, 70, 210, 116, 91, 16, 48, 144, 175, 11, 33, 99, 40, 120, 103, 52, 156, 211, 119, 100, 43, 129, 130, 133, 142, 169, 250, 236, 194, 68, 204, 98, 37, 111, 76, 228, 170, 253, 245, 221, 149, 190, 56, 168, 247, 227, 167, 244, 218, 140, 163, 232, 182, 32, 96, 31, 93, 22, 66, 198, 80, 240, 206, 104, 55, 165, 238, 200, 86, 1],
+[1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1],
+[1, 5, 25, 125, 111, 41, 205, 254, 242, 182, 139, 181, 134, 156, 9, 45, 225, 97, 228, 112, 46, 230, 122, 96, 223, 87, 178, 119, 81, 148, 226, 102, 253, 237, 157, 14, 70, 93, 208, 12, 60, 43, 215, 47, 235, 147, 221, 77, 128, 126, 116, 66, 73, 108, 26, 130, 136, 166, 59, 38, 190, 179, 124, 106, 16, 80, 143, 201, 234, 142, 196, 209, 17, 85, 168, 69, 88, 183, 144, 206, 2, 10, 50, 250, 222, 82, 153, 251, 227, 107, 21, 105, 11, 55, 18, 90, 193, 194, 199, 224, 92, 203, 244, 192, 189, 174, 99, 238, 162, 39, 195, 204, 249, 217, 57, 28, 140, 186, 159, 24, 120, 86, 173, 94, 213, 37, 185, 154, 256, 252, 232, 132, 146, 216, 52, 3, 15, 75, 118, 76, 123, 101, 248, 212, 32, 160, 29, 145, 211, 27, 135, 161, 34, 170, 79, 138, 176, 109, 31, 155, 4, 20, 100, 243, 187, 164, 49, 245, 197, 214, 42, 210, 22, 110, 36, 180, 129, 131, 141, 191, 184, 149, 231, 127, 121, 91, 198, 219, 67, 78, 133, 151, 241, 177, 114, 56, 23, 115, 61, 48, 240, 172, 89, 188, 169, 74, 113, 51, 255, 247, 207, 7, 35, 175, 104, 6, 30, 150, 236, 152, 246, 202, 239, 167, 64, 63, 58, 33, 165, 54, 13, 65, 68, 83, 158, 19, 95, 218, 62, 53, 8, 40, 200, 229, 117, 71, 98, 233, 137, 171, 84, 163, 44, 220, 72, 103, 1],
+[1, 6, 36, 216, 11, 66, 139, 63, 121, 212, 244, 179, 46, 19, 114, 170, 249, 209, 226, 71, 169, 243, 173, 10, 60, 103, 104, 110, 146, 105, 116, 182, 64, 127, 248, 203, 190, 112, 158, 177, 34, 204, 196, 148, 117, 188, 100, 86, 2, 12, 72, 175, 22, 132, 21, 126, 242, 167, 231, 101, 92, 38, 228, 83, 241, 161, 195, 142, 81, 229, 89, 20, 120, 206, 208, 220, 35, 210, 232, 107, 128, 254, 239, 149, 123, 224, 59, 97, 68, 151, 135, 39, 234, 119, 200, 172, 4, 24, 144, 93, 44, 7, 42, 252, 227, 77, 205, 202, 184, 76, 199, 166, 225, 65, 133, 27, 162, 201, 178, 40, 240, 155, 159, 183, 70, 163, 207, 214, 256, 251, 221, 41, 246, 191, 118, 194, 136, 45, 13, 78, 211, 238, 143, 87, 8, 48, 31, 186, 88, 14, 84, 247, 197, 154, 153, 147, 111, 152, 141, 75, 193, 130, 9, 54, 67, 145, 99, 80, 223, 53, 61, 109, 140, 69, 157, 171, 255, 245, 185, 82, 235, 125, 236, 131, 15, 90, 26, 156, 165, 219, 29, 174, 16, 96, 62, 115, 176, 28, 168, 237, 137, 51, 49, 37, 222, 47, 25, 150, 129, 3, 18, 108, 134, 33, 198, 160, 189, 106, 122, 218, 23, 138, 57, 85, 253, 233, 113, 164, 213, 250, 215, 5, 30, 180, 52, 55, 73, 181, 58, 91, 32, 192, 124, 230, 95, 56, 79, 217, 17, 102, 98, 74, 187, 94, 50, 43, 1],
+[1, 7, 49, 86, 88, 102, 200, 115, 34, 238, 124, 97, 165, 127, 118, 55, 128, 125, 104, 214, 213, 206, 157, 71, 240, 138, 195, 80, 46, 65, 198, 101, 193, 66, 205, 150, 22, 154, 50, 93, 137, 188, 31, 217, 234, 96, 158, 78, 32, 224, 26, 182, 246, 180, 232, 82, 60, 163, 113, 20, 140, 209, 178, 218, 241, 145, 244, 166, 134, 167, 141, 216, 227, 47, 72, 247, 187, 24, 168, 148, 8, 56, 135, 174, 190, 45, 58, 149, 15, 105, 221, 5, 35, 245, 173, 183, 253, 229, 61, 170, 162, 106, 228, 54, 121, 76, 18, 126, 111, 6, 42, 37, 2, 14, 98, 172, 176, 204, 143, 230, 68, 219, 248, 194, 73, 254, 236, 110, 256, 250, 208, 171, 169, 155, 57, 142, 223, 19, 133, 160, 92, 130, 139, 202, 129, 132, 153, 43, 44, 51, 100, 186, 17, 119, 62, 177, 211, 192, 59, 156, 64, 191, 52, 107, 235, 103, 207, 164, 120, 69, 226, 40, 23, 161, 99, 179, 225, 33, 231, 75, 11, 77, 25, 175, 197, 94, 144, 237, 117, 48, 79, 39, 16, 112, 13, 91, 123, 90, 116, 41, 30, 210, 185, 10, 70, 233, 89, 109, 249, 201, 122, 83, 67, 212, 199, 108, 242, 152, 36, 252, 222, 12, 84, 74, 4, 28, 196, 87, 95, 151, 29, 203, 136, 181, 239, 131, 146, 251, 215, 220, 255, 243, 159, 85, 81, 53, 114, 27, 189, 38, 9, 63, 184, 3, 21, 147, 1],
+[1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1],
+[1, 9, 81, 215, 136, 196, 222, 199, 249, 185, 123, 79, 197, 231, 23, 207, 64, 62, 44, 139, 223, 208, 73, 143, 2, 18, 162, 173, 15, 135, 187, 141, 241, 113, 246, 158, 137, 205, 46, 157, 128, 124, 88, 21, 189, 159, 146, 29, 4, 36, 67, 89, 30, 13, 117, 25, 225, 226, 235, 59, 17, 153, 92, 57, 256, 248, 176, 42, 121, 61, 35, 58, 8, 72, 134, 178, 60, 26, 234, 50, 193, 195, 213, 118, 34, 49, 184, 114, 255, 239, 95, 84, 242, 122, 70, 116, 16, 144, 11, 99, 120, 52, 211, 100, 129, 133, 169, 236, 68, 98, 111, 228, 253, 221, 190, 168, 227, 244, 140, 232, 32, 31, 22, 198, 240, 104, 165, 200, 1, 9, 81, 215, 136, 196, 222, 199, 249, 185, 123, 79, 197, 231, 23, 207, 64, 62, 44, 139, 223, 208, 73, 143, 2, 18, 162, 173, 15, 135, 187, 141, 241, 113, 246, 158, 137, 205, 46, 157, 128, 124, 88, 21, 189, 159, 146, 29, 4, 36, 67, 89, 30, 13, 117, 25, 225, 226, 235, 59, 17, 153, 92, 57, 256, 248, 176, 42, 121, 61, 35, 58, 8, 72, 134, 178, 60, 26, 234, 50, 193, 195, 213, 118, 34, 49, 184, 114, 255, 239, 95, 84, 242, 122, 70, 116, 16, 144, 11, 99, 120, 52, 211, 100, 129, 133, 169, 236, 68, 98, 111, 228, 253, 221, 190, 168, 227, 244, 140, 232, 32, 31, 22, 198, 240, 104, 165, 200, 1],
+[1, 10, 100, 229, 234, 27, 13, 130, 15, 150, 215, 94, 169, 148, 195, 151, 225, 194, 141, 125, 222, 164, 98, 209, 34, 83, 59, 76, 246, 147, 185, 51, 253, 217, 114, 112, 92, 149, 205, 251, 197, 171, 168, 138, 95, 179, 248, 167, 128, 252, 207, 14, 140, 115, 122, 192, 121, 182, 21, 210, 44, 183, 31, 53, 16, 160, 58, 66, 146, 175, 208, 24, 240, 87, 99, 219, 134, 55, 36, 103, 2, 20, 200, 201, 211, 54, 26, 3, 30, 43, 173, 188, 81, 39, 133, 45, 193, 131, 25, 250, 187, 71, 196, 161, 68, 166, 118, 152, 235, 37, 113, 102, 249, 177, 228, 224, 184, 41, 153, 245, 137, 85, 79, 19, 190, 101, 239, 77, 256, 247, 157, 28, 23, 230, 244, 127, 242, 107, 42, 163, 88, 109, 62, 106, 32, 63, 116, 132, 35, 93, 159, 48, 223, 174, 198, 181, 11, 110, 72, 206, 4, 40, 143, 145, 165, 108, 52, 6, 60, 86, 89, 119, 162, 78, 9, 90, 129, 5, 50, 243, 117, 142, 135, 65, 136, 75, 236, 47, 213, 74, 226, 204, 241, 97, 199, 191, 111, 82, 49, 233, 17, 170, 158, 38, 123, 202, 221, 154, 255, 237, 57, 56, 46, 203, 231, 254, 227, 214, 84, 69, 176, 218, 124, 212, 64, 126, 232, 7, 70, 186, 61, 96, 189, 91, 139, 105, 22, 220, 144, 155, 8, 80, 29, 33, 73, 216, 104, 12, 120, 172, 178, 238, 67, 156, 18, 180, 1],
+[1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1],
+[1, 12, 144, 186, 176, 56, 158, 97, 136, 90, 52, 110, 35, 163, 157, 85, 249, 161, 133, 54, 134, 66, 21, 252, 197, 51, 98, 148, 234, 238, 29, 91, 64, 254, 221, 82, 213, 243, 89, 40, 223, 106, 244, 101, 184, 152, 25, 43, 2, 24, 31, 115, 95, 112, 59, 194, 15, 180, 104, 220, 70, 69, 57, 170, 241, 65, 9, 108, 11, 132, 42, 247, 137, 102, 196, 39, 211, 219, 58, 182, 128, 251, 185, 164, 169, 229, 178, 80, 189, 212, 231, 202, 111, 47, 50, 86, 4, 48, 62, 230, 190, 224, 118, 131, 30, 103, 208, 183, 140, 138, 114, 83, 225, 130, 18, 216, 22, 7, 84, 237, 17, 204, 135, 78, 165, 181, 116, 107, 256, 245, 113, 71, 81, 201, 99, 160, 121, 167, 205, 147, 222, 94, 100, 172, 8, 96, 124, 203, 123, 191, 236, 5, 60, 206, 159, 109, 23, 19, 228, 166, 193, 3, 36, 175, 44, 14, 168, 217, 34, 151, 13, 156, 73, 105, 232, 214, 255, 233, 226, 142, 162, 145, 198, 63, 242, 77, 153, 37, 187, 188, 200, 87, 16, 192, 248, 149, 246, 125, 215, 10, 120, 155, 61, 218, 46, 38, 199, 75, 129, 6, 72, 93, 88, 28, 79, 177, 68, 45, 26, 55, 146, 210, 207, 171, 253, 209, 195, 27, 67, 33, 139, 126, 227, 154, 49, 74, 117, 119, 143, 174, 32, 127, 239, 41, 235, 250, 173, 20, 240, 53, 122, 179, 92, 76, 141, 150, 1],
+[1, 13, 169, 141, 34, 185, 92, 168, 128, 122, 44, 58, 240, 36, 211, 173, 193, 196, 235, 228, 137, 239, 23, 42, 32, 159, 11, 143, 60, 9, 117, 236, 241, 49, 123, 57, 227, 124, 70, 139, 8, 104, 67, 100, 15, 195, 222, 59, 253, 205, 95, 207, 121, 31, 146, 99, 2, 26, 81, 25, 68, 113, 184, 79, 256, 244, 88, 116, 223, 72, 165, 89, 129, 135, 213, 199, 17, 221, 46, 84, 64, 61, 22, 29, 120, 18, 234, 215, 225, 98, 246, 114, 197, 248, 140, 21, 16, 208, 134, 200, 30, 133, 187, 118, 249, 153, 190, 157, 242, 62, 35, 198, 4, 52, 162, 50, 136, 226, 111, 158, 255, 231, 176, 232, 189, 144, 73, 178, 1, 13, 169, 141, 34, 185, 92, 168, 128, 122, 44, 58, 240, 36, 211, 173, 193, 196, 235, 228, 137, 239, 23, 42, 32, 159, 11, 143, 60, 9, 117, 236, 241, 49, 123, 57, 227, 124, 70, 139, 8, 104, 67, 100, 15, 195, 222, 59, 253, 205, 95, 207, 121, 31, 146, 99, 2, 26, 81, 25, 68, 113, 184, 79, 256, 244, 88, 116, 223, 72, 165, 89, 129, 135, 213, 199, 17, 221, 46, 84, 64, 61, 22, 29, 120, 18, 234, 215, 225, 98, 246, 114, 197, 248, 140, 21, 16, 208, 134, 200, 30, 133, 187, 118, 249, 153, 190, 157, 242, 62, 35, 198, 4, 52, 162, 50, 136, 226, 111, 158, 255, 231, 176, 232, 189, 144, 73, 178, 1],
+[1, 14, 196, 174, 123, 180, 207, 71, 223, 38, 18, 252, 187, 48, 158, 156, 128, 250, 159, 170, 67, 167, 25, 93, 17, 238, 248, 131, 35, 233, 178, 179, 193, 132, 49, 172, 95, 45, 116, 82, 120, 138, 133, 63, 111, 12, 168, 39, 32, 191, 104, 171, 81, 106, 199, 216, 197, 188, 62, 97, 73, 251, 173, 109, 241, 33, 205, 43, 88, 204, 29, 149, 30, 163, 226, 80, 92, 3, 42, 74, 8, 112, 26, 107, 213, 155, 114, 54, 242, 47, 144, 217, 211, 127, 236, 220, 253, 201, 244, 75, 22, 51, 200, 230, 136, 105, 185, 20, 23, 65, 139, 147, 2, 28, 135, 91, 246, 103, 157, 142, 189, 76, 36, 247, 117, 96, 59, 55, 256, 243, 61, 83, 134, 77, 50, 186, 34, 219, 239, 5, 70, 209, 99, 101, 129, 7, 98, 87, 190, 90, 232, 164, 240, 19, 9, 126, 222, 24, 79, 78, 64, 125, 208, 85, 162, 212, 141, 175, 137, 119, 124, 194, 146, 245, 89, 218, 225, 66, 153, 86, 176, 151, 58, 41, 60, 69, 195, 160, 184, 6, 84, 148, 16, 224, 52, 214, 169, 53, 228, 108, 227, 94, 31, 177, 165, 254, 215, 183, 249, 145, 231, 150, 44, 102, 143, 203, 15, 210, 113, 40, 46, 130, 21, 37, 4, 56, 13, 182, 235, 206, 57, 27, 121, 152, 72, 237, 234, 192, 118, 110, 255, 229, 122, 166, 11, 154, 100, 115, 68, 181, 221, 10, 140, 161, 198, 202, 1],
+[1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1],
+[1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1],
+[1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1],
+[1, 18, 67, 178, 120, 104, 73, 29, 8, 144, 22, 139, 189, 61, 70, 232, 64, 124, 176, 84, 227, 231, 46, 57, 255, 221, 123, 158, 17, 49, 111, 199, 241, 226, 213, 236, 136, 135, 117, 50, 129, 9, 162, 89, 60, 52, 165, 143, 4, 72, 11, 198, 223, 159, 35, 116, 32, 62, 88, 42, 242, 244, 23, 157, 256, 239, 190, 79, 137, 153, 184, 228, 249, 113, 235, 118, 68, 196, 187, 25, 193, 133, 81, 173, 30, 26, 211, 200, 2, 36, 134, 99, 240, 208, 146, 58, 16, 31, 44, 21, 121, 122, 140, 207, 128, 248, 95, 168, 197, 205, 92, 114, 253, 185, 246, 59, 34, 98, 222, 141, 225, 195, 169, 215, 15, 13, 234, 100, 1, 18, 67, 178, 120, 104, 73, 29, 8, 144, 22, 139, 189, 61, 70, 232, 64, 124, 176, 84, 227, 231, 46, 57, 255, 221, 123, 158, 17, 49, 111, 199, 241, 226, 213, 236, 136, 135, 117, 50, 129, 9, 162, 89, 60, 52, 165, 143, 4, 72, 11, 198, 223, 159, 35, 116, 32, 62, 88, 42, 242, 244, 23, 157, 256, 239, 190, 79, 137, 153, 184, 228, 249, 113, 235, 118, 68, 196, 187, 25, 193, 133, 81, 173, 30, 26, 211, 200, 2, 36, 134, 99, 240, 208, 146, 58, 16, 31, 44, 21, 121, 122, 140, 207, 128, 248, 95, 168, 197, 205, 92, 114, 253, 185, 246, 59, 34, 98, 222, 141, 225, 195, 169, 215, 15, 13, 234, 100, 1],
+[1, 19, 104, 177, 22, 161, 232, 39, 227, 201, 221, 87, 111, 53, 236, 115, 129, 138, 52, 217, 11, 209, 116, 148, 242, 229, 239, 172, 184, 155, 118, 186, 193, 69, 26, 237, 134, 233, 58, 74, 121, 243, 248, 86, 92, 206, 59, 93, 225, 163, 13, 247, 67, 245, 29, 37, 189, 250, 124, 43, 46, 103, 158, 175, 241, 210, 135, 252, 162, 251, 143, 147, 223, 125, 62, 150, 23, 180, 79, 216, 249, 105, 196, 126, 81, 254, 200, 202, 240, 191, 31, 75, 140, 90, 168, 108, 253, 181, 98, 63, 169, 127, 100, 101, 120, 224, 144, 166, 70, 45, 84, 54, 255, 219, 49, 160, 213, 192, 50, 179, 60, 112, 72, 83, 35, 151, 42, 27, 256, 238, 153, 80, 235, 96, 25, 218, 30, 56, 36, 170, 146, 204, 21, 142, 128, 119, 205, 40, 246, 48, 141, 109, 15, 28, 18, 85, 73, 102, 139, 71, 64, 188, 231, 20, 123, 24, 199, 183, 136, 14, 9, 171, 165, 51, 198, 164, 32, 94, 244, 10, 190, 12, 228, 220, 68, 7, 133, 214, 211, 154, 99, 82, 16, 47, 122, 5, 95, 6, 114, 110, 34, 132, 195, 107, 234, 77, 178, 41, 8, 152, 61, 131, 176, 3, 57, 55, 17, 66, 226, 182, 117, 167, 89, 149, 4, 76, 159, 194, 88, 130, 157, 156, 137, 33, 113, 91, 187, 212, 173, 203, 2, 38, 208, 97, 44, 65, 207, 78, 197, 145, 185, 174, 222, 106, 215, 230, 1],
+[1, 20, 143, 33, 146, 93, 61, 192, 242, 214, 168, 19, 123, 147, 113, 204, 225, 131, 50, 229, 211, 108, 104, 24, 223, 91, 21, 163, 176, 179, 239, 154, 253, 177, 199, 125, 187, 142, 13, 3, 60, 172, 99, 181, 22, 183, 62, 212, 128, 247, 57, 112, 184, 82, 98, 161, 136, 150, 173, 119, 67, 55, 72, 155, 16, 63, 232, 14, 23, 203, 205, 245, 17, 83, 118, 47, 169, 39, 9, 180, 2, 40, 29, 66, 35, 186, 122, 127, 227, 171, 79, 38, 246, 37, 226, 151, 193, 5, 100, 201, 165, 216, 208, 48, 189, 182, 42, 69, 95, 101, 221, 51, 249, 97, 141, 250, 117, 27, 26, 6, 120, 87, 198, 105, 44, 109, 124, 167, 256, 237, 114, 224, 111, 164, 196, 65, 15, 43, 89, 238, 134, 110, 144, 53, 32, 126, 207, 28, 46, 149, 153, 233, 34, 166, 236, 94, 81, 78, 18, 103, 4, 80, 58, 132, 70, 115, 244, 254, 197, 85, 158, 76, 235, 74, 195, 45, 129, 10, 200, 145, 73, 175, 159, 96, 121, 107, 84, 138, 190, 202, 185, 102, 241, 194, 25, 243, 234, 54, 52, 12, 240, 174, 139, 210, 88, 218, 248, 77, 255, 217, 228, 191, 222, 71, 135, 130, 30, 86, 178, 219, 11, 220, 31, 106, 64, 252, 157, 56, 92, 41, 49, 209, 68, 75, 215, 188, 162, 156, 36, 206, 8, 160, 116, 7, 140, 230, 231, 251, 137, 170, 59, 152, 213, 148, 133, 90, 1],
+[1, 21, 184, 9, 189, 114, 81, 159, 255, 215, 146, 239, 136, 29, 95, 196, 4, 84, 222, 36, 242, 199, 67, 122, 249, 89, 70, 185, 30, 116, 123, 13, 16, 79, 117, 144, 197, 25, 11, 231, 225, 99, 23, 226, 120, 207, 235, 52, 64, 59, 211, 62, 17, 100, 44, 153, 129, 139, 92, 133, 223, 57, 169, 208, 256, 236, 73, 248, 68, 143, 176, 98, 2, 42, 111, 18, 121, 228, 162, 61, 253, 173, 35, 221, 15, 58, 190, 135, 8, 168, 187, 72, 227, 141, 134, 244, 241, 178, 140, 113, 60, 232, 246, 26, 32, 158, 234, 31, 137, 50, 22, 205, 193, 198, 46, 195, 240, 157, 213, 104, 128, 118, 165, 124, 34, 200, 88, 49, 1, 21, 184, 9, 189, 114, 81, 159, 255, 215, 146, 239, 136, 29, 95, 196, 4, 84, 222, 36, 242, 199, 67, 122, 249, 89, 70, 185, 30, 116, 123, 13, 16, 79, 117, 144, 197, 25, 11, 231, 225, 99, 23, 226, 120, 207, 235, 52, 64, 59, 211, 62, 17, 100, 44, 153, 129, 139, 92, 133, 223, 57, 169, 208, 256, 236, 73, 248, 68, 143, 176, 98, 2, 42, 111, 18, 121, 228, 162, 61, 253, 173, 35, 221, 15, 58, 190, 135, 8, 168, 187, 72, 227, 141, 134, 244, 241, 178, 140, 113, 60, 232, 246, 26, 32, 158, 234, 31, 137, 50, 22, 205, 193, 198, 46, 195, 240, 157, 213, 104, 128, 118, 165, 124, 34, 200, 88, 49, 1],
+[1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1],
+[1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1],
+[1, 24, 62, 203, 246, 250, 89, 80, 121, 77, 49, 148, 211, 181, 232, 171, 249, 65, 18, 175, 88, 56, 59, 131, 60, 155, 122, 101, 111, 94, 200, 174, 64, 251, 113, 142, 67, 66, 42, 237, 34, 45, 52, 220, 140, 19, 199, 150, 2, 48, 124, 149, 235, 243, 178, 160, 242, 154, 98, 39, 165, 105, 207, 85, 241, 130, 36, 93, 176, 112, 118, 5, 120, 53, 244, 202, 222, 188, 143, 91, 128, 245, 226, 27, 134, 132, 84, 217, 68, 90, 104, 183, 23, 38, 141, 43, 4, 96, 248, 41, 213, 229, 99, 63, 227, 51, 196, 78, 73, 210, 157, 170, 225, 3, 72, 186, 95, 224, 236, 10, 240, 106, 231, 147, 187, 119, 29, 182, 256, 233, 195, 54, 11, 7, 168, 177, 136, 180, 208, 109, 46, 76, 25, 86, 8, 192, 239, 82, 169, 201, 198, 126, 197, 102, 135, 156, 146, 163, 57, 83, 193, 6, 144, 115, 190, 191, 215, 20, 223, 212, 205, 37, 117, 238, 58, 107, 255, 209, 133, 108, 22, 14, 79, 97, 15, 103, 159, 218, 92, 152, 50, 172, 16, 127, 221, 164, 81, 145, 139, 252, 137, 204, 13, 55, 35, 69, 114, 166, 129, 12, 31, 230, 123, 125, 173, 40, 189, 167, 153, 74, 234, 219, 116, 214, 253, 161, 9, 216, 44, 28, 158, 194, 30, 206, 61, 179, 184, 47, 100, 87, 32, 254, 185, 71, 162, 33, 21, 247, 17, 151, 26, 110, 70, 138, 228, 75, 1],
+[1, 25, 111, 205, 242, 139, 134, 9, 225, 228, 46, 122, 223, 178, 81, 226, 253, 157, 70, 208, 60, 215, 235, 221, 128, 116, 73, 26, 136, 59, 190, 124, 16, 143, 234, 196, 17, 168, 88, 144, 2, 50, 222, 153, 227, 21, 11, 18, 193, 199, 92, 244, 189, 99, 162, 195, 249, 57, 140, 159, 120, 173, 213, 185, 256, 232, 146, 52, 15, 118, 123, 248, 32, 29, 211, 135, 34, 79, 176, 31, 4, 100, 187, 49, 197, 42, 22, 36, 129, 141, 184, 231, 121, 198, 67, 133, 241, 114, 23, 61, 240, 89, 169, 113, 255, 207, 35, 104, 30, 236, 246, 239, 64, 58, 165, 13, 68, 158, 95, 62, 8, 200, 117, 98, 137, 84, 44, 72, 1, 25, 111, 205, 242, 139, 134, 9, 225, 228, 46, 122, 223, 178, 81, 226, 253, 157, 70, 208, 60, 215, 235, 221, 128, 116, 73, 26, 136, 59, 190, 124, 16, 143, 234, 196, 17, 168, 88, 144, 2, 50, 222, 153, 227, 21, 11, 18, 193, 199, 92, 244, 189, 99, 162, 195, 249, 57, 140, 159, 120, 173, 213, 185, 256, 232, 146, 52, 15, 118, 123, 248, 32, 29, 211, 135, 34, 79, 176, 31, 4, 100, 187, 49, 197, 42, 22, 36, 129, 141, 184, 231, 121, 198, 67, 133, 241, 114, 23, 61, 240, 89, 169, 113, 255, 207, 35, 104, 30, 236, 246, 239, 64, 58, 165, 13, 68, 158, 95, 62, 8, 200, 117, 98, 137, 84, 44, 72, 1],
+[1, 26, 162, 100, 30, 9, 234, 173, 129, 13, 81, 50, 15, 133, 117, 215, 193, 135, 169, 25, 136, 195, 187, 236, 225, 196, 213, 141, 68, 226, 222, 118, 241, 98, 235, 199, 34, 113, 111, 59, 249, 49, 246, 228, 17, 185, 184, 158, 253, 153, 123, 114, 137, 221, 92, 79, 255, 205, 190, 57, 197, 239, 46, 168, 256, 231, 95, 157, 227, 248, 23, 84, 128, 244, 176, 207, 242, 124, 140, 42, 64, 122, 88, 232, 121, 62, 70, 21, 32, 61, 44, 116, 189, 31, 35, 139, 16, 159, 22, 58, 223, 144, 146, 198, 8, 208, 11, 29, 240, 72, 73, 99, 4, 104, 134, 143, 120, 36, 165, 178, 2, 52, 67, 200, 60, 18, 211, 89, 1, 26, 162, 100, 30, 9, 234, 173, 129, 13, 81, 50, 15, 133, 117, 215, 193, 135, 169, 25, 136, 195, 187, 236, 225, 196, 213, 141, 68, 226, 222, 118, 241, 98, 235, 199, 34, 113, 111, 59, 249, 49, 246, 228, 17, 185, 184, 158, 253, 153, 123, 114, 137, 221, 92, 79, 255, 205, 190, 57, 197, 239, 46, 168, 256, 231, 95, 157, 227, 248, 23, 84, 128, 244, 176, 207, 242, 124, 140, 42, 64, 122, 88, 232, 121, 62, 70, 21, 32, 61, 44, 116, 189, 31, 35, 139, 16, 159, 22, 58, 223, 144, 146, 198, 8, 208, 11, 29, 240, 72, 73, 99, 4, 104, 134, 143, 120, 36, 165, 178, 2, 52, 67, 200, 60, 18, 211, 89, 1],
+[1, 27, 215, 151, 222, 83, 185, 112, 197, 179, 207, 192, 44, 160, 208, 219, 2, 54, 173, 45, 187, 166, 113, 224, 137, 101, 157, 127, 88, 63, 159, 181, 4, 108, 89, 90, 117, 75, 226, 191, 17, 202, 57, 254, 176, 126, 61, 105, 8, 216, 178, 180, 234, 150, 195, 125, 34, 147, 114, 251, 95, 252, 122, 210, 16, 175, 99, 103, 211, 43, 133, 250, 68, 37, 228, 245, 190, 247, 244, 163, 32, 93, 198, 206, 165, 86, 9, 243, 136, 74, 199, 233, 123, 237, 231, 69, 64, 186, 139, 155, 73, 172, 18, 229, 15, 148, 141, 209, 246, 217, 205, 138, 128, 115, 21, 53, 146, 87, 36, 201, 30, 39, 25, 161, 235, 177, 153, 19, 256, 230, 42, 106, 35, 174, 72, 145, 60, 78, 50, 65, 213, 97, 49, 38, 255, 203, 84, 212, 70, 91, 144, 33, 120, 156, 100, 130, 169, 194, 98, 76, 253, 149, 168, 167, 140, 182, 31, 66, 240, 55, 200, 3, 81, 131, 196, 152, 249, 41, 79, 77, 23, 107, 62, 132, 223, 110, 143, 6, 162, 5, 135, 47, 241, 82, 158, 154, 46, 214, 124, 7, 189, 220, 29, 12, 67, 10, 13, 94, 225, 164, 59, 51, 92, 171, 248, 14, 121, 183, 58, 24, 134, 20, 26, 188, 193, 71, 118, 102, 184, 85, 239, 28, 242, 109, 116, 48, 11, 40, 52, 119, 129, 142, 236, 204, 111, 170, 221, 56, 227, 218, 232, 96, 22, 80, 104, 238, 1],
+[1, 28, 13, 107, 169, 106, 141, 93, 34, 181, 185, 40, 92, 6, 168, 78, 128, 243, 122, 75, 44, 204, 58, 82, 240, 38, 36, 237, 211, 254, 173, 218, 193, 7, 196, 91, 235, 155, 228, 216, 137, 238, 239, 10, 23, 130, 42, 148, 32, 125, 159, 83, 11, 51, 143, 149, 60, 138, 9, 252, 117, 192, 236, 183, 241, 66, 49, 87, 123, 103, 57, 54, 227, 188, 124, 131, 70, 161, 139, 37, 8, 224, 104, 85, 67, 77, 100, 230, 15, 163, 195, 63, 222, 48, 59, 110, 253, 145, 205, 86, 95, 90, 207, 142, 121, 47, 31, 97, 146, 233, 99, 202, 2, 56, 26, 214, 81, 212, 25, 186, 68, 105, 113, 80, 184, 12, 79, 156, 256, 229, 244, 150, 88, 151, 116, 164, 223, 76, 72, 217, 165, 251, 89, 179, 129, 14, 135, 182, 213, 53, 199, 175, 17, 219, 221, 20, 46, 3, 84, 39, 64, 250, 61, 166, 22, 102, 29, 41, 120, 19, 18, 247, 234, 127, 215, 109, 225, 132, 98, 174, 246, 206, 114, 108, 197, 119, 248, 5, 140, 65, 21, 74, 16, 191, 208, 170, 134, 154, 200, 203, 30, 69, 133, 126, 187, 96, 118, 220, 249, 33, 153, 172, 190, 180, 157, 27, 242, 94, 62, 194, 35, 209, 198, 147, 4, 112, 52, 171, 162, 167, 50, 115, 136, 210, 226, 160, 111, 24, 158, 55, 255, 201, 231, 43, 176, 45, 232, 71, 189, 152, 144, 177, 73, 245, 178, 101, 1],
+[1, 29, 70, 231, 17, 236, 162, 72, 32, 157, 184, 196, 30, 99, 44, 248, 253, 141, 234, 104, 189, 84, 123, 226, 129, 143, 35, 244, 137, 118, 81, 36, 16, 207, 92, 98, 15, 178, 22, 124, 255, 199, 117, 52, 223, 42, 190, 113, 193, 200, 146, 122, 197, 59, 169, 18, 8, 232, 46, 49, 136, 89, 11, 62, 256, 228, 187, 26, 240, 21, 95, 185, 225, 100, 73, 61, 227, 158, 213, 9, 4, 116, 23, 153, 68, 173, 134, 31, 128, 114, 222, 13, 120, 139, 176, 221, 241, 50, 165, 159, 242, 79, 235, 133, 2, 58, 140, 205, 34, 215, 67, 144, 64, 57, 111, 135, 60, 198, 88, 239, 249, 25, 211, 208, 121, 168, 246, 195, 1, 29, 70, 231, 17, 236, 162, 72, 32, 157, 184, 196, 30, 99, 44, 248, 253, 141, 234, 104, 189, 84, 123, 226, 129, 143, 35, 244, 137, 118, 81, 36, 16, 207, 92, 98, 15, 178, 22, 124, 255, 199, 117, 52, 223, 42, 190, 113, 193, 200, 146, 122, 197, 59, 169, 18, 8, 232, 46, 49, 136, 89, 11, 62, 256, 228, 187, 26, 240, 21, 95, 185, 225, 100, 73, 61, 227, 158, 213, 9, 4, 116, 23, 153, 68, 173, 134, 31, 128, 114, 222, 13, 120, 139, 176, 221, 241, 50, 165, 159, 242, 79, 235, 133, 2, 58, 140, 205, 34, 215, 67, 144, 64, 57, 111, 135, 60, 198, 88, 239, 249, 25, 211, 208, 121, 168, 246, 195, 1],
+[1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1],
+[1, 31, 190, 236, 120, 122, 184, 50, 8, 248, 235, 89, 189, 205, 187, 143, 64, 185, 81, 198, 227, 98, 211, 116, 255, 195, 134, 42, 17, 13, 146, 157, 241, 18, 44, 79, 136, 104, 140, 228, 129, 144, 95, 118, 60, 61, 92, 25, 4, 124, 246, 173, 223, 231, 222, 200, 32, 221, 169, 99, 242, 49, 234, 58, 256, 226, 67, 21, 137, 135, 73, 207, 249, 9, 22, 168, 68, 52, 70, 114, 193, 72, 176, 59, 30, 159, 46, 141, 2, 62, 123, 215, 240, 244, 111, 100, 16, 239, 213, 178, 121, 153, 117, 29, 128, 113, 162, 139, 197, 196, 165, 232, 253, 133, 11, 84, 34, 26, 35, 57, 225, 36, 88, 158, 15, 208, 23, 199, 1, 31, 190, 236, 120, 122, 184, 50, 8, 248, 235, 89, 189, 205, 187, 143, 64, 185, 81, 198, 227, 98, 211, 116, 255, 195, 134, 42, 17, 13, 146, 157, 241, 18, 44, 79, 136, 104, 140, 228, 129, 144, 95, 118, 60, 61, 92, 25, 4, 124, 246, 173, 223, 231, 222, 200, 32, 221, 169, 99, 242, 49, 234, 58, 256, 226, 67, 21, 137, 135, 73, 207, 249, 9, 22, 168, 68, 52, 70, 114, 193, 72, 176, 59, 30, 159, 46, 141, 2, 62, 123, 215, 240, 244, 111, 100, 16, 239, 213, 178, 121, 153, 117, 29, 128, 113, 162, 139, 197, 196, 165, 232, 253, 133, 11, 84, 34, 26, 35, 57, 225, 36, 88, 158, 15, 208, 23, 199, 1],
+[1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1],
+[1, 33, 61, 214, 123, 204, 50, 108, 223, 163, 239, 177, 187, 3, 99, 183, 128, 112, 98, 150, 67, 155, 232, 203, 17, 47, 9, 40, 35, 127, 79, 37, 193, 201, 208, 182, 95, 51, 141, 27, 120, 105, 124, 237, 111, 65, 89, 110, 32, 28, 153, 166, 81, 103, 58, 115, 197, 76, 195, 10, 73, 96, 84, 202, 241, 243, 52, 174, 88, 77, 228, 71, 30, 219, 31, 252, 92, 209, 215, 156, 8, 7, 231, 170, 213, 90, 143, 93, 242, 19, 113, 131, 211, 24, 21, 179, 253, 125, 13, 172, 22, 212, 57, 82, 136, 119, 72, 63, 23, 245, 118, 39, 2, 66, 122, 171, 246, 151, 100, 216, 189, 69, 221, 97, 117, 6, 198, 109, 256, 224, 196, 43, 134, 53, 207, 149, 34, 94, 18, 80, 70, 254, 158, 74, 129, 145, 159, 107, 190, 102, 25, 54, 240, 210, 248, 217, 222, 130, 178, 220, 64, 56, 49, 75, 162, 206, 116, 230, 137, 152, 133, 20, 146, 192, 168, 147, 225, 229, 104, 91, 176, 154, 199, 142, 60, 181, 62, 247, 184, 161, 173, 55, 16, 14, 205, 83, 169, 180, 29, 186, 227, 38, 226, 5, 165, 48, 42, 101, 249, 250, 26, 87, 44, 167, 114, 164, 15, 238, 144, 126, 46, 233, 236, 78, 4, 132, 244, 85, 235, 45, 200, 175, 121, 138, 185, 194, 234, 12, 139, 218, 255, 191, 135, 86, 11, 106, 157, 41, 68, 188, 36, 160, 140, 251, 59, 148, 1],
+[1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1],
+[1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1],
+[1, 36, 11, 139, 121, 244, 46, 114, 249, 226, 169, 173, 60, 104, 146, 116, 64, 248, 190, 158, 34, 196, 117, 100, 2, 72, 22, 21, 242, 231, 92, 228, 241, 195, 81, 89, 120, 208, 35, 232, 128, 239, 123, 59, 68, 135, 234, 200, 4, 144, 44, 42, 227, 205, 184, 199, 225, 133, 162, 178, 240, 159, 70, 207, 256, 221, 246, 118, 136, 13, 211, 143, 8, 31, 88, 84, 197, 153, 111, 141, 193, 9, 67, 99, 223, 61, 140, 157, 255, 185, 235, 236, 15, 26, 165, 29, 16, 62, 176, 168, 137, 49, 222, 25, 129, 18, 134, 198, 189, 122, 23, 57, 253, 113, 213, 215, 30, 52, 73, 58, 32, 124, 95, 79, 17, 98, 187, 50, 1, 36, 11, 139, 121, 244, 46, 114, 249, 226, 169, 173, 60, 104, 146, 116, 64, 248, 190, 158, 34, 196, 117, 100, 2, 72, 22, 21, 242, 231, 92, 228, 241, 195, 81, 89, 120, 208, 35, 232, 128, 239, 123, 59, 68, 135, 234, 200, 4, 144, 44, 42, 227, 205, 184, 199, 225, 133, 162, 178, 240, 159, 70, 207, 256, 221, 246, 118, 136, 13, 211, 143, 8, 31, 88, 84, 197, 153, 111, 141, 193, 9, 67, 99, 223, 61, 140, 157, 255, 185, 235, 236, 15, 26, 165, 29, 16, 62, 176, 168, 137, 49, 222, 25, 129, 18, 134, 198, 189, 122, 23, 57, 253, 113, 213, 215, 30, 52, 73, 58, 32, 124, 95, 79, 17, 98, 187, 50, 1],
+[1, 37, 84, 24, 117, 217, 62, 238, 68, 203, 58, 90, 246, 107, 104, 250, 255, 183, 89, 209, 23, 80, 133, 38, 121, 108, 141, 77, 22, 43, 49, 14, 4, 148, 79, 96, 211, 97, 248, 181, 15, 41, 232, 103, 213, 171, 159, 229, 249, 218, 99, 65, 92, 63, 18, 152, 227, 175, 50, 51, 88, 172, 196, 56, 16, 78, 59, 127, 73, 131, 221, 210, 60, 164, 157, 155, 81, 170, 122, 145, 225, 101, 139, 3, 111, 252, 72, 94, 137, 186, 200, 204, 95, 174, 13, 224, 64, 55, 236, 251, 35, 10, 113, 69, 240, 142, 114, 106, 67, 166, 231, 66, 129, 147, 42, 12, 187, 237, 31, 119, 34, 230, 29, 45, 123, 182, 52, 125, 256, 220, 173, 233, 140, 40, 195, 19, 189, 54, 199, 167, 11, 150, 153, 7, 2, 74, 168, 48, 234, 177, 124, 219, 136, 149, 116, 180, 235, 214, 208, 243, 253, 109, 178, 161, 46, 160, 9, 76, 242, 216, 25, 154, 44, 86, 98, 28, 8, 39, 158, 192, 165, 194, 239, 105, 30, 82, 207, 206, 169, 85, 61, 201, 241, 179, 198, 130, 184, 126, 36, 47, 197, 93, 100, 102, 176, 87, 135, 112, 32, 156, 118, 254, 146, 5, 185, 163, 120, 71, 57, 53, 162, 83, 244, 33, 193, 202, 21, 6, 222, 247, 144, 188, 17, 115, 143, 151, 190, 91, 26, 191, 128, 110, 215, 245, 70, 20, 226, 138, 223, 27, 228, 212, 134, 75, 205, 132, 1],
+[1, 38, 159, 131, 95, 12, 199, 109, 30, 112, 144, 75, 23, 103, 59, 186, 129, 19, 208, 194, 176, 6, 228, 183, 15, 56, 72, 166, 140, 180, 158, 93, 193, 138, 104, 97, 88, 3, 114, 220, 136, 28, 36, 83, 70, 90, 79, 175, 225, 69, 52, 177, 44, 130, 57, 110, 68, 14, 18, 170, 35, 45, 168, 216, 241, 163, 26, 217, 22, 65, 157, 55, 34, 7, 9, 85, 146, 151, 84, 108, 249, 210, 13, 237, 11, 161, 207, 156, 17, 132, 133, 171, 73, 204, 42, 54, 253, 105, 135, 247, 134, 209, 232, 78, 137, 66, 195, 214, 165, 102, 21, 27, 255, 181, 196, 252, 67, 233, 116, 39, 197, 33, 226, 107, 211, 51, 139, 142, 256, 219, 98, 126, 162, 245, 58, 148, 227, 145, 113, 182, 234, 154, 198, 71, 128, 238, 49, 63, 81, 251, 29, 74, 242, 201, 185, 91, 117, 77, 99, 164, 64, 119, 153, 160, 169, 254, 143, 37, 121, 229, 221, 174, 187, 167, 178, 82, 32, 188, 205, 80, 213, 127, 200, 147, 189, 243, 239, 87, 222, 212, 89, 41, 16, 94, 231, 40, 235, 192, 100, 202, 223, 250, 248, 172, 111, 106, 173, 149, 8, 47, 244, 20, 246, 96, 50, 101, 240, 125, 124, 86, 184, 53, 215, 203, 4, 152, 122, 10, 123, 48, 25, 179, 120, 191, 62, 43, 92, 155, 236, 230, 2, 76, 61, 5, 190, 24, 141, 218, 60, 224, 31, 150, 46, 206, 118, 115, 1],
+[1, 39, 236, 209, 184, 237, 248, 163, 189, 175, 143, 180, 81, 75, 98, 224, 255, 179, 42, 96, 146, 40, 18, 188, 136, 164, 228, 154, 95, 107, 61, 66, 4, 156, 173, 65, 222, 177, 221, 138, 242, 186, 58, 206, 67, 43, 135, 125, 249, 202, 168, 127, 70, 160, 72, 238, 30, 142, 141, 102, 123, 171, 244, 7, 16, 110, 178, 3, 117, 194, 113, 38, 197, 230, 232, 53, 11, 172, 26, 243, 225, 37, 158, 251, 23, 126, 31, 181, 120, 54, 50, 151, 235, 170, 205, 28, 64, 183, 198, 12, 211, 5, 195, 152, 17, 149, 157, 212, 44, 174, 104, 201, 129, 148, 118, 233, 92, 247, 124, 210, 223, 216, 200, 90, 169, 166, 49, 112, 256, 218, 21, 48, 73, 20, 9, 94, 68, 82, 114, 77, 176, 182, 159, 33, 2, 78, 215, 161, 111, 217, 239, 69, 121, 93, 29, 103, 162, 150, 196, 191, 253, 101, 84, 192, 35, 80, 36, 119, 15, 71, 199, 51, 190, 214, 122, 132, 8, 55, 89, 130, 187, 97, 185, 19, 227, 115, 116, 155, 134, 86, 13, 250, 241, 147, 79, 254, 140, 63, 144, 219, 60, 27, 25, 204, 246, 85, 231, 14, 32, 220, 99, 6, 234, 131, 226, 76, 137, 203, 207, 106, 22, 87, 52, 229, 193, 74, 59, 245, 46, 252, 62, 105, 240, 108, 100, 45, 213, 83, 153, 56, 128, 109, 139, 24, 165, 10, 133, 47, 34, 41, 57, 167, 88, 91, 208, 145, 1],
+[1, 40, 58, 7, 23, 149, 49, 161, 15, 86, 99, 105, 88, 179, 221, 102, 225, 5, 200, 33, 35, 115, 231, 245, 34, 75, 173, 238, 11, 183, 124, 77, 253, 97, 25, 229, 165, 175, 61, 127, 197, 170, 118, 94, 162, 55, 144, 106, 128, 237, 228, 125, 117, 54, 104, 48, 121, 214, 79, 76, 213, 39, 18, 206, 16, 126, 157, 112, 111, 71, 13, 6, 240, 91, 42, 138, 123, 37, 195, 90, 2, 80, 116, 14, 46, 41, 98, 65, 30, 172, 198, 210, 176, 101, 185, 204, 193, 10, 143, 66, 70, 230, 205, 233, 68, 150, 89, 219, 22, 109, 248, 154, 249, 194, 50, 201, 73, 93, 122, 254, 137, 83, 236, 188, 67, 110, 31, 212, 256, 217, 199, 250, 234, 108, 208, 96, 242, 171, 158, 152, 169, 78, 36, 155, 32, 252, 57, 224, 222, 142, 26, 12, 223, 182, 84, 19, 246, 74, 133, 180, 4, 160, 232, 28, 92, 82, 196, 130, 60, 87, 139, 163, 95, 202, 113, 151, 129, 20, 29, 132, 140, 203, 153, 209, 136, 43, 178, 181, 44, 218, 239, 51, 241, 131, 100, 145, 146, 186, 244, 251, 17, 166, 215, 119, 134, 220, 62, 167, 255, 177, 141, 243, 211, 216, 159, 192, 227, 85, 59, 47, 81, 156, 72, 53, 64, 247, 114, 191, 187, 27, 52, 24, 189, 107, 168, 38, 235, 148, 9, 103, 8, 63, 207, 56, 184, 164, 135, 3, 120, 174, 21, 69, 190, 147, 226, 45, 1],
+[1, 41, 139, 45, 46, 87, 226, 14, 60, 147, 116, 130, 190, 80, 196, 69, 2, 82, 21, 90, 92, 174, 195, 28, 120, 37, 232, 3, 123, 160, 135, 138, 4, 164, 42, 180, 184, 91, 133, 56, 240, 74, 207, 6, 246, 63, 13, 19, 8, 71, 84, 103, 111, 182, 9, 112, 223, 148, 157, 12, 235, 126, 26, 38, 16, 142, 168, 206, 222, 107, 18, 224, 189, 39, 57, 24, 213, 252, 52, 76, 32, 27, 79, 155, 187, 214, 36, 191, 121, 78, 114, 48, 169, 247, 104, 152, 64, 54, 158, 53, 117, 171, 72, 125, 242, 156, 228, 96, 81, 237, 208, 47, 128, 108, 59, 106, 234, 85, 144, 250, 227, 55, 199, 192, 162, 217, 159, 94, 256, 216, 118, 212, 211, 170, 31, 243, 197, 110, 141, 127, 67, 177, 61, 188, 255, 175, 236, 167, 165, 83, 62, 229, 137, 220, 25, 254, 134, 97, 122, 119, 253, 93, 215, 77, 73, 166, 124, 201, 17, 183, 50, 251, 11, 194, 244, 238, 249, 186, 173, 154, 146, 75, 248, 145, 34, 109, 100, 245, 22, 131, 231, 219, 241, 115, 89, 51, 35, 150, 239, 33, 68, 218, 200, 233, 44, 5, 205, 181, 225, 230, 178, 102, 70, 43, 221, 66, 136, 179, 143, 209, 88, 10, 153, 105, 193, 203, 99, 204, 140, 86, 185, 132, 15, 101, 29, 161, 176, 20, 49, 210, 129, 149, 198, 151, 23, 172, 113, 7, 30, 202, 58, 65, 95, 40, 98, 163, 1],
+[1, 42, 222, 72, 197, 50, 44, 49, 2, 84, 187, 144, 137, 100, 88, 98, 4, 168, 117, 31, 17, 200, 176, 196, 8, 79, 234, 62, 34, 143, 95, 135, 16, 158, 211, 124, 68, 29, 190, 13, 32, 59, 165, 248, 136, 58, 123, 26, 64, 118, 73, 239, 15, 116, 246, 52, 128, 236, 146, 221, 30, 232, 235, 104, 256, 215, 35, 185, 60, 207, 213, 208, 255, 173, 70, 113, 120, 157, 169, 159, 253, 89, 140, 226, 240, 57, 81, 61, 249, 178, 23, 195, 223, 114, 162, 122, 241, 99, 46, 133, 189, 228, 67, 244, 225, 198, 92, 9, 121, 199, 134, 231, 193, 139, 184, 18, 242, 141, 11, 205, 129, 21, 111, 36, 227, 25, 22, 153, 1, 42, 222, 72, 197, 50, 44, 49, 2, 84, 187, 144, 137, 100, 88, 98, 4, 168, 117, 31, 17, 200, 176, 196, 8, 79, 234, 62, 34, 143, 95, 135, 16, 158, 211, 124, 68, 29, 190, 13, 32, 59, 165, 248, 136, 58, 123, 26, 64, 118, 73, 239, 15, 116, 246, 52, 128, 236, 146, 221, 30, 232, 235, 104, 256, 215, 35, 185, 60, 207, 213, 208, 255, 173, 70, 113, 120, 157, 169, 159, 253, 89, 140, 226, 240, 57, 81, 61, 249, 178, 23, 195, 223, 114, 162, 122, 241, 99, 46, 133, 189, 228, 67, 244, 225, 198, 92, 9, 121, 199, 134, 231, 193, 139, 184, 18, 242, 141, 11, 205, 129, 21, 111, 36, 227, 25, 22, 153, 1],
+[1, 43, 50, 94, 187, 74, 98, 102, 17, 217, 79, 56, 95, 230, 124, 192, 32, 91, 58, 181, 73, 55, 52, 180, 30, 5, 215, 250, 213, 164, 113, 233, 253, 85, 57, 138, 23, 218, 122, 106, 189, 160, 198, 33, 134, 108, 18, 3, 129, 150, 25, 47, 222, 37, 49, 51, 137, 237, 168, 28, 176, 115, 62, 96, 16, 174, 29, 219, 165, 156, 26, 90, 15, 131, 236, 125, 235, 82, 185, 245, 255, 171, 157, 69, 140, 109, 61, 53, 223, 80, 99, 145, 67, 54, 9, 130, 193, 75, 141, 152, 111, 147, 153, 154, 197, 247, 84, 14, 88, 186, 31, 48, 8, 87, 143, 238, 211, 78, 13, 45, 136, 194, 118, 191, 246, 41, 221, 251, 256, 214, 207, 163, 70, 183, 159, 155, 240, 40, 178, 201, 162, 27, 133, 65, 225, 166, 199, 76, 184, 202, 205, 77, 227, 252, 42, 7, 44, 93, 144, 24, 4, 172, 200, 119, 234, 39, 135, 151, 68, 97, 59, 224, 123, 149, 239, 254, 128, 107, 232, 210, 35, 220, 208, 206, 120, 20, 89, 229, 81, 142, 195, 161, 241, 83, 228, 38, 92, 101, 231, 167, 242, 126, 21, 132, 22, 175, 72, 12, 2, 86, 100, 188, 117, 148, 196, 204, 34, 177, 158, 112, 190, 203, 248, 127, 64, 182, 116, 105, 146, 110, 104, 103, 60, 10, 173, 243, 169, 71, 226, 209, 249, 170, 114, 19, 46, 179, 244, 212, 121, 63, 139, 66, 11, 216, 36, 6, 1],
+[1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1],
+[1, 45, 226, 147, 190, 69, 21, 174, 120, 3, 135, 164, 184, 56, 207, 63, 8, 103, 9, 148, 235, 38, 168, 107, 189, 24, 52, 27, 187, 191, 114, 247, 64, 53, 72, 156, 81, 47, 59, 85, 227, 192, 159, 216, 211, 243, 141, 177, 255, 167, 62, 220, 134, 119, 215, 166, 17, 251, 244, 186, 146, 145, 100, 131, 241, 51, 239, 218, 44, 181, 178, 43, 136, 209, 153, 203, 140, 132, 29, 20, 129, 151, 113, 202, 95, 163, 139, 87, 60, 130, 196, 82, 92, 28, 232, 160, 4, 180, 133, 74, 246, 19, 84, 182, 223, 12, 26, 142, 222, 224, 57, 252, 32, 155, 36, 78, 169, 152, 158, 171, 242, 96, 208, 108, 234, 250, 199, 217, 256, 212, 31, 110, 67, 188, 236, 83, 137, 254, 122, 93, 73, 201, 50, 194, 249, 154, 248, 109, 22, 219, 89, 150, 68, 233, 205, 230, 70, 66, 143, 10, 193, 204, 185, 101, 176, 210, 198, 172, 30, 65, 98, 41, 46, 14, 116, 80, 2, 90, 195, 37, 123, 138, 42, 91, 240, 6, 13, 71, 111, 112, 157, 126, 16, 206, 18, 39, 213, 76, 79, 214, 121, 48, 104, 54, 117, 125, 228, 237, 128, 106, 144, 55, 162, 94, 118, 170, 197, 127, 61, 175, 165, 229, 25, 97, 253, 77, 124, 183, 11, 238, 173, 75, 34, 245, 231, 115, 35, 33, 200, 5, 225, 102, 221, 179, 88, 105, 99, 86, 15, 161, 49, 149, 23, 7, 58, 40, 1],
+[1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1],
+[1, 47, 153, 252, 22, 6, 25, 147, 227, 132, 36, 150, 111, 77, 21, 216, 129, 152, 205, 126, 11, 3, 141, 202, 242, 66, 18, 75, 184, 167, 139, 108, 193, 76, 231, 63, 134, 130, 199, 101, 121, 33, 9, 166, 92, 212, 198, 54, 225, 38, 244, 160, 67, 65, 228, 179, 189, 145, 133, 83, 46, 106, 99, 27, 241, 19, 122, 80, 162, 161, 114, 218, 223, 201, 195, 170, 23, 53, 178, 142, 249, 138, 61, 40, 81, 209, 57, 109, 240, 229, 226, 85, 140, 155, 89, 71, 253, 69, 159, 20, 169, 233, 157, 183, 120, 243, 113, 171, 70, 206, 173, 164, 255, 163, 208, 10, 213, 245, 207, 220, 60, 250, 185, 214, 35, 103, 215, 82, 256, 210, 104, 5, 235, 251, 232, 110, 30, 125, 221, 107, 146, 180, 236, 41, 128, 105, 52, 131, 246, 254, 116, 55, 15, 191, 239, 182, 73, 90, 118, 149, 64, 181, 26, 194, 123, 127, 58, 156, 136, 224, 248, 91, 165, 45, 59, 203, 32, 219, 13, 97, 190, 192, 29, 78, 68, 112, 124, 174, 211, 151, 158, 230, 16, 238, 135, 177, 95, 96, 143, 39, 34, 56, 62, 87, 234, 204, 79, 115, 8, 119, 196, 217, 176, 48, 200, 148, 17, 28, 31, 172, 117, 102, 168, 186, 4, 188, 98, 237, 88, 24, 100, 74, 137, 14, 144, 86, 187, 51, 84, 93, 2, 94, 49, 247, 44, 12, 50, 37, 197, 7, 72, 43, 222, 154, 42, 175, 1],
+[1, 48, 248, 82, 81, 33, 42, 217, 136, 103, 61, 101, 222, 119, 58, 214, 249, 130, 72, 115, 123, 250, 178, 63, 197, 204, 26, 220, 23, 76, 50, 87, 64, 245, 195, 108, 44, 56, 118, 10, 223, 167, 49, 39, 73, 163, 114, 75, 2, 96, 239, 164, 162, 66, 84, 177, 15, 206, 122, 202, 187, 238, 116, 171, 241, 3, 144, 230, 246, 243, 99, 126, 137, 151, 52, 183, 46, 152, 100, 174, 128, 233, 133, 216, 88, 112, 236, 20, 189, 77, 98, 78, 146, 69, 228, 150, 4, 192, 221, 71, 67, 132, 168, 97, 30, 155, 244, 147, 117, 219, 232, 85, 225, 6, 31, 203, 235, 229, 198, 252, 17, 45, 104, 109, 92, 47, 200, 91, 256, 209, 9, 175, 176, 224, 215, 40, 121, 154, 196, 156, 35, 138, 199, 43, 8, 127, 185, 142, 134, 7, 79, 194, 60, 53, 231, 37, 234, 181, 207, 170, 193, 12, 62, 149, 213, 201, 139, 247, 34, 90, 208, 218, 184, 94, 143, 182, 255, 161, 18, 93, 95, 191, 173, 80, 242, 51, 135, 55, 70, 19, 141, 86, 16, 254, 113, 27, 11, 14, 158, 131, 120, 106, 205, 74, 211, 105, 157, 83, 129, 24, 124, 41, 169, 145, 21, 237, 68, 180, 159, 179, 111, 188, 29, 107, 253, 65, 36, 186, 190, 125, 89, 160, 227, 102, 13, 110, 140, 38, 25, 172, 32, 251, 226, 54, 22, 28, 59, 5, 240, 212, 153, 148, 165, 210, 57, 166, 1],
+[1, 49, 88, 200, 34, 124, 165, 118, 128, 104, 213, 157, 240, 195, 46, 198, 193, 205, 22, 50, 137, 31, 234, 158, 32, 26, 246, 232, 60, 113, 140, 178, 241, 244, 134, 141, 227, 72, 187, 168, 8, 135, 190, 58, 15, 221, 35, 173, 253, 61, 162, 228, 121, 18, 111, 42, 2, 98, 176, 143, 68, 248, 73, 236, 256, 208, 169, 57, 223, 133, 92, 139, 129, 153, 44, 100, 17, 62, 211, 59, 64, 52, 235, 207, 120, 226, 23, 99, 225, 231, 11, 25, 197, 144, 117, 79, 16, 13, 123, 116, 30, 185, 70, 89, 249, 122, 67, 199, 242, 36, 222, 84, 4, 196, 95, 29, 136, 239, 146, 215, 255, 159, 81, 114, 189, 9, 184, 21, 1, 49, 88, 200, 34, 124, 165, 118, 128, 104, 213, 157, 240, 195, 46, 198, 193, 205, 22, 50, 137, 31, 234, 158, 32, 26, 246, 232, 60, 113, 140, 178, 241, 244, 134, 141, 227, 72, 187, 168, 8, 135, 190, 58, 15, 221, 35, 173, 253, 61, 162, 228, 121, 18, 111, 42, 2, 98, 176, 143, 68, 248, 73, 236, 256, 208, 169, 57, 223, 133, 92, 139, 129, 153, 44, 100, 17, 62, 211, 59, 64, 52, 235, 207, 120, 226, 23, 99, 225, 231, 11, 25, 197, 144, 117, 79, 16, 13, 123, 116, 30, 185, 70, 89, 249, 122, 67, 199, 242, 36, 222, 84, 4, 196, 95, 29, 136, 239, 146, 215, 255, 159, 81, 114, 189, 9, 184, 21, 1],
+[1, 50, 187, 98, 17, 79, 95, 124, 32, 58, 73, 52, 30, 215, 213, 113, 253, 57, 23, 122, 189, 198, 134, 18, 129, 25, 222, 49, 137, 168, 176, 62, 16, 29, 165, 26, 15, 236, 235, 185, 255, 157, 140, 61, 223, 99, 67, 9, 193, 141, 111, 153, 197, 84, 88, 31, 8, 143, 211, 13, 136, 118, 246, 221, 256, 207, 70, 159, 240, 178, 162, 133, 225, 199, 184, 205, 227, 42, 44, 144, 4, 200, 234, 135, 68, 59, 123, 239, 128, 232, 35, 208, 120, 89, 81, 195, 241, 228, 92, 231, 242, 21, 22, 72, 2, 100, 117, 196, 34, 158, 190, 248, 64, 116, 146, 104, 60, 173, 169, 226, 249, 114, 46, 244, 121, 139, 11, 36, 1, 50, 187, 98, 17, 79, 95, 124, 32, 58, 73, 52, 30, 215, 213, 113, 253, 57, 23, 122, 189, 198, 134, 18, 129, 25, 222, 49, 137, 168, 176, 62, 16, 29, 165, 26, 15, 236, 235, 185, 255, 157, 140, 61, 223, 99, 67, 9, 193, 141, 111, 153, 197, 84, 88, 31, 8, 143, 211, 13, 136, 118, 246, 221, 256, 207, 70, 159, 240, 178, 162, 133, 225, 199, 184, 205, 227, 42, 44, 144, 4, 200, 234, 135, 68, 59, 123, 239, 128, 232, 35, 208, 120, 89, 81, 195, 241, 228, 92, 231, 242, 21, 22, 72, 2, 100, 117, 196, 34, 158, 190, 248, 64, 116, 146, 104, 60, 173, 169, 226, 249, 114, 46, 244, 121, 139, 11, 36, 1],
+[1, 51, 31, 39, 190, 181, 236, 214, 120, 209, 122, 54, 184, 132, 50, 237, 8, 151, 248, 55, 235, 163, 89, 170, 189, 130, 205, 175, 187, 28, 143, 97, 64, 180, 185, 183, 81, 19, 198, 75, 227, 12, 98, 115, 211, 224, 116, 5, 255, 155, 195, 179, 134, 152, 42, 86, 17, 96, 13, 149, 146, 250, 157, 40, 241, 212, 18, 147, 44, 188, 79, 174, 136, 254, 104, 164, 140, 201, 228, 63, 129, 154, 144, 148, 95, 219, 118, 107, 60, 233, 61, 27, 92, 66, 25, 247, 4, 204, 124, 156, 246, 210, 173, 85, 223, 65, 231, 216, 222, 14, 200, 177, 32, 90, 221, 220, 169, 138, 99, 166, 242, 6, 49, 186, 234, 112, 58, 131, 256, 206, 226, 218, 67, 76, 21, 43, 137, 48, 135, 203, 73, 125, 207, 20, 249, 106, 9, 202, 22, 94, 168, 87, 68, 127, 52, 82, 70, 229, 114, 160, 193, 77, 72, 74, 176, 238, 59, 182, 30, 245, 159, 142, 46, 33, 141, 252, 2, 102, 62, 78, 123, 105, 215, 171, 240, 161, 244, 108, 111, 7, 100, 217, 16, 45, 239, 110, 213, 69, 178, 83, 121, 3, 153, 93, 117, 56, 29, 194, 128, 103, 113, 109, 162, 38, 139, 150, 197, 24, 196, 230, 165, 191, 232, 10, 253, 53, 133, 101, 11, 47, 84, 172, 34, 192, 26, 41, 35, 243, 57, 80, 225, 167, 36, 37, 88, 119, 158, 91, 15, 251, 208, 71, 23, 145, 199, 126, 1],
+[1, 52, 134, 29, 223, 31, 70, 42, 128, 231, 190, 114, 17, 113, 222, 236, 193, 13, 162, 200, 120, 72, 146, 139, 32, 122, 176, 157, 197, 221, 184, 59, 241, 196, 169, 50, 30, 18, 165, 99, 8, 159, 44, 232, 242, 248, 46, 79, 253, 49, 235, 141, 136, 133, 234, 89, 2, 104, 11, 58, 189, 62, 140, 84, 256, 205, 123, 228, 34, 226, 187, 215, 129, 26, 67, 143, 240, 144, 35, 21, 64, 244, 95, 57, 137, 185, 111, 118, 225, 135, 81, 100, 60, 36, 73, 198, 16, 61, 88, 207, 227, 239, 92, 158, 249, 98, 213, 25, 15, 9, 211, 178, 4, 208, 22, 116, 121, 124, 23, 168, 255, 153, 246, 199, 68, 195, 117, 173, 1, 52, 134, 29, 223, 31, 70, 42, 128, 231, 190, 114, 17, 113, 222, 236, 193, 13, 162, 200, 120, 72, 146, 139, 32, 122, 176, 157, 197, 221, 184, 59, 241, 196, 169, 50, 30, 18, 165, 99, 8, 159, 44, 232, 242, 248, 46, 79, 253, 49, 235, 141, 136, 133, 234, 89, 2, 104, 11, 58, 189, 62, 140, 84, 256, 205, 123, 228, 34, 226, 187, 215, 129, 26, 67, 143, 240, 144, 35, 21, 64, 244, 95, 57, 137, 185, 111, 118, 225, 135, 81, 100, 60, 36, 73, 198, 16, 61, 88, 207, 227, 239, 92, 158, 249, 98, 213, 25, 15, 9, 211, 178, 4, 208, 22, 116, 121, 124, 23, 168, 255, 153, 246, 199, 68, 195, 117, 173, 1],
+[1, 53, 239, 74, 67, 210, 79, 75, 120, 192, 153, 142, 73, 14, 228, 5, 8, 167, 113, 78, 22, 138, 118, 86, 189, 251, 196, 108, 70, 112, 25, 40, 64, 51, 133, 110, 176, 76, 173, 174, 227, 209, 26, 93, 46, 125, 200, 63, 255, 151, 36, 109, 123, 94, 99, 107, 17, 130, 208, 230, 111, 229, 58, 247, 241, 180, 31, 101, 213, 238, 21, 85, 136, 12, 122, 41, 117, 33, 207, 177, 129, 155, 248, 37, 162, 105, 168, 166, 60, 96, 205, 71, 165, 7, 114, 131, 4, 212, 185, 39, 11, 69, 59, 43, 223, 254, 98, 54, 35, 56, 141, 20, 32, 154, 195, 55, 88, 38, 215, 87, 242, 233, 13, 175, 23, 191, 100, 160, 256, 204, 18, 183, 190, 47, 178, 182, 137, 65, 104, 115, 184, 243, 29, 252, 249, 90, 144, 179, 235, 119, 139, 171, 68, 6, 61, 149, 187, 145, 232, 217, 193, 206, 124, 147, 81, 181, 84, 83, 30, 48, 231, 164, 211, 132, 57, 194, 2, 106, 221, 148, 134, 163, 158, 150, 240, 127, 49, 27, 146, 28, 199, 10, 16, 77, 226, 156, 44, 19, 236, 172, 121, 245, 135, 216, 140, 224, 50, 80, 128, 102, 9, 220, 95, 152, 89, 91, 197, 161, 52, 186, 92, 250, 143, 126, 253, 45, 72, 218, 246, 188, 198, 214, 34, 3, 159, 203, 222, 201, 116, 237, 225, 103, 62, 202, 169, 219, 42, 170, 15, 24, 244, 82, 234, 66, 157, 97, 1],
+[1, 54, 89, 180, 211, 86, 18, 201, 60, 156, 200, 6, 67, 20, 52, 238, 2, 108, 178, 103, 165, 172, 36, 145, 120, 55, 143, 12, 134, 40, 104, 219, 4, 216, 99, 206, 73, 87, 72, 33, 240, 110, 29, 24, 11, 80, 208, 181, 8, 175, 198, 155, 146, 174, 144, 66, 223, 220, 58, 48, 22, 160, 159, 105, 16, 93, 139, 53, 35, 91, 31, 132, 189, 183, 116, 96, 44, 63, 61, 210, 32, 186, 21, 106, 70, 182, 62, 7, 121, 109, 232, 192, 88, 126, 122, 163, 64, 115, 42, 212, 140, 107, 124, 14, 242, 218, 207, 127, 176, 252, 244, 69, 128, 230, 84, 167, 23, 214, 248, 28, 227, 179, 157, 254, 95, 247, 231, 138, 256, 203, 168, 77, 46, 171, 239, 56, 197, 101, 57, 251, 190, 237, 205, 19, 255, 149, 79, 154, 92, 85, 221, 112, 137, 202, 114, 245, 123, 217, 153, 38, 253, 41, 158, 51, 184, 170, 185, 224, 17, 147, 228, 233, 246, 177, 49, 76, 249, 82, 59, 102, 111, 83, 113, 191, 34, 37, 199, 209, 235, 97, 98, 152, 241, 164, 118, 204, 222, 166, 226, 125, 68, 74, 141, 161, 213, 194, 196, 47, 225, 71, 236, 151, 187, 75, 195, 250, 136, 148, 25, 65, 169, 131, 135, 94, 193, 142, 215, 45, 117, 150, 133, 243, 15, 39, 50, 130, 81, 5, 13, 188, 129, 27, 173, 90, 234, 43, 9, 229, 30, 78, 100, 3, 162, 10, 26, 119, 1],
+[1, 55, 198, 96, 140, 247, 221, 76, 68, 142, 100, 103, 11, 91, 122, 28, 255, 147, 118, 65, 234, 20, 72, 105, 121, 230, 57, 51, 235, 75, 13, 201, 4, 220, 21, 127, 46, 217, 113, 47, 15, 54, 143, 155, 44, 107, 231, 112, 249, 74, 215, 3, 165, 80, 31, 163, 227, 149, 228, 204, 169, 43, 52, 33, 16, 109, 84, 251, 184, 97, 195, 188, 60, 216, 58, 106, 176, 171, 153, 191, 225, 39, 89, 12, 146, 63, 124, 138, 137, 82, 141, 45, 162, 172, 208, 132, 64, 179, 79, 233, 222, 131, 9, 238, 240, 93, 232, 167, 190, 170, 98, 250, 129, 156, 99, 48, 70, 252, 239, 38, 34, 71, 50, 180, 134, 174, 61, 14, 256, 202, 59, 161, 117, 10, 36, 181, 189, 115, 157, 154, 246, 166, 135, 229, 2, 110, 139, 192, 23, 237, 185, 152, 136, 27, 200, 206, 22, 182, 244, 56, 253, 37, 236, 130, 211, 40, 144, 210, 242, 203, 114, 102, 213, 150, 26, 145, 8, 183, 42, 254, 92, 177, 226, 94, 30, 108, 29, 53, 88, 214, 205, 224, 241, 148, 173, 6, 73, 160, 62, 69, 197, 41, 199, 151, 81, 86, 104, 66, 32, 218, 168, 245, 111, 194, 133, 119, 120, 175, 116, 212, 95, 85, 49, 125, 193, 78, 178, 24, 35, 126, 248, 19, 17, 164, 25, 90, 67, 87, 159, 7, 128, 101, 158, 209, 187, 5, 18, 219, 223, 186, 207, 77, 123, 83, 196, 243, 1],
+[1, 56, 52, 85, 134, 51, 29, 82, 223, 152, 31, 194, 70, 65, 42, 39, 128, 229, 231, 86, 190, 103, 114, 216, 17, 181, 113, 160, 222, 96, 236, 109, 193, 14, 13, 214, 162, 77, 200, 149, 120, 38, 72, 177, 146, 209, 139, 74, 32, 250, 122, 150, 176, 90, 157, 54, 197, 238, 221, 40, 184, 24, 59, 220, 241, 132, 196, 182, 169, 212, 50, 230, 30, 138, 18, 237, 165, 245, 99, 147, 8, 191, 159, 166, 44, 151, 232, 142, 242, 188, 248, 10, 46, 6, 79, 55, 253, 33, 49, 174, 235, 53, 141, 186, 136, 163, 133, 252, 234, 254, 89, 101, 2, 112, 104, 170, 11, 102, 58, 164, 189, 47, 62, 131, 140, 130, 84, 78, 256, 201, 205, 172, 123, 206, 228, 175, 34, 105, 226, 63, 187, 192, 215, 218, 129, 28, 26, 171, 67, 154, 143, 41, 240, 76, 144, 97, 35, 161, 21, 148, 64, 243, 244, 43, 95, 180, 57, 108, 137, 219, 185, 80, 111, 48, 118, 183, 225, 7, 135, 107, 81, 167, 100, 203, 60, 19, 36, 217, 73, 233, 198, 37, 16, 125, 61, 75, 88, 45, 207, 27, 227, 119, 239, 20, 92, 12, 158, 110, 249, 66, 98, 91, 213, 106, 25, 115, 15, 69, 9, 247, 211, 251, 178, 202, 4, 224, 208, 83, 22, 204, 116, 71, 121, 94, 124, 5, 23, 3, 168, 156, 255, 145, 153, 87, 246, 155, 199, 93, 68, 210, 195, 126, 117, 127, 173, 179, 1],
+[1, 57, 165, 153, 240, 59, 22, 226, 32, 25, 140, 13, 227, 89, 190, 36, 253, 29, 111, 159, 68, 21, 169, 124, 129, 157, 211, 205, 120, 158, 11, 113, 16, 141, 70, 135, 242, 173, 95, 18, 255, 143, 184, 208, 34, 139, 213, 62, 193, 207, 234, 231, 60, 79, 134, 185, 8, 199, 35, 196, 121, 215, 176, 9, 256, 200, 92, 104, 17, 198, 235, 31, 225, 232, 117, 244, 30, 168, 67, 221, 4, 228, 146, 98, 189, 236, 88, 133, 128, 100, 46, 52, 137, 99, 246, 144, 241, 116, 187, 122, 15, 84, 162, 239, 2, 114, 73, 49, 223, 118, 44, 195, 64, 50, 23, 26, 197, 178, 123, 72, 249, 58, 222, 61, 136, 42, 81, 248, 1, 57, 165, 153, 240, 59, 22, 226, 32, 25, 140, 13, 227, 89, 190, 36, 253, 29, 111, 159, 68, 21, 169, 124, 129, 157, 211, 205, 120, 158, 11, 113, 16, 141, 70, 135, 242, 173, 95, 18, 255, 143, 184, 208, 34, 139, 213, 62, 193, 207, 234, 231, 60, 79, 134, 185, 8, 199, 35, 196, 121, 215, 176, 9, 256, 200, 92, 104, 17, 198, 235, 31, 225, 232, 117, 244, 30, 168, 67, 221, 4, 228, 146, 98, 189, 236, 88, 133, 128, 100, 46, 52, 137, 99, 246, 144, 241, 116, 187, 122, 15, 84, 162, 239, 2, 114, 73, 49, 223, 118, 44, 195, 64, 50, 23, 26, 197, 178, 123, 72, 249, 58, 222, 61, 136, 42, 81, 248, 1],
+[1, 58, 23, 49, 15, 99, 88, 221, 225, 200, 35, 231, 34, 173, 11, 124, 253, 25, 165, 61, 197, 118, 162, 144, 128, 228, 117, 104, 121, 79, 213, 18, 16, 157, 111, 13, 240, 42, 123, 195, 2, 116, 46, 98, 30, 198, 176, 185, 193, 143, 70, 205, 68, 89, 22, 248, 249, 50, 73, 122, 137, 236, 67, 31, 256, 199, 234, 208, 242, 158, 169, 36, 32, 57, 222, 26, 223, 84, 246, 133, 4, 232, 92, 196, 60, 139, 95, 113, 129, 29, 140, 153, 136, 178, 44, 239, 241, 100, 146, 244, 17, 215, 134, 62, 255, 141, 211, 159, 227, 59, 81, 72, 64, 114, 187, 52, 189, 168, 235, 9, 8, 207, 184, 135, 120, 21, 190, 226, 1, 58, 23, 49, 15, 99, 88, 221, 225, 200, 35, 231, 34, 173, 11, 124, 253, 25, 165, 61, 197, 118, 162, 144, 128, 228, 117, 104, 121, 79, 213, 18, 16, 157, 111, 13, 240, 42, 123, 195, 2, 116, 46, 98, 30, 198, 176, 185, 193, 143, 70, 205, 68, 89, 22, 248, 249, 50, 73, 122, 137, 236, 67, 31, 256, 199, 234, 208, 242, 158, 169, 36, 32, 57, 222, 26, 223, 84, 246, 133, 4, 232, 92, 196, 60, 139, 95, 113, 129, 29, 140, 153, 136, 178, 44, 239, 241, 100, 146, 244, 17, 215, 134, 62, 255, 141, 211, 159, 227, 59, 81, 72, 64, 114, 187, 52, 189, 168, 235, 9, 8, 207, 184, 135, 120, 21, 190, 226, 1],
+[1, 59, 140, 36, 68, 157, 11, 135, 255, 139, 234, 185, 121, 200, 235, 244, 4, 236, 46, 144, 15, 114, 44, 26, 249, 42, 165, 226, 227, 29, 169, 205, 16, 173, 184, 62, 60, 199, 176, 104, 225, 168, 146, 133, 137, 116, 162, 49, 64, 178, 222, 248, 240, 25, 190, 159, 129, 158, 70, 18, 34, 207, 134, 196, 256, 198, 117, 221, 189, 100, 246, 122, 2, 118, 23, 72, 136, 57, 22, 13, 253, 21, 211, 113, 242, 143, 213, 231, 8, 215, 92, 31, 30, 228, 88, 52, 241, 84, 73, 195, 197, 58, 81, 153, 32, 89, 111, 124, 120, 141, 95, 208, 193, 79, 35, 9, 17, 232, 67, 98, 128, 99, 187, 239, 223, 50, 123, 61, 1, 59, 140, 36, 68, 157, 11, 135, 255, 139, 234, 185, 121, 200, 235, 244, 4, 236, 46, 144, 15, 114, 44, 26, 249, 42, 165, 226, 227, 29, 169, 205, 16, 173, 184, 62, 60, 199, 176, 104, 225, 168, 146, 133, 137, 116, 162, 49, 64, 178, 222, 248, 240, 25, 190, 159, 129, 158, 70, 18, 34, 207, 134, 196, 256, 198, 117, 221, 189, 100, 246, 122, 2, 118, 23, 72, 136, 57, 22, 13, 253, 21, 211, 113, 242, 143, 213, 231, 8, 215, 92, 31, 30, 228, 88, 52, 241, 84, 73, 195, 197, 58, 81, 153, 32, 89, 111, 124, 120, 141, 95, 208, 193, 79, 35, 9, 17, 232, 67, 98, 128, 99, 187, 239, 223, 50, 123, 61, 1],
+[1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1],
+[1, 61, 123, 50, 223, 239, 187, 99, 128, 98, 67, 232, 17, 9, 35, 79, 193, 208, 95, 141, 120, 124, 111, 89, 32, 153, 81, 58, 197, 195, 73, 84, 241, 52, 88, 228, 30, 31, 92, 215, 8, 231, 213, 143, 242, 113, 211, 21, 253, 13, 22, 57, 136, 72, 23, 118, 2, 122, 246, 100, 189, 221, 117, 198, 256, 196, 134, 207, 34, 18, 70, 158, 129, 159, 190, 25, 240, 248, 222, 178, 64, 49, 162, 116, 137, 133, 146, 168, 225, 104, 176, 199, 60, 62, 184, 173, 16, 205, 169, 29, 227, 226, 165, 42, 249, 26, 44, 114, 15, 144, 46, 236, 4, 244, 235, 200, 121, 185, 234, 139, 255, 135, 11, 157, 68, 36, 140, 59, 1, 61, 123, 50, 223, 239, 187, 99, 128, 98, 67, 232, 17, 9, 35, 79, 193, 208, 95, 141, 120, 124, 111, 89, 32, 153, 81, 58, 197, 195, 73, 84, 241, 52, 88, 228, 30, 31, 92, 215, 8, 231, 213, 143, 242, 113, 211, 21, 253, 13, 22, 57, 136, 72, 23, 118, 2, 122, 246, 100, 189, 221, 117, 198, 256, 196, 134, 207, 34, 18, 70, 158, 129, 159, 190, 25, 240, 248, 222, 178, 64, 49, 162, 116, 137, 133, 146, 168, 225, 104, 176, 199, 60, 62, 184, 173, 16, 205, 169, 29, 227, 226, 165, 42, 249, 26, 44, 114, 15, 144, 46, 236, 4, 244, 235, 200, 121, 185, 234, 139, 255, 135, 11, 157, 68, 36, 140, 59, 1],
+[1, 62, 246, 89, 121, 49, 211, 232, 249, 18, 88, 59, 60, 122, 111, 200, 64, 113, 67, 42, 34, 52, 140, 199, 2, 124, 235, 178, 242, 98, 165, 207, 241, 36, 176, 118, 120, 244, 222, 143, 128, 226, 134, 84, 68, 104, 23, 141, 4, 248, 213, 99, 227, 196, 73, 157, 225, 72, 95, 236, 240, 231, 187, 29, 256, 195, 11, 168, 136, 208, 46, 25, 8, 239, 169, 198, 197, 135, 146, 57, 193, 144, 190, 215, 223, 205, 117, 58, 255, 133, 22, 79, 15, 159, 92, 50, 16, 221, 81, 139, 137, 13, 35, 114, 129, 31, 123, 173, 189, 153, 234, 116, 253, 9, 44, 158, 30, 61, 184, 100, 32, 185, 162, 21, 17, 26, 70, 228, 1, 62, 246, 89, 121, 49, 211, 232, 249, 18, 88, 59, 60, 122, 111, 200, 64, 113, 67, 42, 34, 52, 140, 199, 2, 124, 235, 178, 242, 98, 165, 207, 241, 36, 176, 118, 120, 244, 222, 143, 128, 226, 134, 84, 68, 104, 23, 141, 4, 248, 213, 99, 227, 196, 73, 157, 225, 72, 95, 236, 240, 231, 187, 29, 256, 195, 11, 168, 136, 208, 46, 25, 8, 239, 169, 198, 197, 135, 146, 57, 193, 144, 190, 215, 223, 205, 117, 58, 255, 133, 22, 79, 15, 159, 92, 50, 16, 221, 81, 139, 137, 13, 35, 114, 129, 31, 123, 173, 189, 153, 234, 116, 253, 9, 44, 158, 30, 61, 184, 100, 32, 185, 162, 21, 17, 26, 70, 228, 1],
+[1, 63, 114, 243, 146, 203, 196, 12, 242, 83, 89, 210, 123, 39, 144, 77, 225, 40, 207, 191, 211, 186, 153, 130, 223, 171, 236, 219, 176, 37, 18, 106, 253, 5, 58, 56, 187, 216, 244, 209, 60, 182, 158, 188, 22, 101, 195, 206, 128, 97, 200, 7, 184, 27, 159, 251, 136, 87, 84, 152, 67, 109, 185, 90, 16, 237, 25, 33, 23, 164, 52, 192, 17, 43, 139, 19, 169, 110, 248, 204, 2, 126, 228, 229, 35, 149, 135, 24, 227, 166, 178, 163, 246, 78, 31, 154, 193, 80, 157, 125, 165, 115, 49, 3, 189, 85, 215, 181, 95, 74, 36, 212, 249, 10, 116, 112, 117, 175, 231, 161, 120, 107, 59, 119, 44, 202, 133, 155, 256, 194, 143, 14, 111, 54, 61, 245, 15, 174, 168, 47, 134, 218, 113, 180, 32, 217, 50, 66, 46, 71, 104, 127, 34, 86, 21, 38, 81, 220, 239, 151, 4, 252, 199, 201, 70, 41, 13, 48, 197, 75, 99, 69, 235, 156, 62, 51, 129, 160, 57, 250, 73, 230, 98, 6, 121, 170, 173, 105, 190, 148, 72, 167, 241, 20, 232, 224, 234, 93, 205, 65, 240, 214, 118, 238, 88, 147, 9, 53, 255, 131, 29, 28, 222, 108, 122, 233, 30, 91, 79, 94, 11, 179, 226, 103, 64, 177, 100, 132, 92, 142, 208, 254, 68, 172, 42, 76, 162, 183, 221, 45, 8, 247, 141, 145, 140, 82, 26, 96, 137, 150, 198, 138, 213, 55, 124, 102, 1],
+[1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1],
+[1, 65, 113, 149, 176, 132, 99, 10, 136, 102, 205, 218, 35, 219, 100, 75, 249, 251, 124, 93, 134, 229, 236, 177, 197, 212, 159, 55, 234, 47, 228, 171, 64, 48, 36, 27, 213, 224, 168, 126, 223, 103, 13, 74, 184, 138, 232, 174, 2, 130, 226, 41, 95, 7, 198, 20, 15, 204, 153, 179, 70, 181, 200, 150, 241, 245, 248, 186, 11, 201, 215, 97, 137, 167, 61, 110, 211, 94, 199, 85, 128, 96, 72, 54, 169, 191, 79, 252, 189, 206, 26, 148, 111, 19, 207, 91, 4, 3, 195, 82, 190, 14, 139, 40, 30, 151, 49, 101, 140, 105, 143, 43, 225, 233, 239, 115, 22, 145, 173, 194, 17, 77, 122, 220, 165, 188, 141, 170, 256, 192, 144, 108, 81, 125, 158, 247, 121, 155, 52, 39, 222, 38, 157, 182, 8, 6, 133, 164, 123, 28, 21, 80, 60, 45, 98, 202, 23, 210, 29, 86, 193, 209, 221, 230, 44, 33, 89, 131, 34, 154, 244, 183, 73, 119, 25, 83, 255, 127, 31, 216, 162, 250, 59, 237, 242, 53, 104, 78, 187, 76, 57, 107, 16, 12, 9, 71, 246, 56, 42, 160, 120, 90, 196, 147, 46, 163, 58, 172, 129, 161, 185, 203, 88, 66, 178, 5, 68, 51, 231, 109, 146, 238, 50, 166, 253, 254, 62, 175, 67, 243, 118, 217, 227, 106, 208, 156, 117, 152, 114, 214, 32, 24, 18, 142, 235, 112, 84, 63, 240, 180, 135, 37, 92, 69, 116, 87, 1],
+[1, 66, 244, 170, 169, 103, 116, 203, 34, 188, 72, 126, 92, 161, 89, 220, 128, 224, 135, 172, 44, 77, 199, 27, 240, 163, 221, 194, 211, 48, 84, 147, 193, 145, 61, 171, 235, 90, 29, 115, 137, 47, 18, 160, 23, 233, 215, 55, 32, 56, 98, 43, 11, 212, 114, 71, 60, 105, 248, 177, 117, 12, 21, 101, 241, 229, 208, 107, 123, 151, 200, 93, 227, 76, 133, 40, 70, 251, 118, 78, 8, 14, 153, 75, 67, 53, 157, 82, 15, 219, 62, 237, 222, 3, 198, 218, 253, 250, 52, 91, 95, 102, 50, 216, 121, 19, 226, 10, 146, 127, 158, 148, 2, 132, 231, 83, 81, 206, 232, 149, 68, 119, 144, 252, 184, 65, 178, 183, 256, 191, 13, 87, 88, 154, 141, 54, 223, 69, 185, 131, 165, 96, 168, 37, 129, 33, 122, 85, 213, 180, 58, 230, 17, 94, 36, 63, 46, 209, 173, 110, 64, 112, 196, 86, 22, 167, 228, 142, 120, 210, 239, 97, 234, 24, 42, 202, 225, 201, 159, 214, 246, 45, 143, 186, 197, 152, 9, 80, 140, 245, 236, 156, 16, 28, 49, 150, 134, 106, 57, 164, 30, 181, 124, 217, 187, 6, 139, 179, 249, 243, 104, 182, 190, 204, 100, 175, 242, 38, 195, 20, 35, 254, 59, 39, 4, 7, 205, 166, 162, 155, 207, 41, 136, 238, 31, 247, 111, 130, 99, 109, 255, 125, 26, 174, 176, 51, 25, 108, 189, 138, 113, 5, 73, 192, 79, 74, 1],
+[1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1],
+[1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1],
+[1, 69, 135, 63, 235, 24, 114, 156, 227, 243, 62, 166, 146, 51, 178, 203, 129, 163, 196, 160, 246, 12, 57, 78, 242, 250, 31, 83, 73, 154, 89, 230, 193, 210, 98, 80, 123, 6, 157, 39, 121, 125, 144, 170, 165, 77, 173, 115, 225, 105, 49, 40, 190, 3, 207, 148, 189, 191, 72, 85, 211, 167, 215, 186, 241, 181, 153, 20, 95, 130, 232, 74, 223, 224, 36, 171, 234, 212, 236, 93, 249, 219, 205, 10, 176, 65, 116, 37, 240, 112, 18, 214, 117, 106, 118, 175, 253, 238, 231, 5, 88, 161, 58, 147, 120, 56, 9, 107, 187, 53, 59, 216, 255, 119, 244, 131, 44, 209, 29, 202, 60, 28, 133, 182, 222, 155, 158, 108, 256, 188, 122, 194, 22, 233, 143, 101, 30, 14, 195, 91, 111, 206, 79, 54, 128, 94, 61, 97, 11, 245, 200, 179, 15, 7, 226, 174, 184, 103, 168, 27, 64, 47, 159, 177, 134, 251, 100, 218, 136, 132, 113, 87, 92, 180, 84, 142, 32, 152, 208, 217, 67, 254, 50, 109, 68, 66, 185, 172, 46, 90, 42, 71, 16, 76, 104, 237, 162, 127, 25, 183, 34, 33, 221, 86, 23, 45, 21, 164, 8, 38, 52, 247, 81, 192, 141, 220, 17, 145, 239, 43, 140, 151, 139, 82, 4, 19, 26, 252, 169, 96, 199, 110, 137, 201, 248, 150, 70, 204, 198, 41, 2, 138, 13, 126, 213, 48, 228, 55, 197, 229, 124, 75, 35, 102, 99, 149, 1],
+[1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1],
+[1, 71, 158, 167, 35, 172, 133, 191, 197, 109, 29, 3, 213, 217, 244, 105, 2, 142, 59, 77, 70, 87, 9, 125, 137, 218, 58, 6, 169, 177, 231, 210, 4, 27, 118, 154, 140, 174, 18, 250, 17, 179, 116, 12, 81, 97, 205, 163, 8, 54, 236, 51, 23, 91, 36, 243, 34, 101, 232, 24, 162, 194, 153, 69, 16, 108, 215, 102, 46, 182, 72, 229, 68, 202, 207, 48, 67, 131, 49, 138, 32, 216, 173, 204, 92, 107, 144, 201, 136, 147, 157, 96, 134, 5, 98, 19, 64, 175, 89, 151, 184, 214, 31, 145, 15, 37, 57, 192, 11, 10, 196, 38, 128, 93, 178, 45, 111, 171, 62, 33, 30, 74, 114, 127, 22, 20, 135, 76, 256, 186, 99, 90, 222, 85, 124, 66, 60, 148, 228, 254, 44, 40, 13, 152, 255, 115, 198, 180, 187, 170, 248, 132, 120, 39, 199, 251, 88, 80, 26, 47, 253, 230, 139, 103, 117, 83, 239, 7, 240, 78, 141, 245, 176, 160, 52, 94, 249, 203, 21, 206, 234, 166, 221, 14, 223, 156, 25, 233, 95, 63, 104, 188, 241, 149, 42, 155, 211, 75, 185, 28, 189, 55, 50, 209, 190, 126, 208, 119, 225, 41, 84, 53, 165, 150, 113, 56, 121, 110, 100, 161, 123, 252, 159, 238, 193, 82, 168, 106, 73, 43, 226, 112, 242, 220, 200, 65, 246, 247, 61, 219, 129, 164, 79, 212, 146, 86, 195, 224, 227, 183, 143, 130, 235, 237, 122, 181, 1],
+[1, 72, 44, 84, 137, 98, 117, 200, 8, 62, 95, 158, 68, 13, 165, 58, 64, 239, 246, 236, 30, 104, 35, 207, 255, 113, 169, 89, 240, 61, 23, 114, 241, 133, 67, 198, 121, 231, 184, 141, 129, 36, 22, 42, 197, 49, 187, 100, 4, 31, 176, 79, 34, 135, 211, 29, 32, 248, 123, 118, 15, 52, 146, 232, 256, 185, 213, 173, 120, 159, 140, 57, 249, 195, 162, 99, 189, 244, 92, 199, 193, 18, 11, 21, 227, 153, 222, 50, 2, 144, 88, 168, 17, 196, 234, 143, 16, 124, 190, 59, 136, 26, 73, 116, 128, 221, 235, 215, 60, 208, 70, 157, 253, 226, 81, 178, 223, 122, 46, 228, 225, 9, 134, 139, 242, 205, 111, 25, 1, 72, 44, 84, 137, 98, 117, 200, 8, 62, 95, 158, 68, 13, 165, 58, 64, 239, 246, 236, 30, 104, 35, 207, 255, 113, 169, 89, 240, 61, 23, 114, 241, 133, 67, 198, 121, 231, 184, 141, 129, 36, 22, 42, 197, 49, 187, 100, 4, 31, 176, 79, 34, 135, 211, 29, 32, 248, 123, 118, 15, 52, 146, 232, 256, 185, 213, 173, 120, 159, 140, 57, 249, 195, 162, 99, 189, 244, 92, 199, 193, 18, 11, 21, 227, 153, 222, 50, 2, 144, 88, 168, 17, 196, 234, 143, 16, 124, 190, 59, 136, 26, 73, 116, 128, 221, 235, 215, 60, 208, 70, 157, 253, 226, 81, 178, 223, 122, 46, 228, 225, 9, 134, 139, 242, 205, 111, 25, 1],
+[1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1],
+[1, 74, 79, 192, 73, 5, 113, 138, 189, 108, 25, 51, 176, 174, 26, 125, 255, 109, 99, 130, 111, 247, 31, 238, 136, 41, 207, 155, 162, 166, 205, 7, 4, 39, 59, 254, 35, 20, 195, 38, 242, 175, 100, 204, 190, 182, 104, 243, 249, 179, 139, 6, 187, 217, 124, 181, 30, 164, 57, 106, 134, 150, 49, 28, 16, 156, 236, 245, 140, 80, 9, 152, 197, 186, 143, 45, 246, 214, 159, 201, 225, 202, 42, 24, 234, 97, 239, 210, 120, 142, 228, 167, 22, 86, 196, 112, 64, 110, 173, 209, 46, 63, 36, 94, 17, 230, 58, 180, 213, 85, 122, 33, 129, 37, 168, 96, 165, 131, 185, 69, 223, 54, 141, 154, 88, 87, 13, 191, 256, 183, 178, 65, 184, 252, 144, 119, 68, 149, 232, 206, 81, 83, 231, 132, 2, 148, 158, 127, 146, 10, 226, 19, 121, 216, 50, 102, 95, 91, 52, 250, 253, 218, 198, 3, 222, 237, 62, 219, 15, 82, 157, 53, 67, 75, 153, 14, 8, 78, 118, 251, 70, 40, 133, 76, 227, 93, 200, 151, 123, 107, 208, 229, 241, 101, 21, 12, 117, 177, 248, 105, 60, 71, 114, 212, 11, 43, 98, 56, 32, 55, 215, 233, 23, 160, 18, 47, 137, 115, 29, 90, 235, 171, 61, 145, 193, 147, 84, 48, 211, 194, 221, 163, 240, 27, 199, 77, 44, 172, 135, 224, 128, 220, 89, 161, 92, 126, 72, 188, 34, 203, 116, 103, 169, 170, 244, 66, 1],
+[1, 75, 228, 138, 70, 110, 26, 151, 17, 247, 21, 33, 162, 71, 185, 254, 32, 87, 100, 47, 184, 179, 61, 206, 30, 194, 158, 28, 44, 216, 9, 161, 253, 214, 116, 219, 234, 74, 153, 167, 189, 40, 173, 125, 123, 230, 31, 12, 129, 166, 114, 69, 35, 55, 13, 204, 137, 252, 139, 145, 81, 164, 221, 127, 16, 172, 50, 152, 92, 218, 159, 103, 15, 97, 79, 14, 22, 108, 133, 209, 255, 107, 58, 238, 117, 37, 205, 212, 223, 20, 215, 191, 190, 115, 144, 6, 193, 83, 57, 163, 146, 156, 135, 102, 197, 126, 198, 201, 169, 82, 239, 192, 8, 86, 25, 76, 46, 109, 208, 180, 136, 177, 168, 7, 11, 54, 195, 233, 256, 182, 29, 119, 187, 147, 231, 106, 240, 10, 236, 224, 95, 186, 72, 3, 225, 170, 157, 210, 73, 78, 196, 51, 227, 63, 99, 229, 213, 41, 248, 96, 4, 43, 141, 38, 23, 183, 104, 90, 68, 217, 84, 132, 134, 27, 226, 245, 128, 91, 143, 188, 222, 202, 244, 53, 120, 5, 118, 112, 176, 93, 36, 130, 241, 85, 207, 105, 165, 39, 98, 154, 242, 160, 178, 243, 235, 149, 124, 48, 2, 150, 199, 19, 140, 220, 52, 45, 34, 237, 42, 66, 67, 142, 113, 251, 64, 174, 200, 94, 111, 101, 122, 155, 60, 131, 59, 56, 88, 175, 18, 65, 249, 171, 232, 181, 211, 148, 49, 77, 121, 80, 89, 250, 246, 203, 62, 24, 1],
+[1, 76, 122, 20, 235, 127, 143, 74, 227, 33, 195, 171, 146, 45, 79, 93, 129, 38, 61, 10, 246, 192, 200, 37, 242, 145, 226, 214, 73, 151, 168, 175, 193, 19, 159, 5, 123, 96, 100, 147, 121, 201, 113, 107, 165, 204, 84, 216, 225, 138, 208, 131, 190, 48, 50, 202, 189, 229, 185, 182, 211, 102, 42, 108, 241, 69, 104, 194, 95, 24, 25, 101, 223, 243, 221, 91, 234, 51, 21, 54, 249, 163, 52, 97, 176, 12, 141, 179, 240, 250, 239, 174, 117, 154, 139, 27, 253, 210, 26, 177, 88, 6, 199, 218, 120, 125, 248, 87, 187, 77, 198, 142, 255, 105, 13, 217, 44, 3, 228, 109, 60, 191, 124, 172, 222, 167, 99, 71, 256, 181, 135, 237, 22, 130, 114, 183, 30, 224, 62, 86, 111, 212, 178, 164, 128, 219, 196, 247, 11, 65, 57, 220, 15, 112, 31, 43, 184, 106, 89, 82, 64, 238, 98, 252, 134, 161, 157, 110, 136, 56, 144, 150, 92, 53, 173, 41, 32, 119, 49, 126, 67, 209, 207, 55, 68, 28, 72, 75, 46, 155, 215, 149, 16, 188, 153, 63, 162, 233, 232, 156, 34, 14, 36, 166, 23, 206, 236, 203, 8, 94, 205, 160, 81, 245, 116, 78, 17, 7, 18, 83, 140, 103, 118, 230, 4, 47, 231, 80, 169, 251, 58, 39, 137, 132, 9, 170, 70, 180, 59, 115, 2, 152, 244, 40, 213, 254, 29, 148, 197, 66, 133, 85, 35, 90, 158, 186, 1],
+[1, 77, 18, 101, 67, 19, 178, 85, 120, 245, 104, 41, 73, 224, 29, 177, 8, 102, 144, 37, 22, 152, 139, 166, 189, 161, 61, 71, 70, 250, 232, 131, 64, 45, 124, 39, 176, 188, 84, 43, 227, 3, 231, 54, 46, 201, 57, 20, 255, 103, 221, 55, 123, 219, 158, 87, 17, 24, 49, 175, 111, 66, 199, 160, 241, 53, 226, 183, 213, 210, 236, 182, 136, 192, 135, 115, 117, 14, 50, 252, 129, 167, 9, 179, 162, 138, 89, 171, 60, 251, 52, 149, 165, 112, 143, 217, 4, 51, 72, 147, 11, 76, 198, 83, 223, 209, 159, 164, 35, 125, 116, 194, 32, 151, 62, 148, 88, 94, 42, 150, 242, 130, 244, 27, 23, 229, 157, 10, 256, 180, 239, 156, 190, 238, 79, 172, 137, 12, 153, 216, 184, 33, 228, 80, 249, 155, 113, 220, 235, 105, 118, 91, 68, 96, 196, 186, 187, 7, 25, 126, 193, 212, 133, 218, 81, 69, 173, 214, 30, 254, 26, 203, 211, 56, 200, 237, 2, 154, 36, 202, 134, 38, 99, 170, 240, 233, 208, 82, 146, 191, 58, 97, 16, 204, 31, 74, 44, 47, 21, 75, 121, 65, 122, 142, 140, 243, 207, 5, 128, 90, 248, 78, 95, 119, 168, 86, 197, 6, 205, 108, 92, 145, 114, 40, 253, 206, 185, 110, 246, 181, 59, 174, 34, 48, 98, 93, 222, 132, 141, 63, 225, 106, 195, 109, 169, 163, 215, 107, 15, 127, 13, 230, 234, 28, 100, 247, 1],
+[1, 78, 173, 130, 117, 131, 195, 47, 68, 164, 199, 102, 246, 170, 153, 112, 255, 101, 168, 254, 23, 252, 124, 163, 121, 186, 116, 53, 22, 174, 208, 33, 4, 55, 178, 6, 211, 10, 9, 188, 15, 142, 25, 151, 213, 166, 98, 191, 249, 147, 158, 245, 92, 237, 239, 138, 227, 230, 207, 212, 88, 182, 61, 132, 16, 220, 198, 24, 73, 40, 36, 238, 60, 54, 100, 90, 81, 150, 135, 250, 225, 74, 118, 209, 111, 177, 185, 38, 137, 149, 57, 77, 95, 214, 244, 14, 64, 109, 21, 96, 35, 160, 144, 181, 240, 216, 143, 103, 67, 86, 26, 229, 129, 39, 215, 65, 187, 194, 226, 152, 34, 82, 228, 51, 123, 85, 205, 56, 256, 179, 84, 127, 140, 126, 62, 210, 189, 93, 58, 155, 11, 87, 104, 145, 2, 156, 89, 3, 234, 5, 133, 94, 136, 71, 141, 204, 235, 83, 49, 224, 253, 202, 79, 251, 46, 247, 248, 69, 242, 115, 232, 106, 44, 91, 159, 66, 8, 110, 99, 12, 165, 20, 18, 119, 30, 27, 50, 45, 169, 75, 196, 125, 241, 37, 59, 233, 184, 217, 221, 19, 197, 203, 157, 167, 176, 107, 122, 7, 32, 183, 139, 48, 146, 80, 72, 219, 120, 108, 200, 180, 162, 43, 13, 243, 193, 148, 236, 161, 222, 97, 113, 76, 17, 41, 114, 154, 190, 171, 231, 28, 128, 218, 42, 192, 70, 63, 31, 105, 223, 175, 29, 206, 134, 172, 52, 201, 1],
+[1, 79, 73, 113, 189, 25, 176, 26, 255, 99, 111, 31, 136, 207, 162, 205, 4, 59, 35, 195, 242, 100, 190, 104, 249, 139, 187, 124, 30, 57, 134, 49, 16, 236, 140, 9, 197, 143, 246, 159, 225, 42, 234, 239, 120, 228, 22, 196, 64, 173, 46, 36, 17, 58, 213, 122, 129, 168, 165, 185, 223, 141, 88, 13, 256, 178, 184, 144, 68, 232, 81, 231, 2, 158, 146, 226, 121, 50, 95, 52, 253, 198, 222, 62, 15, 157, 67, 153, 8, 118, 70, 133, 227, 200, 123, 208, 241, 21, 117, 248, 60, 114, 11, 98, 32, 215, 23, 18, 137, 29, 235, 61, 193, 84, 211, 221, 240, 199, 44, 135, 128, 89, 92, 72, 34, 116, 169, 244, 1, 79, 73, 113, 189, 25, 176, 26, 255, 99, 111, 31, 136, 207, 162, 205, 4, 59, 35, 195, 242, 100, 190, 104, 249, 139, 187, 124, 30, 57, 134, 49, 16, 236, 140, 9, 197, 143, 246, 159, 225, 42, 234, 239, 120, 228, 22, 196, 64, 173, 46, 36, 17, 58, 213, 122, 129, 168, 165, 185, 223, 141, 88, 13, 256, 178, 184, 144, 68, 232, 81, 231, 2, 158, 146, 226, 121, 50, 95, 52, 253, 198, 222, 62, 15, 157, 67, 153, 8, 118, 70, 133, 227, 200, 123, 208, 241, 21, 117, 248, 60, 114, 11, 98, 32, 215, 23, 18, 137, 29, 235, 61, 193, 84, 211, 221, 240, 199, 44, 135, 128, 89, 92, 72, 34, 116, 169, 244, 1],
+[1, 80, 232, 56, 111, 142, 52, 48, 242, 85, 118, 188, 134, 183, 248, 51, 225, 10, 29, 7, 46, 82, 135, 6, 223, 107, 79, 152, 81, 55, 31, 167, 253, 194, 100, 33, 70, 203, 49, 65, 60, 174, 42, 19, 235, 39, 36, 53, 128, 217, 141, 229, 73, 186, 231, 233, 136, 86, 198, 163, 190, 37, 133, 103, 16, 252, 114, 125, 234, 216, 61, 254, 17, 75, 89, 181, 88, 101, 113, 45, 2, 160, 207, 112, 222, 27, 104, 96, 227, 170, 236, 119, 11, 109, 239, 102, 193, 20, 58, 14, 92, 164, 13, 12, 189, 214, 158, 47, 162, 110, 62, 77, 249, 131, 200, 66, 140, 149, 98, 130, 120, 91, 84, 38, 213, 78, 72, 106, 256, 177, 25, 201, 146, 115, 205, 209, 15, 172, 139, 69, 123, 74, 9, 206, 32, 247, 228, 250, 211, 175, 122, 251, 34, 150, 178, 105, 176, 202, 226, 90, 4, 63, 157, 224, 187, 54, 208, 192, 197, 83, 215, 238, 22, 218, 221, 204, 129, 40, 116, 28, 184, 71, 26, 24, 121, 171, 59, 94, 67, 220, 124, 154, 241, 5, 143, 132, 23, 41, 196, 3, 240, 182, 168, 76, 169, 156, 144, 212, 255, 97, 50, 145, 35, 230, 153, 161, 30, 87, 21, 138, 246, 148, 18, 155, 64, 237, 199, 243, 165, 93, 244, 245, 68, 43, 99, 210, 95, 147, 195, 180, 8, 126, 57, 191, 117, 108, 159, 127, 137, 166, 173, 219, 44, 179, 185, 151, 1],
+[1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1],
+[1, 82, 42, 103, 222, 214, 72, 250, 197, 220, 50, 245, 44, 10, 49, 163, 2, 164, 84, 206, 187, 171, 144, 243, 137, 183, 100, 233, 88, 20, 98, 69, 4, 71, 168, 155, 117, 85, 31, 229, 17, 109, 200, 209, 176, 40, 196, 138, 8, 142, 79, 53, 234, 170, 62, 201, 34, 218, 143, 161, 95, 80, 135, 19, 16, 27, 158, 106, 211, 83, 124, 145, 68, 179, 29, 65, 190, 160, 13, 38, 32, 54, 59, 212, 165, 166, 248, 33, 136, 101, 58, 130, 123, 63, 26, 76, 64, 108, 118, 167, 73, 75, 239, 66, 15, 202, 116, 3, 246, 126, 52, 152, 128, 216, 236, 77, 146, 150, 221, 132, 30, 147, 232, 6, 235, 252, 104, 47, 256, 175, 215, 154, 35, 43, 185, 7, 60, 37, 207, 12, 213, 247, 208, 94, 255, 93, 173, 51, 70, 86, 113, 14, 120, 74, 157, 24, 169, 237, 159, 188, 253, 186, 89, 102, 140, 172, 226, 28, 240, 148, 57, 48, 81, 217, 61, 119, 249, 115, 178, 204, 23, 87, 195, 56, 223, 39, 114, 96, 162, 177, 122, 238, 241, 230, 99, 151, 46, 174, 133, 112, 189, 78, 228, 192, 67, 97, 244, 219, 225, 203, 198, 45, 92, 91, 9, 224, 121, 156, 199, 127, 134, 194, 231, 181, 193, 149, 139, 90, 184, 182, 18, 191, 242, 55, 141, 254, 11, 131, 205, 105, 129, 41, 21, 180, 111, 107, 36, 125, 227, 110, 25, 251, 22, 5, 153, 210, 1],
+[1, 83, 207, 219, 187, 101, 159, 90, 17, 126, 178, 125, 95, 175, 133, 245, 32, 86, 199, 69, 73, 148, 205, 53, 30, 177, 42, 145, 213, 203, 144, 130, 253, 182, 200, 152, 23, 110, 135, 154, 189, 10, 59, 14, 134, 71, 239, 48, 129, 170, 232, 238, 222, 179, 208, 45, 137, 63, 89, 191, 176, 216, 195, 251, 16, 43, 228, 163, 165, 74, 231, 155, 15, 217, 21, 201, 235, 230, 72, 65, 255, 91, 100, 76, 140, 55, 196, 77, 223, 5, 158, 7, 67, 164, 248, 24, 193, 85, 116, 119, 111, 218, 104, 151, 197, 160, 173, 224, 88, 108, 226, 254, 8, 150, 114, 210, 211, 37, 244, 206, 136, 237, 139, 229, 246, 115, 36, 161, 256, 174, 50, 38, 70, 156, 98, 167, 240, 131, 79, 132, 162, 82, 124, 12, 225, 171, 58, 188, 184, 109, 52, 204, 227, 80, 215, 112, 44, 54, 113, 127, 4, 75, 57, 105, 234, 147, 122, 103, 68, 247, 198, 243, 123, 186, 18, 209, 128, 87, 25, 19, 35, 78, 49, 212, 120, 194, 168, 66, 81, 41, 62, 6, 241, 214, 29, 94, 92, 183, 26, 102, 242, 40, 236, 56, 22, 27, 185, 192, 2, 166, 157, 181, 117, 202, 61, 180, 34, 252, 99, 250, 190, 93, 9, 233, 64, 172, 141, 138, 146, 39, 153, 106, 60, 97, 84, 33, 169, 149, 31, 3, 249, 107, 143, 47, 46, 220, 13, 51, 121, 20, 118, 28, 11, 142, 221, 96, 1],
+[1, 84, 117, 62, 68, 58, 246, 104, 255, 89, 23, 133, 121, 141, 22, 49, 4, 79, 211, 248, 15, 232, 213, 159, 249, 99, 92, 18, 227, 50, 88, 196, 16, 59, 73, 221, 60, 157, 81, 122, 225, 139, 111, 72, 137, 200, 95, 13, 64, 236, 35, 113, 240, 114, 67, 231, 129, 42, 187, 31, 34, 29, 123, 52, 256, 173, 140, 195, 189, 199, 11, 153, 2, 168, 234, 124, 136, 116, 235, 208, 253, 178, 46, 9, 242, 25, 44, 98, 8, 158, 165, 239, 30, 207, 169, 61, 241, 198, 184, 36, 197, 100, 176, 135, 32, 118, 146, 185, 120, 57, 162, 244, 193, 21, 222, 144, 17, 143, 190, 26, 128, 215, 70, 226, 223, 228, 134, 205, 1, 84, 117, 62, 68, 58, 246, 104, 255, 89, 23, 133, 121, 141, 22, 49, 4, 79, 211, 248, 15, 232, 213, 159, 249, 99, 92, 18, 227, 50, 88, 196, 16, 59, 73, 221, 60, 157, 81, 122, 225, 139, 111, 72, 137, 200, 95, 13, 64, 236, 35, 113, 240, 114, 67, 231, 129, 42, 187, 31, 34, 29, 123, 52, 256, 173, 140, 195, 189, 199, 11, 153, 2, 168, 234, 124, 136, 116, 235, 208, 253, 178, 46, 9, 242, 25, 44, 98, 8, 158, 165, 239, 30, 207, 169, 61, 241, 198, 184, 36, 197, 100, 176, 135, 32, 118, 146, 185, 120, 57, 162, 244, 193, 21, 222, 144, 17, 143, 190, 26, 128, 215, 70, 226, 223, 228, 134, 205, 1],
+[1, 85, 29, 152, 70, 39, 231, 103, 17, 160, 236, 14, 162, 149, 72, 209, 32, 150, 157, 238, 184, 220, 196, 212, 30, 237, 99, 191, 44, 142, 248, 6, 253, 174, 141, 163, 234, 101, 104, 102, 189, 131, 84, 201, 123, 175, 226, 192, 129, 171, 143, 76, 35, 148, 244, 180, 137, 80, 118, 7, 81, 203, 36, 233, 16, 75, 207, 119, 92, 110, 98, 106, 15, 247, 178, 224, 22, 71, 124, 3, 255, 87, 199, 210, 117, 179, 52, 51, 223, 194, 42, 229, 190, 216, 113, 96, 193, 214, 200, 38, 146, 74, 122, 90, 197, 40, 59, 132, 169, 230, 18, 245, 8, 166, 232, 188, 46, 55, 49, 53, 136, 252, 89, 112, 11, 164, 62, 130, 256, 172, 228, 105, 187, 218, 26, 154, 240, 97, 21, 243, 95, 108, 185, 48, 225, 107, 100, 19, 73, 37, 61, 45, 227, 20, 158, 66, 213, 115, 9, 251, 4, 83, 116, 94, 23, 156, 153, 155, 68, 126, 173, 56, 134, 82, 31, 65, 128, 86, 114, 181, 222, 109, 13, 77, 120, 177, 139, 250, 176, 54, 221, 24, 241, 182, 50, 138, 165, 147, 159, 151, 242, 10, 79, 33, 235, 186, 133, 254, 2, 170, 58, 47, 140, 78, 205, 206, 34, 63, 215, 28, 67, 41, 144, 161, 64, 43, 57, 219, 111, 183, 135, 167, 60, 217, 198, 125, 88, 27, 239, 12, 249, 91, 25, 69, 211, 202, 208, 204, 121, 5, 168, 145, 246, 93, 195, 127, 1],
+[1, 86, 200, 238, 165, 55, 104, 206, 240, 80, 198, 66, 22, 93, 31, 96, 32, 182, 232, 163, 140, 218, 244, 167, 227, 247, 168, 56, 190, 149, 221, 245, 253, 170, 228, 76, 111, 37, 98, 204, 68, 194, 236, 250, 169, 142, 133, 130, 129, 43, 100, 119, 211, 156, 52, 103, 120, 40, 99, 33, 11, 175, 144, 48, 16, 91, 116, 210, 70, 109, 122, 212, 242, 252, 84, 28, 95, 203, 239, 251, 255, 85, 114, 38, 184, 147, 49, 102, 34, 97, 118, 125, 213, 71, 195, 65, 193, 150, 50, 188, 234, 78, 26, 180, 60, 20, 178, 145, 134, 216, 72, 24, 8, 174, 58, 105, 35, 183, 61, 106, 121, 126, 42, 14, 176, 230, 248, 254, 256, 171, 57, 19, 92, 202, 153, 51, 17, 177, 59, 191, 235, 164, 226, 161, 225, 75, 25, 94, 117, 39, 13, 90, 30, 10, 89, 201, 67, 108, 36, 12, 4, 87, 29, 181, 146, 220, 159, 53, 189, 63, 21, 7, 88, 115, 124, 127, 128, 214, 157, 138, 46, 101, 205, 154, 137, 217, 158, 224, 246, 82, 113, 209, 241, 166, 141, 47, 187, 148, 135, 45, 15, 5, 173, 229, 162, 54, 18, 6, 2, 172, 143, 219, 73, 110, 208, 155, 223, 160, 139, 132, 44, 186, 62, 192, 64, 107, 207, 69, 23, 179, 231, 77, 197, 237, 79, 112, 123, 41, 185, 233, 249, 83, 199, 152, 222, 74, 196, 151, 136, 131, 215, 243, 81, 27, 9, 3, 1],
+[1, 87, 116, 69, 92, 37, 135, 180, 240, 63, 84, 112, 235, 142, 18, 24, 32, 214, 114, 152, 117, 156, 208, 106, 227, 217, 118, 243, 67, 175, 62, 254, 253, 166, 50, 238, 146, 109, 231, 51, 68, 5, 178, 66, 88, 203, 185, 161, 129, 172, 58, 163, 46, 147, 196, 90, 120, 160, 42, 56, 246, 71, 9, 12, 16, 107, 57, 76, 187, 78, 104, 53, 242, 237, 59, 250, 162, 216, 31, 127, 255, 83, 25, 119, 73, 183, 244, 154, 34, 131, 89, 33, 44, 230, 221, 209, 193, 86, 29, 210, 23, 202, 98, 45, 60, 80, 21, 28, 123, 164, 133, 6, 8, 182, 157, 38, 222, 39, 52, 155, 121, 247, 158, 125, 81, 108, 144, 192, 256, 170, 141, 188, 165, 220, 122, 77, 17, 194, 173, 145, 22, 115, 239, 233, 225, 43, 143, 105, 140, 101, 49, 151, 30, 40, 139, 14, 190, 82, 195, 3, 4, 91, 207, 19, 111, 148, 26, 206, 189, 252, 79, 191, 169, 54, 72, 96, 128, 85, 199, 94, 211, 110, 61, 167, 137, 97, 215, 201, 11, 186, 248, 245, 241, 150, 200, 181, 70, 179, 153, 204, 15, 20, 198, 7, 95, 41, 226, 130, 2, 174, 232, 138, 184, 74, 13, 103, 223, 126, 168, 224, 213, 27, 36, 48, 64, 171, 228, 47, 234, 55, 159, 212, 197, 177, 236, 229, 134, 93, 124, 251, 249, 75, 100, 219, 35, 218, 205, 102, 136, 10, 99, 132, 176, 149, 113, 65, 1],
+[1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1],
+[1, 89, 211, 18, 60, 200, 67, 52, 2, 178, 165, 36, 120, 143, 134, 104, 4, 99, 73, 72, 240, 29, 11, 208, 8, 198, 146, 144, 223, 58, 22, 159, 16, 139, 35, 31, 189, 116, 44, 61, 32, 21, 70, 62, 121, 232, 88, 122, 64, 42, 140, 124, 242, 207, 176, 244, 128, 84, 23, 248, 227, 157, 95, 231, 256, 168, 46, 239, 197, 57, 190, 205, 255, 79, 92, 221, 137, 114, 123, 153, 253, 158, 184, 185, 17, 228, 246, 49, 249, 59, 111, 113, 34, 199, 235, 98, 241, 118, 222, 226, 68, 141, 213, 196, 225, 236, 187, 195, 136, 25, 169, 135, 193, 215, 117, 133, 15, 50, 81, 13, 129, 173, 234, 9, 30, 100, 162, 26, 1, 89, 211, 18, 60, 200, 67, 52, 2, 178, 165, 36, 120, 143, 134, 104, 4, 99, 73, 72, 240, 29, 11, 208, 8, 198, 146, 144, 223, 58, 22, 159, 16, 139, 35, 31, 189, 116, 44, 61, 32, 21, 70, 62, 121, 232, 88, 122, 64, 42, 140, 124, 242, 207, 176, 244, 128, 84, 23, 248, 227, 157, 95, 231, 256, 168, 46, 239, 197, 57, 190, 205, 255, 79, 92, 221, 137, 114, 123, 153, 253, 158, 184, 185, 17, 228, 246, 49, 249, 59, 111, 113, 34, 199, 235, 98, 241, 118, 222, 226, 68, 141, 213, 196, 225, 236, 187, 195, 136, 25, 169, 135, 193, 215, 117, 133, 15, 50, 81, 13, 129, 173, 234, 9, 30, 100, 162, 26, 1],
+[1, 90, 133, 148, 213, 152, 59, 170, 137, 251, 231, 230, 140, 7, 116, 160, 8, 206, 36, 156, 162, 188, 215, 75, 68, 209, 49, 41, 92, 56, 157, 252, 64, 106, 31, 220, 11, 219, 178, 86, 30, 130, 135, 71, 222, 191, 228, 217, 255, 77, 248, 218, 88, 210, 139, 174, 240, 12, 52, 54, 234, 243, 25, 194, 241, 102, 185, 202, 190, 138, 84, 107, 121, 96, 159, 175, 73, 145, 200, 10, 129, 45, 195, 74, 235, 76, 158, 85, 197, 254, 244, 115, 70, 132, 58, 80, 4, 103, 18, 78, 81, 94, 236, 166, 34, 233, 153, 149, 46, 28, 207, 126, 32, 53, 144, 110, 134, 238, 89, 43, 15, 65, 196, 164, 111, 224, 114, 237, 256, 167, 124, 109, 44, 105, 198, 87, 120, 6, 26, 27, 117, 250, 141, 97, 249, 51, 221, 101, 95, 69, 42, 182, 189, 48, 208, 216, 165, 201, 100, 5, 193, 151, 226, 37, 246, 38, 79, 171, 227, 127, 122, 186, 35, 66, 29, 40, 2, 180, 9, 39, 169, 47, 118, 83, 17, 245, 205, 203, 23, 14, 232, 63, 16, 155, 72, 55, 67, 119, 173, 150, 136, 161, 98, 82, 184, 112, 57, 247, 128, 212, 62, 183, 22, 181, 99, 172, 60, 3, 13, 142, 187, 125, 199, 177, 253, 154, 239, 179, 176, 163, 21, 91, 223, 24, 104, 108, 211, 229, 50, 131, 225, 204, 113, 147, 123, 19, 168, 214, 242, 192, 61, 93, 146, 33, 143, 20, 1],
+[1, 91, 57, 47, 165, 109, 153, 45, 240, 252, 59, 229, 22, 203, 226, 6, 32, 85, 25, 219, 140, 147, 13, 155, 227, 97, 89, 132, 190, 71, 36, 192, 253, 150, 29, 69, 111, 78, 159, 77, 68, 20, 21, 112, 169, 216, 124, 233, 129, 174, 157, 152, 211, 183, 205, 151, 120, 126, 158, 243, 11, 230, 113, 3, 16, 171, 141, 238, 70, 202, 135, 206, 242, 177, 173, 66, 95, 164, 18, 96, 255, 75, 143, 163, 184, 39, 208, 167, 34, 10, 139, 56, 213, 108, 62, 245, 193, 87, 207, 76, 234, 220, 231, 204, 60, 63, 79, 250, 134, 115, 185, 130, 8, 214, 199, 119, 35, 101, 196, 103, 121, 217, 215, 33, 176, 82, 9, 48, 256, 166, 200, 210, 92, 148, 104, 212, 17, 5, 198, 28, 235, 54, 31, 251, 225, 172, 232, 38, 117, 110, 244, 102, 30, 160, 168, 125, 67, 186, 221, 65, 4, 107, 228, 188, 146, 179, 98, 180, 189, 237, 236, 145, 88, 41, 133, 24, 128, 83, 100, 105, 46, 74, 52, 106, 137, 131, 99, 14, 246, 27, 144, 254, 241, 86, 116, 19, 187, 55, 122, 51, 15, 80, 84, 191, 162, 93, 239, 161, 2, 182, 114, 94, 73, 218, 49, 90, 223, 247, 118, 201, 44, 149, 195, 12, 64, 170, 50, 181, 23, 37, 26, 53, 197, 194, 178, 7, 123, 142, 72, 127, 249, 43, 58, 138, 222, 156, 61, 154, 136, 40, 42, 224, 81, 175, 248, 209, 1],
+[1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1],
+[1, 93, 168, 204, 211, 91, 239, 125, 60, 183, 57, 161, 67, 63, 205, 47, 2, 186, 79, 151, 165, 182, 221, 250, 120, 109, 114, 65, 134, 126, 153, 94, 4, 115, 158, 45, 73, 107, 185, 243, 240, 218, 228, 130, 11, 252, 49, 188, 8, 230, 59, 90, 146, 214, 113, 229, 223, 179, 199, 3, 22, 247, 98, 119, 16, 203, 118, 180, 35, 171, 226, 201, 189, 101, 141, 6, 44, 237, 196, 238, 32, 149, 236, 103, 70, 85, 195, 145, 121, 202, 25, 12, 88, 217, 135, 219, 64, 41, 215, 206, 140, 170, 133, 33, 242, 147, 50, 24, 176, 177, 13, 181, 128, 82, 173, 155, 23, 83, 9, 66, 227, 37, 100, 48, 95, 97, 26, 105, 256, 164, 89, 53, 46, 166, 18, 132, 197, 74, 200, 96, 190, 194, 52, 210, 255, 71, 178, 106, 92, 75, 36, 7, 137, 148, 143, 192, 123, 131, 104, 163, 253, 142, 99, 212, 184, 150, 72, 14, 17, 39, 29, 127, 246, 5, 208, 69, 249, 27, 198, 167, 111, 43, 144, 28, 34, 78, 58, 254, 235, 10, 159, 138, 241, 54, 139, 77, 222, 86, 31, 56, 68, 156, 116, 251, 213, 20, 61, 19, 225, 108, 21, 154, 187, 172, 62, 112, 136, 55, 232, 245, 169, 40, 122, 38, 193, 216, 42, 51, 117, 87, 124, 224, 15, 110, 207, 233, 81, 80, 244, 76, 129, 175, 84, 102, 234, 174, 248, 191, 30, 220, 157, 209, 162, 160, 231, 152, 1],
+[1, 94, 98, 217, 95, 192, 58, 55, 30, 250, 113, 85, 23, 106, 198, 108, 129, 47, 49, 237, 176, 96, 29, 156, 15, 125, 185, 171, 140, 53, 99, 54, 193, 152, 153, 247, 88, 48, 143, 78, 136, 191, 221, 214, 70, 155, 178, 27, 225, 76, 205, 252, 44, 24, 200, 39, 68, 224, 239, 107, 35, 206, 89, 142, 241, 38, 231, 126, 22, 12, 100, 148, 34, 112, 248, 182, 146, 103, 173, 71, 249, 19, 244, 63, 11, 6, 50, 74, 17, 56, 124, 91, 73, 180, 215, 164, 253, 138, 122, 160, 134, 3, 25, 37, 137, 28, 62, 174, 165, 90, 236, 82, 255, 69, 61, 80, 67, 130, 141, 147, 197, 14, 31, 87, 211, 45, 118, 41, 256, 163, 159, 40, 162, 65, 199, 202, 227, 7, 144, 172, 234, 151, 59, 149, 128, 210, 208, 20, 81, 161, 228, 101, 242, 132, 72, 86, 117, 204, 158, 203, 64, 105, 104, 10, 169, 209, 114, 179, 121, 66, 36, 43, 187, 102, 79, 230, 32, 181, 52, 5, 213, 233, 57, 218, 189, 33, 18, 150, 222, 51, 168, 115, 16, 219, 26, 131, 235, 245, 157, 109, 223, 145, 9, 75, 111, 154, 84, 186, 8, 238, 13, 194, 246, 251, 207, 183, 240, 201, 133, 166, 184, 77, 42, 93, 4, 119, 135, 97, 123, 254, 232, 220, 120, 229, 195, 83, 92, 167, 21, 175, 2, 188, 196, 177, 190, 127, 116, 110, 60, 243, 226, 170, 46, 212, 139, 216, 1],
+[1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1],
+[1, 96, 221, 142, 11, 28, 118, 20, 121, 51, 13, 220, 46, 47, 143, 107, 249, 3, 31, 149, 169, 33, 84, 97, 60, 106, 153, 39, 146, 138, 141, 172, 64, 233, 9, 93, 190, 250, 99, 252, 34, 180, 61, 202, 117, 181, 157, 166, 2, 192, 185, 27, 22, 56, 236, 40, 242, 102, 26, 183, 92, 94, 29, 214, 241, 6, 62, 41, 81, 66, 168, 194, 120, 212, 49, 78, 35, 19, 25, 87, 128, 209, 18, 186, 123, 243, 198, 247, 68, 103, 122, 147, 234, 105, 57, 75, 4, 127, 113, 54, 44, 112, 215, 80, 227, 204, 52, 109, 184, 188, 58, 171, 225, 12, 124, 82, 162, 132, 79, 131, 240, 167, 98, 156, 70, 38, 50, 174, 256, 161, 36, 115, 246, 229, 139, 237, 136, 206, 244, 37, 211, 210, 114, 150, 8, 254, 226, 108, 88, 224, 173, 160, 197, 151, 104, 218, 111, 119, 116, 85, 193, 24, 248, 164, 67, 7, 158, 5, 223, 77, 196, 55, 140, 76, 100, 91, 255, 65, 72, 230, 235, 201, 21, 217, 15, 155, 231, 74, 165, 163, 228, 43, 16, 251, 195, 216, 176, 191, 89, 63, 137, 45, 208, 179, 222, 238, 232, 170, 129, 48, 239, 71, 134, 14, 59, 10, 189, 154, 135, 110, 23, 152, 200, 182, 253, 130, 144, 203, 213, 145, 42, 177, 30, 53, 205, 148, 73, 69, 199, 86, 32, 245, 133, 175, 95, 125, 178, 126, 17, 90, 159, 101, 187, 219, 207, 83, 1],
+[1, 97, 157, 66, 234, 82, 244, 24, 15, 170, 42, 219, 169, 202, 62, 103, 225, 237, 116, 201, 222, 203, 159, 3, 34, 214, 198, 188, 246, 218, 72, 45, 253, 126, 143, 250, 92, 186, 52, 161, 197, 91, 89, 152, 95, 220, 9, 102, 128, 80, 50, 224, 140, 216, 135, 245, 121, 172, 236, 19, 44, 156, 226, 77, 16, 10, 199, 28, 146, 27, 49, 127, 240, 150, 158, 163, 134, 148, 221, 106, 2, 194, 57, 132, 211, 164, 231, 48, 30, 83, 84, 181, 81, 147, 124, 206, 193, 217, 232, 145, 187, 149, 61, 6, 68, 171, 139, 119, 235, 179, 144, 90, 249, 252, 29, 243, 184, 115, 104, 65, 137, 182, 178, 47, 190, 183, 18, 204, 256, 160, 100, 191, 23, 175, 13, 233, 242, 87, 215, 38, 88, 55, 195, 154, 32, 20, 141, 56, 35, 54, 98, 254, 223, 43, 59, 69, 11, 39, 185, 212, 4, 131, 114, 7, 165, 71, 205, 96, 60, 166, 168, 105, 162, 37, 248, 155, 129, 177, 207, 33, 117, 41, 122, 12, 136, 85, 21, 238, 213, 101, 31, 180, 241, 247, 58, 229, 111, 230, 208, 130, 17, 107, 99, 94, 123, 109, 36, 151, 255, 63, 200, 125, 46, 93, 26, 209, 227, 174, 173, 76, 176, 110, 133, 51, 64, 40, 25, 112, 70, 108, 196, 251, 189, 86, 118, 138, 22, 78, 113, 167, 8, 5, 228, 14, 73, 142, 153, 192, 120, 75, 79, 210, 67, 74, 239, 53, 1],
+[1, 98, 95, 58, 30, 113, 23, 198, 129, 49, 176, 29, 15, 185, 140, 99, 193, 153, 88, 143, 136, 221, 70, 178, 225, 205, 44, 200, 68, 239, 35, 89, 241, 231, 22, 100, 34, 248, 146, 173, 249, 244, 11, 50, 17, 124, 73, 215, 253, 122, 134, 25, 137, 62, 165, 236, 255, 61, 67, 141, 197, 31, 211, 118, 256, 159, 162, 199, 227, 144, 234, 59, 128, 208, 81, 228, 242, 72, 117, 158, 64, 104, 169, 114, 121, 36, 187, 79, 32, 52, 213, 57, 189, 18, 222, 168, 16, 26, 235, 157, 223, 9, 111, 84, 8, 13, 246, 207, 240, 133, 184, 42, 4, 135, 123, 232, 120, 195, 92, 21, 2, 196, 190, 116, 60, 226, 46, 139, 1, 98, 95, 58, 30, 113, 23, 198, 129, 49, 176, 29, 15, 185, 140, 99, 193, 153, 88, 143, 136, 221, 70, 178, 225, 205, 44, 200, 68, 239, 35, 89, 241, 231, 22, 100, 34, 248, 146, 173, 249, 244, 11, 50, 17, 124, 73, 215, 253, 122, 134, 25, 137, 62, 165, 236, 255, 61, 67, 141, 197, 31, 211, 118, 256, 159, 162, 199, 227, 144, 234, 59, 128, 208, 81, 228, 242, 72, 117, 158, 64, 104, 169, 114, 121, 36, 187, 79, 32, 52, 213, 57, 189, 18, 222, 168, 16, 26, 235, 157, 223, 9, 111, 84, 8, 13, 246, 207, 240, 133, 184, 42, 4, 135, 123, 232, 120, 195, 92, 21, 2, 196, 190, 116, 60, 226, 46, 139, 1],
+[1, 99, 35, 124, 197, 228, 213, 13, 2, 198, 70, 248, 137, 199, 169, 26, 4, 139, 140, 239, 17, 141, 81, 52, 8, 21, 23, 221, 34, 25, 162, 104, 16, 42, 46, 185, 68, 50, 67, 208, 32, 84, 92, 113, 136, 100, 134, 159, 64, 168, 184, 226, 15, 200, 11, 61, 128, 79, 111, 195, 30, 143, 22, 122, 256, 158, 222, 133, 60, 29, 44, 244, 255, 59, 187, 9, 120, 58, 88, 231, 253, 118, 117, 18, 240, 116, 176, 205, 249, 236, 234, 36, 223, 232, 95, 153, 241, 215, 211, 72, 189, 207, 190, 49, 225, 173, 165, 144, 121, 157, 123, 98, 193, 89, 73, 31, 242, 57, 246, 196, 129, 178, 146, 62, 227, 114, 235, 135, 1, 99, 35, 124, 197, 228, 213, 13, 2, 198, 70, 248, 137, 199, 169, 26, 4, 139, 140, 239, 17, 141, 81, 52, 8, 21, 23, 221, 34, 25, 162, 104, 16, 42, 46, 185, 68, 50, 67, 208, 32, 84, 92, 113, 136, 100, 134, 159, 64, 168, 184, 226, 15, 200, 11, 61, 128, 79, 111, 195, 30, 143, 22, 122, 256, 158, 222, 133, 60, 29, 44, 244, 255, 59, 187, 9, 120, 58, 88, 231, 253, 118, 117, 18, 240, 116, 176, 205, 249, 236, 234, 36, 223, 232, 95, 153, 241, 215, 211, 72, 189, 207, 190, 49, 225, 173, 165, 144, 121, 157, 123, 98, 193, 89, 73, 31, 242, 57, 246, 196, 129, 178, 146, 62, 227, 114, 235, 135, 1],
+[1, 100, 234, 13, 15, 215, 169, 195, 225, 141, 222, 98, 34, 59, 246, 185, 253, 114, 92, 205, 197, 168, 95, 248, 128, 207, 140, 122, 121, 21, 44, 31, 16, 58, 146, 208, 240, 99, 134, 36, 2, 200, 211, 26, 30, 173, 81, 133, 193, 25, 187, 196, 68, 118, 235, 113, 249, 228, 184, 153, 137, 79, 190, 239, 256, 157, 23, 244, 242, 42, 88, 62, 32, 116, 35, 159, 223, 198, 11, 72, 4, 143, 165, 52, 60, 89, 162, 9, 129, 50, 117, 135, 136, 236, 213, 226, 241, 199, 111, 49, 17, 158, 123, 221, 255, 57, 46, 231, 227, 84, 176, 124, 64, 232, 70, 61, 189, 139, 22, 144, 8, 29, 73, 104, 120, 178, 67, 18, 1, 100, 234, 13, 15, 215, 169, 195, 225, 141, 222, 98, 34, 59, 246, 185, 253, 114, 92, 205, 197, 168, 95, 248, 128, 207, 140, 122, 121, 21, 44, 31, 16, 58, 146, 208, 240, 99, 134, 36, 2, 200, 211, 26, 30, 173, 81, 133, 193, 25, 187, 196, 68, 118, 235, 113, 249, 228, 184, 153, 137, 79, 190, 239, 256, 157, 23, 244, 242, 42, 88, 62, 32, 116, 35, 159, 223, 198, 11, 72, 4, 143, 165, 52, 60, 89, 162, 9, 129, 50, 117, 135, 136, 236, 213, 226, 241, 199, 111, 49, 17, 158, 123, 221, 255, 57, 46, 231, 227, 84, 176, 124, 64, 232, 70, 61, 189, 139, 22, 144, 8, 29, 73, 104, 120, 178, 67, 18, 1],
+[1, 101, 178, 245, 73, 177, 144, 152, 189, 71, 232, 45, 176, 43, 231, 201, 255, 55, 158, 24, 111, 160, 226, 210, 136, 115, 50, 167, 162, 171, 52, 112, 4, 147, 198, 209, 35, 194, 62, 94, 242, 27, 157, 180, 190, 172, 153, 33, 249, 220, 118, 96, 187, 126, 133, 69, 30, 203, 200, 154, 134, 170, 208, 191, 16, 74, 21, 65, 140, 5, 248, 119, 197, 108, 114, 206, 246, 174, 98, 132, 225, 109, 215, 127, 234, 247, 18, 19, 120, 41, 29, 102, 22, 166, 61, 250, 64, 39, 84, 3, 46, 20, 221, 219, 17, 175, 199, 53, 213, 182, 135, 14, 129, 179, 89, 251, 165, 217, 72, 76, 223, 164, 116, 151, 88, 150, 244, 229, 256, 156, 79, 12, 184, 80, 113, 105, 68, 186, 25, 212, 81, 214, 26, 56, 2, 202, 99, 233, 146, 97, 31, 47, 121, 142, 207, 90, 95, 86, 205, 145, 253, 110, 59, 48, 222, 63, 195, 163, 15, 230, 100, 77, 67, 85, 104, 224, 8, 37, 139, 161, 70, 131, 124, 188, 227, 54, 57, 103, 123, 87, 49, 66, 241, 183, 236, 192, 117, 252, 9, 138, 60, 149, 143, 51, 11, 83, 159, 125, 32, 148, 42, 130, 23, 10, 239, 238, 137, 216, 228, 155, 235, 91, 196, 7, 193, 218, 173, 254, 211, 237, 36, 38, 240, 82, 58, 204, 44, 75, 122, 243, 128, 78, 168, 6, 92, 40, 185, 181, 34, 93, 141, 106, 169, 107, 13, 28, 1],
+[1, 102, 124, 55, 213, 138, 198, 150, 137, 96, 26, 82, 140, 145, 141, 247, 8, 45, 221, 183, 162, 76, 42, 172, 68, 254, 208, 142, 92, 132, 100, 177, 64, 103, 226, 179, 11, 94, 79, 91, 30, 233, 122, 108, 222, 28, 29, 131, 255, 53, 9, 147, 88, 238, 118, 214, 240, 65, 205, 93, 234, 224, 232, 20, 241, 167, 72, 148, 190, 105, 173, 170, 121, 6, 98, 230, 73, 250, 57, 160, 129, 51, 62, 156, 235, 69, 99, 75, 197, 48, 13, 41, 70, 201, 199, 252, 4, 151, 239, 220, 81, 38, 21, 86, 34, 127, 104, 71, 46, 66, 50, 217, 32, 180, 113, 218, 134, 47, 168, 174, 15, 245, 61, 54, 111, 14, 143, 194, 256, 155, 133, 202, 44, 119, 59, 107, 120, 161, 231, 175, 117, 112, 116, 10, 249, 212, 36, 74, 95, 181, 215, 85, 189, 3, 49, 115, 165, 125, 157, 80, 193, 154, 31, 78, 246, 163, 178, 166, 227, 24, 135, 149, 35, 229, 228, 126, 2, 204, 248, 110, 169, 19, 139, 43, 17, 192, 52, 164, 23, 33, 25, 237, 16, 90, 185, 109, 67, 152, 84, 87, 136, 251, 159, 27, 184, 7, 200, 97, 128, 206, 195, 101, 22, 188, 158, 182, 60, 209, 244, 216, 187, 56, 58, 5, 253, 106, 18, 37, 176, 219, 236, 171, 223, 130, 153, 186, 211, 191, 207, 40, 225, 77, 144, 39, 123, 210, 89, 83, 242, 12, 196, 203, 146, 243, 114, 63, 1],
+[1, 103, 72, 220, 44, 163, 84, 171, 137, 233, 98, 71, 117, 229, 200, 40, 8, 53, 62, 218, 95, 19, 158, 83, 68, 65, 13, 54, 165, 33, 58, 63, 64, 167, 239, 202, 246, 152, 236, 150, 30, 6, 104, 175, 35, 7, 207, 247, 255, 51, 113, 74, 169, 188, 89, 172, 240, 48, 61, 115, 23, 56, 114, 177, 241, 151, 133, 78, 67, 219, 198, 91, 121, 127, 231, 149, 184, 191, 141, 131, 129, 180, 36, 110, 22, 210, 42, 214, 197, 245, 49, 164, 187, 243, 100, 20, 4, 155, 31, 109, 176, 138, 79, 170, 34, 161, 135, 27, 211, 145, 29, 160, 32, 212, 248, 101, 123, 76, 118, 75, 15, 3, 52, 216, 146, 132, 232, 252, 256, 154, 185, 37, 213, 94, 173, 86, 120, 24, 159, 186, 140, 28, 57, 217, 249, 204, 195, 39, 162, 238, 99, 174, 189, 192, 244, 203, 92, 224, 199, 194, 193, 90, 18, 55, 11, 105, 21, 107, 227, 251, 153, 82, 222, 250, 50, 10, 2, 206, 144, 183, 88, 69, 168, 85, 17, 209, 196, 142, 234, 201, 143, 80, 16, 106, 124, 179, 190, 38, 59, 166, 136, 130, 26, 108, 73, 66, 116, 126, 128, 77, 221, 147, 235, 47, 215, 43, 60, 12, 208, 93, 70, 14, 157, 237, 253, 102, 226, 148, 81, 119, 178, 87, 223, 96, 122, 230, 46, 112, 228, 97, 225, 45, 9, 156, 134, 181, 139, 182, 242, 254, 205, 41, 111, 125, 25, 5, 1],
+[1, 104, 22, 232, 227, 221, 111, 236, 129, 52, 11, 116, 242, 239, 184, 118, 193, 26, 134, 58, 121, 248, 92, 59, 225, 13, 67, 29, 189, 124, 46, 158, 241, 135, 162, 143, 223, 62, 23, 79, 249, 196, 81, 200, 240, 31, 140, 168, 253, 98, 169, 100, 120, 144, 70, 84, 255, 49, 213, 50, 60, 72, 35, 42, 256, 153, 235, 25, 30, 36, 146, 21, 128, 205, 246, 141, 15, 18, 73, 139, 64, 231, 123, 199, 136, 9, 165, 198, 32, 244, 190, 228, 68, 133, 211, 99, 16, 122, 95, 114, 34, 195, 234, 178, 8, 61, 176, 57, 17, 226, 117, 89, 4, 159, 88, 157, 137, 113, 187, 173, 2, 208, 44, 207, 197, 185, 222, 215, 1, 104, 22, 232, 227, 221, 111, 236, 129, 52, 11, 116, 242, 239, 184, 118, 193, 26, 134, 58, 121, 248, 92, 59, 225, 13, 67, 29, 189, 124, 46, 158, 241, 135, 162, 143, 223, 62, 23, 79, 249, 196, 81, 200, 240, 31, 140, 168, 253, 98, 169, 100, 120, 144, 70, 84, 255, 49, 213, 50, 60, 72, 35, 42, 256, 153, 235, 25, 30, 36, 146, 21, 128, 205, 246, 141, 15, 18, 73, 139, 64, 231, 123, 199, 136, 9, 165, 198, 32, 244, 190, 228, 68, 133, 211, 99, 16, 122, 95, 114, 34, 195, 234, 178, 8, 61, 176, 57, 17, 226, 117, 89, 4, 159, 88, 157, 137, 113, 187, 173, 2, 208, 44, 207, 197, 185, 222, 215, 1],
+[1, 105, 231, 97, 162, 48, 157, 37, 30, 66, 248, 83, 234, 155, 84, 82, 129, 181, 244, 177, 81, 24, 207, 147, 15, 33, 124, 170, 117, 206, 42, 41, 193, 219, 122, 217, 169, 12, 232, 202, 136, 145, 62, 85, 187, 103, 21, 149, 225, 238, 61, 237, 213, 6, 116, 101, 68, 201, 31, 171, 222, 180, 139, 203, 241, 119, 159, 247, 235, 3, 58, 179, 34, 229, 144, 214, 111, 90, 198, 230, 249, 188, 208, 252, 246, 130, 29, 218, 17, 243, 72, 107, 184, 45, 99, 115, 253, 94, 104, 126, 123, 65, 143, 109, 137, 250, 36, 182, 92, 151, 178, 186, 255, 47, 52, 63, 190, 161, 200, 183, 197, 125, 18, 91, 46, 204, 89, 93, 256, 152, 26, 160, 95, 209, 100, 220, 227, 191, 9, 174, 23, 102, 173, 175, 128, 76, 13, 80, 176, 233, 50, 110, 242, 224, 133, 87, 140, 51, 215, 216, 64, 38, 135, 40, 88, 245, 25, 55, 121, 112, 195, 172, 70, 154, 236, 108, 32, 19, 196, 20, 44, 251, 141, 156, 189, 56, 226, 86, 35, 77, 118, 54, 16, 138, 98, 10, 22, 254, 199, 78, 223, 28, 113, 43, 146, 167, 59, 27, 8, 69, 49, 5, 11, 127, 228, 39, 240, 14, 185, 150, 73, 212, 158, 142, 4, 163, 153, 131, 134, 192, 114, 148, 120, 7, 221, 75, 165, 106, 79, 71, 2, 210, 205, 194, 67, 96, 57, 74, 60, 132, 239, 166, 211, 53, 168, 164, 1],
+[1, 106, 185, 78, 44, 38, 173, 91, 137, 130, 159, 149, 117, 66, 57, 131, 8, 77, 195, 110, 95, 47, 99, 214, 68, 12, 244, 164, 165, 14, 199, 20, 64, 102, 18, 109, 246, 119, 21, 170, 30, 96, 153, 27, 35, 112, 50, 160, 255, 45, 144, 101, 169, 181, 168, 75, 240, 254, 196, 216, 23, 125, 143, 252, 241, 103, 124, 37, 67, 163, 59, 86, 121, 233, 26, 186, 184, 229, 116, 217, 129, 53, 221, 39, 22, 19, 215, 174, 197, 65, 208, 203, 187, 33, 157, 194, 4, 167, 226, 55, 176, 152, 178, 107, 34, 6, 122, 82, 211, 7, 228, 10, 32, 51, 9, 183, 123, 188, 139, 85, 15, 48, 205, 142, 146, 56, 25, 80, 256, 151, 72, 179, 213, 219, 84, 166, 120, 127, 98, 108, 140, 191, 200, 126, 249, 180, 62, 147, 162, 210, 158, 43, 189, 245, 13, 93, 92, 243, 58, 237, 193, 155, 239, 148, 11, 138, 236, 87, 227, 161, 104, 230, 222, 145, 207, 97, 2, 212, 113, 156, 88, 76, 89, 182, 17, 3, 61, 41, 234, 132, 114, 5, 16, 154, 133, 220, 190, 94, 198, 171, 136, 24, 231, 71, 73, 28, 141, 40, 128, 204, 36, 218, 235, 238, 42, 83, 60, 192, 49, 54, 70, 224, 100, 63, 253, 90, 31, 202, 81, 105, 79, 150, 223, 251, 135, 175, 46, 250, 29, 247, 225, 206, 248, 74, 134, 69, 118, 172, 242, 209, 52, 115, 111, 201, 232, 177, 1],
+[1, 107, 141, 181, 92, 78, 122, 204, 240, 237, 173, 7, 235, 216, 239, 130, 32, 83, 143, 138, 117, 183, 49, 103, 227, 131, 139, 224, 67, 230, 195, 48, 253, 86, 207, 47, 146, 202, 26, 212, 68, 80, 79, 229, 88, 164, 72, 251, 129, 182, 199, 219, 46, 39, 61, 102, 120, 247, 215, 132, 246, 108, 248, 65, 16, 170, 200, 69, 187, 220, 153, 180, 242, 194, 198, 112, 162, 115, 226, 24, 255, 43, 232, 152, 73, 101, 13, 106, 34, 40, 168, 243, 44, 82, 36, 254, 193, 91, 228, 238, 23, 148, 159, 51, 60, 252, 236, 66, 123, 54, 124, 161, 8, 85, 100, 163, 222, 110, 205, 90, 121, 97, 99, 56, 81, 186, 113, 12, 256, 150, 116, 76, 165, 179, 135, 53, 17, 20, 84, 250, 22, 41, 18, 127, 225, 174, 114, 119, 140, 74, 208, 154, 30, 126, 118, 33, 190, 27, 62, 209, 4, 171, 50, 210, 111, 55, 231, 45, 189, 177, 178, 28, 169, 93, 185, 6, 128, 75, 58, 38, 211, 218, 196, 155, 137, 10, 42, 125, 11, 149, 9, 192, 241, 87, 57, 188, 70, 37, 104, 77, 15, 63, 59, 145, 95, 142, 31, 233, 2, 214, 25, 105, 184, 156, 244, 151, 223, 217, 89, 14, 213, 175, 221, 3, 64, 166, 29, 19, 234, 109, 98, 206, 197, 5, 21, 191, 134, 203, 133, 96, 249, 172, 157, 94, 35, 147, 52, 167, 136, 160, 158, 201, 176, 71, 144, 245, 1],
+[1, 108, 99, 155, 35, 182, 124, 28, 197, 202, 228, 209, 213, 131, 13, 119, 2, 216, 198, 53, 70, 107, 248, 56, 137, 147, 199, 161, 169, 5, 26, 238, 4, 175, 139, 106, 140, 214, 239, 112, 17, 37, 141, 65, 81, 10, 52, 219, 8, 93, 21, 212, 23, 171, 221, 224, 34, 74, 25, 130, 162, 20, 104, 181, 16, 186, 42, 167, 46, 85, 185, 191, 68, 148, 50, 3, 67, 40, 208, 105, 32, 115, 84, 77, 92, 170, 113, 125, 136, 39, 100, 6, 134, 80, 159, 210, 64, 230, 168, 154, 184, 83, 226, 250, 15, 78, 200, 12, 11, 160, 61, 163, 128, 203, 79, 51, 111, 166, 195, 243, 30, 156, 143, 24, 22, 63, 122, 69, 256, 149, 158, 102, 222, 75, 133, 229, 60, 55, 29, 48, 44, 126, 244, 138, 255, 41, 59, 204, 187, 150, 9, 201, 120, 110, 58, 96, 88, 252, 231, 19, 253, 82, 118, 151, 117, 43, 18, 145, 240, 220, 116, 192, 176, 247, 205, 38, 249, 164, 236, 45, 234, 86, 36, 33, 223, 183, 232, 127, 95, 237, 153, 76, 241, 71, 215, 90, 211, 172, 72, 66, 189, 109, 207, 254, 190, 217, 49, 152, 225, 142, 173, 180, 165, 87, 144, 132, 121, 218, 157, 251, 123, 177, 98, 47, 193, 27, 89, 103, 73, 174, 31, 7, 242, 179, 57, 245, 246, 97, 196, 94, 129, 54, 178, 206, 146, 91, 62, 14, 227, 101, 114, 233, 235, 194, 135, 188, 1],
+[1, 109, 59, 6, 140, 97, 36, 69, 68, 216, 157, 151, 11, 171, 135, 66, 255, 39, 139, 245, 234, 63, 185, 119, 121, 82, 200, 212, 235, 172, 244, 125, 4, 179, 236, 24, 46, 131, 144, 19, 15, 93, 114, 90, 44, 170, 26, 7, 249, 156, 42, 209, 165, 252, 226, 219, 227, 71, 29, 77, 169, 174, 205, 243, 16, 202, 173, 96, 184, 10, 62, 76, 60, 115, 199, 103, 176, 166, 104, 28, 225, 110, 168, 65, 146, 237, 133, 105, 137, 27, 116, 51, 162, 182, 49, 201, 64, 37, 178, 127, 222, 40, 248, 47, 240, 203, 25, 155, 190, 150, 159, 112, 129, 183, 158, 3, 70, 177, 18, 163, 34, 108, 207, 204, 134, 214, 196, 33, 256, 148, 198, 251, 117, 160, 221, 188, 189, 41, 100, 106, 246, 86, 122, 191, 2, 218, 118, 12, 23, 194, 72, 138, 136, 175, 57, 45, 22, 85, 13, 132, 253, 78, 21, 233, 211, 126, 113, 238, 242, 164, 143, 167, 213, 87, 231, 250, 8, 101, 215, 48, 92, 5, 31, 38, 30, 186, 228, 180, 88, 83, 52, 14, 241, 55, 84, 161, 73, 247, 195, 181, 197, 142, 58, 154, 81, 91, 153, 229, 32, 147, 89, 192, 111, 20, 124, 152, 120, 230, 141, 206, 95, 75, 208, 56, 193, 220, 79, 130, 35, 217, 9, 210, 17, 54, 232, 102, 67, 107, 98, 145, 128, 74, 99, 254, 187, 80, 239, 94, 223, 149, 50, 53, 123, 43, 61, 224, 1],
+[1, 110, 21, 254, 184, 194, 9, 219, 189, 230, 114, 204, 81, 172, 159, 14, 255, 37, 215, 6, 146, 126, 239, 76, 136, 54, 29, 106, 95, 170, 196, 229, 4, 183, 84, 245, 222, 5, 36, 105, 242, 149, 199, 45, 67, 174, 122, 56, 249, 148, 89, 24, 70, 247, 185, 47, 30, 216, 116, 167, 123, 166, 13, 145, 16, 218, 79, 209, 117, 20, 144, 163, 197, 82, 25, 180, 11, 182, 231, 224, 225, 78, 99, 96, 23, 217, 226, 188, 120, 93, 207, 154, 235, 150, 52, 66, 64, 101, 59, 65, 211, 80, 62, 138, 17, 71, 100, 206, 44, 214, 153, 125, 129, 55, 139, 127, 92, 97, 133, 238, 223, 115, 57, 102, 169, 86, 208, 7, 256, 147, 236, 3, 73, 63, 248, 38, 68, 27, 143, 53, 176, 85, 98, 243, 2, 220, 42, 251, 111, 131, 18, 181, 121, 203, 228, 151, 162, 87, 61, 28, 253, 74, 173, 12, 35, 252, 221, 152, 15, 108, 58, 212, 190, 83, 135, 201, 8, 109, 168, 233, 187, 10, 72, 210, 227, 41, 141, 90, 134, 91, 244, 112, 241, 39, 178, 48, 140, 237, 113, 94, 60, 175, 232, 77, 246, 75, 26, 33, 32, 179, 158, 161, 234, 40, 31, 69, 137, 164, 50, 103, 22, 107, 205, 191, 193, 156, 198, 192, 46, 177, 195, 119, 240, 186, 157, 51, 213, 43, 104, 132, 128, 202, 118, 130, 165, 160, 124, 19, 34, 142, 200, 155, 88, 171, 49, 250, 1],
+[1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1],
+[1, 112, 208, 166, 88, 90, 57, 216, 34, 210, 133, 247, 165, 233, 139, 148, 128, 201, 153, 174, 213, 212, 100, 149, 240, 152, 62, 5, 46, 12, 59, 183, 193, 28, 52, 170, 22, 151, 207, 54, 137, 181, 226, 126, 234, 251, 99, 37, 32, 243, 231, 172, 246, 53, 25, 230, 60, 38, 144, 194, 140, 3, 79, 110, 241, 7, 13, 171, 134, 102, 116, 142, 227, 238, 185, 160, 187, 127, 89, 202, 8, 125, 122, 43, 190, 206, 199, 186, 15, 138, 36, 177, 35, 65, 84, 156, 253, 66, 196, 107, 162, 154, 29, 164, 121, 188, 239, 40, 111, 96, 215, 179, 2, 224, 159, 75, 176, 180, 114, 175, 68, 163, 9, 237, 73, 209, 21, 39, 256, 145, 49, 91, 169, 167, 200, 41, 223, 47, 124, 10, 92, 24, 118, 109, 129, 56, 104, 83, 44, 45, 157, 108, 17, 105, 195, 252, 211, 245, 198, 74, 64, 229, 205, 87, 235, 106, 50, 203, 120, 76, 31, 131, 23, 6, 158, 220, 225, 14, 26, 85, 11, 204, 232, 27, 197, 219, 113, 63, 117, 254, 178, 147, 16, 250, 244, 86, 123, 155, 141, 115, 30, 19, 72, 97, 70, 130, 168, 55, 249, 132, 135, 214, 67, 51, 58, 71, 242, 119, 221, 80, 222, 192, 173, 101, 4, 191, 61, 150, 95, 103, 228, 93, 136, 69, 18, 217, 146, 161, 42, 78, 255, 33, 98, 182, 81, 77, 143, 82, 189, 94, 248, 20, 184, 48, 236, 218, 1],
+[1, 113, 176, 99, 136, 205, 35, 100, 249, 124, 134, 236, 197, 159, 234, 228, 64, 36, 213, 168, 223, 13, 184, 232, 2, 226, 95, 198, 15, 153, 70, 200, 241, 248, 11, 215, 137, 61, 211, 199, 128, 72, 169, 79, 189, 26, 111, 207, 4, 195, 190, 139, 30, 49, 140, 143, 225, 239, 22, 173, 17, 122, 165, 141, 256, 144, 81, 158, 121, 52, 222, 157, 8, 133, 123, 21, 60, 98, 23, 29, 193, 221, 44, 89, 34, 244, 73, 25, 255, 31, 162, 59, 242, 104, 187, 57, 16, 9, 246, 42, 120, 196, 46, 58, 129, 185, 88, 178, 68, 231, 146, 50, 253, 62, 67, 118, 227, 208, 117, 114, 32, 18, 235, 84, 240, 135, 92, 116, 1, 113, 176, 99, 136, 205, 35, 100, 249, 124, 134, 236, 197, 159, 234, 228, 64, 36, 213, 168, 223, 13, 184, 232, 2, 226, 95, 198, 15, 153, 70, 200, 241, 248, 11, 215, 137, 61, 211, 199, 128, 72, 169, 79, 189, 26, 111, 207, 4, 195, 190, 139, 30, 49, 140, 143, 225, 239, 22, 173, 17, 122, 165, 141, 256, 144, 81, 158, 121, 52, 222, 157, 8, 133, 123, 21, 60, 98, 23, 29, 193, 221, 44, 89, 34, 244, 73, 25, 255, 31, 162, 59, 242, 104, 187, 57, 16, 9, 246, 42, 120, 196, 46, 58, 129, 185, 88, 178, 68, 231, 146, 50, 253, 62, 67, 118, 227, 208, 117, 114, 32, 18, 235, 84, 240, 135, 92, 116, 1],
+[1, 114, 146, 196, 242, 89, 123, 144, 225, 207, 211, 153, 223, 236, 176, 18, 253, 58, 187, 244, 60, 158, 22, 195, 128, 200, 184, 159, 136, 84, 67, 185, 16, 25, 23, 52, 17, 139, 169, 248, 2, 228, 35, 135, 227, 178, 246, 31, 193, 157, 165, 49, 189, 215, 95, 36, 249, 116, 117, 231, 120, 59, 44, 133, 256, 143, 111, 61, 15, 168, 134, 113, 32, 50, 46, 104, 34, 21, 81, 239, 4, 199, 70, 13, 197, 99, 235, 62, 129, 57, 73, 98, 121, 173, 190, 72, 241, 232, 234, 205, 240, 118, 88, 9, 255, 29, 222, 122, 30, 79, 11, 226, 64, 100, 92, 208, 68, 42, 162, 221, 8, 141, 140, 26, 137, 198, 213, 124, 1, 114, 146, 196, 242, 89, 123, 144, 225, 207, 211, 153, 223, 236, 176, 18, 253, 58, 187, 244, 60, 158, 22, 195, 128, 200, 184, 159, 136, 84, 67, 185, 16, 25, 23, 52, 17, 139, 169, 248, 2, 228, 35, 135, 227, 178, 246, 31, 193, 157, 165, 49, 189, 215, 95, 36, 249, 116, 117, 231, 120, 59, 44, 133, 256, 143, 111, 61, 15, 168, 134, 113, 32, 50, 46, 104, 34, 21, 81, 239, 4, 199, 70, 13, 197, 99, 235, 62, 129, 57, 73, 98, 121, 173, 190, 72, 241, 232, 234, 205, 240, 118, 88, 9, 255, 29, 222, 122, 30, 79, 11, 226, 64, 100, 92, 208, 68, 42, 162, 221, 8, 141, 140, 26, 137, 198, 213, 124, 1],
+[1, 115, 118, 206, 46, 150, 31, 224, 60, 218, 141, 24, 190, 5, 61, 76, 2, 230, 236, 155, 92, 43, 62, 191, 120, 179, 25, 48, 123, 10, 122, 152, 4, 203, 215, 53, 184, 86, 124, 125, 240, 101, 50, 96, 246, 20, 244, 47, 8, 149, 173, 106, 111, 172, 248, 250, 223, 202, 100, 192, 235, 40, 231, 94, 16, 41, 89, 212, 222, 87, 239, 243, 189, 147, 200, 127, 213, 80, 205, 188, 32, 82, 178, 167, 187, 174, 221, 229, 121, 37, 143, 254, 169, 160, 153, 119, 64, 164, 99, 77, 117, 91, 185, 201, 242, 74, 29, 251, 81, 63, 49, 238, 128, 71, 198, 154, 234, 182, 113, 145, 227, 148, 58, 245, 162, 126, 98, 219, 256, 142, 139, 51, 211, 107, 226, 33, 197, 39, 116, 233, 67, 252, 196, 181, 255, 27, 21, 102, 165, 214, 195, 66, 137, 78, 232, 209, 134, 247, 135, 105, 253, 54, 42, 204, 73, 171, 133, 132, 17, 156, 207, 161, 11, 237, 13, 210, 249, 108, 84, 151, 146, 85, 9, 7, 34, 55, 157, 65, 22, 217, 26, 163, 241, 216, 168, 45, 35, 170, 18, 14, 68, 110, 57, 130, 44, 177, 52, 69, 225, 175, 79, 90, 70, 83, 36, 28, 136, 220, 114, 3, 88, 97, 104, 138, 193, 93, 158, 180, 140, 166, 72, 56, 15, 183, 228, 6, 176, 194, 208, 19, 129, 186, 59, 103, 23, 75, 144, 112, 30, 109, 199, 12, 95, 131, 159, 38, 1],
+[1, 116, 92, 135, 240, 84, 235, 18, 32, 114, 117, 208, 227, 118, 67, 62, 253, 50, 146, 231, 68, 178, 88, 185, 129, 58, 46, 196, 120, 42, 246, 9, 16, 57, 187, 104, 242, 59, 162, 31, 255, 25, 73, 244, 34, 89, 44, 221, 193, 29, 23, 98, 60, 21, 123, 133, 8, 157, 222, 52, 121, 158, 81, 144, 256, 141, 165, 122, 17, 173, 22, 239, 225, 143, 140, 49, 30, 139, 190, 195, 4, 207, 111, 26, 189, 79, 169, 72, 128, 199, 211, 61, 137, 215, 11, 248, 241, 200, 70, 153, 15, 198, 95, 226, 2, 232, 184, 13, 223, 168, 213, 36, 64, 228, 234, 159, 197, 236, 134, 124, 249, 100, 35, 205, 136, 99, 176, 113, 1, 116, 92, 135, 240, 84, 235, 18, 32, 114, 117, 208, 227, 118, 67, 62, 253, 50, 146, 231, 68, 178, 88, 185, 129, 58, 46, 196, 120, 42, 246, 9, 16, 57, 187, 104, 242, 59, 162, 31, 255, 25, 73, 244, 34, 89, 44, 221, 193, 29, 23, 98, 60, 21, 123, 133, 8, 157, 222, 52, 121, 158, 81, 144, 256, 141, 165, 122, 17, 173, 22, 239, 225, 143, 140, 49, 30, 139, 190, 195, 4, 207, 111, 26, 189, 79, 169, 72, 128, 199, 211, 61, 137, 215, 11, 248, 241, 200, 70, 153, 15, 198, 95, 226, 2, 232, 184, 13, 223, 168, 213, 36, 64, 228, 234, 159, 197, 236, 134, 124, 249, 100, 35, 205, 136, 99, 176, 113, 1],
+[1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1],
+[1, 118, 46, 31, 60, 141, 190, 61, 2, 236, 92, 62, 120, 25, 123, 122, 4, 215, 184, 124, 240, 50, 246, 244, 8, 173, 111, 248, 223, 100, 235, 231, 16, 89, 222, 239, 189, 200, 213, 205, 32, 178, 187, 221, 121, 143, 169, 153, 64, 99, 117, 185, 242, 29, 81, 49, 128, 198, 234, 113, 227, 58, 162, 98, 256, 139, 211, 226, 197, 116, 67, 196, 255, 21, 165, 195, 137, 232, 134, 135, 253, 42, 73, 133, 17, 207, 11, 13, 249, 84, 146, 9, 34, 157, 22, 26, 241, 168, 35, 18, 68, 57, 44, 52, 225, 79, 70, 36, 136, 114, 88, 104, 193, 158, 140, 72, 15, 228, 176, 208, 129, 59, 23, 144, 30, 199, 95, 159, 1, 118, 46, 31, 60, 141, 190, 61, 2, 236, 92, 62, 120, 25, 123, 122, 4, 215, 184, 124, 240, 50, 246, 244, 8, 173, 111, 248, 223, 100, 235, 231, 16, 89, 222, 239, 189, 200, 213, 205, 32, 178, 187, 221, 121, 143, 169, 153, 64, 99, 117, 185, 242, 29, 81, 49, 128, 198, 234, 113, 227, 58, 162, 98, 256, 139, 211, 226, 197, 116, 67, 196, 255, 21, 165, 195, 137, 232, 134, 135, 253, 42, 73, 133, 17, 207, 11, 13, 249, 84, 146, 9, 34, 157, 22, 26, 241, 168, 35, 18, 68, 57, 44, 52, 225, 79, 70, 36, 136, 114, 88, 104, 193, 158, 140, 72, 15, 228, 176, 208, 129, 59, 23, 144, 30, 199, 95, 159, 1],
+[1, 119, 26, 10, 162, 3, 100, 78, 30, 229, 9, 43, 234, 90, 173, 27, 129, 188, 13, 5, 81, 130, 50, 39, 15, 243, 133, 150, 117, 45, 215, 142, 193, 94, 135, 131, 169, 65, 25, 148, 136, 250, 195, 75, 187, 151, 236, 71, 225, 47, 196, 194, 213, 161, 141, 74, 68, 125, 226, 166, 222, 204, 118, 164, 241, 152, 98, 97, 235, 209, 199, 37, 34, 191, 113, 83, 111, 102, 59, 82, 249, 76, 49, 177, 246, 233, 228, 147, 17, 224, 185, 170, 184, 51, 158, 41, 253, 38, 153, 217, 123, 245, 114, 202, 137, 112, 221, 85, 92, 154, 79, 149, 255, 19, 205, 237, 190, 251, 57, 101, 197, 56, 239, 171, 46, 77, 168, 203, 256, 138, 231, 247, 95, 254, 157, 179, 227, 28, 248, 214, 23, 167, 84, 230, 128, 69, 244, 252, 176, 127, 207, 218, 242, 14, 124, 107, 140, 212, 42, 115, 64, 163, 122, 126, 88, 192, 232, 109, 121, 7, 62, 182, 70, 106, 21, 186, 32, 210, 61, 63, 44, 96, 116, 183, 189, 132, 31, 91, 35, 53, 139, 93, 16, 105, 159, 160, 22, 48, 58, 220, 223, 66, 144, 174, 146, 155, 198, 175, 8, 181, 208, 80, 11, 24, 29, 110, 240, 33, 72, 87, 73, 206, 99, 216, 4, 219, 104, 40, 134, 12, 143, 55, 120, 145, 36, 172, 165, 103, 178, 108, 2, 238, 52, 20, 67, 6, 200, 156, 60, 201, 18, 86, 211, 180, 89, 54, 1],
+[1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1],
+[1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1],
+[1, 122, 235, 143, 227, 195, 146, 79, 129, 61, 246, 200, 242, 226, 73, 168, 193, 159, 123, 100, 121, 113, 165, 84, 225, 208, 190, 50, 189, 185, 211, 42, 241, 104, 95, 25, 223, 221, 234, 21, 249, 52, 176, 141, 240, 239, 117, 139, 253, 26, 88, 199, 120, 248, 187, 198, 255, 13, 44, 228, 60, 124, 222, 99, 256, 135, 22, 114, 30, 62, 111, 178, 128, 196, 11, 57, 15, 31, 184, 89, 64, 98, 134, 157, 136, 144, 92, 173, 32, 49, 67, 207, 68, 72, 46, 215, 16, 153, 162, 232, 34, 36, 23, 236, 8, 205, 81, 116, 17, 18, 140, 118, 4, 231, 169, 58, 137, 9, 70, 59, 2, 244, 213, 29, 197, 133, 35, 158, 1, 122, 235, 143, 227, 195, 146, 79, 129, 61, 246, 200, 242, 226, 73, 168, 193, 159, 123, 100, 121, 113, 165, 84, 225, 208, 190, 50, 189, 185, 211, 42, 241, 104, 95, 25, 223, 221, 234, 21, 249, 52, 176, 141, 240, 239, 117, 139, 253, 26, 88, 199, 120, 248, 187, 198, 255, 13, 44, 228, 60, 124, 222, 99, 256, 135, 22, 114, 30, 62, 111, 178, 128, 196, 11, 57, 15, 31, 184, 89, 64, 98, 134, 157, 136, 144, 92, 173, 32, 49, 67, 207, 68, 72, 46, 215, 16, 153, 162, 232, 34, 36, 23, 236, 8, 205, 81, 116, 17, 18, 140, 118, 4, 231, 169, 58, 137, 9, 70, 59, 2, 244, 213, 29, 197, 133, 35, 158, 1],
+[1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1],
+[1, 124, 213, 198, 137, 26, 140, 141, 8, 221, 162, 42, 68, 208, 92, 100, 64, 226, 11, 79, 30, 122, 222, 29, 255, 9, 88, 118, 240, 205, 234, 232, 241, 72, 190, 173, 121, 98, 73, 57, 129, 62, 235, 99, 197, 13, 70, 199, 4, 239, 81, 21, 34, 104, 46, 50, 32, 113, 134, 168, 15, 61, 111, 143, 256, 133, 44, 59, 120, 231, 117, 116, 249, 36, 95, 215, 189, 49, 165, 157, 193, 31, 246, 178, 227, 135, 35, 228, 2, 248, 169, 139, 17, 52, 23, 25, 16, 185, 67, 84, 136, 159, 184, 200, 128, 195, 22, 158, 60, 244, 187, 58, 253, 18, 176, 236, 223, 153, 211, 207, 225, 144, 123, 89, 242, 196, 146, 114, 1, 124, 213, 198, 137, 26, 140, 141, 8, 221, 162, 42, 68, 208, 92, 100, 64, 226, 11, 79, 30, 122, 222, 29, 255, 9, 88, 118, 240, 205, 234, 232, 241, 72, 190, 173, 121, 98, 73, 57, 129, 62, 235, 99, 197, 13, 70, 199, 4, 239, 81, 21, 34, 104, 46, 50, 32, 113, 134, 168, 15, 61, 111, 143, 256, 133, 44, 59, 120, 231, 117, 116, 249, 36, 95, 215, 189, 49, 165, 157, 193, 31, 246, 178, 227, 135, 35, 228, 2, 248, 169, 139, 17, 52, 23, 25, 16, 185, 67, 84, 136, 159, 184, 200, 128, 195, 22, 158, 60, 244, 187, 58, 253, 18, 176, 236, 223, 153, 211, 207, 225, 144, 123, 89, 242, 196, 146, 114, 1],
+[1, 125, 205, 182, 134, 45, 228, 230, 223, 119, 226, 237, 70, 12, 215, 147, 128, 66, 26, 166, 190, 106, 143, 142, 17, 69, 144, 10, 222, 251, 21, 55, 193, 224, 244, 174, 162, 204, 57, 186, 120, 94, 185, 252, 146, 3, 118, 101, 32, 145, 135, 170, 176, 155, 100, 164, 197, 210, 36, 131, 184, 127, 198, 78, 241, 56, 61, 172, 169, 51, 207, 175, 30, 152, 239, 63, 165, 65, 158, 218, 8, 229, 98, 171, 44, 103, 25, 41, 242, 181, 9, 97, 46, 96, 178, 148, 253, 14, 208, 43, 235, 77, 116, 108, 136, 38, 124, 80, 234, 209, 168, 183, 2, 250, 153, 107, 11, 90, 199, 203, 189, 238, 195, 217, 140, 24, 173, 37, 256, 132, 52, 75, 123, 212, 29, 27, 34, 138, 31, 20, 187, 245, 42, 110, 129, 191, 231, 91, 67, 151, 114, 115, 240, 188, 113, 247, 35, 6, 236, 202, 64, 33, 13, 83, 95, 53, 200, 71, 137, 163, 72, 5, 111, 254, 139, 156, 225, 112, 122, 87, 81, 102, 157, 93, 60, 47, 221, 126, 73, 130, 59, 179, 16, 201, 196, 85, 88, 206, 50, 82, 227, 105, 18, 194, 92, 192, 99, 39, 249, 28, 159, 86, 213, 154, 232, 216, 15, 76, 248, 160, 211, 161, 79, 109, 4, 243, 49, 214, 22, 180, 141, 149, 121, 219, 133, 177, 23, 48, 89, 74, 255, 7, 104, 150, 246, 167, 58, 54, 68, 19, 62, 40, 117, 233, 84, 220, 1],
+[1, 126, 199, 145, 23, 71, 208, 251, 15, 91, 158, 119, 88, 37, 36, 167, 225, 80, 57, 243, 35, 41, 26, 192, 34, 172, 84, 47, 11, 101, 133, 53, 253, 10, 232, 191, 165, 230, 196, 24, 197, 150, 139, 38, 162, 109, 113, 103, 128, 194, 29, 56, 117, 93, 153, 3, 121, 83, 178, 69, 213, 110, 239, 45, 16, 217, 100, 7, 111, 108, 244, 161, 240, 171, 215, 105, 123, 78, 62, 102, 2, 252, 141, 33, 46, 142, 159, 245, 30, 182, 59, 238, 176, 74, 72, 77, 193, 160, 114, 229, 70, 82, 52, 127, 68, 87, 168, 94, 22, 202, 9, 106, 249, 20, 207, 125, 73, 203, 135, 48, 137, 43, 21, 76, 67, 218, 226, 206, 256, 131, 58, 112, 234, 186, 49, 6, 242, 166, 99, 138, 169, 220, 221, 90, 32, 177, 200, 14, 222, 216, 231, 65, 223, 85, 173, 210, 246, 156, 124, 204, 4, 247, 25, 66, 92, 27, 61, 233, 60, 107, 118, 219, 95, 148, 144, 154, 129, 63, 228, 201, 140, 164, 104, 254, 136, 174, 79, 188, 44, 147, 18, 212, 241, 40, 157, 250, 146, 149, 13, 96, 17, 86, 42, 152, 134, 179, 195, 155, 255, 5, 116, 224, 211, 115, 98, 12, 227, 75, 198, 19, 81, 183, 185, 180, 64, 97, 143, 28, 187, 175, 205, 130, 189, 170, 89, 163, 235, 55, 248, 151, 8, 237, 50, 132, 184, 54, 122, 209, 120, 214, 236, 181, 190, 39, 31, 51, 1],
+[1, 127, 195, 93, 246, 145, 168, 5, 121, 204, 208, 202, 211, 69, 25, 91, 249, 12, 239, 27, 88, 125, 198, 217, 60, 167, 135, 183, 111, 219, 57, 43, 64, 161, 144, 41, 67, 28, 215, 63, 34, 206, 205, 78, 140, 47, 58, 170, 2, 254, 133, 186, 235, 33, 79, 10, 242, 151, 159, 147, 165, 138, 50, 182, 241, 24, 221, 54, 176, 250, 139, 177, 120, 77, 13, 109, 222, 181, 114, 86, 128, 65, 31, 82, 134, 56, 173, 126, 68, 155, 153, 156, 23, 94, 116, 83, 4, 251, 9, 115, 213, 66, 158, 20, 227, 45, 61, 37, 73, 19, 100, 107, 225, 48, 185, 108, 95, 243, 21, 97, 240, 154, 26, 218, 187, 105, 228, 172, 256, 130, 62, 164, 11, 112, 89, 252, 136, 53, 49, 55, 46, 188, 232, 166, 8, 245, 18, 230, 169, 132, 59, 40, 197, 90, 122, 74, 146, 38, 200, 214, 193, 96, 113, 216, 190, 229, 42, 194, 223, 51, 52, 179, 117, 210, 199, 87, 255, 3, 124, 71, 22, 224, 178, 247, 15, 106, 98, 110, 92, 119, 207, 75, 16, 233, 36, 203, 81, 7, 118, 80, 137, 180, 244, 148, 35, 76, 143, 171, 129, 192, 226, 175, 123, 201, 84, 131, 189, 102, 104, 101, 234, 163, 141, 174, 253, 6, 248, 142, 44, 191, 99, 237, 30, 212, 196, 220, 184, 238, 157, 150, 32, 209, 72, 149, 162, 14, 236, 160, 17, 103, 231, 39, 70, 152, 29, 85, 1],
+[1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1],
+[1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1],
+[1, 130, 195, 164, 246, 112, 168, 252, 121, 53, 208, 55, 211, 188, 25, 166, 249, 245, 239, 230, 88, 132, 198, 40, 60, 90, 135, 74, 111, 38, 57, 214, 64, 96, 144, 216, 67, 229, 215, 194, 34, 51, 205, 179, 140, 210, 58, 87, 2, 3, 133, 71, 235, 224, 79, 247, 242, 106, 159, 110, 165, 119, 50, 75, 241, 233, 221, 203, 176, 7, 139, 80, 120, 180, 13, 148, 222, 76, 114, 171, 128, 192, 31, 175, 134, 201, 173, 131, 68, 102, 153, 101, 23, 163, 116, 174, 4, 6, 9, 142, 213, 191, 158, 237, 227, 212, 61, 220, 73, 238, 100, 150, 225, 209, 185, 149, 95, 14, 21, 160, 240, 103, 26, 39, 187, 152, 228, 85, 256, 127, 62, 93, 11, 145, 89, 5, 136, 204, 49, 202, 46, 69, 232, 91, 8, 12, 18, 27, 169, 125, 59, 217, 197, 167, 122, 183, 146, 219, 200, 43, 193, 161, 113, 41, 190, 28, 42, 63, 223, 206, 52, 78, 117, 47, 199, 170, 255, 254, 124, 186, 22, 33, 178, 10, 15, 151, 98, 147, 92, 138, 207, 182, 16, 24, 36, 54, 81, 250, 118, 177, 137, 77, 244, 109, 35, 181, 143, 86, 129, 65, 226, 82, 123, 56, 84, 126, 189, 155, 104, 156, 234, 94, 141, 83, 253, 251, 248, 115, 44, 66, 99, 20, 30, 45, 196, 37, 184, 19, 157, 107, 32, 48, 72, 108, 162, 243, 236, 97, 17, 154, 231, 218, 70, 105, 29, 172, 1],
+[1, 131, 199, 112, 23, 186, 208, 6, 15, 166, 158, 138, 88, 220, 36, 90, 225, 177, 57, 14, 35, 216, 26, 65, 34, 85, 84, 210, 11, 156, 133, 204, 253, 247, 232, 66, 165, 27, 196, 233, 197, 107, 139, 219, 162, 148, 113, 154, 128, 63, 29, 201, 117, 164, 153, 254, 121, 174, 178, 188, 213, 147, 239, 212, 16, 40, 100, 250, 111, 149, 244, 96, 240, 86, 215, 152, 123, 179, 62, 155, 2, 5, 141, 224, 46, 115, 159, 12, 30, 75, 59, 19, 176, 183, 72, 180, 193, 97, 114, 28, 70, 175, 52, 130, 68, 170, 168, 163, 22, 55, 9, 151, 249, 237, 207, 132, 73, 54, 135, 209, 137, 214, 21, 181, 67, 39, 226, 51, 256, 126, 58, 145, 234, 71, 49, 251, 242, 91, 99, 119, 169, 37, 221, 167, 32, 80, 200, 243, 222, 41, 231, 192, 223, 172, 173, 47, 246, 101, 124, 53, 4, 10, 25, 191, 92, 230, 61, 24, 60, 150, 118, 38, 95, 109, 144, 103, 129, 194, 228, 56, 140, 93, 104, 3, 136, 83, 79, 69, 44, 110, 18, 45, 241, 217, 157, 7, 146, 108, 13, 161, 17, 171, 42, 105, 134, 78, 195, 102, 255, 252, 116, 33, 211, 142, 98, 245, 227, 182, 198, 238, 81, 74, 185, 77, 64, 160, 143, 229, 187, 82, 205, 127, 189, 87, 89, 94, 235, 202, 248, 106, 8, 20, 50, 125, 184, 203, 122, 48, 120, 43, 236, 76, 190, 218, 31, 206, 1],
+[1, 132, 205, 75, 134, 212, 228, 27, 223, 138, 226, 20, 70, 245, 215, 110, 128, 191, 26, 91, 190, 151, 143, 115, 17, 188, 144, 247, 222, 6, 21, 202, 193, 33, 244, 83, 162, 53, 57, 71, 120, 163, 185, 5, 146, 254, 118, 156, 32, 112, 135, 87, 176, 102, 100, 93, 197, 47, 36, 126, 184, 130, 198, 179, 241, 201, 61, 85, 169, 206, 207, 82, 30, 105, 239, 194, 165, 192, 158, 39, 8, 28, 98, 86, 44, 154, 25, 216, 242, 76, 9, 160, 46, 161, 178, 109, 253, 243, 208, 214, 235, 180, 116, 149, 136, 219, 124, 177, 234, 48, 168, 74, 2, 7, 153, 150, 11, 167, 199, 54, 189, 19, 195, 40, 140, 233, 173, 220, 256, 125, 52, 182, 123, 45, 29, 230, 34, 119, 31, 237, 187, 12, 42, 147, 129, 66, 231, 166, 67, 106, 114, 142, 240, 69, 113, 10, 35, 251, 236, 55, 64, 224, 13, 174, 95, 204, 200, 186, 137, 94, 72, 252, 111, 3, 139, 101, 225, 145, 122, 170, 81, 155, 157, 164, 60, 210, 221, 131, 73, 127, 59, 78, 16, 56, 196, 172, 88, 51, 50, 175, 227, 152, 18, 63, 92, 65, 99, 218, 249, 229, 159, 171, 213, 103, 232, 41, 15, 181, 248, 97, 211, 96, 79, 148, 4, 14, 49, 43, 22, 77, 141, 108, 121, 38, 133, 80, 23, 209, 89, 183, 255, 250, 104, 107, 246, 90, 58, 203, 68, 238, 62, 217, 117, 24, 84, 37, 1],
+[1, 133, 213, 59, 137, 231, 140, 116, 8, 36, 162, 215, 68, 49, 92, 157, 64, 31, 11, 178, 30, 135, 222, 228, 255, 248, 88, 139, 240, 52, 234, 25, 241, 185, 190, 84, 121, 159, 73, 200, 129, 195, 235, 158, 197, 244, 70, 58, 4, 18, 81, 236, 34, 153, 46, 207, 32, 144, 134, 89, 15, 196, 111, 114, 256, 124, 44, 198, 120, 26, 117, 141, 249, 221, 95, 42, 189, 208, 165, 100, 193, 226, 246, 79, 227, 122, 35, 29, 2, 9, 169, 118, 17, 205, 23, 232, 16, 72, 67, 173, 136, 98, 184, 57, 128, 62, 22, 99, 60, 13, 187, 199, 253, 239, 176, 21, 223, 104, 211, 50, 225, 113, 123, 168, 242, 61, 146, 143, 1, 133, 213, 59, 137, 231, 140, 116, 8, 36, 162, 215, 68, 49, 92, 157, 64, 31, 11, 178, 30, 135, 222, 228, 255, 248, 88, 139, 240, 52, 234, 25, 241, 185, 190, 84, 121, 159, 73, 200, 129, 195, 235, 158, 197, 244, 70, 58, 4, 18, 81, 236, 34, 153, 46, 207, 32, 144, 134, 89, 15, 196, 111, 114, 256, 124, 44, 198, 120, 26, 117, 141, 249, 221, 95, 42, 189, 208, 165, 100, 193, 226, 246, 79, 227, 122, 35, 29, 2, 9, 169, 118, 17, 205, 23, 232, 16, 72, 67, 173, 136, 98, 184, 57, 128, 62, 22, 99, 60, 13, 187, 199, 253, 239, 176, 21, 223, 104, 211, 50, 225, 113, 123, 168, 242, 61, 146, 143, 1],
+[1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1],
+[1, 135, 235, 114, 227, 62, 146, 178, 129, 196, 246, 57, 242, 31, 73, 89, 193, 98, 123, 157, 121, 144, 165, 173, 225, 49, 190, 207, 189, 72, 211, 215, 241, 153, 95, 232, 223, 36, 234, 236, 249, 205, 176, 116, 240, 18, 117, 118, 253, 231, 88, 58, 120, 9, 187, 59, 255, 244, 44, 29, 60, 133, 222, 158, 256, 122, 22, 143, 30, 195, 111, 79, 128, 61, 11, 200, 15, 226, 184, 168, 64, 159, 134, 100, 136, 113, 92, 84, 32, 208, 67, 50, 68, 185, 46, 42, 16, 104, 162, 25, 34, 221, 23, 21, 8, 52, 81, 141, 17, 239, 140, 139, 4, 26, 169, 199, 137, 248, 70, 198, 2, 13, 213, 228, 197, 124, 35, 99, 1, 135, 235, 114, 227, 62, 146, 178, 129, 196, 246, 57, 242, 31, 73, 89, 193, 98, 123, 157, 121, 144, 165, 173, 225, 49, 190, 207, 189, 72, 211, 215, 241, 153, 95, 232, 223, 36, 234, 236, 249, 205, 176, 116, 240, 18, 117, 118, 253, 231, 88, 58, 120, 9, 187, 59, 255, 244, 44, 29, 60, 133, 222, 158, 256, 122, 22, 143, 30, 195, 111, 79, 128, 61, 11, 200, 15, 226, 184, 168, 64, 159, 134, 100, 136, 113, 92, 84, 32, 208, 67, 50, 68, 185, 46, 42, 16, 104, 162, 25, 34, 221, 23, 21, 8, 52, 81, 141, 17, 239, 140, 139, 4, 26, 169, 199, 137, 248, 70, 198, 2, 13, 213, 228, 197, 124, 35, 99, 1],
+[1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1],
+[1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1],
+[1, 138, 26, 247, 162, 254, 100, 179, 30, 28, 9, 214, 234, 167, 173, 230, 129, 69, 13, 252, 81, 127, 50, 218, 15, 14, 133, 107, 117, 212, 215, 115, 193, 163, 135, 126, 169, 192, 25, 109, 136, 7, 195, 182, 187, 106, 236, 186, 225, 210, 196, 63, 213, 96, 141, 183, 68, 132, 226, 91, 222, 53, 118, 93, 241, 105, 98, 160, 235, 48, 199, 220, 34, 66, 113, 174, 111, 155, 59, 175, 249, 181, 49, 80, 246, 24, 228, 110, 17, 33, 185, 87, 184, 206, 158, 216, 253, 219, 153, 40, 123, 12, 114, 55, 137, 145, 221, 172, 92, 103, 79, 108, 255, 238, 205, 20, 190, 6, 57, 156, 197, 201, 239, 86, 46, 180, 168, 54, 256, 119, 231, 10, 95, 3, 157, 78, 227, 229, 248, 43, 23, 90, 84, 27, 128, 188, 244, 5, 176, 130, 207, 39, 242, 243, 124, 150, 140, 45, 42, 142, 64, 94, 122, 131, 88, 65, 232, 148, 121, 250, 62, 75, 70, 151, 21, 71, 32, 47, 61, 194, 44, 161, 116, 74, 189, 125, 31, 166, 35, 204, 139, 164, 16, 152, 159, 97, 22, 209, 58, 37, 223, 191, 144, 83, 146, 102, 198, 82, 8, 76, 208, 177, 11, 233, 29, 147, 240, 224, 72, 170, 73, 51, 99, 41, 4, 38, 104, 217, 134, 245, 143, 202, 120, 112, 36, 85, 165, 154, 178, 149, 2, 19, 52, 237, 67, 251, 200, 101, 60, 56, 18, 171, 211, 77, 89, 203, 1],
+[1, 139, 46, 226, 60, 116, 190, 196, 2, 21, 92, 195, 120, 232, 123, 135, 4, 42, 184, 133, 240, 207, 246, 13, 8, 84, 111, 9, 223, 157, 235, 26, 16, 168, 222, 18, 189, 57, 213, 52, 32, 79, 187, 36, 121, 114, 169, 104, 64, 158, 117, 72, 242, 228, 81, 208, 128, 59, 234, 144, 227, 199, 162, 159, 256, 118, 211, 31, 197, 141, 67, 61, 255, 236, 165, 62, 137, 25, 134, 122, 253, 215, 73, 124, 17, 50, 11, 244, 249, 173, 146, 248, 34, 100, 22, 231, 241, 89, 35, 239, 68, 200, 44, 205, 225, 178, 70, 221, 136, 143, 88, 153, 193, 99, 140, 185, 15, 29, 176, 49, 129, 198, 23, 113, 30, 58, 95, 98, 1, 139, 46, 226, 60, 116, 190, 196, 2, 21, 92, 195, 120, 232, 123, 135, 4, 42, 184, 133, 240, 207, 246, 13, 8, 84, 111, 9, 223, 157, 235, 26, 16, 168, 222, 18, 189, 57, 213, 52, 32, 79, 187, 36, 121, 114, 169, 104, 64, 158, 117, 72, 242, 228, 81, 208, 128, 59, 234, 144, 227, 199, 162, 159, 256, 118, 211, 31, 197, 141, 67, 61, 255, 236, 165, 62, 137, 25, 134, 122, 253, 215, 73, 124, 17, 50, 11, 244, 249, 173, 146, 248, 34, 100, 22, 231, 241, 89, 35, 239, 68, 200, 44, 205, 225, 178, 70, 221, 136, 143, 88, 153, 193, 99, 140, 185, 15, 29, 176, 49, 129, 198, 23, 113, 30, 58, 95, 98, 1],
+[1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1],
+[1, 141, 92, 122, 240, 173, 235, 239, 32, 143, 117, 49, 227, 139, 67, 195, 253, 207, 146, 26, 68, 79, 88, 72, 129, 199, 46, 61, 120, 215, 246, 248, 16, 200, 187, 153, 242, 198, 162, 226, 255, 232, 73, 13, 34, 168, 44, 36, 193, 228, 23, 159, 60, 236, 123, 124, 8, 100, 222, 205, 121, 99, 81, 113, 256, 116, 165, 135, 17, 84, 22, 18, 225, 114, 140, 208, 30, 118, 190, 62, 4, 50, 111, 231, 189, 178, 169, 185, 128, 58, 211, 196, 137, 42, 11, 9, 241, 57, 70, 104, 15, 59, 95, 31, 2, 25, 184, 244, 223, 89, 213, 221, 64, 29, 234, 98, 197, 21, 134, 133, 249, 157, 35, 52, 136, 158, 176, 144, 1, 141, 92, 122, 240, 173, 235, 239, 32, 143, 117, 49, 227, 139, 67, 195, 253, 207, 146, 26, 68, 79, 88, 72, 129, 199, 46, 61, 120, 215, 246, 248, 16, 200, 187, 153, 242, 198, 162, 226, 255, 232, 73, 13, 34, 168, 44, 36, 193, 228, 23, 159, 60, 236, 123, 124, 8, 100, 222, 205, 121, 99, 81, 113, 256, 116, 165, 135, 17, 84, 22, 18, 225, 114, 140, 208, 30, 118, 190, 62, 4, 50, 111, 231, 189, 178, 169, 185, 128, 58, 211, 196, 137, 42, 11, 9, 241, 57, 70, 104, 15, 59, 95, 31, 2, 25, 184, 244, 223, 89, 213, 221, 64, 29, 234, 98, 197, 21, 134, 133, 249, 157, 35, 52, 136, 158, 176, 144, 1],
+[1, 142, 118, 51, 46, 107, 31, 33, 60, 39, 141, 233, 190, 252, 61, 181, 2, 27, 236, 102, 92, 214, 62, 66, 120, 78, 25, 209, 123, 247, 122, 105, 4, 54, 215, 204, 184, 171, 124, 132, 240, 156, 50, 161, 246, 237, 244, 210, 8, 108, 173, 151, 111, 85, 248, 7, 223, 55, 100, 65, 235, 217, 231, 163, 16, 216, 89, 45, 222, 170, 239, 14, 189, 110, 200, 130, 213, 177, 205, 69, 32, 175, 178, 90, 187, 83, 221, 28, 121, 220, 143, 3, 169, 97, 153, 138, 64, 93, 99, 180, 117, 166, 185, 56, 242, 183, 29, 6, 81, 194, 49, 19, 128, 186, 198, 103, 234, 75, 113, 112, 227, 109, 58, 12, 162, 131, 98, 38, 256, 115, 139, 206, 211, 150, 226, 224, 197, 218, 116, 24, 67, 5, 196, 76, 255, 230, 21, 155, 165, 43, 195, 191, 137, 179, 232, 48, 134, 10, 135, 152, 253, 203, 42, 53, 73, 86, 133, 125, 17, 101, 207, 96, 11, 20, 13, 47, 249, 149, 84, 106, 146, 172, 9, 250, 34, 202, 157, 192, 22, 40, 26, 94, 241, 41, 168, 212, 35, 87, 18, 243, 68, 147, 57, 127, 44, 80, 52, 188, 225, 82, 79, 167, 70, 174, 36, 229, 136, 37, 114, 254, 88, 160, 104, 119, 193, 164, 158, 77, 140, 91, 72, 201, 15, 74, 228, 251, 176, 63, 208, 238, 129, 71, 59, 154, 23, 182, 144, 145, 30, 148, 199, 245, 95, 126, 159, 219, 1],
+[1, 143, 146, 61, 242, 168, 123, 113, 225, 50, 211, 104, 223, 21, 176, 239, 253, 199, 187, 13, 60, 99, 22, 62, 128, 57, 184, 98, 136, 173, 67, 72, 16, 232, 23, 205, 17, 118, 169, 9, 2, 29, 35, 122, 227, 79, 246, 226, 193, 100, 165, 208, 189, 42, 95, 221, 249, 141, 117, 26, 120, 198, 44, 124, 256, 114, 111, 196, 15, 89, 134, 144, 32, 207, 46, 153, 34, 236, 81, 18, 4, 58, 70, 244, 197, 158, 235, 195, 129, 200, 73, 159, 121, 84, 190, 185, 241, 25, 234, 52, 240, 139, 88, 248, 255, 228, 222, 135, 30, 178, 11, 31, 64, 157, 92, 49, 68, 215, 162, 36, 8, 116, 140, 231, 137, 59, 213, 133, 1, 143, 146, 61, 242, 168, 123, 113, 225, 50, 211, 104, 223, 21, 176, 239, 253, 199, 187, 13, 60, 99, 22, 62, 128, 57, 184, 98, 136, 173, 67, 72, 16, 232, 23, 205, 17, 118, 169, 9, 2, 29, 35, 122, 227, 79, 246, 226, 193, 100, 165, 208, 189, 42, 95, 221, 249, 141, 117, 26, 120, 198, 44, 124, 256, 114, 111, 196, 15, 89, 134, 144, 32, 207, 46, 153, 34, 236, 81, 18, 4, 58, 70, 244, 197, 158, 235, 195, 129, 200, 73, 159, 121, 84, 190, 185, 241, 25, 234, 52, 240, 139, 88, 248, 255, 228, 222, 135, 30, 178, 11, 31, 64, 157, 92, 49, 68, 215, 162, 36, 8, 116, 140, 231, 137, 59, 213, 133, 1],
+[1, 144, 176, 158, 136, 52, 35, 157, 249, 133, 134, 21, 197, 98, 234, 29, 64, 221, 213, 89, 223, 244, 184, 25, 2, 31, 95, 59, 15, 104, 70, 57, 241, 9, 11, 42, 137, 196, 211, 58, 128, 185, 169, 178, 189, 231, 111, 50, 4, 62, 190, 118, 30, 208, 140, 114, 225, 18, 22, 84, 17, 135, 165, 116, 256, 113, 81, 99, 121, 205, 222, 100, 8, 124, 123, 236, 60, 159, 23, 228, 193, 36, 44, 168, 34, 13, 73, 232, 255, 226, 162, 198, 242, 153, 187, 200, 16, 248, 246, 215, 120, 61, 46, 199, 129, 72, 88, 79, 68, 26, 146, 207, 253, 195, 67, 139, 227, 49, 117, 143, 32, 239, 235, 173, 240, 122, 92, 141, 1, 144, 176, 158, 136, 52, 35, 157, 249, 133, 134, 21, 197, 98, 234, 29, 64, 221, 213, 89, 223, 244, 184, 25, 2, 31, 95, 59, 15, 104, 70, 57, 241, 9, 11, 42, 137, 196, 211, 58, 128, 185, 169, 178, 189, 231, 111, 50, 4, 62, 190, 118, 30, 208, 140, 114, 225, 18, 22, 84, 17, 135, 165, 116, 256, 113, 81, 99, 121, 205, 222, 100, 8, 124, 123, 236, 60, 159, 23, 228, 193, 36, 44, 168, 34, 13, 73, 232, 255, 226, 162, 198, 242, 153, 187, 200, 16, 248, 246, 215, 120, 61, 46, 199, 129, 72, 88, 79, 68, 26, 146, 207, 253, 195, 67, 139, 227, 49, 117, 143, 32, 239, 235, 173, 240, 122, 92, 141, 1],
+[1, 145, 208, 91, 88, 167, 57, 41, 34, 47, 133, 10, 165, 24, 139, 109, 128, 56, 153, 83, 213, 45, 100, 108, 240, 105, 62, 252, 46, 245, 59, 74, 193, 229, 52, 87, 22, 106, 207, 203, 137, 76, 226, 131, 234, 6, 99, 220, 32, 14, 231, 85, 246, 204, 25, 27, 60, 219, 144, 63, 140, 254, 79, 147, 241, 250, 13, 86, 134, 155, 116, 115, 227, 19, 185, 97, 187, 130, 89, 55, 8, 132, 122, 214, 190, 51, 199, 71, 15, 119, 36, 80, 35, 192, 84, 101, 253, 191, 196, 150, 162, 103, 29, 93, 121, 69, 239, 217, 111, 161, 215, 78, 2, 33, 159, 182, 176, 77, 114, 82, 68, 94, 9, 20, 73, 48, 21, 218, 256, 112, 49, 166, 169, 90, 200, 216, 223, 210, 124, 247, 92, 233, 118, 148, 129, 201, 104, 174, 44, 212, 157, 149, 17, 152, 195, 5, 211, 12, 198, 183, 64, 28, 205, 170, 235, 151, 50, 54, 120, 181, 31, 126, 23, 251, 158, 37, 225, 243, 26, 172, 11, 53, 232, 230, 197, 38, 113, 194, 117, 3, 178, 110, 16, 7, 244, 171, 123, 102, 141, 142, 30, 238, 72, 160, 70, 127, 168, 202, 249, 125, 135, 43, 67, 206, 58, 186, 242, 138, 221, 177, 222, 65, 173, 156, 4, 66, 61, 107, 95, 154, 228, 164, 136, 188, 18, 40, 146, 96, 42, 179, 255, 224, 98, 75, 81, 180, 143, 175, 189, 163, 248, 237, 184, 209, 236, 39, 1],
+[1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1],
+[1, 147, 21, 3, 184, 63, 9, 38, 189, 27, 114, 53, 81, 85, 159, 243, 255, 220, 215, 251, 146, 131, 239, 181, 136, 203, 29, 151, 95, 87, 196, 28, 4, 74, 84, 12, 222, 252, 36, 152, 242, 108, 199, 212, 67, 83, 122, 201, 249, 109, 89, 233, 70, 10, 185, 210, 30, 41, 116, 90, 123, 91, 13, 112, 16, 39, 79, 48, 117, 237, 144, 94, 197, 175, 25, 77, 11, 75, 231, 33, 225, 179, 99, 161, 23, 40, 226, 69, 120, 164, 207, 103, 235, 107, 52, 191, 64, 156, 59, 192, 211, 177, 62, 119, 17, 186, 100, 51, 44, 43, 153, 132, 129, 202, 139, 130, 92, 160, 133, 19, 223, 142, 57, 155, 169, 171, 208, 250, 256, 110, 236, 254, 73, 194, 248, 219, 68, 230, 143, 204, 176, 172, 98, 14, 2, 37, 42, 6, 111, 126, 18, 76, 121, 54, 228, 106, 162, 170, 61, 229, 253, 183, 173, 245, 35, 5, 221, 105, 15, 149, 58, 45, 190, 174, 135, 56, 8, 148, 168, 24, 187, 247, 72, 47, 227, 216, 141, 167, 134, 166, 244, 145, 241, 218, 178, 209, 140, 20, 113, 163, 60, 82, 232, 180, 246, 182, 26, 224, 32, 78, 158, 96, 234, 217, 31, 188, 137, 93, 50, 154, 22, 150, 205, 66, 193, 101, 198, 65, 46, 80, 195, 138, 240, 71, 157, 206, 213, 214, 104, 125, 128, 55, 118, 127, 165, 97, 124, 238, 34, 115, 200, 102, 88, 86, 49, 7, 1],
+[1, 148, 59, 251, 140, 160, 36, 188, 68, 41, 157, 106, 11, 86, 135, 191, 255, 218, 139, 12, 234, 194, 185, 138, 121, 175, 200, 45, 235, 85, 244, 132, 4, 78, 236, 233, 46, 126, 144, 238, 15, 164, 114, 167, 44, 87, 26, 250, 249, 101, 42, 48, 165, 5, 226, 38, 227, 186, 29, 180, 169, 83, 205, 14, 16, 55, 173, 161, 184, 247, 62, 181, 60, 142, 199, 154, 176, 91, 104, 229, 225, 147, 168, 192, 146, 20, 133, 152, 137, 230, 116, 206, 162, 75, 49, 56, 64, 220, 178, 130, 222, 217, 248, 210, 240, 54, 25, 102, 190, 107, 159, 145, 129, 74, 158, 254, 70, 80, 18, 94, 34, 149, 207, 53, 134, 43, 196, 224, 256, 109, 198, 6, 117, 97, 221, 69, 189, 216, 100, 151, 246, 171, 122, 66, 2, 39, 118, 245, 23, 63, 72, 119, 136, 82, 57, 212, 22, 172, 13, 125, 253, 179, 21, 24, 211, 131, 113, 19, 242, 93, 143, 90, 213, 170, 231, 7, 8, 156, 215, 209, 92, 252, 31, 219, 30, 71, 228, 77, 88, 174, 52, 243, 241, 202, 84, 96, 73, 10, 195, 76, 197, 115, 58, 103, 81, 166, 153, 28, 32, 110, 89, 65, 111, 237, 124, 105, 120, 27, 141, 51, 95, 182, 208, 201, 193, 37, 79, 127, 35, 40, 9, 47, 17, 203, 232, 155, 67, 150, 98, 112, 128, 183, 99, 3, 187, 177, 239, 163, 223, 108, 50, 204, 123, 214, 61, 33, 1],
+[1, 149, 99, 102, 35, 75, 124, 229, 197, 55, 228, 48, 213, 126, 13, 138, 2, 41, 198, 204, 70, 150, 248, 201, 137, 110, 199, 96, 169, 252, 26, 19, 4, 82, 139, 151, 140, 43, 239, 145, 17, 220, 141, 192, 81, 247, 52, 38, 8, 164, 21, 45, 23, 86, 221, 33, 34, 183, 25, 127, 162, 237, 104, 76, 16, 71, 42, 90, 46, 172, 185, 66, 68, 109, 50, 254, 67, 217, 208, 152, 32, 142, 84, 180, 92, 87, 113, 132, 136, 218, 100, 251, 134, 177, 159, 47, 64, 27, 168, 103, 184, 174, 226, 7, 15, 179, 200, 245, 11, 97, 61, 94, 128, 54, 79, 206, 111, 91, 195, 14, 30, 101, 143, 233, 22, 194, 122, 188, 256, 108, 158, 155, 222, 182, 133, 28, 60, 202, 29, 209, 44, 131, 244, 119, 255, 216, 59, 53, 187, 107, 9, 56, 120, 147, 58, 161, 88, 5, 231, 238, 253, 175, 118, 106, 117, 214, 18, 112, 240, 37, 116, 65, 176, 10, 205, 219, 249, 93, 236, 212, 234, 171, 36, 224, 223, 74, 232, 130, 95, 20, 153, 181, 241, 186, 215, 167, 211, 85, 72, 191, 189, 148, 207, 3, 190, 40, 49, 105, 225, 115, 173, 77, 165, 170, 144, 125, 121, 39, 157, 6, 123, 80, 98, 210, 193, 230, 89, 154, 73, 83, 31, 250, 242, 78, 57, 12, 246, 160, 196, 163, 129, 203, 178, 51, 146, 166, 62, 243, 227, 156, 114, 24, 235, 63, 135, 69, 1],
+[1, 150, 141, 76, 92, 179, 122, 53, 240, 20, 173, 250, 235, 41, 239, 127, 32, 174, 143, 119, 117, 74, 49, 154, 227, 126, 139, 33, 67, 27, 195, 209, 253, 171, 207, 210, 146, 55, 26, 45, 68, 177, 79, 28, 88, 93, 72, 6, 129, 75, 199, 38, 46, 218, 61, 155, 120, 10, 215, 125, 246, 149, 248, 192, 16, 87, 200, 188, 187, 37, 153, 77, 242, 63, 198, 145, 162, 142, 226, 233, 255, 214, 232, 105, 73, 156, 13, 151, 34, 217, 168, 14, 44, 175, 36, 3, 193, 166, 228, 19, 23, 109, 159, 206, 60, 5, 236, 191, 123, 203, 124, 96, 8, 172, 100, 94, 222, 147, 205, 167, 121, 160, 99, 201, 81, 71, 113, 245, 256, 107, 116, 181, 165, 78, 135, 204, 17, 237, 84, 7, 22, 216, 18, 130, 225, 83, 114, 138, 140, 183, 208, 103, 30, 131, 118, 224, 190, 230, 62, 48, 4, 86, 50, 47, 111, 202, 231, 212, 189, 80, 178, 229, 169, 164, 185, 251, 128, 182, 58, 219, 211, 39, 196, 102, 137, 247, 42, 132, 11, 108, 9, 65, 241, 170, 57, 69, 70, 220, 104, 180, 15, 194, 59, 112, 95, 115, 31, 24, 2, 43, 25, 152, 184, 101, 244, 106, 223, 40, 89, 243, 213, 82, 221, 254, 64, 91, 29, 238, 234, 148, 98, 51, 197, 252, 21, 66, 134, 54, 133, 161, 249, 85, 157, 163, 35, 110, 52, 90, 136, 97, 158, 56, 176, 186, 144, 12, 1],
+[1, 151, 185, 179, 44, 219, 173, 166, 137, 127, 159, 108, 117, 191, 57, 126, 8, 180, 195, 147, 95, 210, 99, 43, 68, 245, 244, 93, 165, 243, 199, 237, 64, 155, 18, 148, 246, 138, 21, 87, 30, 161, 153, 230, 35, 145, 50, 97, 255, 212, 144, 156, 169, 76, 168, 182, 240, 3, 196, 41, 23, 132, 143, 5, 241, 154, 124, 220, 67, 94, 59, 171, 121, 24, 26, 71, 184, 28, 116, 40, 129, 204, 221, 218, 22, 238, 215, 83, 197, 192, 208, 54, 187, 224, 157, 63, 4, 90, 226, 202, 176, 105, 178, 150, 34, 251, 122, 175, 211, 250, 228, 247, 32, 206, 9, 74, 123, 69, 139, 172, 15, 209, 205, 115, 146, 201, 25, 177, 256, 106, 72, 78, 213, 38, 84, 91, 120, 130, 98, 149, 140, 66, 200, 131, 249, 77, 62, 110, 162, 47, 158, 214, 189, 12, 13, 164, 92, 14, 58, 20, 193, 102, 239, 109, 11, 119, 236, 170, 227, 96, 104, 27, 222, 112, 207, 160, 2, 45, 113, 101, 88, 181, 89, 75, 17, 254, 61, 216, 234, 125, 114, 252, 16, 103, 133, 37, 190, 163, 198, 86, 136, 233, 231, 186, 73, 229, 141, 217, 128, 53, 36, 39, 235, 19, 42, 174, 60, 65, 49, 203, 70, 33, 100, 194, 253, 167, 31, 55, 81, 152, 79, 107, 223, 6, 135, 82, 46, 7, 29, 10, 225, 51, 248, 183, 134, 188, 118, 85, 242, 48, 52, 142, 111, 56, 232, 80, 1],
+[1, 152, 231, 160, 162, 209, 157, 220, 30, 191, 248, 174, 234, 102, 84, 175, 129, 76, 244, 80, 81, 233, 207, 110, 15, 224, 124, 87, 117, 51, 42, 216, 193, 38, 122, 40, 169, 245, 232, 55, 136, 112, 62, 172, 187, 154, 21, 108, 225, 19, 61, 20, 213, 251, 116, 156, 68, 56, 31, 86, 222, 77, 139, 54, 241, 138, 159, 10, 235, 254, 58, 78, 34, 28, 144, 43, 111, 167, 198, 27, 249, 69, 208, 5, 246, 127, 29, 39, 17, 14, 72, 150, 184, 212, 99, 142, 253, 163, 104, 131, 123, 192, 143, 148, 137, 7, 36, 75, 92, 106, 178, 71, 255, 210, 52, 194, 190, 96, 200, 74, 197, 132, 18, 166, 46, 53, 89, 164, 256, 105, 26, 97, 95, 48, 100, 37, 227, 66, 9, 83, 23, 155, 173, 82, 128, 181, 13, 177, 176, 24, 50, 147, 242, 33, 133, 170, 140, 206, 215, 41, 64, 219, 135, 217, 88, 12, 25, 202, 121, 145, 195, 85, 70, 103, 236, 149, 32, 238, 196, 237, 44, 6, 141, 101, 189, 201, 226, 171, 35, 180, 118, 203, 16, 119, 98, 247, 22, 3, 199, 179, 223, 229, 113, 214, 146, 90, 59, 230, 8, 188, 49, 252, 11, 130, 228, 218, 240, 243, 185, 107, 73, 45, 158, 115, 4, 94, 153, 126, 134, 65, 114, 109, 120, 250, 221, 182, 165, 151, 79, 186, 2, 47, 205, 63, 67, 161, 57, 183, 60, 125, 239, 91, 211, 204, 168, 93, 1],
+[1, 153, 22, 25, 227, 36, 111, 21, 129, 205, 11, 141, 242, 18, 184, 139, 193, 231, 134, 199, 121, 9, 92, 198, 225, 244, 67, 228, 189, 133, 46, 99, 241, 122, 162, 114, 223, 195, 23, 178, 249, 61, 81, 57, 240, 226, 140, 89, 253, 159, 169, 157, 120, 113, 70, 173, 255, 208, 213, 207, 60, 185, 35, 215, 256, 104, 235, 232, 30, 221, 146, 236, 128, 52, 246, 116, 15, 239, 73, 118, 64, 26, 123, 58, 136, 248, 165, 59, 32, 13, 190, 29, 68, 124, 211, 158, 16, 135, 95, 143, 34, 62, 234, 79, 8, 196, 176, 200, 17, 31, 117, 168, 4, 98, 88, 100, 137, 144, 187, 84, 2, 49, 44, 50, 197, 72, 222, 42, 1, 153, 22, 25, 227, 36, 111, 21, 129, 205, 11, 141, 242, 18, 184, 139, 193, 231, 134, 199, 121, 9, 92, 198, 225, 244, 67, 228, 189, 133, 46, 99, 241, 122, 162, 114, 223, 195, 23, 178, 249, 61, 81, 57, 240, 226, 140, 89, 253, 159, 169, 157, 120, 113, 70, 173, 255, 208, 213, 207, 60, 185, 35, 215, 256, 104, 235, 232, 30, 221, 146, 236, 128, 52, 246, 116, 15, 239, 73, 118, 64, 26, 123, 58, 136, 248, 165, 59, 32, 13, 190, 29, 68, 124, 211, 158, 16, 135, 95, 143, 34, 62, 234, 79, 8, 196, 176, 200, 17, 31, 117, 168, 4, 98, 88, 100, 137, 144, 187, 84, 2, 49, 44, 50, 197, 72, 222, 42, 1],
+[1, 154, 72, 37, 44, 94, 84, 86, 137, 24, 98, 186, 117, 28, 200, 217, 8, 204, 62, 39, 95, 238, 158, 174, 68, 192, 13, 203, 165, 224, 58, 194, 64, 90, 239, 55, 246, 105, 236, 107, 30, 251, 104, 82, 35, 250, 207, 10, 255, 206, 113, 183, 169, 69, 89, 85, 240, 209, 61, 142, 23, 201, 114, 80, 241, 106, 133, 179, 67, 38, 198, 166, 121, 130, 231, 108, 184, 66, 141, 126, 129, 77, 36, 147, 22, 47, 42, 43, 197, 12, 49, 93, 187, 14, 100, 237, 4, 102, 31, 148, 176, 119, 79, 87, 34, 96, 135, 230, 211, 112, 29, 97, 32, 45, 248, 156, 123, 181, 118, 182, 15, 254, 52, 41, 146, 125, 232, 5, 256, 103, 185, 220, 213, 163, 173, 171, 120, 233, 159, 71, 140, 229, 57, 40, 249, 53, 195, 218, 162, 19, 99, 83, 189, 65, 244, 54, 92, 33, 199, 63, 193, 167, 18, 202, 11, 152, 21, 150, 227, 6, 153, 175, 222, 7, 50, 247, 2, 51, 144, 74, 88, 188, 168, 172, 17, 48, 196, 115, 234, 56, 143, 177, 16, 151, 124, 78, 190, 219, 59, 91, 136, 127, 26, 149, 73, 191, 116, 131, 128, 180, 221, 110, 235, 210, 215, 214, 60, 245, 208, 164, 70, 243, 157, 20, 253, 155, 226, 109, 81, 138, 178, 170, 223, 161, 122, 27, 46, 145, 228, 160, 225, 212, 9, 101, 134, 76, 139, 75, 242, 3, 205, 216, 111, 132, 25, 252, 1],
+[1, 155, 124, 202, 213, 119, 198, 107, 137, 161, 26, 175, 140, 112, 141, 10, 8, 212, 221, 74, 162, 181, 42, 85, 68, 3, 208, 115, 92, 125, 100, 80, 64, 154, 226, 78, 11, 163, 79, 166, 30, 24, 122, 149, 222, 229, 29, 126, 255, 204, 9, 110, 88, 19, 118, 43, 240, 192, 205, 164, 234, 33, 232, 237, 241, 90, 72, 109, 190, 152, 173, 87, 121, 251, 98, 27, 73, 7, 57, 97, 129, 206, 62, 101, 235, 188, 99, 182, 197, 209, 13, 216, 70, 56, 199, 5, 4, 106, 239, 37, 81, 219, 21, 171, 34, 130, 104, 186, 46, 191, 50, 40, 32, 77, 113, 39, 134, 210, 168, 83, 15, 12, 61, 203, 111, 243, 143, 63, 256, 102, 133, 55, 44, 138, 59, 150, 120, 96, 231, 82, 117, 145, 116, 247, 249, 45, 36, 183, 95, 76, 215, 172, 189, 254, 49, 142, 165, 132, 157, 177, 193, 103, 31, 179, 246, 94, 178, 91, 227, 233, 135, 108, 35, 28, 228, 131, 2, 53, 248, 147, 169, 238, 139, 214, 17, 65, 52, 93, 23, 224, 25, 20, 16, 167, 185, 148, 67, 105, 84, 170, 136, 6, 159, 230, 184, 250, 200, 160, 128, 51, 195, 156, 22, 69, 158, 75, 60, 48, 244, 41, 187, 201, 58, 252, 253, 151, 18, 220, 176, 38, 236, 86, 223, 127, 153, 71, 211, 66, 207, 217, 225, 180, 144, 218, 123, 47, 89, 174, 242, 245, 196, 54, 146, 14, 114, 194, 1],
+[1, 156, 178, 12, 73, 80, 144, 105, 189, 186, 232, 212, 176, 214, 231, 56, 255, 202, 158, 233, 111, 97, 226, 47, 136, 142, 50, 90, 162, 86, 52, 145, 4, 110, 198, 48, 35, 63, 62, 163, 242, 230, 157, 77, 190, 85, 153, 224, 249, 37, 118, 161, 187, 131, 133, 188, 30, 54, 200, 103, 134, 87, 208, 66, 16, 183, 21, 192, 140, 252, 248, 138, 197, 149, 114, 51, 246, 83, 98, 125, 225, 148, 215, 130, 234, 10, 18, 238, 120, 216, 29, 155, 22, 91, 61, 7, 64, 218, 84, 254, 46, 237, 221, 38, 17, 82, 199, 204, 213, 75, 135, 243, 129, 78, 89, 6, 165, 40, 72, 181, 223, 93, 116, 106, 88, 107, 244, 28, 256, 101, 79, 245, 184, 177, 113, 152, 68, 71, 25, 45, 81, 43, 26, 201, 2, 55, 99, 24, 146, 160, 31, 210, 121, 115, 207, 167, 95, 171, 205, 112, 253, 147, 59, 209, 222, 194, 195, 94, 15, 27, 100, 180, 67, 172, 104, 33, 8, 220, 139, 96, 70, 126, 124, 69, 227, 203, 57, 154, 123, 170, 49, 191, 241, 74, 236, 65, 117, 5, 9, 119, 60, 108, 143, 206, 11, 174, 159, 132, 32, 109, 42, 127, 23, 247, 239, 19, 137, 41, 228, 102, 235, 166, 196, 250, 193, 39, 173, 3, 211, 20, 36, 219, 240, 175, 58, 53, 44, 182, 122, 14, 128, 179, 168, 251, 92, 217, 185, 76, 34, 164, 141, 151, 169, 150, 13, 229, 1],
+[1, 157, 234, 244, 15, 42, 169, 62, 225, 116, 222, 159, 34, 198, 246, 72, 253, 143, 92, 52, 197, 89, 95, 9, 128, 50, 140, 135, 121, 236, 44, 226, 16, 199, 146, 49, 240, 158, 134, 221, 2, 57, 211, 231, 30, 84, 81, 124, 193, 232, 187, 61, 68, 139, 235, 144, 249, 29, 184, 104, 137, 178, 190, 18, 256, 100, 23, 13, 242, 215, 88, 195, 32, 141, 35, 98, 223, 59, 11, 185, 4, 114, 165, 205, 60, 168, 162, 248, 129, 207, 117, 122, 136, 21, 213, 31, 241, 58, 111, 208, 17, 99, 123, 36, 255, 200, 46, 26, 227, 173, 176, 133, 64, 25, 70, 196, 189, 118, 22, 113, 8, 228, 73, 153, 120, 79, 67, 239, 1, 157, 234, 244, 15, 42, 169, 62, 225, 116, 222, 159, 34, 198, 246, 72, 253, 143, 92, 52, 197, 89, 95, 9, 128, 50, 140, 135, 121, 236, 44, 226, 16, 199, 146, 49, 240, 158, 134, 221, 2, 57, 211, 231, 30, 84, 81, 124, 193, 232, 187, 61, 68, 139, 235, 144, 249, 29, 184, 104, 137, 178, 190, 18, 256, 100, 23, 13, 242, 215, 88, 195, 32, 141, 35, 98, 223, 59, 11, 185, 4, 114, 165, 205, 60, 168, 162, 248, 129, 207, 117, 122, 136, 21, 213, 31, 241, 58, 111, 208, 17, 99, 123, 36, 255, 200, 46, 26, 227, 173, 176, 133, 64, 25, 70, 196, 189, 118, 22, 113, 8, 228, 73, 153, 120, 79, 67, 239, 1],
+[1, 158, 35, 133, 197, 29, 213, 244, 2, 59, 70, 9, 137, 58, 169, 231, 4, 118, 140, 18, 17, 116, 81, 205, 8, 236, 23, 36, 34, 232, 162, 153, 16, 215, 46, 72, 68, 207, 67, 49, 32, 173, 92, 144, 136, 157, 134, 98, 64, 89, 184, 31, 15, 57, 11, 196, 128, 178, 111, 62, 30, 114, 22, 135, 256, 99, 222, 124, 60, 228, 44, 13, 255, 198, 187, 248, 120, 199, 88, 26, 253, 139, 117, 239, 240, 141, 176, 52, 249, 21, 234, 221, 223, 25, 95, 104, 241, 42, 211, 185, 189, 50, 190, 208, 225, 84, 165, 113, 121, 100, 123, 159, 193, 168, 73, 226, 242, 200, 246, 61, 129, 79, 146, 195, 227, 143, 235, 122, 1, 158, 35, 133, 197, 29, 213, 244, 2, 59, 70, 9, 137, 58, 169, 231, 4, 118, 140, 18, 17, 116, 81, 205, 8, 236, 23, 36, 34, 232, 162, 153, 16, 215, 46, 72, 68, 207, 67, 49, 32, 173, 92, 144, 136, 157, 134, 98, 64, 89, 184, 31, 15, 57, 11, 196, 128, 178, 111, 62, 30, 114, 22, 135, 256, 99, 222, 124, 60, 228, 44, 13, 255, 198, 187, 248, 120, 199, 88, 26, 253, 139, 117, 239, 240, 141, 176, 52, 249, 21, 234, 221, 223, 25, 95, 104, 241, 42, 211, 185, 189, 50, 190, 208, 225, 84, 165, 113, 121, 100, 123, 159, 193, 168, 73, 226, 242, 200, 246, 61, 129, 79, 146, 195, 227, 143, 235, 122, 1],
+[1, 159, 95, 199, 30, 144, 23, 59, 129, 208, 176, 228, 15, 72, 140, 158, 193, 104, 88, 114, 136, 36, 70, 79, 225, 52, 44, 57, 68, 18, 35, 168, 241, 26, 22, 157, 34, 9, 146, 84, 249, 13, 11, 207, 17, 133, 73, 42, 253, 135, 134, 232, 137, 195, 165, 21, 255, 196, 67, 116, 197, 226, 211, 139, 256, 98, 162, 58, 227, 113, 234, 198, 128, 49, 81, 29, 242, 185, 117, 99, 64, 153, 169, 143, 121, 221, 187, 178, 32, 205, 213, 200, 189, 239, 222, 89, 16, 231, 235, 100, 223, 248, 111, 173, 8, 244, 246, 50, 240, 124, 184, 215, 4, 122, 123, 25, 120, 62, 92, 236, 2, 61, 190, 141, 60, 31, 46, 118, 1, 159, 95, 199, 30, 144, 23, 59, 129, 208, 176, 228, 15, 72, 140, 158, 193, 104, 88, 114, 136, 36, 70, 79, 225, 52, 44, 57, 68, 18, 35, 168, 241, 26, 22, 157, 34, 9, 146, 84, 249, 13, 11, 207, 17, 133, 73, 42, 253, 135, 134, 232, 137, 195, 165, 21, 255, 196, 67, 116, 197, 226, 211, 139, 256, 98, 162, 58, 227, 113, 234, 198, 128, 49, 81, 29, 242, 185, 117, 99, 64, 153, 169, 143, 121, 221, 187, 178, 32, 205, 213, 200, 189, 239, 222, 89, 16, 231, 235, 100, 223, 248, 111, 173, 8, 244, 246, 50, 240, 124, 184, 215, 4, 122, 123, 25, 120, 62, 92, 236, 2, 61, 190, 141, 60, 31, 46, 118, 1],
+[1, 160, 157, 191, 234, 175, 244, 233, 15, 87, 42, 38, 169, 55, 62, 154, 225, 20, 116, 56, 222, 54, 159, 254, 34, 43, 198, 69, 246, 39, 72, 212, 253, 131, 143, 7, 92, 71, 52, 96, 197, 166, 89, 105, 95, 37, 9, 155, 128, 177, 50, 33, 140, 41, 135, 12, 121, 85, 236, 238, 44, 101, 226, 180, 16, 247, 199, 229, 146, 230, 49, 130, 240, 107, 158, 94, 134, 109, 221, 151, 2, 63, 57, 125, 211, 93, 231, 209, 30, 174, 84, 76, 81, 110, 124, 51, 193, 40, 232, 112, 187, 108, 61, 251, 68, 86, 139, 138, 235, 78, 144, 167, 249, 5, 29, 14, 184, 142, 104, 192, 137, 75, 178, 210, 190, 74, 18, 53, 256, 97, 100, 66, 23, 82, 13, 24, 242, 170, 215, 219, 88, 202, 195, 103, 32, 237, 141, 201, 35, 203, 98, 3, 223, 214, 59, 188, 11, 218, 185, 45, 4, 126, 114, 250, 165, 186, 205, 161, 60, 91, 168, 152, 162, 220, 248, 102, 129, 80, 207, 224, 117, 216, 122, 245, 136, 172, 21, 19, 213, 156, 31, 77, 241, 10, 58, 28, 111, 27, 208, 127, 17, 150, 99, 163, 123, 148, 36, 106, 255, 194, 200, 132, 46, 164, 26, 48, 227, 83, 173, 181, 176, 147, 133, 206, 64, 217, 25, 145, 70, 149, 196, 6, 189, 171, 118, 119, 22, 179, 113, 90, 8, 252, 228, 243, 73, 115, 153, 65, 120, 182, 79, 47, 67, 183, 239, 204, 1],
+[1, 161, 221, 115, 11, 229, 118, 237, 121, 206, 13, 37, 46, 210, 143, 150, 249, 254, 31, 108, 169, 224, 84, 160, 60, 151, 153, 218, 146, 119, 141, 85, 64, 24, 9, 164, 190, 7, 99, 5, 34, 77, 61, 55, 117, 76, 157, 91, 2, 65, 185, 230, 22, 201, 236, 217, 242, 155, 26, 74, 92, 163, 29, 43, 241, 251, 62, 216, 81, 191, 168, 63, 120, 45, 49, 179, 35, 238, 25, 170, 128, 48, 18, 71, 123, 14, 198, 10, 68, 154, 122, 110, 234, 152, 57, 182, 4, 130, 113, 203, 44, 145, 215, 177, 227, 53, 52, 148, 184, 69, 58, 86, 225, 245, 124, 175, 162, 125, 79, 126, 240, 90, 98, 101, 70, 219, 50, 83, 256, 96, 36, 142, 246, 28, 139, 20, 136, 51, 244, 220, 211, 47, 114, 107, 8, 3, 226, 149, 88, 33, 173, 97, 197, 106, 104, 39, 111, 138, 116, 172, 193, 233, 248, 93, 67, 250, 158, 252, 223, 180, 196, 202, 140, 181, 100, 166, 255, 192, 72, 27, 235, 56, 21, 40, 15, 102, 231, 183, 165, 94, 228, 214, 16, 6, 195, 41, 176, 66, 89, 194, 137, 212, 208, 78, 222, 19, 232, 87, 129, 209, 239, 186, 134, 243, 59, 247, 189, 103, 135, 147, 23, 105, 200, 75, 253, 127, 144, 54, 213, 112, 42, 80, 30, 204, 205, 109, 73, 188, 199, 171, 32, 12, 133, 82, 95, 132, 178, 131, 17, 167, 159, 156, 187, 38, 207, 174, 1],
+[1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1],
+[1, 163, 98, 40, 95, 65, 58, 202, 30, 7, 113, 172, 23, 151, 198, 149, 129, 210, 49, 20, 176, 161, 29, 101, 15, 132, 185, 86, 140, 204, 99, 203, 193, 105, 153, 10, 88, 209, 143, 179, 136, 66, 221, 43, 70, 102, 178, 230, 225, 181, 205, 5, 44, 233, 200, 218, 68, 33, 239, 150, 35, 51, 89, 115, 241, 219, 231, 131, 22, 245, 100, 109, 34, 145, 248, 75, 146, 154, 173, 186, 249, 238, 244, 194, 11, 251, 50, 183, 17, 201, 124, 166, 73, 77, 215, 93, 253, 119, 122, 97, 134, 254, 25, 220, 137, 229, 62, 83, 165, 167, 236, 175, 255, 188, 61, 177, 67, 127, 141, 110, 197, 243, 31, 170, 211, 212, 118, 216, 256, 94, 159, 217, 162, 192, 199, 55, 227, 250, 144, 85, 234, 106, 59, 108, 128, 47, 208, 237, 81, 96, 228, 156, 242, 125, 72, 171, 117, 53, 158, 54, 64, 152, 104, 247, 169, 48, 114, 78, 121, 191, 36, 214, 187, 155, 79, 27, 32, 76, 52, 252, 213, 24, 57, 39, 189, 224, 18, 107, 222, 206, 168, 142, 16, 38, 26, 126, 235, 12, 157, 148, 223, 112, 9, 182, 111, 103, 84, 71, 8, 19, 13, 63, 246, 6, 207, 74, 240, 56, 133, 91, 184, 180, 42, 164, 4, 138, 135, 160, 123, 3, 232, 37, 120, 28, 195, 174, 92, 90, 21, 82, 2, 69, 196, 80, 190, 130, 116, 147, 60, 14, 226, 87, 46, 45, 139, 41, 1],
+[1, 164, 168, 53, 211, 166, 239, 132, 60, 74, 57, 96, 67, 194, 205, 210, 2, 71, 79, 106, 165, 75, 221, 7, 120, 148, 114, 192, 134, 131, 153, 163, 4, 142, 158, 212, 73, 150, 185, 14, 240, 39, 228, 127, 11, 5, 49, 69, 8, 27, 59, 167, 146, 43, 113, 28, 223, 78, 199, 254, 22, 10, 98, 138, 16, 54, 118, 77, 35, 86, 226, 56, 189, 156, 141, 251, 44, 20, 196, 19, 32, 108, 236, 154, 70, 172, 195, 112, 121, 55, 25, 245, 88, 40, 135, 38, 64, 216, 215, 51, 140, 87, 133, 224, 242, 110, 50, 233, 176, 80, 13, 76, 128, 175, 173, 102, 23, 174, 9, 191, 227, 220, 100, 209, 95, 160, 26, 152, 256, 93, 89, 204, 46, 91, 18, 125, 197, 183, 200, 161, 190, 63, 52, 47, 255, 186, 178, 151, 92, 182, 36, 250, 137, 109, 143, 65, 123, 126, 104, 94, 253, 115, 99, 45, 184, 107, 72, 243, 17, 218, 29, 130, 246, 252, 208, 188, 249, 230, 198, 90, 111, 214, 144, 229, 34, 179, 58, 3, 235, 247, 159, 119, 241, 203, 139, 180, 222, 171, 31, 201, 68, 101, 116, 6, 213, 237, 61, 238, 225, 149, 21, 103, 187, 85, 62, 145, 136, 202, 232, 12, 169, 217, 122, 219, 193, 41, 42, 206, 117, 170, 124, 33, 15, 147, 207, 24, 81, 177, 244, 181, 129, 82, 84, 155, 234, 83, 248, 66, 30, 37, 157, 48, 162, 97, 231, 105, 1],
+[1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1],
+[1, 166, 57, 210, 165, 148, 153, 212, 240, 5, 59, 28, 22, 54, 226, 251, 32, 172, 25, 38, 140, 110, 13, 102, 227, 160, 89, 125, 190, 186, 36, 65, 253, 107, 29, 188, 111, 179, 159, 180, 68, 237, 21, 145, 169, 41, 124, 24, 129, 83, 157, 105, 211, 74, 205, 106, 120, 131, 158, 14, 11, 27, 113, 254, 16, 86, 141, 19, 70, 55, 135, 51, 242, 80, 173, 191, 95, 93, 18, 161, 255, 182, 143, 94, 184, 218, 208, 90, 34, 247, 139, 201, 213, 149, 62, 12, 193, 170, 207, 181, 234, 37, 231, 53, 60, 194, 79, 7, 134, 142, 185, 127, 8, 43, 199, 138, 35, 156, 196, 154, 121, 40, 215, 224, 176, 175, 9, 209, 256, 91, 200, 47, 92, 109, 104, 45, 17, 252, 198, 229, 235, 203, 31, 6, 225, 85, 232, 219, 117, 147, 244, 155, 30, 97, 168, 132, 67, 71, 221, 192, 4, 150, 228, 69, 146, 78, 98, 77, 189, 20, 236, 112, 88, 216, 133, 233, 128, 174, 100, 152, 46, 183, 52, 151, 137, 126, 99, 243, 246, 230, 144, 3, 241, 171, 116, 238, 187, 202, 122, 206, 15, 177, 84, 66, 162, 164, 239, 96, 2, 75, 114, 163, 73, 39, 49, 167, 223, 10, 118, 56, 44, 108, 195, 245, 64, 87, 50, 76, 23, 220, 26, 204, 197, 63, 178, 250, 123, 115, 72, 130, 249, 214, 58, 119, 222, 101, 61, 103, 136, 217, 42, 33, 81, 82, 248, 48, 1],
+[1, 167, 133, 109, 213, 105, 59, 87, 137, 6, 231, 27, 140, 250, 116, 97, 8, 51, 36, 101, 162, 69, 215, 182, 68, 48, 49, 216, 92, 201, 157, 5, 64, 151, 31, 37, 11, 38, 178, 171, 30, 127, 135, 186, 222, 66, 228, 40, 255, 180, 248, 39, 88, 47, 139, 83, 240, 245, 52, 203, 234, 14, 25, 63, 241, 155, 185, 55, 190, 119, 84, 150, 121, 161, 159, 82, 73, 112, 200, 247, 129, 212, 195, 183, 235, 181, 158, 172, 197, 3, 244, 142, 70, 125, 58, 177, 4, 154, 18, 179, 81, 163, 236, 91, 34, 24, 153, 108, 46, 229, 207, 131, 32, 204, 144, 147, 134, 19, 89, 214, 15, 192, 196, 93, 111, 33, 114, 20, 256, 90, 124, 148, 44, 152, 198, 170, 120, 251, 26, 230, 117, 7, 141, 160, 249, 206, 221, 156, 95, 188, 42, 75, 189, 209, 208, 41, 165, 56, 100, 252, 193, 106, 226, 220, 246, 219, 79, 86, 227, 130, 122, 71, 35, 191, 29, 217, 2, 77, 9, 218, 169, 210, 118, 174, 17, 12, 205, 54, 23, 243, 232, 194, 16, 102, 72, 202, 67, 138, 173, 107, 136, 96, 98, 175, 184, 145, 57, 10, 128, 45, 62, 74, 22, 76, 99, 85, 60, 254, 13, 115, 187, 132, 199, 80, 253, 103, 239, 78, 176, 94, 21, 166, 223, 233, 104, 149, 211, 28, 50, 126, 225, 53, 113, 110, 123, 238, 168, 43, 242, 65, 61, 164, 146, 224, 143, 237, 1],
+[1, 168, 211, 239, 60, 57, 67, 205, 2, 79, 165, 221, 120, 114, 134, 153, 4, 158, 73, 185, 240, 228, 11, 49, 8, 59, 146, 113, 223, 199, 22, 98, 16, 118, 35, 226, 189, 141, 44, 196, 32, 236, 70, 195, 121, 25, 88, 135, 64, 215, 140, 133, 242, 50, 176, 13, 128, 173, 23, 9, 227, 100, 95, 26, 256, 89, 46, 18, 197, 200, 190, 52, 255, 178, 92, 36, 137, 143, 123, 104, 253, 99, 184, 72, 17, 29, 246, 208, 249, 198, 111, 144, 34, 58, 235, 159, 241, 139, 222, 31, 68, 116, 213, 61, 225, 21, 187, 62, 136, 232, 169, 122, 193, 42, 117, 124, 15, 207, 81, 244, 129, 84, 234, 248, 30, 157, 162, 231, 1, 168, 211, 239, 60, 57, 67, 205, 2, 79, 165, 221, 120, 114, 134, 153, 4, 158, 73, 185, 240, 228, 11, 49, 8, 59, 146, 113, 223, 199, 22, 98, 16, 118, 35, 226, 189, 141, 44, 196, 32, 236, 70, 195, 121, 25, 88, 135, 64, 215, 140, 133, 242, 50, 176, 13, 128, 173, 23, 9, 227, 100, 95, 26, 256, 89, 46, 18, 197, 200, 190, 52, 255, 178, 92, 36, 137, 143, 123, 104, 253, 99, 184, 72, 17, 29, 246, 208, 249, 198, 111, 144, 34, 58, 235, 159, 241, 139, 222, 31, 68, 116, 213, 61, 225, 21, 187, 62, 136, 232, 169, 122, 193, 42, 117, 124, 15, 207, 81, 244, 129, 84, 234, 248, 30, 157, 162, 231, 1],
+[1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1],
+[1, 170, 116, 188, 92, 220, 135, 77, 240, 194, 84, 145, 235, 115, 18, 233, 32, 43, 114, 105, 117, 101, 208, 151, 227, 40, 118, 14, 67, 82, 62, 3, 253, 91, 50, 19, 146, 148, 231, 206, 68, 252, 178, 191, 88, 54, 185, 96, 129, 85, 58, 94, 46, 110, 196, 167, 120, 97, 42, 201, 246, 186, 9, 245, 16, 150, 57, 181, 187, 179, 104, 204, 242, 20, 59, 7, 162, 41, 31, 130, 255, 174, 25, 138, 73, 74, 244, 103, 34, 126, 89, 224, 44, 27, 221, 48, 193, 171, 29, 47, 23, 55, 98, 212, 60, 177, 21, 229, 123, 93, 133, 251, 8, 75, 157, 219, 222, 218, 52, 102, 121, 10, 158, 132, 81, 149, 144, 65, 256, 87, 141, 69, 165, 37, 122, 180, 17, 63, 173, 112, 22, 142, 239, 24, 225, 214, 143, 152, 140, 156, 49, 106, 30, 217, 139, 243, 190, 175, 195, 254, 4, 166, 207, 238, 111, 109, 26, 51, 189, 5, 79, 66, 169, 203, 72, 161, 128, 172, 199, 163, 211, 147, 61, 90, 137, 160, 215, 56, 11, 71, 248, 12, 241, 107, 200, 76, 70, 78, 153, 53, 15, 237, 198, 250, 95, 216, 226, 127, 2, 83, 232, 119, 184, 183, 13, 154, 223, 131, 168, 33, 213, 230, 36, 209, 64, 86, 228, 210, 234, 202, 159, 45, 197, 80, 236, 28, 134, 164, 124, 6, 249, 182, 100, 38, 35, 39, 205, 155, 136, 247, 99, 125, 176, 108, 113, 192, 1],
+[1, 171, 200, 19, 165, 202, 104, 51, 240, 177, 198, 191, 22, 164, 31, 161, 32, 75, 232, 94, 140, 39, 244, 90, 227, 10, 168, 201, 190, 108, 221, 12, 253, 87, 228, 181, 111, 220, 98, 53, 68, 63, 236, 7, 169, 115, 133, 127, 129, 214, 100, 138, 211, 101, 52, 154, 120, 217, 99, 224, 11, 82, 144, 209, 16, 166, 116, 47, 70, 148, 122, 45, 242, 5, 84, 229, 95, 54, 239, 6, 255, 172, 114, 219, 184, 110, 49, 155, 34, 160, 118, 132, 213, 186, 195, 192, 193, 107, 50, 69, 234, 179, 26, 77, 60, 237, 178, 112, 134, 41, 72, 233, 8, 83, 58, 152, 35, 74, 61, 151, 121, 131, 42, 243, 176, 27, 248, 3, 256, 86, 57, 238, 92, 55, 153, 206, 17, 80, 59, 66, 235, 93, 226, 96, 225, 182, 25, 163, 117, 218, 13, 167, 30, 247, 89, 56, 67, 149, 36, 245, 4, 170, 29, 76, 146, 37, 159, 204, 189, 194, 21, 250, 88, 142, 124, 130, 128, 43, 157, 119, 46, 156, 205, 103, 137, 40, 158, 33, 246, 175, 113, 48, 241, 91, 141, 210, 187, 109, 135, 212, 15, 252, 173, 28, 162, 203, 18, 251, 2, 85, 143, 38, 73, 147, 208, 102, 223, 97, 139, 125, 44, 71, 62, 65, 64, 150, 207, 188, 23, 78, 231, 180, 197, 20, 79, 145, 123, 216, 185, 24, 249, 174, 199, 105, 222, 183, 196, 106, 136, 126, 215, 14, 81, 230, 9, 254, 1],
+[1, 172, 29, 105, 70, 218, 231, 154, 17, 97, 236, 243, 162, 108, 72, 48, 32, 107, 157, 19, 184, 37, 196, 45, 30, 20, 99, 66, 44, 115, 248, 251, 253, 83, 141, 94, 234, 156, 104, 155, 189, 126, 84, 56, 123, 82, 226, 65, 129, 86, 143, 181, 35, 109, 244, 77, 137, 177, 118, 250, 81, 54, 36, 24, 16, 182, 207, 138, 92, 147, 98, 151, 15, 10, 178, 33, 22, 186, 124, 254, 255, 170, 199, 47, 117, 78, 52, 206, 223, 63, 42, 28, 190, 41, 113, 161, 193, 43, 200, 219, 146, 183, 122, 167, 197, 217, 59, 125, 169, 27, 18, 12, 8, 91, 232, 69, 46, 202, 49, 204, 136, 5, 89, 145, 11, 93, 62, 127, 256, 85, 228, 152, 187, 39, 26, 103, 240, 160, 21, 14, 95, 149, 185, 209, 225, 150, 100, 238, 73, 220, 61, 212, 227, 237, 158, 191, 213, 142, 9, 6, 4, 174, 116, 163, 23, 101, 153, 102, 68, 131, 173, 201, 134, 175, 31, 192, 128, 171, 114, 76, 222, 148, 13, 180, 120, 80, 139, 7, 176, 203, 221, 233, 241, 75, 50, 119, 165, 110, 159, 106, 242, 247, 79, 224, 235, 71, 133, 3, 2, 87, 58, 210, 140, 179, 205, 51, 34, 194, 215, 229, 67, 216, 144, 96, 64, 214, 57, 38, 111, 74, 135, 90, 60, 40, 198, 132, 88, 230, 239, 245, 249, 166, 25, 188, 211, 55, 208, 53, 121, 252, 168, 112, 246, 164, 195, 130, 1],
+[1, 173, 117, 195, 68, 199, 246, 153, 255, 168, 23, 124, 121, 116, 22, 208, 4, 178, 211, 9, 15, 25, 213, 98, 249, 158, 92, 239, 227, 207, 88, 61, 16, 198, 73, 36, 60, 100, 81, 135, 225, 118, 111, 185, 137, 57, 95, 244, 64, 21, 35, 144, 240, 143, 67, 26, 129, 215, 187, 226, 34, 228, 123, 205, 256, 84, 140, 62, 189, 58, 11, 104, 2, 89, 234, 133, 136, 141, 235, 49, 253, 79, 46, 248, 242, 232, 44, 159, 8, 99, 165, 18, 30, 50, 169, 196, 241, 59, 184, 221, 197, 157, 176, 122, 32, 139, 146, 72, 120, 200, 162, 13, 193, 236, 222, 113, 17, 114, 190, 231, 128, 42, 70, 31, 223, 29, 134, 52, 1, 173, 117, 195, 68, 199, 246, 153, 255, 168, 23, 124, 121, 116, 22, 208, 4, 178, 211, 9, 15, 25, 213, 98, 249, 158, 92, 239, 227, 207, 88, 61, 16, 198, 73, 36, 60, 100, 81, 135, 225, 118, 111, 185, 137, 57, 95, 244, 64, 21, 35, 144, 240, 143, 67, 26, 129, 215, 187, 226, 34, 228, 123, 205, 256, 84, 140, 62, 189, 58, 11, 104, 2, 89, 234, 133, 136, 141, 235, 49, 253, 79, 46, 248, 242, 232, 44, 159, 8, 99, 165, 18, 30, 50, 169, 196, 241, 59, 184, 221, 197, 157, 176, 122, 32, 139, 146, 72, 120, 200, 162, 13, 193, 236, 222, 113, 17, 114, 190, 231, 128, 42, 70, 31, 223, 29, 134, 52, 1],
+[1, 174, 207, 38, 187, 156, 159, 167, 17, 131, 178, 132, 95, 82, 133, 12, 32, 171, 199, 188, 73, 109, 205, 204, 30, 80, 42, 112, 213, 54, 144, 127, 253, 75, 200, 105, 23, 147, 135, 103, 189, 247, 59, 243, 134, 186, 239, 209, 129, 87, 232, 19, 222, 78, 208, 212, 137, 194, 89, 66, 176, 41, 195, 6, 16, 214, 228, 94, 165, 183, 231, 102, 15, 40, 21, 56, 235, 27, 72, 192, 255, 166, 100, 181, 140, 202, 196, 180, 223, 252, 158, 250, 67, 93, 248, 233, 193, 172, 116, 138, 111, 39, 104, 106, 197, 97, 173, 33, 88, 149, 226, 3, 8, 107, 114, 47, 211, 220, 244, 51, 136, 20, 139, 28, 246, 142, 36, 96, 256, 83, 50, 219, 70, 101, 98, 90, 240, 126, 79, 125, 162, 175, 124, 245, 225, 86, 58, 69, 184, 148, 52, 53, 227, 177, 215, 145, 44, 203, 113, 130, 4, 182, 57, 152, 234, 110, 122, 154, 68, 10, 198, 14, 123, 71, 18, 48, 128, 170, 25, 238, 35, 179, 49, 45, 120, 63, 168, 191, 81, 216, 62, 251, 241, 43, 29, 163, 92, 74, 26, 155, 242, 217, 236, 201, 22, 230, 185, 65, 2, 91, 157, 76, 117, 55, 61, 77, 34, 5, 99, 7, 190, 164, 9, 24, 64, 85, 141, 119, 146, 218, 153, 151, 60, 160, 84, 224, 169, 108, 31, 254, 249, 150, 143, 210, 46, 37, 13, 206, 121, 237, 118, 229, 11, 115, 221, 161, 1],
+[1, 175, 42, 154, 222, 43, 72, 7, 197, 37, 50, 12, 44, 247, 49, 94, 2, 93, 84, 51, 187, 86, 144, 14, 137, 74, 100, 24, 88, 237, 98, 188, 4, 186, 168, 102, 117, 172, 31, 28, 17, 148, 200, 48, 176, 217, 196, 119, 8, 115, 79, 204, 234, 87, 62, 56, 34, 39, 143, 96, 95, 177, 135, 238, 16, 230, 158, 151, 211, 174, 124, 112, 68, 78, 29, 192, 190, 97, 13, 219, 32, 203, 59, 45, 165, 91, 248, 224, 136, 156, 58, 127, 123, 194, 26, 181, 64, 149, 118, 90, 73, 182, 239, 191, 15, 55, 116, 254, 246, 131, 52, 105, 128, 41, 236, 180, 146, 107, 221, 125, 30, 110, 232, 251, 235, 5, 104, 210, 256, 82, 215, 103, 35, 214, 185, 250, 60, 220, 207, 245, 213, 10, 208, 163, 255, 164, 173, 206, 70, 171, 113, 243, 120, 183, 157, 233, 169, 20, 159, 69, 253, 71, 89, 155, 140, 85, 226, 229, 240, 109, 57, 209, 81, 40, 61, 138, 249, 142, 178, 53, 23, 170, 195, 201, 223, 218, 114, 161, 162, 80, 122, 19, 241, 27, 99, 106, 46, 83, 133, 145, 189, 179, 228, 65, 67, 160, 244, 38, 225, 54, 198, 212, 92, 166, 9, 33, 121, 101, 199, 130, 134, 63, 231, 76, 193, 108, 139, 167, 184, 75, 18, 66, 242, 202, 141, 3, 11, 126, 205, 152, 129, 216, 21, 77, 111, 150, 36, 132, 227, 147, 25, 6, 22, 252, 153, 47, 1],
+[1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1],
+[1, 177, 232, 201, 111, 115, 52, 209, 242, 172, 118, 69, 134, 74, 248, 206, 225, 247, 29, 250, 46, 175, 135, 251, 223, 150, 79, 105, 81, 202, 31, 90, 253, 63, 100, 224, 70, 54, 49, 192, 60, 83, 42, 238, 235, 218, 36, 204, 128, 40, 141, 28, 73, 71, 231, 24, 136, 171, 198, 94, 190, 220, 133, 154, 16, 5, 114, 132, 234, 41, 61, 3, 17, 182, 89, 76, 88, 156, 113, 212, 2, 97, 207, 145, 222, 230, 104, 161, 227, 87, 236, 138, 11, 148, 239, 155, 193, 237, 58, 243, 92, 93, 13, 245, 189, 43, 158, 210, 162, 147, 62, 180, 249, 126, 200, 191, 140, 108, 98, 127, 120, 166, 84, 219, 213, 179, 72, 151, 256, 80, 25, 56, 146, 142, 205, 48, 15, 85, 139, 188, 123, 183, 9, 51, 32, 10, 228, 7, 211, 82, 122, 6, 34, 107, 178, 152, 176, 55, 226, 167, 4, 194, 157, 33, 187, 203, 208, 65, 197, 174, 215, 19, 22, 39, 221, 53, 129, 217, 116, 229, 184, 186, 26, 233, 121, 86, 59, 163, 67, 37, 124, 103, 241, 252, 143, 125, 23, 216, 196, 254, 240, 75, 168, 181, 169, 101, 144, 45, 255, 160, 50, 112, 35, 27, 153, 96, 30, 170, 21, 119, 246, 109, 18, 102, 64, 20, 199, 14, 165, 164, 244, 12, 68, 214, 99, 47, 95, 110, 195, 77, 8, 131, 57, 66, 117, 149, 159, 130, 137, 91, 173, 38, 44, 78, 185, 106, 1],
+[1, 178, 73, 144, 189, 232, 176, 231, 255, 158, 111, 226, 136, 50, 162, 52, 4, 198, 35, 62, 242, 157, 190, 153, 249, 118, 187, 133, 30, 200, 134, 208, 16, 21, 140, 248, 197, 114, 246, 98, 225, 215, 234, 18, 120, 29, 22, 61, 64, 84, 46, 221, 17, 199, 213, 135, 129, 89, 165, 72, 223, 116, 88, 244, 256, 79, 184, 113, 68, 25, 81, 26, 2, 99, 146, 31, 121, 207, 95, 205, 253, 59, 222, 195, 15, 100, 67, 104, 8, 139, 70, 124, 227, 57, 123, 49, 241, 236, 117, 9, 60, 143, 11, 159, 32, 42, 23, 239, 137, 228, 235, 196, 193, 173, 211, 36, 240, 58, 44, 122, 128, 168, 92, 185, 34, 141, 169, 13, 1, 178, 73, 144, 189, 232, 176, 231, 255, 158, 111, 226, 136, 50, 162, 52, 4, 198, 35, 62, 242, 157, 190, 153, 249, 118, 187, 133, 30, 200, 134, 208, 16, 21, 140, 248, 197, 114, 246, 98, 225, 215, 234, 18, 120, 29, 22, 61, 64, 84, 46, 221, 17, 199, 213, 135, 129, 89, 165, 72, 223, 116, 88, 244, 256, 79, 184, 113, 68, 25, 81, 26, 2, 99, 146, 31, 121, 207, 95, 205, 253, 59, 222, 195, 15, 100, 67, 104, 8, 139, 70, 124, 227, 57, 123, 49, 241, 236, 117, 9, 60, 143, 11, 159, 32, 42, 23, 239, 137, 228, 235, 196, 193, 173, 211, 36, 240, 58, 44, 122, 128, 168, 92, 185, 34, 141, 169, 13, 1],
+[1, 179, 173, 127, 117, 126, 195, 210, 68, 93, 199, 155, 246, 87, 153, 145, 255, 156, 168, 3, 23, 5, 124, 94, 121, 71, 116, 204, 22, 83, 208, 224, 4, 202, 178, 251, 211, 247, 9, 69, 15, 115, 25, 106, 213, 91, 98, 66, 249, 110, 158, 12, 92, 20, 239, 119, 227, 27, 207, 45, 88, 75, 61, 125, 16, 37, 198, 233, 73, 217, 36, 19, 60, 203, 100, 167, 81, 107, 135, 7, 225, 183, 118, 48, 111, 80, 185, 219, 137, 108, 57, 180, 95, 43, 244, 243, 64, 148, 21, 161, 35, 97, 144, 76, 240, 41, 143, 154, 67, 171, 26, 28, 129, 218, 215, 192, 187, 63, 226, 105, 34, 175, 228, 206, 123, 172, 205, 201, 256, 78, 84, 130, 140, 131, 62, 47, 189, 164, 58, 102, 11, 170, 104, 112, 2, 101, 89, 254, 234, 252, 133, 163, 136, 186, 141, 53, 235, 174, 49, 33, 253, 55, 79, 6, 46, 10, 248, 188, 242, 142, 232, 151, 44, 166, 159, 191, 8, 147, 99, 245, 165, 237, 18, 138, 30, 230, 50, 212, 169, 182, 196, 132, 241, 220, 59, 24, 184, 40, 221, 238, 197, 54, 157, 90, 176, 150, 122, 250, 32, 74, 139, 209, 146, 177, 72, 38, 120, 149, 200, 77, 162, 214, 13, 14, 193, 109, 236, 96, 222, 160, 113, 181, 17, 216, 114, 103, 190, 86, 231, 229, 128, 39, 42, 65, 70, 194, 31, 152, 223, 82, 29, 51, 134, 85, 52, 56, 1],
+[1, 180, 18, 156, 67, 238, 178, 172, 120, 12, 104, 216, 73, 33, 29, 80, 8, 155, 144, 220, 22, 105, 139, 91, 189, 96, 61, 186, 70, 7, 232, 126, 64, 212, 124, 218, 176, 69, 84, 214, 227, 254, 231, 203, 46, 56, 57, 237, 255, 154, 221, 202, 123, 38, 158, 170, 17, 233, 49, 82, 111, 191, 199, 97, 241, 204, 226, 74, 213, 47, 236, 75, 136, 65, 135, 142, 117, 243, 50, 5, 129, 90, 9, 78, 162, 119, 89, 86, 60, 6, 52, 108, 165, 145, 143, 40, 4, 206, 72, 110, 11, 181, 198, 174, 223, 48, 159, 93, 35, 132, 116, 63, 32, 106, 62, 109, 88, 163, 42, 107, 242, 127, 244, 230, 23, 28, 157, 247, 256, 77, 239, 101, 190, 19, 79, 85, 137, 245, 153, 41, 184, 224, 228, 177, 249, 102, 113, 37, 235, 152, 118, 166, 68, 161, 196, 71, 187, 250, 25, 131, 193, 45, 133, 39, 81, 188, 173, 43, 30, 3, 26, 54, 211, 201, 200, 20, 2, 103, 36, 55, 134, 219, 99, 87, 240, 24, 208, 175, 146, 66, 58, 160, 16, 53, 31, 183, 44, 210, 21, 182, 121, 192, 122, 115, 140, 14, 207, 252, 128, 167, 248, 179, 95, 138, 168, 171, 197, 251, 205, 149, 92, 112, 114, 217, 253, 51, 185, 147, 246, 76, 59, 83, 34, 209, 98, 164, 222, 125, 141, 194, 225, 151, 195, 148, 169, 94, 215, 150, 15, 130, 13, 27, 234, 229, 100, 10, 1],
+[1, 181, 122, 237, 235, 130, 143, 183, 227, 224, 195, 86, 146, 212, 79, 164, 129, 219, 61, 247, 246, 65, 200, 220, 242, 112, 226, 43, 73, 106, 168, 82, 193, 238, 159, 252, 123, 161, 100, 110, 121, 56, 113, 150, 165, 53, 84, 41, 225, 119, 208, 126, 190, 209, 50, 55, 189, 28, 185, 75, 211, 155, 42, 149, 241, 188, 104, 63, 95, 233, 25, 156, 223, 14, 221, 166, 234, 206, 21, 203, 249, 94, 52, 160, 176, 245, 141, 78, 240, 7, 239, 83, 117, 103, 139, 230, 253, 47, 26, 80, 88, 251, 199, 39, 120, 132, 248, 170, 187, 180, 198, 115, 255, 152, 13, 40, 44, 254, 228, 148, 60, 66, 124, 85, 222, 90, 99, 186, 256, 76, 135, 20, 22, 127, 114, 74, 30, 33, 62, 171, 111, 45, 178, 93, 128, 38, 196, 10, 11, 192, 57, 37, 15, 145, 31, 214, 184, 151, 89, 175, 64, 19, 98, 5, 134, 96, 157, 147, 136, 201, 144, 107, 92, 204, 173, 216, 32, 138, 49, 131, 67, 48, 207, 202, 68, 229, 72, 182, 46, 102, 215, 108, 16, 69, 153, 194, 162, 24, 232, 101, 34, 243, 36, 91, 23, 51, 236, 54, 8, 163, 205, 97, 81, 12, 116, 179, 17, 250, 18, 174, 140, 154, 118, 27, 4, 210, 231, 177, 169, 6, 58, 218, 137, 125, 9, 87, 70, 77, 59, 142, 2, 105, 244, 217, 213, 3, 29, 109, 197, 191, 133, 172, 35, 167, 158, 71, 1],
+[1, 182, 228, 119, 70, 147, 26, 106, 17, 10, 21, 224, 162, 186, 185, 3, 32, 170, 100, 210, 184, 78, 61, 51, 30, 63, 158, 229, 44, 41, 9, 96, 253, 43, 116, 38, 234, 183, 153, 90, 189, 217, 173, 132, 123, 27, 31, 245, 129, 91, 114, 188, 35, 202, 13, 53, 137, 5, 139, 112, 81, 93, 221, 130, 16, 85, 50, 105, 92, 39, 159, 154, 15, 160, 79, 243, 22, 149, 133, 48, 255, 150, 58, 19, 117, 220, 205, 45, 223, 237, 215, 66, 190, 142, 144, 251, 193, 174, 57, 94, 146, 101, 135, 155, 197, 131, 198, 56, 169, 175, 239, 65, 8, 171, 25, 181, 46, 148, 208, 77, 136, 80, 168, 250, 11, 203, 195, 24, 256, 75, 29, 138, 187, 110, 231, 151, 240, 247, 236, 33, 95, 71, 72, 254, 225, 87, 157, 47, 73, 179, 196, 206, 227, 194, 99, 28, 213, 216, 248, 161, 4, 214, 141, 219, 23, 74, 104, 167, 68, 40, 84, 125, 134, 230, 226, 12, 128, 166, 143, 69, 222, 55, 244, 204, 120, 252, 118, 145, 176, 164, 36, 127, 241, 172, 207, 152, 165, 218, 98, 103, 242, 97, 178, 14, 235, 108, 124, 209, 2, 107, 199, 238, 140, 37, 52, 212, 34, 20, 42, 191, 67, 115, 113, 6, 64, 83, 200, 163, 111, 156, 122, 102, 60, 126, 59, 201, 88, 82, 18, 192, 249, 86, 232, 76, 211, 109, 49, 180, 121, 177, 89, 7, 246, 54, 62, 233, 1],
+[1, 183, 79, 65, 73, 252, 113, 119, 189, 149, 25, 206, 176, 83, 26, 132, 255, 148, 99, 127, 111, 10, 31, 19, 136, 216, 207, 102, 162, 91, 205, 250, 4, 218, 59, 3, 35, 237, 195, 219, 242, 82, 100, 53, 190, 75, 104, 14, 249, 78, 139, 251, 187, 40, 124, 76, 30, 93, 57, 151, 134, 107, 49, 229, 16, 101, 236, 12, 140, 177, 9, 105, 197, 71, 143, 212, 246, 43, 159, 56, 225, 55, 42, 233, 234, 160, 239, 47, 120, 115, 228, 90, 22, 171, 196, 145, 64, 147, 173, 48, 46, 194, 36, 163, 17, 27, 58, 77, 213, 172, 122, 224, 129, 220, 168, 161, 165, 126, 185, 188, 223, 203, 141, 103, 88, 170, 13, 66, 256, 74, 178, 192, 184, 5, 144, 138, 68, 108, 232, 51, 81, 174, 231, 125, 2, 109, 158, 130, 146, 247, 226, 238, 121, 41, 50, 155, 95, 166, 52, 7, 253, 39, 198, 254, 222, 20, 62, 38, 15, 175, 157, 204, 67, 182, 153, 243, 8, 179, 118, 6, 70, 217, 133, 181, 227, 164, 200, 106, 123, 150, 208, 28, 241, 156, 21, 245, 117, 80, 248, 152, 60, 186, 114, 45, 11, 214, 98, 201, 32, 202, 215, 24, 23, 97, 18, 210, 137, 142, 29, 167, 235, 86, 61, 112, 193, 110, 84, 209, 211, 63, 221, 94, 240, 230, 199, 180, 44, 85, 135, 33, 128, 37, 89, 96, 92, 131, 72, 69, 34, 54, 116, 154, 169, 87, 244, 191, 1],
+[1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1],
+[1, 185, 44, 173, 137, 159, 117, 57, 8, 195, 95, 99, 68, 244, 165, 199, 64, 18, 246, 21, 30, 153, 35, 50, 255, 144, 169, 168, 240, 196, 23, 143, 241, 124, 67, 59, 121, 26, 184, 116, 129, 221, 22, 215, 197, 208, 187, 157, 4, 226, 176, 178, 34, 122, 211, 228, 32, 9, 123, 139, 15, 205, 146, 25, 256, 72, 213, 84, 120, 98, 140, 200, 249, 62, 162, 158, 189, 13, 92, 58, 193, 239, 11, 236, 227, 104, 222, 207, 2, 113, 88, 89, 17, 61, 234, 114, 16, 133, 190, 198, 136, 231, 73, 141, 128, 36, 235, 42, 60, 49, 70, 100, 253, 31, 81, 79, 223, 135, 46, 29, 225, 248, 134, 118, 242, 52, 111, 232, 1, 185, 44, 173, 137, 159, 117, 57, 8, 195, 95, 99, 68, 244, 165, 199, 64, 18, 246, 21, 30, 153, 35, 50, 255, 144, 169, 168, 240, 196, 23, 143, 241, 124, 67, 59, 121, 26, 184, 116, 129, 221, 22, 215, 197, 208, 187, 157, 4, 226, 176, 178, 34, 122, 211, 228, 32, 9, 123, 139, 15, 205, 146, 25, 256, 72, 213, 84, 120, 98, 140, 200, 249, 62, 162, 158, 189, 13, 92, 58, 193, 239, 11, 236, 227, 104, 222, 207, 2, 113, 88, 89, 17, 61, 234, 114, 16, 133, 190, 198, 136, 231, 73, 141, 128, 36, 235, 42, 60, 49, 70, 100, 253, 31, 81, 79, 223, 135, 46, 29, 225, 248, 134, 118, 242, 52, 111, 232, 1],
+[1, 186, 158, 90, 35, 85, 133, 66, 197, 148, 29, 254, 213, 40, 244, 152, 2, 115, 59, 180, 70, 170, 9, 132, 137, 39, 58, 251, 169, 80, 231, 47, 4, 230, 118, 103, 140, 83, 18, 7, 17, 78, 116, 245, 81, 160, 205, 94, 8, 203, 236, 206, 23, 166, 36, 14, 34, 156, 232, 233, 162, 63, 153, 188, 16, 149, 215, 155, 46, 75, 72, 28, 68, 55, 207, 209, 67, 126, 49, 119, 32, 41, 173, 53, 92, 150, 144, 56, 136, 110, 157, 161, 134, 252, 98, 238, 64, 82, 89, 106, 184, 43, 31, 112, 15, 220, 57, 65, 11, 247, 196, 219, 128, 164, 178, 212, 111, 86, 62, 224, 30, 183, 114, 130, 22, 237, 135, 181, 256, 71, 99, 167, 222, 172, 124, 191, 60, 109, 228, 3, 44, 217, 13, 105, 255, 142, 198, 77, 187, 87, 248, 125, 120, 218, 199, 6, 88, 177, 26, 210, 253, 27, 139, 154, 117, 174, 239, 250, 240, 179, 141, 12, 176, 97, 52, 163, 249, 54, 21, 51, 234, 91, 221, 243, 223, 101, 25, 24, 95, 194, 104, 69, 241, 108, 42, 102, 211, 182, 185, 229, 189, 202, 50, 48, 190, 131, 208, 138, 225, 216, 84, 204, 165, 107, 113, 201, 121, 147, 100, 96, 123, 5, 159, 19, 193, 175, 168, 151, 73, 214, 226, 145, 242, 37, 200, 192, 246, 10, 61, 38, 129, 93, 79, 45, 146, 171, 195, 33, 227, 74, 143, 127, 235, 20, 122, 76, 1],
+[1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1],
+[1, 188, 135, 194, 235, 233, 114, 101, 227, 14, 62, 91, 146, 206, 178, 54, 129, 94, 196, 97, 246, 245, 57, 179, 242, 7, 31, 174, 73, 103, 89, 27, 193, 47, 98, 177, 123, 251, 157, 218, 121, 132, 144, 87, 165, 180, 173, 142, 225, 152, 49, 217, 190, 254, 207, 109, 189, 66, 72, 172, 211, 90, 215, 71, 241, 76, 153, 237, 95, 127, 232, 183, 223, 33, 36, 86, 234, 45, 236, 164, 249, 38, 205, 247, 176, 192, 116, 220, 240, 145, 18, 43, 117, 151, 118, 82, 253, 19, 231, 252, 88, 96, 58, 110, 120, 201, 9, 150, 187, 204, 59, 41, 255, 138, 244, 126, 44, 48, 29, 55, 60, 229, 133, 75, 222, 102, 158, 149, 256, 69, 122, 63, 22, 24, 143, 156, 30, 243, 195, 166, 111, 51, 79, 203, 128, 163, 61, 160, 11, 12, 200, 78, 15, 250, 226, 83, 184, 154, 168, 230, 64, 210, 159, 80, 134, 6, 100, 39, 136, 125, 113, 170, 92, 77, 84, 115, 32, 105, 208, 40, 67, 3, 50, 148, 68, 191, 185, 85, 46, 167, 42, 186, 16, 181, 104, 20, 162, 130, 25, 74, 34, 224, 221, 171, 23, 212, 21, 93, 8, 219, 52, 10, 81, 65, 141, 37, 17, 112, 239, 214, 140, 106, 139, 175, 4, 238, 26, 5, 169, 161, 199, 147, 137, 56, 248, 107, 70, 53, 198, 216, 2, 119, 13, 131, 213, 209, 228, 202, 197, 28, 124, 182, 35, 155, 99, 108, 1],
+[1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1],
+[1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1],
+[1, 191, 244, 87, 169, 154, 116, 54, 34, 69, 72, 131, 92, 96, 89, 37, 128, 33, 135, 85, 44, 180, 199, 230, 240, 94, 221, 63, 211, 209, 84, 110, 193, 112, 61, 86, 235, 167, 29, 142, 137, 210, 18, 97, 23, 24, 215, 202, 32, 201, 98, 214, 11, 45, 114, 186, 60, 152, 248, 80, 117, 245, 21, 156, 241, 28, 208, 150, 123, 106, 200, 164, 227, 181, 133, 217, 70, 6, 118, 179, 8, 243, 153, 182, 67, 204, 157, 175, 15, 38, 62, 20, 222, 254, 198, 39, 253, 7, 52, 166, 95, 155, 50, 41, 121, 238, 226, 247, 146, 130, 158, 109, 2, 125, 231, 174, 81, 51, 232, 108, 68, 138, 144, 5, 184, 192, 178, 74, 256, 66, 13, 170, 88, 103, 141, 203, 223, 188, 185, 126, 165, 161, 168, 220, 129, 224, 122, 172, 213, 77, 58, 27, 17, 163, 36, 194, 46, 48, 173, 147, 64, 145, 196, 171, 22, 90, 228, 115, 120, 47, 239, 160, 234, 233, 42, 55, 225, 56, 159, 43, 246, 212, 143, 71, 197, 105, 9, 177, 140, 12, 236, 101, 16, 229, 49, 107, 134, 151, 57, 93, 30, 76, 124, 40, 187, 251, 139, 78, 249, 14, 104, 75, 190, 53, 100, 82, 242, 219, 195, 237, 35, 3, 59, 218, 4, 250, 205, 91, 162, 102, 207, 216, 136, 19, 31, 10, 111, 127, 99, 148, 255, 132, 26, 83, 176, 206, 25, 149, 189, 119, 113, 252, 73, 65, 79, 183, 1],
+[1, 192, 113, 108, 176, 125, 99, 247, 136, 155, 205, 39, 35, 38, 100, 182, 249, 6, 124, 164, 134, 28, 236, 80, 197, 45, 159, 202, 234, 210, 228, 86, 64, 209, 36, 230, 213, 33, 168, 131, 223, 154, 13, 183, 184, 119, 232, 83, 2, 127, 226, 216, 95, 250, 198, 237, 15, 53, 153, 78, 70, 76, 200, 107, 241, 12, 248, 71, 11, 56, 215, 160, 137, 90, 61, 147, 211, 163, 199, 172, 128, 161, 72, 203, 169, 66, 79, 5, 189, 51, 26, 109, 111, 238, 207, 166, 4, 254, 195, 175, 190, 243, 139, 217, 30, 106, 49, 156, 140, 152, 143, 214, 225, 24, 239, 142, 22, 112, 173, 63, 17, 180, 122, 37, 165, 69, 141, 87, 256, 65, 144, 149, 81, 132, 158, 10, 121, 102, 52, 218, 222, 219, 157, 75, 8, 251, 133, 93, 123, 229, 21, 177, 60, 212, 98, 55, 23, 47, 29, 171, 193, 48, 221, 27, 44, 224, 89, 126, 34, 103, 244, 74, 73, 138, 25, 174, 255, 130, 31, 41, 162, 7, 59, 20, 242, 204, 104, 179, 187, 181, 57, 150, 16, 245, 9, 186, 246, 201, 42, 97, 120, 167, 196, 110, 46, 94, 58, 85, 129, 96, 185, 54, 88, 191, 178, 252, 68, 206, 231, 148, 146, 19, 50, 91, 253, 3, 62, 82, 67, 14, 118, 40, 227, 151, 208, 101, 117, 105, 114, 43, 32, 233, 18, 115, 235, 145, 84, 194, 240, 77, 135, 220, 92, 188, 116, 170, 1],
+[1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1],
+[1, 194, 114, 14, 146, 54, 196, 245, 242, 174, 89, 47, 123, 218, 144, 180, 225, 217, 207, 66, 211, 71, 153, 127, 223, 86, 236, 38, 176, 220, 18, 151, 253, 252, 58, 201, 187, 41, 244, 48, 60, 75, 158, 69, 22, 156, 195, 51, 128, 160, 200, 250, 184, 230, 159, 6, 136, 170, 84, 105, 67, 148, 185, 167, 16, 20, 25, 224, 23, 93, 52, 65, 17, 214, 139, 238, 169, 147, 248, 53, 2, 131, 228, 28, 35, 108, 135, 233, 227, 91, 178, 94, 246, 179, 31, 103, 193, 177, 157, 132, 165, 142, 49, 254, 189, 172, 215, 76, 95, 183, 36, 45, 249, 247, 116, 145, 117, 82, 231, 96, 120, 150, 59, 138, 44, 55, 133, 102, 256, 63, 143, 243, 111, 203, 61, 12, 15, 83, 168, 210, 134, 39, 113, 77, 32, 40, 50, 191, 46, 186, 104, 130, 34, 171, 21, 219, 81, 37, 239, 106, 4, 5, 199, 56, 70, 216, 13, 209, 197, 182, 99, 188, 235, 101, 62, 206, 129, 97, 57, 7, 73, 27, 98, 251, 121, 87, 173, 152, 190, 109, 72, 90, 241, 237, 232, 33, 234, 164, 205, 192, 240, 43, 118, 19, 88, 110, 9, 204, 255, 126, 29, 229, 222, 149, 122, 24, 30, 166, 79, 163, 11, 78, 226, 154, 64, 80, 100, 125, 92, 115, 208, 3, 68, 85, 42, 181, 162, 74, 221, 212, 8, 10, 141, 112, 140, 175, 26, 161, 137, 107, 198, 119, 213, 202, 124, 155, 1],
+[1, 195, 246, 168, 121, 208, 211, 25, 249, 239, 88, 198, 60, 135, 111, 57, 64, 144, 67, 215, 34, 205, 140, 58, 2, 133, 235, 79, 242, 159, 165, 50, 241, 221, 176, 139, 120, 13, 222, 114, 128, 31, 134, 173, 68, 153, 23, 116, 4, 9, 213, 158, 227, 61, 73, 100, 225, 185, 95, 21, 240, 26, 187, 228, 256, 62, 11, 89, 136, 49, 46, 232, 8, 18, 169, 59, 197, 122, 146, 200, 193, 113, 190, 42, 223, 52, 117, 199, 255, 124, 22, 178, 15, 98, 92, 207, 16, 36, 81, 118, 137, 244, 35, 143, 129, 226, 123, 84, 189, 104, 234, 141, 253, 248, 44, 99, 30, 196, 184, 157, 32, 72, 162, 236, 17, 231, 70, 29, 1, 195, 246, 168, 121, 208, 211, 25, 249, 239, 88, 198, 60, 135, 111, 57, 64, 144, 67, 215, 34, 205, 140, 58, 2, 133, 235, 79, 242, 159, 165, 50, 241, 221, 176, 139, 120, 13, 222, 114, 128, 31, 134, 173, 68, 153, 23, 116, 4, 9, 213, 158, 227, 61, 73, 100, 225, 185, 95, 21, 240, 26, 187, 228, 256, 62, 11, 89, 136, 49, 46, 232, 8, 18, 169, 59, 197, 122, 146, 200, 193, 113, 190, 42, 223, 52, 117, 199, 255, 124, 22, 178, 15, 98, 92, 207, 16, 36, 81, 118, 137, 244, 35, 143, 129, 226, 123, 84, 189, 104, 234, 141, 253, 248, 44, 99, 30, 196, 184, 157, 32, 72, 162, 236, 17, 231, 70, 29, 1],
+[1, 196, 123, 207, 223, 18, 187, 158, 128, 159, 67, 25, 17, 248, 35, 178, 193, 49, 95, 116, 120, 133, 111, 168, 32, 104, 81, 199, 197, 62, 73, 173, 241, 205, 88, 29, 30, 226, 92, 42, 8, 26, 213, 114, 242, 144, 211, 236, 253, 244, 22, 200, 136, 185, 23, 139, 2, 135, 246, 157, 189, 36, 117, 59, 256, 61, 134, 50, 34, 239, 70, 99, 129, 98, 190, 232, 240, 9, 222, 79, 64, 208, 162, 141, 137, 124, 146, 89, 225, 153, 176, 58, 60, 195, 184, 84, 16, 52, 169, 228, 227, 31, 165, 215, 249, 231, 44, 143, 15, 113, 46, 21, 4, 13, 235, 57, 121, 72, 234, 118, 255, 122, 11, 100, 68, 221, 140, 198, 1, 196, 123, 207, 223, 18, 187, 158, 128, 159, 67, 25, 17, 248, 35, 178, 193, 49, 95, 116, 120, 133, 111, 168, 32, 104, 81, 199, 197, 62, 73, 173, 241, 205, 88, 29, 30, 226, 92, 42, 8, 26, 213, 114, 242, 144, 211, 236, 253, 244, 22, 200, 136, 185, 23, 139, 2, 135, 246, 157, 189, 36, 117, 59, 256, 61, 134, 50, 34, 239, 70, 99, 129, 98, 190, 232, 240, 9, 222, 79, 64, 208, 162, 141, 137, 124, 146, 89, 225, 153, 176, 58, 60, 195, 184, 84, 16, 52, 169, 228, 227, 31, 165, 215, 249, 231, 44, 143, 15, 113, 46, 21, 4, 13, 235, 57, 121, 72, 234, 118, 255, 122, 11, 100, 68, 221, 140, 198, 1],
+[1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1],
+[1, 198, 140, 221, 68, 100, 11, 122, 255, 118, 234, 72, 121, 57, 235, 13, 4, 21, 46, 113, 15, 143, 44, 231, 249, 215, 165, 31, 227, 228, 169, 52, 16, 84, 184, 195, 60, 58, 176, 153, 225, 89, 146, 124, 137, 141, 162, 208, 64, 79, 222, 9, 240, 232, 190, 98, 129, 99, 70, 239, 34, 50, 134, 61, 256, 59, 117, 36, 189, 157, 246, 135, 2, 139, 23, 185, 136, 200, 22, 244, 253, 236, 211, 144, 242, 114, 213, 26, 8, 42, 92, 226, 30, 29, 88, 205, 241, 173, 73, 62, 197, 199, 81, 104, 32, 168, 111, 133, 120, 116, 95, 49, 193, 178, 35, 248, 17, 25, 67, 159, 128, 158, 187, 18, 223, 207, 123, 196, 1, 198, 140, 221, 68, 100, 11, 122, 255, 118, 234, 72, 121, 57, 235, 13, 4, 21, 46, 113, 15, 143, 44, 231, 249, 215, 165, 31, 227, 228, 169, 52, 16, 84, 184, 195, 60, 58, 176, 153, 225, 89, 146, 124, 137, 141, 162, 208, 64, 79, 222, 9, 240, 232, 190, 98, 129, 99, 70, 239, 34, 50, 134, 61, 256, 59, 117, 36, 189, 157, 246, 135, 2, 139, 23, 185, 136, 200, 22, 244, 253, 236, 211, 144, 242, 114, 213, 26, 8, 42, 92, 226, 30, 29, 88, 205, 241, 173, 73, 62, 197, 199, 81, 104, 32, 168, 111, 133, 120, 116, 95, 49, 193, 178, 35, 248, 17, 25, 67, 159, 128, 158, 187, 18, 223, 207, 123, 196, 1],
+[1, 199, 23, 208, 15, 158, 88, 36, 225, 57, 35, 26, 34, 84, 11, 133, 253, 232, 165, 196, 197, 139, 162, 113, 128, 29, 117, 153, 121, 178, 213, 239, 16, 100, 111, 244, 240, 215, 123, 62, 2, 141, 46, 159, 30, 59, 176, 72, 193, 114, 70, 52, 68, 168, 22, 9, 249, 207, 73, 135, 137, 21, 67, 226, 256, 58, 234, 49, 242, 99, 169, 221, 32, 200, 222, 231, 223, 173, 246, 124, 4, 25, 92, 61, 60, 118, 95, 144, 129, 228, 140, 104, 136, 79, 44, 18, 241, 157, 146, 13, 17, 42, 134, 195, 255, 116, 211, 98, 227, 198, 81, 185, 64, 143, 187, 205, 189, 89, 235, 248, 8, 50, 184, 122, 120, 236, 190, 31, 1, 199, 23, 208, 15, 158, 88, 36, 225, 57, 35, 26, 34, 84, 11, 133, 253, 232, 165, 196, 197, 139, 162, 113, 128, 29, 117, 153, 121, 178, 213, 239, 16, 100, 111, 244, 240, 215, 123, 62, 2, 141, 46, 159, 30, 59, 176, 72, 193, 114, 70, 52, 68, 168, 22, 9, 249, 207, 73, 135, 137, 21, 67, 226, 256, 58, 234, 49, 242, 99, 169, 221, 32, 200, 222, 231, 223, 173, 246, 124, 4, 25, 92, 61, 60, 118, 95, 144, 129, 228, 140, 104, 136, 79, 44, 18, 241, 157, 146, 13, 17, 42, 134, 195, 255, 116, 211, 98, 227, 198, 81, 185, 64, 143, 187, 205, 189, 89, 235, 248, 8, 50, 184, 122, 120, 236, 190, 31, 1],
+[1, 200, 165, 104, 240, 198, 22, 31, 32, 232, 140, 244, 227, 168, 190, 221, 253, 228, 111, 98, 68, 236, 169, 133, 129, 100, 211, 52, 120, 99, 11, 144, 16, 116, 70, 122, 242, 84, 95, 239, 255, 114, 184, 49, 34, 118, 213, 195, 193, 50, 234, 26, 60, 178, 134, 72, 8, 58, 35, 61, 121, 42, 176, 248, 256, 57, 92, 153, 17, 59, 235, 226, 225, 25, 117, 13, 30, 89, 67, 36, 4, 29, 146, 159, 189, 21, 88, 124, 128, 157, 46, 205, 137, 158, 246, 113, 241, 141, 187, 135, 15, 173, 162, 18, 2, 143, 73, 208, 223, 139, 44, 62, 64, 207, 23, 231, 197, 79, 123, 185, 249, 199, 222, 196, 136, 215, 81, 9, 1, 200, 165, 104, 240, 198, 22, 31, 32, 232, 140, 244, 227, 168, 190, 221, 253, 228, 111, 98, 68, 236, 169, 133, 129, 100, 211, 52, 120, 99, 11, 144, 16, 116, 70, 122, 242, 84, 95, 239, 255, 114, 184, 49, 34, 118, 213, 195, 193, 50, 234, 26, 60, 178, 134, 72, 8, 58, 35, 61, 121, 42, 176, 248, 256, 57, 92, 153, 17, 59, 235, 226, 225, 25, 117, 13, 30, 89, 67, 36, 4, 29, 146, 159, 189, 21, 88, 124, 128, 157, 46, 205, 137, 158, 246, 113, 241, 141, 187, 135, 15, 173, 162, 18, 2, 143, 73, 208, 223, 139, 44, 62, 64, 207, 23, 231, 197, 79, 123, 185, 249, 199, 222, 196, 136, 215, 81, 9, 1],
+[1, 201, 52, 172, 134, 206, 29, 175, 223, 105, 31, 63, 70, 192, 42, 218, 128, 28, 231, 171, 190, 154, 114, 41, 17, 76, 113, 97, 222, 161, 236, 148, 193, 243, 13, 43, 162, 180, 200, 108, 120, 219, 72, 80, 146, 48, 139, 183, 32, 7, 122, 107, 176, 167, 157, 203, 197, 19, 221, 217, 184, 233, 59, 37, 241, 125, 196, 75, 169, 45, 50, 27, 30, 119, 18, 20, 165, 12, 99, 110, 8, 66, 159, 91, 44, 106, 232, 115, 242, 69, 248, 247, 46, 251, 79, 202, 253, 224, 49, 83, 235, 204, 141, 71, 136, 94, 133, 5, 234, 3, 89, 156, 2, 145, 104, 87, 11, 155, 58, 93, 189, 210, 62, 126, 140, 127, 84, 179, 256, 56, 205, 85, 123, 51, 228, 82, 34, 152, 226, 194, 187, 65, 215, 39, 129, 229, 26, 86, 67, 103, 143, 216, 240, 181, 144, 160, 35, 96, 21, 109, 64, 14, 244, 214, 95, 77, 57, 149, 137, 38, 185, 177, 111, 209, 118, 74, 225, 250, 135, 150, 81, 90, 100, 54, 60, 238, 36, 40, 73, 24, 198, 220, 16, 132, 61, 182, 88, 212, 207, 230, 227, 138, 239, 237, 92, 245, 158, 147, 249, 191, 98, 166, 213, 151, 25, 142, 15, 188, 9, 10, 211, 6, 178, 55, 4, 33, 208, 174, 22, 53, 116, 186, 121, 163, 124, 252, 23, 254, 168, 101, 255, 112, 153, 170, 246, 102, 199, 164, 68, 47, 195, 131, 117, 130, 173, 78, 1],
+[1, 202, 198, 161, 140, 10, 221, 181, 68, 115, 100, 154, 11, 166, 122, 229, 255, 110, 118, 192, 234, 237, 72, 152, 121, 27, 57, 206, 235, 182, 13, 56, 4, 37, 21, 130, 46, 40, 113, 210, 15, 203, 143, 102, 44, 150, 231, 145, 249, 183, 215, 254, 165, 177, 31, 94, 227, 108, 228, 53, 169, 214, 52, 224, 16, 148, 84, 6, 184, 160, 195, 69, 60, 41, 58, 151, 176, 86, 153, 66, 225, 218, 89, 245, 146, 194, 124, 119, 137, 175, 141, 212, 162, 85, 208, 125, 64, 78, 79, 24, 222, 126, 9, 19, 240, 164, 232, 90, 190, 87, 98, 7, 129, 101, 99, 209, 70, 5, 239, 219, 34, 186, 50, 77, 134, 83, 61, 243, 256, 55, 59, 96, 117, 247, 36, 76, 189, 142, 157, 103, 246, 91, 135, 28, 2, 147, 139, 65, 23, 20, 185, 105, 136, 230, 200, 51, 22, 75, 244, 201, 253, 220, 236, 127, 211, 217, 144, 47, 242, 54, 114, 155, 213, 107, 26, 112, 8, 74, 42, 3, 92, 80, 226, 163, 30, 149, 29, 204, 88, 43, 205, 33, 241, 109, 173, 251, 73, 97, 62, 188, 197, 216, 199, 106, 81, 171, 104, 191, 32, 39, 168, 12, 111, 63, 133, 138, 120, 82, 116, 45, 95, 172, 49, 132, 193, 179, 178, 233, 35, 131, 248, 238, 17, 93, 25, 167, 67, 170, 159, 250, 128, 156, 158, 48, 187, 252, 18, 38, 223, 71, 207, 180, 123, 174, 196, 14, 1],
+[1, 203, 89, 77, 211, 171, 18, 56, 60, 101, 200, 251, 67, 237, 52, 19, 2, 149, 178, 154, 165, 85, 36, 112, 120, 202, 143, 245, 134, 217, 104, 38, 4, 41, 99, 51, 73, 170, 72, 224, 240, 147, 29, 233, 11, 177, 208, 76, 8, 82, 198, 102, 146, 83, 144, 191, 223, 37, 58, 209, 22, 97, 159, 152, 16, 164, 139, 204, 35, 166, 31, 125, 189, 74, 116, 161, 44, 194, 61, 47, 32, 71, 21, 151, 70, 75, 62, 250, 121, 148, 232, 65, 88, 131, 122, 94, 64, 142, 42, 45, 140, 150, 124, 243, 242, 39, 207, 130, 176, 5, 244, 188, 128, 27, 84, 90, 23, 43, 248, 229, 227, 78, 157, 3, 95, 10, 231, 119, 256, 54, 168, 180, 46, 86, 239, 201, 197, 156, 57, 6, 190, 20, 205, 238, 255, 108, 79, 103, 92, 172, 221, 145, 137, 55, 114, 12, 123, 40, 153, 219, 253, 216, 158, 206, 184, 87, 185, 33, 17, 110, 228, 24, 246, 80, 49, 181, 249, 175, 59, 155, 111, 174, 113, 66, 34, 220, 199, 48, 235, 160, 98, 105, 241, 93, 118, 53, 222, 91, 226, 132, 68, 183, 141, 96, 213, 63, 196, 210, 225, 186, 236, 106, 187, 182, 195, 7, 136, 109, 25, 192, 169, 126, 135, 163, 193, 115, 215, 212, 117, 107, 133, 14, 15, 218, 50, 127, 81, 252, 13, 69, 129, 230, 173, 167, 234, 214, 9, 28, 30, 179, 100, 254, 162, 247, 26, 138, 1],
+[1, 204, 239, 183, 67, 47, 79, 182, 120, 65, 153, 115, 73, 243, 228, 252, 8, 90, 113, 179, 22, 119, 118, 171, 189, 6, 196, 149, 70, 145, 25, 217, 64, 206, 133, 147, 176, 181, 173, 83, 227, 48, 26, 164, 46, 132, 200, 194, 255, 106, 36, 148, 123, 163, 99, 150, 17, 127, 208, 27, 111, 28, 58, 10, 241, 77, 31, 156, 213, 19, 21, 172, 136, 245, 122, 216, 117, 224, 207, 80, 129, 102, 248, 220, 162, 152, 168, 91, 60, 161, 205, 186, 165, 250, 114, 126, 4, 45, 185, 218, 11, 188, 59, 214, 223, 3, 98, 203, 35, 201, 141, 237, 32, 103, 195, 202, 88, 219, 215, 170, 242, 24, 13, 82, 23, 66, 100, 97, 256, 53, 18, 74, 190, 210, 178, 75, 137, 192, 104, 142, 184, 14, 29, 5, 249, 167, 144, 78, 235, 138, 139, 86, 68, 251, 61, 108, 187, 112, 232, 40, 193, 51, 124, 110, 81, 76, 84, 174, 30, 209, 231, 93, 211, 125, 57, 63, 2, 151, 221, 109, 134, 94, 158, 107, 240, 130, 49, 230, 146, 229, 199, 247, 16, 180, 226, 101, 44, 238, 236, 85, 121, 12, 135, 41, 140, 33, 50, 177, 128, 155, 9, 37, 95, 105, 89, 166, 197, 96, 52, 71, 92, 7, 143, 131, 253, 212, 72, 39, 246, 69, 198, 43, 34, 254, 159, 54, 222, 56, 116, 20, 225, 154, 62, 55, 169, 38, 42, 87, 15, 233, 244, 175, 234, 191, 157, 160, 1],
+[1, 205, 134, 228, 223, 226, 70, 215, 128, 26, 190, 143, 17, 144, 222, 21, 193, 244, 162, 57, 120, 185, 146, 118, 32, 135, 176, 100, 197, 36, 184, 198, 241, 61, 169, 207, 30, 239, 165, 158, 8, 98, 44, 25, 242, 9, 46, 178, 253, 208, 235, 116, 136, 124, 234, 168, 2, 153, 11, 199, 189, 195, 140, 173, 256, 52, 123, 29, 34, 31, 187, 42, 129, 231, 67, 114, 240, 113, 35, 236, 64, 13, 95, 200, 137, 72, 111, 139, 225, 122, 81, 157, 60, 221, 73, 59, 16, 196, 88, 50, 227, 18, 92, 99, 249, 159, 213, 232, 15, 248, 211, 79, 4, 49, 22, 141, 121, 133, 23, 89, 255, 104, 246, 58, 68, 62, 117, 84, 1, 205, 134, 228, 223, 226, 70, 215, 128, 26, 190, 143, 17, 144, 222, 21, 193, 244, 162, 57, 120, 185, 146, 118, 32, 135, 176, 100, 197, 36, 184, 198, 241, 61, 169, 207, 30, 239, 165, 158, 8, 98, 44, 25, 242, 9, 46, 178, 253, 208, 235, 116, 136, 124, 234, 168, 2, 153, 11, 199, 189, 195, 140, 173, 256, 52, 123, 29, 34, 31, 187, 42, 129, 231, 67, 114, 240, 113, 35, 236, 64, 13, 95, 200, 137, 72, 111, 139, 225, 122, 81, 157, 60, 221, 73, 59, 16, 196, 88, 50, 227, 18, 92, 99, 249, 159, 213, 232, 15, 248, 211, 79, 4, 49, 22, 141, 121, 133, 23, 89, 255, 104, 246, 58, 68, 62, 117, 84, 1],
+[1, 206, 31, 218, 190, 76, 236, 43, 120, 48, 122, 203, 184, 125, 50, 20, 8, 106, 248, 202, 235, 94, 89, 87, 189, 127, 205, 82, 187, 229, 143, 160, 64, 77, 185, 74, 81, 238, 198, 182, 227, 245, 98, 142, 211, 33, 116, 252, 255, 102, 195, 78, 134, 105, 42, 171, 17, 161, 13, 108, 146, 7, 157, 217, 241, 45, 18, 110, 44, 69, 79, 83, 136, 3, 104, 93, 140, 56, 228, 194, 129, 103, 144, 109, 95, 38, 118, 150, 60, 24, 61, 230, 92, 191, 25, 10, 4, 53, 124, 101, 246, 47, 173, 172, 223, 192, 231, 41, 222, 243, 200, 80, 32, 167, 221, 37, 169, 119, 99, 91, 242, 251, 49, 71, 234, 145, 58, 126, 256, 51, 226, 39, 67, 181, 21, 214, 137, 209, 135, 54, 73, 132, 207, 237, 249, 151, 9, 55, 22, 163, 168, 170, 68, 130, 52, 175, 70, 28, 114, 97, 193, 180, 72, 183, 176, 19, 59, 75, 30, 12, 159, 115, 46, 224, 141, 5, 2, 155, 62, 179, 123, 152, 215, 86, 240, 96, 244, 149, 111, 250, 100, 40, 16, 212, 239, 147, 213, 188, 178, 174, 121, 254, 153, 164, 117, 201, 29, 63, 128, 154, 113, 148, 162, 219, 139, 107, 197, 233, 196, 27, 165, 66, 232, 247, 253, 204, 133, 156, 11, 210, 84, 85, 34, 65, 26, 216, 35, 14, 57, 177, 225, 90, 36, 220, 88, 138, 158, 166, 15, 6, 208, 186, 23, 112, 199, 131, 1],
+[1, 207, 187, 159, 17, 178, 95, 133, 32, 199, 73, 205, 30, 42, 213, 144, 253, 200, 23, 135, 189, 59, 134, 239, 129, 232, 222, 208, 137, 89, 176, 195, 16, 228, 165, 231, 15, 21, 235, 72, 255, 100, 140, 196, 223, 158, 67, 248, 193, 116, 111, 104, 197, 173, 88, 226, 8, 114, 211, 244, 136, 139, 246, 36, 256, 50, 70, 98, 240, 79, 162, 124, 225, 58, 184, 52, 227, 215, 44, 113, 4, 57, 234, 122, 68, 198, 123, 18, 128, 25, 35, 49, 120, 168, 81, 62, 241, 29, 92, 26, 242, 236, 22, 185, 2, 157, 117, 61, 34, 99, 190, 9, 64, 141, 146, 153, 60, 84, 169, 31, 249, 143, 46, 13, 121, 118, 11, 221, 1, 207, 187, 159, 17, 178, 95, 133, 32, 199, 73, 205, 30, 42, 213, 144, 253, 200, 23, 135, 189, 59, 134, 239, 129, 232, 222, 208, 137, 89, 176, 195, 16, 228, 165, 231, 15, 21, 235, 72, 255, 100, 140, 196, 223, 158, 67, 248, 193, 116, 111, 104, 197, 173, 88, 226, 8, 114, 211, 244, 136, 139, 246, 36, 256, 50, 70, 98, 240, 79, 162, 124, 225, 58, 184, 52, 227, 215, 44, 113, 4, 57, 234, 122, 68, 198, 123, 18, 128, 25, 35, 49, 120, 168, 81, 62, 241, 29, 92, 26, 242, 236, 22, 185, 2, 157, 117, 61, 34, 99, 190, 9, 64, 141, 146, 153, 60, 84, 169, 31, 249, 143, 46, 13, 121, 118, 11, 221, 1],
+[1, 208, 88, 57, 34, 133, 165, 139, 128, 153, 213, 100, 240, 62, 46, 59, 193, 52, 22, 207, 137, 226, 234, 99, 32, 231, 246, 25, 60, 144, 140, 79, 241, 13, 134, 116, 227, 185, 187, 89, 8, 122, 190, 199, 15, 36, 35, 84, 253, 196, 162, 29, 121, 239, 111, 215, 2, 159, 176, 114, 68, 9, 73, 21, 256, 49, 169, 200, 223, 124, 92, 118, 129, 104, 44, 157, 17, 195, 211, 198, 64, 205, 235, 50, 120, 31, 23, 158, 225, 26, 11, 232, 197, 113, 117, 178, 16, 244, 123, 141, 30, 72, 70, 168, 249, 135, 67, 58, 242, 221, 222, 173, 4, 61, 95, 228, 136, 18, 146, 42, 255, 98, 81, 143, 189, 248, 184, 236, 1, 208, 88, 57, 34, 133, 165, 139, 128, 153, 213, 100, 240, 62, 46, 59, 193, 52, 22, 207, 137, 226, 234, 99, 32, 231, 246, 25, 60, 144, 140, 79, 241, 13, 134, 116, 227, 185, 187, 89, 8, 122, 190, 199, 15, 36, 35, 84, 253, 196, 162, 29, 121, 239, 111, 215, 2, 159, 176, 114, 68, 9, 73, 21, 256, 49, 169, 200, 223, 124, 92, 118, 129, 104, 44, 157, 17, 195, 211, 198, 64, 205, 235, 50, 120, 31, 23, 158, 225, 26, 11, 232, 197, 113, 117, 178, 16, 244, 123, 141, 30, 72, 70, 168, 249, 135, 67, 58, 242, 221, 222, 173, 4, 61, 95, 228, 136, 18, 146, 42, 255, 98, 81, 143, 189, 248, 184, 236, 1],
+[1, 209, 248, 175, 81, 224, 42, 40, 136, 154, 61, 156, 222, 138, 58, 43, 249, 127, 72, 142, 123, 7, 178, 194, 197, 53, 26, 37, 23, 181, 50, 170, 64, 12, 195, 149, 44, 201, 118, 247, 223, 90, 49, 218, 73, 94, 114, 182, 2, 161, 239, 93, 162, 191, 84, 80, 15, 51, 122, 55, 187, 19, 116, 86, 241, 254, 144, 27, 246, 14, 99, 131, 137, 106, 52, 74, 46, 105, 100, 83, 128, 24, 133, 41, 88, 145, 236, 237, 189, 180, 98, 179, 146, 188, 228, 107, 4, 65, 221, 186, 67, 125, 168, 160, 30, 102, 244, 110, 117, 38, 232, 172, 225, 251, 31, 54, 235, 28, 198, 5, 17, 212, 104, 148, 92, 210, 200, 166, 256, 48, 9, 82, 176, 33, 215, 217, 121, 103, 196, 101, 35, 119, 199, 214, 8, 130, 185, 115, 134, 250, 79, 63, 60, 204, 231, 220, 234, 76, 207, 87, 193, 245, 62, 108, 213, 56, 139, 10, 34, 167, 208, 39, 184, 163, 143, 75, 255, 96, 18, 164, 95, 66, 173, 177, 242, 206, 135, 202, 70, 238, 141, 171, 16, 3, 113, 230, 11, 243, 158, 126, 120, 151, 205, 183, 211, 152, 157, 174, 129, 233, 124, 216, 169, 112, 21, 20, 68, 77, 159, 78, 111, 69, 29, 150, 253, 192, 36, 71, 190, 132, 89, 97, 227, 155, 13, 147, 140, 219, 25, 85, 32, 6, 226, 203, 22, 229, 59, 252, 240, 45, 153, 109, 165, 47, 57, 91, 1],
+[1, 210, 153, 5, 22, 251, 25, 110, 227, 125, 36, 107, 111, 180, 21, 41, 129, 105, 205, 131, 11, 254, 141, 55, 242, 191, 18, 182, 184, 90, 139, 149, 193, 181, 231, 194, 134, 127, 199, 156, 121, 224, 9, 91, 92, 45, 198, 203, 225, 219, 244, 97, 67, 192, 228, 78, 189, 112, 133, 174, 46, 151, 99, 230, 241, 238, 122, 177, 162, 96, 114, 39, 223, 56, 195, 87, 23, 204, 178, 115, 249, 119, 61, 217, 81, 48, 57, 148, 240, 28, 226, 172, 140, 102, 89, 186, 253, 188, 159, 237, 169, 24, 157, 74, 120, 14, 113, 86, 70, 51, 173, 93, 255, 94, 208, 247, 213, 12, 207, 37, 60, 7, 185, 43, 35, 154, 215, 175, 256, 47, 104, 252, 235, 6, 232, 147, 30, 132, 221, 150, 146, 77, 236, 216, 128, 152, 52, 126, 246, 3, 116, 202, 15, 66, 239, 75, 73, 167, 118, 108, 64, 76, 26, 63, 123, 130, 58, 101, 136, 33, 248, 166, 165, 212, 59, 54, 32, 38, 13, 160, 190, 65, 29, 179, 68, 145, 124, 83, 211, 106, 158, 27, 16, 19, 135, 80, 95, 161, 143, 218, 34, 201, 62, 170, 234, 53, 79, 142, 8, 138, 196, 40, 176, 209, 200, 109, 17, 229, 31, 85, 117, 155, 168, 71, 4, 69, 98, 20, 88, 233, 100, 183, 137, 243, 144, 171, 187, 206, 84, 164, 2, 163, 49, 10, 44, 245, 50, 220, 197, 250, 72, 214, 222, 103, 42, 82, 1],
+[1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1],
+[1, 212, 226, 110, 190, 188, 21, 83, 120, 254, 135, 93, 184, 201, 207, 194, 8, 154, 9, 109, 235, 219, 168, 150, 189, 233, 52, 230, 187, 66, 114, 10, 64, 204, 72, 101, 81, 210, 59, 172, 227, 65, 159, 41, 211, 14, 141, 80, 255, 90, 62, 37, 134, 138, 215, 91, 17, 6, 244, 71, 146, 112, 100, 126, 241, 206, 239, 39, 44, 76, 178, 214, 136, 48, 153, 54, 140, 125, 29, 237, 129, 106, 113, 55, 95, 94, 139, 170, 60, 127, 196, 175, 92, 229, 232, 97, 4, 77, 133, 183, 246, 238, 84, 75, 223, 245, 26, 115, 222, 33, 57, 5, 32, 102, 36, 179, 169, 105, 158, 86, 242, 161, 208, 149, 234, 7, 199, 40, 256, 45, 31, 147, 67, 69, 236, 174, 137, 3, 122, 164, 73, 56, 50, 63, 249, 103, 248, 148, 22, 38, 89, 107, 68, 24, 205, 27, 70, 191, 143, 247, 193, 53, 185, 156, 176, 47, 198, 85, 30, 192, 98, 216, 46, 243, 116, 177, 2, 167, 195, 220, 123, 119, 42, 166, 240, 251, 13, 186, 111, 145, 157, 131, 16, 51, 18, 218, 213, 181, 79, 43, 121, 209, 104, 203, 117, 132, 228, 20, 128, 151, 144, 202, 162, 163, 118, 87, 197, 130, 61, 82, 165, 28, 25, 160, 253, 180, 124, 74, 11, 19, 173, 182, 34, 12, 231, 142, 35, 224, 200, 252, 225, 155, 221, 78, 88, 152, 99, 171, 15, 96, 49, 108, 23, 250, 58, 217, 1],
+[1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1],
+[1, 214, 50, 163, 187, 183, 98, 155, 17, 40, 79, 201, 95, 27, 124, 65, 32, 166, 58, 76, 73, 202, 52, 77, 30, 252, 215, 7, 213, 93, 113, 24, 253, 172, 57, 119, 23, 39, 122, 151, 189, 97, 198, 224, 134, 149, 18, 254, 129, 107, 25, 210, 222, 220, 49, 206, 137, 20, 168, 229, 176, 142, 62, 161, 16, 83, 29, 38, 165, 101, 26, 167, 15, 126, 236, 132, 235, 175, 185, 12, 255, 86, 157, 188, 140, 148, 61, 204, 223, 177, 99, 112, 67, 203, 9, 127, 193, 182, 141, 105, 111, 110, 153, 103, 197, 10, 84, 243, 88, 71, 31, 209, 8, 170, 143, 19, 211, 179, 13, 212, 136, 63, 118, 66, 246, 216, 221, 6, 256, 43, 207, 94, 70, 74, 159, 102, 240, 217, 178, 56, 162, 230, 133, 192, 225, 91, 199, 181, 184, 55, 205, 180, 227, 5, 42, 250, 44, 164, 144, 233, 4, 85, 200, 138, 234, 218, 135, 106, 68, 160, 59, 33, 123, 108, 239, 3, 128, 150, 232, 47, 35, 37, 208, 51, 120, 237, 89, 28, 81, 115, 195, 96, 241, 174, 228, 219, 92, 156, 231, 90, 242, 131, 21, 125, 22, 82, 72, 245, 2, 171, 100, 69, 117, 109, 196, 53, 34, 80, 158, 145, 190, 54, 248, 130, 64, 75, 116, 152, 146, 147, 104, 154, 60, 247, 173, 14, 169, 186, 226, 48, 249, 87, 114, 238, 46, 78, 244, 45, 121, 194, 139, 191, 11, 41, 36, 251, 1],
+[1, 215, 222, 185, 197, 207, 44, 208, 2, 173, 187, 113, 137, 157, 88, 159, 4, 89, 117, 226, 17, 57, 176, 61, 8, 178, 234, 195, 34, 114, 95, 122, 16, 99, 211, 133, 68, 228, 190, 244, 32, 198, 165, 9, 136, 199, 123, 231, 64, 139, 73, 18, 15, 141, 246, 205, 128, 21, 146, 36, 30, 25, 235, 153, 256, 42, 35, 72, 60, 50, 213, 49, 255, 84, 70, 144, 120, 100, 169, 98, 253, 168, 140, 31, 240, 200, 81, 196, 249, 79, 23, 62, 223, 143, 162, 135, 241, 158, 46, 124, 189, 29, 67, 13, 225, 59, 92, 248, 121, 58, 134, 26, 193, 118, 184, 239, 242, 116, 11, 52, 129, 236, 111, 221, 227, 232, 22, 104, 1, 215, 222, 185, 197, 207, 44, 208, 2, 173, 187, 113, 137, 157, 88, 159, 4, 89, 117, 226, 17, 57, 176, 61, 8, 178, 234, 195, 34, 114, 95, 122, 16, 99, 211, 133, 68, 228, 190, 244, 32, 198, 165, 9, 136, 199, 123, 231, 64, 139, 73, 18, 15, 141, 246, 205, 128, 21, 146, 36, 30, 25, 235, 153, 256, 42, 35, 72, 60, 50, 213, 49, 255, 84, 70, 144, 120, 100, 169, 98, 253, 168, 140, 31, 240, 200, 81, 196, 249, 79, 23, 62, 223, 143, 162, 135, 241, 158, 46, 124, 189, 29, 67, 13, 225, 59, 92, 248, 121, 58, 134, 26, 193, 118, 184, 239, 242, 116, 11, 52, 129, 236, 111, 221, 227, 232, 22, 104, 1],
+[1, 216, 139, 212, 46, 170, 226, 243, 60, 110, 116, 127, 190, 177, 196, 188, 2, 175, 21, 167, 92, 83, 195, 229, 120, 220, 232, 254, 123, 97, 135, 119, 4, 93, 42, 77, 184, 166, 133, 201, 240, 183, 207, 251, 246, 194, 13, 238, 8, 186, 84, 154, 111, 75, 9, 145, 223, 109, 157, 245, 235, 131, 26, 219, 16, 115, 168, 51, 222, 150, 18, 33, 189, 218, 57, 233, 213, 5, 52, 181, 32, 230, 79, 102, 187, 43, 36, 66, 121, 179, 114, 209, 169, 10, 104, 105, 64, 203, 158, 204, 117, 86, 72, 132, 242, 101, 228, 161, 81, 20, 208, 210, 128, 149, 59, 151, 234, 172, 144, 7, 227, 202, 199, 65, 162, 40, 159, 163, 256, 41, 118, 45, 211, 87, 31, 14, 197, 147, 141, 130, 67, 80, 61, 69, 255, 82, 236, 90, 165, 174, 62, 28, 137, 37, 25, 3, 134, 160, 122, 138, 253, 164, 215, 180, 73, 91, 124, 56, 17, 74, 50, 6, 11, 63, 244, 19, 249, 71, 173, 103, 146, 182, 248, 112, 34, 148, 100, 12, 22, 126, 231, 38, 241, 142, 89, 206, 35, 107, 239, 224, 68, 39, 200, 24, 44, 252, 205, 76, 225, 27, 178, 155, 70, 214, 221, 191, 136, 78, 143, 48, 88, 247, 153, 152, 193, 54, 99, 53, 140, 171, 185, 125, 15, 156, 29, 96, 176, 237, 49, 47, 129, 108, 198, 106, 23, 85, 113, 250, 30, 55, 58, 192, 95, 217, 98, 94, 1],
+[1, 217, 58, 250, 23, 108, 49, 96, 15, 171, 99, 152, 88, 78, 221, 155, 225, 252, 200, 224, 35, 142, 231, 12, 34, 182, 173, 19, 11, 74, 124, 180, 253, 160, 25, 28, 165, 82, 61, 130, 197, 87, 118, 163, 162, 202, 144, 151, 128, 20, 228, 132, 117, 203, 104, 209, 121, 43, 79, 181, 213, 218, 18, 51, 16, 131, 157, 145, 111, 186, 13, 251, 240, 166, 42, 119, 123, 220, 195, 167, 2, 177, 116, 243, 46, 216, 98, 192, 30, 85, 198, 47, 176, 156, 185, 53, 193, 247, 143, 191, 70, 27, 205, 24, 68, 107, 89, 38, 22, 148, 248, 103, 249, 63, 50, 56, 73, 164, 122, 3, 137, 174, 236, 69, 67, 147, 31, 45, 256, 40, 199, 7, 234, 149, 208, 161, 242, 86, 158, 105, 169, 179, 36, 102, 32, 5, 57, 33, 222, 115, 26, 245, 223, 75, 84, 238, 246, 183, 133, 77, 4, 97, 232, 229, 92, 175, 196, 127, 60, 170, 139, 94, 95, 55, 113, 106, 129, 237, 29, 125, 140, 54, 153, 48, 136, 214, 178, 76, 44, 39, 239, 206, 241, 126, 100, 112, 146, 71, 244, 6, 17, 91, 215, 138, 134, 37, 62, 90, 255, 80, 141, 14, 211, 41, 159, 65, 227, 172, 59, 210, 81, 101, 72, 204, 64, 10, 114, 66, 187, 230, 52, 233, 189, 150, 168, 219, 235, 109, 9, 154, 8, 194, 207, 201, 184, 93, 135, 254, 120, 83, 21, 188, 190, 110, 226, 212, 1],
+[1, 218, 236, 48, 184, 20, 248, 94, 189, 82, 143, 77, 81, 182, 98, 33, 255, 78, 42, 161, 146, 217, 18, 69, 136, 93, 228, 103, 95, 150, 61, 191, 4, 101, 173, 192, 222, 80, 221, 119, 242, 71, 58, 51, 67, 214, 135, 132, 249, 55, 168, 130, 70, 97, 72, 19, 30, 115, 141, 155, 123, 86, 244, 250, 16, 147, 178, 254, 117, 63, 113, 219, 197, 27, 232, 204, 11, 85, 26, 14, 225, 220, 158, 6, 23, 131, 31, 76, 120, 203, 50, 106, 235, 87, 205, 229, 64, 74, 198, 245, 211, 252, 195, 105, 17, 108, 157, 45, 44, 83, 104, 56, 129, 109, 118, 24, 92, 10, 124, 47, 223, 41, 200, 167, 169, 91, 49, 145, 256, 39, 21, 209, 73, 237, 9, 163, 68, 175, 114, 180, 176, 75, 159, 224, 2, 179, 215, 96, 111, 40, 239, 188, 121, 164, 29, 154, 162, 107, 196, 66, 253, 156, 84, 65, 35, 177, 36, 138, 15, 186, 199, 206, 190, 43, 122, 125, 8, 202, 89, 127, 187, 160, 185, 238, 227, 142, 116, 102, 134, 171, 13, 7, 241, 110, 79, 3, 140, 194, 144, 38, 60, 230, 25, 53, 246, 172, 231, 243, 32, 37, 99, 251, 234, 126, 226, 181, 137, 54, 207, 151, 22, 170, 52, 28, 193, 183, 59, 12, 46, 5, 62, 152, 240, 149, 100, 212, 213, 174, 153, 201, 128, 148, 139, 233, 165, 247, 133, 210, 34, 216, 57, 90, 88, 166, 208, 112, 1],
+[1, 219, 159, 126, 95, 245, 199, 148, 30, 145, 144, 182, 23, 154, 59, 71, 129, 238, 208, 63, 176, 251, 228, 74, 15, 201, 72, 91, 140, 77, 158, 164, 193, 119, 104, 160, 88, 254, 114, 37, 136, 229, 36, 174, 70, 167, 79, 82, 225, 188, 52, 80, 44, 127, 57, 147, 68, 243, 18, 87, 35, 212, 168, 41, 241, 94, 26, 40, 22, 192, 157, 202, 34, 250, 9, 172, 146, 106, 84, 149, 249, 47, 13, 20, 11, 96, 207, 101, 17, 125, 133, 86, 73, 53, 42, 203, 253, 152, 135, 10, 134, 48, 232, 179, 137, 191, 195, 43, 165, 155, 21, 230, 255, 76, 196, 5, 67, 24, 116, 218, 197, 224, 226, 150, 211, 206, 139, 115, 256, 38, 98, 131, 162, 12, 58, 109, 227, 112, 113, 75, 234, 103, 198, 186, 128, 19, 49, 194, 81, 6, 29, 183, 242, 56, 185, 166, 117, 180, 99, 93, 64, 138, 153, 97, 169, 3, 143, 220, 121, 28, 221, 83, 187, 90, 178, 175, 32, 69, 205, 177, 213, 130, 200, 110, 189, 14, 239, 170, 222, 45, 89, 216, 16, 163, 231, 217, 235, 65, 100, 55, 223, 7, 248, 85, 111, 151, 173, 108, 8, 210, 244, 237, 246, 161, 50, 156, 240, 132, 124, 171, 184, 204, 215, 54, 4, 105, 122, 247, 123, 209, 25, 78, 120, 66, 62, 214, 92, 102, 236, 27, 2, 181, 61, 252, 190, 233, 141, 39, 60, 33, 31, 107, 46, 51, 118, 142, 1],
+[1, 220, 84, 233, 117, 40, 62, 19, 68, 54, 58, 167, 246, 150, 104, 7, 255, 74, 89, 48, 23, 177, 133, 219, 121, 149, 141, 180, 22, 214, 49, 243, 4, 109, 79, 161, 211, 160, 248, 76, 15, 216, 232, 154, 213, 86, 159, 28, 249, 39, 99, 192, 92, 194, 18, 105, 227, 82, 50, 206, 88, 85, 196, 201, 16, 179, 59, 130, 73, 126, 221, 47, 60, 93, 157, 102, 81, 87, 122, 112, 225, 156, 139, 254, 111, 5, 72, 163, 137, 71, 200, 53, 95, 83, 13, 33, 64, 202, 236, 6, 35, 247, 113, 188, 240, 115, 114, 151, 67, 91, 231, 191, 129, 110, 42, 245, 187, 20, 31, 138, 34, 27, 29, 212, 123, 75, 52, 132, 256, 37, 173, 24, 140, 217, 195, 238, 189, 203, 199, 90, 11, 107, 153, 250, 2, 183, 168, 209, 234, 80, 124, 38, 136, 108, 116, 77, 235, 43, 208, 14, 253, 148, 178, 96, 46, 97, 9, 181, 242, 41, 25, 103, 44, 171, 98, 229, 8, 218, 158, 65, 165, 63, 239, 152, 30, 175, 207, 51, 169, 172, 61, 56, 241, 78, 198, 127, 184, 131, 36, 210, 197, 164, 100, 155, 176, 170, 135, 145, 32, 101, 118, 3, 146, 252, 185, 94, 120, 186, 57, 204, 162, 174, 244, 224, 193, 55, 21, 251, 222, 10, 144, 69, 17, 142, 143, 106, 190, 166, 26, 66, 128, 147, 215, 12, 70, 237, 226, 119, 223, 230, 228, 45, 134, 182, 205, 125, 1],
+[1, 221, 11, 118, 121, 13, 46, 143, 249, 31, 169, 84, 60, 153, 146, 141, 64, 9, 190, 99, 34, 61, 117, 157, 2, 185, 22, 236, 242, 26, 92, 29, 241, 62, 81, 168, 120, 49, 35, 25, 128, 18, 123, 198, 68, 122, 234, 57, 4, 113, 44, 215, 227, 52, 184, 58, 225, 124, 162, 79, 240, 98, 70, 50, 256, 36, 246, 139, 136, 244, 211, 114, 8, 226, 88, 173, 197, 104, 111, 116, 193, 248, 67, 158, 223, 196, 140, 100, 255, 72, 235, 21, 15, 231, 165, 228, 16, 195, 176, 89, 137, 208, 222, 232, 129, 239, 134, 59, 189, 135, 23, 200, 253, 144, 213, 42, 30, 205, 73, 199, 32, 133, 95, 178, 17, 159, 187, 207, 1, 221, 11, 118, 121, 13, 46, 143, 249, 31, 169, 84, 60, 153, 146, 141, 64, 9, 190, 99, 34, 61, 117, 157, 2, 185, 22, 236, 242, 26, 92, 29, 241, 62, 81, 168, 120, 49, 35, 25, 128, 18, 123, 198, 68, 122, 234, 57, 4, 113, 44, 215, 227, 52, 184, 58, 225, 124, 162, 79, 240, 98, 70, 50, 256, 36, 246, 139, 136, 244, 211, 114, 8, 226, 88, 173, 197, 104, 111, 116, 193, 248, 67, 158, 223, 196, 140, 100, 255, 72, 235, 21, 15, 231, 165, 228, 16, 195, 176, 89, 137, 208, 222, 232, 129, 239, 134, 59, 189, 135, 23, 200, 253, 144, 213, 42, 30, 205, 73, 199, 32, 133, 95, 178, 17, 159, 187, 207, 1],
+[1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1],
+[1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1],
+[1, 224, 61, 43, 123, 53, 50, 149, 223, 94, 239, 80, 187, 254, 99, 74, 128, 145, 98, 107, 67, 102, 232, 54, 17, 210, 9, 217, 35, 130, 79, 220, 193, 56, 208, 75, 95, 206, 141, 230, 120, 152, 124, 20, 111, 192, 89, 147, 32, 229, 153, 91, 81, 154, 58, 142, 197, 181, 195, 247, 73, 161, 84, 55, 241, 14, 52, 83, 88, 180, 228, 186, 30, 38, 31, 5, 92, 48, 215, 101, 8, 250, 231, 87, 213, 167, 143, 164, 242, 238, 113, 126, 211, 233, 21, 78, 253, 132, 13, 85, 22, 45, 57, 175, 136, 138, 72, 194, 23, 12, 118, 218, 2, 191, 122, 86, 246, 106, 100, 41, 189, 188, 221, 160, 117, 251, 198, 148, 256, 33, 196, 214, 134, 204, 207, 108, 34, 163, 18, 177, 70, 3, 158, 183, 129, 112, 159, 150, 190, 155, 25, 203, 240, 47, 248, 40, 222, 127, 178, 37, 64, 201, 49, 182, 162, 51, 116, 27, 137, 105, 133, 237, 146, 65, 168, 110, 225, 28, 104, 166, 176, 103, 199, 115, 60, 76, 62, 10, 184, 96, 173, 202, 16, 243, 205, 174, 169, 77, 29, 71, 227, 219, 226, 252, 165, 209, 42, 156, 249, 7, 26, 170, 44, 90, 114, 93, 15, 19, 144, 131, 46, 24, 236, 179, 4, 125, 244, 172, 235, 212, 200, 82, 121, 119, 185, 63, 234, 245, 139, 39, 255, 66, 135, 171, 11, 151, 157, 216, 68, 69, 36, 97, 140, 6, 59, 109, 1],
+[1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1],
+[1, 226, 190, 21, 120, 135, 184, 207, 8, 9, 235, 168, 189, 52, 187, 114, 64, 72, 81, 59, 227, 159, 211, 141, 255, 62, 134, 215, 17, 244, 146, 100, 241, 239, 44, 178, 136, 153, 140, 29, 129, 113, 95, 139, 60, 196, 92, 232, 4, 133, 246, 84, 223, 26, 222, 57, 32, 36, 169, 158, 242, 208, 234, 199, 256, 31, 67, 236, 137, 122, 73, 50, 249, 248, 22, 89, 68, 205, 70, 143, 193, 185, 176, 198, 30, 98, 46, 116, 2, 195, 123, 42, 240, 13, 111, 157, 16, 18, 213, 79, 121, 104, 117, 228, 128, 144, 162, 118, 197, 61, 165, 25, 253, 124, 11, 173, 34, 231, 35, 200, 225, 221, 88, 99, 15, 49, 23, 58, 1, 226, 190, 21, 120, 135, 184, 207, 8, 9, 235, 168, 189, 52, 187, 114, 64, 72, 81, 59, 227, 159, 211, 141, 255, 62, 134, 215, 17, 244, 146, 100, 241, 239, 44, 178, 136, 153, 140, 29, 129, 113, 95, 139, 60, 196, 92, 232, 4, 133, 246, 84, 223, 26, 222, 57, 32, 36, 169, 158, 242, 208, 234, 199, 256, 31, 67, 236, 137, 122, 73, 50, 249, 248, 22, 89, 68, 205, 70, 143, 193, 185, 176, 198, 30, 98, 46, 116, 2, 195, 123, 42, 240, 13, 111, 157, 16, 18, 213, 79, 121, 104, 117, 228, 128, 144, 162, 118, 197, 61, 165, 25, 253, 124, 11, 173, 34, 231, 35, 200, 225, 221, 88, 99, 15, 49, 23, 58, 1],
+[1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1],
+[1, 228, 70, 26, 17, 21, 162, 185, 32, 100, 184, 61, 30, 158, 44, 9, 253, 116, 234, 153, 189, 173, 123, 31, 129, 114, 35, 13, 137, 139, 81, 221, 16, 50, 92, 159, 15, 79, 22, 133, 255, 58, 117, 205, 223, 215, 190, 144, 193, 57, 146, 135, 197, 198, 169, 239, 8, 25, 46, 208, 136, 168, 11, 195, 256, 29, 187, 231, 240, 236, 95, 72, 225, 157, 73, 196, 227, 99, 213, 248, 4, 141, 23, 104, 68, 84, 134, 226, 128, 143, 222, 244, 120, 118, 176, 36, 241, 207, 165, 98, 242, 178, 235, 124, 2, 199, 140, 52, 34, 42, 67, 113, 64, 200, 111, 122, 60, 59, 88, 18, 249, 232, 211, 49, 121, 89, 246, 62, 1, 228, 70, 26, 17, 21, 162, 185, 32, 100, 184, 61, 30, 158, 44, 9, 253, 116, 234, 153, 189, 173, 123, 31, 129, 114, 35, 13, 137, 139, 81, 221, 16, 50, 92, 159, 15, 79, 22, 133, 255, 58, 117, 205, 223, 215, 190, 144, 193, 57, 146, 135, 197, 198, 169, 239, 8, 25, 46, 208, 136, 168, 11, 195, 256, 29, 187, 231, 240, 236, 95, 72, 225, 157, 73, 196, 227, 99, 213, 248, 4, 141, 23, 104, 68, 84, 134, 226, 128, 143, 222, 244, 120, 118, 176, 36, 241, 207, 165, 98, 242, 178, 235, 124, 2, 199, 140, 52, 34, 42, 67, 113, 64, 200, 111, 122, 60, 59, 88, 18, 249, 232, 211, 49, 121, 89, 246, 62, 1],
+[1, 229, 13, 150, 169, 151, 141, 164, 34, 76, 185, 217, 92, 251, 168, 179, 128, 14, 122, 182, 44, 53, 58, 175, 240, 219, 36, 20, 211, 3, 173, 39, 193, 250, 196, 166, 235, 102, 228, 41, 137, 19, 239, 247, 23, 127, 42, 109, 32, 132, 159, 174, 11, 206, 143, 108, 60, 119, 9, 5, 117, 65, 236, 74, 241, 191, 49, 170, 123, 154, 57, 203, 227, 69, 124, 126, 70, 96, 139, 220, 8, 33, 104, 172, 67, 180, 100, 27, 15, 94, 195, 194, 222, 209, 59, 147, 253, 112, 205, 171, 95, 167, 207, 115, 121, 210, 31, 160, 146, 24, 99, 55, 2, 201, 26, 43, 81, 45, 25, 71, 68, 152, 113, 177, 184, 245, 79, 101, 256, 28, 244, 107, 88, 106, 116, 93, 223, 181, 72, 40, 165, 6, 89, 78, 129, 243, 135, 75, 213, 204, 199, 82, 17, 38, 221, 237, 46, 254, 84, 218, 64, 7, 61, 91, 22, 155, 29, 216, 120, 238, 18, 10, 234, 130, 215, 148, 225, 125, 98, 83, 246, 51, 114, 149, 197, 138, 248, 252, 140, 192, 21, 183, 16, 66, 208, 87, 134, 103, 200, 54, 30, 188, 133, 131, 187, 161, 118, 37, 249, 224, 153, 85, 190, 77, 157, 230, 242, 163, 62, 63, 35, 48, 198, 110, 4, 145, 52, 86, 162, 90, 50, 142, 136, 47, 226, 97, 111, 233, 158, 202, 255, 56, 231, 214, 176, 212, 232, 186, 189, 105, 144, 80, 73, 12, 178, 156, 1],
+[1, 230, 215, 106, 222, 174, 185, 145, 197, 78, 207, 65, 44, 97, 208, 38, 2, 203, 173, 212, 187, 91, 113, 33, 137, 156, 157, 130, 88, 194, 159, 76, 4, 149, 89, 167, 117, 182, 226, 66, 17, 55, 57, 3, 176, 131, 61, 152, 8, 41, 178, 77, 234, 107, 195, 132, 34, 110, 114, 6, 95, 5, 122, 47, 16, 82, 99, 154, 211, 214, 133, 7, 68, 220, 228, 12, 190, 10, 244, 94, 32, 164, 198, 51, 165, 171, 9, 14, 136, 183, 199, 24, 123, 20, 231, 188, 64, 71, 139, 102, 73, 85, 18, 28, 15, 109, 141, 48, 246, 40, 205, 119, 128, 142, 21, 204, 146, 170, 36, 56, 30, 218, 25, 96, 235, 80, 153, 238, 256, 27, 42, 151, 35, 83, 72, 112, 60, 179, 50, 192, 213, 160, 49, 219, 255, 54, 84, 45, 70, 166, 144, 224, 120, 101, 100, 127, 169, 63, 98, 181, 253, 108, 168, 90, 140, 75, 31, 191, 240, 202, 200, 254, 81, 126, 196, 105, 249, 216, 79, 180, 23, 150, 62, 125, 223, 147, 143, 251, 162, 252, 135, 210, 241, 175, 158, 103, 46, 43, 124, 250, 189, 37, 29, 245, 67, 247, 13, 163, 225, 93, 59, 206, 92, 86, 248, 243, 121, 74, 58, 233, 134, 237, 26, 69, 193, 186, 118, 155, 184, 172, 239, 229, 242, 148, 116, 209, 11, 217, 52, 138, 129, 115, 236, 53, 111, 87, 221, 201, 227, 39, 232, 161, 22, 177, 104, 19, 1],
+[1, 231, 162, 157, 30, 248, 234, 84, 129, 244, 81, 207, 15, 124, 117, 42, 193, 122, 169, 232, 136, 62, 187, 21, 225, 61, 213, 116, 68, 31, 222, 139, 241, 159, 235, 58, 34, 144, 111, 198, 249, 208, 246, 29, 17, 72, 184, 99, 253, 104, 123, 143, 137, 36, 92, 178, 255, 52, 190, 200, 197, 18, 46, 89, 256, 26, 95, 100, 227, 9, 23, 173, 128, 13, 176, 50, 242, 133, 140, 215, 64, 135, 88, 25, 121, 195, 70, 236, 32, 196, 44, 141, 189, 226, 35, 118, 16, 98, 22, 199, 223, 113, 146, 59, 8, 49, 11, 228, 240, 185, 73, 158, 4, 153, 134, 114, 120, 221, 165, 79, 2, 205, 67, 57, 60, 239, 211, 168, 1, 231, 162, 157, 30, 248, 234, 84, 129, 244, 81, 207, 15, 124, 117, 42, 193, 122, 169, 232, 136, 62, 187, 21, 225, 61, 213, 116, 68, 31, 222, 139, 241, 159, 235, 58, 34, 144, 111, 198, 249, 208, 246, 29, 17, 72, 184, 99, 253, 104, 123, 143, 137, 36, 92, 178, 255, 52, 190, 200, 197, 18, 46, 89, 256, 26, 95, 100, 227, 9, 23, 173, 128, 13, 176, 50, 242, 133, 140, 215, 64, 135, 88, 25, 121, 195, 70, 236, 32, 196, 44, 141, 189, 226, 35, 118, 16, 98, 22, 199, 223, 113, 146, 59, 8, 49, 11, 228, 240, 185, 73, 158, 4, 153, 134, 114, 120, 221, 165, 79, 2, 205, 67, 57, 60, 239, 211, 168, 1],
+[1, 232, 111, 52, 242, 118, 134, 248, 225, 29, 46, 135, 223, 79, 81, 31, 253, 100, 70, 49, 60, 42, 235, 36, 128, 141, 73, 231, 136, 198, 190, 133, 16, 114, 234, 61, 17, 89, 88, 113, 2, 207, 222, 104, 227, 236, 11, 239, 193, 58, 92, 13, 189, 158, 162, 62, 249, 200, 140, 98, 120, 84, 213, 72, 256, 25, 146, 205, 15, 139, 123, 9, 32, 228, 211, 122, 34, 178, 176, 226, 4, 157, 187, 208, 197, 215, 22, 221, 129, 116, 184, 26, 121, 59, 67, 124, 241, 143, 23, 196, 240, 168, 169, 144, 255, 50, 35, 153, 30, 21, 246, 18, 64, 199, 165, 244, 68, 99, 95, 195, 8, 57, 117, 159, 137, 173, 44, 185, 1, 232, 111, 52, 242, 118, 134, 248, 225, 29, 46, 135, 223, 79, 81, 31, 253, 100, 70, 49, 60, 42, 235, 36, 128, 141, 73, 231, 136, 198, 190, 133, 16, 114, 234, 61, 17, 89, 88, 113, 2, 207, 222, 104, 227, 236, 11, 239, 193, 58, 92, 13, 189, 158, 162, 62, 249, 200, 140, 98, 120, 84, 213, 72, 256, 25, 146, 205, 15, 139, 123, 9, 32, 228, 211, 122, 34, 178, 176, 226, 4, 157, 187, 208, 197, 215, 22, 221, 129, 116, 184, 26, 121, 59, 67, 124, 241, 143, 23, 196, 240, 168, 169, 144, 255, 50, 35, 153, 30, 21, 246, 18, 64, 199, 165, 244, 68, 99, 95, 195, 8, 57, 117, 159, 137, 173, 44, 185, 1],
+[1, 233, 62, 54, 246, 7, 89, 177, 121, 180, 49, 109, 211, 76, 232, 86, 249, 192, 18, 82, 88, 201, 59, 126, 60, 102, 122, 156, 111, 163, 200, 83, 64, 6, 113, 115, 67, 191, 42, 20, 34, 212, 52, 37, 140, 238, 199, 107, 2, 209, 124, 108, 235, 14, 178, 97, 242, 103, 98, 218, 165, 152, 207, 172, 241, 127, 36, 164, 176, 145, 118, 252, 120, 204, 244, 55, 222, 69, 143, 166, 128, 12, 226, 230, 134, 125, 84, 40, 68, 167, 104, 74, 23, 219, 141, 214, 4, 161, 248, 216, 213, 28, 99, 194, 227, 206, 196, 179, 73, 47, 157, 87, 225, 254, 72, 71, 95, 33, 236, 247, 240, 151, 231, 110, 187, 138, 29, 75, 256, 24, 195, 203, 11, 250, 168, 80, 136, 77, 208, 148, 46, 181, 25, 171, 8, 65, 239, 175, 169, 56, 198, 131, 197, 155, 135, 101, 146, 94, 57, 174, 193, 251, 144, 142, 190, 66, 215, 237, 223, 45, 205, 220, 117, 19, 58, 150, 255, 48, 133, 149, 22, 243, 79, 160, 15, 154, 159, 39, 92, 105, 50, 85, 16, 130, 221, 93, 81, 112, 139, 5, 137, 53, 13, 202, 35, 188, 114, 91, 129, 245, 31, 27, 123, 132, 173, 217, 189, 90, 153, 183, 234, 38, 116, 43, 253, 96, 9, 41, 44, 229, 158, 63, 30, 51, 61, 78, 184, 210, 100, 170, 32, 3, 185, 186, 162, 224, 21, 10, 17, 106, 26, 147, 70, 119, 228, 182, 1],
+[1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1],
+[1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1],
+[1, 236, 184, 248, 189, 143, 81, 98, 255, 42, 146, 18, 136, 228, 95, 61, 4, 173, 222, 221, 242, 58, 67, 135, 249, 168, 70, 72, 30, 141, 123, 244, 16, 178, 117, 113, 197, 232, 11, 26, 225, 158, 23, 31, 120, 50, 235, 205, 64, 198, 211, 195, 17, 157, 44, 104, 129, 118, 92, 124, 223, 200, 169, 49, 256, 21, 73, 9, 68, 114, 176, 159, 2, 215, 111, 239, 121, 29, 162, 196, 253, 84, 35, 36, 15, 199, 190, 122, 8, 89, 187, 185, 227, 116, 134, 13, 241, 79, 140, 144, 60, 25, 246, 231, 32, 99, 234, 226, 137, 207, 22, 52, 193, 59, 46, 62, 240, 100, 213, 153, 128, 139, 165, 133, 34, 57, 88, 208, 1, 236, 184, 248, 189, 143, 81, 98, 255, 42, 146, 18, 136, 228, 95, 61, 4, 173, 222, 221, 242, 58, 67, 135, 249, 168, 70, 72, 30, 141, 123, 244, 16, 178, 117, 113, 197, 232, 11, 26, 225, 158, 23, 31, 120, 50, 235, 205, 64, 198, 211, 195, 17, 157, 44, 104, 129, 118, 92, 124, 223, 200, 169, 49, 256, 21, 73, 9, 68, 114, 176, 159, 2, 215, 111, 239, 121, 29, 162, 196, 253, 84, 35, 36, 15, 199, 190, 122, 8, 89, 187, 185, 227, 116, 134, 13, 241, 79, 140, 144, 60, 25, 246, 231, 32, 99, 234, 226, 137, 207, 22, 52, 193, 59, 46, 62, 240, 100, 213, 153, 128, 139, 165, 133, 34, 57, 88, 208, 1],
+[1, 237, 143, 224, 146, 164, 61, 65, 242, 43, 168, 238, 123, 110, 113, 53, 225, 126, 50, 28, 211, 149, 104, 233, 223, 166, 21, 94, 176, 78, 239, 103, 253, 80, 199, 132, 187, 115, 13, 254, 60, 85, 99, 76, 22, 74, 62, 45, 128, 10, 57, 145, 184, 175, 98, 96, 136, 107, 173, 138, 67, 202, 72, 102, 16, 194, 232, 243, 23, 54, 205, 12, 17, 174, 118, 210, 169, 218, 9, 77, 2, 217, 29, 191, 35, 71, 122, 130, 227, 86, 79, 219, 246, 220, 226, 106, 193, 252, 100, 56, 165, 41, 208, 209, 189, 75, 42, 188, 95, 156, 221, 206, 249, 160, 141, 7, 117, 230, 26, 251, 120, 170, 198, 152, 44, 148, 124, 90, 256, 20, 114, 33, 111, 93, 196, 192, 15, 214, 89, 19, 134, 147, 144, 204, 32, 131, 207, 229, 46, 108, 153, 24, 34, 91, 236, 163, 81, 179, 18, 154, 4, 177, 58, 125, 70, 142, 244, 3, 197, 172, 158, 181, 235, 183, 195, 212, 129, 247, 200, 112, 73, 82, 159, 161, 121, 150, 84, 119, 190, 55, 185, 155, 241, 63, 25, 14, 234, 203, 52, 245, 240, 83, 139, 47, 88, 39, 248, 180, 255, 40, 228, 66, 222, 186, 135, 127, 30, 171, 178, 38, 11, 37, 31, 151, 64, 5, 157, 201, 92, 216, 49, 48, 68, 182, 215, 69, 162, 101, 36, 51, 8, 97, 116, 250, 140, 27, 231, 6, 137, 87, 59, 105, 213, 109, 133, 167, 1],
+[1, 238, 104, 80, 22, 96, 232, 218, 227, 56, 221, 170, 111, 204, 236, 142, 129, 119, 52, 40, 11, 48, 116, 109, 242, 28, 239, 85, 184, 102, 118, 71, 193, 188, 26, 20, 134, 24, 58, 183, 121, 14, 248, 171, 92, 51, 59, 164, 225, 94, 13, 10, 67, 12, 29, 220, 189, 7, 124, 214, 46, 154, 158, 82, 241, 47, 135, 5, 162, 6, 143, 110, 223, 132, 62, 107, 23, 77, 79, 41, 249, 152, 196, 131, 81, 3, 200, 55, 240, 66, 31, 182, 140, 167, 168, 149, 253, 76, 98, 194, 169, 130, 100, 156, 120, 33, 144, 91, 70, 212, 84, 203, 255, 38, 49, 97, 213, 65, 50, 78, 60, 145, 72, 174, 35, 106, 42, 230, 256, 19, 153, 177, 235, 161, 25, 39, 30, 201, 36, 87, 146, 53, 21, 115, 128, 138, 205, 217, 246, 209, 141, 148, 15, 229, 18, 172, 73, 155, 139, 186, 64, 69, 231, 237, 123, 233, 199, 74, 136, 243, 9, 86, 165, 206, 198, 93, 32, 163, 244, 247, 190, 245, 228, 37, 68, 250, 133, 43, 211, 103, 99, 175, 16, 210, 122, 252, 95, 251, 114, 147, 34, 125, 195, 150, 234, 180, 178, 216, 8, 105, 61, 126, 176, 254, 57, 202, 17, 191, 226, 75, 117, 90, 89, 108, 4, 181, 159, 63, 88, 127, 157, 101, 137, 224, 113, 166, 187, 45, 173, 54, 2, 219, 208, 160, 44, 192, 207, 179, 197, 112, 185, 83, 222, 151, 215, 27, 1],
+[1, 239, 67, 79, 120, 153, 73, 228, 8, 113, 22, 118, 189, 196, 70, 25, 64, 133, 176, 173, 227, 26, 46, 200, 255, 36, 123, 99, 17, 208, 111, 58, 241, 31, 213, 21, 136, 122, 117, 207, 129, 248, 162, 168, 60, 205, 165, 114, 4, 185, 11, 59, 223, 98, 35, 141, 32, 195, 88, 215, 242, 13, 23, 100, 256, 18, 190, 178, 137, 104, 184, 29, 249, 144, 235, 139, 68, 61, 187, 232, 193, 124, 81, 84, 30, 231, 211, 57, 2, 221, 134, 158, 240, 49, 146, 199, 16, 226, 44, 236, 121, 135, 140, 50, 128, 9, 95, 89, 197, 52, 92, 143, 253, 72, 246, 198, 34, 159, 222, 116, 225, 62, 169, 42, 15, 244, 234, 157, 1, 239, 67, 79, 120, 153, 73, 228, 8, 113, 22, 118, 189, 196, 70, 25, 64, 133, 176, 173, 227, 26, 46, 200, 255, 36, 123, 99, 17, 208, 111, 58, 241, 31, 213, 21, 136, 122, 117, 207, 129, 248, 162, 168, 60, 205, 165, 114, 4, 185, 11, 59, 223, 98, 35, 141, 32, 195, 88, 215, 242, 13, 23, 100, 256, 18, 190, 178, 137, 104, 184, 29, 249, 144, 235, 139, 68, 61, 187, 232, 193, 124, 81, 84, 30, 231, 211, 57, 2, 221, 134, 158, 240, 49, 146, 199, 16, 226, 44, 236, 121, 135, 140, 50, 128, 9, 95, 89, 197, 52, 92, 143, 253, 72, 246, 198, 34, 159, 222, 116, 225, 62, 169, 42, 15, 244, 234, 157, 1],
+[1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1],
+[1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1],
+[1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1],
+[1, 243, 196, 83, 123, 77, 207, 186, 223, 219, 18, 5, 187, 209, 158, 101, 128, 7, 159, 87, 67, 90, 25, 164, 17, 19, 248, 126, 35, 24, 178, 78, 193, 125, 49, 85, 95, 212, 116, 175, 120, 119, 133, 194, 111, 245, 168, 218, 32, 66, 104, 86, 81, 151, 199, 41, 197, 69, 62, 160, 73, 6, 173, 148, 241, 224, 205, 214, 88, 53, 29, 108, 30, 94, 226, 177, 92, 254, 42, 183, 8, 145, 26, 150, 213, 102, 114, 203, 242, 210, 144, 40, 211, 130, 236, 37, 253, 56, 244, 182, 22, 206, 200, 27, 136, 152, 185, 237, 23, 192, 139, 110, 2, 229, 135, 166, 246, 154, 157, 115, 189, 181, 36, 10, 117, 161, 59, 202, 256, 14, 61, 174, 134, 180, 50, 71, 34, 38, 239, 252, 70, 48, 99, 156, 129, 250, 98, 170, 190, 167, 232, 93, 240, 238, 9, 131, 222, 233, 79, 179, 64, 132, 208, 172, 162, 45, 141, 82, 137, 138, 124, 63, 146, 12, 89, 39, 225, 191, 153, 171, 176, 106, 58, 216, 60, 188, 195, 97, 184, 251, 84, 109, 16, 33, 52, 43, 169, 204, 228, 149, 227, 163, 31, 80, 165, 3, 215, 74, 249, 112, 231, 107, 44, 155, 143, 54, 15, 47, 113, 217, 46, 127, 21, 220, 4, 201, 13, 75, 235, 51, 57, 230, 121, 105, 72, 20, 234, 65, 118, 147, 255, 28, 122, 91, 11, 103, 100, 142, 68, 76, 221, 247, 140, 96, 198, 55, 1],
+[1, 244, 169, 116, 34, 72, 92, 89, 128, 135, 44, 199, 240, 221, 211, 84, 193, 61, 235, 29, 137, 18, 23, 215, 32, 98, 11, 114, 60, 248, 117, 21, 241, 208, 123, 200, 227, 133, 70, 118, 8, 153, 67, 157, 15, 62, 222, 198, 253, 52, 95, 50, 121, 226, 146, 158, 2, 231, 81, 232, 68, 144, 184, 178, 256, 13, 88, 141, 223, 185, 165, 168, 129, 122, 213, 58, 17, 36, 46, 173, 64, 196, 22, 228, 120, 239, 234, 42, 225, 159, 246, 143, 197, 9, 140, 236, 16, 49, 134, 57, 30, 124, 187, 139, 249, 104, 190, 100, 242, 195, 35, 59, 4, 205, 162, 207, 136, 31, 111, 99, 255, 26, 176, 25, 189, 113, 73, 79, 1, 244, 169, 116, 34, 72, 92, 89, 128, 135, 44, 199, 240, 221, 211, 84, 193, 61, 235, 29, 137, 18, 23, 215, 32, 98, 11, 114, 60, 248, 117, 21, 241, 208, 123, 200, 227, 133, 70, 118, 8, 153, 67, 157, 15, 62, 222, 198, 253, 52, 95, 50, 121, 226, 146, 158, 2, 231, 81, 232, 68, 144, 184, 178, 256, 13, 88, 141, 223, 185, 165, 168, 129, 122, 213, 58, 17, 36, 46, 173, 64, 196, 22, 228, 120, 239, 234, 42, 225, 159, 246, 143, 197, 9, 140, 236, 16, 49, 134, 57, 30, 124, 187, 139, 249, 104, 190, 100, 242, 195, 35, 59, 4, 205, 162, 207, 136, 31, 111, 99, 255, 26, 176, 25, 189, 113, 73, 79, 1],
+[1, 245, 144, 71, 176, 201, 158, 160, 136, 167, 52, 147, 35, 94, 157, 172, 249, 96, 133, 203, 134, 191, 21, 5, 197, 206, 98, 109, 234, 19, 29, 166, 64, 3, 221, 175, 213, 14, 89, 217, 223, 151, 244, 156, 184, 105, 25, 214, 2, 233, 31, 142, 95, 145, 59, 63, 15, 77, 104, 37, 70, 188, 57, 87, 241, 192, 9, 149, 11, 125, 42, 10, 137, 155, 196, 218, 211, 38, 58, 75, 128, 6, 185, 93, 169, 28, 178, 177, 189, 45, 231, 55, 111, 210, 50, 171, 4, 209, 62, 27, 190, 33, 118, 126, 30, 154, 208, 74, 140, 119, 114, 174, 225, 127, 18, 41, 22, 250, 84, 20, 17, 53, 135, 179, 165, 76, 116, 150, 256, 12, 113, 186, 81, 56, 99, 97, 121, 90, 205, 110, 222, 163, 100, 85, 8, 161, 124, 54, 123, 66, 236, 252, 60, 51, 159, 148, 23, 238, 228, 91, 193, 254, 36, 82, 44, 243, 168, 40, 34, 106, 13, 101, 73, 152, 232, 43, 255, 24, 226, 115, 162, 112, 198, 194, 242, 180, 153, 220, 187, 69, 200, 170, 16, 65, 248, 108, 246, 132, 215, 247, 120, 102, 61, 39, 46, 219, 199, 182, 129, 251, 72, 164, 88, 229, 79, 80, 68, 212, 26, 202, 146, 47, 207, 86, 253, 48, 195, 230, 67, 224, 139, 131, 227, 103, 49, 183, 117, 138, 143, 83, 32, 130, 239, 216, 235, 7, 173, 237, 240, 204, 122, 78, 92, 181, 141, 107, 1],
+[1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1],
+[1, 247, 100, 28, 234, 230, 13, 127, 15, 107, 215, 163, 169, 109, 195, 106, 225, 63, 141, 132, 222, 93, 98, 48, 34, 174, 59, 181, 246, 110, 185, 206, 253, 40, 114, 145, 92, 108, 205, 6, 197, 86, 168, 119, 95, 78, 248, 90, 128, 5, 207, 243, 140, 142, 122, 65, 121, 75, 21, 47, 44, 74, 31, 204, 16, 97, 58, 191, 146, 82, 208, 233, 240, 170, 99, 38, 134, 202, 36, 154, 2, 237, 200, 56, 211, 203, 26, 254, 30, 214, 173, 69, 81, 218, 133, 212, 193, 126, 25, 7, 187, 186, 196, 96, 68, 91, 118, 105, 235, 220, 113, 155, 249, 80, 228, 33, 184, 216, 153, 12, 137, 172, 79, 238, 190, 156, 239, 180, 256, 10, 157, 229, 23, 27, 244, 130, 242, 150, 42, 94, 88, 148, 62, 151, 32, 194, 116, 125, 35, 164, 159, 209, 223, 83, 198, 76, 11, 147, 72, 51, 4, 217, 143, 112, 165, 149, 52, 251, 60, 171, 89, 138, 162, 179, 9, 167, 129, 252, 50, 14, 117, 115, 135, 192, 136, 182, 236, 210, 213, 183, 226, 53, 241, 160, 199, 66, 111, 175, 49, 24, 17, 87, 158, 219, 123, 55, 221, 103, 255, 20, 57, 201, 46, 54, 231, 3, 227, 43, 84, 188, 176, 39, 124, 45, 64, 131, 232, 250, 70, 71, 61, 161, 189, 166, 139, 152, 22, 37, 144, 102, 8, 177, 29, 224, 73, 41, 104, 245, 120, 85, 178, 19, 67, 101, 18, 77, 1],
+[1, 248, 81, 42, 136, 61, 222, 58, 249, 72, 123, 178, 197, 26, 23, 50, 64, 195, 44, 118, 223, 49, 73, 114, 2, 239, 162, 84, 15, 122, 187, 116, 241, 144, 246, 99, 137, 52, 46, 100, 128, 133, 88, 236, 189, 98, 146, 228, 4, 221, 67, 168, 30, 244, 117, 232, 225, 31, 235, 198, 17, 104, 92, 200, 256, 9, 176, 215, 121, 196, 35, 199, 8, 185, 134, 79, 60, 231, 234, 207, 193, 62, 213, 139, 34, 208, 184, 143, 255, 18, 95, 173, 242, 135, 70, 141, 16, 113, 11, 158, 120, 205, 211, 157, 129, 124, 169, 21, 68, 159, 111, 29, 253, 36, 190, 89, 227, 13, 140, 25, 32, 226, 22, 59, 240, 153, 165, 57, 1, 248, 81, 42, 136, 61, 222, 58, 249, 72, 123, 178, 197, 26, 23, 50, 64, 195, 44, 118, 223, 49, 73, 114, 2, 239, 162, 84, 15, 122, 187, 116, 241, 144, 246, 99, 137, 52, 46, 100, 128, 133, 88, 236, 189, 98, 146, 228, 4, 221, 67, 168, 30, 244, 117, 232, 225, 31, 235, 198, 17, 104, 92, 200, 256, 9, 176, 215, 121, 196, 35, 199, 8, 185, 134, 79, 60, 231, 234, 207, 193, 62, 213, 139, 34, 208, 184, 143, 255, 18, 95, 173, 242, 135, 70, 141, 16, 113, 11, 158, 120, 205, 211, 157, 129, 124, 169, 21, 68, 159, 111, 29, 253, 36, 190, 89, 227, 13, 140, 25, 32, 226, 22, 59, 240, 153, 165, 57, 1],
+[1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1],
+[1, 250, 49, 171, 88, 155, 200, 142, 34, 19, 124, 160, 165, 130, 118, 202, 128, 132, 104, 43, 213, 51, 157, 186, 240, 119, 195, 177, 46, 192, 198, 156, 193, 191, 205, 107, 22, 103, 50, 164, 137, 69, 31, 40, 234, 161, 158, 179, 32, 33, 26, 75, 246, 77, 232, 175, 60, 94, 113, 237, 140, 48, 178, 39, 241, 112, 244, 91, 134, 90, 141, 41, 227, 210, 72, 10, 187, 233, 168, 109, 8, 201, 135, 83, 190, 212, 58, 108, 15, 152, 221, 252, 35, 12, 173, 74, 253, 28, 61, 87, 162, 151, 228, 203, 121, 181, 18, 131, 111, 251, 42, 220, 2, 243, 98, 85, 176, 53, 143, 27, 68, 38, 248, 63, 73, 3, 236, 147, 256, 7, 208, 86, 169, 102, 57, 115, 223, 238, 133, 97, 92, 127, 139, 55, 129, 125, 153, 214, 44, 206, 100, 71, 17, 138, 62, 80, 211, 65, 59, 101, 64, 66, 52, 150, 235, 154, 207, 93, 120, 188, 226, 217, 23, 96, 99, 78, 225, 224, 231, 182, 11, 180, 25, 82, 197, 163, 144, 20, 117, 209, 79, 218, 16, 145, 13, 166, 123, 167, 116, 216, 30, 47, 185, 247, 70, 24, 89, 148, 249, 56, 122, 174, 67, 45, 199, 149, 242, 105, 36, 5, 222, 245, 84, 183, 4, 229, 196, 170, 95, 106, 29, 54, 136, 76, 239, 126, 146, 6, 215, 37, 255, 14, 159, 172, 81, 204, 114, 230, 189, 219, 9, 194, 184, 254, 21, 110, 1],
+[1, 251, 36, 41, 11, 191, 139, 194, 121, 45, 244, 78, 46, 238, 114, 87, 249, 48, 226, 186, 169, 14, 173, 247, 60, 154, 104, 147, 146, 152, 116, 75, 64, 130, 248, 54, 190, 145, 158, 80, 34, 53, 196, 109, 117, 69, 100, 171, 2, 245, 72, 82, 22, 125, 21, 131, 242, 90, 231, 156, 92, 219, 228, 174, 241, 96, 195, 115, 81, 28, 89, 237, 120, 51, 208, 37, 35, 47, 232, 150, 128, 3, 239, 108, 123, 33, 59, 160, 68, 106, 135, 218, 234, 138, 200, 85, 4, 233, 144, 164, 44, 250, 42, 5, 227, 180, 205, 55, 184, 181, 199, 91, 225, 192, 133, 230, 162, 56, 178, 217, 240, 102, 159, 74, 70, 94, 207, 43, 256, 6, 221, 216, 246, 66, 118, 63, 136, 212, 13, 179, 211, 19, 143, 170, 8, 209, 31, 71, 88, 243, 84, 10, 197, 103, 153, 110, 111, 105, 141, 182, 193, 127, 9, 203, 67, 112, 99, 177, 223, 204, 61, 148, 140, 188, 157, 86, 255, 12, 185, 175, 235, 132, 236, 126, 15, 167, 26, 101, 165, 38, 29, 83, 16, 161, 62, 142, 176, 229, 168, 20, 137, 206, 49, 220, 222, 210, 25, 107, 129, 254, 18, 149, 134, 224, 198, 97, 189, 151, 122, 39, 23, 119, 57, 172, 253, 24, 113, 93, 213, 7, 215, 252, 30, 77, 52, 202, 73, 76, 58, 166, 32, 65, 124, 27, 95, 201, 79, 40, 17, 155, 98, 183, 187, 163, 50, 214, 1],
+[1, 252, 25, 132, 111, 216, 205, 3, 242, 75, 139, 76, 134, 101, 9, 212, 225, 160, 228, 145, 46, 27, 122, 161, 223, 170, 178, 138, 81, 109, 226, 155, 253, 20, 157, 243, 70, 164, 208, 245, 60, 214, 215, 210, 235, 110, 221, 180, 128, 131, 116, 191, 73, 149, 26, 127, 136, 91, 59, 219, 190, 78, 124, 151, 16, 177, 143, 56, 234, 115, 196, 48, 17, 172, 168, 188, 88, 74, 144, 51, 2, 247, 50, 7, 222, 175, 153, 6, 227, 150, 21, 152, 11, 202, 18, 167, 193, 63, 199, 33, 92, 54, 244, 65, 189, 83, 99, 19, 162, 218, 195, 53, 249, 40, 57, 229, 140, 71, 159, 233, 120, 171, 173, 163, 213, 220, 185, 103, 256, 5, 232, 125, 146, 41, 52, 254, 15, 182, 118, 181, 123, 156, 248, 45, 32, 97, 29, 112, 211, 230, 135, 96, 34, 87, 79, 119, 176, 148, 31, 102, 4, 237, 100, 14, 187, 93, 49, 12, 197, 43, 42, 47, 22, 147, 36, 77, 129, 126, 141, 66, 184, 108, 231, 130, 121, 166, 198, 38, 67, 179, 133, 106, 241, 80, 114, 201, 23, 142, 61, 209, 240, 85, 89, 69, 169, 183, 113, 206, 255, 10, 207, 250, 35, 82, 104, 251, 30, 107, 236, 105, 246, 55, 239, 90, 64, 194, 58, 224, 165, 203, 13, 192, 68, 174, 158, 238, 95, 39, 62, 204, 8, 217, 200, 28, 117, 186, 98, 24, 137, 86, 84, 94, 44, 37, 72, 154, 1],
+[1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1],
+[1, 254, 9, 230, 81, 14, 215, 126, 136, 106, 196, 183, 222, 105, 199, 174, 249, 24, 185, 216, 123, 145, 79, 20, 197, 180, 231, 78, 23, 188, 207, 150, 64, 65, 62, 71, 44, 125, 139, 97, 223, 102, 208, 147, 73, 38, 143, 85, 2, 251, 18, 203, 162, 28, 173, 252, 15, 212, 135, 109, 187, 210, 141, 91, 241, 48, 113, 175, 246, 33, 158, 40, 137, 103, 205, 156, 46, 119, 157, 43, 128, 130, 124, 142, 88, 250, 21, 194, 189, 204, 159, 37, 146, 76, 29, 170, 4, 245, 36, 149, 67, 56, 89, 247, 30, 167, 13, 218, 117, 163, 25, 182, 225, 96, 226, 93, 235, 66, 59, 80, 17, 206, 153, 55, 92, 238, 57, 86, 256, 3, 248, 27, 176, 243, 42, 131, 121, 151, 61, 74, 35, 152, 58, 83, 8, 233, 72, 41, 134, 112, 178, 237, 60, 77, 26, 179, 234, 69, 50, 107, 193, 192, 195, 186, 213, 132, 118, 160, 34, 155, 49, 110, 184, 219, 114, 172, 255, 6, 239, 54, 95, 229, 84, 5, 242, 45, 122, 148, 70, 47, 116, 166, 16, 209, 144, 82, 11, 224, 99, 217, 120, 154, 52, 101, 211, 138, 100, 214, 129, 127, 133, 115, 169, 7, 236, 63, 68, 53, 98, 220, 111, 181, 228, 87, 253, 12, 221, 108, 190, 201, 168, 10, 227, 90, 244, 39, 140, 94, 232, 75, 32, 161, 31, 164, 22, 191, 198, 177, 240, 51, 104, 202, 165, 19, 200, 171, 1],
+[1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1],
+[1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1],
+];
+
+fn main(x: Field, y: pub Field) {
+    let mut acc: Field = 0;
+    for i in 0..257 {
+        for j in 0..257 {
+            acc += EXPONENTIATE[i][j];
+        }
+    }
+    assert(!acc.lt(x));
+    assert(x != y);
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 8f49fe273e1..5e6ce18be54 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -18,3 +18,4 @@ fold_call_witness_condition
 fold_after_inlined_calls
 fold_numeric_generic_poseidon
 inline_never_basic
+regression_4709

From a2fb3dc77e8d748b77dcabcf26bb82bb5ae1ca76 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 26 Apr 2024 19:14:09 +0100
Subject: [PATCH 231/416] chore: add regression test for #3051 (#4815)

# Description

## Problem\*

Resolves #3051

## Summary\*

This issue has been fixed and so I'm added a regression test.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../regression_3051/Nargo.toml                |  7 ++++++
 .../regression_3051/src/main.nr               | 24 +++++++++++++++++++
 2 files changed, 31 insertions(+)
 create mode 100644 test_programs/execution_success/regression_3051/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_3051/src/main.nr

diff --git a/test_programs/execution_success/regression_3051/Nargo.toml b/test_programs/execution_success/regression_3051/Nargo.toml
new file mode 100644
index 00000000000..844f74cdcb3
--- /dev/null
+++ b/test_programs/execution_success/regression_3051/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_3051"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_3051/src/main.nr b/test_programs/execution_success/regression_3051/src/main.nr
new file mode 100644
index 00000000000..2e7d10fd7b0
--- /dev/null
+++ b/test_programs/execution_success/regression_3051/src/main.nr
@@ -0,0 +1,24 @@
+trait Foo {
+    fn foo(self) -> Field;
+}
+
+impl Foo for Field {
+    fn foo(self) -> Field {
+        self + 1
+    }
+}
+
+trait Bar {
+    fn bar(self) -> u64;
+}
+
+impl Bar for u64 {
+    fn bar(self) -> u64 {
+        self + 1
+    }
+}
+
+fn main() {
+    dep::std::println(1.foo());
+    dep::std::println(1.bar());
+}

From 800f670b63a5a2ae08f09a86dae767089f7f67af Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Fri, 26 Apr 2024 14:44:50 -0400
Subject: [PATCH 232/416] fix: ban self-referential structs (#4883)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/3490

## Summary\*

Directly referencing the current struct within its definition currently
fails with a stack overflow.

This PR makes it a normal error, by keeping track of the
currently-resolving structs and ensuring no field resolves to them.

## Additional Context

Mutual recursion is already handled.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../src/hir/resolution/errors.rs              |  9 ++++++
 .../src/hir/resolution/resolver.rs            | 29 ++++++++++++++++++-
 compiler/noirc_frontend/src/tests.rs          |  2 +-
 .../self_referential_struct/Nargo.toml        |  7 +++++
 .../self_referential_struct/src/main.nr       | 11 +++++++
 5 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/compile_failure/self_referential_struct/Nargo.toml
 create mode 100644 test_programs/compile_failure/self_referential_struct/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 70e7a8e40f2..b6bcfe6972e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -86,6 +86,8 @@ pub enum ResolverError {
     JumpInConstrainedFn { is_break: bool, span: Span },
     #[error("break/continue are only allowed within loops")]
     JumpOutsideLoop { is_break: bool, span: Span },
+    #[error("Self-referential structs are not supported")]
+    SelfReferentialStruct { span: Span },
     #[error("#[inline(tag)] attribute is only allowed on constrained functions")]
     InlineAttributeOnUnconstrained { ident: Ident },
     #[error("#[fold] attribute is only allowed on constrained functions")]
@@ -344,6 +346,13 @@ impl From<ResolverError> for Diagnostic {
                     span,
                 )
             },
+            ResolverError::SelfReferentialStruct { span } => {
+                Diagnostic::simple_error(
+                    "Self-referential structs are not supported".into(),
+                    "".into(),
+                    span,
+                )
+            },
             ResolverError::InlineAttributeOnUnconstrained { ident } => {
                 let name = &ident.0.contents;
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index b17cd50564e..e3b1251955c 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -22,7 +22,7 @@ use crate::hir_def::traits::{Trait, TraitConstraint};
 use crate::macros_api::SecondaryAttribute;
 use crate::token::{Attributes, FunctionAttribute};
 use regex::Regex;
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::rc::Rc;
 
 use crate::ast::{
@@ -96,6 +96,21 @@ pub struct Resolver<'a> {
     /// Used to link items to their dependencies in the dependency graph
     current_item: Option<DependencyId>,
 
+    /// In-resolution names
+    ///
+    /// This needs to be a set because we can have multiple in-resolution
+    /// names when resolving structs that are declared in reverse order of their
+    /// dependencies, such as in the following case:
+    ///
+    /// ```
+    /// struct Wrapper {
+    ///     value: Wrapped
+    /// }
+    /// struct Wrapped {
+    /// }
+    /// ```
+    resolving_ids: BTreeSet<StructId>,
+
     /// True if the current module is a contract.
     /// This is usually determined by self.path_resolver.module_id(), but it can
     /// be overridden for impls. Impls are an odd case since the methods within resolve
@@ -159,6 +174,7 @@ impl<'a> Resolver<'a> {
             lambda_stack: Vec::new(),
             current_trait_impl: None,
             current_item: None,
+            resolving_ids: BTreeSet::new(),
             file,
             in_contract,
             in_unconstrained_fn: false,
@@ -616,6 +632,14 @@ impl<'a> Resolver<'a> {
 
         match self.lookup_struct_or_error(path) {
             Some(struct_type) => {
+                if self.resolving_ids.contains(&struct_type.borrow().id) {
+                    self.push_err(ResolverError::SelfReferentialStruct {
+                        span: struct_type.borrow().name.span(),
+                    });
+
+                    return Type::Error;
+                }
+
                 let expected_generic_count = struct_type.borrow().generics.len();
                 if !self.in_contract
                     && self
@@ -886,7 +910,10 @@ impl<'a> Resolver<'a> {
         self.resolve_local_globals();
 
         self.current_item = Some(DependencyId::Struct(struct_id));
+
+        self.resolving_ids.insert(struct_id);
         let fields = vecmap(unresolved.fields, |(ident, typ)| (ident, self.resolve_type(typ)));
+        self.resolving_ids.remove(&struct_id);
 
         (generics, fields, self.errors)
     }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 5d0f2472a43..fb60047b233 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1167,7 +1167,7 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
     }
 
     #[test]
-    fn deny_cyclic_structs() {
+    fn deny_mutually_recursive_structs() {
         let src = r#"
             struct Foo { bar: Bar }
             struct Bar { foo: Foo }
diff --git a/test_programs/compile_failure/self_referential_struct/Nargo.toml b/test_programs/compile_failure/self_referential_struct/Nargo.toml
new file mode 100644
index 00000000000..a0693f9d4b1
--- /dev/null
+++ b/test_programs/compile_failure/self_referential_struct/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "self_referential_struct"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/self_referential_struct/src/main.nr b/test_programs/compile_failure/self_referential_struct/src/main.nr
new file mode 100644
index 00000000000..d70b1a10ded
--- /dev/null
+++ b/test_programs/compile_failure/self_referential_struct/src/main.nr
@@ -0,0 +1,11 @@
+struct Option2<T> {
+    _is_some: bool,
+    _value: T,
+}
+
+struct SelfReferential
+{
+    prop : Option2<SelfReferential>
+}
+
+fn main(x: SelfReferential) { assert(x._is_some); }

From 8c89f042bef52a771c1a43731c9d5de69251e249 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 29 Apr 2024 15:34:51 +0100
Subject: [PATCH 233/416] chore: update error conversion traits to act on
 references (#4936)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR pulls out some of the changes made to errors in #4918

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_driver/src/lib.rs              |  2 +-
 .../noirc_frontend/src/hir/comptime/errors.rs | 16 ++--
 .../src/hir/comptime/interpreter.rs           |  9 ++-
 .../noirc_frontend/src/hir/comptime/value.rs  |  2 +-
 .../src/hir/def_collector/dc_crate.rs         |  4 +-
 .../src/hir/def_collector/errors.rs           | 38 +++++-----
 .../src/hir/resolution/errors.rs              | 74 +++++++++----------
 .../src/hir/resolution/import.rs              |  4 +-
 .../src/hir/type_check/errors.rs              | 60 +++++++--------
 compiler/noirc_frontend/src/lexer/errors.rs   |  4 +-
 compiler/noirc_frontend/src/parser/errors.rs  |  8 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  2 +-
 .../src/parser/parser/test_helpers.rs         |  8 +-
 tooling/nargo_cli/src/cli/fmt_cmd.rs          |  2 +-
 14 files changed, 117 insertions(+), 116 deletions(-)

diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 8a554879e9f..a2c069eac68 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -252,7 +252,7 @@ pub fn check_crate(
     let mut errors = vec![];
     let diagnostics = CrateDefMap::collect_defs(crate_id, context, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
-        let diagnostic: CustomDiagnostic = error.into();
+        let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
     }));
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 8de444252ab..af5ba9a44cf 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -7,7 +7,7 @@ use super::value::Value;
 /// The possible errors that can halt the interpreter.
 #[derive(Debug, Clone)]
 pub enum InterpreterError {
-    ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
+    ArgumentCountMismatch { expected: usize, actual: usize, location: Location },
     TypeMismatch { expected: Type, value: Value, location: Location },
     NonComptimeVarReferenced { name: String, location: Location },
     IntegerOutOfRangeForType { value: FieldElement, typ: Type, location: Location },
@@ -60,7 +60,7 @@ impl InterpreterError {
 
     pub fn get_location(&self) -> Location {
         match self {
-            InterpreterError::ArgumentCountMismatch { call_location: location, .. }
+            InterpreterError::ArgumentCountMismatch { location, .. }
             | InterpreterError::TypeMismatch { location, .. }
             | InterpreterError::NonComptimeVarReferenced { location, .. }
             | InterpreterError::IntegerOutOfRangeForType { location, .. }
@@ -98,20 +98,20 @@ impl InterpreterError {
     }
 }
 
-impl From<InterpreterError> for CustomDiagnostic {
-    fn from(error: InterpreterError) -> Self {
+impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
+    fn from(error: &'a InterpreterError) -> Self {
         match error {
-            InterpreterError::ArgumentCountMismatch { expected, actual, call_location } => {
+            InterpreterError::ArgumentCountMismatch { expected, actual, location } => {
                 let only = if expected > actual { "only " } else { "" };
-                let plural = if expected == 1 { "" } else { "s" };
-                let was_were = if actual == 1 { "was" } else { "were" };
+                let plural = if *expected == 1 { "" } else { "s" };
+                let was_were = if *actual == 1 { "was" } else { "were" };
                 let msg = format!(
                     "Expected {expected} argument{plural}, but {only}{actual} {was_were} provided"
                 );
 
                 let few_many = if actual < expected { "few" } else { "many" };
                 let secondary = format!("Too {few_many} arguments");
-                CustomDiagnostic::simple_error(msg, secondary, call_location.span)
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
             }
             InterpreterError::TypeMismatch { expected, value, location } => {
                 let typ = value.get_type();
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 4bdd4eaec9a..94456f3037a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -70,20 +70,21 @@ impl<'a> Interpreter<'a> {
         &mut self,
         function: FuncId,
         arguments: Vec<(Value, Location)>,
-        call_location: Location,
+        location: Location,
     ) -> IResult<Value> {
         let previous_state = self.enter_function();
 
         let meta = self.interner.function_meta(&function);
         if meta.kind != FunctionKind::Normal {
-            todo!("Evaluation for {:?} is unimplemented", meta.kind);
+            let item = "Evaluation for builtin functions";
+            return Err(InterpreterError::Unimplemented { item, location });
         }
 
         if meta.parameters.len() != arguments.len() {
             return Err(InterpreterError::ArgumentCountMismatch {
                 expected: meta.parameters.len(),
                 actual: arguments.len(),
-                call_location,
+                location,
             });
         }
 
@@ -113,7 +114,7 @@ impl<'a> Interpreter<'a> {
             return Err(InterpreterError::ArgumentCountMismatch {
                 expected: closure.parameters.len(),
                 actual: arguments.len(),
-                call_location,
+                location: call_location,
             });
         }
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index d7af4643192..6845c6ac5a9 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -116,7 +116,7 @@ impl Value {
             }
             Value::Closure(_lambda, _env, _typ) => {
                 // TODO: How should a closure's environment be inlined?
-                let item = "returning closures from a comptime fn";
+                let item = "Returning closures from a comptime fn";
                 return Err(InterpreterError::Unimplemented { item, location });
             }
             Value::Tuple(fields) => {
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index d8839b33ff4..d98b8a521a6 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -158,8 +158,8 @@ pub enum CompilationError {
     InterpreterError(InterpreterError),
 }
 
-impl From<CompilationError> for CustomDiagnostic {
-    fn from(value: CompilationError) -> Self {
+impl<'a> From<&'a CompilationError> for CustomDiagnostic {
+    fn from(value: &'a CompilationError) -> Self {
         match value {
             CompilationError::ParseError(error) => error.into(),
             CompilationError::DefinitionError(error) => error.into(),
diff --git a/compiler/noirc_frontend/src/hir/def_collector/errors.rs b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
index 59a3051ac70..edeb463e10d 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/errors.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
@@ -77,7 +77,7 @@ pub struct MacroError {
 }
 
 impl DefCollectorErrorKind {
-    pub fn into_file_diagnostic(self, file: fm::FileId) -> FileDiagnostic {
+    pub fn into_file_diagnostic(&self, file: fm::FileId) -> FileDiagnostic {
         Diagnostic::from(self).in_file(file)
     }
 }
@@ -99,8 +99,8 @@ impl fmt::Display for DuplicateType {
     }
 }
 
-impl From<DefCollectorErrorKind> for Diagnostic {
-    fn from(error: DefCollectorErrorKind) -> Diagnostic {
+impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
+    fn from(error: &'a DefCollectorErrorKind) -> Diagnostic {
         match error {
             DefCollectorErrorKind::Duplicate { typ, first_def, second_def } => {
                 let primary_message = format!(
@@ -133,18 +133,18 @@ impl From<DefCollectorErrorKind> for Diagnostic {
             DefCollectorErrorKind::NonStructTypeInImpl { span } => Diagnostic::simple_error(
                 "Non-struct type used in impl".into(),
                 "Only struct types may have implementation methods".into(),
-                span,
+                *span,
             ),
             DefCollectorErrorKind::MutableReferenceInTraitImpl { span } => Diagnostic::simple_error(
                 "Trait impls are not allowed on mutable reference types".into(),
                 "Try using a struct type here instead".into(),
-                span,
+                *span,
             ),
             DefCollectorErrorKind::OverlappingImpl { span, typ } => {
                 Diagnostic::simple_error(
                     format!("Impl for type `{typ}` overlaps with existing impl"),
                     "Overlapping impl".into(),
-                    span,
+                    *span,
                 )
             }
             DefCollectorErrorKind::OverlappingImplNote { span } => {
@@ -154,13 +154,13 @@ impl From<DefCollectorErrorKind> for Diagnostic {
                 Diagnostic::simple_error(
                     "Previous impl defined here".into(),
                     "Previous impl defined here".into(),
-                    span,
+                    *span,
                 )
             }
             DefCollectorErrorKind::ForeignImpl { span, type_name } => Diagnostic::simple_error(
                 "Cannot `impl` a type that was defined outside the current crate".into(),
                 format!("{type_name} was defined outside the current crate"),
-                span,
+                *span,
             ),
             DefCollectorErrorKind::TraitNotFound { trait_path } => Diagnostic::simple_error(
                 format!("Trait {trait_path} not found"),
@@ -174,15 +174,15 @@ impl From<DefCollectorErrorKind> for Diagnostic {
                 origin,
                 span,
             } => {
-                let plural = if expected_generic_count == 1 { "" } else { "s" };
+                let plural = if *expected_generic_count == 1 { "" } else { "s" };
                 let primary_message = format!(
                     "`{origin}` expects {expected_generic_count} generic{plural}, but {location} has {actual_generic_count}");
-                Diagnostic::simple_error(primary_message, "".to_string(), span)
+                Diagnostic::simple_error(primary_message, "".to_string(), *span)
             }
             DefCollectorErrorKind::MethodNotInTrait { trait_name, impl_method } => {
-                let trait_name = trait_name.0.contents;
+                let trait_name = &trait_name.0.contents;
                 let impl_method_span = impl_method.span();
-                let impl_method_name = impl_method.0.contents;
+                let impl_method_name = &impl_method.0.contents;
                 let primary_message = format!("Method with name `{impl_method_name}` is not part of trait `{trait_name}`, therefore it can't be implemented");
                 Diagnostic::simple_error(primary_message, "".to_owned(), impl_method_span)
             }
@@ -191,15 +191,15 @@ impl From<DefCollectorErrorKind> for Diagnostic {
                 method_name,
                 trait_impl_span,
             } => {
-                let trait_name = trait_name.0.contents;
-                let impl_method_name = method_name.0.contents;
+                let trait_name = &trait_name.0.contents;
+                let impl_method_name = &method_name.0.contents;
                 let primary_message = format!(
                     "Method `{impl_method_name}` from trait `{trait_name}` is not implemented"
                 );
                 Diagnostic::simple_error(
                     primary_message,
                     format!("Please implement {impl_method_name} here"),
-                    trait_impl_span,
+                    *trait_impl_span,
                 )
             }
             DefCollectorErrorKind::NotATrait { not_a_trait_name } => {
@@ -213,20 +213,20 @@ impl From<DefCollectorErrorKind> for Diagnostic {
             DefCollectorErrorKind::ModuleAlreadyPartOfCrate { mod_name, span } => {
                 let message = format!("Module '{mod_name}' is already part of the crate");
                 let secondary = String::new();
-                Diagnostic::simple_error(message, secondary, span)
+                Diagnostic::simple_error(message, secondary, *span)
             }
             DefCollectorErrorKind::ModuleOriginallyDefined { mod_name, span } => {
                 let message = format!("Note: {mod_name} was originally declared here");
                 let secondary = String::new();
-                Diagnostic::simple_error(message, secondary, span)
+                Diagnostic::simple_error(message, secondary, *span)
             }
             DefCollectorErrorKind::TraitImplOrphaned { span } => Diagnostic::simple_error(
                 "Orphaned trait implementation".into(),
                 "Either the type or the trait must be from the same crate as the trait implementation".into(),
-                span,
+                *span,
             ),
             DefCollectorErrorKind::MacroError(macro_error) => {
-                Diagnostic::simple_error(macro_error.primary_message, macro_error.secondary_message.unwrap_or_default(), macro_error.span.unwrap_or_default())
+                Diagnostic::simple_error(macro_error.primary_message.clone(), macro_error.secondary_message.clone().unwrap_or_default(), macro_error.span.unwrap_or_default())
             },
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index b6bcfe6972e..d542bd4802a 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -95,24 +95,24 @@ pub enum ResolverError {
 }
 
 impl ResolverError {
-    pub fn into_file_diagnostic(self, file: fm::FileId) -> FileDiagnostic {
+    pub fn into_file_diagnostic(&self, file: fm::FileId) -> FileDiagnostic {
         Diagnostic::from(self).in_file(file)
     }
 }
 
-impl From<ResolverError> for Diagnostic {
+impl<'a> From<&'a ResolverError> for Diagnostic {
     /// Only user errors can be transformed into a Diagnostic
     /// ICEs will make the compiler panic, as they could affect the
     /// soundness of the generated program
-    fn from(error: ResolverError) -> Diagnostic {
+    fn from(error: &'a ResolverError) -> Diagnostic {
         match error {
             ResolverError::DuplicateDefinition { name, first_span, second_span } => {
                 let mut diag = Diagnostic::simple_error(
                     format!("duplicate definitions of {name} found"),
                     "first definition found here".to_string(),
-                    first_span,
+                    *first_span,
                 );
-                diag.add_secondary("second definition found here".to_string(), second_span);
+                diag.add_secondary("second definition found here".to_string(), *second_span);
                 diag
             }
             ResolverError::UnusedVariable { ident } => {
@@ -127,18 +127,18 @@ impl From<ResolverError> for Diagnostic {
             ResolverError::VariableNotDeclared { name, span } => Diagnostic::simple_error(
                 format!("cannot find `{name}` in this scope "),
                 "not found in this scope".to_string(),
-                span,
+                *span,
             ),
             ResolverError::PathIsNotIdent { span } => Diagnostic::simple_error(
                 "cannot use path as an identifier".to_string(),
                 String::new(),
-                span,
+                *span,
             ),
             ResolverError::PathResolutionError(error) => error.into(),
             ResolverError::Expected { span, expected, got } => Diagnostic::simple_error(
                 format!("expected {expected} got {got}"),
                 String::new(),
-                span,
+                *span,
             ),
             ResolverError::DuplicateField { field } => Diagnostic::simple_error(
                 format!("duplicate field {field}"),
@@ -152,7 +152,7 @@ impl From<ResolverError> for Diagnostic {
                     field.span(),
                 )
             }
-            ResolverError::MissingFields { span, mut missing_fields, struct_definition } => {
+            ResolverError::MissingFields { span, missing_fields, struct_definition } => {
                 let plural = if missing_fields.len() != 1 { "s" } else { "" };
                 let remaining_fields_names = match &missing_fields[..] {
                     [field1] => field1.clone(),
@@ -163,7 +163,7 @@ impl From<ResolverError> for Diagnostic {
                         let len_plural = if len != 1 {"s"} else {""};
 
                         let truncated_fields = format!(" and {len} other field{len_plural}");
-                        missing_fields.truncate(3);
+                        let missing_fields = &missing_fields[0..3];
                         format!("{}{truncated_fields}", missing_fields.join(", "))
                     }
                 };
@@ -171,18 +171,18 @@ impl From<ResolverError> for Diagnostic {
                 Diagnostic::simple_error(
                     format!("missing field{plural} {remaining_fields_names} in struct {struct_definition}"),
                     String::new(),
-                    span,
+                    *span,
                 )
             }
             ResolverError::UnnecessaryMut { first_mut, second_mut } => {
                 let mut error = Diagnostic::simple_error(
                     "'mut' here is not necessary".to_owned(),
                     "".to_owned(),
-                    second_mut,
+                    *second_mut,
                 );
                 error.add_secondary(
                     "Pattern was already made mutable from this 'mut'".to_owned(),
-                    first_mut,
+                    *first_mut,
                 );
                 error
             }
@@ -227,17 +227,17 @@ impl From<ResolverError> for Diagnostic {
                     "no expression specifying the value stored by the constant variable {name}"
                 ),
                 "expected expression to be stored for let statement".to_string(),
-                span,
+                *span,
             ),
             ResolverError::InvalidArrayLengthExpr { span } => Diagnostic::simple_error(
                 "Expression invalid in an array-length context".into(),
                 "Array-length expressions can only have simple integer operations and any variables used must be global constants".into(),
-                span,
+                *span,
             ),
             ResolverError::IntegerTooLarge { span } => Diagnostic::simple_error(
                 "Integer too large to be evaluated to an array-length".into(),
                 "Array-lengths may be a maximum size of usize::MAX, including intermediate calculations".into(),
-                span,
+                *span,
             ),
             ResolverError::NoSuchNumericTypeVariable { path } => Diagnostic::simple_error(
                 format!("Cannot find a global or generic type parameter named `{path}`"),
@@ -247,57 +247,57 @@ impl From<ResolverError> for Diagnostic {
             ResolverError::CapturedMutableVariable { span } => Diagnostic::simple_error(
                 "Closures cannot capture mutable variables".into(),
                 "Mutable variable".into(),
-                span,
+                *span,
             ),
             ResolverError::TestFunctionHasParameters { span } => Diagnostic::simple_error(
                 "Test functions cannot have any parameters".into(),
                 "Try removing the parameters or moving the test into a wrapper function".into(),
-                span,
+                *span,
             ),
             ResolverError::NonStructUsedInConstructor { typ, span } => Diagnostic::simple_error(
                 "Only struct types can be used in constructor expressions".into(),
                 format!("{typ} has no fields to construct it with"),
-                span,
+                *span,
             ),
             ResolverError::NonStructWithGenerics { span } => Diagnostic::simple_error(
                 "Only struct types can have generic arguments".into(),
                 "Try removing the generic arguments".into(),
-                span,
+                *span,
             ),
             ResolverError::GenericsOnSelfType { span } => Diagnostic::simple_error(
                 "Cannot apply generics to Self type".into(),
                 "Use an explicit type name or apply the generics at the start of the impl instead".into(),
-                span,
+                *span,
             ),
             ResolverError::IncorrectGenericCount { span, item_name, actual, expected } => {
-                let expected_plural = if expected == 1 { "" } else { "s" };
-                let actual_plural = if actual == 1 { "is" } else { "are" };
+                let expected_plural = if *expected == 1 { "" } else { "s" };
+                let actual_plural = if *actual == 1 { "is" } else { "are" };
 
                 Diagnostic::simple_error(
                     format!("`{item_name}` has {expected} generic argument{expected_plural} but {actual} {actual_plural} given here"),
                     "Incorrect number of generic arguments".into(),
-                    span,
+                    *span,
                 )
             }
-            ResolverError::ParserError(error) => (*error).into(),
+            ResolverError::ParserError(error) => error.as_ref().into(),
             ResolverError::MutableReferenceToImmutableVariable { variable, span } => {
-                Diagnostic::simple_error(format!("Cannot mutably reference the immutable variable {variable}"), format!("{variable} is immutable"), span)
+                Diagnostic::simple_error(format!("Cannot mutably reference the immutable variable {variable}"), format!("{variable} is immutable"), *span)
             },
             ResolverError::MutableReferenceToArrayElement { span } => {
-                Diagnostic::simple_error("Mutable references to array elements are currently unsupported".into(), "Try storing the element in a fresh variable first".into(), span)
+                Diagnostic::simple_error("Mutable references to array elements are currently unsupported".into(), "Try storing the element in a fresh variable first".into(), *span)
             },
             ResolverError::NumericConstantInFormatString { name, span } => Diagnostic::simple_error(
                 format!("cannot find `{name}` in this scope "),
                 "Numeric constants should be printed without formatting braces".to_string(),
-                span,
+                *span,
             ),
             ResolverError::InvalidClosureEnvironment { span, typ } => Diagnostic::simple_error(
                 format!("{typ} is not a valid closure environment type"),
-                "Closure environment must be a tuple or unit type".to_string(), span),
+                "Closure environment must be a tuple or unit type".to_string(), *span),
             ResolverError::NestedSlices { span } => Diagnostic::simple_error(
                 "Nested slices are not supported".into(),
                 "Try to use a constant sized array instead".into(),
-                span,
+                *span,
             ),
             ResolverError::MisplacedRecursiveAttribute { ident } => {
                 let name = &ident.0.contents;
@@ -315,7 +315,7 @@ impl From<ResolverError> for Diagnostic {
                 Diagnostic::simple_error(
                     "#[abi(tag)] attributes can only be used in contracts".to_string(),
                     "misplaced #[abi(tag)] attribute".to_string(),
-                    span,
+                    *span,
                 )
             },
             ResolverError::LowLevelFunctionOutsideOfStdlib { ident } => Diagnostic::simple_error(
@@ -327,30 +327,30 @@ impl From<ResolverError> for Diagnostic {
                 Diagnostic::simple_error(
                     "Dependency cycle found".into(),
                     format!("'{item}' recursively depends on itself: {cycle}"),
-                    span,
+                    *span,
                 )
             },
             ResolverError::JumpInConstrainedFn { is_break, span } => {
-                let item = if is_break { "break" } else { "continue" };
+                let item = if *is_break { "break" } else { "continue" };
                 Diagnostic::simple_error(
                     format!("{item} is only allowed in unconstrained functions"),
                     "Constrained code must always have a known number of loop iterations".into(),
-                    span,
+                    *span,
                 )
             },
             ResolverError::JumpOutsideLoop { is_break, span } => {
-                let item = if is_break { "break" } else { "continue" };
+                let item = if *is_break { "break" } else { "continue" };
                 Diagnostic::simple_error(
                     format!("{item} is only allowed within loops"),
                     "".into(),
-                    span,
+                    *span,
                 )
             },
             ResolverError::SelfReferentialStruct { span } => {
                 Diagnostic::simple_error(
                     "Self-referential structs are not supported".into(),
                     "".into(),
-                    span,
+                    *span,
                 )
             },
             ResolverError::InlineAttributeOnUnconstrained { ident } => {
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index 77e67567f8c..8850331f683 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -53,8 +53,8 @@ pub struct ResolvedImport {
     pub error: Option<PathResolutionError>,
 }
 
-impl From<PathResolutionError> for CustomDiagnostic {
-    fn from(error: PathResolutionError) -> Self {
+impl<'a> From<&'a PathResolutionError> for CustomDiagnostic {
+    fn from(error: &'a PathResolutionError) -> Self {
         match &error {
             PathResolutionError::Unresolved(ident) => {
                 CustomDiagnostic::simple_error(error.to_string(), String::new(), ident.span())
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 9678bb8c9b9..b81727a27f5 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -147,36 +147,36 @@ impl TypeCheckError {
     }
 }
 
-impl From<TypeCheckError> for Diagnostic {
-    fn from(error: TypeCheckError) -> Diagnostic {
+impl<'a> From<&'a TypeCheckError> for Diagnostic {
+    fn from(error: &'a TypeCheckError) -> Diagnostic {
         match error {
             TypeCheckError::TypeCannotBeUsed { typ, place, span } => Diagnostic::simple_error(
                 format!("The type {} cannot be used in a {}", &typ, place),
                 String::new(),
-                span,
+                *span,
             ),
             TypeCheckError::Context { err, ctx } => {
-                let mut diag = Diagnostic::from(*err);
-                diag.add_note(ctx.to_owned());
+                let mut diag = Diagnostic::from(err.as_ref());
+                diag.add_note(ctx.to_string());
                 diag
             }
             TypeCheckError::OpCannotBeUsed { op, place, span } => Diagnostic::simple_error(
                 format!("The operator {op:?} cannot be used in a {place}"),
                 String::new(),
-                span,
+                *span,
             ),
             TypeCheckError::TypeMismatch { expected_typ, expr_typ, expr_span } => {
                 Diagnostic::simple_error(
                     format!("Expected type {expected_typ}, found type {expr_typ}"),
                     String::new(),
-                    expr_span,
+                    *expr_span,
                 )
             }
             TypeCheckError::TraitMethodParameterTypeMismatch { method_name, expected_typ, actual_typ, parameter_index, parameter_span } => {
                 Diagnostic::simple_error(
                     format!("Parameter #{parameter_index} of method `{method_name}` must be of type {expected_typ}, not {actual_typ}"),
                     String::new(),
-                    parameter_span,
+                    *parameter_span,
                 )
             }
             TypeCheckError::NonHomogeneousArray {
@@ -192,27 +192,27 @@ impl From<TypeCheckError> for Diagnostic {
                         "Non homogeneous array, different element types found at indices ({first_index},{second_index})"
                     ),
                     format!("Found type {first_type}"),
-                    first_span,
+                    *first_span,
                 );
-                diag.add_secondary(format!("but then found type {second_type}"), second_span);
+                diag.add_secondary(format!("but then found type {second_type}"), *second_span);
                 diag
             }
             TypeCheckError::ArityMisMatch { expected, found, span } => {
-                let plural = if expected == 1 { "" } else { "s" };
+                let plural = if *expected == 1 { "" } else { "s" };
                 let msg = format!("Expected {expected} argument{plural}, but found {found}");
-                Diagnostic::simple_error(msg, String::new(), span)
+                Diagnostic::simple_error(msg, String::new(), *span)
             }
             TypeCheckError::ParameterCountMismatch { expected, found, span } => {
-                let empty_or_s = if expected == 1 { "" } else { "s" };
-                let was_or_were = if found == 1 { "was" } else { "were" };
+                let empty_or_s = if *expected == 1 { "" } else { "s" };
+                let was_or_were = if *found == 1 { "was" } else { "were" };
                 let msg = format!("Function expects {expected} parameter{empty_or_s} but {found} {was_or_were} given");
-                Diagnostic::simple_error(msg, String::new(), span)
+                Diagnostic::simple_error(msg, String::new(), *span)
             }
             TypeCheckError::GenericCountMismatch { item, expected, found, span } => {
-                let empty_or_s = if expected == 1 { "" } else { "s" };
-                let was_or_were = if found == 1 { "was" } else { "were" };
+                let empty_or_s = if *expected == 1 { "" } else { "s" };
+                let was_or_were = if *found == 1 { "was" } else { "were" };
                 let msg = format!("{item} expects {expected} generic{empty_or_s} but {found} {was_or_were} given");
-                Diagnostic::simple_error(msg, String::new(), span)
+                Diagnostic::simple_error(msg, String::new(), *span)
             }
             TypeCheckError::InvalidCast { span, .. }
             | TypeCheckError::ExpectedFunction { span, .. }
@@ -238,17 +238,17 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::NonConstantSliceLength { span }
             | TypeCheckError::StringIndexAssign { span }
             | TypeCheckError::InvalidShiftSize { span } => {
-                Diagnostic::simple_error(error.to_string(), String::new(), span)
+                Diagnostic::simple_error(error.to_string(), String::new(), *span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(
                 "Functions cannot declare a public return type".to_string(),
                 format!("return type is {typ}"),
-                span,
+                *span,
             ),
             TypeCheckError::TypeAnnotationsNeeded { span } => Diagnostic::simple_error(
                 "Expression type is ambiguous".to_string(),
                 "Type must be known at this point".to_string(),
-                span,
+                *span,
             ),
             TypeCheckError::ResolverError(error) => error.into(),
             TypeCheckError::TypeMismatchWithSource { expected, actual, span, source } => {
@@ -274,30 +274,30 @@ impl From<TypeCheckError> for Diagnostic {
                             diagnostic.add_note(format!("help: try adding a return type: `-> {actual}`"));
                         }
 
-                        diagnostic.add_secondary(format!("{actual} returned here"), expr_span);
+                        diagnostic.add_secondary(format!("{actual} returned here"), *expr_span);
 
                         return diagnostic
                     },
                 };
 
-                Diagnostic::simple_error(message, String::new(), span)
+                Diagnostic::simple_error(message, String::new(), *span)
             }
             TypeCheckError::CallDeprecated { span, ref note, .. } => {
                 let primary_message = error.to_string();
                 let secondary_message = note.clone().unwrap_or_default();
 
-                Diagnostic::simple_warning(primary_message, secondary_message, span)
+                Diagnostic::simple_warning(primary_message, secondary_message, *span)
             }
             TypeCheckError::UnusedResultError { expr_type, expr_span } => {
                 let msg = format!("Unused expression result of type {expr_type}");
-                Diagnostic::simple_warning(msg, String::new(), expr_span)
+                Diagnostic::simple_warning(msg, String::new(), *expr_span)
             }
             TypeCheckError::NoMatchingImplFound { constraints, span } => {
                 assert!(!constraints.is_empty());
                 let msg = format!("No matching impl found for `{}: {}`", constraints[0].0, constraints[0].1);
                 let mut diagnostic = Diagnostic::from_message(&msg);
 
-                diagnostic.add_secondary(format!("No impl for `{}: {}`", constraints[0].0, constraints[0].1), span);
+                diagnostic.add_secondary(format!("No impl for `{}: {}`", constraints[0].0, constraints[0].1), *span);
 
                 // These must be notes since secondaries are unordered
                 for (typ, trait_name) in &constraints[1..] {
@@ -308,11 +308,11 @@ impl From<TypeCheckError> for Diagnostic {
             }
             TypeCheckError::UnneededTraitConstraint { trait_name, typ, span } => {
                 let msg = format!("Constraint for `{typ}: {trait_name}` is not needed, another matching impl is already in scope");
-                Diagnostic::simple_warning(msg, "Unnecessary trait constraint in where clause".into(), span)
+                Diagnostic::simple_warning(msg, "Unnecessary trait constraint in where clause".into(), *span)
             }
             TypeCheckError::InvalidTypeForEntryPoint { span } => Diagnostic::simple_error(
                 "Only sized types may be used in the entry point to a program".to_string(),
-                "Slices, references, or any type containing them may not be used in main, contract functions, or foldable functions".to_string(), span),
+                "Slices, references, or any type containing them may not be used in main, contract functions, or foldable functions".to_string(), *span),
             TypeCheckError::MismatchTraitImplNumParameters {
                 expected_num_parameters,
                 actual_num_parameters,
@@ -320,10 +320,10 @@ impl From<TypeCheckError> for Diagnostic {
                 method_name,
                 span,
             } => {
-                let plural = if expected_num_parameters == 1 { "" } else { "s" };
+                let plural = if *expected_num_parameters == 1 { "" } else { "s" };
                 let primary_message = format!(
                     "`{trait_name}::{method_name}` expects {expected_num_parameters} parameter{plural}, but this method has {actual_num_parameters}");
-                Diagnostic::simple_error(primary_message, "".to_string(), span)
+                Diagnostic::simple_error(primary_message, "".to_string(), *span)
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/lexer/errors.rs b/compiler/noirc_frontend/src/lexer/errors.rs
index 35a07c11e0a..73c75af4cd7 100644
--- a/compiler/noirc_frontend/src/lexer/errors.rs
+++ b/compiler/noirc_frontend/src/lexer/errors.rs
@@ -96,8 +96,8 @@ impl LexerErrorKind {
     }
 }
 
-impl From<LexerErrorKind> for Diagnostic {
-    fn from(error: LexerErrorKind) -> Diagnostic {
+impl<'a> From<&'a LexerErrorKind> for Diagnostic {
+    fn from(error: &'a LexerErrorKind) -> Diagnostic {
         let (primary, secondary, span) = error.parts();
         Diagnostic::simple_error(primary, secondary, span)
     }
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index 407b69c818b..af3d4caa145 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -112,7 +112,7 @@ impl std::fmt::Display for ParserError {
         let reason_str: String = if self.reason.is_none() {
             "".to_string()
         } else {
-            format!("\nreason: {}", Diagnostic::from(self.clone()))
+            format!("\nreason: {}", Diagnostic::from(self))
         };
         let mut expected = vecmap(&self.expected_tokens, ToString::to_string);
         expected.append(&mut vecmap(&self.expected_labels, |label| format!("{label}")));
@@ -138,9 +138,9 @@ impl std::fmt::Display for ParserError {
     }
 }
 
-impl From<ParserError> for Diagnostic {
-    fn from(error: ParserError) -> Diagnostic {
-        match error.reason {
+impl<'a> From<&'a ParserError> for Diagnostic {
+    fn from(error: &'a ParserError) -> Diagnostic {
+        match &error.reason {
             Some(reason) => {
                 match reason {
                     ParserErrorReason::ConstrainDeprecated => Diagnostic::simple_error(
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 6e9f3969297..5cbab9bde3a 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -736,7 +736,7 @@ fn maybe_comp_time() -> impl NoirParser<bool> {
     keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
         if opt.is_some() {
             emit(ParserError::with_reason(
-                ParserErrorReason::ExperimentalFeature("comptime"),
+                ParserErrorReason::ExperimentalFeature("Comptime values"),
                 span,
             ));
         }
diff --git a/compiler/noirc_frontend/src/parser/parser/test_helpers.rs b/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
index 6b8cb80a0a0..83c1e148f0e 100644
--- a/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
+++ b/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
@@ -15,9 +15,9 @@ where
 {
     let (tokens, lexer_errors) = Lexer::lex(program);
     if !lexer_errors.is_empty() {
-        return Err(vecmap(lexer_errors, Into::into));
+        return Err(vecmap(&lexer_errors, Into::into));
     }
-    parser.then_ignore(just(Token::EOF)).parse(tokens).map_err(|errors| vecmap(errors, Into::into))
+    parser.then_ignore(just(Token::EOF)).parse(tokens).map_err(|errors| vecmap(&errors, Into::into))
 }
 
 pub(crate) fn parse_recover<P, T>(parser: P, program: &str) -> (Option<T>, Vec<CustomDiagnostic>)
@@ -27,8 +27,8 @@ where
     let (tokens, lexer_errors) = Lexer::lex(program);
     let (opt, errs) = parser.then_ignore(force(just(Token::EOF))).parse_recovery(tokens);
 
-    let mut errors = vecmap(lexer_errors, Into::into);
-    errors.extend(errs.into_iter().map(Into::into));
+    let mut errors = vecmap(&lexer_errors, Into::into);
+    errors.extend(errs.iter().map(Into::into));
 
     (opt, errors)
 }
diff --git a/tooling/nargo_cli/src/cli/fmt_cmd.rs b/tooling/nargo_cli/src/cli/fmt_cmd.rs
index 2e0ca5632f1..8f66a0a328f 100644
--- a/tooling/nargo_cli/src/cli/fmt_cmd.rs
+++ b/tooling/nargo_cli/src/cli/fmt_cmd.rs
@@ -48,7 +48,7 @@ pub(crate) fn run(args: FormatCommand, config: NargoConfig) -> Result<(), CliErr
                 let errors = errors
                     .into_iter()
                     .map(|error| {
-                        let error: CustomDiagnostic = error.into();
+                        let error = CustomDiagnostic::from(&error);
                         error.in_file(file_id)
                     })
                     .collect();

From 8a3c7f1c11666ed5140a63a5aa296ef417c97bfa Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 29 Apr 2024 10:04:17 -0500
Subject: [PATCH 234/416] feat(experimental): `comptime` globals (#4918)

# Description

## Problem\*

Resolves #4916

## Summary\*

Implements immutable `comptime` globals.

I've made a separate issue for mutable comptime globals since those
would require allowing a `mut` modifier when parsing globals in general.

## Additional Context

The scopes of the interpreter were already set up for globals to work.
The main main part that was needed here was evaluating comptime-known
identifiers during the scan pass. Without this monomorphization would
just use the original rhs of each global.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 aztec_macros/src/utils/hir_utils.rs           |  1 +
 compiler/noirc_frontend/src/ast/statement.rs  |  7 +--
 .../src/hir/comptime/hir_to_ast.rs            |  2 +-
 .../src/hir/comptime/interpreter.rs           | 29 +++++++----
 .../noirc_frontend/src/hir/comptime/mod.rs    |  1 +
 .../noirc_frontend/src/hir/comptime/scan.rs   | 50 +++++++++++++++++--
 .../noirc_frontend/src/hir/comptime/tests.rs  | 14 ++++++
 .../src/hir/def_collector/dc_crate.rs         | 41 ++++++++++++---
 .../src/hir/def_collector/dc_mod.rs           |  5 +-
 .../src/hir/resolution/errors.rs              |  9 ++++
 .../src/hir/resolution/resolver.rs            | 19 ++++---
 .../noirc_frontend/src/hir/type_check/mod.rs  |  1 +
 compiler/noirc_frontend/src/hir_def/stmt.rs   |  1 +
 compiler/noirc_frontend/src/node_interner.rs  | 10 +++-
 compiler/noirc_frontend/src/parser/parser.rs  | 38 +++++++++-----
 compiler/noirc_frontend/src/tests.rs          |  9 ++++
 .../comptime_mut_global/Nargo.toml            |  7 +++
 .../comptime_mut_global/src/main.nr           | 30 +++++++++++
 .../comptime_globals/Nargo.toml               |  7 +++
 .../comptime_globals/src/main.nr              | 21 ++++++++
 tooling/nargo_fmt/src/visitor/stmt.rs         |  2 +-
 21 files changed, 256 insertions(+), 48 deletions(-)
 create mode 100644 test_programs/compile_success_empty/comptime_mut_global/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/comptime_mut_global/src/main.nr
 create mode 100644 test_programs/noir_test_success/comptime_globals/Nargo.toml
 create mode 100644 test_programs/noir_test_success/comptime_globals/src/main.nr

diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index 3801ff1cc75..99b02acd606 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -228,6 +228,7 @@ pub fn inject_global(
         module_id,
         file_id,
         global.attributes.clone(),
+        false,
     );
 
     // Add the statement to the scope so its path can be looked up later
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 1831a046f5b..0da39edfd85 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -40,7 +40,7 @@ pub enum StatementKind {
     Break,
     Continue,
     /// This statement should be executed at compile-time
-    Comptime(Box<StatementKind>),
+    Comptime(Box<Statement>),
     // This is an expression with a trailing semi-colon
     Semi(Expression),
     // This statement is the result of a recovered parse error.
@@ -486,7 +486,8 @@ impl Pattern {
     pub fn name_ident(&self) -> &Ident {
         match self {
             Pattern::Identifier(name_ident) => name_ident,
-            _ => panic!("only the identifier pattern can return a name"),
+            Pattern::Mutable(pattern, ..) => pattern.name_ident(),
+            _ => panic!("Only the Identifier or Mutable patterns can return a name"),
         }
     }
 
@@ -685,7 +686,7 @@ impl Display for StatementKind {
             StatementKind::For(for_loop) => for_loop.fmt(f),
             StatementKind::Break => write!(f, "break"),
             StatementKind::Continue => write!(f, "continue"),
-            StatementKind::Comptime(statement) => write!(f, "comptime {statement}"),
+            StatementKind::Comptime(statement) => write!(f, "comptime {}", statement.kind),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
             StatementKind::Error => write!(f, "Error"),
         }
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
index 42ee76d29fa..1ab9c13ea25 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -67,7 +67,7 @@ impl StmtId {
             HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
             HirStatement::Error => StatementKind::Error,
             HirStatement::Comptime(statement) => {
-                StatementKind::Comptime(Box::new(statement.to_ast(interner).kind))
+                StatementKind::Comptime(Box::new(statement.to_ast(interner)))
             }
         };
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 94456f3037a..26b7c212a30 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -134,8 +134,11 @@ impl<'a> Interpreter<'a> {
     /// `exit_function` is called.
     pub(super) fn enter_function(&mut self) -> (bool, Vec<HashMap<DefinitionId, Value>>) {
         // Drain every scope except the global scope
-        let scope = self.scopes.drain(1..).collect();
-        self.push_scope();
+        let mut scope = Vec::new();
+        if self.scopes.len() > 1 {
+            scope = self.scopes.drain(1..).collect();
+            self.push_scope();
+        }
         (std::mem::take(&mut self.in_loop), scope)
     }
 
@@ -160,7 +163,7 @@ impl<'a> Interpreter<'a> {
         self.scopes.last_mut().unwrap()
     }
 
-    fn define_pattern(
+    pub(super) fn define_pattern(
         &mut self,
         pattern: &HirPattern,
         typ: &Type,
@@ -262,7 +265,7 @@ impl<'a> Interpreter<'a> {
         Err(InterpreterError::NonComptimeVarReferenced { name, location })
     }
 
-    fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
+    pub(super) fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
         self.lookup_id(ident.id, ident.location)
     }
 
@@ -291,7 +294,7 @@ impl<'a> Interpreter<'a> {
     }
 
     /// Evaluate an expression and return the result
-    fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
+    pub(super) fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
         match self.interner.expression(&id) {
             HirExpression::Ident(ident) => self.evaluate_ident(ident, id),
             HirExpression::Literal(literal) => self.evaluate_literal(literal, id),
@@ -322,7 +325,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    fn evaluate_ident(&mut self, ident: HirIdent, id: ExprId) -> IResult<Value> {
+    pub(super) fn evaluate_ident(&mut self, ident: HirIdent, id: ExprId) -> IResult<Value> {
         let definition = self.interner.definition(ident.id);
 
         match &definition.kind {
@@ -332,9 +335,15 @@ impl<'a> Interpreter<'a> {
             }
             DefinitionKind::Local(_) => self.lookup(&ident),
             DefinitionKind::Global(global_id) => {
-                let let_ = self.interner.get_global_let_statement(*global_id).unwrap();
-                self.evaluate_let(let_)?;
-                self.lookup(&ident)
+                // Don't need to check let_.comptime, we can evaluate non-comptime globals too.
+                // Avoid resetting the value if it is already known
+                if let Ok(value) = self.lookup(&ident) {
+                    Ok(value)
+                } else {
+                    let let_ = self.interner.get_global_let_statement(*global_id).unwrap();
+                    self.evaluate_let(let_)?;
+                    self.lookup(&ident)
+                }
             }
             DefinitionKind::GenericType(type_variable) => {
                 let value = match &*type_variable.borrow() {
@@ -1027,7 +1036,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    fn evaluate_let(&mut self, let_: HirLetStatement) -> IResult<Value> {
+    pub(super) fn evaluate_let(&mut self, let_: HirLetStatement) -> IResult<Value> {
         let rhs = self.evaluate(let_.expression)?;
         let location = self.interner.expr_location(&let_.expression);
         self.define_pattern(&let_.pattern, &let_.r#type, rhs, location)?;
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
index 148fa56b4cb..0c8efae63ee 100644
--- a/compiler/noirc_frontend/src/hir/comptime/mod.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -7,3 +7,4 @@ mod value;
 
 pub use errors::InterpreterError;
 pub use interpreter::Interpreter;
+pub use value::Value;
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index 50c8ccb4557..7101a158ddb 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -14,18 +14,19 @@ use crate::{
     hir_def::{
         expr::{
             HirArrayLiteral, HirBlockExpression, HirCallExpression, HirConstructorExpression,
-            HirIfExpression, HirIndexExpression, HirInfixExpression, HirLambda,
+            HirIdent, HirIfExpression, HirIndexExpression, HirInfixExpression, HirLambda,
             HirMethodCallExpression,
         },
         stmt::HirForStatement,
     },
     macros_api::{HirExpression, HirLiteral, HirStatement},
-    node_interner::{ExprId, FuncId, StmtId},
+    node_interner::{DefinitionKind, ExprId, FuncId, GlobalId, StmtId},
 };
 
 use super::{
     errors::{IResult, InterpreterError},
     interpreter::Interpreter,
+    Value,
 };
 
 #[allow(dead_code)]
@@ -48,9 +49,23 @@ impl<'interner> Interpreter<'interner> {
         Ok(())
     }
 
+    /// Evaluate this global if it is a comptime global.
+    /// Otherwise, scan through its expression for any comptime blocks to evaluate.
+    pub fn scan_global(&mut self, global: GlobalId) -> IResult<()> {
+        if let Some(let_) = self.interner.get_global_let_statement(global) {
+            if let_.comptime {
+                self.evaluate_let(let_)?;
+            } else {
+                self.scan_expression(let_.expression)?;
+            }
+        }
+
+        Ok(())
+    }
+
     fn scan_expression(&mut self, expr: ExprId) -> IResult<()> {
         match self.interner.expression(&expr) {
-            HirExpression::Ident(_) => Ok(()),
+            HirExpression::Ident(ident) => self.scan_ident(ident, expr),
             HirExpression::Literal(literal) => self.scan_literal(literal),
             HirExpression::Block(block) => self.scan_block(block),
             HirExpression::Prefix(prefix) => self.scan_expression(prefix.rhs),
@@ -91,6 +106,27 @@ impl<'interner> Interpreter<'interner> {
         }
     }
 
+    // Identifiers have no code to execute but we may need to inline any values
+    // of comptime variables into runtime code.
+    fn scan_ident(&mut self, ident: HirIdent, id: ExprId) -> IResult<()> {
+        let definition = self.interner.definition(ident.id);
+
+        match &definition.kind {
+            DefinitionKind::Function(_) => Ok(()),
+            _ => {
+                // Opportunistically evaluate this identifier to see if it is compile-time known.
+                // If so, inline its value.
+                if let Ok(value) = self.evaluate_ident(ident, id) {
+                    // TODO(#4922): Inlining closures is currently unimplemented
+                    if !matches!(value, Value::Closure(..)) {
+                        self.inline_expression(value, id)?;
+                    }
+                }
+                Ok(())
+            }
+        }
+    }
+
     fn scan_literal(&mut self, literal: HirLiteral) -> IResult<()> {
         match literal {
             HirLiteral::Array(elements) | HirLiteral::Slice(elements) => match elements {
@@ -210,4 +246,12 @@ impl<'interner> Interpreter<'interner> {
         self.pop_scope();
         Ok(())
     }
+
+    fn inline_expression(&mut self, value: Value, expr: ExprId) -> IResult<()> {
+        let location = self.interner.expr_location(&expr);
+        let new_expr = value.into_expression(self.interner, location)?;
+        let new_expr = self.interner.expression(&new_expr);
+        self.interner.replace_expr(&expr, new_expr);
+        Ok(())
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 1a84dae4a87..5a12eb7292c 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -76,6 +76,20 @@ fn mutating_arrays() {
     assert_eq!(result, Value::U8(22));
 }
 
+#[test]
+fn mutate_in_new_scope() {
+    let program = "fn main() -> pub u8 {
+        let mut x = 0;
+        x += 1;
+        {
+            x += 1;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U8(2));
+}
+
 #[test]
 fn for_loop() {
     let program = "fn main() -> pub u8 {
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index d98b8a521a6..2f6b101e62f 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -158,6 +158,13 @@ pub enum CompilationError {
     InterpreterError(InterpreterError),
 }
 
+impl CompilationError {
+    fn is_error(&self) -> bool {
+        let diagnostic = CustomDiagnostic::from(self);
+        diagnostic.is_error()
+    }
+}
+
 impl<'a> From<&'a CompilationError> for CustomDiagnostic {
     fn from(value: &'a CompilationError) -> Self {
         match value {
@@ -404,10 +411,15 @@ impl DefCollector {
             );
         }
 
-        resolved_module.errors.extend(context.def_interner.check_for_dependency_cycles());
+        let cycle_errors = context.def_interner.check_for_dependency_cycles();
+        let cycles_present = !cycle_errors.is_empty();
+        resolved_module.errors.extend(cycle_errors);
 
         resolved_module.type_check(context);
-        resolved_module.evaluate_comptime(&mut context.def_interner);
+
+        if !cycles_present {
+            resolved_module.evaluate_comptime(&mut context.def_interner);
+        }
 
         resolved_module.errors
     }
@@ -503,13 +515,21 @@ impl ResolvedModule {
 
     /// Evaluate all `comptime` expressions in this module
     fn evaluate_comptime(&mut self, interner: &mut NodeInterner) {
-        let mut interpreter = Interpreter::new(interner);
+        if self.count_errors() == 0 {
+            let mut interpreter = Interpreter::new(interner);
 
-        for (_file, function) in &self.functions {
-            // The file returned by the error may be different than the file the
-            // function is in so only use the error's file id.
-            if let Err(error) = interpreter.scan_function(*function) {
-                self.errors.push(error.into_compilation_error_pair());
+            for (_file, global) in &self.globals {
+                if let Err(error) = interpreter.scan_global(*global) {
+                    self.errors.push(error.into_compilation_error_pair());
+                }
+            }
+
+            for (_file, function) in &self.functions {
+                // The file returned by the error may be different than the file the
+                // function is in so only use the error's file id.
+                if let Err(error) = interpreter.scan_function(*function) {
+                    self.errors.push(error.into_compilation_error_pair());
+                }
             }
         }
     }
@@ -524,4 +544,9 @@ impl ResolvedModule {
         self.globals.extend(globals.globals);
         self.errors.extend(globals.errors);
     }
+
+    /// Counts the number of errors (minus warnings) this program currently has
+    fn count_errors(&self) -> usize {
+        self.errors.iter().filter(|(error, _)| error.is_error()).count()
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index baedb109967..b2ec7dbc813 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -6,7 +6,8 @@ use noirc_errors::Location;
 
 use crate::ast::{
     FunctionDefinition, Ident, ItemVisibility, LetStatement, ModuleDeclaration, NoirFunction,
-    NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, TraitImplItem, TraitItem, TypeImpl,
+    NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, Pattern, TraitImplItem, TraitItem,
+    TypeImpl,
 };
 use crate::{
     graph::CrateId,
@@ -109,6 +110,7 @@ impl<'a> ModCollector<'a> {
                 self.module_id,
                 self.file_id,
                 global.attributes.clone(),
+                matches!(global.pattern, Pattern::Mutable { .. }),
             );
 
             // Add the statement to the scope so its path can be looked up later
@@ -463,6 +465,7 @@ impl<'a> ModCollector<'a> {
                             trait_id.0.local_id,
                             self.file_id,
                             vec![],
+                            false,
                         );
 
                         if let Err((first_def, second_def)) = self.def_collector.def_map.modules
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index d542bd4802a..1727471c34f 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -86,6 +86,8 @@ pub enum ResolverError {
     JumpInConstrainedFn { is_break: bool, span: Span },
     #[error("break/continue are only allowed within loops")]
     JumpOutsideLoop { is_break: bool, span: Span },
+    #[error("Only `comptime` globals can be mutable")]
+    MutableGlobal { span: Span },
     #[error("Self-referential structs are not supported")]
     SelfReferentialStruct { span: Span },
     #[error("#[inline(tag)] attribute is only allowed on constrained functions")]
@@ -346,6 +348,13 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
+            ResolverError::MutableGlobal { span } => {
+                Diagnostic::simple_error(
+                    "Only `comptime` globals may be mutable".into(),
+                    String::new(),
+                    *span,
+                )
+            },
             ResolverError::SelfReferentialStruct { span } => {
                 Diagnostic::simple_error(
                     "Self-referential structs are not supported".into(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index e3b1251955c..b13ffe05c2d 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1222,15 +1222,18 @@ impl<'a> Resolver<'a> {
     ) -> HirStatement {
         self.current_item = Some(DependencyId::Global(global_id));
         let expression = self.resolve_expression(let_stmt.expression);
-        let global_id = self.interner.next_global_id();
         let definition = DefinitionKind::Global(global_id);
 
         if !self.in_contract
             && let_stmt.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
         {
-            self.push_err(ResolverError::AbiAttributeOusideContract {
-                span: let_stmt.pattern.span(),
-            });
+            let span = let_stmt.pattern.span();
+            self.push_err(ResolverError::AbiAttributeOusideContract { span });
+        }
+
+        if !let_stmt.comptime && matches!(let_stmt.pattern, Pattern::Mutable(..)) {
+            let span = let_stmt.pattern.span();
+            self.push_err(ResolverError::MutableGlobal { span });
         }
 
         HirStatement::Let(HirLetStatement {
@@ -1238,6 +1241,7 @@ impl<'a> Resolver<'a> {
             r#type: self.resolve_type(let_stmt.r#type),
             expression,
             attributes: let_stmt.attributes,
+            comptime: let_stmt.comptime,
         })
     }
 
@@ -1251,6 +1255,7 @@ impl<'a> Resolver<'a> {
                     r#type: self.resolve_type(let_stmt.r#type),
                     expression,
                     attributes: let_stmt.attributes,
+                    comptime: let_stmt.comptime,
                 })
             }
             StatementKind::Constrain(constrain_stmt) => {
@@ -1322,8 +1327,10 @@ impl<'a> Resolver<'a> {
             }
             StatementKind::Error => HirStatement::Error,
             StatementKind::Comptime(statement) => {
-                let statement = self.resolve_stmt(*statement, span);
-                HirStatement::Comptime(self.interner.push_stmt(statement))
+                let hir_statement = self.resolve_stmt(statement.kind, statement.span);
+                let statement_id = self.interner.push_stmt(hir_statement);
+                self.interner.push_statement_location(statement_id, statement.span, self.file);
+                HirStatement::Comptime(statement_id)
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 03ebb44fa1f..6235fe3848d 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -508,6 +508,7 @@ pub mod test {
             r#type: Type::FieldElement,
             expression: expr_id,
             attributes: vec![],
+            comptime: false,
         };
         let stmt_id = interner.push_stmt(HirStatement::Let(let_stmt));
         let expr_id = interner
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 7e22e5ee9c0..0b4dbeb3006 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -30,6 +30,7 @@ pub struct HirLetStatement {
     pub r#type: Type,
     pub expression: ExprId,
     pub attributes: Vec<SecondaryAttribute>,
+    pub comptime: bool,
 }
 
 impl HirLetStatement {
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 5e4fa3df6c5..7ec32613cb7 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -653,11 +653,13 @@ impl NodeInterner {
         let_statement: StmtId,
         file: FileId,
         attributes: Vec<SecondaryAttribute>,
+        mutable: bool,
     ) -> GlobalId {
         let id = GlobalId(self.globals.len());
         let location = Location::new(ident.span(), file);
         let name = ident.to_string();
-        let definition_id = self.push_definition(name, false, DefinitionKind::Global(id), location);
+        let definition_id =
+            self.push_definition(name, mutable, DefinitionKind::Global(id), location);
 
         self.globals.push(GlobalInfo {
             id,
@@ -682,9 +684,13 @@ impl NodeInterner {
         local_id: LocalModuleId,
         file: FileId,
         attributes: Vec<SecondaryAttribute>,
+        mutable: bool,
     ) -> GlobalId {
         let statement = self.push_stmt(HirStatement::Error);
-        self.push_global(name, local_id, statement, file, attributes)
+        let span = name.span();
+        let id = self.push_global(name, local_id, statement, file, attributes, mutable);
+        self.push_statement_location(statement, span, file);
+        id
     }
 
     /// Intern an empty function.
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 5cbab9bde3a..4a85f6cb18f 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -235,16 +235,27 @@ fn implementation() -> impl NoirParser<TopLevelStatement> {
 fn global_declaration() -> impl NoirParser<TopLevelStatement> {
     let p = attributes::attributes()
         .then(maybe_comp_time())
+        .then(spanned(keyword(Keyword::Mut)).or_not())
         .then_ignore(keyword(Keyword::Global).labelled(ParsingRuleLabel::Global))
         .then(ident().map(Pattern::Identifier));
 
     let p = then_commit(p, optional_type_annotation());
     let p = then_commit_ignore(p, just(Token::Assign));
     let p = then_commit(p, expression());
-    p.validate(|((((attributes, comptime), pattern), r#type), expression), span, emit| {
-        let global_attributes = attributes::validate_secondary_attributes(attributes, span, emit);
-        LetStatement { pattern, r#type, comptime, expression, attributes: global_attributes }
-    })
+    p.validate(
+        |(((((attributes, comptime), mutable), mut pattern), r#type), expression), span, emit| {
+            let global_attributes =
+                attributes::validate_secondary_attributes(attributes, span, emit);
+
+            // Only comptime globals are allowed to be mutable, but we always parse the `mut`
+            // and throw the error in name resolution.
+            if let Some((_, mut_span)) = mutable {
+                let span = mut_span.merge(pattern.span());
+                pattern = Pattern::Mutable(Box::new(pattern), span, false);
+            }
+            LetStatement { pattern, r#type, comptime, expression, attributes: global_attributes }
+        },
+    )
     .map(TopLevelStatement::Global)
 }
 
@@ -532,15 +543,16 @@ where
     P2: ExprParser + 'a,
     S: NoirParser<StatementKind> + 'a,
 {
-    keyword(Keyword::Comptime)
-        .ignore_then(choice((
-            declaration(expr),
-            for_loop(expr_no_constructors, statement.clone()),
-            block(statement).map_with_span(|block, span| {
-                StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
-            }),
-        )))
-        .map(|statement| StatementKind::Comptime(Box::new(statement)))
+    let comptime_statement = choice((
+        declaration(expr),
+        for_loop(expr_no_constructors, statement.clone()),
+        block(statement).map_with_span(|block, span| {
+            StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
+        }),
+    ))
+    .map_with_span(|kind, span| Box::new(Statement { kind, span }));
+
+    keyword(Keyword::Comptime).ignore_then(comptime_statement).map(StatementKind::Comptime)
 }
 
 /// Comptime in an expression position only accepts entire blocks
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index fb60047b233..e017ea9e97b 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1284,6 +1284,15 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
     }
 
     #[test]
+    fn ban_mutable_globals() {
+        // Mutable globals are only allowed in a comptime context
+        let src = r#"
+            mut global FOO: Field = 0;
+            fn main() {}
+        "#;
+        assert_eq!(get_program_errors(src).len(), 1);
+    }
+
     fn deny_inline_attribute_on_unconstrained() {
         let src = r#"
             #[inline(never)]
diff --git a/test_programs/compile_success_empty/comptime_mut_global/Nargo.toml b/test_programs/compile_success_empty/comptime_mut_global/Nargo.toml
new file mode 100644
index 00000000000..c29aa8d83b9
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_mut_global/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_mut_global"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/comptime_mut_global/src/main.nr b/test_programs/compile_success_empty/comptime_mut_global/src/main.nr
new file mode 100644
index 00000000000..fa739289d37
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_mut_global/src/main.nr
@@ -0,0 +1,30 @@
+comptime mut global COUNTER: Field = 0;
+
+comptime fn get_unique_id() -> Field {
+    let id = COUNTER;
+    COUNTER += 1;
+    id
+}
+
+fn id1() -> Field {
+    comptime
+    {
+        get_unique_id()
+    }
+}
+
+fn id2() -> Field {
+    comptime
+    {
+        get_unique_id()
+    }
+}
+
+fn main() {
+    // Order of comptime evaluation between functions isn't guaranteed
+    // so we don't know if (id1 == 0 && id2 == 1) or if (id1 == 1 && id2 == 0).
+    // we only know they are not equal
+    let id1 = id1();
+    let id2 = id2();
+    assert(id1 != id2);
+}
diff --git a/test_programs/noir_test_success/comptime_globals/Nargo.toml b/test_programs/noir_test_success/comptime_globals/Nargo.toml
new file mode 100644
index 00000000000..d4f349f537a
--- /dev/null
+++ b/test_programs/noir_test_success/comptime_globals/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_globals"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/noir_test_success/comptime_globals/src/main.nr b/test_programs/noir_test_success/comptime_globals/src/main.nr
new file mode 100644
index 00000000000..efe9f0742b9
--- /dev/null
+++ b/test_programs/noir_test_success/comptime_globals/src/main.nr
@@ -0,0 +1,21 @@
+// Normal globals can be evaluated in a comptime context too,
+// but comptime globals can only be evaluated in a comptime context.
+comptime global FOO: Field = foo();
+
+// Due to this function's mutability and branching, SSA currently fails
+// to fold this function into a constant before the assert_constant check
+// is evaluated before loop unrolling.
+fn foo() -> Field {
+    let mut three = 3;
+    if three == 3 { 5 } else { 6 }
+}
+
+#[test]
+fn foo_global_constant() {
+    assert_constant(FOO);
+}
+
+#[test(should_fail)]
+fn foo_function_not_constant() {
+    assert_constant(foo());
+}
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index e41827c94a1..8e05fe3f5c5 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -103,7 +103,7 @@ impl super::FmtVisitor<'_> {
             StatementKind::Error => unreachable!(),
             StatementKind::Break => self.push_rewrite("break;".into(), span),
             StatementKind::Continue => self.push_rewrite("continue;".into(), span),
-            StatementKind::Comptime(statement) => self.visit_stmt(*statement, span, is_last),
+            StatementKind::Comptime(statement) => self.visit_stmt(statement.kind, span, is_last),
         }
     }
 }

From 8aad2e45acbe08afc3902db95a83324f822c35eb Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Mon, 29 Apr 2024 11:31:49 -0400
Subject: [PATCH 235/416] feat: add de-sugaring for `impl Trait` in function
 parameters (#4919)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4540

## Summary\*

In the resolver, when `x: impl Trait` is encountered as a function
parameter,
it is desugared to:
```rust
fn function_name<T_impl_trait>(x: T_impl_trait) where T_impl_trait: Trait
```

## Additional Context

In the current iteration of this PR, `T[func_id]_impl_[trait_name]` is
checked for collisions and
incremented (`T[func_id]_impl_[trait_name]_N`) until there's no
collision.

Note that this PR adds a few ~unrelated cases where `TraitAsType` could
have arguments that were previously skipped:

https://github.com/noir-lang/noir/pull/4919/files#diff-52c7ae61478bab09a4d23320128eead3a88cde6a7be16fb8b070b5512d690bbdR1203

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_arena/src/lib.rs               |  8 +++
 .../src/hir/resolution/resolver.rs            | 60 +++++++++++++++--
 compiler/noirc_frontend/src/hir_def/types.rs  | 33 ++++++----
 compiler/noirc_frontend/src/node_interner.rs  |  7 ++
 .../src/parser/parser/function.rs             |  5 ++
 compiler/noirc_frontend/src/tests.rs          | 64 +++++++++++++++++++
 .../tests/expected/impl_trait_fn_parameter.nr |  3 +
 .../tests/input/impl_trait_fn_parameter.nr    |  3 +
 8 files changed, 166 insertions(+), 17 deletions(-)
 create mode 100644 tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr
 create mode 100644 tooling/nargo_fmt/tests/input/impl_trait_fn_parameter.nr

diff --git a/compiler/noirc_arena/src/lib.rs b/compiler/noirc_arena/src/lib.rs
index 2d117304e16..9a25299d6c8 100644
--- a/compiler/noirc_arena/src/lib.rs
+++ b/compiler/noirc_arena/src/lib.rs
@@ -3,6 +3,8 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
+use std::fmt;
+
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)]
 pub struct Index(usize);
 
@@ -25,6 +27,12 @@ impl Index {
     }
 }
 
+impl fmt::Display for Index {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Arena<T> {
     pub vec: Vec<T>,
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index b13ffe05c2d..bef0ebdaacc 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -29,7 +29,7 @@ use crate::ast::{
     ArrayLiteral, BinaryOpKind, BlockExpression, Distinctness, Expression, ExpressionKind,
     ForRange, FunctionDefinition, FunctionKind, FunctionReturnType, Ident, ItemVisibility, LValue,
     LetStatement, Literal, NoirFunction, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
-    Statement, StatementKind, UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint,
+    Statement, StatementKind, TraitBound, UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint,
     UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, Visibility, ERROR_IDENT,
 };
 use crate::graph::CrateId;
@@ -202,6 +202,52 @@ impl<'a> Resolver<'a> {
         self.errors.push(err);
     }
 
+    /// This turns function parameters of the form:
+    /// fn foo(x: impl Bar)
+    ///
+    /// into
+    /// fn foo<T0_impl_Bar>(x: T0_impl_Bar) where T0_impl_Bar: Bar
+    fn desugar_impl_trait_args(&mut self, func: &mut NoirFunction, func_id: FuncId) {
+        let mut impl_trait_generics = HashSet::new();
+        let mut counter: usize = 0;
+        for parameter in func.def.parameters.iter_mut() {
+            if let UnresolvedTypeData::TraitAsType(path, args) = &parameter.typ.typ {
+                let mut new_generic_ident: Ident =
+                    format!("T{}_impl_{}", func_id, path.as_string()).into();
+                let mut new_generic_path = Path::from_ident(new_generic_ident.clone());
+                while impl_trait_generics.contains(&new_generic_ident)
+                    || self.lookup_generic_or_global_type(&new_generic_path).is_some()
+                {
+                    new_generic_ident =
+                        format!("T{}_impl_{}_{}", func_id, path.as_string(), counter).into();
+                    new_generic_path = Path::from_ident(new_generic_ident.clone());
+                    counter += 1;
+                }
+                impl_trait_generics.insert(new_generic_ident.clone());
+
+                let is_synthesized = true;
+                let new_generic_type_data =
+                    UnresolvedTypeData::Named(new_generic_path, vec![], is_synthesized);
+                let new_generic_type =
+                    UnresolvedType { typ: new_generic_type_data.clone(), span: None };
+                let new_trait_bound = TraitBound {
+                    trait_path: path.clone(),
+                    trait_id: None,
+                    trait_generics: args.to_vec(),
+                };
+                let new_trait_constraint = UnresolvedTraitConstraint {
+                    typ: new_generic_type,
+                    trait_bound: new_trait_bound,
+                };
+
+                parameter.typ.typ = new_generic_type_data;
+                func.def.generics.push(new_generic_ident);
+                func.def.where_clause.push(new_trait_constraint);
+            }
+        }
+        self.add_generics(&impl_trait_generics.into_iter().collect());
+    }
+
     /// Resolving a function involves interning the metadata
     /// interning any statements inside of the function
     /// and interning the function itself
@@ -209,7 +255,7 @@ impl<'a> Resolver<'a> {
     /// Since lowering would require scope data, unless we add an extra resolution field to the AST
     pub fn resolve_function(
         mut self,
-        func: NoirFunction,
+        mut func: NoirFunction,
         func_id: FuncId,
     ) -> (HirFunction, FuncMeta, Vec<ResolverError>) {
         self.scopes.start_function();
@@ -217,8 +263,9 @@ impl<'a> Resolver<'a> {
 
         // Check whether the function has globals in the local module and add them to the scope
         self.resolve_local_globals();
-
         self.add_generics(&func.def.generics);
+
+        self.desugar_impl_trait_args(&mut func, func_id);
         self.trait_bounds = func.def.where_clause.clone();
 
         let is_low_level_or_oracle = func
@@ -1150,10 +1197,15 @@ impl<'a> Resolver<'a> {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::TraitAsType(..)
             | Type::Code
             | Type::Forall(_, _) => (),
 
+            Type::TraitAsType(_, _, args) => {
+                for arg in args {
+                    Self::find_numeric_generics_in_type(arg, found);
+                }
+            }
+
             Type::Array(length, element_type) => {
                 if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 8c6e3d48fca..637f3c99e89 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -643,9 +643,11 @@ impl Type {
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::Forall(_, _)
-            | Type::Code
-            | Type::TraitAsType(..) => false,
+            | Type::Code => false,
 
+            Type::TraitAsType(_, _, args) => {
+                args.iter().any(|generic| generic.contains_numeric_typevar(target_id))
+            }
             Type::Array(length, elem) => {
                 elem.contains_numeric_typevar(target_id) || named_generic_id_matches_target(length)
             }
@@ -1591,11 +1593,17 @@ impl Type {
                 element.substitute_helper(type_bindings, substitute_bound_typevars),
             )),
 
+            Type::TraitAsType(s, name, args) => {
+                let args = vecmap(args, |arg| {
+                    arg.substitute_helper(type_bindings, substitute_bound_typevars)
+                });
+                Type::TraitAsType(*s, name.clone(), args)
+            }
+
             Type::FieldElement
             | Type::Integer(_, _)
             | Type::Bool
             | Type::Constant(_)
-            | Type::TraitAsType(..)
             | Type::Error
             | Type::Code
             | Type::Unit => self.clone(),
@@ -1613,7 +1621,9 @@ impl Type {
                 let field_occurs = fields.occurs(target_id);
                 len_occurs || field_occurs
             }
-            Type::Struct(_, generic_args) | Type::Alias(_, generic_args) => {
+            Type::Struct(_, generic_args)
+            | Type::Alias(_, generic_args)
+            | Type::TraitAsType(_, _, generic_args) => {
                 generic_args.iter().any(|arg| arg.occurs(target_id))
             }
             Type::Tuple(fields) => fields.iter().any(|field| field.occurs(target_id)),
@@ -1637,7 +1647,6 @@ impl Type {
             | Type::Integer(_, _)
             | Type::Bool
             | Type::Constant(_)
-            | Type::TraitAsType(..)
             | Type::Error
             | Type::Code
             | Type::Unit => false,
@@ -1689,16 +1698,14 @@ impl Type {
 
             MutableReference(element) => MutableReference(Box::new(element.follow_bindings())),
 
+            TraitAsType(s, name, args) => {
+                let args = vecmap(args, |arg| arg.follow_bindings());
+                TraitAsType(*s, name.clone(), args)
+            }
+
             // Expect that this function should only be called on instantiated types
             Forall(..) => unreachable!(),
-            TraitAsType(..)
-            | FieldElement
-            | Integer(_, _)
-            | Bool
-            | Constant(_)
-            | Unit
-            | Code
-            | Error => self.clone(),
+            FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Code | Error => self.clone(),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 7ec32613cb7..88adc7a9414 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::fmt;
 use std::ops::Deref;
 
 use fm::FileId;
@@ -314,6 +315,12 @@ impl FuncId {
     }
 }
 
+impl fmt::Display for FuncId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, Hash, Copy, Clone, PartialOrd, Ord)]
 pub struct StructId(ModuleId);
 
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index f39b2ad6292..ec4728fba4f 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -193,6 +193,11 @@ mod test {
                 "fn func_name<T>(f: Field, y : T) where T: SomeTrait + {}",
                 // The following should produce compile error on later stage. From the parser's perspective it's fine
                 "fn func_name<A>(f: Field, y : Field, z : Field) where T: SomeTrait {}",
+                // TODO: this fails with known EOF != EOF error
+                // https://github.com/noir-lang/noir/issues/4763
+                // fn func_name(x: impl Eq) {} with error Expected an end of input but found end of input
+                // "fn func_name(x: impl Eq) {}",
+                "fn func_name<T>(x: impl Eq, y : T) where T: SomeTrait + Eq {}",
             ],
         );
 
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index e017ea9e97b..cf2d7dbe153 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -746,6 +746,70 @@ mod test {
         }
     }
 
+    #[test]
+    fn check_trait_as_type_as_fn_parameter() {
+        let src = "
+        trait Eq {
+            fn eq(self, other: Self) -> bool;
+        }
+
+        struct Foo {
+            a: u64,
+        }
+
+        impl Eq for Foo {
+            fn eq(self, other: Foo) -> bool { self.a == other.a } 
+        }
+
+        fn test_eq(x: impl Eq) -> bool {
+            x.eq(x)
+        }
+
+        fn main(a: Foo) -> pub bool {
+            test_eq(a)
+        }";
+
+        let errors = get_program_errors(src);
+        errors.iter().for_each(|err| println!("{:?}", err));
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn check_trait_as_type_as_two_fn_parameters() {
+        let src = "
+        trait Eq {
+            fn eq(self, other: Self) -> bool;
+        }
+
+        trait Test {
+            fn test(self) -> bool;
+        }
+
+        struct Foo {
+            a: u64,
+        }
+
+        impl Eq for Foo {
+            fn eq(self, other: Foo) -> bool { self.a == other.a } 
+        }
+
+        impl Test for u64 {
+            fn test(self) -> bool { self == self } 
+        }
+
+        fn test_eq(x: impl Eq, y: impl Test) -> bool {
+            x.eq(x) == y.test()
+        }
+
+        fn main(a: Foo, b: u64) -> pub bool {
+            test_eq(a, b)
+        }";
+
+        let errors = get_program_errors(src);
+        errors.iter().for_each(|err| println!("{:?}", err));
+        assert!(errors.is_empty());
+    }
+
     fn get_program_captures(src: &str) -> Vec<Vec<String>> {
         let (program, context, _errors) = get_program(src);
         let interner = context.def_interner;
diff --git a/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr b/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr
new file mode 100644
index 00000000000..5ace5c60dcf
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr
@@ -0,0 +1,3 @@
+fn func_name(x: impl Eq) {}
+
+fn func_name<T>(x: impl Eq, y: T) where T: SomeTrait + Eq {}
diff --git a/tooling/nargo_fmt/tests/input/impl_trait_fn_parameter.nr b/tooling/nargo_fmt/tests/input/impl_trait_fn_parameter.nr
new file mode 100644
index 00000000000..5ace5c60dcf
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/impl_trait_fn_parameter.nr
@@ -0,0 +1,3 @@
+fn func_name(x: impl Eq) {}
+
+fn func_name<T>(x: impl Eq, y: T) where T: SomeTrait + Eq {}

From 9d53496db0697bdccf3906e02ced39990e767b79 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 29 Apr 2024 13:26:01 -0500
Subject: [PATCH 236/416] chore: Remove unnecessary `pub(super)` in interpreter
 (#4939)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/comptime/interpreter.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 26b7c212a30..1903d113586 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -163,7 +163,7 @@ impl<'a> Interpreter<'a> {
         self.scopes.last_mut().unwrap()
     }
 
-    pub(super) fn define_pattern(
+    fn define_pattern(
         &mut self,
         pattern: &HirPattern,
         typ: &Type,
@@ -265,7 +265,7 @@ impl<'a> Interpreter<'a> {
         Err(InterpreterError::NonComptimeVarReferenced { name, location })
     }
 
-    pub(super) fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
+    fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
         self.lookup_id(ident.id, ident.location)
     }
 
@@ -294,7 +294,7 @@ impl<'a> Interpreter<'a> {
     }
 
     /// Evaluate an expression and return the result
-    pub(super) fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
+    fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
         match self.interner.expression(&id) {
             HirExpression::Ident(ident) => self.evaluate_ident(ident, id),
             HirExpression::Literal(literal) => self.evaluate_literal(literal, id),

From aaac0f6bffbe11eb090145354f1b82919bb93cb7 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Mon, 29 Apr 2024 15:22:19 -0400
Subject: [PATCH 237/416] fix: ensure where clauses propagated to trait default
 definitions (#4894)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4847

## Summary\*

Before this PR, we were simply copying the default definition as an
unresolved `impl` method, without adding in any `where` clauses from the
top level of the `impl`. This PR propagates the `where` clauses into
default definitions when they're used.

For example:

```rust
impl<T> Foo for Bar<T> where T: Foo {
    fn qux(self) -> bool {
                        ^ we want an implicit "where T: Foo" here
      ..
    }
}
```

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../src/hir/resolution/traits.rs              | 11 +++++-----
 compiler/noirc_frontend/src/tests.rs          | 21 +++++++++++++++++++
 .../impl_from_where_impl/Nargo.toml           |  7 +++++++
 .../impl_from_where_impl/src/main.nr          | 15 +++++++++++++
 4 files changed, 49 insertions(+), 5 deletions(-)
 create mode 100644 test_programs/compile_success_empty/impl_from_where_impl/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/impl_from_where_impl/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index ccae8c6dd03..3d355fd4447 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -124,6 +124,7 @@ fn resolve_trait_methods(
 
             let mut resolver = Resolver::new(interner, &path_resolver, def_maps, file);
             resolver.add_generics(generics);
+
             resolver.add_existing_generics(&unresolved_trait.trait_def.generics, trait_generics);
             resolver.add_existing_generic("Self", name_span, self_typevar);
             resolver.set_self_type(Some(self_type.clone()));
@@ -207,16 +208,16 @@ fn collect_trait_impl_methods(
 
         if overrides.is_empty() {
             if let Some(default_impl) = &method.default_impl {
+                // copy 'where' clause from unresolved trait impl
+                let mut default_impl_clone = default_impl.clone();
+                default_impl_clone.def.where_clause.extend(trait_impl.where_clause.clone());
+
                 let func_id = interner.push_empty_fn();
                 let module = ModuleId { local_id: trait_impl.module_id, krate: crate_id };
                 let location = Location::new(default_impl.def.span, trait_impl.file_id);
                 interner.push_function(func_id, &default_impl.def, module, location);
                 func_ids_in_trait.insert(func_id);
-                ordered_methods.push((
-                    method.default_impl_module_id,
-                    func_id,
-                    *default_impl.clone(),
-                ));
+                ordered_methods.push((method.default_impl_module_id, func_id, *default_impl_clone));
             } else {
                 let error = DefCollectorErrorKind::TraitMissingMethod {
                     trait_name: interner.get_trait(trait_id).name.clone(),
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index cf2d7dbe153..b2cc7eee9f8 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -746,6 +746,27 @@ mod test {
         }
     }
 
+    #[test]
+    fn test_impl_self_within_default_def() {
+        let src = "
+        trait Bar {
+            fn ok(self) -> Self;
+
+            fn ref_ok(self) -> Self {
+                self.ok()
+            }
+        }
+
+        impl<T> Bar for (T, T) where T: Bar {
+            fn ok(self) -> Self {
+                self
+            }
+        }";
+        let errors = get_program_errors(src);
+        errors.iter().for_each(|err| println!("{:?}", err));
+        assert!(errors.is_empty());
+    }
+
     #[test]
     fn check_trait_as_type_as_fn_parameter() {
         let src = "
diff --git a/test_programs/compile_success_empty/impl_from_where_impl/Nargo.toml b/test_programs/compile_success_empty/impl_from_where_impl/Nargo.toml
new file mode 100644
index 00000000000..5894e457dd8
--- /dev/null
+++ b/test_programs/compile_success_empty/impl_from_where_impl/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "impl_from_where_impl"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr b/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr
new file mode 100644
index 00000000000..3cec46bdfcd
--- /dev/null
+++ b/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr
@@ -0,0 +1,15 @@
+trait Bar {
+    fn ok(self) -> Self;
+
+    fn ref_ok(self) -> Self {
+        self.ok()
+    }
+}
+
+impl<T> Bar for (T, T) where T: Bar {
+    fn ok(self) -> Self {
+        self
+    }
+}
+
+fn main() {}

From 0ce04d3ea8734b76d96f5dd0fb2a6cdd4081969e Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 30 Apr 2024 21:13:15 +0100
Subject: [PATCH 238/416] feat: Handle `no_predicates` attribute (#4942)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4911 and
https://github.com/noir-lang/noir/issues/4688

## Summary\*

~~We recently included the `#[inline(never)]` attribute to enable
developers to optimize codegen.~~ This has now been switched to the name
`no_predicates`. The main use-case in mind is for circuits in issue
#4688 where inlining a function with heavy array operations when
dependent upon witnesses is not always ideal. Specifically when the
function being inlined does not need to rely on the predicate for
correctness.

Originally I had in mind to delay inlining all the way to after ACIR gen
and inline the ACIR artifacts. However, this feels overly complex now as
we have all the infrastructure to inline functions as we wish during
SSA, we could just need to delay the inlining of certain functions to
happen after flattening. This PR does exactly what was just mentioned.

For example, the new test `no_predicates_numeric_generic_poseidon` gave
these results when `poseidon_hash` was not marked with
`#[no_predicates_numeric_generic_poseidon]`:
<img width="785" alt="ExistingInlineStrategy"
src="https://github.com/noir-lang/noir/assets/43554004/f2fc1358-c86c-4f02-999e-414056b87a01">

While when `poseidon_hash` was marked with
`#[no_predicates_numeric_generic_poseidon]`:
<img width="788" alt="InlineNeverBench"
src="https://github.com/noir-lang/noir/assets/43554004/21d729f9-32db-4a32-b592-56f76bf5663d">


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa.rs           |  3 +
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 17 +++--
 .../noirc_evaluator/src/ssa/ir/function.rs    |  7 ++
 .../noirc_evaluator/src/ssa/opt/inlining.rs   | 68 +++++++++++++++----
 compiler/noirc_frontend/src/ast/function.rs   |  2 +-
 .../src/hir/resolution/errors.rs              | 12 ++--
 .../src/hir/resolution/resolver.rs            | 12 ++--
 .../noirc_frontend/src/hir/type_check/mod.rs  |  4 +-
 .../noirc_frontend/src/hir_def/function.rs    |  5 +-
 compiler/noirc_frontend/src/lexer/token.rs    | 19 +++---
 .../src/monomorphization/ast.rs               | 21 +++---
 compiler/noirc_frontend/src/tests.rs          |  7 +-
 .../Nargo.toml                                |  2 +-
 .../Prover.toml                               |  0
 .../src/main.nr                               |  2 +-
 .../Nargo.toml                                |  7 ++
 .../Prover.toml                               |  2 +
 .../src/main.nr                               | 33 +++++++++
 tooling/debugger/ignored-tests.txt            |  3 +-
 19 files changed, 164 insertions(+), 62 deletions(-)
 rename test_programs/execution_success/{inline_never_basic => no_predicates_basic}/Nargo.toml (74%)
 rename test_programs/execution_success/{inline_never_basic => no_predicates_basic}/Prover.toml (100%)
 rename test_programs/execution_success/{inline_never_basic => no_predicates_basic}/src/main.nr (87%)
 create mode 100644 test_programs/execution_success/no_predicates_numeric_generic_poseidon/Nargo.toml
 create mode 100644 test_programs/execution_success/no_predicates_numeric_generic_poseidon/Prover.toml
 create mode 100644 test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index f9fd5f41f77..edc32fddeaf 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -61,6 +61,9 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
         // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
+        // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
+        // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
+        .run_pass(Ssa::inline_functions_with_no_predicates, "After Inlining:")
         .run_pass(Ssa::fold_constants, "After Constant Folding:")
         .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffects removal:")
         .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 63d1c1b564f..16680c2b7eb 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -390,7 +390,10 @@ impl<'a> Context<'a> {
                             panic!("ACIR function should have been inlined earlier if not marked otherwise");
                         }
                     }
-                    InlineType::Fold | InlineType::Never => {}
+                    InlineType::NoPredicates => {
+                        panic!("All ACIR functions marked with #[no_predicates] should be inlined before ACIR gen. This is an SSA exclusive codegen attribute");
+                    }
+                    InlineType::Fold => {}
                 }
                 // We only want to convert entry point functions. This being `main` and those marked with `InlineType::Fold`
                 Ok(Some(self.convert_acir_main(function, ssa, brillig)?))
@@ -2653,10 +2656,14 @@ mod test {
         basic_call_with_outputs_assert(InlineType::Fold);
         call_output_as_next_call_input(InlineType::Fold);
         basic_nested_call(InlineType::Fold);
+    }
 
-        call_output_as_next_call_input(InlineType::Never);
-        basic_nested_call(InlineType::Never);
-        basic_call_with_outputs_assert(InlineType::Never);
+    #[test]
+    #[should_panic]
+    fn basic_calls_no_predicates() {
+        call_output_as_next_call_input(InlineType::NoPredicates);
+        basic_nested_call(InlineType::NoPredicates);
+        basic_call_with_outputs_assert(InlineType::NoPredicates);
     }
 
     #[test]
@@ -2795,7 +2802,7 @@ mod test {
         let (acir_functions, _) = ssa
             .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
             .expect("Should compile manually written SSA into ACIR");
-        // The expected result should look very similar to the abvoe test expect that the input witnesses of the `Call`
+        // The expected result should look very similar to the above test expect that the input witnesses of the `Call`
         // opcodes will be different. The changes can discerned from the checks below.
 
         let main_acir = &acir_functions[0];
diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs
index 057786bf5ec..a49e02b0380 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs
@@ -85,6 +85,13 @@ impl Function {
         self.runtime = runtime;
     }
 
+    pub(crate) fn is_no_predicates(&self) -> bool {
+        match self.runtime() {
+            RuntimeType::Acir(inline_type) => matches!(inline_type, InlineType::NoPredicates),
+            RuntimeType::Brillig => false,
+        }
+    }
+
     /// Retrieves the entry block of a function.
     ///
     /// A function's entry block contains the instructions
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 0b78d47fbb1..bddfb25f26c 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -36,13 +36,30 @@ impl Ssa {
     /// changes. This is because if the function's id later becomes known by a later
     /// pass, we would need to re-run all of inlining anyway to inline it, so we might
     /// as well save the work for later instead of performing it twice.
+    ///
+    /// There are some attributes that allow inlining a function at a different step of codegen.
+    /// Currently this is just `InlineType::NoPredicates` for which we have a flag indicating
+    /// whether treating that inline functions. The default is to treat these functions as entry points.
     #[tracing::instrument(level = "trace", skip(self))]
-    pub(crate) fn inline_functions(mut self) -> Ssa {
-        self.functions = btree_map(get_entry_point_functions(&self), |entry_point| {
-            let new_function = InlineContext::new(&self, entry_point).inline_all(&self);
-            (entry_point, new_function)
-        });
+    pub(crate) fn inline_functions(self) -> Ssa {
+        Self::inline_functions_inner(self, true)
+    }
+
+    // Run the inlining pass where functions marked with `InlineType::NoPredicates` as not entry points
+    pub(crate) fn inline_functions_with_no_predicates(self) -> Ssa {
+        Self::inline_functions_inner(self, false)
+    }
 
+    fn inline_functions_inner(mut self, no_predicates_is_entry_point: bool) -> Ssa {
+        self.functions = btree_map(
+            get_entry_point_functions(&self, no_predicates_is_entry_point),
+            |entry_point| {
+                let new_function =
+                    InlineContext::new(&self, entry_point, no_predicates_is_entry_point)
+                        .inline_all(&self);
+                (entry_point, new_function)
+            },
+        );
         self
     }
 }
@@ -60,6 +77,8 @@ struct InlineContext {
 
     // The FunctionId of the entry point function we're inlining into in the old, unmodified Ssa.
     entry_point: FunctionId,
+
+    no_predicates_is_entry_point: bool,
 }
 
 /// The per-function inlining context contains information that is only valid for one function.
@@ -97,10 +116,19 @@ struct PerFunctionContext<'function> {
 /// should be left in the final program.
 /// This is the `main` function, any Acir functions with a [fold inline type][InlineType::Fold],
 /// and any brillig functions used.
-fn get_entry_point_functions(ssa: &Ssa) -> BTreeSet<FunctionId> {
+fn get_entry_point_functions(
+    ssa: &Ssa,
+    no_predicates_is_entry_point: bool,
+) -> BTreeSet<FunctionId> {
     let functions = ssa.functions.iter();
     let mut entry_points = functions
-        .filter(|(_, function)| function.runtime().is_entry_point())
+        .filter(|(_, function)| {
+            // If we have not already finished the flattening pass, functions marked
+            // to not have predicates should be marked as entry points.
+            let no_predicates_is_entry_point =
+                no_predicates_is_entry_point && function.is_no_predicates();
+            function.runtime().is_entry_point() || no_predicates_is_entry_point
+        })
         .map(|(id, _)| *id)
         .collect::<BTreeSet<_>>();
 
@@ -114,11 +142,21 @@ impl InlineContext {
     /// The function being inlined into will always be the main function, although it is
     /// actually a copy that is created in case the original main is still needed from a function
     /// that could not be inlined calling it.
-    fn new(ssa: &Ssa, entry_point: FunctionId) -> InlineContext {
+    fn new(
+        ssa: &Ssa,
+        entry_point: FunctionId,
+        no_predicates_is_entry_point: bool,
+    ) -> InlineContext {
         let source = &ssa.functions[&entry_point];
         let mut builder = FunctionBuilder::new(source.name().to_owned(), entry_point);
         builder.set_runtime(source.runtime());
-        Self { builder, recursion_level: 0, entry_point, call_stack: CallStack::new() }
+        Self {
+            builder,
+            recursion_level: 0,
+            entry_point,
+            call_stack: CallStack::new(),
+            no_predicates_is_entry_point,
+        }
     }
 
     /// Start inlining the entry point function and all functions reachable from it.
@@ -351,11 +389,17 @@ impl<'function> PerFunctionContext<'function> {
         for id in block.instructions() {
             match &self.source_function.dfg[*id] {
                 Instruction::Call { func, arguments } => match self.get_function(*func) {
-                    Some(function) => {
-                        if ssa.functions[&function].runtime().is_entry_point() {
+                    Some(func_id) => {
+                        let function = &ssa.functions[&func_id];
+                        // If we have not already finished the flattening pass, functions marked
+                        // to not have predicates should be marked as entry points.
+                        let no_predicates_is_entry_point =
+                            self.context.no_predicates_is_entry_point
+                                && function.is_no_predicates();
+                        if function.runtime().is_entry_point() || no_predicates_is_entry_point {
                             self.push_instruction(*id);
                         } else {
-                            self.inline_function(ssa, *id, function, arguments);
+                            self.inline_function(ssa, *id, func_id, arguments);
                         }
                     }
                     None => self.push_instruction(*id),
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index 9115178671e..dc426a4642a 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -109,7 +109,7 @@ impl From<FunctionDefinition> for NoirFunction {
             Some(FunctionAttribute::Oracle(_)) => FunctionKind::Oracle,
             Some(FunctionAttribute::Recursive) => FunctionKind::Recursive,
             Some(FunctionAttribute::Fold) => FunctionKind::Normal,
-            Some(FunctionAttribute::Inline(_)) => FunctionKind::Normal,
+            Some(FunctionAttribute::NoPredicates) => FunctionKind::Normal,
             None => FunctionKind::Normal,
         };
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 1727471c34f..953edc7c7d9 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -90,8 +90,8 @@ pub enum ResolverError {
     MutableGlobal { span: Span },
     #[error("Self-referential structs are not supported")]
     SelfReferentialStruct { span: Span },
-    #[error("#[inline(tag)] attribute is only allowed on constrained functions")]
-    InlineAttributeOnUnconstrained { ident: Ident },
+    #[error("#[no_predicates] attribute is only allowed on constrained functions")]
+    NoPredicatesAttributeOnUnconstrained { ident: Ident },
     #[error("#[fold] attribute is only allowed on constrained functions")]
     FoldAttributeOnUnconstrained { ident: Ident },
 }
@@ -362,16 +362,16 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
-            ResolverError::InlineAttributeOnUnconstrained { ident } => {
+            ResolverError::NoPredicatesAttributeOnUnconstrained { ident } => {
                 let name = &ident.0.contents;
 
                 let mut diag = Diagnostic::simple_error(
-                    format!("misplaced #[inline(tag)] attribute on unconstrained function {name}. Only allowed on constrained functions"),
-                    "misplaced #[inline(tag)] attribute".to_string(),
+                    format!("misplaced #[no_predicates] attribute on unconstrained function {name}. Only allowed on constrained functions"),
+                    "misplaced #[no_predicates] attribute".to_string(),
                     ident.0.span(),
                 );
 
-                diag.add_note("The `#[inline(tag)]` attribute specifies to the compiler whether it should diverge from auto-inlining constrained functions".to_owned());
+                diag.add_note("The `#[no_predicates]` attribute specifies to the compiler whether it should diverge from auto-inlining constrained functions".to_owned());
                 diag
             }
             ResolverError::FoldAttributeOnUnconstrained { ident } => {
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index bef0ebdaacc..14a45a8788f 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1000,11 +1000,11 @@ impl<'a> Resolver<'a> {
         let name_ident = HirIdent::non_trait_method(id, location);
 
         let attributes = func.attributes().clone();
-        let has_inline_attribute = attributes.is_inline();
+        let has_no_predicates_attribute = attributes.is_no_predicates();
         let should_fold = attributes.is_foldable();
         if !self.inline_attribute_allowed(func) {
-            if has_inline_attribute {
-                self.push_err(ResolverError::InlineAttributeOnUnconstrained {
+            if has_no_predicates_attribute {
+                self.push_err(ResolverError::NoPredicatesAttributeOnUnconstrained {
                     ident: func.name_ident().clone(),
                 });
             } else if should_fold {
@@ -1013,10 +1013,10 @@ impl<'a> Resolver<'a> {
                 });
             }
         }
-        // Both the #[fold] and #[inline(tag)] alter a function's inline type and code generation in similar ways.
+        // Both the #[fold] and #[no_predicates] alter a function's inline type and code generation in similar ways.
         // In certain cases such as type checking (for which the following flag will be used) both attributes
         // indicate we should code generate in the same way. Thus, we unify the attributes into one flag here.
-        let has_inline_or_fold_attribute = has_inline_attribute || should_fold;
+        let has_inline_attribute = has_no_predicates_attribute || should_fold;
 
         let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
         let mut parameters = vec![];
@@ -1111,7 +1111,7 @@ impl<'a> Resolver<'a> {
             has_body: !func.def.body.is_empty(),
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point: self.is_entry_point_function(func),
-            has_inline_or_fold_attribute,
+            has_inline_attribute,
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 6235fe3848d..ef5692abdd3 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -173,7 +173,7 @@ fn check_if_type_is_valid_for_program_input(
 ) {
     let meta = type_checker.interner.function_meta(&func_id);
     if (meta.is_entry_point && !param.1.is_valid_for_program_input())
-        || (meta.has_inline_or_fold_attribute && !param.1.is_valid_non_inlined_function_input())
+        || (meta.has_inline_attribute && !param.1.is_valid_non_inlined_function_input())
     {
         let span = param.0.span();
         errors.push(TypeCheckError::InvalidTypeForEntryPoint { span });
@@ -546,7 +546,7 @@ pub mod test {
             trait_constraints: Vec::new(),
             direct_generics: Vec::new(),
             is_entry_point: true,
-            has_inline_or_fold_attribute: false,
+            has_inline_attribute: false,
         };
         interner.push_fn_meta(func_meta, func_id);
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 57d3038a135..db54a40c8e7 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -126,8 +126,9 @@ pub struct FuncMeta {
     pub is_entry_point: bool,
 
     /// True if this function is marked with an attribute
-    /// that indicates it should not be inlined, such as `fold` or `inline(never)`
-    pub has_inline_or_fold_attribute: bool,
+    /// that indicates it should be inlined differently than the default (inline everything).
+    /// For example, such as `fold` (never inlined) or `no_predicates` (inlined after flattening)
+    pub has_inline_attribute: bool,
 }
 
 impl FuncMeta {
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 82e17ac3912..ebbc7fc9813 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -582,8 +582,8 @@ impl Attributes {
         self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_foldable())
     }
 
-    pub fn is_inline(&self) -> bool {
-        self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_inline())
+    pub fn is_no_predicates(&self) -> bool {
+        self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_no_predicates())
     }
 }
 
@@ -645,10 +645,7 @@ impl Attribute {
             ["test"] => Attribute::Function(FunctionAttribute::Test(TestScope::None)),
             ["recursive"] => Attribute::Function(FunctionAttribute::Recursive),
             ["fold"] => Attribute::Function(FunctionAttribute::Fold),
-            ["inline", tag] => {
-                validate(tag)?;
-                Attribute::Function(FunctionAttribute::Inline(tag.to_string()))
-            }
+            ["no_predicates"] => Attribute::Function(FunctionAttribute::NoPredicates),
             ["test", name] => {
                 validate(name)?;
                 let malformed_scope =
@@ -701,7 +698,7 @@ pub enum FunctionAttribute {
     Test(TestScope),
     Recursive,
     Fold,
-    Inline(String),
+    NoPredicates,
 }
 
 impl FunctionAttribute {
@@ -738,8 +735,8 @@ impl FunctionAttribute {
     /// Check whether we have an `inline` attribute
     /// Although we also do not want to inline foldable functions,
     /// we keep the two attributes distinct for clarity.
-    pub fn is_inline(&self) -> bool {
-        matches!(self, FunctionAttribute::Inline(_))
+    pub fn is_no_predicates(&self) -> bool {
+        matches!(self, FunctionAttribute::NoPredicates)
     }
 }
 
@@ -752,7 +749,7 @@ impl fmt::Display for FunctionAttribute {
             FunctionAttribute::Oracle(ref k) => write!(f, "#[oracle({k})]"),
             FunctionAttribute::Recursive => write!(f, "#[recursive]"),
             FunctionAttribute::Fold => write!(f, "#[fold]"),
-            FunctionAttribute::Inline(ref k) => write!(f, "#[inline({k})]"),
+            FunctionAttribute::NoPredicates => write!(f, "#[no_predicates]"),
         }
     }
 }
@@ -798,7 +795,7 @@ impl AsRef<str> for FunctionAttribute {
             FunctionAttribute::Test { .. } => "",
             FunctionAttribute::Recursive => "",
             FunctionAttribute::Fold => "",
-            FunctionAttribute::Inline(string) => string,
+            FunctionAttribute::NoPredicates => "",
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index dc43f53e038..721c7d5f0b1 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -213,10 +213,13 @@ pub enum InlineType {
     Inline,
     /// Functions marked as foldable will not be inlined and compiled separately into ACIR
     Fold,
-    /// Similar to `Fold`, these functions will not be inlined and compile separately into ACIR.
-    /// They are different from `Fold` though as they are expected to be inlined into the program
+    /// Functions marked to have no predicates will not be inlined in the default inlining pass
+    /// and will be separately inlined after the flattening pass.
+    /// They are different from `Fold` as they are expected to be inlined into the program
     /// entry point before being used in the backend.
-    Never,
+    /// This attribute is unsafe and can cause a function whose logic relies on predicates from
+    /// the flattening pass to fail.
+    NoPredicates,
 }
 
 impl From<&Attributes> for InlineType {
@@ -224,13 +227,7 @@ impl From<&Attributes> for InlineType {
         attributes.function.as_ref().map_or(InlineType::default(), |func_attribute| {
             match func_attribute {
                 FunctionAttribute::Fold => InlineType::Fold,
-                FunctionAttribute::Inline(tag) => {
-                    if tag == "never" {
-                        InlineType::Never
-                    } else {
-                        InlineType::default()
-                    }
-                }
+                FunctionAttribute::NoPredicates => InlineType::NoPredicates,
                 _ => InlineType::default(),
             }
         })
@@ -242,7 +239,7 @@ impl InlineType {
         match self {
             InlineType::Inline => false,
             InlineType::Fold => true,
-            InlineType::Never => true,
+            InlineType::NoPredicates => false,
         }
     }
 }
@@ -252,7 +249,7 @@ impl std::fmt::Display for InlineType {
         match self {
             InlineType::Inline => write!(f, "inline"),
             InlineType::Fold => write!(f, "fold"),
-            InlineType::Never => write!(f, "inline(never)"),
+            InlineType::NoPredicates => write!(f, "no_predicates"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index b2cc7eee9f8..5f99e9e347a 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1378,9 +1378,10 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         assert_eq!(get_program_errors(src).len(), 1);
     }
 
+    #[test]
     fn deny_inline_attribute_on_unconstrained() {
         let src = r#"
-            #[inline(never)]
+            #[no_predicates]
             unconstrained fn foo(x: Field, y: Field) {
                 assert(x != y);
             }
@@ -1389,7 +1390,9 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
         assert_eq!(errors.len(), 1);
         assert!(matches!(
             errors[0].0,
-            CompilationError::ResolverError(ResolverError::InlineAttributeOnUnconstrained { .. })
+            CompilationError::ResolverError(
+                ResolverError::NoPredicatesAttributeOnUnconstrained { .. }
+            )
         ));
     }
 
diff --git a/test_programs/execution_success/inline_never_basic/Nargo.toml b/test_programs/execution_success/no_predicates_basic/Nargo.toml
similarity index 74%
rename from test_programs/execution_success/inline_never_basic/Nargo.toml
rename to test_programs/execution_success/no_predicates_basic/Nargo.toml
index 16691770d76..bcefd550fb0 100644
--- a/test_programs/execution_success/inline_never_basic/Nargo.toml
+++ b/test_programs/execution_success/no_predicates_basic/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "inline_never_basic"
+name = "no_predicates_basic"
 type = "bin"
 authors = [""]
 compiler_version = ">=0.27.0"
diff --git a/test_programs/execution_success/inline_never_basic/Prover.toml b/test_programs/execution_success/no_predicates_basic/Prover.toml
similarity index 100%
rename from test_programs/execution_success/inline_never_basic/Prover.toml
rename to test_programs/execution_success/no_predicates_basic/Prover.toml
diff --git a/test_programs/execution_success/inline_never_basic/src/main.nr b/test_programs/execution_success/no_predicates_basic/src/main.nr
similarity index 87%
rename from test_programs/execution_success/inline_never_basic/src/main.nr
rename to test_programs/execution_success/no_predicates_basic/src/main.nr
index 1922aaedb6c..d6037c2ab26 100644
--- a/test_programs/execution_success/inline_never_basic/src/main.nr
+++ b/test_programs/execution_success/no_predicates_basic/src/main.nr
@@ -2,7 +2,7 @@ fn main(x: Field, y: pub Field) {
     basic_check(x, y);
 }
 
-#[inline(never)]
+#[no_predicates]
 fn basic_check(x: Field, y: Field) {
     assert(x != y);
 }
diff --git a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/Nargo.toml b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/Nargo.toml
new file mode 100644
index 00000000000..1ce13c24287
--- /dev/null
+++ b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "no_predicates_numeric_generic_poseidon"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/Prover.toml b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/Prover.toml
new file mode 100644
index 00000000000..00e821cf89d
--- /dev/null
+++ b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/Prover.toml
@@ -0,0 +1,2 @@
+enable = [true, false]
+to_hash = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
diff --git a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
new file mode 100644
index 00000000000..dcb5e6bc5ca
--- /dev/null
+++ b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
@@ -0,0 +1,33 @@
+use dep::std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
+
+global NUM_HASHES = 2;
+global HASH_LENGTH = 10;
+
+#[no_predicates]
+pub fn poseidon_hash<N>(inputs: [Field; N]) -> Field {
+    Poseidon2::hash(inputs, inputs.len())
+}
+
+fn main(
+    to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
+    enable: [bool; NUM_HASHES]
+) -> pub [Field; NUM_HASHES + 1] {
+    let mut result = [0; NUM_HASHES + 1];
+    for i in 0..NUM_HASHES {
+        let enable = enable[i];
+        let to_hash = to_hash[i];
+        if enable {
+            result[i] = poseidon_hash(to_hash);
+        }
+    }
+
+    // We want to make sure that the function marked with `#[no_predicates]` with a numeric generic
+    // is monomorphized correctly.
+    let mut double_preimage = [0; 20];
+    for i in 0..HASH_LENGTH * 2 {
+        double_preimage[i] = to_hash[0][i % HASH_LENGTH];
+    }
+    result[NUM_HASHES] = poseidon_hash(double_preimage);
+
+    result
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 5e6ce18be54..f214be5e613 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -17,5 +17,6 @@ fold_basic_nested_call
 fold_call_witness_condition
 fold_after_inlined_calls
 fold_numeric_generic_poseidon
-inline_never_basic
+no_predicates_basic
+no_predicates_numeric_generic_poseidon
 regression_4709

From 25080f3c7a7037d6b738c0b808ab8e08f92a2b50 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 30 Apr 2024 21:28:25 +0100
Subject: [PATCH 239/416] chore: Add test for recursing a foldable function
 (#4948)

# Description

## Problem\*

Resolves #4616

## Summary\*

I wrote the initial issue for recursive calls a while ago. I thought I
had an error at the time and that is why I wrote the issue but it looks
to all be working for fibonacci example. This simply adds a test to
validate recursive ACIR calls.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../execution_success/fold_fibonacci/Nargo.toml      |  7 +++++++
 .../execution_success/fold_fibonacci/Prover.toml     |  1 +
 .../execution_success/fold_fibonacci/src/main.nr     | 12 ++++++++++++
 tooling/debugger/ignored-tests.txt                   |  1 +
 4 files changed, 21 insertions(+)
 create mode 100644 test_programs/execution_success/fold_fibonacci/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_fibonacci/Prover.toml
 create mode 100644 test_programs/execution_success/fold_fibonacci/src/main.nr

diff --git a/test_programs/execution_success/fold_fibonacci/Nargo.toml b/test_programs/execution_success/fold_fibonacci/Nargo.toml
new file mode 100644
index 00000000000..6d8214689b0
--- /dev/null
+++ b/test_programs/execution_success/fold_fibonacci/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_fibonacci"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_fibonacci/Prover.toml b/test_programs/execution_success/fold_fibonacci/Prover.toml
new file mode 100644
index 00000000000..3a627b9188b
--- /dev/null
+++ b/test_programs/execution_success/fold_fibonacci/Prover.toml
@@ -0,0 +1 @@
+x = "10"
diff --git a/test_programs/execution_success/fold_fibonacci/src/main.nr b/test_programs/execution_success/fold_fibonacci/src/main.nr
new file mode 100644
index 00000000000..e150a586086
--- /dev/null
+++ b/test_programs/execution_success/fold_fibonacci/src/main.nr
@@ -0,0 +1,12 @@
+fn main(x: u32) {
+    assert(fibonacci(x) == 55);
+}
+
+#[fold]
+fn fibonacci(x: u32) -> u32 {
+    if x <= 1 {
+        x
+    } else {
+        fibonacci(x - 1) + fibonacci(x - 2)
+    }
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index f214be5e613..eaeea488f3a 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -20,3 +20,4 @@ fold_numeric_generic_poseidon
 no_predicates_basic
 no_predicates_numeric_generic_poseidon
 regression_4709
+fold_fibonacci

From 76d933bdf0d44505c6639b7e2025739ca6440d1d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 1 May 2024 10:12:43 +0100
Subject: [PATCH 240/416] chore: fix typo in
 `ResolverError::AbiAttributeOutsideContract` (#4933)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Fixes a typo in an error variant.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/resolution/errors.rs   | 4 ++--
 compiler/noirc_frontend/src/hir/resolution/resolver.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 953edc7c7d9..fa4ea96316a 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -77,7 +77,7 @@ pub enum ResolverError {
     #[error("#[recursive] attribute is only allowed on entry points to a program")]
     MisplacedRecursiveAttribute { ident: Ident },
     #[error("#[abi(tag)] attribute is only allowed in contracts")]
-    AbiAttributeOusideContract { span: Span },
+    AbiAttributeOutsideContract { span: Span },
     #[error("Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library")]
     LowLevelFunctionOutsideOfStdlib { ident: Ident },
     #[error("Dependency cycle found, '{item}' recursively depends on itself: {cycle} ")]
@@ -313,7 +313,7 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diag.add_note("The `#[recursive]` attribute specifies to the backend whether it should use a prover which generates proofs that are friendly for recursive verification in another circuit".to_owned());
                 diag
             }
-            ResolverError::AbiAttributeOusideContract { span } => {
+            ResolverError::AbiAttributeOutsideContract { span } => {
                 Diagnostic::simple_error(
                     "#[abi(tag)] attributes can only be used in contracts".to_string(),
                     "misplaced #[abi(tag)] attribute".to_string(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 14a45a8788f..bfdc2fe37cc 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -695,7 +695,7 @@ impl<'a> Resolver<'a> {
                         .iter()
                         .any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
                 {
-                    self.push_err(ResolverError::AbiAttributeOusideContract {
+                    self.push_err(ResolverError::AbiAttributeOutsideContract {
                         span: struct_type.borrow().name.span(),
                     });
                 }
@@ -1280,7 +1280,7 @@ impl<'a> Resolver<'a> {
             && let_stmt.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
         {
             let span = let_stmt.pattern.span();
-            self.push_err(ResolverError::AbiAttributeOusideContract { span });
+            self.push_err(ResolverError::AbiAttributeOutsideContract { span });
         }
 
         if !let_stmt.comptime && matches!(let_stmt.pattern, Pattern::Mutable(..)) {

From f1ffdacdf2ac8794c2fcc50dde8b236f2ba9cd48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Wed, 1 May 2024 13:23:00 +0100
Subject: [PATCH 241/416] chore(docs): adding matomo tracking (#4898)

I always forget to turn it off and then spend 10min everyday stressing
out on why it isn't working

![download
(48)](https://github.com/noir-lang/noir/assets/20129824/06acf8fe-9a40-4346-9db5-39690f793efe)
---
 .github/workflows/docs-pr.yml         |   2 +
 docs/docusaurus.config.ts             |   4 +-
 docs/package.json                     |   3 +-
 docs/src/components/Matomo/matomo.jsx | 133 ++++++++++++++++++++++++++
 docs/src/css/custom.css               |  28 ++++++
 docs/src/pages/index.jsx              |   3 +-
 docs/src/theme/Root.js                |  22 +++++
 7 files changed, 191 insertions(+), 4 deletions(-)
 create mode 100644 docs/src/components/Matomo/matomo.jsx
 create mode 100644 docs/src/theme/Root.js

diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index 945ed555639..9cb6775bfb7 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -79,6 +79,8 @@ jobs:
         run: yarn workspace docs version::stables
 
       - name: Build docs
+        env:
+          MATOMO_ENV: staging # not really a secret, it will show in the footer anyway
         run: yarn workspaces foreach -Rpt --from docs run build
 
       - name: Upload artifact
diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts
index 49566c5c380..2d5b8941f55 100644
--- a/docs/docusaurus.config.ts
+++ b/docs/docusaurus.config.ts
@@ -47,7 +47,9 @@ export default {
       },
     ],
   ],
-
+  customFields: {
+    MATOMO_ENV: process.env.MATOMO_ENV,
+  },
   themeConfig: {
     colorMode: {
       respectPrefersColorScheme: true,
diff --git a/docs/package.json b/docs/package.json
index f9e95fc02f8..c81d0b7b24f 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -4,11 +4,12 @@
   "private": true,
   "scripts": {
     "preprocess": "yarn workspace @noir-lang/acvm_js build && ./scripts/codegen_nargo_reference.sh && yarn node ./scripts/preprocess/index.js",
-    "start": "yarn preprocess && docusaurus start",
+    "start": "yarn preprocess && MATOMO_ENV=dev docusaurus start",
     "build": "yarn preprocess && docusaurus build",
     "clean": "rm -rf ./processed-docs ./processed-docs ./build",
     "version::stables": "ts-node ./scripts/setStable.ts",
     "serve": "serve build",
+    "swizzle": "docusaurus swizzle",
     "version": "yarn version::stables && ./scripts/cut_version.sh"
   },
   "dependencies": {
diff --git a/docs/src/components/Matomo/matomo.jsx b/docs/src/components/Matomo/matomo.jsx
new file mode 100644
index 00000000000..7ee34fc8e51
--- /dev/null
+++ b/docs/src/components/Matomo/matomo.jsx
@@ -0,0 +1,133 @@
+import { useEffect, useState } from 'react';
+import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
+import Link from '@docusaurus/Link';
+
+function getSiteId(env) {
+  if (env == 'dev') {
+    return '3';
+  } else if (env == 'staging') {
+    return '2';
+  } else {
+    return '1';
+  }
+}
+function pushInstruction(name, ...args) {
+  return window._paq.push([name, ...args]);
+}
+
+export default function useMatomo() {
+  const { siteConfig } = useDocusaurusContext();
+  const [showBanner, setShowBanner] = useState(false);
+
+  const env = siteConfig.customFields.MATOMO_ENV;
+  const urlBase = 'https://noirlang.matomo.cloud/';
+  const trackerUrl = `${urlBase}matomo.php`;
+  const srcUrl = `${urlBase}matomo.js`;
+
+  window._paq = window._paq || [];
+
+  useEffect(() => {
+    const storedConsent = localStorage.getItem('matomoConsent');
+    if (storedConsent === null) {
+      setShowBanner(true);
+    }
+  }, []);
+
+  useEffect(() => {
+    pushInstruction('setTrackerUrl', trackerUrl);
+    pushInstruction('setSiteId', getSiteId(env));
+    if (env !== 'prod') {
+      pushInstruction('setSecureCookie', false);
+    }
+
+    const doc = document;
+    const scriptElement = doc.createElement('script');
+    const scripts = doc.getElementsByTagName('script')[0];
+
+    scriptElement.type = 'text/javascript';
+    scriptElement.async = true;
+    scriptElement.defer = true;
+    scriptElement.src = srcUrl;
+
+    if (scripts && scripts.parentNode) {
+      scripts.parentNode.insertBefore(scriptElement, scripts);
+    }
+  }, []);
+
+  useEffect(() => {
+    pushInstruction('trackPageView');
+  }, [window.location.href]);
+
+  const optIn = () => {
+    pushInstruction('rememberConsentGiven');
+    localStorage.setItem('matomoConsent', true);
+    setShowBanner(false);
+  };
+
+  const optOut = () => {
+    pushInstruction('forgetConsentGiven');
+    localStorage.setItem('matomoConsent', false);
+    setShowBanner(false);
+  };
+
+  const debug = () => {
+    pushInstruction(function () {
+      console.log(this.getRememberedConsent());
+      console.log(localStorage.getItem('matomoConsent'));
+    });
+  };
+
+  const reset = () => {
+    pushInstruction('forgetConsentGiven');
+    localStorage.clear('matomoConsent');
+  };
+
+  if (!showBanner && env === 'dev') {
+    return (
+      <div id="optout-form">
+        <div className="homepage_footer">
+          <p>Debugging analytics</p>
+          <div className="homepage_cta_footer_container">
+            <button className="cta-button button button--secondary button--sm" onClick={debug}>
+              Debug
+            </button>
+            <button className="cta-button button button--secondary button--sm" onClick={reset}>
+              Reset
+            </button>
+          </div>
+        </div>
+      </div>
+    );
+  } else if (!showBanner) {
+    return null;
+  }
+
+  return (
+    <div id="optout-form">
+      <div className="homepage_footer">
+        <p>
+          We value your privacy and we only collect statistics and essential cookies. If you'd like to help us improve
+          our websites, you can allow cookies for tracking page views, time on site, and other analytics.
+          <br />
+          <br />
+          <Link to="https://aztec.network/privacy-policy/">
+            Find out how we use cookies and how you can change your settings.
+          </Link>
+        </p>
+        <div className="homepage_cta_footer_container">
+          <button className="cta-button button button--primary button--sm" onClick={optIn}>
+            I accept cookies
+          </button>
+          <button className="cta-button button button--secondary button--sm" onClick={optOut}>
+            I refuse cookies
+          </button>
+          {env === 'dev' && (
+            <button className="cta-button button button--secondary button--sm" onClick={debug}>
+              Debug
+            </button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/docs/src/css/custom.css b/docs/src/css/custom.css
index b08766fbc3b..fb6be87b519 100644
--- a/docs/src/css/custom.css
+++ b/docs/src/css/custom.css
@@ -214,3 +214,31 @@ input#docsearch-input {
   background-color: transparent;
 }
 
+
+#optout-form {
+  position: sticky;
+  bottom: 10px;
+  flex-direction: column;
+  display: flex;
+  max-width: 800px;
+  margin: 0 auto;
+  background-color: var(--ifm-breadcrumb-color-active);
+}
+
+
+
+.homepage_footer {
+  text-align: center;
+  margin-bottom: 1rem;
+  padding: 1.5rem 2rem;
+  display: flex;
+  flex-direction: column;
+  border: 1px solid #BEC2C3;
+  border-radius: 12px;
+}
+
+.homepage_cta_footer_container {
+  display: flex;
+  justify-content: center;
+}
+
diff --git a/docs/src/pages/index.jsx b/docs/src/pages/index.jsx
index b372871e7b4..c7de44b300d 100644
--- a/docs/src/pages/index.jsx
+++ b/docs/src/pages/index.jsx
@@ -1,9 +1,8 @@
-import React, { lazy, Suspense } from 'react';
+import React from 'react';
 import Layout from '@theme/Layout';
 import Link from '@docusaurus/Link';
 
 import headerPic from '@site/static/img/homepage_header_pic.png';
-import { BeatLoader } from 'react-spinners';
 
 export default function Landing() {
   return (
diff --git a/docs/src/theme/Root.js b/docs/src/theme/Root.js
new file mode 100644
index 00000000000..68c1e529db3
--- /dev/null
+++ b/docs/src/theme/Root.js
@@ -0,0 +1,22 @@
+import React from 'react';
+import useMatomo from '@site/src/components/Matomo/matomo';
+import BrowserOnly from '@docusaurus/BrowserOnly';
+import useIsBrowser from '@docusaurus/useIsBrowser';
+
+function OptOutForm() {
+  const banner = useMatomo();
+
+  return <>{banner}</>;
+}
+
+export default function Root({ children }) {
+  const useIsBrowserValue = useIsBrowser();
+  if (!useIsBrowserValue) return <>{children}</>;
+
+  return (
+    <>
+      {children}
+      <BrowserOnly>{() => <OptOutForm />}</BrowserOnly>
+    </>
+  );
+}

From 5f1b58470779e977293323d10ab9a8f0857ea29e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 1 May 2024 16:18:05 +0100
Subject: [PATCH 242/416] feat!: use `distinct` return value witnesses by
 default (#4951)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4914
Resolves https://github.com/noir-lang/noir/issues/4443

## Summary\*

We're starting to need various workarounds for non-distinct witnesses to
the point where it's more of a hindrance than it's worth. This PR makes
the `distinct` behaviour the default and raises a parser error when
using the `distinct` keyword.

I've gone for a hard error rather than a warning as the only place where
`distinct` can be used is on `main` and so there's no risk of breaking
libraries. Affected users can simply modify their own binary project to
fix the issue.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../workflows/test-rust-workspace-msrv.yml    |  3 +-
 .github/workflows/test-rust-workspace.yml     |  3 +-
 aztec_macros/src/transforms/functions.rs      |  9 +--
 compiler/noirc_evaluator/src/ssa.rs           |  4 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 64 +++++++++----------
 compiler/noirc_frontend/src/ast/expression.rs |  4 +-
 .../src/hir/resolution/resolver.rs            | 23 +------
 .../noirc_frontend/src/hir/type_check/mod.rs  |  5 +-
 .../noirc_frontend/src/hir_def/function.rs    |  4 +-
 compiler/noirc_frontend/src/lib.rs            |  2 +-
 .../src/monomorphization/ast.rs               |  9 +--
 .../src/monomorphization/mod.rs               |  4 +-
 compiler/noirc_frontend/src/parser/errors.rs  |  2 +
 compiler/noirc_frontend/src/parser/parser.rs  | 30 ++-------
 .../src/parser/parser/function.rs             | 46 ++++++++-----
 .../src/parser/parser/traits.rs               |  6 +-
 docs/docs/noir/concepts/distinct.md           | 64 -------------------
 .../conditional_regression_547/Nargo.toml     |  0
 .../conditional_regression_547/Prover.toml    |  0
 .../conditional_regression_547/src/main.nr    |  0
 .../distinct_keyword/Nargo.toml               |  6 --
 .../distinct_keyword/Prover.toml              |  1 -
 .../distinct_keyword/src/main.nr              |  4 --
 .../main_return/Nargo.toml                    |  0
 .../main_return/Prover.toml                   |  0
 .../main_return/src/main.nr                   |  0
 .../simple_array_param/Nargo.toml             |  0
 .../simple_array_param/Prover.toml            |  0
 .../simple_array_param/src/main.nr            |  0
 tooling/nargo_fmt/src/visitor/item.rs         |  6 +-
 tooling/nargo_fmt/tests/expected/fn.nr        |  2 +-
 tooling/nargo_fmt/tests/input/fn.nr           |  2 +-
 32 files changed, 87 insertions(+), 216 deletions(-)
 delete mode 100644 docs/docs/noir/concepts/distinct.md
 rename test_programs/{compile_success_empty => execution_success}/conditional_regression_547/Nargo.toml (100%)
 rename test_programs/{compile_success_empty => execution_success}/conditional_regression_547/Prover.toml (100%)
 rename test_programs/{compile_success_empty => execution_success}/conditional_regression_547/src/main.nr (100%)
 delete mode 100644 test_programs/execution_success/distinct_keyword/Nargo.toml
 delete mode 100644 test_programs/execution_success/distinct_keyword/Prover.toml
 delete mode 100644 test_programs/execution_success/distinct_keyword/src/main.nr
 rename test_programs/{compile_success_empty => execution_success}/main_return/Nargo.toml (100%)
 rename test_programs/{compile_success_empty => execution_success}/main_return/Prover.toml (100%)
 rename test_programs/{compile_success_empty => execution_success}/main_return/src/main.nr (100%)
 rename test_programs/{compile_success_empty => execution_success}/simple_array_param/Nargo.toml (100%)
 rename test_programs/{compile_success_empty => execution_success}/simple_array_param/Prover.toml (100%)
 rename test_programs/{compile_success_empty => execution_success}/simple_array_param/src/main.nr (100%)

diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index c13b0815d94..ccd431ea879 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -88,7 +88,8 @@ jobs:
       - name: Run tests
         run: |
           cargo nextest run --archive-file nextest-archive.tar.zst \
-            --partition count:${{ matrix.partition }}/4
+            --partition count:${{ matrix.partition }}/4 \
+            --no-fail-fast
 
   # This is a job which depends on all test jobs and reports the overall status.
   # This allows us to add/remove test jobs without having to update the required workflows.
diff --git a/.github/workflows/test-rust-workspace.yml b/.github/workflows/test-rust-workspace.yml
index cf35950fa3e..1f3ee5e2268 100644
--- a/.github/workflows/test-rust-workspace.yml
+++ b/.github/workflows/test-rust-workspace.yml
@@ -75,7 +75,8 @@ jobs:
       - name: Run tests
         run: |
           cargo nextest run --archive-file nextest-archive.tar.zst \
-            --partition count:${{ matrix.partition }}/4
+            --partition count:${{ matrix.partition }}/4 \
+            --no-fail-fast
 
   # This is a job which depends on all test jobs and reports the overall status.
   # This allows us to add/remove test jobs without having to update the required workflows.
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 24cad05b866..b5803d8ac9e 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -2,7 +2,7 @@ use convert_case::{Case, Casing};
 use noirc_errors::Span;
 use noirc_frontend::ast;
 use noirc_frontend::ast::{
-    BlockExpression, ConstrainKind, ConstrainStatement, Distinctness, Expression, ExpressionKind,
+    BlockExpression, ConstrainKind, ConstrainStatement, Expression, ExpressionKind,
     ForLoopStatement, ForRange, FunctionReturnType, Ident, Literal, NoirFunction, NoirStruct,
     Param, PathKind, Pattern, Signedness, Statement, StatementKind, UnresolvedType,
     UnresolvedTypeData, Visibility,
@@ -104,13 +104,8 @@ pub fn transform_function(
         func.def.return_visibility = Visibility::Public;
     }
 
-    // Distinct return types are only required for private functions
     // Public functions should have unconstrained auto-inferred
-    match ty {
-        "Private" => func.def.return_distinctness = Distinctness::Distinct,
-        "Public" | "Avm" => func.def.is_unconstrained = true,
-        _ => (),
-    }
+    func.def.is_unconstrained = matches!(ty, "Public" | "Avm");
 
     Ok(())
 }
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index edc32fddeaf..89ef74c7406 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -43,8 +43,6 @@ pub(crate) fn optimize_into_acir(
     force_brillig_output: bool,
     print_timings: bool,
 ) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
-    let abi_distinctness = program.return_distinctness;
-
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
     let ssa_gen_span_guard = ssa_gen_span.enter();
     let ssa = SsaBuilder::new(program, print_passes, force_brillig_output, print_timings)?
@@ -75,7 +73,7 @@ pub(crate) fn optimize_into_acir(
 
     drop(ssa_gen_span_guard);
 
-    time("SSA to ACIR", print_timings, || ssa.into_acir(&brillig, abi_distinctness))
+    time("SSA to ACIR", print_timings, || ssa.into_acir(&brillig))
 }
 
 // Helper to time SSA passes
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 16680c2b7eb..4a513c7b804 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -41,7 +41,6 @@ use acvm::{
 use fxhash::FxHashMap as HashMap;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
-use noirc_frontend::ast::Distinctness;
 
 #[derive(Default)]
 struct SharedContext {
@@ -281,7 +280,6 @@ impl Ssa {
     pub(crate) fn into_acir(
         self,
         brillig: &Brillig,
-        abi_distinctness: Distinctness,
     ) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
         let mut acirs = Vec::new();
         // TODO: can we parallelise this?
@@ -335,28 +333,33 @@ impl Ssa {
         // Also at the moment we specify Distinctness as part of the ABI exclusively rather than the function itself
         // so this will need to be updated.
         let main_func_acir = &mut acirs[0];
-        match abi_distinctness {
-            Distinctness::Distinct => {
-                // Create a witness for each return witness we have
-                // to guarantee that the return witnesses are distinct
-                let distinct_return_witness: Vec<_> = main_func_acir
-                    .return_witnesses
-                    .clone()
-                    .into_iter()
-                    .map(|return_witness| {
-                        main_func_acir
-                            .create_witness_for_expression(&Expression::from(return_witness))
-                    })
-                    .collect();
+        generate_distinct_return_witnesses(main_func_acir);
 
-                main_func_acir.return_witnesses = distinct_return_witness;
-            }
-            Distinctness::DuplicationAllowed => {}
-        }
         Ok((acirs, brillig))
     }
 }
 
+fn generate_distinct_return_witnesses(acir: &mut GeneratedAcir) {
+    // Create a witness for each return witness we have to guarantee that the return witnesses match the standard
+    // layout for serializing those types as if they were being passed as inputs.
+    //
+    // This is required for recursion as otherwise in situations where we cannot make use of the program's ABI
+    // (e.g. for `std::verify_proof` or the solidity verifier), we need extra knowledge about the program we're
+    // working with rather than following the standard ABI encoding rules.
+    //
+    // TODO: We're being conservative here by generating a new witness for every expression.
+    // This means that we're likely to get a number of constraints which are just renumbering witnesses.
+    // This can be tackled by:
+    // - Tracking the last assigned public input witness and only renumbering a witness if it is below this value.
+    // - Modifying existing constraints to rearrange their outputs so they are suitable
+    //   - See: https://github.com/noir-lang/noir/pull/4467
+    let distinct_return_witness = vecmap(acir.return_witnesses.clone(), |return_witness| {
+        acir.create_witness_for_expression(&Expression::from(return_witness))
+    });
+
+    acir.return_witnesses = distinct_return_witness;
+}
+
 impl<'a> Context<'a> {
     fn new(shared_context: &'a mut SharedContext) -> Context<'a> {
         let mut acir_context = AcirContext::default();
@@ -2705,7 +2708,7 @@ mod test {
         let ssa = builder.finish();
 
         let (acir_functions, _) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
+            .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
         // Expected result:
         // main f0
@@ -2800,7 +2803,7 @@ mod test {
         let ssa = builder.finish();
 
         let (acir_functions, _) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
+            .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
         // The expected result should look very similar to the above test expect that the input witnesses of the `Call`
         // opcodes will be different. The changes can discerned from the checks below.
@@ -2890,7 +2893,7 @@ mod test {
         let ssa = builder.finish();
 
         let (acir_functions, _) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
+            .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 3, "Should have three ACIR functions");
@@ -3003,9 +3006,8 @@ mod test {
         let brillig = ssa.to_brillig(false);
         println!("{}", ssa);
 
-        let (acir_functions, brillig_functions) = ssa
-            .into_acir(&brillig, noirc_frontend::ast::Distinctness::Distinct)
-            .expect("Should compile manually written SSA into ACIR");
+        let (acir_functions, brillig_functions) =
+            ssa.into_acir(&brillig).expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
         assert_eq!(brillig_functions.len(), 2, "Should only have generated two Brillig functions");
@@ -3061,7 +3063,7 @@ mod test {
         // The Brillig bytecode we insert for the stdlib is hardcoded so we do not need to provide any
         // Brillig artifacts to the ACIR gen pass.
         let (acir_functions, brillig_functions) = ssa
-            .into_acir(&Brillig::default(), noirc_frontend::ast::Distinctness::Distinct)
+            .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
@@ -3132,9 +3134,8 @@ mod test {
         let brillig = ssa.to_brillig(false);
         println!("{}", ssa);
 
-        let (acir_functions, brillig_functions) = ssa
-            .into_acir(&brillig, noirc_frontend::ast::Distinctness::Distinct)
-            .expect("Should compile manually written SSA into ACIR");
+        let (acir_functions, brillig_functions) =
+            ssa.into_acir(&brillig).expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
         // We expect 3 brillig functions:
@@ -3221,9 +3222,8 @@ mod test {
         let brillig = ssa.to_brillig(false);
         println!("{}", ssa);
 
-        let (acir_functions, brillig_functions) = ssa
-            .into_acir(&brillig, noirc_frontend::ast::Distinctness::Distinct)
-            .expect("Should compile manually written SSA into ACIR");
+        let (acir_functions, brillig_functions) =
+            ssa.into_acir(&brillig).expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 2, "Should only have two ACIR functions");
         // We expect 3 brillig functions:
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 5659de46588..59c04218e2e 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -2,7 +2,7 @@ use std::borrow::Cow;
 use std::fmt::Display;
 
 use crate::ast::{
-    Distinctness, Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
+    Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
 use crate::token::{Attributes, Token};
@@ -401,7 +401,6 @@ pub struct FunctionDefinition {
     pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub return_type: FunctionReturnType,
     pub return_visibility: Visibility,
-    pub return_distinctness: Distinctness,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -698,7 +697,6 @@ impl FunctionDefinition {
             where_clause: where_clause.to_vec(),
             return_type: return_type.clone(),
             return_visibility: Visibility::Private,
-            return_distinctness: Distinctness::DuplicationAllowed,
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index bfdc2fe37cc..6c07957b27f 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -26,8 +26,8 @@ use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::rc::Rc;
 
 use crate::ast::{
-    ArrayLiteral, BinaryOpKind, BlockExpression, Distinctness, Expression, ExpressionKind,
-    ForRange, FunctionDefinition, FunctionKind, FunctionReturnType, Ident, ItemVisibility, LValue,
+    ArrayLiteral, BinaryOpKind, BlockExpression, Expression, ExpressionKind, ForRange,
+    FunctionDefinition, FunctionKind, FunctionReturnType, Ident, ItemVisibility, LValue,
     LetStatement, Literal, NoirFunction, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
     Statement, StatementKind, TraitBound, UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint,
     UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, Visibility, ERROR_IDENT,
@@ -320,7 +320,6 @@ impl<'a> Resolver<'a> {
             where_clause: where_clause.to_vec(),
             return_type: return_type.clone(),
             return_visibility: Visibility::Private,
-            return_distinctness: Distinctness::DuplicationAllowed,
         };
 
         let (hir_func, func_meta) = self.intern_function(NoirFunction { kind, def }, func_id);
@@ -1069,12 +1068,6 @@ impl<'a> Resolver<'a> {
             });
         }
 
-        if !self.distinct_allowed(func)
-            && func.def.return_distinctness != Distinctness::DuplicationAllowed
-        {
-            self.push_err(ResolverError::DistinctNotAllowed { ident: func.name_ident().clone() });
-        }
-
         if matches!(attributes.function, Some(FunctionAttribute::Test { .. }))
             && !parameters.is_empty()
         {
@@ -1107,7 +1100,6 @@ impl<'a> Resolver<'a> {
             parameters: parameters.into(),
             return_type: func.def.return_type.clone(),
             return_visibility: func.def.return_visibility,
-            return_distinctness: func.def.return_distinctness,
             has_body: !func.def.body.is_empty(),
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point: self.is_entry_point_function(func),
@@ -1136,17 +1128,6 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    /// True if the `distinct` keyword is allowed on a function's return type
-    fn distinct_allowed(&self, func: &NoirFunction) -> bool {
-        if self.in_contract {
-            // "unconstrained" functions are compiled to brillig and thus duplication of
-            // witness indices in their abis is not a concern.
-            !func.def.is_unconstrained
-        } else {
-            func.name() == MAIN_FUNCTION
-        }
-    }
-
     fn inline_attribute_allowed(&self, func: &NoirFunction) -> bool {
         // Inline attributes are only relevant for constrained functions
         // as all unconstrained functions are not inlined
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index ef5692abdd3..0f8131d6ebb 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -433,9 +433,7 @@ pub mod test {
     use iter_extended::btree_map;
     use noirc_errors::{Location, Span};
 
-    use crate::ast::{
-        BinaryOpKind, Distinctness, FunctionKind, FunctionReturnType, Path, Visibility,
-    };
+    use crate::ast::{BinaryOpKind, FunctionKind, FunctionReturnType, Path, Visibility};
     use crate::graph::CrateId;
     use crate::hir::def_map::{ModuleData, ModuleId};
     use crate::hir::resolution::import::{
@@ -539,7 +537,6 @@ pub mod test {
             ]
             .into(),
             return_visibility: Visibility::Private,
-            return_distinctness: Distinctness::DuplicationAllowed,
             has_body: true,
             trait_impl: None,
             return_type: FunctionReturnType::Default(Span::default()),
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index db54a40c8e7..c38dd41fd3d 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -6,7 +6,7 @@ use std::rc::Rc;
 use super::expr::{HirBlockExpression, HirExpression, HirIdent};
 use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
-use crate::ast::{Distinctness, FunctionKind, FunctionReturnType, Visibility};
+use crate::ast::{FunctionKind, FunctionReturnType, Visibility};
 use crate::node_interner::{ExprId, NodeInterner, TraitImplId};
 use crate::{Type, TypeVariable};
 
@@ -99,8 +99,6 @@ pub struct FuncMeta {
 
     pub return_visibility: Visibility,
 
-    pub return_distinctness: Distinctness,
-
     /// The type of this function. Either a Type::Function
     /// or a Type::Forall for generic functions.
     pub typ: Type,
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 6c77e3d0545..958a18ac2fb 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -50,7 +50,7 @@ pub mod macros_api {
     pub use crate::token::SecondaryAttribute;
 
     pub use crate::ast::{
-        BlockExpression, CallExpression, CastExpression, Distinctness, Expression, ExpressionKind,
+        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind,
         FunctionReturnType, Ident, IndexExpression, ItemVisibility, LetStatement, Literal,
         MemberAccessExpression, MethodCallExpression, NoirFunction, Path, PathKind, Pattern,
         Statement, UnresolvedType, UnresolvedTypeData, Visibility,
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 721c7d5f0b1..97a71f800a8 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -7,7 +7,7 @@ use noirc_errors::{
 
 use crate::hir_def::function::FunctionSignature;
 use crate::{
-    ast::{BinaryOpKind, Distinctness, IntegerBitSize, Signedness, Visibility},
+    ast::{BinaryOpKind, IntegerBitSize, Signedness, Visibility},
     token::{Attributes, FunctionAttribute},
 };
 
@@ -302,11 +302,6 @@ pub struct Program {
     pub functions: Vec<Function>,
     pub function_signatures: Vec<FunctionSignature>,
     pub main_function_signature: FunctionSignature,
-    /// Indicates whether witness indices are allowed to reoccur in the ABI of the resulting ACIR.
-    ///
-    /// Note: this has no impact on monomorphization, and is simply attached here for ease of
-    /// forwarding to the next phase.
-    pub return_distinctness: Distinctness,
     pub return_location: Option<Location>,
     pub return_visibility: Visibility,
     /// Indicates to a backend whether a SNARK-friendly prover should be used.  
@@ -322,7 +317,6 @@ impl Program {
         functions: Vec<Function>,
         function_signatures: Vec<FunctionSignature>,
         main_function_signature: FunctionSignature,
-        return_distinctness: Distinctness,
         return_location: Option<Location>,
         return_visibility: Visibility,
         recursive: bool,
@@ -334,7 +328,6 @@ impl Program {
             functions,
             function_signatures,
             main_function_signature,
-            return_distinctness,
             return_location,
             return_visibility,
             recursive,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index b5754897d3f..94cc6bcd849 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -142,8 +142,7 @@ pub fn monomorphize_debug(
         .collect();
 
     let functions = vecmap(monomorphizer.finished_functions, |(_, f)| f);
-    let FuncMeta { return_distinctness, return_visibility, kind, .. } =
-        monomorphizer.interner.function_meta(&main);
+    let FuncMeta { return_visibility, kind, .. } = monomorphizer.interner.function_meta(&main);
 
     let (debug_variables, debug_functions, debug_types) =
         monomorphizer.debug_type_tracker.extract_vars_and_types();
@@ -151,7 +150,6 @@ pub fn monomorphize_debug(
         functions,
         func_sigs,
         function_sig,
-        *return_distinctness,
         monomorphizer.return_location,
         *return_visibility,
         *kind == FunctionKind::Recursive,
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index af3d4caa145..9f9a8200954 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -30,6 +30,8 @@ pub enum ParserErrorReason {
     TraitImplFunctionModifiers,
     #[error("comptime keyword is deprecated")]
     ComptimeDeprecated,
+    #[error("distinct keyword is deprecated. The `distinct` behavior is now the default.")]
+    DistinctDeprecated,
     #[error("{0} are experimental and aren't fully supported yet")]
     ExperimentalFeature(&'static str),
     #[error(
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 4a85f6cb18f..b627714d2a6 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -33,10 +33,10 @@ use super::{
 };
 use super::{spanned, Item, ItemKind};
 use crate::ast::{
-    BinaryOp, BinaryOpKind, BlockExpression, Distinctness, ForLoopStatement, ForRange,
-    FunctionReturnType, Ident, IfExpression, InfixExpression, LValue, Literal, ModuleDeclaration,
-    NoirTypeAlias, Param, Path, Pattern, Recoverable, Statement, TraitBound, TypeImpl,
-    UnresolvedTraitConstraint, UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
+    BinaryOp, BinaryOpKind, BlockExpression, ForLoopStatement, ForRange, Ident, IfExpression,
+    InfixExpression, LValue, Literal, ModuleDeclaration, NoirTypeAlias, Param, Path, Pattern,
+    Recoverable, Statement, TraitBound, TypeImpl, UnresolvedTraitConstraint,
+    UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
 };
 use crate::ast::{
     Expression, ExpressionKind, LetStatement, StatementKind, UnresolvedType, UnresolvedTypeData,
@@ -296,21 +296,6 @@ fn type_alias_definition() -> impl NoirParser<TopLevelStatement> {
     })
 }
 
-fn function_return_type() -> impl NoirParser<((Distinctness, Visibility), FunctionReturnType)> {
-    just(Token::Arrow)
-        .ignore_then(optional_distinctness())
-        .then(optional_visibility())
-        .then(spanned(parse_type()))
-        .or_not()
-        .map_with_span(|ret, span| match ret {
-            Some((head, (ty, _))) => (head, FunctionReturnType::Ty(ty)),
-            None => (
-                (Distinctness::DuplicationAllowed, Visibility::Private),
-                FunctionReturnType::Default(span),
-            ),
-        })
-}
-
 fn self_parameter() -> impl NoirParser<Param> {
     let mut_ref_pattern = just(Token::Ampersand).then_ignore(keyword(Keyword::Mut));
     let mut_pattern = keyword(Keyword::Mut);
@@ -737,13 +722,6 @@ fn optional_visibility() -> impl NoirParser<Visibility> {
         })
 }
 
-fn optional_distinctness() -> impl NoirParser<Distinctness> {
-    keyword(Keyword::Distinct).or_not().map(|opt| match opt {
-        Some(_) => Distinctness::Distinct,
-        None => Distinctness::DuplicationAllowed,
-    })
-}
-
 fn maybe_comp_time() -> impl NoirParser<bool> {
     keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
         if opt.is_some() {
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index ec4728fba4f..40180a9f9ac 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -1,16 +1,19 @@
 use super::{
     attributes::{attributes, validate_attributes},
-    block, fresh_statement, ident, keyword, maybe_comp_time, nothing, optional_distinctness,
-    optional_visibility, parameter_name_recovery, parameter_recovery, parenthesized, parse_type,
-    pattern, self_parameter, where_clause, NoirParser,
-};
-use crate::ast::{
-    Distinctness, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction,
-    Param, Visibility,
+    block, fresh_statement, ident, keyword, maybe_comp_time, nothing, optional_visibility,
+    parameter_name_recovery, parameter_recovery, parenthesized, parse_type, pattern,
+    self_parameter, where_clause, NoirParser,
 };
 use crate::parser::labels::ParsingRuleLabel;
 use crate::parser::spanned;
 use crate::token::{Keyword, Token};
+use crate::{
+    ast::{
+        FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction, Param,
+        Visibility,
+    },
+    parser::{ParserError, ParserErrorReason},
+};
 
 use chumsky::prelude::*;
 
@@ -43,8 +46,7 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunct
                 body,
                 where_clause,
                 return_type: ret.1,
-                return_visibility: ret.0 .1,
-                return_distinctness: ret.0 .0,
+                return_visibility: ret.0,
             }
             .into()
         })
@@ -93,18 +95,26 @@ pub(super) fn generics() -> impl NoirParser<Vec<Ident>> {
         .map(|opt| opt.unwrap_or_default())
 }
 
-fn function_return_type() -> impl NoirParser<((Distinctness, Visibility), FunctionReturnType)> {
+#[deprecated = "Distinct keyword is now deprecated. Remove this function after the 0.30.0 release"]
+fn optional_distinctness() -> impl NoirParser<bool> {
+    keyword(Keyword::Distinct).or_not().validate(|opt, span, emit| {
+        if opt.is_some() {
+            emit(ParserError::with_reason(ParserErrorReason::DistinctDeprecated, span));
+        }
+        opt.is_some()
+    })
+}
+
+pub(super) fn function_return_type() -> impl NoirParser<(Visibility, FunctionReturnType)> {
+    #[allow(deprecated)]
     just(Token::Arrow)
         .ignore_then(optional_distinctness())
-        .then(optional_visibility())
+        .ignore_then(optional_visibility())
         .then(spanned(parse_type()))
         .or_not()
         .map_with_span(|ret, span| match ret {
-            Some((head, (ty, _))) => (head, FunctionReturnType::Ty(ty)),
-            None => (
-                (Distinctness::DuplicationAllowed, Visibility::Private),
-                FunctionReturnType::Default(span),
-            ),
+            Some((visibility, (ty, _))) => (visibility, FunctionReturnType::Ty(ty)),
+            None => (Visibility::Private, FunctionReturnType::Default(span)),
         })
 }
 
@@ -174,7 +184,7 @@ mod test {
                 "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
                 "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
                 "fn func_name(x: [Field], y : [Field;2],y : pub [Field;2], z : pub [u8;5])  {}",
-                "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }",
+                "fn main(x: pub u8, y: pub u8) -> pub [u8; 2] { [x, y] }",
                 "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
                 "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
                 "fn func_name<T>(f: Field, y : T) where T: SomeTrait {}",
@@ -214,6 +224,8 @@ mod test {
                 // A leading plus is not allowed.
                 "fn func_name<T>(f: Field, y : T) where T: + SomeTrait {}",
                 "fn func_name<T>(f: Field, y : T) where T: TraitX + <Y> {}",
+                // `distinct` is deprecated
+                "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }",
             ],
         );
     }
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
index 0507dbdbc71..1aec57c8e41 100644
--- a/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -1,9 +1,7 @@
 use chumsky::prelude::*;
 
-use super::{
-    block, expression, fresh_statement, function, function_declaration_parameters,
-    function_return_type,
-};
+use super::function::function_return_type;
+use super::{block, expression, fresh_statement, function, function_declaration_parameters};
 
 use crate::ast::{
     Expression, ItemVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem, TraitItem,
diff --git a/docs/docs/noir/concepts/distinct.md b/docs/docs/noir/concepts/distinct.md
deleted file mode 100644
index 6c993b8b5e0..00000000000
--- a/docs/docs/noir/concepts/distinct.md
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: Distinct Witnesses
-sidebar_position: 11
----
-
-The `distinct` keyword prevents repetitions of witness indices in the program's ABI. This ensures
-that the witnesses being returned as public inputs are all unique.
-
-The `distinct` keyword is only used for return values on program entry points (usually the `main()`
-function).
-
-When using `distinct` and `pub` simultaneously, `distinct` comes first. See the example below.
-
-You can read more about the problem this solves
-[here](https://github.com/noir-lang/noir/issues/1183).
-
-## Example
-
-Without the `distinct` keyword, the following program
-
-```rust
-fn main(x : pub Field, y : pub Field) -> pub [Field; 4] {
-    let a = 1;
-    let b = 1;
-    [x + 1, y, a, b]
-}
-```
-
-compiles to
-
-```json
-{
-  //...
-  "abi": {
-    //...
-    "param_witnesses": { "x": [1], "y": [2] },
-    "return_witnesses": [3, 2, 4, 4]
-  }
-}
-```
-
-Whereas (with the `distinct` keyword)
-
-```rust
-fn main(x : pub Field, y : pub Field) -> distinct pub [Field; 4] {
-    let a = 1;
-    let b = 1;
-    [x + 1, y, a, b]
-}
-```
-
-compiles to
-
-```json
-{
-  //...
-  "abi": {
-    //...
-    "param_witnesses": { "x": [1], "y": [2] },
-    //...
-    "return_witnesses": [3, 4, 5, 6]
-  }
-}
-```
diff --git a/test_programs/compile_success_empty/conditional_regression_547/Nargo.toml b/test_programs/execution_success/conditional_regression_547/Nargo.toml
similarity index 100%
rename from test_programs/compile_success_empty/conditional_regression_547/Nargo.toml
rename to test_programs/execution_success/conditional_regression_547/Nargo.toml
diff --git a/test_programs/compile_success_empty/conditional_regression_547/Prover.toml b/test_programs/execution_success/conditional_regression_547/Prover.toml
similarity index 100%
rename from test_programs/compile_success_empty/conditional_regression_547/Prover.toml
rename to test_programs/execution_success/conditional_regression_547/Prover.toml
diff --git a/test_programs/compile_success_empty/conditional_regression_547/src/main.nr b/test_programs/execution_success/conditional_regression_547/src/main.nr
similarity index 100%
rename from test_programs/compile_success_empty/conditional_regression_547/src/main.nr
rename to test_programs/execution_success/conditional_regression_547/src/main.nr
diff --git a/test_programs/execution_success/distinct_keyword/Nargo.toml b/test_programs/execution_success/distinct_keyword/Nargo.toml
deleted file mode 100644
index 3f1b1386ba7..00000000000
--- a/test_programs/execution_success/distinct_keyword/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "distinct_keyword"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/distinct_keyword/Prover.toml b/test_programs/execution_success/distinct_keyword/Prover.toml
deleted file mode 100644
index 07890234a19..00000000000
--- a/test_programs/execution_success/distinct_keyword/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = "3"
diff --git a/test_programs/execution_success/distinct_keyword/src/main.nr b/test_programs/execution_success/distinct_keyword/src/main.nr
deleted file mode 100644
index 8e9b5c008ed..00000000000
--- a/test_programs/execution_success/distinct_keyword/src/main.nr
+++ /dev/null
@@ -1,4 +0,0 @@
-// Example that uses the distinct keyword
-fn main(x: pub Field) -> distinct pub [Field; 2] {
-    [x + 1, x]
-}
diff --git a/test_programs/compile_success_empty/main_return/Nargo.toml b/test_programs/execution_success/main_return/Nargo.toml
similarity index 100%
rename from test_programs/compile_success_empty/main_return/Nargo.toml
rename to test_programs/execution_success/main_return/Nargo.toml
diff --git a/test_programs/compile_success_empty/main_return/Prover.toml b/test_programs/execution_success/main_return/Prover.toml
similarity index 100%
rename from test_programs/compile_success_empty/main_return/Prover.toml
rename to test_programs/execution_success/main_return/Prover.toml
diff --git a/test_programs/compile_success_empty/main_return/src/main.nr b/test_programs/execution_success/main_return/src/main.nr
similarity index 100%
rename from test_programs/compile_success_empty/main_return/src/main.nr
rename to test_programs/execution_success/main_return/src/main.nr
diff --git a/test_programs/compile_success_empty/simple_array_param/Nargo.toml b/test_programs/execution_success/simple_array_param/Nargo.toml
similarity index 100%
rename from test_programs/compile_success_empty/simple_array_param/Nargo.toml
rename to test_programs/execution_success/simple_array_param/Nargo.toml
diff --git a/test_programs/compile_success_empty/simple_array_param/Prover.toml b/test_programs/execution_success/simple_array_param/Prover.toml
similarity index 100%
rename from test_programs/compile_success_empty/simple_array_param/Prover.toml
rename to test_programs/execution_success/simple_array_param/Prover.toml
diff --git a/test_programs/compile_success_empty/simple_array_param/src/main.nr b/test_programs/execution_success/simple_array_param/src/main.nr
similarity index 100%
rename from test_programs/compile_success_empty/simple_array_param/src/main.nr
rename to test_programs/execution_success/simple_array_param/src/main.nr
diff --git a/tooling/nargo_fmt/src/visitor/item.rs b/tooling/nargo_fmt/src/visitor/item.rs
index 82cfefba632..a5d042dc71e 100644
--- a/tooling/nargo_fmt/src/visitor/item.rs
+++ b/tooling/nargo_fmt/src/visitor/item.rs
@@ -6,7 +6,7 @@ use crate::{
     },
     visitor::expr::{format_seq, NewlineMode},
 };
-use noirc_frontend::ast::{Distinctness, NoirFunction, Visibility};
+use noirc_frontend::ast::{NoirFunction, Visibility};
 use noirc_frontend::{
     hir::resolution::errors::Span,
     parser::{Item, ItemKind},
@@ -118,10 +118,6 @@ impl super::FmtVisitor<'_> {
         if let Some(span) = return_type_span {
             result.push_str(" -> ");
 
-            if let Distinctness::Distinct = func.def.return_distinctness {
-                result.push_str("distinct ");
-            }
-
             let visibility = match func.def.return_visibility {
                 Visibility::Public => "pub",
                 Visibility::DataBus => "return_data",
diff --git a/tooling/nargo_fmt/tests/expected/fn.nr b/tooling/nargo_fmt/tests/expected/fn.nr
index 0088dba6a8f..3d231cd3f7f 100644
--- a/tooling/nargo_fmt/tests/expected/fn.nr
+++ b/tooling/nargo_fmt/tests/expected/fn.nr
@@ -36,7 +36,7 @@ fn apply_binary_field_op<N>(
     registers: &mut Registers<N>
 ) -> bool {}
 
-fn main() -> distinct pub [Field; 2] {}
+fn main() -> pub [Field; 2] {}
 
 fn ret_normal_lambda1() -> ((fn() -> Field)) {}
 
diff --git a/tooling/nargo_fmt/tests/input/fn.nr b/tooling/nargo_fmt/tests/input/fn.nr
index 26ff5933802..1c6d201fa39 100644
--- a/tooling/nargo_fmt/tests/input/fn.nr
+++ b/tooling/nargo_fmt/tests/input/fn.nr
@@ -23,7 +23,7 @@ fn main(tape: [Field; TAPE_LEN], initial_registers: [Field; REGISTER_COUNT], ini
 
 fn apply_binary_field_op<N>(lhs: RegisterIndex, rhs: RegisterIndex, result: RegisterIndex, op: u8, registers: &mut Registers<N>) -> bool {}
 
-fn main() -> distinct pub [Field;2] {}
+fn main() -> pub [Field;2] {}
 
 fn ret_normal_lambda1() -> ((fn() -> Field)) {}
 

From d4c68066ab35ce1c52510cf0c038fb627a0677c3 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 1 May 2024 17:11:57 +0100
Subject: [PATCH 243/416] fix: Require for all foldable functions to use
 distinct return  (#4949)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…tnesses

# Description

## Problem\*

Found the issue while working on
https://github.com/noir-lang/noir/issues/4608.

## Summary\*

For this program:
```rust
fn main(x: u32, y: pub u32) {
    let new_field = new_field_in_array([x, y, 3]);
    assert(new_field[0] == 25);
}

#[fold]
fn new_field_in_array(mut input: [u32; 3]) -> [u32 ; 3] {
    input[0] = input[0] + 20;
    input
}
```
We get the following ACIR:

Old ACIR:
```
func 0
current witness index : 5
private parameters indices : [0]
public parameters indices : [1]
return value indices : []
BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
BLACKBOX::RANGE [(_1, num_bits: 32)] [ ]
EXPR [ (-1, _2) 3 ]
CALL func 1: PREDICATE = %EXPR [ 1 ]%
inputs: [Witness(0), Witness(1), Witness(2)], outputs: [Witness(3), Witness(4), Witness(5)]
EXPR [ (1, _3) -25 ]

func 1
current witness index : 3
private parameters indices : [0, 1, 2]
public parameters indices : []
return value indices : [1, 2, 3]
BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
BLACKBOX::RANGE [(_1, num_bits: 32)] [ ]
BLACKBOX::RANGE [(_2, num_bits: 32)] [ ]
EXPR [ (1, _0) (-1, _3) 20 ]
BLACKBOX::RANGE [(_3, num_bits: 32)] [ ]
```

One can see how simply the next witness (`_3` in this case) is being
assigned to 20 directly and returned rather than returning it correctly
according to the type. The constraint in the `main` function above will
fail as the returned array will be `[5, 10, 20]` when we want `[20, 5,
10]`. This re-ordering can be mitigated by requiring all returns from
foldable functions to be distinct for which we get the following ACIR:

New ACIR:
The main func is the same.
```
func 0 (same as above)

func 1
current witness index : 6
private parameters indices : [0, 1, 2]
public parameters indices : []
return value indices : [4, 5, 6]
BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
BLACKBOX::RANGE [(_1, num_bits: 32)] [ ]
BLACKBOX::RANGE [(_2, num_bits: 32)] [ ]
EXPR [ (1, _0) (-1, _3) 20 ]
BLACKBOX::RANGE [(_3, num_bits: 32)] [ ]
EXPR [ (1, _3) (-1, _4) 0 ]
EXPR [ (1, _1) (-1, _5) 0 ]
EXPR [ (1, _2) (-1, _6) 0 ]
```

I think just defaulting all return values from foldable functions to be
distinct is going to be the least confusing for users (and we have
discussed making it the default on `main` as well). If we want to add
the ability for a user to not use `distinct` on foldable function return
values that can come in a follow up.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs  | 15 ++++++---------
 .../fold_distinct_return/Nargo.toml               |  7 +++++++
 .../fold_distinct_return/Prover.toml              |  2 ++
 .../fold_distinct_return/src/main.nr              | 10 ++++++++++
 tooling/debugger/ignored-tests.txt                |  1 +
 5 files changed, 26 insertions(+), 9 deletions(-)
 create mode 100644 test_programs/execution_success/fold_distinct_return/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_distinct_return/Prover.toml
 create mode 100644 test_programs/execution_success/fold_distinct_return/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 4a513c7b804..10d58f327e5 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -327,13 +327,9 @@ impl Ssa {
             bytecode: brillig.byte_code,
         });
 
-        // TODO: check whether doing this for a single circuit's return witnesses is correct.
-        // We probably need it for all foldable circuits, as any circuit being folded is essentially an entry point. However, I do not know how that
-        // plays a part when we potentially want not inlined functions normally as part of the compiler.
-        // Also at the moment we specify Distinctness as part of the ABI exclusively rather than the function itself
-        // so this will need to be updated.
-        let main_func_acir = &mut acirs[0];
-        generate_distinct_return_witnesses(main_func_acir);
+        for acir in acirs.iter_mut() {
+            generate_distinct_return_witnesses(acir);
+        }
 
         Ok((acirs, brillig))
     }
@@ -2664,9 +2660,9 @@ mod test {
     #[test]
     #[should_panic]
     fn basic_calls_no_predicates() {
+        basic_call_with_outputs_assert(InlineType::NoPredicates);
         call_output_as_next_call_input(InlineType::NoPredicates);
         basic_nested_call(InlineType::NoPredicates);
-        basic_call_with_outputs_assert(InlineType::NoPredicates);
     }
 
     #[test]
@@ -2909,9 +2905,10 @@ mod test {
 
         let func_with_nested_call_acir = &acir_functions[1];
         let func_with_nested_call_opcodes = func_with_nested_call_acir.opcodes();
+
         assert_eq!(
             func_with_nested_call_opcodes.len(),
-            2,
+            3,
             "Should have an expression and a call to a nested `foo`"
         );
         // Should call foo f2
diff --git a/test_programs/execution_success/fold_distinct_return/Nargo.toml b/test_programs/execution_success/fold_distinct_return/Nargo.toml
new file mode 100644
index 00000000000..f18edb7e49d
--- /dev/null
+++ b/test_programs/execution_success/fold_distinct_return/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_distinct_return"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_distinct_return/Prover.toml b/test_programs/execution_success/fold_distinct_return/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/fold_distinct_return/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/fold_distinct_return/src/main.nr b/test_programs/execution_success/fold_distinct_return/src/main.nr
new file mode 100644
index 00000000000..b0843a02b80
--- /dev/null
+++ b/test_programs/execution_success/fold_distinct_return/src/main.nr
@@ -0,0 +1,10 @@
+fn main(x: u32, y: pub u32) {
+    let new_field = new_field_in_array([x, y, 3]);
+    assert(new_field[0] == 25);
+}
+
+#[fold]
+fn new_field_in_array(mut input: [u32; 3]) -> [u32; 3] {
+    input[0] = input[0] + 20;
+    input
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index eaeea488f3a..cbef395e65c 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -20,4 +20,5 @@ fold_numeric_generic_poseidon
 no_predicates_basic
 no_predicates_numeric_generic_poseidon
 regression_4709
+fold_distinct_return
 fold_fibonacci

From 2e085b935b143c1305b70cd7ae86907b61a45fc0 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 1 May 2024 22:07:08 +0100
Subject: [PATCH 244/416] feat: Complex outputs from acir call (#4952)

# Description

## Problem\*

Resolves #4608

## Summary\*

The change ended up being quite simple where we just have to call the
flattened size on the type rather than `try_get_array_length`. We type
check that any other types such as slices or references are not returned
from the foldable function being called so this call is safe to do. A
test was also included in `fold_complex_outputs` that checks whether we
are able to successfully modify a complex struct in a foldable function
correctly.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 10 +--
 .../fold_complex_outputs/Nargo.toml           |  7 ++
 .../fold_complex_outputs/Prover.toml          |  2 +
 .../fold_complex_outputs/src/main.nr          | 72 +++++++++++++++++++
 tooling/debugger/ignored-tests.txt            |  1 +
 5 files changed, 87 insertions(+), 5 deletions(-)
 create mode 100644 test_programs/execution_success/fold_complex_outputs/Nargo.toml
 create mode 100644 test_programs/execution_success/fold_complex_outputs/Prover.toml
 create mode 100644 test_programs/execution_success/fold_complex_outputs/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 10d58f327e5..65cd9c05992 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -713,11 +713,10 @@ impl<'a> Context<'a> {
                                 assert!(!matches!(inline_type, InlineType::Inline), "ICE: Got an ACIR function named {} that should have already been inlined", func.name());
 
                                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
-                                // TODO(https://github.com/noir-lang/noir/issues/4608): handle complex return types from ACIR functions
-                                let output_count =
-                                    result_ids.iter().fold(0usize, |sum, result_id| {
-                                        sum + dfg.try_get_array_length(*result_id).unwrap_or(1)
-                                    });
+                                let output_count = result_ids
+                                    .iter()
+                                    .map(|result_id| dfg.type_of_value(*result_id).flattened_size())
+                                    .sum();
 
                                 let acir_function_id = ssa
                                     .entry_point_to_generated_index
@@ -729,6 +728,7 @@ impl<'a> Context<'a> {
                                     output_count,
                                     self.current_side_effects_enabled_var,
                                 )?;
+
                                 let output_values =
                                     self.convert_vars_to_values(output_vars, dfg, result_ids);
 
diff --git a/test_programs/execution_success/fold_complex_outputs/Nargo.toml b/test_programs/execution_success/fold_complex_outputs/Nargo.toml
new file mode 100644
index 00000000000..f00c6520b4a
--- /dev/null
+++ b/test_programs/execution_success/fold_complex_outputs/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_complex_outputs"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/fold_complex_outputs/Prover.toml b/test_programs/execution_success/fold_complex_outputs/Prover.toml
new file mode 100644
index 00000000000..a26b97d6471
--- /dev/null
+++ b/test_programs/execution_success/fold_complex_outputs/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "3"
diff --git a/test_programs/execution_success/fold_complex_outputs/src/main.nr b/test_programs/execution_success/fold_complex_outputs/src/main.nr
new file mode 100644
index 00000000000..309d9747598
--- /dev/null
+++ b/test_programs/execution_success/fold_complex_outputs/src/main.nr
@@ -0,0 +1,72 @@
+struct MyStruct {
+    x: u32,
+    y: u32,
+    z: u32,
+    nested_struct: InnerStruct
+}
+
+struct InnerStruct {
+    small_array: [u32; 2],
+    big_array: [u32; 5],
+}
+
+struct ParentStruct {
+    basic_array: [Field; 3],
+    id: u32,
+    my_structs: [MyStruct; 2],
+}
+
+fn main(x: u32, y: pub u32) {
+    let nested_struct = InnerStruct { small_array: [1 as u32; 2], big_array: [0 as u32; 5] };
+    let s = MyStruct { x, y, z: x + y, nested_struct };
+    let parent = ParentStruct { basic_array: [1; 3], id: 100, my_structs: [s, s] };
+    let new_parent = map_fields(parent);
+
+    // Now check that the outputs are as we expect them to be
+    assert(new_parent.basic_array[0] == 1);
+    assert(new_parent.basic_array[1] == 18);
+    assert(new_parent.basic_array[2] == 1);
+
+    let struct_0 = new_parent.my_structs[0];
+    assert(struct_0.x == 5);
+    assert(struct_0.y == 3);
+    assert(struct_0.z == 8);
+    assert(struct_0.nested_struct.small_array == nested_struct.small_array);
+    assert(struct_0.nested_struct.big_array == nested_struct.big_array);
+
+    let struct_1 = new_parent.my_structs[1];
+    assert(struct_1.x == 50);
+    assert(struct_1.y == 30);
+    assert(struct_1.z == 80);
+    assert(struct_1.nested_struct.small_array == [5, 10]);
+    assert(struct_1.nested_struct.big_array == [15, 20, 25, 30, 35]);
+}
+
+// Meaningless mapping to test whether the values returned are what we expect
+#[fold]
+fn map_fields(mut input: ParentStruct) -> ParentStruct {
+    let current_struct = input.my_structs[0];
+    let mut sum = 0;
+    for value in current_struct.nested_struct.small_array {
+        sum += value;
+    }
+    for value in current_struct.nested_struct.big_array {
+        sum += value;
+    }
+    sum += (current_struct.x + current_struct.y + current_struct.z);
+
+    input.basic_array[1] = sum as Field;
+
+    input.my_structs[1].nested_struct.small_array = [5, 10];
+    input.my_structs[1].nested_struct.big_array = [15, 20, 25, 30, 35];
+
+    // LHS input.my_structs[1].x == 50
+    input.my_structs[1].x = input.my_structs[1].x * 10;
+    // LHS input.my_structs[1].y == 30
+    input.my_structs[1].y = input.my_structs[1].y * 10;
+    // LHS input.my_structs[1].x == 80
+    input.my_structs[1].z = input.my_structs[1].x + input.my_structs[1].y;
+
+    input
+}
+
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index cbef395e65c..f2338e85bef 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -22,3 +22,4 @@ no_predicates_numeric_generic_poseidon
 regression_4709
 fold_distinct_return
 fold_fibonacci
+fold_complex_outputs
\ No newline at end of file

From 0154bdef9f6dfe45497d77ecbf3904dcc138b8d7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 2 May 2024 20:45:55 +0100
Subject: [PATCH 245/416] feat: handle empty response foreign calls without an
 external resolver (#4959)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I've modified the `DefaultForeignCallExecutor` so that rather than
panicking on an unrecognised foreign call we return an empty response.

This solves an issue experienced by @spalladino where `nargo test` was
failing due to the use of a custom debugging oracle which doesn't return
any values to the circuit. The only situation where these oracle calls
not being handled would change the outcome of the test would be if they
modify state in an external resolver such as to modify the response of a
different oracle call (and so we'd still fail on those anyway).

## Additional Context

I've cleared up some empty `Prover.toml` files as well.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../noir_test_success/bounded_vec/Prover.toml |  0
 .../brillig_overflow_checks/Prover.toml       |  0
 .../field_comparisons/Prover.toml             |  0
 .../ignored_oracle/Nargo.toml                 |  7 ++
 .../ignored_oracle/src/main.nr                | 23 +++++++
 .../noir_test_success/mock_oracle/Prover.toml |  0
 .../out_of_bounds_alignment/Prover.toml       |  0
 .../should_fail_with_matches/Prover.toml      |  0
 tooling/nargo/src/ops/foreign_calls.rs        | 68 ++++++++++---------
 9 files changed, 67 insertions(+), 31 deletions(-)
 delete mode 100644 test_programs/noir_test_success/bounded_vec/Prover.toml
 delete mode 100644 test_programs/noir_test_success/brillig_overflow_checks/Prover.toml
 delete mode 100644 test_programs/noir_test_success/field_comparisons/Prover.toml
 create mode 100644 test_programs/noir_test_success/ignored_oracle/Nargo.toml
 create mode 100644 test_programs/noir_test_success/ignored_oracle/src/main.nr
 delete mode 100644 test_programs/noir_test_success/mock_oracle/Prover.toml
 delete mode 100644 test_programs/noir_test_success/out_of_bounds_alignment/Prover.toml
 delete mode 100644 test_programs/noir_test_success/should_fail_with_matches/Prover.toml

diff --git a/test_programs/noir_test_success/bounded_vec/Prover.toml b/test_programs/noir_test_success/bounded_vec/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/noir_test_success/brillig_overflow_checks/Prover.toml b/test_programs/noir_test_success/brillig_overflow_checks/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/noir_test_success/field_comparisons/Prover.toml b/test_programs/noir_test_success/field_comparisons/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/noir_test_success/ignored_oracle/Nargo.toml b/test_programs/noir_test_success/ignored_oracle/Nargo.toml
new file mode 100644
index 00000000000..0d9b77c01d7
--- /dev/null
+++ b/test_programs/noir_test_success/ignored_oracle/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "ignored_oracle"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
diff --git a/test_programs/noir_test_success/ignored_oracle/src/main.nr b/test_programs/noir_test_success/ignored_oracle/src/main.nr
new file mode 100644
index 00000000000..9e0bc189939
--- /dev/null
+++ b/test_programs/noir_test_success/ignored_oracle/src/main.nr
@@ -0,0 +1,23 @@
+// In `nargo test` we want to avoid the need for an external oracle resolver service to be required in the situation
+// where its existence doesn't affect whether the tests will pass or fail. We then want to be able to handle any
+// oracles which return zero field elements.
+
+// Note that this custom oracle doesn't return any new values into the program.
+// We can then safely continue execution even in the case where there is no oracle resolver to handle it.
+#[oracle(custom_debug)]
+unconstrained fn custom_debug() {}
+
+// However this oracle call should return a field element. We expect the ACVM to raise an error when it
+// doesn't receive this value.
+#[oracle(custom_getter)]
+unconstrained fn custom_getter() -> Field {}
+
+#[test]
+unconstrained fn unit_return_oracle_ignored() {
+    custom_debug();
+}
+
+#[test(should_fail_with = "0 output values were provided as a foreign call result for 1 destination slots")]
+unconstrained fn field_return_oracle_fails() {
+    let _ = custom_getter();
+}
diff --git a/test_programs/noir_test_success/mock_oracle/Prover.toml b/test_programs/noir_test_success/mock_oracle/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/noir_test_success/out_of_bounds_alignment/Prover.toml b/test_programs/noir_test_success/out_of_bounds_alignment/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test_programs/noir_test_success/should_fail_with_matches/Prover.toml b/test_programs/noir_test_success/should_fail_with_matches/Prover.toml
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index 33767314a37..90313032412 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -315,43 +315,49 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .iter()
                     .position(|response| response.matches(foreign_call_name, &foreign_call.inputs));
 
-                match (mock_response_position, &self.external_resolver) {
-                    (Some(response_position), _) => {
-                        let mock = self
-                            .mocked_responses
-                            .get_mut(response_position)
-                            .expect("Invalid position of mocked response");
-
-                        mock.last_called_params = Some(foreign_call.inputs.clone());
-
-                        let result = mock.result.values.clone();
-
-                        if let Some(times_left) = &mut mock.times_left {
-                            *times_left -= 1;
-                            if *times_left == 0 {
-                                self.mocked_responses.remove(response_position);
-                            }
-                        }
+                if let Some(response_position) = mock_response_position {
+                    // If the program has registered a mocked response to this oracle call then we prefer responding
+                    // with that.
+
+                    let mock = self
+                        .mocked_responses
+                        .get_mut(response_position)
+                        .expect("Invalid position of mocked response");
+
+                    mock.last_called_params = Some(foreign_call.inputs.clone());
+
+                    let result = mock.result.values.clone();
 
-                        Ok(result.into())
+                    if let Some(times_left) = &mut mock.times_left {
+                        *times_left -= 1;
+                        if *times_left == 0 {
+                            self.mocked_responses.remove(response_position);
+                        }
                     }
-                    (None, Some(external_resolver)) => {
-                        let encoded_params: Vec<_> =
-                            foreign_call.inputs.iter().map(build_json_rpc_arg).collect();
 
-                        let req =
-                            external_resolver.build_request(foreign_call_name, &encoded_params);
+                    Ok(result.into())
+                } else if let Some(external_resolver) = &self.external_resolver {
+                    // If the user has registered an external resolver then we forward any remaining oracle calls there.
 
-                        let response = external_resolver.send_request(req)?;
+                    let encoded_params: Vec<_> =
+                        foreign_call.inputs.iter().map(build_json_rpc_arg).collect();
 
-                        let parsed_response: ForeignCallResult = response.result()?;
+                    let req = external_resolver.build_request(foreign_call_name, &encoded_params);
 
-                        Ok(parsed_response.into())
-                    }
-                    (None, None) => panic!(
-                        "No mock for foreign call {}({:?})",
-                        foreign_call_name, &foreign_call.inputs
-                    ),
+                    let response = external_resolver.send_request(req)?;
+
+                    let parsed_response: ForeignCallResult = response.result()?;
+
+                    Ok(parsed_response.into())
+                } else {
+                    // If there's no registered mock oracle response and no registered resolver then we cannot
+                    // return a correct response to the ACVM. The best we can do is to return an empty response,
+                    // this allows us to ignore any foreign calls which exist solely to pass information from inside
+                    // the circuit to the environment (e.g. custom logging) as the execution will still be able to progress.
+                    //
+                    // We optimistically return an empty response for all oracle calls as the ACVM will error
+                    // should a response have been required.
+                    Ok(ForeignCallResult::default().into())
                 }
             }
         }

From f7fa69661006e1e10ddeecee1cdf8f024d6bc3e9 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 2 May 2024 23:34:28 +0100
Subject: [PATCH 246/416] fix: Use annotated type when checking declaration
 (#4966)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4742

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/hir/type_check/stmt.rs   |  4 +++-
 .../slice_init_with_complex_type/Nargo.toml     |  7 +++++++
 .../slice_init_with_complex_type/Prover.toml    |  0
 .../slice_init_with_complex_type/src/main.nr    | 17 +++++++++++++++++
 tooling/debugger/ignored-tests.txt              |  3 ++-
 5 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/execution_success/slice_init_with_complex_type/Nargo.toml
 create mode 100644 test_programs/execution_success/slice_init_with_complex_type/Prover.toml
 create mode 100644 test_programs/execution_success/slice_init_with_complex_type/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index f5f6e1e8180..0760749c9e0 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -348,8 +348,10 @@ impl<'interner> TypeChecker<'interner> {
             if annotated_type.is_unsigned() {
                 self.lint_overflowing_uint(&rhs_expr, &annotated_type);
             }
+            annotated_type
+        } else {
+            expr_type
         }
-        expr_type
     }
 
     /// Check if an assignment is overflowing with respect to `annotated_type`
diff --git a/test_programs/execution_success/slice_init_with_complex_type/Nargo.toml b/test_programs/execution_success/slice_init_with_complex_type/Nargo.toml
new file mode 100644
index 00000000000..a372caf92e9
--- /dev/null
+++ b/test_programs/execution_success/slice_init_with_complex_type/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "slice_init_with_complex_type"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/slice_init_with_complex_type/Prover.toml b/test_programs/execution_success/slice_init_with_complex_type/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/execution_success/slice_init_with_complex_type/src/main.nr b/test_programs/execution_success/slice_init_with_complex_type/src/main.nr
new file mode 100644
index 00000000000..01ccf2fdeff
--- /dev/null
+++ b/test_programs/execution_success/slice_init_with_complex_type/src/main.nr
@@ -0,0 +1,17 @@
+struct strct1 {
+    elem1: Field,
+}
+
+fn main() {
+    let var1: [[i32; 1]] = [[0]];
+    let var2: [[i32; 1]] = var1;
+
+    let var1: [(i32, u8)] = [(1, 2)];
+    let var2: [(i32, u8)] = var1;
+
+    let var3: [strct1] = [strct1 { elem1: 1321351 }];
+    let var4: [strct1] = var3;
+
+    let var1: [i32; 1] = [0];
+    let var2: [[i32; 1]] = [var1];
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index f2338e85bef..fccf4566258 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -22,4 +22,5 @@ no_predicates_numeric_generic_poseidon
 regression_4709
 fold_distinct_return
 fold_fibonacci
-fold_complex_outputs
\ No newline at end of file
+fold_complex_outputs
+slice_init_with_complex_type
\ No newline at end of file

From e04deec8018c686ba25f905bcc6e94af6270fc84 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Fri, 3 May 2024 15:12:25 +0100
Subject: [PATCH 247/416] chore: Switch Noir JS to use execute program instead
 of circuit (#4965)

# Description

## Problem\*

Resolves #4706

## Summary\*

This PR actually does not do too much as we still use
`executeCircuitWithBlackBoxSolver` throughout the ACIR simulator on
aztec. That should be removed separately before we look to remove it
from ACVM JS. Noir JS backend also needs to wait for the barretenberg
interface updates before we can pass a collection of circuits to the
backend.

## Additional Context


## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noir_js/scripts/compile_test_programs.sh  |  2 ++
 tooling/noir_js/src/program.ts                |  9 ++++----
 tooling/noir_js/src/witness_generation.ts     |  8 +++----
 tooling/noir_js/test/node/e2e.test.ts         | 23 +++++++++++++++++++
 tooling/noir_js/test/node/execute.test.ts     | 14 +++++++++++
 .../fold_fibonacci/Nargo.toml                 |  7 ++++++
 .../fold_fibonacci/src/main.nr                | 12 ++++++++++
 7 files changed, 67 insertions(+), 8 deletions(-)
 create mode 100644 tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/Nargo.toml
 create mode 100644 tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/src/main.nr

diff --git a/tooling/noir_js/scripts/compile_test_programs.sh b/tooling/noir_js/scripts/compile_test_programs.sh
index 5257aaae696..23a4cffc072 100755
--- a/tooling/noir_js/scripts/compile_test_programs.sh
+++ b/tooling/noir_js/scripts/compile_test_programs.sh
@@ -3,3 +3,5 @@
 rm -rf ./test/noir_compiled_examples/**/target
 nargo --program-dir ./test/noir_compiled_examples/assert_lt compile --force
 nargo --program-dir ./test/noir_compiled_examples/assert_msg_runtime compile --force
+nargo --program-dir ./test/noir_compiled_examples/fold_fibonacci compile --force
+
diff --git a/tooling/noir_js/src/program.ts b/tooling/noir_js/src/program.ts
index 8d80ec3a247..86aa0f60ddf 100644
--- a/tooling/noir_js/src/program.ts
+++ b/tooling/noir_js/src/program.ts
@@ -2,7 +2,7 @@
 import { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
 import { generateWitness } from './witness_generation.js';
 import initAbi, { abiDecode, InputMap, InputValue } from '@noir-lang/noirc_abi';
-import initACVM, { compressWitness, ForeignCallHandler } from '@noir-lang/acvm_js';
+import initACVM, { compressWitnessStack, ForeignCallHandler } from '@noir-lang/acvm_js';
 
 export class Noir {
   constructor(
@@ -55,9 +55,10 @@ export class Noir {
     foreignCallHandler?: ForeignCallHandler,
   ): Promise<{ witness: Uint8Array; returnValue: InputValue }> {
     await this.init();
-    const witness = await generateWitness(this.circuit, inputs, foreignCallHandler);
-    const { return_value: returnValue } = abiDecode(this.circuit.abi, witness);
-    return { witness: compressWitness(witness), returnValue };
+    const witness_stack = await generateWitness(this.circuit, inputs, foreignCallHandler);
+    const main_witness = witness_stack[0].witness;
+    const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);
+    return { witness: compressWitnessStack(witness_stack), returnValue };
   }
 
   /**
diff --git a/tooling/noir_js/src/witness_generation.ts b/tooling/noir_js/src/witness_generation.ts
index cef1d817d9b..67dcc774288 100644
--- a/tooling/noir_js/src/witness_generation.ts
+++ b/tooling/noir_js/src/witness_generation.ts
@@ -1,12 +1,12 @@
 import { abiEncode, InputMap } from '@noir-lang/noirc_abi';
 import { base64Decode } from './base64_decode.js';
 import {
-  WitnessMap,
+  WitnessStack,
   ForeignCallHandler,
   ForeignCallInput,
   createBlackBoxSolver,
   WasmBlackBoxFunctionSolver,
-  executeCircuitWithBlackBoxSolver,
+  executeProgramWithBlackBoxSolver,
 } from '@noir-lang/acvm_js';
 import { CompiledCircuit } from '@noir-lang/types';
 
@@ -41,14 +41,14 @@ export async function generateWitness(
   compiledProgram: CompiledCircuit,
   inputs: InputMap,
   foreignCallHandler: ForeignCallHandler = defaultForeignCallHandler,
-): Promise<WitnessMap> {
+): Promise<WitnessStack> {
   // Throws on ABI encoding error
   const witnessMap = abiEncode(compiledProgram.abi, inputs);
 
   // Execute the circuit to generate the rest of the witnesses and serialize
   // them into a Uint8Array.
   try {
-    const solvedWitness = await executeCircuitWithBlackBoxSolver(
+    const solvedWitness = await executeProgramWithBlackBoxSolver(
       await getSolver(),
       base64Decode(compiledProgram.bytecode),
       witnessMap,
diff --git a/tooling/noir_js/test/node/e2e.test.ts b/tooling/noir_js/test/node/e2e.test.ts
index 979841c47e6..dbb9abcc964 100644
--- a/tooling/noir_js/test/node/e2e.test.ts
+++ b/tooling/noir_js/test/node/e2e.test.ts
@@ -1,10 +1,12 @@
 import { expect } from 'chai';
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
+import fold_fibonacci_json from '../noir_compiled_examples/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
 import { BarretenbergBackend as Backend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
 import { CompiledCircuit } from '@noir-lang/types';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
+const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
 it('end-to-end proof creation and verification (outer)', async () => {
   // Noir.Js part
@@ -149,3 +151,24 @@ it('[BUG] -- bb.js null function or function signature mismatch (outer-inner) ',
   const isValidInner = await prover.verifyProof(_proofInner);
   expect(isValidInner).to.be.true;
 });
+
+it('end-to-end proof creation and verification for multiple ACIR circuits (inner)', async () => {
+  // Noir.Js part
+  const inputs = {
+    x: '10',
+  };
+
+  const program = new Noir(fold_fibonacci_program);
+
+  const { witness } = await program.execute(inputs);
+
+  // bb.js part
+  //
+  // Proof creation
+  const backend = new Backend(fold_fibonacci_program);
+  const proof = await backend.generateProof(witness);
+
+  // Proof verification
+  const isValid = await backend.verifyProof(proof);
+  expect(isValid).to.be.true;
+});
diff --git a/tooling/noir_js/test/node/execute.test.ts b/tooling/noir_js/test/node/execute.test.ts
index 491bcb0dfc4..8c02ac90a3d 100644
--- a/tooling/noir_js/test/node/execute.test.ts
+++ b/tooling/noir_js/test/node/execute.test.ts
@@ -1,11 +1,13 @@
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
 import assert_msg_json from '../noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json' assert { type: 'json' };
+import fold_fibonacci_json from '../noir_compiled_examples/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
 import { CompiledCircuit } from '@noir-lang/types';
 import { expect } from 'chai';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
 const assert_msg_runtime = assert_msg_json as CompiledCircuit;
+const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
 it('returns the return value of the circuit', async () => {
   const inputs = {
@@ -29,3 +31,15 @@ it('circuit with a dynamic assert message should fail on an assert failure not t
     expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
   }
 });
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
+  }
+});
diff --git a/tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/Nargo.toml b/tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/Nargo.toml
new file mode 100644
index 00000000000..6d8214689b0
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_fibonacci"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/src/main.nr
new file mode 100644
index 00000000000..e150a586086
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/src/main.nr
@@ -0,0 +1,12 @@
+fn main(x: u32) {
+    assert(fibonacci(x) == 55);
+}
+
+#[fold]
+fn fibonacci(x: u32) -> u32 {
+    if x <= 1 {
+        x
+    } else {
+        fibonacci(x - 1) + fibonacci(x - 2)
+    }
+}

From 102ff133cb174bce740f558df6f55de667c033b3 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Fri, 3 May 2024 18:39:16 +0200
Subject: [PATCH 248/416] chore: rename instruction checks for side effects
 (#4945)

# Description

## Problem\*

Resolves #4237

## Summary\*
I replace is_pure() and has_side_effect() by can_be_replaced() and
can_eliminate_if_unused(), the former using
requires_acir_gen_predicate() which indicates if the instructions will
depend on the side_effect_enabled variable.


## Additional Context
I did not renamed has_side_effect() for Intrinsic because I believe the
name is accurate here.


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/ir/instruction.rs | 81 +++++++++++++------
 .../src/ssa/opt/constant_folding.rs           | 11 ++-
 compiler/noirc_evaluator/src/ssa/opt/die.rs   |  8 +-
 3 files changed, 64 insertions(+), 36 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 04f33d528cd..b6f11f45c07 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -242,20 +242,11 @@ impl Instruction {
         matches!(self.result_type(), InstructionResultType::Unknown)
     }
 
-    /// Pure `Instructions` are instructions which have no side-effects and results are a function of the inputs only,
-    /// i.e. there are no interactions with memory.
-    ///
-    /// Pure instructions can be replaced with the results of another pure instruction with the same inputs.
-    pub(crate) fn is_pure(&self, dfg: &DataFlowGraph) -> bool {
+    /// Indicates if the instruction can be safely replaced with the results of another instruction with the same inputs.
+    pub(crate) fn can_be_deduplicated(&self, dfg: &DataFlowGraph) -> bool {
         use Instruction::*;
 
         match self {
-            Binary(bin) => {
-                // In ACIR, a division with a false predicate outputs (0,0), so it cannot replace another instruction unless they have the same predicate
-                bin.operator != BinaryOp::Div
-            }
-            Cast(_, _) | Truncate { .. } | Not(_) => true,
-
             // These either have side-effects or interact with memory
             Constrain(..)
             | EnableSideEffects { .. }
@@ -266,31 +257,36 @@ impl Instruction {
             | DecrementRc { .. }
             | RangeCheck { .. } => false,
 
-            // These can have different behavior depending on the EnableSideEffectsIf context.
-            // Enabling constant folding for these potentially enables replacing an enabled
-            // array get with one that was disabled. See
-            // https://github.com/noir-lang/noir/pull/4716#issuecomment-2047846328.
-            ArrayGet { .. } | ArraySet { .. } => false,
-
             Call { func, .. } => match dfg[*func] {
                 Value::Intrinsic(intrinsic) => !intrinsic.has_side_effects(),
                 _ => false,
             },
+
+            // These can have different behavior depending on the EnableSideEffectsIf context.
+            // Replacing them with a similar instruction potentially enables replacing an instruction
+            // with one that was disabled. See
+            // https://github.com/noir-lang/noir/pull/4716#issuecomment-2047846328.
+            Binary(_)
+            | Cast(_, _)
+            | Not(_)
+            | Truncate { .. }
+            | ArrayGet { .. }
+            | ArraySet { .. } => !self.requires_acir_gen_predicate(dfg),
         }
     }
 
-    pub(crate) fn has_side_effects(&self, dfg: &DataFlowGraph) -> bool {
+    pub(crate) fn can_eliminate_if_unused(&self, dfg: &DataFlowGraph) -> bool {
         use Instruction::*;
         match self {
             Binary(binary) => {
                 if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) {
                     if let Some(rhs) = dfg.get_numeric_constant(binary.rhs) {
-                        rhs == FieldElement::zero()
+                        rhs != FieldElement::zero()
                     } else {
-                        true
+                        false
                     }
                 } else {
-                    false
+                    true
                 }
             }
             Cast(_, _)
@@ -299,32 +295,65 @@ impl Instruction {
             | Allocate
             | Load { .. }
             | ArrayGet { .. }
-            | ArraySet { .. } => false,
+            | ArraySet { .. } => true,
 
             Constrain(..)
             | Store { .. }
             | EnableSideEffects { .. }
             | IncrementRc { .. }
             | DecrementRc { .. }
-            | RangeCheck { .. } => true,
+            | RangeCheck { .. } => false,
 
             // Some `Intrinsic`s have side effects so we must check what kind of `Call` this is.
             Call { func, .. } => match dfg[*func] {
-                Value::Intrinsic(intrinsic) => intrinsic.has_side_effects(),
+                Value::Intrinsic(intrinsic) => !intrinsic.has_side_effects(),
 
                 // All foreign functions are treated as having side effects.
                 // This is because they can be used to pass information
                 // from the ACVM to the external world during execution.
-                Value::ForeignFunction(_) => true,
+                Value::ForeignFunction(_) => false,
 
                 // We must assume that functions contain a side effect as we cannot inspect more deeply.
-                Value::Function(_) => true,
+                Value::Function(_) => false,
 
                 _ => false,
             },
         }
     }
 
+    /// If true the instruction will depends on enable_side_effects context during acir-gen
+    fn requires_acir_gen_predicate(&self, dfg: &DataFlowGraph) -> bool {
+        match self {
+            Instruction::Binary(binary)
+                if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) =>
+            {
+                true
+            }
+            Instruction::EnableSideEffects { .. }
+            | Instruction::ArrayGet { .. }
+            | Instruction::ArraySet { .. } => true,
+
+            Instruction::Call { func, .. } => match dfg[*func] {
+                Value::Function(_) => true,
+                Value::Intrinsic(intrinsic) => {
+                    matches!(intrinsic, Intrinsic::SliceInsert | Intrinsic::SliceRemove)
+                }
+                _ => false,
+            },
+            Instruction::Cast(_, _)
+            | Instruction::Binary(_)
+            | Instruction::Not(_)
+            | Instruction::Truncate { .. }
+            | Instruction::Constrain(_, _, _)
+            | Instruction::RangeCheck { .. }
+            | Instruction::Allocate
+            | Instruction::Load { .. }
+            | Instruction::Store { .. }
+            | Instruction::IncrementRc { .. }
+            | Instruction::DecrementRc { .. } => false,
+        }
+    }
+
     /// Maps each ValueId inside this instruction to a new ValueId, returning the new instruction.
     /// Note that the returned instruction is fresh and will not have an assigned InstructionId
     /// until it is manually inserted in a DataFlowGraph later.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index 5a7134f3486..ac2f6424332 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -6,9 +6,8 @@
 //!   by the [`DataFlowGraph`] automatically as new instructions are pushed.
 //! - Check whether any input values have been constrained to be equal to a value of a simpler form
 //!   by a [constrain instruction][Instruction::Constrain]. If so, replace the input value with the simpler form.
-//! - Check whether the instruction is [pure][Instruction::is_pure()]
-//!   and there exists a duplicate instruction earlier in the same block.
-//!   If so, the instruction can be replaced with the results of this previous instruction.
+//! - Check whether the instruction [can_be_replaced][Instruction::can_be_replaced()]
+//!   by duplicate instruction earlier in the same block.
 //!
 //! These operations are done in parallel so that they can each benefit from each other
 //! without the need for multiple passes.
@@ -257,9 +256,9 @@ impl Context {
             }
         }
 
-        // If the instruction doesn't have side-effects, cache the results so we can reuse them if
-        // the same instruction appears again later in the block.
-        if instruction.is_pure(dfg) {
+        // If the instruction doesn't have side-effects and if it won't interact with enable_side_effects during acir_gen,
+        // we cache the results so we can reuse them if the same instruction appears again later in the block.
+        if instruction.can_be_deduplicated(dfg) {
             instruction_result_cache.insert(instruction, instruction_results);
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index d1b3e1e83f5..d045762f9e9 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -108,12 +108,12 @@ impl Context {
     fn is_unused(&self, instruction_id: InstructionId, function: &Function) -> bool {
         let instruction = &function.dfg[instruction_id];
 
-        if instruction.has_side_effects(&function.dfg) {
-            // If the instruction has side effects we should never remove it.
-            false
-        } else {
+        if instruction.can_eliminate_if_unused(&function.dfg) {
             let results = function.dfg.instruction_results(instruction_id);
             results.iter().all(|result| !self.used_values.contains(result))
+        } else {
+            // If the instruction has side effects we should never remove it.
+            false
         }
     }
 

From a87c655c6c8c077c71e3372cc9181b7870348a3d Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 3 May 2024 12:31:18 -0500
Subject: [PATCH 249/416] feat: Optimize array sets in if conditions (alternate
 version) (#4716)

# Description

## Problem\*

Alternate version of https://github.com/noir-lang/noir/pull/4695

Resolves https://github.com/noir-lang/noir/issues/4692

## Summary\*

- Flattening produces a new `IfElse` instruction to merge values instead
of immediately merging them
- `IfElse` instructions are removed by actually merging the values once
flattening and mem2reg is done. This is done in a new remove_if_else
pass.
- Since slice capacity tracking was done in flattening before and
required to merge values, I've had to move this to the remove_if_else
pass instead. It is somewhat simpler since we don't have to track
loads/stores.

## Additional Context

Currently only failing the nested_array_in_slice and
nested_array_dynamic tests.
The array being asserted somehow has the value `[1, 2, 3]` despite none
of these values being set in the program.

There are currently no actual optimizations here, this is just
structural changes so it should otherwise be equivalent.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: vezenovm <mvezenov@gmail.com>
---
 .../src/brillig/brillig_gen/brillig_block.rs  |   5 +-
 compiler/noirc_evaluator/src/ssa.rs           |   1 +
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |   4 +
 compiler/noirc_evaluator/src/ssa/ir/dfg.rs    |  23 +-
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  63 ++++-
 .../src/ssa/ir/instruction/call.rs            |   4 +-
 .../noirc_evaluator/src/ssa/ir/printer.rs     |  12 +-
 .../src/ssa/opt/flatten_cfg.rs                |  95 ++-----
 .../ssa/opt/flatten_cfg/capacity_tracker.rs   |   4 +-
 .../src/ssa/opt/flatten_cfg/value_merger.rs   | 244 +++++++++++++++---
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |   1 +
 .../src/ssa/opt/remove_enable_side_effects.rs |   1 +
 .../src/ssa/opt/remove_if_else.rs             | 236 +++++++++++++++++
 .../nested_array_dynamic_simple/Nargo.toml    |   7 +
 .../nested_array_dynamic_simple/Prover.toml   |   1 +
 .../nested_array_dynamic_simple/src/main.nr   |   9 +
 16 files changed, 601 insertions(+), 109 deletions(-)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
 create mode 100644 test_programs/execution_success/nested_array_dynamic_simple/Nargo.toml
 create mode 100644 test_programs/execution_success/nested_array_dynamic_simple/Prover.toml
 create mode 100644 test_programs/execution_success/nested_array_dynamic_simple/src/main.nr

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 8dc7ccb9ac0..ff8d33c0fdc 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -631,7 +631,7 @@ impl<'block> BrilligBlock<'block> {
                     destination_variable,
                 );
             }
-            Instruction::ArraySet { array, index, value, .. } => {
+            Instruction::ArraySet { array, index, value, mutable: _ } => {
                 let source_variable = self.convert_ssa_value(*array, dfg);
                 let index_register = self.convert_ssa_single_addr_value(*index, dfg);
                 let value_variable = self.convert_ssa_value(*value, dfg);
@@ -712,6 +712,9 @@ impl<'block> BrilligBlock<'block> {
             Instruction::EnableSideEffects { .. } => {
                 todo!("enable_side_effects not supported by brillig")
             }
+            Instruction::IfElse { .. } => {
+                unreachable!("IfElse instructions should not be possible in brillig")
+            }
         };
 
         let dead_variables = self
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 89ef74c7406..ffe3b380c1a 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -59,6 +59,7 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
         // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
+        .run_pass(Ssa::remove_if_else, "After Remove IfElse:")
         // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
         // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
         .run_pass(Ssa::inline_functions_with_no_predicates, "After Inlining:")
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 65cd9c05992..55c11e06ca3 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -686,6 +686,9 @@ impl<'a> Context<'a> {
                     assert_message.clone(),
                 )?;
             }
+            Instruction::IfElse { .. } => {
+                unreachable!("IfElse instruction remaining in acir-gen")
+            }
         }
 
         self.acir_context.set_call_stack(CallStack::new());
@@ -1009,6 +1012,7 @@ impl<'a> Context<'a> {
                             });
                         }
                     };
+
                     if self.acir_context.is_constant_one(&self.current_side_effects_enabled_var) {
                         // Report the error if side effects are enabled.
                         if index >= array_size {
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
index 6b950c327cf..85630b75614 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
@@ -554,7 +554,10 @@ impl<'dfg> InsertInstructionResult<'dfg> {
         match self {
             InsertInstructionResult::SimplifiedTo(value) => *value,
             InsertInstructionResult::SimplifiedToMultiple(values) => values[0],
-            InsertInstructionResult::Results(_, results) => results[0],
+            InsertInstructionResult::Results(_, results) => {
+                assert_eq!(results.len(), 1);
+                results[0]
+            }
             InsertInstructionResult::InstructionRemoved => {
                 panic!("Instruction was removed, no results")
             }
@@ -583,6 +586,24 @@ impl<'dfg> InsertInstructionResult<'dfg> {
     }
 }
 
+impl<'dfg> std::ops::Index<usize> for InsertInstructionResult<'dfg> {
+    type Output = ValueId;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        match self {
+            InsertInstructionResult::Results(_, results) => &results[index],
+            InsertInstructionResult::SimplifiedTo(result) => {
+                assert_eq!(index, 0);
+                result
+            }
+            InsertInstructionResult::SimplifiedToMultiple(results) => &results[index],
+            InsertInstructionResult::InstructionRemoved => {
+                panic!("Cannot index into InsertInstructionResult::InstructionRemoved")
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::DataFlowGraph;
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index b6f11f45c07..11e3fc940b6 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -1,6 +1,8 @@
 use acvm::{acir::BlackBoxFunc, FieldElement};
 use iter_extended::vecmap;
 
+use crate::ssa::opt::flatten_cfg::value_merger::ValueMerger;
+
 use super::{
     basic_block::BasicBlockId,
     dfg::{CallStack, DataFlowGraph},
@@ -206,6 +208,14 @@ pub(crate) enum Instruction {
     /// implemented via reference counting. In ACIR code this is done with im::Vector and these
     /// DecrementRc instructions are ignored.
     DecrementRc { value: ValueId },
+
+    /// Merge two values returned from opposite branches of a conditional into one.
+    IfElse {
+        then_condition: ValueId,
+        then_value: ValueId,
+        else_condition: ValueId,
+        else_value: ValueId,
+    },
 }
 
 impl Instruction {
@@ -219,10 +229,12 @@ impl Instruction {
         match self {
             Instruction::Binary(binary) => binary.result_type(),
             Instruction::Cast(_, typ) => InstructionResultType::Known(typ.clone()),
-            Instruction::Not(value) | Instruction::Truncate { value, .. } => {
+            Instruction::Not(value)
+            | Instruction::Truncate { value, .. }
+            | Instruction::ArraySet { array: value, .. }
+            | Instruction::IfElse { then_value: value, .. } => {
                 InstructionResultType::Operand(*value)
             }
-            Instruction::ArraySet { array, .. } => InstructionResultType::Operand(*array),
             Instruction::Constrain(..)
             | Instruction::Store { .. }
             | Instruction::IncrementRc { .. }
@@ -270,6 +282,7 @@ impl Instruction {
             | Cast(_, _)
             | Not(_)
             | Truncate { .. }
+            | IfElse { .. }
             | ArrayGet { .. }
             | ArraySet { .. } => !self.requires_acir_gen_predicate(dfg),
         }
@@ -295,6 +308,7 @@ impl Instruction {
             | Allocate
             | Load { .. }
             | ArrayGet { .. }
+            | IfElse { .. }
             | ArraySet { .. } => true,
 
             Constrain(..)
@@ -349,6 +363,7 @@ impl Instruction {
             | Instruction::Allocate
             | Instruction::Load { .. }
             | Instruction::Store { .. }
+            | Instruction::IfElse { .. }
             | Instruction::IncrementRc { .. }
             | Instruction::DecrementRc { .. } => false,
         }
@@ -416,6 +431,14 @@ impl Instruction {
                     assert_message: assert_message.clone(),
                 }
             }
+            Instruction::IfElse { then_condition, then_value, else_condition, else_value } => {
+                Instruction::IfElse {
+                    then_condition: f(*then_condition),
+                    then_value: f(*then_value),
+                    else_condition: f(*else_condition),
+                    else_value: f(*else_value),
+                }
+            }
         }
     }
 
@@ -473,6 +496,12 @@ impl Instruction {
             | Instruction::RangeCheck { value, .. } => {
                 f(*value);
             }
+            Instruction::IfElse { then_condition, then_value, else_condition, else_value } => {
+                f(*then_condition);
+                f(*then_value);
+                f(*else_condition);
+                f(*else_value);
+            }
         }
     }
 
@@ -624,6 +653,36 @@ impl Instruction {
                     None
                 }
             }
+            Instruction::IfElse { then_condition, then_value, else_condition, else_value } => {
+                let typ = dfg.type_of_value(*then_value);
+
+                if let Some(constant) = dfg.get_numeric_constant(*then_condition) {
+                    if constant.is_one() {
+                        return SimplifiedTo(*then_value);
+                    } else if constant.is_zero() {
+                        return SimplifiedTo(*else_value);
+                    }
+                }
+
+                if matches!(&typ, Type::Numeric(_)) {
+                    let then_condition = *then_condition;
+                    let then_value = *then_value;
+                    let else_condition = *else_condition;
+                    let else_value = *else_value;
+
+                    let result = ValueMerger::merge_numeric_values(
+                        dfg,
+                        block,
+                        then_condition,
+                        else_condition,
+                        then_value,
+                        else_value,
+                    );
+                    SimplifiedTo(result)
+                } else {
+                    None
+                }
+            }
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 1187ea8cb07..dcde0aa79be 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -354,7 +354,9 @@ fn simplify_slice_push_back(
     slice_sizes.insert(set_last_slice_value, slice_size / element_size);
     slice_sizes.insert(new_slice, slice_size / element_size);
 
-    let mut value_merger = ValueMerger::new(dfg, block, &mut slice_sizes);
+    let unknown = &mut HashMap::default();
+    let mut value_merger = ValueMerger::new(dfg, block, &mut slice_sizes, unknown, None);
+
     let new_slice = value_merger.merge_values(
         len_not_equals_capacity,
         len_equals_capacity,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index d17d2989341..23395617c85 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -184,7 +184,7 @@ fn display_instruction_inner(
             let index = show(*index);
             let value = show(*value);
             let mutable = if *mutable { " mut" } else { "" };
-            writeln!(f, "array_set{mutable} {array}, index {index}, value {value}",)
+            writeln!(f, "array_set{mutable} {array}, index {index}, value {value}")
         }
         Instruction::IncrementRc { value } => {
             writeln!(f, "inc_rc {}", show(*value))
@@ -195,6 +195,16 @@ fn display_instruction_inner(
         Instruction::RangeCheck { value, max_bit_size, .. } => {
             writeln!(f, "range_check {} to {} bits", show(*value), *max_bit_size,)
         }
+        Instruction::IfElse { then_condition, then_value, else_condition, else_value } => {
+            let then_condition = show(*then_condition);
+            let then_value = show(*then_value);
+            let else_condition = show(*else_condition);
+            let else_value = show(*else_value);
+            writeln!(
+                f,
+                "if {then_condition} then {then_value} else if {else_condition} then {else_value}"
+            )
+        }
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index 07771397ce8..0f8b49b40ec 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -155,9 +155,6 @@ mod branch_analysis;
 mod capacity_tracker;
 pub(crate) mod value_merger;
 
-use capacity_tracker::SliceCapacityTracker;
-use value_merger::ValueMerger;
-
 impl Ssa {
     /// Flattens the control flow graph of main such that the function is left with a
     /// single block containing all instructions and no more control-flow.
@@ -311,18 +308,6 @@ impl<'f> Context<'f> {
         if self.inserter.function.entry_block() == block {
             // we do not inline the entry block into itself
             // for the outer block before we start inlining
-            let outer_block_instructions = self.inserter.function.dfg[block].instructions();
-            let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-            for instruction in outer_block_instructions {
-                let results = self.inserter.function.dfg.instruction_results(*instruction);
-                let instruction = &self.inserter.function.dfg[*instruction];
-                capacity_tracker.collect_slice_information(
-                    instruction,
-                    &mut self.slice_sizes,
-                    results.to_vec(),
-                );
-            }
-
             return;
         }
 
@@ -333,14 +318,7 @@ impl<'f> Context<'f> {
         // unnecessary, when removing it actually causes an aliasing/mutability error.
         let instructions = self.inserter.function.dfg[block].instructions().to_vec();
         for instruction in instructions.iter() {
-            let results = self.push_instruction(*instruction);
-            let (instruction, _) = self.inserter.map_instruction(*instruction);
-            let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-            capacity_tracker.collect_slice_information(
-                &instruction,
-                &mut self.slice_sizes,
-                results,
-            );
+            self.push_instruction(*instruction);
         }
     }
 
@@ -543,24 +521,19 @@ impl<'f> Context<'f> {
 
         let block = self.inserter.function.entry_block();
 
-        // Make sure we have tracked the slice capacities of any block arguments
-        let capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-        for (then_arg, else_arg) in args.iter() {
-            capacity_tracker.compute_slice_capacity(*then_arg, &mut self.slice_sizes);
-            capacity_tracker.compute_slice_capacity(*else_arg, &mut self.slice_sizes);
-        }
-
-        let mut value_merger =
-            ValueMerger::new(&mut self.inserter.function.dfg, block, &mut self.slice_sizes);
-
         // Cannot include this in the previous vecmap since it requires exclusive access to self
         let args = vecmap(args, |(then_arg, else_arg)| {
-            value_merger.merge_values(
-                cond_context.then_branch.condition,
-                cond_context.else_branch.clone().unwrap().condition,
-                then_arg,
-                else_arg,
-            )
+            let instruction = Instruction::IfElse {
+                then_condition: cond_context.then_branch.condition,
+                then_value: then_arg,
+                else_condition: cond_context.else_branch.as_ref().unwrap().condition,
+                else_value: else_arg,
+            };
+            self.inserter
+                .function
+                .dfg
+                .insert_instruction_and_results(instruction, block, None, CallStack::new())
+                .first()
         });
 
         self.merge_stores(cond_context.then_branch, cond_context.else_branch);
@@ -643,15 +616,6 @@ impl<'f> Context<'f> {
             }
         }
 
-        // Most slice information is collected when instructions are inlined.
-        // We need to collect information on slice values here as we may possibly merge stores
-        // before any inlining occurs.
-        let capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-        for (then_case, else_case, _) in new_map.values() {
-            capacity_tracker.compute_slice_capacity(*then_case, &mut self.slice_sizes);
-            capacity_tracker.compute_slice_capacity(*else_case, &mut self.slice_sizes);
-        }
-
         let then_condition = then_branch.condition;
         let else_condition = if let Some(branch) = else_branch {
             branch.condition
@@ -660,13 +624,22 @@ impl<'f> Context<'f> {
         };
         let block = self.inserter.function.entry_block();
 
-        let mut value_merger =
-            ValueMerger::new(&mut self.inserter.function.dfg, block, &mut self.slice_sizes);
         // Merging must occur in a separate loop as we cannot borrow `self` as mutable while `value_merger` does
         let mut new_values = HashMap::default();
         for (address, (then_case, else_case, _)) in &new_map {
-            let value =
-                value_merger.merge_values(then_condition, else_condition, *then_case, *else_case);
+            let instruction = Instruction::IfElse {
+                then_condition,
+                then_value: *then_case,
+                else_condition,
+                else_value: *else_case,
+            };
+            let value = self
+                .inserter
+                .function
+                .dfg
+                .insert_instruction_and_results(instruction, block, None, CallStack::new())
+                .first();
+
             new_values.insert(address, value);
         }
 
@@ -683,16 +656,6 @@ impl<'f> Context<'f> {
                     .insert(address, Store { old_value: *old_value, new_value: value });
             }
         }
-
-        // Collect any potential slice information on the stores we are merging
-        for (address, (_, _, _)) in &new_map {
-            let value = new_values[address];
-            let address = *address;
-            let instruction = Instruction::Store { address, value };
-
-            let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-            capacity_tracker.collect_slice_information(&instruction, &mut self.slice_sizes, vec![]);
-        }
     }
 
     fn remember_store(&mut self, address: ValueId, new_value: ValueId) {
@@ -706,14 +669,6 @@ impl<'f> Context<'f> {
                 let old_value =
                     self.insert_instruction_with_typevars(load.clone(), load_type).first();
 
-                // Need this or else we will be missing a the previous value of a slice that we wish to merge
-                let mut capacity_tracker = SliceCapacityTracker::new(&self.inserter.function.dfg);
-                capacity_tracker.collect_slice_information(
-                    &load,
-                    &mut self.slice_sizes,
-                    vec![old_value],
-                );
-
                 self.store_values.insert(address, Store { old_value, new_value });
             }
         }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
index 93e52542278..4fc19acd2ac 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
@@ -19,10 +19,10 @@ impl<'a> SliceCapacityTracker<'a> {
 
     /// Determine how the slice sizes map needs to be updated according to the provided instruction.
     pub(crate) fn collect_slice_information(
-        &mut self,
+        &self,
         instruction: &Instruction,
         slice_sizes: &mut HashMap<ValueId, usize>,
-        results: Vec<ValueId>,
+        results: &[ValueId],
     ) {
         match instruction {
             Instruction::ArrayGet { array, .. } => {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
index 0a351148fa3..c47d594545c 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
@@ -1,20 +1,25 @@
 use acvm::FieldElement;
-use fxhash::FxHashMap as HashMap;
+use fxhash::{FxHashMap as HashMap, FxHashSet};
 
 use crate::ssa::ir::{
     basic_block::BasicBlockId,
-    dfg::{CallStack, DataFlowGraph},
+    dfg::{CallStack, DataFlowGraph, InsertInstructionResult},
     instruction::{BinaryOp, Instruction},
     types::Type,
-    value::ValueId,
+    value::{Value, ValueId},
 };
 
 pub(crate) struct ValueMerger<'a> {
     dfg: &'a mut DataFlowGraph,
     block: BasicBlockId,
+
+    current_condition: Option<ValueId>,
+
     // Maps SSA array values with a slice type to their size.
     // This must be computed before merging values.
     slice_sizes: &'a mut HashMap<ValueId, usize>,
+
+    array_set_conditionals: &'a mut HashMap<ValueId, ValueId>,
 }
 
 impl<'a> ValueMerger<'a> {
@@ -22,8 +27,10 @@ impl<'a> ValueMerger<'a> {
         dfg: &'a mut DataFlowGraph,
         block: BasicBlockId,
         slice_sizes: &'a mut HashMap<ValueId, usize>,
+        array_set_conditionals: &'a mut HashMap<ValueId, ValueId>,
+        current_condition: Option<ValueId>,
     ) -> Self {
-        ValueMerger { dfg, block, slice_sizes }
+        ValueMerger { dfg, block, slice_sizes, array_set_conditionals, current_condition }
     }
 
     /// Merge two values a and b from separate basic blocks to a single value.
@@ -42,9 +49,14 @@ impl<'a> ValueMerger<'a> {
         else_value: ValueId,
     ) -> ValueId {
         match self.dfg.type_of_value(then_value) {
-            Type::Numeric(_) => {
-                self.merge_numeric_values(then_condition, else_condition, then_value, else_value)
-            }
+            Type::Numeric(_) => Self::merge_numeric_values(
+                self.dfg,
+                self.block,
+                then_condition,
+                else_condition,
+                then_value,
+                else_value,
+            ),
             typ @ Type::Array(_, _) => {
                 self.merge_array_values(typ, then_condition, else_condition, then_value, else_value)
             }
@@ -59,58 +71,57 @@ impl<'a> ValueMerger<'a> {
     /// Merge two numeric values a and b from separate basic blocks to a single value. This
     /// function would return the result of `if c { a } else { b }` as  `c*a + (!c)*b`.
     pub(crate) fn merge_numeric_values(
-        &mut self,
+        dfg: &mut DataFlowGraph,
+        block: BasicBlockId,
         then_condition: ValueId,
         else_condition: ValueId,
         then_value: ValueId,
         else_value: ValueId,
     ) -> ValueId {
-        let then_type = self.dfg.type_of_value(then_value);
-        let else_type = self.dfg.type_of_value(else_value);
+        let then_type = dfg.type_of_value(then_value);
+        let else_type = dfg.type_of_value(else_value);
         assert_eq!(
             then_type, else_type,
             "Expected values merged to be of the same type but found {then_type} and {else_type}"
         );
 
-        let then_call_stack = self.dfg.get_value_call_stack(then_value);
-        let else_call_stack = self.dfg.get_value_call_stack(else_value);
+        if then_value == else_value {
+            return then_value;
+        }
+
+        let then_call_stack = dfg.get_value_call_stack(then_value);
+        let else_call_stack = dfg.get_value_call_stack(else_value);
 
         let call_stack = if then_call_stack.is_empty() { else_call_stack } else { then_call_stack };
 
         // We must cast the bool conditions to the actual numeric type used by each value.
-        let then_condition = self
-            .dfg
+        let then_condition = dfg
             .insert_instruction_and_results(
                 Instruction::Cast(then_condition, then_type),
-                self.block,
+                block,
                 None,
                 call_stack.clone(),
             )
             .first();
-        let else_condition = self
-            .dfg
+        let else_condition = dfg
             .insert_instruction_and_results(
                 Instruction::Cast(else_condition, else_type),
-                self.block,
+                block,
                 None,
                 call_stack.clone(),
             )
             .first();
 
         let mul = Instruction::binary(BinaryOp::Mul, then_condition, then_value);
-        let then_value = self
-            .dfg
-            .insert_instruction_and_results(mul, self.block, None, call_stack.clone())
-            .first();
+        let then_value =
+            dfg.insert_instruction_and_results(mul, block, None, call_stack.clone()).first();
 
         let mul = Instruction::binary(BinaryOp::Mul, else_condition, else_value);
-        let else_value = self
-            .dfg
-            .insert_instruction_and_results(mul, self.block, None, call_stack.clone())
-            .first();
+        let else_value =
+            dfg.insert_instruction_and_results(mul, block, None, call_stack.clone()).first();
 
         let add = Instruction::binary(BinaryOp::Add, then_value, else_value);
-        self.dfg.insert_instruction_and_results(add, self.block, None, call_stack).first()
+        dfg.insert_instruction_and_results(add, block, None, call_stack).first()
     }
 
     /// Given an if expression that returns an array: `if c { array1 } else { array2 }`,
@@ -131,6 +142,18 @@ impl<'a> ValueMerger<'a> {
             _ => panic!("Expected array type"),
         };
 
+        let actual_length = len * element_types.len();
+
+        if let Some(result) = self.try_merge_only_changed_indices(
+            then_condition,
+            else_condition,
+            then_value,
+            else_value,
+            actual_length,
+        ) {
+            return result;
+        }
+
         for i in 0..len {
             for (element_index, element_type) in element_types.iter().enumerate() {
                 let index = ((i * element_types.len() + element_index) as u128).into();
@@ -175,12 +198,18 @@ impl<'a> ValueMerger<'a> {
             _ => panic!("Expected slice type"),
         };
 
-        let then_len = *self.slice_sizes.get(&then_value_id).unwrap_or_else(|| {
-            panic!("ICE: Merging values during flattening encountered slice {then_value_id} without a preset size");
+        let then_len = self.slice_sizes.get(&then_value_id).copied().unwrap_or_else(|| {
+            let (slice, typ) = self.dfg.get_array_constant(then_value_id).unwrap_or_else(|| {
+                panic!("ICE: Merging values during flattening encountered slice {then_value_id} without a preset size");
+            });
+            slice.len() / typ.element_types().len()
         });
 
-        let else_len = *self.slice_sizes.get(&else_value_id).unwrap_or_else(|| {
-            panic!("ICE: Merging values during flattening encountered slice {else_value_id} without a preset size");
+        let else_len = self.slice_sizes.get(&else_value_id).copied().unwrap_or_else(|| {
+            let (slice, typ) = self.dfg.get_array_constant(else_value_id).unwrap_or_else(|| {
+                panic!("ICE: Merging values during flattening encountered slice {else_value_id} without a preset size");
+            });
+            slice.len() / typ.element_types().len()
         });
 
         let len = then_len.max(else_len);
@@ -260,4 +289,157 @@ impl<'a> ValueMerger<'a> {
             }
         }
     }
+
+    fn try_merge_only_changed_indices(
+        &mut self,
+        then_condition: ValueId,
+        else_condition: ValueId,
+        then_value: ValueId,
+        else_value: ValueId,
+        array_length: usize,
+    ) -> Option<ValueId> {
+        let mut found = false;
+        let current_condition = self.current_condition?;
+
+        let mut current_then = then_value;
+        let mut current_else = else_value;
+
+        // Arbitrarily limit this to looking at at most 10 past ArraySet operations.
+        // If there are more than that, we assume 2 completely separate arrays are being merged.
+        let max_iters = 1;
+        let mut seen_then = Vec::with_capacity(max_iters);
+        let mut seen_else = Vec::with_capacity(max_iters);
+
+        // We essentially have a tree of ArraySets and want to find a common
+        // ancestor if it exists, alone with the path to it from each starting node.
+        // This path will be the indices that were changed to create each result array.
+        for _ in 0..max_iters {
+            if current_then == else_value {
+                seen_else.clear();
+                found = true;
+                break;
+            }
+
+            if current_else == then_value {
+                seen_then.clear();
+                found = true;
+                break;
+            }
+
+            if let Some(index) = seen_then.iter().position(|(elem, _, _, _)| *elem == current_else)
+            {
+                seen_else.truncate(index);
+                found = true;
+                break;
+            }
+
+            if let Some(index) = seen_else.iter().position(|(elem, _, _, _)| *elem == current_then)
+            {
+                seen_then.truncate(index);
+                found = true;
+                break;
+            }
+
+            current_then = self.find_previous_array_set(current_then, &mut seen_then);
+            current_else = self.find_previous_array_set(current_else, &mut seen_else);
+        }
+
+        let changed_indices: FxHashSet<_> = seen_then
+            .into_iter()
+            .map(|(_, index, typ, condition)| (index, typ, condition))
+            .chain(seen_else.into_iter().map(|(_, index, typ, condition)| (index, typ, condition)))
+            .collect();
+
+        if !found || changed_indices.len() >= array_length {
+            return None;
+        }
+
+        let mut array = then_value;
+
+        for (index, element_type, condition) in changed_indices {
+            let typevars = Some(vec![element_type.clone()]);
+
+            let instruction = Instruction::EnableSideEffects { condition };
+            self.insert_instruction(instruction);
+
+            let mut get_element = |array, typevars| {
+                let get = Instruction::ArrayGet { array, index };
+                self.dfg
+                    .insert_instruction_and_results(get, self.block, typevars, CallStack::new())
+                    .first()
+            };
+
+            let then_element = get_element(then_value, typevars.clone());
+            let else_element = get_element(else_value, typevars);
+
+            let value =
+                self.merge_values(then_condition, else_condition, then_element, else_element);
+
+            array = self.insert_array_set(array, index, value, Some(condition)).first();
+        }
+
+        let instruction = Instruction::EnableSideEffects { condition: current_condition };
+        self.insert_instruction(instruction);
+        Some(array)
+    }
+
+    fn insert_instruction(&mut self, instruction: Instruction) -> InsertInstructionResult {
+        self.dfg.insert_instruction_and_results(instruction, self.block, None, CallStack::new())
+    }
+
+    fn insert_array_set(
+        &mut self,
+        array: ValueId,
+        index: ValueId,
+        value: ValueId,
+        condition: Option<ValueId>,
+    ) -> InsertInstructionResult {
+        let instruction = Instruction::ArraySet { array, index, value, mutable: false };
+        let result = self.dfg.insert_instruction_and_results(
+            instruction,
+            self.block,
+            None,
+            CallStack::new(),
+        );
+
+        if let Some(condition) = condition {
+            let result_index = if result.len() == 1 {
+                0
+            } else {
+                // Slices return (length, slice)
+                assert_eq!(result.len(), 2);
+                1
+            };
+
+            let result_value = result[result_index];
+            self.array_set_conditionals.insert(result_value, condition);
+        }
+
+        result
+    }
+
+    fn find_previous_array_set(
+        &self,
+        result: ValueId,
+        changed_indices: &mut Vec<(ValueId, ValueId, Type, ValueId)>,
+    ) -> ValueId {
+        match &self.dfg[result] {
+            Value::Instruction { instruction, .. } => match &self.dfg[*instruction] {
+                Instruction::ArraySet { array, index, value, .. } => {
+                    let condition =
+                        *self.array_set_conditionals.get(&result).unwrap_or_else(|| {
+                            panic!(
+                                "Expected to have conditional for array set {result}\n{:?}",
+                                self.array_set_conditionals
+                            )
+                        });
+                    let element_type = self.dfg.type_of_value(*value);
+                    changed_indices.push((result, *index, element_type, condition));
+                    *array
+                }
+                _ => result,
+            },
+            _ => result,
+        }
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index 4452840a28c..27536d59ea5 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -16,5 +16,6 @@ mod mem2reg;
 mod rc;
 mod remove_bit_shifts;
 mod remove_enable_side_effects;
+mod remove_if_else;
 mod simplify_cfg;
 mod unrolling;
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 8535dc2661f..02b9202b209 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -125,6 +125,7 @@ impl Context {
             | Truncate { .. }
             | Constrain(..)
             | RangeCheck { .. }
+            | IfElse { .. }
             | IncrementRc { .. }
             | DecrementRc { .. } => false,
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
new file mode 100644
index 00000000000..fc915756110
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -0,0 +1,236 @@
+use std::collections::hash_map::Entry;
+
+use acvm::FieldElement;
+use fxhash::FxHashMap as HashMap;
+
+use crate::ssa::ir::value::ValueId;
+use crate::ssa::{
+    ir::{
+        dfg::DataFlowGraph,
+        function::Function,
+        instruction::{Instruction, Intrinsic},
+        types::Type,
+        value::Value,
+    },
+    opt::flatten_cfg::value_merger::ValueMerger,
+    Ssa,
+};
+
+impl Ssa {
+    /// This pass removes `inc_rc` and `dec_rc` instructions
+    /// as long as there are no `array_set` instructions to an array
+    /// of the same type in between.
+    ///
+    /// Note that this pass is very conservative since the array_set
+    /// instruction does not need to be to the same array. This is because
+    /// the given array may alias another array (e.g. function parameters or
+    /// a `load`ed array from a reference).
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn remove_if_else(mut self) -> Ssa {
+        for function in self.functions.values_mut() {
+            // This should match the check in flatten_cfg
+            if let crate::ssa::ir::function::RuntimeType::Brillig = function.runtime() {
+                continue;
+            }
+
+            Context::default().remove_if_else(function);
+        }
+        self
+    }
+}
+
+#[derive(Default)]
+struct Context {
+    slice_sizes: HashMap<ValueId, usize>,
+
+    // Maps array_set result -> element that was overwritten by that instruction.
+    // Used to undo array_sets while merging values
+    prev_array_set_elem_values: HashMap<ValueId, ValueId>,
+
+    // Maps array_set result -> enable_side_effects_if value which was active during it.
+    array_set_conditionals: HashMap<ValueId, ValueId>,
+}
+
+impl Context {
+    fn remove_if_else(&mut self, function: &mut Function) {
+        let block = function.entry_block();
+        let instructions = function.dfg[block].take_instructions();
+        let mut current_conditional = function.dfg.make_constant(FieldElement::one(), Type::bool());
+
+        for instruction in instructions {
+            match &function.dfg[instruction] {
+                Instruction::IfElse { then_condition, then_value, else_condition, else_value } => {
+                    let then_condition = *then_condition;
+                    let then_value = *then_value;
+                    let else_condition = *else_condition;
+                    let else_value = *else_value;
+
+                    let typ = function.dfg.type_of_value(then_value);
+                    assert!(!matches!(typ, Type::Numeric(_)));
+
+                    let mut value_merger = ValueMerger::new(
+                        &mut function.dfg,
+                        block,
+                        &mut self.slice_sizes,
+                        &mut self.array_set_conditionals,
+                        Some(current_conditional),
+                    );
+
+                    let value = value_merger.merge_values(
+                        then_condition,
+                        else_condition,
+                        then_value,
+                        else_value,
+                    );
+
+                    let _typ = function.dfg.type_of_value(value);
+                    let results = function.dfg.instruction_results(instruction);
+                    let result = results[0];
+                    // let result = match typ {
+                    //     Type::Array(..) => results[0],
+                    //     Type::Slice(..) => results[1],
+                    //     other => unreachable!("IfElse instructions should only have arrays or slices at this point. Found {other:?}"),
+                    // };
+
+                    function.dfg.set_value_from_id(result, value);
+                    self.array_set_conditionals.insert(result, current_conditional);
+                }
+                Instruction::Call { func, arguments } => {
+                    if let Value::Intrinsic(intrinsic) = function.dfg[*func] {
+                        let results = function.dfg.instruction_results(instruction);
+
+                        match slice_capacity_change(&function.dfg, intrinsic, arguments, results) {
+                            SizeChange::None => (),
+                            SizeChange::SetTo(value, new_capacity) => {
+                                self.slice_sizes.insert(value, new_capacity);
+                            }
+                            SizeChange::Inc { old, new } => {
+                                let old_capacity = self.get_or_find_capacity(&function.dfg, old);
+                                self.slice_sizes.insert(new, old_capacity + 1);
+                            }
+                            SizeChange::Dec { old, new } => {
+                                let old_capacity = self.get_or_find_capacity(&function.dfg, old);
+                                self.slice_sizes.insert(new, old_capacity - 1);
+                            }
+                        }
+                    }
+                    function.dfg[block].instructions_mut().push(instruction);
+                }
+                Instruction::ArraySet { array, .. } => {
+                    let results = function.dfg.instruction_results(instruction);
+                    let result = if results.len() == 2 { results[1] } else { results[0] };
+
+                    self.array_set_conditionals.insert(result, current_conditional);
+
+                    let old_capacity = self.get_or_find_capacity(&function.dfg, *array);
+                    self.slice_sizes.insert(result, old_capacity);
+                    function.dfg[block].instructions_mut().push(instruction);
+                }
+                Instruction::EnableSideEffects { condition } => {
+                    current_conditional = *condition;
+                    function.dfg[block].instructions_mut().push(instruction);
+                }
+                _ => {
+                    function.dfg[block].instructions_mut().push(instruction);
+                }
+            }
+        }
+    }
+
+    fn get_or_find_capacity(&mut self, dfg: &DataFlowGraph, value: ValueId) -> usize {
+        match self.slice_sizes.entry(value) {
+            Entry::Occupied(entry) => return *entry.get(),
+            Entry::Vacant(entry) => {
+                if let Some((array, typ)) = dfg.get_array_constant(value) {
+                    let length = array.len() / typ.element_types().len();
+                    return *entry.insert(length);
+                }
+
+                if let Type::Array(_, length) = dfg.type_of_value(value) {
+                    return *entry.insert(length);
+                }
+            }
+        }
+
+        let dbg_value = &dfg[value];
+        unreachable!("No size for slice {value} = {dbg_value:?}")
+    }
+}
+
+enum SizeChange {
+    None,
+    SetTo(ValueId, usize),
+
+    // These two variants store the old and new slice ids
+    // not their lengths which should be old_len = new_len +/- 1
+    Inc { old: ValueId, new: ValueId },
+    Dec { old: ValueId, new: ValueId },
+}
+
+/// Find the change to a slice's capacity an instruction would have
+fn slice_capacity_change(
+    dfg: &DataFlowGraph,
+    intrinsic: Intrinsic,
+    arguments: &[ValueId],
+    results: &[ValueId],
+) -> SizeChange {
+    match intrinsic {
+        Intrinsic::SlicePushBack | Intrinsic::SlicePushFront | Intrinsic::SliceInsert => {
+            // Expecting:  len, slice = ...
+            assert_eq!(results.len(), 2);
+            let old = arguments[1];
+            let new = results[1];
+            assert!(matches!(dfg.type_of_value(old), Type::Slice(_)));
+            assert!(matches!(dfg.type_of_value(new), Type::Slice(_)));
+            SizeChange::Inc { old, new }
+        }
+
+        Intrinsic::SlicePopBack | Intrinsic::SliceRemove => {
+            let old = arguments[1];
+            let new = results[1];
+            assert!(matches!(dfg.type_of_value(old), Type::Slice(_)));
+            assert!(matches!(dfg.type_of_value(new), Type::Slice(_)));
+            SizeChange::Dec { old, new }
+        }
+
+        Intrinsic::SlicePopFront => {
+            let old = arguments[1];
+            let new = results[results.len() - 1];
+            assert!(matches!(dfg.type_of_value(old), Type::Slice(_)));
+            assert!(matches!(dfg.type_of_value(new), Type::Slice(_)));
+            SizeChange::Dec { old, new }
+        }
+
+        Intrinsic::ToBits(_) => {
+            assert_eq!(results.len(), 2);
+            // Some tests fail this check, returning an array instead somehow:
+            // assert!(matches!(dfg.type_of_value(results[1]), Type::Slice(_)));
+            SizeChange::SetTo(results[1], FieldElement::max_num_bits() as usize)
+        }
+        // ToRadix seems to assume it is to bytes
+        Intrinsic::ToRadix(_) => {
+            assert_eq!(results.len(), 2);
+            assert!(matches!(dfg.type_of_value(results[1]), Type::Slice(_)));
+            SizeChange::SetTo(results[1], FieldElement::max_num_bytes() as usize)
+        }
+        Intrinsic::AsSlice => {
+            assert_eq!(arguments.len(), 1);
+            assert_eq!(results.len(), 2);
+            let length = match dfg.type_of_value(arguments[0]) {
+                Type::Array(_, length) => length,
+                other => unreachable!("slice_capacity_change expected array, found {other:?}"),
+            };
+            assert!(matches!(dfg.type_of_value(results[1]), Type::Slice(_)));
+            SizeChange::SetTo(results[1], length)
+        }
+
+        // These cases don't affect slice capacities
+        Intrinsic::AssertConstant
+        | Intrinsic::ApplyRangeConstraint
+        | Intrinsic::ArrayLen
+        | Intrinsic::StrAsBytes
+        | Intrinsic::BlackBox(_)
+        | Intrinsic::FromField
+        | Intrinsic::AsField => SizeChange::None,
+    }
+}
diff --git a/test_programs/execution_success/nested_array_dynamic_simple/Nargo.toml b/test_programs/execution_success/nested_array_dynamic_simple/Nargo.toml
new file mode 100644
index 00000000000..50ba1d194a6
--- /dev/null
+++ b/test_programs/execution_success/nested_array_dynamic_simple/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "nested_array_dynamic_simple"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/nested_array_dynamic_simple/Prover.toml b/test_programs/execution_success/nested_array_dynamic_simple/Prover.toml
new file mode 100644
index 00000000000..07890234a19
--- /dev/null
+++ b/test_programs/execution_success/nested_array_dynamic_simple/Prover.toml
@@ -0,0 +1 @@
+x = "3"
diff --git a/test_programs/execution_success/nested_array_dynamic_simple/src/main.nr b/test_programs/execution_success/nested_array_dynamic_simple/src/main.nr
new file mode 100644
index 00000000000..3b1908a463b
--- /dev/null
+++ b/test_programs/execution_success/nested_array_dynamic_simple/src/main.nr
@@ -0,0 +1,9 @@
+fn main(x: Field) {
+    // x = 3
+    let array: [[(Field, [Field; 1], [Field; 1]); 1]; 1] = [[(1, [2], [3])]];
+
+    let fetched_value = array[x - 3];
+    assert(fetched_value[0].0 == 1);
+    assert(fetched_value[0].1[0] == 2);
+    assert(fetched_value[0].2[0] == 3);
+}

From 96fb3e94b3a2f7b586d17ea9445f44267f5d9c6d Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Fri, 3 May 2024 22:37:36 +0100
Subject: [PATCH 250/416] fix: Move remove_if_else pass after second inlining 
 (#4976)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

For the test added in this PR I bumped the `max_iter` in
`try_merge_only_changed_indices`. We then get the following panic:
```
The application panicked (crashed).
Message:  internal error: entered unreachable code: All Value::Instructions should already be known during inlining after creating the original inlined instruction. Unknown value v41 = Instruction { instruction: Id(76), position: 0, typ: Array([Numeric(Unsigned { bit_size: 32 })], 30) }
Location: compiler/noirc_evaluator/src/ssa/opt/inlining.rs:253
```
We have to inline immediately following mem2reg before extra
instructions are added by the remove_if_else pass.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa.rs                       | 4 +++-
 .../src/ssa/opt/flatten_cfg/value_merger.rs               | 2 +-
 .../execution_success/array_if_cond_simple/Nargo.toml     | 7 +++++++
 .../execution_success/array_if_cond_simple/Prover.toml    | 2 ++
 .../execution_success/array_if_cond_simple/src/main.nr    | 8 ++++++++
 5 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/execution_success/array_if_cond_simple/Nargo.toml
 create mode 100644 test_programs/execution_success/array_if_cond_simple/Prover.toml
 create mode 100644 test_programs/execution_success/array_if_cond_simple/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index ffe3b380c1a..a9525d3e83c 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -59,10 +59,12 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
         // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
-        .run_pass(Ssa::remove_if_else, "After Remove IfElse:")
         // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
         // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
+        // This pass must come immediately following `mem2reg` as the succeeding passes
+        // may create an SSA which inlining fails to handle.
         .run_pass(Ssa::inline_functions_with_no_predicates, "After Inlining:")
+        .run_pass(Ssa::remove_if_else, "After Remove IfElse:")
         .run_pass(Ssa::fold_constants, "After Constant Folding:")
         .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffects removal:")
         .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
index c47d594545c..80f6529b7b3 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
@@ -306,7 +306,7 @@ impl<'a> ValueMerger<'a> {
 
         // Arbitrarily limit this to looking at at most 10 past ArraySet operations.
         // If there are more than that, we assume 2 completely separate arrays are being merged.
-        let max_iters = 1;
+        let max_iters = 2;
         let mut seen_then = Vec::with_capacity(max_iters);
         let mut seen_else = Vec::with_capacity(max_iters);
 
diff --git a/test_programs/execution_success/array_if_cond_simple/Nargo.toml b/test_programs/execution_success/array_if_cond_simple/Nargo.toml
new file mode 100644
index 00000000000..b885d22c019
--- /dev/null
+++ b/test_programs/execution_success/array_if_cond_simple/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "array_if_cond_simple"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/array_if_cond_simple/Prover.toml b/test_programs/execution_success/array_if_cond_simple/Prover.toml
new file mode 100644
index 00000000000..2825143e8ad
--- /dev/null
+++ b/test_programs/execution_success/array_if_cond_simple/Prover.toml
@@ -0,0 +1,2 @@
+x = true
+y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
\ No newline at end of file
diff --git a/test_programs/execution_success/array_if_cond_simple/src/main.nr b/test_programs/execution_success/array_if_cond_simple/src/main.nr
new file mode 100644
index 00000000000..ee2f762d43c
--- /dev/null
+++ b/test_programs/execution_success/array_if_cond_simple/src/main.nr
@@ -0,0 +1,8 @@
+fn main(x: bool, mut y: [u32; 30]) {
+    if x {
+        y[0] = 1;
+    }
+
+    let z = y[0] + y[1];
+    assert(z == 1);
+}

From 2da28997dbedce4a00d2162eddb57564bdb23546 Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Mon, 6 May 2024 14:56:17 +0100
Subject: [PATCH 251/416] chore: Release Noir(0.29.0) (#4905)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.29.0</summary>

## [0.29.0](https://github.com/noir-lang/noir/compare/v0.28.0...v0.29.0)
(2024-05-03)


### ⚠ BREAKING CHANGES

* use `distinct` return value witnesses by default
([#4951](https://github.com/noir-lang/noir/issues/4951))
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))

### Features

* Add `#[inline(tag)]` attribute and codegen
([#4913](https://github.com/noir-lang/noir/issues/4913))
([1ec9cdc](https://github.com/noir-lang/noir/commit/1ec9cdc7013e867db3672d27e3a6104e4b7e7eef))
* Add de-sugaring for `impl Trait` in function parameters
([#4919](https://github.com/noir-lang/noir/issues/4919))
([8aad2e4](https://github.com/noir-lang/noir/commit/8aad2e45acbe08afc3902db95a83324f822c35eb))
* Add variable size sha256
([#4920](https://github.com/noir-lang/noir/issues/4920))
([dbfca58](https://github.com/noir-lang/noir/commit/dbfca58a817ee1f1512e3e02138119f363c3d12b))
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
* Complex outputs from acir call
([#4952](https://github.com/noir-lang/noir/issues/4952))
([2e085b9](https://github.com/noir-lang/noir/commit/2e085b935b143c1305b70cd7ae86907b61a45fc0))
* **experimental:** `comptime` globals
([#4918](https://github.com/noir-lang/noir/issues/4918))
([8a3c7f1](https://github.com/noir-lang/noir/commit/8a3c7f1c11666ed5140a63a5aa296ef417c97bfa))
* Handle `BrilligCall` opcodes in the debugger
([#4897](https://github.com/noir-lang/noir/issues/4897))
([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
* Handle `no_predicates` attribute
([#4942](https://github.com/noir-lang/noir/issues/4942))
([0ce04d3](https://github.com/noir-lang/noir/commit/0ce04d3ea8734b76d96f5dd0fb2a6cdd4081969e))
* Handle empty response foreign calls without an external resolver
([#4959](https://github.com/noir-lang/noir/issues/4959))
([0154bde](https://github.com/noir-lang/noir/commit/0154bdef9f6dfe45497d77ecbf3904dcc138b8d7))
* Optimize array sets in if conditions (alternate version)
([#4716](https://github.com/noir-lang/noir/issues/4716))
([a87c655](https://github.com/noir-lang/noir/commit/a87c655c6c8c077c71e3372cc9181b7870348a3d))
* Use `distinct` return value witnesses by default
([#4951](https://github.com/noir-lang/noir/issues/4951))
([5f1b584](https://github.com/noir-lang/noir/commit/5f1b58470779e977293323d10ab9a8f0857ea29e))


### Bug Fixes

* Ban self-referential structs
([#4883](https://github.com/noir-lang/noir/issues/4883))
([800f670](https://github.com/noir-lang/noir/commit/800f670b63a5a2ae08f09a86dae767089f7f67af))
* Discard ref counts during unrolling
([#4923](https://github.com/noir-lang/noir/issues/4923))
([91062db](https://github.com/noir-lang/noir/commit/91062db84a749bf191eae9ce487a2315cc74bfb2))
* Ensure where clauses propagated to trait default definitions
([#4894](https://github.com/noir-lang/noir/issues/4894))
([aaac0f6](https://github.com/noir-lang/noir/commit/aaac0f6bffbe11eb090145354f1b82919bb93cb7))
* Move remove_if_else pass after second inlining
([#4976](https://github.com/noir-lang/noir/issues/4976))
([96fb3e9](https://github.com/noir-lang/noir/commit/96fb3e94b3a2f7b586d17ea9445f44267f5d9c6d))
* Nested array equality
([#4903](https://github.com/noir-lang/noir/issues/4903))
([0cf2e2a](https://github.com/noir-lang/noir/commit/0cf2e2a1b8d247bed03ba5b7b1be5cd30f0d51b2))
* Require for all foldable functions to use distinct return
([#4949](https://github.com/noir-lang/noir/issues/4949))
([d4c6806](https://github.com/noir-lang/noir/commit/d4c68066ab35ce1c52510cf0c038fb627a0677c3))
* Use annotated type when checking declaration
([#4966](https://github.com/noir-lang/noir/issues/4966))
([f7fa696](https://github.com/noir-lang/noir/commit/f7fa69661006e1e10ddeecee1cdf8f024d6bc3e9))
</details>

<details><summary>0.45.0</summary>

## [0.45.0](https://github.com/noir-lang/noir/compare/v0.44.0...v0.45.0)
(2024-05-03)


### ⚠ BREAKING CHANGES

* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
* contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
* change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
* trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
* remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
* storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
* contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))

### Features

* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir_gen:** Brillig stdlib
([#4848](https://github.com/noir-lang/noir/issues/4848))
([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
* **acir_gen:** Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **acvm_js:** Execute program
([#4694](https://github.com/noir-lang/noir/issues/4694))
([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
* **acvm:** Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add return values to aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/5389)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Add support for overriding expression width
([#4117](https://github.com/noir-lang/noir/issues/4117))
([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **avm:** Integrate AVM with initializers
(https://github.com/AztecProtocol/aztec-packages/pull/5469)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
* Breaking changes from aztec-packages
([#3955](https://github.com/noir-lang/noir/issues/3955))
([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
* Brillig heterogeneous memory cells
(https://github.com/AztecProtocol/aztec-packages/pull/5608)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Brillig pointer codegen and execution
(https://github.com/AztecProtocol/aztec-packages/pull/5737)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
* Change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Handle `BrilligCall` opcodes in the debugger
([#4897](https://github.com/noir-lang/noir/issues/4897))
([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
* Impl of missing functionality in new key store
(https://github.com/AztecProtocol/aztec-packages/pull/5750)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* **nargo:** Handle call stacks for multiple Acir calls
([#4711](https://github.com/noir-lang/noir/issues/4711))
([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove replacement of boolean range opcodes with `AssertZero` opcodes
([#4107](https://github.com/noir-lang/noir/issues/4107))
([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
* Restore hashing args via slice for performance
(https://github.com/AztecProtocol/aztec-packages/pull/5539)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **simulator:** Fetch return values at circuit execution
(https://github.com/AztecProtocol/aztec-packages/pull/5642)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync `aztec-packages`
([#4011](https://github.com/noir-lang/noir/issues/4011))
([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
* Sync commits from `aztec-packages`
([#4068](https://github.com/noir-lang/noir/issues/4068))
([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5572)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5619)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5697)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5794)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5814)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5935)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5955)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5999)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Variable length returns
(https://github.com/AztecProtocol/aztec-packages/pull/5633)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))


### Bug Fixes

* **acvm:** Mark outputs of Opcode::Call solvable
([#4708](https://github.com/noir-lang/noir/issues/4708))
([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
* Avoid huge unrolling in hash_args
(https://github.com/AztecProtocol/aztec-packages/pull/5703)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Catch panics from EC point creation (e.g. the point is at infinity)
([#4790](https://github.com/noir-lang/noir/issues/4790))
([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
* Don't reuse brillig with slice arguments
(https://github.com/AztecProtocol/aztec-packages/pull/5800)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Issue 4682 and add solver for unconstrained bigintegers
([#4729](https://github.com/noir-lang/noir/issues/4729))
([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Proper field inversion for bigints
([#4802](https://github.com/noir-lang/noir/issues/4802))
([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
* Remove panic from `init_log_level` in `acvm_js`
([#4195](https://github.com/noir-lang/noir/issues/4195))
([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
* Return error rather instead of panicking on invalid circuit
([#3976](https://github.com/noir-lang/noir/issues/3976))
([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).
---
 .release-please-manifest.json                 |   4 +-
 CHANGELOG.md                                  |  33 +
 Cargo.lock                                    |  54 +-
 Cargo.toml                                    |  16 +-
 acvm-repo/CHANGELOG.md                        | 121 ++++
 acvm-repo/acir/Cargo.toml                     |   2 +-
 acvm-repo/acir_field/Cargo.toml               |   2 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm_js/Cargo.toml                  |   2 +-
 acvm-repo/acvm_js/package.json                |   2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   2 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   2 +-
 acvm-repo/brillig_vm/Cargo.toml               |   2 +-
 compiler/wasm/package.json                    |   2 +-
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 142 +++++
 .../hello_noir/project_breakdown.md           | 199 ++++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 102 ++++
 .../getting_started/tooling/noir_codegen.md   | 113 ++++
 .../version-v0.29.0/how_to/_category_.json    |   5 +
 .../how_to/debugger/_category_.json           |   6 +
 .../debugger/debugging_with_the_repl.md       | 164 +++++
 .../how_to/debugger/debugging_with_vs_code.md |  68 +++
 .../version-v0.29.0/how_to/how-to-oracles.md  | 276 +++++++++
 .../how_to/how-to-recursion.md                | 179 ++++++
 .../how_to/how-to-solidity-verifier.md        | 231 +++++++
 .../version-v0.29.0/how_to/merkle-proof.mdx   |  49 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.29.0/index.mdx |  67 ++
 .../version-v0.29.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.29.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.29.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  77 +++
 .../version-v0.29.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 251 ++++++++
 .../noir/concepts/data_types/booleans.md      |  31 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 155 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 195 ++++++
 .../noir/concepts/data_types/strings.md       |  80 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.29.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.29.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.29.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.29.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.29.0/noir/concepts/oracles.md  |  31 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.29.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  99 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  42 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/bigint.md           | 122 ++++
 .../noir/standard_library/black_box_fns.md    |  31 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 326 ++++++++++
 .../standard_library/containers/hashmap.md    | 570 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 151 +++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  98 +++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../cryptographic_primitives/hashes.mdx       | 257 ++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/scalar.mdx       |  33 +
 .../cryptographic_primitives/schnorr.mdx      |  64 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  88 +++
 .../noir/standard_library/traits.md           | 410 +++++++++++++
 .../noir/standard_library/zeroed.md           |  26 +
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 160 +++++
 .../classes/BarretenbergVerifier.md           |  58 ++
 .../NoirJS/backend_barretenberg/index.md      |  59 ++
 .../type-aliases/BackendOptions.md            |  21 +
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  | 132 ++++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +
 .../functions/ecdsa_secp256k1_verify.md       |  28 +
 .../functions/ecdsa_secp256r1_verify.md       |  28 +
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +
 .../NoirJS/noir_js/functions/sha256.md        |  21 +
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +
 .../reference/NoirJS/noir_js/index.md         |  54 ++
 .../type-aliases/ForeignCallHandler.md        |  24 +
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 +
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 +
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 +
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 ++
 .../noir_wasm/functions/compile_contract.md   |  51 ++
 .../noir_wasm/functions/createFileManager.md  |  21 +
 .../functions/inflateDebugSymbols.md          |  21 +
 .../reference/NoirJS/noir_wasm/index.md       |  49 ++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 .../version-v0.29.0/reference/_category_.json |   5 +
 .../reference/debugger/_category_.json        |   6 +
 .../debugger/debugger_known_limitations.md    |  59 ++
 .../reference/debugger/debugger_repl.md       | 360 +++++++++++
 .../reference/debugger/debugger_vscode.md     |  82 +++
 .../reference/nargo_commands.md               | 381 ++++++++++++
 .../version-v0.29.0/tooling/debugger.md       |  27 +
 .../tooling/language_server.md                |  43 ++
 .../version-v0.29.0/tooling/testing.md        |  62 ++
 .../version-v0.29.0/tutorials/noirjs_app.md   | 326 ++++++++++
 .../version-v0.29.0-sidebars.json             |  93 +++
 tooling/noir_codegen/package.json             |   2 +-
 tooling/noir_js/package.json                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noir_js_types/package.json            |   2 +-
 tooling/noirc_abi_wasm/package.json           |   2 +-
 134 files changed, 10252 insertions(+), 52 deletions(-)
 create mode 100644 docs/versioned_docs/version-v0.29.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/getting_started/tooling/noir_codegen.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_the_repl.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_vs_code.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/bigint.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/scalar.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_known_limitations.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_repl.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_vscode.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/tooling/debugger.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.29.0-sidebars.json

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index e20b12e68ef..13ef934aaee 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.28.0",
-  "acvm-repo": "0.44.0"
+  ".": "0.29.0",
+  "acvm-repo": "0.45.0"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 148ecfac876..7be8c387026 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,38 @@
 # Changelog
 
+## [0.29.0](https://github.com/noir-lang/noir/compare/v0.28.0...v0.29.0) (2024-05-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* use `distinct` return value witnesses by default ([#4951](https://github.com/noir-lang/noir/issues/4951))
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907))
+
+### Features
+
+* Add `#[inline(tag)]` attribute and codegen ([#4913](https://github.com/noir-lang/noir/issues/4913)) ([1ec9cdc](https://github.com/noir-lang/noir/commit/1ec9cdc7013e867db3672d27e3a6104e4b7e7eef))
+* Add de-sugaring for `impl Trait` in function parameters ([#4919](https://github.com/noir-lang/noir/issues/4919)) ([8aad2e4](https://github.com/noir-lang/noir/commit/8aad2e45acbe08afc3902db95a83324f822c35eb))
+* Add variable size sha256 ([#4920](https://github.com/noir-lang/noir/issues/4920)) ([dbfca58](https://github.com/noir-lang/noir/commit/dbfca58a817ee1f1512e3e02138119f363c3d12b))
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907)) ([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
+* Complex outputs from acir call ([#4952](https://github.com/noir-lang/noir/issues/4952)) ([2e085b9](https://github.com/noir-lang/noir/commit/2e085b935b143c1305b70cd7ae86907b61a45fc0))
+* **experimental:** `comptime` globals ([#4918](https://github.com/noir-lang/noir/issues/4918)) ([8a3c7f1](https://github.com/noir-lang/noir/commit/8a3c7f1c11666ed5140a63a5aa296ef417c97bfa))
+* Handle `BrilligCall` opcodes in the debugger ([#4897](https://github.com/noir-lang/noir/issues/4897)) ([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
+* Handle `no_predicates` attribute ([#4942](https://github.com/noir-lang/noir/issues/4942)) ([0ce04d3](https://github.com/noir-lang/noir/commit/0ce04d3ea8734b76d96f5dd0fb2a6cdd4081969e))
+* Handle empty response foreign calls without an external resolver ([#4959](https://github.com/noir-lang/noir/issues/4959)) ([0154bde](https://github.com/noir-lang/noir/commit/0154bdef9f6dfe45497d77ecbf3904dcc138b8d7))
+* Optimize array sets in if conditions (alternate version) ([#4716](https://github.com/noir-lang/noir/issues/4716)) ([a87c655](https://github.com/noir-lang/noir/commit/a87c655c6c8c077c71e3372cc9181b7870348a3d))
+* Use `distinct` return value witnesses by default ([#4951](https://github.com/noir-lang/noir/issues/4951)) ([5f1b584](https://github.com/noir-lang/noir/commit/5f1b58470779e977293323d10ab9a8f0857ea29e))
+
+
+### Bug Fixes
+
+* Ban self-referential structs ([#4883](https://github.com/noir-lang/noir/issues/4883)) ([800f670](https://github.com/noir-lang/noir/commit/800f670b63a5a2ae08f09a86dae767089f7f67af))
+* Discard ref counts during unrolling ([#4923](https://github.com/noir-lang/noir/issues/4923)) ([91062db](https://github.com/noir-lang/noir/commit/91062db84a749bf191eae9ce487a2315cc74bfb2))
+* Ensure where clauses propagated to trait default definitions ([#4894](https://github.com/noir-lang/noir/issues/4894)) ([aaac0f6](https://github.com/noir-lang/noir/commit/aaac0f6bffbe11eb090145354f1b82919bb93cb7))
+* Move remove_if_else pass after second inlining  ([#4976](https://github.com/noir-lang/noir/issues/4976)) ([96fb3e9](https://github.com/noir-lang/noir/commit/96fb3e94b3a2f7b586d17ea9445f44267f5d9c6d))
+* Nested array equality ([#4903](https://github.com/noir-lang/noir/issues/4903)) ([0cf2e2a](https://github.com/noir-lang/noir/commit/0cf2e2a1b8d247bed03ba5b7b1be5cd30f0d51b2))
+* Require for all foldable functions to use distinct return  ([#4949](https://github.com/noir-lang/noir/issues/4949)) ([d4c6806](https://github.com/noir-lang/noir/commit/d4c68066ab35ce1c52510cf0c038fb627a0677c3))
+* Use annotated type when checking declaration ([#4966](https://github.com/noir-lang/noir/issues/4966)) ([f7fa696](https://github.com/noir-lang/noir/commit/f7fa69661006e1e10ddeecee1cdf8f024d6bc3e9))
+
 ## [0.28.0](https://github.com/noir-lang/noir/compare/v0.27.0...v0.28.0) (2024-04-24)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index eaed1c08bec..e2f5f0db303 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -26,7 +26,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -40,7 +40,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -56,7 +56,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acir",
  "blake2",
@@ -92,7 +92,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -441,7 +441,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
@@ -452,7 +452,7 @@ dependencies = [
 
 [[package]]
 name = "backend-interface"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "bb_abstraction_leaks",
@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -630,7 +630,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -638,7 +638,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.44.0"
+version = "0.45.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1762,7 +1762,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2383,7 +2383,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.28.0"
+version = "0.29.0"
 
 [[package]]
 name = "itertools"
@@ -2808,7 +2808,7 @@ checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
 name = "nargo"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2834,7 +2834,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2888,7 +2888,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2900,7 +2900,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2979,7 +2979,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -3014,7 +3014,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -3040,7 +3040,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3063,7 +3063,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -3080,7 +3080,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3097,11 +3097,11 @@ dependencies = [
 
 [[package]]
 name = "noirc_arena"
-version = "0.28.0"
+version = "0.29.0"
 
 [[package]]
 name = "noirc_driver"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -3122,7 +3122,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3140,7 +3140,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "chrono",
@@ -3157,7 +3157,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3186,7 +3186,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.28.0"
+version = "0.29.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index ed0aef0d35b..370201773ec 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.28.0"
+version = "0.29.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -52,13 +52,13 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.44.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.44.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.44.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.44.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.44.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.44.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.44.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+acir_field = { version = "0.45.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.45.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.45.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.45.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.45.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.45.0", path = "acvm-repo/blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "0.45.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 fm = { path = "compiler/fm" }
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index b7b8ef3c474..6ac04f6f83f 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,127 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.45.0](https://github.com/noir-lang/noir/compare/v0.44.0...v0.45.0) (2024-05-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907))
+* contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687)
+* change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374)
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620)
+* trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732)
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709)
+* remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617)
+* storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387)
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616)
+* contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386)
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395)
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955))
+
+### Features
+
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir_gen:** Brillig stdlib ([#4848](https://github.com/noir-lang/noir/issues/4848)) ([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
+* **acir_gen:** Fold attribute at compile-time and initial non inlined ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **acvm_js:** Execute program  ([#4694](https://github.com/noir-lang/noir/issues/4694)) ([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
+* **acvm:** Execute multiple circuits  (https://github.com/AztecProtocol/aztec-packages/pull/5380) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add return values to aztec fns (https://github.com/AztecProtocol/aztec-packages/pull/5389) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Add support for overriding expression width ([#4117](https://github.com/noir-lang/noir/issues/4117)) ([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **avm:** Integrate AVM with initializers (https://github.com/AztecProtocol/aztec-packages/pull/5469) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907)) ([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
+* Breaking changes from aztec-packages ([#3955](https://github.com/noir-lang/noir/issues/3955)) ([5be049e](https://github.com/noir-lang/noir/commit/5be049eee6c342649462282ee04f6411e6ea392c))
+* Brillig heterogeneous memory cells (https://github.com/AztecProtocol/aztec-packages/pull/5608) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Brillig pointer codegen and execution (https://github.com/AztecProtocol/aztec-packages/pull/5737) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395) ([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
+* Change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Handle `BrilligCall` opcodes in the debugger ([#4897](https://github.com/noir-lang/noir/issues/4897)) ([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
+* Impl of missing functionality in new key store (https://github.com/AztecProtocol/aztec-packages/pull/5750) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* **nargo:** Handle call stacks for multiple Acir calls ([#4711](https://github.com/noir-lang/noir/issues/4711)) ([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove replacement of boolean range opcodes with `AssertZero` opcodes ([#4107](https://github.com/noir-lang/noir/issues/4107)) ([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
+* Restore hashing args via slice for performance (https://github.com/AztecProtocol/aztec-packages/pull/5539) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **simulator:** Fetch return values at circuit execution (https://github.com/AztecProtocol/aztec-packages/pull/5642) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync `aztec-packages` ([#4011](https://github.com/noir-lang/noir/issues/4011)) ([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
+* Sync commits from `aztec-packages` ([#4068](https://github.com/noir-lang/noir/issues/4068)) ([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144)) ([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5572) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5619) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5697) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5794) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5814) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5935) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5955) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5999) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Variable length returns (https://github.com/AztecProtocol/aztec-packages/pull/5633) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+
+
+### Bug Fixes
+
+* **acvm:** Mark outputs of Opcode::Call solvable ([#4708](https://github.com/noir-lang/noir/issues/4708)) ([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
+* Avoid huge unrolling in hash_args (https://github.com/AztecProtocol/aztec-packages/pull/5703) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Catch panics from EC point creation (e.g. the point is at infinity) ([#4790](https://github.com/noir-lang/noir/issues/4790)) ([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
+* Don't reuse brillig with slice arguments (https://github.com/AztecProtocol/aztec-packages/pull/5800) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Issue 4682 and add solver for unconstrained bigintegers ([#4729](https://github.com/noir-lang/noir/issues/4729)) ([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Proper field inversion for bigints ([#4802](https://github.com/noir-lang/noir/issues/4802)) ([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
+* Remove panic from `init_log_level` in `acvm_js` ([#4195](https://github.com/noir-lang/noir/issues/4195)) ([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
+* Return error rather instead of panicking on invalid circuit ([#3976](https://github.com/noir-lang/noir/issues/3976)) ([67201bf](https://github.com/noir-lang/noir/commit/67201bfc21a9c8858aa86be9cd47d463fb78d925))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.44.0](https://github.com/noir-lang/noir/compare/v0.43.0...v0.44.0) (2024-04-24)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 96ba13e3b3b..9e1a2f940c4 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index fcbe80ded2d..89ee161206e 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 0061eec5bc8..1b671d49366 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index b2db54a4e65..1675d601351 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 7da8bf84b02..5be2f164ac4 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 893bed38905..4dc7df03599 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index d856a57eb9b..3a6c9b1d55b 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 41c2cebdad9..081abe022ae 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 3dcc05c0842..57cf3be974a 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.44.0"
+version = "0.45.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index e8e7c0ab3c9..bccf937219e 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.28.0",
+  "version": "0.29.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/docs/versioned_docs/version-v0.29.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.29.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.29.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.29.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.29.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..743c4d8d634
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/index.md
@@ -0,0 +1,142 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Two additional files would be generated in your project directory:
+
+_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+
+## Prove Our Noir Program
+
+Now that the project is set up, we can create a proof of correct execution of our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Prove the valid execution of your Noir program:
+
+```sh
+nargo prove
+```
+
+A new folder _proofs_ would then be generated in your project directory, containing the proof file
+`<project-name>.proof`, where the project name is defined in Nargo.toml.
+
+The _Verifier.toml_ file would also be updated with the public values computed from program
+execution (in this case the value of `y`):
+
+```toml
+y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+```
+
+> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the
+proof file.
+
+Verify your proof by running:
+
+```sh
+nargo verify
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the
+corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..6160a102c6c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,199 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
+  files, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Verifier.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Verifier.toml
+
+_Verifier.toml_ contains public in/output values computed when executing the Noir program.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
+prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
+verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
+constrained by the proof of the execution of said program (i.e. if the condition was not met, the
+verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
+public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo prove` is executed, two processes happen:
+
+1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
+   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+
+2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove -p OtherProver
+```
+
+## Verifying a Proof
+
+When the command `nargo verify` is executed, two processes happen:
+
+1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
+
+2. If that file is found, the proof's validity is checked
+
+> **Note:** The validity of the proof is linked to the current Noir program; if the program is
+> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
+> _modified_ Noir program.
+
+In production, the prover and the verifier are usually two separate entities. A prover would
+retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
+verifier. The verifier would then retrieve the public inputs, usually from external sources, and
+verify the validity of the proof against it.
+
+Take a private asset transfer as an example:
+
+A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
+public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
+and submit it to the verifier smart contract.
+
+The verifier contract would then draw the user's encrypted balance directly from the blockchain and
+verify the proof submitted against it. If the verification passes, additional functions in the
+verifier contract could trigger (e.g. approve the asset transfer).
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.29.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.29.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.29.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..3634723562b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,102 @@
+---
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.29.0/getting_started/tooling/noir_codegen.md b/docs/versioned_docs/version-v0.29.0/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..d65151da0ab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,113 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 2
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/_category_.json b/docs/versioned_docs/version-v0.29.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.29.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..09e5bae68ad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.29.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..8cf8035a5c4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/how-to-oracles.md
@@ -0,0 +1,276 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("getSqrt", async (params) => {
+  const values = params[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+:::tip
+
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
+
+```json
+{ "values": [{ "Array": ["1", "2"] }]}
+{ "values": [{ "Single": "1" }]}
+{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface SingleForeignCallParam {
+  Single: string,
+}
+
+interface ArrayForeignCallParam {
+  Array: string[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.generateProof(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => i.toString("hex")) },
+    ]);
+    return [oracleReturn.values[0].Array];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.29.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..4c45bb87ae2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/how-to-recursion.md
@@ -0,0 +1,179 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit, backend)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e3c7c1065da
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,231 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo codegen-verifier
+```
+
+A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+
+```
+0x...<proof bytes>... , [0x0000.....02]
+```
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
+Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of
+the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.29.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..16c425bed76
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/merkle-proof.mdx
@@ -0,0 +1,49 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+use dep::std;
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.29.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.29.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.29.0/index.mdx b/docs/versioned_docs/version-v0.29.0/index.mdx
new file mode 100644
index 00000000000..75086ddcdde
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.29.0/migration_notes.md b/docs/versioned_docs/version-v0.29.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.29.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..efce3e95d32
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,251 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..69826fcd724
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,31 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
+> `false` in _Verifier.toml_.
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow) and
+[Assert Function](../assert) sections.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..a10a4810788
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..357813c147a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..1c6b375db49
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,155 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo prove
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+use dep::std;
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..4eccc677b80
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,195 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+use dep::std::slice;
+
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<N>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..311dfd64416
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,80 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging).
+
+```rust
+use dep::std;
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..ddd42bf1f9b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..aa380b5f7b8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/oracles.md
@@ -0,0 +1,31 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+:::note
+
+This is an experimental feature that is not fully documented. If you notice any outdated information or potential improvements to this page, pull request contributions are very welcome: https://github.com/noir-lang/noir
+
+:::
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..ef1445a5907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: dep::some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: dep::some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b8e71fe65f0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md
@@ -0,0 +1,99 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..04c1703d929
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use dep::ecrecover;
+use dep::lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use dep::std::hash::sha256;
+use dep::std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use dep::phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.29.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..2bfdeec6631
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/bigint.md
@@ -0,0 +1,122 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L14-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L14-L19</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L70-L78" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L70-L78</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..be8c65679c3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,31 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..ce4529f6e57
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,326 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..47faa99aba6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,570 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..fcfd7e07aa0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,151 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..d2b42d67b7c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4394b48f907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..c2c0624dfad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..3b83d9ec31a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,257 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L10-L12</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L17-L19</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L16-L18</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L22-L24" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L22-L24</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L46-L48" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L46-L48</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+struct PedersenPoint {
+   x : Field,
+   y : Field,
+}
+
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L27-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L27-L34</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L68-L70</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L22" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L22</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/scalar.mdx b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/scalar.mdx
new file mode 100644
index 00000000000..df411ca5443
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/scalar.mdx
@@ -0,0 +1,33 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplications over a fixed base in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## scalar_mul::fixed_base_embedded_curve
+
+Performs scalar multiplication over the embedded curve whose coordinates are defined by the
+configured noir field. For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+```rust title="fixed_base_embedded_curve" showLineNumbers 
+pub fn fixed_base_embedded_curve(
+    low: Field,
+    high: Field
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/scalar_mul.nr#L27-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/scalar_mul.nr#L27-L32</a></sub></sup>
+
+
+example
+
+```rust
+fn main(x : Field) {
+    let scal = std::scalar_mul::fixed_base_embedded_curve(x);
+    println(scal);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..b59e69c8f07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..a93894043dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md
@@ -0,0 +1,88 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+:::info
+
+This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+
+:::
+
+## Example usage
+
+```rust
+use dep::std;
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..04dc40f0dac
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/traits.md
@@ -0,0 +1,410 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(self) -> T {
+      T::from(self)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L102-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L102-L106</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L17-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L17-L21</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L33-L37" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L33-L37</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L49-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L49-L53</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L65-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L65-L69</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L79-L83" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L79-L83</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L95-L99" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L95-L99</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L111-L115" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L111-L115</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L127-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L127-L131</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops.nr#L142-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops.nr#L142-L146</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..f450fecdd36
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/zeroed.md
@@ -0,0 +1,26 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..d7249d24330
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,160 @@
+# BarretenbergBackend
+
+## Extends
+
+- `BarretenbergVerifierBackend`
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+#### Inherited from
+
+BarretenbergVerifierBackend.constructor
+
+## Properties
+
+| Property | Type | Description | Inheritance |
+| :------ | :------ | :------ | :------ |
+| `acirComposer` | `any` | - | BarretenbergVerifierBackend.acirComposer |
+| `acirUncompressedBytecode` | `Uint8Array` | - | BarretenbergVerifierBackend.acirUncompressedBytecode |
+| `api` | `Barretenberg` | - | BarretenbergVerifierBackend.api |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) | - | BarretenbergVerifierBackend.options |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.destroy
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.getVerificationKey
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.verifyProof
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
new file mode 100644
index 00000000000..500276ea748
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
@@ -0,0 +1,58 @@
+# BarretenbergVerifier
+
+## Constructors
+
+### new BarretenbergVerifier(options)
+
+```ts
+new BarretenbergVerifier(options): BarretenbergVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergVerifier`](BarretenbergVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..64971973196
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,59 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+| [BarretenbergVerifier](classes/BarretenbergVerifier.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+## Functions
+
+### publicInputsToWitnessMap()
+
+```ts
+publicInputsToWitnessMap(publicInputs, abi): Backend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `publicInputs` | `string`[] |
+| `abi` | `Abi` |
+
+#### Returns
+
+[`Backend`](index.md#backend)
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..d7d5128f9e3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier","label":"BarretenbergVerifier"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..45dd62ee57e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,132 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit, backend)
+
+```ts
+new Noir(circuit, backend?): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+| `backend`? | `any` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the underlying backend instance.
+
+#### Example
+
+```typescript
+await noir.destroy();
+```
+
+***
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+### generateProof()
+
+```ts
+generateProof(inputs, foreignCallHandler?): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a witness and a proof given an object as input.
+
+#### Example
+
+```typescript
+async generateProof(input)
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Instantiates the verification key and verifies a proof.
+
+#### Example
+
+```typescript
+async verifyProof(proof)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..cca6b3ace41
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,54 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+***
+
+### ProofData
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..c6d8125eaad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/_category_.json b/docs/versioned_docs/version-v0.29.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.29.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.29.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.29.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..218fcfb0c8c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/reference/nargo_commands.md
@@ -0,0 +1,381 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo backend`↴](#nargo-backend)
+* [`nargo backend current`↴](#nargo-backend-current)
+* [`nargo backend ls`↴](#nargo-backend-ls)
+* [`nargo backend use`↴](#nargo-backend-use)
+* [`nargo backend install`↴](#nargo-backend-install)
+* [`nargo backend uninstall`↴](#nargo-backend-uninstall)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo codegen-verifier`↴](#nargo-codegen-verifier)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo prove`↴](#nargo-prove)
+* [`nargo verify`↴](#nargo-verify)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `backend` — Install and select custom backends used to generate and verify proofs
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `codegen-verifier` — Generates a Solidity verifier smart contract for the program
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `prove` — Create proof for this program. The proof is returned as a hex encoded string
+* `verify` — Given a proof and a program, verify whether the proof is valid
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo backend`
+
+Install and select custom backends used to generate and verify proofs
+
+**Usage:** `nargo backend <COMMAND>`
+
+###### **Subcommands:**
+
+* `current` — Prints the name of the currently active backend
+* `ls` — Prints the list of currently installed backends
+* `use` — Select the backend to use
+* `install` — Install a new backend from a URL
+* `uninstall` — Uninstalls a backend
+
+
+
+## `nargo backend current`
+
+Prints the name of the currently active backend
+
+**Usage:** `nargo backend current`
+
+
+
+## `nargo backend ls`
+
+Prints the list of currently installed backends
+
+**Usage:** `nargo backend ls`
+
+
+
+## `nargo backend use`
+
+Select the backend to use
+
+**Usage:** `nargo backend use <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>`
+
+
+
+## `nargo backend install`
+
+Install a new backend from a URL
+
+**Usage:** `nargo backend install <BACKEND> <URL>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to install
+* `<URL>` — The URL from which to download the backend
+
+
+
+## `nargo backend uninstall`
+
+Uninstalls a backend
+
+**Usage:** `nargo backend uninstall <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to uninstall
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo codegen-verifier`
+
+Generates a Solidity verifier smart contract for the program
+
+**Usage:** `nargo codegen-verifier [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to codegen
+* `--workspace` — Codegen all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo prove`
+
+Create proof for this program. The proof is returned as a hex encoded string
+
+**Usage:** `nargo prove [OPTIONS]`
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--verify` — Verify proof after proving
+* `--package <PACKAGE>` — The name of the package to prove
+* `--workspace` — Prove all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo verify`
+
+Given a proof and a program, verify whether the proof is valid
+
+**Usage:** `nargo verify [OPTIONS]`
+
+###### **Options:**
+
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--package <PACKAGE>` — The name of the package verify
+* `--workspace` — Verify all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.29.0/tooling/debugger.md b/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
new file mode 100644
index 00000000000..184c436068f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
@@ -0,0 +1,27 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+
+- Noir 0.xx 
+- Nargo 0.xx
+- vscode-noir 0.xx
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.29.0/tooling/language_server.md b/docs/versioned_docs/version-v0.29.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.29.0/tooling/testing.md b/docs/versioned_docs/version-v0.29.0/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6446e0b2a76
--- /dev/null
+++ b/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md
@@ -0,0 +1,326 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.27.x matches `noir_js@0.27.x`, etc.
+
+In this guide, we will be pinned to 0.27.0.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+`nargo new circuit`
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+`nargo compile`
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.27.0 @noir-lang/noir_js@0.27.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
+    ),
+  ]);
+};
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit, backend);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const proof = await noir.generateProof(input);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verificationKey = await backend.getVerificationKey();
+const verifier = new Verifier();
+const isValid = await verifier.verifyProof(proof, verificationKey);
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.29.0-sidebars.json b/docs/versioned_sidebars/version-v0.29.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.29.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 2a90e9374df..fa3df8ce101 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.28.0",
+  "version": "0.29.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index c5bb5af9dfa..325ba0fb9a7 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.28.0",
+  "version": "0.29.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index a276a29046f..f0eded1ffef 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.28.0",
+  "version": "0.29.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index a356a771b2a..5332ce20cc7 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 701c843456a..ac7d1606298 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.28.0",
+  "version": "0.29.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From bf491dce9595d0e37057ae6d6721eb7a83cec0e2 Mon Sep 17 00:00:00 2001
From: Leonid Logvinov <logvinov.leon@gmail.com>
Date: Mon, 6 May 2024 17:52:51 +0200
Subject: [PATCH 252/416] feat: implement `From` array trait for `BoundedVec`
 (#4927)

# Description

## Problem\*

Implementing a concise, single-line method for converting arrays to
BoundedVec would enhance usability.

## Summary\*

This pull request implements the `From` trait to enable
array-to-BoundedVec conversions, allowing for the following usage
```rust
let vec = BoundedVec::from([1, 2, 3]);
```

instead of:
```rust
let vec: BoundedVec<Field, 3> = BoundedVec::new();
vec.extend_from_array([1, 2, 3]);
```


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Arkadiusz Konior <akonior@gmail.com>
---
 .../standard_library/containers/boundedvec.md | 14 ++++
 noir_stdlib/src/collections/bounded_vec.nr    | 71 ++++++++++++++++++-
 2 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/docs/docs/noir/standard_library/containers/boundedvec.md b/docs/docs/noir/standard_library/containers/boundedvec.md
index cd0f725f870..ccce62562f8 100644
--- a/docs/docs/noir/standard_library/containers/boundedvec.md
+++ b/docs/docs/noir/standard_library/containers/boundedvec.md
@@ -196,6 +196,20 @@ Example:
 
 #include_code bounded-vec-extend-from-bounded-vec-example test_programs/noir_test_success/bounded_vec/src/main.nr rust
 
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
 ### any
 
 ```rust
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index c6a3365a979..65f3716dd34 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -1,4 +1,4 @@
-use crate::cmp::Eq;
+use crate::{cmp::Eq, convert::From};
 
 struct BoundedVec<T, MaxLen> {
     storage: [T; MaxLen],
@@ -74,6 +74,13 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len = new_len;
     }
 
+    pub fn from_array<Len>(array: [T; Len]) -> Self {
+        assert(Len <= MaxLen, "from array out of bounds");
+        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();
+        vec.extend_from_array(array);
+        vec
+    }
+
     pub fn pop(&mut self) -> T {
         assert(self.len > 0);
         self.len -= 1;
@@ -107,6 +114,12 @@ impl<T, MaxLen> Eq for BoundedVec<T, MaxLen> where T: Eq {
     }
 }
 
+impl<T, MaxLen, Len> From<[T; Len]> for BoundedVec<T, MaxLen> {
+    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen>  {
+        BoundedVec::from_array(array)
+    }
+}
+
 mod bounded_vec_tests {
     // TODO: Allow imports from "super"
     use crate::collections::bounded_vec::BoundedVec;
@@ -128,4 +141,60 @@ mod bounded_vec_tests {
 
         assert(bounded_vec1 != bounded_vec2);
     }
+
+    mod from_array {
+        use crate::collections::bounded_vec::BoundedVec;
+
+        #[test]
+        fn empty() {
+            let empty_array: [Field; 0] = [];
+            let bounded_vec = BoundedVec::from_array([]);
+
+            assert_eq(bounded_vec.max_len(), 0);
+            assert_eq(bounded_vec.len(), 0);
+            assert_eq(bounded_vec.storage(), empty_array);
+        }
+
+        #[test]
+        fn equal_len() {
+            let array = [1, 2, 3];
+            let bounded_vec = BoundedVec::from_array(array);
+
+            assert_eq(bounded_vec.max_len(), 3);
+            assert_eq(bounded_vec.len(), 3);
+            assert_eq(bounded_vec.storage(), array);
+        }
+
+        #[test]
+        fn max_len_greater_then_array_len() {
+            let array = [1, 2, 3];
+            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);
+
+            assert_eq(bounded_vec.max_len(), 10);
+            assert_eq(bounded_vec.len(), 3);
+            assert_eq(bounded_vec.storage()[0], 1);
+            assert_eq(bounded_vec.storage()[1], 2);
+            assert_eq(bounded_vec.storage()[2], 3);
+        }
+
+        #[test(should_fail_with="from array out of bounds")]
+        fn max_len_lower_then_array_len() {
+            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);
+        }
+    }
+
+    mod trait_from {
+        use crate::collections::bounded_vec::BoundedVec;
+
+        #[test]
+        fn simple() {
+            let array = [1, 2];
+            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);
+
+            assert_eq(bounded_vec.max_len(), 10);
+            assert_eq(bounded_vec.len(), 2);
+            assert_eq(bounded_vec.storage()[0], 1);
+            assert_eq(bounded_vec.storage()[1], 2);
+        }
+    }
 }

From 07930d4373a393146210efae69e6ec40171f047b Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 6 May 2024 17:56:43 +0100
Subject: [PATCH 253/416] feat: add `Neg` trait to stdlib (#4983)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR implements the `std::op::Neg` trait so that we can implement
`Sub` on `EmbeddedCurvePoint`

## Additional Context

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

BEGIN_COMMIT_OVERRIDE
feat: add `std::ops::Neg` trait to stdlib
feat: implement `std::ops::Sub` on `EmbeddedCurvePoint`
END_COMMIT_OVERRIDE
---
 docs/docs/noir/standard_library/traits.md |  9 +++++++++
 noir_stdlib/src/ops.nr                    | 15 +++++++++++++++
 noir_stdlib/src/scalar_mul.nr             | 22 +++++++++++++++++-----
 3 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
index 2536d9a943f..b32a2969563 100644
--- a/docs/docs/noir/standard_library/traits.md
+++ b/docs/docs/noir/standard_library/traits.md
@@ -232,6 +232,15 @@ impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
 impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
 ```
 
+### `std::ops::Neg`
+
+#include_code neg-trait noir_stdlib/src/ops.nr rust
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+#include_code neg-trait-impls noir_stdlib/src/ops.nr rust
+
 ### `std::ops::{ BitOr, BitAnd, BitXor }`
 
 #include_code bitor-trait noir_stdlib/src/ops.nr rust
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index ad65a4e11fe..e0814267aea 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -76,6 +76,20 @@ impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
 impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
 impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
 
+// docs:start:neg-trait
+trait Neg {
+    fn neg(self) -> Self;
+}
+// docs:end:neg-trait
+
+// docs:start:neg-trait-impls
+impl Neg for Field { fn neg(self) -> Field { -self } }
+
+impl Neg for i8 { fn neg(self) -> i8 { -self } }
+impl Neg for i32 { fn neg(self) -> i32 { -self } }
+impl Neg for i64 { fn neg(self) -> i64 { -self } }
+// docs:end:neg-trait-impls
+
 // docs:start:bitor-trait
 trait BitOr {
     fn bitor(self, other: Self) -> Self;
@@ -153,3 +167,4 @@ impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
 impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
 impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
 impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
+
diff --git a/noir_stdlib/src/scalar_mul.nr b/noir_stdlib/src/scalar_mul.nr
index eee7aac39f2..4c5de863278 100644
--- a/noir_stdlib/src/scalar_mul.nr
+++ b/noir_stdlib/src/scalar_mul.nr
@@ -1,4 +1,4 @@
-use crate::ops::Add;
+use crate::ops::{Add, Sub, Neg};
 
 struct EmbeddedCurvePoint {
     x: Field,
@@ -17,6 +17,21 @@ impl Add for EmbeddedCurvePoint {
     }
 }
 
+impl Sub for EmbeddedCurvePoint {
+    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint { 
+        self + other.neg()
+    }
+}
+
+impl Neg for EmbeddedCurvePoint {
+    fn neg(self) -> EmbeddedCurvePoint { 
+        EmbeddedCurvePoint {
+            x: self.x,
+            y: -self.y
+        }
+    }
+}
+
 // Computes a fixed base scalar multiplication over the embedded curve.
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.
@@ -25,10 +40,7 @@ impl Add for EmbeddedCurvePoint {
 // underlying proof system.
 #[foreign(fixed_base_scalar_mul)]
 // docs:start:fixed_base_embedded_curve
-pub fn fixed_base_embedded_curve(
-    low: Field,
-    high: Field
-) -> [Field; 2]
+pub fn fixed_base_embedded_curve(low: Field, high: Field) -> [Field; 2]
 // docs:end:fixed_base_embedded_curve
 {}
 

From f3f11507983009771656811f9570bdbe6849c7ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gustavo=20Gir=C3=A1ldez?= <ggiraldez@manas.tech>
Date: Mon, 6 May 2024 17:09:04 -0400
Subject: [PATCH 254/416] fix: Compute the correct slice length when coercing
 from a literal array of complex types (#4986)

# Description

## Problem\*

Resolves #4967

## Summary\*

There is a problem in the [array to slice
coercion](https://github.com/noir-lang/noir/blob/07930d4373a393146210efae69e6ec40171f047b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs#L87)
code. When evaluating the coercion, it does not take into account that
for SSA, complex types such as tuples and structs are flattened,
resulting in an array representation with length of elements times the
size of the complex type (as a result of the flattening). This results
in the replacement slice having an incorrect size.

Then, because the slice has an inflated size, the code which decodes the
elements of the slice for printing or tracking (in the debugger) crashes
when it attempts to decode beyond the values that it has available.

## Additional Context

There are two additional minor changes introduced in this PR:

1. Removed the `Optional<>` for `PrintableType::Array`'s length. This
was introduced to be able to print slices (setting the length to
`None`), but those are now represented properly with
`PrintableType::Slice`.
2. Added support for printing slices.

Both are pretty small changes which I made while investigating the
issue, but I'm willing to send separate PRs for those if required.

I also expanded the existing test cases to verify both the coerced slice
length and printing of slices.

## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/ir/instruction/call.rs            | 12 +++++++++++-
 compiler/noirc_frontend/src/hir_def/types.rs  |  2 +-
 compiler/noirc_printable_type/src/lib.rs      | 19 ++++---------------
 .../execution_success/debug_logs/src/main.nr  | 13 +++++++++++++
 .../slice_coercion/src/main.nr                |  8 ++++++++
 tooling/nargo/src/artifacts/debug_vars.rs     | 14 ++++++--------
 6 files changed, 43 insertions(+), 25 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index dcde0aa79be..fca6a354f2c 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -87,8 +87,18 @@ pub(super) fn simplify_call(
         Intrinsic::AsSlice => {
             let array = dfg.get_array_constant(arguments[0]);
             if let Some((array, array_type)) = array {
-                let slice_length = dfg.make_constant(array.len().into(), Type::length_type());
+                // Compute the resulting slice length by dividing the flattened
+                // array length by the size of each array element
+                let elements_size = array_type.element_size();
                 let inner_element_types = array_type.element_types();
+                assert_eq!(
+                    0,
+                    array.len() % elements_size,
+                    "expected array length to be multiple of its elements size"
+                );
+                let slice_length_value = array.len() / elements_size;
+                let slice_length =
+                    dfg.make_constant(slice_length_value.into(), Type::length_type());
                 let new_slice = dfg.make_array(array, Type::Slice(inner_element_types));
                 SimplifyResult::SimplifiedToMultiple(vec![slice_length, new_slice])
             } else {
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 637f3c99e89..f3b2a24c1f0 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -1787,7 +1787,7 @@ impl From<&Type> for PrintableType {
         match value {
             Type::FieldElement => PrintableType::Field,
             Type::Array(size, typ) => {
-                let length = size.evaluate_to_u64();
+                let length = size.evaluate_to_u64().expect("Cannot print variable sized arrays");
                 let typ = typ.as_ref();
                 PrintableType::Array { length, typ: Box::new(typ.into()) }
             }
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index b9240203a5e..cc0dbca247e 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -11,7 +11,7 @@ use thiserror::Error;
 pub enum PrintableType {
     Field,
     Array {
-        length: Option<u64>,
+        length: u64,
         #[serde(rename = "type")]
         typ: Box<PrintableType>,
     },
@@ -186,7 +186,8 @@ fn to_string(value: &PrintableValue, typ: &PrintableType) -> Option<String> {
         (_, PrintableType::MutableReference { .. }) => {
             output.push_str("<<mutable ref>>");
         }
-        (PrintableValue::Vec { array_elements, is_slice }, PrintableType::Array { typ, .. }) => {
+        (PrintableValue::Vec { array_elements, is_slice }, PrintableType::Array { typ, .. })
+        | (PrintableValue::Vec { array_elements, is_slice }, PrintableType::Slice { typ }) => {
             if *is_slice {
                 output.push('&')
             }
@@ -317,19 +318,7 @@ pub fn decode_value(
 
             PrintableValue::Field(field_element)
         }
-        PrintableType::Array { length: None, typ } => {
-            let length = field_iterator
-                .next()
-                .expect("not enough data to decode variable array length")
-                .to_u128() as usize;
-            let mut array_elements = Vec::with_capacity(length);
-            for _ in 0..length {
-                array_elements.push(decode_value(field_iterator, typ));
-            }
-
-            PrintableValue::Vec { array_elements, is_slice: false }
-        }
-        PrintableType::Array { length: Some(length), typ } => {
+        PrintableType::Array { length, typ } => {
             let length = *length as usize;
             let mut array_elements = Vec::with_capacity(length);
             for _ in 0..length {
diff --git a/test_programs/execution_success/debug_logs/src/main.nr b/test_programs/execution_success/debug_logs/src/main.nr
index ec24b0cc8e8..c7fd01ebbc5 100644
--- a/test_programs/execution_success/debug_logs/src/main.nr
+++ b/test_programs/execution_success/debug_logs/src/main.nr
@@ -71,6 +71,8 @@ fn main(x: Field, y: pub Field) {
     let closured_lambda = |x| x + one;
     println(f"closured_lambda: {closured_lambda}, sentinel: {sentinel}");
     println(closured_lambda);
+
+    regression_4967();
 }
 
 fn string_identity(string: fmtstr<14, (Field, Field)>) -> fmtstr<14, (Field, Field)> {
@@ -122,3 +124,14 @@ fn regression_2906() {
     println(f"array_five_vals: {array_five_vals}, label_five_vals: {label_five_vals}");
 }
 
+fn regression_4967() {
+    let sentinel: u32 = 8888;
+
+    let slice_of_tuples: [(i32, u8)] = &[(11, 22), (33, 44)];
+    println(f"slice_of_tuples: {slice_of_tuples}, sentinel: {sentinel}");
+    println(slice_of_tuples);
+
+    let slice_of_tuples_coerced: [(i32, u8)] = [(11, 22), (33, 44)];
+    println(f"slice_of_tuples: {slice_of_tuples_coerced}, sentinel: {sentinel}");
+    println(slice_of_tuples_coerced);
+}
diff --git a/test_programs/execution_success/slice_coercion/src/main.nr b/test_programs/execution_success/slice_coercion/src/main.nr
index a3785e79afa..a7ba0443bd1 100644
--- a/test_programs/execution_success/slice_coercion/src/main.nr
+++ b/test_programs/execution_success/slice_coercion/src/main.nr
@@ -16,4 +16,12 @@ fn main(expected: pub Field, first: Field) {
     let mut hasher = Hasher::new();
     hasher.add(first);
     assert(hasher.fields[0] == expected);
+
+    regression_4967();
+}
+
+fn regression_4967() {
+    let var1: [(i32, u8)] = [(1, 2)];
+    assert(var1.len() == 1);
+    dep::std::println(var1);
 }
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 6a42a4c3311..3695fa47842 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -96,13 +96,11 @@ impl DebugVars {
                     PrintableType::Array { length, typ },
                 ) => {
                     assert!(!*is_slice, "slice has array type");
-                    if let Some(len) = length {
-                        if *index as u64 >= *len {
-                            panic!("unexpected field index past array length")
-                        }
-                        if *len != array_elements.len() as u64 {
-                            panic!("type/array length mismatch")
-                        }
+                    if *index as u64 >= *length {
+                        panic!("unexpected field index past array length")
+                    }
+                    if *length != array_elements.len() as u64 {
+                        panic!("type/array length mismatch")
                     }
                     (array_elements.get_mut(*index as usize).unwrap(), &*Box::leak(typ.clone()))
                 }
@@ -110,7 +108,7 @@ impl DebugVars {
                     PrintableValue::Vec { array_elements, is_slice },
                     PrintableType::Slice { typ },
                 ) => {
-                    assert!(*is_slice, "array has slice type");
+                    assert!(*is_slice, "slice doesn't have slice type");
                     (array_elements.get_mut(*index as usize).unwrap(), &*Box::leak(typ.clone()))
                 }
                 (

From c49d3a9ded819b828cffdfc031e86614da21e329 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Tue, 7 May 2024 10:47:08 +0200
Subject: [PATCH 255/416] fix: set index and value to 0 for array_get with
 predicate (#4971)

# Description

## Problem\*

Resolves issue on noir-protocol-circuit and should also resolve issues
described in https://github.com/noir-lang/noir/pull/4716.
The issue it resolves is that array_get under a predicate are done at
index 0 if the predicate is false, but since arrays are not homogenous,
it may contain some value that overflow the type of the array_get.

## Summary\*
When getting value from an array_get, I multiply it with the predicate
to avoid any possible overflow if element at index 0 has not the same
type as the expected one.

## Additional Context
If the array is simple (not nested), I get the offset to a compatible
type and use it when computing the predicate_index.
If the first element of the array has compatible size, then the
predicate_index will be correct
If not, we fallback to the multiplication of the value with the
predicate.


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 69 ++++++++++++++++---
 compiler/noirc_evaluator/src/ssa/ir/types.rs  |  8 +++
 .../Nargo.toml                                |  7 ++
 .../Prover.toml                               | 18 +++++
 .../src/main.nr                               | 38 ++++++++++
 5 files changed, 132 insertions(+), 8 deletions(-)
 create mode 100644 test_programs/execution_success/regression_struct_array_conditional/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_struct_array_conditional/Prover.toml
 create mode 100644 test_programs/execution_success/regression_struct_array_conditional/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 55c11e06ca3..16334052d27 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -957,13 +957,39 @@ impl<'a> Context<'a> {
             return Ok(());
         }
 
-        let (new_index, new_value) =
-            self.convert_array_operation_inputs(array, dfg, index, store_value)?;
+        // Get an offset such that the type of the array at the offset is the same as the type at the 'index'
+        // If we find one, we will use it when computing the index under the enable_side_effect predicate
+        // If not, array_get(..) will use a fallback costing one multiplication in the worst case.
+        // cf. https://github.com/noir-lang/noir/pull/4971
+        let array_id = dfg.resolve(array);
+        let array_typ = dfg.type_of_value(array_id);
+        // For simplicity we compute the offset only for simple arrays
+        let is_simple_array = dfg.instruction_results(instruction).len() == 1
+            && can_omit_element_sizes_array(&array_typ);
+        let offset = if is_simple_array {
+            let result_type = dfg.type_of_value(dfg.instruction_results(instruction)[0]);
+            match array_typ {
+                Type::Array(item_type, _) | Type::Slice(item_type) => item_type
+                    .iter()
+                    .enumerate()
+                    .find_map(|(index, typ)| (result_type == *typ).then_some(index)),
+                _ => None,
+            }
+        } else {
+            None
+        };
+        let (new_index, new_value) = self.convert_array_operation_inputs(
+            array,
+            dfg,
+            index,
+            store_value,
+            offset.unwrap_or_default(),
+        )?;
 
         if let Some(new_value) = new_value {
             self.array_set(instruction, new_index, new_value, dfg, mutable_array_set)?;
         } else {
-            self.array_get(instruction, array, new_index, dfg)?;
+            self.array_get(instruction, array, new_index, dfg, offset.is_none())?;
         }
 
         Ok(())
@@ -1053,7 +1079,7 @@ impl<'a> Context<'a> {
     /// - new_index is the index of the array. ACIR memory operations work with a flat memory, so we fully flattened the specified index
     ///     in case we have a nested array. The index for SSA array operations only represents the flattened index of the current array.
     ///     Thus internal array element type sizes need to be computed to accurately transform the index.
-    /// - predicate_index is 0, or the index if the predicate is true
+    /// - predicate_index is offset, or the index if the predicate is true
     /// - new_value is the optional value when the operation is an array_set
     ///     When there is a predicate, it is predicate*value + (1-predicate)*dummy, where dummy is the value of the array at the requested index.
     ///     It is a dummy value because in the case of a false predicate, the value stored at the requested index will be itself.
@@ -1063,14 +1089,18 @@ impl<'a> Context<'a> {
         dfg: &DataFlowGraph,
         index: ValueId,
         store_value: Option<ValueId>,
+        offset: usize,
     ) -> Result<(AcirVar, Option<AcirValue>), RuntimeError> {
         let (array_id, array_typ, block_id) = self.check_array_is_initialized(array, dfg)?;
 
         let index_var = self.convert_numeric_value(index, dfg)?;
         let index_var = self.get_flattened_index(&array_typ, array_id, index_var, dfg)?;
 
-        let predicate_index =
-            self.acir_context.mul_var(index_var, self.current_side_effects_enabled_var)?;
+        // predicate_index = index*predicate + (1-predicate)*offset
+        let offset = self.acir_context.add_constant(offset);
+        let sub = self.acir_context.sub_var(index_var, offset)?;
+        let pred = self.acir_context.mul_var(sub, self.current_side_effects_enabled_var)?;
+        let predicate_index = self.acir_context.add_var(pred, offset)?;
 
         let new_value = if let Some(store) = store_value {
             let store_value = self.convert_value(store, dfg);
@@ -1171,12 +1201,14 @@ impl<'a> Context<'a> {
     }
 
     /// Generates a read opcode for the array
+    /// `index_side_effect == false` means that we ensured `var_index` will have a type matching the value in the array
     fn array_get(
         &mut self,
         instruction: InstructionId,
         array: ValueId,
         mut var_index: AcirVar,
         dfg: &DataFlowGraph,
+        mut index_side_effect: bool,
     ) -> Result<AcirValue, RuntimeError> {
         let (array_id, _, block_id) = self.check_array_is_initialized(array, dfg)?;
         let results = dfg.instruction_results(instruction);
@@ -1195,7 +1227,7 @@ impl<'a> Context<'a> {
                     self.data_bus.call_data_map[&array_id] as i128,
                 ));
                 let new_index = self.acir_context.add_var(offset, bus_index)?;
-                return self.array_get(instruction, call_data, new_index, dfg);
+                return self.array_get(instruction, call_data, new_index, dfg, index_side_effect);
             }
         }
 
@@ -1204,7 +1236,28 @@ impl<'a> Context<'a> {
             !res_typ.contains_slice_element(),
             "ICE: Nested slice result found during ACIR generation"
         );
-        let value = self.array_get_value(&res_typ, block_id, &mut var_index)?;
+        let mut value = self.array_get_value(&res_typ, block_id, &mut var_index)?;
+
+        if let AcirValue::Var(value_var, typ) = &value {
+            let array_id = dfg.resolve(array_id);
+            let array_typ = dfg.type_of_value(array_id);
+            if let (Type::Numeric(numeric_type), AcirType::NumericType(num)) =
+                (array_typ.first(), typ)
+            {
+                if numeric_type.bit_size() <= num.bit_size() {
+                    // first element is compatible
+                    index_side_effect = false;
+                }
+            }
+            // Fallback to multiplication if the index side_effects have not already been handled
+            if index_side_effect {
+                // Set the value to 0 if current_side_effects is 0, to ensure it fits in any value type
+                value = AcirValue::Var(
+                    self.acir_context.mul_var(*value_var, self.current_side_effects_enabled_var)?,
+                    typ.clone(),
+                );
+            }
+        }
 
         self.define_result(dfg, instruction, value.clone());
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/types.rs b/compiler/noirc_evaluator/src/ssa/ir/types.rs
index 48036580d29..d72ad487f66 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/types.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/types.rs
@@ -166,6 +166,14 @@ impl Type {
             other => panic!("element_types: Expected array or slice, found {other}"),
         }
     }
+
+    pub(crate) fn first(&self) -> Type {
+        match self {
+            Type::Numeric(_) | Type::Function => self.clone(),
+            Type::Reference(typ) => typ.first(),
+            Type::Slice(element_types) | Type::Array(element_types, _) => element_types[0].first(),
+        }
+    }
 }
 
 /// Composite Types are essentially flattened struct or tuple types.
diff --git a/test_programs/execution_success/regression_struct_array_conditional/Nargo.toml b/test_programs/execution_success/regression_struct_array_conditional/Nargo.toml
new file mode 100644
index 00000000000..a0587210464
--- /dev/null
+++ b/test_programs/execution_success/regression_struct_array_conditional/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_struct_array_conditional"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_struct_array_conditional/Prover.toml b/test_programs/execution_success/regression_struct_array_conditional/Prover.toml
new file mode 100644
index 00000000000..ef97f9d482a
--- /dev/null
+++ b/test_programs/execution_success/regression_struct_array_conditional/Prover.toml
@@ -0,0 +1,18 @@
+y = 1
+z = 1
+
+[[x]]
+value =  "0x23de33be058ce5504e1ade738db8bdacfe268fa9dbde777092bf1d38519bdf59"
+counter = "10"
+dummy = "0"
+
+[[x]]
+value = "3"
+counter = "2"
+dummy = "0"
+
+[[x]]
+value = "2"
+counter = "0"
+dummy = "0"
+
diff --git a/test_programs/execution_success/regression_struct_array_conditional/src/main.nr b/test_programs/execution_success/regression_struct_array_conditional/src/main.nr
new file mode 100644
index 00000000000..17502a9fe50
--- /dev/null
+++ b/test_programs/execution_success/regression_struct_array_conditional/src/main.nr
@@ -0,0 +1,38 @@
+struct foo { 
+    value: Field,
+    counter: u8,
+    dummy: u8,
+}
+struct bar {
+    dummy: [u8;3],
+    value: Field,
+    counter: u8,
+}
+struct bar_field {
+    dummy: [Field;3],
+    value: Field,
+    counter: u8,
+}
+fn main(x: [foo; 3], y: u32, z: u32) -> pub u8 {
+    let a = [y, z, x[y].counter as u32];
+    let mut b = [bar { value: 0, counter: 0, dummy: [0; 3] }; 3];
+    let mut c = [bar_field { value: 0, counter: 0, dummy: [0; 3] }; 3];
+    for i in 0..3 {
+        b[i].value = x[i].value;
+        b[i].counter = x[i].counter;
+        b[i].dummy[0] = x[i].dummy;
+        c[i].value = x[i].value;
+        c[i].counter = x[i].counter;
+        c[i].dummy[0] = x[i].dummy as Field;
+    }
+    if z == 0 {
+        // offset
+        assert(y as u8 < x[y].counter);
+        assert(y <= a[y]);
+        // first element is compatible
+        assert(y as u8 < b[y].counter);
+        // fallback
+        assert(y as u8 < c[y].counter);
+    }
+    x[0].counter
+}

From e5f356b063fe4facbd14320b7eafed664d0bb027 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 7 May 2024 11:00:15 +0100
Subject: [PATCH 256/416] feat: remove query to backend to get expression width
 (#4975)

# Description

## Problem\*

Progress on #4961

## Summary\*

This PR removes the query to the backend in order to get the expression
width, for now we just have a blanket default of ~4~ 3 (Looks like we're
still waiting to update to a version of `bb` which uses 4). I've decided
to split the ability to specify a package-level override of this default
as I'd need to do some mucky stuff related to `compile_options`.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.
We don't have docs related to the expression width afaik.
# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |  1 -
 compiler/noirc_driver/src/lib.rs              |  4 +-
 tooling/backend_interface/Cargo.toml          |  1 -
 tooling/backend_interface/src/cli/info.rs     | 62 -------------------
 tooling/backend_interface/src/cli/mod.rs      |  2 -
 tooling/backend_interface/src/proof_system.rs | 25 +-------
 .../mock_backend/src/info_cmd.rs              | 40 ------------
 .../test-binaries/mock_backend/src/main.rs    |  3 -
 tooling/nargo_cli/src/cli/check_cmd.rs        |  7 +--
 .../nargo_cli/src/cli/codegen_verifier_cmd.rs |  3 +-
 tooling/nargo_cli/src/cli/compile_cmd.rs      | 17 +----
 tooling/nargo_cli/src/cli/dap_cmd.rs          | 18 ++----
 tooling/nargo_cli/src/cli/debug_cmd.rs        | 14 +----
 tooling/nargo_cli/src/cli/execute_cmd.rs      | 14 +----
 tooling/nargo_cli/src/cli/export_cmd.rs       |  7 +--
 tooling/nargo_cli/src/cli/info_cmd.rs         | 23 ++++---
 tooling/nargo_cli/src/cli/lsp_cmd.rs          |  8 +--
 tooling/nargo_cli/src/cli/mod.rs              | 18 +++---
 tooling/nargo_cli/src/cli/new_cmd.rs          |  8 +--
 tooling/nargo_cli/src/cli/prove_cmd.rs        |  7 +--
 tooling/nargo_cli/src/cli/test_cmd.rs         |  8 +--
 tooling/nargo_cli/src/cli/verify_cmd.rs       |  7 +--
 22 files changed, 54 insertions(+), 243 deletions(-)
 delete mode 100644 tooling/backend_interface/src/cli/info.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs

diff --git a/Cargo.lock b/Cargo.lock
index e2f5f0db303..1cc0f21ed86 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -461,7 +461,6 @@ dependencies = [
  "dirs",
  "flate2",
  "reqwest",
- "serde",
  "serde_json",
  "tar",
  "tempfile",
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index a2c069eac68..cd5a1c4a7fb 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -54,8 +54,8 @@ pub const NOIR_ARTIFACT_VERSION_STRING: &str =
 #[derive(Args, Clone, Debug, Default)]
 pub struct CompileOptions {
     /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width)]
-    pub expression_width: Option<ExpressionWidth>,
+    #[arg(long, value_parser = parse_expression_width, default_value = "3")]
+    pub expression_width: ExpressionWidth,
 
     /// Force a full recompilation.
     #[arg(long = "force")]
diff --git a/tooling/backend_interface/Cargo.toml b/tooling/backend_interface/Cargo.toml
index b731c138c7d..f6b5d5d0132 100644
--- a/tooling/backend_interface/Cargo.toml
+++ b/tooling/backend_interface/Cargo.toml
@@ -13,7 +13,6 @@ license.workspace = true
 acvm.workspace = true
 dirs.workspace = true
 thiserror.workspace = true
-serde.workspace = true
 serde_json.workspace = true
 bb_abstraction_leaks.workspace = true
 tracing.workspace = true
diff --git a/tooling/backend_interface/src/cli/info.rs b/tooling/backend_interface/src/cli/info.rs
deleted file mode 100644
index 6e6603ce53e..00000000000
--- a/tooling/backend_interface/src/cli/info.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use acvm::acir::circuit::ExpressionWidth;
-
-use serde::Deserialize;
-use std::path::{Path, PathBuf};
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-pub(crate) struct InfoCommand {
-    pub(crate) crs_path: PathBuf,
-}
-
-#[derive(Deserialize)]
-struct InfoResponse {
-    language: LanguageResponse,
-}
-
-#[derive(Deserialize)]
-struct LanguageResponse {
-    name: String,
-    width: Option<usize>,
-}
-
-impl InfoCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<ExpressionWidth, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command.arg("info").arg("-c").arg(self.crs_path).arg("-o").arg("-");
-
-        let output = command.output()?;
-
-        if !output.status.success() {
-            return Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)));
-        }
-
-        let backend_info: InfoResponse =
-            serde_json::from_slice(&output.stdout).expect("Backend should return valid json");
-        let expression_width: ExpressionWidth = match backend_info.language.name.as_str() {
-            "PLONK-CSAT" => {
-                let width = backend_info.language.width.unwrap();
-                ExpressionWidth::Bounded { width }
-            }
-            "R1CS" => ExpressionWidth::Unbounded,
-            _ => panic!("Unknown Expression width configuration"),
-        };
-
-        Ok(expression_width)
-    }
-}
-
-#[test]
-fn info_command() -> Result<(), BackendError> {
-    let backend = crate::get_mock_backend()?;
-    let crs_path = backend.backend_directory();
-
-    let expression_width = InfoCommand { crs_path }.run(backend.binary_path())?;
-
-    assert!(matches!(expression_width, ExpressionWidth::Bounded { width: 4 }));
-
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/cli/mod.rs b/tooling/backend_interface/src/cli/mod.rs
index b4dec859839..df43bd5cc2f 100644
--- a/tooling/backend_interface/src/cli/mod.rs
+++ b/tooling/backend_interface/src/cli/mod.rs
@@ -2,7 +2,6 @@
 
 mod contract;
 mod gates;
-mod info;
 mod proof_as_fields;
 mod prove;
 mod verify;
@@ -12,7 +11,6 @@ mod write_vk;
 
 pub(crate) use contract::ContractCommand;
 pub(crate) use gates::GatesCommand;
-pub(crate) use info::InfoCommand;
 pub(crate) use proof_as_fields::ProofAsFieldsCommand;
 pub(crate) use prove::ProveCommand;
 pub(crate) use verify::VerifyCommand;
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index fa1f82a5722..20a6dcf70f1 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -3,7 +3,7 @@ use std::io::Write;
 use std::path::Path;
 
 use acvm::acir::{
-    circuit::{ExpressionWidth, Program},
+    circuit::Program,
     native_types::{WitnessMap, WitnessStack},
 };
 use acvm::FieldElement;
@@ -11,8 +11,8 @@ use tempfile::tempdir;
 use tracing::warn;
 
 use crate::cli::{
-    GatesCommand, InfoCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand,
-    VkAsFieldsCommand, WriteVkCommand,
+    GatesCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand, VkAsFieldsCommand,
+    WriteVkCommand,
 };
 use crate::{Backend, BackendError};
 
@@ -33,25 +33,6 @@ impl Backend {
             .run(binary_path)
     }
 
-    pub fn get_backend_info(&self) -> Result<ExpressionWidth, BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-        InfoCommand { crs_path: self.crs_directory() }.run(binary_path)
-    }
-
-    /// If we cannot get a valid backend, returns `ExpressionWidth::Bound { width: 4 }``
-    /// The function also prints a message saying we could not find a backend
-    pub fn get_backend_info_or_default(&self) -> ExpressionWidth {
-        if let Ok(expression_width) = self.get_backend_info() {
-            expression_width
-        } else {
-            warn!(
-                "No valid backend found, ExpressionWidth defaulting to Bounded with a width of 4"
-            );
-            ExpressionWidth::Bounded { width: 4 }
-        }
-    }
-
     #[tracing::instrument(level = "trace", skip_all)]
     pub fn prove(
         &self,
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
deleted file mode 100644
index 75a6d323e7b..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use clap::Args;
-use std::io::Write;
-use std::path::PathBuf;
-
-const INFO_RESPONSE: &str = r#"{
-    "language": {
-        "name": "PLONK-CSAT",
-        "width": 4
-    },
-    "opcodes_supported": ["arithmetic", "directive", "brillig", "memory_init", "memory_op"],
-    "black_box_functions_supported": [
-        "and",
-        "xor",
-        "range",
-        "sha256",
-        "blake2s",
-        "blake3",
-        "keccak256",
-        "schnorr_verify",
-        "pedersen",
-        "pedersen_hash",
-        "ecdsa_secp256k1",
-        "ecdsa_secp256r1",
-        "fixed_base_scalar_mul",
-        "recursive_aggregation"
-    ]
-}"#;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct InfoCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'o')]
-    pub(crate) info_path: Option<PathBuf>,
-}
-
-pub(crate) fn run(_args: InfoCommand) {
-    std::io::stdout().write_all(INFO_RESPONSE.as_bytes()).unwrap();
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/main.rs b/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
index ef8819af94b..74ea82d28f8 100644
--- a/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
+++ b/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
@@ -7,7 +7,6 @@ use clap::{Parser, Subcommand};
 
 mod contract_cmd;
 mod gates_cmd;
-mod info_cmd;
 mod prove_cmd;
 mod verify_cmd;
 mod write_vk_cmd;
@@ -21,7 +20,6 @@ struct BackendCli {
 
 #[derive(Subcommand, Clone, Debug)]
 enum BackendCommand {
-    Info(info_cmd::InfoCommand),
     Contract(contract_cmd::ContractCommand),
     Gates(gates_cmd::GatesCommand),
     Prove(prove_cmd::ProveCommand),
@@ -34,7 +32,6 @@ fn main() {
     let BackendCli { command } = BackendCli::parse();
 
     match command {
-        BackendCommand::Info(args) => info_cmd::run(args),
         BackendCommand::Contract(args) => contract_cmd::run(args),
         BackendCommand::Gates(args) => gates_cmd::run(args),
         BackendCommand::Prove(args) => prove_cmd::run(args),
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 2b729e44b8a..208379b098d 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -1,4 +1,3 @@
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use clap::Args;
@@ -42,11 +41,7 @@ pub(crate) struct CheckCommand {
     compile_options: CompileOptions,
 }
 
-pub(crate) fn run(
-    _backend: &Backend,
-    args: CheckCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: CheckCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
diff --git a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
index 259e209b65a..8c64d9cd935 100644
--- a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
+++ b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
@@ -44,7 +44,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = backend.get_backend_info()?;
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -62,7 +61,7 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let program = nargo::ops::transform_program(program, expression_width);
+        let program = nargo::ops::transform_program(program, args.compile_options.expression_width);
 
         // TODO(https://github.com/noir-lang/noir/issues/4428):
         // We do not expect to have a smart contract verifier for a foldable program with multiple circuits.
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 54e8535f094..2f878406939 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -20,7 +20,6 @@ use noirc_frontend::hir::ParsedFiles;
 use notify::{EventKind, RecursiveMode, Watcher};
 use notify_debouncer_full::new_debouncer;
 
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use super::fs::program::only_acir;
@@ -47,11 +46,7 @@ pub(crate) struct CompileCommand {
     watch: bool,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    mut args: CompileCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: CompileCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
@@ -63,10 +58,6 @@ pub(crate) fn run(
         Some(NOIR_ARTIFACT_VERSION_STRING.to_owned()),
     )?;
 
-    if args.compile_options.expression_width.is_none() {
-        args.compile_options.expression_width = Some(backend.get_backend_info_or_default());
-    };
-
     if args.watch {
         watch_workspace(&workspace, &args.compile_options)
             .map_err(|err| CliError::Generic(err.to_string()))?;
@@ -128,8 +119,6 @@ fn compile_workspace_full(
     insert_all_files_for_workspace_into_file_manager(workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width =
-        compile_options.expression_width.expect("expression width should have been set");
     let compiled_workspace =
         compile_workspace(&workspace_file_manager, &parsed_files, workspace, compile_options);
 
@@ -149,12 +138,12 @@ fn compile_workspace_full(
     // Save build artifacts to disk.
     let only_acir = compile_options.only_acir;
     for (package, program) in binary_packages.into_iter().zip(compiled_programs) {
-        let program = nargo::ops::transform_program(program, expression_width);
+        let program = nargo::ops::transform_program(program, compile_options.expression_width);
         save_program(program.clone(), &package, &workspace.target_directory_path(), only_acir);
     }
     let circuit_dir = workspace.target_directory_path();
     for (package, contract) in contract_packages.into_iter().zip(compiled_contracts) {
-        let contract = nargo::ops::transform_contract(contract, expression_width);
+        let contract = nargo::ops::transform_contract(contract, compile_options.expression_width);
         save_contract(contract, &package, &circuit_dir);
     }
 
diff --git a/tooling/nargo_cli/src/cli/dap_cmd.rs b/tooling/nargo_cli/src/cli/dap_cmd.rs
index ba4f91609ef..d06d39f3b6a 100644
--- a/tooling/nargo_cli/src/cli/dap_cmd.rs
+++ b/tooling/nargo_cli/src/cli/dap_cmd.rs
@@ -1,6 +1,5 @@
 use acvm::acir::circuit::ExpressionWidth;
 use acvm::acir::native_types::WitnessMap;
-use backend_interface::Backend;
 use clap::Args;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::workspace::Workspace;
@@ -29,8 +28,8 @@ use noir_debugger::errors::{DapError, LoadError};
 #[derive(Debug, Clone, Args)]
 pub(crate) struct DapCommand {
     /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width)]
-    expression_width: Option<ExpressionWidth>,
+    #[arg(long, value_parser = parse_expression_width, default_value = "3")]
+    expression_width: ExpressionWidth,
 
     #[clap(long)]
     preflight_check: bool,
@@ -249,14 +248,7 @@ fn run_preflight_check(
     Ok(())
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: DapCommand,
-    _config: NargoConfig,
-) -> Result<(), CliError> {
-    let expression_width =
-        args.expression_width.unwrap_or_else(|| backend.get_backend_info_or_default());
-
+pub(crate) fn run(args: DapCommand, _config: NargoConfig) -> Result<(), CliError> {
     // When the --preflight-check flag is present, we run Noir's DAP server in "pre-flight mode", which test runs
     // the DAP initialization code without actually starting the DAP server.
     //
@@ -270,12 +262,12 @@ pub(crate) fn run(
     // the DAP loop is established, which otherwise are considered "out of band" by the maintainers of the DAP spec.
     // More details here: https://github.com/microsoft/vscode/issues/108138
     if args.preflight_check {
-        return run_preflight_check(expression_width, args).map_err(CliError::DapError);
+        return run_preflight_check(args.expression_width, args).map_err(CliError::DapError);
     }
 
     let output = BufWriter::new(std::io::stdout());
     let input = BufReader::new(std::io::stdin());
     let server = Server::new(input, output);
 
-    loop_uninitialized_dap(server, expression_width).map_err(CliError::DapError)
+    loop_uninitialized_dap(server, args.expression_width).map_err(CliError::DapError)
 }
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 7cb5cd7846b..f950cd0405c 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -24,7 +24,6 @@ use noirc_frontend::hir::ParsedFiles;
 
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 /// Executes a circuit in debug mode
@@ -53,11 +52,7 @@ pub(crate) struct DebugCommand {
     skip_instrumentation: Option<bool>,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: DebugCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: DebugCommand, config: NargoConfig) -> Result<(), CliError> {
     let acir_mode = args.acir_mode;
     let skip_instrumentation = args.skip_instrumentation.unwrap_or(acir_mode);
 
@@ -69,10 +64,6 @@ pub(crate) fn run(
         Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
     )?;
     let target_dir = &workspace.target_directory_path();
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
 
     let Some(package) = workspace.into_iter().find(|p| p.is_binary()) else {
         println!(
@@ -89,7 +80,8 @@ pub(crate) fn run(
         args.compile_options.clone(),
     )?;
 
-    let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let compiled_program =
+        nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
     run_async(package, compiled_program, &args.prover_name, &args.witness_name, target_dir)
 }
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index a353065491f..503d1606216 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -18,7 +18,6 @@ use noirc_frontend::graph::CrateName;
 
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 /// Executes a circuit to calculate its return value
@@ -48,11 +47,7 @@ pub(crate) struct ExecuteCommand {
     oracle_resolver: Option<String>,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: ExecuteCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: ExecuteCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
@@ -68,10 +63,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -89,7 +80,8 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+        let compiled_program =
+            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
         let (return_value, witness_stack) = execute_program_and_decode(
             compiled_program,
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index 044c2cb4ebb..a61f3ccfc02 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -20,7 +20,6 @@ use noirc_frontend::graph::CrateName;
 
 use clap::Args;
 
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use super::check_cmd::check_crate_and_report_errors;
@@ -43,11 +42,7 @@ pub(crate) struct ExportCommand {
     compile_options: CompileOptions,
 }
 
-pub(crate) fn run(
-    _backend: &Backend,
-    args: ExportCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: ExportCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 3695fb57d31..cac3c36f904 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -70,10 +70,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let compiled_workspace = compile_workspace(
         &workspace_file_manager,
         &parsed_files,
@@ -89,10 +85,10 @@ pub(crate) fn run(
     )?;
 
     let compiled_programs = vecmap(compiled_programs, |program| {
-        nargo::ops::transform_program(program, expression_width)
+        nargo::ops::transform_program(program, args.compile_options.expression_width)
     });
     let compiled_contracts = vecmap(compiled_contracts, |contract| {
-        nargo::ops::transform_contract(contract, expression_width)
+        nargo::ops::transform_contract(contract, args.compile_options.expression_width)
     });
 
     if args.profile_info {
@@ -122,13 +118,24 @@ pub(crate) fn run(
     let program_info = binary_packages
         .par_bridge()
         .map(|(package, program)| {
-            count_opcodes_and_gates_in_program(backend, program, package, expression_width)
+            count_opcodes_and_gates_in_program(
+                backend,
+                program,
+                package,
+                args.compile_options.expression_width,
+            )
         })
         .collect::<Result<_, _>>()?;
 
     let contract_info = compiled_contracts
         .into_par_iter()
-        .map(|contract| count_opcodes_and_gates_in_contract(backend, contract, expression_width))
+        .map(|contract| {
+            count_opcodes_and_gates_in_contract(
+                backend,
+                contract,
+                args.compile_options.expression_width,
+            )
+        })
         .collect::<Result<_, _>>()?;
 
     let info_report = InfoReport { programs: program_info, contracts: contract_info };
diff --git a/tooling/nargo_cli/src/cli/lsp_cmd.rs b/tooling/nargo_cli/src/cli/lsp_cmd.rs
index 1428b8070c8..45ac02ea552 100644
--- a/tooling/nargo_cli/src/cli/lsp_cmd.rs
+++ b/tooling/nargo_cli/src/cli/lsp_cmd.rs
@@ -8,7 +8,6 @@ use noir_lsp::NargoLspService;
 use tower::ServiceBuilder;
 
 use super::NargoConfig;
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 /// Starts the Noir LSP server
@@ -19,12 +18,7 @@ use crate::errors::CliError;
 #[derive(Debug, Clone, Args)]
 pub(crate) struct LspCommand;
 
-pub(crate) fn run(
-    // Backend is currently unused, but we might want to use it to inform the lsp in the future
-    _backend: &Backend,
-    _args: LspCommand,
-    _config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(_args: LspCommand, _config: NargoConfig) -> Result<(), CliError> {
     use tokio::runtime::Builder;
 
     let runtime = Builder::new_current_thread().enable_all().build().unwrap();
diff --git a/tooling/nargo_cli/src/cli/mod.rs b/tooling/nargo_cli/src/cli/mod.rs
index e8e17893815..ad778549ac0 100644
--- a/tooling/nargo_cli/src/cli/mod.rs
+++ b/tooling/nargo_cli/src/cli/mod.rs
@@ -107,21 +107,21 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
     let backend = crate::backends::Backend::new(active_backend);
 
     match command {
-        NargoCommand::New(args) => new_cmd::run(&backend, args, config),
+        NargoCommand::New(args) => new_cmd::run(args, config),
         NargoCommand::Init(args) => init_cmd::run(args, config),
-        NargoCommand::Check(args) => check_cmd::run(&backend, args, config),
-        NargoCommand::Compile(args) => compile_cmd::run(&backend, args, config),
-        NargoCommand::Debug(args) => debug_cmd::run(&backend, args, config),
-        NargoCommand::Execute(args) => execute_cmd::run(&backend, args, config),
-        NargoCommand::Export(args) => export_cmd::run(&backend, args, config),
+        NargoCommand::Check(args) => check_cmd::run(args, config),
+        NargoCommand::Compile(args) => compile_cmd::run(args, config),
+        NargoCommand::Debug(args) => debug_cmd::run(args, config),
+        NargoCommand::Execute(args) => execute_cmd::run(args, config),
+        NargoCommand::Export(args) => export_cmd::run(args, config),
         NargoCommand::Prove(args) => prove_cmd::run(&backend, args, config),
         NargoCommand::Verify(args) => verify_cmd::run(&backend, args, config),
-        NargoCommand::Test(args) => test_cmd::run(&backend, args, config),
+        NargoCommand::Test(args) => test_cmd::run(args, config),
         NargoCommand::Info(args) => info_cmd::run(&backend, args, config),
         NargoCommand::CodegenVerifier(args) => codegen_verifier_cmd::run(&backend, args, config),
         NargoCommand::Backend(args) => backend_cmd::run(args),
-        NargoCommand::Lsp(args) => lsp_cmd::run(&backend, args, config),
-        NargoCommand::Dap(args) => dap_cmd::run(&backend, args, config),
+        NargoCommand::Lsp(args) => lsp_cmd::run(args, config),
+        NargoCommand::Dap(args) => dap_cmd::run(args, config),
         NargoCommand::Fmt(args) => fmt_cmd::run(args, config),
     }?;
 
diff --git a/tooling/nargo_cli/src/cli/new_cmd.rs b/tooling/nargo_cli/src/cli/new_cmd.rs
index b4c823d0c1e..21951f27260 100644
--- a/tooling/nargo_cli/src/cli/new_cmd.rs
+++ b/tooling/nargo_cli/src/cli/new_cmd.rs
@@ -1,4 +1,3 @@
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use super::{init_cmd::initialize_project, NargoConfig};
@@ -30,12 +29,7 @@ pub(crate) struct NewCommand {
     pub(crate) contract: bool,
 }
 
-pub(crate) fn run(
-    // Backend is currently unused, but we might want to use it to inform the "new" template in the future
-    _backend: &Backend,
-    args: NewCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: NewCommand, config: NargoConfig) -> Result<(), CliError> {
     let package_dir = config.program_dir.join(&args.path);
 
     if package_dir.exists() {
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index b9e4bca9e69..47c71527fd8 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -69,10 +69,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -90,7 +86,8 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+        let compiled_program =
+            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
         prove_package(
             backend,
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 88a804d5cf4..967d4c87e6d 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -19,7 +19,7 @@ use noirc_frontend::{
 use rayon::prelude::{IntoParallelIterator, ParallelBridge, ParallelIterator};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
-use crate::{backends::Backend, cli::check_cmd::check_crate_and_report_errors, errors::CliError};
+use crate::{cli::check_cmd::check_crate_and_report_errors, errors::CliError};
 
 use super::NargoConfig;
 
@@ -54,11 +54,7 @@ pub(crate) struct TestCommand {
     oracle_resolver: Option<String>,
 }
 
-pub(crate) fn run(
-    _backend: &Backend,
-    args: TestCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: TestCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
index 7202a179aae..a6078f6c1d3 100644
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ b/tooling/nargo_cli/src/cli/verify_cmd.rs
@@ -54,10 +54,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -75,7 +71,8 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+        let compiled_program =
+            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
         verify_package(backend, &workspace, package, compiled_program, &args.verifier_name)?;
     }

From 9f2c21d2efe7f3c8d562531a75c084dfed85cf5f Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 7 May 2024 13:41:53 +0100
Subject: [PATCH 257/416] chore(ci): run clippy on benchmarks (#4988)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're not currently checking the benchmarks in CI which has resulted in
them no longer compiling. This PR adds them to the clippy checks which
will enforce that they compile properly.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/formatting.yml        | 2 +-
 acvm-repo/acir/benches/serialization.rs | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml
index 8166fb0f7c2..08c02af519f 100644
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@@ -44,7 +44,7 @@ jobs:
           save-if: ${{ github.event_name != 'merge_group' }}
 
       - name: Run `cargo clippy`
-        run: cargo clippy --workspace --locked --release
+        run: cargo clippy --all-targets --workspace --locked --release
 
       - name: Run `cargo fmt`
         run: cargo fmt --all --check
diff --git a/acvm-repo/acir/benches/serialization.rs b/acvm-repo/acir/benches/serialization.rs
index 73e3916a73b..e51726e3901 100644
--- a/acvm-repo/acir/benches/serialization.rs
+++ b/acvm-repo/acir/benches/serialization.rs
@@ -40,6 +40,7 @@ fn sample_program(num_opcodes: usize) -> Program {
             assert_messages: Vec::new(),
             recursive: false,
         }],
+        unconstrained_functions: Vec::new(),
     }
 }
 

From a1a2afbf6baff76c842a148982d1d652175efedd Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 7 May 2024 15:00:30 +0100
Subject: [PATCH 258/416] chore: split `ops` into `arith` and `bit` modules
 (#4989)

# Description

## Problem\*

Part of #4845

## Summary\*

This PR splits the `ops` module into `arith` and `bit` submodules
similarly to the Rust stdlib.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/noir/standard_library/traits.md |  24 +--
 noir_stdlib/src/ops.nr                    | 173 +---------------------
 noir_stdlib/src/ops/arith.nr              |  92 ++++++++++++
 noir_stdlib/src/ops/bit.nr                |  78 ++++++++++
 noir_stdlib/src/scalar_mul.nr             |   2 +-
 5 files changed, 187 insertions(+), 182 deletions(-)
 create mode 100644 noir_stdlib/src/ops/arith.nr
 create mode 100644 noir_stdlib/src/ops/bit.nr

diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
index b32a2969563..08370dde9e4 100644
--- a/docs/docs/noir/standard_library/traits.md
+++ b/docs/docs/noir/standard_library/traits.md
@@ -186,10 +186,10 @@ These traits abstract over addition, subtraction, multiplication, and division r
 Implementing these traits for a given type will also allow that type to be used with the corresponding operator
 for that trait (`+` for Add, etc) in addition to the normal method names.
 
-#include_code add-trait noir_stdlib/src/ops.nr rust
-#include_code sub-trait noir_stdlib/src/ops.nr rust
-#include_code mul-trait noir_stdlib/src/ops.nr rust
-#include_code div-trait noir_stdlib/src/ops.nr rust
+#include_code add-trait noir_stdlib/src/ops/arith.nr rust
+#include_code sub-trait noir_stdlib/src/ops/arith.nr rust
+#include_code mul-trait noir_stdlib/src/ops/arith.nr rust
+#include_code div-trait noir_stdlib/src/ops/arith.nr rust
 
 The implementations block below is given for the `Add` trait, but the same types that implement
 `Add` also implement `Sub`, `Mul`, and `Div`.
@@ -211,7 +211,7 @@ impl Add for u64 { .. }
 
 ### `std::ops::Rem`
 
-#include_code rem-trait noir_stdlib/src/ops.nr rust
+#include_code rem-trait noir_stdlib/src/ops/arith.nr rust
 
 `Rem::rem(a, b)` is the remainder function returning the result of what is
 left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
@@ -234,18 +234,18 @@ impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
 
 ### `std::ops::Neg`
 
-#include_code neg-trait noir_stdlib/src/ops.nr rust
+#include_code neg-trait noir_stdlib/src/ops/arith.nr rust
 
 `Neg::neg` is equivalent to the unary negation operator `-`.
 
 Implementations:
-#include_code neg-trait-impls noir_stdlib/src/ops.nr rust
+#include_code neg-trait-impls noir_stdlib/src/ops/arith.nr rust
 
 ### `std::ops::{ BitOr, BitAnd, BitXor }`
 
-#include_code bitor-trait noir_stdlib/src/ops.nr rust
-#include_code bitand-trait noir_stdlib/src/ops.nr rust
-#include_code bitxor-trait noir_stdlib/src/ops.nr rust
+#include_code bitor-trait noir_stdlib/src/ops/bit.nr rust
+#include_code bitand-trait noir_stdlib/src/ops/bit.nr rust
+#include_code bitxor-trait noir_stdlib/src/ops/bit.nr rust
 
 Traits for the bitwise operations `|`, `&`, and `^`.
 
@@ -272,8 +272,8 @@ impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
 
 ### `std::ops::{ Shl, Shr }`
 
-#include_code shl-trait noir_stdlib/src/ops.nr rust
-#include_code shr-trait noir_stdlib/src/ops.nr rust
+#include_code shl-trait noir_stdlib/src/ops/bit.nr rust
+#include_code shr-trait noir_stdlib/src/ops/bit.nr rust
 
 Traits for a bit shift left and bit shift right.
 
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index e0814267aea..d7ea1dfd484 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -1,170 +1,5 @@
-// docs:start:add-trait
-trait Add {
-    fn add(self, other: Self) -> Self;
-}
-// docs:end:add-trait
-
-impl Add for Field { fn add(self, other: Field) -> Field { self + other } }
-
-impl Add for u64 { fn add(self, other: u64) -> u64 { self + other } }
-impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
-impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
-
-impl Add for i8 { fn add(self, other: i8) -> i8 { self + other } }
-impl Add for i32 { fn add(self, other: i32) -> i32 { self + other } }
-impl Add for i64 { fn add(self, other: i64) -> i64 { self + other } }
-
-// docs:start:sub-trait
-trait Sub {
-    fn sub(self, other: Self) -> Self;
-}
-// docs:end:sub-trait
-
-impl Sub for Field { fn sub(self, other: Field) -> Field { self - other } }
-
-impl Sub for u64 { fn sub(self, other: u64) -> u64 { self - other } }
-impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
-impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
-
-impl Sub for i8 { fn sub(self, other: i8) -> i8 { self - other } }
-impl Sub for i32 { fn sub(self, other: i32) -> i32 { self - other } }
-impl Sub for i64 { fn sub(self, other: i64) -> i64 { self - other } }
-
-// docs:start:mul-trait
-trait Mul {
-    fn mul(self, other: Self) -> Self;
-}
-// docs:end:mul-trait
-
-impl Mul for Field { fn mul(self, other: Field) -> Field { self * other } }
-
-impl Mul for u64 { fn mul(self, other: u64) -> u64 { self * other } }
-impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
-impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
-
-impl Mul for i8 { fn mul(self, other: i8) -> i8 { self * other } }
-impl Mul for i32 { fn mul(self, other: i32) -> i32 { self * other } }
-impl Mul for i64 { fn mul(self, other: i64) -> i64 { self * other } }
-
-// docs:start:div-trait
-trait Div {
-    fn div(self, other: Self) -> Self;
-}
-// docs:end:div-trait
-
-impl Div for Field { fn div(self, other: Field) -> Field { self / other } }
-
-impl Div for u64 { fn div(self, other: u64) -> u64 { self / other } }
-impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
-impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
-
-impl Div for i8 { fn div(self, other: i8) -> i8 { self / other } }
-impl Div for i32 { fn div(self, other: i32) -> i32 { self / other } }
-impl Div for i64 { fn div(self, other: i64) -> i64 { self / other } }
-
-// docs:start:rem-trait
-trait Rem{
-    fn rem(self, other: Self) -> Self;
-}
-// docs:end:rem-trait
-
-impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
-impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
-impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
-
-impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
-impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
-impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
-
-// docs:start:neg-trait
-trait Neg {
-    fn neg(self) -> Self;
-}
-// docs:end:neg-trait
-
-// docs:start:neg-trait-impls
-impl Neg for Field { fn neg(self) -> Field { -self } }
-
-impl Neg for i8 { fn neg(self) -> i8 { -self } }
-impl Neg for i32 { fn neg(self) -> i32 { -self } }
-impl Neg for i64 { fn neg(self) -> i64 { -self } }
-// docs:end:neg-trait-impls
-
-// docs:start:bitor-trait
-trait BitOr {
-    fn bitor(self, other: Self) -> Self;
-}
-// docs:end:bitor-trait
-
-impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
-
-impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
-impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
-impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
-
-impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
-impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
-impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
-
-// docs:start:bitand-trait
-trait BitAnd {
-    fn bitand(self, other: Self) -> Self;
-}
-// docs:end:bitand-trait
-
-impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
-
-impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
-impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
-impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
-
-impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
-impl BitAnd for i32 { fn bitand(self, other: i32) -> i32 { self & other } }
-impl BitAnd for i64 { fn bitand(self, other: i64) -> i64 { self & other } }
-
-// docs:start:bitxor-trait
-trait BitXor {
-    fn bitxor(self, other: Self) -> Self;
-}
-// docs:end:bitxor-trait
-
-impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
-
-impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
-impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
-impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
-
-impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
-impl BitXor for i32 { fn bitxor(self, other: i32) -> i32 { self ^ other } }
-impl BitXor for i64 { fn bitxor(self, other: i64) -> i64 { self ^ other } }
-
-// docs:start:shl-trait
-trait Shl {
-    fn shl(self, other: u8) -> Self;
-}
-// docs:end:shl-trait
-
-impl Shl for u32 { fn shl(self, other: u8) -> u32 { self << other } }
-impl Shl for u64 { fn shl(self, other: u8) -> u64 { self << other } }
-impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
-impl Shl for u1 { fn shl(self, other: u8) -> u1 { self << other } }
-
-impl Shl for i8 { fn shl(self, other: u8) -> i8 { self << other } }
-impl Shl for i32 { fn shl(self, other: u8) -> i32 { self << other } }
-impl Shl for i64 { fn shl(self, other: u8) -> i64 { self << other } }
-
-// docs:start:shr-trait
-trait Shr {
-    fn shr(self, other: u8) -> Self;
-}
-// docs:end:shr-trait
-
-impl Shr for u64 { fn shr(self, other: u8) -> u64 { self >> other } }
-impl Shr for u32 { fn shr(self, other: u8) -> u32 { self >> other } }
-impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
-impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
-
-impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
-impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
-impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
+mod arith;
+mod bit;
 
+use arith::{Add, Sub, Mul, Div, Rem, Neg};
+use bit::{BitOr, BitAnd, BitXor, Shl, Shr};
diff --git a/noir_stdlib/src/ops/arith.nr b/noir_stdlib/src/ops/arith.nr
new file mode 100644
index 00000000000..ea7d633a456
--- /dev/null
+++ b/noir_stdlib/src/ops/arith.nr
@@ -0,0 +1,92 @@
+// docs:start:add-trait
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+// docs:end:add-trait
+
+impl Add for Field { fn add(self, other: Field) -> Field { self + other } }
+
+impl Add for u64 { fn add(self, other: u64) -> u64 { self + other } }
+impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
+impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
+
+impl Add for i8 { fn add(self, other: i8) -> i8 { self + other } }
+impl Add for i32 { fn add(self, other: i32) -> i32 { self + other } }
+impl Add for i64 { fn add(self, other: i64) -> i64 { self + other } }
+
+// docs:start:sub-trait
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+// docs:end:sub-trait
+
+impl Sub for Field { fn sub(self, other: Field) -> Field { self - other } }
+
+impl Sub for u64 { fn sub(self, other: u64) -> u64 { self - other } }
+impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
+impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
+
+impl Sub for i8 { fn sub(self, other: i8) -> i8 { self - other } }
+impl Sub for i32 { fn sub(self, other: i32) -> i32 { self - other } }
+impl Sub for i64 { fn sub(self, other: i64) -> i64 { self - other } }
+
+// docs:start:mul-trait
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+// docs:end:mul-trait
+
+impl Mul for Field { fn mul(self, other: Field) -> Field { self * other } }
+
+impl Mul for u64 { fn mul(self, other: u64) -> u64 { self * other } }
+impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
+impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
+
+impl Mul for i8 { fn mul(self, other: i8) -> i8 { self * other } }
+impl Mul for i32 { fn mul(self, other: i32) -> i32 { self * other } }
+impl Mul for i64 { fn mul(self, other: i64) -> i64 { self * other } }
+
+// docs:start:div-trait
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+// docs:end:div-trait
+
+impl Div for Field { fn div(self, other: Field) -> Field { self / other } }
+
+impl Div for u64 { fn div(self, other: u64) -> u64 { self / other } }
+impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
+impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
+
+impl Div for i8 { fn div(self, other: i8) -> i8 { self / other } }
+impl Div for i32 { fn div(self, other: i32) -> i32 { self / other } }
+impl Div for i64 { fn div(self, other: i64) -> i64 { self / other } }
+
+// docs:start:rem-trait
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+// docs:end:rem-trait
+
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+
+// docs:start:neg-trait
+trait Neg {
+    fn neg(self) -> Self;
+}
+// docs:end:neg-trait
+
+// docs:start:neg-trait-impls
+impl Neg for Field { fn neg(self) -> Field { -self } }
+
+impl Neg for i8 { fn neg(self) -> i8 { -self } }
+impl Neg for i32 { fn neg(self) -> i32 { -self } }
+impl Neg for i64 { fn neg(self) -> i64 { -self } }
+// docs:end:neg-trait-impls
+
diff --git a/noir_stdlib/src/ops/bit.nr b/noir_stdlib/src/ops/bit.nr
new file mode 100644
index 00000000000..8a3d20b1909
--- /dev/null
+++ b/noir_stdlib/src/ops/bit.nr
@@ -0,0 +1,78 @@
+// docs:start:bitor-trait
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+// docs:end:bitor-trait
+
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+
+// docs:start:bitand-trait
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+// docs:end:bitand-trait
+
+impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
+
+impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
+impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
+impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
+
+impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
+impl BitAnd for i32 { fn bitand(self, other: i32) -> i32 { self & other } }
+impl BitAnd for i64 { fn bitand(self, other: i64) -> i64 { self & other } }
+
+// docs:start:bitxor-trait
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+// docs:end:bitxor-trait
+
+impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
+
+impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
+impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
+impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
+
+impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
+impl BitXor for i32 { fn bitxor(self, other: i32) -> i32 { self ^ other } }
+impl BitXor for i64 { fn bitxor(self, other: i64) -> i64 { self ^ other } }
+
+// docs:start:shl-trait
+trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+// docs:end:shl-trait
+
+impl Shl for u32 { fn shl(self, other: u8) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u8) -> u64 { self << other } }
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u1 { fn shl(self, other: u8) -> u1 { self << other } }
+
+impl Shl for i8 { fn shl(self, other: u8) -> i8 { self << other } }
+impl Shl for i32 { fn shl(self, other: u8) -> i32 { self << other } }
+impl Shl for i64 { fn shl(self, other: u8) -> i64 { self << other } }
+
+// docs:start:shr-trait
+trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+// docs:end:shr-trait
+
+impl Shr for u64 { fn shr(self, other: u8) -> u64 { self >> other } }
+impl Shr for u32 { fn shr(self, other: u8) -> u32 { self >> other } }
+impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
+impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
+
+impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
+impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
+impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
+
diff --git a/noir_stdlib/src/scalar_mul.nr b/noir_stdlib/src/scalar_mul.nr
index 4c5de863278..5ce10058f8b 100644
--- a/noir_stdlib/src/scalar_mul.nr
+++ b/noir_stdlib/src/scalar_mul.nr
@@ -1,4 +1,4 @@
-use crate::ops::{Add, Sub, Neg};
+use crate::ops::arith::{Add, Sub, Neg};
 
 struct EmbeddedCurvePoint {
     x: Field,

From e43661d16c1cd07e2af2392b88d29c689889ff9a Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Tue, 7 May 2024 12:15:19 -0400
Subject: [PATCH 259/416] feat: add support for u16/i16 (#4985)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4908

## Summary\*

Adds cases for `u16`. `i16` was right there so added at the same time.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 compiler/noirc_frontend/src/ast/mod.rs        |  3 +
 .../src/hir/comptime/interpreter.rs           | 64 +++++++++++++++++++
 .../noirc_frontend/src/hir/comptime/tests.rs  | 13 ++++
 .../noirc_frontend/src/hir/comptime/value.rs  | 13 ++++
 compiler/noirc_frontend/src/parser/parser.rs  |  7 +-
 .../docs/noir/concepts/data_types/integers.md |  4 +-
 .../execution_success/u16_support/Nargo.toml  |  7 ++
 .../execution_success/u16_support/Prover.toml |  1 +
 .../execution_success/u16_support/src/main.nr | 24 +++++++
 9 files changed, 133 insertions(+), 3 deletions(-)
 create mode 100644 test_programs/execution_success/u16_support/Nargo.toml
 create mode 100644 test_programs/execution_success/u16_support/Prover.toml
 create mode 100644 test_programs/execution_success/u16_support/src/main.nr

diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 254ec4a7590..1c5a5c610aa 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -32,6 +32,7 @@ use iter_extended::vecmap;
 pub enum IntegerBitSize {
     One,
     Eight,
+    Sixteen,
     ThirtyTwo,
     SixtyFour,
 }
@@ -48,6 +49,7 @@ impl From<IntegerBitSize> for u32 {
         match size {
             One => 1,
             Eight => 8,
+            Sixteen => 16,
             ThirtyTwo => 32,
             SixtyFour => 64,
         }
@@ -64,6 +66,7 @@ impl TryFrom<u32> for IntegerBitSize {
         match value {
             1 => Ok(One),
             8 => Ok(Eight),
+            16 => Ok(Sixteen),
             32 => Ok(ThirtyTwo),
             64 => Ok(SixtyFour),
             _ => Err(InvalidIntegerBitSizeError(value)),
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 1903d113586..6dbda202c34 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -401,6 +401,14 @@ impl<'a> Interpreter<'a> {
                     let value = if is_negative { 0u8.wrapping_sub(value) } else { value };
                     Ok(Value::U8(value))
                 }
+                (Signedness::Unsigned, IntegerBitSize::Sixteen) => {
+                    let value: u16 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { 0u16.wrapping_sub(value) } else { value };
+                    Ok(Value::U16(value))
+                }
                 (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
                     let value: u32 =
                         value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
@@ -430,6 +438,14 @@ impl<'a> Interpreter<'a> {
                     let value = if is_negative { -value } else { value };
                     Ok(Value::I8(value))
                 }
+                (Signedness::Signed, IntegerBitSize::Sixteen) => {
+                    let value: i16 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { -value } else { value };
+                    Ok(Value::I16(value))
+                }
                 (Signedness::Signed, IntegerBitSize::ThirtyTwo) => {
                     let value: i32 =
                         value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
@@ -509,9 +525,11 @@ impl<'a> Interpreter<'a> {
             crate::ast::UnaryOp::Minus => match rhs {
                 Value::Field(value) => Ok(Value::Field(FieldElement::zero() - value)),
                 Value::I8(value) => Ok(Value::I8(-value)),
+                Value::I16(value) => Ok(Value::I16(-value)),
                 Value::I32(value) => Ok(Value::I32(-value)),
                 Value::I64(value) => Ok(Value::I64(-value)),
                 Value::U8(value) => Ok(Value::U8(0 - value)),
+                Value::U16(value) => Ok(Value::U16(0 - value)),
                 Value::U32(value) => Ok(Value::U32(0 - value)),
                 Value::U64(value) => Ok(Value::U64(0 - value)),
                 value => {
@@ -523,9 +541,11 @@ impl<'a> Interpreter<'a> {
             crate::ast::UnaryOp::Not => match rhs {
                 Value::Bool(value) => Ok(Value::Bool(!value)),
                 Value::I8(value) => Ok(Value::I8(!value)),
+                Value::I16(value) => Ok(Value::I16(!value)),
                 Value::I32(value) => Ok(Value::I32(!value)),
                 Value::I64(value) => Ok(Value::I64(!value)),
                 Value::U8(value) => Ok(Value::U8(!value)),
+                Value::U16(value) => Ok(Value::U16(!value)),
                 Value::U32(value) => Ok(Value::U32(!value)),
                 Value::U64(value) => Ok(Value::U64(!value)),
                 value => {
@@ -559,9 +579,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Add => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs + rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs + rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs + rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs + rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs + rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs + rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs + rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs + rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs + rhs)),
                 (lhs, rhs) => {
@@ -572,9 +594,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Subtract => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs - rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs - rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs - rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs - rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs - rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs - rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs - rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs - rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs - rhs)),
                 (lhs, rhs) => {
@@ -585,9 +609,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Multiply => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs * rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs * rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs * rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs * rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs * rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs * rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs * rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs * rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs * rhs)),
                 (lhs, rhs) => {
@@ -598,9 +624,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Divide => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs / rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs / rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs / rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs / rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs / rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs / rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs / rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs / rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs / rhs)),
                 (lhs, rhs) => {
@@ -611,9 +639,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Equal => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (lhs, rhs) => {
@@ -624,9 +654,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::NotEqual => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (lhs, rhs) => {
@@ -637,9 +669,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Less => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (lhs, rhs) => {
@@ -650,9 +684,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::LessEqual => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (lhs, rhs) => {
@@ -663,9 +699,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Greater => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (lhs, rhs) => {
@@ -676,9 +714,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::GreaterEqual => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (lhs, rhs) => {
@@ -689,9 +729,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::And => match (lhs, rhs) {
                 (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs & rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs & rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs & rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs & rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs & rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs & rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs & rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs & rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs & rhs)),
                 (lhs, rhs) => {
@@ -702,9 +744,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Or => match (lhs, rhs) {
                 (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs | rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs | rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs | rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs | rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs | rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs | rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs | rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs | rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs | rhs)),
                 (lhs, rhs) => {
@@ -715,9 +759,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Xor => match (lhs, rhs) {
                 (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs ^ rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs ^ rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs ^ rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs ^ rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs ^ rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs ^ rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs ^ rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs ^ rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs ^ rhs)),
                 (lhs, rhs) => {
@@ -727,9 +773,11 @@ impl<'a> Interpreter<'a> {
             },
             BinaryOpKind::ShiftRight => match (lhs, rhs) {
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs >> rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs >> rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs >> rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs >> rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs >> rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs >> rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs >> rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs >> rhs)),
                 (lhs, rhs) => {
@@ -739,9 +787,11 @@ impl<'a> Interpreter<'a> {
             },
             BinaryOpKind::ShiftLeft => match (lhs, rhs) {
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs << rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs << rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs << rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs << rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs << rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs << rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs << rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs << rhs)),
                 (lhs, rhs) => {
@@ -751,9 +801,11 @@ impl<'a> Interpreter<'a> {
             },
             BinaryOpKind::Modulo => match (lhs, rhs) {
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs % rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs % rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs % rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs % rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs % rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs % rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs % rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs % rhs)),
                 (lhs, rhs) => {
@@ -795,9 +847,11 @@ impl<'a> Interpreter<'a> {
                 value.try_to_u64().expect("index could not fit into u64") as usize
             }
             Value::I8(value) => value as usize,
+            Value::I16(value) => value as usize,
             Value::I32(value) => value as usize,
             Value::I64(value) => value as usize,
             Value::U8(value) => value as usize,
+            Value::U16(value) => value as usize,
             Value::U32(value) => value as usize,
             Value::U64(value) => value as usize,
             value => {
@@ -908,9 +962,11 @@ impl<'a> Interpreter<'a> {
         let (mut lhs, lhs_is_negative) = match self.evaluate(cast.lhs)? {
             Value::Field(value) => (value, false),
             Value::U8(value) => ((value as u128).into(), false),
+            Value::U16(value) => ((value as u128).into(), false),
             Value::U32(value) => ((value as u128).into(), false),
             Value::U64(value) => ((value as u128).into(), false),
             Value::I8(value) => signed_int_to_field!(value),
+            Value::I16(value) => signed_int_to_field!(value),
             Value::I32(value) => signed_int_to_field!(value),
             Value::I64(value) => signed_int_to_field!(value),
             Value::Bool(value) => {
@@ -946,6 +1002,9 @@ impl<'a> Interpreter<'a> {
                     Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
                 }
                 (Signedness::Unsigned, IntegerBitSize::Eight) => cast_to_int!(lhs, to_u128, u8, U8),
+                (Signedness::Unsigned, IntegerBitSize::Sixteen) => {
+                    cast_to_int!(lhs, to_u128, u16, U16)
+                }
                 (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
                     cast_to_int!(lhs, to_u128, u32, U32)
                 }
@@ -957,6 +1016,9 @@ impl<'a> Interpreter<'a> {
                     Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
                 }
                 (Signedness::Signed, IntegerBitSize::Eight) => cast_to_int!(lhs, to_i128, i8, I8),
+                (Signedness::Signed, IntegerBitSize::Sixteen) => {
+                    cast_to_int!(lhs, to_i128, i16, I16)
+                }
                 (Signedness::Signed, IntegerBitSize::ThirtyTwo) => {
                     cast_to_int!(lhs, to_i128, i32, I32)
                 }
@@ -1149,9 +1211,11 @@ impl<'a> Interpreter<'a> {
         let get_index = |this: &mut Self, expr| -> IResult<(_, fn(_) -> _)> {
             match this.evaluate(expr)? {
                 Value::I8(value) => Ok((value as i128, |i| Value::I8(i as i8))),
+                Value::I16(value) => Ok((value as i128, |i| Value::I16(i as i16))),
                 Value::I32(value) => Ok((value as i128, |i| Value::I32(i as i32))),
                 Value::I64(value) => Ok((value as i128, |i| Value::I64(i as i64))),
                 Value::U8(value) => Ok((value as i128, |i| Value::U8(i as u8))),
+                Value::U16(value) => Ok((value as i128, |i| Value::U16(i as u16))),
                 Value::U32(value) => Ok((value as i128, |i| Value::U32(i as u32))),
                 Value::U64(value) => Ok((value as i128, |i| Value::U64(i as u64))),
                 value => {
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 5a12eb7292c..41475d3ccf4 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -103,6 +103,19 @@ fn for_loop() {
     assert_eq!(result, Value::U8(15));
 }
 
+#[test]
+fn for_loop_u16() {
+    let program = "fn main() -> pub u16 {
+        let mut x = 0;
+        for i in 0 .. 6 {
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U16(15));
+}
+
 #[test]
 fn for_loop_with_break() {
     let program = "unconstrained fn main() -> pub u32 {
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 6845c6ac5a9..4e4a260871a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -22,9 +22,11 @@ pub enum Value {
     Bool(bool),
     Field(FieldElement),
     I8(i8),
+    I16(i16),
     I32(i32),
     I64(i64),
     U8(u8),
+    U16(u16),
     U32(u32),
     U64(u64),
     String(Rc<String>),
@@ -45,9 +47,11 @@ impl Value {
             Value::Bool(_) => Type::Bool,
             Value::Field(_) => Type::FieldElement,
             Value::I8(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Eight),
+            Value::I16(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Sixteen),
             Value::I32(_) => Type::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo),
             Value::I64(_) => Type::Integer(Signedness::Signed, IntegerBitSize::SixtyFour),
             Value::U8(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+            Value::U16(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Sixteen),
             Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
             Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
             Value::String(value) => {
@@ -87,6 +91,12 @@ impl Value {
                 let value = (value as u128).into();
                 HirExpression::Literal(HirLiteral::Integer(value, negative))
             }
+            Value::I16(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                HirExpression::Literal(HirLiteral::Integer(value, negative))
+            }
             Value::I32(value) => {
                 let negative = value < 0;
                 let value = value.abs();
@@ -102,6 +112,9 @@ impl Value {
             Value::U8(value) => {
                 HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
             }
+            Value::U16(value) => {
+                HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
+            }
             Value::U32(value) => {
                 HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
             }
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index b627714d2a6..b527284d1a9 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1374,7 +1374,7 @@ mod test {
                 fresh_statement(),
                 true,
             ),
-            vec!["x as u8", "0 as Field", "(x + 3) as [Field; 8]"],
+            vec!["x as u8", "x as u16", "0 as Field", "(x + 3) as [Field; 8]"],
         );
         parse_all_failing(
             atom_or_right_unary(
@@ -1546,7 +1546,10 @@ mod test {
         // Let statements are not type checked here, so the parser will accept as
         // long as it is a type. Other statements such as Public are type checked
         // Because for now, they can only have one type
-        parse_all(declaration(expression()), vec!["let _ = 42", "let x = y", "let x : u8 = y"]);
+        parse_all(
+            declaration(expression()),
+            vec!["let _ = 42", "let x = y", "let x : u8 = y", "let x: u16 = y"],
+        );
     }
 
     #[test]
diff --git a/docs/docs/noir/concepts/data_types/integers.md b/docs/docs/noir/concepts/data_types/integers.md
index 1c6b375db49..6b2d3773912 100644
--- a/docs/docs/noir/concepts/data_types/integers.md
+++ b/docs/docs/noir/concepts/data_types/integers.md
@@ -5,7 +5,9 @@ keywords: [noir, integer types, methods, examples, arithmetic]
 sidebar_position: 1
 ---
 
-An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
 
 :::info
 
diff --git a/test_programs/execution_success/u16_support/Nargo.toml b/test_programs/execution_success/u16_support/Nargo.toml
new file mode 100644
index 00000000000..1c6b58e01e8
--- /dev/null
+++ b/test_programs/execution_success/u16_support/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "u16_support"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/u16_support/Prover.toml b/test_programs/execution_success/u16_support/Prover.toml
new file mode 100644
index 00000000000..a56a84e61a4
--- /dev/null
+++ b/test_programs/execution_success/u16_support/Prover.toml
@@ -0,0 +1 @@
+x = "2"
diff --git a/test_programs/execution_success/u16_support/src/main.nr b/test_programs/execution_success/u16_support/src/main.nr
new file mode 100644
index 00000000000..e8b418f16da
--- /dev/null
+++ b/test_programs/execution_success/u16_support/src/main.nr
@@ -0,0 +1,24 @@
+fn main(x: u16) {
+    test_u16(x);
+    test_u16_unconstrained(x);
+}
+
+unconstrained fn test_u16_unconstrained(x: u16) {
+    test_u16(x)
+}
+
+fn test_u16(x: u16) {
+    let t1: u16 = 1234;
+    let t2: u16 = 4321;
+    let t = t1 + t2;
+
+    let t4 = t - t2;
+    assert(t4 == t1);
+
+    let mut small_int = x as u16;
+    let shift = small_int << (x as u8);
+    assert(shift == 8);
+    assert(shift >> (x as u8) == small_int);
+    assert(shift >> 15 == 0);
+    assert(shift << 15 == 0);
+}

From b5777613c51f26fb4f580b9168c4190b1f4bd8f7 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 8 May 2024 12:35:31 +0200
Subject: [PATCH 260/416] fix: defer overflow checks for unsigned integers to
 acir-gen (#4832)

# Description

## Problem\*

Resolves #4456

## Summary\*

Overflow checks for unsigned integers are done in acir-gen, when
converting arithmetic operations into field arithmetic. That way the
semantic of the ssa unsigned operations is preserved.

## Additional Context

As indicated in the issue, I did not touch signed integers, but it could
be cleaner to convert them into unsigned operations (and have the signed
overflow checks done with additional ssa instructions, like we do
currently)

## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../src/brillig/brillig_gen/brillig_block.rs  | 87 ++++++++++++-------
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 70 ++++++++++++++-
 .../src/ssa/opt/remove_bit_shifts.rs          | 11 ++-
 .../src/ssa/opt/remove_enable_side_effects.rs | 12 +--
 .../src/ssa/ssa_gen/context.rs                | 49 ++---------
 5 files changed, 140 insertions(+), 89 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index ff8d33c0fdc..e10127d8f28 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1340,7 +1340,15 @@ impl<'block> BrilligBlock<'block> {
 
         self.brillig_context.binary_instruction(left, right, result_variable, brillig_binary_op);
 
-        self.add_overflow_check(brillig_binary_op, left, right, result_variable, is_signed);
+        self.add_overflow_check(
+            brillig_binary_op,
+            left,
+            right,
+            result_variable,
+            binary,
+            dfg,
+            is_signed,
+        );
     }
 
     /// Splits a two's complement signed integer in the sign bit and the absolute value.
@@ -1493,15 +1501,20 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.deallocate_single_addr(bias);
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn add_overflow_check(
         &mut self,
         binary_operation: BrilligBinaryOp,
         left: SingleAddrVariable,
         right: SingleAddrVariable,
         result: SingleAddrVariable,
+        binary: &Binary,
+        dfg: &DataFlowGraph,
         is_signed: bool,
     ) {
         let bit_size = left.bit_size;
+        let max_lhs_bits = dfg.get_value_max_num_bits(binary.lhs);
+        let max_rhs_bits = dfg.get_value_max_num_bits(binary.rhs);
 
         if bit_size == FieldElement::max_num_bits() {
             return;
@@ -1509,6 +1522,11 @@ impl<'block> BrilligBlock<'block> {
 
         match (binary_operation, is_signed) {
             (BrilligBinaryOp::Add, false) => {
+                if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
+                    // `left` and `right` have both been casted up from smaller types and so cannot overflow.
+                    return;
+                }
+
                 let condition =
                     SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that lhs <= result
@@ -1523,6 +1541,12 @@ impl<'block> BrilligBlock<'block> {
                 self.brillig_context.deallocate_single_addr(condition);
             }
             (BrilligBinaryOp::Sub, false) => {
+                if dfg.is_constant(binary.lhs) && max_lhs_bits > max_rhs_bits {
+                    // `left` is a fixed constant and `right` is restricted such that `left - right > 0`
+                    // Note strict inequality as `right > left` while `max_lhs_bits == max_rhs_bits` is possible.
+                    return;
+                }
+
                 let condition =
                     SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that rhs <= lhs
@@ -1539,39 +1563,36 @@ impl<'block> BrilligBlock<'block> {
                 self.brillig_context.deallocate_single_addr(condition);
             }
             (BrilligBinaryOp::Mul, false) => {
-                // Multiplication overflow is only possible for bit sizes > 1
-                if bit_size > 1 {
-                    let is_right_zero =
-                        SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
-                    let zero =
-                        self.brillig_context.make_constant_instruction(0_usize.into(), bit_size);
-                    self.brillig_context.binary_instruction(
-                        zero,
-                        right,
-                        is_right_zero,
-                        BrilligBinaryOp::Equals,
-                    );
-                    self.brillig_context.codegen_if_not(is_right_zero.address, |ctx| {
-                        let condition = SingleAddrVariable::new(ctx.allocate_register(), 1);
-                        let division = SingleAddrVariable::new(ctx.allocate_register(), bit_size);
-                        // Check that result / rhs == lhs
-                        ctx.binary_instruction(
-                            result,
-                            right,
-                            division,
-                            BrilligBinaryOp::UnsignedDiv,
-                        );
-                        ctx.binary_instruction(division, left, condition, BrilligBinaryOp::Equals);
-                        ctx.codegen_constrain(
-                            condition,
-                            Some("attempt to multiply with overflow".to_string()),
-                        );
-                        ctx.deallocate_single_addr(condition);
-                        ctx.deallocate_single_addr(division);
-                    });
-                    self.brillig_context.deallocate_single_addr(is_right_zero);
-                    self.brillig_context.deallocate_single_addr(zero);
+                if bit_size == 1 || max_lhs_bits + max_rhs_bits <= bit_size {
+                    // Either performing boolean multiplication (which cannot overflow),
+                    // or `left` and `right` have both been casted up from smaller types and so cannot overflow.
+                    return;
                 }
+
+                let is_right_zero =
+                    SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
+                let zero = self.brillig_context.make_constant_instruction(0_usize.into(), bit_size);
+                self.brillig_context.binary_instruction(
+                    zero,
+                    right,
+                    is_right_zero,
+                    BrilligBinaryOp::Equals,
+                );
+                self.brillig_context.codegen_if_not(is_right_zero.address, |ctx| {
+                    let condition = SingleAddrVariable::new(ctx.allocate_register(), 1);
+                    let division = SingleAddrVariable::new(ctx.allocate_register(), bit_size);
+                    // Check that result / rhs == lhs
+                    ctx.binary_instruction(result, right, division, BrilligBinaryOp::UnsignedDiv);
+                    ctx.binary_instruction(division, left, condition, BrilligBinaryOp::Equals);
+                    ctx.codegen_constrain(
+                        condition,
+                        Some("attempt to multiply with overflow".to_string()),
+                    );
+                    ctx.deallocate_single_addr(condition);
+                    ctx.deallocate_single_addr(division);
+                });
+                self.brillig_context.deallocate_single_addr(is_right_zero);
+                self.brillig_context.deallocate_single_addr(zero);
             }
             _ => {}
         }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 16334052d27..b17ca6b043b 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1818,15 +1818,15 @@ impl<'a> Context<'a> {
 
         let binary_type = AcirType::from(binary_type);
         let bit_count = binary_type.bit_size();
-
-        match binary.operator {
+        let num_type = binary_type.to_numeric_type();
+        let result = match binary.operator {
             BinaryOp::Add => self.acir_context.add_var(lhs, rhs),
             BinaryOp::Sub => self.acir_context.sub_var(lhs, rhs),
             BinaryOp::Mul => self.acir_context.mul_var(lhs, rhs),
             BinaryOp::Div => self.acir_context.div_var(
                 lhs,
                 rhs,
-                binary_type,
+                binary_type.clone(),
                 self.current_side_effects_enabled_var,
             ),
             // Note: that this produces unnecessary constraints when
@@ -1850,7 +1850,71 @@ impl<'a> Context<'a> {
             BinaryOp::Shl | BinaryOp::Shr => unreachable!(
                 "ICE - bit shift operators do not exist in ACIR and should have been replaced"
             ),
+        }?;
+
+        if let NumericType::Unsigned { bit_size } = &num_type {
+            // Check for integer overflow
+            self.check_unsigned_overflow(
+                result,
+                *bit_size,
+                binary.lhs,
+                binary.rhs,
+                dfg,
+                binary.operator,
+            )?;
         }
+
+        Ok(result)
+    }
+
+    /// Adds a range check against the bit size of the result of addition, subtraction or multiplication
+    fn check_unsigned_overflow(
+        &mut self,
+        result: AcirVar,
+        bit_size: u32,
+        lhs: ValueId,
+        rhs: ValueId,
+        dfg: &DataFlowGraph,
+        op: BinaryOp,
+    ) -> Result<(), RuntimeError> {
+        // We try to optimize away operations that are guaranteed not to overflow
+        let max_lhs_bits = dfg.get_value_max_num_bits(lhs);
+        let max_rhs_bits = dfg.get_value_max_num_bits(rhs);
+
+        let msg = match op {
+            BinaryOp::Add => {
+                if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
+                    // `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
+                    return Ok(());
+                }
+                "attempt to add with overflow".to_string()
+            }
+            BinaryOp::Sub => {
+                if dfg.is_constant(lhs) && max_lhs_bits > max_rhs_bits {
+                    // `lhs` is a fixed constant and `rhs` is restricted such that `lhs - rhs > 0`
+                    // Note strict inequality as `rhs > lhs` while `max_lhs_bits == max_rhs_bits` is possible.
+                    return Ok(());
+                }
+                "attempt to subtract with overflow".to_string()
+            }
+            BinaryOp::Mul => {
+                if bit_size == 1 || max_lhs_bits + max_rhs_bits <= bit_size {
+                    // Either performing boolean multiplication (which cannot overflow),
+                    // or `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
+                    return Ok(());
+                }
+                "attempt to multiply with overflow".to_string()
+            }
+            _ => return Ok(()),
+        };
+
+        let with_pred = self.acir_context.mul_var(result, self.current_side_effects_enabled_var)?;
+        self.acir_context.range_constrain_var(
+            with_pred,
+            &NumericType::Unsigned { bit_size },
+            Some(msg),
+        )?;
+        Ok(())
     }
 
     /// Operands in a binary operation are checked to have the same type.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index 81e3023f3f8..1103237947d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -109,7 +109,7 @@ impl Context<'_> {
                     return InsertInstructionResult::SimplifiedTo(zero).first();
                 }
             }
-            let pow = self.numeric_constant(FieldElement::from(rhs_bit_size_pow_2), typ);
+            let pow = self.numeric_constant(FieldElement::from(rhs_bit_size_pow_2), typ.clone());
 
             let max_lhs_bits = self.function.dfg.get_value_max_num_bits(lhs);
 
@@ -123,15 +123,18 @@ impl Context<'_> {
             // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
             let rhs_unsigned = self.insert_cast(rhs, Type::unsigned(bit_size));
             let pow = self.pow(base, rhs_unsigned);
-            let pow = self.insert_cast(pow, typ);
+            let pow = self.insert_cast(pow, typ.clone());
             (FieldElement::max_num_bits(), self.insert_binary(predicate, BinaryOp::Mul, pow))
         };
 
         if max_bit <= bit_size {
             self.insert_binary(lhs, BinaryOp::Mul, pow)
         } else {
-            let result = self.insert_binary(lhs, BinaryOp::Mul, pow);
-            self.insert_truncate(result, bit_size, max_bit)
+            let lhs_field = self.insert_cast(lhs, Type::field());
+            let pow_field = self.insert_cast(pow, Type::field());
+            let result = self.insert_binary(lhs_field, BinaryOp::Mul, pow_field);
+            let result = self.insert_truncate(result, bit_size, max_bit);
+            self.insert_cast(result, typ)
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 02b9202b209..ea37d857e58 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -108,17 +108,19 @@ impl Context {
     fn responds_to_side_effects_var(dfg: &DataFlowGraph, instruction: &Instruction) -> bool {
         use Instruction::*;
         match instruction {
-            Binary(binary) => {
-                if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) {
+            Binary(binary) => match binary.operator {
+                BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul => {
+                    dfg.type_of_value(binary.lhs).is_unsigned()
+                }
+                BinaryOp::Div | BinaryOp::Mod => {
                     if let Some(rhs) = dfg.get_numeric_constant(binary.rhs) {
                         rhs == FieldElement::zero()
                     } else {
                         true
                     }
-                } else {
-                    false
                 }
-            }
+                _ => false,
+            },
 
             Cast(_, _)
             | Not(_)
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index f7ecdc8870d..ebcbfbabe73 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -304,7 +304,7 @@ impl<'a> FunctionContext<'a> {
 
     /// Insert constraints ensuring that the operation does not overflow the bit size of the result
     ///
-    /// If the result is unsigned, we simply range check against the bit size
+    /// If the result is unsigned, overflow will be checked during acir-gen (cf. issue #4456), except for bit-shifts, because we will convert them to field multiplication
     ///
     /// If the result is signed, we just prepare it for check_signed_overflow() by casting it to
     /// an unsigned value representing the signed integer.
@@ -351,51 +351,12 @@ impl<'a> FunctionContext<'a> {
             }
             Type::Numeric(NumericType::Unsigned { bit_size }) => {
                 let dfg = &self.builder.current_function.dfg;
-
-                let max_lhs_bits = self.builder.current_function.dfg.get_value_max_num_bits(lhs);
-                let max_rhs_bits = self.builder.current_function.dfg.get_value_max_num_bits(rhs);
+                let max_lhs_bits = dfg.get_value_max_num_bits(lhs);
 
                 match operator {
-                    BinaryOpKind::Add => {
-                        if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
-                            // `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
-                            return result;
-                        }
-
-                        let message = "attempt to add with overflow".to_string();
-                        self.builder.set_location(location).insert_range_check(
-                            result,
-                            bit_size,
-                            Some(message),
-                        );
-                    }
-                    BinaryOpKind::Subtract => {
-                        if dfg.is_constant(lhs) && max_lhs_bits > max_rhs_bits {
-                            // `lhs` is a fixed constant and `rhs` is restricted such that `lhs - rhs > 0`
-                            // Note strict inequality as `rhs > lhs` while `max_lhs_bits == max_rhs_bits` is possible.
-                            return result;
-                        }
-
-                        let message = "attempt to subtract with overflow".to_string();
-                        self.builder.set_location(location).insert_range_check(
-                            result,
-                            bit_size,
-                            Some(message),
-                        );
-                    }
-                    BinaryOpKind::Multiply => {
-                        if bit_size == 1 || max_lhs_bits + max_rhs_bits <= bit_size {
-                            // Either performing boolean multiplication (which cannot overflow),
-                            // or `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
-                            return result;
-                        }
-
-                        let message = "attempt to multiply with overflow".to_string();
-                        self.builder.set_location(location).insert_range_check(
-                            result,
-                            bit_size,
-                            Some(message),
-                        );
+                    BinaryOpKind::Add | BinaryOpKind::Subtract | BinaryOpKind::Multiply => {
+                        // Overflow check is deferred to acir-gen
+                        return result;
                     }
                     BinaryOpKind::ShiftLeft => {
                         if let Some(rhs_const) = dfg.get_numeric_constant(rhs) {

From 73a635e5086cf3407f9846ce39807cd15b4e485a Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 8 May 2024 07:52:50 -0400
Subject: [PATCH 261/416] feat: Sync from aztec-packages (#4993)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat!: AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)
chore(aztec-macros): avm function return types are auto tagged as `pub`
(https://github.com/AztecProtocol/aztec-packages/pull/6250)
refactor: nuking `GrumpkinScalar`
(https://github.com/AztecProtocol/aztec-packages/pull/6240)
feat: `multi_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6097)
feat: Set aztec private functions to be recursive
(https://github.com/AztecProtocol/aztec-packages/pull/6192)
feat: Parsing non-string assertion payloads in noir js
(https://github.com/AztecProtocol/aztec-packages/pull/6079)
feat: `variable_base_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6039)
feat: Dynamic assertion payloads v2
(https://github.com/AztecProtocol/aztec-packages/pull/5949)
chore!: remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
---
 .aztec-sync-commit                            |   2 +-
 .release-please-manifest.json                 |   2 +-
 CONTRIBUTING.md                               |   2 +-
 Cargo.lock                                    |   8 +
 Cargo.toml                                    |   2 +-
 acvm-repo/acir/README.md                      |  14 +-
 acvm-repo/acir/codegen/acir.cpp               | 816 ++++++++++++------
 .../acir/src/circuit/black_box_functions.rs   |  12 +-
 acvm-repo/acir/src/circuit/brillig.rs         |  10 -
 acvm-repo/acir/src/circuit/mod.rs             |  83 +-
 acvm-repo/acir/src/circuit/opcodes.rs         |   9 +-
 .../opcodes/black_box_function_call.rs        |  33 +-
 acvm-repo/acir/src/lib.rs                     |   5 +-
 .../acir/tests/test_program_serialization.rs  | 182 ++--
 acvm-repo/acvm/src/compiler/mod.rs            |   6 +-
 acvm-repo/acvm/src/compiler/optimizers/mod.rs |   2 +-
 .../acvm/src/compiler/transformers/mod.rs     |  14 -
 acvm-repo/acvm/src/pwg/arithmetic.rs          |   4 +
 acvm-repo/acvm/src/pwg/blackbox/aes128.rs     |  32 +
 ...se_scalar_mul.rs => embedded_curve_ops.rs} |  23 +-
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |  16 +-
 acvm-repo/acvm/src/pwg/blackbox/range.rs      |   1 +
 .../acvm/src/pwg/blackbox/signature/ecdsa.rs  |  10 +-
 .../acvm/src/pwg/blackbox/signature/mod.rs    |  34 -
 .../src/pwg/blackbox/signature/schnorr.rs     |   6 +-
 acvm-repo/acvm/src/pwg/blackbox/utils.rs      |  33 +
 acvm-repo/acvm/src/pwg/brillig.rs             |  78 +-
 acvm-repo/acvm/src/pwg/directives/mod.rs      |   1 +
 acvm-repo/acvm/src/pwg/mod.rs                 | 169 ++--
 acvm-repo/acvm/tests/solver.rs                | 336 ++++----
 acvm-repo/acvm_js/src/execute.rs              |  68 +-
 acvm-repo/acvm_js/src/js_execution_error.rs   |  20 +-
 .../test/browser/execute_circuit.test.ts      |   4 +-
 .../acvm_js/test/node/execute_circuit.test.ts |   4 +-
 .../test/shared/complex_foreign_call.ts       |  14 +-
 .../test/shared/fixed_base_scalar_mul.ts      |  17 -
 acvm-repo/acvm_js/test/shared/foreign_call.ts |   8 +-
 acvm-repo/acvm_js/test/shared/memory_op.ts    |   8 +-
 .../acvm_js/test/shared/multi_scalar_mul.ts   |  21 +
 .../acvm_js/test/shared/nested_acir_call.ts   |  14 +-
 acvm-repo/acvm_js/test/shared/pedersen.ts     |   4 +-
 .../acvm_js/test/shared/schnorr_verify.ts     |   4 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   1 +
 acvm-repo/blackbox_solver/src/aes128.rs       |  12 +
 .../src/curve_specific_solver.rs              |  14 +-
 acvm-repo/blackbox_solver/src/lib.rs          |   2 +
 .../src/embedded_curve_ops.rs                 | 241 ++++++
 .../src/fixed_base_scalar_mul.rs              | 165 ----
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |  12 +-
 acvm-repo/brillig/src/black_box.rs            |  17 +-
 acvm-repo/brillig/src/opcodes.rs              |   9 +-
 acvm-repo/brillig_vm/src/black_box.rs         |  37 +-
 acvm-repo/brillig_vm/src/lib.rs               |  10 +-
 .../src/transforms/contract_interface.rs      |   1 +
 aztec_macros/src/transforms/functions.rs      |  10 +-
 compiler/noirc_driver/src/abi_gen.rs          |  12 +-
 compiler/noirc_driver/src/lib.rs              |   2 +
 compiler/noirc_errors/Cargo.toml              |   2 +-
 .../brillig/brillig_gen/brillig_black_box.rs  |  42 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |  56 +-
 .../noirc_evaluator/src/brillig/brillig_ir.rs |  10 +-
 .../src/brillig/brillig_ir/artifact.rs        |   4 +-
 .../brillig_ir/codegen_control_flow.rs        |  71 +-
 .../src/brillig/brillig_ir/debug_show.rs      |  29 +-
 .../src/brillig/brillig_ir/entry_point.rs     |   6 +-
 .../src/brillig/brillig_ir/instructions.rs    |   8 +-
 compiler/noirc_evaluator/src/errors.rs        |  20 +-
 compiler/noirc_evaluator/src/ssa.rs           |  30 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |  54 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  40 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  74 +-
 .../src/ssa/function_builder/mod.rs           |  16 +-
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  64 +-
 .../src/ssa/ir/instruction/call.rs            |   3 +-
 .../src/ssa/ir/instruction/constrain.rs       |   2 +-
 .../noirc_evaluator/src/ssa/ir/post_order.rs  |   2 +-
 .../noirc_evaluator/src/ssa/ir/printer.rs     |  56 +-
 .../src/ssa/opt/defunctionalize.rs            |  31 +-
 .../src/ssa/opt/remove_bit_shifts.rs          |   2 +-
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  68 +-
 .../src/ssa/ssa_gen/program.rs                |   9 +-
 .../src/hir/comptime/interpreter.rs           |   6 +-
 .../src/hir/resolution/resolver.rs            |  49 +-
 .../src/monomorphization/ast.rs               |   4 +-
 .../src/monomorphization/mod.rs               |   9 +-
 .../noir/standard_library/black_box_fns.md    |   3 +-
 .../cryptographic_primitives/ciphers.mdx      |  28 +
 .../embedded_curve_ops.mdx                    |  77 ++
 .../cryptographic_primitives/scalar.mdx       |  26 -
 docs/docs/tutorials/noirjs_app.md             |   2 +-
 .../getting_started/01_tiny_noir_app.md       |   2 +-
 .../getting_started/01_tiny_noir_app.md       |   2 +-
 .../getting_started/01_tiny_noir_app.md       |   2 +-
 .../getting_started/01_tiny_noir_app.md       |   2 +-
 .../getting_started/01_tiny_noir_app.md       |   2 +-
 .../getting_started/01_tiny_noir_app.md       |   2 +-
 .../version-v0.22.0/tutorials/noirjs_app.md   |   2 +-
 .../version-v0.23.0/tutorials/noirjs_app.md   |   2 +-
 .../version-v0.24.0/tutorials/noirjs_app.md   |   2 +-
 .../version-v0.25.0/tutorials/noirjs_app.md   |   2 +-
 .../version-v0.26.0/tutorials/noirjs_app.md   |   2 +-
 .../version-v0.27.0/tutorials/noirjs_app.md   |   2 +-
 noir_stdlib/src/aes128.nr                     |   4 +
 .../{scalar_mul.nr => embedded_curve_ops.nr}  |  34 +-
 noir_stdlib/src/grumpkin_scalar.nr            |  21 -
 noir_stdlib/src/grumpkin_scalar_mul.nr        |   7 -
 noir_stdlib/src/internal.nr                   |  12 -
 noir_stdlib/src/lib.nr                        |   6 +-
 .../intrinsic_die/src/main.nr                 |   4 +-
 .../aes128_encrypt/Nargo.toml                 |   7 +
 .../aes128_encrypt/Prover.toml                |   4 +
 .../aes128_encrypt/src/main.nr                |  44 +
 .../Nargo.toml                                |   2 +-
 .../brillig_embedded_curve/Prover.toml        |   3 +
 .../brillig_embedded_curve/src/main.nr        |  24 +
 .../brillig_scalar_mul/Prover.toml            |   7 -
 .../brillig_scalar_mul/src/main.nr            |  32 -
 .../Nargo.toml                                |   2 +-
 .../embedded_curve_ops/Prover.toml            |   3 +
 .../embedded_curve_ops/src/main.nr            |  24 +
 .../inline_never_basic/Nargo.toml             |   7 +
 .../inline_never_basic/Prover.toml            |   2 +
 .../inline_never_basic/src/main.nr            |   8 +
 .../execution_success/scalar_mul/Prover.toml  |   7 -
 .../execution_success/scalar_mul/src/main.nr  |  31 -
 .../simple_shield/src/main.nr                 |   2 +-
 .../should_fail_with_matches/src/main.nr      |  64 ++
 test_programs/rebuild.sh                      |  13 +-
 tooling/bb_abstraction_leaks/build.rs         |   2 +-
 tooling/debugger/ignored-tests.txt            |   3 +-
 tooling/debugger/src/context.rs               |   5 +-
 tooling/debugger/src/foreign_calls.rs         |  16 +-
 tooling/lsp/src/solver.rs                     |   8 +-
 tooling/nargo/src/errors.rs                   |  57 +-
 tooling/nargo/src/ops/execute.rs              |  65 +-
 tooling/nargo/src/ops/foreign_calls.rs        |  86 +-
 tooling/nargo/src/ops/mod.rs                  |   4 +-
 tooling/nargo/src/ops/test.rs                 |  21 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |   4 +-
 tooling/nargo_cli/src/cli/fs/inputs.rs        |   1 +
 .../noir_js/scripts/compile_test_programs.sh  |   2 +-
 tooling/noir_js/src/index.ts                  |   1 +
 tooling/noir_js/src/witness_generation.ts     |  42 +-
 tooling/noir_js/test/node/execute.test.ts     |  90 +-
 .../assert_msg_runtime/src/main.nr            |   4 +-
 .../assert_raw_payload/Nargo.toml             |   7 +
 .../assert_raw_payload/src/main.nr            |   9 +
 .../noir_js_backend_barretenberg/package.json |   2 +-
 .../test/public_input_deflattening.test.ts    |   1 +
 tooling/noir_js_types/src/types.ts            |  15 +
 tooling/noirc_abi/Cargo.toml                  |   1 +
 tooling/noirc_abi/src/input_parser/mod.rs     |   1 +
 tooling/noirc_abi/src/lib.rs                  | 100 ++-
 tooling/noirc_abi_wasm/build.sh               |   2 +-
 tooling/noirc_abi_wasm/src/lib.rs             |  43 +-
 .../test/browser/decode_error.test.ts         |  64 ++
 .../test/node/decode_error.test.ts            |  60 ++
 .../noirc_abi_wasm/test/shared/abi_encode.ts  |   1 +
 .../test/shared/array_as_field.ts             |   1 +
 .../test/shared/decode_error.ts               |  46 +
 .../test/shared/field_as_array.ts             |   1 +
 tooling/noirc_abi_wasm/test/shared/structs.ts |   1 +
 .../test/shared/uint_overflow.ts              |   1 +
 yarn.lock                                     |  10 +-
 164 files changed, 3054 insertions(+), 1700 deletions(-)
 create mode 100644 acvm-repo/acvm/src/pwg/blackbox/aes128.rs
 rename acvm-repo/acvm/src/pwg/blackbox/{fixed_base_scalar_mul.rs => embedded_curve_ops.rs} (60%)
 create mode 100644 acvm-repo/acvm/src/pwg/blackbox/utils.rs
 delete mode 100644 acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
 create mode 100644 acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
 create mode 100644 acvm-repo/blackbox_solver/src/aes128.rs
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
 delete mode 100644 acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
 create mode 100644 docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx
 create mode 100644 docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
 delete mode 100644 docs/docs/noir/standard_library/cryptographic_primitives/scalar.mdx
 create mode 100644 noir_stdlib/src/aes128.nr
 rename noir_stdlib/src/{scalar_mul.nr => embedded_curve_ops.nr} (61%)
 delete mode 100644 noir_stdlib/src/grumpkin_scalar.nr
 delete mode 100644 noir_stdlib/src/grumpkin_scalar_mul.nr
 delete mode 100644 noir_stdlib/src/internal.nr
 create mode 100644 test_programs/execution_success/aes128_encrypt/Nargo.toml
 create mode 100644 test_programs/execution_success/aes128_encrypt/Prover.toml
 create mode 100644 test_programs/execution_success/aes128_encrypt/src/main.nr
 rename test_programs/execution_success/{scalar_mul => brillig_embedded_curve}/Nargo.toml (62%)
 create mode 100644 test_programs/execution_success/brillig_embedded_curve/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_embedded_curve/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_scalar_mul/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_scalar_mul/src/main.nr
 rename test_programs/execution_success/{brillig_scalar_mul => embedded_curve_ops}/Nargo.toml (65%)
 create mode 100644 test_programs/execution_success/embedded_curve_ops/Prover.toml
 create mode 100644 test_programs/execution_success/embedded_curve_ops/src/main.nr
 create mode 100644 test_programs/execution_success/inline_never_basic/Nargo.toml
 create mode 100644 test_programs/execution_success/inline_never_basic/Prover.toml
 create mode 100644 test_programs/execution_success/inline_never_basic/src/main.nr
 delete mode 100644 test_programs/execution_success/scalar_mul/Prover.toml
 delete mode 100644 test_programs/execution_success/scalar_mul/src/main.nr
 create mode 100644 tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/Nargo.toml
 create mode 100644 tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/src/main.nr
 create mode 100644 tooling/noirc_abi_wasm/test/browser/decode_error.test.ts
 create mode 100644 tooling/noirc_abi_wasm/test/node/decode_error.test.ts
 create mode 100644 tooling/noirc_abi_wasm/test/shared/decode_error.ts

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index a159698f8a8..b9e87cffedc 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-2e64428af9525bd8c390931061505f7b48d729a4
+1c74387e56b49102043fc6701735325a891e6c65
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 13ef934aaee..447e12155b8 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
   ".": "0.29.0",
   "acvm-repo": "0.45.0"
-}
\ No newline at end of file
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d2553b003f8..c02d24e91b8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -196,7 +196,7 @@ yarn docusaurus docs:version <new_version_tag>
 
 This should create a new version by copying the docs folder and the sidebars.js file to the relevant folders, as well as adding this version to versions.json.
 
-You can then open a Pull Request according to the the [PR section](#pull-requests)
+You can then open a Pull Request according to the [PR section](#pull-requests)
 
 ## Changelog
 
diff --git a/Cargo.lock b/Cargo.lock
index 1cc0f21ed86..a8c63c032aa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -63,6 +63,7 @@ dependencies = [
  "blake3",
  "k256",
  "keccak",
+ "libaes",
  "num-bigint",
  "p256",
  "sha2",
@@ -2615,6 +2616,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
+[[package]]
+name = "libaes"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82903360c009b816f5ab72a9b68158c27c301ee2c3f20655b55c5e589e7d3bb7"
+
 [[package]]
 name = "libc"
 version = "0.2.151"
@@ -3067,6 +3074,7 @@ dependencies = [
  "acvm",
  "iter-extended",
  "noirc_frontend",
+ "noirc_printable_type",
  "num-bigint",
  "num-traits",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 370201773ec..f744d6d0cf5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -111,7 +111,7 @@ chumsky = { git = "https://github.com/jfecher/chumsky", rev = "ad9d312", default
 criterion = "0.5.0"
 # Note that using the "frame-pointer" feature breaks framegraphs on linux
 # https://github.com/tikv/pprof-rs/pull/172
-pprof = { version = "0.13", features = ["flamegraph","criterion"] }
+pprof = { version = "0.13", features = ["flamegraph", "criterion"] }
 
 
 dirs = "4"
diff --git a/acvm-repo/acir/README.md b/acvm-repo/acir/README.md
index 801aeac1140..f7fccad0799 100644
--- a/acvm-repo/acir/README.md
+++ b/acvm-repo/acir/README.md
@@ -76,6 +76,12 @@ Some more advanced computations assume that the proving system has an 'embedded
 
 The black box functions supported by ACIR are:
 
+**AES128Encrypt**: ciphers the provided plaintext using AES128 in CBC mode, padding the input using PKCS#7.
+- inputs: byte array [u8; N]
+- iv: initialization vector [u8; 16]
+- key: user key [u8; 16]
+- outputs: byte vector [u8] of length `input.len() + (16 - input.len() % 16)``
+
 **AND**: performs the bitwise AND of lhs and rhs. bit_size must be the same for both inputs.
 - lhs: (witness, bit_size)
 - rhs: (witness, bit_size)
@@ -139,9 +145,11 @@ Inputs and outputs are similar to SchnorrVerify, except that because we use a di
 
 **EcdsaSecp256r1**: Same as EcdsaSecp256k1, but done over another curve.
 
-**FixedBaseScalarMul**: scalar multiplication with a fixed generator of the embedded curve
-- input: low, high are 2 (field , 254), representing the low and high part of the input. For Barretenberg, they must both be less than 128 bits.
-- output: x and y coordinates of $low*G+high*2^{128}*G$, where G is a fixed generator
+**MultiScalarMul**: scalar multiplication with a variable base/input point (P) of the embedded curve
+- input:
+    points (FieldElement, N) a vector of x and y coordinates of input points [x1, y1, x2, y2,...].
+    scalars (FieldElement, N) a vector of low and high limbs of input scalars [s1_low, s1_high, s2_low, s2_high, ...]. (FieldElement, N) For Barretenberg, they must both be less than 128 bits.
+- output: (FieldElement, N) a vector of x and y coordinates of output points [op1_x, op1_y, op2_x, op2_y, ...]. Points computed as $s_low*P+s_high*2^{128}*P$
 
 Because the Grumpkin scalar field is bigger than the ACIR field, we provide 2 ACIR fields representing the low and high parts of the Grumpkin scalar $a$:
 $a=low+high*2^{128},$ with $low, high < 2^{128}$
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 6c7bd347e5d..b7e75c4320d 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -24,6 +24,17 @@ namespace Program {
 
     struct BlackBoxFuncCall {
 
+        struct AES128Encrypt {
+            std::vector<Program::FunctionInput> inputs;
+            std::array<Program::FunctionInput, 16> iv;
+            std::array<Program::FunctionInput, 16> key;
+            std::vector<Program::Witness> outputs;
+
+            friend bool operator==(const AES128Encrypt&, const AES128Encrypt&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static AES128Encrypt bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct AND {
             Program::FunctionInput lhs;
             Program::FunctionInput rhs;
@@ -135,14 +146,14 @@ namespace Program {
             static EcdsaSecp256r1 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct FixedBaseScalarMul {
-            Program::FunctionInput low;
-            Program::FunctionInput high;
+        struct MultiScalarMul {
+            std::vector<Program::FunctionInput> points;
+            std::vector<Program::FunctionInput> scalars;
             std::array<Program::Witness, 2> outputs;
 
-            friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
+            friend bool operator==(const MultiScalarMul&, const MultiScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
+            static MultiScalarMul bincodeDeserialize(std::vector<uint8_t>);
         };
 
         struct EmbeddedCurveAdd {
@@ -266,7 +277,7 @@ namespace Program {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        std::variant<AES128Encrypt, AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, MultiScalarMul, EmbeddedCurveAdd, Keccak256, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -324,6 +335,134 @@ namespace Program {
         static BrilligInputs bincodeDeserialize(std::vector<uint8_t>);
     };
 
+    struct BrilligOutputs {
+
+        struct Simple {
+            Program::Witness value;
+
+            friend bool operator==(const Simple&, const Simple&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Simple bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Array {
+            std::vector<Program::Witness> value;
+
+            friend bool operator==(const Array&, const Array&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Array bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Simple, Array> value;
+
+        friend bool operator==(const BrilligOutputs&, const BrilligOutputs&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static BrilligOutputs bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct Directive {
+
+        struct ToLeRadix {
+            Program::Expression a;
+            std::vector<Program::Witness> b;
+            uint32_t radix;
+
+            friend bool operator==(const ToLeRadix&, const ToLeRadix&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static ToLeRadix bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<ToLeRadix> value;
+
+        friend bool operator==(const Directive&, const Directive&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Directive bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct MemOp {
+        Program::Expression operation;
+        Program::Expression index;
+        Program::Expression value;
+
+        friend bool operator==(const MemOp&, const MemOp&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static MemOp bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct Opcode {
+
+        struct AssertZero {
+            Program::Expression value;
+
+            friend bool operator==(const AssertZero&, const AssertZero&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static AssertZero bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BlackBoxFuncCall {
+            Program::BlackBoxFuncCall value;
+
+            friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BlackBoxFuncCall bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Directive {
+            Program::Directive value;
+
+            friend bool operator==(const Directive&, const Directive&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Directive bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct MemoryOp {
+            Program::BlockId block_id;
+            Program::MemOp op;
+            std::optional<Program::Expression> predicate;
+
+            friend bool operator==(const MemoryOp&, const MemoryOp&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static MemoryOp bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct MemoryInit {
+            Program::BlockId block_id;
+            std::vector<Program::Witness> init;
+
+            friend bool operator==(const MemoryInit&, const MemoryInit&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static MemoryInit bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BrilligCall {
+            uint32_t id;
+            std::vector<Program::BrilligInputs> inputs;
+            std::vector<Program::BrilligOutputs> outputs;
+            std::optional<Program::Expression> predicate;
+
+            friend bool operator==(const BrilligCall&, const BrilligCall&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BrilligCall bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Call {
+            uint32_t id;
+            std::vector<Program::Witness> inputs;
+            std::vector<Program::Witness> outputs;
+            std::optional<Program::Expression> predicate;
+
+            friend bool operator==(const Call&, const Call&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Call bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<AssertZero, BlackBoxFuncCall, Directive, MemoryOp, MemoryInit, BrilligCall, Call> value;
+
+        friend bool operator==(const Opcode&, const Opcode&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Opcode bincodeDeserialize(std::vector<uint8_t>);
+    };
+
     struct BinaryFieldOp {
 
         struct Add {
@@ -490,6 +629,17 @@ namespace Program {
 
     struct BlackBoxOp {
 
+        struct AES128Encrypt {
+            Program::HeapVector inputs;
+            Program::HeapArray iv;
+            Program::HeapArray key;
+            Program::HeapVector outputs;
+
+            friend bool operator==(const AES128Encrypt&, const AES128Encrypt&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static AES128Encrypt bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Sha256 {
             Program::HeapVector message;
             Program::HeapArray output;
@@ -591,14 +741,14 @@ namespace Program {
             static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct FixedBaseScalarMul {
-            Program::MemoryAddress low;
-            Program::MemoryAddress high;
-            Program::HeapArray result;
+        struct MultiScalarMul {
+            Program::HeapVector points;
+            Program::HeapVector scalars;
+            Program::HeapArray outputs;
 
-            friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
+            friend bool operator==(const MultiScalarMul&, const MultiScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
+            static MultiScalarMul bincodeDeserialize(std::vector<uint8_t>);
         };
 
         struct EmbeddedCurveAdd {
@@ -692,7 +842,7 @@ namespace Program {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        std::variant<AES128Encrypt, Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, MultiScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -922,8 +1072,7 @@ namespace Program {
         };
 
         struct Trap {
-            uint64_t revert_data_offset;
-            uint64_t revert_data_size;
+            Program::HeapArray revert_data;
 
             friend bool operator==(const Trap&, const Trap&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -946,151 +1095,54 @@ namespace Program {
         static BrilligOpcode bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct BrilligOutputs {
-
-        struct Simple {
-            Program::Witness value;
+    struct ExpressionOrMemory {
 
-            friend bool operator==(const Simple&, const Simple&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Simple bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct Array {
-            std::vector<Program::Witness> value;
+        struct Expression {
+            Program::Expression value;
 
-            friend bool operator==(const Array&, const Array&);
+            friend bool operator==(const Expression&, const Expression&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Array bincodeDeserialize(std::vector<uint8_t>);
+            static Expression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Simple, Array> value;
-
-        friend bool operator==(const BrilligOutputs&, const BrilligOutputs&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static BrilligOutputs bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct Brillig {
-        std::vector<Program::BrilligInputs> inputs;
-        std::vector<Program::BrilligOutputs> outputs;
-        std::vector<Program::BrilligOpcode> bytecode;
-        std::optional<Program::Expression> predicate;
-
-        friend bool operator==(const Brillig&, const Brillig&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static Brillig bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct Directive {
-
-        struct ToLeRadix {
-            Program::Expression a;
-            std::vector<Program::Witness> b;
-            uint32_t radix;
+        struct Memory {
+            Program::BlockId value;
 
-            friend bool operator==(const ToLeRadix&, const ToLeRadix&);
+            friend bool operator==(const Memory&, const Memory&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static ToLeRadix bincodeDeserialize(std::vector<uint8_t>);
+            static Memory bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<ToLeRadix> value;
+        std::variant<Expression, Memory> value;
 
-        friend bool operator==(const Directive&, const Directive&);
+        friend bool operator==(const ExpressionOrMemory&, const ExpressionOrMemory&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static Directive bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct MemOp {
-        Program::Expression operation;
-        Program::Expression index;
-        Program::Expression value;
-
-        friend bool operator==(const MemOp&, const MemOp&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static MemOp bincodeDeserialize(std::vector<uint8_t>);
+        static ExpressionOrMemory bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct Opcode {
-
-        struct AssertZero {
-            Program::Expression value;
+    struct AssertionPayload {
 
-            friend bool operator==(const AssertZero&, const AssertZero&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static AssertZero bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct BlackBoxFuncCall {
-            Program::BlackBoxFuncCall value;
-
-            friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static BlackBoxFuncCall bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct Directive {
-            Program::Directive value;
-
-            friend bool operator==(const Directive&, const Directive&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Directive bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct Brillig {
-            Program::Brillig value;
-
-            friend bool operator==(const Brillig&, const Brillig&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Brillig bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct MemoryOp {
-            Program::BlockId block_id;
-            Program::MemOp op;
-            std::optional<Program::Expression> predicate;
-
-            friend bool operator==(const MemoryOp&, const MemoryOp&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static MemoryOp bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct MemoryInit {
-            Program::BlockId block_id;
-            std::vector<Program::Witness> init;
-
-            friend bool operator==(const MemoryInit&, const MemoryInit&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static MemoryInit bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct BrilligCall {
-            uint32_t id;
-            std::vector<Program::BrilligInputs> inputs;
-            std::vector<Program::BrilligOutputs> outputs;
-            std::optional<Program::Expression> predicate;
+        struct StaticString {
+            std::string value;
 
-            friend bool operator==(const BrilligCall&, const BrilligCall&);
+            friend bool operator==(const StaticString&, const StaticString&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BrilligCall bincodeDeserialize(std::vector<uint8_t>);
+            static StaticString bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Call {
-            uint32_t id;
-            std::vector<Program::Witness> inputs;
-            std::vector<Program::Witness> outputs;
-            std::optional<Program::Expression> predicate;
+        struct Dynamic {
+            std::tuple<uint64_t, std::vector<Program::ExpressionOrMemory>> value;
 
-            friend bool operator==(const Call&, const Call&);
+            friend bool operator==(const Dynamic&, const Dynamic&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static Call bincodeDeserialize(std::vector<uint8_t>);
+            static Dynamic bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit, BrilligCall, Call> value;
+        std::variant<StaticString, Dynamic> value;
 
-        friend bool operator==(const Opcode&, const Opcode&);
+        friend bool operator==(const AssertionPayload&, const AssertionPayload&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static Opcode bincodeDeserialize(std::vector<uint8_t>);
+        static AssertionPayload bincodeDeserialize(std::vector<uint8_t>);
     };
 
     struct ExpressionWidth {
@@ -1157,7 +1209,7 @@ namespace Program {
         std::vector<Program::Witness> private_parameters;
         Program::PublicInputs public_parameters;
         Program::PublicInputs return_values;
-        std::vector<std::tuple<Program::OpcodeLocation, std::string>> assert_messages;
+        std::vector<std::tuple<Program::OpcodeLocation, Program::AssertionPayload>> assert_messages;
         bool recursive;
 
         friend bool operator==(const Circuit&, const Circuit&);
@@ -1185,6 +1237,124 @@ namespace Program {
 } // end of namespace Program
 
 
+namespace Program {
+
+    inline bool operator==(const AssertionPayload &lhs, const AssertionPayload &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> AssertionPayload::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<AssertionPayload>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline AssertionPayload AssertionPayload::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<AssertionPayload>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::AssertionPayload>::serialize(const Program::AssertionPayload &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::AssertionPayload serde::Deserializable<Program::AssertionPayload>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::AssertionPayload obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const AssertionPayload::StaticString &lhs, const AssertionPayload::StaticString &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> AssertionPayload::StaticString::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<AssertionPayload::StaticString>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline AssertionPayload::StaticString AssertionPayload::StaticString::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<AssertionPayload::StaticString>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::AssertionPayload::StaticString>::serialize(const Program::AssertionPayload::StaticString &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::AssertionPayload::StaticString serde::Deserializable<Program::AssertionPayload::StaticString>::deserialize(Deserializer &deserializer) {
+    Program::AssertionPayload::StaticString obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const AssertionPayload::Dynamic &lhs, const AssertionPayload::Dynamic &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> AssertionPayload::Dynamic::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<AssertionPayload::Dynamic>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline AssertionPayload::Dynamic AssertionPayload::Dynamic::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<AssertionPayload::Dynamic>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::AssertionPayload::Dynamic>::serialize(const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::AssertionPayload::Dynamic serde::Deserializable<Program::AssertionPayload::Dynamic>::deserialize(Deserializer &deserializer) {
+    Program::AssertionPayload::Dynamic obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) {
@@ -2011,6 +2181,53 @@ Program::BlackBoxFuncCall serde::Deserializable<Program::BlackBoxFuncCall>::dese
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, const BlackBoxFuncCall::AES128Encrypt &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.iv == rhs.iv)) { return false; }
+        if (!(lhs.key == rhs.key)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxFuncCall::AES128Encrypt>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxFuncCall::AES128Encrypt BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxFuncCall::AES128Encrypt>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlackBoxFuncCall::AES128Encrypt>::serialize(const Program::BlackBoxFuncCall::AES128Encrypt &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.iv)>::serialize(obj.iv, serializer);
+    serde::Serializable<decltype(obj.key)>::serialize(obj.key, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable<Program::BlackBoxFuncCall::AES128Encrypt>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::AES128Encrypt obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.iv = serde::Deserializable<decltype(obj.iv)>::deserialize(deserializer);
+    obj.key = serde::Deserializable<decltype(obj.key)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::AND &lhs, const BlackBoxFuncCall::AND &rhs) {
@@ -2500,22 +2717,22 @@ Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Program::BlackBo
 
 namespace Program {
 
-    inline bool operator==(const BlackBoxFuncCall::FixedBaseScalarMul &lhs, const BlackBoxFuncCall::FixedBaseScalarMul &rhs) {
-        if (!(lhs.low == rhs.low)) { return false; }
-        if (!(lhs.high == rhs.high)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::MultiScalarMul &lhs, const BlackBoxFuncCall::MultiScalarMul &rhs) {
+        if (!(lhs.points == rhs.points)) { return false; }
+        if (!(lhs.scalars == rhs.scalars)) { return false; }
         if (!(lhs.outputs == rhs.outputs)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxFuncCall::FixedBaseScalarMul::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::MultiScalarMul::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::FixedBaseScalarMul>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::MultiScalarMul>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxFuncCall::FixedBaseScalarMul BlackBoxFuncCall::FixedBaseScalarMul::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::MultiScalarMul BlackBoxFuncCall::MultiScalarMul::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::FixedBaseScalarMul>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::MultiScalarMul>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2526,18 +2743,18 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::BlackBoxFuncCall::FixedBaseScalarMul>::serialize(const Program::BlackBoxFuncCall::FixedBaseScalarMul &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
-    serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
+void serde::Serializable<Program::BlackBoxFuncCall::MultiScalarMul>::serialize(const Program::BlackBoxFuncCall::MultiScalarMul &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.points)>::serialize(obj.points, serializer);
+    serde::Serializable<decltype(obj.scalars)>::serialize(obj.scalars, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::BlackBoxFuncCall::FixedBaseScalarMul serde::Deserializable<Program::BlackBoxFuncCall::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxFuncCall::FixedBaseScalarMul obj;
-    obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
-    obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
+Program::BlackBoxFuncCall::MultiScalarMul serde::Deserializable<Program::BlackBoxFuncCall::MultiScalarMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::MultiScalarMul obj;
+    obj.points = serde::Deserializable<decltype(obj.points)>::deserialize(deserializer);
+    obj.scalars = serde::Deserializable<decltype(obj.scalars)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
@@ -3115,6 +3332,53 @@ Program::BlackBoxOp serde::Deserializable<Program::BlackBoxOp>::deserialize(Dese
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, const BlackBoxOp::AES128Encrypt &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.iv == rhs.iv)) { return false; }
+        if (!(lhs.key == rhs.key)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::AES128Encrypt::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::AES128Encrypt>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::AES128Encrypt BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::AES128Encrypt>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlackBoxOp::AES128Encrypt>::serialize(const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.iv)>::serialize(obj.iv, serializer);
+    serde::Serializable<decltype(obj.key)>::serialize(obj.key, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::BlackBoxOp::AES128Encrypt serde::Deserializable<Program::BlackBoxOp::AES128Encrypt>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::AES128Encrypt obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.iv = serde::Deserializable<decltype(obj.iv)>::deserialize(deserializer);
+    obj.key = serde::Deserializable<decltype(obj.key)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) {
@@ -3560,22 +3824,22 @@ Program::BlackBoxOp::PedersenHash serde::Deserializable<Program::BlackBoxOp::Ped
 
 namespace Program {
 
-    inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, const BlackBoxOp::FixedBaseScalarMul &rhs) {
-        if (!(lhs.low == rhs.low)) { return false; }
-        if (!(lhs.high == rhs.high)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
+    inline bool operator==(const BlackBoxOp::MultiScalarMul &lhs, const BlackBoxOp::MultiScalarMul &rhs) {
+        if (!(lhs.points == rhs.points)) { return false; }
+        if (!(lhs.scalars == rhs.scalars)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::FixedBaseScalarMul::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::MultiScalarMul::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::FixedBaseScalarMul>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::MultiScalarMul>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::FixedBaseScalarMul BlackBoxOp::FixedBaseScalarMul::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::MultiScalarMul BlackBoxOp::MultiScalarMul::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::FixedBaseScalarMul>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::MultiScalarMul>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3586,19 +3850,19 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::FixedBaseScalarMul>::serialize(const Program::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
-    serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Program::BlackBoxOp::MultiScalarMul>::serialize(const Program::BlackBoxOp::MultiScalarMul &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.points)>::serialize(obj.points, serializer);
+    serde::Serializable<decltype(obj.scalars)>::serialize(obj.scalars, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Program::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::FixedBaseScalarMul obj;
-    obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
-    obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+Program::BlackBoxOp::MultiScalarMul serde::Deserializable<Program::BlackBoxOp::MultiScalarMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::MultiScalarMul obj;
+    obj.points = serde::Deserializable<decltype(obj.points)>::deserialize(deserializer);
+    obj.scalars = serde::Deserializable<decltype(obj.scalars)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
@@ -4043,57 +4307,6 @@ Program::BlockId serde::Deserializable<Program::BlockId>::deserialize(Deserializ
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const Brillig &lhs, const Brillig &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.outputs == rhs.outputs)) { return false; }
-        if (!(lhs.bytecode == rhs.bytecode)) { return false; }
-        if (!(lhs.predicate == rhs.predicate)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> Brillig::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Brillig>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline Brillig Brillig::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Brillig>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::Brillig>::serialize(const Program::Brillig &obj, Serializer &serializer) {
-    serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
-    serde::Serializable<decltype(obj.bytecode)>::serialize(obj.bytecode, serializer);
-    serde::Serializable<decltype(obj.predicate)>::serialize(obj.predicate, serializer);
-    serializer.decrease_container_depth();
-}
-
-template <>
-template <typename Deserializer>
-Program::Brillig serde::Deserializable<Program::Brillig>::deserialize(Deserializer &deserializer) {
-    deserializer.increase_container_depth();
-    Program::Brillig obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
-    obj.bytecode = serde::Deserializable<decltype(obj.bytecode)>::deserialize(deserializer);
-    obj.predicate = serde::Deserializable<decltype(obj.predicate)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) {
@@ -5017,8 +5230,7 @@ Program::BrilligOpcode::BlackBox serde::Deserializable<Program::BrilligOpcode::B
 namespace Program {
 
     inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) {
-        if (!(lhs.revert_data_offset == rhs.revert_data_offset)) { return false; }
-        if (!(lhs.revert_data_size == rhs.revert_data_size)) { return false; }
+        if (!(lhs.revert_data == rhs.revert_data)) { return false; }
         return true;
     }
 
@@ -5042,16 +5254,14 @@ namespace Program {
 template <>
 template <typename Serializer>
 void serde::Serializable<Program::BrilligOpcode::Trap>::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.revert_data_offset)>::serialize(obj.revert_data_offset, serializer);
-    serde::Serializable<decltype(obj.revert_data_size)>::serialize(obj.revert_data_size, serializer);
+    serde::Serializable<decltype(obj.revert_data)>::serialize(obj.revert_data, serializer);
 }
 
 template <>
 template <typename Deserializer>
 Program::BrilligOpcode::Trap serde::Deserializable<Program::BrilligOpcode::Trap>::deserialize(Deserializer &deserializer) {
     Program::BrilligOpcode::Trap obj;
-    obj.revert_data_offset = serde::Deserializable<decltype(obj.revert_data_offset)>::deserialize(deserializer);
-    obj.revert_data_size = serde::Deserializable<decltype(obj.revert_data_size)>::deserialize(deserializer);
+    obj.revert_data = serde::Deserializable<decltype(obj.revert_data)>::deserialize(deserializer);
     return obj;
 }
 
@@ -5411,6 +5621,124 @@ Program::Expression serde::Deserializable<Program::Expression>::deserialize(Dese
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const ExpressionOrMemory &lhs, const ExpressionOrMemory &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ExpressionOrMemory::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ExpressionOrMemory>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ExpressionOrMemory ExpressionOrMemory::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ExpressionOrMemory>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::ExpressionOrMemory>::serialize(const Program::ExpressionOrMemory &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::ExpressionOrMemory serde::Deserializable<Program::ExpressionOrMemory>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::ExpressionOrMemory obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const ExpressionOrMemory::Expression &lhs, const ExpressionOrMemory::Expression &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ExpressionOrMemory::Expression::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ExpressionOrMemory::Expression>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ExpressionOrMemory::Expression ExpressionOrMemory::Expression::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ExpressionOrMemory::Expression>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::ExpressionOrMemory::Expression>::serialize(const Program::ExpressionOrMemory::Expression &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::ExpressionOrMemory::Expression serde::Deserializable<Program::ExpressionOrMemory::Expression>::deserialize(Deserializer &deserializer) {
+    Program::ExpressionOrMemory::Expression obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const ExpressionOrMemory::Memory &lhs, const ExpressionOrMemory::Memory &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ExpressionOrMemory::Memory::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ExpressionOrMemory::Memory>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ExpressionOrMemory::Memory ExpressionOrMemory::Memory::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ExpressionOrMemory::Memory>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::ExpressionOrMemory::Memory>::serialize(const Program::ExpressionOrMemory::Memory &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::ExpressionOrMemory::Memory serde::Deserializable<Program::ExpressionOrMemory::Memory>::deserialize(Deserializer &deserializer) {
+    Program::ExpressionOrMemory::Memory obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) {
@@ -6066,44 +6394,6 @@ Program::Opcode::Directive serde::Deserializable<Program::Opcode::Directive>::de
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const Opcode::Brillig &lhs, const Opcode::Brillig &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> Opcode::Brillig::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Opcode::Brillig>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline Opcode::Brillig Opcode::Brillig::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Opcode::Brillig>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::Opcode::Brillig>::serialize(const Program::Opcode::Brillig &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::Opcode::Brillig serde::Deserializable<Program::Opcode::Brillig>::deserialize(Deserializer &deserializer) {
-    Program::Opcode::Brillig obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const Opcode::MemoryOp &lhs, const Opcode::MemoryOp &rhs) {
diff --git a/acvm-repo/acir/src/circuit/black_box_functions.rs b/acvm-repo/acir/src/circuit/black_box_functions.rs
index 0a7ee244a5e..33c14436c85 100644
--- a/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -9,6 +9,8 @@ use strum_macros::EnumIter;
 #[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[cfg_attr(test, derive(EnumIter))]
 pub enum BlackBoxFunc {
+    /// Encrypts the input using AES128.
+    AES128Encrypt,
     /// Bitwise AND.
     AND,
     /// Bitwise XOR.
@@ -36,8 +38,8 @@ pub enum BlackBoxFunc {
     EcdsaSecp256k1,
     /// Verifies a ECDSA signature over the secp256r1 curve.
     EcdsaSecp256r1,
-    /// Performs scalar multiplication over the embedded curve on which [`FieldElement`][acir_field::FieldElement] is defined.
-    FixedBaseScalarMul,
+    /// Performs multi scalar multiplication over the embedded curve.
+    MultiScalarMul,
     /// Calculates the Keccak256 hash of the inputs.
     Keccak256,
     /// Keccak Permutation function of 1600 width
@@ -74,6 +76,7 @@ impl std::fmt::Display for BlackBoxFunc {
 impl BlackBoxFunc {
     pub fn name(&self) -> &'static str {
         match self {
+            BlackBoxFunc::AES128Encrypt => "aes128_encrypt",
             BlackBoxFunc::SHA256 => "sha256",
             BlackBoxFunc::SchnorrVerify => "schnorr_verify",
             BlackBoxFunc::Blake2s => "blake2s",
@@ -81,7 +84,7 @@ impl BlackBoxFunc {
             BlackBoxFunc::PedersenCommitment => "pedersen_commitment",
             BlackBoxFunc::PedersenHash => "pedersen_hash",
             BlackBoxFunc::EcdsaSecp256k1 => "ecdsa_secp256k1",
-            BlackBoxFunc::FixedBaseScalarMul => "fixed_base_scalar_mul",
+            BlackBoxFunc::MultiScalarMul => "multi_scalar_mul",
             BlackBoxFunc::EmbeddedCurveAdd => "embedded_curve_add",
             BlackBoxFunc::AND => "and",
             BlackBoxFunc::XOR => "xor",
@@ -103,6 +106,7 @@ impl BlackBoxFunc {
 
     pub fn lookup(op_name: &str) -> Option<BlackBoxFunc> {
         match op_name {
+            "aes128_encrypt" => Some(BlackBoxFunc::AES128Encrypt),
             "sha256" => Some(BlackBoxFunc::SHA256),
             "schnorr_verify" => Some(BlackBoxFunc::SchnorrVerify),
             "blake2s" => Some(BlackBoxFunc::Blake2s),
@@ -111,7 +115,7 @@ impl BlackBoxFunc {
             "pedersen_hash" => Some(BlackBoxFunc::PedersenHash),
             "ecdsa_secp256k1" => Some(BlackBoxFunc::EcdsaSecp256k1),
             "ecdsa_secp256r1" => Some(BlackBoxFunc::EcdsaSecp256r1),
-            "fixed_base_scalar_mul" => Some(BlackBoxFunc::FixedBaseScalarMul),
+            "multi_scalar_mul" => Some(BlackBoxFunc::MultiScalarMul),
             "embedded_curve_add" => Some(BlackBoxFunc::EmbeddedCurveAdd),
             "and" => Some(BlackBoxFunc::AND),
             "xor" => Some(BlackBoxFunc::XOR),
diff --git a/acvm-repo/acir/src/circuit/brillig.rs b/acvm-repo/acir/src/circuit/brillig.rs
index 7f87aabf9d5..ecf6f7a9761 100644
--- a/acvm-repo/acir/src/circuit/brillig.rs
+++ b/acvm-repo/acir/src/circuit/brillig.rs
@@ -20,16 +20,6 @@ pub enum BrilligOutputs {
     Array(Vec<Witness>),
 }
 
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub struct Brillig {
-    pub inputs: Vec<BrilligInputs>,
-    pub outputs: Vec<BrilligOutputs>,
-    /// The Brillig VM bytecode to be executed by this ACIR opcode.
-    pub bytecode: Vec<BrilligOpcode>,
-    /// Predicate of the Brillig execution - indicates if it should be skipped
-    pub predicate: Option<Expression>,
-}
-
 /// This is purely a wrapper struct around a list of Brillig opcode's which represents
 /// a full Brillig function to be executed by the Brillig VM.
 /// This is stored separately on a program and accessed through a [BrilligPointer].
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index d655d136bc8..6a26a45d88b 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -3,7 +3,8 @@ pub mod brillig;
 pub mod directives;
 pub mod opcodes;
 
-use crate::native_types::Witness;
+use crate::native_types::{Expression, Witness};
+use acir_field::FieldElement;
 pub use opcodes::Opcode;
 use thiserror::Error;
 
@@ -15,7 +16,7 @@ use serde::{de::Error as DeserializationError, Deserialize, Deserializer, Serial
 
 use std::collections::BTreeSet;
 
-use self::brillig::BrilligBytecode;
+use self::{brillig::BrilligBytecode, opcodes::BlockId};
 
 /// Specifies the maximum width of the expressions which will be constrained.
 ///
@@ -59,18 +60,14 @@ pub struct Circuit {
     pub public_parameters: PublicInputs,
     /// The set of public inputs calculated within the circuit.
     pub return_values: PublicInputs,
-    /// Maps opcode locations to failed assertion messages.
-    /// These messages are embedded in the circuit to provide useful feedback to users
+    /// Maps opcode locations to failed assertion payloads.
+    /// The data in the payload is embedded in the circuit to provide useful feedback to users
     /// when a constraint in the circuit is not satisfied.
     ///
     // Note: This should be a BTreeMap, but serde-reflect is creating invalid
     // c++ code at the moment when it is, due to OpcodeLocation needing a comparison
     // implementation which is never generated.
-    //
-    // TODO: These are only used for constraints that are explicitly created during code generation (such as index out of bounds on slices)
-    // TODO: We should move towards having all the checks being evaluated in the same manner
-    // TODO: as runtime assert messages specified by the user. This will also be a breaking change as the `Circuit` structure will change.
-    pub assert_messages: Vec<(OpcodeLocation, String)>,
+    pub assert_messages: Vec<(OpcodeLocation, AssertionPayload)>,
 
     /// States whether the backend should use a SNARK recursion friendly prover.
     /// If implemented by a backend, this means that proofs generated with this circuit
@@ -78,15 +75,67 @@ pub struct Circuit {
     pub recursive: bool,
 }
 
-impl Circuit {
-    /// Returns the assert message associated with the provided [`OpcodeLocation`].
-    /// Returns `None` if no such assert message exists.
-    pub fn get_assert_message(&self, opcode_location: OpcodeLocation) -> Option<&str> {
-        self.assert_messages
-            .iter()
-            .find(|(loc, _)| *loc == opcode_location)
-            .map(|(_, message)| message.as_str())
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ExpressionOrMemory {
+    Expression(Expression),
+    Memory(BlockId),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AssertionPayload {
+    StaticString(String),
+    Dynamic(/* error_selector */ u64, Vec<ExpressionOrMemory>),
+}
+
+#[derive(Debug, Copy, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
+pub struct ErrorSelector(u64);
+
+impl ErrorSelector {
+    pub fn new(integer: u64) -> Self {
+        ErrorSelector(integer)
     }
+
+    pub fn as_u64(&self) -> u64 {
+        self.0
+    }
+}
+
+impl Serialize for ErrorSelector {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.0.to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for ErrorSelector {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: String = Deserialize::deserialize(deserializer)?;
+        let as_u64 = s.parse().map_err(serde::de::Error::custom)?;
+        Ok(ErrorSelector(as_u64))
+    }
+}
+
+/// This selector indicates that the payload is a string.
+/// This is used to parse any error with a string payload directly,
+/// to avoid users having to parse the error externally to the ACVM.
+/// Only non-string errors need to be parsed externally to the ACVM using the circuit ABI.
+pub const STRING_ERROR_SELECTOR: ErrorSelector = ErrorSelector(0);
+
+#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub struct RawAssertionPayload {
+    pub selector: ErrorSelector,
+    pub data: Vec<FieldElement>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ResolvedAssertionPayload {
+    String(String),
+    Raw(RawAssertionPayload),
 }
 
 #[derive(Debug, Copy, Clone)]
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index b0b8e286e0c..7db317c41ab 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -1,5 +1,5 @@
 use super::{
-    brillig::{Brillig, BrilligInputs, BrilligOutputs},
+    brillig::{BrilligInputs, BrilligOutputs},
     directives::Directive,
 };
 use crate::native_types::{Expression, Witness};
@@ -20,7 +20,6 @@ pub enum Opcode {
     /// Often used for exposing more efficient implementations of SNARK-unfriendly computations.  
     BlackBoxFuncCall(BlackBoxFuncCall),
     Directive(Directive),
-    Brillig(Brillig),
     /// Atomic operation on a block of memory
     MemoryOp {
         block_id: BlockId,
@@ -88,12 +87,6 @@ impl std::fmt::Display for Opcode {
                     b.last().unwrap().witness_index(),
                 )
             }
-            Opcode::Brillig(brillig) => {
-                write!(f, "BRILLIG: ")?;
-                writeln!(f, "inputs: {:?}", brillig.inputs)?;
-                writeln!(f, "outputs: {:?}", brillig.outputs)?;
-                writeln!(f, "{:?}", brillig.bytecode)
-            }
             Opcode::MemoryOp { block_id, op, predicate } => {
                 write!(f, "MEM ")?;
                 if let Some(pred) = predicate {
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 405cd0cef00..115a33c1c9d 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -12,6 +12,12 @@ pub struct FunctionInput {
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlackBoxFuncCall {
+    AES128Encrypt {
+        inputs: Vec<FunctionInput>,
+        iv: Box<[FunctionInput; 16]>,
+        key: Box<[FunctionInput; 16]>,
+        outputs: Vec<Witness>,
+    },
     AND {
         lhs: FunctionInput,
         rhs: FunctionInput,
@@ -80,9 +86,9 @@ pub enum BlackBoxFuncCall {
         hashed_message: Box<[FunctionInput; 32]>,
         output: Witness,
     },
-    FixedBaseScalarMul {
-        low: FunctionInput,
-        high: FunctionInput,
+    MultiScalarMul {
+        points: Vec<FunctionInput>,
+        scalars: Vec<FunctionInput>,
         outputs: (Witness, Witness),
     },
     EmbeddedCurveAdd {
@@ -177,6 +183,7 @@ pub enum BlackBoxFuncCall {
 impl BlackBoxFuncCall {
     pub fn get_black_box_func(&self) -> BlackBoxFunc {
         match self {
+            BlackBoxFuncCall::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt,
             BlackBoxFuncCall::AND { .. } => BlackBoxFunc::AND,
             BlackBoxFuncCall::XOR { .. } => BlackBoxFunc::XOR,
             BlackBoxFuncCall::RANGE { .. } => BlackBoxFunc::RANGE,
@@ -188,7 +195,7 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
             BlackBoxFuncCall::EcdsaSecp256k1 { .. } => BlackBoxFunc::EcdsaSecp256k1,
             BlackBoxFuncCall::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
-            BlackBoxFuncCall::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
+            BlackBoxFuncCall::MultiScalarMul { .. } => BlackBoxFunc::MultiScalarMul,
             BlackBoxFuncCall::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
             BlackBoxFuncCall::Keccak256 { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
@@ -210,7 +217,8 @@ impl BlackBoxFuncCall {
 
     pub fn get_inputs_vec(&self) -> Vec<FunctionInput> {
         match self {
-            BlackBoxFuncCall::SHA256 { inputs, .. }
+            BlackBoxFuncCall::AES128Encrypt { inputs, .. }
+            | BlackBoxFuncCall::SHA256 { inputs, .. }
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
@@ -231,7 +239,12 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::BigIntMul { .. }
             | BlackBoxFuncCall::BigIntDiv { .. }
             | BlackBoxFuncCall::BigIntToLeBytes { .. } => Vec::new(),
-            BlackBoxFuncCall::FixedBaseScalarMul { low, high, .. } => vec![*low, *high],
+            BlackBoxFuncCall::MultiScalarMul { points, scalars, .. } => {
+                let mut inputs: Vec<FunctionInput> = Vec::with_capacity(points.len() * 2);
+                inputs.extend(points.iter().copied());
+                inputs.extend(scalars.iter().copied());
+                inputs
+            }
             BlackBoxFuncCall::EmbeddedCurveAdd {
                 input1_x, input1_y, input2_x, input2_y, ..
             } => vec![*input1_x, *input1_y, *input2_x, *input2_y],
@@ -243,7 +256,8 @@ impl BlackBoxFuncCall {
                 message,
                 ..
             } => {
-                let mut inputs = Vec::with_capacity(2 + signature.len() + message.len());
+                let mut inputs: Vec<FunctionInput> =
+                    Vec::with_capacity(2 + signature.len() + message.len());
                 inputs.push(*public_key_x);
                 inputs.push(*public_key_y);
                 inputs.extend(signature.iter().copied());
@@ -320,7 +334,8 @@ impl BlackBoxFuncCall {
 
             BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(),
 
-            BlackBoxFuncCall::Poseidon2Permutation { outputs, .. } => outputs.to_vec(),
+            BlackBoxFuncCall::AES128Encrypt { outputs, .. }
+            | BlackBoxFuncCall::Poseidon2Permutation { outputs, .. } => outputs.to_vec(),
 
             BlackBoxFuncCall::AND { output, .. }
             | BlackBoxFuncCall::XOR { output, .. }
@@ -328,7 +343,7 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
             | BlackBoxFuncCall::PedersenHash { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
-            BlackBoxFuncCall::FixedBaseScalarMul { outputs, .. }
+            BlackBoxFuncCall::MultiScalarMul { outputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { outputs, .. }
             | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => vec![outputs.0, outputs.1],
             BlackBoxFuncCall::RANGE { .. }
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index d14159f34a1..24f27aae06f 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -42,7 +42,8 @@ mod reflection {
             brillig::{BrilligInputs, BrilligOutputs},
             directives::Directive,
             opcodes::BlackBoxFuncCall,
-            Circuit, ExpressionWidth, Opcode, OpcodeLocation, Program,
+            AssertionPayload, Circuit, ExpressionOrMemory, ExpressionWidth, Opcode, OpcodeLocation,
+            Program,
         },
         native_types::{Witness, WitnessMap, WitnessStack},
     };
@@ -74,6 +75,8 @@ mod reflection {
         tracer.trace_simple_type::<Directive>().unwrap();
         tracer.trace_simple_type::<ValueOrArray>().unwrap();
         tracer.trace_simple_type::<HeapValueType>().unwrap();
+        tracer.trace_simple_type::<AssertionPayload>().unwrap();
+        tracer.trace_simple_type::<ExpressionOrMemory>().unwrap();
 
         let registry = tracer.registry().unwrap();
 
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index fb924a7437d..d9327f784e6 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -13,7 +13,7 @@ use std::collections::BTreeSet;
 
 use acir::{
     circuit::{
-        brillig::{Brillig, BrilligInputs, BrilligOutputs},
+        brillig::{BrilligBytecode, BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, BlockId, FunctionInput, MemOp},
         Circuit, Opcode, Program, PublicInputs,
     },
@@ -58,18 +58,24 @@ fn addition_circuit() {
 }
 
 #[test]
-fn fixed_base_scalar_mul_circuit() {
-    let fixed_base_scalar_mul = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::FixedBaseScalarMul {
-        low: FunctionInput { witness: Witness(1), num_bits: 128 },
-        high: FunctionInput { witness: Witness(2), num_bits: 128 },
-        outputs: (Witness(3), Witness(4)),
+fn multi_scalar_mul_circuit() {
+    let multi_scalar_mul = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::MultiScalarMul {
+        points: vec![
+            FunctionInput { witness: Witness(1), num_bits: 128 },
+            FunctionInput { witness: Witness(2), num_bits: 128 },
+        ],
+        scalars: vec![
+            FunctionInput { witness: Witness(3), num_bits: 128 },
+            FunctionInput { witness: Witness(4), num_bits: 128 },
+        ],
+        outputs: (Witness(5), Witness(6)),
     });
 
     let circuit = Circuit {
-        current_witness_index: 5,
-        opcodes: vec![fixed_base_scalar_mul],
-        private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
-        return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(3), Witness(4)])),
+        current_witness_index: 7,
+        opcodes: vec![multi_scalar_mul],
+        private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3), Witness(4)]),
+        return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(5), Witness(6)])),
         ..Circuit::default()
     };
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
@@ -77,9 +83,10 @@ fn fixed_base_scalar_mul_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233,
-        29, 61, 35, 3, 19, 228, 137, 60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135,
-        142, 139, 219, 91, 127, 117, 71, 2, 117, 84, 50, 98, 113, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 76, 65, 14, 0, 32, 8, 82, 179, 186, 244, 104, 159,
+        30, 45, 218, 136, 141, 33, 40, 186, 93, 76, 208, 57, 31, 93, 96, 136, 47, 250, 146, 188,
+        209, 39, 181, 131, 131, 187, 148, 110, 240, 246, 101, 38, 63, 180, 243, 97, 3, 125, 173,
+        118, 131, 153, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -105,11 +112,10 @@ fn pedersen_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 9, 10, 0, 0, 4, 115, 149, 255, 127, 88, 8, 133,
-        213, 218, 137, 80, 144, 32, 182, 79, 213, 151, 173, 61, 5, 121, 245, 91, 103, 255, 191, 3,
-        7, 16, 26, 112, 158, 113, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 73, 10, 0, 0, 4, 180, 29, 252, 255, 193, 66, 40,
+        76, 77, 179, 34, 20, 36, 136, 237, 83, 245, 101, 107, 79, 65, 94, 253, 214, 217, 255, 239,
+        192, 1, 43, 124, 181, 238, 113, 0, 0, 0,
     ];
-
     assert_eq!(bytes, expected_serialization)
 }
 
@@ -152,7 +158,7 @@ fn schnorr_verify_circuit() {
     let expected_serialization: Vec<u8> = vec![
         31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 210, 85, 78, 67, 81, 24, 133, 209, 226, 238, 238,
         238, 238, 238, 165, 148, 82, 102, 193, 252, 135, 64, 232, 78, 87, 147, 114, 147, 147, 5,
-        47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241, 115, 236, 228, 111, 237, 181,
+        47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241, 115, 236, 226, 111, 237, 181,
         178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 135, 189, 236, 99, 63, 7, 56,
         200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60,
         23, 184, 200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187,
@@ -164,8 +170,8 @@ fn schnorr_verify_circuit() {
         180, 144, 14, 210, 64, 246, 95, 46, 212, 119, 207, 230, 217, 59, 91, 103, 231, 108, 156,
         125, 183, 237, 186, 107, 207, 125, 59, 30, 218, 239, 216, 110, 167, 246, 58, 183, 211, 165,
         125, 174, 237, 114, 107, 143, 123, 59, 60, 186, 255, 179, 187, 191, 186, 115, 209, 125, 75,
-        238, 90, 118, 207, 138, 59, 54, 110, 214, 184, 91, 161, 233, 158, 255, 190, 63, 165, 188,
-        93, 151, 233, 3, 0, 0,
+        238, 90, 118, 207, 138, 59, 54, 110, 214, 184, 91, 161, 233, 158, 255, 190, 63, 71, 59, 68,
+        130, 233, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -176,14 +182,7 @@ fn simple_brillig_foreign_call() {
     let w_input = Witness(1);
     let w_inverted = Witness(2);
 
-    let brillig_data = Brillig {
-        inputs: vec![
-            BrilligInputs::Single(w_input.into()), // Input Register 0,
-        ],
-        // This tells the BrilligSolver which witnesses its output values correspond to
-        outputs: vec![
-            BrilligOutputs::Simple(w_inverted), // Output Register 1
-        ],
+    let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             brillig::Opcode::CalldataCopy {
                 destination_address: MemoryAddress(0),
@@ -199,27 +198,38 @@ fn simple_brillig_foreign_call() {
             },
             brillig::Opcode::Stop { return_data_offset: 0, return_data_size: 1 },
         ],
-        predicate: None,
     };
 
-    let opcodes = vec![Opcode::Brillig(brillig_data)];
+    let opcodes = vec![Opcode::BrilligCall {
+        id: 0,
+        inputs: vec![
+            BrilligInputs::Single(w_input.into()), // Input Register 0,
+        ],
+        // This tells the BrilligSolver which witnesses its output values correspond to
+        outputs: vec![
+            BrilligOutputs::Simple(w_inverted), // Output Register 1
+        ],
+        predicate: None,
+    }];
+
     let circuit = Circuit {
         current_witness_index: 8,
         opcodes,
         private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
+    let program =
+        Program { functions: vec![circuit], unconstrained_functions: vec![brillig_bytecode] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 32, 12, 133, 19, 11, 165, 116,
-        235, 77, 236, 13, 122, 153, 14, 93, 58, 136, 120, 124, 241, 47, 129, 12, 42, 130, 126, 16,
-        18, 146, 16, 222, 11, 66, 225, 136, 129, 84, 111, 162, 150, 112, 239, 161, 172, 231, 184,
-        113, 221, 45, 45, 245, 42, 242, 144, 216, 43, 250, 153, 83, 204, 191, 223, 189, 198, 246,
-        92, 39, 60, 244, 63, 195, 59, 87, 99, 150, 165, 113, 83, 193, 0, 1, 19, 247, 29, 5, 160, 1,
-        0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 193, 10, 192, 32, 8, 134, 117, 99, 99, 236,
+        182, 55, 105, 111, 176, 151, 217, 161, 75, 135, 136, 30, 63, 42, 82, 144, 8, 47, 245, 65,
+        252, 230, 47, 162, 34, 52, 174, 242, 144, 226, 131, 148, 255, 18, 206, 125, 164, 102, 142,
+        23, 215, 245, 50, 114, 222, 173, 15, 80, 38, 65, 217, 108, 39, 61, 7, 30, 115, 11, 223,
+        186, 248, 251, 160, 221, 170, 146, 64, 191, 39, 215, 60, 3, 47, 3, 99, 171, 188, 84, 164,
+        1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -239,27 +249,7 @@ fn complex_brillig_foreign_call() {
     let a_plus_b_plus_c = Witness(7);
     let a_plus_b_plus_c_times_2 = Witness(8);
 
-    let brillig_data = Brillig {
-        inputs: vec![
-            // Input 0,1,2
-            BrilligInputs::Array(vec![
-                Expression::from(a),
-                Expression::from(b),
-                Expression::from(c),
-            ]),
-            // Input 3
-            BrilligInputs::Single(Expression {
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, a), (fe_1, b), (fe_1, c)],
-                q_c: fe_0,
-            }),
-        ],
-        // This tells the BrilligSolver which witnesses its output values correspond to
-        outputs: vec![
-            BrilligOutputs::Array(vec![a_times_2, b_times_3, c_times_4]), // Output 0,1,2
-            BrilligOutputs::Simple(a_plus_b_plus_c),                      // Output 3
-            BrilligOutputs::Simple(a_plus_b_plus_c_times_2),              // Output 4
-        ],
+    let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             brillig::Opcode::CalldataCopy {
                 destination_address: MemoryAddress(32),
@@ -300,30 +290,54 @@ fn complex_brillig_foreign_call() {
             },
             brillig::Opcode::Stop { return_data_offset: 32, return_data_size: 5 },
         ],
-        predicate: None,
     };
 
-    let opcodes = vec![Opcode::Brillig(brillig_data)];
+    let opcodes = vec![Opcode::BrilligCall {
+        id: 0,
+        inputs: vec![
+            // Input 0,1,2
+            BrilligInputs::Array(vec![
+                Expression::from(a),
+                Expression::from(b),
+                Expression::from(c),
+            ]),
+            // Input 3
+            BrilligInputs::Single(Expression {
+                mul_terms: vec![],
+                linear_combinations: vec![(fe_1, a), (fe_1, b), (fe_1, c)],
+                q_c: fe_0,
+            }),
+        ],
+        // This tells the BrilligSolver which witnesses its output values correspond to
+        outputs: vec![
+            BrilligOutputs::Array(vec![a_times_2, b_times_3, c_times_4]), // Output 0,1,2
+            BrilligOutputs::Simple(a_plus_b_plus_c),                      // Output 3
+            BrilligOutputs::Simple(a_plus_b_plus_c_times_2),              // Output 4
+        ],
+        predicate: None,
+    }];
+
     let circuit = Circuit {
         current_witness_index: 8,
         opcodes,
         private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3)]),
         ..Circuit::default()
     };
-    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
+    let program =
+        Program { functions: vec![circuit], unconstrained_functions: vec![brillig_bytecode] };
 
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 218, 209, 145, 217,
-        205, 13, 6, 198, 3, 84, 79, 224, 93, 196, 157, 162, 75, 79, 47, 22, 124, 197, 16, 186, 17,
-        43, 104, 32, 36, 109, 126, 143, 36, 45, 211, 70, 133, 103, 134, 110, 61, 27, 232, 140, 179,
-        164, 224, 215, 64, 186, 115, 84, 113, 186, 92, 238, 42, 140, 230, 1, 24, 237, 5, 24, 195,
-        62, 220, 116, 222, 41, 231, 146, 180, 127, 54, 242, 126, 94, 158, 51, 207, 57, 206, 111,
-        200, 2, 247, 4, 219, 79, 245, 157, 132, 31, 137, 89, 52, 73, 176, 214, 46, 167, 125, 23,
-        89, 213, 254, 8, 156, 237, 56, 76, 125, 55, 91, 229, 170, 161, 254, 133, 94, 42, 59, 171,
-        184, 69, 197, 46, 66, 202, 47, 40, 86, 39, 220, 155, 3, 185, 191, 180, 183, 55, 163, 72,
-        98, 70, 66, 221, 251, 40, 173, 255, 35, 68, 62, 61, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 131, 64, 12, 77, 102, 90, 43, 221, 245,
+        6, 133, 246, 0, 211, 158, 192, 187, 136, 59, 69, 151, 158, 94, 116, 48, 131, 241, 233, 70,
+        28, 65, 3, 195, 155, 79, 62, 47, 9, 25, 166, 81, 210, 97, 177, 236, 239, 130, 70, 208, 223,
+        91, 154, 75, 208, 205, 4, 221, 62, 249, 113, 60, 95, 238, 40, 142, 230, 2, 28, 237, 1, 28,
+        73, 245, 255, 132, 253, 142, 217, 151, 168, 245, 179, 43, 243, 115, 163, 113, 190, 18, 57,
+        63, 4, 83, 44, 180, 55, 50, 180, 28, 188, 153, 224, 196, 122, 175, 111, 112, 68, 24, 65,
+        50, 204, 162, 100, 249, 119, 137, 226, 193, 16, 251, 169, 50, 204, 235, 170, 41, 139, 214,
+        130, 42, 82, 253, 168, 253, 23, 222, 25, 236, 58, 176, 237, 20, 234, 207, 107, 45, 78, 184,
+        55, 27, 124, 191, 104, 42, 111, 40, 121, 15, 94, 163, 77, 128, 65, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -357,11 +371,11 @@ fn memory_op_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 57, 14, 0, 32, 8, 147, 195, 255, 224, 15, 252,
-        255, 171, 212, 200, 208, 129, 77, 24, 108, 66, 90, 150, 166, 20, 106, 23, 125, 143, 128,
-        62, 96, 103, 114, 173, 45, 198, 116, 182, 55, 140, 106, 95, 74, 246, 149, 60, 47, 171, 46,
-        215, 126, 43, 87, 179, 111, 23, 8, 202, 176, 99, 248, 240, 9, 11, 137, 33, 212, 110, 35, 3,
-        0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 203, 180, 255, 216, 15, 250,
+        255, 171, 10, 154, 16, 210, 45, 61, 52, 144, 13, 132, 49, 135, 84, 54, 218, 26, 134, 22,
+        112, 5, 19, 180, 237, 61, 6, 88, 223, 208, 179, 125, 41, 216, 151, 227, 188, 52, 187, 92,
+        253, 173, 92, 137, 190, 157, 143, 160, 254, 155, 45, 188, 148, 11, 38, 213, 237, 188, 16,
+        35, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -460,15 +474,15 @@ fn nested_acir_call_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 65, 10, 3, 33, 12, 69, 163, 46, 230, 58, 137,
-        209, 49, 238, 122, 149, 74, 157, 251, 31, 161, 83, 154, 161, 86, 132, 89, 212, 194, 124,
-        248, 24, 36, 132, 228, 241, 29, 188, 229, 212, 47, 45, 187, 205, 110, 11, 31, 25, 53, 28,
-        255, 103, 77, 14, 58, 29, 141, 55, 125, 241, 55, 145, 109, 102, 49, 174, 33, 212, 228, 43,
-        49, 221, 209, 231, 34, 17, 67, 44, 171, 144, 80, 148, 248, 240, 194, 92, 37, 72, 202, 37,
-        39, 204, 20, 184, 210, 22, 51, 111, 58, 204, 205, 219, 11, 161, 129, 208, 214, 6, 6, 114,
-        29, 193, 127, 193, 130, 137, 176, 236, 188, 189, 252, 162, 183, 218, 230, 238, 97, 138,
-        250, 152, 245, 245, 87, 220, 12, 140, 113, 95, 153, 170, 129, 185, 17, 60, 3, 54, 212, 19,
-        104, 145, 195, 151, 14, 4, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147,
+        24, 173, 241, 223, 174, 50, 153, 189, 255, 17, 214, 177, 148, 57, 17, 250, 99, 14, 250,
+        224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 217, 109, 118, 91, 248, 200, 168,
+        225, 248, 63, 107, 114, 208, 233, 104, 188, 233, 139, 191, 137, 108, 51, 139, 113, 13, 161,
+        38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42, 65,
+        82, 46, 57, 97, 166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182, 54,
+        48, 144, 235, 8, 254, 11, 22, 76, 132, 101, 231, 237, 229, 23, 189, 213, 54, 119, 15, 83,
+        212, 199, 172, 175, 191, 226, 102, 96, 140, 251, 202, 84, 13, 204, 141, 224, 25, 176, 161,
+        158, 53, 121, 144, 73, 14, 4, 0, 0,
     ];
     assert_eq!(bytes, expected_serialization);
 }
diff --git a/acvm-repo/acvm/src/compiler/mod.rs b/acvm-repo/acvm/src/compiler/mod.rs
index 6543c70958b..436db648ea8 100644
--- a/acvm-repo/acvm/src/compiler/mod.rs
+++ b/acvm-repo/acvm/src/compiler/mod.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use acir::circuit::{Circuit, ExpressionWidth, OpcodeLocation};
+use acir::circuit::{AssertionPayload, Circuit, ExpressionWidth, OpcodeLocation};
 
 // The various passes that we can use over ACIR
 mod optimizers;
@@ -54,9 +54,9 @@ impl AcirTransformationMap {
 }
 
 fn transform_assert_messages(
-    assert_messages: Vec<(OpcodeLocation, String)>,
+    assert_messages: Vec<(OpcodeLocation, AssertionPayload)>,
     map: &AcirTransformationMap,
-) -> Vec<(OpcodeLocation, String)> {
+) -> Vec<(OpcodeLocation, AssertionPayload)> {
     assert_messages
         .into_iter()
         .flat_map(|(location, message)| {
diff --git a/acvm-repo/acvm/src/compiler/optimizers/mod.rs b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
index 04d3f99a408..dfe348d4ff5 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
@@ -32,7 +32,7 @@ pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
     // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
     let acir_opcode_positions = (0..acir.opcodes.len()).collect();
 
-    if acir.opcodes.len() == 1 && matches!(acir.opcodes[0], Opcode::Brillig(_)) {
+    if acir.opcodes.len() == 1 && matches!(acir.opcodes[0], Opcode::BrilligCall { .. }) {
         info!("Program is fully unconstrained, skipping optimization pass");
         return (acir, acir_opcode_positions);
     }
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index d13fac1672a..0099519e4b6 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -128,20 +128,6 @@ pub(super) fn transform_internal(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
-            Opcode::Brillig(ref brillig) => {
-                for output in &brillig.outputs {
-                    match output {
-                        BrilligOutputs::Simple(w) => transformer.mark_solvable(*w),
-                        BrilligOutputs::Array(v) => {
-                            for witness in v {
-                                transformer.mark_solvable(*witness);
-                            }
-                        }
-                    }
-                }
-                new_acir_opcode_positions.push(acir_opcode_positions[index]);
-                transformed_opcodes.push(opcode);
-            }
             Opcode::BrilligCall { ref outputs, .. } => {
                 for output in outputs {
                     match output {
diff --git a/acvm-repo/acvm/src/pwg/arithmetic.rs b/acvm-repo/acvm/src/pwg/arithmetic.rs
index dc9e13d44b6..b971e4a0efb 100644
--- a/acvm-repo/acvm/src/pwg/arithmetic.rs
+++ b/acvm-repo/acvm/src/pwg/arithmetic.rs
@@ -53,6 +53,7 @@ impl ExpressionSolver {
                         if !total_sum.is_zero() {
                             Err(OpcodeResolutionError::UnsatisfiedConstrain {
                                 opcode_location: ErrorLocation::Unresolved,
+                                payload: None,
                             })
                         } else {
                             Ok(())
@@ -81,6 +82,7 @@ impl ExpressionSolver {
                     if !total_sum.is_zero() {
                         Err(OpcodeResolutionError::UnsatisfiedConstrain {
                             opcode_location: ErrorLocation::Unresolved,
+                            payload: None,
                         })
                     } else {
                         Ok(())
@@ -96,6 +98,7 @@ impl ExpressionSolver {
                 if !(a + b + opcode.q_c).is_zero() {
                     Err(OpcodeResolutionError::UnsatisfiedConstrain {
                         opcode_location: ErrorLocation::Unresolved,
+                        payload: None,
                     })
                 } else {
                     Ok(())
@@ -113,6 +116,7 @@ impl ExpressionSolver {
                     if !total_sum.is_zero() {
                         Err(OpcodeResolutionError::UnsatisfiedConstrain {
                             opcode_location: ErrorLocation::Unresolved,
+                            payload: None,
                         })
                     } else {
                         Ok(())
diff --git a/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/acvm-repo/acvm/src/pwg/blackbox/aes128.rs
new file mode 100644
index 00000000000..c02c59a174f
--- /dev/null
+++ b/acvm-repo/acvm/src/pwg/blackbox/aes128.rs
@@ -0,0 +1,32 @@
+use acir::{
+    circuit::opcodes::FunctionInput,
+    native_types::{Witness, WitnessMap},
+    FieldElement,
+};
+use acvm_blackbox_solver::aes128_encrypt;
+
+use crate::{pwg::insert_value, OpcodeResolutionError};
+
+use super::utils::{to_u8_array, to_u8_vec};
+
+pub(super) fn solve_aes128_encryption_opcode(
+    initial_witness: &mut WitnessMap,
+    inputs: &[FunctionInput],
+    iv: &[FunctionInput; 16],
+    key: &[FunctionInput; 16],
+    outputs: &[Witness],
+) -> Result<(), OpcodeResolutionError> {
+    let scalars = to_u8_vec(initial_witness, inputs)?;
+
+    let iv = to_u8_array(initial_witness, iv)?;
+    let key = to_u8_array(initial_witness, key)?;
+
+    let ciphertext = aes128_encrypt(&scalars, iv, key)?;
+
+    // Write witness assignments
+    for (output_witness, value) in outputs.iter().zip(ciphertext.into_iter()) {
+        insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?;
+    }
+
+    Ok(())
+}
diff --git a/acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs b/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
similarity index 60%
rename from acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs
rename to acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
index c5bfd1d5646..ee35385fa81 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
@@ -6,20 +6,27 @@ use acvm_blackbox_solver::BlackBoxFunctionSolver;
 
 use crate::pwg::{insert_value, witness_to_value, OpcodeResolutionError};
 
-pub(super) fn fixed_base_scalar_mul(
+pub(super) fn multi_scalar_mul(
     backend: &impl BlackBoxFunctionSolver,
     initial_witness: &mut WitnessMap,
-    low: FunctionInput,
-    high: FunctionInput,
+    points: &[FunctionInput],
+    scalars: &[FunctionInput],
     outputs: (Witness, Witness),
 ) -> Result<(), OpcodeResolutionError> {
-    let low = witness_to_value(initial_witness, low.witness)?;
-    let high = witness_to_value(initial_witness, high.witness)?;
+    let points: Result<Vec<_>, _> =
+        points.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
+    let points: Vec<_> = points?.into_iter().cloned().collect();
 
-    let (pub_x, pub_y) = backend.fixed_base_scalar_mul(low, high)?;
+    let scalars: Result<Vec<_>, _> =
+        scalars.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
+    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
 
-    insert_value(&outputs.0, pub_x, initial_witness)?;
-    insert_value(&outputs.1, pub_y, initial_witness)?;
+    // Call the backend's multi-scalar multiplication function
+    let (res_x, res_y) = backend.multi_scalar_mul(&points, &scalars)?;
+
+    // Insert the resulting point into the witness map
+    insert_value(&outputs.0, res_x, initial_witness)?;
+    insert_value(&outputs.1, res_y, initial_witness)?;
 
     Ok(())
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 2753c7baaaa..a74f44b79dc 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -6,21 +6,24 @@ use acir::{
 use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256};
 
 use self::{
-    bigint::AcvmBigIntSolver, hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash,
+    aes128::solve_aes128_encryption_opcode, bigint::AcvmBigIntSolver,
+    hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash,
 };
 
 use super::{insert_value, OpcodeNotSolvable, OpcodeResolutionError};
 use crate::{pwg::witness_to_value, BlackBoxFunctionSolver};
 
+mod aes128;
 pub(crate) mod bigint;
-mod fixed_base_scalar_mul;
+mod embedded_curve_ops;
 mod hash;
 mod logic;
 mod pedersen;
 mod range;
 mod signature;
+pub(crate) mod utils;
 
-use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
+use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 // Hash functions should eventually be exposed for external consumers.
 use hash::{solve_generic_256_hash_opcode, solve_sha_256_permutation_opcode};
 use logic::{and, xor};
@@ -68,6 +71,9 @@ pub(crate) fn solve(
     }
 
     match bb_func {
+        BlackBoxFuncCall::AES128Encrypt { inputs, iv, key, outputs } => {
+            solve_aes128_encryption_opcode(initial_witness, inputs, iv, key, outputs)
+        }
         BlackBoxFuncCall::AND { lhs, rhs, output } => and(initial_witness, lhs, rhs, output),
         BlackBoxFuncCall::XOR { lhs, rhs, output } => xor(initial_witness, lhs, rhs, output),
         BlackBoxFuncCall::RANGE { input } => solve_range_opcode(initial_witness, input),
@@ -155,8 +161,8 @@ pub(crate) fn solve(
             message.as_ref(),
             *output,
         ),
-        BlackBoxFuncCall::FixedBaseScalarMul { low, high, outputs } => {
-            fixed_base_scalar_mul(backend, initial_witness, *low, *high, *outputs)
+        BlackBoxFuncCall::MultiScalarMul { points, scalars, outputs } => {
+            multi_scalar_mul(backend, initial_witness, points, scalars, *outputs)
         }
         BlackBoxFuncCall::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, outputs } => {
             embedded_curve_add(
diff --git a/acvm-repo/acvm/src/pwg/blackbox/range.rs b/acvm-repo/acvm/src/pwg/blackbox/range.rs
index 2afe820b636..aac50b32fc8 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/range.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/range.rs
@@ -12,6 +12,7 @@ pub(crate) fn solve_range_opcode(
     if w_value.num_bits() > input.num_bits {
         return Err(OpcodeResolutionError::UnsatisfiedConstrain {
             opcode_location: ErrorLocation::Unresolved,
+            payload: None,
         });
     }
     Ok(())
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
index b113c801251..ce2e57e0bd7 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
@@ -5,9 +5,13 @@ use acir::{
 };
 use acvm_blackbox_solver::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 
-use crate::{pwg::insert_value, OpcodeResolutionError};
-
-use super::{to_u8_array, to_u8_vec};
+use crate::{
+    pwg::{
+        blackbox::utils::{to_u8_array, to_u8_vec},
+        insert_value,
+    },
+    OpcodeResolutionError,
+};
 
 pub(crate) fn secp256k1_prehashed(
     initial_witness: &mut WitnessMap,
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
index bd223ecd0c9..0cfb96740b8 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
@@ -1,36 +1,2 @@
-use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
-
-use crate::pwg::{witness_to_value, OpcodeResolutionError};
-
-fn to_u8_array<const N: usize>(
-    initial_witness: &WitnessMap,
-    inputs: &[FunctionInput; N],
-) -> Result<[u8; N], OpcodeResolutionError> {
-    let mut result = [0; N];
-    for (it, input) in result.iter_mut().zip(inputs) {
-        let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
-        let byte = witness_value_bytes
-            .last()
-            .expect("Field element must be represented by non-zero amount of bytes");
-        *it = *byte;
-    }
-    Ok(result)
-}
-
-fn to_u8_vec(
-    initial_witness: &WitnessMap,
-    inputs: &[FunctionInput],
-) -> Result<Vec<u8>, OpcodeResolutionError> {
-    let mut result = Vec::with_capacity(inputs.len());
-    for input in inputs {
-        let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
-        let byte = witness_value_bytes
-            .last()
-            .expect("Field element must be represented by non-zero amount of bytes");
-        result.push(*byte);
-    }
-    Ok(result)
-}
-
 pub(super) mod ecdsa;
 pub(super) mod schnorr;
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
index 3d0216fa217..7b085d9ff47 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
@@ -1,6 +1,8 @@
-use super::{to_u8_array, to_u8_vec};
 use crate::{
-    pwg::{insert_value, witness_to_value, OpcodeResolutionError},
+    pwg::{
+        blackbox::utils::{to_u8_array, to_u8_vec},
+        insert_value, witness_to_value, OpcodeResolutionError,
+    },
     BlackBoxFunctionSolver,
 };
 use acir::{
diff --git a/acvm-repo/acvm/src/pwg/blackbox/utils.rs b/acvm-repo/acvm/src/pwg/blackbox/utils.rs
new file mode 100644
index 00000000000..700f30890ae
--- /dev/null
+++ b/acvm-repo/acvm/src/pwg/blackbox/utils.rs
@@ -0,0 +1,33 @@
+use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
+
+use crate::pwg::{witness_to_value, OpcodeResolutionError};
+
+pub(crate) fn to_u8_array<const N: usize>(
+    initial_witness: &WitnessMap,
+    inputs: &[FunctionInput; N],
+) -> Result<[u8; N], OpcodeResolutionError> {
+    let mut result = [0; N];
+    for (it, input) in result.iter_mut().zip(inputs) {
+        let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
+        let byte = witness_value_bytes
+            .last()
+            .expect("Field element must be represented by non-zero amount of bytes");
+        *it = *byte;
+    }
+    Ok(result)
+}
+
+pub(crate) fn to_u8_vec(
+    initial_witness: &WitnessMap,
+    inputs: &[FunctionInput],
+) -> Result<Vec<u8>, OpcodeResolutionError> {
+    let mut result = Vec::with_capacity(inputs.len());
+    for input in inputs {
+        let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
+        let byte = witness_value_bytes
+            .last()
+            .expect("Field element must be represented by non-zero amount of bytes");
+        result.push(*byte);
+    }
+    Ok(result)
+}
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index 10178465d58..c911202c823 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -3,9 +3,10 @@ use std::collections::HashMap;
 use acir::{
     brillig::{ForeignCallParam, ForeignCallResult, Opcode as BrilligOpcode},
     circuit::{
-        brillig::{Brillig, BrilligInputs, BrilligOutputs},
+        brillig::{BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
-        OpcodeLocation,
+        ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
+        STRING_ERROR_SELECTOR,
     },
     native_types::WitnessMap,
     FieldElement,
@@ -50,26 +51,6 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         Ok(())
     }
 
-    // TODO: Delete this old method once `Brillig` is deleted
-    /// Constructs a solver for a Brillig block given the bytecode and initial
-    /// witness.
-    pub(crate) fn new(
-        initial_witness: &WitnessMap,
-        memory: &HashMap<BlockId, MemoryOpSolver>,
-        brillig: &'b Brillig,
-        bb_solver: &'b B,
-        acir_index: usize,
-    ) -> Result<Self, OpcodeResolutionError> {
-        let vm = Self::setup_brillig_vm(
-            initial_witness,
-            memory,
-            &brillig.inputs,
-            &brillig.bytecode,
-            bb_solver,
-        )?;
-        Ok(Self { vm, acir_index })
-    }
-
     /// Constructs a solver for a Brillig block given the bytecode and initial
     /// witness.
     pub(crate) fn new_call(
@@ -180,32 +161,55 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
             VMStatus::Finished { .. } => Ok(BrilligSolverStatus::Finished),
             VMStatus::InProgress => Ok(BrilligSolverStatus::InProgress),
             VMStatus::Failure { reason, call_stack } => {
-                let message = match reason {
-                    FailureReason::RuntimeError { message } => Some(message),
+                let payload = match reason {
+                    FailureReason::RuntimeError { message } => {
+                        Some(ResolvedAssertionPayload::String(message))
+                    }
                     FailureReason::Trap { revert_data_offset, revert_data_size } => {
                         // Since noir can only revert with strings currently, we can parse return data as a string
                         if revert_data_size == 0 {
                             None
                         } else {
                             let memory = self.vm.get_memory();
-                            let bytes = memory
+                            let mut revert_values_iter = memory
                                 [revert_data_offset..(revert_data_offset + revert_data_size)]
-                                .iter()
-                                .map(|memory_value| {
-                                    memory_value
-                                        .try_into()
-                                        .expect("Assert message character is not a byte")
-                                })
-                                .collect();
-                            Some(
-                                String::from_utf8(bytes)
-                                    .expect("Assert message is not valid UTF-8"),
-                            )
+                                .iter();
+                            let error_selector = ErrorSelector::new(
+                                revert_values_iter
+                                    .next()
+                                    .expect("Incorrect revert data size")
+                                    .try_into()
+                                    .expect("Error selector is not u64"),
+                            );
+
+                            match error_selector {
+                                STRING_ERROR_SELECTOR => {
+                                    // If the error selector is 0, it means the error is a string
+                                    let string = revert_values_iter
+                                        .map(|memory_value| {
+                                            let as_u8: u8 = memory_value
+                                                .try_into()
+                                                .expect("String item is not u8");
+                                            as_u8 as char
+                                        })
+                                        .collect();
+                                    Some(ResolvedAssertionPayload::String(string))
+                                }
+                                _ => {
+                                    // If the error selector is not 0, it means the error is a custom error
+                                    Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
+                                        selector: error_selector,
+                                        data: revert_values_iter
+                                            .map(|value| value.to_field())
+                                            .collect(),
+                                    }))
+                                }
+                            }
                         }
                     }
                 };
                 Err(OpcodeResolutionError::BrilligFunctionFailed {
-                    message,
+                    payload,
                     call_stack: call_stack
                         .iter()
                         .map(|brillig_index| OpcodeLocation::Brillig {
diff --git a/acvm-repo/acvm/src/pwg/directives/mod.rs b/acvm-repo/acvm/src/pwg/directives/mod.rs
index ee544521fc7..db79379a374 100644
--- a/acvm-repo/acvm/src/pwg/directives/mod.rs
+++ b/acvm-repo/acvm/src/pwg/directives/mod.rs
@@ -26,6 +26,7 @@ pub(crate) fn solve_directives(
             if b.len() < decomposed_integer.len() {
                 return Err(OpcodeResolutionError::UnsatisfiedConstrain {
                     opcode_location: ErrorLocation::Unresolved,
+                    payload: None,
                 });
             }
 
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index 3d3c52c661b..a4219adbfa6 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -4,7 +4,11 @@ use std::collections::HashMap;
 
 use acir::{
     brillig::ForeignCallResult,
-    circuit::{brillig::BrilligBytecode, opcodes::BlockId, Opcode, OpcodeLocation},
+    circuit::{
+        brillig::BrilligBytecode, opcodes::BlockId, AssertionPayload, ErrorSelector,
+        ExpressionOrMemory, Opcode, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
+        STRING_ERROR_SELECTOR,
+    },
     native_types::{Expression, Witness, WitnessMap},
     BlackBoxFunc, FieldElement,
 };
@@ -117,13 +121,19 @@ pub enum OpcodeResolutionError {
     #[error("Cannot solve opcode: {0}")]
     OpcodeNotSolvable(#[from] OpcodeNotSolvable),
     #[error("Cannot satisfy constraint")]
-    UnsatisfiedConstrain { opcode_location: ErrorLocation },
+    UnsatisfiedConstrain {
+        opcode_location: ErrorLocation,
+        payload: Option<ResolvedAssertionPayload>,
+    },
     #[error("Index out of bounds, array has size {array_size:?}, but index was {index:?}")]
     IndexOutOfBounds { opcode_location: ErrorLocation, index: u32, array_size: u32 },
     #[error("Failed to solve blackbox function: {0}, reason: {1}")]
     BlackBoxFunctionFailed(BlackBoxFunc, String),
-    #[error("Failed to solve brillig function{}", .message.as_ref().map(|m| format!(", reason: {}", m)).unwrap_or_default())]
-    BrilligFunctionFailed { message: Option<String>, call_stack: Vec<OpcodeLocation> },
+    #[error("Failed to solve brillig function")]
+    BrilligFunctionFailed {
+        call_stack: Vec<OpcodeLocation>,
+        payload: Option<ResolvedAssertionPayload>,
+    },
     #[error("Attempted to call `main` with a `Call` opcode")]
     AcirMainCallAttempted { opcode_location: ErrorLocation },
     #[error("{results_size:?} result values were provided for {outputs_size:?} call output witnesses, most likely due to bad ACIR codegen")]
@@ -168,6 +178,8 @@ pub struct ACVM<'a, B: BlackBoxFunctionSolver> {
 
     // Each unconstrained function referenced in the program
     unconstrained_functions: &'a [BrilligBytecode],
+
+    assertion_payloads: &'a [(OpcodeLocation, AssertionPayload)],
 }
 
 impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
@@ -176,6 +188,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         opcodes: &'a [Opcode],
         initial_witness: WitnessMap,
         unconstrained_functions: &'a [BrilligBytecode],
+        assertion_payloads: &'a [(OpcodeLocation, AssertionPayload)],
     ) -> Self {
         let status = if opcodes.is_empty() { ACVMStatus::Solved } else { ACVMStatus::InProgress };
         ACVM {
@@ -190,6 +203,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             acir_call_counter: 0,
             acir_call_results: Vec::default(),
             unconstrained_functions,
+            assertion_payloads,
         }
     }
 
@@ -329,10 +343,6 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 let solver = self.block_solvers.entry(*block_id).or_default();
                 solver.solve_memory_op(op, &mut self.witness_map, predicate)
             }
-            Opcode::Brillig(_) => match self.solve_brillig_opcode() {
-                Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
-                res => res.map(|_| ()),
-            },
             Opcode::BrilligCall { .. } => match self.solve_brillig_call_opcode() {
                 Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
                 res => res.map(|_| ()),
@@ -366,14 +376,19 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                     OpcodeResolutionError::IndexOutOfBounds {
                         opcode_location: opcode_index,
                         ..
-                    }
-                    | OpcodeResolutionError::UnsatisfiedConstrain {
-                        opcode_location: opcode_index,
                     } => {
                         *opcode_index = ErrorLocation::Resolved(OpcodeLocation::Acir(
                             self.instruction_pointer(),
                         ));
                     }
+                    OpcodeResolutionError::UnsatisfiedConstrain {
+                        opcode_location: opcode_index,
+                        payload: assertion_payload,
+                    } => {
+                        let location = OpcodeLocation::Acir(self.instruction_pointer());
+                        *opcode_index = ErrorLocation::Resolved(location);
+                        *assertion_payload = self.extract_assertion_payload(location);
+                    }
                     // All other errors are thrown normally.
                     _ => (),
                 };
@@ -382,44 +397,61 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         }
     }
 
-    fn solve_brillig_opcode(
-        &mut self,
-    ) -> Result<Option<ForeignCallWaitInfo>, OpcodeResolutionError> {
-        let Opcode::Brillig(brillig) = &self.opcodes[self.instruction_pointer] else {
-            unreachable!("Not executing a Brillig opcode");
-        };
-
-        let witness = &mut self.witness_map;
-        if is_predicate_false(witness, &brillig.predicate)? {
-            return BrilligSolver::<B>::zero_out_brillig_outputs(witness, &brillig.outputs)
-                .map(|_| None);
-        }
-
-        // If we're resuming execution after resolving a foreign call then
-        // there will be a cached `BrilligSolver` to avoid recomputation.
-        let mut solver: BrilligSolver<'_, B> = match self.brillig_solver.take() {
-            Some(solver) => solver,
-            None => BrilligSolver::new(
-                witness,
-                &self.block_solvers,
-                brillig,
-                self.backend,
-                self.instruction_pointer,
-            )?,
-        };
-        match solver.solve()? {
-            BrilligSolverStatus::ForeignCallWait(foreign_call) => {
-                // Cache the current state of the solver
-                self.brillig_solver = Some(solver);
-                Ok(Some(foreign_call))
-            }
-            BrilligSolverStatus::InProgress => {
-                unreachable!("Brillig solver still in progress")
+    fn extract_assertion_payload(
+        &self,
+        location: OpcodeLocation,
+    ) -> Option<ResolvedAssertionPayload> {
+        let (_, found_assertion_payload) =
+            self.assertion_payloads.iter().find(|(loc, _)| location == *loc)?;
+        match found_assertion_payload {
+            AssertionPayload::StaticString(string) => {
+                Some(ResolvedAssertionPayload::String(string.clone()))
             }
-            BrilligSolverStatus::Finished => {
-                // Write execution outputs
-                solver.finalize(witness, &brillig.outputs)?;
-                Ok(None)
+            AssertionPayload::Dynamic(error_selector, expression) => {
+                let mut fields = vec![];
+                for expr in expression {
+                    match expr {
+                        ExpressionOrMemory::Expression(expr) => {
+                            let value = get_value(expr, &self.witness_map).ok()?;
+                            fields.push(value);
+                        }
+                        ExpressionOrMemory::Memory(block_id) => {
+                            let memory_block = self.block_solvers.get(block_id)?;
+                            fields.extend((0..memory_block.block_len).map(|memory_index| {
+                                *memory_block
+                                    .block_value
+                                    .get(&memory_index)
+                                    .expect("All memory is initialized on creation")
+                            }));
+                        }
+                    }
+                }
+                let error_selector = ErrorSelector::new(*error_selector);
+
+                Some(match error_selector {
+                    STRING_ERROR_SELECTOR => {
+                        // If the error selector is 0, it means the error is a string
+                        let string = fields
+                            .iter()
+                            .map(|field| {
+                                let as_u8: u8 = field
+                                    .try_to_u64()
+                                    .expect("String character doesn't fit in u64")
+                                    .try_into()
+                                    .expect("String character doesn't fit in u8");
+                                as_u8 as char
+                            })
+                            .collect();
+                        ResolvedAssertionPayload::String(string)
+                    }
+                    _ => {
+                        // If the error selector is not 0, it means the error is a custom error
+                        ResolvedAssertionPayload::Raw(RawAssertionPayload {
+                            selector: error_selector,
+                            data: fields,
+                        })
+                    }
+                })
             }
         }
     }
@@ -433,9 +465,9 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             unreachable!("Not executing a BrilligCall opcode");
         };
 
-        let witness = &mut self.witness_map;
-        if is_predicate_false(witness, predicate)? {
-            return BrilligSolver::<B>::zero_out_brillig_outputs(witness, outputs).map(|_| None);
+        if is_predicate_false(&self.witness_map, predicate)? {
+            return BrilligSolver::<B>::zero_out_brillig_outputs(&mut self.witness_map, outputs)
+                .map(|_| None);
         }
 
         // If we're resuming execution after resolving a foreign call then
@@ -443,7 +475,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         let mut solver: BrilligSolver<'_, B> = match self.brillig_solver.take() {
             Some(solver) => solver,
             None => BrilligSolver::new_call(
-                witness,
+                &self.witness_map,
                 &self.block_solvers,
                 inputs,
                 &self.unconstrained_functions[*id as usize].bytecode,
@@ -451,7 +483,10 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 self.instruction_pointer,
             )?,
         };
-        match solver.solve()? {
+
+        let result = solver.solve().map_err(|err| self.map_brillig_error(err))?;
+
+        match result {
             BrilligSolverStatus::ForeignCallWait(foreign_call) => {
                 // Cache the current state of the solver
                 self.brillig_solver = Some(solver);
@@ -462,12 +497,37 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             }
             BrilligSolverStatus::Finished => {
                 // Write execution outputs
-                solver.finalize(witness, outputs)?;
+                solver.finalize(&mut self.witness_map, outputs)?;
                 Ok(None)
             }
         }
     }
 
+    fn map_brillig_error(&self, mut err: OpcodeResolutionError) -> OpcodeResolutionError {
+        match &mut err {
+            OpcodeResolutionError::BrilligFunctionFailed { call_stack, payload } => {
+                // Some brillig errors have static strings as payloads, we can resolve them here
+                let last_location =
+                    call_stack.last().expect("Call stacks should have at least one item");
+                let assertion_descriptor =
+                    self.assertion_payloads.iter().find_map(|(loc, payload)| {
+                        if loc == last_location {
+                            Some(payload)
+                        } else {
+                            None
+                        }
+                    });
+
+                if let Some(AssertionPayload::StaticString(string)) = assertion_descriptor {
+                    *payload = Some(ResolvedAssertionPayload::String(string.clone()));
+                }
+
+                err
+            }
+            _ => err,
+        }
+    }
+
     pub fn step_into_brillig(&mut self) -> StepResult<'a, B> {
         let Opcode::BrilligCall { id, inputs, outputs, predicate } =
             &self.opcodes[self.instruction_pointer]
@@ -605,6 +665,7 @@ pub fn insert_value(
     if old_value != value_to_insert {
         return Err(OpcodeResolutionError::UnsatisfiedConstrain {
             opcode_location: ErrorLocation::Unresolved,
+            payload: None,
         });
     }
 
diff --git a/acvm-repo/acvm/tests/solver.rs b/acvm-repo/acvm/tests/solver.rs
index f009e2c05b8..df61083eee4 100644
--- a/acvm-repo/acvm/tests/solver.rs
+++ b/acvm-repo/acvm/tests/solver.rs
@@ -1,9 +1,9 @@
 use std::collections::BTreeMap;
 
 use acir::{
-    brillig::{BinaryFieldOp, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
+    brillig::{BinaryFieldOp, HeapArray, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
     circuit::{
-        brillig::{Brillig, BrilligInputs, BrilligOutputs},
+        brillig::{BrilligBytecode, BrilligInputs, BrilligOutputs},
         opcodes::{BlockId, MemOp},
         Opcode, OpcodeLocation,
     },
@@ -43,44 +43,26 @@ fn inversion_brillig_oracle_equivalence() {
         destination: MemoryAddress::from(2),
     };
 
-    let brillig_data = Brillig {
-        inputs: vec![
-            BrilligInputs::Single(Expression {
-                // Input Register 0
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, w_x), (fe_1, w_y)],
-                q_c: fe_0,
-            }),
-            BrilligInputs::Single(Expression::default()), // Input Register 1
-        ],
-        // This tells the BrilligSolver which witnesses its output values correspond to
-        outputs: vec![
-            BrilligOutputs::Simple(w_x_plus_y), // Output Register 0 - from input
-            BrilligOutputs::Simple(w_oracle),   // Output Register 1
-            BrilligOutputs::Simple(w_equal_res), // Output Register 2
-        ],
-        bytecode: vec![
-            BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size: 2,
-                offset: 0,
-            },
-            equal_opcode,
-            // Oracles are named 'foreign calls' in brillig
-            BrilligOpcode::ForeignCall {
-                function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
-                destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
-                input_value_types: vec![HeapValueType::field()],
-            },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 3 },
-        ],
-        predicate: None,
-    };
-
     let opcodes = vec![
-        Opcode::Brillig(brillig_data),
+        Opcode::BrilligCall {
+            id: 0,
+            inputs: vec![
+                BrilligInputs::Single(Expression {
+                    // Input Register 0
+                    mul_terms: vec![],
+                    linear_combinations: vec![(fe_1, w_x), (fe_1, w_y)],
+                    q_c: fe_0,
+                }),
+                BrilligInputs::Single(Expression::default()), // Input Register 1
+            ],
+            // This tells the BrilligSolver which witnesses its output values correspond to
+            outputs: vec![
+                BrilligOutputs::Simple(w_x_plus_y), // Output Register 0 - from input
+                BrilligOutputs::Simple(w_oracle),   // Output Register 1
+                BrilligOutputs::Simple(w_equal_res), // Output Register 2
+            ],
+            predicate: None,
+        },
         Opcode::AssertZero(Expression {
             mul_terms: vec![],
             linear_combinations: vec![(fe_1, w_x), (fe_1, w_y), (-fe_1, w_z)],
@@ -99,14 +81,39 @@ fn inversion_brillig_oracle_equivalence() {
         }),
     ];
 
+    let brillig_bytecode = BrilligBytecode {
+        bytecode: vec![
+            BrilligOpcode::CalldataCopy {
+                destination_address: MemoryAddress(0),
+                size: 2,
+                offset: 0,
+            },
+            equal_opcode,
+            // Oracles are named 'foreign calls' in brillig
+            BrilligOpcode::ForeignCall {
+                function: "invert".into(),
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
+                destination_value_types: vec![HeapValueType::field()],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                input_value_types: vec![HeapValueType::field()],
+            },
+            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 3 },
+        ],
+    };
+
     let witness_assignments = BTreeMap::from([
         (Witness(1), FieldElement::from(2u128)),
         (Witness(2), FieldElement::from(3u128)),
     ])
     .into();
-    let unconstrained_functions = vec![];
-    let mut acvm =
-        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
+    let unconstrained_functions = vec![brillig_bytecode];
+    let mut acvm = ACVM::new(
+        &StubbedBlackBoxSolver,
+        &opcodes,
+        witness_assignments,
+        &unconstrained_functions,
+        &[],
+    );
     // use the partial witness generation solver with our acir program
     let solver_status = acvm.solve();
 
@@ -165,29 +172,52 @@ fn double_inversion_brillig_oracle() {
         destination: MemoryAddress::from(4),
     };
 
-    let brillig_data = Brillig {
-        inputs: vec![
-            BrilligInputs::Single(Expression {
-                // Input Register 0
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, w_x), (fe_1, w_y)],
-                q_c: fe_0,
-            }),
-            BrilligInputs::Single(Expression::default()), // Input Register 1
-            BrilligInputs::Single(Expression {
-                // Input Register 2
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, w_i), (fe_1, w_j)],
-                q_c: fe_0,
-            }),
-        ],
-        outputs: vec![
-            BrilligOutputs::Simple(w_x_plus_y), // Output Register 0 - from input
-            BrilligOutputs::Simple(w_oracle),   // Output Register 1
-            BrilligOutputs::Simple(w_i_plus_j), // Output Register 2 - from input
-            BrilligOutputs::Simple(w_ij_oracle), // Output Register 3
-            BrilligOutputs::Simple(w_equal_res), // Output Register 4
-        ],
+    let opcodes = vec![
+        Opcode::BrilligCall {
+            id: 0,
+            inputs: vec![
+                BrilligInputs::Single(Expression {
+                    // Input Register 0
+                    mul_terms: vec![],
+                    linear_combinations: vec![(fe_1, w_x), (fe_1, w_y)],
+                    q_c: fe_0,
+                }),
+                BrilligInputs::Single(Expression::default()), // Input Register 1
+                BrilligInputs::Single(Expression {
+                    // Input Register 2
+                    mul_terms: vec![],
+                    linear_combinations: vec![(fe_1, w_i), (fe_1, w_j)],
+                    q_c: fe_0,
+                }),
+            ],
+            outputs: vec![
+                BrilligOutputs::Simple(w_x_plus_y), // Output Register 0 - from input
+                BrilligOutputs::Simple(w_oracle),   // Output Register 1
+                BrilligOutputs::Simple(w_i_plus_j), // Output Register 2 - from input
+                BrilligOutputs::Simple(w_ij_oracle), // Output Register 3
+                BrilligOutputs::Simple(w_equal_res), // Output Register 4
+            ],
+            predicate: None,
+        },
+        Opcode::AssertZero(Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![(fe_1, w_x), (fe_1, w_y), (-fe_1, w_z)],
+            q_c: fe_0,
+        }),
+        // Opcode::Directive(Directive::Invert { x: w_z, result: w_z_inverse }),
+        Opcode::AssertZero(Expression {
+            mul_terms: vec![(fe_1, w_z, w_z_inverse)],
+            linear_combinations: vec![],
+            q_c: -fe_1,
+        }),
+        Opcode::AssertZero(Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![(-fe_1, w_oracle), (fe_1, w_z_inverse)],
+            q_c: fe_0,
+        }),
+    ];
+
+    let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::CalldataCopy {
                 destination_address: MemoryAddress(0),
@@ -212,29 +242,8 @@ fn double_inversion_brillig_oracle() {
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 5 },
         ],
-        predicate: None,
     };
 
-    let opcodes = vec![
-        Opcode::Brillig(brillig_data),
-        Opcode::AssertZero(Expression {
-            mul_terms: vec![],
-            linear_combinations: vec![(fe_1, w_x), (fe_1, w_y), (-fe_1, w_z)],
-            q_c: fe_0,
-        }),
-        // Opcode::Directive(Directive::Invert { x: w_z, result: w_z_inverse }),
-        Opcode::AssertZero(Expression {
-            mul_terms: vec![(fe_1, w_z, w_z_inverse)],
-            linear_combinations: vec![],
-            q_c: -fe_1,
-        }),
-        Opcode::AssertZero(Expression {
-            mul_terms: vec![],
-            linear_combinations: vec![(-fe_1, w_oracle), (fe_1, w_z_inverse)],
-            q_c: fe_0,
-        }),
-    ];
-
     let witness_assignments = BTreeMap::from([
         (Witness(1), FieldElement::from(2u128)),
         (Witness(2), FieldElement::from(3u128)),
@@ -242,9 +251,14 @@ fn double_inversion_brillig_oracle() {
         (Witness(9), FieldElement::from(10u128)),
     ])
     .into();
-    let unconstrained_functions = vec![];
-    let mut acvm =
-        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
+    let unconstrained_functions = vec![brillig_bytecode];
+    let mut acvm = ACVM::new(
+        &StubbedBlackBoxSolver,
+        &opcodes,
+        witness_assignments,
+        &unconstrained_functions,
+        &[],
+    );
 
     // use the partial witness generation solver with our acir program
     let solver_status = acvm.solve();
@@ -311,18 +325,7 @@ fn oracle_dependent_execution() {
     let w_x_inv = Witness(3);
     let w_y_inv = Witness(4);
 
-    let brillig_data = Brillig {
-        inputs: vec![
-            BrilligInputs::Single(w_x.into()),            // Input Register 0
-            BrilligInputs::Single(Expression::default()), // Input Register 1
-            BrilligInputs::Single(w_y.into()),            // Input Register 2,
-        ],
-        outputs: vec![
-            BrilligOutputs::Simple(w_x),     // Output Register 0 - from input
-            BrilligOutputs::Simple(w_y_inv), // Output Register 1
-            BrilligOutputs::Simple(w_y),     // Output Register 2 - from input
-            BrilligOutputs::Simple(w_y_inv), // Output Register 3
-        ],
+    let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::CalldataCopy {
                 destination_address: MemoryAddress(0),
@@ -346,7 +349,6 @@ fn oracle_dependent_execution() {
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 4 },
         ],
-        predicate: None,
     };
 
     // This equality check can be executed immediately before resolving any foreign calls.
@@ -366,15 +368,34 @@ fn oracle_dependent_execution() {
 
     let opcodes = vec![
         Opcode::AssertZero(equality_check),
-        Opcode::Brillig(brillig_data),
+        Opcode::BrilligCall {
+            id: 0,
+            inputs: vec![
+                BrilligInputs::Single(w_x.into()),            // Input Register 0
+                BrilligInputs::Single(Expression::default()), // Input Register 1
+                BrilligInputs::Single(w_y.into()),            // Input Register 2,
+            ],
+            outputs: vec![
+                BrilligOutputs::Simple(w_x),     // Output Register 0 - from input
+                BrilligOutputs::Simple(w_y_inv), // Output Register 1
+                BrilligOutputs::Simple(w_y),     // Output Register 2 - from input
+                BrilligOutputs::Simple(w_y_inv), // Output Register 3
+            ],
+            predicate: None,
+        },
         Opcode::AssertZero(inverse_equality_check),
     ];
 
     let witness_assignments =
         BTreeMap::from([(w_x, FieldElement::from(2u128)), (w_y, FieldElement::from(2u128))]).into();
-    let unconstrained_functions = vec![];
-    let mut acvm =
-        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
+    let unconstrained_functions = vec![brillig_bytecode];
+    let mut acvm = ACVM::new(
+        &StubbedBlackBoxSolver,
+        &opcodes,
+        witness_assignments,
+        &unconstrained_functions,
+        &[],
+    );
 
     // use the partial witness generation solver with our acir program
     let solver_status = acvm.solve();
@@ -436,21 +457,7 @@ fn brillig_oracle_predicate() {
         destination: MemoryAddress::from(2),
     };
 
-    let brillig_opcode = Opcode::Brillig(Brillig {
-        inputs: vec![
-            BrilligInputs::Single(Expression {
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, w_x), (fe_1, w_y)],
-                q_c: fe_0,
-            }),
-            BrilligInputs::Single(Expression::default()),
-        ],
-        outputs: vec![
-            BrilligOutputs::Simple(w_x_plus_y),
-            BrilligOutputs::Simple(w_oracle),
-            BrilligOutputs::Simple(w_equal_res),
-            BrilligOutputs::Simple(w_lt_res),
-        ],
+    let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::CalldataCopy {
                 destination_address: MemoryAddress(0),
@@ -467,19 +474,40 @@ fn brillig_oracle_predicate() {
                 input_value_types: vec![HeapValueType::field()],
             },
         ],
-        predicate: Some(Expression::default()),
-    });
+    };
 
-    let opcodes = vec![brillig_opcode];
+    let opcodes = vec![Opcode::BrilligCall {
+        id: 0,
+        inputs: vec![
+            BrilligInputs::Single(Expression {
+                mul_terms: vec![],
+                linear_combinations: vec![(fe_1, w_x), (fe_1, w_y)],
+                q_c: fe_0,
+            }),
+            BrilligInputs::Single(Expression::default()),
+        ],
+        outputs: vec![
+            BrilligOutputs::Simple(w_x_plus_y),
+            BrilligOutputs::Simple(w_oracle),
+            BrilligOutputs::Simple(w_equal_res),
+            BrilligOutputs::Simple(w_lt_res),
+        ],
+        predicate: Some(Expression::default()),
+    }];
 
     let witness_assignments = BTreeMap::from([
         (Witness(1), FieldElement::from(2u128)),
         (Witness(2), FieldElement::from(3u128)),
     ])
     .into();
-    let unconstrained_functions = vec![];
-    let mut acvm =
-        ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &unconstrained_functions);
+    let unconstrained_functions = vec![brillig_bytecode];
+    let mut acvm = ACVM::new(
+        &StubbedBlackBoxSolver,
+        &opcodes,
+        witness_assignments,
+        &unconstrained_functions,
+        &[],
+    );
     let solver_status = acvm.solve();
     assert_eq!(solver_status, ACVMStatus::Solved, "should be fully solved");
 
@@ -514,12 +542,14 @@ fn unsatisfied_opcode_resolved() {
 
     let opcodes = vec![Opcode::AssertZero(opcode_a)];
     let unconstrained_functions = vec![];
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, values, &unconstrained_functions);
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, values, &unconstrained_functions, &[]);
     let solver_status = acvm.solve();
     assert_eq!(
         solver_status,
         ACVMStatus::Failure(OpcodeResolutionError::UnsatisfiedConstrain {
             opcode_location: ErrorLocation::Resolved(OpcodeLocation::Acir(0)),
+            payload: None
         }),
         "The first opcode is not satisfiable, expected an error indicating this"
     );
@@ -554,26 +584,12 @@ fn unsatisfied_opcode_resolved_brillig() {
     let jmp_if_opcode =
         BrilligOpcode::JumpIf { condition: MemoryAddress::from(2), location: location_of_stop };
 
-    let trap_opcode = BrilligOpcode::Trap { revert_data_offset: 0, revert_data_size: 0 };
+    let trap_opcode = BrilligOpcode::Trap { revert_data: HeapArray::default() };
     let stop_opcode = BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 };
 
-    let brillig_opcode = Opcode::Brillig(Brillig {
-        inputs: vec![
-            BrilligInputs::Single(Expression {
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, w_x)],
-                q_c: fe_0,
-            }),
-            BrilligInputs::Single(Expression {
-                mul_terms: vec![],
-                linear_combinations: vec![(fe_1, w_y)],
-                q_c: fe_0,
-            }),
-        ],
-        outputs: vec![BrilligOutputs::Simple(w_result)],
+    let brillig_bytecode = BrilligBytecode {
         bytecode: vec![calldata_copy_opcode, equal_opcode, jmp_if_opcode, trap_opcode, stop_opcode],
-        predicate: Some(Expression::one()),
-    });
+    };
 
     let opcode_a = Expression {
         mul_terms: vec![],
@@ -595,14 +611,34 @@ fn unsatisfied_opcode_resolved_brillig() {
     values.insert(w_y, FieldElement::from(1_i128));
     values.insert(w_result, FieldElement::from(0_i128));
 
-    let opcodes = vec![brillig_opcode, Opcode::AssertZero(opcode_a)];
-    let unconstrained_functions = vec![];
-    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, values, &unconstrained_functions);
+    let opcodes = vec![
+        Opcode::BrilligCall {
+            id: 0,
+            inputs: vec![
+                BrilligInputs::Single(Expression {
+                    mul_terms: vec![],
+                    linear_combinations: vec![(fe_1, w_x)],
+                    q_c: fe_0,
+                }),
+                BrilligInputs::Single(Expression {
+                    mul_terms: vec![],
+                    linear_combinations: vec![(fe_1, w_y)],
+                    q_c: fe_0,
+                }),
+            ],
+            outputs: vec![BrilligOutputs::Simple(w_result)],
+            predicate: Some(Expression::one()),
+        },
+        Opcode::AssertZero(opcode_a),
+    ];
+    let unconstrained_functions = vec![brillig_bytecode];
+    let mut acvm =
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, values, &unconstrained_functions, &[]);
     let solver_status = acvm.solve();
     assert_eq!(
         solver_status,
         ACVMStatus::Failure(OpcodeResolutionError::BrilligFunctionFailed {
-            message: None,
+            payload: None,
             call_stack: vec![OpcodeLocation::Brillig { acir_index: 0, brillig_index: 3 }]
         }),
         "The first opcode is not satisfiable, expected an error indicating this"
@@ -642,7 +678,7 @@ fn memory_operations() {
     let opcodes = vec![init, read_op, expression];
     let unconstrained_functions = vec![];
     let mut acvm =
-        ACVM::new(&StubbedBlackBoxSolver, &opcodes, initial_witness, &unconstrained_functions);
+        ACVM::new(&StubbedBlackBoxSolver, &opcodes, initial_witness, &unconstrained_functions, &[]);
     let solver_status = acvm.solve();
     assert_eq!(solver_status, ACVMStatus::Solved);
     let witness_map = acvm.finalize();
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 2fab684467e..338511874c9 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -1,6 +1,7 @@
 use std::{future::Future, pin::Pin};
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
+use acvm::acir::circuit::ResolvedAssertionPayload;
 use acvm::BlackBoxFunctionSolver;
 use acvm::{
     acir::circuit::{Circuit, Program},
@@ -78,7 +79,7 @@ pub async fn execute_circuit_with_return_witness(
     console_error_panic_hook::set_once();
 
     let program: Program = Program::deserialize_program(&program)
-    .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
+    .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None, None))?;
 
     let mut witness_stack = execute_program_with_native_program_and_return(
         solver,
@@ -93,7 +94,7 @@ pub async fn execute_circuit_with_return_witness(
     let main_circuit = &program.functions[0];
     let return_witness =
         extract_indices(&solved_witness, main_circuit.return_values.0.iter().copied().collect())
-            .map_err(|err| JsExecutionError::new(err, None))?;
+            .map_err(|err| JsExecutionError::new(err, None, None))?;
 
     Ok((solved_witness, return_witness).into())
 }
@@ -165,7 +166,10 @@ async fn execute_program_with_native_type_return(
     foreign_call_executor: &ForeignCallHandler,
 ) -> Result<WitnessStack, Error> {
     let program: Program = Program::deserialize_program(&program)
-    .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
+    .map_err(|_| JsExecutionError::new(
+        "Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), 
+        None,
+        None))?;
 
     execute_program_with_native_program_and_return(
         solver,
@@ -239,6 +243,7 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                 &circuit.opcodes,
                 initial_witness,
                 self.unconstrained_functions,
+                &circuit.assert_messages,
             );
 
             loop {
@@ -250,39 +255,48 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                         unreachable!("Execution should not stop while in `InProgress` state.")
                     }
                     ACVMStatus::Failure(error) => {
-                        let (assert_message, call_stack): (Option<&str>, _) = match &error {
+                        // Fetch call stack
+                        let call_stack = match &error {
                             OpcodeResolutionError::UnsatisfiedConstrain {
                                 opcode_location: ErrorLocation::Resolved(opcode_location),
+                                ..
                             }
                             | OpcodeResolutionError::IndexOutOfBounds {
                                 opcode_location: ErrorLocation::Resolved(opcode_location),
                                 ..
-                            } => (
-                                circuit.get_assert_message(*opcode_location),
-                                Some(vec![*opcode_location]),
-                            ),
-                            OpcodeResolutionError::BrilligFunctionFailed {
-                                call_stack,
-                                message,
-                            } => {
-                                let revert_message = message.as_ref().map(String::as_str);
-                                let failing_opcode = call_stack
-                                    .last()
-                                    .expect("Brillig error call stacks cannot be empty");
-                                (
-                                    revert_message.or(circuit.get_assert_message(*failing_opcode)),
-                                    Some(call_stack.clone()),
-                                )
+                            } => Some(vec![*opcode_location]),
+                            OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
+                                Some(call_stack.clone())
                             }
-                            _ => (None, None),
+                            _ => None,
                         };
-
-                        let error_string = match &assert_message {
-                            Some(assert_message) => format!("Assertion failed: {}", assert_message),
-                            None => error.to_string(),
+                        // If the failed opcode has an assertion message, integrate it into the error message for backwards compatibility.
+                        // Otherwise, pass the raw assertion payload as is.
+                        let (message, raw_assertion_payload) = match error {
+                            OpcodeResolutionError::UnsatisfiedConstrain {
+                                payload: Some(payload),
+                                ..
+                            }
+                            | OpcodeResolutionError::BrilligFunctionFailed {
+                                payload: Some(payload),
+                                ..
+                            } => match payload {
+                                ResolvedAssertionPayload::Raw(raw_payload) => {
+                                    ("Assertion failed".to_string(), Some(raw_payload))
+                                }
+                                ResolvedAssertionPayload::String(message) => {
+                                    (format!("Assertion failed: {}", message), None)
+                                }
+                            },
+                            _ => (error.to_string(), None),
                         };
 
-                        return Err(JsExecutionError::new(error_string, call_stack).into());
+                        return Err(JsExecutionError::new(
+                            message,
+                            call_stack,
+                            raw_assertion_payload,
+                        )
+                        .into());
                     }
                     ACVMStatus::RequiresForeignCall(foreign_call) => {
                         let result =
@@ -304,7 +318,7 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                                 call_resolved_outputs.push(*return_value);
                             } else {
                                 // TODO: look at changing this call stack from None
-                                return Err(JsExecutionError::new(format!("Failed to read from solved witness of ACIR call at witness {}", return_witness_index), None).into());
+                                return Err(JsExecutionError::new(format!("Failed to read from solved witness of ACIR call at witness {}", return_witness_index), None, None).into());
                             }
                         }
                         acvm.resolve_pending_acir_call(call_resolved_outputs);
diff --git a/acvm-repo/acvm_js/src/js_execution_error.rs b/acvm-repo/acvm_js/src/js_execution_error.rs
index d91a9425f7e..b34ea5ddb60 100644
--- a/acvm-repo/acvm_js/src/js_execution_error.rs
+++ b/acvm-repo/acvm_js/src/js_execution_error.rs
@@ -1,11 +1,17 @@
-use acvm::acir::circuit::OpcodeLocation;
+use acvm::acir::circuit::{OpcodeLocation, RawAssertionPayload};
+use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{Array, Error, JsString, Reflect};
 use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
 
 #[wasm_bindgen(typescript_custom_section)]
 const EXECUTION_ERROR: &'static str = r#"
+export type RawAssertionPayload = {
+    selector: string;
+    data: string[];
+};
 export type ExecutionError = Error & {
     callStack?: string[];
+    rawAssertionPayload?: RawAssertionPayload;
 };
 "#;
 
@@ -25,7 +31,11 @@ extern "C" {
 impl JsExecutionError {
     /// Creates a new execution error with the given call stack.
     /// Call stacks won't be optional in the future, after removing ErrorLocation in ACVM.
-    pub fn new(message: String, call_stack: Option<Vec<OpcodeLocation>>) -> Self {
+    pub fn new(
+        message: String,
+        call_stack: Option<Vec<OpcodeLocation>>,
+        assertion_payload: Option<RawAssertionPayload>,
+    ) -> Self {
         let mut error = JsExecutionError::constructor(JsString::from(message));
         let js_call_stack = match call_stack {
             Some(call_stack) => {
@@ -37,8 +47,14 @@ impl JsExecutionError {
             }
             None => JsValue::UNDEFINED,
         };
+        let assertion_payload = match assertion_payload {
+            Some(raw) => <wasm_bindgen::JsValue as JsValueSerdeExt>::from_serde(&raw)
+                .expect("Cannot serialize assertion payload"),
+            None => JsValue::UNDEFINED,
+        };
 
         error.set_property("callStack", js_call_stack);
+        error.set_property("rawAssertionPayload", assertion_payload);
 
         error
     }
diff --git a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
index 259c51ed1c6..625cc91cfe9 100644
--- a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
@@ -93,8 +93,8 @@ it('successfully executes a Pedersen opcode', async function () {
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes a FixedBaseScalarMul opcode', async () => {
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/fixed_base_scalar_mul');
+it('successfully executes a MultiScalarMul opcode', async () => {
+  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/multi_scalar_mul');
 
   const solvedWitness: WitnessMap = await executeCircuit(bytecode, initialWitnessMap, () => {
     throw Error('unexpected oracle');
diff --git a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
index 32487f8bbba..3f9bde2898e 100644
--- a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
@@ -90,8 +90,8 @@ it('successfully executes a Pedersen opcode', async function () {
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes a FixedBaseScalarMul opcode', async () => {
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/fixed_base_scalar_mul');
+it('successfully executes a MultiScalarMul opcode', async () => {
+  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/multi_scalar_mul');
 
   const solvedWitness: WitnessMap = await executeCircuit(bytecode, initialWitnessMap, () => {
     throw Error('unexpected oracle');
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index 722bae8e015..0d6fab0e1f3 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 218, 209, 145, 217, 205, 13, 6, 198, 3, 84, 79,
-  224, 93, 196, 157, 162, 75, 79, 47, 22, 124, 197, 16, 186, 17, 43, 104, 32, 36, 109, 126, 143, 36, 45, 211, 70, 133,
-  103, 134, 110, 61, 27, 232, 140, 179, 164, 224, 215, 64, 186, 115, 84, 113, 186, 92, 238, 42, 140, 230, 1, 24, 237, 5,
-  24, 195, 62, 220, 116, 222, 41, 231, 146, 180, 127, 54, 242, 126, 94, 158, 51, 207, 57, 206, 111, 200, 2, 247, 4, 219,
-  79, 245, 157, 132, 31, 137, 89, 52, 73, 176, 214, 46, 167, 125, 23, 89, 213, 254, 8, 156, 237, 56, 76, 125, 55, 91,
-  229, 170, 161, 254, 133, 94, 42, 59, 171, 184, 69, 197, 46, 66, 202, 47, 40, 86, 39, 220, 155, 3, 185, 191, 180, 183,
-  55, 163, 72, 98, 70, 66, 221, 251, 40, 173, 255, 35, 68, 62, 61, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 131, 64, 12, 77, 102, 90, 43, 221, 245, 6, 133, 246, 0, 211, 158,
+  192, 187, 136, 59, 69, 151, 158, 94, 116, 48, 131, 241, 233, 70, 28, 65, 3, 195, 155, 79, 62, 47, 9, 25, 166, 81, 210,
+  97, 177, 236, 239, 130, 70, 208, 223, 91, 154, 75, 208, 205, 4, 221, 62, 249, 113, 60, 95, 238, 40, 142, 230, 2, 28,
+  237, 1, 28, 73, 245, 255, 132, 253, 142, 217, 151, 168, 245, 179, 43, 243, 115, 163, 113, 190, 18, 57, 63, 4, 83, 44,
+  180, 55, 50, 180, 28, 188, 153, 224, 196, 122, 175, 111, 112, 68, 24, 65, 50, 204, 162, 100, 249, 119, 137, 226, 193,
+  16, 251, 169, 50, 204, 235, 170, 41, 139, 214, 130, 42, 82, 253, 168, 253, 23, 222, 25, 236, 58, 176, 237, 20, 234,
+  207, 107, 45, 78, 184, 55, 27, 124, 191, 104, 42, 111, 40, 121, 15, 94, 163, 77, 128, 65, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
deleted file mode 100644
index 97b5041121a..00000000000
--- a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// See `fixed_base_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
-export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, 29, 61, 35, 3, 19, 228, 137,
-  60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135, 142, 139, 219, 91, 127, 117, 71, 2, 117, 84, 50, 98, 113,
-  0, 0, 0,
-]);
-export const initialWitnessMap = new Map([
-  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [2, '0x0000000000000000000000000000000000000000000000000000000000000000'],
-]);
-
-export const expectedWitnessMap = new Map([
-  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [2, '0x0000000000000000000000000000000000000000000000000000000000000000'],
-  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [4, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
-]);
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index 0e3d77f62a9..3c66ba18629 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,10 +2,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 61, 10, 192, 32, 12, 133, 19, 11, 165, 116, 235, 77, 236, 13, 122, 153,
-  14, 93, 58, 136, 120, 124, 241, 47, 129, 12, 42, 130, 126, 16, 18, 146, 16, 222, 11, 66, 225, 136, 129, 84, 111, 162,
-  150, 112, 239, 161, 172, 231, 184, 113, 221, 45, 45, 245, 42, 242, 144, 216, 43, 250, 153, 83, 204, 191, 223, 189,
-  198, 246, 92, 39, 60, 244, 63, 195, 59, 87, 99, 150, 165, 113, 83, 193, 0, 1, 19, 247, 29, 5, 160, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 193, 10, 192, 32, 8, 134, 117, 99, 99, 236, 182, 55, 105, 111, 176, 151,
+  217, 161, 75, 135, 136, 30, 63, 42, 82, 144, 8, 47, 245, 65, 252, 230, 47, 162, 34, 52, 174, 242, 144, 226, 131, 148,
+  255, 18, 206, 125, 164, 102, 142, 23, 215, 245, 50, 114, 222, 173, 15, 80, 38, 65, 217, 108, 39, 61, 7, 30, 115, 11,
+  223, 186, 248, 251, 160, 221, 170, 146, 64, 191, 39, 215, 60, 3, 47, 3, 99, 171, 188, 84, 164, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index a69ae443259..20ea88c7130 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 57, 14, 0, 32, 8, 147, 195, 255, 224, 15, 252, 255, 171, 212, 200, 208,
-  129, 77, 24, 108, 66, 90, 150, 166, 20, 106, 23, 125, 143, 128, 62, 96, 103, 114, 173, 45, 198, 116, 182, 55, 140,
-  106, 95, 74, 246, 149, 60, 47, 171, 46, 215, 126, 43, 87, 179, 111, 23, 8, 202, 176, 99, 248, 240, 9, 11, 137, 33,
-  212, 110, 35, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 203, 180, 255, 216, 15, 250, 255, 171, 10, 154, 16, 210,
+  45, 61, 52, 144, 13, 132, 49, 135, 84, 54, 218, 26, 134, 22, 112, 5, 19, 180, 237, 61, 6, 88, 223, 208, 179, 125, 41,
+  216, 151, 227, 188, 52, 187, 92, 253, 173, 92, 137, 190, 157, 143, 160, 254, 155, 45, 188, 148, 11, 38, 213, 237, 188,
+  16, 35, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
new file mode 100644
index 00000000000..8ee0a067a3a
--- /dev/null
+++ b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
@@ -0,0 +1,21 @@
+// See `multi_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
+export const bytecode = Uint8Array.from([
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 76, 65, 14, 0, 32, 8, 82, 179, 186, 244, 104, 159, 30, 45, 218, 136, 141, 33,
+  40, 186, 93, 76, 208, 57, 31, 93, 96, 136, 47, 250, 146, 188, 209, 39, 181, 131, 131, 187, 148, 110, 240, 246, 101,
+  38, 63, 180, 243, 97, 3, 125, 173, 118, 131, 153, 0, 0, 0,
+]);
+export const initialWitnessMap = new Map([
+  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [2, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
+  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [4, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+]);
+
+export const expectedWitnessMap = new Map([
+  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [2, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
+  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [4, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [5, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [6, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
+]);
diff --git a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
index 4b73d01bb01..64051dff93f 100644
--- a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
+++ b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap, StackItem, WitnessStack } from '@noir-lang/acvm_js';
 
 // See `nested_acir_call_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 65, 10, 3, 33, 12, 69, 163, 46, 230, 58, 137, 209, 49, 238, 122, 149, 74,
-  157, 251, 31, 161, 83, 154, 161, 86, 132, 89, 212, 194, 124, 248, 24, 36, 132, 228, 241, 29, 188, 229, 212, 47, 45,
-  187, 205, 110, 11, 31, 25, 53, 28, 255, 103, 77, 14, 58, 29, 141, 55, 125, 241, 55, 145, 109, 102, 49, 174, 33, 212,
-  228, 43, 49, 221, 209, 231, 34, 17, 67, 44, 171, 144, 80, 148, 248, 240, 194, 92, 37, 72, 202, 37, 39, 204, 20, 184,
-  210, 22, 51, 111, 58, 204, 205, 219, 11, 161, 129, 208, 214, 6, 6, 114, 29, 193, 127, 193, 130, 137, 176, 236, 188,
-  189, 252, 162, 183, 218, 230, 238, 97, 138, 250, 152, 245, 245, 87, 220, 12, 140, 113, 95, 153, 170, 129, 185, 17, 60,
-  3, 54, 212, 19, 104, 145, 195, 151, 14, 4, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147, 24, 173, 241, 223, 174, 50,
+  153, 189, 255, 17, 214, 177, 148, 57, 17, 250, 99, 14, 250, 224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105,
+  217, 109, 118, 91, 248, 200, 168, 225, 248, 63, 107, 114, 208, 233, 104, 188, 233, 139, 191, 137, 108, 51, 139, 113,
+  13, 161, 38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42, 65, 82, 46, 57, 97,
+  166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182, 54, 48, 144, 235, 8, 254, 11, 22, 76, 132, 101,
+  231, 237, 229, 23, 189, 213, 54, 119, 15, 83, 212, 199, 172, 175, 191, 226, 102, 96, 140, 251, 202, 84, 13, 204, 141,
+  224, 25, 176, 161, 158, 53, 121, 144, 73, 14, 4, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/pedersen.ts b/acvm-repo/acvm_js/test/shared/pedersen.ts
index e8ddc893d87..6e3ec403d65 100644
--- a/acvm-repo/acvm_js/test/shared/pedersen.ts
+++ b/acvm-repo/acvm_js/test/shared/pedersen.ts
@@ -1,7 +1,7 @@
 // See `pedersen_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 9, 10, 0, 0, 4, 115, 149, 255, 127, 88, 8, 133, 213, 218, 137, 80, 144, 32,
-  182, 79, 213, 151, 173, 61, 5, 121, 245, 91, 103, 255, 191, 3, 7, 16, 26, 112, 158, 113, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 73, 10, 0, 0, 4, 180, 29, 252, 255, 193, 66, 40, 76, 77, 179, 34, 20, 36,
+  136, 237, 83, 245, 101, 107, 79, 65, 94, 253, 214, 217, 255, 239, 192, 1, 43, 124, 181, 238, 113, 0, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([[1, '0x0000000000000000000000000000000000000000000000000000000000000001']]);
diff --git a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
index a207aa12b2c..05fcc47e3aa 100644
--- a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
+++ b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
@@ -2,7 +2,7 @@
 export const bytecode = Uint8Array.from([
   31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 210, 85, 78, 67, 81, 24, 133, 209, 226, 238, 238, 238, 238, 238, 165, 148, 82,
   102, 193, 252, 135, 64, 232, 78, 87, 147, 114, 147, 147, 5, 47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241,
-  115, 236, 228, 111, 237, 181, 178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 135, 189, 236, 99, 63, 7,
+  115, 236, 226, 111, 237, 181, 178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 135, 189, 236, 99, 63, 7,
   56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60, 23, 184, 200, 37, 46,
   115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187, 220, 227, 62, 15, 120, 200, 35, 30, 243, 132, 167,
   60, 227, 57, 47, 120, 201, 43, 94, 243, 134, 183, 188, 227, 61, 31, 248, 200, 39, 62, 243, 133, 175, 77, 59, 230, 123,
@@ -11,7 +11,7 @@ export const bytecode = Uint8Array.from([
   210, 72, 250, 72, 27, 233, 34, 77, 164, 135, 180, 144, 14, 210, 64, 246, 95, 46, 212, 119, 207, 230, 217, 59, 91, 103,
   231, 108, 156, 125, 183, 237, 186, 107, 207, 125, 59, 30, 218, 239, 216, 110, 167, 246, 58, 183, 211, 165, 125, 174,
   237, 114, 107, 143, 123, 59, 60, 186, 255, 179, 187, 191, 186, 115, 209, 125, 75, 238, 90, 118, 207, 138, 59, 54, 110,
-  214, 184, 91, 161, 233, 158, 255, 190, 63, 165, 188, 93, 151, 233, 3, 0, 0,
+  214, 184, 91, 161, 233, 158, 255, 190, 63, 71, 59, 68, 130, 233, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 4dc7df03599..f40046acad6 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -37,6 +37,7 @@ p256 = { version = "0.11.0", features = [
     "arithmetic",
 ] }
 
+libaes = "0.7.0"
 
 [features]
 default = ["bn254"]
diff --git a/acvm-repo/blackbox_solver/src/aes128.rs b/acvm-repo/blackbox_solver/src/aes128.rs
new file mode 100644
index 00000000000..a4c6a228744
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/aes128.rs
@@ -0,0 +1,12 @@
+use crate::BlackBoxResolutionError;
+use libaes::Cipher;
+
+pub fn aes128_encrypt(
+    inputs: &[u8],
+    iv: [u8; 16],
+    key: [u8; 16],
+) -> Result<Vec<u8>, BlackBoxResolutionError> {
+    let cipher = Cipher::new_128(&key);
+    let encrypted = cipher.cbc_encrypt(&iv, inputs);
+    Ok(encrypted)
+}
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index fab67467d9a..3403b0fe232 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -24,10 +24,10 @@ pub trait BlackBoxFunctionSolver {
         inputs: &[FieldElement],
         domain_separator: u32,
     ) -> Result<FieldElement, BlackBoxResolutionError>;
-    fn fixed_base_scalar_mul(
+    fn multi_scalar_mul(
         &self,
-        low: &FieldElement,
-        high: &FieldElement,
+        points: &[FieldElement],
+        scalars: &[FieldElement],
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
     fn ec_add(
         &self,
@@ -78,12 +78,12 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
     ) -> Result<FieldElement, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::PedersenHash))
     }
-    fn fixed_base_scalar_mul(
+    fn multi_scalar_mul(
         &self,
-        _low: &FieldElement,
-        _high: &FieldElement,
+        _points: &[FieldElement],
+        _scalars: &[FieldElement],
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::FixedBaseScalarMul))
+        Err(Self::fail(BlackBoxFunc::MultiScalarMul))
     }
     fn ec_add(
         &self,
diff --git a/acvm-repo/blackbox_solver/src/lib.rs b/acvm-repo/blackbox_solver/src/lib.rs
index 0f57f2ce7da..a68b52a2a62 100644
--- a/acvm-repo/blackbox_solver/src/lib.rs
+++ b/acvm-repo/blackbox_solver/src/lib.rs
@@ -10,11 +10,13 @@
 use acir::BlackBoxFunc;
 use thiserror::Error;
 
+mod aes128;
 mod bigint;
 mod curve_specific_solver;
 mod ecdsa;
 mod hash;
 
+pub use aes128::aes128_encrypt;
 pub use bigint::BigIntSolver;
 pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver};
 pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
diff --git a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
new file mode 100644
index 00000000000..3f6d2ac86c1
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
@@ -0,0 +1,241 @@
+// TODO(https://github.com/noir-lang/noir/issues/4932): rename this file to something more generic
+use ark_ec::AffineRepr;
+use ark_ff::MontConfig;
+use num_bigint::BigUint;
+
+use acir::{BlackBoxFunc, FieldElement};
+
+use crate::BlackBoxResolutionError;
+
+/// Performs multi scalar multiplication of points with scalars.
+pub fn multi_scalar_mul(
+    points: &[FieldElement],
+    scalars: &[FieldElement],
+) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+    if points.len() != scalars.len() {
+        return Err(BlackBoxResolutionError::Failed(
+            BlackBoxFunc::MultiScalarMul,
+            "Points and scalars must have the same length".to_string(),
+        ));
+    }
+
+    let mut output_point = grumpkin::SWAffine::zero();
+
+    for i in (0..points.len()).step_by(2) {
+        let point = create_point(points[i], points[i + 1])
+            .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::MultiScalarMul, e))?;
+
+        let scalar_low: u128 = scalars[i].try_into_u128().ok_or_else(|| {
+            BlackBoxResolutionError::Failed(
+                BlackBoxFunc::MultiScalarMul,
+                format!("Limb {} is not less than 2^128", scalars[i].to_hex()),
+            )
+        })?;
+
+        let scalar_high: u128 = scalars[i + 1].try_into_u128().ok_or_else(|| {
+            BlackBoxResolutionError::Failed(
+                BlackBoxFunc::MultiScalarMul,
+                format!("Limb {} is not less than 2^128", scalars[i + 1].to_hex()),
+            )
+        })?;
+
+        let mut bytes = scalar_high.to_be_bytes().to_vec();
+        bytes.extend_from_slice(&scalar_low.to_be_bytes());
+
+        // Check if this is smaller than the grumpkin modulus
+        let grumpkin_integer = BigUint::from_bytes_be(&bytes);
+
+        if grumpkin_integer >= grumpkin::FrConfig::MODULUS.into() {
+            return Err(BlackBoxResolutionError::Failed(
+                BlackBoxFunc::MultiScalarMul,
+                format!("{} is not a valid grumpkin scalar", grumpkin_integer.to_str_radix(16)),
+            ));
+        }
+
+        let iteration_output_point =
+            grumpkin::SWAffine::from(point.mul_bigint(grumpkin_integer.to_u64_digits()));
+
+        output_point = grumpkin::SWAffine::from(output_point + iteration_output_point);
+    }
+
+    if let Some((out_x, out_y)) = output_point.xy() {
+        Ok((FieldElement::from_repr(*out_x), FieldElement::from_repr(*out_y)))
+    } else {
+        Ok((FieldElement::zero(), FieldElement::zero()))
+    }
+}
+
+pub fn embedded_curve_add(
+    input1_x: FieldElement,
+    input1_y: FieldElement,
+    input2_x: FieldElement,
+    input2_y: FieldElement,
+) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+    let point1 = create_point(input1_x, input1_y)
+        .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
+    let point2 = create_point(input2_x, input2_y)
+        .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
+    let res = grumpkin::SWAffine::from(point1 + point2);
+    if let Some((res_x, res_y)) = res.xy() {
+        Ok((FieldElement::from_repr(*res_x), FieldElement::from_repr(*res_y)))
+    } else {
+        Err(BlackBoxResolutionError::Failed(
+            BlackBoxFunc::EmbeddedCurveAdd,
+            "Point is not on curve".to_string(),
+        ))
+    }
+}
+
+fn create_point(x: FieldElement, y: FieldElement) -> Result<grumpkin::SWAffine, String> {
+    let point = grumpkin::SWAffine::new_unchecked(x.into_repr(), y.into_repr());
+    if !point.is_on_curve() {
+        return Err(format!("Point ({}, {}) is not on curve", x.to_hex(), y.to_hex()));
+    };
+    if !point.is_in_correct_subgroup_assuming_on_curve() {
+        return Err(format!("Point ({}, {}) is not in correct subgroup", x.to_hex(), y.to_hex()));
+    };
+    Ok(point)
+}
+
+#[cfg(test)]
+mod tests {
+    use ark_ff::BigInteger;
+
+    use super::*;
+
+    fn get_generator() -> [FieldElement; 2] {
+        let generator = grumpkin::SWAffine::generator();
+        let generator_x = FieldElement::from_repr(*generator.x().unwrap());
+        let generator_y = FieldElement::from_repr(*generator.y().unwrap());
+        [generator_x, generator_y]
+    }
+
+    #[test]
+    fn smoke_test() -> Result<(), BlackBoxResolutionError> {
+        // We check that multiplying 1 by generator results in the generator
+        let generator = get_generator();
+
+        let res = multi_scalar_mul(&generator, &[FieldElement::one(), FieldElement::zero()])?;
+
+        assert_eq!(generator[0], res.0);
+        assert_eq!(generator[1], res.1);
+        Ok(())
+    }
+
+    #[test]
+    fn low_high_smoke_test() -> Result<(), BlackBoxResolutionError> {
+        let points = get_generator();
+        let scalars = [FieldElement::one(), FieldElement::from(2u128)];
+
+        let res = multi_scalar_mul(&points, &scalars)?;
+        let x = "0702ab9c7038eeecc179b4f209991bcb68c7cb05bf4c532d804ccac36199c9a9";
+        let y = "23f10e9e43a3ae8d75d24154e796aae12ae7af546716e8f81a2564f1b5814130";
+
+        assert_eq!(x, res.0.to_hex());
+        assert_eq!(y, res.1.to_hex());
+        Ok(())
+    }
+
+    #[test]
+    fn rejects_invalid_scalar_limbs() {
+        let points = get_generator();
+
+        let max_limb = FieldElement::from(u128::MAX);
+        let invalid_limb = max_limb + FieldElement::one();
+
+        let expected_error = Err(BlackBoxResolutionError::Failed(
+            BlackBoxFunc::MultiScalarMul,
+            "Limb 0000000000000000000000000000000100000000000000000000000000000000 is not less than 2^128".into(),
+        ));
+
+        let res = multi_scalar_mul(&points, &[FieldElement::one(), invalid_limb]);
+        assert_eq!(res, expected_error);
+
+        let res = multi_scalar_mul(&points, &[invalid_limb, FieldElement::one()]);
+        assert_eq!(res, expected_error);
+    }
+
+    #[test]
+    fn rejects_grumpkin_modulus() {
+        let x = grumpkin::FrConfig::MODULUS.to_bytes_be();
+
+        let low = FieldElement::from_be_bytes_reduce(&x[16..32]);
+        let high = FieldElement::from_be_bytes_reduce(&x[0..16]);
+
+        let res = multi_scalar_mul(&get_generator(), &[low, high]);
+
+        assert_eq!(
+            res,
+            Err(BlackBoxResolutionError::Failed(
+                BlackBoxFunc::MultiScalarMul,
+                "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47 is not a valid grumpkin scalar".into(),
+            ))
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_point() {
+        let invalid_point_x = FieldElement::one();
+        let invalid_point_y = FieldElement::one();
+        let valid_scalar_low = FieldElement::zero();
+        let valid_scalar_high = FieldElement::zero();
+
+        let res = multi_scalar_mul(
+            &[invalid_point_x, invalid_point_y],
+            &[valid_scalar_low, valid_scalar_high],
+        );
+
+        assert_eq!(
+            res,
+            Err(BlackBoxResolutionError::Failed(
+                BlackBoxFunc::MultiScalarMul,
+                "Point (0000000000000000000000000000000000000000000000000000000000000001, 0000000000000000000000000000000000000000000000000000000000000001) is not on curve".into(),
+            ))
+        );
+    }
+
+    #[test]
+    fn throws_on_args_length_mismatch() {
+        let points = get_generator();
+        let scalars = [FieldElement::from(2u128)];
+
+        let res = multi_scalar_mul(&points, &scalars);
+
+        assert_eq!(
+            res,
+            Err(BlackBoxResolutionError::Failed(
+                BlackBoxFunc::MultiScalarMul,
+                "Points and scalars must have the same length".into(),
+            ))
+        );
+    }
+
+    #[test]
+    fn rejects_addition_of_points_not_in_curve() {
+        let x = FieldElement::from(1u128);
+        let y = FieldElement::from(2u128);
+
+        let res = embedded_curve_add(x, y, x, y);
+
+        assert_eq!(
+            res,
+            Err(BlackBoxResolutionError::Failed(
+                BlackBoxFunc::EmbeddedCurveAdd,
+                "Point (0000000000000000000000000000000000000000000000000000000000000001, 0000000000000000000000000000000000000000000000000000000000000002) is not on curve".into(),
+            ))
+        );
+    }
+
+    #[test]
+    fn output_of_msm_matches_add() -> Result<(), BlackBoxResolutionError> {
+        let points = get_generator();
+        let scalars = [FieldElement::from(2u128), FieldElement::zero()];
+
+        let msm_res = multi_scalar_mul(&points, &scalars)?;
+        let add_res = embedded_curve_add(points[0], points[1], points[0], points[1])?;
+
+        assert_eq!(msm_res.0, add_res.0);
+        assert_eq!(msm_res.1, add_res.1);
+        Ok(())
+    }
+}
diff --git a/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs b/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
deleted file mode 100644
index cd91c290f49..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use ark_ec::AffineRepr;
-use ark_ff::MontConfig;
-use num_bigint::BigUint;
-
-use acir::{BlackBoxFunc, FieldElement};
-
-use crate::BlackBoxResolutionError;
-
-pub fn fixed_base_scalar_mul(
-    low: &FieldElement,
-    high: &FieldElement,
-) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-    let low: u128 = low.try_into_u128().ok_or_else(|| {
-        BlackBoxResolutionError::Failed(
-            BlackBoxFunc::FixedBaseScalarMul,
-            format!("Limb {} is not less than 2^128", low.to_hex()),
-        )
-    })?;
-
-    let high: u128 = high.try_into_u128().ok_or_else(|| {
-        BlackBoxResolutionError::Failed(
-            BlackBoxFunc::FixedBaseScalarMul,
-            format!("Limb {} is not less than 2^128", high.to_hex()),
-        )
-    })?;
-
-    let mut bytes = high.to_be_bytes().to_vec();
-    bytes.extend_from_slice(&low.to_be_bytes());
-
-    // Check if this is smaller than the grumpkin modulus
-    let grumpkin_integer = BigUint::from_bytes_be(&bytes);
-
-    if grumpkin_integer >= grumpkin::FrConfig::MODULUS.into() {
-        return Err(BlackBoxResolutionError::Failed(
-            BlackBoxFunc::FixedBaseScalarMul,
-            format!("{} is not a valid grumpkin scalar", grumpkin_integer.to_str_radix(16)),
-        ));
-    }
-
-    let result = grumpkin::SWAffine::from(
-        grumpkin::SWAffine::generator().mul_bigint(grumpkin_integer.to_u64_digits()),
-    );
-    if let Some((res_x, res_y)) = result.xy() {
-        Ok((FieldElement::from_repr(*res_x), FieldElement::from_repr(*res_y)))
-    } else {
-        Ok((FieldElement::zero(), FieldElement::zero()))
-    }
-}
-
-fn create_point(x: FieldElement, y: FieldElement) -> Result<grumpkin::SWAffine, String> {
-    let point = grumpkin::SWAffine::new_unchecked(x.into_repr(), y.into_repr());
-    if !point.is_on_curve() {
-        return Err(format!("Point ({}, {}) is not on curve", x.to_hex(), y.to_hex()));
-    };
-    if !point.is_in_correct_subgroup_assuming_on_curve() {
-        return Err(format!("Point ({}, {}) is not in correct subgroup", x.to_hex(), y.to_hex()));
-    };
-    Ok(point)
-}
-
-pub fn embedded_curve_add(
-    input1_x: FieldElement,
-    input1_y: FieldElement,
-    input2_x: FieldElement,
-    input2_y: FieldElement,
-) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-    let point1 = create_point(input1_x, input1_y)
-        .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
-    let point2 = create_point(input2_x, input2_y)
-        .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
-    let res = grumpkin::SWAffine::from(point1 + point2);
-    if let Some((res_x, res_y)) = res.xy() {
-        Ok((FieldElement::from_repr(*res_x), FieldElement::from_repr(*res_y)))
-    } else {
-        Err(BlackBoxResolutionError::Failed(
-            BlackBoxFunc::EmbeddedCurveAdd,
-            "Point is not on curve".to_string(),
-        ))
-    }
-}
-
-#[cfg(test)]
-mod grumpkin_fixed_base_scalar_mul {
-    use ark_ff::BigInteger;
-
-    use super::*;
-
-    #[test]
-    fn smoke_test() -> Result<(), BlackBoxResolutionError> {
-        let input = FieldElement::one();
-
-        let res = fixed_base_scalar_mul(&input, &FieldElement::zero())?;
-        let x = "0000000000000000000000000000000000000000000000000000000000000001";
-        let y = "0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c";
-
-        assert_eq!(x, res.0.to_hex());
-        assert_eq!(y, res.1.to_hex());
-        Ok(())
-    }
-
-    #[test]
-    fn low_high_smoke_test() -> Result<(), BlackBoxResolutionError> {
-        let low = FieldElement::one();
-        let high = FieldElement::from(2u128);
-
-        let res = fixed_base_scalar_mul(&low, &high)?;
-        let x = "0702ab9c7038eeecc179b4f209991bcb68c7cb05bf4c532d804ccac36199c9a9";
-        let y = "23f10e9e43a3ae8d75d24154e796aae12ae7af546716e8f81a2564f1b5814130";
-
-        assert_eq!(x, res.0.to_hex());
-        assert_eq!(y, res.1.to_hex());
-        Ok(())
-    }
-
-    #[test]
-    fn rejects_invalid_limbs() {
-        let max_limb = FieldElement::from(u128::MAX);
-        let invalid_limb = max_limb + FieldElement::one();
-
-        let expected_error = Err(BlackBoxResolutionError::Failed(
-            BlackBoxFunc::FixedBaseScalarMul,
-            "Limb 0000000000000000000000000000000100000000000000000000000000000000 is not less than 2^128".into(),
-        ));
-
-        let res = fixed_base_scalar_mul(&invalid_limb, &FieldElement::zero());
-        assert_eq!(res, expected_error);
-
-        let res = fixed_base_scalar_mul(&FieldElement::zero(), &invalid_limb);
-        assert_eq!(res, expected_error);
-    }
-
-    #[test]
-    fn rejects_grumpkin_modulus() {
-        let x = grumpkin::FrConfig::MODULUS.to_bytes_be();
-
-        let high = FieldElement::from_be_bytes_reduce(&x[0..16]);
-        let low = FieldElement::from_be_bytes_reduce(&x[16..32]);
-
-        let res = fixed_base_scalar_mul(&low, &high);
-
-        assert_eq!(
-            res,
-            Err(BlackBoxResolutionError::Failed(
-                BlackBoxFunc::FixedBaseScalarMul,
-                "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47 is not a valid grumpkin scalar".into(),
-            ))
-        );
-    }
-
-    #[test]
-    fn rejects_addition_of_points_not_in_curve() {
-        let x = FieldElement::from(1u128);
-        let y = FieldElement::from(2u128);
-
-        let res = embedded_curve_add(x, y, x, y);
-
-        assert_eq!(
-            res,
-            Err(BlackBoxResolutionError::Failed(
-                BlackBoxFunc::EmbeddedCurveAdd,
-                "Point (0000000000000000000000000000000000000000000000000000000000000001, 0000000000000000000000000000000000000000000000000000000000000002) is not on curve".into(),
-            ))
-        );
-    }
-}
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 25b10252a78..4cb51b59755 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -5,11 +5,11 @@
 use acir::{BlackBoxFunc, FieldElement};
 use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
-mod fixed_base_scalar_mul;
+mod embedded_curve_ops;
 mod poseidon2;
 mod wasm;
 
-pub use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
+pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use poseidon2::poseidon2_permutation;
 use wasm::Barretenberg;
 
@@ -89,12 +89,12 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
         })
     }
 
-    fn fixed_base_scalar_mul(
+    fn multi_scalar_mul(
         &self,
-        low: &FieldElement,
-        high: &FieldElement,
+        points: &[FieldElement],
+        scalars: &[FieldElement],
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        fixed_base_scalar_mul(low, high)
+        multi_scalar_mul(points, scalars)
     }
 
     fn ec_add(
diff --git a/acvm-repo/brillig/src/black_box.rs b/acvm-repo/brillig/src/black_box.rs
index 29861d0fd84..15abc19ed90 100644
--- a/acvm-repo/brillig/src/black_box.rs
+++ b/acvm-repo/brillig/src/black_box.rs
@@ -5,6 +5,13 @@ use serde::{Deserialize, Serialize};
 /// They are implemented as native functions in the VM.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlackBoxOp {
+    /// Encrypts a message using AES128.
+    AES128Encrypt {
+        inputs: HeapVector,
+        iv: HeapArray,
+        key: HeapArray,
+        outputs: HeapVector,
+    },
     /// Calculates the SHA256 hash of the inputs.
     Sha256 {
         message: HeapVector,
@@ -66,11 +73,11 @@ pub enum BlackBoxOp {
         domain_separator: MemoryAddress,
         output: MemoryAddress,
     },
-    /// Performs scalar multiplication over the embedded curve.
-    FixedBaseScalarMul {
-        low: MemoryAddress,
-        high: MemoryAddress,
-        result: HeapArray,
+    /// Performs multi scalar multiplication over the embedded curve.
+    MultiScalarMul {
+        points: HeapVector,
+        scalars: HeapVector,
+        outputs: HeapArray,
     },
     /// Performs addition over the embedded curve.
     EmbeddedCurveAdd {
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index 468fd88db45..a060aa83d41 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -52,6 +52,12 @@ pub struct HeapArray {
     pub size: usize,
 }
 
+impl Default for HeapArray {
+    fn default() -> Self {
+        Self { pointer: MemoryAddress(0), size: 0 }
+    }
+}
+
 /// A memory-sized vector passed starting from a Brillig memory location and with a memory-held size
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy)]
 pub struct HeapVector {
@@ -179,8 +185,7 @@ pub enum BrilligOpcode {
     BlackBox(BlackBoxOp),
     /// Used to denote execution failure, returning data after the offset
     Trap {
-        revert_data_offset: usize,
-        revert_data_size: usize,
+        revert_data: HeapArray,
     },
     /// Stop execution, returning data after the offset
     Stop {
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 19407da52db..c999b5bf330 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -2,8 +2,8 @@ use acir::brillig::{BlackBoxOp, HeapArray, HeapVector};
 use acir::{BlackBoxFunc, FieldElement};
 use acvm_blackbox_solver::BigIntSolver;
 use acvm_blackbox_solver::{
-    blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, keccakf1600,
-    sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
+    aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256,
+    keccakf1600, sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
 };
 
 use crate::memory::MemoryValue;
@@ -38,6 +38,25 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
     bigint_solver: &mut BigIntSolver,
 ) -> Result<(), BlackBoxResolutionError> {
     match op {
+        BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => {
+            let bb_func = black_box_function_from_op(op);
+
+            let inputs = to_u8_vec(read_heap_vector(memory, inputs));
+
+            let iv: [u8; 16] = to_u8_vec(read_heap_array(memory, iv)).try_into().map_err(|_| {
+                BlackBoxResolutionError::Failed(bb_func, "Invalid iv length".to_string())
+            })?;
+            let key: [u8; 16] =
+                to_u8_vec(read_heap_array(memory, key)).try_into().map_err(|_| {
+                    BlackBoxResolutionError::Failed(bb_func, "Invalid ley length".to_string())
+                })?;
+            let ciphertext = aes128_encrypt(&inputs, iv, key)?;
+
+            memory.write(outputs.size, ciphertext.len().into());
+            memory.write_slice(memory.read_ref(outputs.pointer), &to_value_vec(&ciphertext));
+
+            Ok(())
+        }
         BlackBoxOp::Sha256 { message, output } => {
             let message = to_u8_vec(read_heap_vector(memory, message));
             let bytes = sha256(message.as_slice())?;
@@ -136,10 +155,13 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             memory.write(*result, verified.into());
             Ok(())
         }
-        BlackBoxOp::FixedBaseScalarMul { low, high, result } => {
-            let low = memory.read(*low).try_into().unwrap();
-            let high = memory.read(*high).try_into().unwrap();
-            let (x, y) = solver.fixed_base_scalar_mul(&low, &high)?;
+        BlackBoxOp::MultiScalarMul { points, scalars, outputs: result } => {
+            let points: Vec<FieldElement> =
+                read_heap_vector(memory, points).iter().map(|x| x.try_into().unwrap()).collect();
+            let scalars: Vec<FieldElement> =
+                read_heap_vector(memory, scalars).iter().map(|x| x.try_into().unwrap()).collect();
+
+            let (x, y) = solver.multi_scalar_mul(&points, &scalars)?;
             memory.write_slice(memory.read_ref(result.pointer), &[x.into(), y.into()]);
             Ok(())
         }
@@ -278,6 +300,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
 
 fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
     match op {
+        BlackBoxOp::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt,
         BlackBoxOp::Sha256 { .. } => BlackBoxFunc::SHA256,
         BlackBoxOp::Blake2s { .. } => BlackBoxFunc::Blake2s,
         BlackBoxOp::Blake3 { .. } => BlackBoxFunc::Blake3,
@@ -288,7 +311,7 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::SchnorrVerify { .. } => BlackBoxFunc::SchnorrVerify,
         BlackBoxOp::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
         BlackBoxOp::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
-        BlackBoxOp::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
+        BlackBoxOp::MultiScalarMul { .. } => BlackBoxFunc::MultiScalarMul,
         BlackBoxOp::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
         BlackBoxOp::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
         BlackBoxOp::BigIntSub { .. } => BlackBoxFunc::BigIntSub,
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 75299670f94..7901c313596 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -305,8 +305,12 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 }
                 self.increment_program_counter()
             }
-            Opcode::Trap { revert_data_offset, revert_data_size } => {
-                self.trap(*revert_data_offset, *revert_data_size)
+            Opcode::Trap { revert_data } => {
+                if revert_data.size > 0 {
+                    self.trap(self.memory.read_ref(revert_data.pointer).0, revert_data.size)
+                } else {
+                    self.trap(0, 0)
+                }
             }
             Opcode::Stop { return_data_offset, return_data_size } => {
                 self.finish(*return_data_offset, *return_data_size)
@@ -715,7 +719,7 @@ mod tests {
 
         let jump_opcode = Opcode::Jump { location: 3 };
 
-        let trap_opcode = Opcode::Trap { revert_data_offset: 0, revert_data_size: 0 };
+        let trap_opcode = Opcode::Trap { revert_data: HeapArray::default() };
 
         let not_equal_cmp_opcode = Opcode::BinaryFieldOp {
             op: BinaryFieldOp::Equals,
diff --git a/aztec_macros/src/transforms/contract_interface.rs b/aztec_macros/src/transforms/contract_interface.rs
index 5f68ce98c8a..1afe0a30068 100644
--- a/aztec_macros/src/transforms/contract_interface.rs
+++ b/aztec_macros/src/transforms/contract_interface.rs
@@ -126,6 +126,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
                 target_contract: self.target_contract,
                 selector: {},
                 args: args_acc,
+                gas_opts: dep::aztec::context::gas::GasOpts::default(),
             }}",
             args, is_void, fn_selector,
         );
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index b5803d8ac9e..90563c6085c 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -1,6 +1,6 @@
 use convert_case::{Case, Casing};
 use noirc_errors::Span;
-use noirc_frontend::ast;
+use noirc_frontend::ast::{self, FunctionKind};
 use noirc_frontend::ast::{
     BlockExpression, ConstrainKind, ConstrainStatement, Expression, ExpressionKind,
     ForLoopStatement, ForRange, FunctionReturnType, Ident, Literal, NoirFunction, NoirStruct,
@@ -38,6 +38,7 @@ pub fn transform_function(
     let inputs_name = format!("{}ContextInputs", ty);
     let return_type_name = format!("{}CircuitPublicInputs", ty);
     let is_avm = ty == "Avm";
+    let is_private = ty == "Private";
 
     // Add check that msg sender equals this address and flag function as internal
     if is_internal {
@@ -102,11 +103,18 @@ pub fn transform_function(
         let return_type = create_return_type(&return_type_name);
         func.def.return_type = return_type;
         func.def.return_visibility = Visibility::Public;
+    } else {
+        func.def.return_visibility = Visibility::Public;
     }
 
     // Public functions should have unconstrained auto-inferred
     func.def.is_unconstrained = matches!(ty, "Public" | "Avm");
 
+    // Private functions need to be recursive
+    if is_private {
+        func.kind = FunctionKind::Recursive;
+    }
+
     Ok(())
 }
 
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 51fe4986845..609c88b92c2 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -1,12 +1,13 @@
 use std::collections::BTreeMap;
 
+use acvm::acir::circuit::ErrorSelector;
 use acvm::acir::native_types::Witness;
 use iter_extended::{btree_map, vecmap};
-use noirc_abi::{Abi, AbiParameter, AbiReturnType, AbiType, AbiValue};
+use noirc_abi::{Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue};
 use noirc_frontend::ast::Visibility;
 use noirc_frontend::{
     hir::Context,
-    hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern},
+    hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern, types::Type},
     macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
 };
@@ -20,12 +21,17 @@ pub(super) fn gen_abi(
     input_witnesses: Vec<Witness>,
     return_witnesses: Vec<Witness>,
     return_visibility: Visibility,
+    error_types: BTreeMap<ErrorSelector, Type>,
 ) -> Abi {
     let (parameters, return_type) = compute_function_abi(context, func_id);
     let param_witnesses = param_witnesses_from_abi_param(&parameters, input_witnesses);
     let return_type = return_type
         .map(|typ| AbiReturnType { abi_type: typ, visibility: return_visibility.into() });
-    Abi { parameters, return_type, param_witnesses, return_witnesses }
+    let error_types = error_types
+        .into_iter()
+        .map(|(selector, typ)| (selector, AbiErrorType::from_type(context, &typ)))
+        .collect();
+    Abi { parameters, return_type, param_witnesses, return_witnesses, error_types }
 }
 
 pub(super) fn compute_function_abi(
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index cd5a1c4a7fb..f18997d5d7f 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -529,6 +529,7 @@ pub fn compile_no_check(
         main_input_witnesses,
         main_return_witnesses,
         names,
+        error_types,
     } = create_program(
         program,
         options.show_ssa,
@@ -543,6 +544,7 @@ pub fn compile_no_check(
         main_input_witnesses,
         main_return_witnesses,
         visibility,
+        error_types,
     );
     let file_map = filter_relevant_files(&debug, &context.file_manager);
 
diff --git a/compiler/noirc_errors/Cargo.toml b/compiler/noirc_errors/Cargo.toml
index c9cb7e2709f..41b1cd0ff58 100644
--- a/compiler/noirc_errors/Cargo.toml
+++ b/compiler/noirc_errors/Cargo.toml
@@ -20,4 +20,4 @@ serde_with = "3.2.0"
 tracing.workspace = true
 flate2.workspace = true
 serde_json.workspace = true
-base64.workspace = true
\ No newline at end of file
+base64.workspace = true
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index ee047903743..d982d864d06 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -188,20 +188,20 @@ pub(crate) fn convert_black_box_call(
                 unreachable!("ICE: Schnorr verify expects two registers for the public key, an array for signature, an array for the message hash and one result register")
             }
         }
-        BlackBoxFunc::FixedBaseScalarMul => {
-            if let (
-                [BrilligVariable::SingleAddr(low), BrilligVariable::SingleAddr(high)],
-                [BrilligVariable::BrilligArray(result_array)],
-            ) = (function_arguments, function_results)
+        BlackBoxFunc::MultiScalarMul => {
+            if let ([points, scalars], [BrilligVariable::BrilligArray(outputs)]) =
+                (function_arguments, function_results)
             {
-                brillig_context.black_box_op_instruction(BlackBoxOp::FixedBaseScalarMul {
-                    low: low.address,
-                    high: high.address,
-                    result: result_array.to_heap_array(),
+                let points = convert_array_or_vector(brillig_context, points, bb_func);
+                let scalars = convert_array_or_vector(brillig_context, scalars, bb_func);
+                brillig_context.black_box_op_instruction(BlackBoxOp::MultiScalarMul {
+                    points: points.to_heap_vector(),
+                    scalars: scalars.to_heap_vector(),
+                    outputs: outputs.to_heap_array(),
                 });
             } else {
                 unreachable!(
-                    "ICE: FixedBaseScalarMul expects one register argument and one array result"
+                    "ICE: MultiScalarMul expects two register arguments and one array result"
                 )
             }
         }
@@ -401,6 +401,28 @@ pub(crate) fn convert_black_box_call(
                 unreachable!("ICE: Sha256Compression expects two array argument, one array result")
             }
         }
+        BlackBoxFunc::AES128Encrypt => {
+            if let (
+                [inputs, BrilligVariable::BrilligArray(iv), BrilligVariable::BrilligArray(key)],
+                [BrilligVariable::SingleAddr(out_len), outputs],
+            ) = (function_arguments, function_results)
+            {
+                let inputs = convert_array_or_vector(brillig_context, inputs, bb_func);
+                let outputs = convert_array_or_vector(brillig_context, outputs, bb_func);
+                let output_vec = outputs.to_heap_vector();
+                brillig_context.black_box_op_instruction(BlackBoxOp::AES128Encrypt {
+                    inputs: inputs.to_heap_vector(),
+                    iv: iv.to_heap_array(),
+                    key: key.to_heap_array(),
+                    outputs: output_vec,
+                });
+                brillig_context.mov_instruction(out_len.address, output_vec.size);
+                // Returns slice, so we need to allocate memory for it after the fact
+                brillig_context.increase_free_memory_pointer_instruction(output_vec.size);
+            } else {
+                unreachable!("ICE: AES128Encrypt expects three array arguments, one array result")
+            }
+        }
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index e10127d8f28..f660c8e0b7a 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -5,7 +5,7 @@ use crate::brillig::brillig_ir::{
     BrilligBinaryOp, BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 use crate::ssa::ir::dfg::CallStack;
-use crate::ssa::ir::instruction::{ConstrainError, UserDefinedConstrainError};
+use crate::ssa::ir::instruction::ConstrainError;
 use crate::ssa::ir::{
     basic_block::{BasicBlock, BasicBlockId},
     dfg::DataFlowGraph,
@@ -248,34 +248,6 @@ impl<'block> BrilligBlock<'block> {
                 self.convert_ssa_binary(binary, dfg, result_var);
             }
             Instruction::Constrain(lhs, rhs, assert_message) => {
-                let (has_revert_data, static_assert_message) = if let Some(error) = assert_message {
-                    match error.as_ref() {
-                        ConstrainError::Intrinsic(string) => (false, Some(string.clone())),
-                        ConstrainError::UserDefined(UserDefinedConstrainError::Static(string)) => {
-                            (true, Some(string.clone()))
-                        }
-                        ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
-                            call_instruction,
-                        )) => {
-                            let Instruction::Call { func, arguments } = call_instruction else {
-                                unreachable!("expected a call instruction")
-                            };
-
-                            let Value::Function(func_id) = &dfg[*func] else {
-                                unreachable!("expected a function value")
-                            };
-
-                            self.convert_ssa_function_call(*func_id, arguments, dfg, &[]);
-
-                            // Dynamic assert messages are handled in the generated function call.
-                            // We then don't need to attach one to the constrain instruction.
-                            (false, None)
-                        }
-                    }
-                } else {
-                    (false, None)
-                };
-
                 let condition = SingleAddrVariable {
                     address: self.brillig_context.allocate_register(),
                     bit_size: 1,
@@ -286,11 +258,27 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                     condition,
                 );
-                if has_revert_data {
-                    self.brillig_context
-                        .codegen_constrain_with_revert_data(condition, static_assert_message);
-                } else {
-                    self.brillig_context.codegen_constrain(condition, static_assert_message);
+                match assert_message {
+                    Some(ConstrainError::UserDefined(selector, values)) => {
+                        let payload_values =
+                            vecmap(values, |value| self.convert_ssa_value(*value, dfg));
+                        let payload_as_params = vecmap(values, |value| {
+                            let value_type = dfg.type_of_value(*value);
+                            FunctionContext::ssa_type_to_parameter(&value_type)
+                        });
+                        self.brillig_context.codegen_constrain_with_revert_data(
+                            condition,
+                            payload_values,
+                            payload_as_params,
+                            selector.as_u64(),
+                        );
+                    }
+                    Some(ConstrainError::Intrinsic(message)) => {
+                        self.brillig_context.codegen_constrain(condition, Some(message.clone()));
+                    }
+                    None => {
+                        self.brillig_context.codegen_constrain(condition, None);
+                    }
                 }
                 self.brillig_context.deallocate_single_addr(condition);
             }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 7e37e1da434..fadcdb22c15 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -130,7 +130,7 @@ pub(crate) mod tests {
     use std::vec;
 
     use acvm::acir::brillig::{
-        ForeignCallParam, ForeignCallResult, HeapVector, MemoryAddress, ValueOrArray,
+        ForeignCallParam, ForeignCallResult, HeapArray, HeapVector, MemoryAddress, ValueOrArray,
     };
     use acvm::brillig_vm::brillig::HeapValueType;
     use acvm::brillig_vm::{VMStatus, VM};
@@ -167,10 +167,10 @@ pub(crate) mod tests {
         ) -> Result<FieldElement, BlackBoxResolutionError> {
             Ok(6_u128.into())
         }
-        fn fixed_base_scalar_mul(
+        fn multi_scalar_mul(
             &self,
-            _low: &FieldElement,
-            _high: &FieldElement,
+            _points: &[FieldElement],
+            _scalars: &[FieldElement],
         ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
             Ok((4_u128.into(), 5_u128.into()))
         }
@@ -270,7 +270,7 @@ pub(crate) mod tests {
         // uses unresolved jumps which requires a block to be constructed in SSA and
         // we don't need this for Brillig IR tests
         context.push_opcode(BrilligOpcode::JumpIf { condition: r_equality, location: 8 });
-        context.push_opcode(BrilligOpcode::Trap { revert_data_offset: 0, revert_data_size: 0 });
+        context.push_opcode(BrilligOpcode::Trap { revert_data: HeapArray::default() });
 
         context.stop_instruction();
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index 8a4f469f5c9..dee6c6076f4 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -29,7 +29,9 @@ pub(crate) struct GeneratedBrillig {
 /// It includes the bytecode of the function and all the metadata that allows linking with other functions.
 pub(crate) struct BrilligArtifact {
     pub(crate) byte_code: Vec<BrilligOpcode>,
-    /// A map of bytecode positions to assertion messages
+    /// A map of bytecode positions to assertion messages.
+    /// Some error messages (compiler intrinsics) are not emitted via revert data,
+    /// instead, they are handled externally so they don't add size to user programs.
     pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
     /// The set of jumps that need to have their locations
     /// resolved.
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index f8f39f03df4..d9109646338 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -1,7 +1,9 @@
-use acvm::acir::brillig::MemoryAddress;
+use acvm::acir::brillig::{HeapArray, MemoryAddress};
 
 use super::{
-    brillig_variable::SingleAddrVariable, BrilligBinaryOp, BrilligContext, ReservedRegisters,
+    artifact::BrilligParameter,
+    brillig_variable::{BrilligVariable, SingleAddrVariable},
+    BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 
 impl BrilligContext {
@@ -144,25 +146,62 @@ impl BrilligContext {
     pub(crate) fn codegen_constrain_with_revert_data(
         &mut self,
         condition: SingleAddrVariable,
-        assert_message: Option<String>,
+        revert_data_items: Vec<BrilligVariable>,
+        revert_data_types: Vec<BrilligParameter>,
+        error_selector: u64,
     ) {
         assert!(condition.bit_size == 1);
 
         self.codegen_if_not(condition.address, |ctx| {
-            let (revert_data_offset, revert_data_size) =
-                if let Some(assert_message) = assert_message {
-                    let bytes = assert_message.as_bytes();
-                    for (i, byte) in bytes.iter().enumerate() {
-                        ctx.const_instruction(
-                            SingleAddrVariable::new(MemoryAddress(i), 8),
-                            (*byte as usize).into(),
+            let revert_data = HeapArray {
+                pointer: ctx.allocate_register(),
+                // + 1 due to the revert data id being the first item returned
+                size: BrilligContext::flattened_tuple_size(&revert_data_types) + 1,
+            };
+            ctx.codegen_allocate_fixed_length_array(revert_data.pointer, revert_data.size);
+
+            let current_revert_data_pointer = ctx.allocate_register();
+            ctx.mov_instruction(current_revert_data_pointer, revert_data.pointer);
+            let revert_data_id =
+                ctx.make_usize_constant_instruction((error_selector as u128).into());
+            ctx.store_instruction(current_revert_data_pointer, revert_data_id.address);
+
+            ctx.codegen_usize_op_in_place(current_revert_data_pointer, BrilligBinaryOp::Add, 1);
+            for (revert_variable, revert_param) in
+                revert_data_items.into_iter().zip(revert_data_types.into_iter())
+            {
+                let flattened_size = BrilligContext::flattened_size(&revert_param);
+                match revert_param {
+                    BrilligParameter::SingleAddr(_) => {
+                        ctx.store_instruction(
+                            current_revert_data_pointer,
+                            revert_variable.extract_single_addr().address,
+                        );
+                    }
+                    BrilligParameter::Array(item_type, item_count) => {
+                        let variable_pointer = revert_variable.extract_array().pointer;
+
+                        ctx.flatten_array(
+                            &item_type,
+                            item_count,
+                            current_revert_data_pointer,
+                            variable_pointer,
                         );
                     }
-                    (0, bytes.len())
-                } else {
-                    (0, 0)
-                };
-            ctx.trap_instruction(revert_data_offset, revert_data_size);
+                    BrilligParameter::Slice(_, _) => {
+                        unimplemented!("Slices are not supported as revert data")
+                    }
+                }
+                ctx.codegen_usize_op_in_place(
+                    current_revert_data_pointer,
+                    BrilligBinaryOp::Add,
+                    flattened_size,
+                );
+            }
+            ctx.trap_instruction(revert_data);
+            ctx.deallocate_register(revert_data.pointer);
+            ctx.deallocate_register(current_revert_data_pointer);
+            ctx.deallocate_single_addr(revert_data_id);
         });
     }
 
@@ -176,7 +215,7 @@ impl BrilligContext {
         assert!(condition.bit_size == 1);
 
         self.codegen_if_not(condition.address, |ctx| {
-            ctx.trap_instruction(0, 0);
+            ctx.trap_instruction(HeapArray::default());
             if let Some(assert_message) = assert_message {
                 ctx.obj.add_assert_message_to_last_opcode(assert_message);
             }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 41a6d1873e4..667ccf6ddbe 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -114,13 +114,8 @@ impl DebugShow {
     }
 
     /// Emits a `trap` instruction.
-    pub(crate) fn trap_instruction(&self, revert_data_offset: usize, revert_data_size: usize) {
-        debug_println!(
-            self.enable_debug_trace,
-            "  TRAP {}..{}",
-            revert_data_offset,
-            revert_data_offset + revert_data_size
-        );
+    pub(crate) fn trap_instruction(&self, revert_data: HeapArray) {
+        debug_println!(self.enable_debug_trace, "  TRAP {}", revert_data);
     }
 
     /// Emits a `mov` instruction.
@@ -271,6 +266,16 @@ impl DebugShow {
     /// Debug function for black_box_op
     pub(crate) fn black_box_op_instruction(&self, op: &BlackBoxOp) {
         match op {
+            BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  AES128 ENCRYPT {} {} {}  -> {}",
+                    inputs,
+                    iv,
+                    key,
+                    outputs
+                );
+            }
             BlackBoxOp::Sha256 { message, output } => {
                 debug_println!(self.enable_debug_trace, "  SHA256 {} -> {}", message, output);
             }
@@ -320,13 +325,13 @@ impl DebugShow {
                     result
                 );
             }
-            BlackBoxOp::FixedBaseScalarMul { low, high, result } => {
+            BlackBoxOp::MultiScalarMul { points, scalars, outputs } => {
                 debug_println!(
                     self.enable_debug_trace,
-                    "  FIXED_BASE_SCALAR_MUL {} {} -> {}",
-                    low,
-                    high,
-                    result
+                    "  MULTI_SCALAR_MUL {} {} -> {}",
+                    points,
+                    scalars,
+                    outputs
                 );
             }
             BlackBoxOp::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, result } => {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 88cf987325d..732bd3cbc59 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -164,7 +164,7 @@ impl BrilligContext {
     }
 
     /// Computes the size of a parameter if it was flattened
-    fn flattened_size(param: &BrilligParameter) -> usize {
+    pub(super) fn flattened_size(param: &BrilligParameter) -> usize {
         match param {
             BrilligParameter::SingleAddr(_) => 1,
             BrilligParameter::Array(item_types, item_count)
@@ -176,7 +176,7 @@ impl BrilligContext {
     }
 
     /// Computes the size of a parameter if it was flattened
-    fn flattened_tuple_size(tuple: &[BrilligParameter]) -> usize {
+    pub(super) fn flattened_tuple_size(tuple: &[BrilligParameter]) -> usize {
         tuple.iter().map(BrilligContext::flattened_size).sum()
     }
 
@@ -369,7 +369,7 @@ impl BrilligContext {
     }
 
     // Flattens an array by recursively copying nested arrays and regular items.
-    fn flatten_array(
+    pub(super) fn flatten_array(
         &mut self,
         item_type: &[BrilligParameter],
         item_count: usize,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index dc160ce6a66..5d2430208e4 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -1,6 +1,6 @@
 use acvm::{
     acir::brillig::{
-        BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapValueType, MemoryAddress,
+        BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapArray, HeapValueType, MemoryAddress,
         Opcode as BrilligOpcode, ValueOrArray,
     },
     FieldElement,
@@ -460,10 +460,10 @@ impl BrilligContext {
         });
     }
 
-    pub(super) fn trap_instruction(&mut self, revert_data_offset: usize, revert_data_size: usize) {
-        self.debug_show.trap_instruction(revert_data_offset, revert_data_size);
+    pub(super) fn trap_instruction(&mut self, revert_data: HeapArray) {
+        self.debug_show.trap_instruction(revert_data);
 
-        self.push_opcode(BrilligOpcode::Trap { revert_data_offset, revert_data_size });
+        self.push_opcode(BrilligOpcode::Trap { revert_data });
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index b3e838e708e..1e922060100 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -7,7 +7,7 @@
 //! An Error of the former is a user Error
 //!
 //! An Error of the latter is an error in the implementation of the compiler
-use acvm::{acir::native_types::Expression, FieldElement};
+use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic};
 use thiserror::Error;
@@ -17,13 +17,6 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, PartialEq, Eq, Clone, Error)]
 pub enum RuntimeError {
-    #[error("{}", format_failed_constraint(.assert_message))]
-    FailedConstraint {
-        lhs: Box<Expression>,
-        rhs: Box<Expression>,
-        call_stack: CallStack,
-        assert_message: Option<String>,
-    },
     #[error(transparent)]
     InternalError(#[from] InternalError),
     #[error("Index out of bounds, array has size {array_size}, but index was {index}")]
@@ -52,16 +45,6 @@ pub enum RuntimeError {
     UnconstrainedOracleReturnToConstrained { call_stack: CallStack },
 }
 
-// We avoid showing the actual lhs and rhs since most of the time they are just 0
-// and 1 respectively. This would confuse users if a constraint such as
-// assert(foo < bar) fails with "failed constraint: 0 = 1."
-fn format_failed_constraint(message: &Option<String>) -> String {
-    match message {
-        Some(message) => format!("Failed constraint: '{message}'"),
-        None => "Failed constraint".to_owned(),
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum SsaReport {
     Warning(InternalWarning),
@@ -129,7 +112,6 @@ impl RuntimeError {
                 | InternalError::UndeclaredAcirVar { call_stack }
                 | InternalError::Unexpected { call_stack, .. },
             )
-            | RuntimeError::FailedConstraint { call_stack, .. }
             | RuntimeError::IndexOutOfBounds { call_stack, .. }
             | RuntimeError::InvalidRangeConstraint { call_stack, .. }
             | RuntimeError::TypeConversion { call_stack, .. }
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index a9525d3e83c..69e5f6ddfcc 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -7,12 +7,13 @@
 //! This module heavily borrows from Cranelift
 #![allow(dead_code)]
 
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
 
 use crate::errors::{RuntimeError, SsaReport};
 use acvm::acir::{
     circuit::{
-        brillig::BrilligBytecode, Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs,
+        brillig::BrilligBytecode, Circuit, ErrorSelector, ExpressionWidth, Program as AcirProgram,
+        PublicInputs,
     },
     native_types::Witness,
 };
@@ -20,10 +21,16 @@ use acvm::acir::{
 use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
 
 use noirc_frontend::ast::Visibility;
-use noirc_frontend::{hir_def::function::FunctionSignature, monomorphization::ast::Program};
+use noirc_frontend::{
+    hir_def::{function::FunctionSignature, types::Type as HirType},
+    monomorphization::ast::Program,
+};
 use tracing::{span, Level};
 
-use self::{acir_gen::GeneratedAcir, ssa_gen::Ssa};
+use self::{
+    acir_gen::{Artifacts, GeneratedAcir},
+    ssa_gen::Ssa,
+};
 
 mod acir_gen;
 pub(super) mod function_builder;
@@ -42,7 +49,7 @@ pub(crate) fn optimize_into_acir(
     print_brillig_trace: bool,
     force_brillig_output: bool,
     print_timings: bool,
-) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
+) -> Result<Artifacts, RuntimeError> {
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
     let ssa_gen_span_guard = ssa_gen_span.enter();
     let ssa = SsaBuilder::new(program, print_passes, force_brillig_output, print_timings)?
@@ -100,10 +107,14 @@ pub struct SsaProgramArtifact {
     pub main_input_witnesses: Vec<Witness>,
     pub main_return_witnesses: Vec<Witness>,
     pub names: Vec<String>,
+    pub error_types: BTreeMap<ErrorSelector, HirType>,
 }
 
 impl SsaProgramArtifact {
-    fn new(unconstrained_functions: Vec<BrilligBytecode>) -> Self {
+    fn new(
+        unconstrained_functions: Vec<BrilligBytecode>,
+        error_types: BTreeMap<ErrorSelector, HirType>,
+    ) -> Self {
         let program = AcirProgram { functions: Vec::default(), unconstrained_functions };
         Self {
             program,
@@ -112,6 +123,7 @@ impl SsaProgramArtifact {
             main_input_witnesses: Vec::default(),
             main_return_witnesses: Vec::default(),
             names: Vec::default(),
+            error_types,
         }
     }
 
@@ -146,7 +158,7 @@ pub fn create_program(
     let func_sigs = program.function_signatures.clone();
 
     let recursive = program.recursive;
-    let (generated_acirs, generated_brillig) = optimize_into_acir(
+    let (generated_acirs, generated_brillig, error_types) = optimize_into_acir(
         program,
         enable_ssa_logging,
         enable_brillig_logging,
@@ -159,7 +171,7 @@ pub fn create_program(
         "The generated ACIRs should match the supplied function signatures"
     );
 
-    let mut program_artifact = SsaProgramArtifact::new(generated_brillig);
+    let mut program_artifact = SsaProgramArtifact::new(generated_brillig, error_types);
     // For setting up the ABI we need separately specify main's input and return witnesses
     let mut is_main = true;
     for (acir, func_sig) in generated_acirs.into_iter().zip(func_sigs) {
@@ -202,7 +214,7 @@ fn convert_generated_acir_into_circuit(
         return_witnesses,
         locations,
         input_witnesses,
-        assert_messages,
+        assertion_payloads: assert_messages,
         warnings,
         name,
         ..
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 3f5e4129dd0..407cdf0a17f 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -9,7 +9,7 @@ use crate::ssa::ir::types::Type as SsaType;
 use crate::ssa::ir::{instruction::Endian, types::NumericType};
 use acvm::acir::circuit::brillig::{BrilligInputs, BrilligOutputs};
 use acvm::acir::circuit::opcodes::{BlockId, MemOp};
-use acvm::acir::circuit::Opcode;
+use acvm::acir::circuit::{AssertionPayload, ExpressionOrMemory, Opcode};
 use acvm::blackbox_solver;
 use acvm::brillig_vm::{MemoryValue, VMStatus, VM};
 use acvm::{
@@ -495,7 +495,7 @@ impl AcirContext {
         &mut self,
         lhs: AcirVar,
         rhs: AcirVar,
-        assert_message: Option<String>,
+        assert_message: Option<AssertionPayload>,
     ) -> Result<(), RuntimeError> {
         let lhs_expr = self.var_to_expression(lhs)?;
         let rhs_expr = self.var_to_expression(rhs)?;
@@ -511,14 +511,38 @@ impl AcirContext {
         }
 
         self.acir_ir.assert_is_zero(diff_expr);
-        if let Some(message) = assert_message {
-            self.acir_ir.assert_messages.insert(self.acir_ir.last_acir_opcode_location(), message);
+        if let Some(payload) = assert_message {
+            self.acir_ir
+                .assertion_payloads
+                .insert(self.acir_ir.last_acir_opcode_location(), payload);
         }
         self.mark_variables_equivalent(lhs, rhs)?;
 
         Ok(())
     }
 
+    pub(crate) fn vars_to_expressions_or_memory(
+        &self,
+        values: &[AcirValue],
+    ) -> Result<Vec<ExpressionOrMemory>, RuntimeError> {
+        let mut result = Vec::with_capacity(values.len());
+        for value in values {
+            match value {
+                AcirValue::Var(var, _) => {
+                    result.push(ExpressionOrMemory::Expression(self.var_to_expression(*var)?));
+                }
+                AcirValue::Array(vars) => {
+                    let vars_as_vec: Vec<_> = vars.iter().cloned().collect();
+                    result.extend(self.vars_to_expressions_or_memory(&vars_as_vec)?);
+                }
+                AcirValue::DynamicArray(AcirDynamicArray { block_id, .. }) => {
+                    result.push(ExpressionOrMemory::Memory(*block_id));
+                }
+            }
+        }
+        Ok(result)
+    }
+
     /// Adds a new Variable to context whose value will
     /// be constrained to be the division of `lhs` and `rhs`
     pub(crate) fn div_var(
@@ -985,9 +1009,10 @@ impl AcirContext {
                 let witness = self.var_to_witness(witness_var)?;
                 self.acir_ir.range_constraint(witness, *bit_size)?;
                 if let Some(message) = message {
-                    self.acir_ir
-                        .assert_messages
-                        .insert(self.acir_ir.last_acir_opcode_location(), message);
+                    self.acir_ir.assertion_payloads.insert(
+                        self.acir_ir.last_acir_opcode_location(),
+                        AssertionPayload::StaticString(message.clone()),
+                    );
                 }
             }
             NumericType::NativeField => {
@@ -1299,6 +1324,21 @@ impl AcirContext {
                     self.big_int_ctx.new_big_int(FieldElement::from(modulus_id as u128));
                 (modulus, vec![result_id.bigint_id(), result_id.modulus_id()])
             }
+            BlackBoxFunc::AES128Encrypt => {
+                let invalid_input = "aes128_encrypt - operation requires a plaintext to encrypt";
+                let input_size = match inputs.first().expect(invalid_input) {
+                    AcirValue::Array(values) => Ok::<usize, RuntimeError>(values.len()),
+                    AcirValue::DynamicArray(dyn_array) => Ok::<usize, RuntimeError>(dyn_array.len),
+                    _ => {
+                        return Err(RuntimeError::InternalError(InternalError::General {
+                            message: "aes128_encrypt requires an array of inputs".to_string(),
+                            call_stack: self.get_call_stack(),
+                        }));
+                    }
+                }?;
+                output_count = input_size + (16 - input_size % 16);
+                (vec![], vec![FieldElement::from(output_count as u128)])
+            }
             _ => (vec![], vec![]),
         };
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 9f305a28c25..c1249ae41c8 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -7,12 +7,11 @@ use crate::{
     errors::{InternalError, RuntimeError, SsaReport},
     ssa::ir::dfg::CallStack,
 };
-
 use acvm::acir::{
     circuit::{
         brillig::{BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, FunctionInput, Opcode as AcirOpcode},
-        OpcodeLocation,
+        AssertionPayload, OpcodeLocation,
     },
     native_types::Witness,
     BlackBoxFunc,
@@ -61,7 +60,7 @@ pub(crate) struct GeneratedAcir {
     pub(crate) call_stack: CallStack,
 
     /// Correspondence between an opcode index and the error message associated with it.
-    pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
+    pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload>,
 
     pub(crate) warnings: Vec<SsaReport>,
 
@@ -189,6 +188,18 @@ impl GeneratedAcir {
         let outputs_clone = outputs.clone();
 
         let black_box_func_call = match func_name {
+            BlackBoxFunc::AES128Encrypt => BlackBoxFuncCall::AES128Encrypt {
+                inputs: inputs[0].clone(),
+                iv: inputs[1]
+                    .clone()
+                    .try_into()
+                    .expect("Compiler should generate correct size inputs"),
+                key: inputs[2]
+                    .clone()
+                    .try_into()
+                    .expect("Compiler should generate correct size inputs"),
+                outputs,
+            },
             BlackBoxFunc::AND => {
                 BlackBoxFuncCall::AND { lhs: inputs[0][0], rhs: inputs[1][0], output: outputs[0] }
             }
@@ -279,9 +290,9 @@ impl GeneratedAcir {
                     output: outputs[0],
                 }
             }
-            BlackBoxFunc::FixedBaseScalarMul => BlackBoxFuncCall::FixedBaseScalarMul {
-                low: inputs[0][0],
-                high: inputs[1][0],
+            BlackBoxFunc::MultiScalarMul => BlackBoxFuncCall::MultiScalarMul {
+                points: inputs[0].clone(),
+                scalars: inputs[1].clone(),
                 outputs: (outputs[0], outputs[1]),
             },
             BlackBoxFunc::EmbeddedCurveAdd => BlackBoxFuncCall::EmbeddedCurveAdd {
@@ -603,12 +614,12 @@ impl GeneratedAcir {
             );
         }
         for (brillig_index, message) in generated_brillig.assert_messages.iter() {
-            self.assert_messages.insert(
+            self.assertion_payloads.insert(
                 OpcodeLocation::Brillig {
                     acir_index: self.opcodes.len() - 1,
                     brillig_index: *brillig_index,
                 },
-                message.clone(),
+                AssertionPayload::StaticString(message.clone()),
             );
         }
     }
@@ -643,7 +654,8 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
 
         // All of the hash/cipher methods will take in a
         // variable number of inputs.
-        BlackBoxFunc::Keccak256
+        BlackBoxFunc::AES128Encrypt
+        | BlackBoxFunc::Keccak256
         | BlackBoxFunc::SHA256
         | BlackBoxFunc::Blake2s
         | BlackBoxFunc::Blake3
@@ -666,9 +678,8 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
         | BlackBoxFunc::EcdsaSecp256k1
         | BlackBoxFunc::EcdsaSecp256r1 => None,
 
-        // Inputs for fixed based scalar multiplication
-        // is the low and high limbs of the scalar
-        BlackBoxFunc::FixedBaseScalarMul => Some(2),
+        // Inputs for multi scalar multiplication is an arbitrary number of [point, scalar] pairs.
+        BlackBoxFunc::MultiScalarMul => None,
 
         // Recursive aggregation has a variable number of inputs
         BlackBoxFunc::RecursiveAggregation => None,
@@ -724,7 +735,7 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         // Output of operations over the embedded curve
         // will be 2 field elements representing the point.
-        BlackBoxFunc::FixedBaseScalarMul | BlackBoxFunc::EmbeddedCurveAdd => Some(2),
+        BlackBoxFunc::MultiScalarMul | BlackBoxFunc::EmbeddedCurveAdd => Some(2),
 
         // Big integer operations return a big integer
         BlackBoxFunc::BigIntAdd
@@ -738,6 +749,9 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         // Recursive aggregation has a variable number of outputs
         BlackBoxFunc::RecursiveAggregation => None,
+
+        // AES encryption returns a variable number of outputs
+        BlackBoxFunc::AES128Encrypt => None,
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index b17ca6b043b..dea7e2fa13b 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -9,7 +9,8 @@ use self::acir_ir::generated_acir::BrilligStdlibFunc;
 use super::function_builder::data_bus::DataBus;
 use super::ir::dfg::CallStack;
 use super::ir::function::FunctionId;
-use super::ir::instruction::{ConstrainError, UserDefinedConstrainError};
+use super::ir::instruction::{ConstrainError, ErrorType};
+use super::ir::printer::try_to_extract_string_from_error_payload;
 use super::{
     ir::{
         dfg::DataFlowGraph,
@@ -31,7 +32,7 @@ pub(crate) use acir_ir::generated_acir::GeneratedAcir;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::acir::circuit::OpcodeLocation;
+use acvm::acir::circuit::{AssertionPayload, ErrorSelector, OpcodeLocation};
 use acvm::acir::native_types::Witness;
 use acvm::acir::BlackBoxFunc;
 use acvm::{
@@ -275,12 +276,12 @@ impl AcirValue {
     }
 }
 
+pub(crate) type Artifacts =
+    (Vec<GeneratedAcir>, Vec<BrilligBytecode>, BTreeMap<ErrorSelector, ErrorType>);
+
 impl Ssa {
     #[tracing::instrument(level = "trace", skip_all)]
-    pub(crate) fn into_acir(
-        self,
-        brillig: &Brillig,
-    ) -> Result<(Vec<GeneratedAcir>, Vec<BrilligBytecode>), RuntimeError> {
+    pub(crate) fn into_acir(self, brillig: &Brillig) -> Result<Artifacts, RuntimeError> {
         let mut acirs = Vec::new();
         // TODO: can we parallelise this?
         let mut shared_context = SharedContext::default();
@@ -327,11 +328,14 @@ impl Ssa {
             bytecode: brillig.byte_code,
         });
 
-        for acir in acirs.iter_mut() {
-            generate_distinct_return_witnesses(acir);
+        let runtime_types = self.functions.values().map(|function| function.runtime());
+        for (acir, runtime_type) in acirs.iter_mut().zip(runtime_types) {
+            if matches!(runtime_type, RuntimeType::Acir(_)) {
+                generate_distinct_return_witnesses(acir);
+            }
         }
 
-        Ok((acirs, brillig))
+        Ok((acirs, brillig, self.error_selector_to_type))
     }
 }
 
@@ -613,24 +617,39 @@ impl<'a> Context<'a> {
                 let lhs = self.convert_numeric_value(*lhs, dfg)?;
                 let rhs = self.convert_numeric_value(*rhs, dfg)?;
 
-                let assert_message = if let Some(error) = assert_message {
-                    match error.as_ref() {
-                        ConstrainError::Intrinsic(string)
-                        | ConstrainError::UserDefined(UserDefinedConstrainError::Static(string)) => {
-                            Some(string.clone())
+                let assert_payload = if let Some(error) = assert_message {
+                    match error {
+                        ConstrainError::Intrinsic(string) => {
+                            Some(AssertionPayload::StaticString(string.clone()))
                         }
-                        ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
-                            call_instruction,
-                        )) => {
-                            self.convert_ssa_call(call_instruction, dfg, ssa, brillig, &[])?;
-                            None
+                        ConstrainError::UserDefined(error_selector, values) => {
+                            if let Some(constant_string) = try_to_extract_string_from_error_payload(
+                                *error_selector,
+                                values,
+                                dfg,
+                            ) {
+                                Some(AssertionPayload::StaticString(constant_string))
+                            } else {
+                                let acir_vars: Vec<_> = values
+                                    .iter()
+                                    .map(|value| self.convert_value(*value, dfg))
+                                    .collect();
+
+                                let expressions_or_memory =
+                                    self.acir_context.vars_to_expressions_or_memory(&acir_vars)?;
+
+                                Some(AssertionPayload::Dynamic(
+                                    error_selector.as_u64(),
+                                    expressions_or_memory,
+                                ))
+                            }
                         }
                     }
                 } else {
                     None
                 };
 
-                self.acir_context.assert_eq_var(lhs, rhs, assert_message)?;
+                self.acir_context.assert_eq_var(lhs, rhs, assert_payload)?;
             }
             Instruction::Cast(value_id, _) => {
                 let acir_var = self.convert_numeric_value(*value_id, dfg)?;
@@ -2824,7 +2843,7 @@ mod test {
 
         let ssa = builder.finish();
 
-        let (acir_functions, _) = ssa
+        let (acir_functions, _, _) = ssa
             .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
         // Expected result:
@@ -2919,7 +2938,7 @@ mod test {
 
         let ssa = builder.finish();
 
-        let (acir_functions, _) = ssa
+        let (acir_functions, _, _) = ssa
             .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
         // The expected result should look very similar to the above test expect that the input witnesses of the `Call`
@@ -3009,7 +3028,7 @@ mod test {
 
         let ssa = builder.finish();
 
-        let (acir_functions, _) = ssa
+        let (acir_functions, _, _) = ssa
             .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
 
@@ -3122,9 +3141,8 @@ mod test {
 
         let ssa = builder.finish();
         let brillig = ssa.to_brillig(false);
-        println!("{}", ssa);
 
-        let (acir_functions, brillig_functions) =
+        let (acir_functions, brillig_functions, _) =
             ssa.into_acir(&brillig).expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
@@ -3180,7 +3198,7 @@ mod test {
 
         // The Brillig bytecode we insert for the stdlib is hardcoded so we do not need to provide any
         // Brillig artifacts to the ACIR gen pass.
-        let (acir_functions, brillig_functions) = ssa
+        let (acir_functions, brillig_functions, _) = ssa
             .into_acir(&Brillig::default())
             .expect("Should compile manually written SSA into ACIR");
 
@@ -3252,7 +3270,7 @@ mod test {
         let brillig = ssa.to_brillig(false);
         println!("{}", ssa);
 
-        let (acir_functions, brillig_functions) =
+        let (acir_functions, brillig_functions, _) =
             ssa.into_acir(&brillig).expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 1, "Should only have a `main` ACIR function");
@@ -3340,7 +3358,7 @@ mod test {
         let brillig = ssa.to_brillig(false);
         println!("{}", ssa);
 
-        let (acir_functions, brillig_functions) =
+        let (acir_functions, brillig_functions, _) =
             ssa.into_acir(&brillig).expect("Should compile manually written SSA into ACIR");
 
         assert_eq!(acir_functions.len(), 2, "Should only have two ACIR functions");
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 091ab294edc..f5afbfae1bb 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -1,8 +1,8 @@
 pub(crate) mod data_bus;
 
-use std::{borrow::Cow, rc::Rc};
+use std::{borrow::Cow, collections::BTreeMap, rc::Rc};
 
-use acvm::FieldElement;
+use acvm::{acir::circuit::ErrorSelector, FieldElement};
 use noirc_errors::Location;
 use noirc_frontend::monomorphization::ast::InlineType;
 
@@ -19,7 +19,7 @@ use super::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
         function::RuntimeType,
-        instruction::{ConstrainError, InstructionId, Intrinsic},
+        instruction::{ConstrainError, ErrorType, InstructionId, Intrinsic},
     },
     ssa_gen::Ssa,
 };
@@ -36,6 +36,7 @@ pub(crate) struct FunctionBuilder {
     current_block: BasicBlockId,
     finished_functions: Vec<Function>,
     call_stack: CallStack,
+    error_types: BTreeMap<ErrorSelector, ErrorType>,
 }
 
 impl FunctionBuilder {
@@ -51,6 +52,7 @@ impl FunctionBuilder {
             current_function: new_function,
             finished_functions: Vec::new(),
             call_stack: CallStack::new(),
+            error_types: BTreeMap::default(),
         }
     }
 
@@ -100,7 +102,7 @@ impl FunctionBuilder {
     /// Consume the FunctionBuilder returning all the functions it has generated.
     pub(crate) fn finish(mut self) -> Ssa {
         self.finished_functions.push(self.current_function);
-        Ssa::new(self.finished_functions)
+        Ssa::new(self.finished_functions, self.error_types)
     }
 
     /// Add a parameter to the current function with the given parameter type.
@@ -269,7 +271,7 @@ impl FunctionBuilder {
         &mut self,
         lhs: ValueId,
         rhs: ValueId,
-        assert_message: Option<Box<ConstrainError>>,
+        assert_message: Option<ConstrainError>,
     ) {
         self.insert_instruction(Instruction::Constrain(lhs, rhs, assert_message), None);
     }
@@ -480,6 +482,10 @@ impl FunctionBuilder {
             }
         }
     }
+
+    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: ErrorType) {
+        self.error_types.insert(selector, typ);
+    }
 }
 
 impl std::ops::Index<ValueId> for FunctionBuilder {
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 11e3fc940b6..7cc19e9f2b8 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -1,5 +1,15 @@
-use acvm::{acir::BlackBoxFunc, FieldElement};
+use std::hash::{Hash, Hasher};
+
+use acvm::{
+    acir::{
+        circuit::{ErrorSelector, STRING_ERROR_SELECTOR},
+        BlackBoxFunc,
+    },
+    FieldElement,
+};
+use fxhash::FxHasher;
 use iter_extended::vecmap;
+use noirc_frontend::hir_def::types::Type as HirType;
 
 use crate::ssa::opt::flatten_cfg::value_merger::ValueMerger;
 
@@ -159,7 +169,7 @@ pub(crate) enum Instruction {
     Truncate { value: ValueId, bit_size: u32, max_bit_size: u32 },
 
     /// Constrains two values to be equal to one another.
-    Constrain(ValueId, ValueId, Option<Box<ConstrainError>>),
+    Constrain(ValueId, ValueId, Option<ConstrainError>),
 
     /// Range constrain `value` to `max_bit_size`
     RangeCheck { value: ValueId, max_bit_size: u32, assert_message: Option<String> },
@@ -390,12 +400,12 @@ impl Instruction {
                 // Must map the `lhs` and `rhs` first as the value `f` is moved with the closure
                 let lhs = f(*lhs);
                 let rhs = f(*rhs);
-                let assert_message = assert_message.as_ref().map(|error| match error.as_ref() {
-                    ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(call_instr)) => {
-                        let new_instr = call_instr.map_values(f);
-                        Box::new(ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
-                            new_instr,
-                        )))
+                let assert_message = assert_message.as_ref().map(|error| match error {
+                    ConstrainError::UserDefined(selector, payload_values) => {
+                        ConstrainError::UserDefined(
+                            *selector,
+                            payload_values.iter().map(|&value| f(value)).collect(),
+                        )
                     }
                     _ => error.clone(),
                 });
@@ -464,13 +474,10 @@ impl Instruction {
             Instruction::Constrain(lhs, rhs, assert_error) => {
                 f(*lhs);
                 f(*rhs);
-                if let Some(error) = assert_error.as_ref() {
-                    if let ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
-                        call_instr,
-                    )) = error.as_ref()
-                    {
-                        call_instr.for_each_value(f);
-                    }
+                if let Some(ConstrainError::UserDefined(_, values)) = assert_error.as_ref() {
+                    values.iter().for_each(|&val| {
+                        f(val);
+                    });
                 }
             }
 
@@ -687,22 +694,27 @@ impl Instruction {
     }
 }
 
+pub(crate) type ErrorType = HirType;
+
+pub(crate) fn error_selector_from_type(typ: &ErrorType) -> ErrorSelector {
+    match typ {
+        ErrorType::String(_) => STRING_ERROR_SELECTOR,
+        _ => {
+            let mut hasher = FxHasher::default();
+            typ.hash(&mut hasher);
+            let hash = hasher.finish();
+            assert!(hash != 0, "ICE: Error type {} collides with the string error type", typ);
+            ErrorSelector::new(hash)
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub(crate) enum ConstrainError {
     // These are errors which have been hardcoded during SSA gen
     Intrinsic(String),
     // These are errors issued by the user
-    UserDefined(UserDefinedConstrainError),
-}
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone)]
-pub(crate) enum UserDefinedConstrainError {
-    // These are errors which come from static strings specified by a Noir program
-    Static(String),
-    // These are errors which come from runtime expressions specified by a Noir program
-    // We store an `Instruction` as we want this Instruction to be atomic in SSA with
-    // a constrain instruction, and leave codegen of this instruction to lower level passes.
-    Dynamic(Instruction),
+    UserDefined(ErrorSelector, Vec<ValueId>),
 }
 
 impl From<String> for ConstrainError {
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index fca6a354f2c..7ad6a625f9c 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -464,7 +464,7 @@ fn simplify_black_box_func(
             simplify_signature(dfg, arguments, acvm::blackbox_solver::ecdsa_secp256r1_verify)
         }
 
-        BlackBoxFunc::FixedBaseScalarMul
+        BlackBoxFunc::MultiScalarMul
         | BlackBoxFunc::SchnorrVerify
         | BlackBoxFunc::PedersenCommitment
         | BlackBoxFunc::PedersenHash
@@ -492,6 +492,7 @@ fn simplify_black_box_func(
             )
         }
         BlackBoxFunc::Sha256Compression => SimplifyResult::None, //TODO(Guillaume)
+        BlackBoxFunc::AES128Encrypt => SimplifyResult::None,
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
index b4198e2cfec..d844f350927 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
@@ -7,7 +7,7 @@ use super::{Binary, BinaryOp, ConstrainError, DataFlowGraph, Instruction, Type,
 pub(super) fn decompose_constrain(
     lhs: ValueId,
     rhs: ValueId,
-    msg: &Option<Box<ConstrainError>>,
+    msg: &Option<ConstrainError>,
     dfg: &mut DataFlowGraph,
 ) -> Vec<Instruction> {
     let lhs = dfg.resolve(lhs);
diff --git a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
index d95ec451779..94ff96ba1d7 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
@@ -51,7 +51,7 @@ impl PostOrder {
                         // stack, we push the item that's due for a visit first to the top.
                         for successor_id in func.dfg[block_id].successors().rev() {
                             if !visited.contains(&successor_id) {
-                                // This not visited check would also be cover by the the next
+                                // This not visited check would also be cover by the next
                                 // iteration, but checking here two saves an iteration per successor.
                                 stack.push((Visit::First, successor_id));
                             }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 23395617c85..58c593b0ad6 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -4,16 +4,15 @@ use std::{
     fmt::{Formatter, Result},
 };
 
+use acvm::acir::circuit::{ErrorSelector, STRING_ERROR_SELECTOR};
 use iter_extended::vecmap;
 
 use super::{
     basic_block::BasicBlockId,
+    dfg::DataFlowGraph,
     function::Function,
-    instruction::{
-        ConstrainError, Instruction, InstructionId, TerminatorInstruction,
-        UserDefinedConstrainError,
-    },
-    value::ValueId,
+    instruction::{ConstrainError, Instruction, InstructionId, TerminatorInstruction},
+    value::{Value, ValueId},
 };
 
 /// Helper function for Function's Display impl to pretty-print the function with the given formatter.
@@ -63,7 +62,6 @@ pub(crate) fn display_block(
 /// Specialize displaying value ids so that if they refer to a numeric
 /// constant or a function we print those directly.
 fn value(function: &Function, id: ValueId) -> String {
-    use super::value::Value;
     let id = function.dfg.resolve(id);
     match &function.dfg[id] {
         Value::NumericConstant { constant, typ } => {
@@ -159,7 +157,6 @@ fn display_instruction_inner(
         Instruction::Constrain(lhs, rhs, error) => {
             write!(f, "constrain {} == {}", show(*lhs), show(*rhs))?;
             if let Some(error) = error {
-                write!(f, " ")?;
                 display_constrain_error(function, error, f)
             } else {
                 writeln!(f)
@@ -208,18 +205,51 @@ fn display_instruction_inner(
     }
 }
 
+/// Tries to extract a constant string from an error payload.
+pub(crate) fn try_to_extract_string_from_error_payload(
+    error_selector: ErrorSelector,
+    values: &[ValueId],
+    dfg: &DataFlowGraph,
+) -> Option<String> {
+    ((error_selector == STRING_ERROR_SELECTOR) && (values.len() == 1))
+        .then_some(())
+        .and_then(|()| {
+            let Value::Array { array: values, .. } = &dfg[values[0]] else {
+                return None;
+            };
+            let fields: Option<Vec<_>> =
+                values.iter().map(|value_id| dfg.get_numeric_constant(*value_id)).collect();
+
+            fields
+        })
+        .map(|fields| {
+            fields
+                .iter()
+                .map(|field| {
+                    let as_u8 = field.try_to_u64().unwrap_or_default() as u8;
+                    as_u8 as char
+                })
+                .collect()
+        })
+}
+
 fn display_constrain_error(
     function: &Function,
     error: &ConstrainError,
     f: &mut Formatter,
 ) -> Result {
     match error {
-        ConstrainError::Intrinsic(assert_message_string)
-        | ConstrainError::UserDefined(UserDefinedConstrainError::Static(assert_message_string)) => {
-            writeln!(f, "{assert_message_string:?}")
-        }
-        ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(assert_message_call)) => {
-            display_instruction_inner(function, assert_message_call, f)
+        ConstrainError::Intrinsic(assert_message_string) => {
+            writeln!(f, " '{assert_message_string:?}'")
+        }
+        ConstrainError::UserDefined(selector, values) => {
+            if let Some(constant_string) =
+                try_to_extract_string_from_error_payload(*selector, values, &function.dfg)
+            {
+                writeln!(f, " '{}'", constant_string)
+            } else {
+                writeln!(f, ", data {}", value_list(function, values))
+            }
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index aa0368cc2dd..cfeb8751f25 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -14,7 +14,7 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         function::{Function, FunctionId, Signature},
-        instruction::{BinaryOp, ConstrainError, Instruction, UserDefinedConstrainError},
+        instruction::{BinaryOp, Instruction},
         types::{NumericType, Type},
         value::{Value, ValueId},
     },
@@ -90,18 +90,6 @@ impl DefunctionalizationContext {
                     Instruction::Call { func: target_func_id, arguments } => {
                         (*target_func_id, arguments)
                     }
-                    // Constrain instruction potentially hold a call instruction themselves
-                    // thus we need to account for them.
-                    Instruction::Constrain(_, _, Some(constrain_error)) => {
-                        if let ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(
-                            Instruction::Call { func: target_func_id, arguments },
-                        )) = constrain_error.as_ref()
-                        {
-                            (*target_func_id, arguments)
-                        } else {
-                            continue;
-                        }
-                    }
                     _ => continue,
                 };
 
@@ -133,22 +121,7 @@ impl DefunctionalizationContext {
                     }
                     _ => {}
                 }
-                if let Some(mut new_instruction) = replacement_instruction {
-                    if let Instruction::Constrain(lhs, rhs, constrain_error_call) = instruction {
-                        let new_error_call = if let Some(error) = constrain_error_call {
-                            match error.as_ref() {
-                                ConstrainError::UserDefined(
-                                    UserDefinedConstrainError::Dynamic(_),
-                                ) => Some(Box::new(ConstrainError::UserDefined(
-                                    UserDefinedConstrainError::Dynamic(new_instruction),
-                                ))),
-                                _ => None,
-                            }
-                        } else {
-                            None
-                        };
-                        new_instruction = Instruction::Constrain(lhs, rhs, new_error_call);
-                    }
+                if let Some(new_instruction) = replacement_instruction {
                     func.dfg[instruction_id] = new_instruction;
                 }
             }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index 1103237947d..65a77552c79 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -97,7 +97,7 @@ impl Context<'_> {
         let typ = self.function.dfg.type_of_value(lhs);
         let (max_bit, pow) = if let Some(rhs_constant) = self.function.dfg.get_numeric_constant(rhs)
         {
-            // Happy case is that we know precisely by how many bits the the integer will
+            // Happy case is that we know precisely by how many bits the integer will
             // increase: lhs_bit_size + rhs
             let bit_shift_size = rhs_constant.to_u128() as u32;
 
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index ebde3dcf66e..698a2b0471a 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -8,10 +8,11 @@ use context::SharedContext;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
 use noirc_frontend::ast::{UnaryOp, Visibility};
+use noirc_frontend::hir_def::types::Type as HirType;
 use noirc_frontend::monomorphization::ast::{self, Expression, Program};
 
 use crate::{
-    errors::{InternalError, RuntimeError},
+    errors::RuntimeError,
     ssa::{function_builder::data_bus::DataBusBuilder, ir::instruction::Intrinsic},
 };
 
@@ -20,13 +21,12 @@ use self::{
     value::{Tree, Values},
 };
 
+use super::ir::instruction::error_selector_from_type;
 use super::{
     function_builder::data_bus::DataBus,
     ir::{
         function::RuntimeType,
-        instruction::{
-            BinaryOp, ConstrainError, Instruction, TerminatorInstruction, UserDefinedConstrainError,
-        },
+        instruction::{BinaryOp, ConstrainError, TerminatorInstruction},
         types::Type,
         value::ValueId,
     },
@@ -146,8 +146,8 @@ impl<'a> FunctionContext<'a> {
             }
             Expression::Call(call) => self.codegen_call(call),
             Expression::Let(let_expr) => self.codegen_let(let_expr),
-            Expression::Constrain(expr, location, assert_message) => {
-                self.codegen_constrain(expr, *location, assert_message)
+            Expression::Constrain(expr, location, assert_payload) => {
+                self.codegen_constrain(expr, *location, assert_payload)
             }
             Expression::Assign(assign) => self.codegen_assign(assign),
             Expression::Semi(semi) => self.codegen_semi(semi),
@@ -448,7 +448,7 @@ impl<'a> FunctionContext<'a> {
         self.builder.insert_constrain(
             is_offset_out_of_bounds,
             true_const,
-            Some(Box::new("Index out of bounds".to_owned().into())),
+            Some("Index out of bounds".to_owned().into()),
         );
     }
 
@@ -675,7 +675,7 @@ impl<'a> FunctionContext<'a> {
         &mut self,
         expr: &Expression,
         location: Location,
-        assert_message: &Option<Box<Expression>>,
+        assert_payload: &Option<Box<(Expression, HirType)>>,
     ) -> Result<Values, RuntimeError> {
         let expr = self.codegen_non_tuple_expression(expr)?;
         let true_literal = self.builder.numeric_constant(true, Type::bool());
@@ -683,9 +683,9 @@ impl<'a> FunctionContext<'a> {
         // Set the location here for any errors that may occur when we codegen the assert message
         self.builder.set_location(location);
 
-        let assert_message = self.codegen_constrain_error(assert_message)?;
+        let assert_payload = self.codegen_constrain_error(assert_payload)?;
 
-        self.builder.insert_constrain(expr, true_literal, assert_message);
+        self.builder.insert_constrain(expr, true_literal, assert_payload);
 
         Ok(Self::unit_value())
     }
@@ -696,42 +696,22 @@ impl<'a> FunctionContext<'a> {
     // inserted to the SSA as we want that instruction to be atomic in SSA with a constrain instruction.
     fn codegen_constrain_error(
         &mut self,
-        assert_message: &Option<Box<Expression>>,
-    ) -> Result<Option<Box<ConstrainError>>, RuntimeError> {
-        let Some(assert_message_expr) = assert_message else { return Ok(None) };
-
-        if let ast::Expression::Literal(ast::Literal::Str(assert_message)) =
-            assert_message_expr.as_ref()
-        {
-            return Ok(Some(Box::new(ConstrainError::UserDefined(
-                UserDefinedConstrainError::Static(assert_message.to_string()),
-            ))));
-        }
-
-        let ast::Expression::Call(call) = assert_message_expr.as_ref() else {
-            return Err(InternalError::Unexpected {
-                expected: "Expected a call expression".to_owned(),
-                found: "Instead found {expr:?}".to_owned(),
-                call_stack: self.builder.get_call_stack(),
+        assert_message: &Option<Box<(Expression, HirType)>>,
+    ) -> Result<Option<ConstrainError>, RuntimeError> {
+        let Some(assert_message_payload) = assert_message else { return Ok(None) };
+        let (assert_message_expression, assert_message_typ) = assert_message_payload.as_ref();
+
+        let values = self.codegen_expression(assert_message_expression)?.into_value_list(self);
+
+        let error_type_id = error_selector_from_type(assert_message_typ);
+        // Do not record string errors in the ABI
+        match assert_message_typ {
+            HirType::String(_) => {}
+            _ => {
+                self.builder.record_error_type(error_type_id, assert_message_typ.clone());
             }
-            .into());
         };
-
-        let func = self.codegen_non_tuple_expression(&call.func)?;
-        let mut arguments = Vec::with_capacity(call.arguments.len());
-
-        for argument in &call.arguments {
-            let mut values = self.codegen_expression(argument)?.into_value_list(self);
-            arguments.append(&mut values);
-        }
-
-        // If an array is passed as an argument we increase its reference count
-        for argument in &arguments {
-            self.builder.increment_array_reference_count(*argument);
-        }
-
-        let instr = Instruction::Call { func, arguments };
-        Ok(Some(Box::new(ConstrainError::UserDefined(UserDefinedConstrainError::Dynamic(instr)))))
+        Ok(Some(ConstrainError::UserDefined(error_type_id, values)))
     }
 
     fn codegen_assign(&mut self, assign: &ast::Assign) -> Result<Values, RuntimeError> {
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
index b05a2cbc741..21178c55c73 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
@@ -1,11 +1,13 @@
 use std::{collections::BTreeMap, fmt::Display};
 
+use acvm::acir::circuit::ErrorSelector;
 use iter_extended::btree_map;
 
 use crate::ssa::ir::{
     function::{Function, FunctionId, RuntimeType},
     map::AtomicCounter,
 };
+use noirc_frontend::hir_def::types::Type as HirType;
 
 /// Contains the entire SSA representation of the program.
 pub(crate) struct Ssa {
@@ -17,12 +19,16 @@ pub(crate) struct Ssa {
     /// This mapping is necessary to use the correct function pointer for an ACIR call,
     /// as the final program artifact will be a list of only entry point functions.
     pub(crate) entry_point_to_generated_index: BTreeMap<FunctionId, u32>,
+    pub(crate) error_selector_to_type: BTreeMap<ErrorSelector, HirType>,
 }
 
 impl Ssa {
     /// Create a new Ssa object from the given SSA functions.
     /// The first function in this vector is expected to be the main function.
-    pub(crate) fn new(functions: Vec<Function>) -> Self {
+    pub(crate) fn new(
+        functions: Vec<Function>,
+        error_types: BTreeMap<ErrorSelector, HirType>,
+    ) -> Self {
         let main_id = functions.first().expect("Expected at least 1 SSA function").id();
         let mut max_id = main_id;
 
@@ -50,6 +56,7 @@ impl Ssa {
             main_id,
             next_id: AtomicCounter::starting_after(max_id),
             entry_point_to_generated_index,
+            error_selector_to_type: error_types,
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 6dbda202c34..84df3a0a244 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -163,7 +163,7 @@ impl<'a> Interpreter<'a> {
         self.scopes.last_mut().unwrap()
     }
 
-    fn define_pattern(
+    pub(super) fn define_pattern(
         &mut self,
         pattern: &HirPattern,
         typ: &Type,
@@ -265,7 +265,7 @@ impl<'a> Interpreter<'a> {
         Err(InterpreterError::NonComptimeVarReferenced { name, location })
     }
 
-    fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
+    pub(super) fn lookup(&self, ident: &HirIdent) -> IResult<Value> {
         self.lookup_id(ident.id, ident.location)
     }
 
@@ -294,7 +294,7 @@ impl<'a> Interpreter<'a> {
     }
 
     /// Evaluate an expression and return the result
-    fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
+    pub(super) fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
         match self.interner.expression(&id) {
             HirExpression::Ident(ident) => self.evaluate_ident(ident, id),
             HirExpression::Literal(literal) => self.evaluate_literal(literal, id),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 6c07957b27f..60baaecab59 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1292,15 +1292,14 @@ impl<'a> Resolver<'a> {
                 })
             }
             StatementKind::Constrain(constrain_stmt) => {
-                let span = constrain_stmt.0.span;
-                let assert_msg_call_expr_id =
-                    self.resolve_assert_message(constrain_stmt.1, span, constrain_stmt.0.clone());
                 let expr_id = self.resolve_expression(constrain_stmt.0);
+                let assert_message_expr_id =
+                    constrain_stmt.1.map(|assert_expr_id| self.resolve_expression(assert_expr_id));
 
                 HirStatement::Constrain(HirConstrainStatement(
                     expr_id,
                     self.file,
-                    assert_msg_call_expr_id,
+                    assert_message_expr_id,
                 ))
             }
             StatementKind::Expression(expr) => {
@@ -1368,48 +1367,6 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    fn resolve_assert_message(
-        &mut self,
-        assert_message_expr: Option<Expression>,
-        span: Span,
-        condition: Expression,
-    ) -> Option<ExprId> {
-        let assert_message_expr = assert_message_expr?;
-
-        if matches!(
-            assert_message_expr,
-            Expression { kind: ExpressionKind::Literal(Literal::Str(..)), .. }
-        ) {
-            return Some(self.resolve_expression(assert_message_expr));
-        }
-
-        let is_in_stdlib = self.path_resolver.module_id().krate.is_stdlib();
-        let assert_msg_call_path = if is_in_stdlib {
-            ExpressionKind::Variable(Path {
-                segments: vec![Ident::from("internal"), Ident::from("resolve_assert_message")],
-                kind: PathKind::Crate,
-                span,
-            })
-        } else {
-            ExpressionKind::Variable(Path {
-                segments: vec![
-                    Ident::from("std"),
-                    Ident::from("internal"),
-                    Ident::from("resolve_assert_message"),
-                ],
-                kind: PathKind::Dep,
-                span,
-            })
-        };
-        let assert_msg_call_args = vec![assert_message_expr.clone(), condition];
-        let assert_msg_call_expr = Expression::call(
-            Expression { kind: assert_msg_call_path, span },
-            assert_msg_call_args,
-            span,
-        );
-        Some(self.resolve_expression(assert_msg_call_expr))
-    }
-
     pub fn intern_stmt(&mut self, stmt: Statement) -> StmtId {
         let hir_stmt = self.resolve_stmt(stmt.kind, stmt.span);
         let id = self.interner.push_stmt(hir_stmt);
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 97a71f800a8..15c27ee344c 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -11,6 +11,8 @@ use crate::{
     token::{Attributes, FunctionAttribute},
 };
 
+use super::HirType;
+
 /// The monomorphized AST is expression-based, all statements are also
 /// folded into this expression enum. Compared to the HIR, the monomorphized
 /// AST has several differences:
@@ -36,7 +38,7 @@ pub enum Expression {
     ExtractTupleField(Box<Expression>, usize),
     Call(Call),
     Let(Let),
-    Constrain(Box<Expression>, Location, Option<Box<Expression>>),
+    Constrain(Box<Expression>, Location, Option<Box<(Expression, HirType)>>),
     Assign(Assign),
     Semi(Box<Expression>),
     Break,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 94cc6bcd849..f918610af2c 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -593,7 +593,11 @@ impl<'interner> Monomorphizer<'interner> {
                 let location = self.interner.expr_location(&constrain.0);
                 let assert_message = constrain
                     .2
-                    .map(|assert_msg_expr| self.expr(assert_msg_expr))
+                    .map(|assert_msg_expr| {
+                        self.expr(assert_msg_expr).map(|expr| {
+                            (expr, self.interner.id_type(assert_msg_expr).follow_bindings())
+                        })
+                    })
                     .transpose()?
                     .map(Box::new);
                 Ok(ast::Expression::Constrain(Box::new(expr), location, assert_message))
@@ -1100,9 +1104,6 @@ impl<'interner> Monomorphizer<'interner> {
                     // The first argument to the `print` oracle is a bool, indicating a newline to be inserted at the end of the input
                     // The second argument is expected to always be an ident
                     self.append_printable_type_info(&hir_arguments[1], &mut arguments);
-                } else if name.as_str() == "assert_message" {
-                    // The first argument to the `assert_message` oracle is the expression passed as a message to an `assert` or `assert_eq` statement
-                    self.append_printable_type_info(&hir_arguments[0], &mut arguments);
                 }
             }
         }
diff --git a/docs/docs/noir/standard_library/black_box_fns.md b/docs/docs/noir/standard_library/black_box_fns.md
index be8c65679c3..eeead580969 100644
--- a/docs/docs/noir/standard_library/black_box_fns.md
+++ b/docs/docs/noir/standard_library/black_box_fns.md
@@ -12,6 +12,7 @@ The ACVM spec defines a set of blackbox functions which backends will be expecte
 
 Here is a list of the current black box functions:
 
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
 - [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
 - [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
 - [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
@@ -19,7 +20,7 @@ Here is a list of the current black box functions:
 - [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
 - [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
 - [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
 - AND
 - XOR
 - RANGE
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..0103791d2e4
--- /dev/null
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,28 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+#include_code aes128 noir_stdlib/src/aes128.nr rust
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo />
\ No newline at end of file
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..f1122fc37d5
--- /dev/null
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,77 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+#include_code multi_scalar_mul noir_stdlib/src/embedded_curve_ops.nr rust
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+#include_code fixed_base_scalar_mul noir_stdlib/src/embedded_curve_ops.nr rust
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+#include_code embedded_curve_add noir_stdlib/src/embedded_curve_ops.nr rust
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/scalar.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/scalar.mdx
deleted file mode 100644
index c2946b2b73b..00000000000
--- a/docs/docs/noir/standard_library/cryptographic_primitives/scalar.mdx
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Scalar multiplication
-description: See how you can perform scalar multiplications over a fixed base in Noir
-keywords: [cryptographic primitives, Noir project, scalar multiplication]
-sidebar_position: 1
----
-
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
-
-## scalar_mul::fixed_base_embedded_curve
-
-Performs scalar multiplication over the embedded curve whose coordinates are defined by the
-configured noir field. For the BN254 scalar field, this is BabyJubJub or Grumpkin.
-
-#include_code fixed_base_embedded_curve noir_stdlib/src/scalar_mul.nr rust
-
-example
-
-```rust
-fn main(x : Field) {
-    let scal = std::scalar_mul::fixed_base_embedded_curve(x);
-    println(scal);
-}
-```
-
-<BlackBoxInfo />
diff --git a/docs/docs/tutorials/noirjs_app.md b/docs/docs/tutorials/noirjs_app.md
index 6446e0b2a76..3dd9fe7d2b0 100644
--- a/docs/docs/tutorials/noirjs_app.md
+++ b/docs/docs/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/docs/versioned_docs/version-v0.17.0/noir_js/getting_started/01_tiny_noir_app.md b/docs/versioned_docs/version-v0.17.0/noir_js/getting_started/01_tiny_noir_app.md
index 142cd02b94c..b3f1d6df747 100644
--- a/docs/versioned_docs/version-v0.17.0/noir_js/getting_started/01_tiny_noir_app.md
+++ b/docs/versioned_docs/version-v0.17.0/noir_js/getting_started/01_tiny_noir_app.md
@@ -18,7 +18,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.19.0/noir_js/getting_started/01_tiny_noir_app.md b/docs/versioned_docs/version-v0.19.0/noir_js/getting_started/01_tiny_noir_app.md
index 795baa59d59..64ba4a2c44a 100644
--- a/docs/versioned_docs/version-v0.19.0/noir_js/getting_started/01_tiny_noir_app.md
+++ b/docs/versioned_docs/version-v0.19.0/noir_js/getting_started/01_tiny_noir_app.md
@@ -20,7 +20,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.19.1/noir_js/getting_started/01_tiny_noir_app.md b/docs/versioned_docs/version-v0.19.1/noir_js/getting_started/01_tiny_noir_app.md
index 795baa59d59..64ba4a2c44a 100644
--- a/docs/versioned_docs/version-v0.19.1/noir_js/getting_started/01_tiny_noir_app.md
+++ b/docs/versioned_docs/version-v0.19.1/noir_js/getting_started/01_tiny_noir_app.md
@@ -20,7 +20,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.19.2/noir_js/getting_started/01_tiny_noir_app.md b/docs/versioned_docs/version-v0.19.2/noir_js/getting_started/01_tiny_noir_app.md
index 795baa59d59..64ba4a2c44a 100644
--- a/docs/versioned_docs/version-v0.19.2/noir_js/getting_started/01_tiny_noir_app.md
+++ b/docs/versioned_docs/version-v0.19.2/noir_js/getting_started/01_tiny_noir_app.md
@@ -20,7 +20,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.19.3/noir_js/getting_started/01_tiny_noir_app.md b/docs/versioned_docs/version-v0.19.3/noir_js/getting_started/01_tiny_noir_app.md
index 795baa59d59..64ba4a2c44a 100644
--- a/docs/versioned_docs/version-v0.19.3/noir_js/getting_started/01_tiny_noir_app.md
+++ b/docs/versioned_docs/version-v0.19.3/noir_js/getting_started/01_tiny_noir_app.md
@@ -20,7 +20,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.19.4/noir_js/getting_started/01_tiny_noir_app.md b/docs/versioned_docs/version-v0.19.4/noir_js/getting_started/01_tiny_noir_app.md
index 795baa59d59..64ba4a2c44a 100644
--- a/docs/versioned_docs/version-v0.19.4/noir_js/getting_started/01_tiny_noir_app.md
+++ b/docs/versioned_docs/version-v0.19.4/noir_js/getting_started/01_tiny_noir_app.md
@@ -20,7 +20,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../../getting_started/00_nargo_installation.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.22.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.22.0/tutorials/noirjs_app.md
index 0763b6224c9..516e07c89fd 100644
--- a/docs/versioned_docs/version-v0.22.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.22.0/tutorials/noirjs_app.md
@@ -21,7 +21,7 @@ In this guide, we will be pinned to 0.17.0.
 
 Make sure you have Node installed on your machine by opening a terminal and executing `node --version`. If you don't see a version, you should install [node](https://github.com/nvm-sh/nvm). You can also use `yarn` if you prefer that package manager over npm (which comes with node).
 
-First of all, follow the the [Nargo guide](../getting_started/installation/index.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
+First of all, follow the [Nargo guide](../getting_started/installation/index.md) to install nargo version 0.17.0 and create a new project with `nargo new circuit`. Once there, `cd` into the `circuit` folder. You should then be able to compile your circuit into `json` format and see it inside the `target` folder:
 
 ```bash
 nargo compile
diff --git a/docs/versioned_docs/version-v0.23.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.23.0/tutorials/noirjs_app.md
index 82899217e61..e3bc8c58b24 100644
--- a/docs/versioned_docs/version-v0.23.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.23.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md
index 12beb476994..0d75e2e8045 100644
--- a/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.24.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
index 02044cd2ff6..0cea72314ce 100644
--- a/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.25.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
index d098827e6d9..a6dda7e08c3 100644
--- a/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.26.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md
index 12beb476994..0d75e2e8045 100644
--- a/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.27.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/noir_stdlib/src/aes128.nr b/noir_stdlib/src/aes128.nr
new file mode 100644
index 00000000000..e6e2a5e4997
--- /dev/null
+++ b/noir_stdlib/src/aes128.nr
@@ -0,0 +1,4 @@
+#[foreign(aes128_encrypt)]
+// docs:start:aes128
+pub fn aes128_encrypt<N>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+// docs:end:aes128
diff --git a/noir_stdlib/src/scalar_mul.nr b/noir_stdlib/src/embedded_curve_ops.nr
similarity index 61%
rename from noir_stdlib/src/scalar_mul.nr
rename to noir_stdlib/src/embedded_curve_ops.nr
index 5ce10058f8b..21d658db615 100644
--- a/noir_stdlib/src/scalar_mul.nr
+++ b/noir_stdlib/src/embedded_curve_ops.nr
@@ -1,5 +1,6 @@
 use crate::ops::arith::{Add, Sub, Neg};
 
+// TODO(https://github.com/noir-lang/noir/issues/4931)
 struct EmbeddedCurvePoint {
     x: Field,
     y: Field,
@@ -32,21 +33,42 @@ impl Neg for EmbeddedCurvePoint {
     }
 }
 
-// Computes a fixed base scalar multiplication over the embedded curve.
+// Computes a multi scalar multiplication over the embedded curve.
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.
 //
 // The embedded curve being used is decided by the 
 // underlying proof system.
-#[foreign(fixed_base_scalar_mul)]
-// docs:start:fixed_base_embedded_curve
-pub fn fixed_base_embedded_curve(low: Field, high: Field) -> [Field; 2]
-// docs:end:fixed_base_embedded_curve
+#[foreign(multi_scalar_mul)]
+// docs:start:multi_scalar_mul
+pub fn multi_scalar_mul<N>(
+    points: [Field; N], // points represented as x and y coordinates [x1, y1, x2, y2, ...]
+    scalars: [Field; N] // scalars represented as low and high limbs [low1, high1, low2, high2, ...]
+) -> [Field; 2]
+// docs:end:multi_scalar_mul
 {}
 
+// docs:start:fixed_base_scalar_mul
+pub fn fixed_base_scalar_mul(
+    scalar_low: Field,
+    scalar_high: Field
+) -> [Field; 2]
+// docs:end:fixed_base_scalar_mul
+{
+    let g1_x = 1;
+    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
+    multi_scalar_mul([g1_x, g1_y], [scalar_low, scalar_high])
+}
+
 // This is a hack as returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray
 // as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.
-fn embedded_curve_add(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint) -> EmbeddedCurvePoint {
+// docs:start:embedded_curve_add
+fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint
+) -> EmbeddedCurvePoint
+// docs:end:embedded_curve_add
+{
     let point_array = embedded_curve_add_array_return(point1, point2);
     let x = point_array[0];
     let y = point_array[1];
diff --git a/noir_stdlib/src/grumpkin_scalar.nr b/noir_stdlib/src/grumpkin_scalar.nr
deleted file mode 100644
index d05158488f4..00000000000
--- a/noir_stdlib/src/grumpkin_scalar.nr
+++ /dev/null
@@ -1,21 +0,0 @@
-struct GrumpkinScalar {
-    low: Field,
-    high: Field,
-}
-
-impl GrumpkinScalar {
-    pub fn new(low: Field, high: Field) -> Self {
-        // TODO: check that the low and high value fit within the grumpkin modulus
-        GrumpkinScalar { low, high }
-    }
-}
-
-global GRUMPKIN_SCALAR_SERIALIZED_LEN: Field = 2;
-
-pub fn deserialize_grumpkin_scalar(fields: [Field; GRUMPKIN_SCALAR_SERIALIZED_LEN]) -> GrumpkinScalar {
-    GrumpkinScalar { low: fields[0], high: fields[1] }
-}
-
-pub fn serialize_grumpkin_scalar(scalar: GrumpkinScalar) -> [Field; GRUMPKIN_SCALAR_SERIALIZED_LEN] {
-    [scalar.low, scalar.high]
-}
diff --git a/noir_stdlib/src/grumpkin_scalar_mul.nr b/noir_stdlib/src/grumpkin_scalar_mul.nr
deleted file mode 100644
index 06d30d62332..00000000000
--- a/noir_stdlib/src/grumpkin_scalar_mul.nr
+++ /dev/null
@@ -1,7 +0,0 @@
-use crate::grumpkin_scalar::GrumpkinScalar;
-use crate::scalar_mul::fixed_base_embedded_curve;
-
-pub fn grumpkin_fixed_base(scalar: GrumpkinScalar) -> [Field; 2] {
-    // TODO: this should use both the low and high limbs to do the scalar multiplication
-    fixed_base_embedded_curve(scalar.low, scalar.high)
-}
diff --git a/noir_stdlib/src/internal.nr b/noir_stdlib/src/internal.nr
deleted file mode 100644
index 8d5c01dda7f..00000000000
--- a/noir_stdlib/src/internal.nr
+++ /dev/null
@@ -1,12 +0,0 @@
-// This file contains functions which should only be used in calls injected by the Noir compiler.
-// These functions should not be called manually in user code.
-//
-// Changes to this file will not be considered breaking.
-
-#[oracle(assert_message)]
-unconstrained fn assert_message_oracle<T>(_input: T) {}
-unconstrained pub fn resolve_assert_message<T>(input: T, condition: bool) {
-    if !condition {
-        assert_message_oracle(input);
-    }
-}
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index 90c04472066..33504be0b9a 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -1,4 +1,5 @@
 mod hash;
+mod aes128;
 mod array;
 mod slice;
 mod merkle;
@@ -6,9 +7,7 @@ mod schnorr;
 mod ecdsa_secp256k1;
 mod ecdsa_secp256r1;
 mod eddsa;
-mod grumpkin_scalar;
-mod grumpkin_scalar_mul;
-mod scalar_mul;
+mod embedded_curve_ops;
 mod sha256;
 mod sha512;
 mod field;
@@ -26,7 +25,6 @@ mod default;
 mod prelude;
 mod uint128;
 mod bigint;
-mod internal;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
diff --git a/test_programs/compile_success_empty/intrinsic_die/src/main.nr b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
index 8cac707dfea..9ce17f72c0d 100644
--- a/test_programs/compile_success_empty/intrinsic_die/src/main.nr
+++ b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
@@ -2,5 +2,7 @@ use dep::std;
 // This test checks that we perform dead-instruction-elimination on intrinsic functions.
 fn main(x: Field) {
     let hash = std::hash::pedersen_commitment([x]);
-    let _p1 = std::scalar_mul::fixed_base_embedded_curve(x, 0);
+    let g1_x = 0x0000000000000000000000000000000000000000000000000000000000000001;
+    let g1_y = 0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c;
+    let _p1 = std::embedded_curve_ops::multi_scalar_mul([g1_x, g1_y], [x, 0]);
 }
diff --git a/test_programs/execution_success/aes128_encrypt/Nargo.toml b/test_programs/execution_success/aes128_encrypt/Nargo.toml
new file mode 100644
index 00000000000..29425131cff
--- /dev/null
+++ b/test_programs/execution_success/aes128_encrypt/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "aes128_encrypt"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/aes128_encrypt/Prover.toml b/test_programs/execution_success/aes128_encrypt/Prover.toml
new file mode 100644
index 00000000000..b6b684790e1
--- /dev/null
+++ b/test_programs/execution_success/aes128_encrypt/Prover.toml
@@ -0,0 +1,4 @@
+inputs = "kevlovesrust"
+iv = "0000000000000000"
+key = "0000000000000000"
+output = "F40E7EACAB28D0BAADB8E269EE7ACDBF"
\ No newline at end of file
diff --git a/test_programs/execution_success/aes128_encrypt/src/main.nr b/test_programs/execution_success/aes128_encrypt/src/main.nr
new file mode 100644
index 00000000000..f6ed0f309c3
--- /dev/null
+++ b/test_programs/execution_success/aes128_encrypt/src/main.nr
@@ -0,0 +1,44 @@
+use dep::std;
+
+unconstrained fn decode_ascii(ascii: u8) -> u8 {
+    if ascii < 58 {
+        ascii - 48
+    } else if ascii < 71 {
+        ascii - 55
+    } else {
+        ascii - 87
+    }
+}
+
+unconstrained fn decode_hex<N, M>(s: str<N>) -> [u8; M] {
+    let mut result: [u8; M] = [0; M];
+    let as_bytes = s.as_bytes();
+    for i in 0..N {
+        if i % 2 != 0 {
+            continue;
+        }
+        result[i/2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]);
+    }
+    result
+}
+
+unconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] {
+    let slice_res = std::aes128::aes128_encrypt(plaintext, iv, key);
+    let mut result = [0; 16];
+    for i in 0..16 {
+        result[i] = slice_res[i];
+    }
+    result
+}
+
+fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {
+    let result = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
+    let output_bytes: [u8; 16] = decode_hex(output);
+    for i in 0..16 {
+        assert(result[i] == output_bytes[i]);
+    }
+    let unconstrained_result = cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
+    for i in 0..16 {
+        assert(unconstrained_result[i] == output_bytes[i]);
+    }
+}
diff --git a/test_programs/execution_success/scalar_mul/Nargo.toml b/test_programs/execution_success/brillig_embedded_curve/Nargo.toml
similarity index 62%
rename from test_programs/execution_success/scalar_mul/Nargo.toml
rename to test_programs/execution_success/brillig_embedded_curve/Nargo.toml
index 926114ec374..b92e11d6383 100644
--- a/test_programs/execution_success/scalar_mul/Nargo.toml
+++ b/test_programs/execution_success/brillig_embedded_curve/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "scalar_mul"
+name = "brillig_embedded_curve"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/brillig_embedded_curve/Prover.toml b/test_programs/execution_success/brillig_embedded_curve/Prover.toml
new file mode 100644
index 00000000000..7113b9cd038
--- /dev/null
+++ b/test_programs/execution_success/brillig_embedded_curve/Prover.toml
@@ -0,0 +1,3 @@
+priv_key = "1"
+pub_x = "0x0000000000000000000000000000000000000000000000000000000000000001"
+pub_y = "0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c"
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_embedded_curve/src/main.nr b/test_programs/execution_success/brillig_embedded_curve/src/main.nr
new file mode 100644
index 00000000000..8a1a7f08975
--- /dev/null
+++ b/test_programs/execution_success/brillig_embedded_curve/src/main.nr
@@ -0,0 +1,24 @@
+use dep::std;
+
+unconstrained fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
+    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
+    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y };
+
+    // Test that multi_scalar_mul correctly derives the public key
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y], [priv_key, 0]);
+    assert(res[0] == pub_x);
+    assert(res[1] == pub_y);
+
+    // Test that double function calling embedded_curve_add works as expected
+    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y };
+    let res = pub_point.double();
+    let double = g1.add(g1);
+
+    assert(double.x == res.x);
+
+    // Test calling multi_scalar_mul with multiple points and scalars
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y, g1.x, g1.y], [priv_key, 0, priv_key, 0]);
+
+    // The results should be double the g1 point because the scalars are 1 and we pass in g1 twice
+    assert(double.x == res[0]);
+}
diff --git a/test_programs/execution_success/brillig_scalar_mul/Prover.toml b/test_programs/execution_success/brillig_scalar_mul/Prover.toml
deleted file mode 100644
index 69b91cb5f31..00000000000
--- a/test_programs/execution_success/brillig_scalar_mul/Prover.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-a = "1"
-a_pub_x = "0x0000000000000000000000000000000000000000000000000000000000000001"
-a_pub_y = "0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c"
-
-b = "2"
-b_pub_x = "0x06ce1b0827aafa85ddeb49cdaa36306d19a74caa311e13d46d8bc688cdbffffe"
-b_pub_y = "0x1c122f81a3a14964909ede0ba2a6855fc93faf6fa1a788bf467be7e7a43f80ac"
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_scalar_mul/src/main.nr b/test_programs/execution_success/brillig_scalar_mul/src/main.nr
deleted file mode 100644
index c7c3a85a4ff..00000000000
--- a/test_programs/execution_success/brillig_scalar_mul/src/main.nr
+++ /dev/null
@@ -1,32 +0,0 @@
-use dep::std;
-
-unconstrained fn main(
-    a: Field,
-    a_pub_x: pub Field,
-    a_pub_y: pub Field,
-    b: Field,
-    b_pub_x: pub Field,
-    b_pub_y: pub Field
-) {
-    let mut priv_key = a;
-    let mut pub_x: Field = a_pub_x;
-    let mut pub_y: Field = a_pub_y;
-    if a != 1 {
-        // Change `a` in Prover.toml to test input `b`
-        priv_key = b;
-        pub_x = b_pub_x;
-        pub_y = b_pub_y;
-    }
-    let res = std::scalar_mul::fixed_base_embedded_curve(priv_key, 0);
-    assert(res[0] == pub_x);
-    assert(res[1] == pub_y);
-
-    let pub_point= std::scalar_mul::EmbeddedCurvePoint { x: pub_x, y: pub_y };
-    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
-    let g1= std::scalar_mul::EmbeddedCurvePoint { x: 1, y: g1_y };
-
-    let res = pub_point.double();
-    let double = g1.add(g1);
-
-    assert(double.x == res.x);
-}
diff --git a/test_programs/execution_success/brillig_scalar_mul/Nargo.toml b/test_programs/execution_success/embedded_curve_ops/Nargo.toml
similarity index 65%
rename from test_programs/execution_success/brillig_scalar_mul/Nargo.toml
rename to test_programs/execution_success/embedded_curve_ops/Nargo.toml
index eefd041b899..1c389149aaf 100644
--- a/test_programs/execution_success/brillig_scalar_mul/Nargo.toml
+++ b/test_programs/execution_success/embedded_curve_ops/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_scalar_mul"
+name = "embedded_curve_ops"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/embedded_curve_ops/Prover.toml b/test_programs/execution_success/embedded_curve_ops/Prover.toml
new file mode 100644
index 00000000000..7113b9cd038
--- /dev/null
+++ b/test_programs/execution_success/embedded_curve_ops/Prover.toml
@@ -0,0 +1,3 @@
+priv_key = "1"
+pub_x = "0x0000000000000000000000000000000000000000000000000000000000000001"
+pub_y = "0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c"
\ No newline at end of file
diff --git a/test_programs/execution_success/embedded_curve_ops/src/main.nr b/test_programs/execution_success/embedded_curve_ops/src/main.nr
new file mode 100644
index 00000000000..3cb27d8c181
--- /dev/null
+++ b/test_programs/execution_success/embedded_curve_ops/src/main.nr
@@ -0,0 +1,24 @@
+use dep::std;
+
+fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
+    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
+    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y };
+
+    // Test that multi_scalar_mul correctly derives the public key
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y], [priv_key, 0]);
+    assert(res[0] == pub_x);
+    assert(res[1] == pub_y);
+
+    // Test that double function calling embedded_curve_add works as expected
+    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y };
+    let res = pub_point.double();
+    let double = g1.add(g1);
+
+    assert(double.x == res.x);
+
+    // Test calling multi_scalar_mul with multiple points and scalars
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y, g1.x, g1.y], [priv_key, 0, priv_key, 0]);
+
+    // The results should be double the g1 point because the scalars are 1 and we pass in g1 twice
+    assert(double.x == res[0]);
+}
diff --git a/test_programs/execution_success/inline_never_basic/Nargo.toml b/test_programs/execution_success/inline_never_basic/Nargo.toml
new file mode 100644
index 00000000000..16691770d76
--- /dev/null
+++ b/test_programs/execution_success/inline_never_basic/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "inline_never_basic"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/inline_never_basic/Prover.toml b/test_programs/execution_success/inline_never_basic/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/inline_never_basic/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/inline_never_basic/src/main.nr b/test_programs/execution_success/inline_never_basic/src/main.nr
new file mode 100644
index 00000000000..1922aaedb6c
--- /dev/null
+++ b/test_programs/execution_success/inline_never_basic/src/main.nr
@@ -0,0 +1,8 @@
+fn main(x: Field, y: pub Field) {
+    basic_check(x, y);
+}
+
+#[inline(never)]
+fn basic_check(x: Field, y: Field) {
+    assert(x != y);
+}
diff --git a/test_programs/execution_success/scalar_mul/Prover.toml b/test_programs/execution_success/scalar_mul/Prover.toml
deleted file mode 100644
index 69b91cb5f31..00000000000
--- a/test_programs/execution_success/scalar_mul/Prover.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-a = "1"
-a_pub_x = "0x0000000000000000000000000000000000000000000000000000000000000001"
-a_pub_y = "0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c"
-
-b = "2"
-b_pub_x = "0x06ce1b0827aafa85ddeb49cdaa36306d19a74caa311e13d46d8bc688cdbffffe"
-b_pub_y = "0x1c122f81a3a14964909ede0ba2a6855fc93faf6fa1a788bf467be7e7a43f80ac"
\ No newline at end of file
diff --git a/test_programs/execution_success/scalar_mul/src/main.nr b/test_programs/execution_success/scalar_mul/src/main.nr
deleted file mode 100644
index e20f47907db..00000000000
--- a/test_programs/execution_success/scalar_mul/src/main.nr
+++ /dev/null
@@ -1,31 +0,0 @@
-use dep::std;
-
-fn main(
-    a: Field,
-    a_pub_x: pub Field,
-    a_pub_y: pub Field,
-    b: Field,
-    b_pub_x: pub Field,
-    b_pub_y: pub Field
-) {
-    let mut priv_key = a;
-    let mut pub_x: Field = a_pub_x;
-    let mut pub_y: Field = a_pub_y;
-    if a != 1 {
-        // Change `a` in Prover.toml to test input `b`
-        priv_key = b;
-        pub_x = b_pub_x;
-        pub_y = b_pub_y;
-    }
-    let res = std::scalar_mul::fixed_base_embedded_curve(priv_key, 0);
-    assert(res[0] == pub_x);
-    assert(res[1] == pub_y);
-    let pub_point= std::scalar_mul::EmbeddedCurvePoint { x: pub_x, y: pub_y };
-    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
-    let g1= std::scalar_mul::EmbeddedCurvePoint { x: 1, y: g1_y };
-
-    let res = pub_point.double();
-    let double = g1.add(g1);
-
-    assert(double.x == res.x);
-}
diff --git a/test_programs/execution_success/simple_shield/src/main.nr b/test_programs/execution_success/simple_shield/src/main.nr
index c46d3b4594c..548ba17d462 100644
--- a/test_programs/execution_success/simple_shield/src/main.nr
+++ b/test_programs/execution_success/simple_shield/src/main.nr
@@ -13,7 +13,7 @@ fn main(
     to_pubkey_y: Field
 ) -> pub [Field; 2] {
     // Compute public key from private key to show ownership
-    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key, 0);
+    let pubkey = std::embedded_curve_ops::fixed_base_scalar_mul(priv_key, 0);
     let pubkey_x = pubkey[0];
     let pubkey_y = pubkey[1];
     // Compute input note commitment
diff --git a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
index d2b7d155a32..56ee5cfa586 100644
--- a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
+++ b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
@@ -17,3 +17,67 @@ fn test_should_fail_with_runtime_match() {
 fn test_should_fail_without_runtime_match() {
     assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0);
 }
+
+struct InvalidPointError {
+    point: dep::std::hash::PedersenPoint,
+}
+
+#[test(should_fail_with = "InvalidPointError { point: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 } }")]
+fn test_should_fail_with_struct() {
+    let hash = dep::std::hash::pedersen_commitment([27]);
+    assert_eq(hash.x, 0, InvalidPointError { point: hash });
+}
+
+#[test(should_fail_with = "A: 0x00 is not 1!")]
+fn test_should_fail_with_basic_type_fmt_string() {
+    let a = 0;
+    let b = 1;
+    assert_eq(a, b, f"A: {a} is not 1!");
+}
+
+#[test(should_fail_with = "Invalid hash: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 }")]
+fn test_should_fail_with_struct_fmt_string() {
+    let hash = dep::std::hash::pedersen_commitment([27]);
+    assert_eq(hash.x, 0, f"Invalid hash: {hash}");
+}
+
+// Also test unconstrained versions
+
+#[test(should_fail_with = "Not equal")]
+unconstrained fn unconstrained_test_should_fail_with_match() {
+    assert_eq(0, 1, "Not equal");
+}
+
+#[test(should_fail)]
+unconstrained fn unconstrained_test_should_fail_without_match() {
+    assert_eq(0, 1);
+}
+
+#[test(should_fail_with = "Not equal")]
+unconstrained fn unconstrained_test_should_fail_with_runtime_match() {
+    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0, "Not equal");
+}
+
+#[test(should_fail)]
+unconstrained fn unconstrained_test_should_fail_without_runtime_match() {
+    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0);
+}
+
+#[test(should_fail_with = "InvalidPointError { point: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 } }")]
+unconstrained fn unconstrained_test_should_fail_with_struct() {
+    let hash = dep::std::hash::pedersen_commitment([27]);
+    assert_eq(hash.x, 0, InvalidPointError { point: hash });
+}
+
+#[test(should_fail_with = "A: 0x00 is not 1!")]
+unconstrained fn unconstrained_test_should_fail_with_basic_type_fmt_string() {
+    let a = 0;
+    let b = 1;
+    assert_eq(a, b, f"A: {a} is not 1!");
+}
+
+#[test(should_fail_with = "Invalid hash: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 }")]
+unconstrained fn unconstrained_test_should_fail_with_struct_fmt_string() {
+    let hash = dep::std::hash::pedersen_commitment([27]);
+    assert_eq(hash.x, 0, f"Invalid hash: {hash}");
+}
diff --git a/test_programs/rebuild.sh b/test_programs/rebuild.sh
index a3137920fd5..51e97278281 100755
--- a/test_programs/rebuild.sh
+++ b/test_programs/rebuild.sh
@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 set -e
 
+NO_PARALLEL=${1:-}
+
 process_dir() {
     local dir=$1
     local current_dir=$2
@@ -46,10 +48,17 @@ done
 
 # Process each directory in parallel
 pids=()
+if [ -z $NO_PARALLEL ]; then
 for dir in "${dirs_to_process[@]}"; do
     process_dir "$dir" "$current_dir" &
     pids+=($!)
 done
+else
+for dir in "${dirs_to_process[@]}"; do
+    process_dir "$dir" "$current_dir"
+    pids+=($!)
+done
+fi
 
 # Check the exit status of each background job.
 for pid in "${pids[@]}"; do
@@ -58,5 +67,7 @@ done
 
 # Exit with a failure status if any job failed.
 if [ ! -z "$exit_status" ]; then
+    echo "Rebuild failed!"
     exit $exit_status
-fi
\ No newline at end of file
+fi
+echo "Rebuild Succeeded!"
\ No newline at end of file
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index b3dfff9e94c..45da7f9d00c 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.35.1";
+const VERSION: &str = "0.38.0";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index fccf4566258..cda26169421 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -23,4 +23,5 @@ regression_4709
 fold_distinct_return
 fold_fibonacci
 fold_complex_outputs
-slice_init_with_complex_type
\ No newline at end of file
+slice_init_with_complex_type
+hashmap
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index a423016eacf..ea32c864a0b 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -2,7 +2,6 @@ use crate::foreign_calls::DebugForeignCallExecutor;
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
-use acvm::brillig_vm::brillig::ForeignCallResult;
 use acvm::brillig_vm::MemoryValue;
 use acvm::pwg::{
     ACVMStatus, BrilligSolver, BrilligSolverStatus, ForeignCallWaitInfo, StepResult, ACVM,
@@ -54,6 +53,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
                 &circuit.opcodes,
                 initial_witness,
                 unconstrained_functions,
+                &circuit.assert_messages,
             ),
             brillig_solver: None,
             foreign_call_executor,
@@ -356,9 +356,6 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         let foreign_call_result = self.foreign_call_executor.execute(&foreign_call);
         match foreign_call_result {
             Ok(foreign_call_result) => {
-                let foreign_call_result = foreign_call_result
-                    .get_brillig_output()
-                    .unwrap_or(ForeignCallResult::default());
                 if let Some(mut solver) = self.brillig_solver.take() {
                     solver.resolve_pending_foreign_call(foreign_call_result);
                     self.brillig_solver = Some(solver);
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index f11ac22cd75..209439f5f92 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -5,7 +5,7 @@ use acvm::{
 };
 use nargo::{
     artifacts::debug::{DebugArtifact, DebugVars, StackFrame},
-    ops::{DefaultForeignCallExecutor, ForeignCallExecutor, NargoForeignCallResult},
+    ops::{DefaultForeignCallExecutor, ForeignCallExecutor},
 };
 use noirc_errors::debug_info::{DebugFnId, DebugVarId};
 use noirc_printable_type::ForeignCallError;
@@ -94,7 +94,7 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<NargoForeignCallResult, ForeignCallError> {
+    ) -> Result<ForeignCallResult, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match DebugForeignCall::lookup(foreign_call_name) {
             Some(DebugForeignCall::VarAssign) => {
@@ -105,7 +105,7 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                         foreign_call.inputs[1..].iter().flat_map(|x| x.fields()).collect();
                     self.debug_vars.assign_var(var_id, &values);
                 }
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(DebugForeignCall::VarDrop) => {
                 let fcp_var_id = &foreign_call.inputs[0];
@@ -113,7 +113,7 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                     let var_id = debug_var_id(var_id_value);
                     self.debug_vars.drop_var(var_id);
                 }
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(DebugForeignCall::MemberAssign(arity)) => {
                 if let Some(ForeignCallParam::Single(var_id_value)) = foreign_call.inputs.first() {
@@ -141,7 +141,7 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                         .collect();
                     self.debug_vars.assign_field(var_id, indexes, &values);
                 }
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(DebugForeignCall::DerefAssign) => {
                 let fcp_var_id = &foreign_call.inputs[0];
@@ -150,7 +150,7 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                     let var_id = debug_var_id(var_id_value);
                     self.debug_vars.assign_deref(var_id, &fcp_value.fields());
                 }
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(DebugForeignCall::FnEnter) => {
                 let fcp_fn_id = &foreign_call.inputs[0];
@@ -159,11 +159,11 @@ impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
                 };
                 let fn_id = debug_fn_id(fn_id_value);
                 self.debug_vars.push_fn(fn_id);
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(DebugForeignCall::FnExit) => {
                 self.debug_vars.pop_fn();
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             None => self.executor.execute(foreign_call),
         }
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 0fea9b16b54..249406effaf 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -24,12 +24,12 @@ impl BlackBoxFunctionSolver for WrapperSolver {
         self.0.pedersen_commitment(inputs, domain_separator)
     }
 
-    fn fixed_base_scalar_mul(
+    fn multi_scalar_mul(
         &self,
-        low: &acvm::FieldElement,
-        high: &acvm::FieldElement,
+        points: &[acvm::FieldElement],
+        scalars: &[acvm::FieldElement],
     ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
-        self.0.fixed_base_scalar_mul(low, high)
+        self.0.multi_scalar_mul(points, scalars)
     }
 
     fn pedersen_hash(
diff --git a/tooling/nargo/src/errors.rs b/tooling/nargo/src/errors.rs
index ac03330a7c8..63a72247e2f 100644
--- a/tooling/nargo/src/errors.rs
+++ b/tooling/nargo/src/errors.rs
@@ -1,7 +1,13 @@
+use std::collections::BTreeMap;
+
 use acvm::{
-    acir::circuit::{OpcodeLocation, ResolvedOpcodeLocation},
+    acir::circuit::{
+        ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
+        ResolvedOpcodeLocation,
+    },
     pwg::{ErrorLocation, OpcodeResolutionError},
 };
+use noirc_abi::{display_abi_error, Abi, AbiErrorType};
 use noirc_errors::{
     debug_info::DebugInfo, reporter::ReportedErrors, CustomDiagnostic, FileDiagnostic,
 };
@@ -53,24 +59,34 @@ impl NargoError {
     ///
     /// We want to extract the user defined error so that we can compare it
     /// in tests to expected failure messages
-    pub fn user_defined_failure_message(&self) -> Option<&str> {
+    pub fn user_defined_failure_message(
+        &self,
+        error_types: &BTreeMap<ErrorSelector, AbiErrorType>,
+    ) -> Option<String> {
         let execution_error = match self {
             NargoError::ExecutionError(error) => error,
             _ => return None,
         };
 
         match execution_error {
-            ExecutionError::AssertionFailed(message, _) => Some(message),
+            ExecutionError::AssertionFailed(payload, _) => match payload {
+                ResolvedAssertionPayload::String(message) => Some(message.to_string()),
+                ResolvedAssertionPayload::Raw(raw) => {
+                    let abi_type = error_types.get(&raw.selector)?;
+                    let decoded = display_abi_error(&raw.data, abi_type.clone());
+                    Some(decoded.to_string())
+                }
+            },
             ExecutionError::SolvingError(error, _) => match error {
                 OpcodeResolutionError::IndexOutOfBounds { .. }
                 | OpcodeResolutionError::OpcodeNotSolvable(_)
                 | OpcodeResolutionError::UnsatisfiedConstrain { .. }
                 | OpcodeResolutionError::AcirMainCallAttempted { .. }
+                | OpcodeResolutionError::BrilligFunctionFailed { .. }
                 | OpcodeResolutionError::AcirCallOutputsMismatch { .. } => None,
-                OpcodeResolutionError::BrilligFunctionFailed { message, .. } => {
-                    message.as_ref().map(|s| s.as_str())
+                OpcodeResolutionError::BlackBoxFunctionFailed(_, reason) => {
+                    Some(reason.to_string())
                 }
-                OpcodeResolutionError::BlackBoxFunctionFailed(_, reason) => Some(reason),
             },
         }
     }
@@ -78,8 +94,8 @@ impl NargoError {
 
 #[derive(Debug, Error)]
 pub enum ExecutionError {
-    #[error("Failed assertion: '{}'", .0)]
-    AssertionFailed(String, Vec<ResolvedOpcodeLocation>),
+    #[error("Failed assertion")]
+    AssertionFailed(ResolvedAssertionPayload, Vec<ResolvedOpcodeLocation>),
 
     #[error("Failed to solve program: '{}'", .0)]
     SolvingError(OpcodeResolutionError, Option<Vec<ResolvedOpcodeLocation>>),
@@ -101,7 +117,7 @@ fn extract_locations_from_error(
             acir_call_stack,
         )
         | ExecutionError::SolvingError(
-            OpcodeResolutionError::UnsatisfiedConstrain { opcode_location: error_location },
+            OpcodeResolutionError::UnsatisfiedConstrain { opcode_location: error_location, .. },
             acir_call_stack,
         ) => match error_location {
             ErrorLocation::Unresolved => {
@@ -144,11 +160,27 @@ fn extract_locations_from_error(
     )
 }
 
-fn extract_message_from_error(nargo_err: &NargoError) -> String {
+fn extract_message_from_error(
+    error_types: &BTreeMap<ErrorSelector, AbiErrorType>,
+    nargo_err: &NargoError,
+) -> String {
     match nargo_err {
-        NargoError::ExecutionError(ExecutionError::AssertionFailed(message, _)) => {
+        NargoError::ExecutionError(ExecutionError::AssertionFailed(
+            ResolvedAssertionPayload::String(message),
+            _,
+        )) => {
             format!("Assertion failed: '{message}'")
         }
+        NargoError::ExecutionError(ExecutionError::AssertionFailed(
+            ResolvedAssertionPayload::Raw(RawAssertionPayload { selector, data }),
+            ..,
+        )) => {
+            if let Some(error_type) = error_types.get(selector) {
+                format!("Assertion failed: {}", display_abi_error(data, error_type.clone()))
+            } else {
+                "Assertion failed".to_string()
+            }
+        }
         NargoError::ExecutionError(ExecutionError::SolvingError(
             OpcodeResolutionError::IndexOutOfBounds { index, array_size, .. },
             _,
@@ -166,6 +198,7 @@ fn extract_message_from_error(nargo_err: &NargoError) -> String {
 /// Tries to generate a runtime diagnostic from a nargo error. It will successfully do so if it's a runtime error with a call stack.
 pub fn try_to_diagnose_runtime_error(
     nargo_err: &NargoError,
+    abi: &Abi,
     debug: &[DebugInfo],
 ) -> Option<FileDiagnostic> {
     let source_locations = match nargo_err {
@@ -177,7 +210,7 @@ pub fn try_to_diagnose_runtime_error(
     // The location of the error itself will be the location at the top
     // of the call stack (the last item in the Vec).
     let location = source_locations.last()?;
-    let message = extract_message_from_error(nargo_err);
+    let message = extract_message_from_error(&abi.error_types, nargo_err);
     Some(
         CustomDiagnostic::simple_error(message, String::new(), location.span)
             .in_file(location.file)
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 34755d14ed2..4a75212ba47 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -1,7 +1,6 @@
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{OpcodeLocation, Program, ResolvedOpcodeLocation};
 use acvm::acir::native_types::WitnessStack;
-use acvm::brillig_vm::brillig::ForeignCallResult;
 use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ACVM};
 use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
@@ -9,7 +8,7 @@ use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 use crate::errors::ExecutionError;
 use crate::NargoError;
 
-use super::foreign_calls::{ForeignCallExecutor, NargoForeignCallResult};
+use super::foreign_calls::ForeignCallExecutor;
 
 struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
     functions: &'a [Circuit],
@@ -63,10 +62,9 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
             &circuit.opcodes,
             initial_witness,
             self.unconstrained_functions,
+            &circuit.assert_messages,
         );
 
-        // This message should be resolved by a nargo foreign call only when we have an unsatisfied assertion.
-        let mut assert_message: Option<String> = None;
         loop {
             let solver_status = acvm.solve();
 
@@ -79,6 +77,7 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                     let call_stack = match &error {
                         OpcodeResolutionError::UnsatisfiedConstrain {
                             opcode_location: ErrorLocation::Resolved(opcode_location),
+                            ..
                         }
                         | OpcodeResolutionError::IndexOutOfBounds {
                             opcode_location: ErrorLocation::Resolved(opcode_location),
@@ -103,55 +102,25 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                         _ => None,
                     };
 
-                    return Err(NargoError::ExecutionError(match call_stack {
-                        Some(call_stack) => {
-                            // First check whether we have a runtime assertion message that should be resolved on an ACVM failure
-                            // If we do not have a runtime assertion message, we check whether the error is a brillig error with a user-defined message,
-                            // and finally we should check whether the circuit has any hardcoded messages associated with a specific `OpcodeLocation`.
-                            // Otherwise return the provided opcode resolution error.
-                            if let Some(assert_message) = assert_message {
-                                ExecutionError::AssertionFailed(
-                                    assert_message.to_owned(),
-                                    call_stack,
-                                )
-                            } else if let OpcodeResolutionError::BrilligFunctionFailed {
-                                message: Some(message),
-                                ..
-                            } = &error
-                            {
-                                ExecutionError::AssertionFailed(message.to_owned(), call_stack)
-                            } else if let Some(assert_message) = circuit.get_assert_message(
-                                call_stack
-                                    .last()
-                                    .expect("Call stacks should not be empty")
-                                    .opcode_location,
-                            ) {
-                                ExecutionError::AssertionFailed(
-                                    assert_message.to_owned(),
-                                    call_stack,
-                                )
-                            } else {
-                                ExecutionError::SolvingError(error, Some(call_stack))
-                            }
+                    let assertion_payload = match &error {
+                        OpcodeResolutionError::BrilligFunctionFailed { payload, .. }
+                        | OpcodeResolutionError::UnsatisfiedConstrain { payload, .. } => {
+                            payload.clone()
                         }
-                        None => ExecutionError::SolvingError(error, None),
+                        _ => None,
+                    };
+
+                    return Err(NargoError::ExecutionError(match assertion_payload {
+                        Some(payload) => ExecutionError::AssertionFailed(
+                            payload,
+                            call_stack.expect("Should have call stack for an assertion failure"),
+                        ),
+                        None => ExecutionError::SolvingError(error, call_stack),
                     }));
                 }
                 ACVMStatus::RequiresForeignCall(foreign_call) => {
                     let foreign_call_result = self.foreign_call_executor.execute(&foreign_call)?;
-                    match foreign_call_result {
-                        NargoForeignCallResult::BrilligOutput(foreign_call_result) => {
-                            acvm.resolve_pending_foreign_call(foreign_call_result);
-                        }
-                        NargoForeignCallResult::ResolvedAssertMessage(message) => {
-                            if assert_message.is_some() {
-                                unreachable!("Resolving an assert message should happen only once as the VM should have failed");
-                            }
-                            assert_message = Some(message);
-
-                            acvm.resolve_pending_foreign_call(ForeignCallResult::default());
-                        }
-                    }
+                    acvm.resolve_pending_foreign_call(foreign_call_result);
                 }
                 ACVMStatus::RequiresAcirCall(call_info) => {
                     // Store the parent function index whose context we are currently executing
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index 90313032412..c314a230cef 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -10,69 +10,13 @@ pub trait ForeignCallExecutor {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<NargoForeignCallResult, ForeignCallError>;
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum NargoForeignCallResult {
-    BrilligOutput(ForeignCallResult),
-    ResolvedAssertMessage(String),
-}
-
-impl NargoForeignCallResult {
-    pub fn get_assert_message(self) -> Option<String> {
-        match self {
-            Self::ResolvedAssertMessage(msg) => Some(msg),
-            _ => None,
-        }
-    }
-
-    pub fn get_brillig_output(self) -> Option<ForeignCallResult> {
-        match self {
-            Self::BrilligOutput(foreign_call_result) => Some(foreign_call_result),
-            _ => None,
-        }
-    }
-}
-
-impl From<ForeignCallResult> for NargoForeignCallResult {
-    fn from(value: ForeignCallResult) -> Self {
-        Self::BrilligOutput(value)
-    }
-}
-
-impl From<String> for NargoForeignCallResult {
-    fn from(value: String) -> Self {
-        Self::ResolvedAssertMessage(value)
-    }
-}
-
-impl From<FieldElement> for NargoForeignCallResult {
-    fn from(value: FieldElement) -> Self {
-        let foreign_call_result: ForeignCallResult = value.into();
-        foreign_call_result.into()
-    }
-}
-
-impl From<Vec<FieldElement>> for NargoForeignCallResult {
-    fn from(values: Vec<FieldElement>) -> Self {
-        let foreign_call_result: ForeignCallResult = values.into();
-        foreign_call_result.into()
-    }
-}
-
-impl From<Vec<ForeignCallParam>> for NargoForeignCallResult {
-    fn from(values: Vec<ForeignCallParam>) -> Self {
-        let foreign_call_result: ForeignCallResult = values.into();
-        foreign_call_result.into()
-    }
+    ) -> Result<ForeignCallResult, ForeignCallError>;
 }
 
 /// This enumeration represents the Brillig foreign calls that are natively supported by nargo.
 /// After resolution of a foreign call, nargo will restart execution of the ACVM
 pub enum ForeignCall {
     Print,
-    AssertMessage,
     CreateMock,
     SetMockParams,
     GetMockLastParams,
@@ -91,7 +35,6 @@ impl ForeignCall {
     pub(crate) fn name(&self) -> &'static str {
         match self {
             ForeignCall::Print => "print",
-            ForeignCall::AssertMessage => "assert_message",
             ForeignCall::CreateMock => "create_mock",
             ForeignCall::SetMockParams => "set_mock_params",
             ForeignCall::GetMockLastParams => "get_mock_last_params",
@@ -104,7 +47,6 @@ impl ForeignCall {
     pub(crate) fn lookup(op_name: &str) -> Option<ForeignCall> {
         match op_name {
             "print" => Some(ForeignCall::Print),
-            "assert_message" => Some(ForeignCall::AssertMessage),
             "create_mock" => Some(ForeignCall::CreateMock),
             "set_mock_params" => Some(ForeignCall::SetMockParams),
             "get_mock_last_params" => Some(ForeignCall::GetMockLastParams),
@@ -223,13 +165,6 @@ impl DefaultForeignCallExecutor {
         Ok(())
     }
 
-    fn execute_assert_message(
-        foreign_call_inputs: &[ForeignCallParam],
-    ) -> Result<NargoForeignCallResult, ForeignCallError> {
-        let display_string = Self::format_printable_value(foreign_call_inputs, true)?;
-        Ok(display_string.into())
-    }
-
     fn format_printable_value(
         foreign_call_inputs: &[ForeignCallParam],
         skip_newline: bool,
@@ -246,16 +181,15 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<NargoForeignCallResult, ForeignCallError> {
+    ) -> Result<ForeignCallResult, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match ForeignCall::lookup(foreign_call_name) {
             Some(ForeignCall::Print) => {
                 if self.show_output {
                     Self::execute_print(&foreign_call.inputs)?;
                 }
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
-            Some(ForeignCall::AssertMessage) => Self::execute_assert_message(&foreign_call.inputs),
             Some(ForeignCall::CreateMock) => {
                 let mock_oracle_name = Self::parse_string(&foreign_call.inputs[0]);
                 assert!(ForeignCall::lookup(&mock_oracle_name).is_none());
@@ -271,7 +205,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .params = Some(params.to_vec());
 
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(ForeignCall::GetMockLastParams) => {
                 let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -291,7 +225,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .result = ForeignCallResult { values: params.to_vec() };
 
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(ForeignCall::SetMockTimes) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -302,12 +236,12 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .times_left = Some(times);
 
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             Some(ForeignCall::ClearMock) => {
                 let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
                 self.mocked_responses.retain(|response| response.id != id);
-                Ok(ForeignCallResult::default().into())
+                Ok(ForeignCallResult::default())
             }
             None => {
                 let mock_response_position = self
@@ -348,7 +282,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
 
                     let parsed_response: ForeignCallResult = response.result()?;
 
-                    Ok(parsed_response.into())
+                    Ok(parsed_response)
                 } else {
                     // If there's no registered mock oracle response and no registered resolver then we cannot
                     // return a correct response to the ACVM. The best we can do is to return an empty response,
@@ -357,7 +291,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     //
                     // We optimistically return an empty response for all oracle calls as the ACVM will error
                     // should a response have been required.
-                    Ok(ForeignCallResult::default().into())
+                    Ok(ForeignCallResult::default())
                 }
             }
         }
@@ -429,7 +363,7 @@ mod tests {
         };
 
         let result = executor.execute(&foreign_call);
-        assert_eq!(result.unwrap(), ForeignCallResult { values: foreign_call.inputs }.into());
+        assert_eq!(result.unwrap(), ForeignCallResult { values: foreign_call.inputs });
 
         server.close();
     }
diff --git a/tooling/nargo/src/ops/mod.rs b/tooling/nargo/src/ops/mod.rs
index 2f5e6ebb7d4..cada2f0e915 100644
--- a/tooling/nargo/src/ops/mod.rs
+++ b/tooling/nargo/src/ops/mod.rs
@@ -3,9 +3,7 @@ pub use self::compile::{
     compile_workspace, report_errors,
 };
 pub use self::execute::execute_program;
-pub use self::foreign_calls::{
-    DefaultForeignCallExecutor, ForeignCall, ForeignCallExecutor, NargoForeignCallResult,
-};
+pub use self::foreign_calls::{DefaultForeignCallExecutor, ForeignCall, ForeignCallExecutor};
 pub use self::optimize::{optimize_contract, optimize_program};
 pub use self::transform::{transform_contract, transform_program};
 
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index b216fff827d..86dd8cd7cd5 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -2,9 +2,9 @@ use acvm::{
     acir::native_types::{WitnessMap, WitnessStack},
     BlackBoxFunctionSolver,
 };
+use noirc_abi::Abi;
 use noirc_driver::{compile_no_check, CompileError, CompileOptions};
 use noirc_errors::{debug_info::DebugInfo, FileDiagnostic};
-use noirc_evaluator::errors::RuntimeError;
 use noirc_frontend::hir::{def_map::TestFunction, Context};
 
 use crate::{errors::try_to_diagnose_runtime_error, NargoError};
@@ -44,6 +44,7 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
             );
             test_status_program_compile_pass(
                 test_function,
+                compiled_program.abi,
                 compiled_program.debug,
                 circuit_execution,
             )
@@ -64,18 +65,7 @@ fn test_status_program_compile_fail(err: CompileError, test_function: &TestFunct
         return TestStatus::CompileError(err.into());
     }
 
-    // The test has failed compilation, extract the assertion message if present and check if it's expected.
-    let assert_message = if let CompileError::RuntimeError(RuntimeError::FailedConstraint {
-        assert_message,
-        ..
-    }) = &err
-    {
-        assert_message.clone()
-    } else {
-        None
-    };
-
-    check_expected_failure_message(test_function, assert_message, Some(err.into()))
+    check_expected_failure_message(test_function, None, Some(err.into()))
 }
 
 /// The test function compiled successfully.
@@ -84,6 +74,7 @@ fn test_status_program_compile_fail(err: CompileError, test_function: &TestFunct
 /// passed/failed to determine the test status.
 fn test_status_program_compile_pass(
     test_function: &TestFunction,
+    abi: Abi,
     debug: Vec<DebugInfo>,
     circuit_execution: Result<WitnessStack, NargoError>,
 ) -> TestStatus {
@@ -105,7 +96,7 @@ fn test_status_program_compile_pass(
     // If we reach here, then the circuit execution failed.
     //
     // Check if the function should have passed
-    let diagnostic = try_to_diagnose_runtime_error(&circuit_execution_err, &debug);
+    let diagnostic = try_to_diagnose_runtime_error(&circuit_execution_err, &abi, &debug);
     let test_should_have_passed = !test_function.should_fail();
     if test_should_have_passed {
         return TestStatus::Fail {
@@ -116,7 +107,7 @@ fn test_status_program_compile_pass(
 
     check_expected_failure_message(
         test_function,
-        circuit_execution_err.user_defined_failure_message().map(|s| s.to_string()),
+        circuit_execution_err.user_defined_failure_message(&abi.error_types),
         diagnostic,
     )
 }
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 503d1606216..68f902dfe33 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -146,7 +146,9 @@ pub(crate) fn execute_program(
                 warnings: compiled_program.warnings.clone(),
             };
 
-            if let Some(diagnostic) = try_to_diagnose_runtime_error(&err, &compiled_program.debug) {
+            if let Some(diagnostic) =
+                try_to_diagnose_runtime_error(&err, &compiled_program.abi, &compiled_program.debug)
+            {
                 diagnostic.report(&debug_artifact, false);
             }
 
diff --git a/tooling/nargo_cli/src/cli/fs/inputs.rs b/tooling/nargo_cli/src/cli/fs/inputs.rs
index 023195010ac..bd038c51ad5 100644
--- a/tooling/nargo_cli/src/cli/fs/inputs.rs
+++ b/tooling/nargo_cli/src/cli/fs/inputs.rs
@@ -107,6 +107,7 @@ mod tests {
             // Neither of these should be relevant so we leave them empty.
             param_witnesses: BTreeMap::new(),
             return_witnesses: Vec::new(),
+            error_types: BTreeMap::new(),
         };
         let input_map = BTreeMap::from([
             ("foo".to_owned(), InputValue::Field(42u128.into())),
diff --git a/tooling/noir_js/scripts/compile_test_programs.sh b/tooling/noir_js/scripts/compile_test_programs.sh
index 23a4cffc072..0642159aa69 100755
--- a/tooling/noir_js/scripts/compile_test_programs.sh
+++ b/tooling/noir_js/scripts/compile_test_programs.sh
@@ -4,4 +4,4 @@ rm -rf ./test/noir_compiled_examples/**/target
 nargo --program-dir ./test/noir_compiled_examples/assert_lt compile --force
 nargo --program-dir ./test/noir_compiled_examples/assert_msg_runtime compile --force
 nargo --program-dir ./test/noir_compiled_examples/fold_fibonacci compile --force
-
+nargo --program-dir ./test/noir_compiled_examples/assert_raw_payload compile --force
diff --git a/tooling/noir_js/src/index.ts b/tooling/noir_js/src/index.ts
index bacb391a464..e7f356a582e 100644
--- a/tooling/noir_js/src/index.ts
+++ b/tooling/noir_js/src/index.ts
@@ -16,6 +16,7 @@ export { InputMap } from '@noir-lang/noirc_abi';
 export { WitnessMap, ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@noir-lang/acvm_js';
 
 export { Noir } from './program.js';
+export { ErrorWithPayload } from './witness_generation.js';
 
 /** @ignore */
 export { acvm, abi };
diff --git a/tooling/noir_js/src/witness_generation.ts b/tooling/noir_js/src/witness_generation.ts
index 67dcc774288..7d018c81d53 100644
--- a/tooling/noir_js/src/witness_generation.ts
+++ b/tooling/noir_js/src/witness_generation.ts
@@ -1,4 +1,4 @@
-import { abiEncode, InputMap } from '@noir-lang/noirc_abi';
+import { abiDecodeError, abiEncode, InputMap } from '@noir-lang/noirc_abi';
 import { base64Decode } from './base64_decode.js';
 import {
   WitnessStack,
@@ -7,8 +7,9 @@ import {
   createBlackBoxSolver,
   WasmBlackBoxFunctionSolver,
   executeProgramWithBlackBoxSolver,
+  ExecutionError,
 } from '@noir-lang/acvm_js';
-import { CompiledCircuit } from '@noir-lang/types';
+import { Abi, CompiledCircuit } from '@noir-lang/types';
 
 let solver: Promise<WasmBlackBoxFunctionSolver>;
 
@@ -26,16 +27,37 @@ const defaultForeignCallHandler: ForeignCallHandler = async (name: string, args:
     //
     // If a user needs to print values then they should provide a custom foreign call handler.
     return [];
-  } else if (name == 'assert_message') {
-    // By default we do not do anything for `assert_message` foreign calls due to a need for formatting,
-    // however we provide an empty response in order to not halt execution.
-    //
-    // If a user needs to use dynamic assertion messages then they should provide a custom foreign call handler.
-    return [];
   }
   throw Error(`Unexpected oracle during execution: ${name}(${args.join(', ')})`);
 };
 
+// Payload is any since it can be of any type defined by the circuit dev.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ErrorWithPayload = ExecutionError & { decodedAssertionPayload?: any };
+
+function parseErrorPayload(abi: Abi, originalError: ExecutionError): Error {
+  const payload = originalError.rawAssertionPayload;
+  if (!payload) return originalError;
+  const enrichedError = originalError as ErrorWithPayload;
+
+  try {
+    // Decode the payload
+    const decodedPayload = abiDecodeError(abi, payload);
+
+    if (typeof decodedPayload === 'string') {
+      // If it's a string, just add it to the error message
+      enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
+    } else {
+      // If not, attach the payload to the original error
+      enrichedError.decodedAssertionPayload = decodedPayload;
+    }
+  } catch (_errorDecoding) {
+    // Ignore errors decoding the payload
+  }
+
+  return enrichedError;
+}
+
 // Generates the witnesses needed to feed into the chosen proving system
 export async function generateWitness(
   compiledProgram: CompiledCircuit,
@@ -56,6 +78,10 @@ export async function generateWitness(
     );
     return solvedWitness;
   } catch (err) {
+    // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+    if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+      throw parseErrorPayload(compiledProgram.abi, err as ExecutionError);
+    }
     throw new Error(`Circuit execution failed: ${err}`);
   }
 }
diff --git a/tooling/noir_js/test/node/execute.test.ts b/tooling/noir_js/test/node/execute.test.ts
index 8c02ac90a3d..d047e35035f 100644
--- a/tooling/noir_js/test/node/execute.test.ts
+++ b/tooling/noir_js/test/node/execute.test.ts
@@ -1,7 +1,9 @@
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
 import assert_msg_json from '../noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json' assert { type: 'json' };
 import fold_fibonacci_json from '../noir_compiled_examples/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
-import { Noir } from '@noir-lang/noir_js';
+import assert_raw_payload_json from '../noir_compiled_examples/assert_raw_payload/target/assert_raw_payload.json' assert { type: 'json' };
+
+import { Noir, ErrorWithPayload } from '@noir-lang/noir_js';
 import { CompiledCircuit } from '@noir-lang/types';
 import { expect } from 'chai';
 
@@ -19,13 +21,97 @@ it('returns the return value of the circuit', async () => {
   expect(returnValue).to.be.eq('0x05');
 });
 
-it('circuit with a dynamic assert message should fail on an assert failure not the foreign call handler', async () => {
+it('circuit with a fmt string assert message should fail with the resolved assertion message', async () => {
   const inputs = {
     x: '10',
     y: '5',
   };
   try {
     await new Noir(assert_msg_runtime).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Expected x < y but got 10 < 5');
+  }
+});
+
+it('circuit with a raw assert payload should fail with the decoded payload', async () => {
+  const inputs = {
+    x: '7',
+    y: '5',
+  };
+  try {
+    await new Noir(assert_raw_payload_json).execute(inputs);
+  } catch (error) {
+    const knownError = error as ErrorWithPayload;
+    const invalidXYErrorSelector = Object.keys(assert_raw_payload_json.abi.error_types)[0];
+    expect(knownError.rawAssertionPayload!.selector).to.equal(invalidXYErrorSelector);
+    expect(knownError.decodedAssertionPayload).to.deep.equal({
+      x: '0x07',
+      y: '0x05',
+    });
+  }
+});
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Expected x < y but got 10 < 5');
+  }
+});
+
+it('circuit with a raw assert payload should fail with the decoded payload', async () => {
+  const inputs = {
+    x: '7',
+    y: '5',
+  };
+  try {
+    await new Noir(assert_raw_payload_json).execute(inputs);
+  } catch (error) {
+    const knownError = error as ErrorWithPayload;
+    const invalidXYErrorSelector = Object.keys(assert_raw_payload_json.abi.error_types)[0];
+    expect(knownError.rawAssertionPayload!.selector).to.equal(invalidXYErrorSelector);
+    expect(knownError.decodedAssertionPayload).to.deep.equal({
+      x: '0x07',
+      y: '0x05',
+    });
+  }
+});
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
+  }
+});
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
+  }
+});
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
   } catch (error) {
     const knownError = error as Error;
     expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr
index 40e447cad02..0bcd5c58c24 100644
--- a/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr
@@ -1,6 +1,4 @@
 fn main(x: u64, y: pub u64) {
-    // A dynamic assertion message is used to show that noirJS will ignore the call and continue execution
-    // We need this assertion to fail as the `assert_message` oracle in Noir is only called
-    // upon a failing condition in an assert.
+    // A fmtstr assertion message is used to show that noirJS will decode the error payload as a string.
     assert(x < y, f"Expected x < y but got {x} < {y}");
 }
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/Nargo.toml b/tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/Nargo.toml
new file mode 100644
index 00000000000..f88832264ea
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "assert_raw_payload"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/src/main.nr
new file mode 100644
index 00000000000..4c981330b31
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_raw_payload/src/main.nr
@@ -0,0 +1,9 @@
+struct InvalidXYError {
+    x: u64,
+    y: u64,
+}
+
+fn main(x: u64, y: pub u64) {
+    // A raw assertion payload is used to show that noirJS will decode the error payload as a struct.
+    assert(x < y, InvalidXYError { x, y });
+}
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index f0eded1ffef..3368dcd8a09 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.35.1",
+    "@aztec/bb.js": "0.38.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts b/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts
index 079a1ad268b..cfd43eff250 100644
--- a/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts
+++ b/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts
@@ -55,6 +55,7 @@ const abi: Abi = {
     visibility: 'public',
   },
   return_witnesses: [2, 13, 13],
+  error_types: {},
 };
 
 it('flattens a witness map in order of its witness indices', async () => {
diff --git a/tooling/noir_js_types/src/types.ts b/tooling/noir_js_types/src/types.ts
index 456e5a57f40..0258f2f90c9 100644
--- a/tooling/noir_js_types/src/types.ts
+++ b/tooling/noir_js_types/src/types.ts
@@ -19,6 +19,20 @@ export type AbiParameter = {
   visibility: Visibility;
 };
 
+export type AbiErrorType =
+  | {
+      error_kind: 'fmtstring';
+      length: number;
+      item_types: AbiType[];
+    }
+  | ({ error_kind: 'custom' } & AbiType);
+
+// The payload for a raw assertion error returned on execution.
+export type RawAssertionPayload = {
+  selector: string;
+  data: string[];
+};
+
 // Map from witness index to hex string value of witness.
 export type WitnessMap = Map<number, string>;
 
@@ -27,6 +41,7 @@ export type Abi = {
   param_witnesses: Record<string, { start: number; end: number }[]>;
   return_type: { abi_type: AbiType; visibility: Visibility } | null;
   return_witnesses: number[];
+  error_types: Record<string, AbiErrorType>;
 };
 
 export interface VerifierBackend {
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index 3258ea04c40..040f8a0dc79 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -12,6 +12,7 @@ license.workspace = true
 acvm.workspace = true
 iter-extended.workspace = true
 noirc_frontend.workspace = true
+noirc_printable_type.workspace = true
 toml.workspace = true
 serde_json = "1.0"
 serde.workspace = true
diff --git a/tooling/noirc_abi/src/input_parser/mod.rs b/tooling/noirc_abi/src/input_parser/mod.rs
index 4cf66820b8d..9629ddc87ab 100644
--- a/tooling/noirc_abi/src/input_parser/mod.rs
+++ b/tooling/noirc_abi/src/input_parser/mod.rs
@@ -270,6 +270,7 @@ mod serialization_tests {
             // These two fields are unused when serializing/deserializing to file.
             param_witnesses: BTreeMap::new(),
             return_witnesses: Vec::new(),
+            error_types: Default::default(),
         };
 
         let input_map: BTreeMap<String, InputValue> = BTreeMap::from([
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 8ff0154d32c..7e89a102a98 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -4,7 +4,10 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
 
 use acvm::{
-    acir::native_types::{Witness, WitnessMap},
+    acir::{
+        circuit::ErrorSelector,
+        native_types::{Witness, WitnessMap},
+    },
     FieldElement,
 };
 use errors::AbiError;
@@ -12,8 +15,12 @@ use input_parser::InputValue;
 use iter_extended::{try_btree_map, try_vecmap, vecmap};
 use noirc_frontend::ast::{Signedness, Visibility};
 use noirc_frontend::{hir::Context, Type, TypeBinding, TypeVariableKind};
+use noirc_printable_type::{
+    decode_value as printable_type_decode_value, PrintableType, PrintableValue,
+    PrintableValueDisplay,
+};
 use serde::{Deserialize, Serialize};
-use std::ops::Range;
+use std::{borrow::Borrow, ops::Range};
 use std::{collections::BTreeMap, str};
 // This is the ABI used to bridge the different TOML formats for the initial
 // witness, the partial witness generator and the interpreter.
@@ -203,6 +210,38 @@ impl AbiType {
     }
 }
 
+impl From<&AbiType> for PrintableType {
+    fn from(value: &AbiType) -> Self {
+        match value {
+            AbiType::Field => PrintableType::Field,
+            AbiType::String { length } => PrintableType::String { length: *length },
+            AbiType::Tuple { fields } => {
+                let fields = fields.iter().map(|field| field.into()).collect();
+                PrintableType::Tuple { types: fields }
+            }
+            AbiType::Array { length, typ } => {
+                let borrowed: &AbiType = typ.borrow();
+                PrintableType::Array { length: *length, typ: Box::new(borrowed.into()) }
+            }
+            AbiType::Boolean => PrintableType::Boolean,
+            AbiType::Struct { path, fields } => {
+                let fields =
+                    fields.iter().map(|(name, field)| (name.clone(), field.into())).collect();
+                PrintableType::Struct {
+                    name: path.split("::").last().unwrap_or_default().to_string(),
+                    fields,
+                }
+            }
+            AbiType::Integer { sign: Sign::Unsigned, width } => {
+                PrintableType::UnsignedInteger { width: *width }
+            }
+            AbiType::Integer { sign: Sign::Signed, width } => {
+                PrintableType::SignedInteger { width: *width }
+            }
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 /// An argument or return value of the circuit's `main` function.
 pub struct AbiParameter {
@@ -223,6 +262,7 @@ pub struct AbiReturnType {
     pub abi_type: AbiType,
     pub visibility: AbiVisibility,
 }
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Abi {
     /// An ordered list of the arguments to the program's `main` function, specifying their types and visibility.
@@ -232,6 +272,7 @@ pub struct Abi {
     pub param_witnesses: BTreeMap<String, Vec<Range<Witness>>>,
     pub return_type: Option<AbiReturnType>,
     pub return_witnesses: Vec<Witness>,
+    pub error_types: BTreeMap<ErrorSelector, AbiErrorType>,
 }
 
 impl Abi {
@@ -281,6 +322,7 @@ impl Abi {
             param_witnesses,
             return_type: self.return_type,
             return_witnesses: self.return_witnesses,
+            error_types: self.error_types,
         }
     }
 
@@ -444,7 +486,7 @@ impl Abi {
     }
 }
 
-fn decode_value(
+pub fn decode_value(
     field_iterator: &mut impl Iterator<Item = FieldElement>,
     value_type: &AbiType,
 ) -> Result<InputValue, AbiError> {
@@ -547,6 +589,57 @@ fn range_to_vec(ranges: &[Range<Witness>]) -> Vec<Witness> {
     result
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "error_kind", rename_all = "lowercase")]
+pub enum AbiErrorType {
+    FmtString { length: u64, item_types: Vec<AbiType> },
+    Custom(AbiType),
+}
+impl AbiErrorType {
+    pub fn from_type(context: &Context, typ: &Type) -> Self {
+        match typ {
+            Type::FmtString(len, item_types) => {
+                let length = len.evaluate_to_u64().expect("Cannot evaluate fmt length");
+                let Type::Tuple(item_types) = item_types.as_ref() else {
+                    unreachable!("FmtString items must be a tuple")
+                };
+                let item_types =
+                    item_types.iter().map(|typ| AbiType::from_type(context, typ)).collect();
+                Self::FmtString { length, item_types }
+            }
+            _ => Self::Custom(AbiType::from_type(context, typ)),
+        }
+    }
+}
+
+pub fn display_abi_error(
+    fields: &[FieldElement],
+    error_type: AbiErrorType,
+) -> PrintableValueDisplay {
+    match error_type {
+        AbiErrorType::FmtString { length, item_types } => {
+            let mut fields_iter = fields.iter().copied();
+            let PrintableValue::String(string) =
+                printable_type_decode_value(&mut fields_iter, &PrintableType::String { length })
+            else {
+                unreachable!("Got non-string from string decoding");
+            };
+            let _length_of_items = fields_iter.next();
+            let items = item_types.into_iter().map(|abi_type| {
+                let printable_typ = (&abi_type).into();
+                let decoded = printable_type_decode_value(&mut fields_iter, &printable_typ);
+                (decoded, printable_typ)
+            });
+            PrintableValueDisplay::FmtString(string, items.collect())
+        }
+        AbiErrorType::Custom(abi_typ) => {
+            let printable_type = (&abi_typ).into();
+            let decoded = printable_type_decode_value(&mut fields.iter().copied(), &printable_type);
+            PrintableValueDisplay::Plain(decoded, printable_type)
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::collections::BTreeMap;
@@ -583,6 +676,7 @@ mod test {
                 visibility: AbiVisibility::Public,
             }),
             return_witnesses: vec![Witness(3)],
+            error_types: BTreeMap::default(),
         };
 
         // Note we omit return value from inputs
diff --git a/tooling/noirc_abi_wasm/build.sh b/tooling/noirc_abi_wasm/build.sh
index 16fb26e55db..c07d2d8a4c1 100755
--- a/tooling/noirc_abi_wasm/build.sh
+++ b/tooling/noirc_abi_wasm/build.sh
@@ -25,7 +25,7 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-require_command wasm-opt
+#require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')
diff --git a/tooling/noirc_abi_wasm/src/lib.rs b/tooling/noirc_abi_wasm/src/lib.rs
index fad5abaebba..10c0c43b352 100644
--- a/tooling/noirc_abi_wasm/src/lib.rs
+++ b/tooling/noirc_abi_wasm/src/lib.rs
@@ -5,12 +5,16 @@
 // See Cargo.toml for explanation.
 use getrandom as _;
 
-use acvm::acir::native_types::{WitnessMap, WitnessStack};
+use acvm::acir::{
+    circuit::RawAssertionPayload,
+    native_types::{WitnessMap, WitnessStack},
+};
 use iter_extended::try_btree_map;
 use noirc_abi::{
+    decode_value, display_abi_error,
     errors::InputParserError,
     input_parser::{json::JsonTypes, InputValue},
-    Abi, MAIN_RETURN_NAME,
+    Abi, AbiErrorType, MAIN_RETURN_NAME,
 };
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -26,8 +30,8 @@ use js_witness_map::JsWitnessMap;
 
 #[wasm_bindgen(typescript_custom_section)]
 const INPUT_MAP: &'static str = r#"
-import { Field, InputValue, InputMap, Visibility, Sign, AbiType, AbiParameter, Abi, WitnessMap } from "@noir-lang/types";
-export { Field, InputValue, InputMap, Visibility, Sign, AbiType, AbiParameter, Abi, WitnessMap } from "@noir-lang/types";
+import { Field, InputValue, InputMap, Visibility, Sign, AbiType, AbiParameter, Abi, WitnessMap, RawAssertionPayload } from "@noir-lang/types";
+export { Field, InputValue, InputMap, Visibility, Sign, AbiType, AbiParameter, Abi, WitnessMap, RawAssertionPayload } from "@noir-lang/types";
 "#;
 
 #[wasm_bindgen]
@@ -40,6 +44,10 @@ extern "C" {
     #[derive(Clone, Debug, PartialEq, Eq)]
     pub type JsInputValue;
 
+    #[wasm_bindgen(extends = js_sys::Object, js_name = "RawAssertionPayload", typescript_type = "RawAssertionPayload")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsRawAssertionPayload;
+
     #[wasm_bindgen(extends = js_sys::Object, js_name = "Abi", typescript_type = "Abi")]
     #[derive(Clone, Debug, PartialEq, Eq)]
     pub type JsAbi;
@@ -122,3 +130,30 @@ pub fn serialise_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsAbiErro
     let output = witness_stack.try_into();
     output.map_err(|_| JsAbiError::new("Failed to convert to Vec<u8>".to_string()))
 }
+
+#[wasm_bindgen(js_name = abiDecodeError)]
+pub fn abi_decode_error(
+    abi: JsAbi,
+    raw_error: JsRawAssertionPayload,
+) -> Result<JsValue, JsAbiError> {
+    console_error_panic_hook::set_once();
+    let mut abi: Abi =
+        JsValueSerdeExt::into_serde(&JsValue::from(abi)).map_err(|err| err.to_string())?;
+
+    let raw_error: RawAssertionPayload =
+        JsValueSerdeExt::into_serde(&JsValue::from(raw_error)).map_err(|err| err.to_string())?;
+
+    let error_type = abi.error_types.remove(&raw_error.selector).expect("Missing error type");
+    match error_type {
+        AbiErrorType::FmtString { .. } => {
+            let string = display_abi_error(&raw_error.data, error_type).to_string();
+            Ok(JsValue::from_str(&string))
+        }
+        AbiErrorType::Custom(typ) => {
+            let input_value = decode_value(&mut raw_error.data.into_iter(), &typ)?;
+            let json_types = JsonTypes::try_from_input_value(&input_value, &typ)?;
+            <wasm_bindgen::JsValue as JsValueSerdeExt>::from_serde(&json_types)
+                .map_err(|err| err.to_string().into())
+        }
+    }
+}
diff --git a/tooling/noirc_abi_wasm/test/browser/decode_error.test.ts b/tooling/noirc_abi_wasm/test/browser/decode_error.test.ts
new file mode 100644
index 00000000000..2407ddc6535
--- /dev/null
+++ b/tooling/noirc_abi_wasm/test/browser/decode_error.test.ts
@@ -0,0 +1,64 @@
+import { expect } from '@esm-bundle/chai';
+import initNoirAbi, { RawAssertionPayload, abiDecodeError } from '@noir-lang/noirc_abi';
+
+beforeEach(async () => {
+  await initNoirAbi();
+});
+
+it('Recovers custom field errors', async () => {
+  const { FAKE_FIELD_SELECTOR, abi } = await import('../shared/decode_error');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_FIELD_SELECTOR,
+    data: ['0x000001'],
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.equal('0x01');
+});
+
+it('Recovers custom tuple errors', async () => {
+  const { FAKE_TUPLE_SELECTOR, abi } = await import('../shared/decode_error');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_TUPLE_SELECTOR,
+    data: ['0x000001', '0x000002'],
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.deep.equal(['0x01', '0x02']);
+});
+
+it('Recovers custom fmt string errors', async () => {
+  const { FAKE_FMT_STRING_SELECTOR, abi, SAMPLE_FMT_STRING } = await import('../shared/decode_error');
+
+  // FmtStrings contain the string serialized to fields
+  const data = [...SAMPLE_FMT_STRING].map((c) => `0x${c.charCodeAt(0).toString(16)}`);
+  // Then they contain the length of the values to replace
+  data.push('0x01');
+  // And then the value to replace
+  data.push('0x07');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_FMT_STRING_SELECTOR,
+    data,
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.equal('hello 0x07');
+});
+
+it('Recovers struct errors', async () => {
+  const { FAKE_STRUCT_SELECTOR, abi } = await import('../shared/decode_error');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_STRUCT_SELECTOR,
+    data: ['0x01', '0x02'],
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.deep.equal({
+    a: '0x01',
+    b: '0x02',
+  });
+});
diff --git a/tooling/noirc_abi_wasm/test/node/decode_error.test.ts b/tooling/noirc_abi_wasm/test/node/decode_error.test.ts
new file mode 100644
index 00000000000..711653ad077
--- /dev/null
+++ b/tooling/noirc_abi_wasm/test/node/decode_error.test.ts
@@ -0,0 +1,60 @@
+import { expect } from 'chai';
+import { RawAssertionPayload, abiDecodeError } from '@noir-lang/noirc_abi';
+
+it('Recovers custom field errors', async () => {
+  const { FAKE_FIELD_SELECTOR, abi } = await import('../shared/decode_error');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_FIELD_SELECTOR,
+    data: ['0x000001'],
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.equal('0x01');
+});
+
+it('Recovers custom tuple errors', async () => {
+  const { FAKE_TUPLE_SELECTOR, abi } = await import('../shared/decode_error');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_TUPLE_SELECTOR,
+    data: ['0x000001', '0x000002'],
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.deep.equal(['0x01', '0x02']);
+});
+
+it('Recovers custom fmt string errors', async () => {
+  const { FAKE_FMT_STRING_SELECTOR, abi, SAMPLE_FMT_STRING } = await import('../shared/decode_error');
+
+  // FmtStrings contain the string serialized to fields
+  const data = [...SAMPLE_FMT_STRING].map((c) => `0x${c.charCodeAt(0).toString(16)}`);
+  // Then they contain the length of the values to replace
+  data.push('0x01');
+  // And then the value to replace
+  data.push('0x07');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_FMT_STRING_SELECTOR,
+    data,
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.equal('hello 0x07');
+});
+
+it('Recovers struct errors', async () => {
+  const { FAKE_STRUCT_SELECTOR, abi } = await import('../shared/decode_error');
+
+  const payload: RawAssertionPayload = {
+    selector: FAKE_STRUCT_SELECTOR,
+    data: ['0x01', '0x02'],
+  };
+
+  const decoded = abiDecodeError(abi, payload);
+  expect(decoded).to.deep.equal({
+    a: '0x01',
+    b: '0x02',
+  });
+});
diff --git a/tooling/noirc_abi_wasm/test/shared/abi_encode.ts b/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
index cb80c6710ba..f4ab8175700 100644
--- a/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
+++ b/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
@@ -12,6 +12,7 @@ export const abi: Abi = {
   param_witnesses: { foo: [{ start: 1, end: 2 }], bar: [{ start: 2, end: 4 }] },
   return_type: null,
   return_witnesses: [],
+  error_types: {},
 };
 
 export const inputs: InputMap = {
diff --git a/tooling/noirc_abi_wasm/test/shared/array_as_field.ts b/tooling/noirc_abi_wasm/test/shared/array_as_field.ts
index 0cc0035fa68..3698b913c66 100644
--- a/tooling/noirc_abi_wasm/test/shared/array_as_field.ts
+++ b/tooling/noirc_abi_wasm/test/shared/array_as_field.ts
@@ -11,6 +11,7 @@ export const abi: Abi = {
   param_witnesses: { foo: [{ start: 1, end: 3 }] },
   return_type: null,
   return_witnesses: [],
+  error_types: {},
 };
 
 export const inputs: InputMap = {
diff --git a/tooling/noirc_abi_wasm/test/shared/decode_error.ts b/tooling/noirc_abi_wasm/test/shared/decode_error.ts
new file mode 100644
index 00000000000..36eb18b5210
--- /dev/null
+++ b/tooling/noirc_abi_wasm/test/shared/decode_error.ts
@@ -0,0 +1,46 @@
+import { Abi } from '@noir-lang/noirc_abi';
+
+export const FAKE_FIELD_SELECTOR = '1';
+export const FAKE_TUPLE_SELECTOR = '2';
+export const FAKE_FMT_STRING_SELECTOR = '3';
+export const FAKE_STRUCT_SELECTOR = '4';
+
+export const SAMPLE_FMT_STRING = 'hello {a}';
+
+export const abi: Abi = {
+  parameters: [
+    {
+      name: 'foo',
+      type: { kind: 'array', length: 2, type: { kind: 'field' } },
+      visibility: 'private',
+    },
+  ],
+  param_witnesses: { foo: [{ start: 1, end: 3 }] },
+  return_type: null,
+  return_witnesses: [],
+  error_types: {
+    [FAKE_FIELD_SELECTOR]: {
+      error_kind: 'custom',
+      kind: 'field',
+    },
+    [FAKE_TUPLE_SELECTOR]: {
+      error_kind: 'custom',
+      kind: 'tuple',
+      fields: [{ kind: 'field' }, { kind: 'field' }],
+    },
+    [FAKE_FMT_STRING_SELECTOR]: {
+      error_kind: 'fmtstring',
+      length: SAMPLE_FMT_STRING.length,
+      item_types: [{ kind: 'field' }],
+    },
+    [FAKE_STRUCT_SELECTOR]: {
+      error_kind: 'custom',
+      kind: 'struct',
+      path: 'foo',
+      fields: [
+        { name: 'a', type: { kind: 'field' } },
+        { name: 'b', type: { kind: 'field' } },
+      ],
+    },
+  },
+};
diff --git a/tooling/noirc_abi_wasm/test/shared/field_as_array.ts b/tooling/noirc_abi_wasm/test/shared/field_as_array.ts
index 6ae709459de..4e3e2fd12a8 100644
--- a/tooling/noirc_abi_wasm/test/shared/field_as_array.ts
+++ b/tooling/noirc_abi_wasm/test/shared/field_as_array.ts
@@ -11,6 +11,7 @@ export const abi: Abi = {
   param_witnesses: { foo: [{ start: 1, end: 3 }] },
   return_type: null,
   return_witnesses: [],
+  error_types: {},
 };
 
 export const inputs: InputMap = {
diff --git a/tooling/noirc_abi_wasm/test/shared/structs.ts b/tooling/noirc_abi_wasm/test/shared/structs.ts
index 6614f8f278e..ee666e40e87 100644
--- a/tooling/noirc_abi_wasm/test/shared/structs.ts
+++ b/tooling/noirc_abi_wasm/test/shared/structs.ts
@@ -54,6 +54,7 @@ export const abi: Abi = {
   },
   return_type: null,
   return_witnesses: [],
+  error_types: {},
 };
 
 export const inputs: InputMap = {
diff --git a/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts b/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts
index c6e066e2bcd..82a3e3998ca 100644
--- a/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts
+++ b/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts
@@ -11,6 +11,7 @@ export const abi: Abi = {
   param_witnesses: { foo: [{ start: 1, end: 2 }] },
   return_type: null,
   return_witnesses: [],
+  error_types: {},
 };
 
 export const inputs: InputMap = {
diff --git a/yarn.lock b/yarn.lock
index e9915882fac..85966ce3392 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.35.1":
-  version: 0.35.1
-  resolution: "@aztec/bb.js@npm:0.35.1"
+"@aztec/bb.js@npm:0.38.0":
+  version: 0.38.0
+  resolution: "@aztec/bb.js@npm:0.38.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 8e3551f059523d9494af4721a9219e2c6e63c8ed1df447a2d0daa9f8526a794758ae708bd1d9c9b1fbfb89c56dc867d9f0b87250dbabfcde23ec02dabbb5a32a
+  checksum: 5ebc2850f37993db1d0fe4306ec612e9df14c5d227e1451f1b2f96e63e61c64225c46b32d1e1d2a1a0c37795e50b2875362520e9eb49324312516ec9fd6de2c7
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.35.1
+    "@aztec/bb.js": 0.38.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 190879aabb52d6b4f07e4a599af3ab2d9a40a6f4 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 8 May 2024 14:34:32 +0100
Subject: [PATCH 262/416] chore: disable `gates_report.yml` (#4997)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/gates_report.yml | 144 ++++++++++++++---------------
 1 file changed, 72 insertions(+), 72 deletions(-)

diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index ba4cb600c59..3d4bef1940e 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -1,88 +1,88 @@
-name: Report gates diff
+# name: Report gates diff
 
-on:
-  push:
-    branches:
-      - master
-  pull_request:
+# on:
+#   push:
+#     branches:
+#       - master
+#   pull_request:
 
-jobs:
-  build-nargo:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64-unknown-linux-gnu]
+# jobs:
+#   build-nargo:
+#     runs-on: ubuntu-latest
+#     strategy:
+#       matrix:
+#         target: [x86_64-unknown-linux-gnu]
 
-    steps:
-      - name: Checkout Noir repo
-        uses: actions/checkout@v4
+#     steps:
+#       - name: Checkout Noir repo
+#         uses: actions/checkout@v4
 
-      - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.74.1
+#       - name: Setup toolchain
+#         uses: dtolnay/rust-toolchain@1.74.1
 
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: ${{ matrix.target }}
-          cache-on-failure: true
-          save-if: ${{ github.event_name != 'merge_group' }}
+#       - uses: Swatinem/rust-cache@v2
+#         with:
+#           key: ${{ matrix.target }}
+#           cache-on-failure: true
+#           save-if: ${{ github.event_name != 'merge_group' }}
 
-      - name: Build Nargo
-        run: cargo build --package nargo_cli --release
+#       - name: Build Nargo
+#         run: cargo build --package nargo_cli --release
 
-      - name: Package artifacts
-        run: |
-          mkdir dist
-          cp ./target/release/nargo ./dist/nargo
-          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
+#       - name: Package artifacts
+#         run: |
+#           mkdir dist
+#           cp ./target/release/nargo ./dist/nargo
+#           7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
 
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: nargo
-          path: ./dist/*
-          retention-days: 3
+#       - name: Upload artifact
+#         uses: actions/upload-artifact@v4
+#         with:
+#           name: nargo
+#           path: ./dist/*
+#           retention-days: 3
 
 
-  compare_gas_reports:
-    needs: [build-nargo]
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
+#   compare_gas_reports:
+#     needs: [build-nargo]
+#     runs-on: ubuntu-latest
+#     permissions:
+#       pull-requests: write
 
-    steps:
-      - uses: actions/checkout@v4
+#     steps:
+#       - uses: actions/checkout@v4
 
-      - name: Download nargo binary
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: ./nargo
+#       - name: Download nargo binary
+#         uses: actions/download-artifact@v4
+#         with:
+#           name: nargo
+#           path: ./nargo
 
-      - name: Set nargo on PATH
-        run: |
-          nargo_binary="${{ github.workspace }}/nargo/nargo"
-          chmod +x $nargo_binary
-          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
-          export PATH="$PATH:$(dirname $nargo_binary)"
-          nargo -V
+#       - name: Set nargo on PATH
+#         run: |
+#           nargo_binary="${{ github.workspace }}/nargo/nargo"
+#           chmod +x $nargo_binary
+#           echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+#           export PATH="$PATH:$(dirname $nargo_binary)"
+#           nargo -V
 
-      - name: Generate gates report
-        working-directory: ./test_programs
-        run: |
-          ./gates_report.sh
-          mv gates_report.json ../gates_report.json
+#       - name: Generate gates report
+#         working-directory: ./test_programs
+#         run: |
+#           ./gates_report.sh
+#           mv gates_report.json ../gates_report.json
       
-      - name: Compare gates reports
-        id: gates_diff
-        uses: vezenovm/noir-gates-diff@acf12797860f237117e15c0d6e08d64253af52b6
-        with:
-          report: gates_report.json
-          summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
+#       - name: Compare gates reports
+#         id: gates_diff
+#         uses: vezenovm/noir-gates-diff@acf12797860f237117e15c0d6e08d64253af52b6
+#         with:
+#           report: gates_report.json
+#           summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
 
-      - name: Add gates diff to sticky comment
-        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
-        uses: marocchino/sticky-pull-request-comment@v2
-        with:
-          # delete the comment in case changes no longer impact circuit sizes
-          delete: ${{ !steps.gates_diff.outputs.markdown }}
-          message: ${{ steps.gates_diff.outputs.markdown }}
+#       - name: Add gates diff to sticky comment
+#         if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+#         uses: marocchino/sticky-pull-request-comment@v2
+#         with:
+#           # delete the comment in case changes no longer impact circuit sizes
+#           delete: ${{ !steps.gates_diff.outputs.markdown }}
+#           message: ${{ steps.gates_diff.outputs.markdown }}

From 8b65663f9e836c11a87e458bd7c6a52920448d5c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 8 May 2024 14:46:48 +0100
Subject: [PATCH 263/416] feat: implement `ops` traits on `u16`/`i16` (#4996)

# Description

## Problem\*

Followup to #4985

## Summary\*

This PR adds implementations for the `std::ops` traits for the new 16
bit traits.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 noir_stdlib/src/ops/arith.nr | 11 +++++++++++
 noir_stdlib/src/ops/bit.nr   | 10 ++++++++++
 2 files changed, 21 insertions(+)

diff --git a/noir_stdlib/src/ops/arith.nr b/noir_stdlib/src/ops/arith.nr
index ea7d633a456..df0ff978a7c 100644
--- a/noir_stdlib/src/ops/arith.nr
+++ b/noir_stdlib/src/ops/arith.nr
@@ -8,9 +8,11 @@ impl Add for Field { fn add(self, other: Field) -> Field { self + other } }
 
 impl Add for u64 { fn add(self, other: u64) -> u64 { self + other } }
 impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
+impl Add for u16 { fn add(self, other: u16) -> u16 { self + other } }
 impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
 
 impl Add for i8 { fn add(self, other: i8) -> i8 { self + other } }
+impl Add for i16 { fn add(self, other: i16) -> i16 { self + other } }
 impl Add for i32 { fn add(self, other: i32) -> i32 { self + other } }
 impl Add for i64 { fn add(self, other: i64) -> i64 { self + other } }
 
@@ -24,9 +26,11 @@ impl Sub for Field { fn sub(self, other: Field) -> Field { self - other } }
 
 impl Sub for u64 { fn sub(self, other: u64) -> u64 { self - other } }
 impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
+impl Sub for u16 { fn sub(self, other: u16) -> u16 { self - other } }
 impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
 
 impl Sub for i8 { fn sub(self, other: i8) -> i8 { self - other } }
+impl Sub for i16 { fn sub(self, other: i16) -> i16 { self - other } }
 impl Sub for i32 { fn sub(self, other: i32) -> i32 { self - other } }
 impl Sub for i64 { fn sub(self, other: i64) -> i64 { self - other } }
 
@@ -40,9 +44,11 @@ impl Mul for Field { fn mul(self, other: Field) -> Field { self * other } }
 
 impl Mul for u64 { fn mul(self, other: u64) -> u64 { self * other } }
 impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
+impl Mul for u16 { fn mul(self, other: u16) -> u16 { self * other } }
 impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
 
 impl Mul for i8 { fn mul(self, other: i8) -> i8 { self * other } }
+impl Mul for i16 { fn mul(self, other: i16) -> i16 { self * other } }
 impl Mul for i32 { fn mul(self, other: i32) -> i32 { self * other } }
 impl Mul for i64 { fn mul(self, other: i64) -> i64 { self * other } }
 
@@ -56,9 +62,11 @@ impl Div for Field { fn div(self, other: Field) -> Field { self / other } }
 
 impl Div for u64 { fn div(self, other: u64) -> u64 { self / other } }
 impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
+impl Div for u16 { fn div(self, other: u16) -> u16 { self / other } }
 impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
 
 impl Div for i8 { fn div(self, other: i8) -> i8 { self / other } }
+impl Div for i16 { fn div(self, other: i16) -> i16 { self / other } }
 impl Div for i32 { fn div(self, other: i32) -> i32 { self / other } }
 impl Div for i64 { fn div(self, other: i64) -> i64 { self / other } }
 
@@ -70,9 +78,11 @@ trait Rem{
 
 impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
 impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
 impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
 
 impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
 impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
 impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
 
@@ -86,6 +96,7 @@ trait Neg {
 impl Neg for Field { fn neg(self) -> Field { -self } }
 
 impl Neg for i8 { fn neg(self) -> i8 { -self } }
+impl Neg for i16 { fn neg(self) -> i16 { -self } }
 impl Neg for i32 { fn neg(self) -> i32 { -self } }
 impl Neg for i64 { fn neg(self) -> i64 { -self } }
 // docs:end:neg-trait-impls
diff --git a/noir_stdlib/src/ops/bit.nr b/noir_stdlib/src/ops/bit.nr
index 8a3d20b1909..ae06520e9c4 100644
--- a/noir_stdlib/src/ops/bit.nr
+++ b/noir_stdlib/src/ops/bit.nr
@@ -8,9 +8,11 @@ impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
 
 impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
 impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
 impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
 
 impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
 impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
 impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
 
@@ -24,9 +26,11 @@ impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
 
 impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
 impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
+impl BitAnd for u16 { fn bitand(self, other: u16) -> u16 { self & other } }
 impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
 
 impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
+impl BitAnd for i16 { fn bitand(self, other: i16) -> i16 { self & other } }
 impl BitAnd for i32 { fn bitand(self, other: i32) -> i32 { self & other } }
 impl BitAnd for i64 { fn bitand(self, other: i64) -> i64 { self & other } }
 
@@ -40,9 +44,11 @@ impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
 
 impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
 impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
+impl BitXor for u16 { fn bitxor(self, other: u16) -> u16 { self ^ other } }
 impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
 
 impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
+impl BitXor for i16 { fn bitxor(self, other: i16) -> i16 { self ^ other } }
 impl BitXor for i32 { fn bitxor(self, other: i32) -> i32 { self ^ other } }
 impl BitXor for i64 { fn bitxor(self, other: i64) -> i64 { self ^ other } }
 
@@ -54,10 +60,12 @@ trait Shl {
 
 impl Shl for u32 { fn shl(self, other: u8) -> u32 { self << other } }
 impl Shl for u64 { fn shl(self, other: u8) -> u64 { self << other } }
+impl Shl for u16 { fn shl(self, other: u8) -> u16 { self << other } }
 impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
 impl Shl for u1 { fn shl(self, other: u8) -> u1 { self << other } }
 
 impl Shl for i8 { fn shl(self, other: u8) -> i8 { self << other } }
+impl Shl for i16 { fn shl(self, other: u8) -> i16 { self << other } }
 impl Shl for i32 { fn shl(self, other: u8) -> i32 { self << other } }
 impl Shl for i64 { fn shl(self, other: u8) -> i64 { self << other } }
 
@@ -69,10 +77,12 @@ trait Shr {
 
 impl Shr for u64 { fn shr(self, other: u8) -> u64 { self >> other } }
 impl Shr for u32 { fn shr(self, other: u8) -> u32 { self >> other } }
+impl Shr for u16 { fn shr(self, other: u8) -> u16 { self >> other } }
 impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
 impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
 
 impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
+impl Shr for i16 { fn shr(self, other: u8) -> i16 { self >> other } }
 impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
 impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
 

From 4b16c7fe0b57473f8b1073b2ff1a6a6c4a0e766f Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Wed, 8 May 2024 09:51:31 -0400
Subject: [PATCH 264/416] chore: adding name shadowing tests template program
 (#4799)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/4672

## Summary\*

The plan is to generate variations of a test program that checks for
several types of name shadowing, and then ensure that we get expected
results or errors for different combinations of name conflicts.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 compiler/noirc_frontend/src/tests.rs          | 2481 ++++++++---------
 .../src/tests/name_shadowing.rs               |  419 +++
 2 files changed, 1642 insertions(+), 1258 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/tests/name_shadowing.rs

diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 5f99e9e347a..6f7470807be 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1,1236 +1,1214 @@
+#![cfg(test)]
+
+#[cfg(test)]
+mod name_shadowing;
+
 // XXX: These tests repeat a lot of code
 // what we should do is have test cases which are passed to a test harness
 // A test harness will allow for more expressive and readable tests
-#[cfg(test)]
-mod test {
-
-    use core::panic;
-    use std::collections::BTreeMap;
-
-    use fm::FileId;
-
-    use iter_extended::vecmap;
-    use noirc_errors::Location;
-
-    use crate::hir::def_collector::dc_crate::CompilationError;
-    use crate::hir::def_collector::errors::{DefCollectorErrorKind, DuplicateType};
-    use crate::hir::def_map::ModuleData;
-    use crate::hir::resolution::errors::ResolverError;
-    use crate::hir::resolution::import::PathResolutionError;
-    use crate::hir::type_check::TypeCheckError;
-    use crate::hir::Context;
-    use crate::node_interner::{NodeInterner, StmtId};
-
-    use crate::hir::def_collector::dc_crate::DefCollector;
-    use crate::hir_def::expr::HirExpression;
-    use crate::hir_def::stmt::HirStatement;
-    use crate::monomorphization::monomorphize;
-    use crate::parser::ParserErrorReason;
-    use crate::ParsedModule;
-    use crate::{
-        hir::def_map::{CrateDefMap, LocalModuleId},
-        parse_program,
-    };
-    use fm::FileManager;
-    use noirc_arena::Arena;
+use core::panic;
+use std::collections::BTreeMap;
+
+use fm::FileId;
+
+use iter_extended::vecmap;
+use noirc_errors::Location;
+
+use crate::hir::def_collector::dc_crate::CompilationError;
+use crate::hir::def_collector::errors::{DefCollectorErrorKind, DuplicateType};
+use crate::hir::def_map::ModuleData;
+use crate::hir::resolution::errors::ResolverError;
+use crate::hir::resolution::import::PathResolutionError;
+use crate::hir::type_check::TypeCheckError;
+use crate::hir::Context;
+use crate::node_interner::{NodeInterner, StmtId};
+
+use crate::hir::def_collector::dc_crate::DefCollector;
+use crate::hir_def::expr::HirExpression;
+use crate::hir_def::stmt::HirStatement;
+use crate::monomorphization::monomorphize;
+use crate::parser::ParserErrorReason;
+use crate::ParsedModule;
+use crate::{
+    hir::def_map::{CrateDefMap, LocalModuleId},
+    parse_program,
+};
+use fm::FileManager;
+use noirc_arena::Arena;
+
+pub(crate) fn has_parser_error(errors: &[(CompilationError, FileId)]) -> bool {
+    errors.iter().any(|(e, _f)| matches!(e, CompilationError::ParseError(_)))
+}
 
-    pub(crate) fn has_parser_error(errors: &[(CompilationError, FileId)]) -> bool {
-        errors.iter().any(|(e, _f)| matches!(e, CompilationError::ParseError(_)))
-    }
+pub(crate) fn remove_experimental_warnings(errors: &mut Vec<(CompilationError, FileId)>) {
+    errors.retain(|(error, _)| match error {
+        CompilationError::ParseError(error) => {
+            !matches!(error.reason(), Some(ParserErrorReason::ExperimentalFeature(..)))
+        }
+        _ => true,
+    });
+}
 
-    pub(crate) fn remove_experimental_warnings(errors: &mut Vec<(CompilationError, FileId)>) {
-        errors.retain(|(error, _)| match error {
-            CompilationError::ParseError(error) => {
-                !matches!(error.reason(), Some(ParserErrorReason::ExperimentalFeature(..)))
-            }
-            _ => true,
-        });
-    }
-
-    pub(crate) fn get_program(
-        src: &str,
-    ) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
-        let root = std::path::Path::new("/");
-        let fm = FileManager::new(root);
-
-        let mut context = Context::new(fm, Default::default());
-        context.def_interner.populate_dummy_operator_traits();
-        let root_file_id = FileId::dummy();
-        let root_crate_id = context.crate_graph.add_crate_root(root_file_id);
-
-        let (program, parser_errors) = parse_program(src);
-        let mut errors = vecmap(parser_errors, |e| (e.into(), root_file_id));
-        remove_experimental_warnings(&mut errors);
-
-        if !has_parser_error(&errors) {
-            // Allocate a default Module for the root, giving it a ModuleId
-            let mut modules: Arena<ModuleData> = Arena::default();
-            let location = Location::new(Default::default(), root_file_id);
-            let root = modules.insert(ModuleData::new(None, location, false));
-
-            let def_map = CrateDefMap {
-                root: LocalModuleId(root),
-                modules,
-                krate: root_crate_id,
-                extern_prelude: BTreeMap::new(),
-            };
+pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
+    let root = std::path::Path::new("/");
+    let fm = FileManager::new(root);
+
+    let mut context = Context::new(fm, Default::default());
+    context.def_interner.populate_dummy_operator_traits();
+    let root_file_id = FileId::dummy();
+    let root_crate_id = context.crate_graph.add_crate_root(root_file_id);
+
+    let (program, parser_errors) = parse_program(src);
+    let mut errors = vecmap(parser_errors, |e| (e.into(), root_file_id));
+    remove_experimental_warnings(&mut errors);
+
+    if !has_parser_error(&errors) {
+        // Allocate a default Module for the root, giving it a ModuleId
+        let mut modules: Arena<ModuleData> = Arena::default();
+        let location = Location::new(Default::default(), root_file_id);
+        let root = modules.insert(ModuleData::new(None, location, false));
+
+        let def_map = CrateDefMap {
+            root: LocalModuleId(root),
+            modules,
+            krate: root_crate_id,
+            extern_prelude: BTreeMap::new(),
+        };
 
-            // Now we want to populate the CrateDefMap using the DefCollector
-            errors.extend(DefCollector::collect(
-                def_map,
-                &mut context,
-                program.clone().into_sorted(),
-                root_file_id,
-                &[], // No macro processors
-            ));
-        }
-        (program, context, errors)
+        // Now we want to populate the CrateDefMap using the DefCollector
+        errors.extend(DefCollector::collect(
+            def_map,
+            &mut context,
+            program.clone().into_sorted(),
+            root_file_id,
+            &[], // No macro processors
+        ));
     }
+    (program, context, errors)
+}
 
-    pub(crate) fn get_program_errors(src: &str) -> Vec<(CompilationError, FileId)> {
-        get_program(src).2
-    }
+pub(crate) fn get_program_errors(src: &str) -> Vec<(CompilationError, FileId)> {
+    get_program(src).2
+}
 
-    #[test]
-    fn check_trait_implemented_for_all_t() {
-        let src = "
-        trait Default {
-            fn default() -> Self;
-        }
-        
-        trait Eq {
-            fn eq(self, other: Self) -> bool;
+#[test]
+fn check_trait_implemented_for_all_t() {
+    let src = "
+    trait Default {
+        fn default() -> Self;
+    }
+    
+    trait Eq {
+        fn eq(self, other: Self) -> bool;
+    }
+    
+    trait IsDefault {
+        fn is_default(self) -> bool;
+    }
+    
+    impl<T> IsDefault for T where T: Default + Eq {
+        fn is_default(self) -> bool {
+            self.eq(T::default())
         }
-        
-        trait IsDefault {
-            fn is_default(self) -> bool;
+    }
+    
+    struct Foo {
+        a: u64,
+    }
+    
+    impl Eq for Foo {
+        fn eq(self, other: Foo) -> bool { self.a == other.a } 
+    }
+    
+    impl Default for u64 {
+        fn default() -> Self {
+            0
         }
-        
-        impl<T> IsDefault for T where T: Default + Eq {
-            fn is_default(self) -> bool {
-                self.eq(T::default())
-            }
+    }
+    
+    impl Default for Foo {
+        fn default() -> Self {
+            Foo { a: Default::default() }
         }
-        
-        struct Foo {
-            a: u64,
+    }
+    
+    fn main(a: Foo) -> pub bool {
+        a.is_default()
+    }";
+
+    let errors = get_program_errors(src);
+    errors.iter().for_each(|err| println!("{:?}", err));
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn check_trait_implementation_duplicate_method() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Field;
+    }
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    impl Default for Foo {
+        // Duplicate trait methods should not compile
+        fn default(x: Field, y: Field) -> Field {
+            y + 2 * x
         }
-        
-        impl Eq for Foo {
-            fn eq(self, other: Foo) -> bool { self.a == other.a } 
+        // Duplicate trait methods should not compile
+        fn default(x: Field, y: Field) -> Field {
+            x + 2 * y
         }
-        
-        impl Default for u64 {
-            fn default() -> Self {
-                0
+    }
+    
+    fn main() {}";
+
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::Duplicate {
+                typ,
+                first_def,
+                second_def,
+            }) => {
+                assert_eq!(typ, &DuplicateType::TraitAssociatedFunction);
+                assert_eq!(first_def, "default");
+                assert_eq!(second_def, "default");
             }
-        }
-        
-        impl Default for Foo {
-            fn default() -> Self {
-                Foo { a: Default::default() }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
             }
-        }
-        
-        fn main(a: Foo) -> pub bool {
-            a.is_default()
-        }";
-
-        let errors = get_program_errors(src);
-        errors.iter().for_each(|err| println!("{:?}", err));
-        assert!(errors.is_empty());
+        };
     }
+}
 
-    #[test]
-    fn check_trait_implementation_duplicate_method() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Field;
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+#[test]
+fn check_trait_wrong_method_return_type() {
+    let src = "
+    trait Default {
+        fn default() -> Self;
+    }
+    
+    struct Foo {
+    }
+    
+    impl Default for Foo {
+        fn default() -> Field {
+            0
         }
-        
-        impl Default for Foo {
-            // Duplicate trait methods should not compile
-            fn default(x: Field, y: Field) -> Field {
-                y + 2 * x
+    }
+    
+    fn main() {
+    }
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::TypeError(TypeCheckError::TypeMismatch {
+                expected_typ,
+                expr_typ,
+                expr_span: _,
+            }) => {
+                assert_eq!(expected_typ, "Foo");
+                assert_eq!(expr_typ, "Field");
             }
-            // Duplicate trait methods should not compile
-            fn default(x: Field, y: Field) -> Field {
-                x + 2 * y
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
             }
-        }
-        
-        fn main() {}";
-
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::Duplicate {
-                    typ,
-                    first_def,
-                    second_def,
-                }) => {
-                    assert_eq!(typ, &DuplicateType::TraitAssociatedFunction);
-                    assert_eq!(first_def, "default");
-                    assert_eq!(second_def, "default");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_wrong_method_return_type() {
-        let src = "
-        trait Default {
-            fn default() -> Self;
-        }
-        
-        struct Foo {
+#[test]
+fn check_trait_wrong_method_return_type2() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Self;
+    }
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    impl Default for Foo {
+        fn default(x: Field, _y: Field) -> Field {
+            x
         }
-        
-        impl Default for Foo {
-            fn default() -> Field {
-                0
+    }
+    
+    fn main() {
+    }";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::TypeError(TypeCheckError::TypeMismatch {
+                expected_typ,
+                expr_typ,
+                expr_span: _,
+            }) => {
+                assert_eq!(expected_typ, "Foo");
+                assert_eq!(expr_typ, "Field");
             }
-        }
-        
-        fn main() {
-        }
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::TypeError(TypeCheckError::TypeMismatch {
-                    expected_typ,
-                    expr_typ,
-                    expr_span: _,
-                }) => {
-                    assert_eq!(expected_typ, "Foo");
-                    assert_eq!(expr_typ, "Field");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_wrong_method_return_type2() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Self;
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+#[test]
+fn check_trait_missing_implementation() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Self;
+    
+        fn method2(x: Field) -> Field;
+    
+    }
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    impl Default for Foo {
+        fn default(x: Field, y: Field) -> Self {
+            Self { bar: x, array: [x,y] }
         }
-        
-        impl Default for Foo {
-            fn default(x: Field, _y: Field) -> Field {
-                x
+    }
+    
+    fn main() {
+    }
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::TraitMissingMethod {
+                trait_name,
+                method_name,
+                trait_impl_span: _,
+            }) => {
+                assert_eq!(trait_name, "Default");
+                assert_eq!(method_name, "method2");
             }
-        }
-        
-        fn main() {
-        }";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::TypeError(TypeCheckError::TypeMismatch {
-                    expected_typ,
-                    expr_typ,
-                    expr_span: _,
-                }) => {
-                    assert_eq!(expected_typ, "Foo");
-                    assert_eq!(expr_typ, "Field");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_missing_implementation() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Self;
-        
-            fn method2(x: Field) -> Field;
-        
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+#[test]
+fn check_trait_not_in_scope() {
+    let src = "
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    // Default trait does not exist
+    impl Default for Foo {
+        fn default(x: Field, y: Field) -> Self {
+            Self { bar: x, array: [x,y] }
         }
-        
-        impl Default for Foo {
-            fn default(x: Field, y: Field) -> Self {
-                Self { bar: x, array: [x,y] }
+    }
+    
+    fn main() {
+    }
+    
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::TraitNotFound {
+                trait_path,
+            }) => {
+                assert_eq!(trait_path.as_string(), "Default");
             }
-        }
-        
-        fn main() {
-        }
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::TraitMissingMethod {
-                    trait_name,
-                    method_name,
-                    trait_impl_span: _,
-                }) => {
-                    assert_eq!(trait_name, "Default");
-                    assert_eq!(method_name, "method2");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_not_in_scope() {
-        let src = "
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+#[test]
+fn check_trait_wrong_method_name() {
+    let src = "
+    trait Default {
+    }
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    // wrong trait name method should not compile
+    impl Default for Foo {
+        fn does_not_exist(x: Field, y: Field) -> Self {
+            Self { bar: x, array: [x,y] }
         }
-        
-        // Default trait does not exist
-        impl Default for Foo {
-            fn default(x: Field, y: Field) -> Self {
-                Self { bar: x, array: [x,y] }
+    }
+    
+    fn main() {
+    }";
+    let compilation_errors = get_program_errors(src);
+    assert!(!has_parser_error(&compilation_errors));
+    assert!(
+        compilation_errors.len() == 1,
+        "Expected 1 compilation error, got: {:?}",
+        compilation_errors
+    );
+
+    for (err, _file_id) in compilation_errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::MethodNotInTrait {
+                trait_name,
+                impl_method,
+            }) => {
+                assert_eq!(trait_name, "Default");
+                assert_eq!(impl_method, "does_not_exist");
             }
-        }
-        
-        fn main() {
-        }
-        
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::TraitNotFound {
-                    trait_path,
-                }) => {
-                    assert_eq!(trait_path.as_string(), "Default");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_wrong_method_name() {
-        let src = "
-        trait Default {
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+#[test]
+fn check_trait_wrong_parameter() {
+    let src = "
+    trait Default {
+        fn default(x: Field) -> Self;
+    }
+    
+    struct Foo {
+        bar: u32,
+    }
+    
+    impl Default for Foo {
+        fn default(x: u32) -> Self {
+            Foo {bar: x}
         }
-        
-        // wrong trait name method should not compile
-        impl Default for Foo {
-            fn does_not_exist(x: Field, y: Field) -> Self {
-                Self { bar: x, array: [x,y] }
+    }
+    
+    fn main() {
+    }
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::TypeError(TypeCheckError::TraitMethodParameterTypeMismatch {
+                method_name,
+                expected_typ,
+                actual_typ,
+                ..
+            }) => {
+                assert_eq!(method_name, "default");
+                assert_eq!(expected_typ, "Field");
+                assert_eq!(actual_typ, "u32");
             }
-        }
-        
-        fn main() {
-        }";
-        let compilation_errors = get_program_errors(src);
-        assert!(!has_parser_error(&compilation_errors));
-        assert!(
-            compilation_errors.len() == 1,
-            "Expected 1 compilation error, got: {:?}",
-            compilation_errors
-        );
-
-        for (err, _file_id) in compilation_errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::MethodNotInTrait {
-                    trait_name,
-                    impl_method,
-                }) => {
-                    assert_eq!(trait_name, "Default");
-                    assert_eq!(impl_method, "does_not_exist");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_wrong_parameter() {
-        let src = "
-        trait Default {
-            fn default(x: Field) -> Self;
-        }
-        
-        struct Foo {
-            bar: u32,
+#[test]
+fn check_trait_wrong_parameter2() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Self;
+    }
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    impl Default for Foo {
+        fn default(x: Field, y: Foo) -> Self {
+            Self { bar: x, array: [x, y.bar] }
         }
-        
-        impl Default for Foo {
-            fn default(x: u32) -> Self {
-                Foo {bar: x}
+    }
+    
+    fn main() {
+    }";
+
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::TypeError(TypeCheckError::TraitMethodParameterTypeMismatch {
+                method_name,
+                expected_typ,
+                actual_typ,
+                ..
+            }) => {
+                assert_eq!(method_name, "default");
+                assert_eq!(expected_typ, "Field");
+                assert_eq!(actual_typ, "Foo");
             }
-        }
-        
-        fn main() {
-        }
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::TypeError(TypeCheckError::TraitMethodParameterTypeMismatch {
-                    method_name,
-                    expected_typ,
-                    actual_typ,
-                    ..
-                }) => {
-                    assert_eq!(method_name, "default");
-                    assert_eq!(expected_typ, "Field");
-                    assert_eq!(actual_typ, "u32");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_wrong_parameter2() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Self;
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
-        }
-        
-        impl Default for Foo {
-            fn default(x: Field, y: Foo) -> Self {
-                Self { bar: x, array: [x, y.bar] }
+#[test]
+fn check_trait_wrong_parameter_type() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: NotAType) -> Field;
+    }
+    
+    fn main(x: Field, y: Field) {
+        assert(y == x);
+    }";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
+
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::ResolverError(ResolverError::PathResolutionError(
+                PathResolutionError::Unresolved(ident),
+            )) => {
+                assert_eq!(ident, "NotAType");
             }
-        }
-        
-        fn main() {
-        }";
-
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::TypeError(TypeCheckError::TraitMethodParameterTypeMismatch {
-                    method_name,
-                    expected_typ,
-                    actual_typ,
-                    ..
-                }) => {
-                    assert_eq!(method_name, "default");
-                    assert_eq!(expected_typ, "Field");
-                    assert_eq!(actual_typ, "Foo");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_wrong_parameter_type() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: NotAType) -> Field;
-        }
-        
-        fn main(x: Field, y: Field) {
-            assert(y == x);
-        }";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::ResolverError(ResolverError::PathResolutionError(
-                    PathResolutionError::Unresolved(ident),
-                )) => {
-                    assert_eq!(ident, "NotAType");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+#[test]
+fn check_trait_wrong_parameters_count() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Self;
     }
-
-    #[test]
-    fn check_trait_wrong_parameters_count() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Self;
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    impl Default for Foo {
+        fn default(x: Field) -> Self {
+            Self { bar: x, array: [x, x] }
         }
-        
-        impl Default for Foo {
-            fn default(x: Field) -> Self {
-                Self { bar: x, array: [x, x] }
+    }
+    
+    fn main() {
+    }
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::TypeError(TypeCheckError::MismatchTraitImplNumParameters {
+                actual_num_parameters,
+                expected_num_parameters,
+                trait_name,
+                method_name,
+                ..
+            }) => {
+                assert_eq!(actual_num_parameters, &1_usize);
+                assert_eq!(expected_num_parameters, &2_usize);
+                assert_eq!(method_name, "default");
+                assert_eq!(trait_name, "Default");
             }
-        }
-        
-        fn main() {
-        }
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::TypeError(TypeCheckError::MismatchTraitImplNumParameters {
-                    actual_num_parameters,
-                    expected_num_parameters,
-                    trait_name,
-                    method_name,
-                    ..
-                }) => {
-                    assert_eq!(actual_num_parameters, &1_usize);
-                    assert_eq!(expected_num_parameters, &2_usize);
-                    assert_eq!(method_name, "default");
-                    assert_eq!(trait_name, "Default");
-                }
-                _ => {
-                    panic!("No other errors are expected in this test case! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected in this test case! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_impl_for_non_type() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Field;
-        }
-
-        impl Default for main {
-            fn default(x: Field, y: Field) -> Field {
-                x + y
-            }
-        }
+#[test]
+fn check_trait_impl_for_non_type() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Field;
+    }
 
-        fn main() {}
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::ResolverError(ResolverError::Expected {
-                    expected, got, ..
-                }) => {
-                    assert_eq!(expected, "type");
-                    assert_eq!(got, "function");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
+    impl Default for main {
+        fn default(x: Field, y: Field) -> Field {
+            x + y
         }
     }
 
-    #[test]
-    fn check_impl_struct_not_trait() {
-        let src = "
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
-        }
-        
-        struct Default {
-            x: Field,
-            z: Field, 
-        }
-        
-        // Default is struct not a trait
-        impl Default for Foo {
-            fn default(x: Field, y: Field) -> Self {
-                Self { bar: x, array: [x,y] }
+    fn main() {}
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::ResolverError(ResolverError::Expected { expected, got, .. }) => {
+                assert_eq!(expected, "type");
+                assert_eq!(got, "function");
             }
-        }
-        
-        fn main() {
-        }
-        
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::NotATrait {
-                    not_a_trait_name,
-                }) => {
-                    assert_eq!(not_a_trait_name.to_string(), "plain::Default");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_duplicate_declaration() {
-        let src = "
-        trait Default {
-            fn default(x: Field, y: Field) -> Self;
-        }
-        
-        struct Foo {
-            bar: Field,
-            array: [Field; 2],
+#[test]
+fn check_impl_struct_not_trait() {
+    let src = "
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    struct Default {
+        x: Field,
+        z: Field, 
+    }
+    
+    // Default is struct not a trait
+    impl Default for Foo {
+        fn default(x: Field, y: Field) -> Self {
+            Self { bar: x, array: [x,y] }
         }
-        
-        impl Default for Foo {
-            fn default(x: Field,y: Field) -> Self {
-                Self { bar: x, array: [x,y] }
+    }
+    
+    fn main() {
+    }
+    
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::NotATrait {
+                not_a_trait_name,
+            }) => {
+                assert_eq!(not_a_trait_name.to_string(), "plain::Default");
             }
-        }
-        
-        
-        trait Default {
-            fn default(x: Field) -> Self;
-        }
-        
-        fn main() {
-        }";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::Duplicate {
-                    typ,
-                    first_def,
-                    second_def,
-                }) => {
-                    assert_eq!(typ, &DuplicateType::Trait);
-                    assert_eq!(first_def, "Default");
-                    assert_eq!(second_def, "Default");
-                }
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
     }
+}
 
-    #[test]
-    fn check_trait_duplicate_implementation() {
-        let src = "
-        trait Default {
-        }
-        struct Foo {
-            bar: Field,
-        }
-        
-        impl Default for Foo {
-        }
-        impl Default for Foo {
-        }
-        fn main() {
-        }
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImpl {
-                    ..
-                }) => (),
-                CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImplNote {
-                    ..
-                }) => (),
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
-        }
+#[test]
+fn check_trait_duplicate_declaration() {
+    let src = "
+    trait Default {
+        fn default(x: Field, y: Field) -> Self;
     }
-
-    #[test]
-    fn check_trait_duplicate_implementation_with_alias() {
-        let src = "
-        trait Default {
-        }
-        
-        struct MyStruct {
-        }
-        
-        type MyType = MyStruct;
-        
-        impl Default for MyStruct {
-        }
-        
-        impl Default for MyType {
-        }
-        
-        fn main() {
-        }
-        ";
-        let errors = get_program_errors(src);
-        assert!(!has_parser_error(&errors));
-        assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImpl {
-                    ..
-                }) => (),
-                CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImplNote {
-                    ..
-                }) => (),
-                _ => {
-                    panic!("No other errors are expected! Found = {:?}", err);
-                }
-            };
+    
+    struct Foo {
+        bar: Field,
+        array: [Field; 2],
+    }
+    
+    impl Default for Foo {
+        fn default(x: Field,y: Field) -> Self {
+            Self { bar: x, array: [x,y] }
         }
     }
+    
+    
+    trait Default {
+        fn default(x: Field) -> Self;
+    }
+    
+    fn main() {
+    }";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::Duplicate {
+                typ,
+                first_def,
+                second_def,
+            }) => {
+                assert_eq!(typ, &DuplicateType::Trait);
+                assert_eq!(first_def, "Default");
+                assert_eq!(second_def, "Default");
+            }
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
+            }
+        };
+    }
+}
 
-    #[test]
-    fn test_impl_self_within_default_def() {
-        let src = "
-        trait Bar {
-            fn ok(self) -> Self;
-
-            fn ref_ok(self) -> Self {
-                self.ok()
+#[test]
+fn check_trait_duplicate_implementation() {
+    let src = "
+    trait Default {
+    }
+    struct Foo {
+        bar: Field,
+    }
+    
+    impl Default for Foo {
+    }
+    impl Default for Foo {
+    }
+    fn main() {
+    }
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImpl {
+                ..
+            }) => (),
+            CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImplNote {
+                ..
+            }) => (),
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
             }
-        }
+        };
+    }
+}
 
-        impl<T> Bar for (T, T) where T: Bar {
-            fn ok(self) -> Self {
-                self
+#[test]
+fn check_trait_duplicate_implementation_with_alias() {
+    let src = "
+    trait Default {
+    }
+    
+    struct MyStruct {
+    }
+    
+    type MyType = MyStruct;
+    
+    impl Default for MyStruct {
+    }
+    
+    impl Default for MyType {
+    }
+    
+    fn main() {
+    }
+    ";
+    let errors = get_program_errors(src);
+    assert!(!has_parser_error(&errors));
+    assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImpl {
+                ..
+            }) => (),
+            CompilationError::DefinitionError(DefCollectorErrorKind::OverlappingImplNote {
+                ..
+            }) => (),
+            _ => {
+                panic!("No other errors are expected! Found = {:?}", err);
             }
-        }";
-        let errors = get_program_errors(src);
-        errors.iter().for_each(|err| println!("{:?}", err));
-        assert!(errors.is_empty());
+        };
     }
+}
 
-    #[test]
-    fn check_trait_as_type_as_fn_parameter() {
-        let src = "
-        trait Eq {
-            fn eq(self, other: Self) -> bool;
-        }
+#[test]
+fn test_impl_self_within_default_def() {
+    let src = "
+    trait Bar {
+        fn ok(self) -> Self;
 
-        struct Foo {
-            a: u64,
+        fn ref_ok(self) -> Self {
+            self.ok()
         }
+    }
 
-        impl Eq for Foo {
-            fn eq(self, other: Foo) -> bool { self.a == other.a } 
+    impl<T> Bar for (T, T) where T: Bar {
+        fn ok(self) -> Self {
+            self
         }
+    }";
+    let errors = get_program_errors(src);
+    errors.iter().for_each(|err| println!("{:?}", err));
+    assert!(errors.is_empty());
+}
 
-        fn test_eq(x: impl Eq) -> bool {
-            x.eq(x)
-        }
+#[test]
+fn check_trait_as_type_as_fn_parameter() {
+    let src = "
+    trait Eq {
+        fn eq(self, other: Self) -> bool;
+    }
 
-        fn main(a: Foo) -> pub bool {
-            test_eq(a)
-        }";
+    struct Foo {
+        a: u64,
+    }
 
-        let errors = get_program_errors(src);
-        errors.iter().for_each(|err| println!("{:?}", err));
-        assert!(errors.is_empty());
+    impl Eq for Foo {
+        fn eq(self, other: Foo) -> bool { self.a == other.a } 
     }
 
-    #[test]
-    fn check_trait_as_type_as_two_fn_parameters() {
-        let src = "
-        trait Eq {
-            fn eq(self, other: Self) -> bool;
-        }
+    fn test_eq(x: impl Eq) -> bool {
+        x.eq(x)
+    }
 
-        trait Test {
-            fn test(self) -> bool;
-        }
+    fn main(a: Foo) -> pub bool {
+        test_eq(a)
+    }";
 
-        struct Foo {
-            a: u64,
-        }
+    let errors = get_program_errors(src);
+    errors.iter().for_each(|err| println!("{:?}", err));
+    assert!(errors.is_empty());
+}
 
-        impl Eq for Foo {
-            fn eq(self, other: Foo) -> bool { self.a == other.a } 
-        }
+#[test]
+fn check_trait_as_type_as_two_fn_parameters() {
+    let src = "
+    trait Eq {
+        fn eq(self, other: Self) -> bool;
+    }
 
-        impl Test for u64 {
-            fn test(self) -> bool { self == self } 
-        }
+    trait Test {
+        fn test(self) -> bool;
+    }
 
-        fn test_eq(x: impl Eq, y: impl Test) -> bool {
-            x.eq(x) == y.test()
-        }
+    struct Foo {
+        a: u64,
+    }
 
-        fn main(a: Foo, b: u64) -> pub bool {
-            test_eq(a, b)
-        }";
-
-        let errors = get_program_errors(src);
-        errors.iter().for_each(|err| println!("{:?}", err));
-        assert!(errors.is_empty());
-    }
-
-    fn get_program_captures(src: &str) -> Vec<Vec<String>> {
-        let (program, context, _errors) = get_program(src);
-        let interner = context.def_interner;
-        let mut all_captures: Vec<Vec<String>> = Vec::new();
-        for func in program.into_sorted().functions {
-            let func_id = interner.find_function(func.name()).unwrap();
-            let hir_func = interner.function(&func_id);
-            // Iterate over function statements and apply filtering function
-            find_lambda_captures(
-                hir_func.block(&interner).statements(),
-                &interner,
-                &mut all_captures,
-            );
-        }
-        all_captures
-    }
-
-    fn find_lambda_captures(
-        stmts: &[StmtId],
-        interner: &NodeInterner,
-        result: &mut Vec<Vec<String>>,
-    ) {
-        for stmt_id in stmts.iter() {
-            let hir_stmt = interner.statement(stmt_id);
-            let expr_id = match hir_stmt {
-                HirStatement::Expression(expr_id) => expr_id,
-                HirStatement::Let(let_stmt) => let_stmt.expression,
-                HirStatement::Assign(assign_stmt) => assign_stmt.expression,
-                HirStatement::Constrain(constr_stmt) => constr_stmt.0,
-                HirStatement::Semi(semi_expr) => semi_expr,
-                HirStatement::For(for_loop) => for_loop.block,
-                HirStatement::Error => panic!("Invalid HirStatement!"),
-                HirStatement::Break => panic!("Unexpected break"),
-                HirStatement::Continue => panic!("Unexpected continue"),
-                HirStatement::Comptime(_) => panic!("Unexpected comptime"),
-            };
-            let expr = interner.expression(&expr_id);
+    impl Eq for Foo {
+        fn eq(self, other: Foo) -> bool { self.a == other.a } 
+    }
 
-            get_lambda_captures(expr, interner, result); // TODO: dyn filter function as parameter
-        }
+    impl Test for u64 {
+        fn test(self) -> bool { self == self } 
     }
 
-    fn get_lambda_captures(
-        expr: HirExpression,
-        interner: &NodeInterner,
-        result: &mut Vec<Vec<String>>,
-    ) {
-        if let HirExpression::Lambda(lambda_expr) = expr {
-            let mut cur_capture = Vec::new();
+    fn test_eq(x: impl Eq, y: impl Test) -> bool {
+        x.eq(x) == y.test()
+    }
 
-            for capture in lambda_expr.captures.iter() {
-                cur_capture.push(interner.definition(capture.ident.id).name.clone());
-            }
-            result.push(cur_capture);
+    fn main(a: Foo, b: u64) -> pub bool {
+        test_eq(a, b)
+    }";
 
-            // Check for other captures recursively within the lambda body
-            let hir_body_expr = interner.expression(&lambda_expr.body);
-            if let HirExpression::Block(block_expr) = hir_body_expr {
-                find_lambda_captures(block_expr.statements(), interner, result);
-            }
-        }
+    let errors = get_program_errors(src);
+    errors.iter().for_each(|err| println!("{:?}", err));
+    assert!(errors.is_empty());
+}
+
+fn get_program_captures(src: &str) -> Vec<Vec<String>> {
+    let (program, context, _errors) = get_program(src);
+    let interner = context.def_interner;
+    let mut all_captures: Vec<Vec<String>> = Vec::new();
+    for func in program.into_sorted().functions {
+        let func_id = interner.find_function(func.name()).unwrap();
+        let hir_func = interner.function(&func_id);
+        // Iterate over function statements and apply filtering function
+        find_lambda_captures(hir_func.block(&interner).statements(), &interner, &mut all_captures);
     }
+    all_captures
+}
 
-    #[test]
-    fn resolve_empty_function() {
-        let src = "
-            fn main() {
+fn find_lambda_captures(stmts: &[StmtId], interner: &NodeInterner, result: &mut Vec<Vec<String>>) {
+    for stmt_id in stmts.iter() {
+        let hir_stmt = interner.statement(stmt_id);
+        let expr_id = match hir_stmt {
+            HirStatement::Expression(expr_id) => expr_id,
+            HirStatement::Let(let_stmt) => let_stmt.expression,
+            HirStatement::Assign(assign_stmt) => assign_stmt.expression,
+            HirStatement::Constrain(constr_stmt) => constr_stmt.0,
+            HirStatement::Semi(semi_expr) => semi_expr,
+            HirStatement::For(for_loop) => for_loop.block,
+            HirStatement::Error => panic!("Invalid HirStatement!"),
+            HirStatement::Break => panic!("Unexpected break"),
+            HirStatement::Continue => panic!("Unexpected continue"),
+            HirStatement::Comptime(_) => panic!("Unexpected comptime"),
+        };
+        let expr = interner.expression(&expr_id);
 
-            }
-        ";
-        assert!(get_program_errors(src).is_empty());
-    }
-    #[test]
-    fn resolve_basic_function() {
-        let src = r#"
-            fn main(x : Field) {
-                let y = x + x;
-                assert(y == x);
-            }
-        "#;
-        assert!(get_program_errors(src).is_empty());
-    }
-    #[test]
-    fn resolve_unused_var() {
-        let src = r#"
-            fn main(x : Field) {
-                let y = x + x;
-                assert(x == x);
-            }
-        "#;
-
-        let errors = get_program_errors(src);
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        // It should be regarding the unused variable
-        match &errors[0].0 {
-            CompilationError::ResolverError(ResolverError::UnusedVariable { ident }) => {
-                assert_eq!(&ident.0.contents, "y");
-            }
-            _ => unreachable!("we should only have an unused var error"),
-        }
+        get_lambda_captures(expr, interner, result); // TODO: dyn filter function as parameter
     }
+}
 
-    #[test]
-    fn resolve_unresolved_var() {
-        let src = r#"
-            fn main(x : Field) {
-                let y = x + x;
-                assert(y == z);
-            }
-        "#;
-        let errors = get_program_errors(src);
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        // It should be regarding the unresolved var `z` (Maybe change to undeclared and special case)
-        match &errors[0].0 {
-            CompilationError::ResolverError(ResolverError::VariableNotDeclared {
-                name,
-                span: _,
-            }) => assert_eq!(name, "z"),
-            _ => unimplemented!("we should only have an unresolved variable"),
+fn get_lambda_captures(
+    expr: HirExpression,
+    interner: &NodeInterner,
+    result: &mut Vec<Vec<String>>,
+) {
+    if let HirExpression::Lambda(lambda_expr) = expr {
+        let mut cur_capture = Vec::new();
+
+        for capture in lambda_expr.captures.iter() {
+            cur_capture.push(interner.definition(capture.ident.id).name.clone());
+        }
+        result.push(cur_capture);
+
+        // Check for other captures recursively within the lambda body
+        let hir_body_expr = interner.expression(&lambda_expr.body);
+        if let HirExpression::Block(block_expr) = hir_body_expr {
+            find_lambda_captures(block_expr.statements(), interner, result);
         }
     }
+}
+
+#[test]
+fn resolve_empty_function() {
+    let src = "
+        fn main() {
 
-    #[test]
-    fn unresolved_path() {
-        let src = "
-            fn main(x : Field) {
-                let _z = some::path::to::a::func(x);
-            }
-        ";
-        let errors = get_program_errors(src);
-        assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
-        for (compilation_error, _file_id) in errors {
-            match compilation_error {
-                CompilationError::ResolverError(err) => {
-                    match err {
-                        ResolverError::PathResolutionError(PathResolutionError::Unresolved(
-                            name,
-                        )) => {
-                            assert_eq!(name.to_string(), "some");
-                        }
-                        _ => unimplemented!("we should only have an unresolved function"),
-                    };
-                }
-                _ => unimplemented!(),
-            }
         }
+    ";
+    assert!(get_program_errors(src).is_empty());
+}
+#[test]
+fn resolve_basic_function() {
+    let src = r#"
+        fn main(x : Field) {
+            let y = x + x;
+            assert(y == x);
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
+#[test]
+fn resolve_unused_var() {
+    let src = r#"
+        fn main(x : Field) {
+            let y = x + x;
+            assert(x == x);
+        }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    // It should be regarding the unused variable
+    match &errors[0].0 {
+        CompilationError::ResolverError(ResolverError::UnusedVariable { ident }) => {
+            assert_eq!(&ident.0.contents, "y");
+        }
+        _ => unreachable!("we should only have an unused var error"),
     }
+}
 
-    #[test]
-    fn resolve_literal_expr() {
-        let src = r#"
-            fn main(x : Field) {
-                let y = 5;
-                assert(y == x);
-            }
-        "#;
-        assert!(get_program_errors(src).is_empty());
+#[test]
+fn resolve_unresolved_var() {
+    let src = r#"
+        fn main(x : Field) {
+            let y = x + x;
+            assert(y == z);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    // It should be regarding the unresolved var `z` (Maybe change to undeclared and special case)
+    match &errors[0].0 {
+        CompilationError::ResolverError(ResolverError::VariableNotDeclared { name, span: _ }) => {
+            assert_eq!(name, "z");
+        }
+        _ => unimplemented!("we should only have an unresolved variable"),
     }
+}
 
-    #[test]
-    fn multiple_resolution_errors() {
-        let src = r#"
-            fn main(x : Field) {
-               let y = foo::bar(x);
-               let z = y + a;
-            }
-        "#;
-
-        let errors = get_program_errors(src);
-        assert!(errors.len() == 3, "Expected 3 errors, got: {:?}", errors);
-
-        // Errors are:
-        // `a` is undeclared
-        // `z` is unused
-        // `foo::bar` does not exist
-        for (compilation_error, _file_id) in errors {
-            match compilation_error {
-                CompilationError::ResolverError(err) => {
-                    match err {
-                        ResolverError::UnusedVariable { ident } => {
-                            assert_eq!(&ident.0.contents, "z");
-                        }
-                        ResolverError::VariableNotDeclared { name, .. } => {
-                            assert_eq!(name, "a");
-                        }
-                        ResolverError::PathResolutionError(PathResolutionError::Unresolved(
-                            name,
-                        )) => {
-                            assert_eq!(name.to_string(), "foo");
-                        }
-                        _ => unimplemented!(),
-                    };
-                }
-                _ => unimplemented!(),
+#[test]
+fn unresolved_path() {
+    let src = "
+        fn main(x : Field) {
+            let _z = some::path::to::a::func(x);
+        }
+    ";
+    let errors = get_program_errors(src);
+    assert!(errors.len() == 1, "Expected 1 error, got: {:?}", errors);
+    for (compilation_error, _file_id) in errors {
+        match compilation_error {
+            CompilationError::ResolverError(err) => {
+                match err {
+                    ResolverError::PathResolutionError(PathResolutionError::Unresolved(name)) => {
+                        assert_eq!(name.to_string(), "some");
+                    }
+                    _ => unimplemented!("we should only have an unresolved function"),
+                };
             }
+            _ => unimplemented!(),
         }
     }
+}
 
-    #[test]
-    fn resolve_prefix_expr() {
-        let src = r#"
-            fn main(x : Field) {
-                let _y = -x;
-            }
-        "#;
-        assert!(get_program_errors(src).is_empty());
-    }
+#[test]
+fn resolve_literal_expr() {
+    let src = r#"
+        fn main(x : Field) {
+            let y = 5;
+            assert(y == x);
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
 
-    #[test]
-    fn resolve_for_expr() {
-        let src = r#"
-            fn main(x : u64) {
-                for i in 1..20 {
-                    let _z = x + i;
+#[test]
+fn multiple_resolution_errors() {
+    let src = r#"
+        fn main(x : Field) {
+           let y = foo::bar(x);
+           let z = y + a;
+        }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert!(errors.len() == 3, "Expected 3 errors, got: {:?}", errors);
+
+    // Errors are:
+    // `a` is undeclared
+    // `z` is unused
+    // `foo::bar` does not exist
+    for (compilation_error, _file_id) in errors {
+        match compilation_error {
+            CompilationError::ResolverError(err) => {
+                match err {
+                    ResolverError::UnusedVariable { ident } => {
+                        assert_eq!(&ident.0.contents, "z");
+                    }
+                    ResolverError::VariableNotDeclared { name, .. } => {
+                        assert_eq!(name, "a");
+                    }
+                    ResolverError::PathResolutionError(PathResolutionError::Unresolved(name)) => {
+                        assert_eq!(name.to_string(), "foo");
+                    }
+                    _ => unimplemented!(),
                 };
             }
-        "#;
-        assert!(get_program_errors(src).is_empty());
+            _ => unimplemented!(),
+        }
     }
+}
 
-    #[test]
-    fn resolve_call_expr() {
-        let src = r#"
-            fn main(x : Field) {
-                let _z = foo(x);
-            }
+#[test]
+fn resolve_prefix_expr() {
+    let src = r#"
+        fn main(x : Field) {
+            let _y = -x;
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
 
-            fn foo(x : Field) -> Field {
-                x
-            }
-        "#;
-        assert!(get_program_errors(src).is_empty());
-    }
-
-    #[test]
-    fn resolve_shadowing() {
-        let src = r#"
-            fn main(x : Field) {
-                let x = foo(x);
-                let x = x;
-                let (x, x) = (x, x);
-                let _ = x;
-            }
+#[test]
+fn resolve_for_expr() {
+    let src = r#"
+        fn main(x : u64) {
+            for i in 1..20 {
+                let _z = x + i;
+            };
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
 
-            fn foo(x : Field) -> Field {
-                x
-            }
-        "#;
-        assert!(get_program_errors(src).is_empty());
-    }
+#[test]
+fn resolve_call_expr() {
+    let src = r#"
+        fn main(x : Field) {
+            let _z = foo(x);
+        }
 
-    #[test]
-    fn resolve_basic_closure() {
-        let src = r#"
-            fn main(x : Field) -> pub Field {
-                let closure = |y| y + x;
-                closure(x)
-            }
-        "#;
-        assert!(get_program_errors(src).is_empty());
-    }
+        fn foo(x : Field) -> Field {
+            x
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
 
-    #[test]
-    fn resolve_simplified_closure() {
-        // based on bug https://github.com/noir-lang/noir/issues/1088
+#[test]
+fn resolve_shadowing() {
+    let src = r#"
+        fn main(x : Field) {
+            let x = foo(x);
+            let x = x;
+            let (x, x) = (x, x);
+            let _ = x;
+        }
 
-        let src = r#"fn do_closure(x: Field) -> Field {
-            let y = x;
-            let ret_capture = || {
-              y
-            };
-            ret_capture()
-          }
-
-          fn main(x: Field) {
-              assert(do_closure(x) == 100);
-          }
-
-          "#;
-        let parsed_captures = get_program_captures(src);
-        let expected_captures = vec![vec!["y".to_string()]];
-        assert_eq!(expected_captures, parsed_captures);
-    }
-
-    #[test]
-    fn resolve_complex_closures() {
-        let src = r#"
-            fn main(x: Field) -> pub Field {
-                let closure_without_captures = |x: Field| -> Field { x + x };
-                let a = closure_without_captures(1);
-
-                let closure_capturing_a_param = |y: Field| -> Field { y + x };
-                let b = closure_capturing_a_param(2);
-
-                let closure_capturing_a_local_var = |y: Field| -> Field { y + b };
-                let c = closure_capturing_a_local_var(3);
-
-                let closure_with_transitive_captures = |y: Field| -> Field {
-                    let d = 5;
-                    let nested_closure = |z: Field| -> Field {
-                        let doubly_nested_closure = |w: Field| -> Field { w + x + b };
-                        a + z + y + d + x + doubly_nested_closure(4) + x + y
-                    };
-                    let res = nested_closure(5);
-                    res
+        fn foo(x : Field) -> Field {
+            x
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
+
+#[test]
+fn resolve_basic_closure() {
+    let src = r#"
+        fn main(x : Field) -> pub Field {
+            let closure = |y| y + x;
+            closure(x)
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty());
+}
+
+#[test]
+fn resolve_simplified_closure() {
+    // based on bug https://github.com/noir-lang/noir/issues/1088
+
+    let src = r#"fn do_closure(x: Field) -> Field {
+        let y = x;
+        let ret_capture = || {
+          y
+        };
+        ret_capture()
+      }
+
+      fn main(x: Field) {
+          assert(do_closure(x) == 100);
+      }
+
+      "#;
+    let parsed_captures = get_program_captures(src);
+    let expected_captures = vec![vec!["y".to_string()]];
+    assert_eq!(expected_captures, parsed_captures);
+}
+
+#[test]
+fn resolve_complex_closures() {
+    let src = r#"
+        fn main(x: Field) -> pub Field {
+            let closure_without_captures = |x: Field| -> Field { x + x };
+            let a = closure_without_captures(1);
+
+            let closure_capturing_a_param = |y: Field| -> Field { y + x };
+            let b = closure_capturing_a_param(2);
+
+            let closure_capturing_a_local_var = |y: Field| -> Field { y + b };
+            let c = closure_capturing_a_local_var(3);
+
+            let closure_with_transitive_captures = |y: Field| -> Field {
+                let d = 5;
+                let nested_closure = |z: Field| -> Field {
+                    let doubly_nested_closure = |w: Field| -> Field { w + x + b };
+                    a + z + y + d + x + doubly_nested_closure(4) + x + y
                 };
+                let res = nested_closure(5);
+                res
+            };
+
+            a + b + c + closure_with_transitive_captures(6)
+        }
+    "#;
+    assert!(get_program_errors(src).is_empty(), "there should be no errors");
+
+    let expected_captures = vec![
+        vec![],
+        vec!["x".to_string()],
+        vec!["b".to_string()],
+        vec!["x".to_string(), "b".to_string(), "a".to_string()],
+        vec!["x".to_string(), "b".to_string(), "a".to_string(), "y".to_string(), "d".to_string()],
+        vec!["x".to_string(), "b".to_string()],
+    ];
+
+    let parsed_captures = get_program_captures(src);
+
+    assert_eq!(expected_captures, parsed_captures);
+}
+
+#[test]
+fn resolve_fmt_strings() {
+    let src = r#"
+        fn main() {
+            let string = f"this is i: {i}";
+            println(string);
+
+            println(f"I want to print {0}");
+
+            let new_val = 10;
+            println(f"random_string{new_val}{new_val}");
+        }
+        fn println<T>(x : T) -> T {
+            x
+        }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert!(errors.len() == 5, "Expected 5 errors, got: {:?}", errors);
 
-                a + b + c + closure_with_transitive_captures(6)
+    for (err, _file_id) in errors {
+        match &err {
+            CompilationError::ResolverError(ResolverError::VariableNotDeclared {
+                name, ..
+            }) => {
+                assert_eq!(name, "i");
             }
-        "#;
-        assert!(get_program_errors(src).is_empty(), "there should be no errors");
-
-        let expected_captures = vec![
-            vec![],
-            vec!["x".to_string()],
-            vec!["b".to_string()],
-            vec!["x".to_string(), "b".to_string(), "a".to_string()],
-            vec![
-                "x".to_string(),
-                "b".to_string(),
-                "a".to_string(),
-                "y".to_string(),
-                "d".to_string(),
-            ],
-            vec!["x".to_string(), "b".to_string()],
-        ];
-
-        let parsed_captures = get_program_captures(src);
-
-        assert_eq!(expected_captures, parsed_captures);
-    }
-
-    #[test]
-    fn resolve_fmt_strings() {
-        let src = r#"
-            fn main() {
-                let string = f"this is i: {i}";
-                println(string);
-
-                println(f"I want to print {0}");
-
-                let new_val = 10;
-                println(f"random_string{new_val}{new_val}");
+            CompilationError::ResolverError(ResolverError::NumericConstantInFormatString {
+                name,
+                ..
+            }) => {
+                assert_eq!(name, "0");
             }
-            fn println<T>(x : T) -> T {
-                x
+            CompilationError::TypeError(TypeCheckError::UnusedResultError {
+                expr_type: _,
+                expr_span,
+            }) => {
+                let a = src.get(expr_span.start() as usize..expr_span.end() as usize).unwrap();
+                assert!(
+                    a == "println(string)"
+                        || a == "println(f\"I want to print {0}\")"
+                        || a == "println(f\"random_string{new_val}{new_val}\")"
+                );
             }
-        "#;
-
-        let errors = get_program_errors(src);
-        assert!(errors.len() == 5, "Expected 5 errors, got: {:?}", errors);
-
-        for (err, _file_id) in errors {
-            match &err {
-                CompilationError::ResolverError(ResolverError::VariableNotDeclared {
-                    name,
-                    ..
-                }) => {
-                    assert_eq!(name, "i");
-                }
-                CompilationError::ResolverError(ResolverError::NumericConstantInFormatString {
-                    name,
-                    ..
-                }) => {
-                    assert_eq!(name, "0");
-                }
-                CompilationError::TypeError(TypeCheckError::UnusedResultError {
-                    expr_type: _,
-                    expr_span,
-                }) => {
-                    let a = src.get(expr_span.start() as usize..expr_span.end() as usize).unwrap();
-                    assert!(
-                        a == "println(string)"
-                            || a == "println(f\"I want to print {0}\")"
-                            || a == "println(f\"random_string{new_val}{new_val}\")"
-                    );
-                }
-                _ => unimplemented!(),
-            };
-        }
+            _ => unimplemented!(),
+        };
     }
+}
 
-    fn check_rewrite(src: &str, expected: &str) {
-        let (_program, mut context, _errors) = get_program(src);
-        let main_func_id = context.def_interner.find_function("main").unwrap();
-        let program = monomorphize(main_func_id, &mut context.def_interner).unwrap();
-        assert!(format!("{}", program) == expected);
-    }
+fn check_rewrite(src: &str, expected: &str) {
+    let (_program, mut context, _errors) = get_program(src);
+    let main_func_id = context.def_interner.find_function("main").unwrap();
+    let program = monomorphize(main_func_id, &mut context.def_interner).unwrap();
+    assert!(format!("{}", program) == expected);
+}
 
-    #[test]
-    fn simple_closure_with_no_captured_variables() {
-        let src = r#"
-        fn main() -> pub Field {
-            let x = 1;
-            let closure = || x;
-            closure()
-        }
-        "#;
+#[test]
+fn simple_closure_with_no_captured_variables() {
+    let src = r#"
+    fn main() -> pub Field {
+        let x = 1;
+        let closure = || x;
+        closure()
+    }
+    "#;
 
-        let expected_rewrite = r#"fn main$f0() -> Field {
+    let expected_rewrite = r#"fn main$f0() -> Field {
     let x$0 = 1;
     let closure$3 = {
         let closure_variable$2 = {
@@ -1248,167 +1226,154 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
     env$l1.0
 }
 "#;
-        check_rewrite(src, expected_rewrite);
-    }
-
-    #[test]
-    fn deny_mutually_recursive_structs() {
-        let src = r#"
-            struct Foo { bar: Bar }
-            struct Bar { foo: Foo }
-            fn main() {}
-        "#;
-        assert_eq!(get_program_errors(src).len(), 1);
-    }
-
-    #[test]
-    fn deny_cyclic_globals() {
-        let src = r#"
-            global A = B;
-            global B = A;
-            fn main() {}
-        "#;
-        assert_eq!(get_program_errors(src).len(), 1);
-    }
-
-    #[test]
-    fn deny_cyclic_type_aliases() {
-        let src = r#"
-            type A = B;
-            type B = A;
-            fn main() {}
-        "#;
-        assert_eq!(get_program_errors(src).len(), 1);
-    }
-
-    #[test]
-    fn ensure_nested_type_aliases_type_check() {
-        let src = r#"
-            type A = B;
-            type B = u8;
-            fn main() {
-                let _a: A = 0 as u16;
-            }
-        "#;
-        assert_eq!(get_program_errors(src).len(), 1);
-    }
-
-    #[test]
-    fn type_aliases_in_entry_point() {
-        let src = r#"
-            type Foo = u8;
-            fn main(_x: Foo) {}
-        "#;
-        assert_eq!(get_program_errors(src).len(), 0);
-    }
-
-    #[test]
-    fn operators_in_global_used_in_type() {
-        let src = r#"
-            global ONE = 1;
-            global COUNT = ONE + 2;
-            fn main() {
-                let _array: [Field; COUNT] = [1, 2, 3];
-            }
-        "#;
-        assert_eq!(get_program_errors(src).len(), 0);
-    }
+    check_rewrite(src, expected_rewrite);
+}
 
-    #[test]
-    fn break_and_continue_in_constrained_fn() {
-        let src = r#"
-            fn main() {
-                for i in 0 .. 10 {
-                    if i == 2 {
-                        continue;
-                    }
-                    if i == 5 {
-                        break;
-                    }
+#[test]
+fn deny_cyclic_globals() {
+    let src = r#"
+        global A = B;
+        global B = A;
+        fn main() {}
+    "#;
+    assert_eq!(get_program_errors(src).len(), 1);
+}
+
+#[test]
+fn deny_cyclic_type_aliases() {
+    let src = r#"
+        type A = B;
+        type B = A;
+        fn main() {}
+    "#;
+    assert_eq!(get_program_errors(src).len(), 1);
+}
+
+#[test]
+fn ensure_nested_type_aliases_type_check() {
+    let src = r#"
+        type A = B;
+        type B = u8;
+        fn main() {
+            let _a: A = 0 as u16;
+        }
+    "#;
+    assert_eq!(get_program_errors(src).len(), 1);
+}
+
+#[test]
+fn type_aliases_in_entry_point() {
+    let src = r#"
+        type Foo = u8;
+        fn main(_x: Foo) {}
+    "#;
+    assert_eq!(get_program_errors(src).len(), 0);
+}
+
+#[test]
+fn operators_in_global_used_in_type() {
+    let src = r#"
+        global ONE = 1;
+        global COUNT = ONE + 2;
+        fn main() {
+            let _array: [Field; COUNT] = [1, 2, 3];
+        }
+    "#;
+    assert_eq!(get_program_errors(src).len(), 0);
+}
+
+#[test]
+fn break_and_continue_in_constrained_fn() {
+    let src = r#"
+        fn main() {
+            for i in 0 .. 10 {
+                if i == 2 {
+                    continue;
+                }
+                if i == 5 {
+                    break;
                 }
             }
-        "#;
-        assert_eq!(get_program_errors(src).len(), 2);
-    }
+        }
+    "#;
+    assert_eq!(get_program_errors(src).len(), 2);
+}
 
-    #[test]
-    fn break_and_continue_outside_loop() {
-        let src = r#"
-            unconstrained fn main() {
-                continue;
-                break;
-            }
-        "#;
-        assert_eq!(get_program_errors(src).len(), 2);
-    }
+#[test]
+fn break_and_continue_outside_loop() {
+    let src = r#"
+        unconstrained fn main() {
+            continue;
+            break;
+        }
+    "#;
+    assert_eq!(get_program_errors(src).len(), 2);
+}
 
-    // Regression for #2540
-    #[test]
-    fn for_loop_over_array() {
-        let src = r#"
-            fn hello<N>(_array: [u1; N]) {
-                for _ in 0..N {}
-            }
+// Regression for #2540
+#[test]
+fn for_loop_over_array() {
+    let src = r#"
+        fn hello<N>(_array: [u1; N]) {
+            for _ in 0..N {}
+        }
 
-            fn main() {
-                let array: [u1; 2] = [0, 1];
-                hello(array);
-            }
-        "#;
-        assert_eq!(get_program_errors(src).len(), 0);
-    }
-
-    // Regression for #4545
-    #[test]
-    fn type_aliases_in_main() {
-        let src = r#"
-            type Outer<N> = [u8; N];
-            fn main(_arg: Outer<1>) {}
-        "#;
-        assert_eq!(get_program_errors(src).len(), 0);
-    }
-
-    #[test]
-    fn ban_mutable_globals() {
-        // Mutable globals are only allowed in a comptime context
-        let src = r#"
-            mut global FOO: Field = 0;
-            fn main() {}
-        "#;
-        assert_eq!(get_program_errors(src).len(), 1);
-    }
-
-    #[test]
-    fn deny_inline_attribute_on_unconstrained() {
-        let src = r#"
-            #[no_predicates]
-            unconstrained fn foo(x: Field, y: Field) {
-                assert(x != y);
-            }
-        "#;
-        let errors = get_program_errors(src);
-        assert_eq!(errors.len(), 1);
-        assert!(matches!(
-            errors[0].0,
-            CompilationError::ResolverError(
-                ResolverError::NoPredicatesAttributeOnUnconstrained { .. }
-            )
-        ));
-    }
+        fn main() {
+            let array: [u1; 2] = [0, 1];
+            hello(array);
+        }
+    "#;
+    assert_eq!(get_program_errors(src).len(), 0);
+}
 
-    #[test]
-    fn deny_fold_attribute_on_unconstrained() {
-        let src = r#"
-            #[fold]
-            unconstrained fn foo(x: Field, y: Field) {
-                assert(x != y);
-            }
-        "#;
-        let errors = get_program_errors(src);
-        assert_eq!(errors.len(), 1);
-        assert!(matches!(
-            errors[0].0,
-            CompilationError::ResolverError(ResolverError::FoldAttributeOnUnconstrained { .. })
-        ));
-    }
+// Regression for #4545
+#[test]
+fn type_aliases_in_main() {
+    let src = r#"
+        type Outer<N> = [u8; N];
+        fn main(_arg: Outer<1>) {}
+    "#;
+    assert_eq!(get_program_errors(src).len(), 0);
+}
+
+#[test]
+fn ban_mutable_globals() {
+    // Mutable globals are only allowed in a comptime context
+    let src = r#"
+        mut global FOO: Field = 0;
+        fn main() {}
+    "#;
+    assert_eq!(get_program_errors(src).len(), 1);
+}
+
+#[test]
+fn deny_inline_attribute_on_unconstrained() {
+    let src = r#"
+        #[no_predicates]
+        unconstrained fn foo(x: Field, y: Field) {
+            assert(x != y);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::NoPredicatesAttributeOnUnconstrained { .. })
+    ));
+}
+
+#[test]
+fn deny_fold_attribute_on_unconstrained() {
+    let src = r#"
+        #[fold]
+        unconstrained fn foo(x: Field, y: Field) {
+            assert(x != y);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::FoldAttributeOnUnconstrained { .. })
+    ));
 }
diff --git a/compiler/noirc_frontend/src/tests/name_shadowing.rs b/compiler/noirc_frontend/src/tests/name_shadowing.rs
new file mode 100644
index 00000000000..b0d83510039
--- /dev/null
+++ b/compiler/noirc_frontend/src/tests/name_shadowing.rs
@@ -0,0 +1,419 @@
+#![cfg(test)]
+use super::get_program_errors;
+use std::collections::HashSet;
+
+#[test]
+fn test_name_shadowing() {
+    let src = "
+    trait Default {
+        fn default() -> Self;
+    }
+
+    impl Default for bool {
+        fn default() -> bool {
+            false
+        }
+    }
+
+    impl Default for Field {
+        fn default() -> Field {
+            0
+        }
+    }
+
+    impl<T, N> Default for [T; N] where T: Default {
+        fn default() -> [T; N] {
+            [Default::default(); N]
+        }
+    }
+
+    impl<T, U> Default for (T, U) where T: Default, U: Default {
+        fn default() -> (T, U) {
+            (Default::default(), Default::default())
+        }
+    }
+
+    fn drop_var<T, U>(_x: T, y: U) -> U { y }
+
+    mod local_module {
+        use crate::{Default, drop_var};
+
+        global LOCAL_GLOBAL_N: Field = 0;
+
+        global LOCAL_GLOBAL_M: Field = 1;
+
+        struct LocalStruct<N, M, A, B> {
+            field1: A,
+            field2: B,
+            field3: [A; N],
+            field4: ([A; N], [B; M]),
+            field5: &mut A,
+        }
+
+        impl<N, M, A, B> Default for LocalStruct<N, M, A, B> where A: Default, B: Default {
+            fn default() -> Self {
+                let mut mut_field = &mut Default::default();
+                Self {
+                    field1: Default::default(),
+                    field2: Default::default(),
+                    field3: Default::default(),
+                    field4: Default::default(),
+                    field5: mut_field,
+                }
+            }
+        }
+
+        trait DefinedInLocalModule1<A, B, N, M> {
+            fn trait_fn1(self, x: A);
+            fn trait_fn2(self, y: B);
+            fn trait_fn3(&mut self, x: A, y: B);
+            fn trait_fn4(self, x: [A; 0], y: [B]);
+            fn trait_fn5(self, x: [A; N], y: [B; M]) -> [A; 0];
+            fn trait_fn6(self, x: [A; N], y: [B; M]) -> [A; 0];
+            fn trait_fn7(self, _x: fn([A; 0]) -> B) -> Field {
+                drop_var(self, N + M)
+            }
+        }
+
+        impl<N, M, A, B> DefinedInLocalModule1<A, B, N, M> for LocalStruct<N, M, A, B> {
+            fn trait_fn1(self, _x: A) { drop_var(self, ()) }
+            fn trait_fn2(self, _y: B) { drop_var(self, ()) }
+            fn trait_fn3(&mut self, _x: A, _y: B) { drop_var(self, ()) }
+            fn trait_fn4(self, _x: [A; 0], _y: [B]) { drop_var(self, ()) }
+            fn trait_fn5(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, []) }
+            fn trait_fn6(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, []) }
+        }
+
+        pub fn local_fn4<A, N, B, M>(_x: (A, B), _y: [Field; N], _z: [Field; M]) -> [A; 0] {
+            assert(LOCAL_GLOBAL_N != LOCAL_GLOBAL_M);
+            let x: Field = 0;
+            assert(x == 0);
+            let x: Field = 1;
+            assert(x == 1);
+            []
+        }
+    }
+
+    mod library {
+        use crate::{Default, drop_var};
+
+        mod library2 {
+            use crate::{Default, drop_var};
+
+            global IMPORT_GLOBAL_N_2: Field = 4;
+
+            global IMPORT_GLOBAL_M_2: Field = 5;
+
+            // When we re-export this type from another library and then use it in
+            // main, we get a panic
+            struct ReExportMeFromAnotherLib1 {
+                x : Field,
+            }
+
+            struct PubLibLocalStruct3<N, M, A, B> {
+                pub_field1: A,
+                pub_field2: B,
+                pub_field3: [A; N],
+                pub_field4: ([A; N], [B; M]),
+                pub_field5: &mut A,
+            }
+
+            impl<N, M, A, B> Default for PubLibLocalStruct3<N, M, A, B> where A: Default, B: Default {
+                fn default() -> Self {
+                    let mut mut_field = &mut Default::default();
+                    Self {
+                        pub_field1: Default::default(),
+                        pub_field2: Default::default(),
+                        pub_field3: Default::default(),
+                        pub_field4: Default::default(),
+                        pub_field5: mut_field,
+                    }
+                }
+            }
+
+            trait PubLibDefinedInLocalModule3<A, B, N, M> {
+                fn pub_trait_fn1(self, x: A);
+                fn pub_trait_fn2(self, y: B);
+                fn pub_trait_fn3(&mut self, x: A, y: B);
+                fn pub_trait_fn4(self, x: [A; 0], y: [B]);
+                fn pub_trait_fn5(self, x: [A; N], y: [B; M]) -> [A; 0];
+                fn pub_trait_fn6(self, x: [A; N], y: [B; M]) -> [A; 0];
+                fn pub_trait_fn7(self, _x: fn([A; 0]) -> B) -> Field {
+                    drop_var(self, N + M)
+                }
+            }
+
+            impl<N, M, A, B> PubLibDefinedInLocalModule3<A, B, N, M> for PubLibLocalStruct3<N, M, A, B> {
+                fn pub_trait_fn1(self, _x: A) { drop_var(self, ()) }
+                fn pub_trait_fn2(self, _y: B) { drop_var(self, ()) }
+                fn pub_trait_fn3(&mut self, _x: A, _y: B) { drop_var(self, ()) }
+                fn pub_trait_fn4(self, _x: [A; 0], _y: [B]) { drop_var(self, ()) }
+                fn pub_trait_fn5(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, []) }
+                fn pub_trait_fn6(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, []) }
+            }
+
+            pub fn PubLiblocal_fn3<A, N, B, M>(_x: (A, B), _y: [Field; N], _z: [Field; M]) -> [A; 0] {
+                assert(IMPORT_GLOBAL_N_2 != IMPORT_GLOBAL_M_2);
+                []
+            }
+        }
+
+        // Re-export 
+        use library2::ReExportMeFromAnotherLib1;
+
+        global IMPORT_GLOBAL_N_1: Field = 2;
+
+        global IMPORT_GLOBAL_M_1: Field = 3;
+
+        struct LibLocalStruct1<N, M, A, B> {
+            lib_field1: A,
+            lib_field2: B,
+            lib_field3: [A; N],
+            lib_field4: ([A; N], [B; M]),
+            lib_field5: &mut A,
+        }
+
+        impl<N, M, A, B> Default for LibLocalStruct1<N, M, A, B> where A: Default, B: Default {
+            fn default() -> Self {
+                let mut mut_field = &mut Default::default();
+                Self {
+                    lib_field1: Default::default(),
+                    lib_field2: Default::default(),
+                    lib_field3: Default::default(),
+                    lib_field4: Default::default(),
+                    lib_field5: mut_field,
+                }
+            }
+        }
+
+        trait LibDefinedInLocalModule1<A, B, N, M> {
+            fn lib_trait_fn1(self, x: A);
+            fn lib_trait_fn2(self, y: B);
+            fn lib_trait_fn3(&mut self, x: A, y: B);
+            fn lib_trait_fn4(self, x: [A; 0], y: [B]);
+            fn lib_trait_fn5(self, x: [A; N], y: [B; M]) -> [A; 0];
+            fn lib_trait_fn6(self, x: [A; N], y: [B; M]) -> [A; 0];
+            fn lib_trait_fn7(self, _x: fn([A; 0]) -> B) -> Field {
+                drop_var(self, N + M)
+            }
+        }
+
+        impl<N, M, A, B> LibDefinedInLocalModule1<A, B, N, M> for LibLocalStruct1<N, M, A, B> {
+            fn lib_trait_fn1(self, _x: A) { drop_var(self, ()) }
+            fn lib_trait_fn2(self, _y: B) { drop_var(self, ()) }
+            fn lib_trait_fn3(&mut self, _x: A, _y: B) { drop_var(self, ()) }
+            fn lib_trait_fn4(self, _x: [A; 0], _y: [B]) { drop_var(self, ()) }
+            fn lib_trait_fn5(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, []) }
+            fn lib_trait_fn6(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, []) }
+        }
+
+        pub fn Liblocal_fn1<A, N, B, M>(_x: (A, B), _y: [Field; N], _z: [Field; M]) -> [A; 0] {
+            assert(IMPORT_GLOBAL_N_1 != IMPORT_GLOBAL_M_1);
+            []
+        }
+    }
+
+    mod library3 {
+        use crate::{Default, drop_var};
+
+        global IMPORT_GLOBAL_N_3: Field = 6;
+
+        global IMPORT_GLOBAL_M_3: Field = 7;
+
+        struct ReExportMeFromAnotherLib2 {
+            x : Field,
+        }
+
+        struct PubCrateLibLocalStruct2<N, M, A, B> {
+            crate_field1: A,
+            crate_field2: B,
+            crate_field3: [A; N],
+            crate_field4: ([A; N], [B; M]),
+            crate_field5: &mut A,
+        }
+
+        impl<N, M, A, B> Default for PubCrateLibLocalStruct2<N, M, A, B> where A: Default, B: Default {
+            fn default() -> Self {
+                let mut mut_field = &mut Default::default();
+                Self {
+                    crate_field1: Default::default(),
+                    crate_field2: Default::default(),
+                    crate_field3: Default::default(),
+                    crate_field4: Default::default(),
+                    crate_field5: mut_field,
+                }
+            }
+        }
+
+        trait PubCrateLibDefinedInLocalModule2<A, B, N, M> {
+            fn crate_trait_fn1(self, x: A);
+            fn crate_trait_fn2(self, y: B);
+            fn crate_trait_fn3(&mut self, x: A, y: B);
+            fn crate_trait_fn4(self, x: [A; 0], y: [B]);
+            fn crate_trait_fn5(self, x: [A; N], y: [B; M]) -> [A; 0];
+            fn crate_trait_fn6(self, x: [A; N], y: [B; M]) -> [A; 0];
+            fn crate_trait_fn7(self, _x: fn([A; 0]) -> B) -> Field {
+                drop_var(self, N + M)
+            }
+        }
+
+        impl<N, M, A, B> PubCrateLibDefinedInLocalModule2<A, B, N, M> for PubCrateLibLocalStruct2<N, M, A, B> {
+            fn crate_trait_fn1(self, _x: A) { drop_var(self, ()) }
+            fn crate_trait_fn2(self, _y: B) { drop_var(self, ()) }
+            fn crate_trait_fn3(&mut self, _x: A, _y: B) { drop_var(self, ()) }
+            fn crate_trait_fn4(self, _x: [A; 0], _y: [B]) { drop_var(self, ()) }
+            fn crate_trait_fn5(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, ()); [] }
+            fn crate_trait_fn6(self, _x: [A; N], _y: [B; M]) -> [A; 0] { drop_var(self, ()); [] }
+        }
+
+        pub(crate) fn PubCrateLiblocal_fn2<A, N, B, M>(_x: (A, B), _y: [Field; N], _z: [Field; M]) -> [A; 0] {
+            assert(IMPORT_GLOBAL_N_3 != IMPORT_GLOBAL_M_3);
+            []
+        }
+    }
+
+
+    use crate::local_module::{local_fn4, LocalStruct, DefinedInLocalModule1, LOCAL_GLOBAL_N, LOCAL_GLOBAL_M};
+
+    use library::{ReExportMeFromAnotherLib1, LibLocalStruct1, LibDefinedInLocalModule1, Liblocal_fn1, IMPORT_GLOBAL_N_1, IMPORT_GLOBAL_M_1};
+
+    // overlapping
+    // use library::library2::ReExportMeFromAnotherLib1;
+    use crate::library::library2::{PubLibLocalStruct3, PubLibDefinedInLocalModule3, PubLiblocal_fn3, IMPORT_GLOBAL_N_2, IMPORT_GLOBAL_M_2};
+
+    use library3::{ReExportMeFromAnotherLib2, PubCrateLibLocalStruct2, PubCrateLibDefinedInLocalModule2, PubCrateLiblocal_fn2, IMPORT_GLOBAL_N_3, IMPORT_GLOBAL_M_3};
+
+
+    fn main(_x: ReExportMeFromAnotherLib1, _y: ReExportMeFromAnotherLib2) {
+        assert(LOCAL_GLOBAL_N != LOCAL_GLOBAL_M);
+        assert(IMPORT_GLOBAL_N_1 != IMPORT_GLOBAL_M_1);
+        assert(IMPORT_GLOBAL_N_2 != IMPORT_GLOBAL_M_2);
+        assert(IMPORT_GLOBAL_N_3 != IMPORT_GLOBAL_M_3);
+
+        let x: LocalStruct<LOCAL_GLOBAL_N, LOCAL_GLOBAL_M, Field, bool> = Default::default();
+        assert(drop_var(x.trait_fn5([0; LOCAL_GLOBAL_N], [false; LOCAL_GLOBAL_M]), true));
+        assert(drop_var(x.trait_fn6([0; LOCAL_GLOBAL_N], [false; LOCAL_GLOBAL_M]), true));
+
+        let x: LibLocalStruct1<IMPORT_GLOBAL_N_1, IMPORT_GLOBAL_M_1, Field, bool> = Default::default();
+        assert(drop_var(x.lib_trait_fn5([0; IMPORT_GLOBAL_N_1], [false; IMPORT_GLOBAL_M_1]), true));
+        assert(drop_var(x.lib_trait_fn6([0; IMPORT_GLOBAL_N_1], [false; IMPORT_GLOBAL_M_1]), true));
+
+        let x: PubLibLocalStruct3<IMPORT_GLOBAL_N_2, IMPORT_GLOBAL_M_2, Field, bool> = Default::default();
+        assert(drop_var(x.pub_trait_fn5([0; IMPORT_GLOBAL_N_2], [false; IMPORT_GLOBAL_M_2]), true));
+        assert(drop_var(x.pub_trait_fn6([0; IMPORT_GLOBAL_N_2], [false; IMPORT_GLOBAL_M_2]), true));
+
+        let x: PubCrateLibLocalStruct2<IMPORT_GLOBAL_N_3, IMPORT_GLOBAL_M_3, Field, bool> = Default::default();
+        assert(drop_var(x.crate_trait_fn5([0; IMPORT_GLOBAL_N_3], [false; IMPORT_GLOBAL_M_3]), true));
+        assert(drop_var(x.crate_trait_fn6([0; IMPORT_GLOBAL_N_3], [false; IMPORT_GLOBAL_M_3]), true));
+
+        assert(drop_var(local_fn2((0, 1), [], []), true));
+        assert(drop_var(Liblocal_fn1((0, 1), [], []), true));
+        assert(drop_var(PubLiblocal_fn4((0, 1), [], []), true));
+        assert(drop_var(PubCrateLiblocal_fn3((0, 1), [], []), true));
+    }";
+
+    // NOTE: these names must be "replacement-unique", i.e.
+    // replacing one in a discinct name should do nothing
+    let names_to_collapse = [
+        "DefinedInLocalModule1",
+        "IMPORT_GLOBAL_M_1",
+        "IMPORT_GLOBAL_M_2",
+        "IMPORT_GLOBAL_M_3",
+        "IMPORT_GLOBAL_N_1",
+        "IMPORT_GLOBAL_N_2",
+        "IMPORT_GLOBAL_N_3",
+        "LOCAL_GLOBAL_M",
+        "LOCAL_GLOBAL_N",
+        "LibDefinedInLocalModule1",
+        "LibLocalStruct1",
+        "Liblocal_fn1",
+        "LocalStruct",
+        "PubCrateLibDefinedInLocalModule2",
+        "PubCrateLibLocalStruct2",
+        "PubCrateLiblocal_fn2",
+        "PubLibDefinedInLocalModule3",
+        "PubLibLocalStruct3",
+        "PubLiblocal_fn3",
+        "ReExportMeFromAnotherLib1",
+        "ReExportMeFromAnotherLib2",
+        "local_fn4",
+        "crate_field1",
+        "crate_field2",
+        "crate_field3",
+        "crate_field4",
+        "crate_field5",
+        "crate_trait_fn1",
+        "crate_trait_fn2",
+        "crate_trait_fn3",
+        "crate_trait_fn4",
+        "crate_trait_fn5",
+        "crate_trait_fn6",
+        "crate_trait_fn7",
+        "field1",
+        "field2",
+        "field3",
+        "field4",
+        "field5",
+        "lib_field1",
+        "lib_field2",
+        "lib_field3",
+        "lib_field4",
+        "lib_field5",
+        "lib_trait_fn1",
+        "lib_trait_fn2",
+        "lib_trait_fn3",
+        "lib_trait_fn4",
+        "lib_trait_fn5",
+        "lib_trait_fn6",
+        "lib_trait_fn7",
+        "pub_field1",
+        "pub_field2",
+        "pub_field3",
+        "pub_field4",
+        "pub_field5",
+        "pub_trait_fn1",
+        "pub_trait_fn2",
+        "pub_trait_fn3",
+        "pub_trait_fn4",
+        "pub_trait_fn5",
+        "pub_trait_fn6",
+        "pub_trait_fn7",
+        "trait_fn1",
+        "trait_fn2",
+        "trait_fn3",
+        "trait_fn4",
+        "trait_fn5",
+        "trait_fn6",
+        "trait_fn7",
+    ];
+
+    // TODO(https://github.com/noir-lang/noir/issues/4973):
+    // Name resolution panic from name shadowing test
+    let cases_to_skip = [
+        (1, 21),
+        (2, 11),
+        (2, 21),
+        (3, 11),
+        (3, 18),
+        (3, 21),
+        (4, 21),
+        (5, 11),
+        (5, 21),
+        (6, 11),
+        (6, 18),
+        (6, 21),
+    ];
+    let cases_to_skip: HashSet<(usize, usize)> = cases_to_skip.into_iter().collect();
+
+    for (i, x) in names_to_collapse.iter().enumerate() {
+        for (j, y) in names_to_collapse.iter().enumerate().filter(|(j, _)| i < *j) {
+            if !cases_to_skip.contains(&(i, j)) {
+                dbg!((i, j));
+
+                let modified_src = src.replace(x, y);
+                let errors = get_program_errors(&modified_src);
+                assert!(!errors.is_empty(), "Expected errors, got: {:?}", errors);
+            }
+        }
+    }
+}

From f01d3090759a5ff0f1f83c5616d22890c6bd76be Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 8 May 2024 15:56:10 +0100
Subject: [PATCH 265/416] feat: increase default expression width to 4 (#4995)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The new version of `bb` can use an expression width of 4 so we update to
make use of this.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acir/benches/serialization.rs       |  2 +-
 .../optimizers/constant_backpropagation.rs    |  2 +-
 .../compiler/optimizers/redundant_range.rs    |  2 +-
 compiler/noirc_driver/src/lib.rs              |  2 +-
 compiler/wasm/src/compile.rs                  | 21 ++++++++-----
 compiler/wasm/src/compile_new.rs              | 30 ++++++++++++-------
 tooling/nargo_cli/src/cli/dap_cmd.rs          |  2 +-
 7 files changed, 38 insertions(+), 23 deletions(-)

diff --git a/acvm-repo/acir/benches/serialization.rs b/acvm-repo/acir/benches/serialization.rs
index e51726e3901..a7f32b4a4c7 100644
--- a/acvm-repo/acir/benches/serialization.rs
+++ b/acvm-repo/acir/benches/serialization.rs
@@ -33,7 +33,7 @@ fn sample_program(num_opcodes: usize) -> Program {
         functions: vec![Circuit {
             current_witness_index: 4000,
             opcodes: assert_zero_opcodes.to_vec(),
-            expression_width: ExpressionWidth::Bounded { width: 3 },
+            expression_width: ExpressionWidth::Bounded { width: 4 },
             private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3), Witness(4)]),
             public_parameters: PublicInputs(BTreeSet::from([Witness(5)])),
             return_values: PublicInputs(BTreeSet::from([Witness(6)])),
diff --git a/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs b/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
index 0e7d28104da..5b778f63f07 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
@@ -282,7 +282,7 @@ mod tests {
     fn test_circuit(opcodes: Vec<Opcode>) -> Circuit {
         Circuit {
             current_witness_index: 1,
-            expression_width: ExpressionWidth::Bounded { width: 3 },
+            expression_width: ExpressionWidth::Bounded { width: 4 },
             opcodes,
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs::default(),
diff --git a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
index c6ca18d30ae..0e1629717b3 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
@@ -164,7 +164,7 @@ mod tests {
 
         Circuit {
             current_witness_index: 1,
-            expression_width: ExpressionWidth::Bounded { width: 3 },
+            expression_width: ExpressionWidth::Bounded { width: 4 },
             opcodes,
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs::default(),
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index f18997d5d7f..5f1985b0553 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -54,7 +54,7 @@ pub const NOIR_ARTIFACT_VERSION_STRING: &str =
 #[derive(Args, Clone, Debug, Default)]
 pub struct CompileOptions {
     /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width, default_value = "3")]
+    #[arg(long, value_parser = parse_expression_width, default_value = "4")]
     pub expression_width: ExpressionWidth,
 
     /// Force a full recompilation.
diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index de157a1fe20..57b17a6f79e 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -1,3 +1,4 @@
+use acvm::acir::circuit::ExpressionWidth;
 use fm::FileManager;
 use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{JsString, Object};
@@ -169,9 +170,10 @@ pub fn compile_program(
     console_error_panic_hook::set_once();
     let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
 
-    let compile_options = CompileOptions::default();
-    // For now we default to a bounded width of 3, though we can add it as a parameter
-    let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
+    let compile_options = CompileOptions {
+        expression_width: ExpressionWidth::Bounded { width: 4 },
+        ..CompileOptions::default()
+    };
 
     let compiled_program =
         noirc_driver::compile_main(&mut context, crate_id, &compile_options, None)
@@ -184,7 +186,8 @@ pub fn compile_program(
             })?
             .0;
 
-    let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let optimized_program =
+        nargo::ops::transform_program(compiled_program, compile_options.expression_width);
     let warnings = optimized_program.warnings.clone();
 
     Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
@@ -199,9 +202,10 @@ pub fn compile_contract(
     console_error_panic_hook::set_once();
     let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
 
-    let compile_options = CompileOptions::default();
-    // For now we default to a bounded width of 3, though we can add it as a parameter
-    let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
+    let compile_options = CompileOptions {
+        expression_width: ExpressionWidth::Bounded { width: 4 },
+        ..CompileOptions::default()
+    };
 
     let compiled_contract =
         noirc_driver::compile_contract(&mut context, crate_id, &compile_options)
@@ -214,7 +218,8 @@ pub fn compile_contract(
             })?
             .0;
 
-    let optimized_contract = nargo::ops::transform_contract(compiled_contract, expression_width);
+    let optimized_contract =
+        nargo::ops::transform_contract(compiled_contract, compile_options.expression_width);
 
     let functions =
         optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index c187fe7f3de..4f11cafb975 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -3,6 +3,7 @@ use crate::compile::{
     PathToFileSourceMap,
 };
 use crate::errors::{CompileError, JsCompileError};
+use acvm::acir::circuit::ExpressionWidth;
 use nargo::artifacts::contract::{ContractArtifact, ContractFunctionArtifact};
 use nargo::parse_all;
 use noirc_driver::{
@@ -96,11 +97,14 @@ impl CompilerContext {
         mut self,
         program_width: usize,
     ) -> Result<JsCompileProgramResult, JsCompileError> {
-        let compile_options = CompileOptions::default();
-        let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
+        let expression_width = if program_width == 0 {
+            ExpressionWidth::Unbounded
+        } else {
+            ExpressionWidth::Bounded { width: 4 }
+        };
+        let compile_options = CompileOptions { expression_width, ..CompileOptions::default() };
 
         let root_crate_id = *self.context.root_crate_id();
-
         let compiled_program =
             compile_main(&mut self.context, root_crate_id, &compile_options, None)
                 .map_err(|errs| {
@@ -112,7 +116,8 @@ impl CompilerContext {
                 })?
                 .0;
 
-        let optimized_program = nargo::ops::transform_program(compiled_program, np_language);
+        let optimized_program =
+            nargo::ops::transform_program(compiled_program, compile_options.expression_width);
         let warnings = optimized_program.warnings.clone();
 
         Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
@@ -122,10 +127,14 @@ impl CompilerContext {
         mut self,
         program_width: usize,
     ) -> Result<JsCompileContractResult, JsCompileError> {
-        let compile_options = CompileOptions::default();
-        let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
-        let root_crate_id = *self.context.root_crate_id();
+        let expression_width = if program_width == 0 {
+            ExpressionWidth::Unbounded
+        } else {
+            ExpressionWidth::Bounded { width: 4 }
+        };
+        let compile_options = CompileOptions { expression_width, ..CompileOptions::default() };
 
+        let root_crate_id = *self.context.root_crate_id();
         let compiled_contract =
             compile_contract(&mut self.context, root_crate_id, &compile_options)
                 .map_err(|errs| {
@@ -137,7 +146,8 @@ impl CompilerContext {
                 })?
                 .0;
 
-        let optimized_contract = nargo::ops::transform_contract(compiled_contract, np_language);
+        let optimized_contract =
+            nargo::ops::transform_contract(compiled_contract, compile_options.expression_width);
 
         let functions =
             optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
@@ -166,7 +176,7 @@ pub fn compile_program_(
 
     let compiler_context =
         prepare_compiler_context(entry_point, dependency_graph, file_source_map)?;
-    let program_width = 3;
+    let program_width = 4;
 
     compiler_context.compile_program(program_width)
 }
@@ -183,7 +193,7 @@ pub fn compile_contract_(
 
     let compiler_context =
         prepare_compiler_context(entry_point, dependency_graph, file_source_map)?;
-    let program_width = 3;
+    let program_width = 4;
 
     compiler_context.compile_contract(program_width)
 }
diff --git a/tooling/nargo_cli/src/cli/dap_cmd.rs b/tooling/nargo_cli/src/cli/dap_cmd.rs
index d06d39f3b6a..124e30069ae 100644
--- a/tooling/nargo_cli/src/cli/dap_cmd.rs
+++ b/tooling/nargo_cli/src/cli/dap_cmd.rs
@@ -28,7 +28,7 @@ use noir_debugger::errors::{DapError, LoadError};
 #[derive(Debug, Clone, Args)]
 pub(crate) struct DapCommand {
     /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width, default_value = "3")]
+    #[arg(long, value_parser = parse_expression_width, default_value = "4")]
     expression_width: ExpressionWidth,
 
     #[clap(long)]

From 95d4d133d1eb5e0eb44cd928d8183d890e970a13 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 8 May 2024 17:27:52 +0100
Subject: [PATCH 266/416] feat: add `Not` trait to stdlib (#4999)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds a `Not` trait which is an equivalent of Rust's
`std::ops::Not` trait which represents a bitwise NOT.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/noir/standard_library/traits.md |  9 +++++++
 noir_stdlib/src/ops.nr                    |  2 +-
 noir_stdlib/src/ops/bit.nr                | 21 ++++++++++++++++
 noir_stdlib/src/uint128.nr                | 30 +++++++++++++++++++++--
 4 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
index 08370dde9e4..96a7b8e2f22 100644
--- a/docs/docs/noir/standard_library/traits.md
+++ b/docs/docs/noir/standard_library/traits.md
@@ -241,6 +241,15 @@ impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
 Implementations:
 #include_code neg-trait-impls noir_stdlib/src/ops/arith.nr rust
 
+### `std::ops::Not`
+
+#include_code not-trait noir_stdlib/src/ops/bit.nr rust
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+#include_code not-trait-impls noir_stdlib/src/ops/bit.nr rust
+
 ### `std::ops::{ BitOr, BitAnd, BitXor }`
 
 #include_code bitor-trait noir_stdlib/src/ops/bit.nr rust
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index d7ea1dfd484..8b1903cff0b 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -2,4 +2,4 @@ mod arith;
 mod bit;
 
 use arith::{Add, Sub, Mul, Div, Rem, Neg};
-use bit::{BitOr, BitAnd, BitXor, Shl, Shr};
+use bit::{Not, BitOr, BitAnd, BitXor, Shl, Shr};
diff --git a/noir_stdlib/src/ops/bit.nr b/noir_stdlib/src/ops/bit.nr
index ae06520e9c4..a31cfee878c 100644
--- a/noir_stdlib/src/ops/bit.nr
+++ b/noir_stdlib/src/ops/bit.nr
@@ -1,3 +1,24 @@
+// docs:start:not-trait
+trait Not {
+    fn not(self: Self) -> Self;
+}
+// docs:end:not-trait
+
+// docs:start:not-trait-impls
+impl Not for bool { fn not(self) -> bool { !self } }
+
+impl Not for u64 { fn not(self) -> u64 { !self } }
+impl Not for u32 { fn not(self) -> u32 { !self } }
+impl Not for u16 { fn not(self) -> u16 { !self } }
+impl Not for u8 { fn not(self) -> u8 { !self } }
+impl Not for u1 { fn not(self) -> u1 { !self } }
+
+impl Not for i8 { fn not(self) -> i8 { !self } }
+impl Not for i16 { fn not(self) -> i16 { !self } }
+impl Not for i32 { fn not(self) -> i32 { !self } }
+impl Not for i64 { fn not(self) -> i64 { !self } }
+// docs:end:not-trait-impls
+
 // docs:start:bitor-trait
 trait BitOr {
     fn bitor(self, other: Self) -> Self;
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index d0f38079e6f..9c61fc801f3 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -1,4 +1,4 @@
-use crate::ops::{Add, Sub, Mul, Div, Rem, BitOr, BitAnd, BitXor, Shl, Shr};
+use crate::ops::{Add, Sub, Mul, Div, Rem, Not, BitOr, BitAnd, BitXor, Shl, Shr};
 use crate::cmp::{Eq, Ord, Ordering};
 
 global pow64 : Field = 18446744073709551616; //2^64;
@@ -228,11 +228,20 @@ impl Ord for U128 {
     }
 }
 
+impl Not for U128 { 
+    fn not(self) -> U128 {
+        U128 {
+            lo: (!(self.lo as u64)) as Field,
+            hi: (!(self.hi as u64)) as Field
+        }
+    }
+}
+
 impl BitOr for U128 { 
     fn bitor(self, other: U128) -> U128 {
         U128 {
             lo: ((self.lo as u64) | (other.lo as u64)) as Field,
-            hi: ((self.hi as u64) | (other.hi as u64))as Field
+            hi: ((self.hi as u64) | (other.hi as u64)) as Field
         }
     }
 }
@@ -284,3 +293,20 @@ impl Shr for U128 {
         self / U128::from_integer(y)
     } 
 }
+
+mod test {
+    use crate::uint128::{U128, pow64};
+
+    #[test]
+    fn test_not() {
+        let num = U128::from_u64s_le(0, 0);
+        let not_num = num.not();
+
+        let max_u64: Field = pow64 - 1;
+        assert_eq(not_num.hi, max_u64);
+        assert_eq(not_num.lo, max_u64);
+
+        let not_not_num = not_num.not();
+        assert_eq(num, not_not_num);
+    }
+}

From e12bf9b412a47d1514ea921003a55fb9b77b2020 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 9 May 2024 12:57:58 -0500
Subject: [PATCH 267/416] chore(experimental): Add Elaborator pass (#4992)

# Description

## Problem\*

Resolves #4953

## Summary\*

Adds an elaborator - a concept borrowed from dependently typed languages
- which performs name resolution and type checking simultaneously. The
new elaborator is currently disabled (inaccessible from user code) since
it is not hooked up to the `dc_crate` module.

This PR is extremely large (sorry!) but is 99% a pseudo copy-paste of
existing code from the name resolver and type checker, only slightly
adapted to be able to work in tandem. Unfortunately, this also means
that we'll need to duplicate any changes made to the name resolver &
type checker in the elaborator as well until we can remove the old name
resolution and type checking passes. For example,
https://github.com/noir-lang/noir/pull/4958 will need to be integrated
into the elaborator as well.

## Additional Context

After this PR the plan is to
1. Connect the elaborator to `dc_crate`, enabling it with a command-line
option.
2. Insert logic for the comptime scanning pass in the elaborator as
well.
3. Test the elaborator against all existing tests.
4. Once it passes, we can use the elaborator by default and delete the
name resolution, type checking, and comptime scanning passes.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/statement.rs  |    5 +-
 .../src/elaborator/expressions.rs             |  604 +++++++
 compiler/noirc_frontend/src/elaborator/mod.rs |  159 ++
 .../noirc_frontend/src/elaborator/patterns.rs |  463 ++++++
 .../noirc_frontend/src/elaborator/scope.rs    |  100 ++
 .../src/elaborator/statements.rs              |  409 +++++
 .../noirc_frontend/src/elaborator/types.rs    | 1399 +++++++++++++++++
 .../src/hir/resolution/import.rs              |    9 +
 .../src/hir/resolution/resolver.rs            |   12 +-
 .../noirc_frontend/src/hir/type_check/expr.rs |    4 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  |    2 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |   11 +-
 compiler/noirc_frontend/src/hir_def/types.rs  |    8 +-
 compiler/noirc_frontend/src/lib.rs            |    1 +
 compiler/noirc_frontend/src/node_interner.rs  |    6 +-
 15 files changed, 3170 insertions(+), 22 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/elaborator/expressions.rs
 create mode 100644 compiler/noirc_frontend/src/elaborator/mod.rs
 create mode 100644 compiler/noirc_frontend/src/elaborator/patterns.rs
 create mode 100644 compiler/noirc_frontend/src/elaborator/scope.rs
 create mode 100644 compiler/noirc_frontend/src/elaborator/statements.rs
 create mode 100644 compiler/noirc_frontend/src/elaborator/types.rs

diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 0da39edfd85..94b5841e52c 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -565,7 +565,7 @@ impl ForRange {
         identifier: Ident,
         block: Expression,
         for_loop_span: Span,
-    ) -> StatementKind {
+    ) -> Statement {
         /// Counter used to generate unique names when desugaring
         /// code in the parser requires the creation of fresh variables.
         /// The parser is stateless so this is a static global instead.
@@ -662,7 +662,8 @@ impl ForRange {
                 let block = ExpressionKind::Block(BlockExpression {
                     statements: vec![let_array, for_loop],
                 });
-                StatementKind::Expression(Expression::new(block, for_loop_span))
+                let kind = StatementKind::Expression(Expression::new(block, for_loop_span));
+                Statement { kind, span: for_loop_span }
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
new file mode 100644
index 00000000000..19ee67b442c
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -0,0 +1,604 @@
+use iter_extended::vecmap;
+use noirc_errors::{Location, Span};
+use regex::Regex;
+use rustc_hash::FxHashSet as HashSet;
+
+use crate::{
+    ast::{
+        ArrayLiteral, ConstructorExpression, IfExpression, InfixExpression, Lambda,
+        UnresolvedTypeExpression,
+    },
+    hir::{
+        resolution::{errors::ResolverError, resolver::LambdaContext},
+        type_check::TypeCheckError,
+    },
+    hir_def::{
+        expr::{
+            HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
+            HirConstructorExpression, HirIdent, HirIfExpression, HirIndexExpression,
+            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
+            HirMethodReference, HirPrefixExpression,
+        },
+        traits::TraitConstraint,
+    },
+    macros_api::{
+        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirExpression,
+        HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
+        MethodCallExpression, PrefixExpression,
+    },
+    node_interner::{DefinitionKind, ExprId, FuncId},
+    Shared, StructType, Type,
+};
+
+use super::Elaborator;
+
+impl Elaborator {
+    pub(super) fn elaborate_expression(&mut self, expr: Expression) -> (ExprId, Type) {
+        let (hir_expr, typ) = match expr.kind {
+            ExpressionKind::Literal(literal) => self.elaborate_literal(literal, expr.span),
+            ExpressionKind::Block(block) => self.elaborate_block(block),
+            ExpressionKind::Prefix(prefix) => self.elaborate_prefix(*prefix),
+            ExpressionKind::Index(index) => self.elaborate_index(*index),
+            ExpressionKind::Call(call) => self.elaborate_call(*call, expr.span),
+            ExpressionKind::MethodCall(call) => self.elaborate_method_call(*call, expr.span),
+            ExpressionKind::Constructor(constructor) => self.elaborate_constructor(*constructor),
+            ExpressionKind::MemberAccess(access) => {
+                return self.elaborate_member_access(*access, expr.span)
+            }
+            ExpressionKind::Cast(cast) => self.elaborate_cast(*cast, expr.span),
+            ExpressionKind::Infix(infix) => return self.elaborate_infix(*infix, expr.span),
+            ExpressionKind::If(if_) => self.elaborate_if(*if_),
+            ExpressionKind::Variable(variable) => return self.elaborate_variable(variable),
+            ExpressionKind::Tuple(tuple) => self.elaborate_tuple(tuple),
+            ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
+            ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
+            ExpressionKind::Quote(quote) => self.elaborate_quote(quote),
+            ExpressionKind::Comptime(comptime) => self.elaborate_comptime_block(comptime),
+            ExpressionKind::Error => (HirExpression::Error, Type::Error),
+        };
+        let id = self.interner.push_expr(hir_expr);
+        self.interner.push_expr_location(id, expr.span, self.file);
+        self.interner.push_expr_type(id, typ.clone());
+        (id, typ)
+    }
+
+    pub(super) fn elaborate_block(&mut self, block: BlockExpression) -> (HirExpression, Type) {
+        self.push_scope();
+        let mut block_type = Type::Unit;
+        let mut statements = Vec::with_capacity(block.statements.len());
+
+        for (i, statement) in block.statements.into_iter().enumerate() {
+            let (id, stmt_type) = self.elaborate_statement(statement);
+            statements.push(id);
+
+            if let HirStatement::Semi(expr) = self.interner.statement(&id) {
+                let inner_expr_type = self.interner.id_type(expr);
+                let span = self.interner.expr_span(&expr);
+
+                self.unify(&inner_expr_type, &Type::Unit, || TypeCheckError::UnusedResultError {
+                    expr_type: inner_expr_type.clone(),
+                    expr_span: span,
+                });
+
+                if i + 1 == statements.len() {
+                    block_type = stmt_type;
+                }
+            }
+        }
+
+        self.pop_scope();
+        (HirExpression::Block(HirBlockExpression { statements }), block_type)
+    }
+
+    fn elaborate_literal(&mut self, literal: Literal, span: Span) -> (HirExpression, Type) {
+        use HirExpression::Literal as Lit;
+        match literal {
+            Literal::Unit => (Lit(HirLiteral::Unit), Type::Unit),
+            Literal::Bool(b) => (Lit(HirLiteral::Bool(b)), Type::Bool),
+            Literal::Integer(integer, sign) => {
+                let int = HirLiteral::Integer(integer, sign);
+                (Lit(int), self.polymorphic_integer_or_field())
+            }
+            Literal::Str(str) | Literal::RawStr(str, _) => {
+                let len = Type::Constant(str.len() as u64);
+                (Lit(HirLiteral::Str(str)), Type::String(Box::new(len)))
+            }
+            Literal::FmtStr(str) => self.elaborate_fmt_string(str, span),
+            Literal::Array(array_literal) => {
+                self.elaborate_array_literal(array_literal, span, true)
+            }
+            Literal::Slice(array_literal) => {
+                self.elaborate_array_literal(array_literal, span, false)
+            }
+        }
+    }
+
+    fn elaborate_array_literal(
+        &mut self,
+        array_literal: ArrayLiteral,
+        span: Span,
+        is_array: bool,
+    ) -> (HirExpression, Type) {
+        let (expr, elem_type, length) = match array_literal {
+            ArrayLiteral::Standard(elements) => {
+                let first_elem_type = self.interner.next_type_variable();
+                let first_span = elements.first().map(|elem| elem.span).unwrap_or(span);
+
+                let elements = vecmap(elements.into_iter().enumerate(), |(i, elem)| {
+                    let span = elem.span;
+                    let (elem_id, elem_type) = self.elaborate_expression(elem);
+
+                    self.unify(&elem_type, &first_elem_type, || {
+                        TypeCheckError::NonHomogeneousArray {
+                            first_span,
+                            first_type: first_elem_type.to_string(),
+                            first_index: 0,
+                            second_span: span,
+                            second_type: elem_type.to_string(),
+                            second_index: i,
+                        }
+                        .add_context("elements in an array must have the same type")
+                    });
+                    elem_id
+                });
+
+                let length = Type::Constant(elements.len() as u64);
+                (HirArrayLiteral::Standard(elements), first_elem_type, length)
+            }
+            ArrayLiteral::Repeated { repeated_element, length } => {
+                let span = length.span;
+                let length =
+                    UnresolvedTypeExpression::from_expr(*length, span).unwrap_or_else(|error| {
+                        self.push_err(ResolverError::ParserError(Box::new(error)));
+                        UnresolvedTypeExpression::Constant(0, span)
+                    });
+
+                let length = self.convert_expression_type(length);
+                let (repeated_element, elem_type) = self.elaborate_expression(*repeated_element);
+
+                let length_clone = length.clone();
+                (HirArrayLiteral::Repeated { repeated_element, length }, elem_type, length_clone)
+            }
+        };
+        let constructor = if is_array { HirLiteral::Array } else { HirLiteral::Slice };
+        let elem_type = Box::new(elem_type);
+        let typ = if is_array {
+            Type::Array(Box::new(length), elem_type)
+        } else {
+            Type::Slice(elem_type)
+        };
+        (HirExpression::Literal(constructor(expr)), typ)
+    }
+
+    fn elaborate_fmt_string(&mut self, str: String, call_expr_span: Span) -> (HirExpression, Type) {
+        let re = Regex::new(r"\{([a-zA-Z0-9_]+)\}")
+            .expect("ICE: an invalid regex pattern was used for checking format strings");
+
+        let mut fmt_str_idents = Vec::new();
+        let mut capture_types = Vec::new();
+
+        for field in re.find_iter(&str) {
+            let matched_str = field.as_str();
+            let ident_name = &matched_str[1..(matched_str.len() - 1)];
+
+            let scope_tree = self.scopes.current_scope_tree();
+            let variable = scope_tree.find(ident_name);
+            if let Some((old_value, _)) = variable {
+                old_value.num_times_used += 1;
+                let ident = HirExpression::Ident(old_value.ident.clone());
+                let expr_id = self.interner.push_expr(ident);
+                self.interner.push_expr_location(expr_id, call_expr_span, self.file);
+                let ident = old_value.ident.clone();
+                let typ = self.type_check_variable(ident, expr_id);
+                self.interner.push_expr_type(expr_id, typ.clone());
+                capture_types.push(typ);
+                fmt_str_idents.push(expr_id);
+            } else if ident_name.parse::<usize>().is_ok() {
+                self.push_err(ResolverError::NumericConstantInFormatString {
+                    name: ident_name.to_owned(),
+                    span: call_expr_span,
+                });
+            } else {
+                self.push_err(ResolverError::VariableNotDeclared {
+                    name: ident_name.to_owned(),
+                    span: call_expr_span,
+                });
+            }
+        }
+
+        let len = Type::Constant(str.len() as u64);
+        let typ = Type::FmtString(Box::new(len), Box::new(Type::Tuple(capture_types)));
+        (HirExpression::Literal(HirLiteral::FmtStr(str, fmt_str_idents)), typ)
+    }
+
+    fn elaborate_prefix(&mut self, prefix: PrefixExpression) -> (HirExpression, Type) {
+        let span = prefix.rhs.span;
+        let (rhs, rhs_type) = self.elaborate_expression(prefix.rhs);
+        let ret_type = self.type_check_prefix_operand(&prefix.operator, &rhs_type, span);
+        (HirExpression::Prefix(HirPrefixExpression { operator: prefix.operator, rhs }), ret_type)
+    }
+
+    fn elaborate_index(&mut self, index_expr: IndexExpression) -> (HirExpression, Type) {
+        let span = index_expr.index.span;
+        let (index, index_type) = self.elaborate_expression(index_expr.index);
+
+        let expected = self.polymorphic_integer_or_field();
+        self.unify(&index_type, &expected, || TypeCheckError::TypeMismatch {
+            expected_typ: "an integer".to_owned(),
+            expr_typ: index_type.to_string(),
+            expr_span: span,
+        });
+
+        // When writing `a[i]`, if `a : &mut ...` then automatically dereference `a` as many
+        // times as needed to get the underlying array.
+        let lhs_span = index_expr.collection.span;
+        let (lhs, lhs_type) = self.elaborate_expression(index_expr.collection);
+        let (collection, lhs_type) = self.insert_auto_dereferences(lhs, lhs_type);
+
+        let typ = match lhs_type.follow_bindings() {
+            // XXX: We can check the array bounds here also, but it may be better to constant fold first
+            // and have ConstId instead of ExprId for constants
+            Type::Array(_, base_type) => *base_type,
+            Type::Slice(base_type) => *base_type,
+            Type::Error => Type::Error,
+            typ => {
+                self.push_err(TypeCheckError::TypeMismatch {
+                    expected_typ: "Array".to_owned(),
+                    expr_typ: typ.to_string(),
+                    expr_span: lhs_span,
+                });
+                Type::Error
+            }
+        };
+
+        let expr = HirExpression::Index(HirIndexExpression { collection, index });
+        (expr, typ)
+    }
+
+    fn elaborate_call(&mut self, call: CallExpression, span: Span) -> (HirExpression, Type) {
+        let (func, func_type) = self.elaborate_expression(*call.func);
+
+        let mut arguments = Vec::with_capacity(call.arguments.len());
+        let args = vecmap(call.arguments, |arg| {
+            let span = arg.span;
+            let (arg, typ) = self.elaborate_expression(arg);
+            arguments.push(arg);
+            (typ, arg, span)
+        });
+
+        let location = Location::new(span, self.file);
+        let call = HirCallExpression { func, arguments, location };
+        let typ = self.type_check_call(&call, func_type, args, span);
+        (HirExpression::Call(call), typ)
+    }
+
+    fn elaborate_method_call(
+        &mut self,
+        method_call: MethodCallExpression,
+        span: Span,
+    ) -> (HirExpression, Type) {
+        let object_span = method_call.object.span;
+        let (mut object, mut object_type) = self.elaborate_expression(method_call.object);
+        object_type = object_type.follow_bindings();
+
+        let method_name = method_call.method_name.0.contents.as_str();
+        match self.lookup_method(&object_type, method_name, span) {
+            Some(method_ref) => {
+                // Automatically add `&mut` if the method expects a mutable reference and
+                // the object is not already one.
+                if let HirMethodReference::FuncId(func_id) = &method_ref {
+                    if *func_id != FuncId::dummy_id() {
+                        let function_type = self.interner.function_meta(func_id).typ.clone();
+
+                        self.try_add_mutable_reference_to_object(
+                            &function_type,
+                            &mut object_type,
+                            &mut object,
+                        );
+                    }
+                }
+
+                // These arguments will be given to the desugared function call.
+                // Compared to the method arguments, they also contain the object.
+                let mut function_args = Vec::with_capacity(method_call.arguments.len() + 1);
+                let mut arguments = Vec::with_capacity(method_call.arguments.len());
+
+                function_args.push((object_type.clone(), object, object_span));
+
+                for arg in method_call.arguments {
+                    let span = arg.span;
+                    let (arg, typ) = self.elaborate_expression(arg);
+                    arguments.push(arg);
+                    function_args.push((typ, arg, span));
+                }
+
+                let location = Location::new(span, self.file);
+                let method = method_call.method_name;
+                let method_call = HirMethodCallExpression { method, object, arguments, location };
+
+                // Desugar the method call into a normal, resolved function call
+                // so that the backend doesn't need to worry about methods
+                // TODO: update object_type here?
+                let ((function_id, function_name), function_call) = method_call.into_function_call(
+                    &method_ref,
+                    object_type,
+                    location,
+                    &mut self.interner,
+                );
+
+                let func_type = self.type_check_variable(function_name, function_id);
+
+                // Type check the new call now that it has been changed from a method call
+                // to a function call. This way we avoid duplicating code.
+                let typ = self.type_check_call(&function_call, func_type, function_args, span);
+                (HirExpression::Call(function_call), typ)
+            }
+            None => (HirExpression::Error, Type::Error),
+        }
+    }
+
+    fn elaborate_constructor(
+        &mut self,
+        constructor: ConstructorExpression,
+    ) -> (HirExpression, Type) {
+        let span = constructor.type_name.span();
+
+        match self.lookup_type_or_error(constructor.type_name) {
+            Some(Type::Struct(r#type, struct_generics)) => {
+                let struct_type = r#type.clone();
+                let generics = struct_generics.clone();
+
+                let fields = constructor.fields;
+                let field_types = r#type.borrow().get_fields(&struct_generics);
+                let fields = self.resolve_constructor_expr_fields(
+                    struct_type.clone(),
+                    field_types,
+                    fields,
+                    span,
+                );
+                let expr = HirExpression::Constructor(HirConstructorExpression {
+                    fields,
+                    r#type,
+                    struct_generics,
+                });
+                (expr, Type::Struct(struct_type, generics))
+            }
+            Some(typ) => {
+                self.push_err(ResolverError::NonStructUsedInConstructor { typ, span });
+                (HirExpression::Error, Type::Error)
+            }
+            None => (HirExpression::Error, Type::Error),
+        }
+    }
+
+    /// Resolve all the fields of a struct constructor expression.
+    /// Ensures all fields are present, none are repeated, and all
+    /// are part of the struct.
+    fn resolve_constructor_expr_fields(
+        &mut self,
+        struct_type: Shared<StructType>,
+        field_types: Vec<(String, Type)>,
+        fields: Vec<(Ident, Expression)>,
+        span: Span,
+    ) -> Vec<(Ident, ExprId)> {
+        let mut ret = Vec::with_capacity(fields.len());
+        let mut seen_fields = HashSet::default();
+        let mut unseen_fields = struct_type.borrow().field_names();
+
+        for (field_name, field) in fields {
+            let expected_type = field_types.iter().find(|(name, _)| name == &field_name.0.contents);
+            let expected_type = expected_type.map(|(_, typ)| typ).unwrap_or(&Type::Error);
+
+            let field_span = field.span;
+            let (resolved, field_type) = self.elaborate_expression(field);
+
+            if unseen_fields.contains(&field_name) {
+                unseen_fields.remove(&field_name);
+                seen_fields.insert(field_name.clone());
+
+                self.unify_with_coercions(&field_type, expected_type, resolved, || {
+                    TypeCheckError::TypeMismatch {
+                        expected_typ: expected_type.to_string(),
+                        expr_typ: field_type.to_string(),
+                        expr_span: field_span,
+                    }
+                });
+            } else if seen_fields.contains(&field_name) {
+                // duplicate field
+                self.push_err(ResolverError::DuplicateField { field: field_name.clone() });
+            } else {
+                // field not required by struct
+                self.push_err(ResolverError::NoSuchField {
+                    field: field_name.clone(),
+                    struct_definition: struct_type.borrow().name.clone(),
+                });
+            }
+
+            ret.push((field_name, resolved));
+        }
+
+        if !unseen_fields.is_empty() {
+            self.push_err(ResolverError::MissingFields {
+                span,
+                missing_fields: unseen_fields.into_iter().map(|field| field.to_string()).collect(),
+                struct_definition: struct_type.borrow().name.clone(),
+            });
+        }
+
+        ret
+    }
+
+    fn elaborate_member_access(
+        &mut self,
+        access: MemberAccessExpression,
+        span: Span,
+    ) -> (ExprId, Type) {
+        let (lhs, lhs_type) = self.elaborate_expression(access.lhs);
+        let rhs = access.rhs;
+        // `is_offset` is only used when lhs is a reference and we want to return a reference to rhs
+        let access = HirMemberAccess { lhs, rhs, is_offset: false };
+        let expr_id = self.intern_expr(HirExpression::MemberAccess(access.clone()), span);
+        let typ = self.type_check_member_access(access, expr_id, lhs_type, span);
+        self.interner.push_expr_type(expr_id, typ.clone());
+        (expr_id, typ)
+    }
+
+    fn intern_expr(&mut self, expr: HirExpression, span: Span) -> ExprId {
+        let id = self.interner.push_expr(expr);
+        self.interner.push_expr_location(id, span, self.file);
+        id
+    }
+
+    fn elaborate_cast(&mut self, cast: CastExpression, span: Span) -> (HirExpression, Type) {
+        let (lhs, lhs_type) = self.elaborate_expression(cast.lhs);
+        let r#type = self.resolve_type(cast.r#type);
+        let result = self.check_cast(lhs_type, &r#type, span);
+        let expr = HirExpression::Cast(HirCastExpression { lhs, r#type });
+        (expr, result)
+    }
+
+    fn elaborate_infix(&mut self, infix: InfixExpression, span: Span) -> (ExprId, Type) {
+        let (lhs, lhs_type) = self.elaborate_expression(infix.lhs);
+        let (rhs, rhs_type) = self.elaborate_expression(infix.rhs);
+        let trait_id = self.interner.get_operator_trait_method(infix.operator.contents);
+
+        let operator = HirBinaryOp::new(infix.operator, self.file);
+        let expr = HirExpression::Infix(HirInfixExpression {
+            lhs,
+            operator,
+            trait_method_id: trait_id,
+            rhs,
+        });
+
+        let expr_id = self.interner.push_expr(expr);
+        self.interner.push_expr_location(expr_id, span, self.file);
+
+        let typ = match self.infix_operand_type_rules(&lhs_type, &operator, &rhs_type, span) {
+            Ok((typ, use_impl)) => {
+                if use_impl {
+                    // Delay checking the trait constraint until the end of the function.
+                    // Checking it now could bind an unbound type variable to any type
+                    // that implements the trait.
+                    let constraint = TraitConstraint {
+                        typ: lhs_type.clone(),
+                        trait_id: trait_id.trait_id,
+                        trait_generics: Vec::new(),
+                    };
+                    self.trait_constraints.push((constraint, expr_id));
+                    self.type_check_operator_method(expr_id, trait_id, &lhs_type, span);
+                }
+                typ
+            }
+            Err(error) => {
+                self.push_err(error);
+                Type::Error
+            }
+        };
+
+        self.interner.push_expr_type(expr_id, typ.clone());
+        (expr_id, typ)
+    }
+
+    fn elaborate_if(&mut self, if_expr: IfExpression) -> (HirExpression, Type) {
+        let expr_span = if_expr.condition.span;
+        let (condition, cond_type) = self.elaborate_expression(if_expr.condition);
+        let (consequence, mut ret_type) = self.elaborate_expression(if_expr.consequence);
+
+        self.unify(&cond_type, &Type::Bool, || TypeCheckError::TypeMismatch {
+            expected_typ: Type::Bool.to_string(),
+            expr_typ: cond_type.to_string(),
+            expr_span,
+        });
+
+        let alternative = if_expr.alternative.map(|alternative| {
+            let expr_span = alternative.span;
+            let (else_, else_type) = self.elaborate_expression(alternative);
+
+            self.unify(&ret_type, &else_type, || {
+                let err = TypeCheckError::TypeMismatch {
+                    expected_typ: ret_type.to_string(),
+                    expr_typ: else_type.to_string(),
+                    expr_span,
+                };
+
+                let context = if ret_type == Type::Unit {
+                    "Are you missing a semicolon at the end of your 'else' branch?"
+                } else if else_type == Type::Unit {
+                    "Are you missing a semicolon at the end of the first block of this 'if'?"
+                } else {
+                    "Expected the types of both if branches to be equal"
+                };
+
+                err.add_context(context)
+            });
+            else_
+        });
+
+        if alternative.is_none() {
+            ret_type = Type::Unit;
+        }
+
+        let if_expr = HirIfExpression { condition, consequence, alternative };
+        (HirExpression::If(if_expr), ret_type)
+    }
+
+    fn elaborate_tuple(&mut self, tuple: Vec<Expression>) -> (HirExpression, Type) {
+        let mut element_ids = Vec::with_capacity(tuple.len());
+        let mut element_types = Vec::with_capacity(tuple.len());
+
+        for element in tuple {
+            let (id, typ) = self.elaborate_expression(element);
+            element_ids.push(id);
+            element_types.push(typ);
+        }
+
+        (HirExpression::Tuple(element_ids), Type::Tuple(element_types))
+    }
+
+    fn elaborate_lambda(&mut self, lambda: Lambda) -> (HirExpression, Type) {
+        self.push_scope();
+        let scope_index = self.scopes.current_scope_index();
+
+        self.lambda_stack.push(LambdaContext { captures: Vec::new(), scope_index });
+
+        let mut arg_types = Vec::with_capacity(lambda.parameters.len());
+        let parameters = vecmap(lambda.parameters, |(pattern, typ)| {
+            let parameter = DefinitionKind::Local(None);
+            let typ = self.resolve_inferred_type(typ);
+            arg_types.push(typ.clone());
+            (self.elaborate_pattern(pattern, typ.clone(), parameter), typ)
+        });
+
+        let return_type = self.resolve_inferred_type(lambda.return_type);
+        let body_span = lambda.body.span;
+        let (body, body_type) = self.elaborate_expression(lambda.body);
+
+        let lambda_context = self.lambda_stack.pop().unwrap();
+        self.pop_scope();
+
+        self.unify(&body_type, &return_type, || TypeCheckError::TypeMismatch {
+            expected_typ: return_type.to_string(),
+            expr_typ: body_type.to_string(),
+            expr_span: body_span,
+        });
+
+        let captured_vars = vecmap(&lambda_context.captures, |capture| {
+            self.interner.definition_type(capture.ident.id)
+        });
+
+        let env_type =
+            if captured_vars.is_empty() { Type::Unit } else { Type::Tuple(captured_vars) };
+
+        let captures = lambda_context.captures;
+        let expr = HirExpression::Lambda(HirLambda { parameters, return_type, body, captures });
+        (expr, Type::Function(arg_types, Box::new(body_type), Box::new(env_type)))
+    }
+
+    fn elaborate_quote(&mut self, block: BlockExpression) -> (HirExpression, Type) {
+        (HirExpression::Quote(block), Type::Code)
+    }
+
+    fn elaborate_comptime_block(&mut self, _comptime: BlockExpression) -> (HirExpression, Type) {
+        todo!("Elaborate comptime block")
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
new file mode 100644
index 00000000000..9a34fa847f5
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -0,0 +1,159 @@
+#![allow(unused)]
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    rc::Rc,
+};
+
+use crate::graph::CrateId;
+use crate::hir::def_map::CrateDefMap;
+use crate::{
+    ast::{
+        ArrayLiteral, ConstructorExpression, FunctionKind, IfExpression, InfixExpression, Lambda,
+        UnresolvedTraitConstraint, UnresolvedTypeExpression,
+    },
+    hir::{
+        def_collector::dc_crate::CompilationError,
+        resolution::{errors::ResolverError, path_resolver::PathResolver, resolver::LambdaContext},
+        scope::ScopeForest as GenericScopeForest,
+        type_check::TypeCheckError,
+    },
+    hir_def::{
+        expr::{
+            HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
+            HirConstructorExpression, HirIdent, HirIfExpression, HirIndexExpression,
+            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
+            HirMethodReference, HirPrefixExpression,
+        },
+        traits::TraitConstraint,
+    },
+    macros_api::{
+        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirExpression,
+        HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
+        MethodCallExpression, NodeInterner, NoirFunction, PrefixExpression, Statement,
+        StatementKind, StructId,
+    },
+    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, StmtId, TraitId},
+    Shared, StructType, Type, TypeVariable,
+};
+
+mod expressions;
+mod patterns;
+mod scope;
+mod statements;
+mod types;
+
+use fm::FileId;
+use iter_extended::vecmap;
+use noirc_errors::{Location, Span};
+use regex::Regex;
+use rustc_hash::FxHashSet as HashSet;
+
+/// ResolverMetas are tagged onto each definition to track how many times they are used
+#[derive(Debug, PartialEq, Eq)]
+struct ResolverMeta {
+    num_times_used: usize,
+    ident: HirIdent,
+    warn_if_unused: bool,
+}
+
+type ScopeForest = GenericScopeForest<String, ResolverMeta>;
+
+struct Elaborator {
+    scopes: ScopeForest,
+
+    errors: Vec<CompilationError>,
+
+    interner: NodeInterner,
+    file: FileId,
+
+    in_unconstrained_fn: bool,
+    nested_loops: usize,
+
+    /// True if the current module is a contract.
+    /// This is usually determined by self.path_resolver.module_id(), but it can
+    /// be overridden for impls. Impls are an odd case since the methods within resolve
+    /// as if they're in the parent module, but should be placed in a child module.
+    /// Since they should be within a child module, in_contract is manually set to false
+    /// for these so we can still resolve them in the parent module without them being in a contract.
+    in_contract: bool,
+
+    /// Contains a mapping of the current struct or functions's generics to
+    /// unique type variables if we're resolving a struct. Empty otherwise.
+    /// This is a Vec rather than a map to preserve the order a functions generics
+    /// were declared in.
+    generics: Vec<(Rc<String>, TypeVariable, Span)>,
+
+    /// When resolving lambda expressions, we need to keep track of the variables
+    /// that are captured. We do this in order to create the hidden environment
+    /// parameter for the lambda function.
+    lambda_stack: Vec<LambdaContext>,
+
+    /// Set to the current type if we're resolving an impl
+    self_type: Option<Type>,
+
+    /// The current dependency item we're resolving.
+    /// Used to link items to their dependencies in the dependency graph
+    current_item: Option<DependencyId>,
+
+    trait_id: Option<TraitId>,
+
+    path_resolver: Rc<dyn PathResolver>,
+    def_maps: BTreeMap<CrateId, CrateDefMap>,
+
+    /// In-resolution names
+    ///
+    /// This needs to be a set because we can have multiple in-resolution
+    /// names when resolving structs that are declared in reverse order of their
+    /// dependencies, such as in the following case:
+    ///
+    /// ```
+    /// struct Wrapper {
+    ///     value: Wrapped
+    /// }
+    /// struct Wrapped {
+    /// }
+    /// ```
+    resolving_ids: BTreeSet<StructId>,
+
+    trait_bounds: Vec<UnresolvedTraitConstraint>,
+
+    current_function: Option<FuncId>,
+
+    /// All type variables created in the current function.
+    /// This map is used to default any integer type variables at the end of
+    /// a function (before checking trait constraints) if a type wasn't already chosen.
+    type_variables: Vec<Type>,
+
+    /// Trait constraints are collected during type checking until they are
+    /// verified at the end of a function. This is because constraints arise
+    /// on each variable, but it is only until function calls when the types
+    /// needed for the trait constraint may become known.
+    trait_constraints: Vec<(TraitConstraint, ExprId)>,
+}
+
+impl Elaborator {
+    fn elaborate_function(&mut self, function: NoirFunction, _id: FuncId) {
+        // This is a stub until the elaborator is connected to dc_crate
+        match function.kind {
+            FunctionKind::LowLevel => todo!(),
+            FunctionKind::Builtin => todo!(),
+            FunctionKind::Oracle => todo!(),
+            FunctionKind::Recursive => todo!(),
+            FunctionKind::Normal => {
+                let _body = self.elaborate_block(function.def.body);
+            }
+        }
+    }
+
+    fn push_scope(&mut self) {
+        // stub
+    }
+
+    fn pop_scope(&mut self) {
+        // stub
+    }
+
+    fn push_err(&mut self, error: impl Into<CompilationError>) {
+        self.errors.push(error.into());
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
new file mode 100644
index 00000000000..b51115417e7
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -0,0 +1,463 @@
+use iter_extended::vecmap;
+use noirc_errors::{Location, Span};
+use rustc_hash::FxHashSet as HashSet;
+
+use crate::{
+    ast::ERROR_IDENT,
+    hir::{
+        resolution::errors::ResolverError,
+        type_check::{Source, TypeCheckError},
+    },
+    hir_def::{
+        expr::{HirIdent, ImplKind},
+        stmt::HirPattern,
+    },
+    macros_api::{HirExpression, Ident, Path, Pattern},
+    node_interner::{DefinitionId, DefinitionKind, ExprId, TraitImplKind},
+    Shared, StructType, Type, TypeBindings,
+};
+
+use super::{Elaborator, ResolverMeta};
+
+impl Elaborator {
+    pub(super) fn elaborate_pattern(
+        &mut self,
+        pattern: Pattern,
+        expected_type: Type,
+        definition_kind: DefinitionKind,
+    ) -> HirPattern {
+        self.elaborate_pattern_mut(pattern, expected_type, definition_kind, None)
+    }
+
+    fn elaborate_pattern_mut(
+        &mut self,
+        pattern: Pattern,
+        expected_type: Type,
+        definition: DefinitionKind,
+        mutable: Option<Span>,
+    ) -> HirPattern {
+        match pattern {
+            Pattern::Identifier(name) => {
+                // If this definition is mutable, do not store the rhs because it will
+                // not always refer to the correct value of the variable
+                let definition = match (mutable, definition) {
+                    (Some(_), DefinitionKind::Local(_)) => DefinitionKind::Local(None),
+                    (_, other) => other,
+                };
+                let ident = self.add_variable_decl(name, mutable.is_some(), true, definition);
+                self.interner.push_definition_type(ident.id, expected_type);
+                HirPattern::Identifier(ident)
+            }
+            Pattern::Mutable(pattern, span, _) => {
+                if let Some(first_mut) = mutable {
+                    self.push_err(ResolverError::UnnecessaryMut { first_mut, second_mut: span });
+                }
+
+                let pattern =
+                    self.elaborate_pattern_mut(*pattern, expected_type, definition, Some(span));
+                let location = Location::new(span, self.file);
+                HirPattern::Mutable(Box::new(pattern), location)
+            }
+            Pattern::Tuple(fields, span) => {
+                let field_types = match expected_type {
+                    Type::Tuple(fields) => fields,
+                    Type::Error => Vec::new(),
+                    expected_type => {
+                        let tuple =
+                            Type::Tuple(vecmap(&fields, |_| self.interner.next_type_variable()));
+
+                        self.push_err(TypeCheckError::TypeMismatchWithSource {
+                            expected: expected_type,
+                            actual: tuple,
+                            span,
+                            source: Source::Assignment,
+                        });
+                        Vec::new()
+                    }
+                };
+
+                let fields = vecmap(fields.into_iter().enumerate(), |(i, field)| {
+                    let field_type = field_types.get(i).cloned().unwrap_or(Type::Error);
+                    self.elaborate_pattern_mut(field, field_type, definition.clone(), mutable)
+                });
+                let location = Location::new(span, self.file);
+                HirPattern::Tuple(fields, location)
+            }
+            Pattern::Struct(name, fields, span) => self.elaborate_struct_pattern(
+                name,
+                fields,
+                span,
+                expected_type,
+                definition,
+                mutable,
+            ),
+        }
+    }
+
+    fn elaborate_struct_pattern(
+        &mut self,
+        name: Path,
+        fields: Vec<(Ident, Pattern)>,
+        span: Span,
+        expected_type: Type,
+        definition: DefinitionKind,
+        mutable: Option<Span>,
+    ) -> HirPattern {
+        let error_identifier = |this: &mut Self| {
+            // Must create a name here to return a HirPattern::Identifier. Allowing
+            // shadowing here lets us avoid further errors if we define ERROR_IDENT
+            // multiple times.
+            let name = ERROR_IDENT.into();
+            let identifier = this.add_variable_decl(name, false, true, definition.clone());
+            HirPattern::Identifier(identifier)
+        };
+
+        let (struct_type, generics) = match self.lookup_type_or_error(name) {
+            Some(Type::Struct(struct_type, generics)) => (struct_type, generics),
+            None => return error_identifier(self),
+            Some(typ) => {
+                self.push_err(ResolverError::NonStructUsedInConstructor { typ, span });
+                return error_identifier(self);
+            }
+        };
+
+        let actual_type = Type::Struct(struct_type.clone(), generics);
+        let location = Location::new(span, self.file);
+
+        self.unify(&actual_type, &expected_type, || TypeCheckError::TypeMismatchWithSource {
+            expected: expected_type.clone(),
+            actual: actual_type.clone(),
+            span: location.span,
+            source: Source::Assignment,
+        });
+
+        let typ = struct_type.clone();
+        let fields = self.resolve_constructor_pattern_fields(
+            typ,
+            fields,
+            span,
+            expected_type.clone(),
+            definition,
+            mutable,
+        );
+
+        HirPattern::Struct(expected_type, fields, location)
+    }
+
+    /// Resolve all the fields of a struct constructor expression.
+    /// Ensures all fields are present, none are repeated, and all
+    /// are part of the struct.
+    fn resolve_constructor_pattern_fields(
+        &mut self,
+        struct_type: Shared<StructType>,
+        fields: Vec<(Ident, Pattern)>,
+        span: Span,
+        expected_type: Type,
+        definition: DefinitionKind,
+        mutable: Option<Span>,
+    ) -> Vec<(Ident, HirPattern)> {
+        let mut ret = Vec::with_capacity(fields.len());
+        let mut seen_fields = HashSet::default();
+        let mut unseen_fields = struct_type.borrow().field_names();
+
+        for (field, pattern) in fields {
+            let field_type = expected_type.get_field_type(&field.0.contents).unwrap_or(Type::Error);
+            let resolved =
+                self.elaborate_pattern_mut(pattern, field_type, definition.clone(), mutable);
+
+            if unseen_fields.contains(&field) {
+                unseen_fields.remove(&field);
+                seen_fields.insert(field.clone());
+            } else if seen_fields.contains(&field) {
+                // duplicate field
+                self.push_err(ResolverError::DuplicateField { field: field.clone() });
+            } else {
+                // field not required by struct
+                self.push_err(ResolverError::NoSuchField {
+                    field: field.clone(),
+                    struct_definition: struct_type.borrow().name.clone(),
+                });
+            }
+
+            ret.push((field, resolved));
+        }
+
+        if !unseen_fields.is_empty() {
+            self.push_err(ResolverError::MissingFields {
+                span,
+                missing_fields: unseen_fields.into_iter().map(|field| field.to_string()).collect(),
+                struct_definition: struct_type.borrow().name.clone(),
+            });
+        }
+
+        ret
+    }
+
+    pub(super) fn add_variable_decl(
+        &mut self,
+        name: Ident,
+        mutable: bool,
+        allow_shadowing: bool,
+        definition: DefinitionKind,
+    ) -> HirIdent {
+        self.add_variable_decl_inner(name, mutable, allow_shadowing, true, definition)
+    }
+
+    fn add_variable_decl_inner(
+        &mut self,
+        name: Ident,
+        mutable: bool,
+        allow_shadowing: bool,
+        warn_if_unused: bool,
+        definition: DefinitionKind,
+    ) -> HirIdent {
+        if definition.is_global() {
+            return self.add_global_variable_decl(name, definition);
+        }
+
+        let location = Location::new(name.span(), self.file);
+        let id =
+            self.interner.push_definition(name.0.contents.clone(), mutable, definition, location);
+        let ident = HirIdent::non_trait_method(id, location);
+        let resolver_meta =
+            ResolverMeta { num_times_used: 0, ident: ident.clone(), warn_if_unused };
+
+        let scope = self.scopes.get_mut_scope();
+        let old_value = scope.add_key_value(name.0.contents.clone(), resolver_meta);
+
+        if !allow_shadowing {
+            if let Some(old_value) = old_value {
+                self.push_err(ResolverError::DuplicateDefinition {
+                    name: name.0.contents,
+                    first_span: old_value.ident.location.span,
+                    second_span: location.span,
+                });
+            }
+        }
+
+        ident
+    }
+
+    fn add_global_variable_decl(&mut self, name: Ident, definition: DefinitionKind) -> HirIdent {
+        let scope = self.scopes.get_mut_scope();
+
+        // This check is necessary to maintain the same definition ids in the interner. Currently, each function uses a new resolver that has its own ScopeForest and thus global scope.
+        // We must first check whether an existing definition ID has been inserted as otherwise there will be multiple definitions for the same global statement.
+        // This leads to an error in evaluation where the wrong definition ID is selected when evaluating a statement using the global. The check below prevents this error.
+        let mut global_id = None;
+        let global = self.interner.get_all_globals();
+        for global_info in global {
+            if global_info.ident == name
+                && global_info.local_id == self.path_resolver.local_module_id()
+            {
+                global_id = Some(global_info.id);
+            }
+        }
+
+        let (ident, resolver_meta) = if let Some(id) = global_id {
+            let global = self.interner.get_global(id);
+            let hir_ident = HirIdent::non_trait_method(global.definition_id, global.location);
+            let ident = hir_ident.clone();
+            let resolver_meta = ResolverMeta { num_times_used: 0, ident, warn_if_unused: true };
+            (hir_ident, resolver_meta)
+        } else {
+            let location = Location::new(name.span(), self.file);
+            let id =
+                self.interner.push_definition(name.0.contents.clone(), false, definition, location);
+            let ident = HirIdent::non_trait_method(id, location);
+            let resolver_meta =
+                ResolverMeta { num_times_used: 0, ident: ident.clone(), warn_if_unused: true };
+            (ident, resolver_meta)
+        };
+
+        let old_global_value = scope.add_key_value(name.0.contents.clone(), resolver_meta);
+        if let Some(old_global_value) = old_global_value {
+            self.push_err(ResolverError::DuplicateDefinition {
+                name: name.0.contents.clone(),
+                first_span: old_global_value.ident.location.span,
+                second_span: name.span(),
+            });
+        }
+        ident
+    }
+
+    // Checks for a variable having been declared before.
+    // (Variable declaration and definition cannot be separate in Noir.)
+    // Once the variable has been found, intern and link `name` to this definition,
+    // returning (the ident, the IdentId of `name`)
+    //
+    // If a variable is not found, then an error is logged and a dummy id
+    // is returned, for better error reporting UX
+    pub(super) fn find_variable_or_default(&mut self, name: &Ident) -> (HirIdent, usize) {
+        self.use_variable(name).unwrap_or_else(|error| {
+            self.push_err(error);
+            let id = DefinitionId::dummy_id();
+            let location = Location::new(name.span(), self.file);
+            (HirIdent::non_trait_method(id, location), 0)
+        })
+    }
+
+    /// Lookup and use the specified variable.
+    /// This will increment its use counter by one and return the variable if found.
+    /// If the variable is not found, an error is returned.
+    pub(super) fn use_variable(
+        &mut self,
+        name: &Ident,
+    ) -> Result<(HirIdent, usize), ResolverError> {
+        // Find the definition for this Ident
+        let scope_tree = self.scopes.current_scope_tree();
+        let variable = scope_tree.find(&name.0.contents);
+
+        let location = Location::new(name.span(), self.file);
+        if let Some((variable_found, scope)) = variable {
+            variable_found.num_times_used += 1;
+            let id = variable_found.ident.id;
+            Ok((HirIdent::non_trait_method(id, location), scope))
+        } else {
+            Err(ResolverError::VariableNotDeclared {
+                name: name.0.contents.clone(),
+                span: name.0.span(),
+            })
+        }
+    }
+
+    pub(super) fn elaborate_variable(&mut self, variable: Path) -> (ExprId, Type) {
+        let span = variable.span;
+        let expr = self.resolve_variable(variable);
+        let id = self.interner.push_expr(HirExpression::Ident(expr.clone()));
+        self.interner.push_expr_location(id, span, self.file);
+        let typ = self.type_check_variable(expr, id);
+        self.interner.push_expr_type(id, typ.clone());
+        (id, typ)
+    }
+
+    fn resolve_variable(&mut self, path: Path) -> HirIdent {
+        if let Some((method, constraint, assumed)) = self.resolve_trait_generic_path(&path) {
+            HirIdent {
+                location: Location::new(path.span, self.file),
+                id: self.interner.trait_method_id(method),
+                impl_kind: ImplKind::TraitMethod(method, constraint, assumed),
+            }
+        } else {
+            // If the Path is being used as an Expression, then it is referring to a global from a separate module
+            // Otherwise, then it is referring to an Identifier
+            // This lookup allows support of such statements: let x = foo::bar::SOME_GLOBAL + 10;
+            // If the expression is a singular indent, we search the resolver's current scope as normal.
+            let (hir_ident, var_scope_index) = self.get_ident_from_path(path);
+
+            if hir_ident.id != DefinitionId::dummy_id() {
+                match self.interner.definition(hir_ident.id).kind {
+                    DefinitionKind::Function(id) => {
+                        if let Some(current_item) = self.current_item {
+                            self.interner.add_function_dependency(current_item, id);
+                        }
+                    }
+                    DefinitionKind::Global(global_id) => {
+                        if let Some(current_item) = self.current_item {
+                            self.interner.add_global_dependency(current_item, global_id);
+                        }
+                    }
+                    DefinitionKind::GenericType(_) => {
+                        // Initialize numeric generics to a polymorphic integer type in case
+                        // they're used in expressions. We must do this here since type_check_variable
+                        // does not check definition kinds and otherwise expects parameters to
+                        // already be typed.
+                        if self.interner.definition_type(hir_ident.id) == Type::Error {
+                            let typ = Type::polymorphic_integer_or_field(&mut self.interner);
+                            self.interner.push_definition_type(hir_ident.id, typ);
+                        }
+                    }
+                    DefinitionKind::Local(_) => {
+                        // only local variables can be captured by closures.
+                        self.resolve_local_variable(hir_ident.clone(), var_scope_index);
+                    }
+                }
+            }
+
+            hir_ident
+        }
+    }
+
+    pub(super) fn type_check_variable(&mut self, ident: HirIdent, expr_id: ExprId) -> Type {
+        let mut bindings = TypeBindings::new();
+
+        // Add type bindings from any constraints that were used.
+        // We need to do this first since otherwise instantiating the type below
+        // will replace each trait generic with a fresh type variable, rather than
+        // the type used in the trait constraint (if it exists). See #4088.
+        if let ImplKind::TraitMethod(_, constraint, _) = &ident.impl_kind {
+            let the_trait = self.interner.get_trait(constraint.trait_id);
+            assert_eq!(the_trait.generics.len(), constraint.trait_generics.len());
+
+            for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics) {
+                // Avoid binding t = t
+                if !arg.occurs(param.id()) {
+                    bindings.insert(param.id(), (param.clone(), arg.clone()));
+                }
+            }
+        }
+
+        // An identifiers type may be forall-quantified in the case of generic functions.
+        // E.g. `fn foo<T>(t: T, field: Field) -> T` has type `forall T. fn(T, Field) -> T`.
+        // We must instantiate identifiers at every call site to replace this T with a new type
+        // variable to handle generic functions.
+        let t = self.interner.id_type_substitute_trait_as_type(ident.id);
+
+        // This instantiates a trait's generics as well which need to be set
+        // when the constraint below is later solved for when the function is
+        // finished. How to link the two?
+        let (typ, bindings) = t.instantiate_with_bindings(bindings, &self.interner);
+
+        // Push any trait constraints required by this definition to the context
+        // to be checked later when the type of this variable is further constrained.
+        if let Some(definition) = self.interner.try_definition(ident.id) {
+            if let DefinitionKind::Function(function) = definition.kind {
+                let function = self.interner.function_meta(&function);
+
+                for mut constraint in function.trait_constraints.clone() {
+                    constraint.apply_bindings(&bindings);
+                    self.trait_constraints.push((constraint, expr_id));
+                }
+            }
+        }
+
+        if let ImplKind::TraitMethod(_, mut constraint, assumed) = ident.impl_kind {
+            constraint.apply_bindings(&bindings);
+            if assumed {
+                let trait_impl = TraitImplKind::Assumed {
+                    object_type: constraint.typ,
+                    trait_generics: constraint.trait_generics,
+                };
+                self.interner.select_impl_for_expression(expr_id, trait_impl);
+            } else {
+                // Currently only one impl can be selected per expr_id, so this
+                // constraint needs to be pushed after any other constraints so
+                // that monomorphization can resolve this trait method to the correct impl.
+                self.trait_constraints.push((constraint, expr_id));
+            }
+        }
+
+        self.interner.store_instantiation_bindings(expr_id, bindings);
+        typ
+    }
+
+    fn get_ident_from_path(&mut self, path: Path) -> (HirIdent, usize) {
+        let location = Location::new(path.span(), self.file);
+
+        let error = match path.as_ident().map(|ident| self.use_variable(ident)) {
+            Some(Ok(found)) => return found,
+            // Try to look it up as a global, but still issue the first error if we fail
+            Some(Err(error)) => match self.lookup_global(path) {
+                Ok(id) => return (HirIdent::non_trait_method(id, location), 0),
+                Err(_) => error,
+            },
+            None => match self.lookup_global(path) {
+                Ok(id) => return (HirIdent::non_trait_method(id, location), 0),
+                Err(error) => error,
+            },
+        };
+        self.push_err(error);
+        let id = DefinitionId::dummy_id();
+        (HirIdent::non_trait_method(id, location), 0)
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/scope.rs b/compiler/noirc_frontend/src/elaborator/scope.rs
new file mode 100644
index 00000000000..e8baba6bd89
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/scope.rs
@@ -0,0 +1,100 @@
+use rustc_hash::FxHashMap as HashMap;
+
+use crate::hir::comptime::Value;
+use crate::{
+    hir::{
+        def_map::{ModuleDefId, TryFromModuleDefId},
+        resolution::errors::ResolverError,
+    },
+    hir_def::{
+        expr::{HirCapturedVar, HirIdent},
+        traits::Trait,
+    },
+    macros_api::{Path, StructId},
+    node_interner::{DefinitionId, TraitId, TypeAliasId},
+    Shared, StructType,
+};
+
+use super::Elaborator;
+
+impl Elaborator {
+    pub(super) fn lookup<T: TryFromModuleDefId>(&mut self, path: Path) -> Result<T, ResolverError> {
+        let span = path.span();
+        let id = self.resolve_path(path)?;
+        T::try_from(id).ok_or_else(|| ResolverError::Expected {
+            expected: T::description(),
+            got: id.as_str().to_owned(),
+            span,
+        })
+    }
+
+    pub(super) fn resolve_path(&mut self, path: Path) -> Result<ModuleDefId, ResolverError> {
+        let path_resolution = self.path_resolver.resolve(&self.def_maps, path)?;
+
+        if let Some(error) = path_resolution.error {
+            self.push_err(error);
+        }
+
+        Ok(path_resolution.module_def_id)
+    }
+
+    pub(super) fn get_struct(&self, type_id: StructId) -> Shared<StructType> {
+        self.interner.get_struct(type_id)
+    }
+
+    pub(super) fn get_trait_mut(&mut self, trait_id: TraitId) -> &mut Trait {
+        self.interner.get_trait_mut(trait_id)
+    }
+
+    pub(super) fn resolve_local_variable(&mut self, hir_ident: HirIdent, var_scope_index: usize) {
+        let mut transitive_capture_index: Option<usize> = None;
+
+        for lambda_index in 0..self.lambda_stack.len() {
+            if self.lambda_stack[lambda_index].scope_index > var_scope_index {
+                // Beware: the same variable may be captured multiple times, so we check
+                // for its presence before adding the capture below.
+                let position = self.lambda_stack[lambda_index]
+                    .captures
+                    .iter()
+                    .position(|capture| capture.ident.id == hir_ident.id);
+
+                if position.is_none() {
+                    self.lambda_stack[lambda_index].captures.push(HirCapturedVar {
+                        ident: hir_ident.clone(),
+                        transitive_capture_index,
+                    });
+                }
+
+                if lambda_index + 1 < self.lambda_stack.len() {
+                    // There is more than one closure between the current scope and
+                    // the scope of the variable, so this is a propagated capture.
+                    // We need to track the transitive capture index as we go up in
+                    // the closure stack.
+                    transitive_capture_index = Some(position.unwrap_or(
+                        // If this was a fresh capture, we added it to the end of
+                        // the captures vector:
+                        self.lambda_stack[lambda_index].captures.len() - 1,
+                    ));
+                }
+            }
+        }
+    }
+
+    pub(super) fn lookup_global(&mut self, path: Path) -> Result<DefinitionId, ResolverError> {
+        let span = path.span();
+        let id = self.resolve_path(path)?;
+
+        if let Some(function) = TryFromModuleDefId::try_from(id) {
+            return Ok(self.interner.function_definition_id(function));
+        }
+
+        if let Some(global) = TryFromModuleDefId::try_from(id) {
+            let global = self.interner.get_global(global);
+            return Ok(global.definition_id);
+        }
+
+        let expected = "global variable".into();
+        let got = "local variable".into();
+        Err(ResolverError::Expected { span, expected, got })
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
new file mode 100644
index 00000000000..6ad6d66b2d4
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -0,0 +1,409 @@
+use noirc_errors::{Location, Span};
+
+use crate::{
+    ast::{AssignStatement, ConstrainStatement, LValue},
+    hir::{
+        resolution::errors::ResolverError,
+        type_check::{Source, TypeCheckError},
+    },
+    hir_def::{
+        expr::HirIdent,
+        stmt::{
+            HirAssignStatement, HirConstrainStatement, HirForStatement, HirLValue, HirLetStatement,
+        },
+    },
+    macros_api::{
+        ForLoopStatement, ForRange, HirStatement, LetStatement, Statement, StatementKind,
+    },
+    node_interner::{DefinitionId, DefinitionKind, StmtId},
+    Type,
+};
+
+use super::Elaborator;
+
+impl Elaborator {
+    fn elaborate_statement_value(&mut self, statement: Statement) -> (HirStatement, Type) {
+        match statement.kind {
+            StatementKind::Let(let_stmt) => self.elaborate_let(let_stmt),
+            StatementKind::Constrain(constrain) => self.elaborate_constrain(constrain),
+            StatementKind::Assign(assign) => self.elaborate_assign(assign),
+            StatementKind::For(for_stmt) => self.elaborate_for(for_stmt),
+            StatementKind::Break => self.elaborate_jump(true, statement.span),
+            StatementKind::Continue => self.elaborate_jump(false, statement.span),
+            StatementKind::Comptime(statement) => self.elaborate_comptime(*statement),
+            StatementKind::Expression(expr) => {
+                let (expr, typ) = self.elaborate_expression(expr);
+                (HirStatement::Expression(expr), typ)
+            }
+            StatementKind::Semi(expr) => {
+                let (expr, _typ) = self.elaborate_expression(expr);
+                (HirStatement::Semi(expr), Type::Unit)
+            }
+            StatementKind::Error => (HirStatement::Error, Type::Error),
+        }
+    }
+
+    pub(super) fn elaborate_statement(&mut self, statement: Statement) -> (StmtId, Type) {
+        let span = statement.span;
+        let (hir_statement, typ) = self.elaborate_statement_value(statement);
+        let id = self.interner.push_stmt(hir_statement);
+        self.interner.push_stmt_location(id, span, self.file);
+        (id, typ)
+    }
+
+    pub(super) fn elaborate_let(&mut self, let_stmt: LetStatement) -> (HirStatement, Type) {
+        let expr_span = let_stmt.expression.span;
+        let (expression, expr_type) = self.elaborate_expression(let_stmt.expression);
+        let definition = DefinitionKind::Local(Some(expression));
+        let annotated_type = self.resolve_type(let_stmt.r#type);
+
+        // First check if the LHS is unspecified
+        // If so, then we give it the same type as the expression
+        let r#type = if annotated_type != Type::Error {
+            // Now check if LHS is the same type as the RHS
+            // Importantly, we do not coerce any types implicitly
+            self.unify_with_coercions(&expr_type, &annotated_type, expression, || {
+                TypeCheckError::TypeMismatch {
+                    expected_typ: annotated_type.to_string(),
+                    expr_typ: expr_type.to_string(),
+                    expr_span,
+                }
+            });
+            if annotated_type.is_unsigned() {
+                self.lint_overflowing_uint(&expression, &annotated_type);
+            }
+            annotated_type
+        } else {
+            expr_type
+        };
+
+        let let_ = HirLetStatement {
+            pattern: self.elaborate_pattern(let_stmt.pattern, r#type.clone(), definition),
+            r#type,
+            expression,
+            attributes: let_stmt.attributes,
+            comptime: let_stmt.comptime,
+        };
+        (HirStatement::Let(let_), Type::Unit)
+    }
+
+    pub(super) fn elaborate_constrain(&mut self, stmt: ConstrainStatement) -> (HirStatement, Type) {
+        let expr_span = stmt.0.span;
+        let (expr_id, expr_type) = self.elaborate_expression(stmt.0);
+
+        // Must type check the assertion message expression so that we instantiate bindings
+        let msg = stmt.1.map(|assert_msg_expr| self.elaborate_expression(assert_msg_expr).0);
+
+        self.unify(&expr_type, &Type::Bool, || TypeCheckError::TypeMismatch {
+            expr_typ: expr_type.to_string(),
+            expected_typ: Type::Bool.to_string(),
+            expr_span,
+        });
+
+        (HirStatement::Constrain(HirConstrainStatement(expr_id, self.file, msg)), Type::Unit)
+    }
+
+    pub(super) fn elaborate_assign(&mut self, assign: AssignStatement) -> (HirStatement, Type) {
+        let span = assign.expression.span;
+        let (expression, expr_type) = self.elaborate_expression(assign.expression);
+        let (lvalue, lvalue_type, mutable) = self.elaborate_lvalue(assign.lvalue, span);
+
+        if !mutable {
+            let (name, span) = self.get_lvalue_name_and_span(&lvalue);
+            self.push_err(TypeCheckError::VariableMustBeMutable { name, span });
+        }
+
+        self.unify_with_coercions(&expr_type, &lvalue_type, expression, || {
+            TypeCheckError::TypeMismatchWithSource {
+                actual: expr_type.clone(),
+                expected: lvalue_type.clone(),
+                span,
+                source: Source::Assignment,
+            }
+        });
+
+        let stmt = HirAssignStatement { lvalue, expression };
+        (HirStatement::Assign(stmt), Type::Unit)
+    }
+
+    pub(super) fn elaborate_for(&mut self, for_loop: ForLoopStatement) -> (HirStatement, Type) {
+        let (start, end) = match for_loop.range {
+            ForRange::Range(start, end) => (start, end),
+            ForRange::Array(_) => {
+                let for_stmt =
+                    for_loop.range.into_for(for_loop.identifier, for_loop.block, for_loop.span);
+
+                return self.elaborate_statement_value(for_stmt);
+            }
+        };
+
+        let start_span = start.span;
+        let end_span = end.span;
+
+        let (start_range, start_range_type) = self.elaborate_expression(start);
+        let (end_range, end_range_type) = self.elaborate_expression(end);
+        let (identifier, block) = (for_loop.identifier, for_loop.block);
+
+        self.nested_loops += 1;
+        self.push_scope();
+
+        // TODO: For loop variables are currently mutable by default since we haven't
+        //       yet implemented syntax for them to be optionally mutable.
+        let kind = DefinitionKind::Local(None);
+        let identifier = self.add_variable_decl(identifier, false, true, kind);
+
+        // Check that start range and end range have the same types
+        let range_span = start_span.merge(end_span);
+        self.unify(&start_range_type, &end_range_type, || TypeCheckError::TypeMismatch {
+            expected_typ: start_range_type.to_string(),
+            expr_typ: end_range_type.to_string(),
+            expr_span: range_span,
+        });
+
+        let expected_type = self.polymorphic_integer();
+
+        self.unify(&start_range_type, &expected_type, || TypeCheckError::TypeCannotBeUsed {
+            typ: start_range_type.clone(),
+            place: "for loop",
+            span: range_span,
+        });
+
+        self.interner.push_definition_type(identifier.id, start_range_type);
+
+        let (block, _block_type) = self.elaborate_expression(block);
+
+        self.pop_scope();
+        self.nested_loops -= 1;
+
+        let statement =
+            HirStatement::For(HirForStatement { start_range, end_range, block, identifier });
+
+        (statement, Type::Unit)
+    }
+
+    fn elaborate_jump(&mut self, is_break: bool, span: noirc_errors::Span) -> (HirStatement, Type) {
+        if !self.in_unconstrained_fn {
+            self.push_err(ResolverError::JumpInConstrainedFn { is_break, span });
+        }
+        if self.nested_loops == 0 {
+            self.push_err(ResolverError::JumpOutsideLoop { is_break, span });
+        }
+
+        let expr = if is_break { HirStatement::Break } else { HirStatement::Continue };
+        (expr, self.interner.next_type_variable())
+    }
+
+    fn get_lvalue_name_and_span(&self, lvalue: &HirLValue) -> (String, Span) {
+        match lvalue {
+            HirLValue::Ident(name, _) => {
+                let span = name.location.span;
+
+                if let Some(definition) = self.interner.try_definition(name.id) {
+                    (definition.name.clone(), span)
+                } else {
+                    ("(undeclared variable)".into(), span)
+                }
+            }
+            HirLValue::MemberAccess { object, .. } => self.get_lvalue_name_and_span(object),
+            HirLValue::Index { array, .. } => self.get_lvalue_name_and_span(array),
+            HirLValue::Dereference { lvalue, .. } => self.get_lvalue_name_and_span(lvalue),
+        }
+    }
+
+    fn elaborate_lvalue(&mut self, lvalue: LValue, assign_span: Span) -> (HirLValue, Type, bool) {
+        match lvalue {
+            LValue::Ident(ident) => {
+                let mut mutable = true;
+                let (ident, scope_index) = self.find_variable_or_default(&ident);
+                self.resolve_local_variable(ident.clone(), scope_index);
+
+                let typ = if ident.id == DefinitionId::dummy_id() {
+                    Type::Error
+                } else {
+                    if let Some(definition) = self.interner.try_definition(ident.id) {
+                        mutable = definition.mutable;
+                    }
+
+                    let typ = self.interner.definition_type(ident.id).instantiate(&self.interner).0;
+                    typ.follow_bindings()
+                };
+
+                (HirLValue::Ident(ident.clone(), typ.clone()), typ, mutable)
+            }
+            LValue::MemberAccess { object, field_name, span } => {
+                let (object, lhs_type, mut mutable) = self.elaborate_lvalue(*object, assign_span);
+                let mut object = Box::new(object);
+                let field_name = field_name.clone();
+
+                let object_ref = &mut object;
+                let mutable_ref = &mut mutable;
+                let location = Location::new(span, self.file);
+
+                let dereference_lhs = move |_: &mut Self, _, element_type| {
+                    // We must create a temporary value first to move out of object_ref before
+                    // we eventually reassign to it.
+                    let id = DefinitionId::dummy_id();
+                    let ident = HirIdent::non_trait_method(id, location);
+                    let tmp_value = HirLValue::Ident(ident, Type::Error);
+
+                    let lvalue = std::mem::replace(object_ref, Box::new(tmp_value));
+                    *object_ref =
+                        Box::new(HirLValue::Dereference { lvalue, element_type, location });
+                    *mutable_ref = true;
+                };
+
+                let name = &field_name.0.contents;
+                let (object_type, field_index) = self
+                    .check_field_access(&lhs_type, name, field_name.span(), Some(dereference_lhs))
+                    .unwrap_or((Type::Error, 0));
+
+                let field_index = Some(field_index);
+                let typ = object_type.clone();
+                let lvalue =
+                    HirLValue::MemberAccess { object, field_name, field_index, typ, location };
+                (lvalue, object_type, mutable)
+            }
+            LValue::Index { array, index, span } => {
+                let expr_span = index.span;
+                let (index, index_type) = self.elaborate_expression(index);
+                let location = Location::new(span, self.file);
+
+                let expected = self.polymorphic_integer_or_field();
+                self.unify(&index_type, &expected, || TypeCheckError::TypeMismatch {
+                    expected_typ: "an integer".to_owned(),
+                    expr_typ: index_type.to_string(),
+                    expr_span,
+                });
+
+                let (mut lvalue, mut lvalue_type, mut mutable) =
+                    self.elaborate_lvalue(*array, assign_span);
+
+                // Before we check that the lvalue is an array, try to dereference it as many times
+                // as needed to unwrap any &mut wrappers.
+                while let Type::MutableReference(element) = lvalue_type.follow_bindings() {
+                    let element_type = element.as_ref().clone();
+                    lvalue =
+                        HirLValue::Dereference { lvalue: Box::new(lvalue), element_type, location };
+                    lvalue_type = *element;
+                    // We know this value to be mutable now since we found an `&mut`
+                    mutable = true;
+                }
+
+                let typ = match lvalue_type.follow_bindings() {
+                    Type::Array(_, elem_type) => *elem_type,
+                    Type::Slice(elem_type) => *elem_type,
+                    Type::Error => Type::Error,
+                    Type::String(_) => {
+                        let (_lvalue_name, lvalue_span) = self.get_lvalue_name_and_span(&lvalue);
+                        self.push_err(TypeCheckError::StringIndexAssign { span: lvalue_span });
+                        Type::Error
+                    }
+                    other => {
+                        // TODO: Need a better span here
+                        self.push_err(TypeCheckError::TypeMismatch {
+                            expected_typ: "array".to_string(),
+                            expr_typ: other.to_string(),
+                            expr_span: assign_span,
+                        });
+                        Type::Error
+                    }
+                };
+
+                let array = Box::new(lvalue);
+                let array_type = typ.clone();
+                (HirLValue::Index { array, index, typ, location }, array_type, mutable)
+            }
+            LValue::Dereference(lvalue, span) => {
+                let (lvalue, reference_type, _) = self.elaborate_lvalue(*lvalue, assign_span);
+                let lvalue = Box::new(lvalue);
+                let location = Location::new(span, self.file);
+
+                let element_type = Type::type_variable(self.interner.next_type_variable_id());
+                let expected_type = Type::MutableReference(Box::new(element_type.clone()));
+
+                self.unify(&reference_type, &expected_type, || TypeCheckError::TypeMismatch {
+                    expected_typ: expected_type.to_string(),
+                    expr_typ: reference_type.to_string(),
+                    expr_span: assign_span,
+                });
+
+                // Dereferences are always mutable since we already type checked against a &mut T
+                let typ = element_type.clone();
+                let lvalue = HirLValue::Dereference { lvalue, element_type, location };
+                (lvalue, typ, true)
+            }
+        }
+    }
+
+    /// Type checks a field access, adding dereference operators as necessary
+    pub(super) fn check_field_access(
+        &mut self,
+        lhs_type: &Type,
+        field_name: &str,
+        span: Span,
+        dereference_lhs: Option<impl FnMut(&mut Self, Type, Type)>,
+    ) -> Option<(Type, usize)> {
+        let lhs_type = lhs_type.follow_bindings();
+
+        match &lhs_type {
+            Type::Struct(s, args) => {
+                let s = s.borrow();
+                if let Some((field, index)) = s.get_field(field_name, args) {
+                    return Some((field, index));
+                }
+            }
+            Type::Tuple(elements) => {
+                if let Ok(index) = field_name.parse::<usize>() {
+                    let length = elements.len();
+                    if index < length {
+                        return Some((elements[index].clone(), index));
+                    } else {
+                        self.push_err(TypeCheckError::TupleIndexOutOfBounds {
+                            index,
+                            lhs_type,
+                            length,
+                            span,
+                        });
+                        return None;
+                    }
+                }
+            }
+            // If the lhs is a mutable reference we automatically transform
+            // lhs.field into (*lhs).field
+            Type::MutableReference(element) => {
+                if let Some(mut dereference_lhs) = dereference_lhs {
+                    dereference_lhs(self, lhs_type.clone(), element.as_ref().clone());
+                    return self.check_field_access(
+                        element,
+                        field_name,
+                        span,
+                        Some(dereference_lhs),
+                    );
+                } else {
+                    let (element, index) =
+                        self.check_field_access(element, field_name, span, dereference_lhs)?;
+                    return Some((Type::MutableReference(Box::new(element)), index));
+                }
+            }
+            _ => (),
+        }
+
+        // If we get here the type has no field named 'access.rhs'.
+        // Now we specialize the error message based on whether we know the object type in question yet.
+        if let Type::TypeVariable(..) = &lhs_type {
+            self.push_err(TypeCheckError::TypeAnnotationsNeeded { span });
+        } else if lhs_type != Type::Error {
+            self.push_err(TypeCheckError::AccessUnknownMember {
+                lhs_type,
+                field_name: field_name.to_string(),
+                span,
+            });
+        }
+
+        None
+    }
+
+    pub(super) fn elaborate_comptime(&self, _statement: Statement) -> (HirStatement, Type) {
+        todo!("Comptime scanning")
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
new file mode 100644
index 00000000000..2cd699b919d
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -0,0 +1,1399 @@
+use std::rc::Rc;
+
+use iter_extended::vecmap;
+use noirc_errors::{Location, Span};
+
+use crate::{
+    ast::{BinaryOpKind, IntegerBitSize, UnresolvedTraitConstraint, UnresolvedTypeExpression},
+    hir::{
+        def_map::ModuleDefId,
+        resolution::{
+            errors::ResolverError,
+            import::PathResolution,
+            resolver::{verify_mutable_reference, SELF_TYPE_NAME},
+        },
+        type_check::{Source, TypeCheckError},
+    },
+    hir_def::{
+        expr::{
+            HirBinaryOp, HirCallExpression, HirIdent, HirMemberAccess, HirMethodReference,
+            HirPrefixExpression,
+        },
+        traits::{Trait, TraitConstraint},
+    },
+    macros_api::{
+        HirExpression, HirLiteral, Path, PathKind, SecondaryAttribute, Signedness, UnaryOp,
+        UnresolvedType, UnresolvedTypeData,
+    },
+    node_interner::{DefinitionKind, ExprId, GlobalId, TraitImplKind, TraitMethodId},
+    Generics, Shared, StructType, Type, TypeAlias, TypeBinding, TypeVariable, TypeVariableKind,
+};
+
+use super::Elaborator;
+
+impl Elaborator {
+    /// Translates an UnresolvedType to a Type
+    pub(super) fn resolve_type(&mut self, typ: UnresolvedType) -> Type {
+        let span = typ.span;
+        let resolved_type = self.resolve_type_inner(typ, &mut vec![]);
+        if resolved_type.is_nested_slice() {
+            self.push_err(ResolverError::NestedSlices { span: span.unwrap() });
+        }
+
+        resolved_type
+    }
+
+    /// Translates an UnresolvedType into a Type and appends any
+    /// freshly created TypeVariables created to new_variables.
+    fn resolve_type_inner(&mut self, typ: UnresolvedType, new_variables: &mut Generics) -> Type {
+        use crate::ast::UnresolvedTypeData::*;
+
+        let resolved_type = match typ.typ {
+            FieldElement => Type::FieldElement,
+            Array(size, elem) => {
+                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
+                let size = self.resolve_array_size(Some(size), new_variables);
+                Type::Array(Box::new(size), elem)
+            }
+            Slice(elem) => {
+                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
+                Type::Slice(elem)
+            }
+            Expression(expr) => self.convert_expression_type(expr),
+            Integer(sign, bits) => Type::Integer(sign, bits),
+            Bool => Type::Bool,
+            String(size) => {
+                let resolved_size = self.resolve_array_size(size, new_variables);
+                Type::String(Box::new(resolved_size))
+            }
+            FormatString(size, fields) => {
+                let resolved_size = self.convert_expression_type(size);
+                let fields = self.resolve_type_inner(*fields, new_variables);
+                Type::FmtString(Box::new(resolved_size), Box::new(fields))
+            }
+            Code => Type::Code,
+            Unit => Type::Unit,
+            Unspecified => Type::Error,
+            Error => Type::Error,
+            Named(path, args, _) => self.resolve_named_type(path, args, new_variables),
+            TraitAsType(path, args) => self.resolve_trait_as_type(path, args, new_variables),
+
+            Tuple(fields) => {
+                Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field, new_variables)))
+            }
+            Function(args, ret, env) => {
+                let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+                let ret = Box::new(self.resolve_type_inner(*ret, new_variables));
+
+                // expect() here is valid, because the only places we don't have a span are omitted types
+                // e.g. a function without return type implicitly has a spanless UnresolvedType::Unit return type
+                // To get an invalid env type, the user must explicitly specify the type, which will have a span
+                let env_span =
+                    env.span.expect("Unexpected missing span for closure environment type");
+
+                let env = Box::new(self.resolve_type_inner(*env, new_variables));
+
+                match *env {
+                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _) => {
+                        Type::Function(args, ret, env)
+                    }
+                    _ => {
+                        self.push_err(ResolverError::InvalidClosureEnvironment {
+                            typ: *env,
+                            span: env_span,
+                        });
+                        Type::Error
+                    }
+                }
+            }
+            MutableReference(element) => {
+                Type::MutableReference(Box::new(self.resolve_type_inner(*element, new_variables)))
+            }
+            Parenthesized(typ) => self.resolve_type_inner(*typ, new_variables),
+        };
+
+        if let Type::Struct(_, _) = resolved_type {
+            if let Some(unresolved_span) = typ.span {
+                // Record the location of the type reference
+                self.interner.push_type_ref_location(
+                    resolved_type.clone(),
+                    Location::new(unresolved_span, self.file),
+                );
+            }
+        }
+        resolved_type
+    }
+
+    fn find_generic(&self, target_name: &str) -> Option<&(Rc<String>, TypeVariable, Span)> {
+        self.generics.iter().find(|(name, _, _)| name.as_ref() == target_name)
+    }
+
+    fn resolve_named_type(
+        &mut self,
+        path: Path,
+        args: Vec<UnresolvedType>,
+        new_variables: &mut Generics,
+    ) -> Type {
+        if args.is_empty() {
+            if let Some(typ) = self.lookup_generic_or_global_type(&path) {
+                return typ;
+            }
+        }
+
+        // Check if the path is a type variable first. We currently disallow generics on type
+        // variables since we do not support higher-kinded types.
+        if path.segments.len() == 1 {
+            let name = &path.last_segment().0.contents;
+
+            if name == SELF_TYPE_NAME {
+                if let Some(self_type) = self.self_type.clone() {
+                    if !args.is_empty() {
+                        self.push_err(ResolverError::GenericsOnSelfType { span: path.span() });
+                    }
+                    return self_type;
+                }
+            }
+        }
+
+        let span = path.span();
+        let mut args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+
+        if let Some(type_alias) = self.lookup_type_alias(path.clone()) {
+            let type_alias = type_alias.borrow();
+            let expected_generic_count = type_alias.generics.len();
+            let type_alias_string = type_alias.to_string();
+            let id = type_alias.id;
+
+            self.verify_generics_count(expected_generic_count, &mut args, span, || {
+                type_alias_string
+            });
+
+            if let Some(item) = self.current_item {
+                self.interner.add_type_alias_dependency(item, id);
+            }
+
+            // Collecting Type Alias references [Location]s to be used by LSP in order
+            // to resolve the definition of the type alias
+            self.interner.add_type_alias_ref(id, Location::new(span, self.file));
+
+            // Because there is no ordering to when type aliases (and other globals) are resolved,
+            // it is possible for one to refer to an Error type and issue no error if it is set
+            // equal to another type alias. Fixing this fully requires an analysis to create a DFG
+            // of definition ordering, but for now we have an explicit check here so that we at
+            // least issue an error that the type was not found instead of silently passing.
+            let alias = self.interner.get_type_alias(id);
+            return Type::Alias(alias, args);
+        }
+
+        match self.lookup_struct_or_error(path) {
+            Some(struct_type) => {
+                if self.resolving_ids.contains(&struct_type.borrow().id) {
+                    self.push_err(ResolverError::SelfReferentialStruct {
+                        span: struct_type.borrow().name.span(),
+                    });
+
+                    return Type::Error;
+                }
+
+                let expected_generic_count = struct_type.borrow().generics.len();
+                if !self.in_contract
+                    && self
+                        .interner
+                        .struct_attributes(&struct_type.borrow().id)
+                        .iter()
+                        .any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
+                {
+                    self.push_err(ResolverError::AbiAttributeOutsideContract {
+                        span: struct_type.borrow().name.span(),
+                    });
+                }
+                self.verify_generics_count(expected_generic_count, &mut args, span, || {
+                    struct_type.borrow().to_string()
+                });
+
+                if let Some(current_item) = self.current_item {
+                    let dependency_id = struct_type.borrow().id;
+                    self.interner.add_type_dependency(current_item, dependency_id);
+                }
+
+                Type::Struct(struct_type, args)
+            }
+            None => Type::Error,
+        }
+    }
+
+    fn resolve_trait_as_type(
+        &mut self,
+        path: Path,
+        args: Vec<UnresolvedType>,
+        new_variables: &mut Generics,
+    ) -> Type {
+        let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+
+        if let Some(t) = self.lookup_trait_or_error(path) {
+            Type::TraitAsType(t.id, Rc::new(t.name.to_string()), args)
+        } else {
+            Type::Error
+        }
+    }
+
+    fn verify_generics_count(
+        &mut self,
+        expected_count: usize,
+        args: &mut Vec<Type>,
+        span: Span,
+        type_name: impl FnOnce() -> String,
+    ) {
+        if args.len() != expected_count {
+            self.push_err(ResolverError::IncorrectGenericCount {
+                span,
+                item_name: type_name(),
+                actual: args.len(),
+                expected: expected_count,
+            });
+
+            // Fix the generic count so we can continue typechecking
+            args.resize_with(expected_count, || Type::Error);
+        }
+    }
+
+    fn lookup_generic_or_global_type(&mut self, path: &Path) -> Option<Type> {
+        if path.segments.len() == 1 {
+            let name = &path.last_segment().0.contents;
+            if let Some((name, var, _)) = self.find_generic(name) {
+                return Some(Type::NamedGeneric(var.clone(), name.clone()));
+            }
+        }
+
+        // If we cannot find a local generic of the same name, try to look up a global
+        match self.path_resolver.resolve(&self.def_maps, path.clone()) {
+            Ok(PathResolution { module_def_id: ModuleDefId::GlobalId(id), error }) => {
+                if let Some(current_item) = self.current_item {
+                    self.interner.add_global_dependency(current_item, id);
+                }
+
+                if let Some(error) = error {
+                    self.push_err(error);
+                }
+                Some(Type::Constant(self.eval_global_as_array_length(id, path)))
+            }
+            _ => None,
+        }
+    }
+
+    fn resolve_array_size(
+        &mut self,
+        length: Option<UnresolvedTypeExpression>,
+        new_variables: &mut Generics,
+    ) -> Type {
+        match length {
+            None => {
+                let id = self.interner.next_type_variable_id();
+                let typevar = TypeVariable::unbound(id);
+                new_variables.push(typevar.clone());
+
+                // 'Named'Generic is a bit of a misnomer here, we want a type variable that
+                // wont be bound over but this one has no name since we do not currently
+                // require users to explicitly be generic over array lengths.
+                Type::NamedGeneric(typevar, Rc::new("".into()))
+            }
+            Some(length) => self.convert_expression_type(length),
+        }
+    }
+
+    pub(super) fn convert_expression_type(&mut self, length: UnresolvedTypeExpression) -> Type {
+        match length {
+            UnresolvedTypeExpression::Variable(path) => {
+                self.lookup_generic_or_global_type(&path).unwrap_or_else(|| {
+                    self.push_err(ResolverError::NoSuchNumericTypeVariable { path });
+                    Type::Constant(0)
+                })
+            }
+            UnresolvedTypeExpression::Constant(int, _) => Type::Constant(int),
+            UnresolvedTypeExpression::BinaryOperation(lhs, op, rhs, _) => {
+                let (lhs_span, rhs_span) = (lhs.span(), rhs.span());
+                let lhs = self.convert_expression_type(*lhs);
+                let rhs = self.convert_expression_type(*rhs);
+
+                match (lhs, rhs) {
+                    (Type::Constant(lhs), Type::Constant(rhs)) => {
+                        Type::Constant(op.function()(lhs, rhs))
+                    }
+                    (lhs, _) => {
+                        let span =
+                            if !matches!(lhs, Type::Constant(_)) { lhs_span } else { rhs_span };
+                        self.push_err(ResolverError::InvalidArrayLengthExpr { span });
+                        Type::Constant(0)
+                    }
+                }
+            }
+        }
+    }
+
+    /// Lookup a given struct type by name.
+    fn lookup_struct_or_error(&mut self, path: Path) -> Option<Shared<StructType>> {
+        match self.lookup(path) {
+            Ok(struct_id) => Some(self.get_struct(struct_id)),
+            Err(error) => {
+                self.push_err(error);
+                None
+            }
+        }
+    }
+
+    /// Lookup a given trait by name/path.
+    fn lookup_trait_or_error(&mut self, path: Path) -> Option<&mut Trait> {
+        match self.lookup(path) {
+            Ok(trait_id) => Some(self.get_trait_mut(trait_id)),
+            Err(error) => {
+                self.push_err(error);
+                None
+            }
+        }
+    }
+
+    /// Looks up a given type by name.
+    /// This will also instantiate any struct types found.
+    pub(super) fn lookup_type_or_error(&mut self, path: Path) -> Option<Type> {
+        let ident = path.as_ident();
+        if ident.map_or(false, |i| i == SELF_TYPE_NAME) {
+            if let Some(typ) = &self.self_type {
+                return Some(typ.clone());
+            }
+        }
+
+        match self.lookup(path) {
+            Ok(struct_id) => {
+                let struct_type = self.get_struct(struct_id);
+                let generics = struct_type.borrow().instantiate(&mut self.interner);
+                Some(Type::Struct(struct_type, generics))
+            }
+            Err(error) => {
+                self.push_err(error);
+                None
+            }
+        }
+    }
+
+    fn lookup_type_alias(&mut self, path: Path) -> Option<Shared<TypeAlias>> {
+        self.lookup(path).ok().map(|id| self.interner.get_type_alias(id))
+    }
+
+    // this resolves Self::some_static_method, inside an impl block (where we don't have a concrete self_type)
+    //
+    // Returns the trait method, trait constraint, and whether the impl is assumed to exist by a where clause or not
+    // E.g. `t.method()` with `where T: Foo<Bar>` in scope will return `(Foo::method, T, vec![Bar])`
+    fn resolve_trait_static_method_by_self(
+        &mut self,
+        path: &Path,
+    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+        let trait_id = self.trait_id?;
+
+        if path.kind == PathKind::Plain && path.segments.len() == 2 {
+            let name = &path.segments[0].0.contents;
+            let method = &path.segments[1];
+
+            if name == SELF_TYPE_NAME {
+                let the_trait = self.interner.get_trait(trait_id);
+                let method = the_trait.find_method(method.0.contents.as_str())?;
+
+                let constraint = TraitConstraint {
+                    typ: self.self_type.clone()?,
+                    trait_generics: Type::from_generics(&the_trait.generics),
+                    trait_id,
+                };
+                return Some((method, constraint, false));
+            }
+        }
+        None
+    }
+
+    // this resolves TraitName::some_static_method
+    //
+    // Returns the trait method, trait constraint, and whether the impl is assumed to exist by a where clause or not
+    // E.g. `t.method()` with `where T: Foo<Bar>` in scope will return `(Foo::method, T, vec![Bar])`
+    fn resolve_trait_static_method(
+        &mut self,
+        path: &Path,
+    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+        if path.kind == PathKind::Plain && path.segments.len() == 2 {
+            let method = &path.segments[1];
+
+            let mut trait_path = path.clone();
+            trait_path.pop();
+            let trait_id = self.lookup(trait_path).ok()?;
+            let the_trait = self.interner.get_trait(trait_id);
+
+            let method = the_trait.find_method(method.0.contents.as_str())?;
+            let constraint = TraitConstraint {
+                typ: Type::TypeVariable(
+                    the_trait.self_type_typevar.clone(),
+                    TypeVariableKind::Normal,
+                ),
+                trait_generics: Type::from_generics(&the_trait.generics),
+                trait_id,
+            };
+            return Some((method, constraint, false));
+        }
+        None
+    }
+
+    // This resolves a static trait method T::trait_method by iterating over the where clause
+    //
+    // Returns the trait method, trait constraint, and whether the impl is assumed from a where
+    // clause. This is always true since this helper searches where clauses for a generic constraint.
+    // E.g. `t.method()` with `where T: Foo<Bar>` in scope will return `(Foo::method, T, vec![Bar])`
+    fn resolve_trait_method_by_named_generic(
+        &mut self,
+        path: &Path,
+    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+        if path.segments.len() != 2 {
+            return None;
+        }
+
+        for UnresolvedTraitConstraint { typ, trait_bound } in self.trait_bounds.clone() {
+            if let UnresolvedTypeData::Named(constraint_path, _, _) = &typ.typ {
+                // if `path` is `T::method_name`, we're looking for constraint of the form `T: SomeTrait`
+                if constraint_path.segments.len() == 1
+                    && path.segments[0] != constraint_path.last_segment()
+                {
+                    continue;
+                }
+
+                if let Ok(ModuleDefId::TraitId(trait_id)) =
+                    self.resolve_path(trait_bound.trait_path.clone())
+                {
+                    let the_trait = self.interner.get_trait(trait_id);
+                    if let Some(method) =
+                        the_trait.find_method(path.segments.last().unwrap().0.contents.as_str())
+                    {
+                        let constraint = TraitConstraint {
+                            trait_id,
+                            typ: self.resolve_type(typ.clone()),
+                            trait_generics: vecmap(trait_bound.trait_generics, |typ| {
+                                self.resolve_type(typ)
+                            }),
+                        };
+                        return Some((method, constraint, true));
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    // Try to resolve the given trait method path.
+    //
+    // Returns the trait method, trait constraint, and whether the impl is assumed to exist by a where clause or not
+    // E.g. `t.method()` with `where T: Foo<Bar>` in scope will return `(Foo::method, T, vec![Bar])`
+    pub(super) fn resolve_trait_generic_path(
+        &mut self,
+        path: &Path,
+    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+        self.resolve_trait_static_method_by_self(path)
+            .or_else(|| self.resolve_trait_static_method(path))
+            .or_else(|| self.resolve_trait_method_by_named_generic(path))
+    }
+
+    fn eval_global_as_array_length(&mut self, global: GlobalId, path: &Path) -> u64 {
+        let Some(stmt) = self.interner.get_global_let_statement(global) else {
+            let path = path.clone();
+            self.push_err(ResolverError::NoSuchNumericTypeVariable { path });
+            return 0;
+        };
+
+        let length = stmt.expression;
+        let span = self.interner.expr_span(&length);
+        let result = self.try_eval_array_length_id(length, span);
+
+        match result.map(|length| length.try_into()) {
+            Ok(Ok(length_value)) => return length_value,
+            Ok(Err(_cast_err)) => self.push_err(ResolverError::IntegerTooLarge { span }),
+            Err(Some(error)) => self.push_err(error),
+            Err(None) => (),
+        }
+        0
+    }
+
+    fn try_eval_array_length_id(
+        &self,
+        rhs: ExprId,
+        span: Span,
+    ) -> Result<u128, Option<ResolverError>> {
+        // Arbitrary amount of recursive calls to try before giving up
+        let fuel = 100;
+        self.try_eval_array_length_id_with_fuel(rhs, span, fuel)
+    }
+
+    fn try_eval_array_length_id_with_fuel(
+        &self,
+        rhs: ExprId,
+        span: Span,
+        fuel: u32,
+    ) -> Result<u128, Option<ResolverError>> {
+        if fuel == 0 {
+            // If we reach here, it is likely from evaluating cyclic globals. We expect an error to
+            // be issued for them after name resolution so issue no error now.
+            return Err(None);
+        }
+
+        match self.interner.expression(&rhs) {
+            HirExpression::Literal(HirLiteral::Integer(int, false)) => {
+                int.try_into_u128().ok_or(Some(ResolverError::IntegerTooLarge { span }))
+            }
+            HirExpression::Ident(ident) => {
+                let definition = self.interner.definition(ident.id);
+                match definition.kind {
+                    DefinitionKind::Global(global_id) => {
+                        let let_statement = self.interner.get_global_let_statement(global_id);
+                        if let Some(let_statement) = let_statement {
+                            let expression = let_statement.expression;
+                            self.try_eval_array_length_id_with_fuel(expression, span, fuel - 1)
+                        } else {
+                            Err(Some(ResolverError::InvalidArrayLengthExpr { span }))
+                        }
+                    }
+                    _ => Err(Some(ResolverError::InvalidArrayLengthExpr { span })),
+                }
+            }
+            HirExpression::Infix(infix) => {
+                let lhs = self.try_eval_array_length_id_with_fuel(infix.lhs, span, fuel - 1)?;
+                let rhs = self.try_eval_array_length_id_with_fuel(infix.rhs, span, fuel - 1)?;
+
+                match infix.operator.kind {
+                    BinaryOpKind::Add => Ok(lhs + rhs),
+                    BinaryOpKind::Subtract => Ok(lhs - rhs),
+                    BinaryOpKind::Multiply => Ok(lhs * rhs),
+                    BinaryOpKind::Divide => Ok(lhs / rhs),
+                    BinaryOpKind::Equal => Ok((lhs == rhs) as u128),
+                    BinaryOpKind::NotEqual => Ok((lhs != rhs) as u128),
+                    BinaryOpKind::Less => Ok((lhs < rhs) as u128),
+                    BinaryOpKind::LessEqual => Ok((lhs <= rhs) as u128),
+                    BinaryOpKind::Greater => Ok((lhs > rhs) as u128),
+                    BinaryOpKind::GreaterEqual => Ok((lhs >= rhs) as u128),
+                    BinaryOpKind::And => Ok(lhs & rhs),
+                    BinaryOpKind::Or => Ok(lhs | rhs),
+                    BinaryOpKind::Xor => Ok(lhs ^ rhs),
+                    BinaryOpKind::ShiftRight => Ok(lhs >> rhs),
+                    BinaryOpKind::ShiftLeft => Ok(lhs << rhs),
+                    BinaryOpKind::Modulo => Ok(lhs % rhs),
+                }
+            }
+            _other => Err(Some(ResolverError::InvalidArrayLengthExpr { span })),
+        }
+    }
+
+    /// Check if an assignment is overflowing with respect to `annotated_type`
+    /// in a declaration statement where `annotated_type` is an unsigned integer
+    pub(super) fn lint_overflowing_uint(&mut self, rhs_expr: &ExprId, annotated_type: &Type) {
+        let expr = self.interner.expression(rhs_expr);
+        let span = self.interner.expr_span(rhs_expr);
+        match expr {
+            HirExpression::Literal(HirLiteral::Integer(value, false)) => {
+                let v = value.to_u128();
+                if let Type::Integer(_, bit_count) = annotated_type {
+                    let bit_count: u32 = (*bit_count).into();
+                    let max = 1 << bit_count;
+                    if v >= max {
+                        self.push_err(TypeCheckError::OverflowingAssignment {
+                            expr: value,
+                            ty: annotated_type.clone(),
+                            range: format!("0..={}", max - 1),
+                            span,
+                        });
+                    };
+                };
+            }
+            HirExpression::Prefix(expr) => {
+                self.lint_overflowing_uint(&expr.rhs, annotated_type);
+                if matches!(expr.operator, UnaryOp::Minus) {
+                    self.push_err(TypeCheckError::InvalidUnaryOp {
+                        kind: "annotated_type".to_string(),
+                        span,
+                    });
+                }
+            }
+            HirExpression::Infix(expr) => {
+                self.lint_overflowing_uint(&expr.lhs, annotated_type);
+                self.lint_overflowing_uint(&expr.rhs, annotated_type);
+            }
+            _ => {}
+        }
+    }
+
+    pub(super) fn unify(
+        &mut self,
+        actual: &Type,
+        expected: &Type,
+        make_error: impl FnOnce() -> TypeCheckError,
+    ) {
+        let mut errors = Vec::new();
+        actual.unify(expected, &mut errors, make_error);
+        self.errors.extend(errors.into_iter().map(Into::into));
+    }
+
+    /// Wrapper of Type::unify_with_coercions using self.errors
+    pub(super) fn unify_with_coercions(
+        &mut self,
+        actual: &Type,
+        expected: &Type,
+        expression: ExprId,
+        make_error: impl FnOnce() -> TypeCheckError,
+    ) {
+        let mut errors = Vec::new();
+        actual.unify_with_coercions(
+            expected,
+            expression,
+            &mut self.interner,
+            &mut errors,
+            make_error,
+        );
+        self.errors.extend(errors.into_iter().map(Into::into));
+    }
+
+    /// Return a fresh integer or field type variable and log it
+    /// in self.type_variables to default it later.
+    pub(super) fn polymorphic_integer_or_field(&mut self) -> Type {
+        let typ = Type::polymorphic_integer_or_field(&mut self.interner);
+        self.type_variables.push(typ.clone());
+        typ
+    }
+
+    /// Return a fresh integer type variable and log it
+    /// in self.type_variables to default it later.
+    pub(super) fn polymorphic_integer(&mut self) -> Type {
+        let typ = Type::polymorphic_integer(&mut self.interner);
+        self.type_variables.push(typ.clone());
+        typ
+    }
+
+    /// Translates a (possibly Unspecified) UnresolvedType to a Type.
+    /// Any UnresolvedType::Unspecified encountered are replaced with fresh type variables.
+    pub(super) fn resolve_inferred_type(&mut self, typ: UnresolvedType) -> Type {
+        match &typ.typ {
+            UnresolvedTypeData::Unspecified => self.interner.next_type_variable(),
+            _ => self.resolve_type_inner(typ, &mut vec![]),
+        }
+    }
+
+    pub(super) fn type_check_prefix_operand(
+        &mut self,
+        op: &crate::ast::UnaryOp,
+        rhs_type: &Type,
+        span: Span,
+    ) -> Type {
+        let mut unify = |this: &mut Self, expected| {
+            this.unify(rhs_type, &expected, || TypeCheckError::TypeMismatch {
+                expr_typ: rhs_type.to_string(),
+                expected_typ: expected.to_string(),
+                expr_span: span,
+            });
+            expected
+        };
+
+        match op {
+            crate::ast::UnaryOp::Minus => {
+                if rhs_type.is_unsigned() {
+                    self.push_err(TypeCheckError::InvalidUnaryOp {
+                        kind: rhs_type.to_string(),
+                        span,
+                    });
+                }
+                let expected = self.polymorphic_integer_or_field();
+                self.unify(rhs_type, &expected, || TypeCheckError::InvalidUnaryOp {
+                    kind: rhs_type.to_string(),
+                    span,
+                });
+                expected
+            }
+            crate::ast::UnaryOp::Not => {
+                let rhs_type = rhs_type.follow_bindings();
+
+                // `!` can work on booleans or integers
+                if matches!(rhs_type, Type::Integer(..)) {
+                    return rhs_type;
+                }
+
+                unify(self, Type::Bool)
+            }
+            crate::ast::UnaryOp::MutableReference => {
+                Type::MutableReference(Box::new(rhs_type.follow_bindings()))
+            }
+            crate::ast::UnaryOp::Dereference { implicitly_added: _ } => {
+                let element_type = self.interner.next_type_variable();
+                unify(self, Type::MutableReference(Box::new(element_type.clone())));
+                element_type
+            }
+        }
+    }
+
+    /// Insert as many dereference operations as necessary to automatically dereference a method
+    /// call object to its base value type T.
+    pub(super) fn insert_auto_dereferences(&mut self, object: ExprId, typ: Type) -> (ExprId, Type) {
+        if let Type::MutableReference(element) = typ {
+            let location = self.interner.id_location(object);
+
+            let object = self.interner.push_expr(HirExpression::Prefix(HirPrefixExpression {
+                operator: UnaryOp::Dereference { implicitly_added: true },
+                rhs: object,
+            }));
+            self.interner.push_expr_type(object, element.as_ref().clone());
+            self.interner.push_expr_location(object, location.span, location.file);
+
+            // Recursively dereference to allow for converting &mut &mut T to T
+            self.insert_auto_dereferences(object, *element)
+        } else {
+            (object, typ)
+        }
+    }
+
+    /// Given a method object: `(*foo).bar` of a method call `(*foo).bar.baz()`, remove the
+    /// implicitly added dereference operator if one is found.
+    ///
+    /// Returns Some(new_expr_id) if a dereference was removed and None otherwise.
+    fn try_remove_implicit_dereference(&mut self, object: ExprId) -> Option<ExprId> {
+        match self.interner.expression(&object) {
+            HirExpression::MemberAccess(mut access) => {
+                let new_lhs = self.try_remove_implicit_dereference(access.lhs)?;
+                access.lhs = new_lhs;
+                access.is_offset = true;
+
+                // `object` will have a different type now, which will be filled in
+                // later when type checking the method call as a function call.
+                self.interner.replace_expr(&object, HirExpression::MemberAccess(access));
+                Some(object)
+            }
+            HirExpression::Prefix(prefix) => match prefix.operator {
+                // Found a dereference we can remove. Now just replace it with its rhs to remove it.
+                UnaryOp::Dereference { implicitly_added: true } => Some(prefix.rhs),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    fn bind_function_type_impl(
+        &mut self,
+        fn_params: &[Type],
+        fn_ret: &Type,
+        callsite_args: &[(Type, ExprId, Span)],
+        span: Span,
+    ) -> Type {
+        if fn_params.len() != callsite_args.len() {
+            self.push_err(TypeCheckError::ParameterCountMismatch {
+                expected: fn_params.len(),
+                found: callsite_args.len(),
+                span,
+            });
+            return Type::Error;
+        }
+
+        for (param, (arg, _, arg_span)) in fn_params.iter().zip(callsite_args) {
+            self.unify(arg, param, || TypeCheckError::TypeMismatch {
+                expected_typ: param.to_string(),
+                expr_typ: arg.to_string(),
+                expr_span: *arg_span,
+            });
+        }
+
+        fn_ret.clone()
+    }
+
+    pub(super) fn bind_function_type(
+        &mut self,
+        function: Type,
+        args: Vec<(Type, ExprId, Span)>,
+        span: Span,
+    ) -> Type {
+        // Could do a single unification for the entire function type, but matching beforehand
+        // lets us issue a more precise error on the individual argument that fails to type check.
+        match function {
+            Type::TypeVariable(binding, TypeVariableKind::Normal) => {
+                if let TypeBinding::Bound(typ) = &*binding.borrow() {
+                    return self.bind_function_type(typ.clone(), args, span);
+                }
+
+                let ret = self.interner.next_type_variable();
+                let args = vecmap(args, |(arg, _, _)| arg);
+                let env_type = self.interner.next_type_variable();
+                let expected = Type::Function(args, Box::new(ret.clone()), Box::new(env_type));
+
+                if let Err(error) = binding.try_bind(expected, span) {
+                    self.push_err(error);
+                }
+                ret
+            }
+            // The closure env is ignored on purpose: call arguments never place
+            // constraints on closure environments.
+            Type::Function(parameters, ret, _env) => {
+                self.bind_function_type_impl(&parameters, &ret, &args, span)
+            }
+            Type::Error => Type::Error,
+            found => {
+                self.push_err(TypeCheckError::ExpectedFunction { found, span });
+                Type::Error
+            }
+        }
+    }
+
+    pub(super) fn check_cast(&mut self, from: Type, to: &Type, span: Span) -> Type {
+        match from.follow_bindings() {
+            Type::Integer(..)
+            | Type::FieldElement
+            | Type::TypeVariable(_, TypeVariableKind::IntegerOrField)
+            | Type::TypeVariable(_, TypeVariableKind::Integer)
+            | Type::Bool => (),
+
+            Type::TypeVariable(_, _) => {
+                self.push_err(TypeCheckError::TypeAnnotationsNeeded { span });
+                return Type::Error;
+            }
+            Type::Error => return Type::Error,
+            from => {
+                self.push_err(TypeCheckError::InvalidCast { from, span });
+                return Type::Error;
+            }
+        }
+
+        match to {
+            Type::Integer(sign, bits) => Type::Integer(*sign, *bits),
+            Type::FieldElement => Type::FieldElement,
+            Type::Bool => Type::Bool,
+            Type::Error => Type::Error,
+            _ => {
+                self.push_err(TypeCheckError::UnsupportedCast { span });
+                Type::Error
+            }
+        }
+    }
+
+    // Given a binary comparison operator and another type. This method will produce the output type
+    // and a boolean indicating whether to use the trait impl corresponding to the operator
+    // or not. A value of false indicates the caller to use a primitive operation for this
+    // operator, while a true value indicates a user-provided trait impl is required.
+    fn comparator_operand_type_rules(
+        &mut self,
+        lhs_type: &Type,
+        rhs_type: &Type,
+        op: &HirBinaryOp,
+        span: Span,
+    ) -> Result<(Type, bool), TypeCheckError> {
+        use Type::*;
+
+        match (lhs_type, rhs_type) {
+            // Avoid reporting errors multiple times
+            (Error, _) | (_, Error) => Ok((Bool, false)),
+            (Alias(alias, args), other) | (other, Alias(alias, args)) => {
+                let alias = alias.borrow().get_type(args);
+                self.comparator_operand_type_rules(&alias, other, op, span)
+            }
+
+            // Matches on TypeVariable must be first to follow any type
+            // bindings.
+            (TypeVariable(var, _), other) | (other, TypeVariable(var, _)) => {
+                if let TypeBinding::Bound(binding) = &*var.borrow() {
+                    return self.comparator_operand_type_rules(other, binding, op, span);
+                }
+
+                let use_impl = self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
+                Ok((Bool, use_impl))
+            }
+            (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => {
+                if sign_x != sign_y {
+                    return Err(TypeCheckError::IntegerSignedness {
+                        sign_x: *sign_x,
+                        sign_y: *sign_y,
+                        span,
+                    });
+                }
+                if bit_width_x != bit_width_y {
+                    return Err(TypeCheckError::IntegerBitWidth {
+                        bit_width_x: *bit_width_x,
+                        bit_width_y: *bit_width_y,
+                        span,
+                    });
+                }
+                Ok((Bool, false))
+            }
+            (FieldElement, FieldElement) => {
+                if op.kind.is_valid_for_field_type() {
+                    Ok((Bool, false))
+                } else {
+                    Err(TypeCheckError::FieldComparison { span })
+                }
+            }
+
+            // <= and friends are technically valid for booleans, just not very useful
+            (Bool, Bool) => Ok((Bool, false)),
+
+            (lhs, rhs) => {
+                self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource {
+                    expected: lhs.clone(),
+                    actual: rhs.clone(),
+                    span: op.location.span,
+                    source: Source::Binary,
+                });
+                Ok((Bool, true))
+            }
+        }
+    }
+
+    /// Handles the TypeVariable case for checking binary operators.
+    /// Returns true if we should use the impl for the operator instead of the primitive
+    /// version of it.
+    fn bind_type_variables_for_infix(
+        &mut self,
+        lhs_type: &Type,
+        op: &HirBinaryOp,
+        rhs_type: &Type,
+        span: Span,
+    ) -> bool {
+        self.unify(lhs_type, rhs_type, || TypeCheckError::TypeMismatchWithSource {
+            expected: lhs_type.clone(),
+            actual: rhs_type.clone(),
+            source: Source::Binary,
+            span,
+        });
+
+        let use_impl = !lhs_type.is_numeric();
+
+        // If this operator isn't valid for fields we have to possibly narrow
+        // TypeVariableKind::IntegerOrField to TypeVariableKind::Integer.
+        // Doing so also ensures a type error if Field is used.
+        // The is_numeric check is to allow impls for custom types to bypass this.
+        if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric() {
+            let target = Type::polymorphic_integer(&mut self.interner);
+
+            use crate::ast::BinaryOpKind::*;
+            use TypeCheckError::*;
+            self.unify(lhs_type, &target, || match op.kind {
+                Less | LessEqual | Greater | GreaterEqual => FieldComparison { span },
+                And | Or | Xor | ShiftRight | ShiftLeft => FieldBitwiseOp { span },
+                Modulo => FieldModulo { span },
+                other => unreachable!("Operator {other:?} should be valid for Field"),
+            });
+        }
+
+        use_impl
+    }
+
+    // Given a binary operator and another type. This method will produce the output type
+    // and a boolean indicating whether to use the trait impl corresponding to the operator
+    // or not. A value of false indicates the caller to use a primitive operation for this
+    // operator, while a true value indicates a user-provided trait impl is required.
+    pub(super) fn infix_operand_type_rules(
+        &mut self,
+        lhs_type: &Type,
+        op: &HirBinaryOp,
+        rhs_type: &Type,
+        span: Span,
+    ) -> Result<(Type, bool), TypeCheckError> {
+        if op.kind.is_comparator() {
+            return self.comparator_operand_type_rules(lhs_type, rhs_type, op, span);
+        }
+
+        use Type::*;
+        match (lhs_type, rhs_type) {
+            // An error type on either side will always return an error
+            (Error, _) | (_, Error) => Ok((Error, false)),
+            (Alias(alias, args), other) | (other, Alias(alias, args)) => {
+                let alias = alias.borrow().get_type(args);
+                self.infix_operand_type_rules(&alias, op, other, span)
+            }
+
+            // Matches on TypeVariable must be first so that we follow any type
+            // bindings.
+            (TypeVariable(int, _), other) | (other, TypeVariable(int, _)) => {
+                if let TypeBinding::Bound(binding) = &*int.borrow() {
+                    return self.infix_operand_type_rules(binding, op, other, span);
+                }
+                if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
+                    self.unify(
+                        rhs_type,
+                        &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+                        || TypeCheckError::InvalidShiftSize { span },
+                    );
+                    let use_impl = if lhs_type.is_numeric() {
+                        let integer_type = Type::polymorphic_integer(&mut self.interner);
+                        self.bind_type_variables_for_infix(lhs_type, op, &integer_type, span)
+                    } else {
+                        true
+                    };
+                    return Ok((lhs_type.clone(), use_impl));
+                }
+                let use_impl = self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
+                Ok((other.clone(), use_impl))
+            }
+            (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => {
+                if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
+                    if *sign_y != Signedness::Unsigned || *bit_width_y != IntegerBitSize::Eight {
+                        return Err(TypeCheckError::InvalidShiftSize { span });
+                    }
+                    return Ok((Integer(*sign_x, *bit_width_x), false));
+                }
+                if sign_x != sign_y {
+                    return Err(TypeCheckError::IntegerSignedness {
+                        sign_x: *sign_x,
+                        sign_y: *sign_y,
+                        span,
+                    });
+                }
+                if bit_width_x != bit_width_y {
+                    return Err(TypeCheckError::IntegerBitWidth {
+                        bit_width_x: *bit_width_x,
+                        bit_width_y: *bit_width_y,
+                        span,
+                    });
+                }
+                Ok((Integer(*sign_x, *bit_width_x), false))
+            }
+            // The result of two Fields is always a witness
+            (FieldElement, FieldElement) => {
+                if !op.kind.is_valid_for_field_type() {
+                    if op.kind == BinaryOpKind::Modulo {
+                        return Err(TypeCheckError::FieldModulo { span });
+                    } else {
+                        return Err(TypeCheckError::FieldBitwiseOp { span });
+                    }
+                }
+                Ok((FieldElement, false))
+            }
+
+            (Bool, Bool) => Ok((Bool, false)),
+
+            (lhs, rhs) => {
+                if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
+                    if rhs == &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight) {
+                        return Ok((lhs.clone(), true));
+                    }
+                    return Err(TypeCheckError::InvalidShiftSize { span });
+                }
+                self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource {
+                    expected: lhs.clone(),
+                    actual: rhs.clone(),
+                    span: op.location.span,
+                    source: Source::Binary,
+                });
+                Ok((lhs.clone(), true))
+            }
+        }
+    }
+
+    /// Prerequisite: verify_trait_constraint of the operator's trait constraint.
+    ///
+    /// Although by this point the operator is expected to already have a trait impl,
+    /// we still need to match the operator's type against the method's instantiated type
+    /// to ensure the instantiation bindings are correct and the monomorphizer can
+    /// re-apply the needed bindings.
+    pub(super) fn type_check_operator_method(
+        &mut self,
+        expr_id: ExprId,
+        trait_method_id: TraitMethodId,
+        object_type: &Type,
+        span: Span,
+    ) {
+        let the_trait = self.interner.get_trait(trait_method_id.trait_id);
+
+        let method = &the_trait.methods[trait_method_id.method_index];
+        let (method_type, mut bindings) = method.typ.clone().instantiate(&self.interner);
+
+        match method_type {
+            Type::Function(args, _, _) => {
+                // We can cheat a bit and match against only the object type here since no operator
+                // overload uses other generic parameters or return types aside from the object type.
+                let expected_object_type = &args[0];
+                self.unify(object_type, expected_object_type, || TypeCheckError::TypeMismatch {
+                    expected_typ: expected_object_type.to_string(),
+                    expr_typ: object_type.to_string(),
+                    expr_span: span,
+                });
+            }
+            other => {
+                unreachable!("Expected operator method to have a function type, but found {other}")
+            }
+        }
+
+        // We must also remember to apply these substitutions to the object_type
+        // referenced by the selected trait impl, if one has yet to be selected.
+        let impl_kind = self.interner.get_selected_impl_for_expression(expr_id);
+        if let Some(TraitImplKind::Assumed { object_type, trait_generics }) = impl_kind {
+            let the_trait = self.interner.get_trait(trait_method_id.trait_id);
+            let object_type = object_type.substitute(&bindings);
+            bindings.insert(
+                the_trait.self_type_typevar_id,
+                (the_trait.self_type_typevar.clone(), object_type.clone()),
+            );
+            self.interner.select_impl_for_expression(
+                expr_id,
+                TraitImplKind::Assumed { object_type, trait_generics },
+            );
+        }
+
+        self.interner.store_instantiation_bindings(expr_id, bindings);
+    }
+
+    pub(super) fn type_check_member_access(
+        &mut self,
+        mut access: HirMemberAccess,
+        expr_id: ExprId,
+        lhs_type: Type,
+        span: Span,
+    ) -> Type {
+        let access_lhs = &mut access.lhs;
+
+        let dereference_lhs = |this: &mut Self, lhs_type, element| {
+            let old_lhs = *access_lhs;
+            *access_lhs = this.interner.push_expr(HirExpression::Prefix(HirPrefixExpression {
+                operator: crate::ast::UnaryOp::Dereference { implicitly_added: true },
+                rhs: old_lhs,
+            }));
+            this.interner.push_expr_type(old_lhs, lhs_type);
+            this.interner.push_expr_type(*access_lhs, element);
+
+            let old_location = this.interner.id_location(old_lhs);
+            this.interner.push_expr_location(*access_lhs, span, old_location.file);
+        };
+
+        // If this access is just a field offset, we want to avoid dereferencing
+        let dereference_lhs = (!access.is_offset).then_some(dereference_lhs);
+
+        match self.check_field_access(&lhs_type, &access.rhs.0.contents, span, dereference_lhs) {
+            Some((element_type, index)) => {
+                self.interner.set_field_index(expr_id, index);
+                // We must update `access` in case we added any dereferences to it
+                self.interner.replace_expr(&expr_id, HirExpression::MemberAccess(access));
+                element_type
+            }
+            None => Type::Error,
+        }
+    }
+
+    pub(super) fn lookup_method(
+        &mut self,
+        object_type: &Type,
+        method_name: &str,
+        span: Span,
+    ) -> Option<HirMethodReference> {
+        match object_type.follow_bindings() {
+            Type::Struct(typ, _args) => {
+                let id = typ.borrow().id;
+                match self.interner.lookup_method(object_type, id, method_name, false) {
+                    Some(method_id) => Some(HirMethodReference::FuncId(method_id)),
+                    None => {
+                        self.push_err(TypeCheckError::UnresolvedMethodCall {
+                            method_name: method_name.to_string(),
+                            object_type: object_type.clone(),
+                            span,
+                        });
+                        None
+                    }
+                }
+            }
+            // TODO: We should allow method calls on `impl Trait`s eventually.
+            //       For now it is fine since they are only allowed on return types.
+            Type::TraitAsType(..) => {
+                self.push_err(TypeCheckError::UnresolvedMethodCall {
+                    method_name: method_name.to_string(),
+                    object_type: object_type.clone(),
+                    span,
+                });
+                None
+            }
+            Type::NamedGeneric(_, _) => {
+                let func_meta = self.interner.function_meta(
+                    &self.current_function.expect("unexpected method outside a function"),
+                );
+
+                for constraint in &func_meta.trait_constraints {
+                    if *object_type == constraint.typ {
+                        if let Some(the_trait) = self.interner.try_get_trait(constraint.trait_id) {
+                            for (method_index, method) in the_trait.methods.iter().enumerate() {
+                                if method.name.0.contents == method_name {
+                                    let trait_method = TraitMethodId {
+                                        trait_id: constraint.trait_id,
+                                        method_index,
+                                    };
+                                    return Some(HirMethodReference::TraitMethodId(
+                                        trait_method,
+                                        constraint.trait_generics.clone(),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                self.push_err(TypeCheckError::UnresolvedMethodCall {
+                    method_name: method_name.to_string(),
+                    object_type: object_type.clone(),
+                    span,
+                });
+                None
+            }
+            // Mutable references to another type should resolve to methods of their element type.
+            // This may be a struct or a primitive type.
+            Type::MutableReference(element) => self
+                .interner
+                .lookup_primitive_trait_method_mut(element.as_ref(), method_name)
+                .map(HirMethodReference::FuncId)
+                .or_else(|| self.lookup_method(&element, method_name, span)),
+
+            // If we fail to resolve the object to a struct type, we have no way of type
+            // checking its arguments as we can't even resolve the name of the function
+            Type::Error => None,
+
+            // The type variable must be unbound at this point since follow_bindings was called
+            Type::TypeVariable(_, TypeVariableKind::Normal) => {
+                self.push_err(TypeCheckError::TypeAnnotationsNeeded { span });
+                None
+            }
+
+            other => match self.interner.lookup_primitive_method(&other, method_name) {
+                Some(method_id) => Some(HirMethodReference::FuncId(method_id)),
+                None => {
+                    self.push_err(TypeCheckError::UnresolvedMethodCall {
+                        method_name: method_name.to_string(),
+                        object_type: object_type.clone(),
+                        span,
+                    });
+                    None
+                }
+            },
+        }
+    }
+
+    pub(super) fn type_check_call(
+        &mut self,
+        call: &HirCallExpression,
+        func_type: Type,
+        args: Vec<(Type, ExprId, Span)>,
+        span: Span,
+    ) -> Type {
+        // Need to setup these flags here as `self` is borrowed mutably to type check the rest of the call expression
+        // These flags are later used to type check calls to unconstrained functions from constrained functions
+        let func_mod = self.current_function.map(|func| self.interner.function_modifiers(&func));
+        let is_current_func_constrained =
+            func_mod.map_or(true, |func_mod| !func_mod.is_unconstrained);
+
+        let is_unconstrained_call = self.is_unconstrained_call(call.func);
+        self.check_if_deprecated(call.func);
+
+        // Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime
+        if is_current_func_constrained && is_unconstrained_call {
+            for (typ, _, _) in args.iter() {
+                if matches!(&typ.follow_bindings(), Type::MutableReference(_)) {
+                    self.push_err(TypeCheckError::ConstrainedReferenceToUnconstrained { span });
+                }
+            }
+        }
+
+        let return_type = self.bind_function_type(func_type, args, span);
+
+        // Check that we are not passing a slice from an unconstrained runtime to a constrained runtime
+        if is_current_func_constrained && is_unconstrained_call {
+            if return_type.contains_slice() {
+                self.push_err(TypeCheckError::UnconstrainedSliceReturnToConstrained { span });
+            } else if matches!(&return_type.follow_bindings(), Type::MutableReference(_)) {
+                self.push_err(TypeCheckError::UnconstrainedReferenceToConstrained { span });
+            }
+        };
+
+        return_type
+    }
+
+    fn check_if_deprecated(&mut self, expr: ExprId) {
+        if let HirExpression::Ident(HirIdent { location, id, impl_kind: _ }) =
+            self.interner.expression(&expr)
+        {
+            if let Some(DefinitionKind::Function(func_id)) =
+                self.interner.try_definition(id).map(|def| &def.kind)
+            {
+                let attributes = self.interner.function_attributes(func_id);
+                if let Some(note) = attributes.get_deprecated_note() {
+                    self.push_err(TypeCheckError::CallDeprecated {
+                        name: self.interner.definition_name(id).to_string(),
+                        note,
+                        span: location.span,
+                    });
+                }
+            }
+        }
+    }
+
+    fn is_unconstrained_call(&self, expr: ExprId) -> bool {
+        if let HirExpression::Ident(HirIdent { id, .. }) = self.interner.expression(&expr) {
+            if let Some(DefinitionKind::Function(func_id)) =
+                self.interner.try_definition(id).map(|def| &def.kind)
+            {
+                let modifiers = self.interner.function_modifiers(func_id);
+                return modifiers.is_unconstrained;
+            }
+        }
+        false
+    }
+
+    /// Check if the given method type requires a mutable reference to the object type, and check
+    /// if the given object type is already a mutable reference. If not, add one.
+    /// This is used to automatically transform a method call: `foo.bar()` into a function
+    /// call: `bar(&mut foo)`.
+    ///
+    /// A notable corner case of this function is where it interacts with auto-deref of `.`.
+    /// If a field is being mutated e.g. `foo.bar.mutate_bar()` where `foo: &mut Foo`, the compiler
+    /// will insert a dereference before bar `(*foo).bar.mutate_bar()` which would cause us to
+    /// mutate a copy of bar rather than a reference to it. We must check for this corner case here
+    /// and remove the implicitly added dereference operator if we find one.
+    pub(super) fn try_add_mutable_reference_to_object(
+        &mut self,
+        function_type: &Type,
+        object_type: &mut Type,
+        object: &mut ExprId,
+    ) {
+        let expected_object_type = match function_type {
+            Type::Function(args, _, _) => args.first(),
+            Type::Forall(_, typ) => match typ.as_ref() {
+                Type::Function(args, _, _) => args.first(),
+                typ => unreachable!("Unexpected type for function: {typ}"),
+            },
+            typ => unreachable!("Unexpected type for function: {typ}"),
+        };
+
+        if let Some(expected_object_type) = expected_object_type {
+            let actual_type = object_type.follow_bindings();
+
+            if matches!(expected_object_type.follow_bindings(), Type::MutableReference(_)) {
+                if !matches!(actual_type, Type::MutableReference(_)) {
+                    if let Err(error) = verify_mutable_reference(&self.interner, *object) {
+                        self.push_err(TypeCheckError::ResolverError(error));
+                    }
+
+                    let new_type = Type::MutableReference(Box::new(actual_type));
+                    *object_type = new_type.clone();
+
+                    // First try to remove a dereference operator that may have been implicitly
+                    // inserted by a field access expression `foo.bar` on a mutable reference `foo`.
+                    let new_object = self.try_remove_implicit_dereference(*object);
+
+                    // If that didn't work, then wrap the whole expression in an `&mut`
+                    *object = new_object.unwrap_or_else(|| {
+                        let location = self.interner.id_location(*object);
+
+                        let new_object =
+                            self.interner.push_expr(HirExpression::Prefix(HirPrefixExpression {
+                                operator: UnaryOp::MutableReference,
+                                rhs: *object,
+                            }));
+                        self.interner.push_expr_type(new_object, new_type);
+                        self.interner.push_expr_location(new_object, location.span, location.file);
+                        new_object
+                    });
+                }
+            // Otherwise if the object type is a mutable reference and the method is not, insert as
+            // many dereferences as needed.
+            } else if matches!(actual_type, Type::MutableReference(_)) {
+                let (new_object, new_type) = self.insert_auto_dereferences(*object, actual_type);
+                *object_type = new_type;
+                *object = new_object;
+            }
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index 8850331f683..343113836ed 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -2,11 +2,14 @@ use noirc_errors::{CustomDiagnostic, Span};
 use thiserror::Error;
 
 use crate::graph::CrateId;
+use crate::hir::def_collector::dc_crate::CompilationError;
 use std::collections::BTreeMap;
 
 use crate::ast::{Ident, ItemVisibility, Path, PathKind};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleDefId, ModuleId, PerNs};
 
+use super::errors::ResolverError;
+
 #[derive(Debug, Clone)]
 pub struct ImportDirective {
     pub module_id: LocalModuleId,
@@ -53,6 +56,12 @@ pub struct ResolvedImport {
     pub error: Option<PathResolutionError>,
 }
 
+impl From<PathResolutionError> for CompilationError {
+    fn from(error: PathResolutionError) -> Self {
+        Self::ResolverError(ResolverError::PathResolutionError(error))
+    }
+}
+
 impl<'a> From<&'a PathResolutionError> for CustomDiagnostic {
     fn from(error: &'a PathResolutionError) -> Self {
         match &error {
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 60baaecab59..7dc307fe716 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -56,17 +56,17 @@ use crate::hir_def::{
 use super::errors::{PubPosition, ResolverError};
 use super::import::PathResolution;
 
-const SELF_TYPE_NAME: &str = "Self";
+pub const SELF_TYPE_NAME: &str = "Self";
 
 type Scope = GenericScope<String, ResolverMeta>;
 type ScopeTree = GenericScopeTree<String, ResolverMeta>;
 type ScopeForest = GenericScopeForest<String, ResolverMeta>;
 
 pub struct LambdaContext {
-    captures: Vec<HirCapturedVar>,
+    pub captures: Vec<HirCapturedVar>,
     /// the index in the scope tree
     /// (sometimes being filled by ScopeTree's find method)
-    scope_index: usize,
+    pub scope_index: usize,
 }
 
 /// The primary jobs of the Resolver are to validate that every variable found refers to exactly 1
@@ -1345,7 +1345,7 @@ impl<'a> Resolver<'a> {
                     range @ ForRange::Array(_) => {
                         let for_stmt =
                             range.into_for(for_loop.identifier, for_loop.block, for_loop.span);
-                        self.resolve_stmt(for_stmt, for_loop.span)
+                        self.resolve_stmt(for_stmt.kind, for_loop.span)
                     }
                 }
             }
@@ -1361,7 +1361,7 @@ impl<'a> Resolver<'a> {
             StatementKind::Comptime(statement) => {
                 let hir_statement = self.resolve_stmt(statement.kind, statement.span);
                 let statement_id = self.interner.push_stmt(hir_statement);
-                self.interner.push_statement_location(statement_id, statement.span, self.file);
+                self.interner.push_stmt_location(statement_id, statement.span, self.file);
                 HirStatement::Comptime(statement_id)
             }
         }
@@ -1370,7 +1370,7 @@ impl<'a> Resolver<'a> {
     pub fn intern_stmt(&mut self, stmt: Statement) -> StmtId {
         let hir_stmt = self.resolve_stmt(stmt.kind, stmt.span);
         let id = self.interner.push_stmt(hir_stmt);
-        self.interner.push_statement_location(id, stmt.span, self.file);
+        self.interner.push_stmt_location(id, stmt.span, self.file);
         id
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 9b40c959981..48598109829 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -250,14 +250,14 @@ impl<'interner> TypeChecker<'interner> {
                         }
 
                         // TODO: update object_type here?
-                        let function_call = method_call.into_function_call(
+                        let (_, function_call) = method_call.into_function_call(
                             &method_ref,
                             object_type,
                             location,
                             self.interner,
                         );
 
-                        self.interner.replace_expr(expr_id, function_call);
+                        self.interner.replace_expr(expr_id, HirExpression::Call(function_call));
 
                         // Type check the new call now that it has been changed from a method call
                         // to a function call. This way we avoid duplicating code.
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 0f8131d6ebb..2e448858d9e 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -25,7 +25,7 @@ use crate::{
     Type, TypeBindings,
 };
 
-use self::errors::Source;
+pub use self::errors::Source;
 
 pub struct TypeChecker<'interner> {
     interner: &'interner mut NodeInterner,
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index bf7d9b7b4ba..8df6785e0eb 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -200,13 +200,15 @@ pub enum HirMethodReference {
 
 impl HirMethodCallExpression {
     /// Converts a method call into a function call
+    ///
+    /// Returns ((func_var_id, func_var), call_expr)
     pub fn into_function_call(
         mut self,
         method: &HirMethodReference,
         object_type: Type,
         location: Location,
         interner: &mut NodeInterner,
-    ) -> HirExpression {
+    ) -> ((ExprId, HirIdent), HirCallExpression) {
         let mut arguments = vec![self.object];
         arguments.append(&mut self.arguments);
 
@@ -224,10 +226,11 @@ impl HirMethodCallExpression {
                 (id, ImplKind::TraitMethod(*method_id, constraint, false))
             }
         };
-        let func = HirExpression::Ident(HirIdent { location, id, impl_kind });
-        let func = interner.push_expr(func);
+        let func_var = HirIdent { location, id, impl_kind };
+        let func = interner.push_expr(HirExpression::Ident(func_var.clone()));
         interner.push_expr_location(func, location.span, location.file);
-        HirExpression::Call(HirCallExpression { func, arguments, location })
+        let expr = HirCallExpression { func, arguments, location };
+        ((func, func_var), expr)
     }
 }
 
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index f3b2a24c1f0..f31aeea0552 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -1423,14 +1423,14 @@ impl Type {
 
     /// Retrieves the type of the given field name
     /// Panics if the type is not a struct or tuple.
-    pub fn get_field_type(&self, field_name: &str) -> Type {
+    pub fn get_field_type(&self, field_name: &str) -> Option<Type> {
         match self {
-            Type::Struct(def, args) => def.borrow().get_field(field_name, args).unwrap().0,
+            Type::Struct(def, args) => def.borrow().get_field(field_name, args).map(|(typ, _)| typ),
             Type::Tuple(fields) => {
                 let mut fields = fields.iter().enumerate();
-                fields.find(|(i, _)| i.to_string() == *field_name).unwrap().1.clone()
+                fields.find(|(i, _)| i.to_string() == *field_name).map(|(_, typ)| typ).cloned()
             }
-            other => panic!("Tried to iterate over the fields of '{other}', which has none"),
+            _ => None,
         }
     }
 
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 958a18ac2fb..b05c635f436 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -12,6 +12,7 @@
 
 pub mod ast;
 pub mod debug;
+pub mod elaborator;
 pub mod graph;
 pub mod lexer;
 pub mod monomorphization;
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 88adc7a9414..faf89016f96 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -532,7 +532,7 @@ impl NodeInterner {
         self.id_to_type.insert(expr_id.into(), typ);
     }
 
-    /// Store the type for an interned expression
+    /// Store the type for a definition
     pub fn push_definition_type(&mut self, definition_id: DefinitionId, typ: Type) {
         self.definition_to_type.insert(definition_id, typ);
     }
@@ -696,7 +696,7 @@ impl NodeInterner {
         let statement = self.push_stmt(HirStatement::Error);
         let span = name.span();
         let id = self.push_global(name, local_id, statement, file, attributes, mutable);
-        self.push_statement_location(statement, span, file);
+        self.push_stmt_location(statement, span, file);
         id
     }
 
@@ -942,7 +942,7 @@ impl NodeInterner {
         self.id_location(stmt_id)
     }
 
-    pub fn push_statement_location(&mut self, id: StmtId, span: Span, file: FileId) {
+    pub fn push_stmt_location(&mut self, id: StmtId, span: Span, file: FileId) {
         self.id_to_location.insert(id.into(), Location::new(span, file));
     }
 

From c8b70accd899cfa57c983a4b65231b2f56e4b48e Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 9 May 2024 14:33:07 -0500
Subject: [PATCH 268/416] chore(experimental): Add compiler option to enable
 the Elaborator (#5003)

# Description

## Problem\*

Working towards #4594

## Summary\*

Adds a hidden compiler option `--use-elaborator` to enable the
experimental elaborator code to be run on a codebase.

This also connects the elaborator with `dc_crate` (and thus the cli flag
above) by filling in the stub for elaborating functions. Filling in the
stub required quite a bit of code but it was as usual just copied from
name resolution and type checking.

## Additional Context

Originally I wanted to connect the elaborator to more of the frontend
(e.g. resolve globals, types, traits, etc) but this already ballooned to
a large line count. To review I'd recommend reviewing the non-elaborator
portions first then just skimming through the elaborator portions since
they are copied from `Resolver::resolve_function`,
`Resolver::extract_meta`, `Resolver::intern_function`, and
`type_check_func`.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_driver/src/lib.rs              |  25 +-
 .../noirc_driver/tests/stdlib_warnings.rs     |   3 +-
 compiler/noirc_frontend/src/ast/function.rs   |   9 +
 .../src/elaborator/expressions.rs             |   6 +-
 compiler/noirc_frontend/src/elaborator/mod.rs | 669 +++++++++++++++++-
 .../noirc_frontend/src/elaborator/patterns.rs |  18 +-
 .../noirc_frontend/src/elaborator/scope.rs    | 106 ++-
 .../src/elaborator/statements.rs              |   4 +-
 .../noirc_frontend/src/elaborator/types.rs    | 191 +++--
 .../src/hir/def_collector/dc_crate.rs         | 104 +--
 .../src/hir/def_collector/dc_mod.rs           |  16 +-
 .../noirc_frontend/src/hir/def_map/mod.rs     |  10 +-
 .../noirc_frontend/src/hir_def/function.rs    |   5 +-
 compiler/noirc_frontend/src/tests.rs          |   1 +
 tooling/lsp/src/lib.rs                        |   2 +-
 tooling/lsp/src/notifications/mod.rs          |   4 +-
 tooling/lsp/src/requests/code_lens_request.rs |   2 +-
 tooling/lsp/src/requests/goto_declaration.rs  |   2 +-
 tooling/lsp/src/requests/goto_definition.rs   |   2 +-
 tooling/lsp/src/requests/test_run.rs          |   2 +-
 tooling/lsp/src/requests/tests.rs             |   2 +-
 tooling/nargo_cli/src/cli/check_cmd.rs        |   4 +-
 tooling/nargo_cli/src/cli/export_cmd.rs       |   1 +
 tooling/nargo_cli/src/cli/test_cmd.rs         |   2 +
 tooling/nargo_cli/tests/stdlib-tests.rs       |  17 +-
 25 files changed, 1015 insertions(+), 192 deletions(-)

diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 5f1985b0553..801c0b685a9 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -103,6 +103,10 @@ pub struct CompileOptions {
     /// Force Brillig output (for step debugging)
     #[arg(long, hide = true)]
     pub force_brillig: bool,
+
+    /// Enable the experimental elaborator pass
+    #[arg(long, hide = true)]
+    pub use_elaborator: bool,
 }
 
 fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
@@ -245,12 +249,13 @@ pub fn check_crate(
     crate_id: CrateId,
     deny_warnings: bool,
     disable_macros: bool,
+    use_elaborator: bool,
 ) -> CompilationResult<()> {
     let macros: &[&dyn MacroProcessor] =
         if disable_macros { &[] } else { &[&aztec_macros::AztecMacro as &dyn MacroProcessor] };
 
     let mut errors = vec![];
-    let diagnostics = CrateDefMap::collect_defs(crate_id, context, macros);
+    let diagnostics = CrateDefMap::collect_defs(crate_id, context, use_elaborator, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
         let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
@@ -282,8 +287,13 @@ pub fn compile_main(
     options: &CompileOptions,
     cached_program: Option<CompiledProgram>,
 ) -> CompilationResult<CompiledProgram> {
-    let (_, mut warnings) =
-        check_crate(context, crate_id, options.deny_warnings, options.disable_macros)?;
+    let (_, mut warnings) = check_crate(
+        context,
+        crate_id,
+        options.deny_warnings,
+        options.disable_macros,
+        options.use_elaborator,
+    )?;
 
     let main = context.get_main_function(&crate_id).ok_or_else(|| {
         // TODO(#2155): This error might be a better to exist in Nargo
@@ -318,8 +328,13 @@ pub fn compile_contract(
     crate_id: CrateId,
     options: &CompileOptions,
 ) -> CompilationResult<CompiledContract> {
-    let (_, warnings) =
-        check_crate(context, crate_id, options.deny_warnings, options.disable_macros)?;
+    let (_, warnings) = check_crate(
+        context,
+        crate_id,
+        options.deny_warnings,
+        options.disable_macros,
+        options.use_elaborator,
+    )?;
 
     // TODO: We probably want to error if contracts is empty
     let contracts = context.get_all_contracts(&crate_id);
diff --git a/compiler/noirc_driver/tests/stdlib_warnings.rs b/compiler/noirc_driver/tests/stdlib_warnings.rs
index 6f437621123..327c8daad06 100644
--- a/compiler/noirc_driver/tests/stdlib_warnings.rs
+++ b/compiler/noirc_driver/tests/stdlib_warnings.rs
@@ -24,7 +24,8 @@ fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings>
     let mut context = Context::new(file_manager, parsed_files);
     let root_crate_id = prepare_crate(&mut context, file_name);
 
-    let ((), warnings) = noirc_driver::check_crate(&mut context, root_crate_id, false, false)?;
+    let ((), warnings) =
+        noirc_driver::check_crate(&mut context, root_crate_id, false, false, false)?;
 
     assert_eq!(warnings, Vec::new(), "stdlib is producing warnings");
 
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index dc426a4642a..8acc068d86a 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -32,6 +32,15 @@ pub enum FunctionKind {
     Recursive,
 }
 
+impl FunctionKind {
+    pub fn can_ignore_return_type(self) -> bool {
+        match self {
+            FunctionKind::LowLevel | FunctionKind::Builtin | FunctionKind::Oracle => true,
+            FunctionKind::Normal | FunctionKind::Recursive => false,
+        }
+    }
+}
+
 impl NoirFunction {
     pub fn normal(def: FunctionDefinition) -> NoirFunction {
         NoirFunction { kind: FunctionKind::Normal, def }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 19ee67b442c..ed8ed5305d1 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -32,7 +32,7 @@ use crate::{
 
 use super::Elaborator;
 
-impl Elaborator {
+impl<'context> Elaborator<'context> {
     pub(super) fn elaborate_expression(&mut self, expr: Expression) -> (ExprId, Type) {
         let (hir_expr, typ) = match expr.kind {
             ExpressionKind::Literal(literal) => self.elaborate_literal(literal, expr.span),
@@ -323,7 +323,7 @@ impl Elaborator {
                     &method_ref,
                     object_type,
                     location,
-                    &mut self.interner,
+                    self.interner,
                 );
 
                 let func_type = self.type_check_variable(function_name, function_id);
@@ -443,7 +443,7 @@ impl Elaborator {
         (expr_id, typ)
     }
 
-    fn intern_expr(&mut self, expr: HirExpression, span: Span) -> ExprId {
+    pub fn intern_expr(&mut self, expr: HirExpression, span: Span) -> ExprId {
         let id = self.interner.push_expr(expr);
         self.interner.push_expr_location(id, span, self.file);
         id
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 9a34fa847f5..446e5b62ead 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -4,7 +4,6 @@ use std::{
     rc::Rc,
 };
 
-use crate::graph::CrateId;
 use crate::hir::def_map::CrateDefMap;
 use crate::{
     ast::{
@@ -35,6 +34,28 @@ use crate::{
     node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, StmtId, TraitId},
     Shared, StructType, Type, TypeVariable,
 };
+use crate::{
+    ast::{TraitBound, UnresolvedGenerics},
+    graph::CrateId,
+    hir::{
+        def_collector::{
+            dc_crate::{CollectedItems, DefCollector},
+            errors::DefCollectorErrorKind,
+        },
+        def_map::{LocalModuleId, ModuleDefId, ModuleId, MAIN_FUNCTION},
+        resolution::{
+            errors::PubPosition,
+            import::{PathResolution, PathResolutionError},
+            path_resolver::StandardPathResolver,
+        },
+        Context,
+    },
+    hir_def::function::{FuncMeta, HirFunction},
+    macros_api::{Param, Path, UnresolvedType, UnresolvedTypeData, Visibility},
+    node_interner::TraitImplId,
+    token::FunctionAttribute,
+    Generics,
+};
 
 mod expressions;
 mod patterns;
@@ -50,7 +71,7 @@ use rustc_hash::FxHashSet as HashSet;
 
 /// ResolverMetas are tagged onto each definition to track how many times they are used
 #[derive(Debug, PartialEq, Eq)]
-struct ResolverMeta {
+pub struct ResolverMeta {
     num_times_used: usize,
     ident: HirIdent,
     warn_if_unused: bool,
@@ -58,12 +79,15 @@ struct ResolverMeta {
 
 type ScopeForest = GenericScopeForest<String, ResolverMeta>;
 
-struct Elaborator {
+pub struct Elaborator<'context> {
     scopes: ScopeForest,
 
-    errors: Vec<CompilationError>,
+    errors: Vec<(CompilationError, FileId)>,
+
+    interner: &'context mut NodeInterner,
+
+    def_maps: &'context BTreeMap<CrateId, CrateDefMap>,
 
-    interner: NodeInterner,
     file: FileId,
 
     in_unconstrained_fn: bool,
@@ -95,10 +119,11 @@ struct Elaborator {
     /// Used to link items to their dependencies in the dependency graph
     current_item: Option<DependencyId>,
 
-    trait_id: Option<TraitId>,
+    /// If we're currently resolving methods within a trait impl, this will be set
+    /// to the corresponding trait impl ID.
+    current_trait_impl: Option<TraitImplId>,
 
-    path_resolver: Rc<dyn PathResolver>,
-    def_maps: BTreeMap<CrateId, CrateDefMap>,
+    trait_id: Option<TraitId>,
 
     /// In-resolution names
     ///
@@ -129,31 +154,629 @@ struct Elaborator {
     /// on each variable, but it is only until function calls when the types
     /// needed for the trait constraint may become known.
     trait_constraints: Vec<(TraitConstraint, ExprId)>,
+
+    /// The current module this elaborator is in.
+    /// Initially empty, it is set whenever a new top-level item is resolved.
+    local_module: LocalModuleId,
+
+    crate_id: CrateId,
 }
 
-impl Elaborator {
-    fn elaborate_function(&mut self, function: NoirFunction, _id: FuncId) {
-        // This is a stub until the elaborator is connected to dc_crate
-        match function.kind {
-            FunctionKind::LowLevel => todo!(),
-            FunctionKind::Builtin => todo!(),
-            FunctionKind::Oracle => todo!(),
-            FunctionKind::Recursive => todo!(),
-            FunctionKind::Normal => {
-                let _body = self.elaborate_block(function.def.body);
+impl<'context> Elaborator<'context> {
+    pub fn new(context: &'context mut Context, crate_id: CrateId) -> Self {
+        Self {
+            scopes: ScopeForest::default(),
+            errors: Vec::new(),
+            interner: &mut context.def_interner,
+            def_maps: &context.def_maps,
+            file: FileId::dummy(),
+            in_unconstrained_fn: false,
+            nested_loops: 0,
+            in_contract: false,
+            generics: Vec::new(),
+            lambda_stack: Vec::new(),
+            self_type: None,
+            current_item: None,
+            trait_id: None,
+            local_module: LocalModuleId::dummy_id(),
+            crate_id,
+            resolving_ids: BTreeSet::new(),
+            trait_bounds: Vec::new(),
+            current_function: None,
+            type_variables: Vec::new(),
+            trait_constraints: Vec::new(),
+            current_trait_impl: None,
+        }
+    }
+
+    pub fn elaborate(
+        context: &'context mut Context,
+        crate_id: CrateId,
+        items: CollectedItems,
+    ) -> Vec<(CompilationError, FileId)> {
+        let mut this = Self::new(context, crate_id);
+
+        // the resolver filters literal globals first
+        for global in items.globals {}
+
+        for alias in items.type_aliases {}
+
+        for trait_ in items.traits {}
+
+        for struct_ in items.types {}
+
+        for trait_impl in &items.trait_impls {
+            // only collect now
+        }
+
+        for impl_ in &items.impls {
+            // only collect now
+        }
+
+        // resolver resolves non-literal globals here
+
+        for functions in items.functions {
+            this.file = functions.file_id;
+            this.trait_id = functions.trait_id; // TODO: Resolve?
+            for (local_module, id, func) in functions.functions {
+                this.local_module = local_module;
+                this.elaborate_function(func, id);
+            }
+        }
+
+        for impl_ in items.impls {}
+
+        for trait_impl in items.trait_impls {}
+
+        let cycle_errors = this.interner.check_for_dependency_cycles();
+        this.errors.extend(cycle_errors);
+
+        this.errors
+    }
+
+    fn elaborate_function(&mut self, mut function: NoirFunction, id: FuncId) {
+        self.current_function = Some(id);
+        self.resolve_where_clause(&mut function.def.where_clause);
+
+        // Without this, impl methods can accidentally be placed in contracts. See #3254
+        if self.self_type.is_some() {
+            self.in_contract = false;
+        }
+
+        self.scopes.start_function();
+        self.current_item = Some(DependencyId::Function(id));
+
+        // Check whether the function has globals in the local module and add them to the scope
+        self.resolve_local_globals();
+        self.add_generics(&function.def.generics);
+
+        self.desugar_impl_trait_args(&mut function, id);
+        self.trait_bounds = function.def.where_clause.clone();
+
+        let is_low_level_or_oracle = function
+            .attributes()
+            .function
+            .as_ref()
+            .map_or(false, |func| func.is_low_level() || func.is_oracle());
+
+        if function.def.is_unconstrained {
+            self.in_unconstrained_fn = true;
+        }
+
+        let func_meta = self.extract_meta(&function, id);
+
+        self.add_trait_constraints_to_scope(&func_meta);
+
+        let (hir_func, body_type) = match function.kind {
+            FunctionKind::Builtin | FunctionKind::LowLevel | FunctionKind::Oracle => {
+                (HirFunction::empty(), Type::Error)
+            }
+            FunctionKind::Normal | FunctionKind::Recursive => {
+                let block_span = function.def.span;
+                let (block, body_type) = self.elaborate_block(function.def.body);
+                let expr_id = self.intern_expr(block, block_span);
+                self.interner.push_expr_type(expr_id, body_type.clone());
+                (HirFunction::unchecked_from_expr(expr_id), body_type)
             }
+        };
+
+        if !func_meta.can_ignore_return_type() {
+            self.type_check_function_body(body_type, &func_meta, hir_func.as_expr());
+        }
+
+        // Default any type variables that still need defaulting.
+        // This is done before trait impl search since leaving them bindable can lead to errors
+        // when multiple impls are available. Instead we default first to choose the Field or u64 impl.
+        for typ in &self.type_variables {
+            if let Type::TypeVariable(variable, kind) = typ.follow_bindings() {
+                let msg = "TypeChecker should only track defaultable type vars";
+                variable.bind(kind.default_type().expect(msg));
+            }
+        }
+
+        // Verify any remaining trait constraints arising from the function body
+        for (constraint, expr_id) in std::mem::take(&mut self.trait_constraints) {
+            let span = self.interner.expr_span(&expr_id);
+            self.verify_trait_constraint(
+                &constraint.typ,
+                constraint.trait_id,
+                &constraint.trait_generics,
+                expr_id,
+                span,
+            );
+        }
+
+        // Now remove all the `where` clause constraints we added
+        for constraint in &func_meta.trait_constraints {
+            self.interner.remove_assumed_trait_implementations_for_trait(constraint.trait_id);
+        }
+
+        let func_scope_tree = self.scopes.end_function();
+
+        // The arguments to low-level and oracle functions are always unused so we do not produce warnings for them.
+        if !is_low_level_or_oracle {
+            self.check_for_unused_variables_in_scope_tree(func_scope_tree);
         }
+
+        self.trait_bounds.clear();
+
+        self.interner.push_fn_meta(func_meta, id);
+        self.interner.update_fn(id, hir_func);
+        self.current_function = None;
     }
 
-    fn push_scope(&mut self) {
-        // stub
+    /// This turns function parameters of the form:
+    /// fn foo(x: impl Bar)
+    ///
+    /// into
+    /// fn foo<T0_impl_Bar>(x: T0_impl_Bar) where T0_impl_Bar: Bar
+    fn desugar_impl_trait_args(&mut self, func: &mut NoirFunction, func_id: FuncId) {
+        let mut impl_trait_generics = HashSet::default();
+        let mut counter: usize = 0;
+        for parameter in func.def.parameters.iter_mut() {
+            if let UnresolvedTypeData::TraitAsType(path, args) = &parameter.typ.typ {
+                let mut new_generic_ident: Ident =
+                    format!("T{}_impl_{}", func_id, path.as_string()).into();
+                let mut new_generic_path = Path::from_ident(new_generic_ident.clone());
+                while impl_trait_generics.contains(&new_generic_ident)
+                    || self.lookup_generic_or_global_type(&new_generic_path).is_some()
+                {
+                    new_generic_ident =
+                        format!("T{}_impl_{}_{}", func_id, path.as_string(), counter).into();
+                    new_generic_path = Path::from_ident(new_generic_ident.clone());
+                    counter += 1;
+                }
+                impl_trait_generics.insert(new_generic_ident.clone());
+
+                let is_synthesized = true;
+                let new_generic_type_data =
+                    UnresolvedTypeData::Named(new_generic_path, vec![], is_synthesized);
+                let new_generic_type =
+                    UnresolvedType { typ: new_generic_type_data.clone(), span: None };
+                let new_trait_bound = TraitBound {
+                    trait_path: path.clone(),
+                    trait_id: None,
+                    trait_generics: args.to_vec(),
+                };
+                let new_trait_constraint = UnresolvedTraitConstraint {
+                    typ: new_generic_type,
+                    trait_bound: new_trait_bound,
+                };
+
+                parameter.typ.typ = new_generic_type_data;
+                func.def.generics.push(new_generic_ident);
+                func.def.where_clause.push(new_trait_constraint);
+            }
+        }
+        self.add_generics(&impl_trait_generics.into_iter().collect());
     }
 
-    fn pop_scope(&mut self) {
-        // stub
+    /// Add the given generics to scope.
+    /// Each generic will have a fresh Shared<TypeBinding> associated with it.
+    pub fn add_generics(&mut self, generics: &UnresolvedGenerics) -> Generics {
+        vecmap(generics, |generic| {
+            // Map the generic to a fresh type variable
+            let id = self.interner.next_type_variable_id();
+            let typevar = TypeVariable::unbound(id);
+            let span = generic.0.span();
+
+            // Check for name collisions of this generic
+            let name = Rc::new(generic.0.contents.clone());
+
+            if let Some((_, _, first_span)) = self.find_generic(&name) {
+                self.push_err(ResolverError::DuplicateDefinition {
+                    name: generic.0.contents.clone(),
+                    first_span: *first_span,
+                    second_span: span,
+                });
+            } else {
+                self.generics.push((name, typevar.clone(), span));
+            }
+
+            typevar
+        })
     }
 
     fn push_err(&mut self, error: impl Into<CompilationError>) {
-        self.errors.push(error.into());
+        self.errors.push((error.into(), self.file));
+    }
+
+    fn resolve_where_clause(&mut self, clause: &mut [UnresolvedTraitConstraint]) {
+        for bound in clause {
+            if let Some(trait_id) = self.resolve_trait_by_path(bound.trait_bound.trait_path.clone())
+            {
+                bound.trait_bound.trait_id = Some(trait_id);
+            }
+        }
+    }
+
+    fn resolve_trait_by_path(&mut self, path: Path) -> Option<TraitId> {
+        let path_resolver = StandardPathResolver::new(self.module_id());
+
+        let error = match path_resolver.resolve(self.def_maps, path.clone()) {
+            Ok(PathResolution { module_def_id: ModuleDefId::TraitId(trait_id), error }) => {
+                if let Some(error) = error {
+                    self.push_err(error);
+                }
+                return Some(trait_id);
+            }
+            Ok(_) => DefCollectorErrorKind::NotATrait { not_a_trait_name: path },
+            Err(_) => DefCollectorErrorKind::TraitNotFound { trait_path: path },
+        };
+        self.push_err(error);
+        None
+    }
+
+    fn resolve_local_globals(&mut self) {
+        let globals = vecmap(self.interner.get_all_globals(), |global| {
+            (global.id, global.local_id, global.ident.clone())
+        });
+        for (id, local_module_id, name) in globals {
+            if local_module_id == self.local_module {
+                let definition = DefinitionKind::Global(id);
+                self.add_global_variable_decl(name, definition);
+            }
+        }
+    }
+
+    /// TODO: This is currently only respected for generic free functions
+    /// there's a bunch of other places where trait constraints can pop up
+    fn resolve_trait_constraints(
+        &mut self,
+        where_clause: &[UnresolvedTraitConstraint],
+    ) -> Vec<TraitConstraint> {
+        where_clause
+            .iter()
+            .cloned()
+            .filter_map(|constraint| self.resolve_trait_constraint(constraint))
+            .collect()
+    }
+
+    pub fn resolve_trait_constraint(
+        &mut self,
+        constraint: UnresolvedTraitConstraint,
+    ) -> Option<TraitConstraint> {
+        let typ = self.resolve_type(constraint.typ);
+        let trait_generics =
+            vecmap(constraint.trait_bound.trait_generics, |typ| self.resolve_type(typ));
+
+        let span = constraint.trait_bound.trait_path.span();
+        let the_trait = self.lookup_trait_or_error(constraint.trait_bound.trait_path)?;
+        let trait_id = the_trait.id;
+
+        let expected_generics = the_trait.generics.len();
+        let actual_generics = trait_generics.len();
+
+        if actual_generics != expected_generics {
+            let item_name = the_trait.name.to_string();
+            self.push_err(ResolverError::IncorrectGenericCount {
+                span,
+                item_name,
+                actual: actual_generics,
+                expected: expected_generics,
+            });
+        }
+
+        Some(TraitConstraint { typ, trait_id, trait_generics })
+    }
+
+    /// Extract metadata from a NoirFunction
+    /// to be used in analysis and intern the function parameters
+    /// Prerequisite: self.add_generics() has already been called with the given
+    /// function's generics, including any generics from the impl, if any.
+    fn extract_meta(&mut self, func: &NoirFunction, func_id: FuncId) -> FuncMeta {
+        let location = Location::new(func.name_ident().span(), self.file);
+        let id = self.interner.function_definition_id(func_id);
+        let name_ident = HirIdent::non_trait_method(id, location);
+
+        let attributes = func.attributes().clone();
+        let has_no_predicates_attribute = attributes.is_no_predicates();
+        let should_fold = attributes.is_foldable();
+        if !self.inline_attribute_allowed(func) {
+            if has_no_predicates_attribute {
+                self.push_err(ResolverError::NoPredicatesAttributeOnUnconstrained {
+                    ident: func.name_ident().clone(),
+                });
+            } else if should_fold {
+                self.push_err(ResolverError::FoldAttributeOnUnconstrained {
+                    ident: func.name_ident().clone(),
+                });
+            }
+        }
+        // Both the #[fold] and #[no_predicates] alter a function's inline type and code generation in similar ways.
+        // In certain cases such as type checking (for which the following flag will be used) both attributes
+        // indicate we should code generate in the same way. Thus, we unify the attributes into one flag here.
+        let has_inline_attribute = has_no_predicates_attribute || should_fold;
+        let is_entry_point = self.is_entry_point_function(func);
+
+        let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
+        let mut parameters = vec![];
+        let mut parameter_types = vec![];
+
+        for Param { visibility, pattern, typ, span: _ } in func.parameters().iter().cloned() {
+            if visibility == Visibility::Public && !self.pub_allowed(func) {
+                self.push_err(ResolverError::UnnecessaryPub {
+                    ident: func.name_ident().clone(),
+                    position: PubPosition::Parameter,
+                });
+            }
+
+            let type_span = typ.span.unwrap_or_else(|| pattern.span());
+            let typ = self.resolve_type_inner(typ, &mut generics);
+            self.check_if_type_is_valid_for_program_input(
+                &typ,
+                is_entry_point,
+                has_inline_attribute,
+                type_span,
+            );
+            let pattern = self.elaborate_pattern(pattern, typ.clone(), DefinitionKind::Local(None));
+
+            parameters.push((pattern, typ.clone(), visibility));
+            parameter_types.push(typ);
+        }
+
+        let return_type = Box::new(self.resolve_type(func.return_type()));
+
+        self.declare_numeric_generics(&parameter_types, &return_type);
+
+        if !self.pub_allowed(func) && func.def.return_visibility == Visibility::Public {
+            self.push_err(ResolverError::UnnecessaryPub {
+                ident: func.name_ident().clone(),
+                position: PubPosition::ReturnType,
+            });
+        }
+
+        let is_low_level_function =
+            attributes.function.as_ref().map_or(false, |func| func.is_low_level());
+
+        if !self.crate_id.is_stdlib() && is_low_level_function {
+            let error =
+                ResolverError::LowLevelFunctionOutsideOfStdlib { ident: func.name_ident().clone() };
+            self.push_err(error);
+        }
+
+        // 'pub' is required on return types for entry point functions
+        if is_entry_point
+            && return_type.as_ref() != &Type::Unit
+            && func.def.return_visibility == Visibility::Private
+        {
+            self.push_err(ResolverError::NecessaryPub { ident: func.name_ident().clone() });
+        }
+        // '#[recursive]' attribute is only allowed for entry point functions
+        if !is_entry_point && func.kind == FunctionKind::Recursive {
+            self.push_err(ResolverError::MisplacedRecursiveAttribute {
+                ident: func.name_ident().clone(),
+            });
+        }
+
+        if matches!(attributes.function, Some(FunctionAttribute::Test { .. }))
+            && !parameters.is_empty()
+        {
+            self.push_err(ResolverError::TestFunctionHasParameters {
+                span: func.name_ident().span(),
+            });
+        }
+
+        let mut typ = Type::Function(parameter_types, return_type, Box::new(Type::Unit));
+
+        if !generics.is_empty() {
+            typ = Type::Forall(generics, Box::new(typ));
+        }
+
+        self.interner.push_definition_type(name_ident.id, typ.clone());
+
+        let direct_generics = func.def.generics.iter();
+        let direct_generics = direct_generics
+            .filter_map(|generic| self.find_generic(&generic.0.contents))
+            .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
+            .collect();
+
+        FuncMeta {
+            name: name_ident,
+            kind: func.kind,
+            location,
+            typ,
+            direct_generics,
+            trait_impl: self.current_trait_impl,
+            parameters: parameters.into(),
+            return_type: func.def.return_type.clone(),
+            return_visibility: func.def.return_visibility,
+            has_body: !func.def.body.is_empty(),
+            trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
+            is_entry_point,
+            has_inline_attribute,
+        }
+    }
+
+    /// Only sized types are valid to be used as main's parameters or the parameters to a contract
+    /// function. If the given type is not sized (e.g. contains a slice or NamedGeneric type), an
+    /// error is issued.
+    fn check_if_type_is_valid_for_program_input(
+        &mut self,
+        typ: &Type,
+        is_entry_point: bool,
+        has_inline_attribute: bool,
+        span: Span,
+    ) {
+        if (is_entry_point && !typ.is_valid_for_program_input())
+            || (has_inline_attribute && !typ.is_valid_non_inlined_function_input())
+        {
+            self.push_err(TypeCheckError::InvalidTypeForEntryPoint { span });
+        }
+    }
+
+    fn inline_attribute_allowed(&self, func: &NoirFunction) -> bool {
+        // Inline attributes are only relevant for constrained functions
+        // as all unconstrained functions are not inlined
+        !func.def.is_unconstrained
+    }
+
+    /// True if the 'pub' keyword is allowed on parameters in this function
+    /// 'pub' on function parameters is only allowed for entry point functions
+    fn pub_allowed(&self, func: &NoirFunction) -> bool {
+        self.is_entry_point_function(func) || func.attributes().is_foldable()
+    }
+
+    fn is_entry_point_function(&self, func: &NoirFunction) -> bool {
+        if self.in_contract {
+            func.attributes().is_contract_entry_point()
+        } else {
+            func.name() == MAIN_FUNCTION
+        }
+    }
+
+    fn declare_numeric_generics(&mut self, params: &[Type], return_type: &Type) {
+        if self.generics.is_empty() {
+            return;
+        }
+
+        for (name_to_find, type_variable) in Self::find_numeric_generics(params, return_type) {
+            // Declare any generics to let users use numeric generics in scope.
+            // Don't issue a warning if these are unused
+            //
+            // We can fail to find the generic in self.generics if it is an implicit one created
+            // by the compiler. This can happen when, e.g. eliding array lengths using the slice
+            // syntax [T].
+            if let Some((name, _, span)) =
+                self.generics.iter().find(|(name, _, _)| name.as_ref() == &name_to_find)
+            {
+                let ident = Ident::new(name.to_string(), *span);
+                let definition = DefinitionKind::GenericType(type_variable);
+                self.add_variable_decl_inner(ident, false, false, false, definition);
+            }
+        }
+    }
+
+    fn find_numeric_generics(
+        parameters: &[Type],
+        return_type: &Type,
+    ) -> Vec<(String, TypeVariable)> {
+        let mut found = BTreeMap::new();
+        for parameter in parameters {
+            Self::find_numeric_generics_in_type(parameter, &mut found);
+        }
+        Self::find_numeric_generics_in_type(return_type, &mut found);
+        found.into_iter().collect()
+    }
+
+    fn find_numeric_generics_in_type(typ: &Type, found: &mut BTreeMap<String, TypeVariable>) {
+        match typ {
+            Type::FieldElement
+            | Type::Integer(_, _)
+            | Type::Bool
+            | Type::Unit
+            | Type::Error
+            | Type::TypeVariable(_, _)
+            | Type::Constant(_)
+            | Type::NamedGeneric(_, _)
+            | Type::Code
+            | Type::Forall(_, _) => (),
+
+            Type::TraitAsType(_, _, args) => {
+                for arg in args {
+                    Self::find_numeric_generics_in_type(arg, found);
+                }
+            }
+
+            Type::Array(length, element_type) => {
+                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                    found.insert(name.to_string(), type_variable.clone());
+                }
+                Self::find_numeric_generics_in_type(element_type, found);
+            }
+
+            Type::Slice(element_type) => {
+                Self::find_numeric_generics_in_type(element_type, found);
+            }
+
+            Type::Tuple(fields) => {
+                for field in fields {
+                    Self::find_numeric_generics_in_type(field, found);
+                }
+            }
+
+            Type::Function(parameters, return_type, _env) => {
+                for parameter in parameters {
+                    Self::find_numeric_generics_in_type(parameter, found);
+                }
+                Self::find_numeric_generics_in_type(return_type, found);
+            }
+
+            Type::Struct(struct_type, generics) => {
+                for (i, generic) in generics.iter().enumerate() {
+                    if let Type::NamedGeneric(type_variable, name) = generic {
+                        if struct_type.borrow().generic_is_numeric(i) {
+                            found.insert(name.to_string(), type_variable.clone());
+                        }
+                    } else {
+                        Self::find_numeric_generics_in_type(generic, found);
+                    }
+                }
+            }
+            Type::Alias(alias, generics) => {
+                for (i, generic) in generics.iter().enumerate() {
+                    if let Type::NamedGeneric(type_variable, name) = generic {
+                        if alias.borrow().generic_is_numeric(i) {
+                            found.insert(name.to_string(), type_variable.clone());
+                        }
+                    } else {
+                        Self::find_numeric_generics_in_type(generic, found);
+                    }
+                }
+            }
+            Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found),
+            Type::String(length) => {
+                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                    found.insert(name.to_string(), type_variable.clone());
+                }
+            }
+            Type::FmtString(length, fields) => {
+                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                    found.insert(name.to_string(), type_variable.clone());
+                }
+                Self::find_numeric_generics_in_type(fields, found);
+            }
+        }
+    }
+
+    fn add_trait_constraints_to_scope(&mut self, func_meta: &FuncMeta) {
+        for constraint in &func_meta.trait_constraints {
+            let object = constraint.typ.clone();
+            let trait_id = constraint.trait_id;
+            let generics = constraint.trait_generics.clone();
+
+            if !self.interner.add_assumed_trait_implementation(object, trait_id, generics) {
+                if let Some(the_trait) = self.interner.try_get_trait(trait_id) {
+                    let trait_name = the_trait.name.to_string();
+                    let typ = constraint.typ.clone();
+                    let span = func_meta.location.span;
+                    self.push_err(TypeCheckError::UnneededTraitConstraint {
+                        trait_name,
+                        typ,
+                        span,
+                    });
+                }
+            }
+        }
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index b51115417e7..195d37878f1 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -19,7 +19,7 @@ use crate::{
 
 use super::{Elaborator, ResolverMeta};
 
-impl Elaborator {
+impl<'context> Elaborator<'context> {
     pub(super) fn elaborate_pattern(
         &mut self,
         pattern: Pattern,
@@ -203,7 +203,7 @@ impl Elaborator {
         self.add_variable_decl_inner(name, mutable, allow_shadowing, true, definition)
     }
 
-    fn add_variable_decl_inner(
+    pub fn add_variable_decl_inner(
         &mut self,
         name: Ident,
         mutable: bool,
@@ -238,7 +238,11 @@ impl Elaborator {
         ident
     }
 
-    fn add_global_variable_decl(&mut self, name: Ident, definition: DefinitionKind) -> HirIdent {
+    pub fn add_global_variable_decl(
+        &mut self,
+        name: Ident,
+        definition: DefinitionKind,
+    ) -> HirIdent {
         let scope = self.scopes.get_mut_scope();
 
         // This check is necessary to maintain the same definition ids in the interner. Currently, each function uses a new resolver that has its own ScopeForest and thus global scope.
@@ -247,9 +251,7 @@ impl Elaborator {
         let mut global_id = None;
         let global = self.interner.get_all_globals();
         for global_info in global {
-            if global_info.ident == name
-                && global_info.local_id == self.path_resolver.local_module_id()
-            {
+            if global_info.ident == name && global_info.local_id == self.local_module {
                 global_id = Some(global_info.id);
             }
         }
@@ -363,7 +365,7 @@ impl Elaborator {
                         // does not check definition kinds and otherwise expects parameters to
                         // already be typed.
                         if self.interner.definition_type(hir_ident.id) == Type::Error {
-                            let typ = Type::polymorphic_integer_or_field(&mut self.interner);
+                            let typ = Type::polymorphic_integer_or_field(self.interner);
                             self.interner.push_definition_type(hir_ident.id, typ);
                         }
                     }
@@ -406,7 +408,7 @@ impl Elaborator {
         // This instantiates a trait's generics as well which need to be set
         // when the constraint below is later solved for when the function is
         // finished. How to link the two?
-        let (typ, bindings) = t.instantiate_with_bindings(bindings, &self.interner);
+        let (typ, bindings) = t.instantiate_with_bindings(bindings, self.interner);
 
         // Push any trait constraints required by this definition to the context
         // to be checked later when the type of this variable is further constrained.
diff --git a/compiler/noirc_frontend/src/elaborator/scope.rs b/compiler/noirc_frontend/src/elaborator/scope.rs
index e8baba6bd89..cf10dbbc2b2 100644
--- a/compiler/noirc_frontend/src/elaborator/scope.rs
+++ b/compiler/noirc_frontend/src/elaborator/scope.rs
@@ -1,6 +1,13 @@
+use noirc_errors::Spanned;
 use rustc_hash::FxHashMap as HashMap;
 
+use crate::ast::ERROR_IDENT;
 use crate::hir::comptime::Value;
+use crate::hir::def_map::{LocalModuleId, ModuleId};
+use crate::hir::resolution::path_resolver::{PathResolver, StandardPathResolver};
+use crate::hir::resolution::resolver::SELF_TYPE_NAME;
+use crate::hir::scope::{Scope as GenericScope, ScopeTree as GenericScopeTree};
+use crate::macros_api::Ident;
 use crate::{
     hir::{
         def_map::{ModuleDefId, TryFromModuleDefId},
@@ -14,10 +21,14 @@ use crate::{
     node_interner::{DefinitionId, TraitId, TypeAliasId},
     Shared, StructType,
 };
+use crate::{Type, TypeAlias};
 
-use super::Elaborator;
+use super::{Elaborator, ResolverMeta};
 
-impl Elaborator {
+type Scope = GenericScope<String, ResolverMeta>;
+type ScopeTree = GenericScopeTree<String, ResolverMeta>;
+
+impl<'context> Elaborator<'context> {
     pub(super) fn lookup<T: TryFromModuleDefId>(&mut self, path: Path) -> Result<T, ResolverError> {
         let span = path.span();
         let id = self.resolve_path(path)?;
@@ -28,8 +39,14 @@ impl Elaborator {
         })
     }
 
+    pub(super) fn module_id(&self) -> ModuleId {
+        assert_ne!(self.local_module, LocalModuleId::dummy_id(), "local_module is unset");
+        ModuleId { krate: self.crate_id, local_id: self.local_module }
+    }
+
     pub(super) fn resolve_path(&mut self, path: Path) -> Result<ModuleDefId, ResolverError> {
-        let path_resolution = self.path_resolver.resolve(&self.def_maps, path)?;
+        let resolver = StandardPathResolver::new(self.module_id());
+        let path_resolution = resolver.resolve(self.def_maps, path)?;
 
         if let Some(error) = path_resolution.error {
             self.push_err(error);
@@ -97,4 +114,87 @@ impl Elaborator {
         let got = "local variable".into();
         Err(ResolverError::Expected { span, expected, got })
     }
+
+    pub fn push_scope(&mut self) {
+        self.scopes.start_scope();
+    }
+
+    pub fn pop_scope(&mut self) {
+        let scope = self.scopes.end_scope();
+        self.check_for_unused_variables_in_scope_tree(scope.into());
+    }
+
+    pub fn check_for_unused_variables_in_scope_tree(&mut self, scope_decls: ScopeTree) {
+        let mut unused_vars = Vec::new();
+        for scope in scope_decls.0.into_iter() {
+            Self::check_for_unused_variables_in_local_scope(scope, &mut unused_vars);
+        }
+
+        for unused_var in unused_vars.iter() {
+            if let Some(definition_info) = self.interner.try_definition(unused_var.id) {
+                let name = &definition_info.name;
+                if name != ERROR_IDENT && !definition_info.is_global() {
+                    let ident = Ident(Spanned::from(unused_var.location.span, name.to_owned()));
+                    self.push_err(ResolverError::UnusedVariable { ident });
+                }
+            }
+        }
+    }
+
+    fn check_for_unused_variables_in_local_scope(decl_map: Scope, unused_vars: &mut Vec<HirIdent>) {
+        let unused_variables = decl_map.filter(|(variable_name, metadata)| {
+            let has_underscore_prefix = variable_name.starts_with('_'); // XXX: This is used for development mode, and will be removed
+            metadata.warn_if_unused && metadata.num_times_used == 0 && !has_underscore_prefix
+        });
+        unused_vars.extend(unused_variables.map(|(_, meta)| meta.ident.clone()));
+    }
+
+    /// Lookup a given trait by name/path.
+    pub fn lookup_trait_or_error(&mut self, path: Path) -> Option<&mut Trait> {
+        match self.lookup(path) {
+            Ok(trait_id) => Some(self.get_trait_mut(trait_id)),
+            Err(error) => {
+                self.push_err(error);
+                None
+            }
+        }
+    }
+
+    /// Lookup a given struct type by name.
+    pub fn lookup_struct_or_error(&mut self, path: Path) -> Option<Shared<StructType>> {
+        match self.lookup(path) {
+            Ok(struct_id) => Some(self.get_struct(struct_id)),
+            Err(error) => {
+                self.push_err(error);
+                None
+            }
+        }
+    }
+
+    /// Looks up a given type by name.
+    /// This will also instantiate any struct types found.
+    pub(super) fn lookup_type_or_error(&mut self, path: Path) -> Option<Type> {
+        let ident = path.as_ident();
+        if ident.map_or(false, |i| i == SELF_TYPE_NAME) {
+            if let Some(typ) = &self.self_type {
+                return Some(typ.clone());
+            }
+        }
+
+        match self.lookup(path) {
+            Ok(struct_id) => {
+                let struct_type = self.get_struct(struct_id);
+                let generics = struct_type.borrow().instantiate(self.interner);
+                Some(Type::Struct(struct_type, generics))
+            }
+            Err(error) => {
+                self.push_err(error);
+                None
+            }
+        }
+    }
+
+    pub fn lookup_type_alias(&mut self, path: Path) -> Option<Shared<TypeAlias>> {
+        self.lookup(path).ok().map(|id| self.interner.get_type_alias(id))
+    }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 6ad6d66b2d4..a7a2df4041e 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -21,7 +21,7 @@ use crate::{
 
 use super::Elaborator;
 
-impl Elaborator {
+impl<'context> Elaborator<'context> {
     fn elaborate_statement_value(&mut self, statement: Statement) -> (HirStatement, Type) {
         match statement.kind {
             StatementKind::Let(let_stmt) => self.elaborate_let(let_stmt),
@@ -224,7 +224,7 @@ impl Elaborator {
                         mutable = definition.mutable;
                     }
 
-                    let typ = self.interner.definition_type(ident.id).instantiate(&self.interner).0;
+                    let typ = self.interner.definition_type(ident.id).instantiate(self.interner).0;
                     typ.follow_bindings()
                 };
 
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 2cd699b919d..4c8364b6dda 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -19,19 +19,20 @@ use crate::{
             HirBinaryOp, HirCallExpression, HirIdent, HirMemberAccess, HirMethodReference,
             HirPrefixExpression,
         },
+        function::FuncMeta,
         traits::{Trait, TraitConstraint},
     },
     macros_api::{
-        HirExpression, HirLiteral, Path, PathKind, SecondaryAttribute, Signedness, UnaryOp,
-        UnresolvedType, UnresolvedTypeData,
+        HirExpression, HirLiteral, HirStatement, Path, PathKind, SecondaryAttribute, Signedness,
+        UnaryOp, UnresolvedType, UnresolvedTypeData,
     },
-    node_interner::{DefinitionKind, ExprId, GlobalId, TraitImplKind, TraitMethodId},
+    node_interner::{DefinitionKind, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId},
     Generics, Shared, StructType, Type, TypeAlias, TypeBinding, TypeVariable, TypeVariableKind,
 };
 
 use super::Elaborator;
 
-impl Elaborator {
+impl<'context> Elaborator<'context> {
     /// Translates an UnresolvedType to a Type
     pub(super) fn resolve_type(&mut self, typ: UnresolvedType) -> Type {
         let span = typ.span;
@@ -45,7 +46,11 @@ impl Elaborator {
 
     /// Translates an UnresolvedType into a Type and appends any
     /// freshly created TypeVariables created to new_variables.
-    fn resolve_type_inner(&mut self, typ: UnresolvedType, new_variables: &mut Generics) -> Type {
+    pub fn resolve_type_inner(
+        &mut self,
+        typ: UnresolvedType,
+        new_variables: &mut Generics,
+    ) -> Type {
         use crate::ast::UnresolvedTypeData::*;
 
         let resolved_type = match typ.typ {
@@ -124,7 +129,7 @@ impl Elaborator {
         resolved_type
     }
 
-    fn find_generic(&self, target_name: &str) -> Option<&(Rc<String>, TypeVariable, Span)> {
+    pub fn find_generic(&self, target_name: &str) -> Option<&(Rc<String>, TypeVariable, Span)> {
         self.generics.iter().find(|(name, _, _)| name.as_ref() == target_name)
     }
 
@@ -257,7 +262,7 @@ impl Elaborator {
         }
     }
 
-    fn lookup_generic_or_global_type(&mut self, path: &Path) -> Option<Type> {
+    pub fn lookup_generic_or_global_type(&mut self, path: &Path) -> Option<Type> {
         if path.segments.len() == 1 {
             let name = &path.last_segment().0.contents;
             if let Some((name, var, _)) = self.find_generic(name) {
@@ -266,15 +271,12 @@ impl Elaborator {
         }
 
         // If we cannot find a local generic of the same name, try to look up a global
-        match self.path_resolver.resolve(&self.def_maps, path.clone()) {
-            Ok(PathResolution { module_def_id: ModuleDefId::GlobalId(id), error }) => {
+        match self.resolve_path(path.clone()) {
+            Ok(ModuleDefId::GlobalId(id)) => {
                 if let Some(current_item) = self.current_item {
                     self.interner.add_global_dependency(current_item, id);
                 }
 
-                if let Some(error) = error {
-                    self.push_err(error);
-                }
                 Some(Type::Constant(self.eval_global_as_array_length(id, path)))
             }
             _ => None,
@@ -330,55 +332,6 @@ impl Elaborator {
         }
     }
 
-    /// Lookup a given struct type by name.
-    fn lookup_struct_or_error(&mut self, path: Path) -> Option<Shared<StructType>> {
-        match self.lookup(path) {
-            Ok(struct_id) => Some(self.get_struct(struct_id)),
-            Err(error) => {
-                self.push_err(error);
-                None
-            }
-        }
-    }
-
-    /// Lookup a given trait by name/path.
-    fn lookup_trait_or_error(&mut self, path: Path) -> Option<&mut Trait> {
-        match self.lookup(path) {
-            Ok(trait_id) => Some(self.get_trait_mut(trait_id)),
-            Err(error) => {
-                self.push_err(error);
-                None
-            }
-        }
-    }
-
-    /// Looks up a given type by name.
-    /// This will also instantiate any struct types found.
-    pub(super) fn lookup_type_or_error(&mut self, path: Path) -> Option<Type> {
-        let ident = path.as_ident();
-        if ident.map_or(false, |i| i == SELF_TYPE_NAME) {
-            if let Some(typ) = &self.self_type {
-                return Some(typ.clone());
-            }
-        }
-
-        match self.lookup(path) {
-            Ok(struct_id) => {
-                let struct_type = self.get_struct(struct_id);
-                let generics = struct_type.borrow().instantiate(&mut self.interner);
-                Some(Type::Struct(struct_type, generics))
-            }
-            Err(error) => {
-                self.push_err(error);
-                None
-            }
-        }
-    }
-
-    fn lookup_type_alias(&mut self, path: Path) -> Option<Shared<TypeAlias>> {
-        self.lookup(path).ok().map(|id| self.interner.get_type_alias(id))
-    }
-
     // this resolves Self::some_static_method, inside an impl block (where we don't have a concrete self_type)
     //
     // Returns the trait method, trait constraint, and whether the impl is assumed to exist by a where clause or not
@@ -629,7 +582,7 @@ impl Elaborator {
     ) {
         let mut errors = Vec::new();
         actual.unify(expected, &mut errors, make_error);
-        self.errors.extend(errors.into_iter().map(Into::into));
+        self.errors.extend(errors.into_iter().map(|error| (error.into(), self.file)));
     }
 
     /// Wrapper of Type::unify_with_coercions using self.errors
@@ -641,20 +594,14 @@ impl Elaborator {
         make_error: impl FnOnce() -> TypeCheckError,
     ) {
         let mut errors = Vec::new();
-        actual.unify_with_coercions(
-            expected,
-            expression,
-            &mut self.interner,
-            &mut errors,
-            make_error,
-        );
-        self.errors.extend(errors.into_iter().map(Into::into));
+        actual.unify_with_coercions(expected, expression, self.interner, &mut errors, make_error);
+        self.errors.extend(errors.into_iter().map(|error| (error.into(), self.file)));
     }
 
     /// Return a fresh integer or field type variable and log it
     /// in self.type_variables to default it later.
     pub(super) fn polymorphic_integer_or_field(&mut self) -> Type {
-        let typ = Type::polymorphic_integer_or_field(&mut self.interner);
+        let typ = Type::polymorphic_integer_or_field(self.interner);
         self.type_variables.push(typ.clone());
         typ
     }
@@ -662,7 +609,7 @@ impl Elaborator {
     /// Return a fresh integer type variable and log it
     /// in self.type_variables to default it later.
     pub(super) fn polymorphic_integer(&mut self) -> Type {
-        let typ = Type::polymorphic_integer(&mut self.interner);
+        let typ = Type::polymorphic_integer(self.interner);
         self.type_variables.push(typ.clone());
         typ
     }
@@ -962,7 +909,7 @@ impl Elaborator {
         // Doing so also ensures a type error if Field is used.
         // The is_numeric check is to allow impls for custom types to bypass this.
         if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric() {
-            let target = Type::polymorphic_integer(&mut self.interner);
+            let target = Type::polymorphic_integer(self.interner);
 
             use crate::ast::BinaryOpKind::*;
             use TypeCheckError::*;
@@ -1014,7 +961,7 @@ impl Elaborator {
                         || TypeCheckError::InvalidShiftSize { span },
                     );
                     let use_impl = if lhs_type.is_numeric() {
-                        let integer_type = Type::polymorphic_integer(&mut self.interner);
+                        let integer_type = Type::polymorphic_integer(self.interner);
                         self.bind_type_variables_for_infix(lhs_type, op, &integer_type, span)
                     } else {
                         true
@@ -1095,7 +1042,7 @@ impl Elaborator {
         let the_trait = self.interner.get_trait(trait_method_id.trait_id);
 
         let method = &the_trait.methods[trait_method_id.method_index];
-        let (method_type, mut bindings) = method.typ.clone().instantiate(&self.interner);
+        let (method_type, mut bindings) = method.typ.clone().instantiate(self.interner);
 
         match method_type {
             Type::Function(args, _, _) => {
@@ -1362,7 +1309,7 @@ impl Elaborator {
 
             if matches!(expected_object_type.follow_bindings(), Type::MutableReference(_)) {
                 if !matches!(actual_type, Type::MutableReference(_)) {
-                    if let Err(error) = verify_mutable_reference(&self.interner, *object) {
+                    if let Err(error) = verify_mutable_reference(self.interner, *object) {
                         self.push_err(TypeCheckError::ResolverError(error));
                     }
 
@@ -1396,4 +1343,96 @@ impl Elaborator {
             }
         }
     }
+
+    pub fn type_check_function_body(&mut self, body_type: Type, meta: &FuncMeta, body_id: ExprId) {
+        let (expr_span, empty_function) = self.function_info(body_id);
+        let declared_return_type = meta.return_type();
+
+        let func_span = self.interner.expr_span(&body_id); // XXX: We could be more specific and return the span of the last stmt, however stmts do not have spans yet
+        if let Type::TraitAsType(trait_id, _, generics) = declared_return_type {
+            if self.interner.lookup_trait_implementation(&body_type, *trait_id, generics).is_err() {
+                self.push_err(TypeCheckError::TypeMismatchWithSource {
+                    expected: declared_return_type.clone(),
+                    actual: body_type,
+                    span: func_span,
+                    source: Source::Return(meta.return_type.clone(), expr_span),
+                });
+            }
+        } else {
+            self.unify_with_coercions(&body_type, declared_return_type, body_id, || {
+                let mut error = TypeCheckError::TypeMismatchWithSource {
+                    expected: declared_return_type.clone(),
+                    actual: body_type.clone(),
+                    span: func_span,
+                    source: Source::Return(meta.return_type.clone(), expr_span),
+                };
+
+                if empty_function {
+                    error = error.add_context(
+                        "implicitly returns `()` as its body has no tail or `return` expression",
+                    );
+                }
+                error
+            });
+        }
+    }
+
+    fn function_info(&self, function_body_id: ExprId) -> (noirc_errors::Span, bool) {
+        let (expr_span, empty_function) =
+            if let HirExpression::Block(block) = self.interner.expression(&function_body_id) {
+                let last_stmt = block.statements().last();
+                let mut span = self.interner.expr_span(&function_body_id);
+
+                if let Some(last_stmt) = last_stmt {
+                    if let HirStatement::Expression(expr) = self.interner.statement(last_stmt) {
+                        span = self.interner.expr_span(&expr);
+                    }
+                }
+
+                (span, last_stmt.is_none())
+            } else {
+                (self.interner.expr_span(&function_body_id), false)
+            };
+        (expr_span, empty_function)
+    }
+
+    pub fn verify_trait_constraint(
+        &mut self,
+        object_type: &Type,
+        trait_id: TraitId,
+        trait_generics: &[Type],
+        function_ident_id: ExprId,
+        span: Span,
+    ) {
+        match self.interner.lookup_trait_implementation(object_type, trait_id, trait_generics) {
+            Ok(impl_kind) => {
+                self.interner.select_impl_for_expression(function_ident_id, impl_kind);
+            }
+            Err(erroring_constraints) => {
+                if erroring_constraints.is_empty() {
+                    self.push_err(TypeCheckError::TypeAnnotationsNeeded { span });
+                } else {
+                    // Don't show any errors where try_get_trait returns None.
+                    // This can happen if a trait is used that was never declared.
+                    let constraints = erroring_constraints
+                        .into_iter()
+                        .map(|constraint| {
+                            let r#trait = self.interner.try_get_trait(constraint.trait_id)?;
+                            let mut name = r#trait.name.to_string();
+                            if !constraint.trait_generics.is_empty() {
+                                let generics =
+                                    vecmap(&constraint.trait_generics, ToString::to_string);
+                                name += &format!("<{}>", generics.join(", "));
+                            }
+                            Some((constraint.typ, name))
+                        })
+                        .collect::<Option<Vec<_>>>();
+
+                    if let Some(constraints) = constraints {
+                        self.push_err(TypeCheckError::NoMatchingImplFound { constraints, span });
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 2f6b101e62f..4aac0fec9c3 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -1,5 +1,6 @@
 use super::dc_mod::collect_defs;
 use super::errors::{DefCollectorErrorKind, DuplicateType};
+use crate::elaborator::Elaborator;
 use crate::graph::CrateId;
 use crate::hir::comptime::{Interpreter, InterpreterError};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
@@ -129,14 +130,18 @@ pub struct UnresolvedGlobal {
 /// Given a Crate root, collect all definitions in that crate
 pub struct DefCollector {
     pub(crate) def_map: CrateDefMap,
-    pub(crate) collected_imports: Vec<ImportDirective>,
-    pub(crate) collected_functions: Vec<UnresolvedFunctions>,
-    pub(crate) collected_types: BTreeMap<StructId, UnresolvedStruct>,
-    pub(crate) collected_type_aliases: BTreeMap<TypeAliasId, UnresolvedTypeAlias>,
-    pub(crate) collected_traits: BTreeMap<TraitId, UnresolvedTrait>,
-    pub(crate) collected_globals: Vec<UnresolvedGlobal>,
-    pub(crate) collected_impls: ImplMap,
-    pub(crate) collected_traits_impls: Vec<UnresolvedTraitImpl>,
+    pub(crate) imports: Vec<ImportDirective>,
+    pub(crate) items: CollectedItems,
+}
+
+pub struct CollectedItems {
+    pub(crate) functions: Vec<UnresolvedFunctions>,
+    pub(crate) types: BTreeMap<StructId, UnresolvedStruct>,
+    pub(crate) type_aliases: BTreeMap<TypeAliasId, UnresolvedTypeAlias>,
+    pub(crate) traits: BTreeMap<TraitId, UnresolvedTrait>,
+    pub(crate) globals: Vec<UnresolvedGlobal>,
+    pub(crate) impls: ImplMap,
+    pub(crate) trait_impls: Vec<UnresolvedTraitImpl>,
 }
 
 /// Maps the type and the module id in which the impl is defined to the functions contained in that
@@ -210,14 +215,16 @@ impl DefCollector {
     fn new(def_map: CrateDefMap) -> DefCollector {
         DefCollector {
             def_map,
-            collected_imports: vec![],
-            collected_functions: vec![],
-            collected_types: BTreeMap::new(),
-            collected_type_aliases: BTreeMap::new(),
-            collected_traits: BTreeMap::new(),
-            collected_impls: HashMap::new(),
-            collected_globals: vec![],
-            collected_traits_impls: vec![],
+            imports: vec![],
+            items: CollectedItems {
+                functions: vec![],
+                types: BTreeMap::new(),
+                type_aliases: BTreeMap::new(),
+                traits: BTreeMap::new(),
+                impls: HashMap::new(),
+                globals: vec![],
+                trait_impls: vec![],
+            },
         }
     }
 
@@ -229,6 +236,7 @@ impl DefCollector {
         context: &mut Context,
         ast: SortedModule,
         root_file_id: FileId,
+        use_elaborator: bool,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
@@ -242,7 +250,12 @@ impl DefCollector {
         let crate_graph = &context.crate_graph[crate_id];
 
         for dep in crate_graph.dependencies.clone() {
-            errors.extend(CrateDefMap::collect_defs(dep.crate_id, context, macro_processors));
+            errors.extend(CrateDefMap::collect_defs(
+                dep.crate_id,
+                context,
+                use_elaborator,
+                macro_processors,
+            ));
 
             let dep_def_root =
                 context.def_map(&dep.crate_id).expect("ice: def map was just created").root;
@@ -275,18 +288,13 @@ impl DefCollector {
         // Add the current crate to the collection of DefMaps
         context.def_maps.insert(crate_id, def_collector.def_map);
 
-        inject_prelude(crate_id, context, crate_root, &mut def_collector.collected_imports);
+        inject_prelude(crate_id, context, crate_root, &mut def_collector.imports);
         for submodule in submodules {
-            inject_prelude(
-                crate_id,
-                context,
-                LocalModuleId(submodule),
-                &mut def_collector.collected_imports,
-            );
+            inject_prelude(crate_id, context, LocalModuleId(submodule), &mut def_collector.imports);
         }
 
         // Resolve unresolved imports collected from the crate, one by one.
-        for collected_import in def_collector.collected_imports {
+        for collected_import in std::mem::take(&mut def_collector.imports) {
             match resolve_import(crate_id, &collected_import, &context.def_maps) {
                 Ok(resolved_import) => {
                     if let Some(error) = resolved_import.error {
@@ -323,6 +331,12 @@ impl DefCollector {
             }
         }
 
+        if use_elaborator {
+            let mut more_errors = Elaborator::elaborate(context, crate_id, def_collector.items);
+            more_errors.append(&mut errors);
+            return errors;
+        }
+
         let mut resolved_module = ResolvedModule { errors, ..Default::default() };
 
         // We must first resolve and intern the globals before we can resolve any stmts inside each function.
@@ -330,26 +344,25 @@ impl DefCollector {
         //
         // Additionally, we must resolve integer globals before structs since structs may refer to
         // the values of integer globals as numeric generics.
-        let (literal_globals, other_globals) =
-            filter_literal_globals(def_collector.collected_globals);
+        let (literal_globals, other_globals) = filter_literal_globals(def_collector.items.globals);
 
         resolved_module.resolve_globals(context, literal_globals, crate_id);
 
         resolved_module.errors.extend(resolve_type_aliases(
             context,
-            def_collector.collected_type_aliases,
+            def_collector.items.type_aliases,
             crate_id,
         ));
 
         resolved_module.errors.extend(resolve_traits(
             context,
-            def_collector.collected_traits,
+            def_collector.items.traits,
             crate_id,
         ));
         // Must resolve structs before we resolve globals.
         resolved_module.errors.extend(resolve_structs(
             context,
-            def_collector.collected_types,
+            def_collector.items.types,
             crate_id,
         ));
 
@@ -358,7 +371,7 @@ impl DefCollector {
         resolved_module.errors.extend(collect_trait_impls(
             context,
             crate_id,
-            &mut def_collector.collected_traits_impls,
+            &mut def_collector.items.trait_impls,
         ));
 
         // Before we resolve any function symbols we must go through our impls and
@@ -368,11 +381,7 @@ impl DefCollector {
         //
         // These are resolved after trait impls so that struct methods are chosen
         // over trait methods if there are name conflicts.
-        resolved_module.errors.extend(collect_impls(
-            context,
-            crate_id,
-            &def_collector.collected_impls,
-        ));
+        resolved_module.errors.extend(collect_impls(context, crate_id, &def_collector.items.impls));
 
         // We must wait to resolve non-integer globals until after we resolve structs since struct
         // globals will need to reference the struct type they're initialized to to ensure they are valid.
@@ -383,7 +392,7 @@ impl DefCollector {
             &mut context.def_interner,
             crate_id,
             &context.def_maps,
-            def_collector.collected_functions,
+            def_collector.items.functions,
             None,
             &mut resolved_module.errors,
         );
@@ -392,13 +401,13 @@ impl DefCollector {
             &mut context.def_interner,
             crate_id,
             &context.def_maps,
-            def_collector.collected_impls,
+            def_collector.items.impls,
             &mut resolved_module.errors,
         ));
 
         resolved_module.trait_impl_functions = resolve_trait_impls(
             context,
-            def_collector.collected_traits_impls,
+            def_collector.items.trait_impls,
             crate_id,
             &mut resolved_module.errors,
         );
@@ -431,15 +440,18 @@ fn inject_prelude(
     crate_root: LocalModuleId,
     collected_imports: &mut Vec<ImportDirective>,
 ) {
-    let segments: Vec<_> = "std::prelude"
-        .split("::")
-        .map(|segment| crate::ast::Ident::new(segment.into(), Span::default()))
-        .collect();
+    if !crate_id.is_stdlib() {
+        let segments: Vec<_> = "std::prelude"
+            .split("::")
+            .map(|segment| crate::ast::Ident::new(segment.into(), Span::default()))
+            .collect();
 
-    let path =
-        Path { segments: segments.clone(), kind: crate::ast::PathKind::Dep, span: Span::default() };
+        let path = Path {
+            segments: segments.clone(),
+            kind: crate::ast::PathKind::Dep,
+            span: Span::default(),
+        };
 
-    if !crate_id.is_stdlib() {
         if let Ok(PathResolution { module_def_id, error }) = path_resolver::resolve_path(
             &context.def_maps,
             ModuleId { krate: crate_id, local_id: crate_root },
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index b2ec7dbc813..e688f192d3d 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -70,7 +70,7 @@ pub fn collect_defs(
 
     // Then add the imports to defCollector to resolve once all modules in the hierarchy have been resolved
     for import in ast.imports {
-        collector.def_collector.collected_imports.push(ImportDirective {
+        collector.def_collector.imports.push(ImportDirective {
             module_id: collector.module_id,
             path: import.path,
             alias: import.alias,
@@ -126,7 +126,7 @@ impl<'a> ModCollector<'a> {
                 errors.push((err.into(), self.file_id));
             }
 
-            self.def_collector.collected_globals.push(UnresolvedGlobal {
+            self.def_collector.items.globals.push(UnresolvedGlobal {
                 file_id: self.file_id,
                 module_id: self.module_id,
                 global_id,
@@ -154,7 +154,7 @@ impl<'a> ModCollector<'a> {
             }
 
             let key = (r#impl.object_type, self.module_id);
-            let methods = self.def_collector.collected_impls.entry(key).or_default();
+            let methods = self.def_collector.items.impls.entry(key).or_default();
             methods.push((r#impl.generics, r#impl.type_span, unresolved_functions));
         }
     }
@@ -191,7 +191,7 @@ impl<'a> ModCollector<'a> {
                 trait_generics: trait_impl.trait_generics,
             };
 
-            self.def_collector.collected_traits_impls.push(unresolved_trait_impl);
+            self.def_collector.items.trait_impls.push(unresolved_trait_impl);
         }
     }
 
@@ -269,7 +269,7 @@ impl<'a> ModCollector<'a> {
             }
         }
 
-        self.def_collector.collected_functions.push(unresolved_functions);
+        self.def_collector.items.functions.push(unresolved_functions);
         errors
     }
 
@@ -316,7 +316,7 @@ impl<'a> ModCollector<'a> {
             }
 
             // And store the TypeId -> StructType mapping somewhere it is reachable
-            self.def_collector.collected_types.insert(id, unresolved);
+            self.def_collector.items.types.insert(id, unresolved);
         }
         definition_errors
     }
@@ -354,7 +354,7 @@ impl<'a> ModCollector<'a> {
                 errors.push((err.into(), self.file_id));
             }
 
-            self.def_collector.collected_type_aliases.insert(type_alias_id, unresolved);
+            self.def_collector.items.type_aliases.insert(type_alias_id, unresolved);
         }
         errors
     }
@@ -506,7 +506,7 @@ impl<'a> ModCollector<'a> {
                 method_ids,
                 fns_with_default_impl: unresolved_functions,
             };
-            self.def_collector.collected_traits.insert(trait_id, unresolved);
+            self.def_collector.items.traits.insert(trait_id, unresolved);
         }
         errors
     }
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 590c2e3d6b6..19e06387d43 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -73,6 +73,7 @@ impl CrateDefMap {
     pub fn collect_defs(
         crate_id: CrateId,
         context: &mut Context,
+        use_elaborator: bool,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         // Check if this Crate has already been compiled
@@ -116,7 +117,14 @@ impl CrateDefMap {
         };
 
         // Now we want to populate the CrateDefMap using the DefCollector
-        errors.extend(DefCollector::collect(def_map, context, ast, root_file_id, macro_processors));
+        errors.extend(DefCollector::collect(
+            def_map,
+            context,
+            ast,
+            root_file_id,
+            use_elaborator,
+            macro_processors,
+        ));
 
         errors.extend(
             parsing_errors.iter().map(|e| (e.clone().into(), root_file_id)).collect::<Vec<_>>(),
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index c38dd41fd3d..ceec9ad8580 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -135,10 +135,7 @@ impl FuncMeta {
     /// So this method tells the type checker to ignore the return
     /// of the empty function, which is unit
     pub fn can_ignore_return_type(&self) -> bool {
-        match self.kind {
-            FunctionKind::LowLevel | FunctionKind::Builtin | FunctionKind::Oracle => true,
-            FunctionKind::Normal | FunctionKind::Recursive => false,
-        }
+        self.kind.can_ignore_return_type()
     }
 
     pub fn function_signature(&self) -> FunctionSignature {
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 6f7470807be..fb80a7d8018 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -81,6 +81,7 @@ pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(Compilation
             &mut context,
             program.clone().into_sorted(),
             root_file_id,
+            false,
             &[], // No macro processors
         ));
     }
diff --git a/tooling/lsp/src/lib.rs b/tooling/lsp/src/lib.rs
index be9b83e02f6..05345b96c80 100644
--- a/tooling/lsp/src/lib.rs
+++ b/tooling/lsp/src/lib.rs
@@ -345,7 +345,7 @@ fn prepare_package_from_source_string() {
     let mut state = LspState::new(&client, acvm::blackbox_solver::StubbedBlackBoxSolver);
 
     let (mut context, crate_id) = crate::prepare_source(source.to_string(), &mut state);
-    let _check_result = noirc_driver::check_crate(&mut context, crate_id, false, false);
+    let _check_result = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
     let main_func_id = context.get_main_function(&crate_id);
     assert!(main_func_id.is_some());
 }
diff --git a/tooling/lsp/src/notifications/mod.rs b/tooling/lsp/src/notifications/mod.rs
index 355bb7832c4..3856bdc79e9 100644
--- a/tooling/lsp/src/notifications/mod.rs
+++ b/tooling/lsp/src/notifications/mod.rs
@@ -56,7 +56,7 @@ pub(super) fn on_did_change_text_document(
     state.input_files.insert(params.text_document.uri.to_string(), text.clone());
 
     let (mut context, crate_id) = prepare_source(text, state);
-    let _ = check_crate(&mut context, crate_id, false, false);
+    let _ = check_crate(&mut context, crate_id, false, false, false);
 
     let workspace = match resolve_workspace_for_source_path(
         params.text_document.uri.to_file_path().unwrap().as_path(),
@@ -139,7 +139,7 @@ fn process_noir_document(
             let (mut context, crate_id) =
                 prepare_package(&workspace_file_manager, &parsed_files, package);
 
-            let file_diagnostics = match check_crate(&mut context, crate_id, false, false) {
+            let file_diagnostics = match check_crate(&mut context, crate_id, false, false, false) {
                 Ok(((), warnings)) => warnings,
                 Err(errors_and_warnings) => errors_and_warnings,
             };
diff --git a/tooling/lsp/src/requests/code_lens_request.rs b/tooling/lsp/src/requests/code_lens_request.rs
index 893ba33d845..744bddedd9d 100644
--- a/tooling/lsp/src/requests/code_lens_request.rs
+++ b/tooling/lsp/src/requests/code_lens_request.rs
@@ -67,7 +67,7 @@ fn on_code_lens_request_inner(
     let (mut context, crate_id) = prepare_source(source_string, state);
     // We ignore the warnings and errors produced by compilation for producing code lenses
     // because we can still get the test functions even if compilation fails
-    let _ = check_crate(&mut context, crate_id, false, false);
+    let _ = check_crate(&mut context, crate_id, false, false, false);
 
     let collected_lenses =
         collect_lenses_for_package(&context, crate_id, &workspace, package, None);
diff --git a/tooling/lsp/src/requests/goto_declaration.rs b/tooling/lsp/src/requests/goto_declaration.rs
index 8e6d519b895..5cff16b2348 100644
--- a/tooling/lsp/src/requests/goto_declaration.rs
+++ b/tooling/lsp/src/requests/goto_declaration.rs
@@ -46,7 +46,7 @@ fn on_goto_definition_inner(
         interner = def_interner;
     } else {
         // We ignore the warnings and errors produced by compilation while resolving the definition
-        let _ = noirc_driver::check_crate(&mut context, crate_id, false, false);
+        let _ = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
         interner = &context.def_interner;
     }
 
diff --git a/tooling/lsp/src/requests/goto_definition.rs b/tooling/lsp/src/requests/goto_definition.rs
index 88bb667f2e8..32e13ce00f6 100644
--- a/tooling/lsp/src/requests/goto_definition.rs
+++ b/tooling/lsp/src/requests/goto_definition.rs
@@ -54,7 +54,7 @@ fn on_goto_definition_inner(
         interner = def_interner;
     } else {
         // We ignore the warnings and errors produced by compilation while resolving the definition
-        let _ = noirc_driver::check_crate(&mut context, crate_id, false, false);
+        let _ = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
         interner = &context.def_interner;
     }
 
diff --git a/tooling/lsp/src/requests/test_run.rs b/tooling/lsp/src/requests/test_run.rs
index 1844a3d9bf0..83b05ba06a2 100644
--- a/tooling/lsp/src/requests/test_run.rs
+++ b/tooling/lsp/src/requests/test_run.rs
@@ -60,7 +60,7 @@ fn on_test_run_request_inner(
         Some(package) => {
             let (mut context, crate_id) =
                 prepare_package(&workspace_file_manager, &parsed_files, package);
-            if check_crate(&mut context, crate_id, false, false).is_err() {
+            if check_crate(&mut context, crate_id, false, false, false).is_err() {
                 let result = NargoTestRunResult {
                     id: params.id.clone(),
                     result: "error".to_string(),
diff --git a/tooling/lsp/src/requests/tests.rs b/tooling/lsp/src/requests/tests.rs
index 5b78fcc65c3..cdf4ad338c4 100644
--- a/tooling/lsp/src/requests/tests.rs
+++ b/tooling/lsp/src/requests/tests.rs
@@ -61,7 +61,7 @@ fn on_tests_request_inner(
                 prepare_package(&workspace_file_manager, &parsed_files, package);
             // We ignore the warnings and errors produced by compilation for producing tests
             // because we can still get the test functions even if compilation fails
-            let _ = check_crate(&mut context, crate_id, false, false);
+            let _ = check_crate(&mut context, crate_id, false, false, false);
 
             // We don't add test headings for a package if it contains no `#[test]` functions
             get_package_tests_in_crate(&context, &crate_id, &package.name)
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 208379b098d..d5313d96076 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -87,6 +87,7 @@ fn check_package(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.silence_warnings,
+        compile_options.use_elaborator,
     )?;
 
     if package.is_library() || package.is_contract() {
@@ -173,8 +174,9 @@ pub(crate) fn check_crate_and_report_errors(
     deny_warnings: bool,
     disable_macros: bool,
     silence_warnings: bool,
+    use_elaborator: bool,
 ) -> Result<(), CompileError> {
-    let result = check_crate(context, crate_id, deny_warnings, disable_macros);
+    let result = check_crate(context, crate_id, deny_warnings, disable_macros, use_elaborator);
     report_errors(result, &context.file_manager, deny_warnings, silence_warnings)
 }
 
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index a61f3ccfc02..324eed340ad 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -89,6 +89,7 @@ fn compile_exported_functions(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.silence_warnings,
+        compile_options.use_elaborator,
     )?;
 
     let exported_functions = context.get_all_exported_functions_in_crate(&crate_id);
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 967d4c87e6d..51e21248afd 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -175,6 +175,7 @@ fn run_test<S: BlackBoxFunctionSolver + Default>(
         crate_id,
         compile_options.deny_warnings,
         compile_options.disable_macros,
+        compile_options.use_elaborator,
     )
     .expect("Any errors should have occurred when collecting test functions");
 
@@ -208,6 +209,7 @@ fn get_tests_in_package(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.silence_warnings,
+        compile_options.use_elaborator,
     )?;
 
     Ok(context
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 9d377cfaee9..70a9354f50a 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -10,8 +10,7 @@ use nargo::{
     parse_all, prepare_package,
 };
 
-#[test]
-fn stdlib_noir_tests() {
+fn run_stdlib_tests(use_elaborator: bool) {
     let mut file_manager = file_manager_with_stdlib(&PathBuf::from("."));
     file_manager.add_file_with_source_canonical_path(&PathBuf::from("main.nr"), "".to_owned());
     let parsed_files = parse_all(&file_manager);
@@ -30,7 +29,7 @@ fn stdlib_noir_tests() {
     let (mut context, dummy_crate_id) =
         prepare_package(&file_manager, &parsed_files, &dummy_package);
 
-    let result = check_crate(&mut context, dummy_crate_id, true, false);
+    let result = check_crate(&mut context, dummy_crate_id, true, false, use_elaborator);
     report_errors(result, &context.file_manager, true, false)
         .expect("Error encountered while compiling standard library");
 
@@ -60,3 +59,15 @@ fn stdlib_noir_tests() {
     assert!(!test_report.is_empty(), "Could not find any tests within the stdlib");
     assert!(test_report.iter().all(|(_, status)| !status.failed()));
 }
+
+#[test]
+fn stdlib_noir_tests() {
+    run_stdlib_tests(false)
+}
+
+// Once this no longer panics we can use the elaborator by default and remove the old passes
+#[test]
+#[should_panic]
+fn stdlib_elaborator_tests() {
+    run_stdlib_tests(true)
+}

From b541e793e20fa3c991e0328ec2ff7926bdcdfd45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Fri, 10 May 2024 13:05:02 +0200
Subject: [PATCH 269/416] fix: Ignore no_predicates in brillig functions
 (#5012)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5010

## Summary\*

Ignores no predicates for brillig functions to avoid trying to convert
to brillig flattened functions.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/opt/inlining.rs     |  7 ++++---
 .../no_predicates_brillig/Nargo.toml                 |  7 +++++++
 .../no_predicates_brillig/Prover.toml                |  2 ++
 .../no_predicates_brillig/src/main.nr                | 12 ++++++++++++
 4 files changed, 25 insertions(+), 3 deletions(-)
 create mode 100644 test_programs/execution_success/no_predicates_brillig/Nargo.toml
 create mode 100644 test_programs/execution_success/no_predicates_brillig/Prover.toml
 create mode 100644 test_programs/execution_success/no_predicates_brillig/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index bddfb25f26c..77b9e545e03 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -11,7 +11,7 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         dfg::{CallStack, InsertInstructionResult},
-        function::{Function, FunctionId},
+        function::{Function, FunctionId, RuntimeType},
         instruction::{Instruction, InstructionId, TerminatorInstruction},
         value::{Value, ValueId},
     },
@@ -392,10 +392,11 @@ impl<'function> PerFunctionContext<'function> {
                     Some(func_id) => {
                         let function = &ssa.functions[&func_id];
                         // If we have not already finished the flattening pass, functions marked
-                        // to not have predicates should be marked as entry points.
+                        // to not have predicates should be marked as entry points unless we are inlining into brillig.
                         let no_predicates_is_entry_point =
                             self.context.no_predicates_is_entry_point
-                                && function.is_no_predicates();
+                                && function.is_no_predicates()
+                                && !matches!(self.source_function.runtime(), RuntimeType::Brillig);
                         if function.runtime().is_entry_point() || no_predicates_is_entry_point {
                             self.push_instruction(*id);
                         } else {
diff --git a/test_programs/execution_success/no_predicates_brillig/Nargo.toml b/test_programs/execution_success/no_predicates_brillig/Nargo.toml
new file mode 100644
index 00000000000..328d78c8f99
--- /dev/null
+++ b/test_programs/execution_success/no_predicates_brillig/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "no_predicates_brillig"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/no_predicates_brillig/Prover.toml b/test_programs/execution_success/no_predicates_brillig/Prover.toml
new file mode 100644
index 00000000000..93a825f609f
--- /dev/null
+++ b/test_programs/execution_success/no_predicates_brillig/Prover.toml
@@ -0,0 +1,2 @@
+x = "10"
+y = "20"
diff --git a/test_programs/execution_success/no_predicates_brillig/src/main.nr b/test_programs/execution_success/no_predicates_brillig/src/main.nr
new file mode 100644
index 00000000000..1d088473aa7
--- /dev/null
+++ b/test_programs/execution_success/no_predicates_brillig/src/main.nr
@@ -0,0 +1,12 @@
+unconstrained fn main(x: u32, y: pub u32) {
+    basic_checks(x, y);
+}
+
+#[no_predicates]
+fn basic_checks(x: u32, y: u32) {
+    if x > y {
+        assert(x == 10);
+    } else {
+        assert(y == 20);
+    }
+}

From 7280baddedca8e08f7d4a30c80e1b0233dff09a2 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 10 May 2024 14:12:46 +0100
Subject: [PATCH 270/416] chore: add script to print lines of code (#4991)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds a small script to print out the LOC for various sections of
the codebase. Adding weightings will come in a later PR. Note that this
PR relies on my fork of tokei which has support for Noir source code.

cc @rumata888

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .tokeignore          | 12 ++++++++++++
 scripts/count_loc.sh | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+)
 create mode 100644 .tokeignore
 create mode 100755 scripts/count_loc.sh

diff --git a/.tokeignore b/.tokeignore
new file mode 100644
index 00000000000..55f24e41dbd
--- /dev/null
+++ b/.tokeignore
@@ -0,0 +1,12 @@
+docs
+scripts
+
+# aztec_macros is explicitly considered OOS for Noir audit
+aztec_macros
+
+# config files
+*.toml
+*.md
+*.json
+*.txt
+*.config.mjs
diff --git a/scripts/count_loc.sh b/scripts/count_loc.sh
new file mode 100755
index 00000000000..91565aa6c4a
--- /dev/null
+++ b/scripts/count_loc.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -eu
+
+# Run relative to repo root
+cd $(dirname "$0")/../
+
+if ! command -v "tokei" >/dev/null 2>&1; then
+    echo "Error: tokei is required but not installed." >&2
+    echo "Error: Run \`cargo install --git https://github.com/TomAFrench/tokei --branch tf/add-noir-support tokei\`" >&2
+    
+    exit 1
+fi
+
+echo ""
+echo "Total:"
+
+tokei ./ --sort code
+
+echo ""
+echo "ACIR/ACVM:"
+tokei ./acvm-repo --sort code
+
+echo ""
+echo "Compiler:"
+tokei ./compiler --sort code
+
+echo ""
+echo "Tooling:"
+tokei ./tooling --sort code
+
+echo ""
+echo "Standard Library:"
+tokei ./noir_stdlib --sort code

From 9c6de4b25d318c6d211361dd62a112a9d2432c56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Fri, 10 May 2024 18:20:03 +0200
Subject: [PATCH 271/416] fix: Fix no predicates for brillig with intermediate
 functions (#5015)

# Description

## Problem\*

Fixes https://github.com/noir-lang/noir/pull/5012 using the entry point
instead of the source function, to consider intermediate functions.

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/opt/inlining.rs              | 3 ++-
 .../execution_success/no_predicates_brillig/src/main.nr       | 4 ++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 77b9e545e03..73dc3888184 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -393,10 +393,11 @@ impl<'function> PerFunctionContext<'function> {
                         let function = &ssa.functions[&func_id];
                         // If we have not already finished the flattening pass, functions marked
                         // to not have predicates should be marked as entry points unless we are inlining into brillig.
+                        let entry_point = &ssa.functions[&self.context.entry_point];
                         let no_predicates_is_entry_point =
                             self.context.no_predicates_is_entry_point
                                 && function.is_no_predicates()
-                                && !matches!(self.source_function.runtime(), RuntimeType::Brillig);
+                                && !matches!(entry_point.runtime(), RuntimeType::Brillig);
                         if function.runtime().is_entry_point() || no_predicates_is_entry_point {
                             self.push_instruction(*id);
                         } else {
diff --git a/test_programs/execution_success/no_predicates_brillig/src/main.nr b/test_programs/execution_success/no_predicates_brillig/src/main.nr
index 1d088473aa7..65e2e5d61fe 100644
--- a/test_programs/execution_success/no_predicates_brillig/src/main.nr
+++ b/test_programs/execution_success/no_predicates_brillig/src/main.nr
@@ -1,4 +1,8 @@
 unconstrained fn main(x: u32, y: pub u32) {
+    intermediate_function(x, y);
+}
+
+fn intermediate_function(x: u32, y: u32) {
     basic_checks(x, y);
 }
 

From e5ab24d6a4154d11b3c8ae08f4431b7b93c76f23 Mon Sep 17 00:00:00 2001
From: Innokentii Sennovskii <isennovskiy@gmail.com>
Date: Tue, 14 May 2024 15:06:21 +0100
Subject: [PATCH 272/416] fix: Fixed several vulnerabilities in U128, added
 some tests (#5024)

# Description

## Summary\*

I added the tests for construction and depedent functions, unconstrained
division and wrapping multiplication, fixing several bugs. I also added
a directory with the bugs so that it's easier to dive into what sort of
issues we come across in the future.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/uint128.nr          | 244 ++++++++++++++++++++++++++--
 security/insectarium/noir_stdlib.md |  61 +++++++
 2 files changed, 290 insertions(+), 15 deletions(-)
 create mode 100644 security/insectarium/noir_stdlib.md

diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index 9c61fc801f3..173fa54863a 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -1,8 +1,9 @@
 use crate::ops::{Add, Sub, Mul, Div, Rem, Not, BitOr, BitAnd, BitXor, Shl, Shr};
 use crate::cmp::{Eq, Ord, Ordering};
+use crate::println;
 
 global pow64 : Field = 18446744073709551616; //2^64;
-
+global pow63 : Field = 9223372036854775808; // 2^63;
 struct U128 {
     lo: Field,
     hi: Field,
@@ -20,6 +21,13 @@ impl U128 {
         U128::from_u64s_le(lo, hi)
     }
 
+    pub fn zero() -> U128 {
+        U128 { lo: 0, hi: 0 }
+    }
+
+    pub fn one() -> U128 {
+        U128 { lo: 1, hi: 0 }
+    }
     pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {
         let mut lo = 0;
         let mut base = 1;
@@ -87,27 +95,44 @@ impl U128 {
         U128 { lo: lo as Field, hi: hi as Field }
     }
 
+    unconstrained fn uconstrained_check_is_upper_ascii(ascii: u8) -> bool {
+        ((ascii >= 65) & (ascii <= 90)) // Between 'A' and 'Z'
+    }
+
     fn decode_ascii(ascii: u8) -> Field {
         if ascii < 58 {
             ascii - 48
-        } else if ascii < 71 {
-            ascii - 55
         } else {
+            let ascii = ascii + 32 * (U128::uconstrained_check_is_upper_ascii(ascii) as u8);
+            assert(ascii >= 97); // enforce >= 'a'
+            assert(ascii <= 102); // enforce <= 'f'
             ascii - 87
         } as Field
     }
 
+    // TODO: Replace with a faster version. 
+    // A circuit that uses this function can be slow to compute
+    // (we're doing up to 127 calls to compute the quotient)
     unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {
-        if self < b {
-            (U128::from_u64s_le(0, 0), self)
+        if b == U128::zero() {
+            // Return 0,0 to avoid eternal loop
+            (U128::zero(), U128::zero())
+        } else if self < b {
+            (U128::zero(), self)
+        } else if self == b {
+            (U128::one(), U128::zero())
         } else {
-            //TODO check if this can overflow?
-            let (q,r) = self.unconstrained_div(b * U128::from_u64s_le(2, 0));
+            let (q,r) = if b.hi as u64 >= pow63 as u64 {
+                // The result of multiplication by 2 would overflow
+                (U128::zero(), self)
+            } else {
+                self.unconstrained_div(b * U128::from_u64s_le(2, 0))
+            };
             let q_mul_2 = q * U128::from_u64s_le(2, 0);
             if r < b {
                 (q_mul_2, r)
             } else {
-                (q_mul_2 + U128::from_u64s_le(1, 0), r - b)
+                (q_mul_2 + U128::one(), r - b)
             }
         }
     }
@@ -129,11 +154,7 @@ impl U128 {
         let low = self.lo * b.lo;
         let lo = low as u64 as Field;
         let carry = (low - lo) / pow64;
-        let high = if crate::field::modulus_num_bits() as u32 > 196 {
-            (self.lo + self.hi) * (b.lo + b.hi) - low + carry
-        } else {
-            self.lo * b.hi + self.hi * b.lo + carry
-        };
+        let high = self.lo * b.hi + self.hi * b.lo + carry;
         let hi = high as u64 as Field;
         U128 { lo, hi }
     }
@@ -294,8 +315,8 @@ impl Shr for U128 {
     } 
 }
 
-mod test {
-    use crate::uint128::{U128, pow64};
+mod tests {
+    use crate::uint128::{U128, pow64, pow63};
 
     #[test]
     fn test_not() {
@@ -309,4 +330,197 @@ mod test {
         let not_not_num = not_num.not();
         assert_eq(num, not_not_num);
     }
+    #[test]
+    fn test_construction() {
+        // Check little-endian u64 is inversed with big-endian u64 construction
+        let a = U128::from_u64s_le(2, 1);
+        let b = U128::from_u64s_be(1, 2);
+        assert_eq(a, b);
+        // Check byte construction is equivalent
+        let c = U128::from_le_bytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
+        let d = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);
+        assert_eq(c, d);
+    }
+    #[test]
+    fn test_byte_decomposition() {
+        let a = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);
+        // Get big-endian and little-endian byte decompostions
+        let le_bytes_a= a.to_le_bytes();
+        let be_bytes_a= a.to_be_bytes();
+
+        // Check equivalence
+        for i in 0..16 {
+            assert_eq(le_bytes_a[i], be_bytes_a[15 - i]);
+        }
+        // Reconstruct U128 from byte decomposition
+        let b= U128::from_le_bytes(le_bytes_a);
+        // Check that it's the same element
+        assert_eq(a, b);
+    }
+    #[test]
+    fn test_hex_constuction() {
+        let a = U128::from_u64s_le(0x1, 0x2);
+        let b = U128::from_hex("0x20000000000000001");
+        assert_eq(a, b);
+
+        let c= U128::from_hex("0xffffffffffffffffffffffffffffffff");
+        let d= U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);
+        assert_eq(c, d);
+
+        let e= U128::from_hex("0x00000000000000000000000000000000");
+        let f= U128::from_u64s_le(0, 0);
+        assert_eq(e, f);
+    }
+
+    // Ascii decode tests
+
+    #[test]
+    fn test_ascii_decode_correct_range() {
+        // '0'..'9' range
+        for i in 0..10 {
+            let decoded= U128::decode_ascii(48 + i);
+            assert_eq(decoded, i as Field);
+        }
+        // 'A'..'F' range
+        for i in 0..6 {
+            let decoded = U128::decode_ascii(65 + i);
+            assert_eq(decoded, (i + 10) as Field);
+        }
+        // 'a'..'f' range
+        for i in 0..6 {
+            let decoded = U128::decode_ascii(97 + i);
+            assert_eq(decoded, (i + 10) as Field);
+        }
+    }
+
+    #[test(should_fail)]
+    fn test_ascii_decode_range_less_than_48_fails_0() {
+        crate::println(U128::decode_ascii(0));
+    }
+    #[test(should_fail)]
+    fn test_ascii_decode_range_less_than_48_fails_1() {
+        crate::println(U128::decode_ascii(47));
+    }
+
+    #[test(should_fail)]
+    fn test_ascii_decode_range_58_64_fails_0() {
+        let _ = U128::decode_ascii(58);
+    }
+    #[test(should_fail)]
+    fn test_ascii_decode_range_58_64_fails_1() {
+        let _ = U128::decode_ascii(64);
+    }
+    #[test(should_fail)]
+    fn test_ascii_decode_range_71_96_fails_0() {
+        let _ = U128::decode_ascii(71);
+    }
+    #[test(should_fail)]
+    fn test_ascii_decode_range_71_96_fails_1() {
+        let _ = U128::decode_ascii(96);
+    }
+    #[test(should_fail)]
+    fn test_ascii_decode_range_greater_than_102_fails() {
+        let _ = U128::decode_ascii(103);
+    }
+
+    #[test(should_fail)]
+    fn test_ascii_decode_regression() {
+        // This code will actually fail because of ascii_decode,
+        // but in the past it was possible to create a value > (1<<128)
+        let a = U128::from_hex("0x~fffffffffffffffffffffffffffffff");
+        let b:Field= a.to_integer();
+        let c= b.to_le_bytes(17);
+        assert(c[16] != 0);
+    }
+
+    #[test]
+    fn test_unconstrained_div() {
+        // Test the potential overflow case
+        let a= U128::from_u64s_le(0x0, 0xffffffffffffffff);
+        let b= U128::from_u64s_le(0x0, 0xfffffffffffffffe);
+        let c= U128::one();
+        let d= U128::from_u64s_le(0x0, 0x1);
+        let (q,r) = a.unconstrained_div(b);
+        assert_eq(q, c);
+        assert_eq(r, d);
+
+        let a = U128::from_u64s_le(2, 0);
+        let b = U128::one();
+        // Check the case where a is a multiple of b
+        let (c,d ) = a.unconstrained_div(b);
+        assert_eq((c, d), (a, U128::zero()));
+
+        // Check where b is a multiple of a
+        let (c,d) = b.unconstrained_div(a);
+        assert_eq((c, d), (U128::zero(), b));
+
+        // Dividing by zero returns 0,0
+        let a = U128::from_u64s_le(0x1, 0x0);
+        let b = U128::zero();
+        let (c,d)= a.unconstrained_div(b);
+        assert_eq((c, d), (U128::zero(), U128::zero()));
+
+        // Dividing 1<<127 by 1<<127 (special case)
+        let a = U128::from_u64s_le(0x0, pow63 as u64);
+        let b = U128::from_u64s_le(0x0, pow63 as u64);
+        let (c,d )= a.unconstrained_div(b);
+        assert_eq((c, d), (U128::one(), U128::zero()));
+    }
+
+    #[test]
+    fn integer_conversions() {
+        // Maximum
+        let start:Field = 0xffffffffffffffffffffffffffffffff;
+        let a = U128::from_integer(start);
+        let end = a.to_integer();
+        assert_eq(start, end);
+
+        // Minimum
+        let start:Field = 0x0;
+        let a = U128::from_integer(start);
+        let end = a.to_integer();
+        assert_eq(start, end);
+
+        // Low limb
+        let start:Field = 0xffffffffffffffff;
+        let a = U128::from_integer(start);
+        let end = a.to_integer();
+        assert_eq(start, end);
+
+        // High limb
+        let start:Field = 0xffffffffffffffff0000000000000000;
+        let a = U128::from_integer(start);
+        let end = a.to_integer();
+        assert_eq(start, end);
+    }
+    #[test]
+    fn test_wrapping_mul() {
+        // 1*0==0
+        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::one()));
+
+        // 0*1==0
+        assert_eq(U128::zero(), U128::one().wrapping_mul(U128::zero()));
+
+        // 1*1==1
+        assert_eq(U128::one(), U128::one().wrapping_mul(U128::one()));
+
+        // 0 * ( 1 << 64 ) ==  0
+        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::from_u64s_le(0, 1)));
+
+        // ( 1 << 64 ) * 0 == 0
+        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::zero()));
+
+        // 1 * ( 1 << 64 ) == 1 << 64
+        assert_eq(U128::from_u64s_le(0, 1), U128::from_u64s_le(0, 1).wrapping_mul(U128::one()));
+
+        // ( 1 << 64 ) * 1 == 1 << 64
+        assert_eq(U128::from_u64s_le(0, 1), U128::one().wrapping_mul(U128::from_u64s_le(0, 1)));
+
+        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64
+        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::from_u64s_le(0, 1)));
+        // -1 * -1 == 1
+        assert_eq(
+            U128::one(), U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff))
+        );
+    }
 }
diff --git a/security/insectarium/noir_stdlib.md b/security/insectarium/noir_stdlib.md
new file mode 100644
index 00000000000..5ec4eb5f6cd
--- /dev/null
+++ b/security/insectarium/noir_stdlib.md
@@ -0,0 +1,61 @@
+# Bugs found in Noir stdlib
+
+## U128
+
+### decode_ascii
+Old **decode_ascii** function didn't check that the values of individual bytes in the string were just in the range of [0-9a-f-A-F].
+```rust
+fn decode_ascii(ascii: u8) -> Field {
+    if ascii < 58 {
+        ascii - 48
+    } else if ascii < 71 {
+        ascii - 55
+    } else {
+        ascii - 87
+    } as Field
+}
+```
+Since the function used the assumption that decode_ascii returns values in range [0,15] to construct **lo** and **hi** it was possible to overflow these 64-bit limbs.
+
+### unconstrained_div
+```rust
+ unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {
+        if self < b {
+            (U128::from_u64s_le(0, 0), self)
+        } else {
+            //TODO check if this can overflow?
+            let (q,r) = self.unconstrained_div(b * U128::from_u64s_le(2, 0));
+            let q_mul_2 = q * U128::from_u64s_le(2, 0);
+            if r < b {
+                (q_mul_2, r)
+            } else {
+                (q_mul_2 + U128::from_u64s_le(1, 0), r - b)
+            }
+        }
+    }
+```
+There were 2 issues in unconstrained_div:
+1) Attempting to divide by zero resulted in an infinite loop, because there was no check.
+2) $a >= 2^{127}$ cause the function to multiply b to such power of 2 that the result would be more than $2^{128}$ and lead to assertion failure even though it was a legitimate input
+
+N.B. initial fix by Rumata888 also had an edgecase missing for when a==b and b >= (1<<127).
+
+### wrapping_mul
+```rust
+fn wrapping_mul(self: Self, b: U128) -> U128 {
+        let low = self.lo * b.lo;
+        let lo = low as u64 as Field;
+        let carry = (low - lo) / pow64;
+        let high = if crate::field::modulus_num_bits() as u32 > 196 {
+            (self.lo + self.hi) * (b.lo + b.hi) - low + carry // Bug
+        } else {
+            self.lo * b.hi + self.hi * b.lo + carry
+        };
+        let hi = high as u64 as Field;
+        U128 { lo, hi }
+    }
+```
+Wrapping mul had the code copied from regular mul barring the assertion that the product of high limbs is zero. Because that check was removed, the optimized path for moduli > 196 bits was incorrect, since it included their product (as at least one of them was supposed to be zero originally, but not for wrapping multiplication)
+
+
+

From a5b7df12faf9d71ff24f8c5cde5e78da44558caf Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Tue, 14 May 2024 19:31:46 +0200
Subject: [PATCH 273/416] feat: do not return databus returndata, keep it
 private. (#5023)

# Description

## Problem\*

Related to  #4974

## Summary\*
Very small PR which avoids returning databus objects, because they need
to be handled as private inputs.
This is incremental work, so it cannot be tested yet. The PR only impact
databus use case.



## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 21 +++++++++++++++----
 tooling/noirc_abi/src/lib.rs                  | 10 ++++++++-
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index dea7e2fa13b..05d2e3e3e6a 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1729,13 +1729,16 @@ impl<'a> Context<'a> {
         // will expand the array if there is one.
         let return_acir_vars = self.flatten_value_list(return_values, dfg)?;
         let mut warnings = Vec::new();
-        for acir_var in return_acir_vars {
+        for (acir_var, is_databus) in return_acir_vars {
             if self.acir_context.is_constant(&acir_var) {
                 warnings.push(SsaReport::Warning(InternalWarning::ReturnConstant {
                     call_stack: call_stack.clone(),
                 }));
             }
-            self.acir_context.return_var(acir_var)?;
+            if !is_databus {
+                // We do not return value for the data bus.
+                self.acir_context.return_var(acir_var)?;
+            }
         }
         Ok(warnings)
     }
@@ -2659,12 +2662,22 @@ impl<'a> Context<'a> {
         &mut self,
         arguments: &[ValueId],
         dfg: &DataFlowGraph,
-    ) -> Result<Vec<AcirVar>, InternalError> {
+    ) -> Result<Vec<(AcirVar, bool)>, InternalError> {
         let mut acir_vars = Vec::with_capacity(arguments.len());
         for value_id in arguments {
+            let is_databus = if let Some(return_databus) = self.data_bus.return_data {
+                dfg[*value_id] == dfg[return_databus]
+            } else {
+                false
+            };
             let value = self.convert_value(*value_id, dfg);
             acir_vars.append(
-                &mut self.acir_context.flatten(value)?.iter().map(|(var, _)| *var).collect(),
+                &mut self
+                    .acir_context
+                    .flatten(value)?
+                    .iter()
+                    .map(|(var, _)| (*var, is_databus))
+                    .collect(),
             );
         }
         Ok(acir_vars)
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 7e89a102a98..7a1d1787ca5 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -471,7 +471,15 @@ impl Abi {
                         .copied()
                 })
             {
-                Some(decode_value(&mut return_witness_values.into_iter(), &return_type.abi_type)?)
+                // We do not return value for the data bus.
+                if return_type.visibility == AbiVisibility::DataBus {
+                    None
+                } else {
+                    Some(decode_value(
+                        &mut return_witness_values.into_iter(),
+                        &return_type.abi_type,
+                    )?)
+                }
             } else {
                 // Unlike for the circuit inputs, we tolerate not being able to find the witness values for the return value.
                 // This is because the user may be decoding a partial witness map for which is hasn't been calculated yet.

From abe49df24fb024414f00c9650c5a39ec6444b1a7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 20 May 2024 01:24:09 +0100
Subject: [PATCH 274/416] chore: add benchmarks for pedersen and schnorr
 verification (#5056)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds benchmarks for pedersen commitments/hashes as well as
schnorr signature verification.

```
pedersen_commitment     time:   [542.17 µs 543.27 µs 544.40 µs]

pedersen_hash           time:   [850.69 µs 852.11 µs 853.68 µs]

schnorr_verify          time:   [1.5978 ms 1.5997 ms 1.6018 ms]
```

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../benches/criterion.rs                      | 53 ++++++++++++++++++-
 1 file changed, 51 insertions(+), 2 deletions(-)

diff --git a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
index eb529ed2c11..a8fa7d8aae4 100644
--- a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
+++ b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
@@ -2,7 +2,8 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use std::{hint::black_box, time::Duration};
 
 use acir::FieldElement;
-use bn254_blackbox_solver::poseidon2_permutation;
+use acvm_blackbox_solver::BlackBoxFunctionSolver;
+use bn254_blackbox_solver::{poseidon2_permutation, Bn254BlackBoxSolver};
 
 use pprof::criterion::{Output, PProfProfiler};
 
@@ -12,10 +13,58 @@ fn bench_poseidon2(c: &mut Criterion) {
     c.bench_function("poseidon2", |b| b.iter(|| poseidon2_permutation(black_box(&inputs), 4)));
 }
 
+fn bench_pedersen_commitment(c: &mut Criterion) {
+    let inputs = [FieldElement::one(); 2];
+    let solver = Bn254BlackBoxSolver::new();
+
+    c.bench_function("pedersen_commitment", |b| {
+        b.iter(|| solver.pedersen_commitment(black_box(&inputs), 0))
+    });
+}
+
+fn bench_pedersen_hash(c: &mut Criterion) {
+    let inputs = [FieldElement::one(); 2];
+    let solver = Bn254BlackBoxSolver::new();
+
+    c.bench_function("pedersen_hash", |b| b.iter(|| solver.pedersen_hash(black_box(&inputs), 0)));
+}
+
+fn bench_schnorr_verify(c: &mut Criterion) {
+    let solver = Bn254BlackBoxSolver::new();
+
+    let pub_key_x = FieldElement::from_hex(
+        "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
+    )
+    .unwrap();
+    let pub_key_y = FieldElement::from_hex(
+        "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
+    )
+    .unwrap();
+    let sig_bytes: [u8; 64] = [
+        1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76, 77,
+        33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84, 247, 27,
+        22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64, 199, 19, 84,
+        239, 138, 124, 12,
+    ];
+
+    let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    c.bench_function("schnorr_verify", |b| {
+        b.iter(|| {
+            solver.schnorr_verify(
+                black_box(&pub_key_x),
+                black_box(&pub_key_y),
+                black_box(&sig_bytes),
+                black_box(message),
+            )
+        })
+    });
+}
+
 criterion_group!(
     name = benches;
     config = Criterion::default().sample_size(40).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = bench_poseidon2
+    targets = bench_poseidon2, bench_pedersen_commitment, bench_pedersen_hash, bench_schnorr_verify
 );
 
 criterion_main!(benches);

From fb039f74df23aea39bc0593a5d538d82b4efadf0 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 20 May 2024 16:42:29 +0100
Subject: [PATCH 275/416] feat: add native rust implementations of pedersen
 functions (#4871)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves #4863

## Summary\*

This PR pulls in the relevant code from
[Barustenberg](https://github.com/laudiacay/barustenberg) for performing
pedersen commitments + hashes. Tests are currently failing (seems like
Barustenberg is failing its own CI) however it's a good starting point
for a working implementation.

In order for this PR to be merged we should have tests in barretenberg
which shows expected outputs for all of these added functions and this
code should replicate those.

Benchmarks relative to #5056
```
pedersen_commitment     time:   [3.5018 µs 3.5059 µs 3.5102 µs]
                        change: [-99.357% -99.356% -99.354%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 1 outliers among 40 measurements (2.50%)
  1 (2.50%) low mild

pedersen_hash           time:   [6.9828 µs 6.9920 µs 7.0021 µs]
                        change: [-99.181% -99.180% -99.178%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 2 outliers among 40 measurements (5.00%)
  2 (5.00%) high mild
```

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |   1 +
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   1 +
 .../src/generator/generators.rs               | 184 ++++++++++++++++++
 .../src/generator/hash_to_curve.rs            | 135 +++++++++++++
 .../src/generator/mod.rs                      |   8 +
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |  24 ++-
 .../src/pedersen/commitment.rs                |  76 ++++++++
 .../src/pedersen/hash.rs                      |  68 +++++++
 .../bn254_blackbox_solver/src/pedersen/mod.rs |   2 +
 .../src/wasm/barretenberg_structures.rs       |  25 ---
 .../bn254_blackbox_solver/src/wasm/mod.rs     |  20 --
 .../src/wasm/pedersen.rs                      |  73 -------
 cspell.json                                   |   1 +
 13 files changed, 491 insertions(+), 127 deletions(-)
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/generator/generators.rs
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/generator/hash_to_curve.rs
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/generator/mod.rs
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs
 delete mode 100644 acvm-repo/bn254_blackbox_solver/src/wasm/barretenberg_structures.rs
 delete mode 100644 acvm-repo/bn254_blackbox_solver/src/wasm/pedersen.rs

diff --git a/Cargo.lock b/Cargo.lock
index a8c63c032aa..2e8eeb10a58 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -614,6 +614,7 @@ dependencies = [
  "acvm_blackbox_solver",
  "ark-ec",
  "ark-ff",
+ "ark-std",
  "cfg-if 1.0.0",
  "criterion",
  "getrandom 0.2.10",
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 3a6c9b1d55b..b261be65735 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -40,6 +40,7 @@ getrandom.workspace = true
 wasmer = "4.2.6"
 
 [dev-dependencies]
+ark-std = { version = "^0.4.0", default-features = false }
 criterion = "0.5.0"
 pprof = { version = "0.12", features = [
     "flamegraph",
diff --git a/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs b/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs
new file mode 100644
index 00000000000..f89d582d167
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs
@@ -0,0 +1,184 @@
+// Adapted from https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/ecc/groups/affine_element.rshttps://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/ecc/groups/group.rs
+//!
+//! Code is used under the MIT license
+
+use std::sync::OnceLock;
+
+use ark_ec::short_weierstrass::Affine;
+
+use acvm_blackbox_solver::blake3;
+use grumpkin::GrumpkinParameters;
+
+use super::hash_to_curve::hash_to_curve;
+
+pub(crate) const DEFAULT_DOMAIN_SEPARATOR: &[u8] = "DEFAULT_DOMAIN_SEPARATOR".as_bytes();
+const NUM_DEFAULT_GENERATORS: usize = 8;
+
+fn default_generators() -> &'static [Affine<GrumpkinParameters>; NUM_DEFAULT_GENERATORS] {
+    static INSTANCE: OnceLock<[Affine<GrumpkinParameters>; NUM_DEFAULT_GENERATORS]> =
+        OnceLock::new();
+    INSTANCE.get_or_init(|| {
+        _derive_generators(DEFAULT_DOMAIN_SEPARATOR, NUM_DEFAULT_GENERATORS as u32, 0)
+            .try_into()
+            .expect("Should generate `NUM_DEFAULT_GENERATORS`")
+    })
+}
+
+/// Derives generator points via [hash-to-curve][hash_to_curve].
+///
+/// # ALGORITHM DESCRIPTION
+///
+/// 1. Each generator has an associated "generator index" described by its location in the vector
+/// 2. a 64-byte preimage buffer is generated with the following structure:
+///     - bytes 0-31: BLAKE3 hash of domain_separator
+///     - bytes 32-63: generator index in big-endian form
+/// 3. The [hash-to-curve algorithm][hash_to_curve] is used to hash the above into a curve point.
+///
+/// NOTE: The domain separator is included to ensure that it is possible to derive independent sets of
+/// index-addressable generators.
+///
+/// [hash_to_curve]: super::hash_to_curve::hash_to_curve
+pub(crate) fn derive_generators(
+    domain_separator_bytes: &[u8],
+    num_generators: u32,
+    starting_index: u32,
+) -> Vec<Affine<GrumpkinParameters>> {
+    // We cache a small number of the default generators so we can reuse them without needing to repeatedly recalculate them.
+    if domain_separator_bytes == DEFAULT_DOMAIN_SEPARATOR
+        && starting_index + num_generators <= NUM_DEFAULT_GENERATORS as u32
+    {
+        let start_index = starting_index as usize;
+        let end_index = (starting_index + num_generators) as usize;
+        default_generators()[start_index..end_index].to_vec()
+    } else {
+        _derive_generators(domain_separator_bytes, num_generators, starting_index)
+    }
+}
+
+fn _derive_generators(
+    domain_separator_bytes: &[u8],
+    num_generators: u32,
+    starting_index: u32,
+) -> Vec<Affine<GrumpkinParameters>> {
+    let mut generator_preimage = [0u8; 64];
+    let domain_hash = blake3(domain_separator_bytes).expect("hash should succeed");
+    //1st 32 bytes are blake3 domain_hash
+    generator_preimage[..32].copy_from_slice(&domain_hash);
+
+    // Convert generator index in big-endian form
+    let mut res = Vec::with_capacity(num_generators as usize);
+    for i in starting_index..(starting_index + num_generators) {
+        let generator_be_bytes: [u8; 4] = i.to_be_bytes();
+        generator_preimage[32] = generator_be_bytes[0];
+        generator_preimage[33] = generator_be_bytes[1];
+        generator_preimage[34] = generator_be_bytes[2];
+        generator_preimage[35] = generator_be_bytes[3];
+        let generator = hash_to_curve(&generator_preimage, 0);
+        res.push(generator);
+    }
+    res
+}
+
+#[cfg(test)]
+mod test {
+
+    use ark_ec::AffineRepr;
+    use ark_ff::{BigInteger, PrimeField};
+
+    use super::*;
+
+    #[test]
+    fn test_derive_generators() {
+        let res = derive_generators("test domain".as_bytes(), 128, 0);
+
+        let is_unique = |y: Affine<grumpkin::GrumpkinParameters>, j: usize| -> bool {
+            for (i, res) in res.iter().enumerate() {
+                if i != j && *res == y {
+                    return false;
+                }
+            }
+            true
+        };
+
+        for (i, res) in res.iter().enumerate() {
+            assert!(is_unique(*res, i));
+            assert!(res.is_on_curve());
+        }
+    }
+
+    #[test]
+    fn derive_length_generator() {
+        let domain_separator = "pedersen_hash_length";
+        let length_generator = derive_generators(domain_separator.as_bytes(), 1, 0)[0];
+
+        let expected_generator = (
+            "2df8b940e5890e4e1377e05373fae69a1d754f6935e6a780b666947431f2cdcd",
+            "2ecd88d15967bc53b885912e0d16866154acb6aac2d3f85e27ca7eefb2c19083",
+        );
+        assert_eq!(
+            hex::encode(length_generator.x().unwrap().into_bigint().to_bytes_be()),
+            expected_generator.0,
+            "Failed on x component"
+        );
+        assert_eq!(
+            hex::encode(length_generator.y().unwrap().into_bigint().to_bytes_be()),
+            expected_generator.1,
+            "Failed on y component"
+        );
+    }
+
+    #[test]
+    fn derives_default_generators() {
+        const DEFAULT_GENERATORS: &[[&str; 2]] = &[
+            [
+                "083e7911d835097629f0067531fc15cafd79a89beecb39903f69572c636f4a5a",
+                "1a7f5efaad7f315c25a918f30cc8d7333fccab7ad7c90f14de81bcc528f9935d",
+            ],
+            [
+                "054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402",
+                "209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126",
+            ],
+            [
+                "1c44f2a5207c81c28a8321a5815ce8b1311024bbed131819bbdaf5a2ada84748",
+                "03aaee36e6422a1d0191632ac6599ae9eba5ac2c17a8c920aa3caf8b89c5f8a8",
+            ],
+            [
+                "26d8b1160c6821a30c65f6cb47124afe01c29f4338f44d4a12c9fccf22fb6fb2",
+                "05c70c3b9c0d25a4c100e3a27bf3cc375f8af8cdd9498ec4089a823d7464caff",
+            ],
+            [
+                "20ed9c6a1d27271c4498bfce0578d59db1adbeaa8734f7facc097b9b994fcf6e",
+                "29cd7d370938b358c62c4a00f73a0d10aba7e5aaa04704a0713f891ebeb92371",
+            ],
+            [
+                "0224a8abc6c8b8d50373d64cd2a1ab1567bf372b3b1f7b861d7f01257052d383",
+                "2358629b90eafb299d6650a311e79914b0215eb0a790810b26da5a826726d711",
+            ],
+            [
+                "0f106f6d46bc904a5290542490b2f238775ff3c445b2f8f704c466655f460a2a",
+                "29ab84d472f1d33f42fe09c47b8f7710f01920d6155250126731e486877bcf27",
+            ],
+            [
+                "0298f2e42249f0519c8a8abd91567ebe016e480f219b8c19461d6a595cc33696",
+                "035bec4b8520a4ece27bd5aafabee3dfe1390d7439c419a8c55aceb207aac83b",
+            ],
+        ];
+
+        let generated_generators =
+            derive_generators(DEFAULT_DOMAIN_SEPARATOR, DEFAULT_GENERATORS.len() as u32, 0);
+        for (i, (generator, expected_generator)) in
+            generated_generators.iter().zip(DEFAULT_GENERATORS).enumerate()
+        {
+            assert_eq!(
+                hex::encode(generator.x().unwrap().into_bigint().to_bytes_be()),
+                expected_generator[0],
+                "Failed on x component of generator {i}"
+            );
+            assert_eq!(
+                hex::encode(generator.y().unwrap().into_bigint().to_bytes_be()),
+                expected_generator[1],
+                "Failed on y component of generator {i}"
+            );
+        }
+    }
+}
diff --git a/acvm-repo/bn254_blackbox_solver/src/generator/hash_to_curve.rs b/acvm-repo/bn254_blackbox_solver/src/generator/hash_to_curve.rs
new file mode 100644
index 00000000000..c0197883442
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/generator/hash_to_curve.rs
@@ -0,0 +1,135 @@
+// Adapted from https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/ecc/groups/affine_element.rs
+//!
+//! Code is used under the MIT license
+
+use acvm_blackbox_solver::blake3;
+
+use ark_ec::{short_weierstrass::Affine, AffineRepr, CurveConfig};
+use ark_ff::Field;
+use ark_ff::{BigInteger, PrimeField};
+use grumpkin::GrumpkinParameters;
+
+/// Hash a seed buffer into a point
+///
+/// # ALGORITHM DESCRIPTION
+///
+///  1. Initialize unsigned integer `attempt_count = 0`
+///  2. Copy seed into a buffer whose size is 2 bytes greater than `seed` (initialized to `0`)
+///  3. Interpret `attempt_count` as a byte and write into buffer at `[buffer.size() - 2]`
+///  4. Compute Blake3 hash of buffer
+///  5. Set the end byte of the buffer to `1`
+///  6. Compute Blake3 hash of buffer
+///  7. Interpret the two hash outputs as the high / low 256 bits of a 512-bit integer (big-endian)
+///  8. Derive x-coordinate of point by reducing the 512-bit integer modulo the curve's field modulus (Fq)
+///  9. Compute `y^2` from the curve formula `y^2 = x^3 + ax + b` (`a`, `b` are curve params. for BN254, `a = 0`, `b = 3`)
+///  10. IF `y^2` IS NOT A QUADRATIC RESIDUE:
+///
+///  a. increment `attempt_count` by 1 and go to step 2
+///  
+///  11. IF `y^2` IS A QUADRATIC RESIDUE:
+///
+///  a. derive y coordinate via `y = sqrt(y)`
+///
+///  b. Interpret most significant bit of 512-bit integer as a 'parity' bit
+///
+///  c. If parity bit is set AND `y`'s most significant bit is not set, invert `y`
+///
+///  d. If parity bit is not set AND `y`'s most significant bit is set, invert `y`
+///
+///  e. return (x, y)
+///
+///  N.B. steps c. and e. are because the `sqrt()` algorithm can return 2 values,
+///  we need to a way to canonically distinguish between these 2 values and select a "preferred" one
+pub(crate) fn hash_to_curve(seed: &[u8], attempt_count: u8) -> Affine<GrumpkinParameters> {
+    let seed_size = seed.len();
+    // expand by 2 bytes to cover incremental hash attempts
+    let mut target_seed = seed.to_vec();
+    target_seed.extend_from_slice(&[0u8; 2]);
+
+    target_seed[seed_size] = attempt_count;
+    target_seed[seed_size + 1] = 0;
+    let hash_hi = blake3(&target_seed).expect("hash should succeed");
+    target_seed[seed_size + 1] = 1;
+    let hash_lo = blake3(&target_seed).expect("hash should succeed");
+
+    let mut hash = hash_hi.to_vec();
+    hash.extend_from_slice(&hash_lo);
+
+    // Here we reduce the 512 bit number modulo the base field modulus to calculate `x`
+    let x = <<GrumpkinParameters as CurveConfig>::BaseField as Field>::BasePrimeField::from_be_bytes_mod_order(&hash);
+    let x = <GrumpkinParameters as CurveConfig>::BaseField::from_base_prime_field(x);
+
+    if let Some(point) = Affine::<GrumpkinParameters>::get_point_from_x_unchecked(x, false) {
+        let parity_bit = hash_hi[0] > 127;
+        let y_bit_set = point.y().unwrap().into_bigint().get_bit(0);
+        if (parity_bit && !y_bit_set) || (!parity_bit && y_bit_set) {
+            -point
+        } else {
+            point
+        }
+    } else {
+        hash_to_curve(seed, attempt_count + 1)
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use ark_ec::AffineRepr;
+    use ark_ff::{BigInteger, PrimeField};
+
+    use super::hash_to_curve;
+
+    #[test]
+    fn smoke_test() {
+        let test_cases: [(&[u8], u8, (&str, &str)); 4] = [
+            (
+                &[],
+                0,
+                (
+                    "24c4cb9c1206ab5470592f237f1698abe684dadf0ab4d7a132c32b2134e2c12e",
+                    "0668b8d61a317fb34ccad55c930b3554f1828a0e5530479ecab4defe6bbc0b2e",
+                ),
+            ),
+            (
+                &[],
+                1,
+                (
+                    "24c4cb9c1206ab5470592f237f1698abe684dadf0ab4d7a132c32b2134e2c12e",
+                    "0668b8d61a317fb34ccad55c930b3554f1828a0e5530479ecab4defe6bbc0b2e",
+                ),
+            ),
+            (
+                &[1],
+                0,
+                (
+                    "107f1b633c6113f3222f39f6256f0546b41a4880918c86864b06471afb410454",
+                    "050cd3823d0c01590b6a50adcc85d2ee4098668fd28805578aa05a423ea938c6",
+                ),
+            ),
+            (
+                &[0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64],
+                0,
+                (
+                    "037c5c229ae495f6e8d1b4bf7723fafb2b198b51e27602feb8a4d1053d685093",
+                    "10cf9596c5b2515692d930efa2cf3817607e4796856a79f6af40c949b066969f",
+                ),
+            ),
+        ];
+
+        for (seed, attempt_count, expected_point) in test_cases {
+            let point = hash_to_curve(seed, attempt_count);
+            assert!(point.is_on_curve());
+            assert_eq!(
+                hex::encode(point.x().unwrap().into_bigint().to_bytes_be()),
+                expected_point.0,
+                "Failed on x component with seed {seed:?}, attempt_count {attempt_count}"
+            );
+            assert_eq!(
+                hex::encode(point.y().unwrap().into_bigint().to_bytes_be()),
+                expected_point.1,
+                "Failed on y component with seed {seed:?}, attempt_count {attempt_count}"
+            );
+        }
+    }
+}
diff --git a/acvm-repo/bn254_blackbox_solver/src/generator/mod.rs b/acvm-repo/bn254_blackbox_solver/src/generator/mod.rs
new file mode 100644
index 00000000000..0f62642516a
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/generator/mod.rs
@@ -0,0 +1,8 @@
+//! This module is adapted from the [Barustenberg][barustenberg] Rust implementation of the Barretenberg library.
+//!
+//! Code is used under the MIT license
+//!
+//! [barustenberg]: https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/
+
+pub(crate) mod generators;
+mod hash_to_curve;
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 4cb51b59755..ae6fb7999a0 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -6,14 +6,17 @@ use acir::{BlackBoxFunc, FieldElement};
 use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 mod embedded_curve_ops;
+mod generator;
+mod pedersen;
 mod poseidon2;
 mod wasm;
 
+use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use poseidon2::poseidon2_permutation;
 use wasm::Barretenberg;
 
-use self::wasm::{Pedersen, SchnorrSig};
+use self::wasm::SchnorrSig;
 
 pub struct Bn254BlackBoxSolver {
     blackbox_vendor: Barretenberg,
@@ -72,10 +75,13 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
         inputs: &[FieldElement],
         domain_separator: u32,
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        #[allow(deprecated)]
-        self.blackbox_vendor.encrypt(inputs.to_vec(), domain_separator).map_err(|err| {
-            BlackBoxResolutionError::Failed(BlackBoxFunc::PedersenCommitment, err.to_string())
-        })
+        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
+        let result = pedersen::commitment::commit_native_with_index(&inputs, domain_separator);
+        let res_x =
+            FieldElement::from_repr(*result.x().expect("should not commit to point at infinity"));
+        let res_y =
+            FieldElement::from_repr(*result.y().expect("should not commit to point at infinity"));
+        Ok((res_x, res_y))
     }
 
     fn pedersen_hash(
@@ -83,10 +89,10 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
         inputs: &[FieldElement],
         domain_separator: u32,
     ) -> Result<FieldElement, BlackBoxResolutionError> {
-        #[allow(deprecated)]
-        self.blackbox_vendor.hash(inputs.to_vec(), domain_separator).map_err(|err| {
-            BlackBoxResolutionError::Failed(BlackBoxFunc::PedersenCommitment, err.to_string())
-        })
+        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
+        let result = pedersen::hash::hash_with_index(&inputs, domain_separator);
+        let result = FieldElement::from_repr(result);
+        Ok(result)
     }
 
     fn multi_scalar_mul(
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
new file mode 100644
index 00000000000..6769150508a
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
@@ -0,0 +1,76 @@
+// Taken from: https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/crypto/pedersen/pederson.rs
+
+use ark_ec::{short_weierstrass::Affine, AffineRepr, CurveGroup};
+use ark_ff::{MontConfig, PrimeField};
+use grumpkin::{Fq, FqConfig, Fr, FrConfig, GrumpkinParameters};
+
+use crate::generator::generators::{derive_generators, DEFAULT_DOMAIN_SEPARATOR};
+
+/// Given a vector of fields, generate a pedersen commitment using the indexed generators.
+pub(crate) fn commit_native_with_index(
+    inputs: &[Fq],
+    starting_index: u32,
+) -> Affine<GrumpkinParameters> {
+    let generators =
+        derive_generators(DEFAULT_DOMAIN_SEPARATOR, inputs.len() as u32, starting_index);
+
+    // As |F_r| > |F_q|, we can safely convert any `F_q` into an `F_r` uniquely.
+    assert!(FrConfig::MODULUS > FqConfig::MODULUS);
+
+    inputs.iter().enumerate().fold(Affine::zero(), |mut acc, (i, input)| {
+        acc = (acc + (generators[i] * Fr::from_bigint(input.into_bigint()).unwrap()).into_affine())
+            .into_affine();
+        acc
+    })
+}
+
+#[cfg(test)]
+mod test {
+
+    use acir::FieldElement;
+    use ark_ec::short_weierstrass::Affine;
+    use ark_std::{One, Zero};
+    use grumpkin::Fq;
+
+    use crate::pedersen::commitment::commit_native_with_index;
+
+    #[test]
+    fn commitment() {
+        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.test.cpp#L10-L18
+        let res = commit_native_with_index(&[Fq::one(), Fq::one()], 0);
+        let expected = Affine::new(
+            FieldElement::from_hex(
+                "0x2f7a8f9a6c96926682205fb73ee43215bf13523c19d7afe36f12760266cdfe15",
+            )
+            .unwrap()
+            .into_repr(),
+            FieldElement::from_hex(
+                "0x01916b316adbbf0e10e39b18c1d24b33ec84b46daddf72f43878bcc92b6057e6",
+            )
+            .unwrap()
+            .into_repr(),
+        );
+
+        assert_eq!(res, expected);
+    }
+
+    #[test]
+    fn commitment_with_zero() {
+        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.test.cpp#L20-L29
+        let res = commit_native_with_index(&[Fq::zero(), Fq::one()], 0);
+        let expected = Affine::new(
+            FieldElement::from_hex(
+                "0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402",
+            )
+            .unwrap()
+            .into_repr(),
+            FieldElement::from_hex(
+                "0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126",
+            )
+            .unwrap()
+            .into_repr(),
+        );
+
+        assert_eq!(res, expected);
+    }
+}
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
new file mode 100644
index 00000000000..28bf354edc9
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
@@ -0,0 +1,68 @@
+// Taken from: https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/crypto/pedersen/pederson_hash.rs
+
+use std::sync::OnceLock;
+
+use ark_ec::{short_weierstrass::Affine, CurveConfig, CurveGroup};
+use grumpkin::GrumpkinParameters;
+
+use crate::generator::generators::derive_generators;
+
+use super::commitment::commit_native_with_index;
+
+/// Given a vector of fields, generate a pedersen hash using the indexed generators.
+pub(crate) fn hash_with_index(
+    inputs: &[grumpkin::Fq],
+    starting_index: u32,
+) -> <GrumpkinParameters as CurveConfig>::BaseField {
+    let length_as_scalar: <GrumpkinParameters as CurveConfig>::ScalarField =
+        (inputs.len() as u64).into();
+    let length_prefix = *length_generator() * length_as_scalar;
+    let result = length_prefix + commit_native_with_index(inputs, starting_index);
+    result.into_affine().x
+}
+
+fn length_generator() -> &'static Affine<GrumpkinParameters> {
+    static INSTANCE: OnceLock<Affine<GrumpkinParameters>> = OnceLock::new();
+    INSTANCE.get_or_init(|| derive_generators("pedersen_hash_length".as_bytes(), 1, 0)[0])
+}
+
+#[cfg(test)]
+pub(crate) mod test {
+
+    use super::*;
+
+    use acir::FieldElement;
+    use ark_std::One;
+    use grumpkin::Fq;
+
+    //reference: https://github.com/AztecProtocol/barretenberg/blob/master/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.test.cpp
+    #[test]
+    fn hash_one() {
+        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.test.cpp#L21-L26
+        let res = hash_with_index(&[Fq::one(), Fq::one()], 0);
+
+        assert_eq!(
+            res,
+            FieldElement::from_hex(
+                "0x07ebfbf4df29888c6cd6dca13d4bb9d1a923013ddbbcbdc3378ab8845463297b",
+            )
+            .unwrap()
+            .into_repr(),
+        );
+    }
+
+    #[test]
+    fn test_hash_with_index() {
+        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.test.cpp#L28-L33
+        let res = hash_with_index(&[Fq::one(), Fq::one()], 5);
+
+        assert_eq!(
+            res,
+            FieldElement::from_hex(
+                "0x1c446df60816b897cda124524e6b03f36df0cec333fad87617aab70d7861daa6",
+            )
+            .unwrap()
+            .into_repr(),
+        );
+    }
+}
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs
new file mode 100644
index 00000000000..c3c4ed56450
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod commitment;
+pub(crate) mod hash;
diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/barretenberg_structures.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/barretenberg_structures.rs
deleted file mode 100644
index 302ffa8af9b..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/barretenberg_structures.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use acir::FieldElement;
-
-#[derive(Debug, Default)]
-pub(crate) struct Assignments(Vec<FieldElement>);
-
-impl Assignments {
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let mut buffer = Vec::new();
-
-        let witness_len = self.0.len() as u32;
-        buffer.extend_from_slice(&witness_len.to_be_bytes());
-
-        for assignment in self.0.iter() {
-            buffer.extend_from_slice(&assignment.to_be_bytes());
-        }
-
-        buffer
-    }
-}
-
-impl From<Vec<FieldElement>> for Assignments {
-    fn from(w: Vec<FieldElement>) -> Assignments {
-        Assignments(w)
-    }
-}
diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
index f4f6f56aa99..e0a5c4c9069 100644
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
@@ -4,13 +4,8 @@
 //!
 //! As [`acvm`] includes rust implementations for these opcodes, this module can be removed.
 
-mod barretenberg_structures;
-mod pedersen;
 mod schnorr;
 
-use barretenberg_structures::Assignments;
-
-pub(crate) use pedersen::Pedersen;
 pub(crate) use schnorr::SchnorrSig;
 
 /// The number of bytes necessary to store a `FieldElement`.
@@ -208,10 +203,6 @@ impl Barretenberg {
         buf
     }
 
-    pub(crate) fn call(&self, name: &str, param: &WASMValue) -> Result<WASMValue, Error> {
-        self.call_multiple(name, vec![param])
-    }
-
     pub(crate) fn call_multiple(
         &self,
         name: &str,
@@ -236,17 +227,6 @@ impl Barretenberg {
 
         Ok(WASMValue(option_value))
     }
-
-    /// Creates a pointer and allocates the bytes that the pointer references to, to the heap
-    pub(crate) fn allocate(&self, bytes: &[u8]) -> Result<WASMValue, Error> {
-        let ptr: i32 = self.call("bbmalloc", &bytes.len().into())?.try_into()?;
-
-        let i32_bytes = ptr.to_be_bytes();
-        let u32_bytes = u32::from_be_bytes(i32_bytes);
-
-        self.transfer_to_heap(bytes, u32_bytes as usize);
-        Ok(ptr.into())
-    }
 }
 
 fn init_memory_and_state() -> (Memory, Store, Imports) {
diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/pedersen.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/pedersen.rs
deleted file mode 100644
index c816e5b4d1b..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/pedersen.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use acir::FieldElement;
-
-use super::{Assignments, Barretenberg, Error, FIELD_BYTES};
-
-pub(crate) trait Pedersen {
-    fn encrypt(
-        &self,
-        inputs: Vec<FieldElement>,
-        hash_index: u32,
-    ) -> Result<(FieldElement, FieldElement), Error>;
-
-    fn hash(&self, inputs: Vec<FieldElement>, hash_index: u32) -> Result<FieldElement, Error>;
-}
-
-impl Pedersen for Barretenberg {
-    fn encrypt(
-        &self,
-        inputs: Vec<FieldElement>,
-        hash_index: u32,
-    ) -> Result<(FieldElement, FieldElement), Error> {
-        let input_buf = Assignments::from(inputs).to_bytes();
-        let input_ptr = self.allocate(&input_buf)?;
-        let result_ptr: usize = 0;
-
-        self.call_multiple(
-            "pedersen_plookup_commit_with_hash_index",
-            vec![&input_ptr, &result_ptr.into(), &hash_index.into()],
-        )?;
-
-        let result_bytes: [u8; 2 * FIELD_BYTES] = self.read_memory(result_ptr);
-        let (point_x_bytes, point_y_bytes) = result_bytes.split_at(FIELD_BYTES);
-
-        let point_x = FieldElement::from_be_bytes_reduce(point_x_bytes);
-        let point_y = FieldElement::from_be_bytes_reduce(point_y_bytes);
-
-        Ok((point_x, point_y))
-    }
-
-    fn hash(&self, inputs: Vec<FieldElement>, hash_index: u32) -> Result<FieldElement, Error> {
-        let input_buf = Assignments::from(inputs).to_bytes();
-        let input_ptr = self.allocate(&input_buf)?;
-        let result_ptr: usize = 0;
-
-        self.call_multiple(
-            "pedersen_plookup_compress_with_hash_index",
-            vec![&input_ptr, &result_ptr.into(), &hash_index.into()],
-        )?;
-
-        let result_bytes: [u8; FIELD_BYTES] = self.read_memory(result_ptr);
-
-        let hash = FieldElement::from_be_bytes_reduce(&result_bytes);
-
-        Ok(hash)
-    }
-}
-
-#[test]
-fn pedersen_hash_to_point() -> Result<(), Error> {
-    let barretenberg = Barretenberg::new();
-    let (x, y) = barretenberg.encrypt(vec![FieldElement::one(), FieldElement::one()], 1)?;
-    let expected_x = FieldElement::from_hex(
-        "0x12afb43195f5c621d1d2cabb5f629707095c5307fd4185a663d4e80bb083e878",
-    )
-    .unwrap();
-    let expected_y = FieldElement::from_hex(
-        "0x25793f5b5e62beb92fd18a66050293a9fd554a2ff13bceba0339cae1a038d7c1",
-    )
-    .unwrap();
-
-    assert_eq!(expected_x.to_hex(), x.to_hex());
-    assert_eq!(expected_y.to_hex(), y.to_hex());
-    Ok(())
-}
diff --git a/cspell.json b/cspell.json
index bf3040265c2..1fbbe5c428d 100644
--- a/cspell.json
+++ b/cspell.json
@@ -18,6 +18,7 @@
         "Backpropagation",
         "barebones",
         "barretenberg",
+        "barustenberg",
         "bincode",
         "bindgen",
         "bitand",

From af57471035e4fa7eaffa71693219df6d029dbcde Mon Sep 17 00:00:00 2001
From: kevaundray <kevtheappdev@gmail.com>
Date: Tue, 21 May 2024 17:17:52 +0300
Subject: [PATCH 276/416] chore: Release Noir(0.30.0) (#4981)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.30.0</summary>

## [0.30.0](https://github.com/noir-lang/noir/compare/v0.29.0...v0.30.0)
(2024-05-20)


### ⚠ BREAKING CHANGES

* remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
* AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)

### Features

* `multi_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6097)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* `variable_base_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6039)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Add `Not` trait to stdlib
([#4999](https://github.com/noir-lang/noir/issues/4999))
([95d4d13](https://github.com/noir-lang/noir/commit/95d4d133d1eb5e0eb44cd928d8183d890e970a13))
* Add `std::ops::Neg` trait to stdlib
([07930d4](https://github.com/noir-lang/noir/commit/07930d4373a393146210efae69e6ec40171f047b))
* Add native rust implementations of pedersen functions
([#4871](https://github.com/noir-lang/noir/issues/4871))
([fb039f7](https://github.com/noir-lang/noir/commit/fb039f74df23aea39bc0593a5d538d82b4efadf0))
* Add support for u16/i16
([#4985](https://github.com/noir-lang/noir/issues/4985))
([e43661d](https://github.com/noir-lang/noir/commit/e43661d16c1cd07e2af2392b88d29c689889ff9a))
* AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Do not return databus returndata, keep it private.
([#5023](https://github.com/noir-lang/noir/issues/5023))
([a5b7df1](https://github.com/noir-lang/noir/commit/a5b7df12faf9d71ff24f8c5cde5e78da44558caf))
* Dynamic assertion payloads v2
(https://github.com/AztecProtocol/aztec-packages/pull/5949)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Implement `From` array trait for `BoundedVec`
([#4927](https://github.com/noir-lang/noir/issues/4927))
([bf491dc](https://github.com/noir-lang/noir/commit/bf491dce9595d0e37057ae6d6721eb7a83cec0e2))
* Implement `ops` traits on `u16`/`i16`
([#4996](https://github.com/noir-lang/noir/issues/4996))
([8b65663](https://github.com/noir-lang/noir/commit/8b65663f9e836c11a87e458bd7c6a52920448d5c))
* Implement `std::ops::Sub` on `EmbeddedCurvePoint`
([07930d4](https://github.com/noir-lang/noir/commit/07930d4373a393146210efae69e6ec40171f047b))
* Increase default expression width to 4
([#4995](https://github.com/noir-lang/noir/issues/4995))
([f01d309](https://github.com/noir-lang/noir/commit/f01d3090759a5ff0f1f83c5616d22890c6bd76be))
* Parsing non-string assertion payloads in noir js
(https://github.com/AztecProtocol/aztec-packages/pull/6079)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Remove query to backend to get expression width
([#4975](https://github.com/noir-lang/noir/issues/4975))
([e5f356b](https://github.com/noir-lang/noir/commit/e5f356b063fe4facbd14320b7eafed664d0bb027))
* Set aztec private functions to be recursive
(https://github.com/AztecProtocol/aztec-packages/pull/6192)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))


### Bug Fixes

* Compute the correct slice length when coercing from a literal array of
complex types ([#4986](https://github.com/noir-lang/noir/issues/4986))
([f3f1150](https://github.com/noir-lang/noir/commit/f3f11507983009771656811f9570bdbe6849c7ef))
* Defer overflow checks for unsigned integers to acir-gen
([#4832](https://github.com/noir-lang/noir/issues/4832))
([b577761](https://github.com/noir-lang/noir/commit/b5777613c51f26fb4f580b9168c4190b1f4bd8f7))
* Fix no predicates for brillig with intermediate functions
([#5015](https://github.com/noir-lang/noir/issues/5015))
([9c6de4b](https://github.com/noir-lang/noir/commit/9c6de4b25d318c6d211361dd62a112a9d2432c56))
* Fixed several vulnerabilities in U128, added some tests
([#5024](https://github.com/noir-lang/noir/issues/5024))
([e5ab24d](https://github.com/noir-lang/noir/commit/e5ab24d6a4154d11b3c8ae08f4431b7b93c76f23))
* Ignore no_predicates in brillig functions
([#5012](https://github.com/noir-lang/noir/issues/5012))
([b541e79](https://github.com/noir-lang/noir/commit/b541e793e20fa3c991e0328ec2ff7926bdcdfd45))
* Set index and value to 0 for array_get with predicate
([#4971](https://github.com/noir-lang/noir/issues/4971))
([c49d3a9](https://github.com/noir-lang/noir/commit/c49d3a9ded819b828cffdfc031e86614da21e329))


### Miscellaneous Chores

* Remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
</details>

<details><summary>0.46.0</summary>

## [0.46.0](https://github.com/noir-lang/noir/compare/v0.45.0...v0.46.0)
(2024-05-20)


### ⚠ BREAKING CHANGES

* remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
* AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
* contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
* change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
* trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
* remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
* storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
* contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))

### Features

* `multi_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6097)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* `variable_base_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6039)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir_gen:** Brillig stdlib
([#4848](https://github.com/noir-lang/noir/issues/4848))
([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
* **acir_gen:** Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **acvm_js:** Execute program
([#4694](https://github.com/noir-lang/noir/issues/4694))
([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
* **acvm:** Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add native rust implementations of pedersen functions
([#4871](https://github.com/noir-lang/noir/issues/4871))
([fb039f7](https://github.com/noir-lang/noir/commit/fb039f74df23aea39bc0593a5d538d82b4efadf0))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add return values to aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/5389)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Add support for overriding expression width
([#4117](https://github.com/noir-lang/noir/issues/4117))
([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **avm:** Integrate AVM with initializers
(https://github.com/AztecProtocol/aztec-packages/pull/5469)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
* Brillig heterogeneous memory cells
(https://github.com/AztecProtocol/aztec-packages/pull/5608)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Brillig pointer codegen and execution
(https://github.com/AztecProtocol/aztec-packages/pull/5737)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
* Change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Dynamic assertion payloads v2
(https://github.com/AztecProtocol/aztec-packages/pull/5949)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Handle `BrilligCall` opcodes in the debugger
([#4897](https://github.com/noir-lang/noir/issues/4897))
([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
* Impl of missing functionality in new key store
(https://github.com/AztecProtocol/aztec-packages/pull/5750)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Increase default expression width to 4
([#4995](https://github.com/noir-lang/noir/issues/4995))
([f01d309](https://github.com/noir-lang/noir/commit/f01d3090759a5ff0f1f83c5616d22890c6bd76be))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* **nargo:** Handle call stacks for multiple Acir calls
([#4711](https://github.com/noir-lang/noir/issues/4711))
([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Parsing non-string assertion payloads in noir js
(https://github.com/AztecProtocol/aztec-packages/pull/6079)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Remove replacement of boolean range opcodes with `AssertZero` opcodes
([#4107](https://github.com/noir-lang/noir/issues/4107))
([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
* Restore hashing args via slice for performance
(https://github.com/AztecProtocol/aztec-packages/pull/5539)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Set aztec private functions to be recursive
(https://github.com/AztecProtocol/aztec-packages/pull/6192)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **simulator:** Fetch return values at circuit execution
(https://github.com/AztecProtocol/aztec-packages/pull/5642)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync `aztec-packages`
([#4011](https://github.com/noir-lang/noir/issues/4011))
([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
* Sync commits from `aztec-packages`
([#4068](https://github.com/noir-lang/noir/issues/4068))
([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
* Sync commits from `aztec-packages`
([#4144](https://github.com/noir-lang/noir/issues/4144))
([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5572)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5619)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5697)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5794)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5814)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5935)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5955)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5999)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Variable length returns
(https://github.com/AztecProtocol/aztec-packages/pull/5633)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))


### Bug Fixes

* **acvm:** Mark outputs of Opcode::Call solvable
([#4708](https://github.com/noir-lang/noir/issues/4708))
([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
* Avoid huge unrolling in hash_args
(https://github.com/AztecProtocol/aztec-packages/pull/5703)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Catch panics from EC point creation (e.g. the point is at infinity)
([#4790](https://github.com/noir-lang/noir/issues/4790))
([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
* Don't reuse brillig with slice arguments
(https://github.com/AztecProtocol/aztec-packages/pull/5800)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Issue 4682 and add solver for unconstrained bigintegers
([#4729](https://github.com/noir-lang/noir/issues/4729))
([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Proper field inversion for bigints
([#4802](https://github.com/noir-lang/noir/issues/4802))
([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
* Remove panic from `init_log_level` in `acvm_js`
([#4195](https://github.com/noir-lang/noir/issues/4195))
([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).
---
 .release-please-manifest.json                 |   4 +-
 CHANGELOG.md                                  |  42 ++
 Cargo.lock                                    |  54 +-
 Cargo.toml                                    |  16 +-
 acvm-repo/CHANGELOG.md                        | 129 ++++
 acvm-repo/acir/Cargo.toml                     |   2 +-
 acvm-repo/acir_field/Cargo.toml               |   2 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm_js/Cargo.toml                  |   2 +-
 acvm-repo/acvm_js/package.json                |   2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   2 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   2 +-
 acvm-repo/brillig_vm/Cargo.toml               |   2 +-
 compiler/wasm/package.json                    |   2 +-
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 142 +++++
 .../hello_noir/project_breakdown.md           | 199 ++++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 102 ++++
 .../getting_started/tooling/noir_codegen.md   | 113 ++++
 .../version-v0.30.0/how_to/_category_.json    |   5 +
 .../how_to/debugger/_category_.json           |   6 +
 .../debugger/debugging_with_the_repl.md       | 164 +++++
 .../how_to/debugger/debugging_with_vs_code.md |  68 +++
 .../version-v0.30.0/how_to/how-to-oracles.md  | 276 +++++++++
 .../how_to/how-to-recursion.md                | 179 ++++++
 .../how_to/how-to-solidity-verifier.md        | 231 +++++++
 .../version-v0.30.0/how_to/merkle-proof.mdx   |  49 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.30.0/index.mdx |  67 ++
 .../version-v0.30.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.30.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.30.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  77 +++
 .../version-v0.30.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 251 ++++++++
 .../noir/concepts/data_types/booleans.md      |  31 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 157 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 195 ++++++
 .../noir/concepts/data_types/strings.md       |  80 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.30.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.30.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.30.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.30.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.30.0/noir/concepts/oracles.md  |  31 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.30.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  99 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  42 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/bigint.md           | 122 ++++
 .../noir/standard_library/black_box_fns.md    |  32 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 340 +++++++++++
 .../standard_library/containers/hashmap.md    | 570 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 151 +++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ciphers.mdx      |  32 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  98 +++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../embedded_curve_ops.mdx                    |  98 +++
 .../cryptographic_primitives/hashes.mdx       | 257 ++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/schnorr.mdx      |  64 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  88 +++
 .../noir/standard_library/traits.md           | 464 ++++++++++++++
 .../noir/standard_library/zeroed.md           |  26 +
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 160 +++++
 .../classes/BarretenbergVerifier.md           |  58 ++
 .../NoirJS/backend_barretenberg/index.md      |  59 ++
 .../type-aliases/BackendOptions.md            |  21 +
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  | 132 ++++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +
 .../functions/ecdsa_secp256k1_verify.md       |  28 +
 .../functions/ecdsa_secp256r1_verify.md       |  28 +
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +
 .../NoirJS/noir_js/functions/sha256.md        |  21 +
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +
 .../reference/NoirJS/noir_js/index.md         |  55 ++
 .../noir_js/type-aliases/ErrorWithPayload.md  |  15 +
 .../type-aliases/ForeignCallHandler.md        |  24 +
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 +
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 +
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 +
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 ++
 .../noir_wasm/functions/compile_contract.md   |  51 ++
 .../noir_wasm/functions/createFileManager.md  |  21 +
 .../functions/inflateDebugSymbols.md          |  21 +
 .../reference/NoirJS/noir_wasm/index.md       |  49 ++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 .../version-v0.30.0/reference/_category_.json |   5 +
 .../reference/debugger/_category_.json        |   6 +
 .../debugger/debugger_known_limitations.md    |  59 ++
 .../reference/debugger/debugger_repl.md       | 360 +++++++++++
 .../reference/debugger/debugger_vscode.md     |  82 +++
 .../reference/nargo_commands.md               | 397 ++++++++++++
 .../version-v0.30.0/tooling/debugger.md       |  27 +
 .../tooling/language_server.md                |  43 ++
 .../version-v0.30.0/tooling/testing.md        |  62 ++
 .../version-v0.30.0/tutorials/noirjs_app.md   | 326 ++++++++++
 .../version-v0.30.0-sidebars.json             |  93 +++
 tooling/noir_codegen/package.json             |   2 +-
 tooling/noir_js/package.json                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noir_js_types/package.json            |   2 +-
 tooling/noirc_abi_wasm/package.json           |   2 +-
 136 files changed, 10469 insertions(+), 52 deletions(-)
 create mode 100644 docs/versioned_docs/version-v0.30.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/getting_started/tooling/noir_codegen.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_the_repl.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_vs_code.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/bigint.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_known_limitations.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_repl.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_vscode.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/tooling/debugger.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.30.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.30.0-sidebars.json

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 447e12155b8..83338327d88 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.29.0",
-  "acvm-repo": "0.45.0"
+  ".": "0.30.0",
+  "acvm-repo": "0.46.0"
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7be8c387026..db4ec8f4567 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,47 @@
 # Changelog
 
+## [0.30.0](https://github.com/noir-lang/noir/compare/v0.29.0...v0.30.0) (2024-05-20)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove `Opcode::Brillig` from ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5995)
+* AES blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6016)
+
+### Features
+
+* `multi_scalar_mul` blackbox func (https://github.com/AztecProtocol/aztec-packages/pull/6097) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* `variable_base_scalar_mul` blackbox func (https://github.com/AztecProtocol/aztec-packages/pull/6039) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Add `Not` trait to stdlib ([#4999](https://github.com/noir-lang/noir/issues/4999)) ([95d4d13](https://github.com/noir-lang/noir/commit/95d4d133d1eb5e0eb44cd928d8183d890e970a13))
+* Add `std::ops::Neg` trait to stdlib ([07930d4](https://github.com/noir-lang/noir/commit/07930d4373a393146210efae69e6ec40171f047b))
+* Add native rust implementations of pedersen functions ([#4871](https://github.com/noir-lang/noir/issues/4871)) ([fb039f7](https://github.com/noir-lang/noir/commit/fb039f74df23aea39bc0593a5d538d82b4efadf0))
+* Add support for u16/i16 ([#4985](https://github.com/noir-lang/noir/issues/4985)) ([e43661d](https://github.com/noir-lang/noir/commit/e43661d16c1cd07e2af2392b88d29c689889ff9a))
+* AES blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6016) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Do not return databus returndata, keep it private. ([#5023](https://github.com/noir-lang/noir/issues/5023)) ([a5b7df1](https://github.com/noir-lang/noir/commit/a5b7df12faf9d71ff24f8c5cde5e78da44558caf))
+* Dynamic assertion payloads v2 (https://github.com/AztecProtocol/aztec-packages/pull/5949) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Implement `From` array trait for `BoundedVec` ([#4927](https://github.com/noir-lang/noir/issues/4927)) ([bf491dc](https://github.com/noir-lang/noir/commit/bf491dce9595d0e37057ae6d6721eb7a83cec0e2))
+* Implement `ops` traits on `u16`/`i16` ([#4996](https://github.com/noir-lang/noir/issues/4996)) ([8b65663](https://github.com/noir-lang/noir/commit/8b65663f9e836c11a87e458bd7c6a52920448d5c))
+* Implement `std::ops::Sub` on `EmbeddedCurvePoint` ([07930d4](https://github.com/noir-lang/noir/commit/07930d4373a393146210efae69e6ec40171f047b))
+* Increase default expression width to 4 ([#4995](https://github.com/noir-lang/noir/issues/4995)) ([f01d309](https://github.com/noir-lang/noir/commit/f01d3090759a5ff0f1f83c5616d22890c6bd76be))
+* Parsing non-string assertion payloads in noir js (https://github.com/AztecProtocol/aztec-packages/pull/6079) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Remove query to backend to get expression width ([#4975](https://github.com/noir-lang/noir/issues/4975)) ([e5f356b](https://github.com/noir-lang/noir/commit/e5f356b063fe4facbd14320b7eafed664d0bb027))
+* Set aztec private functions to be recursive (https://github.com/AztecProtocol/aztec-packages/pull/6192) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+
+
+### Bug Fixes
+
+* Compute the correct slice length when coercing from a literal array of complex types ([#4986](https://github.com/noir-lang/noir/issues/4986)) ([f3f1150](https://github.com/noir-lang/noir/commit/f3f11507983009771656811f9570bdbe6849c7ef))
+* Defer overflow checks for unsigned integers to acir-gen ([#4832](https://github.com/noir-lang/noir/issues/4832)) ([b577761](https://github.com/noir-lang/noir/commit/b5777613c51f26fb4f580b9168c4190b1f4bd8f7))
+* Fix no predicates for brillig with intermediate functions ([#5015](https://github.com/noir-lang/noir/issues/5015)) ([9c6de4b](https://github.com/noir-lang/noir/commit/9c6de4b25d318c6d211361dd62a112a9d2432c56))
+* Fixed several vulnerabilities in U128, added some tests ([#5024](https://github.com/noir-lang/noir/issues/5024)) ([e5ab24d](https://github.com/noir-lang/noir/commit/e5ab24d6a4154d11b3c8ae08f4431b7b93c76f23))
+* Ignore no_predicates in brillig functions ([#5012](https://github.com/noir-lang/noir/issues/5012)) ([b541e79](https://github.com/noir-lang/noir/commit/b541e793e20fa3c991e0328ec2ff7926bdcdfd45))
+* Set index and value to 0 for array_get with predicate ([#4971](https://github.com/noir-lang/noir/issues/4971)) ([c49d3a9](https://github.com/noir-lang/noir/commit/c49d3a9ded819b828cffdfc031e86614da21e329))
+
+
+### Miscellaneous Chores
+
+* Remove `Opcode::Brillig` from ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5995) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+
 ## [0.29.0](https://github.com/noir-lang/noir/compare/v0.28.0...v0.29.0) (2024-05-03)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 2e8eeb10a58..be7f781f96d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -26,7 +26,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -40,7 +40,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -56,7 +56,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acir",
  "blake2",
@@ -93,7 +93,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -442,7 +442,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "convert_case 0.6.0",
  "iter-extended",
@@ -453,7 +453,7 @@ dependencies = [
 
 [[package]]
 name = "backend-interface"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "bb_abstraction_leaks",
@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -631,7 +631,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -639,7 +639,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.45.0"
+version = "0.46.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1763,7 +1763,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2384,7 +2384,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.29.0"
+version = "0.30.0"
 
 [[package]]
 name = "itertools"
@@ -2815,7 +2815,7 @@ checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
 name = "nargo"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2841,7 +2841,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2895,7 +2895,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2907,7 +2907,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2986,7 +2986,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -3021,7 +3021,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -3047,7 +3047,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3070,7 +3070,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -3088,7 +3088,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -3105,11 +3105,11 @@ dependencies = [
 
 [[package]]
 name = "noirc_arena"
-version = "0.29.0"
+version = "0.30.0"
 
 [[package]]
 name = "noirc_driver"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -3130,7 +3130,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3148,7 +3148,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "chrono",
@@ -3165,7 +3165,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -3194,7 +3194,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.29.0"
+version = "0.30.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index f744d6d0cf5..670ae36dd4b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.29.0"
+version = "0.30.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -52,13 +52,13 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.45.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.45.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.45.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.45.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.45.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.45.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.45.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+acir_field = { version = "0.46.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.46.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.46.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.46.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.46.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.46.0", path = "acvm-repo/blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "0.46.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 fm = { path = "compiler/fm" }
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index 6ac04f6f83f..c9bb0d610eb 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,135 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.46.0](https://github.com/noir-lang/noir/compare/v0.45.0...v0.46.0) (2024-05-20)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove `Opcode::Brillig` from ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5995)
+* AES blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6016)
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907))
+* contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687)
+* change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374)
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620)
+* trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732)
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709)
+* remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617)
+* storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387)
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616)
+* contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386)
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395)
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144))
+
+### Features
+
+* `multi_scalar_mul` blackbox func (https://github.com/AztecProtocol/aztec-packages/pull/6097) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* `variable_base_scalar_mul` blackbox func (https://github.com/AztecProtocol/aztec-packages/pull/6039) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir_gen:** Brillig stdlib ([#4848](https://github.com/noir-lang/noir/issues/4848)) ([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
+* **acir_gen:** Fold attribute at compile-time and initial non inlined ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **acvm_js:** Execute program  ([#4694](https://github.com/noir-lang/noir/issues/4694)) ([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
+* **acvm:** Execute multiple circuits  (https://github.com/AztecProtocol/aztec-packages/pull/5380) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add native rust implementations of pedersen functions ([#4871](https://github.com/noir-lang/noir/issues/4871)) ([fb039f7](https://github.com/noir-lang/noir/commit/fb039f74df23aea39bc0593a5d538d82b4efadf0))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add return values to aztec fns (https://github.com/AztecProtocol/aztec-packages/pull/5389) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Add support for overriding expression width ([#4117](https://github.com/noir-lang/noir/issues/4117)) ([c8026d5](https://github.com/noir-lang/noir/commit/c8026d557d535b10fe455165d6445076df7a03de))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* AES blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6016) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **avm:** Integrate AVM with initializers (https://github.com/AztecProtocol/aztec-packages/pull/5469) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907)) ([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
+* Brillig heterogeneous memory cells (https://github.com/AztecProtocol/aztec-packages/pull/5608) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Brillig pointer codegen and execution (https://github.com/AztecProtocol/aztec-packages/pull/5737) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395) ([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
+* Change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Dynamic assertion payloads v2 (https://github.com/AztecProtocol/aztec-packages/pull/5949) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Handle `BrilligCall` opcodes in the debugger ([#4897](https://github.com/noir-lang/noir/issues/4897)) ([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
+* Impl of missing functionality in new key store (https://github.com/AztecProtocol/aztec-packages/pull/5750) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Increase default expression width to 4 ([#4995](https://github.com/noir-lang/noir/issues/4995)) ([f01d309](https://github.com/noir-lang/noir/commit/f01d3090759a5ff0f1f83c5616d22890c6bd76be))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* **nargo:** Handle call stacks for multiple Acir calls ([#4711](https://github.com/noir-lang/noir/issues/4711)) ([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Parsing non-string assertion payloads in noir js (https://github.com/AztecProtocol/aztec-packages/pull/6079) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Remove replacement of boolean range opcodes with `AssertZero` opcodes ([#4107](https://github.com/noir-lang/noir/issues/4107)) ([dac0e87](https://github.com/noir-lang/noir/commit/dac0e87ee3be3446b92bbb12ef4832fd493fcee3))
+* Restore hashing args via slice for performance (https://github.com/AztecProtocol/aztec-packages/pull/5539) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Set aztec private functions to be recursive (https://github.com/AztecProtocol/aztec-packages/pull/6192) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **simulator:** Fetch return values at circuit execution (https://github.com/AztecProtocol/aztec-packages/pull/5642) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync `aztec-packages` ([#4011](https://github.com/noir-lang/noir/issues/4011)) ([fee2452](https://github.com/noir-lang/noir/commit/fee24523c427c27f0bdaf98ea09a852a2da3e94c))
+* Sync commits from `aztec-packages` ([#4068](https://github.com/noir-lang/noir/issues/4068)) ([7a8f3a3](https://github.com/noir-lang/noir/commit/7a8f3a33b57875e681e3d81e667e3570a1cdbdcc))
+* Sync commits from `aztec-packages` ([#4144](https://github.com/noir-lang/noir/issues/4144)) ([0205d3b](https://github.com/noir-lang/noir/commit/0205d3b4ad0cf5ffd775a43eb5af273a772cf138))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5572) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5619) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5697) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5794) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5814) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5935) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5955) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5999) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Variable length returns (https://github.com/AztecProtocol/aztec-packages/pull/5633) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+
+
+### Bug Fixes
+
+* **acvm:** Mark outputs of Opcode::Call solvable ([#4708](https://github.com/noir-lang/noir/issues/4708)) ([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
+* Avoid huge unrolling in hash_args (https://github.com/AztecProtocol/aztec-packages/pull/5703) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Catch panics from EC point creation (e.g. the point is at infinity) ([#4790](https://github.com/noir-lang/noir/issues/4790)) ([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
+* Don't reuse brillig with slice arguments (https://github.com/AztecProtocol/aztec-packages/pull/5800) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Issue 4682 and add solver for unconstrained bigintegers ([#4729](https://github.com/noir-lang/noir/issues/4729)) ([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Proper field inversion for bigints ([#4802](https://github.com/noir-lang/noir/issues/4802)) ([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
+* Remove panic from `init_log_level` in `acvm_js` ([#4195](https://github.com/noir-lang/noir/issues/4195)) ([2e26530](https://github.com/noir-lang/noir/commit/2e26530bf53006c1ed4fee310bcaa905c95dd95b))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove `Opcode::Brillig` from ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5995) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.45.0](https://github.com/noir-lang/noir/compare/v0.44.0...v0.45.0) (2024-05-03)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 9e1a2f940c4..32a9bbe8303 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 89ee161206e..dd4b7af9ffc 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 1b671d49366..74aed429f9a 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 1675d601351..ec63649947e 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 5be2f164ac4..48c5b2a8644 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index f40046acad6..6c1cd190254 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index b261be65735..49448d58fe6 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 081abe022ae..f60bde6f074 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 57cf3be974a..7dd11912449 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.45.0"
+version = "0.46.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index bccf937219e..0bb9b803ee0 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.29.0",
+  "version": "0.30.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/docs/versioned_docs/version-v0.30.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.30.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.30.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.30.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.30.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..743c4d8d634
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/index.md
@@ -0,0 +1,142 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Two additional files would be generated in your project directory:
+
+_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+
+## Prove Our Noir Program
+
+Now that the project is set up, we can create a proof of correct execution of our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Prove the valid execution of your Noir program:
+
+```sh
+nargo prove
+```
+
+A new folder _proofs_ would then be generated in your project directory, containing the proof file
+`<project-name>.proof`, where the project name is defined in Nargo.toml.
+
+The _Verifier.toml_ file would also be updated with the public values computed from program
+execution (in this case the value of `y`):
+
+```toml
+y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+```
+
+> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the
+proof file.
+
+Verify your proof by running:
+
+```sh
+nargo verify
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the
+corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..6160a102c6c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,199 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
+  files, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Verifier.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Verifier.toml
+
+_Verifier.toml_ contains public in/output values computed when executing the Noir program.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
+prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
+verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
+constrained by the proof of the execution of said program (i.e. if the condition was not met, the
+verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
+public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo prove` is executed, two processes happen:
+
+1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
+   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+
+2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+
+```bash
+nargo prove -p OtherProver
+```
+
+## Verifying a Proof
+
+When the command `nargo verify` is executed, two processes happen:
+
+1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
+
+2. If that file is found, the proof's validity is checked
+
+> **Note:** The validity of the proof is linked to the current Noir program; if the program is
+> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
+> _modified_ Noir program.
+
+In production, the prover and the verifier are usually two separate entities. A prover would
+retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
+verifier. The verifier would then retrieve the public inputs, usually from external sources, and
+verify the validity of the proof against it.
+
+Take a private asset transfer as an example:
+
+A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
+public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
+and submit it to the verifier smart contract.
+
+The verifier contract would then draw the user's encrypted balance directly from the blockchain and
+verify the proof submitted against it. If the verification passes, additional functions in the
+verifier contract could trigger (e.g. approve the asset transfer).
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.30.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.30.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.30.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..3634723562b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,102 @@
+---
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.30.0/getting_started/tooling/noir_codegen.md b/docs/versioned_docs/version-v0.30.0/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..d65151da0ab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,113 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 2
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/_category_.json b/docs/versioned_docs/version-v0.30.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.30.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..09e5bae68ad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.30.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..8cf8035a5c4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/how-to-oracles.md
@@ -0,0 +1,276 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("getSqrt", async (params) => {
+  const values = params[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+:::tip
+
+Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
+
+```json
+{ "values": [{ "Array": ["1", "2"] }]}
+{ "values": [{ "Single": "1" }]}
+{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface SingleForeignCallParam {
+  Single: string,
+}
+
+interface ArrayForeignCallParam {
+  Array: string[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.generateProof(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => i.toString("hex")) },
+    ]);
+    return [oracleReturn.values[0].Array];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.30.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..4c45bb87ae2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/how-to-recursion.md
@@ -0,0 +1,179 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit, backend)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.30.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e3c7c1065da
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,231 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo codegen-verifier
+```
+
+A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+
+```
+0x...<proof bytes>... , [0x0000.....02]
+```
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
+Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of
+the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.30.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..16c425bed76
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/merkle-proof.mdx
@@ -0,0 +1,49 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+use dep::std;
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.30.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.30.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.30.0/index.mdx b/docs/versioned_docs/version-v0.30.0/index.mdx
new file mode 100644
index 00000000000..75086ddcdde
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.30.0/migration_notes.md b/docs/versioned_docs/version-v0.30.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.30.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..efce3e95d32
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,251 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..69826fcd724
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,31 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
+> `false` in _Verifier.toml_.
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow) and
+[Assert Function](../assert) sections.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..a10a4810788
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..357813c147a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..6b2d3773912
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,157 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo prove
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+use dep::std;
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..4eccc677b80
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,195 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+use dep::std::slice;
+
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<N>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..311dfd64416
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,80 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging).
+
+```rust
+use dep::std;
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..ddd42bf1f9b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..aa380b5f7b8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/oracles.md
@@ -0,0 +1,31 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+:::note
+
+This is an experimental feature that is not fully documented. If you notice any outdated information or potential improvements to this page, pull request contributions are very welcome: https://github.com/noir-lang/noir
+
+:::
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..ef1445a5907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: dep::some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: dep::some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b8e71fe65f0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md
@@ -0,0 +1,99 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..04c1703d929
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use dep::ecrecover;
+use dep::lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use dep::std::hash::sha256;
+use dep::std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use dep::phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.30.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..2bfdeec6631
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/bigint.md
@@ -0,0 +1,122 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L14-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L14-L19</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L70-L78" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L70-L78</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..eeead580969
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..c22fe8c5045
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,340 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(mut self: Self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L68-L76</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L81-L93</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L98-L113</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L118-L124</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L129-L136</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L141-L148</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L153-L162</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L229-L235</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..47faa99aba6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,570 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u64 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..fcfd7e07aa0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,151 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..e83e26efb97
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<N>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo />
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..d2b42d67b7c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4394b48f907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..c2c0624dfad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+let mut hasher = Poseidon2Hasher::default();
+eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..9dab7dd1047
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,98 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<N>(
+    points: [Field; N], // points represented as x and y coordinates [x1, y1, x2, y2, ...]
+    scalars: [Field; N] // scalars represented as low and high limbs [low1, high1, low2, high2, ...]
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L43-L48" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L43-L48</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(
+    scalar_low: Field,
+    scalar_high: Field
+) -> [Field; 2]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L51-L56" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L51-L56</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L65-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L65-L70</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..3b83d9ec31a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,257 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L10-L12</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L17-L19</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L16-L18</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L22-L24" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L22-L24</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L46-L48" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L46-L48</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+struct PedersenPoint {
+   x : Field,
+   y : Field,
+}
+
+pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L27-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L27-L34</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L9</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L68-L70</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+use dep::std;
+
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L22" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L22</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use dep::std::hash::poseidon;
+use dep::std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..b59e69c8f07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..a93894043dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md
@@ -0,0 +1,88 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+:::info
+
+This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+
+:::
+
+## Example usage
+
+```rust
+use dep::std;
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..a14312d2792
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/traits.md
@@ -0,0 +1,464 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(self) -> T {
+      T::from(self)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L102-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L102-L106</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L19-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L19-L23</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L37-L41" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L37-L41</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L55-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L55-L59</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L73-L77" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L73-L77</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L89-L93" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L89-L93</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field { fn neg(self) -> Field { -self } }
+
+impl Neg for i8 { fn neg(self) -> i8 { -self } }
+impl Neg for i16 { fn neg(self) -> i16 { -self } }
+impl Neg for i32 { fn neg(self) -> i32 { -self } }
+impl Neg for i64 { fn neg(self) -> i64 { -self } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L95-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L95-L102</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool { fn not(self) -> bool { !self } }
+
+impl Not for u64 { fn not(self) -> u64 { !self } }
+impl Not for u32 { fn not(self) -> u32 { !self } }
+impl Not for u16 { fn not(self) -> u16 { !self } }
+impl Not for u8 { fn not(self) -> u8 { !self } }
+impl Not for u1 { fn not(self) -> u1 { !self } }
+
+impl Not for i8 { fn not(self) -> i8 { !self } }
+impl Not for i16 { fn not(self) -> i16 { !self } }
+impl Not for i32 { fn not(self) -> i32 { !self } }
+impl Not for i64 { fn not(self) -> i64 { !self } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L20</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L22-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L22-L26</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L40-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L40-L44</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L58-L62" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L58-L62</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L76-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L76-L80</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L93-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L93-L97</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..f450fecdd36
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/zeroed.md
@@ -0,0 +1,26 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..d7249d24330
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,160 @@
+# BarretenbergBackend
+
+## Extends
+
+- `BarretenbergVerifierBackend`
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+#### Inherited from
+
+BarretenbergVerifierBackend.constructor
+
+## Properties
+
+| Property | Type | Description | Inheritance |
+| :------ | :------ | :------ | :------ |
+| `acirComposer` | `any` | - | BarretenbergVerifierBackend.acirComposer |
+| `acirUncompressedBytecode` | `Uint8Array` | - | BarretenbergVerifierBackend.acirUncompressedBytecode |
+| `api` | `Barretenberg` | - | BarretenbergVerifierBackend.api |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) | - | BarretenbergVerifierBackend.options |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.destroy
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.getVerificationKey
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.verifyProof
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
new file mode 100644
index 00000000000..500276ea748
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
@@ -0,0 +1,58 @@
+# BarretenbergVerifier
+
+## Constructors
+
+### new BarretenbergVerifier(options)
+
+```ts
+new BarretenbergVerifier(options): BarretenbergVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergVerifier`](BarretenbergVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..64971973196
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,59 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+| [BarretenbergVerifier](classes/BarretenbergVerifier.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+## Functions
+
+### publicInputsToWitnessMap()
+
+```ts
+publicInputsToWitnessMap(publicInputs, abi): Backend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `publicInputs` | `string`[] |
+| `abi` | `Abi` |
+
+#### Returns
+
+[`Backend`](index.md#backend)
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..d7d5128f9e3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier","label":"BarretenbergVerifier"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..45dd62ee57e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,132 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit, backend)
+
+```ts
+new Noir(circuit, backend?): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+| `backend`? | `any` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Description
+
+Destroys the underlying backend instance.
+
+#### Example
+
+```typescript
+await noir.destroy();
+```
+
+***
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+### generateProof()
+
+```ts
+generateProof(inputs, foreignCallHandler?): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a witness and a proof given an object as input.
+
+#### Example
+
+```typescript
+async generateProof(input)
+```
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Instantiates the verification key and verifies a proof.
+
+#### Example
+
+```typescript
+async verifyProof(proof)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..40bef8393fc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,55 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+***
+
+### ProofData
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..b3156097df6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/_category_.json b/docs/versioned_docs/version-v0.30.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.30.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.30.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.30.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..519e3dbddc2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/reference/nargo_commands.md
@@ -0,0 +1,397 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo backend`↴](#nargo-backend)
+* [`nargo backend current`↴](#nargo-backend-current)
+* [`nargo backend ls`↴](#nargo-backend-ls)
+* [`nargo backend use`↴](#nargo-backend-use)
+* [`nargo backend install`↴](#nargo-backend-install)
+* [`nargo backend uninstall`↴](#nargo-backend-uninstall)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo codegen-verifier`↴](#nargo-codegen-verifier)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo prove`↴](#nargo-prove)
+* [`nargo verify`↴](#nargo-verify)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `backend` — Install and select custom backends used to generate and verify proofs
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `codegen-verifier` — Generates a Solidity verifier smart contract for the program
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `prove` — Create proof for this program. The proof is returned as a hex encoded string
+* `verify` — Given a proof and a program, verify whether the proof is valid
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo backend`
+
+Install and select custom backends used to generate and verify proofs
+
+**Usage:** `nargo backend <COMMAND>`
+
+###### **Subcommands:**
+
+* `current` — Prints the name of the currently active backend
+* `ls` — Prints the list of currently installed backends
+* `use` — Select the backend to use
+* `install` — Install a new backend from a URL
+* `uninstall` — Uninstalls a backend
+
+
+
+## `nargo backend current`
+
+Prints the name of the currently active backend
+
+**Usage:** `nargo backend current`
+
+
+
+## `nargo backend ls`
+
+Prints the list of currently installed backends
+
+**Usage:** `nargo backend ls`
+
+
+
+## `nargo backend use`
+
+Select the backend to use
+
+**Usage:** `nargo backend use <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>`
+
+
+
+## `nargo backend install`
+
+Install a new backend from a URL
+
+**Usage:** `nargo backend install <BACKEND> <URL>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to install
+* `<URL>` — The URL from which to download the backend
+
+
+
+## `nargo backend uninstall`
+
+Uninstalls a backend
+
+**Usage:** `nargo backend uninstall <BACKEND>`
+
+###### **Arguments:**
+
+* `<BACKEND>` — The name of the backend to uninstall
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo codegen-verifier`
+
+Generates a Solidity verifier smart contract for the program
+
+**Usage:** `nargo codegen-verifier [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to codegen
+* `--workspace` — Codegen all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo prove`
+
+Create proof for this program. The proof is returned as a hex encoded string
+
+**Usage:** `nargo prove [OPTIONS]`
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--verify` — Verify proof after proving
+* `--package <PACKAGE>` — The name of the package to prove
+* `--workspace` — Prove all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo verify`
+
+Given a proof and a program, verify whether the proof is valid
+
+**Usage:** `nargo verify [OPTIONS]`
+
+###### **Options:**
+
+* `-v`, `--verifier-name <VERIFIER_NAME>` — The name of the toml file which contains the inputs for the verifier
+
+  Default value: `Verifier`
+* `--package <PACKAGE>` — The name of the package verify
+* `--workspace` — Verify all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.30.0/tooling/debugger.md b/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
new file mode 100644
index 00000000000..184c436068f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
@@ -0,0 +1,27 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+
+- Noir 0.xx 
+- Nargo 0.xx
+- vscode-noir 0.xx
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.30.0/tooling/language_server.md b/docs/versioned_docs/version-v0.30.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.30.0/tooling/testing.md b/docs/versioned_docs/version-v0.30.0/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.30.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.30.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..3dd9fe7d2b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.30.0/tutorials/noirjs_app.md
@@ -0,0 +1,326 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.27.x matches `noir_js@0.27.x`, etc.
+
+In this guide, we will be pinned to 0.27.0.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+`nargo new circuit`
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+`nargo compile`
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.27.0 @noir-lang/noir_js@0.27.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
+    ),
+  ]);
+};
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit, backend);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const proof = await noir.generateProof(input);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verificationKey = await backend.getVerificationKey();
+const verifier = new Verifier();
+const isValid = await verifier.verifyProof(proof, verificationKey);
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.30.0-sidebars.json b/docs/versioned_sidebars/version-v0.30.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.30.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index fa3df8ce101..5d3a7d6315e 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.29.0",
+  "version": "0.30.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index 325ba0fb9a7..eca3f29957f 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.29.0",
+  "version": "0.30.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 3368dcd8a09..6adf8749aba 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.29.0",
+  "version": "0.30.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index 5332ce20cc7..b2b84b640a5 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index ac7d1606298..399a333f157 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.29.0",
+  "version": "0.30.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From fab1c3567d731ea7902635a7a020a8d14f94fd27 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 21 May 2024 16:34:09 +0100
Subject: [PATCH 277/416] feat: add native rust implementation of schnorr
 signature verification (#5053)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR replaces the final wasm calls to barretenberg with a native
implementation of schnorr signature verification. This allows us to
remove the entire `acvm_backend.wasm`.

This schnorr implementation is something this I've slapped together in
an afternoon so be warned of potential bugs, there doesn't seem to be
any off-the-shelf rust implementations of schnorr using grumpkin
however.

Now we don't need to do wasm initialisation for acvm_js, we can stop
caching a solver object to pass into acvm_js, I've maintained the
interface for now however but the external solver is ignored.


Benchmarks relative to https://github.com/noir-lang/noir/pull/5056
```
schnorr_verify          time:   [526.91 µs 527.81 µs 528.91 µs]
                        change: [-67.185% -67.081% -66.993%] (p = 0.00 < 0.05)
                        Performance has improved.
```

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 Cargo.lock                                    | 794 ++----------------
 acvm-repo/acvm_js/Cargo.toml                  |   4 +
 acvm-repo/acvm_js/src/lib.rs                  |   3 +
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |  15 -
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |  40 +-
 .../bn254_blackbox_solver/src/schnorr/mod.rs  | 146 ++++
 .../src/wasm/acvm_backend.wasm                | Bin 756082 -> 0 bytes
 .../bn254_blackbox_solver/src/wasm/mod.rs     | 332 --------
 .../bn254_blackbox_solver/src/wasm/schnorr.rs | 104 ---
 9 files changed, 236 insertions(+), 1202 deletions(-)
 create mode 100644 acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
 delete mode 100755 acvm-repo/bn254_blackbox_solver/src/wasm/acvm_backend.wasm
 delete mode 100644 acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
 delete mode 100644 acvm-repo/bn254_blackbox_solver/src/wasm/schnorr.rs

diff --git a/Cargo.lock b/Cargo.lock
index be7f781f96d..b5dc6f9bfdf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -100,6 +100,7 @@ dependencies = [
  "build-data",
  "console_error_panic_hook",
  "const-str",
+ "getrandom 0.2.15",
  "gloo-utils",
  "js-sys",
  "pkg-config",
@@ -117,7 +118,7 @@ version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4fa78e18c64fce05e902adecd7a5eed15a5e0a3439f7b0e169f0252214865e3"
 dependencies = [
- "gimli 0.27.3",
+ "gimli",
 ]
 
 [[package]]
@@ -132,7 +133,7 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
 dependencies = [
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
  "once_cell",
  "version_check",
 ]
@@ -144,7 +145,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if 1.0.0",
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
  "once_cell",
  "version_check",
  "zerocopy",
@@ -563,18 +564,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
 [[package]]
 name = "blake2"
 version = "0.10.6"
@@ -615,18 +604,12 @@ dependencies = [
  "ark-ec",
  "ark-ff",
  "ark-std",
- "cfg-if 1.0.0",
  "criterion",
- "getrandom 0.2.10",
  "hex",
- "js-sys",
  "lazy_static",
  "noir_grumpkin",
  "num-bigint",
  "pprof 0.12.1",
- "thiserror",
- "wasm-bindgen-futures",
- "wasmer",
 ]
 
 [[package]]
@@ -693,28 +676,6 @@ version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 
-[[package]]
-name = "bytecheck"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b6372023ac861f6e6dc89c8344a8f398fb42aaba2b5dbc649ca0c0e9dbcb627"
-dependencies = [
- "bytecheck_derive",
- "ptr_meta",
- "simdutf8",
-]
-
-[[package]]
-name = "bytecheck_derive"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7ec4c6f261935ad534c0c22dbef2201b45918860eb1c574b972bd213a76af61"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "bytecount"
 version = "0.6.3"
@@ -850,9 +811,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.7"
+version = "4.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac495e00dcec98c83465d5ad66c5c4fabd652fd6686e7c6269b117e729a6f17b"
+checksum = "bfaff671f6b22ca62406885ece523383b9b64022e341e53e009a62ebc47a45f2"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -868,9 +829,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.7"
+version = "4.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77ed9a32a62e6ca27175d00d29d05ca32e396ea1eb5fb01d8256b669cec7663"
+checksum = "a216b506622bb1d316cd51328dce24e07bdff4a6128a47c7e7fad11878d5adbb"
 dependencies = [
  "anstream",
  "anstyle",
@@ -887,7 +848,7 @@ dependencies = [
  "heck 0.4.1",
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -925,7 +886,7 @@ checksum = "fc4159b76af02757139baf42c0c971c6dc155330999fbfd8eddb29b97fb2db68"
 dependencies = [
  "codespan-reporting",
  "lsp-types 0.88.0",
- "url 2.4.0",
+ "url 2.5.0",
 ]
 
 [[package]]
@@ -1059,19 +1020,6 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
-[[package]]
-name = "corosensei"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80128832c58ea9cbd041d2a759ec449224487b2c1e400453d99d244eead87a8e"
-dependencies = [
- "autocfg",
- "cfg-if 1.0.0",
- "libc",
- "scopeguard",
- "windows-sys 0.33.0",
-]
-
 [[package]]
 name = "cpp_demangle"
 version = "0.4.2"
@@ -1090,89 +1038,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "cranelift-bforest"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2ab4512dfd3a6f4be184403a195f76e81a8a9f9e6c898e19d2dc3ce20e0115"
-dependencies = [
- "cranelift-entity",
-]
-
-[[package]]
-name = "cranelift-codegen"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98b022ed2a5913a38839dfbafe6cf135342661293b08049843362df4301261dc"
-dependencies = [
- "arrayvec",
- "bumpalo",
- "cranelift-bforest",
- "cranelift-codegen-meta",
- "cranelift-codegen-shared",
- "cranelift-egraph",
- "cranelift-entity",
- "cranelift-isle",
- "gimli 0.26.2",
- "log",
- "regalloc2",
- "smallvec",
- "target-lexicon",
-]
-
-[[package]]
-name = "cranelift-codegen-meta"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "639307b45434ad112a98f8300c0f0ab085cbefcd767efcdef9ef19d4c0756e74"
-dependencies = [
- "cranelift-codegen-shared",
-]
-
-[[package]]
-name = "cranelift-codegen-shared"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278e52e29c53fcf32431ef08406c295699a70306d05a0715c5b1bf50e33a9ab7"
-
-[[package]]
-name = "cranelift-egraph"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624b54323b06e675293939311943ba82d323bb340468ce1889be5da7932c8d73"
-dependencies = [
- "cranelift-entity",
- "fxhash",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
- "log",
- "smallvec",
-]
-
-[[package]]
-name = "cranelift-entity"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a59bcbca89c3f1b70b93ab3cbba5e5e0cbf3e63dadb23c7525cb142e21a9d4c"
-
-[[package]]
-name = "cranelift-frontend"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d70abacb8cfef3dc8ff7e8836e9c1d70f7967dfdac824a4cd5e30223415aca6"
-dependencies = [
- "cranelift-codegen",
- "log",
- "smallvec",
- "target-lexicon",
-]
-
-[[package]]
-name = "cranelift-isle"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "393bc73c451830ff8dbb3a07f61843d6cb41a084f9996319917c0b291ed785bb"
-
 [[package]]
 name = "crc32fast"
 version = "1.3.2"
@@ -1252,24 +1117,11 @@ dependencies = [
  "scopeguard",
 ]
 
-[[package]]
-name = "crossbeam-queue"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.17"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d96137f14f244c37f989d9fff8f95e6c18b918e71f36638f8c49112e4c78f"
-dependencies = [
- "cfg-if 1.0.0",
-]
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
 
 [[package]]
 name = "crunchy"
@@ -1352,7 +1204,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -1363,20 +1215,7 @@ checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.32",
-]
-
-[[package]]
-name = "dashmap"
-version = "5.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
-dependencies = [
- "cfg-if 1.0.0",
- "hashbrown 0.14.0",
- "lock_api",
- "once_cell",
- "parking_lot_core 0.9.8",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -1584,47 +1423,6 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
 
-[[package]]
-name = "enum-iterator"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6"
-dependencies = [
- "enum-iterator-derive",
-]
-
-[[package]]
-name = "enum-iterator-derive"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "enumset"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e875f1719c16de097dee81ed675e2d9bb63096823ed3f0ca827b7dea3028bbbb"
-dependencies = [
- "enumset_derive",
-]
-
-[[package]]
-name = "enumset_derive"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08b6c6ab82d70f08844964ba10c7babb716de2ecaeab9be5717918a5177d3af"
-dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn 2.0.32",
-]
-
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -1661,12 +1459,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "fallible-iterator"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
-
 [[package]]
 name = "fastrand"
 version = "2.0.1"
@@ -1779,11 +1571,11 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
 dependencies = [
- "percent-encoding 2.3.0",
+ "percent-encoding 2.3.1",
 ]
 
 [[package]]
@@ -1795,12 +1587,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
 [[package]]
 name = "futures"
 version = "0.1.31"
@@ -1864,7 +1650,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -1930,9 +1716,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.10"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -1941,17 +1727,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "gimli"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
-dependencies = [
- "fallible-iterator",
- "indexmap 1.9.3",
- "stable_deref_trait",
-]
-
 [[package]]
 name = "gimli"
 version = "0.27.3"
@@ -2024,7 +1799,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "slab",
  "tokio",
  "tokio-util 0.7.10",
@@ -2051,9 +1826,6 @@ name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-dependencies = [
- "ahash 0.7.8",
-]
 
 [[package]]
 name = "hashbrown"
@@ -2066,9 +1838,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.14.0"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "heck"
@@ -2226,9 +1998,9 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
 dependencies = [
  "unicode-bidi",
  "unicode-normalization",
@@ -2309,12 +2081,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.0.0"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.5",
  "serde",
 ]
 
@@ -2611,12 +2383,6 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
-[[package]]
-name = "leb128"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
-
 [[package]]
 name = "libaes"
 version = "0.7.0"
@@ -2625,9 +2391,9 @@ checksum = "82903360c009b816f5ab72a9b68158c27c301ee2c3f20655b55c5e589e7d3bb7"
 
 [[package]]
 name = "libc"
-version = "0.2.151"
+version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
 [[package]]
 name = "libm"
@@ -2687,7 +2453,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_repr",
- "url 2.4.0",
+ "url 2.5.0",
 ]
 
 [[package]]
@@ -2700,16 +2466,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_repr",
- "url 2.4.0",
-]
-
-[[package]]
-name = "mach"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
-dependencies = [
- "libc",
+ "url 2.5.0",
 ]
 
 [[package]]
@@ -2742,15 +2499,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "memmap2"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d28bba84adfe6646737845bc5ebbfa2c08424eb1c37e94a1fd2a82adb56a872"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "memoffset"
 version = "0.6.5"
@@ -2807,12 +2555,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "more-asserts"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
-
 [[package]]
 name = "nargo"
 version = "0.30.0"
@@ -2917,7 +2659,7 @@ dependencies = [
  "serde",
  "thiserror",
  "toml 0.7.6",
- "url 2.4.0",
+ "url 2.5.0",
 ]
 
 [[package]]
@@ -3053,7 +2795,7 @@ dependencies = [
  "build-data",
  "console_error_panic_hook",
  "fm",
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
  "gloo-utils",
  "js-sys",
  "nargo",
@@ -3093,7 +2835,7 @@ dependencies = [
  "acvm",
  "build-data",
  "console_error_panic_hook",
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
  "gloo-utils",
  "iter-extended",
  "js-sys",
@@ -3417,9 +3159,9 @@ checksum = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "petgraph"
@@ -3428,7 +3170,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
 dependencies = [
  "fixedbitset",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
 ]
 
 [[package]]
@@ -3658,30 +3400,6 @@ dependencies = [
  "toml 0.5.11",
 ]
 
-[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
-dependencies = [
- "proc-macro2",
- "quote",
- "version_check",
-]
-
 [[package]]
 name = "proc-macro-hack"
 version = "0.5.20+deprecated"
@@ -3690,9 +3408,9 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.66"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b"
 dependencies = [
  "unicode-ident",
 ]
@@ -3717,26 +3435,6 @@ dependencies = [
  "unarray",
 ]
 
-[[package]]
-name = "ptr_meta"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
-dependencies = [
- "ptr_meta_derive",
-]
-
-[[package]]
-name = "ptr_meta_derive"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "quick-error"
 version = "1.2.3"
@@ -3754,19 +3452,13 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.31"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fe8a65d69dd0808184ebb5f836ab526bb259db23c657efa38711b1072ee47f0"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
 [[package]]
 name = "radix_trie"
 version = "0.2.1"
@@ -3836,7 +3528,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
 ]
 
 [[package]]
@@ -3925,23 +3617,11 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
  "redox_syscall 0.2.16",
  "thiserror",
 ]
 
-[[package]]
-name = "regalloc2"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300d4fbfb40c1c66a78ba3ddd41c1110247cf52f97b87d0f2fc9209bd49b030c"
-dependencies = [
- "fxhash",
- "log",
- "slice-group-by",
- "smallvec",
-]
-
 [[package]]
 name = "regex"
 version = "1.10.3"
@@ -3998,27 +3678,6 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
-[[package]]
-name = "region"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76e189c2369884dce920945e2ddf79b3dff49e071a167dd1817fa9c4c00d512e"
-dependencies = [
- "bitflags 1.3.2",
- "libc",
- "mach",
- "winapi",
-]
-
-[[package]]
-name = "rend"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581008d2099240d37fb08d77ad713bcaec2c4d89d50b5b21a8bb1996bbab68ab"
-dependencies = [
- "bytecheck",
-]
-
 [[package]]
 name = "reqwest"
 version = "0.11.20"
@@ -4040,7 +3699,7 @@ dependencies = [
  "log",
  "mime",
  "once_cell",
- "percent-encoding 2.3.0",
+ "percent-encoding 2.3.1",
  "pin-project-lite",
  "rustls",
  "rustls-pemfile",
@@ -4050,7 +3709,7 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "url 2.4.0",
+ "url 2.5.0",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
@@ -4114,42 +3773,13 @@ checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
 dependencies = [
  "cc",
  "cfg-if 1.0.0",
- "getrandom 0.2.10",
+ "getrandom 0.2.15",
  "libc",
  "spin 0.9.8",
  "untrusted 0.9.0",
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "rkyv"
-version = "0.7.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0200c8230b013893c0b2d6213d6ec64ed2b9be2e0e016682b7224ff82cff5c58"
-dependencies = [
- "bitvec",
- "bytecheck",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
- "ptr_meta",
- "rend",
- "rkyv_derive",
- "seahash",
- "tinyvec",
- "uuid",
-]
-
-[[package]]
-name = "rkyv_derive"
-version = "0.7.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2e06b915b5c230a17d7a736d1e2e63ee753c256a8614ef3f5147b13a4f5541d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "rust-embed"
 version = "6.8.1"
@@ -4170,7 +3800,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rust-embed-utils",
- "syn 2.0.32",
+ "syn 2.0.64",
  "walkdir",
 ]
 
@@ -4391,12 +4021,6 @@ dependencies = [
  "untrusted 0.7.1",
 ]
 
-[[package]]
-name = "seahash"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
-
 [[package]]
 name = "sec1"
 version = "0.3.0"
@@ -4411,12 +4035,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "self_cell"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e388332cd64eb80cd595a00941baf513caffae8dce9cfd0467fc9c66397dade6"
-
 [[package]]
 name = "semver"
 version = "1.0.20"
@@ -4428,9 +4046,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.179"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5bf42b8d227d4abf38a1ddb08602e229108a517cd4e5bb28f9c7eaafdce5c0"
+checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395"
 dependencies = [
  "serde_derive",
 ]
@@ -4469,26 +4087,15 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "serde-wasm-bindgen"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf"
-dependencies = [
- "js-sys",
- "serde",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "serde_derive"
-version = "1.0.179"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "741e124f5485c7e60c03b043f79f320bff3527f4bbf12cf3831750dc46a0ec2c"
+checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -4510,7 +4117,7 @@ checksum = "1d89a8107374290037607734c0b73a85db7ed80cae314b3c5791f192a496e731"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -4544,7 +4151,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "serde",
  "serde_json",
  "serde_with_macros",
@@ -4560,7 +4167,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -4593,16 +4200,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "shared-buffer"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6c99835bad52957e7aa241d3975ed17c1e5f8c92026377d117a606f36b84b16"
-dependencies = [
- "bytes",
- "memmap2 0.6.2",
-]
-
 [[package]]
 name = "shell-words"
 version = "1.1.0"
@@ -4619,12 +4216,6 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
-[[package]]
-name = "simdutf8"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a"
-
 [[package]]
 name = "similar"
 version = "2.3.0"
@@ -4670,12 +4261,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "slice-group-by"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
-
 [[package]]
 name = "small-ord-set"
 version = "0.1.3"
@@ -4807,7 +4392,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "167a4ffd7c35c143fd1030aa3c2caf76ba42220bd5a6b5f4781896434723b8c3"
 dependencies = [
  "debugid",
- "memmap2 0.5.10",
+ "memmap2",
  "stable_deref_trait",
  "uuid",
 ]
@@ -4836,21 +4421,15 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.32"
+version = "2.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "239814284fd6f1a4ffe4ca893952cdd93c224b6a1571c9a9eadd670295c0c9e2"
+checksum = "7ad3dee41f36859875573074334c200d1add8e4a87bb37113ebd31d926b7b11f"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
 [[package]]
 name = "tar"
 version = "0.4.40"
@@ -4862,12 +4441,6 @@ dependencies = [
  "xattr",
 ]
 
-[[package]]
-name = "target-lexicon"
-version = "0.12.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d0e916b1148c8e263850e1ebcbd046f333e0683c724876bb0da63ea4373dc8a"
-
 [[package]]
 name = "tempfile"
 version = "3.8.0"
@@ -4970,7 +4543,7 @@ checksum = "463fe12d7993d3b327787537ce8dd4dfa058de32fc2b195ef3cde03dc4771e8f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -5070,7 +4643,7 @@ checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -5159,7 +4732,7 @@ version = "0.19.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8123f27e969974a3dfba720fdb560be359f57b44302d280ba72e76a74480e8a"
 dependencies = [
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -5221,7 +4794,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -5392,13 +4965,13 @@ dependencies = [
 
 [[package]]
 name = "url"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50bff7831e19200a85b17131d085c25d7811bc4e186efdaf54bbd132994a88cb"
+checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
 dependencies = [
  "form_urlencoded",
- "idna 0.4.0",
- "percent-encoding 2.3.0",
+ "idna 0.5.0",
+ "percent-encoding 2.3.1",
  "serde",
 ]
 
@@ -5499,7 +5072,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
  "wasm-bindgen-shared",
 ]
 
@@ -5533,7 +5106,7 @@ checksum = "e128beba882dd1eb6200e1dc92ae6c5dbaa4311aa7bb211ca035779e5efc39f8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -5568,179 +5141,6 @@ dependencies = [
  "quote",
 ]
 
-[[package]]
-name = "wasm-encoder"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba64e81215916eaeb48fee292f29401d69235d62d8b8fd92a7b2844ec5ae5f7"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "wasmer"
-version = "4.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c15724dc25d1ee57962334aea8e41ade2675e5ea2ac6b8d42da6051b0face66"
-dependencies = [
- "bytes",
- "cfg-if 1.0.0",
- "derivative",
- "indexmap 1.9.3",
- "js-sys",
- "more-asserts",
- "rustc-demangle",
- "serde",
- "serde-wasm-bindgen",
- "shared-buffer",
- "target-lexicon",
- "thiserror",
- "tracing",
- "wasm-bindgen",
- "wasmer-compiler",
- "wasmer-compiler-cranelift",
- "wasmer-derive",
- "wasmer-types",
- "wasmer-vm",
- "wasmparser",
- "wat",
- "winapi",
-]
-
-[[package]]
-name = "wasmer-compiler"
-version = "4.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55a7f3b3a96f8d844c25e2c032af9572306dd63fa93dc17bcca4c5458ac569bd"
-dependencies = [
- "backtrace",
- "bytes",
- "cfg-if 1.0.0",
- "enum-iterator",
- "enumset",
- "lazy_static",
- "leb128",
- "memmap2 0.5.10",
- "more-asserts",
- "region",
- "rkyv",
- "self_cell",
- "shared-buffer",
- "smallvec",
- "thiserror",
- "wasmer-types",
- "wasmer-vm",
- "wasmparser",
- "winapi",
-]
-
-[[package]]
-name = "wasmer-compiler-cranelift"
-version = "4.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "102e2c5bacac69495c4025767e2fa26797ffb27f242dccb7cf57d9cefd944386"
-dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "gimli 0.26.2",
- "more-asserts",
- "rayon",
- "smallvec",
- "target-lexicon",
- "tracing",
- "wasmer-compiler",
- "wasmer-types",
-]
-
-[[package]]
-name = "wasmer-derive"
-version = "4.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea737fa08f95d6abc4459f42a70a9833e8974b814e74971d77ef473814f4d4c"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "wasmer-types"
-version = "4.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0689110e291b0f07fc665f2824e5ff81df120848e8a9acfbf1a9bf7990773f9"
-dependencies = [
- "bytecheck",
- "enum-iterator",
- "enumset",
- "indexmap 1.9.3",
- "more-asserts",
- "rkyv",
- "target-lexicon",
- "thiserror",
-]
-
-[[package]]
-name = "wasmer-vm"
-version = "4.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd41f822a1ac4242d478754e8ceba2806a00ea5072803622e1fe91e8e28b2a1"
-dependencies = [
- "backtrace",
- "cc",
- "cfg-if 1.0.0",
- "corosensei",
- "crossbeam-queue",
- "dashmap",
- "derivative",
- "enum-iterator",
- "fnv",
- "indexmap 1.9.3",
- "lazy_static",
- "libc",
- "mach",
- "memoffset 0.9.0",
- "more-asserts",
- "region",
- "scopeguard",
- "thiserror",
- "wasmer-types",
- "winapi",
-]
-
-[[package]]
-name = "wasmparser"
-version = "0.121.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
-dependencies = [
- "bitflags 2.5.0",
- "indexmap 2.0.0",
- "semver",
-]
-
-[[package]]
-name = "wast"
-version = "64.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a259b226fd6910225aa7baeba82f9d9933b6d00f2ce1b49b80fa4214328237cc"
-dependencies = [
- "leb128",
- "memchr",
- "unicode-width",
- "wasm-encoder",
-]
-
-[[package]]
-name = "wat"
-version = "1.0.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53253d920ab413fca1c7dc2161d601c79b4fdf631d0ba51dd4343bf9b556c3f6"
-dependencies = [
- "wast",
-]
-
 [[package]]
 name = "web-sys"
 version = "0.3.63"
@@ -5797,19 +5197,6 @@ dependencies = [
  "windows-targets 0.48.1",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43dbb096663629518eb1dfa72d80243ca5a6aca764cae62a2df70af760a9be75"
-dependencies = [
- "windows_aarch64_msvc 0.33.0",
- "windows_i686_gnu 0.33.0",
- "windows_i686_msvc 0.33.0",
- "windows_x86_64_gnu 0.33.0",
- "windows_x86_64_msvc 0.33.0",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -5870,12 +5257,6 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.0"
@@ -5888,12 +5269,6 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.0"
@@ -5906,12 +5281,6 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.0"
@@ -5924,12 +5293,6 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.0"
@@ -5954,12 +5317,6 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.0"
@@ -5991,15 +5348,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
 [[package]]
 name = "xattr"
 version = "1.0.1"
@@ -6026,7 +5374,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -6046,5 +5394,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.32",
+ "syn 2.0.64",
 ]
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index ec63649947e..63f64e97729 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -29,6 +29,10 @@ tracing-web.workspace = true
 
 const-str = "0.5.5"
 
+# This is an unused dependency, we are adding it
+# so that we can enable the js feature in getrandom.
+getrandom = { workspace = true, features = ["js"] }
+
 [build-dependencies]
 build-data.workspace = true
 pkg-config = "0.3"
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index 66a4388b132..3b8210f4875 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -2,6 +2,9 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
+// See Cargo.toml for explanation.
+use getrandom as _;
+
 mod black_box_solvers;
 mod build_info;
 mod compression;
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 49448d58fe6..132dddd50e5 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -15,8 +15,6 @@ repository.workspace = true
 [dependencies]
 acir.workspace = true
 acvm_blackbox_solver.workspace = true
-thiserror.workspace = true
-cfg-if = "1.0.0"
 hex.workspace = true
 lazy_static = "1.4"
 
@@ -26,19 +24,6 @@ ark-ec = { version = "^0.4.0", default-features = false }
 ark-ff = { version = "^0.4.0", default-features = false }
 num-bigint.workspace = true
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-wasmer = { version = "4.2.6", default-features = false, features = [
-    "js-default",
-] }
-
-getrandom = { workspace = true, features = ["js"] }
-wasm-bindgen-futures.workspace = true
-js-sys.workspace = true
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-getrandom.workspace = true
-wasmer = "4.2.6"
-
 [dev-dependencies]
 ark-std = { version = "^0.4.0", default-features = false }
 criterion = "0.5.0"
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index ae6fb7999a0..eebc65db141 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -2,44 +2,29 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
-use acir::{BlackBoxFunc, FieldElement};
+use acir::FieldElement;
 use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 mod embedded_curve_ops;
 mod generator;
 mod pedersen;
 mod poseidon2;
-mod wasm;
+mod schnorr;
 
 use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use poseidon2::poseidon2_permutation;
-use wasm::Barretenberg;
 
-use self::wasm::SchnorrSig;
-
-pub struct Bn254BlackBoxSolver {
-    blackbox_vendor: Barretenberg,
-}
+pub struct Bn254BlackBoxSolver;
 
 impl Bn254BlackBoxSolver {
     pub async fn initialize() -> Bn254BlackBoxSolver {
-        // We fallback to the sync initialization of barretenberg on non-wasm targets.
-        // This ensures that wasm packages consuming this still build on the default target (useful for linting, etc.)
-        cfg_if::cfg_if! {
-            if #[cfg(target_arch = "wasm32")] {
-                let blackbox_vendor = Barretenberg::initialize().await;
-                Bn254BlackBoxSolver { blackbox_vendor }
-            } else {
-                Bn254BlackBoxSolver::new()
-            }
-        }
+        Bn254BlackBoxSolver
     }
 
     #[cfg(not(target_arch = "wasm32"))]
     pub fn new() -> Bn254BlackBoxSolver {
-        let blackbox_vendor = Barretenberg::new();
-        Bn254BlackBoxSolver { blackbox_vendor }
+        Bn254BlackBoxSolver
     }
 }
 
@@ -58,16 +43,15 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
         signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError> {
-        let pub_key_bytes: Vec<u8> =
-            public_key_x.to_be_bytes().iter().copied().chain(public_key_y.to_be_bytes()).collect();
-
-        let pub_key: [u8; 64] = pub_key_bytes.try_into().unwrap();
         let sig_s: [u8; 32] = signature[0..32].try_into().unwrap();
         let sig_e: [u8; 32] = signature[32..64].try_into().unwrap();
-
-        self.blackbox_vendor.verify_signature(pub_key, sig_s, sig_e, message).map_err(|err| {
-            BlackBoxResolutionError::Failed(BlackBoxFunc::SchnorrVerify, err.to_string())
-        })
+        Ok(schnorr::verify_signature(
+            public_key_x.into_repr(),
+            public_key_y.into_repr(),
+            sig_s,
+            sig_e,
+            message,
+        ))
     }
 
     fn pedersen_commitment(
diff --git a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
new file mode 100644
index 00000000000..cb213726973
--- /dev/null
+++ b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
@@ -0,0 +1,146 @@
+use acvm_blackbox_solver::blake2s;
+use ark_ec::{
+    short_weierstrass::{Affine, SWCurveConfig},
+    AffineRepr, CurveConfig, CurveGroup,
+};
+use ark_ff::{BigInteger, PrimeField, Zero};
+use grumpkin::{Fq, GrumpkinParameters};
+
+pub(crate) fn verify_signature(
+    pub_key_x: Fq,
+    pub_key_y: Fq,
+    sig_s_bytes: [u8; 32],
+    sig_e_bytes: [u8; 32],
+    message: &[u8],
+) -> bool {
+    let pub_key = Affine::<GrumpkinParameters>::new_unchecked(pub_key_x, pub_key_y);
+
+    if !pub_key.is_on_curve()
+        || !pub_key.is_in_correct_subgroup_assuming_on_curve()
+        || pub_key.is_zero()
+    {
+        return false;
+    }
+
+    let sig_s =
+        <GrumpkinParameters as CurveConfig>::ScalarField::from_be_bytes_mod_order(&sig_s_bytes);
+    let sig_e =
+        <GrumpkinParameters as CurveConfig>::ScalarField::from_be_bytes_mod_order(&sig_e_bytes);
+
+    if sig_s.is_zero() || sig_e.is_zero() {
+        return false;
+    }
+
+    // R = g^{sig.s} • pub^{sig.e}
+    let r = GrumpkinParameters::GENERATOR * sig_s + pub_key * sig_e;
+    if r.is_zero() {
+        // this result implies k == 0, which would be catastrophic for the prover.
+        // it is a cheap check that ensures this doesn't happen.
+        return false;
+    }
+
+    // compare the _hashes_ rather than field elements modulo r
+    // e = H(pedersen(r, pk.x, pk.y), m), where r = R.x
+    let target_e_bytes = schnorr_generate_challenge(message, pub_key_x, pub_key_y, r.into_affine());
+
+    sig_e_bytes == target_e_bytes
+}
+
+fn schnorr_generate_challenge(
+    message: &[u8],
+    pub_key_x: Fq,
+    pub_key_y: Fq,
+    r: Affine<GrumpkinParameters>,
+) -> [u8; 32] {
+    // create challenge message pedersen_commitment(R.x, pubkey)
+
+    let r_x = *r.x().expect("r has been checked to be non-zero");
+    let pedersen_hash = crate::pedersen::hash::hash_with_index(&[r_x, pub_key_x, pub_key_y], 0);
+
+    let mut hash_input: Vec<u8> = pedersen_hash.into_bigint().to_bytes_be();
+    hash_input.extend(message);
+
+    blake2s(&hash_input).unwrap()
+}
+
+#[cfg(test)]
+mod schnorr_tests {
+    use acir::FieldElement;
+
+    use super::verify_signature;
+
+    #[test]
+    fn verifies_valid_signature() {
+        let pub_key_x: grumpkin::Fq = FieldElement::from_hex(
+            "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
+        )
+        .unwrap()
+        .into_repr();
+        let pub_key_y: grumpkin::Fq = FieldElement::from_hex(
+            "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
+        )
+        .unwrap()
+        .into_repr();
+        let sig_s_bytes: [u8; 32] = [
+            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,
+            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48,
+        ];
+        let sig_e_bytes: [u8; 32] = [
+            27, 237, 155, 84, 39, 84, 247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135,
+            179, 171, 4, 214, 202, 64, 199, 19, 84, 239, 138, 124, 12,
+        ];
+        let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+        assert!(verify_signature(pub_key_x, pub_key_y, sig_s_bytes, sig_e_bytes, message));
+    }
+
+    #[test]
+    fn rejects_zero_e() {
+        let pub_key_x: grumpkin::Fq = FieldElement::from_hex(
+            "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
+        )
+        .unwrap()
+        .into_repr();
+        let pub_key_y: grumpkin::Fq = FieldElement::from_hex(
+            "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
+        )
+        .unwrap()
+        .into_repr();
+        let sig_s_bytes: [u8; 32] = [
+            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,
+            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48,
+        ];
+        let sig_e_bytes: [u8; 32] = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0,
+        ];
+        let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+        assert!(!verify_signature(pub_key_x, pub_key_y, sig_s_bytes, sig_e_bytes, message));
+    }
+
+    #[test]
+    fn rejects_zero_s() {
+        let pub_key_x: grumpkin::Fq = FieldElement::from_hex(
+            "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
+        )
+        .unwrap()
+        .into_repr();
+        let pub_key_y: grumpkin::Fq = FieldElement::from_hex(
+            "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
+        )
+        .unwrap()
+        .into_repr();
+        let sig_s_bytes: [u8; 32] = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0,
+        ];
+        let sig_e_bytes: [u8; 32] = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0,
+        ];
+        let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+        assert!(!verify_signature(pub_key_x, pub_key_y, sig_s_bytes, sig_e_bytes, message));
+    }
+}
diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/acvm_backend.wasm b/acvm-repo/bn254_blackbox_solver/src/wasm/acvm_backend.wasm
deleted file mode 100755
index bcf3bbf27ee6f7331f0ab8c776fef80ff023e3d1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 756082
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

diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
deleted file mode 100644
index e0a5c4c9069..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-//! ACVM execution is independent of the proving backend against which the ACIR code is being proven.
-//! However there are currently a few opcodes for which there is currently no rust implementation so we must
-//! use the C++ implementations included in Aztec Lab's Barretenberg library.
-//!
-//! As [`acvm`] includes rust implementations for these opcodes, this module can be removed.
-
-mod schnorr;
-
-pub(crate) use schnorr::SchnorrSig;
-
-/// The number of bytes necessary to store a `FieldElement`.
-const FIELD_BYTES: usize = 32;
-
-#[derive(Debug, thiserror::Error)]
-pub(crate) enum Error {
-    #[error(transparent)]
-    FromFeature(#[from] FeatureError),
-}
-
-#[derive(Debug, thiserror::Error)]
-pub(crate) enum FeatureError {
-    #[error("Trying to call {name} resulted in an error")]
-    FunctionCallFailed { name: String, source: wasmer::RuntimeError },
-    #[error("Could not find function export named {name}")]
-    InvalidExport { name: String, source: wasmer::ExportError },
-    #[error("No value available when value was expected")]
-    NoValue,
-    #[error("Value expected to be i32")]
-    InvalidI32,
-    #[error("Could not convert value {value} from i32 to u32")]
-    InvalidU32 { value: i32, source: std::num::TryFromIntError },
-    #[error("Could not convert value {value} from i32 to usize")]
-    InvalidUsize { value: i32, source: std::num::TryFromIntError },
-    #[error("Value expected to be 0 or 1 representing a boolean")]
-    InvalidBool,
-}
-#[derive(Debug, thiserror::Error)]
-#[error(transparent)]
-pub(crate) struct BackendError(#[from] Error);
-
-impl From<FeatureError> for BackendError {
-    fn from(value: FeatureError) -> Self {
-        BackendError(Error::FromFeature(value))
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Barretenberg {
-    store: std::cell::RefCell<wasmer::Store>,
-    memory: wasmer::Memory,
-    instance: wasmer::Instance,
-}
-
-use std::cell::RefCell;
-
-use wasmer::{
-    imports, Function, FunctionEnv, FunctionEnvMut, Imports, Instance, Memory, MemoryType, Store,
-    Value, WasmPtr,
-};
-
-/// The number of bytes necessary to represent a pointer to memory inside the wasm.
-// pub(super) const POINTER_BYTES: usize = 4;
-
-/// The Barretenberg WASM gives us 1024 bytes of scratch space which we can use without
-/// needing to allocate/free it ourselves. This can be useful for when we need to pass in several small variables
-/// when calling functions on the wasm, however it's important to not overrun this scratch space as otherwise
-/// the written data will begin to corrupt the stack.
-///
-/// Using this scratch space isn't particularly safe if we have multiple threads interacting with the wasm however,
-/// each thread could write to the same pointer address simultaneously.
-pub(super) const WASM_SCRATCH_BYTES: usize = 1024;
-
-/// Embed the Barretenberg WASM file
-const WASM_BIN: &[u8] = include_bytes!("./acvm_backend.wasm");
-
-impl Barretenberg {
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn new() -> Barretenberg {
-        let (instance, memory, store) = instance_load();
-        let barretenberg = Barretenberg { memory, instance, store: RefCell::new(store) };
-        barretenberg.call_wasi_initialize();
-        barretenberg
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    pub(crate) async fn initialize() -> Barretenberg {
-        let (instance, memory, store) = instance_load().await;
-        let barretenberg = Barretenberg { memory, instance, store: RefCell::new(store) };
-        barretenberg.call_wasi_initialize();
-        barretenberg
-    }
-    /// Call initialization function for WASI, to initialize all of the appropriate
-    /// globals.
-    fn call_wasi_initialize(&self) {
-        self.call_multiple("_initialize", vec![])
-            .expect("expected call to WASI initialization function to not fail");
-    }
-}
-
-/// A wrapper around the arguments or return value from a WASM call.
-/// Notice, `Option<Value>` is used because not every call returns a value,
-/// some calls are simply made to free a pointer or manipulate the heap.
-#[derive(Debug, Clone)]
-pub(crate) struct WASMValue(Option<Value>);
-
-impl From<usize> for WASMValue {
-    fn from(value: usize) -> Self {
-        WASMValue(Some(Value::I32(value as i32)))
-    }
-}
-
-impl From<u32> for WASMValue {
-    fn from(value: u32) -> Self {
-        WASMValue(Some(Value::I32(value as i32)))
-    }
-}
-
-impl From<i32> for WASMValue {
-    fn from(value: i32) -> Self {
-        WASMValue(Some(Value::I32(value)))
-    }
-}
-
-impl From<Value> for WASMValue {
-    fn from(value: Value) -> Self {
-        WASMValue(Some(value))
-    }
-}
-
-impl TryFrom<WASMValue> for bool {
-    type Error = FeatureError;
-
-    fn try_from(value: WASMValue) -> Result<Self, Self::Error> {
-        match value.try_into()? {
-            0 => Ok(false),
-            1 => Ok(true),
-            _ => Err(FeatureError::InvalidBool),
-        }
-    }
-}
-
-impl TryFrom<WASMValue> for usize {
-    type Error = FeatureError;
-
-    fn try_from(value: WASMValue) -> Result<Self, Self::Error> {
-        let value: i32 = value.try_into()?;
-        value.try_into().map_err(|source| FeatureError::InvalidUsize { value, source })
-    }
-}
-
-impl TryFrom<WASMValue> for u32 {
-    type Error = FeatureError;
-
-    fn try_from(value: WASMValue) -> Result<Self, Self::Error> {
-        let value = value.try_into()?;
-        u32::try_from(value).map_err(|source| FeatureError::InvalidU32 { value, source })
-    }
-}
-
-impl TryFrom<WASMValue> for i32 {
-    type Error = FeatureError;
-
-    fn try_from(value: WASMValue) -> Result<Self, Self::Error> {
-        value.0.map_or(Err(FeatureError::NoValue), |val| val.i32().ok_or(FeatureError::InvalidI32))
-    }
-}
-
-impl TryFrom<WASMValue> for Value {
-    type Error = FeatureError;
-
-    fn try_from(value: WASMValue) -> Result<Self, Self::Error> {
-        value.0.ok_or(FeatureError::NoValue)
-    }
-}
-
-impl Barretenberg {
-    /// Transfer bytes to WASM heap
-    // TODO: Consider making this Result-returning
-    pub(crate) fn transfer_to_heap(&self, data: &[u8], offset: usize) {
-        let memory = &self.memory;
-        let store = self.store.borrow();
-        let memory_view = memory.view(&store);
-
-        memory_view.write(offset as u64, data).unwrap();
-    }
-
-    // TODO: Consider making this Result-returning
-    pub(crate) fn read_memory<const SIZE: usize>(&self, start: usize) -> [u8; SIZE] {
-        self.read_memory_variable_length(start, SIZE)
-            .try_into()
-            .expect("Read memory should be of the specified length")
-    }
-
-    // TODO: Consider making this Result-returning
-    pub(crate) fn read_memory_variable_length(&self, offset: usize, length: usize) -> Vec<u8> {
-        let memory = &self.memory;
-        let store = &self.store.borrow();
-        let memory_view = memory.view(&store);
-
-        let mut buf = vec![0; length];
-
-        memory_view.read(offset as u64, &mut buf).unwrap();
-        buf
-    }
-
-    pub(crate) fn call_multiple(
-        &self,
-        name: &str,
-        params: Vec<&WASMValue>,
-    ) -> Result<WASMValue, Error> {
-        // We take in a reference to values, since they do not implement Copy.
-        // We then clone them inside of this function, so that the API does not have a bunch of Clones everywhere
-
-        let mut args: Vec<Value> = vec![];
-        for param in params.into_iter().cloned() {
-            args.push(param.try_into()?);
-        }
-        let func = self
-            .instance
-            .exports
-            .get_function(name)
-            .map_err(|source| FeatureError::InvalidExport { name: name.to_string(), source })?;
-        let boxed_value = func.call(&mut self.store.borrow_mut(), &args).map_err(|source| {
-            FeatureError::FunctionCallFailed { name: name.to_string(), source }
-        })?;
-        let option_value = boxed_value.first().cloned();
-
-        Ok(WASMValue(option_value))
-    }
-}
-
-fn init_memory_and_state() -> (Memory, Store, Imports) {
-    let mut store = Store::default();
-
-    let mem_type = MemoryType::new(18, Some(65536), false);
-    let memory = Memory::new(&mut store, mem_type).unwrap();
-
-    let function_env = FunctionEnv::new(&mut store, memory.clone());
-    let custom_imports = imports! {
-        "env" => {
-            "logstr" => Function::new_typed_with_env(
-                &mut store,
-                &function_env,
-                logstr,
-            ),
-            "memory" => memory.clone(),
-        },
-        "wasi_snapshot_preview1" => {
-            "proc_exit" =>  Function::new_typed(&mut store, proc_exit),
-            "random_get" => Function::new_typed_with_env(
-                &mut store,
-                &function_env,
-                random_get
-            ),
-        },
-    };
-
-    (memory, store, custom_imports)
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-fn instance_load() -> (Instance, Memory, Store) {
-    use wasmer::Module;
-
-    let (memory, mut store, custom_imports) = init_memory_and_state();
-
-    let module = Module::new(&store, WASM_BIN).unwrap();
-
-    (Instance::new(&mut store, &module, &custom_imports).unwrap(), memory, store)
-}
-
-#[cfg(target_arch = "wasm32")]
-async fn instance_load() -> (Instance, Memory, Store) {
-    use js_sys::WebAssembly::{self};
-    use wasmer::AsJs;
-
-    let (memory, mut store, custom_imports) = init_memory_and_state();
-
-    let js_bytes = unsafe { js_sys::Uint8Array::view(&WASM_BIN) };
-    let js_module_promise = WebAssembly::compile(&js_bytes);
-    let js_module: js_sys::WebAssembly::Module =
-        wasm_bindgen_futures::JsFuture::from(js_module_promise).await.unwrap().into();
-
-    let js_instance_promise =
-        WebAssembly::instantiate_module(&js_module, &custom_imports.as_jsvalue(&store).into());
-    let js_instance = wasm_bindgen_futures::JsFuture::from(js_instance_promise).await.unwrap();
-    let module = wasmer::Module::from((js_module, WASM_BIN));
-    let instance: wasmer::Instance = Instance::from_jsvalue(&mut store, &module, &js_instance)
-        .map_err(|_| "Error while creating BlackBox Functions vendor instance")
-        .unwrap();
-
-    (instance, memory, store)
-}
-
-fn logstr(mut env: FunctionEnvMut<Memory>, ptr: i32) {
-    let (memory, store) = env.data_and_store_mut();
-    let memory_view = memory.view(&store);
-
-    let log_str_wasm_ptr: WasmPtr<u8, wasmer::Memory32> = WasmPtr::new(ptr as u32);
-
-    match log_str_wasm_ptr.read_utf8_string_with_nul(&memory_view) {
-        Ok(log_string) => println!("{log_string}"),
-        Err(err) => println!("Error while reading log string from memory: {err}"),
-    };
-}
-
-// Based on https://github.com/wasmerio/wasmer/blob/2.3.0/lib/wasi/src/syscalls/mod.rs#L2537
-fn random_get(mut env: FunctionEnvMut<Memory>, buf_ptr: i32, buf_len: i32) -> i32 {
-    let mut u8_buffer = vec![0; buf_len as usize];
-    let res = getrandom::getrandom(&mut u8_buffer);
-    match res {
-        Ok(()) => {
-            let (memory, store) = env.data_and_store_mut();
-            let memory_view = memory.view(&store);
-            match memory_view.write(buf_ptr as u64, u8_buffer.as_mut_slice()) {
-                Ok(_) => {
-                    0_i32 // __WASI_ESUCCESS
-                }
-                Err(_) => {
-                    29_i32 // __WASI_EIO
-                }
-            }
-        }
-        Err(_) => {
-            29_i32 // __WASI_EIO
-        }
-    }
-}
-
-fn proc_exit(_: i32) {
-    unimplemented!("proc_exit is not implemented")
-}
diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/schnorr.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/schnorr.rs
deleted file mode 100644
index 18c4f04ef64..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/schnorr.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use super::{Barretenberg, Error, FIELD_BYTES, WASM_SCRATCH_BYTES};
-
-pub(crate) trait SchnorrSig {
-    fn construct_signature(
-        &self,
-        message: &[u8],
-        private_key: [u8; 32],
-    ) -> Result<([u8; 32], [u8; 32]), Error>;
-    fn construct_public_key(&self, private_key: [u8; 32]) -> Result<[u8; 64], Error>;
-    fn verify_signature(
-        &self,
-        pub_key: [u8; 64],
-        sig_s: [u8; 32],
-        sig_e: [u8; 32],
-        message: &[u8],
-    ) -> Result<bool, Error>;
-}
-
-impl SchnorrSig for Barretenberg {
-    fn construct_signature(
-        &self,
-        message: &[u8],
-        private_key: [u8; 32],
-    ) -> Result<([u8; 32], [u8; 32]), Error> {
-        let sig_s_ptr: usize = 0;
-        let sig_e_ptr: usize = sig_s_ptr + FIELD_BYTES;
-        let private_key_ptr: usize = sig_e_ptr + FIELD_BYTES;
-        let message_ptr: usize = private_key_ptr + private_key.len();
-        assert!(
-            message_ptr + message.len() < WASM_SCRATCH_BYTES,
-            "Message overran wasm scratch space"
-        );
-
-        self.transfer_to_heap(&private_key, private_key_ptr);
-        self.transfer_to_heap(message, message_ptr);
-        self.call_multiple(
-            "construct_signature",
-            vec![
-                &message_ptr.into(),
-                &message.len().into(),
-                &private_key_ptr.into(),
-                &sig_s_ptr.into(),
-                &sig_e_ptr.into(),
-            ],
-        )?;
-
-        let sig_s: [u8; FIELD_BYTES] = self.read_memory(sig_s_ptr);
-        let sig_e: [u8; FIELD_BYTES] = self.read_memory(sig_e_ptr);
-
-        Ok((sig_s, sig_e))
-    }
-
-    #[allow(dead_code)]
-    fn construct_public_key(&self, private_key: [u8; 32]) -> Result<[u8; 64], Error> {
-        let private_key_ptr: usize = 0;
-        let result_ptr: usize = private_key_ptr + FIELD_BYTES;
-
-        self.transfer_to_heap(&private_key, private_key_ptr);
-
-        self.call_multiple(
-            "compute_public_key",
-            vec![&private_key_ptr.into(), &result_ptr.into()],
-        )?;
-
-        Ok(self.read_memory(result_ptr))
-    }
-
-    fn verify_signature(
-        &self,
-        pub_key: [u8; 64],
-        sig_s: [u8; 32],
-        sig_e: [u8; 32],
-        message: &[u8],
-    ) -> Result<bool, Error> {
-        let public_key_ptr: usize = 0;
-        let sig_s_ptr: usize = public_key_ptr + pub_key.len();
-        let sig_e_ptr: usize = sig_s_ptr + sig_s.len();
-        let message_ptr: usize = sig_e_ptr + sig_e.len();
-        assert!(
-            message_ptr + message.len() < WASM_SCRATCH_BYTES,
-            "Message overran wasm scratch space"
-        );
-
-        self.transfer_to_heap(&pub_key, public_key_ptr);
-        self.transfer_to_heap(&sig_s, sig_s_ptr);
-        self.transfer_to_heap(&sig_e, sig_e_ptr);
-        self.transfer_to_heap(message, message_ptr);
-
-        let verified = self.call_multiple(
-            "verify_signature",
-            vec![
-                &message_ptr.into(),
-                &message.len().into(),
-                &public_key_ptr.into(),
-                &sig_s_ptr.into(),
-                &sig_e_ptr.into(),
-            ],
-        )?;
-
-        // Note, currently for Barretenberg plonk, if the signature fails
-        // then the whole circuit fails.
-        Ok(verified.try_into()?)
-    }
-}

From aea60c0ca75a5b7d66085e40bfbe481f016114f2 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 21 May 2024 10:45:07 -0500
Subject: [PATCH 278/416] chore(experimental): Elaborate impls & non-trait
 impls (#5007)

# Description

## Problem\*

Working towards #4594

## Summary\*

Adds support for impls and trait impls to the elaborator.

This was somewhat satisfying to add since the existing code for this in
`dc_crate.rs` is very messy & long winded due to our current design of
creating a new `NameResolver` for every resolution. Keeping everything
in the same elaborator and not needing to keep setting the interner, def
maps, current crate, module, generics, append errors, etc saved many
lines. I think this implementation is roughly half the size as a result.

## Additional Context

Still need types, type aliases, and globals after this. The pass is
testable after that but is expected to fail the comptime tests at least.
So I'll need to inline the comptime scanning pass in the elaborator as
well. After that the pass is theoretically done but realistically there
will be bugs to fix before we can make it the default.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 355 +++++++++++++++++-
 .../src/hir/def_collector/dc_crate.rs         |   4 +
 2 files changed, 342 insertions(+), 17 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 446e5b62ead..0f9d22ca9b5 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -4,14 +4,13 @@ use std::{
     rc::Rc,
 };
 
-use crate::hir::def_map::CrateDefMap;
 use crate::{
     ast::{
         ArrayLiteral, ConstructorExpression, FunctionKind, IfExpression, InfixExpression, Lambda,
         UnresolvedTraitConstraint, UnresolvedTypeExpression,
     },
     hir::{
-        def_collector::dc_crate::CompilationError,
+        def_collector::{dc_crate::CompilationError, errors::DuplicateType},
         resolution::{errors::ResolverError, path_resolver::PathResolver, resolver::LambdaContext},
         scope::ScopeForest as GenericScopeForest,
         type_check::TypeCheckError,
@@ -56,6 +55,14 @@ use crate::{
     token::FunctionAttribute,
     Generics,
 };
+use crate::{
+    hir::{
+        def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
+        def_map::{CrateDefMap, ModuleData},
+    },
+    hir_def::traits::TraitImpl,
+    macros_api::ItemVisibility,
+};
 
 mod expressions;
 mod patterns;
@@ -86,7 +93,7 @@ pub struct Elaborator<'context> {
 
     interner: &'context mut NodeInterner,
 
-    def_maps: &'context BTreeMap<CrateId, CrateDefMap>,
+    def_maps: &'context mut BTreeMap<CrateId, CrateDefMap>,
 
     file: FileId,
 
@@ -168,7 +175,7 @@ impl<'context> Elaborator<'context> {
             scopes: ScopeForest::default(),
             errors: Vec::new(),
             interner: &mut context.def_interner,
-            def_maps: &context.def_maps,
+            def_maps: &mut context.def_maps,
             file: FileId::dummy(),
             in_unconstrained_fn: false,
             nested_loops: 0,
@@ -192,7 +199,7 @@ impl<'context> Elaborator<'context> {
     pub fn elaborate(
         context: &'context mut Context,
         crate_id: CrateId,
-        items: CollectedItems,
+        mut items: CollectedItems,
     ) -> Vec<(CompilationError, FileId)> {
         let mut this = Self::new(context, crate_id);
 
@@ -205,28 +212,27 @@ impl<'context> Elaborator<'context> {
 
         for struct_ in items.types {}
 
-        for trait_impl in &items.trait_impls {
-            // only collect now
+        for trait_impl in &mut items.trait_impls {
+            this.collect_trait_impl(trait_impl);
         }
 
-        for impl_ in &items.impls {
-            // only collect now
+        for ((typ, module), impls) in &items.impls {
+            this.collect_impls(typ, *module, impls);
         }
 
         // resolver resolves non-literal globals here
 
         for functions in items.functions {
-            this.file = functions.file_id;
-            this.trait_id = functions.trait_id; // TODO: Resolve?
-            for (local_module, id, func) in functions.functions {
-                this.local_module = local_module;
-                this.elaborate_function(func, id);
-            }
+            this.elaborate_functions(functions);
         }
 
-        for impl_ in items.impls {}
+        for ((typ, module), impls) in items.impls {
+            this.elaborate_impls(typ, module, impls);
+        }
 
-        for trait_impl in items.trait_impls {}
+        for trait_impl in items.trait_impls {
+            this.elaborate_trait_impl(trait_impl);
+        }
 
         let cycle_errors = this.interner.check_for_dependency_cycles();
         this.errors.extend(cycle_errors);
@@ -234,6 +240,17 @@ impl<'context> Elaborator<'context> {
         this.errors
     }
 
+    fn elaborate_functions(&mut self, functions: UnresolvedFunctions) {
+        self.file = functions.file_id;
+        self.trait_id = functions.trait_id; // TODO: Resolve?
+        for (local_module, id, func) in functions.functions {
+            self.local_module = local_module;
+            let generics_count = self.generics.len();
+            self.elaborate_function(func, id);
+            self.generics.truncate(generics_count);
+        }
+    }
+
     fn elaborate_function(&mut self, mut function: NoirFunction, id: FuncId) {
         self.current_function = Some(id);
         self.resolve_where_clause(&mut function.def.where_clause);
@@ -779,4 +796,308 @@ impl<'context> Elaborator<'context> {
             }
         }
     }
+
+    fn elaborate_impls(
+        &mut self,
+        typ: UnresolvedType,
+        module: LocalModuleId,
+        impls: Vec<(Vec<Ident>, Span, UnresolvedFunctions)>,
+    ) {
+        self.generics.clear();
+
+        for (generics, _, functions) in impls {
+            self.file = functions.file_id;
+            self.add_generics(&generics);
+            let self_type = self.resolve_type(typ.clone());
+            self.self_type = Some(self_type.clone());
+
+            let function_ids = vecmap(&functions.functions, |(_, id, _)| *id);
+            self.elaborate_functions(functions);
+
+            if self_type != Type::Error {
+                for method_id in function_ids {
+                    let method_name = self.interner.function_name(&method_id).to_owned();
+
+                    if let Some(first_fn) =
+                        self.interner.add_method(&self_type, method_name.clone(), method_id, false)
+                    {
+                        let error = ResolverError::DuplicateDefinition {
+                            name: method_name,
+                            first_span: self.interner.function_ident(&first_fn).span(),
+                            second_span: self.interner.function_ident(&method_id).span(),
+                        };
+                        self.push_err(error);
+                    }
+                }
+            }
+        }
+    }
+
+    fn elaborate_trait_impl(&mut self, trait_impl: UnresolvedTraitImpl) {
+        self.file = trait_impl.file_id;
+        self.local_module = trait_impl.module_id;
+
+        let unresolved_type = trait_impl.object_type;
+        let self_type_span = unresolved_type.span;
+        self.add_generics(&trait_impl.generics);
+
+        let trait_generics =
+            vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
+
+        let self_type = self.resolve_type(unresolved_type.clone());
+        let impl_id = self.interner.next_trait_impl_id();
+
+        self.self_type = Some(self_type.clone());
+        self.current_trait_impl = Some(impl_id);
+
+        let mut methods = trait_impl.methods.function_ids();
+
+        self.elaborate_functions(trait_impl.methods);
+
+        if matches!(self_type, Type::MutableReference(_)) {
+            let span = self_type_span.unwrap_or_else(|| trait_impl.trait_path.span());
+            self.push_err(DefCollectorErrorKind::MutableReferenceInTraitImpl { span });
+        }
+
+        if let Some(trait_id) = trait_impl.trait_id {
+            for func_id in &methods {
+                self.interner.set_function_trait(*func_id, self_type.clone(), trait_id);
+            }
+
+            let where_clause = trait_impl
+                .where_clause
+                .into_iter()
+                .flat_map(|item| self.resolve_trait_constraint(item))
+                .collect();
+
+            let resolved_trait_impl = Shared::new(TraitImpl {
+                ident: trait_impl.trait_path.last_segment().clone(),
+                typ: self_type.clone(),
+                trait_id,
+                trait_generics: trait_generics.clone(),
+                file: trait_impl.file_id,
+                where_clause,
+                methods,
+            });
+
+            let generics = vecmap(&self.generics, |(_, type_variable, _)| type_variable.clone());
+
+            if let Err((prev_span, prev_file)) = self.interner.add_trait_implementation(
+                self_type.clone(),
+                trait_id,
+                trait_generics,
+                impl_id,
+                generics,
+                resolved_trait_impl,
+            ) {
+                self.push_err(DefCollectorErrorKind::OverlappingImpl {
+                    typ: self_type.clone(),
+                    span: self_type_span.unwrap_or_else(|| trait_impl.trait_path.span()),
+                });
+
+                // The 'previous impl defined here' note must be a separate error currently
+                // since it may be in a different file and all errors have the same file id.
+                self.file = prev_file;
+                self.push_err(DefCollectorErrorKind::OverlappingImplNote { span: prev_span });
+                self.file = trait_impl.file_id;
+            }
+        }
+
+        self.self_type = None;
+        self.current_trait_impl = None;
+        self.generics.clear();
+    }
+
+    fn collect_impls(
+        &mut self,
+        self_type: &UnresolvedType,
+        module: LocalModuleId,
+        impls: &[(Vec<Ident>, Span, UnresolvedFunctions)],
+    ) {
+        self.local_module = module;
+
+        for (generics, span, unresolved) in impls {
+            self.file = unresolved.file_id;
+            self.declare_method_on_struct(self_type, generics, false, unresolved, *span);
+        }
+    }
+
+    fn collect_trait_impl(&mut self, trait_impl: &mut UnresolvedTraitImpl) {
+        self.local_module = trait_impl.module_id;
+        self.file = trait_impl.file_id;
+        trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
+
+        if let Some(trait_id) = trait_impl.trait_id {
+            self.collect_trait_impl_methods(trait_id, trait_impl);
+
+            let span = trait_impl.object_type.span.expect("All trait self types should have spans");
+            let object_type = &trait_impl.object_type;
+            let generics = &trait_impl.generics;
+            self.declare_method_on_struct(object_type, generics, true, &trait_impl.methods, span);
+        }
+    }
+
+    fn get_module_mut(&mut self, module: ModuleId) -> &mut ModuleData {
+        let message = "A crate should always be present for a given crate id";
+        &mut self.def_maps.get_mut(&module.krate).expect(message).modules[module.local_id.0]
+    }
+
+    fn declare_method_on_struct(
+        &mut self,
+        self_type: &UnresolvedType,
+        generics: &UnresolvedGenerics,
+        is_trait_impl: bool,
+        functions: &UnresolvedFunctions,
+        span: Span,
+    ) {
+        let generic_count = self.generics.len();
+        self.add_generics(generics);
+        let typ = self.resolve_type(self_type.clone());
+
+        if let Type::Struct(struct_type, _generics) = typ {
+            let struct_type = struct_type.borrow();
+
+            // `impl`s are only allowed on types defined within the current crate
+            if !is_trait_impl && struct_type.id.krate() != self.crate_id {
+                let type_name = struct_type.name.to_string();
+                self.push_err(DefCollectorErrorKind::ForeignImpl { span, type_name });
+                self.generics.truncate(generic_count);
+                return;
+            }
+
+            // Grab the module defined by the struct type. Note that impls are a case
+            // where the module the methods are added to is not the same as the module
+            // they are resolved in.
+            let module = self.get_module_mut(struct_type.id.module_id());
+
+            for (_, method_id, method) in &functions.functions {
+                // If this method was already declared, remove it from the module so it cannot
+                // be accessed with the `TypeName::method` syntax. We'll check later whether the
+                // object types in each method overlap or not. If they do, we issue an error.
+                // If not, that is specialization which is allowed.
+                let name = method.name_ident().clone();
+                if module.declare_function(name, ItemVisibility::Public, *method_id).is_err() {
+                    module.remove_function(method.name_ident());
+                }
+            }
+        // Prohibit defining impls for primitive types if we're not in the stdlib
+        } else if !is_trait_impl && typ != Type::Error && !self.crate_id.is_stdlib() {
+            self.push_err(DefCollectorErrorKind::NonStructTypeInImpl { span });
+        }
+        self.generics.truncate(generic_count);
+    }
+
+    fn collect_trait_impl_methods(
+        &mut self,
+        trait_id: TraitId,
+        trait_impl: &mut UnresolvedTraitImpl,
+    ) {
+        self.local_module = trait_impl.module_id;
+        self.file = trait_impl.file_id;
+
+        // In this Vec methods[i] corresponds to trait.methods[i]. If the impl has no implementation
+        // for a particular method, the default implementation will be added at that slot.
+        let mut ordered_methods = Vec::new();
+
+        // check whether the trait implementation is in the same crate as either the trait or the type
+        self.check_trait_impl_crate_coherence(trait_id, trait_impl);
+
+        // set of function ids that have a corresponding method in the trait
+        let mut func_ids_in_trait = HashSet::default();
+
+        // Temporarily take ownership of the trait's methods so we can iterate over them
+        // while also mutating the interner
+        let the_trait = self.interner.get_trait_mut(trait_id);
+        let methods = std::mem::take(&mut the_trait.methods);
+
+        for method in &methods {
+            let overrides: Vec<_> = trait_impl
+                .methods
+                .functions
+                .iter()
+                .filter(|(_, _, f)| f.name() == method.name.0.contents)
+                .collect();
+
+            if overrides.is_empty() {
+                if let Some(default_impl) = &method.default_impl {
+                    // copy 'where' clause from unresolved trait impl
+                    let mut default_impl_clone = default_impl.clone();
+                    default_impl_clone.def.where_clause.extend(trait_impl.where_clause.clone());
+
+                    let func_id = self.interner.push_empty_fn();
+                    let module = self.module_id();
+                    let location = Location::new(default_impl.def.span, trait_impl.file_id);
+                    self.interner.push_function(func_id, &default_impl.def, module, location);
+                    func_ids_in_trait.insert(func_id);
+                    ordered_methods.push((
+                        method.default_impl_module_id,
+                        func_id,
+                        *default_impl_clone,
+                    ));
+                } else {
+                    self.push_err(DefCollectorErrorKind::TraitMissingMethod {
+                        trait_name: self.interner.get_trait(trait_id).name.clone(),
+                        method_name: method.name.clone(),
+                        trait_impl_span: trait_impl
+                            .object_type
+                            .span
+                            .expect("type must have a span"),
+                    });
+                }
+            } else {
+                for (_, func_id, _) in &overrides {
+                    func_ids_in_trait.insert(*func_id);
+                }
+
+                if overrides.len() > 1 {
+                    self.push_err(DefCollectorErrorKind::Duplicate {
+                        typ: DuplicateType::TraitAssociatedFunction,
+                        first_def: overrides[0].2.name_ident().clone(),
+                        second_def: overrides[1].2.name_ident().clone(),
+                    });
+                }
+
+                ordered_methods.push(overrides[0].clone());
+            }
+        }
+
+        // Restore the methods that were taken before the for loop
+        let the_trait = self.interner.get_trait_mut(trait_id);
+        the_trait.set_methods(methods);
+
+        // Emit MethodNotInTrait error for methods in the impl block that
+        // don't have a corresponding method signature defined in the trait
+        for (_, func_id, func) in &trait_impl.methods.functions {
+            if !func_ids_in_trait.contains(func_id) {
+                let trait_name = the_trait.name.clone();
+                let impl_method = func.name_ident().clone();
+                let error = DefCollectorErrorKind::MethodNotInTrait { trait_name, impl_method };
+                self.errors.push((error.into(), self.file));
+            }
+        }
+
+        trait_impl.methods.functions = ordered_methods;
+        trait_impl.methods.trait_id = Some(trait_id);
+    }
+
+    fn check_trait_impl_crate_coherence(
+        &mut self,
+        trait_id: TraitId,
+        trait_impl: &UnresolvedTraitImpl,
+    ) {
+        self.local_module = trait_impl.module_id;
+        self.file = trait_impl.file_id;
+
+        let object_crate = match self.resolve_type(trait_impl.object_type.clone()) {
+            Type::Struct(struct_type, _) => struct_type.borrow().id.krate(),
+            _ => CrateId::Dummy,
+        };
+
+        let the_trait = self.interner.get_trait(trait_id);
+        if self.crate_id != the_trait.crate_id && self.crate_id != object_crate {
+            self.push_err(DefCollectorErrorKind::TraitImplOrphaned {
+                span: trait_impl.object_type.span.expect("object type must have a span"),
+            });
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 4aac0fec9c3..d2eaf79b0f0 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -54,6 +54,10 @@ impl UnresolvedFunctions {
         self.functions.push((mod_id, func_id, func));
     }
 
+    pub fn function_ids(&self) -> Vec<FuncId> {
+        vecmap(&self.functions, |(_, id, _)| *id)
+    }
+
     pub fn resolve_trait_bounds_trait_ids(
         &mut self,
         def_maps: &BTreeMap<CrateId, CrateDefMap>,

From faf5bd8ed80fb89b4bb6a2536b9bfa9649579da7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 21 May 2024 17:12:07 +0100
Subject: [PATCH 279/416] feat: add `as_witness` builtin function in order to
 constrain a witness to be equal to a variable  (#4641)

# Description

## Problem\*

Quick fix to #4629

## Summary\*

This PR adds a `as_witness` function which takes a `Field` and instructs
the compiler to lay down an opcode which constrains a witness to be
equal to this value.

This prevents the issue in #4629 where we collect ever growing
expressions which need to be broken down multiple times while reshaping
the circuit. Doing this during acirgen instead allows us to avoid this
repetition.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.
Feature is experimental

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs            | 5 ++++-
 compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs         | 9 +++++++++
 compiler/noirc_evaluator/src/ssa/ir/instruction.rs       | 7 ++++++-
 compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs  | 1 +
 .../src/ssa/opt/remove_enable_side_effects.rs            | 3 ++-
 compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs   | 3 ++-
 noir_stdlib/src/lib.nr                                   | 3 +++
 7 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 407cdf0a17f..5f180edd05c 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -236,7 +236,10 @@ impl AcirContext {
         self.acir_ir.call_stack = call_stack;
     }
 
-    fn get_or_create_witness_var(&mut self, var: AcirVar) -> Result<AcirVar, InternalError> {
+    pub(crate) fn get_or_create_witness_var(
+        &mut self,
+        var: AcirVar,
+    ) -> Result<AcirVar, InternalError> {
         if self.var_to_expression(var)?.to_witness().is_some() {
             // If called with a variable which is already a witness then return the same variable.
             return Ok(var);
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 05d2e3e3e6a..2430a00fd4c 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -2605,6 +2605,15 @@ impl<'a> Context<'a> {
 
                 Ok(result)
             }
+
+            Intrinsic::AsWitness => {
+                let arg = arguments[0];
+                let input = self.convert_value(arg, dfg).into_var()?;
+                Ok(self
+                    .acir_context
+                    .get_or_create_witness_var(input)
+                    .map(|val| self.convert_vars_to_values(vec![val], dfg, result_ids))?)
+            }
             _ => todo!("expected a black box function"),
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 7cc19e9f2b8..f136d3c5fb2 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -64,6 +64,7 @@ pub(crate) enum Intrinsic {
     BlackBox(BlackBoxFunc),
     FromField,
     AsField,
+    AsWitness,
 }
 
 impl std::fmt::Display for Intrinsic {
@@ -87,6 +88,7 @@ impl std::fmt::Display for Intrinsic {
             Intrinsic::BlackBox(function) => write!(f, "{function}"),
             Intrinsic::FromField => write!(f, "from_field"),
             Intrinsic::AsField => write!(f, "as_field"),
+            Intrinsic::AsWitness => write!(f, "as_witness"),
         }
     }
 }
@@ -97,7 +99,9 @@ impl Intrinsic {
     /// If there are no side effects then the `Intrinsic` can be removed if the result is unused.
     pub(crate) fn has_side_effects(&self) -> bool {
         match self {
-            Intrinsic::AssertConstant | Intrinsic::ApplyRangeConstraint => true,
+            Intrinsic::AssertConstant | Intrinsic::ApplyRangeConstraint | Intrinsic::AsWitness => {
+                true
+            }
 
             // These apply a constraint that the input must fit into a specified number of limbs.
             Intrinsic::ToBits(_) | Intrinsic::ToRadix(_) => true,
@@ -140,6 +144,7 @@ impl Intrinsic {
             "to_be_bits" => Some(Intrinsic::ToBits(Endian::Big)),
             "from_field" => Some(Intrinsic::FromField),
             "as_field" => Some(Intrinsic::AsField),
+            "as_witness" => Some(Intrinsic::AsWitness),
             other => BlackBoxFunc::lookup(other).map(Intrinsic::BlackBox),
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 7ad6a625f9c..8e320de9337 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -293,6 +293,7 @@ pub(super) fn simplify_call(
             let instruction = Instruction::Cast(truncated_value, target_type);
             SimplifyResult::SimplifiedToInstruction(instruction)
         }
+        Intrinsic::AsWitness => SimplifyResult::None,
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index ea37d857e58..9309652d508 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -157,7 +157,8 @@ impl Context {
                     | Intrinsic::BlackBox(_)
                     | Intrinsic::FromField
                     | Intrinsic::AsField
-                    | Intrinsic::AsSlice => false,
+                    | Intrinsic::AsSlice
+                    | Intrinsic::AsWitness => false,
                 },
 
                 // We must assume that functions contain a side effect as we cannot inspect more deeply.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
index fc915756110..3d2b5142219 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -231,6 +231,7 @@ fn slice_capacity_change(
         | Intrinsic::StrAsBytes
         | Intrinsic::BlackBox(_)
         | Intrinsic::FromField
-        | Intrinsic::AsField => SizeChange::None,
+        | Intrinsic::AsField
+        | Intrinsic::AsWitness => SizeChange::None,
     }
 }
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index 33504be0b9a..4e83fc59276 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -67,3 +67,6 @@ pub fn wrapping_sub<T>(x: T, y: T) -> T {
 pub fn wrapping_mul<T>(x: T, y: T) -> T {
     crate::from_field(crate::as_field(x) * crate::as_field(y))
 }
+
+#[builtin(as_witness)]
+pub fn as_witness(x: Field) {}
\ No newline at end of file

From 226724e3b54c2e0d9ba005661c76b40a87d9295a Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 21 May 2024 12:30:36 -0500
Subject: [PATCH 280/416] feat: Implement turbofish operator (#3542)

# Description

## Problem\*

Resolves #3413

## Summary\*

Adds the turbofish operator `::<>` to variables and method calls in
Noir.

## Additional Context

I'm publishing this as a draft because I'm shelving this work for now
after implementing the majority of it.

The work that remains to be done is handling the special case of method
calls on generic impls. A generic impl will implicitly add the impl
generics to each method - which means the generic count on a method
itself as seen by the turbofish operator will not match the actual
generics on the function internally. We'll likely need to separate out
these implicit generics internally. Such that `expected_generic_count =
function_generics - impl_generics`. I've added this as a test case to
the `generics` test to ensure it works when this is merged.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[Exceptional Case]** Documentation to be submitted in a separate
PR.
- [x] No documentation is in this PR yet since it is still a draft.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 aztec_macros/src/transforms/functions.rs      |  2 +-
 aztec_macros/src/utils/ast_utils.rs           |  7 +-
 compiler/noirc_frontend/src/ast/expression.rs | 34 ++++++---
 compiler/noirc_frontend/src/ast/mod.rs        |  6 +-
 compiler/noirc_frontend/src/ast/statement.rs  | 30 ++++----
 compiler/noirc_frontend/src/debug/mod.rs      | 74 +++++++++++--------
 .../src/elaborator/expressions.rs             | 15 +++-
 .../noirc_frontend/src/elaborator/patterns.rs |  8 +-
 .../noirc_frontend/src/elaborator/types.rs    |  6 +-
 .../src/hir/comptime/hir_to_ast.rs            | 10 ++-
 .../src/hir/comptime/interpreter.rs           |  2 +-
 .../noirc_frontend/src/hir/comptime/scan.rs   |  2 +-
 .../noirc_frontend/src/hir/comptime/value.rs  |  2 +-
 .../src/hir/def_collector/dc_mod.rs           |  1 +
 .../src/hir/resolution/resolver.rs            | 36 ++++++---
 .../src/hir/type_check/errors.rs              | 10 +++
 .../noirc_frontend/src/hir/type_check/expr.rs | 56 ++++++++++++--
 .../noirc_frontend/src/hir/type_check/mod.rs  |  5 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |  8 +-
 compiler/noirc_frontend/src/hir_def/types.rs  | 39 +++++++++-
 .../src/monomorphization/mod.rs               |  4 +-
 compiler/noirc_frontend/src/node_interner.rs  |  4 +
 compiler/noirc_frontend/src/parser/parser.rs  | 56 ++++++++------
 .../src/parser/parser/primitives.rs           | 15 +++-
 .../noirc_frontend/src/resolve_locations.rs   |  2 +-
 compiler/noirc_frontend/src/tests.rs          | 65 ++++++++++++++++
 cspell.json                                   |  1 +
 .../turbofish_generic_count/Nargo.toml        |  7 ++
 .../turbofish_generic_count/src/main.nr       | 22 ++++++
 .../execution_success/generics/src/main.nr    | 15 ++++
 tooling/nargo_fmt/src/rewrite/expr.rs         | 35 ++++++++-
 .../tests/expected/turbofish_call.nr          |  8 ++
 .../tests/expected/turbofish_method_call.nr   | 12 +++
 .../nargo_fmt/tests/input/turbofish_call.nr   |  7 ++
 .../tests/input/turbofish_method_call.nr      |  5 ++
 35 files changed, 486 insertions(+), 125 deletions(-)
 create mode 100644 test_programs/compile_failure/turbofish_generic_count/Nargo.toml
 create mode 100644 test_programs/compile_failure/turbofish_generic_count/src/main.nr
 create mode 100644 tooling/nargo_fmt/tests/expected/turbofish_call.nr
 create mode 100644 tooling/nargo_fmt/tests/expected/turbofish_method_call.nr
 create mode 100644 tooling/nargo_fmt/tests/input/turbofish_call.nr
 create mode 100644 tooling/nargo_fmt/tests/input/turbofish_method_call.nr

diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 90563c6085c..39d709ef520 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -680,7 +680,7 @@ fn add_struct_to_hasher(identifier: &Ident, hasher_name: &str) -> Statement {
 fn str_to_bytes(identifier: &Ident) -> (Statement, Ident) {
     // let identifier_as_bytes = identifier.as_bytes();
     let var = variable_ident(identifier.clone());
-    let contents = if let ExpressionKind::Variable(p) = &var.kind {
+    let contents = if let ExpressionKind::Variable(p, _) = &var.kind {
         p.segments.first().cloned().unwrap_or_else(|| panic!("No segments")).0.contents
     } else {
         panic!("Unexpected identifier type")
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index ebb4854f86e..ba51090c2be 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -27,15 +27,15 @@ pub fn expression(kind: ExpressionKind) -> Expression {
 }
 
 pub fn variable(name: &str) -> Expression {
-    expression(ExpressionKind::Variable(ident_path(name)))
+    expression(ExpressionKind::Variable(ident_path(name), None))
 }
 
 pub fn variable_ident(identifier: Ident) -> Expression {
-    expression(ExpressionKind::Variable(path(identifier)))
+    expression(ExpressionKind::Variable(path(identifier), None))
 }
 
 pub fn variable_path(path: Path) -> Expression {
-    expression(ExpressionKind::Variable(path))
+    expression(ExpressionKind::Variable(path, None))
 }
 
 pub fn method_call(
@@ -47,6 +47,7 @@ pub fn method_call(
         object,
         method_name: ident(method_name),
         arguments,
+        generics: None,
     })))
 }
 
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 59c04218e2e..0173b17d28f 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -10,6 +10,8 @@ use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
 
+use super::UnaryRhsMemberAccess;
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ExpressionKind {
     Literal(Literal),
@@ -23,7 +25,9 @@ pub enum ExpressionKind {
     Cast(Box<CastExpression>),
     Infix(Box<InfixExpression>),
     If(Box<IfExpression>),
-    Variable(Path),
+    // The optional vec here is the optional list of generics
+    // provided by the turbofish operator, if used
+    Variable(Path, Option<Vec<UnresolvedType>>),
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
@@ -39,7 +43,7 @@ pub type UnresolvedGenerics = Vec<Ident>;
 impl ExpressionKind {
     pub fn into_path(self) -> Option<Path> {
         match self {
-            ExpressionKind::Variable(path) => Some(path),
+            ExpressionKind::Variable(path, _) => Some(path),
             _ => None,
         }
     }
@@ -164,16 +168,19 @@ impl Expression {
 
     pub fn member_access_or_method_call(
         lhs: Expression,
-        (rhs, args): (Ident, Option<Vec<Expression>>),
+        (rhs, args): UnaryRhsMemberAccess,
         span: Span,
     ) -> Expression {
         let kind = match args {
             None => ExpressionKind::MemberAccess(Box::new(MemberAccessExpression { lhs, rhs })),
-            Some(arguments) => ExpressionKind::MethodCall(Box::new(MethodCallExpression {
-                object: lhs,
-                method_name: rhs,
-                arguments,
-            })),
+            Some((generics, arguments)) => {
+                ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+                    object: lhs,
+                    method_name: rhs,
+                    generics,
+                    arguments,
+                }))
+            }
         };
         Expression::new(kind, span)
     }
@@ -435,6 +442,8 @@ pub struct CallExpression {
 pub struct MethodCallExpression {
     pub object: Expression,
     pub method_name: Ident,
+    /// Method calls have an optional list of generics if the turbofish operator was used
+    pub generics: Option<Vec<UnresolvedType>>,
     pub arguments: Vec<Expression>,
 }
 
@@ -494,7 +503,14 @@ impl Display for ExpressionKind {
             Cast(cast) => cast.fmt(f),
             Infix(infix) => infix.fmt(f),
             If(if_expr) => if_expr.fmt(f),
-            Variable(path) => path.fmt(f),
+            Variable(path, generics) => {
+                if let Some(generics) = generics {
+                    let generics = vecmap(generics, ToString::to_string);
+                    write!(f, "{path}::<{}>", generics.join(", "))
+                } else {
+                    path.fmt(f)
+                }
+            }
             Constructor(constructor) => constructor.fmt(f),
             MemberAccess(access) => access.fmt(f),
             Tuple(elements) => {
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 1c5a5c610aa..c3556dac6af 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -132,6 +132,10 @@ pub struct UnresolvedType {
     pub span: Option<Span>,
 }
 
+/// Type wrapper for a member access
+pub(crate) type UnaryRhsMemberAccess =
+    (Ident, Option<(Option<Vec<UnresolvedType>>, Vec<Expression>)>);
+
 /// The precursor to TypeExpression, this is the type that the parser allows
 /// to be used in the length position of an array type. Only constants, variables,
 /// and numeric binary operators are allowed here.
@@ -310,7 +314,7 @@ impl UnresolvedTypeExpression {
                     None => Err(expr),
                 }
             }
-            ExpressionKind::Variable(path) => Ok(UnresolvedTypeExpression::Variable(path)),
+            ExpressionKind::Variable(path, _) => Ok(UnresolvedTypeExpression::Variable(path)),
             ExpressionKind::Prefix(prefix) if prefix.operator == UnaryOp::Minus => {
                 let lhs = Box::new(UnresolvedTypeExpression::Constant(0, expr.span));
                 let rhs = Box::new(UnresolvedTypeExpression::from_expr_helper(prefix.rhs)?);
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 94b5841e52c..863615da53d 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -228,11 +228,10 @@ impl From<Ident> for Expression {
     fn from(i: Ident) -> Expression {
         Expression {
             span: i.0.span(),
-            kind: ExpressionKind::Variable(Path {
-                span: i.span(),
-                segments: vec![i],
-                kind: PathKind::Plain,
-            }),
+            kind: ExpressionKind::Variable(
+                Path { span: i.span(), segments: vec![i], kind: PathKind::Plain },
+                None,
+            ),
         }
     }
 }
@@ -509,7 +508,7 @@ impl Recoverable for Pattern {
 impl LValue {
     fn as_expression(&self) -> Expression {
         let kind = match self {
-            LValue::Ident(ident) => ExpressionKind::Variable(Path::from_ident(ident.clone())),
+            LValue::Ident(ident) => ExpressionKind::Variable(Path::from_ident(ident.clone()), None),
             LValue::MemberAccess { object, field_name, span: _ } => {
                 ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
                     lhs: object.as_expression(),
@@ -599,15 +598,15 @@ impl ForRange {
 
                 // array.len()
                 let segments = vec![array_ident];
-                let array_ident = ExpressionKind::Variable(Path {
-                    segments,
-                    kind: PathKind::Plain,
-                    span: array_span,
-                });
+                let array_ident = ExpressionKind::Variable(
+                    Path { segments, kind: PathKind::Plain, span: array_span },
+                    None,
+                );
 
                 let end_range = ExpressionKind::MethodCall(Box::new(MethodCallExpression {
                     object: Expression::new(array_ident.clone(), array_span),
                     method_name: Ident::new("len".to_string(), array_span),
+                    generics: None,
                     arguments: vec![],
                 }));
                 let end_range = Expression::new(end_range, array_span);
@@ -618,11 +617,10 @@ impl ForRange {
 
                 // array[i]
                 let segments = vec![Ident::new(index_name, array_span)];
-                let index_ident = ExpressionKind::Variable(Path {
-                    segments,
-                    kind: PathKind::Plain,
-                    span: array_span,
-                });
+                let index_ident = ExpressionKind::Variable(
+                    Path { segments, kind: PathKind::Plain, span: array_span },
+                    None,
+                );
 
                 let loop_element = ExpressionKind::Index(Box::new(IndexExpression {
                     collection: Expression::new(array_ident, array_span),
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 3e7d123398b..c222e08e77a 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -171,11 +171,14 @@ impl DebugInstrumenter {
         let last_stmt = if has_ret_expr {
             ast::Statement {
                 kind: ast::StatementKind::Expression(ast::Expression {
-                    kind: ast::ExpressionKind::Variable(ast::Path {
-                        segments: vec![ident("__debug_expr", span)],
-                        kind: PathKind::Plain,
-                        span,
-                    }),
+                    kind: ast::ExpressionKind::Variable(
+                        ast::Path {
+                            segments: vec![ident("__debug_expr", span)],
+                            kind: PathKind::Plain,
+                            span,
+                        },
+                        None,
+                    ),
                     span,
                 }),
                 span,
@@ -568,11 +571,14 @@ fn build_assign_var_stmt(var_id: SourceVarId, expr: ast::Expression) -> ast::Sta
     let span = expr.span;
     let kind = ast::ExpressionKind::Call(Box::new(ast::CallExpression {
         func: Box::new(ast::Expression {
-            kind: ast::ExpressionKind::Variable(ast::Path {
-                segments: vec![ident("__debug_var_assign", span)],
-                kind: PathKind::Plain,
-                span,
-            }),
+            kind: ast::ExpressionKind::Variable(
+                ast::Path {
+                    segments: vec![ident("__debug_var_assign", span)],
+                    kind: PathKind::Plain,
+                    span,
+                },
+                None,
+            ),
             span,
         }),
         arguments: vec![uint_expr(var_id.0 as u128, span), expr],
@@ -583,11 +589,14 @@ fn build_assign_var_stmt(var_id: SourceVarId, expr: ast::Expression) -> ast::Sta
 fn build_drop_var_stmt(var_id: SourceVarId, span: Span) -> ast::Statement {
     let kind = ast::ExpressionKind::Call(Box::new(ast::CallExpression {
         func: Box::new(ast::Expression {
-            kind: ast::ExpressionKind::Variable(ast::Path {
-                segments: vec![ident("__debug_var_drop", span)],
-                kind: PathKind::Plain,
-                span,
-            }),
+            kind: ast::ExpressionKind::Variable(
+                ast::Path {
+                    segments: vec![ident("__debug_var_drop", span)],
+                    kind: PathKind::Plain,
+                    span,
+                },
+                None,
+            ),
             span,
         }),
         arguments: vec![uint_expr(var_id.0 as u128, span)],
@@ -607,11 +616,14 @@ fn build_assign_member_stmt(
     let span = expr.span;
     let kind = ast::ExpressionKind::Call(Box::new(ast::CallExpression {
         func: Box::new(ast::Expression {
-            kind: ast::ExpressionKind::Variable(ast::Path {
-                segments: vec![ident(&format!["__debug_member_assign_{arity}"], span)],
-                kind: PathKind::Plain,
-                span,
-            }),
+            kind: ast::ExpressionKind::Variable(
+                ast::Path {
+                    segments: vec![ident(&format!["__debug_member_assign_{arity}"], span)],
+                    kind: PathKind::Plain,
+                    span,
+                },
+                None,
+            ),
             span,
         }),
         arguments: [
@@ -627,11 +639,14 @@ fn build_assign_member_stmt(
 fn build_debug_call_stmt(fname: &str, fn_id: DebugFnId, span: Span) -> ast::Statement {
     let kind = ast::ExpressionKind::Call(Box::new(ast::CallExpression {
         func: Box::new(ast::Expression {
-            kind: ast::ExpressionKind::Variable(ast::Path {
-                segments: vec![ident(&format!["__debug_fn_{fname}"], span)],
-                kind: PathKind::Plain,
-                span,
-            }),
+            kind: ast::ExpressionKind::Variable(
+                ast::Path {
+                    segments: vec![ident(&format!["__debug_fn_{fname}"], span)],
+                    kind: PathKind::Plain,
+                    span,
+                },
+                None,
+            ),
             span,
         }),
         arguments: vec![uint_expr(fn_id.0 as u128, span)],
@@ -693,11 +708,10 @@ fn ident(s: &str, span: Span) -> ast::Ident {
 
 fn id_expr(id: &ast::Ident) -> ast::Expression {
     ast::Expression {
-        kind: ast::ExpressionKind::Variable(Path {
-            segments: vec![id.clone()],
-            kind: PathKind::Plain,
-            span: id.span(),
-        }),
+        kind: ast::ExpressionKind::Variable(
+            Path { segments: vec![id.clone()], kind: PathKind::Plain, span: id.span() },
+            None,
+        ),
         span: id.span(),
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index ed8ed5305d1..75c95c06d09 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -48,7 +48,12 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Cast(cast) => self.elaborate_cast(*cast, expr.span),
             ExpressionKind::Infix(infix) => return self.elaborate_infix(*infix, expr.span),
             ExpressionKind::If(if_) => self.elaborate_if(*if_),
-            ExpressionKind::Variable(variable) => return self.elaborate_variable(variable),
+            ExpressionKind::Variable(variable, generics) => {
+                let generics = generics.map(|option_inner| {
+                    option_inner.into_iter().map(|generic| self.resolve_type(generic)).collect()
+                });
+                return self.elaborate_variable(variable, generics);
+            }
             ExpressionKind::Tuple(tuple) => self.elaborate_tuple(tuple),
             ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
             ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
@@ -185,7 +190,7 @@ impl<'context> Elaborator<'context> {
             let variable = scope_tree.find(ident_name);
             if let Some((old_value, _)) = variable {
                 old_value.num_times_used += 1;
-                let ident = HirExpression::Ident(old_value.ident.clone());
+                let ident = HirExpression::Ident(old_value.ident.clone(), None);
                 let expr_id = self.interner.push_expr(ident);
                 self.interner.push_expr_location(expr_id, call_expr_span, self.file);
                 let ident = old_value.ident.clone();
@@ -314,7 +319,11 @@ impl<'context> Elaborator<'context> {
 
                 let location = Location::new(span, self.file);
                 let method = method_call.method_name;
-                let method_call = HirMethodCallExpression { method, object, arguments, location };
+                let generics = method_call.generics.map(|option_inner| {
+                    option_inner.into_iter().map(|generic| self.resolve_type(generic)).collect()
+                });
+                let method_call =
+                    HirMethodCallExpression { method, object, arguments, location, generics };
 
                 // Desugar the method call into a normal, resolved function call
                 // so that the backend doesn't need to worry about methods
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 195d37878f1..810e1b90743 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -323,10 +323,14 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub(super) fn elaborate_variable(&mut self, variable: Path) -> (ExprId, Type) {
+    pub(super) fn elaborate_variable(
+        &mut self,
+        variable: Path,
+        generics: Option<Vec<Type>>,
+    ) -> (ExprId, Type) {
         let span = variable.span;
         let expr = self.resolve_variable(variable);
-        let id = self.interner.push_expr(HirExpression::Ident(expr.clone()));
+        let id = self.interner.push_expr(HirExpression::Ident(expr.clone(), generics));
         self.interner.push_expr_location(id, span, self.file);
         let typ = self.type_check_variable(expr, id);
         self.interner.push_expr_type(id, typ.clone());
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 4c8364b6dda..54920d5738b 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -494,7 +494,7 @@ impl<'context> Elaborator<'context> {
             HirExpression::Literal(HirLiteral::Integer(int, false)) => {
                 int.try_into_u128().ok_or(Some(ResolverError::IntegerTooLarge { span }))
             }
-            HirExpression::Ident(ident) => {
+            HirExpression::Ident(ident, _) => {
                 let definition = self.interner.definition(ident.id);
                 match definition.kind {
                     DefinitionKind::Global(global_id) => {
@@ -1249,7 +1249,7 @@ impl<'context> Elaborator<'context> {
     }
 
     fn check_if_deprecated(&mut self, expr: ExprId) {
-        if let HirExpression::Ident(HirIdent { location, id, impl_kind: _ }) =
+        if let HirExpression::Ident(HirIdent { location, id, impl_kind: _ }, _) =
             self.interner.expression(&expr)
         {
             if let Some(DefinitionKind::Function(func_id)) =
@@ -1268,7 +1268,7 @@ impl<'context> Elaborator<'context> {
     }
 
     fn is_unconstrained_call(&self, expr: ExprId) -> bool {
-        if let HirExpression::Ident(HirIdent { id, .. }) = self.interner.expression(&expr) {
+        if let HirExpression::Ident(HirIdent { id, .. }, _) = self.interner.expression(&expr) {
             if let Some(DefinitionKind::Function(func_id)) =
                 self.interner.try_definition(id).map(|def| &def.kind)
             {
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
index 1ab9c13ea25..e0fdd91adb4 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
@@ -82,9 +82,12 @@ impl ExprId {
         let span = interner.expr_span(&self);
 
         let kind = match expression {
-            HirExpression::Ident(ident) => {
+            HirExpression::Ident(ident, generics) => {
                 let path = Path::from_ident(ident.to_ast(interner));
-                ExpressionKind::Variable(path)
+                ExpressionKind::Variable(
+                    path,
+                    generics.map(|option| option.iter().map(|generic| generic.to_ast()).collect()),
+                )
             }
             HirExpression::Literal(HirLiteral::Array(array)) => {
                 let array = array.into_ast(interner, span);
@@ -146,6 +149,9 @@ impl ExprId {
                     object: method_call.object.to_ast(interner),
                     method_name: method_call.method,
                     arguments: vecmap(method_call.arguments, |arg| arg.to_ast(interner)),
+                    generics: method_call
+                        .generics
+                        .map(|option| option.iter().map(|generic| generic.to_ast()).collect()),
                 }))
             }
             HirExpression::Cast(cast) => {
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 84df3a0a244..5984e454f7a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -296,7 +296,7 @@ impl<'a> Interpreter<'a> {
     /// Evaluate an expression and return the result
     pub(super) fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
         match self.interner.expression(&id) {
-            HirExpression::Ident(ident) => self.evaluate_ident(ident, id),
+            HirExpression::Ident(ident, _) => self.evaluate_ident(ident, id),
             HirExpression::Literal(literal) => self.evaluate_literal(literal, id),
             HirExpression::Block(block) => self.evaluate_block(block),
             HirExpression::Prefix(prefix) => self.evaluate_prefix(prefix, id),
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index 7101a158ddb..cc6b9aa7e9c 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -65,7 +65,7 @@ impl<'interner> Interpreter<'interner> {
 
     fn scan_expression(&mut self, expr: ExprId) -> IResult<()> {
         match self.interner.expression(&expr) {
-            HirExpression::Ident(ident) => self.scan_ident(ident, expr),
+            HirExpression::Ident(ident, _) => self.scan_ident(ident, expr),
             HirExpression::Literal(literal) => self.scan_literal(literal),
             HirExpression::Block(block) => self.scan_block(block),
             HirExpression::Prefix(prefix) => self.scan_expression(prefix.rhs),
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 4e4a260871a..3c8b6e92445 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -125,7 +125,7 @@ impl Value {
             Value::Function(id, _typ) => {
                 let id = interner.function_definition_id(id);
                 let impl_kind = ImplKind::NotATraitMethod;
-                HirExpression::Ident(HirIdent { location, id, impl_kind })
+                HirExpression::Ident(HirIdent { location, id, impl_kind }, None)
             }
             Value::Closure(_lambda, _env, _typ) => {
                 // TODO: How should a closure's environment be inlined?
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index e688f192d3d..3d0ffdb0155 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -420,6 +420,7 @@ impl<'a> ModCollector<'a> {
                             // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629
                             attributes: crate::token::Attributes::empty(),
                             is_unconstrained: false,
+                            generic_count: generics.len(),
                             is_comptime: false,
                         };
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 7dc307fe716..1f006697359 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1475,14 +1475,20 @@ impl<'a> Resolver<'a> {
                 Literal::FmtStr(str) => self.resolve_fmt_str_literal(str, expr.span),
                 Literal::Unit => HirLiteral::Unit,
             }),
-            ExpressionKind::Variable(path) => {
+            ExpressionKind::Variable(path, generics) => {
+                let generics =
+                    generics.map(|generics| vecmap(generics, |typ| self.resolve_type(typ)));
+
                 if let Some((method, constraint, assumed)) = self.resolve_trait_generic_path(&path)
                 {
-                    HirExpression::Ident(HirIdent {
-                        location: Location::new(expr.span, self.file),
-                        id: self.interner.trait_method_id(method),
-                        impl_kind: ImplKind::TraitMethod(method, constraint, assumed),
-                    })
+                    HirExpression::Ident(
+                        HirIdent {
+                            location: Location::new(expr.span, self.file),
+                            id: self.interner.trait_method_id(method),
+                            impl_kind: ImplKind::TraitMethod(method, constraint, assumed),
+                        },
+                        generics,
+                    )
                 } else {
                     // If the Path is being used as an Expression, then it is referring to a global from a separate module
                     // Otherwise, then it is referring to an Identifier
@@ -1519,7 +1525,7 @@ impl<'a> Resolver<'a> {
                         }
                     }
 
-                    HirExpression::Ident(hir_ident)
+                    HirExpression::Ident(hir_ident, generics)
                 }
             }
             ExpressionKind::Prefix(prefix) => {
@@ -1557,12 +1563,20 @@ impl<'a> Resolver<'a> {
             ExpressionKind::MethodCall(call_expr) => {
                 let method = call_expr.method_name;
                 let object = self.resolve_expression(call_expr.object);
+
+                // Cannot verify the generic count here equals the expected count since we don't
+                // know which definition `method` refers to until it is resolved during type checking.
+                let generics = call_expr
+                    .generics
+                    .map(|generics| vecmap(generics, |typ| self.resolve_type(typ)));
+
                 let arguments = vecmap(call_expr.arguments, |arg| self.resolve_expression(arg));
                 let location = Location::new(expr.span, self.file);
                 HirExpression::MethodCall(HirMethodCallExpression {
-                    arguments,
                     method,
                     object,
+                    generics,
+                    arguments,
                     location,
                 })
             }
@@ -2038,7 +2052,7 @@ impl<'a> Resolver<'a> {
             HirExpression::Literal(HirLiteral::Integer(int, false)) => {
                 int.try_into_u128().ok_or(Some(ResolverError::IntegerTooLarge { span }))
             }
-            HirExpression::Ident(ident) => {
+            HirExpression::Ident(ident, _) => {
                 let definition = self.interner.definition(ident.id);
                 match definition.kind {
                     DefinitionKind::Global(global_id) => {
@@ -2092,7 +2106,7 @@ impl<'a> Resolver<'a> {
             let variable = scope_tree.find(ident_name);
             if let Some((old_value, _)) = variable {
                 old_value.num_times_used += 1;
-                let ident = HirExpression::Ident(old_value.ident.clone());
+                let ident = HirExpression::Ident(old_value.ident.clone(), None);
                 let expr_id = self.interner.push_expr(ident);
                 self.interner.push_expr_location(expr_id, call_expr_span, self.file);
                 fmt_str_idents.push(expr_id);
@@ -2132,7 +2146,7 @@ pub fn verify_mutable_reference(interner: &NodeInterner, rhs: ExprId) -> Result<
             let span = interner.expr_span(&rhs);
             Err(ResolverError::MutableReferenceToArrayElement { span })
         }
-        HirExpression::Ident(ident) => {
+        HirExpression::Ident(ident, _) => {
             if let Some(definition) = interner.try_definition(ident.id) {
                 if !definition.mutable {
                     return Err(ResolverError::MutableReferenceToImmutableVariable {
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index b81727a27f5..549d8138f1d 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -115,6 +115,10 @@ pub enum TypeCheckError {
     NoMatchingImplFound { constraints: Vec<(Type, String)>, span: Span },
     #[error("Constraint for `{typ}: {trait_name}` is not needed, another matching impl is already in scope")]
     UnneededTraitConstraint { trait_name: String, typ: Type, span: Span },
+    #[error(
+        "Expected {expected_count} generic(s) from this function, but {actual_count} were provided"
+    )]
+    IncorrectTurbofishGenericCount { expected_count: usize, actual_count: usize, span: Span },
     #[error(
         "Cannot pass a mutable reference from a constrained runtime to an unconstrained runtime"
     )]
@@ -325,6 +329,12 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                     "`{trait_name}::{method_name}` expects {expected_num_parameters} parameter{plural}, but this method has {actual_num_parameters}");
                 Diagnostic::simple_error(primary_message, "".to_string(), *span)
             }
+            TypeCheckError::IncorrectTurbofishGenericCount { expected_count, actual_count, span } => {
+                let expected_plural = if *expected_count == 1 { "" } else { "s" };
+                let actual_plural = if *actual_count == 1 { "was" } else { "were" };
+                let msg = format!("Expected {expected_count} generic{expected_plural} from this function, but {actual_count} {actual_plural} provided");
+                Diagnostic::simple_error(msg, "".into(), *span)
+            },
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 48598109829..c4f80591bf8 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -20,7 +20,7 @@ use super::{errors::TypeCheckError, TypeChecker};
 
 impl<'interner> TypeChecker<'interner> {
     fn check_if_deprecated(&mut self, expr: &ExprId) {
-        if let HirExpression::Ident(expr::HirIdent { location, id, impl_kind: _ }) =
+        if let HirExpression::Ident(expr::HirIdent { location, id, impl_kind: _ }, _) =
             self.interner.expression(expr)
         {
             if let Some(DefinitionKind::Function(func_id)) =
@@ -39,7 +39,7 @@ impl<'interner> TypeChecker<'interner> {
     }
 
     fn is_unconstrained_call(&self, expr: &ExprId) -> bool {
-        if let HirExpression::Ident(expr::HirIdent { id, .. }) = self.interner.expression(expr) {
+        if let HirExpression::Ident(expr::HirIdent { id, .. }, _) = self.interner.expression(expr) {
             if let Some(DefinitionKind::Function(func_id)) =
                 self.interner.try_definition(id).map(|def| &def.kind)
             {
@@ -103,7 +103,7 @@ impl<'interner> TypeChecker<'interner> {
     /// function `foo` to refer to.
     pub(crate) fn check_expression(&mut self, expr_id: &ExprId) -> Type {
         let typ = match self.interner.expression(expr_id) {
-            HirExpression::Ident(ident) => self.check_ident(ident, expr_id),
+            HirExpression::Ident(ident, generics) => self.check_ident(ident, expr_id, generics),
             HirExpression::Literal(literal) => match literal {
                 HirLiteral::Array(hir_array_literal) => {
                     let (length, elem_type) = self.check_hir_array_literal(hir_array_literal);
@@ -349,7 +349,12 @@ impl<'interner> TypeChecker<'interner> {
     }
 
     /// Returns the type of the given identifier
-    fn check_ident(&mut self, ident: HirIdent, expr_id: &ExprId) -> Type {
+    fn check_ident(
+        &mut self,
+        ident: HirIdent,
+        expr_id: &ExprId,
+        generics: Option<Vec<Type>>,
+    ) -> Type {
         let mut bindings = TypeBindings::new();
 
         // Add type bindings from any constraints that were used.
@@ -374,10 +379,20 @@ impl<'interner> TypeChecker<'interner> {
         // variable to handle generic functions.
         let t = self.interner.id_type_substitute_trait_as_type(ident.id);
 
+        let span = self.interner.expr_span(expr_id);
+
+        let definition = self.interner.try_definition(ident.id);
+        let function_generic_count = definition.map_or(0, |definition| match &definition.kind {
+            DefinitionKind::Function(function) => {
+                self.interner.function_modifiers(function).generic_count
+            }
+            _ => 0,
+        });
+
         // This instantiates a trait's generics as well which need to be set
         // when the constraint below is later solved for when the function is
         // finished. How to link the two?
-        let (typ, bindings) = t.instantiate_with_bindings(bindings, self.interner);
+        let (typ, bindings) = self.instantiate(t, bindings, generics, function_generic_count, span);
 
         // Push any trait constraints required by this definition to the context
         // to be checked later when the type of this variable is further constrained.
@@ -412,6 +427,37 @@ impl<'interner> TypeChecker<'interner> {
         typ
     }
 
+    fn instantiate(
+        &mut self,
+        typ: Type,
+        bindings: TypeBindings,
+        turbofish_generics: Option<Vec<Type>>,
+        function_generic_count: usize,
+        span: Span,
+    ) -> (Type, TypeBindings) {
+        match turbofish_generics {
+            Some(turbofish_generics) => {
+                if turbofish_generics.len() != function_generic_count {
+                    self.errors.push(TypeCheckError::IncorrectTurbofishGenericCount {
+                        expected_count: function_generic_count,
+                        actual_count: turbofish_generics.len(),
+                        span,
+                    });
+                    typ.instantiate_with_bindings(bindings, self.interner)
+                } else {
+                    // Fetch the count of any implicit generics on the function, such as
+                    // for a method within a generic impl.
+                    let implicit_generic_count = match &typ {
+                        Type::Forall(generics, _) => generics.len() - function_generic_count,
+                        _ => 0,
+                    };
+                    typ.instantiate_with(turbofish_generics, self.interner, implicit_generic_count)
+                }
+            }
+            None => typ.instantiate_with_bindings(bindings, self.interner),
+        }
+    }
+
     pub fn verify_trait_constraint(
         &mut self,
         object_type: &Type,
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 2e448858d9e..9335b8297fe 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -89,7 +89,6 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     }
 
     let function_last_type = type_checker.check_function_body(function_body_id);
-
     // Check declared return type and actual return type
     if !can_ignore_ret {
         let (expr_span, empty_function) = function_info(type_checker.interner, function_body_id);
@@ -486,8 +485,8 @@ pub mod test {
         let z = HirIdent::non_trait_method(z_id, location);
 
         // Push x and y as expressions
-        let x_expr_id = interner.push_expr(HirExpression::Ident(x.clone()));
-        let y_expr_id = interner.push_expr(HirExpression::Ident(y.clone()));
+        let x_expr_id = interner.push_expr(HirExpression::Ident(x.clone(), None));
+        let y_expr_id = interner.push_expr(HirExpression::Ident(y.clone(), None));
 
         // Create Infix
         let operator = HirBinaryOp { location, kind: BinaryOpKind::Add };
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index 8df6785e0eb..163ea10ee02 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -17,7 +17,9 @@ use super::types::{StructType, Type};
 /// from the definition that refers to them so there is no ambiguity with names.
 #[derive(Debug, Clone)]
 pub enum HirExpression {
-    Ident(HirIdent),
+    // The optional vec here is the optional list of generics
+    // provided by the turbofish operator, if it was used
+    Ident(HirIdent, Option<Vec<Type>>),
     Literal(HirLiteral),
     Block(HirBlockExpression),
     Prefix(HirPrefixExpression),
@@ -181,6 +183,8 @@ pub struct HirCallExpression {
 pub struct HirMethodCallExpression {
     pub method: Ident,
     pub object: ExprId,
+    /// Method calls have an optional list of generics provided by the turbofish operator
+    pub generics: Option<Vec<Type>>,
     pub arguments: Vec<ExprId>,
     pub location: Location,
 }
@@ -227,7 +231,7 @@ impl HirMethodCallExpression {
             }
         };
         let func_var = HirIdent { location, id, impl_kind };
-        let func = interner.push_expr(HirExpression::Ident(func_var.clone()));
+        let func = interner.push_expr(HirExpression::Ident(func_var.clone(), self.generics));
         interner.push_expr_location(func, location.span, location.file);
         let expr = HirCallExpression { func, arguments, location };
         ((func, func_var), expr)
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index f31aeea0552..cf9aafbb308 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -1478,6 +1478,43 @@ impl Type {
         }
     }
 
+    /// Instantiates a type with the given types.
+    /// This differs from substitute in that only the quantified type variables
+    /// are matched against the type list and are eligible for substitution - similar
+    /// to normal instantiation. This function is used when the turbofish operator
+    /// is used and generic substitutions are provided manually by users.
+    ///
+    /// Expects the given type vector to be the same length as the Forall type variables.
+    pub fn instantiate_with(
+        &self,
+        types: Vec<Type>,
+        interner: &NodeInterner,
+        implicit_generic_count: usize,
+    ) -> (Type, TypeBindings) {
+        match self {
+            Type::Forall(typevars, typ) => {
+                assert_eq!(types.len() + implicit_generic_count, typevars.len(), "Turbofish operator used with incorrect generic count which was not caught by name resolution");
+
+                let replacements = typevars
+                    .iter()
+                    .enumerate()
+                    .map(|(i, var)| {
+                        let binding = if i < implicit_generic_count {
+                            interner.next_type_variable()
+                        } else {
+                            types[i - implicit_generic_count].clone()
+                        };
+                        (var.id(), (var.clone(), binding))
+                    })
+                    .collect();
+
+                let instantiated = typ.substitute(&replacements);
+                (instantiated, replacements)
+            }
+            other => (other.clone(), HashMap::new()),
+        }
+    }
+
     /// Substitute any type variables found within this type with the
     /// given bindings if found. If a type variable is not found within
     /// the given TypeBindings, it is unchanged.
@@ -1727,7 +1764,7 @@ fn convert_array_expression_to_slice(
 
     let as_slice_id = interner.function_definition_id(as_slice_method);
     let location = interner.expr_location(&expression);
-    let as_slice = HirExpression::Ident(HirIdent::non_trait_method(as_slice_id, location));
+    let as_slice = HirExpression::Ident(HirIdent::non_trait_method(as_slice_id, location), None);
     let func = interner.push_expr(as_slice);
 
     // Copy the expression and give it a new ExprId. The old one
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index f918610af2c..9a20d0dd537 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -393,7 +393,7 @@ impl<'interner> Monomorphizer<'interner> {
         use ast::Literal::*;
 
         let expr = match self.interner.expression(&expr) {
-            HirExpression::Ident(ident) => self.ident(ident, expr)?,
+            HirExpression::Ident(ident, _) => self.ident(ident, expr)?,
             HirExpression::Literal(HirLiteral::Str(contents)) => Literal(Str(contents)),
             HirExpression::Literal(HirLiteral::FmtStr(contents, idents)) => {
                 let fields = try_vecmap(idents, |ident| self.expr(ident))?;
@@ -1172,7 +1172,7 @@ impl<'interner> Monomorphizer<'interner> {
         arguments: &mut Vec<ast::Expression>,
     ) {
         match hir_argument {
-            HirExpression::Ident(ident) => {
+            HirExpression::Ident(ident, _) => {
                 let typ = self.interner.definition_type(ident.id);
                 let typ: Type = typ.follow_bindings();
                 let is_fmt_str = match typ {
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index faf89016f96..7f1b67abfbd 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -244,6 +244,8 @@ pub struct FunctionModifiers {
 
     pub is_unconstrained: bool,
 
+    pub generic_count: usize,
+
     pub is_comptime: bool,
 }
 
@@ -257,6 +259,7 @@ impl FunctionModifiers {
             visibility: ItemVisibility::Public,
             attributes: Attributes::empty(),
             is_unconstrained: false,
+            generic_count: 0,
             is_comptime: false,
         }
     }
@@ -775,6 +778,7 @@ impl NodeInterner {
             visibility: function.visibility,
             attributes: function.attributes.clone(),
             is_unconstrained: function.is_unconstrained,
+            generic_count: function.generics.len(),
             is_comptime: function.is_comptime,
         };
         self.push_function_definition(id, modifiers, module, location)
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index b527284d1a9..890ab795e00 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -35,7 +35,7 @@ use super::{spanned, Item, ItemKind};
 use crate::ast::{
     BinaryOp, BinaryOpKind, BlockExpression, ForLoopStatement, ForRange, Ident, IfExpression,
     InfixExpression, LValue, Literal, ModuleDeclaration, NoirTypeAlias, Param, Path, Pattern,
-    Recoverable, Statement, TraitBound, TypeImpl, UnresolvedTraitConstraint,
+    Recoverable, Statement, TraitBound, TypeImpl, UnaryRhsMemberAccess, UnresolvedTraitConstraint,
     UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
 };
 use crate::ast::{
@@ -676,9 +676,9 @@ fn parse_type<'a>() -> impl NoirParser<UnresolvedType> + 'a {
     recursive(parse_type_inner)
 }
 
-fn parse_type_inner(
-    recursive_type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
+fn parse_type_inner<'a>(
+    recursive_type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     choice((
         field_type(),
         int_type(),
@@ -751,9 +751,9 @@ fn string_type() -> impl NoirParser<UnresolvedType> {
         .map_with_span(|expr, span| UnresolvedTypeData::String(expr).with_span(span))
 }
 
-fn format_string_type(
-    type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
+fn format_string_type<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     keyword(Keyword::FormatString)
         .ignore_then(
             type_expression()
@@ -783,22 +783,27 @@ fn int_type() -> impl NoirParser<UnresolvedType> {
     })
 }
 
-fn named_type(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
+fn named_type<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     path().then(generic_type_args(type_parser)).map_with_span(|(path, args), span| {
         UnresolvedTypeData::Named(path, args, false).with_span(span)
     })
 }
 
-fn named_trait(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
+fn named_trait<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     keyword(Keyword::Impl).ignore_then(path()).then(generic_type_args(type_parser)).map_with_span(
         |(path, args), span| UnresolvedTypeData::TraitAsType(path, args).with_span(span),
     )
 }
 
-fn generic_type_args(
-    type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<Vec<UnresolvedType>> {
+fn generic_type_args<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<Vec<UnresolvedType>> + 'a {
     type_parser
+        .clone()
         // Without checking for a terminating ',' or '>' here we may incorrectly
         // parse a generic `N * 2` as just the type `N` then fail when there is no
         // separator afterward. Failing early here ensures we try the `type_expression`
@@ -814,7 +819,9 @@ fn generic_type_args(
         .map(Option::unwrap_or_default)
 }
 
-fn array_type(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
+fn array_type<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     just(Token::LeftBracket)
         .ignore_then(type_parser)
         .then(just(Token::Semicolon).ignore_then(type_expression()))
@@ -1037,6 +1044,7 @@ where
             expr_no_constructors,
             statement,
             allow_constructors,
+            parse_type(),
         ))
     })
 }
@@ -1057,6 +1065,7 @@ fn atom_or_right_unary<'a, P, P2, S>(
     expr_no_constructors: P2,
     statement: S,
     allow_constructors: bool,
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
 ) -> impl NoirParser<Expression> + 'a
 where
     P: ExprParser + 'a,
@@ -1067,7 +1076,7 @@ where
         Call(Vec<Expression>),
         ArrayIndex(Expression),
         Cast(UnresolvedType),
-        MemberAccess((Ident, Option<Vec<Expression>>)),
+        MemberAccess(UnaryRhsMemberAccess),
     }
 
     // `(arg1, ..., argN)` in `my_func(arg1, ..., argN)`
@@ -1081,14 +1090,17 @@ where
 
     // `as Type` in `atom as Type`
     let cast_rhs = keyword(Keyword::As)
-        .ignore_then(parse_type())
+        .ignore_then(type_parser.clone())
         .map(UnaryRhs::Cast)
         .labelled(ParsingRuleLabel::Cast);
 
+    // A turbofish operator is optional in a method call to specify generic types
+    let turbofish = primitives::turbofish(type_parser);
+
     // `.foo` or `.foo(args)` in `atom.foo` or `atom.foo(args)`
     let member_rhs = just(Token::Dot)
         .ignore_then(field_name())
-        .then(parenthesized(expression_list(expr_parser.clone())).or_not())
+        .then(turbofish.then(parenthesized(expression_list(expr_parser.clone()))).or_not())
         .map(UnaryRhs::MemberAccess)
         .labelled(ParsingRuleLabel::FieldAccess);
 
@@ -1277,7 +1289,7 @@ fn type_expression_atom<'a, P>(expr_parser: P) -> impl NoirParser<Expression> +
 where
     P: ExprParser + 'a,
 {
-    variable()
+    primitives::variable_no_turbofish()
         .or(literal())
         .map_with_span(Expression::new)
         .or(parenthesized(expr_parser))
@@ -1367,22 +1379,19 @@ mod test {
 
     #[test]
     fn parse_cast() {
+        let expression_nc = expression_no_constructors(expression());
         parse_all(
             atom_or_right_unary(
                 expression(),
                 expression_no_constructors(expression()),
                 fresh_statement(),
                 true,
+                parse_type(),
             ),
             vec!["x as u8", "x as u16", "0 as Field", "(x + 3) as [Field; 8]"],
         );
         parse_all_failing(
-            atom_or_right_unary(
-                expression(),
-                expression_no_constructors(expression()),
-                fresh_statement(),
-                true,
-            ),
+            atom_or_right_unary(expression(), expression_nc, fresh_statement(), true, parse_type()),
             vec!["x as pub u8"],
         );
     }
@@ -1402,6 +1411,7 @@ mod test {
                 expression_no_constructors(expression()),
                 fresh_statement(),
                 true,
+                parse_type(),
             ),
             valid,
         );
diff --git a/compiler/noirc_frontend/src/parser/parser/primitives.rs b/compiler/noirc_frontend/src/parser/parser/primitives.rs
index 8413f14ae4d..9da19c0a185 100644
--- a/compiler/noirc_frontend/src/parser/parser/primitives.rs
+++ b/compiler/noirc_frontend/src/parser/parser/primitives.rs
@@ -1,6 +1,7 @@
 use chumsky::prelude::*;
 
 use crate::ast::{ExpressionKind, Ident, UnaryOp};
+use crate::macros_api::UnresolvedType;
 use crate::{
     parser::{labels::ParsingRuleLabel, ExprParser, NoirParser, ParserError},
     token::{Keyword, Token, TokenKind},
@@ -77,8 +78,20 @@ where
         .map(|rhs| ExpressionKind::prefix(UnaryOp::Dereference { implicitly_added: false }, rhs))
 }
 
+pub(super) fn turbofish<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<Option<Vec<UnresolvedType>>> + 'a {
+    just(Token::DoubleColon).ignore_then(super::generic_type_args(type_parser)).or_not()
+}
+
 pub(super) fn variable() -> impl NoirParser<ExpressionKind> {
-    path().map(ExpressionKind::Variable)
+    path()
+        .then(turbofish(super::parse_type()))
+        .map(|(path, generics)| ExpressionKind::Variable(path, generics))
+}
+
+pub(super) fn variable_no_turbofish() -> impl NoirParser<ExpressionKind> {
+    path().map(|path| ExpressionKind::Variable(path, None))
 }
 
 #[cfg(test)]
diff --git a/compiler/noirc_frontend/src/resolve_locations.rs b/compiler/noirc_frontend/src/resolve_locations.rs
index ac8c96a092e..2fa7c8adbf8 100644
--- a/compiler/noirc_frontend/src/resolve_locations.rs
+++ b/compiler/noirc_frontend/src/resolve_locations.rs
@@ -97,7 +97,7 @@ impl NodeInterner {
         return_type_location_instead: bool,
     ) -> Option<Location> {
         match expression {
-            HirExpression::Ident(ident) => {
+            HirExpression::Ident(ident, _) => {
                 let definition_info = self.definition(ident.id);
                 match definition_info.kind {
                     DefinitionKind::Function(func_id) => {
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index fb80a7d8018..7bf5655486b 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1378,3 +1378,68 @@ fn deny_fold_attribute_on_unconstrained() {
         CompilationError::ResolverError(ResolverError::FoldAttributeOnUnconstrained { .. })
     ));
 }
+
+#[test]
+fn specify_function_types_with_turbofish() {
+    let src = r#"
+        trait Default {
+            fn default() -> Self;
+        }
+
+        impl Default for Field {
+            fn default() -> Self { 0 }
+        }
+
+        impl Default for u64 {
+            fn default() -> Self { 0 }
+        }
+
+        // Need the above as we don't have access to the stdlib here.
+        // We also need to construct a concrete value of `U` without giving away its type
+        // as otherwise the unspecified type is ignored.
+
+        fn generic_func<T, U>() -> (T, U) where T: Default, U: Default {
+            (T::default(), U::default())
+        }
+    
+        fn main() {
+            let _ = generic_func::<u64, Field>();
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 0);
+}
+
+#[test]
+fn specify_method_types_with_turbofish() {
+    let src = r#"
+        trait Default {
+            fn default() -> Self;
+        }
+
+        impl Default for Field {
+            fn default() -> Self { 0 }
+        }
+
+        // Need the above as we don't have access to the stdlib here.
+        // We also need to construct a concrete value of `U` without giving away its type
+        // as otherwise the unspecified type is ignored.
+
+        struct Foo<T> {
+            inner: T
+        }
+        
+        impl<T> Foo<T> {
+            fn generic_method<U>(_self: Self) where U: Default {
+                U::default()
+            }
+        }
+        
+        fn main() {
+            let foo: Foo<Field> = Foo { inner: 1 };
+            foo.generic_method::<Field>();
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 0);
+}
diff --git a/cspell.json b/cspell.json
index 1fbbe5c428d..eaf3fcd1b00 100644
--- a/cspell.json
+++ b/cspell.json
@@ -180,6 +180,7 @@
         "termcolor",
         "thiserror",
         "tslog",
+        "turbofish",
         "typecheck",
         "typechecked",
         "typevar",
diff --git a/test_programs/compile_failure/turbofish_generic_count/Nargo.toml b/test_programs/compile_failure/turbofish_generic_count/Nargo.toml
new file mode 100644
index 00000000000..92be7dcb749
--- /dev/null
+++ b/test_programs/compile_failure/turbofish_generic_count/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "turbofish_generic_count"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/turbofish_generic_count/src/main.nr b/test_programs/compile_failure/turbofish_generic_count/src/main.nr
new file mode 100644
index 00000000000..a360641fa15
--- /dev/null
+++ b/test_programs/compile_failure/turbofish_generic_count/src/main.nr
@@ -0,0 +1,22 @@
+
+struct Bar<T> {
+    one: Field,
+    two: Field,
+    other: T,
+}
+
+impl<T> Bar<T> {
+    fn zeroed<A>(_self: Self) -> A {
+        dep::std::unsafe::zeroed()
+    }
+}
+
+fn foo<T>(bar: Bar<T>) {
+    assert(bar.one == bar.two);
+}
+
+fn main(x: Field, y: pub Field) {
+    let bar1: Bar<Field> = Bar { one: x, two: y, other: 0 };
+
+    assert(bar1.zeroed::<u32, Field>() == 0);
+}
diff --git a/test_programs/execution_success/generics/src/main.nr b/test_programs/execution_success/generics/src/main.nr
index 3edce1ed8e7..c8616960559 100644
--- a/test_programs/execution_success/generics/src/main.nr
+++ b/test_programs/execution_success/generics/src/main.nr
@@ -31,6 +31,13 @@ impl Bar<Field> {
     }
 }
 
+impl<T> Bar<T> {
+    // This is to test that we can use turbofish on methods as well
+    fn zeroed<A>(_self: Self) -> A {
+        dep::std::unsafe::zeroed()
+    }
+}
+
 fn main(x: Field, y: Field) {
     let bar1: Bar<Field> = Bar { one: x, two: y, other: 0 };
     let bar2 = Bar { one: x, two: y, other: [0] };
@@ -51,6 +58,14 @@ fn main(x: Field, y: Field) {
     let nested_generics: Bar<Bar<Field>> = Bar { one, two, other: Bar { one, two, other: 0 } };
     assert(nested_generics.other.other == bar1.get_other());
 
+    // Test turbofish operator
+    foo::<Field>(bar1);
+
+    // Test that turbofish works on methods and that it uses the generics on the methods
+    // While still handling the generic on the impl (T in this case) that is implicitly added
+    // to the method.
+    assert(bar1.zeroed::<u32>() == 0);
+
     let _ = regression_2055([1, 2, 3]);
 }
 
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 6b7dca6c5c7..e5b30f99b7b 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -1,8 +1,9 @@
 use noirc_frontend::ast::{
-    ArrayLiteral, BlockExpression, Expression, ExpressionKind, Literal, UnaryOp,
+    ArrayLiteral, BlockExpression, Expression, ExpressionKind, Literal, UnaryOp, UnresolvedType,
 };
 use noirc_frontend::{macros_api::Span, token::Token};
 
+use crate::rewrite;
 use crate::visitor::{
     expr::{format_brackets, format_parens, NewlineMode},
     ExpressionType, FmtVisitor, Indent, Shape,
@@ -72,6 +73,7 @@ pub(crate) fn rewrite(
 
             let object = rewrite_sub_expr(visitor, shape, method_call_expr.object);
             let method = method_call_expr.method_name.to_string();
+            let turbofish = rewrite_turbofish(visitor, shape, method_call_expr.generics);
             let args = format_parens(
                 visitor.config.fn_call_width.into(),
                 visitor.fork(),
@@ -83,7 +85,7 @@ pub(crate) fn rewrite(
                 NewlineMode::IfContainsNewLineAndWidth,
             );
 
-            format!("{object}.{method}{args}")
+            format!("{object}.{method}{turbofish}{args}")
         }
         ExpressionKind::MemberAccess(member_access_expr) => {
             let lhs_str = rewrite_sub_expr(visitor, shape, member_access_expr.lhs);
@@ -157,7 +159,13 @@ pub(crate) fn rewrite(
 
             visitor.format_if(*if_expr)
         }
-        ExpressionKind::Lambda(_) | ExpressionKind::Variable(_) => visitor.slice(span).to_string(),
+        ExpressionKind::Variable(path, generics) => {
+            let path_string = visitor.slice(path.span);
+
+            let turbofish = rewrite_turbofish(visitor, shape, generics);
+            format!("{path_string}{turbofish}")
+        }
+        ExpressionKind::Lambda(_) => visitor.slice(span).to_string(),
         ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
         ExpressionKind::Comptime(block) => {
             format!("comptime {}", rewrite_block(visitor, block, span))
@@ -171,3 +179,24 @@ fn rewrite_block(visitor: &FmtVisitor, block: BlockExpression, span: Span) -> St
     visitor.visit_block(block, span);
     visitor.finish()
 }
+
+fn rewrite_turbofish(
+    visitor: &FmtVisitor,
+    shape: Shape,
+    generics: Option<Vec<UnresolvedType>>,
+) -> String {
+    if let Some(generics) = generics {
+        let mut turbofish = "".to_owned();
+        for (i, generic) in generics.into_iter().enumerate() {
+            let generic = rewrite::typ(visitor, shape, generic);
+            turbofish = if i == 0 {
+                format!("::<{}", generic)
+            } else {
+                format!("{turbofish}, {}", generic)
+            };
+        }
+        format!("{turbofish}>")
+    } else {
+        "".to_owned()
+    }
+}
diff --git a/tooling/nargo_fmt/tests/expected/turbofish_call.nr b/tooling/nargo_fmt/tests/expected/turbofish_call.nr
new file mode 100644
index 00000000000..bcf0df9a969
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/turbofish_call.nr
@@ -0,0 +1,8 @@
+fn foo() {
+    my_function::<Field, u32>(10, some_value, another_func(20, 30));
+
+    outer_function::<Field>(
+        some_function(), // Original inner function call
+        another_function() // Original inner function call
+    );
+}
diff --git a/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr b/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr
new file mode 100644
index 00000000000..52fa3db2ac9
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr
@@ -0,0 +1,12 @@
+fn foo() {
+    my_object.some_method::<Field>(10, var_value, inner_method::<u32>(20, 30));
+
+    assert(
+        p4_affine.eq::<Field>(
+            Gaffine::new::<Field>(
+                6890855772600357754907169075114257697580319025794532037257385534741338397365,
+                4338620300185947561074059802482547481416142213883829469920100239455078257889
+            )
+        )
+    );
+}
diff --git a/tooling/nargo_fmt/tests/input/turbofish_call.nr b/tooling/nargo_fmt/tests/input/turbofish_call.nr
new file mode 100644
index 00000000000..03abde789fe
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/turbofish_call.nr
@@ -0,0 +1,7 @@
+fn foo() {
+    my_function ::<Field, u32>  (   10,some_value,another_func( 20 , 30)  );
+
+    outer_function ::<Field> (some_function(),    // Original inner function call
+ another_function(), // Original inner function call
+    );
+}
\ No newline at end of file
diff --git a/tooling/nargo_fmt/tests/input/turbofish_method_call.nr b/tooling/nargo_fmt/tests/input/turbofish_method_call.nr
new file mode 100644
index 00000000000..aa7ae87f23a
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/turbofish_method_call.nr
@@ -0,0 +1,5 @@
+fn foo() {
+    my_object  .  some_method :: <Field> (   10,var_value,inner_method:: <u32>( 20 , 30)  );
+
+    assert(p4_affine.eq::<Field>(Gaffine::new::<Field>(6890855772600357754907169075114257697580319025794532037257385534741338397365, 4338620300185947561074059802482547481416142213883829469920100239455078257889)));
+}
\ No newline at end of file

From 89846cfbc4961c5258d91b5973f027be80885a20 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 21 May 2024 19:29:31 +0100
Subject: [PATCH 281/416] fix(frontend): Call trait method with mut self from
 generic definition (#5041)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

Not sure if there is another issue for this I will have to look again,
but I found this bug when trying to implement
https://github.com/noir-lang/noir/issues/4514

## Summary\*

When type checking a `MethodCall` from the HIR now we also add a mutable
reference to the object type when we have a
`HirMethodReference::TraitMethodId`. We were previously only doing this
for a `HirMethodReference::FuncId`.

For example that meant this program would fail with the following errors
laid out in the comments:
```rust
fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
    // Check that we can a trait method to instead a trait implementation
    let mut hasher: H = H::default();
    // Regression that the object is converted to a mutable reference type `&mut _`.
    // Otherwise will see `Expected type &mut _, found type H`.
    // Then we need to make sure to also auto dereference later in the type checking process
    // when searching for a matching impl or else we will get `No matching impl found for `&mut H: Hasher`
    hasher.write(input[0]);
    hasher.write(input[1]);
    hasher.finish()
}
```
I also had to add auto dereferencing when verifying the trait
constraints later inside of `type_check_func`. So first we add a mutable
reference to the method call's object type to avoid a mismatched type
error, and then we later dereference it to find the appropriate trait
implementation.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Jake Fecher <jake@aztecprotocol.com>
Co-authored-by: Jake Fecher <jfecher11@gmail.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../noirc_frontend/src/hir/type_check/expr.rs | 32 +++++---
 .../noirc_frontend/src/hir/type_check/mod.rs  |  9 ++-
 noir_stdlib/src/lib.nr                        |  2 +-
 .../trait_method_mut_self/Nargo.toml          |  7 ++
 .../trait_method_mut_self/Prover.toml         |  2 +
 .../trait_method_mut_self/src/main.nr         | 74 +++++++++++++++++++
 6 files changed, 113 insertions(+), 13 deletions(-)
 create mode 100644 test_programs/execution_success/trait_method_mut_self/Nargo.toml
 create mode 100644 test_programs/execution_success/trait_method_mut_self/Prover.toml
 create mode 100644 test_programs/execution_success/trait_method_mut_self/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index c4f80591bf8..abff466e1d5 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -236,17 +236,27 @@ impl<'interner> TypeChecker<'interner> {
 
                         // Automatically add `&mut` if the method expects a mutable reference and
                         // the object is not already one.
-                        if let HirMethodReference::FuncId(func_id) = &method_ref {
-                            if *func_id != FuncId::dummy_id() {
-                                let function_type =
-                                    self.interner.function_meta(func_id).typ.clone();
-
-                                self.try_add_mutable_reference_to_object(
-                                    &mut method_call,
-                                    &function_type,
-                                    &mut object_type,
-                                );
+                        let func_id = match &method_ref {
+                            HirMethodReference::FuncId(func_id) => *func_id,
+                            HirMethodReference::TraitMethodId(method_id, _) => {
+                                let id = self.interner.trait_method_id(*method_id);
+                                let definition = self.interner.definition(id);
+                                let DefinitionKind::Function(func_id) = definition.kind else {
+                                    unreachable!(
+                                        "Expected trait function to be a DefinitionKind::Function"
+                                    )
+                                };
+                                func_id
                             }
+                        };
+
+                        if func_id != FuncId::dummy_id() {
+                            let function_type = self.interner.function_meta(&func_id).typ.clone();
+                            self.try_add_mutable_reference_to_object(
+                                &mut method_call,
+                                &function_type,
+                                &mut object_type,
+                            );
                         }
 
                         // TODO: update object_type here?
@@ -567,7 +577,7 @@ impl<'interner> TypeChecker<'interner> {
 
     /// Insert as many dereference operations as necessary to automatically dereference a method
     /// call object to its base value type T.
-    fn insert_auto_dereferences(&mut self, object: ExprId, typ: Type) -> (ExprId, Type) {
+    pub(crate) fn insert_auto_dereferences(&mut self, object: ExprId, typ: Type) -> (ExprId, Type) {
         if let Type::MutableReference(element) = typ {
             let location = self.interner.id_location(object);
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 9335b8297fe..b2a76828c88 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -141,8 +141,15 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     }
 
     // Verify any remaining trait constraints arising from the function body
-    for (constraint, expr_id) in std::mem::take(&mut type_checker.trait_constraints) {
+    for (mut constraint, expr_id) in std::mem::take(&mut type_checker.trait_constraints) {
         let span = type_checker.interner.expr_span(&expr_id);
+
+        if matches!(&constraint.typ, Type::MutableReference(_)) {
+            let (_, dereferenced_typ) =
+                type_checker.insert_auto_dereferences(expr_id, constraint.typ.clone());
+            constraint.typ = dereferenced_typ;
+        }
+
         type_checker.verify_trait_constraint(
             &constraint.typ,
             constraint.trait_id,
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index 4e83fc59276..f11b21003ad 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -69,4 +69,4 @@ pub fn wrapping_mul<T>(x: T, y: T) -> T {
 }
 
 #[builtin(as_witness)]
-pub fn as_witness(x: Field) {}
\ No newline at end of file
+pub fn as_witness(x: Field) {}
diff --git a/test_programs/execution_success/trait_method_mut_self/Nargo.toml b/test_programs/execution_success/trait_method_mut_self/Nargo.toml
new file mode 100644
index 00000000000..d2fe9e8e137
--- /dev/null
+++ b/test_programs/execution_success/trait_method_mut_self/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "trait_method_mut_self"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/trait_method_mut_self/Prover.toml b/test_programs/execution_success/trait_method_mut_self/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/trait_method_mut_self/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/trait_method_mut_self/src/main.nr b/test_programs/execution_success/trait_method_mut_self/src/main.nr
new file mode 100644
index 00000000000..fa47fd5d881
--- /dev/null
+++ b/test_programs/execution_success/trait_method_mut_self/src/main.nr
@@ -0,0 +1,74 @@
+use dep::std::hash::Hasher;
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+
+fn main(x: Field, y: pub Field) {
+    let mut a_mut_ref = AType { x };
+
+    pass_trait_by_value(a_mut_ref, y);
+    assert(a_mut_ref.x == x);
+
+    pass_trait_by_value_impl_param(a_mut_ref, y);
+    assert(a_mut_ref.x == x);
+
+    pass_trait_by_mut_ref(&mut a_mut_ref, y);
+    assert(a_mut_ref.x == y);
+
+    let mut hasher = Poseidon2Hasher::default();
+    hasher.write(x);
+    hasher.write(y);
+    let expected_hash = hasher.finish();
+    // Check that we get the same result when using the hasher in a 
+    // method that purely uses trait methods without a supplied implementation.
+    assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == expected_hash);
+}
+
+trait SomeTrait {
+    fn set_value(&mut self, new_value: Field) -> ();
+
+    fn get_value(self) -> Field;
+}
+
+struct AType {
+    x: Field
+}
+
+impl SomeTrait for AType {
+    fn set_value(&mut self, new_value: Field) -> () {
+        self.x = new_value;
+    }
+
+    fn get_value(self) -> Field {
+        self.x
+    }
+}
+
+fn pass_trait_by_value_impl_param(mut a_mut_ref: impl SomeTrait, value: Field) {
+    // We auto add a mutable reference to the object type if the method call expects a mutable self
+    a_mut_ref.set_value(value);
+    assert(a_mut_ref.get_value() == value);
+}
+
+fn pass_trait_by_value<T>(mut a_mut_ref: T, value: Field) where T: SomeTrait {
+    // We auto add a mutable reference to the object type if the method call expects a mutable self
+    a_mut_ref.set_value(value);
+    assert(a_mut_ref.get_value() == value);
+}
+
+fn pass_trait_by_mut_ref<T>(a_mut_ref: &mut T, value: Field) where T: SomeTrait {
+    // We auto add a mutable reference to the object type if the method call expects a mutable self
+    a_mut_ref.set_value(value);
+}
+
+fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
+    // Check that we can call a trait method instead of a trait implementation
+    // TODO: Need to remove the need for this type annotation
+    // TODO: Curently, without the annotation we will get `Expression type is ambiguous` when trying to use the `hasher`
+    let mut hasher: H = H::default();
+    // Regression that the object is converted to a mutable reference type `&mut _`.
+    // Otherwise will see `Expected type &mut _, found type H`.
+    // Then we need to make sure to also auto dereference later in the type checking process
+    // when searching for a matching impl or else we will get `No matching impl found for `&mut H: Hasher`
+    hasher.write(input[0]);
+    hasher.write(input[1]);
+    hasher.finish()
+}

From fd772e7a764004373f5a41a54eb6847f4decda77 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 21 May 2024 20:17:08 +0100
Subject: [PATCH 282/416] fix(frontend): Correctly monomorphize turbofish
 functions (#5049)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

Working towards https://github.com/noir-lang/noir/issues/4514 and fully
resolving https://github.com/noir-lang/noir/issues/4710

## Summary\*

We need to accurately monomorphize functions with turbofish operators
where no function parameters or the return type using the specified
generic.

Without this change the following would pass:
```
fn main(x: Field, y: pub Field) {
    let mut hasher = PoseidonHasher::default();
    hasher.write(x);
    hasher.write(y);
    let poseidon_expected_hash = hasher.finish();
    assert(hash_simple_array::<PoseidonHasher>([x, y]) == poseidon_expected_hash);

    let mut hasher = Poseidon2Hasher::default();
    hasher.write(x);
    hasher.write(y);
    let poseidon2_expected_hash = hasher.finish();
    assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == poseidon_expected_hash);
    assert(hash_simple_array::<Poseidon2Hasher>([x, y]) != poseidon2_expected_hash);
}

fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
    let mut hasher: H = H::default();
    hasher.write(input[0]);
    hasher.write(input[1]);
    hasher.finish()
}
```

Essentially any future invocations of `hash_simple_array` would use the
`PoseidonHasher`. We now correctly monomorphize the functions to use the
correct type.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Jake Fecher <jake@aztecprotocol.com>
Co-authored-by: Jake Fecher <jfecher11@gmail.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../src/monomorphization/mod.rs               | 48 ++++++++++++++-----
 .../trait_method_mut_self/src/main.nr         | 22 ---------
 .../turbofish_call_func_diff_types/Nargo.toml |  7 +++
 .../Prover.toml                               |  2 +
 .../src/main.nr                               | 36 ++++++++++++++
 5 files changed, 81 insertions(+), 34 deletions(-)
 create mode 100644 test_programs/execution_success/turbofish_call_func_diff_types/Nargo.toml
 create mode 100644 test_programs/execution_success/turbofish_call_func_diff_types/Prover.toml
 create mode 100644 test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr

diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 9a20d0dd537..54a6af97744 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -55,9 +55,12 @@ struct LambdaContext {
 struct Monomorphizer<'interner> {
     /// Functions are keyed by their unique ID and expected type so that we can monomorphize
     /// a new version of the function for each type.
+    /// We also key by any turbofish generics that are specified.
+    /// This is necessary for a case where we may have a trait generic that can be instantiated
+    /// outside of a function parameter or return value.
     ///
     /// Using nested HashMaps here lets us avoid cloning HirTypes when calling .get()
-    functions: HashMap<node_interner::FuncId, HashMap<HirType, FuncId>>,
+    functions: HashMap<node_interner::FuncId, HashMap<(HirType, Vec<HirType>), FuncId>>,
 
     /// Unlike functions, locals are only keyed by their unique ID because they are never
     /// duplicated during monomorphization. Doing so would allow them to be used polymorphically
@@ -198,10 +201,15 @@ impl<'interner> Monomorphizer<'interner> {
         id: node_interner::FuncId,
         expr_id: node_interner::ExprId,
         typ: &HirType,
+        turbofish_generics: Vec<HirType>,
         trait_method: Option<TraitMethodId>,
     ) -> Definition {
         let typ = typ.follow_bindings();
-        match self.functions.get(&id).and_then(|inner_map| inner_map.get(&typ)) {
+        match self
+            .functions
+            .get(&id)
+            .and_then(|inner_map| inner_map.get(&(typ.clone(), turbofish_generics.clone())))
+        {
             Some(id) => Definition::Function(*id),
             None => {
                 // Function has not been monomorphized yet
@@ -222,7 +230,8 @@ impl<'interner> Monomorphizer<'interner> {
                         Definition::Builtin(opcode)
                     }
                     FunctionKind::Normal => {
-                        let id = self.queue_function(id, expr_id, typ, trait_method);
+                        let id =
+                            self.queue_function(id, expr_id, typ, turbofish_generics, trait_method);
                         Definition::Function(id)
                     }
                     FunctionKind::Oracle => {
@@ -249,8 +258,14 @@ impl<'interner> Monomorphizer<'interner> {
     }
 
     /// Prerequisite: typ = typ.follow_bindings()
-    fn define_function(&mut self, id: node_interner::FuncId, typ: HirType, new_id: FuncId) {
-        self.functions.entry(id).or_default().insert(typ, new_id);
+    fn define_function(
+        &mut self,
+        id: node_interner::FuncId,
+        typ: HirType,
+        turbofish_generics: Vec<HirType>,
+        new_id: FuncId,
+    ) {
+        self.functions.entry(id).or_default().insert((typ, turbofish_generics), new_id);
     }
 
     fn compile_main(
@@ -393,7 +408,7 @@ impl<'interner> Monomorphizer<'interner> {
         use ast::Literal::*;
 
         let expr = match self.interner.expression(&expr) {
-            HirExpression::Ident(ident, _) => self.ident(ident, expr)?,
+            HirExpression::Ident(ident, generics) => self.ident(ident, expr, generics)?,
             HirExpression::Literal(HirLiteral::Str(contents)) => Literal(Str(contents)),
             HirExpression::Literal(HirLiteral::FmtStr(contents, idents)) => {
                 let fields = try_vecmap(idents, |ident| self.expr(ident))?;
@@ -825,6 +840,7 @@ impl<'interner> Monomorphizer<'interner> {
         &mut self,
         ident: HirIdent,
         expr_id: node_interner::ExprId,
+        generics: Option<Vec<HirType>>,
     ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.interner.id_type(expr_id);
 
@@ -838,7 +854,13 @@ impl<'interner> Monomorphizer<'interner> {
                 let mutable = definition.mutable;
                 let location = Some(ident.location);
                 let name = definition.name.clone();
-                let definition = self.lookup_function(*func_id, expr_id, &typ, None);
+                let definition = self.lookup_function(
+                    *func_id,
+                    expr_id,
+                    &typ,
+                    generics.unwrap_or_default(),
+                    None,
+                );
                 let typ = Self::convert_type(&typ, ident.location)?;
                 let ident = ast::Ident { location, mutable, definition, name, typ: typ.clone() };
                 let ident_expression = ast::Expression::Ident(ident);
@@ -1063,10 +1085,11 @@ impl<'interner> Monomorphizer<'interner> {
             }
         };
 
-        let func_id = match self.lookup_function(func_id, expr_id, &function_type, Some(method)) {
-            Definition::Function(func_id) => func_id,
-            _ => unreachable!(),
-        };
+        let func_id =
+            match self.lookup_function(func_id, expr_id, &function_type, vec![], Some(method)) {
+                Definition::Function(func_id) => func_id,
+                _ => unreachable!(),
+            };
 
         let the_trait = self.interner.get_trait(method.trait_id);
         let location = self.interner.expr_location(&expr_id);
@@ -1292,10 +1315,11 @@ impl<'interner> Monomorphizer<'interner> {
         id: node_interner::FuncId,
         expr_id: node_interner::ExprId,
         function_type: HirType,
+        turbofish_generics: Vec<HirType>,
         trait_method: Option<TraitMethodId>,
     ) -> FuncId {
         let new_id = self.next_function_id();
-        self.define_function(id, function_type.clone(), new_id);
+        self.define_function(id, function_type.clone(), turbofish_generics, new_id);
 
         let bindings = self.interner.get_instantiation_bindings(expr_id);
         let bindings = self.follow_bindings(bindings);
diff --git a/test_programs/execution_success/trait_method_mut_self/src/main.nr b/test_programs/execution_success/trait_method_mut_self/src/main.nr
index fa47fd5d881..0e736c2f098 100644
--- a/test_programs/execution_success/trait_method_mut_self/src/main.nr
+++ b/test_programs/execution_success/trait_method_mut_self/src/main.nr
@@ -12,14 +12,6 @@ fn main(x: Field, y: pub Field) {
 
     pass_trait_by_mut_ref(&mut a_mut_ref, y);
     assert(a_mut_ref.x == y);
-
-    let mut hasher = Poseidon2Hasher::default();
-    hasher.write(x);
-    hasher.write(y);
-    let expected_hash = hasher.finish();
-    // Check that we get the same result when using the hasher in a 
-    // method that purely uses trait methods without a supplied implementation.
-    assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == expected_hash);
 }
 
 trait SomeTrait {
@@ -58,17 +50,3 @@ fn pass_trait_by_mut_ref<T>(a_mut_ref: &mut T, value: Field) where T: SomeTrait
     // We auto add a mutable reference to the object type if the method call expects a mutable self
     a_mut_ref.set_value(value);
 }
-
-fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
-    // Check that we can call a trait method instead of a trait implementation
-    // TODO: Need to remove the need for this type annotation
-    // TODO: Curently, without the annotation we will get `Expression type is ambiguous` when trying to use the `hasher`
-    let mut hasher: H = H::default();
-    // Regression that the object is converted to a mutable reference type `&mut _`.
-    // Otherwise will see `Expected type &mut _, found type H`.
-    // Then we need to make sure to also auto dereference later in the type checking process
-    // when searching for a matching impl or else we will get `No matching impl found for `&mut H: Hasher`
-    hasher.write(input[0]);
-    hasher.write(input[1]);
-    hasher.finish()
-}
diff --git a/test_programs/execution_success/turbofish_call_func_diff_types/Nargo.toml b/test_programs/execution_success/turbofish_call_func_diff_types/Nargo.toml
new file mode 100644
index 00000000000..8624cda646b
--- /dev/null
+++ b/test_programs/execution_success/turbofish_call_func_diff_types/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "turbofish_call_func_diff_types"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/turbofish_call_func_diff_types/Prover.toml b/test_programs/execution_success/turbofish_call_func_diff_types/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/execution_success/turbofish_call_func_diff_types/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr b/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
new file mode 100644
index 00000000000..709a694e77b
--- /dev/null
+++ b/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
@@ -0,0 +1,36 @@
+use dep::std::hash::Hasher;
+use dep::std::hash::poseidon2::Poseidon2Hasher;
+use dep::std::hash::poseidon::PoseidonHasher;
+
+fn main(x: Field, y: pub Field) {
+    let mut hasher = PoseidonHasher::default();
+    hasher.write(x);
+    hasher.write(y);
+    let poseidon_expected_hash = hasher.finish();
+    // Check that we get the same result when using the hasher in a 
+    // method that purely uses trait methods without a supplied implementation.
+    assert(hash_simple_array::<PoseidonHasher>([x, y]) == poseidon_expected_hash);
+
+    // Now let's do the same logic but with a different `Hasher` supplied to the turbofish operator
+    // We want to make sure that we have correctly monomorphized a function with a trait generic
+    // where the generic is not used on any function parameters or the return value.
+    let mut hasher = Poseidon2Hasher::default();
+    hasher.write(x);
+    hasher.write(y);
+    let poseidon2_expected_hash = hasher.finish();
+    assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == poseidon2_expected_hash);
+}
+
+fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
+    // Check that we can call a trait method instead of a trait implementation
+    // TODO(https://github.com/noir-lang/noir/issues/5063): Need to remove the need for this type annotation
+    // Curently, without the annotation we will get `Expression type is ambiguous` when trying to use the `hasher`
+    let mut hasher: H = H::default();
+    // Regression that the object is converted to a mutable reference type `&mut _`.
+    // Otherwise will see `Expected type &mut _, found type H`.
+    // Then we need to make sure to also auto dereference later in the type checking process
+    // when searching for a matching impl or else we will get `No matching impl found for `&mut H: Hasher`
+    hasher.write(input[0]);
+    hasher.write(input[1]);
+    hasher.finish()
+}

From 79362629ed8cf42b6601e9a551ed8f9fe03e0112 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 21 May 2024 20:46:09 +0100
Subject: [PATCH 283/416] feat(stdlib)!: eddsa function using turbofish (#5050)

# Description

## Problem\*

Resolves #4514

## Summary\*

This updates `eddsa_verify_with_hasher` to have the following signature
now that we support the turbofish operator:
```rust
pub fn eddsa_verify_with_hasher<H>(
    pub_key_x: Field,
    pub_key_y: Field,
    signature_s: Field,
    signature_r8_x: Field,
    signature_r8_y: Field,
    message: Field
) -> bool
where H: Hasher + Default {
  [function body ...]
}
```
This re-work was only possible with further bug fixes from
https://github.com/noir-lang/noir/pull/5049 and
https://github.com/noir-lang/noir/pull/5041. The original turbofish PR
can be found here (https://github.com/noir-lang/noir/pull/3542).

## Additional Context

This PR can most likely be merged into its parent #5049 but I just made
this separate PR to separate the bug fix and the stdlib library breaking
change.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Jake Fecher <jake@aztecprotocol.com>
Co-authored-by: Jake Fecher <jfecher11@gmail.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 .../cryptographic_primitives/eddsa.mdx        |  6 ++---
 noir_stdlib/src/eddsa.nr                      | 27 +++++++++----------
 .../execution_success/eddsa/src/main.nr       |  5 ++--
 3 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
index c2c0624dfad..789d26ce426 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -15,12 +15,12 @@ Verifier for EdDSA signatures
 fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
 ```
 
-It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify_with_hasher` function with a parameter implementing the Hasher trait. For instance, if you want to use Poseidon2 instead, you can do the following:
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
+For instance, if you want to use Poseidon2 instead, you can do the following:
 ```rust
 use dep::std::hash::poseidon2::Poseidon2Hasher;
 
-let mut hasher = Poseidon2Hasher::default();
-eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher);
+eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
 ```
 
 <BlackBoxInfo />
diff --git a/noir_stdlib/src/eddsa.nr b/noir_stdlib/src/eddsa.nr
index 3aff6043ffd..1ab0158af8f 100644
--- a/noir_stdlib/src/eddsa.nr
+++ b/noir_stdlib/src/eddsa.nr
@@ -3,6 +3,7 @@ use crate::ec::consts::te::baby_jubjub;
 use crate::ec::tecurve::affine::Point as TEPoint;
 use crate::hash::{Hash, Hasher, BuildHasher, BuildHasherDefault};
 use crate::hash::poseidon::PoseidonHasher;
+use crate::default::Default;
 
 // Returns true if signature is valid
 pub fn eddsa_poseidon_verify(
@@ -13,28 +14,25 @@ pub fn eddsa_poseidon_verify(
     signature_r8_y: Field,
     message: Field
 ) -> bool {
-    let mut hasher = PoseidonHasher::default();
-    eddsa_verify_with_hasher(
+    eddsa_verify::<PoseidonHasher>(
         pub_key_x,
         pub_key_y,
         signature_s,
         signature_r8_x,
         signature_r8_y,
-        message,
-        &mut hasher
+        message
     )
 }
 
-pub fn eddsa_verify_with_hasher<H>(
+pub fn eddsa_verify<H>(
     pub_key_x: Field,
     pub_key_y: Field,
     signature_s: Field,
     signature_r8_x: Field,
     signature_r8_y: Field,
-    message: Field,
-    hasher: &mut H
+    message: Field
 ) -> bool 
-where H: Hasher {
+where H: Hasher + Default {
     // Verifies by testing:
     // S * B8 = R8 + H(R8, A, m) * A8
     let bjj = baby_jubjub();
@@ -47,12 +45,13 @@ where H: Hasher {
     // Ensure S < Subgroup Order
     assert(signature_s.lt(bjj.suborder));
     // Calculate the h = H(R, A, msg)
-    signature_r8_x.hash(hasher);
-    signature_r8_y.hash(hasher);
-    pub_key_x.hash(hasher);
-    pub_key_y.hash(hasher);
-    message.hash(hasher);
-    let hash: Field = (*hasher).finish();
+    let mut hasher: H = H::default();
+    hasher.write(signature_r8_x);
+    hasher.write(signature_r8_y);
+    hasher.write(pub_key_x);
+    hasher.write(pub_key_y);
+    hasher.write(message);
+    let hash: Field = hasher.finish();
     // Calculate second part of the right side:  right2 = h*8*A
     // Multiply by 8 by doubling 3 times. This also ensures that the result is in the subgroup.
     let pub_key_mul_2 = bjj.curve.add(pub_key, pub_key);
diff --git a/test_programs/execution_success/eddsa/src/main.nr b/test_programs/execution_success/eddsa/src/main.nr
index 012c8466f2f..ada15d5405c 100644
--- a/test_programs/execution_success/eddsa/src/main.nr
+++ b/test_programs/execution_success/eddsa/src/main.nr
@@ -2,7 +2,7 @@ use dep::std::compat;
 use dep::std::ec::consts::te::baby_jubjub;
 use dep::std::ec::tecurve::affine::Point as TEPoint;
 use dep::std::hash;
-use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify_with_hasher};
+use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify};
 use dep::std::hash::poseidon2::Poseidon2Hasher;
 
 fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
@@ -50,7 +50,6 @@ fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
         // User A's signature over the message can't be used with another message
         assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg + 1));
         // Using a different hash should fail
-        let mut hasher = Poseidon2Hasher::default();
-        assert(!eddsa_verify_with_hasher(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg, &mut hasher));
+        assert(!eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg));
     }
 }

From d8e96ef86e3e246e8dbba48e1054e58ceeae9305 Mon Sep 17 00:00:00 2001
From: 0xsisyfos <107465625+0xsisyfos@users.noreply.github.com>
Date: Wed, 22 May 2024 13:27:16 +0200
Subject: [PATCH 284/416] chore: update docs to represent zksync supporting
 necessary precompiles (#5071)

Since its latest v24 upgrade, zkSync supports ecMul, ecAdd, and
ecPairing.

The verifier compiles and deploys on zkSync Sepolia Testnet

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../version-v0.29.0/how_to/how-to-solidity-verifier.md         | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md
index e3c7c1065da..e5ce3b7bc22 100644
--- a/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md
+++ b/docs/versioned_docs/version-v0.29.0/how_to/how-to-solidity-verifier.md
@@ -212,13 +212,14 @@ It would be incorrect to say that a Noir proof verification costs any gas at all
 
 ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
 
-For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+For example, `Polygon zkEVM` does not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
 
 - Optimism
 - Arbitrum
 - Polygon PoS
 - Scroll
 - Celo
+- zkSync
 
 If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
 

From 436bbdaadb2a294b94f93e53d7d3cad3859c7e46 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Wed, 22 May 2024 07:47:09 -0400
Subject: [PATCH 285/416] feat: Sync from aztec-packages (#5070)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6573)
feat!: compile-time incorrect exec environment errors
(https://github.com/AztecProtocol/aztec-packages/pull/6442)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6555)
feat: View functions with static context enforcing
(https://github.com/AztecProtocol/aztec-packages/pull/6338)
feat!: add is_infinite to curve addition opcode
(https://github.com/AztecProtocol/aztec-packages/pull/6384)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6500)
chore!: remove backend interactions from `nargo`
(https://github.com/AztecProtocol/aztec-packages/pull/6320)
fix: removed plain from path in array args of contract interfaces
(https://github.com/AztecProtocol/aztec-packages/pull/6497)
chore: bump maximum nullifier read requests (necessary for e2e tests in
AVM) (https://github.com/AztecProtocol/aztec-packages/pull/6495)
Revert "chore: bump maximum nullifier read requests (necessary for e2e
tests in AVM)"
(https://github.com/AztecProtocol/aztec-packages/pull/6483)
chore: bump maximum nullifier read requests (necessary for e2e tests in
AVM) (https://github.com/AztecProtocol/aztec-packages/pull/6462)
fix: Check for public args in aztec functions
(https://github.com/AztecProtocol/aztec-packages/pull/6355)
feat: Move abi demonomorphizer to noir_codegen and use noir_codegen in
protocol types
(https://github.com/AztecProtocol/aztec-packages/pull/6302)
feat!: switch `bb` over to read ACIR from nargo artifacts
(https://github.com/AztecProtocol/aztec-packages/pull/6283)
feat: ToRadix BB + avm transpiler support
(https://github.com/AztecProtocol/aztec-packages/pull/6330)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6332)
fix: temporarily revert to_radix blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6304)
feat: move to_radix to a blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6294)
chore: skip formatting informattable comments
(https://github.com/AztecProtocol/aztec-packages/pull/6288)
chore(dsl): Update backend gateCount command to query a Program in a
single request
(https://github.com/AztecProtocol/aztec-packages/pull/6228)
feat: Private Kernel Recursion
(https://github.com/AztecProtocol/aztec-packages/pull/6278)
feat: Proper padding in ts AES and constrained AES in body and header
computations (https://github.com/AztecProtocol/aztec-packages/pull/6269)
chore: simplify nargo CLI to read from artifacts
(https://github.com/AztecProtocol/aztec-packages/pull/6279)
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6280)
chore: enforce formatting of noir code
(https://github.com/AztecProtocol/aztec-packages/pull/6271)
feat!: specify databus arrays for BB
(https://github.com/AztecProtocol/aztec-packages/pull/6239)
END_COMMIT_OVERRIDE

---------

Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 .aztec-sync-commit                            |   2 +-
 .github/workflows/test-js-packages.yml        |  50 ++-
 Cargo.lock                                    | 284 ---------------
 Cargo.toml                                    |   2 -
 acvm-repo/acir/codegen/acir.cpp               | 270 ++++++++++++++-
 acvm-repo/acir/src/circuit/opcodes.rs         |  16 +-
 .../opcodes/black_box_function_call.rs        |  22 +-
 acvm-repo/acir/src/lib.rs                     |   3 +-
 .../acir/tests/test_program_serialization.rs  |  41 ++-
 .../src/pwg/blackbox/embedded_curve_ops.rs    |  41 ++-
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |  12 +-
 acvm-repo/acvm/src/pwg/mod.rs                 |   2 +-
 acvm-repo/acvm/tests/solver.rs                |   8 +-
 acvm-repo/acvm_js/build.sh                    |   2 +-
 acvm-repo/acvm_js/test/shared/memory_op.ts    |   8 +-
 .../acvm_js/test/shared/multi_scalar_mul.ts   |  21 +-
 .../src/curve_specific_solver.rs              |  18 +-
 .../src/embedded_curve_ops.rs                 | 104 ++++--
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |  16 +-
 acvm-repo/brillig/src/black_box.rs            |   7 +
 acvm-repo/brillig_vm/src/black_box.rs         |  78 ++++-
 aztec_macros/src/lib.rs                       |  42 ++-
 .../src/transforms/contract_interface.rs      |  50 ++-
 aztec_macros/src/transforms/functions.rs      |  78 ++++-
 aztec_macros/src/transforms/storage.rs        | 114 ++++--
 aztec_macros/src/utils/ast_utils.rs           |  13 +-
 aztec_macros/src/utils/errors.rs              |  12 +
 .../scripts/codegen-verifiers.sh              |  36 +-
 compiler/noirc_driver/src/lib.rs              |   4 -
 .../brillig/brillig_gen/brillig_black_box.rs  |   8 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |  38 +-
 .../noirc_evaluator/src/brillig/brillig_ir.rs |  11 +-
 .../brillig/brillig_ir/codegen_intrinsic.rs   |  62 ++--
 .../src/brillig/brillig_ir/debug_show.rs      |  13 +-
 .../src/brillig/brillig_ir/entry_point.rs     |   2 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |   9 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  17 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  14 +-
 cspell.json                                   |   6 +
 .../barretenberg/_category_.json              |   6 +
 .../getting_started/barretenberg/index.md     |  53 +++
 .../hello_noir/_category_.json                |   2 +-
 docs/docs/getting_started/hello_noir/index.md |  41 ++-
 .../hello_noir/project_breakdown.md           |  66 +---
 .../getting_started/tooling/noir_codegen.md   |   2 +-
 docs/docs/how_to/how-to-oracles.md            |   4 +-
 docs/docs/how_to/how-to-solidity-verifier.md  |  44 ++-
 .../docs/noir/concepts/data_types/booleans.md |   3 -
 .../docs/noir/concepts/data_types/integers.md |   2 +-
 examples/codegen_verifier/.gitignore          |   4 +
 examples/codegen_verifier/Nargo.toml          |   7 +
 examples/codegen_verifier/Prover.toml         |   2 +
 examples/codegen_verifier/codegen_verifier.sh |  38 ++
 examples/codegen_verifier/foundry.toml        |   6 +
 examples/codegen_verifier/src/main.nr         |   3 +
 examples/codegen_verifier/test.sh             |  15 +
 examples/prove_and_verify/Nargo.toml          |   7 +
 examples/prove_and_verify/Prover.toml         |   2 +
 examples/prove_and_verify/proofs/proof        | Bin 0 -> 2176 bytes
 examples/prove_and_verify/prove_and_verify.sh |  14 +
 examples/prove_and_verify/src/main.nr         |   3 +
 examples/prove_and_verify/test.sh             |  10 +
 noir_stdlib/src/aes128.nr                     |   3 +
 noir_stdlib/src/embedded_curve_ops.nr         |  39 ++-
 noir_stdlib/src/field/bn254.nr                |  57 +--
 scripts/install_bb.sh                         |   9 +
 .../intrinsic_die/src/main.nr                 |   4 +-
 .../brillig_embedded_curve/src/main.nr        |  10 +-
 .../embedded_curve_ops/src/main.nr            |  10 +-
 .../trait_method_mut_self/src/main.nr         |  22 ++
 .../execution_success/unit_value/Nargo.toml   |   4 +-
 .../embedded_curve_ops/Nargo.toml             |   7 +
 .../embedded_curve_ops/src/main.nr            |  37 ++
 test_programs/rebuild.sh                      |   5 +-
 tooling/backend_interface/CHANGELOG.md        | 233 -------------
 tooling/backend_interface/Cargo.toml          |  35 --
 tooling/backend_interface/src/cli/contract.rs |  71 ----
 tooling/backend_interface/src/cli/gates.rs    |  64 ----
 tooling/backend_interface/src/cli/mod.rs      |  39 ---
 .../src/cli/proof_as_fields.rs                |  38 --
 tooling/backend_interface/src/cli/prove.rs    |  66 ----
 tooling/backend_interface/src/cli/verify.rs   |  74 ----
 tooling/backend_interface/src/cli/version.rs  |  29 --
 .../backend_interface/src/cli/vk_as_fields.rs |  39 ---
 tooling/backend_interface/src/cli/write_vk.rs |  58 ----
 tooling/backend_interface/src/download.rs     |  58 ----
 tooling/backend_interface/src/lib.rs          | 150 --------
 tooling/backend_interface/src/proof_system.rs | 169 ---------
 .../backend_interface/src/smart_contract.rs   |  70 ----
 .../test-binaries/mock_backend/Cargo.lock     | 223 ------------
 .../test-binaries/mock_backend/Cargo.toml     |  11 -
 .../mock_backend/src/contract_cmd.rs          |  21 --
 .../mock_backend/src/gates_cmd.rs             |  18 -
 .../test-binaries/mock_backend/src/main.rs    |  41 ---
 .../mock_backend/src/prove_cmd.rs             |  25 --
 .../mock_backend/src/verify_cmd.rs            |  24 --
 .../mock_backend/src/write_vk_cmd.rs          |  20 --
 tooling/bb_abstraction_leaks/Cargo.toml       |  17 -
 tooling/bb_abstraction_leaks/build.rs         |  58 ----
 tooling/bb_abstraction_leaks/src/lib.rs       |  26 --
 tooling/debugger/src/context.rs               |   6 +-
 tooling/debugger/tests/debug.rs               |   6 -
 tooling/lsp/src/solver.rs                     |  19 +-
 tooling/nargo/src/artifacts/contract.rs       |   6 +-
 tooling/nargo/src/artifacts/debug.rs          |  27 ++
 tooling/nargo/src/artifacts/program.rs        |   2 +-
 tooling/nargo/src/constants.rs                |   2 -
 tooling/nargo/src/package.rs                  |   7 +-
 tooling/nargo_cli/Cargo.toml                  |   6 +-
 tooling/nargo_cli/build.rs                    |   7 -
 tooling/nargo_cli/src/backends.rs             |  39 ---
 .../src/cli/backend_cmd/current_cmd.rs        |  13 -
 .../src/cli/backend_cmd/install_cmd.rs        |  30 --
 .../nargo_cli/src/cli/backend_cmd/ls_cmd.rs   |  34 --
 tooling/nargo_cli/src/cli/backend_cmd/mod.rs  |  41 ---
 .../src/cli/backend_cmd/uninstall_cmd.rs      |  59 ----
 .../nargo_cli/src/cli/backend_cmd/use_cmd.rs  |  26 --
 tooling/nargo_cli/src/cli/check_cmd.rs        |  18 +-
 .../nargo_cli/src/cli/codegen_verifier_cmd.rs |  83 -----
 tooling/nargo_cli/src/cli/compile_cmd.rs      |  21 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |  35 +-
 tooling/nargo_cli/src/cli/fs/inputs.rs        |  98 ------
 tooling/nargo_cli/src/cli/fs/mod.rs           |  12 -
 tooling/nargo_cli/src/cli/fs/program.rs       |  11 -
 tooling/nargo_cli/src/cli/fs/proof.rs         |  20 --
 tooling/nargo_cli/src/cli/info_cmd.rs         | 159 ++-------
 tooling/nargo_cli/src/cli/mod.rs              |  25 +-
 tooling/nargo_cli/src/cli/prove_cmd.rs        | 154 ---------
 tooling/nargo_cli/src/cli/verify_cmd.rs       | 109 ------
 tooling/nargo_cli/src/errors.rs               |  27 +-
 tooling/nargo_cli/src/main.rs                 |   1 -
 tooling/nargo_cli/tests/codegen-verifier.rs   |  37 --
 tooling/nargo_cli/tests/hello_world.rs        |  15 +-
 tooling/nargo_fmt/src/config.rs               |   2 +-
 tooling/noir_codegen/src/index.ts             |  79 +----
 tooling/noir_codegen/src/main.ts              |   2 +-
 tooling/noir_codegen/src/noir_types.ts        | 187 ----------
 tooling/noir_codegen/src/parseArgs.ts         |  17 +
 .../src/utils/abi_type_with_generics.ts       | 139 ++++++++
 .../noir_codegen/src/utils/demonomorphizer.ts | 284 +++++++++++++++
 .../src/utils/typings_generator.ts            | 324 ++++++++++++++++++
 tooling/noir_codegen/test/index.test.ts       |  18 +-
 tooling/noir_codegen/test/test_lib/src/lib.nr |  22 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 yarn.lock                                     |  10 +-
 145 files changed, 2262 insertions(+), 3733 deletions(-)
 create mode 100644 docs/docs/getting_started/barretenberg/_category_.json
 create mode 100644 docs/docs/getting_started/barretenberg/index.md
 create mode 100644 examples/codegen_verifier/.gitignore
 create mode 100644 examples/codegen_verifier/Nargo.toml
 create mode 100644 examples/codegen_verifier/Prover.toml
 create mode 100755 examples/codegen_verifier/codegen_verifier.sh
 create mode 100644 examples/codegen_verifier/foundry.toml
 create mode 100644 examples/codegen_verifier/src/main.nr
 create mode 100755 examples/codegen_verifier/test.sh
 create mode 100644 examples/prove_and_verify/Nargo.toml
 create mode 100644 examples/prove_and_verify/Prover.toml
 create mode 100644 examples/prove_and_verify/proofs/proof
 create mode 100755 examples/prove_and_verify/prove_and_verify.sh
 create mode 100644 examples/prove_and_verify/src/main.nr
 create mode 100755 examples/prove_and_verify/test.sh
 create mode 100755 scripts/install_bb.sh
 create mode 100644 test_programs/noir_test_success/embedded_curve_ops/Nargo.toml
 create mode 100644 test_programs/noir_test_success/embedded_curve_ops/src/main.nr
 delete mode 100644 tooling/backend_interface/CHANGELOG.md
 delete mode 100644 tooling/backend_interface/Cargo.toml
 delete mode 100644 tooling/backend_interface/src/cli/contract.rs
 delete mode 100644 tooling/backend_interface/src/cli/gates.rs
 delete mode 100644 tooling/backend_interface/src/cli/mod.rs
 delete mode 100644 tooling/backend_interface/src/cli/proof_as_fields.rs
 delete mode 100644 tooling/backend_interface/src/cli/prove.rs
 delete mode 100644 tooling/backend_interface/src/cli/verify.rs
 delete mode 100644 tooling/backend_interface/src/cli/version.rs
 delete mode 100644 tooling/backend_interface/src/cli/vk_as_fields.rs
 delete mode 100644 tooling/backend_interface/src/cli/write_vk.rs
 delete mode 100644 tooling/backend_interface/src/download.rs
 delete mode 100644 tooling/backend_interface/src/lib.rs
 delete mode 100644 tooling/backend_interface/src/proof_system.rs
 delete mode 100644 tooling/backend_interface/src/smart_contract.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/Cargo.lock
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/Cargo.toml
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/contract_cmd.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/gates_cmd.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/main.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/prove_cmd.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/verify_cmd.rs
 delete mode 100644 tooling/backend_interface/test-binaries/mock_backend/src/write_vk_cmd.rs
 delete mode 100644 tooling/bb_abstraction_leaks/Cargo.toml
 delete mode 100644 tooling/bb_abstraction_leaks/build.rs
 delete mode 100644 tooling/bb_abstraction_leaks/src/lib.rs
 delete mode 100644 tooling/nargo_cli/src/backends.rs
 delete mode 100644 tooling/nargo_cli/src/cli/backend_cmd/current_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/backend_cmd/install_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/backend_cmd/ls_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/backend_cmd/mod.rs
 delete mode 100644 tooling/nargo_cli/src/cli/backend_cmd/uninstall_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/backend_cmd/use_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/fs/proof.rs
 delete mode 100644 tooling/nargo_cli/src/cli/prove_cmd.rs
 delete mode 100644 tooling/nargo_cli/src/cli/verify_cmd.rs
 delete mode 100644 tooling/nargo_cli/tests/codegen-verifier.rs
 delete mode 100644 tooling/noir_codegen/src/noir_types.ts
 create mode 100644 tooling/noir_codegen/src/utils/abi_type_with_generics.ts
 create mode 100644 tooling/noir_codegen/src/utils/demonomorphizer.ts
 create mode 100644 tooling/noir_codegen/src/utils/typings_generator.ts

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index b9e87cffedc..82e81e9d74c 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-1c74387e56b49102043fc6701735325a891e6c65
+221e2479622aef8e70120dc0a9f91ffcbc99efba
diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index e6098dd269c..9668e3f629f 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -399,6 +399,12 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Install `bb`
+        run: |
+          ./scripts/install_bb.sh
+          echo "$HOME/.barretenberg/" >> $GITHUB_PATH
+          export PATH="$PATH:$HOME/.barretenberg/"
+
       - name: Download nargo binary
         uses: actions/download-artifact@v4
         with:
@@ -448,7 +454,7 @@ jobs:
   test-integration-browser:
     name: Integration Tests (Browser)
     runs-on: ubuntu-latest
-    needs: [build-acvm-js, build-noir-wasm, build-nargo, build-noirc-abi]
+    needs: [build-acvm-js, build-noir-wasm, build-noirc-abi]
     timeout-minutes: 30
 
     steps:
@@ -490,6 +496,47 @@ jobs:
         run: |
           yarn test:browser
   
+  test-examples:
+    name: Example scripts
+    runs-on: ubuntu-latest
+    needs: [build-nargo]
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1.2.0
+
+      - name: Install `bb`
+        run: |
+          ./scripts/install_bb.sh
+          echo "$HOME/.barretenberg/" >> $GITHUB_PATH
+          export PATH="$PATH:$HOME/.barretenberg/"
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Run `prove_and_verify`
+        working-directory: ./examples/prove_and_verify
+        run: ./test.sh
+
+      - name: Run `codegen_verifier`
+        working-directory: ./examples/codegen_verifier
+        run: ./test.sh
+
   # This is a job which depends on all test jobs and reports the overall status.
   # This allows us to add/remove test jobs without having to update the required workflows.
   tests-end:
@@ -507,6 +554,7 @@ jobs:
       - test-noir-codegen
       - test-integration-node
       - test-integration-browser
+      - test-examples
     
     steps:
         - name: Report overall success
diff --git a/Cargo.lock b/Cargo.lock
index b5dc6f9bfdf..bfc012d23f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -452,25 +452,6 @@ dependencies = [
  "regex",
 ]
 
-[[package]]
-name = "backend-interface"
-version = "0.30.0"
-dependencies = [
- "acvm",
- "bb_abstraction_leaks",
- "build-target",
- "const_format",
- "dirs",
- "flate2",
- "reqwest",
- "serde_json",
- "tar",
- "tempfile",
- "test-binary",
- "thiserror",
- "tracing",
-]
-
 [[package]]
 name = "backtrace"
 version = "0.3.68"
@@ -510,15 +491,6 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
-[[package]]
-name = "bb_abstraction_leaks"
-version = "0.11.0"
-dependencies = [
- "acvm",
- "build-target",
- "const_format",
-]
-
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -664,12 +636,6 @@ dependencies = [
  "safe-regex",
 ]
 
-[[package]]
-name = "build-target"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "832133bbabbbaa9fbdba793456a2827627a7d2b8fb96032fa1e7666d7895832b"
-
 [[package]]
 name = "bumpalo"
 version = "3.13.0"
@@ -1408,15 +1374,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
-[[package]]
-name = "encoding_rs"
-version = "0.8.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
 [[package]]
 name = "endian-type"
 version = "0.1.2"
@@ -1787,25 +1744,6 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "h2"
-version = "0.3.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap 2.2.6",
- "slab",
- "tokio",
- "tokio-util 0.7.10",
- "tracing",
-]
-
 [[package]]
 name = "half"
 version = "1.8.2"
@@ -1922,7 +1860,6 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
  "http",
  "http-body",
  "httparse",
@@ -1936,20 +1873,6 @@ dependencies = [
  "want",
 ]
 
-[[package]]
-name = "hyper-rustls"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
-dependencies = [
- "futures-util",
- "http",
- "hyper",
- "rustls",
- "tokio",
- "tokio-rustls",
-]
-
 [[package]]
 name = "iai"
 version = "0.1.1"
@@ -2137,12 +2060,6 @@ dependencies = [
  "cfg-if 1.0.0",
 ]
 
-[[package]]
-name = "ipnet"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6"
-
 [[package]]
 name = "is-terminal"
 version = "0.4.9"
@@ -2517,12 +2434,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "mime"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
-
 [[package]]
 name = "miniz_oxide"
 version = "0.7.1"
@@ -2589,7 +2500,6 @@ dependencies = [
  "assert_cmd",
  "assert_fs",
  "async-lsp",
- "backend-interface",
  "bn254_blackbox_solver",
  "build-data",
  "clap",
@@ -2600,7 +2510,6 @@ dependencies = [
  "dap",
  "dirs",
  "fm",
- "hex",
  "iai",
  "iter-extended",
  "nargo",
@@ -3678,45 +3587,6 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
-[[package]]
-name = "reqwest"
-version = "0.11.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e9ad3fe7488d7e34558a2033d45a0c90b72d97b4f80705666fea71472e2e6a1"
-dependencies = [
- "base64 0.21.2",
- "bytes",
- "encoding_rs",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "hyper",
- "hyper-rustls",
- "ipnet",
- "js-sys",
- "log",
- "mime",
- "once_cell",
- "percent-encoding 2.3.1",
- "pin-project-lite",
- "rustls",
- "rustls-pemfile",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "tokio",
- "tokio-rustls",
- "tower-service",
- "url 2.5.0",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "webpki-roots",
- "winreg",
-]
-
 [[package]]
 name = "rexpect"
 version = "0.5.0"
@@ -3750,36 +3620,6 @@ dependencies = [
  "bytemuck",
 ]
 
-[[package]]
-name = "ring"
-version = "0.16.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
-dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin 0.5.2",
- "untrusted 0.7.1",
- "web-sys",
- "winapi",
-]
-
-[[package]]
-name = "ring"
-version = "0.17.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
-dependencies = [
- "cc",
- "cfg-if 1.0.0",
- "getrandom 0.2.15",
- "libc",
- "spin 0.9.8",
- "untrusted 0.9.0",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "rust-embed"
 version = "6.8.1"
@@ -3848,37 +3688,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "rustls"
-version = "0.21.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
-dependencies = [
- "log",
- "ring 0.17.8",
- "rustls-webpki",
- "sct",
-]
-
-[[package]]
-name = "rustls-pemfile"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d3987094b1d07b653b7dfdc3f70ce9a1da9c51ac18c1b06b662e4f9a0e9f4b2"
-dependencies = [
- "base64 0.21.2",
-]
-
-[[package]]
-name = "rustls-webpki"
-version = "0.101.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
-dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
-]
-
 [[package]]
 name = "rustversion"
 version = "1.0.14"
@@ -4011,16 +3820,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
-[[package]]
-name = "sct"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
-dependencies = [
- "ring 0.16.20",
- "untrusted 0.7.1",
-]
-
 [[package]]
 name = "sec1"
 version = "0.3.0"
@@ -4129,18 +3928,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_urlencoded"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
-dependencies = [
- "form_urlencoded",
- "itoa",
- "ryu",
- "serde",
-]
-
 [[package]]
 name = "serde_with"
 version = "3.2.0"
@@ -4301,18 +4088,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
-[[package]]
-name = "spin"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-
 [[package]]
 name = "spki"
 version = "0.6.0"
@@ -4430,17 +4205,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "tar"
-version = "0.4.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
-dependencies = [
- "filetime",
- "libc",
- "xattr",
-]
-
 [[package]]
 name = "tempfile"
 version = "3.8.0"
@@ -4646,16 +4410,6 @@ dependencies = [
  "syn 2.0.64",
 ]
 
-[[package]]
-name = "tokio-rustls"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
-dependencies = [
- "rustls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-stream"
 version = "0.1.15"
@@ -4693,7 +4447,6 @@ dependencies = [
  "futures-sink",
  "pin-project-lite",
  "tokio",
- "tracing",
 ]
 
 [[package]]
@@ -4940,18 +4693,6 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
-[[package]]
-name = "untrusted"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
-
-[[package]]
-name = "untrusted"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
-
 [[package]]
 name = "url"
 version = "1.7.2"
@@ -5151,12 +4892,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "webpki-roots"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -5338,25 +5073,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "winreg"
-version = "0.50.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
-dependencies = [
- "cfg-if 1.0.0",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "xattr"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4686009f71ff3e5c4dbcf1a282d0a44db3f021ba69350cd42086b3e5f1c6985"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "zerocopy"
 version = "0.7.32"
diff --git a/Cargo.toml b/Cargo.toml
index 670ae36dd4b..182580f8d67 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,8 +13,6 @@ members = [
     "compiler/fm",
     "compiler/wasm",
     # Crates related to tooling built on top of the Noir compiler
-    "tooling/backend_interface",
-    "tooling/bb_abstraction_leaks",
     "tooling/lsp",
     "tooling/debugger",
     "tooling/nargo",
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index b7e75c4320d..47e184a6332 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -149,7 +149,7 @@ namespace Program {
         struct MultiScalarMul {
             std::vector<Program::FunctionInput> points;
             std::vector<Program::FunctionInput> scalars;
-            std::array<Program::Witness, 2> outputs;
+            std::array<Program::Witness, 3> outputs;
 
             friend bool operator==(const MultiScalarMul&, const MultiScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -157,11 +157,9 @@ namespace Program {
         };
 
         struct EmbeddedCurveAdd {
-            Program::FunctionInput input1_x;
-            Program::FunctionInput input1_y;
-            Program::FunctionInput input2_x;
-            Program::FunctionInput input2_y;
-            std::array<Program::Witness, 2> outputs;
+            std::array<Program::FunctionInput, 3> input1;
+            std::array<Program::FunctionInput, 3> input2;
+            std::array<Program::Witness, 3> outputs;
 
             friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -292,6 +290,33 @@ namespace Program {
         static BlockId bincodeDeserialize(std::vector<uint8_t>);
     };
 
+    struct BlockType {
+
+        struct Memory {
+            friend bool operator==(const Memory&, const Memory&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Memory bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct CallData {
+            friend bool operator==(const CallData&, const CallData&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static CallData bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct ReturnData {
+            friend bool operator==(const ReturnData&, const ReturnData&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static ReturnData bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Memory, CallData, ReturnData> value;
+
+        friend bool operator==(const BlockType&, const BlockType&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static BlockType bincodeDeserialize(std::vector<uint8_t>);
+    };
+
     struct Expression {
         std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
         std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
@@ -428,6 +453,7 @@ namespace Program {
         struct MemoryInit {
             Program::BlockId block_id;
             std::vector<Program::Witness> init;
+            Program::BlockType block_type;
 
             friend bool operator==(const MemoryInit&, const MemoryInit&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -754,8 +780,10 @@ namespace Program {
         struct EmbeddedCurveAdd {
             Program::MemoryAddress input1_x;
             Program::MemoryAddress input1_y;
+            Program::MemoryAddress input1_infinite;
             Program::MemoryAddress input2_x;
             Program::MemoryAddress input2_y;
+            Program::MemoryAddress input2_infinite;
             Program::HeapArray result;
 
             friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
@@ -842,7 +870,17 @@ namespace Program {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AES128Encrypt, Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, MultiScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        struct ToRadix {
+            Program::MemoryAddress input;
+            uint32_t radix;
+            Program::HeapArray output;
+
+            friend bool operator==(const ToRadix&, const ToRadix&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static ToRadix bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<AES128Encrypt, Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, MultiScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression, ToRadix> value;
 
         friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -2762,10 +2800,8 @@ Program::BlackBoxFuncCall::MultiScalarMul serde::Deserializable<Program::BlackBo
 namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) {
-        if (!(lhs.input1_x == rhs.input1_x)) { return false; }
-        if (!(lhs.input1_y == rhs.input1_y)) { return false; }
-        if (!(lhs.input2_x == rhs.input2_x)) { return false; }
-        if (!(lhs.input2_y == rhs.input2_y)) { return false; }
+        if (!(lhs.input1 == rhs.input1)) { return false; }
+        if (!(lhs.input2 == rhs.input2)) { return false; }
         if (!(lhs.outputs == rhs.outputs)) { return false; }
         return true;
     }
@@ -2790,10 +2826,8 @@ namespace Program {
 template <>
 template <typename Serializer>
 void serde::Serializable<Program::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
-    serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
-    serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
-    serde::Serializable<decltype(obj.input2_y)>::serialize(obj.input2_y, serializer);
+    serde::Serializable<decltype(obj.input1)>::serialize(obj.input1, serializer);
+    serde::Serializable<decltype(obj.input2)>::serialize(obj.input2, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
@@ -2801,10 +2835,8 @@ template <>
 template <typename Deserializer>
 Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Program::BlackBoxFuncCall::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
     Program::BlackBoxFuncCall::EmbeddedCurveAdd obj;
-    obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
-    obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
-    obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
-    obj.input2_y = serde::Deserializable<decltype(obj.input2_y)>::deserialize(deserializer);
+    obj.input1 = serde::Deserializable<decltype(obj.input1)>::deserialize(deserializer);
+    obj.input2 = serde::Deserializable<decltype(obj.input2)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
@@ -3871,8 +3903,10 @@ namespace Program {
     inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) {
         if (!(lhs.input1_x == rhs.input1_x)) { return false; }
         if (!(lhs.input1_y == rhs.input1_y)) { return false; }
+        if (!(lhs.input1_infinite == rhs.input1_infinite)) { return false; }
         if (!(lhs.input2_x == rhs.input2_x)) { return false; }
         if (!(lhs.input2_y == rhs.input2_y)) { return false; }
+        if (!(lhs.input2_infinite == rhs.input2_infinite)) { return false; }
         if (!(lhs.result == rhs.result)) { return false; }
         return true;
     }
@@ -3899,8 +3933,10 @@ template <typename Serializer>
 void serde::Serializable<Program::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
     serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
+    serde::Serializable<decltype(obj.input1_infinite)>::serialize(obj.input1_infinite, serializer);
     serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
     serde::Serializable<decltype(obj.input2_y)>::serialize(obj.input2_y, serializer);
+    serde::Serializable<decltype(obj.input2_infinite)>::serialize(obj.input2_infinite, serializer);
     serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
 }
 
@@ -3910,8 +3946,10 @@ Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Program::BlackBoxOp:
     Program::BlackBoxOp::EmbeddedCurveAdd obj;
     obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
     obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
+    obj.input1_infinite = serde::Deserializable<decltype(obj.input1_infinite)>::deserialize(deserializer);
     obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
     obj.input2_y = serde::Deserializable<decltype(obj.input2_y)>::deserialize(deserializer);
+    obj.input2_infinite = serde::Deserializable<decltype(obj.input2_infinite)>::deserialize(deserializer);
     obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
@@ -4265,6 +4303,50 @@ Program::BlackBoxOp::Sha256Compression serde::Deserializable<Program::BlackBoxOp
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BlackBoxOp::ToRadix &lhs, const BlackBoxOp::ToRadix &rhs) {
+        if (!(lhs.input == rhs.input)) { return false; }
+        if (!(lhs.radix == rhs.radix)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::ToRadix::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::ToRadix>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::ToRadix BlackBoxOp::ToRadix::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::ToRadix>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlackBoxOp::ToRadix>::serialize(const Program::BlackBoxOp::ToRadix &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
+    serde::Serializable<decltype(obj.radix)>::serialize(obj.radix, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::BlackBoxOp::ToRadix serde::Deserializable<Program::BlackBoxOp::ToRadix>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::ToRadix obj;
+    obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
+    obj.radix = serde::Deserializable<decltype(obj.radix)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BlockId &lhs, const BlockId &rhs) {
@@ -4307,6 +4389,153 @@ Program::BlockId serde::Deserializable<Program::BlockId>::deserialize(Deserializ
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BlockType &lhs, const BlockType &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType BlockType::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType>::serialize(const Program::BlockType &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType serde::Deserializable<Program::BlockType>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::BlockType obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const BlockType::Memory &lhs, const BlockType::Memory &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::Memory::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType::Memory>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType::Memory BlockType::Memory::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType::Memory>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::Memory>::serialize(const Program::BlockType::Memory &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::Memory serde::Deserializable<Program::BlockType::Memory>::deserialize(Deserializer &deserializer) {
+    Program::BlockType::Memory obj;
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const BlockType::CallData &lhs, const BlockType::CallData &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::CallData::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType::CallData>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType::CallData BlockType::CallData::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType::CallData>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::CallData>::serialize(const Program::BlockType::CallData &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::CallData serde::Deserializable<Program::BlockType::CallData>::deserialize(Deserializer &deserializer) {
+    Program::BlockType::CallData obj;
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const BlockType::ReturnData &lhs, const BlockType::ReturnData &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlockType::ReturnData::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlockType::ReturnData>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlockType::ReturnData BlockType::ReturnData::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlockType::ReturnData>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BlockType::ReturnData>::serialize(const Program::BlockType::ReturnData &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Program::BlockType::ReturnData serde::Deserializable<Program::BlockType::ReturnData>::deserialize(Deserializer &deserializer) {
+    Program::BlockType::ReturnData obj;
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) {
@@ -6443,6 +6672,7 @@ namespace Program {
     inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) {
         if (!(lhs.block_id == rhs.block_id)) { return false; }
         if (!(lhs.init == rhs.init)) { return false; }
+        if (!(lhs.block_type == rhs.block_type)) { return false; }
         return true;
     }
 
@@ -6468,6 +6698,7 @@ template <typename Serializer>
 void serde::Serializable<Program::Opcode::MemoryInit>::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
+    serde::Serializable<decltype(obj.block_type)>::serialize(obj.block_type, serializer);
 }
 
 template <>
@@ -6476,6 +6707,7 @@ Program::Opcode::MemoryInit serde::Deserializable<Program::Opcode::MemoryInit>::
     Program::Opcode::MemoryInit obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
+    obj.block_type = serde::Deserializable<decltype(obj.block_type)>::deserialize(deserializer);
     return obj;
 }
 
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index 7db317c41ab..e6dc11dac78 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -11,6 +11,13 @@ mod memory_operation;
 pub use black_box_function_call::{BlackBoxFuncCall, FunctionInput};
 pub use memory_operation::{BlockId, MemOp};
 
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum BlockType {
+    Memory,
+    CallData,
+    ReturnData,
+}
+
 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Opcode {
@@ -30,6 +37,7 @@ pub enum Opcode {
     MemoryInit {
         block_id: BlockId,
         init: Vec<Witness>,
+        block_type: BlockType,
     },
     /// Calls to unconstrained functions
     BrilligCall {
@@ -103,8 +111,12 @@ impl std::fmt::Display for Opcode {
                     write!(f, "(id: {}, op {} at: {}) ", block_id.0, op.operation, op.index)
                 }
             }
-            Opcode::MemoryInit { block_id, init } => {
-                write!(f, "INIT ")?;
+            Opcode::MemoryInit { block_id, init, block_type: databus } => {
+                match databus {
+                    BlockType::Memory => write!(f, "INIT ")?,
+                    BlockType::CallData => write!(f, "INIT CALLDATA ")?,
+                    BlockType::ReturnData => write!(f, "INIT RETURNDATA ")?,
+                }
                 write!(f, "(id: {}, len: {}) ", block_id.0, init.len())
             }
             // We keep the display for a BrilligCall and circuit Call separate as they
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 115a33c1c9d..b0e77b15c2c 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -89,14 +89,12 @@ pub enum BlackBoxFuncCall {
     MultiScalarMul {
         points: Vec<FunctionInput>,
         scalars: Vec<FunctionInput>,
-        outputs: (Witness, Witness),
+        outputs: (Witness, Witness, Witness),
     },
     EmbeddedCurveAdd {
-        input1_x: FunctionInput,
-        input1_y: FunctionInput,
-        input2_x: FunctionInput,
-        input2_y: FunctionInput,
-        outputs: (Witness, Witness),
+        input1: Box<[FunctionInput; 3]>,
+        input2: Box<[FunctionInput; 3]>,
+        outputs: (Witness, Witness, Witness),
     },
     Keccak256 {
         inputs: Vec<FunctionInput>,
@@ -245,9 +243,9 @@ impl BlackBoxFuncCall {
                 inputs.extend(scalars.iter().copied());
                 inputs
             }
-            BlackBoxFuncCall::EmbeddedCurveAdd {
-                input1_x, input1_y, input2_x, input2_y, ..
-            } => vec![*input1_x, *input1_y, *input2_x, *input2_y],
+            BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, .. } => {
+                vec![input1[0], input1[1], input2[0], input2[1]]
+            }
             BlackBoxFuncCall::RANGE { input } => vec![*input],
             BlackBoxFuncCall::SchnorrVerify {
                 public_key_x,
@@ -343,9 +341,11 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
             | BlackBoxFuncCall::PedersenHash { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
+            BlackBoxFuncCall::PedersenCommitment { outputs, .. } => vec![outputs.0, outputs.1],
             BlackBoxFuncCall::MultiScalarMul { outputs, .. }
-            | BlackBoxFuncCall::PedersenCommitment { outputs, .. }
-            | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => vec![outputs.0, outputs.1],
+            | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => {
+                vec![outputs.0, outputs.1, outputs.2]
+            }
             BlackBoxFuncCall::RANGE { .. }
             | BlackBoxFuncCall::RecursiveAggregation { .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { .. }
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index 24f27aae06f..f60f1b46b6a 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -41,7 +41,7 @@ mod reflection {
         circuit::{
             brillig::{BrilligInputs, BrilligOutputs},
             directives::Directive,
-            opcodes::BlackBoxFuncCall,
+            opcodes::{BlackBoxFuncCall, BlockType},
             AssertionPayload, Circuit, ExpressionOrMemory, ExpressionWidth, Opcode, OpcodeLocation,
             Program,
         },
@@ -60,6 +60,7 @@ mod reflection {
         };
 
         let mut tracer = Tracer::new(TracerConfig::default());
+        tracer.trace_simple_type::<BlockType>().unwrap();
         tracer.trace_simple_type::<Program>().unwrap();
         tracer.trace_simple_type::<Circuit>().unwrap();
         tracer.trace_simple_type::<ExpressionWidth>().unwrap();
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index d9327f784e6..19e4beb6158 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -63,19 +63,26 @@ fn multi_scalar_mul_circuit() {
         points: vec![
             FunctionInput { witness: Witness(1), num_bits: 128 },
             FunctionInput { witness: Witness(2), num_bits: 128 },
+            FunctionInput { witness: Witness(3), num_bits: 1 },
         ],
         scalars: vec![
-            FunctionInput { witness: Witness(3), num_bits: 128 },
             FunctionInput { witness: Witness(4), num_bits: 128 },
+            FunctionInput { witness: Witness(5), num_bits: 128 },
         ],
-        outputs: (Witness(5), Witness(6)),
+        outputs: (Witness(6), Witness(7), Witness(8)),
     });
 
     let circuit = Circuit {
-        current_witness_index: 7,
+        current_witness_index: 9,
         opcodes: vec![multi_scalar_mul],
-        private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3), Witness(4)]),
-        return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(5), Witness(6)])),
+        private_parameters: BTreeSet::from([
+            Witness(1),
+            Witness(2),
+            Witness(3),
+            Witness(4),
+            Witness(5),
+        ]),
+        return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(6), Witness(7), Witness(8)])),
         ..Circuit::default()
     };
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
@@ -83,10 +90,10 @@ fn multi_scalar_mul_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 76, 65, 14, 0, 32, 8, 82, 179, 186, 244, 104, 159,
-        30, 45, 218, 136, 141, 33, 40, 186, 93, 76, 208, 57, 31, 93, 96, 136, 47, 250, 146, 188,
-        209, 39, 181, 131, 131, 187, 148, 110, 240, 246, 101, 38, 63, 180, 243, 97, 3, 125, 173,
-        118, 131, 153, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 141, 219, 10, 0, 32, 8, 67, 243, 214, 5, 250, 232,
+        62, 189, 69, 123, 176, 132, 195, 116, 50, 149, 114, 107, 0, 97, 127, 116, 2, 75, 243, 2,
+        74, 53, 122, 202, 189, 211, 15, 106, 5, 13, 116, 238, 35, 221, 81, 230, 61, 249, 37, 253,
+        250, 179, 79, 109, 218, 22, 67, 227, 173, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -347,7 +354,11 @@ fn complex_brillig_foreign_call() {
 fn memory_op_circuit() {
     let init = vec![Witness(1), Witness(2)];
 
-    let memory_init = Opcode::MemoryInit { block_id: BlockId(0), init };
+    let memory_init = Opcode::MemoryInit {
+        block_id: BlockId(0),
+        init,
+        block_type: acir::circuit::opcodes::BlockType::Memory,
+    };
     let write = Opcode::MemoryOp {
         block_id: BlockId(0),
         op: MemOp::write_to_mem_index(FieldElement::from(1u128).into(), Witness(3).into()),
@@ -371,11 +382,11 @@ fn memory_op_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 203, 180, 255, 216, 15, 250,
-        255, 171, 10, 154, 16, 210, 45, 61, 52, 144, 13, 132, 49, 135, 84, 54, 218, 26, 134, 22,
-        112, 5, 19, 180, 237, 61, 6, 88, 223, 208, 179, 125, 41, 216, 151, 227, 188, 52, 187, 92,
-        253, 173, 92, 137, 190, 157, 143, 160, 254, 155, 45, 188, 148, 11, 38, 213, 237, 188, 16,
-        35, 3, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 211, 180, 255, 216, 15, 250,
+        255, 171, 10, 82, 176, 232, 150, 30, 26, 200, 118, 144, 49, 135, 8, 11, 117, 14, 169, 102,
+        229, 162, 140, 78, 219, 206, 137, 174, 44, 111, 104, 217, 190, 24, 236, 75, 113, 94, 146,
+        93, 174, 252, 86, 46, 71, 223, 78, 46, 104, 129, 253, 155, 45, 60, 195, 5, 3, 89, 11, 161,
+        73, 39, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
diff --git a/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs b/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
index ee35385fa81..0b52ae295a2 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
@@ -11,7 +11,7 @@ pub(super) fn multi_scalar_mul(
     initial_witness: &mut WitnessMap,
     points: &[FunctionInput],
     scalars: &[FunctionInput],
-    outputs: (Witness, Witness),
+    outputs: (Witness, Witness, Witness),
 ) -> Result<(), OpcodeResolutionError> {
     let points: Result<Vec<_>, _> =
         points.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
@@ -19,35 +19,44 @@ pub(super) fn multi_scalar_mul(
 
     let scalars: Result<Vec<_>, _> =
         scalars.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
-    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
-
+    let mut scalars_lo = Vec::new();
+    let mut scalars_hi = Vec::new();
+    for (i, scalar) in scalars?.into_iter().enumerate() {
+        if i % 2 == 0 {
+            scalars_lo.push(*scalar);
+        } else {
+            scalars_hi.push(*scalar);
+        }
+    }
     // Call the backend's multi-scalar multiplication function
-    let (res_x, res_y) = backend.multi_scalar_mul(&points, &scalars)?;
+    let (res_x, res_y, is_infinite) =
+        backend.multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
 
     // Insert the resulting point into the witness map
     insert_value(&outputs.0, res_x, initial_witness)?;
     insert_value(&outputs.1, res_y, initial_witness)?;
-
+    insert_value(&outputs.2, is_infinite, initial_witness)?;
     Ok(())
 }
 
 pub(super) fn embedded_curve_add(
     backend: &impl BlackBoxFunctionSolver,
     initial_witness: &mut WitnessMap,
-    input1_x: FunctionInput,
-    input1_y: FunctionInput,
-    input2_x: FunctionInput,
-    input2_y: FunctionInput,
-    outputs: (Witness, Witness),
+    input1: [FunctionInput; 3],
+    input2: [FunctionInput; 3],
+    outputs: (Witness, Witness, Witness),
 ) -> Result<(), OpcodeResolutionError> {
-    let input1_x = witness_to_value(initial_witness, input1_x.witness)?;
-    let input1_y = witness_to_value(initial_witness, input1_y.witness)?;
-    let input2_x = witness_to_value(initial_witness, input2_x.witness)?;
-    let input2_y = witness_to_value(initial_witness, input2_y.witness)?;
-    let (res_x, res_y) = backend.ec_add(input1_x, input1_y, input2_x, input2_y)?;
+    let input1_x = witness_to_value(initial_witness, input1[0].witness)?;
+    let input1_y = witness_to_value(initial_witness, input1[1].witness)?;
+    let input1_infinite = witness_to_value(initial_witness, input1[2].witness)?;
+    let input2_x = witness_to_value(initial_witness, input2[0].witness)?;
+    let input2_y = witness_to_value(initial_witness, input2[1].witness)?;
+    let input2_infinite = witness_to_value(initial_witness, input2[2].witness)?;
+    let (res_x, res_y, res_infinite) =
+        backend.ec_add(input1_x, input1_y, input1_infinite, input2_x, input2_y, input2_infinite)?;
 
     insert_value(&outputs.0, res_x, initial_witness)?;
     insert_value(&outputs.1, res_y, initial_witness)?;
-
+    insert_value(&outputs.2, res_infinite, initial_witness)?;
     Ok(())
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index a74f44b79dc..99ed09a52e4 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -164,16 +164,8 @@ pub(crate) fn solve(
         BlackBoxFuncCall::MultiScalarMul { points, scalars, outputs } => {
             multi_scalar_mul(backend, initial_witness, points, scalars, *outputs)
         }
-        BlackBoxFuncCall::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, outputs } => {
-            embedded_curve_add(
-                backend,
-                initial_witness,
-                *input1_x,
-                *input1_y,
-                *input2_x,
-                *input2_y,
-                *outputs,
-            )
+        BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, outputs } => {
+            embedded_curve_add(backend, initial_witness, **input1, **input2, *outputs)
         }
         // Recursive aggregation will be entirely handled by the backend and is not solved by the ACVM
         BlackBoxFuncCall::RecursiveAggregation { .. } => Ok(()),
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index a4219adbfa6..f2649b93991 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -335,7 +335,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 &mut self.bigint_solver,
             ),
             Opcode::Directive(directive) => solve_directives(&mut self.witness_map, directive),
-            Opcode::MemoryInit { block_id, init } => {
+            Opcode::MemoryInit { block_id, init, .. } => {
                 let solver = self.block_solvers.entry(*block_id).or_default();
                 solver.init(init, &self.witness_map)
             }
diff --git a/acvm-repo/acvm/tests/solver.rs b/acvm-repo/acvm/tests/solver.rs
index df61083eee4..495389d7b3e 100644
--- a/acvm-repo/acvm/tests/solver.rs
+++ b/acvm-repo/acvm/tests/solver.rs
@@ -4,7 +4,7 @@ use acir::{
     brillig::{BinaryFieldOp, HeapArray, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
     circuit::{
         brillig::{BrilligBytecode, BrilligInputs, BrilligOutputs},
-        opcodes::{BlockId, MemOp},
+        opcodes::{BlockId, BlockType, MemOp},
         Opcode, OpcodeLocation,
     },
     native_types::{Expression, Witness, WitnessMap},
@@ -658,7 +658,11 @@ fn memory_operations() {
 
     let block_id = BlockId(0);
 
-    let init = Opcode::MemoryInit { block_id, init: (1..6).map(Witness).collect() };
+    let init = Opcode::MemoryInit {
+        block_id,
+        init: (1..6).map(Witness).collect(),
+        block_type: BlockType::Memory,
+    };
 
     let read_op = Opcode::MemoryOp {
         block_id,
diff --git a/acvm-repo/acvm_js/build.sh b/acvm-repo/acvm_js/build.sh
index 16fb26e55db..ee93413ab85 100755
--- a/acvm-repo/acvm_js/build.sh
+++ b/acvm-repo/acvm_js/build.sh
@@ -25,7 +25,7 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-require_command wasm-opt
+# require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index 20ea88c7130..f7443c2258b 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 203, 180, 255, 216, 15, 250, 255, 171, 10, 154, 16, 210,
-  45, 61, 52, 144, 13, 132, 49, 135, 84, 54, 218, 26, 134, 22, 112, 5, 19, 180, 237, 61, 6, 88, 223, 208, 179, 125, 41,
-  216, 151, 227, 188, 52, 187, 92, 253, 173, 92, 137, 190, 157, 143, 160, 254, 155, 45, 188, 148, 11, 38, 213, 237, 188,
-  16, 35, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 211, 180, 255, 216, 15, 250, 255, 171, 10, 82, 176, 232,
+  150, 30, 26, 200, 118, 144, 49, 135, 8, 11, 117, 14, 169, 102, 229, 162, 140, 78, 219, 206, 137, 174, 44, 111, 104,
+  217, 190, 24, 236, 75, 113, 94, 146, 93, 174, 252, 86, 46, 71, 223, 78, 46, 104, 129, 253, 155, 45, 60, 195, 5, 3, 89,
+  11, 161, 73, 39, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
index 8ee0a067a3a..5401da76974 100644
--- a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
+++ b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
@@ -1,21 +1,24 @@
 // See `multi_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 76, 65, 14, 0, 32, 8, 82, 179, 186, 244, 104, 159, 30, 45, 218, 136, 141, 33,
-  40, 186, 93, 76, 208, 57, 31, 93, 96, 136, 47, 250, 146, 188, 209, 39, 181, 131, 131, 187, 148, 110, 240, 246, 101,
-  38, 63, 180, 243, 97, 3, 125, 173, 118, 131, 153, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 141, 219, 10, 0, 32, 8, 67, 243, 214, 5, 250, 232, 62, 189, 69, 123, 176, 132,
+  195, 116, 50, 149, 114, 107, 0, 97, 127, 116, 2, 75, 243, 2, 74, 53, 122, 202, 189, 211, 15, 106, 5, 13, 116, 238, 35,
+  221, 81, 230, 61, 249, 37, 253, 250, 179, 79, 109, 218, 22, 67, 227, 173, 0, 0, 0,
 ]);
 export const initialWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
   [2, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
-  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [4, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [3, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [4, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [5, '0x0000000000000000000000000000000000000000000000000000000000000000'],
 ]);
 
 export const expectedWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
   [2, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
-  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [4, '0x0000000000000000000000000000000000000000000000000000000000000000'],
-  [5, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [6, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
+  [3, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [4, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [5, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [6, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [7, '0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c'],
+  [8, '0x0000000000000000000000000000000000000000000000000000000000000000'],
 ]);
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index 3403b0fe232..73f64d3d9d1 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -27,15 +27,18 @@ pub trait BlackBoxFunctionSolver {
     fn multi_scalar_mul(
         &self,
         points: &[FieldElement],
-        scalars: &[FieldElement],
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
+        scalars_lo: &[FieldElement],
+        scalars_hi: &[FieldElement],
+    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError>;
     fn ec_add(
         &self,
         input1_x: &FieldElement,
         input1_y: &FieldElement,
+        input1_infinite: &FieldElement,
         input2_x: &FieldElement,
         input2_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
+        input2_infinite: &FieldElement,
+    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError>;
     fn poseidon2_permutation(
         &self,
         _inputs: &[FieldElement],
@@ -81,17 +84,20 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
     fn multi_scalar_mul(
         &self,
         _points: &[FieldElement],
-        _scalars: &[FieldElement],
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+        _scalars_lo: &[FieldElement],
+        _scalars_hi: &[FieldElement],
+    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::MultiScalarMul))
     }
     fn ec_add(
         &self,
         _input1_x: &FieldElement,
         _input1_y: &FieldElement,
+        _input1_infinite: &FieldElement,
         _input2_x: &FieldElement,
         _input2_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+        _input2_infinite: &FieldElement,
+    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::EmbeddedCurveAdd))
     }
     fn poseidon2_permutation(
diff --git a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
index 3f6d2ac86c1..901eb9d5a0f 100644
--- a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
@@ -10,9 +10,11 @@ use crate::BlackBoxResolutionError;
 /// Performs multi scalar multiplication of points with scalars.
 pub fn multi_scalar_mul(
     points: &[FieldElement],
-    scalars: &[FieldElement],
-) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-    if points.len() != scalars.len() {
+    scalars_lo: &[FieldElement],
+    scalars_hi: &[FieldElement],
+) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+    if points.len() != 3 * scalars_lo.len() || scalars_lo.len() != scalars_hi.len() {
+        dbg!(&points.len(), &scalars_lo.len(), &scalars_hi.len());
         return Err(BlackBoxResolutionError::Failed(
             BlackBoxFunc::MultiScalarMul,
             "Points and scalars must have the same length".to_string(),
@@ -21,21 +23,22 @@ pub fn multi_scalar_mul(
 
     let mut output_point = grumpkin::SWAffine::zero();
 
-    for i in (0..points.len()).step_by(2) {
-        let point = create_point(points[i], points[i + 1])
-            .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::MultiScalarMul, e))?;
+    for i in (0..points.len()).step_by(3) {
+        let point =
+            create_point(points[i], points[i + 1], points[i + 2] == FieldElement::from(1_u128))
+                .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::MultiScalarMul, e))?;
 
-        let scalar_low: u128 = scalars[i].try_into_u128().ok_or_else(|| {
+        let scalar_low: u128 = scalars_lo[i / 3].try_into_u128().ok_or_else(|| {
             BlackBoxResolutionError::Failed(
                 BlackBoxFunc::MultiScalarMul,
-                format!("Limb {} is not less than 2^128", scalars[i].to_hex()),
+                format!("Limb {} is not less than 2^128", scalars_lo[i].to_hex()),
             )
         })?;
 
-        let scalar_high: u128 = scalars[i + 1].try_into_u128().ok_or_else(|| {
+        let scalar_high: u128 = scalars_hi[i / 3].try_into_u128().ok_or_else(|| {
             BlackBoxResolutionError::Failed(
                 BlackBoxFunc::MultiScalarMul,
-                format!("Limb {} is not less than 2^128", scalars[i + 1].to_hex()),
+                format!("Limb {} is not less than 2^128", scalars_hi[i].to_hex()),
             )
         })?;
 
@@ -59,25 +62,33 @@ pub fn multi_scalar_mul(
     }
 
     if let Some((out_x, out_y)) = output_point.xy() {
-        Ok((FieldElement::from_repr(*out_x), FieldElement::from_repr(*out_y)))
+        Ok((
+            FieldElement::from_repr(*out_x),
+            FieldElement::from_repr(*out_y),
+            FieldElement::from(output_point.is_zero() as u128),
+        ))
     } else {
-        Ok((FieldElement::zero(), FieldElement::zero()))
+        Ok((FieldElement::from(0_u128), FieldElement::from(0_u128), FieldElement::from(1_u128)))
     }
 }
 
 pub fn embedded_curve_add(
-    input1_x: FieldElement,
-    input1_y: FieldElement,
-    input2_x: FieldElement,
-    input2_y: FieldElement,
-) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-    let point1 = create_point(input1_x, input1_y)
+    input1: [FieldElement; 3],
+    input2: [FieldElement; 3],
+) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+    let point1 = create_point(input1[0], input1[1], input1[2] == FieldElement::one())
         .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
-    let point2 = create_point(input2_x, input2_y)
+    let point2 = create_point(input2[0], input2[1], input2[2] == FieldElement::one())
         .map_err(|e| BlackBoxResolutionError::Failed(BlackBoxFunc::EmbeddedCurveAdd, e))?;
     let res = grumpkin::SWAffine::from(point1 + point2);
     if let Some((res_x, res_y)) = res.xy() {
-        Ok((FieldElement::from_repr(*res_x), FieldElement::from_repr(*res_y)))
+        Ok((
+            FieldElement::from_repr(*res_x),
+            FieldElement::from_repr(*res_y),
+            FieldElement::from(res.is_zero() as u128),
+        ))
+    } else if res.is_zero() {
+        Ok((FieldElement::from(0_u128), FieldElement::from(0_u128), FieldElement::from(1_u128)))
     } else {
         Err(BlackBoxResolutionError::Failed(
             BlackBoxFunc::EmbeddedCurveAdd,
@@ -86,7 +97,14 @@ pub fn embedded_curve_add(
     }
 }
 
-fn create_point(x: FieldElement, y: FieldElement) -> Result<grumpkin::SWAffine, String> {
+fn create_point(
+    x: FieldElement,
+    y: FieldElement,
+    is_infinite: bool,
+) -> Result<grumpkin::SWAffine, String> {
+    if is_infinite {
+        return Ok(grumpkin::SWAffine::zero());
+    }
     let point = grumpkin::SWAffine::new_unchecked(x.into_repr(), y.into_repr());
     if !point.is_on_curve() {
         return Err(format!("Point ({}, {}) is not on curve", x.to_hex(), y.to_hex()));
@@ -103,11 +121,11 @@ mod tests {
 
     use super::*;
 
-    fn get_generator() -> [FieldElement; 2] {
+    fn get_generator() -> [FieldElement; 3] {
         let generator = grumpkin::SWAffine::generator();
         let generator_x = FieldElement::from_repr(*generator.x().unwrap());
         let generator_y = FieldElement::from_repr(*generator.y().unwrap());
-        [generator_x, generator_y]
+        [generator_x, generator_y, FieldElement::zero()]
     }
 
     #[test]
@@ -115,7 +133,7 @@ mod tests {
         // We check that multiplying 1 by generator results in the generator
         let generator = get_generator();
 
-        let res = multi_scalar_mul(&generator, &[FieldElement::one(), FieldElement::zero()])?;
+        let res = multi_scalar_mul(&generator, &[FieldElement::one()], &[FieldElement::zero()])?;
 
         assert_eq!(generator[0], res.0);
         assert_eq!(generator[1], res.1);
@@ -125,9 +143,10 @@ mod tests {
     #[test]
     fn low_high_smoke_test() -> Result<(), BlackBoxResolutionError> {
         let points = get_generator();
-        let scalars = [FieldElement::one(), FieldElement::from(2u128)];
+        let scalars_lo = [FieldElement::one()];
+        let scalars_hi = [FieldElement::from(2u128)];
 
-        let res = multi_scalar_mul(&points, &scalars)?;
+        let res = multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
         let x = "0702ab9c7038eeecc179b4f209991bcb68c7cb05bf4c532d804ccac36199c9a9";
         let y = "23f10e9e43a3ae8d75d24154e796aae12ae7af546716e8f81a2564f1b5814130";
 
@@ -148,10 +167,10 @@ mod tests {
             "Limb 0000000000000000000000000000000100000000000000000000000000000000 is not less than 2^128".into(),
         ));
 
-        let res = multi_scalar_mul(&points, &[FieldElement::one(), invalid_limb]);
+        let res = multi_scalar_mul(&points, &[FieldElement::one()], &[invalid_limb]);
         assert_eq!(res, expected_error);
 
-        let res = multi_scalar_mul(&points, &[invalid_limb, FieldElement::one()]);
+        let res = multi_scalar_mul(&points, &[invalid_limb], &[FieldElement::one()]);
         assert_eq!(res, expected_error);
     }
 
@@ -162,7 +181,7 @@ mod tests {
         let low = FieldElement::from_be_bytes_reduce(&x[16..32]);
         let high = FieldElement::from_be_bytes_reduce(&x[0..16]);
 
-        let res = multi_scalar_mul(&get_generator(), &[low, high]);
+        let res = multi_scalar_mul(&get_generator(), &[low], &[high]);
 
         assert_eq!(
             res,
@@ -181,8 +200,9 @@ mod tests {
         let valid_scalar_high = FieldElement::zero();
 
         let res = multi_scalar_mul(
-            &[invalid_point_x, invalid_point_y],
-            &[valid_scalar_low, valid_scalar_high],
+            &[invalid_point_x, invalid_point_y, FieldElement::zero()],
+            &[valid_scalar_low],
+            &[valid_scalar_high],
         );
 
         assert_eq!(
@@ -197,9 +217,10 @@ mod tests {
     #[test]
     fn throws_on_args_length_mismatch() {
         let points = get_generator();
-        let scalars = [FieldElement::from(2u128)];
+        let scalars_lo = [FieldElement::from(2u128)];
+        let scalars_hi = [];
 
-        let res = multi_scalar_mul(&points, &scalars);
+        let res = multi_scalar_mul(&points, &scalars_lo, &scalars_hi);
 
         assert_eq!(
             res,
@@ -215,7 +236,10 @@ mod tests {
         let x = FieldElement::from(1u128);
         let y = FieldElement::from(2u128);
 
-        let res = embedded_curve_add(x, y, x, y);
+        let res = embedded_curve_add(
+            [x, y, FieldElement::from(0u128)],
+            [x, y, FieldElement::from(0u128)],
+        );
 
         assert_eq!(
             res,
@@ -229,10 +253,14 @@ mod tests {
     #[test]
     fn output_of_msm_matches_add() -> Result<(), BlackBoxResolutionError> {
         let points = get_generator();
-        let scalars = [FieldElement::from(2u128), FieldElement::zero()];
-
-        let msm_res = multi_scalar_mul(&points, &scalars)?;
-        let add_res = embedded_curve_add(points[0], points[1], points[0], points[1])?;
+        let scalars_lo = [FieldElement::from(2u128)];
+        let scalars_hi = [FieldElement::zero()];
+
+        let msm_res = multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
+        let add_res = embedded_curve_add(
+            [points[0], points[1], FieldElement::from(0u128)],
+            [points[0], points[1], FieldElement::from(0u128)],
+        )?;
 
         assert_eq!(msm_res.0, add_res.0);
         assert_eq!(msm_res.1, add_res.1);
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index eebc65db141..43b86e083d5 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -82,19 +82,25 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
     fn multi_scalar_mul(
         &self,
         points: &[FieldElement],
-        scalars: &[FieldElement],
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        multi_scalar_mul(points, scalars)
+        scalars_lo: &[FieldElement],
+        scalars_hi: &[FieldElement],
+    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+        multi_scalar_mul(points, scalars_lo, scalars_hi)
     }
 
     fn ec_add(
         &self,
         input1_x: &FieldElement,
         input1_y: &FieldElement,
+        input1_infinite: &FieldElement,
         input2_x: &FieldElement,
         input2_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        embedded_curve_add(*input1_x, *input1_y, *input2_x, *input2_y)
+        input2_infinite: &FieldElement,
+    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+        embedded_curve_add(
+            [*input1_x, *input1_y, *input1_infinite],
+            [*input2_x, *input2_y, *input2_infinite],
+        )
     }
 
     fn poseidon2_permutation(
diff --git a/acvm-repo/brillig/src/black_box.rs b/acvm-repo/brillig/src/black_box.rs
index 15abc19ed90..3887092a8c2 100644
--- a/acvm-repo/brillig/src/black_box.rs
+++ b/acvm-repo/brillig/src/black_box.rs
@@ -83,8 +83,10 @@ pub enum BlackBoxOp {
     EmbeddedCurveAdd {
         input1_x: MemoryAddress,
         input1_y: MemoryAddress,
+        input1_infinite: MemoryAddress,
         input2_x: MemoryAddress,
         input2_y: MemoryAddress,
+        input2_infinite: MemoryAddress,
         result: HeapArray,
     },
     BigIntAdd {
@@ -126,4 +128,9 @@ pub enum BlackBoxOp {
         hash_values: HeapVector,
         output: HeapArray,
     },
+    ToRadix {
+        input: MemoryAddress,
+        radix: u32,
+        output: HeapArray,
+    },
 }
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index c999b5bf330..ebaa6976283 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -5,6 +5,7 @@ use acvm_blackbox_solver::{
     aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256,
     keccakf1600, sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
 };
+use num_bigint::BigUint;
 
 use crate::memory::MemoryValue;
 use crate::Memory;
@@ -156,22 +157,63 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::MultiScalarMul { points, scalars, outputs: result } => {
-            let points: Vec<FieldElement> =
-                read_heap_vector(memory, points).iter().map(|x| x.try_into().unwrap()).collect();
+            let points: Vec<FieldElement> = read_heap_vector(memory, points)
+                .iter()
+                .enumerate()
+                .map(|(i, x)| {
+                    if i % 3 == 2 {
+                        let is_infinite: bool = x.try_into().unwrap();
+                        FieldElement::from(is_infinite as u128)
+                    } else {
+                        x.try_into().unwrap()
+                    }
+                })
+                .collect();
             let scalars: Vec<FieldElement> =
                 read_heap_vector(memory, scalars).iter().map(|x| x.try_into().unwrap()).collect();
-
-            let (x, y) = solver.multi_scalar_mul(&points, &scalars)?;
-            memory.write_slice(memory.read_ref(result.pointer), &[x.into(), y.into()]);
+            let mut scalars_lo = Vec::with_capacity(scalars.len() / 2);
+            let mut scalars_hi = Vec::with_capacity(scalars.len() / 2);
+            for (i, scalar) in scalars.iter().enumerate() {
+                if i % 2 == 0 {
+                    scalars_lo.push(*scalar);
+                } else {
+                    scalars_hi.push(*scalar);
+                }
+            }
+            let (x, y, is_infinite) = solver.multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
+            memory.write_slice(
+                memory.read_ref(result.pointer),
+                &[x.into(), y.into(), is_infinite.into()],
+            );
             Ok(())
         }
-        BlackBoxOp::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, result } => {
+        BlackBoxOp::EmbeddedCurveAdd {
+            input1_x,
+            input1_y,
+            input2_x,
+            input2_y,
+            result,
+            input1_infinite,
+            input2_infinite,
+        } => {
             let input1_x = memory.read(*input1_x).try_into().unwrap();
             let input1_y = memory.read(*input1_y).try_into().unwrap();
+            let input1_infinite: bool = memory.read(*input1_infinite).try_into().unwrap();
             let input2_x = memory.read(*input2_x).try_into().unwrap();
             let input2_y = memory.read(*input2_y).try_into().unwrap();
-            let (x, y) = solver.ec_add(&input1_x, &input1_y, &input2_x, &input2_y)?;
-            memory.write_slice(memory.read_ref(result.pointer), &[x.into(), y.into()]);
+            let input2_infinite: bool = memory.read(*input2_infinite).try_into().unwrap();
+            let (x, y, infinite) = solver.ec_add(
+                &input1_x,
+                &input1_y,
+                &input1_infinite.into(),
+                &input2_x,
+                &input2_y,
+                &input2_infinite.into(),
+            )?;
+            memory.write_slice(
+                memory.read_ref(result.pointer),
+                &[x.into(), y.into(), infinite.into()],
+            );
             Ok(())
         }
         BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
@@ -295,6 +337,25 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             memory.write_slice(memory.read_ref(output.pointer), &state);
             Ok(())
         }
+        BlackBoxOp::ToRadix { input, radix, output } => {
+            let input: FieldElement =
+                memory.read(*input).try_into().expect("ToRadix input not a field");
+
+            let mut input = BigUint::from_bytes_be(&input.to_be_bytes());
+            let radix = BigUint::from(*radix);
+
+            let mut limbs: Vec<MemoryValue> = Vec::with_capacity(output.size);
+
+            for _ in 0..output.size {
+                let limb = &input % &radix;
+                limbs.push(FieldElement::from_be_bytes_reduce(&limb.to_bytes_be()).into());
+                input /= &radix;
+            }
+
+            memory.write_slice(memory.read_ref(output.pointer), &limbs);
+
+            Ok(())
+        }
     }
 }
 
@@ -321,6 +382,7 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::BigIntToLeBytes { .. } => BlackBoxFunc::BigIntToLeBytes,
         BlackBoxOp::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
         BlackBoxOp::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
+        BlackBoxOp::ToRadix { .. } => unreachable!("ToRadix is not an ACIR BlackBoxFunc"),
     }
 }
 
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 17ae999fb8f..5326920511b 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -1,17 +1,20 @@
 mod transforms;
 mod utils;
 
+use noirc_errors::Location;
 use transforms::{
     compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
     contract_interface::{
         generate_contract_interface, stub_function, update_fn_signatures_in_contract_interface,
     },
     events::{generate_selector_impl, transform_events},
-    functions::{export_fn_abi, transform_function, transform_unconstrained},
+    functions::{
+        check_for_public_args, export_fn_abi, transform_function, transform_unconstrained,
+    },
     note_interface::{generate_note_interface_impl, inject_note_exports},
     storage::{
         assign_storage_slots, check_for_storage_definition, check_for_storage_implementation,
-        generate_storage_implementation, generate_storage_layout,
+        generate_storage_implementation, generate_storage_layout, inject_context_in_storage,
     },
 };
 
@@ -64,6 +67,7 @@ fn transform(
     for submodule in ast.submodules.iter_mut().filter(|submodule| submodule.is_contract) {
         if transform_module(
             crate_id,
+            &file_id,
             context,
             &mut submodule.contents,
             submodule.name.0.contents.as_str(),
@@ -84,6 +88,7 @@ fn transform(
 /// Returns true if an annotated node is found, false otherwise
 fn transform_module(
     crate_id: &CrateId,
+    file_id: &FileId,
     context: &HirContext,
     module: &mut SortedModule,
     module_name: &str,
@@ -97,6 +102,7 @@ fn transform_module(
     let storage_defined = maybe_storage_struct_name.is_some();
 
     if let Some(ref storage_struct_name) = maybe_storage_struct_name {
+        inject_context_in_storage(module)?;
         if !check_for_storage_implementation(module, storage_struct_name) {
             generate_storage_implementation(module, storage_struct_name)?;
         }
@@ -132,6 +138,7 @@ fn transform_module(
         let mut is_initializer = false;
         let mut is_internal = false;
         let mut insert_init_check = has_initializer;
+        let mut is_static = false;
 
         for secondary_attribute in func.def.attributes.secondary.clone() {
             if is_custom_attribute(&secondary_attribute, "aztec(private)") {
@@ -148,6 +155,9 @@ fn transform_module(
             } else if is_custom_attribute(&secondary_attribute, "aztec(public-vm)") {
                 is_public_vm = true;
             }
+            if is_custom_attribute(&secondary_attribute, "aztec(view)") {
+                is_static = true;
+            }
         }
 
         // Apply transformations to the function based on collected attributes
@@ -159,7 +169,8 @@ fn transform_module(
             } else {
                 "Public"
             };
-            stubs.push(stub_function(fn_type, func));
+            let stub_src = stub_function(fn_type, func, is_static);
+            stubs.push((stub_src, Location { file: *file_id, span: func.name_ident().span() }));
 
             export_fn_abi(&mut module.types, func)?;
             transform_function(
@@ -169,6 +180,7 @@ fn transform_module(
                 is_initializer,
                 insert_init_check,
                 is_internal,
+                is_static,
             )?;
             has_transformed_module = true;
         } else if storage_defined && func.def.is_unconstrained {
@@ -180,7 +192,7 @@ fn transform_module(
     if has_transformed_module {
         // We only want to run these checks if the macro processor has found the module to be an Aztec contract.
 
-        let private_functions_count = module
+        let private_functions: Vec<_> = module
             .functions
             .iter()
             .filter(|func| {
@@ -190,9 +202,27 @@ fn transform_module(
                     .iter()
                     .any(|attr| is_custom_attribute(attr, "aztec(private)"))
             })
-            .count();
+            .collect();
+
+        let public_functions: Vec<_> = module
+            .functions
+            .iter()
+            .filter(|func| {
+                func.def
+                    .attributes
+                    .secondary
+                    .iter()
+                    .any(|attr| is_custom_attribute(attr, "aztec(public)"))
+            })
+            .collect();
+
+        let private_function_count = private_functions.len();
+
+        check_for_public_args(&private_functions)?;
+
+        check_for_public_args(&public_functions)?;
 
-        if private_functions_count > MAX_CONTRACT_PRIVATE_FUNCTIONS {
+        if private_function_count > MAX_CONTRACT_PRIVATE_FUNCTIONS {
             return Err(AztecMacroError::ContractHasTooManyPrivateFunctions {
                 span: Span::default(),
             });
diff --git a/aztec_macros/src/transforms/contract_interface.rs b/aztec_macros/src/transforms/contract_interface.rs
index 1afe0a30068..bb63357d251 100644
--- a/aztec_macros/src/transforms/contract_interface.rs
+++ b/aztec_macros/src/transforms/contract_interface.rs
@@ -1,4 +1,5 @@
-use noirc_frontend::ast::{NoirFunction, UnresolvedTypeData};
+use noirc_errors::Location;
+use noirc_frontend::ast::{Ident, NoirFunction, UnresolvedTypeData};
 use noirc_frontend::{
     graph::CrateId,
     macros_api::{FileId, HirContext, HirExpression, HirLiteral, HirStatement},
@@ -39,7 +40,7 @@ use crate::utils::{
 // }
 //
 // The selector placeholder has to be replaced with the actual function signature after type checking in the next macro pass
-pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
+pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call: bool) -> String {
     let fn_name = func.name().to_string();
     let fn_parameters = func
         .parameters()
@@ -59,6 +60,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
 
     let parameters = func.parameters();
     let is_void = if matches!(fn_return_type.typ, UnresolvedTypeData::Unit) { "Void" } else { "" };
+    let is_static = if is_static_call { "Static" } else { "" };
     let return_type_hint = if is_void == "Void" {
         "".to_string()
     } else {
@@ -75,7 +77,8 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
                 for i in 0..{0}.len() {{
                     args_acc = args_acc.append(hash_{0}[i].as_slice());
                 }}\n",
-                        param_name, typ.typ
+                        param_name,
+                        typ.typ.to_string().replace("plain::", "")
                     )
                 }
                 _ => {
@@ -100,18 +103,18 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
 
         let fn_body = format!(
             "{}
-                dep::aztec::context::{}{}CallInterface {{
+                dep::aztec::context::{}{}{}CallInterface {{
                     target_contract: self.target_contract,
                     selector: {},
                     args_hash,
                 }}",
-            args_hash, aztec_visibility, is_void, fn_selector,
+            args_hash, aztec_visibility, is_static, is_void, fn_selector,
         );
         format!(
-            "pub fn {}(self, {}) -> dep::aztec::context::{}{}CallInterface{} {{
+            "pub fn {}(self, {}) -> dep::aztec::context::{}{}{}CallInterface{} {{
                     {}
                 }}",
-            fn_name, fn_parameters, aztec_visibility, is_void, return_type_hint, fn_body
+            fn_name, fn_parameters, aztec_visibility, is_static, is_void, return_type_hint, fn_body
         )
     } else {
         let args = format!(
@@ -122,19 +125,19 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
         );
         let fn_body = format!(
             "{}
-            dep::aztec::context::Avm{}CallInterface {{
+            dep::aztec::context::Avm{}{}CallInterface {{
                 target_contract: self.target_contract,
                 selector: {},
                 args: args_acc,
                 gas_opts: dep::aztec::context::gas::GasOpts::default(),
             }}",
-            args, is_void, fn_selector,
+            args, is_static, is_void, fn_selector,
         );
         format!(
-            "pub fn {}(self, {}) -> dep::aztec::context::Avm{}CallInterface{} {{
+            "pub fn {}(self, {}) -> dep::aztec::context::Avm{}{}CallInterface{} {{
                     {}
             }}",
-            fn_name, fn_parameters, is_void, return_type_hint, fn_body
+            fn_name, fn_parameters, is_static, is_void, return_type_hint, fn_body
         )
     }
 }
@@ -145,7 +148,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction) -> String {
 pub fn generate_contract_interface(
     module: &mut SortedModule,
     module_name: &str,
-    stubs: &[String],
+    stubs: &[(String, Location)],
 ) -> Result<(), AztecMacroError> {
     let contract_interface = format!(
         "
@@ -171,7 +174,7 @@ pub fn generate_contract_interface(
         }}
     ",
         module_name,
-        stubs.join("\n"),
+        stubs.iter().map(|(src, _)| src.to_owned()).collect::<Vec<String>>().join("\n"),
     );
 
     let (contract_interface_ast, errors) = parse_program(&contract_interface);
@@ -181,8 +184,27 @@ pub fn generate_contract_interface(
     }
 
     let mut contract_interface_ast = contract_interface_ast.into_sorted();
+    let mut impl_with_locations = contract_interface_ast.impls.pop().unwrap();
+
+    impl_with_locations.methods = impl_with_locations
+        .methods
+        .iter()
+        .enumerate()
+        .map(|(i, (method, orig_span))| {
+            if method.name() == "at" {
+                (method.clone(), *orig_span)
+            } else {
+                let (_, new_location) = stubs[i];
+                let mut modified_method = method.clone();
+                modified_method.def.name =
+                    Ident::new(modified_method.name().to_string(), new_location.span);
+                (modified_method, *orig_span)
+            }
+        })
+        .collect();
+
     module.types.push(contract_interface_ast.types.pop().unwrap());
-    module.impls.push(contract_interface_ast.impls.pop().unwrap());
+    module.impls.push(impl_with_locations);
     module.functions.push(contract_interface_ast.functions.pop().unwrap());
 
     Ok(())
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 39d709ef520..00e9c444421 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -10,6 +10,7 @@ use noirc_frontend::ast::{
 
 use noirc_frontend::{macros_api::FieldElement, parse_program};
 
+use crate::utils::ast_utils::member_access;
 use crate::{
     chained_dep, chained_path,
     utils::{
@@ -33,6 +34,7 @@ pub fn transform_function(
     is_initializer: bool,
     insert_init_check: bool,
     is_internal: bool,
+    is_static: bool,
 ) -> Result<(), AztecMacroError> {
     let context_name = format!("{}Context", ty);
     let inputs_name = format!("{}ContextInputs", ty);
@@ -40,6 +42,12 @@ pub fn transform_function(
     let is_avm = ty == "Avm";
     let is_private = ty == "Private";
 
+    // Force a static context if the function is static
+    if is_static {
+        let is_static_check = create_static_check(func.name(), is_avm);
+        func.def.body.statements.insert(0, is_static_check);
+    }
+
     // Add check that msg sender equals this address and flag function as internal
     if is_internal {
         let is_internal_check = create_internal_check(func.name());
@@ -59,7 +67,7 @@ pub fn transform_function(
 
     // Add access to the storage struct
     if let Some(storage_struct_name) = storage_struct_name {
-        let storage_def = abstract_storage(storage_struct_name, &ty.to_lowercase(), false);
+        let storage_def = abstract_storage(storage_struct_name, false);
         func.def.body.statements.insert(0, storage_def);
     }
 
@@ -213,10 +221,7 @@ pub fn export_fn_abi(
 ///
 /// This will allow developers to access their contract' storage struct in unconstrained functions
 pub fn transform_unconstrained(func: &mut NoirFunction, storage_struct_name: String) {
-    func.def
-        .body
-        .statements
-        .insert(0, abstract_storage(storage_struct_name, "Unconstrained", true));
+    func.def.body.statements.insert(0, abstract_storage(storage_struct_name, true));
 }
 
 /// Helper function that returns what the private context would look like in the ast
@@ -275,6 +280,31 @@ fn create_mark_as_initialized(ty: &str) -> Statement {
     )))
 }
 
+/// Forces a static context for a function, ensuring that no state modifications are allowed
+///
+/// ```noir
+/// assert(context.inputs.call_context.is_static_call == true,  "Function can only be called statically")
+/// ```
+fn create_static_check(fname: &str, is_avm: bool) -> Statement {
+    let is_static_call_expr = if !is_avm {
+        ["inputs", "call_context", "is_static_call"]
+            .iter()
+            .fold(variable("context"), |acc, member| member_access(acc, member))
+    } else {
+        ["inputs", "is_static_call"]
+            .iter()
+            .fold(variable("context"), |acc, member| member_access(acc, member))
+    };
+    make_statement(StatementKind::Constrain(ConstrainStatement(
+        make_eq(is_static_call_expr, expression(ExpressionKind::Literal(Literal::Bool(true)))),
+        Some(expression(ExpressionKind::Literal(Literal::Str(format!(
+            "Function {} can only be called statically",
+            fname
+        ))))),
+        ConstrainKind::Assert,
+    )))
+}
+
 /// Creates a check for internal functions ensuring that the caller is self.
 ///
 /// ```noir
@@ -564,7 +594,7 @@ fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>,
 /// ```noir
 /// #[aztec(private)]
 /// fn lol() {
-///     let storage = Storage::init(Context::private(context));
+///     let storage = Storage::init(context);
 /// }
 /// ```
 ///
@@ -572,33 +602,28 @@ fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>,
 /// ```noir
 /// #[aztec(public)]
 /// fn lol() {
-///    let storage = Storage::init(Context::public(context));
+///    let storage = Storage::init(context);
 /// }
 /// ```
 ///
 /// For unconstrained functions:
 /// ```noir
 /// unconstrained fn lol() {
-///   let storage = Storage::init(Context::none());
+///   let storage = Storage::init(());
 /// }
-fn abstract_storage(storage_struct_name: String, typ: &str, unconstrained: bool) -> Statement {
-    let init_context_call = if unconstrained {
-        call(
-            variable_path(chained_dep!("aztec", "context", "Context", "none")), // Path
-            vec![],                                                             // args
-        )
+fn abstract_storage(storage_struct_name: String, unconstrained: bool) -> Statement {
+    let context_expr = if unconstrained {
+        // Note that the literal unit type (i.e. '()') is not the same as a tuple with zero elements
+        expression(ExpressionKind::Literal(Literal::Unit))
     } else {
-        call(
-            variable_path(chained_dep!("aztec", "context", "Context", typ)), // Path
-            vec![mutable_reference("context")],                              // args
-        )
+        mutable_reference("context")
     };
 
     assignment(
         "storage", // Assigned to
         call(
             variable_path(chained_path!(storage_struct_name.as_str(), "init")), // Path
-            vec![init_context_call],                                            // args
+            vec![context_expr],                                                 // args
         ),
     )
 }
@@ -792,3 +817,18 @@ fn add_cast_to_hasher(identifier: &Ident, hasher_name: &str) -> Statement {
         vec![cast_operation],  // args
     )))
 }
+
+/**
+ * Takes a vector of functions and checks for the presence of arguments with Public visibility
+ * Returns AztecMAcroError::PublicArgsDisallowed if found
+ */
+pub fn check_for_public_args(functions: &[&NoirFunction]) -> Result<(), AztecMacroError> {
+    for func in functions {
+        for param in &func.def.parameters {
+            if param.visibility == Visibility::Public {
+                return Err(AztecMacroError::PublicArgsDisallowed { span: func.span() });
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 1e3cc011715..0a210934827 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -1,7 +1,7 @@
 use noirc_errors::Span;
 use noirc_frontend::ast::{
     BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
-    NoirStruct, PathKind, Pattern, StatementKind, TypeImpl, UnresolvedType, UnresolvedTypeData,
+    NoirStruct, Pattern, StatementKind, TypeImpl, UnresolvedType, UnresolvedTypeData,
 };
 use noirc_frontend::{
     graph::CrateId,
@@ -16,7 +16,7 @@ use noirc_frontend::{
 };
 
 use crate::{
-    chained_dep, chained_path,
+    chained_path,
     utils::{
         ast_utils::{
             call, expression, ident, ident_path, is_custom_attribute, lambda, make_statement,
@@ -48,7 +48,58 @@ pub fn check_for_storage_definition(
     Ok(result.iter().map(|&r#struct| r#struct.name.0.contents.clone()).next())
 }
 
-// Check to see if the user has defined a storage struct
+// Injects the Context generic in each of the Storage struct fields to avoid boilerplate,
+// taking maps into account (including nested maps)
+fn inject_context_in_storage_field(field: &mut UnresolvedType) -> Result<(), AztecMacroError> {
+    match &mut field.typ {
+        UnresolvedTypeData::Named(path, generics, _) => {
+            generics.push(make_type(UnresolvedTypeData::Named(
+                ident_path("Context"),
+                vec![],
+                false,
+            )));
+            match path.segments.last().unwrap().0.contents.as_str() {
+                "Map" => inject_context_in_storage_field(&mut generics[1]),
+                _ => Ok(()),
+            }
+        }
+        _ => Err(AztecMacroError::CouldNotInjectContextGenericInStorage {
+            secondary_message: Some(format!("Unsupported type: {:?}", field.typ)),
+        }),
+    }
+}
+
+// Injects the Context generic in the storage struct to avoid boilerplate
+// Transforms this:
+// struct Storage {
+//     a_var: SomeStoragePrimitive<ASerializableType>,
+//     a_map: Map<Field, SomeStoragePrimitive<ASerializableType>>,
+// }
+//
+// Into this:
+//
+// struct Storage<Context> {
+//     a_var: SomeStoragePrimitive<ASerializableType, Context>,
+//     a_map: Map<Field, SomeStoragePrimitive<ASerializableType, Context>, Context>,
+// }
+pub fn inject_context_in_storage(module: &mut SortedModule) -> Result<(), AztecMacroError> {
+    let storage_struct = module
+        .types
+        .iter_mut()
+        .find(|r#struct| {
+            r#struct.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(storage)"))
+        })
+        .unwrap();
+    storage_struct.generics.push(ident("Context"));
+    storage_struct
+        .fields
+        .iter_mut()
+        .map(|(_, field)| inject_context_in_storage_field(field))
+        .collect::<Result<Vec<_>, _>>()?;
+    Ok(())
+}
+
+// Check to see if the user has defined an impl for the storage struct
 pub fn check_for_storage_implementation(
     module: &SortedModule,
     storage_struct_name: &String,
@@ -79,22 +130,22 @@ pub fn generate_storage_field_constructor(
                         variable("context"),
                         slot,
                         lambda(
+                            // This lambda will be equivalent to the following
+                            // | context, slot | { T::new(context, slot) }
+                            // Since the `new` function has type bindings for its arguments, we don't specify the types
+                            // of either context nor slot, and avoid that way having to deal with the generic context
+                            // type.
                             vec![
-                                (
-                                    pattern("context"),
-                                    make_type(UnresolvedTypeData::Named(
-                                        chained_dep!("aztec", "context", "Context"),
-                                        vec![],
-                                        true,
-                                    )),
-                                ),
+                                (pattern("context"), make_type(UnresolvedTypeData::Unspecified)),
                                 (
                                     Pattern::Identifier(ident("slot")),
-                                    make_type(UnresolvedTypeData::FieldElement),
+                                    make_type(UnresolvedTypeData::Unspecified),
                                 ),
                             ],
                             generate_storage_field_constructor(
-                                &(type_ident.clone(), generics.iter().last().unwrap().clone()),
+                                // Map is expected to have three generic parameters: key, value and context (i.e.
+                                // Map<K, V, Context>. Here `get(1)` fetches the value type.
+                                &(type_ident.clone(), generics.get(1).unwrap().clone()),
                                 variable("slot"),
                             )?,
                         ),
@@ -113,15 +164,15 @@ pub fn generate_storage_field_constructor(
 // Generates the Storage implementation block from the Storage struct definition if it does not exist
 /// From:
 ///
-/// struct Storage {
-///     a_map: Map<Field, SomeStoragePrimitive<ASerializableType>>,
-///     a_nested_map: Map<Field, Map<Field, SomeStoragePrimitive<ASerializableType>>>,
-///     a_field: SomeStoragePrimitive<ASerializableType>,
+/// struct Storage<Context> {
+///     a_map: Map<Field, SomeStoragePrimitive<ASerializableType, Context>, Context>,
+///     a_nested_map: Map<Field, Map<Field, SomeStoragePrimitive<ASerializableType, Context>, Context>, Context>,
+///     a_field: SomeStoragePrimitive<ASerializableType, Context>,
 /// }
 ///
 /// To:
 ///
-/// impl Storage {
+/// impl<Context> Storage<Contex> {
 ///    fn init(context: Context) -> Self {
 ///        Storage {
 ///             a_map: Map::new(context, 0, |context, slot| {
@@ -167,17 +218,15 @@ pub fn generate_storage_implementation(
         ExpressionKind::constructor((chained_path!(storage_struct_name), field_constructors)),
     )));
 
+    // This is the type over which the impl is generic.
+    let generic_context_ident = ident("Context");
+    let generic_context_type =
+        make_type(UnresolvedTypeData::Named(ident_path("Context"), vec![], true));
+
     let init = NoirFunction::normal(FunctionDefinition::normal(
         &ident("init"),
         &vec![],
-        &[(
-            ident("context"),
-            make_type(UnresolvedTypeData::Named(
-                chained_dep!("aztec", "context", "Context"),
-                vec![],
-                true,
-            )),
-        )],
+        &[(ident("context"), generic_context_type.clone())],
         &BlockExpression { statements: vec![storage_constructor_statement] },
         &[],
         &return_type(chained_path!("Self")),
@@ -185,11 +234,16 @@ pub fn generate_storage_implementation(
 
     let storage_impl = TypeImpl {
         object_type: UnresolvedType {
-            typ: UnresolvedTypeData::Named(chained_path!(storage_struct_name), vec![], true),
+            typ: UnresolvedTypeData::Named(
+                chained_path!(storage_struct_name),
+                vec![generic_context_type.clone()],
+                true,
+            ),
             span: Some(Span::default()),
         },
         type_span: Span::default(),
-        generics: vec![],
+        generics: vec![generic_context_ident],
+
         methods: vec![(init, Span::default())],
     };
     module.impls.push(storage_impl);
@@ -341,7 +395,9 @@ pub fn assign_storage_slots(
 
             let mut storage_slot: u64 = 1;
             for (index, (_, expr_id)) in storage_constructor_expression.fields.iter().enumerate() {
-                let fields = storage_struct.borrow().get_fields(&[]);
+                let fields = storage_struct
+                    .borrow()
+                    .get_fields(&storage_constructor_expression.struct_generics);
                 let (field_name, field_type) = fields.get(index).unwrap();
                 let new_call_expression = match context.def_interner.expression(expr_id) {
                     HirExpression::Call(hir_call_expression) => Ok(hir_call_expression),
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index ba51090c2be..4706be2df25 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -1,9 +1,9 @@
 use noirc_errors::{Span, Spanned};
 use noirc_frontend::ast::{
     BinaryOpKind, CallExpression, CastExpression, Expression, ExpressionKind, FunctionReturnType,
-    Ident, IndexExpression, InfixExpression, Lambda, LetStatement, MethodCallExpression,
-    NoirTraitImpl, Path, Pattern, PrefixExpression, Statement, StatementKind, TraitImplItem,
-    UnaryOp, UnresolvedType, UnresolvedTypeData,
+    Ident, IndexExpression, InfixExpression, Lambda, LetStatement, MemberAccessExpression,
+    MethodCallExpression, NoirTraitImpl, Path, Pattern, PrefixExpression, Statement, StatementKind,
+    TraitImplItem, UnaryOp, UnresolvedType, UnresolvedTypeData,
 };
 use noirc_frontend::token::SecondaryAttribute;
 
@@ -126,6 +126,13 @@ pub fn make_statement(kind: StatementKind) -> Statement {
     Statement { span: Span::default(), kind }
 }
 
+pub fn member_access(lhs: Expression, member: &str) -> Expression {
+    expression(ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
+        lhs,
+        rhs: ident(member),
+    })))
+}
+
 #[macro_export]
 macro_rules! chained_path {
     ( $base:expr ) => {
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index db86012a007..51aea3d052f 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -16,10 +16,12 @@ pub enum AztecMacroError {
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
     MultipleStorageDefinitions { span: Option<Span> },
     CouldNotExportStorageLayout { span: Option<Span>, secondary_message: Option<String> },
+    CouldNotInjectContextGenericInStorage { secondary_message: Option<String> },
     CouldNotExportFunctionAbi { span: Option<Span>, secondary_message: Option<String> },
     CouldNotGenerateContractInterface { secondary_message: Option<String> },
     EventError { span: Span, message: String },
     UnsupportedAttributes { span: Span, secondary_message: Option<String> },
+    PublicArgsDisallowed { span: Span },
 }
 
 impl From<AztecMacroError> for MacroError {
@@ -75,6 +77,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span,
             },
+            AztecMacroError::CouldNotInjectContextGenericInStorage { secondary_message } => MacroError {
+                primary_message: "Could not inject context generic in storage".to_string(),
+                secondary_message,
+                span: None
+            },
             AztecMacroError::CouldNotExportFunctionAbi { secondary_message, span } => MacroError {
                 primary_message: "Could not generate and export function abi".to_string(),
                 secondary_message,
@@ -95,6 +102,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span: Some(span),
             },
+            AztecMacroError::PublicArgsDisallowed { span } => MacroError {
+                primary_message: "Aztec functions can't have public arguments".to_string(),
+                secondary_message: None,
+                span: Some(span),
+            },
         }
     }
 }
diff --git a/compiler/integration-tests/scripts/codegen-verifiers.sh b/compiler/integration-tests/scripts/codegen-verifiers.sh
index e377a3ee3f8..abc26c4c465 100644
--- a/compiler/integration-tests/scripts/codegen-verifiers.sh
+++ b/compiler/integration-tests/scripts/codegen-verifiers.sh
@@ -1,26 +1,34 @@
 #!/usr/bin/env bash
 
+NARGO_BACKEND_PATH=${NARGO_BACKEND_PATH:-bb}
+
 self_path=$(dirname "$(readlink -f "$0")")
 
 repo_root=$self_path/../../..
 
-# Run codegen-verifier for 1_mul
+# We want to move all the contracts to the root of compiler/integration-tests
+contracts_dir=$self_path/../contracts
+rm -rf $contracts_dir
+mkdir $contracts_dir
+
+KEYS=$(mktemp -d)
+
+# Codegen verifier contract for 1_mul
 mul_dir=$repo_root/test_programs/execution_success/1_mul
-nargo --program-dir $mul_dir codegen-verifier
+nargo --program-dir $mul_dir compile
+$NARGO_BACKEND_PATH write_vk -b $mul_dir/target/1_mul.json -o $KEYS/1_mul 
+$NARGO_BACKEND_PATH contract -k $KEYS/1_mul -o $contracts_dir/1_mul.sol 
 
-# Run codegen-verifier for assert_statement
+# Codegen verifier contract for assert_statement
 assert_statement_dir=$repo_root/test_programs/execution_success/assert_statement
-nargo --program-dir $assert_statement_dir codegen-verifier
+nargo --program-dir $assert_statement_dir compile
+$NARGO_BACKEND_PATH write_vk -b $assert_statement_dir/target/assert_statement.json -o $KEYS/assert_statement
+$NARGO_BACKEND_PATH contract -k $KEYS/assert_statement -o $contracts_dir/assert_statement.sol
 
-# Run codegen-verifier for recursion
+# Codegen verifier contract for recursion
 recursion_dir=$repo_root/compiler/integration-tests/circuits/recursion
-nargo --program-dir $recursion_dir codegen-verifier
-
-# Copy compiled contracts from the root of compiler/integration-tests
-contracts_dir=$self_path/../contracts
-rm -rf $contracts_dir
-mkdir $contracts_dir
+nargo --program-dir $recursion_dir compile
+$NARGO_BACKEND_PATH write_vk -b $recursion_dir/target/recursion.json -o $KEYS/recursion
+$NARGO_BACKEND_PATH contract -k $KEYS/recursion ./ -o $contracts_dir/recursion.sol
 
-cp $mul_dir/contract/1_mul/plonk_vk.sol $contracts_dir/1_mul.sol
-cp $assert_statement_dir/contract/assert_statement/plonk_vk.sol $contracts_dir/assert_statement.sol
-cp $recursion_dir/contract/recursion/plonk_vk.sol $contracts_dir/recursion.sol
+rm -rf $KEYS
\ No newline at end of file
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 801c0b685a9..d7368f299b8 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -84,10 +84,6 @@ pub struct CompileOptions {
     #[arg(long, conflicts_with = "deny_warnings")]
     pub silence_warnings: bool,
 
-    /// Output ACIR gzipped bytecode instead of the JSON artefact
-    #[arg(long, hide = true)]
-    pub only_acir: bool,
-
     /// Disables the builtin Aztec macros being used in the compiler
     #[arg(long, hide = true)]
     pub disable_macros: bool,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index d982d864d06..f56c5daf315 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -207,15 +207,17 @@ pub(crate) fn convert_black_box_call(
         }
         BlackBoxFunc::EmbeddedCurveAdd => {
             if let (
-                [BrilligVariable::SingleAddr(input1_x), BrilligVariable::SingleAddr(input1_y), BrilligVariable::SingleAddr(input2_x), BrilligVariable::SingleAddr(input2_y)],
+                [BrilligVariable::SingleAddr(input1_x), BrilligVariable::SingleAddr(input1_y), BrilligVariable::SingleAddr(input1_infinite), BrilligVariable::SingleAddr(input2_x), BrilligVariable::SingleAddr(input2_y), BrilligVariable::SingleAddr(input2_infinite)],
                 [BrilligVariable::BrilligArray(result_array)],
             ) = (function_arguments, function_results)
             {
                 brillig_context.black_box_op_instruction(BlackBoxOp::EmbeddedCurveAdd {
                     input1_x: input1_x.address,
                     input1_y: input1_y.address,
+                    input1_infinite: input1_infinite.address,
                     input2_x: input2_x.address,
                     input2_y: input2_y.address,
+                    input2_infinite: input2_infinite.address,
                     result: result_array.to_heap_array(),
                 });
             } else {
@@ -233,9 +235,7 @@ pub(crate) fn convert_black_box_call(
         BlackBoxFunc::RANGE => unreachable!(
             "ICE: `BlackBoxFunc::RANGE` calls should be transformed into a `Instruction::Cast`"
         ),
-        BlackBoxFunc::RecursiveAggregation => unimplemented!(
-            "ICE: `BlackBoxFunc::RecursiveAggregation` is not implemented by the Brillig VM"
-        ),
+        BlackBoxFunc::RecursiveAggregation => {}
         BlackBoxFunc::BigIntAdd => {
             if let (
                 [BrilligVariable::SingleAddr(lhs), BrilligVariable::SingleAddr(lhs_modulus), BrilligVariable::SingleAddr(rhs), BrilligVariable::SingleAddr(rhs_modulus)],
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index f660c8e0b7a..6a4f9f5cc0e 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -488,8 +488,22 @@ impl<'block> BrilligBlock<'block> {
                 }
                 Value::Intrinsic(Intrinsic::ToRadix(endianness)) => {
                     let source = self.convert_ssa_single_addr_value(arguments[0], dfg);
-                    let radix = self.convert_ssa_single_addr_value(arguments[1], dfg);
-                    let limb_count = self.convert_ssa_single_addr_value(arguments[2], dfg);
+
+                    let radix: u32 = dfg
+                        .get_numeric_constant(arguments[1])
+                        .expect("Radix should be known")
+                        .try_to_u64()
+                        .expect("Radix should fit in u64")
+                        .try_into()
+                        .expect("Radix should be u32");
+
+                    let limb_count: usize = dfg
+                        .get_numeric_constant(arguments[2])
+                        .expect("Limb count should be known")
+                        .try_to_u64()
+                        .expect("Limb count should fit in u64")
+                        .try_into()
+                        .expect("Limb count should fit in usize");
 
                     let results = dfg.instruction_results(instruction_id);
 
@@ -511,7 +525,8 @@ impl<'block> BrilligBlock<'block> {
                         .extract_vector();
 
                     // Update the user-facing slice length
-                    self.brillig_context.cast_instruction(target_len, limb_count);
+                    self.brillig_context
+                        .usize_const_instruction(target_len.address, limb_count.into());
 
                     self.brillig_context.codegen_to_radix(
                         source,
@@ -524,7 +539,13 @@ impl<'block> BrilligBlock<'block> {
                 }
                 Value::Intrinsic(Intrinsic::ToBits(endianness)) => {
                     let source = self.convert_ssa_single_addr_value(arguments[0], dfg);
-                    let limb_count = self.convert_ssa_single_addr_value(arguments[1], dfg);
+                    let limb_count: usize = dfg
+                        .get_numeric_constant(arguments[1])
+                        .expect("Limb count should be known")
+                        .try_to_u64()
+                        .expect("Limb count should fit in u64")
+                        .try_into()
+                        .expect("Limb count should fit in usize");
 
                     let results = dfg.instruction_results(instruction_id);
 
@@ -549,21 +570,18 @@ impl<'block> BrilligBlock<'block> {
                         BrilligVariable::SingleAddr(..) => unreachable!("ICE: ToBits on non-array"),
                     };
 
-                    let radix = self.brillig_context.make_constant_instruction(2_usize.into(), 32);
-
                     // Update the user-facing slice length
-                    self.brillig_context.cast_instruction(target_len, limb_count);
+                    self.brillig_context
+                        .usize_const_instruction(target_len.address, limb_count.into());
 
                     self.brillig_context.codegen_to_radix(
                         source,
                         target_vector,
-                        radix,
+                        2,
                         limb_count,
                         matches!(endianness, Endian::Big),
                         1,
                     );
-
-                    self.brillig_context.deallocate_single_addr(radix);
                 }
                 _ => {
                     unreachable!("unsupported function call type {:?}", dfg[*func])
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index fadcdb22c15..2bd57dc9486 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -170,18 +170,21 @@ pub(crate) mod tests {
         fn multi_scalar_mul(
             &self,
             _points: &[FieldElement],
-            _scalars: &[FieldElement],
-        ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-            Ok((4_u128.into(), 5_u128.into()))
+            _scalars_lo: &[FieldElement],
+            _scalars_hi: &[FieldElement],
+        ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+            Ok((4_u128.into(), 5_u128.into(), 0_u128.into()))
         }
 
         fn ec_add(
             &self,
             _input1_x: &FieldElement,
             _input1_y: &FieldElement,
+            _input1_infinite: &FieldElement,
             _input2_x: &FieldElement,
             _input2_y: &FieldElement,
-        ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+            _input2_infinite: &FieldElement,
+        ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
             panic!("Path not trodden by this test")
         }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
index ab756217bcd..58166554e1d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -1,6 +1,7 @@
-use acvm::FieldElement;
-
-use crate::brillig::brillig_ir::BrilligBinaryOp;
+use acvm::{
+    acir::brillig::{BlackBoxOp, HeapArray},
+    FieldElement,
+};
 
 use super::{
     brillig_variable::{BrilligVector, SingleAddrVariable},
@@ -36,57 +37,46 @@ impl BrilligContext {
         &mut self,
         source_field: SingleAddrVariable,
         target_vector: BrilligVector,
-        radix: SingleAddrVariable,
-        limb_count: SingleAddrVariable,
+        radix: u32,
+        limb_count: usize,
         big_endian: bool,
         limb_bit_size: u32,
     ) {
         assert!(source_field.bit_size == FieldElement::max_num_bits());
-        assert!(radix.bit_size == 32);
-        assert!(limb_count.bit_size == 32);
-        let radix_as_field =
-            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
-        self.cast_instruction(radix_as_field, radix);
 
-        self.cast_instruction(SingleAddrVariable::new_usize(target_vector.size), limb_count);
+        self.usize_const_instruction(target_vector.size, limb_count.into());
         self.usize_const_instruction(target_vector.rc, 1_usize.into());
         self.codegen_allocate_array(target_vector.pointer, target_vector.size);
 
-        let shifted_field =
-            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
-        self.mov_instruction(shifted_field.address, source_field.address);
+        self.black_box_op_instruction(BlackBoxOp::ToRadix {
+            input: source_field.address,
+            radix,
+            output: HeapArray { pointer: target_vector.pointer, size: limb_count },
+        });
 
         let limb_field =
             SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
 
         let limb_casted = SingleAddrVariable::new(self.allocate_register(), limb_bit_size);
 
-        self.codegen_loop(target_vector.size, |ctx, iterator_register| {
-            // Compute the modulus
-            ctx.binary_instruction(
-                shifted_field,
-                radix_as_field,
-                limb_field,
-                BrilligBinaryOp::Modulo,
-            );
-            // Cast it
-            ctx.cast_instruction(limb_casted, limb_field);
-            // Write it
-            ctx.codegen_array_set(target_vector.pointer, iterator_register, limb_casted.address);
-            // Integer div the field
-            ctx.binary_instruction(
-                shifted_field,
-                radix_as_field,
-                shifted_field,
-                BrilligBinaryOp::UnsignedDiv,
-            );
-        });
+        if limb_bit_size != FieldElement::max_num_bits() {
+            self.codegen_loop(target_vector.size, |ctx, iterator_register| {
+                // Read the limb
+                ctx.codegen_array_get(target_vector.pointer, iterator_register, limb_field.address);
+                // Cast it
+                ctx.cast_instruction(limb_casted, limb_field);
+                // Write it
+                ctx.codegen_array_set(
+                    target_vector.pointer,
+                    iterator_register,
+                    limb_casted.address,
+                );
+            });
+        }
 
         // Deallocate our temporary registers
-        self.deallocate_single_addr(shifted_field);
         self.deallocate_single_addr(limb_field);
         self.deallocate_single_addr(limb_casted);
-        self.deallocate_single_addr(radix_as_field);
 
         if big_endian {
             self.codegen_reverse_vector_in_place(target_vector);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 667ccf6ddbe..def91f82bfd 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -334,7 +334,9 @@ impl DebugShow {
                     outputs
                 );
             }
-            BlackBoxOp::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, result } => {
+            BlackBoxOp::EmbeddedCurveAdd {
+                input1_x, input1_y, input2_x, input2_y, result, ..
+            } => {
                 debug_println!(
                     self.enable_debug_trace,
                     "  EMBEDDED_CURVE_ADD ({} {}) ({} {}) -> {}",
@@ -451,6 +453,15 @@ impl DebugShow {
                     output
                 );
             }
+            BlackBoxOp::ToRadix { input, radix, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  TO_RADIX {} {} -> {}",
+                    input,
+                    radix,
+                    output
+                );
+            }
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 732bd3cbc59..38e9bdfa8b8 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -7,7 +7,7 @@ use super::{
 };
 use acvm::{acir::brillig::MemoryAddress, FieldElement};
 
-pub(crate) const MAX_STACK_SIZE: usize = 1024;
+pub(crate) const MAX_STACK_SIZE: usize = 2048;
 
 impl BrilligContext {
     /// Creates an entry point artifact that will jump to the function label provided.
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 5f180edd05c..90cdbb650c2 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -8,7 +8,7 @@ use crate::ssa::ir::dfg::CallStack;
 use crate::ssa::ir::types::Type as SsaType;
 use crate::ssa::ir::{instruction::Endian, types::NumericType};
 use acvm::acir::circuit::brillig::{BrilligInputs, BrilligOutputs};
-use acvm::acir::circuit::opcodes::{BlockId, MemOp};
+use acvm::acir::circuit::opcodes::{BlockId, BlockType, MemOp};
 use acvm::acir::circuit::{AssertionPayload, ExpressionOrMemory, Opcode};
 use acvm::blackbox_solver;
 use acvm::brillig_vm::{MemoryValue, VMStatus, VM};
@@ -1776,6 +1776,7 @@ impl AcirContext {
         block_id: BlockId,
         len: usize,
         optional_value: Option<AcirValue>,
+        databus: BlockType,
     ) -> Result<(), InternalError> {
         let initialized_values = match optional_value {
             None => {
@@ -1790,7 +1791,11 @@ impl AcirContext {
             }
         };
 
-        self.acir_ir.push_opcode(Opcode::MemoryInit { block_id, init: initialized_values });
+        self.acir_ir.push_opcode(Opcode::MemoryInit {
+            block_id,
+            init: initialized_values,
+            block_type: databus,
+        });
 
         Ok(())
     }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index c1249ae41c8..d23f4abe5f5 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -293,14 +293,13 @@ impl GeneratedAcir {
             BlackBoxFunc::MultiScalarMul => BlackBoxFuncCall::MultiScalarMul {
                 points: inputs[0].clone(),
                 scalars: inputs[1].clone(),
-                outputs: (outputs[0], outputs[1]),
+                outputs: (outputs[0], outputs[1], outputs[2]),
             },
+
             BlackBoxFunc::EmbeddedCurveAdd => BlackBoxFuncCall::EmbeddedCurveAdd {
-                input1_x: inputs[0][0],
-                input1_y: inputs[1][0],
-                input2_x: inputs[2][0],
-                input2_y: inputs[3][0],
-                outputs: (outputs[0], outputs[1]),
+                input1: Box::new([inputs[0][0], inputs[1][0], inputs[2][0]]),
+                input2: Box::new([inputs[3][0], inputs[4][0], inputs[5][0]]),
+                outputs: (outputs[0], outputs[1], outputs[2]),
             },
             BlackBoxFunc::Keccak256 => {
                 let var_message_size = match inputs.to_vec().pop() {
@@ -684,8 +683,8 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
         // Recursive aggregation has a variable number of inputs
         BlackBoxFunc::RecursiveAggregation => None,
 
-        // Addition over the embedded curve: input are coordinates (x1,y1) and (x2,y2) of the Grumpkin points
-        BlackBoxFunc::EmbeddedCurveAdd => Some(4),
+        // Addition over the embedded curve: input are coordinates (x1,y1,infinite1) and (x2,y2,infinite2) of the Grumpkin points
+        BlackBoxFunc::EmbeddedCurveAdd => Some(6),
 
         // Big integer operations take in 0 inputs. They use constants for their inputs.
         BlackBoxFunc::BigIntAdd
@@ -735,7 +734,7 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         // Output of operations over the embedded curve
         // will be 2 field elements representing the point.
-        BlackBoxFunc::MultiScalarMul | BlackBoxFunc::EmbeddedCurveAdd => Some(2),
+        BlackBoxFunc::MultiScalarMul | BlackBoxFunc::EmbeddedCurveAdd => Some(3),
 
         // Big integer operations return a big integer
         BlackBoxFunc::BigIntAdd
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 2430a00fd4c..fefe5f6f8e6 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -29,6 +29,7 @@ use crate::brillig::brillig_ir::BrilligContext;
 use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig};
 use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
 pub(crate) use acir_ir::generated_acir::GeneratedAcir;
+use acvm::acir::circuit::opcodes::BlockType;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
@@ -1683,7 +1684,18 @@ impl<'a> Context<'a> {
         len: usize,
         value: Option<AcirValue>,
     ) -> Result<(), InternalError> {
-        self.acir_context.initialize_array(array, len, value)?;
+        let databus = if self.data_bus.call_data.is_some()
+            && self.block_id(&self.data_bus.call_data.unwrap()) == array
+        {
+            BlockType::CallData
+        } else if self.data_bus.return_data.is_some()
+            && self.block_id(&self.data_bus.return_data.unwrap()) == array
+        {
+            BlockType::ReturnData
+        } else {
+            BlockType::Memory
+        };
+        self.acir_context.initialize_array(array, len, value, databus)?;
         self.initialized_arrays.insert(array);
         Ok(())
     }
diff --git a/cspell.json b/cspell.json
index eaf3fcd1b00..b4f214c2f27 100644
--- a/cspell.json
+++ b/cspell.json
@@ -63,6 +63,12 @@
         "defunctionalization",
         "defunctionalize",
         "defunctionalized",
+        "demonomorphization",
+        "demonomorphize",
+        "demonomorphized",
+        "demonomorphizer",
+        "demonomorphizes",
+        "demonomorphizing",
         "deque",
         "desugared",
         "devcontainer",
diff --git a/docs/docs/getting_started/barretenberg/_category_.json b/docs/docs/getting_started/barretenberg/_category_.json
new file mode 100644
index 00000000000..27a8e89228d
--- /dev/null
+++ b/docs/docs/getting_started/barretenberg/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 1,
+    "label": "Install Barretenberg",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/docs/getting_started/barretenberg/index.md b/docs/docs/getting_started/barretenberg/index.md
new file mode 100644
index 00000000000..048ba39f046
--- /dev/null
+++ b/docs/docs/getting_started/barretenberg/index.md
@@ -0,0 +1,53 @@
+---
+title: Barretenberg Installation
+description: bb is a command line tool for interacting with Aztec's proving backend Barretenberg. This page is a quick guide on how to install `bb`
+keywords: [
+  Barretenberg
+  bb
+  Installation
+  Terminal Commands
+  Version Check
+  Nightlies
+  Specific Versions
+  Branches
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`bb` is the CLI tool for generating and verifying proofs for Noir programs using the Barretenberg proving library. It also allows generating solidity verifier contracts for which you can verify contracts which were constructed using `bb`.
+
+## Installing `bb`
+
+Open a terminal on your machine, and write:
+
+##### macOS (Apple Silicon)
+
+```bash
+mkdir -p $HOME/.barretenberg && \
+curl -o ./barretenberg-aarch64-apple-darwin.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.38.0/barretenberg-aarch64-apple-darwin.tar.gz && \
+tar -xvf ./barretenberg-aarch64-apple-darwin.tar.gz -C $HOME/.barretenberg/ && \
+echo 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.zshrc && \
+source ~/.zshrc
+```
+
+##### macOS (Intel)
+
+```bash
+mkdir -p $HOME/.barretenberg && \
+curl -o ./barretenberg-x86_64-apple-darwin.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.38.0/barretenberg-x86_64-apple-darwin.tar.gz && \
+tar -xvf ./barretenberg-x86_64-apple-darwin.tar.gz -C $HOME/.barretenberg/ && \
+echo 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.zshrc && \
+source ~/.zshrc
+```
+
+##### Linux (Bash)
+
+```bash
+mkdir -p $HOME/.barretenberg && \
+curl -o ./barretenberg-x86_64-linux-gnu.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.38.0/barretenberg-x86_64-linux-gnu.tar.gz && \
+tar -xvf ./barretenberg-x86_64-linux-gnu.tar.gz -C $HOME/.barretenberg/ && \
+echo -e 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.bashrc && \
+source ~/.bashrc
+```
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/docs/getting_started/hello_noir/_category_.json b/docs/docs/getting_started/hello_noir/_category_.json
index 23b560f610b..976a2325de0 100644
--- a/docs/docs/getting_started/hello_noir/_category_.json
+++ b/docs/docs/getting_started/hello_noir/_category_.json
@@ -1,5 +1,5 @@
 {
-    "position": 1,
+    "position": 2,
     "collapsible": true,
     "collapsed": true
 }
diff --git a/docs/docs/getting_started/hello_noir/index.md b/docs/docs/getting_started/hello_noir/index.md
index 743c4d8d634..1ade3f09ae3 100644
--- a/docs/docs/getting_started/hello_noir/index.md
+++ b/docs/docs/getting_started/hello_noir/index.md
@@ -90,13 +90,11 @@ cd hello_world
 nargo check
 ```
 
-Two additional files would be generated in your project directory:
+A _Prover.toml_ file will be generated in your project directory, to allow specifying input values to the program.
 
-_Prover.toml_ houses input values, and _Verifier.toml_ houses public values.
+## Execute Our Noir Program
 
-## Prove Our Noir Program
-
-Now that the project is set up, we can create a proof of correct execution of our Noir program.
+Now that the project is set up, we can execute our Noir program.
 
 Fill in input values for execution in the _Prover.toml_ file. For example:
 
@@ -105,37 +103,42 @@ x = "1"
 y = "2"
 ```
 
-Prove the valid execution of your Noir program:
+Execute your Noir program:
 
 ```sh
-nargo prove
+nargo execute witness-name
 ```
 
-A new folder _proofs_ would then be generated in your project directory, containing the proof file
-`<project-name>.proof`, where the project name is defined in Nargo.toml.
+The witness corresponding to this execution will then be written to the file `./target/witness-name.gz`.
 
-The _Verifier.toml_ file would also be updated with the public values computed from program
-execution (in this case the value of `y`):
+## Prove Our Noir Program
 
-```toml
-y = "0x0000000000000000000000000000000000000000000000000000000000000002"
+:::info
+
+Nargo no longer handles communicating with backends in order to generate proofs. In order to prove/verify your Noir programs, you'll need an installation of [bb](../barretenberg/index.md).
+
+:::
+
+Prove the valid execution of your Noir program using `bb`:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/witness-name.gz -o ./proof
 ```
 
-> **Note:** Values in _Verifier.toml_ are computed as 32-byte hex values.
+A new file called `proof` will be generated in your project directory, containing the generated proof for your program.
 
 ## Verify Our Noir Program
 
-Once a proof is generated, we can verify correct execution of our Noir program by verifying the
-proof file.
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the proof file.
 
 Verify your proof by running:
 
 ```sh
-nargo verify
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./proof
 ```
 
-The verification will complete in silence if it is successful. If it fails, it will log the
-corresponding error instead.
+The verification will complete in silence if it is successful. If it fails, it will log the corresponding error instead.
 
 Congratulations, you have now created and verified a proof for your very first Noir program!
 
diff --git a/docs/docs/getting_started/hello_noir/project_breakdown.md b/docs/docs/getting_started/hello_noir/project_breakdown.md
index 6160a102c6c..29688df148f 100644
--- a/docs/docs/getting_started/hello_noir/project_breakdown.md
+++ b/docs/docs/getting_started/hello_noir/project_breakdown.md
@@ -1,10 +1,10 @@
 ---
 title: Project Breakdown
 description:
-  Learn about the anatomy of a Nargo project, including the purpose of the Prover and Verifier TOML
-  files, and how to prove and verify your program.
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
 keywords:
-  [Nargo, Nargo project, Prover.toml, Verifier.toml, proof verification, private asset transfer]
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
 sidebar_position: 2 
 ---
 
@@ -18,7 +18,6 @@ commands, you would get a minimal Nargo project of the following structure:
 
     - src
     - Prover.toml
-    - Verifier.toml
     - Nargo.toml
 
 The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
@@ -28,10 +27,6 @@ file will be generated within it.
 
 _Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
 
-### Verifier.toml
-
-_Verifier.toml_ contains public in/output values computed when executing the Noir program.
-
 ### Nargo.toml
 
 _Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
@@ -92,20 +87,15 @@ fn main(x : Field, y : Field) {
 }
 ```
 
-The parameters `x` and `y` can be seen as the API for the program and must be supplied by the
-prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when
-verifying the proof.
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
 
 The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
 
-As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is
-constrained by the proof of the execution of said program (i.e. if the condition was not met, the
-verifier would reject the proof as an invalid proof).
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
 
 ### Prover.toml
 
-The _Prover.toml_ file is a file which the prover uses to supply his witness values(both private and
-public).
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
 
 In our hello world program the _Prover.toml_ file looks like this:
 
@@ -114,12 +104,9 @@ x = "1"
 y = "2"
 ```
 
-When the command `nargo prove` is executed, two processes happen:
-
-1. Noir creates a proof that `x`, which holds the value of `1`, and `y`, which holds the value of `2`,
-   is not equal. This inequality constraint is due to the line `assert(x != y)`.
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
 
-2. Noir creates and stores the proof of this statement in the _proofs_ directory in a file called your-project.proof. So if your project is named "private_voting" (defined in the project Nargo.toml), the proof will be saved at `./proofs/private_voting.proof`. Opening this file will display the proof in hex format.
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
 
 #### Arrays of Structs
 
@@ -155,45 +142,18 @@ baz = 2
 
 #### Custom toml files
 
-You can specify a `toml` file with a different name to use for proving by using the `--prover-name` or `-p` flags.
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
 
-This command looks for proof inputs in the default **Prover.toml** and generates the proof and saves it at `./proofs/<project-name>.proof`:
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
 
 ```bash
-nargo prove
+nargo execute foo
 ```
 
-This command looks for proof inputs in the custom **OtherProver.toml** and generates proof and saves it at `./proofs/<project-name>.proof`:
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
 
 ```bash
-nargo prove -p OtherProver
+nargo execute -p OtherProver bar
 ```
 
-## Verifying a Proof
-
-When the command `nargo verify` is executed, two processes happen:
-
-1. Noir checks in the _proofs_ directory for a proof file with the project name (eg. test_project.proof)
-
-2. If that file is found, the proof's validity is checked
-
-> **Note:** The validity of the proof is linked to the current Noir program; if the program is
-> changed and the verifier verifies the proof, it will fail because the proof is not valid for the
-> _modified_ Noir program.
-
-In production, the prover and the verifier are usually two separate entities. A prover would
-retrieve the necessary inputs, execute the Noir program, generate a proof and pass it to the
-verifier. The verifier would then retrieve the public inputs, usually from external sources, and
-verify the validity of the proof against it.
-
-Take a private asset transfer as an example:
-
-A person using a browser as the prover would retrieve private inputs locally (e.g. the user's private key) and
-public inputs (e.g. the user's encrypted balance on-chain), compute the transfer, generate a proof
-and submit it to the verifier smart contract.
-
-The verifier contract would then draw the user's encrypted balance directly from the blockchain and
-verify the proof submitted against it. If the verification passes, additional functions in the
-verifier contract could trigger (e.g. approve the asset transfer).
-
 Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/docs/getting_started/tooling/noir_codegen.md b/docs/docs/getting_started/tooling/noir_codegen.md
index d65151da0ab..1c040585340 100644
--- a/docs/docs/getting_started/tooling/noir_codegen.md
+++ b/docs/docs/getting_started/tooling/noir_codegen.md
@@ -2,7 +2,7 @@
 title: Noir Codegen for TypeScript
 description: Learn how to use Noir codegen to generate TypeScript bindings 
 keywords: [Nargo, Noir, compile, TypeScript]
-sidebar_position: 2
+sidebar_position: 3
 ---
 
 When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index 8cf8035a5c4..5f427f1e23f 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -177,7 +177,7 @@ interface ForeignCallResult {
 
 ## Step 3 - Usage with Nargo
 
-Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test`, `nargo execute` and `nargo prove` commands by passing a value to `--oracle-resolver`. For example:
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
 
 ```bash
 nargo test --oracle-resolver http://localhost:5555
@@ -203,7 +203,7 @@ As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_j
 
 Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
 
-You don't technically have to, but then how would you run `nargo test` or `nargo prove`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
 
 :::
 
diff --git a/docs/docs/how_to/how-to-solidity-verifier.md b/docs/docs/how_to/how-to-solidity-verifier.md
index e3c7c1065da..7c96e22b8d5 100644
--- a/docs/docs/how_to/how-to-solidity-verifier.md
+++ b/docs/docs/how_to/how-to-solidity-verifier.md
@@ -43,11 +43,19 @@ Generating a Solidity Verifier contract is actually a one-command process. Howev
 This is by far the most straight-forward step. Just run:
 
 ```sh
-nargo codegen-verifier
+nargo compile
 ```
 
-A new `contract` folder would then be generated in your project directory, containing the Solidity
-file `plonk_vk.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
 
 :::info
 
@@ -123,11 +131,25 @@ To verify a proof using the Solidity verifier contract, we call the `verify` fun
 function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
 ```
 
-When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. For `_proof`, run `nargo prove` and use the string in `proof/<file>.proof` (adding the hex `0x` prefix). We can also copy the public input from `Verifier.toml`, as it will be properly formatted as 32-byte strings:
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
 
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/hello_noir/index.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the 
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
 ```
-0x...<proof bytes>... , [0x0000.....02]
-```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
 
 A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
 
@@ -144,11 +166,9 @@ function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 null
 
 :::info[Return Values]
 
-A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in
-Noir.
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
 
-Under the hood, the return value is passed as an input to the circuit and is checked at the end of
-the circuit program.
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
 
 For example, if you have Noir program like this:
 
@@ -162,11 +182,11 @@ fn main(
 ) -> pub Field
 ```
 
-the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value. Like before, these values are populated in Verifier.toml after running `nargo prove`.
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
 
 Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
 
-In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return]`.
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
 
 :::
 
diff --git a/docs/docs/noir/concepts/data_types/booleans.md b/docs/docs/noir/concepts/data_types/booleans.md
index 69826fcd724..3dcfa836814 100644
--- a/docs/docs/noir/concepts/data_types/booleans.md
+++ b/docs/docs/noir/concepts/data_types/booleans.md
@@ -23,9 +23,6 @@ fn main() {
 }
 ```
 
-> **Note:** When returning a boolean value, it will show up as a value of 1 for `true` and 0 for
-> `false` in _Verifier.toml_.
-
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
 statements. More about conditionals is covered in the [Control Flow](../control_flow) and
 [Assert Function](../assert) sections.
diff --git a/docs/docs/noir/concepts/data_types/integers.md b/docs/docs/noir/concepts/data_types/integers.md
index 6b2d3773912..c14fffa7174 100644
--- a/docs/docs/noir/concepts/data_types/integers.md
+++ b/docs/docs/noir/concepts/data_types/integers.md
@@ -115,7 +115,7 @@ y = "1"
 Would result in:
 
 ```
-$ nargo prove
+$ nargo execute
 error: Assertion failed: 'attempt to add with overflow'
 ┌─ ~/src/main.nr:9:13
 │
diff --git a/examples/codegen_verifier/.gitignore b/examples/codegen_verifier/.gitignore
new file mode 100644
index 00000000000..c0d62c447d3
--- /dev/null
+++ b/examples/codegen_verifier/.gitignore
@@ -0,0 +1,4 @@
+out
+cache
+target
+src/contract.sol
\ No newline at end of file
diff --git a/examples/codegen_verifier/Nargo.toml b/examples/codegen_verifier/Nargo.toml
new file mode 100644
index 00000000000..2b367f30dbc
--- /dev/null
+++ b/examples/codegen_verifier/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "hello_world"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/examples/codegen_verifier/Prover.toml b/examples/codegen_verifier/Prover.toml
new file mode 100644
index 00000000000..2c1854573a4
--- /dev/null
+++ b/examples/codegen_verifier/Prover.toml
@@ -0,0 +1,2 @@
+x = 1
+y = 2
diff --git a/examples/codegen_verifier/codegen_verifier.sh b/examples/codegen_verifier/codegen_verifier.sh
new file mode 100755
index 00000000000..fabd6235a67
--- /dev/null
+++ b/examples/codegen_verifier/codegen_verifier.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+set -eu
+
+BACKEND=${BACKEND:-bb}
+
+nargo compile
+
+# TODO: backend should automatically generate vk if necessary.
+$BACKEND write_vk -b ./target/hello_world.json
+$BACKEND contract -o ./src/contract.sol
+
+# We now generate a proof and check whether the verifier contract will verify it.
+
+nargo execute witness
+
+PROOF_PATH=./target/proof
+$BACKEND prove -b ./target/hello_world.json -w ./target/witness.gz -o $PROOF_PATH
+
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=$((32 * $NUM_PUBLIC_INPUTS))
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES $PROOF_PATH | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) $PROOF_PATH | od -An -v -t x1 | tr -d $' \n')
+
+# Spin up an anvil node to deploy the contract to
+anvil &
+
+DEPLOY_INFO=$(forge create UltraVerifier \
+    --rpc-url "127.0.0.1:8545" \
+    --private-key "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" \
+    --json)
+VERIFIER_ADDRESS=$(echo $DEPLOY_INFO | jq -r '.deployedTo')
+
+# Call the verifier contract with our proof.
+# Note that we haven't needed to split up `HEX_PUBLIC_INPUTS` as there's only a single public input
+cast call $VERIFIER_ADDRESS "verify(bytes, bytes32[])(bool)" "0x$HEX_PROOF" "[0x$HEX_PUBLIC_INPUTS]"
+
+# Stop anvil node again
+kill %-
\ No newline at end of file
diff --git a/examples/codegen_verifier/foundry.toml b/examples/codegen_verifier/foundry.toml
new file mode 100644
index 00000000000..25b918f9c9a
--- /dev/null
+++ b/examples/codegen_verifier/foundry.toml
@@ -0,0 +1,6 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+
+# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
diff --git a/examples/codegen_verifier/src/main.nr b/examples/codegen_verifier/src/main.nr
new file mode 100644
index 00000000000..baef0c3786a
--- /dev/null
+++ b/examples/codegen_verifier/src/main.nr
@@ -0,0 +1,3 @@
+fn main(x: Field, y: pub Field) {
+    assert(x != y);
+}
\ No newline at end of file
diff --git a/examples/codegen_verifier/test.sh b/examples/codegen_verifier/test.sh
new file mode 100755
index 00000000000..93c2f6edf51
--- /dev/null
+++ b/examples/codegen_verifier/test.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+set -eu
+
+# This file is used for Noir CI and is not required.
+
+BACKEND=${BACKEND:-bb}
+
+rm -f ./src/contract.sol
+
+./codegen_verifier.sh
+
+if ! [ -f ./src/contract.sol ]; then 
+    printf '%s\n' "Contract not written to file" >&2
+    exit 1
+fi
\ No newline at end of file
diff --git a/examples/prove_and_verify/Nargo.toml b/examples/prove_and_verify/Nargo.toml
new file mode 100644
index 00000000000..2b367f30dbc
--- /dev/null
+++ b/examples/prove_and_verify/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "hello_world"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/examples/prove_and_verify/Prover.toml b/examples/prove_and_verify/Prover.toml
new file mode 100644
index 00000000000..8c12ebba6cf
--- /dev/null
+++ b/examples/prove_and_verify/Prover.toml
@@ -0,0 +1,2 @@
+x = "1"
+y = "2"
diff --git a/examples/prove_and_verify/proofs/proof b/examples/prove_and_verify/proofs/proof
new file mode 100644
index 0000000000000000000000000000000000000000..01d5ad276865ced1d94c7e1be9a84e09e0d6cb50
GIT binary patch
literal 2176
zcmV-`2!Hng000000000000000000000000000000000000006J0S8cdAa>aDI1er`
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
C5)-Ka

literal 0
HcmV?d00001

diff --git a/examples/prove_and_verify/prove_and_verify.sh b/examples/prove_and_verify/prove_and_verify.sh
new file mode 100755
index 00000000000..01ee6c70738
--- /dev/null
+++ b/examples/prove_and_verify/prove_and_verify.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+set -eu
+
+BACKEND=${BACKEND:-bb}
+
+nargo execute witness
+
+# TODO: `bb` should create `proofs` directory if it doesn't exist.
+mkdir -p proofs
+$BACKEND prove -b ./target/hello_world.json -w ./target/witness.gz
+
+# TODO: backend should automatically generate vk if necessary.
+$BACKEND write_vk -b ./target/hello_world.json
+$BACKEND verify -v ./target/vk -p ./proofs/proof
\ No newline at end of file
diff --git a/examples/prove_and_verify/src/main.nr b/examples/prove_and_verify/src/main.nr
new file mode 100644
index 00000000000..baef0c3786a
--- /dev/null
+++ b/examples/prove_and_verify/src/main.nr
@@ -0,0 +1,3 @@
+fn main(x: Field, y: pub Field) {
+    assert(x != y);
+}
\ No newline at end of file
diff --git a/examples/prove_and_verify/test.sh b/examples/prove_and_verify/test.sh
new file mode 100755
index 00000000000..a8ae3cca132
--- /dev/null
+++ b/examples/prove_and_verify/test.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+set -eu
+
+# This file is used for Noir CI and is not required.
+
+BACKEND=${BACKEND:-bb}
+
+rm -rf ./target ./proofs
+
+./prove_and_verify.sh
\ No newline at end of file
diff --git a/noir_stdlib/src/aes128.nr b/noir_stdlib/src/aes128.nr
index e6e2a5e4997..cd61021a953 100644
--- a/noir_stdlib/src/aes128.nr
+++ b/noir_stdlib/src/aes128.nr
@@ -2,3 +2,6 @@
 // docs:start:aes128
 pub fn aes128_encrypt<N>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
 // docs:end:aes128
+
+#[foreign(aes128_encrypt)]
+pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
diff --git a/noir_stdlib/src/embedded_curve_ops.nr b/noir_stdlib/src/embedded_curve_ops.nr
index 21d658db615..cd8c421e136 100644
--- a/noir_stdlib/src/embedded_curve_ops.nr
+++ b/noir_stdlib/src/embedded_curve_ops.nr
@@ -1,15 +1,21 @@
 use crate::ops::arith::{Add, Sub, Neg};
+use crate::cmp::Eq;
 
 // TODO(https://github.com/noir-lang/noir/issues/4931)
 struct EmbeddedCurvePoint {
     x: Field,
     y: Field,
+    is_infinite: bool
 }
 
 impl EmbeddedCurvePoint {
     fn double(self) -> EmbeddedCurvePoint {
         embedded_curve_add(self, self)
     }
+
+    fn point_at_infinity() -> EmbeddedCurvePoint {
+        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }
+    }
 }
 
 impl Add for EmbeddedCurvePoint {
@@ -28,11 +34,24 @@ impl Neg for EmbeddedCurvePoint {
     fn neg(self) -> EmbeddedCurvePoint { 
         EmbeddedCurvePoint {
             x: self.x,
-            y: -self.y
+            y: -self.y,
+            is_infinite: self.is_infinite
         }
     }
 }
 
+impl Eq for EmbeddedCurvePoint {
+    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {
+        (self.is_infinite & b.is_infinite) | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))
+    }
+}
+
+// Scalar represented as low and high limbs
+struct EmbeddedCurveScalar {
+    lo: Field,
+    hi: Field,
+}
+
 // Computes a multi scalar multiplication over the embedded curve.
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.
@@ -42,9 +61,9 @@ impl Neg for EmbeddedCurvePoint {
 #[foreign(multi_scalar_mul)]
 // docs:start:multi_scalar_mul
 pub fn multi_scalar_mul<N>(
-    points: [Field; N], // points represented as x and y coordinates [x1, y1, x2, y2, ...]
-    scalars: [Field; N] // scalars represented as low and high limbs [low1, high1, low2, high2, ...]
-) -> [Field; 2]
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N]
+) -> [Field; 3]
 // docs:end:multi_scalar_mul
 {}
 
@@ -52,12 +71,12 @@ pub fn multi_scalar_mul<N>(
 pub fn fixed_base_scalar_mul(
     scalar_low: Field,
     scalar_high: Field
-) -> [Field; 2]
+) -> [Field; 3]
 // docs:end:fixed_base_scalar_mul
 {
-    let g1_x = 1;
-    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
-    multi_scalar_mul([g1_x, g1_y], [scalar_low, scalar_high])
+    let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+    let scalar = EmbeddedCurveScalar { lo: scalar_low, hi: scalar_high };
+    multi_scalar_mul([g1], [scalar])
 }
 
 // This is a hack as returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray
@@ -72,8 +91,8 @@ fn embedded_curve_add(
     let point_array = embedded_curve_add_array_return(point1, point2);
     let x = point_array[0];
     let y = point_array[1];
-    EmbeddedCurvePoint { x, y }
+    EmbeddedCurvePoint { x, y, is_infinite: point_array[2] == 1 }
 }
 
 #[foreign(embedded_curve_add)]
-fn embedded_curve_add_array_return(_point1: EmbeddedCurvePoint, _point2: EmbeddedCurvePoint) -> [Field; 2] {}
+fn embedded_curve_add_array_return(_point1: EmbeddedCurvePoint, _point2: EmbeddedCurvePoint) -> [Field; 3] {}
diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index d70310be391..2e82d9e7c23 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -25,7 +25,7 @@ unconstrained fn decompose_unsafe(x: Field) -> (Field, Field) {
 fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
     let (alo, ahi) = a;
     let (blo, bhi) = b;
-    let borrow = lte_unsafe(alo, blo, 16);
+    let borrow = lte_unsafe_16(alo, blo);
 
     let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
     let rhi = ahi - bhi - (borrow as Field);
@@ -51,9 +51,9 @@ pub fn decompose(x: Field) -> (Field, Field) {
     (xlo, xhi)
 }
 
-unconstrained fn lt_unsafe(x: Field, y: Field, num_bytes: u32) -> bool {
-    let x_bytes = x.__to_le_radix(256, num_bytes);
-    let y_bytes = y.__to_le_radix(256, num_bytes);
+fn lt_unsafe_internal(x: Field, y: Field, num_bytes: u32) -> bool {
+    let x_bytes = x.to_le_radix(256, num_bytes);
+    let y_bytes = y.to_le_radix(256, num_bytes);
     let mut x_is_lt = false;
     let mut done = false;
     for i in 0..num_bytes {
@@ -70,8 +70,20 @@ unconstrained fn lt_unsafe(x: Field, y: Field, num_bytes: u32) -> bool {
     x_is_lt
 }
 
-unconstrained fn lte_unsafe(x: Field, y: Field, num_bytes: u32) -> bool {
-    lt_unsafe(x, y, num_bytes) | (x == y)
+fn lte_unsafe_internal(x: Field, y: Field, num_bytes: u32) -> bool {
+    if x == y {
+        true
+    } else {
+        lt_unsafe_internal(x, y, num_bytes)
+    }
+}
+
+unconstrained fn lt_unsafe_32(x: Field, y: Field) -> bool {
+    lt_unsafe_internal(x, y, 32)
+}
+
+unconstrained fn lte_unsafe_16(x: Field, y: Field) -> bool {
+    lte_unsafe_internal(x, y, 16)
 }
 
 pub fn assert_gt(a: Field, b: Field) {
@@ -90,7 +102,7 @@ pub fn assert_lt(a: Field, b: Field) {
 pub fn gt(a: Field, b: Field) -> bool {
     if a == b {
         false
-    } else if lt_unsafe(a, b, 32) {
+    } else if lt_unsafe_32(a, b) {
         assert_gt(b, a);
         false
     } else {
@@ -105,7 +117,10 @@ pub fn lt(a: Field, b: Field) -> bool {
 
 mod tests {
     // TODO: Allow imports from "super"
-    use crate::field::bn254::{decompose_unsafe, decompose, lt_unsafe, assert_gt, gt, lt, TWO_POW_128, lte_unsafe, PLO, PHI};
+    use crate::field::bn254::{
+        decompose_unsafe, decompose, lt_unsafe_internal, assert_gt, gt, lt, TWO_POW_128,
+        lte_unsafe_internal, PLO, PHI
+    };
 
     #[test]
     fn check_decompose_unsafe() {
@@ -123,23 +138,23 @@ mod tests {
 
     #[test]
     fn check_lt_unsafe() {
-        assert(lt_unsafe(0, 1, 16));
-        assert(lt_unsafe(0, 0x100, 16));
-        assert(lt_unsafe(0x100, TWO_POW_128 - 1, 16));
-        assert(!lt_unsafe(0, TWO_POW_128, 16));
+        assert(lt_unsafe_internal(0, 1, 16));
+        assert(lt_unsafe_internal(0, 0x100, 16));
+        assert(lt_unsafe_internal(0x100, TWO_POW_128 - 1, 16));
+        assert(!lt_unsafe_internal(0, TWO_POW_128, 16));
     }
 
     #[test]
     fn check_lte_unsafe() {
-        assert(lte_unsafe(0, 1, 16));
-        assert(lte_unsafe(0, 0x100, 16));
-        assert(lte_unsafe(0x100, TWO_POW_128 - 1, 16));
-        assert(!lte_unsafe(0, TWO_POW_128, 16));
-
-        assert(lte_unsafe(0, 0, 16));
-        assert(lte_unsafe(0x100, 0x100, 16));
-        assert(lte_unsafe(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
-        assert(lte_unsafe(TWO_POW_128, TWO_POW_128, 16));
+        assert(lte_unsafe_internal(0, 1, 16));
+        assert(lte_unsafe_internal(0, 0x100, 16));
+        assert(lte_unsafe_internal(0x100, TWO_POW_128 - 1, 16));
+        assert(!lte_unsafe_internal(0, TWO_POW_128, 16));
+
+        assert(lte_unsafe_internal(0, 0, 16));
+        assert(lte_unsafe_internal(0x100, 0x100, 16));
+        assert(lte_unsafe_internal(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
+        assert(lte_unsafe_internal(TWO_POW_128, TWO_POW_128, 16));
     }
 
     #[test]
diff --git a/scripts/install_bb.sh b/scripts/install_bb.sh
new file mode 100755
index 00000000000..519ffe6cb03
--- /dev/null
+++ b/scripts/install_bb.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# We use this script just for CI so we assume we're running on x86 linux
+
+mkdir -p $HOME/.barretenberg
+curl -o ./barretenberg-x86_64-linux-gnu.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.41.0/barretenberg-x86_64-linux-gnu.tar.gz
+tar -xvf ./barretenberg-x86_64-linux-gnu.tar.gz -C $HOME/.barretenberg/
+echo 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.bashrc
+source ~/.bashrc
diff --git a/test_programs/compile_success_empty/intrinsic_die/src/main.nr b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
index 9ce17f72c0d..a6c6d3df9a1 100644
--- a/test_programs/compile_success_empty/intrinsic_die/src/main.nr
+++ b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
@@ -4,5 +4,7 @@ fn main(x: Field) {
     let hash = std::hash::pedersen_commitment([x]);
     let g1_x = 0x0000000000000000000000000000000000000000000000000000000000000001;
     let g1_y = 0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c;
-    let _p1 = std::embedded_curve_ops::multi_scalar_mul([g1_x, g1_y], [x, 0]);
+    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: g1_x, y: g1_y, is_infinite: false };
+    let scalar = std::embedded_curve_ops::EmbeddedCurveScalar { lo: x, hi: 0 };
+    let _p1 = std::embedded_curve_ops::multi_scalar_mul([g1], [scalar]);
 }
diff --git a/test_programs/execution_success/brillig_embedded_curve/src/main.nr b/test_programs/execution_success/brillig_embedded_curve/src/main.nr
index 8a1a7f08975..89a699448dc 100644
--- a/test_programs/execution_success/brillig_embedded_curve/src/main.nr
+++ b/test_programs/execution_success/brillig_embedded_curve/src/main.nr
@@ -2,22 +2,22 @@ use dep::std;
 
 unconstrained fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
     let g1_y = 17631683881184975370165255887551781615748388533673675138860;
-    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y };
-
+    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y, is_infinite: false };
+    let scalar = std::embedded_curve_ops::EmbeddedCurveScalar { lo: priv_key, hi: 0 };
     // Test that multi_scalar_mul correctly derives the public key
-    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y], [priv_key, 0]);
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1], [scalar]);
     assert(res[0] == pub_x);
     assert(res[1] == pub_y);
 
     // Test that double function calling embedded_curve_add works as expected
-    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y };
+    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y, is_infinite: false };
     let res = pub_point.double();
     let double = g1.add(g1);
 
     assert(double.x == res.x);
 
     // Test calling multi_scalar_mul with multiple points and scalars
-    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y, g1.x, g1.y], [priv_key, 0, priv_key, 0]);
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1, g1], [scalar, scalar]);
 
     // The results should be double the g1 point because the scalars are 1 and we pass in g1 twice
     assert(double.x == res[0]);
diff --git a/test_programs/execution_success/embedded_curve_ops/src/main.nr b/test_programs/execution_success/embedded_curve_ops/src/main.nr
index 3cb27d8c181..46f919e947a 100644
--- a/test_programs/execution_success/embedded_curve_ops/src/main.nr
+++ b/test_programs/execution_success/embedded_curve_ops/src/main.nr
@@ -2,22 +2,22 @@ use dep::std;
 
 fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
     let g1_y = 17631683881184975370165255887551781615748388533673675138860;
-    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y };
-
+    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y, is_infinite: false };
+    let scalar = std::embedded_curve_ops::EmbeddedCurveScalar { lo: priv_key, hi: 0 };
     // Test that multi_scalar_mul correctly derives the public key
-    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y], [priv_key, 0]);
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1], [scalar]);
     assert(res[0] == pub_x);
     assert(res[1] == pub_y);
 
     // Test that double function calling embedded_curve_add works as expected
-    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y };
+    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y, is_infinite: false };
     let res = pub_point.double();
     let double = g1.add(g1);
 
     assert(double.x == res.x);
 
     // Test calling multi_scalar_mul with multiple points and scalars
-    let res = std::embedded_curve_ops::multi_scalar_mul([g1.x, g1.y, g1.x, g1.y], [priv_key, 0, priv_key, 0]);
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1, g1], [scalar, scalar]);
 
     // The results should be double the g1 point because the scalars are 1 and we pass in g1 twice
     assert(double.x == res[0]);
diff --git a/test_programs/execution_success/trait_method_mut_self/src/main.nr b/test_programs/execution_success/trait_method_mut_self/src/main.nr
index 0e736c2f098..fa47fd5d881 100644
--- a/test_programs/execution_success/trait_method_mut_self/src/main.nr
+++ b/test_programs/execution_success/trait_method_mut_self/src/main.nr
@@ -12,6 +12,14 @@ fn main(x: Field, y: pub Field) {
 
     pass_trait_by_mut_ref(&mut a_mut_ref, y);
     assert(a_mut_ref.x == y);
+
+    let mut hasher = Poseidon2Hasher::default();
+    hasher.write(x);
+    hasher.write(y);
+    let expected_hash = hasher.finish();
+    // Check that we get the same result when using the hasher in a 
+    // method that purely uses trait methods without a supplied implementation.
+    assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == expected_hash);
 }
 
 trait SomeTrait {
@@ -50,3 +58,17 @@ fn pass_trait_by_mut_ref<T>(a_mut_ref: &mut T, value: Field) where T: SomeTrait
     // We auto add a mutable reference to the object type if the method call expects a mutable self
     a_mut_ref.set_value(value);
 }
+
+fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
+    // Check that we can call a trait method instead of a trait implementation
+    // TODO: Need to remove the need for this type annotation
+    // TODO: Curently, without the annotation we will get `Expression type is ambiguous` when trying to use the `hasher`
+    let mut hasher: H = H::default();
+    // Regression that the object is converted to a mutable reference type `&mut _`.
+    // Otherwise will see `Expected type &mut _, found type H`.
+    // Then we need to make sure to also auto dereference later in the type checking process
+    // when searching for a matching impl or else we will get `No matching impl found for `&mut H: Hasher`
+    hasher.write(input[0]);
+    hasher.write(input[1]);
+    hasher.finish()
+}
diff --git a/test_programs/execution_success/unit_value/Nargo.toml b/test_programs/execution_success/unit_value/Nargo.toml
index f7e3697a7c1..1f9c4524ec5 100644
--- a/test_programs/execution_success/unit_value/Nargo.toml
+++ b/test_programs/execution_success/unit_value/Nargo.toml
@@ -1,7 +1,7 @@
 [package]
-name = "short"
+name = "unit_value"
 type = "bin"
 authors = [""]
 compiler_version = ">=0.23.0"
 
-[dependencies]
\ No newline at end of file
+[dependencies]
diff --git a/test_programs/noir_test_success/embedded_curve_ops/Nargo.toml b/test_programs/noir_test_success/embedded_curve_ops/Nargo.toml
new file mode 100644
index 00000000000..65e6efea538
--- /dev/null
+++ b/test_programs/noir_test_success/embedded_curve_ops/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "embedded_curve_ops"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/noir_test_success/embedded_curve_ops/src/main.nr b/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
new file mode 100644
index 00000000000..9e3c5d87874
--- /dev/null
+++ b/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
@@ -0,0 +1,37 @@
+use dep::std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
+
+#[test]
+    
+ fn test_infinite_point() {
+    let zero = EmbeddedCurvePoint::point_at_infinity();
+    let zero = EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true };
+    let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+    let g2 = g1 + g1;
+
+    let s1 = EmbeddedCurveScalar { lo: 1, hi: 0 };
+    let a = multi_scalar_mul([g1], [s1]);
+    assert(a[2] == 0);
+    assert(g1 + zero == g1);
+    assert(g1 - g1 == zero);
+    assert(g1 - zero == g1);
+    assert(zero + zero == zero);
+    assert(
+        multi_scalar_mul([g1], [s1])
+        == [1, 17631683881184975370165255887551781615748388533673675138860, 0]
+    );
+    assert(multi_scalar_mul([g1, g1], [s1, s1]) == [g2.x, g2.y, 0]);
+    assert(
+        multi_scalar_mul(
+        [g1, zero],
+        [EmbeddedCurveScalar { lo: 2, hi: 0 }, EmbeddedCurveScalar { lo: 42, hi: 25 }]
+    )
+        == [g2.x, g2.y, 0]
+    );
+    assert(
+        multi_scalar_mul(
+        [g1, g1, zero],
+        [s1, s1, EmbeddedCurveScalar { lo: 42, hi: 25 }]
+    )
+        == [g2.x, g2.y, 0]
+    );
+}
diff --git a/test_programs/rebuild.sh b/test_programs/rebuild.sh
index 51e97278281..4733bad10c3 100755
--- a/test_programs/rebuild.sh
+++ b/test_programs/rebuild.sh
@@ -16,13 +16,14 @@ process_dir() {
     if [ -d ./target/ ]; then
       rm -r ./target/
     fi
-    nargo compile --only-acir && nargo execute witness
+    nargo execute witness
 
     if [ -d "$current_dir/acir_artifacts/$dir_name/target" ]; then
       rm -r "$current_dir/acir_artifacts/$dir_name/target"
     fi
     mkdir $current_dir/acir_artifacts/$dir_name/target
 
+    mv ./target/$dir_name.json $current_dir/acir_artifacts/$dir_name/target/program.json
     mv ./target/*.gz $current_dir/acir_artifacts/$dir_name/target/
 
     cd $current_dir
@@ -70,4 +71,4 @@ if [ ! -z "$exit_status" ]; then
     echo "Rebuild failed!"
     exit $exit_status
 fi
-echo "Rebuild Succeeded!"
\ No newline at end of file
+echo "Rebuild Succeeded!"
diff --git a/tooling/backend_interface/CHANGELOG.md b/tooling/backend_interface/CHANGELOG.md
deleted file mode 100644
index 9ebde989add..00000000000
--- a/tooling/backend_interface/CHANGELOG.md
+++ /dev/null
@@ -1,233 +0,0 @@
-# Changelog
-
-## [0.11.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.10.1...v0.11.0) (2023-08-18)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update `acvm` to 0.22.0 ([#240](https://github.com/noir-lang/acvm-backend-barretenberg/issues/240))
-
-### Features
-
-* Update `acvm` to 0.22.0 ([#240](https://github.com/noir-lang/acvm-backend-barretenberg/issues/240)) ([d8342fd](https://github.com/noir-lang/acvm-backend-barretenberg/commit/d8342fd6da605ac3bbd889edf89cd122bc4689ce))
-
-## [0.10.1](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.10.0...v0.10.1) (2023-08-18)
-
-
-### Features
-
-* Migrate to `wasmer` 3.3.0 ([#236](https://github.com/noir-lang/acvm-backend-barretenberg/issues/236)) ([e115e38](https://github.com/noir-lang/acvm-backend-barretenberg/commit/e115e38856887c6b1eeead3534534ac7e6327ea9))
-
-## [0.10.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.9.1...v0.10.0) (2023-07-26)
-
-
-### ⚠ BREAKING CHANGES
-
-* Migrate to ACVM 0.21.0 ([#234](https://github.com/noir-lang/acvm-backend-barretenberg/issues/234))
-
-### Features
-
-* Migrate to ACVM 0.21.0 ([#234](https://github.com/noir-lang/acvm-backend-barretenberg/issues/234)) ([15c8676](https://github.com/noir-lang/acvm-backend-barretenberg/commit/15c86768685d2946a767c350f6ef5972c86677eb))
-
-## [0.9.1](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.9.0...v0.9.1) (2023-07-21)
-
-
-### Features
-
-* add support for atomic memory opcodes ([#232](https://github.com/noir-lang/acvm-backend-barretenberg/issues/232)) ([a7aa6e9](https://github.com/noir-lang/acvm-backend-barretenberg/commit/a7aa6e9505bb402c1b3db0a990845ed26928e7aa))
-
-## [0.9.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.8.0...v0.9.0) (2023-07-17)
-
-
-### ⚠ BREAKING CHANGES
-
-* update to ACVM 0.19.0 ([#230](https://github.com/noir-lang/acvm-backend-barretenberg/issues/230))
-
-### Miscellaneous Chores
-
-* update to ACVM 0.19.0 ([#230](https://github.com/noir-lang/acvm-backend-barretenberg/issues/230)) ([3f1d967](https://github.com/noir-lang/acvm-backend-barretenberg/commit/3f1d9674b904acb02c2a3e52481be8a6104c3a9d))
-
-## [0.8.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.7.0...v0.8.0) (2023-07-12)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update to acvm 0.18.1 ([#228](https://github.com/noir-lang/acvm-backend-barretenberg/issues/228))
-
-### Features
-
-* Update to acvm 0.18.1 ([#228](https://github.com/noir-lang/acvm-backend-barretenberg/issues/228)) ([397098b](https://github.com/noir-lang/acvm-backend-barretenberg/commit/397098b239efbe16785b1c9af108ca9fc4e24497))
-
-## [0.7.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.6.1...v0.7.0) (2023-07-08)
-
-
-### ⚠ BREAKING CHANGES
-
-* **bberg:** add secp256r1 builtin to barretenberg ([#223](https://github.com/noir-lang/acvm-backend-barretenberg/issues/223))
-
-### Features
-
-* **bberg:** add secp256r1 builtin to barretenberg ([#223](https://github.com/noir-lang/acvm-backend-barretenberg/issues/223)) ([ceb4770](https://github.com/noir-lang/acvm-backend-barretenberg/commit/ceb47705a492fcdcea1f3c098aaab42ea8edbf2e))
-
-## [0.6.1](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.6.0...v0.6.1) (2023-07-06)
-
-
-### Features
-
-* switch RecursiveAggregation support to true ([#225](https://github.com/noir-lang/acvm-backend-barretenberg/issues/225)) ([e9462ae](https://github.com/noir-lang/acvm-backend-barretenberg/commit/e9462ae015ec0dfb0a23ccbb89562071f87940f5))
-
-## [0.6.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.5.1...v0.6.0) (2023-07-06)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update to ACVM 0.16.0  ([#221](https://github.com/noir-lang/acvm-backend-barretenberg/issues/221))
-
-### Features
-
-* Update to ACVM 0.16.0  ([#221](https://github.com/noir-lang/acvm-backend-barretenberg/issues/221)) ([062d5ed](https://github.com/noir-lang/acvm-backend-barretenberg/commit/062d5ed9b476fab8ac8d3ca13371699fb2aac332))
-
-## [0.5.1](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.5.0...v0.5.1) (2023-06-20)
-
-
-### Bug Fixes
-
-* Remove wasm32 target ([#219](https://github.com/noir-lang/acvm-backend-barretenberg/issues/219)) ([e4cbb6d](https://github.com/noir-lang/acvm-backend-barretenberg/commit/e4cbb6d476e8746de33c38506e2fcb970f1c866a))
-
-## [0.5.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.4.0...v0.5.0) (2023-06-15)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update to target ACVM 0.15.0 ([#217](https://github.com/noir-lang/acvm-backend-barretenberg/issues/217))
-
-### Features
-
-* Update to target ACVM 0.15.0 ([#217](https://github.com/noir-lang/acvm-backend-barretenberg/issues/217)) ([9331898](https://github.com/noir-lang/acvm-backend-barretenberg/commit/9331898f161321c8b6a82d5ea850f197952b2ed2))
-
-## [0.4.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.3.0...v0.4.0) (2023-06-07)
-
-
-### ⚠ BREAKING CHANGES
-
-* Recursion ([#207](https://github.com/noir-lang/acvm-backend-barretenberg/issues/207))
-
-### Features
-
-* Recursion ([#207](https://github.com/noir-lang/acvm-backend-barretenberg/issues/207)) ([6fc479b](https://github.com/noir-lang/acvm-backend-barretenberg/commit/6fc479b9ae99d59bbfeb1b895d63cdbea469dcaa))
-
-## [0.3.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.2.0...v0.3.0) (2023-06-01)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update to ACVM 0.13.0 ([#205](https://github.com/noir-lang/acvm-backend-barretenberg/issues/205))
-* added keccakvar constraints ([#213](https://github.com/noir-lang/acvm-backend-barretenberg/issues/213))
-* update pedersen hashes for new implementation ([#212](https://github.com/noir-lang/acvm-backend-barretenberg/issues/212))
-
-### Features
-
-* added keccakvar constraints ([91ea65f](https://github.com/noir-lang/acvm-backend-barretenberg/commit/91ea65f6af7039095c7a3af7bc1e4ce302a68a8d))
-* added keccakvar constraints ([#213](https://github.com/noir-lang/acvm-backend-barretenberg/issues/213)) ([91ea65f](https://github.com/noir-lang/acvm-backend-barretenberg/commit/91ea65f6af7039095c7a3af7bc1e4ce302a68a8d))
-* Update to ACVM 0.13.0 ([#205](https://github.com/noir-lang/acvm-backend-barretenberg/issues/205)) ([298446e](https://github.com/noir-lang/acvm-backend-barretenberg/commit/298446ef8b69f528b6e2fd2abb2298d7b0a8118e))
-
-
-### Bug Fixes
-
-* Add or cleanup implementations for JS target ([#199](https://github.com/noir-lang/acvm-backend-barretenberg/issues/199)) ([f6134b7](https://github.com/noir-lang/acvm-backend-barretenberg/commit/f6134b7b502cb74882300b0046ab91ab000daf3c))
-* update pedersen hashes for new impl ([9a233ce](https://github.com/noir-lang/acvm-backend-barretenberg/commit/9a233ce8db9984b29b9cce0603f758d5281c89c9))
-* update pedersen hashes for new implementation ([#212](https://github.com/noir-lang/acvm-backend-barretenberg/issues/212)) ([9a233ce](https://github.com/noir-lang/acvm-backend-barretenberg/commit/9a233ce8db9984b29b9cce0603f758d5281c89c9))
-
-## [0.2.0](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.1.2...v0.2.0) (2023-05-22)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update to acvm 0.12.0 ([#165](https://github.com/noir-lang/acvm-backend-barretenberg/issues/165))
-* Add serialization logic for RAM and ROM opcodes ([#153](https://github.com/noir-lang/acvm-backend-barretenberg/issues/153))
-
-### Features
-
-* Add serde to `ConstraintSystem` types ([#196](https://github.com/noir-lang/acvm-backend-barretenberg/issues/196)) ([4c04a79](https://github.com/noir-lang/acvm-backend-barretenberg/commit/4c04a79e6d2b0115f3b4526c60f9f7dae8b464ae))
-* Add serialization logic for RAM and ROM opcodes ([#153](https://github.com/noir-lang/acvm-backend-barretenberg/issues/153)) ([3d3847d](https://github.com/noir-lang/acvm-backend-barretenberg/commit/3d3847de70e74a8f65c64e165ad15ae3d31f5350))
-* Update to acvm 0.12.0 ([#165](https://github.com/noir-lang/acvm-backend-barretenberg/issues/165)) ([d613c79](https://github.com/noir-lang/acvm-backend-barretenberg/commit/d613c79584a599f4adbd11d2ce3b61403c185b73))
-
-## [0.1.2](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.1.1...v0.1.2) (2023-05-11)
-
-
-### Bug Fixes
-
-* Remove star dependencies to allow publishing ([#182](https://github.com/noir-lang/acvm-backend-barretenberg/issues/182)) ([1727a79](https://github.com/noir-lang/acvm-backend-barretenberg/commit/1727a79ce7e66d95528f70c445cb4ec1b1ece636))
-
-## [0.1.1](https://github.com/noir-lang/acvm-backend-barretenberg/compare/v0.1.0...v0.1.1) (2023-05-11)
-
-
-### Bug Fixes
-
-* Add description so crate can be published ([#180](https://github.com/noir-lang/acvm-backend-barretenberg/issues/180)) ([caabf94](https://github.com/noir-lang/acvm-backend-barretenberg/commit/caabf9434031c6023a5e3a436c87fba0a1072539))
-
-## 0.1.0 (2023-05-10)
-
-
-### ⚠ BREAKING CHANGES
-
-* Update to ACVM v0.11.0 ([#151](https://github.com/noir-lang/acvm-backend-barretenberg/issues/151))
-* Add Keccak constraints ([#150](https://github.com/noir-lang/acvm-backend-barretenberg/issues/150))
-* migrate to ACVM 0.10.3 ([#148](https://github.com/noir-lang/acvm-backend-barretenberg/issues/148))
-* remove all crates other than `acvm-backend-barretenberg` and remove workspace ([#147](https://github.com/noir-lang/acvm-backend-barretenberg/issues/147))
-* merge `barretenberg_static_lib` and `barretenberg_wasm` ([#117](https://github.com/noir-lang/acvm-backend-barretenberg/issues/117))
-* remove dead blake2 code ([#137](https://github.com/noir-lang/acvm-backend-barretenberg/issues/137))
-* Implement pseudo-builder pattern for ConstraintSystem & hide struct fields ([#120](https://github.com/noir-lang/acvm-backend-barretenberg/issues/120))
-* return boolean rather than `FieldElement` from `verify_signature` ([#123](https://github.com/noir-lang/acvm-backend-barretenberg/issues/123))
-* avoid exposing internals of Assignments type ([#119](https://github.com/noir-lang/acvm-backend-barretenberg/issues/119))
-* update to acvm 0.9.0 ([#106](https://github.com/noir-lang/acvm-backend-barretenberg/issues/106))
-* Depend upon upstream barretenberg & switch to UltraPlonk ([#84](https://github.com/noir-lang/acvm-backend-barretenberg/issues/84))
-* update to ACVM 0.7.0 ([#90](https://github.com/noir-lang/acvm-backend-barretenberg/issues/90))
-* Remove create_proof and verify functions ([#82](https://github.com/noir-lang/acvm-backend-barretenberg/issues/82))
-* update to acvm v0.5.0 ([#60](https://github.com/noir-lang/acvm-backend-barretenberg/issues/60))
-
-### Features
-
-* **acvm_interop:** Updates to reflect new acvm methods using pk/vk ([#50](https://github.com/noir-lang/acvm-backend-barretenberg/issues/50)) ([cff757d](https://github.com/noir-lang/acvm-backend-barretenberg/commit/cff757dca7971161e4bd25e7a744d910c37c22be))
-* Add Keccak constraints ([#150](https://github.com/noir-lang/acvm-backend-barretenberg/issues/150)) ([ce2b9ed](https://github.com/noir-lang/acvm-backend-barretenberg/commit/ce2b9ed456bd8d2ad8357c15736d62c2a5812add))
-* allow overriding transcript location with BARRETENBERG_TRANSCRIPT env var ([#86](https://github.com/noir-lang/acvm-backend-barretenberg/issues/86)) ([af92b99](https://github.com/noir-lang/acvm-backend-barretenberg/commit/af92b99c7b5f37e9659931af378a851b3658a80b))
-* **ci:** add concurrency group for rust workflow ([#63](https://github.com/noir-lang/acvm-backend-barretenberg/issues/63)) ([5c936bc](https://github.com/noir-lang/acvm-backend-barretenberg/commit/5c936bc63cc3adcf9d43c9c4ce69053566089ad9))
-* Depend upon upstream barretenberg & switch to UltraPlonk ([#84](https://github.com/noir-lang/acvm-backend-barretenberg/issues/84)) ([8437bf7](https://github.com/noir-lang/acvm-backend-barretenberg/commit/8437bf7e08acadf43b55b307545336596a9fe766))
-* Implement pseudo-builder pattern for ConstraintSystem & hide struct fields ([#120](https://github.com/noir-lang/acvm-backend-barretenberg/issues/120)) ([8ed67d6](https://github.com/noir-lang/acvm-backend-barretenberg/commit/8ed67d68c71d655e1a6a5c38fa9ea1c3566f771d))
-* Leverage rustls when using downloader crate ([#46](https://github.com/noir-lang/acvm-backend-barretenberg/issues/46)) ([9de36b6](https://github.com/noir-lang/acvm-backend-barretenberg/commit/9de36b642d125d1fb4facd1bf60db67946be70ae))
-* merge `barretenberg_static_lib` and `barretenberg_wasm` ([#117](https://github.com/noir-lang/acvm-backend-barretenberg/issues/117)) ([ba1d0d6](https://github.com/noir-lang/acvm-backend-barretenberg/commit/ba1d0d61b94de91b15044d97608907c21bfb5299))
-* migrate to ACVM 0.10.3 ([#148](https://github.com/noir-lang/acvm-backend-barretenberg/issues/148)) ([c9fb9e8](https://github.com/noir-lang/acvm-backend-barretenberg/commit/c9fb9e806f1400a2ff7594a0669bec56025220bb))
-* remove all crates other than `acvm-backend-barretenberg` and remove workspace ([#147](https://github.com/noir-lang/acvm-backend-barretenberg/issues/147)) ([8fe7111](https://github.com/noir-lang/acvm-backend-barretenberg/commit/8fe7111ebdcb043764a83436744662e8c3ca5abc))
-* remove dead blake2 code ([#137](https://github.com/noir-lang/acvm-backend-barretenberg/issues/137)) ([14d8a5b](https://github.com/noir-lang/acvm-backend-barretenberg/commit/14d8a5b893eb1cb91d5bde908643b487b41809d6))
-* replace `downloader` dependency with `reqwest` ([#114](https://github.com/noir-lang/acvm-backend-barretenberg/issues/114)) ([dd62231](https://github.com/noir-lang/acvm-backend-barretenberg/commit/dd62231b8bfcee32e1029d31a07895b16159339c))
-* return boolean from `verify_signature` ([e560602](https://github.com/noir-lang/acvm-backend-barretenberg/commit/e560602ebbd547386ca4cab35735ffa92e98ac4b))
-* return boolean rather than `FieldElement` from `check_membership` ([#124](https://github.com/noir-lang/acvm-backend-barretenberg/issues/124)) ([a0a338e](https://github.com/noir-lang/acvm-backend-barretenberg/commit/a0a338e2295635a07f6b9e497c029160a5f323bc))
-* return boolean rather than `FieldElement` from `verify_signature` ([#123](https://github.com/noir-lang/acvm-backend-barretenberg/issues/123)) ([e560602](https://github.com/noir-lang/acvm-backend-barretenberg/commit/e560602ebbd547386ca4cab35735ffa92e98ac4b))
-* store transcript in `.nargo/backends` directory ([#91](https://github.com/noir-lang/acvm-backend-barretenberg/issues/91)) ([c6b5023](https://github.com/noir-lang/acvm-backend-barretenberg/commit/c6b50231da065e7550bfe8bddf8e46f4cd8002d7))
-* update `aztec_backend_wasm` to use new serialization ([#94](https://github.com/noir-lang/acvm-backend-barretenberg/issues/94)) ([28014d8](https://github.com/noir-lang/acvm-backend-barretenberg/commit/28014d803d052a7f459e03dbd7b5b9210449b1d0))
-* update to acvm 0.9.0 ([#106](https://github.com/noir-lang/acvm-backend-barretenberg/issues/106)) ([ff350fb](https://github.com/noir-lang/acvm-backend-barretenberg/commit/ff350fb111043964b8a14fc0df62508c87506423))
-* Update to ACVM v0.11.0 ([#151](https://github.com/noir-lang/acvm-backend-barretenberg/issues/151)) ([9202415](https://github.com/noir-lang/acvm-backend-barretenberg/commit/92024155532e15f25acb2f3ed8d5ca78da0fddd9))
-* update to acvm v0.5.0 ([#60](https://github.com/noir-lang/acvm-backend-barretenberg/issues/60)) ([74b4d8d](https://github.com/noir-lang/acvm-backend-barretenberg/commit/74b4d8d8b118e4477880c04149e5e9d93d388384))
-
-
-### Bug Fixes
-
-* Avoid exposing internals of Assignments type ([614c81b](https://github.com/noir-lang/acvm-backend-barretenberg/commit/614c81b0ea5e110bbf5a61a526bb0173f4fe377a))
-* avoid exposing internals of Assignments type ([#119](https://github.com/noir-lang/acvm-backend-barretenberg/issues/119)) ([614c81b](https://github.com/noir-lang/acvm-backend-barretenberg/commit/614c81b0ea5e110bbf5a61a526bb0173f4fe377a))
-* fix serialization of arithmetic expressions ([#145](https://github.com/noir-lang/acvm-backend-barretenberg/issues/145)) ([7f42535](https://github.com/noir-lang/acvm-backend-barretenberg/commit/7f4253570257d9dedcfa8c8fb96b9d097ef06419))
-* Implement random_get for wasm backend ([#102](https://github.com/noir-lang/acvm-backend-barretenberg/issues/102)) ([9c0f06e](https://github.com/noir-lang/acvm-backend-barretenberg/commit/9c0f06ef56f23e2b5794e810f433e36ff2c5d6b5))
-* rename gates to opcodes ([#59](https://github.com/noir-lang/acvm-backend-barretenberg/issues/59)) ([6e05307](https://github.com/noir-lang/acvm-backend-barretenberg/commit/6e053072d8b9c5d93c296f10782251ccb597f902))
-* reorganize and ensure contracts can be compiled in Remix ([#112](https://github.com/noir-lang/acvm-backend-barretenberg/issues/112)) ([7ec5693](https://github.com/noir-lang/acvm-backend-barretenberg/commit/7ec5693f194a79c379ae2952bc17a31ee63a42b9))
-* replace `serialize_circuit` function with `from&lt;&Circuit&gt;` ([#118](https://github.com/noir-lang/acvm-backend-barretenberg/issues/118)) ([94f83a7](https://github.com/noir-lang/acvm-backend-barretenberg/commit/94f83a78e32d91dfb7ae9824923695d9b4c425b0))
-* Replace serialize_circuit function with `from&lt;&Circuit&gt;` ([94f83a7](https://github.com/noir-lang/acvm-backend-barretenberg/commit/94f83a78e32d91dfb7ae9824923695d9b4c425b0))
-* Update bb-sys to resolve bugs in some environments ([#129](https://github.com/noir-lang/acvm-backend-barretenberg/issues/129)) ([e3d4504](https://github.com/noir-lang/acvm-backend-barretenberg/commit/e3d4504f15e1295e637c4da80b1d08c87c267c45))
-* Update dependency containing pk write fix for large general circuits ([#78](https://github.com/noir-lang/acvm-backend-barretenberg/issues/78)) ([2cb523d](https://github.com/noir-lang/acvm-backend-barretenberg/commit/2cb523d2ab95249157b22e198d9dcd6841c3eed8))
-* Update to bb-sys 0.1.1 and update bb in lockfile ([00bb157](https://github.com/noir-lang/acvm-backend-barretenberg/commit/00bb15779dfb64539eeb3f3bb4c4deeba106f2fe))
-* update to bb-sys 0.1.1 and update bb in lockfile ([#111](https://github.com/noir-lang/acvm-backend-barretenberg/issues/111)) ([00bb157](https://github.com/noir-lang/acvm-backend-barretenberg/commit/00bb15779dfb64539eeb3f3bb4c4deeba106f2fe))
-* use `Barretenberg.call` to query circuit size from wasm ([#121](https://github.com/noir-lang/acvm-backend-barretenberg/issues/121)) ([a775af1](https://github.com/noir-lang/acvm-backend-barretenberg/commit/a775af14137cc7bc2e9d8a063fa718a5a9abe6cb))
-
-
-### Miscellaneous Chores
-
-* Remove create_proof and verify functions ([#82](https://github.com/noir-lang/acvm-backend-barretenberg/issues/82)) ([ad0c422](https://github.com/noir-lang/acvm-backend-barretenberg/commit/ad0c4228488457bd155ff381186ecf583f18bfac))
-* update to ACVM 0.7.0 ([#90](https://github.com/noir-lang/acvm-backend-barretenberg/issues/90)) ([6c03687](https://github.com/noir-lang/acvm-backend-barretenberg/commit/6c036870a6a8e26612ab8b4f90a162f7540b42e2))
diff --git a/tooling/backend_interface/Cargo.toml b/tooling/backend_interface/Cargo.toml
deleted file mode 100644
index f6b5d5d0132..00000000000
--- a/tooling/backend_interface/Cargo.toml
+++ /dev/null
@@ -1,35 +0,0 @@
-[package]
-name = "backend-interface"
-description = "The definition of the backend CLI interface which Nargo uses for proving/verifying ACIR circuits."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-acvm.workspace = true
-dirs.workspace = true
-thiserror.workspace = true
-serde_json.workspace = true
-bb_abstraction_leaks.workspace = true
-tracing.workspace = true
-
-tempfile.workspace = true
-
-## bb binary downloading
-tar = "~0.4.15"
-flate2 = "~1.0.1"
-reqwest = { version = "0.11.20", default-features = false, features = [
-    "rustls-tls",
-    "blocking",
-] }
-
-[dev-dependencies]
-test-binary = "3.0.1"
-
-[build-dependencies]
-build-target = "0.4.0"
-const_format.workspace = true
diff --git a/tooling/backend_interface/src/cli/contract.rs b/tooling/backend_interface/src/cli/contract.rs
deleted file mode 100644
index e83fc1909b6..00000000000
--- a/tooling/backend_interface/src/cli/contract.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-/// VerifyCommand will call the barretenberg binary
-/// to return a solidity library with the verification key
-/// that can be used to verify proofs on-chain.
-///
-/// This does not return a Solidity file that is able
-/// to verify a proof. See acvm_interop/contract.sol for the
-/// remaining logic that is missing.
-pub(crate) struct ContractCommand {
-    pub(crate) crs_path: PathBuf,
-    pub(crate) vk_path: PathBuf,
-}
-
-impl ContractCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<String, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command
-            .arg("contract")
-            .arg("-c")
-            .arg(self.crs_path)
-            .arg("-k")
-            .arg(self.vk_path)
-            .arg("-o")
-            .arg("-");
-
-        let output = command.output()?;
-
-        if output.status.success() {
-            String::from_utf8(output.stdout)
-                .map_err(|error| BackendError::InvalidUTF8Vector(error.into_bytes()))
-        } else {
-            Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)))
-        }
-    }
-}
-
-#[test]
-fn contract_command() -> Result<(), BackendError> {
-    use tempfile::tempdir;
-
-    let backend = crate::get_mock_backend()?;
-
-    let temp_directory = tempdir().expect("could not create a temporary directory");
-    let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
-    let vk_path = temp_directory_path.join("vk");
-
-    let crs_path = backend.backend_directory();
-
-    std::fs::File::create(&bytecode_path).expect("file should be created");
-
-    let write_vk_command = super::WriteVkCommand {
-        bytecode_path,
-        vk_path_output: vk_path.clone(),
-        crs_path: crs_path.clone(),
-    };
-    write_vk_command.run(backend.binary_path())?;
-
-    let contract_command = ContractCommand { vk_path, crs_path };
-    contract_command.run(backend.binary_path())?;
-
-    drop(temp_directory);
-
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/cli/gates.rs b/tooling/backend_interface/src/cli/gates.rs
deleted file mode 100644
index aca05f0232a..00000000000
--- a/tooling/backend_interface/src/cli/gates.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-/// GatesCommand will call the barretenberg binary
-/// to return the number of gates needed to create a proof
-/// for the given bytecode.
-pub(crate) struct GatesCommand {
-    pub(crate) crs_path: PathBuf,
-    pub(crate) bytecode_path: PathBuf,
-}
-
-impl GatesCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<u32, BackendError> {
-        let output = std::process::Command::new(binary_path)
-            .arg("gates")
-            .arg("-c")
-            .arg(self.crs_path)
-            .arg("-b")
-            .arg(self.bytecode_path)
-            .output()?;
-
-        if !output.status.success() {
-            return Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)));
-        }
-        // Note: barretenberg includes the newline, so that subsequent prints to stdout
-        // are not on the same line as the gates output.
-
-        const EXPECTED_BYTES: usize = 8;
-        let gates_bytes: [u8; EXPECTED_BYTES] =
-            output.stdout.as_slice().try_into().map_err(|_| {
-                BackendError::UnexpectedNumberOfBytes(EXPECTED_BYTES, output.stdout.clone())
-            })?;
-
-        // Convert bytes to u64 in little-endian format
-        let value = u64::from_le_bytes(gates_bytes);
-
-        Ok(value as u32)
-    }
-}
-
-#[test]
-fn gate_command() -> Result<(), BackendError> {
-    use tempfile::tempdir;
-
-    let backend = crate::get_mock_backend()?;
-
-    let temp_directory = tempdir().expect("could not create a temporary directory");
-    let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
-    let crs_path = backend.backend_directory();
-
-    std::fs::File::create(&bytecode_path).expect("file should be created");
-
-    let gate_command = GatesCommand { crs_path, bytecode_path };
-
-    let output = gate_command.run(backend.binary_path())?;
-    // Mock backend always returns zero gates.
-    assert_eq!(output, 0);
-
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/cli/mod.rs b/tooling/backend_interface/src/cli/mod.rs
deleted file mode 100644
index df43bd5cc2f..00000000000
--- a/tooling/backend_interface/src/cli/mod.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Reference: https://github.com/AztecProtocol/aztec-packages/blob/master/barretenberg/cpp/src/barretenberg/bb/main.cpp
-
-mod contract;
-mod gates;
-mod proof_as_fields;
-mod prove;
-mod verify;
-mod version;
-mod vk_as_fields;
-mod write_vk;
-
-pub(crate) use contract::ContractCommand;
-pub(crate) use gates::GatesCommand;
-pub(crate) use proof_as_fields::ProofAsFieldsCommand;
-pub(crate) use prove::ProveCommand;
-pub(crate) use verify::VerifyCommand;
-pub(crate) use version::VersionCommand;
-pub(crate) use vk_as_fields::VkAsFieldsCommand;
-pub(crate) use write_vk::WriteVkCommand;
-
-#[test]
-fn no_command_provided_works() -> Result<(), crate::BackendError> {
-    // This is a simple test to check that the binaries work
-
-    let backend = crate::get_mock_backend()?;
-
-    let output = std::process::Command::new(backend.binary_path()).output()?;
-
-    let stderr = string_from_stderr(&output.stderr);
-    // Assert help message is printed due to no command being provided.
-    assert!(stderr.contains("Usage: mock_backend <COMMAND>"));
-
-    Ok(())
-}
-
-// Converts a stderr byte array to a string (including invalid characters)
-fn string_from_stderr(stderr: &[u8]) -> String {
-    String::from_utf8_lossy(stderr).to_string()
-}
diff --git a/tooling/backend_interface/src/cli/proof_as_fields.rs b/tooling/backend_interface/src/cli/proof_as_fields.rs
deleted file mode 100644
index 7eb1c1ef35c..00000000000
--- a/tooling/backend_interface/src/cli/proof_as_fields.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use acvm::FieldElement;
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-/// `ProofAsFieldsCommand` will call the barretenberg binary
-/// to split a proof into a representation as [`FieldElement`]s.
-pub(crate) struct ProofAsFieldsCommand {
-    pub(crate) proof_path: PathBuf,
-    pub(crate) vk_path: PathBuf,
-}
-
-impl ProofAsFieldsCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<Vec<FieldElement>, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command
-            .arg("proof_as_fields")
-            .arg("-p")
-            .arg(self.proof_path)
-            .arg("-k")
-            .arg(self.vk_path)
-            .arg("-o")
-            .arg("-");
-
-        let output = command.output()?;
-        if output.status.success() {
-            let string_output = String::from_utf8(output.stdout).unwrap();
-            serde_json::from_str(&string_output)
-                .map_err(|err| BackendError::CommandFailed(err.to_string()))
-        } else {
-            Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)))
-        }
-    }
-}
diff --git a/tooling/backend_interface/src/cli/prove.rs b/tooling/backend_interface/src/cli/prove.rs
deleted file mode 100644
index c63d8afab54..00000000000
--- a/tooling/backend_interface/src/cli/prove.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-/// ProveCommand will call the barretenberg binary
-/// to create a proof, given the witness and the bytecode.
-///
-/// Note:Internally barretenberg will create and discard the
-/// proving key, so this is not returned.
-///
-/// The proof will be written to the specified output file.
-pub(crate) struct ProveCommand {
-    pub(crate) crs_path: PathBuf,
-    pub(crate) bytecode_path: PathBuf,
-    pub(crate) witness_path: PathBuf,
-}
-
-impl ProveCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<Vec<u8>, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command
-            .arg("prove")
-            .arg("-c")
-            .arg(self.crs_path)
-            .arg("-b")
-            .arg(self.bytecode_path)
-            .arg("-w")
-            .arg(self.witness_path)
-            .arg("-o")
-            .arg("-");
-
-        let output = command.output()?;
-        if output.status.success() {
-            Ok(output.stdout)
-        } else {
-            Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)))
-        }
-    }
-}
-
-#[test]
-fn prove_command() -> Result<(), BackendError> {
-    use tempfile::tempdir;
-
-    let backend = crate::get_mock_backend()?;
-
-    let temp_directory = tempdir().expect("could not create a temporary directory");
-    let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
-    let witness_path = temp_directory_path.join("witness.tr");
-
-    std::fs::File::create(&bytecode_path).expect("file should be created");
-    std::fs::File::create(&witness_path).expect("file should be created");
-
-    let crs_path = backend.backend_directory();
-    let prove_command = ProveCommand { crs_path, bytecode_path, witness_path };
-
-    let proof = prove_command.run(backend.binary_path())?;
-    assert_eq!(proof, "proof".as_bytes());
-    drop(temp_directory);
-
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/cli/verify.rs b/tooling/backend_interface/src/cli/verify.rs
deleted file mode 100644
index 1a4ba50b7de..00000000000
--- a/tooling/backend_interface/src/cli/verify.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use crate::BackendError;
-
-/// VerifyCommand will call the barretenberg binary
-/// to verify a proof
-pub(crate) struct VerifyCommand {
-    pub(crate) crs_path: PathBuf,
-    pub(crate) proof_path: PathBuf,
-    pub(crate) vk_path: PathBuf,
-}
-
-impl VerifyCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<bool, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command
-            .arg("verify")
-            .arg("-c")
-            .arg(self.crs_path)
-            .arg("-p")
-            .arg(self.proof_path)
-            .arg("-k")
-            .arg(self.vk_path);
-
-        let output = command.output()?;
-
-        // We currently do not distinguish between an invalid proof and an error inside the backend.
-        Ok(output.status.success())
-    }
-}
-
-#[test]
-fn verify_command() -> Result<(), BackendError> {
-    use tempfile::tempdir;
-
-    use super::{ProveCommand, WriteVkCommand};
-    use crate::proof_system::write_to_file;
-
-    let backend = crate::get_mock_backend()?;
-
-    let temp_directory = tempdir().expect("could not create a temporary directory");
-    let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
-    let witness_path = temp_directory_path.join("witness.tr");
-    let proof_path = temp_directory_path.join("1_mul.proof");
-    let vk_path_output = temp_directory_path.join("vk");
-
-    let crs_path = backend.backend_directory();
-
-    std::fs::File::create(&bytecode_path).expect("file should be created");
-    std::fs::File::create(&witness_path).expect("file should be created");
-
-    let write_vk_command = WriteVkCommand {
-        bytecode_path: bytecode_path.clone(),
-        crs_path: crs_path.clone(),
-        vk_path_output: vk_path_output.clone(),
-    };
-
-    write_vk_command.run(backend.binary_path())?;
-
-    let prove_command = ProveCommand { crs_path: crs_path.clone(), bytecode_path, witness_path };
-    let proof = prove_command.run(backend.binary_path())?;
-
-    write_to_file(&proof, &proof_path);
-
-    let verify_command = VerifyCommand { crs_path, proof_path, vk_path: vk_path_output };
-
-    let verified = verify_command.run(backend.binary_path())?;
-    assert!(verified);
-
-    drop(temp_directory);
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/cli/version.rs b/tooling/backend_interface/src/cli/version.rs
deleted file mode 100644
index 83ab72a870e..00000000000
--- a/tooling/backend_interface/src/cli/version.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use std::path::Path;
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-/// VersionCommand will call the backend binary
-/// to query installed version.
-pub(crate) struct VersionCommand;
-
-impl VersionCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<String, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command.arg("--version");
-
-        let output = command.output()?;
-        if output.status.success() {
-            match String::from_utf8(output.stdout) {
-                Ok(result) => Ok(result),
-                Err(_) => Err(BackendError::CommandFailed(
-                    "Unexpected output from --version check.".to_owned(),
-                )),
-            }
-        } else {
-            Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)))
-        }
-    }
-}
diff --git a/tooling/backend_interface/src/cli/vk_as_fields.rs b/tooling/backend_interface/src/cli/vk_as_fields.rs
deleted file mode 100644
index 1b0212241c4..00000000000
--- a/tooling/backend_interface/src/cli/vk_as_fields.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use acvm::FieldElement;
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-/// VkAsFieldsCommand will call the barretenberg binary
-/// to split a verification key into a representation as [`FieldElement`]s.
-///
-/// The hash of the verification key will also be returned.
-pub(crate) struct VkAsFieldsCommand {
-    pub(crate) vk_path: PathBuf,
-}
-
-impl VkAsFieldsCommand {
-    pub(crate) fn run(
-        self,
-        binary_path: &Path,
-    ) -> Result<(FieldElement, Vec<FieldElement>), BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command.arg("vk_as_fields").arg("-k").arg(self.vk_path).arg("-o").arg("-");
-
-        let output = command.output()?;
-        if output.status.success() {
-            let string_output = String::from_utf8(output.stdout).unwrap();
-            let mut fields: Vec<FieldElement> = serde_json::from_str(&string_output)
-                .map_err(|err| BackendError::CommandFailed(err.to_string()))?;
-
-            // The first element of this vector is the hash of the verification key, we want to split that off.
-            let hash = fields.remove(0);
-            Ok((hash, fields))
-        } else {
-            Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)))
-        }
-    }
-}
diff --git a/tooling/backend_interface/src/cli/write_vk.rs b/tooling/backend_interface/src/cli/write_vk.rs
deleted file mode 100644
index da9fc04cbef..00000000000
--- a/tooling/backend_interface/src/cli/write_vk.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use super::string_from_stderr;
-use crate::BackendError;
-
-/// WriteCommand will call the barretenberg binary
-/// to write a verification key to a file
-pub(crate) struct WriteVkCommand {
-    pub(crate) crs_path: PathBuf,
-    pub(crate) bytecode_path: PathBuf,
-    pub(crate) vk_path_output: PathBuf,
-}
-
-impl WriteVkCommand {
-    #[tracing::instrument(level = "trace", name = "vk_generation", skip_all)]
-    pub(crate) fn run(self, binary_path: &Path) -> Result<(), BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command
-            .arg("write_vk")
-            .arg("-c")
-            .arg(self.crs_path)
-            .arg("-b")
-            .arg(self.bytecode_path)
-            .arg("-o")
-            .arg(self.vk_path_output);
-
-        let output = command.output()?;
-        if output.status.success() {
-            Ok(())
-        } else {
-            Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)))
-        }
-    }
-}
-
-#[test]
-fn write_vk_command() -> Result<(), BackendError> {
-    use tempfile::tempdir;
-
-    let backend = crate::get_mock_backend()?;
-
-    let temp_directory = tempdir().expect("could not create a temporary directory");
-    let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
-    let vk_path_output = temp_directory.path().join("vk");
-
-    let crs_path = backend.backend_directory();
-
-    std::fs::File::create(&bytecode_path).expect("file should be created");
-
-    let write_vk_command = WriteVkCommand { bytecode_path, crs_path, vk_path_output };
-
-    write_vk_command.run(backend.binary_path())?;
-    drop(temp_directory);
-
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/download.rs b/tooling/backend_interface/src/download.rs
deleted file mode 100644
index 60ecb14e642..00000000000
--- a/tooling/backend_interface/src/download.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use std::{
-    io::{Cursor, ErrorKind},
-    path::Path,
-};
-
-/// Downloads a zipped archive and unpacks the backend binary to `destination_path`.
-///
-/// # Backend Requirements
-///
-/// In order for a backend to be compatible with this function:
-/// - `backend_url` must serve a gzipped tarball.
-/// - The tarball must only contain the backend's binary.
-/// - The binary file must be located at the archive root.
-pub fn download_backend(backend_url: &str, destination_path: &Path) -> std::io::Result<()> {
-    use flate2::read::GzDecoder;
-    use tar::Archive;
-    use tempfile::tempdir;
-
-    // Download sources
-    let compressed_file: Cursor<Vec<u8>> = download_binary_from_url(backend_url).map_err(|_| {
-        std::io::Error::new(
-            ErrorKind::Other,
-            format!("Could not download backend from install url: {backend_url}"),
-        )
-    })?;
-
-    // Unpack the tarball
-    let gz_decoder = GzDecoder::new(compressed_file);
-    let mut archive = Archive::new(gz_decoder);
-
-    let temp_directory = tempdir()?;
-    archive.unpack(&temp_directory)?;
-
-    // Assume that the archive contains a single file which is the backend binary.
-    let mut archive_files = std::fs::read_dir(&temp_directory)?;
-    let temp_binary_path = archive_files.next().unwrap()?.path();
-
-    // Create directory to place binary in.
-    std::fs::create_dir_all(destination_path.parent().unwrap())?;
-
-    // Rename the binary to the desired name
-    std::fs::copy(temp_binary_path, destination_path)?;
-
-    drop(temp_directory);
-
-    Ok(())
-}
-
-/// Try to download the specified URL into a buffer which is returned.
-fn download_binary_from_url(url: &str) -> Result<Cursor<Vec<u8>>, reqwest::Error> {
-    let response = reqwest::blocking::get(url)?;
-
-    let bytes = response.bytes()?;
-
-    // TODO: Check SHA of downloaded binary
-
-    Ok(Cursor::new(bytes.to_vec()))
-}
diff --git a/tooling/backend_interface/src/lib.rs b/tooling/backend_interface/src/lib.rs
deleted file mode 100644
index eab98852555..00000000000
--- a/tooling/backend_interface/src/lib.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-#![warn(unused_crate_dependencies, unused_extern_crates)]
-#![warn(unreachable_pub)]
-
-use std::path::PathBuf;
-
-mod cli;
-mod download;
-mod proof_system;
-mod smart_contract;
-
-pub use bb_abstraction_leaks::ACVM_BACKEND_BARRETENBERG;
-use bb_abstraction_leaks::BB_VERSION;
-use cli::VersionCommand;
-pub use download::download_backend;
-use tracing::warn;
-
-const BACKENDS_DIR: &str = ".nargo/backends";
-
-pub fn backends_directory() -> PathBuf {
-    let home_directory = dirs::home_dir().unwrap();
-    home_directory.join(BACKENDS_DIR)
-}
-
-#[cfg(test)]
-test_binary::build_test_binary_once!(mock_backend, "test-binaries");
-
-#[cfg(test)]
-fn get_mock_backend() -> Result<Backend, BackendError> {
-    std::env::set_var("NARGO_BACKEND_PATH", path_to_mock_backend());
-
-    let mock_backend = Backend::new("mock_backend".to_string());
-    mock_backend.assert_binary_exists()?;
-
-    Ok(mock_backend)
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum BackendError {
-    #[error(transparent)]
-    IoError(#[from] std::io::Error),
-
-    #[error("Backend binary does not exist")]
-    MissingBinary,
-
-    #[error("The backend responded with a malformed UTF8 byte vector: {0:?}")]
-    InvalidUTF8Vector(Vec<u8>),
-
-    #[error(
-        "The backend responded with a unexpected number of bytes. Expected: {0} but got {} ({1:?})", .1.len()
-    )]
-    UnexpectedNumberOfBytes(usize, Vec<u8>),
-
-    #[error("The backend encountered an error: {0:?}")]
-    CommandFailed(String),
-}
-
-#[derive(Debug)]
-pub struct Backend {
-    name: String,
-    binary_path: PathBuf,
-}
-
-impl Backend {
-    pub fn new(name: String) -> Backend {
-        let binary_path = if let Some(binary_path) = std::env::var_os("NARGO_BACKEND_PATH") {
-            PathBuf::from(binary_path)
-        } else {
-            const BINARY_NAME: &str = "backend_binary";
-
-            backends_directory().join(&name).join(BINARY_NAME)
-        };
-        Backend { name, binary_path }
-    }
-
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn binary_path(&self) -> &PathBuf {
-        &self.binary_path
-    }
-
-    fn assert_binary_exists(&self) -> Result<&PathBuf, BackendError> {
-        let binary_path = self.binary_path();
-        if binary_path.is_file() {
-            Ok(binary_path)
-        } else {
-            if self.name == ACVM_BACKEND_BARRETENBERG {
-                // If we're trying to use barretenberg, automatically go and install it.
-                let bb_url = std::env::var("BB_BINARY_URL")
-                    .unwrap_or_else(|_| bb_abstraction_leaks::BB_DOWNLOAD_URL.to_owned());
-                download_backend(&bb_url, binary_path)?;
-                return Ok(binary_path);
-            }
-            Err(BackendError::MissingBinary)
-        }
-    }
-
-    fn backend_directory(&self) -> PathBuf {
-        self.binary_path()
-            .parent()
-            .expect("backend binary should have a parent directory")
-            .to_path_buf()
-    }
-
-    fn crs_directory(&self) -> PathBuf {
-        self.backend_directory().join("crs")
-    }
-
-    fn assert_correct_version(&self) -> Result<&PathBuf, BackendError> {
-        let binary_path = self.binary_path();
-        if binary_path.to_string_lossy().contains(ACVM_BACKEND_BARRETENBERG) {
-            match VersionCommand.run(binary_path) {
-                // If version matches then do nothing.
-                Ok(version_string) if version_string == BB_VERSION => (),
-
-                // If version doesn't match then download the correct version.
-                Ok(version_string) => {
-                    warn!("`{ACVM_BACKEND_BARRETENBERG}` version `{version_string}` is different from expected `{BB_VERSION}`. Downloading expected version...");
-                    let bb_url = std::env::var("BB_BINARY_URL")
-                        .unwrap_or_else(|_| bb_abstraction_leaks::BB_DOWNLOAD_URL.to_owned());
-                    download_backend(&bb_url, binary_path)?;
-                }
-
-                // If `bb` fails to report its version, then attempt to fix it by re-downloading the binary.
-                Err(_) => {
-                    warn!("Could not determine version of `{ACVM_BACKEND_BARRETENBERG}`. Downloading expected version...");
-                    let bb_url = std::env::var("BB_BINARY_URL")
-                        .unwrap_or_else(|_| bb_abstraction_leaks::BB_DOWNLOAD_URL.to_owned());
-                    download_backend(&bb_url, binary_path)?;
-                }
-            }
-        }
-        Ok(binary_path)
-    }
-}
-
-#[cfg(test)]
-mod backend {
-    use crate::{Backend, BackendError};
-
-    #[test]
-    fn raises_error_on_missing_binary() {
-        let bad_backend = Backend::new("i_don't_exist".to_string());
-
-        let binary_path = bad_backend.assert_binary_exists();
-
-        assert!(matches!(binary_path, Err(BackendError::MissingBinary)));
-    }
-}
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
deleted file mode 100644
index 20a6dcf70f1..00000000000
--- a/tooling/backend_interface/src/proof_system.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
-
-use acvm::acir::{
-    circuit::Program,
-    native_types::{WitnessMap, WitnessStack},
-};
-use acvm::FieldElement;
-use tempfile::tempdir;
-use tracing::warn;
-
-use crate::cli::{
-    GatesCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand, VkAsFieldsCommand,
-    WriteVkCommand,
-};
-use crate::{Backend, BackendError};
-
-impl Backend {
-    pub fn get_exact_circuit_size(&self, program: &Program) -> Result<u32, BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-
-        let temp_directory = tempdir().expect("could not create a temporary directory");
-        let temp_directory = temp_directory.path().to_path_buf();
-
-        // Create a temporary file for the circuit
-        let circuit_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_program = Program::serialize_program(program);
-        write_to_file(&serialized_program, &circuit_path);
-
-        GatesCommand { crs_path: self.crs_directory(), bytecode_path: circuit_path }
-            .run(binary_path)
-    }
-
-    #[tracing::instrument(level = "trace", skip_all)]
-    pub fn prove(
-        &self,
-        program: &Program,
-        witness_stack: WitnessStack,
-    ) -> Result<Vec<u8>, BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-
-        let temp_directory = tempdir().expect("could not create a temporary directory");
-        let temp_directory = temp_directory.path().to_path_buf();
-
-        // Create a temporary file for the witness
-        let serialized_witnesses: Vec<u8> =
-            witness_stack.try_into().expect("could not serialize witness map");
-        let witness_path = temp_directory.join("witness").with_extension("tr");
-        write_to_file(&serialized_witnesses, &witness_path);
-
-        // Create a temporary file for the circuit
-        //
-        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
-        let serialized_program = Program::serialize_program(program);
-        write_to_file(&serialized_program, &bytecode_path);
-
-        // Create proof and store it in the specified path
-        let proof_with_public_inputs =
-            ProveCommand { crs_path: self.crs_directory(), bytecode_path, witness_path }
-                .run(binary_path)?;
-
-        let proof = bb_abstraction_leaks::remove_public_inputs(
-            // TODO(https://github.com/noir-lang/noir/issues/4428)
-            program.functions[0].public_inputs().0.len(),
-            &proof_with_public_inputs,
-        );
-        Ok(proof)
-    }
-
-    #[tracing::instrument(level = "trace", skip_all)]
-    pub fn verify(
-        &self,
-        proof: &[u8],
-        public_inputs: WitnessMap,
-        program: &Program,
-    ) -> Result<bool, BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-
-        let temp_directory = tempdir().expect("could not create a temporary directory");
-        let temp_directory = temp_directory.path().to_path_buf();
-
-        // Create a temporary file for the proof
-        let proof_with_public_inputs =
-            bb_abstraction_leaks::prepend_public_inputs(proof.to_vec(), public_inputs);
-        let proof_path = temp_directory.join("proof").with_extension("proof");
-        write_to_file(&proof_with_public_inputs, &proof_path);
-
-        // Create a temporary file for the circuit
-        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
-        let serialized_program = Program::serialize_program(program);
-        write_to_file(&serialized_program, &bytecode_path);
-
-        // Create the verification key and write it to the specified path
-        let vk_path = temp_directory.join("vk");
-
-        WriteVkCommand {
-            crs_path: self.crs_directory(),
-            bytecode_path,
-            vk_path_output: vk_path.clone(),
-        }
-        .run(binary_path)?;
-
-        // Verify the proof
-        VerifyCommand { crs_path: self.crs_directory(), proof_path, vk_path }.run(binary_path)
-    }
-
-    pub fn get_intermediate_proof_artifacts(
-        &self,
-        program: &Program,
-        proof: &[u8],
-        public_inputs: WitnessMap,
-    ) -> Result<(Vec<FieldElement>, FieldElement, Vec<FieldElement>), BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-
-        let temp_directory = tempdir().expect("could not create a temporary directory");
-        let temp_directory = temp_directory.path().to_path_buf();
-
-        // Create a temporary file for the circuit
-        //
-        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
-        let serialized_program = Program::serialize_program(program);
-        write_to_file(&serialized_program, &bytecode_path);
-
-        // Create the verification key and write it to the specified path
-        let vk_path = temp_directory.join("vk");
-
-        WriteVkCommand {
-            crs_path: self.crs_directory(),
-            bytecode_path,
-            vk_path_output: vk_path.clone(),
-        }
-        .run(binary_path)?;
-
-        // Create a temporary file for the proof
-
-        let proof_with_public_inputs =
-            bb_abstraction_leaks::prepend_public_inputs(proof.to_vec(), public_inputs);
-        let proof_path = temp_directory.join("proof").with_extension("proof");
-        write_to_file(&proof_with_public_inputs, &proof_path);
-
-        // Now ready to generate intermediate artifacts.
-
-        let proof_as_fields =
-            ProofAsFieldsCommand { proof_path, vk_path: vk_path.clone() }.run(binary_path)?;
-
-        let (vk_hash, vk_as_fields) = VkAsFieldsCommand { vk_path }.run(binary_path)?;
-
-        Ok((proof_as_fields, vk_hash, vk_as_fields))
-    }
-}
-
-pub(super) fn write_to_file(bytes: &[u8], path: &Path) -> String {
-    let display = path.display();
-
-    let mut file = match File::create(path) {
-        Err(why) => panic!("couldn't create {display}: {why}"),
-        Ok(file) => file,
-    };
-
-    match file.write_all(bytes) {
-        Err(why) => panic!("couldn't write to {display}: {why}"),
-        Ok(_) => display.to_string(),
-    }
-}
diff --git a/tooling/backend_interface/src/smart_contract.rs b/tooling/backend_interface/src/smart_contract.rs
deleted file mode 100644
index 153ab52c83f..00000000000
--- a/tooling/backend_interface/src/smart_contract.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use super::proof_system::write_to_file;
-use crate::{
-    cli::{ContractCommand, WriteVkCommand},
-    Backend, BackendError,
-};
-use acvm::acir::circuit::Program;
-use tempfile::tempdir;
-
-impl Backend {
-    pub fn eth_contract(&self, program: &Program) -> Result<String, BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-
-        let temp_directory = tempdir().expect("could not create a temporary directory");
-        let temp_directory_path = temp_directory.path().to_path_buf();
-
-        // Create a temporary file for the circuit
-        let bytecode_path = temp_directory_path.join("program").with_extension("bytecode");
-        let serialized_program = Program::serialize_program(program);
-        write_to_file(&serialized_program, &bytecode_path);
-
-        // Create the verification key and write it to the specified path
-        let vk_path = temp_directory_path.join("vk");
-
-        WriteVkCommand {
-            crs_path: self.crs_directory(),
-            bytecode_path,
-            vk_path_output: vk_path.clone(),
-        }
-        .run(binary_path)?;
-
-        ContractCommand { crs_path: self.crs_directory(), vk_path }.run(binary_path)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::BTreeSet;
-
-    use acvm::acir::{
-        circuit::{Circuit, ExpressionWidth, Opcode, Program, PublicInputs},
-        native_types::{Expression, Witness},
-    };
-
-    use crate::{get_mock_backend, BackendError};
-
-    #[test]
-    fn test_smart_contract() -> Result<(), BackendError> {
-        let expression = &(Witness(1) + Witness(2)) - &Expression::from(Witness(3));
-        let constraint = Opcode::AssertZero(expression);
-
-        let circuit = Circuit {
-            current_witness_index: 4,
-            expression_width: ExpressionWidth::Bounded { width: 4 },
-            opcodes: vec![constraint],
-            private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
-            public_parameters: PublicInputs::default(),
-            return_values: PublicInputs::default(),
-            assert_messages: Default::default(),
-            recursive: false,
-        };
-        let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
-
-        let contract = get_mock_backend()?.eth_contract(&program)?;
-
-        assert!(contract.contains("contract VerifierContract"));
-
-        Ok(())
-    }
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/Cargo.lock b/tooling/backend_interface/test-binaries/mock_backend/Cargo.lock
deleted file mode 100644
index 3c14a936907..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/Cargo.lock
+++ /dev/null
@@ -1,223 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anstream"
-version = "0.6.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e2e1ebcb11de5c03c67de28a7df593d32191b44939c482e97702baaaa6ab6a5"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
-dependencies = [
- "anstyle",
- "windows-sys",
-]
-
-[[package]]
-name = "clap"
-version = "4.4.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e578d6ec4194633722ccf9544794b71b1385c3c027efe0c55db226fc880865c"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.4.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4df4df40ec50c46000231c914968278b1eb05098cf8f1b3a518a95030e71d1c7"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
-
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
-[[package]]
-name = "mock_backend"
-version = "0.1.0"
-dependencies = [
- "clap",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.76"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "syn"
-version = "2.0.48"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
-
-[[package]]
-name = "utf8parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
-
-[[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
diff --git a/tooling/backend_interface/test-binaries/mock_backend/Cargo.toml b/tooling/backend_interface/test-binaries/mock_backend/Cargo.toml
deleted file mode 100644
index f527b03a7b9..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[workspace]
-
-[package]
-name = "mock_backend"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-clap = { version = "4.3.19", features = ["derive"] }
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/contract_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/contract_cmd.rs
deleted file mode 100644
index 7ee41121d61..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/contract_cmd.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use clap::Args;
-use std::io::Write;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct ContractCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'k')]
-    pub(crate) vk_path: PathBuf,
-
-    #[clap(short = 'o')]
-    pub(crate) contract_path: PathBuf,
-}
-
-pub(crate) fn run(args: ContractCommand) {
-    assert!(args.vk_path.is_file(), "Could not find vk file at provided path");
-
-    std::io::stdout().write_all(b"contract VerifierContract {}").unwrap();
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/gates_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/gates_cmd.rs
deleted file mode 100644
index 3cc397d3292..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/gates_cmd.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use clap::Args;
-use std::io::Write;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct GatesCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'b')]
-    pub(crate) bytecode_path: PathBuf,
-}
-
-pub(crate) fn run(args: GatesCommand) {
-    assert!(args.bytecode_path.is_file(), "Could not find bytecode file at provided path");
-
-    std::io::stdout().write_all(&0u64.to_le_bytes()).unwrap();
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/main.rs b/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
deleted file mode 100644
index 74ea82d28f8..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![forbid(unsafe_code)]
-#![warn(unreachable_pub)]
-#![warn(clippy::semicolon_if_nothing_returned)]
-#![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
-
-use clap::{Parser, Subcommand};
-
-mod contract_cmd;
-mod gates_cmd;
-mod prove_cmd;
-mod verify_cmd;
-mod write_vk_cmd;
-
-#[derive(Parser, Debug)]
-#[command(name = "mock_backend")]
-struct BackendCli {
-    #[command(subcommand)]
-    command: BackendCommand,
-}
-
-#[derive(Subcommand, Clone, Debug)]
-enum BackendCommand {
-    Contract(contract_cmd::ContractCommand),
-    Gates(gates_cmd::GatesCommand),
-    Prove(prove_cmd::ProveCommand),
-    Verify(verify_cmd::VerifyCommand),
-    #[command(name = "write_vk")]
-    WriteVk(write_vk_cmd::WriteVkCommand),
-}
-
-fn main() {
-    let BackendCli { command } = BackendCli::parse();
-
-    match command {
-        BackendCommand::Contract(args) => contract_cmd::run(args),
-        BackendCommand::Gates(args) => gates_cmd::run(args),
-        BackendCommand::Prove(args) => prove_cmd::run(args),
-        BackendCommand::Verify(args) => verify_cmd::run(args),
-        BackendCommand::WriteVk(args) => write_vk_cmd::run(args),
-    };
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/prove_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/prove_cmd.rs
deleted file mode 100644
index 3967778d4e8..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/prove_cmd.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use clap::Args;
-use std::io::Write;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct ProveCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'b')]
-    pub(crate) bytecode_path: PathBuf,
-
-    #[clap(short = 'w')]
-    pub(crate) witness_path: PathBuf,
-
-    #[clap(short = 'o')]
-    pub(crate) proof_path: PathBuf,
-}
-
-pub(crate) fn run(args: ProveCommand) {
-    assert!(args.bytecode_path.is_file(), "Could not find bytecode file at provided path");
-    assert!(args.witness_path.is_file(), "Could not find witness file at provided path");
-
-    std::io::stdout().write_all(b"proof").unwrap();
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/verify_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/verify_cmd.rs
deleted file mode 100644
index 1a715eea880..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/verify_cmd.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use clap::Args;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct VerifyCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'p')]
-    pub(crate) proof_path: PathBuf,
-
-    #[clap(short = 'k')]
-    pub(crate) vk_path: PathBuf,
-
-    #[clap(short = 'r')]
-    pub(crate) is_recursive: bool,
-}
-
-pub(crate) fn run(args: VerifyCommand) {
-    assert!(args.vk_path.is_file(), "Could not find verification key file at provided path");
-    assert!(args.proof_path.is_file(), "Could not find proof file at provided path");
-
-    std::fs::write(args.proof_path, "proof").unwrap();
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/write_vk_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/write_vk_cmd.rs
deleted file mode 100644
index fcee224e85b..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/write_vk_cmd.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use clap::Args;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct WriteVkCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'b')]
-    pub(crate) bytecode_path: PathBuf,
-
-    #[clap(short = 'o')]
-    pub(crate) vk_path: PathBuf,
-}
-
-pub(crate) fn run(args: WriteVkCommand) {
-    assert!(args.bytecode_path.is_file(), "Could not find bytecode file at provided path");
-
-    std::fs::write(args.vk_path, "vk").unwrap();
-}
diff --git a/tooling/bb_abstraction_leaks/Cargo.toml b/tooling/bb_abstraction_leaks/Cargo.toml
deleted file mode 100644
index 972c78831a7..00000000000
--- a/tooling/bb_abstraction_leaks/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "bb_abstraction_leaks"
-description = "A crate which encapsulates knowledge about Barretenberg which is currently leaking into Nargo"
-version = "0.11.0"
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-acvm.workspace = true
-
-[build-dependencies]
-build-target = "0.4.0"
-const_format.workspace = true
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
deleted file mode 100644
index 45da7f9d00c..00000000000
--- a/tooling/bb_abstraction_leaks/build.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use build_target::{Arch, Os};
-use const_format::formatcp;
-
-// Useful for printing debugging messages during the build
-// macro_rules! p {
-//     ($($tokens: tt)*) => {
-//         println!("cargo:warning={}", format!($($tokens)*))
-//     }
-// }
-
-const USERNAME: &str = "AztecProtocol";
-const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.38.0";
-const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
-
-const API_URL: &str =
-    formatcp!("https://github.com/{}/{}/releases/download/{}", USERNAME, REPO, TAG);
-
-fn main() -> Result<(), String> {
-    // We need to inject which OS we're building for so that we can download the correct barretenberg binary.
-    let os = match build_target::target_os().unwrap() {
-        os @ (Os::Linux | Os::MacOs) => os,
-        Os::Windows => todo!("Windows is not currently supported"),
-        os_name => panic!("Unsupported OS {os_name}"),
-    };
-
-    let arch = match build_target::target_arch().unwrap() {
-        arch @ (Arch::X86_64 | Arch::AARCH64) => arch,
-        arch_name => panic!("Unsupported Architecture {arch_name}"),
-    };
-
-    // Arm builds of linux are not supported
-    // We do not panic because we allow users to run nargo without a backend.
-    if let (Os::Linux, Arch::AARCH64) = (&os, &arch) {
-        println!(
-            "cargo:warning=ARM64 builds of linux are not supported for the barretenberg binary"
-        );
-    };
-
-    println!("cargo:rustc-env=BB_BINARY_URL={}", get_bb_download_url(arch, os));
-    println!("cargo:rustc-env=BB_VERSION={}", VERSION);
-
-    Ok(())
-}
-
-fn get_bb_download_url(target_arch: Arch, target_os: Os) -> String {
-    let archive_name = match target_os {
-        Os::Linux => "barretenberg-x86_64-linux-gnu.tar.gz",
-        Os::MacOs => match target_arch {
-            Arch::AARCH64 => "barretenberg-aarch64-apple-darwin.tar.gz",
-            Arch::X86_64 => "barretenberg-x86_64-apple-darwin.tar.gz",
-            arch => panic!("unsupported arch {arch}"),
-        },
-        os => panic!("Unsupported OS {os}"),
-    };
-
-    format!("{API_URL}/{archive_name}")
-}
diff --git a/tooling/bb_abstraction_leaks/src/lib.rs b/tooling/bb_abstraction_leaks/src/lib.rs
deleted file mode 100644
index 56a4f58cd21..00000000000
--- a/tooling/bb_abstraction_leaks/src/lib.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![warn(unused_crate_dependencies, unused_extern_crates)]
-#![warn(unreachable_pub)]
-
-use acvm::{acir::native_types::WitnessMap, FieldElement};
-
-pub const ACVM_BACKEND_BARRETENBERG: &str = "acvm-backend-barretenberg";
-pub const BB_DOWNLOAD_URL: &str = env!("BB_BINARY_URL");
-pub const BB_VERSION: &str = env!("BB_VERSION");
-
-/// Removes the public inputs which are prepended to a proof by Barretenberg.
-pub fn remove_public_inputs(num_pub_inputs: usize, proof: &[u8]) -> Vec<u8> {
-    // Barretenberg prepends the public inputs onto the proof so we need to remove
-    // the first `num_pub_inputs` field elements.
-    let num_bytes_to_remove = num_pub_inputs * (FieldElement::max_num_bytes() as usize);
-    proof[num_bytes_to_remove..].to_vec()
-}
-
-/// Prepends a set of public inputs to a proof.
-pub fn prepend_public_inputs(proof: Vec<u8>, public_inputs: WitnessMap) -> Vec<u8> {
-    // We omit any unassigned witnesses.
-    // Witness values should be ordered by their index but we skip over any indices without an assignment.
-    let public_inputs_bytes =
-        public_inputs.into_iter().flat_map(|(_, assignment)| assignment.to_be_bytes());
-
-    public_inputs_bytes.chain(proof).collect()
-}
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index ea32c864a0b..646beaf0096 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -862,7 +862,11 @@ mod tests {
 
         let opcodes = vec![
             Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
-            Opcode::MemoryInit { block_id: BlockId(0), init: vec![] },
+            Opcode::MemoryInit {
+                block_id: BlockId(0),
+                init: vec![],
+                block_type: acvm::acir::circuit::opcodes::BlockType::Memory,
+            },
             Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
             Opcode::AssertZero(Expression::default()),
         ];
diff --git a/tooling/debugger/tests/debug.rs b/tooling/debugger/tests/debug.rs
index b104a2c84ac..313b6b30591 100644
--- a/tooling/debugger/tests/debug.rs
+++ b/tooling/debugger/tests/debug.rs
@@ -16,12 +16,6 @@ mod tests {
         let mut dbg_session =
             spawn_bash(Some(timeout_seconds * 1000)).expect("Could not start bash session");
 
-        // Set backend to `/dev/null` to force an error if nargo tries to speak to a backend.
-        dbg_session
-            .send_line("export NARGO_BACKEND_PATH=/dev/null")
-            .expect("Could not export NARGO_BACKEND_PATH.");
-        dbg_session.wait_for_prompt().expect("Could not export NARGO_BACKEND_PATH.");
-
         // Start debugger and test that it loads for the given program.
         dbg_session
             .execute(
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 249406effaf..87327b01e36 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -27,9 +27,13 @@ impl BlackBoxFunctionSolver for WrapperSolver {
     fn multi_scalar_mul(
         &self,
         points: &[acvm::FieldElement],
-        scalars: &[acvm::FieldElement],
-    ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
-        self.0.multi_scalar_mul(points, scalars)
+        scalars_lo: &[acvm::FieldElement],
+        scalars_hi: &[acvm::FieldElement],
+    ) -> Result<
+        (acvm::FieldElement, acvm::FieldElement, acvm::FieldElement),
+        acvm::BlackBoxResolutionError,
+    > {
+        self.0.multi_scalar_mul(points, scalars_lo, scalars_hi)
     }
 
     fn pedersen_hash(
@@ -44,10 +48,15 @@ impl BlackBoxFunctionSolver for WrapperSolver {
         &self,
         input1_x: &acvm::FieldElement,
         input1_y: &acvm::FieldElement,
+        input1_infinite: &acvm::FieldElement,
         input2_x: &acvm::FieldElement,
         input2_y: &acvm::FieldElement,
-    ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
-        self.0.ec_add(input1_x, input1_y, input2_x, input2_y)
+        input2_infinite: &acvm::FieldElement,
+    ) -> Result<
+        (acvm::FieldElement, acvm::FieldElement, acvm::FieldElement),
+        acvm::BlackBoxResolutionError,
+    > {
+        self.0.ec_add(input1_x, input1_y, input1_infinite, input2_x, input2_y, input2_infinite)
     }
 
     fn poseidon2_permutation(
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index 83bb4b94f82..a864da7c33c 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -9,7 +9,7 @@ use std::collections::{BTreeMap, HashMap};
 
 use fm::FileId;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 pub struct ContractOutputsArtifact {
     pub structs: HashMap<String, Vec<AbiType>>,
     pub globals: HashMap<String, Vec<AbiValue>>,
@@ -21,7 +21,7 @@ impl From<CompiledContractOutputs> for ContractOutputsArtifact {
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 pub struct ContractArtifact {
     /// Version of noir used to compile this contract
     pub noir_version: String,
@@ -51,7 +51,7 @@ impl From<CompiledContract> for ContractArtifact {
 ///
 /// A contract function unlike a regular Noir program however can have additional properties.
 /// One of these being a function type.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ContractFunctionArtifact {
     pub name: String,
 
diff --git a/tooling/nargo/src/artifacts/debug.rs b/tooling/nargo/src/artifacts/debug.rs
index 496896468cc..2570c3f5c9f 100644
--- a/tooling/nargo/src/artifacts/debug.rs
+++ b/tooling/nargo/src/artifacts/debug.rs
@@ -9,6 +9,7 @@ use std::{
 };
 
 pub use super::debug_vars::{DebugVars, StackFrame};
+use super::{contract::ContractArtifact, program::ProgramArtifact};
 use fm::{FileId, FileManager, PathString};
 
 /// A Debug Artifact stores, for a given program, the debug info for every function
@@ -128,6 +129,16 @@ impl From<CompiledProgram> for DebugArtifact {
     }
 }
 
+impl From<ProgramArtifact> for DebugArtifact {
+    fn from(program_artifact: ProgramArtifact) -> Self {
+        DebugArtifact {
+            debug_symbols: program_artifact.debug_symbols.debug_infos,
+            file_map: program_artifact.file_map,
+            warnings: Vec::new(),
+        }
+    }
+}
+
 impl From<CompiledContract> for DebugArtifact {
     fn from(compiled_artifact: CompiledContract) -> Self {
         let all_functions_debug: Vec<DebugInfo> = compiled_artifact
@@ -144,6 +155,22 @@ impl From<CompiledContract> for DebugArtifact {
     }
 }
 
+impl From<ContractArtifact> for DebugArtifact {
+    fn from(compiled_artifact: ContractArtifact) -> Self {
+        let all_functions_debug: Vec<DebugInfo> = compiled_artifact
+            .functions
+            .into_iter()
+            .flat_map(|contract_function| contract_function.debug_symbols.debug_infos)
+            .collect();
+
+        DebugArtifact {
+            debug_symbols: all_functions_debug,
+            file_map: compiled_artifact.file_map,
+            warnings: Vec::new(),
+        }
+    }
+}
+
 impl<'a> Files<'a> for DebugArtifact {
     type FileId = FileId;
     type Name = PathString;
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/nargo/src/artifacts/program.rs
index 67ac9f53ec8..3c25b9e3345 100644
--- a/tooling/nargo/src/artifacts/program.rs
+++ b/tooling/nargo/src/artifacts/program.rs
@@ -8,7 +8,7 @@ use noirc_driver::DebugFile;
 use noirc_errors::debug_info::ProgramDebugInfo;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct ProgramArtifact {
     pub noir_version: String,
 
diff --git a/tooling/nargo/src/constants.rs b/tooling/nargo/src/constants.rs
index 0b50d61fe37..1048d86fcd7 100644
--- a/tooling/nargo/src/constants.rs
+++ b/tooling/nargo/src/constants.rs
@@ -13,8 +13,6 @@ pub const EXPORT_DIR: &str = "export";
 // Files
 /// The file from which Nargo pulls prover inputs
 pub const PROVER_INPUT_FILE: &str = "Prover";
-/// The file from which Nargo pulls verifier inputs
-pub const VERIFIER_INPUT_FILE: &str = "Verifier";
 /// The package definition file for a Noir project.
 pub const PKG_FILE: &str = "Nargo.toml";
 
diff --git a/tooling/nargo/src/package.rs b/tooling/nargo/src/package.rs
index ecbf3585210..44f0a3504f7 100644
--- a/tooling/nargo/src/package.rs
+++ b/tooling/nargo/src/package.rs
@@ -2,7 +2,7 @@ use std::{collections::BTreeMap, fmt::Display, path::PathBuf};
 
 use noirc_frontend::graph::CrateName;
 
-use crate::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
+use crate::constants::PROVER_INPUT_FILE;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum PackageType {
@@ -59,11 +59,6 @@ impl Package {
         // For now it is hard-coded to be toml.
         self.root_dir.join(format!("{PROVER_INPUT_FILE}.toml"))
     }
-    pub fn verifier_input_path(&self) -> PathBuf {
-        // TODO: This should be configurable, such as if we are looking for .json or .toml or custom paths
-        // For now it is hard-coded to be toml.
-        self.root_dir.join(format!("{VERIFIER_INPUT_FILE}.toml"))
-    }
 
     pub fn is_binary(&self) -> bool {
         self.package_type == PackageType::Binary
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index c20be037e62..d10dd6a22ff 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -43,11 +43,10 @@ thiserror.workspace = true
 tower.workspace = true
 async-lsp = { workspace = true, features = ["client-monitor", "stdio", "tracing", "tokio"] }
 const_format.workspace = true
-hex.workspace = true
 similar-asserts.workspace = true
 termcolor = "1.1.2"
 color-eyre = "0.6.2"
-tokio = { version = "1.0", features = ["io-std"] }
+tokio = { version = "1.0", features = ["io-std", "rt"] }
 dap.workspace = true
 clap-markdown = { git = "https://github.com/noir-lang/clap-markdown", rev = "450d759532c88f0dba70891ceecdbc9ff8f25d2b", optional = true }
 
@@ -55,9 +54,6 @@ notify = "6.1.1"
 notify-debouncer-full = "0.3.1"
 termion = "3.0.0"
 
-# Backends
-backend-interface = { path = "../backend_interface" }
-
 # Logs
 tracing-subscriber.workspace = true
 tracing-appender = "0.2.3"
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 0ed2d4c07f7..74042cf4e40 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -63,7 +63,6 @@ fn execution_success_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("execute").arg("--force");
 
@@ -101,7 +100,6 @@ fn execution_failure_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("execute").arg("--force");
 
@@ -139,7 +137,6 @@ fn noir_test_success_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("test");
 
@@ -177,7 +174,6 @@ fn noir_test_failure_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("test");
 
@@ -218,7 +214,6 @@ fn compile_success_empty_{test_name}() {{
 
     let test_program_dir = PathBuf::from("{test_dir}");
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("info");
     cmd.arg("--json");
@@ -269,7 +264,6 @@ fn compile_success_contract_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("compile").arg("--force");
 
@@ -307,7 +301,6 @@ fn compile_failure_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.env("NARGO_BACKEND_PATH", path_to_mock_backend());
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("compile").arg("--force");
 
diff --git a/tooling/nargo_cli/src/backends.rs b/tooling/nargo_cli/src/backends.rs
deleted file mode 100644
index 2b3e9d8861f..00000000000
--- a/tooling/nargo_cli/src/backends.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use std::path::PathBuf;
-
-use backend_interface::backends_directory;
-pub(crate) use backend_interface::Backend;
-
-fn active_backend_file_path() -> PathBuf {
-    backends_directory().join(".selected_backend")
-}
-
-pub(crate) use backend_interface::ACVM_BACKEND_BARRETENBERG;
-
-pub(crate) fn clear_active_backend() {
-    let active_backend_file = active_backend_file_path();
-    if active_backend_file.is_file() {
-        std::fs::remove_file(active_backend_file_path())
-            .expect("should delete active backend file");
-    }
-}
-
-pub(crate) fn set_active_backend(backend_name: &str) {
-    let active_backend_file = active_backend_file_path();
-    let backends_directory =
-        active_backend_file.parent().expect("active backend file should have parent");
-
-    std::fs::create_dir_all(backends_directory).expect("Could not create backends directory");
-    std::fs::write(active_backend_file, backend_name.as_bytes())
-        .expect("Could not write to active backend file");
-}
-
-pub(crate) fn get_active_backend() -> String {
-    let active_backend_file = active_backend_file_path();
-
-    if !active_backend_file.is_file() {
-        set_active_backend(ACVM_BACKEND_BARRETENBERG);
-        return ACVM_BACKEND_BARRETENBERG.to_string();
-    }
-
-    std::fs::read_to_string(active_backend_file).expect("Could not read active backend file")
-}
diff --git a/tooling/nargo_cli/src/cli/backend_cmd/current_cmd.rs b/tooling/nargo_cli/src/cli/backend_cmd/current_cmd.rs
deleted file mode 100644
index 5aba00764d3..00000000000
--- a/tooling/nargo_cli/src/cli/backend_cmd/current_cmd.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use clap::Args;
-
-use crate::{backends::get_active_backend, errors::CliError};
-
-/// Prints the name of the currently active backend
-#[derive(Debug, Clone, Args)]
-pub(crate) struct CurrentCommand;
-
-pub(crate) fn run(_args: CurrentCommand) -> Result<(), CliError> {
-    println!("{}", get_active_backend());
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/backend_cmd/install_cmd.rs b/tooling/nargo_cli/src/cli/backend_cmd/install_cmd.rs
deleted file mode 100644
index 974db9ff7f5..00000000000
--- a/tooling/nargo_cli/src/cli/backend_cmd/install_cmd.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use clap::Args;
-
-use backend_interface::{backends_directory, download_backend};
-
-use crate::errors::{BackendError, CliError};
-
-use super::ls_cmd::get_available_backends;
-
-/// Install a new backend from a URL.
-#[derive(Debug, Clone, Args)]
-pub(crate) struct InstallCommand {
-    /// The name of the backend to install.
-    backend: String,
-
-    /// The URL from which to download the backend.
-    url: String,
-}
-
-pub(crate) fn run(args: InstallCommand) -> Result<(), CliError> {
-    let installed_backends = get_available_backends();
-
-    if installed_backends.contains(&args.backend) {
-        return Err(BackendError::AlreadyInstalled(args.backend).into());
-    }
-
-    download_backend(&args.url, &backends_directory().join(args.backend).join("backend_binary"))
-        .map_err(BackendError::from)?;
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/backend_cmd/ls_cmd.rs b/tooling/nargo_cli/src/cli/backend_cmd/ls_cmd.rs
deleted file mode 100644
index da37b104d65..00000000000
--- a/tooling/nargo_cli/src/cli/backend_cmd/ls_cmd.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use backend_interface::backends_directory;
-use clap::Args;
-
-use crate::errors::CliError;
-
-/// Prints the list of currently installed backends
-#[derive(Debug, Clone, Args)]
-pub(crate) struct LsCommand;
-
-pub(crate) fn run(_args: LsCommand) -> Result<(), CliError> {
-    for backend in get_available_backends() {
-        println!("{backend}");
-    }
-
-    Ok(())
-}
-
-pub(super) fn get_available_backends() -> Vec<String> {
-    let backend_directory_contents = std::fs::read_dir(backends_directory())
-        .expect("Could not read backends directory contents");
-
-    // TODO: Highlight the currently active backend.
-    backend_directory_contents
-        .into_iter()
-        .filter_map(|entry| {
-            let path = entry.ok()?.path();
-            if path.is_dir() {
-                path.file_name().map(|name| name.to_string_lossy().to_string())
-            } else {
-                None
-            }
-        })
-        .collect()
-}
diff --git a/tooling/nargo_cli/src/cli/backend_cmd/mod.rs b/tooling/nargo_cli/src/cli/backend_cmd/mod.rs
deleted file mode 100644
index 985dbbdb934..00000000000
--- a/tooling/nargo_cli/src/cli/backend_cmd/mod.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use clap::{Args, Subcommand};
-
-use crate::errors::CliError;
-
-mod current_cmd;
-mod install_cmd;
-mod ls_cmd;
-mod uninstall_cmd;
-mod use_cmd;
-
-#[non_exhaustive]
-#[derive(Args, Clone, Debug)]
-/// Install and select custom backends used to generate and verify proofs.
-pub(crate) struct BackendCommand {
-    #[command(subcommand)]
-    command: BackendCommands,
-}
-
-#[non_exhaustive]
-#[derive(Subcommand, Clone, Debug)]
-pub(crate) enum BackendCommands {
-    Current(current_cmd::CurrentCommand),
-    Ls(ls_cmd::LsCommand),
-    Use(use_cmd::UseCommand),
-    Install(install_cmd::InstallCommand),
-    Uninstall(uninstall_cmd::UninstallCommand),
-}
-
-pub(crate) fn run(cmd: BackendCommand) -> Result<(), CliError> {
-    let BackendCommand { command } = cmd;
-
-    match command {
-        BackendCommands::Current(args) => current_cmd::run(args),
-        BackendCommands::Ls(args) => ls_cmd::run(args),
-        BackendCommands::Use(args) => use_cmd::run(args),
-        BackendCommands::Install(args) => install_cmd::run(args),
-        BackendCommands::Uninstall(args) => uninstall_cmd::run(args),
-    }?;
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/backend_cmd/uninstall_cmd.rs b/tooling/nargo_cli/src/cli/backend_cmd/uninstall_cmd.rs
deleted file mode 100644
index 7497f1bc2f6..00000000000
--- a/tooling/nargo_cli/src/cli/backend_cmd/uninstall_cmd.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use clap::Args;
-
-use backend_interface::backends_directory;
-
-use crate::{
-    backends::{
-        clear_active_backend, get_active_backend, set_active_backend, ACVM_BACKEND_BARRETENBERG,
-    },
-    errors::{BackendError, CliError},
-};
-
-use super::ls_cmd::get_available_backends;
-
-/// Uninstalls a backend
-#[derive(Debug, Clone, Args)]
-pub(crate) struct UninstallCommand {
-    /// The name of the backend to uninstall.
-    backend: String,
-}
-
-pub(crate) fn run(args: UninstallCommand) -> Result<(), CliError> {
-    let installed_backends = get_available_backends();
-
-    if !installed_backends.contains(&args.backend) {
-        return Err(BackendError::UnknownBackend(args.backend).into());
-    }
-
-    let active_backend = get_active_backend();
-
-    // Handle the case where we're uninstalling the currently active backend.
-    if active_backend == args.backend {
-        let barretenberg_is_installed =
-            installed_backends.iter().any(|backend_name| backend_name == ACVM_BACKEND_BARRETENBERG);
-
-        let new_active_backend =
-            if args.backend != ACVM_BACKEND_BARRETENBERG && barretenberg_is_installed {
-                // Prefer switching to barretenberg if possible.
-                Some(ACVM_BACKEND_BARRETENBERG)
-            } else {
-                // Otherwise pick the first backend which isn't being uninstalled.
-                installed_backends
-                    .iter()
-                    .find(|&backend_name| backend_name != &args.backend)
-                    .map(|name| name.as_str())
-            };
-
-        if let Some(backend) = new_active_backend {
-            set_active_backend(backend);
-        } else {
-            // We've deleted the last backend. Clear the active backend file to be recreated once we install a new one.
-            clear_active_backend();
-        }
-    }
-
-    std::fs::remove_dir_all(backends_directory().join(args.backend))
-        .expect("backend directory should be deleted");
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/backend_cmd/use_cmd.rs b/tooling/nargo_cli/src/cli/backend_cmd/use_cmd.rs
deleted file mode 100644
index 66a129c2148..00000000000
--- a/tooling/nargo_cli/src/cli/backend_cmd/use_cmd.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use clap::Args;
-
-use crate::{
-    backends::set_active_backend,
-    errors::{BackendError, CliError},
-};
-
-use super::ls_cmd::get_available_backends;
-
-/// Select the backend to use
-#[derive(Debug, Clone, Args)]
-pub(crate) struct UseCommand {
-    backend: String,
-}
-
-pub(crate) fn run(args: UseCommand) -> Result<(), CliError> {
-    let backends = get_available_backends();
-
-    if !backends.contains(&args.backend) {
-        return Err(BackendError::UnknownBackend(args.backend).into());
-    }
-
-    set_active_backend(&args.backend);
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index d5313d96076..e2e1f147b90 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -95,13 +95,11 @@ fn check_package(
         Ok(false)
     } else {
         // XXX: We can have a --overwrite flag to determine if you want to overwrite the Prover/Verifier.toml files
-        if let Some((parameters, return_type)) = compute_function_abi(&context, &crate_id) {
+        if let Some((parameters, _)) = compute_function_abi(&context, &crate_id) {
             let path_to_prover_input = package.prover_input_path();
-            let path_to_verifier_input = package.verifier_input_path();
 
             // Before writing the file, check if it exists and whether overwrite is set
             let should_write_prover = !path_to_prover_input.exists() || allow_overwrite;
-            let should_write_verifier = !path_to_verifier_input.exists() || allow_overwrite;
 
             if should_write_prover {
                 let prover_toml = create_input_toml_template(parameters.clone(), None);
@@ -110,19 +108,7 @@ fn check_package(
                 eprintln!("Note: Prover.toml already exists. Use --overwrite to force overwrite.");
             }
 
-            if should_write_verifier {
-                let public_inputs =
-                    parameters.into_iter().filter(|param| param.is_public()).collect();
-
-                let verifier_toml = create_input_toml_template(public_inputs, return_type);
-                write_to_file(verifier_toml.as_bytes(), &path_to_verifier_input);
-            } else {
-                eprintln!(
-                    "Note: Verifier.toml already exists. Use --overwrite to force overwrite."
-                );
-            }
-
-            let any_file_written = should_write_prover || should_write_verifier;
+            let any_file_written = should_write_prover;
 
             Ok(any_file_written)
         } else {
diff --git a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
deleted file mode 100644
index 8c64d9cd935..00000000000
--- a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use super::fs::{create_named_dir, write_to_file};
-use super::NargoConfig;
-use crate::backends::Backend;
-use crate::errors::CliError;
-
-use clap::Args;
-use nargo::ops::{compile_program, report_errors};
-use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_driver::{file_manager_with_stdlib, CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
-use noirc_frontend::graph::CrateName;
-
-/// Generates a Solidity verifier smart contract for the program
-#[derive(Debug, Clone, Args)]
-pub(crate) struct CodegenVerifierCommand {
-    /// The name of the package to codegen
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Codegen all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
-
-    #[clap(flatten)]
-    compile_options: CompileOptions,
-}
-
-pub(crate) fn run(
-    backend: &Backend,
-    args: CodegenVerifierCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
-    let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
-    let workspace = resolve_workspace_from_toml(
-        &toml_path,
-        selection,
-        Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
-    )?;
-
-    let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
-
-    let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
-    for package in binary_packages {
-        let compilation_result = compile_program(
-            &workspace_file_manager,
-            &parsed_files,
-            package,
-            &args.compile_options,
-            None,
-        );
-
-        let program = report_errors(
-            compilation_result,
-            &workspace_file_manager,
-            args.compile_options.deny_warnings,
-            args.compile_options.silence_warnings,
-        )?;
-
-        let program = nargo::ops::transform_program(program, args.compile_options.expression_width);
-
-        // TODO(https://github.com/noir-lang/noir/issues/4428):
-        // We do not expect to have a smart contract verifier for a foldable program with multiple circuits.
-        // However, in the future we can expect to possibly have non-inlined ACIR functions during compilation
-        // that will be inlined at a later step such as by the ACVM compiler or by the backend.
-        // Add appropriate handling here once the compiler enables multiple ACIR functions.
-        assert_eq!(program.program.functions.len(), 1);
-        let smart_contract_string = backend.eth_contract(&program.program)?;
-
-        let contract_dir = workspace.contracts_directory_path(package);
-        create_named_dir(&contract_dir, "contract");
-        let contract_path = contract_dir.join("plonk_vk").with_extension("sol");
-
-        let path = write_to_file(smart_contract_string.as_bytes(), &contract_path);
-        println!("[{}] Contract successfully created and located at {path}", package.name);
-    }
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 2f878406939..ecf2e2e9f53 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -22,7 +22,6 @@ use notify_debouncer_full::new_debouncer;
 
 use crate::errors::CliError;
 
-use super::fs::program::only_acir;
 use super::fs::program::{read_program_from_file, save_contract_to_file, save_program_to_file};
 use super::NargoConfig;
 use rayon::prelude::*;
@@ -111,7 +110,7 @@ fn watch_workspace(workspace: &Workspace, compile_options: &CompileOptions) -> n
     Ok(())
 }
 
-fn compile_workspace_full(
+pub(super) fn compile_workspace_full(
     workspace: &Workspace,
     compile_options: &CompileOptions,
 ) -> Result<(), CliError> {
@@ -136,10 +135,9 @@ fn compile_workspace_full(
         .partition(|package| package.is_binary());
 
     // Save build artifacts to disk.
-    let only_acir = compile_options.only_acir;
     for (package, program) in binary_packages.into_iter().zip(compiled_programs) {
         let program = nargo::ops::transform_program(program, compile_options.expression_width);
-        save_program(program.clone(), &package, &workspace.target_directory_path(), only_acir);
+        save_program(program.clone(), &package, &workspace.target_directory_path());
     }
     let circuit_dir = workspace.target_directory_path();
     for (package, contract) in contract_packages.into_iter().zip(compiled_contracts) {
@@ -197,18 +195,9 @@ pub(super) fn compile_workspace(
     }
 }
 
-pub(super) fn save_program(
-    program: CompiledProgram,
-    package: &Package,
-    circuit_dir: &Path,
-    only_acir_opt: bool,
-) {
-    if only_acir_opt {
-        only_acir(program.program, circuit_dir);
-    } else {
-        let program_artifact = ProgramArtifact::from(program.clone());
-        save_program_to_file(&program_artifact, &package.name, circuit_dir);
-    }
+pub(super) fn save_program(program: CompiledProgram, package: &Package, circuit_dir: &Path) {
+    let program_artifact = ProgramArtifact::from(program.clone());
+    save_program_to_file(&program_artifact, &package.name, circuit_dir);
 }
 
 fn save_contract(contract: CompiledContract, package: &Package, circuit_dir: &Path) {
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 68f902dfe33..862a46884ef 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -5,19 +5,18 @@ use clap::Args;
 use nargo::artifacts::debug::DebugArtifact;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::errors::try_to_diagnose_runtime_error;
-use nargo::ops::{compile_program, report_errors, DefaultForeignCallExecutor};
+use nargo::ops::DefaultForeignCallExecutor;
 use nargo::package::Package;
-use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_abi::input_parser::{Format, InputValue};
 use noirc_abi::InputMap;
-use noirc_driver::{
-    file_manager_with_stdlib, CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING,
-};
+use noirc_driver::{CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_frontend::graph::CrateName;
 
+use super::compile_cmd::compile_workspace_full;
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
+use crate::cli::fs::program::read_program_from_file;
 use crate::errors::CliError;
 
 /// Executes a circuit to calculate its return value
@@ -59,32 +58,16 @@ pub(crate) fn run(args: ExecuteCommand, config: NargoConfig) -> Result<(), CliEr
     )?;
     let target_dir = &workspace.target_directory_path();
 
-    let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
+    // Compile the full workspace in order to generate any build artifacts.
+    compile_workspace_full(&workspace, &args.compile_options)?;
 
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
-        let compilation_result = compile_program(
-            &workspace_file_manager,
-            &parsed_files,
-            package,
-            &args.compile_options,
-            None,
-        );
-
-        let compiled_program = report_errors(
-            compilation_result,
-            &workspace_file_manager,
-            args.compile_options.deny_warnings,
-            args.compile_options.silence_warnings,
-        )?;
-
-        let compiled_program =
-            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
+        let program_artifact_path = workspace.package_build_path(package);
+        let program: CompiledProgram = read_program_from_file(program_artifact_path)?.into();
 
         let (return_value, witness_stack) = execute_program_and_decode(
-            compiled_program,
+            program,
             package,
             &args.prover_name,
             args.oracle_resolver.as_deref(),
diff --git a/tooling/nargo_cli/src/cli/fs/inputs.rs b/tooling/nargo_cli/src/cli/fs/inputs.rs
index bd038c51ad5..dee9a00507c 100644
--- a/tooling/nargo_cli/src/cli/fs/inputs.rs
+++ b/tooling/nargo_cli/src/cli/fs/inputs.rs
@@ -6,8 +6,6 @@ use std::{collections::BTreeMap, path::Path};
 
 use crate::errors::FilesystemError;
 
-use super::write_to_file;
-
 /// Returns the circuit's parameters and its return value, if one exists.
 /// # Examples
 ///
@@ -36,99 +34,3 @@ pub(crate) fn read_inputs_from_file<P: AsRef<Path>>(
 
     Ok((input_map, return_value))
 }
-
-pub(crate) fn write_inputs_to_file<P: AsRef<Path>>(
-    input_map: &InputMap,
-    return_value: &Option<InputValue>,
-    abi: &Abi,
-    path: P,
-    file_name: &str,
-    format: Format,
-) -> Result<(), FilesystemError> {
-    let file_path = path.as_ref().join(file_name).with_extension(format.ext());
-
-    // We must insert the return value into the `InputMap` in order for it to be written to file.
-    let serialized_output = match return_value {
-        // Parameters and return values are kept separate except for when they're being written to file.
-        // As a result, we don't want to modify the original map and must clone it before insertion.
-        Some(return_value) => {
-            let mut input_map = input_map.clone();
-            input_map.insert(MAIN_RETURN_NAME.to_owned(), return_value.clone());
-            format.serialize(&input_map, abi)?
-        }
-        // If no return value exists, then we can serialize the original map directly.
-        None => format.serialize(input_map, abi)?,
-    };
-
-    write_to_file(serialized_output.as_bytes(), &file_path);
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{collections::BTreeMap, vec};
-
-    use acvm::FieldElement;
-    use nargo::constants::VERIFIER_INPUT_FILE;
-    use noirc_abi::{
-        input_parser::{Format, InputValue},
-        Abi, AbiParameter, AbiReturnType, AbiType, AbiVisibility,
-    };
-    use tempfile::TempDir;
-
-    use super::{read_inputs_from_file, write_inputs_to_file};
-
-    #[test]
-    fn write_and_read_recovers_inputs_and_return_value() {
-        let input_dir = TempDir::new().unwrap().into_path();
-
-        // We purposefully test a simple ABI here as we're focussing on `fs`.
-        // Tests for serializing complex types should exist in `noirc_abi`.
-        let abi = Abi {
-            parameters: vec![
-                AbiParameter {
-                    name: "foo".into(),
-                    typ: AbiType::Field,
-                    visibility: AbiVisibility::Public,
-                },
-                AbiParameter {
-                    name: "bar".into(),
-                    typ: AbiType::String { length: 11 },
-                    visibility: AbiVisibility::Private,
-                },
-            ],
-            return_type: Some(AbiReturnType {
-                abi_type: AbiType::Field,
-                visibility: AbiVisibility::Public,
-            }),
-
-            // Input serialization is only dependent on types, not position in witness map.
-            // Neither of these should be relevant so we leave them empty.
-            param_witnesses: BTreeMap::new(),
-            return_witnesses: Vec::new(),
-            error_types: BTreeMap::new(),
-        };
-        let input_map = BTreeMap::from([
-            ("foo".to_owned(), InputValue::Field(42u128.into())),
-            ("bar".to_owned(), InputValue::String("hello world".to_owned())),
-        ]);
-        let return_value = Some(InputValue::Field(FieldElement::zero()));
-
-        write_inputs_to_file(
-            &input_map,
-            &return_value,
-            &abi,
-            &input_dir,
-            VERIFIER_INPUT_FILE,
-            Format::Toml,
-        )
-        .unwrap();
-
-        let (loaded_inputs, loaded_return_value) =
-            read_inputs_from_file(input_dir, VERIFIER_INPUT_FILE, Format::Toml, &abi).unwrap();
-
-        assert_eq!(loaded_inputs, input_map);
-        assert_eq!(loaded_return_value, return_value);
-    }
-}
diff --git a/tooling/nargo_cli/src/cli/fs/mod.rs b/tooling/nargo_cli/src/cli/fs/mod.rs
index 4ebce3b3325..8658bd5b248 100644
--- a/tooling/nargo_cli/src/cli/fs/mod.rs
+++ b/tooling/nargo_cli/src/cli/fs/mod.rs
@@ -4,11 +4,8 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use crate::errors::FilesystemError;
-
 pub(super) mod inputs;
 pub(super) mod program;
-pub(super) mod proof;
 pub(super) mod witness;
 
 pub(super) fn create_named_dir(named_dir: &Path, name: &str) -> PathBuf {
@@ -31,12 +28,3 @@ pub(super) fn write_to_file(bytes: &[u8], path: &Path) -> String {
         Ok(_) => display.to_string(),
     }
 }
-
-pub(super) fn load_hex_data<P: AsRef<Path>>(path: P) -> Result<Vec<u8>, FilesystemError> {
-    let hex_data: Vec<_> = std::fs::read(&path)
-        .map_err(|_| FilesystemError::PathNotValid(path.as_ref().to_path_buf()))?;
-
-    let raw_bytes = hex::decode(hex_data).map_err(FilesystemError::HexArtifactNotValid)?;
-
-    Ok(raw_bytes)
-}
diff --git a/tooling/nargo_cli/src/cli/fs/program.rs b/tooling/nargo_cli/src/cli/fs/program.rs
index 77005e8d5af..ba017651667 100644
--- a/tooling/nargo_cli/src/cli/fs/program.rs
+++ b/tooling/nargo_cli/src/cli/fs/program.rs
@@ -1,6 +1,5 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::circuit::Program;
 use nargo::artifacts::{contract::ContractArtifact, program::ProgramArtifact};
 use noirc_frontend::graph::CrateName;
 
@@ -17,16 +16,6 @@ pub(crate) fn save_program_to_file<P: AsRef<Path>>(
     save_build_artifact_to_file(program_artifact, &circuit_name, circuit_dir)
 }
 
-/// Writes the bytecode as acir.gz
-pub(crate) fn only_acir<P: AsRef<Path>>(program: Program, circuit_dir: P) -> PathBuf {
-    create_named_dir(circuit_dir.as_ref(), "target");
-    let circuit_path = circuit_dir.as_ref().join("acir").with_extension("gz");
-    let bytes = Program::serialize_program(&program);
-    write_to_file(&bytes, &circuit_path);
-
-    circuit_path
-}
-
 pub(crate) fn save_contract_to_file<P: AsRef<Path>>(
     compiled_contract: &ContractArtifact,
     circuit_name: &str,
diff --git a/tooling/nargo_cli/src/cli/fs/proof.rs b/tooling/nargo_cli/src/cli/fs/proof.rs
deleted file mode 100644
index d2b3050708b..00000000000
--- a/tooling/nargo_cli/src/cli/fs/proof.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use nargo::constants::PROOF_EXT;
-
-use crate::errors::FilesystemError;
-
-use super::{create_named_dir, write_to_file};
-
-pub(crate) fn save_proof_to_dir<P: AsRef<Path>>(
-    proof: &[u8],
-    proof_name: &str,
-    proof_dir: P,
-) -> Result<PathBuf, FilesystemError> {
-    create_named_dir(proof_dir.as_ref(), "proof");
-    let proof_path = proof_dir.as_ref().join(proof_name).with_extension(PROOF_EXT);
-
-    write_to_file(hex::encode(proof).as_bytes(), &proof_path);
-
-    Ok(proof_path)
-}
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index cac3c36f904..11cf6e22ab5 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -1,28 +1,25 @@
 use std::collections::HashMap;
 
-use acvm::acir::circuit::{ExpressionWidth, Program};
-use backend_interface::BackendError;
+use acvm::acir::circuit::ExpressionWidth;
 use clap::Args;
 use iter_extended::vecmap;
 use nargo::{
-    artifacts::debug::DebugArtifact, insert_all_files_for_workspace_into_file_manager,
-    ops::report_errors, package::Package, parse_all,
+    artifacts::{debug::DebugArtifact, program::ProgramArtifact},
+    package::Package,
 };
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_driver::{
-    file_manager_with_stdlib, CompileOptions, CompiledContract, CompiledProgram,
-    NOIR_ARTIFACT_VERSION_STRING,
-};
+use noirc_driver::{CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_errors::{debug_info::OpCodesCount, Location};
 use noirc_frontend::graph::CrateName;
 use prettytable::{row, table, Row};
 use rayon::prelude::*;
 use serde::Serialize;
 
-use crate::backends::Backend;
 use crate::errors::CliError;
 
-use super::{compile_cmd::compile_workspace, NargoConfig};
+use super::{
+    compile_cmd::compile_workspace_full, fs::program::read_program_from_file, NargoConfig,
+};
 
 /// Provides detailed information on each of a program's function (represented by a single circuit)
 ///
@@ -51,11 +48,7 @@ pub(crate) struct InfoCommand {
     compile_options: CompileOptions,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: InfoCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
@@ -66,79 +59,42 @@ pub(crate) fn run(
         Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
     )?;
 
-    let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
-
-    let compiled_workspace = compile_workspace(
-        &workspace_file_manager,
-        &parsed_files,
-        &workspace,
-        &args.compile_options,
-    );
-
-    let (compiled_programs, compiled_contracts) = report_errors(
-        compiled_workspace,
-        &workspace_file_manager,
-        args.compile_options.deny_warnings,
-        args.compile_options.silence_warnings,
-    )?;
+    // Compile the full workspace in order to generate any build artifacts.
+    compile_workspace_full(&workspace, &args.compile_options)?;
 
-    let compiled_programs = vecmap(compiled_programs, |program| {
-        nargo::ops::transform_program(program, args.compile_options.expression_width)
-    });
-    let compiled_contracts = vecmap(compiled_contracts, |contract| {
-        nargo::ops::transform_contract(contract, args.compile_options.expression_width)
-    });
+    let binary_packages: Vec<(Package, ProgramArtifact)> = workspace
+        .into_iter()
+        .filter(|package| package.is_binary())
+        .map(|package| -> Result<(Package, ProgramArtifact), CliError> {
+            let program_artifact_path = workspace.package_build_path(package);
+            let program = read_program_from_file(program_artifact_path)?;
+            Ok((package.clone(), program))
+        })
+        .collect::<Result<_, _>>()?;
 
     if args.profile_info {
-        for compiled_program in &compiled_programs {
+        for (_, compiled_program) in &binary_packages {
             let debug_artifact = DebugArtifact::from(compiled_program.clone());
-            for function_debug in compiled_program.debug.iter() {
+            for function_debug in compiled_program.debug_symbols.debug_infos.iter() {
                 let span_opcodes = function_debug.count_span_opcodes();
                 print_span_opcodes(span_opcodes, &debug_artifact);
             }
         }
-
-        for compiled_contract in &compiled_contracts {
-            let debug_artifact = DebugArtifact::from(compiled_contract.clone());
-            let functions = &compiled_contract.functions;
-            for contract_function in functions {
-                for function_debug in contract_function.debug.iter() {
-                    let span_opcodes = function_debug.count_span_opcodes();
-                    print_span_opcodes(span_opcodes, &debug_artifact);
-                }
-            }
-        }
     }
 
-    let binary_packages =
-        workspace.into_iter().filter(|package| package.is_binary()).zip(compiled_programs);
-
     let program_info = binary_packages
+        .into_iter()
         .par_bridge()
         .map(|(package, program)| {
             count_opcodes_and_gates_in_program(
-                backend,
                 program,
-                package,
-                args.compile_options.expression_width,
-            )
-        })
-        .collect::<Result<_, _>>()?;
-
-    let contract_info = compiled_contracts
-        .into_par_iter()
-        .map(|contract| {
-            count_opcodes_and_gates_in_contract(
-                backend,
-                contract,
+                &package,
                 args.compile_options.expression_width,
             )
         })
-        .collect::<Result<_, _>>()?;
+        .collect();
 
-    let info_report = InfoReport { programs: program_info, contracts: contract_info };
+    let info_report = InfoReport { programs: program_info, contracts: Vec::new() };
 
     if args.json {
         // Expose machine-readable JSON data.
@@ -156,23 +112,6 @@ pub(crate) fn run(
             }
             program_table.printstd();
         }
-        if !info_report.contracts.is_empty() {
-            let mut contract_table = table!([
-                Fm->"Contract",
-                Fm->"Function",
-                Fm->"Expression Width",
-                Fm->"ACIR Opcodes",
-                Fm->"Backend Circuit Size"
-            ]);
-            for contract_info in info_report.contracts {
-                let contract_rows: Vec<Row> = contract_info.into();
-                for row in contract_rows {
-                    contract_table.add_row(row);
-                }
-            }
-
-            contract_table.printstd();
-        }
     }
 
     Ok(())
@@ -249,7 +188,6 @@ impl From<ProgramInfo> for Vec<Row> {
                 Fc->format!("{}", function.name),
                 format!("{:?}", program_info.expression_width),
                 Fc->format!("{}", function.acir_opcodes),
-                Fc->format!("{}", function.circuit_size),
             ]
         })
     }
@@ -268,7 +206,6 @@ struct ContractInfo {
 struct FunctionInfo {
     name: String,
     acir_opcodes: usize,
-    circuit_size: u32,
 }
 
 impl From<ContractInfo> for Vec<Row> {
@@ -279,56 +216,26 @@ impl From<ContractInfo> for Vec<Row> {
                 Fc->format!("{}", function.name),
                 format!("{:?}", contract_info.expression_width),
                 Fc->format!("{}", function.acir_opcodes),
-                Fc->format!("{}", function.circuit_size),
             ]
         })
     }
 }
 
 fn count_opcodes_and_gates_in_program(
-    backend: &Backend,
-    compiled_program: CompiledProgram,
+    compiled_program: ProgramArtifact,
     package: &Package,
     expression_width: ExpressionWidth,
-) -> Result<ProgramInfo, CliError> {
+) -> ProgramInfo {
     let functions = compiled_program
-        .program
+        .bytecode
         .functions
         .into_par_iter()
         .enumerate()
-        .map(|(i, function)| -> Result<_, BackendError> {
-            Ok(FunctionInfo {
-                name: compiled_program.names[i].clone(),
-                acir_opcodes: function.opcodes.len(),
-                // Unconstrained functions do not matter to a backend circuit count so we pass nothing here
-                circuit_size: backend.get_exact_circuit_size(&Program {
-                    functions: vec![function],
-                    unconstrained_functions: Vec::new(),
-                })?,
-            })
-        })
-        .collect::<Result<_, _>>()?;
-
-    Ok(ProgramInfo { package_name: package.name.to_string(), expression_width, functions })
-}
-
-fn count_opcodes_and_gates_in_contract(
-    backend: &Backend,
-    contract: CompiledContract,
-    expression_width: ExpressionWidth,
-) -> Result<ContractInfo, CliError> {
-    let functions = contract
-        .functions
-        .into_par_iter()
-        .map(|function| -> Result<_, BackendError> {
-            Ok(FunctionInfo {
-                name: function.name,
-                // TODO(https://github.com/noir-lang/noir/issues/4720)
-                acir_opcodes: function.bytecode.functions[0].opcodes.len(),
-                circuit_size: backend.get_exact_circuit_size(&function.bytecode)?,
-            })
+        .map(|(i, function)| FunctionInfo {
+            name: compiled_program.names[i].clone(),
+            acir_opcodes: function.opcodes.len(),
         })
-        .collect::<Result<_, _>>()?;
+        .collect();
 
-    Ok(ContractInfo { name: contract.name, expression_width, functions })
+    ProgramInfo { package_name: package.name.to_string(), expression_width, functions }
 }
diff --git a/tooling/nargo_cli/src/cli/mod.rs b/tooling/nargo_cli/src/cli/mod.rs
index ad778549ac0..485ccc7abaf 100644
--- a/tooling/nargo_cli/src/cli/mod.rs
+++ b/tooling/nargo_cli/src/cli/mod.rs
@@ -6,13 +6,9 @@ use std::path::PathBuf;
 
 use color_eyre::eyre;
 
-use crate::backends::get_active_backend;
-
 mod fs;
 
-mod backend_cmd;
 mod check_cmd;
-mod codegen_verifier_cmd;
 mod compile_cmd;
 mod dap_cmd;
 mod debug_cmd;
@@ -23,9 +19,7 @@ mod info_cmd;
 mod init_cmd;
 mod lsp_cmd;
 mod new_cmd;
-mod prove_cmd;
 mod test_cmd;
-mod verify_cmd;
 
 const GIT_HASH: &str = env!("GIT_COMMIT");
 const IS_DIRTY: &str = env!("GIT_DIRTY");
@@ -60,10 +54,8 @@ pub(crate) struct NargoConfig {
 #[non_exhaustive]
 #[derive(Subcommand, Clone, Debug)]
 enum NargoCommand {
-    Backend(backend_cmd::BackendCommand),
     Check(check_cmd::CheckCommand),
     Fmt(fmt_cmd::FormatCommand),
-    CodegenVerifier(codegen_verifier_cmd::CodegenVerifierCommand),
     #[command(alias = "build")]
     Compile(compile_cmd::CompileCommand),
     New(new_cmd::NewCommand),
@@ -73,8 +65,6 @@ enum NargoCommand {
     Export(export_cmd::ExportCommand),
     #[command(hide = true)] // Hidden while the feature is being built out
     Debug(debug_cmd::DebugCommand),
-    Prove(prove_cmd::ProveCommand),
-    Verify(verify_cmd::VerifyCommand),
     Test(test_cmd::TestCommand),
     Info(info_cmd::InfoCommand),
     Lsp(lsp_cmd::LspCommand),
@@ -94,18 +84,11 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
     // Search through parent directories to find package root if necessary.
     if !matches!(
         command,
-        NargoCommand::New(_)
-            | NargoCommand::Init(_)
-            | NargoCommand::Lsp(_)
-            | NargoCommand::Backend(_)
-            | NargoCommand::Dap(_)
+        NargoCommand::New(_) | NargoCommand::Init(_) | NargoCommand::Lsp(_) | NargoCommand::Dap(_)
     ) {
         config.program_dir = find_package_root(&config.program_dir)?;
     }
 
-    let active_backend = get_active_backend();
-    let backend = crate::backends::Backend::new(active_backend);
-
     match command {
         NargoCommand::New(args) => new_cmd::run(args, config),
         NargoCommand::Init(args) => init_cmd::run(args, config),
@@ -114,12 +97,8 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
         NargoCommand::Debug(args) => debug_cmd::run(args, config),
         NargoCommand::Execute(args) => execute_cmd::run(args, config),
         NargoCommand::Export(args) => export_cmd::run(args, config),
-        NargoCommand::Prove(args) => prove_cmd::run(&backend, args, config),
-        NargoCommand::Verify(args) => verify_cmd::run(&backend, args, config),
         NargoCommand::Test(args) => test_cmd::run(args, config),
-        NargoCommand::Info(args) => info_cmd::run(&backend, args, config),
-        NargoCommand::CodegenVerifier(args) => codegen_verifier_cmd::run(&backend, args, config),
-        NargoCommand::Backend(args) => backend_cmd::run(args),
+        NargoCommand::Info(args) => info_cmd::run(args, config),
         NargoCommand::Lsp(args) => lsp_cmd::run(args, config),
         NargoCommand::Dap(args) => dap_cmd::run(args, config),
         NargoCommand::Fmt(args) => fmt_cmd::run(args, config),
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
deleted file mode 100644
index 47c71527fd8..00000000000
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-use clap::Args;
-use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
-use nargo::ops::{compile_program, report_errors};
-use nargo::package::Package;
-use nargo::workspace::Workspace;
-use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_abi::input_parser::Format;
-use noirc_driver::{
-    file_manager_with_stdlib, CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING,
-};
-use noirc_frontend::graph::CrateName;
-
-use super::fs::{
-    inputs::{read_inputs_from_file, write_inputs_to_file},
-    proof::save_proof_to_dir,
-};
-use super::NargoConfig;
-use crate::{backends::Backend, cli::execute_cmd::execute_program, errors::CliError};
-
-/// Create proof for this program. The proof is returned as a hex encoded string.
-#[derive(Debug, Clone, Args)]
-#[clap(visible_alias = "p")]
-pub(crate) struct ProveCommand {
-    /// The name of the toml file which contains the inputs for the prover
-    #[clap(long, short, default_value = PROVER_INPUT_FILE)]
-    prover_name: String,
-
-    /// The name of the toml file which contains the inputs for the verifier
-    #[clap(long, short, default_value = VERIFIER_INPUT_FILE)]
-    verifier_name: String,
-
-    /// Verify proof after proving
-    #[arg(long)]
-    verify: bool,
-
-    /// The name of the package to prove
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Prove all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
-
-    #[clap(flatten)]
-    compile_options: CompileOptions,
-
-    /// JSON RPC url to solve oracle calls
-    #[clap(long)]
-    oracle_resolver: Option<String>,
-}
-
-pub(crate) fn run(
-    backend: &Backend,
-    args: ProveCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
-    let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
-    let workspace = resolve_workspace_from_toml(
-        &toml_path,
-        selection,
-        Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
-    )?;
-
-    let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
-
-    let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
-    for package in binary_packages {
-        let compilation_result = compile_program(
-            &workspace_file_manager,
-            &parsed_files,
-            package,
-            &args.compile_options,
-            None,
-        );
-
-        let compiled_program = report_errors(
-            compilation_result,
-            &workspace_file_manager,
-            args.compile_options.deny_warnings,
-            args.compile_options.silence_warnings,
-        )?;
-
-        let compiled_program =
-            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
-
-        prove_package(
-            backend,
-            &workspace,
-            package,
-            compiled_program,
-            &args.prover_name,
-            &args.verifier_name,
-            args.verify,
-            args.oracle_resolver.as_deref(),
-        )?;
-    }
-
-    Ok(())
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn prove_package(
-    backend: &Backend,
-    workspace: &Workspace,
-    package: &Package,
-    compiled_program: CompiledProgram,
-    prover_name: &str,
-    verifier_name: &str,
-    check_proof: bool,
-    foreign_call_resolver_url: Option<&str>,
-) -> Result<(), CliError> {
-    // Parse the initial witness values from Prover.toml
-    let (inputs_map, _) =
-        read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &compiled_program.abi)?;
-
-    let witness_stack = execute_program(&compiled_program, &inputs_map, foreign_call_resolver_url)?;
-
-    // Write public inputs into Verifier.toml
-    let public_abi = compiled_program.abi.public_abi();
-    // Get the entry point witness for the ABI
-    let main_witness =
-        &witness_stack.peek().expect("Should have at least one witness on the stack").witness;
-    let (public_inputs, return_value) = public_abi.decode(main_witness)?;
-
-    write_inputs_to_file(
-        &public_inputs,
-        &return_value,
-        &public_abi,
-        &package.root_dir,
-        verifier_name,
-        Format::Toml,
-    )?;
-
-    let proof = backend.prove(&compiled_program.program, witness_stack)?;
-
-    if check_proof {
-        let public_inputs = public_abi.encode(&public_inputs, return_value)?;
-        let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.program)?;
-
-        if !valid_proof {
-            return Err(CliError::InvalidProof("".into()));
-        }
-    }
-
-    save_proof_to_dir(&proof, &String::from(&package.name), workspace.proofs_directory_path())?;
-
-    Ok(())
-}
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
deleted file mode 100644
index a6078f6c1d3..00000000000
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-use super::fs::{inputs::read_inputs_from_file, load_hex_data};
-use super::NargoConfig;
-use crate::{backends::Backend, errors::CliError};
-
-use clap::Args;
-use nargo::constants::{PROOF_EXT, VERIFIER_INPUT_FILE};
-use nargo::ops::{compile_program, report_errors};
-use nargo::package::Package;
-use nargo::workspace::Workspace;
-use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_abi::input_parser::Format;
-use noirc_driver::{
-    file_manager_with_stdlib, CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING,
-};
-use noirc_frontend::graph::CrateName;
-
-/// Given a proof and a program, verify whether the proof is valid
-#[derive(Debug, Clone, Args)]
-#[clap(visible_alias = "v")]
-pub(crate) struct VerifyCommand {
-    /// The name of the toml file which contains the inputs for the verifier
-    #[clap(long, short, default_value = VERIFIER_INPUT_FILE)]
-    verifier_name: String,
-
-    /// The name of the package verify
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Verify all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
-
-    #[clap(flatten)]
-    compile_options: CompileOptions,
-}
-
-pub(crate) fn run(
-    backend: &Backend,
-    args: VerifyCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
-    let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
-    let workspace = resolve_workspace_from_toml(
-        &toml_path,
-        selection,
-        Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
-    )?;
-
-    let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
-
-    let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
-    for package in binary_packages {
-        let compilation_result = compile_program(
-            &workspace_file_manager,
-            &parsed_files,
-            package,
-            &args.compile_options,
-            None,
-        );
-
-        let compiled_program = report_errors(
-            compilation_result,
-            &workspace_file_manager,
-            args.compile_options.deny_warnings,
-            args.compile_options.silence_warnings,
-        )?;
-
-        let compiled_program =
-            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
-
-        verify_package(backend, &workspace, package, compiled_program, &args.verifier_name)?;
-    }
-
-    Ok(())
-}
-
-fn verify_package(
-    backend: &Backend,
-    workspace: &Workspace,
-    package: &Package,
-    compiled_program: CompiledProgram,
-    verifier_name: &str,
-) -> Result<(), CliError> {
-    // Load public inputs (if any) from `verifier_name`.
-    let public_abi = compiled_program.abi.public_abi();
-    let (public_inputs_map, return_value) =
-        read_inputs_from_file(&package.root_dir, verifier_name, Format::Toml, &public_abi)?;
-
-    let public_inputs = public_abi.encode(&public_inputs_map, return_value)?;
-
-    let proof_path =
-        workspace.proofs_directory_path().join(package.name.to_string()).with_extension(PROOF_EXT);
-
-    let proof = load_hex_data(&proof_path)?;
-
-    let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.program)?;
-
-    if valid_proof {
-        Ok(())
-    } else {
-        Err(CliError::InvalidProof(proof_path))
-    }
-}
diff --git a/tooling/nargo_cli/src/errors.rs b/tooling/nargo_cli/src/errors.rs
index 40fb7886405..3e0b13a9cbc 100644
--- a/tooling/nargo_cli/src/errors.rs
+++ b/tooling/nargo_cli/src/errors.rs
@@ -1,5 +1,4 @@
 use acvm::acir::native_types::WitnessStackError;
-use hex::FromHexError;
 use nargo::{errors::CompileError, NargoError};
 use nargo_toml::ManifestError;
 use noir_debugger::errors::DapError;
@@ -11,8 +10,7 @@ use thiserror::Error;
 pub(crate) enum FilesystemError {
     #[error("Error: {} is not a valid path\nRun either `nargo compile` to generate missing build artifacts or `nargo prove` to construct a proof", .0.display())]
     PathNotValid(PathBuf),
-    #[error("Error: could not parse hex build artifact (proof, proving and/or verification keys, ACIR checksum) ({0})")]
-    HexArtifactNotValid(FromHexError),
+
     #[error(
         " Error: cannot find {0}.toml file.\n Expected location: {1:?} \n Please generate this file at the expected location."
     )]
@@ -37,9 +35,6 @@ pub(crate) enum CliError {
     #[error("Error: destination {} already exists", .0.display())]
     DestinationAlreadyExists(PathBuf),
 
-    #[error("Failed to verify proof {}", .0.display())]
-    InvalidProof(PathBuf),
-
     #[error("Invalid package name {0}. Did you mean to use `--name`?")]
     InvalidPackageName(String),
 
@@ -68,24 +63,4 @@ pub(crate) enum CliError {
     /// Error from the compilation pipeline
     #[error(transparent)]
     CompileError(#[from] CompileError),
-
-    /// Error related to backend selection/installation.
-    #[error(transparent)]
-    BackendError(#[from] BackendError),
-
-    /// Error related to communication with backend.
-    #[error(transparent)]
-    BackendCommunicationError(#[from] backend_interface::BackendError),
-}
-
-#[derive(Debug, thiserror::Error)]
-pub(crate) enum BackendError {
-    #[error("No backend is installed with the name {0}")]
-    UnknownBackend(String),
-
-    #[error("The backend {0} is already installed")]
-    AlreadyInstalled(String),
-
-    #[error("Backend installation failed: {0}")]
-    InstallationError(#[from] std::io::Error),
 }
diff --git a/tooling/nargo_cli/src/main.rs b/tooling/nargo_cli/src/main.rs
index 6e2b7069bc4..a407d467ced 100644
--- a/tooling/nargo_cli/src/main.rs
+++ b/tooling/nargo_cli/src/main.rs
@@ -7,7 +7,6 @@
 //! This name was used because it sounds like `cargo` and
 //! Noir Package Manager abbreviated is npm, which is already taken.
 
-mod backends;
 mod cli;
 mod errors;
 
diff --git a/tooling/nargo_cli/tests/codegen-verifier.rs b/tooling/nargo_cli/tests/codegen-verifier.rs
deleted file mode 100644
index f991f72b108..00000000000
--- a/tooling/nargo_cli/tests/codegen-verifier.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! This integration test aims to check that the `nargo codegen-verifier` will successfully create a
-//! file containing a verifier for a simple program.
-
-use assert_cmd::prelude::*;
-use predicates::prelude::*;
-use std::process::Command;
-
-use assert_fs::prelude::{PathAssert, PathChild};
-
-#[test]
-fn simple_verifier_codegen() {
-    let test_dir = assert_fs::TempDir::new().unwrap();
-    std::env::set_current_dir(&test_dir).unwrap();
-
-    // Create trivial program
-    let project_name = "hello_world";
-    let project_dir = test_dir.child(project_name);
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("new").arg(project_name);
-    cmd.assert().success();
-
-    std::env::set_current_dir(&project_dir).unwrap();
-
-    // Run `nargo codegen-verifier`
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("codegen-verifier");
-    cmd.assert()
-        .success()
-        .stdout(predicate::str::contains("Contract successfully created and located at"));
-
-    project_dir
-        .child("contract")
-        .child("hello_world")
-        .child("plonk_vk.sol")
-        .assert(predicate::path::is_file());
-}
diff --git a/tooling/nargo_cli/tests/hello_world.rs b/tooling/nargo_cli/tests/hello_world.rs
index 9fcb0c873e1..6b6931542b5 100644
--- a/tooling/nargo_cli/tests/hello_world.rs
+++ b/tooling/nargo_cli/tests/hello_world.rs
@@ -34,22 +34,11 @@ fn hello_world_example() {
         .stdout(predicate::str::contains("Constraint system successfully built!"));
 
     project_dir.child("Prover.toml").assert(predicate::path::is_file());
-    project_dir.child("Verifier.toml").assert(predicate::path::is_file());
 
-    // `nargo prove`
+    // `nargo execute`
     project_dir.child("Prover.toml").write_str("x = 1\ny = 2").unwrap();
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("prove");
-    cmd.assert().success();
-
-    project_dir
-        .child("proofs")
-        .child(format!("{project_name}.proof"))
-        .assert(predicate::path::is_file());
-
-    // `nargo verify p`
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("verify");
+    cmd.arg("execute");
     cmd.assert().success();
 }
diff --git a/tooling/nargo_fmt/src/config.rs b/tooling/nargo_fmt/src/config.rs
index 2bb5d97c0af..5e38dc7d8b0 100644
--- a/tooling/nargo_fmt/src/config.rs
+++ b/tooling/nargo_fmt/src/config.rs
@@ -45,7 +45,7 @@ config! {
     max_width: usize, 100, "Maximum width of each line";
     tab_spaces: usize, 4, "Number of spaces per tab";
     remove_nested_parens: bool, true, "Remove nested parens";
-    error_on_lost_comment: bool, true, "Error if unable to get comments";
+    error_on_lost_comment: bool, false, "Error if unable to get comments";
     short_array_element_width_threshold: usize, 10, "Width threshold for an array element to be considered short";
     array_width: usize, 100, "Maximum width of an array literal before falling back to vertical formatting";
     fn_call_width: usize, 60, "Maximum width of the args of a function call before falling back to vertical formatting";
diff --git a/tooling/noir_codegen/src/index.ts b/tooling/noir_codegen/src/index.ts
index fbbab07bcfe..d00990f01bc 100644
--- a/tooling/noir_codegen/src/index.ts
+++ b/tooling/noir_codegen/src/index.ts
@@ -1,66 +1,17 @@
-import { AbiType } from '@noir-lang/noirc_abi';
 import { CompiledCircuit } from '@noir-lang/types';
-import { PrimitiveTypesUsed, generateTsInterface, codegenStructDefinitions } from './noir_types.js';
-
-// TODO: reenable this. See `abiTypeToTs` for reasoning.
-// export type FixedLengthArray<T, L extends number> = L extends 0 ? never[]: T[] & { length: L };
-
-const codegenPrelude = `/* Autogenerated file, do not edit! */
-
-/* eslint-disable */
-
-import { Noir, InputMap, CompiledCircuit, ForeignCallHandler } from "@noir-lang/noir_js"
-
-export { ForeignCallHandler } from "@noir-lang/noir_js"
-`;
-
-const codegenFunction = (
-  name: string,
-  compiled_program: CompiledCircuit,
-  function_signature: { inputs: [string, string][]; returnValue: string | null },
-) => {
-  const args = function_signature.inputs.map(([name]) => `${name}`).join(', ');
-  const args_with_types = function_signature.inputs.map(([name, type]) => `${name}: ${type}`).join(', ');
-
-  return `export const ${name}_circuit: CompiledCircuit = ${JSON.stringify(compiled_program)};
-
-export async function ${name}(${args_with_types}, foreignCallHandler?: ForeignCallHandler): Promise<${
-    function_signature.returnValue
-  }> {
-  const program = new Noir(${name}_circuit);
-  const args: InputMap = { ${args} };
-  const { returnValue } = await program.execute(args, foreignCallHandler);
-  return returnValue as ${function_signature.returnValue};
-}
-`;
+import { TypingsGenerator } from './utils/typings_generator.js';
+
+export const codegen = (
+  programs: [string, CompiledCircuit][],
+  embedArtifact: boolean,
+  useFixedLengthArrays: boolean,
+): string => {
+  return new TypingsGenerator(
+    programs.map((program) => ({
+      circuitName: program[0],
+      artifact: embedArtifact ? program[1] : undefined,
+      abi: structuredClone(program[1].abi), // We'll mutate the ABI types when doing typescript codegen, so we clone it to avoid mutating the artifact.
+    })),
+    useFixedLengthArrays,
+  ).codegen();
 };
-
-export const codegen = (programs: [string, CompiledCircuit][]): string => {
-  let results = [codegenPrelude];
-  const primitiveTypeMap = new Map<string, PrimitiveTypesUsed>();
-  const structTypeMap = new Map<string, { name: string; type: AbiType }[]>();
-
-  const functions: string[] = [];
-  for (const [name, program] of programs) {
-    const function_sig = generateTsInterface(program.abi, structTypeMap, primitiveTypeMap);
-    functions.push(codegenFunction(name, stripUnwantedFields(program), function_sig));
-  }
-
-  const structTypeDefinitions: string = codegenStructDefinitions(structTypeMap, primitiveTypeMap);
-
-  // Add the primitive Noir types that do not have a 1-1 mapping to TypeScript.
-  const primitiveTypeAliases: string[] = [];
-  for (const value of primitiveTypeMap.values()) {
-    primitiveTypeAliases.push(`export type ${value.aliasName} = ${value.tsType};`);
-  }
-
-  results = results.concat(...primitiveTypeAliases, '', structTypeDefinitions, ...functions);
-
-  return results.join('\n');
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function stripUnwantedFields(value: any): CompiledCircuit {
-  const { abi, bytecode } = value;
-  return { abi, bytecode };
-}
diff --git a/tooling/noir_codegen/src/main.ts b/tooling/noir_codegen/src/main.ts
index 591e7420dba..835b24a9e48 100644
--- a/tooling/noir_codegen/src/main.ts
+++ b/tooling/noir_codegen/src/main.ts
@@ -24,7 +24,7 @@ function main() {
     return [program_name, { abi, bytecode }];
   });
 
-  const result = codegen(programs);
+  const result = codegen(programs, !cliConfig.externalArtifact, cliConfig.useFixedLengthArrays);
 
   const outputDir = path.resolve(cliConfig.outDir ?? './codegen');
   const outputFile = path.join(outputDir, 'index.ts');
diff --git a/tooling/noir_codegen/src/noir_types.ts b/tooling/noir_codegen/src/noir_types.ts
deleted file mode 100644
index 0c0e2b7c60f..00000000000
--- a/tooling/noir_codegen/src/noir_types.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import { AbiType, Abi } from '@noir-lang/noirc_abi';
-
-/**
- * Keep track off all of the Noir primitive types that were used.
- * Most of these will not have a 1-1 definition in TypeScript,
- * so we will need to generate type aliases for them.
- *
- * We want to generate type aliases
- * for specific types that are used in the ABI.
- *
- * For example:
- * - If `Field` is used we want to alias that
- * with `number`.
- * - If `u32` is used we want to alias that with `number` too.
- */
-export type PrimitiveTypesUsed = {
-  /**
-   * The name of the type alias that we will generate.
-   */
-  aliasName: string;
-  /**
-   * The TypeScript type that we will alias to.
-   */
-  tsType: string;
-};
-
-/**
- * Typescript does not allow us to check for equality of non-primitive types
- * easily, so we create a addIfUnique function that will only add an item
- * to the map if it is not already there by using JSON.stringify.
- * @param item - The item to add to the map.
- */
-function addIfUnique(primitiveTypeMap: Map<string, PrimitiveTypesUsed>, item: PrimitiveTypesUsed) {
-  const key = JSON.stringify(item);
-  if (!primitiveTypeMap.has(key)) {
-    primitiveTypeMap.set(key, item);
-  }
-}
-
-/**
- * Converts an ABI type to a TypeScript type.
- * @param type - The ABI type to convert.
- * @returns The typescript code to define the type.
- */
-function abiTypeToTs(type: AbiType, primitiveTypeMap: Map<string, PrimitiveTypesUsed>): string {
-  switch (type.kind) {
-    case 'field':
-      addIfUnique(primitiveTypeMap, { aliasName: 'Field', tsType: 'string' });
-      return 'Field';
-    case 'integer': {
-      const typeName = type.sign === 'signed' ? `i${type.width}` : `u${type.width}`;
-      // Javascript cannot safely represent the full range of Noir's integer types as numbers.
-      // `Number.MAX_SAFE_INTEGER == 2**53 - 1` so we disallow passing numbers to types which may exceed this.
-      // 52 has been chosen as the cutoff rather than 53 for safety.
-      const tsType = type.width <= 52 ? `string | number` : `string`;
-
-      addIfUnique(primitiveTypeMap, { aliasName: typeName, tsType });
-      return typeName;
-    }
-    case 'boolean':
-      return `boolean`;
-    case 'array':
-      // We can't force the usage of fixed length arrays as this currently throws errors in TS.
-      // The array would need to be `as const` to support this whereas that's unlikely to happen in user code.
-      // return `FixedLengthArray<${abiTypeToTs(type.type, primitiveTypeMap)}, ${type.length}>`;
-      return `${abiTypeToTs(type.type, primitiveTypeMap)}[]`;
-    case 'string':
-      // We could enforce that literals are the correct length but not generally.
-      // This would run into similar problems to above.
-      return `string`;
-    case 'struct':
-      return getLastComponentOfPath(type.path);
-    case 'tuple': {
-      const field_types = type.fields.map((field) => abiTypeToTs(field, primitiveTypeMap));
-      return `[${field_types.join(', ')}]`;
-    }
-    default:
-      throw new Error(`Unknown ABI type ${JSON.stringify(type)}`);
-  }
-}
-
-/**
- * Returns the last component of a path, e.g. "foo::bar::baz" -\> "baz"
- * Note: that if we have a path such as "Baz", we will return "Baz".
- *
- * Since these paths corresponds to structs, we can assume that we
- * cannot have "foo::bar::".
- *
- * We also make the assumption that since these paths are coming from
- * Noir, then we will not have two paths that look like this:
- * - foo::bar::Baz
- * - cat::dog::Baz
- * ie the last component of the path (struct name) is enough to uniquely identify
- * the whole path.
- *
- * TODO: We should double check this assumption when we use type aliases,
- * I expect that `foo::bar::Baz as Dog` would effectively give `foo::bar::Dog`
- * @param str - The path to get the last component of.
- * @returns The last component of the path.
- */
-function getLastComponentOfPath(str: string): string {
-  const parts = str.split('::');
-  const lastPart = parts[parts.length - 1];
-  return lastPart;
-}
-
-/**
- * Generates TypeScript interfaces for the structs used in the ABI.
- * @param type - The ABI type to generate the interface for.
- * @param output - The set of structs that we have already generated bindings for.
- * @returns The TypeScript code to define the struct.
- */
-function generateStructInterfaces(
-  type: AbiType,
-  structsEncountered: Map<string, { name: string; type: AbiType }[]>,
-  primitiveTypeMap: Map<string, PrimitiveTypesUsed>,
-) {
-  // Edge case to handle the array of structs case.
-  if (
-    type.kind === 'array' &&
-    type.type.kind === 'struct' &&
-    !structsEncountered.has(getLastComponentOfPath(type.type.path))
-  ) {
-    generateStructInterfaces(type.type, structsEncountered, primitiveTypeMap);
-  }
-  if (type.kind !== 'struct') return;
-
-  const structName = getLastComponentOfPath(type.path);
-  if (!structsEncountered.has(structName)) {
-    for (const field of type.fields) {
-      generateStructInterfaces(field.type, structsEncountered, primitiveTypeMap);
-    }
-    structsEncountered.set(structName, type.fields);
-  }
-}
-
-/**
- * Generates a TypeScript interface for the ABI.
- * @param abiObj - The ABI to generate the interface for.
- * @returns The TypeScript code to define the interface.
- */
-export function generateTsInterface(
-  abiObj: Abi,
-  structsEncountered: Map<string, { name: string; type: AbiType }[]>,
-  primitiveTypeMap: Map<string, PrimitiveTypesUsed>,
-): { inputs: [string, string][]; returnValue: string | null } {
-  // Define structs for composite types
-  for (const param of abiObj.parameters) {
-    generateStructInterfaces(param.type, structsEncountered, primitiveTypeMap);
-  }
-
-  // Generating Return type, if it exists
-  if (abiObj.return_type != null) {
-    generateStructInterfaces(abiObj.return_type.abi_type, structsEncountered, primitiveTypeMap);
-  }
-
-  return getTsFunctionSignature(abiObj, primitiveTypeMap);
-}
-
-export function codegenStructDefinitions(
-  structsEncountered: Map<string, { name: string; type: AbiType }[]>,
-  primitiveTypeMap: Map<string, PrimitiveTypesUsed>,
-): string {
-  let codeGeneratedStruct = '';
-
-  for (const [structName, structFields] of structsEncountered) {
-    codeGeneratedStruct += `export type ${structName} = {\n`;
-    for (const field of structFields) {
-      codeGeneratedStruct += `  ${field.name}: ${abiTypeToTs(field.type, primitiveTypeMap)};\n`;
-    }
-    codeGeneratedStruct += `};\n\n`;
-  }
-
-  return codeGeneratedStruct;
-}
-
-function getTsFunctionSignature(
-  abi: Abi,
-  primitiveTypeMap: Map<string, PrimitiveTypesUsed>,
-): { inputs: [string, string][]; returnValue: string | null } {
-  const inputs: [string, string][] = abi.parameters.map((param) => [
-    param.name,
-    abiTypeToTs(param.type, primitiveTypeMap),
-  ]);
-  const returnValue = abi.return_type ? abiTypeToTs(abi.return_type.abi_type, primitiveTypeMap) : null;
-  return { inputs, returnValue };
-}
diff --git a/tooling/noir_codegen/src/parseArgs.ts b/tooling/noir_codegen/src/parseArgs.ts
index 58468c1b8f8..83b6c8bcdb2 100644
--- a/tooling/noir_codegen/src/parseArgs.ts
+++ b/tooling/noir_codegen/src/parseArgs.ts
@@ -6,6 +6,8 @@ export interface ParsedArgs {
   files: string[];
   outDir?: string | undefined;
   inputDir?: string | undefined;
+  externalArtifact: boolean;
+  useFixedLengthArrays: boolean;
 }
 
 export function parseArgs(): ParsedArgs {
@@ -27,6 +29,17 @@ export function parseArgs(): ParsedArgs {
           'Directory containing program artifact files. Inferred as lowest common path of all files if not specified.',
       },
       help: { type: Boolean, defaultValue: false, alias: 'h', description: 'Prints this message.' },
+      'external-artifact': {
+        type: Boolean,
+        defaultValue: false,
+        description:
+          'Does not embed the circuit artifact in the code, instead requiring passing the circuit artifact as an argument to the generated functions.',
+      },
+      'fixed-length-arrays': {
+        type: Boolean,
+        defaultValue: false,
+        description: 'Use fixed-length arrays for inputs and outputs.',
+      },
     },
     {
       helpArg: 'help',
@@ -53,6 +66,8 @@ export function parseArgs(): ParsedArgs {
     files: rawOptions.glob,
     outDir: rawOptions['out-dir'],
     inputDir: rawOptions['input-dir'],
+    externalArtifact: rawOptions['external-artifact'],
+    useFixedLengthArrays: rawOptions['fixed-length-arrays'],
   };
 }
 
@@ -61,4 +76,6 @@ interface CommandLineArgs {
   'out-dir'?: string;
   'input-dir'?: string;
   help: boolean;
+  'external-artifact': boolean;
+  'fixed-length-arrays': boolean;
 }
diff --git a/tooling/noir_codegen/src/utils/abi_type_with_generics.ts b/tooling/noir_codegen/src/utils/abi_type_with_generics.ts
new file mode 100644
index 00000000000..844e116f444
--- /dev/null
+++ b/tooling/noir_codegen/src/utils/abi_type_with_generics.ts
@@ -0,0 +1,139 @@
+import { AbiType } from '@noir-lang/noirc_abi';
+
+/**
+ * Represents a binding to a generic.
+ */
+export class BindingId {
+  constructor(
+    public id: number,
+    public isNumeric: boolean,
+  ) {}
+}
+
+export type StructType = {
+  path: string;
+  fields: { name: string; type: AbiTypeWithGenerics }[];
+  /** The generics of the struct, bound to the fields */
+  generics: BindingId[];
+};
+
+export type StringType = {
+  kind: 'string';
+  length: number | BindingId | null;
+};
+
+export type Constant = {
+  kind: 'constant';
+  value: number;
+};
+
+export type ArrayType = {
+  kind: 'array';
+  length: number | BindingId | null;
+  type: AbiTypeWithGenerics;
+};
+
+export type Tuple = {
+  kind: 'tuple';
+  fields: AbiTypeWithGenerics[];
+};
+
+export type Struct = {
+  kind: 'struct';
+  structType: StructType;
+  /** The arguments are the concrete instantiation of the generics in the struct type. */
+  args: AbiTypeWithGenerics[];
+};
+
+export type AbiTypeWithGenerics =
+  | { kind: 'field' }
+  | { kind: 'boolean' }
+  | { kind: 'integer'; sign: string; width: number }
+  | { kind: 'binding'; id: BindingId }
+  | { kind: 'constant'; value: number }
+  | StringType
+  | ArrayType
+  | Tuple
+  | Struct;
+
+/**
+ * Maps an ABI type to an ABI type with generics.
+ * This performs pure type conversion, and does not generate any bindings.
+ */
+export function mapAbiTypeToAbiTypeWithGenerics(abiType: AbiType): AbiTypeWithGenerics {
+  switch (abiType.kind) {
+    case 'field':
+    case 'boolean':
+    case 'string':
+    case 'integer':
+      return abiType;
+    case 'array':
+      return {
+        kind: 'array',
+        length: abiType.length,
+        type: mapAbiTypeToAbiTypeWithGenerics(abiType.type),
+      };
+    case 'struct': {
+      const structType = {
+        path: abiType.path,
+        fields: abiType.fields.map((field) => ({
+          name: field.name,
+          type: mapAbiTypeToAbiTypeWithGenerics(field.type),
+        })),
+        generics: [],
+      };
+      return {
+        kind: 'struct',
+        structType,
+        args: [],
+      };
+    }
+    case 'tuple':
+      return {
+        kind: 'tuple',
+        fields: abiType.fields.map(mapAbiTypeToAbiTypeWithGenerics),
+      };
+    default: {
+      const exhaustiveCheck: never = abiType;
+      throw new Error(`Unhandled abi type: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+/**
+ * Finds the structs in an ABI type.
+ * This won't explore nested structs.
+ */
+export function findStructsInType(abiType: AbiTypeWithGenerics): Struct[] {
+  switch (abiType.kind) {
+    case 'field':
+    case 'boolean':
+    case 'string':
+    case 'integer':
+      return [];
+    case 'array':
+      return findStructsInType(abiType.type);
+    case 'tuple':
+      return abiType.fields.flatMap(findStructsInType);
+    case 'struct':
+      return [abiType];
+    default: {
+      return [];
+    }
+  }
+}
+
+/**
+ * Finds all the structs in an ABI type, including nested structs.
+ */
+export function findAllStructsInType(abiType: AbiTypeWithGenerics): Struct[] {
+  let allStructs: Struct[] = [];
+  let lastStructs = findStructsInType(abiType);
+  while (lastStructs.length > 0) {
+    allStructs = allStructs.concat(lastStructs);
+    lastStructs = lastStructs.flatMap((struct) =>
+      struct.structType.fields.flatMap((field) => findStructsInType(field.type)),
+    );
+  }
+  return allStructs;
+}
diff --git a/tooling/noir_codegen/src/utils/demonomorphizer.ts b/tooling/noir_codegen/src/utils/demonomorphizer.ts
new file mode 100644
index 00000000000..2b33b574557
--- /dev/null
+++ b/tooling/noir_codegen/src/utils/demonomorphizer.ts
@@ -0,0 +1,284 @@
+import {
+  type AbiTypeWithGenerics,
+  type ArrayType,
+  BindingId,
+  type Constant,
+  type StringType,
+  type Struct,
+  type StructType,
+  type Tuple,
+  findAllStructsInType,
+  findStructsInType,
+} from './abi_type_with_generics.js';
+
+export interface DemonomorphizerConfig {
+  leaveArrayLengthsUnbounded: boolean;
+  leaveStringLengthsUnbounded: boolean;
+}
+
+/**
+ * Demonomorphizes a list of ABI types adding generics to structs.
+ * Since monomorphization of the generics destroys information, this process is not guaranteed to return the original structure.
+ * However, it should successfully unify all struct types that share the same name and field names.
+ */
+export class Demonomorphizer {
+  private variantsMap: Map<string, Struct[]>;
+  private visitedStructs: Map<string, StructType>;
+  private lastBindingId = 0;
+
+  /**
+   * Demonomorphizes the passed in ABI types, mutating them.
+   */
+  public static demonomorphize(abiTypes: AbiTypeWithGenerics[], config: DemonomorphizerConfig) {
+    new Demonomorphizer(abiTypes, config);
+  }
+
+  private constructor(
+    private types: AbiTypeWithGenerics[],
+    private config: DemonomorphizerConfig,
+  ) {
+    this.variantsMap = new Map<string, Struct[]>();
+    this.fillVariantsMap();
+
+    this.visitedStructs = new Map<string, StructType>();
+    this.demonomorphizeStructs();
+  }
+
+  /**
+   * Finds all the variants of the structs in the types.
+   * A variant is every use of a struct with the same name and fields.
+   */
+  private fillVariantsMap() {
+    const allStructs = this.types.flatMap(findAllStructsInType);
+    for (const struct of allStructs) {
+      const id = Demonomorphizer.buildIdForStruct(struct.structType);
+      const variants = this.variantsMap.get(id) ?? [];
+      variants.push(struct);
+      this.variantsMap.set(id, variants);
+    }
+  }
+
+  private demonomorphizeStructs() {
+    for (const type of this.types) {
+      const topLevelStructs = findStructsInType(type);
+      for (const struct of topLevelStructs) {
+        this.demonomorphizeStruct(struct);
+      }
+    }
+  }
+
+  /**
+   * Demonomorphizes a struct, by demonomorphizing its dependencies first.
+   * Then it'll unify the types of the variants generating a unique generic type.
+   * It'll also generate args that instantiate the generic type with the concrete arguments for each variant.
+   */
+  private demonomorphizeStruct(struct: Struct) {
+    const id = Demonomorphizer.buildIdForStruct(struct.structType);
+    if (this.visitedStructs.has(id)) {
+      return;
+    }
+    const dependencies = struct.structType.fields.flatMap((field) => findStructsInType(field.type));
+    for (const dependency of dependencies) {
+      this.demonomorphizeStruct(dependency);
+    }
+    if (this.visitedStructs.has(id)) {
+      throw new Error('Circular dependency detected');
+    }
+
+    const variants = this.variantsMap.get(id)!;
+    const mappedStructType = struct.structType;
+
+    for (let i = 0; i < struct.structType.fields.length; i++) {
+      const variantTypes = variants.map((variant) => variant.structType.fields[i].type);
+      const mappedType = this.unifyTypes(variantTypes, mappedStructType.generics, variants);
+      mappedStructType.fields[i].type = mappedType;
+    }
+
+    // Mutate variants setting the new struct type
+    variants.forEach((variant) => (variant.structType = mappedStructType));
+
+    this.visitedStructs.set(id, mappedStructType);
+  }
+
+  /**
+   * Tries to unify the types of a set of variants recursively.
+   * Unification will imply replacing some properties with bindings and pushing bindings to the generics of the struct.
+   */
+  private unifyTypes(
+    types: AbiTypeWithGenerics[],
+    generics: BindingId[], // Mutates generics adding new bindings
+    variants: Struct[], // mutates variants adding different args to the variants
+  ): AbiTypeWithGenerics {
+    const kinds = new Set(types.map((type) => type.kind));
+    if (kinds.size > 1) {
+      return this.buildBindingAndPushToVariants(types, generics, variants);
+    }
+    switch (types[0].kind) {
+      case 'field':
+      case 'boolean':
+      case 'binding':
+        return types[0];
+      case 'integer': {
+        if (allDeepEqual(types)) {
+          return types[0];
+        } else {
+          return this.buildBindingAndPushToVariants(types, generics, variants);
+        }
+      }
+      case 'string': {
+        const strings = types as StringType[];
+        const unifiedStringType = strings[0];
+        if (strings.every((string) => string.length === unifiedStringType.length)) {
+          return unifiedStringType;
+        } else if (!this.config.leaveStringLengthsUnbounded) {
+          unifiedStringType.length = this.buildNumericBindingAndPushToVariants(
+            strings.map((string) => {
+              if (typeof string.length !== 'number') {
+                throw new Error('Trying to unify strings with bindings');
+              }
+              return string.length;
+            }),
+            generics,
+            variants,
+          );
+          return unifiedStringType;
+        } else {
+          unifiedStringType.length = null;
+          return unifiedStringType;
+        }
+      }
+      case 'array': {
+        const arrays = types as ArrayType[];
+        const unifiedArrayType: ArrayType = arrays[0];
+        if (!arrays.every((array) => array.length === unifiedArrayType.length)) {
+          if (!this.config.leaveArrayLengthsUnbounded) {
+            unifiedArrayType.length = this.buildNumericBindingAndPushToVariants(
+              arrays.map((array) => {
+                if (typeof array.length !== 'number') {
+                  throw new Error('Trying to unify arrays with bindings');
+                }
+                return array.length;
+              }),
+              generics,
+              variants,
+            );
+          } else {
+            unifiedArrayType.length = null;
+          }
+        }
+
+        unifiedArrayType.type = this.unifyTypes(
+          arrays.map((array) => array.type),
+          generics,
+          variants,
+        );
+        return unifiedArrayType;
+      }
+      case 'tuple': {
+        const tuples = types as Tuple[];
+        const unifiedTupleType: Tuple = tuples[0];
+        for (let i = 0; i < unifiedTupleType.fields.length; i++) {
+          unifiedTupleType.fields[i] = this.unifyTypes(
+            tuples.map((tuple) => tuple.fields[i]),
+            generics,
+            variants,
+          );
+        }
+        return unifiedTupleType;
+      }
+      case 'struct': {
+        const structs = types as Struct[];
+        const ids = new Set(structs.map((struct) => Demonomorphizer.buildIdForStruct(struct.structType)));
+        if (ids.size > 1) {
+          // If the types are different structs, we can only unify them by creating a new binding.
+          // For example, if we have a struct A { x: u32 } and a struct A { x: Field }, the only possible unification is A<T> { x: T }
+          return this.buildBindingAndPushToVariants(types, generics, variants);
+        } else {
+          // If the types are the same struct, we must unify the arguments to the struct.
+          // For example, if we have A<Field> and A<u32>, we need to unify to A<T> and push T to the generics of the struct type.
+          const unifiedStruct = structs[0];
+
+          if (!structs.every((struct) => struct.args.length === unifiedStruct.args.length)) {
+            throw new Error('Same struct with different number of args encountered');
+          }
+          for (let i = 0; i < unifiedStruct.args.length; i++) {
+            const argTypes = structs.map((struct) => struct.args[i]);
+            unifiedStruct.args[i] = this.unifyTypes(argTypes, generics, variants);
+          }
+          return unifiedStruct;
+        }
+      }
+
+      case 'constant': {
+        const constants = types as Constant[];
+        if (constants.every((constant) => constant.value === constants[0].value)) {
+          return constants[0];
+        } else {
+          return this.buildBindingAndPushToVariants(types, generics, variants, true);
+        }
+      }
+
+      default: {
+        const exhaustiveCheck: never = types[0];
+        throw new Error(`Unhandled abi type: ${exhaustiveCheck}`);
+      }
+    }
+  }
+
+  /**
+   * We consider a struct to be the same if it has the same name and field names.
+   * Structs with the same id will be unified into a single type by the demonomorphizer.
+   */
+  public static buildIdForStruct(struct: StructType): string {
+    const name = struct.path.split('::').pop()!;
+    const fields = struct.fields.map((field) => field.name).join(',');
+    return `${name}(${fields})`;
+  }
+
+  private buildBindingAndPushToVariants(
+    concreteTypes: AbiTypeWithGenerics[],
+    generics: BindingId[],
+    variants: Struct[],
+    isNumeric = false,
+  ): AbiTypeWithGenerics {
+    const bindingId = new BindingId(this.lastBindingId++, isNumeric);
+
+    for (let i = 0; i < variants.length; i++) {
+      const variant = variants[i];
+      const concreteType = concreteTypes[i];
+      variant.args.push(concreteType);
+    }
+
+    generics.push(bindingId);
+    return { kind: 'binding', id: bindingId };
+  }
+
+  private buildNumericBindingAndPushToVariants(
+    concreteNumbers: number[],
+    generics: BindingId[],
+    variants: Struct[],
+  ): BindingId {
+    const bindingId = new BindingId(this.lastBindingId++, true);
+
+    for (let i = 0; i < variants.length; i++) {
+      const variant = variants[i];
+      variant.args.push({ kind: 'constant', value: concreteNumbers[i] });
+    }
+
+    generics.push(bindingId);
+    return bindingId;
+  }
+}
+
+function allDeepEqual<T>(arr: T[]): boolean {
+  if (arr.length === 0) {
+    return true;
+  }
+  const first = JSON.stringify(arr[0]);
+  for (let i = 0; i < arr.length; i++) {
+    if (JSON.stringify(arr[i]) !== first) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/tooling/noir_codegen/src/utils/typings_generator.ts b/tooling/noir_codegen/src/utils/typings_generator.ts
new file mode 100644
index 00000000000..36d2de140f0
--- /dev/null
+++ b/tooling/noir_codegen/src/utils/typings_generator.ts
@@ -0,0 +1,324 @@
+import { CompiledCircuit } from '@noir-lang/types';
+import {
+  AbiTypeWithGenerics,
+  BindingId,
+  StructType,
+  findAllStructsInType,
+  mapAbiTypeToAbiTypeWithGenerics,
+} from './abi_type_with_generics.js';
+import { Demonomorphizer } from './demonomorphizer.js';
+import { Abi } from '@noir-lang/noirc_abi';
+
+const codegenPrelude = `/* Autogenerated file, do not edit! */
+
+/* eslint-disable */
+
+import { Noir, InputMap, CompiledCircuit, ForeignCallHandler } from "@noir-lang/noir_js"
+
+export { ForeignCallHandler } from "@noir-lang/noir_js"
+`;
+/**
+ * Keep track off all of the Noir primitive types that were used.
+ * Most of these will not have a 1-1 definition in TypeScript,
+ * so we will need to generate type aliases for them.
+ *
+ * We want to generate type aliases
+ * for specific types that are used in the ABI.
+ *
+ * For example:
+ * - If `Field` is used we want to alias that
+ * with `number`.
+ * - If `u32` is used we want to alias that with `number` too.
+ */
+type PrimitiveTypesUsed = {
+  /**
+   * The name of the type alias that we will generate.
+   */
+  aliasName: string;
+  /**
+   * The TypeScript type that we will alias to.
+   */
+  tsType: string;
+};
+
+/**
+ * Returns the last component of a path, e.g. "foo::bar::baz" -\> "baz"
+ * Note: that if we have a path such as "Baz", we will return "Baz".
+ *
+ * Since these paths corresponds to structs, we can assume that we
+ * cannot have "foo::bar::".
+ *
+ * We also make the assumption that since these paths are coming from
+ * Noir, then we will not have two paths that look like this:
+ * - foo::bar::Baz
+ * - cat::dog::Baz
+ * ie the last component of the path (struct name) is enough to uniquely identify
+ * the whole path.
+ *
+ * TODO: We should double check this assumption when we use type aliases,
+ * I expect that `foo::bar::Baz as Dog` would effectively give `foo::bar::Dog`
+ * @param str - The path to get the last component of.
+ * @returns The last component of the path.
+ */
+function getLastComponentOfPath(str: string): string {
+  const parts = str.split('::');
+  const lastPart = parts[parts.length - 1];
+  return lastPart;
+}
+
+/**
+ * Replaces a numeric binding with the corresponding generics name or the actual value.
+ */
+function replaceNumericBinding(id: number | BindingId, genericsNameMap: Map<number, string>): string {
+  if (typeof id === 'number') {
+    return id.toString();
+  } else {
+    return genericsNameMap.get(id.id) ?? 'unknown';
+  }
+}
+
+export class TypingsGenerator {
+  /** All the types in the ABIs */
+  private allTypes: AbiTypeWithGenerics[] = [];
+  /** The demonomorphized ABIs of the circuits */
+  private demonomorphizedAbis: {
+    circuitName: string;
+    params: { name: string; type: AbiTypeWithGenerics }[];
+    returnType?: AbiTypeWithGenerics;
+    artifact?: CompiledCircuit;
+  }[] = [];
+  /** Maps struct id to name for structs with the same name and different field sets */
+  private structIdToTsName = new Map<string, string>();
+  /** Collect all the primitives used in the types to add them to the codegen */
+  private primitiveTypesUsed = new Map<string, PrimitiveTypesUsed>();
+
+  constructor(
+    circuits: { abi: Abi; circuitName: string; artifact?: CompiledCircuit }[],
+    private useFixedLengthArrays: boolean,
+  ) {
+    // Map all the types used in the ABIs to the demonomorphized types
+    for (const { abi, circuitName, artifact } of circuits) {
+      const params = abi.parameters.map((param) => {
+        const type = mapAbiTypeToAbiTypeWithGenerics(param.type);
+        this.allTypes.push(type);
+        return { name: param.name, type };
+      });
+      if (abi.return_type) {
+        const returnType = mapAbiTypeToAbiTypeWithGenerics(abi.return_type.abi_type);
+        this.allTypes.push(returnType);
+        this.demonomorphizedAbis.push({ circuitName, params, returnType, artifact });
+      } else {
+        this.demonomorphizedAbis.push({ circuitName, params, artifact });
+      }
+    }
+    // Demonomorphize the types
+    Demonomorphizer.demonomorphize(this.allTypes, {
+      leaveArrayLengthsUnbounded: !useFixedLengthArrays,
+      leaveStringLengthsUnbounded: true,
+    });
+  }
+
+  public codegen(): string {
+    this.primitiveTypesUsed = new Map<string, PrimitiveTypesUsed>();
+    const structsCode = this.codegenAllStructs();
+    const interfacesCode = this.codegenAllInterfaces();
+    const primitivesCode = this.codegenAllPrimitives();
+
+    return `
+${codegenPrelude}
+${primitivesCode}
+${structsCode}
+${interfacesCode}`;
+  }
+
+  private codegenAllStructs(): string {
+    const allStructs = this.allTypes.flatMap(findAllStructsInType);
+    // First, deduplicate the structs used
+    const structTypesToExport = new Map<string, StructType>();
+    for (const struct of allStructs) {
+      const id = Demonomorphizer.buildIdForStruct(struct.structType);
+      if (structTypesToExport.has(id)) {
+        continue;
+      }
+      structTypesToExport.set(id, struct.structType);
+    }
+
+    // Then, we have to consider the case where we have struct with the same name but different fields.
+    // For those, we'll naively append a number to the name.
+    const idsPerName = new Map<string, string[]>();
+    for (const [id, structType] of structTypesToExport.entries()) {
+      const name = getLastComponentOfPath(structType.path);
+      const ids = idsPerName.get(name) ?? [];
+      ids.push(id);
+      idsPerName.set(name, ids);
+    }
+
+    this.structIdToTsName = new Map();
+    for (const [name, ids] of idsPerName.entries()) {
+      if (ids.length !== 1) {
+        ids.forEach((id, index) => {
+          this.structIdToTsName.set(id, `${name}${index + 1}`);
+        });
+      }
+    }
+    // Now we can just generate the code for the structs
+    let resultCode = '';
+
+    for (const structType of structTypesToExport.values()) {
+      resultCode += this.codegenStructType(structType);
+    }
+
+    return resultCode;
+  }
+
+  private getStructName(structType: StructType): string {
+    return (
+      this.structIdToTsName.get(Demonomorphizer.buildIdForStruct(structType)) || getLastComponentOfPath(structType.path)
+    );
+  }
+
+  private codegenStructType(structType: StructType): string {
+    // Generate names for the generic bindings.
+    const genericsNameMap = new Map<number, string>();
+    structType.generics.forEach((generic, index) => {
+      genericsNameMap.set(generic.id, String.fromCharCode('A'.charCodeAt(0) + index));
+    });
+
+    const name = this.getStructName(structType);
+    const generics = structType.generics.length
+      ? `<${structType.generics
+          .map((generic) => `${genericsNameMap.get(generic.id)}${generic.isNumeric ? ' extends number' : ''}`)
+          .join(', ')}>`
+      : '';
+
+    let resultCode = `export type ${name}${generics} = {\n`;
+
+    for (const field of structType.fields) {
+      resultCode += `  ${field.name}: ${this.codegenType(field.type, genericsNameMap)};\n`;
+    }
+
+    resultCode += '}\n\n';
+
+    return resultCode;
+  }
+
+  private codegenType(type: AbiTypeWithGenerics, genericsNameMap: Map<number, string>): string {
+    switch (type.kind) {
+      case 'field':
+        this.addIfUnique({ aliasName: 'Field', tsType: 'string' });
+        return 'Field';
+      case 'boolean':
+        return 'boolean';
+      case 'integer': {
+        const typeName = type.sign === 'signed' ? `i${type.width}` : `u${type.width}`;
+        // Even though noir accepts numbers or strings for integers, it always returns strings
+        // So we must use string as the type here.
+        this.addIfUnique({ aliasName: typeName, tsType: 'string' });
+        return typeName;
+      }
+      case 'binding':
+        return genericsNameMap.get(type.id.id) ?? 'unknown';
+      case 'constant':
+        return type.value.toString();
+      case 'string':
+        return `string`;
+      case 'array':
+        if (this.useFixedLengthArrays) {
+          if (type.length === null) {
+            throw new Error('Got unbounded array with fixed length arrays enabled');
+          }
+          return `FixedLengthArray<${this.codegenType(type.type, genericsNameMap)}, ${replaceNumericBinding(
+            type.length,
+            genericsNameMap,
+          )}>`;
+        } else {
+          return `${this.codegenType(type.type, genericsNameMap)}[]`;
+        }
+      case 'tuple': {
+        const fieldTypes = type.fields.map((field) => this.codegenType(field, genericsNameMap));
+        return `[${fieldTypes.join(', ')}]`;
+      }
+      case 'struct': {
+        const name = this.getStructName(type.structType);
+        if (type.args.length) {
+          const args = type.args.map((arg) => this.codegenType(arg, genericsNameMap)).join(', ');
+          return `${name}<${args}>`;
+        } else {
+          return name;
+        }
+      }
+    }
+  }
+
+  /**
+   * Typescript does not allow us to check for equality of non-primitive types
+   * easily, so we create a addIfUnique function that will only add an item
+   * to the map if it is not already there by using JSON.stringify.
+   * @param item - The item to add to the map.
+   */
+  private addIfUnique(item: PrimitiveTypesUsed) {
+    const key = JSON.stringify(item);
+    if (!this.primitiveTypesUsed.has(key)) {
+      this.primitiveTypesUsed.set(key, item);
+    }
+  }
+
+  /**
+   * Codegen all the interfaces for the circuits.
+   * For a circuit named Foo, we'll codegen FooInputType and FooReturnType.
+   */
+  private codegenAllInterfaces(): string {
+    let resultCode = '';
+    for (const { circuitName, params, returnType, artifact } of this.demonomorphizedAbis) {
+      const functionSignature = {
+        inputs: params.map((param): [string, string] => [param.name, this.codegenType(param.type, new Map())]),
+        returnValue: returnType ? this.codegenType(returnType, new Map()) : null,
+      };
+      resultCode += this.codegenStructType({
+        path: `${circuitName}InputType`,
+        fields: params,
+        generics: [],
+      });
+
+      if (returnType) {
+        resultCode += `export type ${circuitName}ReturnType = ${this.codegenType(returnType, new Map())};\n`;
+      }
+
+      resultCode += codegenFunction(circuitName, functionSignature, artifact);
+    }
+    return resultCode;
+  }
+
+  private codegenAllPrimitives(): string {
+    let primitiveTypeAliases = this.useFixedLengthArrays
+      ? 'export type FixedLengthArray<T, L extends number> = L extends 0 ? never[]: T[] & { length: L }\n'
+      : '';
+    for (const [, value] of this.primitiveTypesUsed) {
+      primitiveTypeAliases += `export type ${value.aliasName} = ${value.tsType};\n`;
+    }
+    return primitiveTypeAliases;
+  }
+}
+
+const codegenFunction = (
+  name: string,
+  function_signature: { inputs: [string, string][]; returnValue: string | null },
+  compiled_program?: CompiledCircuit,
+): string => {
+  const args = function_signature.inputs.map(([name]) => `${name}`).join(', ');
+  const args_with_types = function_signature.inputs.map(([name, type]) => `${name}: ${type}`).join(', ');
+
+  const artifact = compiled_program
+    ? `export const ${name}_circuit: CompiledCircuit = ${JSON.stringify(compiled_program)};`
+    : '';
+
+  return `${artifact}
+
+export async function ${name}(${args_with_types}${compiled_program ? '' : `, ${name}_circuit: CompiledCircuit`}, foreignCallHandler?: ForeignCallHandler): Promise<${function_signature.returnValue}> {
+  const program = new Noir(${name}_circuit);
+  const args: InputMap = { ${args} };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as ${function_signature.returnValue};
+}
+`;
+};
diff --git a/tooling/noir_codegen/test/index.test.ts b/tooling/noir_codegen/test/index.test.ts
index 03fb680a537..afc7769ed9e 100644
--- a/tooling/noir_codegen/test/index.test.ts
+++ b/tooling/noir_codegen/test/index.test.ts
@@ -1,18 +1,18 @@
 import { expect } from 'chai';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore File is codegenned at test time.
-import { exported_function_foo, MyStruct, u64, ForeignCallHandler } from './codegen/index.js';
+import { exported_function_foo, MyStruct, u64, u32, ForeignCallHandler } from './codegen/index.js';
 
 it('codegens a callable function', async () => {
-  const my_struct = { foo: true, bar: ['12345', '12345', '12345'], baz: '0x00' };
+  const my_struct = { foo: true, bar: ['123', '123', '123', '123'], baz: '0x00' };
 
-  const [sum, constant, struct]: [u64, u64, MyStruct] = await exported_function_foo(
+  const [sum, constant, struct]: [u64, u32, MyStruct] = await exported_function_foo(
     '2',
     '3',
-    [0, 0, 0, 0, 0],
+    ['0x00', '0x00', '0x00', '0x00', '0x00'],
     {
       foo: my_struct,
-      bar: [my_struct, my_struct, my_struct],
+      bar: [my_struct, my_struct],
       baz: '64',
     },
     '12345',
@@ -35,15 +35,15 @@ it('allows passing a custom foreign call handler', async () => {
     return [];
   };
 
-  const my_struct = { foo: true, bar: ['12345', '12345', '12345'], baz: '0x00' };
+  const my_struct = { foo: true, bar: ['123', '123', '123', '123'], baz: '0x00' };
 
-  const [sum, constant, struct]: [u64, u64, MyStruct] = await exported_function_foo(
+  const [sum, constant, struct]: [u64, u32, MyStruct] = await exported_function_foo(
     '2',
     '3',
-    [0, 0, 0, 0, 0],
+    ['0x00', '0x00', '0x00', '0x00', '0x00'],
     {
       foo: my_struct,
-      bar: [my_struct, my_struct, my_struct],
+      bar: [my_struct, my_struct],
       baz: '64',
     },
     '12345',
diff --git a/tooling/noir_codegen/test/test_lib/src/lib.nr b/tooling/noir_codegen/test/test_lib/src/lib.nr
index 23607c6f65f..4915b0a2c49 100644
--- a/tooling/noir_codegen/test/test_lib/src/lib.nr
+++ b/tooling/noir_codegen/test/test_lib/src/lib.nr
@@ -1,17 +1,23 @@
-struct MyStruct {
+struct MyStruct<STR_LEN, BAR_SIZE> {
     foo: bool,
-    bar: [str<5>; 3],
+    bar: [str<STR_LEN>; BAR_SIZE],
     baz: Field
 }
 
-struct NestedStruct {
-    foo: MyStruct,
-    bar: [MyStruct; 3],
-    baz: u64
+struct NestedStruct<BAR_SIZE, STR_LEN, NESTED_BAR_SIZE, BAZ_TYP> {
+    foo: MyStruct<STR_LEN, NESTED_BAR_SIZE>,
+    bar: [MyStruct<STR_LEN, NESTED_BAR_SIZE>; BAR_SIZE],
+    baz: BAZ_TYP
 }
 
 #[export]
-fn exported_function_foo(x: u64, y: u64, array: [u8; 5], my_struct: NestedStruct, string: str<5>) -> (u64, u64, MyStruct) {
+fn exported_function_foo(
+    x: u64,
+    y: u64,
+    array: [u8; 5],
+    my_struct: NestedStruct<2,3,4, Field>,
+    string: str<5>
+) -> (u64, u32, MyStruct<3, 4>) {
     assert(array.len() == 5);
     assert(my_struct.foo.foo);
     assert(string == "12345");
@@ -22,6 +28,6 @@ fn exported_function_foo(x: u64, y: u64, array: [u8; 5], my_struct: NestedStruct
 }
 
 #[export]
-fn exported_function_bar(my_struct: NestedStruct) -> (u64) {
+fn exported_function_bar(my_struct: NestedStruct<1,2,3, u64>) -> (u64) {
     my_struct.baz
 }
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 6adf8749aba..10fd14a0090 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.38.0",
+    "@aztec/bb.js": "0.41.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index 85966ce3392..8fb574afa30 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.38.0":
-  version: 0.38.0
-  resolution: "@aztec/bb.js@npm:0.38.0"
+"@aztec/bb.js@npm:0.41.0":
+  version: 0.41.0
+  resolution: "@aztec/bb.js@npm:0.41.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 5ebc2850f37993db1d0fe4306ec612e9df14c5d227e1451f1b2f96e63e61c64225c46b32d1e1d2a1a0c37795e50b2875362520e9eb49324312516ec9fd6de2c7
+  checksum: e5e0095eaff3de45726366726337b131bb6ff7cf2cb53be705572c7d6715dae4c948bf86a03cfad68bc98c0c2d83e64cbe3723cc72260c8dbfa262af8cb81f9b
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.38.0
+    "@aztec/bb.js": 0.41.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From 533d10eec83711f19a39848f86b10a18f480506d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 22 May 2024 14:23:55 +0100
Subject: [PATCH 286/416] chore: use `bbup` to install `bb` (#5073)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

`bbup` is now in master so we can use it to install `bb`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/test-js-packages.yml         |  6 ++----
 cspell.json                                    |  1 +
 .../docs/getting_started/barretenberg/index.md | 18 ++++++------------
 scripts/install_bb.sh                          | 14 ++++++++------
 4 files changed, 17 insertions(+), 22 deletions(-)

diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index 9668e3f629f..db162e21269 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -402,8 +402,7 @@ jobs:
       - name: Install `bb`
         run: |
           ./scripts/install_bb.sh
-          echo "$HOME/.barretenberg/" >> $GITHUB_PATH
-          export PATH="$PATH:$HOME/.barretenberg/"
+          echo "$HOME/.bb/" >> $GITHUB_PATH
 
       - name: Download nargo binary
         uses: actions/download-artifact@v4
@@ -512,8 +511,7 @@ jobs:
       - name: Install `bb`
         run: |
           ./scripts/install_bb.sh
-          echo "$HOME/.barretenberg/" >> $GITHUB_PATH
-          export PATH="$PATH:$HOME/.barretenberg/"
+          echo "$HOME/.bb/" >> $GITHUB_PATH
 
       - name: Download nargo binary
         uses: actions/download-artifact@v4
diff --git a/cspell.json b/cspell.json
index b4f214c2f27..4497d0bf9da 100644
--- a/cspell.json
+++ b/cspell.json
@@ -19,6 +19,7 @@
         "barebones",
         "barretenberg",
         "barustenberg",
+        "bbup",
         "bincode",
         "bindgen",
         "bitand",
diff --git a/docs/docs/getting_started/barretenberg/index.md b/docs/docs/getting_started/barretenberg/index.md
index 048ba39f046..0102c86770b 100644
--- a/docs/docs/getting_started/barretenberg/index.md
+++ b/docs/docs/getting_started/barretenberg/index.md
@@ -23,31 +23,25 @@ Open a terminal on your machine, and write:
 ##### macOS (Apple Silicon)
 
 ```bash
-mkdir -p $HOME/.barretenberg && \
-curl -o ./barretenberg-aarch64-apple-darwin.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.38.0/barretenberg-aarch64-apple-darwin.tar.gz && \
-tar -xvf ./barretenberg-aarch64-apple-darwin.tar.gz -C $HOME/.barretenberg/ && \
-echo 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.zshrc && \
+curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
 source ~/.zshrc
+bbup -v 0.41.0
 ```
 
 ##### macOS (Intel)
 
 ```bash
-mkdir -p $HOME/.barretenberg && \
-curl -o ./barretenberg-x86_64-apple-darwin.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.38.0/barretenberg-x86_64-apple-darwin.tar.gz && \
-tar -xvf ./barretenberg-x86_64-apple-darwin.tar.gz -C $HOME/.barretenberg/ && \
-echo 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.zshrc && \
+curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
 source ~/.zshrc
+bbup -v 0.41.0
 ```
 
 ##### Linux (Bash)
 
 ```bash
-mkdir -p $HOME/.barretenberg && \
-curl -o ./barretenberg-x86_64-linux-gnu.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.38.0/barretenberg-x86_64-linux-gnu.tar.gz && \
-tar -xvf ./barretenberg-x86_64-linux-gnu.tar.gz -C $HOME/.barretenberg/ && \
-echo -e 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.bashrc && \
+curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
 source ~/.bashrc
+bbup -v 0.41.0
 ```
 
 Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/scripts/install_bb.sh b/scripts/install_bb.sh
index 519ffe6cb03..c3ed476200a 100755
--- a/scripts/install_bb.sh
+++ b/scripts/install_bb.sh
@@ -1,9 +1,11 @@
 #!/bin/bash
 
-# We use this script just for CI so we assume we're running on x86 linux
+VERSION="0.41.0"
 
-mkdir -p $HOME/.barretenberg
-curl -o ./barretenberg-x86_64-linux-gnu.tar.gz -L https://github.com/AztecProtocol/aztec-packages/releases/download/aztec-packages-v0.41.0/barretenberg-x86_64-linux-gnu.tar.gz
-tar -xvf ./barretenberg-x86_64-linux-gnu.tar.gz -C $HOME/.barretenberg/
-echo 'export PATH=$PATH:$HOME/.barretenberg/' >> ~/.bashrc
-source ~/.bashrc
+BBUP_PATH=~/.bb/bbup
+
+if ! [ -f $BBUP_PATH ]; then 
+    curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
+fi
+
+$BBUP_PATH -v $VERSION

From 9420d7c2ba6bbbf5ecb9a066837c505310955b6c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 22 May 2024 14:55:28 +0100
Subject: [PATCH 287/416] feat: remove conditional compilation of
 `bn254_blackbox_solver` (#5058)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR removes the conditional compilation on `Bn254BlackBoxSolver` as
it's no longer necessary.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acvm_js/src/execute.rs              | 57 ++++++-------------
 .../benches/criterion.rs                      | 12 ++--
 acvm-repo/bn254_blackbox_solver/src/lib.rs    | 19 +------
 tooling/acvm_cli/src/cli/execute_cmd.rs       |  3 +-
 tooling/nargo_cli/src/cli/dap_cmd.rs          |  5 +-
 tooling/nargo_cli/src/cli/debug_cmd.rs        |  4 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |  4 +-
 tooling/nargo_cli/src/cli/lsp_cmd.rs          |  3 +-
 8 files changed, 30 insertions(+), 77 deletions(-)

diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 338511874c9..9f2b07b31fc 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -20,11 +20,11 @@ use crate::{
 };
 
 #[wasm_bindgen]
-pub struct WasmBlackBoxFunctionSolver(Bn254BlackBoxSolver);
+pub struct WasmBlackBoxFunctionSolver;
 
 impl WasmBlackBoxFunctionSolver {
     async fn initialize() -> WasmBlackBoxFunctionSolver {
-        WasmBlackBoxFunctionSolver(Bn254BlackBoxSolver::initialize().await)
+        WasmBlackBoxFunctionSolver
     }
 }
 
@@ -47,15 +47,9 @@ pub async fn execute_circuit(
 ) -> Result<JsWitnessMap, Error> {
     console_error_panic_hook::set_once();
 
-    let solver = WasmBlackBoxFunctionSolver::initialize().await;
-
-    let mut witness_stack = execute_program_with_native_type_return(
-        &solver,
-        program,
-        initial_witness,
-        &foreign_call_handler,
-    )
-    .await?;
+    let mut witness_stack =
+        execute_program_with_native_type_return(program, initial_witness, &foreign_call_handler)
+            .await?;
     let witness_map =
         witness_stack.pop().expect("Should have at least one witness on the stack").witness;
     Ok(witness_map.into())
@@ -71,7 +65,7 @@ pub async fn execute_circuit(
 /// @returns {SolvedAndReturnWitness} The solved witness calculated by executing the circuit on the provided inputs, as well as the return witness indices as specified by the circuit.
 #[wasm_bindgen(js_name = executeCircuitWithReturnWitness, skip_jsdoc)]
 pub async fn execute_circuit_with_return_witness(
-    solver: &WasmBlackBoxFunctionSolver,
+    _solver: &WasmBlackBoxFunctionSolver,
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
@@ -82,7 +76,6 @@ pub async fn execute_circuit_with_return_witness(
     .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None, None))?;
 
     let mut witness_stack = execute_program_with_native_program_and_return(
-        solver,
         &program,
         initial_witness,
         &foreign_call_handler,
@@ -108,20 +101,16 @@ pub async fn execute_circuit_with_return_witness(
 /// @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
 #[wasm_bindgen(js_name = executeCircuitWithBlackBoxSolver, skip_jsdoc)]
 pub async fn execute_circuit_with_black_box_solver(
-    solver: &WasmBlackBoxFunctionSolver,
+    _solver: &WasmBlackBoxFunctionSolver,
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
 ) -> Result<JsWitnessMap, Error> {
     console_error_panic_hook::set_once();
 
-    let mut witness_stack = execute_program_with_native_type_return(
-        solver,
-        program,
-        initial_witness,
-        &foreign_call_handler,
-    )
-    .await?;
+    let mut witness_stack =
+        execute_program_with_native_type_return(program, initial_witness, &foreign_call_handler)
+            .await?;
     let witness_map =
         witness_stack.pop().expect("Should have at least one witness on the stack").witness;
     Ok(witness_map.into())
@@ -143,24 +132,19 @@ pub async fn execute_program(
 
 #[wasm_bindgen(js_name = executeProgramWithBlackBoxSolver, skip_jsdoc)]
 pub async fn execute_program_with_black_box_solver(
-    solver: &WasmBlackBoxFunctionSolver,
+    _solver: &WasmBlackBoxFunctionSolver,
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_executor: &ForeignCallHandler,
 ) -> Result<JsWitnessStack, Error> {
-    let witness_stack = execute_program_with_native_type_return(
-        solver,
-        program,
-        initial_witness,
-        foreign_call_executor,
-    )
-    .await?;
+    let witness_stack =
+        execute_program_with_native_type_return(program, initial_witness, foreign_call_executor)
+            .await?;
 
     Ok(witness_stack.into())
 }
 
 async fn execute_program_with_native_type_return(
-    solver: &WasmBlackBoxFunctionSolver,
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_executor: &ForeignCallHandler,
@@ -171,25 +155,20 @@ async fn execute_program_with_native_type_return(
         None,
         None))?;
 
-    execute_program_with_native_program_and_return(
-        solver,
-        &program,
-        initial_witness,
-        foreign_call_executor,
-    )
-    .await
+    execute_program_with_native_program_and_return(&program, initial_witness, foreign_call_executor)
+        .await
 }
 
 async fn execute_program_with_native_program_and_return(
-    solver: &WasmBlackBoxFunctionSolver,
     program: &Program,
     initial_witness: JsWitnessMap,
     foreign_call_executor: &ForeignCallHandler,
 ) -> Result<WitnessStack, Error> {
+    let blackbox_solver = Bn254BlackBoxSolver;
     let executor = ProgramExecutor::new(
         &program.functions,
         &program.unconstrained_functions,
-        &solver.0,
+        &blackbox_solver,
         foreign_call_executor,
     );
     let witness_stack = executor.execute(initial_witness.into()).await?;
diff --git a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
index a8fa7d8aae4..b86414423cf 100644
--- a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
+++ b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
@@ -15,23 +15,21 @@ fn bench_poseidon2(c: &mut Criterion) {
 
 fn bench_pedersen_commitment(c: &mut Criterion) {
     let inputs = [FieldElement::one(); 2];
-    let solver = Bn254BlackBoxSolver::new();
 
     c.bench_function("pedersen_commitment", |b| {
-        b.iter(|| solver.pedersen_commitment(black_box(&inputs), 0))
+        b.iter(|| Bn254BlackBoxSolver.pedersen_commitment(black_box(&inputs), 0))
     });
 }
 
 fn bench_pedersen_hash(c: &mut Criterion) {
     let inputs = [FieldElement::one(); 2];
-    let solver = Bn254BlackBoxSolver::new();
 
-    c.bench_function("pedersen_hash", |b| b.iter(|| solver.pedersen_hash(black_box(&inputs), 0)));
+    c.bench_function("pedersen_hash", |b| {
+        b.iter(|| Bn254BlackBoxSolver.pedersen_hash(black_box(&inputs), 0))
+    });
 }
 
 fn bench_schnorr_verify(c: &mut Criterion) {
-    let solver = Bn254BlackBoxSolver::new();
-
     let pub_key_x = FieldElement::from_hex(
         "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
     )
@@ -51,7 +49,7 @@ fn bench_schnorr_verify(c: &mut Criterion) {
 
     c.bench_function("schnorr_verify", |b| {
         b.iter(|| {
-            solver.schnorr_verify(
+            Bn254BlackBoxSolver.schnorr_verify(
                 black_box(&pub_key_x),
                 black_box(&pub_key_y),
                 black_box(&sig_bytes),
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 43b86e083d5..ae5a1c3db6d 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -15,26 +15,9 @@ use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use poseidon2::poseidon2_permutation;
 
+#[derive(Default)]
 pub struct Bn254BlackBoxSolver;
 
-impl Bn254BlackBoxSolver {
-    pub async fn initialize() -> Bn254BlackBoxSolver {
-        Bn254BlackBoxSolver
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn new() -> Bn254BlackBoxSolver {
-        Bn254BlackBoxSolver
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl Default for Bn254BlackBoxSolver {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
     fn schnorr_verify(
         &self,
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index 4e36dbd1f22..5f9651c9138 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -67,13 +67,12 @@ pub(crate) fn execute_program_from_witness(
     bytecode: &[u8],
     foreign_call_resolver_url: Option<&str>,
 ) -> Result<WitnessStack, CliError> {
-    let blackbox_solver = Bn254BlackBoxSolver::new();
     let program: Program = Program::deserialize_program(bytecode)
         .map_err(|_| CliError::CircuitDeserializationError())?;
     execute_program(
         &program,
         inputs_map,
-        &blackbox_solver,
+        &Bn254BlackBoxSolver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
     )
     .map_err(CliError::CircuitExecutionError)
diff --git a/tooling/nargo_cli/src/cli/dap_cmd.rs b/tooling/nargo_cli/src/cli/dap_cmd.rs
index 124e30069ae..eded2bfd8d2 100644
--- a/tooling/nargo_cli/src/cli/dap_cmd.rs
+++ b/tooling/nargo_cli/src/cli/dap_cmd.rs
@@ -1,5 +1,6 @@
 use acvm::acir::circuit::ExpressionWidth;
 use acvm::acir::native_types::WitnessMap;
+use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::workspace::Workspace;
@@ -193,11 +194,9 @@ fn loop_uninitialized_dap<R: Read, W: Write>(
                     Ok((compiled_program, initial_witness)) => {
                         server.respond(req.ack()?)?;
 
-                        let blackbox_solver = bn254_blackbox_solver::Bn254BlackBoxSolver::new();
-
                         noir_debugger::run_dap_loop(
                             server,
-                            &blackbox_solver,
+                            &Bn254BlackBoxSolver,
                             compiled_program,
                             initial_witness,
                         )?;
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index f950cd0405c..7865b608261 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -219,8 +219,6 @@ pub(crate) fn debug_program(
     compiled_program: &CompiledProgram,
     inputs_map: &InputMap,
 ) -> Result<Option<WitnessMap>, CliError> {
-    let blackbox_solver = Bn254BlackBoxSolver::new();
-
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
     let debug_artifact = DebugArtifact {
@@ -230,7 +228,7 @@ pub(crate) fn debug_program(
     };
 
     noir_debugger::debug_circuit(
-        &blackbox_solver,
+        &Bn254BlackBoxSolver,
         &compiled_program.program.functions[0],
         debug_artifact,
         initial_witness,
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 862a46884ef..3fcedbb8f54 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -110,14 +110,12 @@ pub(crate) fn execute_program(
     inputs_map: &InputMap,
     foreign_call_resolver_url: Option<&str>,
 ) -> Result<WitnessStack, CliError> {
-    let blackbox_solver = Bn254BlackBoxSolver::new();
-
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
     let solved_witness_stack_err = nargo::ops::execute_program(
         &compiled_program.program,
         initial_witness,
-        &blackbox_solver,
+        &Bn254BlackBoxSolver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
     );
     match solved_witness_stack_err {
diff --git a/tooling/nargo_cli/src/cli/lsp_cmd.rs b/tooling/nargo_cli/src/cli/lsp_cmd.rs
index 45ac02ea552..9ff7a42e5f5 100644
--- a/tooling/nargo_cli/src/cli/lsp_cmd.rs
+++ b/tooling/nargo_cli/src/cli/lsp_cmd.rs
@@ -25,8 +25,7 @@ pub(crate) fn run(_args: LspCommand, _config: NargoConfig) -> Result<(), CliErro
 
     runtime.block_on(async {
         let (server, _) = async_lsp::MainLoop::new_server(|client| {
-            let blackbox_solver = Bn254BlackBoxSolver::new();
-            let router = NargoLspService::new(&client, blackbox_solver);
+            let router = NargoLspService::new(&client, Bn254BlackBoxSolver);
 
             ServiceBuilder::new()
                 .layer(TracingLayer::default())

From 904f5eba2cb3e47f2148d5f2441c8e5107a5e705 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 22 May 2024 10:03:45 -0500
Subject: [PATCH 288/416] chore(experimental): Add types and traits to the
 elaborator (#5066)

# Description

## Problem\*

Working towards #4594

## Summary\*

Adds support for resolving top-level traits and type definitions to the
elaborator.

## Additional Context

After this PR only globals will need to be resolved in the elaborator.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs |  87 +++++++-
 .../noirc_frontend/src/elaborator/traits.rs   | 196 ++++++++++++++++++
 .../noirc_frontend/src/elaborator/types.rs    |  33 ++-
 3 files changed, 307 insertions(+), 9 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/elaborator/traits.rs

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 0f9d22ca9b5..50b39757fda 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -10,7 +10,10 @@ use crate::{
         UnresolvedTraitConstraint, UnresolvedTypeExpression,
     },
     hir::{
-        def_collector::{dc_crate::CompilationError, errors::DuplicateType},
+        def_collector::{
+            dc_crate::{CompilationError, UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias},
+            errors::DuplicateType,
+        },
         resolution::{errors::ResolverError, path_resolver::PathResolver, resolver::LambdaContext},
         scope::ScopeForest as GenericScopeForest,
         type_check::TypeCheckError,
@@ -27,10 +30,10 @@ use crate::{
     macros_api::{
         BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirExpression,
         HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
-        MethodCallExpression, NodeInterner, NoirFunction, PrefixExpression, Statement,
+        MethodCallExpression, NodeInterner, NoirFunction, NoirStruct, PrefixExpression, Statement,
         StatementKind, StructId,
     },
-    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, StmtId, TraitId},
+    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, StmtId, TraitId, TypeAliasId},
     Shared, StructType, Type, TypeVariable,
 };
 use crate::{
@@ -68,6 +71,7 @@ mod expressions;
 mod patterns;
 mod scope;
 mod statements;
+mod traits;
 mod types;
 
 use fm::FileId;
@@ -206,11 +210,12 @@ impl<'context> Elaborator<'context> {
         // the resolver filters literal globals first
         for global in items.globals {}
 
-        for alias in items.type_aliases {}
-
-        for trait_ in items.traits {}
+        for (alias_id, alias) in items.type_aliases {
+            this.define_type_alias(alias_id, alias);
+        }
 
-        for struct_ in items.types {}
+        this.collect_traits(items.traits);
+        this.collect_struct_definitions(items.types);
 
         for trait_impl in &mut items.trait_impls {
             this.collect_trait_impl(trait_impl);
@@ -1100,4 +1105,72 @@ impl<'context> Elaborator<'context> {
             });
         }
     }
+
+    fn define_type_alias(&mut self, alias_id: TypeAliasId, alias: UnresolvedTypeAlias) {
+        self.file = alias.file_id;
+        self.local_module = alias.module_id;
+
+        let generics = self.add_generics(&alias.type_alias_def.generics);
+        self.resolve_local_globals();
+        self.current_item = Some(DependencyId::Alias(alias_id));
+        let typ = self.resolve_type(alias.type_alias_def.typ);
+        self.interner.set_type_alias(alias_id, typ, generics);
+    }
+
+    fn collect_struct_definitions(&mut self, structs: BTreeMap<StructId, UnresolvedStruct>) {
+        // This is necessary to avoid cloning the entire struct map
+        // when adding checks after each struct field is resolved.
+        let struct_ids = structs.keys().copied().collect::<Vec<_>>();
+
+        // Resolve each field in each struct.
+        // Each struct should already be present in the NodeInterner after def collection.
+        for (type_id, typ) in structs {
+            self.file = typ.file_id;
+            self.local_module = typ.module_id;
+            let (generics, fields) = self.resolve_struct_fields(typ.struct_def, type_id);
+
+            self.interner.update_struct(type_id, |struct_def| {
+                struct_def.set_fields(fields);
+                struct_def.generics = generics;
+            });
+        }
+
+        // Check whether the struct fields have nested slices
+        // We need to check after all structs are resolved to
+        // make sure every struct's fields is accurately set.
+        for id in struct_ids {
+            let struct_type = self.interner.get_struct(id);
+            // Only handle structs without generics as any generics args will be checked
+            // after monomorphization when performing SSA codegen
+            if struct_type.borrow().generics.is_empty() {
+                let fields = struct_type.borrow().get_fields(&[]);
+                for (_, field_type) in fields.iter() {
+                    if field_type.is_nested_slice() {
+                        let location = struct_type.borrow().location;
+                        self.file = location.file;
+                        self.push_err(ResolverError::NestedSlices { span: location.span });
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn resolve_struct_fields(
+        &mut self,
+        unresolved: NoirStruct,
+        struct_id: StructId,
+    ) -> (Generics, Vec<(Ident, Type)>) {
+        let generics = self.add_generics(&unresolved.generics);
+
+        // Check whether the struct definition has globals in the local module and add them to the scope
+        self.resolve_local_globals();
+
+        self.current_item = Some(DependencyId::Struct(struct_id));
+
+        self.resolving_ids.insert(struct_id);
+        let fields = vecmap(unresolved.fields, |(ident, typ)| (ident, self.resolve_type(typ)));
+        self.resolving_ids.remove(&struct_id);
+
+        (generics, fields)
+    }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
new file mode 100644
index 00000000000..e7018d900d8
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -0,0 +1,196 @@
+use std::collections::BTreeMap;
+
+use iter_extended::vecmap;
+use noirc_errors::Location;
+
+use crate::{
+    ast::{FunctionKind, TraitItem, UnresolvedGenerics, UnresolvedTraitConstraint},
+    hir::{
+        def_collector::dc_crate::UnresolvedTrait, def_map::ModuleId,
+        resolution::path_resolver::StandardPathResolver,
+    },
+    hir_def::{
+        function::{FuncMeta, HirFunction},
+        traits::{TraitConstant, TraitFunction, TraitType},
+    },
+    macros_api::{
+        BlockExpression, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility,
+        NoirFunction, Param, Pattern, UnresolvedType, Visibility,
+    },
+    node_interner::{FuncId, TraitId},
+    token::Attributes,
+    Generics, Type, TypeVariable, TypeVariableKind,
+};
+
+use super::Elaborator;
+
+impl<'context> Elaborator<'context> {
+    pub fn collect_traits(&mut self, traits: BTreeMap<TraitId, UnresolvedTrait>) {
+        for (trait_id, unresolved_trait) in &traits {
+            self.interner.push_empty_trait(*trait_id, unresolved_trait);
+        }
+
+        for (trait_id, unresolved_trait) in traits {
+            let generics = vecmap(&unresolved_trait.trait_def.generics, |_| {
+                TypeVariable::unbound(self.interner.next_type_variable_id())
+            });
+
+            // Resolve order
+            // 1. Trait Types ( Trait constants can have a trait type, therefore types before constants)
+            let _ = self.resolve_trait_types(&unresolved_trait);
+            // 2. Trait Constants ( Trait's methods can use trait types & constants, therefore they should be after)
+            let _ = self.resolve_trait_constants(&unresolved_trait);
+            // 3. Trait Methods
+            let methods = self.resolve_trait_methods(trait_id, &unresolved_trait, &generics);
+
+            self.interner.update_trait(trait_id, |trait_def| {
+                trait_def.set_methods(methods);
+                trait_def.generics = generics;
+            });
+
+            // This check needs to be after the trait's methods are set since
+            // the interner may set `interner.ordering_type` based on the result type
+            // of the Cmp trait, if this is it.
+            if self.crate_id.is_stdlib() {
+                self.interner.try_add_operator_trait(trait_id);
+            }
+        }
+    }
+
+    fn resolve_trait_types(&mut self, _unresolved_trait: &UnresolvedTrait) -> Vec<TraitType> {
+        // TODO
+        vec![]
+    }
+
+    fn resolve_trait_constants(
+        &mut self,
+        _unresolved_trait: &UnresolvedTrait,
+    ) -> Vec<TraitConstant> {
+        // TODO
+        vec![]
+    }
+
+    fn resolve_trait_methods(
+        &mut self,
+        trait_id: TraitId,
+        unresolved_trait: &UnresolvedTrait,
+        trait_generics: &Generics,
+    ) -> Vec<TraitFunction> {
+        self.local_module = unresolved_trait.module_id;
+        self.file = self.def_maps[&self.crate_id].file_id(unresolved_trait.module_id);
+
+        let mut functions = vec![];
+
+        for item in &unresolved_trait.trait_def.items {
+            if let TraitItem::Function {
+                name,
+                generics,
+                parameters,
+                return_type,
+                where_clause,
+                body: _,
+            } = item
+            {
+                let old_generic_count = self.generics.len();
+
+                let the_trait = self.interner.get_trait(trait_id);
+                let self_typevar = the_trait.self_type_typevar.clone();
+                let self_type = Type::TypeVariable(self_typevar.clone(), TypeVariableKind::Normal);
+                let name_span = the_trait.name.span();
+
+                self.add_generics(generics);
+                self.add_existing_generics(&unresolved_trait.trait_def.generics, trait_generics);
+                self.add_existing_generic("Self", name_span, self_typevar);
+                self.self_type = Some(self_type.clone());
+
+                let func_id = unresolved_trait.method_ids[&name.0.contents];
+                self.resolve_trait_function(
+                    name,
+                    generics,
+                    parameters,
+                    return_type,
+                    where_clause,
+                    func_id,
+                );
+
+                let arguments = vecmap(parameters, |param| self.resolve_type(param.1.clone()));
+                let return_type = self.resolve_type(return_type.get_type().into_owned());
+
+                let generics = vecmap(&self.generics, |(_, type_var, _)| type_var.clone());
+
+                let default_impl_list: Vec<_> = unresolved_trait
+                    .fns_with_default_impl
+                    .functions
+                    .iter()
+                    .filter(|(_, _, q)| q.name() == name.0.contents)
+                    .collect();
+
+                let default_impl = if default_impl_list.len() == 1 {
+                    Some(Box::new(default_impl_list[0].2.clone()))
+                } else {
+                    None
+                };
+
+                let no_environment = Box::new(Type::Unit);
+                let function_type =
+                    Type::Function(arguments, Box::new(return_type), no_environment);
+
+                functions.push(TraitFunction {
+                    name: name.clone(),
+                    typ: Type::Forall(generics, Box::new(function_type)),
+                    location: Location::new(name.span(), unresolved_trait.file_id),
+                    default_impl,
+                    default_impl_module_id: unresolved_trait.module_id,
+                });
+
+                self.generics.truncate(old_generic_count);
+            }
+        }
+        functions
+    }
+
+    pub fn resolve_trait_function(
+        &mut self,
+        name: &Ident,
+        generics: &UnresolvedGenerics,
+        parameters: &[(Ident, UnresolvedType)],
+        return_type: &FunctionReturnType,
+        where_clause: &[UnresolvedTraitConstraint],
+        func_id: FuncId,
+    ) {
+        let old_generic_count = self.generics.len();
+        self.scopes.start_function();
+
+        // Check whether the function has globals in the local module and add them to the scope
+        self.resolve_local_globals();
+
+        self.trait_bounds = where_clause.to_vec();
+
+        let kind = FunctionKind::Normal;
+        let def = FunctionDefinition {
+            name: name.clone(),
+            attributes: Attributes::empty(),
+            is_unconstrained: false,
+            is_comptime: false,
+            visibility: ItemVisibility::Public, // Trait functions are always public
+            generics: generics.clone(),
+            parameters: vecmap(parameters, |(name, typ)| Param {
+                visibility: Visibility::Private,
+                pattern: Pattern::Identifier(name.clone()),
+                typ: typ.clone(),
+                span: name.span(),
+            }),
+            body: BlockExpression { statements: Vec::new() },
+            span: name.span(),
+            where_clause: where_clause.to_vec(),
+            return_type: return_type.clone(),
+            return_visibility: Visibility::Private,
+        };
+
+        self.elaborate_function(NoirFunction { kind, def }, func_id);
+        let _ = self.scopes.end_function();
+        // Don't check the scope tree for unused variables, they can't be used in a declaration anyway.
+        self.trait_bounds.clear();
+        self.generics.truncate(old_generic_count);
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 54920d5738b..3c8d805d802 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -4,7 +4,10 @@ use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
 use crate::{
-    ast::{BinaryOpKind, IntegerBitSize, UnresolvedTraitConstraint, UnresolvedTypeExpression},
+    ast::{
+        BinaryOpKind, IntegerBitSize, NoirTypeAlias, UnresolvedGenerics, UnresolvedTraitConstraint,
+        UnresolvedTypeExpression,
+    },
     hir::{
         def_map::ModuleDefId,
         resolution::{
@@ -26,7 +29,10 @@ use crate::{
         HirExpression, HirLiteral, HirStatement, Path, PathKind, SecondaryAttribute, Signedness,
         UnaryOp, UnresolvedType, UnresolvedTypeData,
     },
-    node_interner::{DefinitionKind, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId},
+    node_interner::{
+        DefinitionKind, DependencyId, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId,
+        TypeAliasId,
+    },
     Generics, Shared, StructType, Type, TypeAlias, TypeBinding, TypeVariable, TypeVariableKind,
 };
 
@@ -1435,4 +1441,27 @@ impl<'context> Elaborator<'context> {
             }
         }
     }
+
+    pub fn add_existing_generics(&mut self, names: &UnresolvedGenerics, generics: &Generics) {
+        assert_eq!(names.len(), generics.len());
+
+        for (name, typevar) in names.iter().zip(generics) {
+            self.add_existing_generic(&name.0.contents, name.0.span(), typevar.clone());
+        }
+    }
+
+    pub fn add_existing_generic(&mut self, name: &str, span: Span, typevar: TypeVariable) {
+        // Check for name collisions of this generic
+        let rc_name = Rc::new(name.to_owned());
+
+        if let Some((_, _, first_span)) = self.find_generic(&rc_name) {
+            self.push_err(ResolverError::DuplicateDefinition {
+                name: name.to_owned(),
+                first_span: *first_span,
+                second_span: span,
+            });
+        } else {
+            self.generics.push((rc_name, typevar, span));
+        }
+    }
 }

From 20c4b81c6f89a89714e0c5205f49f1358110d728 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 22 May 2024 10:35:09 -0500
Subject: [PATCH 289/416] chore(experimental): Elaborate globals (#5069)

# Description

## Problem\*

Working towards #4992

## Summary\*

Adds support for elaborating globals. This was the last major item for
resolution + type checking in the elaborator.

## Additional Context

Next up in the elaborator will be integrating the scanning
pass/interpreter and hooking it up to our integration tests.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 68 +++++++++++++++++--
 .../src/hir/def_collector/dc_crate.rs         |  2 +-
 compiler/noirc_frontend/src/node_interner.rs  | 12 ++++
 3 files changed, 75 insertions(+), 7 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 50b39757fda..0581e7900f8 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -11,7 +11,10 @@ use crate::{
     },
     hir::{
         def_collector::{
-            dc_crate::{CompilationError, UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias},
+            dc_crate::{
+                filter_literal_globals, CompilationError, UnresolvedGlobal, UnresolvedStruct,
+                UnresolvedTrait, UnresolvedTypeAlias,
+            },
             errors::DuplicateType,
         },
         resolution::{errors::ResolverError, path_resolver::PathResolver, resolver::LambdaContext},
@@ -25,13 +28,14 @@ use crate::{
             HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
             HirMethodReference, HirPrefixExpression,
         },
+        stmt::HirLetStatement,
         traits::TraitConstraint,
     },
     macros_api::{
         BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirExpression,
         HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
-        MethodCallExpression, NodeInterner, NoirFunction, NoirStruct, PrefixExpression, Statement,
-        StatementKind, StructId,
+        MethodCallExpression, NodeInterner, NoirFunction, NoirStruct, Pattern, PrefixExpression,
+        SecondaryAttribute, Statement, StatementKind, StructId,
     },
     node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, StmtId, TraitId, TypeAliasId},
     Shared, StructType, Type, TypeVariable,
@@ -207,25 +211,48 @@ impl<'context> Elaborator<'context> {
     ) -> Vec<(CompilationError, FileId)> {
         let mut this = Self::new(context, crate_id);
 
-        // the resolver filters literal globals first
-        for global in items.globals {}
+        // We must first resolve and intern the globals before we can resolve any stmts inside each function.
+        // Each function uses its own resolver with a newly created ScopeForest, and must be resolved again to be within a function's scope
+        //
+        // Additionally, we must resolve integer globals before structs since structs may refer to
+        // the values of integer globals as numeric generics.
+        let (literal_globals, non_literal_globals) = filter_literal_globals(items.globals);
+
+        for global in literal_globals {
+            this.elaborate_global(global);
+        }
 
         for (alias_id, alias) in items.type_aliases {
             this.define_type_alias(alias_id, alias);
         }
 
         this.collect_traits(items.traits);
+
+        // Must resolve structs before we resolve globals.
         this.collect_struct_definitions(items.types);
 
+        // Bind trait impls to their trait. Collect trait functions, that have a
+        // default implementation, which hasn't been overridden.
         for trait_impl in &mut items.trait_impls {
             this.collect_trait_impl(trait_impl);
         }
 
+        // Before we resolve any function symbols we must go through our impls and
+        // re-collect the methods within into their proper module. This cannot be
+        // done during def collection since we need to be able to resolve the type of
+        // the impl since that determines the module we should collect into.
+        //
+        // These are resolved after trait impls so that struct methods are chosen
+        // over trait methods if there are name conflicts.
         for ((typ, module), impls) in &items.impls {
             this.collect_impls(typ, *module, impls);
         }
 
-        // resolver resolves non-literal globals here
+        // We must wait to resolve non-literal globals until after we resolve structs since struct
+        // globals will need to reference the struct type they're initialized to to ensure they are valid.
+        for global in non_literal_globals {
+            this.elaborate_global(global);
+        }
 
         for functions in items.functions {
             this.elaborate_functions(functions);
@@ -1173,4 +1200,33 @@ impl<'context> Elaborator<'context> {
 
         (generics, fields)
     }
+
+    fn elaborate_global(&mut self, global: UnresolvedGlobal) {
+        self.local_module = global.module_id;
+        self.file = global.file_id;
+
+        let global_id = global.global_id;
+        self.current_item = Some(DependencyId::Global(global_id));
+
+        let definition_kind = DefinitionKind::Global(global_id);
+        let let_stmt = global.stmt_def;
+
+        if !self.in_contract
+            && let_stmt.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
+        {
+            let span = let_stmt.pattern.span();
+            self.push_err(ResolverError::AbiAttributeOutsideContract { span });
+        }
+
+        if !let_stmt.comptime && matches!(let_stmt.pattern, Pattern::Mutable(..)) {
+            let span = let_stmt.pattern.span();
+            self.push_err(ResolverError::MutableGlobal { span });
+        }
+
+        let (let_statement, _typ) = self.elaborate_let(let_stmt);
+
+        let statement_id = self.interner.get_global(global_id).let_statement;
+        self.interner.get_global_definition_mut(global_id).kind = definition_kind;
+        self.interner.replace_statement(statement_id, let_statement);
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index d2eaf79b0f0..afec3839599 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -486,7 +486,7 @@ fn inject_prelude(
 /// Separate the globals Vec into two. The first element in the tuple will be the
 /// literal globals, except for arrays, and the second will be all other globals.
 /// We exclude array literals as they can contain complex types
-fn filter_literal_globals(
+pub fn filter_literal_globals(
     globals: Vec<UnresolvedGlobal>,
 ) -> (Vec<UnresolvedGlobal>, Vec<UnresolvedGlobal>) {
     globals.into_iter().partition(|global| match &global.stmt_def.expression.kind {
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 7f1b67abfbd..d4145ef6a1d 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -916,6 +916,13 @@ impl NodeInterner {
         &self.definitions[id.0]
     }
 
+    /// Retrieves the definition where the given id was defined.
+    /// This will panic if given DefinitionId::dummy_id. Use try_definition for
+    /// any call with a possibly undefined variable.
+    pub fn definition_mut(&mut self, id: DefinitionId) -> &mut DefinitionInfo {
+        &mut self.definitions[id.0]
+    }
+
     /// Tries to retrieve the given id's definition.
     /// This function should be used during name resolution or type checking when we cannot be sure
     /// all variables have corresponding definitions (in case of an error in the user's code).
@@ -997,6 +1004,11 @@ impl NodeInterner {
         self.definition(global.definition_id)
     }
 
+    pub fn get_global_definition_mut(&mut self, global_id: GlobalId) -> &mut DefinitionInfo {
+        let global = self.get_global(global_id);
+        self.definition_mut(global.definition_id)
+    }
+
     pub fn get_all_globals(&self) -> &[GlobalInfo] {
         &self.globals
     }

From d43ba1bddbf6ebd56a7bee0e1db38d155fec95d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gustavo=20Gir=C3=A1ldez?= <ggiraldez@manas.tech>
Date: Wed, 22 May 2024 11:53:50 -0400
Subject: [PATCH 290/416] fix: Use plain integer addresses for opcodes in DAP
 disassembly view (#4941)

# Description

## Problem\*

Resolves #4904

The disassembly view from VS.Code didn't work properly. Sometimes it
would only show the first opcode only and once open it wouldn't update
the current opcode pointer when stepping through the code. This was
because we were using opcode locations (eg. `3.17`) as instruction
references (typed as string in the API), but VS.Code expects integers
either in decimal or hexadecimal format.

## Summary\*

This PR updates the disassembly request DAP command handler to return
integer addresses only, and changes the instruction set breakpoint
command to parse and map the given address to the appropriate opcode
location.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/debugger/src/context.rs | 259 ++++++++++++--------------------
 tooling/debugger/src/dap.rs     |  93 ++++++------
 2 files changed, 145 insertions(+), 207 deletions(-)

diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 646beaf0096..a031d127d82 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -34,6 +34,10 @@ pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver> {
     breakpoints: HashSet<OpcodeLocation>,
     source_to_opcodes: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>>,
     unconstrained_functions: &'a [BrilligBytecode],
+
+    // Absolute (in terms of all the opcodes ACIR+Brillig) addresses of the ACIR
+    // opcodes with one additional entry for to indicate the last valid address.
+    acir_opcode_addresses: Vec<usize>,
 }
 
 impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
@@ -46,6 +50,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         unconstrained_functions: &'a [BrilligBytecode],
     ) -> Self {
         let source_to_opcodes = build_source_to_opcode_debug_mappings(debug_artifact);
+        let acir_opcode_addresses = build_acir_opcode_offsets(circuit, unconstrained_functions);
         Self {
             // TODO: need to handle brillig pointer in the debugger
             acvm: ACVM::new(
@@ -61,6 +66,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
             breakpoints: HashSet::new(),
             source_to_opcodes,
             unconstrained_functions,
+            acir_opcode_addresses,
         }
     }
 
@@ -213,111 +219,55 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
             .collect()
     }
 
-    fn get_opcodes_sizes(&self) -> Vec<usize> {
-        self.get_opcodes()
-            .iter()
-            .map(|opcode| match opcode {
-                Opcode::BrilligCall { id, .. } => {
-                    self.unconstrained_functions[*id as usize].bytecode.len()
-                }
-                _ => 1,
-            })
-            .collect()
+    /// Returns the absolute address of the opcode at the given location.
+    /// Absolute here means accounting for nested Brillig opcodes in BrilligCall
+    /// opcodes.
+    pub fn opcode_location_to_address(&self, location: &OpcodeLocation) -> usize {
+        match location {
+            OpcodeLocation::Acir(acir_index) => self.acir_opcode_addresses[*acir_index],
+            OpcodeLocation::Brillig { acir_index, brillig_index } => {
+                self.acir_opcode_addresses[*acir_index] + *brillig_index
+            }
+        }
     }
 
-    /// Offsets the given location by the given number of opcodes (including
-    /// Brillig opcodes). If the offset would move the location outside of a
-    /// valid circuit location, returns None and the number of remaining
-    /// opcodes/instructions left which span outside the valid range in the
-    /// second element of the returned tuple.
-    pub(super) fn offset_opcode_location(
-        &self,
-        location: &Option<OpcodeLocation>,
-        mut offset: i64,
-    ) -> (Option<OpcodeLocation>, i64) {
-        if offset == 0 {
-            return (*location, 0);
+    pub fn address_to_opcode_location(&self, address: usize) -> Option<OpcodeLocation> {
+        if address >= *self.acir_opcode_addresses.last().unwrap_or(&0) {
+            return None;
         }
-        let Some(location) = location else {
-            return (None, offset);
-        };
-
-        let (mut acir_index, mut brillig_index) = match location {
-            OpcodeLocation::Acir(acir_index) => (*acir_index, 0),
-            OpcodeLocation::Brillig { acir_index, brillig_index } => (*acir_index, *brillig_index),
-        };
-        let opcode_sizes = self.get_opcodes_sizes();
-        if offset > 0 {
-            while offset > 0 {
-                let opcode_size = opcode_sizes[acir_index] as i64 - brillig_index as i64;
-                if offset >= opcode_size {
-                    acir_index += 1;
-                    offset -= opcode_size;
-                    brillig_index = 0;
-                } else {
-                    brillig_index += offset as usize;
-                    offset = 0;
-                }
-                if acir_index >= opcode_sizes.len() {
-                    return (None, offset);
-                }
+        let location = match self.acir_opcode_addresses.binary_search(&address) {
+            Ok(found_index) => OpcodeLocation::Acir(found_index),
+            Err(insert_index) => {
+                let acir_index = insert_index - 1;
+                let base_offset = self.acir_opcode_addresses[acir_index];
+                let brillig_index = address - base_offset;
+                OpcodeLocation::Brillig { acir_index, brillig_index }
             }
-        } else {
-            while offset < 0 {
-                if brillig_index > 0 {
-                    if brillig_index > (-offset) as usize {
-                        brillig_index -= (-offset) as usize;
-                        offset = 0;
-                    } else {
-                        offset += brillig_index as i64;
-                        brillig_index = 0;
-                    }
-                } else {
-                    if acir_index == 0 {
-                        return (None, offset);
-                    }
-                    acir_index -= 1;
-                    let opcode_size = opcode_sizes[acir_index] as i64;
-                    if opcode_size <= -offset {
-                        offset += opcode_size;
-                    } else {
-                        brillig_index = (opcode_size + offset) as usize;
-                        offset = 0;
-                    }
-                }
-            }
-        }
-        if brillig_index > 0 {
-            (Some(OpcodeLocation::Brillig { acir_index, brillig_index }), 0)
-        } else {
-            (Some(OpcodeLocation::Acir(acir_index)), 0)
-        }
+        };
+        Some(location)
     }
 
-    pub(super) fn render_opcode_at_location(&self, location: &Option<OpcodeLocation>) -> String {
+    pub(super) fn render_opcode_at_location(&self, location: &OpcodeLocation) -> String {
         let opcodes = self.get_opcodes();
         match location {
-            None => String::from("invalid"),
-            Some(OpcodeLocation::Acir(acir_index)) => {
+            OpcodeLocation::Acir(acir_index) => {
                 let opcode = &opcodes[*acir_index];
                 match opcode {
                     Opcode::BrilligCall { id, .. } => {
                         let first_opcode = &self.unconstrained_functions[*id as usize].bytecode[0];
-                        format!("BRILLIG CALL {first_opcode:?}")
+                        format!("BRILLIG {first_opcode:?}")
                     }
                     _ => format!("{opcode:?}"),
                 }
             }
-            Some(OpcodeLocation::Brillig { acir_index, brillig_index }) => {
-                match &opcodes[*acir_index] {
-                    Opcode::BrilligCall { id, .. } => {
-                        let bytecode = &self.unconstrained_functions[*id as usize].bytecode;
-                        let opcode = &bytecode[*brillig_index];
-                        format!("      | {opcode:?}")
-                    }
-                    _ => String::from("      | invalid"),
+            OpcodeLocation::Brillig { acir_index, brillig_index } => match &opcodes[*acir_index] {
+                Opcode::BrilligCall { id, .. } => {
+                    let bytecode = &self.unconstrained_functions[*id as usize].bytecode;
+                    let opcode = &bytecode[*brillig_index];
+                    format!("      | {opcode:?}")
                 }
-            }
+                _ => String::from("      | invalid"),
+            },
         }
     }
 
@@ -640,6 +590,28 @@ fn build_source_to_opcode_debug_mappings(
     result
 }
 
+fn build_acir_opcode_offsets(
+    circuit: &Circuit,
+    unconstrained_functions: &[BrilligBytecode],
+) -> Vec<usize> {
+    let mut result = Vec::with_capacity(circuit.opcodes.len() + 1);
+    // address of the first opcode is always 0
+    result.push(0);
+    circuit.opcodes.iter().fold(0, |acc, opcode| {
+        let acc = acc
+            + match opcode {
+                Opcode::BrilligCall { id, .. } => {
+                    unconstrained_functions[*id as usize].bytecode.len()
+                }
+                _ => 1,
+            };
+        // push the starting address of the next opcode
+        result.push(acc);
+        acc
+    });
+    result
+}
+
 // TODO: update all debugger tests to use unconstrained brillig pointers
 #[cfg(test)]
 mod tests {
@@ -851,7 +823,7 @@ mod tests {
     }
 
     #[test]
-    fn test_offset_opcode_location() {
+    fn test_address_opcode_location_mapping() {
         let brillig_bytecode = BrilligBytecode {
             bytecode: vec![
                 BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
@@ -883,85 +855,48 @@ mod tests {
             brillig_funcs,
         );
 
-        assert_eq!(context.offset_opcode_location(&None, 0), (None, 0));
-        assert_eq!(context.offset_opcode_location(&None, 2), (None, 2));
-        assert_eq!(context.offset_opcode_location(&None, -2), (None, -2));
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 0),
-            (Some(OpcodeLocation::Acir(0)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 1),
-            (Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 }), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 2),
-            (Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 3),
-            (Some(OpcodeLocation::Acir(1)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 4),
-            (Some(OpcodeLocation::Acir(2)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 5),
-            (Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 1 }), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 7),
-            (Some(OpcodeLocation::Acir(3)), 0)
-        );
-        assert_eq!(context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 8), (None, 0));
-        assert_eq!(context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), 20), (None, 12));
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(1)), 2),
-            (Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 1 }), 0)
-        );
-        assert_eq!(context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), -1), (None, -1));
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(0)), -10),
-            (None, -10)
-        );
+        let locations =
+            (0..=7).map(|address| context.address_to_opcode_location(address)).collect::<Vec<_>>();
 
+        // mapping from addresses to opcode locations
         assert_eq!(
-            context.offset_opcode_location(
-                &Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 }),
-                -1
-            ),
-            (Some(OpcodeLocation::Acir(0)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(
-                &Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }),
-                -2
-            ),
-            (Some(OpcodeLocation::Acir(0)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(1)), -3),
-            (Some(OpcodeLocation::Acir(0)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(2)), -4),
-            (Some(OpcodeLocation::Acir(0)), 0)
-        );
-        assert_eq!(
-            context.offset_opcode_location(
-                &Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 1 }),
-                -5
-            ),
-            (Some(OpcodeLocation::Acir(0)), 0)
+            locations,
+            vec![
+                Some(OpcodeLocation::Acir(0)),
+                Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 }),
+                Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }),
+                Some(OpcodeLocation::Acir(1)),
+                Some(OpcodeLocation::Acir(2)),
+                Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 1 }),
+                Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 2 }),
+                Some(OpcodeLocation::Acir(3)),
+            ]
         );
+
+        let addresses = locations
+            .iter()
+            .flatten()
+            .map(|location| context.opcode_location_to_address(location))
+            .collect::<Vec<_>>();
+
+        // and vice-versa
+        assert_eq!(addresses, (0..=7).collect::<Vec<_>>());
+
+        // check edge cases
+        assert_eq!(None, context.address_to_opcode_location(8));
         assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(3)), -7),
-            (Some(OpcodeLocation::Acir(0)), 0)
+            0,
+            context.opcode_location_to_address(&OpcodeLocation::Brillig {
+                acir_index: 0,
+                brillig_index: 0
+            })
         );
         assert_eq!(
-            context.offset_opcode_location(&Some(OpcodeLocation::Acir(2)), -2),
-            (Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }), 0)
+            4,
+            context.opcode_location_to_address(&OpcodeLocation::Brillig {
+                acir_index: 2,
+                brillig_index: 0
+            })
         );
     }
 }
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index 060945132f5..c9b6b816a7e 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -1,6 +1,5 @@
 use std::collections::BTreeMap;
 use std::io::{Read, Write};
-use std::str::FromStr;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, OpcodeLocation};
@@ -205,6 +204,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
                     Some(frame) => format!("{} {}", frame.function_name, index),
                     None => format!("frame #{index}"),
                 };
+                let address = self.context.opcode_location_to_address(opcode_location);
 
                 StackFrame {
                     id: index as i64,
@@ -218,7 +218,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
                     }),
                     line: line_number as i64,
                     column: column_number as i64,
-                    instruction_pointer_reference: Some(opcode_location.to_string()),
+                    instruction_pointer_reference: Some(address.to_string()),
                     ..StackFrame::default()
                 }
             })
@@ -240,50 +240,41 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
         let Command::Disassemble(ref args) = req.command else {
             unreachable!("handle_disassemble called on a non disassemble request");
         };
-        let starting_ip = OpcodeLocation::from_str(args.memory_reference.as_str()).ok();
+
+        // we assume memory references are unsigned integers
+        let starting_address = args.memory_reference.parse::<i64>().unwrap_or(0);
         let instruction_offset = args.instruction_offset.unwrap_or(0);
-        let (mut opcode_location, mut invalid_count) =
-            self.context.offset_opcode_location(&starting_ip, instruction_offset);
+
+        let mut address = starting_address + instruction_offset;
         let mut count = args.instruction_count;
 
         let mut instructions: Vec<DisassembledInstruction> = vec![];
 
-        // leading invalid locations (when the request goes back
-        // beyond the start of the program)
-        if invalid_count < 0 {
-            while invalid_count < 0 {
+        while count > 0 {
+            let opcode_location = if address >= 0 {
+                self.context.address_to_opcode_location(address as usize)
+            } else {
+                None
+            };
+
+            if let Some(opcode_location) = opcode_location {
                 instructions.push(DisassembledInstruction {
-                    address: String::from("---"),
-                    instruction: String::from("---"),
+                    address: address.to_string(),
+                    // we'll use the instruction_bytes field to render the OpcodeLocation
+                    instruction_bytes: Some(opcode_location.to_string()),
+                    instruction: self.context.render_opcode_at_location(&opcode_location),
+                    ..DisassembledInstruction::default()
+                });
+            } else {
+                // entry for invalid location to fill up the request
+                instructions.push(DisassembledInstruction {
+                    address: "---".to_owned(),
+                    instruction: "---".to_owned(),
                     ..DisassembledInstruction::default()
                 });
-                invalid_count += 1;
-                count -= 1;
-            }
-            if count > 0 {
-                opcode_location = Some(OpcodeLocation::Acir(0));
             }
-        }
-        // the actual opcodes
-        while count > 0 && opcode_location.is_some() {
-            instructions.push(DisassembledInstruction {
-                address: format!("{}", opcode_location.unwrap()),
-                instruction: self.context.render_opcode_at_location(&opcode_location),
-                ..DisassembledInstruction::default()
-            });
-            (opcode_location, _) = self.context.offset_opcode_location(&opcode_location, 1);
-            count -= 1;
-        }
-        // any remaining instruction count is beyond the valid opcode
-        // vector so return invalid placeholders
-        while count > 0 {
-            instructions.push(DisassembledInstruction {
-                address: String::from("---"),
-                instruction: String::from("---"),
-                ..DisassembledInstruction::default()
-            });
-            invalid_count -= 1;
             count -= 1;
+            address += 1;
         }
 
         self.server.respond(
@@ -418,25 +409,35 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
             .breakpoints
             .iter()
             .map(|breakpoint| {
-                let Ok(location) =
-                    OpcodeLocation::from_str(breakpoint.instruction_reference.as_str())
-                else {
+                let offset = breakpoint.offset.unwrap_or(0);
+                let address = breakpoint.instruction_reference.parse::<i64>().unwrap_or(0) + offset;
+                let Ok(address): Result<usize, _> = address.try_into() else {
                     return Breakpoint {
                         verified: false,
-                        message: Some(String::from("Missing instruction reference")),
+                        message: Some(String::from("Invalid instruction reference/offset")),
                         ..Breakpoint::default()
                     };
                 };
-                if !self.context.is_valid_opcode_location(&location) {
+                let Some(location) = self
+                    .context
+                    .address_to_opcode_location(address)
+                    .filter(|location| self.context.is_valid_opcode_location(location))
+                else {
                     return Breakpoint {
                         verified: false,
                         message: Some(String::from("Invalid opcode location")),
                         ..Breakpoint::default()
                     };
-                }
+                };
                 let id = self.get_next_breakpoint_id();
                 breakpoints_to_set.push((location, id));
-                Breakpoint { id: Some(id), verified: true, ..Breakpoint::default() }
+                Breakpoint {
+                    id: Some(id),
+                    verified: true,
+                    offset: Some(0),
+                    instruction_reference: Some(address.to_string()),
+                    ..Breakpoint::default()
+                }
             })
             .collect();
 
@@ -496,15 +497,17 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
                         ..Breakpoint::default()
                     };
                 }
-                let instruction_reference = format!("{}", location);
+                let breakpoint_address = self.context.opcode_location_to_address(&location);
+                let instruction_reference = format!("{}", breakpoint_address);
                 let breakpoint_id = self.get_next_breakpoint_id();
                 breakpoints_to_set.push((location, breakpoint_id));
                 Breakpoint {
                     id: Some(breakpoint_id),
                     verified: true,
                     source: Some(args.source.clone()),
-                    instruction_reference: Some(instruction_reference),
                     line: Some(line),
+                    instruction_reference: Some(instruction_reference),
+                    offset: Some(0),
                     ..Breakpoint::default()
                 }
             })

From c9fda3c7fd4575bfe7d457e8d4230e071f0129a0 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 22 May 2024 18:36:23 +0200
Subject: [PATCH 291/416] feat: Activate return_data in ACIR opcodes (#5080)

# Description

## Problem\*

Related to #4974

## Summary\*
This PR mark return data array with return_data block type, and disable
the unused arrays optimisation for databus.
This is required because the return_data is not returned from main
although similar constraints will be generated on the backend side.


## Additional Context
This should be the last piece for this databus iteration from issue
#4974, and it will allow to generate an end-to-end test with the databus
to check if we get what is expected.


## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acir/src/circuit/opcodes.rs                   | 6 ++++++
 acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs | 5 +++--
 compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs        | 4 +++-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index e6dc11dac78..6043196dfff 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -18,6 +18,12 @@ pub enum BlockType {
     ReturnData,
 }
 
+impl BlockType {
+    pub fn is_databus(&self) -> bool {
+        matches!(self, BlockType::CallData | BlockType::ReturnData)
+    }
+}
+
 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Opcode {
diff --git a/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs b/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs
index 18eefa79ac2..5fdcf54a492 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs
@@ -44,8 +44,9 @@ impl UnusedMemoryOptimizer {
         let mut optimized_opcodes = Vec::with_capacity(self.circuit.opcodes.len());
         for (idx, opcode) in self.circuit.opcodes.into_iter().enumerate() {
             match opcode {
-                Opcode::MemoryInit { block_id, .. }
-                    if self.unused_memory_initializations.contains(&block_id) =>
+                Opcode::MemoryInit { block_id, block_type, .. }
+                    if !block_type.is_databus()
+                        && self.unused_memory_initializations.contains(&block_id) =>
                 {
                     // Drop opcode
                 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index fefe5f6f8e6..30fd83d7704 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1728,7 +1728,7 @@ impl<'a> Context<'a> {
         &mut self,
         terminator: &TerminatorInstruction,
         dfg: &DataFlowGraph,
-    ) -> Result<Vec<SsaReport>, InternalError> {
+    ) -> Result<Vec<SsaReport>, RuntimeError> {
         let (return_values, call_stack) = match terminator {
             TerminatorInstruction::Return { return_values, call_stack } => {
                 (return_values, call_stack)
@@ -1750,6 +1750,8 @@ impl<'a> Context<'a> {
             if !is_databus {
                 // We do not return value for the data bus.
                 self.acir_context.return_var(acir_var)?;
+            } else {
+                self.check_array_is_initialized(self.data_bus.return_data.unwrap(), dfg)?;
             }
         }
         Ok(warnings)

From 4ae91cf083e4357adc74df510e33ef00b94fc620 Mon Sep 17 00:00:00 2001
From: TomAFrench <tom@tomfren.ch>
Date: Wed, 22 May 2024 19:03:48 +0000
Subject: [PATCH 292/416] chore: update `nargo info` table to remove circuit
 size column

---
 tooling/nargo_cli/src/cli/info_cmd.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 11cf6e22ab5..6c0709e7611 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -94,7 +94,7 @@ pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError
         })
         .collect();
 
-    let info_report = InfoReport { programs: program_info, contracts: Vec::new() };
+    let info_report = InfoReport { programs: program_info };
 
     if args.json {
         // Expose machine-readable JSON data.
@@ -102,7 +102,7 @@ pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError
     } else {
         // Otherwise print human-readable table.
         if !info_report.programs.is_empty() {
-            let mut program_table = table!([Fm->"Package", Fm->"Function", Fm->"Expression Width", Fm->"ACIR Opcodes", Fm->"Backend Circuit Size"]);
+            let mut program_table = table!([Fm->"Package", Fm->"Function", Fm->"Expression Width", Fm->"ACIR Opcodes"]);
 
             for program_info in info_report.programs {
                 let program_rows: Vec<Row> = program_info.into();
@@ -169,7 +169,6 @@ fn byte_index(string: &str, index: u32) -> usize {
 #[derive(Debug, Default, Serialize)]
 struct InfoReport {
     programs: Vec<ProgramInfo>,
-    contracts: Vec<ContractInfo>,
 }
 
 #[derive(Debug, Serialize)]

From e807f0d5080707794af7b3612b51b3956d7417e8 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 23 May 2024 00:25:08 +0100
Subject: [PATCH 293/416] chore: automatically clear any unwanted directories
 in `test_programs` (#5081)

# Description

## Problem\*

Closes #5035

## Summary\*

Alternative to #5035 which just deletes any test programs which don't
have a Nargo.toml file.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 test_programs/rebuild.sh              | 8 ++++++++
 tooling/nargo_cli/src/cli/info_cmd.rs | 3 ++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/test_programs/rebuild.sh b/test_programs/rebuild.sh
index 4733bad10c3..cfc6479febf 100755
--- a/test_programs/rebuild.sh
+++ b/test_programs/rebuild.sh
@@ -8,6 +8,14 @@ process_dir() {
     local current_dir=$2
     local dir_name=$(basename "$dir")
 
+    if [[ ! -f "$dir/Nargo.toml" ]]; then
+      # This directory isn't a proper test but just hold some stale build artifacts
+      # We then delete it and carry on.
+      rm -rf $dir
+      return 0
+    fi
+
+
     if [[ ! -d "$current_dir/acir_artifacts/$dir_name" ]]; then
       mkdir -p $current_dir/acir_artifacts/$dir_name
     fi
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 6c0709e7611..7c50e907dc9 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -102,7 +102,8 @@ pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError
     } else {
         // Otherwise print human-readable table.
         if !info_report.programs.is_empty() {
-            let mut program_table = table!([Fm->"Package", Fm->"Function", Fm->"Expression Width", Fm->"ACIR Opcodes"]);
+            let mut program_table =
+                table!([Fm->"Package", Fm->"Function", Fm->"Expression Width", Fm->"ACIR Opcodes"]);
 
             for program_info in info_report.programs {
                 let program_rows: Vec<Row> = program_info.into();

From 23a64779c7a7384b852bf1c51295f3eb77573130 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 23 May 2024 00:37:57 +0100
Subject: [PATCH 294/416] chore: reactivate gates report (#5084)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR reactivates the gates report workflow now that we don't have
access to the number of constraints through `nargo info`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/gates_report.yml            | 180 +++++++++---------
 .../brillig_slice_input/Nargo.toml            |   0
 .../brillig_slice_input/src/main.nr           |   0
 .../regression_4383/Nargo.toml                |   0
 .../regression_4383/src/main.nr               |   0
 .../regression_4436/Nargo.toml                |   0
 .../regression_4436/src/main.nr               |   0
 .../slice_init_with_complex_type/Nargo.toml   |   0
 .../slice_init_with_complex_type/Prover.toml  |   0
 .../slice_init_with_complex_type/src/main.nr  |   0
 test_programs/gates_report.sh                 |  39 ++--
 11 files changed, 113 insertions(+), 106 deletions(-)
 rename test_programs/{execution_success => compile_success_empty}/brillig_slice_input/Nargo.toml (100%)
 rename test_programs/{execution_success => compile_success_empty}/brillig_slice_input/src/main.nr (100%)
 rename test_programs/{execution_success => compile_success_empty}/regression_4383/Nargo.toml (100%)
 rename test_programs/{execution_success => compile_success_empty}/regression_4383/src/main.nr (100%)
 rename test_programs/{execution_success => compile_success_empty}/regression_4436/Nargo.toml (100%)
 rename test_programs/{execution_success => compile_success_empty}/regression_4436/src/main.nr (100%)
 rename test_programs/{execution_success => compile_success_empty}/slice_init_with_complex_type/Nargo.toml (100%)
 rename test_programs/{execution_success => compile_success_empty}/slice_init_with_complex_type/Prover.toml (100%)
 rename test_programs/{execution_success => compile_success_empty}/slice_init_with_complex_type/src/main.nr (100%)

diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
index 3d4bef1940e..0cc94a1a04d 100644
--- a/.github/workflows/gates_report.yml
+++ b/.github/workflows/gates_report.yml
@@ -1,88 +1,94 @@
-# name: Report gates diff
-
-# on:
-#   push:
-#     branches:
-#       - master
-#   pull_request:
-
-# jobs:
-#   build-nargo:
-#     runs-on: ubuntu-latest
-#     strategy:
-#       matrix:
-#         target: [x86_64-unknown-linux-gnu]
-
-#     steps:
-#       - name: Checkout Noir repo
-#         uses: actions/checkout@v4
-
-#       - name: Setup toolchain
-#         uses: dtolnay/rust-toolchain@1.74.1
-
-#       - uses: Swatinem/rust-cache@v2
-#         with:
-#           key: ${{ matrix.target }}
-#           cache-on-failure: true
-#           save-if: ${{ github.event_name != 'merge_group' }}
-
-#       - name: Build Nargo
-#         run: cargo build --package nargo_cli --release
-
-#       - name: Package artifacts
-#         run: |
-#           mkdir dist
-#           cp ./target/release/nargo ./dist/nargo
-#           7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
-
-#       - name: Upload artifact
-#         uses: actions/upload-artifact@v4
-#         with:
-#           name: nargo
-#           path: ./dist/*
-#           retention-days: 3
-
-
-#   compare_gas_reports:
-#     needs: [build-nargo]
-#     runs-on: ubuntu-latest
-#     permissions:
-#       pull-requests: write
-
-#     steps:
-#       - uses: actions/checkout@v4
-
-#       - name: Download nargo binary
-#         uses: actions/download-artifact@v4
-#         with:
-#           name: nargo
-#           path: ./nargo
-
-#       - name: Set nargo on PATH
-#         run: |
-#           nargo_binary="${{ github.workspace }}/nargo/nargo"
-#           chmod +x $nargo_binary
-#           echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
-#           export PATH="$PATH:$(dirname $nargo_binary)"
-#           nargo -V
-
-#       - name: Generate gates report
-#         working-directory: ./test_programs
-#         run: |
-#           ./gates_report.sh
-#           mv gates_report.json ../gates_report.json
+name: Report gates diff
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  build-nargo:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64-unknown-linux-gnu]
+
+    steps:
+      - name: Checkout Noir repo
+        uses: actions/checkout@v4
+
+      - name: Setup toolchain
+        uses: dtolnay/rust-toolchain@1.74.1
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
+          cache-on-failure: true
+          save-if: ${{ github.event_name != 'merge_group' }}
+
+      - name: Build Nargo
+        run: cargo build --package nargo_cli --release
+
+      - name: Package artifacts
+        run: |
+          mkdir dist
+          cp ./target/release/nargo ./dist/nargo
+          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: nargo
+          path: ./dist/*
+          retention-days: 3
+
+
+  compare_gates_reports:
+    needs: [build-nargo]
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install `bb`
+        run: |
+          ./scripts/install_bb.sh
+          echo "$HOME/.bb/" >> $GITHUB_PATH
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Generate gates report
+        working-directory: ./test_programs
+        run: |
+          ./rebuild.sh
+          ./gates_report.sh
+          mv gates_report.json ../gates_report.json
       
-#       - name: Compare gates reports
-#         id: gates_diff
-#         uses: vezenovm/noir-gates-diff@acf12797860f237117e15c0d6e08d64253af52b6
-#         with:
-#           report: gates_report.json
-#           summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
-
-#       - name: Add gates diff to sticky comment
-#         if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
-#         uses: marocchino/sticky-pull-request-comment@v2
-#         with:
-#           # delete the comment in case changes no longer impact circuit sizes
-#           delete: ${{ !steps.gates_diff.outputs.markdown }}
-#           message: ${{ steps.gates_diff.outputs.markdown }}
+      - name: Compare gates reports
+        id: gates_diff
+        uses: vezenovm/noir-gates-diff@acf12797860f237117e15c0d6e08d64253af52b6
+        with:
+          report: gates_report.json
+          summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
+
+      - name: Add gates diff to sticky comment
+        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          # delete the comment in case changes no longer impact circuit sizes
+          delete: ${{ !steps.gates_diff.outputs.markdown }}
+          message: ${{ steps.gates_diff.outputs.markdown }}
diff --git a/test_programs/execution_success/brillig_slice_input/Nargo.toml b/test_programs/compile_success_empty/brillig_slice_input/Nargo.toml
similarity index 100%
rename from test_programs/execution_success/brillig_slice_input/Nargo.toml
rename to test_programs/compile_success_empty/brillig_slice_input/Nargo.toml
diff --git a/test_programs/execution_success/brillig_slice_input/src/main.nr b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
similarity index 100%
rename from test_programs/execution_success/brillig_slice_input/src/main.nr
rename to test_programs/compile_success_empty/brillig_slice_input/src/main.nr
diff --git a/test_programs/execution_success/regression_4383/Nargo.toml b/test_programs/compile_success_empty/regression_4383/Nargo.toml
similarity index 100%
rename from test_programs/execution_success/regression_4383/Nargo.toml
rename to test_programs/compile_success_empty/regression_4383/Nargo.toml
diff --git a/test_programs/execution_success/regression_4383/src/main.nr b/test_programs/compile_success_empty/regression_4383/src/main.nr
similarity index 100%
rename from test_programs/execution_success/regression_4383/src/main.nr
rename to test_programs/compile_success_empty/regression_4383/src/main.nr
diff --git a/test_programs/execution_success/regression_4436/Nargo.toml b/test_programs/compile_success_empty/regression_4436/Nargo.toml
similarity index 100%
rename from test_programs/execution_success/regression_4436/Nargo.toml
rename to test_programs/compile_success_empty/regression_4436/Nargo.toml
diff --git a/test_programs/execution_success/regression_4436/src/main.nr b/test_programs/compile_success_empty/regression_4436/src/main.nr
similarity index 100%
rename from test_programs/execution_success/regression_4436/src/main.nr
rename to test_programs/compile_success_empty/regression_4436/src/main.nr
diff --git a/test_programs/execution_success/slice_init_with_complex_type/Nargo.toml b/test_programs/compile_success_empty/slice_init_with_complex_type/Nargo.toml
similarity index 100%
rename from test_programs/execution_success/slice_init_with_complex_type/Nargo.toml
rename to test_programs/compile_success_empty/slice_init_with_complex_type/Nargo.toml
diff --git a/test_programs/execution_success/slice_init_with_complex_type/Prover.toml b/test_programs/compile_success_empty/slice_init_with_complex_type/Prover.toml
similarity index 100%
rename from test_programs/execution_success/slice_init_with_complex_type/Prover.toml
rename to test_programs/compile_success_empty/slice_init_with_complex_type/Prover.toml
diff --git a/test_programs/execution_success/slice_init_with_complex_type/src/main.nr b/test_programs/compile_success_empty/slice_init_with_complex_type/src/main.nr
similarity index 100%
rename from test_programs/execution_success/slice_init_with_complex_type/src/main.nr
rename to test_programs/compile_success_empty/slice_init_with_complex_type/src/main.nr
diff --git a/test_programs/gates_report.sh b/test_programs/gates_report.sh
index 3b0b4d9e148..b33e81b037c 100755
--- a/test_programs/gates_report.sh
+++ b/test_programs/gates_report.sh
@@ -1,36 +1,37 @@
 #!/usr/bin/env bash
 set -e
 
+BACKEND=${BACKEND:-bb}
+
 # These tests are incompatible with gas reporting
 excluded_dirs=("workspace" "workspace_default_member" "double_verify_nested_proof")
 
-# These tests cause failures in CI with a stack overflow for some reason.
-ci_excluded_dirs=("eddsa")
-
 current_dir=$(pwd)
-base_path="$current_dir/execution_success"
-test_dirs=$(ls $base_path)
+artifacts_path="$current_dir/acir_artifacts"
+test_dirs=$(ls $artifacts_path)
 
-# We generate a Noir workspace which contains all of the test cases
-# This allows us to generate a gates report using `nargo info` for all of them at once.
+echo "{\"programs\": [" > gates_report.json
 
-echo "[workspace]" > Nargo.toml
-echo "members = [" >> Nargo.toml
+# Bound for checking where to place last parentheses 
+NUM_ARTIFACTS=$(ls -1q "$artifacts_path" | wc -l)
 
-for dir in $test_dirs; do
-    if [[ " ${excluded_dirs[@]} " =~ " ${dir} " ]]; then
-      continue
-    fi
+ITER="1"
+for pathname in $test_dirs; do    
+    ARTIFACT_NAME=$(basename "$pathname")
+
+    GATES_INFO=$($BACKEND gates -b "$artifacts_path/$ARTIFACT_NAME/target/program.json")
+    MAIN_FUNCTION_INFO=$(echo $GATES_INFO | jq -r '.functions[0] | .name = "main"')
+    echo "{\"package_name\": \"$ARTIFACT_NAME\", \"functions\": [$MAIN_FUNCTION_INFO]" >> gates_report.json
 
-    if [[ ${CI-false} = "true" ]] && [[ " ${ci_excluded_dirs[@]} " =~ " ${dir} " ]]; then
-      continue
+    if (($ITER == $NUM_ARTIFACTS)); then
+        echo "}" >> gates_report.json
+    else 
+        echo "}, " >> gates_report.json
     fi
 
-    echo "  \"execution_success/$dir\"," >> Nargo.toml
+    ITER=$(( $ITER + 1 ))
 done
 
-echo "]" >> Nargo.toml
+echo "]}" >> gates_report.json 
 
-nargo info --json > gates_report.json
 
-rm Nargo.toml

From 2b4755c2b57460d5eb839ee835f8c9acd5773a7c Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 23 May 2024 14:14:43 +0100
Subject: [PATCH 295/416] fix: Apply self type from generic trait constraint
 before instantiating identifiers (#5087)

# Description

## Problem\*

Resolves #5063

## Summary\*

After the turbofish PRs we want the ability to instantiate a variable
from a generic trait. This was possible but it required a redundant type
annotiation like such (assume `H` has been specified with a `where`
clause):
```rust
let hasher: H = H::default()
```
Similarly to trait generics, we now add type bindings from a trait
constraint if the trait impl is assumed to exist.
We now can just do:
```rust
let hasher = H::default()
```

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/type_check/expr.rs   | 12 +++++++++++-
 compiler/noirc_frontend/src/tests.rs                 |  4 ++--
 noir_stdlib/src/eddsa.nr                             |  2 +-
 .../turbofish_call_func_diff_types/src/main.nr       |  4 +---
 4 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index abff466e1d5..9a54e76b8a4 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -371,7 +371,7 @@ impl<'interner> TypeChecker<'interner> {
         // We need to do this first since otherwise instantiating the type below
         // will replace each trait generic with a fresh type variable, rather than
         // the type used in the trait constraint (if it exists). See #4088.
-        if let ImplKind::TraitMethod(_, constraint, _) = &ident.impl_kind {
+        if let ImplKind::TraitMethod(_, constraint, assumed) = &ident.impl_kind {
             let the_trait = self.interner.get_trait(constraint.trait_id);
             assert_eq!(the_trait.generics.len(), constraint.trait_generics.len());
 
@@ -381,6 +381,16 @@ impl<'interner> TypeChecker<'interner> {
                     bindings.insert(param.id(), (param.clone(), arg.clone()));
                 }
             }
+
+            // If the trait impl is already assumed to exist we should add any type bindings for `Self`.
+            // Otherwise `self` will be replaced with a fresh type variable, which will require the user
+            // to specify a redundant type annotation.
+            if *assumed {
+                bindings.insert(
+                    the_trait.self_type_typevar_id,
+                    (the_trait.self_type_typevar.clone(), constraint.typ.clone()),
+                );
+            }
         }
 
         // An identifiers type may be forall-quantified in the case of generic functions.
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 7bf5655486b..bd81752c046 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1430,14 +1430,14 @@ fn specify_method_types_with_turbofish() {
         }
         
         impl<T> Foo<T> {
-            fn generic_method<U>(_self: Self) where U: Default {
+            fn generic_method<U>(_self: Self) -> U where U: Default {
                 U::default()
             }
         }
         
         fn main() {
             let foo: Foo<Field> = Foo { inner: 1 };
-            foo.generic_method::<Field>();
+            let _ = foo.generic_method::<Field>();
         }
     "#;
     let errors = get_program_errors(src);
diff --git a/noir_stdlib/src/eddsa.nr b/noir_stdlib/src/eddsa.nr
index 1ab0158af8f..337969be90e 100644
--- a/noir_stdlib/src/eddsa.nr
+++ b/noir_stdlib/src/eddsa.nr
@@ -45,7 +45,7 @@ where H: Hasher + Default {
     // Ensure S < Subgroup Order
     assert(signature_s.lt(bjj.suborder));
     // Calculate the h = H(R, A, msg)
-    let mut hasher: H = H::default();
+    let mut hasher = H::default();
     hasher.write(signature_r8_x);
     hasher.write(signature_r8_y);
     hasher.write(pub_key_x);
diff --git a/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr b/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
index 709a694e77b..b880d3ae047 100644
--- a/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
+++ b/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
@@ -23,9 +23,7 @@ fn main(x: Field, y: pub Field) {
 
 fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
     // Check that we can call a trait method instead of a trait implementation
-    // TODO(https://github.com/noir-lang/noir/issues/5063): Need to remove the need for this type annotation
-    // Curently, without the annotation we will get `Expression type is ambiguous` when trying to use the `hasher`
-    let mut hasher: H = H::default();
+    let mut hasher = H::default();
     // Regression that the object is converted to a mutable reference type `&mut _`.
     // Otherwise will see `Expected type &mut _, found type H`.
     // Then we need to make sure to also auto dereference later in the type checking process

From 86fd0ac4e6dd168227de6b8c97ed08da89e58a89 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 23 May 2024 22:18:48 +0100
Subject: [PATCH 296/416] chore: Move turbofish changes to the elaborator
 (#5094)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Moving https://github.com/noir-lang/noir/pull/3542,
https://github.com/noir-lang/noir/pull/5041, and
https://github.com/noir-lang/noir/pull/5087 to the elaborator

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../src/elaborator/expressions.rs             | 33 ++++++---
 .../noirc_frontend/src/elaborator/patterns.rs | 70 +++++++++++++++++--
 .../noirc_frontend/src/hir/type_check/expr.rs |  3 +-
 3 files changed, 88 insertions(+), 18 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 75c95c06d09..f1631286336 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -194,7 +194,7 @@ impl<'context> Elaborator<'context> {
                 let expr_id = self.interner.push_expr(ident);
                 self.interner.push_expr_location(expr_id, call_expr_span, self.file);
                 let ident = old_value.ident.clone();
-                let typ = self.type_check_variable(ident, expr_id);
+                let typ = self.type_check_variable(ident, expr_id, None);
                 self.interner.push_expr_type(expr_id, typ.clone());
                 capture_types.push(typ);
                 fmt_str_idents.push(expr_id);
@@ -291,16 +291,25 @@ impl<'context> Elaborator<'context> {
             Some(method_ref) => {
                 // Automatically add `&mut` if the method expects a mutable reference and
                 // the object is not already one.
-                if let HirMethodReference::FuncId(func_id) = &method_ref {
-                    if *func_id != FuncId::dummy_id() {
-                        let function_type = self.interner.function_meta(func_id).typ.clone();
-
-                        self.try_add_mutable_reference_to_object(
-                            &function_type,
-                            &mut object_type,
-                            &mut object,
-                        );
+                let func_id = match &method_ref {
+                    HirMethodReference::FuncId(func_id) => *func_id,
+                    HirMethodReference::TraitMethodId(method_id, _) => {
+                        let id = self.interner.trait_method_id(*method_id);
+                        let definition = self.interner.definition(id);
+                        let DefinitionKind::Function(func_id) = definition.kind else {
+                            unreachable!("Expected trait function to be a DefinitionKind::Function")
+                        };
+                        func_id
                     }
+                };
+
+                if func_id != FuncId::dummy_id() {
+                    let function_type = self.interner.function_meta(&func_id).typ.clone();
+                    self.try_add_mutable_reference_to_object(
+                        &function_type,
+                        &mut object_type,
+                        &mut object,
+                    );
                 }
 
                 // These arguments will be given to the desugared function call.
@@ -322,6 +331,7 @@ impl<'context> Elaborator<'context> {
                 let generics = method_call.generics.map(|option_inner| {
                     option_inner.into_iter().map(|generic| self.resolve_type(generic)).collect()
                 });
+                let turbofish_generics = generics.clone();
                 let method_call =
                     HirMethodCallExpression { method, object, arguments, location, generics };
 
@@ -335,7 +345,8 @@ impl<'context> Elaborator<'context> {
                     self.interner,
                 );
 
-                let func_type = self.type_check_variable(function_name, function_id);
+                let func_type =
+                    self.type_check_variable(function_name, function_id, turbofish_generics);
 
                 // Type check the new call now that it has been changed from a method call
                 // to a function call. This way we avoid duplicating code.
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 810e1b90743..17c11b88f4a 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -5,6 +5,7 @@ use rustc_hash::FxHashSet as HashSet;
 use crate::{
     ast::ERROR_IDENT,
     hir::{
+        def_collector::dc_crate::CompilationError,
         resolution::errors::ResolverError,
         type_check::{Source, TypeCheckError},
     },
@@ -330,9 +331,9 @@ impl<'context> Elaborator<'context> {
     ) -> (ExprId, Type) {
         let span = variable.span;
         let expr = self.resolve_variable(variable);
-        let id = self.interner.push_expr(HirExpression::Ident(expr.clone(), generics));
+        let id = self.interner.push_expr(HirExpression::Ident(expr.clone(), generics.clone()));
         self.interner.push_expr_location(id, span, self.file);
-        let typ = self.type_check_variable(expr, id);
+        let typ = self.type_check_variable(expr, id, generics);
         self.interner.push_expr_type(id, typ.clone());
         (id, typ)
     }
@@ -384,14 +385,19 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub(super) fn type_check_variable(&mut self, ident: HirIdent, expr_id: ExprId) -> Type {
+    pub(super) fn type_check_variable(
+        &mut self,
+        ident: HirIdent,
+        expr_id: ExprId,
+        generics: Option<Vec<Type>>,
+    ) -> Type {
         let mut bindings = TypeBindings::new();
 
         // Add type bindings from any constraints that were used.
         // We need to do this first since otherwise instantiating the type below
         // will replace each trait generic with a fresh type variable, rather than
         // the type used in the trait constraint (if it exists). See #4088.
-        if let ImplKind::TraitMethod(_, constraint, _) = &ident.impl_kind {
+        if let ImplKind::TraitMethod(_, constraint, assumed) = &ident.impl_kind {
             let the_trait = self.interner.get_trait(constraint.trait_id);
             assert_eq!(the_trait.generics.len(), constraint.trait_generics.len());
 
@@ -401,6 +407,16 @@ impl<'context> Elaborator<'context> {
                     bindings.insert(param.id(), (param.clone(), arg.clone()));
                 }
             }
+
+            // If the trait impl is already assumed to exist we should add any type bindings for `Self`.
+            // Otherwise `self` will be replaced with a fresh type variable, which will require the user
+            // to specify a redundant type annotation.
+            if *assumed {
+                bindings.insert(
+                    the_trait.self_type_typevar_id,
+                    (the_trait.self_type_typevar.clone(), constraint.typ.clone()),
+                );
+            }
         }
 
         // An identifiers type may be forall-quantified in the case of generic functions.
@@ -409,10 +425,21 @@ impl<'context> Elaborator<'context> {
         // variable to handle generic functions.
         let t = self.interner.id_type_substitute_trait_as_type(ident.id);
 
+        let definition = self.interner.try_definition(ident.id);
+        let function_generic_count = definition.map_or(0, |definition| match &definition.kind {
+            DefinitionKind::Function(function) => {
+                self.interner.function_modifiers(function).generic_count
+            }
+            _ => 0,
+        });
+
+        let span = self.interner.expr_span(&expr_id);
+        let location = self.interner.expr_location(&expr_id);
         // This instantiates a trait's generics as well which need to be set
         // when the constraint below is later solved for when the function is
         // finished. How to link the two?
-        let (typ, bindings) = t.instantiate_with_bindings(bindings, self.interner);
+        let (typ, bindings) =
+            self.instantiate(t, bindings, generics, function_generic_count, span, location);
 
         // Push any trait constraints required by this definition to the context
         // to be checked later when the type of this variable is further constrained.
@@ -447,6 +474,39 @@ impl<'context> Elaborator<'context> {
         typ
     }
 
+    fn instantiate(
+        &mut self,
+        typ: Type,
+        bindings: TypeBindings,
+        turbofish_generics: Option<Vec<Type>>,
+        function_generic_count: usize,
+        span: Span,
+        location: Location,
+    ) -> (Type, TypeBindings) {
+        match turbofish_generics {
+            Some(turbofish_generics) => {
+                if turbofish_generics.len() != function_generic_count {
+                    let type_check_err = TypeCheckError::IncorrectTurbofishGenericCount {
+                        expected_count: function_generic_count,
+                        actual_count: turbofish_generics.len(),
+                        span,
+                    };
+                    self.errors.push((CompilationError::TypeError(type_check_err), location.file));
+                    typ.instantiate_with_bindings(bindings, self.interner)
+                } else {
+                    // Fetch the count of any implicit generics on the function, such as
+                    // for a method within a generic impl.
+                    let implicit_generic_count = match &typ {
+                        Type::Forall(generics, _) => generics.len() - function_generic_count,
+                        _ => 0,
+                    };
+                    typ.instantiate_with(turbofish_generics, self.interner, implicit_generic_count)
+                }
+            }
+            None => typ.instantiate_with_bindings(bindings, self.interner),
+        }
+    }
+
     fn get_ident_from_path(&mut self, path: Path) -> (HirIdent, usize) {
         let location = Location::new(path.span(), self.file);
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 9a54e76b8a4..336c1cedbb6 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -399,8 +399,6 @@ impl<'interner> TypeChecker<'interner> {
         // variable to handle generic functions.
         let t = self.interner.id_type_substitute_trait_as_type(ident.id);
 
-        let span = self.interner.expr_span(expr_id);
-
         let definition = self.interner.try_definition(ident.id);
         let function_generic_count = definition.map_or(0, |definition| match &definition.kind {
             DefinitionKind::Function(function) => {
@@ -409,6 +407,7 @@ impl<'interner> TypeChecker<'interner> {
             _ => 0,
         });
 
+        let span = self.interner.expr_span(expr_id);
         // This instantiates a trait's generics as well which need to be set
         // when the constraint below is later solved for when the function is
         // finished. How to link the two?

From 281ebf26e4cd16daf361938de505697f8d5fbd5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Fri, 24 May 2024 16:44:32 +0200
Subject: [PATCH 297/416] feat: Add intrinsic to get if running inside an
 unconstrained context (#5098)

# Description

## Problem\*

Currently, when creating a regular (not marked with unconstrained)
function, it can end up running in both a constrained and unconstrained
context.

## Summary\*

This intrinsic is resolved at compile time a provides a way for
developers to dispatch to different implementations in library code for
constrained and unconstrained context. This intrinsic has been used in
stdlib's field comparison code as demonstration.

## Additional Context

It's very typical for the constrained version of a calculation to take a
hint of a computed value and verify it. However, in the unconstrained
version of that calculation we just need to compute the value, there is
no point in verifying what we just did. This intrinsic provides a tool
for devs to optimize a function for unconstrained removing these
verifications.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 compiler/noirc_evaluator/src/ssa.rs           |   1 +
 .../noirc_evaluator/src/ssa/ir/instruction.rs |   6 +-
 .../src/ssa/ir/instruction/call.rs            |   1 +
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |   1 +
 .../src/ssa/opt/remove_enable_side_effects.rs |   3 +-
 .../src/ssa/opt/remove_if_else.rs             |   3 +-
 .../src/ssa/opt/resolve_is_unconstrained.rs   |  56 ++++++
 .../noir/standard_library/is_unconstrained.md |  59 ++++++
 noir_stdlib/src/field/bn254.nr                | 183 +++++++++++-------
 noir_stdlib/src/lib.nr                        |   2 +
 noir_stdlib/src/runtime.nr                    |   2 +
 .../is_unconstrained/Nargo.toml               |   6 +
 .../is_unconstrained/Prover.toml              |   1 +
 .../is_unconstrained/src/main.nr              |  14 ++
 tooling/debugger/ignored-tests.txt            |   1 +
 15 files changed, 263 insertions(+), 76 deletions(-)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs
 create mode 100644 docs/docs/noir/standard_library/is_unconstrained.md
 create mode 100644 noir_stdlib/src/runtime.nr
 create mode 100644 test_programs/execution_success/is_unconstrained/Nargo.toml
 create mode 100644 test_programs/execution_success/is_unconstrained/Prover.toml
 create mode 100644 test_programs/execution_success/is_unconstrained/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 69e5f6ddfcc..c2fe7878bf8 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -56,6 +56,7 @@ pub(crate) fn optimize_into_acir(
         .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
         .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
         .run_pass(Ssa::inline_functions, "After Inlining:")
+        .run_pass(Ssa::resolve_is_unconstrained, "After Resolving IsUnconstrained:")
         // Run mem2reg with the CFG separated into blocks
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
         .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index f136d3c5fb2..93ea703721f 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -65,6 +65,7 @@ pub(crate) enum Intrinsic {
     FromField,
     AsField,
     AsWitness,
+    IsUnconstrained,
 }
 
 impl std::fmt::Display for Intrinsic {
@@ -89,6 +90,7 @@ impl std::fmt::Display for Intrinsic {
             Intrinsic::FromField => write!(f, "from_field"),
             Intrinsic::AsField => write!(f, "as_field"),
             Intrinsic::AsWitness => write!(f, "as_witness"),
+            Intrinsic::IsUnconstrained => write!(f, "is_unconstrained"),
         }
     }
 }
@@ -116,7 +118,8 @@ impl Intrinsic {
             | Intrinsic::SliceRemove
             | Intrinsic::StrAsBytes
             | Intrinsic::FromField
-            | Intrinsic::AsField => false,
+            | Intrinsic::AsField
+            | Intrinsic::IsUnconstrained => false,
 
             // Some black box functions have side-effects
             Intrinsic::BlackBox(func) => matches!(func, BlackBoxFunc::RecursiveAggregation),
@@ -145,6 +148,7 @@ impl Intrinsic {
             "from_field" => Some(Intrinsic::FromField),
             "as_field" => Some(Intrinsic::AsField),
             "as_witness" => Some(Intrinsic::AsWitness),
+            "is_unconstrained" => Some(Intrinsic::IsUnconstrained),
             other => BlackBoxFunc::lookup(other).map(Intrinsic::BlackBox),
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 8e320de9337..8f57d9de368 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -294,6 +294,7 @@ pub(super) fn simplify_call(
             SimplifyResult::SimplifiedToInstruction(instruction)
         }
         Intrinsic::AsWitness => SimplifyResult::None,
+        Intrinsic::IsUnconstrained => SimplifyResult::None,
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index 27536d59ea5..f6c3f022bfc 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -17,5 +17,6 @@ mod rc;
 mod remove_bit_shifts;
 mod remove_enable_side_effects;
 mod remove_if_else;
+mod resolve_is_unconstrained;
 mod simplify_cfg;
 mod unrolling;
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 9309652d508..464faa57323 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -158,7 +158,8 @@ impl Context {
                     | Intrinsic::FromField
                     | Intrinsic::AsField
                     | Intrinsic::AsSlice
-                    | Intrinsic::AsWitness => false,
+                    | Intrinsic::AsWitness
+                    | Intrinsic::IsUnconstrained => false,
                 },
 
                 // We must assume that functions contain a side effect as we cannot inspect more deeply.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
index 3d2b5142219..91b455dbf29 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -232,6 +232,7 @@ fn slice_capacity_change(
         | Intrinsic::BlackBox(_)
         | Intrinsic::FromField
         | Intrinsic::AsField
-        | Intrinsic::AsWitness => SizeChange::None,
+        | Intrinsic::AsWitness
+        | Intrinsic::IsUnconstrained => SizeChange::None,
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs b/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs
new file mode 100644
index 00000000000..2c9e33ae528
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs
@@ -0,0 +1,56 @@
+use crate::ssa::{
+    ir::{
+        function::{Function, RuntimeType},
+        instruction::{Instruction, Intrinsic},
+        types::Type,
+        value::Value,
+    },
+    ssa_gen::Ssa,
+};
+use acvm::FieldElement;
+use fxhash::FxHashSet as HashSet;
+
+impl Ssa {
+    /// An SSA pass to find any calls to `Intrinsic::IsUnconstrained` and replacing any uses of the result of the intrinsic
+    /// with the resolved boolean value.
+    /// Note that this pass must run after the pass that does runtime separation, since in SSA generation an ACIR function can end up targeting brillig.
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn resolve_is_unconstrained(mut self) -> Self {
+        for func in self.functions.values_mut() {
+            replace_is_unconstrained_result(func);
+        }
+        self
+    }
+}
+
+fn replace_is_unconstrained_result(func: &mut Function) {
+    let mut is_unconstrained_calls = HashSet::default();
+    // Collect all calls to is_unconstrained
+    for block_id in func.reachable_blocks() {
+        for &instruction_id in func.dfg[block_id].instructions() {
+            let target_func = match &func.dfg[instruction_id] {
+                Instruction::Call { func, .. } => *func,
+                _ => continue,
+            };
+
+            if let Value::Intrinsic(Intrinsic::IsUnconstrained) = &func.dfg[target_func] {
+                is_unconstrained_calls.insert(instruction_id);
+            }
+        }
+    }
+
+    for instruction_id in is_unconstrained_calls {
+        let call_returns = func.dfg.instruction_results(instruction_id);
+        let original_return_id = call_returns[0];
+
+        // We replace the result with a fresh id. This will be unused, so the DIE pass will remove the leftover intrinsic call.
+        func.dfg.replace_result(instruction_id, original_return_id);
+
+        let is_within_unconstrained = func.dfg.make_constant(
+            FieldElement::from(matches!(func.runtime(), RuntimeType::Brillig)),
+            Type::bool(),
+        );
+        // Replace all uses of the original return value with the constant
+        func.dfg.set_value_from_id(original_return_id, is_within_unconstrained);
+    }
+}
diff --git a/docs/docs/noir/standard_library/is_unconstrained.md b/docs/docs/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..bb157e719dc
--- /dev/null
+++ b/docs/docs/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,59 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
\ No newline at end of file
diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index 2e82d9e7c23..bcdc23f80dc 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -1,11 +1,13 @@
+use crate::runtime::is_unconstrained;
+
 // The low and high decomposition of the field modulus
 global PLO: Field = 53438638232309528389504892708671455233;
 global PHI: Field = 64323764613183177041862057485226039389;
 
 global TWO_POW_128: Field = 0x100000000000000000000000000000000;
 
-/// A hint for decomposing a single field into two 16 byte fields.
-unconstrained fn decompose_unsafe(x: Field) -> (Field, Field) {
+// Decomposes a single field into two 16 byte fields.
+fn compute_decomposition(x: Field) -> (Field, Field) {
     let x_bytes = x.to_le_bytes(32);
 
     let mut low: Field = 0;
@@ -21,37 +23,11 @@ unconstrained fn decompose_unsafe(x: Field) -> (Field, Field) {
     (low, high)
 }
 
-// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
-fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
-    let (alo, ahi) = a;
-    let (blo, bhi) = b;
-    let borrow = lte_unsafe_16(alo, blo);
-
-    let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
-    let rhi = ahi - bhi - (borrow as Field);
-
-    rlo.assert_max_bit_size(128);
-    rhi.assert_max_bit_size(128);
-}
-
-/// Decompose a single field into two 16 byte fields.
-pub fn decompose(x: Field) -> (Field, Field) {
-    // Take hints of the decomposition
-    let (xlo, xhi) = decompose_unsafe(x);
-
-    // Range check the limbs
-    xlo.assert_max_bit_size(128);
-    xhi.assert_max_bit_size(128);
-
-    // Check that the decomposition is correct
-    assert_eq(x, xlo + TWO_POW_128 * xhi);
-
-    // Assert that the decomposition of P is greater than the decomposition of x
-    assert_gt_limbs((PLO, PHI), (xlo, xhi));
-    (xlo, xhi)
+unconstrained fn decompose_hint(x: Field) -> (Field, Field) {
+    compute_decomposition(x)
 }
 
-fn lt_unsafe_internal(x: Field, y: Field, num_bytes: u32) -> bool {
+fn compute_lt(x: Field, y: Field, num_bytes: u32) -> bool {
     let x_bytes = x.to_le_radix(256, num_bytes);
     let y_bytes = y.to_le_radix(256, num_bytes);
     let mut x_is_lt = false;
@@ -70,29 +46,67 @@ fn lt_unsafe_internal(x: Field, y: Field, num_bytes: u32) -> bool {
     x_is_lt
 }
 
-fn lte_unsafe_internal(x: Field, y: Field, num_bytes: u32) -> bool {
+fn compute_lte(x: Field, y: Field, num_bytes: u32) -> bool {
     if x == y {
         true
     } else {
-        lt_unsafe_internal(x, y, num_bytes)
+        compute_lt(x, y, num_bytes)
     }
 }
 
-unconstrained fn lt_unsafe_32(x: Field, y: Field) -> bool {
-    lt_unsafe_internal(x, y, 32)
+unconstrained fn lt_32_hint(x: Field, y: Field) -> bool {
+    compute_lt(x, y, 32)
 }
 
-unconstrained fn lte_unsafe_16(x: Field, y: Field) -> bool {
-    lte_unsafe_internal(x, y, 16)
+unconstrained fn lte_16_hint(x: Field, y: Field) -> bool {
+    compute_lte(x, y, 16)
+}
+
+// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
+fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
+    let (alo, ahi) = a;
+    let (blo, bhi) = b;
+    let borrow = lte_16_hint(alo, blo);
+
+    let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
+    let rhi = ahi - bhi - (borrow as Field);
+
+    rlo.assert_max_bit_size(128);
+    rhi.assert_max_bit_size(128);
+}
+
+/// Decompose a single field into two 16 byte fields.
+pub fn decompose(x: Field) -> (Field, Field) {
+    if is_unconstrained() {
+        compute_decomposition(x)
+    } else {
+        // Take hints of the decomposition
+        let (xlo, xhi) = decompose_hint(x);
+
+        // Range check the limbs
+        xlo.assert_max_bit_size(128);
+        xhi.assert_max_bit_size(128);
+
+        // Check that the decomposition is correct
+        assert_eq(x, xlo + TWO_POW_128 * xhi);
+
+        // Assert that the decomposition of P is greater than the decomposition of x
+        assert_gt_limbs((PLO, PHI), (xlo, xhi));
+        (xlo, xhi)
+    }
 }
 
 pub fn assert_gt(a: Field, b: Field) {
-    // Decompose a and b
-    let a_limbs = decompose(a);
-    let b_limbs = decompose(b);
+    if is_unconstrained() {
+        assert(compute_lt(b, a, 32));
+    } else {
+        // Decompose a and b
+        let a_limbs = decompose(a);
+        let b_limbs = decompose(b);
 
-    // Assert that a_limbs is greater than b_limbs
-    assert_gt_limbs(a_limbs, b_limbs)
+        // Assert that a_limbs is greater than b_limbs
+        assert_gt_limbs(a_limbs, b_limbs)
+    }
 }
 
 pub fn assert_lt(a: Field, b: Field) {
@@ -100,14 +114,19 @@ pub fn assert_lt(a: Field, b: Field) {
 }
 
 pub fn gt(a: Field, b: Field) -> bool {
-    if a == b {
-        false
-    } else if lt_unsafe_32(a, b) {
-        assert_gt(b, a);
+    if is_unconstrained() {
+        compute_lt(b, a, 32)
+    } else if a == b {
         false
-    } else {
-        assert_gt(a, b);
-        true
+    } else  {
+        // Take a hint of the comparison and verify it
+        if lt_32_hint(a, b) {
+            assert_gt(b, a);
+            false
+        } else {
+            assert_gt(a, b);
+            true
+        }
     }
 }
 
@@ -117,44 +136,41 @@ pub fn lt(a: Field, b: Field) -> bool {
 
 mod tests {
     // TODO: Allow imports from "super"
-    use crate::field::bn254::{
-        decompose_unsafe, decompose, lt_unsafe_internal, assert_gt, gt, lt, TWO_POW_128,
-        lte_unsafe_internal, PLO, PHI
-    };
+    use crate::field::bn254::{decompose_hint, decompose, compute_lt, assert_gt, gt, lt, TWO_POW_128, compute_lte, PLO, PHI};
 
     #[test]
-    fn check_decompose_unsafe() {
-        assert_eq(decompose_unsafe(TWO_POW_128), (0, 1));
-        assert_eq(decompose_unsafe(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
-        assert_eq(decompose_unsafe(0x1234567890), (0x1234567890, 0));
+    fn check_decompose() {
+        assert_eq(decompose(TWO_POW_128), (0, 1));
+        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
+        assert_eq(decompose(0x1234567890), (0x1234567890, 0));
     }
 
     #[test]
-    fn check_decompose() {
+    unconstrained fn check_decompose_unconstrained() {
         assert_eq(decompose(TWO_POW_128), (0, 1));
         assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
         assert_eq(decompose(0x1234567890), (0x1234567890, 0));
     }
 
     #[test]
-    fn check_lt_unsafe() {
-        assert(lt_unsafe_internal(0, 1, 16));
-        assert(lt_unsafe_internal(0, 0x100, 16));
-        assert(lt_unsafe_internal(0x100, TWO_POW_128 - 1, 16));
-        assert(!lt_unsafe_internal(0, TWO_POW_128, 16));
+    fn check_compute_lt() {
+        assert(compute_lt(0, 1, 16));
+        assert(compute_lt(0, 0x100, 16));
+        assert(compute_lt(0x100, TWO_POW_128 - 1, 16));
+        assert(!compute_lt(0, TWO_POW_128, 16));
     }
 
     #[test]
-    fn check_lte_unsafe() {
-        assert(lte_unsafe_internal(0, 1, 16));
-        assert(lte_unsafe_internal(0, 0x100, 16));
-        assert(lte_unsafe_internal(0x100, TWO_POW_128 - 1, 16));
-        assert(!lte_unsafe_internal(0, TWO_POW_128, 16));
-
-        assert(lte_unsafe_internal(0, 0, 16));
-        assert(lte_unsafe_internal(0x100, 0x100, 16));
-        assert(lte_unsafe_internal(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
-        assert(lte_unsafe_internal(TWO_POW_128, TWO_POW_128, 16));
+    fn check_compute_lte() {
+        assert(compute_lte(0, 1, 16));
+        assert(compute_lte(0, 0x100, 16));
+        assert(compute_lte(0x100, TWO_POW_128 - 1, 16));
+        assert(!compute_lte(0, TWO_POW_128, 16));
+
+        assert(compute_lte(0, 0, 16));
+        assert(compute_lte(0x100, 0x100, 16));
+        assert(compute_lte(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
+        assert(compute_lte(TWO_POW_128, TWO_POW_128, 16));
     }
 
     #[test]
@@ -166,6 +182,15 @@ mod tests {
         assert_gt(0 - 1, 0);
     }
 
+    #[test]
+    unconstrained fn check_assert_gt_unconstrained() {
+        assert_gt(1, 0);
+        assert_gt(0x100, 0);
+        assert_gt((0 - 1), (0 - 2));
+        assert_gt(TWO_POW_128, 0);
+        assert_gt(0 - 1, 0);
+    }
+
     #[test]
     fn check_gt() {
         assert(gt(1, 0));
@@ -178,6 +203,18 @@ mod tests {
         assert(!gt(0 - 2, 0 - 1));
     }
 
+    #[test]
+    unconstrained fn check_gt_unconstrained() {
+        assert(gt(1, 0));
+        assert(gt(0x100, 0));
+        assert(gt((0 - 1), (0 - 2)));
+        assert(gt(TWO_POW_128, 0));
+        assert(!gt(0, 0));
+        assert(!gt(0, 0x100));
+        assert(gt(0 - 1, 0 - 2));
+        assert(!gt(0 - 2, 0 - 1));
+    }
+
     #[test]
     fn check_plo_phi() {
         assert_eq(PLO + PHI * TWO_POW_128, 0);
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index f11b21003ad..ad47171fa46 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -25,6 +25,7 @@ mod default;
 mod prelude;
 mod uint128;
 mod bigint;
+mod runtime;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
@@ -70,3 +71,4 @@ pub fn wrapping_mul<T>(x: T, y: T) -> T {
 
 #[builtin(as_witness)]
 pub fn as_witness(x: Field) {}
+
diff --git a/noir_stdlib/src/runtime.nr b/noir_stdlib/src/runtime.nr
new file mode 100644
index 00000000000..c075107cd52
--- /dev/null
+++ b/noir_stdlib/src/runtime.nr
@@ -0,0 +1,2 @@
+#[builtin(is_unconstrained)]
+pub fn is_unconstrained() -> bool {}
diff --git a/test_programs/execution_success/is_unconstrained/Nargo.toml b/test_programs/execution_success/is_unconstrained/Nargo.toml
new file mode 100644
index 00000000000..deef68c7f72
--- /dev/null
+++ b/test_programs/execution_success/is_unconstrained/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "is_unconstrained"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/is_unconstrained/Prover.toml b/test_programs/execution_success/is_unconstrained/Prover.toml
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/test_programs/execution_success/is_unconstrained/Prover.toml
@@ -0,0 +1 @@
+
diff --git a/test_programs/execution_success/is_unconstrained/src/main.nr b/test_programs/execution_success/is_unconstrained/src/main.nr
new file mode 100644
index 00000000000..af40af1029f
--- /dev/null
+++ b/test_programs/execution_success/is_unconstrained/src/main.nr
@@ -0,0 +1,14 @@
+use dep::std::runtime::is_unconstrained;
+
+fn check(should_be_unconstrained: bool) {
+    assert_eq(should_be_unconstrained, is_unconstrained());
+}
+
+unconstrained fn unconstrained_intermediate() {
+    check(true);
+}
+
+fn main() {
+    unconstrained_intermediate();
+    check(false);
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index cda26169421..a6d3c9a3a94 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -25,3 +25,4 @@ fold_fibonacci
 fold_complex_outputs
 slice_init_with_complex_type
 hashmap
+is_unconstrained
\ No newline at end of file

From 9db206e98555ccd8089256144ef39ed43bd981b6 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Fri, 24 May 2024 18:03:43 +0200
Subject: [PATCH 298/416] chore: Avoid creating witness for simple
 multiplications (#5100)

# Description

## Problem\*

Related to  #4629

## Summary\*
Do not create a witness when multiplying a witness (or an affine
transformation of a witness) with an expression of degree 1.


## Additional Context
This PR does NOT fix the issue #4629, but it should help reducing the
overall gates number.
The arithmetic expressions resulting from the multiplication should not
explode in width since I only consider multiplication with a witness (or
'affine witness').

## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../acvm/src/compiler/transformers/csat.rs    |  4 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 41 ++++++++++++++++---
 2 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/acvm-repo/acvm/src/compiler/transformers/csat.rs b/acvm-repo/acvm/src/compiler/transformers/csat.rs
index 9e2e3091c74..12a37e3e37a 100644
--- a/acvm-repo/acvm/src/compiler/transformers/csat.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/csat.rs
@@ -210,16 +210,16 @@ impl CSatTransformer {
                             }
                         } else {
                             // No more usable elements left in the old opcode
-                            opcode.linear_combinations = remaining_linear_terms;
                             break;
                         }
                     }
+                    opcode.linear_combinations.extend(remaining_linear_terms);
+
                     // Constraint this intermediate_opcode to be equal to the temp variable by adding it into the IndexMap
                     // We need a unique name for our intermediate variable
                     // XXX: Another optimization, which could be applied in another algorithm
                     // If two opcodes have a large fan-in/out and they share a few common terms, then we should create intermediate variables for them
                     // Do some sort of subset matching algorithm for this on the terms of the polynomial
-
                     let inter_var = Self::get_or_create_intermediate_vars(
                         intermediate_variables,
                         intermediate_opcode,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 90cdbb650c2..b6e88a8d4b0 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -614,13 +614,44 @@ impl AcirContext {
                 expr.push_multiplication_term(FieldElement::one(), lhs_witness, rhs_witness);
                 self.add_data(AcirVarData::Expr(expr))
             }
-            (
-                AcirVarData::Expr(_) | AcirVarData::Witness(_),
-                AcirVarData::Expr(_) | AcirVarData::Witness(_),
-            ) => {
+            (AcirVarData::Expr(expression), AcirVarData::Witness(witness))
+            | (AcirVarData::Witness(witness), AcirVarData::Expr(expression))
+                if expression.is_linear() =>
+            {
+                let mut expr = Expression::default();
+                for term in expression.linear_combinations.iter() {
+                    expr.push_multiplication_term(term.0, term.1, witness);
+                }
+                expr.push_addition_term(expression.q_c, witness);
+                self.add_data(AcirVarData::Expr(expr))
+            }
+            (AcirVarData::Expr(lhs_expr), AcirVarData::Expr(rhs_expr)) => {
+                let degree_one = if lhs_expr.is_linear() && rhs_expr.is_degree_one_univariate() {
+                    Some((lhs_expr, rhs_expr))
+                } else if rhs_expr.is_linear() && lhs_expr.is_degree_one_univariate() {
+                    Some((rhs_expr, lhs_expr))
+                } else {
+                    None
+                };
+                if let Some((lin, univariate)) = degree_one {
+                    let mut expr = Expression::default();
+                    let rhs_term = univariate.linear_combinations[0];
+                    for term in lin.linear_combinations.iter() {
+                        expr.push_multiplication_term(term.0 * rhs_term.0, term.1, rhs_term.1);
+                    }
+                    expr.push_addition_term(lin.q_c * rhs_term.0, rhs_term.1);
+                    expr.sort();
+                    expr = expr.add_mul(univariate.q_c, &lin);
+                    self.add_data(AcirVarData::Expr(expr))
+                } else {
+                    let lhs = self.get_or_create_witness_var(lhs)?;
+                    let rhs = self.get_or_create_witness_var(rhs)?;
+                    self.mul_var(lhs, rhs)?
+                }
+            }
+            _ => {
                 let lhs = self.get_or_create_witness_var(lhs)?;
                 let rhs = self.get_or_create_witness_var(rhs)?;
-
                 self.mul_var(lhs, rhs)?
             }
         };

From 6a7c7a95864a60a34a79e896163ba2b70cd06bbe Mon Sep 17 00:00:00 2001
From: josh crites <jc@joshcrites.com>
Date: Fri, 24 May 2024 17:23:53 -0400
Subject: [PATCH 299/416] chore(docs): Link to evmdiff for supported EVM chains
 (#5107)

# Description

Links to evmdiff.com to show which EVM chains have the required
precompiles

## Problem\*

related to #4964

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/how_to/how-to-solidity-verifier.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/how_to/how-to-solidity-verifier.md b/docs/docs/how_to/how-to-solidity-verifier.md
index 7c96e22b8d5..e6ed9abaec6 100644
--- a/docs/docs/how_to/how-to-solidity-verifier.md
+++ b/docs/docs/how_to/how-to-solidity-verifier.md
@@ -230,7 +230,7 @@ It would be incorrect to say that a Noir proof verification costs any gas at all
 
 ## A Note on EVM chains
 
-ZK-SNARK verification depends on some precompiled cryptographic primitives such as Elliptic Curve Pairings (if you like complex math, you can read about EC Pairings [here](https://medium.com/@VitalikButerin/exploring-elliptic-curve-pairings-c73c1864e627)). Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them.
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
 
 For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
 

From e4eb5f539f377fd3c2e1a874707ffce62a5bc10a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Mon, 27 May 2024 11:30:33 +0200
Subject: [PATCH 300/416] feat: Consider block parameters in variable liveness
 (#5097)

# Description

## Problem\*

Previously, on variable liveness we completely ignored block parameters,
by allocating all the parameters of all blocks at the start of the
function codegen and maintaining them allocated for the whole function.

## Summary\*

With this change, we add a definition point for block parameters and we
start considering them and allocating and freeing them dynamically. This
should save space in the stack, especially in heavily inlined functions
with many blocks.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen.rs                |   2 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |  35 +++--
 .../brillig_gen/brillig_block_variables.rs    |  48 ++----
 .../src/brillig/brillig_gen/brillig_fn.rs     |  31 +---
 .../brillig/brillig_gen/brillig_slice_ops.rs  |   4 +-
 .../brillig/brillig_gen/variable_liveness.rs  | 138 +++++++++++++++---
 .../Nargo.toml                                |   6 +
 .../Prover.toml                               |   1 +
 .../src/main.nr                               |  91 ++++++++++++
 9 files changed, 247 insertions(+), 109 deletions(-)
 create mode 100644 test_programs/execution_success/brillig_block_parameter_liveness/Nargo.toml
 create mode 100644 test_programs/execution_success/brillig_block_parameter_liveness/Prover.toml
 create mode 100644 test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
index 22814a22889..5576d673f1d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
@@ -14,7 +14,7 @@ use crate::ssa::ir::function::Function;
 pub(crate) fn convert_ssa_function(func: &Function, enable_debug_trace: bool) -> BrilligArtifact {
     let mut brillig_context = BrilligContext::new(enable_debug_trace);
 
-    let mut function_context = FunctionContext::new(func, &mut brillig_context);
+    let mut function_context = FunctionContext::new(func);
 
     brillig_context.enter_context(FunctionContext::function_id_to_function_label(func.id()));
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 6a4f9f5cc0e..0dbab80dace 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -7,7 +7,7 @@ use crate::brillig::brillig_ir::{
 use crate::ssa::ir::dfg::CallStack;
 use crate::ssa::ir::instruction::ConstrainError;
 use crate::ssa::ir::{
-    basic_block::{BasicBlock, BasicBlockId},
+    basic_block::BasicBlockId,
     dfg::DataFlowGraph,
     function::FunctionId,
     instruction::{
@@ -49,8 +49,7 @@ impl<'block> BrilligBlock<'block> {
         dfg: &DataFlowGraph,
     ) {
         let live_in = function_context.liveness.get_live_in(&block_id);
-        let variables =
-            BlockVariables::new(live_in.clone(), function_context.all_block_parameters());
+        let variables = BlockVariables::new(live_in.clone());
 
         brillig_context.set_allocated_registers(
             variables
@@ -72,9 +71,9 @@ impl<'block> BrilligBlock<'block> {
         let block_label = self.create_block_label_for_current_function(self.block_id);
         self.brillig_context.enter_context(block_label);
 
-        // Convert the block parameters
+        self.convert_block_params(dfg);
+
         let block = &dfg[self.block_id];
-        self.convert_block_params(block, dfg);
 
         // Convert all of the instructions into the block
         for instruction_id in block.instructions() {
@@ -134,12 +133,8 @@ impl<'block> BrilligBlock<'block> {
                 let target_block = &dfg[*destination_block];
                 for (src, dest) in arguments.iter().zip(target_block.parameters()) {
                     // Destinations are block parameters so they should have been allocated previously.
-                    let destination = self.variables.get_block_param(
-                        self.function_context,
-                        *destination_block,
-                        *dest,
-                        dfg,
-                    );
+                    let destination =
+                        self.variables.get_allocation(self.function_context, *dest, dfg);
                     let source = self.convert_ssa_value(*src, dfg);
                     self.pass_variable(source, destination);
                 }
@@ -206,10 +201,14 @@ impl<'block> BrilligBlock<'block> {
         }
     }
 
-    /// Converts SSA Block parameters into Brillig Registers.
-    fn convert_block_params(&mut self, block: &BasicBlock, dfg: &DataFlowGraph) {
-        for param_id in block.parameters() {
-            let value = &dfg[*param_id];
+    /// Allocates the block parameters that the given block is defining
+    fn convert_block_params(&mut self, dfg: &DataFlowGraph) {
+        // We don't allocate the block parameters here, we allocate the parameters the block is defining.
+        // Since predecessors to a block have to know where the parameters of the block are allocated to pass data to it,
+        // the block parameters need to be defined/allocated before the given block. Variable liveness provides when the block parameters are defined.
+        // For the entry block, the defined block params will be the params of the function + any extra params of blocks it's the immediate dominator of.
+        for param_id in self.function_context.liveness.defined_block_params(&self.block_id) {
+            let value = &dfg[param_id];
             let param_type = match value {
                 Value::Param { typ, .. } => typ,
                 _ => unreachable!("ICE: Only Param type values should appear in block parameters"),
@@ -220,10 +219,10 @@ impl<'block> BrilligBlock<'block> {
                 // Be a valid pointer to the array.
                 // For slices, two registers are passed, the pointer to the data and a register holding the size of the slice.
                 Type::Numeric(_) | Type::Array(..) | Type::Slice(..) | Type::Reference(_) => {
-                    self.variables.get_block_param(
+                    self.variables.define_variable(
                         self.function_context,
-                        self.block_id,
-                        *param_id,
+                        self.brillig_context,
+                        param_id,
                         dfg,
                     );
                 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
index 892e82d771a..fb9a8577d94 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
@@ -9,7 +9,6 @@ use crate::{
         BrilligContext,
     },
     ssa::ir::{
-        basic_block::BasicBlockId,
         dfg::DataFlowGraph,
         types::{CompositeType, Type},
         value::ValueId,
@@ -21,18 +20,13 @@ use super::brillig_fn::FunctionContext;
 #[derive(Debug, Default)]
 pub(crate) struct BlockVariables {
     available_variables: HashSet<ValueId>,
-    block_parameters: HashSet<ValueId>,
     available_constants: HashMap<ValueId, BrilligVariable>,
 }
 
 impl BlockVariables {
     /// Creates a BlockVariables instance. It uses the variables that are live in to the block and the global available variables (block parameters)
-    pub(crate) fn new(live_in: HashSet<ValueId>, all_block_parameters: HashSet<ValueId>) -> Self {
-        BlockVariables {
-            available_variables: live_in.into_iter().chain(all_block_parameters.clone()).collect(),
-            block_parameters: all_block_parameters,
-            ..Default::default()
-        }
+    pub(crate) fn new(live_in: HashSet<ValueId>) -> Self {
+        BlockVariables { available_variables: live_in, ..Default::default() }
     }
 
     /// Returns all non-constant variables that have not been removed at this point.
@@ -92,16 +86,13 @@ impl BlockVariables {
         brillig_context: &mut BrilligContext,
     ) {
         assert!(self.available_variables.remove(value_id), "ICE: Variable is not available");
-        // Block parameters should not be deallocated
-        if !self.block_parameters.contains(value_id) {
-            let variable = function_context
-                .ssa_value_allocations
-                .get(value_id)
-                .expect("ICE: Variable allocation not found");
-            variable.extract_registers().iter().for_each(|register| {
-                brillig_context.deallocate_register(*register);
-            });
-        }
+        let variable = function_context
+            .ssa_value_allocations
+            .get(value_id)
+            .expect("ICE: Variable allocation not found");
+        variable.extract_registers().iter().for_each(|register| {
+            brillig_context.deallocate_register(*register);
+        });
     }
 
     /// For a given SSA value id, return the corresponding cached allocation.
@@ -155,27 +146,6 @@ impl BlockVariables {
     pub(crate) fn dump_constants(&mut self) {
         self.available_constants.clear();
     }
-
-    /// For a given block parameter, return the allocation that was done globally to the function.
-    pub(crate) fn get_block_param(
-        &mut self,
-        function_context: &FunctionContext,
-        block_id: BasicBlockId,
-        value_id: ValueId,
-        dfg: &DataFlowGraph,
-    ) -> BrilligVariable {
-        let value_id = dfg.resolve(value_id);
-        assert!(
-            function_context
-                .block_parameters
-                .get(&block_id)
-                .expect("Block not found")
-                .contains(&value_id),
-            "Value is not a block parameter"
-        );
-
-        *function_context.ssa_value_allocations.get(&value_id).expect("Block param not found")
-    }
 }
 
 /// Computes the length of an array. This will match with the indexes that SSA will issue
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index 617e400b92f..000d1230ece 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -4,7 +4,6 @@ use crate::{
     brillig::brillig_ir::{
         artifact::{BrilligParameter, Label},
         brillig_variable::{get_bit_size_from_ssa_type, BrilligVariable},
-        BrilligContext,
     },
     ssa::ir::{
         basic_block::BasicBlockId,
@@ -14,16 +13,14 @@ use crate::{
         value::ValueId,
     },
 };
-use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
+use fxhash::FxHashMap as HashMap;
 
-use super::{brillig_block_variables::allocate_value, variable_liveness::VariableLiveness};
+use super::variable_liveness::VariableLiveness;
 
 pub(crate) struct FunctionContext {
     pub(crate) function_id: FunctionId,
     /// Map from SSA values its allocation. Since values can be only defined once in SSA form, we insert them here on when we allocate them at their definition.
     pub(crate) ssa_value_allocations: HashMap<ValueId, BrilligVariable>,
-    /// Block parameters are pre allocated at the function level.
-    pub(crate) block_parameters: HashMap<BasicBlockId, Vec<ValueId>>,
     /// The block ids of the function in reverse post order.
     pub(crate) blocks: Vec<BasicBlockId>,
     /// Liveness information for each variable in the function.
@@ -31,40 +28,22 @@ pub(crate) struct FunctionContext {
 }
 
 impl FunctionContext {
-    /// Creates a new function context. It will allocate parameters for all blocks and compute the liveness of every variable.
-    pub(crate) fn new(function: &Function, brillig_context: &mut BrilligContext) -> Self {
+    /// Creates a new function context. It will compute the liveness of every variable.
+    pub(crate) fn new(function: &Function) -> Self {
         let id = function.id();
 
         let mut reverse_post_order = Vec::new();
         reverse_post_order.extend_from_slice(PostOrder::with_function(function).as_slice());
         reverse_post_order.reverse();
 
-        let mut block_parameters = HashMap::default();
-        let mut ssa_variable_to_register_or_memory = HashMap::default();
-
-        for &block_id in &reverse_post_order {
-            let block = &function.dfg[block_id];
-            let parameters = block.parameters().to_vec();
-            parameters.iter().for_each(|&value_id| {
-                let variable = allocate_value(value_id, brillig_context, &function.dfg);
-                ssa_variable_to_register_or_memory.insert(value_id, variable);
-            });
-            block_parameters.insert(block_id, parameters);
-        }
-
         Self {
             function_id: id,
-            ssa_value_allocations: ssa_variable_to_register_or_memory,
-            block_parameters,
+            ssa_value_allocations: HashMap::default(),
             blocks: reverse_post_order,
             liveness: VariableLiveness::from_function(function),
         }
     }
 
-    pub(crate) fn all_block_parameters(&self) -> HashSet<ValueId> {
-        self.block_parameters.values().flat_map(|parameters| parameters.iter()).cloned().collect()
-    }
-
     /// Creates a function label from a given SSA function id.
     pub(crate) fn function_id_to_function_label(function_id: FunctionId) -> Label {
         function_id.to_string()
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 3e1515b1eed..491086e8c0f 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -377,9 +377,9 @@ mod tests {
         builder.set_runtime(RuntimeType::Brillig);
 
         let ssa = builder.finish();
-        let mut brillig_context = create_context();
+        let brillig_context = create_context();
 
-        let function_context = FunctionContext::new(ssa.main(), &mut brillig_context);
+        let function_context = FunctionContext::new(ssa.main());
         (ssa, function_context, brillig_context)
     }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
index c9f1cd1e247..52eded81919 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
@@ -93,6 +93,9 @@ fn variables_used_in_block(block: &BasicBlock, dfg: &DataFlowGraph) -> Vec<Value
         })
         .collect();
 
+    // We consider block parameters used, so they live up to the block that owns them.
+    used.extend(block.parameters().iter());
+
     if let Some(terminator) = block.terminator() {
         terminator.for_each_value(|value_id| {
             used.extend(collect_variables_of_value(value_id, dfg));
@@ -104,23 +107,6 @@ fn variables_used_in_block(block: &BasicBlock, dfg: &DataFlowGraph) -> Vec<Value
 
 type Variables = HashSet<ValueId>;
 
-fn compute_defined_variables(block: &BasicBlock, dfg: &DataFlowGraph) -> Variables {
-    let mut defined_vars = HashSet::default();
-
-    for parameter in block.parameters() {
-        defined_vars.insert(dfg.resolve(*parameter));
-    }
-
-    for instruction_id in block.instructions() {
-        let result_values = dfg.instruction_results(*instruction_id);
-        for result_value in result_values {
-            defined_vars.insert(dfg.resolve(*result_value));
-        }
-    }
-
-    defined_vars
-}
-
 fn compute_used_before_def(
     block: &BasicBlock,
     dfg: &DataFlowGraph,
@@ -142,6 +128,8 @@ pub(crate) struct VariableLiveness {
     live_in: HashMap<BasicBlockId, Variables>,
     /// The variables that stop being alive after each specific instruction
     last_uses: HashMap<BasicBlockId, LastUses>,
+    /// The list of block params the given block is defining. The order matters for the entry block, so it's a vec.
+    param_definitions: HashMap<BasicBlockId, Vec<ValueId>>,
 }
 
 impl VariableLiveness {
@@ -150,8 +138,15 @@ impl VariableLiveness {
         let cfg = ControlFlowGraph::with_function(func);
         let post_order = PostOrder::with_function(func);
 
-        let mut instance =
-            Self { cfg, post_order, live_in: HashMap::default(), last_uses: HashMap::default() };
+        let mut instance = Self {
+            cfg,
+            post_order,
+            live_in: HashMap::default(),
+            last_uses: HashMap::default(),
+            param_definitions: HashMap::default(),
+        };
+
+        instance.compute_block_param_definitions(func);
 
         instance.compute_live_in_of_blocks(func);
 
@@ -179,6 +174,30 @@ impl VariableLiveness {
         self.last_uses.get(block_id).expect("Last uses should have been calculated")
     }
 
+    /// Retrieves the list of block params the given block is defining.
+    /// Block params are defined before the block that owns them (since they are used by the predecessor blocks). They must be defined in the immediate dominator.
+    /// This is the last point where the block param can be allocated without it being allocated in different places in different branches.
+    pub(crate) fn defined_block_params(&self, block_id: &BasicBlockId) -> Vec<ValueId> {
+        self.param_definitions.get(block_id).cloned().unwrap_or_default()
+    }
+
+    fn compute_block_param_definitions(&mut self, func: &Function) {
+        let tree = DominatorTree::with_cfg_and_post_order(&self.cfg, &self.post_order);
+
+        // Going in reverse post order to process the entry block first
+        let mut reverse_post_order = Vec::new();
+        reverse_post_order.extend_from_slice(self.post_order.as_slice());
+        reverse_post_order.reverse();
+        for block in reverse_post_order {
+            let params = func.dfg[block].parameters();
+            // If it has no dominator, it's the entry block
+            let dominator_block = tree.immediate_dominator(block).unwrap_or(func.entry_block());
+            let definitions_for_the_dominator =
+                self.param_definitions.entry(dominator_block).or_default();
+            definitions_for_the_dominator.extend(params.iter());
+        }
+    }
+
     fn compute_live_in_of_blocks(&mut self, func: &Function) {
         let back_edges = find_back_edges(func, &self.cfg, &self.post_order);
 
@@ -197,9 +216,10 @@ impl VariableLiveness {
         block_id: BasicBlockId,
         back_edges: &HashSet<BackEdge>,
     ) {
-        let block = &func.dfg[block_id];
+        let defined = self.compute_defined_variables(block_id, &func.dfg);
+
+        let block: &BasicBlock = &func.dfg[block_id];
 
-        let defined = compute_defined_variables(block, &func.dfg);
         let used_before_def = compute_used_before_def(block, &func.dfg, &defined);
 
         let mut live_out = HashSet::default();
@@ -222,6 +242,24 @@ impl VariableLiveness {
         self.live_in.insert(block_id, used_before_def.union(&passthrough_vars).cloned().collect());
     }
 
+    fn compute_defined_variables(&self, block_id: BasicBlockId, dfg: &DataFlowGraph) -> Variables {
+        let block: &BasicBlock = &dfg[block_id];
+        let mut defined_vars = HashSet::default();
+
+        for parameter in self.defined_block_params(&block_id) {
+            defined_vars.insert(dfg.resolve(parameter));
+        }
+
+        for instruction_id in block.instructions() {
+            let result_values = dfg.instruction_results(*instruction_id);
+            for result_value in result_values {
+                defined_vars.insert(dfg.resolve(*result_value));
+            }
+        }
+
+        defined_vars
+    }
+
     fn update_live_ins_within_loop(&mut self, back_edge: BackEdge) {
         let header_live_ins = self
             .live_in
@@ -513,12 +551,12 @@ mod test {
         let liveness = VariableLiveness::from_function(func);
 
         assert!(liveness.get_live_in(&func.entry_block()).is_empty());
-        assert_eq!(liveness.get_live_in(&b1), &FxHashSet::from_iter([v0, v1, v3].into_iter()));
+        assert_eq!(liveness.get_live_in(&b1), &FxHashSet::from_iter([v0, v1, v3, v4].into_iter()));
         assert_eq!(liveness.get_live_in(&b3), &FxHashSet::from_iter([v3].into_iter()));
         assert_eq!(liveness.get_live_in(&b2), &FxHashSet::from_iter([v0, v1, v3, v4].into_iter()));
         assert_eq!(
             liveness.get_live_in(&b4),
-            &FxHashSet::from_iter([v0, v1, v3, v4, v6].into_iter())
+            &FxHashSet::from_iter([v0, v1, v3, v4, v6, v7].into_iter())
         );
         assert_eq!(liveness.get_live_in(&b6), &FxHashSet::from_iter([v0, v1, v3, v4].into_iter()));
         assert_eq!(
@@ -540,4 +578,58 @@ mod test {
             Some(&FxHashSet::from_iter([v3].into_iter()))
         );
     }
+
+    #[test]
+    fn block_params() {
+        // brillig fn main f0 {
+        //     b0(v0: u1):
+        //       jmpif v0 then: b1, else: b2
+        //     b1():
+        //       jmp b3(Field 27, Field 29)
+        //     b3(v1: Field, v2: Field):
+        //       return v1
+        //     b2():
+        //       jmp b3(Field 28, Field 40)
+        //   }
+
+        let main_id = Id::test_new(1);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
+        builder.set_runtime(RuntimeType::Brillig);
+
+        let v0 = builder.add_parameter(Type::bool());
+
+        let b1 = builder.insert_block();
+        let b2 = builder.insert_block();
+        let b3 = builder.insert_block();
+
+        builder.terminate_with_jmpif(v0, b1, b2);
+
+        builder.switch_to_block(b1);
+        let twenty_seven = builder.field_constant(27_u128);
+        let twenty_nine = builder.field_constant(29_u128);
+        builder.terminate_with_jmp(b3, vec![twenty_seven, twenty_nine]);
+
+        builder.switch_to_block(b3);
+        let v1 = builder.add_block_parameter(b3, Type::field());
+        let v2 = builder.add_block_parameter(b3, Type::field());
+        builder.terminate_with_return(vec![v1]);
+
+        builder.switch_to_block(b2);
+        let twenty_eight = builder.field_constant(28_u128);
+        let forty = builder.field_constant(40_u128);
+        builder.terminate_with_jmp(b3, vec![twenty_eight, forty]);
+
+        let ssa = builder.finish();
+        let func = ssa.main();
+        let liveness = VariableLiveness::from_function(func);
+
+        // Entry point defines its own params and also b3's params.
+        assert_eq!(liveness.defined_block_params(&func.entry_block()), vec![v0, v1, v2]);
+        assert_eq!(liveness.defined_block_params(&b1), vec![]);
+        assert_eq!(liveness.defined_block_params(&b2), vec![]);
+        assert_eq!(liveness.defined_block_params(&b3), vec![]);
+
+        assert_eq!(liveness.get_live_in(&b1), &FxHashSet::from_iter([v1, v2].into_iter()));
+        assert_eq!(liveness.get_live_in(&b2), &FxHashSet::from_iter([v1, v2].into_iter()));
+    }
 }
diff --git a/test_programs/execution_success/brillig_block_parameter_liveness/Nargo.toml b/test_programs/execution_success/brillig_block_parameter_liveness/Nargo.toml
new file mode 100644
index 00000000000..e094862a1dc
--- /dev/null
+++ b/test_programs/execution_success/brillig_block_parameter_liveness/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "brillig_block_parameter_liveness"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_block_parameter_liveness/Prover.toml b/test_programs/execution_success/brillig_block_parameter_liveness/Prover.toml
new file mode 100644
index 00000000000..6b7fd9c6ab6
--- /dev/null
+++ b/test_programs/execution_success/brillig_block_parameter_liveness/Prover.toml
@@ -0,0 +1 @@
+conditions = ["1", "0", "1", "0", "1"]
diff --git a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
new file mode 100644
index 00000000000..142290ecbe2
--- /dev/null
+++ b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
@@ -0,0 +1,91 @@
+// Tests that we run liveness in block parameters by trying to create too many block parameters to fit in the stack
+
+// Uses up 10 stack items
+struct Inner {
+    a: u64,
+    b: u64,
+    c: u64,
+    d: u64,
+    e: u64,
+    f: u64,
+    g: u64,
+    h: u64,
+    i: u64,
+    j: u64,
+}
+
+// Uses up 50 stack items
+struct Middle {
+    inner_a: Inner,
+    inner_b: Inner,
+    inner_c: Inner,
+    inner_d: Inner,
+    inner_e: Inner,
+}
+
+// Uses up 500 stack items
+struct Outer {
+    middle_a: Middle,
+    middle_b: Middle,
+    middle_c: Middle,
+    middle_d: Middle,
+    middle_e: Middle,
+    middle_f: Middle,
+    middle_g: Middle,
+    middle_h: Middle,
+}
+
+// If we don't take into account block parameter liveness, this function will need 5*500=2500 stack items
+unconstrained fn main(conditions: [bool; 5]) -> pub Outer {
+    let out0 = if conditions[0] {
+        let mut outer: Outer = dep::std::unsafe::zeroed();
+        outer.middle_a.inner_a.a = 1;
+        outer
+    } else {
+        let mut outer: Outer= dep::std::unsafe::zeroed();
+        outer.middle_f.inner_c.d = 2;
+        outer
+    };
+
+    let out1 = if conditions[1] {
+        let mut new_outer = out0;
+        new_outer.middle_a.inner_a.b = 3;
+        new_outer
+    } else {
+        let mut new_outer = out0;
+        new_outer.middle_f.inner_c.c = 4;
+        new_outer
+    };
+
+    let out2 = if conditions[2] {
+        let mut new_outer = out1;
+        new_outer.middle_a.inner_a.c = 5;
+        new_outer
+    } else {
+        let mut new_outer = out1;
+        new_outer.middle_f.inner_c.b = 6;
+        new_outer
+    };
+
+    let out3 = if conditions[3] {
+        let mut new_outer = out2;
+        new_outer.middle_a.inner_a.d = 7;
+        new_outer
+    } else {
+        let mut new_outer = out2;
+        new_outer.middle_f.inner_c.a = 8;
+        new_outer
+    };
+
+    let out4 = if conditions[4] {
+        let mut new_outer = out3;
+        new_outer.middle_a.inner_a.f = 9;
+        new_outer
+    } else {
+        let mut new_outer = out3;
+        new_outer.middle_f.inner_c.f = 10;
+        new_outer
+    };
+
+    out4
+}

From b359bacf6981343bba4e684489a58573e20dfdb4 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 15:54:08 +0100
Subject: [PATCH 301/416] chore: perform dead instruction elimination through
 `std::as_witness` (#5123)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds handling for `std::as_witness` in dead instruction
elimination. i.e. if we're asking for an SSA value to be assigned to a
witness when that value would not otherwise be represented in the ACIR
then we can remove it.

This issue can be seen in #5122 where making two calls to the same
function with the same inputs and asserting that the outputs are the
same results in constraints whereas this can be determined at runtime.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/ssa/ir/dfg.rs  |  2 +-
 compiler/noirc_evaluator/src/ssa/opt/die.rs | 49 ++++++++++++++++++++-
 2 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
index 85630b75614..c71781557bd 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
@@ -284,7 +284,7 @@ impl DataFlowGraph {
         intrinsic_value_id
     }
 
-    pub(crate) fn get_intrinsic(&mut self, intrinsic: Intrinsic) -> Option<&ValueId> {
+    pub(crate) fn get_intrinsic(&self, intrinsic: Intrinsic) -> Option<&ValueId> {
         self.intrinsics.get(&intrinsic)
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index d045762f9e9..42383680f44 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -7,7 +7,7 @@ use crate::ssa::{
         basic_block::{BasicBlock, BasicBlockId},
         dfg::DataFlowGraph,
         function::Function,
-        instruction::{Instruction, InstructionId},
+        instruction::{Instruction, InstructionId, Intrinsic},
         post_order::PostOrder,
         value::{Value, ValueId},
     },
@@ -111,6 +111,10 @@ impl Context {
         if instruction.can_eliminate_if_unused(&function.dfg) {
             let results = function.dfg.instruction_results(instruction_id);
             results.iter().all(|result| !self.used_values.contains(result))
+        } else if let Instruction::Call { func, arguments } = instruction {
+            // TODO: make this more general for instructions which don't have results but have side effects "sometimes" like `Intrinsic::AsWitness`
+            let as_witness_id = function.dfg.get_intrinsic(Intrinsic::AsWitness);
+            as_witness_id == Some(func) && !self.used_values.contains(&arguments[0])
         } else {
             // If the instruction has side effects we should never remove it.
             false
@@ -256,4 +260,47 @@ mod test {
         assert_eq!(main.dfg[main.entry_block()].instructions().len(), 1);
         assert_eq!(main.dfg[b1].instructions().len(), 6);
     }
+
+    #[test]
+    fn as_witness_die() {
+        // fn main f0 {
+        //   b0(v0: Field):
+        //     v1 = add v0, Field 1
+        //     v2 = add v0, Field 2
+        //     call as_witness(v2)
+        //     return v1
+        // }
+        let main_id = Id::test_new(0);
+
+        // Compiling main
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
+        let v0 = builder.add_parameter(Type::field());
+
+        let one = builder.field_constant(1u128);
+        let two = builder.field_constant(2u128);
+
+        let v1 = builder.insert_binary(v0, BinaryOp::Add, one);
+        let v2 = builder.insert_binary(v0, BinaryOp::Add, two);
+        let as_witness = builder.import_intrinsic("as_witness").unwrap();
+        builder.insert_call(as_witness, vec![v2], Vec::new());
+        builder.terminate_with_return(vec![v1]);
+
+        let ssa = builder.finish();
+        let main = ssa.main();
+
+        // The instruction count never includes the terminator instruction
+        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 3);
+
+        // Expected output:
+        //
+        // acir(inline) fn main f0 {
+        //    b0(v0: Field):
+        //      v3 = add v0, Field 1
+        //      return v3
+        //  }
+        let ssa = ssa.dead_instruction_elimination();
+        let main = ssa.main();
+
+        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 1);
+    }
 }

From 56c1a85056ed338644595f1aa58cc94563786b9e Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 28 May 2024 16:50:55 +0100
Subject: [PATCH 302/416] fix: Auto dereference trait methods in the elaborator
 (#5124)

# Description

## Problem\*

Follow-up to https://github.com/noir-lang/noir/pull/5094

## Summary\*

This was missed when moving over changes due to the turbofish operator
over to the elaborato.r

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 0581e7900f8..121a4d89ef0 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -344,8 +344,15 @@ impl<'context> Elaborator<'context> {
         }
 
         // Verify any remaining trait constraints arising from the function body
-        for (constraint, expr_id) in std::mem::take(&mut self.trait_constraints) {
+        for (mut constraint, expr_id) in std::mem::take(&mut self.trait_constraints) {
             let span = self.interner.expr_span(&expr_id);
+
+            if matches!(&constraint.typ, Type::MutableReference(_)) {
+                let (_, dereferenced_typ) =
+                    self.insert_auto_dereferences(expr_id, constraint.typ.clone());
+                constraint.typ = dereferenced_typ;
+            }
+
             self.verify_trait_constraint(
                 &constraint.typ,
                 constraint.trait_id,

From 70f374c06642962d8f2b95b80f8c938fcf7761d7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 16:55:30 +0100
Subject: [PATCH 303/416] feat: make ACVM generic across fields (#5114)

# Description

Step towards #5055

## Summary\*

This PR starts us down the road towards removing the compile-time flags
for specifying which field is being used by replacing the usage of the
`FieldElement` type with an `AcirField` trait. This trait is mostly all
of the external methods from `FieldElement` dumped into it for now but
we can break it down in future PRs (XOR and AND are looking ready for
culling)

I've taken this route rather than just using `generic_ark::FieldElement`
as we'd need to have trait bounds for `PrimeField` anyway so we might as
well have our own trait.

I've had to delete a couple of trait implementations which fall afoul of
the orphan rule now it's being implemented for a generic type (e.g. we
need to use `MemoryValue::new_field` explicitly now) but nothing too
bad.

## Additional Context


## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |   2 +
 acvm-repo/acir/Cargo.toml                     |   5 +-
 acvm-repo/acir/benches/serialization.rs       |   8 +-
 acvm-repo/acir/src/circuit/brillig.rs         |  10 +-
 acvm-repo/acir/src/circuit/directives.rs      |   4 +-
 acvm-repo/acir/src/circuit/mod.rs             |  94 +++---
 acvm-repo/acir/src/circuit/opcodes.rs         |  21 +-
 .../opcodes/black_box_function_call.rs        |  10 +-
 .../src/circuit/opcodes/memory_operation.rs   |  15 +-
 acvm-repo/acir/src/lib.rs                     |  23 +-
 .../acir/src/native_types/expression/mod.rs   | 135 ++++----
 .../src/native_types/expression/operators.rs  | 212 ++++++------
 .../src/native_types/expression/ordering.rs   |  10 +-
 acvm-repo/acir/src/native_types/witness.rs    |  13 -
 .../acir/src/native_types/witness_map.rs      |  37 +--
 .../acir/src/native_types/witness_stack.rs    |  26 +-
 .../acir/tests/test_program_serialization.rs  |  37 ++-
 acvm-repo/acir_field/Cargo.toml               |  15 +-
 acvm-repo/acir_field/src/generic_ark.rs       | 312 +++++++++++-------
 acvm-repo/acir_field/src/lib.rs               |  17 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm/src/compiler/mod.rs            |  17 +-
 .../acvm/src/compiler/optimizers/general.rs   |  20 +-
 acvm-repo/acvm/src/compiler/optimizers/mod.rs |  11 +-
 .../compiler/optimizers/redundant_range.rs    |  21 +-
 .../src/compiler/optimizers/unused_memory.rs  |  12 +-
 .../acvm/src/compiler/transformers/csat.rs    | 244 +++++++-------
 .../acvm/src/compiler/transformers/mod.rs     |  18 +-
 acvm-repo/acvm/src/lib.rs                     |   2 +-
 acvm-repo/acvm/src/pwg/arithmetic.rs          | 139 ++++----
 acvm-repo/acvm/src/pwg/blackbox/aes128.rs     |  10 +-
 acvm-repo/acvm/src/pwg/blackbox/bigint.rs     |  20 +-
 .../src/pwg/blackbox/embedded_curve_ops.rs    |  17 +-
 acvm-repo/acvm/src/pwg/blackbox/hash.rs       |  48 ++-
 acvm-repo/acvm/src/pwg/blackbox/logic.rs      |  22 +-
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        |  18 +-
 acvm-repo/acvm/src/pwg/blackbox/pedersen.rs   |  17 +-
 acvm-repo/acvm/src/pwg/blackbox/range.rs      |   8 +-
 .../acvm/src/pwg/blackbox/signature/ecdsa.rs  |  18 +-
 .../src/pwg/blackbox/signature/schnorr.rs     |  16 +-
 acvm-repo/acvm/src/pwg/blackbox/utils.rs      |  14 +-
 acvm-repo/acvm/src/pwg/brillig.rs             |  68 ++--
 acvm-repo/acvm/src/pwg/directives/mod.rs      |  14 +-
 acvm-repo/acvm/src/pwg/memory_op.rs           |  35 +-
 acvm-repo/acvm/src/pwg/mod.rs                 | 154 +++++----
 acvm-repo/acvm/tests/solver.rs                |  43 ++-
 acvm-repo/acvm_js/src/black_box_solvers.rs    |   2 +-
 acvm-repo/acvm_js/src/execute.rs              |  37 ++-
 acvm-repo/acvm_js/src/foreign_call/inputs.rs  |   4 +-
 acvm-repo/acvm_js/src/foreign_call/mod.rs     |   6 +-
 acvm-repo/acvm_js/src/foreign_call/outputs.rs |  12 +-
 acvm-repo/acvm_js/src/js_execution_error.rs   |   7 +-
 acvm-repo/acvm_js/src/js_witness_map.rs       |  13 +-
 acvm-repo/acvm_js/src/js_witness_stack.rs     |   8 +-
 acvm-repo/acvm_js/src/public_witness.rs       |  19 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   1 -
 .../src/curve_specific_solver.rs              |  82 ++---
 .../benches/criterion.rs                      |   2 +-
 .../src/embedded_curve_ops.rs                 |   7 +-
 acvm-repo/bn254_blackbox_solver/src/lib.rs    |   2 +-
 .../src/pedersen/commitment.rs                |   2 +-
 .../src/pedersen/hash.rs                      |   2 +-
 .../bn254_blackbox_solver/src/poseidon2.rs    |   4 +-
 .../bn254_blackbox_solver/src/schnorr/mod.rs  |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   1 -
 acvm-repo/brillig/src/foreign_call.rs         |  40 +--
 acvm-repo/brillig/src/opcodes.rs              |   6 +-
 acvm-repo/brillig_vm/Cargo.toml               |   1 -
 acvm-repo/brillig_vm/src/arithmetic.rs        |  37 ++-
 acvm-repo/brillig_vm/src/black_box.rs         |  95 ++++--
 acvm-repo/brillig_vm/src/lib.rs               | 140 ++++----
 acvm-repo/brillig_vm/src/memory.rs            | 124 +++----
 aztec_macros/Cargo.toml                       |   1 +
 aztec_macros/src/transforms/storage.rs        |   1 +
 aztec_macros/src/utils/hir_utils.rs           |   1 +
 compiler/noirc_driver/src/contract.rs         |   4 +-
 compiler/noirc_driver/src/program.rs          |   4 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |   2 +-
 .../brillig/brillig_gen/brillig_directive.rs  |   1 +
 .../noirc_evaluator/src/brillig/brillig_ir.rs |  15 +-
 .../src/brillig/brillig_ir/artifact.rs        |  14 +-
 .../brillig/brillig_ir/brillig_variable.rs    |   1 +
 .../brillig/brillig_ir/codegen_intrinsic.rs   |   1 +
 .../src/brillig/brillig_ir/entry_point.rs     |   2 +-
 .../src/brillig/brillig_ir/instructions.rs    |   5 +-
 compiler/noirc_evaluator/src/ssa.rs           |  19 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |  62 ++--
 .../src/ssa/acir_gen/acir_ir/big_int.rs       |   2 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  36 +-
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |   7 +-
 .../src/ssa/function_builder/mod.rs           |   2 +-
 compiler/noirc_evaluator/src/ssa/ir/dfg.rs    |   2 +-
 .../noirc_evaluator/src/ssa/ir/instruction.rs |   1 +
 .../src/ssa/ir/instruction/binary.rs          |   2 +-
 .../src/ssa/ir/instruction/call.rs            |   2 +-
 .../src/ssa/ir/instruction/cast.rs            |   2 +-
 .../src/ssa/ir/instruction/constrain.rs       |   2 +-
 .../noirc_evaluator/src/ssa/ir/printer.rs     |   1 +
 compiler/noirc_evaluator/src/ssa/ir/types.rs  |   2 +-
 .../src/ssa/opt/constant_folding.rs           |   3 +-
 .../src/ssa/opt/flatten_cfg.rs                |   4 +-
 .../ssa/opt/flatten_cfg/capacity_tracker.rs   |   2 +-
 .../src/ssa/opt/flatten_cfg/value_merger.rs   |   2 +-
 .../noirc_evaluator/src/ssa/opt/inlining.rs   |   3 +-
 .../noirc_evaluator/src/ssa/opt/mem2reg.rs    |   2 +-
 .../src/ssa/opt/remove_bit_shifts.rs          |   2 +-
 .../src/ssa/opt/remove_enable_side_effects.rs |   2 +-
 .../src/ssa/opt/remove_if_else.rs             |   2 +-
 .../src/ssa/opt/simplify_cfg.rs               |   3 +
 .../noirc_evaluator/src/ssa/opt/unrolling.rs  |   2 +
 .../src/ssa/ssa_gen/context.rs                |   2 +-
 compiler/noirc_frontend/src/ast/expression.rs |   2 +-
 compiler/noirc_frontend/src/ast/mod.rs        |   1 +
 compiler/noirc_frontend/src/ast/statement.rs  |   1 +
 .../noirc_frontend/src/elaborator/types.rs    |   1 +
 .../noirc_frontend/src/hir/comptime/errors.rs |   2 +-
 .../src/hir/comptime/interpreter.rs           |   2 +-
 .../src/hir/resolution/resolver.rs            |   2 +
 .../noirc_frontend/src/hir/type_check/stmt.rs |   1 +
 compiler/noirc_frontend/src/lexer/token.rs    |   2 +-
 .../src/monomorphization/debug.rs             |   1 +
 .../src/monomorphization/mod.rs               |   2 +-
 compiler/noirc_printable_type/src/lib.rs      |  14 +-
 compiler/wasm/Cargo.toml                      |   2 +-
 tooling/acvm_cli/src/cli/execute_cmd.rs       |   7 +-
 tooling/acvm_cli/src/cli/fs/inputs.rs         |   6 +-
 tooling/acvm_cli/src/cli/fs/witness.rs        |  12 +-
 tooling/debugger/src/context.rs               |  36 +-
 tooling/debugger/src/dap.rs                   |  16 +-
 tooling/debugger/src/foreign_calls.rs         |   6 +-
 tooling/debugger/src/lib.rs                   |  16 +-
 tooling/debugger/src/repl.rs                  |  30 +-
 tooling/lsp/src/lib.rs                        |  12 +-
 tooling/lsp/src/solver.rs                     |   4 +-
 tooling/nargo/src/artifacts/contract.rs       |   4 +-
 tooling/nargo/src/artifacts/program.rs        |   3 +-
 tooling/nargo/src/errors.rs                   |   5 +-
 tooling/nargo/src/ops/execute.rs              |  52 +--
 tooling/nargo/src/ops/foreign_calls.rs        |  52 +--
 tooling/nargo/src/ops/optimize.rs             |   7 +-
 tooling/nargo/src/ops/test.rs                 |   6 +-
 tooling/nargo/src/ops/transform.rs            |   9 +-
 tooling/nargo_cli/Cargo.toml                  |   2 +-
 tooling/nargo_cli/src/cli/dap_cmd.rs          |   3 +-
 tooling/nargo_cli/src/cli/debug_cmd.rs        |   5 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |   5 +-
 tooling/nargo_cli/src/cli/fs/witness.rs       |   4 +-
 tooling/nargo_cli/src/cli/test_cmd.rs         |   6 +-
 tooling/noirc_abi/src/input_parser/json.rs    |   2 +-
 tooling/noirc_abi/src/input_parser/mod.rs     |   6 +-
 tooling/noirc_abi/src/input_parser/toml.rs    |   2 +-
 tooling/noirc_abi/src/lib.rs                  |   8 +-
 tooling/noirc_abi_wasm/Cargo.toml             |   2 +-
 tooling/noirc_abi_wasm/src/js_witness_map.rs  |  10 +-
 tooling/noirc_abi_wasm/src/lib.rs             |  15 +-
 155 files changed, 1760 insertions(+), 1519 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bfc012d23f0..919bdc48748 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -44,6 +44,7 @@ version = "0.46.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
+ "ark-bls12-381",
  "brillig_vm",
  "indexmap 1.9.3",
  "num-bigint",
@@ -445,6 +446,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 name = "aztec_macros"
 version = "0.30.0"
 dependencies = [
+ "acvm",
  "convert_case 0.6.0",
  "iter-extended",
  "noirc_errors",
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 32a9bbe8303..101ce7a0f39 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -33,9 +33,8 @@ criterion.workspace = true
 pprof.workspace = true
 
 [features]
-default = ["bn254"]
-bn254 = ["acir_field/bn254", "brillig/bn254"]
-bls12_381 = ["acir_field/bls12_381", "brillig/bls12_381"]
+bn254 = ["acir_field/bn254"]
+bls12_381 = ["acir_field/bls12_381"]
 
 [[bench]]
 name = "serialization"
diff --git a/acvm-repo/acir/benches/serialization.rs b/acvm-repo/acir/benches/serialization.rs
index a7f32b4a4c7..792200c8912 100644
--- a/acvm-repo/acir/benches/serialization.rs
+++ b/acvm-repo/acir/benches/serialization.rs
@@ -11,8 +11,8 @@ use pprof::criterion::{Output, PProfProfiler};
 
 const SIZES: [usize; 9] = [10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000];
 
-fn sample_program(num_opcodes: usize) -> Program {
-    let assert_zero_opcodes: Vec<Opcode> = (0..num_opcodes)
+fn sample_program(num_opcodes: usize) -> Program<FieldElement> {
+    let assert_zero_opcodes: Vec<Opcode<_>> = (0..num_opcodes)
         .map(|i| {
             Opcode::AssertZero(Expression {
                 mul_terms: vec![(
@@ -83,7 +83,7 @@ fn bench_deserialization(c: &mut Criterion) {
             BenchmarkId::from_parameter(size),
             &serialized_program,
             |b, program| {
-                b.iter(|| Program::deserialize_program(program));
+                b.iter(|| Program::<FieldElement>::deserialize_program(program));
             },
         );
     }
@@ -107,7 +107,7 @@ fn bench_deserialization(c: &mut Criterion) {
             |b, program| {
                 b.iter(|| {
                     let mut deserializer = serde_json::Deserializer::from_slice(program);
-                    Program::deserialize_program_base64(&mut deserializer)
+                    Program::<FieldElement>::deserialize_program_base64(&mut deserializer)
                 });
             },
         );
diff --git a/acvm-repo/acir/src/circuit/brillig.rs b/acvm-repo/acir/src/circuit/brillig.rs
index ecf6f7a9761..ee25d05afb0 100644
--- a/acvm-repo/acir/src/circuit/brillig.rs
+++ b/acvm-repo/acir/src/circuit/brillig.rs
@@ -6,9 +6,9 @@ use serde::{Deserialize, Serialize};
 /// Inputs for the Brillig VM. These are the initial inputs
 /// that the Brillig VM will use to start.
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub enum BrilligInputs {
-    Single(Expression),
-    Array(Vec<Expression>),
+pub enum BrilligInputs<F> {
+    Single(Expression<F>),
+    Array(Vec<Expression<F>>),
     MemoryArray(BlockId),
 }
 
@@ -24,6 +24,6 @@ pub enum BrilligOutputs {
 /// a full Brillig function to be executed by the Brillig VM.
 /// This is stored separately on a program and accessed through a [BrilligPointer].
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Debug)]
-pub struct BrilligBytecode {
-    pub bytecode: Vec<BrilligOpcode>,
+pub struct BrilligBytecode<F> {
+    pub bytecode: Vec<BrilligOpcode<F>>,
 }
diff --git a/acvm-repo/acir/src/circuit/directives.rs b/acvm-repo/acir/src/circuit/directives.rs
index 099d0634399..3bc66288590 100644
--- a/acvm-repo/acir/src/circuit/directives.rs
+++ b/acvm-repo/acir/src/circuit/directives.rs
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 /// Directives do not apply any constraints.
 /// You can think of them as opcodes that allow one to use non-determinism
 /// In the future, this can be replaced with asm non-determinism blocks
-pub enum Directive {
+pub enum Directive<F> {
     //decomposition of a: a=\sum b[i]*radix^i where b is an array of witnesses < radix in little endian form
-    ToLeRadix { a: Expression, b: Vec<Witness>, radix: u32 },
+    ToLeRadix { a: Expression<F>, b: Vec<Witness>, radix: u32 },
 }
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index 6a26a45d88b..7632afda423 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -4,7 +4,7 @@ pub mod directives;
 pub mod opcodes;
 
 use crate::native_types::{Expression, Witness};
-use acir_field::FieldElement;
+use acir_field::AcirField;
 pub use opcodes::Opcode;
 use thiserror::Error;
 
@@ -38,17 +38,17 @@ pub enum ExpressionWidth {
 /// A program represented by multiple ACIR circuits. The execution trace of these
 /// circuits is dictated by construction of the [crate::native_types::WitnessStack].
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct Program {
-    pub functions: Vec<Circuit>,
-    pub unconstrained_functions: Vec<BrilligBytecode>,
+pub struct Program<F> {
+    pub functions: Vec<Circuit<F>>,
+    pub unconstrained_functions: Vec<BrilligBytecode<F>>,
 }
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct Circuit {
+pub struct Circuit<F> {
     // current_witness_index is the highest witness index in the circuit. The next witness to be added to this circuit
     // will take on this value. (The value is cached here as an optimization.)
     pub current_witness_index: u32,
-    pub opcodes: Vec<Opcode>,
+    pub opcodes: Vec<Opcode<F>>,
     pub expression_width: ExpressionWidth,
 
     /// The set of private inputs to the circuit.
@@ -67,7 +67,7 @@ pub struct Circuit {
     // Note: This should be a BTreeMap, but serde-reflect is creating invalid
     // c++ code at the moment when it is, due to OpcodeLocation needing a comparison
     // implementation which is never generated.
-    pub assert_messages: Vec<(OpcodeLocation, AssertionPayload)>,
+    pub assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>,
 
     /// States whether the backend should use a SNARK recursion friendly prover.
     /// If implemented by a backend, this means that proofs generated with this circuit
@@ -76,15 +76,15 @@ pub struct Circuit {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum ExpressionOrMemory {
-    Expression(Expression),
+pub enum ExpressionOrMemory<F> {
+    Expression(Expression<F>),
     Memory(BlockId),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AssertionPayload {
+pub enum AssertionPayload<F> {
     StaticString(String),
-    Dynamic(/* error_selector */ u64, Vec<ExpressionOrMemory>),
+    Dynamic(/* error_selector */ u64, Vec<ExpressionOrMemory<F>>),
 }
 
 #[derive(Debug, Copy, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
@@ -127,15 +127,15 @@ impl<'de> Deserialize<'de> for ErrorSelector {
 pub const STRING_ERROR_SELECTOR: ErrorSelector = ErrorSelector(0);
 
 #[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
-pub struct RawAssertionPayload {
+pub struct RawAssertionPayload<F> {
     pub selector: ErrorSelector,
-    pub data: Vec<FieldElement>,
+    pub data: Vec<F>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub enum ResolvedAssertionPayload {
+pub enum ResolvedAssertionPayload<F> {
     String(String),
-    Raw(RawAssertionPayload),
+    Raw(RawAssertionPayload<F>),
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -204,7 +204,7 @@ impl FromStr for OpcodeLocation {
     }
 }
 
-impl Circuit {
+impl<F: AcirField> Circuit<F> {
     pub fn num_vars(&self) -> u32 {
         self.current_witness_index + 1
     }
@@ -223,7 +223,7 @@ impl Circuit {
     }
 }
 
-impl Program {
+impl<F: Serialize> Program<F> {
     fn write<W: std::io::Write>(&self, writer: W) -> std::io::Result<()> {
         let buf = bincode::serialize(self).unwrap();
         let mut encoder = flate2::write::GzEncoder::new(writer, Compression::default());
@@ -232,26 +232,14 @@ impl Program {
         Ok(())
     }
 
-    fn read<R: std::io::Read>(reader: R) -> std::io::Result<Self> {
-        let mut gz_decoder = flate2::read::GzDecoder::new(reader);
-        let mut buf_d = Vec::new();
-        gz_decoder.read_to_end(&mut buf_d)?;
-        bincode::deserialize(&buf_d)
-            .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))
-    }
-
-    pub fn serialize_program(program: &Program) -> Vec<u8> {
+    pub fn serialize_program(program: &Self) -> Vec<u8> {
         let mut program_bytes: Vec<u8> = Vec::new();
         program.write(&mut program_bytes).expect("expected circuit to be serializable");
         program_bytes
     }
 
-    pub fn deserialize_program(serialized_circuit: &[u8]) -> std::io::Result<Self> {
-        Program::read(serialized_circuit)
-    }
-
     // Serialize and base64 encode program
-    pub fn serialize_program_base64<S>(program: &Program, s: S) -> Result<S::Ok, S::Error>
+    pub fn serialize_program_base64<S>(program: &Self, s: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
@@ -259,9 +247,23 @@ impl Program {
         let encoded_b64 = base64::engine::general_purpose::STANDARD.encode(program_bytes);
         s.serialize_str(&encoded_b64)
     }
+}
+
+impl<F: for<'a> Deserialize<'a>> Program<F> {
+    fn read<R: std::io::Read>(reader: R) -> std::io::Result<Self> {
+        let mut gz_decoder = flate2::read::GzDecoder::new(reader);
+        let mut buf_d = Vec::new();
+        gz_decoder.read_to_end(&mut buf_d)?;
+        bincode::deserialize(&buf_d)
+            .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))
+    }
+
+    pub fn deserialize_program(serialized_circuit: &[u8]) -> std::io::Result<Self> {
+        Program::read(serialized_circuit)
+    }
 
     // Deserialize and base64 decode program
-    pub fn deserialize_program_base64<'de, D>(deserializer: D) -> Result<Program, D::Error>
+    pub fn deserialize_program_base64<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
@@ -274,7 +276,7 @@ impl Program {
     }
 }
 
-impl std::fmt::Display for Circuit {
+impl<F: AcirField> std::fmt::Display for Circuit<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "current witness index : {}", self.current_witness_index)?;
 
@@ -313,13 +315,13 @@ impl std::fmt::Display for Circuit {
     }
 }
 
-impl std::fmt::Debug for Circuit {
+impl<F: AcirField> std::fmt::Debug for Circuit<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self, f)
     }
 }
 
-impl std::fmt::Display for Program {
+impl<F: AcirField> std::fmt::Display for Program<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for (func_index, function) in self.functions.iter().enumerate() {
             writeln!(f, "func {}", func_index)?;
@@ -333,7 +335,7 @@ impl std::fmt::Display for Program {
     }
 }
 
-impl std::fmt::Debug for Program {
+impl<F: AcirField> std::fmt::Debug for Program<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self, f)
     }
@@ -365,21 +367,22 @@ mod tests {
         circuit::{ExpressionWidth, Program},
         native_types::Witness,
     };
-    use acir_field::FieldElement;
+    use acir_field::{AcirField, FieldElement};
+    use serde::{Deserialize, Serialize};
 
-    fn and_opcode() -> Opcode {
+    fn and_opcode<F: AcirField>() -> Opcode<F> {
         Opcode::BlackBoxFuncCall(BlackBoxFuncCall::AND {
             lhs: FunctionInput { witness: Witness(1), num_bits: 4 },
             rhs: FunctionInput { witness: Witness(2), num_bits: 4 },
             output: Witness(3),
         })
     }
-    fn range_opcode() -> Opcode {
+    fn range_opcode<F: AcirField>() -> Opcode<F> {
         Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
             input: FunctionInput { witness: Witness(1), num_bits: 8 },
         })
     }
-    fn keccakf1600_opcode() -> Opcode {
+    fn keccakf1600_opcode<F: AcirField>() -> Opcode<F> {
         let inputs: Box<[FunctionInput; 25]> = Box::new(std::array::from_fn(|i| FunctionInput {
             witness: Witness(i as u32 + 1),
             num_bits: 8,
@@ -388,7 +391,7 @@ mod tests {
 
         Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 { inputs, outputs })
     }
-    fn schnorr_verify_opcode() -> Opcode {
+    fn schnorr_verify_opcode<F: AcirField>() -> Opcode<F> {
         let public_key_x =
             FunctionInput { witness: Witness(1), num_bits: FieldElement::max_num_bits() };
         let public_key_y =
@@ -413,7 +416,7 @@ mod tests {
         let circuit = Circuit {
             current_witness_index: 5,
             expression_width: ExpressionWidth::Unbounded,
-            opcodes: vec![and_opcode(), range_opcode(), schnorr_verify_opcode()],
+            opcodes: vec![and_opcode::<FieldElement>(), range_opcode(), schnorr_verify_opcode()],
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(12)])),
             return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(4), Witness(12)])),
@@ -422,7 +425,9 @@ mod tests {
         };
         let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
-        fn read_write(program: Program) -> (Program, Program) {
+        fn read_write<F: AcirField + Serialize + for<'a> Deserialize<'a>>(
+            program: Program<F>,
+        ) -> (Program<F>, Program<F>) {
             let bytes = Program::serialize_program(&program);
             let got_program = Program::deserialize_program(&bytes).unwrap();
             (program, got_program)
@@ -475,7 +480,8 @@ mod tests {
         encoder.write_all(bad_circuit).unwrap();
         encoder.finish().unwrap();
 
-        let deserialization_result = Program::deserialize_program(&zipped_bad_circuit);
+        let deserialization_result: Result<Program<FieldElement>, _> =
+            Program::deserialize_program(&zipped_bad_circuit);
         assert!(deserialization_result.is_err());
     }
 }
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index 6043196dfff..20c6903dc52 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -3,6 +3,7 @@ use super::{
     directives::Directive,
 };
 use crate::native_types::{Expression, Witness};
+use acir_field::AcirField;
 use serde::{Deserialize, Serialize};
 
 mod black_box_function_call;
@@ -26,19 +27,19 @@ impl BlockType {
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Opcode {
-    AssertZero(Expression),
+pub enum Opcode<F> {
+    AssertZero(Expression<F>),
     /// Calls to "gadgets" which rely on backends implementing support for specialized constraints.
     ///
     /// Often used for exposing more efficient implementations of SNARK-unfriendly computations.  
     BlackBoxFuncCall(BlackBoxFuncCall),
-    Directive(Directive),
+    Directive(Directive<F>),
     /// Atomic operation on a block of memory
     MemoryOp {
         block_id: BlockId,
-        op: MemOp,
+        op: MemOp<F>,
         /// Predicate of the memory operation - indicates if it should be skipped
-        predicate: Option<Expression>,
+        predicate: Option<Expression<F>>,
     },
     MemoryInit {
         block_id: BlockId,
@@ -51,11 +52,11 @@ pub enum Opcode {
         /// to fetch the appropriate Brillig bytecode from this id.
         id: u32,
         /// Inputs to the function call
-        inputs: Vec<BrilligInputs>,
+        inputs: Vec<BrilligInputs<F>>,
         /// Outputs to the function call
         outputs: Vec<BrilligOutputs>,
         /// Predicate of the Brillig execution - indicates if it should be skipped
-        predicate: Option<Expression>,
+        predicate: Option<Expression<F>>,
     },
     /// Calls to functions represented as a separate circuit. A call opcode allows us
     /// to build a call stack when executing the outer-most circuit.
@@ -68,11 +69,11 @@ pub enum Opcode {
         /// Outputs of the function call
         outputs: Vec<Witness>,
         /// Predicate of the circuit execution - indicates if it should be skipped
-        predicate: Option<Expression>,
+        predicate: Option<Expression<F>>,
     },
 }
 
-impl std::fmt::Display for Opcode {
+impl<F: AcirField> std::fmt::Display for Opcode<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Opcode::AssertZero(expr) => {
@@ -147,7 +148,7 @@ impl std::fmt::Display for Opcode {
     }
 }
 
-impl std::fmt::Debug for Opcode {
+impl<F: AcirField> std::fmt::Debug for Opcode<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self, f)
     }
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index b0e77b15c2c..362e9ba5936 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -481,11 +481,11 @@ where
 mod tests {
 
     use crate::{circuit::Opcode, native_types::Witness};
-    use acir_field::FieldElement;
+    use acir_field::{AcirField, FieldElement};
 
     use super::{BlackBoxFuncCall, FunctionInput};
 
-    fn keccakf1600_opcode() -> Opcode {
+    fn keccakf1600_opcode<F: AcirField>() -> Opcode<F> {
         let inputs: Box<[FunctionInput; 25]> = Box::new(std::array::from_fn(|i| FunctionInput {
             witness: Witness(i as u32 + 1),
             num_bits: 8,
@@ -494,7 +494,7 @@ mod tests {
 
         Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 { inputs, outputs })
     }
-    fn schnorr_verify_opcode() -> Opcode {
+    fn schnorr_verify_opcode<F: AcirField>() -> Opcode<F> {
         let public_key_x =
             FunctionInput { witness: Witness(1), num_bits: FieldElement::max_num_bits() };
         let public_key_y =
@@ -516,7 +516,7 @@ mod tests {
 
     #[test]
     fn keccakf1600_serialization_roundtrip() {
-        let opcode = keccakf1600_opcode();
+        let opcode = keccakf1600_opcode::<FieldElement>();
         let buf = bincode::serialize(&opcode).unwrap();
         let recovered_opcode = bincode::deserialize(&buf).unwrap();
         assert_eq!(opcode, recovered_opcode);
@@ -524,7 +524,7 @@ mod tests {
 
     #[test]
     fn schnorr_serialization_roundtrip() {
-        let opcode = schnorr_verify_opcode();
+        let opcode = schnorr_verify_opcode::<FieldElement>();
         let buf = bincode::serialize(&opcode).unwrap();
         let recovered_opcode = bincode::deserialize(&buf).unwrap();
         assert_eq!(opcode, recovered_opcode);
diff --git a/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs b/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
index 0e94c0f051e..2147e7430b2 100644
--- a/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
@@ -1,4 +1,5 @@
 use crate::native_types::{Expression, Witness};
+use acir_field::AcirField;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash, Copy, Default)]
@@ -7,22 +8,22 @@ pub struct BlockId(pub u32);
 /// Operation on a block of memory
 /// We can either write or read at an index in memory
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub struct MemOp {
+pub struct MemOp<F> {
     /// Can be 0 (read) or 1 (write)
-    pub operation: Expression,
-    pub index: Expression,
-    pub value: Expression,
+    pub operation: Expression<F>,
+    pub index: Expression<F>,
+    pub value: Expression<F>,
 }
 
-impl MemOp {
+impl<F: AcirField> MemOp<F> {
     /// Creates a `MemOp` which reads from memory at `index` and inserts the read value
     /// into the [`WitnessMap`][crate::native_types::WitnessMap] at `witness`
-    pub fn read_at_mem_index(index: Expression, witness: Witness) -> Self {
+    pub fn read_at_mem_index(index: Expression<F>, witness: Witness) -> Self {
         MemOp { operation: Expression::zero(), index, value: witness.into() }
     }
 
     /// Creates a `MemOp` which writes the [`Expression`] `value` into memory at `index`.
-    pub fn write_to_mem_index(index: Expression, value: Expression) -> Self {
+    pub fn write_to_mem_index(index: Expression<F>, value: Expression<F>) -> Self {
         MemOp { operation: Expression::one(), index, value }
     }
 }
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index f60f1b46b6a..f064cfaca0e 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -9,7 +9,7 @@ pub mod circuit;
 pub mod native_types;
 
 pub use acir_field;
-pub use acir_field::FieldElement;
+pub use acir_field::{AcirField, FieldElement};
 pub use brillig;
 pub use circuit::black_box_functions::BlackBoxFunc;
 
@@ -31,6 +31,7 @@ mod reflection {
         path::{Path, PathBuf},
     };
 
+    use acir_field::FieldElement;
     use brillig::{
         BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapValueType, Opcode as BrilligOpcode,
         ValueOrArray,
@@ -61,23 +62,23 @@ mod reflection {
 
         let mut tracer = Tracer::new(TracerConfig::default());
         tracer.trace_simple_type::<BlockType>().unwrap();
-        tracer.trace_simple_type::<Program>().unwrap();
-        tracer.trace_simple_type::<Circuit>().unwrap();
+        tracer.trace_simple_type::<Program<FieldElement>>().unwrap();
+        tracer.trace_simple_type::<Circuit<FieldElement>>().unwrap();
         tracer.trace_simple_type::<ExpressionWidth>().unwrap();
-        tracer.trace_simple_type::<Opcode>().unwrap();
+        tracer.trace_simple_type::<Opcode<FieldElement>>().unwrap();
         tracer.trace_simple_type::<OpcodeLocation>().unwrap();
         tracer.trace_simple_type::<BinaryFieldOp>().unwrap();
         tracer.trace_simple_type::<BlackBoxFuncCall>().unwrap();
-        tracer.trace_simple_type::<BrilligInputs>().unwrap();
+        tracer.trace_simple_type::<BrilligInputs<FieldElement>>().unwrap();
         tracer.trace_simple_type::<BrilligOutputs>().unwrap();
-        tracer.trace_simple_type::<BrilligOpcode>().unwrap();
+        tracer.trace_simple_type::<BrilligOpcode<FieldElement>>().unwrap();
         tracer.trace_simple_type::<BinaryIntOp>().unwrap();
         tracer.trace_simple_type::<BlackBoxOp>().unwrap();
-        tracer.trace_simple_type::<Directive>().unwrap();
+        tracer.trace_simple_type::<Directive<FieldElement>>().unwrap();
         tracer.trace_simple_type::<ValueOrArray>().unwrap();
         tracer.trace_simple_type::<HeapValueType>().unwrap();
-        tracer.trace_simple_type::<AssertionPayload>().unwrap();
-        tracer.trace_simple_type::<ExpressionOrMemory>().unwrap();
+        tracer.trace_simple_type::<AssertionPayload<FieldElement>>().unwrap();
+        tracer.trace_simple_type::<ExpressionOrMemory<FieldElement>>().unwrap();
 
         let registry = tracer.registry().unwrap();
 
@@ -110,8 +111,8 @@ mod reflection {
 
         let mut tracer = Tracer::new(TracerConfig::default());
         tracer.trace_simple_type::<Witness>().unwrap();
-        tracer.trace_simple_type::<WitnessMap>().unwrap();
-        tracer.trace_simple_type::<WitnessStack>().unwrap();
+        tracer.trace_simple_type::<WitnessMap<FieldElement>>().unwrap();
+        tracer.trace_simple_type::<WitnessStack<FieldElement>>().unwrap();
 
         let registry = tracer.registry().unwrap();
 
diff --git a/acvm-repo/acir/src/native_types/expression/mod.rs b/acvm-repo/acir/src/native_types/expression/mod.rs
index 402aa3eb3a6..b34862429e7 100644
--- a/acvm-repo/acir/src/native_types/expression/mod.rs
+++ b/acvm-repo/acir/src/native_types/expression/mod.rs
@@ -1,8 +1,7 @@
 use crate::native_types::Witness;
-use acir_field::FieldElement;
+use acir_field::AcirField;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
-
 mod operators;
 mod ordering;
 
@@ -14,30 +13,26 @@ mod ordering;
 // In the multiplication polynomial
 // XXX: If we allow the degree of the quotient polynomial to be arbitrary, then we will need a vector of wire values
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
-pub struct Expression {
+pub struct Expression<F> {
     // To avoid having to create intermediate variables pre-optimization
     // We collect all of the multiplication terms in the assert-zero opcode
     // A multiplication term if of the form q_M * wL * wR
     // Hence this vector represents the following sum: q_M1 * wL1 * wR1 + q_M2 * wL2 * wR2 + .. +
-    pub mul_terms: Vec<(FieldElement, Witness, Witness)>,
+    pub mul_terms: Vec<(F, Witness, Witness)>,
 
-    pub linear_combinations: Vec<(FieldElement, Witness)>,
+    pub linear_combinations: Vec<(F, Witness)>,
     // TODO: rename q_c to `constant` moreover q_X is not clear to those who
     // TODO are not familiar with PLONK
-    pub q_c: FieldElement,
+    pub q_c: F,
 }
 
-impl Default for Expression {
-    fn default() -> Expression {
-        Expression {
-            mul_terms: Vec::new(),
-            linear_combinations: Vec::new(),
-            q_c: FieldElement::zero(),
-        }
+impl<F: AcirField> Default for Expression<F> {
+    fn default() -> Self {
+        Expression { mul_terms: Vec::new(), linear_combinations: Vec::new(), q_c: F::zero() }
     }
 }
 
-impl std::fmt::Display for Expression {
+impl<F: AcirField> std::fmt::Display for Expression<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         if let Some(witness) = self.to_witness() {
             write!(f, "x{}", witness.witness_index())
@@ -47,7 +42,7 @@ impl std::fmt::Display for Expression {
     }
 }
 
-impl Expression {
+impl<F: AcirField> Expression<F> {
     // TODO: possibly remove, and move to noir repo.
     pub const fn can_defer_constraint(&self) -> bool {
         false
@@ -58,30 +53,25 @@ impl Expression {
         self.mul_terms.len()
     }
 
-    pub fn from_field(q_c: FieldElement) -> Expression {
+    pub fn from_field(q_c: F) -> Self {
         Self { q_c, ..Default::default() }
     }
 
-    pub fn one() -> Expression {
-        Self::from_field(FieldElement::one())
+    pub fn one() -> Self {
+        Self::from_field(F::one())
     }
 
-    pub fn zero() -> Expression {
+    pub fn zero() -> Self {
         Self::default()
     }
 
     /// Adds a new linear term to the `Expression`.
-    pub fn push_addition_term(&mut self, coefficient: FieldElement, variable: Witness) {
+    pub fn push_addition_term(&mut self, coefficient: F, variable: Witness) {
         self.linear_combinations.push((coefficient, variable));
     }
 
     /// Adds a new quadratic term to the `Expression`.
-    pub fn push_multiplication_term(
-        &mut self,
-        coefficient: FieldElement,
-        lhs: Witness,
-        rhs: Witness,
-    ) {
+    pub fn push_multiplication_term(&mut self, coefficient: F, lhs: Witness, rhs: Witness) {
         self.mul_terms.push((coefficient, lhs, rhs));
     }
 
@@ -145,7 +135,7 @@ impl Expression {
     /// - f(x,y) = 2*y + 6 would return `None`
     /// - f(x,y) = x + y would return `None`
     /// - f(x,y) = 5 would return `FieldElement(5)`
-    pub fn to_const(&self) -> Option<FieldElement> {
+    pub fn to_const(&self) -> Option<F> {
         self.is_const().then_some(self.q_c)
     }
 
@@ -216,7 +206,7 @@ impl Expression {
         let mul_term = &self.mul_terms[0];
 
         // The coefficient should be non-zero, as this method is ran after the compiler removes all zero coefficient terms
-        assert_ne!(mul_term.0, FieldElement::zero());
+        assert_ne!(mul_term.0, F::zero());
 
         let mut found_x = false;
         let mut found_y = false;
@@ -240,18 +230,19 @@ impl Expression {
     }
 
     /// Returns `self + k*b`
-    pub fn add_mul(&self, k: FieldElement, b: &Expression) -> Expression {
+    pub fn add_mul(&self, k: F, b: &Self) -> Self {
         if k.is_zero() {
             return self.clone();
         } else if self.is_const() {
-            return self.q_c + (k * b);
+            let kb = b * k;
+            return kb + self.q_c;
         } else if b.is_const() {
             return self.clone() + (k * b.q_c);
         }
 
-        let mut mul_terms: Vec<(FieldElement, Witness, Witness)> =
+        let mut mul_terms: Vec<(F, Witness, Witness)> =
             Vec::with_capacity(self.mul_terms.len() + b.mul_terms.len());
-        let mut linear_combinations: Vec<(FieldElement, Witness)> =
+        let mut linear_combinations: Vec<(F, Witness)> =
             Vec::with_capacity(self.linear_combinations.len() + b.linear_combinations.len());
         let q_c = self.q_c + k * b.q_c;
 
@@ -338,7 +329,7 @@ impl Expression {
         while i2 < b.mul_terms.len() {
             let (b_c, b_wl, b_wr) = b.mul_terms[i2];
             let coeff = b_c * k;
-            if coeff != FieldElement::zero() {
+            if coeff != F::zero() {
                 mul_terms.push((coeff, b_wl, b_wr));
             }
             i2 += 1;
@@ -348,57 +339,63 @@ impl Expression {
     }
 }
 
-impl From<FieldElement> for Expression {
-    fn from(constant: FieldElement) -> Expression {
+impl<F: AcirField> From<F> for Expression<F> {
+    fn from(constant: F) -> Self {
         Expression { q_c: constant, linear_combinations: Vec::new(), mul_terms: Vec::new() }
     }
 }
 
-impl From<Witness> for Expression {
+impl<F: AcirField> From<Witness> for Expression<F> {
     /// Creates an Expression from a Witness.
     ///
     /// This is infallible since an `Expression` is
     /// a multi-variate polynomial and a `Witness`
     /// can be seen as a univariate polynomial
-    fn from(wit: Witness) -> Expression {
+    fn from(wit: Witness) -> Self {
         Expression {
-            q_c: FieldElement::zero(),
-            linear_combinations: vec![(FieldElement::one(), wit)],
+            q_c: F::zero(),
+            linear_combinations: vec![(F::one(), wit)],
             mul_terms: Vec::new(),
         }
     }
 }
 
-#[test]
-fn add_mul_smoketest() {
-    let a = Expression {
-        mul_terms: vec![(FieldElement::from(2u128), Witness(1), Witness(2))],
-        ..Default::default()
-    };
-
-    let k = FieldElement::from(10u128);
-
-    let b = Expression {
-        mul_terms: vec![
-            (FieldElement::from(3u128), Witness(0), Witness(2)),
-            (FieldElement::from(3u128), Witness(1), Witness(2)),
-            (FieldElement::from(4u128), Witness(4), Witness(5)),
-        ],
-        linear_combinations: vec![(FieldElement::from(4u128), Witness(4))],
-        q_c: FieldElement::one(),
-    };
-
-    let result = a.add_mul(k, &b);
-    assert_eq!(
-        result,
-        Expression {
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use acir_field::{AcirField, FieldElement};
+
+    #[test]
+    fn add_mul_smoketest() {
+        let a = Expression {
+            mul_terms: vec![(FieldElement::from(2u128), Witness(1), Witness(2))],
+            ..Default::default()
+        };
+
+        let k = FieldElement::from(10u128);
+
+        let b = Expression {
             mul_terms: vec![
-                (FieldElement::from(30u128), Witness(0), Witness(2)),
-                (FieldElement::from(32u128), Witness(1), Witness(2)),
-                (FieldElement::from(40u128), Witness(4), Witness(5)),
+                (FieldElement::from(3u128), Witness(0), Witness(2)),
+                (FieldElement::from(3u128), Witness(1), Witness(2)),
+                (FieldElement::from(4u128), Witness(4), Witness(5)),
             ],
-            linear_combinations: vec![(FieldElement::from(40u128), Witness(4))],
-            q_c: FieldElement::from(10u128)
-        }
-    );
+            linear_combinations: vec![(FieldElement::from(4u128), Witness(4))],
+            q_c: FieldElement::one(),
+        };
+
+        let result = a.add_mul(k, &b);
+        assert_eq!(
+            result,
+            Expression {
+                mul_terms: vec![
+                    (FieldElement::from(30u128), Witness(0), Witness(2)),
+                    (FieldElement::from(32u128), Witness(1), Witness(2)),
+                    (FieldElement::from(40u128), Witness(4), Witness(5)),
+                ],
+                linear_combinations: vec![(FieldElement::from(40u128), Witness(4))],
+                q_c: FieldElement::from(10u128)
+            }
+        );
+    }
 }
diff --git a/acvm-repo/acir/src/native_types/expression/operators.rs b/acvm-repo/acir/src/native_types/expression/operators.rs
index 29cdc6967bb..a8f5dc8e7ad 100644
--- a/acvm-repo/acir/src/native_types/expression/operators.rs
+++ b/acvm-repo/acir/src/native_types/expression/operators.rs
@@ -1,5 +1,5 @@
 use crate::native_types::Witness;
-use acir_field::FieldElement;
+use acir_field::AcirField;
 use std::{
     cmp::Ordering,
     ops::{Add, Mul, Neg, Sub},
@@ -9,8 +9,8 @@ use super::Expression;
 
 // Negation
 
-impl Neg for &Expression {
-    type Output = Expression;
+impl<F: AcirField> Neg for &Expression<F> {
+    type Output = Expression<F>;
     fn neg(self) -> Self::Output {
         // XXX(med) : Implement an efficient way to do this
 
@@ -27,9 +27,9 @@ impl Neg for &Expression {
 
 // FieldElement
 
-impl Add<FieldElement> for Expression {
-    type Output = Expression;
-    fn add(self, rhs: FieldElement) -> Self::Output {
+impl<F: AcirField> Add<F> for Expression<F> {
+    type Output = Self;
+    fn add(self, rhs: F) -> Self::Output {
         // Increase the constant
         let q_c = self.q_c + rhs;
 
@@ -37,17 +37,9 @@ impl Add<FieldElement> for Expression {
     }
 }
 
-impl Add<Expression> for FieldElement {
-    type Output = Expression;
-    #[inline]
-    fn add(self, rhs: Expression) -> Self::Output {
-        rhs + self
-    }
-}
-
-impl Sub<FieldElement> for Expression {
-    type Output = Expression;
-    fn sub(self, rhs: FieldElement) -> Self::Output {
+impl<F: AcirField> Sub<F> for Expression<F> {
+    type Output = Self;
+    fn sub(self, rhs: F) -> Self::Output {
         // Increase the constant
         let q_c = self.q_c - rhs;
 
@@ -55,17 +47,9 @@ impl Sub<FieldElement> for Expression {
     }
 }
 
-impl Sub<Expression> for FieldElement {
-    type Output = Expression;
-    #[inline]
-    fn sub(self, rhs: Expression) -> Self::Output {
-        rhs - self
-    }
-}
-
-impl Mul<FieldElement> for &Expression {
-    type Output = Expression;
-    fn mul(self, rhs: FieldElement) -> Self::Output {
+impl<F: AcirField> Mul<F> for &Expression<F> {
+    type Output = Expression<F>;
+    fn mul(self, rhs: F) -> Self::Output {
         // Scale the mul terms
         let mul_terms: Vec<_> =
             self.mul_terms.iter().map(|(q_m, w_l, w_r)| (*q_m * rhs, *w_l, *w_r)).collect();
@@ -81,42 +65,34 @@ impl Mul<FieldElement> for &Expression {
     }
 }
 
-impl Mul<&Expression> for FieldElement {
-    type Output = Expression;
-    #[inline]
-    fn mul(self, rhs: &Expression) -> Self::Output {
-        rhs * self
-    }
-}
-
 // Witness
 
-impl Add<Witness> for &Expression {
-    type Output = Expression;
-    fn add(self, rhs: Witness) -> Expression {
+impl<F: AcirField> Add<Witness> for &Expression<F> {
+    type Output = Expression<F>;
+    fn add(self, rhs: Witness) -> Self::Output {
         self + &Expression::from(rhs)
     }
 }
 
-impl Add<&Expression> for Witness {
-    type Output = Expression;
+impl<F: AcirField> Add<&Expression<F>> for Witness {
+    type Output = Expression<F>;
     #[inline]
-    fn add(self, rhs: &Expression) -> Expression {
+    fn add(self, rhs: &Expression<F>) -> Self::Output {
         rhs + self
     }
 }
 
-impl Sub<Witness> for &Expression {
-    type Output = Expression;
-    fn sub(self, rhs: Witness) -> Expression {
+impl<F: AcirField> Sub<Witness> for &Expression<F> {
+    type Output = Expression<F>;
+    fn sub(self, rhs: Witness) -> Self::Output {
         self - &Expression::from(rhs)
     }
 }
 
-impl Sub<&Expression> for Witness {
-    type Output = Expression;
+impl<F: AcirField> Sub<&Expression<F>> for Witness {
+    type Output = Expression<F>;
     #[inline]
-    fn sub(self, rhs: &Expression) -> Expression {
+    fn sub(self, rhs: &Expression<F>) -> Self::Output {
         rhs - self
     }
 }
@@ -125,25 +101,25 @@ impl Sub<&Expression> for Witness {
 
 // Expression
 
-impl Add<&Expression> for &Expression {
-    type Output = Expression;
-    fn add(self, rhs: &Expression) -> Expression {
-        self.add_mul(FieldElement::one(), rhs)
+impl<F: AcirField> Add<&Expression<F>> for &Expression<F> {
+    type Output = Expression<F>;
+    fn add(self, rhs: &Expression<F>) -> Self::Output {
+        self.add_mul(F::one(), rhs)
     }
 }
 
-impl Sub<&Expression> for &Expression {
-    type Output = Expression;
-    fn sub(self, rhs: &Expression) -> Expression {
-        self.add_mul(-FieldElement::one(), rhs)
+impl<F: AcirField> Sub<&Expression<F>> for &Expression<F> {
+    type Output = Expression<F>;
+    fn sub(self, rhs: &Expression<F>) -> Self::Output {
+        self.add_mul(-F::one(), rhs)
     }
 }
 
-impl Mul<&Expression> for &Expression {
-    type Output = Option<Expression>;
-    fn mul(self, rhs: &Expression) -> Option<Expression> {
+impl<F: AcirField> Mul<&Expression<F>> for &Expression<F> {
+    type Output = Option<Expression<F>>;
+    fn mul(self, rhs: &Expression<F>) -> Self::Output {
         if self.is_const() {
-            return Some(self.q_c * rhs);
+            return Some(rhs * self.q_c);
         } else if rhs.is_const() {
             return Some(self * rhs.q_c);
         } else if !(self.is_linear() && rhs.is_linear()) {
@@ -215,7 +191,7 @@ impl Mul<&Expression> for &Expression {
 }
 
 /// Returns `w*b.linear_combinations`
-fn single_mul(w: Witness, b: &Expression) -> Expression {
+fn single_mul<F: AcirField>(w: Witness, b: &Expression<F>) -> Expression<F> {
     Expression {
         mul_terms: b
             .linear_combinations
@@ -229,62 +205,68 @@ fn single_mul(w: Witness, b: &Expression) -> Expression {
     }
 }
 
-#[test]
-fn add_smoke_test() {
-    let a = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![(FieldElement::from(2u128), Witness(2))],
-        q_c: FieldElement::from(2u128),
-    };
-
-    let b = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![(FieldElement::from(4u128), Witness(4))],
-        q_c: FieldElement::one(),
-    };
-
-    assert_eq!(
-        &a + &b,
-        Expression {
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use acir_field::{AcirField, FieldElement};
+
+    #[test]
+    fn add_smoke_test() {
+        let a = Expression {
             mul_terms: vec![],
-            linear_combinations: vec![
-                (FieldElement::from(2u128), Witness(2)),
-                (FieldElement::from(4u128), Witness(4))
-            ],
-            q_c: FieldElement::from(3u128)
-        }
-    );
+            linear_combinations: vec![(FieldElement::from(2u128), Witness(2))],
+            q_c: FieldElement::from(2u128),
+        };
 
-    // Enforce commutativity
-    assert_eq!(&a + &b, &b + &a);
-}
+        let b = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![(FieldElement::from(4u128), Witness(4))],
+            q_c: FieldElement::one(),
+        };
+
+        assert_eq!(
+            &a + &b,
+            Expression {
+                mul_terms: vec![],
+                linear_combinations: vec![
+                    (FieldElement::from(2u128), Witness(2)),
+                    (FieldElement::from(4u128), Witness(4))
+                ],
+                q_c: FieldElement::from(3u128)
+            }
+        );
 
-#[test]
-fn mul_smoke_test() {
-    let a = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![(FieldElement::from(2u128), Witness(2))],
-        q_c: FieldElement::from(2u128),
-    };
-
-    let b = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![(FieldElement::from(4u128), Witness(4))],
-        q_c: FieldElement::one(),
-    };
-
-    assert_eq!(
-        (&a * &b).unwrap(),
-        Expression {
-            mul_terms: vec![(FieldElement::from(8u128), Witness(2), Witness(4)),],
-            linear_combinations: vec![
-                (FieldElement::from(2u128), Witness(2)),
-                (FieldElement::from(8u128), Witness(4))
-            ],
-            q_c: FieldElement::from(2u128)
-        }
-    );
+        // Enforce commutativity
+        assert_eq!(&a + &b, &b + &a);
+    }
 
-    // Enforce commutativity
-    assert_eq!(&a * &b, &b * &a);
+    #[test]
+    fn mul_smoke_test() {
+        let a = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![(FieldElement::from(2u128), Witness(2))],
+            q_c: FieldElement::from(2u128),
+        };
+
+        let b = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![(FieldElement::from(4u128), Witness(4))],
+            q_c: FieldElement::one(),
+        };
+
+        assert_eq!(
+            (&a * &b).unwrap(),
+            Expression {
+                mul_terms: vec![(FieldElement::from(8u128), Witness(2), Witness(4)),],
+                linear_combinations: vec![
+                    (FieldElement::from(2u128), Witness(2)),
+                    (FieldElement::from(8u128), Witness(4))
+                ],
+                q_c: FieldElement::from(2u128)
+            }
+        );
+
+        // Enforce commutativity
+        assert_eq!(&a * &b, &b * &a);
+    }
 }
diff --git a/acvm-repo/acir/src/native_types/expression/ordering.rs b/acvm-repo/acir/src/native_types/expression/ordering.rs
index e24a25ec3af..b0e5e88454f 100644
--- a/acvm-repo/acir/src/native_types/expression/ordering.rs
+++ b/acvm-repo/acir/src/native_types/expression/ordering.rs
@@ -1,3 +1,5 @@
+use acir_field::AcirField;
+
 use crate::native_types::Witness;
 use std::cmp::Ordering;
 
@@ -6,7 +8,7 @@ use super::Expression;
 // TODO: It's undecided whether `Expression` should implement `Ord/PartialOrd`.
 // This is currently used in ACVM in the compiler.
 
-impl Ord for Expression {
+impl<F: AcirField> Ord for Expression<F> {
     fn cmp(&self, other: &Self) -> Ordering {
         let mut i1 = self.get_max_idx();
         let mut i2 = other.get_max_idx();
@@ -17,13 +19,13 @@ impl Ord for Expression {
             if m1.is_none() && m2.is_none() {
                 return Ordering::Equal;
             }
-            result = Expression::cmp_max(m1, m2);
+            result = Expression::<F>::cmp_max(m1, m2);
         }
         result
     }
 }
 
-impl PartialOrd for Expression {
+impl<F: AcirField> PartialOrd for Expression<F> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
@@ -35,7 +37,7 @@ struct WitnessIdx {
     second_term: bool,
 }
 
-impl Expression {
+impl<F: AcirField> Expression<F> {
     fn get_max_idx(&self) -> WitnessIdx {
         WitnessIdx {
             linear: self.linear_combinations.len(),
diff --git a/acvm-repo/acir/src/native_types/witness.rs b/acvm-repo/acir/src/native_types/witness.rs
index 740d10d2951..3e9beb510bc 100644
--- a/acvm-repo/acir/src/native_types/witness.rs
+++ b/acvm-repo/acir/src/native_types/witness.rs
@@ -1,10 +1,5 @@
-use std::ops::Add;
-
-use acir_field::FieldElement;
 use serde::{Deserialize, Serialize};
 
-use super::Expression;
-
 // Witness might be a misnomer. This is an index that represents the position a witness will take
 #[derive(
     Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize,
@@ -33,11 +28,3 @@ impl From<u32> for Witness {
         Self(value)
     }
 }
-
-impl Add<Witness> for Witness {
-    type Output = Expression;
-
-    fn add(self, rhs: Witness) -> Self::Output {
-        Expression::from(self).add_mul(FieldElement::one(), &Expression::from(rhs))
-    }
-}
diff --git a/acvm-repo/acir/src/native_types/witness_map.rs b/acvm-repo/acir/src/native_types/witness_map.rs
index 00245d5842c..e508fe5b186 100644
--- a/acvm-repo/acir/src/native_types/witness_map.rs
+++ b/acvm-repo/acir/src/native_types/witness_map.rs
@@ -4,7 +4,6 @@ use std::{
     ops::Index,
 };
 
-use acir_field::FieldElement;
 use flate2::bufread::GzDecoder;
 use flate2::bufread::GzEncoder;
 use flate2::Compression;
@@ -25,63 +24,63 @@ pub struct WitnessMapError(#[from] SerializationError);
 
 /// A map from the witnesses in a constraint system to the field element values
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
-pub struct WitnessMap(BTreeMap<Witness, FieldElement>);
+pub struct WitnessMap<F>(BTreeMap<Witness, F>);
 
-impl WitnessMap {
+impl<F> WitnessMap<F> {
     pub fn new() -> Self {
         Self(BTreeMap::new())
     }
-    pub fn get(&self, witness: &Witness) -> Option<&FieldElement> {
+    pub fn get(&self, witness: &Witness) -> Option<&F> {
         self.0.get(witness)
     }
-    pub fn get_index(&self, index: u32) -> Option<&FieldElement> {
+    pub fn get_index(&self, index: u32) -> Option<&F> {
         self.0.get(&index.into())
     }
     pub fn contains_key(&self, key: &Witness) -> bool {
         self.0.contains_key(key)
     }
-    pub fn insert(&mut self, key: Witness, value: FieldElement) -> Option<FieldElement> {
+    pub fn insert(&mut self, key: Witness, value: F) -> Option<F> {
         self.0.insert(key, value)
     }
 }
 
-impl Index<&Witness> for WitnessMap {
-    type Output = FieldElement;
+impl<F> Index<&Witness> for WitnessMap<F> {
+    type Output = F;
 
     fn index(&self, index: &Witness) -> &Self::Output {
         &self.0[index]
     }
 }
 
-pub struct IntoIter(btree_map::IntoIter<Witness, FieldElement>);
+pub struct IntoIter<F>(btree_map::IntoIter<Witness, F>);
 
-impl Iterator for IntoIter {
-    type Item = (Witness, FieldElement);
+impl<F> Iterator for IntoIter<F> {
+    type Item = (Witness, F);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.0.next()
     }
 }
 
-impl IntoIterator for WitnessMap {
-    type Item = (Witness, FieldElement);
-    type IntoIter = IntoIter;
+impl<F> IntoIterator for WitnessMap<F> {
+    type Item = (Witness, F);
+    type IntoIter = IntoIter<F>;
 
     fn into_iter(self) -> Self::IntoIter {
         IntoIter(self.0.into_iter())
     }
 }
 
-impl From<BTreeMap<Witness, FieldElement>> for WitnessMap {
-    fn from(value: BTreeMap<Witness, FieldElement>) -> Self {
+impl<F> From<BTreeMap<Witness, F>> for WitnessMap<F> {
+    fn from(value: BTreeMap<Witness, F>) -> Self {
         Self(value)
     }
 }
 
-impl TryFrom<WitnessMap> for Vec<u8> {
+impl<F: Serialize> TryFrom<WitnessMap<F>> for Vec<u8> {
     type Error = WitnessMapError;
 
-    fn try_from(val: WitnessMap) -> Result<Self, Self::Error> {
+    fn try_from(val: WitnessMap<F>) -> Result<Self, Self::Error> {
         let buf = bincode::serialize(&val).unwrap();
         let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best());
         let mut buf_c = Vec::new();
@@ -90,7 +89,7 @@ impl TryFrom<WitnessMap> for Vec<u8> {
     }
 }
 
-impl TryFrom<&[u8]> for WitnessMap {
+impl<F: for<'a> Deserialize<'a>> TryFrom<&[u8]> for WitnessMap<F> {
     type Error = WitnessMapError;
 
     fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs
index 7c79e3db431..8a4fffa1577 100644
--- a/acvm-repo/acir/src/native_types/witness_stack.rs
+++ b/acvm-repo/acir/src/native_types/witness_stack.rs
@@ -20,28 +20,28 @@ pub struct WitnessStackError(#[from] SerializationError);
 
 /// An ordered set of witness maps for separate circuits
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
-pub struct WitnessStack {
-    stack: Vec<StackItem>,
+pub struct WitnessStack<F> {
+    stack: Vec<StackItem<F>>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
-pub struct StackItem {
+pub struct StackItem<F> {
     /// Index into a [crate::circuit::Program] function list for which we have an associated witness
     pub index: u32,
     /// A full witness for the respective constraint system specified by the index
-    pub witness: WitnessMap,
+    pub witness: WitnessMap<F>,
 }
 
-impl WitnessStack {
-    pub fn push(&mut self, index: u32, witness: WitnessMap) {
+impl<F> WitnessStack<F> {
+    pub fn push(&mut self, index: u32, witness: WitnessMap<F>) {
         self.stack.push(StackItem { index, witness });
     }
 
-    pub fn pop(&mut self) -> Option<StackItem> {
+    pub fn pop(&mut self) -> Option<StackItem<F>> {
         self.stack.pop()
     }
 
-    pub fn peek(&self) -> Option<&StackItem> {
+    pub fn peek(&self) -> Option<&StackItem<F>> {
         self.stack.last()
     }
 
@@ -50,17 +50,17 @@ impl WitnessStack {
     }
 }
 
-impl From<WitnessMap> for WitnessStack {
-    fn from(witness: WitnessMap) -> Self {
+impl<F> From<WitnessMap<F>> for WitnessStack<F> {
+    fn from(witness: WitnessMap<F>) -> Self {
         let stack = vec![StackItem { index: 0, witness }];
         Self { stack }
     }
 }
 
-impl TryFrom<WitnessStack> for Vec<u8> {
+impl<F: Serialize> TryFrom<WitnessStack<F>> for Vec<u8> {
     type Error = WitnessStackError;
 
-    fn try_from(val: WitnessStack) -> Result<Self, Self::Error> {
+    fn try_from(val: WitnessStack<F>) -> Result<Self, Self::Error> {
         let buf = bincode::serialize(&val).unwrap();
         let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best());
         let mut buf_c = Vec::new();
@@ -69,7 +69,7 @@ impl TryFrom<WitnessStack> for Vec<u8> {
     }
 }
 
-impl TryFrom<&[u8]> for WitnessStack {
+impl<F: for<'a> Deserialize<'a>> TryFrom<&[u8]> for WitnessStack<F> {
     type Error = WitnessStackError;
 
     fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 19e4beb6158..d4c7a8782ab 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -19,7 +19,7 @@ use acir::{
     },
     native_types::{Expression, Witness},
 };
-use acir_field::FieldElement;
+use acir_field::{AcirField, FieldElement};
 use brillig::{HeapArray, HeapValueType, MemoryAddress, ValueOrArray};
 
 #[test]
@@ -34,12 +34,12 @@ fn addition_circuit() {
         q_c: FieldElement::zero(),
     });
 
-    let circuit = Circuit {
+    let circuit: Circuit<FieldElement> = Circuit {
         current_witness_index: 4,
         opcodes: vec![addition],
         private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
         return_values: PublicInputs([Witness(3)].into()),
-        ..Circuit::default()
+        ..Circuit::<FieldElement>::default()
     };
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
@@ -59,18 +59,19 @@ fn addition_circuit() {
 
 #[test]
 fn multi_scalar_mul_circuit() {
-    let multi_scalar_mul = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::MultiScalarMul {
-        points: vec![
-            FunctionInput { witness: Witness(1), num_bits: 128 },
-            FunctionInput { witness: Witness(2), num_bits: 128 },
-            FunctionInput { witness: Witness(3), num_bits: 1 },
-        ],
-        scalars: vec![
-            FunctionInput { witness: Witness(4), num_bits: 128 },
-            FunctionInput { witness: Witness(5), num_bits: 128 },
-        ],
-        outputs: (Witness(6), Witness(7), Witness(8)),
-    });
+    let multi_scalar_mul: Opcode<FieldElement> =
+        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::MultiScalarMul {
+            points: vec![
+                FunctionInput { witness: Witness(1), num_bits: 128 },
+                FunctionInput { witness: Witness(2), num_bits: 128 },
+                FunctionInput { witness: Witness(3), num_bits: 1 },
+            ],
+            scalars: vec![
+                FunctionInput { witness: Witness(4), num_bits: 128 },
+                FunctionInput { witness: Witness(5), num_bits: 128 },
+            ],
+            outputs: (Witness(6), Witness(7), Witness(8)),
+        });
 
     let circuit = Circuit {
         current_witness_index: 9,
@@ -107,7 +108,7 @@ fn pedersen_circuit() {
         domain_separator: 0,
     });
 
-    let circuit = Circuit {
+    let circuit: Circuit<FieldElement> = Circuit {
         current_witness_index: 4,
         opcodes: vec![pedersen],
         private_parameters: BTreeSet::from([Witness(1)]),
@@ -151,7 +152,7 @@ fn schnorr_verify_circuit() {
         output,
     });
 
-    let circuit = Circuit {
+    let circuit: Circuit<FieldElement> = Circuit {
         current_witness_index: 100,
         opcodes: vec![schnorr],
         private_parameters: BTreeSet::from_iter((1..=last_input).map(Witness)),
@@ -219,7 +220,7 @@ fn simple_brillig_foreign_call() {
         predicate: None,
     }];
 
-    let circuit = Circuit {
+    let circuit: Circuit<FieldElement> = Circuit {
         current_witness_index: 8,
         opcodes,
         private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index dd4b7af9ffc..8d8a1e9e2bd 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -18,17 +18,12 @@ num-bigint.workspace = true
 serde.workspace = true
 num-traits.workspace = true
 
-ark-bn254 = { version = "^0.4.0", optional = true, default-features = false, features = [
-    "curve",
-] }
-ark-bls12-381 = { version = "^0.4.0", optional = true, default-features = false, features = [
-    "curve",
-] }
-ark-ff = { version = "^0.4.0", optional = true, default-features = false }
+ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
+ark-bls12-381 = { version = "^0.4.0", optional = true, default-features = false, features = ["curve"] }
+ark-ff = { version = "^0.4.0", default-features = false }
 
 cfg-if = "1.0.0"
 
 [features]
-default = ["bn254"]
-bn254 = ["dep:ark-bn254", "dep:ark-ff"]
-bls12_381 = ["dep:ark-bls12-381", "dep:ark-ff"]
+bn254 = []
+bls12_381 = ["dep:ark-bls12-381"]
diff --git a/acvm-repo/acir_field/src/generic_ark.rs b/acvm-repo/acir_field/src/generic_ark.rs
index 3178011a075..c1bc7971922 100644
--- a/acvm-repo/acir_field/src/generic_ark.rs
+++ b/acvm-repo/acir_field/src/generic_ark.rs
@@ -4,9 +4,90 @@ use num_bigint::BigUint;
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 
+/// This trait is extremely unstable and WILL have breaking changes.
+pub trait AcirField:
+    std::marker::Sized
+    + Display
+    + Debug
+    + Default
+    + Clone
+    + Copy
+    + Neg<Output = Self>
+    + Add<Self, Output = Self>
+    + Sub<Self, Output = Self>
+    + Mul<Self, Output = Self>
+    + Div<Self, Output = Self>
+    + PartialOrd
+    + AddAssign<Self>
+    + SubAssign<Self>
+    + From<usize>
+    + From<u128>
+    // + From<u64>
+    // + From<u32>
+    // + From<u16>
+    // + From<u8>
+    + From<bool>
+    + Hash
+    + std::cmp::Eq
+{
+    fn one() -> Self;
+    fn zero() -> Self;
+
+    fn is_zero(&self) -> bool;
+    fn is_one(&self) -> bool;
+
+    fn pow(&self, exponent: &Self) -> Self;
+
+    /// Maximum number of bits needed to represent a field element
+    /// This is not the amount of bits being used to represent a field element
+    /// Example, you only need 254 bits to represent a field element in BN256
+    /// But the representation uses 256 bits, so the top two bits are always zero
+    /// This method would return 254
+    fn max_num_bits() -> u32;
+
+    /// Maximum numbers of bytes needed to represent a field element
+    /// We are not guaranteed that the number of bits being used to represent a field element
+    /// will always be divisible by 8. If the case that it is not, we add one to the max number of bytes
+    /// For example, a max bit size of 254 would give a max byte size of 32.
+    fn max_num_bytes() -> u32;
+
+    fn modulus() -> BigUint;
+
+    /// This is the number of bits required to represent this specific field element
+    fn num_bits(&self) -> u32;
+
+    fn to_u128(self) -> u128;
+
+    fn try_into_u128(self) -> Option<u128>;
+
+    fn to_i128(self) -> i128;
+
+    fn try_to_u64(&self) -> Option<u64>;
+
+    /// Computes the inverse or returns zero if the inverse does not exist
+    /// Before using this FieldElement, please ensure that this behavior is necessary
+    fn inverse(&self) -> Self;
+
+    fn to_hex(self) -> String;
+
+    fn from_hex(hex_str: &str) -> Option<Self>;
+
+    fn to_be_bytes(self) -> Vec<u8>;
+
+    /// Converts bytes into a FieldElement and applies a reduction if needed.
+    fn from_be_bytes_reduce(bytes: &[u8]) -> Self;
+
+    /// Returns the closest number of bytes to the bits specified
+    /// This method truncates
+    fn fetch_nearest_bytes(&self, num_bits: usize) -> Vec<u8>;
+
+    fn and(&self, rhs: &Self, num_bits: u32) -> Self;
+    fn xor(&self, rhs: &Self, num_bits: u32) -> Self;
+}
+
 // XXX: Switch out for a trait and proper implementations
 // This implementation is in-efficient, can definitely remove hex usage and Iterator instances for trivial functionality
-#[derive(Clone, Copy, Eq, PartialOrd, Ord)]
+#[derive(Default, Clone, Copy, Eq, PartialOrd, Ord)]
 pub struct FieldElement<F: PrimeField>(F);
 
 impl<F: PrimeField> std::fmt::Display for FieldElement<F> {
@@ -161,25 +242,104 @@ impl<F: PrimeField> From<bool> for FieldElement<F> {
 }
 
 impl<F: PrimeField> FieldElement<F> {
-    pub fn one() -> FieldElement<F> {
+    pub fn from_repr(field: F) -> Self {
+        Self(field)
+    }
+
+    // XXX: This method is used while this field element
+    // implementation is not generic.
+    pub fn into_repr(self) -> F {
+        self.0
+    }
+
+    fn is_negative(&self) -> bool {
+        self.neg().num_bits() < self.num_bits()
+    }
+
+    fn fits_in_u128(&self) -> bool {
+        self.num_bits() <= 128
+    }
+
+    /// Returns None, if the string is not a canonical
+    /// representation of a field element; less than the order
+    /// or if the hex string is invalid.
+    /// This method can be used for both hex and decimal representations.
+    pub fn try_from_str(input: &str) -> Option<FieldElement<F>> {
+        if input.contains('x') {
+            return FieldElement::from_hex(input);
+        }
+
+        let fr = F::from_str(input).ok()?;
+        Some(FieldElement(fr))
+    }
+
+    // mask_to methods will not remove any bytes from the field
+    // they are simply zeroed out
+    // Whereas truncate_to will remove those bits and make the byte array smaller
+    fn mask_to_be_bytes(&self, num_bits: u32) -> Vec<u8> {
+        let mut bytes = self.to_be_bytes();
+        mask_vector_le(&mut bytes, num_bits as usize);
+        bytes
+    }
+
+    fn bits(&self) -> Vec<bool> {
+        fn byte_to_bit(byte: u8) -> Vec<bool> {
+            let mut bits = Vec::with_capacity(8);
+            for index in (0..=7).rev() {
+                bits.push((byte & (1 << index)) >> index == 1);
+            }
+            bits
+        }
+
+        let bytes = self.to_be_bytes();
+        let mut bits = Vec::with_capacity(bytes.len() * 8);
+        for byte in bytes {
+            let _bits = byte_to_bit(byte);
+            bits.extend(_bits);
+        }
+        bits
+    }
+
+    fn and_xor(&self, rhs: &FieldElement<F>, num_bits: u32, is_xor: bool) -> FieldElement<F> {
+        // XXX: Gadgets like SHA256 need to have their input be a multiple of 8
+        // This is not a restriction caused by SHA256, as it works on bits
+        // but most backends assume bytes.
+        // We could implicitly pad, however this may not be intuitive for users.
+        // assert!(
+        //     num_bits % 8 == 0,
+        //     "num_bits is not a multiple of 8, it is {}",
+        //     num_bits
+        // );
+
+        let lhs_bytes = self.mask_to_be_bytes(num_bits);
+        let rhs_bytes = rhs.mask_to_be_bytes(num_bits);
+
+        let and_byte_arr: Vec<_> = lhs_bytes
+            .into_iter()
+            .zip(rhs_bytes)
+            .map(|(lhs, rhs)| if is_xor { lhs ^ rhs } else { lhs & rhs })
+            .collect();
+
+        FieldElement::from_be_bytes_reduce(&and_byte_arr)
+    }
+}
+
+impl<F: PrimeField> AcirField for FieldElement<F> {
+    fn one() -> FieldElement<F> {
         FieldElement(F::one())
     }
-    pub fn zero() -> FieldElement<F> {
+    fn zero() -> FieldElement<F> {
         FieldElement(F::zero())
     }
 
-    pub fn is_zero(&self) -> bool {
+    fn is_zero(&self) -> bool {
         self == &Self::zero()
     }
-    pub fn is_one(&self) -> bool {
+    fn is_one(&self) -> bool {
         self == &Self::one()
     }
 
-    pub fn is_negative(&self) -> bool {
-        self.neg().num_bits() < self.num_bits()
-    }
-
-    pub fn pow(&self, exponent: &Self) -> Self {
+    fn pow(&self, exponent: &Self) -> Self {
         FieldElement(self.0.pow(exponent.0.into_bigint()))
     }
 
@@ -188,7 +348,7 @@ impl<F: PrimeField> FieldElement<F> {
     /// Example, you only need 254 bits to represent a field element in BN256
     /// But the representation uses 256 bits, so the top two bits are always zero
     /// This method would return 254
-    pub const fn max_num_bits() -> u32 {
+    fn max_num_bits() -> u32 {
         F::MODULUS_BIT_SIZE
     }
 
@@ -196,7 +356,7 @@ impl<F: PrimeField> FieldElement<F> {
     /// We are not guaranteed that the number of bits being used to represent a field element
     /// will always be divisible by 8. If the case that it is not, we add one to the max number of bytes
     /// For example, a max bit size of 254 would give a max byte size of 32.
-    pub const fn max_num_bytes() -> u32 {
+    fn max_num_bytes() -> u32 {
         let num_bytes = Self::max_num_bits() / 8;
         if Self::max_num_bits() % 8 == 0 {
             num_bytes
@@ -205,24 +365,12 @@ impl<F: PrimeField> FieldElement<F> {
         }
     }
 
-    pub fn modulus() -> BigUint {
+    fn modulus() -> BigUint {
         F::MODULUS.into()
     }
-    /// Returns None, if the string is not a canonical
-    /// representation of a field element; less than the order
-    /// or if the hex string is invalid.
-    /// This method can be used for both hex and decimal representations.
-    pub fn try_from_str(input: &str) -> Option<FieldElement<F>> {
-        if input.contains('x') {
-            return FieldElement::from_hex(input);
-        }
-
-        let fr = F::from_str(input).ok()?;
-        Some(FieldElement(fr))
-    }
 
     /// This is the number of bits required to represent this specific field element
-    pub fn num_bits(&self) -> u32 {
+    fn num_bits(&self) -> u32 {
         let bits = self.bits();
         // Iterate the number of bits and pop off all leading zeroes
         let iter = bits.iter().skip_while(|x| !(**x));
@@ -231,57 +379,39 @@ impl<F: PrimeField> FieldElement<F> {
         iter.count() as u32
     }
 
-    pub fn fits_in_u128(&self) -> bool {
-        self.num_bits() <= 128
-    }
-
-    pub fn to_u128(self) -> u128 {
+    fn to_u128(self) -> u128 {
         let bytes = self.to_be_bytes();
         u128::from_be_bytes(bytes[16..32].try_into().unwrap())
     }
 
-    pub fn try_into_u128(self) -> Option<u128> {
+    fn try_into_u128(self) -> Option<u128> {
         self.fits_in_u128().then(|| self.to_u128())
     }
 
-    pub fn to_i128(self) -> i128 {
+    fn to_i128(self) -> i128 {
         let is_negative = self.is_negative();
         let bytes = if is_negative { self.neg() } else { self }.to_be_bytes();
         i128::from_be_bytes(bytes[16..32].try_into().unwrap()) * if is_negative { -1 } else { 1 }
     }
 
-    pub fn try_to_u64(&self) -> Option<u64> {
+    fn try_to_u64(&self) -> Option<u64> {
         (self.num_bits() <= 64).then(|| self.to_u128() as u64)
     }
 
     /// Computes the inverse or returns zero if the inverse does not exist
     /// Before using this FieldElement, please ensure that this behavior is necessary
-    pub fn inverse(&self) -> FieldElement<F> {
+    fn inverse(&self) -> FieldElement<F> {
         let inv = self.0.inverse().unwrap_or_else(F::zero);
         FieldElement(inv)
     }
 
-    pub fn try_inverse(mut self) -> Option<Self> {
-        self.0.inverse_in_place().map(|f| FieldElement(*f))
-    }
-
-    pub fn from_repr(field: F) -> Self {
-        Self(field)
-    }
-
-    // XXX: This method is used while this field element
-    // implementation is not generic.
-    pub fn into_repr(self) -> F {
-        self.0
-    }
-
-    pub fn to_hex(self) -> String {
+    fn to_hex(self) -> String {
         let mut bytes = Vec::new();
         self.0.serialize_uncompressed(&mut bytes).unwrap();
         bytes.reverse();
         hex::encode(bytes)
     }
-    pub fn from_hex(hex_str: &str) -> Option<FieldElement<F>> {
+    fn from_hex(hex_str: &str) -> Option<FieldElement<F>> {
         let value = hex_str.strip_prefix("0x").unwrap_or(hex_str);
         // Values of odd length require an additional "0" prefix
         let sanitized_value =
@@ -290,7 +420,7 @@ impl<F: PrimeField> FieldElement<F> {
         Some(FieldElement::from_be_bytes_reduce(&hex_as_bytes))
     }
 
-    pub fn to_be_bytes(self) -> Vec<u8> {
+    fn to_be_bytes(self) -> Vec<u8> {
         // to_be_bytes! uses little endian which is why we reverse the output
         // TODO: Add a little endian equivalent, so the caller can use whichever one
         // TODO they desire
@@ -302,31 +432,13 @@ impl<F: PrimeField> FieldElement<F> {
 
     /// Converts bytes into a FieldElement and applies a
     /// reduction if needed.
-    pub fn from_be_bytes_reduce(bytes: &[u8]) -> FieldElement<F> {
+    fn from_be_bytes_reduce(bytes: &[u8]) -> FieldElement<F> {
         FieldElement(F::from_be_bytes_mod_order(bytes))
     }
 
-    pub fn bits(&self) -> Vec<bool> {
-        let bytes = self.to_be_bytes();
-        let mut bits = Vec::with_capacity(bytes.len() * 8);
-        for byte in bytes {
-            let _bits = FieldElement::<F>::byte_to_bit(byte);
-            bits.extend(_bits);
-        }
-        bits
-    }
-
-    fn byte_to_bit(byte: u8) -> Vec<bool> {
-        let mut bits = Vec::with_capacity(8);
-        for index in (0..=7).rev() {
-            bits.push((byte & (1 << index)) >> index == 1);
-        }
-        bits
-    }
-
     /// Returns the closest number of bytes to the bits specified
     /// This method truncates
-    pub fn fetch_nearest_bytes(&self, num_bits: usize) -> Vec<u8> {
+    fn fetch_nearest_bytes(&self, num_bits: usize) -> Vec<u8> {
         fn nearest_bytes(num_bits: usize) -> usize {
             ((num_bits + 7) / 8) * 8
         }
@@ -340,45 +452,17 @@ impl<F: PrimeField> FieldElement<F> {
         bytes[0..num_elements].to_vec()
     }
 
-    // mask_to methods will not remove any bytes from the field
-    // they are simply zeroed out
-    // Whereas truncate_to will remove those bits and make the byte array smaller
-    fn mask_to_be_bytes(&self, num_bits: u32) -> Vec<u8> {
-        let mut bytes = self.to_be_bytes();
-        mask_vector_le(&mut bytes, num_bits as usize);
-        bytes
-    }
-
-    fn and_xor(&self, rhs: &FieldElement<F>, num_bits: u32, is_xor: bool) -> FieldElement<F> {
-        // XXX: Gadgets like SHA256 need to have their input be a multiple of 8
-        // This is not a restriction caused by SHA256, as it works on bits
-        // but most backends assume bytes.
-        // We could implicitly pad, however this may not be intuitive for users.
-        // assert!(
-        //     num_bits % 8 == 0,
-        //     "num_bits is not a multiple of 8, it is {}",
-        //     num_bits
-        // );
-
-        let lhs_bytes = self.mask_to_be_bytes(num_bits);
-        let rhs_bytes = rhs.mask_to_be_bytes(num_bits);
-
-        let and_byte_arr: Vec<_> = lhs_bytes
-            .into_iter()
-            .zip(rhs_bytes)
-            .map(|(lhs, rhs)| if is_xor { lhs ^ rhs } else { lhs & rhs })
-            .collect();
-
-        FieldElement::from_be_bytes_reduce(&and_byte_arr)
-    }
-    pub fn and(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
+    fn and(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
         self.and_xor(rhs, num_bits, false)
     }
-    pub fn xor(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
+    fn xor(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
         self.and_xor(rhs, num_bits, true)
     }
 }
 
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::hash::Hash;
 use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
 
 impl<F: PrimeField> Neg for FieldElement<F> {
@@ -489,6 +573,8 @@ fn superscript(n: u64) -> String {
 
 #[cfg(test)]
 mod tests {
+    use super::{AcirField, FieldElement};
+
     #[test]
     fn and() {
         let max = 10_000u32;
@@ -496,7 +582,7 @@ mod tests {
         let num_bits = (std::mem::size_of::<u32>() * 8) as u32 - max.leading_zeros();
 
         for x in 0..max {
-            let x = crate::generic_ark::FieldElement::<ark_bn254::Fr>::from(x as i128);
+            let x = FieldElement::<ark_bn254::Fr>::from(x as i128);
             let res = x.and(&x, num_bits);
             assert_eq!(res.to_be_bytes(), x.to_be_bytes());
         }
@@ -513,8 +599,7 @@ mod tests {
         ];
 
         for (i, string) in hex_strings.into_iter().enumerate() {
-            let minus_i_field_element =
-                -crate::generic_ark::FieldElement::<ark_bn254::Fr>::from(i as i128);
+            let minus_i_field_element = -FieldElement::<ark_bn254::Fr>::from(i as i128);
             assert_eq!(minus_i_field_element.to_hex(), string);
         }
     }
@@ -525,12 +610,9 @@ mod tests {
         let hex_strings =
             vec![("0x0", "0x00"), ("0x1", "0x01"), ("0x002", "0x0002"), ("0x00003", "0x000003")];
         for (i, case) in hex_strings.into_iter().enumerate() {
-            let i_field_element =
-                crate::generic_ark::FieldElement::<ark_bn254::Fr>::from(i as i128);
-            let odd_field_element =
-                crate::generic_ark::FieldElement::<ark_bn254::Fr>::from_hex(case.0).unwrap();
-            let even_field_element =
-                crate::generic_ark::FieldElement::<ark_bn254::Fr>::from_hex(case.1).unwrap();
+            let i_field_element = FieldElement::<ark_bn254::Fr>::from(i as i128);
+            let odd_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.0).unwrap();
+            let even_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.1).unwrap();
 
             assert_eq!(i_field_element, odd_field_element);
             assert_eq!(odd_field_element, even_field_element);
@@ -539,7 +621,7 @@ mod tests {
 
     #[test]
     fn max_num_bits_smoke() {
-        let max_num_bits_bn254 = crate::generic_ark::FieldElement::<ark_bn254::Fr>::max_num_bits();
+        let max_num_bits_bn254 = FieldElement::<ark_bn254::Fr>::max_num_bits();
         assert_eq!(max_num_bits_bn254, 254);
     }
 }
diff --git a/acvm-repo/acir_field/src/lib.rs b/acvm-repo/acir_field/src/lib.rs
index eafe4bb2ad4..7f06330ed8d 100644
--- a/acvm-repo/acir_field/src/lib.rs
+++ b/acvm-repo/acir_field/src/lib.rs
@@ -5,19 +5,20 @@
 
 use num_bigint::BigUint;
 use num_traits::Num;
+mod generic_ark;
 
-cfg_if::cfg_if! {
-    if #[cfg(feature = "bn254")] {
-        mod generic_ark;
-        pub type FieldElement = generic_ark::FieldElement<ark_bn254::Fr>;
-        pub const CHOSEN_FIELD : FieldOptions = FieldOptions::BN254;
+pub use generic_ark::AcirField;
+
+/// Temporarily exported generic field to aid migration to `AcirField`
+pub use generic_ark::FieldElement as GenericFieldElement;
 
-    } else if #[cfg(feature = "bls12_381")] {
-        mod generic_ark;
+cfg_if::cfg_if! {
+    if #[cfg(feature = "bls12_381")] {
         pub type FieldElement = generic_ark::FieldElement<ark_bls12_381::Fr>;
         pub const CHOSEN_FIELD : FieldOptions = FieldOptions::BLS12_381;
     } else {
-        compile_error!("please specify a field to compile with");
+        pub type FieldElement = generic_ark::FieldElement<ark_bn254::Fr>;
+        pub const CHOSEN_FIELD : FieldOptions = FieldOptions::BN254;
     }
 }
 
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 74aed429f9a..577978939b0 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -24,7 +24,6 @@ acvm_blackbox_solver.workspace = true
 indexmap = "1.7.0"
 
 [features]
-default = ["bn254"]
 bn254 = [
     "acir/bn254",
     "brillig_vm/bn254",
@@ -40,3 +39,4 @@ bls12_381 = [
 rand = "0.8.5"
 proptest = "1.2.0"
 paste = "1.0.14"
+ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
\ No newline at end of file
diff --git a/acvm-repo/acvm/src/compiler/mod.rs b/acvm-repo/acvm/src/compiler/mod.rs
index 436db648ea8..5ece3d19a6e 100644
--- a/acvm-repo/acvm/src/compiler/mod.rs
+++ b/acvm-repo/acvm/src/compiler/mod.rs
@@ -1,6 +1,9 @@
 use std::collections::HashMap;
 
-use acir::circuit::{AssertionPayload, Circuit, ExpressionWidth, OpcodeLocation};
+use acir::{
+    circuit::{AssertionPayload, Circuit, ExpressionWidth, OpcodeLocation},
+    AcirField,
+};
 
 // The various passes that we can use over ACIR
 mod optimizers;
@@ -53,10 +56,10 @@ impl AcirTransformationMap {
     }
 }
 
-fn transform_assert_messages(
-    assert_messages: Vec<(OpcodeLocation, AssertionPayload)>,
+fn transform_assert_messages<F: Clone>(
+    assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>,
     map: &AcirTransformationMap,
-) -> Vec<(OpcodeLocation, AssertionPayload)> {
+) -> Vec<(OpcodeLocation, AssertionPayload<F>)> {
     assert_messages
         .into_iter()
         .flat_map(|(location, message)| {
@@ -67,10 +70,10 @@ fn transform_assert_messages(
 }
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
-pub fn compile(
-    acir: Circuit,
+pub fn compile<F: AcirField>(
+    acir: Circuit<F>,
     expression_width: ExpressionWidth,
-) -> (Circuit, AcirTransformationMap) {
+) -> (Circuit<F>, AcirTransformationMap) {
     let (acir, acir_opcode_positions) = optimize_internal(acir);
 
     let (mut acir, acir_opcode_positions) =
diff --git a/acvm-repo/acvm/src/compiler/optimizers/general.rs b/acvm-repo/acvm/src/compiler/optimizers/general.rs
index a48a590a05e..39a01a38cac 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/general.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/general.rs
@@ -1,6 +1,6 @@
 use acir::{
     native_types::{Expression, Witness},
-    FieldElement,
+    AcirField,
 };
 use indexmap::IndexMap;
 
@@ -10,7 +10,7 @@ use indexmap::IndexMap;
 pub(crate) struct GeneralOptimizer;
 
 impl GeneralOptimizer {
-    pub(crate) fn optimize(opcode: Expression) -> Expression {
+    pub(crate) fn optimize<F: AcirField>(opcode: Expression<F>) -> Expression<F> {
         // XXX: Perhaps this optimization can be done on the fly
         let opcode = remove_zero_coefficients(opcode);
         let opcode = simplify_mul_terms(opcode);
@@ -19,7 +19,7 @@ impl GeneralOptimizer {
 }
 
 // Remove all terms with zero as a coefficient
-fn remove_zero_coefficients(mut opcode: Expression) -> Expression {
+fn remove_zero_coefficients<F: AcirField>(mut opcode: Expression<F>) -> Expression<F> {
     // Check the mul terms
     opcode.mul_terms.retain(|(scale, _, _)| !scale.is_zero());
     // Check the linear combination terms
@@ -28,8 +28,8 @@ fn remove_zero_coefficients(mut opcode: Expression) -> Expression {
 }
 
 // Simplifies all mul terms with the same bi-variate variables
-fn simplify_mul_terms(mut gate: Expression) -> Expression {
-    let mut hash_map: IndexMap<(Witness, Witness), FieldElement> = IndexMap::new();
+fn simplify_mul_terms<F: AcirField>(mut gate: Expression<F>) -> Expression<F> {
+    let mut hash_map: IndexMap<(Witness, Witness), F> = IndexMap::new();
 
     // Canonicalize the ordering of the multiplication, lets just order by variable name
     for (scale, w_l, w_r) in gate.mul_terms.into_iter() {
@@ -37,7 +37,7 @@ fn simplify_mul_terms(mut gate: Expression) -> Expression {
         // Sort using rust sort algorithm
         pair.sort();
 
-        *hash_map.entry((pair[0], pair[1])).or_insert_with(FieldElement::zero) += scale;
+        *hash_map.entry((pair[0], pair[1])).or_insert_with(F::zero) += scale;
     }
 
     gate.mul_terms = hash_map.into_iter().map(|((w_l, w_r), scale)| (scale, w_l, w_r)).collect();
@@ -45,17 +45,17 @@ fn simplify_mul_terms(mut gate: Expression) -> Expression {
 }
 
 // Simplifies all linear terms with the same variables
-fn simplify_linear_terms(mut gate: Expression) -> Expression {
-    let mut hash_map: IndexMap<Witness, FieldElement> = IndexMap::new();
+fn simplify_linear_terms<F: AcirField>(mut gate: Expression<F>) -> Expression<F> {
+    let mut hash_map: IndexMap<Witness, F> = IndexMap::new();
 
     // Canonicalize the ordering of the terms, lets just order by variable name
     for (scale, witness) in gate.linear_combinations.into_iter() {
-        *hash_map.entry(witness).or_insert_with(FieldElement::zero) += scale;
+        *hash_map.entry(witness).or_insert_with(F::zero) += scale;
     }
 
     gate.linear_combinations = hash_map
         .into_iter()
-        .filter(|(_, scale)| scale != &FieldElement::zero())
+        .filter(|(_, scale)| !scale.is_zero())
         .map(|(witness, scale)| (scale, witness))
         .collect();
     gate
diff --git a/acvm-repo/acvm/src/compiler/optimizers/mod.rs b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
index dfe348d4ff5..e20ad97a108 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
@@ -1,4 +1,7 @@
-use acir::circuit::{Circuit, Opcode};
+use acir::{
+    circuit::{Circuit, Opcode},
+    AcirField,
+};
 
 // mod constant_backpropagation;
 mod general;
@@ -15,7 +18,7 @@ use self::unused_memory::UnusedMemoryOptimizer;
 use super::{transform_assert_messages, AcirTransformationMap};
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] independent optimizations to a [`Circuit`].
-pub fn optimize(acir: Circuit) -> (Circuit, AcirTransformationMap) {
+pub fn optimize<F: AcirField>(acir: Circuit<F>) -> (Circuit<F>, AcirTransformationMap) {
     let (mut acir, new_opcode_positions) = optimize_internal(acir);
 
     let transformation_map = AcirTransformationMap::new(new_opcode_positions);
@@ -27,7 +30,7 @@ pub fn optimize(acir: Circuit) -> (Circuit, AcirTransformationMap) {
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] independent optimizations to a [`Circuit`].
 #[tracing::instrument(level = "trace", name = "optimize_acir" skip(acir))]
-pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
+pub(super) fn optimize_internal<F: AcirField>(acir: Circuit<F>) -> (Circuit<F>, Vec<usize>) {
     // Track original acir opcode positions throughout the transformation passes of the compilation
     // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
     let acir_opcode_positions = (0..acir.opcodes.len()).collect();
@@ -40,7 +43,7 @@ pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
     info!("Number of opcodes before: {}", acir.opcodes.len());
 
     // General optimizer pass
-    let opcodes: Vec<Opcode> = acir
+    let opcodes: Vec<Opcode<F>> = acir
         .opcodes
         .into_iter()
         .map(|opcode| {
diff --git a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
index 0e1629717b3..7001c953d63 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
@@ -4,6 +4,7 @@ use acir::{
         Circuit, Opcode,
     },
     native_types::Witness,
+    AcirField,
 };
 use std::collections::{BTreeMap, HashSet};
 
@@ -26,16 +27,16 @@ use std::collections::{BTreeMap, HashSet};
 ///
 /// This optimization pass will keep the 16-bit range constraint
 /// and remove the 32-bit range constraint opcode.
-pub(crate) struct RangeOptimizer {
+pub(crate) struct RangeOptimizer<F> {
     /// Maps witnesses to their lowest known bit sizes.
     lists: BTreeMap<Witness, u32>,
-    circuit: Circuit,
+    circuit: Circuit<F>,
 }
 
-impl RangeOptimizer {
+impl<F: AcirField> RangeOptimizer<F> {
     /// Creates a new `RangeOptimizer` by collecting all known range
     /// constraints from `Circuit`.
-    pub(crate) fn new(circuit: Circuit) -> Self {
+    pub(crate) fn new(circuit: Circuit<F>) -> Self {
         let range_list = Self::collect_ranges(&circuit);
         Self { circuit, lists: range_list }
     }
@@ -46,7 +47,7 @@ impl RangeOptimizer {
     /// both 32 bits and 16 bits. This function will
     /// only store the fact that we have constrained it to
     /// be 16 bits.
-    fn collect_ranges(circuit: &Circuit) -> BTreeMap<Witness, u32> {
+    fn collect_ranges(circuit: &Circuit<F>) -> BTreeMap<Witness, u32> {
         let mut witness_to_bit_sizes: BTreeMap<Witness, u32> = BTreeMap::new();
 
         for opcode in &circuit.opcodes {
@@ -95,7 +96,10 @@ impl RangeOptimizer {
 
     /// Returns a `Circuit` where each Witness is only range constrained
     /// once to the lowest number `bit size` possible.
-    pub(crate) fn replace_redundant_ranges(self, order_list: Vec<usize>) -> (Circuit, Vec<usize>) {
+    pub(crate) fn replace_redundant_ranges(
+        self,
+        order_list: Vec<usize>,
+    ) -> (Circuit<F>, Vec<usize>) {
         let mut already_seen_witness = HashSet::new();
 
         let mut new_order_list = Vec::with_capacity(order_list.len());
@@ -148,10 +152,11 @@ mod tests {
             Circuit, ExpressionWidth, Opcode, PublicInputs,
         },
         native_types::{Expression, Witness},
+        FieldElement,
     };
 
-    fn test_circuit(ranges: Vec<(Witness, u32)>) -> Circuit {
-        fn test_range_constraint(witness: Witness, num_bits: u32) -> Opcode {
+    fn test_circuit(ranges: Vec<(Witness, u32)>) -> Circuit<FieldElement> {
+        fn test_range_constraint(witness: Witness, num_bits: u32) -> Opcode<FieldElement> {
             Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
                 input: FunctionInput { witness, num_bits },
             })
diff --git a/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs b/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs
index 5fdcf54a492..1963430210f 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/unused_memory.rs
@@ -2,15 +2,15 @@ use acir::circuit::{opcodes::BlockId, Circuit, Opcode};
 use std::collections::HashSet;
 
 /// `UnusedMemoryOptimizer` will remove initializations of memory blocks which are unused.
-pub(crate) struct UnusedMemoryOptimizer {
+pub(crate) struct UnusedMemoryOptimizer<F> {
     unused_memory_initializations: HashSet<BlockId>,
-    circuit: Circuit,
+    circuit: Circuit<F>,
 }
 
-impl UnusedMemoryOptimizer {
+impl<F> UnusedMemoryOptimizer<F> {
     /// Creates a new `UnusedMemoryOptimizer ` by collecting unused memory init
     /// opcodes from `Circuit`.
-    pub(crate) fn new(circuit: Circuit) -> Self {
+    pub(crate) fn new(circuit: Circuit<F>) -> Self {
         let unused_memory_initializations = Self::collect_unused_memory_initializations(&circuit);
         Self { circuit, unused_memory_initializations }
     }
@@ -18,7 +18,7 @@ impl UnusedMemoryOptimizer {
     /// Creates a set of ids for memory blocks for which no [`Opcode::MemoryOp`]s exist.
     ///
     /// These memory blocks can be safely removed.
-    fn collect_unused_memory_initializations(circuit: &Circuit) -> HashSet<BlockId> {
+    fn collect_unused_memory_initializations(circuit: &Circuit<F>) -> HashSet<BlockId> {
         let mut unused_memory_initialization = HashSet::new();
 
         for opcode in &circuit.opcodes {
@@ -39,7 +39,7 @@ impl UnusedMemoryOptimizer {
     pub(crate) fn remove_unused_memory_initializations(
         self,
         order_list: Vec<usize>,
-    ) -> (Circuit, Vec<usize>) {
+    ) -> (Circuit<F>, Vec<usize>) {
         let mut new_order_list = Vec::with_capacity(order_list.len());
         let mut optimized_opcodes = Vec::with_capacity(self.circuit.opcodes.len());
         for (idx, opcode) in self.circuit.opcodes.into_iter().enumerate() {
diff --git a/acvm-repo/acvm/src/compiler/transformers/csat.rs b/acvm-repo/acvm/src/compiler/transformers/csat.rs
index 12a37e3e37a..6cf74c04205 100644
--- a/acvm-repo/acvm/src/compiler/transformers/csat.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/csat.rs
@@ -2,7 +2,7 @@ use std::{cmp::Ordering, collections::HashSet};
 
 use acir::{
     native_types::{Expression, Witness},
-    FieldElement,
+    AcirField,
 };
 use indexmap::IndexMap;
 
@@ -30,7 +30,7 @@ impl CSatTransformer {
     }
 
     /// Check if the equation 'expression=0' can be solved, and if yes, add the solved witness to set of solvable witness
-    fn try_solve(&mut self, opcode: &Expression) {
+    fn try_solve<F>(&mut self, opcode: &Expression<F>) {
         let mut unresolved = Vec::new();
         for (_, w1, w2) in &opcode.mul_terms {
             if !self.solvable_witness.contains(w1) {
@@ -64,12 +64,12 @@ impl CSatTransformer {
     // Still missing dead witness optimization.
     // To do this, we will need the whole set of assert-zero opcodes
     // I think it can also be done before the local optimization seen here, as dead variables will come from the user
-    pub(crate) fn transform(
+    pub(crate) fn transform<F: AcirField>(
         &mut self,
-        opcode: Expression,
-        intermediate_variables: &mut IndexMap<Expression, (FieldElement, Witness)>,
+        opcode: Expression<F>,
+        intermediate_variables: &mut IndexMap<Expression<F>, (F, Witness)>,
         num_witness: &mut u32,
-    ) -> Expression {
+    ) -> Expression<F> {
         // Here we create intermediate variables and constrain them to be equal to any subset of the polynomial that can be represented as a full opcode
         let opcode =
             self.full_opcode_scan_optimization(opcode, intermediate_variables, num_witness);
@@ -107,12 +107,12 @@ impl CSatTransformer {
     // The polynomial now looks like so t + t2
     // We can no longer extract another full opcode, hence the algorithm terminates. Creating two intermediate variables t and t2.
     // This stage of preprocessing does not guarantee that all polynomials can fit into a opcode. It only guarantees that all full opcodes have been extracted from each polynomial
-    fn full_opcode_scan_optimization(
+    fn full_opcode_scan_optimization<F: AcirField>(
         &mut self,
-        mut opcode: Expression,
-        intermediate_variables: &mut IndexMap<Expression, (FieldElement, Witness)>,
+        mut opcode: Expression<F>,
+        intermediate_variables: &mut IndexMap<Expression<F>, (F, Witness)>,
         num_witness: &mut u32,
-    ) -> Expression {
+    ) -> Expression<F> {
         // We pass around this intermediate variable IndexMap, so that we do not create intermediate variables that we have created before
         // One instance where this might happen is t1 = wL * wR and t2 = wR * wL
 
@@ -245,7 +245,7 @@ impl CSatTransformer {
     /// Normalize an expression by dividing it by its first coefficient
     /// The first coefficient here means coefficient of the first linear term, or of the first quadratic term if no linear terms exist.
     /// The function panic if the input expression is constant
-    fn normalize(mut expr: Expression) -> (FieldElement, Expression) {
+    fn normalize<F: AcirField>(mut expr: Expression<F>) -> (F, Expression<F>) {
         expr.sort();
         let a = if !expr.linear_combinations.is_empty() {
             expr.linear_combinations[0].0
@@ -259,11 +259,11 @@ impl CSatTransformer {
     /// The sets of previously generated witness and their (normalized) expression is cached in the intermediate_variables map
     /// If there is no cache hit, we generate a new witness (and add the expression to the cache)
     /// else, we return the cached witness along with the scaling factor so it is equal to the provided expression
-    fn get_or_create_intermediate_vars(
-        intermediate_variables: &mut IndexMap<Expression, (FieldElement, Witness)>,
-        expr: Expression,
+    fn get_or_create_intermediate_vars<F: AcirField>(
+        intermediate_variables: &mut IndexMap<Expression<F>, (F, Witness)>,
+        expr: Expression<F>,
         num_witness: &mut u32,
-    ) -> (FieldElement, Witness) {
+    ) -> (F, Witness) {
         let (k, normalized_expr) = Self::normalize(expr);
 
         if intermediate_variables.contains_key(&normalized_expr) {
@@ -274,7 +274,7 @@ impl CSatTransformer {
             *num_witness += 1;
             // Add intermediate opcode and variable to map
             intermediate_variables.insert(normalized_expr, (k, inter_var));
-            (FieldElement::one(), inter_var)
+            (F::one(), inter_var)
         }
     }
 
@@ -315,12 +315,12 @@ impl CSatTransformer {
     // Also remember that since we did full opcode scan, there is no way we can have a non-zero mul term along with the wL and wR terms being non-zero
     //
     // Cases, a lot of mul terms, a lot of fan-in terms, 50/50
-    fn partial_opcode_scan_optimization(
+    fn partial_opcode_scan_optimization<F: AcirField>(
         &mut self,
-        mut opcode: Expression,
-        intermediate_variables: &mut IndexMap<Expression, (FieldElement, Witness)>,
+        mut opcode: Expression<F>,
+        intermediate_variables: &mut IndexMap<Expression<F>, (F, Witness)>,
         num_witness: &mut u32,
-    ) -> Expression {
+    ) -> Expression<F> {
         // We will go for the easiest route, which is to convert all multiplications into additions using intermediate variables
         // Then use intermediate variables again to squash the fan-in, so that it can fit into the appropriate width
 
@@ -409,101 +409,113 @@ impl CSatTransformer {
     }
 }
 
-#[test]
-fn simple_reduction_smoke_test() {
-    let a = Witness(0);
-    let b = Witness(1);
-    let c = Witness(2);
-    let d = Witness(3);
-
-    // a = b + c + d;
-    let opcode_a = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![
-            (FieldElement::one(), a),
-            (-FieldElement::one(), b),
-            (-FieldElement::one(), c),
-            (-FieldElement::one(), d),
-        ],
-        q_c: FieldElement::zero(),
-    };
-
-    let mut intermediate_variables: IndexMap<Expression, (FieldElement, Witness)> = IndexMap::new();
-
-    let mut num_witness = 4;
-
-    let mut optimizer = CSatTransformer::new(3);
-    optimizer.mark_solvable(b);
-    optimizer.mark_solvable(c);
-    optimizer.mark_solvable(d);
-    let got_optimized_opcode_a =
-        optimizer.transform(opcode_a, &mut intermediate_variables, &mut num_witness);
-
-    // a = b + c + d => a - b - c - d = 0
-    // For width3, the result becomes:
-    // a - d + e = 0
-    // - c - b  - e = 0
-    //
-    // a - b + e = 0
-    let e = Witness(4);
-    let expected_optimized_opcode_a = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![
-            (FieldElement::one(), a),
-            (-FieldElement::one(), d),
-            (FieldElement::one(), e),
-        ],
-        q_c: FieldElement::zero(),
-    };
-    assert_eq!(expected_optimized_opcode_a, got_optimized_opcode_a);
-
-    assert_eq!(intermediate_variables.len(), 1);
-
-    // e = - c - b
-    let expected_intermediate_opcode = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![(-FieldElement::one(), c), (-FieldElement::one(), b)],
-        q_c: FieldElement::zero(),
-    };
-    let (_, normalized_opcode) = CSatTransformer::normalize(expected_intermediate_opcode);
-    assert!(intermediate_variables.contains_key(&normalized_opcode));
-    assert_eq!(intermediate_variables[&normalized_opcode].1, e);
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use acir::{AcirField, FieldElement};
+
+    #[test]
+    fn simple_reduction_smoke_test() {
+        let a = Witness(0);
+        let b = Witness(1);
+        let c = Witness(2);
+        let d = Witness(3);
+
+        // a = b + c + d;
+        let opcode_a = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![
+                (FieldElement::one(), a),
+                (-FieldElement::one(), b),
+                (-FieldElement::one(), c),
+                (-FieldElement::one(), d),
+            ],
+            q_c: FieldElement::zero(),
+        };
+
+        let mut intermediate_variables: IndexMap<
+            Expression<FieldElement>,
+            (FieldElement, Witness),
+        > = IndexMap::new();
+
+        let mut num_witness = 4;
+
+        let mut optimizer = CSatTransformer::new(3);
+        optimizer.mark_solvable(b);
+        optimizer.mark_solvable(c);
+        optimizer.mark_solvable(d);
+        let got_optimized_opcode_a =
+            optimizer.transform(opcode_a, &mut intermediate_variables, &mut num_witness);
+
+        // a = b + c + d => a - b - c - d = 0
+        // For width3, the result becomes:
+        // a - d + e = 0
+        // - c - b  - e = 0
+        //
+        // a - b + e = 0
+        let e = Witness(4);
+        let expected_optimized_opcode_a = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![
+                (FieldElement::one(), a),
+                (-FieldElement::one(), d),
+                (FieldElement::one(), e),
+            ],
+            q_c: FieldElement::zero(),
+        };
+        assert_eq!(expected_optimized_opcode_a, got_optimized_opcode_a);
+
+        assert_eq!(intermediate_variables.len(), 1);
 
-#[test]
-fn stepwise_reduction_test() {
-    let a = Witness(0);
-    let b = Witness(1);
-    let c = Witness(2);
-    let d = Witness(3);
-    let e = Witness(4);
-
-    // a = b + c + d + e;
-    let opcode_a = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![
-            (-FieldElement::one(), a),
-            (FieldElement::one(), b),
-            (FieldElement::one(), c),
-            (FieldElement::one(), d),
-            (FieldElement::one(), e),
-        ],
-        q_c: FieldElement::zero(),
-    };
-
-    let mut intermediate_variables: IndexMap<Expression, (FieldElement, Witness)> = IndexMap::new();
-
-    let mut num_witness = 4;
-
-    let mut optimizer = CSatTransformer::new(3);
-    optimizer.mark_solvable(a);
-    optimizer.mark_solvable(c);
-    optimizer.mark_solvable(d);
-    optimizer.mark_solvable(e);
-    let got_optimized_opcode_a =
-        optimizer.transform(opcode_a, &mut intermediate_variables, &mut num_witness);
-
-    // Since b is not known, it cannot be put inside intermediate opcodes, so it must belong to the transformed opcode.
-    let contains_b = got_optimized_opcode_a.linear_combinations.iter().any(|(_, w)| *w == b);
-    assert!(contains_b);
+        // e = - c - b
+        let expected_intermediate_opcode = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![(-FieldElement::one(), c), (-FieldElement::one(), b)],
+            q_c: FieldElement::zero(),
+        };
+        let (_, normalized_opcode) = CSatTransformer::normalize(expected_intermediate_opcode);
+        assert!(intermediate_variables.contains_key(&normalized_opcode));
+        assert_eq!(intermediate_variables[&normalized_opcode].1, e);
+    }
+
+    #[test]
+    fn stepwise_reduction_test() {
+        let a = Witness(0);
+        let b = Witness(1);
+        let c = Witness(2);
+        let d = Witness(3);
+        let e = Witness(4);
+
+        // a = b + c + d + e;
+        let opcode_a = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![
+                (-FieldElement::one(), a),
+                (FieldElement::one(), b),
+                (FieldElement::one(), c),
+                (FieldElement::one(), d),
+                (FieldElement::one(), e),
+            ],
+            q_c: FieldElement::zero(),
+        };
+
+        let mut intermediate_variables: IndexMap<
+            Expression<FieldElement>,
+            (FieldElement, Witness),
+        > = IndexMap::new();
+
+        let mut num_witness = 4;
+
+        let mut optimizer = CSatTransformer::new(3);
+        optimizer.mark_solvable(a);
+        optimizer.mark_solvable(c);
+        optimizer.mark_solvable(d);
+        optimizer.mark_solvable(e);
+        let got_optimized_opcode_a =
+            optimizer.transform(opcode_a, &mut intermediate_variables, &mut num_witness);
+
+        // Since b is not known, it cannot be put inside intermediate opcodes, so it must belong to the transformed opcode.
+        let contains_b = got_optimized_opcode_a.linear_combinations.iter().any(|(_, w)| *w == b);
+        assert!(contains_b);
+    }
 }
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 0099519e4b6..4fd8ba7883f 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::{brillig::BrilligOutputs, directives::Directive, Circuit, ExpressionWidth, Opcode},
     native_types::{Expression, Witness},
-    FieldElement,
+    AcirField,
 };
 use indexmap::IndexMap;
 
@@ -12,10 +12,10 @@ pub(crate) use csat::CSatTransformer;
 use super::{transform_assert_messages, AcirTransformationMap};
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
-pub fn transform(
-    acir: Circuit,
+pub fn transform<F: AcirField>(
+    acir: Circuit<F>,
     expression_width: ExpressionWidth,
-) -> (Circuit, AcirTransformationMap) {
+) -> (Circuit<F>, AcirTransformationMap) {
     // Track original acir opcode positions throughout the transformation passes of the compilation
     // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
     let acir_opcode_positions = acir.opcodes.iter().enumerate().map(|(i, _)| i).collect();
@@ -34,11 +34,11 @@ pub fn transform(
 ///
 /// Accepts an injected `acir_opcode_positions` to allow transformations to be applied directly after optimizations.
 #[tracing::instrument(level = "trace", name = "transform_acir", skip(acir, acir_opcode_positions))]
-pub(super) fn transform_internal(
-    acir: Circuit,
+pub(super) fn transform_internal<F: AcirField>(
+    acir: Circuit<F>,
     expression_width: ExpressionWidth,
     acir_opcode_positions: Vec<usize>,
-) -> (Circuit, Vec<usize>) {
+) -> (Circuit<F>, Vec<usize>) {
     let mut transformer = match &expression_width {
         ExpressionWidth::Unbounded => {
             return (acir, acir_opcode_positions);
@@ -64,7 +64,7 @@ pub(super) fn transform_internal(
     let mut next_witness_index = acir.current_witness_index + 1;
     // maps a normalized expression to the intermediate variable which represents the expression, along with its 'norm'
     // the 'norm' is simply the value of the first non zero coefficient in the expression, taken from the linear terms, or quadratic terms if there is none.
-    let mut intermediate_variables: IndexMap<Expression, (FieldElement, Witness)> = IndexMap::new();
+    let mut intermediate_variables: IndexMap<Expression<F>, (F, Witness)> = IndexMap::new();
     for (index, opcode) in acir.opcodes.into_iter().enumerate() {
         match opcode {
             Opcode::AssertZero(arith_expr) => {
@@ -83,7 +83,7 @@ pub(super) fn transform_internal(
                     // de-normalize
                     let mut intermediate_opcode = g * *norm;
                     // constrain the intermediate opcode to the intermediate variable
-                    intermediate_opcode.linear_combinations.push((-FieldElement::one(), *w));
+                    intermediate_opcode.linear_combinations.push((-F::one(), *w));
                     intermediate_opcode.sort();
                     new_opcodes.push(intermediate_opcode);
                 }
diff --git a/acvm-repo/acvm/src/lib.rs b/acvm-repo/acvm/src/lib.rs
index 00a253fde07..4c64e1da749 100644
--- a/acvm-repo/acvm/src/lib.rs
+++ b/acvm-repo/acvm/src/lib.rs
@@ -11,7 +11,7 @@ use pwg::OpcodeResolutionError;
 
 // re-export acir
 pub use acir;
-pub use acir::FieldElement;
+pub use acir::{AcirField, FieldElement};
 // re-export brillig vm
 pub use brillig_vm;
 // re-export blackbox solver
diff --git a/acvm-repo/acvm/src/pwg/arithmetic.rs b/acvm-repo/acvm/src/pwg/arithmetic.rs
index b971e4a0efb..5eeabd8a833 100644
--- a/acvm-repo/acvm/src/pwg/arithmetic.rs
+++ b/acvm-repo/acvm/src/pwg/arithmetic.rs
@@ -1,6 +1,6 @@
 use acir::{
     native_types::{Expression, Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 
 use super::{insert_value, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError};
@@ -10,24 +10,24 @@ use super::{insert_value, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionErro
 pub(crate) struct ExpressionSolver;
 
 #[allow(clippy::enum_variant_names)]
-pub(super) enum OpcodeStatus {
-    OpcodeSatisfied(FieldElement),
-    OpcodeSolvable(FieldElement, (FieldElement, Witness)),
+pub(super) enum OpcodeStatus<F> {
+    OpcodeSatisfied(F),
+    OpcodeSolvable(F, (F, Witness)),
     OpcodeUnsolvable,
 }
 
-pub(crate) enum MulTerm {
-    OneUnknown(FieldElement, Witness), // (qM * known_witness, unknown_witness)
+pub(crate) enum MulTerm<F> {
+    OneUnknown(F, Witness), // (qM * known_witness, unknown_witness)
     TooManyUnknowns,
-    Solved(FieldElement),
+    Solved(F),
 }
 
 impl ExpressionSolver {
     /// Derives the rest of the witness based on the initial low level variables
-    pub(crate) fn solve(
-        initial_witness: &mut WitnessMap,
-        opcode: &Expression,
-    ) -> Result<(), OpcodeResolutionError> {
+    pub(crate) fn solve<F: AcirField>(
+        initial_witness: &mut WitnessMap<F>,
+        opcode: &Expression<F>,
+    ) -> Result<(), OpcodeResolutionError<F>> {
         let opcode = &ExpressionSolver::evaluate(opcode, initial_witness);
         // Evaluate multiplication term
         let mul_result =
@@ -133,14 +133,14 @@ impl ExpressionSolver {
     /// If the witness values are not known, then the function returns a None
     /// XXX: Do we need to account for the case where 5xy + 6x = 0 ? We do not know y, but it can be solved given x . But I believe x can be solved with another opcode
     /// XXX: What about making a mul opcode = a constant 5xy + 7 = 0 ? This is the same as the above.
-    fn solve_mul_term(
-        arith_opcode: &Expression,
-        witness_assignments: &WitnessMap,
-    ) -> Result<MulTerm, OpcodeStatus> {
+    fn solve_mul_term<F: AcirField>(
+        arith_opcode: &Expression<F>,
+        witness_assignments: &WitnessMap<F>,
+    ) -> Result<MulTerm<F>, OpcodeStatus<F>> {
         // First note that the mul term can only contain one/zero term
         // We are assuming it has been optimized.
         match arith_opcode.mul_terms.len() {
-            0 => Ok(MulTerm::Solved(FieldElement::zero())),
+            0 => Ok(MulTerm::Solved(F::zero())),
             1 => Ok(ExpressionSolver::solve_mul_term_helper(
                 &arith_opcode.mul_terms[0],
                 witness_assignments,
@@ -149,10 +149,10 @@ impl ExpressionSolver {
         }
     }
 
-    fn solve_mul_term_helper(
-        term: &(FieldElement, Witness, Witness),
-        witness_assignments: &WitnessMap,
-    ) -> MulTerm {
+    fn solve_mul_term_helper<F: AcirField>(
+        term: &(F, Witness, Witness),
+        witness_assignments: &WitnessMap<F>,
+    ) -> MulTerm<F> {
         let (q_m, w_l, w_r) = term;
         // Check if these values are in the witness assignments
         let w_l_value = witness_assignments.get(w_l);
@@ -166,10 +166,10 @@ impl ExpressionSolver {
         }
     }
 
-    fn solve_fan_in_term_helper(
-        term: &(FieldElement, Witness),
-        witness_assignments: &WitnessMap,
-    ) -> Option<FieldElement> {
+    fn solve_fan_in_term_helper<F: AcirField>(
+        term: &(F, Witness),
+        witness_assignments: &WitnessMap<F>,
+    ) -> Option<F> {
         let (q_l, w_l) = term;
         // Check if we have w_l
         let w_l_value = witness_assignments.get(w_l);
@@ -179,17 +179,17 @@ impl ExpressionSolver {
     /// Returns the summation of all of the variables, plus the unknown variable
     /// Returns None, if there is more than one unknown variable
     /// We cannot assign
-    pub(super) fn solve_fan_in_term(
-        arith_opcode: &Expression,
-        witness_assignments: &WitnessMap,
-    ) -> OpcodeStatus {
+    pub(super) fn solve_fan_in_term<F: AcirField>(
+        arith_opcode: &Expression<F>,
+        witness_assignments: &WitnessMap<F>,
+    ) -> OpcodeStatus<F> {
         // This is assuming that the fan-in is more than 0
 
         // This is the variable that we want to assign the value to
-        let mut unknown_variable = (FieldElement::zero(), Witness::default());
+        let mut unknown_variable = (F::zero(), Witness::default());
         let mut num_unknowns = 0;
         // This is the sum of all of the known variables
-        let mut result = FieldElement::zero();
+        let mut result = F::zero();
 
         for term in arith_opcode.linear_combinations.iter() {
             let value = ExpressionSolver::solve_fan_in_term_helper(term, witness_assignments);
@@ -215,7 +215,10 @@ impl ExpressionSolver {
     }
 
     // Partially evaluate the opcode using the known witnesses
-    pub(crate) fn evaluate(expr: &Expression, initial_witness: &WitnessMap) -> Expression {
+    pub(crate) fn evaluate<F: AcirField>(
+        expr: &Expression<F>,
+        initial_witness: &WitnessMap<F>,
+    ) -> Expression<F> {
         let mut result = Expression::default();
         for &(c, w1, w2) in &expr.mul_terms {
             let mul_result = ExpressionSolver::solve_mul_term_helper(&(c, w1, w2), initial_witness);
@@ -245,43 +248,49 @@ impl ExpressionSolver {
     }
 }
 
-#[test]
-fn expression_solver_smoke_test() {
-    let a = Witness(0);
-    let b = Witness(1);
-    let c = Witness(2);
-    let d = Witness(3);
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use acir::FieldElement;
 
-    // a = b + c + d;
-    let opcode_a = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![
-            (FieldElement::one(), a),
-            (-FieldElement::one(), b),
-            (-FieldElement::one(), c),
-            (-FieldElement::one(), d),
-        ],
-        q_c: FieldElement::zero(),
-    };
+    #[test]
+    fn expression_solver_smoke_test() {
+        let a = Witness(0);
+        let b = Witness(1);
+        let c = Witness(2);
+        let d = Witness(3);
 
-    let e = Witness(4);
-    let opcode_b = Expression {
-        mul_terms: vec![],
-        linear_combinations: vec![
-            (FieldElement::one(), e),
-            (-FieldElement::one(), a),
-            (-FieldElement::one(), b),
-        ],
-        q_c: FieldElement::zero(),
-    };
+        // a = b + c + d;
+        let opcode_a = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![
+                (FieldElement::one(), a),
+                (-FieldElement::one(), b),
+                (-FieldElement::one(), c),
+                (-FieldElement::one(), d),
+            ],
+            q_c: FieldElement::zero(),
+        };
 
-    let mut values = WitnessMap::new();
-    values.insert(b, FieldElement::from(2_i128));
-    values.insert(c, FieldElement::from(1_i128));
-    values.insert(d, FieldElement::from(1_i128));
+        let e = Witness(4);
+        let opcode_b = Expression {
+            mul_terms: vec![],
+            linear_combinations: vec![
+                (FieldElement::one(), e),
+                (-FieldElement::one(), a),
+                (-FieldElement::one(), b),
+            ],
+            q_c: FieldElement::zero(),
+        };
 
-    assert_eq!(ExpressionSolver::solve(&mut values, &opcode_a), Ok(()));
-    assert_eq!(ExpressionSolver::solve(&mut values, &opcode_b), Ok(()));
+        let mut values = WitnessMap::new();
+        values.insert(b, FieldElement::from(2_i128));
+        values.insert(c, FieldElement::from(1_i128));
+        values.insert(d, FieldElement::from(1_i128));
 
-    assert_eq!(values.get(&a).unwrap(), &FieldElement::from(4_i128));
+        assert_eq!(ExpressionSolver::solve(&mut values, &opcode_a), Ok(()));
+        assert_eq!(ExpressionSolver::solve(&mut values, &opcode_b), Ok(()));
+
+        assert_eq!(values.get(&a).unwrap(), &FieldElement::from(4_i128));
+    }
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/acvm-repo/acvm/src/pwg/blackbox/aes128.rs
index c02c59a174f..181a78a2a6a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/aes128.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/aes128.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 use acvm_blackbox_solver::aes128_encrypt;
 
@@ -9,13 +9,13 @@ use crate::{pwg::insert_value, OpcodeResolutionError};
 
 use super::utils::{to_u8_array, to_u8_vec};
 
-pub(super) fn solve_aes128_encryption_opcode(
-    initial_witness: &mut WitnessMap,
+pub(super) fn solve_aes128_encryption_opcode<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     inputs: &[FunctionInput],
     iv: &[FunctionInput; 16],
     key: &[FunctionInput; 16],
     outputs: &[Witness],
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let scalars = to_u8_vec(initial_witness, inputs)?;
 
     let iv = to_u8_array(initial_witness, iv)?;
@@ -25,7 +25,7 @@ pub(super) fn solve_aes128_encryption_opcode(
 
     // Write witness assignments
     for (output_witness, value) in outputs.iter().zip(ciphertext.into_iter()) {
-        insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?;
+        insert_value(output_witness, F::from(value as u128), initial_witness)?;
     }
 
     Ok(())
diff --git a/acvm-repo/acvm/src/pwg/blackbox/bigint.rs b/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
index 3c05fb2761d..be5a4613a55 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    BlackBoxFunc, FieldElement,
+    AcirField, BlackBoxFunc,
 };
 
 use acvm_blackbox_solver::BigIntSolver;
@@ -18,13 +18,13 @@ pub(crate) struct AcvmBigIntSolver {
 }
 
 impl AcvmBigIntSolver {
-    pub(crate) fn bigint_from_bytes(
+    pub(crate) fn bigint_from_bytes<F: AcirField>(
         &mut self,
         inputs: &[FunctionInput],
         modulus: &[u8],
         output: u32,
-        initial_witness: &mut WitnessMap,
-    ) -> Result<(), OpcodeResolutionError> {
+        initial_witness: &mut WitnessMap<F>,
+    ) -> Result<(), OpcodeResolutionError<F>> {
         let bytes = inputs
             .iter()
             .map(|input| initial_witness.get(&input.witness).unwrap().to_u128() as u8)
@@ -33,29 +33,29 @@ impl AcvmBigIntSolver {
         Ok(())
     }
 
-    pub(crate) fn bigint_to_bytes(
+    pub(crate) fn bigint_to_bytes<F: AcirField>(
         &self,
         input: u32,
         outputs: &[Witness],
-        initial_witness: &mut WitnessMap,
-    ) -> Result<(), OpcodeResolutionError> {
+        initial_witness: &mut WitnessMap<F>,
+    ) -> Result<(), OpcodeResolutionError<F>> {
         let mut bytes = self.bigint_solver.bigint_to_bytes(input)?;
         while bytes.len() < outputs.len() {
             bytes.push(0);
         }
         bytes.iter().zip(outputs.iter()).for_each(|(byte, output)| {
-            initial_witness.insert(*output, FieldElement::from(*byte as u128));
+            initial_witness.insert(*output, F::from(*byte as u128));
         });
         Ok(())
     }
 
-    pub(crate) fn bigint_op(
+    pub(crate) fn bigint_op<F>(
         &mut self,
         lhs: u32,
         rhs: u32,
         output: u32,
         func: BlackBoxFunc,
-    ) -> Result<(), OpcodeResolutionError> {
+    ) -> Result<(), OpcodeResolutionError<F>> {
         self.bigint_solver.bigint_op(lhs, rhs, output, func)?;
         Ok(())
     }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs b/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
index 0b52ae295a2..411a6d1b737 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/embedded_curve_ops.rs
@@ -1,18 +1,19 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
+    AcirField,
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
 
 use crate::pwg::{insert_value, witness_to_value, OpcodeResolutionError};
 
-pub(super) fn multi_scalar_mul(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(super) fn multi_scalar_mul<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     points: &[FunctionInput],
     scalars: &[FunctionInput],
     outputs: (Witness, Witness, Witness),
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let points: Result<Vec<_>, _> =
         points.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
     let points: Vec<_> = points?.into_iter().cloned().collect();
@@ -39,13 +40,13 @@ pub(super) fn multi_scalar_mul(
     Ok(())
 }
 
-pub(super) fn embedded_curve_add(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(super) fn embedded_curve_add<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     input1: [FunctionInput; 3],
     input2: [FunctionInput; 3],
     outputs: (Witness, Witness, Witness),
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let input1_x = witness_to_value(initial_witness, input1[0].witness)?;
     let input1_y = witness_to_value(initial_witness, input1[1].witness)?;
     let input1_infinite = witness_to_value(initial_witness, input1[2].witness)?;
diff --git a/acvm-repo/acvm/src/pwg/blackbox/hash.rs b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
index caa09ea8973..fe9bd46b091 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/hash.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 use acvm_blackbox_solver::{sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError};
 
@@ -10,13 +10,13 @@ use crate::OpcodeResolutionError;
 
 /// Attempts to solve a 256 bit hash function opcode.
 /// If successful, `initial_witness` will be mutated to contain the new witness assignment.
-pub(super) fn solve_generic_256_hash_opcode(
-    initial_witness: &mut WitnessMap,
+pub(super) fn solve_generic_256_hash_opcode<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     inputs: &[FunctionInput],
     var_message_size: Option<&FunctionInput>,
     outputs: &[Witness; 32],
     hash_function: fn(data: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError>,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let message_input = get_hash_input(initial_witness, inputs, var_message_size)?;
     let digest: [u8; 32] = hash_function(&message_input)?;
 
@@ -24,11 +24,11 @@ pub(super) fn solve_generic_256_hash_opcode(
 }
 
 /// Reads the hash function input from a [`WitnessMap`].
-fn get_hash_input(
-    initial_witness: &WitnessMap,
+fn get_hash_input<F: AcirField>(
+    initial_witness: &WitnessMap<F>,
     inputs: &[FunctionInput],
     message_size: Option<&FunctionInput>,
-) -> Result<Vec<u8>, OpcodeResolutionError> {
+) -> Result<Vec<u8>, OpcodeResolutionError<F>> {
     // Read witness assignments.
     let mut message_input = Vec::new();
     for input in inputs.iter() {
@@ -62,26 +62,22 @@ fn get_hash_input(
 }
 
 /// Writes a `digest` to the [`WitnessMap`] at witness indices `outputs`.
-fn write_digest_to_outputs(
-    initial_witness: &mut WitnessMap,
+fn write_digest_to_outputs<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     outputs: &[Witness; 32],
     digest: [u8; 32],
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     for (output_witness, value) in outputs.iter().zip(digest.into_iter()) {
-        insert_value(
-            output_witness,
-            FieldElement::from_be_bytes_reduce(&[value]),
-            initial_witness,
-        )?;
+        insert_value(output_witness, F::from_be_bytes_reduce(&[value]), initial_witness)?;
     }
 
     Ok(())
 }
 
-fn to_u32_array<const N: usize>(
-    initial_witness: &WitnessMap,
+fn to_u32_array<const N: usize, F: AcirField>(
+    initial_witness: &WitnessMap<F>,
     inputs: &[FunctionInput; N],
-) -> Result<[u32; N], OpcodeResolutionError> {
+) -> Result<[u32; N], OpcodeResolutionError<F>> {
     let mut result = [0; N];
     for (it, input) in result.iter_mut().zip(inputs) {
         let witness_value = witness_to_value(initial_witness, input.witness)?;
@@ -90,31 +86,31 @@ fn to_u32_array<const N: usize>(
     Ok(result)
 }
 
-pub(crate) fn solve_sha_256_permutation_opcode(
-    initial_witness: &mut WitnessMap,
+pub(crate) fn solve_sha_256_permutation_opcode<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     inputs: &[FunctionInput; 16],
     hash_values: &[FunctionInput; 8],
     outputs: &[Witness; 8],
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let message = to_u32_array(initial_witness, inputs)?;
     let mut state = to_u32_array(initial_witness, hash_values)?;
 
     sha256compression(&mut state, &message);
 
     for (output_witness, value) in outputs.iter().zip(state.into_iter()) {
-        insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?;
+        insert_value(output_witness, F::from(value as u128), initial_witness)?;
     }
 
     Ok(())
 }
 
-pub(crate) fn solve_poseidon2_permutation_opcode(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(crate) fn solve_poseidon2_permutation_opcode<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     inputs: &[FunctionInput],
     outputs: &[Witness],
     len: u32,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     if len as usize != inputs.len() {
         return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
             acir::BlackBoxFunc::Poseidon2Permutation,
diff --git a/acvm-repo/acvm/src/pwg/blackbox/logic.rs b/acvm-repo/acvm/src/pwg/blackbox/logic.rs
index 8e69730f71d..6e2ade3c49b 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/logic.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/logic.rs
@@ -3,17 +3,17 @@ use crate::OpcodeResolutionError;
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 
 /// Solves a [`BlackBoxFunc::And`][acir::circuit::black_box_functions::BlackBoxFunc::AND] opcode and inserts
 /// the result into the supplied witness map
-pub(super) fn and(
-    initial_witness: &mut WitnessMap,
+pub(super) fn and<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     lhs: &FunctionInput,
     rhs: &FunctionInput,
     output: &Witness,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     assert_eq!(
         lhs.num_bits, rhs.num_bits,
         "number of bits specified for each input must be the same"
@@ -25,12 +25,12 @@ pub(super) fn and(
 
 /// Solves a [`BlackBoxFunc::XOR`][acir::circuit::black_box_functions::BlackBoxFunc::XOR] opcode and inserts
 /// the result into the supplied witness map
-pub(super) fn xor(
-    initial_witness: &mut WitnessMap,
+pub(super) fn xor<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     lhs: &FunctionInput,
     rhs: &FunctionInput,
     output: &Witness,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     assert_eq!(
         lhs.num_bits, rhs.num_bits,
         "number of bits specified for each input must be the same"
@@ -41,13 +41,13 @@ pub(super) fn xor(
 }
 
 /// Derives the rest of the witness based on the initial low level variables
-fn solve_logic_opcode(
-    initial_witness: &mut WitnessMap,
+fn solve_logic_opcode<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     a: &Witness,
     b: &Witness,
     result: Witness,
-    logic_op: impl Fn(&FieldElement, &FieldElement) -> FieldElement,
-) -> Result<(), OpcodeResolutionError> {
+    logic_op: impl Fn(&F, &F) -> F,
+) -> Result<(), OpcodeResolutionError<F>> {
     let w_l_value = witness_to_value(initial_witness, *a)?;
     let w_r_value = witness_to_value(initial_witness, *b)?;
     let assignment = logic_op(w_l_value, w_r_value);
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 99ed09a52e4..8bda9221d8a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::opcodes::{BlackBoxFuncCall, FunctionInput},
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256};
 
@@ -37,8 +37,8 @@ use signature::{
 /// Check if all of the inputs to the function have assignments
 ///
 /// Returns the first missing assignment if any are missing
-fn first_missing_assignment(
-    witness_assignments: &WitnessMap,
+fn first_missing_assignment<F>(
+    witness_assignments: &WitnessMap<F>,
     inputs: &[FunctionInput],
 ) -> Option<Witness> {
     inputs.iter().find_map(|input| {
@@ -51,16 +51,16 @@ fn first_missing_assignment(
 }
 
 /// Check if all of the inputs to the function have assignments
-fn contains_all_inputs(witness_assignments: &WitnessMap, inputs: &[FunctionInput]) -> bool {
+fn contains_all_inputs<F>(witness_assignments: &WitnessMap<F>, inputs: &[FunctionInput]) -> bool {
     inputs.iter().all(|input| witness_assignments.contains_key(&input.witness))
 }
 
-pub(crate) fn solve(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(crate) fn solve<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     bb_func: &BlackBoxFuncCall,
     bigint_solver: &mut AcvmBigIntSolver,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let inputs = bb_func.get_inputs_vec();
     if !contains_all_inputs(initial_witness, &inputs) {
         let unassigned_witness = first_missing_assignment(initial_witness, &inputs)
@@ -108,7 +108,7 @@ pub(crate) fn solve(
             }
             let output_state = keccakf1600(state)?;
             for (output_witness, value) in outputs.iter().zip(output_state.into_iter()) {
-                insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?;
+                insert_value(output_witness, F::from(value as u128), initial_witness)?;
             }
             Ok(())
         }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs b/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
index bb214c1ceaf..f64a3a79465 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
@@ -1,6 +1,7 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
+    AcirField,
 };
 
 use crate::{
@@ -8,13 +9,13 @@ use crate::{
     BlackBoxFunctionSolver,
 };
 
-pub(super) fn pedersen(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(super) fn pedersen<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     inputs: &[FunctionInput],
     domain_separator: u32,
     outputs: (Witness, Witness),
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let scalars: Result<Vec<_>, _> =
         inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
     let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
@@ -27,13 +28,13 @@ pub(super) fn pedersen(
     Ok(())
 }
 
-pub(super) fn pedersen_hash(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(super) fn pedersen_hash<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     inputs: &[FunctionInput],
     domain_separator: u32,
     output: Witness,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let scalars: Result<Vec<_>, _> =
         inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
     let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
diff --git a/acvm-repo/acvm/src/pwg/blackbox/range.rs b/acvm-repo/acvm/src/pwg/blackbox/range.rs
index aac50b32fc8..0ca001aff7a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/range.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/range.rs
@@ -2,12 +2,12 @@ use crate::{
     pwg::{witness_to_value, ErrorLocation},
     OpcodeResolutionError,
 };
-use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
+use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap, AcirField};
 
-pub(crate) fn solve_range_opcode(
-    initial_witness: &WitnessMap,
+pub(crate) fn solve_range_opcode<F: AcirField>(
+    initial_witness: &WitnessMap<F>,
     input: &FunctionInput,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let w_value = witness_to_value(initial_witness, input.witness)?;
     if w_value.num_bits() > input.num_bits {
         return Err(OpcodeResolutionError::UnsatisfiedConstrain {
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
index ce2e57e0bd7..707e3f26af0 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs
@@ -1,7 +1,7 @@
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 use acvm_blackbox_solver::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 
@@ -13,14 +13,14 @@ use crate::{
     OpcodeResolutionError,
 };
 
-pub(crate) fn secp256k1_prehashed(
-    initial_witness: &mut WitnessMap,
+pub(crate) fn secp256k1_prehashed<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     public_key_x_inputs: &[FunctionInput; 32],
     public_key_y_inputs: &[FunctionInput; 32],
     signature_inputs: &[FunctionInput; 64],
     hashed_message_inputs: &[FunctionInput],
     output: Witness,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let hashed_message = to_u8_vec(initial_witness, hashed_message_inputs)?;
 
     let pub_key_x: [u8; 32] = to_u8_array(initial_witness, public_key_x_inputs)?;
@@ -29,17 +29,17 @@ pub(crate) fn secp256k1_prehashed(
 
     let is_valid = ecdsa_secp256k1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?;
 
-    insert_value(&output, FieldElement::from(is_valid), initial_witness)
+    insert_value(&output, F::from(is_valid), initial_witness)
 }
 
-pub(crate) fn secp256r1_prehashed(
-    initial_witness: &mut WitnessMap,
+pub(crate) fn secp256r1_prehashed<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
     public_key_x_inputs: &[FunctionInput; 32],
     public_key_y_inputs: &[FunctionInput; 32],
     signature_inputs: &[FunctionInput; 64],
     hashed_message_inputs: &[FunctionInput],
     output: Witness,
-) -> Result<(), OpcodeResolutionError> {
+) -> Result<(), OpcodeResolutionError<F>> {
     let hashed_message = to_u8_vec(initial_witness, hashed_message_inputs)?;
 
     let pub_key_x: [u8; 32] = to_u8_array(initial_witness, public_key_x_inputs)?;
@@ -48,5 +48,5 @@ pub(crate) fn secp256r1_prehashed(
 
     let is_valid = ecdsa_secp256r1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?;
 
-    insert_value(&output, FieldElement::from(is_valid), initial_witness)
+    insert_value(&output, F::from(is_valid), initial_witness)
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
index 7b085d9ff47..5e0ac94f8be 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
@@ -8,21 +8,21 @@ use crate::{
 use acir::{
     circuit::opcodes::FunctionInput,
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 
 #[allow(clippy::too_many_arguments)]
-pub(crate) fn schnorr_verify(
-    backend: &impl BlackBoxFunctionSolver,
-    initial_witness: &mut WitnessMap,
+pub(crate) fn schnorr_verify<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
     public_key_x: FunctionInput,
     public_key_y: FunctionInput,
     signature: &[FunctionInput; 64],
     message: &[FunctionInput],
     output: Witness,
-) -> Result<(), OpcodeResolutionError> {
-    let public_key_x: &FieldElement = witness_to_value(initial_witness, public_key_x.witness)?;
-    let public_key_y: &FieldElement = witness_to_value(initial_witness, public_key_y.witness)?;
+) -> Result<(), OpcodeResolutionError<F>> {
+    let public_key_x: &F = witness_to_value(initial_witness, public_key_x.witness)?;
+    let public_key_y: &F = witness_to_value(initial_witness, public_key_y.witness)?;
 
     let signature = to_u8_array(initial_witness, signature)?;
     let message = to_u8_vec(initial_witness, message)?;
@@ -30,7 +30,7 @@ pub(crate) fn schnorr_verify(
     let valid_signature =
         backend.schnorr_verify(public_key_x, public_key_y, &signature, &message)?;
 
-    insert_value(&output, FieldElement::from(valid_signature), initial_witness)?;
+    insert_value(&output, F::from(valid_signature), initial_witness)?;
 
     Ok(())
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/utils.rs b/acvm-repo/acvm/src/pwg/blackbox/utils.rs
index 700f30890ae..6880d21a324 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/utils.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/utils.rs
@@ -1,11 +1,11 @@
-use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
+use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap, AcirField};
 
 use crate::pwg::{witness_to_value, OpcodeResolutionError};
 
-pub(crate) fn to_u8_array<const N: usize>(
-    initial_witness: &WitnessMap,
+pub(crate) fn to_u8_array<const N: usize, F: AcirField>(
+    initial_witness: &WitnessMap<F>,
     inputs: &[FunctionInput; N],
-) -> Result<[u8; N], OpcodeResolutionError> {
+) -> Result<[u8; N], OpcodeResolutionError<F>> {
     let mut result = [0; N];
     for (it, input) in result.iter_mut().zip(inputs) {
         let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
@@ -17,10 +17,10 @@ pub(crate) fn to_u8_array<const N: usize>(
     Ok(result)
 }
 
-pub(crate) fn to_u8_vec(
-    initial_witness: &WitnessMap,
+pub(crate) fn to_u8_vec<F: AcirField>(
+    initial_witness: &WitnessMap<F>,
     inputs: &[FunctionInput],
-) -> Result<Vec<u8>, OpcodeResolutionError> {
+) -> Result<Vec<u8>, OpcodeResolutionError<F>> {
     let mut result = Vec::with_capacity(inputs.len());
     for input in inputs {
         let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes();
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index c911202c823..7e6c207b69a 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -9,7 +9,7 @@ use acir::{
         STRING_ERROR_SELECTOR,
     },
     native_types::WitnessMap,
-    FieldElement,
+    AcirField,
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use brillig_vm::{FailureReason, MemoryValue, VMStatus, VM};
@@ -19,31 +19,31 @@ use crate::{pwg::OpcodeNotSolvable, OpcodeResolutionError};
 use super::{get_value, insert_value, memory_op::MemoryOpSolver};
 
 #[derive(Debug)]
-pub enum BrilligSolverStatus {
+pub enum BrilligSolverStatus<F> {
     Finished,
     InProgress,
-    ForeignCallWait(ForeignCallWaitInfo),
+    ForeignCallWait(ForeignCallWaitInfo<F>),
 }
 
-pub struct BrilligSolver<'b, B: BlackBoxFunctionSolver> {
-    vm: VM<'b, B>,
+pub struct BrilligSolver<'b, F, B: BlackBoxFunctionSolver<F>> {
+    vm: VM<'b, F, B>,
     acir_index: usize,
 }
 
-impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
+impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
     /// Assigns the zero value to all outputs of the given [`Brillig`] bytecode.
     pub(super) fn zero_out_brillig_outputs(
-        initial_witness: &mut WitnessMap,
+        initial_witness: &mut WitnessMap<F>,
         outputs: &[BrilligOutputs],
-    ) -> Result<(), OpcodeResolutionError> {
+    ) -> Result<(), OpcodeResolutionError<F>> {
         for output in outputs {
             match output {
                 BrilligOutputs::Simple(witness) => {
-                    insert_value(witness, FieldElement::zero(), initial_witness)?;
+                    insert_value(witness, F::zero(), initial_witness)?;
                 }
                 BrilligOutputs::Array(witness_arr) => {
                     for witness in witness_arr {
-                        insert_value(witness, FieldElement::zero(), initial_witness)?;
+                        insert_value(witness, F::zero(), initial_witness)?;
                     }
                 }
             }
@@ -54,27 +54,27 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
     /// Constructs a solver for a Brillig block given the bytecode and initial
     /// witness.
     pub(crate) fn new_call(
-        initial_witness: &WitnessMap,
-        memory: &HashMap<BlockId, MemoryOpSolver>,
-        inputs: &'b [BrilligInputs],
-        brillig_bytecode: &'b [BrilligOpcode],
+        initial_witness: &WitnessMap<F>,
+        memory: &HashMap<BlockId, MemoryOpSolver<F>>,
+        inputs: &'b [BrilligInputs<F>],
+        brillig_bytecode: &'b [BrilligOpcode<F>],
         bb_solver: &'b B,
         acir_index: usize,
-    ) -> Result<Self, OpcodeResolutionError> {
+    ) -> Result<Self, OpcodeResolutionError<F>> {
         let vm =
             Self::setup_brillig_vm(initial_witness, memory, inputs, brillig_bytecode, bb_solver)?;
         Ok(Self { vm, acir_index })
     }
 
     fn setup_brillig_vm(
-        initial_witness: &WitnessMap,
-        memory: &HashMap<BlockId, MemoryOpSolver>,
-        inputs: &[BrilligInputs],
-        brillig_bytecode: &'b [BrilligOpcode],
+        initial_witness: &WitnessMap<F>,
+        memory: &HashMap<BlockId, MemoryOpSolver<F>>,
+        inputs: &[BrilligInputs<F>],
+        brillig_bytecode: &'b [BrilligOpcode<F>],
         bb_solver: &'b B,
-    ) -> Result<VM<'b, B>, OpcodeResolutionError> {
+    ) -> Result<VM<'b, F, B>, OpcodeResolutionError<F>> {
         // Set input values
-        let mut calldata: Vec<FieldElement> = Vec::new();
+        let mut calldata: Vec<F> = Vec::new();
         // Each input represents an expression or array of expressions to evaluate.
         // Iterate over each input and evaluate the expression(s) associated with it.
         // Push the results into memory.
@@ -123,11 +123,11 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         Ok(vm)
     }
 
-    pub fn get_memory(&self) -> &[MemoryValue] {
+    pub fn get_memory(&self) -> &[MemoryValue<F>] {
         self.vm.get_memory()
     }
 
-    pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue) {
+    pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue<F>) {
         self.vm.write_memory_at(ptr, value);
     }
 
@@ -135,12 +135,12 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         self.vm.get_call_stack()
     }
 
-    pub(crate) fn solve(&mut self) -> Result<BrilligSolverStatus, OpcodeResolutionError> {
+    pub(crate) fn solve(&mut self) -> Result<BrilligSolverStatus<F>, OpcodeResolutionError<F>> {
         let status = self.vm.process_opcodes();
         self.handle_vm_status(status)
     }
 
-    pub fn step(&mut self) -> Result<BrilligSolverStatus, OpcodeResolutionError> {
+    pub fn step(&mut self) -> Result<BrilligSolverStatus<F>, OpcodeResolutionError<F>> {
         let status = self.vm.process_opcode();
         self.handle_vm_status(status)
     }
@@ -151,8 +151,8 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
 
     fn handle_vm_status(
         &self,
-        vm_status: VMStatus,
-    ) -> Result<BrilligSolverStatus, OpcodeResolutionError> {
+        vm_status: VMStatus<F>,
+    ) -> Result<BrilligSolverStatus<F>, OpcodeResolutionError<F>> {
         // Check the status of the Brillig VM and return a resolution.
         // It may be finished, in-progress, failed, or may be waiting for results of a foreign call.
         // Return the "resolution" to the caller who may choose to make subsequent calls
@@ -227,9 +227,9 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
 
     pub(crate) fn finalize(
         self,
-        witness: &mut WitnessMap,
+        witness: &mut WitnessMap<F>,
         outputs: &[BrilligOutputs],
-    ) -> Result<(), OpcodeResolutionError> {
+    ) -> Result<(), OpcodeResolutionError<F>> {
         // Finish the Brillig execution by writing the outputs to the witness map
         let vm_status = self.vm.get_status();
         match vm_status {
@@ -243,11 +243,11 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
 
     fn write_brillig_outputs(
         &self,
-        witness_map: &mut WitnessMap,
+        witness_map: &mut WitnessMap<F>,
         return_data_offset: usize,
         return_data_size: usize,
         outputs: &[BrilligOutputs],
-    ) -> Result<(), OpcodeResolutionError> {
+    ) -> Result<(), OpcodeResolutionError<F>> {
         // Write VM execution results into the witness map
         let memory = self.vm.get_memory();
         let mut current_ret_data_idx = return_data_offset;
@@ -274,7 +274,7 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         Ok(())
     }
 
-    pub fn resolve_pending_foreign_call(&mut self, foreign_call_result: ForeignCallResult) {
+    pub fn resolve_pending_foreign_call(&mut self, foreign_call_result: ForeignCallResult<F>) {
         match self.vm.get_status() {
             VMStatus::ForeignCallWait { .. } => self.vm.resolve_foreign_call(foreign_call_result),
             _ => unreachable!("Brillig VM is not waiting for a foreign call"),
@@ -287,9 +287,9 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
 ///
 /// The caller must resolve this opcode externally based upon the information in the request.
 #[derive(Debug, PartialEq, Clone)]
-pub struct ForeignCallWaitInfo {
+pub struct ForeignCallWaitInfo<F> {
     /// An identifier interpreted by the caller process
     pub function: String,
     /// Resolved inputs to a foreign call computed in the previous steps of a Brillig VM process
-    pub inputs: Vec<ForeignCallParam>,
+    pub inputs: Vec<ForeignCallParam<F>>,
 }
diff --git a/acvm-repo/acvm/src/pwg/directives/mod.rs b/acvm-repo/acvm/src/pwg/directives/mod.rs
index db79379a374..d7bee88c278 100644
--- a/acvm-repo/acvm/src/pwg/directives/mod.rs
+++ b/acvm-repo/acvm/src/pwg/directives/mod.rs
@@ -1,4 +1,4 @@
-use acir::{circuit::directives::Directive, native_types::WitnessMap, FieldElement};
+use acir::{circuit::directives::Directive, native_types::WitnessMap, AcirField};
 use num_bigint::BigUint;
 
 use crate::OpcodeResolutionError;
@@ -11,10 +11,10 @@ use super::{get_value, insert_value, ErrorLocation};
 /// Returns `Ok(OpcodeResolution)` to signal whether the directive was successful solved.
 ///
 /// Returns `Err(OpcodeResolutionError)` if a circuit constraint is unsatisfied.
-pub(crate) fn solve_directives(
-    initial_witness: &mut WitnessMap,
-    directive: &Directive,
-) -> Result<(), OpcodeResolutionError> {
+pub(crate) fn solve_directives<F: AcirField>(
+    initial_witness: &mut WitnessMap<F>,
+    directive: &Directive<F>,
+) -> Result<(), OpcodeResolutionError<F>> {
     match directive {
         Directive::ToLeRadix { a, b, radix } => {
             let value_a = get_value(a, initial_witness)?;
@@ -36,8 +36,8 @@ pub(crate) fn solve_directives(
                 // If it is not available, which can happen when the decomposed integer
                 // list is shorter than the witness list, we return 0.
                 let value = match decomposed_integer.get(i) {
-                    Some(digit) => FieldElement::from_be_bytes_reduce(&[*digit]),
-                    None => FieldElement::zero(),
+                    Some(digit) => F::from_be_bytes_reduce(&[*digit]),
+                    None => F::zero(),
                 };
 
                 insert_value(witness, value, initial_witness)?;
diff --git a/acvm-repo/acvm/src/pwg/memory_op.rs b/acvm-repo/acvm/src/pwg/memory_op.rs
index 672c13e11c2..a9ed7f5d15b 100644
--- a/acvm-repo/acvm/src/pwg/memory_op.rs
+++ b/acvm-repo/acvm/src/pwg/memory_op.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use acir::{
     circuit::opcodes::MemOp,
     native_types::{Expression, Witness, WitnessMap},
-    FieldElement,
+    AcirField,
 };
 
 use super::{
@@ -15,17 +15,17 @@ type MemoryIndex = u32;
 
 /// Maintains the state for solving [`MemoryInit`][`acir::circuit::Opcode::MemoryInit`] and [`MemoryOp`][`acir::circuit::Opcode::MemoryOp`] opcodes.
 #[derive(Default)]
-pub(crate) struct MemoryOpSolver {
-    pub(super) block_value: HashMap<MemoryIndex, FieldElement>,
+pub(crate) struct MemoryOpSolver<F> {
+    pub(super) block_value: HashMap<MemoryIndex, F>,
     pub(super) block_len: u32,
 }
 
-impl MemoryOpSolver {
+impl<F: AcirField> MemoryOpSolver<F> {
     fn write_memory_index(
         &mut self,
         index: MemoryIndex,
-        value: FieldElement,
-    ) -> Result<(), OpcodeResolutionError> {
+        value: F,
+    ) -> Result<(), OpcodeResolutionError<F>> {
         if index >= self.block_len {
             return Err(OpcodeResolutionError::IndexOutOfBounds {
                 opcode_location: ErrorLocation::Unresolved,
@@ -37,7 +37,7 @@ impl MemoryOpSolver {
         Ok(())
     }
 
-    fn read_memory_index(&self, index: MemoryIndex) -> Result<FieldElement, OpcodeResolutionError> {
+    fn read_memory_index(&self, index: MemoryIndex) -> Result<F, OpcodeResolutionError<F>> {
         self.block_value.get(&index).copied().ok_or(OpcodeResolutionError::IndexOutOfBounds {
             opcode_location: ErrorLocation::Unresolved,
             index,
@@ -49,8 +49,8 @@ impl MemoryOpSolver {
     pub(crate) fn init(
         &mut self,
         init: &[Witness],
-        initial_witness: &WitnessMap,
-    ) -> Result<(), OpcodeResolutionError> {
+        initial_witness: &WitnessMap<F>,
+    ) -> Result<(), OpcodeResolutionError<F>> {
         self.block_len = init.len() as u32;
         for (memory_index, witness) in init.iter().enumerate() {
             self.write_memory_index(
@@ -63,10 +63,10 @@ impl MemoryOpSolver {
 
     pub(crate) fn solve_memory_op(
         &mut self,
-        op: &MemOp,
-        initial_witness: &mut WitnessMap,
-        predicate: &Option<Expression>,
-    ) -> Result<(), OpcodeResolutionError> {
+        op: &MemOp<F>,
+        initial_witness: &mut WitnessMap<F>,
+        predicate: &Option<Expression<F>>,
+    ) -> Result<(), OpcodeResolutionError<F>> {
         let operation = get_value(&op.operation, initial_witness)?;
 
         // Find the memory index associated with this memory operation.
@@ -96,11 +96,8 @@ impl MemoryOpSolver {
 
             // A zero predicate indicates that we should skip the read operation
             // and zero out the operation's output.
-            let value_in_array = if skip_operation {
-                FieldElement::zero()
-            } else {
-                self.read_memory_index(memory_index)?
-            };
+            let value_in_array =
+                if skip_operation { F::zero() } else { self.read_memory_index(memory_index)? };
             insert_value(&value_read_witness, value_in_array, initial_witness)
         } else {
             // `arr[memory_index] = value_write`
@@ -129,7 +126,7 @@ mod tests {
     use acir::{
         circuit::opcodes::MemOp,
         native_types::{Expression, Witness, WitnessMap},
-        FieldElement,
+        AcirField, FieldElement,
     };
 
     use super::MemoryOpSolver;
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index f2649b93991..da4510db63a 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -10,7 +10,7 @@ use acir::{
         STRING_ERROR_SELECTOR,
     },
     native_types::{Expression, Witness, WitnessMap},
-    BlackBoxFunc, FieldElement,
+    AcirField, BlackBoxFunc,
 };
 use acvm_blackbox_solver::BlackBoxResolutionError;
 
@@ -36,7 +36,7 @@ pub use self::brillig::{BrilligSolver, BrilligSolverStatus};
 pub use brillig::ForeignCallWaitInfo;
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum ACVMStatus {
+pub enum ACVMStatus<F> {
     /// All opcodes have been solved.
     Solved,
 
@@ -45,23 +45,23 @@ pub enum ACVMStatus {
 
     /// The ACVM has encountered an irrecoverable error while executing the circuit and can not progress.
     /// Most commonly this will be due to an unsatisfied constraint due to invalid inputs to the circuit.
-    Failure(OpcodeResolutionError),
+    Failure(OpcodeResolutionError<F>),
 
     /// The ACVM has encountered a request for a Brillig [foreign call][acir::brillig_vm::Opcode::ForeignCall]
     /// to retrieve information from outside of the ACVM. The result of the foreign call must be passed back
     /// to the ACVM using [`ACVM::resolve_pending_foreign_call`].
     ///
     /// Once this is done, the ACVM can be restarted to solve the remaining opcodes.
-    RequiresForeignCall(ForeignCallWaitInfo),
+    RequiresForeignCall(ForeignCallWaitInfo<F>),
 
     /// The ACVM has encountered a request for an ACIR [call][acir::circuit::Opcode]
     /// to execute a separate ACVM instance. The result of the ACIR call must be passd back to the ACVM.
     ///
     /// Once this is done, the ACVM can be restarted to solve the remaining opcodes.
-    RequiresAcirCall(AcirCallWaitInfo),
+    RequiresAcirCall(AcirCallWaitInfo<F>),
 }
 
-impl std::fmt::Display for ACVMStatus {
+impl<F> std::fmt::Display for ACVMStatus<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ACVMStatus::Solved => write!(f, "Solved"),
@@ -73,9 +73,9 @@ impl std::fmt::Display for ACVMStatus {
     }
 }
 
-pub enum StepResult<'a, B: BlackBoxFunctionSolver> {
-    Status(ACVMStatus),
-    IntoBrillig(BrilligSolver<'a, B>),
+pub enum StepResult<'a, F, B: BlackBoxFunctionSolver<F>> {
+    Status(ACVMStatus<F>),
+    IntoBrillig(BrilligSolver<'a, F, B>),
 }
 
 // This enum represents the different cases in which an
@@ -87,13 +87,13 @@ pub enum StepResult<'a, B: BlackBoxFunctionSolver> {
 // TODO: we could have a error enum for expression solver failure cases in that module
 // TODO that can be converted into an OpcodeNotSolvable or OpcodeResolutionError enum
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
-pub enum OpcodeNotSolvable {
+pub enum OpcodeNotSolvable<F> {
     #[error("missing assignment for witness index {0}")]
     MissingAssignment(u32),
     #[error("Attempted to load uninitialized memory block")]
     MissingMemoryBlock(u32),
     #[error("expression has too many unknowns {0}")]
-    ExpressionHasTooManyUnknowns(Expression),
+    ExpressionHasTooManyUnknowns(Expression<F>),
 }
 
 /// Allows to point to a specific opcode as cause in errors.
@@ -117,13 +117,13 @@ impl std::fmt::Display for ErrorLocation {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
-pub enum OpcodeResolutionError {
+pub enum OpcodeResolutionError<F> {
     #[error("Cannot solve opcode: {0}")]
-    OpcodeNotSolvable(#[from] OpcodeNotSolvable),
+    OpcodeNotSolvable(#[from] OpcodeNotSolvable<F>),
     #[error("Cannot satisfy constraint")]
     UnsatisfiedConstrain {
         opcode_location: ErrorLocation,
-        payload: Option<ResolvedAssertionPayload>,
+        payload: Option<ResolvedAssertionPayload<F>>,
     },
     #[error("Index out of bounds, array has size {array_size:?}, but index was {index:?}")]
     IndexOutOfBounds { opcode_location: ErrorLocation, index: u32, array_size: u32 },
@@ -132,7 +132,7 @@ pub enum OpcodeResolutionError {
     #[error("Failed to solve brillig function")]
     BrilligFunctionFailed {
         call_stack: Vec<OpcodeLocation>,
-        payload: Option<ResolvedAssertionPayload>,
+        payload: Option<ResolvedAssertionPayload<F>>,
     },
     #[error("Attempted to call `main` with a `Call` opcode")]
     AcirMainCallAttempted { opcode_location: ErrorLocation },
@@ -140,7 +140,7 @@ pub enum OpcodeResolutionError {
     AcirCallOutputsMismatch { opcode_location: ErrorLocation, results_size: u32, outputs_size: u32 },
 }
 
-impl From<BlackBoxResolutionError> for OpcodeResolutionError {
+impl<F> From<BlackBoxResolutionError> for OpcodeResolutionError<F> {
     fn from(value: BlackBoxResolutionError) -> Self {
         match value {
             BlackBoxResolutionError::Failed(func, reason) => {
@@ -150,45 +150,45 @@ impl From<BlackBoxResolutionError> for OpcodeResolutionError {
     }
 }
 
-pub struct ACVM<'a, B: BlackBoxFunctionSolver> {
-    status: ACVMStatus,
+pub struct ACVM<'a, F, B: BlackBoxFunctionSolver<F>> {
+    status: ACVMStatus<F>,
 
     backend: &'a B,
 
     /// Stores the solver for memory operations acting on blocks of memory disambiguated by [block][`BlockId`].
-    block_solvers: HashMap<BlockId, MemoryOpSolver>,
+    block_solvers: HashMap<BlockId, MemoryOpSolver<F>>,
 
     bigint_solver: AcvmBigIntSolver,
 
     /// A list of opcodes which are to be executed by the ACVM.
-    opcodes: &'a [Opcode],
+    opcodes: &'a [Opcode<F>],
     /// Index of the next opcode to be executed.
     instruction_pointer: usize,
 
-    witness_map: WitnessMap,
+    witness_map: WitnessMap<F>,
 
-    brillig_solver: Option<BrilligSolver<'a, B>>,
+    brillig_solver: Option<BrilligSolver<'a, F, B>>,
 
     /// A counter maintained throughout an ACVM process that determines
     /// whether the caller has resolved the results of an ACIR [call][Opcode::Call].
     acir_call_counter: usize,
     /// Represents the outputs of all ACIR calls during an ACVM process
     /// List is appended onto by the caller upon reaching a [ACVMStatus::RequiresAcirCall]
-    acir_call_results: Vec<Vec<FieldElement>>,
+    acir_call_results: Vec<Vec<F>>,
 
     // Each unconstrained function referenced in the program
-    unconstrained_functions: &'a [BrilligBytecode],
+    unconstrained_functions: &'a [BrilligBytecode<F>],
 
-    assertion_payloads: &'a [(OpcodeLocation, AssertionPayload)],
+    assertion_payloads: &'a [(OpcodeLocation, AssertionPayload<F>)],
 }
 
-impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
+impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
     pub fn new(
         backend: &'a B,
-        opcodes: &'a [Opcode],
-        initial_witness: WitnessMap,
-        unconstrained_functions: &'a [BrilligBytecode],
-        assertion_payloads: &'a [(OpcodeLocation, AssertionPayload)],
+        opcodes: &'a [Opcode<F>],
+        initial_witness: WitnessMap<F>,
+        unconstrained_functions: &'a [BrilligBytecode<F>],
+        assertion_payloads: &'a [(OpcodeLocation, AssertionPayload<F>)],
     ) -> Self {
         let status = if opcodes.is_empty() { ACVMStatus::Solved } else { ACVMStatus::InProgress };
         ACVM {
@@ -210,20 +210,16 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     /// Returns a reference to the current state of the ACVM's [`WitnessMap`].
     ///
     /// Once execution has completed, the witness map can be extracted using [`ACVM::finalize`]
-    pub fn witness_map(&self) -> &WitnessMap {
+    pub fn witness_map(&self) -> &WitnessMap<F> {
         &self.witness_map
     }
 
-    pub fn overwrite_witness(
-        &mut self,
-        witness: Witness,
-        value: FieldElement,
-    ) -> Option<FieldElement> {
+    pub fn overwrite_witness(&mut self, witness: Witness, value: F) -> Option<F> {
         self.witness_map.insert(witness, value)
     }
 
     /// Returns a slice containing the opcodes of the circuit being executed.
-    pub fn opcodes(&self) -> &[Opcode] {
+    pub fn opcodes(&self) -> &[Opcode<F>] {
         self.opcodes
     }
 
@@ -233,7 +229,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     }
 
     /// Finalize the ACVM execution, returning the resulting [`WitnessMap`].
-    pub fn finalize(self) -> WitnessMap {
+    pub fn finalize(self) -> WitnessMap<F> {
         if self.status != ACVMStatus::Solved {
             panic!("ACVM execution is not complete: ({})", self.status);
         }
@@ -242,29 +238,29 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
 
     /// Updates the current status of the VM.
     /// Returns the given status.
-    fn status(&mut self, status: ACVMStatus) -> ACVMStatus {
+    fn status(&mut self, status: ACVMStatus<F>) -> ACVMStatus<F> {
         self.status = status.clone();
         status
     }
 
-    pub fn get_status(&self) -> &ACVMStatus {
+    pub fn get_status(&self) -> &ACVMStatus<F> {
         &self.status
     }
 
     /// Sets the VM status to [ACVMStatus::Failure] using the provided `error`.
     /// Returns the new status.
-    fn fail(&mut self, error: OpcodeResolutionError) -> ACVMStatus {
+    fn fail(&mut self, error: OpcodeResolutionError<F>) -> ACVMStatus<F> {
         self.status(ACVMStatus::Failure(error))
     }
 
     /// Sets the status of the VM to `RequiresForeignCall`.
     /// Indicating that the VM is now waiting for a foreign call to be resolved.
-    fn wait_for_foreign_call(&mut self, foreign_call: ForeignCallWaitInfo) -> ACVMStatus {
+    fn wait_for_foreign_call(&mut self, foreign_call: ForeignCallWaitInfo<F>) -> ACVMStatus<F> {
         self.status(ACVMStatus::RequiresForeignCall(foreign_call))
     }
 
     /// Return a reference to the arguments for the next pending foreign call, if one exists.
-    pub fn get_pending_foreign_call(&self) -> Option<&ForeignCallWaitInfo> {
+    pub fn get_pending_foreign_call(&self) -> Option<&ForeignCallWaitInfo<F>> {
         if let ACVMStatus::RequiresForeignCall(foreign_call) = &self.status {
             Some(foreign_call)
         } else {
@@ -275,7 +271,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     /// Resolves a foreign call's [result][acir::brillig_vm::ForeignCallResult] using a result calculated outside of the ACVM.
     ///
     /// The ACVM can then be restarted to solve the remaining Brillig VM process as well as the remaining ACIR opcodes.
-    pub fn resolve_pending_foreign_call(&mut self, foreign_call_result: ForeignCallResult) {
+    pub fn resolve_pending_foreign_call(&mut self, foreign_call_result: ForeignCallResult<F>) {
         if !matches!(self.status, ACVMStatus::RequiresForeignCall(_)) {
             panic!("ACVM is not expecting a foreign call response as no call was made");
         }
@@ -289,14 +285,14 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
 
     /// Sets the status of the VM to `RequiresAcirCall`
     /// Indicating that the VM is now waiting for an ACIR call to be resolved
-    fn wait_for_acir_call(&mut self, acir_call: AcirCallWaitInfo) -> ACVMStatus {
+    fn wait_for_acir_call(&mut self, acir_call: AcirCallWaitInfo<F>) -> ACVMStatus<F> {
         self.status(ACVMStatus::RequiresAcirCall(acir_call))
     }
 
     /// Resolves an ACIR call's result (simply a list of fields) using a result calculated by a separate ACVM instance.
     ///
     /// The current ACVM instance can then be restarted to solve the remaining ACIR opcodes.
-    pub fn resolve_pending_acir_call(&mut self, call_result: Vec<FieldElement>) {
+    pub fn resolve_pending_acir_call(&mut self, call_result: Vec<F>) {
         if !matches!(self.status, ACVMStatus::RequiresAcirCall(_)) {
             panic!("ACVM is not expecting an ACIR call response as no call was made");
         }
@@ -316,14 +312,14 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     /// 1. All opcodes have been executed successfully.
     /// 2. The circuit has been found to be unsatisfiable.
     /// 2. A Brillig [foreign call][`ForeignCallWaitInfo`] has been encountered and must be resolved.
-    pub fn solve(&mut self) -> ACVMStatus {
+    pub fn solve(&mut self) -> ACVMStatus<F> {
         while self.status == ACVMStatus::InProgress {
             self.solve_opcode();
         }
         self.status.clone()
     }
 
-    pub fn solve_opcode(&mut self) -> ACVMStatus {
+    pub fn solve_opcode(&mut self) -> ACVMStatus<F> {
         let opcode = &self.opcodes[self.instruction_pointer];
 
         let resolution = match opcode {
@@ -357,8 +353,8 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
 
     fn handle_opcode_resolution(
         &mut self,
-        resolution: Result<(), OpcodeResolutionError>,
-    ) -> ACVMStatus {
+        resolution: Result<(), OpcodeResolutionError<F>>,
+    ) -> ACVMStatus<F> {
         match resolution {
             Ok(()) => {
                 self.instruction_pointer += 1;
@@ -400,7 +396,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
     fn extract_assertion_payload(
         &self,
         location: OpcodeLocation,
-    ) -> Option<ResolvedAssertionPayload> {
+    ) -> Option<ResolvedAssertionPayload<F>> {
         let (_, found_assertion_payload) =
             self.assertion_payloads.iter().find(|(loc, _)| location == *loc)?;
         match found_assertion_payload {
@@ -458,7 +454,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
 
     fn solve_brillig_call_opcode(
         &mut self,
-    ) -> Result<Option<ForeignCallWaitInfo>, OpcodeResolutionError> {
+    ) -> Result<Option<ForeignCallWaitInfo<F>>, OpcodeResolutionError<F>> {
         let Opcode::BrilligCall { id, inputs, outputs, predicate } =
             &self.opcodes[self.instruction_pointer]
         else {
@@ -466,13 +462,13 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         };
 
         if is_predicate_false(&self.witness_map, predicate)? {
-            return BrilligSolver::<B>::zero_out_brillig_outputs(&mut self.witness_map, outputs)
+            return BrilligSolver::<F, B>::zero_out_brillig_outputs(&mut self.witness_map, outputs)
                 .map(|_| None);
         }
 
         // If we're resuming execution after resolving a foreign call then
         // there will be a cached `BrilligSolver` to avoid recomputation.
-        let mut solver: BrilligSolver<'_, B> = match self.brillig_solver.take() {
+        let mut solver: BrilligSolver<'_, F, B> = match self.brillig_solver.take() {
             Some(solver) => solver,
             None => BrilligSolver::new_call(
                 &self.witness_map,
@@ -503,7 +499,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         }
     }
 
-    fn map_brillig_error(&self, mut err: OpcodeResolutionError) -> OpcodeResolutionError {
+    fn map_brillig_error(&self, mut err: OpcodeResolutionError<F>) -> OpcodeResolutionError<F> {
         match &mut err {
             OpcodeResolutionError::BrilligFunctionFailed { call_stack, payload } => {
                 // Some brillig errors have static strings as payloads, we can resolve them here
@@ -528,7 +524,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         }
     }
 
-    pub fn step_into_brillig(&mut self) -> StepResult<'a, B> {
+    pub fn step_into_brillig(&mut self) -> StepResult<'a, F, B> {
         let Opcode::BrilligCall { id, inputs, outputs, predicate } =
             &self.opcodes[self.instruction_pointer]
         else {
@@ -541,7 +537,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
             Err(err) => return StepResult::Status(self.handle_opcode_resolution(Err(err))),
         };
         if should_skip {
-            let resolution = BrilligSolver::<B>::zero_out_brillig_outputs(witness, outputs);
+            let resolution = BrilligSolver::<F, B>::zero_out_brillig_outputs(witness, outputs);
             return StepResult::Status(self.handle_opcode_resolution(resolution));
         }
 
@@ -559,7 +555,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         }
     }
 
-    pub fn finish_brillig_with_solver(&mut self, solver: BrilligSolver<'a, B>) -> ACVMStatus {
+    pub fn finish_brillig_with_solver(&mut self, solver: BrilligSolver<'a, F, B>) -> ACVMStatus<F> {
         if !matches!(self.opcodes[self.instruction_pointer], Opcode::BrilligCall { .. }) {
             unreachable!("Not executing a Brillig/BrilligCall opcode");
         }
@@ -567,7 +563,9 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         self.solve_opcode()
     }
 
-    pub fn solve_call_opcode(&mut self) -> Result<Option<AcirCallWaitInfo>, OpcodeResolutionError> {
+    pub fn solve_call_opcode(
+        &mut self,
+    ) -> Result<Option<AcirCallWaitInfo<F>>, OpcodeResolutionError<F>> {
         let Opcode::Call { id, inputs, outputs, predicate } =
             &self.opcodes[self.instruction_pointer]
         else {
@@ -584,7 +582,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         if is_predicate_false(&self.witness_map, predicate)? {
             // Zero out the outputs if we have a false predicate
             for output in outputs {
-                insert_value(output, FieldElement::zero(), &mut self.witness_map)?;
+                insert_value(output, F::zero(), &mut self.witness_map)?;
             }
             return Ok(None);
         }
@@ -621,10 +619,10 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
 // Returns the concrete value for a particular witness
 // If the witness has no assignment, then
 // an error is returned
-pub fn witness_to_value(
-    initial_witness: &WitnessMap,
+pub fn witness_to_value<F>(
+    initial_witness: &WitnessMap<F>,
     witness: Witness,
-) -> Result<&FieldElement, OpcodeResolutionError> {
+) -> Result<&F, OpcodeResolutionError<F>> {
     match initial_witness.get(&witness) {
         Some(value) => Ok(value),
         None => Err(OpcodeNotSolvable::MissingAssignment(witness.0).into()),
@@ -633,10 +631,10 @@ pub fn witness_to_value(
 
 // TODO: There is an issue open to decide on whether we need to get values from Expressions
 // TODO versus just getting values from Witness
-pub fn get_value(
-    expr: &Expression,
-    initial_witness: &WitnessMap,
-) -> Result<FieldElement, OpcodeResolutionError> {
+pub fn get_value<F: AcirField>(
+    expr: &Expression<F>,
+    initial_witness: &WitnessMap<F>,
+) -> Result<F, OpcodeResolutionError<F>> {
     let expr = ExpressionSolver::evaluate(expr, initial_witness);
     match expr.to_const() {
         Some(value) => Ok(value),
@@ -650,11 +648,11 @@ pub fn get_value(
 ///
 /// Returns an error if there was already a value in the map
 /// which does not match the value that one is about to insert
-pub fn insert_value(
+pub fn insert_value<F: AcirField>(
     witness: &Witness,
-    value_to_insert: FieldElement,
-    initial_witness: &mut WitnessMap,
-) -> Result<(), OpcodeResolutionError> {
+    value_to_insert: F,
+    initial_witness: &mut WitnessMap<F>,
+) -> Result<(), OpcodeResolutionError<F>> {
     let optional_old_value = initial_witness.insert(*witness, value_to_insert);
 
     let old_value = match optional_old_value {
@@ -675,7 +673,7 @@ pub fn insert_value(
 // Returns one witness belonging to an expression, in no relevant order
 // Returns None if the expression is const
 // The function is used during partial witness generation to report unsolved witness
-fn any_witness_from_expression(expr: &Expression) -> Option<Witness> {
+fn any_witness_from_expression<F>(expr: &Expression<F>) -> Option<Witness> {
     if expr.linear_combinations.is_empty() {
         if expr.mul_terms.is_empty() {
             None
@@ -690,10 +688,10 @@ fn any_witness_from_expression(expr: &Expression) -> Option<Witness> {
 /// Returns `true` if the predicate is zero
 /// A predicate is used to indicate whether we should skip a certain operation.
 /// If we have a zero predicate it means the operation should be skipped.
-pub(crate) fn is_predicate_false(
-    witness: &WitnessMap,
-    predicate: &Option<Expression>,
-) -> Result<bool, OpcodeResolutionError> {
+pub(crate) fn is_predicate_false<F: AcirField>(
+    witness: &WitnessMap<F>,
+    predicate: &Option<Expression<F>>,
+) -> Result<bool, OpcodeResolutionError<F>> {
     match predicate {
         Some(pred) => get_value(pred, witness).map(|pred_value| pred_value.is_zero()),
         // If the predicate is `None`, then we treat it as an unconditional `true`
@@ -702,9 +700,9 @@ pub(crate) fn is_predicate_false(
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct AcirCallWaitInfo {
+pub struct AcirCallWaitInfo<F> {
     /// Index in the list of ACIR function's that should be called
     pub id: u32,
     /// Initial witness for the given circuit to be called
-    pub initial_witness: WitnessMap,
+    pub initial_witness: WitnessMap<F>,
 }
diff --git a/acvm-repo/acvm/tests/solver.rs b/acvm-repo/acvm/tests/solver.rs
index 495389d7b3e..e55dbb73ae1 100644
--- a/acvm-repo/acvm/tests/solver.rs
+++ b/acvm-repo/acvm/tests/solver.rs
@@ -1,6 +1,7 @@
 use std::collections::BTreeMap;
 
 use acir::{
+    acir_field::GenericFieldElement,
     brillig::{BinaryFieldOp, HeapArray, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
     circuit::{
         brillig::{BrilligBytecode, BrilligInputs, BrilligOutputs},
@@ -8,7 +9,7 @@ use acir::{
         Opcode, OpcodeLocation,
     },
     native_types::{Expression, Witness, WitnessMap},
-    FieldElement,
+    AcirField, FieldElement,
 };
 
 use acvm::pwg::{ACVMStatus, ErrorLocation, ForeignCallWaitInfo, OpcodeResolutionError, ACVM};
@@ -17,6 +18,38 @@ use brillig_vm::brillig::HeapValueType;
 
 // Reenable these test cases once we move the brillig implementation of inversion down into the acvm stdlib.
 
+#[test]
+fn bls12_381_circuit() {
+    type Bls12FieldElement = GenericFieldElement<ark_bls12_381::Fr>;
+
+    let addition = Opcode::AssertZero(Expression {
+        mul_terms: Vec::new(),
+        linear_combinations: vec![
+            (Bls12FieldElement::one(), Witness(1)),
+            (Bls12FieldElement::one(), Witness(2)),
+            (-Bls12FieldElement::one(), Witness(3)),
+        ],
+        q_c: Bls12FieldElement::zero(),
+    });
+    let opcodes = [addition];
+
+    let witness_assignments = BTreeMap::from([
+        (Witness(1), Bls12FieldElement::from(2u128)),
+        (Witness(2), Bls12FieldElement::from(3u128)),
+    ])
+    .into();
+
+    let mut acvm = ACVM::new(&StubbedBlackBoxSolver, &opcodes, witness_assignments, &[], &[]);
+    // use the partial witness generation solver with our acir program
+    let solver_status = acvm.solve();
+    assert_eq!(solver_status, ACVMStatus::Solved, "should be fully solved");
+
+    // ACVM should be able to be finalized in `Solved` state.
+    let witness_stack = acvm.finalize();
+
+    assert_eq!(witness_stack.get(&Witness(3)).unwrap(), &Bls12FieldElement::from(5u128));
+}
+
 #[test]
 fn inversion_brillig_oracle_equivalence() {
     // Opcodes below describe the following:
@@ -123,7 +156,7 @@ fn inversion_brillig_oracle_equivalence() {
     );
     assert_eq!(acvm.instruction_pointer(), 0, "brillig should have been removed");
 
-    let foreign_call_wait_info: &ForeignCallWaitInfo =
+    let foreign_call_wait_info: &ForeignCallWaitInfo<FieldElement> =
         acvm.get_pending_foreign_call().expect("should have a brillig foreign call request");
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
@@ -268,7 +301,7 @@ fn double_inversion_brillig_oracle() {
     );
     assert_eq!(acvm.instruction_pointer(), 0, "should stall on brillig");
 
-    let foreign_call_wait_info: &ForeignCallWaitInfo =
+    let foreign_call_wait_info: &ForeignCallWaitInfo<FieldElement> =
         acvm.get_pending_foreign_call().expect("should have a brillig foreign call request");
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
@@ -405,7 +438,7 @@ fn oracle_dependent_execution() {
     );
     assert_eq!(acvm.instruction_pointer(), 1, "should stall on brillig");
 
-    let foreign_call_wait_info: &ForeignCallWaitInfo =
+    let foreign_call_wait_info: &ForeignCallWaitInfo<FieldElement> =
         acvm.get_pending_foreign_call().expect("should have a brillig foreign call request");
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
@@ -421,7 +454,7 @@ fn oracle_dependent_execution() {
     );
     assert_eq!(acvm.instruction_pointer(), 1, "should stall on brillig");
 
-    let foreign_call_wait_info: &ForeignCallWaitInfo =
+    let foreign_call_wait_info: &ForeignCallWaitInfo<FieldElement> =
         acvm.get_pending_foreign_call().expect("should have a brillig foreign call request");
     assert_eq!(foreign_call_wait_info.inputs.len(), 1, "Should be waiting for a single input");
 
diff --git a/acvm-repo/acvm_js/src/black_box_solvers.rs b/acvm-repo/acvm_js/src/black_box_solvers.rs
index 188e5334ed5..4f2676f8d2f 100644
--- a/acvm-repo/acvm_js/src/black_box_solvers.rs
+++ b/acvm-repo/acvm_js/src/black_box_solvers.rs
@@ -2,7 +2,7 @@ use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
 use crate::js_witness_map::{field_element_to_js_string, js_value_to_field_element};
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 
 /// Performs a bitwise AND operation between `lhs` and `rhs`
 #[wasm_bindgen]
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 9f2b07b31fc..85cc3f455a0 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -2,12 +2,12 @@ use std::{future::Future, pin::Pin};
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::ResolvedAssertionPayload;
-use acvm::BlackBoxFunctionSolver;
 use acvm::{
     acir::circuit::{Circuit, Program},
     acir::native_types::{WitnessMap, WitnessStack},
     pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM},
 };
+use acvm::{BlackBoxFunctionSolver, FieldElement};
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 
 use js_sys::Error;
@@ -72,7 +72,7 @@ pub async fn execute_circuit_with_return_witness(
 ) -> Result<JsSolvedAndReturnWitness, Error> {
     console_error_panic_hook::set_once();
 
-    let program: Program = Program::deserialize_program(&program)
+    let program: Program<FieldElement> = Program::deserialize_program(&program)
     .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None, None))?;
 
     let mut witness_stack = execute_program_with_native_program_and_return(
@@ -148,8 +148,8 @@ async fn execute_program_with_native_type_return(
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_executor: &ForeignCallHandler,
-) -> Result<WitnessStack, Error> {
-    let program: Program = Program::deserialize_program(&program)
+) -> Result<WitnessStack<FieldElement>, Error> {
+    let program: Program<FieldElement> = Program::deserialize_program(&program)
     .map_err(|_| JsExecutionError::new(
         "Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), 
         None,
@@ -160,10 +160,10 @@ async fn execute_program_with_native_type_return(
 }
 
 async fn execute_program_with_native_program_and_return(
-    program: &Program,
+    program: &Program<FieldElement>,
     initial_witness: JsWitnessMap,
     foreign_call_executor: &ForeignCallHandler,
-) -> Result<WitnessStack, Error> {
+) -> Result<WitnessStack<FieldElement>, Error> {
     let blackbox_solver = Bn254BlackBoxSolver;
     let executor = ProgramExecutor::new(
         &program.functions,
@@ -176,20 +176,20 @@ async fn execute_program_with_native_program_and_return(
     Ok(witness_stack)
 }
 
-struct ProgramExecutor<'a, B: BlackBoxFunctionSolver> {
-    functions: &'a [Circuit],
+struct ProgramExecutor<'a, B: BlackBoxFunctionSolver<FieldElement>> {
+    functions: &'a [Circuit<FieldElement>],
 
-    unconstrained_functions: &'a [BrilligBytecode],
+    unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 
     blackbox_solver: &'a B,
 
     foreign_call_handler: &'a ForeignCallHandler,
 }
 
-impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
+impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ProgramExecutor<'a, B> {
     fn new(
-        functions: &'a [Circuit],
-        unconstrained_functions: &'a [BrilligBytecode],
+        functions: &'a [Circuit<FieldElement>],
+        unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
         blackbox_solver: &'a B,
         foreign_call_handler: &'a ForeignCallHandler,
     ) -> Self {
@@ -201,7 +201,10 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
         }
     }
 
-    async fn execute(&self, initial_witness: WitnessMap) -> Result<WitnessStack, Error> {
+    async fn execute(
+        &self,
+        initial_witness: WitnessMap<FieldElement>,
+    ) -> Result<WitnessStack<FieldElement>, Error> {
         let main = &self.functions[0];
 
         let mut witness_stack = WitnessStack::default();
@@ -212,10 +215,10 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
 
     fn execute_circuit(
         &'a self,
-        circuit: &'a Circuit,
-        initial_witness: WitnessMap,
-        witness_stack: &'a mut WitnessStack,
-    ) -> Pin<Box<dyn Future<Output = Result<WitnessMap, Error>> + 'a>> {
+        circuit: &'a Circuit<FieldElement>,
+        initial_witness: WitnessMap<FieldElement>,
+        witness_stack: &'a mut WitnessStack<FieldElement>,
+    ) -> Pin<Box<dyn Future<Output = Result<WitnessMap<FieldElement>, Error>> + 'a>> {
         Box::pin(async {
             let mut acvm = ACVM::new(
                 self.blackbox_solver,
diff --git a/acvm-repo/acvm_js/src/foreign_call/inputs.rs b/acvm-repo/acvm_js/src/foreign_call/inputs.rs
index ebd29fb7d58..dd12bc639ec 100644
--- a/acvm-repo/acvm_js/src/foreign_call/inputs.rs
+++ b/acvm-repo/acvm_js/src/foreign_call/inputs.rs
@@ -1,9 +1,9 @@
-use acvm::brillig_vm::brillig::ForeignCallParam;
+use acvm::{brillig_vm::brillig::ForeignCallParam, FieldElement};
 
 use crate::js_witness_map::field_element_to_js_string;
 
 pub(super) fn encode_foreign_call_inputs(
-    foreign_call_inputs: &[ForeignCallParam],
+    foreign_call_inputs: &[ForeignCallParam<FieldElement>],
 ) -> js_sys::Array {
     let inputs = js_sys::Array::default();
     for input in foreign_call_inputs {
diff --git a/acvm-repo/acvm_js/src/foreign_call/mod.rs b/acvm-repo/acvm_js/src/foreign_call/mod.rs
index 9ccaf733f84..4884c1173dc 100644
--- a/acvm-repo/acvm_js/src/foreign_call/mod.rs
+++ b/acvm-repo/acvm_js/src/foreign_call/mod.rs
@@ -1,4 +1,4 @@
-use acvm::{brillig_vm::brillig::ForeignCallResult, pwg::ForeignCallWaitInfo};
+use acvm::{brillig_vm::brillig::ForeignCallResult, pwg::ForeignCallWaitInfo, FieldElement};
 
 use js_sys::{Error, JsString};
 use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
@@ -29,8 +29,8 @@ extern "C" {
 
 pub(super) async fn resolve_brillig(
     foreign_call_callback: &ForeignCallHandler,
-    foreign_call_wait_info: &ForeignCallWaitInfo,
-) -> Result<ForeignCallResult, Error> {
+    foreign_call_wait_info: &ForeignCallWaitInfo<FieldElement>,
+) -> Result<ForeignCallResult<FieldElement>, Error> {
     // Prepare to call
     let name = JsString::from(foreign_call_wait_info.function.clone());
     let inputs = inputs::encode_foreign_call_inputs(&foreign_call_wait_info.inputs);
diff --git a/acvm-repo/acvm_js/src/foreign_call/outputs.rs b/acvm-repo/acvm_js/src/foreign_call/outputs.rs
index 78fa520aa15..2b3f44fe98d 100644
--- a/acvm-repo/acvm_js/src/foreign_call/outputs.rs
+++ b/acvm-repo/acvm_js/src/foreign_call/outputs.rs
@@ -1,9 +1,12 @@
-use acvm::brillig_vm::brillig::{ForeignCallParam, ForeignCallResult};
+use acvm::{
+    brillig_vm::brillig::{ForeignCallParam, ForeignCallResult},
+    FieldElement,
+};
 use wasm_bindgen::JsValue;
 
 use crate::js_witness_map::js_value_to_field_element;
 
-fn decode_foreign_call_output(output: JsValue) -> Result<ForeignCallParam, String> {
+fn decode_foreign_call_output(output: JsValue) -> Result<ForeignCallParam<FieldElement>, String> {
     if output.is_string() {
         let value = js_value_to_field_element(output)?;
         Ok(ForeignCallParam::Single(value))
@@ -22,8 +25,9 @@ fn decode_foreign_call_output(output: JsValue) -> Result<ForeignCallParam, Strin
 
 pub(super) fn decode_foreign_call_result(
     js_array: js_sys::Array,
-) -> Result<ForeignCallResult, String> {
-    let mut values: Vec<ForeignCallParam> = Vec::with_capacity(js_array.length() as usize);
+) -> Result<ForeignCallResult<FieldElement>, String> {
+    let mut values: Vec<ForeignCallParam<FieldElement>> =
+        Vec::with_capacity(js_array.length() as usize);
     for elem in js_array.iter() {
         values.push(decode_foreign_call_output(elem)?);
     }
diff --git a/acvm-repo/acvm_js/src/js_execution_error.rs b/acvm-repo/acvm_js/src/js_execution_error.rs
index b34ea5ddb60..e51a912a63a 100644
--- a/acvm-repo/acvm_js/src/js_execution_error.rs
+++ b/acvm-repo/acvm_js/src/js_execution_error.rs
@@ -1,4 +1,7 @@
-use acvm::acir::circuit::{OpcodeLocation, RawAssertionPayload};
+use acvm::{
+    acir::circuit::{OpcodeLocation, RawAssertionPayload},
+    FieldElement,
+};
 use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{Array, Error, JsString, Reflect};
 use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
@@ -34,7 +37,7 @@ impl JsExecutionError {
     pub fn new(
         message: String,
         call_stack: Option<Vec<OpcodeLocation>>,
-        assertion_payload: Option<RawAssertionPayload>,
+        assertion_payload: Option<RawAssertionPayload<FieldElement>>,
     ) -> Self {
         let mut error = JsExecutionError::constructor(JsString::from(message));
         let js_call_stack = match call_stack {
diff --git a/acvm-repo/acvm_js/src/js_witness_map.rs b/acvm-repo/acvm_js/src/js_witness_map.rs
index c4482c4a234..8316059e21a 100644
--- a/acvm-repo/acvm_js/src/js_witness_map.rs
+++ b/acvm-repo/acvm_js/src/js_witness_map.rs
@@ -1,5 +1,6 @@
 use acvm::{
     acir::native_types::{Witness, WitnessMap},
+    acir::AcirField,
     FieldElement,
 };
 use js_sys::{JsString, Map, Object};
@@ -51,8 +52,8 @@ impl Default for JsSolvedAndReturnWitness {
     }
 }
 
-impl From<WitnessMap> for JsWitnessMap {
-    fn from(witness_map: WitnessMap) -> Self {
+impl From<WitnessMap<FieldElement>> for JsWitnessMap {
+    fn from(witness_map: WitnessMap<FieldElement>) -> Self {
         let js_map = JsWitnessMap::new();
         for (key, value) in witness_map {
             js_map.set(
@@ -64,7 +65,7 @@ impl From<WitnessMap> for JsWitnessMap {
     }
 }
 
-impl From<JsWitnessMap> for WitnessMap {
+impl From<JsWitnessMap> for WitnessMap<FieldElement> {
     fn from(js_map: JsWitnessMap) -> Self {
         let mut witness_map = WitnessMap::new();
         js_map.for_each(&mut |value, key| {
@@ -76,8 +77,8 @@ impl From<JsWitnessMap> for WitnessMap {
     }
 }
 
-impl From<(WitnessMap, WitnessMap)> for JsSolvedAndReturnWitness {
-    fn from(witness_maps: (WitnessMap, WitnessMap)) -> Self {
+impl From<(WitnessMap<FieldElement>, WitnessMap<FieldElement>)> for JsSolvedAndReturnWitness {
+    fn from(witness_maps: (WitnessMap<FieldElement>, WitnessMap<FieldElement>)) -> Self {
         let js_solved_witness = JsWitnessMap::from(witness_maps.0);
         let js_return_witness = JsWitnessMap::from(witness_maps.1);
 
@@ -113,7 +114,7 @@ mod test {
 
     use acvm::{
         acir::native_types::{Witness, WitnessMap},
-        FieldElement,
+        AcirField, FieldElement,
     };
     use wasm_bindgen::JsValue;
 
diff --git a/acvm-repo/acvm_js/src/js_witness_stack.rs b/acvm-repo/acvm_js/src/js_witness_stack.rs
index 59f2dbc051e..d59ee508086 100644
--- a/acvm-repo/acvm_js/src/js_witness_stack.rs
+++ b/acvm-repo/acvm_js/src/js_witness_stack.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessStack;
+use acvm::{acir::native_types::WitnessStack, FieldElement};
 use js_sys::{Array, Map, Object};
 use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
 
@@ -38,8 +38,8 @@ impl Default for JsWitnessStack {
     }
 }
 
-impl From<WitnessStack> for JsWitnessStack {
-    fn from(mut witness_stack: WitnessStack) -> Self {
+impl From<WitnessStack<FieldElement>> for JsWitnessStack {
+    fn from(mut witness_stack: WitnessStack<FieldElement>) -> Self {
         let js_witness_stack = JsWitnessStack::new();
         while let Some(stack_item) = witness_stack.pop() {
             let js_map = JsWitnessMap::from(stack_item.witness);
@@ -57,7 +57,7 @@ impl From<WitnessStack> for JsWitnessStack {
     }
 }
 
-impl From<JsWitnessStack> for WitnessStack {
+impl From<JsWitnessStack> for WitnessStack<FieldElement> {
     fn from(js_witness_stack: JsWitnessStack) -> Self {
         let mut witness_stack = WitnessStack::default();
         js_witness_stack.for_each(&mut |stack_item, _, _| {
diff --git a/acvm-repo/acvm_js/src/public_witness.rs b/acvm-repo/acvm_js/src/public_witness.rs
index 4ba054732d4..245d5b4dd0a 100644
--- a/acvm-repo/acvm_js/src/public_witness.rs
+++ b/acvm-repo/acvm_js/src/public_witness.rs
@@ -1,6 +1,9 @@
-use acvm::acir::{
-    circuit::Program,
-    native_types::{Witness, WitnessMap},
+use acvm::{
+    acir::{
+        circuit::Program,
+        native_types::{Witness, WitnessMap},
+    },
+    FieldElement,
 };
 use js_sys::JsString;
 use wasm_bindgen::prelude::wasm_bindgen;
@@ -8,9 +11,9 @@ use wasm_bindgen::prelude::wasm_bindgen;
 use crate::JsWitnessMap;
 
 pub(crate) fn extract_indices(
-    witness_map: &WitnessMap,
+    witness_map: &WitnessMap<FieldElement>,
     indices: Vec<Witness>,
-) -> Result<WitnessMap, String> {
+) -> Result<WitnessMap<FieldElement>, String> {
     let mut extracted_witness_map = WitnessMap::new();
     for witness in indices {
         let witness_value = witness_map.get(&witness).ok_or(format!(
@@ -36,7 +39,7 @@ pub fn get_return_witness(
     witness_map: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let program: Program =
+    let program: Program<FieldElement> =
         Program::deserialize_program(&program).expect("Failed to deserialize circuit");
     let circuit = match program.functions.len() {
         0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
@@ -63,7 +66,7 @@ pub fn get_public_parameters_witness(
     solved_witness: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let program: Program =
+    let program: Program<FieldElement> =
         Program::deserialize_program(&program).expect("Failed to deserialize circuit");
     let circuit = match program.functions.len() {
         0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
@@ -90,7 +93,7 @@ pub fn get_public_witness(
     solved_witness: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let program: Program =
+    let program: Program<FieldElement> =
         Program::deserialize_program(&program).expect("Failed to deserialize circuit");
     let circuit = match program.functions.len() {
         0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 6c1cd190254..00c87bbca74 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -40,6 +40,5 @@ p256 = { version = "0.11.0", features = [
 libaes = "0.7.0"
 
 [features]
-default = ["bn254"]
 bn254 = ["acir/bn254"]
 bls12_381 = ["acir/bls12_381"]
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index 73f64d3d9d1..0ee3a252840 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -1,4 +1,4 @@
-use acir::{BlackBoxFunc, FieldElement};
+use acir::BlackBoxFunc;
 
 use crate::BlackBoxResolutionError;
 
@@ -6,44 +6,44 @@ use crate::BlackBoxResolutionError;
 /// doesn't have a canonical Rust implementation.
 ///
 /// Returns an [`BlackBoxResolutionError`] if the backend does not support the given [`acir::BlackBoxFunc`].
-pub trait BlackBoxFunctionSolver {
+pub trait BlackBoxFunctionSolver<F> {
     fn schnorr_verify(
         &self,
-        public_key_x: &FieldElement,
-        public_key_y: &FieldElement,
+        public_key_x: &F,
+        public_key_y: &F,
         signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError>;
     fn pedersen_commitment(
         &self,
-        inputs: &[FieldElement],
+        inputs: &[F],
         domain_separator: u32,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
+    ) -> Result<(F, F), BlackBoxResolutionError>;
     fn pedersen_hash(
         &self,
-        inputs: &[FieldElement],
+        inputs: &[F],
         domain_separator: u32,
-    ) -> Result<FieldElement, BlackBoxResolutionError>;
+    ) -> Result<F, BlackBoxResolutionError>;
     fn multi_scalar_mul(
         &self,
-        points: &[FieldElement],
-        scalars_lo: &[FieldElement],
-        scalars_hi: &[FieldElement],
-    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError>;
+        points: &[F],
+        scalars_lo: &[F],
+        scalars_hi: &[F],
+    ) -> Result<(F, F, F), BlackBoxResolutionError>;
     fn ec_add(
         &self,
-        input1_x: &FieldElement,
-        input1_y: &FieldElement,
-        input1_infinite: &FieldElement,
-        input2_x: &FieldElement,
-        input2_y: &FieldElement,
-        input2_infinite: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError>;
+        input1_x: &F,
+        input1_y: &F,
+        input1_infinite: &F,
+        input2_x: &F,
+        input2_y: &F,
+        input2_infinite: &F,
+    ) -> Result<(F, F, F), BlackBoxResolutionError>;
     fn poseidon2_permutation(
         &self,
-        _inputs: &[FieldElement],
+        _inputs: &[F],
         _len: u32,
-    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError>;
+    ) -> Result<Vec<F>, BlackBoxResolutionError>;
 }
 
 pub struct StubbedBlackBoxSolver;
@@ -57,11 +57,11 @@ impl StubbedBlackBoxSolver {
     }
 }
 
-impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
+impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
     fn schnorr_verify(
         &self,
-        _public_key_x: &FieldElement,
-        _public_key_y: &FieldElement,
+        _public_key_x: &F,
+        _public_key_y: &F,
         _signature: &[u8; 64],
         _message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError> {
@@ -69,42 +69,42 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
     }
     fn pedersen_commitment(
         &self,
-        _inputs: &[FieldElement],
+        _inputs: &[F],
         _domain_separator: u32,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+    ) -> Result<(F, F), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::PedersenCommitment))
     }
     fn pedersen_hash(
         &self,
-        _inputs: &[FieldElement],
+        _inputs: &[F],
         _domain_separator: u32,
-    ) -> Result<FieldElement, BlackBoxResolutionError> {
+    ) -> Result<F, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::PedersenHash))
     }
     fn multi_scalar_mul(
         &self,
-        _points: &[FieldElement],
-        _scalars_lo: &[FieldElement],
-        _scalars_hi: &[FieldElement],
-    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+        _points: &[F],
+        _scalars_lo: &[F],
+        _scalars_hi: &[F],
+    ) -> Result<(F, F, F), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::MultiScalarMul))
     }
     fn ec_add(
         &self,
-        _input1_x: &FieldElement,
-        _input1_y: &FieldElement,
-        _input1_infinite: &FieldElement,
-        _input2_x: &FieldElement,
-        _input2_y: &FieldElement,
-        _input2_infinite: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
+        _input1_x: &F,
+        _input1_y: &F,
+        _input1_infinite: &F,
+        _input2_x: &F,
+        _input2_y: &F,
+        _input2_infinite: &F,
+    ) -> Result<(F, F, F), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::EmbeddedCurveAdd))
     }
     fn poseidon2_permutation(
         &self,
-        _inputs: &[FieldElement],
+        _inputs: &[F],
         _len: u32,
-    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
+    ) -> Result<Vec<F>, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::Poseidon2Permutation))
     }
 }
diff --git a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
index b86414423cf..cbcb75a3291 100644
--- a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
+++ b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
@@ -1,7 +1,7 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::{hint::black_box, time::Duration};
 
-use acir::FieldElement;
+use acir::{AcirField, FieldElement};
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use bn254_blackbox_solver::{poseidon2_permutation, Bn254BlackBoxSolver};
 
diff --git a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
index 901eb9d5a0f..148accd8b23 100644
--- a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
@@ -3,7 +3,8 @@ use ark_ec::AffineRepr;
 use ark_ff::MontConfig;
 use num_bigint::BigUint;
 
-use acir::{BlackBoxFunc, FieldElement};
+use acir::BlackBoxFunc;
+use acir::{AcirField, FieldElement};
 
 use crate::BlackBoxResolutionError;
 
@@ -117,10 +118,10 @@ fn create_point(
 
 #[cfg(test)]
 mod tests {
-    use ark_ff::BigInteger;
-
     use super::*;
 
+    use ark_ff::BigInteger;
+
     fn get_generator() -> [FieldElement; 3] {
         let generator = grumpkin::SWAffine::generator();
         let generator_x = FieldElement::from_repr(*generator.x().unwrap());
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index ae5a1c3db6d..e3cea1153be 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -18,7 +18,7 @@ pub use poseidon2::poseidon2_permutation;
 #[derive(Default)]
 pub struct Bn254BlackBoxSolver;
 
-impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
+impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
     fn schnorr_verify(
         &self,
         public_key_x: &FieldElement,
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
index 6769150508a..5ff2c269d8c 100644
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
@@ -27,7 +27,7 @@ pub(crate) fn commit_native_with_index(
 #[cfg(test)]
 mod test {
 
-    use acir::FieldElement;
+    use acir::{AcirField, FieldElement};
     use ark_ec::short_weierstrass::Affine;
     use ark_std::{One, Zero};
     use grumpkin::Fq;
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
index 28bf354edc9..5c637207491 100644
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
@@ -31,7 +31,7 @@ pub(crate) mod test {
 
     use super::*;
 
-    use acir::FieldElement;
+    use acir::{AcirField, FieldElement};
     use ark_std::One;
     use grumpkin::Fq;
 
diff --git a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
index 65058e15099..95c620aab0d 100644
--- a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
@@ -1,4 +1,4 @@
-use acir::FieldElement;
+use acir::{AcirField, FieldElement};
 use acvm_blackbox_solver::BlackBoxResolutionError;
 use lazy_static::lazy_static;
 
@@ -543,7 +543,7 @@ impl<'a> Poseidon2<'a> {
 
 #[cfg(test)]
 mod test {
-    use acir::FieldElement;
+    use acir::{AcirField, FieldElement};
 
     use super::{field_from_hex, poseidon2_permutation};
 
diff --git a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
index cb213726973..62e515a0792 100644
--- a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
@@ -65,7 +65,7 @@ fn schnorr_generate_challenge(
 
 #[cfg(test)]
 mod schnorr_tests {
-    use acir::FieldElement;
+    use acir::{AcirField, FieldElement};
 
     use super::verify_signature;
 
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index f60bde6f074..245767dcecd 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -17,6 +17,5 @@ acir_field.workspace = true
 serde.workspace = true
 
 [features]
-default = ["bn254"]
 bn254 = ["acir_field/bn254"]
 bls12_381 = ["acir_field/bls12_381"]
diff --git a/acvm-repo/brillig/src/foreign_call.rs b/acvm-repo/brillig/src/foreign_call.rs
index e547b99f0eb..a439d5c3202 100644
--- a/acvm-repo/brillig/src/foreign_call.rs
+++ b/acvm-repo/brillig/src/foreign_call.rs
@@ -1,34 +1,34 @@
-use acir_field::FieldElement;
+use acir_field::AcirField;
 use serde::{Deserialize, Serialize};
 
 /// Single output of a [foreign call][crate::Opcode::ForeignCall].
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
-pub enum ForeignCallParam {
-    Single(FieldElement),
-    Array(Vec<FieldElement>),
+pub enum ForeignCallParam<F> {
+    Single(F),
+    Array(Vec<F>),
 }
 
-impl From<FieldElement> for ForeignCallParam {
-    fn from(value: FieldElement) -> Self {
+impl<F> From<F> for ForeignCallParam<F> {
+    fn from(value: F) -> Self {
         ForeignCallParam::Single(value)
     }
 }
 
-impl From<Vec<FieldElement>> for ForeignCallParam {
-    fn from(values: Vec<FieldElement>) -> Self {
+impl<F> From<Vec<F>> for ForeignCallParam<F> {
+    fn from(values: Vec<F>) -> Self {
         ForeignCallParam::Array(values)
     }
 }
 
-impl ForeignCallParam {
-    pub fn fields(&self) -> Vec<FieldElement> {
+impl<F: AcirField> ForeignCallParam<F> {
+    pub fn fields(&self) -> Vec<F> {
         match self {
             ForeignCallParam::Single(value) => vec![*value],
-            ForeignCallParam::Array(values) => values.clone(),
+            ForeignCallParam::Array(values) => values.to_vec(),
         }
     }
 
-    pub fn unwrap_field(&self) -> FieldElement {
+    pub fn unwrap_field(&self) -> F {
         match self {
             ForeignCallParam::Single(value) => *value,
             ForeignCallParam::Array(_) => panic!("Expected single value, found array"),
@@ -38,25 +38,25 @@ impl ForeignCallParam {
 
 /// Represents the full output of a [foreign call][crate::Opcode::ForeignCall].
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, Default)]
-pub struct ForeignCallResult {
+pub struct ForeignCallResult<F> {
     /// Resolved output values of the foreign call.
-    pub values: Vec<ForeignCallParam>,
+    pub values: Vec<ForeignCallParam<F>>,
 }
 
-impl From<FieldElement> for ForeignCallResult {
-    fn from(value: FieldElement) -> Self {
+impl<F> From<F> for ForeignCallResult<F> {
+    fn from(value: F) -> Self {
         ForeignCallResult { values: vec![value.into()] }
     }
 }
 
-impl From<Vec<FieldElement>> for ForeignCallResult {
-    fn from(values: Vec<FieldElement>) -> Self {
+impl<F> From<Vec<F>> for ForeignCallResult<F> {
+    fn from(values: Vec<F>) -> Self {
         ForeignCallResult { values: vec![values.into()] }
     }
 }
 
-impl From<Vec<ForeignCallParam>> for ForeignCallResult {
-    fn from(values: Vec<ForeignCallParam>) -> Self {
+impl<F> From<Vec<ForeignCallParam<F>>> for ForeignCallResult<F> {
+    fn from(values: Vec<ForeignCallParam<F>>) -> Self {
         ForeignCallResult { values }
     }
 }
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index a060aa83d41..78c6ba8097c 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -1,5 +1,5 @@
 use crate::black_box::BlackBoxOp;
-use acir_field::FieldElement;
+use acir_field::{AcirField, FieldElement};
 use serde::{Deserialize, Serialize};
 
 pub type Label = usize;
@@ -89,7 +89,7 @@ pub enum ValueOrArray {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum BrilligOpcode {
+pub enum BrilligOpcode<F> {
     /// Takes the fields in addresses `lhs` and `rhs`
     /// Performs the specified binary operation
     /// and stores the value in the `result` address.  
@@ -142,7 +142,7 @@ pub enum BrilligOpcode {
     Const {
         destination: MemoryAddress,
         bit_size: u32,
-        value: FieldElement,
+        value: F,
     },
     Return,
     /// Used to get data from an outside source.
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 7dd11912449..4735514c9a7 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -20,6 +20,5 @@ num-traits.workspace = true
 thiserror.workspace = true
 
 [features]
-default = ["bn254"]
 bn254 = ["acir/bn254"]
 bls12_381 = ["acir/bls12_381"]
diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
index c17c019d11c..c88e06e2b94 100644
--- a/acvm-repo/brillig_vm/src/arithmetic.rs
+++ b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -1,5 +1,5 @@
 use acir::brillig::{BinaryFieldOp, BinaryIntOp};
-use acir::FieldElement;
+use acir::AcirField;
 use num_bigint::BigUint;
 use num_traits::ToPrimitive;
 use num_traits::{One, Zero};
@@ -19,36 +19,36 @@ pub(crate) enum BrilligArithmeticError {
 }
 
 /// Evaluate a binary operation on two FieldElement memory values.
-pub(crate) fn evaluate_binary_field_op(
+pub(crate) fn evaluate_binary_field_op<F: AcirField>(
     op: &BinaryFieldOp,
-    lhs: MemoryValue,
-    rhs: MemoryValue,
-) -> Result<MemoryValue, BrilligArithmeticError> {
+    lhs: MemoryValue<F>,
+    rhs: MemoryValue<F>,
+) -> Result<MemoryValue<F>, BrilligArithmeticError> {
     let MemoryValue::Field(a) = lhs else {
         return Err(BrilligArithmeticError::MismatchedLhsBitSize {
             lhs_bit_size: lhs.bit_size(),
-            op_bit_size: FieldElement::max_num_bits(),
+            op_bit_size: F::max_num_bits(),
         });
     };
     let MemoryValue::Field(b) = rhs else {
         return Err(BrilligArithmeticError::MismatchedLhsBitSize {
             lhs_bit_size: rhs.bit_size(),
-            op_bit_size: FieldElement::max_num_bits(),
+            op_bit_size: F::max_num_bits(),
         });
     };
 
     Ok(match op {
         // Perform addition, subtraction, multiplication, and division based on the BinaryOp variant.
-        BinaryFieldOp::Add => (a + b).into(),
-        BinaryFieldOp::Sub => (a - b).into(),
-        BinaryFieldOp::Mul => (a * b).into(),
-        BinaryFieldOp::Div => (a / b).into(),
+        BinaryFieldOp::Add => MemoryValue::new_field(a + b),
+        BinaryFieldOp::Sub => MemoryValue::new_field(a - b),
+        BinaryFieldOp::Mul => MemoryValue::new_field(a * b),
+        BinaryFieldOp::Div => MemoryValue::new_field(a / b),
         BinaryFieldOp::IntegerDiv => {
             let a_big = BigUint::from_bytes_be(&a.to_be_bytes());
             let b_big = BigUint::from_bytes_be(&b.to_be_bytes());
 
             let result = a_big / b_big;
-            FieldElement::from_be_bytes_reduce(&result.to_bytes_be()).into()
+            MemoryValue::new_field(F::from_be_bytes_reduce(&result.to_bytes_be()))
         }
         BinaryFieldOp::Equals => (a == b).into(),
         BinaryFieldOp::LessThan => (a < b).into(),
@@ -57,12 +57,12 @@ pub(crate) fn evaluate_binary_field_op(
 }
 
 /// Evaluate a binary operation on two unsigned big integers with a given bit size.
-pub(crate) fn evaluate_binary_int_op(
+pub(crate) fn evaluate_binary_int_op<F: AcirField>(
     op: &BinaryIntOp,
-    lhs: MemoryValue,
-    rhs: MemoryValue,
+    lhs: MemoryValue<F>,
+    rhs: MemoryValue<F>,
     bit_size: u32,
-) -> Result<MemoryValue, BrilligArithmeticError> {
+) -> Result<MemoryValue<F>, BrilligArithmeticError> {
     let lhs = lhs.expect_integer_with_bit_size(bit_size).map_err(|err| match err {
         MemoryTypeError::MismatchedBitSize { value_bit_size, expected_bit_size } => {
             BrilligArithmeticError::MismatchedLhsBitSize {
@@ -82,7 +82,7 @@ pub(crate) fn evaluate_binary_int_op(
         }
     })?;
 
-    if bit_size == FieldElement::max_num_bits() {
+    if bit_size == F::max_num_bits() {
         return Err(BrilligArithmeticError::IntegerOperationOnField { op: *op });
     }
 
@@ -155,6 +155,7 @@ pub(crate) fn evaluate_binary_int_op(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use acir::{AcirField, FieldElement};
 
     struct TestParams {
         a: u128,
@@ -163,7 +164,7 @@ mod tests {
     }
 
     fn evaluate_u128(op: &BinaryIntOp, a: u128, b: u128, bit_size: u32) -> u128 {
-        let result_value = evaluate_binary_int_op(
+        let result_value: MemoryValue<FieldElement> = evaluate_binary_int_op(
             op,
             MemoryValue::new_integer(a.into(), bit_size),
             MemoryValue::new_integer(b.into(), bit_size),
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index ebaa6976283..2053f4e7c86 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -1,5 +1,5 @@
 use acir::brillig::{BlackBoxOp, HeapArray, HeapVector};
-use acir::{BlackBoxFunc, FieldElement};
+use acir::{AcirField, BlackBoxFunc};
 use acvm_blackbox_solver::BigIntSolver;
 use acvm_blackbox_solver::{
     aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256,
@@ -10,17 +10,23 @@ use num_bigint::BigUint;
 use crate::memory::MemoryValue;
 use crate::Memory;
 
-fn read_heap_vector<'a>(memory: &'a Memory, vector: &HeapVector) -> &'a [MemoryValue] {
+fn read_heap_vector<'a, F: AcirField>(
+    memory: &'a Memory<F>,
+    vector: &HeapVector,
+) -> &'a [MemoryValue<F>] {
     let size = memory.read(vector.size);
     memory.read_slice(memory.read_ref(vector.pointer), size.to_usize())
 }
 
-fn read_heap_array<'a>(memory: &'a Memory, array: &HeapArray) -> &'a [MemoryValue] {
+fn read_heap_array<'a, F: AcirField>(
+    memory: &'a Memory<F>,
+    array: &HeapArray,
+) -> &'a [MemoryValue<F>] {
     memory.read_slice(memory.read_ref(array.pointer), array.size)
 }
 
 /// Extracts the last byte of every value
-fn to_u8_vec(inputs: &[MemoryValue]) -> Vec<u8> {
+fn to_u8_vec<F: AcirField>(inputs: &[MemoryValue<F>]) -> Vec<u8> {
     let mut result = Vec::with_capacity(inputs.len());
     for input in inputs {
         result.push(input.try_into().unwrap());
@@ -28,14 +34,14 @@ fn to_u8_vec(inputs: &[MemoryValue]) -> Vec<u8> {
     result
 }
 
-fn to_value_vec(input: &[u8]) -> Vec<MemoryValue> {
+fn to_value_vec<F: AcirField>(input: &[u8]) -> Vec<MemoryValue<F>> {
     input.iter().map(|&x| x.into()).collect()
 }
 
-pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
+pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>>(
     op: &BlackBoxOp,
     solver: &Solver,
-    memory: &mut Memory,
+    memory: &mut Memory<F>,
     bigint_solver: &mut BigIntSolver,
 ) -> Result<(), BlackBoxResolutionError> {
     match op {
@@ -91,7 +97,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
 
             let new_state = keccakf1600(state)?;
 
-            let new_state: Vec<MemoryValue> = new_state.into_iter().map(|x| x.into()).collect();
+            let new_state: Vec<MemoryValue<F>> = new_state.into_iter().map(|x| x.into()).collect();
             memory.write_slice(memory.read_ref(output.pointer), &new_state);
             Ok(())
         }
@@ -146,8 +152,8 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::SchnorrVerify { public_key_x, public_key_y, message, signature, result } => {
-            let public_key_x = memory.read(*public_key_x).try_into().unwrap();
-            let public_key_y = memory.read(*public_key_y).try_into().unwrap();
+            let public_key_x = *memory.read(*public_key_x).extract_field().unwrap();
+            let public_key_y = *memory.read(*public_key_y).extract_field().unwrap();
             let message: Vec<u8> = to_u8_vec(read_heap_vector(memory, message));
             let signature: [u8; 64] =
                 to_u8_vec(read_heap_vector(memory, signature)).try_into().unwrap();
@@ -157,20 +163,22 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::MultiScalarMul { points, scalars, outputs: result } => {
-            let points: Vec<FieldElement> = read_heap_vector(memory, points)
+            let points: Vec<F> = read_heap_vector(memory, points)
                 .iter()
                 .enumerate()
                 .map(|(i, x)| {
                     if i % 3 == 2 {
                         let is_infinite: bool = x.try_into().unwrap();
-                        FieldElement::from(is_infinite as u128)
+                        F::from(is_infinite as u128)
                     } else {
-                        x.try_into().unwrap()
+                        *x.extract_field().unwrap()
                     }
                 })
                 .collect();
-            let scalars: Vec<FieldElement> =
-                read_heap_vector(memory, scalars).iter().map(|x| x.try_into().unwrap()).collect();
+            let scalars: Vec<F> = read_heap_vector(memory, scalars)
+                .iter()
+                .map(|x| *x.extract_field().unwrap())
+                .collect();
             let mut scalars_lo = Vec::with_capacity(scalars.len() / 2);
             let mut scalars_hi = Vec::with_capacity(scalars.len() / 2);
             for (i, scalar) in scalars.iter().enumerate() {
@@ -183,7 +191,11 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             let (x, y, is_infinite) = solver.multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
             memory.write_slice(
                 memory.read_ref(result.pointer),
-                &[x.into(), y.into(), is_infinite.into()],
+                &[
+                    MemoryValue::new_field(x),
+                    MemoryValue::new_field(y),
+                    MemoryValue::new_field(is_infinite),
+                ],
             );
             Ok(())
         }
@@ -196,11 +208,11 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             input1_infinite,
             input2_infinite,
         } => {
-            let input1_x = memory.read(*input1_x).try_into().unwrap();
-            let input1_y = memory.read(*input1_y).try_into().unwrap();
+            let input1_x = *memory.read(*input1_x).extract_field().unwrap();
+            let input1_y = *memory.read(*input1_y).extract_field().unwrap();
             let input1_infinite: bool = memory.read(*input1_infinite).try_into().unwrap();
-            let input2_x = memory.read(*input2_x).try_into().unwrap();
-            let input2_y = memory.read(*input2_y).try_into().unwrap();
+            let input2_x = *memory.read(*input2_x).extract_field().unwrap();
+            let input2_y = *memory.read(*input2_y).extract_field().unwrap();
             let input2_infinite: bool = memory.read(*input2_infinite).try_into().unwrap();
             let (x, y, infinite) = solver.ec_add(
                 &input1_x,
@@ -212,13 +224,19 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             )?;
             memory.write_slice(
                 memory.read_ref(result.pointer),
-                &[x.into(), y.into(), infinite.into()],
+                &[
+                    MemoryValue::new_field(x),
+                    MemoryValue::new_field(y),
+                    MemoryValue::new_field(infinite),
+                ],
             );
             Ok(())
         }
         BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
-            let inputs: Vec<FieldElement> =
-                read_heap_vector(memory, inputs).iter().map(|x| x.try_into().unwrap()).collect();
+            let inputs: Vec<F> = read_heap_vector(memory, inputs)
+                .iter()
+                .map(|x| *x.extract_field().unwrap())
+                .collect();
             let domain_separator: u32 =
                 memory.read(*domain_separator).try_into().map_err(|_| {
                     BlackBoxResolutionError::Failed(
@@ -227,12 +245,17 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
                     )
                 })?;
             let (x, y) = solver.pedersen_commitment(&inputs, domain_separator)?;
-            memory.write_slice(memory.read_ref(output.pointer), &[x.into(), y.into()]);
+            memory.write_slice(
+                memory.read_ref(output.pointer),
+                &[MemoryValue::new_field(x), MemoryValue::new_field(y)],
+            );
             Ok(())
         }
         BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
-            let inputs: Vec<FieldElement> =
-                read_heap_vector(memory, inputs).iter().map(|x| x.try_into().unwrap()).collect();
+            let inputs: Vec<F> = read_heap_vector(memory, inputs)
+                .iter()
+                .map(|x| *x.extract_field().unwrap())
+                .collect();
             let domain_separator: u32 =
                 memory.read(*domain_separator).try_into().map_err(|_| {
                     BlackBoxResolutionError::Failed(
@@ -241,7 +264,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
                     )
                 })?;
             let hash = solver.pedersen_hash(&inputs, domain_separator)?;
-            memory.write(*output, hash.into());
+            memory.write(*output, MemoryValue::new_field(hash));
             Ok(())
         }
         BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
@@ -297,12 +320,12 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
         }
         BlackBoxOp::Poseidon2Permutation { message, output, len } => {
             let input = read_heap_vector(memory, message);
-            let input: Vec<FieldElement> = input.iter().map(|x| x.try_into().unwrap()).collect();
+            let input: Vec<F> = input.iter().map(|x| *x.extract_field().unwrap()).collect();
             let len = memory.read(*len).try_into().unwrap();
             let result = solver.poseidon2_permutation(&input, len)?;
             let mut values = Vec::new();
             for i in result {
-                values.push(i.into());
+                values.push(MemoryValue::new_field(i));
             }
             memory.write_slice(memory.read_ref(output.pointer), &values);
             Ok(())
@@ -338,17 +361,16 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::ToRadix { input, radix, output } => {
-            let input: FieldElement =
-                memory.read(*input).try_into().expect("ToRadix input not a field");
+            let input: F = *memory.read(*input).extract_field().expect("ToRadix input not a field");
 
             let mut input = BigUint::from_bytes_be(&input.to_be_bytes());
             let radix = BigUint::from(*radix);
 
-            let mut limbs: Vec<MemoryValue> = Vec::with_capacity(output.size);
+            let mut limbs: Vec<MemoryValue<F>> = Vec::with_capacity(output.size);
 
             for _ in 0..output.size {
                 let limb = &input % &radix;
-                limbs.push(FieldElement::from_be_bytes_reduce(&limb.to_bytes_be()).into());
+                limbs.push(MemoryValue::new_field(F::from_be_bytes_reduce(&limb.to_bytes_be())));
                 input /= &radix;
             }
 
@@ -388,7 +410,10 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
 
 #[cfg(test)]
 mod test {
-    use acir::brillig::{BlackBoxOp, MemoryAddress};
+    use acir::{
+        brillig::{BlackBoxOp, MemoryAddress},
+        FieldElement,
+    };
     use acvm_blackbox_solver::{BigIntSolver, StubbedBlackBoxSolver};
 
     use crate::{
@@ -401,7 +426,7 @@ mod test {
         let message: Vec<u8> = b"hello world".to_vec();
         let message_length = message.len();
 
-        let mut memory = Memory::default();
+        let mut memory: Memory<FieldElement> = Memory::default();
         let message_pointer = 3;
         let result_pointer = message_pointer + message_length;
         memory.write(MemoryAddress(0), message_pointer.into());
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 7901c313596..aaf55056589 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -15,7 +15,7 @@ use acir::brillig::{
     BinaryFieldOp, BinaryIntOp, ForeignCallParam, ForeignCallResult, HeapArray, HeapValueType,
     HeapVector, MemoryAddress, Opcode, ValueOrArray,
 };
-use acir::FieldElement;
+use acir::AcirField;
 use acvm_blackbox_solver::{BigIntSolver, BlackBoxFunctionSolver};
 use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
 use black_box::evaluate_black_box;
@@ -39,7 +39,7 @@ pub enum FailureReason {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub enum VMStatus {
+pub enum VMStatus<F> {
     Finished {
         return_data_offset: usize,
         return_data_size: usize,
@@ -60,15 +60,15 @@ pub enum VMStatus {
         function: String,
         /// Input values
         /// Each input is a list of values as an input can be either a single value or a memory pointer
-        inputs: Vec<ForeignCallParam>,
+        inputs: Vec<ForeignCallParam<F>>,
     },
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 /// VM encapsulates the state of the Brillig VM during execution.
-pub struct VM<'a, B: BlackBoxFunctionSolver> {
+pub struct VM<'a, F, B: BlackBoxFunctionSolver<F>> {
     /// Calldata to the brillig function
-    calldata: Vec<FieldElement>,
+    calldata: Vec<F>,
     /// Instruction pointer
     program_counter: usize,
     /// A counter maintained throughout a Brillig process that determines
@@ -76,13 +76,13 @@ pub struct VM<'a, B: BlackBoxFunctionSolver> {
     foreign_call_counter: usize,
     /// Represents the outputs of all foreign calls during a Brillig process
     /// List is appended onto by the caller upon reaching a [VMStatus::ForeignCallWait]
-    foreign_call_results: Vec<ForeignCallResult>,
+    foreign_call_results: Vec<ForeignCallResult<F>>,
     /// Executable opcodes
-    bytecode: &'a [Opcode],
+    bytecode: &'a [Opcode<F>],
     /// Status of the VM
-    status: VMStatus,
+    status: VMStatus<F>,
     /// Memory of the VM
-    memory: Memory,
+    memory: Memory<F>,
     /// Call stack
     call_stack: Vec<usize>,
     /// The solver for blackbox functions
@@ -91,12 +91,12 @@ pub struct VM<'a, B: BlackBoxFunctionSolver> {
     bigint_solver: BigIntSolver,
 }
 
-impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
+impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
     /// Constructs a new VM instance
     pub fn new(
-        calldata: Vec<FieldElement>,
-        bytecode: &'a [Opcode],
-        foreign_call_results: Vec<ForeignCallResult>,
+        calldata: Vec<F>,
+        bytecode: &'a [Opcode<F>],
+        foreign_call_results: Vec<ForeignCallResult<F>>,
         black_box_solver: &'a B,
     ) -> Self {
         Self {
@@ -115,17 +115,17 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
 
     /// Updates the current status of the VM.
     /// Returns the given status.
-    fn status(&mut self, status: VMStatus) -> VMStatus {
+    fn status(&mut self, status: VMStatus<F>) -> VMStatus<F> {
         self.status = status.clone();
         status
     }
 
-    pub fn get_status(&self) -> VMStatus {
+    pub fn get_status(&self) -> VMStatus<F> {
         self.status.clone()
     }
 
     /// Sets the current status of the VM to Finished (completed execution).
-    fn finish(&mut self, return_data_offset: usize, return_data_size: usize) -> VMStatus {
+    fn finish(&mut self, return_data_offset: usize, return_data_size: usize) -> VMStatus<F> {
         self.status(VMStatus::Finished { return_data_offset, return_data_size })
     }
 
@@ -134,12 +134,12 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     fn wait_for_foreign_call(
         &mut self,
         function: String,
-        inputs: Vec<ForeignCallParam>,
-    ) -> VMStatus {
+        inputs: Vec<ForeignCallParam<F>>,
+    ) -> VMStatus<F> {
         self.status(VMStatus::ForeignCallWait { function, inputs })
     }
 
-    pub fn resolve_foreign_call(&mut self, foreign_call_result: ForeignCallResult) {
+    pub fn resolve_foreign_call(&mut self, foreign_call_result: ForeignCallResult<F>) {
         if self.foreign_call_counter < self.foreign_call_results.len() {
             panic!("No unresolved foreign calls");
         }
@@ -156,7 +156,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     /// Sets the current status of the VM to `fail`.
     /// Indicating that the VM encountered a `Trap` Opcode
     /// or an invalid state.
-    fn trap(&mut self, revert_data_offset: usize, revert_data_size: usize) -> VMStatus {
+    fn trap(&mut self, revert_data_offset: usize, revert_data_size: usize) -> VMStatus<F> {
         self.status(VMStatus::Failure {
             call_stack: self.get_error_stack(),
             reason: FailureReason::Trap { revert_data_offset, revert_data_size },
@@ -164,7 +164,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         self.status.clone()
     }
 
-    fn fail(&mut self, message: String) -> VMStatus {
+    fn fail(&mut self, message: String) -> VMStatus<F> {
         self.status(VMStatus::Failure {
             call_stack: self.get_error_stack(),
             reason: FailureReason::RuntimeError { message },
@@ -173,7 +173,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     }
 
     /// Loop over the bytecode and update the program counter
-    pub fn process_opcodes(&mut self) -> VMStatus {
+    pub fn process_opcodes(&mut self) -> VMStatus<F> {
         while !matches!(
             self.process_opcode(),
             VMStatus::Finished { .. } | VMStatus::Failure { .. } | VMStatus::ForeignCallWait { .. }
@@ -181,11 +181,11 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         self.status.clone()
     }
 
-    pub fn get_memory(&self) -> &[MemoryValue] {
+    pub fn get_memory(&self) -> &[MemoryValue<F>] {
         self.memory.values()
     }
 
-    pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue) {
+    pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue<F>) {
         self.memory.write(MemoryAddress(ptr), value);
     }
 
@@ -196,7 +196,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     }
 
     /// Process a single opcode and modify the program counter.
-    pub fn process_opcode(&mut self) -> VMStatus {
+    pub fn process_opcode(&mut self) -> VMStatus<F> {
         let opcode = &self.bytecode[self.program_counter];
         match opcode {
             Opcode::BinaryFieldOp { op, lhs, rhs, destination: result } => {
@@ -360,14 +360,14 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     }
 
     /// Increments the program counter by 1.
-    fn increment_program_counter(&mut self) -> VMStatus {
+    fn increment_program_counter(&mut self) -> VMStatus<F> {
         self.set_program_counter(self.program_counter + 1)
     }
 
     /// Increments the program counter by `value`.
     /// If the program counter no longer points to an opcode
     /// in the bytecode, then the VMStatus reports halted.
-    fn set_program_counter(&mut self, value: usize) -> VMStatus {
+    fn set_program_counter(&mut self, value: usize) -> VMStatus<F> {
         assert!(self.program_counter < self.bytecode.len());
         self.program_counter = value;
         if self.program_counter >= self.bytecode.len() {
@@ -380,10 +380,10 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         &self,
         input: ValueOrArray,
         value_type: &HeapValueType,
-    ) -> ForeignCallParam {
+    ) -> ForeignCallParam<F> {
         match (input, value_type) {
             (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(_)) => {
-                self.memory.read(value_index).to_field().into()
+                ForeignCallParam::Single(self.memory.read(value_index).to_field())
             }
             (
                 ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
@@ -421,7 +421,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         start: MemoryAddress,
         size: usize,
         value_types: &[HeapValueType],
-    ) -> Vec<MemoryValue> {
+    ) -> Vec<MemoryValue<F>> {
         if HeapValueType::all_simple(value_types) {
             self.memory.read_slice(start, size).to_vec()
         } else {
@@ -618,7 +618,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     }
 
     /// Casts a value to a different bit size.
-    fn cast(&self, bit_size: u32, source_value: MemoryValue) -> MemoryValue {
+    fn cast(&self, bit_size: u32, source_value: MemoryValue<F>) -> MemoryValue<F> {
         let lhs_big = source_value.to_integer();
         let mask = BigUint::from(2_u32).pow(bit_size) - 1_u32;
         MemoryValue::new_from_integer(lhs_big & mask, bit_size)
@@ -627,6 +627,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
 
 #[cfg(test)]
 mod tests {
+    use acir::{AcirField, FieldElement};
     use acvm_blackbox_solver::StubbedBlackBoxSolver;
 
     use super::*;
@@ -664,7 +665,7 @@ mod tests {
 
     #[test]
     fn jmpif_opcode() {
-        let mut calldata = vec![];
+        let mut calldata: Vec<FieldElement> = vec![];
         let mut opcodes = vec![];
 
         let lhs = {
@@ -709,7 +710,7 @@ mod tests {
 
     #[test]
     fn jmpifnot_opcode() {
-        let calldata = vec![1u128.into(), 2u128.into()];
+        let calldata: Vec<FieldElement> = vec![1u128.into(), 2u128.into()];
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -779,7 +780,7 @@ mod tests {
 
     #[test]
     fn cast_opcode() {
-        let calldata = vec![((2_u128.pow(32)) - 1).into()];
+        let calldata: Vec<FieldElement> = vec![((2_u128.pow(32)) - 1).into()];
 
         let opcodes = &[
             Opcode::CalldataCopy {
@@ -813,7 +814,7 @@ mod tests {
 
     #[test]
     fn mov_opcode() {
-        let calldata = vec![(1u128).into(), (2u128).into(), (3u128).into()];
+        let calldata: Vec<FieldElement> = vec![(1u128).into(), (2u128).into(), (3u128).into()];
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -844,7 +845,8 @@ mod tests {
 
     #[test]
     fn cmov_opcode() {
-        let calldata = vec![(0u128).into(), (1u128).into(), (2u128).into(), (3u128).into()];
+        let calldata: Vec<FieldElement> =
+            vec![(0u128).into(), (1u128).into(), (2u128).into(), (3u128).into()];
 
         let calldata_copy = Opcode::CalldataCopy {
             destination_address: MemoryAddress::from(0),
@@ -910,7 +912,7 @@ mod tests {
     #[test]
     fn cmp_binary_ops() {
         let bit_size = 32;
-        let calldata =
+        let calldata: Vec<FieldElement> =
             vec![(2u128).into(), (2u128).into(), (0u128).into(), (5u128).into(), (6u128).into()];
         let calldata_size = calldata.len();
 
@@ -1010,14 +1012,14 @@ mod tests {
         ///         memory[i] = i as Value;
         ///         i += 1;
         ///     }
-        fn brillig_write_memory(item_count: usize) -> Vec<MemoryValue> {
+        fn brillig_write_memory(item_count: usize) -> Vec<MemoryValue<FieldElement>> {
             let bit_size = 64;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_tmp = MemoryAddress::from(2);
             let r_pointer = MemoryAddress::from(3);
 
-            let start = [
+            let start: [Opcode<FieldElement>; 3] = [
                 // i = 0
                 Opcode::Const { destination: r_i, value: 0u128.into(), bit_size },
                 // len = memory.len() (approximation)
@@ -1091,7 +1093,7 @@ mod tests {
             let r_tmp = MemoryAddress::from(3);
             let r_pointer = MemoryAddress::from(4);
 
-            let start = [
+            let start: [Opcode<FieldElement>; 5] = [
                 // sum = 0
                 Opcode::Const {
                     destination: r_sum,
@@ -1179,18 +1181,18 @@ mod tests {
         ///         recursive_write(memory, i + 1, len);
         ///     }
         /// Note we represent a 100% in-stack optimized form in brillig
-        fn brillig_recursive_write_memory(size: usize) -> Vec<MemoryValue> {
+        fn brillig_recursive_write_memory<F: AcirField>(size: usize) -> Vec<MemoryValue<F>> {
             let bit_size = 64;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_tmp = MemoryAddress::from(2);
             let r_pointer = MemoryAddress::from(3);
 
-            let start = [
+            let start: [Opcode<F>; 5] = [
                 // i = 0
                 Opcode::Const { destination: r_i, value: 0u128.into(), bit_size },
                 // len = size
-                Opcode::Const { destination: r_len, value: size.into(), bit_size },
+                Opcode::Const { destination: r_len, value: (size as u128).into(), bit_size },
                 // pointer = free_memory_ptr
                 Opcode::Const { destination: r_pointer, value: 4u128.into(), bit_size },
                 // call recursive_fn
@@ -1245,28 +1247,28 @@ mod tests {
             vm.get_memory()[4..].to_vec()
         }
 
-        let memory = brillig_recursive_write_memory(5);
+        let memory = brillig_recursive_write_memory::<FieldElement>(5);
         let expected =
             vec![(0u64).into(), (1u64).into(), (2u64).into(), (3u64).into(), (4u64).into()];
         assert_eq!(memory, expected);
 
-        let memory = brillig_recursive_write_memory(1024);
+        let memory = brillig_recursive_write_memory::<FieldElement>(1024);
         let expected: Vec<_> = (0..1024).map(|i: u64| i.into()).collect();
         assert_eq!(memory, expected);
     }
 
     /// Helper to execute brillig code
-    fn brillig_execute_and_get_vm(
-        calldata: Vec<FieldElement>,
-        opcodes: &[Opcode],
-    ) -> VM<'_, StubbedBlackBoxSolver> {
+    fn brillig_execute_and_get_vm<F: AcirField>(
+        calldata: Vec<F>,
+        opcodes: &[Opcode<F>],
+    ) -> VM<'_, F, StubbedBlackBoxSolver> {
         let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
         brillig_execute(&mut vm);
         assert_eq!(vm.call_stack, vec![]);
         vm
     }
 
-    fn brillig_execute(vm: &mut VM<StubbedBlackBoxSolver>) {
+    fn brillig_execute<F: AcirField>(vm: &mut VM<F, StubbedBlackBoxSolver>) {
         loop {
             let status = vm.process_opcode();
             if matches!(status, VMStatus::Finished { .. } | VMStatus::ForeignCallWait { .. }) {
@@ -1330,7 +1332,8 @@ mod tests {
         let r_output = MemoryAddress::from(1);
 
         // Define a simple 2x2 matrix in memory
-        let initial_matrix = vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
+        let initial_matrix: Vec<FieldElement> =
+            vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
 
         // Transpose of the matrix (but arbitrary for this test, the 'correct value')
         let expected_result: Vec<FieldElement> =
@@ -1505,7 +1508,8 @@ mod tests {
         let r_output = MemoryAddress::from(1);
 
         // Define a simple 2x2 matrix in memory
-        let initial_matrix = vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
+        let initial_matrix: Vec<FieldElement> =
+            vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
 
         // Transpose of the matrix (but arbitrary for this test, the 'correct value')
         let expected_result: Vec<FieldElement> =
@@ -1592,9 +1596,11 @@ mod tests {
         let r_output = MemoryAddress::from(2);
 
         // Define a simple 2x2 matrix in memory
-        let matrix_a = vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
+        let matrix_a: Vec<FieldElement> =
+            vec![(1u128).into(), (2u128).into(), (3u128).into(), (4u128).into()];
 
-        let matrix_b = vec![(10u128).into(), (11u128).into(), (12u128).into(), (13u128).into()];
+        let matrix_b: Vec<FieldElement> =
+            vec![(10u128).into(), (11u128).into(), (12u128).into(), (13u128).into()];
 
         // Transpose of the matrix (but arbitrary for this test, the 'correct value')
         let expected_result: Vec<FieldElement> =
@@ -1678,17 +1684,19 @@ mod tests {
     fn foreign_call_opcode_nested_arrays_and_slices_input() {
         // [(1, <2,3>, [4]), (5, <6,7,8>, [9])]
 
-        let v2: Vec<MemoryValue> = vec![
-            MemoryValue::from(FieldElement::from(2u128)),
-            MemoryValue::from(FieldElement::from(3u128)),
+        let v2: Vec<MemoryValue<FieldElement>> = vec![
+            MemoryValue::new_field(FieldElement::from(2u128)),
+            MemoryValue::new_field(FieldElement::from(3u128)),
         ];
-        let a4: Vec<MemoryValue> = vec![FieldElement::from(4u128).into()];
-        let v6: Vec<MemoryValue> = vec![
-            MemoryValue::from(FieldElement::from(6u128)),
-            MemoryValue::from(FieldElement::from(7u128)),
-            MemoryValue::from(FieldElement::from(8u128)),
+        let a4: Vec<MemoryValue<FieldElement>> =
+            vec![MemoryValue::new_field(FieldElement::from(4u128))];
+        let v6: Vec<MemoryValue<FieldElement>> = vec![
+            MemoryValue::new_field(FieldElement::from(6u128)),
+            MemoryValue::new_field(FieldElement::from(7u128)),
+            MemoryValue::new_field(FieldElement::from(8u128)),
         ];
-        let a9: Vec<MemoryValue> = vec![FieldElement::from(9u128).into()];
+        let a9: Vec<MemoryValue<FieldElement>> =
+            vec![MemoryValue::new_field(FieldElement::from(9u128))];
 
         // construct memory by declaring all inner arrays/vectors first
         let v2_ptr: usize = 0usize;
@@ -1710,11 +1718,11 @@ mod tests {
         // finally we add the contents of the outer array
         let outer_ptr = memory.len();
         let outer_array = vec![
-            MemoryValue::from(FieldElement::from(1u128)),
+            MemoryValue::new_field(FieldElement::from(1u128)),
             MemoryValue::from(v2.len()),
             MemoryValue::from(v2_start),
             MemoryValue::from(a4_start),
-            MemoryValue::from(FieldElement::from(5u128)),
+            MemoryValue::new_field(FieldElement::from(5u128)),
             MemoryValue::from(v6.len()),
             MemoryValue::from(v6_start),
             MemoryValue::from(a9_start),
@@ -1801,7 +1809,7 @@ mod tests {
 
         // Check result
         let result_value = vm.memory.read(r_output);
-        assert_eq!(result_value, MemoryValue::from(FieldElement::from(45u128)));
+        assert_eq!(result_value, MemoryValue::new_field(FieldElement::from(45u128)));
 
         // Ensure the foreign call counter has been incremented
         assert_eq!(vm.foreign_call_counter, 1);
diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index feeb3706bde..4092cd06ae0 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -1,12 +1,12 @@
-use acir::{brillig::MemoryAddress, FieldElement};
+use acir::{brillig::MemoryAddress, AcirField};
 use num_bigint::BigUint;
 use num_traits::{One, Zero};
 
 pub const MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub enum MemoryValue {
-    Field(FieldElement),
+pub enum MemoryValue<F> {
+    Field(F),
     Integer(BigUint, u32),
 }
 
@@ -16,10 +16,10 @@ pub enum MemoryTypeError {
     MismatchedBitSize { value_bit_size: u32, expected_bit_size: u32 },
 }
 
-impl MemoryValue {
+impl<F: AcirField> MemoryValue<F> {
     /// Builds a memory value from a field element.
-    pub fn new_from_field(value: FieldElement, bit_size: u32) -> Self {
-        if bit_size == FieldElement::max_num_bits() {
+    pub fn new_from_field(value: F, bit_size: u32) -> Self {
+        if bit_size == F::max_num_bits() {
             MemoryValue::new_field(value)
         } else {
             MemoryValue::new_integer(BigUint::from_bytes_be(&value.to_be_bytes()), bit_size)
@@ -28,16 +28,16 @@ impl MemoryValue {
 
     /// Builds a memory value from an integer
     pub fn new_from_integer(value: BigUint, bit_size: u32) -> Self {
-        if bit_size == FieldElement::max_num_bits() {
-            MemoryValue::new_field(FieldElement::from_be_bytes_reduce(&value.to_bytes_be()))
+        if bit_size == F::max_num_bits() {
+            MemoryValue::new_field(F::from_be_bytes_reduce(&value.to_bytes_be()))
         } else {
             MemoryValue::new_integer(value, bit_size)
         }
     }
 
     /// Builds a memory value from a field element, checking that the value is within the bit size.
-    pub fn new_checked(value: FieldElement, bit_size: u32) -> Option<Self> {
-        if bit_size < FieldElement::max_num_bits() && value.num_bits() > bit_size {
+    pub fn new_checked(value: F, bit_size: u32) -> Option<Self> {
+        if bit_size < F::max_num_bits() && value.num_bits() > bit_size {
             return None;
         }
 
@@ -45,21 +45,21 @@ impl MemoryValue {
     }
 
     /// Builds a field-typed memory value.
-    pub fn new_field(value: FieldElement) -> Self {
+    pub fn new_field(value: F) -> Self {
         MemoryValue::Field(value)
     }
 
     /// Builds an integer-typed memory value.
     pub fn new_integer(value: BigUint, bit_size: u32) -> Self {
         assert!(
-            bit_size != FieldElement::max_num_bits(),
+            bit_size != F::max_num_bits(),
             "Tried to build a field memory value via new_integer"
         );
         MemoryValue::Integer(value, bit_size)
     }
 
     /// Extracts the field element from the memory value, if it is typed as field element.
-    pub fn extract_field(&self) -> Option<&FieldElement> {
+    pub fn extract_field(&self) -> Option<&F> {
         match self {
             MemoryValue::Field(value) => Some(value),
             _ => None,
@@ -75,12 +75,10 @@ impl MemoryValue {
     }
 
     /// Converts the memory value to a field element, independent of its type.
-    pub fn to_field(&self) -> FieldElement {
+    pub fn to_field(&self) -> F {
         match self {
             MemoryValue::Field(value) => *value,
-            MemoryValue::Integer(value, _) => {
-                FieldElement::from_be_bytes_reduce(&value.to_bytes_be())
-            }
+            MemoryValue::Integer(value, _) => F::from_be_bytes_reduce(&value.to_bytes_be()),
         }
     }
 
@@ -94,7 +92,7 @@ impl MemoryValue {
 
     pub fn bit_size(&self) -> u32 {
         match self {
-            MemoryValue::Field(_) => FieldElement::max_num_bits(),
+            MemoryValue::Field(_) => F::max_num_bits(),
             MemoryValue::Integer(_, bit_size) => *bit_size,
         }
     }
@@ -107,11 +105,11 @@ impl MemoryValue {
         self.extract_integer().unwrap().0.try_into().unwrap()
     }
 
-    pub fn expect_field(&self) -> Result<&FieldElement, MemoryTypeError> {
+    pub fn expect_field(&self) -> Result<&F, MemoryTypeError> {
         match self {
             MemoryValue::Integer(_, bit_size) => Err(MemoryTypeError::MismatchedBitSize {
                 value_bit_size: *bit_size,
-                expected_bit_size: FieldElement::max_num_bits(),
+                expected_bit_size: F::max_num_bits(),
             }),
             MemoryValue::Field(field) => Ok(field),
         }
@@ -132,14 +130,14 @@ impl MemoryValue {
                 Ok(value)
             }
             MemoryValue::Field(_) => Err(MemoryTypeError::MismatchedBitSize {
-                value_bit_size: FieldElement::max_num_bits(),
+                value_bit_size: F::max_num_bits(),
                 expected_bit_size,
             }),
         }
     }
 }
 
-impl std::fmt::Display for MemoryValue {
+impl<F: std::fmt::Display> std::fmt::Display for MemoryValue<F> {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
         match self {
             MemoryValue::Field(value) => write!(f, "{}: field", value),
@@ -155,85 +153,71 @@ impl std::fmt::Display for MemoryValue {
     }
 }
 
-impl Default for MemoryValue {
+impl<F: AcirField> Default for MemoryValue<F> {
     fn default() -> Self {
         MemoryValue::new_integer(BigUint::zero(), 0)
     }
 }
 
-impl From<FieldElement> for MemoryValue {
-    fn from(field: FieldElement) -> Self {
-        MemoryValue::new_field(field)
-    }
-}
-
-impl From<usize> for MemoryValue {
+impl<F: AcirField> From<usize> for MemoryValue<F> {
     fn from(value: usize) -> Self {
         MemoryValue::new_integer(value.into(), MEMORY_ADDRESSING_BIT_SIZE)
     }
 }
 
-impl From<u64> for MemoryValue {
+impl<F: AcirField> From<u64> for MemoryValue<F> {
     fn from(value: u64) -> Self {
         MemoryValue::new_integer(value.into(), 64)
     }
 }
 
-impl From<u32> for MemoryValue {
+impl<F: AcirField> From<u32> for MemoryValue<F> {
     fn from(value: u32) -> Self {
         MemoryValue::new_integer(value.into(), 32)
     }
 }
 
-impl From<u8> for MemoryValue {
+impl<F: AcirField> From<u8> for MemoryValue<F> {
     fn from(value: u8) -> Self {
         MemoryValue::new_integer(value.into(), 8)
     }
 }
 
-impl From<bool> for MemoryValue {
+impl<F: AcirField> From<bool> for MemoryValue<F> {
     fn from(value: bool) -> Self {
         let value = if value { BigUint::one() } else { BigUint::zero() };
         MemoryValue::new_integer(value, 1)
     }
 }
 
-impl TryFrom<MemoryValue> for FieldElement {
-    type Error = MemoryTypeError;
-
-    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_field().copied()
-    }
-}
-
-impl TryFrom<MemoryValue> for u64 {
+impl<F: AcirField> TryFrom<MemoryValue<F>> for u64 {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: MemoryValue<F>) -> Result<Self, Self::Error> {
         memory_value.expect_integer_with_bit_size(64).map(|value| value.try_into().unwrap())
     }
 }
 
-impl TryFrom<MemoryValue> for u32 {
+impl<F: AcirField> TryFrom<MemoryValue<F>> for u32 {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: MemoryValue<F>) -> Result<Self, Self::Error> {
         memory_value.expect_integer_with_bit_size(32).map(|value| value.try_into().unwrap())
     }
 }
 
-impl TryFrom<MemoryValue> for u8 {
+impl<F: AcirField> TryFrom<MemoryValue<F>> for u8 {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: MemoryValue<F>) -> Result<Self, Self::Error> {
         memory_value.expect_integer_with_bit_size(8).map(|value| value.try_into().unwrap())
     }
 }
 
-impl TryFrom<MemoryValue> for bool {
+impl<F: AcirField> TryFrom<MemoryValue<F>> for bool {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: MemoryValue<F>) -> Result<Self, Self::Error> {
         let as_integer = memory_value.expect_integer_with_bit_size(1)?;
 
         if as_integer.is_zero() {
@@ -246,48 +230,40 @@ impl TryFrom<MemoryValue> for bool {
     }
 }
 
-impl TryFrom<&MemoryValue> for FieldElement {
-    type Error = MemoryTypeError;
-
-    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
-        memory_value.expect_field().copied()
-    }
-}
-
-impl TryFrom<&MemoryValue> for u64 {
+impl<F: AcirField> TryFrom<&MemoryValue<F>> for u64 {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: &MemoryValue<F>) -> Result<Self, Self::Error> {
         memory_value.expect_integer_with_bit_size(64).map(|value| {
             value.try_into().expect("memory_value has been asserted to contain a 64 bit integer")
         })
     }
 }
 
-impl TryFrom<&MemoryValue> for u32 {
+impl<F: AcirField> TryFrom<&MemoryValue<F>> for u32 {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: &MemoryValue<F>) -> Result<Self, Self::Error> {
         memory_value.expect_integer_with_bit_size(32).map(|value| {
             value.try_into().expect("memory_value has been asserted to contain a 32 bit integer")
         })
     }
 }
 
-impl TryFrom<&MemoryValue> for u8 {
+impl<F: AcirField> TryFrom<&MemoryValue<F>> for u8 {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: &MemoryValue<F>) -> Result<Self, Self::Error> {
         memory_value.expect_integer_with_bit_size(8).map(|value| {
             value.try_into().expect("memory_value has been asserted to contain an 8 bit integer")
         })
     }
 }
 
-impl TryFrom<&MemoryValue> for bool {
+impl<F: AcirField> TryFrom<&MemoryValue<F>> for bool {
     type Error = MemoryTypeError;
 
-    fn try_from(memory_value: &MemoryValue) -> Result<Self, Self::Error> {
+    fn try_from(memory_value: &MemoryValue<F>) -> Result<Self, Self::Error> {
         let as_integer = memory_value.expect_integer_with_bit_size(1)?;
 
         if as_integer.is_zero() {
@@ -301,15 +277,15 @@ impl TryFrom<&MemoryValue> for bool {
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct Memory {
+pub struct Memory<F> {
     // Memory is a vector of values.
     // We grow the memory when values past the end are set, extending with 0s.
-    inner: Vec<MemoryValue>,
+    inner: Vec<MemoryValue<F>>,
 }
 
-impl Memory {
+impl<F: AcirField> Memory<F> {
     /// Gets the value at pointer
-    pub fn read(&self, ptr: MemoryAddress) -> MemoryValue {
+    pub fn read(&self, ptr: MemoryAddress) -> MemoryValue<F> {
         self.inner.get(ptr.to_usize()).cloned().unwrap_or_default()
     }
 
@@ -317,12 +293,12 @@ impl Memory {
         MemoryAddress(self.read(ptr).to_usize())
     }
 
-    pub fn read_slice(&self, addr: MemoryAddress, len: usize) -> &[MemoryValue] {
+    pub fn read_slice(&self, addr: MemoryAddress, len: usize) -> &[MemoryValue<F>] {
         &self.inner[addr.to_usize()..(addr.to_usize() + len)]
     }
 
     /// Sets the value at pointer `ptr` to `value`
-    pub fn write(&mut self, ptr: MemoryAddress, value: MemoryValue) {
+    pub fn write(&mut self, ptr: MemoryAddress, value: MemoryValue<F>) {
         self.resize_to_fit(ptr.to_usize() + 1);
         self.inner[ptr.to_usize()] = value;
     }
@@ -335,13 +311,13 @@ impl Memory {
     }
 
     /// Sets the values after pointer `ptr` to `values`
-    pub fn write_slice(&mut self, ptr: MemoryAddress, values: &[MemoryValue]) {
+    pub fn write_slice(&mut self, ptr: MemoryAddress, values: &[MemoryValue<F>]) {
         self.resize_to_fit(ptr.to_usize() + values.len());
         self.inner[ptr.to_usize()..(ptr.to_usize() + values.len())].clone_from_slice(values);
     }
 
     /// Returns the values of the memory
-    pub fn values(&self) -> &[MemoryValue] {
+    pub fn values(&self) -> &[MemoryValue<F>] {
         &self.inner
     }
 }
diff --git a/aztec_macros/Cargo.toml b/aztec_macros/Cargo.toml
index 355036d28a7..ed70066af22 100644
--- a/aztec_macros/Cargo.toml
+++ b/aztec_macros/Cargo.toml
@@ -10,6 +10,7 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+acvm.workspace = true
 noirc_frontend.workspace = true
 noirc_errors.workspace = true
 iter-extended.workspace = true
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 0a210934827..bd9fff3c3d3 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -1,3 +1,4 @@
+use acvm::acir::AcirField;
 use noirc_errors::Span;
 use noirc_frontend::ast::{
     BlockExpression, Expression, ExpressionKind, FunctionDefinition, Ident, Literal, NoirFunction,
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index 99b02acd606..34aed3b34a4 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -1,3 +1,4 @@
+use acvm::acir::AcirField;
 use iter_extended::vecmap;
 use noirc_errors::Location;
 use noirc_frontend::ast;
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index d6c3dc6205d..11fc1bb637a 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap};
 
-use acvm::acir::circuit::Program;
+use acvm::{acir::circuit::Program, FieldElement};
 use fm::FileId;
 use noirc_abi::{Abi, AbiType, AbiValue};
 use noirc_errors::debug_info::DebugInfo;
@@ -51,7 +51,7 @@ pub struct ContractFunction {
         serialize_with = "Program::serialize_program_base64",
         deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Program,
+    pub bytecode: Program<FieldElement>,
 
     pub debug: Vec<DebugInfo>,
 
diff --git a/compiler/noirc_driver/src/program.rs b/compiler/noirc_driver/src/program.rs
index ed7ddb29f59..8e02de0b8b3 100644
--- a/compiler/noirc_driver/src/program.rs
+++ b/compiler/noirc_driver/src/program.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Program;
+use acvm::{acir::circuit::Program, FieldElement};
 use fm::FileId;
 
 use noirc_errors::debug_info::DebugInfo;
@@ -22,7 +22,7 @@ pub struct CompiledProgram {
         serialize_with = "Program::serialize_program_base64",
         deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub program: Program,
+    pub program: Program<FieldElement>,
     pub abi: noirc_abi::Abi,
     pub debug: Vec<DebugInfo>,
     pub file_map: BTreeMap<FileId, DebugFile>,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 0dbab80dace..1fa4f41b29c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -18,7 +18,7 @@ use crate::ssa::ir::{
 };
 use acvm::acir::brillig::{MemoryAddress, ValueOrArray};
 use acvm::brillig_vm::brillig::HeapVector;
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use iter_extended::vecmap;
 use num_bigint::BigUint;
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
index 4b97a61491d..74319595795 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
@@ -1,5 +1,6 @@
 use acvm::{
     acir::brillig::{BinaryFieldOp, BinaryIntOp, MemoryAddress, Opcode as BrilligOpcode},
+    acir::AcirField,
     FieldElement,
 };
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 2bd57dc9486..9341db2ead7 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -27,7 +27,10 @@ pub(crate) use instructions::BrilligBinaryOp;
 
 use self::{artifact::BrilligArtifact, registers::BrilligRegistersContext};
 use crate::ssa::ir::dfg::CallStack;
-use acvm::acir::brillig::{MemoryAddress, Opcode as BrilligOpcode};
+use acvm::{
+    acir::brillig::{MemoryAddress, Opcode as BrilligOpcode},
+    FieldElement,
+};
 use debug_show::DebugShow;
 
 /// The Brillig VM does not apply a limit to the memory address space,
@@ -110,7 +113,7 @@ impl BrilligContext {
         result
     }
     /// Adds a brillig instruction to the brillig byte code
-    fn push_opcode(&mut self, opcode: BrilligOpcode) {
+    fn push_opcode(&mut self, opcode: BrilligOpcode<FieldElement>) {
         self.obj.push_opcode(opcode);
     }
 
@@ -143,7 +146,7 @@ pub(crate) mod tests {
 
     pub(crate) struct DummyBlackBoxSolver;
 
-    impl BlackBoxFunctionSolver for DummyBlackBoxSolver {
+    impl BlackBoxFunctionSolver<FieldElement> for DummyBlackBoxSolver {
         fn schnorr_verify(
             &self,
             _public_key_x: &FieldElement,
@@ -217,8 +220,8 @@ pub(crate) mod tests {
 
     pub(crate) fn create_and_run_vm(
         calldata: Vec<FieldElement>,
-        bytecode: &[BrilligOpcode],
-    ) -> (VM<'_, DummyBlackBoxSolver>, usize, usize) {
+        bytecode: &[BrilligOpcode<FieldElement>],
+    ) -> (VM<'_, FieldElement, DummyBlackBoxSolver>, usize, usize) {
         let mut vm = VM::new(calldata, bytecode, vec![], &DummyBlackBoxSolver);
 
         let status = vm.process_opcodes();
@@ -277,7 +280,7 @@ pub(crate) mod tests {
 
         context.stop_instruction();
 
-        let bytecode: Vec<BrilligOpcode> = context.artifact().finish().byte_code;
+        let bytecode: Vec<BrilligOpcode<FieldElement>> = context.artifact().finish().byte_code;
         let number_sequence: Vec<FieldElement> =
             (0_usize..12_usize).map(FieldElement::from).collect();
         let mut vm = VM::new(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index dee6c6076f4..99e922c1580 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -1,4 +1,4 @@
-use acvm::acir::brillig::Opcode as BrilligOpcode;
+use acvm::{acir::brillig::Opcode as BrilligOpcode, FieldElement};
 use std::collections::{BTreeMap, HashMap};
 
 use crate::ssa::ir::dfg::CallStack;
@@ -19,7 +19,7 @@ pub(crate) enum BrilligParameter {
 /// This is ready to run bytecode with attached metadata.
 #[derive(Debug, Default)]
 pub(crate) struct GeneratedBrillig {
-    pub(crate) byte_code: Vec<BrilligOpcode>,
+    pub(crate) byte_code: Vec<BrilligOpcode<FieldElement>>,
     pub(crate) locations: BTreeMap<OpcodeLocation, CallStack>,
     pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
 }
@@ -28,7 +28,7 @@ pub(crate) struct GeneratedBrillig {
 /// Artifacts resulting from the compilation of a function into brillig byte code.
 /// It includes the bytecode of the function and all the metadata that allows linking with other functions.
 pub(crate) struct BrilligArtifact {
-    pub(crate) byte_code: Vec<BrilligOpcode>,
+    pub(crate) byte_code: Vec<BrilligOpcode<FieldElement>>,
     /// A map of bytecode positions to assertion messages.
     /// Some error messages (compiler intrinsics) are not emitted via revert data,
     /// instead, they are handled externally so they don't add size to user programs.
@@ -154,7 +154,7 @@ impl BrilligArtifact {
     }
 
     /// Adds a brillig instruction to the brillig byte code
-    pub(crate) fn push_opcode(&mut self, opcode: BrilligOpcode) {
+    pub(crate) fn push_opcode(&mut self, opcode: BrilligOpcode<FieldElement>) {
         if !self.call_stack.is_empty() {
             self.locations.insert(self.index_of_next_opcode(), self.call_stack.clone());
         }
@@ -164,7 +164,7 @@ impl BrilligArtifact {
     /// Adds a unresolved jump to be fixed at the end of bytecode processing.
     pub(crate) fn add_unresolved_jump(
         &mut self,
-        jmp_instruction: BrilligOpcode,
+        jmp_instruction: BrilligOpcode<FieldElement>,
         destination: UnresolvedJumpLocation,
     ) {
         assert!(
@@ -178,7 +178,7 @@ impl BrilligArtifact {
     /// Adds a unresolved external call that will be fixed once linking has been done.
     pub(crate) fn add_unresolved_external_call(
         &mut self,
-        call_instruction: BrilligOpcode,
+        call_instruction: BrilligOpcode<FieldElement>,
         destination: UnresolvedJumpLocation,
     ) {
         // TODO: Add a check to ensure that the opcode is a call instruction
@@ -188,7 +188,7 @@ impl BrilligArtifact {
     }
 
     /// Returns true if the opcode is a jump instruction
-    fn is_jmp_instruction(instruction: &BrilligOpcode) -> bool {
+    fn is_jmp_instruction(instruction: &BrilligOpcode<FieldElement>) -> bool {
         matches!(
             instruction,
             BrilligOpcode::JumpIfNot { .. }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
index bbfdbb69f7c..cf1fd555191 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
@@ -1,4 +1,5 @@
 use acvm::{
+    acir::AcirField,
     brillig_vm::brillig::{HeapArray, HeapValueType, HeapVector, MemoryAddress, ValueOrArray},
     FieldElement,
 };
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
index 58166554e1d..42f3b34aea0 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -1,5 +1,6 @@
 use acvm::{
     acir::brillig::{BlackBoxOp, HeapArray},
+    acir::AcirField,
     FieldElement,
 };
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 38e9bdfa8b8..9023183eb36 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -5,7 +5,7 @@ use super::{
     registers::BrilligRegistersContext,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
-use acvm::{acir::brillig::MemoryAddress, FieldElement};
+use acvm::{acir::brillig::MemoryAddress, acir::AcirField, FieldElement};
 
 pub(crate) const MAX_STACK_SIZE: usize = 2048;
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 5d2430208e4..03a9216b73a 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -3,6 +3,7 @@ use acvm::{
         BinaryFieldOp, BinaryIntOp, BlackBoxOp, HeapArray, HeapValueType, MemoryAddress,
         Opcode as BrilligOpcode, ValueOrArray,
     },
+    acir::AcirField,
     FieldElement,
 };
 
@@ -212,7 +213,7 @@ impl BrilligContext {
     /// Adds a unresolved `Jump` to the bytecode.
     fn add_unresolved_jump(
         &mut self,
-        jmp_instruction: BrilligOpcode,
+        jmp_instruction: BrilligOpcode<FieldElement>,
         destination: UnresolvedJumpLocation,
     ) {
         self.obj.add_unresolved_jump(jmp_instruction, destination);
@@ -380,7 +381,7 @@ impl BrilligContext {
             constant,
             result.bit_size
         );
-        if result.bit_size > 128 && !constant.fits_in_u128() {
+        if result.bit_size > 128 && constant.num_bits() > 128 {
             let high = FieldElement::from_be_bytes_reduce(
                 constant.to_be_bytes().get(0..16).expect("FieldElement::to_be_bytes() too short!"),
             );
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index c2fe7878bf8..d38601bfc1b 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -10,12 +10,15 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use crate::errors::{RuntimeError, SsaReport};
-use acvm::acir::{
-    circuit::{
-        brillig::BrilligBytecode, Circuit, ErrorSelector, ExpressionWidth, Program as AcirProgram,
-        PublicInputs,
+use acvm::{
+    acir::{
+        circuit::{
+            brillig::BrilligBytecode, Circuit, ErrorSelector, ExpressionWidth,
+            Program as AcirProgram, PublicInputs,
+        },
+        native_types::Witness,
     },
-    native_types::Witness,
+    FieldElement,
 };
 
 use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
@@ -102,7 +105,7 @@ fn time<T>(name: &str, print_timings: bool, f: impl FnOnce() -> T) -> T {
 
 #[derive(Default)]
 pub struct SsaProgramArtifact {
-    pub program: AcirProgram,
+    pub program: AcirProgram<FieldElement>,
     pub debug: Vec<DebugInfo>,
     pub warnings: Vec<SsaReport>,
     pub main_input_witnesses: Vec<Witness>,
@@ -113,7 +116,7 @@ pub struct SsaProgramArtifact {
 
 impl SsaProgramArtifact {
     fn new(
-        unconstrained_functions: Vec<BrilligBytecode>,
+        unconstrained_functions: Vec<BrilligBytecode<FieldElement>>,
         error_types: BTreeMap<ErrorSelector, HirType>,
     ) -> Self {
         let program = AcirProgram { functions: Vec::default(), unconstrained_functions };
@@ -194,7 +197,7 @@ pub fn create_program(
 
 pub struct SsaCircuitArtifact {
     name: String,
-    circuit: Circuit,
+    circuit: Circuit<FieldElement>,
     debug_info: DebugInfo,
     warnings: Vec<SsaReport>,
     input_witnesses: Vec<Witness>,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index b6e88a8d4b0..4a0f9f798ff 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -13,6 +13,7 @@ use acvm::acir::circuit::{AssertionPayload, ExpressionOrMemory, Opcode};
 use acvm::blackbox_solver;
 use acvm::brillig_vm::{MemoryValue, VMStatus, VM};
 use acvm::{
+    acir::AcirField,
     acir::{
         brillig::Opcode as BrilligOpcode,
         circuit::opcodes::FunctionInput,
@@ -269,7 +270,10 @@ impl AcirContext {
     }
 
     /// Converts an [`AcirVar`] to an [`Expression`]
-    pub(crate) fn var_to_expression(&self, var: AcirVar) -> Result<Expression, InternalError> {
+    pub(crate) fn var_to_expression(
+        &self,
+        var: AcirVar,
+    ) -> Result<Expression<FieldElement>, InternalError> {
         let var_data = match self.vars.get(&var) {
             Some(var_data) => var_data,
             None => {
@@ -498,7 +502,7 @@ impl AcirContext {
         &mut self,
         lhs: AcirVar,
         rhs: AcirVar,
-        assert_message: Option<AssertionPayload>,
+        assert_message: Option<AssertionPayload<FieldElement>>,
     ) -> Result<(), RuntimeError> {
         let lhs_expr = self.var_to_expression(lhs)?;
         let rhs_expr = self.var_to_expression(rhs)?;
@@ -527,7 +531,7 @@ impl AcirContext {
     pub(crate) fn vars_to_expressions_or_memory(
         &self,
         values: &[AcirValue],
-    ) -> Result<Vec<ExpressionOrMemory>, RuntimeError> {
+    ) -> Result<Vec<ExpressionOrMemory<FieldElement>>, RuntimeError> {
         let mut result = Vec::with_capacity(values.len());
         for value in values {
             match value {
@@ -901,7 +905,7 @@ impl AcirContext {
 
         // Optimization when rhs is const and fits within a u128
         let rhs_expr = self.var_to_expression(rhs)?;
-        if rhs_expr.is_const() && rhs_expr.q_c.fits_in_u128() {
+        if rhs_expr.is_const() && rhs_expr.q_c.num_bits() <= 128 {
             // We try to move the offset to rhs
             let rhs_offset = if self.is_constant_one(&offset) && rhs_expr.q_c.to_u128() >= 1 {
                 lhs_offset = lhs;
@@ -1554,21 +1558,24 @@ impl AcirContext {
         brillig_function_index: u32,
         brillig_stdlib_func: Option<BrilligStdlibFunc>,
     ) -> Result<Vec<AcirValue>, RuntimeError> {
-        let brillig_inputs = try_vecmap(inputs, |i| -> Result<_, InternalError> {
-            match i {
-                AcirValue::Var(var, _) => Ok(BrilligInputs::Single(self.var_to_expression(var)?)),
-                AcirValue::Array(vars) => {
-                    let mut var_expressions: Vec<Expression> = Vec::new();
-                    for var in vars {
-                        self.brillig_array_input(&mut var_expressions, var)?;
+        let brillig_inputs: Vec<BrilligInputs<FieldElement>> =
+            try_vecmap(inputs, |i| -> Result<_, InternalError> {
+                match i {
+                    AcirValue::Var(var, _) => {
+                        Ok(BrilligInputs::Single(self.var_to_expression(var)?))
+                    }
+                    AcirValue::Array(vars) => {
+                        let mut var_expressions: Vec<Expression<FieldElement>> = Vec::new();
+                        for var in vars {
+                            self.brillig_array_input(&mut var_expressions, var)?;
+                        }
+                        Ok(BrilligInputs::Array(var_expressions))
+                    }
+                    AcirValue::DynamicArray(AcirDynamicArray { block_id, .. }) => {
+                        Ok(BrilligInputs::MemoryArray(block_id))
                     }
-                    Ok(BrilligInputs::Array(var_expressions))
-                }
-                AcirValue::DynamicArray(AcirDynamicArray { block_id, .. }) => {
-                    Ok(BrilligInputs::MemoryArray(block_id))
                 }
-            }
-        })?;
+            })?;
 
         // Optimistically try executing the brillig now, if we can complete execution they just return the results.
         // This is a temporary measure pending SSA optimizations being applied to Brillig which would remove constant-input opcodes (See #2066)
@@ -1645,7 +1652,7 @@ impl AcirContext {
 
     fn brillig_array_input(
         &mut self,
-        var_expressions: &mut Vec<Expression>,
+        var_expressions: &mut Vec<Expression<FieldElement>>,
         input: AcirValue,
     ) -> Result<(), InternalError> {
         match input {
@@ -1704,8 +1711,8 @@ impl AcirContext {
 
     fn execute_brillig(
         &mut self,
-        code: &[BrilligOpcode],
-        inputs: &[BrilligInputs],
+        code: &[BrilligOpcode<FieldElement>],
+        inputs: &[BrilligInputs<FieldElement>],
         outputs_types: &[AcirType],
     ) -> Option<Vec<AcirValue>> {
         let mut memory = (execute_brillig(code, inputs)?).into_iter();
@@ -1730,7 +1737,7 @@ impl AcirContext {
         &mut self,
         element_types: &[AcirType],
         size: usize,
-        memory_iter: &mut impl Iterator<Item = MemoryValue>,
+        memory_iter: &mut impl Iterator<Item = MemoryValue<FieldElement>>,
     ) -> AcirValue {
         let mut array_values = im::Vector::new();
         for _ in 0..size {
@@ -1885,7 +1892,7 @@ impl AcirContext {
 #[derive(Debug, Eq, Clone)]
 enum AcirVarData {
     Witness(Witness),
-    Expr(Expression),
+    Expr(Expression<FieldElement>),
     Const(FieldElement),
 }
 
@@ -1917,7 +1924,7 @@ impl AcirVarData {
         None
     }
     /// Converts all enum variants to an Expression.
-    pub(crate) fn to_expression(&self) -> Cow<Expression> {
+    pub(crate) fn to_expression(&self) -> Cow<Expression<FieldElement>> {
         match self {
             AcirVarData::Witness(witness) => Cow::Owned(Expression::from(*witness)),
             AcirVarData::Expr(expr) => Cow::Borrowed(expr),
@@ -1938,8 +1945,8 @@ impl From<Witness> for AcirVarData {
     }
 }
 
-impl From<Expression> for AcirVarData {
-    fn from(expr: Expression) -> Self {
+impl From<Expression<FieldElement>> for AcirVarData {
+    fn from(expr: Expression<FieldElement>) -> Self {
         // Prefer simpler variants if possible.
         if let Some(constant) = expr.to_const() {
             AcirVarData::from(constant)
@@ -1960,7 +1967,10 @@ pub(crate) struct AcirVar(usize);
 /// Returns the finished state of the Brillig VM if execution can complete.
 ///
 /// Returns `None` if complete execution of the Brillig bytecode is not possible.
-fn execute_brillig(code: &[BrilligOpcode], inputs: &[BrilligInputs]) -> Option<Vec<MemoryValue>> {
+fn execute_brillig(
+    code: &[BrilligOpcode<FieldElement>],
+    inputs: &[BrilligInputs<FieldElement>],
+) -> Option<Vec<MemoryValue<FieldElement>>> {
     // Set input values
     let mut calldata: Vec<FieldElement> = Vec::new();
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
index c21188a8dbc..b9c596d80c7 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use num_bigint::BigUint;
 
 /// Represents a bigint value in the form (id, modulus) where
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index d23f4abe5f5..6c79c0a228d 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -17,6 +17,7 @@ use acvm::acir::{
     BlackBoxFunc,
 };
 use acvm::{
+    acir::AcirField,
     acir::{circuit::directives::Directive, native_types::Expression},
     FieldElement,
 };
@@ -41,7 +42,7 @@ pub(crate) struct GeneratedAcir {
     current_witness_index: Option<u32>,
 
     /// The opcodes of which the compiled ACIR will comprise.
-    opcodes: Vec<AcirOpcode>,
+    opcodes: Vec<AcirOpcode<FieldElement>>,
 
     /// All witness indices that comprise the final return value of the program
     ///
@@ -60,7 +61,7 @@ pub(crate) struct GeneratedAcir {
     pub(crate) call_stack: CallStack,
 
     /// Correspondence between an opcode index and the error message associated with it.
-    pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload>,
+    pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload<FieldElement>>,
 
     pub(crate) warnings: Vec<SsaReport>,
 
@@ -99,18 +100,18 @@ impl GeneratedAcir {
     }
 
     /// Adds a new opcode into ACIR.
-    pub(crate) fn push_opcode(&mut self, opcode: AcirOpcode) {
+    pub(crate) fn push_opcode(&mut self, opcode: AcirOpcode<FieldElement>) {
         self.opcodes.push(opcode);
         if !self.call_stack.is_empty() {
             self.locations.insert(self.last_acir_opcode_location(), self.call_stack.clone());
         }
     }
 
-    pub(crate) fn opcodes(&self) -> &[AcirOpcode] {
+    pub(crate) fn opcodes(&self) -> &[AcirOpcode<FieldElement>] {
         &self.opcodes
     }
 
-    pub(crate) fn take_opcodes(&mut self) -> Vec<AcirOpcode> {
+    pub(crate) fn take_opcodes(&mut self) -> Vec<AcirOpcode<FieldElement>> {
         std::mem::take(&mut self.opcodes)
     }
 
@@ -129,7 +130,7 @@ impl GeneratedAcir {
     ///
     /// If `expr` can be represented as a `Witness` then this function will return it,
     /// else a new opcode will be added to create a `Witness` that is equal to `expr`.
-    pub(crate) fn get_or_create_witness(&mut self, expr: &Expression) -> Witness {
+    pub(crate) fn get_or_create_witness(&mut self, expr: &Expression<FieldElement>) -> Witness {
         match expr.to_witness() {
             Some(witness) => witness,
             None => self.create_witness_for_expression(expr),
@@ -142,7 +143,10 @@ impl GeneratedAcir {
     /// This means you cannot multiply an infinite amount of `Expression`s together.
     /// Once the `Expression` goes over degree-2, then it needs to be reduced to a `Witness`
     /// which has degree-1 in order to be able to continue the multiplication chain.
-    pub(crate) fn create_witness_for_expression(&mut self, expression: &Expression) -> Witness {
+    pub(crate) fn create_witness_for_expression(
+        &mut self,
+        expression: &Expression<FieldElement>,
+    ) -> Witness {
         let fresh_witness = self.next_witness_index();
 
         // Create a constraint that sets them to be equal to each other
@@ -392,7 +396,7 @@ impl GeneratedAcir {
     /// Only radix that are a power of two are supported
     pub(crate) fn radix_le_decompose(
         &mut self,
-        input_expr: &Expression,
+        input_expr: &Expression<FieldElement>,
         radix: u32,
         limb_count: u32,
         bit_size: u32,
@@ -438,7 +442,7 @@ impl GeneratedAcir {
     ///
     /// Safety: It is the callers responsibility to ensure that the
     /// resulting `Witness` is constrained to be the inverse.
-    pub(crate) fn brillig_inverse(&mut self, expr: Expression) -> Witness {
+    pub(crate) fn brillig_inverse(&mut self, expr: Expression<FieldElement>) -> Witness {
         // Create the witness for the result
         let inverted_witness = self.next_witness_index();
 
@@ -462,14 +466,18 @@ impl GeneratedAcir {
     ///
     /// If `expr` is not zero, then the constraint system will
     /// fail upon verification.
-    pub(crate) fn assert_is_zero(&mut self, expr: Expression) {
+    pub(crate) fn assert_is_zero(&mut self, expr: Expression<FieldElement>) {
         self.push_opcode(AcirOpcode::AssertZero(expr));
     }
 
     /// Returns a `Witness` that is constrained to be:
     /// - `1` if `lhs == rhs`
     /// - `0` otherwise
-    pub(crate) fn is_equal(&mut self, lhs: &Expression, rhs: &Expression) -> Witness {
+    pub(crate) fn is_equal(
+        &mut self,
+        lhs: &Expression<FieldElement>,
+        rhs: &Expression<FieldElement>,
+    ) -> Witness {
         let t = lhs - rhs;
 
         self.is_zero(&t)
@@ -527,7 +535,7 @@ impl GeneratedAcir {
     /// By setting `z` to be `0`, we can make `y` equal to `1`.
     /// This is easily observed: `y = 1 - t * 0`
     /// Now since `y` is one, this means that `t` needs to be zero, or else `y * t == 0` will fail.
-    fn is_zero(&mut self, t_expr: &Expression) -> Witness {
+    fn is_zero(&mut self, t_expr: &Expression<FieldElement>) -> Witness {
         // We're checking for equality with zero so we can negate the expression without changing the result.
         // This is useful as it will sometimes allow us to simplify an expression down to a witness.
         let t_witness = if let Some(witness) = t_expr.to_witness() {
@@ -588,9 +596,9 @@ impl GeneratedAcir {
 
     pub(crate) fn brillig_call(
         &mut self,
-        predicate: Option<Expression>,
+        predicate: Option<Expression<FieldElement>>,
         generated_brillig: &GeneratedBrillig,
-        inputs: Vec<BrilligInputs>,
+        inputs: Vec<BrilligInputs<FieldElement>>,
         outputs: Vec<BrilligOutputs>,
         brillig_function_index: u32,
         stdlib_func: Option<BrilligStdlibFunc>,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 30fd83d7704..e9b2d5f46df 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -37,6 +37,7 @@ use acvm::acir::circuit::{AssertionPayload, ErrorSelector, OpcodeLocation};
 use acvm::acir::native_types::Witness;
 use acvm::acir::BlackBoxFunc;
 use acvm::{
+    acir::AcirField,
     acir::{circuit::opcodes::BlockId, native_types::Expression},
     FieldElement,
 };
@@ -278,7 +279,7 @@ impl AcirValue {
 }
 
 pub(crate) type Artifacts =
-    (Vec<GeneratedAcir>, Vec<BrilligBytecode>, BTreeMap<ErrorSelector, ErrorType>);
+    (Vec<GeneratedAcir>, Vec<BrilligBytecode<FieldElement>>, BTreeMap<ErrorSelector, ErrorType>);
 
 impl Ssa {
     #[tracing::instrument(level = "trace", skip_all)]
@@ -3097,7 +3098,7 @@ mod test {
     }
 
     fn check_call_opcode(
-        opcode: &Opcode,
+        opcode: &Opcode<FieldElement>,
         expected_id: u32,
         expected_inputs: Vec<Witness>,
         expected_outputs: Vec<Witness>,
@@ -3425,7 +3426,7 @@ mod test {
 
     fn check_brillig_calls(
         brillig_stdlib_function_locations: &BTreeMap<OpcodeLocation, BrilligStdlibFunc>,
-        opcodes: &[Opcode],
+        opcodes: &[Opcode<FieldElement>],
         num_normal_brillig_functions: u32,
         expected_num_stdlib_calls: u32,
         expected_num_normal_calls: u32,
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index f5afbfae1bb..b24c5632b24 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -516,7 +516,7 @@ impl std::ops::Index<BasicBlockId> for FunctionBuilder {
 mod tests {
     use std::rc::Rc;
 
-    use acvm::FieldElement;
+    use acvm::{acir::AcirField, FieldElement};
 
     use crate::ssa::ir::{
         instruction::{Endian, Intrinsic},
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
index c71781557bd..545827df1c5 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
@@ -13,7 +13,7 @@ use super::{
     value::{Value, ValueId},
 };
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use fxhash::FxHashMap as HashMap;
 use iter_extended::vecmap;
 use noirc_errors::Location;
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 93ea703721f..5110140bfcc 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -1,6 +1,7 @@
 use std::hash::{Hash, Hasher};
 
 use acvm::{
+    acir::AcirField,
     acir::{
         circuit::{ErrorSelector, STRING_ERROR_SELECTOR},
         BlackBoxFunc,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
index 9099268ace9..dbb717b0a10 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 
 use super::{
     DataFlowGraph, Instruction, InstructionResultType, NumericType, SimplifyResult, Type, ValueId,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 8f57d9de368..74e5653c7ba 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -1,7 +1,7 @@
 use fxhash::FxHashMap as HashMap;
 use std::{collections::VecDeque, rc::Rc};
 
-use acvm::{acir::BlackBoxFunc, BlackBoxResolutionError, FieldElement};
+use acvm::{acir::AcirField, acir::BlackBoxFunc, BlackBoxResolutionError, FieldElement};
 use iter_extended::vecmap;
 use num_bigint::BigUint;
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs
index 671820e801d..d0ed5a1fa9c 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use num_bigint::BigUint;
 
 use super::{DataFlowGraph, Instruction, NumericType, SimplifyResult, Type, Value, ValueId};
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
index d844f350927..66f50440d64 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 
 use super::{Binary, BinaryOp, ConstrainError, DataFlowGraph, Instruction, Type, Value, ValueId};
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 58c593b0ad6..f7ffe2406ec 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -5,6 +5,7 @@ use std::{
 };
 
 use acvm::acir::circuit::{ErrorSelector, STRING_ERROR_SELECTOR};
+use acvm::acir::AcirField;
 use iter_extended::vecmap;
 
 use super::{
diff --git a/compiler/noirc_evaluator/src/ssa/ir/types.rs b/compiler/noirc_evaluator/src/ssa/ir/types.rs
index d72ad487f66..ded385d2d3c 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/types.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/types.rs
@@ -1,6 +1,6 @@
 use std::rc::Rc;
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 
 /// A numeric type in the Intermediate representation
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index ac2f6424332..48bd70ff139 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -21,7 +21,7 @@
 //! different blocks are merged, i.e. after the [`flatten_cfg`][super::flatten_cfg] pass.
 use std::collections::HashSet;
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 
 use crate::ssa::{
@@ -288,6 +288,7 @@ mod test {
             value::{Value, ValueId},
         },
     };
+    use acvm::acir::AcirField;
 
     #[test]
     fn simple_constant_fold() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index 0f8b49b40ec..690c0244f62 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -134,7 +134,7 @@
 use fxhash::FxHashMap as HashMap;
 use std::collections::{BTreeMap, HashSet};
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 
 use crate::ssa::{
@@ -792,6 +792,8 @@ impl<'f> Context<'f> {
 mod test {
     use std::rc::Rc;
 
+    use acvm::acir::AcirField;
+
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
index 4fc19acd2ac..f0760f29006 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
@@ -5,7 +5,7 @@ use crate::ssa::ir::{
     value::{Value, ValueId},
 };
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use fxhash::FxHashMap as HashMap;
 
 pub(crate) struct SliceCapacityTracker<'a> {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
index 80f6529b7b3..c59134e4ecc 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use fxhash::{FxHashMap as HashMap, FxHashSet};
 
 use crate::ssa::ir::{
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 73dc3888184..1293671da50 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -4,6 +4,7 @@
 //! be a single function remaining when the pass finishes.
 use std::collections::{BTreeSet, HashSet};
 
+use acvm::acir::AcirField;
 use iter_extended::{btree_map, vecmap};
 
 use crate::ssa::{
@@ -562,7 +563,7 @@ impl<'function> PerFunctionContext<'function> {
 
 #[cfg(test)]
 mod test {
-    use acvm::FieldElement;
+    use acvm::{acir::AcirField, FieldElement};
     use noirc_frontend::monomorphization::ast::InlineType;
 
     use crate::ssa::{
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index 7b87142d824..5b1139e5b9c 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -406,7 +406,7 @@ impl<'f> PerFunctionContext<'f> {
 mod tests {
     use std::rc::Rc;
 
-    use acvm::FieldElement;
+    use acvm::{acir::AcirField, FieldElement};
     use im::vector;
 
     use crate::ssa::{
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index 65a77552c79..628e1bd7410 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -1,6 +1,6 @@
 use std::{borrow::Cow, rc::Rc};
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 
 use crate::ssa::{
     ir::{
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 464faa57323..6db76996747 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -10,7 +10,7 @@
 //!       before the [Instruction]. Continue inserting instructions until the next [Instruction::EnableSideEffects] is encountered.
 use std::collections::HashSet;
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 
 use crate::ssa::{
     ir::{
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
index 91b455dbf29..6ca7eb74e9d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -1,6 +1,6 @@
 use std::collections::hash_map::Entry;
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use fxhash::FxHashMap as HashMap;
 
 use crate::ssa::ir::value::ValueId;
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index f524b10f1f2..9d5d7879dcb 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -11,6 +11,8 @@
 //! Currently, 1 and 4 are unimplemented.
 use std::collections::HashSet;
 
+use acvm::acir::AcirField;
+
 use crate::ssa::{
     ir::{
         basic_block::BasicBlockId, cfg::ControlFlowGraph, dfg::CallStack, function::Function,
@@ -159,6 +161,7 @@ mod test {
             types::Type,
         },
     };
+    use acvm::acir::AcirField;
 
     #[test]
     fn inline_blocks() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index cfb5cfac326..5f58be41422 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -16,6 +16,8 @@
 //! we remove reference count instructions because they are only used by Brillig bytecode
 use std::collections::HashSet;
 
+use acvm::acir::AcirField;
+
 use crate::{
     errors::RuntimeError,
     ssa::{
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index ebcbfbabe73..df14ee99bd3 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -1,7 +1,7 @@
 use std::rc::Rc;
 use std::sync::{Mutex, RwLock};
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::Location;
 use noirc_frontend::ast::{BinaryOpKind, Signedness};
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 0173b17d28f..21131c71217 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -6,7 +6,7 @@ use crate::ast::{
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
 use crate::token::{Attributes, Token};
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
 
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index c3556dac6af..090a41fa7d9 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -26,6 +26,7 @@ use crate::{
     token::IntType,
     BinaryTypeOperator,
 };
+use acvm::acir::AcirField;
 use iter_extended::vecmap;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Ord, PartialOrd)]
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 863615da53d..9b2c0fbfee8 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -1,6 +1,7 @@
 use std::fmt::Display;
 use std::sync::atomic::{AtomicU32, Ordering};
 
+use acvm::acir::AcirField;
 use acvm::FieldElement;
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 3c8d805d802..4c2b58580cf 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -1,5 +1,6 @@
 use std::rc::Rc;
 
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index af5ba9a44cf..34cecf0ece4 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -1,5 +1,5 @@
 use crate::{hir::def_collector::dc_crate::CompilationError, Type};
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use noirc_errors::{CustomDiagnostic, Location};
 
 use super::value::Value;
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 5984e454f7a..c0aeb910f22 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -1,6 +1,6 @@
 use std::{collections::hash_map::Entry, rc::Rc};
 
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use im::Vector;
 use iter_extended::try_vecmap;
 use noirc_errors::Location;
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 1f006697359..8beac340c4b 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -11,6 +11,8 @@
 // XXX: Change mentions of intern to resolve. In regards to the above comment
 //
 // XXX: Resolver does not check for unused functions
+use acvm::acir::AcirField;
+
 use crate::hir_def::expr::{
     HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCapturedVar,
     HirCastExpression, HirConstructorExpression, HirExpression, HirIdent, HirIfExpression,
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index 0760749c9e0..3a570922c81 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -1,3 +1,4 @@
+use acvm::acir::AcirField;
 use iter_extended::vecmap;
 use noirc_errors::Span;
 
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index ebbc7fc9813..fdda271e79c 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use noirc_errors::{Position, Span, Spanned};
 use std::{fmt, iter::Map, vec::IntoIter};
 
diff --git a/compiler/noirc_frontend/src/monomorphization/debug.rs b/compiler/noirc_frontend/src/monomorphization/debug.rs
index 88943be727f..3b399c75706 100644
--- a/compiler/noirc_frontend/src/monomorphization/debug.rs
+++ b/compiler/noirc_frontend/src/monomorphization/debug.rs
@@ -1,3 +1,4 @@
+use acvm::acir::AcirField;
 use iter_extended::vecmap;
 use noirc_errors::debug_info::DebugVarId;
 use noirc_errors::Location;
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 54a6af97744..2e74eb87e60 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -21,7 +21,7 @@ use crate::{
     token::FunctionAttribute,
     Type, TypeBinding, TypeBindings, TypeVariable, TypeVariableKind,
 };
-use acvm::FieldElement;
+use acvm::{acir::AcirField, FieldElement};
 use iter_extended::{btree_map, try_vecmap, vecmap};
 use noirc_errors::Location;
 use noirc_printable_type::PrintableType;
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index cc0dbca247e..a12ecf01b56 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, str};
 
-use acvm::{brillig_vm::brillig::ForeignCallParam, FieldElement};
+use acvm::{acir::AcirField, brillig_vm::brillig::ForeignCallParam, FieldElement};
 use iter_extended::vecmap;
 use regex::{Captures, Regex};
 use serde::{Deserialize, Serialize};
@@ -81,10 +81,12 @@ pub enum ForeignCallError {
     ResolvedAssertMessage(String),
 }
 
-impl TryFrom<&[ForeignCallParam]> for PrintableValueDisplay {
+impl TryFrom<&[ForeignCallParam<FieldElement>]> for PrintableValueDisplay {
     type Error = ForeignCallError;
 
-    fn try_from(foreign_call_inputs: &[ForeignCallParam]) -> Result<Self, Self::Error> {
+    fn try_from(
+        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
+    ) -> Result<Self, Self::Error> {
         let (is_fmt_str, foreign_call_inputs) =
             foreign_call_inputs.split_last().ok_or(ForeignCallError::MissingForeignCallInputs)?;
 
@@ -97,7 +99,7 @@ impl TryFrom<&[ForeignCallParam]> for PrintableValueDisplay {
 }
 
 fn convert_string_inputs(
-    foreign_call_inputs: &[ForeignCallParam],
+    foreign_call_inputs: &[ForeignCallParam<FieldElement>],
 ) -> Result<PrintableValueDisplay, ForeignCallError> {
     // Fetch the PrintableType from the foreign call input
     // The remaining input values should hold what is to be printed
@@ -114,7 +116,7 @@ fn convert_string_inputs(
 }
 
 fn convert_fmt_string_inputs(
-    foreign_call_inputs: &[ForeignCallParam],
+    foreign_call_inputs: &[ForeignCallParam<FieldElement>],
 ) -> Result<PrintableValueDisplay, ForeignCallError> {
     let (message, input_and_printable_types) =
         foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
@@ -143,7 +145,7 @@ fn convert_fmt_string_inputs(
 }
 
 fn fetch_printable_type(
-    printable_type: &ForeignCallParam,
+    printable_type: &ForeignCallParam<FieldElement>,
 ) -> Result<PrintableType, ForeignCallError> {
     let printable_type_as_fields = printable_type.fields();
     let printable_type_as_string = decode_string_value(&printable_type_as_fields);
diff --git a/compiler/wasm/Cargo.toml b/compiler/wasm/Cargo.toml
index 31ef5161014..23686cc4ea1 100644
--- a/compiler/wasm/Cargo.toml
+++ b/compiler/wasm/Cargo.toml
@@ -13,7 +13,7 @@ license.workspace = true
 crate-type = ["cdylib"]
 
 [dependencies]
-acvm.workspace = true
+acvm = { workspace = true, features = ["bn254"] }
 fm.workspace = true
 nargo.workspace = true
 noirc_driver.workspace = true
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index 5f9651c9138..ac3af03684f 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -2,6 +2,7 @@ use std::io::{self, Write};
 
 use acir::circuit::Program;
 use acir::native_types::{WitnessMap, WitnessStack};
+use acir::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
@@ -63,11 +64,11 @@ pub(crate) fn run(args: ExecuteCommand) -> Result<String, CliError> {
 }
 
 pub(crate) fn execute_program_from_witness(
-    inputs_map: WitnessMap,
+    inputs_map: WitnessMap<FieldElement>,
     bytecode: &[u8],
     foreign_call_resolver_url: Option<&str>,
-) -> Result<WitnessStack, CliError> {
-    let program: Program = Program::deserialize_program(bytecode)
+) -> Result<WitnessStack<FieldElement>, CliError> {
+    let program: Program<FieldElement> = Program::deserialize_program(bytecode)
         .map_err(|_| CliError::CircuitDeserializationError())?;
     execute_program(
         &program,
diff --git a/tooling/acvm_cli/src/cli/fs/inputs.rs b/tooling/acvm_cli/src/cli/fs/inputs.rs
index 2a46cfba884..a0b6e3a9545 100644
--- a/tooling/acvm_cli/src/cli/fs/inputs.rs
+++ b/tooling/acvm_cli/src/cli/fs/inputs.rs
@@ -1,6 +1,6 @@
 use acir::{
     native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField, FieldElement,
 };
 use toml::Table;
 
@@ -11,7 +11,7 @@ use std::{fs::read, path::Path};
 pub(crate) fn read_inputs_from_file<P: AsRef<Path>>(
     working_directory: P,
     file_name: &String,
-) -> Result<WitnessMap, CliError> {
+) -> Result<WitnessMap<FieldElement>, CliError> {
     let file_path = working_directory.as_ref().join(file_name);
     if !file_path.exists() {
         return Err(CliError::FilesystemError(FilesystemError::MissingTomlFile(
@@ -25,7 +25,7 @@ pub(crate) fn read_inputs_from_file<P: AsRef<Path>>(
     let input_map = input_string
         .parse::<Table>()
         .map_err(|_| FilesystemError::InvalidTomlFile(file_name.clone()))?;
-    let mut witnesses: WitnessMap = WitnessMap::new();
+    let mut witnesses: WitnessMap<FieldElement> = WitnessMap::new();
     for (key, value) in input_map.into_iter() {
         let index =
             Witness(key.trim().parse().map_err(|_| CliError::WitnessIndexError(key.clone()))?);
diff --git a/tooling/acvm_cli/src/cli/fs/witness.rs b/tooling/acvm_cli/src/cli/fs/witness.rs
index 30ef4278f4b..6ecba9792c3 100644
--- a/tooling/acvm_cli/src/cli/fs/witness.rs
+++ b/tooling/acvm_cli/src/cli/fs/witness.rs
@@ -5,7 +5,11 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use acvm::acir::native_types::{WitnessMap, WitnessStack};
+use acir::FieldElement;
+use acvm::acir::{
+    native_types::{WitnessMap, WitnessStack},
+    AcirField,
+};
 
 use crate::errors::{CliError, FilesystemError};
 
@@ -31,7 +35,9 @@ fn write_to_file(bytes: &[u8], path: &Path) -> String {
 }
 
 /// Creates a toml representation of the provided witness map
-pub(crate) fn create_output_witness_string(witnesses: &WitnessMap) -> Result<String, CliError> {
+pub(crate) fn create_output_witness_string(
+    witnesses: &WitnessMap<FieldElement>,
+) -> Result<String, CliError> {
     let mut witness_map: BTreeMap<String, String> = BTreeMap::new();
     for (key, value) in witnesses.clone().into_iter() {
         witness_map.insert(key.0.to_string(), format!("0x{}", value.to_hex()));
@@ -41,7 +47,7 @@ pub(crate) fn create_output_witness_string(witnesses: &WitnessMap) -> Result<Str
 }
 
 pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
-    witnesses: WitnessStack,
+    witnesses: WitnessStack<FieldElement>,
     witness_name: &str,
     witness_dir: P,
 ) -> Result<PathBuf, FilesystemError> {
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index a031d127d82..110e3211e24 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -26,28 +26,28 @@ pub(super) enum DebugCommandResult {
     Error(NargoError),
 }
 
-pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver> {
-    acvm: ACVM<'a, B>,
-    brillig_solver: Option<BrilligSolver<'a, B>>,
+pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver<FieldElement>> {
+    acvm: ACVM<'a, FieldElement, B>,
+    brillig_solver: Option<BrilligSolver<'a, FieldElement, B>>,
     foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
     debug_artifact: &'a DebugArtifact,
     breakpoints: HashSet<OpcodeLocation>,
     source_to_opcodes: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>>,
-    unconstrained_functions: &'a [BrilligBytecode],
+    unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 
     // Absolute (in terms of all the opcodes ACIR+Brillig) addresses of the ACIR
     // opcodes with one additional entry for to indicate the last valid address.
     acir_opcode_addresses: Vec<usize>,
 }
 
-impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
+impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     pub(super) fn new(
         blackbox_solver: &'a B,
-        circuit: &'a Circuit,
+        circuit: &'a Circuit<FieldElement>,
         debug_artifact: &'a DebugArtifact,
-        initial_witness: WitnessMap,
+        initial_witness: WitnessMap<FieldElement>,
         foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
-        unconstrained_functions: &'a [BrilligBytecode],
+        unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
     ) -> Self {
         let source_to_opcodes = build_source_to_opcode_debug_mappings(debug_artifact);
         let acir_opcode_addresses = build_acir_opcode_offsets(circuit, unconstrained_functions);
@@ -70,11 +70,11 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    pub(super) fn get_opcodes(&self) -> &[Opcode] {
+    pub(super) fn get_opcodes(&self) -> &[Opcode<FieldElement>] {
         self.acvm.opcodes()
     }
 
-    pub(super) fn get_witness_map(&self) -> &WitnessMap {
+    pub(super) fn get_witness_map(&self) -> &WitnessMap<FieldElement> {
         self.acvm.witness_map()
     }
 
@@ -302,7 +302,10 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    fn handle_foreign_call(&mut self, foreign_call: ForeignCallWaitInfo) -> DebugCommandResult {
+    fn handle_foreign_call(
+        &mut self,
+        foreign_call: ForeignCallWaitInfo<FieldElement>,
+    ) -> DebugCommandResult {
         let foreign_call_result = self.foreign_call_executor.execute(&foreign_call);
         match foreign_call_result {
             Ok(foreign_call_result) => {
@@ -319,7 +322,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    fn handle_acvm_status(&mut self, status: ACVMStatus) -> DebugCommandResult {
+    fn handle_acvm_status(&mut self, status: ACVMStatus<FieldElement>) -> DebugCommandResult {
         if let ACVMStatus::RequiresForeignCall(foreign_call) = status {
             return self.handle_foreign_call(foreign_call);
         }
@@ -465,7 +468,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         }
     }
 
-    pub(super) fn get_brillig_memory(&self) -> Option<&[MemoryValue]> {
+    pub(super) fn get_brillig_memory(&self) -> Option<&[MemoryValue<FieldElement>]> {
         self.brillig_solver.as_ref().map(|solver| solver.get_memory())
     }
 
@@ -539,7 +542,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         matches!(self.acvm.get_status(), ACVMStatus::Solved)
     }
 
-    pub fn finalize(self) -> WitnessMap {
+    pub fn finalize(self) -> WitnessMap<FieldElement> {
         self.acvm.finalize()
     }
 }
@@ -591,8 +594,8 @@ fn build_source_to_opcode_debug_mappings(
 }
 
 fn build_acir_opcode_offsets(
-    circuit: &Circuit,
-    unconstrained_functions: &[BrilligBytecode],
+    circuit: &Circuit<FieldElement>,
+    unconstrained_functions: &[BrilligBytecode<FieldElement>],
 ) -> Vec<usize> {
     let mut result = Vec::with_capacity(circuit.opcodes.len() + 1);
     // address of the first opcode is always 0
@@ -625,6 +628,7 @@ mod tests {
                 opcodes::BlockId,
             },
             native_types::Expression,
+            AcirField,
         },
         blackbox_solver::StubbedBlackBoxSolver,
         brillig_vm::brillig::{
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index c9b6b816a7e..d0ed0559b89 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -4,7 +4,7 @@ use std::io::{Read, Write};
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, OpcodeLocation};
 use acvm::acir::native_types::WitnessMap;
-use acvm::BlackBoxFunctionSolver;
+use acvm::{BlackBoxFunctionSolver, FieldElement};
 
 use crate::context::DebugCommandResult;
 use crate::context::DebugContext;
@@ -31,7 +31,7 @@ use noirc_driver::CompiledProgram;
 
 type BreakpointId = i64;
 
-pub struct DapSession<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> {
+pub struct DapSession<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> {
     server: Server<R, W>,
     context: DebugContext<'a, B>,
     debug_artifact: &'a DebugArtifact,
@@ -57,14 +57,14 @@ impl From<i64> for ScopeReferences {
     }
 }
 
-impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
+impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<'a, R, W, B> {
     pub fn new(
         server: Server<R, W>,
         solver: &'a B,
-        circuit: &'a Circuit,
+        circuit: &'a Circuit<FieldElement>,
         debug_artifact: &'a DebugArtifact,
-        initial_witness: WitnessMap,
-        unconstrained_functions: &'a [BrilligBytecode],
+        initial_witness: WitnessMap<FieldElement>,
+        unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
     ) -> Self {
         let context = DebugContext::new(
             solver,
@@ -602,11 +602,11 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver> DapSession<'a, R, W, B> {
     }
 }
 
-pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver>(
+pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>>(
     server: Server<R, W>,
     solver: &B,
     program: CompiledProgram,
-    initial_witness: WitnessMap,
+    initial_witness: WitnessMap<FieldElement>,
 ) -> Result<(), ServerError> {
     let debug_artifact = DebugArtifact {
         debug_symbols: program.debug,
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index 209439f5f92..6989936ae93 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -1,7 +1,7 @@
 use acvm::{
     acir::brillig::{ForeignCallParam, ForeignCallResult},
     pwg::ForeignCallWaitInfo,
-    FieldElement,
+    AcirField, FieldElement,
 };
 use nargo::{
     artifacts::debug::{DebugArtifact, DebugVars, StackFrame},
@@ -93,8 +93,8 @@ fn debug_fn_id(value: &FieldElement) -> DebugFnId {
 impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
     fn execute(
         &mut self,
-        foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<ForeignCallResult, ForeignCallError> {
+        foreign_call: &ForeignCallWaitInfo<FieldElement>,
+    ) -> Result<ForeignCallResult<FieldElement>, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match DebugForeignCall::lookup(foreign_call_name) {
             Some(DebugForeignCall::VarAssign) => {
diff --git a/tooling/debugger/src/lib.rs b/tooling/debugger/src/lib.rs
index a8fc61c893f..d7a1337c82f 100644
--- a/tooling/debugger/src/lib.rs
+++ b/tooling/debugger/src/lib.rs
@@ -10,29 +10,29 @@ use std::io::{Read, Write};
 use ::dap::errors::ServerError;
 use ::dap::server::Server;
 use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
+use acvm::{BlackBoxFunctionSolver, FieldElement};
 
 use nargo::artifacts::debug::DebugArtifact;
 
 use nargo::NargoError;
 use noirc_driver::CompiledProgram;
 
-pub fn debug_circuit<B: BlackBoxFunctionSolver>(
+pub fn debug_circuit<B: BlackBoxFunctionSolver<FieldElement>>(
     blackbox_solver: &B,
-    circuit: &Circuit,
+    circuit: &Circuit<FieldElement>,
     debug_artifact: DebugArtifact,
-    initial_witness: WitnessMap,
-    unconstrained_functions: &[BrilligBytecode],
-) -> Result<Option<WitnessMap>, NargoError> {
+    initial_witness: WitnessMap<FieldElement>,
+    unconstrained_functions: &[BrilligBytecode<FieldElement>],
+) -> Result<Option<WitnessMap<FieldElement>>, NargoError> {
     repl::run(blackbox_solver, circuit, &debug_artifact, initial_witness, unconstrained_functions)
 }
 
-pub fn run_dap_loop<R: Read, W: Write, B: BlackBoxFunctionSolver>(
+pub fn run_dap_loop<R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>>(
     server: Server<R, W>,
     solver: &B,
     program: CompiledProgram,
-    initial_witness: WitnessMap,
+    initial_witness: WitnessMap<FieldElement>,
 ) -> Result<(), ServerError> {
     dap::run_session(server, solver, program, initial_witness)
 }
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 8f908a38ffc..5aef12ad8d4 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -15,23 +15,23 @@ use std::cell::RefCell;
 
 use crate::source_code_printer::print_source_code_location;
 
-pub struct ReplDebugger<'a, B: BlackBoxFunctionSolver> {
+pub struct ReplDebugger<'a, B: BlackBoxFunctionSolver<FieldElement>> {
     context: DebugContext<'a, B>,
     blackbox_solver: &'a B,
-    circuit: &'a Circuit,
+    circuit: &'a Circuit<FieldElement>,
     debug_artifact: &'a DebugArtifact,
-    initial_witness: WitnessMap,
+    initial_witness: WitnessMap<FieldElement>,
     last_result: DebugCommandResult,
-    unconstrained_functions: &'a [BrilligBytecode],
+    unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 }
 
-impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
+impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
     pub fn new(
         blackbox_solver: &'a B,
-        circuit: &'a Circuit,
+        circuit: &'a Circuit<FieldElement>,
         debug_artifact: &'a DebugArtifact,
-        initial_witness: WitnessMap,
-        unconstrained_functions: &'a [BrilligBytecode],
+        initial_witness: WitnessMap<FieldElement>,
+        unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
     ) -> Self {
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
@@ -161,7 +161,7 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
                 ""
             }
         };
-        let print_brillig_bytecode = |acir_index, bytecode: &[BrilligOpcode]| {
+        let print_brillig_bytecode = |acir_index, bytecode: &[BrilligOpcode<FieldElement>]| {
             for (brillig_index, brillig_opcode) in bytecode.iter().enumerate() {
                 println!(
                     "{:>3}.{:<2} |{:2} {:?}",
@@ -371,18 +371,18 @@ impl<'a, B: BlackBoxFunctionSolver> ReplDebugger<'a, B> {
         self.context.is_solved()
     }
 
-    fn finalize(self) -> WitnessMap {
+    fn finalize(self) -> WitnessMap<FieldElement> {
         self.context.finalize()
     }
 }
 
-pub fn run<B: BlackBoxFunctionSolver>(
+pub fn run<B: BlackBoxFunctionSolver<FieldElement>>(
     blackbox_solver: &B,
-    circuit: &Circuit,
+    circuit: &Circuit<FieldElement>,
     debug_artifact: &DebugArtifact,
-    initial_witness: WitnessMap,
-    unconstrained_functions: &[BrilligBytecode],
-) -> Result<Option<WitnessMap>, NargoError> {
+    initial_witness: WitnessMap<FieldElement>,
+    unconstrained_functions: &[BrilligBytecode<FieldElement>],
+) -> Result<Option<WitnessMap<FieldElement>>, NargoError> {
     let context = RefCell::new(ReplDebugger::new(
         blackbox_solver,
         circuit,
diff --git a/tooling/lsp/src/lib.rs b/tooling/lsp/src/lib.rs
index 05345b96c80..304a2d34e47 100644
--- a/tooling/lsp/src/lib.rs
+++ b/tooling/lsp/src/lib.rs
@@ -13,7 +13,7 @@ use std::{
     task::{self, Poll},
 };
 
-use acvm::BlackBoxFunctionSolver;
+use acvm::{BlackBoxFunctionSolver, FieldElement};
 use async_lsp::{
     router::Router, AnyEvent, AnyNotification, AnyRequest, ClientSocket, Error, LspService,
     ResponseError,
@@ -79,7 +79,10 @@ pub struct LspState {
 }
 
 impl LspState {
-    fn new(client: &ClientSocket, solver: impl BlackBoxFunctionSolver + 'static) -> Self {
+    fn new(
+        client: &ClientSocket,
+        solver: impl BlackBoxFunctionSolver<FieldElement> + 'static,
+    ) -> Self {
         Self {
             client: client.clone(),
             root_path: None,
@@ -99,7 +102,10 @@ pub struct NargoLspService {
 }
 
 impl NargoLspService {
-    pub fn new(client: &ClientSocket, solver: impl BlackBoxFunctionSolver + 'static) -> Self {
+    pub fn new(
+        client: &ClientSocket,
+        solver: impl BlackBoxFunctionSolver<FieldElement> + 'static,
+    ) -> Self {
         let state = LspState::new(client, solver);
         let mut router = Router::new(state);
         router
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 87327b01e36..0fcac73b905 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -3,9 +3,9 @@ use acvm::BlackBoxFunctionSolver;
 // This is a struct that wraps a dynamically dispatched `BlackBoxFunctionSolver`
 // where we proxy the unimplemented stuff to the wrapped backend, but it
 // allows us to avoid changing function signatures to include the `Box`
-pub(super) struct WrapperSolver(pub(super) Box<dyn BlackBoxFunctionSolver>);
+pub(super) struct WrapperSolver(pub(super) Box<dyn BlackBoxFunctionSolver<acvm::FieldElement>>);
 
-impl BlackBoxFunctionSolver for WrapperSolver {
+impl BlackBoxFunctionSolver<acvm::FieldElement> for WrapperSolver {
     fn schnorr_verify(
         &self,
         public_key_x: &acvm::FieldElement,
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index a864da7c33c..1afc7977aec 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -1,4 +1,4 @@
-use acvm::acir::circuit::Program;
+use acvm::{acir::circuit::Program, FieldElement};
 use noirc_abi::{Abi, AbiType, AbiValue};
 use noirc_driver::{CompiledContract, CompiledContractOutputs, ContractFunction};
 use serde::{Deserialize, Serialize};
@@ -65,7 +65,7 @@ pub struct ContractFunctionArtifact {
         serialize_with = "Program::serialize_program_base64",
         deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Program,
+    pub bytecode: Program<FieldElement>,
 
     #[serde(
         serialize_with = "ProgramDebugInfo::serialize_compressed_base64_json",
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/nargo/src/artifacts/program.rs
index 3c25b9e3345..91f02157414 100644
--- a/tooling/nargo/src/artifacts/program.rs
+++ b/tooling/nargo/src/artifacts/program.rs
@@ -1,6 +1,7 @@
 use std::collections::BTreeMap;
 
 use acvm::acir::circuit::Program;
+use acvm::FieldElement;
 use fm::FileId;
 use noirc_abi::Abi;
 use noirc_driver::CompiledProgram;
@@ -24,7 +25,7 @@ pub struct ProgramArtifact {
         serialize_with = "Program::serialize_program_base64",
         deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Program,
+    pub bytecode: Program<FieldElement>,
 
     #[serde(
         serialize_with = "ProgramDebugInfo::serialize_compressed_base64_json",
diff --git a/tooling/nargo/src/errors.rs b/tooling/nargo/src/errors.rs
index 63a72247e2f..200420e5ce5 100644
--- a/tooling/nargo/src/errors.rs
+++ b/tooling/nargo/src/errors.rs
@@ -6,6 +6,7 @@ use acvm::{
         ResolvedOpcodeLocation,
     },
     pwg::{ErrorLocation, OpcodeResolutionError},
+    FieldElement,
 };
 use noirc_abi::{display_abi_error, Abi, AbiErrorType};
 use noirc_errors::{
@@ -95,10 +96,10 @@ impl NargoError {
 #[derive(Debug, Error)]
 pub enum ExecutionError {
     #[error("Failed assertion")]
-    AssertionFailed(ResolvedAssertionPayload, Vec<ResolvedOpcodeLocation>),
+    AssertionFailed(ResolvedAssertionPayload<FieldElement>, Vec<ResolvedOpcodeLocation>),
 
     #[error("Failed to solve program: '{}'", .0)]
-    SolvingError(OpcodeResolutionError, Option<Vec<ResolvedOpcodeLocation>>),
+    SolvingError(OpcodeResolutionError<FieldElement>, Option<Vec<ResolvedOpcodeLocation>>),
 }
 
 /// Extracts the opcode locations from a nargo error.
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 4a75212ba47..42e93e0e3cf 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -1,22 +1,24 @@
 use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::acir::circuit::{OpcodeLocation, Program, ResolvedOpcodeLocation};
+use acvm::acir::circuit::{
+    OpcodeLocation, Program, ResolvedAssertionPayload, ResolvedOpcodeLocation,
+};
 use acvm::acir::native_types::WitnessStack;
 use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ACVM};
-use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
+use acvm::{BlackBoxFunctionSolver, FieldElement};
 
 use crate::errors::ExecutionError;
 use crate::NargoError;
 
 use super::foreign_calls::ForeignCallExecutor;
 
-struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
-    functions: &'a [Circuit],
+struct ProgramExecutor<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor> {
+    functions: &'a [Circuit<FieldElement>],
 
-    unconstrained_functions: &'a [BrilligBytecode],
+    unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 
     // This gets built as we run through the program looking at each function call
-    witness_stack: WitnessStack,
+    witness_stack: WitnessStack<FieldElement>,
 
     blackbox_solver: &'a B,
 
@@ -32,10 +34,12 @@ struct ProgramExecutor<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> {
     current_function_index: usize,
 }
 
-impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a, B, F> {
+impl<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>
+    ProgramExecutor<'a, B, F>
+{
     fn new(
-        functions: &'a [Circuit],
-        unconstrained_functions: &'a [BrilligBytecode],
+        functions: &'a [Circuit<FieldElement>],
+        unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
         blackbox_solver: &'a B,
         foreign_call_executor: &'a mut F,
     ) -> Self {
@@ -50,12 +54,15 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
         }
     }
 
-    fn finalize(self) -> WitnessStack {
+    fn finalize(self) -> WitnessStack<FieldElement> {
         self.witness_stack
     }
 
     #[tracing::instrument(level = "trace", skip_all)]
-    fn execute_circuit(&mut self, initial_witness: WitnessMap) -> Result<WitnessMap, NargoError> {
+    fn execute_circuit(
+        &mut self,
+        initial_witness: WitnessMap<FieldElement>,
+    ) -> Result<WitnessMap<FieldElement>, NargoError> {
         let circuit = &self.functions[self.current_function_index];
         let mut acvm = ACVM::new(
             self.blackbox_solver,
@@ -102,13 +109,14 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
                         _ => None,
                     };
 
-                    let assertion_payload = match &error {
-                        OpcodeResolutionError::BrilligFunctionFailed { payload, .. }
-                        | OpcodeResolutionError::UnsatisfiedConstrain { payload, .. } => {
-                            payload.clone()
-                        }
-                        _ => None,
-                    };
+                    let assertion_payload: Option<ResolvedAssertionPayload<FieldElement>> =
+                        match &error {
+                            OpcodeResolutionError::BrilligFunctionFailed { payload, .. }
+                            | OpcodeResolutionError::UnsatisfiedConstrain { payload, .. } => {
+                                payload.clone()
+                            }
+                            _ => None,
+                        };
 
                     return Err(NargoError::ExecutionError(match assertion_payload {
                         Some(payload) => ExecutionError::AssertionFailed(
@@ -166,12 +174,12 @@ impl<'a, B: BlackBoxFunctionSolver, F: ForeignCallExecutor> ProgramExecutor<'a,
 }
 
 #[tracing::instrument(level = "trace", skip_all)]
-pub fn execute_program<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
-    program: &Program,
-    initial_witness: WitnessMap,
+pub fn execute_program<B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>(
+    program: &Program<FieldElement>,
+    initial_witness: WitnessMap<FieldElement>,
     blackbox_solver: &B,
     foreign_call_executor: &mut F,
-) -> Result<WitnessStack, NargoError> {
+) -> Result<WitnessStack<FieldElement>, NargoError> {
     let mut executor = ProgramExecutor::new(
         &program.functions,
         &program.unconstrained_functions,
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index c314a230cef..c6b284beb13 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -1,7 +1,7 @@
 use acvm::{
     acir::brillig::{ForeignCallParam, ForeignCallResult},
     pwg::ForeignCallWaitInfo,
-    FieldElement,
+    AcirField, FieldElement,
 };
 use jsonrpc::{arg as build_json_rpc_arg, minreq_http::Builder, Client};
 use noirc_printable_type::{decode_string_value, ForeignCallError, PrintableValueDisplay};
@@ -9,8 +9,8 @@ use noirc_printable_type::{decode_string_value, ForeignCallError, PrintableValue
 pub trait ForeignCallExecutor {
     fn execute(
         &mut self,
-        foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<ForeignCallResult, ForeignCallError>;
+        foreign_call: &ForeignCallWaitInfo<FieldElement>,
+    ) -> Result<ForeignCallResult<FieldElement>, ForeignCallError>;
 }
 
 /// This enumeration represents the Brillig foreign calls that are natively supported by nargo.
@@ -66,11 +66,11 @@ struct MockedCall {
     /// The oracle it's mocking
     name: String,
     /// Optionally match the parameters
-    params: Option<Vec<ForeignCallParam>>,
+    params: Option<Vec<ForeignCallParam<FieldElement>>>,
     /// The parameters with which the mock was last called
-    last_called_params: Option<Vec<ForeignCallParam>>,
+    last_called_params: Option<Vec<ForeignCallParam<FieldElement>>>,
     /// The result to return when this mock is called
-    result: ForeignCallResult,
+    result: ForeignCallResult<FieldElement>,
     /// How many times should this mock be called before it is removed
     times_left: Option<u64>,
 }
@@ -89,7 +89,7 @@ impl MockedCall {
 }
 
 impl MockedCall {
-    fn matches(&self, name: &str, params: &[ForeignCallParam]) -> bool {
+    fn matches(&self, name: &str, params: &[ForeignCallParam<FieldElement>]) -> bool {
         self.name == name && (self.params.is_none() || self.params.as_deref() == Some(params))
     }
 }
@@ -130,8 +130,8 @@ impl DefaultForeignCallExecutor {
 
 impl DefaultForeignCallExecutor {
     fn extract_mock_id(
-        foreign_call_inputs: &[ForeignCallParam],
-    ) -> Result<(usize, &[ForeignCallParam]), ForeignCallError> {
+        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
+    ) -> Result<(usize, &[ForeignCallParam<FieldElement>]), ForeignCallError> {
         let (id, params) =
             foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
         let id =
@@ -148,12 +148,14 @@ impl DefaultForeignCallExecutor {
         self.mocked_responses.iter_mut().find(|response| response.id == id)
     }
 
-    fn parse_string(param: &ForeignCallParam) -> String {
+    fn parse_string(param: &ForeignCallParam<FieldElement>) -> String {
         let fields: Vec<_> = param.fields().to_vec();
         decode_string_value(&fields)
     }
 
-    fn execute_print(foreign_call_inputs: &[ForeignCallParam]) -> Result<(), ForeignCallError> {
+    fn execute_print(
+        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
+    ) -> Result<(), ForeignCallError> {
         let skip_newline = foreign_call_inputs[0].unwrap_field().is_zero();
 
         let foreign_call_inputs =
@@ -166,7 +168,7 @@ impl DefaultForeignCallExecutor {
     }
 
     fn format_printable_value(
-        foreign_call_inputs: &[ForeignCallParam],
+        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
         skip_newline: bool,
     ) -> Result<String, ForeignCallError> {
         let display_values: PrintableValueDisplay = foreign_call_inputs.try_into()?;
@@ -180,8 +182,8 @@ impl DefaultForeignCallExecutor {
 impl ForeignCallExecutor for DefaultForeignCallExecutor {
     fn execute(
         &mut self,
-        foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<ForeignCallResult, ForeignCallError> {
+        foreign_call: &ForeignCallWaitInfo<FieldElement>,
+    ) -> Result<ForeignCallResult<FieldElement>, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match ForeignCall::lookup(foreign_call_name) {
             Some(ForeignCall::Print) => {
@@ -280,7 +282,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
 
                     let response = external_resolver.send_request(req)?;
 
-                    let parsed_response: ForeignCallResult = response.result()?;
+                    let parsed_response: ForeignCallResult<FieldElement> = response.result()?;
 
                     Ok(parsed_response)
                 } else {
@@ -314,20 +316,32 @@ mod tests {
     #[rpc]
     pub trait OracleResolver {
         #[rpc(name = "echo")]
-        fn echo(&self, param: ForeignCallParam) -> RpcResult<ForeignCallResult>;
+        fn echo(
+            &self,
+            param: ForeignCallParam<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>>;
 
         #[rpc(name = "sum")]
-        fn sum(&self, array: ForeignCallParam) -> RpcResult<ForeignCallResult>;
+        fn sum(
+            &self,
+            array: ForeignCallParam<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>>;
     }
 
     struct OracleResolverImpl;
 
     impl OracleResolver for OracleResolverImpl {
-        fn echo(&self, param: ForeignCallParam) -> RpcResult<ForeignCallResult> {
+        fn echo(
+            &self,
+            param: ForeignCallParam<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>> {
             Ok(vec![param].into())
         }
 
-        fn sum(&self, array: ForeignCallParam) -> RpcResult<ForeignCallResult> {
+        fn sum(
+            &self,
+            array: ForeignCallParam<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>> {
             let mut res: FieldElement = 0_usize.into();
 
             for value in array.fields() {
diff --git a/tooling/nargo/src/ops/optimize.rs b/tooling/nargo/src/ops/optimize.rs
index a62f4696328..07adfb57df4 100644
--- a/tooling/nargo/src/ops/optimize.rs
+++ b/tooling/nargo/src/ops/optimize.rs
@@ -1,4 +1,4 @@
-use acvm::acir::circuit::Program;
+use acvm::{acir::circuit::Program, FieldElement};
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 use noirc_errors::debug_info::DebugInfo;
@@ -18,7 +18,10 @@ pub fn optimize_contract(contract: CompiledContract) -> CompiledContract {
     CompiledContract { functions, ..contract }
 }
 
-fn optimize_program_internal(mut program: Program, debug: &mut [DebugInfo]) -> Program {
+fn optimize_program_internal(
+    mut program: Program<FieldElement>,
+    debug: &mut [DebugInfo],
+) -> Program<FieldElement> {
     let functions = std::mem::take(&mut program.functions);
 
     let optimized_functions = functions
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 86dd8cd7cd5..ed45251ac8a 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -1,6 +1,6 @@
 use acvm::{
     acir::native_types::{WitnessMap, WitnessStack},
-    BlackBoxFunctionSolver,
+    BlackBoxFunctionSolver, FieldElement,
 };
 use noirc_abi::Abi;
 use noirc_driver::{compile_no_check, CompileError, CompileOptions};
@@ -23,7 +23,7 @@ impl TestStatus {
     }
 }
 
-pub fn run_test<B: BlackBoxFunctionSolver>(
+pub fn run_test<B: BlackBoxFunctionSolver<FieldElement>>(
     blackbox_solver: &B,
     context: &mut Context,
     test_function: &TestFunction,
@@ -76,7 +76,7 @@ fn test_status_program_compile_pass(
     test_function: &TestFunction,
     abi: Abi,
     debug: Vec<DebugInfo>,
-    circuit_execution: Result<WitnessStack, NargoError>,
+    circuit_execution: Result<WitnessStack<FieldElement>, NargoError>,
 ) -> TestStatus {
     let circuit_execution_err = match circuit_execution {
         // Circuit execution was successful; ie no errors or unsatisfied constraints
diff --git a/tooling/nargo/src/ops/transform.rs b/tooling/nargo/src/ops/transform.rs
index b4811bd5780..9255ac3e0ec 100644
--- a/tooling/nargo/src/ops/transform.rs
+++ b/tooling/nargo/src/ops/transform.rs
@@ -1,4 +1,7 @@
-use acvm::acir::circuit::{ExpressionWidth, Program};
+use acvm::{
+    acir::circuit::{ExpressionWidth, Program},
+    FieldElement,
+};
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 use noirc_errors::debug_info::DebugInfo;
@@ -30,10 +33,10 @@ pub fn transform_contract(
 }
 
 fn transform_program_internal(
-    mut program: Program,
+    mut program: Program<FieldElement>,
     debug: &mut [DebugInfo],
     expression_width: ExpressionWidth,
-) -> Program {
+) -> Program<FieldElement> {
     let functions = std::mem::take(&mut program.functions);
 
     let optimized_functions = functions
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index d10dd6a22ff..9e886bc7002 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -32,7 +32,7 @@ noirc_driver.workspace = true
 noirc_frontend.workspace = true
 noirc_abi.workspace = true
 noirc_errors.workspace = true
-acvm.workspace = true
+acvm = { workspace = true, features = ["bn254"] }
 bn254_blackbox_solver.workspace = true
 toml.workspace = true
 serde.workspace = true
diff --git a/tooling/nargo_cli/src/cli/dap_cmd.rs b/tooling/nargo_cli/src/cli/dap_cmd.rs
index eded2bfd8d2..a84e961cfe7 100644
--- a/tooling/nargo_cli/src/cli/dap_cmd.rs
+++ b/tooling/nargo_cli/src/cli/dap_cmd.rs
@@ -1,5 +1,6 @@
 use acvm::acir::circuit::ExpressionWidth;
 use acvm::acir::native_types::WitnessMap;
+use acvm::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 use nargo::constants::PROVER_INPUT_FILE;
@@ -101,7 +102,7 @@ fn load_and_compile_project(
     expression_width: ExpressionWidth,
     acir_mode: bool,
     skip_instrumentation: bool,
-) -> Result<(CompiledProgram, WitnessMap), LoadError> {
+) -> Result<(CompiledProgram, WitnessMap<FieldElement>), LoadError> {
     let workspace = find_workspace(project_folder, package)
         .ok_or(LoadError::Generic(workspace_not_found_error_msg(project_folder, package)))?;
     let package = workspace
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 7865b608261..adc17f41598 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 use acvm::acir::native_types::{WitnessMap, WitnessStack};
+use acvm::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
@@ -199,7 +200,7 @@ fn debug_program_and_decode(
     program: CompiledProgram,
     package: &Package,
     prover_name: &str,
-) -> Result<(Option<InputValue>, Option<WitnessMap>), CliError> {
+) -> Result<(Option<InputValue>, Option<WitnessMap<FieldElement>>), CliError> {
     // Parse the initial witness values from Prover.toml
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
@@ -218,7 +219,7 @@ fn debug_program_and_decode(
 pub(crate) fn debug_program(
     compiled_program: &CompiledProgram,
     inputs_map: &InputMap,
-) -> Result<Option<WitnessMap>, CliError> {
+) -> Result<Option<WitnessMap<FieldElement>>, CliError> {
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
     let debug_artifact = DebugArtifact {
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 3fcedbb8f54..c312cc4cfd6 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -1,4 +1,5 @@
 use acvm::acir::native_types::WitnessStack;
+use acvm::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
@@ -91,7 +92,7 @@ fn execute_program_and_decode(
     package: &Package,
     prover_name: &str,
     foreign_call_resolver_url: Option<&str>,
-) -> Result<(Option<InputValue>, WitnessStack), CliError> {
+) -> Result<(Option<InputValue>, WitnessStack<FieldElement>), CliError> {
     // Parse the initial witness values from Prover.toml
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
@@ -109,7 +110,7 @@ pub(crate) fn execute_program(
     compiled_program: &CompiledProgram,
     inputs_map: &InputMap,
     foreign_call_resolver_url: Option<&str>,
-) -> Result<WitnessStack, CliError> {
+) -> Result<WitnessStack<FieldElement>, CliError> {
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
     let solved_witness_stack_err = nargo::ops::execute_program(
diff --git a/tooling/nargo_cli/src/cli/fs/witness.rs b/tooling/nargo_cli/src/cli/fs/witness.rs
index 613cdec28da..f95eb3d7a4c 100644
--- a/tooling/nargo_cli/src/cli/fs/witness.rs
+++ b/tooling/nargo_cli/src/cli/fs/witness.rs
@@ -1,13 +1,13 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::native_types::WitnessStack;
+use acvm::{acir::native_types::WitnessStack, FieldElement};
 use nargo::constants::WITNESS_EXT;
 
 use super::{create_named_dir, write_to_file};
 use crate::errors::FilesystemError;
 
 pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
-    witness_stack: WitnessStack,
+    witness_stack: WitnessStack<FieldElement>,
     witness_name: &str,
     witness_dir: P,
 ) -> Result<PathBuf, FilesystemError> {
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 51e21248afd..99c284e5019 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use acvm::BlackBoxFunctionSolver;
+use acvm::{BlackBoxFunctionSolver, FieldElement};
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 use fm::FileManager;
@@ -119,7 +119,7 @@ pub(crate) fn run(args: TestCommand, config: NargoConfig) -> Result<(), CliError
     }
 }
 
-fn run_tests<S: BlackBoxFunctionSolver + Default>(
+fn run_tests<S: BlackBoxFunctionSolver<FieldElement> + Default>(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
     package: &Package,
@@ -157,7 +157,7 @@ fn run_tests<S: BlackBoxFunctionSolver + Default>(
     Ok(test_report)
 }
 
-fn run_test<S: BlackBoxFunctionSolver + Default>(
+fn run_test<S: BlackBoxFunctionSolver<FieldElement> + Default>(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
     package: &Package,
diff --git a/tooling/noirc_abi/src/input_parser/json.rs b/tooling/noirc_abi/src/input_parser/json.rs
index 7618cd6c15a..070f9effe42 100644
--- a/tooling/noirc_abi/src/input_parser/json.rs
+++ b/tooling/noirc_abi/src/input_parser/json.rs
@@ -1,6 +1,6 @@
 use super::{parse_str_to_field, InputValue};
 use crate::{errors::InputParserError, Abi, AbiType, MAIN_RETURN_NAME};
-use acvm::FieldElement;
+use acvm::{AcirField, FieldElement};
 use iter_extended::{try_btree_map, try_vecmap};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
diff --git a/tooling/noirc_abi/src/input_parser/mod.rs b/tooling/noirc_abi/src/input_parser/mod.rs
index 9629ddc87ab..14d92bc71b3 100644
--- a/tooling/noirc_abi/src/input_parser/mod.rs
+++ b/tooling/noirc_abi/src/input_parser/mod.rs
@@ -3,7 +3,7 @@ use num_traits::{Num, Zero};
 use std::collections::{BTreeMap, HashSet};
 use thiserror::Error;
 
-use acvm::FieldElement;
+use acvm::{AcirField, FieldElement};
 use serde::Serialize;
 
 use crate::errors::InputParserError;
@@ -229,7 +229,7 @@ impl Format {
 mod serialization_tests {
     use std::collections::BTreeMap;
 
-    use acvm::FieldElement;
+    use acvm::{AcirField, FieldElement};
     use strum::IntoEnumIterator;
 
     use crate::{
@@ -362,7 +362,7 @@ fn field_from_big_int(bigint: BigInt) -> FieldElement {
 
 #[cfg(test)]
 mod test {
-    use acvm::FieldElement;
+    use acvm::{AcirField, FieldElement};
     use num_bigint::BigUint;
 
     use super::parse_str_to_field;
diff --git a/tooling/noirc_abi/src/input_parser/toml.rs b/tooling/noirc_abi/src/input_parser/toml.rs
index b216fe58794..321d3511b5d 100644
--- a/tooling/noirc_abi/src/input_parser/toml.rs
+++ b/tooling/noirc_abi/src/input_parser/toml.rs
@@ -1,6 +1,6 @@
 use super::{parse_str_to_field, parse_str_to_signed, InputValue};
 use crate::{errors::InputParserError, Abi, AbiType, MAIN_RETURN_NAME};
-use acvm::FieldElement;
+use acvm::{AcirField, FieldElement};
 use iter_extended::{try_btree_map, try_vecmap};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 7a1d1787ca5..0acace71fb3 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -8,7 +8,7 @@ use acvm::{
         circuit::ErrorSelector,
         native_types::{Witness, WitnessMap},
     },
-    FieldElement,
+    AcirField, FieldElement,
 };
 use errors::AbiError;
 use input_parser::InputValue;
@@ -331,7 +331,7 @@ impl Abi {
         &self,
         input_map: &InputMap,
         return_value: Option<InputValue>,
-    ) -> Result<WitnessMap, AbiError> {
+    ) -> Result<WitnessMap<FieldElement>, AbiError> {
         // Check that no extra witness values have been provided.
         let param_names = self.parameter_names();
         if param_names.len() < input_map.len() {
@@ -439,7 +439,7 @@ impl Abi {
     /// Decode a `WitnessMap` into the types specified in the ABI.
     pub fn decode(
         &self,
-        witness_map: &WitnessMap,
+        witness_map: &WitnessMap<FieldElement>,
     ) -> Result<(InputMap, Option<InputValue>), AbiError> {
         let public_inputs_map =
             try_btree_map(self.parameters.clone(), |AbiParameter { name, typ, .. }| {
@@ -652,7 +652,7 @@ pub fn display_abi_error(
 mod test {
     use std::collections::BTreeMap;
 
-    use acvm::{acir::native_types::Witness, FieldElement};
+    use acvm::{acir::native_types::Witness, AcirField, FieldElement};
 
     use crate::{
         input_parser::InputValue, Abi, AbiParameter, AbiReturnType, AbiType, AbiVisibility,
diff --git a/tooling/noirc_abi_wasm/Cargo.toml b/tooling/noirc_abi_wasm/Cargo.toml
index c78c3ead0c3..5692c757d3e 100644
--- a/tooling/noirc_abi_wasm/Cargo.toml
+++ b/tooling/noirc_abi_wasm/Cargo.toml
@@ -12,7 +12,7 @@ license.workspace = true
 crate-type = ["cdylib"]
 
 [dependencies]
-acvm.workspace = true
+acvm = { workspace = true, features = ["bn254"] }
 noirc_abi.workspace = true
 iter-extended.workspace = true
 wasm-bindgen.workspace = true
diff --git a/tooling/noirc_abi_wasm/src/js_witness_map.rs b/tooling/noirc_abi_wasm/src/js_witness_map.rs
index 293c5c089f8..a82621822e4 100644
--- a/tooling/noirc_abi_wasm/src/js_witness_map.rs
+++ b/tooling/noirc_abi_wasm/src/js_witness_map.rs
@@ -2,7 +2,7 @@
 
 use acvm::{
     acir::native_types::{Witness, WitnessMap},
-    FieldElement,
+    AcirField, FieldElement,
 };
 use js_sys::{JsString, Map};
 use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
@@ -25,8 +25,8 @@ impl Default for JsWitnessMap {
     }
 }
 
-impl From<WitnessMap> for JsWitnessMap {
-    fn from(witness_map: WitnessMap) -> Self {
+impl From<WitnessMap<FieldElement>> for JsWitnessMap {
+    fn from(witness_map: WitnessMap<FieldElement>) -> Self {
         let js_map = JsWitnessMap::new();
         for (key, value) in witness_map {
             js_map.set(
@@ -38,7 +38,7 @@ impl From<WitnessMap> for JsWitnessMap {
     }
 }
 
-impl From<JsWitnessMap> for WitnessMap {
+impl From<JsWitnessMap> for WitnessMap<FieldElement> {
     fn from(js_map: JsWitnessMap) -> Self {
         let mut witness_map = WitnessMap::new();
         js_map.for_each(&mut |value, key| {
@@ -73,7 +73,7 @@ mod test {
 
     use acvm::{
         acir::native_types::{Witness, WitnessMap},
-        FieldElement,
+        AcirField, FieldElement,
     };
     use wasm_bindgen::JsValue;
 
diff --git a/tooling/noirc_abi_wasm/src/lib.rs b/tooling/noirc_abi_wasm/src/lib.rs
index 10c0c43b352..ef4a468b661 100644
--- a/tooling/noirc_abi_wasm/src/lib.rs
+++ b/tooling/noirc_abi_wasm/src/lib.rs
@@ -5,9 +5,12 @@
 // See Cargo.toml for explanation.
 use getrandom as _;
 
-use acvm::acir::{
-    circuit::RawAssertionPayload,
-    native_types::{WitnessMap, WitnessStack},
+use acvm::{
+    acir::{
+        circuit::RawAssertionPayload,
+        native_types::{WitnessMap, WitnessStack},
+    },
+    FieldElement,
 };
 use iter_extended::try_btree_map;
 use noirc_abi::{
@@ -125,8 +128,8 @@ pub fn abi_decode(abi: JsAbi, witness_map: JsWitnessMap) -> Result<JsValue, JsAb
 #[wasm_bindgen(js_name = serializeWitness)]
 pub fn serialise_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsAbiError> {
     console_error_panic_hook::set_once();
-    let converted_witness: WitnessMap = witness_map.into();
-    let witness_stack: WitnessStack = converted_witness.into();
+    let converted_witness: WitnessMap<FieldElement> = witness_map.into();
+    let witness_stack: WitnessStack<FieldElement> = converted_witness.into();
     let output = witness_stack.try_into();
     output.map_err(|_| JsAbiError::new("Failed to convert to Vec<u8>".to_string()))
 }
@@ -140,7 +143,7 @@ pub fn abi_decode_error(
     let mut abi: Abi =
         JsValueSerdeExt::into_serde(&JsValue::from(abi)).map_err(|err| err.to_string())?;
 
-    let raw_error: RawAssertionPayload =
+    let raw_error: RawAssertionPayload<FieldElement> =
         JsValueSerdeExt::into_serde(&JsValue::from(raw_error)).map_err(|err| err.to_string())?;
 
     let error_type = abi.error_types.remove(&raw_error.selector).expect("Missing error type");

From 33c2b6b8102aad5597aa9d71b04a59185bb285cf Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 17:03:21 +0100
Subject: [PATCH 304/416] chore: remove warnings field from `DebugArtifact`
 (#5118)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I'm not sure why the SSA warnings were ever added onto the
`DebugArtifact` but we don't use it at all so we can just remove them
(which avoids a dependency on `noirc_evaluator`)

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                               |  1 -
 tooling/debugger/src/context.rs          |  9 +++------
 tooling/debugger/src/dap.rs              |  6 +-----
 tooling/nargo/Cargo.toml                 |  1 -
 tooling/nargo/src/artifacts/debug.rs     | 23 ++++-------------------
 tooling/nargo_cli/src/cli/debug_cmd.rs   |  1 -
 tooling/nargo_cli/src/cli/execute_cmd.rs |  1 -
 7 files changed, 8 insertions(+), 34 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 919bdc48748..f1ea5929d32 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2484,7 +2484,6 @@ dependencies = [
  "noirc_abi",
  "noirc_driver",
  "noirc_errors",
- "noirc_evaluator",
  "noirc_frontend",
  "noirc_printable_type",
  "rayon",
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 110e3211e24..9dc5c758c6f 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -679,8 +679,7 @@ mod tests {
 
         let debug_symbols = vec![];
         let file_map = BTreeMap::new();
-        let warnings = vec![];
-        let debug_artifact = &DebugArtifact { debug_symbols, file_map, warnings };
+        let debug_artifact = &DebugArtifact { debug_symbols, file_map };
 
         let initial_witness = BTreeMap::from([(Witness(1), fe_1)]).into();
 
@@ -789,8 +788,7 @@ mod tests {
 
         let debug_symbols = vec![];
         let file_map = BTreeMap::new();
-        let warnings = vec![];
-        let debug_artifact = &DebugArtifact { debug_symbols, file_map, warnings };
+        let debug_artifact = &DebugArtifact { debug_symbols, file_map };
 
         let initial_witness = BTreeMap::from([(Witness(1), fe_1), (Witness(2), fe_1)]).into();
 
@@ -847,8 +845,7 @@ mod tests {
             Opcode::AssertZero(Expression::default()),
         ];
         let circuit = Circuit { opcodes, ..Circuit::default() };
-        let debug_artifact =
-            DebugArtifact { debug_symbols: vec![], file_map: BTreeMap::new(), warnings: vec![] };
+        let debug_artifact = DebugArtifact { debug_symbols: vec![], file_map: BTreeMap::new() };
         let brillig_funcs = &vec![brillig_bytecode];
         let context = DebugContext::new(
             &StubbedBlackBoxSolver,
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index d0ed0559b89..40b77f0ad2a 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -608,11 +608,7 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>>(
     program: CompiledProgram,
     initial_witness: WitnessMap<FieldElement>,
 ) -> Result<(), ServerError> {
-    let debug_artifact = DebugArtifact {
-        debug_symbols: program.debug,
-        file_map: program.file_map,
-        warnings: program.warnings,
-    };
+    let debug_artifact = DebugArtifact { debug_symbols: program.debug, file_map: program.file_map };
     let mut session = DapSession::new(
         server,
         solver,
diff --git a/tooling/nargo/Cargo.toml b/tooling/nargo/Cargo.toml
index 72b412ac5b9..48047d10ea6 100644
--- a/tooling/nargo/Cargo.toml
+++ b/tooling/nargo/Cargo.toml
@@ -15,7 +15,6 @@ fm.workspace = true
 noirc_abi.workspace = true
 noirc_driver.workspace = true
 noirc_errors.workspace = true
-noirc_evaluator.workspace = true
 noirc_frontend.workspace = true
 noirc_printable_type.workspace = true
 iter-extended.workspace = true
diff --git a/tooling/nargo/src/artifacts/debug.rs b/tooling/nargo/src/artifacts/debug.rs
index 2570c3f5c9f..21102c40fcf 100644
--- a/tooling/nargo/src/artifacts/debug.rs
+++ b/tooling/nargo/src/artifacts/debug.rs
@@ -1,7 +1,6 @@
 use codespan_reporting::files::{Error, Files, SimpleFile};
 use noirc_driver::{CompiledContract, CompiledProgram, DebugFile};
 use noirc_errors::{debug_info::DebugInfo, Location};
-use noirc_evaluator::errors::SsaReport;
 use serde::{Deserialize, Serialize};
 use std::{
     collections::{BTreeMap, BTreeSet},
@@ -18,7 +17,6 @@ use fm::{FileId, FileManager, PathString};
 pub struct DebugArtifact {
     pub debug_symbols: Vec<DebugInfo>,
     pub file_map: BTreeMap<FileId, DebugFile>,
-    pub warnings: Vec<SsaReport>,
 }
 
 impl DebugArtifact {
@@ -45,7 +43,7 @@ impl DebugArtifact {
             );
         }
 
-        Self { debug_symbols, file_map, warnings: Vec::new() }
+        Self { debug_symbols, file_map }
     }
 
     /// Given a location, returns its file's source code
@@ -121,11 +119,7 @@ impl DebugArtifact {
 
 impl From<CompiledProgram> for DebugArtifact {
     fn from(compiled_program: CompiledProgram) -> Self {
-        DebugArtifact {
-            debug_symbols: compiled_program.debug,
-            file_map: compiled_program.file_map,
-            warnings: compiled_program.warnings,
-        }
+        DebugArtifact { debug_symbols: compiled_program.debug, file_map: compiled_program.file_map }
     }
 }
 
@@ -134,7 +128,6 @@ impl From<ProgramArtifact> for DebugArtifact {
         DebugArtifact {
             debug_symbols: program_artifact.debug_symbols.debug_infos,
             file_map: program_artifact.file_map,
-            warnings: Vec::new(),
         }
     }
 }
@@ -147,11 +140,7 @@ impl From<CompiledContract> for DebugArtifact {
             .flat_map(|contract_function| contract_function.debug)
             .collect();
 
-        DebugArtifact {
-            debug_symbols: all_functions_debug,
-            file_map: compiled_artifact.file_map,
-            warnings: compiled_artifact.warnings,
-        }
+        DebugArtifact { debug_symbols: all_functions_debug, file_map: compiled_artifact.file_map }
     }
 }
 
@@ -163,11 +152,7 @@ impl From<ContractArtifact> for DebugArtifact {
             .flat_map(|contract_function| contract_function.debug_symbols.debug_infos)
             .collect();
 
-        DebugArtifact {
-            debug_symbols: all_functions_debug,
-            file_map: compiled_artifact.file_map,
-            warnings: Vec::new(),
-        }
+        DebugArtifact { debug_symbols: all_functions_debug, file_map: compiled_artifact.file_map }
     }
 }
 
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index adc17f41598..ebcd9ff6569 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -225,7 +225,6 @@ pub(crate) fn debug_program(
     let debug_artifact = DebugArtifact {
         debug_symbols: compiled_program.debug.clone(),
         file_map: compiled_program.file_map.clone(),
-        warnings: compiled_program.warnings.clone(),
     };
 
     noir_debugger::debug_circuit(
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index c312cc4cfd6..5d6754b29f7 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -125,7 +125,6 @@ pub(crate) fn execute_program(
             let debug_artifact = DebugArtifact {
                 debug_symbols: compiled_program.debug.clone(),
                 file_map: compiled_program.file_map.clone(),
-                warnings: compiled_program.warnings.clone(),
             };
 
             if let Some(diagnostic) =

From a40a9a55571deed386688fb84260bdf2794d4d38 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 28 May 2024 12:09:10 -0400
Subject: [PATCH 305/416] feat: Sync from aztec-packages (#5125)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: remove external blackbox solver from acir simulator
(https://github.com/AztecProtocol/aztec-packages/pull/6586)
chore: remove aes slice
(https://github.com/AztecProtocol/aztec-packages/pull/6550)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 .aztec-sync-commit                            |  2 +-
 acvm-repo/acvm_js/src/execute.rs              | 57 +----------
 acvm-repo/acvm_js/src/lib.rs                  |  5 +-
 .../test/browser/execute_circuit.test.ts      | 30 +-----
 .../acvm_js/test/node/execute_circuit.test.ts | 37 ++-----
 aztec_macros/src/lib.rs                       | 13 +--
 .../src/transforms/contract_interface.rs      |  6 +-
 aztec_macros/src/transforms/functions.rs      | 47 ++++-----
 aztec_macros/src/transforms/note_interface.rs | 96 ++++++++++++++++---
 aztec_macros/src/utils/hir_utils.rs           |  2 +-
 .../test/browser/recursion.test.ts            |  3 +-
 .../onchain_recursive_verification.test.ts    |  3 +-
 noir_stdlib/src/aes128.nr                     |  3 -
 .../ecdsa_secp256r1_3x/Nargo.toml             |  7 ++
 .../ecdsa_secp256r1_3x/Prover.toml            | 57 +++++++++++
 .../ecdsa_secp256r1_3x/src/main.nr            | 23 +++++
 tooling/noir_js/src/witness_generation.ts     | 26 +----
 17 files changed, 221 insertions(+), 196 deletions(-)
 create mode 100644 test_programs/execution_success/ecdsa_secp256r1_3x/Nargo.toml
 create mode 100644 test_programs/execution_success/ecdsa_secp256r1_3x/Prover.toml
 create mode 100644 test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 82e81e9d74c..fdbc14d511e 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-221e2479622aef8e70120dc0a9f91ffcbc99efba
+1d785fd1087d7387fc29213ca3be50b2fc9c4725
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 85cc3f455a0..94ef30604e2 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -19,20 +19,6 @@ use crate::{
     JsExecutionError, JsSolvedAndReturnWitness, JsWitnessMap, JsWitnessStack,
 };
 
-#[wasm_bindgen]
-pub struct WasmBlackBoxFunctionSolver;
-
-impl WasmBlackBoxFunctionSolver {
-    async fn initialize() -> WasmBlackBoxFunctionSolver {
-        WasmBlackBoxFunctionSolver
-    }
-}
-
-#[wasm_bindgen(js_name = "createBlackBoxSolver")]
-pub async fn create_black_box_solver() -> WasmBlackBoxFunctionSolver {
-    WasmBlackBoxFunctionSolver::initialize().await
-}
-
 /// Executes an ACIR circuit to generate the solved witness from the initial witness.
 ///
 /// @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
@@ -58,14 +44,12 @@ pub async fn execute_circuit(
 /// Executes an ACIR circuit to generate the solved witness from the initial witness.
 /// This method also extracts the public return values from the solved witness into its own return witness.
 ///
-/// @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
 /// @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
 /// @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `circuit`..
 /// @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
 /// @returns {SolvedAndReturnWitness} The solved witness calculated by executing the circuit on the provided inputs, as well as the return witness indices as specified by the circuit.
 #[wasm_bindgen(js_name = executeCircuitWithReturnWitness, skip_jsdoc)]
 pub async fn execute_circuit_with_return_witness(
-    _solver: &WasmBlackBoxFunctionSolver,
     program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
@@ -94,28 +78,10 @@ pub async fn execute_circuit_with_return_witness(
 
 /// Executes an ACIR circuit to generate the solved witness from the initial witness.
 ///
-/// @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
-/// @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
-/// @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `circuit`..
-/// @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
-/// @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
-#[wasm_bindgen(js_name = executeCircuitWithBlackBoxSolver, skip_jsdoc)]
-pub async fn execute_circuit_with_black_box_solver(
-    _solver: &WasmBlackBoxFunctionSolver,
-    program: Vec<u8>,
-    initial_witness: JsWitnessMap,
-    foreign_call_handler: ForeignCallHandler,
-) -> Result<JsWitnessMap, Error> {
-    console_error_panic_hook::set_once();
-
-    let mut witness_stack =
-        execute_program_with_native_type_return(program, initial_witness, &foreign_call_handler)
-            .await?;
-    let witness_map =
-        witness_stack.pop().expect("Should have at least one witness on the stack").witness;
-    Ok(witness_map.into())
-}
-
+/// @param {Uint8Array} program - A serialized representation of an ACIR program
+/// @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `program`.
+/// @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the program.
+/// @returns {WitnessStack} The solved witness calculated by executing the program on the provided inputs.
 #[wasm_bindgen(js_name = executeProgram, skip_jsdoc)]
 pub async fn execute_program(
     program: Vec<u8>,
@@ -124,21 +90,8 @@ pub async fn execute_program(
 ) -> Result<JsWitnessStack, Error> {
     console_error_panic_hook::set_once();
 
-    let solver = WasmBlackBoxFunctionSolver::initialize().await;
-
-    execute_program_with_black_box_solver(&solver, program, initial_witness, &foreign_call_handler)
-        .await
-}
-
-#[wasm_bindgen(js_name = executeProgramWithBlackBoxSolver, skip_jsdoc)]
-pub async fn execute_program_with_black_box_solver(
-    _solver: &WasmBlackBoxFunctionSolver,
-    program: Vec<u8>,
-    initial_witness: JsWitnessMap,
-    foreign_call_executor: &ForeignCallHandler,
-) -> Result<JsWitnessStack, Error> {
     let witness_stack =
-        execute_program_with_native_type_return(program, initial_witness, foreign_call_executor)
+        execute_program_with_native_type_return(program, initial_witness, &foreign_call_handler)
             .await?;
 
     Ok(witness_stack.into())
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index 3b8210f4875..fdb8d5ffe08 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -23,10 +23,7 @@ pub use build_info::build_info;
 pub use compression::{
     compress_witness, compress_witness_stack, decompress_witness, decompress_witness_stack,
 };
-pub use execute::{
-    create_black_box_solver, execute_circuit, execute_circuit_with_black_box_solver,
-    execute_circuit_with_return_witness, execute_program, execute_program_with_black_box_solver,
-};
+pub use execute::{execute_circuit, execute_circuit_with_return_witness, execute_program};
 pub use js_execution_error::JsExecutionError;
 pub use js_witness_map::JsSolvedAndReturnWitness;
 pub use js_witness_map::JsWitnessMap;
diff --git a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
index 625cc91cfe9..cfd5523b79f 100644
--- a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
@@ -1,13 +1,5 @@
 import { expect } from '@esm-bundle/chai';
-import initACVM, {
-  createBlackBoxSolver,
-  executeCircuit,
-  executeCircuitWithBlackBoxSolver,
-  WasmBlackBoxFunctionSolver,
-  WitnessMap,
-  initLogLevel,
-  ForeignCallHandler,
-} from '@noir-lang/acvm_js';
+import initACVM, { executeCircuit, WitnessMap, initLogLevel, ForeignCallHandler } from '@noir-lang/acvm_js';
 
 beforeEach(async () => {
   await initACVM();
@@ -122,23 +114,3 @@ it('successfully executes a MemoryOp opcode', async () => {
 
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
-
-it('successfully executes two circuits with same backend', async function () {
-  // chose pedersen op here because it is the one with slow initialization
-  // that led to the decision to pull backend initialization into a separate
-  // function/wasmbind
-  const solver: WasmBlackBoxFunctionSolver = await createBlackBoxSolver();
-
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/pedersen');
-
-  const solvedWitness0: WitnessMap = await executeCircuitWithBlackBoxSolver(solver, bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  expect(solvedWitness0).to.be.deep.eq(expectedWitnessMap);
-
-  const solvedWitness1: WitnessMap = await executeCircuitWithBlackBoxSolver(solver, bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-  expect(solvedWitness1).to.be.deep.eq(expectedWitnessMap);
-});
diff --git a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
index 3f9bde2898e..1e3517e8814 100644
--- a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
@@ -1,9 +1,6 @@
 import { expect } from 'chai';
 import {
-  createBlackBoxSolver,
   executeCircuit,
-  executeCircuitWithBlackBoxSolver,
-  WasmBlackBoxFunctionSolver,
   WitnessMap,
   ForeignCallHandler,
   executeProgram,
@@ -120,40 +117,18 @@ it('successfully executes a MemoryOp opcode', async () => {
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes two circuits with same backend', async function () {
-  this.timeout(10000);
-
-  // chose pedersen op here because it is the one with slow initialization
-  // that led to the decision to pull backend initialization into a separate
-  // function/wasmbind
-  const solver: WasmBlackBoxFunctionSolver = await createBlackBoxSolver();
-
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/pedersen');
-
-  const solvedWitness0 = await executeCircuitWithBlackBoxSolver(solver, bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  const solvedWitness1 = await executeCircuitWithBlackBoxSolver(solver, bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  expect(solvedWitness0).to.be.deep.eq(expectedWitnessMap);
-  expect(solvedWitness1).to.be.deep.eq(expectedWitnessMap);
-});
-
-it('successfully executes 500 circuits with same backend', async function () {
+it('successfully executes 500 pedersen circuits', async function () {
   this.timeout(100000);
 
-  // chose pedersen op here because it is the one with slow initialization
-  // that led to the decision to pull backend initialization into a separate
-  // function/wasmbind
-  const solver: WasmBlackBoxFunctionSolver = await createBlackBoxSolver();
+  // Pedersen opcodes used to have a large upfront cost due to generator calculation
+  // so we'd need to pass around the blackbox solver in JS to avoid redoing this work.
+  //
+  // This test now shows that we don't need to do this anymore without a performance regression.
 
   const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/pedersen');
 
   for (let i = 0; i < 500; i++) {
-    const solvedWitness = await executeCircuitWithBlackBoxSolver(solver, bytecode, initialWitnessMap, () => {
+    const solvedWitness = await executeCircuit(bytecode, initialWitnessMap, () => {
       throw Error('unexpected oracle');
     });
 
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 5326920511b..2daf86dc643 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -134,7 +134,6 @@ fn transform_module(
     for func in module.functions.iter_mut() {
         let mut is_private = false;
         let mut is_public = false;
-        let mut is_public_vm = false;
         let mut is_initializer = false;
         let mut is_internal = false;
         let mut insert_init_check = has_initializer;
@@ -152,8 +151,6 @@ fn transform_module(
                 is_internal = true;
             } else if is_custom_attribute(&secondary_attribute, "aztec(public)") {
                 is_public = true;
-            } else if is_custom_attribute(&secondary_attribute, "aztec(public-vm)") {
-                is_public_vm = true;
             }
             if is_custom_attribute(&secondary_attribute, "aztec(view)") {
                 is_static = true;
@@ -161,14 +158,8 @@ fn transform_module(
         }
 
         // Apply transformations to the function based on collected attributes
-        if is_private || is_public || is_public_vm {
-            let fn_type = if is_private {
-                "Private"
-            } else if is_public_vm {
-                "Avm"
-            } else {
-                "Public"
-            };
+        if is_private || is_public {
+            let fn_type = if is_private { "Private" } else { "Public" };
             let stub_src = stub_function(fn_type, func, is_static);
             stubs.push((stub_src, Location { file: *file_id, span: func.name_ident().span() }));
 
diff --git a/aztec_macros/src/transforms/contract_interface.rs b/aztec_macros/src/transforms/contract_interface.rs
index bb63357d251..90f9ce6164a 100644
--- a/aztec_macros/src/transforms/contract_interface.rs
+++ b/aztec_macros/src/transforms/contract_interface.rs
@@ -88,7 +88,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
         })
         .collect::<Vec<_>>()
         .join("");
-    if aztec_visibility != "Avm" {
+    if aztec_visibility != "Public" {
         let args_hash = if !parameters.is_empty() {
             format!(
                 "let mut args_acc: [Field] = &[];
@@ -125,7 +125,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
         );
         let fn_body = format!(
             "{}
-            dep::aztec::context::Avm{}{}CallInterface {{
+            dep::aztec::context::Public{}{}CallInterface {{
                 target_contract: self.target_contract,
                 selector: {},
                 args: args_acc,
@@ -134,7 +134,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
             args, is_static, is_void, fn_selector,
         );
         format!(
-            "pub fn {}(self, {}) -> dep::aztec::context::Avm{}{}CallInterface{} {{
+            "pub fn {}(self, {}) -> dep::aztec::context::Public{}{}CallInterface{} {{
                     {}
             }}",
             fn_name, fn_parameters, is_static, is_void, return_type_hint, fn_body
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 00e9c444421..0fb13975fec 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -36,15 +36,15 @@ pub fn transform_function(
     is_internal: bool,
     is_static: bool,
 ) -> Result<(), AztecMacroError> {
+    assert!(matches!(ty, "Private" | "Public"));
     let context_name = format!("{}Context", ty);
     let inputs_name = format!("{}ContextInputs", ty);
     let return_type_name = format!("{}CircuitPublicInputs", ty);
-    let is_avm = ty == "Avm";
     let is_private = ty == "Private";
 
     // Force a static context if the function is static
     if is_static {
-        let is_static_check = create_static_check(func.name(), is_avm);
+        let is_static_check = create_static_check(func.name(), is_private);
         func.def.body.statements.insert(0, is_static_check);
     }
 
@@ -72,10 +72,10 @@ pub fn transform_function(
     }
 
     // Insert the context creation as the first action
-    let create_context = if !is_avm {
-        create_context(&context_name, &func.def.parameters)?
+    let create_context = if is_private {
+        create_context_private(&context_name, &func.def.parameters)?
     } else {
-        create_context_avm()?
+        create_context_public()?
     };
     func.def.body.statements.splice(0..0, (create_context).iter().cloned());
 
@@ -84,7 +84,7 @@ pub fn transform_function(
     func.def.parameters.insert(0, input);
 
     // Abstract return types such that they get added to the kernel's return_values
-    if !is_avm {
+    if is_private {
         if let Some(return_values_statements) = abstract_return_values(func)? {
             // In case we are pushing return values to the context, we remove the statement that originated it
             // This avoids running duplicate code, since blocks like if/else can be value returning statements
@@ -101,13 +101,13 @@ pub fn transform_function(
     }
 
     // Push the finish method call to the end of the function
-    if !is_avm {
+    if is_private {
         let finish_def = create_context_finish();
         func.def.body.statements.push(finish_def);
     }
 
     // The AVM doesn't need a return type yet.
-    if !is_avm {
+    if is_private {
         let return_type = create_return_type(&return_type_name);
         func.def.return_type = return_type;
         func.def.return_visibility = Visibility::Public;
@@ -116,7 +116,7 @@ pub fn transform_function(
     }
 
     // Public functions should have unconstrained auto-inferred
-    func.def.is_unconstrained = matches!(ty, "Public" | "Avm");
+    func.def.is_unconstrained = !is_private;
 
     // Private functions need to be recursive
     if is_private {
@@ -285,8 +285,8 @@ fn create_mark_as_initialized(ty: &str) -> Statement {
 /// ```noir
 /// assert(context.inputs.call_context.is_static_call == true,  "Function can only be called statically")
 /// ```
-fn create_static_check(fname: &str, is_avm: bool) -> Statement {
-    let is_static_call_expr = if !is_avm {
+fn create_static_check(fname: &str, is_private: bool) -> Statement {
+    let is_static_call_expr = if is_private {
         ["inputs", "call_context", "is_static_call"]
             .iter()
             .fold(variable("context"), |acc, member| member_access(acc, member))
@@ -410,7 +410,7 @@ fn serialize_to_hasher(
 ///     let mut context = PrivateContext::new(inputs, hasher.hash());
 /// }
 /// ```
-fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
+fn create_context_private(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMacroError> {
     let mut injected_statements: Vec<Statement> = vec![];
 
     let hasher_name = "args_hasher";
@@ -471,30 +471,33 @@ fn create_context(ty: &str, params: &[Param]) -> Result<Vec<Statement>, AztecMac
     Ok(injected_statements)
 }
 
-/// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
-/// appended into the args hash object.
+/// Creates the public context object to be accessed within the function.
 ///
 /// The replaced code:
 /// ```noir
-/// #[aztec(public-vm)]
-/// fn foo(inputs: AvmContextInputs, ...) -> Field {
-///     let mut context = AvmContext::new(inputs);
+/// #[aztec(public)]
+/// fn foo(inputs: PublicContextInputs, ...) -> Field {
+///     let mut context = PublicContext::new(inputs);
 /// }
 /// ```
-fn create_context_avm() -> Result<Vec<Statement>, AztecMacroError> {
+fn create_context_public() -> Result<Vec<Statement>, AztecMacroError> {
     let mut injected_expressions: Vec<Statement> = vec![];
 
     // Create the inputs to the context
-    let ty = "AvmContext";
     let inputs_expression = variable("inputs");
-    let path_snippet = ty.to_case(Case::Snake); // e.g. private_context
 
     // let mut context = {ty}::new(inputs, hash);
     let let_context = mutable_assignment(
         "context", // Assigned to
         call(
-            variable_path(chained_dep!("aztec", "context", &path_snippet, ty, "new")), // Path
-            vec![inputs_expression],                                                   // args
+            variable_path(chained_dep!(
+                "aztec",
+                "context",
+                "public_context",
+                "PublicContext",
+                "new"
+            )), // Path
+            vec![inputs_expression], // args
         ),
     );
     injected_expressions.push(let_context);
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index f183c69b27a..fdce8b81db2 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -76,19 +76,27 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
         // Identify the note type (struct name), its fields and its serialized length (generic param of NoteInterface trait impl)
         let note_type = note_struct.name.0.contents.to_string();
         let mut note_fields = vec![];
-        let note_serialized_len = match &trait_impl.trait_generics[0].typ {
-            UnresolvedTypeData::Named(path, _, _) => Ok(path.last_segment().0.contents.to_string()),
-            UnresolvedTypeData::Expression(UnresolvedTypeExpression::Constant(val, _)) => {
-                Ok(val.to_string())
-            }
-            _ => Err(AztecMacroError::CouldNotImplementNoteInterface {
-                span: trait_impl.object_type.span,
-                secondary_message: Some(format!(
-                    "Cannot find note serialization length for: {}",
-                    note_type
-                )),
-            }),
-        }?;
+        let note_interface_generics = trait_impl
+            .trait_generics
+            .iter()
+            .map(|gen| match gen.typ.clone() {
+                UnresolvedTypeData::Named(path, _, _) => {
+                    Ok(path.last_segment().0.contents.to_string())
+                }
+                UnresolvedTypeData::Expression(UnresolvedTypeExpression::Constant(val, _)) => {
+                    Ok(val.to_string())
+                }
+                _ => Err(AztecMacroError::CouldNotImplementNoteInterface {
+                    span: trait_impl.object_type.span,
+                    secondary_message: Some(format!(
+                        "NoteInterface must be generic over NOTE_LEN and NOTE_BYTES_LEN: {}",
+                        note_type
+                    )),
+                }),
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let [note_serialized_len, note_bytes_len]: [_; 2] =
+            note_interface_generics.try_into().unwrap();
         let note_type_id = note_type_id(&note_type);
 
         // Automatically inject the header field if it's not present
@@ -186,12 +194,73 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 generate_compute_note_content_hash(&note_type, note_interface_impl_span)?;
             trait_impl.items.push(TraitImplItem::Function(get_header_fn));
         }
+
+        if !check_trait_method_implemented(trait_impl, "to_be_bytes") {
+            let get_header_fn = generate_note_to_be_bytes(
+                &note_type,
+                note_bytes_len.as_str(),
+                note_serialized_len.as_str(),
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(get_header_fn));
+        }
     }
 
     module.types.extend(structs_to_inject);
     Ok(())
 }
 
+fn generate_note_to_be_bytes(
+    note_type: &String,
+    byte_length: &str,
+    serialized_length: &str,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn to_be_bytes(self: {1}, storage_slot: Field) -> [u8; {0}] {{
+            assert({0} == {2} * 32 + 64, \"Note byte length must be equal to (serialized_length * 32) + 64 bytes\");
+            let serialized_note = self.serialize_content();
+
+            let mut buffer: [u8; {0}] = [0; {0}];
+
+            let storage_slot_bytes = storage_slot.to_be_bytes(32);
+            let note_type_id_bytes = {1}::get_note_type_id().to_be_bytes(32);
+
+            for i in 0..32 {{
+                buffer[i] = storage_slot_bytes[i];
+                buffer[32 + i] = note_type_id_bytes[i];
+            }}
+
+            for i in 0..serialized_note.len() {{
+                let bytes = serialized_note[i].to_be_bytes(32);
+                for j in 0..32 {{
+                    buffer[64 + i * 32 + j] = bytes[j];
+                }}
+            }}
+            buffer
+        }}
+    ",
+        byte_length, note_type, serialized_length
+    )
+    .to_string();
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn to_be_bytes). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
 fn generate_note_get_header(
     note_type: &String,
     note_header_field_name: &String,
@@ -209,6 +278,7 @@ fn generate_note_get_header(
 
     let (function_ast, errors) = parse_program(&function_source);
     if !errors.is_empty() {
+        dbg!(errors);
         return Err(AztecMacroError::CouldNotImplementNoteInterface {
             secondary_message: Some("Failed to parse Noir macro code (fn get_header). This is either a bug in the compiler or the Noir macro code".to_string()),
             span: impl_span
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index 34aed3b34a4..7ce280c4c7f 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -325,7 +325,7 @@ pub fn get_serialized_length(
         .iter()
         .find_map(|&trait_id| {
             let r#trait = interner.get_trait(trait_id);
-            if r#trait.name.0.contents == trait_name && r#trait.generics.len() == 1 {
+            if r#trait.name.0.contents == trait_name {
                 interner.lookup_all_trait_implementations(typ, trait_id).into_iter().next()
             } else {
                 None
diff --git a/compiler/integration-tests/test/browser/recursion.test.ts b/compiler/integration-tests/test/browser/recursion.test.ts
index a8927aa6a75..abbee7b96ad 100644
--- a/compiler/integration-tests/test/browser/recursion.test.ts
+++ b/compiler/integration-tests/test/browser/recursion.test.ts
@@ -40,7 +40,8 @@ describe('It compiles noir program code, receiving circuit bytes and abi object.
     circuit_main_toml = await new Response(await getFile(`${base_relative_path}/${circuit_main}/Prover.toml`)).text();
   });
 
-  it('Should generate valid inner proof for correct input, then verify proof within a proof', async () => {
+  // TODO(https://github.com/noir-lang/noir/issues/5106): Reinstate this test.
+  it.skip('Should generate valid inner proof for correct input, then verify proof within a proof', async () => {
     const main_program = await getCircuit(`${base_relative_path}/${circuit_main}`);
     const main_inputs: InputMap = TOML.parse(circuit_main_toml) as InputMap;
 
diff --git a/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts b/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
index 6147f770f16..ca7f19309d6 100644
--- a/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
+++ b/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
@@ -11,7 +11,8 @@ import { Field, InputMap } from '@noir-lang/noirc_abi';
 
 import { compile, createFileManager } from '@noir-lang/noir_wasm';
 
-it(`smart contract can verify a recursive proof`, async () => {
+// TODO(https://github.com/AztecProtocol/aztec-packages/issues/6672): Reinstate this test.
+it.skip(`smart contract can verify a recursive proof`, async () => {
   const basePath = resolve(join(__dirname, '../../../../'));
   const fm = createFileManager(basePath);
   const innerCompilationResult = await compile(
diff --git a/noir_stdlib/src/aes128.nr b/noir_stdlib/src/aes128.nr
index cd61021a953..e6e2a5e4997 100644
--- a/noir_stdlib/src/aes128.nr
+++ b/noir_stdlib/src/aes128.nr
@@ -2,6 +2,3 @@
 // docs:start:aes128
 pub fn aes128_encrypt<N>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
 // docs:end:aes128
-
-#[foreign(aes128_encrypt)]
-pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
diff --git a/test_programs/execution_success/ecdsa_secp256r1_3x/Nargo.toml b/test_programs/execution_success/ecdsa_secp256r1_3x/Nargo.toml
new file mode 100644
index 00000000000..860b863a365
--- /dev/null
+++ b/test_programs/execution_success/ecdsa_secp256r1_3x/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "ecdsa_secp256r1_3x"
+description = "Three ECDSA secp256r1 verifications"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/ecdsa_secp256r1_3x/Prover.toml b/test_programs/execution_success/ecdsa_secp256r1_3x/Prover.toml
new file mode 100644
index 00000000000..e8edf26b2f3
--- /dev/null
+++ b/test_programs/execution_success/ecdsa_secp256r1_3x/Prover.toml
@@ -0,0 +1,57 @@
+hashed_message = [
+    84, 112, 91, 163, 186, 175, 219, 223, 186, 140, 95, 154, 112, 247, 168, 155, 238, 152,
+    217, 6, 181, 62, 49, 7, 77, 167, 186, 236, 220, 13, 169, 173,
+]
+pub_key_x = [
+    85, 15, 71, 16, 3, 243, 223, 151, 195, 223, 80, 106, 199, 151, 246, 114, 31, 177, 161,
+    251, 123, 143, 111, 131, 210, 36, 73, 138, 101, 200, 142, 36,
+]
+pub_key_y = [
+    19, 96, 147, 215, 1, 46, 80, 154, 115, 113, 92, 189, 11, 0, 163, 204, 15, 244, 181,
+    192, 27, 63, 250, 25, 106, 177, 251, 50, 112, 54, 184, 230,
+]
+signature = [
+    44,  112, 168, 208, 132, 182, 43,  252, 92,  224, 54, 65, 202, 249, 247, 42,
+    212, 218, 140, 129, 191, 230, 236, 148, 135, 187, 94, 27, 239, 98,  161, 50,
+    24,  173, 158, 226, 158, 175, 53,  31,  220, 80,  241, 82,  12,  66, 94, 155,
+    144, 138, 7,   39,  139, 67,  176, 236, 123, 135, 39,  120, 193, 78, 7,  132 
+]
+
+hashed_message_2 = [
+    84, 112, 91, 163, 186, 175, 219, 223, 186, 140, 95, 154, 112, 247, 168, 155, 238, 152,
+    217, 6, 181, 62, 49, 7, 77, 167, 186, 236, 220, 13, 169, 173,
+]
+pub_key_x_2 = [
+    85, 15, 71, 16, 3, 243, 223, 151, 195, 223, 80, 106, 199, 151, 246, 114, 31, 177, 161,
+    251, 123, 143, 111, 131, 210, 36, 73, 138, 101, 200, 142, 36,
+]
+pub_key_y_2 = [
+    19, 96, 147, 215, 1, 46, 80, 154, 115, 113, 92, 189, 11, 0, 163, 204, 15, 244, 181,
+    192, 27, 63, 250, 25, 106, 177, 251, 50, 112, 54, 184, 230,
+]
+signature_2 = [
+    44,  112, 168, 208, 132, 182, 43,  252, 92,  224, 54, 65, 202, 249, 247, 42,
+    212, 218, 140, 129, 191, 230, 236, 148, 135, 187, 94, 27, 239, 98,  161, 50,
+    24,  173, 158, 226, 158, 175, 53,  31,  220, 80,  241, 82,  12,  66, 94, 155,
+    144, 138, 7,   39,  139, 67,  176, 236, 123, 135, 39,  120, 193, 78, 7,  132 
+]
+
+
+hashed_message_3 = [
+    84, 112, 91, 163, 186, 175, 219, 223, 186, 140, 95, 154, 112, 247, 168, 155, 238, 152,
+    217, 6, 181, 62, 49, 7, 77, 167, 186, 236, 220, 13, 169, 173,
+]
+pub_key_x_3 = [
+    85, 15, 71, 16, 3, 243, 223, 151, 195, 223, 80, 106, 199, 151, 246, 114, 31, 177, 161,
+    251, 123, 143, 111, 131, 210, 36, 73, 138, 101, 200, 142, 36,
+]
+pub_key_y_3 = [
+    19, 96, 147, 215, 1, 46, 80, 154, 115, 113, 92, 189, 11, 0, 163, 204, 15, 244, 181,
+    192, 27, 63, 250, 25, 106, 177, 251, 50, 112, 54, 184, 230,
+]
+signature_3 = [
+    44,  112, 168, 208, 132, 182, 43,  252, 92,  224, 54, 65, 202, 249, 247, 42,
+    212, 218, 140, 129, 191, 230, 236, 148, 135, 187, 94, 27, 239, 98,  161, 50,
+    24,  173, 158, 226, 158, 175, 53,  31,  220, 80,  241, 82,  12,  66, 94, 155,
+    144, 138, 7,   39,  139, 67,  176, 236, 123, 135, 39,  120, 193, 78, 7,  132 
+]
\ No newline at end of file
diff --git a/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
new file mode 100644
index 00000000000..e7a6be9d47a
--- /dev/null
+++ b/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
@@ -0,0 +1,23 @@
+use dep::std;
+
+fn main(
+    hashed_message: [u8; 32],
+    pub_key_x: [u8; 32],
+    pub_key_y: [u8; 32],
+    signature: [u8; 64],
+    hashed_message_2: [u8; 32],
+    pub_key_x_2: [u8; 32],
+    pub_key_y_2: [u8; 32],
+    signature_2: [u8; 64],
+    hashed_message_3: [u8; 32],
+    pub_key_x_3: [u8; 32],
+    pub_key_y_3: [u8; 32],
+    signature_3: [u8; 64]
+) {
+    let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+    assert(valid_signature);
+    let valid_signature_2 = std::ecdsa_secp256r1::verify_signature(pub_key_x_2, pub_key_y_2, signature_2, hashed_message_2);
+    assert(valid_signature_2);
+    let valid_signature_3 = std::ecdsa_secp256r1::verify_signature(pub_key_x_3, pub_key_y_3, signature_3, hashed_message_3);
+    assert(valid_signature_3);
+}
diff --git a/tooling/noir_js/src/witness_generation.ts b/tooling/noir_js/src/witness_generation.ts
index 7d018c81d53..c84cb2e83b3 100644
--- a/tooling/noir_js/src/witness_generation.ts
+++ b/tooling/noir_js/src/witness_generation.ts
@@ -1,25 +1,8 @@
 import { abiDecodeError, abiEncode, InputMap } from '@noir-lang/noirc_abi';
 import { base64Decode } from './base64_decode.js';
-import {
-  WitnessStack,
-  ForeignCallHandler,
-  ForeignCallInput,
-  createBlackBoxSolver,
-  WasmBlackBoxFunctionSolver,
-  executeProgramWithBlackBoxSolver,
-  ExecutionError,
-} from '@noir-lang/acvm_js';
+import { WitnessStack, ForeignCallHandler, ForeignCallInput, ExecutionError, executeProgram } from '@noir-lang/acvm_js';
 import { Abi, CompiledCircuit } from '@noir-lang/types';
 
-let solver: Promise<WasmBlackBoxFunctionSolver>;
-
-const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
-  if (!solver) {
-    solver = createBlackBoxSolver();
-  }
-  return solver;
-};
-
 const defaultForeignCallHandler: ForeignCallHandler = async (name: string, args: ForeignCallInput[]) => {
   if (name == 'print') {
     // By default we do not print anything for `print` foreign calls due to a need for formatting,
@@ -70,12 +53,7 @@ export async function generateWitness(
   // Execute the circuit to generate the rest of the witnesses and serialize
   // them into a Uint8Array.
   try {
-    const solvedWitness = await executeProgramWithBlackBoxSolver(
-      await getSolver(),
-      base64Decode(compiledProgram.bytecode),
-      witnessMap,
-      foreignCallHandler,
-    );
+    const solvedWitness = await executeProgram(base64Decode(compiledProgram.bytecode), witnessMap, foreignCallHandler);
     return solvedWitness;
   } catch (err) {
     // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.

From a2894047f580a8861898d71cd335c06ee53290a4 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 17:19:00 +0100
Subject: [PATCH 306/416] chore: deduplicate `ReturnConstant` warning (#5109)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR inlines `flatten_value_list` into `define_result_var` and
deduplicates any `InternalWarning::ReturnConstant` warnings

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 75 ++++++++-----------
 1 file changed, 31 insertions(+), 44 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index e9b2d5f46df..13677506d0b 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1732,29 +1732,44 @@ impl<'a> Context<'a> {
     ) -> Result<Vec<SsaReport>, RuntimeError> {
         let (return_values, call_stack) = match terminator {
             TerminatorInstruction::Return { return_values, call_stack } => {
-                (return_values, call_stack)
+                (return_values, call_stack.clone())
             }
             // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions
             _ => unreachable!("ICE: Program must have a singular return"),
         };
 
-        // The return value may or may not be an array reference. Calling `flatten_value_list`
-        // will expand the array if there is one.
-        let return_acir_vars = self.flatten_value_list(return_values, dfg)?;
-        let mut warnings = Vec::new();
-        for (acir_var, is_databus) in return_acir_vars {
-            if self.acir_context.is_constant(&acir_var) {
-                warnings.push(SsaReport::Warning(InternalWarning::ReturnConstant {
-                    call_stack: call_stack.clone(),
-                }));
-            }
-            if !is_databus {
-                // We do not return value for the data bus.
-                self.acir_context.return_var(acir_var)?;
-            } else {
-                self.check_array_is_initialized(self.data_bus.return_data.unwrap(), dfg)?;
+        let mut has_constant_return = false;
+        for value_id in return_values {
+            let is_databus = self
+                .data_bus
+                .return_data
+                .map_or(false, |return_databus| dfg[*value_id] == dfg[return_databus]);
+            let value = self.convert_value(*value_id, dfg);
+
+            // `value` may or may not be an array reference. Calling `flatten` will expand the array if there is one.
+            let acir_vars = self.acir_context.flatten(value)?;
+            for (acir_var, _) in acir_vars {
+                has_constant_return |= self.acir_context.is_constant(&acir_var);
+                if is_databus {
+                    // We do not return value for the data bus.
+                    self.check_array_is_initialized(
+                        self.data_bus.return_data.expect(
+                            "`is_databus == true` implies `data_bus.return_data` is `Some`",
+                        ),
+                        dfg,
+                    )?;
+                } else {
+                    self.acir_context.return_var(acir_var)?;
+                }
             }
         }
+
+        let warnings = if has_constant_return {
+            vec![SsaReport::Warning(InternalWarning::ReturnConstant { call_stack })]
+        } else {
+            Vec::new()
+        };
+
         Ok(warnings)
     }
 
@@ -2679,34 +2694,6 @@ impl<'a> Context<'a> {
         }
     }
 
-    /// Maps an ssa value list, for which some values may be references to arrays, by inlining
-    /// the `AcirVar`s corresponding to the contents of each array into the list of `AcirVar`s
-    /// that correspond to other values.
-    fn flatten_value_list(
-        &mut self,
-        arguments: &[ValueId],
-        dfg: &DataFlowGraph,
-    ) -> Result<Vec<(AcirVar, bool)>, InternalError> {
-        let mut acir_vars = Vec::with_capacity(arguments.len());
-        for value_id in arguments {
-            let is_databus = if let Some(return_databus) = self.data_bus.return_data {
-                dfg[*value_id] == dfg[return_databus]
-            } else {
-                false
-            };
-            let value = self.convert_value(*value_id, dfg);
-            acir_vars.append(
-                &mut self
-                    .acir_context
-                    .flatten(value)?
-                    .iter()
-                    .map(|(var, _)| (*var, is_databus))
-                    .collect(),
-            );
-        }
-        Ok(acir_vars)
-    }
-
     /// Convert a Vec<AcirVar> into a Vec<AcirValue> using the given result ids.
     /// If the type of a result id is an array, several acir vars are collected into
     /// a single AcirValue::Array of the same length.

From 06dd2f25a28201e0095a3647cf420337d8465236 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 18:16:07 +0100
Subject: [PATCH 307/416] chore: move `is_native_field` up into
 `noirc_frontend` (#5119)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This struct is only used for a single check up in `noirc_frontend` so we
should move this logic closer to where it's used.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |  4 ++-
 acvm-repo/acir_field/Cargo.toml               |  1 -
 acvm-repo/acir_field/src/lib.rs               | 32 -------------------
 compiler/noirc_frontend/Cargo.toml            |  6 ++++
 .../src/hir/def_collector/dc_mod.rs           | 29 +++++++++++++++--
 compiler/wasm/Cargo.toml                      |  2 +-
 tooling/nargo_cli/Cargo.toml                  |  2 +-
 tooling/noirc_abi/Cargo.toml                  | 10 ++++++
 tooling/noirc_abi_wasm/Cargo.toml             |  2 +-
 9 files changed, 49 insertions(+), 39 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f1ea5929d32..4b140a513f2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -34,7 +34,6 @@ dependencies = [
  "cfg-if 1.0.0",
  "hex",
  "num-bigint",
- "num-traits",
  "serde",
 ]
 
@@ -2821,6 +2820,7 @@ version = "0.30.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
+ "cfg-if 1.0.0",
  "chumsky",
  "fm",
  "im",
@@ -2830,6 +2830,8 @@ dependencies = [
  "noirc_arena",
  "noirc_errors",
  "noirc_printable_type",
+ "num-bigint",
+ "num-traits",
  "petgraph",
  "regex",
  "rustc-hash",
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 8d8a1e9e2bd..f182c6c4aba 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -16,7 +16,6 @@ repository.workspace = true
 hex.workspace = true
 num-bigint.workspace = true
 serde.workspace = true
-num-traits.workspace = true
 
 ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
 ark-bls12-381 = { version = "^0.4.0", optional = true, default-features = false, features = ["curve"] }
diff --git a/acvm-repo/acir_field/src/lib.rs b/acvm-repo/acir_field/src/lib.rs
index 7f06330ed8d..9b8919e4bcb 100644
--- a/acvm-repo/acir_field/src/lib.rs
+++ b/acvm-repo/acir_field/src/lib.rs
@@ -2,9 +2,6 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
-
-use num_bigint::BigUint;
-use num_traits::Num;
 mod generic_ark;
 
 pub use generic_ark::AcirField;
@@ -15,40 +12,11 @@ pub use generic_ark::FieldElement as GenericFieldElement;
 cfg_if::cfg_if! {
     if #[cfg(feature = "bls12_381")] {
         pub type FieldElement = generic_ark::FieldElement<ark_bls12_381::Fr>;
-        pub const CHOSEN_FIELD : FieldOptions = FieldOptions::BLS12_381;
     } else {
         pub type FieldElement = generic_ark::FieldElement<ark_bn254::Fr>;
-        pub const CHOSEN_FIELD : FieldOptions = FieldOptions::BN254;
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
-pub enum FieldOptions {
-    BN254,
-    BLS12_381,
-}
-
-impl FieldOptions {
-    pub fn to_string(&self) -> &str {
-        match self {
-            FieldOptions::BN254 => "bn254",
-            FieldOptions::BLS12_381 => "bls12_381",
-        }
-    }
-
-    pub fn is_native_field(str: &str) -> bool {
-        let big_num = if let Some(hex) = str.strip_prefix("0x") {
-            BigUint::from_str_radix(hex, 16)
-        } else {
-            BigUint::from_str_radix(str, 10)
-        };
-        if let Ok(big_num) = big_num {
-            big_num == FieldElement::modulus()
-        } else {
-            CHOSEN_FIELD.to_string() == str
-        }
-    }
-}
 // This is needed because features are additive through the dependency graph; if a dependency turns on the bn254, then it
 // will be turned on in all crates that depend on it
 #[macro_export]
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index 0430d214d53..381eb4a9bb9 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -21,13 +21,17 @@ smol_str.workspace = true
 im.workspace = true
 serde_json.workspace = true
 serde.workspace = true
+num-bigint.workspace = true
+num-traits.workspace = true
 rustc-hash = "1.1.0"
 small-ord-set = "0.1.3"
 regex = "1.9.1"
+cfg-if = "1.0.0"
 tracing.workspace = true
 petgraph = "0.6"
 lalrpop-util = { version = "0.20.2", features = ["lexer"] }
 
+
 [dev-dependencies]
 base64.workspace = true
 strum = "0.24"
@@ -39,3 +43,5 @@ lalrpop = "0.20.2"
 
 [features]
 experimental_parser = []
+bn254 = []
+bls12_381 = []
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 3d0ffdb0155..56a0387cf8d 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -1,8 +1,10 @@
 use std::{collections::HashMap, path::Path, vec};
 
-use acvm::acir::acir_field::FieldOptions;
+use acvm::{AcirField, FieldElement};
 use fm::{FileId, FileManager, FILE_EXTENSION};
 use noirc_errors::Location;
+use num_bigint::BigUint;
+use num_traits::Num;
 
 use crate::ast::{
     FunctionDefinition, Ident, ItemVisibility, LetStatement, ModuleDeclaration, NoirFunction,
@@ -233,7 +235,7 @@ impl<'a> ModCollector<'a> {
         for function in functions {
             // check if optional field attribute is compatible with native field
             if let Some(field) = function.attributes().get_field_attribute() {
-                if !FieldOptions::is_native_field(&field) {
+                if !is_native_field(&field) {
                     continue;
                 }
             }
@@ -721,6 +723,29 @@ fn should_check_siblings_for_module(module_path: &Path, parent_path: &Path) -> b
     }
 }
 
+cfg_if::cfg_if! {
+    if #[cfg(feature = "bn254")] {
+        pub const CHOSEN_FIELD: &str = "bn254";
+    } else if #[cfg(feature = "bls12_381")] {
+        pub const CHOSEN_FIELD: &str = "bls12_381";
+    } else {
+        compile_error!("please specify a field to compile with");
+    }
+}
+
+fn is_native_field(str: &str) -> bool {
+    let big_num = if let Some(hex) = str.strip_prefix("0x") {
+        BigUint::from_str_radix(hex, 16)
+    } else {
+        BigUint::from_str_radix(str, 10)
+    };
+    if let Ok(big_num) = big_num {
+        big_num == FieldElement::modulus()
+    } else {
+        CHOSEN_FIELD == str
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/compiler/wasm/Cargo.toml b/compiler/wasm/Cargo.toml
index 23686cc4ea1..03e59b3e269 100644
--- a/compiler/wasm/Cargo.toml
+++ b/compiler/wasm/Cargo.toml
@@ -17,7 +17,7 @@ acvm = { workspace = true, features = ["bn254"] }
 fm.workspace = true
 nargo.workspace = true
 noirc_driver.workspace = true
-noirc_frontend.workspace = true
+noirc_frontend = { workspace = true, features = ["bn254"] }
 noirc_errors.workspace = true
 noirc_evaluator.workspace = true
 wasm-bindgen.workspace = true
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index 9e886bc7002..a9946c8700c 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -29,7 +29,7 @@ nargo_toml.workspace = true
 noir_lsp.workspace = true
 noir_debugger.workspace = true
 noirc_driver.workspace = true
-noirc_frontend.workspace = true
+noirc_frontend = { workspace = true, features = ["bn254"] }
 noirc_abi.workspace = true
 noirc_errors.workspace = true
 acvm = { workspace = true, features = ["bn254"] }
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index 040f8a0dc79..baae2dfa35e 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -23,3 +23,13 @@ num-traits = "0.2"
 [dev-dependencies]
 strum = "0.24"
 strum_macros = "0.24"
+
+[features]
+bn254 = [
+    "acvm/bn254",
+    "noirc_frontend/bn254",
+]
+bls12_381 = [
+    "acvm/bls12_381",
+    "noirc_frontend/bls12_381",
+]
\ No newline at end of file
diff --git a/tooling/noirc_abi_wasm/Cargo.toml b/tooling/noirc_abi_wasm/Cargo.toml
index 5692c757d3e..daa619ca01d 100644
--- a/tooling/noirc_abi_wasm/Cargo.toml
+++ b/tooling/noirc_abi_wasm/Cargo.toml
@@ -13,7 +13,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 acvm = { workspace = true, features = ["bn254"] }
-noirc_abi.workspace = true
+noirc_abi = { workspace = true, features = ["bn254"] }
 iter-extended.workspace = true
 wasm-bindgen.workspace = true
 serde.workspace = true

From ffcb410978a362c73783fbfe5bbdc9691499609e Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 28 May 2024 12:23:34 -0500
Subject: [PATCH 308/416] fix(experimental elaborator): Fix panic in the
 elaborator (#5082)

# Description

## Problem\*

Working towards #4594

## Summary\*

When run on a program the elaborator would always panic previously due
to `FuncMeta`s not yet being set for other functions while one function
was being elaborated. This is because we used to set them during name
resolution and only check them during type checking, but now that these
two passes are merged we'll need to set them all before elaboration
instead.

This PR creates a new `define_function_metas` function to create the
`FuncMeta`s beforehand. I imagine there are more changes required here
related to scoping / generics / parameters but this at least stops the
panic.

## Additional Context

This is the first of the elaborator PRs to feature only new changes
rather than largely copied code, so feel free to critique as usual if
you think a different approach would be better, notice an issue, etc.

After this PR the elaborator will run on a small example program, only
producing 1052 errors in the standard library :slightly_smiling_face:.
Most of these errors appear to be variants of "no method named '...'
found for ..." and "no matching impl found for ..."

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .../src/elaborator/expressions.rs             |  12 +-
 compiler/noirc_frontend/src/elaborator/mod.rs | 168 ++++++++++++------
 .../noirc_frontend/src/elaborator/scope.rs    |   4 +-
 .../noirc_frontend/src/elaborator/traits.rs   |  18 +-
 .../noirc_frontend/src/elaborator/types.rs    |  16 +-
 .../src/hir/def_collector/dc_crate.rs         |  13 +-
 .../src/hir/def_collector/dc_mod.rs           |   7 +-
 compiler/noirc_frontend/src/node_interner.rs  |  21 +--
 .../noirc_frontend/src/resolve_locations.rs   |   4 +-
 9 files changed, 161 insertions(+), 102 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index f1631286336..2ad1598c6a2 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -15,9 +15,9 @@ use crate::{
     hir_def::{
         expr::{
             HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
-            HirConstructorExpression, HirIdent, HirIfExpression, HirIndexExpression,
-            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
-            HirMethodReference, HirPrefixExpression,
+            HirConstructorExpression, HirIfExpression, HirIndexExpression, HirInfixExpression,
+            HirLambda, HirMemberAccess, HirMethodCallExpression, HirMethodReference,
+            HirPrefixExpression,
         },
         traits::TraitConstraint,
     },
@@ -84,10 +84,10 @@ impl<'context> Elaborator<'context> {
                     expr_type: inner_expr_type.clone(),
                     expr_span: span,
                 });
+            }
 
-                if i + 1 == statements.len() {
-                    block_type = stmt_type;
-                }
+            if i + 1 == statements.len() {
+                block_type = stmt_type;
             }
         }
 
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 121a4d89ef0..c537531a748 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1,19 +1,15 @@
-#![allow(unused)]
 use std::{
     collections::{BTreeMap, BTreeSet},
     rc::Rc,
 };
 
 use crate::{
-    ast::{
-        ArrayLiteral, ConstructorExpression, FunctionKind, IfExpression, InfixExpression, Lambda,
-        UnresolvedTraitConstraint, UnresolvedTypeExpression,
-    },
+    ast::{FunctionKind, UnresolvedTraitConstraint},
     hir::{
         def_collector::{
             dc_crate::{
-                filter_literal_globals, CompilationError, UnresolvedGlobal, UnresolvedStruct,
-                UnresolvedTrait, UnresolvedTypeAlias,
+                filter_literal_globals, CompilationError, ImplMap, UnresolvedGlobal,
+                UnresolvedStruct, UnresolvedTypeAlias,
             },
             errors::DuplicateType,
         },
@@ -21,38 +17,21 @@ use crate::{
         scope::ScopeForest as GenericScopeForest,
         type_check::TypeCheckError,
     },
-    hir_def::{
-        expr::{
-            HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
-            HirConstructorExpression, HirIdent, HirIfExpression, HirIndexExpression,
-            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
-            HirMethodReference, HirPrefixExpression,
-        },
-        stmt::HirLetStatement,
-        traits::TraitConstraint,
-    },
+    hir_def::{expr::HirIdent, function::Parameters, traits::TraitConstraint},
     macros_api::{
-        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirExpression,
-        HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
-        MethodCallExpression, NodeInterner, NoirFunction, NoirStruct, Pattern, PrefixExpression,
-        SecondaryAttribute, Statement, StatementKind, StructId,
+        Ident, NodeInterner, NoirFunction, NoirStruct, Pattern, SecondaryAttribute, StructId,
     },
-    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, StmtId, TraitId, TypeAliasId},
-    Shared, StructType, Type, TypeVariable,
+    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, TraitId, TypeAliasId},
+    Shared, Type, TypeVariable,
 };
 use crate::{
     ast::{TraitBound, UnresolvedGenerics},
     graph::CrateId,
     hir::{
-        def_collector::{
-            dc_crate::{CollectedItems, DefCollector},
-            errors::DefCollectorErrorKind,
-        },
+        def_collector::{dc_crate::CollectedItems, errors::DefCollectorErrorKind},
         def_map::{LocalModuleId, ModuleDefId, ModuleId, MAIN_FUNCTION},
         resolution::{
-            errors::PubPosition,
-            import::{PathResolution, PathResolutionError},
-            path_resolver::StandardPathResolver,
+            errors::PubPosition, import::PathResolution, path_resolver::StandardPathResolver,
         },
         Context,
     },
@@ -81,7 +60,6 @@ mod types;
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
-use regex::Regex;
 use rustc_hash::FxHashSet as HashSet;
 
 /// ResolverMetas are tagged onto each definition to track how many times they are used
@@ -226,6 +204,8 @@ impl<'context> Elaborator<'context> {
             this.define_type_alias(alias_id, alias);
         }
 
+        this.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
+
         this.collect_traits(items.traits);
 
         // Must resolve structs before we resolve globals.
@@ -268,7 +248,6 @@ impl<'context> Elaborator<'context> {
 
         let cycle_errors = this.interner.check_for_dependency_cycles();
         this.errors.extend(cycle_errors);
-
         this.errors
     }
 
@@ -285,7 +264,6 @@ impl<'context> Elaborator<'context> {
 
     fn elaborate_function(&mut self, mut function: NoirFunction, id: FuncId) {
         self.current_function = Some(id);
-        self.resolve_where_clause(&mut function.def.where_clause);
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
         if self.self_type.is_some() {
@@ -297,9 +275,6 @@ impl<'context> Elaborator<'context> {
 
         // Check whether the function has globals in the local module and add them to the scope
         self.resolve_local_globals();
-        self.add_generics(&function.def.generics);
-
-        self.desugar_impl_trait_args(&mut function, id);
         self.trait_bounds = function.def.where_clause.clone();
 
         let is_low_level_or_oracle = function
@@ -312,8 +287,19 @@ impl<'context> Elaborator<'context> {
             self.in_unconstrained_fn = true;
         }
 
-        let func_meta = self.extract_meta(&function, id);
+        let func_meta = self.interner.func_meta.get(&id);
+        let func_meta = func_meta
+            .expect("FuncMetas should be declared before a function is elaborated")
+            .clone();
 
+        for (parameter, param2) in function.def.parameters.iter().zip(&func_meta.parameters.0) {
+            let definition_kind = DefinitionKind::Local(None);
+            self.elaborate_pattern(parameter.pattern.clone(), param2.1.clone(), definition_kind);
+        }
+
+        self.add_generics(&function.def.generics);
+        self.desugar_impl_trait_args(&mut function, id);
+        self.declare_numeric_generics(&func_meta.parameters, func_meta.return_type());
         self.add_trait_constraints_to_scope(&func_meta);
 
         let (hir_func, body_type) = match function.kind {
@@ -376,7 +362,6 @@ impl<'context> Elaborator<'context> {
 
         self.trait_bounds.clear();
 
-        self.interner.push_fn_meta(func_meta, id);
         self.interner.update_fn(id, hir_func);
         self.current_function = None;
     }
@@ -538,9 +523,23 @@ impl<'context> Elaborator<'context> {
 
     /// Extract metadata from a NoirFunction
     /// to be used in analysis and intern the function parameters
-    /// Prerequisite: self.add_generics() has already been called with the given
-    /// function's generics, including any generics from the impl, if any.
-    fn extract_meta(&mut self, func: &NoirFunction, func_id: FuncId) -> FuncMeta {
+    /// Prerequisite: any implicit generics, including any generics from the impl,
+    /// have already been added to scope via `self.add_generics`.
+    fn define_function_meta(&mut self, func: &mut NoirFunction, func_id: FuncId) {
+        self.current_function = Some(func_id);
+        self.resolve_where_clause(&mut func.def.where_clause);
+
+        // Without this, impl methods can accidentally be placed in contracts. See #3254
+        if self.self_type.is_some() {
+            self.in_contract = false;
+        }
+
+        self.scopes.start_function();
+        self.current_item = Some(DependencyId::Function(func_id));
+
+        // Check whether the function has globals in the local module and add them to the scope
+        self.resolve_local_globals();
+
         let location = Location::new(func.name_ident().span(), self.file);
         let id = self.interner.function_definition_id(func_id);
         let name_ident = HirIdent::non_trait_method(id, location);
@@ -565,6 +564,8 @@ impl<'context> Elaborator<'context> {
         let has_inline_attribute = has_no_predicates_attribute || should_fold;
         let is_entry_point = self.is_entry_point_function(func);
 
+        self.add_generics(&func.def.generics);
+
         let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
         let mut parameters = vec![];
         let mut parameter_types = vec![];
@@ -593,8 +594,6 @@ impl<'context> Elaborator<'context> {
 
         let return_type = Box::new(self.resolve_type(func.return_type()));
 
-        self.declare_numeric_generics(&parameter_types, &return_type);
-
         if !self.pub_allowed(func) && func.def.return_visibility == Visibility::Public {
             self.push_err(ResolverError::UnnecessaryPub {
                 ident: func.name_ident().clone(),
@@ -647,7 +646,7 @@ impl<'context> Elaborator<'context> {
             .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
             .collect();
 
-        FuncMeta {
+        let meta = FuncMeta {
             name: name_ident,
             kind: func.kind,
             location,
@@ -661,7 +660,12 @@ impl<'context> Elaborator<'context> {
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point,
             has_inline_attribute,
-        }
+        };
+
+        self.interner.push_fn_meta(meta, func_id);
+        self.current_function = None;
+        self.scopes.end_function();
+        self.current_item = None;
     }
 
     /// Only sized types are valid to be used as main's parameters or the parameters to a contract
@@ -701,7 +705,7 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn declare_numeric_generics(&mut self, params: &[Type], return_type: &Type) {
+    fn declare_numeric_generics(&mut self, params: &Parameters, return_type: &Type) {
         if self.generics.is_empty() {
             return;
         }
@@ -724,11 +728,11 @@ impl<'context> Elaborator<'context> {
     }
 
     fn find_numeric_generics(
-        parameters: &[Type],
+        parameters: &Parameters,
         return_type: &Type,
     ) -> Vec<(String, TypeVariable)> {
         let mut found = BTreeMap::new();
-        for parameter in parameters {
+        for (_, parameter, _) in &parameters.0 {
             Self::find_numeric_generics_in_type(parameter, &mut found);
         }
         Self::find_numeric_generics_in_type(return_type, &mut found);
@@ -842,10 +846,11 @@ impl<'context> Elaborator<'context> {
         module: LocalModuleId,
         impls: Vec<(Vec<Ident>, Span, UnresolvedFunctions)>,
     ) {
-        self.generics.clear();
+        self.local_module = module;
 
         for (generics, _, functions) in impls {
             self.file = functions.file_id;
+            let old_generics_length = self.generics.len();
             self.add_generics(&generics);
             let self_type = self.resolve_type(typ.clone());
             self.self_type = Some(self_type.clone());
@@ -869,6 +874,8 @@ impl<'context> Elaborator<'context> {
                     }
                 }
             }
+
+            self.generics.truncate(old_generics_length);
         }
     }
 
@@ -878,18 +885,20 @@ impl<'context> Elaborator<'context> {
 
         let unresolved_type = trait_impl.object_type;
         let self_type_span = unresolved_type.span;
+        let old_generics_length = self.generics.len();
         self.add_generics(&trait_impl.generics);
 
         let trait_generics =
             vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
 
-        let self_type = self.resolve_type(unresolved_type.clone());
-        let impl_id = self.interner.next_trait_impl_id();
+        let self_type = trait_impl.resolved_object_type.unwrap_or(Type::Error);
+        let impl_id =
+            trait_impl.impl_id.expect("An impls' id should be set during define_function_metas");
 
         self.self_type = Some(self_type.clone());
-        self.current_trait_impl = Some(impl_id);
+        self.current_trait_impl = trait_impl.impl_id;
 
-        let mut methods = trait_impl.methods.function_ids();
+        let methods = trait_impl.methods.function_ids();
 
         self.elaborate_functions(trait_impl.methods);
 
@@ -944,7 +953,7 @@ impl<'context> Elaborator<'context> {
 
         self.self_type = None;
         self.current_trait_impl = None;
-        self.generics.clear();
+        self.generics.truncate(old_generics_length);
     }
 
     fn collect_impls(
@@ -1236,4 +1245,55 @@ impl<'context> Elaborator<'context> {
         self.interner.get_global_definition_mut(global_id).kind = definition_kind;
         self.interner.replace_statement(statement_id, let_statement);
     }
+
+    fn define_function_metas(
+        &mut self,
+        functions: &mut [UnresolvedFunctions],
+        impls: &mut ImplMap,
+        trait_impls: &mut [UnresolvedTraitImpl],
+    ) {
+        for function_set in functions {
+            self.define_function_metas_for_functions(function_set);
+        }
+
+        for ((_typ, local_module), function_sets) in impls {
+            self.local_module = *local_module;
+
+            for (_generics, _, function_set) in function_sets {
+                self.define_function_metas_for_functions(function_set);
+            }
+        }
+
+        for trait_impl in trait_impls {
+            self.file = trait_impl.file_id;
+            self.local_module = trait_impl.module_id;
+
+            let unresolved_type = &trait_impl.object_type;
+            let old_generics_length = self.generics.len();
+            self.add_generics(&trait_impl.generics);
+
+            let self_type = self.resolve_type(unresolved_type.clone());
+            self.self_type = Some(self_type.clone());
+
+            let impl_id = self.interner.next_trait_impl_id();
+            self.current_trait_impl = Some(impl_id);
+
+            self.define_function_metas_for_functions(&mut trait_impl.methods);
+
+            trait_impl.resolved_object_type = self.self_type.take();
+            trait_impl.impl_id = self.current_trait_impl.take();
+            self.generics.truncate(old_generics_length);
+        }
+    }
+
+    fn define_function_metas_for_functions(&mut self, function_set: &mut UnresolvedFunctions) {
+        self.file = function_set.file_id;
+
+        for (local_module, id, func) in &mut function_set.functions {
+            self.local_module = *local_module;
+            let old_generics_length = self.generics.len();
+            self.define_function_meta(func, *id);
+            self.generics.truncate(old_generics_length);
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/scope.rs b/compiler/noirc_frontend/src/elaborator/scope.rs
index cf10dbbc2b2..6ae43bd3c49 100644
--- a/compiler/noirc_frontend/src/elaborator/scope.rs
+++ b/compiler/noirc_frontend/src/elaborator/scope.rs
@@ -1,8 +1,6 @@
 use noirc_errors::Spanned;
-use rustc_hash::FxHashMap as HashMap;
 
 use crate::ast::ERROR_IDENT;
-use crate::hir::comptime::Value;
 use crate::hir::def_map::{LocalModuleId, ModuleId};
 use crate::hir::resolution::path_resolver::{PathResolver, StandardPathResolver};
 use crate::hir::resolution::resolver::SELF_TYPE_NAME;
@@ -18,7 +16,7 @@ use crate::{
         traits::Trait,
     },
     macros_api::{Path, StructId},
-    node_interner::{DefinitionId, TraitId, TypeAliasId},
+    node_interner::{DefinitionId, TraitId},
     Shared, StructType,
 };
 use crate::{Type, TypeAlias};
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index e7018d900d8..c2f9a83e559 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -5,14 +5,8 @@ use noirc_errors::Location;
 
 use crate::{
     ast::{FunctionKind, TraitItem, UnresolvedGenerics, UnresolvedTraitConstraint},
-    hir::{
-        def_collector::dc_crate::UnresolvedTrait, def_map::ModuleId,
-        resolution::path_resolver::StandardPathResolver,
-    },
-    hir_def::{
-        function::{FuncMeta, HirFunction},
-        traits::{TraitConstant, TraitFunction, TraitType},
-    },
+    hir::def_collector::dc_crate::UnresolvedTrait,
+    hir_def::traits::{TraitConstant, TraitFunction, TraitType},
     macros_api::{
         BlockExpression, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility,
         NoirFunction, Param, Pattern, UnresolvedType, Visibility,
@@ -26,10 +20,6 @@ use super::Elaborator;
 
 impl<'context> Elaborator<'context> {
     pub fn collect_traits(&mut self, traits: BTreeMap<TraitId, UnresolvedTrait>) {
-        for (trait_id, unresolved_trait) in &traits {
-            self.interner.push_empty_trait(*trait_id, unresolved_trait);
-        }
-
         for (trait_id, unresolved_trait) in traits {
             let generics = vecmap(&unresolved_trait.trait_def.generics, |_| {
                 TypeVariable::unbound(self.interner.next_type_variable_id())
@@ -187,7 +177,9 @@ impl<'context> Elaborator<'context> {
             return_visibility: Visibility::Private,
         };
 
-        self.elaborate_function(NoirFunction { kind, def }, func_id);
+        let mut function = NoirFunction { kind, def };
+        self.define_function_meta(&mut function, func_id);
+        self.elaborate_function(function, func_id);
         let _ = self.scopes.end_function();
         // Don't check the scope tree for unused variables, they can't be used in a declaration anyway.
         self.trait_bounds.clear();
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 4c2b58580cf..059ff857df8 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -1,19 +1,18 @@
 use std::rc::Rc;
 
-use acvm::{acir::AcirField, FieldElement};
+use acvm::acir::AcirField;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
 use crate::{
     ast::{
-        BinaryOpKind, IntegerBitSize, NoirTypeAlias, UnresolvedGenerics, UnresolvedTraitConstraint,
+        BinaryOpKind, IntegerBitSize, UnresolvedGenerics, UnresolvedTraitConstraint,
         UnresolvedTypeExpression,
     },
     hir::{
         def_map::ModuleDefId,
         resolution::{
             errors::ResolverError,
-            import::PathResolution,
             resolver::{verify_mutable_reference, SELF_TYPE_NAME},
         },
         type_check::{Source, TypeCheckError},
@@ -24,17 +23,14 @@ use crate::{
             HirPrefixExpression,
         },
         function::FuncMeta,
-        traits::{Trait, TraitConstraint},
+        traits::TraitConstraint,
     },
     macros_api::{
         HirExpression, HirLiteral, HirStatement, Path, PathKind, SecondaryAttribute, Signedness,
         UnaryOp, UnresolvedType, UnresolvedTypeData,
     },
-    node_interner::{
-        DefinitionKind, DependencyId, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId,
-        TypeAliasId,
-    },
-    Generics, Shared, StructType, Type, TypeAlias, TypeBinding, TypeVariable, TypeVariableKind,
+    node_interner::{DefinitionKind, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId},
+    Generics, Type, TypeBinding, TypeVariable, TypeVariableKind,
 };
 
 use super::Elaborator;
@@ -636,7 +632,7 @@ impl<'context> Elaborator<'context> {
         rhs_type: &Type,
         span: Span,
     ) -> Type {
-        let mut unify = |this: &mut Self, expected| {
+        let unify = |this: &mut Self, expected| {
             this.unify(rhs_type, &expected, || TypeCheckError::TypeMismatch {
                 expr_typ: rhs_type.to_string(),
                 expected_typ: expected.to_string(),
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index afec3839599..60b841699f1 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -5,6 +5,7 @@ use crate::graph::CrateId;
 use crate::hir::comptime::{Interpreter, InterpreterError};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
+use crate::Type;
 
 use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
 use crate::hir::resolution::{
@@ -18,7 +19,9 @@ use crate::hir::type_check::{
 use crate::hir::Context;
 
 use crate::macros_api::{MacroError, MacroProcessor};
-use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId, TraitId, TypeAliasId};
+use crate::node_interner::{
+    FuncId, GlobalId, NodeInterner, StructId, TraitId, TraitImplId, TypeAliasId,
+};
 
 use crate::ast::{
     ExpressionKind, Ident, LetStatement, Literal, NoirFunction, NoirStruct, NoirTrait,
@@ -107,13 +110,17 @@ pub struct UnresolvedTrait {
 pub struct UnresolvedTraitImpl {
     pub file_id: FileId,
     pub module_id: LocalModuleId,
-    pub trait_id: Option<TraitId>,
     pub trait_generics: Vec<UnresolvedType>,
     pub trait_path: Path,
     pub object_type: UnresolvedType,
     pub methods: UnresolvedFunctions,
     pub generics: UnresolvedGenerics,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
+
+    // These fields are filled in later during elaboration
+    pub trait_id: Option<TraitId>,
+    pub impl_id: Option<TraitImplId>,
+    pub resolved_object_type: Option<Type>,
 }
 
 #[derive(Clone)]
@@ -337,7 +344,7 @@ impl DefCollector {
 
         if use_elaborator {
             let mut more_errors = Elaborator::elaborate(context, crate_id, def_collector.items);
-            more_errors.append(&mut errors);
+            errors.append(&mut more_errors);
             return errors;
         }
 
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 56a0387cf8d..645c41ad33b 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -189,8 +189,12 @@ impl<'a> ModCollector<'a> {
                 object_type: trait_impl.object_type,
                 generics: trait_impl.impl_generics,
                 where_clause: trait_impl.where_clause,
-                trait_id: None, // will be filled later
                 trait_generics: trait_impl.trait_generics,
+
+                // These last fields are filled later on
+                trait_id: None,
+                impl_id: None,
+                resolved_object_type: None,
             };
 
             self.def_collector.items.trait_impls.push(unresolved_trait_impl);
@@ -509,6 +513,7 @@ impl<'a> ModCollector<'a> {
                 method_ids,
                 fns_with_default_impl: unresolved_functions,
             };
+            context.def_interner.push_empty_trait(trait_id, &unresolved);
             self.def_collector.items.traits.insert(trait_id, unresolved);
         }
         errors
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index d4145ef6a1d..60cc2580bb8 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -111,7 +111,9 @@ pub struct NodeInterner {
     // The purpose for this hashmap is to detect duplication of trait implementations ( if any )
     //
     // Indexed by TraitImplIds
-    pub(crate) trait_implementations: Vec<Shared<TraitImpl>>,
+    pub(crate) trait_implementations: HashMap<TraitImplId, Shared<TraitImpl>>,
+
+    next_trait_implementation_id: usize,
 
     /// Trait implementations on each type. This is expected to always have the same length as
     /// `self.trait_implementations`.
@@ -485,7 +487,8 @@ impl Default for NodeInterner {
             struct_attributes: HashMap::new(),
             type_aliases: Vec::new(),
             traits: HashMap::new(),
-            trait_implementations: Vec::new(),
+            trait_implementations: HashMap::new(),
+            next_trait_implementation_id: 0,
             trait_implementation_map: HashMap::new(),
             selected_trait_implementations: HashMap::new(),
             operator_traits: HashMap::new(),
@@ -1143,7 +1146,7 @@ impl NodeInterner {
     }
 
     pub fn get_trait_implementation(&self, id: TraitImplId) -> Shared<TraitImpl> {
-        self.trait_implementations[id.0].clone()
+        self.trait_implementations[&id].clone()
     }
 
     /// Given a `ObjectType: TraitId` pair, try to find an existing impl that satisfies the
@@ -1378,9 +1381,7 @@ impl NodeInterner {
         impl_generics: Generics,
         trait_impl: Shared<TraitImpl>,
     ) -> Result<(), (Span, FileId)> {
-        assert_eq!(impl_id.0, self.trait_implementations.len(), "trait impl defined out of order");
-
-        self.trait_implementations.push(trait_impl.clone());
+        self.trait_implementations.insert(impl_id, trait_impl.clone());
 
         // Replace each generic with a fresh type variable
         let substitutions = impl_generics
@@ -1483,10 +1484,10 @@ impl NodeInterner {
     }
 
     /// Returns what the next trait impl id is expected to be.
-    /// Note that this does not actually reserve the slot so care should
-    /// be taken that the next trait impl added matches this ID.
-    pub fn next_trait_impl_id(&self) -> TraitImplId {
-        TraitImplId(self.trait_implementations.len())
+    pub fn next_trait_impl_id(&mut self) -> TraitImplId {
+        let next_id = self.next_trait_implementation_id;
+        self.next_trait_implementation_id += 1;
+        TraitImplId(next_id)
     }
 
     /// Removes all TraitImplKind::Assumed from the list of known impls for the given trait
diff --git a/compiler/noirc_frontend/src/resolve_locations.rs b/compiler/noirc_frontend/src/resolve_locations.rs
index 2fa7c8adbf8..5efe2e4a041 100644
--- a/compiler/noirc_frontend/src/resolve_locations.rs
+++ b/compiler/noirc_frontend/src/resolve_locations.rs
@@ -157,11 +157,11 @@ impl NodeInterner {
         self.trait_implementations
             .iter()
             .find(|shared_trait_impl| {
-                let trait_impl = shared_trait_impl.borrow();
+                let trait_impl = shared_trait_impl.1.borrow();
                 trait_impl.file == location.file && trait_impl.ident.span().contains(&location.span)
             })
             .and_then(|shared_trait_impl| {
-                let trait_impl = shared_trait_impl.borrow();
+                let trait_impl = shared_trait_impl.1.borrow();
                 self.traits.get(&trait_impl.trait_id).map(|trait_| trait_.location)
             })
     }

From f5d294645e82fc85d8dc28ee2a846ba11af85ce5 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 28 May 2024 13:55:31 -0500
Subject: [PATCH 309/416] fix(experimental elaborator): Only call
 `add_generics` once (#5091)

# Description

## Problem\*

Resolves an issue introduced by
https://github.com/noir-lang/noir/pull/5082 where `add_generics` would
be called multiple times on a given item. Once when declaring the
FuncMeta beforehand, and again when defining it afterward. This is an
issue because `add_generics` will give a fresh set of generics each
time. This meant the generics in a function's signature weren't the same
type variables as the ones used internally, which led to type errors.

## Summary\*



## Additional Context

Down to ~~400~~ 226 errors in the stdlib down from 1050

Edit: Fixed a case where structs never popped their generics out of
scope

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 195 ++++++++++--------
 .../noirc_frontend/src/elaborator/traits.rs   |   2 +-
 .../src/hir/def_collector/dc_crate.rs         |   9 +-
 .../src/hir/def_collector/dc_mod.rs           |  19 +-
 .../src/hir/resolution/resolver.rs            |   4 +
 .../noirc_frontend/src/hir/type_check/mod.rs  |   4 +-
 .../noirc_frontend/src/hir_def/function.rs    |  24 ++-
 7 files changed, 154 insertions(+), 103 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index c537531a748..261a97ec3fb 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -205,7 +205,6 @@ impl<'context> Elaborator<'context> {
         }
 
         this.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
-
         this.collect_traits(items.traits);
 
         // Must resolve structs before we resolve globals.
@@ -224,7 +223,7 @@ impl<'context> Elaborator<'context> {
         //
         // These are resolved after trait impls so that struct methods are chosen
         // over trait methods if there are name conflicts.
-        for ((typ, module), impls) in &items.impls {
+        for ((typ, module), impls) in &mut items.impls {
             this.collect_impls(typ, *module, impls);
         }
 
@@ -238,8 +237,8 @@ impl<'context> Elaborator<'context> {
             this.elaborate_functions(functions);
         }
 
-        for ((typ, module), impls) in items.impls {
-            this.elaborate_impls(typ, module, impls);
+        for impls in items.impls.into_values() {
+            this.elaborate_impls(impls);
         }
 
         for trait_impl in items.trait_impls {
@@ -251,15 +250,27 @@ impl<'context> Elaborator<'context> {
         this.errors
     }
 
+    /// Runs `f` and if it modifies `self.generics`, `self.generics` is truncated
+    /// back to the previous length.
+    fn recover_generics<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T {
+        let generics_count = self.generics.len();
+        let ret = f(self);
+        self.generics.truncate(generics_count);
+        ret
+    }
+
     fn elaborate_functions(&mut self, functions: UnresolvedFunctions) {
         self.file = functions.file_id;
         self.trait_id = functions.trait_id; // TODO: Resolve?
+        self.self_type = functions.self_type;
+
         for (local_module, id, func) in functions.functions {
             self.local_module = local_module;
-            let generics_count = self.generics.len();
-            self.elaborate_function(func, id);
-            self.generics.truncate(generics_count);
+            self.recover_generics(|this| this.elaborate_function(func, id));
         }
+
+        self.self_type = None;
+        self.trait_id = None;
     }
 
     fn elaborate_function(&mut self, mut function: NoirFunction, id: FuncId) {
@@ -277,12 +288,6 @@ impl<'context> Elaborator<'context> {
         self.resolve_local_globals();
         self.trait_bounds = function.def.where_clause.clone();
 
-        let is_low_level_or_oracle = function
-            .attributes()
-            .function
-            .as_ref()
-            .map_or(false, |func| func.is_low_level() || func.is_oracle());
-
         if function.def.is_unconstrained {
             self.in_unconstrained_fn = true;
         }
@@ -297,7 +302,7 @@ impl<'context> Elaborator<'context> {
             self.elaborate_pattern(parameter.pattern.clone(), param2.1.clone(), definition_kind);
         }
 
-        self.add_generics(&function.def.generics);
+        self.generics = func_meta.all_generics.clone();
         self.desugar_impl_trait_args(&mut function, id);
         self.declare_numeric_generics(&func_meta.parameters, func_meta.return_type());
         self.add_trait_constraints_to_scope(&func_meta);
@@ -315,7 +320,8 @@ impl<'context> Elaborator<'context> {
             }
         };
 
-        if !func_meta.can_ignore_return_type() {
+        // Don't verify the return type for builtin functions & trait function declarations
+        if !func_meta.is_stub() {
             self.type_check_function_body(body_type, &func_meta, hir_func.as_expr());
         }
 
@@ -356,7 +362,7 @@ impl<'context> Elaborator<'context> {
         let func_scope_tree = self.scopes.end_function();
 
         // The arguments to low-level and oracle functions are always unused so we do not produce warnings for them.
-        if !is_low_level_or_oracle {
+        if !func_meta.is_stub() {
             self.check_for_unused_variables_in_scope_tree(func_scope_tree);
         }
 
@@ -525,7 +531,12 @@ impl<'context> Elaborator<'context> {
     /// to be used in analysis and intern the function parameters
     /// Prerequisite: any implicit generics, including any generics from the impl,
     /// have already been added to scope via `self.add_generics`.
-    fn define_function_meta(&mut self, func: &mut NoirFunction, func_id: FuncId) {
+    fn define_function_meta(
+        &mut self,
+        func: &mut NoirFunction,
+        func_id: FuncId,
+        is_trait_function: bool,
+    ) {
         self.current_function = Some(func_id);
         self.resolve_where_clause(&mut func.def.where_clause);
 
@@ -652,6 +663,7 @@ impl<'context> Elaborator<'context> {
             location,
             typ,
             direct_generics,
+            all_generics: self.generics.clone(),
             trait_impl: self.current_trait_impl,
             parameters: parameters.into(),
             return_type: func.def.return_type.clone(),
@@ -659,6 +671,7 @@ impl<'context> Elaborator<'context> {
             has_body: !func.def.body.is_empty(),
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point,
+            is_trait_function,
             has_inline_attribute,
         };
 
@@ -840,42 +853,10 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn elaborate_impls(
-        &mut self,
-        typ: UnresolvedType,
-        module: LocalModuleId,
-        impls: Vec<(Vec<Ident>, Span, UnresolvedFunctions)>,
-    ) {
-        self.local_module = module;
-
-        for (generics, _, functions) in impls {
+    fn elaborate_impls(&mut self, impls: Vec<(Vec<Ident>, Span, UnresolvedFunctions)>) {
+        for (_, _, functions) in impls {
             self.file = functions.file_id;
-            let old_generics_length = self.generics.len();
-            self.add_generics(&generics);
-            let self_type = self.resolve_type(typ.clone());
-            self.self_type = Some(self_type.clone());
-
-            let function_ids = vecmap(&functions.functions, |(_, id, _)| *id);
-            self.elaborate_functions(functions);
-
-            if self_type != Type::Error {
-                for method_id in function_ids {
-                    let method_name = self.interner.function_name(&method_id).to_owned();
-
-                    if let Some(first_fn) =
-                        self.interner.add_method(&self_type, method_name.clone(), method_id, false)
-                    {
-                        let error = ResolverError::DuplicateDefinition {
-                            name: method_name,
-                            first_span: self.interner.function_ident(&first_fn).span(),
-                            second_span: self.interner.function_ident(&method_id).span(),
-                        };
-                        self.push_err(error);
-                    }
-                }
-            }
-
-            self.generics.truncate(old_generics_length);
+            self.recover_generics(|this| this.elaborate_functions(functions));
         }
     }
 
@@ -886,7 +867,7 @@ impl<'context> Elaborator<'context> {
         let unresolved_type = trait_impl.object_type;
         let self_type_span = unresolved_type.span;
         let old_generics_length = self.generics.len();
-        self.add_generics(&trait_impl.generics);
+        self.generics = trait_impl.resolved_generics;
 
         let trait_generics =
             vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
@@ -895,7 +876,6 @@ impl<'context> Elaborator<'context> {
         let impl_id =
             trait_impl.impl_id.expect("An impls' id should be set during define_function_metas");
 
-        self.self_type = Some(self_type.clone());
         self.current_trait_impl = trait_impl.impl_id;
 
         let methods = trait_impl.methods.function_ids();
@@ -960,13 +940,16 @@ impl<'context> Elaborator<'context> {
         &mut self,
         self_type: &UnresolvedType,
         module: LocalModuleId,
-        impls: &[(Vec<Ident>, Span, UnresolvedFunctions)],
+        impls: &mut [(Vec<Ident>, Span, UnresolvedFunctions)],
     ) {
         self.local_module = module;
 
         for (generics, span, unresolved) in impls {
             self.file = unresolved.file_id;
-            self.declare_method_on_struct(self_type, generics, false, unresolved, *span);
+            self.recover_generics(|this| {
+                this.add_generics(generics);
+                this.declare_methods_on_struct(self_type, false, unresolved, *span);
+            });
         }
     }
 
@@ -980,8 +963,12 @@ impl<'context> Elaborator<'context> {
 
             let span = trait_impl.object_type.span.expect("All trait self types should have spans");
             let object_type = &trait_impl.object_type;
-            let generics = &trait_impl.generics;
-            self.declare_method_on_struct(object_type, generics, true, &trait_impl.methods, span);
+
+            self.recover_generics(|this| {
+                this.add_generics(&trait_impl.generics);
+                trait_impl.resolved_generics = this.generics.clone();
+                this.declare_methods_on_struct(object_type, true, &mut trait_impl.methods, span);
+            });
         }
     }
 
@@ -990,33 +977,33 @@ impl<'context> Elaborator<'context> {
         &mut self.def_maps.get_mut(&module.krate).expect(message).modules[module.local_id.0]
     }
 
-    fn declare_method_on_struct(
+    fn declare_methods_on_struct(
         &mut self,
         self_type: &UnresolvedType,
-        generics: &UnresolvedGenerics,
         is_trait_impl: bool,
-        functions: &UnresolvedFunctions,
+        functions: &mut UnresolvedFunctions,
         span: Span,
     ) {
-        let generic_count = self.generics.len();
-        self.add_generics(generics);
-        let typ = self.resolve_type(self_type.clone());
+        let self_type = self.resolve_type(self_type.clone());
+
+        functions.self_type = Some(self_type.clone());
+
+        let function_ids = functions.function_ids();
 
-        if let Type::Struct(struct_type, _generics) = typ {
-            let struct_type = struct_type.borrow();
+        if let Type::Struct(struct_type, _) = &self_type {
+            let struct_ref = struct_type.borrow();
 
             // `impl`s are only allowed on types defined within the current crate
-            if !is_trait_impl && struct_type.id.krate() != self.crate_id {
-                let type_name = struct_type.name.to_string();
+            if !is_trait_impl && struct_ref.id.krate() != self.crate_id {
+                let type_name = struct_ref.name.to_string();
                 self.push_err(DefCollectorErrorKind::ForeignImpl { span, type_name });
-                self.generics.truncate(generic_count);
                 return;
             }
 
             // Grab the module defined by the struct type. Note that impls are a case
             // where the module the methods are added to is not the same as the module
             // they are resolved in.
-            let module = self.get_module_mut(struct_type.id.module_id());
+            let module = self.get_module_mut(struct_ref.id.module_id());
 
             for (_, method_id, method) in &functions.functions {
                 // If this method was already declared, remove it from the module so it cannot
@@ -1028,11 +1015,33 @@ impl<'context> Elaborator<'context> {
                     module.remove_function(method.name_ident());
                 }
             }
-        // Prohibit defining impls for primitive types if we're not in the stdlib
-        } else if !is_trait_impl && typ != Type::Error && !self.crate_id.is_stdlib() {
-            self.push_err(DefCollectorErrorKind::NonStructTypeInImpl { span });
+
+            self.declare_struct_methods(&self_type, &function_ids);
+        // We can define methods on primitive types only if we're in the stdlib
+        } else if !is_trait_impl && self_type != Type::Error {
+            if self.crate_id.is_stdlib() {
+                self.declare_struct_methods(&self_type, &function_ids);
+            } else {
+                self.push_err(DefCollectorErrorKind::NonStructTypeInImpl { span });
+            }
+        }
+    }
+
+    fn declare_struct_methods(&mut self, self_type: &Type, function_ids: &[FuncId]) {
+        for method_id in function_ids {
+            let method_name = self.interner.function_name(method_id).to_owned();
+
+            if let Some(first_fn) =
+                self.interner.add_method(self_type, method_name.clone(), *method_id, false)
+            {
+                let error = ResolverError::DuplicateDefinition {
+                    name: method_name,
+                    first_span: self.interner.function_ident(&first_fn).span(),
+                    second_span: self.interner.function_ident(method_id).span(),
+                };
+                self.push_err(error);
+            }
         }
-        self.generics.truncate(generic_count);
     }
 
     fn collect_trait_impl_methods(
@@ -1203,18 +1212,20 @@ impl<'context> Elaborator<'context> {
         unresolved: NoirStruct,
         struct_id: StructId,
     ) -> (Generics, Vec<(Ident, Type)>) {
-        let generics = self.add_generics(&unresolved.generics);
+        self.recover_generics(|this| {
+            let generics = this.add_generics(&unresolved.generics);
 
-        // Check whether the struct definition has globals in the local module and add them to the scope
-        self.resolve_local_globals();
+            // Check whether the struct definition has globals in the local module and add them to the scope
+            this.resolve_local_globals();
 
-        self.current_item = Some(DependencyId::Struct(struct_id));
+            this.current_item = Some(DependencyId::Struct(struct_id));
 
-        self.resolving_ids.insert(struct_id);
-        let fields = vecmap(unresolved.fields, |(ident, typ)| (ident, self.resolve_type(typ)));
-        self.resolving_ids.remove(&struct_id);
+            this.resolving_ids.insert(struct_id);
+            let fields = vecmap(unresolved.fields, |(ident, typ)| (ident, this.resolve_type(typ)));
+            this.resolving_ids.remove(&struct_id);
 
-        (generics, fields)
+            (generics, fields)
+        })
     }
 
     fn elaborate_global(&mut self, global: UnresolvedGlobal) {
@@ -1256,11 +1267,16 @@ impl<'context> Elaborator<'context> {
             self.define_function_metas_for_functions(function_set);
         }
 
-        for ((_typ, local_module), function_sets) in impls {
+        for ((self_type, local_module), function_sets) in impls {
             self.local_module = *local_module;
 
-            for (_generics, _, function_set) in function_sets {
+            for (generics, _, function_set) in function_sets {
+                self.add_generics(generics);
+                let self_type = self.resolve_type(self_type.clone());
+                function_set.self_type = Some(self_type.clone());
+                self.self_type = Some(self_type);
                 self.define_function_metas_for_functions(function_set);
+                self.generics.clear();
             }
         }
 
@@ -1269,11 +1285,12 @@ impl<'context> Elaborator<'context> {
             self.local_module = trait_impl.module_id;
 
             let unresolved_type = &trait_impl.object_type;
-            let old_generics_length = self.generics.len();
             self.add_generics(&trait_impl.generics);
 
             let self_type = self.resolve_type(unresolved_type.clone());
+
             self.self_type = Some(self_type.clone());
+            trait_impl.methods.self_type = Some(self_type);
 
             let impl_id = self.interner.next_trait_impl_id();
             self.current_trait_impl = Some(impl_id);
@@ -1282,7 +1299,7 @@ impl<'context> Elaborator<'context> {
 
             trait_impl.resolved_object_type = self.self_type.take();
             trait_impl.impl_id = self.current_trait_impl.take();
-            self.generics.truncate(old_generics_length);
+            self.generics.clear();
         }
     }
 
@@ -1291,9 +1308,9 @@ impl<'context> Elaborator<'context> {
 
         for (local_module, id, func) in &mut function_set.functions {
             self.local_module = *local_module;
-            let old_generics_length = self.generics.len();
-            self.define_function_meta(func, *id);
-            self.generics.truncate(old_generics_length);
+            self.recover_generics(|this| {
+                this.define_function_meta(func, *id, false);
+            });
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index c2f9a83e559..76cdc592276 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -178,7 +178,7 @@ impl<'context> Elaborator<'context> {
         };
 
         let mut function = NoirFunction { kind, def };
-        self.define_function_meta(&mut function, func_id);
+        self.define_function_meta(&mut function, func_id, true);
         self.elaborate_function(function, func_id);
         let _ = self.scopes.end_function();
         // Don't check the scope tree for unused variables, they can't be used in a declaration anyway.
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 60b841699f1..838aac3f067 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -5,7 +5,7 @@ use crate::graph::CrateId;
 use crate::hir::comptime::{Interpreter, InterpreterError};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
-use crate::Type;
+use crate::{Type, TypeVariable};
 
 use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
 use crate::hir::resolution::{
@@ -33,6 +33,7 @@ use iter_extended::vecmap;
 use noirc_errors::{CustomDiagnostic, Span};
 use std::collections::{BTreeMap, HashMap};
 
+use std::rc::Rc;
 use std::vec;
 
 #[derive(Default)]
@@ -50,6 +51,9 @@ pub struct UnresolvedFunctions {
     pub file_id: FileId,
     pub functions: Vec<(LocalModuleId, FuncId, NoirFunction)>,
     pub trait_id: Option<TraitId>,
+
+    // The object type this set of functions was declared on, if there is one.
+    pub self_type: Option<Type>,
 }
 
 impl UnresolvedFunctions {
@@ -117,10 +121,11 @@ pub struct UnresolvedTraitImpl {
     pub generics: UnresolvedGenerics,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
 
-    // These fields are filled in later during elaboration
+    // These fields are filled in later
     pub trait_id: Option<TraitId>,
     pub impl_id: Option<TraitImplId>,
     pub resolved_object_type: Option<Type>,
+    pub resolved_generics: Vec<(Rc<String>, TypeVariable, Span)>,
 }
 
 #[derive(Clone)]
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 645c41ad33b..536332d8f8a 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -146,6 +146,7 @@ impl<'a> ModCollector<'a> {
                 file_id: self.file_id,
                 functions: Vec::new(),
                 trait_id: None,
+                self_type: None,
             };
 
             for (method, _) in r#impl.methods {
@@ -195,6 +196,7 @@ impl<'a> ModCollector<'a> {
                 trait_id: None,
                 impl_id: None,
                 resolved_object_type: None,
+                resolved_generics: Vec::new(),
             };
 
             self.def_collector.items.trait_impls.push(unresolved_trait_impl);
@@ -207,8 +209,12 @@ impl<'a> ModCollector<'a> {
         trait_impl: &NoirTraitImpl,
         krate: CrateId,
     ) -> UnresolvedFunctions {
-        let mut unresolved_functions =
-            UnresolvedFunctions { file_id: self.file_id, functions: Vec::new(), trait_id: None };
+        let mut unresolved_functions = UnresolvedFunctions {
+            file_id: self.file_id,
+            functions: Vec::new(),
+            trait_id: None,
+            self_type: None,
+        };
 
         let module = ModuleId { krate, local_id: self.module_id };
 
@@ -230,8 +236,12 @@ impl<'a> ModCollector<'a> {
         functions: Vec<NoirFunction>,
         krate: CrateId,
     ) -> Vec<(CompilationError, FileId)> {
-        let mut unresolved_functions =
-            UnresolvedFunctions { file_id: self.file_id, functions: Vec::new(), trait_id: None };
+        let mut unresolved_functions = UnresolvedFunctions {
+            file_id: self.file_id,
+            functions: Vec::new(),
+            trait_id: None,
+            self_type: None,
+        };
         let mut errors = vec![];
 
         let module = ModuleId { krate, local_id: self.module_id };
@@ -404,6 +414,7 @@ impl<'a> ModCollector<'a> {
                 file_id: self.file_id,
                 functions: Vec::new(),
                 trait_id: None,
+                self_type: None,
             };
 
             let mut method_ids = HashMap::new();
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 8beac340c4b..9fe0d473f15 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1106,6 +1106,10 @@ impl<'a> Resolver<'a> {
             trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
             is_entry_point: self.is_entry_point_function(func),
             has_inline_attribute,
+
+            // This is only used by the elaborator
+            all_generics: Vec::new(),
+            is_trait_function: false,
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index b2a76828c88..70d7c4021ed 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -49,7 +49,7 @@ pub struct TypeChecker<'interner> {
 pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<TypeCheckError> {
     let meta = interner.function_meta(&func_id);
     let declared_return_type = meta.return_type().clone();
-    let can_ignore_ret = meta.can_ignore_return_type();
+    let can_ignore_ret = meta.is_stub();
 
     let function_body_id = &interner.function(&func_id).as_expr();
 
@@ -549,7 +549,9 @@ pub mod test {
             trait_constraints: Vec::new(),
             direct_generics: Vec::new(),
             is_entry_point: true,
+            is_trait_function: false,
             has_inline_attribute: false,
+            all_generics: Vec::new(),
         };
         interner.push_fn_meta(func_meta, func_id);
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index ceec9ad8580..9e03f074ffe 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -109,6 +109,12 @@ pub struct FuncMeta {
     /// such as a trait's `Self` type variable.
     pub direct_generics: Vec<(Rc<String>, TypeVariable)>,
 
+    /// All the generics used by this function, which includes any implicit generics or generics
+    /// from outer scopes, such as those introduced by an impl.
+    /// This is stored when the FuncMeta is first created to later be used to set the current
+    /// generics when the function's body is later resolved.
+    pub all_generics: Vec<(Rc<String>, TypeVariable, Span)>,
+
     pub location: Location,
 
     // This flag is needed for the attribute check pass
@@ -123,6 +129,11 @@ pub struct FuncMeta {
     /// For non-contracts, this means the function is `main`.
     pub is_entry_point: bool,
 
+    /// True if this function was defined within a trait (not a trait impl!).
+    /// Trait functions are just stubs and shouldn't have their return type checked
+    /// against their body type, nor should unused variables be checked.
+    pub is_trait_function: bool,
+
     /// True if this function is marked with an attribute
     /// that indicates it should be inlined differently than the default (inline everything).
     /// For example, such as `fold` (never inlined) or `no_predicates` (inlined after flattening)
@@ -130,12 +141,13 @@ pub struct FuncMeta {
 }
 
 impl FuncMeta {
-    /// Builtin, LowLevel and Oracle functions usually have the return type
-    /// declared, however their function bodies will be empty
-    /// So this method tells the type checker to ignore the return
-    /// of the empty function, which is unit
-    pub fn can_ignore_return_type(&self) -> bool {
-        self.kind.can_ignore_return_type()
+    /// A stub function does not have a body. This includes Builtin, LowLevel,
+    /// and Oracle functions in addition to method declarations within a trait.
+    ///
+    /// We don't check the return type of these functions since it will always have
+    /// an empty body, and we don't check for unused parameters.
+    pub fn is_stub(&self) -> bool {
+        self.kind.can_ignore_return_type() || self.is_trait_function
     }
 
     pub fn function_signature(&self) -> FunctionSignature {

From 11e98f348d1d43a9b28d83ec3308027b7afc0da6 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 20:14:22 +0100
Subject: [PATCH 310/416] feat: replace stdlib poseidon implementation with
 optimized version (#5122)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR pulls out the existing poseidon implementation and replaces it
with @zac-williamson's improved version.

I've removed the "optimized" version which hardcodes the values of
`rf`/`rp` as it was equivalent to just using a constant config
(something which I expect would happen in 99.9999% of cases).

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 noir_stdlib/src/hash/poseidon.nr              |   198 +-
 noir_stdlib/src/hash/poseidon/bn254.nr        |    85 +-
 noir_stdlib/src/hash/poseidon/bn254/consts.nr | 24885 +++++++++++++++-
 noir_stdlib/src/hash/poseidon/bn254/perm.nr   |     2 +-
 4 files changed, 24981 insertions(+), 189 deletions(-)

diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr
index 742bfcaf804..f40ea2738ed 100644
--- a/noir_stdlib/src/hash/poseidon.nr
+++ b/noir_stdlib/src/hash/poseidon.nr
@@ -3,66 +3,134 @@ use crate::field::modulus_num_bits;
 use crate::hash::Hasher;
 use crate::default::Default;
 
-struct PoseidonConfig<M,N> {
-    t: Field, // Width, i.e. state size
-    rf: u8, // Number of full rounds; should be even
-    rp: u8, // Number of partial rounds
-    alpha: Field, // S-box power; depends on the underlying field
-    ark: [Field; M], // Additive round keys
-    mds: [Field; N] // MDS Matrix in row-major order
+// A config struct defining the parameters of the Poseidon instance to use.
+//
+// A thorough writeup of this method (along with an unoptimized method) can be found at: https://spec.filecoin.io/algorithms/crypto/poseidon/
+struct PoseidonConfig<T, N, X> { 
+    // State width, should be equal to `T`
+    t: Field,
+    // Number of full rounds. should be even
+    rf: u8,
+    // Number of partial rounds
+    rp: u8,
+     // S-box power; depends on the underlying field
+    alpha: Field,
+    // The round constants for the
+    round_constants: [Field; N],
+    // The MDS matrix for the Poseidon instance
+    mds: [[Field; T]; T],
+    // An MDS matrix which also applies a basis transformation which allows
+    // sparse matrices to be used for the partial rounds.
+    //
+    // This should be applied instead of `mds` in the final full round.
+    presparse_mds: [[Field; T]; T],
+    // A set of sparse matrices used for MDS mixing for the partial rounds.
+    sparse_mds: [Field; X],
 }
 
-pub fn config<M, N>(
+pub fn config<T, N, X>(
     t: Field,
     rf: u8,
     rp: u8,
     alpha: Field,
-    ark: [Field; M],
-    mds: [Field; N]
-) -> PoseidonConfig<M,N> {
+    round_constants: [Field; N],
+    mds: [[Field; T]; T],
+    presparse_mds: [[Field; T]; T],
+    sparse_mds: [Field; X]
+) -> PoseidonConfig<T, N, X> {
     // Input checks
-    let mul = crate::wrapping_mul(t as u8, (rf + rp));
-    assert(mul == ark.len() as u8);
-    assert(t * t == mds.len() as Field);
+    assert_eq(rf & 1, 0);
+    assert_eq((t as u8) * rf + rp, N);
+    assert_eq(t, T);
     assert(alpha != 0);
 
-    PoseidonConfig { t, rf, rp, alpha, ark, mds }
+    PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds }
 }
-// General Poseidon permutation on elements of type Field
-fn permute<M, N, O>(pos_conf: PoseidonConfig<M, N>, mut state: [Field; O]) -> [Field; O] {
-    let PoseidonConfig {t, rf, rp, alpha, ark, mds} = pos_conf;
 
-    assert(t == state.len() as Field);
+pub fn permute<T, N, X>(pos_conf: PoseidonConfig<T, N, X>, mut state: [Field; T]) -> [Field; T] {
+    let PoseidonConfig {t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } = pos_conf;
 
-    let mut count = 0;
-    // for r in 0..rf + rp
-    for r in 0..(ark.len() / state.len()) {
-        for i in 0..state.len() {
-            state[i] = state[i] + ark[count + i];
-        } // Shift by round constants
+    for i in 0..state.len() {
+        state[i] += round_constants[i];
+    }
+
+    for _r in 0..rf / 2 - 1 {
+        state = sigma(state);
+        for i in 0..T {
+            state[i] += round_constants[T * (_r + 1) as u64 + i];
+        }
+        state = apply_matrix(mds, state);
+    }
+
+    state = sigma(state);
+    for i in 0..T {
+        state[i] += round_constants[T * (rf / 2) as u64 + i];
+    }
+    state = apply_matrix(presparse_mds, state);
+
+    for i in 0..T {
+        crate::as_witness(state[i]);
+    }
+
+    for _r in 0..rp {
         state[0] = state[0].pow_32(alpha);
-        // Check whether we are in a full round
-        if (r as u8 < rf / 2) | (r as u8 >= rf / 2 + rp) {
-            for i in 1..state.len() {
-                state[i] = state[i].pow_32(alpha);
+        state[0] += round_constants[(rf/2 + 1) as u64 * T + _r as u64];
+        crate::as_witness(state[0]);
+        {
+            let mut newState0 = 0;
+            for j in 0..T {
+                newState0 += sparse_mds[(T * 2 - 1) * _r as u64 + j as u64] * state[j];
+            }
+            for k in 1..T {
+                state[k] += state[0] * sparse_mds[(t * 2 - 1) as u64 * _r as u64 + T + k - 1];
+            }
+            state[0] = newState0;
+
+            if (_r & 1 == 0) {
+                for k in 1..T {
+                    crate::as_witness(state[k]);
+                }
             }
         }
+    }
 
-        state = apply_matrix(mds, state); // Apply MDS matrix
-        count = count + t as u64;
+    for _r in 0..rf / 2 - 1 {
+        state = sigma(state);
+        for i in 0..state.len() {
+            state[i] += round_constants[(rf/2+1) as u64 * T + rp as u64 + (_r as u64) * T + i];
+        }
+        state = apply_matrix(mds, state);
     }
 
+    state = sigma(state);
+    state = apply_matrix(mds, state);
+
     state
 }
-// Absorption. Fully absorbs input message.
-fn absorb<M, N, O, P>(
-    pos_conf: PoseidonConfig<M, N>,
-    mut state: [Field; O], // Initial state; usually [0; O]
-    rate: Field, // Rate
-    capacity: Field, // Capacity; usually 1
-    msg: [Field; P]
-) -> [Field; O] {
-    assert(pos_conf.t == rate + capacity);
+
+// Performs matrix multiplication on a vector
+fn apply_matrix<N>(matrix: [[Field; N]; N], vec: [Field; N]) -> [Field; N] {
+    let mut out = [0; N];
+
+    for i in 0..N {
+        for j in 0..N {
+            out[i] += vec[j] * matrix[j][i];
+        }
+    }
+
+    out
+}
+
+// Corresponding absorption.
+fn absorb<T, N, X, O>(
+    pos_conf: PoseidonConfig<T, N, X>,
+    // Initial state; usually [0; O]
+    mut state: [Field; T],
+    rate: Field,
+    capacity: Field,
+    msg: [Field; O] // Arbitrary length message
+) -> [Field; T] {
+    assert_eq(pos_conf.t, rate + capacity);
 
     let mut i = 0;
 
@@ -83,25 +151,24 @@ fn absorb<M, N, O, P>(
 
     state
 }
+
+fn sigma<O>(x: [Field; O]) -> [Field; O] {
+    let mut y = x;
+    for i in 0..O {
+        let t = y[i];
+        let tt = t * t;
+        let tttt = tt * tt;
+        y[i] *= tttt;
+    }
+    y
+}
+
 // Check security of sponge instantiation
 fn check_security(rate: Field, width: Field, security: Field) -> bool {
     let n = modulus_num_bits();
 
     ((n - 1) as Field * (width - rate) / 2) as u8 > security as u8
 }
-// A*x where A is an n x n matrix in row-major order and x an n-vector
-fn apply_matrix<N, M>(a: [Field; M], x: [Field; N]) -> [Field; N] {
-    let mut y = x;
-
-    for i in 0..x.len() {
-        y[i] = 0;
-        for j in 0..x.len() {
-            y[i] = y[i] + a[x.len()*i + j]* x[j];
-        }
-    }
-
-    y
-}
 
 struct PoseidonHasher{
     _state: [Field],
@@ -174,3 +241,28 @@ impl Default for PoseidonHasher{
         }
     }
 }
+
+mod poseidon_tests {
+    use crate::hash::poseidon;
+
+    #[test]
+    fn reference_impl_test_vectors() {
+        // hardcoded test vectors from https://extgit.iaik.tugraz.at/krypto/hadeshash/-/blob/master/code/test_vectors.txt
+        {
+            let mut state = [0, 1, 2];
+            let mut expected = [
+                0x115cc0f5e7d690413df64c6b9662e9cf2a3617f2743245519e19607a4417189a, 0x0fca49b798923ab0239de1c9e7a4a9a2210312b6a2f616d18b5a87f9b628ae29, 0x0e7ae82e40091e63cbd4f16a6d16310b3729d4b6e138fcf54110e2867045a30c
+            ];
+            assert_eq(expected, poseidon::bn254::perm::x5_3(state), "Failed to reproduce output for [0, 1, 2]");
+        }
+        {
+            let mut state = [0, 1, 2, 3, 4];
+            let mut expected = [
+                0x299c867db6c1fdd79dcefa40e4510b9837e60ebb1ce0663dbaa525df65250465, 0x1148aaef609aa338b27dafd89bb98862d8bb2b429aceac47d86206154ffe053d, 0x24febb87fed7462e23f6665ff9a0111f4044c38ee1672c1ac6b0637d34f24907, 0x0eb08f6d809668a981c186beaf6110060707059576406b248e5d9cf6e78b3d3e, 0x07748bc6877c9b82c8b98666ee9d0626ec7f5be4205f79ee8528ef1c4a376fc7
+            ];
+            assert_eq(
+                expected, poseidon::bn254::perm::x5_5(state), "Failed to reproduce output for [0, 1, 2, 3, 4]"
+            );
+        }
+    }
+}
diff --git a/noir_stdlib/src/hash/poseidon/bn254.nr b/noir_stdlib/src/hash/poseidon/bn254.nr
index 37b08e3c8fb..54f22884e29 100644
--- a/noir_stdlib/src/hash/poseidon/bn254.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254.nr
@@ -2,93 +2,14 @@
 mod perm;
 mod consts;
 
-use crate::hash::poseidon::PoseidonConfig;
-use crate::hash::poseidon::apply_matrix;
-// Optimised permutation for this particular field; uses hardcoded rf and rp values,
-// which should agree with those in pos_conf.
-#[field(bn254)]
-pub fn permute<M, N, O>(pos_conf: PoseidonConfig<M, N>, mut state: [Field; O]) -> [Field; O] {
-    let PoseidonConfig {t, rf: config_rf, rp: config_rp, alpha, ark, mds} = pos_conf;
-    let rf: u8 = 8;
-    let rp: u8 = [56, 57, 56, 60, 60, 63, 64, 63, 60, 66, 60, 65, 70, 60, 64, 68][state.len() - 2];
-
-    assert(t == state.len() as Field);
-    assert(rf == config_rf);
-    assert(rp == config_rp);
-
-    let mut count = 0;
-    // First half of full rounds
-    for _r in 0..rf / 2 {
-        for i in 0..state.len() {
-            state[i] = state[i] + ark[count + i];
-        } // Shift by round constants
-        for i in 0..state.len() {
-            state[i] = state[i].pow_32(alpha);
-        }
-
-        state = apply_matrix(mds, state); // Apply MDS matrix
-        count = count + t as u64;
-    }
-    // Partial rounds
-    for _r in 0..rp {
-        for i in 0..state.len() {
-            state[i] = state[i] + ark[count + i];
-        } // Shift by round constants
-        state[0] = state[0].pow_32(alpha);
-
-        state = apply_matrix(mds, state); // Apply MDS matrix
-        count = count + t as u64;
-    }
-    // Second half of full rounds
-    for _r in 0..rf / 2 {
-        for i in 0..state.len() {
-            state[i] = state[i] + ark[count + i];
-        } // Shift by round constants
-        for i in 0..state.len() {
-            state[i] = state[i].pow_32(alpha);
-        }
-
-        state = apply_matrix(mds, state); // Apply MDS matrix
-        count = count + t as u64;
-    }
-
-    state
-}
-// Corresponding absorption.
-#[field(bn254)]
-fn absorb<M, N, O, P>(
-    pos_conf: PoseidonConfig<M, N>,
-    mut state: [Field; O], // Initial state; usually [0; O]
-    rate: Field, // Rate
-    capacity: Field, // Capacity; usually 1
-    msg: [Field; P] // Arbitrary length message
-) -> [Field; O] {
-    assert(pos_conf.t == rate + capacity);
-
-    let mut i = 0;
-
-    for k in 0..msg.len() {
-        // Add current block to state
-        state[capacity + i] += msg[k];
-        i = i+1;
-        // Enough to absorb
-        if i == rate {
-            state = permute(pos_conf, state);
-            i = 0;
-        }
-    }
-    // If we have one more block to permute
-    if i != 0 {
-        state = permute(pos_conf, state);
-    }
-
-    state
-}
+use crate::hash::poseidon::{PoseidonConfig, absorb};
+
 // Variable-length Poseidon-128 sponge as suggested in second bullet point of §3 of https://eprint.iacr.org/2019/458.pdf
 #[field(bn254)]
 pub fn sponge<N>(msg: [Field; N]) -> Field {
     absorb(consts::x5_5_config(), [0; 5], 4, 1, msg)[1]
 }
+
 // Various instances of the Poseidon hash function
 // Consistent with Circom's implementation
 pub fn hash_1(input: [Field; 1]) -> Field {
diff --git a/noir_stdlib/src/hash/poseidon/bn254/consts.nr b/noir_stdlib/src/hash/poseidon/bn254/consts.nr
index 62b5f4b5212..81d78377ce8 100644
--- a/noir_stdlib/src/hash/poseidon/bn254/consts.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254/consts.nr
@@ -1,9 +1,11 @@
+// Parameters are generated by a reference script https://extgit.iaik.tugraz.at/krypto/hadeshash/-/blob/master/code/generate_parameters_grain.sage
+// Used like so: sage generate_parameters_grain.sage 1 0 254 2 8 56 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
+
 // Constants for various Poseidon instances in the case of the prime field of the same order as BN254.
 // Consistent with https://github.com/iden3/circomlib/blob/master/circuits/poseidon.circom and https://github.com/iden3/circomlib/blob/master/circuits/poseidon_constants.circom
 use crate::hash::poseidon::PoseidonConfig;
 use crate::hash::poseidon::config;
 // Number of full rounds
-global rf = 8;
 // Number of partial rounds
 fn rp() -> [u8; 16] {
     [56, 57, 56, 60, 60, 63, 64, 63, 60, 66, 60, 65, 70, 60, 64, 68]
@@ -12,181 +14,24958 @@ fn rp() -> [u8; 16] {
 fn alpha() -> Field {
     5
 }
-// Poseidon configurations for states of size 2 to 17.
+
 // noir-fmt:ignore
-pub fn x5_2_config() -> PoseidonConfig<128, 4> {
+pub fn x5_2_config() -> PoseidonConfig<2, 72, 168> {
     config(
         2,
         8,
         56,
         alpha(),
-        [4417881134626180770308697923359573201005643519861877412381846989312604493735,5433650512959517612316327474713065966758808864213826738576266661723522780033,13641176377184356099764086973022553863760045607496549923679278773208775739952,17949713444224994136330421782109149544629237834775211751417461773584374506783,13765628375339178273710281891027109699578766420463125835325926111705201856003,19179513468172002314585757290678967643352171735526887944518845346318719730387,5157412437176756884543472904098424903141745259452875378101256928559722612176,535160875740282236955320458485730000677124519901643397458212725410971557409,1050793453380762984940163090920066886770841063557081906093018330633089036729,10665495010329663932664894101216428400933984666065399374198502106997623173873,19965634623406616956648724894636666805991993496469370618546874926025059150737,13007250030070838431593222885902415182312449212965120303174723305710127422213,16877538715074991604507979123743768693428157847423939051086744213162455276374,18211747749504876135588847560312685184956239426147543810126553367063157141465,18151553319826126919739798892854572062191241985315767086020821632812331245635,19957033149976712666746140949846950406660099037474791840946955175819555930825,3469514863538261843186854830917934449567467100548474599735384052339577040841,989698510043911779243192466312362856042600749099921773896924315611668507708,12568377015646290945235387813564567111330046038050864455358059568128000172201,20856104135605479600325529349246932565148587186338606236677138505306779314172,8206918720503535523121349917159924938835810381723474192155637697065780938424,1309058477013932989380617265069188723120054926187607548493110334522527703566,14076116939332667074621703729512195584105250395163383769419390236426287710606,10153498892749751942204288991871286290442690932856658983589258153608012428674,18202499207234128286137597834010475797175973146805180988367589376893530181575,12739388830157083522877690211447248168864006284243907142044329113461613743052,15123358710467780770838026754240340042441262572309759635224051333176022613949,19925004701844594370904593774447343836015483888496504201331110250494635362184,10352416606816998476681131583320899030072315953910679608943150613208329645891,10567371822366244361703342347428230537114808440249611395507235283708966113221,5635498582763880627392290206431559361272660937399944184533035305989295959602,11866432933224219174041051738704352719163271639958083608224676028593315904909,5795020705294401441272215064554385591292330721703923167136157291459784140431,9482202378699252817564375087302794636287866584767523335624368774856230692758,4245237636894546151746468406560945873445548423466753843402086544922216329298,12000500941313982757584712677991730019124834399479314697467598397927435905133,7596790274058425558167520209857956363736666939016807569082239187494363541787,2484867918246116343205467273440098378820186751202461278013576281097918148877,18312645949449997391810445935615409295369169383463185688973803378104013950190,15320686572748723004980855263301182130424010735782762814513954166519592552733,12618438900597948888520621062416758747872180395546164387827245287017031303859,17438141672027706116733201008397064011774368832458707512367404736905021019585,6374197807230665998865688675365359100400438034755781666913068586172586548950,2189398913433273865510950346186699930188746169476472274335177556702504595264,6268495580028970231803791523870131137294646402347399003576649137450213034606,17896250365994900261202920044129628104272791547990619503076839618914047059275,13692156312448722528008862371944543449350293305158722920787736248435893008873,15234446864368744483209945022439268713300180233589581910497691316744177619376,1572426502623310766593681563281600503979671244997798691029595521622402217227,80103447810215150918585162168214870083573048458555897999822831203653996617,8228820324013669567851850635126713973797711779951230446503353812192849106342,5375851433746509614045812476958526065449377558695752132494533666370449415873,12115998939203497346386774317892338270561208357481805380546938146796257365018,9764067909645821279940531410531154041386008396840887338272986634350423466622,8538708244538850542384936174629541085495830544298260335345008245230827876882,7140127896620013355910287215441004676619168261422440177712039790284719613114,14297402962228458726038826185823085337698917275385741292940049024977027409762,6667115556431351074165934212337261254608231545257434281887966406956835140819,20226761165244293291042617464655196752671169026542832236139342122602741090001,12038289506489256655759141386763477208196694421666339040483042079632134429119,19027757334170818571203982241812412991528769934917288000224335655934473717551,16272152964456553579565580463468069884359929612321610357528838696790370074720,2500392889689246014710135696485946334448570271481948765283016105301740284071,8595254970528530312401637448610398388203855633951264114100575485022581946023,11635945688914011450976408058407206367914559009113158286982919675551688078198,614739068603482619581328040478536306925147663946742687395148680260956671871,18692271780377861570175282183255720350972693125537599213951106550953176268753,4987059230784976306647166378298632695585915319042844495357753339378260807164,21851403978498723616722415377430107676258664746210815234490134600998983955497,9830635451186415300891533983087800047564037813328875992115573428596207326204,4842706106434537116860242620706030229206345167233200482994958847436425185478,6422235064906823218421386871122109085799298052314922856340127798647926126490,4564364104986856861943331689105797031330091877115997069096365671501473357846,1944043894089780613038197112872830569538541856657037469098448708685350671343,21179865974855950600518216085229498748425990426231530451599322283119880194955,14296697761894107574369608843560006996183955751502547883167824879840894933162,12274619649702218570450581712439138337725246879938860735460378251639845671898,16371396450276899401411886674029075408418848209575273031725505038938314070356,3702561221750983937578095019779188631407216522704543451228773892695044653565,19721616877735564664624984774636557499099875603996426215495516594530838681980,6383350109027696789969911008057747025018308755462287526819231672217685282429,20860583956177367265984596617324237471765572961978977333122281041544719622905,5766390934595026947545001478457407504285452477687752470140790011329357286275,4043175758319898049344746138515323336207420888499903387536875603879441092484,15579382179133608217098622223834161692266188678101563820988612253342538956534,1864640783252634743892105383926602930909039567065240010338908865509831749824,15943719865023133586707144161652035291705809358178262514871056013754142625673,2326415993032390211558498780803238091925402878871059708106213703504162832999,19995326402773833553207196590622808505547443523750970375738981396588337910289,5143583711361588952673350526320181330406047695593201009385718506918735286622,15436006486881920976813738625999473183944244531070780793506388892313517319583,16660446760173633166698660166238066533278664023818938868110282615200613695857,4966065365695755376133119391352131079892396024584848298231004326013366253934,20683781957411705574951987677641476019618457561419278856689645563561076926702,17280836839165902792086432296371645107551519324565649849400948918605456875699,17045635513701208892073056357048619435743564064921155892004135325530808465371,17055032967194400710390142791334572297458033582458169295920670679093585707295,15727174639569115300068198908071514334002742825679221638729902577962862163505,1001755657610446661315902885492677747789366510875120894840818704741370398633,18638547332826171619311285502376343504539399518545103511265465604926625041234,6751954224763196429755298529194402870632445298969935050224267844020826420799,3526747115904224771452549517614107688674036840088422555827581348280834879405,15705897908180497062880001271426561999724005008972544196300715293701537574122,574386695213920937259007343820417029802510752426579750428758189312416867750,15973040855000600860816974646787367136127946402908768408978806375685439868553,20934130413948796333037139460875996342810005558806621330680156931816867321122,6918585327145564636398173845411579411526758237572034236476079610890705810764,14158163500813182062258176233162498241310167509137716527054939926126453647182,4164602626597695668474100217150111342272610479949122406544277384862187287433,12146526846507496913615390662823936206892812880963914267275606265272996025304,10153527926900017763244212043512822363696541810586522108597162891799345289938,13564663485965299104296214940873270349072051793008946663855767889066202733588,5612449256997576125867742696783020582952387615430650198777254717398552960096,12151885480032032868507892738683067544172874895736290365318623681886999930120,380452237704664384810613424095477896605414037288009963200982915188629772177,9067557551252570188533509616805287919563636482030947363841198066124642069518,21280306817619711661335268484199763923870315733198162896599997188206277056900,5567165819557297006750252582140767993422097822227408837378089569369734876257,10411936321072105429908396649383171465939606386380071222095155850987201580137,21338390051413922944780864872652000187403217966653363270851298678606449622266,12156296560457833712186127325312904760045212412680904475497938949653569234473,4271647814574748734312113971565139132510281260328947438246615707172526380757,9061738206062369647211128232833114177054715885442782773131292534862178874950,10134551893627587797380445583959894183158393780166496661696555422178052339133,8932270237664043612366044102088319242789325050842783721780970129656616386103,3339412934966886386194449782756711637636784424032779155216609410591712750636,9704903972004596791086522314847373103670545861209569267884026709445485704400,17467570179597572575614276429760169990940929887711661192333523245667228809456],
-        [2910766817845651019878574839501801340070030115151021261302834310722729507541,19727366863391167538122140361473584127147630672623100827934084310230022599144,5776684794125549462448597414050232243778680302179439492664047328281728356345,8348174920934122550483593999453880006756108121341067172388445916328941978568]
+        [
+            0x9c46e9ec68e9bd4fe1faaba294cba38a71aa177534cdd1b6c7dc0dbd0abd7a7,
+            0xc0356530896eec42a97ed937f3135cfc5142b3ae405b8343c1d83ffa604cb81,
+            0x250f5116a417d76aaa422952fcc5b33329f7714fc26d56c0432507fc740a87c4,
+            0x264065ad87572e016659626c33c8213f7a373b9b8225a384f458d850bb4a949f,
+            0x2bb8e94ad8d8adca6ce909ff94b8750729b294e4400376da39e33fda24bd42af,
+            0x19051065d05d861ec813c15291d46a328f6201b21ad5d239d4f85fbb09a5dbae,
+            0x245bd0617aa449618f5bd4550aac7b8e08d4d1c017165943cdf4776cdff3434a,
+            0x9fb1a1118074ff79d8acbf5b02131e048a1570155e0f2b1c36ad091d491a88f,
+            0x234ab504bbae8198972741952f78b7eb018ea192f05e54c1484ab8973ff66d88,
+            0x1f66e509b84c355ae3d4c3513a282fd48f9c8c6439f42a7835fbcfe0f2a324c,
+            0x1b22f5d69d725e6002cf00dd9ee62d1a5af0efdc4910f54127a920ccc43f91fa,
+            0x252b55edead135f852968b7f1c4f490fa659ecd5b47a78a7db91f65a6dfc23f,
+            0x1773ae2e1637c92ad0677c2a047fea8eca4b53303f21871f6892a2c0487d7ff1,
+            0x2d57b02906cd0ab82a79e76faeef6f87666eac093cf7715645d5ec9f7ac732f5,
+            0xa16f3a62824b281e8b2ddb8fc391a498fb061317faffa03696f834596313d93,
+            0x1666f525f7f4b6988d2a37834ab747eae0587757b788eb7f1e26b08e36a08591,
+            0x5da44f8e0a3b8bb13231f0ca25b50b57f5c82128e1dfec3e541d912ebe17b76,
+            0x9a39ba9993303ba191bac8bdb3e0144dbfb5f39624cdd9524dc7861633bc95a,
+            0x6c0fb824a19202d30ee6b418c0029e100e85a6d158f9f2a828dfd2ed0920a68,
+            0x387d8e056b2b176a9776b4492cb3b418adc660627e52bb3324283bf9522395d,
+            0x147a1af82036ef5b28a7a37bea40d6ac3013cf1b62358396bf7156f5c2dc9684,
+            0x3038d92060daeaaf1bd0482bd3f0613d88e8dff90a7a0525f9227e4cb7c6f81b,
+            0x72940aa1d538a5a39a323f9e5d65616cf6c223339006f9789a97245532908f5,
+            0x2d3d604949f4e14c70b8a879aedec49b3a367ba216af048f464ed6f15e2b9023,
+            0x225b9e4f35c7549f80774c2b4d18309b2dcf7c7287b982e49746a176641e73c5,
+            0x1ea781288fdf13b2190095a2344828e37dfe81c75a09709f0d139bbbf6c70414,
+            0x8e96c3e7e8de4432b202405458468b90dc6890d4cee128b3502e5b6cb4aeeeb,
+            0x5b43da7c8aa29af6dcaae57d070b49d29ce889a64a4ac183e85d55b366c805f,
+            0xbec98a034e3b8af7ba4861f1ad5a48dcef7c996e7a51c7cdde724d8f610e52,
+            0x2eb67ccfa29e2b422b9f84a5d0575fc435b30fcae303039480be384ee4ebe72a,
+            0x102bbdc21a3f147bf04eedee5d70bd084a7105c631c86ecd2c4e8749a13915ca,
+            0x274bc16c88721babfd5bbe8d8562c1bf127ae38915280fbb8e3115cad3582f79,
+            0x185cece417549b25283de04511f769101c8850b409d4928ab831611351bd9938,
+            0x13c73fb043f7e978bc9cfb55c7faacb4f4c823674abe17737059ac0a32c36007,
+            0x24b3a1d83308742b360c9c60595673e201cdd4cef5a4145c933c4e5969481d70,
+            0x18b5ae94df9ec97aaa2a8f0f42425bcccdc8266a070f866ef0f48d7a3744398b,
+            0x20eb398cb958cc2ccc7cb1fac38501abbe38169b2d8522d9e5f099f2d5905cb4,
+            0x1e588dd3ec8b0d252c2c7c0c78a02b22bbbad1f4dcaa2e78a8b8eef2f4e29344,
+            0xf8bf3bd6c22ba3b1bf3ab2e3fb40818cd4217ffbaf294ca42331d4e3043a0a6,
+            0x388c9fcf30fc2841d648f46bad01dd10bee9dc184d25eabc9f617021109cec3,
+            0x2bb7f397c5941ac67befa8b232f15c8853dac263da793555441a90cec83b6454,
+            0x17f389b52f9ea7a98874a4a31ef6a7beb43fb17db0e499250bb3f0181c59fb21,
+            0x3a2090eacb897a31fb10561d560a9aeec24b7ad14d17b145f20c875a0b28c7c,
+            0xc398534f0eb580f1fe4bf64553389e67cca4714399430e09619dcbee17ba099,
+            0x7095ac9fda46afa7f181259e3635feffa7f11ee63f3ee777a5cebf4822328c4,
+            0x2046f7cf1c8f13ef2b69cbc8bc0d5d809f82568abe2b33d1cd060958b1ced683,
+            0x2c274136a5de2849de6e7f92f9097296501acb68d56138fbcb660c4cb0f69107,
+            0x1c4d5178acb5c6b6eceef23afc6f16ec7b0383094cb6467e8d0f4507b3cf74c3,
+            0x65b1447d0d64ceced116785b92c63a6a7dd9701507dcbe8b909325e28f7b8d3,
+            0x2265d7e244881220c81a193d979330409c9bfa333438951340e023e7b72a1961,
+            0x15b12b355af7e05637a1c76e67f9cec6fca8a6449b37669f6850502256b30aba,
+            0x1a1522fecc6ae028e4d3e3029497b88f35c2b48c687af168ec2582d9075b4387,
+            0x22f56e79e81b7496e472a641a053c414bcc53b0a9350e2589240803076f58f26,
+            0x202ddb66d0988994e7aabad692ceac4e2324672a17ab8417d1ee278afd17fd0c,
+            0x12b0701e8813c5b21a8e30208f8f1158b96cd428ae77bdea72f84510f73edfce,
+            0x1e63fd20e706e1407c8838ceb26b84c9fe693fdde0eb1e1a9df7e84e53eeee7e,
+            0x20a16c5a86256deffd15af174c39f9d9aa11500676ac7e570088280dd1896259,
+            0x1c8f8bf8e153da55ad5aca2eaaee38da563e0435c0f2f37c27558fb9bae0a3eb,
+            0xd7732687bb7bf5f3aabcfdcc4fbb67e159c1983213e416c3880124fddf187c9,
+            0xcdd04475a86999a2edcbbbf8264b195e108b3b60b6475d835f6ccef9e2f6865,
+            0x2fe65586cd4e754b4c63a88c2ed3f9ba0e3bfa43f547b41153560c214fe3cbcd,
+            0x503cf963c8273604e659128ec29261f62399815d98c56dbf4f2837c727ad4d9,
+            0x1ee48ea27839061b78379936f6d97ca9400b393ef5fdf38ef1475c8742cb334c,
+            0x1a423f8d8fc892b22d7cd5bf0197c575c579e83563d04859d73b2c1c5c0413f9,
+            0x69a0da50133e9952f00e61778972a7be0e8d8ab76c95616ae465636abb97ec7,
+            0x1bf7879dd42f2cbb91c65a0976356f67964c2f94dfbf0e44cf2b9909165d8614,
+            0x1b23dccf485822065c8fc0afe610be7164e25056267f6c4a805fffd4547a0b98,
+            0x2ebe90d6f6fdca420e0c2e004ce5c5a4409e564c9c4f3671e3011f627bec7c2e,
+            0x167cd6930535a816dfebe81d20c376e77687760f3a2fa0da290b2f4d6c6863f7,
+            0x8865c10f4a633c54ccc8b68b79df285f19f1210374cc64e3c8a966d4f90264b,
+            0x1de902fbc0bf01951ca25abb39d78894721b37e071851b03a72cc6b833b7893b,
+            0xe3eca007699dd0f852eb22da642e495f67c988dd5bf0137676b16a31eab4667
+        ],
+        [
+            [
+                0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+                0xcc57cdbb08507d62bf67a4493cc262fb6c09d557013fff1f573f431221f8ff9
+            ],
+            [
+                0x2b9d4b4110c9ae997782e1509b1d0fdb20a7c02bbd8bea7305462b9f8125b1e8,
+                0x1274e649a32ed355a31a6ed69724e1adade857e86eb5c3a121bcd147943203c8
+            ]
+        ],
+        [
+            [
+                0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+                0x20e3e914631964e394d269ae59f17efee3fecee512cbb163d32cc760be574bd6
+            ],
+            [
+                0x2b9d4b4110c9ae997782e1509b1d0fdb20a7c02bbd8bea7305462b9f8125b1e8,
+                0x10a44ed9dd9ce568563394632833d8633690d329ae737c8c7220a9b197ee3f46
+            ]
+        ],
+        [
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1fd20dcb58503896fd52998d6a5be6f12ec33b3cbd590c793e45de825ff8cb5f,
+            0x8c8295df0ba11861e97f0cdde8f202a7096c1e6452d33d64a11b5be4e0a1efb,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2458ee6d7c526073d165d2b08b95cf8947e20e05a76bc12b401b996421e89835,
+            0x18c235e6e723390aa65baf06ffa557829f78a2fe1fbfb44eef84e938209c92f9,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1868e106689f8ea2e9c561b4b192899d07b52e58595c393436c37df24976a584,
+            0x2d5161804f0ec6445cb8904ad3e8e9ec21153350df4075c9cbe840b7b609ca92,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x3510550ddf6292355c690f03b9b815aab2dc3f4914612da7ecb79ddcf7b0b90,
+            0x9a2e7bb3b278a1d5f264a26345ad8365efe0058403d8a52909cf2d5f6ee6170,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x13dd4148c491a166b015a7a4233f4e488ae94a0e6439be66fe149b50b55759c0,
+            0x1d2d3b261f5beb3fc010f42ec3825649d90150eee4ce55dc9f86ddf110295550,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x221b4477678dad4e2abcabb47eb5e7a4129190b3855ae4eecd8ba68643ff77e5,
+            0x16b76448e9855f165f2043f5f09bedf1830a4998ff45ebc25f1d40e8e8fcd6e4,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2a10b6a2cbae9578142cf66104b69e448eae6d3bd53ac8602363460e2286c92d,
+            0x2db84dba4a9d96cebe94dfb1d59edfa58ccfa871b9c067c522e31949b69f2bec,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1ca9bbf26402238296ad897ec1a55b4fc273cf20c1f68f03d5c149be890e7b60,
+            0x283d37fa5e35d25c83d1b9d34ecb00cd03848ca730ace52f367e0d7b5fde30d6,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x349057941b141ceea5a063a0ff8ab221271e618a174e5d8009ab5f9c791d960,
+            0x1af2e1d98c3c09908503883d3b9ed50fe8958eb1e5d6538016c344d40070efc2,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x5b7bddacf4522b0aa3082e2c05448962743d0023bb6402291f592e6c1da4679,
+            0x1fceeccf337e8a903cf6a0c21a6445da7ff8c4a0bc78909c7e704131c8a35241,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2f30a25f4d843e28afdd850f31d1920ee058dfb6d91c322fc960473e917a6768,
+            0x1a55160bf49a4936bcc59162617026194574a89e5857751b68f3c08f7c07ce87,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x19c66ee887ab4763b17573b6ad192b7df1af24f54761998b03b342b95709041e,
+            0x1a82828b7f87eba7f5f8624b31e1115506ab3e723266777b3789c9104f9c781e,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xf506d3199d96083de9fc4e71b250825e84a242d81ae3a81d99debc7faed3385,
+            0x1cac7482d91faef657db9072a97567ff172374d99987a8b24b2c04472aab9f83,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x249b26b1d4e333b23f3192f0e4f52884ee63d489ee153ecc3216939a72848150,
+            0x13d1aeb10b225e2a8b97131154407d1bf145972dcd3a0073339dca336180dfb1,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xb90f72b7fcf867eb2e0f9400787d1dd52720cbc14a7095784e4116624d16df3,
+            0x25e346edd8dd55142abd2135951398230f0c8d08bc5c365c5a6cd70011a8f39,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x263003b8ed502577c6427b0b4589ef6ceb87b4e21b7c424e587f2630a7b868a2,
+            0x2d92ef6b8bdc53dd1b6c5b1c92e5a8248eb9c12255b910ff89c09961ec12ead7,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2eb36b6d0bfc593a8d6d9459a7af04f0b15bcae4181bbb123543870c11316681,
+            0x1e48bb591146f461c1d2f085f3979139e37f4a5c2354952c833b2791f59034e0,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xe759913751418871f0351ee180ca466cf8a03f541079c1b51bb001550d8162a,
+            0x1e45e194b16936c5b1f81c72eb0fe8c62e859c4661b14b7e327503cf49eca55b,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x28c8b58c9e4cfb830a51af4529318b6269c4f6ac1867ed1174ce4aefc57fbeb3,
+            0x255b293fcb1be27d9e5aafd4cd28c26746fc3520889367eed1355c2c41b93016,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1db1367a8e37c5597835365bbfa66f6ecf40da775a54c35d5c94da70415544fe,
+            0xcdd97951c2f0b885edc683b9db74f08df61286578a69989a9fed7ca34c5b4ce,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xe4d4e42cacb9fa6745c6dd3630ec5a4cca8a912b7ec28576ab3ba29c57306c9,
+            0x2141a925c279e4c4e351641744750d4702d90ef2137d1905dada0bae3c7b3af6,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x8f9f9b3abc79ed89c20597cfbfe49021119cc50648ce401dc50cb042a54d167,
+            0x6af6c072313d868cd945c9f0eb7d4eadb24c8d4763fa042952b99353df2b236,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x8b43c97bf4a40b4f376d1fa0c5e6e6955cbf9ba301f878ed3eae4ac812b79d1,
+            0x11e0e607ac6781ca34a714e6c5b7a4f839852377446520032420e2abe16115a7,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2dd7f0e1b303f425cb7e6b1c30ca428b3bff751e7b651152eb4de008b2c00da6,
+            0x107d7f92d1c6a24068b917120f993ae3ee84349aaadb71eaa4128b349812dda8,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x10ab9e8e4ec9ad5fdb1166c64ed2fc3223c7e16dd982f66dcd820a7861ae1463,
+            0x3000d3b3ddb3fb864ccc729984468a7317397713303544a84d7de1d209d25cb1,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x17610359e624e7feb3eede8099a1dc45c4a0c6b2debc2dc8f200fa27a0da6ebd,
+            0x2affce5b7a7d8c5aac04f6c2708794cd01a8439b65d74df5982d24ad2a944eb8,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2d439fbefe8d2b65ed32658bd21fc5604408d5fb69e1f64965e5895ca61c6e09,
+            0xb51cc2a1b1c329fd72a286d4938540db3cfc4320de363a3f68a7935cd193ab9,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1468ea2868d31f7ebafe78af8c24656a3185963272f34c51d5e2695c43bd3247,
+            0x29553949324f27f4fa7bd734920e9be7b662a0ec5797fdd4ed3fe19464879b95,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xd9780ee7d395f7c977fd4b86329f6cd720047a7f9d1672d18d2cfb428343afa,
+            0x210a098afd451fca3997860e220106c7487f4716831dfff78036de18f17cb31d,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1cedcfe2751b360e73d6ef5af88cd5b75a2b2d97c571889a0dda87a0dd90ad81,
+            0x22719f26e16723c1bd45a619e91836c340a304f3648672f90de2b047880aee03,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xae0cec959c4c7859f670f19c7490f8eef6ad66346e04613c1350597be000be2,
+            0x177560de731482bdb7316c238bc38f20a16cd03edda2e0393b1c515ec64b0727,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1f19a267da0b8fc2b4850a4f458add5514edf0aad6f7a7f175aef0b98e816a40,
+            0x1da77cdeff9cf822b54509031ea2888f6f398051ae1870afd3770e7724c09f31,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2d1e17aaaa96743665a869970255c267ba338cfd43ec9b33ecaa764f48f17a8,
+            0xc376a8ff1da39dec980316ea26ef66fae5c86877a8f82266c14670024329d12,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xbb856048ef43a77b39560adeb3c7a9a783db5cad8e3f422495a69c56680a79,
+            0x1d81808a3c73be1bb2c99b6403f3ac4a532c88d29ad652cbb20061656006c19a,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x15e52ae83a9db363d24cc5900df8ff0b81e445d4409a0e2aafd3223c354add62,
+            0x2aa2fc03cb5f72e237f7d88ef66f765a159be533354ffb88751abb8885203ad4,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x10afedad881a1da7dace5c69546d0890bc35f41992b1062a7c7789b03ac932c0,
+            0x1d18193701979ad24042446e947dfedfad22a6e7d4f6bde875fe2d8c882c858a,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2f0b8457690e4d9770beb0300a09fc7001cd417061e826bc450dd96d7b24f36,
+            0xdc31897d61d70e16870e0b02b9776bc53b8b9848be3062f8da18ff9d981effb,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x203c94bb7694f9cdad3a14a7603e3cb69c141200fd46bdc9ebb0d5d73663525,
+            0x2b778a231f21f8a6cdaa3c84372933e610eb985dcc81af9926fe8b09f1afc81f,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2c8a0376c766055e6a9d5272a2466a28faa7e359db111e84d98b2138c8c9d5d2,
+            0x2ffda33f5b85a4fde16ba590ae0cd49fce4ad01e095f94f49138fe44aaa8c778,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x318af53cfd822ec2a7f4d40614f72fc6cb27f44067fb58d15789bbe15444844,
+            0xd24997465c5b23d4e7436a4ecef2f91ce9f8910b6fa8a4a3ba6f884bd7206cc,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1ea39e4d9edebf65d648e42880b396a6becfa66b3c5e47ff9a33577a3d2a658,
+            0x15e4e016c94a026fd9ede9bdcf11268f7735cf5ebdbdd4a092fda1ee8b50f2ff,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2ef185c4b1cdb7072a82fd43fe4bb145c4dbd04973fb3ef76e757b00392eac9d,
+            0x15cedc8a4ef6f7017d1dd3d92255beb54f1d7d1e3bb0204cb07ab81c71435902,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xdbf148ee8983db0c117b111270f1c2c8219565733684494eaf5ce0645e5749a,
+            0x2842f44ddc05dbd5b319b1efe6b3eabced380b99ffc42dfb08805ea2b4c48aab,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1aa07e7ffa4a036f1b7efb2e124e75028426fdf5f1e4fb8bb62e1ebf3298af2c,
+            0x1e5a2abded8c7022a8ba97ea683b605d09f017fd43e92296656561eb96d25d32,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xacf3ab02c018573bc3d36b0cb73de6df11e8cc1dea223e98a2a0cfbc028d2af,
+            0x1bab48ad2c31dcec5fcc6df1f02dc4164f949202122673b06105f7ff1beabb29,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1a36af3ad1c61cddc06a2a4c6967dc004b589a4a8b358ded11a38cce6a7f31c,
+            0x125e0e822514cf49536fa643a66e1d2fa6788cb5b4805c9cd3cb69a584e0d8d2,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x85be8486ecb3dbf71d63940d8d689f9b142434a14d5d4f8c93d7d0f17bfcbd3,
+            0x275651360d88063b2feead8bc71ae9c002d5db9822ab63b058f11e0d506b17e3,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xf7eb245596d9ac5ecc21446ed94c80289db1e1f9f620c18f7815b247b228a6f,
+            0x221862a04a00f406bc67f7677ab459c9d887c8bb88091513f0fc2fb103ad549c,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1bd575603b7085afcf0a588a5fadf8705cda7eb1d4ab7e70137dbd47fc26e3a2,
+            0x146d1d176245ff772db8575d986a82e931079de61e67184c4158a6f62db446f1,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2202ec1e7fd85c4749393664f024d578d392d59cb12a42e2ef4fa728da4cd3a,
+            0x1c0e72693a0e12bff0ab3e12a1203c846b5dfdb9dd5ba26a7309c6970371421,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2b3d8733bb4872b6cbb0bd83378163ab14a585dbf5ad9758c07948de056071e0,
+            0x185d12aa30aed1a0575b9d3dcee6332f4fa34643a429cfdd8de0fdc87a29640e,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x1b394227301f28bee29bd3dfc35dfcc8e1c60ec6dd944dd33593a9a77675f641,
+            0x15b1cfd522bdc418f6c08a3deb114a4ff48854b4a496537d41eb3a325f2265e7,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0xbca3aef46833e8a30a9db0a16b59abc619800d2da15da01dd5a0713ff4cbbb8,
+            0x529062596e51b8ca2c2f8c7cf4adff0853150015e2e6b4ce7af212500f5e6ca,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2fda517f4261325a7366a45da1e847cd150d022be2982eb6105dcfc31fdef60,
+            0x1fec5a09cea4d25e5b7ff9d2fbab64d264db993e8d8629b7154a1539d12dd1cf,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x2d87776eef5dfabbe5605094751af17b831717fa3f8e01943b74d1a9a42eb1bb,
+            0xd257a437910f3995aebd0afb9be584967afa4188c4684958f68c39f9f01ff19,
+            0x66f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5,
+            0x98f0aa06092ed2cbcbac004f90799e6e1c32fc24a9f0b6066f8d7289716aee4,
+            0xcc57cdbb08507d62bf67a4493cc262fb6c09d557013fff1f573f431221f8ff9
+        ]
     )
-        
 }
+
 // noir-fmt:ignore
-pub fn x5_3_config() -> PoseidonConfig<195, 9> {
+pub fn x5_3_config() -> PoseidonConfig<3, 81, 285> {
     config(
         3,
         8,
         57,
-        5,
-        [6745197990210204598374042828761989596302876299545964402857411729872131034734,426281677759936592021316809065178817848084678679510574715894138690250139748,4014188762916583598888942667424965430287497824629657219807941460227372577781,21328925083209914769191926116470334003273872494252651254811226518870906634704,19525217621804205041825319248827370085205895195618474548469181956339322154226,1402547928439424661186498190603111095981986484908825517071607587179649375482,18320863691943690091503704046057443633081959680694199244583676572077409194605,17709820605501892134371743295301255810542620360751268064484461849423726103416,15970119011175710804034336110979394557344217932580634635707518729185096681010,9818625905832534778628436765635714771300533913823445439412501514317783880744,6235167673500273618358172865171408902079591030551453531218774338170981503478,12575685815457815780909564540589853169226710664203625668068862277336357031324,7381963244739421891665696965695211188125933529845348367882277882370864309593,14214782117460029685087903971105962785460806586237411939435376993762368956406,13382692957873425730537487257409819532582973556007555550953772737680185788165,2203881792421502412097043743980777162333765109810562102330023625047867378813,2916799379096386059941979057020673941967403377243798575982519638429287573544,4341714036313630002881786446132415875360643644216758539961571543427269293497,2340590164268886572738332390117165591168622939528604352383836760095320678310,5222233506067684445011741833180208249846813936652202885155168684515636170204,7963328565263035669460582454204125526132426321764384712313576357234706922961,1394121618978136816716817287892553782094854454366447781505650417569234586889,20251767894547536128245030306810919879363877532719496013176573522769484883301,141695147295366035069589946372747683366709960920818122842195372849143476473,15919677773886738212551540894030218900525794162097204800782557234189587084981,2616624285043480955310772600732442182691089413248613225596630696960447611520,4740655602437503003625476760295930165628853341577914460831224100471301981787,19201590924623513311141753466125212569043677014481753075022686585593991810752,12116486795864712158501385780203500958268173542001460756053597574143933465696,8481222075475748672358154589993007112877289817336436741649507712124418867136,5181207870440376967537721398591028675236553829547043817076573656878024336014,1576305643467537308202593927724028147293702201461402534316403041563704263752,2555752030748925341265856133642532487884589978209403118872788051695546807407,18840924862590752659304250828416640310422888056457367520753407434927494649454,14593453114436356872569019099482380600010961031449147888385564231161572479535,20826991704411880672028799007667199259549645488279985687894219600551387252871,9159011389589751902277217485643457078922343616356921337993871236707687166408,5605846325255071220412087261490782205304876403716989785167758520729893194481,1148784255964739709393622058074925404369763692117037208398835319441214134867,20945896491956417459309978192328611958993484165135279604807006821513499894540,229312996389666104692157009189660162223783309871515463857687414818018508814,21184391300727296923488439338697060571987191396173649012875080956309403646776,21853424399738097885762888601689700621597911601971608617330124755808946442758,12776298811140222029408960445729157525018582422120161448937390282915768616621,7556638921712565671493830639474905252516049452878366640087648712509680826732,19042212131548710076857572964084011858520620377048961573689299061399932349935,12871359356889933725034558434803294882039795794349132643274844130484166679697,3313271555224009399457959221795880655466141771467177849716499564904543504032,15080780006046305940429266707255063673138269243146576829483541808378091931472,21300668809180077730195066774916591829321297484129506780637389508430384679582,20480395468049323836126447690964858840772494303543046543729776750771407319822,10034492246236387932307199011778078115444704411143703430822959320969550003883,19584962776865783763416938001503258436032522042569001300175637333222729790225,20155726818439649091211122042505326538030503429443841583127932647435472711802,13313554736139368941495919643765094930693458639277286513236143495391474916777,14606609055603079181113315307204024259649959674048912770003912154260692161833,5563317320536360357019805881367133322562055054443943486481491020841431450882,10535419877021741166931390532371024954143141727751832596925779759801808223060,12025323200952647772051708095132262602424463606315130667435888188024371598063,2906495834492762782415522961458044920178260121151056598901462871824771097354,19131970618309428864375891649512521128588657129006772405220584460225143887876,8896386073442729425831367074375892129571226824899294414632856215758860965449,7748212315898910829925509969895667732958278025359537472413515465768989125274,422974903473869924285294686399247660575841594104291551918957116218939002865,6398251826151191010634405259351528880538837895394722626439957170031528482771,18978082967849498068717608127246258727629855559346799025101476822814831852169,19150742296744826773994641927898928595714611370355487304294875666791554590142,12896891575271590393203506752066427004153880610948642373943666975402674068209,9546270356416926575977159110423162512143435321217584886616658624852959369669,2159256158967802519099187112783460402410585039950369442740637803310736339200,8911064487437952102278704807713767893452045491852457406400757953039127292263,745203718271072817124702263707270113474103371777640557877379939715613501668,19313999467876585876087962875809436559985619524211587308123441305315685710594,13254105126478921521101199309550428567648131468564858698707378705299481802310,1842081783060652110083740461228060164332599013503094142244413855982571335453,9630707582521938235113899367442877106957117302212260601089037887382200262598,5066637850921463603001689152130702510691309665971848984551789224031532240292,4222575506342961001052323857466868245596202202118237252286417317084494678062,2919565560395273474653456663643621058897649501626354982855207508310069954086,6828792324689892364977311977277548750189770865063718432946006481461319858171,2245543836264212411244499299744964607957732316191654500700776604707526766099,19602444885919216544870739287153239096493385668743835386720501338355679311704,8239538512351936341605373169291864076963368674911219628966947078336484944367,15053013456316196458870481299866861595818749671771356646798978105863499965417,7173615418515925804810790963571435428017065786053377450925733428353831789901,8239211677777829016346247446855147819062679124993100113886842075069166957042,15330855478780269194281285878526984092296288422420009233557393252489043181621,10014883178425964324400942419088813432808659204697623248101862794157084619079,14014440630268834826103915635277409547403899966106389064645466381170788813506,3580284508947993352601712737893796312152276667249521401778537893620670305946,2559754020964039399020874042785294258009596917335212876725104742182177996988,14898657953331064524657146359621913343900897440154577299309964768812788279359,2094037260225570753385567402013028115218264157081728958845544426054943497065,18051086536715129874440142649831636862614413764019212222493256578581754875930,21680659279808524976004872421382255670910633119979692059689680820959727969489,13950668739013333802529221454188102772764935019081479852094403697438884885176,9703845704528288130475698300068368924202959408694460208903346143576482802458,12064310080154762977097567536495874701200266107682637369509532768346427148165,16970760937630487134309762150133050221647250855182482010338640862111040175223,9790997389841527686594908620011261506072956332346095631818178387333642218087,16314772317774781682315680698375079500119933343877658265473913556101283387175,82044870826814863425230825851780076663078706675282523830353041968943811739,21696416499108261787701615667919260888528264686979598953977501999747075085778,327771579314982889069767086599893095509690747425186236545716715062234528958,4606746338794869835346679399457321301521448510419912225455957310754258695442,64499140292086295251085369317820027058256893294990556166497635237544139149,10455028514626281809317431738697215395754892241565963900707779591201786416553,10421411526406559029881814534127830959833724368842872558146891658647152404488,18848084335930758908929996602136129516563864917028006334090900573158639401697,13844582069112758573505569452838731733665881813247931940917033313637916625267,13488838454403536473492810836925746129625931018303120152441617863324950564617,15742141787658576773362201234656079648895020623294182888893044264221895077688,6756884846734501741323584200608866954194124526254904154220230538416015199997,7860026400080412708388991924996537435137213401947704476935669541906823414404,7871040688194276447149361970364037034145427598711982334898258974993423182255,20758972836260983284101736686981180669442461217558708348216227791678564394086,21723241881201839361054939276225528403036494340235482225557493179929400043949,19428469330241922173653014973246050805326196062205770999171646238586440011910,7969200143746252148180468265998213908636952110398450526104077406933642389443,10950417916542216146808986264475443189195561844878185034086477052349738113024,18149233917533571579549129116652755182249709970669448788972210488823719849654,3729796741814967444466779622727009306670204996071028061336690366291718751463,5172504399789702452458550583224415301790558941194337190035441508103183388987,6686473297578275808822003704722284278892335730899287687997898239052863590235,19426913098142877404613120616123695099909113097119499573837343516470853338513,5120337081764243150760446206763109494847464512045895114970710519826059751800,5055737465570446530938379301905385631528718027725177854815404507095601126720,14235578612970484492268974539959119923625505766550088220840324058885914976980,653592517890187950103239281291172267359747551606210609563961204572842639923,5507360526092411682502736946959369987101940689834541471605074817375175870579,7864202866011437199771472205361912625244234597659755013419363091895334445453,21294659996736305811805196472076519801392453844037698272479731199885739891648,13767183507040326119772335839274719411331242166231012705169069242737428254651,810181532076738148308457416289197585577119693706380535394811298325092337781,14232321930654703053193240133923161848171310212544136614525040874814292190478,16796904728299128263054838299534612533844352058851230375569421467352578781209,16256310366973209550759123431979563367001604350120872788217761535379268327259,19791658638819031543640174069980007021961272701723090073894685478509001321817,7046232469803978873754056165670086532908888046886780200907660308846356865119,16001732848952745747636754668380555263330934909183814105655567108556497219752,9737276123084413897604802930591512772593843242069849260396983774140735981896,11410895086919039954381533622971292904413121053792570364694836768885182251535,19098362474249267294548762387533474746422711206129028436248281690105483603471,11013788190750472643548844759298623898218957233582881400726340624764440203586,2206958256327295151076063922661677909471794458896944583339625762978736821035,7171889270225471948987523104033632910444398328090760036609063776968837717795,2510237900514902891152324520472140114359583819338640775472608119384714834368,8825275525296082671615660088137472022727508654813239986303576303490504107418,1481125575303576470988538039195271612778457110700618040436600537924912146613,16268684562967416784133317570130804847322980788316762518215429249893668424280,4681491452239189664806745521067158092729838954919425311759965958272644506354,3131438137839074317765338377823608627360421824842227925080193892542578675835,7930402370812046914611776451748034256998580373012248216998696754202474945793,8973151117361309058790078507956716669068786070949641445408234962176963060145,10223139291409280771165469989652431067575076252562753663259473331031932716923,2232089286698717316374057160056566551249777684520809735680538268209217819725,16930089744400890347392540468934821520000065594669279286854302439710657571308,21739597952486540111798430281275997558482064077591840966152905690279247146674,7508315029150148468008716674010060103310093296969466203204862163743615534994,11418894863682894988747041469969889669847284797234703818032750410328384432224,10895338268862022698088163806301557188640023613155321294365781481663489837917,18644184384117747990653304688839904082421784959872380449968500304556054962449,7414443845282852488299349772251184564170443662081877445177167932875038836497,5391299369598751507276083947272874512197023231529277107201098701900193273851,10329906873896253554985208009869159014028187242848161393978194008068001342262,4711719500416619550464783480084256452493890461073147512131129596065578741786,11943219201565014805519989716407790139241726526989183705078747065985453201504,4298705349772984837150885571712355513879480272326239023123910904259614053334,9999044003322463509208400801275356671266978396985433172455084837770460579627,4908416131442887573991189028182614782884545304889259793974797565686968097291,11963412684806827200577486696316210731159599844307091475104710684559519773777,20129916000261129180023520480843084814481184380399868943565043864970719708502,12884788430473747619080473633364244616344003003135883061507342348586143092592,20286808211545908191036106582330883564479538831989852602050135926112143921015,16282045180030846845043407450751207026423331632332114205316676731302016331498,4332932669439410887701725251009073017227450696965904037736403407953448682093,11105712698773407689561953778861118250080830258196150686012791790342360778288,21853934471586954540926699232107176721894655187276984175226220218852955976831,9807888223112768841912392164376763820266226276821186661925633831143729724792,13411808896854134882869416756427789378942943805153730705795307450368858622668,17906847067500673080192335286161014930416613104209700445088168479205894040011,14554387648466176616800733804942239711702169161888492380425023505790070369632,4264116751358967409634966292436919795665643055548061693088119780787376143967,2401104597023440271473786738539405349187326308074330930748109868990675625380,12251645483867233248963286274239998200789646392205783056343767189806123148785,15331181254680049984374210433775713530849624954688899814297733641575188164316,13108834590369183125338853868477110922788848506677889928217413952560148766472,6843160824078397950058285123048455551935389277899379615286104657075620692224,10151103286206275742153883485231683504642432930275602063393479013696349676320,7074320081443088514060123546121507442501369977071685257650287261047855962224,11413928794424774638606755585641504971720734248726394295158115188173278890938,7312756097842145322667451519888915975561412209738441762091369106604423801080,7181677521425162567568557182629489303281861794357882492140051324529826589361,15123155547166304758320442783720138372005699143801247333941013553002921430306,13409242754315411433193860530743374419854094495153957441316635981078068351329],
-        [7511745149465107256748700652201246547602992235352608707588321460060273774987,10370080108974718697676803824769673834027675643658433702224577712625900127200,19705173408229649878903981084052839426532978878058043055305024233888854471533,18732019378264290557468133440468564866454307626475683536618613112504878618481,20870176810702568768751421378473869562658540583882454726129544628203806653987,7266061498423634438633389053804536045105766754026813321943009179476902321146,9131299761947733513298312097611845208338517739621853568979632113419485819303,10595341252162738537912664445405114076324478519622938027420701542910180337937,11597556804922396090267472882856054602429588299176362916247939723151043581408])
-        
+        alpha(),
+        [
+            0xee9a592ba9a9518d05986d656f40c2114c4993c11bb29938d21d47304cd8e6e,
+            0xf1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864,
+            0x8dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5,
+            0x84d520e4e5bb469e1f9075cb7c490efa59565eedae2d00ca8ef88ceea2b0197,
+            0x2d15d982d99577fa33da56722416fd734b3e667a2f9f15d8eb3e767ae0fd811e,
+            0xed2538844aba161cf1578a43cf0364e91601f6536a5996d0efbe65632c41b6d,
+            0x2600c27d879fbca186e739e6363c71cf804c877d829b735dcc3e3af02955e60a,
+            0x28f8bd44a583cbaa475bd15396430e7ccb99a5517440dfd970058558282bf2c5,
+            0x9cd7d4c380dc5488781aad012e7eaef1ed314d7f697a5572d030c55df153221,
+            0x11bb6ee1291aabb206120ecaace460d24b6713febe82234951e2bee7d0f855f5,
+            0x2d74e8fa0637d9853310f3c0e3fae1d06f171580f5b8fd05349cadeecfceb230,
+            0x2735e4ec9d39bdffac9bef31bacba338b1a09559a511a18be4b4d316ed889033,
+            0xf03c1e9e0895db1a5da6312faa78e971106c33f826e08dcf617e24213132dfd,
+            0x17094cd297bf827caf92920205b719c18741090b8f777811848a7e9ead6778c4,
+            0xdb8f419c21f92461fc2b3219465798348df90d4178042c81ba7d4b4d559e2b8,
+            0x243443613f64ffa417427ed5933fcfbc66809db60b9ca1724a22709ceceeece2,
+            0x22af49fbfd5d7e9fcd256c25c07d3dd8ecbbae6deecd03aa04bb191fada75411,
+            0x14fbd37fa8ad6e4e0c78a20d93c7230c4677f797b4327323f7f7c097c19420e0,
+            0x15a9298bbb882534d4b2c9fbc6e4ef4189420c4eb3f3e1ea22faa7e18b5ae625,
+            0x2f7de75f23ddaaa5221323ebceb2f2ac83eef92e854e75434c2f1d90562232bc,
+            0x36a4432a868283b78a315e84c4ae5aeca216f2ff9e9b2e623584f7479cd5c27,
+            0x2180d7786a8cf810e277218ab14a11e5e39f3c962f11e860ae1c5682c797de5c,
+            0xa268ef870736eebd0cb55be640d73ee3778990484cc03ce53572377eefff8e4,
+            0x1eefefe11c0be4664f2999031f15994829e982e8c90e09069df9bae16809a5b2,
+            0x27e87f033bd1e0a89ca596e8cb77fe3a4b8fb93d9a1129946571a3c3cf244c52,
+            0x1498a3e6599fe243321f57d6c5435889979c4f9d2a3e184d21451809178ee39,
+            0x27c0a41f4cb9fe67e9dd4d7ce33707f74d5d6bcc235bef108dea1bbebde507aa,
+            0x1f75230908b141b46637238b120fc770f4f4ae825d5004c16a7c91fe1dae280f,
+            0x25f99a9198e923167bba831b15fffd2d7b97b3a089808d4eb1f0a085bee21656,
+            0x101bc318e9ea5920d0f6acdc2bb526593d3d56ec8ed14c67622974228ba900c6,
+            0x1a175607067d517397c1334ecb019754ebc0c852a3cf091ec1ccc43207a83c76,
+            0xf02f0e6d25f9ea3deb245f3e8c381ee6b2eb380ba4af5c1c4d89770155df37b,
+            0x151d757acc8237af08d8a6677203ec9692565de456ae789ff358b3163b393bc9,
+            0x256cd9577cea143049e0a1fe0068dd20084980ee5b757890a79d13a3a624fad4,
+            0x513abaff6195ea48833b13da50e0884476682c3fbdd195497b8ae86e1937c61,
+            0x1d9570dc70a205f36f610251ee6e2e8039246e84e4ac448386d19dbac4e4a655,
+            0x18f1a5194755b8c5d5d7f1bf8aaa6f56effb012dd784cf5e044eec50b29fc9d4,
+            0x266b53b615ef73ac866512c091e4a4f2fa4bb0af966ef420d88163238eebbca8,
+            0x2d63234c9207438aa42b8de27644c02268304dfeb8c89a1a3f4fd6e8344ae0f7,
+            0x2ab30fbe51ee49bc7b3adde219a6f0b5fbb976205ef8df7e0021daee6f55c693,
+            0x1aee6d4b3ebe9366dcb9cce48969d4df1dc42abcd528b270068d9207fa6a45c9,
+            0x1891aeab71e34b895a79452e5864ae1d11f57646c60bb34aa211d123f6095219,
+            0x24492b5f95c0b0876437e94b4101c69118e16b2657771bd3a7caab01c818aa4b,
+            0x1752161b3350f7e1b3b2c8663a0d642964628213d66c10ab2fddf71bcfde68f,
+            0xab676935722e2f67cfb84938e614c6c2f445b8d148de54368cfb8f90a00f3a7,
+            0xb0f72472b9a2f5f45bc730117ed9ae5683fc2e6e227e3d4fe0da1f7aa348189,
+            0x16aa6f9273acd5631c201d1a52fc4f8acaf2b2152c3ae6df13a78a513edcd369,
+            0x2f60b987e63614eb13c324c1d8716eb0bf62d9b155d23281a45c08d52435cd60,
+            0x18d24ae01dde92fd7606bb7884554e9df1cb89b042f508fd9db76b7cc1b21212,
+            0x4fc3bf76fe31e2f8d776373130df79d18c3185fdf1593960715d4724cffa586,
+            0xd18f6b53fc69546cfdd670b41732bdf6dee9e06b21260c6b5d26270468dbf82,
+            0xba4231a918f13acec11fbafa17c5223f1f70b4cdb045036fa5d7045bd10e24,
+            0x7b458b2e00cd7c6100985301663e7ec33c826da0635ff1ebedd0dd86120b4c8,
+            0x1c35c2d96db90f4f6058e76f15a0c8286bba24e2ed40b16cec39e9fd7baa5799,
+            0x1d12bea3d8c32a5d766568f03dd1ecdb0a4f589abbef96945e0dde688e292050,
+            0xd953e20022003270525f9a73526e9889c995bb62fdea94313db405a61300286,
+            0x29f053ec388795d786a40bec4c875047f06ff0b610b4040a760e33506d2671e1,
+            0x4188e33735f46b14a4952a98463bc12e264d5f446e0c3f64b9679caaae44fc2,
+            0x149ec28846d4f438a84f1d0529431bb9e996a408b7e97eb3bf1735cdbe96f68f,
+            0xde20fae0af5188bca24b5f63630bad47aeafd98e651922d148cce1c5fdddee8,
+            0x12d650e8f790b1253ea94350e722ad2f7d836c234b8660edf449fba6984c6709,
+            0x22ab53aa39f34ad30ea96717ba7446aafdadbc1a8abe28d78340dfc4babb8f6c,
+            0x26503e8d4849bdf5450dabea7907bc3de0de109871dd776904a129db9149166c,
+            0x1d5e7a0e2965dffa00f5454f5003c5c8ec34b23d897e7fc4c8064035b0d33850,
+            0xee3d8daa098bee012d96b7ec48448c6bc9a6aefa544615b9cb3c7bbd07104cb,
+            0x1bf282082a04979955d30754cd4d9056fa9ef7a7175703d91dc232b5f98ead00,
+            0x7ae1344abfc6c2ce3e951bc316bee49971645f16b693733a0272173ee9ad461,
+            0x217e3a247827c376ec21b131d511d7dbdc98a36b7a47d97a5c8e89762ee80488,
+            0x215ffe584b0eb067a003d438e2fbe28babe1e50efc2894117509b616addc30ee,
+            0x1e770fc8ecbfdc8692dcedc597c4ca0fbec19b84e33da57412a92d1d3ce3ec20,
+            0x2f6243cda919bf4c9f1e3a8a6d66a05742914fc19338b3c0e50e828f69ff6d1f,
+            0x246efddc3117ecd39595d0046f44ab303a195d0e9cc89345d3c03ff87a11b693,
+            0x53e8d9b3ea5b8ed4fe006f139cbc4e0168b1c89a918dfbe602bc62cec6adf1,
+            0x1b894a2f45cb96647d910f6a710d38b7eb4f261beefff135aec04c1abe59427b,
+            0xaeb1554e266693d8212652479107d5fdc077abf88651f5a42553d54ec242cc0,
+            0x16a735f6f7209d24e6888680d1781c7f04ba7d71bd4b7d0e11faf9da8d9ca28e,
+            0x487b8b7fab5fc8fd7c13b4df0543cd260e4bcbb615b19374ff549dcf073d41b,
+            0x1e75b9d2c2006307124bea26b0772493cfb5d512068c3ad677fdf51c92388793,
+            0x5120e3d0e28003c253b46d5ff77d272ae46fa1e239d1c6c961dcb02da3b388f,
+            0xda5feb534576492b822e8763240119ac0900a053b171823f890f5fd55d78372,
+            0x2e211b39a023031a22acc1a1f5f3bb6d8c2666a6379d9d2c40cc8f78b7bd9abe
+        ],
+        [
+            [
+                0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+                0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771,
+                0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7
+            ],
+            [
+                0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0,
+                0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23,
+                0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911
+            ],
+            [
+                0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d,
+                0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa,
+                0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0
+            ]
+        ],
+        [
+        [
+        0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+        0x1e6f20a11d1e31e43f83dcedddb9a0236203f5f24ae72c925a8a79a66831f51d,
+        0x1bd8c528472e57bdc722a141f8785694484f426725403ae24084e3027e782467
+        ],
+        [
+        0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0,
+        0x2d51ba82c8073c6d6bacf1ad5e56655b7143625b0a9e9c3190527a1a5f05079a,
+        0x1b07d6d51e6f7e97e0ab10fc2e51ea83ce0611f940ff0731b5f927fe8d6a77c9
+        ],
+        [
+        0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d,
+        0x11e12a40d262ae88e8376f62d19edf43093cdef1ccf34d985a3e53f0bc5765a0,
+        0x221c170e4d02a2479c6f3e47b5ff55781574f980d89038308a3ef37cce8463bd
+        ]
+        ],
+        [
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x3f0815ab463f1b76ee25a9b8768b3231a89752f427f4f063ab718e707576b31,
+            0x15648bf46f60d82954c7e33029b3617357012a3d3b1d34c8e008859f1dbfb317,
+            0x127e00c2253de07818ca7f2eafdd7564d05ea850cf61f1daa0cfefbf7fbfba85,
+            0x66365afd18a41ef9382fc0b1d265cb4d3ce470a8cbbb878f7d48051630747bd,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x219d14f823513140dc69a96f7fe7e086f4fa24c84e57dcf2b099715c4404aae7,
+            0x3a30bfbbf2cb86d4a6a63a8050d91f9f14f4d33696d37ebaefa9ac2302132d5,
+            0x2121bbcdeaa33a35b0270fb7d5c9f94edad5a84d74b06e3385104b0b41935bcc,
+            0x196b544fbeb0a792cfbb82c289e579b7cd5580c2e338a389d053ef8b3d10e70e,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2809c3a1547c0cee89c1db270ef479c26973ec73edb4bd4e7d907ea0202f560f,
+            0x11c34446b083ef92ca157585a02b8b342a4c67175b31f4b5d40d4e96dfc5c8f1,
+            0x253ea0b33a8bf3b2367c030e3289cbe0f6242ad7709d90b86d9d8026e2e39925,
+            0x30467dc1930f6afe90c89d4007ad29fc4f5a19c006d1030438c16df85637bd5f,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2f9d4b55495f7e377e20e6f5a3a88af7aa6a536458b38bbe13c8ebfbbba54f44,
+            0x1d9e9d5c736e3151f11d36d499e7e093d8ee2353be18aad54cfd03ff0feac4b8,
+            0x124b617b43e598f9ebf622f7823a3de7d1bfedb87e097c315f343de301e54841,
+            0x198e7cfc66ae45774055cf073bedc945a5f9c5b19cae08d789cc5748ffe199b2,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2eac25b3498dfadffd124ab3aad57789eb945ba57443099c5bb6c27ed977fe24,
+            0x1ee02c175cdfe1871b378305c1bb9c904e8af1d4454ed3550b3c6ab5f4f90126,
+            0x616f8c34c607266b29ea8f9d2dfa47ff6fbb1d9745c48609fa98301d0f679d5,
+            0x181d68b0a188504958b9f19cbbdb972a853e51ed385e4883a43a42832803370b,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2d5397ce863464a25d6b7f5b015d579181d1ce2f24cbabf6059e9327f5ba7004,
+            0x15bf817491b94d71e8912940cc0b80277713e7d32da2b6591724d8dbd4bc2618,
+            0x2a7cbd11460b177ab76feab28b69485ac8cc687740bc910994a3827d29c08714,
+            0xf7cd5ffa4661730ab56e447fae5cc1763cb462da80a85614c237b290de9d502,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0xe0766004b4c4176eb13273508eb6575f768137d86d305be644ce04531008100,
+            0x625fa7145813481f6d148be6b9c8bb7b54ee3c1afac00104e1f763000b9924c,
+            0x7c5472508b459916ee0f5461aad2e0b19cd9c7b184f515b65136318ce2c6a5,
+            0x567375470d189b693ac77ab3fb7557231d53073951d43c54685879cb7a89fcb,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1d0406bcbec83f8d5165f56c063e42108ad21f51ea4bfc71601174ba5c7b8bcc,
+            0xc02b18eef22332d280a8aa1f86405f3375f06342f8696ee7c73b46c63272cb7,
+            0x17c1fc174cd9a6ebeaa7add2f801a664823509ad4fd1b15aad053a55ad6da4cf,
+            0x5f843c23024eb1dab7ebbc86709a021aaa6caf433f7ed258a08638e9584b32d,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x22df2420697ca28b5cc51c53165e002727b45ccd90a55c87589f792f0ad8cb37,
+            0x2f1438303a7b49d473400aaedf0f48009fd3af804b76be86417588efc4d7302a,
+            0x2323d5fcf2da8965c6b2b7b4fbf9a24bbaa7f4dccd35d5ca6155c5463093b23b,
+            0x26c85b9dfbbe48fe83b753a5e7336b9f40f7b961e9c54f94e37700073d4d26e,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x31511000251ec86feb38b5ab4e335f070b271df4c20979528e41d65384c318f,
+            0x18e588324a9bbaacb42fa69e5d90a0c0e27cd16b941e34a60ff5df9a26c03af1,
+            0x2642b5d8e16b953b070635775c8d3c9498357d6ad9bef2e7d99f03c10ea1f95f,
+            0x21fc313ba11c60e8e84ff60db906a0f031189b0b48335c4221f909aef836c133,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2d3562e3d4b42bc6890b698cc6ab89f7311298bcbac6e4e9f2f4d93d06dae151,
+            0xa74ef541d360e842e3e0b6ff7e5c7c77934a5f67616f01c189d886dfd2e0808,
+            0x140564b53e0a812ac3983d6e3b433afa43f434087d9e754967c2c9b1b02caf8a,
+            0x14709e32d98ae4cd18b400181e71ab9759c436c8e83fa6993adb6f2db6bba9d0,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x734b2366c59e394423f179e1266dd392372db4f2dba651f4a619a4b52bdc010,
+            0x11fb2d705c94b08d5ad3e3c5fb6629abe963ed92913642c7d02d7e71088fd2d4,
+            0x27d03abf5c1f290e5d715eba19371050ef6eb7f78fd84be834e4cc3618059484,
+            0x13ed9e9e6b452df27fb3353cfc2cd63ebe817f212a39c6a8bb9b441ac1395861,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1319c51cf37aaa10246cdaaa04a12e88795de4452604263a7c5b79ab99cbd23c,
+            0xbca25588d187b7f9dad839f2c8cb526a4cf444eebbd0e715b6cea019ac3f2,
+            0x1d837ea0341c5964181226874b923cd01a069b493f02f7a3c01be23cf51d593f,
+            0x1b41ce9ed3634cbd42c427ce4c5c83774149e2a6dbd25f24012090db7de4e7f9,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x671f0e3b674ae7cddc790ecc4e946f4bca74b98b78a127c7b56bd6673f1ce1f,
+            0x19fc073797a39b272e40cd30615f55fefeb682c1ac14143071d0449a5426e4e,
+            0x17bee47d262a497fd1f7c5c6d5a7c70fa4209480bf5d97311c5096619e9fd13,
+            0x2073cff92d3141b480763539cff2978a4c7944721cc937ba00cc8527274471e3,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x3bd7b3e2c1885877f43182a55a91d48f9c58d152e730fe2c7aa46b1fa663baa,
+            0x226ebc9a538b5bbaff128edfb9bbf5fa0ceb100719a14c8dfed9ffbbbad9b6b7,
+            0xd395f0b08b9fede0373a06e1552c0e634a49572af1d830dc6e394e8a5d3b21a,
+            0x28242439b524540a30d49b68e19e31ba5284bd3bcf1e0f2f41f77d5331f99ffa,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x370d6fa19eaac142d2de034801ab85e0b457e129e91f929754b48c6154d4df6,
+            0x9a16f573b3280f390762abf269579eaa37939bc0c753feb0a2b2e0bcbde1659,
+            0x2228e360fb5b162b496ac443f98127ee3c0021a690b71b268d99981368231d97,
+            0x7e42c2ca633d2c49fabf83991476d209431e34d8032b6a1b97675f3c567f944,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2ce12d7269663770c3cab85a6215a32eed35fda1d8e9d753a50fe96097724a9f,
+            0x3d7427704c61e2009eeb9b1b45a0125084bc4daf70973a7ba0b2231815b15de,
+            0x10f8abf0764185861c1267fcf4b4b33ca096fb4ddc4626732d86921e553e69c6,
+            0x17ccaf6f26f7267a025d7cb456e3aeb251a1a620aaf6568a5c95644c7c5914cc,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x63bb306b96310051385c3ce00ca820ad0e3651a6e55754d59de6df28cea4d51,
+            0x1f761ee5553c5e86f2c304a18095ab7403242e0b65e608bc920cf993a4169974,
+            0xdc5f00bbfd7c1d9a23c0e666859ba6564bcde8761b45717cd6bdfc09de4e8f2,
+            0x6de511520e277b7df07c3536381c13eb44cf790a230abc391089760bfc40ef2,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2a134348c8660efcf9ef54863e70528a1fd4481b50a1fe21f24a8c06e10cca03,
+            0xaeb5023bbb9a64c4bd80089e99edf8ed5f6f1ffb63a7dbba1b33520bcfce37b,
+            0x141a6d0810366ae225ecb5f0bfdc9995406c5960ab26155836fc51fb7cb933d1,
+            0x9d2ea05ef54dadbbe776f404dca6626cc0b2539990bc0b8bfe87497f1e2c5b7,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1e56d244a8e41be5d104d5f8ef70891d22d4a5432441bfe8ff1a16e91719cdde,
+            0x1d4f020c57c4f14aec908b2f99b5c4fd5e09447fa85c2fd68ba4d5c5f50c7b49,
+            0x763911a3a92a4f0e09f4e14cd03398d8d82a1e09db80fb0ee1e833764c18fd3,
+            0x12857275be2fe6b9ba2ec68f9061643f1fc5d9a2c5e47e55684366e54b302946,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2ed11ccd2e2e2376655ffe9a96c4b81adc0a60353c5d83d4d0ebf50d1bbf87c0,
+            0x3e31de8958e82645b320d5e3e966ef4726d5b1c2cfbb4acd288a21543c6d594,
+            0x11e880dfefdbd08858ae890046533d58da28a608d7e905366ec2ca4a36e71963,
+            0x1835b275deaed2d00704a9c3cc21ab7a44a34662978d53c190dc25e969a507b2,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x68b75315e25ed4ace5a4a9480e1d82ce5d44f76f1324240419f372ff8d3c3f5,
+            0x1b7ef7d04aec73d62b052d2ad12b92a4268fccd795c839d698ad3b22823274d1,
+            0x28c0c848022a90606f6193ff5501b57216b670727f4b8efcc240d30bbaa9f03f,
+            0x13bda49296cbcc51686a7bfb1c39f3f254370985a16660efd6e5d82d4f068e1b,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2e7987ea8204389d11eb10b34265e378a945729f86c3e0e2fd38490d3a594141,
+            0x826d4a2324ad3aa4b2b45c10a190fedef702aeffda3226ce5415fffd03935c8,
+            0x2dbeee85eaeaa9fa3675ef541c9df7bb964a85435c3b59685f93b434036ded,
+            0x227ee7a945edaee6919418ecb3279b11e6fa44f5f5c5abfb966a4be599cb86c7,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1d0a6d1a9519877805ac90d696faf2a5ffadc23986de8c698d541471c7244220,
+            0x2208aaba508ae816da4f333b7854fbbcd10eea1db284ec3e9f4de02b25f6e9d4,
+            0x28a58901035b2c99e36a7d29b587a215c9e59268e2f8e01a175720971ccf04ec,
+            0x112f6d8d42b0a0d123a07865ca1376df317a2a14ffc0191226f38a8adfd6238,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x8c6eb19c016d1833174dda182d266d5c727f97fb4d01f1daf906b6d3c6e2308,
+            0x1359d2d6c8b5a116d0b38b95f9c642df75b1be9a48c8698ecfea9103f73f1879,
+            0x10c5052ec67ab9b6a467c1cc1878d91aaa07aacf7725f8a5ed42b699c4af3ca7,
+            0x583c4d292d54f3cdb708803e6338fc6afdb188d5d4e9f060193823684c96c75,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2d94a1c55be382151a4054c5b96322e7bcd1fe2b3e076e16ee2c18bfc06f57b4,
+            0x15e3402fdde8770fb997369579c1b1703ef77c671927ead80dbc64dd2211c3ec,
+            0x185be98784817f22f7b21e6b867d5a71b5000bef8bb902eb302677e20a727be3,
+            0x18db4321c721c03666ed8927c89890aa8aad1b00c054547b5ca14cd94de467b6,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2a852b6247f5d61f0c390b3f3d799188528849bcd2cd0aff4eb2134a039b5126,
+            0x2510aeed51b7f506e65fb9a18ee0124aa5276f6de1cd771b165930204da58f22,
+            0xf2074a32eb8260fb5bd3a236f03a47b47b7fb54dcad1d7977d6486513bab5f2,
+            0x2f4c69297866bd45a8270e19941926cec3531c9e12c4c2c84971404bfa044090,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x154668727d2dbadf05d083a65093c0d0e92df5fd5f3fd75e9b792c562a37473f,
+            0x1e6ffc5d6a1ff5dc4fd77fc5ab5c8c4e8d3e2e375bcd1194a91e5b0f7b13cadf,
+            0x2cf1a1d7c44309109d75acbc9395cb8398c8b2d428538571fafa389da29990c6,
+            0x140fb39a89f26f6d87cf76cd5ce8da47aa5d8a023e24cf016ecf64cf793c9880,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1289d13d58a17b5bf0712b201fb3cddfce2c16dac159990b8298a93a8589f9e8,
+            0xf45cf974d2c9edb5781e8d3d207adc8370cf56bc5218749610920fe98b2db2e,
+            0x11909c81a16518046b79edfd24f5abcc585a81d1b333568b8687a1c9eceb44d4,
+            0x2990b23c81882f7709f3b891a0e3da4d6917672f2d5a1041fd7bbd6792330d16,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x609551b14716ca3cd5560e0821e7285e0a083ea9a16dc102ecf461e4aef7277,
+            0xc8c1abdfab99d03fd93dced2467354b6175de1755f4f93dc0880eaa08d03f77,
+            0x138bd098c4923b9fbd02f33f8bec6c730db3fed298ec09f78a7a55d08f2e0b10,
+            0x2e61e4bc021630114673f0f77161ae55dcd0b45ce07d9ae3f21bb5a3190f14c0,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x124860913e3df8f65a9c4060ce3297c626abd1c22401c905ddb408260d8e910,
+            0x13807f89c394a133ec104804d955cbe125f24c5701d98286c6ac8b7ed052ec8,
+            0x2e88d1a6938f0788132aa9eeaec08d2f59aa444050c8f4c4e85578abb0fc2fe5,
+            0x1f3d24f17cfc6050a0cbf64e1f1787e2257be3c3ba607c2e8fcc1f26abf3104,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1fe1cb0e2ae169f83b9d4f133d41fb5b3fe6c76a82a916bfd9b62f82f0f8d0bf,
+            0xef79351229409cd353329221229827e19946f3d8d1c48bf5e3377f9177071f3,
+            0x18fb2e46fc1b90fe1c4893ef77a9d111507551883127860e89088608373beda9,
+            0x77afe2579f42ec14c32ef0761e23a3cc0ad6263a68c5cb61916bd57120d1868,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x79769092daa5a752642c04ccf8a6ea54e2ac9836fdd65d248b186f1490b7b99,
+            0x1d8bf229c19968f0254eb6e09c5c8bfd67eb9734606b676b663c76cf76bab4a5,
+            0x2a33b7d855e7fe55f93556e49e4b37737664f14236f17256428f29f6ec1bddad,
+            0x25b0331d7e2b15af4ec161c86e84ba6ab2056077e7aa7536340dc3187ccca8b2,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x762098f5fe26598ccbf45e4810211b0ffcf8ccbb92c16e2f4f13f22342474e2,
+            0xe234d720d70b2886d0da4c007b1bda42362e144185c70716dece2b6172c2514,
+            0x1d82bedccd2bc8a06e3742e720b7fec2ea72182f11c0c60d135c811152aa4b60,
+            0x480064d4b3eb0ada5e9a3e7d05930b7c3397fd6b94d481314bd1c690a17c979,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x10a892763b3cca9ef7593fbb1140edc8c8e4580568560cf41867f7464fb0c11a,
+            0xb5ec64548ea841ac921f9b2553680785978b315667ae4714dde4cd7f4de8b91,
+            0x10554aca4e348e5949761bd7131dfaebd78010edd030e1a9ce3c65c9db931d46,
+            0x15be66f38d86b0998b93655462b1f475b9be9de306e150d4ac648fab3db0cff6,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x176ad3600fd3491182d182957ffad01bf6c26e9d4ab0c23caaf308e427d3dbe8,
+            0x2b6f355b3dbf65f09335001d705ac125e3beb20f4fc11bd3ce82b5cf0af2e6f2,
+            0x1c85c06a6d5d40d81d7c89edefb32d1a8448c51288fa296b6de9ff788c77451,
+            0x20e1e876c4746a0cbd9a51d76b2e25f82361c389e43f7d1f51a70aaac2460d79,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x20e46219f684186d2a024b637bc35a29ee3b08ce737701392d987dda9217fa08,
+            0x2ea7279db9f2aa0f654e987907277c24480766367a8bd90e28be0f2ed6091367,
+            0x136be2a7f18924c9362096d472bc75ca0969dc077c9171b1641be95091780f74,
+            0x1ca2033501baa3f73067c4300fb0f51119ed5736fbc8f1f6c924baf0df5a0e9e,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0xa82f199c2505277ecaa75e495f34e3525824f7a4a9d9fa1da810832b48a50c7,
+            0xecf10485307b4bae92fefb0d7f7782a9f37a2722e7ed9eb7925a2dea580b7d5,
+            0x7b642138dfd6a6dd12aa22f08a8296d68615c8478f13af16aebbbb339a3936b,
+            0x1d9dda43a25593ffd2256d34921fb86ed70e760ba76d61e9cbc3b6dd0f1a2150,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2f1af228520c8b751dc91136c91c6bccd5367eb08213d392958ce2fd3d7d2fce,
+            0x1fecfe833ad540455c6d6c1ab3de4abae61ada625a1a2b6b18551a45a6cde123,
+            0x18fc8e608c735b2b3b0d7583460227575657ff8a77abe637bdd3ad28e4a23c88,
+            0x28f740bc1182e9706ebf03cb3f53aba8a43ce0b618783a5586388a7547faa815,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x47998cc0af5a26b94ad301e4b998d29e960a4851cfd13822bed35b7146966a4,
+            0x1b5f1525b31db911dda43e415e1b9a3a9725c7b52e880ee130a14a692b777b70,
+            0x275a83fa5d19b4535f65e965a90eac9bf770ae9bd1d7b1af945fa57ed5c8de6e,
+            0x2e8789257ed2cbcccb430568e49bc9dc2a563359808c9897ce3e40a6f6a27aa8,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x927f46cfe80feefeb2721a4c09e9d17f60c34500dcd6e41e2925a39c8e2c7c1,
+            0x1f868ae04832a5dbc37619bfe6ab6a97fd8fb2cfbc1ecf9e0e484bbfe7698101,
+            0x9d7a11e27d2f53109b73f745b2defed65d94ba80f308fb19ce6d56c9b45eff4,
+            0x282d857cfe8da3b5104e1c2823fb7c5b9a7b25924fda5995b0c351aa2b879dff,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x20ba8a9fcec815b13f349ff830ae663b27576e135c0744f6987fb0f6ff49c217,
+            0x11b6afc91e32f1ca4589fba12e657d226d57b471ddd2ab1b66a8ae4dcbfb136e,
+            0x2e666402ac9cc588316e335c7d93db344788eec2c72ddf3f908141736cebc3be,
+            0x17522e0e9e64f795a202a110e283faad7057aec5c9ed9a1a74920f2794f18595,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2d2ed17f7a1f3ee9e20b470cad4cc7319e6adb40e2ff24b7878cb9878edbd3b9,
+            0x1a81efb19d7e1edaa96fa276e89e85d08f75e54a8136f4d73c937da16c7bf9f4,
+            0x27ff57c1ca847e57210a7b44e52e5630f299c5f451c7a0d515a16bb3bd33e237,
+            0x1c1a8e22230abcd13c5be96031bfa167840d117b3c6a5a0a11be26a7f5fb1a94,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2a1c3f15d4927c843627a9cd533e4250d81e7774d2c32b59d5836f9c19a5657,
+            0x2ddbb7239eb904d81c52499b37cb4be1af0373a10ac112e185acb219899357e4,
+            0xdff198393085a754e0d6faec54be81d8edf8bc25edadab48a86fad6da0afb60,
+            0x10d50c2473146bbc76275fcc589d038dec8db28728789f28b6d5f504bd1645ca,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x61e8328fb5593f92a53dfd40e1022e6231ba45948506282536b08b4476c1538,
+            0x1b589243847198ded90b644bee31ac58067debf3f07d3c51cfa5a0dd9f6d9784,
+            0x4b00c0da1f851e59863b053bd4c6087190f0bdcced99d5ce6f67a420a3bd1f7,
+            0x239941a46c2b93d9126a70163009a7ac27f8a8d42e35018b3bec8cdcb5ddfd67,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x204f26ca7993b03ac2c35377cb0a3712bfc9bc3ec0bfecb4e87ef6814acf2ea2,
+            0x85aff9c7fdadba039d832d8be165a1e5747cf7308d515e348ef117e926d721c,
+            0x249042a8dc111f27c4ae9db044c0b0b3f10e57d05e093158efd375df00ea2068,
+            0x6e799bcdf2b4a74542854f3029803e2f84550665203327b3e0825977413e96b,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x1cb3caed4bffb6aca9f4d2c002921bc3fffed333cae12085c612496183b87996,
+            0xb47e9755fae480128a128bfd4faa6a3dd6ea03cab566889dcd99e84d310d51c,
+            0xc7e4cea365c2061920a0c9fd2c360a6506293bc024fd1ca3f0bb730da886a4f,
+            0x21da1f701bac77bcbbaa30d964d6f6f63dbe1b20d9d6988c8dcd7ba4187215df,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x9ae612e8ba1ca1370905fb67899d10db86b47bd19965b6edd1a9486e3c6cc55,
+            0x262e1e0b56cac47fc150f284491190e6aab75445b0c99373fe1f7a0e3b95cf3d,
+            0x234bf4a7dce7587c2c87c293e3bb7c9e2a7bfa5f29fd4ddeaa5d3f67491d34bd,
+            0x2f6cbac694c886b02d0a527cac744fb658d2690e213d7432eee67f6cb69f70c2,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x22accb18b7c49b4b7bb8c9fdf78b7aded52aa1842fff818d9a3300876dec3ad9,
+            0x81e2f0652f898c6d659f22d2c77be302eabd9182a0b3d3cbf623a1df7f8f2fc,
+            0x12c0a25e70d006eccea3ada75d669b8c534b962890f3ffc016b3186ad675b935,
+            0x10ef9c23848128cc2fd6fc869df24d7ab56efd349edd56f49f8d4f2381df3259,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x2161cd280772819dd4a81262b71df1bcc2c1d41b9491e0620bda347962b240f0,
+            0x2cebb0ae5108318eb406590041b5248292533364f799bc41b7f4fdd12cb8d38a,
+            0x2b2092f86b5979a7fe4f7c22d9561f3bf2852283a656880fb759e08709a0a62f,
+            0x1566b3402d774b8c08146188425a442450cfc900cf643e7382b2d8507a065fed,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x11a316aa31607f268fb4c56d6c57ba01627c3635fccf8d3d1a163e601d1a0173,
+            0xde7ee069c934256b782648b560e595408a5e8434644609152e353d9c2874e44,
+            0x2d36f4029245704cc84df0297708c5e5845c36ae706c72e67128b8949eab1af,
+            0x1b8cc326b5ee160f53198c217fb34e899bde46cd82dabdc284d7951d546f858,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x27625da0f73ea07110689fb2187b71694cbf9203fd4ddf8a96ece85407550ebb,
+            0x1cd8338a3e5b1ad7cdc0da581a6950f6dea349c3edda06cb99ba025b94e4790d,
+            0x5ea02d65b209f6da763856c94b6438c78a8aed8d3e67e877a10a84072741a56,
+            0x9f7cb68d4e388f85366cfcf284a895d8b6250ced627e810817743ce03330a55,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x18c6230ddc0f896827b043f5e58dbd1aec13995a202e4ebcdfeb969e9d5c1212,
+            0x73a6114b997285e1a91c0a0fdccdaa8452e4f07bfd2e1a10578232096db6dcd,
+            0x2e78746340b2a6d222c6a1fc0838adf5fe013f39b1660ce7a3e7742b2f37be7f,
+            0x7aa27e7150baddd06303ad8e5e4bf4249b7ea846553def28e675259d3e5c851,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0xb66fdec210ea4eabf623d2712cf4d9fa90273ccb4643f680cbc98345715ead8,
+            0x2fb6a29d9f394a589b633b8a4d6be51c9c0601ce0b140be641acea41c49aa5e3,
+            0x29025cc66fd041c4fc845e9c1c2cd1288569fb243d049bd675a69dc889b2ce2a,
+            0x150963f0aca9bcbe4126214ab9c627a6f7ed731cfa695168b85d534b17be3f48,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0xed59780302257663f72c1bfc6656eb7b5bca2e47bec0d5798a08a32a61a8a65,
+            0x7e19cb8a893369b3d30ae188c767f391c11888a3000debfc8d30c06143cc084,
+            0x600c7d2b6946345e5f1eeeafb5eb8ec2b6ecfe528d2c052cd860afb4a3aa272,
+            0x596083b6c972bc13022a1f33d6523b4773f2cd0a480e19ea0125119f0385705,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0x210b5c36f27a07d97f98b9d8663d85db2e64513099a8e1ef6db21043631e24c4,
+            0x13bb2764bf1475cfc7bb9f3d563c5cc201c2489874e9159326a8f4930b7883f9,
+            0x202cf557d625c26080eb082862a76757287872b181e89997219e4b7576e24d30,
+            0xe561c3f8bd4f76e76d49e97142d220601fbc5a03d905a4728ea1f95fd8824b2,
+            0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b,
+            0xde20097480e7555471785de07bd9809d57dd859bbe827307c33ae9ed7890597,
+            0x72f2a6287fb984bb810df8c5788eebcfd2825613cb72bb80cde8edd76d2e97d,
+            0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771,
+            0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7
+        ]
+    )
 }
+
 // noir-fmt:ignore
-pub fn x5_4_config() -> PoseidonConfig<256, 16> {
+pub fn x5_4_config() -> PoseidonConfig<4, 88, 392> {
     config(
         4,
         8,
         56,
         alpha(),
-        [11633431549750490989983886834189948010834808234699737327785600195936805266405,17353750182810071758476407404624088842693631054828301270920107619055744005334,11575173631114898451293296430061690731976535592475236587664058405912382527658,9724643380371653925020965751082872123058642683375812487991079305063678725624,20936725237749945635418633443468987188819556232926135747685274666391889856770,6427758822462294912934022562310355233516927282963039741999349770315205779230,16782979953202249973699352594809882974187694538612412531558950864304931387798,8979171037234948998646722737761679613767384188475887657669871981433930833742,5428827536651017352121626533783677797977876323745420084354839999137145767736,507241738797493565802569310165979445570507129759637903167193063764556368390,6711578168107599474498163409443059675558516582274824463959700553865920673097,2197359304646916921018958991647650011119043556688567376178243393652789311643,4634703622846121403803831560584049007806112989824652272428991253572845447400,17008376818199175111793852447685303011746023680921106348278379453039148937791,18430784755956196942937899353653692286521408688385681805132578732731487278753,4573768376486344895797915946239137669624900197544620153250805961657870918727,5624865188680173294191042415227598609140934495743721047183803859030618890703,8228252753786907198149068514193371173033070694924002912950645971088002709521,17586714789554691446538331362711502394998837215506284064347036653995353304693,12985198716830497423350597750558817467658937953000235442251074063454897365701,13480076116139680784838493959937969792577589073830107110893279354229821035984,480609231761423388761863647137314056373740727639536352979673303078459561332,19503345496799249258956440299354839375920540225688429628121751361906635419276,16837818502122887883669221005435922946567532037624537243846974433811447595173,5492108497278641078569490709794391352213168666744080628008171695469579703581,11365311159988448419785032079155356000691294261495515880484003277443744617083,13876891705632851072613751905778242936713392247975808888614530203269491723653,10660388389107698747692475159023710744797290186015856503629656779989214850043,18876318870401623474401728758498150977988613254023317877612912724282285739292,15543349138237018307536452195922365893694804703361435879256942490123776892424,2839988449157209999638903652853828318645773519300826410959678570041742458201,7566039810305694135184226097163626060317478635973510706368412858136696413063,6344830340705033582410486810600848473125256338903726340728639711688240744220,12475357769019880256619207099578191648078162511547701737481203260317463892731,13337401254840718303633782478677852514218549070508887338718446132574012311307,21161869193849404954234950798647336336709035097706159414187214758702055364571,20671052961616073313397254362345395594858011165315285344464242404604146448678,2772189387845778213446441819361180378678387127454165972767013098872140927416,3339032002224218054945450150550795352855387702520990006196627537441898997147,14919705931281848425960108279746818433850049439186607267862213649460469542157,17056699976793486403099510941807022658662936611123286147276760381688934087770,16144580075268719403964467603213740327573316872987042261854346306108421013323,15582343953927413680541644067712456296539774919658221087452235772880573393376,17528510080741946423534916423363640132610906812668323263058626230135522155749,3190600034239022251529646836642735752388641846393941612827022280601486805721,8463814172152682468446984305780323150741498069701538916468821815030498611418,16533435971270903741871235576178437313873873358463959658178441562520661055273,11845696835505436397913764735273748291716405946246049903478361223369666046634,18391057370973634202531308463652130631065370546571735004701144829951670507215,262537877325812689820791215463881982531707709719292538608229687240243203710,2187234489894387585309965540987639130975753519805550941279098789852422770021,19189656350920455659006418422409390013967064310525314160026356916172976152967,15839474183930359560478122372067744245080413846070743460407578046890458719219,1805019124769763805045852541831585930225376844141668951787801647576910524592,323592203814803486950280155834638828455175703393817797003361354810251742052,9780393509796825017346015868945480913627956475147371732521398519483580624282,14009429785059642386335012561867511048847749030947687313594053997432177705759,13749550162460745037234826077137388777330401847577727796245150843898019635981,19497187499283431845443758879472819384797584633472792651343926414232528405311,3708428802547661961864524194762556064568867603968214870300574294082023305587,1339414413482882567499652761996854155383863472782829777976929310155400981782,6396261245879814100794661157306877072718690153118140891315137894471052482309,2069661495404347929962833138824526893650803079024564477269192079629046031674,15793521554502133342917616035884588152451122589545915605459159078589855944361,17053424498357819626596285492499512504457128907932827007302385782133229252374,13658536470391360399708067455536748955260723760813498481671323619545320978896,21546095668130239633971575351786704948662094117932406102037724221634677838565,21411726238386979516934941789127061362496195649331822900487557574597304399109,1944776378988765673004063363506638781964264107780425928778257145151172817981,15590719714223718537172639598316570285163081746016049278954513732528516468773,1351266421179051765004709939353170430290500926943038391678843253157009556309,6772476224477167317130064764757502335545080109882028900432703947986275397548,10670120969725161535937685539136065944959698664551200616467222887025111751992,4731853626374224678749618809759140702342195350742653173378450474772131006181,14473527495914528513885847341981310373531349450901830749157165104135412062812,16937191362061486658876740597821783333355021670608822932942683228741190786143,5656559696428674390125424316117443507583679061659043998559560535270557939546,8897648276515725841133578021896617755369443750194849587616503841335248902806,14938684446722672719637788054570691068799510611164812175626676768545923371470,15284149043690546115252102390417391226617211133644099356880071475803043461465,2623479025068612775740107497276979457946709347831661908218182874823658838107,6809791961761836061129379546794905411734858375517368211894790874813684813988,2417620338751920563196799065781703780495622795713803712576790485412779971775,4445143310792944321746901285176579692343442786777464604312772017806735512661,1429019233589939118995503267516676481141938536269008901607126781291273208629,19874283200702583165110559932895904979843482162236139561356679724680604144459,13426632171723830006915194799390005513190035492503509233177687891041405113055,10582332261829184460912611488470654685922576576939233092337240630493625631748,21233753931561918964692715735079738969202507286592442257083521969358109931739,15570526832729960536088203016939646235070527502823725736220985057263010426410,9379993197409194016084018867205217180276068758980710078281820842068357746159,20771047769547788232530761122022227554484215799917531852224053856574439035591,20468066117407230615347036860121267564735050776924839007390915936603720868039,5488458379783632930817704196671117722181776789793038046303454621235628350505,1394272944960494549436156060041871735938329188644910029274839018389507786995,5147716541319265558364686380685869814344975511061045836883803841066664401308,14583556014436264794011679557180458872925270147116325433110111823036572987256,11881598145635709076820802010238799308467020773223027240974808290357539410246,1566675577370566803714158020143436746360531503329117352692311127363508063658,212097210828847555076368799807292486212366234848453077606919035866276438405,7447795983723838393344606913699113402588250391491430720006009618589586043349,7626475329478847982857743246276194948757851985510858890691733676098590062312,148936322117705719734052984176402258788283488576388928671173547788498414614,15456385653678559339152734484033356164266089951521103188900320352052358038156,18207029603568083031075933940507782729612798852390383193518574746240484434885,2783356767974552799246444090988849933848968900471538294757665724820698962027,2721136724873145834448711197875719736776242904173494370334510875996324906822,2101139679159828164567502977338446902934095964116292264803779234163802308621,8995221857405946029753863203034191016106353727035116779995228902499254557482,502050382895618998241481591846956281507455925731652006822624065608151015665,4998642074447347292230083981705092465562944918178587362047610976950173759150,9349925422548495396957991080641322437286312278286826683803695584372829655908,11780347248050333407713097022607360765169543706092266937432199545936788840710,17875657248128792902343900636176628524337469245418171053476833541334867949063,10366707960411170224546487410133378396211437543372531210718212258701730218585,16918708725327525329474486073529093971911689155838787615544405646587858805834,18845394288827839099791436411179859406694814287249240544635770075956540806104,9838806160073701591447223014625214979004281138811495046618998465898136914308,10285680425916086863571101560978592912547567902925573205991454216988033815759,1292119286233210185026381033809498665433650491423040630240164455269575958565,2665524343601461489082054230426835550060387413710679950970616347092017688857,13502286133892103192305476866434484921895765252706158317341618311553476426306,686854655578191041672292972738875170071982317195092845673566320025160026512,9315942923163981372372434957632152754092082859001311184186702151150554806508,17166793131238158480636170455452575971861309825745828685724097210995239015581,4443784618760852757287735236046535266034706880634443644576653970979377878608,21470445782021672615018345703580059646973568891521510437236903770708690160080,6932852445473908850835611723958058203645654625170962537129706393570586565567,17078326120157725640173982185667969009350208542843294226397809921509565607842,19251873001736801921864956728611772738233338338726553113352118847732921831266,13062907978694932362695258750558734366820802962383346229947907261606619788585,16576609187793673559170206379939616900133457644695219057683704871664434872406,17140499059660867342372156843620845644831519603574612796639429147195776838516,16226688173010504218547945848523900236290532501559570164276462499487632388445,2806068123803905806401128967330263340459046260107112845068533446899070326517,17788735370835052317224182711467216134690146479710634688273650370951230404901,9840665370904113434661468973557421114403401847108482949465899631150766783733,17357287363046228581837055771327121704742940914150998420465281177406182088510,8956082469997974864521346025916496675956939495318858500685756691488425559998,10583741436561099911914917245130852199607666337956354910388730829023746895549,15241902639811607164983030447109332729761435946009172128089506810551693978973,10889882303914055687481932975789161945462141459528413507160087442461090813788,19789561133254944544821898921133697408237804586549835559829396563401674817160,20741336668287037026472434608739333171202674306575625457456116338034432647230,17864073449995977742930566850933082711031717858550870842712972350665650521079,6017691253505466300212182439349954426085752315661098358839308909771637792741,5209125836207196173669497054522582922896061838702136844305036341250990710540,8138726312837322624537330169363664364899441867118983214176695868443641051381,15491983986041746833254372934846748393213690608865689646440909282144232382678,5054332867608171303802774230688792431028169804536607979111644888500809938980,15427030776591294577308915282298854681562344215287630895931797573417982096417,21754057982677295571284116502193272661309010996970316384923307174180521790164,16265286590463120486705206231835953324076688991892805307349612983237844034032,17679791107777049796013011282788633179411040182820636236163074053597517790779,4281652562868629887097957174897458165728741859103571825874408386197225591996,9168010397863299719604788533602757515513214141450093775967322808686129400625,17584182367226175071087689123358883902969885218985589531538416263709138156515,15671512310414658663135385639435845966109237059155734764323312289873534719186,10536294659491685326297777845632759824567028904726211134518740400643540109527,13431319759608247201135260841651365578663315527795431484765940626659812285319,9584697124715190200241839387725546204368618031045071660911490086723434692561,5180327104839158483066851400960171505063442195966219343315555549982472660055,18888217223053385111625483360538133292128748730565502371803782424772027937822,19535732913737027522540340630296365525208404217634392013266346283017745945894,8577759627886344995887423695190093296190181539234301534326157005220006624466,16793670928407147476673650839110019799844249677846432113010280456483595763987,13926032620965299897272071104154310460519723329016284975305942957859374938463,4794697578055472890255676575927616606591024075768967985031137397587590174501,3529566190782060578446859853852791941913086545101307988176595267965876143250,3975008029239568933166738482470827494289192118694622729549964538823092192163,17739094873244464728483944474780943281491793683051033330476367597242349886622,7367136451127531266518046223598095299278392589059366687082785080179161005418,11175297939460631138047404082172242706491354303440776362693987984031241399771,21687543815463985355165197827968086406938428974327951792877419032069230058777,21156136641989461785420005321350884477682466566148802533375726181416623358719,17347558768803521970212188258074365309929638984714303299899732035040892048478,16293716234695956076322008955071091921491953458541407305955104663269677475740,4206144021605871396668976569508168522675546062304959729829228403361714668567,19988050626299122864942213847548542155670073758974734015174045163059179151544,747972634423324369570795147739377097591383105262743308036321386836856106229,4612470951309047869982067912468200581649949743307592869671537990797895413707,9630852913694079049153027193127278569487291430069466630362958024525616303220,17941539917430916523930519432495442476511211427972760202450248798031711471474,20332911350443969653703295317915788278109458962706923653715140186132935894113,21764801803055897327474057344100833670291402543384934706514147201527191846513,18792043166429470991157980448329308661526906138700725174612608941551872082876,12308177224490762720061048892842527800271687977085172836705858261595655154325,6234555076867437297776538521925679658360922070165740193866337972293380196151,4651047048822067434403056477377459986292934655827821636179452835839127581305,4762047093602693619418269784972874862577325737690375448572644958129932507374,12373514879531674477721132062882065826558811149582829246378921774344318418269,452512704634345955634014968317367844987135264395068376894497483188243356523,21642936370936057063268550589361090955573362743817395689260298777690935495218,16170209200627740434842090607802586195654207376087117044989637541681675086276,11682826760471401430136435257946377996085824742031456481961511737883954750045,20628055165039718158878805520495324869838279647796500565701893698896698211929,16438375313036818694140277721632185529697783132872683043559674569424388375143,4855690425141732729622202649174026736476144238882856677953515240716341676853,11680269552161854836013784579325442981497075865007420427279871128110023581360,7052688838948398479718163301866620773458411881591190572311273079833122884040,10339199500986679207942447430230758709198802637648680544816596214595887890122,16310974164366557619327768780809157500356605306298690718711623172209302167675,4572051236178600578566286373491186377601851723137133424312445102215267283375,20933392620931420860078756859763708025350478446661033451436796955762857910093,10145870387395991071594748880090507240612313913083518483680901820696866812598,11173854866888110108878560284050142518686158431744851782991510385755602063727,3895357290105797542988795070918100785105415165483657264407967118738833241858,16358886674154007883356717944805100413481233709808000948036974385803613296849,10544067501284177518983466437755150442726536257903869254459488412549270232123,10495171258604974589451578238018388630585794890815982293891430761424812600427,13820724103604550843562070971473423552484851063169471886037640613650155173554,2334954333435579600152488915208745055087482119087065911968347050969338669409,15100284614446277058846085121308897497066957549089629374506920751044105723791,8493821960754696376711287628276980042183127459347650448500304251148421115590,18612435536889941393944858783110719304584209891406420832295898519317994950798,362101794940079733974215941991047456600874474038781578925062694203564740952,11020033081956343850903875701444955317664141075326494650405276926536449284939,9396289482656518627529185765935649373549564165735162258912975312413185691167,6879055176150676925438486069371149089824290576271090206945130252868108043422,12466610601804566637227883322591924115458766539177061670432424956205788935144,6570302110526154075173287644133038486970998888099669190857256824048085590052,20997862990590350605775941983360263378441519274215787225587679916056749626824,2642485040919927233352421501444361753154137311893617974318977215281720542724,18832940311494549247524002614969382413324906834787422940144532352384742506504,18751288968473015103659806087408412890105261892140397690496125593160830694164,13938622158186434739533995447553824444480420613323252752005511269934155122652,12878982657080117316101160964182202074759312554860119090514406868768962707099,13757859113119127982418426758782225628393556023865807897214601826218702003247,11817871682869491875135867072669251115204978941736982465520516648114811792373,11336448548896065624515261709306933490181794458266726453198857687608284871020,194970717714150352477887371297168267861902418496792228400198694925721020795,4999282817977533227652305360183045040853565298259070645110453061034932285549,17094174197873140035316532568922652294881600587639905417701074492648767414173,8484251464872873032022789624790167173458682056313339863651348894878144808746,10260366716129057466862964875306868898686918428814373470382979997177852668590,549263552864476084904464374701167884060947403076520259964592729731619317724,10052714818439832487575851829190658679562445501271745818931448693381812170889,1735373362835209096342827192021124337509188507323448903608623506589963950966,7998373949540733111485892137806629484517602009122941425332571732658301689428,9035170288660659483243066011612158174896974797912618405030929911180945246244,6458619567307414386633203375143968061892762498463026121155477954682976784731,12314261817227551876673777186352972884847144237148169773300066404053441924532,19869454329688183813243851218196625862680921049019496233616575272637276975230,20326917073492686652690019138603910654692396590122884746951129061818467704300,20403270805536666081472738304916561119325397964511536801752236086414818653063,2865941730880218719188224311916978807415673142487507504983320505748719154068,20614246027521726470902405957496110178017768563127335842405314212897493119848,12060194341463088508348622863463208827312128863463014006529428845777217660299,1128906798719793375274166820235650701301189774851381709919492584451845983197,19670876372911656158743764425809421400123168087389888660308456184201759209723,5647230694522866559497222129254930524469944430191328619422533907417776118543,318629082509194371490189248876734616088516535434806492900653650176451776632,13685970881538585172319228162662520285656571966985351768743970447782846353365,8283840607829148567836919316142994745766280854211662326632930274668867638198,8968895518159422029900464138741638511289476298837958524156654785428413265371,10061801991000917366002570579819627134666386452411986168205986791283562415829],
-        [16023668707004248971294664614290028914393192768609916554276071736843535714477,17849615858846139011678879517964683507928512741474025695659909954675835121177,1013663139540921998616312712475594638459213772728467613870351821911056489570,13211800058103802189838759488224684841774731021206389709687693993627918500545,19204974983793400699898444372535256207646557857575315905278218870961389967884,3722304780857845144568029505892077496425786544014166938942516810831732569870,11920634922168932145084219049241528148129057802067880076377897257847125830511,6085682566123812000257211683010755099394491689511511633947011263229442977967,14672613178263529785795301930884172260797190868602674472542654261498546023746,20850178060552184587113773087797340350525370429749200838012809627359404457643,7082289538076771741936674361200789891432311337766695368327626572220036527624,1787876543469562003404632310460227730887431311758627706450615128255538398187,21407770160218607278833379114951608489910182969042472165261557405353704846967,16058955581309173858487265533260133430557379878452348481750737813742488209262,593311177550138061601452020934455734040559402531605836278498327468203888086,341662423637860635938968460722645910313598807845686354625820505885069260074]
+        [
+            0x19b849f69450b06848da1d39bd5e4a4302bb86744edc26238b0878e269ed23e5,
+            0x265ddfe127dd51bd7239347b758f0a1320eb2cc7450acc1dad47f80c8dcf34d6,
+            0x199750ec472f1809e0f66a545e1e51624108ac845015c2aa3dfc36bab497d8aa,
+            0x157ff3fe65ac7208110f06a5f74302b14d743ea25067f0ffd032f787c7f1cdf8,
+            0x1b0f68f0726a0514a4d05b377b58aabc45945842e70183784a4ab5a32337b8f8,
+            0x1228d2565787140430569d69342d374d85509dea4245db479fdef1a425e27526,
+            0x17a8784ecdcdd6e550875c36a89610f7b8c1d245d52f53ff96eeb91283585e0b,
+            0x9870a8b450722a2b2d5ee7ae865aaf0aa00adcfc31520a32e0ceaa250aaebaf,
+            0x1e1d6aaa902574e3e4055c6b6f03a49b2bbdb7847f940ebc78c0a6d3f9372a64,
+            0x2816c4fa6b085487e1eec1eefd92ee9fef40f30190ac61009103d03266550db2,
+            0x17359fd88be36ba867000e83f76ffb46660634efbad15dcf4d4d502d427ff51c,
+            0xe3004cb44ba455a3f16fefbd0c026404cbac203c0f236baad879610b8661022,
+            0xa55f276af1ceb6ebc6c6820f334b26f11ca4af98c833bc1b496193d6b04a7ca,
+            0x1ee4b0458adcd4c4861a27adc1404a5981d320b6b8e20e51d31b9b877e8346d,
+            0x14315e2753e7fb94f70199f8645d78f87c194a4054e69872b3841da1b4f482f1,
+            0x2b7b63ecffd55d95c660f435ad9e2e25f266cb57e17ebd1b6b0d75e88a6a56d6,
+            0xbb56fa3e9fd48ab46d4e7295bbe1204b652ebe958221860f56e38db80d83c0,
+            0x50653bf5dd59edd6d15fa6071f5005057218b33a8f92a58b9c2656081249f82,
+            0x2c575423e24b522655c5a976c65d069287900c8d5825514098c5b13c86f1fcdc,
+            0x2ff3a2ccdee91e09a32f74232b704cdd99f72c1f78557a2ce568b07e218071d7,
+            0x1144734901a81c1543b8bc6fc9d365f50469eb89949491d3693dbe9c6238d90c,
+            0x1eff9a954e24bcd4af20b6ab74d89e1cd38bc694a9e75ea6da217a98db80cd22,
+            0x14707de7496c5638f97fe9bd7d485c20ead6bfdbfc0599791e49fad0301cd6df,
+            0x13d0de341ba819f90fe3ef1f7ce0a54d8538acdd9b3ef840a91d48ee536042b8,
+            0x26520ab1d20055daded712d59b07088458c18afbd0da58aee9f151a903372ba1,
+            0x68cb4827ac485fc6e7537a3c0a06d08a4c2790f5c65d9866d75296999f7495f,
+            0x7d6baaa2e587c21b03dfa0eb71136e2982cb389b438c8bc282748d0e674e89e,
+            0x15b92d36db02cb16b831eeab2e6ed75d126ffbc274cc3362370851526de13d27,
+            0x277b9ce89133de7b7918ad5fcfab7323ef5b9c1916b588cd7e5a0d814cbc3395,
+            0x2ae847b66b3c5d73b70b733040aa86c51f737092d65c3492d529000fa1802b24,
+            0x2fa3e8ae1fef974cded6aba6dc25cf567e16e0af29e675706643f21bf8efd651,
+            0xb1d4b9508cec4d19aa53f4efe46c57952dbd368fcbcd454a8b1087bc18a2088,
+            0x2d381014d01578b888b3273270babdc393ac392e7958be0478947fafa569bb0,
+            0x2e79a827c85406242523a94431007021bc865a45cabcba4368c41d4486fefec8,
+            0x207c99b7d594a5c61d7e60cc2365c4c0c804cd434098af6244f0a00c259b347,
+            0x119c124086ea58ebb83f14f262c693424360e97e6fb42ae8596badbe9edb2dca,
+            0x104ff38cca0f00173ccd0b68bddba09fc543f074f753bd8e413f8334f887a251,
+            0x2f5b5377bd156f89845811eb262436638dc038b8cb10e147a87df4c0e2384253,
+            0xf70e8e02d1d23968930a8e0db69b1c20204f3e3b4cecd101f81476d0b5ea996,
+            0x1ac4653a51071ae722f90a03f006d8575814db782b7f19f607dae4d56ad586b3,
+            0x12b12600e3bfd8e7bdfae5ef9c4f3805fa41e74acabf7de817823017a8b23db9,
+            0x11b9d19908919dacb7e0f8d0ba77286d417529a18a1d89c405ed1c30289fdd28,
+            0x2c350d245f4f75864744f88dbff8fe335b00f4fb688895c1363a7484ace820d3,
+            0x16a7f76fd2b2147db6ef94c22c78bff782de17ef73e52da7df82603f422b461f,
+            0x1d18d8024be1e96ec25626af06a139f6093545aa504033dac7e285d1cc3db3de,
+            0xc8cab1ad5998072945b9b88228f53c295466819fb94d8f6a9ed449be8f7c18c,
+            0x1a68d133d703cd406ca30041913ce3423c73b13384187ab1530109b756ad4f7a,
+            0x24a58b9e86ce823ff4c45342941417ff23d03c80fcdef9498ca0d860855e01a9,
+            0xe6315c93fbb89d38021148b6c35320fb793c41c6a4386d6aed6acfe2f952c57,
+            0x2c3806d99a69ce63299e876f5f218c7295d87224795d7568d558696e34c692f8,
+            0x59c893a771e94774d49a356494568dd376856ab89705dff25db8273860fa04e,
+            0x1166d9819c4faae8982243d0deb1f8977027d5cc56bf52ce260bec5e27e8b0f5,
+            0x12806fab3fcb09fc2b79406c3c203c4965fc7259112af2104312e1537327e0a3,
+            0x172015e0e33736058f60aa33e82d3dd73dc3ead89f98ded0dba35dcc1d8bda2c,
+            0x77ba18800d852d0a34f70ae8cfd68a080296bf9d47a1b40de7e6fd6392a0d30,
+            0x2094ecd768bfa8f0df0d78d0d946e1aff4a2d38e029e41479d6e3c0fe79fa8b9,
+            0xccebd302afe84c20ff774d3c1f650ca7cd0bca08baa1e261da9c7441a823f89,
+            0x5b9303053bb40c73671f5d55b4052e0d5549871f1b5283f01485a6b568cd05,
+            0x2527289084ab492275b4cd67d38311a2b816eaa68ee6bdb2389eeefd6ba4c721,
+            0x2222f9738290d8d5f2a3eacdad95f12cd4e7417ed2661b012f6448c7503877f2,
+            0x226c8208f26d69e6b7e02fe26557e6bd160fcbe27ee741fd1e581161c1789354,
+            0x216b208c0261f3c91faf609e15f7a9d4853e40d9204496b2441115d73c2941c5,
+            0xe0d660e046a259f3bad6829729b6ae3151fbcd75de33b122fe134ca3d5a4dd6,
+            0x240f039d2026b3266f39ba5c4ec48ac6ace88aadaef991498cd52daaa0ffbba8,
+            0x28c8cccf7b40a2c3cfd2eee0ec4d160a876a4dfeb408ffe333e92fa5e1ee4d79,
+            0xd7f81b4b46d4f247c4243f045a852cc957d2b2923d28eb2fa77b5a9844efd69,
+            0x2be432f87b2c5094a82c788457651dd8cdb0200ac3b42860cbf54475996b772f,
+            0x13ea39f2d63d9adae187af14dd07b533d45a63435e0ea4e5e555d35e70d4016b,
+            0x29e3b1afe1973be9cd1cf4b047325abfaa65cf2b98ff3aed47870461977ec921,
+            0x8db7d684e6b841b5e9692498f95a1f950a1cf1eb638bb4e48f3bc1a3c571197,
+            0xf4f1041a976aa05196da1c042124e3277ea1a28fb6eeeab4bec1243bd31618b,
+            0x5a9d0526d6f18c86b255f00e86ec34e7f8a26c251b51c21fe4c12bdc4c0ff1d,
+            0x284b0304dd6ce669bcf650c5ab85c89d4410d472aa6eb00df1b8d17e52f2f3ff,
+            0x2363e9b01a0163598962ff86907002f95902e725049294ca7ab10cc7aa3f06ba,
+            0x2c2db12647c4c0461dd3290a75c5f2fd8d7f115b3e040cb05dd7e3ad260d842,
+            0x2e3c42f671431f9560f3d0863ac445052422d5b993e9fda6b81486b14ffe3a74,
+            0x1d38441f228c0ce22ff2882560f5d7ee3b4c0caa101371cb7782ffd97af5fff1,
+            0x268141b0e49c59eab1d573ead4e2e1f379364dd133f2cec574c25ade2c794287,
+            0x2209cb2e187df1522810d3f28868da6cf52af9a65dbd7b806049f472d966374a,
+            0xa5eb2510e6f804d1830d7974ac1677d082034e5388bfaee91a319eca7c1ffab,
+            0x1cb2864c38800736f8f3ad98669d3ad7a9d5ee52138e96b8a7015e1089e36ae0,
+            0x2af8ed05bfc8f8ada547ee9bc6c7c6c5e8c15c6c0d380a3f9aa277273321b54e,
+            0xf85d1593b35be03f79b222885555a252bf1f0a3911d784132c49b1a96ac0f3c,
+            0x29095192ec53e0b859eba456295d95bc4567d351a6dad391b8b89707855008c5,
+            0x1a92efde1f5fa56aeb02b4c4b8f51ac80831f898c7843407113fbb6011177854,
+            0x2a05e8deeea15e4377c080aa70fd6a86dc73f3fdfa6b55f5610614c184b0b02e,
+            0x12119f3b019cc3fc46ecc80893e86f510b1dd4030b2ce28c9dadcd1e71ad4891,
+            0x42b6ffe687bc23a2bf6b73317286a543c60ed122fc225aae742c3a1c2dd3a1d
+        ],
+        [
+            [
+                0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+                0x2a75a171563b807db525be259699ab28fe9bc7fb1f70943ff049bc970e841a0c,
+                0x2070679e798782ef592a52ca9cef820d497ad2eecbaa7e42f366b3e521c4ed42,
+                0x2f545e578202c9732488540e41f783b68ff0613fd79375f8ba8b3d30958e7677
+            ],
+            [
+                0x277686494f7644bbc4a9b194e10724eb967f1dc58718e59e3cedc821b2a7ae19,
+                0x83abff5e10051f078e2827d092e1ae808b4dd3e15ccc3706f38ce4157b6770e,
+                0x2e18c8570d20bf5df800739a53da75d906ece318cd224ab6b3a2be979e2d7eab,
+                0x23810bf82877fc19bff7eefeae3faf4bb8104c32ba4cd701596a15623d01476e
+            ],
+            [
+                0x23db68784e3f0cc0b85618826a9b3505129c16479973b0a84a4529e66b09c62,
+                0x1a5ad71bbbecd8a97dc49cfdbae303ad24d5c4741eab8b7568a9ff8253a1eb6f,
+                0xfa86f0f27e4d3dd7f3367ce86f684f1f2e4386d3e5b9f38fa283c6aa723b608,
+                0x14fcd5eb0be6d5beeafc4944034cf321c068ef930f10be2207ed58d2a34cdd6
+            ],
+            [
+                0x1d359d245f286c12d50d663bae733f978af08cdbd63017c57b3a75646ff382c1,
+                0xd745fd00dd167fb86772133640f02ce945004a7bc2c59e8790f725c5d84f0af,
+                0x3f3e6fab791f16628168e4b14dbaeb657035ee3da6b2ca83f0c2491e0b403eb,
+                0xc15fc3a1d5733dd835eae0823e377f8ba4a8b627627cc2bb661c25d20fb52a
+            ]
+        ],
+        [
+[
+0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+0x2b257df708d2f3d6785ff39129c7f268c13aef87ee92e9096bd6bd8d2989a74,
+0x224a7cc70daf93a67ba74c0f2d80c5b0aea7ec1bb1f4e17ea21ff147c58b0a1b,
+0x18ce43c42faa57788e66b11b59c98363b6970c4fbe9206a0986ac7a4438b96c9
+],
+[
+0x277686494f7644bbc4a9b194e10724eb967f1dc58718e59e3cedc821b2a7ae19,
+0x27907df41fa277d8c74c3725e5b8be54f4b35d3d0b6e57b26ead3cde3d431897,
+0x1b7e85dfcfe013c45746d870fb2114991d43131fadbf80494c01d5b105d44a5e,
+0x2c1597f81dc951f0b27440567676ac64ea1b184e65eb25292cc4da61d8bf9824
+],
+[
+0x23db68784e3f0cc0b85618826a9b3505129c16479973b0a84a4529e66b09c62,
+0x2460a032cf84ecd1f57096c9d21f5d48d1b21abc6d70277d7a75946997aed17,
+0xc7a2ae4396db1838e5cb1ee490a768c1777efac919031924ab242d19be92806,
+0x8c2147f957a152ffc37eec7b1cb029c07ecfabcc84489502a6e052aa6f94288
+],
+[
+0x1d359d245f286c12d50d663bae733f978af08cdbd63017c57b3a75646ff382c1,
+0x2456b3c4841aabbcc4bcb4950dae4a0f8e60cf0511decb8b67afdabeca0dc590,
+0x1a2e45b92aba8f36f92110d68941ce37d39fe27d02b794d53f7b961b7ed377c5,
+0x182d95b63ec720b3af3a3bc6d0a6012d4885ba5754f32aa1f1d92ba130fe5745
+]
+],
+        [
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2ca7b911ea4f6a11da0bd5e72ab3cc621c5908b59ff3d76c609ea9c2fba8fa41,
+            0x2de5f3a5bbe5b20d77ba6a6f8ffe2db01ff5000901b9ce0140df133385fd9506,
+            0xa150cdbffe3c60c7a52cefa903bbee4d3846d24339f926c3655cdf9f81f67fb,
+            0x2026ad7e03636deef47934dd0d5dd29d87056d172e993bf5e96d6a3bb32d2e9c,
+            0x232507a3d48ca163c5e1b6f5bf391141524733d9cef80d404fdf78393c90151d,
+            0x1b16b96e6aec89d326a5a6c18336ec3c56e7189f8c1fe74c5c46074b865a1d83,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xfdf5d15426498ac82411ff8a7a3884894f02c5242eab1dd7fdfca1cfdabd35b,
+            0x97cfa1218fe00b4edf8ce61cd20b4f8875ea5c8282d90f6f7153c9463bfbd95,
+            0xfd1ebd67968d1e49926c3952aaf96d3558aa856acbfe48e5a9fdb4285ad9bda,
+            0x27d5dc47f678316695d548d3b4fd1b00244a11d4cb753edd917d849cfa02fb8c,
+            0x2602ddd7ea3a280860321a70aa806562a57bebfa5a0f5d2770f3a169b88ae244,
+            0x2fafd30b7fac7a6699776892b07366b40fa387bc4141e009ee42070337088a89,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1b2ac2c9f97eb32560cee0b8e8320f52866b17042d2c7c13178dbd963936517,
+            0xc6db19118e83768bce24e1556ab9d383adb0f4f2b63c3f540d5b5e4deebb1f4,
+            0xf94cafc14403845ea574997bf75caba6b2016ee5a10de57ae35923c9c6a2261,
+            0x9145c337938ac3f71b78022c80fcdce4c1742f47dd2190c31c3cc5a41980f5d,
+            0xa0ca462d8ae218e235b6f24f4c17747886524aded7e4f3a59631497a4f98863,
+            0x1851288ccce2bdece3a7f68ff33b00cb961e6292f2af29c775cdf6ce3fe0777b,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x9ad33992db79124edac791c80e82876cf3a60a043edfcd7bfb5a93ee3feab08,
+            0xb320d1000c50439a989886c4c11e711bd26667e61c50afba9d347cbd4b312f3,
+            0x26123488a4f037ba7b2a51391f25f91642ae52bae1435dfe32c5f47ce63f68a5,
+            0xd7a4403c3407d64ff5f63275add86c161183b2f1e88dab842607a8f3fcaa270,
+            0x2cad68fb4be69ca135d9b37e2d3084557efa6423a9662f1fb24150b310c71727,
+            0x2e122deb202b0e2c6a25e15226c09b9564cc57a8fc0d3645be77c36f8f27d4fd,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x23e090845b17c18cc12ff83ce7deb2e58cff2f37771c39cd0b68ba14f4cd65ac,
+            0x8b041b40e47ef1883a30a5e631cb1e0596543f5c240701002be9d495d59a775,
+            0x19d0ad6176cd87e6109b92dff1b863104182e2c85bbaac5330b2b7a4b56f9a6e,
+            0x11296e1ff67a98dff758d023ea74c5fabe372a797f86a621bac4bbcdf31878bd,
+            0x1b0943c04cc4c3885335624a4df555ff89e439a40e6691d5db44732aea1b36ab,
+            0xc2cb45703a55a050e57ca3e51bf386b2cba4d5dadeb1749f8a6e047c5e9ac1d,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x20c061a0f70692748ab2f61b7e52e5ddd5e704e51de165eb19312700eef604a9,
+            0x2aeb2df6a12c099b42c03dac1557681f03947ecd76426d6cb8a749dfb9f964f0,
+            0x111fa84f899677752592a75d53083c3188d97a72d8aa1be3835b681bc6813270,
+            0x1aad37ed6a2102cb892b98a7783fb019752cc8c0327190be544ad76165251f90,
+            0x1be6d262a580b10956cd6163ef221f3d9b0dc3e5cbc7ab04b3f8f2a0ffe86be9,
+            0x19fb44907e93686f59b9f17c0266c8139f8f4d8a5d212503bec1c6ef72409fca,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xccbd07f12f007d8f30c6150e395dacffde4eae8fa51bf6bea1d6a7c421a586d,
+            0x9a3428b0108143dc9c78633aa3bb37807bcd9603406be211bb286e42b58cb52,
+            0x2a7ab6ca90a4e66f52e863c4b0f515148798ac8f92661b2b816902e915d8227c,
+            0x179239cb6d96131ef12f09a58f9535b66b23c4367bcfab687e9a7c3c880a040f,
+            0x7f9eff8cd62907b5d607140bd0b0944d175f17abe2b2eed814b6463ad29b8ce,
+            0x2f44cd6674099eae8cee5c6f84e9b25cfd7c801e0b457278e83fe4b511458c8e,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x241d4acb53e51cee878b7d23223fd33311ff0aae81f4faa07816546eb732d8d9,
+            0x13016b694f63245a8a9b2f09a84bef7c0711bb8838b3ad49e0b7838f6f644560,
+            0x240a3ff47c2e7332534647a5a2fe278aff069cc479fa000d7c31a78ce2929bd1,
+            0x1a510b683ed295b19be81ace3dfbf7cf1061b07a18579325f7cd001d38146c30,
+            0x20c4eceba419b0575a95e295d84e71bd1a928d5ccca5d79a809059de3342c9cf,
+            0xbaf9899a51723a56cda43c1aecd6c096a499b57ae1893e16a28908bc5dcff6a,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x162315c3b31a4d5b766510f46974ff89071424364fd69c9bfba1b6e0bece8eac,
+            0x2f6a4f9489ad4e1439c806d757799fd6ee58ca5d0560d15a8f658c6eb86f47d6,
+            0xf67999a01cf660e19180113f770041cc147a335e19f545e3f31a61bb6b4efa9,
+            0x9146d7f035d379789456542d3d727b593a6fc67252a631ec407053635478fa0,
+            0x2e44a6eb2efede0a5768d8491e4c86bfcd63b0ee2f383b74d62af311cf91de5a,
+            0x160631bd9c54749181816c9aca5fe004260ee7a56fd35fb56977ef04911d5e71,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x26f7f151e37cde405da94d5b7e897e9768862af285902b590b636e12bb43c7af,
+            0xeeffd18325f8754d15db8adf98d290ac816cab0e4315306b2418068e78dd02f,
+            0x284277b5d2b0fd66df351ff703419da6b1aea5ee405bba09bd4a369e6eaea49a,
+            0x13584c5168cf2fc77f884d111e05fa8512e7cffec60dd3a105503196d682ca12,
+            0x1ebd55190bbbaae0e9dd1af991eaf3ae13af0e71fa686312224c886c97e9e2f9,
+            0x13a449ace196028aea035af0cd9d5b763d29f8d292443a762d8be06b1e136dfb,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x21fa424cf90bf0b715656aeb3d02acc326cb56880bcd91602efacf66164bd07b,
+            0x24694b5ba9200603bca8f52d73d0f3fea26c0ee1939d2cec8a9bc5f961cd68c7,
+            0x1a6d98f744fca59c910dfb19ad89d7c25f2c719332edbbafb6cc85c190e4e170,
+            0xab904b12244246c2dd95c69a28ab91d2c34e641f697b5361bd91d1625c937dc,
+            0xfd87c8923668cce921af698cda67103c048864129954800460374ded5b86770,
+            0x2098ce0512ca13bea1141e48f14bc691b410cf81de7f597d062465e1431c4c2a,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x4d94ebda7313ce25cd0dfcd1dde7992439daae630c054d7cfd6d690a85c27e9,
+            0xaf2fa274dd5b1e16568fc4613e76c9ab4fa99d09d10105e98bd9b92b82ea455,
+            0x19153b7441c48cd270b491762e96e470858714e9650aac65169577d2fc755af4,
+            0x2a5c69d030248d78f70674af65d92a908a7c27c34f32f9fd2417450e0585254b,
+            0x436d86f139382ffb61085560e2592290518eced5230894b4a8bcdebe06a88fb,
+            0x23b40e7f1bd0b7fae8cf2ea0608ace9299b903ac8d9994f7448bc2e46090af99,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x21427832371fd1ce0efebe904a3ffae941142d4f35ce77e064e256ab5937653a,
+            0x1b527a15f36d4f03015a6ff483cfb5c18f8b331a7caf79237998fb914dd46149,
+            0x13d847e25b71d35789c6cde81ad9ad9c1afa6ace79ecf363920dc233e5646338,
+            0x238b13365a6b8fcd6580ff9f4bf267b01366a41d7c326c826be7dfec751bd480,
+            0x2fdc1ab225df187a8fdece2e14114cb71f01ed887085eed22731ded19882966b,
+            0x2fc9fa00830e2671b36e8eeec5c369a6b3fc27bd96905b5fc220fcf0458d1c3e,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x101b70dd04be642aa07377610e3ee7d630bdb12e3b26295806b92e9f482151cb,
+            0x1227872231f192f1c81440c79fdebe597ce8ad03894cb07ac9b3423e4db90d10,
+            0x1d01d734b7090603174951fe6d338fb3cccc00c0accf2ac8d45859f45166305c,
+            0xe593e9c0177976f4caa991e54fc7eeae897fb723a9fad08a811b296f3e7b10e,
+            0x2fe9b7637f54d7060ff768205f9e161a4cb3bd9dcf14a8bbcb37743b6fc60c16,
+            0x26ac179b67db2c393739a450573022142905e5faa7e8efdd1c717eb603a6d9c2,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2e26f19972ff8bedefb7803e3284690f4fc7828cb0bcf3b5d5697b82714a171a,
+            0x7f4790a30254f654fb0a465c42217421998843693e2c2320e58cdf31a77ceea,
+            0x16adbd595b9959b8b903db7df15187e66b7f6fd433fd2ed3ca0dab8d45f8d031,
+            0x1341399558f697e9e3b49e50ad3889a7a6ac1b7a169ffe1575a3172a4f33c75a,
+            0x2c8e714ec99e38714e1d01b984f863c0d8e05b8c3b7ff6fbca20caacfbf3bf4,
+            0xaeb4122ca96285c5eb5b52fe2c26355db417406c567aa6c35dec7fc58ba6176,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x24f5e61cac001b78c4664cdc75cd8d75bde602e45c6dac698f3b28ded5a75604,
+            0x158dab8b85f4412fdaefdee4d4f1fecb22f433672964d2ee7730b03663361f1d,
+            0x210a7fd894e483be032c8e6876957968f2152a9f1eded11c3cd26539ab12a213,
+            0x27dd83e178817fe22e022c22e620afb88e02fb15346322b8f70bb26485b813ed,
+            0x28b60c3bcdd4693b01f111dab969ee5dfa4a8840defdbf2bbf38604ce4e23e70,
+            0x5c56f683ea2d1d507676f03c411a29c9925215ca5d8e7f28a3da73cd7b513de,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1ef913d33b18f5ca1d000c2209646780c4580869163f287c4fbe537e270c308b,
+            0x2f77767437b926272dcdeecd45416aaa588551a79bfeb15fc3c76d938d12afcb,
+            0x2da62c50f92d8dcc0f6fdd909051708b0c8f21f966ad57ba303370f00209ed21,
+            0x118c1924b687d5268424af23862f95eb629e1c699a7c27de27c581c495ef159f,
+            0x1c20f20b601f89d66abc8e1854d3f29489de9a559584b9df842fb988980133c4,
+            0x19078ba50370eef76a00f6c89217183bba9da58fe15d8a07c565caa019147772,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x90d697c32be00d8b71f734d1f9023cdd11a587b51581e763bac5b3c766c5043,
+            0x28309a912afc86848b67f7d85be9603f34ddceac4385e702f3662b3c2bdcf9e5,
+            0xb100f36ac254ea63a6b92996445318f7053603e181261d07051400f302dc3bc,
+            0x1931597f6dfad68193199a2166736c0c7e874189ca4d4d2555ef9d964b06c93e,
+            0xb26976995fcdb354ec5c6c50e1b29139fc3c0a64709cbfc2fa992effa833800,
+            0x2dd919c2edc302e56e0ece7b8537905feaa8c6dfa6c6130f94d68f7380bca019,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x278b0231cff85bdeee497f6274fda5e07cefaac1ab05ce89f863db3fce5eeb29,
+            0x9ee1dcae79dc90e4cf0d0fb5e6bdee96fa6b751adde822d30e3a80b1a5bb506,
+            0x1769f50fb961ba50df8b9e03a12fc37bc965265fce93f9762b274328fd04afbd,
+            0x20a99da43235a2bb30b0ef58d708d07740510f517b2eedb678a94aaa4edbdeee,
+            0x11b7181ec0f9a1485d84cd91c342f70e1924c7a85f48a33e7bf8b5dba2b8b7a9,
+            0x23453eb1a5e44e28b31107f29dc6a7bf4818a7ce156d2c7e81dff75cc02e937a,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2abc91241e3275e2028d68130f5533d6c8e3d1ec2942632fa4b91a49fc762880,
+            0x21653a887bf627cba0b5a35ebb3329f4602afd8440ada0050c31b249d962f86e,
+            0x2ffee525440cb92eafc518b16135ca00df2ccd813bf1f9bc458252d7ee478def,
+            0x104bce734fb0322de9a91058ffb340e35c212a8af5c5b6ce1817344d82137d5,
+            0x12db34f34145195e64455a298fe597ce8b757426784cc53975ed5a439b91c12a,
+            0x13a9a61ca0008c1b911748f5593bbeaf633308428e4e85378214be04aef88b1c,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x14ade7cef88a7726d51eb001357d8bfce8d1d8ec79472f6f2531d94792d4707a,
+            0x24baee921a2b827fe96835346b85a3e94ab75b4eb9fcab4235cb9c54d0a077a6,
+            0x4dfb441b179922b9e2ca9458de6d3aa0c653beca2fa7317a5d1fc4138e8782b,
+            0x2efdb84c3c6faceb0f58fefdefc09e447ea2302291d3ab11101d487f3c679ee4,
+            0x24d861650389f03a0da9d720f25df6e7ab3796ab597ed63d38055431655bbba5,
+            0x1f8b2609f6999f6b15577697e90e891fc7b691c30c2695278042c2d152aac2ae,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x242fed5519f01070752e2e3779757e5df21033baaab86a9fbdb1a54d11cd4db6,
+            0x6dff8e392f51302fd8864de5068b943a2b04fb0b239c38b679faf689d69e1a9,
+            0x1ce5db5cd27794bbda0f7215bd9404f46502d2b601f74fcf2cb1a5b7fd440fbc,
+            0x16aea838ec8bc6e8b8f48309cd6e783cb4a337b92728f66f701f0d5efb32a80a,
+            0x1fd21a8ff13f0ef12be5a125bfbd5e952ef1e46b4f3747f3fbd8198209d4ea95,
+            0x125158b21d677618076854954d977c35a6313a1f37564e36bf6d072d2500df6,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2bb8e29cb323e3e2879d93d36e9312bb3c38a922cc6bcc1689f72793f5d4a18e,
+            0xd0e2ecbd08e247ae7aff1bce2bc54ad1603fc2cf0ef32822701feeebf4e826a,
+            0x2e7df0f7b842490b3f39d0d87bbb35a90cf23f3cfeef3c8a4fe4716a47699470,
+            0x1d9dd609a2944aa782ecb1a08acb5c0bb857c7489920644f6839c93c10b37837,
+            0x11ad269471d4b36fb23aa243904a0290608c32759020f082cda8b4d538752109,
+            0x2d2f546cbe60a9822e205c3f3fd187bf89f6def774c3f988de86e4eb91595bea,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x28113fd3a8d3b95ebcf29f2ddb54c6d9ea034a51e3bd1198e4c1f4f1dcf068d0,
+            0x114ed46d49b389b14c202ba1c069ed4d836c131dcec2472f4bb78f803b90025b,
+            0x14a217bf8737fb3570e38b75cbc97b316ba21db8a3f316aca5a26ed35c0d1424,
+            0x16c9e7a58ddf141978209561d930058233b8adbb9e3aec9702ff674c22b009d0,
+            0x1388b78b9ec0242e402906d75be419cf92e3dbc2a5152df9797318e004632793,
+            0x2a459318d3f7156d87e3c666a8f7626cfed0d30fca28ef7927513b1f7a294b07,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1f3df3ca1c4b854792a69d107bb7e6e7be2f479be397de83c94cb310e8e821cb,
+            0x2869447a669cafc20f1f9017028e3098b38a82fdf3cee59d9de2c888004b41e9,
+            0x25eccbdcaf0a67d5ef15c7baaef8bd2a4eaa1a6d5d70385ed777c10db4796ff7,
+            0x24c26970e999f27e6351f1be0a3211c0a177cdb778ead13baea9b7b4be3534a5,
+            0x731afc922ad48a9f0ce9d635e26ba013a7d4ae8d52d4fb75f0f02409d83433b,
+            0x217044abaa3c9ab6c51927ad1061d0c1cedc63a90b01b7b5f1c10974e66f879d,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x26cfa9ff210943f6b07c08691c2eddb1bb1d2167a417912ece724706b5c20b0e,
+            0xa5509b4fa5bc8be630a2ca7c40980904713b196e36a7e9f839c4474037e049c,
+            0x1c4dc788b6131f9dd132c2edffc7a46ec50b000383faff5419392f0d291c3475,
+            0x150bdab59767a62d994ce37edf2c3cd5311abd0bfe541fb30968e19ee2601053,
+            0x25393627a593730f4cf25a068932d447c1581f251f9a7b7d86cf9e392aca0d31,
+            0x10598af7a84cfdb4c458ca7625dd8b18509491e7109db65bd8a0f80d8778a6ae,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1fd5ba5922d7109795d5dba77bfb57ba6aef1bb6aef0baec38d0f916d35ec9d0,
+            0x439026e268ca0fa85b1f6ded27c854552eed2629ddb59e6a679d4efaea6f218,
+            0x1d5d47eb657ce510b9f9a17e9a49d6f0040f7f360399dab7f053faba3f06286e,
+            0x5cf07dcd831c1c51062ea271b402941996f46dd9df0fbb227305a550f42697,
+            0x24ef1615afe18b0ff998bf9e1fc69fedf38db66b2257f4bac76adc04ce92e029,
+            0xce1da26cb97828162425a7236c23e8f4b7778bda9d7d514b1b8fc9328087c2c,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1355e415b0db4001ca01503bc20232a49e67f0e816dc90ff18a4280437e9e9b8,
+            0x11fc9669cbe3bf176da65f312e409d635dbee3fbf8f3d1d6b056b48473cb451,
+            0x1d6c1910236789557b4c42df0191d2a46cddd2838ec6a74b7c308f023e71d4c5,
+            0x1626f4d2cc7f2d46d7c9c97030c1b420d6c2d55033f7becea7d377541b19f57f,
+            0x210c4bb43d712b400d4bae4bf8dde436786fc88bfcb82570b3e235ddc2982115,
+            0x213fd23b04ea9e58ea915c1fdb460f3a0ac4b0041afe80f6ca1ba9e1a0e13825,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2ea430efe8ee1f2c72ac009258a1ad98b87725c00f72d27a31c445046bb9a80e,
+            0x2d694e23e1b3f6b632b646584e76fb7b0d35aeda598fa5069d73c75136bd0272,
+            0x2ed754f34a22fe04fbb3635776e0894d21cdbf4cc6e03b8bf33787883c1a0db0,
+            0xf23e64e2b59d750be3bd037f4df62f7fbf16899400e69554b893f4afeaa41ae,
+            0x1cd301878d6d778480ef82b2a3cb9bcc36362d198e44c204e490cc524a2bb2b0,
+            0x276d797b67c8b3d935a71d2f8342bf7cbbd68de537e32c466f95a01a5a207f04,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x16e8ab5ced34e81dfe00c24c7fbd0f4188351be2b1b26b6d63a1e02b84aea6b,
+            0x1caf3b10ac5814656ec2d5852b5439f810c8dc0a4fd6ebe82d9f33134f60c7a7,
+            0x225f97bdaeb6a565372c547e9d6c354c1f78fa1998cc3d92c28212ec7edb634e,
+            0x2d828acba9e58e0f3adf239a3689449515a1ba244c13b0186c827d600b7a7358,
+            0x1f9da4066a62e0cf290cb839bf62c9a49cf79b0ea1affe03696062ab8cb9d39b,
+            0x240706e2b81b5b65343b41e59330666d2b405258c4b9b177495776c2b1b6816c,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2d0f43029750f58be22d66c5b2963ac6b15b18c6e9d009b717044859fef9618d,
+            0x14237392b60352f6c8aa0f5c08024beb882ab82dbd3e790cda3898886aa3e9bb,
+            0xc8f3b03657beee6e1f94c98662b6339cfb7db5cb431fb9813587ee3f194d260,
+            0x18700b515de19b3256513482566afcbf490e55633dc0ba574c2fb4efad1ef118,
+            0x1c3b0a6645d002a9d1e18721a96d1e8b00217bdbea74ff1340dca47e6a326e26,
+            0x2979c4d21f80db612fa98aa90bbd65e2cecc1ea431849612005a904c08bfd014,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x24509dfe357470309be062b07c05dd3df57d7cca62caa26001991820ce3af97f,
+            0x2bedda6eaf8901b78a0e53e25dacd92c60673046c86deb333ce4798bcf9357e2,
+            0x1f1d984e06825a3da53ac4066d4910067f6e0ff13ef83152cce3977ccb273404,
+            0x1f592946ac103f244d168802c352a7e2dc52bd2e53d3ef2f4a7571af810609e,
+            0x1a975c6688744220ac1e3d5295126f8ee0db7ca6283a176585e8dd5bce060ff9,
+            0x1a78319fb62d99297737e9dfdccd57fe6ffe0329195b8ff713a2d6d33596a6f6,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2fb4c2f41520052bd4498be87f445b3c62e86ca7d872dae8fa99c67b5977d11,
+            0x3162b367e9f34180f2228d505e54dbb7f2f23a3a8fee14f3084aea490fbf3fa,
+            0xda5cb94995f668763e7c6ecf96dc6bc13943abf3e49c55a702d37f36f79114e,
+            0x2575cdf1a61befe9fb7b83e880e8cc23d82600f35598ea2f81ad1bec1bd701b9,
+            0x1f83d6c20646a7e089a8fd0ad274021af2fb24e315f400dcb3d26a99ab5a35ae,
+            0x2c774cf487f79664580219c9d698781249e47b432767b0cbaf5169a5079fdb42,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x203c1b59256ff5c004e70c2c5125ed51cc53e99390a8de9018e647e1be8d9888,
+            0x27abfb2e0894c5b4279b39b9319fa54ccbabd1efc509b31d906a1b5f764963c1,
+            0x2fea2fd0f35fffa4f84894b6525b3fec299c821a4766a78c829c2e7e69efbf0b,
+            0x2451d54dc48cb608f2e96698b96fd545816fef09dcaea75c9928179373a66fba,
+            0x17c5d4cbf713d33eb7c1f915dd2b0e439bebc5510cb409594adb43f94b7a0e9a,
+            0x279fbf4382e4b2bc46c1a8f719063ddb4226bb09c10cd68008b37c7f32d469c,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xeb7c1194600e6ced3d8dc88c8689704d4188dfe89970dd790bb9cb600652321,
+            0xa0e776c12cd108cc589b14e8493dc743d85046b1c4ca97715ec501fcb166ba3,
+            0x1a8a8487cb8a60bce5774f64f62d0bcee791dc32d3a6f872f7dc626e4a732948,
+            0x16f103fdba708db2bce8b58c467a05bb8878939c82852921e94e5e955aa09ca0,
+            0x27a57324ff8193272833550d82f749d1389b493f98c8d3473f1a98900376325b,
+            0x26e4040378441fe8a60d1a5319aab70076c82cc203530d82e758844070c04860,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x71846aa99eae694fa17d73eae87534f09c4539fa5c3b79ea6bc56d888dfa9c1,
+            0xcf75a0326b8ca3e2ad571834bc835c083555587a928fef417730656217faa2e,
+            0x1b80702e894d74821bfef8a2dae36f71d4802940f63a14fe64b3081340c4f11b,
+            0x2cc49fb1ce9198b927ab098ec9f454d205342ab49677037f9ff7f08e3f07ce71,
+            0x1a6e74bef4b0a5b3566facbf770a14bad98d8b6feab3e45995a328135888e924,
+            0x2ef1e0f0bbff91312b2c9b4710ca04f4e978061ba53657e9bc1893bdb2e7c7c9,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xbb77a79511909681081da11a13c7abf3107373ba413ecba4d47ee5a0c288fac,
+            0x23d8b2e6869d7d05101d387c1b8cde6b85b7fe860e7eed2944c50d099053bfa5,
+            0x3023a8bf03a803eda3830c500d1c0e061fa85c4c15b72459475e3de290616ae9,
+            0x2b27c41a943be0d396ed3630098ff7018767161fc1a24d25f47969f1a44e20eb,
+            0x2a73bceed9ee2a7261290c8590e2ff679582a3a6c5988254ddf6f108f1103e13,
+            0x2579c47b76db59c6206ef023b59884fae08ef6a697acf7e55b6f132fd7733bc2,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2a5993c9c2a80be0f4b0a6f9c432e2c0604cf59d5bf5bf24609572d7d0acb900,
+            0x10faea103aa36e7d5c7bf760b355e0fd381a393feca3c04450d7faf0f6a22804,
+            0x2e98e92bc9904ca92c3e6d68fdd79e8bef6123ad5174f01d5dc04a240d8f47f1,
+            0x119937bb5d5d9029f290239eb94fe86069f2db6bcedcda8a1028e0b7a434428,
+            0x7c67a48f20850fc8ec8c735b73e07af2a08f52e7bc90084e9609e97f070cf2,
+            0x2da7855de0bdab6e993fdc9ece5fadf00c5d39d58f6599a56438aa2663cc35ee,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1a69a3840762376c3a2aec1bd8a434f2a5e410a7e92d23dbbb20a0991aadc46b,
+            0x57e27ad9218a311c3627a25345c879508fb856d68b9c0aca90276b1dfa4bf15,
+            0x14307851c6b079c4f3b26689dc5f62b8ac2b69ccf33f3802e9ada26718881832,
+            0x26c71cfb532662f6e681dd310fe112703b78f8ce1e3c39183d5d4889ce304271,
+            0x294cb0c139a1a5a345bc094d8a53f21d90e82cf47bb87e3d5e5bbd761e6d82aa,
+            0x84133bb35d1cee7f10a2f61953a4c77e09c4661a5565646654ddb7fec0be900,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1807d1d910cf5420087bc575b795cf7b77b590b7d14d3e3d2298b302c875bc1a,
+            0x1df001fd3c1262358bfa1198116229dc12e112bcd91b4f3962c8136c02c57e9a,
+            0x2b424b88ddb0ae2ff74d14a89099f8942df4e737c63f61f695ecea4842f9ff07,
+            0x189b086bfbbb9da30885f11ff9cb213c0a353710153cadd96203c7f97203791a,
+            0x1bd472ab81eb7d6c92809c07a387b1dad43a3083fe658bc88d1c3ac1672e2ec9,
+            0x2bcb32de32d02f4b8f8b1d100459f537cb0e4e1f14cfe5724424107a9929bf8f,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xcfc7baed4497a2252d54cdeaf8ce6f23773209abb5f341ca2ab616f0516195e,
+            0x1cbfb6629ded2640c886dd504a2ec58f96b441839b79e54feab04260eb90b128,
+            0xb3e19811df2edf55549ac304fb205cdae326abff1e7febd20f350af8752f2b,
+            0x17e85c4c6fe808534124bb66995e5c663eb5a195ac1a26d8a096db675ca0dfcf,
+            0x31cdebefacdf2b2dc708ff87cee0315f36e97308369e304e8d2654c342622dd,
+            0x17c33efac12fd569e1ff7c0a0165c4cb8d23c279d442e7bbd073cadbe4f665b2,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x866a0d2140ed3854d5822fba68985764126345cdafbf547ebd33c39aecb895c,
+            0x2bbd1e9f3114413c347ee4037d08f914d4cb655617c0cfaab77bb09ced39950,
+            0x1ad0d5f7480a78dd4e048c459479d5622ed65f87880f675cbd2c4d97e7bc7847,
+            0x1b88066e99b993f70306cde87ea47cab3efa6d698c9d3b1ba355b2c9f3453b74,
+            0x25fa0cd0dea157ff4ed741b0dc76e0095a51fc30c799500e80d0b821aad7b9f1,
+            0x208e0d0378f2c7d87a6ce8abcbd4bdd979a4d9dc80268cb96d84ad440fd0f99a,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xbcb27a9e590ba76102f8bfa6f1c64726558f57a0027e6ddbc46d564eb8b09da,
+            0xce91923c51960849a75b3f8fd1bfe1d9754dc7cd48144f964a0c91a4e08dd61,
+            0x1fac92c295c763fe6b1e3c0f3604f0c7d618def2133ee2f869d2a1e774b4245d,
+            0x87968a25cdbb96cd471e88fc2cccbf3e5b8bd1037b4ee5332adac070a82a109,
+            0xcc8d9f53ff98eedd6fdd5c5def364a45d12ace1ff5e3626f760773b5de0e624,
+            0x2b95310fe6307070e985d61390a351ca5e1c4a9f5e2c539602136fcd080f4e6a,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x28c0a6ccd9587d41eb73206239493c9150e52258eefa598382cf609d4559b2e8,
+            0x165c6c313faa07be77275b235bcccbf30af0740ca973d6acce2cafa9462491d9,
+            0xcdeb047d8e50b00253e926dff5f95b4279be0377669908d6759612cb73259e6,
+            0x10140d5f85f2f329572c2c9b7535776b7695d62d6362ef27285485abbf9db018,
+            0x9501340c196da04db07c8b1c3bc1461c228e926c9ee26f5e26364dd894b1468,
+            0xf607855b7f42530fc19f6431d53035a74eb03f7251d71567982458698c93ac0,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x255be79d8de4168c44cf8a26522391ec6b67e30f2474bf2cc7c792dd25a47046,
+            0x1ecb792391cc746710b586800234267adcd4d9841c4e8f1e76dfc5dd15eaec90,
+            0x292470307f3a20d0205a19091cb044a8f9e58d0156f0364b21f3b6025b65d016,
+            0xc3d7b0383d1377489843e884a06ba72245f0498e71043af2acda8353a47ecee,
+            0xc610cb1971aaa4ae5f87fb14ed536198648cdc876c7c6e2f531d7d5d1ad625c,
+            0x1c237dcaf124be157c5897960fe7f22af44d441d2d4590028a07bb249711d7e2,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2a5e583e4003e7e747a1d39ad6027a9f347c7de946a3cfd00750a9a102c05e3b,
+            0x16ccec4b4960d2331a960804ecdb0442ecb1bcddb9bab42b306c4736510675e9,
+            0x2d0db3092b03a54bdb861c291c1a1f522112f9e457e3a51d731851dd59b1365f,
+            0x16f1469935ef074ab1ae192294dd62af3e14ae22f1e294032222c5ae19e2adbd,
+            0x67c4106d011aaf52f2539ba2f8d1fe65ce9ae081858ad629b9ebe8148cc0878,
+            0x12c6eaadcc69ac3b7344b8296ea4a251facc1c96356c84e8131b662f3d5f34a3,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2ad9831069e1f113495cdaaaf18733aa4a4eae1e850d58c06665a1c787ed6049,
+            0x1a6d2b5f928d9f0a9c4022b9520d707e5eca0ac9cee84927a71737a036628f6c,
+            0x1d92d368ae1f42256bfe712909a03c69a46bcd207c17461986a6de00e0952945,
+            0x10ad1d35f6f8f499e64daef032a28251b50c622a28429d2b2107ab377784faaf,
+            0x150225afc95fcb450fa9b2b7723479ecf7c3143eda0eaa257df4f1a798cf6375,
+            0x13c542f46f245c790955fd30c8cfe7125534ebcf6df7b1d9bedbe7205eddb980,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2fea3116266bd3005b05649b48c70089e572a077ed0f8f9730b63cbb9134a368,
+            0x1bc4f0df44852b392b2a36846030f42fcd462c40b04d0c90e71129e621842af6,
+            0x83b244ee2ab819a95d0c4bcdb9d915dabb6832b4dff9bde7ce0515827d19cfb,
+            0x1fe91590b6942e9c496a9c696c067b3086fd707b01290a7711d4f398908c8917,
+            0x2e97a6382c9007fb2b6ac74186070eda269b10506e8e4a74ba82274d154268c0,
+            0x19d731e981d3dd374362f4b4f05c5ee9600b5396567615c3ee94e0a80c8cc4ac,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1299ec83503dcd0c6aaece92e6c2cf7871b61e43318dc82a183a5039044fd000,
+            0x27059db058fd253b71b341d077246299734497dc31f2159918c64a78188b85e1,
+            0xf8c2dee7cdc8dc90eb57f025076157a181973f6347318feeb0c99afeae085d0,
+            0x1053d862218c7ad87cda3105ac23bcb12c92e883006c3d44fa3f9166e827cfd6,
+            0x1442ee0343b9bc2ae95f8c4f59cb32bb461a4c7b40a12e89b68b6990a4b71933,
+            0x2ef147fa908e6186fc2ed54fadf20555ef2a1e9b3babcb6863879adf84a3472b,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x297d7f9fc303a0f583f992f7347f68b50b5bbd791acb93e2d8bc8efdc4c1ab53,
+            0x2b4e8b40ce6c64abc1c906a956e5aaf5ebbdb7c98110e171adac573b81b16195,
+            0x316fe041d68e38cbaa5d728d225ed818f00b2aa9ffb1ad3d9ec24bcdfccdcbc,
+            0x168c57b725731fe3159d73e0d94c0ebf35171e3cf88e1267c2b556a5456ae6c1,
+            0x90666d655622b3757b5ae5283432b4aeaece83148a36eb57821d241b3efbd3e,
+            0x2c91164e87fcb1bd07143870286eca8a29df3678768bae50817569f48bd7bdf,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x110f901d246c2e951c579bbe91467a2950e69ecf241d8b68c4a4c98f05284b26,
+            0x484e7feefee9a459b2861009d6007e8b15721afb4a35f3e5c9a6f1f70334091,
+            0x11300deae6b73e9e5129595f0996c10ce002506c2c207bf672676a130aba8364,
+            0xec4bcec59f43f5b5653a3cb0440d71118ce31bb60c75b9c6766b6a5e0524968,
+            0xefa65a66b38b03467fe38d8669207d9fbb9f38faaf70d13a67c6bf71e1e71e6,
+            0x27806883684a018d11ee2ecabb971dd9f690cc5a22ffe36ce61f17c6ea5fb4a8,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0xf4b7f229e28a7a9e7bf019b18ce7a36280fff22f7a99e60bd84d1baa891cd12,
+            0x20b53ef54ebd25d7c222d418e017b7cc5e00a9ae5221191a1ff561b1ee3177b8,
+            0x14efc55a08da5f53635520e21890e2e5eaf0cc1fa1fddcacf1302dc65ee059c2,
+            0x1b701800b22e5765059fc4525bb4aacfac8dedf2ed37253160baa818678ef374,
+            0x118648d759ffd92fb5bcb86acfdfc4bceddadd6fb1679c317cbbcf686651c67f,
+            0x2601544a6e67f78415a0c2a6e8f4665f5910909c58bb2eb03f7854519af15f0,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x1bfdb6da2db944b4b79fc0ef825d6ca2acd350cbb87ff12187db30a1798d0dcf,
+            0x969ce62c18f96eb6c6e3d0c5a7bc7b2b1de0cb7ae0474b47d16445f2d067cbb,
+            0x13d54abe37dccf2eede120eeaabc5105b997f3647874179cfebc1c9b022b8215,
+            0x27b42d0a347af048017cd6e2a577e959c0b6b6b8c2ae405cd9b05b793a2643b3,
+            0x2737758ec335fcb4498d54d210c11bce1d2cf1b97b7ebb835c4bd17b1cf8d54f,
+            0x1f9696df0bb5e293dc20d0579dba1866adef8f6e6d3846f42380861f5b54ca46,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x2fa9dd289eab48f0424a48c9a2b4f51d2de3ae6cf2d5e23a10b0366938541d65,
+            0xfc755141d556a5eebf1efccbcbbf72ead5eecb5ad93e9814b715c4d388d7709,
+            0x26127072286989c57c665090b20dc85c5fa983ae80c412fb2d8ad02194843981,
+            0x229663addd9b99e225513a7d0ed1b43c0b02de97a57466355e670add9ad636b3,
+            0x3011613dbd895a56a9dc81ca4f61a03f4e77c18834c6c20a51be01d4ef9062d2,
+            0x5598cd7707b28488e2a0d669ac14e8464804e51537d7d3baa45a7c80e489c5b,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x16dc1f58a2e54f8f78d4a2bc67c5dd242744ff2db0ea9533a9fb3de2afa831e5,
+            0x2a274cc1ef7dd9e160541523dd6b2c159fcb0f40191b63a8d0a877777b8dd060,
+            0x1e8f3078f2fd0b0409460ab369a100d5a82cd93b3dd947644aa6bb8fc2f4f863,
+            0x2ee81ae8b9bc0eb7d4417e09a83dd467ca8dcb6e8f0c8758b9cba555123dac67,
+            0x367cb4b603a227e6b02ba57173fe7391e93db6078be2d56ef2e9164b6fd2721,
+            0x184637a267f328df1bd119191fe0d1158eab799713ea537f01bebfa4fbb640f3,
+            0x236d13393ef85cc48a351dd786dd7a1de5e39942296127fd87947223ae5108ad,
+            0x27649a3a1db5ba83511b2f9fb3785dbdf083f1f5d4bed38b76fd379545d9ca08,
+            0x8f84f219781937a7bd7ed5aecdffbcad92a1d31262fe51761c94a0f19973283,
+            0x14f65d95f7359b8f9f3527527ba9722197df3e698f773cf3027c00bc4160f989,
+            0x2a75a171563b807db525be259699ab28fe9bc7fb1f70943ff049bc970e841a0c,
+            0x2070679e798782ef592a52ca9cef820d497ad2eecbaa7e42f366b3e521c4ed42,
+            0x2f545e578202c9732488540e41f783b68ff0613fd79375f8ba8b3d30958e7677
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_5_config() -> PoseidonConfig<340, 25> {
+pub fn x5_5_config() -> PoseidonConfig<5, 100, 540> {
     config(
         5,
         8,
         60,
         alpha(),
-        [6652655389322448471317061533546982911992554640679550674058582942754771150993,2411464732857349694082092299330329691469354396507353145272547491824343787723,21491443688002139478732659842894153142870918973450440713149176834049574486740,20196926676989483530222124573030747187074792043523478381149800153065505592963,12986278951352369831003505493892366673723882190521699331613883287145355738793,21126146258242782643168619000295062005037298340836817770565977031890883232034,15509665795506578582538177431401381655815033647735781734613703976071034655246,6989769181472743404364681671283889685042701491627165526899522083327752110839,7062179885254277466334896166987547257487047183881628199983668518000910197987,13842521112365108087725039904948872289730786568469683976372377853164252494752,3830559505943186272618534143266118508463381443414165428900505002474439179836,17704863473432653834041116667846189591617394753001613253930974854399793083900,875580502229441633079974792778818749112423694973231971690365132230865385439,1971134273535892826573832061354985059300866001765691176219451252512658771248,4865738840363990164915013008693722144676933915103280504727326977328013515878,1148603338028060679975883868174895825055359423662532941509525326937127571764,17506086433923270253695698017062834613463718526046463655503742220257039588796,21580033018107258179208198773211859664893072138803756118939260252922297665067,15411900706973212043830142913959920716501447427702082030760032355626616412240,12219699506725448409610279620972339448030565224304464695714944121760832152291,4525719544192047521328360848269156485222470829314314216955024799558286708479,19667371373588322336224317159113441765198420040800065314868656839300028747331,18916925604689704279265158984702141998345424765142129953154245912230835240445,12789343981741773931665143789673052782408749041041266509485929045869073416222,3094428508959717445577232225505810354980663487713729230015754183012845687401,18544590634480965569098056786078005630500574069468005220462377474861119476492,20990087440247450018723844204951613913840993427110495085701200965767234569705,17552251989761134508416634118845221324472178264364440017634233349418103869223,21000797802575507763447855752602183842956182733750968489641741136166640639409,19292751508591545849778577901067988044973302547209758604667395356943370737868,18314088316445539319869442180584299715533304874169767778761887632882728399870,15003745150856597539000559910957155642193629735521291045949652201905498569732,7839443900003691950104175747634267110464104444913379977500178134209666299140,13568305490393393394812598233983935295266242465548739772708079888867621061127,6453005227995051361096639028742707098785560656441339640433794156400437698140,1420171596348195609536167209221442141824294918625468780931400849866478645240,8347329128252205996443084339884155586061343024498283583400215109265013719709,7893774494551056447960817286805128884970061671041428326788899872964096959040,8970476243368194065341537088653900235777512204874037182428362347342487241690,239049405935404678508864874854718951364753739466303321590415544572014148257,15772878921699764223771017074289335629553777447709755479885293350677783703695,5416082112919155131434995906647355834510201879607888732259087164602171650389,4384524908062410354304345761652962203632712291085564157560146286207296352050,4210984612917608245844011498198864216639269565627982123611519493203177283139,18816442907032290878644773027005263628136050677095986565400687355912498966559,21443510232279945782338486087712914668515437675585863788610958361560172084515,3234314779308300525339049581669531363375743827111579883853941968586490182859,11029499234949696730080035941750777601416171837281021031653841244636590396063,11145210633226924132308292113124660576759662647204939721872338908644906571564,4583160563963432761409369246361117506465307518522062239686649163525543782173,9813992026757562966842771727657080117609486122615087352428596024939855084450,10084171857039480706430282187972782725948479260179367780776125786119489581409,3874212709197875589640151274548083098712939093643165182881681226579903752816,21595542491397091124739711708612983479307589335640792812157875295064235960610,2068530815441314105493629066002923150651375034543842424822712297257260726954,2673459852071215292298131389250564595426361004231758522146794940265552265806,8591046256746588406353455230465605224309754008961178558834659065898923355164,1020055192431352394776887540248098706183934464205704158014904833376067287118,11085709480582865378042656141271006552092494690130782253913953070642865919312,5673844083530503489429922596812992664928167369104420134641855283771127716005,10492199162275168254265892158402955076490959375050993042712629236807564461542,2280843393156259739329331366624245275580688891778782679394848304764573859886,6807797027131305026345508953353882265754363485246407959111359919046340709440,12692191384043938397944633973317584101723715998700063415107128429315536223446,19818676957110967644349139912613239435706480354664804036688552936554140369382,18055602608192644695569077694296748842203151828348990995792087204755925787339,20934555391215769430553078793246717148484784880715746179415906355043590089450,11420705181439111353998210442417752592951340005396931802449360401461783159557,19878854521263746227125001670931867821366047088989510542865511663910116386085,8568201846715449867087132677683368912214864824182424933182820310911278496552,19198701614488576617610339232794062430644024620523684127268879880793305460015,15262122764244854433806270478871594904740306012582364033343126589996733802868,6412758421155818207287638337822550233376667015263373809976157264137577776202,17371585001641430978766734501830788427263945848682170096055857509304472649262,20262970042379497707724791203314262108784948621691331141565359315001027736581,3859750447119748295302212198327542106766447958113540005985799287718502362717,1172269945800307665458943534144481495673510885455899148864236015097947176746,8164247467959680477306326470118519335673181279975551434197731340070491876250,4513977811114181395323888111232002391599397736872779927267726121435887238972,1075250595927474080680862736233039825365918646878264905022213616210377518447,18658420120424372681792175914064174056413842231969276203770574969914576681364,17769673440848360838244654765103041739044212539359630263894092078288342647801,4319086204044362848967484441065231939136453667264715596505827197873119273506,11221173270629292820060668122527062274557317856738971635698169204652845111606,8635411372759272135249379415383299350267629947167809163276219879514948820576,926977621651476360285369760355547766944001783780761167546467658394097283069,17702143780592866375901805387463459229828093905183622296234691441436877570082,629612289140842594504574984021125242351317893847688437087866691775821981724,19990548577495092294245865870717186004301934545721835081514347926537975465539,7124830628609719908679298707909792306162298058570958688501370177898647946696,14620227791860703231425817538142948793892390269806790476396226159679984968174,18495581997440241868332244230687799183899751339442721677540757155760745277888,16922065056093401385376103551657968760602009001905886435813054626317776258714,9969610601962874779035054685661667941954971427956866645694064022029705170229,15281641269114187762159685323068136816556739502211864119670902056596295644116,12114994625438879103001132949163961965524612903017200394727056658298824651596,4840986177718281128440833017205097196672382395936939379498412745183060615212,12847307562796769659308999092658905656250954898192781948610713494470441775991,20290096217351155282642224215178246911041509999959311313223857240001143893317,16151664509646153154405691138084115125600386733136285504828908979176781265710,13848845391482751436287906247470303487958950799995701248612703022979890932133,6335716166231441585596963683321661194889815181545222079376536449814718259931,1824302750039354704619545544386637317858342555634601563660279997221547953768,11327469654081586239268713126961534952233559223228327222485848924908493444712,10077703415170135154603829433031861799853903739210136452726077323833067256620,16368073884579385814331927334821006319227867093692644942500207970751483237405,10621580796499573269115131164341885791299038227955222944695715163010783205295,2099241376651019397894434242565225315652133572870234550073686122343103853816,17104632243449417396641550271977294699471083572885397875525767745512335891599,1935453754847256492223646005402770357836971113012418013930273797463411526183,7492761611332930896292052363224494314920390056637668407353957465667515477934,16836705924460095689555600825174696605443212968244843485187771119291716736958,16995495500678141665340056658079449793587669420913589967848082091551329904176,16097379973857697753436437302681608056543122759719328497348770844548177814262,17476569537128329379528694049566216604638194592812108658767104922628767500420,17997217989870184804787026924935938133194070033518938653831611194683423549591,17573343771046232580761295935281170028624495346579002725814597714902588657750,2450087639204541254902859018960918562514681200270997307467560465282168310665,17288084325555056222618040923753050382954155896826087372317882602328092535440,21837047676579063581498107773514419735425738753079336764356909012851439336687,370061273472837873736743292149368449614309676635341873070086681342317566380,420725183996224279379885018872359102189091670793820517618337092091910692771,4966571645678139143731798992823327185758562224229132271884647901363447388530,5039558223429273757296118284876763395391635773837549121798873235133698166026,14663152729953724779401067486012084029581847325524052152795817923033297673686,7201040456590575809960214033959496417566605177095808543357813677845263237276,16872945504528960415453618286121813996587432836152082188694652370255998768595,4914824783780909279212078186433590922437371437384817332713271291839616026466,17503018483514413315464207189113334433424965178631599286655188843769810245465,4087750571011463387872022799241315348852213278729592692674275176152296405923,4006961923780091252337105595934918049936238157468198971234322013673884171131,4481908842184366902145805444001507554481032302978790080019710161108326487967,13532316826436461968093937893872910736305115143550039673102602344678825540956,11602986656925867325907196773754426955346837006705269228226729102186031417465,15306992574062791537454541745213815567999895856471097922112648012979731636068,4497571735611504561173050536899411999551839050319538712220770383407135602945,2571242673174714867278075260451133687893879636121064640779554188161591611843,7070272070524747733177730083966686149849667613589868731851816020060781720851,1308310289745495626002351437755820460104812708071634598163946330870933261232,9483468192990391193401121929514821570714432121414330663623018046165053411090,7317568349845215930675847155716598288688799068821709820024570206796617676748,1918505733423704616434273602054555051755671749253598966287072464475922854850,15158168161084905689406532256983805923258003804476527617207287404280855731962,6855540174355511438343304861678411868002455139032857270673849263857877330771,5989863238360846166935911112885654223487221280254816980802479355446167746774,20283337058688740322296928691341300752003492063748410749625272920572074851396,18957132189629332408653055312790838576277703952267542471751593810468444454136,15764518568966520670995753676429154315765754748131847346608706222194564055358,7192524197002826721654253762628934164676539329903087107420445743247046038858,142950766663597487919643890566358241353679421113406309294925836697585309311,15012262168187689680572958978610204856600235635916074406168861726626292993057,20795666834671497603181209610179324236645779324677512349797033323222380300794,12650341271833683789775531792948185319868795529390391267833516836256688318306,5597700232877580665749288204589530549415282468176625525368428476461504532052,20949303924691159143653175365242293984396858344688574262804199947001630916385,10746523145835332938672833282581864816136388045771578294905302886974358762209,4998982766221590779170630035756820066555357949247521575936385387288356143784,6936999580131731861735955554005106460473097800566952971315565150681540640020,6670695360676548472482680016233507548657051302712214051977034166870814430578,12210816592786563975173850937247594401582085430897698766795696447223454826466,14933901149105284237676334791785996160108290333321693498322435129559137152007,3848529433916624869590379003597911090976938589461403388133685310398004369431,12778805225074604003024964969486878839359935515509480774809299341511161183802,3288267180428684202786697419666969564766921974531343432588030535602163038467,1272672432174256751826350693883913844502039730140570583479554071765667798207,21130828804874452930669244946376257892693846272313548250936991077452679117587,21254559353072473881932828401787134230282801383134765683324465204971002861493,4116075860631781527931204624078712926526805345818156200756399332393348685924,17435888597009729827411190999389277840088354756277916760187756022854497211746,15837398163415665169712832984380121382150588321621493928953938599666110830812,17988638446757562417082379159769772097890681265659458369075768452342579854303,8144561030363576879343874888624208577604401139613622673042754207987577727758,20020299925602421262203305284307419339160247406220693128040712457114283033661,2945951415037890626891130390523013930737768652394758977777336357159436605764,1505954324723537402640844232704189835623922400329086438898375859826553573763,11851584491756305117491374581845512067704002072833714119284164514457248861803,14471204965036278214508938537949717553799007630471016532866101610339050785912,7163557293233604902868673807221391042191134560333950452577270522828534690707,17291625782465108601367695465389799786592304061550212130987221355832952230827,10240907112109243116543462081552827576656826251172050843989873656917271396422,20702261919346727858635106264046787321170414155594199951578791234276181642650,16678253307828004252292273162411388452019952018258857370242272543091326285541,19810917631941180098047817620026253706643400683524412974923209268916769874447,3357220165225360610202375608872621445880880830154732998557832689480921421791,4392285438534542495332422274902727975330102148971785438164412161504066619105,14642025133729666610167675086855441462580619607677226879159952689184960379911,18142623439987890999821892559271093087005885278955082040377769578204898750505,11769399023330099592616157336702104329646487200891911089287290893650532639221,7261353756299584174448625214367175510387913706095214313669922259027644778060,10406994568199070863112470594593301582798997458844791396920771226539013327304,7475277967562870216712397220016587384793504784585573136176313471517144184018,9598064630327104406929367986473441777975480987434868213697837347643980267620,21137410002545951849752865514437404724653771608225272412595423069852350320648,12345612867231779996383303763804719815752861524077922121654106906093103051400,16461750199070055335468534730937701659470268635084522644824623393184528879703,7829250842543018165409887731515254191943527926556191989558018633300783421935,19801151644322693878208767560968285812646931156576102755771403150148125880648,808770634664491371274943928223981161442027957963181999892266696287962813461,2298122748772261447929855283951027113218922003687701626762072351622993276571,17407798064458858450209051887305178872029674498718760624162479511390762310526,18585562277464562541666582720366573863334618817908062612923861658144918595030,733976598693219656339731904831283238690050114241501938501377743874139460889,11316063986696838098122262534148335669847478050407756877728672233736962269417,17614529714381496379478130066245111825610297227468263851608027100133421612826,12110694197729365219340374599835523099651939156213930558791147158357810646901,4337343008663255658976574468931581484970687989356019720784093082313510905405,1379188959674402095268172673987199124815512095460112504778179157481327937561,3116148242507754420428768481157196067508084836097458698846114802493377512591,13306507137873332434793374848948087993544118494881134631519748904811343155566,18496878480807017010077624766326681523549495609998881196570603040242554712562,3940126764022508707486095199473913866137718790062498893812401335738707507732,10030078765792498033316282784150304209584388923549357286679864120250994473810,18519871685760382462428068450331593474924737719734568498029727699878543899254,12599428893576891013523136950822667754415283296587096197120138265392279834128,16038578953099895530943034305356008247313649524436132877362941968861459073483,14319233878082524834510736727226054073026413911339853399113450188859080424272,13710161613540579690732775978855380876556751245265568031703536595040993113748,14958726446649273856607176275240008023824615720456760403465034344703779274727,20935428111942360630758629263346308597806819928838924586682307174931367773605,5826394436548487315966647466017047216786257295199620110266250301500717796281,31401797997389676486806123612280306684597605608110075525648021056710776011,10784171495708237485952707518956314344821522727746927291389338644844400581452,11604345371765580191117799693565193618158448665352599382713281103552305960442,1378145039624937931836538950217364481423707761527018494355648047365613434790,10284294167221806561993937798090888689421933711157676807977401896199778472860,8233695574758520342808807499924062869636681352769371531557726871630696672029,6570581391072134029876349038190171593169496519436674767949949730275868319732,4026501263908027819614805027945064360196399012004574117767831931274788631138,21091098569404004244061462065218203986433580687172854429523306262593782053656,20711772916118045406356429185975897495222240215931761100801599257137350834799,3165519312799351250309462589160165591299333587158531489859211268084164422251,16470663723473939739601217501478624726068461799539012562455639586886033078064,15672299304945968727435591100602007503785845873606917887638890765525875123857,21393538327627889838198844493522533627143658125568123117776524944297103649079,7688819203734248199049004650451546300187194458173935784579101984183800649342,6609663518412297884695057080546416278366560290439222127471462938252865438638,3476303650597281786976907813110835564442121684386467570637538230409080744769,20633582549754495054832414039299188930065286005370053173386561254823483851717,18067076834611402459142612082327591538480657933568191619109271502102126814407,157209609820117793892254328219308970217366919934739036156851508233236414461,1848396116513925340973398423998379465460554039715233953825786874352442451413,188642786730195655565401615804782553245486295156304142809552609651873793325,540089254487190924787439362270708251103955915909358626209177199653451469720,12796274768956950589847157187031845061404119522843128177103898080653493269942,1785666356337148874573621868025910291826158842346617719666738769156993598966,20649919247042517528354490854561347316237285929352042389729444382153378749538,9568390566108569727471722677925269460696523515877621230569682954652430518787,8590683334740232786825518158771304803451657249486419816607179533515442407283,9321198393538172042803957409292145345834077448228642847843261373640165958582,3651905214805616378360839954289447530035139753215923648216350128870943481828,1324345422558073117779462079218851558068746895262914344818945294328678893083,6666363895154434021620869731925915051086919707989020578203743660669796175288,9850757893972463103359995012900314323213006625927501272997539940766979170137,10214293226445704940138790188111862069675188797488928722469679760666574484266,16862124085118494177559484642483513597285992646267864845521573612482278871023,9172340118369291059693735314505606817316211450324955429310200429408035954801,1968992755714619414656181112336357119271845800144345284299978250769356388249,17192498940296212027365280042755701662136570107224000496521552617655679821443,10063385968535643122430064779260670089120686456635080613693015398478175344193,20101961459945738562625328882763768836449780661345042148985756598106706734632,12704305975772252539534386080950631076046431529894091327218544197389260775334,3008242816727585639441748210631464697850194693570485141354082562181236010097,7797705698071555811456747812384107102104184812467361013142453143842134807658,19323240331433203844038522035479659453946066968727795017745942269828428751105,1698137797127320576751729191866734754105401103859852376273763815257758421427,17656850887825900397821271738817912328294075224643535784810269137125067875996,20755447986835730799031196367323817361150623932048563112034040627213597261325,6221130271964372280138992636208062417325313096379273438539556580491430711297,11042709376363248213366896208587241517252100440844476816212498352999929578287,987361321094619571176752720390429919723900732295551211263814448408232028205,15077982986114392945859048373768437818569856001604485167476360943078774679228,6278894644165961404521866714059972066255652200107181684047812674333675794053,2649747800006903047073625320829560088088800522557851927539477888486006072675,2636278052351769676017824297717609512488651850924228608531372135635042762078,816232991472315395984098922575496846552245086608787214581606973359616326446,14372687274434205592004117128588852491871014819273428668840779210928924573820,7351401720390274950322621121981079413650308506660552567079785209176949174210,10275293929161727274572318228903710245677747557851999483919909420098936352013,14869686444606195206734119702227763209172799407142930791211203702643805341518,937617196362766626935279232045712623531859540210120280128165029613358941709,21331527351771920568751070369057714014285398281585036009305608379072813379081,4305436470381074948146072259605215282335211631970525440530773004228212378618,5894273721571292784412707230481346442881109207745969297947253583203466014760,6512250441044591603946512492071171861967500633638753443182294740883123881284,20863871952569294813936866452848141274047362082838805921071316386912981651979,18788566662709810970880679984141390717017951403407913908833463086244783373013,7784927597396249543149135503684024377171301321636804832597181795981969626201,13818519831569592521516488188127966399245767953522268350556654747680372036664,10515208647860053151690062640705322684876580250632027862984821874343071549235,797604926079325807488629085866693514275115789253871397971708541758696512985,8741784289526985522570446847275649913333939699807282742190607491216732972386,20966712704043418981047968701828936463778140093909973286855779694780086635828,11359697297415630167449040380538108774924967116147664240213257348125754475868,8070907838094569287067982462230761680706116783989613960066342967469297961118,1868550288036217638713133945402464194193242298015503906068429633793800456561,198709459347510170000840600179608479136663571567208109852828485236018304733,1601154135701845545733926027872374554514541574822026314034696802419388627041,4363994778006302991481199477873248350039564117453810275561422974475581105893,773054378219982710451611471050404495804413666789496412742983455527754059148,5209426340109575519362014651321132459061755868557415513439993327176584352934,16124961412020675839394907565568143713078242978522632778625312854364651991011,20812496670075231301471694692369245988519082317145989298573032859079075730004,3312489967581906638742585802390894285073229440039144559060030129184388053832,2967475373447822846542676378804990140732835322255774209561143670843223463335,19744585401442299381952694102570931935735276268739851233412754166721728873141,20026293345566344685499234599699178313754630774489046573312844763673073616936,2611303659034102517884318354550433047021831422518437228002960700934925644951,6230291832603218406134986471162106408091661326026848531605999413028246206577,9126162046556730019959291776456914453189657463686708035601186672661595109020,18827736146609035067773173111376739253733288103277133456626928961785293662143,2328703958261360872869074208611873245571971231035163763965210852182760438390,13796410059666172174899788866809560044715551934510722965495280798363043241416,1593663256684781552813616365605526150610454082601584196604084376715746899324,1565874145189898288764434737762721576951043839540107044892767693968417810945,8709849304563896945461696717753976956465219721409993781555147204068634555572,2994256803561260177499267243802460581941891553208150783951937342406846377191,10452746656507347152042187616753027475507881362159944564077673851918869542550,20130580998875572619695450234900655050996104101008767761546912649074040426200,18926933358104691474037431437316089682088433006245222723356764715400831411716,3783551594057498940671877156409957274854990650480535806320220142873170375307,7919031943604095374667473717154511882451510130166237539514111182596247372692,14518552587329209714850286012780632801030157943402419401997576700600952906519,4770764028263701271241862755569969531641408032906982530346384375773459918490,10866502826034731763529371496585294375373238783964914673031891984092997621879,4234148117462322266937279401468367908013627589417699250592523530383852950379,10747942066055887965185603234524367638106812660210378090215017248140719240336,2587411532912868255102795810490361867789634574022411742057853375399270197531,17350061113113681344498080520518808976916692173267298878258722510332360424059,16490282364669098969805528215926442920328903121380947471680517193373377657129,9274691782659584680377375192682066090127280485689527337429804211265749864190,7630965482352419767782717986075793694403609453648729580916814032587325374653,9483872310024003776681196467845329825094379763716541754956796450187787638623,12182966986735661215639970080491757244218854808156498220088212871061979325833,1853790963611367149183440339188924598268644281518961106776656221408171642714,17425077915972423995335545370701802959607559878032910147159424242864219303096,14571075346526399549826264845894977639678567831720652860528738036970272895919,5627701855249158721927849603102149698163511782011562166637339712383551336091,3620805686755372260289125555061886982808014642356719556961142525373021656729,11556995641752009899073583627136467840237831247117281278719511600076965602980,18960242154096055221658318882298412299294886669455506299567210308762501113202],
-        [16789463359527776692258765063233607350971630674230623383979223533600140787105,17179611066821656668705197789232102741366879862607190942874777813024566441829,18653277315487164762584377009009109585010878033606596417396490909822722930739,7373070639853668650581790286343199505413793790160702463077019294817051722180,4823864393442908763804841692709014014130031798360007432734996408628916373879,19196309854577132760746782449135315310664418272926255500908899397538686486585,18123132816088485879885148351452823314623055244145916622592591084094232513914,18436594886553181913092702411547018228276047601279727265790147051821171174455,15167500404313194506503404655898040457721633218143681920692711693000769735187,9437986152015460505719924283993842205604222075968464846270136901243896809793,21445376105821232747280055223032050399373725161014449207033808524504027971613,49684738714301073369749035791061182456037935161360748355432247732088942674,9826409059947591908303145327284336313371973037536805760095514429930589897515,8494798325496773219358794086647759478982958403252584257436898618394561204124,21251937175072447337747316555423152807036003235223125066270735279039060889959,5539100337780919206842837176908516952801756637410959104376645017856664270896,6297628909516159190915174165284309160976659474973668336571577778869958189934,12792263637464508665199868777503118105486490400267592501708855807938962470650,17254685306085558791725544672172906900581495686070720065168939143671412445514,3590396502942934679818900672232030233017710909687947858184099000783280809247,19055249881366445073616526879263250763682650596233071589085239500077496415637,7367697936402141224946246030743627391716576575953707640061577218995381577033,1322791522030759131093883057746095061798181102708855007233180025036972924046,20456741074925985565499300081580917471340328842103779922028754640077047587707,9059147312071680695674575245237100802111605600478121517359780850134328696420]
+        [
+            0xeb544fee2815dda7f53e29ccac98ed7d889bb4ebd47c3864f3c2bd81a6da891,
+            0x554d736315b8662f02fdba7dd737fbca197aeb12ea64713ba733f28475128cb,
+            0x2f83b9df259b2b68bcd748056307c37754907df0c0fb0035f5087c58d5e8c2d4,
+            0x2ca70e2e8d7f39a12447ac83052451b461f15f8b41a75ef31915208f5aba9683,
+            0x1cb5f9319be6a45e91b04d7222271c94994196f12ed22c5d4ec719cb83ecfea9,
+            0xa9c0b1916a8e41d360d02e6e2e5d1b98c34dfcec769429c851867e46e126fa3,
+            0x1dd6ba3731e49d21e8d36e9d4d1edad245ebf9bdd9ebb60a252e4804a6390f6a,
+            0x24ae2a67c3d521c11a11b7112abbdee30647107b808866a980837d0d7da4e3e0,
+            0xd20c9310b5c14d9ef12866af5a45eae3ca9be16d200497066c8b2ee96781d70,
+            0xe047c9821fe94d55d400d763a66c4c6169993abed543c7284b4a35430019445,
+            0x29474ab799b1e13948eff41d2ce79bfad335d09110157076988ac207e10c81dd,
+            0x3899f139d0dc4b281be3b74ab4c70789b7f41e7aca47ea2722a20d79afbca93,
+            0x1866624f761ab8dd7a91c5f37af5e47639951d5acb6b1bbf3b96ca273f71029d,
+            0x13c119f36718f7d5f09ad8541325a13acf6b34db6d9ee2af7ea06061240f3009,
+            0xe4a1008158077402b11f13c08890b739643cc8e93fa44487b5a1575dd867fd7,
+            0xef505fd44ac10a251b670dafe14cabd9ada9e3002210ac9c3876f37de4e7ad8,
+            0x1d31e4e2a5978b7491c43d367470a5a5d1445b6b8129a5b9a6fd238405720de5,
+            0xa979ad5428d481cb624d9d504524a9694ca5cb4421b5d1dc6af2c030fbeac39,
+            0xf7fccd2ec8bc6ed9ce3682f38aa291deea9373f4995778bf762ade36d6ab2a0,
+            0x2691b924dfa123005f7c078d9bf8706defe99c2ba99bd6ee53b153e9fec7bb80,
+            0x2077df6510b4860e56b913bef3a80dbc464b0e4678add60dea7a9517463220b,
+            0x29ee09d8af9d24ca49350ce2e0aa47d00a3dc21bafbfac1c9ba61c58e2993e8c,
+            0x8b292c661d427506b9a01916624f3cde332aaced9f1a494a733cea6f25bfaad,
+            0x2583699ce536a757b22e4713edfbb050092c84abc72c90ad87393a1da9a4cf90,
+            0x1e3f1b660223d65ad88999475374f6e25fd4148eb8110a0b12cffa19657b0b66,
+            0x20f3ecbb37c34aec79131455461259e59b222f0ee8e02f3194cf62a9ad4c3448,
+            0xdf4f5088e4444fbf87d553ba62dbda95696d8b9cf6210b1c85513b1776fbc64,
+            0x2b348effd4c9cef00a1cf4dd67dd664b2ffe361a807c589a252c63bcbfc6833,
+            0x1ba1e522fcb153676cd8f20e82256f0327c000fa96b1b462fc84b556f26a86c7,
+            0x294c44df8e68c96144e964c37bbc5766764ed3550aff80dbe9d3fa74419fe50,
+            0x313716eec6dcd8a602ca040700498dc04c77dfe2194753c59bc818c1d2636a1,
+            0x287dec74696d663e2359f68225de955384d960bbafb90967429a442e19e3ec61,
+            0x25e42f72c6be0942311ba097cf365683db4962c8204fec9213f0f8f72c1946be,
+            0x12b6881b96654fe1768c242acd5399b08639f081a94896f5ea6da70b6b475c91,
+            0xdfc2b54546fd3267d7be55c716cb243ef18118ed9498c8270449bd9418afdb5,
+            0x27dd55fe0d5c0ff56ad4890fa029c27c5f36d04cdc73899ab99b2872b28eedf0,
+            0xc60962711aef16e7a2ce59f587443ec8b41ef8dcfccb38188adcbddd32f173f,
+            0x2edc09feb267c6b586e62fffe32bf5f16c28b585986b81116684b7e8b40d42d2,
+            0xaf8386859db252ff295a19466d8d100622c90502137aa1cd4c4bcc9656d11e2,
+            0x121f218392f73d4c16abe382102a459e6c080b3ca4eda51a23e651a13a680550,
+            0x1ea38273f5d59e65061f8c775c571ffc75ef67d29405b5e02913cb3019d56f8e,
+            0x9bd2349005699bcc0ac35b627e2f8f08bfc3b0bf30b146f37742ac1556187fe,
+            0x91c505b1e92448c11aea22aaac4d44f6a7f2132f89e91b7f55f9404696c1433,
+            0xb316f1c29689d4f490f7fcdd5e9f2d256d443ba14cda4bb799b0573a931a99f,
+            0x2049251919a8f3f4398188b81f99d2e2d0e3f5359cfa55bdf3aa75fdadf367e7,
+            0x1fe7f9eb6788101908814168e3e4cf7a899a105bf9e584af0064188a4aac55bd,
+            0x158e6579b0388153b0acd630ea94de8f6d966d529c2d01b9e9b1c67c1ec1d570,
+            0x1994f82f27153afb9de2aa3f4be05c4b2c487e393dcedca2566aa6b7fbc3696b,
+            0x1b6250553e8629a5a8a40b568432ce7dbd83c87603eeccc8dad572ccebef6e1d,
+            0x20296940a7d1eded2ae79fd78fa2ac11abb2210bf24542feabee71f0d0d7c9e,
+            0x2553943f9e0ffce9c297cd31c29f1fa5f01883cc9e504fded7a905032c170c89,
+            0x1c56eb362896c2f00ad18faeaf04d577f5feb4db4e077965c38f2eaf5f7be08c,
+            0xed8857205e0680055de7e822b6f7d62ac0f75fef67da1ff7b7735208885cf90,
+            0x118f91185a09355f9d8c3f556367a2bebe79e7d9528a8d72a592681671aac75,
+            0x2a71e6a67abdb25a78010fe6fe0a20d1d84e21cba75ad55937dc1834c13af0c5,
+            0x2327dbc05997ce8575680e4b8929d4e9ed25fb9204277d603061986dbee57e0,
+            0xe05235e01f21cc3f2971c382d18c14e41785a5ec8d447cd93d13281792e6d6e,
+            0x98afa2ea7ff065b2adfc4ab00f3b04496c1e490eab264d2370b107e5a49204e,
+            0x27bddb7bf06eaa63419adae44209dd25a4e35edcb863b009bd34ccc4905d204b,
+            0x2704406bc806f4ccb19085cb9d3771b12ab5ce7aabf0601e9e06a2bc98837ade,
+            0x21c75c54664b9fec86756aa9027261975244f42cf91c9cc0b33c2a62b756a3ef,
+            0x2be84c1d84c16038ea5f933290699daaaa8164c5ea39a02bcbddc66cf69fe8ec,
+            0x2c970e41d48649cf013c676c8c688ac165563720d1d5f32628ac5b239488a96e,
+            0xe1ad2660a2e958daa1f2654b3a37fee60546ca0327150733070742edc806435,
+            0x2060ee7fdf775fc7e389a55376374c9e35d5c8763d597f426304e236f577b829,
+            0x1e0116818c843ed86f09daee0a581af10d52deeadad77656e736eac08e6f0f17,
+            0xa89c1498ef25a383d886bb58424e6940ac399e3e557e9de951a697c54a7576c,
+            0x303743d6f36d925e1097483350f5bd2cb297d4ec9239209f63c516b849a67e6,
+            0x8cf44446d968430232df175d462b9c9b0e2e2c37e8406764cb96c7c3446018d,
+            0x2419811cbaeb3f551b0a9232eee5d53e3769fbcf5239533074375f1b00777f16,
+            0x4237c622626db376b774849dbbe876809082f1b13f5824f4c58369f27fe7b6,
+            0x1e5b490c72eeb607e114a5cb87a8494b178937cdee34b9e8e947342c14454558,
+            0x4265333e59e1a5ff749203cb4a5d1415a72862c61380b1c242d0f32ca15b97a,
+            0x189deaf74258451ac4da682532be43d24a5c683293c1ff7486de26d35d982e86,
+            0x4ec516b0fd42fa53a34905cfdedaad021b36399d03d8263ae08c46af3eca76f,
+            0x2ce1c8a00845a82b3aa1b6642fc988578576cef86196525e6d595c7701ad700d,
+            0x247816fd0d34f9d3b396917478605c94a1c052a6ed663bdc344e7aee9686b6b4,
+            0xc676dbe6c494d5609c444de622bcf60cf555091a507fce86477019daea987d,
+            0x1cb395ade530fc2407aa7b2148d2dfaee30f4ddf258fc149cce3c5cde80a85d5,
+            0x190e1494e3cfdada3b9e65d8fe3c1ec769540da023f9ec2e56259f6a56890b0e,
+            0x18f2941b2335138336c351a792343222a845ee0a2ea5a3b9160c1d6d9b229fe2,
+            0x14ea23ce8b2312e07df57e0aece1da5d2c0e01f757e6a5c86ab5e403688544dc,
+            0x2818ad1005f4efb5d554361a29f85ea10940d6e71f38e8369beff3563a660bbe,
+            0x23ce3a9a522915a281793977b49054c37d65f90b841e0ca90817bab49d79db4a,
+            0x6c2ed2be876309a9b3b44ece37b1c42382927dd04249658a3d41e3f38d5e022,
+            0x18b6740f72d77ebcf642b945ca2ed6c8a9853a3749d7fab6051e4ca36f44fc42,
+            0x1feacb9eb2a6878061374d069a9dae328369ee63e75a1b99cdb06a48b0d9976a,
+            0x1a44ee4565a967647300c75ed2b2543d8d45d5477fd606a356d1073bd13831d2,
+            0x41f3b3b5b1050c16bf3d62d87d5d273b067da484679103231ed65a18da9fe48,
+            0x1fd958cc4fe0a290bd0fbfb8b8a513acb5898d63bc0d7e585b7d081c49eb5659,
+            0x175daba07c5edbf84f09c87a8c34dd73325943a48fc12cb839dca47512561d2e,
+            0x9cf0a4e6e31dc24dfd5a5a27a77833e477d5b2d92cff5fc5ccad9528c43ba78,
+            0x12d49465bd4120cbf78e5a3414d44c6530bc963bd701c54d4c6418a6cebe80b1,
+            0x101b2f2b675804d3b26b2bd1e07c7365af0bfc2edf010916eefb39e28215d44a,
+            0x114fc65faba09a59749e0b5f111930783529a0638456216232cb7e5a339736aa,
+            0x1dff99b52799afc802c2bbf9b67dd044d3cb51017dc4f88358ddd67366d3a9f5,
+            0x290f4496a52dd4dda59edccd7325038bbdc0554ad3a9a0be7931c91062a67027,
+            0x91e8704663c516c3b96721d2033d985089fb992dca48c8ddcb97d7d15c7e188,
+            0x2dce22599de04196a0169fc211d0f9c8692643aa09728eadf6d50bb534c0e323,
+            0x29a7ff0720e170c0e67efde72795328fecef66daada5f0e2ca858a8c6135fd48
+        ],
+        [
+            [
+                0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+                0x2a70b9f1d4bbccdbc03e17c1d1dcdb02052903dc6609ea6969f661b2eb74c839,
+                0x2f69a7198e1fbcc7dea43265306a37ed55b91bff652ad69aa4fa8478970d401d,
+                0xc3f050a6bf5af151981e55e3e1a29a13c3ffa4550bd2514f1afd6c5f721f830,
+                0x2a20e3a4a0e57d92f97c9d6186c6c3ea7c5e55c20146259be2f78c2ccc2e3595
+            ],
+            [
+                0x25fb50b65acf4fb047cbd3b1c17d97c7fe26ea9ca238d6e348550486e91c7765,
+                0x281154651c921e746315a9934f1b8a1bba9f92ad8ef4b979115b8e2e991ccd7a,
+                0x1c1edd62645b73ad931ab80e37bbb267ba312b34140e716d6a3747594d3052,
+                0xdec54e6dbf75205fa75ba7992bd34f08b2efe2ecd424a73eda7784320a1a36e,
+                0x1049f8210566b51faafb1e9a5d63c0ee701673aed820d9c4403b01feb727a549
+            ],
+            [
+                0x293d617d7da72102355f39ebf62f91b06deb5325f367a4556ea1e31ed5767833,
+                0x28c2be2f8264f95f0b53c732134efa338ccd8fdb9ee2b45fb86a894f7db36c37,
+                0x15b98ce93e47bc64ce2f2c96c69663c439c40c603049466fa7f9a4b228bfc32b,
+                0x1c482a25a729f5df20225815034b196098364a11f4d988fb7cc75cf32d8136fa,
+                0x2ecac687ef5b4b568002bd9d1b96b4bef357a69e3e86b5561b9299b82d69c8e
+            ],
+            [
+                0x104d0295ab00c85e960111ac25da474366599e575a9b7edf6145f14ba6d3c1c4,
+                0x21888041e6febd546d427c890b1883bb9b626d8cb4dc18dcc4ec8fa75e530a13,
+                0x12c7e2adfa524e5958f65be2fbac809fcba8458b28e44d9265051de33163cf9c,
+                0x2625ce48a7b39a4252732624e4ab94360812ac2fc9a14a5fb8b607ae9fd8514a,
+                0x2d3a1aea2e6d44466808f88c9ba903d3bdcb6b58ba40441ed4ebcf11bbe1e37b
+            ],
+            [
+                0xaaa35e2c84baf117dea3e336cd96a39792b3813954fe9bf3ed5b90f2f69c977,
+                0x14ddb5fada0171db80195b9592d8cf2be810930e3ea4574a350d65e2cbff4941,
+                0x2efc2b90d688134849018222e7b8922eaf67ce79816ef468531ec2de53bbd167,
+                0x7f017a7ebd56dd086f7cd4fd710c509ed7ef8e300b9a8bb9fb9f28af710251f,
+                0x14074bb14c982c81c9ad171e4f35fe49b39c4a7a72dbb6d9c98d803bfed65e64
+            ]
+        ],
+       [
+[
+0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+0x12873658ecf188d299b8ccd568eb14a4d4307c5caa95633dc296f05cfc966598,
+0x153cf8033d8e8a15cde2c5e6b93da4018c5954d00a9274ec5ec6d5101ea22761,
+0x9f15a882446823fdca6f6ab15dd8e250d90c84470516671afbdfb0de80fb00e,
+0x167c655bf6cf3e0fb64c9075773bc862b24b4ce2f69c8ec198add2758a2ce216
+],
+[
+0x25fb50b65acf4fb047cbd3b1c17d97c7fe26ea9ca238d6e348550486e91c7765,
+0x27f9160806de9ef57ddb4243f839e4b7e8bb293ac176fdc5b5419ed73a07999f,
+0x16fceedd703bbbc2bc6f1d792e501939105b044b1b904d3b110110da983ccdc2,
+0x2eaa925d06b6f5a77c0d5cb20598742791495cec84593a57ee9fc4c9115ae7ca,
+0x279b324735fbc883e24f191ca7039f9986115b9e6fcf4946cf45f08ceda2dc8c
+],
+[
+0x293d617d7da72102355f39ebf62f91b06deb5325f367a4556ea1e31ed5767833,
+0x97d71f1fd579a0d0f436a6b36165cd23a9fcab03ad25e7872cdb09b4a0ea0dc,
+0x1a9fd26611128d592d594f51c251dbf4eff6dccecbcf2ebf310e34bed661337e,
+0x21eb30a57e5912ab06d18573fc546b2bf3be840d5f5ede01f91dd2bbb578dcc2,
+0x13abaf72889b31372b1e6f48759371ef65bc57d28ac2f60e6d227eb008b96ced
+],
+[
+0x104d0295ab00c85e960111ac25da474366599e575a9b7edf6145f14ba6d3c1c4,
+0x19bb8abf6a012cc7b8b974039c6be6df31446a51702b39a8d90ae4be7ec33ec9,
+0x11075889bc0dcc9d6f06af3012f04aadcf9049de04fc775f8fa091702e70b9bb,
+0x2e4cb25599a3dbf07de338827b28d16b9c8fcab8fffe8f2a16161be6a521a358,
+0xc7a700b33fb23fc642e0e8671deb84d05ded8ccbc968d15171182e158684e85
+],
+[
+0xaaa35e2c84baf117dea3e336cd96a39792b3813954fe9bf3ed5b90f2f69c977,
+0x2b5d28e8d648bffe0fab59e3c7d983a4099fa0a4c548df0006e6d0f4e20206c1,
+0x1a96c37c461ab8a38ee15bc2784c5096d30d1482e57c2f861bab95584b90d84a,
+0xdbdd3171308bfcd3cb8b8a676592858b8652e902142beb8fe4145002fba8e0f,
+0x17ac4855f295a3b8fb8ceded7f4b39290647a0145af56b03b01e957808d66fa7
+]
+], 
+        [
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x351d582486c39726623750495e297970b0e19787b49173a9388a0d5b08788ab,
+            0x10e1a3beae297a472a31a3b51514c664abb12ec2d15860a29d2a9352d3ce8ba,
+            0x12395fabf1c14664faf3ecc72a84623c1d5cb7b5e5744e602c886a5773e5f06d,
+            0x9b91873151f00b299a173a5b736f73fbe2ce543f0b4d237565bd58758935cfd,
+            0x1d53cf618f93c90852172c773264b8f49e938bf22791cff829e95ff6942299b,
+            0x1a78e48450798918f254396fa7417bf2c5ff69259200c2a8d53af5f2c4d8ba1e,
+            0xd3d4c1eb9828c87afeca8ea128d1d533750cf555c6b70d70a8520ccf16feb,
+            0x3af062fcd1ca71ba6de0ca4436f1a5a0698a3f49abbe4ecf3daa0ea2e4dc84c,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1ad1ba4f26d401924b25657414256b59767284a692897ba5cd53a7f5322005fc,
+            0x1133694747d2cb4890f4f5982564eac6019ca5a9091b302d2c10b87297041d5f,
+            0x1b46c42ff1aa475972e26f559a88164024234f7b392039fb2a2171be631bd8de,
+            0x1954aa0a79f14968c817000929e2e744262871011f238d986086e7d9574936b4,
+            0x7aced898db99ae9796fc7191a103b9de4c77f0e08ecea6aa593974f652ac4ba,
+            0x18a5a098d914f6221726d42ada7683a1605e20217a09489c9b2d84c3cdd2c39e,
+            0x13e00cf4ab3b1e028165af8d41019ca20a21aeb40926592a180f9806083eb5a0,
+            0x478f72938b528ec79defe09215b46320801fb752ddc88d638a48790561b4e2b,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x8ff43b0eda2134077b96d7e4cc37a6871254910ab4c58a4bcc78c1bc6ce3937,
+            0x27d7fa3ab9c438b6ad1ec5a60e8ad91aad02e4d2908ff7192e5ac0cebd91f928,
+            0x1e9ac8ae7cf2b40d629999251be50d9771391326a664dfc206f2abec8efbe56f,
+            0x2d6b56b4849de82b636d81f2e98476bb6c35cbc8962137b615bff86f8f261971,
+            0x21e70566d2f4bb8728fdb3749da99a2143a0d90bb6c1b0d6d02125aa1fe63092,
+            0x1c01c050dd9b0b8ec8e5ee1eaecac1171bf69a8f3d477eb7ec3a605b010d4ea5,
+            0x282e8dde73a0dc74ee10816aacc1dba10c142109c14ad7954eb7b56ca268a16e,
+            0x767cf96b16035a96d19fcc57edcd92e746d226cfe84b733454c7ff9a16d25cc,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x18974b9f253b6bb681f82ed0f2d3e6b4f70ca858468b7f1bd3ded1a581ec21d9,
+            0x18153fe8966abfc450a25222a6a27f6175fe851989776dcd2111a5a2de99c2da,
+            0x2da1e2e775539490c2fe2c827e65c00e382a4a5d6c49a8374381d39c627f36c,
+            0x2608589b9cd3f4c12b4e832e05fc5ebdcb403cd6560a8d7ece8d17ac94e79e06,
+            0x5b4b074edb1366d35bf1c1ec1451a36cff351b407a8d30d563471bde491f146,
+            0x856cc5a00bc37dd0217920da66c5765dea0644555e35822d7fd464d9eb38096,
+            0x2021dde3ed193bdade457c9db5ab799e6b3fca640669d2f6295b4852f54d446e,
+            0x12e3785f05f36bb797b2c9f03c5a55fab52e88b0550b7155d6013b706574d41b,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x118084c76d1340b3980add4df3878df4ffc6e9fe26f0b5c4e2f9579ee6fe2c1a,
+            0xb9dacae8623c514c622c85753ef7b994d9102ab46620f956c26e9c62fe53050,
+            0xdaea6d18a826bb2ba972ae16dc621cb8fdf9ecd531ee3c9f9d0b4012da6769f,
+            0x8f2a5df6437e253b579921fc3208b3c176e5a18dde267a4f85b7afb7f79ceed,
+            0x6a91d7c75e34fd43d9aa53b7d2793e4d5d70a5fecc5fd5653b162ba2631aa68,
+            0x207579e33c36af2d20d759996c313f78dc339878c0a289d5db58b6b3d6069c56,
+            0x25562540cd12084b3392c8cb8cda95ffc9c2dd6f8a75054ce16acf87ba871b9f,
+            0xbbf47feca60b93dd0501ee0fc294c2a82b103817b4acf0af6979183afcdc87,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1e0814ce223453b24804a1ab4ce39815e35aed2fe9f7510e6288abb9d8b15711,
+            0x18f9aa2721d95963399ae18d6d95a6f81b78b528e750554eb2613d6dabbd72a9,
+            0x2ea329822ad302ab8831c559c64080e7ba6bf4c98ea0caf9cddd929bbb5875a6,
+            0x29910d86bc27b38a93bca80677a3647c01cb5262ed19cd0c00872925a046a338,
+            0x21c0a05ace45015ea895e01d630ce6b7423f3c211d26e8b6ef54d3dfc0660ab,
+            0x25e7c463042f520ed2ff8c68be30bdddbd7ea5cdd7a91224bc6a32a3f5c0fcc,
+            0xdf5b7e7663197f911e0dcd1ff4237ffdf080234e9b92201538ae7db6b6a7d21,
+            0x94d0fcd9592b4771d2b9bfbc2bd78defef3b6ca923c68382650f9d63ce37c85,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x270361108967ed0391a49d4b7cd6af9bdd544e8bf048658c4fab36aa12407263,
+            0x18bbf89e7cae93044c847bea654101914dbdd1656483e54e07ae332857821961,
+            0x4aa47a0ede64ecdfa83507a2b8947b4b587758d75239071f6b4d3d66777bc1e,
+            0x182d30ec988fca803ff7def1470c06aa6a596f56710184909fda17d354d3ce02,
+            0x223c27171e456846dffc59cb1a53c761afddf85582e4c70ebafddf10eb1f8448,
+            0x7d46dc97554a25edb78ea4d862c48bc5a08e9ea1eb369c5c8c2e0903114c915,
+            0x1bf473a2e982e519523b486d264941d8e32cbbad362bdbf736d7ac04c4d2a964,
+            0x12277b175bf54c3f2b0a57eb189e77714cf21630ace1fcf44d39397aae5b6da5,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x15c0a2cfffac7feab86a185031f489a9f83e89e3337a84b51dfe6fbb57feb15b,
+            0x2b83199ec584185de52190f5a415c1fbb9efd4bb9eae4c4e2763abcf99359ccc,
+            0x28601b9940a312c65b02adccb76937ef645d4e451c940ad4241b2b0f4925d7da,
+            0x1a187b4875be24a2420729e016901b94ec0566c8a6936978c3f21e8d611996f7,
+            0x10ed1fd44722d10bc7e44824e64978d36e68d56de2a465a0201b8e31065d5c57,
+            0x2c4b6867179a949d377a9bfd3efe48456f7e70f02d859c78684a3573486dc227,
+            0x15cb2c17aabecf7aa0f61655a8bb35a7afd87d0e20ac38fe21a07da7b388dfb1,
+            0x4dff03c742111aab3e61f4166a733e87699c1ffa889fce179316e39f7d845ec,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x17baac874eaaa88de70cc92d5a72e00be4ec0e5e99ba7cbac2b0d98cead394a1,
+            0x1dba338b4779919a2fb22ba949a050c85a73983d5ea4752cd73f664fe05f6247,
+            0x1e33e7fcc41f32f90de5771d69e58f4486290c7b856becd5cd967d8e7739f719,
+            0x10877ad7cf0652a2ff93977d3862e3ffb5d87d0c040f02a4f98612afafc9b604,
+            0x115d3675856ff59ebcc9110defb9d6c70df6af533d4b0875d0e5eec430350595,
+            0x3d74b961ba9013a874e7bcdc782f478da6097537549db7e6af4702ca749dae5,
+            0x2563411e29867500a8fd18e4eba3c9a2b7992e44d263c29f7e06000f74887cdd,
+            0x285501c4e0ee1b3c3e6b1b29160d6ec0f1af4dc2f36a4a1e654b7b47899738d7,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x209194489c86891b179e33103a81d969c5c75e941dc30e7228c04ed8ba68704f,
+            0x2c7b2835cb79c29852926900cc168b2315aaf03a89532dd9fc162c2f7ddad845,
+            0x1df181c420308c5b0bf00ee21c16f248edff686e9e835869d1022dcd4a8a635a,
+            0x1ffabdffee2481d8cc1233506f708d9acabc1d758bb99c329142c866ef4c7474,
+            0x8955ed55c2bec07027e4355a694a9b6ae1d9d50126563b29d8a074ea65540f5,
+            0x1ab4b24a4db7c5758471846eb375163e7587791417cbc355b6ce93b64fd01da2,
+            0x25a3439d2838ad459270bc633164f3a68215e11217eef1d605ecfa8b1805c609,
+            0x65240d63179ae83013295a8251fbe17dd988ca5c84761ccb6a6ecb2bfbf02a6,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xc1a91ddc1b24113bf876a2ef895c3315cd1b109cfa569b79f3155ee12b1c564,
+            0x146fe8e28539ae36ae921069f4af83f675f1b68399efceb18989cab5fdd36ac9,
+            0x1ba8c3cfa46425412e30790090980db139810efed7bdba7a38adf75e1a0d3641,
+            0x83a58c9d889b74e66636bb8418db624726b0f1374f59eafb4d269ba1ed234d8,
+            0x2b812a76ea526ce18df6032192ef033541aaf99d1c61839a0edf0336142a25f3,
+            0x295f6d35fb9e57a50a5d913600538030ba8c09e021c16aa8634488cc8eeba645,
+            0x1de69ba07e3b9f90c87eb67b1f64660c71befe5138061dbebb752296032542e6,
+            0x24734fa363e52c64ee0162a86578ca899796e89caa1a3a3533b0965665208f59,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x2d5fb67efe93e8386fac071fe3522be1dade9dbf1d1030417a7b51e3122111f4,
+            0x19522e9228feae7473e317fd7958a021a0b042a81b75da6dbf7568b857afab75,
+            0x2bc3f6f0df0c7305afe83fd9ef0b708e129fbe889fce42cb695b33b290479342,
+            0x783e5635eea0e623bb8c406909f0db77ad4f9302d4828b51015d6512818690e,
+            0x2d61b243f02e21edaed6fd2e4969ddb95a6d0da8db17d115a9a3b0d8885bccaa,
+            0x55e1a09f4bd4809a86e67f99279fc06ca89a4468df1ea25d76fe0ad36ccea12,
+            0x17871eed22b0cdd2de61e55ba5c9f4e37da63ed0376420bb1ee7f077a0d7a85e,
+            0x20fd0af1329bbdd70d4d835d18c915d98956c5f0a4252cfb81c1fe02fe130091,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x2e5b840ca8faeba6ec3613e22eb7b071d9633c83cef659ed96b2f6a8fcc6b262,
+            0x5f5385703edf7c4a388ce585a81fe7cc92ff49e900b5601865a352c61d6b111,
+            0x21e83ab5e95d369ccd30cc1c55cd5844cb1cc78ffcf0c8bc91c9c0d9937a3fab,
+            0xa67b7ed9c37946306ac525597f1275b30a5d004ca50258c3d992284d90d724d,
+            0x214f52f9f73a2c2d5425c9610461303d839dfe71891489c376c2ea3b5d868b27,
+            0x241e0d267f7d1d899656929cdebd850f70ace216d9ac10253ab720bf40da0c7e,
+            0x2229153475b7a6b282e110b10e8aed1fbc2a05a37352e954f40d85205fbd8bef,
+            0xf30d0b7cd8ef10e895cdfab3faa4f4c1a61a5f4eba688634540619c84782d2d,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x265589a340c71d49e1660d3dd43d1869408176d8b9110ae8c369078de8ff7aef,
+            0x1bcadf844bd1a2e7f4f464991dd651b9f15630c94977d35ebc3e85801252ac2e,
+            0xc112b1c56ea288e8518cc039fe050649cf40b7ab98de8fdbc56eb7ef6bcfdde,
+            0xf020b9ef75af8ddd505cd3947e11a04270be15daacbfa76fa04d9005283aa77,
+            0xa426601ce9415e666acbbaf2a7cc8ef7ef7d07538d84b1a53da24c19c601688,
+            0x10a1af65503614381fe2003123aee9008ab97d69739dc462e72a8be04594618e,
+            0x2d792f9fe5f0ad658dddadfe3893d158012d84b3837b7415e188131595b060d2,
+            0x2daa42d04e0b62fcb3869031bf382c3b9f8a98f7f5bf7421d0b63c2598f5f65e,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x144c0395157a1bfcfb5cc4187f271096784dbcdbfcb6a28c31ce8a06f908c0ac,
+            0x1af8cdba0eccc83c16019622667527645e94c9ce64add4415df7f40446277a09,
+            0x213c7a7ad6237e7211530c210a8d6f46a25bee433bade010591e6adf42fcd906,
+            0x224f1ca24803c0119ad0e6c41a64968e064a83f5821972f2a5c9d5895da4ea42,
+            0x10944d95ff5a3699efdde41ead13344937e3b1b93ba73a1531246ca4b99aad2b,
+            0xcb2508b0a3395fabbeee5286ce5f1839c006ebbc09d94f475924923d8079ec2,
+            0x284a14b1007ff6c5c0f8f7d8d0e4b19fe2d4a7094103912134b0f563a672acd1,
+            0x2bc0bce43d55bfe1a27eed426980cf9055b0dbd42e8de516e77580b9d9a9060f,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x28e9b1884a4619b38b6f8a384368c358b7f210f3412c4481a26ae296f73c5c72,
+            0x2123ca1f119a35e7d4e1b323fd2942d12ed020ccff3a7ad6b65af90457f00614,
+            0x4aaffb0ba008fb9a82fc0700beaab2ce39efa895acdc280252f01e31035b8ad,
+            0x1f1e16f8ec9261c82443b9b31cd908015e2c2d2314629a22639af1f37e1073d8,
+            0x134928ff5ebe5e019214ef937b7f7a28248285d583613ea2bedfc66b5e2ae924,
+            0x87fc99e11e63deec9d55047ac98030c57a4f09228cfa7749a3e1c7ab5f212e7,
+            0x9429bcc52d6c43814df5b07fa116f8875299500a36ef791b592a64e27cca486,
+            0x2267b1dfa5d26e6f0a80bc8b4c0026f0204bd4fd06c7725544d7760354e401f4,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x16fb3cdb76d21d3448c9988f428d198c8e5a640035ac2caff7aa7964b34ff1dd,
+            0x80dd9d263a6698479df06bc98fc64594478028b61047ff93c425b29b092d37c,
+            0x165f4f2d302a24eea5f46abeec4ab03d21e3d013865085e515bebcb2684af340,
+            0xa8a3f3abf28f457c62045789fdcd302f0df1049b6ec521db2b7e72e8d9516cb,
+            0x2342f103587a005c977578b12810378f9014bae831809cf7ad59ef3aed48aae9,
+            0x1d1308e311e7ab846e158769c12213013eca377f396061aada6220f29eb1b7d8,
+            0x2563949aeabfaa782be07dad903ebff5c913893761b75a3f8402a1e2bea5a998,
+            0xcb371898d8d2e1f5bbc32dc21782704a73e415e0c9f6387157b48746bbf6ebe,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1231d40e7c6fe5bd47010ebe4f63d186369cdb6e8823aec194093a0b4cbc6845,
+            0x18943696a4da551747068255f57a0437ba0ec36ad7e5c92cbed9c49a9775b97,
+            0x1fa58f378160dd4af40e3b01bfe32dfd34f2cdca527973c194a53af30bc40670,
+            0xc976561eeade533c5579041bcf5e8272e4af95efe3af9e5372250fdc5ad8966,
+            0xcacfeeae1a8359ae9fcf831f315a4b8c576d579eae86b1b09823656231d3bff,
+            0x109b0647298eaec354e4a155308192b5facfb586bc2fe63f073cd221a2106fb4,
+            0x69d4744aca289d123baa0e6754c5232202dbcdfadd0ee8d14dd19a7bea39781,
+            0x156195fe27df23b8184fc58a30e1a9bafcb9cc9fa9ce071163a26dccfb7c6ad0,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x20fed35942cbdc86df51a49ca26055bb25e232a42476ef06997af8911560fc12,
+            0xcf20343957a55345423dd3450c2fd74039f1a82c6c02446dd64c4569d31471e,
+            0x1e177139b05dbe38a56c40f919dc1f07126bad03049fc4025d77b4bc34c25ebf,
+            0x144d1944a849fdc2aba8ab2a4368d57911e9614e3956d9326ca493c83050e932,
+            0x162f08d305fe4f1b0a9bb1acf1223bde3405aecbf2356508841b85f1180cbc1d,
+            0x21d68868502ab599c7c5f2a54d65be40ed5caec1613a98b2a98c5f8117415d97,
+            0x984adb0c5263193be4027c68c6f3a6dbf7e22cf199dc4358b52968b0a248789,
+            0x2883f3a940a8c10f7f347a8011b0f0d7f6e0a4a82eff568fffc7524235d1e4f3,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xd89a340993be3d3ba07d2fa8432d412730e8ebf2bbfacbf9378c0c4d3d1e692,
+            0x105e4a12836770bdbab24c85e7a63572c77556fffafc8f55a0e3f6e7383f7b02,
+            0x4b09e851bb6dbbffd0780af3f99cbb707f5e8a073810b28b1b59794c8b117a8,
+            0x2c8031907c10e1df2bfdd2589dd502a012a2292202e67954091ca57d21906d41,
+            0x88a360cf4c5e26faddcba291dd2553906abd82fecb0ffaff4f3f544f672d703,
+            0xe9e8d8ba62712e7f95840b5651f32912e84f146bbd57c566c178084cbb155f8,
+            0x38fbaea7dd737c642ec414759bdeca4250d31d6011140e7e45e86c12c6f6fe2,
+            0x96dea6e0d6411dd0c18e516511b03d8506c4901c52dbc2772c3d47bdbf461ab,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x2d60fb66fb133b0507b6b41ed7fbd5278c4ba9fa0679d2889da9672d21f07037,
+            0x2567f444cfdbbf4d7799d5b50c8c582e1d2038a11969b3eb2b60aebafb1efc7b,
+            0x2401d941b4fafe3311bc6cd9fb0bef62ad9b59e731c1ec4e6b0ca5e2c685bb2c,
+            0x28747741579283853ed4e6525da70a4312769f7040db4f098eb7d9214fc8fae6,
+            0x1104899fde3f530cf99500f20c4fb9d479e512cd70a15def442a4ea92bcb9743,
+            0x4ddfde1b1aacb33977d4b3020db51b834f6197a18505e3ccfb37fa8a3a8764c,
+            0x2bfa6913d62c8aea04ccc3e50229220efe3b9af6a568194ece56c065e3cac8aa,
+            0x5cb914ec7b72436cf25adcbd0550c2db3c9c09aac565d46f96ac156fa72a90e,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x145dcc8a89ffd8fddf4e5bbe377a3b7649ab6faaddf5eb580ced3e0421b7077c,
+            0x21f1b7c169a0744e49718346cbd390dbe3287f5de3897acdaaf2e4bbc1f3e80b,
+            0xeeae34b5e8e48d2ba6bd062c803ced1dd1165cce5f8f0574ff7caf4e6eaf6b4,
+            0x2827170c30a7f570a12f37aa0434e01a4aed9b5d37f1815029d5de89a8ff75e2,
+            0xe328161a29c0376af526c8004597fbe018328d6d0c89503eaee36f59a4cee8a,
+            0xd6617ff29ac941a779f907e749603cb36778fef6644b8684fa40055c8d978c6,
+            0x169506e0877092fdef32109c064d251c4d6a50257ab9c032bd79801fa23094ba,
+            0x8c516740479e1a852294e8cbbcbf83b4d7095b69758aaa9f1a368004dc1742a,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x281bcec4cbcefa9e18a1aca1dfeacd7f7ec527df5deb6c002f541ee4c0f2bcda,
+            0x13ea58a6a82bf43f6d4c2619b87da0ce760410b68b77f694685e3f34ff47b86c,
+            0x1ed604569bf581c71e4180d59a78dd48e2103006ac045566e44162656c36080b,
+            0x15d25d19f8fb93c9272f10ea525e787c758f98c5bca884e6317ed21a292abf6f,
+            0x1696701143abf5794f370a122fc60dafa4f0c241e8607983222bc72d1d8d1439,
+            0x1471c9bea5d880676ffb53255487c1af57a0476b77eba56204a4a3780b109b50,
+            0x1ec18e953909ee6e34dcbdde64fd6ae8b99817ffef4811551a27924b714cc00d,
+            0x89ad915c65eb1cc1633229dd97f098a2f86e7ea44ee6d94f3fe5f08682c807f,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x7e3bb22a5d8f517b12b42d68ab707d809ce83671dd9a933313d251889a9d55,
+            0x142b4285cb7ac7249975ddf59d177aeed1a94e0412002d83861ce061e3f38621,
+            0x24839c6f8fade0c2ef1e248f64c4d81e324caa4ef4052916a31c5d1da484ec43,
+            0xac0879ac864dc7bf40955a3f4a19cf37846fcfa9289ae59c8f8c7c174c5a57e,
+            0x44832eb1eb4ac43192406deb4a37ea61e2d110468762d3a31f01f3c6c1f8208,
+            0x2b3f948fb289860a26e995d14c6f8aba2089511c7ba58a310e6cbcb533f2dca2,
+            0x118bfa7e2d1386301f187c1b1eda2f48c0a03de15e370b5be0f431a0b574681e,
+            0x1399fb352bfce7874d22e0fcb24553b96ab59b85364c0c3c9b0135d4970c2349,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x2f25d0089300da1d286c5efcc9cf22d095af8f615b76cbee09b9ba651d737311,
+            0x84eaaf7a0b07cf4992c7d05790c42cc742a7bed021c48f614b988d99f141e3d,
+            0xcbb53527ad34cbd3c4d59504fa47c87eb5be078155e58ac3f1e4b3f45dd1cec,
+            0x14e8e0d80d2af6efd3cc60741cbc21f6da3a42e2429322bc209097b1d22d26b4,
+            0x149dc605f3ad39d4b470a132191d2739df2ad19fb71e067f6ede3f9da3172922,
+            0x1533cdda4fe346f0a3e538172b8d5636d3b4b502047cb268015b2088f12b9897,
+            0x1da21ab47505b1ed4358160f3cd24a01330718bb901beedde8cca37839805c62,
+            0x130eee6229e6346096e121bda6bd3892aba85c363deda16ae8c8efc6ba721b18,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1d0669bb3cb83ad8702a76855510918ef300df2416cdf04a83061a915a6fbdeb,
+            0x113f0f0db699267055417d499467b7502e23179a0c23787b7e8130967c95080d,
+            0x28cd66f5e2046799405a9c14282070ef66fd409507971fcbac16032499bada61,
+            0x230173d8146362d28c0cc9bc2c72a64afa7741b77653726017932821c1dc9502,
+            0x4b23de911f3a1d3f32366c35a7f293837e1e7e8287b8abde423b2b3ab81c187,
+            0xd4bcdd5ff441637f977dba6d523ef1f6178ba245cda76e429a91b0ca994db04,
+            0x93bfbfaa8f3a8718603066321ce48219b55558f33e0f8645a93a41e6f4d3e2d,
+            0x24e21e25f0b3d0e754bfd0e91e62b5fcd232e756ab34cbed6b4ab709dfca551a,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x146990fff0e10b8d70a4411f57f9e74a03d2ac0127b216400b82c8c644038303,
+            0x1ddaefaba77bcd9c5ba0671b0a34a4cb37b7c689bdca187d90212f188ba4a87c,
+            0xa7c37e8eab27e5edcfc3d6682b0267e3d9250fe470980956f5e3e5993ddaaaf,
+            0x2d81f6984b67d7cc74b35aa9d673878f05d517085812190798dd24a510b8d6b5,
+            0x7c46458e45e15ce1338bbe98ed3c0726664d8ae0c965bf0fc79ae31ad04a349,
+            0x16dd83567c7289d8ea0e62df8620df74f3c987d5f162b6b0a24ab09837b5d2da,
+            0x21819b9d78ef5e05c535a83e7d709f80f3ab5e8d733146139015ec4e34b29f1b,
+            0x2340a29e4e4d4e920f39a6a32149b54307f918a2e179e6c7288cd02834c0e44c,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1ced784118aac9880c9fbbee28972453b36abc3d967b20e9b0a886af86d64305,
+            0x237848c6b0c87f794b30cad5a3cebfe2c6c9173f7a258f4ea139252338a3ea5a,
+            0x27c636aa956756d9ee04b355abe2fad8d703b1721fcf73b17a77751813c8abb4,
+            0x1b40358386698e21d43bd3950c00f81d6ae340eff9ac0821a213f8fabd142d09,
+            0x695487b95b15feda7188ab9bd8072f0edfcdaea2dfbe06596f8c037bf52145b,
+            0x1df336831b6745c8f22a80c252ba12b24e2bb1e7fd3615cc96145d898dbf3220,
+            0x264b7a66fcd41995c19f021b71fcb1abd59986c55377a82ad92e79a1165e58f5,
+            0x208defb2122d53224aacda9868250ca3b39f78b13c9d150a14d75a886a1a42bc,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1627fe11fe92ca5b0841cd804a211151ca6c0d2706b2a17ec17a7fd224a48a13,
+            0xd483b82a1ed0d6788ec73c257cacba9738eae7232e365df112b15a93459627e,
+            0x24c490612a1636b43f902459851afb3cfc37d71db5e9ffd247116d5cbd34f9fc,
+            0x2f2d08c8cab748b056307066141837d5cf195104459a91084768548346c8593f,
+            0x42d3a4f87d782326b0c097a03de01ac1698954c8f300af708fa79a92e84790f,
+            0x2b064fb3fabe9deb1593d253ecc7a12fcfae3193e8f7e16ec563876f92e4c62c,
+            0x22b8060d8bd295c3a201655ef3891a481e21748554dcb7613ce6c0a532628e5a,
+            0x1526148f85ce610667aa96af20059f0b02c8a9d4d463b27f0711db72a545503a,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x12d2a42d255875bd671d376e499cd79393db48c414f967d53388f60b4e180986,
+            0x22d0f27c6767b64adf2eb09ed595e2f2c211a3504a8de66ac01991c81c0e2669,
+            0x1fbcdf3ca6f2e0739b571248a9a994ea913375db065ed255b5eca3fde587dc91,
+            0x402b7640d18feac0c700cbea0d8f527a7c3fb44a110c4d7cff21deae9a70e40,
+            0x27f6c76f1b519e71c3888f1ece7cce4e0f99f231ddccc7798a31b0dee0c68206,
+            0x2fe908cd208699c9d8e3b0c09f5c0fd58716d0eb50017aa7d12df08b53d963ff,
+            0x1922a59ac83c1e2821afccf1610aa5fb0b3cf8eb3fe3f4957bac604c177fcffc,
+            0x126fc5609db3cb254a05919034b8a7f9a0f85ec5abbde6f85068607250ea0ac0,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x28db35e17bb31e5be954d69f5bf8f6838651bb6f5c80f750b6b7017643b6c28c,
+            0x26dd684288015065728c5e09454535a33e1537761d874102bd4ecd2baf40b384,
+            0x1895d33a312becc17090e45df74981b4fc4b220d3aaa346c7e8485311cab159d,
+            0x28bff25eb0f2a5c6d007a92a7c4d88bd9c12c5622d0ecc5a509c404048b7b5aa,
+            0x130136f07c7e09acd49556f3a6bf0739c9efc0a1be738453af67b31e845c976e,
+            0x259c455761e6b6420dadf3d6b64eb65493f989fb3e5698e7307a6d6075714ede,
+            0x1c9ac464fb08828d02006c7529eb1e8f45eef54405ed2cfaa133bd697f618929,
+            0x60abe65207efd0fda7b24719d35018f7607dd732e71c05077148f3d046dd180,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x2a41f347b5f6eebe8969667071926905a3e6e521b85a89006ec2f500ef42b000,
+            0x17840fa3a180177731bce340ffeb5a3b6a68b94e3f870501e787edc5a94db63b,
+            0x161ec94c3f624f928eadb0e2f2cf6b16430fba680a5a50590d89005a688d9b18,
+            0x22d8be171b4571fb5b773c3a548fbb286b06e2701ce99b7630866e1bca6e2cc5,
+            0x52464c9c7ad14525380aaea9b06e76f03db8edd220f90b03a9feef2fecfb978,
+            0xbdee83b20d91ff9a0404d8b0593879c90f7be5a95a22c8e1b157d92c3cf4746,
+            0x2d84235b4f4e04262d8f246123b8e631ad51a4e1051f41f1c89cc42b61717302,
+            0x3d6b62f816bc4b464e2971cc6a7c1a585e519266c4627b1367ce7963cf93d86,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x16caff6fcc165168b3ed958d3aac8d09f98f670bdbb847ec0e9083a022d27692,
+            0x2cd4beaac59c5306bf76ef7e06c81adff6de4bee730cd4676e966db45fc067d4,
+            0x1b11abd8ee736830ffeda3782fc7a82623ecc5afa92c0ec9eeec58177ce8608b,
+            0x2c80d3430e64bf850c9e10a22f6b781fd513af20d4705435bc870ec8cbe93cee,
+            0x2d2f20d2ec0e52eec9fc2d0e49fef7a2454aa77a5055ebfc4d4449e8f83bd015,
+            0x1e51c55a8d7a04be4edae4f7dfe6137e96370ee2a4ed459ec524b19de646e0b0,
+            0x13d4327afa809e26c8f97e36ebb5be1d3992ec72d459760bbd25659790738f43,
+            0x176222f47d8c0ff9e8a967920376793dbdb9dcc3a79b44fd25e1f43a755e6b81,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x5193cbcb59713c78012ede93db828e69336a197fdd30c6b7d03b1cfcdd6adfc,
+            0x2bbe660fd34f6ac3f2545cba9f717d2eae9f8c60242851657f8661504a457c69,
+            0x1fe59c3d2724f4158483406e6cd62aafa121c451f13e48ab3c857b2293333c3b,
+            0x249c893f9de208601de45c9769ebad071eb864524003add0bde31fef7f4f91a7,
+            0xc20c4a12bbd772e0dbb929b69b24751da26b0fa8639005ff786a25ac1a5fe96,
+            0x1a0750fb1d27bcb326ceb3a3065a487cf7d513d8954f31dfb174fc5ed95ce55b,
+            0x16d40c0ba7a7aa232eea997d45ec4f0567fb6814677b262aadfaefc91d409cad,
+            0x25ccf860fc7237cc8721aaf1c717190db40ccd65bf65d108b16f851cebca736,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1a25b1a6b81926e968ffffa63979c900c1e82452c986ae599ef991ba214e6f67,
+            0x2b344bbb50400ea76151bd0b68c3139955f101c701d32befddcfec1ca72df25e,
+            0x1044e69af594eca5f9ca7ee28cc38d161d01037fe223412e2f10838bb9ffd1e5,
+            0x1145f6f783af7d1e0ee3388f107ccc27609bb8314bce27b03dbf8d02843ab2c7,
+            0x20ed7009a6093b160020318b0bbfbc9a9d14de64a3aa25936ddff0ffe3a3bc4b,
+            0x24cc5ed4ff9d84fce95c1508e1c7852fe60a6def592f423bb79c229327be7627,
+            0x1fc31b0e67cdf9efa9c0c312afe54b5158ada1511719c76953587b772f1c830c,
+            0x1faf997032cbbadc0c6d30fc804d068faeccbdf7cc90155395b739e017081259,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1197c402e5f0a49c8f9b9a41af6fbcd013cf9adfe864613c1bdecb6201d9651e,
+            0x3025d698462f4cf23c7d4d8a3eec4aa8e1a2184a43020122db653afc6d0deb4,
+            0xecd1d402fafa3602052ab586f804ec15f1910542f35c608eb7a247d5a960cc9,
+            0x30021619d0c0b402b429d4e962cc3c2a2d00c62c131144f7b3d7f8acae6975b8,
+            0x2bcd05e889bf0fcd9dc4f5faf21c506cde15c316aaca47724e71bad0cf34b27d,
+            0x1b890b4097a781900b40d9c1ffa06a5e8cd05ae8fe52e040db0e7085ca46b460,
+            0x8081b53a974ee264310b279468093218cd5e5edec1b7da6b21ab35622242e48,
+            0xe6632e8ec976cefca5b164e6c07ab40ac611fc723e8d8a14899a4cf4be3b2a,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x63a3f8dea9d024a6f6a851ecdb21bffbfe259ac17f6793c91e73823a82f4f76,
+            0x23b2c6ec9af5d0188e75baab9990f663f8e929bcdac96cc09c4c0626274692a0,
+            0x9a41c06730fe53d395c602113f1607fbe01425190d50d56e9f215658ad128cc,
+            0x16571048fa92024a9345a0ffecc159e76602455a71bc7e9c9c01dc50d8aa1d6c,
+            0x2a5a7e76dc76ad78878b3d3b4c74995e2ce77bc126e4d17db507161b049eadf6,
+            0xa23738e129c11b285d81c1c01e3f87989c87600727e7593af45607f98fb18eb,
+            0x2ce8d6eeaf4d6c7ca0922c4738e81dfba227e98fc3ed24e7696ebe9c2732a1ff,
+            0x22e3bfb13d10368cee5175f5e2a2cc205d28021caf5fb2898de2389123178a5,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x66c43e71903c5b74ee8e90ec30a1d8cbff7d8c85d3c7b995a976036eef8c4b7,
+            0x2fe5dfcdc9335f0c0dd3d08f4e783a5ff6c2e6fb7e2928840821e6da8d91570a,
+            0x9accce03257f967a24c11ce718f21167d9d71a1cb60a4f50d0228418428300,
+            0x224e2a85316b67bf2dc64549c505721a7858438a00e793fe76b961bfbfb67291,
+            0x29f1447b45128f5c1cdb12a334509e0a991c0d2c9360a5cfc28af420c2ffffe0,
+            0x1301ae5665bd3e87cb647f566ebcf2f2eb5bec4b257a77061a15dcc7b8b34abf,
+            0xfc6599ea957e02f69b1ca585c7135425a6825867d0cdd2b06019f3c9398ba4f,
+            0x22e91a30a945b960bd87d7b0d8290dcd5f5b1caa339c41aef323be1ba9c724e,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1c7c359c26eab655aa469e0f9a8cc3d8c7a8149ba9e9baeca9233b7edddd1d24,
+            0x1ddf651a5d396b680828eaea1f252625db1988504765eb4aeae3274a19cef175,
+            0xab486e3e737f40898d3fdd6bab09213c0056c2e090a90acc754574739159385,
+            0xd0b817b8995913e3ddd08b576951bd47b45f536739fc9cc782e769fd17e0028,
+            0x13471abd3a25160947928376fcd79dd5aa58672f8382745e3a040c2acb464974,
+            0x7bff672e50ff1f20296b1838e5270229a7477110d9a7fb56580371ee4ba38c4,
+            0x23f91ef1b8182e80c8a0f54c3a35ad51cb9a3bb61b07b3e34386f16f7f4b32bd,
+            0x16c390b3fdf09c6c42e50b66557532cc5998cb5a8c15446d31813e7b70607ec5,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1976d21aee74f79c60d44e46029a5b04fc03ebfb9bdb09a0b5dbb89f677cd296,
+            0x56e7cdc08bff8d8bc12dc72af3c84858dde68919cd991bdf513656eb0a0cfb2,
+            0x22b7992d7c0ed349aab7531de2f12da4fdcf961215ba06f2b7577f5d42bfa85e,
+            0x10f97fcc757a0d6d0d4e2d585ea5968b3faba9d6458d16bd366d081ab65ae95a,
+            0x21bc046c3d727baf6e65b568653a398aeed8c95b73567feca3884a051ac001a2,
+            0xe757fd0b77219a771723e071c9896062eedbb3da05cda25d39ead3cdf738491,
+            0x1ed536c497ff36f612f326f3d03e97d30abf91605ba686af36ea04c19cce4f4a,
+            0x2491340ecfed3f98ed6fd566034240e64a08e5a39a468c78b31e4734a679bd67,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x144b73c6f361a4c232674a08616b36c33f7bd667dcaeec35530a2e8fcb66103f,
+            0xb244143540a248840ba5fa161cbfb2fb2dab97332073042cbf8a932144d27b,
+            0xb5bedd8122560caf5a9dbd69f82f7439543bbad397d7cfb4ef7782f64ea4e12,
+            0x1386c7e88c5c0bf880b28eb2735e221c2a88e7f871ca5d720c99b4287c528a67,
+            0x277164cdc5187613b0a6d6450b56cabfc828f20dd7d07611edccbfc3d381c9ba,
+            0x16bc97ee1ac4b1cea8f96e731dfa610212aec4a193015b94b0f2a1657d41f13,
+            0xb341e4361f31734af9951c20a6aace08a3dc80f57379add9693b56b047b3480,
+            0x263a060ba49fe4862df997994261e665c0406642c669c32dee4ae7a153fe1dbf,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xdf811b70cab32c0ad0aacb576fd95b23424d3686d79e36feeff21d1aa047eb8,
+            0xafae979e41c0cf7d662b4cf09e93dca70c0945c6759c4f8d2c935a6084eced,
+            0x21ae12f1dbb152c33213efe9cdb6044574b3df8236be92341131435152115e5f,
+            0x272fd8955a7524a09f77c28ce89d58caf7d883f9e4503ad6a37c0eab6bcbe468,
+            0x3712cabfab0f6f3d23ac7beb815226883f409d60d798242c6d5e9dae8178fa6,
+            0x15bc41d746b14885ba93dc7d00594ea2f174b3b3dbc1acd774335405c18b154f,
+            0x9dded6d75c33754be1c1ebd2dbed077c1f1cb80938f0798bb2e25b054a52962,
+            0x1d9fd7f273e141e48d7ae825a6d7758e351d80c4ed50139a659d52edff60d227,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xca2cbfed626671d6e0f2e3d1b6b2ebb5e9048c2f1273223c34fe599429e1f2,
+            0x1e9bb2efac004014858166710da5d764ab36b80e4e97500d784fe5cc2326fca1,
+            0x23f8af81b77d2f06d566eb0d9096c4b267f498f92bac69d622dbed85bc8a8ada,
+            0x11546811642965c71b3865d830809b7f402e02d1980c3219c4bbe48e8bd37811,
+            0x2b872c434320ac521ac1e14867c05d88692de6ee063f402c28cba02adeaf9c51,
+            0x1f80e8d09a04ffb20613cd83ea35fc1593f9a5d8db6c846d80dca53cd4ba5a94,
+            0x117c4e17071565b51a2b97908f375ca0194dd595e9e873e8c0a158b59684ac70,
+            0x14da94b9be3adb3c5f7cd04dd5c58f63e74245d5a1e6fce5de3d093d476f08a4,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x2ac96264771dd5b1762078d5132db23febb0d2edb19c7b24848d4b654e9ce670,
+            0x5a23e8be5fe8e01b11d0c7a1dc85c909602604b15d620c7a51e2b017dd63830,
+            0x172623676d3d38b2c68ba2b30c12c5818d874d83a98478cbec0b1d27f5dd7ece,
+            0xb632ee1e8730d509691580805b890371ca2d51bce083faed1615a845481de7b,
+            0x2a220ef566e4d54373e1a095231c10905a2f5e72edd2b6259b46ea45749203ce,
+            0x2ebf4340ee05460d8298d52260b4ebae389357bd857cb638c41b2708cc333dc8,
+            0x27e873b1750916366d2e7906ffe4f42e6dd7545bf534adc73a02b7410f7f8275,
+            0x1ee70cb51ad6da4513ce42ff200e46dfa39992a90447f1004765711f3f5ad52e,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1021282efc84669e4a98956e30ad0043c6c19dfeb98d6d14bf027bcfa555f8af,
+            0x1f1c2e424bdeadd277162d70faeb398d661225414a975a59be613e47274b73c3,
+            0x1a71e415abc5ccd5bf268130070e89b1e61981cd54f6e5864b8cc4e1d50bb21b,
+            0x29799820e28bb9c0a7bd0a2c6d6105e5c91f8f88b2823da7c57825067214dbb6,
+            0x17377cb0195b95b473606c81a6bd5c807b22870afa6cb230a1048e9515e31db,
+            0x2f73cf9f22e0431d5e7bbd907ebeb8553b4117ff1fc50d09fc7b75935ef41251,
+            0x19cd57e77a99328260bd31fb993e7bb3fd27fdc21b2187fe3a4bac0ad664719c,
+            0xd5ff1b6b5f33d6d568d9197d0df40d07abede20ae3a94a0292c01c304012713,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x26c7615e04be2355af0773fc0e025f86baab5f59d834ba005e099d95331d61b0,
+            0x170ea6732c6d1b2ce3279f2d4990926fb8d279e4864d966ce6ee6c319739c2f5,
+            0x2f870269a506f351fb0b9a9d677bad1bbc5e6ab40ff0afc1772f02ba395fdc8c,
+            0x11986790a1cc239c92bd4b8d8a1b9baa76e1e49f847f16ede5f6398aa83e97c2,
+            0x2510c2e5a39cd6c243ff590621941b221d2a2c5a79ed6e5bb90eb1008219239f,
+            0x1ba5c05a828609b93a7e151338699af0b8b0aa96d3d5cc9e7d3785333fa03dcd,
+            0x8648c03bd03b5f4dc3868ac1c47363d90010b9cb19933554fc7586b97b5fbda,
+            0x69d0c72c5880618f66ad58d65f09e5fc488697c71d92135be291f55d496cb7,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x91acb34aa0d03afd0ea47c1d56965a9051b05eebff9af71e07c4554184f462a,
+            0x2b3f75e8ca7118776d9676fe058565eb99b6e99bd23505a8fefc927e17cf5336,
+            0x16d9ae82c0073fe1dcf35384c0dce87494b2400f9027ce1e64ee440a439fcbaa,
+            0x2a11becd9333eb48f3027ad8f3c24fa1a0ea671a1020278ad84c863c322e8057,
+            0xd569be295d5e44ccffd9d3ba84aaf6a0c178e8639689aa6c57214f00a6a9d90,
+            0xa66025e45040fd45eb136eccc63e2d7fd237aae9b62e2330aaaa0bb44dbef48,
+            0x2cda68234c7e22d8fd725d952d3c529b6997b68dc02065f6a047b6cabdd29e42,
+            0x1f9ab3e8029afc72f56af02ced5a6b145ebc81444ed12e82c7ea547e9ad23650,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x18a2e32bb69277e0f5e82c2a60a008b3db5caf3c53a669215c0b3493b73c7138,
+            0x224c4f2e98b4fa10d4ddc83f26ada461e5b4f412f94a1eb153be707470746fbf,
+            0x1b2a8787e954d981add1b123a6f6c100a609e8135c0781ac9a1e7e326c4b0f4e,
+            0x2da288c34f32d86d5dfc0b2dc9891091d396d36de9f70589b7beee769a058622,
+            0x2e24d351b0d0e94f3e0f83eb60f2d476b8b64dcb47674290e87b27eda7f20180,
+            0x14af016f9da2f982e82aec1ff6ee809445db2c6d85382f959508a31830dce9d7,
+            0x91aeac9bde9ce64a54cbad523032180c2135b51ec4547ebcda08824bc9cdf9e,
+            0xcaa07eac62d9f07c17f63f749b7047eaa1adda97f5716d76f23affd6d845dd3,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x554f06e31b164d9d7ada3e01c4bbf452fdccac121ca787b08ad50dd2928ed42,
+            0xbf8f8d7702b1e8830bf126dc420158a624359067a0f6385068390b01d176601,
+            0x1604d181baf488dce4f99bf63c065ed934ee29f0649af4dcc9ac2a2887e8690c,
+            0xac951e2944f7532d4ddce72d31c8e91c0795cdfab82df338f172dd9bffdae43,
+            0x24d53d9f665348c12bdc3425c2b83e24fbea3b66b0c9d119146ed5d5a1d1e9f3,
+            0x1ee01a89a7ebc6b8e93f2ac2e60b9909e3e3d855852e0e113a72a118f56e2da3,
+            0x2b78c3171a3c8ec6231bb7c208e5b7c2c90a85956a7f2a1f763cb6c883059938,
+            0x7ca1e306d90787461696fc7e4a3938712312494329be76c8e2b402cc0d617e1,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1febc25f88aab92179ac3cefeea663f51562f6fc631bb236c04f5ef85b464784,
+            0x1b1b065eb60dbd39a34da94414fdfa4415933a6bdba5c2de470ad8ccef1b28fd,
+            0x60fcebd24cc08503ac4f80c0ffb87d0898f34bdce41420e84d941b5f7d352a,
+            0x2a7b16d282447357a66d83fc5aafab7d3edbcb3f01105f193954c5ed496ae165,
+            0xac39f59e76b9e296ef53921ae0436ab01217493f948bf6eca12b11ce46678b5,
+            0x90b38aaae1df1873784a8966f1f62b68bbd93d34b0f4c637e208f9aeaedfc26,
+            0x1ba601baf813cb2d40ed5674747b9e3d5760143501e0f21e31a7dd44b7135eb8,
+            0x17695ec6204f10059ae5ca72c1332bc882cb7b4e161accd1ba9ef760b7365d5d,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xab5930a06bb6b9a78e664dc5308da0b64d1e09e6c69fa583bc737245c5a469,
+            0x16ab9a5de48bf089fba600dc70d2790ce0e8f79c1430566802f97fee43bc4e2b,
+            0x75df7d5cdb7ccc175462dfad73927bf5a5f465e15ad267930c5ec846f42ae5e,
+            0x23e4a7be74d0f0930279585aeaa432b5c28a4a2b21e3990aa45b5092f08d48ed,
+            0x298795a8af97b8b3d378279e60b276b95227e66d74e2dc66cffa1c495af98c25,
+            0x133d1455b6ea278f4acd91c65906bf75f2c90e41cdbefc2721b1e96adc5eeda7,
+            0x24b722af1967cddac6a1745b71aca7bac72d436ed464e2b8ce55aa2ad5ff3502,
+            0x276cb6e59cf4a06ff6775a537a4b04c6b42780c9c98a51ff634804b23acfac2b,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1044b0ed6b39096c0ff4d292c18632c909d1519149139b1cd192de01485dce3e,
+            0x2dc918abffffceeb34cb17a8cb532f889d7dea98e9ad2686ef8e30936ecdb03a,
+            0x2a5030937ec5690d090ad8b3d897541ecd187d2ee126fac5be6a280fbd4aa465,
+            0x16961c105f85925010e0fdd445ee840dbd3370aab933ccfcb6e4b24a8826037,
+            0x17262da0f8e41b6c42707dfbabec1d9f79ecdfdd25a32c2a640d3c5a4a3e8770,
+            0x59935903a135cffc7c5e8cb06de7a0adbc6fe4f66b07a74172eb65951c6a345,
+            0x1ea2228bc5f09dadfabf025e3d19db3cca4e448e60f2973605d2559a27b3bff8,
+            0x1e35c4737f19de2debd3760ddc81e1f5857a01c42c86f4e264ba323f4165d5ed,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x5958875cfb17091058a7e29cbfe20d0d242ecdfbd3635279cd1e0c3a1144dd8,
+            0x19fd165b2741329dc18d2a5b03d7b58eb3dcdf2c2b0870731a924387139033dd,
+            0x11cea375386801203c61577504cdc68493716d023d116356def9ad9825be5887,
+            0x2e911408231ad83ab40e44e28ee0b017a82f7e080a0d4bc1b42c52e9205ed13a,
+            0x9d3f08c1d2cd4de393b703a7dd94df0540c91b59b288df6c1ad8ba0e51f179a,
+            0xd8bac92c12807a3fb4b20ec11e083a88b953070c08c1ae9be28c80cddb29a50,
+            0x22829b774491c0e3add8e7d2de8096cb55a1009ae9ce983b80c14972bc68b84e,
+            0x2aec91a87a1731f6b2f534955aef3d09ca7e2ee2dbdb5e9a0d15db232557c621,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x281ec503552e6778fbafd7270951cfef153fcfeca0517410e495c62b81655f9e,
+            0x98a3183f2ee18973943856c28e0dceb4392af147ca8b528ebee97577178bcf1,
+            0x794a78e51b51af07808b643ed37bad31e6d6c68e5ef3171dcd06de598c6c29e,
+            0x214a19348cd7cc8b1f985287e637e7987a3bedfa233f98dae9774daaea42fce9,
+            0x130acc584954a9048597bda6395bd25ba02fce56102928cea7d5a6f520683ca4,
+            0x1d09e1227434a4bcf72d8e91f5419ffd6da212a1d1ccb2a51b03e80aa258243,
+            0x127397f2b156ba00d83847f03dd242007faf326271d0e2cd4f6dc84c961b19a6,
+            0x971a3d373d35db8f181e0d7b26c33cff17e533e8f560d844694f853e7197e47,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x241c8bcc463ac96e3c1cc240ce83c44edcf9c781e258a2dad09d1976d9dc6dd6,
+            0x1a0b489baf0a182599f458897aa340e57986dcde7bfd34738851092a75ae6e0e,
+            0x102c886ce6381276fe52d15c51dbd571e94904a8ec4d4445d457d596442e443e,
+            0x289f8a46d6792691caac00cd43dde74940f122c0e5ac202588349c2eee473f6b,
+            0x2ed1721123242c33f23f809f6e431511594c10b0533afde3304ba62afc55f5ec,
+            0xc730a9beb7b64f090a39929af4901900e772b0f817098adace287cc20dd9e84,
+            0x480eb2f48521f46f5049f8d9d682d6f4060ff6c4190b2a22c40c27d0754b912,
+            0x221d30bbccbb39bc23ffe2c8571a8cd1763cd48de6dfe21d7d8f2805db1e5066,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x22eff0bad54cf4f8fda9e07bfdae36713527756cff255aa481b730bd286cc90,
+            0x220c6f4c23ec9272eafb522055494a1af4de6fe7456b39c5db851e1299b7a86e,
+            0x18d66b43fd01a9cc88dd14b1b5d6c0d23b29ac28775ff60d3ccf36039de0963a,
+            0x1f62901537c1c56f671fabbb4fc31fa743f3236c26f9f5c98ecbf332eda817df,
+            0x130beece629451200a3de22eab4c45bb592aad667f9fc6729842971d4a802fcc,
+            0x24411acb2c9c481c59adc41bc54fdb0fac658ed6e0b3636cdadfd12c386f8c98,
+            0x2370059923938a3552819155a8b3816fb90cbde45871f6c122c190a27e7fdc43,
+            0x217ccb823582bf7edbf4a6a64692e37928f2b02d79b43775abf304500dd2da46,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xe2be5d3f9ee73557a1c421fe42cb29bdf8f4a58679a61496bf8a5a4f9bba3be,
+            0x27639d7e461732f3baeb172103de2bc4a26708623919783fe54774153bdb59bf,
+            0x159c005b660c7fb3551cbf624aadcec047ce72625673c866c5fb289f8c865fff,
+            0x130d38734b549e833b50c550a90580c53248bb96731c0921ad6373316dfdaa8c,
+            0x13ee4afd14334602b6791a7b8f49c4f4979d485b8d1b1119cb4a2a7c31a74f39,
+            0x2d2647b74c63579e81a6270afc73e636e588996745ac0499dbeb6a7cf80a889e,
+            0x1b884086fa3c4173be0fd5cb1c866c87e0f9ae4c3d9f1e3df630cb4c2fa59af5,
+            0x2289328b5db5b2b2d00e76ff78815696e77eb19acdcb6c84279e65fcce29d15d,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0xbbd293300c70f612c8f5b7bcc6c4106246d2f713df02774a29742c31efeb4ae,
+            0x278e2893fbb5d590fe623652e50086d58ab18d3015a59d6a61602b409252ec2b,
+            0x2fcc41f73df0c835b0b514cbdd469af1e2b494f05269d15a6343af34668b18c9,
+            0x378097f57525674b961d42a2f57a937c1fecaba4c673bdce345050d981b8fe0,
+            0x15a6727e6f181a5da795ce173f1889e07f12892e13f889c4f8f6c71725ab9f62,
+            0x1edc3a58673d364ba5906c3b39ff7f654c5d42f4ff94e6e75d2c500842846477,
+            0x1aeddbe743c87ec10fe447a5d08ab5c73836eb214ef95a08ce91131b8e1a7f8,
+            0x286e544456f114ce609d6b805b31064ab65482585699c91b9b3e83a75ca386b3,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x1477e88daf9348ea5f95cb08426f4285c654a897a2c4895333052fe2cdba34cb,
+            0xc9918bbd089bc26c937ae2e0a92a1d8c87cf4480b055e43831a5e6a3acbe5b5,
+            0x283c24f7bedf789f31465682347ff86b4c0fbb7f9aacbe5630021b41532f7931,
+            0xb1e5f0ca68bafaf026438a4682a55c1df5d387c4c5f3e111ead3163eb5b2754,
+            0x2d9da1df21f14ce401ff84b99fba07311a9da3cd7efc200695ab55b1233b9043,
+            0xbb61e50ddc0821f0c03b3bed9476f580a02157b6a69a17f2afb0eff5f1e2a37,
+            0x21dc1358f62ff3dc24cfc896fdfbae88b0074323dfc7b36d680edba89c470e4b,
+            0xdc75868b6f7e6ec9c26221637eb789b9e4c2b892ce81b527c7da05627ec2dc8,
+            0x251e7fdf99591080080b0af133b9e4369f22e57ace3cd7f64fc6fdbcf38d7da1,
+            0x8606e28acd8b2ee4c23a757886d7e99e407d177a58fb31b410ead7fbe1ef272,
+            0x2f70d379513ce458231a8ee6b3029bcbbb4860ef48c104ddcffe65603d81592d,
+            0x15315ba38b9e4c7a64a0844985e7b45db39eaec4c63b490cecfb19f02e102669,
+            0x2a1529e4b1ca0cee97cde58af1536c4823f7e558bdc13f774e4ef3ec8454675b,
+            0x2a70b9f1d4bbccdbc03e17c1d1dcdb02052903dc6609ea6969f661b2eb74c839,
+            0x2f69a7198e1fbcc7dea43265306a37ed55b91bff652ad69aa4fa8478970d401d,
+            0xc3f050a6bf5af151981e55e3e1a29a13c3ffa4550bd2514f1afd6c5f721f830,
+            0x2a20e3a4a0e57d92f97c9d6186c6c3ea7c5e55c20146259be2f78c2ccc2e3595
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_6_config() -> PoseidonConfig<408, 36> {
+pub fn x5_6_config() -> PoseidonConfig<6, 108, 660> {
     config(
         6,
         8,
         60,
         alpha(),
-        [9174141306060971809979631725764298697615039980311809306145004207410652431953,4847693924685156250211477469465516228032151306221739650606132660616428517315,19669833054057639609249840291533340493211768292967819468538893000195036768991,19800508893433268850924828171290876015556093796000695603651522426066333836892,8244699449852279148780456022144420353408196866113049322676048275081354214716,1563672068712965454176533719400672258364596155638916268717470967009721945171,12723223712027468580318230235559705540011996847167975439677647504573149248849,19944398841194165937952509356635863229327574447452745793253427406349161295763,21218058308392585368594275702746106483411305671883946244077923955757637296177,18442884961885927579732373746933397748806426938144021013884176466434407012116,11138408360119814115926439449668526422561003790198269766757675305576549475808,12724564576884231109847024566806896391934587839830522481308995309797961575379,4897733190252075532660075013731462724561461746919488679609618967302541674417,4797748331306263412471031924618974997396620231469532262170060449304337691527,8626839560132907403537141283531395025838110825355541158539075100658769738351,6096293906324574249636975851522292408228519044739444932687579741964974917617,2351617695830568421216396081605990689071283678701192113347036659596049514149,3045682390398203085155257535118136303069379656645406266260961816947178911890,6935829264874515341379952008241845470659188886156484974987865751370715745075,19847439266968955911971997829840067368072860877451092633069920565944933744280,12795097343831149148337906863235678514689648096503928066579129201713661539889,10424580232112390318877053133877999442988769389050776486274146627765228950235,11651452649618223740363812212607761589812354035139843126315028745587570714609,21307929358023177131550002602820591970791247513576735567457471459920519084552,2579908580162153663820021562014873149811195641589016321720930006635393981680,8198198178555784054784079137247244121807775986273563786249987394640289859893,17176088986876377315956611075288620878117708836881362200541916957398026761276,671389874397910339333118510595007038137908096657753354622355890021074216004,19161949137729278558310070194809106779119877882343914445178348849980058405327,10827554013954037091657804154642286174226562252063767377995268439458401752538,11693672899474469123468133710607776304784343543318650064064636202512816205843,7026547767612627656560992117440221331093280829523426249915938274837157551621,14422968137896343032446633683271253661000603582016449215470992885331170459671,7685352543184863430081115767111935982586458632527708735083385591291346555502,14089009391529192464370954954330128327830078875414722902347666490457756695535,8424161061743752192085022963953944100289245618074575727145394775891645849043,9809236779073852557054640507912802523501426410996355424610807253990040160483,14100245203768962710288059230665566265892855964739454261791429988929622355986,7775683622333704945225255741567928967674629526812606133980425422182282014012,8739247215686497264451630351996892836638898510934389758205488381695687859658,9431876969679115468275053745264413939426444105271849398322497961102606290132,257914055321743732506701382989022126153391940932933566664491918941925247878,21801414068435960590201256257290267142214176965736081788536576642934903066059,9465495933537134443327560834432669768951376466867005153580146079082722525723,7862366214258716333873810314803222267215825847232397599183717032713290878315,10701164906390193792620967030790214270231326273599373762943959252633779929633,11951628827727068395937910010248864431667047516686609553745879936868276916066,14268744039571470490378560085356767818183790841094115879980723591887874138419,14468215915818797151199796266933432577607248341385185700017147731054148927023,1523824033338639123415809477892820349580561577160869448927791050266158538520,13559991428776910947424645696251487328999214391124402586267086012691140984198,18151203063828433535061866995346135260543721730169485344610433976436663085882,13436242600153492361692256644258899977135098134175123174795293078081801647137,9384556671429507406657070680351030238568956203341356106463890924933167416522,20321079285577981781556986944841048777999006905303986053275199507771332527205,13510502130738135726695195328780836716597947131948116750163533622597187969844,20903049289119144354363108865308751668897757360882852151457514926552553533040,5611953645512225417723205546533389174830971368309601830751921473015551069534,8816886019615642422040038431962872654062471314244185285424018745071289038220,16751828354835345790163611999302863949792305206769993810746019449909446216365,10421654749141018171116296259626916395875529220250947127973888230084671091757,6065225315766552671037285757918350882361743810888619479819895087632281975681,5737755346739850738724717271213687543479332312420206954339242459110768587128,14770522272891919220644639305274656491731294860310497013287297810648680944682,2777394791070450473479179489594969793054480209411136328689318984981401732197,10039559932930709555975364107098145624058027439566384376771787183526929807647,20757756003754261934858081777796652436155530474748550156383127600004580439167,13253166894715452480712170898662712132411702335275401581167208877688374856806,2037004052447343668129085129987646907388123739343356363273464870501805506884,21829471491172175426560705585746893969222010633542962882847909490991398830669,5130395545419191392223692116621486075405299333195732914002649716762739787586,20333821730990393095934147177227294218344864602777744425090741435432040213391,13629653802252084129446975515814037702423511189484562534040643669977716900228,18489091892360842692678715136565494502607711254719045543684163289077857041829,21380328601365035012832876315565064374684993115210423862017233170195286906080,2280052193465635727584791148501382679094142036232980037838088033232747821762,21415541711468815972744677841317235994302058341802530962394281077076174148777,17146992672828650459975820445250769505470616910596779130798889014378635881076,21676475584514120109058208398560066698690773910598518925936412952356431597439,18337052978997482578725645166749278142628133291693686105612531426715865276143,14864089429815580405957698645045711801464462794754089671996837547347950054532,10834607317840698149140890207826430113987295440254355899459691878793978994131,1157143498448645320415276909137008396665083714591338741616893578930275511205,5027542104048754930085470328670427788489455916338375169351586496298129661248,1922685817237874482932428650501872692326329693528175054457715565489676406535,3071473720617798005831658342971536643616129392641449174655528578463370685788,21091078808046042460442535848913779439792606439995062001271357804782672390627,19773167374024045118471391738750949555178717045037157435777574972149053404157,6418695831178793575992210834992785624340084513619644969535805236049937971859,6317875495482489567338519005308431806047606843913867465201005132273298011425,18001249545956637376455848019549801116909661454019565655561439372098476761813,15530167556609139699164228289904946047951254183080358784988008899829027775935,8702757129830652230304011519426558036441096750485189115358314568895250616455,6369986882953061252605652398893489899416599935424066958291402945530517772170,6842894437627604179732847187262933342846269043996061072487488027804029200046,20951621154051947571647917571547811655800779287153833018533872651413529893817,1219277535080749134805291725937516331501172121638812333911793209536894469364,11704605822590166851511022757496386950530399074796545751042566537118336773236,5983427701962592508775640503988144495847156070437130549832329402380170245893,20169091361583397776908351163571343158517532527313940288212943504015977979442,3347733015762117176159731683196584632702931062411889821726902331981723958255,16217509027282489850987935065936382820558307489954122630844029918951230268972,10781269196927764524006466217779648732772805761839205677745819812868343369087,10568911823766972365218731330080733630028238366288098114239172953421915095075,5568774544682750792074131352530555554984876659733959079036284517928264996437,17854353469028651373397049175548228061144941710027186166132671198740388767529,6573034112757039329551886086829829282007989555105157401271097204633906940776,14069627287078359391137554212536883450595451640858724555679971658981340584258,21119713641590541511025673864154852875977162278614553796484277752677323191505,12802116677235410441672624559825044917295689876859311183079161588690810005363,16037054471696658545113065872215787085337497333273419984439267709950724531124,11698654309680908244303850432833183602706804558317993513795996394673734185716,15147889780127043019188099948246961619198549928908180192590946633702778981583,3657342516407201801006680507925024451922115018712017224805778401726428603983,19776786467141868744713630352693556348834540992018636838044610844396164981103,7980994848490005281733955776875257044050741738176865989521982608944874160873,12415191330803073018395217955802011585094769098717180100014182475381600382452,9300986814650530426668152137665814177758578011365736727321578452726378799933,4412208980274764197258090802604347599791567698589180187154608728755887977460,2582317668924231956058541757507620542434237159213236485179804217989764223164,19860814395849792324574773787600734118308975251437485131415273418632757301303,2765909129639570206766170018363951893338720647679193401532780051354569922989,5402210382809272147099442645489124829067576777592680891367494969197685281513,21011104174655621871977821285307554463403659856745964274018020456838460357574,7018364707286303918877589672878574811337524823085078243421192184715151775983,136380103284908296988715215087018020601815024625535396780012012453684253071,15953315437474610448052466140270091879233956524793052736202793153707558909889,5912305909658884889781037379491781973092020933879206417274479331390062715252,21575635295587180789566592951559325743281772394055590203112195979769645712827,1541325805478255472079288730846072146731241030100908414806224735345400173350,17207219201921814683730773200330679841907450967511507012179337438654141678023,18266907794578843029196926509122804272900478710738403531664855427655744759655,1204224895193276222782842236712348692319665277014183965830735736728887994581,4023246588034712778784328407820569751989619386134504404739514704773521558127,9064437981037864995763386367268294611921404895425171966596873454090899491243,18733802217274421976148972926716884457128521840010001893311936746027998476583,684088380644531080099595788833220377905013807951051638705160997709156627273,11994830816367980341637110785269531718699655485484715851375754143223090344544,1831724566362300629700078416489434571462666430381219293205871349415506993475,476710745682537342427691635955087951551678644045621275039835625280220347951,3586272766499559446129476613035465343616602918105042144185864609818186807939,21220348736799044560439132291243370111879983677197111626309132298278891334631,13683795063599185801186093771702503913590598475095473714851383723199050309401,16118007386401646906425171859166434660243697555307927508268622819509657450614,20930641024767526790605168032291665313905337763598128831404465184891980632233,8098646212401100552303711812039666794078834386731698810205195111722330322418,11585783577173465460243373201831086724911159484415020913089605532852648999143,6939053275662244505087635417541857793206828446247848992283188764105131966721,12798043540382494855660472922674138947867597503468216532170157050160462426199,20713389801600667412553956346192236970217099413304167366340548074880917096741,8708207547232102069057776099666995672015399188924281674772351753887161579745,16016293152251662056020528248861487281148011452459422778601663166015837379163,14324897997637439510797191208789711173129460994362368408063402682894248793270,5652996184880208428967511742390474289004021508049280419259474250332590598159,9877106633097964013050071703002221796318046172981334418310092241450453368579,5385816971548914185604875069230499528103133871233951354186676373318036241822,8683091293306949708478955451280670950858818602696102489349595054818146782362,16854975838650963077652189417311897888852709425835763860743171659164792100482,2485160816649177905834265823672532710299580013309324666453183278408904845122,13571692148185502188613896013359942531817915076247598483272449919094247957149,11899399615412173136098732970606292047945698835588882297719609812145308198009,16827672312681684936590464376780346837611857292837989006980972390576065571472,15588237822592586948064701827497915157359094833395277985658706133691498343174,18356642512438827417103800170157877145465512961188328254773957819312191285168,21642368145757804795143182901389223409544979732781450480847315495418822041608,13104082060493963869934085622104709047787444250961437496674916673804812287386,1561532086277971111804773016487251313460788916643968126116038406859074212104,2718320602791009266532615731130512762296058687816604986701989820504700684864,6182683520717583142027400659687593712743548729948584058329789905227082638908,5757242145794370726637363237313640925174531077560764545993554185332488520899,13688467192244237790806289073845563960119021610896694359815485764764608925981,12528461541936459922472167643986446262977222390263675720335825628163511159437,4897268894447399415795897967133432014527122426051771866816059363418177665482,764332419588242767884018802335623760055144509861323437945071732931233600264,11755468878196093893190753985692714003062307843033761257593209352165323938879,6006022813561851182403581780143813226749481175437001910923100661321563995672,13901542382190510449243772206670622017835690746895066410475076631498053123535,17648853891656481911225897080296737974064729032668806126284849597245044343224,15106333841965710929952896897521673254279668876709612770907537801609875568099,20899315415025260484895459315726322363345188136910564549344894025053466430346,1409310408943258102775009950750654615881913956151269414096059752250092035807,3899088673345731523976816322438172722785832982334214339521575164464706226294,21406686765584824639201351330529610299177537976609066339927938099572420696135,9121591670793901722224770893633585291275002987585289305307167711146944200595,10711764678410479049841945177317023555168593838022414378232020467195337241279,6599257303974597452501135281719536074294806740553273627128065549267140155175,2142616913275380526921597026822750992917222975992774063376747381991404337593,16361086527663411948363284957489078505159658832010445114438602510508720771278,17122647864721668762640781848678028227021534122268561738445496382823789619088,21708018685042482318786273055293241752114005312590172460099480713746031274624,8303630654111760473056607545365338851734309857718959193970615705292826806179,3658686547507488906491014260011151850549759409901579684176172268581462329020,7720024124908065424512743488999250878143598904717873371853608249805302871508,8805244918657836956533473437651380347005779399042661429698187314657501156241,6303681354794120075893215838935586592706844702088252970663343726024171795351,21512507181643408509426104627003618425209526633080701556628608990726677651135,11835373417333287523801757951049679177935522717858158305516568595764125190183,13059698839045014411602727811400239840163533672024084777768305507840091151855,17635240655824524168378284083397931667938326555447077097306236826752492079430,3374412791113107178205006579112630099131939030015047870738873452427211677886,649711083340882271985565833699379436167716866997851102439037906608755280128,20002805138014565226408902156524463368767807620908543995020210484077706418135,11071355197960433041624284534649121637702414580710232237233568479006159191217,1105441595020980635809093220782460032826849883993030969714432603468135735502,9652765957610682812348919340146799318537766051849796416434577860126024594091,19248299650856496267902926731608572596705132576830681367365128976226233392929,15285802367070100569572399512275861017714681455564415244982064571963339715277,19970416835730683993734843405673457882587154729456022607061085470691843864556,1017865638757684714433500504002748241987153668285974836527484933462490771227,17284848056169793253916338792235498052654877955690514601079806604278964099314,11718277105372928962350331838305733149270432706448484259807630484543527733952,6670793378364949883511003949124179112275066568088468958915163969545409700112,17088789393958965094855662340742013087397643056458490270185660553870734946796,1930788514812600942005320214284180860980345276633471423966020111188605196111,8844343159753729614645407314580317697758296041737296276765583948670245312842,16657939543606018325703787748629433167511611178952563626096990460124133990109,15333343644239485619497914931918504163396626751908652058758135581206765801100,16533875915742793452819179569144271760125646811168930162441077117553849625884,19679534317472082858641184998487299940737032844519038845860980362664393659234,16385719932525604857740698205965045007053424961009717093945644387917936681719,14490521084213123170781774542655088188106794646066074998587858678154251198444,6386781978322405984893078797365492485297499058328348606653460996474947075858,17508047533433736707046937662428611868296556965172642086594091783148965906980,14904597000414815084666285064575232635645852687797347860862157463159487771060,14979972442969995336727018758631782107138089738395941038626891064816880204567,5299243186271864957800928637599294208954109271450189950375274196644046222516,16189884555052883188473617525411302750109401983487269295700675997730645714379,1645560170870292006287241616671417605853047420339675073261660626733726665673,17866745974872498136933906591373095763114066893081150553715211393380040095383,5744849574386643500716045532645657520001448510343827372577217716983339773799,14021966200238971589811034967347517039341058556783068950884921208853167419283,1201178089866013320759085637098781870734315826415474628546655403142858044361,5875644793836087035760988842421852197052681650818034527831700615895391179258,10875065950479466897559006840696567433921014267247530366235539292597441428702,2221662399199449388725697795500999209427453463134383582414172135385907744785,9758513532658579204941116584445291102215928928145103503086996542188799521709,20879593323317766577775570558015407573466986714590017262168011643343469361329,17225846522404915080676699509636264825833159640824918876741681229188434930856,15189442986691997434021855855358620506645387296294217783597931695143376252483,15973617135551858849206811241799666696907820418171736027820254766840973764431,11888113439449420418408437784450952639345990804839507528208325036625374967083,12365920814385241227394825974928370916184942218042429533600397623369545597697,11966175169612449906889690852332416255478894176917636726028104087408060623141,11163554022908212145274813635928762748847331295589087669583554722521180712379,15273476004030808005186443499782264987539818978741159793745891769358221570633,2013969196885866182480519514425192091338553670034650196068995589691938248955,5008975446746271526106846692137145404766553748264648461545948417006052208130,3926749194225734582453671614337621250954608160208554883789519551411469033731,1635544156808471185144068767649088695307748439189898784051754434524720057896,17144944482517962143604430553750908864860079758005337246916094084534304051981,13823503533305241872793740090687668844401004819859520464168798913603662683770,16335911272023134851779534303717879370955813837529588982953758998930285394340,14467284210444150699969889681308566002886261365990840091849371665183151060295,10578205764525658336257882813734672799527733392763965031628376897794294290414,18771425328697137255453620743509164311086906349726510394566012237817674245865,21804626093983212038528370352039806004465345685985435415809095637323683466452,12056805308954301132385034564357716323176447186932453788072119595595483786736,14307195735327805282612857510308008767450554777122724855715789120735513378827,6848201070063637295416045855906784325422580350462489495889308309540335269587,631364713487758647973016689203003205602593076699875191323345338325349259049,16214655556434201961140525501007839859074077768660052713461045928979956365067,20940788212183642266181811368870506130164462254923655617893660245551698033523,8257440848494309435270838240795567828478627302119374684511017376568090372435,13701089242130867705897643891164147923878521147124165292045879194108024940909,6895272953337895406509859406973110417619874994579965619097329249292199573333,530437169778092455975584310016745919549274205817234464915791595041990209639,9008612822403008353420189298381046023002474279157557733428254452507266389025,14863423501786052071018008300345884780479084379412157784789951872243409629758,20091026239041315645045502002997446404106877721183777765607724358538559881231,11103877261161399045807234470901399725912406134008627937945079980590775715243,21529163495181909351665093277427712610965764606448489357319207727176092439794,19540446772694448035410067193880900774391072899517686330271100773183944540294,17549510450820803306426739851959754252204444648959723652883552677325100583689,12252518814610348662318155253547558779974557529822012236107550517806390105567,8058115132085119666951861652409945532276905989404523986413207631657437321956,15916100116790431839835734530362130437167135501074855072245598938219364570910,14256533476494466694764843270015662315303617568641801280831873052211753536970,17865471381417606502707639037418669122823481329049436020149405646709537112534,14015711483636570179335132940981982618090553643653746531174110949872682031017,6075776171664976866533080327142904134938121198707020111533599997509054627652,6357981809351565370498807027309828058036389418343890944791766504532174516243,15145296985037303761634018005118672316118004891352906450983918852209191841446,2473672396516437070485250176897956191104549656554290725379242542480862701754,11059085933391482002269653121188853142706883316754376424538662772943167665341,14804069155713123448375113552227724310276294677318593116834685772120057819258,10146378656966122923223443263705119557842694560695035707977826044606938090895,21828309590915152213768434346306434851424116996828875020020066586363340244814,15568879616082229996551157805731419126872501425454775741945679993142071548779,17504079509060638501918729619244098692140123800571022969294759717277257664716,2998311560047298465700351970612785742605093777116697796464434026101441410385,20229972737818088327107446854254558628041027965197447598027135778783710740259,14884874200763033520375899992902136897590350894844904733314191389520252900641,9619409751736964504139815024141276029474791187139050183491749032619248817404,11534029087676783672833531415041588991838838078174102967049055562568798961925,17106297093375816944137015955705541133308466659538554159312635106186252148471,21676736161168806529097919794022110433487869702564846859065695507460463414524,12596447704589377083704857810305080195761099125652005594925931498073219198049,310943124066162607352831846280730445558498286205117614171844835745706684432,16013029710570597613246104892930389004941711962070683476555063566372534206859,14282564976066063966062366540992448474634085812789771416509095817495183298269,20757241092771652500911491636894210910134068426068355089789205706892703219255,17084251309147907751212619949757520468224028014308500329099194408342072624132,14680350698112448759886861002622963534698534998651150537754386791270019720748,17739512731440543100681958009173086667000199263945053345384367808940651002571,8967486063900234709994801661246451094429250620940593387993430620369318619734,3906067814916986286272005884942051451306945488494283077675304366798199289520,2517004675157816404807349457307096161030587393097616279110332574293494030636,9995302877359286298434340810356550712107485295049220989690824504445305103587,12849909876017357260683411536833847986127911582040960825577300322066595609115,18074515800779889507358182860997188274134395074469953155084226981497567860114,6692811728183968363967959295970424292426462800383828091752006855360167264617,17859827663908740084792157440799065184931609649811664442236242315795442091367,12243409340804252499520308602187370739653046835019551522661290645230850934962,3009118420068966587115224335717185828292538080040896739662684632413054772046,15856202298588272962175258696610233941787471472716811521132004805327415486141,7549804594729480554341356998842376772514802673462970334329441043324983960866,6390806437030742378988258255983502109201709511321162596105974797942236431761,17370236522182003753669946647208335160124999930136364231371998757664000198520,2261672244214630177095236704932243497157963117166120717011661647779055001646,17325026196605130064689259977831126468940872193987407658419640959345091161632,3631641025220845885502691330008982895233731506600778684638817282531001457735,8656561399441987116927438675277763317789561532507396244334062468892541066084,4069166732330197412844703565599514109399373916243310212229125901351402003915,19808198732373520522982274785888742523226720967259539531129335924093928174880,8555796834031869022510134190573521699378201702450788201649007358450530423866,17759660636058865290579521740750449606781204755231964378855563896473545202303,1335826395218609619260020055566056869243760115287254209950063597653055872566,21596200365241795669701682696176077888309278223833581800772036945674858315765,12619752319673193899296833725747186284394167228468888029626464753793997178599,17420588547980145067421969830249755561311178399975476925894947008643385243007,10337481272389772505654575850886249605422739785111225132545740838911222864209,17928431631046752749930349099366498612885288622404560316665023363985966878427,3075798659324203306711977985120251896073145961913793478792728028765206521425,4639500613932181914847461422373341918892878975546430906324216810326467690534,15396322795715441250300995201889120935591602515487993982711884319616897970533,6391276937505284102735701938724106665734769352007891548547667448647832351929,6811373320779057384916660178551330838095673247430496448933336925226142036083,6590973140323934807800215988687710942074412987201753370126190631819398102173,19364648614154949386936259588484266535262135334799266379433252509193375956715,4702754284612371917466042550086249683933140314858807272591351280832918881874,1081036249074169248236179367049085684430282426446509768147097371368406374049,18548093223441988703029589168425055383154624592689171393242936199350770119589,11098999608073377668352846814752381891400020647878345005629685447730764310163,16001262992680194260590639872321865154716987495605624862471107193457192704714,21696229443869118415905915570780926763029898831113534481730746953640692230062,11716215712634983607563947056324900205144202447594949676250978337464771243867,1778908113733035314726603632369389424542091991692308812147944884836647395775,4019081204388123040098634987844274011285321286777408246805308194144238418480,3473266952388383063447927231564219811787341139731701190625605897592140631276,10457881304788072618845101933412333126160339089704353596608910674508961127232,14926101732700077295531234099443522459232814784151318061435025890154852791802,4036967072197259618286839959572768559469665646019907384624959071646231971399,12776716624632228928613396031717959431597335742467953143594165782617234803915,18894783424164609284436913400522166453255844750192864579927645453695213022195,6303809107919167113924303987533838414137996606980561570652539716097058487126,4729698693443803882717817492985796053343431875965792864932005291979914613160,1645790034267553926884568714540144778649055395816210525904813567839945991808,8138260225269705405100573121045873922755899939885385491610389913906979427176,680936760009829486282006800072001712155424246576949107399338687767760991887,17240357869291182045663678468827695873425113788704614245279840174870850373113,19100963939745621863641468371111320143895293700517367016077996431570157414340,16188989656090417148189510820963186890780289777598053654241741803194118100843,18027402882394597868782011288920739982398714370069420860949975937357531046151,17780529984916796963712255733293310230026423072958099290880849386941451922559,20004531511171838591303710792081846238092292916166965045929062171308088520097,13855731634251510230399834192704620793850325654395687428672253016405315169901,16872938837392115669581040432902657478544143723662502779821325505282093696739,2541555081244462826761076743762714962901590548271316707071685417008817634653,5136424039269088350807839181761422963254683236279333039713142751702136147963,19216238128964101420135465007632926445321991494181045543846024053552797518994,18868537488540023742258053821537824724371813776839672880900985865823137839953,18246710415801024039719497716350501105591286880983169809863166130543617917249,20608694004331631709610739723463009412162748201282986294016482926528443868949,11318113915971658853560322943565673154831611543653209084299774855226816037778,16240989418312335385576389959938922684406585560688799437547298624184839261343,16171299673760267132909753100946681733778389681324959987573199154235691694977,8036823955656422391918380552495301547890420665617977624790236120392727764522,20269862530534739231936251654244170650781428788816658397167110617927916774329,2368678892744667199202318323282128737449992006513656480477288092472671147090,4618078962163037429845764284139891171861860687111566735174912070413086829215,12695350627501306162901105159009497730633599768443844225981772758225613194238,16356283146491744069785034066388746989409816380917535719898337817088223419024,6407893217596287850421377738867081146106659458551198123106454022096864887316,18168868018352364136212098098453930600797374324006271488950341490483455519349,18352629174410142476418438008157117497168118524562206830585500251463010761689,4344169393287991961961456515301754172943022039566219343212376057129143739343,19424839806870716108478074501405697296961947409763509419111261767390677718987,5796037897847804302272999466834285170265203646465480652521088328457333766863,17402105801450379889120987010453669096275392789725153915905747267778100864362,15540989618743824352651126288511222263828123668208146479603617243655978402205,945810410725426921570254447269595873973858272778720657523509910503434094174,6962323734045776666289031609372270190654631739266635759799844631053633876675,11382945272742312954364642163371436855283161775445664525053938433459897196647,18940251871958826726849623572811640436342841713786099464305053400421580490631,13969540696178305383564753026163726563325318478290740131984853424331762285147,4841983966001277917879506889862519614692143906356361564304719688757862622407,8939049562492171082419559182596894186639203815268680721033389307282239000385,19265363396776097866041313346787101192508520582744521467413665478819721956884,337106861429123598189388456471513480497137213511877011021531147545809512194,251367482782327915297484770356856386307188967585026711663629212746150191478,19506616511267234489421548744907283107923549136620297132842391511025844759064,20633589633280372440758096707466273580151526293980868749421563697429194761212,18833062060138888612708634036427140134887774731041742144004707524569102994071,2927291160590267909596732410727396533948837350308818016906834558527125752899,7095572562193114209617459307511041110255341231707924363346373597653253806883,14274988113217913224290208839851596837329960221329537670822013510325939323091,9965830780560026128320556230399915681196410289456547935188741323403719404039,10333365845496980935202034863900757172839454015352626511769637076650624839070],
-        [8266021233794274332054729525918686051968756165685671155584565440479247355160,7947823415909040438587565055355894256799314737783432792935458921778371169026,16508811191852041977017821887204137955816331040385276110261643892701458724933,1804800467126006102677564831888710635194614232739335985819349312754063580223,11189892034806587650995829160516587240879881493093022855087765921356611070470,20567450145123179140729389574352706949280207113956641415022972885523439610844,4666756311257455192796774305229624459258864488677689058174087310651786875914,11389253665835451896363091846189307652796786468610595637047377864063404843117,18793736599347263150867965517898541872137378991464725717839931503944801692688,4206344588923325482680116848820594823631536459347642329098796888497153867720,1739462481670645248707834504605096139894257554120906850613041004917967456145,18514227342636266640333254638454588508118462110178719555586534011641424431745,17887039315911403193186866703775654467672391491657957999455462537283842145802,2824959020572825365047639014537190268717891749361604043531643698340708119767,12521547103713919592301476538318318223836047611311454785951907894055964264287,8658146183671258251984364885894342376430874614261222570603159082682815800788,154390145585284450772861151318029820117470958184878116158462181541183085587,7593705166056392393963956710828665339496927193740869686529339432486182720653,5529559239163081088908568555890212324771345012509269613465629182165427812002,3729910453162885538930719732708124491456460687048972152311428493400220125686,11942815243552870715777415109008273807076911177089425348095503288499102855779,498938524453430895689241565973888863905147713935369405079343247530256066618,3976257517234324421403708035200810671331954932478384823208414346189926720724,723540703523219510043977323240437576248315561543814629392162302024056718473,13306548824219676333032339487546407241767961556934015003605485324283250885682,7970147269291664639740298762956131361316495463191268382513594527221399186752,20633313939958767604804835838065337107615699351647541991788258289962727735454,17162090859520817529294904484646695645841022315617926715432606252643123848792,9181379842957190051440498041153333325098774266789773971685141362947015398641,7051606617662816798224904133351061549832959857069896192072217769241273559278,16619522548478824222688310091434959542211899852679631815023615875678448806029,14965311177811968100298579672135357167599499478246106482433786066289128683961,9792733250919070275775594069208673385381167169182805600474820364274865306108,2069253833779081039049908513863485270550301879399727430830923273191877809560,15847298987712771667136245955631872888473964330474501593909263901393348546986,12244443532166430060291409356011430759892629145539185535677568234713942157668]
+        [0x1448614598e00f98e7ae7dea45fbd83bd968653ef8390cde2e86b706ad40c651,
+        0xab7b291388e5c9e43c0dc1f591fb83ecdb65022e1b70af43b8a7b40c1dff7c3,
+        0x2b7cbb217896f52c9a8c088e654af21e84cde754a3cef5b15c4d5466612d6adf,
+        0x2bc6b0ddbe1d701b6570428bdc1ca1bf0da59ff3bbbb95fc2bc71c0c6e67a65c,
+        0x123a55a31980384f3d20b2cecbc44ed60c38c11f7d20e9271efab9a905eefd3c,
+        0x37501cc8c9dc819309a769f4df098e588b01858bc8eb7e279e2883be9fb8c53,
+        0x15de231637a8ea3473c2499e1bee320c17c6a0a4f48a9b28ad1444d5351ddb36,
+        0x1c9b1da36989206de9173b0ddfb539bdf07f89df055efc1cc489002da3f4b534,
+        0x1f28ec9fdcb3854cb327e3e2fe3958550c37fd179198a41cf20a1a4c810654cb,
+        0x2a0418e12dd26e796c091bc1fb1e50f8290263b3c80f68036e6593c2db2f83c6,
+        0xdf6bc990dd688fabc1f8a5f8fa02a6a86f7a3a9ee452f5684d123eac1507890,
+        0x24cd99ab301ee74e2382e238be9941d9876f320e9940481647fcbfbca7eb6a8c,
+        0x1036eec6b3ab659a50c22ae3b357252e64641ce082e5c084bf61a4e61198ac85,
+        0x21ece1030bf5ad5759f35ba96af936d82a64abe4f9bb2f50c28a488209286118,
+        0x2e5d9059e62303d8d17fb509a60afdc4d8ee1d9137f8fff0d0c6e9135aaf66cb,
+        0x2591d88c11580b75c4edf44dba6ba31c696f6789e22d3fa63bbaee71c6986857,
+        0x1e647345c108005a7e2f870f01142223bb22ab44a03c7198852aaf6d765c3bdd,
+        0x107e279d710e65358ef44f966e594d2ba04e3e15e37ca5aa5117adc71b441f09,
+        0x173b298298adf659b3f695a02f51617ecca7e221f678375405f20405e377a44c,
+        0x1228a0cd105946870acc7586969e7e3b3e8d4f5f46d450b14698202adb9ea1ce,
+        0x778cb45d98c0ec68849bf203dc7b151840928cc9d7f40670bf7d48b3c661d68,
+        0x72a7ff12706fa3b3400308feb33ef3ddeaeb9a5678bd4a17dff096fa99e9e64,
+        0x2b0997b01165c2874503dc12fe77d6ab58a44c583b939c35d0805bb555cd09f3,
+        0x80805129259af50e2e5f2d8efbde358132da1c19fcb7daf48985491c9d287b5,
+        0x143e4e1f2af4def1b19038a0d6ac9606e33f40704799f0890b4aba0b2d6cb923,
+        0x1c16b447df0a3026d5b9123abaf02d69076c59153052660df237b5221485da3d,
+        0x2212763564a17c5b816703e5e52a7db0c5bfb668fe2e424cb251361426830b92,
+        0x16dd30a48d96f76e9378f65bc341781e97cfb94af5a57091bf341342c0d7a6e,
+        0xefae4a569514657f67e19ca11c01e2426ef0faa2bed48efe0711d338ea3b86b,
+        0x281dcd532dc450be559536e252e0159ee21d5b91fbf9725f4a57dd870d80e779,
+        0xfe4d11a8b3f24dc559b4a37118f15ab83dad5a74dfaed41637e994a81333f95,
+        0x1857938e02790819328278a913222344640f200c51410456089768bfcea561a5,
+        0x2007d043ddfc54fd999f6f4b63d4ca66c5f126951388cddb1dcde32944155675,
+        0x23de66b927d576792c69a2c6e7df20d3fc745614f5202780bc2b4c2fb27e9e39,
+        0x2bdfcbefe353fa2ffe79d2efd5a51c981345a2de40ef5c764bf90da86fedcfe3,
+        0x26cffc0e5984933313e4f06dead07943880da66929d3aded77e0fa7f994244fe,
+        0x21c532ad0d50674be3947ff2d4eb744eadbaa2812fc0fc25a41cb84c0fd3efb8,
+        0x246ecf2ee4531862cc5a2d7842fe3c780b868ef445f70c9a1e2bff46149cc46d,
+        0x397b3980a3cefa0fdc7339c4f9500b3643c54a3ee7a39600304741a2e772e90,
+        0x144490957677636a9a7bf12b1ac99af955ea70999b2f972211552ac7562c6aef,
+        0x4a96669777938cd9643ff257d5f56c5f4f1eb5adea49a678cec3ea17067f1d,
+        0x2423a50871429a8c48ba13e4df938e6280d715b39af43449ff06030e346e3e2b,
+        0x1ca50640e8f42c03c288014e8ef12b8014c3c40a62fc5856ee9b633146ec602a,
+        0xa8335c2fa762d09bda1eb7e22b11cc117df788c0d023d6d8947727681a7a9eb,
+        0x1c57af7a6796ed37bd964c33cd1bc9c89747ba21df6100209fc3df9f707f1cda,
+        0x8f0ad5a6c01f0bde7d1a8e7d26848179f5ee31d6d59bb8e2c701e37a4cfbb22,
+        0x50c7821c6e53eba185a6278fe04a5c1f2f28641bdc843c9fab2ac897e8a2466,
+        0xbc5d445c5df52fb9b4b9d6954bc75763d53b0c2089832ebdca9605679f68d0e,
+        0x10a6b2a07c472c2a32e9dc1f0501fbda5c9f05b861d1c78a5cff3594197b73d6,
+        0x1a24448b3442479c7ac8191bfafc67d9c75e40200b318f7c72d0c2d908b3ddb3,
+        0x5e230c7b91dc067802c6c9fead50897c03379389e2a7def370ef4c28e5671be,
+        0x1eead685d9f3577f7e364da47f74d8ee2cf6cee31660055615d8f294a30294ac,
+        0x4a22eaa10791b59b1bd8ad9626df74275535ebea301f8f912c521ef29c504b1,
+        0x6377b60615b7b9a9f0eb2276786d028cca82fbce7db1cc27f50b8486c8806da,
+        0xc76495da478bbdfd623fcac2f3b08d641c4c654738fad67b9e90ea0715714f,
+        0x250ad6b94e1bd06817cfd2421423a95e18ba872b276c199e16a8fc650c5a9d61,
+        0x1b2e0e66146fb5b1221c878286a0983e903e6a95390f57d298a50dce6f52ab47,
+        0x18ca890aaeaef97c7c17cab2c3518fccf1180b8fbd134fbcbce38f786f2c0e03,
+        0x1b5c3db94d9e0cd45571c1b88084186eb58930bceceb2c8f775b12f37961bea0,
+        0x6294c72686a69b6069349a73a81542cb16a6ad71337b7c7ff5a5dfe06a260ae,
+        0x2c18a25a8c2cae179b1a643e11159e8f5c9da448aaee3a44de48be3eca7bb253,
+        0xfc45a2b9bd6f41901baa7afad40cc28d4479c304d101067c3567fe449332eb0,
+        0x378bc3b5a32cf5ca088227c5b6f0a566e0b75733c704804619e6a979bc1d36f,
+        0x255375346beabd092bfbfd7278b437bdd3c18bd951d7f4220cdc5013611fd9f,
+        0x524853a2a9717af64500fec836c13807e5978be32886047bd3683a5a65b6859,
+        0x1b3998553154fc26ce88f0488160c244e1dec648b930c132d077cb93997af5ea,
+        0x12074b4d83e92f8e0ab92429aeb5270140338a97ee8e5c74f2b599d9577f25ff,
+        0x1a40b1e01a096ea7ebce74c027536bc58778b45dcefb7cc056256dd07326a662,
+        0xf5228bc094b9eec1967d778a2b7d6b4de58ede8e0f974165d37ab6f2336bee4,
+        0x27314b961d2f96970977a33f2fac6823c043207e4b6a48a05537ea78d779c16f,
+        0x2a78f5bdf98afa1da6dd45ab360b877703e1f9f0e797fecca45327ee4ab46595,
+        0x2cfde59ca2f01a27fce554c265bc23fda32ddd9dff3dd0a2f1dfddd0764c20b4,
+        0x1925a7d1cacee560010f843ef5fc9e7b0294667d871d49e3523a88fe0af56aa,
+        0x199ff4bbaf94ee387560fbbec395db1af9eed9f50dd60dc3ca2cb92e92452263,
+        0x26f7f91d959cdae91907b28fb2f149dbc275f13d55776da51a88200f8e7caf09,
+        0x24cddd641b7ca3bc6c4d257832a5ae5e92126c3bd2e9f05e012731114d62d0c2,
+        0x18547edf50bd77b2653c2a53284c999dce5dc69dd613804d10a0ee96bca55738,
+        0x2b27178eca4b798ba72b2e6b566bdfeccb2a1e60d8504e4c8ec9192f2baebb,
+        0x3020eb88ae7acfd6342709f3d3be45cf2c146bcdc906ee5795273ae4b6e7004a,
+        0x54b81a6d3b1f002230c4cd623f77b0fb6eeca3afefafe694544eeeec1a170f,
+        0x4d1e03c93510ba6fb49bd9ab51063d3b15e48e2ed449bda2765d03065f6cffc,
+        0x2ca6a28e6b98b8c8220abc091a2fafe86f271eef1d93864b7b2bb5a160dd8d99,
+        0x2a586600678651f144bf1e54de3d6f8fd519daaf4a4ad9a1f32233e89f9d6733,
+        0xa94a9fb854a3c53411d736ce58dc82196b2cd13144a240a6fe173508a221d91,
+        0x2d336c647cbb5478e3a72f20f41d135d35f96fbdd9b2b2884e6b23ec201e47fd,
+        0x3dbe3f89948f9f4715c491a483dfbf6f6f9dcfb5853c5d3ced707f0050a218a,
+        0x22466ec15338114c3b316b2d986c8c0d3d14800d82275a42f476b0ffdf9435b4,
+        0x1c2d6c5b182f394e8d36999e91a9eee77da71f5490961fb783a4f8e6f842e687,
+        0x4fc56515cf83247e370e48809d3bd245abb52638d86b48a1cb743167db2294d,
+        0x1aaebc90617e5aa4b4f9036fcc5092da7edce9c110e3eaf00d7fd39b17aaed27,
+        0x15f7dad928cb34e6858a2deb2f9d92c452a535a096c5d713f7319c0c577e413,
+        0x60028307221323f46eb56773c5320fdaa2d7123875b420176e34b3ee079e972,
+        0x157b288cec9b5356e60373bfa43e67511e2a7e62493650c8f38d819fc34e59d0,
+        0x88dbe88f3fe8fdcbebc34ce3f00f07fda411d780ecff1da57660aebfd12ebfc,
+        0x9f13c89213c82d5bfd38f8f8bcfe46fdf403d28e6d349ec0176e37df9c912fe,
+        0x5bffad53722ac6c42236124c3200669abffa6dc923fbe5141c8e4157cd317a3,
+        0x290a7829a4cef2e25d2f6f28421463344bfde52203d4cca736573537af33421e,
+        0x9e7209dac7151697be17d3e3ac52b0ee6467929b878d814ae4cc2734b39348f,
+        0x7629f5b7cd3dd536df6a866a071fb5df56352fafd0f097711cd1667ea344039,
+        0x11641de0af5d033b442dce1f8334eafd4959f122304ea6c2177c377d55eae045,
+        0x1021e806d83de4cbecb3c1650c761774e83cae4ecbbb0df13310150cbada88f4,
+        0x4ae37e1e7676e1d3cf64285f704135c8cd640f70c895bdedd51ded260fbb69f,
+        0x2a491d28b320ff77bf7221b59fcc2535c7cfc9c0f11a5fdc5e49c837a71f0239,
+        0x2ba7c26958118f0b751444e8ea3524d45fccefd8744618e66e55679e42be29c6,
+        0xc6516f4cbac8b8f29be9406c6c309df34e2da7d931133e4a34f29ec6283e9b3,
+        0x2991acc7db5eb3159f8766c49d692079025b480a70656435ee70c5687daaeb0c,
+        0x29d7605b413cddd192779b7325e1afb8e52ed3e97e92adf701c7a70c118c648d,
+        0x2507bd3788f57cefee754d3ff5a92980dcf062ae4a3fad93ec0059eb2fe545ec
+    ],
+    [
+        [
+            0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+            0xa514a5c227f4cec95dfa029e8dd124c34895aa46bb27c0911f3780d5015540a,
+            0x278bb49a7b4e44aea46eb0f882cb692801a6e60fdd5b5c23c63cd65ccce4fe0a,
+            0xc399e9f67aa40707a203feefb0b958bbdadcec5ca34901d253d026a2419f6a2,
+            0x1d6b3d5f6ea369c26f825d2362933eaa31ea35ec0a77c1fbd9e01ca1523e4432,
+            0x24be510095436206dd0abd0b0cbb95c883ab304aa52598b1a69306ec981a688d
+        ],
+        [
+            0x11924f02fd19b09255aaa1cf46ea0518e3d7bfeef47421609491011db0bd0b02,
+            0x192e16d17d956b257b85a652eefdf2ee09589eac5be80915775723d2cb1da06d,
+            0x63edec1bed831f506af8db648d6fdea145345887e8bdcff109035a1d9b674d7,
+            0x83f0df3f1a0351d0330ec3ff602ca8cc353b7f6e762c7107184cd7b423449f6,
+            0x119ef188bb3dd0d32306976c19941e8664be687e7a69692da27da215a6f06d40,
+            0x211610e2ad4a377426fadf7068b0c1a6c299a164c1c1a603eaed944870d0b9b9
+        ],
+        [
+            0x247fa7f022304a1994ff505456c2201ef9b717369498d3ffce446601ed9df845,
+            0x298ce0c1e3113bb935c7058e7772b533b1aa9db0c0926bdc8917e5605ca3ac10,
+            0x1baef1cb5509b526a42061fb53657f99b3232500e855192cbe8c940e068c475f,
+            0x1a6764d5943fc4a720b4c0a19fdb8c711984307287a58b9b5f9f5d58212cb263,
+            0x2d9e0ab5c06893dfdfd03481381ba86b6e6292df5609d71f2c64b2d9a79f809e,
+            0x15a67d981041b1f6f09f3f9ebefd864e779d3af08157786ac077505e50ec79fc
+        ],
+        [
+            0x3fd7b19ef2c861f22f77ff810f54e277bc94eb76c02d79d986be3dcdf051c3f,
+            0x94cb4e83621afd271e41bc71727f0158ebd612239ac9d698b17fe4be05b7fc8,
+            0x1324564ac7bdf9e22164e9858d7fa8e368b165eaea3daf4eb67ee59c0df2e5d4,
+            0x11a63a26feabf87fa66bde66cc25a922c96382d76c6a7ff48f1537beaed683a,
+            0x25f16631bf77060f7ea34087c025bf135784319ef08cda2e31419ee0a529e658,
+            0x49327fa79d28c12a2c82406947f77f06775b0287468b3136877701dbe7c9598
+        ],
+        [
+            0x18bd41239c3e71579a677443ecffbd555a81eeeea69352a68b67c8563c0c2a06,
+            0x3d880395be93c27d649af5fd142e76b33918cb8841d5a28173bd5cf7d328791,
+            0x5761b8c6aecb1a8ca4ea4dfc2c8376064a4a8004ceeda210a55240562ddc13,
+            0x8ca7b64657c3548f32bef5b63ad24288a41c0b251099ad27f9434307e3e64d4,
+            0x144c7a11da5a7c5dabae3f33fbd03cad86d18bc594c79a497ecb9894edb554f1,
+            0x230940dcc5232658ff9c29697a3fd416d170e8c998f1aa85dea0c42d79f951aa
+        ],
+        [
+            0x2d78c3a5d28de9ff35bf0a257635196e5730ca7f40493277078cd75da8b4ebdc,
+            0x28eeae6b5866ad68e443bbaf91680db7d7e2b3037e38fef61b42cbccffceca81,
+            0x10c9e283159d58cb4cb2e35fde83a3ba1fdc28002ed9963d2a99f186178a148d,
+            0x1998270471e9361955446b0cdb8bea915ec0675f1cd648ddcb04303507a4489,
+            0xf971162627723f3feadacb28b0c104cb8f74de508752fa8d7c0db2af13de8ee,
+            0x1b121c049cd1159e289007e0c9da9995cc4bab4c26fb888ec3972a8a2e656964
+        ]
+    ],
+    [
+[
+0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+0x18ce75a35f7297cad2bcc25f0ed1bb4f7c592eea8c6903b19850511ddb83274c,
+0x138f93361c6546d69015ad48ef50af34fa9e19c6e6844a847eba9d908572052f,
+0x13c29b24c0e38e65a1b9428622ba42931bdb65eb5975e66d3c496c7fe6f7a30,
+0x211a38485f1e9db425379f4b3fe9c20474c968aba2ef8a4bbb898a8420d0fc90,
+0x2fa4d773833d944be46ec798f7d16e9fd02f51c086141af5d69acf97e9a80b2
+],
+[
+0x11924f02fd19b09255aaa1cf46ea0518e3d7bfeef47421609491011db0bd0b02,
+0x2c001eb6b378c49fc5b37aa41c13fdba486bf324eae0e0063ff83551827f338e,
+0x51071183ba1b8fde055b8f273005056fb37684b241f88851a5b550ed0cbc452,
+0x14201055ff5412f834d761da8017961213666e5c44d6c5a8237deb4d0f734d79,
+0x182177db418ecda99e6e9999c3c0492f4ec27a89b2ab554dc8165da9ba8c9762,
+0x1111d2d4d2a013e33fcad48d574587e3d7f7f6b484d7fefcf933dc833d13bf28
+],
+[
+0x247fa7f022304a1994ff505456c2201ef9b717369498d3ffce446601ed9df845,
+0x16e74e9c0932c76182ca25ffa7dc6ae62b2cfbe19142b2ce1d95ec0839d7faa,
+0x1a13e7beefcfa55aef7815712c7b350b465c0785afe7d6b356342b61047d07c1,
+0x1adcf63e81b22ad38811b20aa6175ec41784eb99fbee0f3e56a15df0c1ac5179,
+0x2f3a76ad0307b740f6e6e7aa989335c6000d930029beebee83c0631b3b435123,
+0x24dd1c38ec3e47cf711221cdaf4b2ccfc0991a178cf7df2f3d1b88f858763c40
+],
+[
+0x3fd7b19ef2c861f22f77ff810f54e277bc94eb76c02d79d986be3dcdf051c3f,
+0x24de008c4b20c4dd769afa3b377e2e72f0a74339f53c3f6ba8b84b0a85fbe9ab,
+0x274ab81953247f18a26dae90d93deb1f33ea243af6aac4e05e117e233b922bd2,
+0x16a796c4310ddbc2c435ea5ef0d6381e163250c33485426e97a566ab6f2bb07,
+0x1befbb4037c8b847d2711cda8600d941a1583cf2fe06a8ae02bbc26e180259ba,
+0x3a01ab7488d6cac69f70b90101e5c8beb78bf65a79fd6068c9010ec2e0fda4e
+],
+[
+0x18bd41239c3e71579a677443ecffbd555a81eeeea69352a68b67c8563c0c2a06,
+0x2a28f2409cb364d31b858844023279404e2ce02d38430be77b2755aeb9193a56,
+0x1b8e6cf61af064c9804f1888a6a83f6cea7c57e574c229f978aa922ddccd80da,
+0xca6769d4383398d1a04d3d7a6f3510d85fba7f5f6e6d287d447908d11c71153,
+0x125428fe689ac0be368c80b67e8b2ab83d8163ba30b4391927f352b3bf3dc5b0,
+0x30516fe884be9bad887032b15a83c91d84147d44fe15c90935ec4d421f5ed05f
+],
+[
+0x2d78c3a5d28de9ff35bf0a257635196e5730ca7f40493277078cd75da8b4ebdc,
+0x2afeb1a63b374a502180680156748121a68fd7002114733bb039f74ad576c0d1,
+0x3ddf5c61fc2eae153e94adfab9b234d07b261ad228547ba9218c4caf6cbaae9,
+0xc2e8c673f27f45ac1112d92cc8b81ef4af42657d7a114d2d6bcc4b74bbab7c7,
+0xda5ededdd0fdac9af41d58581e5aecafee671a5253023205aa9a2b7e1df842c,
+0x280364612aadf31ee5b176ccc54b4a5f961cc782168c8f83ff2ab5b4d12adc0f
+]
+],
+    [
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x6fac61a13c7139a37697a657fafd9c12611f196b60aab2342eb6e869de7069,
+        0x27b4b4ea2ab70bb1a791b43c0571329ee6e44da480d8f0bfed4eb43125bdfdc4,
+        0xfce2531c0dd9b1906513da21cc6442611222f8c05b5bb5ced0c5d392a1b4254,
+        0x2278afba888b07c659b7d537ef4f2da49f03e42e6fd4f6ba90966b2bd89291f,
+        0x456a8c01bcdcc91bda80b7c97f7e9019009163bc2613446a40a49fba3c70ff1,
+        0x2e4c46b8f3ebe49417334ca76f3dad782cb15d40bd4fc143df9937aae5fdd9c,
+        0x2c13f0f7c421c96b47743df05ba0a84d302823a72fa019c251cc653bf9fce8cb,
+        0x57b6bc405c5ad7f6dba556199efad30bf33380cf4bf74ec23214edd123676a3,
+        0x2d127c7a346cdfcc822076c8df679eb5cf6bd0b6a1fff70f753f1317acaaf8af,
+        0x1a4dc6959d65fda6047532a57790a1426499672d67b10ea360603bcdabda06e1,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1ab539242bb16cb2ca4984bc82002d07c6fc29bd0d9a71e348669ec4f909e567,
+        0x144bd8b4ba25cebbcc44c0847844f5d945e389efb61cebced8ac7740104e2da9,
+        0x8325106daf6927a182c4d83e0bbe039fd390e2507a359747a98d35b41bf57,
+        0x1469c5365c13ba0cb10b14f109d6893eba3239739e970ebc50b63a9870da0ede,
+        0x111e82bf1fb3d4458829cb1d852b66f7c2ce4079ed210c88374dacb88c69c252,
+        0x2bd6778059c21f8d5df3e825464319ba8d9f0fd7b2bdc4525ac788061031eab5,
+        0x212d3cc6c2012c922fd9372f6be58aa0518c392a9e25338071401daa267e36c0,
+        0x267547f0b00c32e85957a425dd05961a02626ac79b2eee417af0c450646ff99c,
+        0x15f1012eb18a32c69ac392696cc974530f711109a197501b43d9b49c445d9dbf,
+        0x24e5916738efe20b55496e3aecbca9239063458c2c562f3c0c2ad45ecb9a0c27,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x537e9d61e32a91ac981e5442837942833efed46c25b4009d6622c1d5cd67228,
+        0x2409867674021c13c26db12dc4687258c8a7b8c39ea9e5f0e538c9a5d79d00b1,
+        0x12dd0ad0bbdad721a2bb795f4b54e08a21e4e5043e30bb1fdf1e369b45abbb8a,
+        0x194d2892087f1485580dbd9db047343f73d71741cb1d679264d0f15f22011a17,
+        0xce1f30705772a51b72eaffe307f73c59d16cec505e28a06352fec8497398b6,
+        0xb4c42bfd8b2eee4229dc6b4b6ae934b6882a560dc0b056952cea95e04e84ce8,
+        0x2831274ffa49361ca9ad0f3687f1fd840db43b13fc4bd747fcbcce877ed78fec,
+        0x11c3faaea57cd532f952f56dac42a8d29c72c8d1b29459ec218d5280c374e141,
+        0xd01440afe63c28b5820215a0a082fe296ae749a3ee6116967d46c4b9d59b77e,
+        0x27fd7799437558165b866c1b89762a0b94bf7db886b158ce62dd2ba01dc6fd48,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2aa5a2f43e0f4bb8b52041f635ec810e7fbd82548dc722605bf2c15e7b2e044e,
+        0x109e17fad36368fd93917a9c4919820ac8620c5baa64d813f420f25f0e97a087,
+        0x1c6178a12c2d4fc816077f0e4825fcaed9b6ddbca03d665be624cbef3df6c10c,
+        0xc8b545f3ba3005742d7867b42b2acb3895868630d4d1ca9bd2e7d18b22f7b1d,
+        0x1cf272cf45a39a8f47599447b65ed8ec169b564e656acd8720550f78b1aea9e9,
+        0xed81d4f2b8cc774767ad184b89c02d1cf3aef1866d4b8df571a8feac7e1fb26,
+        0x25c22916d7c3d030b6207eef339a432d2f2a485a98a63fac53be6a93d90cdcc9,
+        0x140c2f65889d437a0736acd2164839f1a951aa1e9ee18258b701b19d0f880820,
+        0x19b9bf03c47ce774ff4541d66232a3a61a1eb767c37ec93730c2d29b43ec2d0b,
+        0x1464a2e5c87714bb4afc1b5cb90f1cd587ac7f3133e7f4a5e45d0426bafa3946,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2fdf0895b6e7dd081135a74466610d02ec2f5e53d065f8f28f55626f8984590a,
+        0x2136a6254155d5370c654be03d5f2ea833abac83f3ee2aa86080b4c812f6d9ee,
+        0x2c25045d4ad7cabc1457656efe3091cffa14b2a3c3a74cde1619658015d69a3e,
+        0x35edf90ee5ee2937a2258e02a11d996be7d2263c30a8111a8f461b31b61d756,
+        0x24a6181596fefcf6b89c799218467001223efd7b39880e0b241bac300d20a3ad,
+        0x29dcdaed731430d9695b46313d84713e6dec7b565f79b94b2cfa3dd7e9e4ea51,
+        0x1724f4a9b1696abe55d95e9c0dc048d1d473394ccf983f198d9e90d2c73d1b8c,
+        0x1af69c74aae418d0fa8d9c030ebc68c04e608e5a8cc00a35b1910ddbc6fcf143,
+        0x27a0793076b09c2b5e775c8b738f488a11171c0066277483afa7fd8c1dc5bdb0,
+        0x1d4ff6c75f1778615e31525a57fcef7dfa5b5d84382b5efe78fc90625f8e1e12,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xfdf45f1143c7650173ddbf41fd32b101ac1058dcb360e4f55fb042d86b3bbef,
+        0x28605df321f1d74a93860493ae581fac9bd5dfab8755373d8bbea346601a2a1c,
+        0x2894568db7debb47fdb42ebcba7bb4c2bf391c73c0ea435ff611a9a721a2ab09,
+        0x193887de99914c911549cd4c5a402b7b33e650ef0009d7c99075bee089ee532f,
+        0xe5688ca400eea76906895ad874136e390c7545ba17d0b64b9da48aecfd53d91,
+        0x2c60db3843ae2171a20f4eeddff7e6cd3bd2b06cd8d39e97f93b895a4096371b,
+        0x8fb4f2d9d8a12c667625b7df6751d25d3409df0443411de74f779e90109ff34,
+        0x4d7d91e3652705f015e14eefc3aa412c707a8615d7dc336fa2da72d1a1802,
+        0xc60ca70bd06719bcb51c3a8664b73f8b921234656168e68d4ff6e9552808d54,
+        0x1ed054abe9f3b4e19cb8a439399c5ff5f6de90c8463a09b82da225c567d05095,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2b3d78867b390b2fdb654d68512c316ec959c5b8c9aec49d5fe74188257c3b6b,
+        0x19f72308eb341f3328570cdc9f78fa3838e628260d6e76bb3b09cb4e5136545a,
+        0x54c9fdfc6bb12bd2061b153f433d828dd2ddf02d56e4d6eb280f19591597d9,
+        0x20a858ce8c00fe452359acbce4df9110ff6c89a362ff4c8ccc7f9da470124a1c,
+        0x1a55f3dae7d4d14c6eb851e44463ee0da6e66b0f56114b8f46dda9e717a9b1fa,
+        0x65d52f3291af23a00e2d058bb6ba8e17889f7d03bfcbc5234272ae8660abf31,
+        0x278715151d06026cdd68f4bb0fee4b041cd0a8c62bd5faf71b393ea9dc3bcf2b,
+        0x9c6ec8631ac5a417f041efe2951033a622baf01b9f1630c7bc093ccd6f3fc60,
+        0x9c078b2310e182f40304e342c5f965f8605102931254955aea231962f762f75,
+        0x22f4faf4ed2ac6947282b926253d93751ab1118a05d1466bf117dc853dc3c532,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xf24da597b74c3677589a6cf15426219cd0e2c1a60c9acb4b9764b8e5b4fb5fe,
+        0xf39e91701d900bc7ea63b7f0d3b753cc31d2cf6666eef786a6400ad04515c96,
+        0xb41187c60cc3bff1020fc4e647452ba940a5b3d9ffdd1b47ab613a515df66e5,
+        0x619fadfd7cbaa89e7d5558c4d23275665531928f62fb14cc4aa42605f97a1b5,
+        0x285ed3287367338bc9387c83fb8987cadf1b4ea7f1dc6b172e924ee0fd2ffb87,
+        0x853d29d7e18010d04607ed8b3089833d55166ebf58aef558b3642f29ae2eb31,
+        0xb1d3737cb97c59030221a7d5d112bb755d096d8766242158d0bad07bed5ba9b,
+        0x272b60326347683fbe6dff2b97289dfefa1be8238526c8067ee0a126942ca6ae,
+        0x2c7ef420b2bca189f6d7929af54403354933d68446096f3cfccd12e76818b23b,
+        0x10fa5605e0b680e055175664a979aea1a45c45057f452e5b90cd613012b70508,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2ad6fe66fcc8eb73e2dd7dc6a2186c31107f8896b5f8c7f9ebbac9bacffc59,
+        0x1db23b49760ab87c22237095db005ad9b792ba63647031f2f5e8d0c66ca2c833,
+        0x2b51ab38d81609e885b8d8c3ce799cedac1febdec5e27a205ca82b010b3bd9f8,
+        0x2bbd8df986114303d59bf8a408982796d6f1809269b983910bb6fcbbfa72af53,
+        0x3516ee288a26a7555d7bc66bdbec4203e74c105513cd8be87a99c035a176c22,
+        0x21161b2869e0be07d85e11051ac0d8894044cf1b4715d5dedd57cbd6aa48b240,
+        0xf4723c169e787400b2153bac8a074da0d992f44a8558a0956d563e73ac03dc3,
+        0x890ec1904c98ba5b3cef6bed816850fdf6734951b143faa0c2c643a1c1368b4,
+        0x1453882ebd23e2ce3f5655eb4f2db4e7d6dcd892a14e3da655caaa5f45a2744e,
+        0xdf69ed4eae9a6ffcf54a77d8d8ba14541af9d276327678b71e7c49c8deb41c6,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x84cfab525ae12db3c30220f978a1b48bb652c2e47d1f5f4bf1cb3d5ea4ae0a1,
+        0x220ee2aac4ec50cf3a51d76ea554c6960befe1a9b946be4b58cff8b4d8a16561,
+        0x9d60891cc06c285c3ca3cf7a78e37e2516e4d0ff503179234ea12645848d45d,
+        0x2f51338183dfa99604f1be042cc1dec8e96e08c7faf7bb3b7eb860dfdcdd295b,
+        0x29fb82b7e1ea4acf9d2ca8b32f27e68d10b27214361156770bfa4732f85e1b01,
+        0x24d4646bb66688b33367aeec4cfdcfe16b7d21f47f1bb1f88a25896e526ecb8b,
+        0x2cdaecd1c5653769c095f9ab2e0b4131a3dc4f581954fa91120dc7864a5d5b5,
+        0x2e48eb6f5a9dd830bab11e8f49f7431a851938335f6af547bdcde3b9a2595913,
+        0xd3d729c3d04c7f9967a7f3ce11c053d5a5598f0847966dc9840eeebd9676b11,
+        0x2c9c7d8f5c11a1cbf89ab2b794739a371d818f77cc71bffc6ca55d4472648f2b,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xf330feb7fa24cbfbbafc2eae5d109a2bbe9d5358ec7a34035d728c6a531b17e,
+        0x1b4af72b65b66913013263c37d97ffaddbb8a824b34d45819029b0867ccfb460,
+        0x2ace1ffd40f56f145cea9e679db6c57732315343423ce026a8e9275e888307fc,
+        0x1c328a5168d04cdbc31519e037fdcc5c426f9a6990fe80c875d625880c7d033f,
+        0x1970922d81c9cd97d3030d53733e33e3d046684219f4960ecdd0910f5aae548d,
+        0x76fcdeddfca38e6bc4c5e872eeb1628caf23d8d7b966d97963f38b8b55a86ab,
+        0x3e273f1f05592ce120df7ff9ba32eff1c1bc065b149c2c2a7986c1569e4cc3a,
+        0x2b1f8dfec05e8d4495fd0759474932a003b11289a3440792a48e2cb777badf6a,
+        0x126fd80bd8f9f83f00cc51cde97f9e4a3bd540c93921e8f3603c0cb13f89cc9f,
+        0x7cf5007a4ecae9f4cd74689126175d8a81f7c51a317a2c1657cfcd533b4a57a,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x18793b6ef20fbe077cf212e603b2a491b8b9965510bf81c85b4cef874fba6093,
+        0x5bc7621748131cb19ae5e7e6cfa468344c116dd37fae01e1780381f9b1ddebc,
+        0x1aa859447f3acaff5c15fbc24bf7c164faeca846b555b02637fa84a52cc9efba,
+        0x28c3d01915f85693e04821e4f2ca799c62b1fdc4739123d8dcdfbd1c77636c1f,
+        0x2c7f8527d2ad7d02e7046dbe690997f033e351fd18d357089e988e041223f15,
+        0x126b669244c7ea73d340ded56f5edce3632a0a69b9cddede297acf2f072db9c6,
+        0x24f71ee920c1cc2790112e7a8e9d3d824255420604fe31b331e98d2bef539781,
+        0x182fbdc24f8599ae291b3e8a96bd15251396a94167c8e34ed1f86069c067f03f,
+        0xeab7f1b18721b3c154fb3b7fb067c4f7ec18a50fa3ab3aa5873a408d6d8cbbd,
+        0x2012fdfd4d53aadbac3d7ab9172a826705d55e5862d1be643cd4449e1cc6b06d,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x140490ba93d42481632e9924a725c65bf59f7e4975e98fbdf486a9772f4b6e8b,
+        0x2adfb4e0a55448609a06a1ac31bc5d06d74c45a4dd23680923d985b867f054b9,
+        0x2035a526748b686ac46231697cc52fb4c6d8e48c4314cb0a1ee08eaeb43938c8,
+        0x242ec6b33cd2c625d1ca2833159053a0e9beeb37c59ec90e52d40c983e865096,
+        0x10f8808d7f88620998e3f144046327b9522a07220a62c7986debf2820accb611,
+        0x5d4d8a6023401b798a1b296dd42c9010da081b9e6073aa73dbed7a98bef4419,
+        0x20be6be68c47dda41e08c5f858520b25c036923b978fa8be6e870e85fcc16ac8,
+        0x39240da2e14965307bd9be9af5c0cdda03a4019f86c45bbbea90f40afcfc500,
+        0x60457249c4fffb06481b95457ec48e2b795dc414d6b71350ad08b56cdba7c3c,
+        0x239ebf95f3d5909ff12820066059f1b999f9ee594dc03af1fad6e0015d698e72,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x90738838c7088a39b45b7b8466e003c1d0b85fc0c95153e85f9feea552cbed3,
+        0xd0aa07eb53bc77f6a7c777fd33d11e4eec54afb97da769f937310f797df2469,
+        0x22e87e33862f106af8bf1a6ac33f69d994ce06f021ad32236f5529eb399a8ef,
+        0x16a3ff860e2110d98eceb0f5e7946d207273ff9a4f1e088a009f1aae19c5b0c0,
+        0x13e35cdae4c6ff35a681118ecf4612503081b2920a59f54cbf5603c5690ead76,
+        0x11dcdcbb80fe328963d887aa5443a88e602767afcff3938a877ef8b5e6b62084,
+        0x1440ac3cf3a1ca78709a2a97a0255d08882b40ae287994670dc7d58d7b929c71,
+        0x9112aba3d285034fd7808ce5c69caf188aa2192e3143ca73ce3ad404c503a9a,
+        0x2c8eb1b5f21c2f320943badb09721ad68f1c2f3576531713981a905daf415450,
+        0x695acc1afc2070eabaf2e2279eb6f11d6e24c787b37f3a311f2bdac5cf0b160,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1fb55d0f07f478f8d6f5a59e0856ad2bb9a4e1987cbb36e437895230685ceef5,
+        0x24ffa19b717061f29d7befe633215f277119ea89aec1326f9f7e2fb3773f3a5a,
+        0x16cf73a3eb3a86fe74cba7ab2b591ecf57d66ffae3113107298e11f21d7f69e5,
+        0x115c7124e48b479e39faf24d853540716cea1bf2fdc19fdec358d1f740c1f874,
+        0x1587c165c3d5592e72a8445bab791271ce64032bf746d66194ba23a413116cad,
+        0x20677bb9ac0210a06115586f21fdcd1e6b28e8a1a8664e48681bb077b75e001c,
+        0xfdcb34056ef1d893287ad074ffd8e4d767ed07f9ac97b5de1f34d8e3dd1a651,
+        0x19ec313123a0d8e63b853a0931c9a99b14cc775f1c312bbb13d5d53f8818b79c,
+        0x19c0eb17f727d16dc136af9e86888808b870b5e9e5d9e3a3c3f0d9431bdd5728,
+        0x2b158fd09d9bb317ce4378cf6e0d574374690d42cc465100ac3f9a6bac9b6907,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x67895e624f72c2ee73f06438d1e38b380f0259e6a04047dc2ee474d543df74,
+        0x24d801233a58b2016b8c6af6bb88cdb17e194fbd8c619a7d844ce681b933d5f1,
+        0x18bbcf6fa75ef7e68070f388815361f028acdf41c8e0d9f2afc62b8bbb9ab94f,
+        0xd8f16cc1dac32ee244cc1837b1ba594c32a38e1a594a6f1367af545463db7a6,
+        0x85b04652f4427e9220976032ce4aae7e1eca676f0c169f9570bf91014ec3d60,
+        0x29b6e637abd64aa25e69de1bc8bc2061010a523a6319d49c8d908c46c2e76112,
+        0x686bc450316a122c312fde6bfea7146f929091962bbe3225769f767ee92e1f9,
+        0x1c7db281138ff861643018caafaf569efa4f7d1dd5fe8db8115679c9d4e464ba,
+        0x434b9adf694ee77662c888fe50a3f24f9a680df2fb6f501422589800c123cac,
+        0x26bf3831811b3222ad4a14f3b9a5357b756702139b7d8e7e2bb87dd6034b352d,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x24b42bac7abee89474ff328bcb61e4ad5f128773e068dea11b88fc2ea6ab66b0,
+        0x199ed05bbee1131c4dbba92583a02fbf9ea30aa59c7f2fc5bd5c0857cedb470f,
+        0x2bd6670f967781e74ad00648e01596abb5117b74adb95734ade1c81fd02d100a,
+        0x17127e11451908da53f67a87859373b4c6db941086091270d35f7742e286bb63,
+        0x292010c36ff554b02f56a128071f54171b237591087f805189af62b616205261,
+        0x2f6af6bf3c24ccd04480e6490018b489284a951f067750f4e8b461290402e3c,
+        0x11ff6780b8da3672a8b9eceaf9d5ad240bf0f1d91028f3abce5147d0608449e7,
+        0xdae6cefcea61ea52cc1bcd5bdd0c9a4f1cf123109cce7354405dd38054a8b2e,
+        0x2234fe0dad3dd0ded7a39050f4478ac43bdcdeac99cb7ea75d61a66c2382c35f,
+        0x1627a2a755f77f83d07a5cc58dc2aafec9ce48a85427f07f813e217e7d3e9272,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xbc958ac5faec064de3de070d9605135bb3bc321f74b7f4795cfc4cdd4f64c7f,
+        0x1761972f9f0d7d67e62f476c88b521ebe60cfe3e1aaf50580acd20f45590507,
+        0x3ae68549640072b1b75251b5fe4b2282191f235ff9a753fcfccc995a3ed3734,
+        0x1d3a95b2449e1d227b3cb97854bdfa5248b78bf8acc15feed87036a74829b12,
+        0x1be688f94403019eb20b49acd9f201d5b765853301e9f30943647cdac98a983c,
+        0xd40a2c767f9d882eb478793e2e146af99a620af4a76e6f3429d6259149311bf,
+        0x2075d588d996d67e08cacafa27bdfbb6ff08a0d97d2b6470f475b87c034fad40,
+        0x1db5acabacf79eef4e6079222f548fc488438af4e04f5f8e64f37a80eff37aeb,
+        0x14042fd27044254958665e0fa0ef7ec155c9079147eab6fc55c9d8c35d433a04,
+        0x21ca73c94e245ed00ec13dcbb943bf4ab0ae1c29b0f3c2dd27c7ed414a39c2ea,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x20ddb53f4160aa862028ef9ffc0ca24edc8e7ce304602be7e8db7a7ea7aa22ac,
+        0x182fcdfa75858b86631ea8d0e0308f3e1202f77cab67f448c118d2e47080c137,
+        0x28cd7a17b0f3349700263450f631d80337f6f6e490e8736b4c322f77c6eb94b5,
+        0x4a6cffef8bf0db8c769ef391c25c8162ad2588db68f202adc27f23e01199f97,
+        0x1f208c20855afe52522395aa73d971db1dc111dc531adef15f24a91fd6cf7085,
+        0x107fa0c5c5aeeb26505669eba119568c4e249d7c16da6fac168de7abe11b444d,
+        0x210dce59a46fc548ea60317c73249bc85062f0c2cef2944df4484f967c6248b9,
+        0x278cd8d83323de48695c3da57cce026e001525a3dd65bc57ca2612b3c6f1cd82,
+        0xb9cb7e4dbe036abc7cb070e610b96d61b7fe2bf29a4aee59d5f051bdf1b942f,
+        0x2aa13fa2731b295a9974aabe82b9cf343d27373cecdb3a83e03e0aa3af07baaa,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x11e4ba066ef8a6cb251a9704dd23abb5e8ef31ffc2048d70400ab4029486d1cc,
+        0x23578b304fd7b3d28d886e3d71f029c849885c84f9488e5687e5be7fbc2d2e4d,
+        0x143068c60714bb1eb26b0991681a9117decf370a9e1a24ff5d2163fb6c8bb770,
+        0x1a42d3af21b7f72faee430f085becc8598c057127907373ce297e1c1493715a9,
+        0x260e79c967c0d5bc720f95ec7a7b088051dc85423f798776f2de0e8c26606002,
+        0x2314b014bb5c57a4217f48112e9c91186bcd27feaa9a1f3800fc6b2fb6ada2d5,
+        0x10ab73560f145dd61d66edf15e597c73871a80cf0645b714e6e7268bc1b59bd2,
+        0x2da780f43e972a1ea7844b5cffe76215f0b86f708c3d0ebc758024a3328c67cf,
+        0x26e5fd2c13423aee6c1a543b5d4fee91af5ce83d74efa84dce6ab9323d1644ce,
+        0x91cf8a0d9aef97c341241ac92fade04f1f21f20c9af67c55a6a63626b73befd,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1ac2da30c9db6a34995d64973ba9137283144b108b9619f678cf3f4a95c096e3,
+        0x11376660bfc8fe7104c949626d350f6b0dc1b37973819e4797017487619ec25f,
+        0x21a72bfc29af637d0a76681e97a310e9ad1dc8b47a66598807e88fd34a46aa81,
+        0x1d61ed0d0221cec05abe9d2e8c0f72cb74cf4ec2df3ed582d4acfc2afc972f13,
+        0x2cf2377f25f134cd525ddc0a210ae1edc91adc51cfbd451a7b280d332463fbe0,
+        0x128d871cc9d69dad9adc58ff843d01210527b2e434fb21b3770a9a7e639cd55e,
+        0x180f7db2b079ef5027f9e517057b6186136b6631556ed4979d115704ad305729,
+        0x271f62e52e4a218aa6d6af3d547117c04b4c082c24950714dff89dc0ca70cebd,
+        0x1c33419ecb6f7066567d7fc5addff3010852e87e68f89d6b6dbce38850401526,
+        0x1a75ac0eb3ff4f7b647206b926ab9b6b70e54815c7d169de9dfb34b4d9baf9ec,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1662417df464715005ce1228264c58708b62a54eb3d0300c7e2ed1017828f1bc,
+        0x1bc3d8189b4c0993407f585a4e859ff2d038b607f678602ec2ee5af423dae356,
+        0xd1fdc7177e273bb5962f8ade3aa5d858ed7fd9bbd22b2d9856348382e8481e6,
+        0x2e847d92b4b1cd7198df2d2bd91b845c52b9d1f25d685bb54cf43d7cdc06a89e,
+        0x2116ff3bbe130b9b1bd4b76f1cb4b4d7c7b472cefb4d98dc08789dc993aff289,
+        0x1057a54ade240ea545bac05e9707460d7f0e1930cb04e460e261852a5aee96a1,
+        0x24c6693b4bafa19500e73514069e278c2abfaa8370d62312ac7dff2d8f973327,
+        0x2cb268850f0ed89fdce142c8511d2f583a22e580cbb3d0790e41bc7e47420331,
+        0xa731e96f407cbd92e535d4a18dd9981ce5c8e4ab15bf7f5eccd29d831b0712e,
+        0x9f9e3fd0498d86308ea480d5ffba80e367c19fb4a78b11712dbab0011cae43b,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x4670b146f637567754612aecee2b9bfcb842e7d6785b7904a3b1e37b740d4c0,
+        0x3c5e0facfdd5fdebc0255a4f78af5fc16c82892038137186db5687475ee26ca,
+        0x23a34dc39f0b7bdf631f9c88dafedb4bade20015c869fc463a25b7c483254b57,
+        0x20a919d5f1fb9b22abce924797ec204d7cf534a9c5e908e57315992edc06062b,
+        0x41f1d89022bcd40dfcd978191b200f8a2b7adb2168f3202b4f2dcce8726d922,
+        0x23c914f4087c43ee789ba6be9c4b99fb032b7b5f65ca9f3af46e14dadc38134d,
+        0x2d61a559f806a5e382041aeab1d5456dd212c3018ffdcada5235fd842f37ae0e,
+        0x2e5457db2f94992120c5c9054a6a45974270109e5c6b5a4830e175c812549aa3,
+        0x9f4292ce6a22415c7f83c120b5613b9b66fae13bc8d1b1af298418be41079c3,
+        0xf82a2950fe7f2169a76eb6c5ce246ded654db2f03ba27e88030124d9ceda7f0,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xc8a9b44c11b429d1cb9eceaf7f5501e9f0a400fbf4f0ff3fbb5f977607542f7,
+        0x116275de531eb4f4861812d5dba5dc91ac027d187072cd9aab4ebc5c316eaa0f,
+        0x10face39f20b71707fe83569937fa20ccd528792796bafd01dc9e094ba7336e1,
+        0x6cc30ed5380e3e57cb30f3cef40f3c49819eebd7784a7b0de815fe2c007956a,
+        0x11e62c7d02773e2a4bf5e2d96b2e2a7ab172514dadece61b41632f613336200c,
+        0x5688b27d4a2435fb45c8d5f3743b0b1cd380ba6ddc95abb6f117aadbdc83736,
+        0x22e95383d9f4bc94e9e2be09ed243d6114041ffc729e7edcc238dd82c7d5ad19,
+        0x1dcf7620094c223d73dae01624272a7706c44ea51c959df302fb6e91e70f2501,
+        0xd686d6407ba6f204fb927b3628ab5becc48de21f3979f6818cf12b76f7a89c1,
+        0x4059e8835ec958751f897986059ac067fecc5eef0911b714170e73c389169fb,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xce22a6f7aa9168150d064857ce6f891c975c3191bbff919474702bf4c8d813,
+        0x194f2018abf3467e78243e36ce971440b9e8aabc83687a0851c048d7eea72729,
+        0x29974bc9d401f128049f4732d6610eb9f269743fa28db231db6ace55216d7764,
+        0x23ad853475090c61403fcef91ea2d8a36afe29741569acb39f2e5333921739d2,
+        0x4efe76826f38d11a7a761748f9622e4210ddc38454bb5329eb9cd5ff5bf4556,
+        0x8a2e45b2884b3bcb463f58ca3a7e4f2e7f16aada17a609bc358e339486ea6f9,
+        0x1c22ab2592802c8f64a76cbf083074d7d72de9bd3f8d993467b00dec27c6e28b,
+        0x180c18b59f0dc43c04da21fa47b4bdff8fcd6d845d886f71855c212307514f7b,
+        0x146346178cae4f0bf5bc9dcdb8e1bfe21a0ff0d80abf33418c72499e70aaa225,
+        0x301de4fecad713260a57d4ecec83a8e4966d1b89797805c4b8f2b6be9561d1df,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x80ff1bccc78688253119861fa90b44fdac2f5d2708a1be1225696d47db0da7a,
+        0x2e8300243648b888b59914509ba219649e3f28cbe190cc3dfebb1c083a7a7fe9,
+        0xcda045c07fc05561a686cfa9e82c9fa0774f17f34450dcfdddc1d15f88b52a3,
+        0x21335dfd5874c230f903aa6249f64cdffaf2b30a19b4f8b9e42e6dc7472f3521,
+        0x2e7bfd8d6d903cd0d2722ee33f82aa80805629516de6d9091afe9a1613183c05,
+        0x443b099429cd33864738e414391c37d032dfc795378e8439afe62eebc49d241,
+        0x215a81cf42f2710c48f96513f2d1ee0d350ae57ff01c96daf3eafbd0b769ae8f,
+        0x156a1611ff9933ccf069fb2156159851c8fd02f7fc27bd5bad61ad00826c72b,
+        0x90d3ac25b80c0f69e9b306380d3cc0418a5de630ffac363ec793a0fc54fcf97,
+        0xf53453418098174e3a6214c9fa8b59792048cc0c963b668feb4b79fdfdfe4d7,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x167dcc32fc7311f7c5df9a1d2955a928fb6a1ce771019241fa491c655c697381,
+        0x2a191b6a2f8f96da4bb2f91cd377b32fc8e84aaa857e976fecb7dc98bf518a03,
+        0xc2fd4887d8b704662b62339aef5380e2cfc1eecfde9a4c9c14abc52c2a0a8c4,
+        0x1e630649bc36af20c735f3e55a10e18fb1192eb537dad2b23932079a5e3e039,
+        0x210302a02dd75f2d3846da16ea7c309911eab034fb60adeb5ba69c1b31b8471a,
+        0x1d9e0ac6e8f8b9bfc77b7439b345b772596f8cd23370855956e42366d42a172d,
+        0x2a6cf61cb3658480617be7daa4072efe4c2063b9777c1fc7748cf00ebb670067,
+        0x2c6d225faad9f6f0959163a42621d26c7c91941196ddac67a618b390bf84b5ef,
+        0x2d2cea26566fae8c2853a5976075b6d73da65b6a7156ab30540aa9db05d9aa29,
+        0x2e13c310c5e84e55bf6453d9cc647f87c90dc2625f366a6dd61f60a0b38ca3dc,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x18f8e2508be0983a6ad4de69cd797d5f3974c5f2e4ed2dab4e67db7b13e9119a,
+        0x122a34cadaaf871dbf14a2626be775882ee4653beeecd92d742541350f929c10,
+        0x1eaa9c56276ed20072675773838cf7f72966a70537bcfc85874821b40bbcb7b6,
+        0x10e0b85cefc5748eec9d7ebab1e9cec57d580b3d66e5b47772b1faa267eb7fd4,
+        0x961d96cc4f121a184a78db78c217fa96c22521ef88e9f454ae88ac934832633,
+        0x2d40eb8157494a91a99a67959fbefa10958f2f96111d46461d3abafdf3f89735,
+        0x21807e2e88a4f906a998c7d9c6a395aab2c1a09b38878f047cd59a2e61f8f85d,
+        0x2e19eaca5d16c8bbb6ef892613aac237eb47b65c64deb2d167904d719edcb77a,
+        0x16714242c7b7e789d41c82a4c9722d57e294d6a566f6a48cdfe79123f8c1d32a,
+        0x5566d38792f0671ce10c1ad7e93534075f422f61928eb6c2e4857e2ef1fa242,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x13290f24b105f48dac27734782f076151f3192c0f432da08f73ee09570c143d6,
+        0x1b4b953ada89454c82b19e887dfccc01784fa68082bba9a561beb496f267eaf8,
+        0x2613eebb5f02fde5560e2f1aaedbe7ac32199983ff9ba2cedda7ad9a6d3855fd,
+        0x1aec57bd5745a26c3c0219ef96fa6c69250bf9b6584e371cab2aa2bdb7ae4990,
+        0x67389e348c3409b4cd299d8bce723984b5f2e95b0be560fc10132d8ef8d3e85,
+        0xb0e06a1e7dc543f9187aba9ddaf2e32d32ca8b8a5da85597e6ee5fda0c9eef6,
+        0xa1fb4cb7fd491382e2cf3347ce4ac8a42342a72afd1a1e64eb0ff970f54d5f9,
+        0x1977003ba614ea8e81991f6f0d79d62feec3b0f15d20d899b87382fc3fb13aa3,
+        0x286e912fa4b01948dd7b1cc0251084aa96017f4fbfcdc6c743feaceb1dea753b,
+        0x23370231ef55f59d8f37515ad3cad730625e79325fb839e1d9e9c2d1630e6ecb,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xb1cf6bfcfeb3cf344f8d1038fdc7b9faf945027ff5bf710d10286df9cbd4ca9,
+        0x123d9a409d14c996b914c9a56c54b02c25f4a33a3ecb6066fec4a77c6525acb3,
+        0x89f21498630a31293ede8725da4179396e31708754f8f26935a9593ab1c207d,
+        0x2f5bfc653853a2d74ee03547dd49092a78177c6bc16eef3d4513709040705202,
+        0xa18b08811ddbe006ac8516b188d76ed6e8abb635697bb576f438b5eb234729d,
+        0x1e0fb18481c8d9535410561b4ced6025654b74d7caac3e4d487143d74155f7e8,
+        0x936106e344c77a4425d0ae924553340214d5264abf959ff5c3de4cc163fac02,
+        0x1abeb831643365e91e7266135607235fce484149cdce1551fa4577791ff62fc,
+        0x22892af37e8064bf4d88322256bb872e0d733c032d1f7beff2bdb749fc0c7d5,
+        0x29b830534e780d7205e38ca2f9ba43ea1f1eaab7d08b6060a9a8e52e1cecdfb6,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2ae98ec328e9150679a246222b5122c2c2e35d2044fec7950832b9774900bcb,
+        0x155494f37217d033e8d586c6852ec501c6dcced5096404877c788f75f09c95e8,
+        0x191c6cdbbacbbdf644b3bc357fabbbb79045e3200f2d10f824dc4761ada0db41,
+        0x2d0f68dc5a731e30aeeb23a76c2d985338f7cf7aa1db7452ab7c05f6b96a1c12,
+        0x8761ae31b00851939ebf81f3201610f53702765e42367d15a5a64e4fc780e75,
+        0x22259606cc46b6876ed844c436ff76ee5dc734754a91bfb977d2ae9f620f738c,
+        0x290031eb3efbfdd567219f6f69b6ea098dc1c7ff13db57bf22c699d9061923e,
+        0x11a164ee321faecfcd283c24baaac523e609ad4dd6f6387206e8083d8ba2d08,
+        0x14a6a424876b86e06f8a891826c3393bf9a9355f0f705d61c39bf65204a488a0,
+        0xe1d8d72bd4c192af2d73279f2b7cc893ca0be9b313f90eeb64a5fb69e7a9771,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2720b31b0b3687a93e8203819f9fe8f41591cc67bba0bd4c050339c327d0a6c9,
+        0x22ea080102094dcc01da97ec17bd1c5ff0e61f1afc3567ba2a4c79127e16e848,
+        0x7a0740ef451bc5150556d1083b5108eba7660ba47f5cef92df76ad0cd53fdd0,
+        0xc191e9d1d2ac3648df5a9fa6a347c9ed3c01a4176091e91f8191417c885b674,
+        0x21a6605ece262ebf5658153119ada85793c68dceeb560782c533e7143c53435c,
+        0x7b585c00d1974dadd86b01acc175939143e66f0dff55a7263b7f70507294f4c,
+        0x30570c2f5807b56cc39cee5e1164c58506d902a348dd400be3f3ba1ea9b918c5,
+        0x2724ae7cb7eaf7d39b6ab671df9d70a260fd1691cff81987460d2c19f200fb9a,
+        0x112877dce9f6f179eab02788c44fc9da3d64b99966a71cedbfc4d5ce1606ee80,
+        0x3006485215c00900e3c42c74ec9c58c6fca0047827f238431e387772a30febcd,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2f2b423c67329cc34adc75ef955e65a6ecf5fecdaddbccc7c69de3a12ae457,
+        0x28020df7c36abcaba69762a94eee88063b5f132efc9bf99a8283d4fa34a7a1d9,
+        0x1c1e47e09591c1ec91b7840a307819d89c19a567d6e3eb2f8fce818bafbde9a6,
+        0x1a84ae16924b521e378f6db619d0a094066209f18492b604c6a8523d9574a4bd,
+        0xf1f1f4fe16f636b8fb7d1aa4cecd1846bb37f73880a09eb9680ef2dc49dce4a,
+        0x2033b19b71951e7d180851c4c0b54cb8e3d1df44ad55e08de3c10555ff434c0b,
+        0x298497dba4b52d50c528b089cf9f51b98c797b5f9f1893df8bd71d6427957ca7,
+        0x7979509bc42b0bd1855c2feeb4890c5a2e5cf6f6cbad87558b11b82e43ebab5,
+        0xc027d8065b422a5d05af6953119cd1451ecdf3b1c2b49048bac9ffa19a29571,
+        0x1cda0318f56da08e42b609732f23a762831ee22bd873a8565a2923adebd88e76,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x109f467daedad2bbc6b984902be029aa07e7241a63ef242966db9c5b584c39d8,
+        0xdf1e1a43181d21009c9873cb22a76337ca84b8196432cee8eec9975c3c1b9cb,
+        0x20e2202c033befa6d32f13f6b4426e40121c40ae7cf8ce57c8271e0d7e5f1315,
+        0x8fbc9206e82a3f139c8b86fd5da23bf86a2f719c6b7b7db42c10c62a0280bfb,
+        0xafcd3b41eef210253ae3d684a1f816f6772b2f253c2ebba5b444b8edc05b775,
+        0x2ad7e0ba8acf03ffb2fd84b30f89033119d3f34236df92d1a985d3a71faf5492,
+        0x235b9840306c9bbda7e11c12ed8805fb2de3127555334e216bff8defdaf3fa5a,
+        0x108abc439242ac2ba789aca0ca17f761aaaaa7f90be1398627dd51a5b5385f50,
+        0x64cfee2a05138648491938218fb9c287038cfa0f29397e83e914f355e0f6efb,
+        0x169b49780138618a4ac7de6e164f1f8a95dce8dbb68be3737bd1d1d17601b583,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x37c1010183f05d3baeb2407c7105539b59355e854ee6ba69ad0ca93ffe304aa,
+        0x7619f4a716dfa87c4180b37779fc156c1380a593cf4686b92f519e35431a0db,
+        0x303a616ca0c021b513b39d551877b764b241e582140cd49c66650ed748742f6,
+        0xe0a3c66b892792aba5936d212c510a929571e260f7ebd7e4d8fda17bbd6e4e,
+        0x2db87865f56b59e6db18e9fa23e4797466341e3114f73d04a77aa96b0608289,
+        0x16b7dd14f376839839b33d74035959e364029cb5ffc4a5197cf2f6654e07f9ce,
+        0x1282d2dc0a5418205d397ca3b788ac90b617ab48777a3d0754f288e105bf0aa1,
+        0x137494fbdd4f68f089812314c259f9d55b6f2ea9a5e01d31df36953bc67a6cd1,
+        0x27939a8ae7cd5b8891f1effa260b4003c5d1f3588ca41b51fa66a15fbef587a8,
+        0x209d342ed11c9c6a95f7beba1d6ae606dbb91d53c7b125329540632856980819,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2374ed44c2bf10061ff872112598b048396433c0e99ee618a978d7b52eead11d,
+        0x5037cf03e8e4060b62671b6b3738c3326b57462d2df714d312dc3cf902e3499,
+        0x1bdc6d72769d56d435d2664fc00867d0818ca90f30791fd9b2b1e397f018879e,
+        0x125626a10725e4febc2526fea8f28eda9fc9facdc3f853bff34df2d870b6760,
+        0x6d4bff3f90a1436f9eb4cff6768bc95d0748105b6bfad3efc469005b74dde6a,
+        0xa7e7d0bd3eabab06af826e769285f473ba07336539872edfe4291e7d10f8863,
+        0x5b7eee126f854c941925eba6d02d796947eab9ebce35b78f94b68068b8e2577,
+        0xc787497b88a8df57e716224abfb8238149ee8cb2b41a30452ac5c8c9ea11bcb,
+        0x12e46e1b82dc0fc451122f0d73c36150bbdac4266091f6f16e887c29e6ab3e66,
+        0x13fd578c074db81ea352cb09285b53d7e8e9979bfab7cdbe954f2ebdb014c9f8,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x9d89ecd0e9e76d53bab1d004dddb96233658cfac386ad366c614e0b270f97d4,
+        0x1663ce3fd8e8a219e95598524d0a14e95ec2eddbeaceb5c91e3325f03b811cd1,
+        0x2d7643a55ef8f191a8385f26b7933068bd8691d8bfacc0298edd54b5da3a81b2,
+        0x10ef304c05d0641004092988202bd102a1b76a155469ebf41804b8556370ca28,
+        0x2058baa454c35fe9ee8b0a8b6c3579e00d8dea44db1f036f286f8c1c5a489e10,
+        0xfe297ae198ed7e6fd6836bcbc60670d9fa40d8196e48cd5e691b04cc7668744,
+        0x1dc4589f1ccbbf2e48394a90cd3cb121c3bc56576398e14b37f117f3588e6156,
+        0x2531aa8925a4e146a2178446d4213afe2b4bf59537090877084e08abb32b46f1,
+        0x2b8d6fb09de987c69fd1423ca5ba68c7e47f24326997ee6ec06b27bb8202fd79,
+        0x2cfa7103a4e60296297b5ceb2d5a59acda5b0f1c33c19c941a05b9c310f25ac7,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x10202be4306b5ec29ef575c5214a35a3ebb8c8e808c572c87ebfa388b13e947b,
+        0x1b5aa16b76926df627ac1ec6f6c12602520e67cb23106c456063e8faa4b902a4,
+        0x19a92337476b5856c088850149772036f311a5ff94f05442f0a15f23c5c4df81,
+        0xbe8fc498e64abe93a3891dd69b068a200b4fff681cd1ac1c8b6c0dec68489b8,
+        0x1a0fc42aa273470caf30582564186291b8d122dc036309656303d48a9c3d5547,
+        0x18db0efcc7f60ca3fcefa9809141bf46c3659de012760d8a1002f771c77971b8,
+        0x1237b3bd8e9218944b33f45ea4c9e7872be40e3d71df354d0b4d22424152274e,
+        0x65c096251bd3ae0ba92367a9db4753b90bac169e7bbe2da1a23ae3402e45d27,
+        0x1dc83ef066fb306e222db36b1b368020ed31d2b1589cb6ec2e84e406213c8e04,
+        0x2c1a8e6e5fbc28d95ac7e784228ac12d2d28be32c4fbbafbf21c6ab0776f449a,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x17ca0461bce08a8a8853a8f49f7e9f52ab8f3d8a7cb8a925d4dfd834a92005c,
+        0x1c90c977e1daec74c1d7e6d3ed14c7d41a17fec6d1440fcb3cfde4945ba43b7f,
+        0x9f6aee2e43570fe682544dcaf6efe50f273784349ee907a7da08cf0a3892a09,
+        0x1a9e810a073d7982a50a4a3ae97e16ef3cb1e231fe0aad228ddeff415e873d34,
+        0x25fadb922987714ac135457abd253469ff387847e625a4f376a21f60c54aacf0,
+        0x11b65d5a4e0393733848b5a18f5ba22c9df6667e9b87075de2dcca2a6322e980,
+        0x22e9e700cc820ac9dc080e94407b9c18adc135535702c34b64005803881d3556,
+        0x160c88605fad7ad65a5b926dc177fa9799c951ae17b067ed62b06679a4cf03f3,
+        0x1dc2851df6d0947e5b3c9385544d31278346d45806328142b6d3b25702bd7510,
+        0x8a42ac9c651c761dac4cd3334d8ff8541ecbba391cba04f21505589f39b4d00,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x289fa0e8ce8df0c60be933c0ab3902f988a6a59adc39dd4d87456c88982edc70,
+        0x1e70c2b91d3d44777fde9b8672508185789aa7af7d0ed1b3e08273c02eb63201,
+        0x26202efdbdd93fbc22b59bb52b001dea2076ff49c1bd9aa0ac0e732406f85362,
+        0x665130b10a00cc5088515f8e16903ba3156fa42285bf0b9d1cb845209425be3,
+        0x20a044a5e1a405e1ad5d751492516684148b3755b1fac705fd6b6eb666fde2a,
+        0x2640e021b9313db742e534158b3737b355779eb05ffbe6257bf3a96ccd0ebefe,
+        0x1937f02a9ea7e1700da7773129f32911d991f2b872def0f10a176054e332ff51,
+        0xb198e0da024b3dab3d6e79f1e1a0304c6055a8ea3f4f93b0ce24c6ede206873,
+        0x2c0a30d51449d8db5f3dfd12c4dae7857a91ee88e297208dc151ccd8be4f0870,
+        0x187c5f8a529149c6250007730a57ba31c7dc0461d40fcc17326702020a21d33e,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2085c1bdf91d64b88fa27cfc4c08e07efa31aedd384d465f558c3d60ffb0565b,
+        0x25af25414fef41bc7e5f3320cb78b1ad4532319473caa7cbad0cebd1a77a91c6,
+        0x1a1b25a6cafd3bd28f97f314456566c05ff153beed81b1db117f20ff97f132cc,
+        0x2d9ab0595a2025fc0cc0850b027cbf4d778dfdb36b3f49fae8029efb2ea63f1f,
+        0x2f30cc9b0e5b85bf04d9c921c26195c7431a50a6fedc28250bad8d5cfdae1d39,
+        0xa37b2a74bd14072efd62cb285eff2901ae78fd90dc17e6fec4676cb04f244ac,
+        0x1c424788fca025dfac66c90118b11c8272d4d68e315879b3bad72b595016b1a6,
+        0x20f5240469332dac40167ee37438a75bd816dcc1fb4cce2ac7fbb77adaba5be2,
+        0x38722e06b9b7d6ba8232eca553b288225456b08a94f8c0722196654430b5221,
+        0x56eec5b756d6945d7f1ec8e5147ca2765ea9bf915399d7110f15bca953cb8c4,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x27f0800ddcac9fa1f1cfab29f40c24fc7d4ca5b1590f2610520e88b510a1ccb4,
+        0x1a6a8f6f7e612f637ab123355dda1d4bead9dff6643c35d5407652a392e70382,
+        0x1b2a744cbf0e7326885b084f907e7756f3212136d607d074486fe4ac707a413e,
+        0x4abaf721c7350f1696a88a898880c58962814c3821b12fef0927677ffead3a,
+        0x2f194b7fb646175f3ec81abfd10bc33c5deb6b4f69955d8e37f90d5619bb1f96,
+        0x1457d0d9729fd924f98a0ab82c379d9e1fa349c99ec5d40866961486f9c9441f,
+        0x24022debb2e2b1ebc444755063ded047216aef7a53efcd357c33bcf18abf7d78,
+        0x2f1a9fa9fa2d06c6afdfb03865806fac1f08d5b64a4a4102dd69b8ffaa16d9f9,
+        0x2a39c8affd2c36951f2d65ce28583cdd27e8d09b3c4682d9a91a8e6da20f018d,
+        0x6cd4a8162b4407a90a632bcc6e13d25a93501cd27df389a7f8240da9d0fb308,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x240bdd87896f169f78702f2fddf10472d1e56b0c8dca668c3be9c5b9fc922f8,
+        0x3cebc8d717886a58a2c2a2bc572e3f58922c19e6a8026dee09a8aaac59d9170,
+        0xf2ac5c2f8ac681e231a623034707fabc5e81b7c766c12db359575e5402982dd,
+        0x2dc50cb75530f53c584f0db1885d6c1fc03009cc8e8f8abc50b5ea096d8cc1f3,
+        0x94c8952fde36c4126f4df8518ec3f831fdd80129f8fa8ff1b87d7739efde02d,
+        0x180e29433d8dc3cbc26a9b063087678e5b7569bd759c2173ad0622557d942c0e,
+        0x137513995f9a52a60cc08ec51aa5efd1f10828587cea9b2a5d016788021bd0e6,
+        0x102c8b90ff6c327d16952ad18bc65d9d6efa7dc421443ff4159e72b02ae2cf2f,
+        0x29f1e94ed28f72023e6584dbc4a4c090c6c5ee310d8b83f0f191ca9a382e83e3,
+        0x1c5292bf3034389addc954d33494f4231ee9adaee58686e630548ff0eca63191,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1430d7953574889945b2851241e066ee9d6b5cd11c106e1fd2093d691a164ea,
+        0x1b3448e3a38b05b85a691e2df172b46c7501f3ca292b5f484dab6286f4a23edb,
+        0xdb96c5859d2163a39d6b3ba31694b603706633accf6529526ed570fe019f001,
+        0x21b598a7b1f1990081af12292ae6d85107d314c05534cc1ed39f7fca3280fd0,
+        0x2110995ecd4f7cae17dbb93117661040a5059bd20650a990dd6781e6e773790e,
+        0x21893b6a2b4a66316b37eb749dff8ca4ee17c8bff8632ee3765f7f8fe572b0c4,
+        0x2ccaf308f912ffd14b46f30d8f8e2d4680b6f3ca217587a4a6c1c1bb840f3683,
+        0x10be28be53fa8a09cda9f67606978013149dd78dbafc39b3e4ec0ff2ec75b2d0,
+        0x17e826d4b7b4a2040fcba809278bede0cd4a79c0b0da81342163270a1422931a,
+        0x9ece717307f52d17f18b7bd204324209c011daf9ef789973e69f9f9e09940ef,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x21c512b8be5a975e58cc3dc195f284a90a921a264c67f8723a5c9fc79c4ee590,
+        0x1a9c325e96a34745f686eec8b268877ba7aa0d44b11f59b4eb11b24ba30ab1f6,
+        0x256c5ed746133373328079945658a21927e576985c8c26c42fb0e27a37aeed5c,
+        0x96dd009241c6a5a268d535f5ea13cb1f313735cd9ffbd97f580477251073fa7,
+        0x1b5697a3492346753e3b41b5f690f4ed6cae7bc246e9050e461154da63b72346,
+        0x212e6acfb305068286ecd6d2bba2ccba4bf952487d7db86840d1bc35d1890834,
+        0x188957819ec0569d19dc54c6a31fac77b75a89c8190ea57720a7fc3f7e6a4917,
+        0x551b30aa085a016401370424d8ec7b729442d95c263ab077ef1f717d805ed6e,
+        0x22883b03ba4694c2602c5e0c148a2d8b142da732f2dae3402732527f1a57fcd1,
+        0x53a4c4b2055a58c5ccb0f23464de37cc9c3af86cd2347d821612c4b017e8e25,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x12ccea9183993e5d7dfc16fdef26d9f845eed10de2fbafe63008e29d3ca8b507,
+        0x582c12381fe92ce0cb41392d98cf0bfc811a96519d717af5ffd45c6ca1679b,
+        0x47527fea0d1a194240f9d9f4c5198bdd620ee5041d2dca5db40375fa6ec11bb,
+        0x9803bd526d49e31dc0fa4188e3069b7ad81f2d6391934de41df4aefced4b086,
+        0x21d3b002266d0893a5e7c1a7bc7ad2f2aedc63bca12b0107670b271010c2c177,
+        0x18f7b09e05bf3b680428a2d2baa51298016ef23bb71ac95152bf75c82ab4cd2,
+        0x18bea4252cbd7815e4bc3bd34b039be2027c226b930eab9cb0714c2ee80139a,
+        0x100f77a4054eb625b22130838ccde66d21c66b6a4bf8c8b10edcd1d48665b7,
+        0x9c8b96501ea765284653b0d464445b012086366ef33d57e3a9e388e740233f6,
+        0x6c9ac27ccf47da2979230b1b6f6704a08a30029752acbf49942c1962ea2f9da,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x68dfe569c59fe117f04ca4d04df9a59ce5c9327ab88894f60a8433cb3bbc7e7,
+        0x29e21c7d1b3fdd04d0f89e3bec6e66c41347183faa487a085bcf1ad2a446319,
+        0x61ac0b5b33b8d667219f7663fd68c937c548d342bc27e5f398b8f12c4fd54f9,
+        0x2e8eaea01526ea362b730fa76697dcab6f0298fd91f0ee145ced504a164bfbc4,
+        0x1bba6639ec598530de2706ca4264f5b42e6ed5374993f5517d407f3a287b2902,
+        0x1da74a23eb1fd7db1b30cd5942ac540c379bc74a3d1e51d5b0bddd2087ed100c,
+        0x2a0e3100447c818717bcadcdd0b7d120224d203c8d9ef48064d7b97f6aabe593,
+        0x27753925a34a26b8a301c8531ba88815a976e1836858e054f90d6561c4373330,
+        0x2370d8627c27ecd31b2b6a93c33ad409a2e785c8798bc444f361d667c59417e9,
+        0x24447e984cae81901b8c1668e8a11d94557b39ddf2aec74ef457701e00d51e6b,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xac0847e3de8e5f007ad7427f2555515e4079bdaf0b0e34b4be5e541f482f33,
+        0xb2c4754b01925272d1ba4359fa02c399bdaba806b32f51c2285e2c16bf3316e,
+        0xd33fb4ca1a013eb65ff09dc85098969747083ddbaf4e0093d86f29ef3948fd7,
+        0xf06aa40d012cd276378c356edd414c02a77abec6bbbe8520d90b8ab96be7304,
+        0x11620ba3b59e9e02401b1023d0e3675c1a26d896908931f88ac8f487cd408d26,
+        0x2d1783e31f3c242476318403db851fb1a6b826651ae10aa2c8c6cee8b71e9bba,
+        0x2c989d933295a819e388cbb736f1dfc008a813b11500d7a5d75c3de45443c7df,
+        0x185d645f3186249ad6b20d2efeb6ae61ea7add22139c06f0fb143d4b36428a6a,
+        0x295390e4301ff52cb4cc265685900719cf785fe42fb3fc7606eea8402d2c3be2,
+        0x2cff591766f8ed033dd1004a216c9545cb1be5c235f59ac0189845a3f0fb623f,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1d2f561702487b43d9f7f6583fb8a342c82f15053b53c2952a7dd2d32491d880,
+        0x1431b6537ec76dc2c30ee7476301e832700ce7f638553e84cd6fce7d6f14d7e8,
+        0x9f68e9512cf4368a0b526aae1af2bfb818655c50e8a87dc157f83d79b409a00,
+        0x2e07015e39f5f8af17cd2d0d04a76917c1b6c30f0b3bb3c35a24d099249b17d,
+        0x22d3936579de1b153c68258f36a157477c7c746fbdc4f9f3d8d0ab07d651c28e,
+        0x1c1511375128ea34b876fdf17a984c28f9f5f551b8f5008a559875d627caee62,
+        0x142882177b08db528d3e30ac62d3325ceceb585c4cc091e5070a79abc3105fea,
+        0x1a168d198284cb1386879a2642bffaba7bb7672c91bcd6c562be03e3ab636179,
+        0x17221d50c79b06811d1d66e63757c063ce62dece8b1359c38932b53e0c199401,
+        0xd1d4e722fc75c3f4931701cd9ac240a172a8e3b638bafba1c99fe987492809a,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x27db073487a124e2eef709dcfbb41a62f07ee32aa952f69af50ac486b6caa7d,
+        0x268c8bbdaaee13720df617507518283e1758788bd916fa548026485c7aa9a0b2,
+        0x1fde18979072c0225095c73dce75c99e7c0ea3164cedac4ee985f4dd029b9e95,
+        0x2531f077c0a77c6ce0ca7024c5b150a41489e06180688904997855777baa84f1,
+        0x294a5bd8cf93bc687c0568c4e29e516d90acddfa5ca2c7df81eb09286583fcb6,
+        0x294e322170c9ff2069704807e64caed0a0e9f31683641a3012e867f5e913559c,
+        0x2b3addd6cb0f23db00d6cd79dc8856992da36e648e3bf0ee0b2715d785d5b4b4,
+        0x3135e79314a76a13df9cbfa22a7eeaaa6a5d2441ec32edbad2396c270eb6003,
+        0x173a562d9eddfaf8ffa687c362e2bdc39da36db4a8557a6dc851055a2c48a2bc,
+        0x612d864c1ff73f7b2d780725cffad529426a6e1aa5936875bd9aa472e7829bc,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x2ba89301ebfc123b4220c6c74488005cb752c72f7487bc8ef630bebbd41bf6d9,
+        0x10fd2909f9f7f2774720ce193a4c009bc92bab7f27f959a57842b3cb2f10e622,
+        0x249c1b33cde3144fb9b9bdf30e45544cb98bb9304efacf2adbf1271d59bc00eb,
+        0x75727d6b84d8e427bb742cea7e88009c286e83bd66e1d6951dd7929dcbe3621,
+        0x1bddd7e537992438f10091b25a5225fb06132dec4ded9cbfeeb451a034acc670,
+        0x7ef5e8e55faf5d9129f012479e12e08834b5e1a38ed28aea583e7ca6ebba680,
+        0x14b714178fc8031d847db2e05553dded47111455674598347dce1ce8b8ce4e5f,
+        0x119e1cb2a7e4cc688569e9b87952d4b229be2265a58ed6e619aaa93f30c38f0c,
+        0x21575c98afb0fd8dc75ce88a04201c36aec620f733d6ce71bddd6c4dae189c0b,
+        0x2e69188594acabdea88e257c19b0aabfc728d191a931d7a5f4e7ed8370c24fc4,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xd30b0f7b463491b93ef9a20562faf35b4eee1b0dcaaf84964b850c3fa9f52,
+        0x104f6ec28eac4f771576a7ec410980b2fdc63c39d1b90c3f0e721847209e2025,
+        0x201753ba0a0a888b66ec516584f333b4cd1f57c164b75da22519a89811dcf077,
+        0x16fc76f1f5f7644de6bc79cc484e010dd1da3d0631ef42714cf5dd21f59ebff2,
+        0x10892fc5eec5ed00fc6d5d0975221d3d870685367f211ca576706cfb083b49f7,
+        0x1c59c9b6844de29584ac93a73022b6761b196e0041e3fa32f548373a84307ad8,
+        0x188a3064c72ee6e3b555ce35313f73c91a154bdb59e57fdbc95d286df429fb64,
+        0x25a747a9139698f6b090741ac55c98ba3e55c845dc8af25ad83d6e48c945e249,
+        0x19cf0ef78c77006fa9f4849ccfcc2c52dd326a646a5789cd25f79ed84f5ccc09,
+        0x1145187227de632d3deb1d625a4e5fe3886f5103ae46615a8f07e6035f65397b,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x12606f5141cbc1b9a349a9121e54295d17ff69f2f9027bacdb0ebc8a6dd2d0a7,
+        0x2d1ec807263d78373ca6b3aa8f4c51ae94487ae04cb9f5fa6cb7a6155d44cfe0,
+        0x2b83ffd72f83ccd4c18dd16bd1d406aee308fd475bf706f00cc287d9dcd97283,
+        0x2378c35a0428264b3afafa0b782312463b724a4d281a0b56ba6036abb9d84c46,
+        0xddba7feea2855679ecfe13432b420858ab5d93bc835c9a0ad59b8c011fc058a,
+        0x60a0091b5a50a516e31bb6ae3023d902a23e57efdb4c571c143ad6321304673,
+        0xd08421d815f9281094977237c6aa7e6243ab5cd76e38d9df19dd2b4a62211d0,
+        0x165a3eeb547af156b4be28850c24586c0733767364429a0a1b7dcd2e7f99822f,
+        0x2367643242f32a40574489345294604135469a362e8f6f8717c381dbef5d40e2,
+        0x303a0941f18aa3166611976111e43a94d92f51f6fbdaa07557b47b4680a21af4,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1aecf5def09ba5be2ccd968996c5564145f38f60aab4191978db8089fdb31cdd,
+        0x304ebc6fb5252ad8b42ca58356799e8c6961ac84708f8b465227103259913243,
+        0x26ab128903aa48b65d12869a85697da4dd7dbbab09aed508b833a398855eaa29,
+        0x245567a4087a5582bb36dd3803f7008596ac2514a1d7380d66ede29e27823942,
+        0x46585da7e8d6c6cf0ff92b5e3394bc0499808442cde328d13646b44a69cadaa,
+        0x12be98bc0a25716e254570afde08db45e96e159a86d7d1c685e1eb2a45a4b3ee,
+        0x1853379c16580675d773c80841b8b6e7db0e8a2b97637204619472145e3ca760,
+        0x138cc77819364fd983a34eb109c53295de653f1d905fd2de7b6f80814fe8cc0b,
+        0x2db2fee2d496891332218a6eb709848a819f62b8725482c591bceeabc1e3fd43,
+        0x22e95c3ae4db1cfe5e4cfb697815697cd9c34211c65111b8fe850ed25958057d,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x14f0f0699aa9bd8326bbec5ddd0bccbe3a7caeab685d9ce7883e517164bd5994,
+        0x1815774675d576817db84840bb9fa16b713472d72f4bc24c2cebc09aef0c203,
+        0x2a82117a43030418e52b708eb696ab01c9ab04396eb53a3ea4194b9a19824238,
+        0x1f02d515206f3d9a3c2086b2d7c6b19004cc8553a77908d534ad0af83a637097,
+        0x3dd5240ce1c5530fda4993dae13bc07bee4c7994c1f65f263a2b8a2f7bc9db,
+        0xc414ca1ed2f718060876a21de201d87b76f6fa224faf2775ec99cc13c534117,
+        0xab48043b18014d78845ac07a6b9727cfe0b283b44404e20c5da462aaa24f7cd,
+        0x3fac53034fc748ce7cf966aa1f6bf15445cb4f6f3a4a929cb27ede7928667cf,
+        0x1f91737266e97b633fc63e5b0e1ca82b486680cf677b132ab7a6b4ac75f70482,
+        0x2556e1170d24d8da980464376850938b361e16999f2f628e1281f5d6ab0b13f8,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xd258cad10974250f6da3a9e068f6830d7c65f1253ae250324bfb72b50ee94e8,
+        0x15e2bde6eee969fbbb22dde530a8e6117fd640972712b644ebe5b4bf0841fc90,
+        0x231dd2a58fc24a20243b93b6ed5cf8b88b7a94a4137961852fb85a207b6e849a,
+        0x4fcf48ba86493a6ed7afdbbd1b74fa91b715a0cab2e1cb27d416d1cfd220258,
+        0x27313c2f8d4e5dd6764d672e1a6f951d50083e4e404b9c1cd22334e7eed12f4,
+        0x1e8cc36fca79a1a3319d34db2305478ce58717e36f9710873528b16d4f0c1a22,
+        0x266e3f3550eeee1d1e2931ff3be33ed142df41311f650e0704d1a333b0bfff52,
+        0x88acc576b7bb1fd00b8e1783f7a48b72b48a529e130fb6f2f6550f41c67ae65,
+        0x145537172cb306df020f911d46eeec82af8134b982f00dcad839c3c10073b1f1,
+        0x897eada2a51e4cc2e55be2bab91c68a0d1378aaa4a65bd985e22cc675fae8d5,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x1fede8462b07d0a305d02035683cf29be572a53ecfebc28c77d17ff531a0e873,
+        0x64cddb26305c79f75302ceef162391813ffb575b21526a2a99d4d05fdd904bc,
+        0x41688ddfe25e6f627d365fc18d74efe41659d9213f25808c81da4168f465efb,
+        0x263065cabd50395ef40943af93df5370ad2f6d17bb6de59b3e8e7115ec56b82,
+        0x1becfb943b8985991a66c0758322e4c3f22632c199c1737f83a7dc251164a730,
+        0xe01451b1ef92c997edac826766a61525bc9a345dcd66955f9ff9911b653e737,
+        0xb9f01062d426904168cf7092d57e2c86f6660111475f9978f6b0608ad2f2278,
+        0x2f9dc8eb38534652d3eea5e1b8de7f088c3ea8f9015ae1347004c3122256efda,
+        0x2d97e9440f1fca57f227bf0769729d3dba7fe6cff7fbddcebe492e1b1fa1557c,
+        0x1b0553d2ee91c3a63730d686ff1a53a0478682a7363ddd4e7ece42ba0fe0cb2e,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0xe83184ff6e43582fabb4d62c346c957a365358123861b4061670720703577a7,
+        0xce4cb25f594fd996c28d4578a4a8e3b0581299a6f165882fbd1ddb2d85b2ddc,
+        0x585f5827997ef8691078d8ab635cf133358212340599c51e1bfa20c93226056,
+        0x29bba7e4c28316d70bafc5d05ba5a97bd5451a127ed75d9ef2136a02fb0e75f8,
+        0x5e8ce714d85ecab7027dc4ad12c3a5e75a211e771db239df7b3f661658d4d08,
+        0x1d243f2bab7712f5d12fcc7e4239b39bc533ba6d7e1fe98779a5ced87dcf0f64,
+        0x19207f2711d65bd5cc7d1f5afc770d74efbadf057865e27efe6e61db2a83f1ed,
+        0x54538bfb0b84e707e000ec579bfb8d796106da1a5e4abfa8a273141d6f6ed,
+        0xcbab8595eee6b93df0d9f2545d61416af5ae2dc55a4f332653af8ce11fb42d0,
+        0x1dc6ca4abd54f254c1f401b871501e022c4200688e661613926a63ce19f78945,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x164b183c9251e3f103a08c44ff9bdfdee4a7f8b860850fc3b0ddac111be2c24b,
+        0x80435e71f368774466eb276b7cfa5f9a7a4b90aa4c34e1984fc4998816a9fd3,
+        0x24a82532902cf98917319ef392e49cbd1c7906ebc78d24a4677e1014ceb98c83,
+        0x9f961322ffb0b5ce846054c4c6dc75852776dc8dfa0c2f8b66229b3fb62fce7,
+        0xb9af076f893d939a48902f2107976e8a8875aa5369806e57e8c1f6fc1f5527,
+        0x6c40239edae3e7600dfd00e6cfe939db8a69799a826ab5e91f035e971232cd9,
+        0x24701c675052c925f2baf10f661d4f719bf145893362632605adcfbdf5acaab2,
+        0x11000d892cb37fbeb8e415c01e1cfc25cb3a25d287aeb67b247d0efce56c3c29,
+        0x2caaccd757a3146300021050345effd1a9e5b64182e1cbb67653997b0e391086,
+        0x10d9b51b3a086b412b1cdca5ce171ada65395036badcc79ef33f84aafe908bfe,
+        0x124666f80561ed5916f2f070b1bd248c6d53f44d273d956a0c87b917692a4d18,
+        0x147c39dddaed8630bf1b92249600016fdddc5e9f5f08291ca1663358a41d3dde,
+        0x2d25d39661406faf935d340fb1535be9086598121d96d85f84cb586880517fc1,
+        0x1a2643c9cc6f7e74f27ecdc2e30158b4a6510773a5aedf52fe9fef5a2261c263,
+        0x2d5d7010ca67e74c9a4d54c50188de26c802a2e02080d6d352fd3d5b5682c83a,
+        0x3060121bf7682a4f51292933031818468d050b84c2809ae816f14340a635bc10,
+        0xa514a5c227f4cec95dfa029e8dd124c34895aa46bb27c0911f3780d5015540a,
+        0x278bb49a7b4e44aea46eb0f882cb692801a6e60fdd5b5c23c63cd65ccce4fe0a,
+        0xc399e9f67aa40707a203feefb0b958bbdadcec5ca34901d253d026a2419f6a2,
+        0x1d6b3d5f6ea369c26f825d2362933eaa31ea35ec0a77c1fbd9e01ca1523e4432,
+        0x24be510095436206dd0abd0b0cbb95c883ab304aa52598b1a69306ec981a688d
+    ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_7_config() -> PoseidonConfig<497, 49> {
+pub fn x5_7_config() -> PoseidonConfig<7, 119, 819> {
     config(
         7,
         8,
         63,
         alpha(),
-        [15193892625865514930501893609026366493846449603945567488151250645948827690215,8655680243784803430516500496316192098841666200175185895457692057709359214457,11710807066713707084726423334946631888369490193496350458331067367713412617049,15442364818086019103203999366702499670382575019009657513015496640703659810202,1358747428976145481402682338881091555771254635226375581638965497131373838774,15658002471767984962034589730824699545808755102240624650914676102923421241582,6420480504329990097173256112095253518339231893829818344055438052479612135029,15457172495394305353698644252424643614748461590123908880271021612601244389162,5745943350537490600340174787616110056830333091917248931684290284533019091654,3877253492903478989342845512796806320713689655633086736499730391667425329322,11257677301507982757739320943403112189613848490812422490591766717141506751601,16906586852467953445509312290627525856126394969718997799028223470195783329296,15263589725854108297280528692120758129000336125328939290924952731952242586386,21735940039489460025710098364749096267519151075908323637361429746399161905338,20023056608360522105358681147781839024069418874082333862551226466128829664291,5677500725280079960679484373333947430817198394184436922575072427342643665917,3080516739494460477657748111767941482024045797587058388950619118994388252853,21486496065617100719537932626843898998311175055335457507845650282870586541596,5371049178920102602305531530023787518286335086323221270202212974241707302466,3074817222296007572297581554183445947239252698770067839721345984255386069425,19180807038569629573914331337874446591506172622522351734982093457681161813141,16937785199372956273358037645552299688842385008757508130180245705952406225194,1688218397616770248184651775433764527272029131542529408516364801909017591719,16315958669815317541884966612581197291281164499674338063931623110684590850347,6218230753007070123505625054833158632732536069700963073464625252554943737669,17774528060285257656595928889288330429565059134928074258373583886985960212139,16197131592052727313460949906369199026477758140133103701908949020106767192893,13418604038232148873269488320329340508522225417123160144993642839875173062296,7265658443160253752317166706266927598319661172006072732797351716897681315157,17200150079219747370109251547638276280610591698078334228421747259741754887,8627121890622175767416692555014275717515106888840919734160364408960047296494,14546964505431549758350267964924534495477687922558528647552728692912697049247,17132720822762740343718421124251772119916072270451579802112353604446214831761,234333065870376500756753915306346778417056884715946003873280290982247600083,18375643491701271245209094287106352436174133929245169725584150600992143374298,5158448692161567615645197008737390561357077078129599243188536485308363800282,614161645152783610732075198073600394068518413590650990586931263981193439341,12661793104597977909223565537293318966803153852970198322604479648383643541371,13041905650419760925682179803296711066088286278603171065755078690359168540579,15006023590144168506070897325649191051975999212058008674224953860265667513015,4983349941266961584317889823965291023669365981564144622292227613558024302012,482274340065333833495445682213681402212945945150526736364263233985449810602,3966893131006556898236790392613869798057510088913626163333804949895810673044,20923301526284527685000591080290190641416245135554916208054502046381491809443,20838692384005825835959734210506718428443540957544929066941550833051093000166,8282357714606447781782716442854085217089572080066047419459610560432999443766,5410651444876169088887579490283094453001167796545260026969919887357676973543,15276966646285075387317940436655285872037988805762800567413073418506412856419,15066911464727337689573664613158712498015597773345106524271610486257089622849,14583790985054968382519116885383608902981814292128186470697458065499359610203,12059090796146479535492139954279038037217093044815277624197659219529427760034,7273811886044732271171500579064359282424476926867187108258957006777685922641,1463086899665237074608503061872751147444637332808872866814340325832200880984,4403177494620214359779479537027014449448686844655371530169401219256448130398,10860968418848589590932601250051274256181778387706764281989724391784015147562,5268786978207139542368199165627108325282167169564314266747401266496556301775,10683355823176907476704511935094343405052640940909677712096702771871787224727,12998090263935761477316698114799901126086030852595294916463464609721875730852,21401280461419124637791689956622923839426783908187419462727763377498739154778,9827224472048063173905906705579289843819400982583185823840008976971109664519,6215804144039763858354471461864183189301201862376216122255322421321775987311,15461308489200344015891625455653488930440613755785081602434124530381300882814,19336334695450889400681207491394600659946256404722006637851709906131899294790,1712331165786355540802697725399423752392267480553199895882357858951999960061,18153038525983970702748717571053178456148003321236490384959117581005013333018,1080183517033034908031748897211289245459330899463186432840251241943892326023,8948022108193679628295152361559653763100984324221629445749311939820327674857,9553342289560502306921915013446606435600388298465288181461633559299564421155,12714965617376828547637017050548818007690047452402682720666099310241001848988,10945704657865102635748104464461970844653553427083981539165832149959193156197,17511714411688352203059545713591160825310809755917403629838415797949261359373,9253691969419856285051096287845246422848295397226841130282244592511676512433,12218945350859454581754463621617733341764245716874083264842931063272433793037,15268139709971695434346690496076067658968455677120655340969837725391575270485,7948825129295102283421620705853168119104356217418364837218892682579042520651,6887299291348589691868712194070626390224806410428583073294593431810559288717,3610235157455454109573625364057240708256027358184031380521552355839155549623,16532488069063334064099666525339953823111673083177894678898823509406678724969,19317517725107761280217103201908049748015068578935276576200982249386084367574,14980901224290526859762385599553818204548992110637275324411078408232697158492,7741797285700915051013289492475875831764653137095445146268474269974647962596,11964233864746181868467810392101989052496076326472717372132104394243614334823,12746657111181947224582102380049766839578185276220682311596480990298620200286,6408726946032901840418309506578019708113712492100046332894630652186614300568,20959261828945984489015610988397031913577918654575078054490013338416801523934,3173674599420546165852740604987014294355430358334465189504551707066179193914,16110281513253204315524614633789708146700074483476149119440509845258215816735,17135377580103690088853370572199271964414896742342749305424508776150797285064,1405769920008485935711505753346340073052795087429311991287498566024570212365,19088073362945853867763169651582894739272002359692597239222895238839593467749,19897231284455588615416169252449008151349728648961637517447194842672488184146,20476415629812014715153863754869742189693986277342067785614833846523246536739,11074321446706734150375041020583051611133090415774365192315805856051215270782,15231367549323128694183572409135806408519505225209496441892541205465727777072,10515952069292929457050921929301902464262874744159361114100398880194109971971,3216370118771824418364829250073852356774095079734089790620447714552849459645,1940445924652458480775282556203659335417827058983719042726494187979000691704,7899310668555694144370607061960060230071621529123669746309839400642332452086,3125410912833939638823760577011271607678545358020637189655641109813198731542,2980079409624774815878860133121670095839651294537928173829312563570356348730,3766498515736372882285796238406751547889526137955288498682767455795237989580,21751217522789414135074956130080241003845828660310903627224390345319859795839,4947229586642010378772262640583556676497656670779800090478805824039760706318,2168676839236948809859825591626629233985269801981092020040909992251312517552,21172906642114648036685108008020762271569381607092920279879047961076646303327,882675742500939602754673078407141697482716600335919344527751158504426951699,20942968937722199705624825492102184647835614761458159157410261242387423597787,21880640497503102067412608072166388563991106464538369680846671301780353850077,17593472026567804917122179982860735087124786197105685847979050530954084564297,4492875530722152383516030266828166766820778742874238188105265500984280376666,6799763500412433367637987497601148507907071065930142757525839585946238894092,7812331664758167657763399273963290017340604299019483750344476103319142702775,2222332747647756867926707541092465789402467819000336747029352557749400316077,20438798382149666667185974604464532451975024544676922060351031604444896151494,16155157103796724378615022758633778903205872772589663310774455593497441785913,20281325298063880945091623185126257485818350714264176365501683813650871716911,4922178080989486450454493110764936742315495846015561426329316977670113220071,19579063976700768282784922967523980346960151903154507737857728349662090787824,2458828873355000645851832396764221987760639423132968569631493912353159373462,21166618206785010755521994106737991950548963896649678270059527421944129497211,9131643699583013708059191290958290089892787165715294157378879201986981390031,1820371114511473946932363841206094088983972935646887524223011276305844153307,7264184404232663540867032945940974372967974872966180860960243405462016972362,11228656105550475045610757902396386402555430893045183008968975441800824215261,7151503559113638565935009743218857812859208253653498318591469659718664783964,16876040581364499037941813142092448836399042253618385783944016186340703846779,10334125383426918152464737478646460879481305348617711177774418125714273980769,18900559046103390399749767994653107625464807708680067464279674225251110804100,18685667289312169245526749652972366835289568864080726348092618145885982989561,19970582871354083670567197978171723431124602481748785146813441774826500485907,15873472427137024971035326229485784626398898771525077832924901475242073457867,9090803292122260583635467396769157643561973206888822931647063181944243467413,10156295009710074552070572489422360071526675259143523597882131082376797944708,18600630374968456966046654667577076758720435487386724419578803020365834014000,21292291483064245088298314957584631356250347533568992016547598449487977536460,2784266893057214755054197979675795184619614089277590464548240934105557638370,21206743389683892419024645604723431382001453245850423743581664552645211926469,7915761821775326316473924816837591351530533394717381318596295803119061411675,21881095237485064870468603451853549262304643738646051878343976465227744077912,2011784725603622472271597952122938645154942022107573948889667939904597454410,21059869383015715705096974077910228193608826877524913363323189378554601804559,13660545486380051482020817701263881806531607595506890631732662177505270213284,10831091042775967380899180760062457635694790868286967266013231823406639854653,149288128407476550494800886735600251983375852319258454101603889073198917321,4032475033542195421623899365282946172767274020529645277615759958662043553317,17860535012887415629230166789742533149365132198763199254812432302158542514395,611194463774512114860065022851497908950074400927073001695280142990812150583,5518364261187313845085346561539515049557757056751872639492957432879259341390,783263978868449790737487156609432867806742277074765259237378374864740012575,19059339826992310300213673274315612374137067865428300882729551175173242291657,3179709304184015397125565132235783368222831063701934511986753856772139349894,10954198701843076039176000728742415722273043852061382139560487789741501275316,16411266672500930935370066093245284646483148609897099268661795671514664627451,14614816948231085620934132277599546641612327229810158468490195811014141518325,2458257206135880430320027516329707989817636936777744813891328347210486074414,13549483340434455515002570470395006683062583844603627042649952800864870013910,14465927800403373425828183741641078057513049263889255157342086762479739044711,4039391352709218793104596256671892882216573882631238721514928981154171136548,12750457082077152291009387792121930725761848879916565703854704756389714536037,20703941646953337308096638741387402857948436803334980867971163138332859477843,20148755487317949638981041809982361196106823990400472213765926589941031736503,19035096428824471222963574043396024781574056587456391309795571372815435282399,13597108420431213178364236660710194375344287228654817880431599113069659963625,16737817219786305757887002253067607822378794077688837656791543060369162185533,5164935079689729145670846016031605160169301936105766707946436049006171651941,21653381930704765824477248798502813954284378782353810890869232482999795586793,2062605478140760101860087118379474541965619844748678233207247884294051836812,6841505950265078437298089354417829781031272459823272323626556598403583002674,18723551101558427097952125661588457059960574026361073828482106612260297969553,7898804490983679270754258611113569895515918945891808074921872907759024464249,10882278698112390755842292529204069263813359338030917602809789513528936860051,19447560013395173052961224723195565400117958329259001072560983848146677205053,6251288025262210726686494480483550276704856797649458538460443509657307219922,13176666617050786358406074057104742181338809005466316548399895981897535342946,20703225796049910173111490454489910459787604528779911406172217267261190895618,20336720518722954780604743873837334696992422089627753769439653667292899832714,21420427865372074512365684526694872695798980614525900481233709853915806389425,2498895690812694987926199054702295457557454143930759961192198950277119149872,18753512301709603592612141197073246313430368834576850495154922324845448997662,13229612292359498096055458608547157785066962647476451239567069089111704445000,2690879919643532184588441383789963956137193400890598777054187145581183393168,14142396602342548413722428497204107502988046500369932366351553161157672540408,20448725195660080278132534867269279218381543910636641344871383714386318629041,2559459540570011016181396098001618067535109329950570139376049832813577592045,2209294835847631004298393339896770055851570184195462947318472391473531519454,14610669112573509857774678749257346364319969641690596877040685661582231189775,15281088465087253563674405311018738676067395725444151577815750152538449780965,8600553033773805414817363397077178137667131851961144771667772828459236208319,2748346039979601666392027583251905158817539034260921486084376270967628661657,6854960712378511006304629447898292218014632388505703802374806527561178043857,20207552563190343462280438839438087615024485494479390954719687107061991587248,10281541252271366635718295778088948309847900730867531177275273130071062184625,18855605847424121529776135453072696981767402526737712879984848146282568841809,4160214035780913418097601322951078913381556877408879904436917334405689553255,2122867135885631508183413043949777333811557914428796322029495785048111325437,18793959580906171893053069386015945646795465354959679615181136313144978078417,1043591673717355695648236328597936528752358227297053230241551190351813693314,15686469257015275311444450012704351019335987785561570672026138336552980987277,14048856209379833670666148034655599475317994357805584661156301746235313941815,1011563953969880478397969933799483261900428580241502003261587014788238280391,19240556623066672446907714818724971233422104071815927265423017590508305430997,2121904286573815063480388650799381683473766736407678915747169455786741101182,6724437969134367395210139771738563153857495313330774537559578422672993498270,20206855573383441961836932177838081339503382415601366823182724056749038447809,3659051978213562322887447057085386386485486575515693147713900345497451171308,21246119528547168535908718411570119652856799993958321864163737649108920924448,10446114322905404392321651684574668727564081327779662579984472408056125404335,10052242287865403393859620372179811039720807230902452334457123873762222543944,6373462744579965543231173757071025010089494620309953425653057223643612177083,11716070974813426833631730493593924834405915845847679294742728105127112594434,6451284530793440411577197006976867289209413848762574411101073727224316913966,20143217291446069633369261481904349401356557325260758866598205109039367201468,7741896897172494958877302103827661518814930985518070029789560123401964418102,7414486245715284930410091802521351113719159777210731898112598211035848096490,6480506916211642204624111742530825907262535747743645014149694168805302825019,18349725066341807634895742572304899830893334427067633858521634672944685466440,1838291082333887710851505844271184097051704051003105078056248035350245616867,19201915197596065583046168024521824662441686729039260890206806469763190071269,11253788423541320580105520117231178489492440242200599071301755928628199128159,6048832714406694444296771635481934823208451249770515560893368035838759154821,6398008918881249487422929614611145638894557821587972164243877575640548705346,7013037564266297435879776776659289982125632651326438965546874242685502904730,5942504790082366811245813670914617310604940200824079289270465669331434165301,14344789199380317440464969138686896230070901882253997360605407637865754361287,19920212380356573378521292048728904573841049083972983190424200459025557666792,8983390577894750782268266038315113359711163721228398686939390484499979421166,14953991148867572055684497824790735528852361750007063016470842397064705671772,5592033578501586280289038012647352732276003389059749788953239057845882297561,14076883072716069263619564306953450824526010844333044566762059693672378725675,11108270411921226463443318601950168860230077781212396032908932369105145901793,3681277588815101350213324449908372578846563884174807724121308021640034446476,7194753190480156904207319938161903897566477363779122267985209483435838216959,21241255448366937244332942306324590869759761073985963892514045368815880517382,6203071960722514588958553813186803009742459823360660333787981951206442471249,19041823565851118046937769551785013706136778514067168239416647071096062639366,4928136619692555022185087228378238193895894009623071873887735418398682287593,16266329364886004534411977872528706660422476743809029518681886596981922182359,8814684891729998059175829142248330760704444206534875755023421115211106199303,11072277000652722690981202459933101924925520292174200155471966778637063588914,15889576313969861857250394875354819627977602318110620311480656842740292435237,6934515229262494305594741689326968268143898236690173897991110238064230886755,16212991575388366798683594066983659236103186124339324856776288894513503543244,21100508914867482363389012032457112622475533432309937238082785660233880354422,10381104469089401657446748653199843213201270332853172509558263968565255702795,8849389605935865968361613766905708889092097013638425059146677490704442276611,4826404934194100291623537890117339503344940312401101713754206109744511979962,9981819567268652304810465083896863711149056310505889216307212434682251812603,16218484218588441290424553684558267080330286201433140852298971691458926313766,21317661296916247018967238829275056855142711494630067664736600708605437812892,19523923008662567951910986132173659591346561824926093935331274289896011695634,21439241836891927940168832009944210084078628922824257988298290967895179737163,3818036890597976956138669961319975835941979944306305168232209375279960168960,10212547715001519604442389033695156945619060410131175896383181616280631586732,956283172524544133830416114111944076629240232397666924807554743752464221045,8545109273807246425343308224167362024331960554428088718932211551700420545275,5647769597708100114837534314408246331518385631750569421373379085922684908872,21776221280695269311212391423788179027868152904973644113087833004348746215729,15989020831232836203074762591626149244364214836699154611339161287030952623233,9384665943619921791886218744024370375464874104981653298499433530463000935024,15469006121097295841026542766455781293432005131673839148320165243166330403027,16103671377537767724271717097892044266704736999841135349844319906338275108222,842367229428650719054831004741080336526228967970570607897528985803108607790,8752325400224955775788313769797750158375262384121380328719514077259567119347,4803861091350023344885030428100876947830986453029412601567992550504530969575,7917553047944370948250445233027936387189889293110390303835890604428798853681,16378323148632546424902611135263436821435778030958161546757828745002247975096,19873719885630097137106352132870659633926425645300622070145979694717581586592,20324790419158243246762098227260178678767896786893299456278167341205663612964,4358908354524026935988729716331497263147669784003421920394531784876541301801,14403952632095852077754539203207047943619815438482171213105824864831554185165,16410713482142323347391147127545553384558868490870150984280601225023662513809,7304216341846662695189617252648753140769311862815448449926830269690397729157,16792943782280077475956215580025612636120139194657275471595325031090407485768,18494329391227402645175320826355306995912366111176422593669423022411884295357,3277597348237827068690736756050060740435013727549848360800059544123155276133,9396765756719511114743964794180256605700037182617127755220919249774110852382,5637053961584389263881381098869862042993858662768294676971865632259649027245,1752142832257643043564515360000718468888861086573246457619082905919623770956,14504506574384680785750882507533398260948836347427103366421836731538357314790,18947994518078004413210940685748534988014581551965984303066903086446389273117,8931855168578615387850254663107425567403115805663142600825724478150698936342,10982092525200624040399870568387498905840578524691489797530932831401946309626,4738907023206802373255186532236849256768509848242049657234258536668430260775,10888145285628319545262252531874405309329869513560101920454793431198094714989,4767721624212785367044047554655794533816937807005608600525762243335180089923,4054394679973840378112083329204220302222586590732553688297938891619998137578,15390471663419625573793381445844013245022413344196724396864223784781333233143,690498740448849288977645176879593806019080276382495160049117613302192708860,3326968907274045758110436838010900592335267522219473049427145975873344598768,19461545874830130561487975864151403334363998126023624462211037468138940028328,2255249425919459031033123095731665691066980364231819200773725596456576056043,17139538647342063569964264947811360956712827863014723985947727876623459280539,262834317961189780923232082352297808796511874872711860311746704570027370416,17784213646586812350819691264737755884800773322574478474130308351003659945289,9206479615073686723914227166450906925650471865894639492301222855979337534393,5955379232184076713510750681781395826148323482009739159408415185190732125682,16345512244217240951729073298135981012471478596479891072149124888060645303490,20053701095030547796310908765544502773063879272854547881438596069907281565287,11519146559536679602608982593432194283609736022486509747046459824035493513614,10868663839942247532249591973192159672852196011910414460124452013501564199585,12668355291693420029179738224611760713369106517542315102687346083105601320689,4091011252347209563858280520339886760216002486858313383741839652119084430270,11416347683590132388448480763970462739172261435271326798646502987745949753371,4462763980178675172541782335457125059884067698347130082276003539434128058577,21728891122467658477520865529973242372850367356840114983386033432316519759391,9556106604731806817435679463077765288658189491612307664294729425381901530224,5086982973132652080709554654284904229374030594786774699435814748257879554118,2278505454992311041650060186856758463754878439802195559533882189615578260695,16123495070352975934848591912315341924608875638550779884194576881433498909405,13177225503435100563531015597038445430211235761527278782674200718068329833622,11626932451843299545922103072142674578946680165802341368625957942237790110177,8872973246419344365802198448930136062421718851114220299577394844231810068090,11920016786052130191738519934437207519332291620474831138559948859328822621221,2773753221970604083383541092979093729869734021029185810064937974430862835870,1194583082499114147792330367943150006952486615245506995832323057119894886077,15293312601348482070373672684782686300692505365845870624263228679370968807837,2292156760291800990693425534213440357167359161992251338587906324724034592198,20920049766730284147153707151387304988393631464951398563908410768221002588086,3587899345078220957148828249287269521408604837648269936718299413697642586126,5857527906708110948691023855516662527925762284342493618496858248142623857037,18312267494676788897591109008609888960798722042916784593521762607767538629817,18354455618287562133438807735729369657256664914390381320892039403006410339493,18594037435499535688023807489676900345345731643180370940972090155512943637000,6361231157299815359812386352981667048590510979947935475914610076041390336883,6503045850716008738909204934356093641022474278658078426701342798380459107813,15826908470360778431798326530563200301151807861414464213699967513881040969457,913167165738148713876672473302437265273760468892350716109373788573860454641,5163418960719047707254162004625467116036830361107107814320243058319914687515,1852750695670141634014249062360862036043602867770163972096325792863710036947,16164029969996795952250343426848596535809001568622155377829217918121790073916,42291476149937488089591434144089904529405222471677684973768504172369443350,1329340386229357940610579826659090359930768580941108555938139535621252899508,14087936453397725507000489457270864434699508074557952952329368237400407748133,11454917885298514922755456675259734718428103879515668717779418480236210705323,17749966508430836878443008025013283275306943216523661550528505419303121693213,16617298839486771009961431205770630163409905047728421465641369616889696635464,5622873871440608391107520706189063847917690892897751818294742462879871297589,13537715561706278379083684257583804567523085149672090320983273122424669242274,12609629910090871112615676094781247031353826207267723991911250780907380059468,11881347692420971451998583525696964339513193164613288356598017302547676912004,3620434358220496198439193226313617496907852030586214671337652678218740406153,16586456872124455799862826347901525401871594428044067424833235946565396779382,19602593015746956165116919928045364895525104709835703557292833702385934632182,2465427491077301663150648330772125184470808854603184374760649420983178107738,12521323976712195518272978277895155774288446093713549157148428964880747896725,361951232333654306694462853852464888974834703718677826403016226307188397185,20048343816024297162848487251896481827914904696805156112188099141327595641104,997638030405613623344188782838773314122493364653596616029491564227193697621,10932007654988104622042938184134556963651043067553327861790671211490960094259,47171599193060570819891696279547021610376047998583333086685382152080932821,14669115378939104862697280661831896914139331878760241858539421915983017116504,17868874372855679948405169936193924176514630305572838555185339642210810710203,10178296575837129106771098084407669500326673901243393867574658658064222502028,11497182727976130924559852428316615034304736115488257034951588831868596612725,18847036158089242140209840241495282890278502700082131513222116906134183113862,15514518995390761662346743876733004358408187550386554449789531199638765348953,11474102901522012346251529527050392650125347221410246734211005177721289856415,6612195415835443084676700243243174090072629504450965229103970796390091290688,11572474094368358234669561324969692616275099241307798860733942350364532366113,3855324911963410548772360326122995145790506408472649961229511965629894550308,8802640003128749594245736338745752744580147773009816234644244502373660889677,15676839305513015047736600040932186843826469281853634239081282896349443894145,11124722103091011602185413968164672678635980457394627450785290630813993266691,15087674670944618980358596427703842917302233637812357643695687556421910213028,457555060782651847600218200815104907046227486293278645126081160142069992497,5340353060455057701755599760342180989590806327490432497082435572367648024359,3289809733259936118731355294329652879189400852472418229718273887860572748363,1821386174933044868215348232606758690922944887434531299978498726875279584854,17399236630582894158137572250502674699298844870791766041927951699287421557453,16772722824042046255416248879357647708113647471330900665176012648038469814744,331374066696126093678097185404981758791664151917354547180452342655690460271,5482079579065945934120471179616600325379965440378196448353560421120276746028,11861638874356162254375133266687016527365630872709665703116365332534843803431,19751278476934230895840638614095718373810690662562196455711240141902305648888,21017623330912840225230534280017695045717261514215145256795880310933667407841,9692530233397639077769939390011937602190121885296235066426091743618448584134,7914031992737639503490179289412369887137436318696390718781298556229610513180,5046304088054212585035723354298412694927209198400753780585596829596665931980,12735457541003664856181534137486291132119134214862779086936585300598349629287,8144204472889944485922664106370529127382213990656088602566223875490414163362,5526161442679804982165840590640681348630369336752481706044759543203459722566,4665464612431440885211271075488840033628676516298384234452346107374012633528,8451965709652752887539585363308640999657377914501438391781526068371105983117,18990458193856163728406448194111866469438835810342179114684453609893347662421,14602960690767985987882800342208585041637986661619503513589079723840776294824,294650277854196485752526848096008214721988745350555311479128101695333774927,9930361494944692931597991649915857642608730961125454734483697613693272941776,17972565769620820679641368732920396905240248490243886868922250461473059009007,11842743032528966560856860268344505094861546674985872961254820091273444880060,2260251491209762630871337015316066081541066308706934094017641769176593121838,21336986809148977544823484666876006147697590184356254785752148187171367963063,15637234083283356311249527335446193685599985235080555266374006156231977517227,7637477891046186378249227336975234440873859617986704147458186423096226771577,10435340982947407847927678888878882924793449778165415690957335683641419176012,21071574044063633264442120715854514033847137356154103023224485568597330648075,20085745552872944745120547909310789275453780111307008151203836541147270866122,2369255222739182549768488367357061329939116877812397072967912842660453854658,3320710154094663715463854219978294133429318041799642537800174050047893035878,2437552820481788519744888712380245016748276158860265401041560980354471184914,6687580113987208531705167517979176727449238324356562435678492283111952291541,13835828959457330678345759960614663723017667326485961761361157914420441377430,1823843951353887792473925888956554516299304358703549730900495356152013614424,18229384804985230011714562427207966412342158903455811854157839446374012856695,4983049472282717134994110428470567601005310848076496400503178535459679438524,2047051967230753763135778305592853785901616983565528680886843131244871631064,17059505494771925862841990046823342770591010831955480339095397897088168520686,5845823714127413134610517798305104245114036685335948729450609519089263487144,19810252752845594230307894817800427820113926573704856490871938876757561680148,20741340243371419379519807725035036726040739024854919427690724405113594586449,17305746835229988220561638584011917989169628535378748397361130724475478785704,16273970657972145440112726408308019138099820274904080726219726815138597785735,4927605725478881247988642936459897069651251926499343645614635597380235002430,4076655226193629464789557616268492785057128805549395585385432329518368497686,18134767316186963456589895259454813585756254459227058992203617493951135964914,20798436806114056077588608064161229365173163847083955162560624566238528904361,8811900287453512972593412116532745098600991077158875340182906101108258578231,1611466530857794066271650650204918615746591649578992581483080164777650137733,19520757346022691586967284723955378385034675472244175822936613026597514818901,8258287931139503595713718829279050060190693609290797346704848518381891359704,13807143439443425137076128013998009581746894329904809421858222329599144124143,2034200548964915935625429760202284220693125881760822084201315022529206424506,20594375914400911567795140472107624446159181622166676420027082349633992663301,17773828019575037451999782968066986504577459910353828196403976545023426528432,10645884969014005687699860915213473815514464399964009808411811895545112650817,3135829883501342672772973577699379927756997243617424917654928164800203666496,21807676600134151299257078976418813484444183016737321278512745883771478511369,14168063038909284721702678019083222059818438340503980617872573468231611140141,19022539506931505257153342575586362988716958060936788031721967221986624233067,919797128086310623571009200546035983274688764270933413427846490906074137487,10651353481391913627770814216074873532920753703051075188645774021198634943682,21601553598752750925049978818528421110707879819831249175157596816870100048288,9544964974935674319204796617933096476421551193682156030394816088243121582636,17113833205578964054057051521784698139661258340576694677296240312431808476286,9889647672195559279745677506312894570402108521106900082889976819798270827735,16028191999932520938901585234936954312994452706490572504997534210876573833649,19224701772787524647172128751148104366752057774529591812815327738829591289117,8065294760892477625290114823800398061529770004833832691347498933238361039736,8385011404987806129246014860479833290406969218526611328586242951296814426438,17626526623257098006524211054563886193098683828265081734658432468695686509315,9760584950604786147191288118087660976225563461953070125437519145090832114537,3282956645059793949082172795607530130101621492305193365378997603911833418463,3788543541342252822847978185963388795825378340921321139695221828685330606335,5728277403393912877393143174229934529937061751983246730506397742038949251701,20532577038632159357383817240596922896191478140446876998140515404169184846609,6138500779693128517529525961343097735306947649093633133232282430353593175172,16387038830089541476468870208162294639575042754761542956218362331966004300870,10184264376398708852688445921404363179240954227345322711923845040842165453208,12576299651793170522912156101640799825541149618303513174146382191633847258859,1340015400080181141720946234858756484323564628916867888877667239334982793481,733959369856163480135680991009606990817015555938726628110611986599242143578,11467033813562140192244869512537566463715027496952375979909160849747976831918,4619667645046391146577435774790188488541561222783010406420406869960248783331,58552761198135931030902257754896948615688045302818928845814661296914920622,1199849881730507352706524556330002080538296688430736582840314007371442152147,7124502590511184113044595527748024819132713282667933641439666531514739645089,8623660134669459112474551498616256867375253975034970808437732784494772311361,12655669439191191182341423414424342421477486764113555800095493091893820045534,18432703875775002490514477493898870315422995231506677048275960580528644904682,15467220287938881354678249472400749704814316816035426814619089032223454845193,2851120240492392321044027263769720216640877441121430445737594074121655318176,20519914249934881206828098454303256358482675671718589102535780334267934987941,17275124961392392047135728713829752470490098022504524438869454049765356211723,3323710067527231515807603961736782048796606296990840839366613937968342331886,4468708240622802562056471128793253296493002925988003094771284205007772045098,9006494818135081033869830730030943407240565201693254355620348420258773924028,2624130417875598753127999576825019766166727976335690685433712946223008520912,164131399455376615654870570697119442360078693174350746600132391198500093412,14931668887432843139264972187415200544679230597820424081936926034478502874299,1638753880783574431267395352024193675000113296497173968722590753809640941864,15505380865926802396097545843811910443367233632805651511272732002583232431557,17973744614207669251901495093091561913998272050499760575282030108740677066624,6137688223696761009295745609563284204827706564566466060484103844265403078408,14774243062532823236792831566222119634320864630838624098798648826842418775856,15864970393171078370207775103899428499600152663946379517190945807315353544891,19010063123357565300336230971672519561204810737546730911549311353159512986740,12607162829921425080830052984475623157169603642577010527391007035133383807243,17803108634879437217723652777640120469990779759700458421844361066182881628345,10065874953507223318296028499872542865030107611981933577973812883589535269142,3276471432535144390388324850641020151392959100393035635141206272558418581928,7532054601401798035926415744768772852833516520318445183340725930886329458991,18893822928119227829016544343228228897166113682019317256005502643243867377334,15940597493253236451533839310728876441657428995464658827726295547815292644378,4268009387843764409267791203070919313017052533005657826253994943184768120896,21611251949238422413354051947529388972078300717392131751061464498329326474580,12516447001729804412674006874184731098280474050775388553768469608793631490618,49838549447142926741568525697026885045023997277705726329780325103507790978,19763902910323896567698991616245963026306943100978479625077573937114135803058,12029297973430627253212633299020402005457460023136429653800185001711727387314,17676997725594777991384952086633589048516371093397126876621255518370680168503,10567543371894667303450346380722020266352683222046730266924342174164712049360,14583364850544999818712646438016435003942847076919084667364987497592599663937,17348091487238815837308569582101875357715798351834275089190053280855958465528,8743083090296259283603789316855921930102444739264013461469099560398359267240,15114064505647935792598848256320570567717917317803629185764147361301698519005,18332675991829764561879941291908436508530604635608341316693114747813051532006,1757567731797951053080580099911774643896363235228742197150882457231133285549,6526388717947413328592956348507481629843816325885832861915399601868279124246],
-        [19332164824128329382868318451458022991369413618825711961282217322674570624669,12346323761995603285640868741615937712088302657627126374070962894016296466118,3913895681115272361294397190916803190924061797587910478563401817340941991811,7048322889096718105055545382948709082135086733564574465991576956878202831861,10375086910057323893637057154182902576957472442368661576421122036461645295833,12765622911241487148932810040772504127756393086809438933166282251044289864727,266900212758702307861826326591090138389415348463003233900705815890364224151,14435131616556129905356866638030823183270286404767286105643513738132789033353,5780976801287540146775934937953368730928109502001687434229528186520268917700,1618320442446662026869390273942730786145909339107736579759397243640902802126,3818399583522206096165108192531271582827953520684743806492664825009577810261,11764506724346386316602508039052965575734225646587104133777798242528580374987,2414215974836165993714858157462355581258152126063378817495129367240311967136,17609437036230923129211608175600293197801044251801590649435913902851695334081,363438080029711424794236047863047716381155074181485245036621530063262917196,535766679023716739184211613469394818313893958493710642899297971974381051070,5305068908469731303772738758164870877638068032868328180355958394150421214337,10807632568240507366657354568432178961148417327580695024415275247652313539292,15964415873358391713354948903242729080763777490509563223190335273158191600135,20700362719972015883260687302741075186857660623182772413609788566925949033885,10135127975676256977820296631533839366076919827597067890970660746228807376456,4251490167543116819728642817282216847143714366441358372252125244838181656331,7745587495915033527847242564710473705100826890903278244320948416581724663023,11741113129223221800185946819924457344647035336264986754437921049066977440806,11630296782890656599545188109639399768829653360050213193782325240600583381364,16861140446185941149398487176581839232380972247302922484807333229513905651035,365879246117123675211400356410703684399715291171114630107795112994207447819,21725607857580053522363567649763546934441685061337033780528788383243719579033,9222866548596464928765000608129177609426964853736257576074550520759533736918,10261578281201197531384003420612639018011405529775212563256392340336951230146,15644037447921591571869862919382888810859308861783088910843592577202362807673,12752004188139535619565478547449108772137477456363099481095747591698702436636,4205805109630387448825516813913983509046636797101589615147198457314360427718,21047095155106717901091873146599497621258071512562421967648909471775919992713,15624165295872926124160584750951090817255240214488120310950503163805737026315,15064589937731741958666763896598138037875460434244947486199623542160035749721,1801577872277160959016940766173040841160105238799805406938450020949902989173,2896766420608048344829901127120623317655260981420052771341833288256800199953,12828791469509204618898135640019714232831708508424682785876476343251730674999,21363471986981372923191391880511344708743312828234098289107697080824665183315,21372706354350795416381912271616633829725494570576895047490974943034914894898,16006531510217730955981102005088687858079561573088629102219485906666961331083,2389357602244845938251345005183369360523566673990464798041306722747500447645,15275955107196234672088664710679934029171843237458844492987233368659104714648,8038797517535218686870517662905230585331773059774130312418943649247287196930,17923922393436914864421862212181654800719733137689602673604754147078808030201,12890519745320143484176500044628647247549456778462652469313611980363507314914,8058516556024397257577081553178859094042894928866720408652077334516681924252,768425396034382182896247252731538808045254601036758108993106260984310129743]
+        [
+            0x2197703fceb4cbf07c6dbf46c4ad93e7d14e554db66d09102ff84824743fe4e7,
+            0x1322f0fffc7e4854bd8b5fc23e7106b51f59bd5061d8b565aca2fd3efe512f79,
+            0x19e414f80380aa2d222133118c337d82a8c5894c2f88861ee46f448fa9d61359,
+            0x22241199a4df9cb7d65249d9562cad6c65f16460e79a7939cbfdd6d7b9209d9a,
+            0x301061735384dfcecf9a311c22ade327b51c78b211615f41c77f6d85e8a41b6,
+            0x229e1d86c1f2810f4a2633b7b4b5bb61b7dc5d19ac95fd8d379548ff2b6850ee,
+            0xe31dcf9c53209a817eeb292e989727c3f56bff65883afe5fdc28ac3dfbea675,
+            0x68f917bb1b0805e5b5888b6a97824395baed195b5da0b71c42abd091c2ef54b,
+            0x1d0bfb8bb90ac234002d837715613297802a5bbcb69aa2da8cfabd832f52d7b2,
+            0xd67c182fbf41c18d5afcb48be20237413f02a64dbf09eaf71f23a14fb9e2103,
+            0x3058909cb103557706304b9bb64d94aea4e504d8fda8b82313996f7962884886,
+            0x4d06a80196e10e664adfefd075d0cca04961ee8a89f4fd6d601eeb9b60c8dbb,
+            0xab062f8d4b5ed0ec21bdb42eb3fcb0a88fa13afcae4523d2386455228407b56,
+            0x17380754792ad5f8195e327a5a63cd7570cd1994bd6a130e01c1fa1a173d4630,
+            0x2d4f3780eef4ff99ac916f4b12dd575613cb9621bc5fa0980ed9a4ec8aade56c,
+            0x2abbef481b368ca971e74dae04691439f845c10d1d57894269b275c196aaf9ee,
+            0xf24324f82d68231dd9dd6f8c05f52d8eacb9ae01ccb1f3b30228222377d0e53,
+            0x267617317f5146654295ef602b91250db010b45f4724ce7ec54884b29c404597,
+            0x157f9e2f737498821bb01ab1001d715eb2c336dbdfcb867becf0a2bb6490c06,
+            0xda7bec0cb98d337a52cdf0d66e8a97f24229671346848a552eac14c8a30c702,
+            0x15fc820ef53302dca709f3ee480ba1371c91ade79f9f587fc7878d731c0596d1,
+            0x845715adfca35c3e8057c0fcd4ce6a6128d0e8117d88f551d3ec6587d0f4296,
+            0x422f744e2b736096bc8775a3906893a64cda874aa4457d2b442a9a771956d0f,
+            0x15f421550bf6639d46ab5779fd26b1e11618e0497e05cc85c608b00faf3382a1,
+            0x4f17cad2ba0ef6f8602e93f5b988d5f357e61ae5f3ec35066fcb4d1a7b720c8,
+            0x1732ef5660d84ae50ca09c021eb0d77f1fb2a00cc7905b2479588c49c488673f,
+            0x29b12501fa79e08bc25259985f730cdce9e2434192ec826e0f4b9d568bd351b2,
+            0x207c8006aa78fc40a84db40ad82142d0f61b28dedf10e2201d815cf4f6274590,
+            0xa25704ce4cb74a94d7bdcbdb5fa268abd589d88fe45b2f2c82f90326cd049a8,
+            0x11211f3a71af30a00101c423ea40a9585a9eec75687725d7ee289f428f40efb2,
+            0xe01e8bbf5ee611471380ce8bb8c34b932ac76e96faabcb7ad20be96187c2fa7,
+            0x1c894a1430513df35523e22e4fe9f410a43de91dac73ae338c772fef1fb74363,
+            0x2bee349392dfa0b5b4a08ee58ef54f002e06ab26834f94843d48ff0ced526d5c,
+            0x84a60c1d70887d9f2d23a8c7713332829eb41cf3181149fb223b7abff4d7f0,
+            0x23a4506c90c07f3ae176a0e2bf67f57f88d45898c97bcdebc8a8263ab602c7c5,
+            0x1ab66896a1df95c0208b990e2c634707394a1110cb314bb82e0a2e2b4958aee7,
+            0x2c6b842aabeb84ede49e559d8eea658293ff4bba9325b5a1d4cb649d317f4616,
+            0x16321af63871328c2b88f46df432be9aa14b008b93f85cd971dd986dc16d2e35,
+            0x13d647208d3dbcc9df10d1ee35b598e6c8ed85608f81ba6953088e7bc6db73ec,
+            0x1c6aeda9e0fa69f5143e6f22e747b7e74e692b9254d55c61b890470cbd7f06b,
+            0x287d74a5fa03a4ed65bd4a7c6daf033418f474c7dd9b957bf2b17965cac024b1,
+            0x27a4327beb0b3e0cc219805b3f05e854bedcda1b7c93f11691ffd6bb76a5d0e9,
+            0x271a03a000bf412e7fcfe8918baa689c6682417803f5b302f1ae30695c8e6770,
+            0x1a4436200e4d0be65d2f0f4000157c957fee515e591c8b54bcd46c02d599235f,
+            0x1bce9394a5dad0a4cee35b8e99b4b3c0cee058b8ae4fde301c3145a5a7a94c76,
+            0x2b1b4ff2bc186b7dda9c3e05dd4932f38e6a7c04b0af0839441a5972125dc902,
+            0x13c87d0e4bfa493cc2a197b1c9db49426979adfee4714048d865d4f6e95f699b,
+            0xe861496d1b54e3530aa0dc64c6683ec0d01a4e3d1c69d50f4d6720b981ccd62,
+            0xdb63bd46e06bcaffbcb03e5dd3faa88f26a0aaa728198c5d09a483fc4197100,
+            0x2f8fca3a44bf9ea99452e1a055886af7c95850b716222ad89f0219054d45db87,
+            0x5b7bb3e5a4e2946395d1d6ddd541bd9c166cfa1956d161713e7e350f5947d73,
+            0x20e4e6c47a68be3175fcf5a7a3f8bf7b3b2198203b4552ed620b9593b66e5483,
+            0x154a2a02379c7695ba4783e15d10a147560ee2b4d03a04a0b901dade72df4862,
+            0x156f02cab5fb0e7e6fa0c743bfd64716e15e5e50e12774805b1c74dea89c5345,
+            0x1d258218556d0152f0a3be042b1bd146774a616ffc7e7313e9519b5041318912,
+            0x160a5da355d469412e5535804f99dfb8fa839d7ce2cb7afa50c1fd036219f4e8,
+            0x1693c0c96b95f7037faf6a18289814c68237870edc94a72c883eb2c751d5ec43,
+            0x2b0df0f463f69ca206ad5c4a115d1a6a83d5e0ac328bd468f35826a968d5708b,
+            0x19cad23c14a9bed0e159f250bec8655c07149bba04161fe002f76954ca192b60,
+            0x25857eae6be307b653c36a4090a3963d60842410e04c5722dfede28fa645f54e,
+            0x29ac9714955b7a9c94e7959efbeba17c04839ad7bbabdc643b9840ae43155f72,
+            0x2e637dbad876dd52a7284db266593aa85b2020bf340802625e74f45a2cdf962d,
+            0x468d89779fadedbdb4f0093858113c5060321aaaf082a53d44fc74c65e7ee84,
+            0x914cefd51a2822efcf8629d57eb5b6ec7195a90087762ec8814f14bde647522,
+            0x120a9d3cbca58b917f4e61117c7fe2190ba6d238ce374949778c40a6d176707d,
+            0x1cf1c75a1b2ca09ac655215cb308b39ecef96d746ecbc34b37583bd8e0480d5e,
+            0x511cadc2d431769a953d0d2355cdd3d8c13dca7a6c5b19005bcbf3c5bcf7770,
+            0x1e2aac063f4303e24a2a44b1bed5688a43279356dc78a772e4dcfad0562e5dd1,
+            0x172a396d41cfb2b1241e096aa41f3a4788303d8824d5496871e03cb9590f89ba,
+            0xbde068237cc41aadb7ac718d4c6b916cb7f35fb399ebb2515307e6004969e2e,
+            0x1522d1f8f0cb9214b3f6602d9f867bd2ae07a8fa77aefbc3153af4d350d933ee,
+            0x157d56053aca2c4cd30f7ba34e5d41b8a636961ef78c1dea1759dceaccd1ed69,
+            0x10aff8c0fa2f25f58a299e22c732f1b901616f6e4bc6f63af79bb93d45fc188e,
+            0xa9557d37fbb35ce046f2df3d8bd9cfccedf85eef2549843da7f2c2e36d2bde4,
+            0x75029d8351a4949170136de66c179a8d6ee6b56b89598af199528d78e8d2c59,
+            0x2aa767c911398696b2302fe15ad33ef35c6c97618e672f837aa4fd42930355cf,
+            0x14d99c7417a329ff62d32828421e1b8a031d30242b285c86a4f63795e376623,
+            0x186e1b78089467478310c35eca9d2058c0a8bb8e2ea5c324f1314e478a12894e,
+            0x2ca9306ef62dfb1ad58244ac5bd70b0bc84f86368f6c9bd4e15ddaed432e9838,
+            0x17630d6307628585661eaaee9438c67160f7eaf6d03d3ca6364d4adda49bdf27,
+            0x21187c1dffae74340a488cdf08ce322226544816780af016098d8c39c7e72e31,
+            0x1db210b93c320a18bab1769aee63276bd99ac89035b0da327cd06cb70854aca,
+            0x18bb6f89805c1bd59d8d7ad109d5f26b4d18813f71cf3aaba26ee896709404e1,
+            0x9c0a6c2d79cc06023f3f43196c9b8a60a55716d2c7ca095d849a5d67ff6fe98,
+            0xbe6b7d6cfed9528f4d1ae306f3138306ea7c81cbf903e9b884eab5084dc4c16,
+            0x16fc7c808552b1362d8a739bfdf6c6dbe70b00611780fb4818d424d5e017ed5c,
+            0xf31a91e6db75df904be6bb14fe7271429e5787f9a918d1cb128ad76ac948836,
+            0x230a66ce24feddd45fcfcb5ca7e4efb12461a7c0a0b673a73b252925d310d488,
+            0x5ed3707e7ad3478ae508126cba274743cfe8685b46153f6da3a0b4b83ea92d0,
+            0x465c370db40b8f14b4f6ef913550c11bcb2839ac707e2fe9a9c31b43cf8d938,
+            0x85f42b894873a7451a60fec0539f9ff8b2e0a495e43db7b95c3a75c57c20ed,
+            0x2e8b3ae9368c9c1f1542ae734cd995869f81aac64902fb1d3597022da08f9938,
+            0x161485d4fa8620e6fd09b088159c4e223155019bfe9eae28f9870ff19ccff314,
+            0xb6e400339e5e76c1d200fd27884599d473dd98fade9e648940833ea32b75416,
+            0x261ee31fad47c0db7bc046f718437ee518fe73ec92c1e203155d8f284d44b310,
+            0x4e106089b776d01a284b84adcddba4bf0ee56c2c85ac584b4d938f45023252e,
+            0x4b14e89f42287dee36142a17718f7615789c9f9623b534afeffcf9c7e26449f,
+            0x1d55915b20b60534f1d89f2f8c49568123fcb4c6d9197373e54662e7d9eb83b0,
+            0xbf04f5b7d178a77ee32fe543be468e1c89aa457a2f4d6699aea743f80494b8,
+            0x1bb1f31e887647cb45b8bc5be185e206e91accf86e5ce5bc1b39af12f857ea3e,
+            0x26f0b4214212ea8030aba75b2eb699e84adf24bc4b856a3522b82c1edca87e9d,
+            0x1ad7e1c6feade269c076b67239b316e7cfc194b036b5a53f9207f457599c5fca,
+            0x11947cedad859f02ffb4b99e8108512fa325224ad7e1bcf82b28c61a89840035,
+            0x1ef4f0330d6144228ef6cc36eda0d179384c4dc1858c95de12d070d11c43348c,
+            0x1031abebb0216be506c04a6514d471f18b0dc1b5a9b616c87a465b689cd1336d,
+            0x23f97eb680f5a13b3e8daae572abe2ac0dd92eaab473002f0708e6b6084b2df8,
+            0x289b2ba2e3c8f665b94a4d73b5bdf7d6687468aaa84ef7f6e04fe123659e41b2,
+            0xd40f713b31b2d041d3e01e2504af10020bfc45bd5bbde4f4b133f63536090b5,
+            0x29204d73ce84b3fbbe047c74997ee799f92923cd16ece1eb6275c8b71659f149,
+            0x23cd14b50f4129fa56263fefbe7475e51c85f67cdf38a9ae7637ad04ad644c6a,
+            0x1603887bc7e6956ae4ff5b9f4423b2293ab52b69b2ec021acb90bb6da8dc3883,
+            0x2137d99c24145e52ead0129bb220690c5ff8f6dbff755c8467054b645c74b0f9,
+            0x1f3d6d1349096a8e0594443a487386f9f51b2fc366e910a9952d4f0b3dbec414,
+            0x2148e1aab3e9c82a297d04af8191e2b05cec71b0cd6b8b4e079061dd00f01a00,
+            0x17fb0721b3375406028ab6f04882a202e6801cbbbb50badcbd5d760d59e60c54,
+            0x44f8ade334554cd610743aababa1196e00106e754cff8b088ac69a273ed074d,
+            0x2e10e74d30679661fc3ac960b7c967cbc50029d2ea463ab8ef55633cc5405243,
+            0x1e44030832526ce32d540c5cdd2def7f900509bc8019fec5e38848b3576dba8e,
+            0x2c17bd7af463d52d3fd7e8723d11078369561ca3c4ece48f1298adabe7c822e0
+        ],
+        [
+            [
+                0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+                0x1fe9feb5c7f7c7a426bff032cd6a3158278b6c6b2cc57a871213fcafd6427989,
+                0xcdb2db9e4f9d732d217c5e3114821165d49e5a2d41556bcd53d0c4d433224c,
+                0x9664216ca565c1a44fc2b98347ea8b36904b3877f2159dcc999895adeb4d70b,
+                0x1463f51d4a4cb1eba16dbc115566aa48fe77b43c244c9988a3c658d2f56493d6,
+                0x214e41788bd2b990347c7f2a8f47612d4dfceb1a1e6da38165873df66ce51f59,
+                0x548541724f64e20128260899abe8fbcdff184a1957a9385fb715923bf0fc79d
+            ],
+            [
+                0x1b4bc5885d1cfc8eb691875300db5a0c7362ae381898acaf8b63cad04ecb36c6,
+                0xcc7eabb154aa7955eac47a19f6437a2b8dec0fe9e5686150ff6e88b1a7b4bc4,
+                0x12f3bb29c972793182123f5c49306e16a3a787c4bcd9c798a131b70856d1cbe,
+                0x111fd8dfce2bd3b7ba0cfa93e20fb685abf76d77305857b8df30914e4849ecef,
+                0x16afd8f4c39038b8006a59d292aea84731c0f83832a61b82250ed90118e8fec2,
+                0x3fba82d3f783620873da94e9f4e84c8b529d76f54e4b5d7d4805272af9b9775,
+                0x21c5e25a6991364e59a205e5b01c811deeb095680a72928369cfd2de71b14f98
+            ],
+            [
+                0x8a72fbb55dde3e93c5818571a424a54953695029eedbcf91eaeb012751c7f83,
+                0x393efd96399aa0726ef9af79be8b6c715e429906ca0d15076b5a990fea75ace,
+                0xbba9006404c5ede82b527677daf444ed43fd1e0dbdc5528dd2cd1f17ad73481,
+                0x19f53c0a592b3ea93497a511e56f66753598265b1ab6774da48eec04e4d93426,
+                0x2296361f3bf154efbab996921936e9b1dff8352711f958638172055333e07579,
+                0x66782fe3e869de2cebd7ebbf60fb435785329dfb12ad9bd1b4e46ed36289511,
+                0x11c5cc53f6338c825817aff7792a2efbce8fff171300d41455a2edac37663d02
+            ],
+            [
+                0xf95359a1f6845d4921892f83e500bbb1b3d3763d8fc762400af039b0abb83f5,
+                0x871233835b752ea030cf8a4f43771296eeb33f697d1b0825db47d39ac9e5955,
+                0x17e4e73bf701f88d219acf1ca6390cc1e17c9f84b1713820837ca070be84a2dc,
+                0x19b683c39d3b002fc3523b7bee5a60148b1dbdf18dd1c318e6a541e8cf66a174,
+                0x1c3160ebaeb10f809f69843cf8d5bbaca198d1f8e3439be29beb92d909ec891c,
+                0x1c5cd6b23ef336be01efa37a27e6b7aae5d1643fceeb212cdff51588835fb537,
+                0x27a0949fdc9f10495c4ee7214aa0edd2ad8eef68f577da8b96f9d87a39504bf9
+            ],
+            [
+                0x16f01751ce985328afde34d81619defb43e6c7b5dadf52d0f82472fbce7770d9,
+                0x1a02798f047a51baaea34fcfb26ca6afe96a5fad1d2db4270497b6e6504891cb,
+                0x234b8a077ef52b53a343b8da5b20cc358ad60760dd60276d485015f73d53d207,
+                0x2547113a818779f13e3448719c7ef100b8036bb3e882dd5e6456c35311c1bd5b,
+                0x94c66bdcff54382cd9213abe43312edb5b4d414c6e09acca24912a7635404c6,
+                0x2f3b4bf0f105f88e27248af094e29feed9ff3fad9a794e15830bd2b311539453,
+                0x1c7fc68f3fbde4a23c455ef0d0dbce0ce556a0194e6d552c0455cbb5b0c230e2
+            ],
+            [
+                0x1c391626328457fcafa629f3e6d33e2555e8d885e3c07cecc8af1f4d56596417,
+                0x55665d76df3cd0fcb713c234ea79d06a31d6e3e4c3bcc657dba4c664d5a0da0,
+                0x2dc3fd77394b7b5ac1cbd1b46e6ded5b835d7217a4c50a487ae9a35a7fd45d9d,
+                0xcf148f8045cdbe7bb1013f72ebd4126a3e35cba9a970441ba8d5bc76943b0b,
+                0x2e883bd408c4c826d004ff777d7c0938434ab5bb84f3420e5d94b853b1746f89,
+                0x2f4085eaa9f80a69b739fc23f2fe4057f64729b311783fcfab3a0a36fc1ff432,
+                0x11d0f56fc00e7d85b3a2939fd33991dc8abc1ced0c3f3c530cbfb4500d63de9c
+            ],
+            [
+                0x970f671b9ba35e3e3c642d1e0b8032023ed5bac91c2c1056f03965a42c5297,
+                0x26ee9691a638edc7c91887e302fc55e8e7758286a44845ad88fd7de3bb1052c1,
+                0x1668477640fab14c72b1c16ff0192e48cf882f12276bd12f97f82c6ee2e61e48,
+                0x3008421eed767a093322a09c3733973a038168cb28cd2e1f709076c00b869599,
+                0x228af6d425e91a783dd18fd89a6b38bda053f2f23c094b875f27cb3abba2030b,
+                0x2363603349e94f520fa1f98fe2507f6aae361934078aa59a16214c088185638b,
+                0x1b2e9d20d9b55deb048cabe1636f0e96363bec886679cbd91f332fb2bade44f
+            ]
+        ],
+        [
+[
+0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+0x90df29b70c5a783521503f92a45753c8bca03a74627a24c44dbca6eca32ac42,
+0x11a48e9fa064121f52297162fd169e051d154a0e203583624a16c73534430b9b,
+0x1636fd9a0457ce75aede0821e036773e39c37adf6fedcc7b2cdd72254e2ec7cc,
+0x2e64b2e0bd6fb47559f585b63e8dd15b430058a63f2076636052efccdea98ec6,
+0x2cb7863886cc4ee1640210d29a4a329d93a040ed45f2744c25731c8fcd15f0f8,
+0xf3212046ef984438989c355db0984f93ea4bf99de1700ee0185886e81f2ef43
+],
+[
+0x1b4bc5885d1cfc8eb691875300db5a0c7362ae381898acaf8b63cad04ecb36c6,
+0x2c628e21a22008733e14f81e953a50072ac800560554df9e97971a56c509222b,
+0x1cb1d2eca719de8ea352adccabcdd100c4fddbd380871e2190e33390b8bab1ef,
+0x6a0175e0d8aa3e1b994a177af69a40bdf6dfae09c41d2fb3d8c599c76e7f07a,
+0x5fc6589a1d1d35b2473c61ac293c6d6cbe24fab12a9086c0aee1f8d1a28a883,
+0x26342b8b16928328123d727014822f00f4fbde2cd45046f5dbb6b986edfeb632,
+0xd7565999ffac123203ee5a0699bd4a2f4c491fcfe05676f928694717e572878
+],
+[
+0x8a72fbb55dde3e93c5818571a424a54953695029eedbcf91eaeb012751c7f83,
+0x1567d8f8711949c036030ef808665350cfe9b648f13c675379aedd83d9b83767,
+0xc9037b1b5cb3451595b4f8a1ca80c3d72ceb93d6d58dfe8eba02e88d211b281,
+0x183d06dae1a0ce53171aa09f25f25ee397263dbad5306dd1b7428872baabd5f,
+0x7da96bbf5fc4458741de810178e19a89631a95f2e0cd7e5f2783cd237f3d911,
+0x1efe4b3bfbb320e15ac79fa9abd46e4a19b21f39bc40143351321f658f6cfe7c,
+0x900505bde5ee2d55f5baa932e38805bd914afbcf3fc854219cf41d147b89db9
+],
+[
+0xf95359a1f6845d4921892f83e500bbb1b3d3763d8fc762400af039b0abb83f5,
+0x27630d326f12eed19ada60a1f6c496680425b457f42e8999f49676af0b637a6c,
+0x26920194603a11727525c5e7b267ab6580abe2a7912789eea077a55f7ec3204,
+0x10e5dd7a0862c4aba24ece684e502d3d6132a99d906908b20eba4f3466812e42,
+0x2d30f6e371ba6fa64853fca459d0d6e0edf941c3e8177ad5d333d4eaecd7dc7c,
+0x7ed952f7c3370e03880bfca6348ab2ad35bbdf9b7e9c266e7885b580edd59fd,
+0x25b7a438b7dac4f0b36183f18766ce503f69d6c1d9cd29b986d7d2b8b44be433
+],
+[
+0x16f01751ce985328afde34d81619defb43e6c7b5dadf52d0f82472fbce7770d9,
+0x37e3c16dbd340ff80f49ee4f7dbe1098b474176a92b7a6964a63f2fbb8acfa,
+0x2cf7810985ed56d898150ddcbd42edcfab6442f0d0a7f637693f676300c85c5,
+0x2595dfbda733d0477a01cb6693b93eb4cb711bef3784b5fc9e17f1b342eb15d4,
+0x7d9eb804f0a999ec586c58164da8467a481c1975e27b951f6f18411a7440cd8,
+0x56b8df70be9577f94b6fc2a3a94f736d9c7b9de29134ff3a524e406e3143280,
+0x258a0dbb961fc61bffd39764fe6d3c687a1061b59ad00fe85d1c18594b7e7270
+],
+[
+0x1c391626328457fcafa629f3e6d33e2555e8d885e3c07cecc8af1f4d56596417,
+0x1814234ad66f16a36711c9d2779c1358ef58f650cab5cfd95a0678af36224c98,
+0x25965b4db95bc7104bffcc6ed99af5cf5328012a3a1a35cdcbcae4ed2470175a,
+0x3090eb08e04a2d235c164b71a56dd730c6b95e5a2613d39cfd932b90af23ad0,
+0xaca5e46d797e1748aa438d2e2967569992dfcd41997be143c3ebd2a823b7660,
+0x18e6cc7c6ba50e61933de0f615fd4458d39a6c34c2f241a4cb78dab9dd1b4283,
+0x216fe55a6f2e8daa2523b65eda5367ad3a3a6c55856c5447f398a280e57d6535
+],
+[
+0x970f671b9ba35e3e3c642d1e0b8032023ed5bac91c2c1056f03965a42c5297,
+0x1bfb7975cfa9022d9bea2acafbd020c85cd3f1091794d28413510f2d723ffdb3,
+0x20c27ab9c365c5d2de660b9b31d4a406907c506b5488787bbe2de181b76e6a7c,
+0x28feb3ed6c194200a579ff340040be172171c1f7980e63214a0b3f7603d68a02,
+0x100d8a1a7ff31b30725190584c830b15c0cc5a41d9d530ed57c0bab464368b5d,
+0x791d241f4743deb4afd41d9989448220d5a1d101bd96db5ab2968b981aad486,
+0x1749c39995115eef14e1bcb1ccd4cdfc5c928ff14e078b38f5af326ed6b1e099
+]
+],
+        [
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x277ac8a3178a356b9072bb7b469ccd57a0a63dbf08fd0dd7356008d5307bb3e6,
+            0x24903bdf5d3968a8e49c6bfafc0e28d539ec1e2756e69301a8e38dab87c6c402,
+            0x14e025a7131c3bc8bd2d48508aa4f791c8ebd10688d7e5566a41fa0c149b8602,
+            0x2e41c7e320ecfc1d86df765fd7bf43ed2b6bf27ab8b7c74174ed61d57905c555,
+            0x11bb3cde82e89bb0041907d66de91029b35a9c8c90ea44de1661ea2ace917451,
+            0xa7460b280828af7d0a5bf4065b2b9640a9cf83d19899cca0171ff6abcb49751,
+            0x234be66b59a16a323cb35d6516c5a92f4997b76e14e656a8c41f29fc94925b0e,
+            0x27c512cd854e483667792d785ed1ed7e30569dbe12fc3fcb0c804110c937adff,
+            0x1532821b842df3a4e64577b7c8917219c86fa82e68857a1a5be4056e8763a864,
+            0x1ec15f1ce8c3cd648f325d92ace903521d7b0f668a01c6d2b92b43e35b5ac58b,
+            0x234748a5e415d7b5cd0b75b712675e72e95b1e02ce6f48d299d5a3a489905ea5,
+            0x14037feed35ba091ce3dbb4e6033098d07a3cc512e981a493c0788e3827a6694,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xa7c49a32b5a05a6d74faaded50d303c066ec843a10ec59dc90cbd37ba4b1b6b,
+            0x7fe2a4ab68b94f006bc1ed36af445905c8d234d308d57011dc1d393e6bcce8a,
+            0x15b26f61d51ae17017b1b9d1c9034a51083f25b33f474c96bca5bf47e8a658f0,
+            0x1a9c3ed5b8f524e8e2de1678002e73c63ebeb3606fffc29ae527fb94c60f5f78,
+            0x153aafcf4923742708efe169c490514516a223537245aca3ea205df20b8b5ccf,
+            0x239cbec4c84afc21975a40e29610d83c1d71a378cc58995e505def01cc6bc872,
+            0x1edb2bf1ce76a49c4844b7e5692018b524b30c1660a2e003b5768787d7af6d32,
+            0x222778dc5bf834f9320f037f4847ce62a2ae63be8cb846a5e10a3c2eb2ff22ee,
+            0x17c2ef46844a5365828904ac73e5114f9bc2833cf35f65adde116491bc86e0c0,
+            0x2fff9c9428727c51c6bd6c657e31314706237633e5cb78ae244d5d4c3ace4839,
+            0x1d188182ea443a5a5cea9823f3eee70a2c1e18459e4305ef862666d16236b0b8,
+            0x194dfe2339f7aa042818a43f4c6d3b5b2fadf648ba0dc219e56ec7f849ec7e5d,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1c7aa6d64a120d657fbeb04c84017166427d0f02f0406c0674899118aeb3a1c8,
+            0x1dc18887cff4545b07d122b9086f80b9c464ee5aaf98ebbee8a648df3b74551d,
+            0x27c28329d9f8519a1ad9973cbc710635e5cd01ff884e1c113cca7b35742578d9,
+            0x289ce154bb02ab338ede3bdf7b2efe8de1fe22259477475987386544f3eb5cb8,
+            0x2257e368b26697c9ae1bed7b5cae11efb9d48138dae5b7b3c499a37cde286d03,
+            0x1bc9d5e7820a13f9f045f7b544abb2e4b954a8d9b6d38f198efe3275d9d7edd9,
+            0x18d112c5305a06c15faf556d58b84ddc492912505da27bc8500fbd32e4df9c39,
+            0x2c63e80087f924919d20067f050b7d7edbdaae2f3018fef6f8cdace9768faa75,
+            0x877b395faf50d5d108121e29b7ca64c6408dbc08f173278ebf6de8b9685e113,
+            0x40cdf2e7828e66a99121262b33701cc96696849e5532f492486d69b2779e9e4,
+            0x16e80a1f3fe9b828493e83d1a31428b1c586b3dd54d735eedd257930a2f539b,
+            0x994a923eee5e6fd6a4caa317c6926ff4beb82c3dfe033f37433d31898a60f20,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2060946803f18c085b6fde5a3d8750d80f9b21ed391e27e1c7bed180d708e87e,
+            0x24fa5c0683c2eb83b0864853cded9d57d38f33fae496818450e2f6c49968dcd7,
+            0x162824e200bf52b73914219f02ddc59785407c558eb4dd72ff9b11921a351eb,
+            0x1edb37284aaca008c1703ddea2da4eb79521cc4cdcb7692ae344be2b880f574f,
+            0x2189adace1c5a701dfa9c5354cefcd8204c60095f5b8568232dd01acb3c09688,
+            0x19f1b2d64e3cddcf28e7187f16f3a90c93975e2569625ac689e3878b2de7c778,
+            0xc62cf98668e5178bb9b6b261f36e1c8f176f190d372921c9b46f824db8c6190,
+            0x16ef695c32d05c8c43431f284a33a0138455d93408ca2f742944d71eee85aba6,
+            0x1916a7ff07956db69d712449d024d8272e2d9fbe9428d6562c503b99337b1c14,
+            0x155303d79a49e28947744f334366acd9454fca21261d32bddc76ce6086e8f1aa,
+            0x21dd4756d2217bdbb9b439bc12e5daf5a8661b1effd889c642cb49c4839cd533,
+            0x197232e52cfe9adf15394e38dc30548d7cf495c7499bcdd993c2df59993d72a5,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2f1786e4f7d8187788ae6fc25c6818d2e7fb34a8896414ac9f6b958de481eb0d,
+            0x7b914cb16d817387d79ee23fe9975ec91fed24d0e163dbcb5418d96b504c2ff,
+            0x1958452705af91d4b3be5bbaba856067cae00977353897c5ac0d070f90e34ba8,
+            0x20f47ed0ffd3fa2dd8dbfd9d0daa514b0d72d270d1327e33840cf178b27637e5,
+            0x2bdcc2280fe50acaa851536e7432f37c888a6507168a4b79e2578d7372f5db82,
+            0x100ca23f8d8ebcf656d1fa5cb225932b62772fe53e2c5650109e71231c3a9b0b,
+            0x1d359baef3547113637ed1d8e44c89166eb4154d190d38a2c6d47afe5cc12e1,
+            0xa78ae4732461eba1b90fc18b100cad3712d8b684324dd57343cc127b005a3bb,
+            0x1a843ce91e265e4b6cf8ac90c3454584d4d481813247df111241cb4409b26b2d,
+            0x140c4ee1c78bf8555602a74eccc3c3f71e050a5deab03ccde1d8431c151bc3b,
+            0x7696859ae6cbcd413e8a035a9191cda79f3d04e6c3d18658434d0555824e4fc,
+            0x2e7f9004dc09157cebb4e42884622e0307f85fe2c37fa7ad2674b0981b2c0d32,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x17607febb988532e6c79c307d903056a2266735b7423da83843f70723f09a5bf,
+            0x2c02579472877870c8c3457b6d3b284eed6cac0d43e93c38af218961a9ec3ee5,
+            0x2b24eeb2617860189e832b5a50bd17938b2788858e58d9ea9bbcb7ea175ea012,
+            0x18c375a125854f8fbf30b0a138ccb4c771dbcff64c77d1c62b79d70a13e307f7,
+            0x7251d3e863183333fdbe9dba4f3abb21777555ec7f996db96352311cd9fc784,
+            0x2adb341301b3948dc700e495384dcc124d5371ec6163615ee7263009fbfef1da,
+            0x1472cc421bd8fa9a7efb991ea065ec1c822b44fe601640f46995c3f10f1323c3,
+            0x2c3a91912dc2c2a792df5e43134bc6d7e582f822994a5c2a6352e789997f9258,
+            0x15e8c106e6ea3898a09e7660ec87c5fb217270ee9a8ebb1d052e64f3dfb155d,
+            0x196b68215343e220781a52bb0a324e4ca765394d2f3201a769bebbd931dbd2ed,
+            0x2ea4a2d5188e98ec570e50b70d0303ede5207bee762ee8932a466bdf891a333f,
+            0xfbf65aa42b0d900ec78b68de4b2041140fc85fa3458303276d99826e97a2783,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2d93d238704becd76c0220fc95afa0783f9695075c5d98b363f91cd249c47a22,
+            0x1011608ec77a11a0ce8b8b1b36ce08de4f93af8682fa026b87d8a2795b71391b,
+            0x108c04095f95a9fcbbd038c079842940d8105c509c729129f7cea1c5e968e194,
+            0x27bab26eeabbce153dd52489db2fade373a936ac52383034ab82a9e252381e73,
+            0xd2611e73e27ed17349dd52e13a90adec9830a5e2c7115d8823d23688ba4e570,
+            0x1cb4e6780cd70a0bcb4662edfe8bb829e146a62c4461c271ff1a0d8db5c1974d,
+            0x1d429b1257e514fae54614b4648d627169928dd3a496a3d021d8dd7b2a1cbfb6,
+            0x919d557a82cd7294d666137090c7348da53c3b92bfa3346bf14903a12e5ffc0,
+            0x1b99c14cb08972b58f1e7216933e31e2e67caf29f8e6e998fe2b1c30ecbc9473,
+            0xf0435abfab0c4e0ffb1a687de5cc0ce3fed74cf9bb2b559b569a552e8ec86d9,
+            0x99366a2b727e153c4e338c7cff84efbedfaf7dbf4c7904854574f75f3d8e848,
+            0x187b41d7da085759b71c2028e359907408319e8c6ad842c79bb202ecb419be5f,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xf8adabe145a57461fe9a583655046a75a03785a0a2942221ae2000664936e3b,
+            0x21b8878c75b423cb1f80e0b574b3f62d28785663aa6b4e0caa3043a693bef6c2,
+            0x1dec99dbe933ff6d1c4b6285f8c68771b3ee297afbb5c934aa2874765f64d602,
+            0x2d23ed96c51ebc9c51489f7c87de4fa151cd8378cbbc701542f54bd4f4d808,
+            0xabfef9fb01611d86e6ae1c1ce2d3febf41378ba90a38f11166b097187272e88,
+            0x28f60239d945991b837eaeb4693d496be520241c8b739d3f21c7b838ee0f946d,
+            0x18ad1fe91d4530ef15ee77e9ff06e2d3b05564aa44613bef3b191f6b12e1bd83,
+            0x53844fdd99071115909fc518f92c7d0d7ee91beb16180cf9bd158d33c8679cc,
+            0x28f997134ae9a3be6b79f6f3257aff2498774d1bb18f553b229f70076c979ddf,
+            0x5dd57491f096cf44399e477bd78c20fd872d357f5d1d210873d01d3a014bfbf,
+            0x1f1a859e7cd1cc205ba1a1b3cc2bf04e0b24d32a62dbed89e59e2113d54e0b37,
+            0x75f98af212f11e1de886197216bd78258bb77287937f0af8e464f916d7ce5f2,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x128d5ad7a08858a2ed8c161997ed55c8ca8ff495cd27ea475983d1715cc602d3,
+            0x75c499dc0dfb0ce2005e7d13c1861e5f375e03bcf06951de3239d4b56f7868e,
+            0x2917faec22c04d8b879d4490a8ae7a9d9cf7f3fcdd33634aabe189b50710f87d,
+            0x1a86eef4ec1b75a75d97e62178663f995cf6fdf3913595632105284bce7cc346,
+            0x65be02d94e4417edcba4b6b68675b107a25462092e90e7ea887af7870c0ffc0,
+            0x2a1d799daf1e300abeb7f5a66264360c7984ef52c9b153f15411f9c62ac84d87,
+            0x17c036c19ef8085449f760a6365e814823f270ba4a5e41d2ce4ae1c653f087dd,
+            0x2151cb617d9f323ca37ce71d5c77ae83c8490057b9cbe8c17f150945893382bc,
+            0x24624a8c4bf96cf50401f7361f74ce162c47ac803ed9424b7bbe4d7465d9f20d,
+            0x2c01122a63dbde586507877763b572ccfdb59f2055ff15ef205fa8487f82a3a1,
+            0x17a88764e660e91940993b5efc7d317ca4d0e28d7dc164f6ab6e8c0fd2bd111b,
+            0x2287b5e929e98ac38199873b142845c015bb20880cd9a1d9316a7027a9b2d208,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x25527f081eab2b3258ed36e0a72ebbfbcd874e81c49836faa218b94c0a330b87,
+            0x186169de0e37c01f31821e0909bc4c7bec2129acf9a34948cf7a8ca58c9b57f9,
+            0x6d5d287a7a8d09650979fd72764614e0384a22972d86d191d1255c999d3daa5,
+            0x2c1f7628e8aaaee261c58c8966f5cc90e7aeb1dda64d590228e61de098e4ecf8,
+            0x1c3761c8c7a1ee1f98871ebfaf81b0b89a5bd53a69966681681bb1352f1d4fa1,
+            0x14d1774293d8bb21421fba59295456c98e3e9afd0c9858d6aef305318707e365,
+            0x1df2d2c614e4fe2a6cae058be1dc9e56ce12171c7c3bc4b9d1e76b1916458f72,
+            0xf27fd9322adc74859d8b58e4bc2595b276061b606acce303f2a90ae404beb2b,
+            0xa2aeb992439b6e372a606b46e95bd4b52c2072e6fb28c0689e84b5f444f7a99,
+            0x23e0b17792144b002252bc0490e7640a3d47784e77db53af09de2f3dd650e9b7,
+            0x2aec9631493082d844e77232cd2202224fc38b2eb0d87e7e5e62c11c5af5d006,
+            0x131847cf279637a5a337815fa4f40d51251f6e0174e59c5ff4ac4cb35e2f21fa,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1c8f5a7ebf52e4504d205b2b92ef4a87c99bf55fed83fe42edf01645332dcec8,
+            0x1eed962a391acaa8a59d90d324a9ad8447d898f4b516db4a289a4bc0c565fdcb,
+            0x2b7c65f02b600d4cb64a49b484840ebb11ed7e99a43db9113ed92bc07d2ac4e7,
+            0x2b21e821c34c25f6fe3b027b3f9877d0966ee34e7224c738f0e1f454ae3e6d51,
+            0x2331843ec8156532e5fc129b95d129546fe5ff9928bce0b17964a9fa4d8d16ab,
+            0x22dfdad5cbedc015829fa14df6356c60037761a018d0cf78e13d3805464273ac,
+            0x292c701ad0a3bf427a33e1bfcd073edd2cb8b5e6e949906e6efa9356b471cd62,
+            0x253d7f1f0d16d4a21b0d14d04b927f0ad96d348e78a7e36107a9c2481f51c587,
+            0x12f89c0d808f729c196c25f570d2027925fa37a17f07d9cd86b366793b5b89ca,
+            0x28739fec5ce7338db7feb9b2996877e00c4c5d6f1587f24d5d165672d727d4b7,
+            0x2ae7492c4a9864de31330c131c06f9de5d50bbfa4b6ee21132068d43e00d87d6,
+            0x22d24c6c5b0ddfc162fe02b69859138f2428a54ee04d51b7d28db3dd1de5fe75,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xce556d3d5727d4e62e2716588f873bd595b1c1a31499dacd96b724c4b7a0848,
+            0x2e9e730ca4be19d180bc945c9284a0ac19a2d1b6523bb1c0ba4c105625e428f2,
+            0x662d03f6ae59288dfe205ca54c24f7f33615c42212e9e759bdc519a37573214,
+            0x130fb7df8e39fffdec5284ca63b4bfa2d450757eeebc88a4876f4538bd398d03,
+            0x16a882ce517234ae0932404d34fd73070e27a824e337e1e99eb71abd536a9673,
+            0x29c0802ac349b823b5b63267ab07fb4ac43717bfdd344a22ce4eb347dff10b8d,
+            0x26a04ea7406058bc1b0892ce3a849ca4d4692db13e1efbed22eb8846f62700d,
+            0x190401694ed647aedc22c5ddcfa7e5c0690182d5901c6cd17e72d053acbcdd16,
+            0x210d51487ac153bd15fd95e70ce61c1760d2ca4ed3c8904a85a7be721dc2593d,
+            0xb0b2f1b7b01b969254538e7e34f31c99abb093463df48171756cb005641b641,
+            0x28c21cf93221e40e088a37b7e8c4e4f6b4eca3ceda40ee4b7307c9940076206f,
+            0x6131acfb2371ead4b47df9a6f6e7ae744931224d78ea55cc67caaf0e5804ae,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2bebdfc924b28a04eafda183476a1a5add23075c9d02b679e1064e61e9482210,
+            0x1faf98e88f5306663b31fd4e1e346eebf6e3a1cb1f21142e2c22344f2adb72d5,
+            0x22cb488da424d56b9878634ac766c48a306371ab23ababb0688e9fbc2bd2f305,
+            0x1ebc0f4f5901ae74815b159db10956d58d8faef0992a2c2cec68919d131a0c62,
+            0x29c4ecf2d8c9d693dada0aec9e743bb283b0f02bf4ccfb0ab8fc3fd7fea381b8,
+            0x2c4a092b45660f079277c81df9f8f3a7cb74d3603bc839eeb2fbfd798398919a,
+            0x145c56ab4720f6ad4011ca83e7a29a83fb11f6f1a5f9fbc2782f7ff4f7f18618,
+            0x2809c4d7a6aa62cf849cd656c9f76c7ebe815d51f180e1dee45cde9714261b6,
+            0x14881d4e8659014f6dbdb9c1a45f273ff86fd6491a729c1b4cf5faaad83c1319,
+            0x2e10104a54b4dee285b186d2ceebb3c520a6f08b0f2dc3ef071aac189ff90a6a,
+            0x1aa6d9185256a7da783e9673f47a57a4f1a539ef39f3f7f1686995e7f6de9011,
+            0x1433a78ede2442f29e1c90a35c75945079ba472a07a5fff22dd632611f0514d9,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2113235e983b253534d3373d425b2e65ad758d985010990e0cc4c8c0971fddc,
+            0x2bbe5669cac7d09050c0479d3b77eb9d91f22a19776d9e396a4c79b90cdb6c80,
+            0x251dce15ba53f2fcdfd39448e3ce48f74bce1d96cc2b4cac2383a40f45918c5,
+            0x25af3b31579c2c0227ce1fbea8085d27d1301236e4a469f154422c0c00a3b47f,
+            0x101f2400d1e814d019a47ad9bd6d800b821c2de5fec03914276fd7413071aa3d,
+            0x1976bfe37936541354a1d66197e6a7818313cafdc2f4889f7647f808fa4a7b36,
+            0x223ac76deff06a630762ccd8db9391023a783e28659eb7f9d57223812b6abd2c,
+            0x2ac83b6435ac467384d3fe77f06d349c66d13274d40c37626c0e186ed73da3a5,
+            0x1075e744bd71d84cd204e4652afab236f75fa604f833d02e2ac15f06e13ef92a,
+            0x9684685d0631b2170daaeb0e82af4cbd5c2945f68dc758f05da1483c2633015,
+            0x292e0a7a8cc10221f67d029c700ac0bc1a9e41dc376fd1f7ee52b1aced908f2a,
+            0x1592dd8fded27b0499c5d7b77069e8eb2d27ed4d0159955db902ff47cec50d1b,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x116530f4782990542c91156b83b5283f48a5b3b96f4cc9a5eccfe8db89446397,
+            0x20792a7c07e235c08d2cc9d5b4ef2a93b7ab876d9f646d0f4538c7c1ff354fbe,
+            0x1c934293f228bc73fa4b8d5af9d93bc21b7db38e654c0f69a82e6d53a3babbcc,
+            0xadac0d1a0eb882f325bcd49c617778178187541c3f2b877c9a6e2e200b15c29,
+            0x23788446ab58d10e48572e52577108cf0d9fe33539bd0e8ba8d635c0d135b409,
+            0x2745bd6d0a95fe5be2bf988b86fdc7d17bdd6323777ffed4b0ef00e692a591f8,
+            0x17cdaa3978f7d9243acd9d66de86ad0a1bc5a2767206d506b43fa8df769ee178,
+            0x1cacfa3a8850decdd65a7de60fe3d4b063b9eafaa858e4455d6b0da518c6b221,
+            0x2291ce130877baacecde1e1932143f97da67a5c3b2bfa99ea099893932fd3e6f,
+            0x15adba2fc3b14d20852d217be0744d63363ac5bdc8aefa6be3d94ebca832c3ed,
+            0x150619b091f5304ccc7d367cd48d4b878a2de06dce5d9d7137ad6ee307e9cade,
+            0x6bcd482b40a5463d05a49cfae4907c05872388694c4548377ef2be93c2b1499,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xc678bf7b43613dd2c36546b68ca0dd3890f78927c5b7898a79f0051aab7199d,
+            0x4d55e1ef8446fdfdd9659d06180dd772bad31738654829e3f68a54625342b6c,
+            0x17451474d0a043f2ecdb1c11311e7848637cad312badb49664776d9947a25578,
+            0x166f2116cf6846c85bbe1e4c78bcaabb2823e0d4c0c27a6bcec3f1c1c3a4b001,
+            0x1d2d00463d86b76474ac56cfbd0fbb7f5071c792f61145f1ffd1568645e83f39,
+            0x52fa6833906fac636cf7a1bbe3b6d365f16d917e5786ccd1f303eff8439447e,
+            0x1aee2e06db5d4e2ebdf163a8d1ef89b70510c37acbb47b5a14d0c6496e66669f,
+            0x1e4d0a71dca74b2d4c0c403a8c99cd9582611412743944d25b97ee4108026fb9,
+            0x1a31ea0102b313bc96cbe558f0fc662425e25fc5f9395a42a051e927ae3fa2f3,
+            0x2e7d99fc4631683d67b62afc214c8e89bebc91b4adc4625c70fc5813840b9bc1,
+            0xba02e66d788b4db2c10e4b63344e564cd24c1a3e7e7f3b5c8c0bc50f2aa8051,
+            0x1938e6cee09167fe4f1b6256929ec89307fea623ff00a4c15993fd44b9b9ae2,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x24ea9e2b25c1d10973fc2758114ac04d62292d75633e5a98d87d42245d3085dd,
+            0xb7f3dadf80c5be4a9fe724d8c7ef9e4b4626d9e8ad61295f9482a5bdc1c6615,
+            0x6d9a25f5efafbe0738e9c1d8e291d7dcc6e70434973971636fbf957353545df,
+            0x57d08da194c641d1c1957a6ff6ea5037640f6b2910f854653c1d14909a73b92,
+            0x1b1c3fb5c7160d87cae56ef5a808308a5188abf94b4f127411b3636a5098a628,
+            0x4e0f9b281f00e246bcb7f3e5259e4554eba1148b92b1d464727259267b599d1,
+            0x1f31a5baeff037edd6912779c79b566c6891b55bf02398c2a2f1f40a41b2aac9,
+            0x24ecaac4d6023fb27cb5836794e1f821f6a61924d14810ec882e757bb5150709,
+            0x151f138379a4341cfb1a1fa09bb3fc4ea4f58f0c0213bd2213971fdcf1791394,
+            0x1f8ffc956b5fa5f6c5700394e863341ded45cbf64199185425651e92564c2fe9,
+            0x17ec84b7ec93fc7204915e7cf163797456992c8b5bd1ce3879ff7238d60627ed,
+            0x3a67e721da24139c6203edf65ee56debd2db5102b2c193aca10c98e70cc2354,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x199a8c4c63048f8c92b96e2fe73c3ef1be1e2ae312bc504cd6edcad0bf96967b,
+            0x20d5d5315614291c431a1f27ee637d098c6b2455e019872a06bfa9b1322bbc58,
+            0x204e87cda44e50d72b36c9a0bef8906abb1471cb4faea1262bbe1f148eedb60f,
+            0x1ae0dc4cf8615efcdbe69bf7e65863b9884297d7320b3d2c9abac80aedf519a,
+            0x19ddcb6e703520397f566c8969b47605f907fd733a7531330329fd07d0daab63,
+            0x224f871490b12271549e5bf1205ac16364f8c6f9cbfda8214068b69f3b58ca57,
+            0x305888f9b716c0aad54f0ce4ee1c74052bcc42261232cda96eafd2c17faee5c5,
+            0x797616b6e3a31ba4090fc46bf370854483846428e52ed4fbbde16ecdb407edf,
+            0x10d0c9c192672de1a9ab86b469c6c9bdf474fd4c077fa2b27e702611295e06b6,
+            0x1bbe4c061e88ab93144f0cdf7873acdcdf695abe01712409f942517bf2775c29,
+            0x3f37c5294f581af0e0b407e1f1691acccc9b2f0fab04fc68d968627ce38fcc,
+            0x10fd1cac0351284931df18b06d6d8baaae12879304e6567e96e024258a63d84c,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2f4ce93fa6f69179598530075c2dfed92480e40b5082c1e4d0884a6e5a970c95,
+            0x48aa1e38a66c3d656ba67124986f27fbf41e16d1aea5d66b56d7ff786a5411f,
+            0x69328b6c9761099bb94e1fbaff46a4643a6d52c2826038bfbad2b96aa800a55,
+            0x18c5dfbb9611df4c176034f538bb3355c4ea9a34428b568b3d5484264fe2ec7e,
+            0x250964c6e716f188f1a060bbfcc20bf6c9c575aed8eee7a952883875e3469e5f,
+            0x1cafc40f71b4ea55f7449981d952e200242a375056b3ebeec542f743029d3680,
+            0x1e345fd27b75da9f73b66d7d11fe53bf4d7d9907194ffff926b6fd73650eab00,
+            0x1f86c19a4e41622c5cf6d297f3fb0966d1ddf28c14c2ef296d811dcd725656bb,
+            0x67a9ca314c1b989a258f5306f02017756676c8555e15e331674dfe2de960aed,
+            0x1a8c2c393c5940ee66a9fcb7745c711183ddd8d5336cd2b72880d1534fbd954f,
+            0x2d0fe4e3cea76d8b33f29cf85eb4268e0097270b955369782adf6f3b56a2762c,
+            0x83f71c1657f460360ace088b5682357e7d591b331beca39de70e7c057acaecd,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1029b4658ee5d03c9476e1df7b7ec5447dca910ddf67e610247695140f7ae6b,
+            0x2d2fbe8b4aa2a78e6d15b471d034a31c0710a8cb23cd64bf8a105b0f5f6c5088,
+            0x2c68d13a038f7cc21d4035f2fae3ce2e44b06076755e64dbc95a48ef8fd32ec8,
+            0x255433e441013f28b645c439abd003cf216195cd6ac89e9cca3a2605e2afafe9,
+            0x2b6131efd66fa044954f1b2cf0798c44840b9ac5f91f73bc1d6a435d192c0606,
+            0xc50cf3d47abc4d5094e4faa45ef8950e9f30f6125953caabe1240c70dac54c4,
+            0x19ac7bb02c466c14f957a8683f2dc7a0f888f0bb9f233acae0568493f353b438,
+            0x134932780855ca4e70db189d5439192d257a8560daab00be7ac2bb05a5f43d49,
+            0x14652e3f019f18958f6e8c521fb5b375f755691cdb4cf7cc5de4ea7e5443845a,
+            0xeee4bb3c7a628fe38bd14dfa58f7a774001261e2c1b0013b8abc115e4059685,
+            0x1ad10967a8fa3bd36d86621d021c46dba709ff285387c064ae6f305cbb0dc77e,
+            0x6fc3833718a4e8937f1151ced67bd1059ab386ffca63596129980ffe0ceb943,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x16d751a67c79f9914851155d386e13b0058b4682283da2d2078704c75576c7e1,
+            0x2ded2eddee5893bd27e85a03d6501a2968b3ef18a20ecf50642d5201fd40252f,
+            0x1ac7670ba55f7ee1c2ee56e825e80ee2da811ef8fa08b90d8beeedbee104929b,
+            0x64cfb658abd66706a012f10e3f27e0d8c9b83b3e8e5234774dfec5e1202712d,
+            0x806d16963ae96badc162c4595f484fc6a8cdf753d18d336aff5b24ce1303ddb,
+            0x148cd069f578f6a864c92ca38fad53423c9a8792967e44378305739c39c3951b,
+            0x1513984d0c1ca0b24ab794ed86a4b94f4750a3a5bf1977fb6feac9afc85f45d3,
+            0x51f998093e4dbb4e7f8e410139a65ea44764f0d2af6ab5461b34717a9561bf6,
+            0x1f87df4d84ecd7b55bd03728de507a7c5409886811152634e16cd2d35a18db0b,
+            0x956f375546f0b19f6d2f31c5be42795b17904341594daa5f98886bad442108c,
+            0xf17b03f697af65662c25f3dc43f1f5e050f1ecf009ab004f3fc632938130339,
+            0x2d40326e94d3dd13c0534db03b0f6ba6ee54bb280af99fdd05d1cc7c94c9536d,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2b0eee4044939efed29b0a5002b16ab0e02f75d1e193a21787d6a7f93a018508,
+            0x1b59d055ed845b4c304fc1e713c622d1dfcc7eca8fdaa57f38d7182d52b1b4a9,
+            0x1d2d4adfe8bf73cebefe07a088507412eef5a1efc020c7e3c81fc9c6a11036a6,
+            0x2857125d19ae926856a3ccfcaf70acf2b258f9fad70fe242f7168ffa2d02d2e0,
+            0x2f1da0ad4d4cdbd868691a65495006eb3728c6e410a57db82f874671f75d7c81,
+            0x294d34350a9bbf726992bee62b3cd7d2a333002340a4bfed74f6209c4b6173ce,
+            0x16e5f374066b223ca5a2401f102d65f5e7fbd677905b2e17e568612ff96b602c,
+            0x17c1bc44d70706417225c79dcc9db569c79fbea66c018f2881321c4877b7fc31,
+            0x264cd13057b3635518ee4425f88edba986a49776e94760a4d73b17902cc0d359,
+            0x2b8fa1e65fdb45989701a0f231114c0ef7a8fd3725c62070a9d748e5aae95827,
+            0x79f16e76efaa3caa7e2f266ae7b3f1bbb54a6ee571688463c9d62b17acfd6e8,
+            0x1c5a6ff0893053c43c552cf41b68b48a7759e63d0fc6069d2ee247c170f71d25,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x277dcb1f82810d091b7dbd02eba6e8edf5c97b08407a469c4ad99ec0a7938a26,
+            0x1507357ce338a6f1c5f01907a91c62082e6e5182cd8b8c47f9051b2cbacd5238,
+            0x10d9fb4dc60b7064e8d6ec643727c394da7318244c57696bbb473e2bfc273cb0,
+            0x51cdb7af55af1483816cf02db477c5c21a2e16760ac17395417afc92cc78979,
+            0x57d7491951dbf51f0b1b05406e58ea37d61518a67546fd430178a47e5c34dc0,
+            0x1a512039992c0d21bd7f2436bad315a3955b38097568c306fa92e603d4129ec1,
+            0x3047f751d881408a1f583df677a7313f341d0d90150b0031bfdaf5a17c1a71a6,
+            0x182d95d647c5f27363818039527bbbbcf23f4c143f6bb98b064daa5f09d127d6,
+            0x25973c85813c7ec78b26bd63395f522e0f8cfb0fa6a82375b9b65ef0e24c2aff,
+            0x30016e4e94afa204d5c420908f1aa18fbbe286a9512a0f7dd492b268e2bd4d0a,
+            0xde8759915e7ab1ba0347e7d3cead6663449cf3e56dfbc87b231f784a6a16f6c,
+            0x2b3e7d63f286ab49bb3ccb30f9a8d337c2a871799020681e7c1e5170569bb6b6,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x22f6dc515f2a6d844a494d3c307ec715cb4ac439abab7badd9f0084ce1785718,
+            0x1ec843ef7fd4d4078d3c68f3f699197d1818a3321f64d15d940ea6816db2d4ed,
+            0x27488355bc40e3b48175e215bb7937413eb1fe296f51266e42d421d1d744859c,
+            0x2e5cb786cdfbe0c74b05fcc700ee95936658634d6bb9152251e1ad38f3ca6666,
+            0x92f4b8b30e895442ee3f481121a04542cb01e9a458f3e61c773328e1b887f51,
+            0x2943525f7b6302dcbdabfbf7ac5c27c0187bb016069c33b3947becc68c00a873,
+            0x22a61651f69e2636019411d42edfbcb0cdbcc3b1c0f5bbee8ac9baf66b1b8487,
+            0xcd43ea643c19e6eec4448fbae1ea6c40dd9665d93b04099658f4e216b0d7925,
+            0xe6fb9ac72a3c4754de58d5b4ebce0f32aa651db3d14d5adbab0edf79d746644,
+            0xe18bf3657ce59002f57e8a25131e39534ade10d742313d81f02beca3cbef04d,
+            0x24d31ca462d9f59dfe6f114bafbbd67bbc9fb15e260bed3552e06e559bc049f2,
+            0x1663ec74cf67dbb8e668d7eac5c8bf51c5742c090f7a707e297d44a0e300b093,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x159eca9b923d7cbe5bd8ca7b3ded11c3ce6226130a63cb905289e0f02a5351cb,
+            0x2abbc33b435baed63f3c31aa583ebf8061236d423321e6ca666d33a0159b1193,
+            0x22798974294faef1e314beb8b7dffae46b50276230b06c98069b742d5bc789ce,
+            0x56841bcb1c18a70dd298ada142c577a249b7ca301d1080a6be5a621d604f15f,
+            0x1823a55887acaf96966399d381bdc7b8a792d40d71e5c5dc24a51d02f9946cd2,
+            0x27bb9a8678b0a2cbd911e61b68f4a6928ec6f3db90fc28884af8e20ef711842b,
+            0x1391eb35e10db17d84b0e7dd45145a754977c4cbb90ed1bece966ab89de71f10,
+            0x1ddaad4930fb9cff01affe0c6bc2034acbc20df09fefb4fea7c346dfadcf99d8,
+            0x967a6467b486450b51ca8d529d6aea1efb101edf31f3646efe1e969535a6a8c,
+            0x26edad91bcac2202606d579d3682ee71417af365a5bd3cdeda16158d0059f32d,
+            0x9c8e2fd871c35f3448ee49d7e7531dcb5301a6e748809ee639b152896773878,
+            0x2de254340f39689fb3c5e3740c1d1ceee26e8ef87c64c8b3ef5eeae2712a2fd,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x229ad4c71354c4b2ae2f011e374de05f72548aac7f407d8f52f00ddb74f2456c,
+            0x15d1ae9e3d615f8321be16db99bd43b9231dc51fca7ae9ef2c1ff50cc948d5e5,
+            0x1ad595eb60e44bda1591a4a7ea6facb03ed18e8e4c7fe44aa4949c176b3fdd93,
+            0x21c6b958e8a24ddfd5686e18a1b1c93843ea3efba13869302f46382e6a57e567,
+            0x1b4643c47be36a9608af217edbf9b2138045e295b062dd4b720896c55c1980e6,
+            0x44415df1dbbaf342d11d905f569a68a53cdef58ce2bf19503ed0d032ad3cb58,
+            0x2b1b266d410ad7a8990d350e5be5b1be70822f5cf0591cfbc00302c6a1504fad,
+            0x3cf806a68e9ee25ea00b57abdeb9f4b5ca199f9af3428a8b5cc87db1efe81ad,
+            0x1013c9c92352dfd09c3e6acaaffa2c44923b35492c5691bc7e9e734072fee822,
+            0x18afc92340649e0d9608aa526d2f86866d4bc5280c3f45addc6567b8339286de,
+            0x265cff469832ff20e35d2da4e50505b8e17a4eeaccdb516f36f3a71fc916a82d,
+            0xc83c2b9df3aa4a874494e329206968b89b23b02f35258788e9bafb43c47c973,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x10bfc00fe5269d28301b200756e26cf1281be271d1300b11d988a9ebc062b10a,
+            0x303c1e41ec4614539b4edebbce405652475c1282eea708cf2ff39ba8aff4a4df,
+            0xcb8f9cbe9420f6adf09e987a8bb44158ffba89abd7a738ed54ac6a95f17500a,
+            0x2f0cb3011c761f84dc5b01ba7a89194919d06f94304fb99dcbc0ad7a7bfaf796,
+            0x10151a6d8c2e4d4dd265b3ebcc0e778aaf056a02139fff9c2ef25968dd2abad9,
+            0x1e50838bb4dc4ff216abf8455b8585010107e2d64d1fa600f6f3408655d36fc0,
+            0x528850ff2c7ccccd074baa85e0989e57ce76ea60b697b8ff19c97f1f9b5771b,
+            0xda83be0e16ae4edebd1fbbd5b3003486f5783bd79164ea1c6a4fbd945a285b,
+            0x1bf809aaf61005aa262952e1ac2141e5a0aa596fb9d828cf2ee2639b59101e65,
+            0x231a51ec8565bb72d6791bb758f8abbe5392ce08a655f2bd03f7593a026ed371,
+            0x227aa3bd0866433629f3cfd228e20be57f8499f4a5597d3429c40eadb238f1f0,
+            0x272b5a76f45cf6eee3210ca6df476b2555fd79fd06180b3f7eb546bdf2e9e4e8,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xaba393911c001b6e701b44726a176bcdb276d02d3eff5e70b0cc16aa7570958,
+            0x282c157f6cc7614232f974eb110212f786134a965872ff9ee9430cf05a7826a6,
+            0x16cb3b06654e4997a543284ea7d12efa7b821e96889b0dfebaab9eb705d829b7,
+            0x2364c3f74a3b18bc2af5f89126552fcb58c80ecee9c05c0fcb4e39332dedb205,
+            0x267b1113aa1f20f45d5bd1e042290c8d1e7e7b4b5628184704b81f894d07fd0f,
+            0xbd187c337ead48b6889b3e20026dbf604729fb27460fc1b51b7b3a03e9812e,
+            0x2691351a32661a9080480e51d758cf0e3bbb9dbc43e108293576c153dbb92654,
+            0x13c49152d941d3664ef620a47f29229b8b41060b9ae5880658772ac615f6c48b,
+            0xac5e68b38810d5343dccc099076b7ac9388c25cd6a2b2d182800156ad18b438,
+            0x18a7e5e6e2f6d92c409fcf6bc1978d963fa8093bd83667a95f19841f1a826022,
+            0x1ee76fbde9ff833d860abfe09f44cce584cede5a6a20aa765975764d97c3c38f,
+            0x29139e18d16666687e950c7f417aca14588356d6737bb72d04444fe31e15c292,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x27ff4617698e6b395ced6d0e40bb327a4dda5467ae001e4ed828713c58e4cf72,
+            0x1faeaa26b9d4016a7b060a1125b5b83e22174ac6131c860d77c34cf368d4d5fa,
+            0x116b96192f543b8503130b1bf684a9bf282b41f400aad0041777f741f97d42af,
+            0x1ace40f357a524887cbc0748e9cc2bd2f968a87ef94468359c48fdd333eaffd1,
+            0xeb90e74f33e537563c4c2f8633e6d8f8d2304266741ab5b0c0c97a89c4f76b3,
+            0x15f692b65b0e4a2729d1d07a728029a22e6aaf2d8013a26d80ea2f4ed7230b2d,
+            0x199c258f1265f41f038d234249d79a9d7cd0f435355f9c9f9d671d12b3d81360,
+            0x2aa4870dc13bc48b19f3d7ab5df282f855783d5cb1539cf358d235859cc38328,
+            0x2fa96e08d4613eb78063774846b608be0b7014165df4207b83217229d452336b,
+            0x1e45df6508abb41b74eef391fe603465e142e7331c1a11e6d1a6dce3b5af459e,
+            0x157326de3fc278a3ab49527c3bbd66e6944065a068afdab3426acecda2fced3a,
+            0x13cbb184686e4e800c03d32b9bb0e86322c0547ff70bdcd6b6dd622fe9cf772c,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2195bf264d78f5905511e946fa2bf8fd1c31e251405f24edc679fdc2e28c4935,
+            0x2891a04c8c9333c3f86cb9c27db0cd4590b91574f283d98d87588c5329070ff8,
+            0x25774ca47fb81e980d6024bcb7849e10bf90974712f1c15b3c5e42d48a990b32,
+            0x19afc1bfca44fab6dd8cf347d13bd9d679a663ab864dd7474c095855a69489aa,
+            0x2a855f347153503391af5cdd8f33ba84d9b7f330c5d71a3d4d1308aa36ee1f5e,
+            0x2169a917b5586a2cd1f44fc39acee8a0af21c0b0551fe2823662087b50d3e183,
+            0x165c3839b46f2b8d9c94cfd1acda9fe4cb4b37b64f7530324e44a859b82c083f,
+            0x12bf9acf97c5d1b2c23723541455fbfa679d3539879434010843e578fe33ba26,
+            0x973d4990abd501d246a5bea2b5d467ae07f8f141968bc7049a8d7d100b8d80a,
+            0x281a0f1018049ce5560aed11919df7e93c341795c9fb1ea17ca7f6e61f56450b,
+            0x1607dc7766404c513850fdefc9f3e25d2b9f6e90b4f566418fa142b787ba1d2,
+            0x100010328a776d1e0c53f55c79556f12bee9f2fc908b0b19b215253b91c071af,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xfe6e334c004b36f6a9aa7a1695325b8413cc3a527fd77093960d6da1da678bf,
+            0x192c7a5566dbab04d61dcfaf9675cc88833477473f0742c7df458dc0c72492f6,
+            0x16d9f79f4e2e32895e9b7d3a13cba3f9055c22ee00fafaf94cf1a2237279c28b,
+            0xb3c970c3abc81a5c64df8177d69ce62aaabafe4c797eada6f8724ed59924963,
+            0x1e3480b6b43165f2e9e98cdc6b1750c9f8552375c746fd9318f6e98dde188146,
+            0x3ed9978d698020e1627fbde78f83dfd7267a525315d03c27f934a04901d717f,
+            0x14f962e4f1786884e7ec52bda63442115550a7523e9840ed60e8ce1d97e81c27,
+            0x352ef9bb93ac53fbf0cad44a4c9f359d8be239da7c8da512c3b8f339f1eb8ca,
+            0x1d7daf3d516993cdf2ab5199f7fa038ec18b7bc1d7643191dca490734b41162a,
+            0x19c4fb9c7330292b9859c4471c0558692ef015cbd58c7d6b9f8f6a61701055bf,
+            0x22261c2ca798dbea2a989b4959a6ce59a327a1a5817ef4d0c99147d79e119d66,
+            0x1c8a822a7cc949bc91f32624282c0b91835aecebcc805add937f2c33ef2b13e0,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x241eafca2ffd1a89501dfb8ee9f6b91c270d2edfb22b77f5d96b64c074972866,
+            0x1ebfd44d328c120e25331359b950e96faa3b24d803cfebfc3fbdb5aec7d3f21e,
+            0x1d45f9e955be39be29b72435e60ccb82ceca4dd1f1bb242ca40461f9966dba18,
+            0x3e68e982b6f9a1317a8c72d1519c8d992747107cd1647f55cf86f1274921934,
+            0x24d58310c23fa88e127678cfdadc69ced4344aa62dffda5d17bfb5cc6cf92164,
+            0x277159e31996dcdb712c9a030b14b40e45704c9debbf6c83381d23b98277564d,
+            0x3fc9ff00ba6b7b1584eca5fb9bc2479289e05be8f7fae084849424cb08a1412,
+            0x102731ced3c51f13b9f0c571a0327d5b16984151ac388ae71008e062b103c7ed,
+            0x2aec624f610d949b7e050f9240bdc67eb00b17980637731a93401129babc51c5,
+            0x348bd0822fa0e5733e59d37c6c25354a899286210dd11b006b45086b8936e64,
+            0xf7b4685de34e45e8e884726809202d717000926dc62d3373ecdc8f6d6105a3b,
+            0x229abf24fc333d2643cf514ec877c3155b9f5d4563975ddefa179e69e728ae0a,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1e9a882703f9fc17e0b9b0e13c13361beb7f37c04d00ab391d59bff4ea9cc738,
+            0x18ae81de5d561926c49500b4a1c817e127ff35bd92ef713b8becd8ca934e18ee,
+            0xf691c4241640871dccc03e386a591c9068711b69e35c618ae8213a7b976b467,
+            0x1dd3a781963eacb7623f1a53996b79b1c5dbdeef63ba509d264179d7c7c58367,
+            0xe30b8151c59129f74a868583f2da36f7f32cf07d93a21dcb8a418929a3bab4,
+            0x176a4a7f6bf803a3b2d7b366d35468d449210f48f31753fb63d4c50a522f04ee,
+            0x2d0138a0a5f600964d4ba4ce8391caaf610e7b9cb46ece6bac438658e7284606,
+            0x1208049ec66dd8b35cdd748c6b7e54c3dfd4ce63937a8e5f5d7bb55c70bc3256,
+            0x1c9f3c36dfe21664afaeb0f1d29166f2896455fe34a3e3a937767a3de6fb92ba,
+            0x203ca885554ddda35c4ca58ed2150867f677c99a1afa4796fbec4c3ea534b7bb,
+            0x20e28f5d901c425eb6d48980e9f86b212911fd94de850663e4bc4042cf2fb8e,
+            0x8eee40dacd3ba8ca8953eb7713bf9c642327bb96f55a7200f7f19851a25147,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2de2cac04d23e8f84478018e4160a1cf34d66ecd6b4cb8ca67379b0dfed1707d,
+            0xdee104be28ba9a4493e05d14072223610a77ef655f646a8ec1f254146b0739d,
+            0x198546db1f9b3073c570cf4937bd3d716336b8267aeffda95debaad2764c91b0,
+            0x2df10c785477ccf2aad54873a099f7a5245b7a1797d4b7692df35a01a4265e0c,
+            0x38e6b803b72b22d07f3c4d4da85d583d1952dabe6f4cbfad8ae16ffe5aaed55,
+            0x20ff66ad9f9056e8a0c513785f7f1aa1ad0b53ee305429c5d299ecb3b7d3ff95,
+            0x2662e4ce6ef014cf95ae1041e8ee8f25eb02d188a234bdbcff2a4fdcd222fa0e,
+            0x174299b27d180d0ac59e31ffb101a68ebee5b5e17e8ee251b61cdc2d73b5d96b,
+            0x2cd73c6ce46c664bab760c4d73a7f05132e1ddfc0ec113e9b37f9144f7a1a24a,
+            0x1c951a5015ebe45893a92af1b5b51688298fbbba474875f7b9bf97faaa69cdfb,
+            0x1292a82ec348fc639f61c1b9d4f48e1a729f8e4d297289c45deb9d79245a7c6a,
+            0xa0eb1649895b7028e7b286f147cd47655fd9380ad96b12f25d4d50134f1b624,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x153879267fe585e41277a47095c2e71a556aecc89b880549a3e6598a2b679888,
+            0x20564715ed17601ede44b0ddeaab78c07b24d7c384b2a278ae5902ae4d53ac21,
+            0x244a763e10b0ebfdea4ad6e115bfc6294ab8592515a0f103750f23ff4745d4bb,
+            0x2313de5d350a08f83a06f60301627b52170678ec4089d95e31a85ce639d4d3fa,
+            0x2f61c7a357564272a6c31f1d4a2c37d68f947ebae5ef06f0003f47baaf8b2551,
+            0x2ba56182022bfcaa94b28c4bac74fd7bab368e2f17b123aca7cad3c07377ba7d,
+            0x903e97b86b03d63bda9d015cfac4e1df0c7eb553114d6603e1d9cc6def5a2bf,
+            0x17ef136a59507887ee376c9d03155d5638f73695829bdf753f2027c93f6e0ff4,
+            0xd2cf9780d3b8665f07b485f9b61c97ad43523b52b89a216175fb479596b429c,
+            0x2cb10c6713c9c041f988e1d16e1974db3bbf64fa6a0dd716654d2f3d7ee3fa08,
+            0x2a7fac0f7cce1677e53465203478eb2a87f4a5acfd0ac6b10b24261967f265c1,
+            0x150f1a3251ea142ce9c8863adadf908f98b6f4eca4fa8c7f60834ebda805efce,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1f5f9f0a9e7226242aba685459ba2d087305dbcd15238e0d61537fbcb4e8ea54,
+            0xfec778388bd29f1fdc01719aa2acfbbd07873a4c628caadf04ed461a49b5730,
+            0x8fbb80d8ad67e52030c52512f3947eb0fa257e7a6bc97dbc18848ed6843fdb0,
+            0x220ae6fc4a1411f922a67c3d2191d16fa72e4485881f5c44d07ad1b30ff72534,
+            0xc24db144fed773dbf4a285f6b292f097e73c4210b64f60d0471099526125207,
+            0x153e33da5f9393fb14de5f8d9ff25fec63f9c284563c9b75485b8c5965716022,
+            0x28190eec890ed4fb51176a21643ca8bf8a4c6d1ddcdfbda70baee9842e771e0d,
+            0xd352d314f8a649bedac97ade9cbe51cbb4c1d76124bcb753ff46124ae2c671f,
+            0x589454222f880ff67b3b6771ac9579115ef98b4a5291ad1f466c37df59f7a0c,
+            0x707968b36327eb7bf42d881932225d1e6a9cbae3e9a9eb1a3573575b081525f,
+            0x24d15b907584822d94ed3cfb07644a1d9cf985b94ac08fbabbbf5070ca3ba2cf,
+            0x2d51c48b63d97625628fc1a9c265a29f4b5ac1a1d0ba807f3f1d6a729e8d0d7,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xc5d3e1681af8c731635a66d82e8ffa52d6fe9ae4551c31d9ce5c7e9f1482f3c,
+            0x19f573c7bbaf4af57ab119d9c34a976c7a2770e9960f8324bf938e67a40bb621,
+            0xdd53d93a158832a63ae02346cfb050f4aabd93d2c376a694322b70020af739a,
+            0x122168471be451e1fe2383a1a82795668084d4602e136c3533156ae4eb44e5fe,
+            0x181171e6af7921e268f8e4ca02a69df02f99e374f086433e2d8438465b878fa4,
+            0x20fde424afb171516bdba5aba1302f3c40adbc6df6009941ce0978e1005f1570,
+            0xc999a3c07697cd6e4632110862a0e3cd6f2ae7ead5a0c62f83e57e3752726ac,
+            0x181e43350d64b75df7c57808060a8a467304a9b10766426597fb485016642d1c,
+            0x22f941438fb638d0f6e1013d81672149e91bdd794816a149426830a140ba5520,
+            0x27bc96df0a03fa540349df2a46633309b8e0d2935a624c7aa51cd859373b1d3a,
+            0xda6574a31cb0b010480dfb6ad33015708e71c420b8f3664186876afb8b48b69,
+            0x2a932da3d493f5d229a00f18bdc6b13a00783ef10510ef02d3836a9728e75653,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1aa840ec7905fbed4b22675c84cbd527218db6bdd21e9558fef98860bc337607,
+            0x2c5107353c0edc8e05ad36b277477c9d3ab2d26fd43dd2252878ca814c48459d,
+            0x1aced21cae771d0294a1630be67579d81245093d2731898a72b822f8185ef3f8,
+            0x1a24a7fa4d6d5498af1df2f86ca66471a340c4747a1e24f592aa7667346aaa8,
+            0x289caf37dc4c64fd8c66718013fc3f1492b3c76cd1ca713196aef3d95281e3a9,
+            0x284c43505df8fa7ddd6f9ea7464f3caca8a3b3b55d39512a38b2f37b7437802,
+            0x501489e7c91a13086c850a7174848dd37bcb7e6a2f8571ca3086415e22a249a,
+            0x1d911e709cba9411cf221392b1d8e8f292d3895e5cf250977f7bdf724637e7a5,
+            0x26ec755542bd45c2c4968fcc98192cac25bb539cfecb7c16c926edfebc0dd4a9,
+            0x211b3d812f9687467d623861909909e8a579e66c135d0ad0d36038116e858ceb,
+            0x1835f5c44c7bec7bff1c814c38d109572702ee85860c2977650db910dd555db5,
+            0x22bb08010cdd744ace85c758c58576d6b353ca6326e9de8ca594c57b40a76b48,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x178bdbd863dfd248db7cc60881b17996fa8cb0f5a806ba37e818d493dd4d04d5,
+            0x2c2feebc25c3e9911fbcd7c77ddfc8feda0e36b3045e86059eb2507db84b20dc,
+            0x1d8f0924e2fe93b786ea1ca32cd7dd268097e1144e5f386813e40d7de6385414,
+            0x1d7b4297d5b583bc00d946ea2d45e79bca3b869f3889a3ef8b6986ee80515603,
+            0x6b29e8a6cd82571306523e57a88ae2f1c627688af6a57ab4adec48071d864ad,
+            0x23f708026a0738512248c05a5a51dc0f0b64cbd50c98f2c001301a8dada15649,
+            0xfb9b67606d1b70a59afef99cc15b51ccdacd8ac412858e37fd0a5b685aa1187,
+            0x2e507b8087200a7b14d7c84650e5683ef78d7e5281b489d43524206ced314cd2,
+            0x1bec098d210e06aa6b800469725bb7d361da8f106e3df06fd5788b3b423bfecf,
+            0x6ef2b78454ee5f43388a7ea4728996fcacb8c01c644534fa590de1da8642172,
+            0xd5662f25569baaa0b10d66142378f0ff302a3654da318bfa370812bad2a66fc,
+            0x2bf77b6c0aa149a79c695d67d64005c90e926b44890085b3fe631b4a8da64760,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1bd8975c90ca4e356f1c37f12fcec0ef5ecf484736f375f78566ba8aa9e86427,
+            0x2bebb46043c675d8d4b13e9d3c243f49da64640954fd5e194022c846d69cdd69,
+            0x1fb7e54c00e38234348206b136e17db48743a1e8833a4146f905113960314be1,
+            0xfa50d544f0434df48d3dfdcfdd164b9ebd8e57d7a60be66b879294a40a9c396,
+            0x283ea6139b65326666af04d9913f3200f9b93067867be1f2431796e9add5bdac,
+            0x758ac2a306bb32c1030578921fe09a5d40d83d968ec10aad31a15a7c56da8b4,
+            0xf413088d4106e8a46bf7cba046d1f47b7f8a741400768835d853830ea00ef3a,
+            0x466358069d58f4786b2ca782dc4f7a6786fce88983fcf9275b9a5850f814f28,
+            0x1385f23802d6bee8b76743564dd5510ed1200f094ae6c16f03ff8b4cefa07047,
+            0x108072d197cc79b4188436a0c50845d245ccbfd1480a4882af2cc88351d5419e,
+            0xb6d297f7ec667c68d5d7ff7aef48259dde62daeac24b7868e0fad90ab3f3a79,
+            0xc82418faf403bde8e551554f4c8be945cfcd1f78615c9525d3c607930b0aba9,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x297b1a1c6fb19a9f0490226d23936796caa8c47a390ce5e3414d91243adffdf5,
+            0x1d8de05dd33fb6513962f6bf1406d3da402064e2d32000dcfba1aae1d39a2d97,
+            0x19ac0a18a29761fe4968baa2f8d4d4d7a8d241c5fc5cb54a13997873a4bf8f0d,
+            0x13009a2e1be50b353babfbfa0c9fc48341125c9028a93d99b16c31835e2191cd,
+            0xd660995842ce191476ad064a5599e2c5415f48ce57392e66e671a503a30b119,
+            0xe5587ae4cfd416edf434a263c9babb45d793a1b522fc96e7845005f516944b,
+            0x10fbbc420434916261f6ce95d1ca7497b8237143757089de2c813388acc3070d,
+            0x190d15507748b38ec5d8d96cbb40cbccd3cd004f1f500f3a8fdf9d9dd05cffc8,
+            0x70e81c5cf9512b85087fec4b044bcacdf0ebc36939e0e33f12095929b153fa7,
+            0x20577171accc171de1282cef827a5b3f7620c29566598066037947da13dc09fc,
+            0x105c02eabf359c9fb180c1112e560bc894bc2c453941f29e1b52c28c0d8c6c31,
+            0x701986232b2471f9bb70c70941f0732c59b9d1c1d7acd7df2b5c9a3d1063397,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xbd0cfaeacb5343bc71818eec4baa3eb1f73e5ccdf4d4fb1e585b9326794d8ec,
+            0xab6ce9fe9ad13beeeedb535f9cc7bdd51a9edd426a54a9b85b6f23911dbcb8e,
+            0x20f5023d1e52fefee124ab42f5eb28a0c18cea887e3a0bb7c4626ee694946984,
+            0x180f0ee72343b33cd7098990a9bf33abb509d454700f602d23067f031a314ab2,
+            0x9e006f3e85886370bc11a2c92d6b1905da2e1d7389fbbfa8ce2b0c3797b3204,
+            0xcd828a1733f7fe84eb56482b0c373b7bf9ffee9c70933a70782c46104a7abef,
+            0x14ae5043d94b8f236d770e5435d370e07be470537fa8734aa62453ef2dba83ef,
+            0xcfc46dedc8f1535ceabc7507cb5bc7dc27a44b69eb8d799ea037b9dc0cb49bf,
+            0x13d10cd39447e65f03bcc27657ce46b8f4b9f0d6d0d9052eaa700aaac4e56204,
+            0x1d19d4106503a113839685de852f7dfa1ccd2131552e18f9e62799bfdbd394e,
+            0x1c1e57d62f76f88539ab7fd73bd7577c358aac8bfdbe0c0953cceccef55b1c7c,
+            0x19f2dac762392328c37a5a54d4cb980383918297078ca2fccf8605c52f36ee48,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x11104096d51f11f8db806853a470e1f2838eec2abef570a01a7bc833a27526f3,
+            0x203846151d74394d322ecefd82202cb29361192fc6692f8de4c0788e5364bff3,
+            0x2a3214dc89d8794cc308f0b2fed1240426e9095879935f4889f7bce9b06d1223,
+            0x296caa3afab57aff0ceac16ecf05b6887ae6981c263b60b49eaadbbdf5332a76,
+            0x2ca633b28c1343b7c3ca88c3b6f4f9da113daa93280626e98b3c79d6932d3932,
+            0x2c62732b69393a4495154205a9b636650a201271da60b65433419ae8f4543f2c,
+            0x54a20f1bce174b2063f5581a86913d9edb5b6b30de76348a881f320afcd4c0d,
+            0x12dbc8f4c166edc2716c576248af681b69ed94ffa1e5b3b48459c9787ce39569,
+            0x13d733d018ed7c6f4a1e471d7b8a6f36047ac9ca93167d7f0aa674f1704fe7b4,
+            0x2baa1b752a095c0d7552dfb65cf2f568b47a132ffd5000cba2720ba8ac4c18a1,
+            0xdc97cfacd4771b400ba35d33cbebba737c70e84f07d0ca37dba093a2460c944,
+            0x2eb71ba2764a7250281b7d3506deaf0416593ec3428df1a9fe2312e66541f31b,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x24a6b2f63282ecf9be0988f99d0b11798ca33f2c8bcc4e5669bc7a256ab3594b,
+            0x13b074b54de58e9fa17ce6356d3a6da3d800419d9a7170e3bb1310daa4f4f96e,
+            0x2711023ae2f03c0399399775a8ca018e7b91e50fb4c7529bbb09d5cc88dc9d90,
+            0x9fbf1f0c9fc28e92f2040fb7b132373a55bdef07f9009c3aefd13ee0f7b369a,
+            0x2b5a1ba0a4702083424b045869aff8680388290f4b164cc2f022b16eb0e96e58,
+            0x1292c762ad6a3abd75f5ead608b8f2f90f8c528b772a42d750cd244d74db2e86,
+            0x99282d849ffac983bc6cd99827a1d368dec42e7fbbedfb56a6947854f4177b3,
+            0x176eac7dd262c43fff3d935c0c11db3d23b0542a6e5e07502dbcea633ae43106,
+            0xfaa232a1d0ceb281c3a428f3e67aafe0fb1a27fbd58c89b3143f486dde5db27,
+            0x20cca8c39156be9d3b7f3caa041af52ea538f3ec173cccc0b3497aa068b8e1a3,
+            0x146799bee14e96cb93165e30306e78be322d11b4ff008af316286989d648ebd4,
+            0x2b1d7a8ffc222693ea0d5398028d6042bcbfbce6894aae6c79c02d3398fe43f0,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x13a158f9d67d4b35e8187f741513e818c32a15e9ce3d7ad17e5e0ff76861073b,
+            0x2b64a21d911a768ed8f424092d85badea0a141699d41bb31b44d05ca7677f622,
+            0x6721fc051436a604df0acd76947426dd9464034c79d02f434ebeae270b8f113,
+            0x1ffeeeae4f5475d7b8cfb723d7daed094e18949532bb7f47635ea7290d27b75b,
+            0x94d465c413d8f36b86f1a1d2cf263ec81a2588fe3784ad6c7e7abecb2e59853,
+            0x205f5fdead5ce83dc8000b0320741d41c9d2c729ff5a7f0cf8acc2c875cd3257,
+            0x1978d9908c11cde5f456e20e6ebbecb4d06fcd7e31e5e70ac0efabc721aa8a8f,
+            0xdb51092fb5654d04e24dbca267fbaee53776bde616f4f87975b9759cd833207,
+            0xa93c02bfdbe4c17a20506b1a5c56caf375aec6dee3b0b2a0884a48b104c00ca,
+            0x26d4bd0047fbd72369c8f4834ed8144c5ff28a42ae16b56818b842b9b4d6b9dc,
+            0x17c89c980d214a12738a2939cc7fc425406aed9be9a932e0c427991610c0cf73,
+            0x49a23ee91a6c076fe5b135cb6f92a8081c604adcc21c8d6456332de80420263,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x13f9655a5f1532244d4e030e782ca3f9d236f8d302af289b9c0a946376b45f3f,
+            0x271d8aee48a5a8dc6bdbf29a491b31f24c71e023554a92693eaf0bc68a6f0272,
+            0x250f4bf66572c4d089c73f90e1ffed7638ae0f926523295891cf7c765abcc0e6,
+            0x155c20d00e84b634d4884c42359c91df2fbe1de2f75006677041c0e70bc23acc,
+            0x14c2c6a209a7bc6aa6d978fb994d95646613ae8e6b0e0e5f5cc8f5707766c7b7,
+            0xf12be26119ede0fddb6393af22db838f258136f2031fdd223dcd8e1bea243d9,
+            0x2efdb0edc82b4dce032308b04745dd1f1fbbbb5640bf28b188031e0cb2e1c1dd,
+            0x1ff34842585b84d2bb8c9151b3f6c65f48b84a4e34b07f60192c13a6ce08a7d4,
+            0x2d9fc37d4a22c1f195838803941d2f629e69eeefc566990919974d8e7aa968bb,
+            0x21b778120c0eb0974971f5a24e29c204042f8b50a61b785b7611b8c0ecc6bd8c,
+            0x1fd36ff9b7adcf1b3cfa6ab317bdfe9115683da95b29f84c4e113fa6e55c6b90,
+            0x151cf47cc2e82f3eea09b8d6aa86037caafdd0cd43a85ecf5fc3d314380e99d8,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x19c8e29952ab4d0984bf1da922e2448fa9910c0123a999a592dcb473f296564e,
+            0x23331f65cf68a733b5e8142daf41bb2cbc40b2c334b78820e92852637f1e87ab,
+            0x2a7f938a6cdc65be6c071c8807ff6df4c48a36bfbd92f55fd06c057a48bc8aff,
+            0x2c121d40b94585543cbb38980aa3e320f5bb460d165fed90e367f2799cc1e8ad,
+            0x2082427ee8b6508762d08df82f8449c47d4b4b117165ff4fa1ff944d63b74d7f,
+            0xbbf36473715a6bfeb2bd46b4650b2e48b4fabb9059c1d41675fa76d880edf08,
+            0xfcc45095ed5a36166ce4033e91caa2446d9594905b652b7b56bfcbe7fe03ff6,
+            0x270c8e9de025f4460363730d789c1f3dedea3343457841db516e129b670c25ad,
+            0x1e9cfb5b0f1dfd2465ef5d2731a8d5d26b5479cc6b6e438783231e5b0e805faf,
+            0x1884f4ef9e723cc405fe49803473ebda5080731b4878e1d3a5108fb20896d14b,
+            0x182b8932fba285b925b7454327ae2a1aef739b088bfb47dcd675730bd1aafe4f,
+            0x222f2075bf57fc059a247d5e733b3828fec1aac68509a2c0e4a8ca1fdada90fc,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xef4c76e42df7e6d4e71b536872ef6816d62d64c06322bdaac4aae65ce6d59fe,
+            0x4e28c59213cc28cfb7b21091bc98169875e4488188b70a385197588025ac778,
+            0x2d69c1a48c1be2b798dd77218a0653f7bec46bdefb7f55cde3e6d28f56527260,
+            0x198d2bf44196f81d74761554f80cc169eae8e817f44ecb588bc64f6277f1d625,
+            0x13c8bbb561fe1109612865ee008786c5d50158e42d9e91b6f52b02508b67874d,
+            0x1eb37605af262ce36884c03967bfc38d8f625e080c7bbeb4bfca07e25458d12e,
+            0x25cd986975f4cb765e4a8f17706cc4438675bf8ab7b110470d88dea1a64f66ad,
+            0x71d02268b089992a8d62240d94fe171bee083b1a2d9bbefce3cc7c8cff5a577,
+            0x12ee53cf69c9a0be3be3de51789d16cbef35961c6114e4b01244d814a5ced3a0,
+            0x94acc645dc2e6929022f4b4b946e8f51ac595fb3200074cde24b86643bbfc43,
+            0x22af41b2a54ccf55b3030b344dbc82eb8499ca8c67c191d4b6873bcdb7639f9d,
+            0x14c87352fe94d929e26aeedc2421c5812b7fbbcb00a7b20a79877ee086416778,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x21cdd152af751112267ca585f98b2abd9bf78eae7bc404dfd9e8d34010af7c3e,
+            0x20d39dbb9c5188640b6f30abed60efa7c61433e6ffeeaf7cd73bbd2d713f55b9,
+            0x2642c98bb9bcf76eb3b6e3f86c309b400e79071f12bf462c19fc612a89722b65,
+            0x2c2562c294b65505f0ffb6476def69c03e6d1324fd2ed7319368a61c7fc672d7,
+            0x265a567985ea221426328919c3ec1bccf462516e6525bee01d1d810c172e88e2,
+            0x7fe7a2e56090a75757a54a27a15711c9b7b3451536b61e6a5519a3a073a5a9e,
+            0xea63f1b7258831a4f087c53827988f0a5033170186619e513ad470ac9691088,
+            0x1d0082b1e2aba35d77b41e3fca46a4526360eae2d1d49d7be6a4498f315be6c8,
+            0x17c7b18d8e5324867653d44a765f34f6653a43d2795b040900a2e0b4c03baf2c,
+            0x29e0ca8dc73ca2f25b4dd5c756bf5316b25be6c0811e62c2f4437fdb9a7e278b,
+            0x1f1e7e26201e619629f66ae5a3c2e09acde700436c22b1ff505280a62db0e242,
+            0x2fbd789305950579f702ba8777534c2708028a7845173f13e187752cdc5d98c4,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2a88c6c0393f56fa63e8e340f708efaf40ac4b85b2ee681d39ee1aa0dfe396e5,
+            0x20a321497aa9e78f16a5957492e3ea0428d22442056649de52d115b1c73b1079,
+            0x1f00d5da2a0498a2c1341f1698df1a0780c5169111a7b02fef79b0faf32d6498,
+            0x15f194a187cba501891864984a6f52cfa2d4bc63ba2a35f61489c70cd651e9b9,
+            0x5cd85fe0fc0c75c027f4e3f1bc62872153988eaa0b2ca20b0cb5e7fa3a687e8,
+            0x1ed21eaf16b3d661b44df4003cb3636184353d25def19bb04baca933a3142e78,
+            0x2b37b5e88cca20d2bb43f1718091b40fc1ab0ea7350f77a5a0ce905708bcf2df,
+            0x232c7f2de11cfe7ee3c4dc933a0bd034b32c9979b48e2ca966c6a6cbceb82ffc,
+            0x974bb70523301360dc181faffa4a31da9c89a158d446cf9f1d0dd078d681a5e,
+            0x6231c17adcde68b2df5512d5137e4207b5ab127b989e551710a7cc87562fe8f,
+            0x2694daf5d67e6751c38511d595f6ab520ca299dc52eea4783a1c6fbaf85e843a,
+            0x2eb55960ecababf455a49b9ea9db9801a47ff818217381b791b546b262df5836,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2e375ca4dd0623584c0be2078652c7e0f1999eaf84f80e86f6161d129ce76f8,
+            0x206f7162f5d7700b7cce6981f0748ba08695dcfa544eb1a903207220febabc67,
+            0x176a8b69b12a5a3269ee7ef982044b9895baaeb85938900d7ef35a89f93b879c,
+            0xc58b1d3319260e528cc712e2f2a6c606d711cca0b2856a30f2ebbe57d5fc733,
+            0x19b13e16ddad7823e970721ebfc7e4a7c6563a7e3d92de2135873e0e60e750a,
+            0xa4e8fd444448adda180b0c6a3ffd32026f0644911a7f4ff85797d7e834fb383,
+            0x18be2ac266e3d98839e5efaf7ef5f17abdfd6b6fc729e1f18d834e9a383bab83,
+            0xc56583074bd6c3a67fddc94f840cf7b97b35256e00a647bdd7f992e731eb61e,
+            0x28ab1c80f8d8221dccd8818785b995aaff05e17d4fd8f55664b3729715f67715,
+            0xb886b2ff06d6d3db570b2060a95b75e3a085d74c6ed9dd8c4f96065ab77c5b0,
+            0x841d7473d45e77983a689c8bf384015f323838d32fe65cb9991784db323e25d,
+            0x1c1ee3b1346ad2c298b7ae7d837d8cf98af1cfb7a2af5e1d06f0c9a826ab1bc8,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x11e7a68f1defb47369a757ad1d47eac4fd12ec54eaa4c2f3a84e2b97e56697f6,
+            0x2386b42cc098f278197163ea21b9f6758c7bf1e8a97fc99d0d48b329c908698b,
+            0x2d1e8f11167a3889b194c794e8566bb92d1c622807fc519445bb09a92c10d11b,
+            0x1e998707bd13625c95c9599bae3261e67f2d517f78805aa50356b8a5e6792427,
+            0x1c6b72fa7c47168bc0c13b70af218b5f37ed9977f1903c64c6b0317cd1b5f738,
+            0x2f50f79c2c896a12658ba1449023f04c4dba2c68e327ee5796e83b6cc7bc7218,
+            0x4b15dbc180b8634691f763a02187916b21f6a9b230302cdb226c9c20b1f56bf,
+            0x23c08c77cc0ed597c537ad1232524e7f9cde922aa3b9acb7a8e0eecb3f09dca3,
+            0x246b55cb9b404e710f5430129208fd2f7d1c3b71b8d5d1a3c954ca326fd3e7e0,
+            0x2a3c7dcb7f8fa6097e5c00f781f27f884c76c6b7ae85bd0a71ce537fd50388d8,
+            0x268e6eb795786ecaaf037752d214a2422ead74f48d800ed7f14f4b174c53f76d,
+            0x5ac3952618af339466cb8428c30acfd937e76257609d299f1346d72f87ed82c,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1b2b7aacc25b941e4a03f085a09a773154f908b9e5c2d20d3f67779ca448896,
+            0x22cdca81e323db126eedc2d331697df5f2157d052ec4f66e69c17307bdd15692,
+            0x267f9661ee6cfaed2fd4e4c8140c3e168d16232fb26a3c2a2517b6a4899dc512,
+            0x10ce863d93a47aa85b421e17c96dd0b05510418e41c576b331770a10bd4d0baa,
+            0xe26a35e642d56208bc813191e7980bc9b8cf0044ca564b4ff7d92f4a0410942,
+            0x230f6e95f170836c89332e68f4522dc26f56be6fb7079958cb175770aac34fe8,
+            0x1838b36fd6f0d488d9d7029a50a8520511aea9750ba69c8a7f08c711ac5f9ca9,
+            0x4f19bf00ae88b7c9ea78742fff7593867760fad46d653ea407726b452cdc403,
+            0x133619fd5268a1c03b2486e0a7a1ab4e8b83eb2540c2b9f02159c3e487d19602,
+            0xd6268401cc2509a633dce917407f9a1b569c6f9e56063022183e4be7651a006,
+            0x365d7940e1c53edea08251eef9a5529c9337a408926ce27f35d56389f2d0d63,
+            0x125f88039ff7e0df7f265d09018809058d3e38c77907985c4c87c75d8a76f515,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xfa21fe3e0314d2e7486a95e6feef8d81fd5fd1b6e34a456054787fd85453e68,
+            0x2951984c7afbd03db22245a37d1df055eb109e4ac7344127f2c35dcfbed8e73b,
+            0x156bf5310e6b76a3cc65f74c58593ff14ab052dd9d0fc09abeeb4a95fdf0de19,
+            0x774fe420c3ab105f6dfbb8eb0cc6ed4f5a13299cbcbfa9a6e20d01ca5f834eb,
+            0x13a7f1f4fa81d9e5e24d6236110fd39528fd3c216f0dc86a0c79b2c438470649,
+            0x1019d2e8646ed7feedcfc77169f5e9fc2dd718dace5f6f8b9a67637d933a3041,
+            0xc63653fc5eef7c50cde7d0c3856f90e2b0e0fcc9c5b16fcddd1e9740faf9b00,
+            0x1343f7e28ede90c999f7312542d0fc39d1bc0d3c656440b6e170a6f3bc35b0f5,
+            0x1bccca2bd0880591b20d5501ca0e4134c926c5d0d97bc70da24c4c70dcc61702,
+            0x227006078f001421d3488f1bec3e70a69d8a51480ee878cfcfa26a8caafe9adb,
+            0x2badd9b9334957d41b28808cceebe3e3c55807bbf4e7d1997d8b7a71121704b6,
+            0x15fca0d19035e164f8fecb36822f26b07efe12ffb2d831c48e5ea9cc8258b755,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2316c328984e3a8d25f2a26fa5c8d29f762f70b66fd648c7df1248c6edebcdd8,
+            0x14f86a4483471960a505e400b9adb874961582c40ad4f306ee61ca15f769db60,
+            0x22448cc6b58101c266b94849c276c0b469f440cc5699098228fe293a3e15613a,
+            0x9e98ce02891c97faf65620ce63a9279fc5c0ac4b7ad0073a03b8ae8951620ab,
+            0x3d80d14e85f09ebe6840f5ac4f467568686cfc56acef42550d8d8c33677bf3a,
+            0x3d857a698a64801730b3c11467d17cb8568fdb626cbdcd5a5586912e558c022,
+            0x1793c7b3f75f911d0c7f4c64b74e7a1d344a52438774d42922a245fd55cf10e6,
+            0xeefda98fc56b0b2f2467ab429a8e513b5d4ffca2b9355de8b8ef645b14732a6,
+            0xb7efc4302f68263ac68294dc896062831725e4bdb1d2a6e8da2572aa4ff8471,
+            0x2c4b370a050627bca60b267ee3154f0706975b6cd9df0fb5be76162dccd293c2,
+            0x14b35f50c4e9103a3452cdc68fd4db02677bfe9dcc9d7619ef62197878176588,
+            0x2e598155fa34aca3ecb0e66e290d99b9aa080539f461e9734bbace8c72bf2c60,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2f83ce87bde779865b4ccc5eff39d9bd2e8bd0ecc9c2cdea49ec7472976d923d,
+            0x933a19319eea25c52f096207f6d8a2ea91fa531291fcf80436ae6ebb2ada32e,
+            0x263439a31e513a82bd9fc8ce9e074df4e27e59683382019b7679cabe55618338,
+            0x1584ecbb64a4db8dd2d5c4608ed26bda0e0c38c1130b28cc6c1b4308dcf40e44,
+            0x49e790446ad72623caef9bc50395299d0221c2781686a04415190f52b5143a3,
+            0x10b37775f18ed958dc5dae40b445b28b2c4413b5ffd672491334bc73470274b0,
+            0x24701d4ce3d32060677e07f1267d9f7e55d4332b56379700ccf64ee9d57d1e11,
+            0x202b8fb221cdec4a092a035d4e454528eaf0b319d671e60a063f4c0724cd8c15,
+            0x1d43768bfae552891485d63ce8e1c3eed865af9e608b31a925f4a31a98675866,
+            0x32b94736117256d76b6f85a01f3aff1e4d954eaabc9a367b61ca0d8bbd42c37,
+            0x3231b4434df84936a826b7667aa33f161a86607219730bd78142eba4bea0dd4,
+            0xf45de5ea90165e3da111af4a7775204d4ac83dbabe4eac41abf318487b1e996,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2ca2db65ad224b51a8b24e8042cdb875693897fd5503bc751d888f695d9607ec,
+            0x44928f5528543c7f450eba9d4cb5db7e58b8081b98c7f752162303a16af1ed3,
+            0x2733260b5780a3db7cb63e4fc82386491a217d4312c7a93e54707894e3b20da3,
+            0x24f726fb193e627cb10dee649b4e3e2242b94a2524974242835db3e96befff11,
+            0x1e38f6d8f6306aeade802545000b3da45ab90c9bfd2405dbc765d184b91df08,
+            0x8ad1a8e37ea4e152a07cd69de6b60e41de49ad1047fad9194aa32849052b8e5,
+            0x235d4b4258dc982dad9cb9a47a963088a59fae5f730093f1e9ce387abe83765c,
+            0x2b01da9199fa4220f95e00c98cac996d65113f5af19912cb331c53f9c52334fb,
+            0x1eda45b7f8edf24cacd398e7444437e30670bbde613facb9f1e4676b0d3f3d32,
+            0x119f815c307628877d5e222bbbbfec68834f7b1338bfa7688adaf8c6e8c132a8,
+            0x5f96bf0532d7b9065530d4777fa98b0410e5566b6b048b85cae029cb0e497e7,
+            0x340a6c3788a26e7492b9d20754d96aa10ec846f07aed7cca49f234d45988d63,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x2515fb66f81792d13ff8bbdd5c038ae895a028fd5527645f96496ac910d44e03,
+            0x18dee821d0ad52dd6641fa0289b4ca755a70a603c6bfa5bd491ec55ba7af13e2,
+            0x3015c688b294a9657c6ca12c65b33865b1b79556838bbe3f4bc1af83c1e1cc8d,
+            0x14fd24e81aa0eed88a08b4ca95c08addbe4ee861d173dce5289aa6897d828128,
+            0x19d02cb7110cd61dc1991b925320208985e0f64fa145d3017537470c77813deb,
+            0x496cc3972bd13c9f0dd2715a9cc66b770699b0832a8248334ff5d213c5a7b12,
+            0x528b341e3531d9d48b0a65c5d6316d2fd21cd8801adfbf0050e0cf6f0f74553,
+            0x388cd95cf4d04968d3443ceadc7fa242abaf4eca59961cf3c850efb1319a4de,
+            0x1e6588c7ee49bb4547504a62550304ed4d3e5affa5ac8f08b8c0cd0eec44dd46,
+            0x23d611ae14db5a2638609c8212d29f327ce0956038039f270efe1a10537363fb,
+            0x2b86d928a54b3f7c987dcf5ae89d7de994331f200381dd09d12ecb846a7a9b12,
+            0x13055b796975dbbe1e5a913a59c11ae296ab60bbe64202c15d4d6108d086f462,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x14f38d1ffa510f2b0332476733f9fc5c79df981b55acea4a8f0e3b4cc61dd759,
+            0x1f312d4d6d9a3ca368e3dc8912bab32366d7204bd0fbdd3ebc577d3f26bc407c,
+            0xd0f712e8570585e196ca13e8b1f1a2c963063f27d62427af9eaf6aad438e723,
+            0x2dcbc4e8492001dd99dd80175771d5bdbb308436faa08e39f19b4dc21828c131,
+            0xbbfd5086b33a2f0e5afd9be44f7ee3267d62833ae3019938c440d756a24588a,
+            0x2e11c7002202decd43434c9730452b8ecfb543cd892429fc88db33c63c404387,
+            0xa04ca0b4eb3a67bf9f7b699b179d0339883792d4bf4800802aea15318b7c0d0,
+            0x19004be334dd838c3cfec0528bfb1f91db2d10d7d3d3454a5cf35b7f431d9f99,
+            0xf0db552b704894427ab3ada1a9eb881506e592325b73d7ca4bd04002efbc259,
+            0x1a1e713b1af5f35ab4fa7f9bfa19b0980ee21821afd1ab3445352cf784b8d27f,
+            0x179f8e92246a7a24d55045b43b515200227c4be9e0087db3654a34db445d89f0,
+            0xdf566626948128c150102e68c71e6cc60d52112b96993a1d15c43f2aa2d0d5f,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x242d3b170212915d835e974b8f24c64c866611832cdf59aea0f9e9269dd8f615,
+            0x780ab3cb7bf3cfe1cb4fd742ef1dea1daf725d4505f481c9089f9a6a1aadb10,
+            0x224f1cd253223cd87977be41be77930bf651ac744d3b362b302fa36ed0f6c37f,
+            0x4637e287df2d94786d07580a457013d8d54a6c31418d3f3ed4cfc582ef57154,
+            0x2d703aad67bdcfc9855e65f429a8120ea93da66d877ebeca1ac3b1538f2dd96f,
+            0x11c9e9aec8fb7bdabbf3696cdd441207e1749e0d8fdfb21535ef940f68e904e7,
+            0x2be2aaa990f638dcd8bed18d9b76465b1f326abcde1ac1f3bb907b34c6029c27,
+            0x16a6ff3478e400876366dcf2c41671f4ca6cae21bc985f0493b4cea2948e83fa,
+            0x2d5c1ad3358720b486ff21f6ec096377f8564a544f54db36e9fcb540933022f5,
+            0x2706883c34903b26fc209d59a13cf12ea7513995f226c80e6eb8fb69ae20bc67,
+            0x1c0cfdb4290fbc3c53be1bed2a7e271ed1ba5aa5f372adf67132a8e53d2cda28,
+            0x5d00b6e4b2d0a2d0067e0d1ad30789c2dae657135d627485a6e782c8b9ced92,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0xacd1175f3984a9e7cf08bbf5c1777cea1e7256defb95b191ad3d868d8092534,
+            0xabffa5e8d3f345572069d11f25ad4e654e8006102f8d4759188a07201b43b95,
+            0x3c0a0138dacff601c9d0631e83b8970db14ca395f83cc18c7a64db35eb6328f,
+            0x26cca174ba7d6ee3fcecd1e16f868bcd4228785252b2b7de96fefea71306d5d9,
+            0x15461d04466499fa137c5246d7c65ef254e24fcd50b5d43ec9d5e012f89a4840,
+            0xba61686f2ac1ccae7946a24316c258848a86659591468507870c9983c272759,
+            0x4017df4afcb1ba3116385bf4630e9cff49539b1ccebc1f4942b5f43ce3711d9,
+            0x1424d70cbb9da7aba0be6bfe60c6ed4310efdb6c0a7389ec0c17d4a6e390ef53,
+            0x1b4adfeb3a81ffc9088ab0cc532061a6d3e88830178f3771dcf7a02534532e8f,
+            0xa12244e29cbbc56d28f49bad8f18c3bcdbe95681a7b84889c1b8f356db69c17,
+            0x1d2798cf1798c27d89de5f07a9da5e45553ae27737020e51d7f6d365bad0491e,
+            0x99921cc276f9a00e458f09183b359359740bcd453f652fc0e6f6c9a173ee5a1,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x1ff1617e14011200242d96c976a9b73585ccc1103145cf23d1e2b922d03d5d6a,
+            0x2c20a2a5dc3bf0aab0b87093f9c0e9ae5118db1173adf4f5117b33763bec7b68,
+            0x1a5f9d44d0d30cae600f5592492ec4d112e9c0a24631d4b49f6e14ce69836859,
+            0x2506549fb4f1fdb290bc61f697719b418f146af1cf8d61da1632e293230e302f,
+            0x19761a80b065bb3820ea466dba6f358637f3a298d986e9a5024a8701149ec0b0,
+            0x23f6ba2cafacff6a627f60f1ce6dc5b30a4caf64f4fb21c226d4c2d847b841c0,
+            0x2e6f1caa062248065f02aad7120cf91d3a9c29ff5680cd4638144d7f2ca95e97,
+            0x28b3b74cb98af781b0f5344c7d8526ab317280697e26d8503eff674cee5759a1,
+            0x271858d8121deee03fc457245a298384b9a55b3a8359a7190ce8bd23de50eb84,
+            0x2dd5829605b8e77bd72dc4ba2a12eb8a9aec46c1d253e3a8dafbceaff52cfe03,
+            0x2d30204a0bede236a8b41721ec0376629eb558f6bce9a69e6a93a89af0a637f,
+            0x2a6e862532fc598b61ed8c490ace702e5e92ef403111f4a9888e71f058b9883a,
+            0x2abd9e16b7b48289aa19cdfec726fa3fa15cc1625102ae511bca45f39d337e9d,
+            0x8496e866a25167f5c61f388550c49bf6639d6394274cc49d136a8ea4aef8f04,
+            0x14e8da7feefe3d716eb940bedfcb7a3f6cff1ef49e459c3d1d0df8d9a403e1de,
+            0xdbbd1d73459a395ddb33c120018d9692897578dfb67ad660d628e3a46cd398a,
+            0x1342655df63fac44d438d6f4a1b1288e693cc3b530cd73b3eeb588e8f2236cb9,
+            0x31a141b9e2cb72dbaa792b5b29c8a7c748c5cb4f1cd6f5c0568861265504f6c,
+            0x28f97968428b8a94432861d7fd12313a084d3c7514886fa6ed30521e588088b0,
+            0x1fe9feb5c7f7c7a426bff032cd6a3158278b6c6b2cc57a871213fcafd6427989,
+            0xcdb2db9e4f9d732d217c5e3114821165d49e5a2d41556bcd53d0c4d433224c,
+            0x9664216ca565c1a44fc2b98347ea8b36904b3877f2159dcc999895adeb4d70b,
+            0x1463f51d4a4cb1eba16dbc115566aa48fe77b43c244c9988a3c658d2f56493d6,
+            0x214e41788bd2b990347c7f2a8f47612d4dfceb1a1e6da38165873df66ce51f59,
+            0x548541724f64e20128260899abe8fbcdff184a1957a9385fb715923bf0fc79d
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_8_config() -> PoseidonConfig<576, 64> {
+pub fn x5_8_config() -> PoseidonConfig<8, 128, 960> {
     config(
         8,
         8,
         64,
         alpha(),
-        [8243355230504186170667337521705529968548180153769821936979698914169521362326,21549235422807751640146583237936799392598740234259041629069949854834009192195,15309683586299089746803554818142261058154570215179112411063662706557055610156,12007539402495575255755232938576927941514879725482443887151392201585760698040,18793669376013417649313139054009540629720623019893420956495818743913188610515,6637074549079529416739232814950531409613090469922787253991308038219905474403,3042007484821627445120830225760006405192082634864137749621636257026891883326,5337388510268581167254715112479133594089770138749507073603490761032513368106,12325446798142239188409242319577957593792614990556679862642230477712636037037,676789245562467194073706116744095779362669155912771165373940448756070927910,5854747984773506278911353281567883752585612596682487681686710970786834920041,11245406467967785626327694659468342056789182160059009120973665143197638081760,10395601815816075071544509552592627172226369015806880764151195346316980080894,6756096862783612163697577917108261850810460757753491809406999449771712474223,1708595072322964393019739105130946639405776432058599259998973103484499438306,2817817145890818701877539103826217929456570347854153048034669346981432211659,20337270972708498869284875601749656006552838338471813066271573323209168221011,19192338172842323468707146045612196807750411464817516820711948717057036544820,17223253657227310295312621282100531845543865578630870272599545474783775759681,15004735209586276209064505708625280228119288986650187909395010184201059452346,3875652974956649356154345677088455126258183810851242537013757276075769588050,10514447960615206081458524578173743817818597124482828867666984705327684376752,2087647010835075851760610474040959236825470174942075295716631067964093542910,5927163251920754154392384551305623830535034440727310604898855074616515892551,20585333621997037505291454298836355589763292536744926081563336065939121006537,19320876518201905459682928158170419256739531666800973485138890064423348282196,15942638804716709831210239594904570403189415026144938623559274984027906868220,11197022744936474661934096628367688581641778841814728682794507017845346201383,11034020922250561671038205476395109731446686553549026383358725302157324264144,7574933006942933995255906769787776608010920618615581322603847524789684181970,10061361506744906780155460423367413099657465765582917482575074226383566926764,18611343221859570540963418999548488653944851224739716224660835306206658947980,17094203924957299390365889251598099482992645049968199405515681968938743421467,9407145832890449495071969940777105644547801064593141904558463573167881762713,10921438560879150587765515492087524756046482460218342400194862909363870270743,15101279960899220452674629307354995123411280418550386595937683027146194547144,1872357133681596467751878560069114718371273548294363719900935160833598069645,15505500304018853111989216259257978796595506623204851206292254759641600763191,2079667978353221447444850850900204451820443725835104896018664141845782871343,2852655320672908960411014862634757863509253400797831983637863741066632490909,2702824031197306101989338159138451445088523866133498139857862801497066633794,14553308731276493692643101846551382187575566516925133957384350697980935154102,4314969815396483242407853639218064117498232660761075778657880116870422414637,20236724297078811959918602376319440958076910292454596856154100774072250182183,6360017115980704736383763605019264589498600998515606807745670287390050560160,20856970531105411628054833058646203890148287930330473527735908484791842390307,17691356258507144960616314395885779533907781694329041597441621553108536658757,4464167934150673174817562382299722091160711333547138388803048452674668158635,11538922347277268848344412167140306567742076984016453903533772667841006045703,15558861252260038101730449864896864763293561339637017072015859069059083288561,931980552683520059135814229579184511049009637966018180567726214946979768011,12746506550979326220422215987591117730943427023997792332255149062957909690818,16416138987000536018990311324687201169959549714116951891693452597169869821726,7473835750915837381583185047008243788613524206396316652305987269933344653773,21223994082372071324452834147900730753626104062167370333103771844983134656961,11102363694946721470818933128034696027504133564649607436252022322296041603786,2666835000155694643357391634256423691785613060199379949509682292216642706081,16883033667413528795407641102416904598130659502290474063092941543309042023190,13093053604456598783294628038129487761924241298889312497497820946915331319389,7426349812936697309541457521193139970366533826612714195359894150484429907425,5243217285990182677741567384304278362485372018078770234262925321063263504918,21185490040917275396474067542756068684704036418473170810170344320388557093876,16181135763579884029508432324330748636846464150219757303321560798898398598349,18088358880437096005757355821526785623101357556483672471222924931365890201571,20418860027198053484245336569800730261127301261293595190270103940460998981236,2058948081811170389115771489993053947061173620273801887242248130631460165879,6353796008567532863300373986154930294334380098977007704532496889557690195858,15854609649070278722833415779491666201355987522519101725393408435189057056690,1355942327518086746604287131396672941922424788908995789539897301592998007690,10194046920666955610804398522181498854525794643476895032285888778350918459761,18342608728256650520630397534564293474806178807929639999068140223470256007117,16101948218093381908101491223075947943147313203969904451859930796280152622017,9866645853452683082481412876547916795343134459981103407915522925093474319332,9309485422719740772955698359258466728180120624442685713365406080485336040166,5201701081505060757054562398073722930344229781365241858092054974705598137660,5279555243870694216927790669819597822350327573071817682265773244733785382064,10661662716572743893824841881707597899963881485303936548294117975770384660590,4306964326426793675768869124893413588264762573088622132302954501394542576141,19945975928045383298785833694292459276727208605892865429301546022994613804030,5037834331249812829239656466783521330249138768989720606017856991559732121456,20693877087308232030611148201802513236570270737947270986743265610517665094074,17748932969923719316564673051784340920943155490113289807023660243301385585070,16950307665556055391386715682532553772527550247031548278958142572490582126842,15034211391483347494286112687349366897258989065045859280146461213731663274520,3455096385235320554100221104677124747996171720170690637998043454239897385610,11220329458242704347549150795173830262585759464331372299692251819012138352257,8230076319752658879891285909687940775399748755759819661970430769188439691274,4178690445391578185009939705412120505162313641744671740163024993195883735198,18632680236376151061913536149173846032710756800956417249233907621575802688710,14168747730472612819827430620596085566004981811676505988180237018638188025380,16777617016129912124437138351698263064579177499617525409625791377061066895460,403267570119386144603206457308168792379980670187570608148634410971295877610,11045890302538505532103216886575539246473207034538532950483165910580782953337,2632893274667647784827087132221744991131294771819888858265016332574437797556,14022461303364013571172470728150898521630042996798160127819093871974124417229,18349129573612583311962846403448135938849737390546876598640066736462315682295,8009723611300112743690923532773238474616291315457276539919568488041436720507,3287586297388209299132232426281031982329712892122181769502106059441842217623,19893256464101780566218598404932657965361824655069879954668551189408491121155,21779954643920608321663779655887581582907923850271820082121309309571440586162,13938145028737822338330333388496944993576078307754676998341398757402576278690,17280605833933949866452995551396279974325968699794264573823990818913515933775,11562775307500290654949270847967546133812416593099094805234457839659652146289,21556021192476590536800970202944195471695121915357500612310904064652863447972,17407055226077297021071802288772735837293135175537846248261973015744713174949,21295838064085671525042198277220548723525913660103018392096215316189390548013,14589917958236435754986191512564058641868109230240077937707647376289105324812,4538073055458854134606640263494592220617270326115451287834630189270577020111,21247609438242282269742265796811514090579388884916478939008977411932487423659,19263560475610984724826226948356735903574936974192558145730920786586162783055,1898614508331499418660051276594019416852890004788354240344418815409520758722,13346547977920686435662774643991891597826323722140876186086635239306340843003,12144969177194297999321084025481801838621405926243412487948189180755523714531,11624156909934489978766768065107924627236090741698411458481638802308500352917,8674349037900011131899280296161700067911742760618648557038290076406601619864,18627233188669469962636721109716646416813512041955577645627776298400086440228,1153719160094308748956884656041023320488424966635003188538565876464091909764,8000003066081501211900754070779689975656073731442793160620896624291841806771,12069801117560082050163959286673266840809976769131514316118288648293224324822,11694828863372498882861202648883355759680038037706633938668096525787115759720,1181495201505177954430275085371953511604847831716865494220845031383860562941,18321980275956746302814628602546438645691886543647725888694024551609678639266,2785661975937033521551267460848061931764727388015171856456622007438303671899,15557886094116287182932984983441793820379366058597052543066101158081817575352,175179830261452669822497364983291141568331314582563701393865403724263011876,10455128373814266139918350629083299308526836847946708764631040462916637941146,12622681406523708498691044494295298210175441851465578469593208754136900020434,9624138424345877000077746656879336097173254842107184716328214933320809030543,11726383465426411877912203592949370178096897707629953853811352568008881233112,17566146584557385507728086844334319515338136183689530813551207417981719751958,18423839150858891406289385710861955437811779173242111498197433255650436048047,17408376662161624435555256564084894291578222902661202310977717110546842356960,20995943422377609225953642092578140203148330329113983394181012996247925741957,10409490873284794620245703460832015892256721643100501421596423100640512505920,15047062105747285153444463303020356100177963702386173227676803770571846532695,4535940688608096040988822900684697329863791065464226849059470519882399535780,18980357680792173392910397806033731294240363676914829395702138582894418363978,16468042735091009392571235146440392007609078458297170996132218787642722263238,1869769403621899262774247370472546961521039203681166934356431996537822108263,6151829532330885020831674048300360431343535966534922988242884341920915237665,14373964388615044752046531046884609884388869283450342961030080770253954449754,21429869771065858399481388829822721985084474326196139156050788103070270663923,11836916222341149344359827526882466618136359738495035945807998286429671739008,4542193081188277792793758113018430324598765345700596639963408884670534634317,17262340128494663310404052919129368521415818617921877469042393034218456907650,11614110585474201606235056157412783071151951301104822431509283035322273244217,17241248261774133453753660970137875514052923171943595080766050681996607133130,2990875140768570679733810173464987023133165559726680992079139149034178002777,10032389096385585741539206260012253444831624820404318451026478423856181568200,8391217416130739565515338215591963109158836617019021044489286448654465296819,8553700889274799411012667201578367398970695661169430162294018618925895640041,13529692770771168133213371031275281478756443444824139121847596546264553079152,14478949636372928879378459122088894160202116364833386541382488835123981766413,18528743543311452855194545818079449921167163839226390851954136986727320245809,11724222260540829258562889360923785293478512718704276634048783603461995522859,2652532822068043785753514309321715043229885635900630208154874285707479247265,16473666207635815797882774885364997250503755116232911726426811919269547851975,12436631741803099512327160776479880302093882812091908650798222524569929954222,13061081443094122428989571162147084312340276850316867585582410062467362267361,20909566607465067204267258789556187669343825005173558971220332255443231196363,14278016202378252898173761523743422243750790190417896338147106476354187349947,7703701752136585609667768350038563449121231460368808945757767724712186009894,1622258312841010773225479468430896972269503924285598181547410615000034107894,4706114868510775588142857635375822293570353199661120256611528287780303504954,12723022498690150801900112713057006417552064300221766812928489357200260312668,7736508633931646965699972944684083339925061856252811104228904321699984469949,195095354858363944780141950724441876473553677166595890451203685104276178612,18877614091447727762374351623731936445361116363480970639310200637662433378180,17239262588506530491210045452642505719938421789517734104955853192075731537629,3391556611912995522919492308422471958888145521362922265487749943660431330300,10164629656754294522862462407441648133619259920942013682702008716587122474446,11939828733425435518898229234599966533928666730047925120030711579782543312731,17335155958861138542643885799966192412363788951639890938680530110842555336617,21068414996957890621467676209673805582866493104159841584377567318112060433438,18041291613104743972430309067462668732698702146146761776321539150844598296986,6149130772490689572076747194977244577047643214871016443290724757756394340290,12105848363324940274456322072887282559016226587661485273111872063034847034485,5683957548001811989600472365740829603387405501208071642225953069881259762607,16529542077365261070047716411124689196456625611983373158922227651721798753876,11961524596519782767188645738887896272947446382672325012202336646508449392990,9785728068011868312995387469680578201705397880590293454099364001157116688561,18127416268588083447440821307938591826251677223119815897950307944959875167560,19296461637807972438220899702591874518336722552660488565818484435311224286288,6801016831512114134395242293457679538495311188529990156831889204433183626116,2964298470426582070507861407971247200639242211740381994158541687335361446525,13485975887078791259342768620261671076376983307468484850600890777864999230190,18842264035089067687391583729082424222425351385494040849910540441253540345719,14703642210510851071131854548671393020078600676544458548174965732036621712435,21220214849253889952179905879367949668848598115028365535238742829171770487419,11808561815315084933226034934054773302447242219261466208644893422841430468026,13540888692913543742580940929469376532537583430034252053023468103862294761259,7244161097354558003276348625436123965060461415149286453943040900234287411785,14838699086047571226987010390426316539929576717533827724866261274778253262656,14556703155521968503536618488028548581329555701042498979115582733446728182407,7681623302896593715513288894378158777679657507901023568046253058158573848701,1088441387469941348668229287331864702951247349577784177659963097331109780661,7314603916265509104428110912296267885635061026393352039011815022900719549691,3986211915826218802854255636104488183733664187834078111248006041750140814882,7773946401984571616670752866609685859292708427659817737120107917606152933392,2842014599902358831415178364343115068084073955515903534808862171830738904933,5310724334723991338015239276468023426385678184604207589409781216959654582406,5255222348968955358505450804240823699077014235887887249383824524518164498567,4683270496545943333741165516340250527555279356319043788098737100323469078711,1419863943011284607504318632953959861647793372073243840131919334395882404459,7983638904317557271319561780754076927110887040374328063199742162092282580125,5569432847705373609838086039153225563020182698189928344759413994203981320990,15459233133041758499623402905899885787129812358908703405750502906067055055230,13557004098047782158753673078158469379829777184696159361573537670440394932233,15455882302725774286899673141535924396516348007554186719344822187820635072053,3420919058826876625284567898132572990967515410265578892047210512917031439632,20100418454140979684745740106982178755085746706837715848777042819378494283102,2569258507332519764813672456351707773863376375715947817185409500202699032309,11051426796304102496144764766958179671506736496976882366028801902480842422589,12740229748287653735988491742372785228070141556372656548689214318469788908817,21628842595664718258888324339774974922449098458375293925060310284267692457557,16339231976272978519029290439531768093693541721039081313180796119705575069472,40124736742096746520902512885311967045111742860721554225254094895613700655,17732965892472841235257958105891466451086090480423956940377743815006013439,21822629194074446176794925064792912534191501981075390813302606875002422233533,9308214945046921143097017249780654286051601646816113552080893008307002107495,1407926751839535775233537792971129618756456590720440342541085713782189375466,5640645423977029900985251540406734874840031539109774937559862819450972865688,5033216407501194252797695593441325021622991729008118693554186469034086370061,8067057037475400447259522316648004416684453970851364075976857314405950145375,3763719773038467529952189678629891209905984306908045328296798459182240539135,16939797418368521863388331657892541744299855742774206972703171911218723184714,4830944198856568835319759101429165879092462296316662230100861015921313890231,12704214658232136513943612645116991664417275945120192627735782298715562058820,9273823420095008025667777982828688153052061387261780450903573585273931011552,11055274871946976331353174512200687536982312509623944578515862663278819898965,6608499500253253446996042326570359354182967780655057286059057541317584758989,20888058022129906086941050692798413401844596394165346138911969309287247738108,13297667979268130800823342819300433555314639138313483863899090834749801969571,18968104066692458124571065270953767119743779337036553042450471941512165236867,14932841303199490878640323744926137685749952622800747995690439854118498001885,6250599214474930878673138968631643032807502364864165001640712550360147900771,13872044280192246670253542029636668414586465840988190477111017540404431909403,81456119668307937036914780206985985650137679027930766352442712034886058018,8178364156193615628946078892680068624209694278864784660439209878556857933585,20847565685305938921688196081711559611104247746032524045765048360946563554616,14790603163347071870110696142274029411377352843070075577069234486581346354229,18977464663780407707262531952390299277523056655145169930121579582916387871374,16780630803676794749613238124686604459373604071531057035207376612438682381040,20186476042367781999034353334494913683828163385175556939730585228743410724033,6782638209588187356802454014110236225878206067794807253486060610876934918759,8993456778572039939715813797180666624819850516232234360679317411311388323391,19966302498904269727099815984264954717659138861990152509516897188319443441697,20169703794592063233917650314404110898564218327366603108408586484609331826027,5979829627203584558315118820578826847995466683728103070319484562170838879477,8237679343008214539352062545936737645555361114339038346011678993504862443129,12382432100828502258569798167004899872248210099869176340581848176730802349663,1568185664985590267262857882936657784210740515169196983171026814738347336756,21214766447038120613598232832812136678657988502205964335817205381807920739938,7692941991237742474520327457310452870153482370889548010226143053981890424652,13595129445265049664221406027681079958478209116108739005508499004805469917071,19188096071580221579092496028987371780642557049389322053081699235155567772173,17975673380464001374676034638564230054429981676012676440863525293845130019904,20841685157342026757711329464299804445471940020955209397956987009823404283299,7510778644672212989684926383821874729073504800968951172295535413714975603558,5412964648109092367425127656145675316528154462488440576988541278054587052058,6998001450950528857399821530729656471745472711969582871968416561472553420135,10017795190513370580285083759517584035694996563220913850722002288744022757377,12113185651597474067026664715619946415749981707739597619454641751791169267554,20451540737363571466111039734160615184627155382583098695879349204357410296631,729116950403569953818905038668361626861855541652418271170712441039707291924,6874571610670154627346562968411422088198077609945741147515101915358108207688,20307824547105117373454598908217917152093200208838326389260620574762152675045,8758875530447210792904496135011086289851932865540018278850670496425499052683,13224694410602002105805224454797207933944742532123981533211431845662395381395,6621493224766717216701548708726891168784911176896760330321592836065310482866,13937858022779991611039558948054774910543950212969141252259896915615778617893,4917806030251482092362529677296731621677399228082641707762616055246746126061,16304922224312728276104330461175394847795848175925462853738047204383447573035,16678452722472429203861326329044632626530032631343862086351886162579978046420,9974691111613144697061424119079539196535411918411684404824080439336446439564,12391128852318795781829794456501239823062804741032268163807689059014957151322,16376931186038869228971542812469753097050036606517944132293138523631153279825,3057841358487505418761470758562979965285993261118087156094367416201750095404,15045409518037090814105826994439679855639635253710791541219370329682069820225,13442376736433669968016223589180307683361433436806777011753497283272674012644,18917174176736242961299708438032963296686220808211170958894252981698475343631,11380920704380401611525239094209208940853859054744619020167150893676619275400,5399632748693319676480270098239871368958944610827825094400876104909425716392,3072779406768337118240884091792704214322792415195488652476136252175179362880,8351873470285292321562674159922105545256148886389216816367528787141186556758,19039526722628732399365091326361517675801947890934047817293511021151913744591,11316453563295765895775061205389385485172841919365628835333993250531664655988,7850755275953939062184858524678116551304016605992491147837939252676680785208,189663666172994057560830062107872734380479327839628938168402275701561917176,8944554955574110171273295960753608410178793391130829960067372967633462961614,7116498249918759493875054905542634690892118438594298685578805598675410965669,2535963611074434631003149876163530430931993688129878286594756194015465278460,18022460558081751594574692271414706303627866472796139479944146908393139741182,15341193598946540230880135952221211503846552166425406354080863978843527894671,2942431717153385426545606490874257811230086292797817271859433296359160259239,3009774438756820489964746831334449123894740822794580986556997529296717581423,9496138301121689616049759054935646143502980987880350156990306735995260671175,4076156724842725224174300000468119057699244699381290980710548119313376968129,20301500572584246879220468905731058339249778940966192891128325027181404226629,12240449395531309263037726882974869058539543342019721791945417590157321444565,2734576041547526732946886809654954568832411068107541730145912482251139322538,1913611111144137178181099357504813610426696502807761974432419767623037547574,8323981703091520786969788588517080546120036429535328021157459160571413370125,17608089795804665912003122420873117027406690592641558991713120617999818930151,17954961401611739290579723858653246962839079599354059880628870682426849304674,7693642591048722104105715300765742636898670019493041402551952316778508785882,10925165536949195683545612102300879902373347522535838874708839717193999335745,16740598974035404805544189925980303793846400946043080633235004418045311113846,3028458114292500648266975052798389647613432243149006395166123161184170940972,2817600861932061603203157785548222970685465773360278995551965365313604217882,2811366666795973435332404603090484498270752802044239619104866535127344245139,6901007103297959557257110184636027233977945890205420866896244199105220459744,6811040256124961160848956238308470640308462502755753004833080999365205628787,846642049586630199735666112786431409696508103735494916428842550432654381594,13061166881718302681365231291832588791959186056326831853549555763101859584396,1581547457654855644173875819143310956457964952802128135344084991507959176621,12591698412731075291488515328885878994038884715020576113812619060374399968487,7129047166046749599109058206849766841261983329246180789653876287940952140294,17780920041966559015242418384239510699940753783778307759603993814380170147815,11411967002648206460094819913767451172535988461576286592244752756526683869398,6535147980143805768211908880661065989475773196469834562468932004056012068981,12872366293792794368642323198969017581196463071340612957009439105182673573396,3845096876544992085668616039795853840768469571100517631039776002796484609549,20386025860348257305841141103130861239832870083066852913792413739711579490278,5663975388273723452136125938377376330824298621841190787892884430812699456136,20880523335705106555101009571713688438858731841737802690910851430800496104934,8664815262171336902475127109386834836220742848950659183106085559300961747316,15212672296023611959246835252860546019670000046804751249547303425954183847429,3786255974807528210793957400325837912933369979823637013145025357556219775102,19646410587152058982763388053845872310164493339475512721275474101828150077273,14407426259630290801648546162995549804322572985407158009259933675410180400077,1275955073103101917295562169849127375209112030395179332033340866715396722452,5487750760448101899937260261898752719887276580825994742322208269609306618405,12414079753210256499611439235670285717945909010061941159696368398137523291140,18058271753030912252347026705895506604519018890772902865355002646910918153759,13935235821735626611156505080089322797654275868806802361406549798199236177528,17110498079878546324718511787669387410942622969712445909354000807236690314957,10687508266469903792000405420136150569946636272800228999781195239976105560612,1277956894120355360649091990517188151791867400124079104247693321263057601099,929982009519538400155920125117423265869657236620766216139182914925009802954,16559970949358997473575123467518158994842000800881347427572300986319432656507,863852544580033885106607226598354103099120172650200980695458006092725115354,436810575313416269983882563851323926836428928449351162094565391723605483516,6334913013691170767138698286357556285297887475783792365865857018173994149486,17785859069146472999908840832788077051672090890508101583397157534162626183973,427206014337914391283601765560115825767253196347193816620589108299037926541,15115704735938262072587983952645382098893412471333885175144579020987265065203,12017969315449748476118643575203596675122272214009056004034938899095907760206,20642434407226804845623813766397536183962927868804716012482833199686414302852,18982318327848493301474677819747807686491978396022748137991684529478469330097,2306193794828709014215315860179466106408084703631347012188232489780230095671,7060813397820173935956757571314686808083877731722252822508055423697679476893,9925864312610988474999359617458205534034473691089101964213562993662824159034,14036238569106986370932971272638702550236692459418895654245682921654874601312,9509048813859143088347263336607686057099400727479311504780670742158653486206,6842166521132564137619008158396211111980991013087076743268157882198576269675,10217353423046013950417213172971567565900229914457220187215408404202554351836,18220384419265532097596052952017594673237799959023133602933674050572298730193,17866822945198657177461453619458294532377313634196332518543246556611008452933,17694368679979949511817467967015330546905282492241200905890171992458134240678,18971922685739566979638356009544944454629162680819328093994329160719843056737,18684937612086669383439812199377945074448160740155966772829350355651237261795,9235876281667970051504588287667786944160228843888838710239865727309603061015,6187574163551283282357553100017400574873868151705871779659681332774938473442,17196369096305464930639002419417036905613312721767481044644254878990952814786,18296927216321111202881056198300973553112302777685079899199090840516364581791,4983948188027170589078739023086929105628955321978589464920358286161528573448,2276814237931645487686771259585160667452008745791625290365802841496721618760,4138273157833414032755498052453436990872835066620446328921138739885868998379,5835580830979414828575054128735121537583042482361311845838347096674448689116,20992630219061340843601881100837482710979119542034786928296223633950908472388,1118381353525339785976839119511758587763620520383755136959051018516094253090,10337002023922138844951367775712178432524190386722995225923120494344904079950,9765947418137225404722546740514250763898752374389411503005283184253024586058,15411836962046751164622748177831913963909013265942110958658714173394711125370,20722527012138131360820192152290968950993396481440050289358737370268218859591,16585853587281811014582898583977502965045639444130273779047322749735299560207,21436098743421172924014781240823435281025352300035264733201366114473419058727,14178112462860881459540462916598447735177675761773338824394753907217898488960,2590560710846804342662010467713568407285290476715663333366063002353018991264,17949223181156469858379065899254284317305309247290121304422294912030586532673,6940063127036366626640075420306454154706369567406835284901717013872681276911,13212339415583029091219180722363760875223983190396769244985733901171214077679,11143838426689049623360248250302972103117784521940658207527698432687552942591,4994693363062895106345077091869420711664571716019971952890352464184561249569,7785839099197795033948112451740381108555553042322704038905686323540025631473,15291655295654923849266753004503491258117644584862711291502217292211074445996,18223946690101945712849081159295298164630378278313069852577349403051751559726,13247893325056509281811135293440873471348664328435966021736203439379360560346,1838627965154116499570588511051176331708387980121591719463695143475045130831,21746931323535899361372833028120884537569529325326959379977185108159655128847,1569229799996373000993208676467175871896208509249271061977636872731081653113,18668959729045139805375896352501526759923123936419773886979446262254907152787,12698285530824454564359053510831159718450594302921296519937334733529589738160,5743752602883180080321224936560739109224279187008023590149271256478879997507,17615461436426765950762679333452659818080751337498512367037395397687644820677,4379963027402443949761342437016192165148025657715626365315450970388283739261,12622442863880120105122485141053297017921305018805552070109568547893924027508,16493349884995741255319414030015325273883108492981717376626952633010860098410,11501183900713163689133184470477728399861217340901493951105967658399341986313,13184464903575565740074003127437693743650101614906307232173855163739473476900,19056993236227362680720448341933549082689888775458266843506880469982452347227,1180947252747369471066257076205537751320494098262241412291924855089764608729,16229532924404554580195616835338949126663348103713418556119694233568376894947,8604714607572995451336310555882946070542334844212691610961393592348706930493,8362594100280133221998296898045505539071433915735634439526614339277300552370,16399159148365956463951582514857891684943332179297226423628752792536028483990,20791958918883897879651946680726738927333774947616022833294686415482396438838,6976099533465307077876553477341301102578695004868981952387720840685240842560,17588607896443047770053818219711270035985826074286753981361920802895326076124,12865981806811655044812914486873432317316688987331760480657262748139002813688,19080259696546964979932036247707282742365340353585423017939782931928015046575,5475353703257038456872747308072401784844227202792527428899399083236860900298,699444932025038530835460727165156424336147795146205258896894678525124927461,15695622674480818777943366659102932349783785381339274197766151422625765388038,7644428489984569999599080644830401450294253782967784792584750934960812468382,2484044190398385977417569061356693291812041338880061938702052957819048506706,8456986467797277421685766156179980502998860530369856189405630837033584471075,5054041625001826317568038929780665383894838531896986763764007995985738029810,5197336058480822437408118036219119090707158130910220019747427914262297331861,8896147437242770809876821567936215621570430903276974181159659855796295866923,20755757167342693300106178757642141909843395817794855978028122598254488316281,12495257799325917448205113238508489684392516282807104246531380538192500498286,17639970982424592615983334078785592256655637539816187733799215839326807071148,8140016957188286078776165555436655378303814378750387793587919949009492167586,17209468066776420206923060639618147772644663380208004030591040036263548572020,2619409586309117922582791327977378099828554504012201484641253637770276078843,11172679254412598275301264634812740710430873755458899712228629497147611473029,16829502099778629987235691213955928527920624415791356237580609633148661633897,592799060717298365629187138482067858694007427100574367745567028165989185342,16864381084532235865281462338072964457337415344658720676113860956416999505572,1015589663070446561434523645329239389344944669662180065723984179503017360337,9982212112174542265411457778485410853904388759147308861218634697975431894510,5412525702631618381358272227447367851318305617863423359948039591381065713581,9852930575259000100332996271562617389630146990442517175422889296173516799181,6036993105785310658467845672504384047591296265363803946714632979523201713762,1821500632172143873156399122734194851200445368324858351038486833883177057468,21556520116213603298246786137688925835788594639953568860110645708136881336676,658318860971707056155247027603536846915894897192791739866840963356575472681,602842622617647573132938965729563329852165494525296971607175031334298950242,1151063223719891516862415316972915766442753873652837551132768558136109394634,20030054542089253165409106868864476953251573918915762537158006593968012247497,14455078111822464502989472874268580626098857184523941794725425258923962713053,1699191450188970110166570608380346465689006650580298122024202987580198200132,13971136504849280501801880342723497383580392506287195375689019810750613223527,11259011415071078991947983706483998982146186263873384729739331890304233635860,17741270384736018529047001790810396141344433078911295725171243367964019815741,3617456068852846022110280599700245470402025130645759911795429861830057016581,18773989857774369564707484486703863617112883499664601804221477949481034222590,391101570414854801618801587626783162239406618115954162053108159404294160435,3752824438659815340558915518196975380567589032517034180452547083690665271869,13652227089592801810376789544861979384538590096633526007583054323554301421745,5753030785259259818058977992956569985665739253964735992489420513570911607,12794765444364718066463627091127875266371595037234762762560519184694440318642,1844165267423966444579133456200541636533189889959706801468771335509321515822,799352162562582415493264759184613437140226428304061991778193411771388762097,15915114786946818157476898276501926276831197920612814619300062353559927906953,13041871949144831370743756131359537126101784549008553888408794912277392285626,1684702427149441531010110315726002248751792272226034774456204740385384491604,10195318610969070608511028432066597876456281143783329459466964443360549551082,13714193389971576085579160116206487363436474313560046541969781285568217247624,12202470771012770210445954644081270058473831351768121852596394422757629850892,7784616613742667796197638965440313242748565680231200921682296807888993222090,18581613859576442652033888735999982405110741068271804741467526764394720805037,14828223806255884089537896775456938290494683211666564494946175120085694803958,6191868112332934762674478056112840408041237177775248347690069948259811627101,6055199518589075551800066499277675747934144570099354689629636497613775458486,20043219892592698889412649805669712950039510114250762278667968995416842502234,10591576812697540586115991527347511638405122244793393962099090930538459086772,8146910292072979142616688207315340017602882692938548874592904341871514175303,15451576003386544225828312996072681331940167554848966592330715947662789205180,21156998090948310800651324456525534600543417534335507361948830316109451323115,21421497039083336739241851024868234958744697872115637345287618993148799764131,8835309990713613011240324096693076755485475658999871502819747407829989219746,13102158958973358955423565573049580406238531533936309830903999596178966162490,19927703189662863743499379923522860979653455328626544661291243971618992342837,18417771183154820005238210056528713167003520086953806649233005148247829186154,13242250186667974182640987653516460478853973058739850129463954545512907574522,10971901023853281329361069638276077765206234747340067637718378767976633645829,20436550472837870181409690438226695091760115955076127106091878852797639823191,683842651763399941903331243661454687566310039977770092715404267515366625429,3304534668380354910105587611199035768704466410761708200478786163367382500984,14327892159763789670354328059011011973128878640806462164819794130243254129821,13712101990593648405837473744314130986494510088132644940425089514662460031793,1270386163717136732049662990020454155453019401464056820650142849751291739739,4559668312052315567004252521434018809625818725552950834596073025095274632653,10289456013947128246221059115194021747046925564818529566042034047888244657473,6981981682422059144716871555026845840161063380660424650450978975416029699739,13275723002453843398308458799872954358948259042779675411059905047590837397361,18372074965684100000331046096891533070433189717560527825752357282553296305210,6007153627662867365254986874716350833679184737288669421698890656788831322929,11557682792813633323168221751485510314542594132819842305598531070629168100143,10536598621155464430657941977974614272794233321865085717974545329727298277125,20566123440884795144385782557360498238445700080133152934423121801124172346047,5484210585392274768700243869223282957415576141086566136019633416151230114084,4675266041161206862174450141632759296562489084453522360678052892725376421684,14506966485061491552710372008504993235111668026216492386033611735228479487468,3682565950309631924420685101131217452257499881999322497664342243267291843503,16753306733039910894513530708776251948831720207834805689601646616427039909037,11892397629144764406188085785897237236955294380381710017192179450763501663923,17027229171478232498721421673139332166581061755210509139252013418924500461243,3560458480908782960366816146149753544371185355186140843210760460011482921556,2523290942811919827064721825289040221770310594770466909167316010377190569820,17586848354290518015476851435178627882600199642491204839902589087637701736514,18771893348474501482962831973790983143756587183687952333177929270650139940171,6788202157749582404834375771398928959748074435244246320016871403739257327326,11025631863450004428764861086496374449453982180198151399523240056816657483248,3256907622263919521402687344729539839835290137654795380148237049547054026004,729757374802086603625382264910105909740146180896096383332210024077887641124,19863253866253150070643618896444516678169346690564661550005769233120838139485,12468569017378925985548033310919519222810416238732327538088208928920140959143,712344748962578398623451251358410865586764243720605242158768608887082462846,8546087066371010720013920767653366050032317738437010080974697619001241722483,17144825509786899110344839698077839239721239583625175190269757913667929043953,10651563297701188942358589203989937961905153035428112097802788565849122022100,19602341346389413323180922571631527509531683866957468565049297030414658843948,9238186664745057178430953403953596421917515090260446457039212350976296818523,263640414028390180122517954487976369901122460517389747631764885875587715955,2311641918305077640172935641310996393584851078677397516017312506521775283636,12911852110192471656473443086611566556755106535388637084532737811151296554463,10436700004928765835031725654432267178079115705246966695358470216435798181674,12755555289896266917759922247555708737024386059041699214870911784508162783525,17390583422165077903045260639521919716984664232208360646931078032292219709718,7412526952366864882775200227476857681850213243362827192310877977391550357930,5016060582872027330190350728607317487069057897723717249157495640519710863591,70447200134990075406173842139872041532268968648265338736409860251327029352,1545500244158153586647380894391367444874762740407966854865957002078767363820,2082567114283705201161441383508830647153064041365131752708347264051557391980,7773933577113494097575644205473257493685202208592412633139277067190461074505,15907352821797623044340355088248954282080052141018731890243639338361458586983,2453390435048874114321626738320866552399505338711520013030652128583351121221,9182038581165182763924458518550360578443802241218652973210280653624820005202,13176557622325900598244222336641110473108400343854387783748570353220729582767,10599983241136666078578113335543683963633036808782400964809769571709020578918,1430816790456574892099931300141571059151141389317227589818258647628212654923,7207251746626434553568433426934231676780727971853793874008147862305418016123,3847365229378532841231862621068765430417579646617713430532944299440264931969,922422158589085666348657924088867593873646110588554410818179794404300446471,4298485174770134050325487753075508760849575591910135387686931072102416450479,9475141350581193757416877790061277619494551108434152557051757495614692231364,7750163624390542388958191386016094472536166330496081849246099823270737686866,14363173695671306304956071467171940429435853698217676411185837490356013810171,3402134714494071567155197273072160417049647120230862441840621369782667867977,11378968132153772980874973211734670604659991740586197794619174704886870525408,2500862781199005154907185089778932765489906994365960644306361544820582839768,21880931942133046355810983155922578513531850539420426025723154879488808270315,17850206894189265929807971665186479441938275634968267590809377452033564010382,18427883853363251276513100116480886898434829323430684895879968439179171503760,18758795974827407022563870795763356401215175366078230621502388363785425038612,15672649260544536516531393740985073476934112035694203841471047634286525005174,14497479780124030172334631091033639981498927489925809517218125709975200816290,11190855071574099336548308963044121660452976926988171712775481672446931541539,8339442292395337481335048552147626044800877206694030770577319544121541364092,2461178629683239975488518502624530284391365519847067341739449204945212652770,3972313936510404965199308344697399140590038866586718833591813109326652018667,3224811019580618549699828950033477378112059204060062023677479068506440937528,18443657715765406615721041820828109800966587434816919981514222787674698772960,666201271764511484388505793135876064418452477237751508215203932379618265382,4434899717815685275523711262432486808621984251515429736982413712108987655422,14584918585762085382434085071460369807803840154636220934254933165793423091295,15646480282455307022430957975574008173154630787861430193406352480280577045711,402840791633175231660910669665966910050981784044822648466848382615330599909,15437492296189220094817534101128968523410729375545135146260659057729649968314,13987760171743052442513877961667805977500573882586118554487715622045738218279,12589095501858681021442730872878907609617459069328956803139727387371467358051,17551064250089164193025672794811675406761638177060737129533175904585851772273,13500706213131978087516005477128059726177752268287240395927379509000435850498,7331629294073516250840302816971095420668983701195024195892939287001016568514,12949377725980318589136021850295478499564248427839661600142796482665024587971,3988955063770305621858590171391799353484164878730082586815877210936858093890,20512156157023978986265779260320491356890557397261515752540394821171756173724,11624190532749034673782735319581023504009231230729490439584417709012081446066,12473562150323140802035699452896239306300376623759190078147999182702752528013,21504777935543484323252258287484534200045631968996932563017737909760083499017,16104745906544338230790783632377375683831341202924378150021598903321494336736,8312554144734150053969625169851557776466370096299754626528722906617398229171],
-        [12051363189633051999486642007657476767332174247874678146882148540363198906151,6387692555402871022209406699166470377527846400909826148301704257996818597444,5501161701967897191598344153113501150221327945211106479845703139297020305204,11704372055359680530622226011526065512090721245437046184430227296826364812961,1448611482943320179763394986273491989368427112997509352702795612841455555221,11429145481524962708631235759094055797723504985787912972575745356597208940857,18021858528471759023192195347788820214752298716891162685115069036283008604659,19817577944622399780828745167469547332167999743980557486183403063955748437619,16868980302925985719076889965831700407328155411673408077166038059874616424216,14717432944340806781505761211058502775325970511884444497202848327581753493322,6273484270523289845253546319956998489830555038697388950038256377785540828355,7726043103954429233325852791166106732104332590864071922310309250010129731951,21052353119157611359715869265647287129868507410601603360127523286602350622783,14881796557136180514390287939887071460258251160875710427576954128871507002642,16341327439981153879863707938117355436152690262312411284193970279829974799334,10737675906107372302108775622264379258926415910493665638388971468924879578019,17652699767629314433191915267767147860052614073432922215674211498672835339113,7457854400138129895665591719907473144796504905294990100367501377050420942800,2136850802972823585140870808569264373787409642804109426616292140046700710743,14029467347298896610468190615212519453678316548442709087191045978401072380889,17927699952921266007590534383984238136710494507499176330493504416180410161683,1404719213830610030709583332543456268094679432456284386108188509031502237811,15774757292079018355173698870903422490868220545526384876021336136892926326596,13992040374687149195439840459922227749294794072303579532004750946306028893274,19895094843870397064274579657905921299619388074084417486420154568847155746891,943833985612967248618844364501030453998731991825395875139617731659343743483,18334641092245356682448009823797080853859186519922476229272838591594967878678,12440287044655505483131716236615633401781045711053210640202766768864619378050,19130942564098572936370308509908873069169152245172660555660369853346605570826,13687979327148217614616687417475244897906227789285703940171633508277844471062,16887921327479880141959363366262254722342925451159884082370074726344024008329,20378003125024698406589040864014894045124234695859352480989552885205935609512,9961553412530901953022991497331082655746860319830309417179972582392489275965,17755268665220780466271147660314410613992814315871705414495724015443459797439,15394131279964876131165951719955566821453162041574233072088124095626652523043,12668230348320365182085867728169435383987570924921845106243310905832768752125,14046812111383844816383347755263287603387502282980410255379630204396960343368,11590093969266595252327261214735156204516524792938909229175092594303424141199,4623517074925959322927421514289132524032863498392441375476410779446526502799,11550389531965919926150256242174358326491059727918559332939872696684299343135,408487396317981846281976563618407581852133413686169882346565860317912856432,10717757571561029382519744040791773994731123262749372629687813122941078154016,21323787615496251932181222397986048515693661833099659753170924658480548866921,20780799310067873093555276926357624414275975377319941015818682052081980020892,9948385944800296129032348634683354181546876394979291412116493575442898426065,4957033413111065858035065225611730571499258914257595411830870977545212164095,5227254936689728148737265263965107718869714128941995977191096572191110991079,3582814872786080867997255427740166393615552773099677831398251586195329933975,2136737803483410555580163900871515004623198990079556379647848364282254542316,2965752098571712086281180512370022839542603960309127077035724860894697782076,1478525086510042909660572998242949118476342047444968703549274608283885678547,3563375996604290844805064443647611841824012587505923250907062088840679700555,15461452581843517997080348781604020486994675070532901120353124746087231692278,20472517020063295821544268171575414161230806406668271887185150097779785573889,21058001005918321995459971112208002381460494177332965873048074199074929946172,15805746645980285645504697043988763170971539673993759868487715403982423015009,7141240965656437676130015766799708612940092856280620325870466265817008351948,21418010338098024788434337801477243267248314524079104488811186206038748626642,20272108634229595317682817969506273496034097230124371921628691470754475805838,16734095147399743907618148751687506877774623133599770145304816136018239803101,8439324632051181834455499457268557602816180314723268640869118054114888151316,4953900961796661020464968131122569974581908893169105485631905994366550928492,18071625983692455679240094911529791119099077429122520426399552756115503123111,19638917592063029281156873227053827678889868373299664608974791764751784473040]
+        [
+            0x123992df3b9daa65139ec13fbb52f7d348e134333684c1596feb0e8d8c3ad596,
+            0x2fa46f5dba9909ce9984a01e2af30b550dfec978be92b49119a3959c7f623703,
+            0x21d8f94d3bd98f0b63a7aacb175b2cca13b2dd8a8cf68fc36d94ae29401b2d2c,
+            0x1a8c06c61046e0f8dc6a39bc57aea0d07fd7db34e68f73579da89e116af87eb8,
+            0x298cd7046f58c0cab77523a58a6fdfd1401b89e7ae5eef4994442d167f7ad1d3,
+            0xeac737966715df4a20b31ab693eda86a07f3e830fca475a6574d67fc5f19f63,
+            0x6b9b718bb3b6d45e0cbe6d5d9a2f096a77beb056821750d072262af2a70a33e,
+            0xbccdad6e8b1fdfba846a9553fc7905b3f96e435d653eec3972565e1fbbc302a,
+            0x21c2dfe20dc5a72167bbabdd95a18c147f8483cb7c0e2e684a1ee4012f4bd92e,
+            0x24ad6b2755a6a6ee51d92fa30df2489320e50a8ce7132504ceca30e9480079b0,
+            0x67a46fc4c52c6ea102cd37b4478fdbdb5e749877ec437bcb7acbfb64e61ecca,
+            0x1a2623975652d476f4b9cadc4b85219268910c7c3b2d0ae12fd47eb162257f35,
+            0x25f8ce30441ce86e6b21d52ca87463cec299a3ef543220d72bc2491fdc04c4b,
+            0x1acdf0b48d8a4789a9b3ac5ff8962b16e9a56c880e223668a25018657834aa5d,
+            0x14d3fa7ee1cd2b8be2f42eb6f4b95bb8b1d156d77f143fae3e82bb8c5610ea77,
+            0x3a224f6470a64f294fa4dd67524de58b18f70812e093c0e1c06b31d758a113f,
+            0x2c822aea71402807ec21db11a089668fce2e6c2d23174de3eb69484a53148527,
+            0x1305b66e890e97e11d52771a60509026baedd0e0bd5e797134259c748a289995,
+            0x2b1e80bc5e3f546f4b11399e77a0784eb7c439c546e9fba26eb6c77d89c14517,
+            0x1562326a8b0d5436bd7bd173d3f9e69c3be74dc79270b4fb1e8539d584eac1d1,
+            0x8c9aca89b447e7468bf1ea6db080346b6a6827eff1fb81392cde7f6130910b4,
+            0x138e002e8c0c597550b72acbfc9c50952175ba85c061b7e973d87d979476b54b,
+            0x317ee43e6f4e38796821ad2d55844d012bfc5c2b990fa48b491ef7c6372bdc3,
+            0x1b60831fc11521d122d9cdc6ff45c7005e6a166717e7aa1685cb286c9ecc992b,
+            0x2e73d35eba9b43a5100de17bba5c59d871ffa2a9b522b0645e283a89259d446f,
+            0x22a4d3cb7750e5f4d2f0381294578f698be7d678311595793ff6f1ee3eff2df4,
+            0x2471b7a969af295b9d407634a486a1c82cc273506d89a9cd5c80a53b40e1935f,
+            0x197b73e1d792a106452ac3d31fd02b5e1617f5442fe26bef5fffdb7e1497754,
+            0xb2df733b3541c788362a5debf818a087bd9c9a9d39c1fcf2564ad3980bae8f8,
+            0x1cc66ea285b3c09cb4653283b9c6ee66b7e7a3cae20cd50315dafe3a92113a2c,
+            0x25b6152ba9ebe836c2f5679d0f891b30b96ae3e06a6132da2f6f6d212fc4b52,
+            0x1a889aa16461370a4e75ea6bf7ff9405c29656295996b0b5884216311ecfd7a2,
+            0x1f6faf41cf708d8307442a5194c1d38dc3e833ccc4ecdfdb8aa44c5e9fce566e,
+            0x170221e35fe04da2303dea141113f7711c651dca57beb7fa3624d2881085d7d3,
+            0x1f4fd254340f9509fc1ce072bf795c9abcfedd5f80ad8ebea2726be474197b1b,
+            0x2bb4fa69cd631d5b418837b9155db02d5489e7feb92b2eb5a17bee8031058780,
+            0x2fc737a4c1073c018432cd0f9e8bc5b75c19f94f554314251d510fc788b79d5f,
+            0x299d38d16803616a9065d1820e2b8608280e8157f7e9ef5b954eb3d2beb2646e,
+            0x6e8fa64f6f9e2a66650e0f002b2afa7e0c2c9ae417072c68b8f1f31b217bd67,
+            0x151e2effa0eef7ae28945060179f4aafda3a50635be3b3cfd4252b5ec9c29449,
+            0x13f225ff220789cf3d9547f15ff5f6bd6b057570636e25cbffae7b707d6b3a6b,
+            0x75f0d5b2f3aef1e72cbe0d0b406505ec9a0c2b61f37ac0fac82b44d9fdd5f79,
+            0x26f491b65ef18ffd2382c44ed506a506a375a9049e2f6fa392a837f3004c50d,
+            0x26916c460b0e2d5697914d1652fbc3da25179b010a1158e546de85020742ae2,
+            0x178e270b0c35c5ade3457fa5985c1295f64d458a2a25fe849c7eb5b4bfc81348,
+            0x12b5fb7e1894d846ff3999b3f9105329a9cc459d5b605ed00f333da7b2130905,
+            0x138f42f4f01f4b059cd6cbd6afa1aad443f29893e24313d2fd3b0e61a378cfa2,
+            0xaf68a2bb5f9b6fb492356bf6a80f40730056bf1d85424614ae9703ebd20ae87,
+            0x711a1f848efb7d202068d15ad1825720c2b82bb2114bc884043bc38d727f6b3,
+            0xf7275b3afe158fde58367a5036fd26eadb8cd1c646afb4dea64fbf1d80e1f50,
+            0x455acba2c77be3a518fc64f7977ee3c646b30b534294726ec896976d6a16529,
+            0xbd261d1d46c99febb2cb1bd70ac8fbe0129528be059fce75cdba328f73d7348,
+            0x2e5aeeb04dfbbf5fc35ddb3712549be8e643ea1429fa000872af2ed500152719,
+            0x1c86ae64c468a452e8c1c2d5208ba6e17378cc3237380a48279889bceaacccbd,
+            0x2acc9d15663027fc5b4fa467e70c3b476f2a07a6ea585caf7287921100567a40,
+            0x230d03be86fe9114145312605773dcafdf71b97d8e2cf9e9ef246106b5fb1459,
+            0x2ab60a4154e2261c6e4e82b20be3e08f7613cd334dbae29586e48c1df49ad592,
+            0x2328aa6369f0af736abace3f7885d7dc566c39ef831508178e6d62bd4380cfc1,
+            0x1164b8dce7e4179ec0e294da56e5ab43de2c20a75d57b8e583ffea2349e62539,
+            0x2491cd6f23416063e77171095c0db217248a2c00adc3e146ba32d9ac2b941742,
+            0x1cdc848d353fc772de151f8656a7e2e24b7fda385568d6596fe81a303ea208f4,
+            0x2a398eb8ec4d3bd99bdc3520db7341946d4eed3a16f6faedf167905e6552884,
+            0xb07f73cc8432e1f9e4095e392359fd46467f9bff3e24af5bc4cbe9b17b43e62,
+            0x4e964ad5ded274940fe678e4f72079ebb09f289b8381bfa71d7c8ef0605954b,
+            0xdb2a3aab326c1344771f4c5f872a050465f87469ca27704fd93ef3fe5a5a1d6,
+            0x27b044fefd92da8972a60b0297f9b93f291786a749fef1e29f8ccf6bfde72564,
+            0xc6c0bf5ece0bb9be0737e0c94f9b10594489ee5c00676e51f31781155ee8729,
+            0xa36c8af931781acb11cc6922f0bf6e28ce01a1a18ee990da3421a0a9aea0147,
+            0x255f76204e6137ac12ae576fdc49baa054ba182678d75a0a3cebd01d0cd6c286,
+            0xaa31a68117f221fbe1b609d8e269e9ba1e9ac228e2e0a512ab9c774a3a63f79,
+            0x14151310e656644c86a5cda7620c6440ad2bb09688c70530c1ebac60d96d56b5,
+            0x27b953b1de0e30a1a423405b749d830285bfea294cfa1d3e11b4cc5801aaa640,
+            0x30476b760f0b45ab4e5b7bebef2cceafb2b06f3b4193fb9938c946c63115b008,
+            0xb70ffa00f97a377990544d9501602376ef9a496ab8dfc44856306bf28a1b920,
+            0x2861adb9067f446db45b36bf93ab6345f53e07746c063546df691604ec026529,
+            0x33e9b4274c357a8c6dd61a3e30236735b5a23f396acb52d92d6685a5f03ef67,
+            0x28b4e505d5309e29a6da8f94fdec039ac44b43110bc0f8bcde42bd833dfb0d31,
+            0xf6fae1122b219ee0b1675ee8bb5c7c48744954e3dae2f9d5d1ea71c0edb0a9c,
+            0x2b4173bbd542f1b89fe8d3478a050e81d42fa495e9c96af263aaea3c498e917,
+            0x8d72f5f016ab29391344f20b821450da912ff016e4da674ff97c5d92bd3a1a1,
+            0x1d9e387998377d9e680b0b55e8309fb8a29719551de783c1cf817cff9ad6a90b,
+            0x1424e2acf5db0d91956e15d5b5dc4132ad6c4fb863c9c8e572bb49feeebf7e22,
+            0xb3db34e4253558779669b849ef2fab55ffc654d4f9f770f74cbc45ba117f483,
+            0x1269861c49d7f3713673f6fec4b57436c9059aa10b541d64aebdbc11e6513f6a,
+            0x2557b7a318681664ac27c48349b1b5f44892e5ad02c8b81493418bdc66517342,
+            0x650dcd4d3610b1d776d673024e679b6c76b5cde0b985091ba00e1cf4eb26062,
+            0xeae77312a73dc3ecb243143ba64f7cfdc9465cf00fb0872958286430fd41aa,
+            0xf43d99f10bb7c8d851384f5215bcdbc90489bd63c9b4fa3ec48bf1851012d93,
+            0x2d95bd041d1b5522fed823a5d9d607d7afd455461f33bc8c1404ef348221abb8,
+            0x2fd83f519597b7e807ab80fd8701dca3f4085957b8f2955f5df79c24f00a1f53,
+            0x25c0c9abd576c803e422eecd77a3ca4f63a32b9f90f5366ed37658eea86f271d,
+            0x31509bde9a7286eed15ea23537ac72dfcc35a9f4c8cdc92baf39dd7cca4939b,
+            0x2f6692e9fbfa0ad64b3f748425ce43c3c69cb5e4c13a0ff06c14f2bb75141af0,
+            0x1aa375c879966cbd87d4ce7089e354786c6f2a58e26b97c760dfafb72df9c5eb,
+            0x2f14baf1792365a476c4c193939244a6a4edf35f41616bb6db4b2bf511642a23,
+            0xc1552511a3185d9730d9ad3a86c6dce629f5871d7e9ca38399758b587830ece,
+            0xa499163b884b67402058e13910d1c89873c952ea1a7d1a3eefeaa22d2a37d7f,
+            0x2cfdadc4634dc875e4c2be0f579768c85b32e5a19baf3b5d536a3d10a3199bfe,
+            0x2ba9818b35db18cb7631164687c593c9badacb53bf720607b46212330be420ca,
+            0xe37b0ae73060dc2b5f671e27e14a7cdbf6f37b7a03e69654bee75a9fbd52c6a,
+            0xfdce2fc3a75a381f6dd84b4ca5f9753a5f0f8bebf5cb6e606c59717aa7b814,
+            0xfb5a2ddc03041dffb808a10877d437c2764240964c2edfdbe545854aae282af,
+            0x1ea4030900b9f74c33a53a950d21f40738813f69e8baf44444d6f0a1368c6d85,
+            0x2b26ae52bbf7d41a66d984ee37a40c95129c4949cc74ede40fd7df3f3bfc7714,
+            0x16062ea8f9c3d1bc9acece3e3afad961eaf765069773e679240dd723dd4530fa,
+            0x78830573fab36a4777b4d82c044a60d06fc2abcaac1826fffd2ce0630d00eb0,
+            0x2f17fdbeedaae54d1409c5cee2a3f3ded005fb6f84db8eb600111679e471be8,
+            0x1a01b0c5b209af90e35799cf630441b0fe38394300a1dbdadf7e80230425ce03,
+            0xfa20a26a6950d031e20c9fe19f1317c0e694eb4397a25fdf97946bfd66e5198,
+            0x1b63869e274926ea2e91c0fa091b7074d5fcfd9987e887614da86eebd6b42c1d,
+            0x728043328557038e7370dd984a822050199193a7da9c0a670af7af9094382d0,
+            0x9570a7f7a06102b55bcfcdff64c42cf2ae994a20254054abecf6609318b3707,
+            0x1c2ff23fd6d0090161db54a99810f76ec767e2db6e830afc9aabde9614829e6,
+            0x7faf7d80752f501cf0eccc6bda01cd349376330df799ca842ed4f452517f6fd,
+            0x2a25dc90d45e36b9367d207e45be38d449034231ed7c6422d2795baed9e08d3f,
+            0x5d6d08e40d2741bc318cfdd961e62bd5b1439145206f49aeb0e8bb68a244851,
+            0x9d7b3f8a46f030b3b0b27bdc77d990cc642e4f3dd667b085ef114d08bbda9f0,
+            0x2d17960ecd06706c37ddcdad5e4707ddc0385d883f08fe7c8b36659d94ef85b1,
+            0x15f2471564848a163204b074c1dba4c518b1e9a4052a3a7e5d9c2a0e77e8ea99,
+            0xbc29d644405d0cf3ef18b311474b8f6d0e5bb9856059ea6b908d8eabbbe4a3f,
+            0x1f3cc2b9a666ca5dab8bc17436762dece0ea6ef3becf39214992627d49595ee2,
+            0xc5c7ec0b72c7947f7e1129191a11ea5c2d21a431561b3ee1513d0fe07b6b5d1,
+            0x1b02b02f8547bf62c0250622fdbf6c094909fc25151c3941b5c8c2e06d675be2,
+            0xd3213b732109beeaf102b359db224d86031ea2bbe1406f70b654eba980ab84c,
+            0x15848ecf21e60c3ec1ef45998777202b708426a72b03f8dc4e5696dc74eefc8c,
+            0x14dbf6efa7caed2cf9ec698db97e7552c62b386a3483ac39028be9fb5d6e3b0c,
+            0x2616126b746c3d8a4dcdcbee6d4bb8c5ab7a3ac8c5c5b91a654747119bc70ae4,
+            0x191fe12396efc23ef8865e32908d76c09ab0fe52a4665554020b7ba659386297
+        ],
+        [
+            [
+                0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+                0x254b8126f45243f14dd8211df41fe5516b35952d56c62678c148e73cdbad3718,
+                0x270712f18b1518fafe093660f492cdbc2fb70ffab31d8a4d8a1934be68792369,
+                0x2bfc3981a249aeaaec4ab9001727d32d4e6fe75598ee964fc85cf30d50df584b,
+                0x16060a17e1b11f851ceab20464572b3d78d582ea050014843101485f65ab723d,
+                0xe73217a106c402e4c6c166cd9ef1fd2a0b16ac1cb43646bc1c726f83177770,
+                0x4b959ca07e7182ca08f2351a03545bd7ab676f740b02331637ea1434c8545ec,
+                0xfc9cc95222f92715cf7476010225e14cc38f314071e50e0f3bc9ec674a8aacc
+            ],
+            [
+                0xe1f4e4d26e9da5f8ee3deaf48b493610be61d7d3db1d9754feca30879adc644,
+                0x2089c597feaa4ca9a202edfbc823763100e294c9e33000e513b2a216491d474a,
+                0x107cfefa1e864045a668396526ed9f675b2bbf272ca635d8d3e8801099bb97d0,
+                0x21630ec3f236ed219f73cc617b9f8b267dbee99a63c528544ea31b27cde49fb,
+                0x2741203d66c523c7639ea713b20346119c961cc1e9659a458af74cbee16d71bf,
+                0x17b2092b0f634576b654c6de21a1a8d812bd4c01559fff83217129082e2b2b20,
+                0x68e8e63411df2b3a9d7c567f66419a580d3ba15bbfdd1226effa3fd6bd47b3c,
+                0x2f5a2a0cd0cb24896c94878a8106d57e82c68dcf1e209167a45ae9cf8570fed2
+            ],
+            [
+                0xc298c14356a5a7f226c5a549e59184900385aafd8ea41d9746729964ef75f34,
+                0xddeaa906cb65f3e9c9bea6344dda8db90c253c0f7f99ecef88786fefe0e5cc3,
+                0x4b96a296a35acf415929b8784b6bba64a630d29dff28b628fc98ef708230b57,
+                0x28890a03199b727fede5ed0090ed69494c053c97930fbb6c52358b0d7d104c16,
+                0x2208c5004806c7aaf58314590bcbea16168fe62ec0497afc6bdd2938c12d9a23,
+                0x2f24d609cb23720eda55fae29ec6f19902c42d8bf904fb656202736d97b2eb69,
+                0x344d0c772c2f053664a7b9266b19d48ae5d2ab3d1c1a18150754ab4b836afd3,
+                0x2cd19b5c55bab1809e52cc9fc1a038c08935da19cfc563e7048d6bd1970a0c8e
+            ],
+            [
+                0x19e070982d3ee675e1622ca20d13b2375e528b676706882eb8f1afe1c5045ea1,
+                0x1114c9120442750493d999d4dd45dbd4f3b75ab183209235396ce83d8ee9916f,
+                0x1f0465a9c133a1c6805d705be6b3ea9912a2d062c34dbef92de46955b83e7bd9,
+                0x1b80f3f439396c2f466b8e9b25765a014970455a1beaed7a6fa308dac75fb582,
+                0x1c01f6db435dc4885eef9cdfed193250b9d3eb4cee366674b07bdd194ff349fd,
+                0x2df183fe2bc9b8b75773fa961c8d4117e582a80b656af5c58763e7024ea4189c,
+                0x7e0cca1a35ed15fbdb619bfaecc7a9a8f4c51293927562acea8eab817c6b84b,
+                0x24ff2986781fe40ae61e8f5ca0ef17c5a5ea7bddbc127d431547c1f6a8f5cedd
+            ],
+            [
+                0x333e2923992e89dee570a650125eda75a20a72e69e10863a19d17b7beea9295,
+                0x2e8b35a8c29e639dde8dfd49b4b347f00ee467863f6efcb355fa1534ef70783f,
+                0x27a2b7f5549e5eedb90105c0f8e20f0571ab7af0801f1bdd23eaad91f2229a13,
+                0x2a4bbad245a33e5d9701537f751410e4ff297b8f1d1d9098fe9c518c261a1b0a,
+                0x1f0e36c2cf9ac2c4388e74966d9ee7d1a0b3186916a08cfa306f6bb36d21e548,
+                0x15fe963f5bd0d92878c10a894e118018db82e63528afa4d4703e9881eda118d1,
+                0x222edf3e26bf74b2f503983189201d4ee8e6d6fad341d7ff50748dd739749df6,
+                0x12a87d0c5419f448419840e5e5a92d276ace00963d987f2a1008913d98a27114
+            ],
+            [
+                0x1944aac72bf6fbcdec04361238c3c4d9510d5f07439a1b6ff41f652990be0139,
+                0x20e6cc613ae6cb0a518425f53db1298a7f8859ee20aad08320d0a4f9bbfe8512,
+                0x31b0afb7ab2f1d241f882178f7dcdad48591cc67905d651dbcafce94b14d073,
+                0x1e431f2b1b7edae4f8cbb5d307bf5131c352c2a215a870d739617f4b017c6d16,
+                0x199fc2be60e49e679ec2ede6cf3345dcb3b918e5b3e07c2cd8141333934e178f,
+                0xaf594dc4030e8509701fbd3d8995f73126ad72a7af0fff344eee82a31ce77ff,
+                0x2d4308b4823b465db653d36818181209d23cd12f844f72f7548d49e55055a601,
+                0xaf3ceff2c865a901b9406d5d9b2fc58833d642f46c6493ca030ef595061ec6c
+            ],
+            [
+                0x27d802ad019a42fd04892ad167d9e83596a730605890401319661675736359f3,
+                0x2420dd1281fc0dfac176a752d15906b55f137b9cc320d5d5daa9df3f3d43d3e6,
+                0x22e0323bbbdace5fbc74a0b3dedea6e1e3bf10e84dfc71fe395089ac197af744,
+                0x255639889a259ebe59f74a8fdf2efce7fde1e3a666b35d8e6ec601d4d0b22689,
+                0xa38d163b8a2fa3092999c1797b1af909bd971a25a656baefbdbdfa3628e678f,
+                0xb8e857d9fb1d554f3a4ec307ad907de7a436438603af1b28d4e4ee379960ce7,
+                0x2e8e67fc85f9b4d00e9e1197b35bedf55afd7300a4c370987c83c15cf73cae3c,
+                0x27f42d86842f4d8a8c3aff2f47ffc1e179f097aaecce55bba0b0fdfd5b190aa7
+            ],
+            [
+                0x2bd05a040a0987ac6bc01f67242d54b7a2c527a970ad2815b273471eb9623e73,
+                0x17bd4f2726748d99925af9a2f2929e231c1869428c13b1e397bb0099191723a3,
+                0x1eef36d62f3f864eae67c63324e47a6344e33a2d5bfb82f05bef9900c54e745a,
+                0x2d0d8a814cfa16c2323f174be2dcbe0c295829fc59bf2a89f13b4ead0eb056a8,
+                0x198949eef2b27c2b9c3d699e3fe57da3d5b509c2b670afce400aba1aaa9ed51f,
+                0x7ebcd25a10e56693a28155fcdaf7b3519d9e0e08241e21789696cb76ee06297,
+                0x22f1bc4ec138b596128ce5ee5b8184964cc262318e17ad21d45c552477f53e61,
+                0x2b6b3bc340d4119e57831e4a2187013f1216ab3b639945dd92a984943241f1d0
+            ]
+        ],
+        [
+[
+0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+0x2ed795314c562ca0b6d7070712495423ae6bea218cd94677d06e1043327d5d11,
+0x1c700c219b9fd0ac323c67f0960cfa94e637aec4a5b68c8c8c579da52123752c,
+0x126587f4ddc000b06931fd6bb92c2497aebd10bf7d001a3f664c6d6934225f1d,
+0x1d322025a71f8a8445b7c50d8020f3d755b7ecef465abebec16e0d391bf9bb8d,
+0x1d3fa515e56ec187ca7657d279ee613e0f993ad146ee2b37f12d142eb8108e07,
+0x146acde01679ad962ede1caeb39836b4d818c68db52a9a1cde771be24b2e5e20,
+0x48997cdde9b1ec6f3bc2ef708b27929596d02b366f44386093108703f4a6106
+],
+[
+0xe1f4e4d26e9da5f8ee3deaf48b493610be61d7d3db1d9754feca30879adc644,
+0x17ad6adb37b2fdc36e43baa800fc4a0fca98a20a2ff9c184a838a1bff5baf530,
+0x14583143fe69954ead766939d693b018c9c6d99e86ba2002e2960640f993f19e,
+0x9664ce4670db8421617eef97a4619d9914046ced174c5907e7305424656d460,
+0x51301752f12f6de8c23dc31745b2b19b9bb7c39cc1ea08d08738c36a5e85885,
+0x226238a28654ad973e1a259a8263c6b4aec4209093ce8e563b3eadb0f1144170,
+0x1fd98a7ceef4a6d3b32de8b124c7e024e57c37498fbec5e451b92f5666a9e441,
+0x1f471d25bb7448b69310b975678ddae2aa9080ef691242dc6871e6a680bf6a44
+],
+[
+0xc298c14356a5a7f226c5a549e59184900385aafd8ea41d9746729964ef75f34,
+0x4ef313ca88e6a46eb38c9aba804ec4264f79f1dd0c05857bbdf427a86de4483,
+0x117bffb0996f3b8796bcf62f00e93cded9b3e7b07180721f2c01e53c98502f42,
+0x36d342dca9ebe248ef3674d1399d5cb02a51b6ce92efed9de36f2adfc837cd9,
+0x1521f1fad861eeea8bb068264dcbe68a93abb6076fae2f9e17066e4ff5be87c,
+0x2d6baf82ccebf60b0fb1632990d9bff876ce740798a6613203cb078a9ca1a532,
+0xa2ce4bc27cb25682f84ebfce048f14689f31b45e346b713dfe35716b9447431,
+0x1e1b9c1ae86ec688bdae2fe7788b7311114a3a8d6f8d7fd8ac4d79a3cbb38e4e
+],
+[
+0x19e070982d3ee675e1622ca20d13b2375e528b676706882eb8f1afe1c5045ea1,
+0x1562e5b3db42e4e28c9c3c085cfc8fe652b68e8bce182e6e1c84ab02661a8cfe,
+0x1abaf63769a9a837a0d09e1dc6efb2dd1dc312b0c1c4a8c066663998ae04bda4,
+0x338e5e98906f68a17cb1852bb77b5f42f287cb74e3afdb066fe966889db200c,
+0x2d74e6c13b0856c0dd85188c8a80f41dca1e9791b1042521e7bae94bb36d499f,
+0x7672fca8816914835cccdbbee62aa422a95d77118fe52444b5af200af0e00b2,
+0x276718d84a065a288179b23b9b2d8ff3f6e55cbf97d873ad1f7e9a2cc8a09649,
+0xa1bd98c224950369af79941d860914b7cfcca9596899786e6bd0889482641bd
+],
+[
+0x333e2923992e89dee570a650125eda75a20a72e69e10863a19d17b7beea9295,
+0x1a197674d40c43447787e6079278b5812ccb17996403315e0f06230e2dbe016a,
+0x1ae4af74d44320001b70a0a230327d586b0319d53a839f5fd27fac9169085169,
+0xb169fad164bc7690cbadd1ffb6ab2e67be46376d16629d663b0b83ea7b7e4f5,
+0x154b82a74672e1433c3417f9cd1c53d4ec0e4efc9d4c2655eee3c24e4449655d,
+0x2c54cb56058d37bdfac59708d54a16c1c7cef8012ae5d1cd83d87140ea73adeb,
+0xaedbd439fc8a60c641e55ba0f17880e00420bbbe5ae332855e7be146a0a0b24,
+0x1b87ebdbf566fc8747d2430b3c45edfa8ea4f8c9770230ff4091f58d6cf6b61f
+],
+[
+0x1944aac72bf6fbcdec04361238c3c4d9510d5f07439a1b6ff41f652990be0139,
+0x32aac2605d772f1fa6f328379ca86f4368bf679a39937cfc508a58e982db9a8,
+0x3a38b1fc1f632c027894c17bbc4702d45616649d8e3759d1bd4239d89c9cfa3,
+0x26492ca60cbc803da9930bf40b24ab2136a9275fa8b299cfc2674ef08234ad11,
+0x37a36e914e568f3de0d6be824fb24b107bfc8c77ed767e707f8aa5f0199b205,
+0x5de377805bca799a16d073b79fdbb07a672e7597d16df2739345938a20c5b3,
+0x2eec7d749447d3df1f1c2da415cfc4b448b3fcd473b9cb5891f36db1c33b5c17,
+0x5c539bdc0b98fdf23e2c568d8aa039f8d4e200a6da374c8e764b530e9b65d2f
+],
+[
+0x27d802ad019a42fd04892ad167d9e83596a730605890401319661675736359f3,
+0x1e8382dcf318cd0d7f58ba77c1e4641ed3412a480f0b779ee6c9b73147b09d2d,
+0x5fe56b2e7f2cdf071f3a588f1c604b2ab62cf34ffc1d2c72cf8a86079f01fd4,
+0x177bd045809197d7bedb995ae85f213e19c1e301a646a8caaf7c9f3492042b,
+0x179ab9300b69ae8b9b7540f256c0947b8dee0e53289ed0b5b7d0ef09fd10826a,
+0x2c2ad35579f01d21b61c81721de5f2787950facb1755abc12e63b0ade9c66e4d,
+0xe78c7c5a33ddcd2ac7aba36f3b50757bd7e867f9e6775bef50c85632f870959,
+0x2010d6aaa2a1cc21415a72760a1a9d8e1aa82111c3f91e1a35f2abe8b79f2085
+],
+[
+0x2bd05a040a0987ac6bc01f67242d54b7a2c527a970ad2815b273471eb9623e73,
+0x2f337068a0ab32fb994362be568487a5c9974d9ff203f3db13234838c8246469,
+0x305fc4e93cd1c823068e5063fa983fd71a9804864231e37d61035bef75f60188,
+0x170e3b120459d017daed43224c80f6425f59ca2260178321543bb556d501c090,
+0x1e1ceec2c1097c4b47a0523f89c94a42f52f2e011da379b6a0e57ad09973e16f,
+0x13e72b920d7df0336d643ff47f37bc44888b98f7ea8064d5c96f8d39d11834e,
+0x2fa9d8cfc04dba7c7f80eae1154d535657bc7015459a3df9dbe47ec7044ec009,
+0x288ac5e38d20b5159d4c37374d8ca702decbc6265b6396d30b2c2959ae2af9b7
+]
+],
+        [
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1aaae08b891f5b2046c0e697f481c70f34b0c71e81cadc7603c7e5d31139d196,
+            0x2693bc2b2377f44f7d8c291f332a6bf184d993289445a794fd3f815824c7a4aa,
+            0xfa4b8bf58974824edb3fb2d26038975f49c2cf84050c8208ea7a30aec1cdf02,
+            0x1746022555831c140765eeaeb08a06bdbb7e2e65f5a5f70977d41f0f2a18b757,
+            0x3004430cc176cbbe7f33aa7eaebd01856b009f291df0567d4fced835382f68ca,
+            0x6406c73da9aef2475718a34075970df351312c5203526d0e55bb00aac90c6f6,
+            0x27db71cc71c8a22d6133172f19b8bbaf0e37ff0772a58aecacd25e869675c3d2,
+            0x25a9cb700e5decd6dc4544b9c5e3b49c0e04a8d1f8557e231da51d8bc228082e,
+            0x1f8b293768d050b67db5fd50be414ea637f6ac51998971b57ecf4e4db972fdb3,
+            0x537fd07b3ac0757eb471a2745efbccb327fe00df9da4b4b37ce2798d5441343,
+            0xf3d208e42fd3d45dc0bf71a72621a3a1f735caa82faf0c3829e666889211ccf,
+            0x21b6ec876fedb5cabffce8f4386966e8f1bfd0bbac488ed7c3a9cc73afe3638d,
+            0x95100091241dbbbf7446ae4b3d1cc2e00fd45c725456edfbaed74111168db13,
+            0xf1cf912f0d9e8be188f3d193aa91b094e79780511c3a3853b6f20c771a1051f,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1c0b352556b629b1e64c6e3abac4b349c05801e9fa43439fd61a8392cf186509,
+            0x1298fbf78e8967359120670758f382a8c951a8d2186b96e364e9b221d7b121a0,
+            0x32529e49b3721ba593bd059db34fc4c01b5d036d2495b6d3221456edb02fa3d,
+            0x2dbd37ed630dd234ae12f4c3dd4d106e277497f79cb16a71b4ed871d708729d5,
+            0xe9a1b9cef20c937bd369647f84e2a310bd5d83e8d177ca9c7ea457169745b77,
+            0x2f25b164c0610b5cc1a2ffc3e962a54ab01e0632b062e87a0bf249f8f7a51cf5,
+            0x27b73694b83e0b1c06069c9cc1fc20dba1d037e481ef2161a30f4de74c4979f5,
+            0x1aca98163961aa6b3b4bbb40fa812c86822948bf91d38e606bbf5e1dbb732f2c,
+            0x23f67b87edb5d48126bd42b7f2a9f8be7db2ece0206f97d840d28dc3a4967c0f,
+            0x2d7104faa91a3300e3ec93486228f3657b0aaa7277f0aff4760d0aed02ca07c,
+            0x2f948955cf159477c7b411b0a868b9ae9a56a240cc20e40ce1a097a4749467a1,
+            0x105151aad6d4d7960ffafca05d4f8ab4ac1930b222fb91eb9eaae07ddc18ba84,
+            0x3cb3379d04500d1996cefd61c5032852d43e41e87148d92329bd98003fe5d8a,
+            0x12cc617757c857678ec716ed94050bfe192215d9fd76be3bf98b65401e8d12a4,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0xc8716d8ded0a8c521da019c24594a1b859e53e85311efae748ec9312a0697d6,
+            0x2e082be597fce21e7ed641c2a50feab6a4b26c6050cb7733979656d9a71988f2,
+            0x1775849fbef452ce7a0863e715a67ad4361b9a2b72a055469333b0b8b8175b21,
+            0x1fc8ebac9a5cabb10ecd4fb66339a2fec1ee8af951e69f5837775cdf4abd3e0c,
+            0xc92dc16c65e5fc74d162103763ac39f2ca7ad692aa9dbbf9132b8d7af4025af,
+            0x1e5b7963f79d2bdf1f857f13e667e9d7a97b4605846db4f0a26baec8daf691a3,
+            0x19172d7e44ac5b1b381c2c893dd30cfda08c46fc6277dd38cfe1b1cc4daaa8b9,
+            0x184154d48a6c6cbf9613d54a604aebd5820c53049749f533c0efd168e4e83e60,
+            0x1ce093daa2ab71b132dc2d3bc1fdbfb91292c35f083d350eda02629f66eae2c4,
+            0x12b07847ea7982e0e6dfb1b2864ac2e8f04ddf7d766c33bee75749015a91342,
+            0x1b96c0239c9b6643850b8a653486e0df1d4c7f667a59ede3064e4b5068b44200,
+            0xb053365816d9cc61b7e857531ea416ea33d60c4d8a529317e29a73a3aad422e,
+            0x1fb9b2c50a99cd788717b3689d46c05e0d7dfa13c58f725a54851b1174c2278a,
+            0x2c34ad3345bff455c0e461587b7332e19e0a9165375225769e8dbb2087391eff,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x60718f37a9480c0837f5a5e7c13eb75c07f60a8d8c1cf9ff30ae132251203f6,
+            0x4f4bbea35e9b9001e92d6cf690b28e9c0a463382cb76c5b4e6acef622c0436,
+            0x304a3b30d2300c7bcd5a2b7ecea51942b79b7d04bf346f95961d37dccdfaa238,
+            0x626de3124c2c8f04ef55566942ffd3a46f2b7bfc898ee9c5313e50a3810a397,
+            0xaeb9945d06bfb644e310b3109297f03f2ac002c31dea430b2a06666f4d93e09,
+            0xb9264fb57be56298cdbd2084d379720375d397ef5d09a3ec90f29983f0a1538,
+            0x17dbef787498ee541ccad5751663330e379ec632306e689cb3dd89480adf582c,
+            0x15e36a3829fcaa26cec9655273017e83e621b84a1eac7be9a764638202a1724b,
+            0x243a86766734068afe7659f078d7384e2ae7a73c2e2b6dbede12dd0ac2b71a76,
+            0x19f171461fb4bca771adb125c689bdf519519dc2b7960b5a7caf07c1700f0921,
+            0x1f5a2974eab40b787b5ffb6de24e939ec04b5bc31475cd803bb2fe0395a6ec5b,
+            0x96ee06e8758968f1be067fb4582c810694a7205d39ac72247c3bc4e74fc02a0,
+            0xb960361062101863b600c67724666f71ff5acc674628f46d840329eec2a20db,
+            0x54f72b1aaf1f0531eaea95d0148b0525af381f598b075f56f86ac0f7edad99,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x15d5de1e8c0f0d18b7aad179279727eece9d2ff735ee49e3634167d4d440491a,
+            0x16df68e36d342998fa4818e065c50d575012f4203a0ee73e155fb6f9c4ebc049,
+            0x283e201525e86ba0ffe200bb698683a35d51810b72339aa3773217411af1ead,
+            0x289ddd4c7635287baba51ebee25b7e42f98cad532e2f57073dd7e8465ace409f,
+            0x16c3afd8596d8515eed82ca10249d26aa036c6abdfaa26efb7c98841b2719d33,
+            0x4d76016f612698f913a86dc0749646b7f4517d3e668903f76effaa95351e90f,
+            0xd021dbb869aff3f4fe189fe3015d9d5848393aa6f76eceff7f9d9a72a736843,
+            0xe769248c92dd03d46e9e6ac5835329f2d5f7af5cfc5d1bd920f097379443e98,
+            0x189d6ee4a5b445947e0efa11690f186e98a54d3e6406d880b7706f7defe167d8,
+            0x2d9bcac46f7ca9415b13759c9b4cad42a113bc19565a01cb889e1d2d698c76d1,
+            0x684c2e542b4e0c59a7f03a6d361369a5f6421a91b98b1fcf0ac1b7144e631b8,
+            0x1f6608bda209f29ea2d9c7df3a924b661aa614e1fe034f6ff1ec18bba7a14f38,
+            0x203c71fb9d4f1881845f258bf12de6153df99d35fa3da8cda1ef4e18ddc0a65d,
+            0x2bddac5720ca5c69a727c029e4edfc393e4115f898b9da856f064321ee8e37f7,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0xf415650a23aed782936a31cc331b3856b64768dc9b29c9a68a8904a08a2366c,
+            0x2a3272896962e7d3fb7a1c783e24ad141781fcd588f4cdc319b3deaca21f79ed,
+            0x1aa729490f697568fa8cc7587c9d92bd19610d8712eb3d31a03ee9a65bd443d8,
+            0x102aefa3ca3e1722980dae564122eac6ed4b1534b65d6effe5503b615d7b76fc,
+            0x8fec616df09b477c42d44cacea45c18644a68c59183933f1fb67ec8c452008c,
+            0x6b5b266f1fbe4ea9237a231f8c28ea19723adb47729b6913b7af9454f23dda5,
+            0x2d4a264e748b499d97b3320cffb56648af68616fd73bd29e1225e2c45c1163b6,
+            0x2224e659d1d7f55a80406d270debf092f713eec67aa001eb50cd8b173a766988,
+            0x20260ec25a18f49225f3accf1020805f5982f34b658c553f5f744d360d50d571,
+            0x1a692c93319abaaec066616f97e14c1d511e86965517496540cc0391490b1b57,
+            0x2189d255d9ca828ade6cef86f5de626fc2689904db402a6131066b41616c23c8,
+            0x43059b6857affa85b90d865eb1a9a91f036aabe5a12c9a03e8ad87934991a09,
+            0x2a32437cdaa6a32a0a3c060c2865abcd8cc2a79bad7efbac1cb8cdece412be75,
+            0x1746046edbf4fae210a3f0273bd7cf58beabba4c210b3617b030f7b51e6f8f44,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x166371ee86c08d7d38a594cd70011ea1ecd01154007d555fcce5796dfec39e35,
+            0x22f89213a0580e56569c73128c8a41351b42106d11f08b6f900f8c61e89e3edd,
+            0x1b3bcf6322de40853b5647f94ceafa4b109dec51c81cd7a38b51ad6d96ecfa8d,
+            0x2fed79c7828b5f8fefc7c73f312de0739c9a2081e432cf2f62731a5f02fa16ca,
+            0x243db465df5d6d34ade58f233829cedd38dfb57101da284d42207eb4df69c7ea,
+            0x1d49c10bee07998c64facc37ae50dcd91a17966b8731f2d1a34b3f78559bfb14,
+            0x2d7c4a750b7000a296da599f89c4ea7729cfb85883037333e1b4526aed397cea,
+            0xd4f4d2dd076db4bd67ac279bb51826a827742918d35aa52a5c1df7a3ac5d339,
+            0x228901e5388a5c10531d4122f7e0772759d1e4d026379ec16676f45a64b818ed,
+            0x111e7f5a746d046f4d7c19f2fb49c31255ba045db988cddecfa0e4172fcb2d6e,
+            0x1595f02fae7bf2b328680bc0ae805194fe9ee83f4fdf4dd0d35e84ab29a122ec,
+            0x2d22c9fe81fe2db64f3ba5cbac4957fada1f0c6a6a4cc883db4dd922d35906ed,
+            0x21587d485b2624d0549a6f5de06c009ed06c5b48201d8f9a750c5e5a98ff19ae,
+            0x24c33e212e7e9d3faf0ce44a3cb2113e74ffb7c28b45c7b4ceba5c1d6944a64d,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x187f5db526575c180e8adcabdda34e701463bf8b1596130c0c6b815dfb5e7a24,
+            0x75eccf8b0d6ecb184e0f168c64404e50e013ce0df06bf31cbcef2421ed7b0e9,
+            0xbf2f82a1b14f888c48822e147e332a2bcaf77ebb32d7cb3cdde813f0b1a373e,
+            0x1f587a1be361522f8568d2109e0984f059a87317a35f7ccd7365c5d97d447e62,
+            0x24a69effda852c7d20fb4fd8c3f413db1b6ff3979409e83922789cca594a462d,
+            0x2ce67cebac6bc12ace86bece70ae7a5a59a97023cab6db35a0f8cb7110552ad4,
+            0x2ef4852f4fa73b0c40c37118ee2690692f1e7101a78a38771a8686ecd37023a1,
+            0x4ea49b4f2225a5cbe53c157c56f62973f394fdb3076954bbbdf30786debedfe,
+            0x2e874d03cebf495782ded304d1f37903b06c3f834f170e96d26812be0ff52466,
+            0x23acdefba9e5cff344b212629dae61e76e03a8a8eecef4e6c0588277f53d81fa,
+            0x1173808e27354b4bfa76d6bd920cfc8309f1e9e99f997f773195070843eda183,
+            0x29aea310845b4a505ea34932e7bc2a8f2b936c47fec5f2269a3c999413d048f6,
+            0xf5536e4420b891f4cc82c50a833a17f0cabb89c3ae4cba4c28fdd5cb02e3d2b,
+            0x7a3576f0287b2a1c0d832be178d43b6858a4c8989e30041cc143f09e2012fb,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0xa260dcd98e220b61c2012dc6380f52adef96a11d38e7371c576d54563f7bfb9,
+            0x224028c158b4b4adc53ae913cfd9ea42e4456690be5dd8d4c459779945157e4,
+            0x166151c43e43373467888a2ed4bdaf3148d8ea2432d998162f62f8159cec690a,
+            0x556f9ec39ba4bc77b183cff006a0a582adb55d52dd0f4a8c1f156b33898b28b,
+            0x201670bf6f1fa62050110754b53b3d0671086156d9890ac85f40c69aa4aa297,
+            0x18a78efc7a694b6e957b209c42d6044af319f194dc16451c6da27802e7f1c85c,
+            0x28efacaa79a0af5fa9ddd71cc6a711629788664849b96ff0b42a61e2e43c87df,
+            0x1d07f908b2ac7783f0d734e871a40be7b2e164afe885db6fd312bcecf4cbe9ab,
+            0x8f97fb3cc640d078af3d17c569f37a9ebfa6f49c48db74b3d948a8675db96e4,
+            0x2718e729e940dd2d26c6a6fc7de40b89927f8c9df032cdcc06ed4ebe194fd596,
+            0x2c68ea4120e5abbe11f3b62801199cdd8686dbecdc52ca8a9458ba48b19aa6a6,
+            0x2f39ffaf54a4cbf00809ff50047289530732279ea49607ee779fb149b87e10c6,
+            0x130fb307c6cec609ab7c5f9bd5910a9ed9958fc11e443705609ef3066197a9a7,
+            0x129a1c66d1eb5e84211c482bcaf70789e6d5cc473e1001dfbda059379f7b58e1,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1cff973af21d88635ec9afbffd85b1cc595703ae5bd5f4faa6ead489d7aeea20,
+            0x27ac0db61623f033dd102e118d47d847f34fe11826bc9d23d7e3e43386ad16a9,
+            0x25ed2b22b59ed4baed8f5c957caed1fb52630971092d0af3ac8ffe5fe3a13904,
+            0xb634c3abd9ad8e1b2da84a144207c4ddeb62c8f4860f65aa2209c1c0d0d7e75,
+            0x2158eacda450c34d62fe6ed5e3c9e211c170f4c3bf4247c5caf0b9e2340e409d,
+            0x1c0e715ac64d64535fc97e4d86b95c6120401f5c2697332b1ed6a9e83710afca,
+            0x1a491a07ee1df9abb02aa300654e59bd34f593a15b74306b41c04e8b9530986a,
+            0x1523cc6481931e85611b1844832abbf8763fab9c85130f50ab3075fa4f60762f,
+            0x2816926c129f5c99a970733571d5c01be1cc18ec0f45bc5e46068f0d188bc9e5,
+            0x2d94c81e271fb9800d333223a141c9e904476dec1f8f1e6d224ed49467e18a1f,
+            0x1bf8ab0b8cefdeedac41738599d38ccaee7c03914364eb617b5421e9a51a0b27,
+            0x21fd6c59b0f417453f2a4d669851364f5156b6adf104625f857681411bd04c64,
+            0xaea3c50afc0806b117aa98c104499b4d84bee966a94865896a39b9f8ebcb917,
+            0x29a8795e1f8f1e27e7e04b23788ac40e102536d56b57aa85fd1015cc21970f55,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x17e4ac7e489fb7da610506535bce04186426722fe24a261a3e286df2f3519b34,
+            0x10ae4901e443ef76726afccf1c9099fc18001fbbf5d144ed721196ac9f2cc130,
+            0xe60f58884bc252084c93a18b4feff245175727c03003f025100d435a0debb60,
+            0x17de16da3692bd34ac4069982a1fb163da3119cc01d12c6f1ebf64db787deca7,
+            0x78d14f36f6349d1af6d92afc8dd98ae7322f3c11993c59a225b079c7acbd4fe,
+            0x2cfc356c4f60781e3cc83474da74607b9567ed3a08cdd7242ffec76f7d36cecc,
+            0x1531440db56edd521c68fd2dffb627155130e6f3a2b47fde65bf8785ceea104f,
+            0xc9d25b13772cda116107dc0c4fe9818b74f24a51f4bbca5a63bc4fc6441996b,
+            0x28a4751755712b3d33f9eee850ccecea47ebbc32a1fd199fc256b69c04456500,
+            0x1eb00cff68143cfad376aa8ec83216badcd664d55e990cb2d611fcdda52e4407,
+            0x1bbcd528cc66eb76816135706b090ea3b46d45f0db08af962f17df4eb996dee5,
+            0x19a41df7dae052bb5821aa4f32e9103dff752baa24b9fb51fcbe4359827f8cdb,
+            0x6f34fe490adf4a07fee6398a39e84a0c32c04259c9691daba54ca4bf696ac5f,
+            0x10cebd9c9c4b941425619aacf24419380dffdcc7f5326e766d38e72838be3120,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x214aea2850fed7223af80a5906052159cbfd07a30736ae5d95e6b60cb4989d14,
+            0x15595aea45afbcab1d4d2e73c0a36cae9d2fb50d36cdfd5c0c127f95862add38,
+            0xc4055b948c4a9fe79aff19190da8995eaa7c537a20cdd18f5bca5371d0c895f,
+            0x202dc56d64cd4dd16ba2e50781fbf937803bccaf08b7ba8733eadb427c13989c,
+            0x2ef4191b7deb37e92edd46f965bfcc66bc5a8539957f319958d91066c3fe15da,
+            0x2f6942e918adbb191600a517edb486cc96e355737961c85e0d8595ecf579552a,
+            0x2cd60b5a15f37871b552d8095cd8a6ffaf033b539d7bf1ae5f671e2ffcb9f2ce,
+            0x2e05c44549c1ca99a8aa9e5ccf4726240f75a4060ad8a71012deb2ad55486afb,
+            0x29b52fb3d57ee05634b2864e7b2977f7393906c12e903931531f95c5f4ae08f8,
+            0x1a565be54d3bd12bc9a46a1e2853a18ed26d6744c98e5cf53c83e6600cc56a60,
+            0xc806f9ac20225e54ea2ff82c73c6809497b46d85d51a4b05c46f667bb3ed592,
+            0x2aac8b1272085c7986012bc5c7612d5b7eb5933a9140498359b260116290048d,
+            0x1ef1b93e5e0c4bdeed8d40d74e84fb0ec5e8bd52af3ecfeaa54105e674611a3a,
+            0x1a1fe313685a247b03cc9abf0f0ca133ea119ad01ef6a090baf774491a001296,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x694287a5d6c2f8c7e6ad899f7960ea1abd3aa7829422a66be8e8a1ad6bafc0b,
+            0x2aa1bd4878e2ef8252ff42d595d2d0b59d774a98e3439d05682cd28463e15104,
+            0xecb968856d9c8a1317c756d0e48d5b1c365e6eaf980989d3cf77d110237314d,
+            0x8a950f1079254aa243fbd11fbb4d25fb0cb8a0c39bea71a3aa1c0df80943907,
+            0x2ca441a867e40ca07b530a40b899052427bafd17c7a31d484188f96ea21cadc0,
+            0x60117f9406bde6b52e0af3a54444fe9cb69bc9ef22405e2b85d223051852c23,
+            0x18cfbf11b6c20bd7cb8fa67ff4c032c39fc2b3610cd8f90bca3e6136c6b04f4e,
+            0x14addf2c0a38c601d30bf96a82d3fcba2ee369b0d2f232adf5da3e2bd2970a43,
+            0x2677d87f29a2a948ca7e8f5a5341b56947563be4acc97c46e557f5c60eb84442,
+            0x2f423100c2e9988b6cf5e9bcb1b2aac09d926458b9f1177f841977f39109c1ec,
+            0x2549090369bcca257da260694265b951c15643c8103c9cc73fbb6b065db979a8,
+            0x205c0e6789ef1fad3b8f1367cf4eb199b400b16499841e1feac1cfb774412d97,
+            0x116a1eb2caf56acf7308b5b7a7ca6b98224c93a655d78ca7867a3ee170b33fba,
+            0x319871e083a6e2cfa6a69f480121787a71853c4c6f772fab9dea2e267f3576b,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x5b98a534aa4041bb0c7e79ae6b2f5c164053b4c0a65dba7fa318a5aea8d22b6,
+            0xdd5bbcdcf0d6fe99e9ab4774911a304957b461e3e2d809775da6d9c66ff2cf8,
+            0xd5e13e77b22ec3447adb2487c15a4ced671076f0d0c0e8ebc9072f1d8e37b87,
+            0x20468b6dc384b134a4538c25683b468c877cf30b1321dc7c39e0fc942dc64450,
+            0xe2bfc13ac065e251caa703abd5362783941ed0060dd9d1b81f50c630dca8376,
+            0xf300f277165a02ff123b3078e87e6251de0de93dd81e76e8f8197b949960e0d,
+            0x19ecc98c331d8b440400e5a71e1ca2f830536b1900580b3348f3b7ce93f75a5c,
+            0x2b60e2012b670944ceb50be1c78808ec4568c7c442933b21f125e9cdfa7ecba8,
+            0x2c3e3476d128db70aba892a46c2061ef24df0ac74db004e7731b167f32697459,
+            0x2eba0701ccabc0ab29863c74c80f1eb3f6a6ae79792249f4e4fbec63b6282e0c,
+            0x1b821e2031ccfef578878ebe3481c9b5db9e7df929755b98059ae847b7871a1d,
+            0x12424e45b885060002f66118e487a97bbb10ca97ee0414712f85f2154a6395a0,
+            0x22dd55670c91344017558b62f32c530ef0f3387736514af44cd43812c3c3830d,
+            0x18c607675f0a99f94f2e7b161c693472ca5963f71823a62bcb4545249ed116df,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2d16a32d5c9663139709f054159cd7cf6f93c5f9133007b4ec8de3983231be32,
+            0x1af2c4175ff13a4c27cdf6f91e6ee2d81e56a4d42d6c13f5e1b41d8f71a985fc,
+            0x244100fc9f31adb4e58ef3e56c2fa32b5b534d42a226880d78eb3be202c9dd07,
+            0x25fabd23de22009b978a089414dd805837cc0e1d2d68f919a50b7e17418f2151,
+            0x22f32d43c35f5cb33a857ac06d5d9777a42b92268f0c06b26d68f7542a6b50e8,
+            0x20b44788f504781a9951e09b497f1c1c2d2f723b864b84e74c1523527f48f996,
+            0x17192ddb8a67bd2ccbb940532adb6e376759800df7429c45e5a09314e64cf7b0,
+            0x116b6619b40c6172f572650a9566ed2b809164b994e388b6fc467637b61cc2ae,
+            0x1e0133f2e4adbf08938a9ccc82fa3d3693316aada3b052fb02ed3900e1d730ae,
+            0x1664c7e25e5a7d2f285156dee897b4af0c1446a32e575fce4d56a3cab23deb44,
+            0x2512c8e3d7d525edbbd4bb03394bc4ae7aed7bab5ed55ce3fc4aeafc329b7f49,
+            0xf5800164acb67ed0f6efc527bbcdb851e66995c9dd3ea18cdd9b54259f64bba,
+            0x1e4dadc5ca72e83a6f54dc097f0c2f72d506ed77d576abce800858d48cdb9cc7,
+            0x398b2ad87a996aec8db980123effebfc59ef1d35be0e6a7fdacbf3929551bbc,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2e351fe58b5f36389df6c53ace1a5366d9c012a2ce2e0c4a9dcb30cf75f59869,
+            0x290c7b5e749c1532ba364061abbbde22272b62ee90ff19be581c4ea68f58c5f3,
+            0x1313fd3c761307310d30f5aa63cb0733244796351a9c6077ab5ea343e996a778,
+            0x2c31bfd37ed16abb1583c403f09dd2a064e4d03f9487a076f496e0c8c5dbb3ac,
+            0x10cabad2beffecd1d735b7284037753a85845e6fd5b7247f3b457ba9cc9a323f,
+            0xe02a96e2faec73e916458f940919859a161b6b85894abe5ae146ea4d3736d10,
+            0x1d6e090f0acd4da143b23f3ccc565567bdf49353b3416207af2096389b791b06,
+            0x45f7f1687d62eaaeedbfe3fd4f725c85176968069afd815dda5778563ae1a93,
+            0x2874ad2d5ff34d854490d2f41eb79295d0bd9befdd54580b257fb4f2da1cb9b3,
+            0x201894e0f41d2f3f21a6641ff9e3959584a749648f98c6c6b3c3dc6e8285239c,
+            0x1e51409dcf81bc661657b6f0cac27edeaa209baffb0c862fde7c0d0610506b73,
+            0x2cf3f549a9651db991a798c7392afcb8cfff307af338cee2a501dc1be740598a,
+            0x1b7aa8f35a2488bda1d6ee416a8be05035872fddbb96fa56645d0f63bad04b69,
+            0x182132ead4b05f9e1a44e7422da93b1e0e94d5906a78f63469cfa1b0ffd06a02,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x863bf81ed562159fc915b628bb76e3bae663dc10556dae9cd432ef8de50b6f9,
+            0x16eb9ab36c92c197c99c3d11ef6d1469a9c4f9779daedbe99a8e5f24c8f5c0fb,
+            0x2a0f1728e8a783630378d81f1509e94bb9803a47a112d99f7a58c60943c5c97d,
+            0x20b391efe82379701a0f86af56e5d22cd881f98d0ac433df14ed990881cb5ac,
+            0x586a52cbe0c5a8a0c45440f80dc7fc52451e815c5b0f784bb25f0ce319a1c01,
+            0x4af2601360cbbcef49162688f13409f2fb6026f4137a0b9f85d4e2272106766,
+            0x9ad52f4be13ee678536dc64d24eb019da0f5cfb36d4c35b667c7ef4c85ed800,
+            0x177a0d318b5c0b226c15afa0ebdb0f3d582caf9373d45e73c25ea6dbd1ef0e8e,
+            0x1ad9d99de7417cec3a5d831e8a8cc4d633ba770104d76f19740f8483411bc837,
+            0x69f24d59c4dbc2351edef37a68c5e0133da60eaf4ec85cc174f5509e4676f2c,
+            0x2f87a8a8a421081d17480f0363088e6604780562ec2d97aa1780a7be1d7808f1,
+            0x2c2318745d149dfbb796aaed50048227cb01c1885ab2eeec9897423d824e65bc,
+            0x128ec586a98e49ffbb2a98e078eb12b4c504448f53a7c59a7e2944ce6636ac02,
+            0x2ab7de0aed5e6302873d6cf0f642ecbcf4b84d263c5f60316ea0e434f518e270,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x642e786838ddb539b8b481d50922cf6acba80cbb8cd74d91558b4f7a59cfe41,
+            0x1e02bec25bd53fcc6becefa234ab7a591e14d7e1b9dded90a1bf8bdfdee1ae72,
+            0x261a2baf4b655675fadc57ed29369e831a3a236768779c26340007d048dabfb6,
+            0x10b56d5ccdd0be5391c62cda87eca6a70f12f8465ab4004c6742beafa69afad3,
+            0xd1e13710db39230e576013e5b339b6697349b6102a915993648b2097ad216d6,
+            0x2d0bd075d622a9ffaefc6998e1d3a845ac07e8827ceb27da1eb79ff36386be91,
+            0x17f840bc566db8a3debeac087e4c9d5db07e4eccd0871c09c5314fa935243f1,
+            0x299f4beec86f210fa27d718f78fae4f2d94a7d0b1e029c92bb0e33456c572506,
+            0x6aa7db000f3f4d915c35090ac9b1a90b269c8d90e76269053befd34b76c41a5,
+            0x10dc89ce0e3e131a594f3bd90a12586629af838d2dd7cd9566a66785cfc7b8de,
+            0x14e4b1cc172d23e0d5fc7f219fa43fc301be8d8702dc1311fd97f784d0d1d773,
+            0x26390978a65b917ecae0242affc450f91c4649139b132aaeb1406b77a751216d,
+            0x19aebfa3fa2b4cf836f3d9f5b672a682b20f82ef9cbf8f092608c22327f1663e,
+            0x2917d6cbc77bba7388d8c43278a57baf86c1fc54fbf57d0dc985238678c404a4,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2962061bef3a0b557f60a3af8ca0b4e6b44336359bbfc9d30149435deeece130,
+            0x1ab2e3bd8c03c56d30372867a29a5017fc95e868c228c456e318ebb2a7c2de76,
+            0xdce3071ee2164d465e882c1f319aa89d169d4216a2b3a29dca0d74244c36a5e,
+            0x1c7ff77683589db1c00e5303d9568894c240201761b546d2aa38e6c63831a4c9,
+            0xda3ad9016d141320edf78fb242fc386662fc9183a250242fbe72997646ede8a,
+            0x108c858506802f97c0a8a005b6f3d0e73e56ade83d3e1ef9291783cebeb0104,
+            0x18a041ad99415766535e735d35e2406d99f500507d44c121194ab5d62bb3dc73,
+            0x804d788ecca64fcd1dc6eb9594fb8e91b5fc9027c2e0542369f2a125b1cd397,
+            0x7731d16594681b792f143ae2ef1365e94c7f0fe15a472a29d71aef1760961ea,
+            0x2bfa3cb90f13111146c89385af82d9051c4e02f738f2f996d2a5f1db712ec6bb,
+            0x1fddcd4b1429134574b4f66c202cd63a4214580e654e739ecfbfa3fc3bf8b41d,
+            0x886c258df023184bd7c942c2f273140834d867b8def498fb10218af80d66425,
+            0x19ccae1db1a9300785f134702d3b1c8d13d9ac87b9c2013e5285209cb804e1c2,
+            0x7a4b8155eb76363e05e5f00ff95defcbd37b94afd901c13045979dcb63d6ad9,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x11526ac8331c0fb6dd4e34233c163073d83300629288634713359b2dcfafcff0,
+            0x2ee5b7cdcb61f59988e2794312192b8afddd8f8fa1cf883c998f7a782891dc7b,
+            0x2b88c35e9f5dc25ddc81bc209216b88fb526ad94c189d5300c9476d0445426a,
+            0x1947ffebc3ac4ac3ccd1d57cefaf6190f1c1035bc5ba84706dcce44d9706f1bc,
+            0x99f8cc64e0503354ea12b5a678143fd74f1b4d69654c9a8baba1d58101a3147,
+            0x1afffd8d0170799d162462549921f3c7344d8a27eea55b4f9397c509f59f0e83,
+            0x2fcd5239954935486f68514bc4cbb30282b25171bb9227ac96ce5ec9e6486732,
+            0x2ca2a102b6561ae65db852da22c3b486fc77c6a2f5583506720a328a3aed8e20,
+            0x1002dc58bfec0fd85333fb805a44eaaa1b478ae253a3d4a57681590d0b52ddfb,
+            0x139557f5ff664db54d6be4e42e0b4f7ab92b47d9d81da1307240385200759205,
+            0x2c89c5c93e90d0a7039ca638e7a1ea5cbc2358e61044b6a09d103cfc9ac4d9c4,
+            0xcd0d79c5b4c6e7875b58f2c619fc727aba63df991c99d25ad2f24beca0df141,
+            0x184b385669595dd8fa774311e59b2abe04f59546686f74fec70c9514899894c6,
+            0x1cf3e5292afd10a90414741ed3287263f4af9515b8cae7f41d45e4109ab0ff06,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2e764ed9c7bcd1b4f7a64f1afd3efad5476eece0cbc566617cc52bc51885cfd,
+            0x2e6eb18b75b4908c063a9204147ea1e9707791f2c6fd201d081703b4cdc97ddb,
+            0x172b99d8419fe0858380c2295d156c711ccf85f150ed4917ebc0942aba4ae961,
+            0x864eea049a1f9510949a12d9a6e74537b3aac9f670c50d4f4bb77a7b68d73f0,
+            0x1f9a772d2f96ded0661156db1ac0bbb7829ad3cde0c3e63bb95a5a47d4a2ca23,
+            0xe72ce0076500c498994a78879704743def13b87a1c78bb60557598652e84051,
+            0x183ca9c331d42e15818e0dd9fe4cea99078e0cb54013eb596f798c3dc22c4e52,
+            0xcf4da57b9a9c07ecd1427b2b437664b5a2e885e76e1eb08e234c7b12761beba,
+            0xc7aeb1957239cebeb8c3f35f94ab2fe443234d88b99fa1a77cc669717410a30,
+            0x120218ec06b07045ed6b079c2fa91b68cab9caf72ffef5816c4bb77cb3dca124,
+            0x290ab4acbb20c93cf9c99d07c9fd3189dd8a395928cf9be93857f3be7a4dcfce,
+            0x1da24af446511ae52972f6cb9490df5fb5ef6f0414b514380f9c645a78c8511f,
+            0x8eadf51c905e829f936a2a68786a45c09296b064ef0764b59e05398f7601d65,
+            0x19b72523f030bfb311fd94c66cb20d105ba2f1ff248bea6c3bc314cd4558005f,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x177f0b80a1de3ab56e24bf4f8e63b45b31685e1dc1da5e30553d6be482bad1ad,
+            0x5b07ed986c2df68a97a40e1c227c2f72d5520271666cd41326394722b9932c2,
+            0x24d2c3f8955b7a068cf9a7bf1cd3cc1f7daddbf2a99b581f3af4980fb1d17892,
+            0x25838298a0cc4b774b6bc89dc923f9d330599a9d122629aa96ed251b5bf10bf5,
+            0x2afd3dd5e0fc21f0d9a2926ae68745e8c7bdb307a5e790ea08872e878cd3bdcc,
+            0x80f2fce3bab6286e19d950f3372e78d4afe22d2b2757373253b424858b37e6e,
+            0x29ad15ea08093d81d74c6fef9f18aefa1a6915eeb05e47f4779c8c44bb17c8e8,
+            0xe004451085075e404f3daac34818db8878cd02f134592adbed0cc081851599a,
+            0x2c1793f6782d38379e1e1e3867db57bf514320c0e37fc2961e50ce2cd3a61c82,
+            0xbf3dd46be8800ec0b7452c61319c2aa365307c9b7e9d955aa7aa1057e91dad3,
+            0x2dc74ff53d61799295950b34ea3daf706a0acd6d5cd2ab7461ec706dba082402,
+            0x12d0bf8b8fe9ecbabdc9464854f9df7fc9950388a9f68bf7920aebb5f0285a2c,
+            0x1e939676347eeeeaa96e3c0bd51e14604ecd97336f72eb054c61fa71309e43cb,
+            0xa5c3db062ebf2c84c384588b0e97a0d2431f7334ea9006436f6795aba6423a7,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x41b75c1586f0664a618abc2e19231f4230761fbbf90746fa7ec06d4a517311f,
+            0x202eb00eddadb4c0761953255195ee55af32ca0621e408a73eec96f080f07d1f,
+            0xf0cbd02267d601b91a1a62e5d54246f07b337e84661c9a7f40de79f8527e94,
+            0x14f2c248139059dfe9f4d970c661fd17be54e8fcb3a7e2cfc1160288a01d3904,
+            0x1ba2c5f95dfaf2df18985f49b0be1c1892b59dfcde7afcf553fbde41c2397183,
+            0xe0b040e8c04374f4ff9c54e6ae1cbd79cf4e46a5a32d644ae35f95b6c924540,
+            0x3d017d86b1b62da699920b08e0bcade7c6c365edb3b9b2ed28e1cc5c37351eb,
+            0x23b785d6905e142dc5f955a2ed3b4f57c0f18c79b9599d1f21a9d370d323283c,
+            0x860b1ccb980266b5c9800d56394061e4a39bb2b31d503e915c8e4f2678a66c9,
+            0x1e3095884e8e3e82a4282d39e2020cd3f4dd4c14def98a1bb3e4dfba4f372cd,
+            0x1c0063fdf232c7cacaeaaf3243b4acd8511f8b784129c8d6a7fbaca45477c377,
+            0x2de234571d455023bde68bbae1fb69b62b80b889c8c8099beb25adef8da9f879,
+            0x305e6097b1a9cd0761e08a2509895f2d6ebf453aa7f3841bd97809cfa9a46635,
+            0x2bcc7b73e56788e3f70565b4168248b0321f65d941840f199ca849402bd52971,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1d437882b57028c88c69eab64507b2649e1705eb397a4069781ac10151eb2258,
+            0x1af1a36aae7b181df7ddbfb34e34a53ae40e8529c224ec940907fdbcf97522e2,
+            0x2785516123326658487ced2a9e864d2a9372df4a480d96a810f3ae1246840a50,
+            0x27d476e2c174e2eecb790e9d96acaf1b17c675fd85f84923f0bd1744a0f700cf,
+            0x1eb090499e37004464a5edf2eeedeec40e2c2becdb31426992f382a1e1197753,
+            0x92fe84aaf6c1b773c1e9afa8775db02848a85bed444d4133e1fca601c6c68ca,
+            0x104d16cb816ebbc760c4b3e28fe8c18aed972dadeb94896a2310ff9d61d44e3b,
+            0x2fa387f6bb06f1d9cd2e78be84286a7d58cfd870c5c1e8315232361f2b44cd0f,
+            0x176b64eac41dadeaa403f9ed5910f11a419372fd90df93bed240c8f79ae5c550,
+            0x2ad76ba01e94f7bb8412f271b92d24ad2d7efe5eed06b0852d8f53a7700022b3,
+            0x1a8932f1b4cfac9286ce27de3faeaddfa0733d07261297a38cce6399d96fc38e,
+            0x1eaa55a6354586d0087e1d042859f63927cf27def44830af38905e3d876ffd15,
+            0x34c7817421f2bc213fd6caced95f1cf9b176473e8721a100b1b6eef4348b786,
+            0x31efc323d83d4deceef06774dfe798dacc4c5946664b0431d54e67acbb840fe,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x9e3886c90029fe260f4a2fec7d2e1c9a0d07abe79ea3598a758ad63c20e807,
+            0x1525c95ae08bd592e2e428803d4e6a493016a47943488b02a78f2d552d16c4a7,
+            0xb1011a90a452ee3a6bad8aa9e4885a62472da29771ebb98cee7117ba1f0e77b,
+            0x2fa5ca0f8d2c52fb2b4578e1efb6e1a77fffd1bc525809626d3535833c5001bb,
+            0x1db0397e4ddd02c509cf2ed25df7b81dfc5ae489bb9415ccb7127a205d3e876e,
+            0x27a3012fa6ee7c193ece6fd7692ee96b8e4c89797792262db8d6d1efd755dbe0,
+            0x274e23c2c097373e9a0d952f34b70020e233fd2e0a67c4e20729a5fc17f88c,
+            0xaef53482e7e1c25fb664756df6ae69506b5e7aef718b3b1486aec64c4078ab9,
+            0x457365cb68df73941a3ba80edae9f25aa2250e63cdd3a3b86b031cca2134d8c,
+            0x1ca262a197b5402ad0640e919508176a3988519d3bcf91b55930fed1fc89ea20,
+            0x2131c2ae4df6b479dcf26ed81a1ecfd47e351d7dc790ee906dbafbd803991c4c,
+            0x162bf8864391b12a2b1dafcb658fb94cbfc90e0bddf199cbbc66564550036827,
+            0xc7a2f06399f8766bbc313a2f1fbda042eca4ba85734b4040db27cf4ac1e8ef2,
+            0x2f9fa0e3320e9ac3cf702f8750b5bd1c71c697a583c34cf417706738314eead1,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x9f933726715613504e7cdc8700fac64aff61cd1899b4754249b7e61bdba19f4,
+            0xebcc03b0c123f471bf2e57426211644f0098aac347c81fd12621c7187bb787d,
+            0x246aed0e85ffca6527d79f2e223c37b5d7df029c52d38b340bac3b2d3e2257bc,
+            0xeed1e00ab5b0ecbf337edc63d27cfcf9135997f860f96befc4198c56e59c72,
+            0x4df1a4aa55992245ce955d325c1c08a841f727b9e9ce11cbe54835d575c56fd,
+            0xd5e59bf9fe7755023aaf344298440987786568aa06aa9d03f8a33f70b227fde,
+            0x2ffe56ed078cbe07667f7e48e1a360d4710d046f0bb51130f9b924eee01dc332,
+            0xd13ed4075159b29a4d4ff4f9fd7d768fbd28dd4487a2bdf2a813540bfb99907,
+            0x173512477cbd6d2a69801143d1e7fce3a6ce79cfe3bc2a2ebeed24bb7e6672a4,
+            0xcbd4277bd737219d8739e4e818cecfb664e369782e296a56290020877778329,
+            0x14588264fd7d1fdd6d4ae3e372417fc1ebd7fa434fb945fadc55ee805b81d3e0,
+            0x14acd0cc6605c0c722a1d399ad5433d5450614fc3231d5af742ec5926c35e77c,
+            0x14320d8cb13dcc09670d6e93819b69d7e66504066f9095ed4ff25566d3a066a0,
+            0x1b3e47537a897026a989e433fb7c4eba62144a10781548577de3f370434b6578,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x263d424c886417f9b6ac1de0e2c1bb2e32b870fe671b11e8219760d1ae4ad0b,
+            0x1545d2c32ddd1e1e37103adeeb116e09275624e964f6efba626787ea0b1089d,
+            0x287183d246f54265d2283b5bad5c4dc4ff3e5765025efb643ed93015c1de8a71,
+            0xbc24a36833b64ccaa323f7622d1b9bedcc204bf19b7f83be4c62b8771a2ecee,
+            0x2ac5f667d34cfc3cc80a3788402696009dce7f61ad3483b54de3246cfbdbe164,
+            0x269ec95973b00d3f96125e7daca220f7ebd6bcb6f08df2d39301ba36c6ea4fb,
+            0x1bda71d6e900e79196f126cddb042592ce1b6c0c0b92cd7d86bbb8613c2ee0ef,
+            0x2dd51fa2045a74f10e86b8301210f5acf7bcfb7f40b8d984ed23a00e3268219e,
+            0x81f8b7c05030b310ec5adfe7f6ee0efc0c44b6facb8701fb1aa3852aaa29db2,
+            0x12cd7c92b7efc7b50810ad410dee511e137f3c995e4b8080e98902c5c862452f,
+            0x222b991677686866f2059fb4d66bd16b9f3fff5b65df7c782747dc0bc7dfefb9,
+            0x171f3e3c2562f120982c7dd903d7b74665f3e8d085e398dfc4d7f73a837c0ae9,
+            0x1b7b4bd3c56e17518b850f06f15341f6e610254b420dbd4873030c0f309c3c72,
+            0x16c84ba6c4962352d3073fbefa9034f5d7d1035773e84ea47a70b5cf615c7147,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x3928b7c1f5234a3ef4caf7d19b815c0ce64a8e8906f2dcac43a5ad59c24f14c,
+            0x254ec8b72f52e44c83734b672b33b630e8931d1522f5b25c69273784b997bb46,
+            0x17084c1eb0e0ce6e4baf294ce40d5b24ca44b06ce6551b90d9f0ef7a5caf4339,
+            0xc57ca90acee1624f9315266c48c653bd44400b9424e172953f044338a77b27e,
+            0x5c7aa15848b5250efecf2eefb8b6758751f0e69ed1ece426fe6f85666b6a5a7,
+            0x15ed7d3733abe5c01bc9491e0816d11aec10b0dbfaa86fb47279d7a1448e20b6,
+            0x2fcca33e780707db84102f6a8f1e9a652874845769918754db5d936fbdbdc5d5,
+            0x2d23b90c995b3b2956fbdb6448195ed441e717a7895dc1e433815b9a8077d315,
+            0x138d37c5ccdfefe044ee28894bb422f29e9f3860154ac2ddefdc900bd5b1e2ee,
+            0x801587f5637bdf253298bdb8c8fa556bba51f40c6c4713d73e31a0f0e72ce6f,
+            0x23cf40715c260876a24e43b5c314c2a1cce16e1f412ebcb0916f2fea18e5893d,
+            0x2733d53df2ccff16c87efc741114e39ebbaeff9f12ba0376b931b402629c525c,
+            0x23e801d5f635e9af022f077b1a43f877db7241055d3c71b771ffa75cf6eee4ad,
+            0xd094fe93f2bf4cd4af61d10a7bfe2b145692cb94337ecbff9c91aa88ffcf890,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x93b40efe6c068bfde4c0c198171a60e496e1d834c28765c9afda090405e4a56,
+            0x2305950150a0b9c2cae71061661c181c1a6b3d5c87980b91ca959450e5cad30a,
+            0x2107ba64be5e7797def29bd72b72b8bf0b1428062ee8902aaa58f0676ed03aed,
+            0xed4b91b00cb5bfa594ed5cb57d703424a8f2dd9daf5f54f6fff74e5cb0198d9,
+            0x2c7df01a6a701115c6d07756e4e0359ff5191b58300db58aa98cdf3c985252d1,
+            0x5d54d23f2d684e0c609aaf56ce816de9d5871924ba47ea7025885674f2bd411,
+            0x248f367c66a05a93adc27d36acc9ecdaceac63385cc5389d01a8d7bed9388525,
+            0xef717b148e289194b332dec7ed2ac824317e40beb40d74ac7bfddb23d2b3cc9,
+            0x1559abe59817b0a24492729506cadb87e76fb54f9214ac87346f8013c3032b3,
+            0x3bd5cd6f008061a1c0b2da097013ed88d28caa10de0036904ca03a4bcfade75,
+            0x2ba9dabbe0f9fdc8efff7060142fe244cda2d8feffe907ff23cc61c08b619da8,
+            0x139f0add5443dfbe642f4f60a57ab2502a2faeae1b6f12e1e5e09b1909050fbd,
+            0x8965484ff559d1e6864e3abadb5d8dd402ad180059473b76e9bf827b7542463,
+            0x240c21fb9f6cf7f02e733c6609f9773970098adc7e21b041f7486156b4f78e3c,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x151923a505f13bee4d368e9f471b79b499975b00aabef8962a861e7c858f2999,
+            0x20f6374e3f28e5665b4288c722551c898eb41fd64f2878b47ffc9188812c1e3c,
+            0x1f26fe05c0ecf99843cc88c28bf5c7bb0f744153fcb405c37d4c9e5c60dff349,
+            0x101a3d68872e2a2174e1e73cc53c3034532ccbfc8645ba9bd17744a0a9b7c7ab,
+            0x1015cbc312d356c0ce96131b59584b0794aa717ea120efc994512c1dfdeb4226,
+            0x1a7b53d07ebf6963fe87166c26f5c041019f2210f4eb48383c9abe98a35c3c77,
+            0x8fd8a0e2a1df82e44da83d916b870960f621aa62a5336b9cd0bb124bd30ed8,
+            0x2c43cee66409ac215740bc8b1f684999679b5e240301f8030ad3fef640e05c51,
+            0x2c29dbf22349ffb1635b0182ea7d3ba41c0748fe4bf06b44a401cd15eb0ef330,
+            0x1c13b6b5651a6d7f3929ab0946246f7366f5addc9d360bc5ddce3599638a090c,
+            0x10171b916d8a14075abfe7c468b01d239c7043a8f97df103701e716bf5a73f29,
+            0xc57c3d6c68c9d2da843ac9b37adcf1c46a3e0eac7c42fda4dfe0ce5c799ae5d,
+            0x131e361e5a8725d01e57c3c77bfa27d1f3329533b82ef4b01a1ab3ddad098856,
+            0xfd9e076ff4f5dc71afbb2743c74f080a43853793f8f6d80a93f3cdd39012fa8,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1573d9a6d17cf8af947c125da5f9f64516344307d15be028600d7fbbf3a99080,
+            0x2b6645695f714c85742f738822c21a26c8906c1bc19f98e0c34cd1eb463da48a,
+            0x2fec770ae63e759af86d0742b049eb76e81d45f6807728e66930d00cb9e1a404,
+            0x24ed0296e066560c8dcb239e7e7f39ddcb1898e5836543f8e98aeccb6f6144fc,
+            0x1ace8484c0d96d050ade091dbcf0c6cd9bef86884bbec6f8ee56ca5ff46b9325,
+            0x110a7faed51892c73e54c654f2fa35e47fd2647d90d6e5e5a8afef6dda4da73d,
+            0x1491aa7f36d89ac133fa9992990af2913b71196cb0d0c3511c34aa52af7d4fe4,
+            0x20cb0c1cd1adeefa16498b4673c4596b37f34fdfe83a41065c1fab66c42f34b5,
+            0x1ba292539d1568ec6a3e2615134dbb5134c73e6b14deca4c1b1a993f9441c830,
+            0x21bbe75d7c858ac948623d0de8c35924f28f466ef62a7a473d6a1b4f592a007d,
+            0x1c96f9fb4c6bc33d46892d8826bd0c2f24d7dbbf38d9dbecf09e77f69bd701f2,
+            0x12d33ecdd6482928f8aac0987910bbc372ba2f107d6e2a25fee34e82f10be2d5,
+            0x2c1b610ce987acbfcda328fd40b56c209b6a944bf5781e3a77d1af9fa30baa6f,
+            0x2d77c3f420a31d59dc0cf83c4518721eca03f4c8913fac371b553b966cfea46e,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1e081cb9e91ff3eb0d111f2be59f4ec3febd9407a69ecb0778d7355ed3048ced,
+            0x2e0888b957e0fcfecca2a1157dd74cb01a1d8545d15ca25f937c554195da3c9d,
+            0x14434487e62089ed7659870346fb4acabe0f9f9ead2a19657a88cac39f773bbe,
+            0x9299821c0f470cc59fb688b6e57522d7f57aff1e589dc15722869ede760a9e1,
+            0x1f1ce2cba9b4c9aad6bcaf3bf03f690e267acf7e335863a54e6987634279b9d2,
+            0x199fab9479b7b342dfb6dfcd8adcdb5ef8cd9cacd897ff15a3445379d86fd826,
+            0x2bcff4e8008af4e04f02c3373fb37247aa873ce7b7caa35030fba7360479a6d6,
+            0x3b2b37e288090ff11cd831c00b9fbedf6d82e97540c5607b59a1a5ab4e305c2,
+            0xd3c39eb880cde63d9a4fec82a68313c912a25d4638a1f6177adf9d841d3d84,
+            0x121da38157e113a3b3e4060acab7e1b40b36ce2e2a677e5bef5abebd6d4c94b1,
+            0x1a5923736c007cdd31311b26d560615fadc7e01e86240033e1f2465e93df234a,
+            0x90f568d806c5c4b1b5e61542ba122cf1f5d4aed3966c26508d824c3228e97a0,
+            0x20d2b7987c326a68610ba3cecd0b4dc54c90390df012b7d96170d9693c29cd01,
+            0x3020b14b8e1529cdd9289680c5ad441627632cab08b206759d28e76a0fbfe97,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1aed16276f89ca766d4502fe21ccce046a63cd2f7d44a0aa8770771e2f012eee,
+            0x29a61b71b5a33237899eca4e7f4e40d008c97a32bbeb0c7c09d8f24d6ca574c6,
+            0x301dabbfd4bbca914d16943cbbfc3ebf006988c86b054d6b613f07ae1d092afc,
+            0x2a3c6d1263e470cca3ae533107339b8dfed7700c910039b2b45b2bc67575f9f4,
+            0x20ff2a6b8212735ccb82ff59798862854e3244244cb0566f5d3d59e341aa36d2,
+            0x2e5dab75ff69d4a42e745287c98107ca9c3e423dc6f41096c039eb9724b8252,
+            0x2f0f8690c7cd4737e913653ebd84f51d5f727bb6ec729c78c42972aa34d6e4cd,
+            0x2be6c4a5efe483fe0a737eb77df7815a6599f091f021131ef37fd192305c4c53,
+            0x2f18439786b79df3460f437b9fed74ffa5d899e2fc7774ac78afd1c75d7d98b,
+            0x257eb2e8a7939be6bfc59d3fc6fba75da35049a36277c37513de03f6cae91538,
+            0x12f8298c4a68070f15caaf500879659d02c3aa9b771106241917cb6638608133,
+            0x22aa263182f19c8abe727e87a2291fdd6af7014f5ee5ac6c198a108dcf02f539,
+            0x14cee2715a061bc708337507b88d099267ffd7d71962eba1bf7d2a117106b111,
+            0xbea09b03b5e03d2565e9b4f7c43a91ed8137de6dfa41f70ec7b24d58eb7b1b4,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1c01114013e2d2cc0f452ef7ef2b20226cc69e57b028464e95228e951d1cd855,
+            0x25c7e0412d2072062684e96b656c4410dd5d77f644c64b1b1c84ad5e882cde60,
+            0x1231e9e375c85c424c5fac79600e91904f849b8fb71c7ab4c37a7ae58c17d5e0,
+            0x7a0a63d6b544338243ae9c846b542b213c67256036a719a44a451b8e621d846,
+            0x2894d383becca5a477263e188d30dd81d7a41e56ef5c85c10d97a309b8daccfe,
+            0x101c0e6bc868c92f99608d9839fb6263313c2ae6efe4d9efc642d577577066b3,
+            0x1d2a84f7475ba65bf319106ab571e734611e0aa742df49e03c98814c215582f1,
+            0x2d2913e61d8423d557920d0a4ce230a35e6f45df0092e1af389d420902295e2b,
+            0x1eed01941020a3099668dfa81b2a57c1639ea6c61ffd2cfce89f696e78023df,
+            0x25417306ef421d8d0a06515c241b62dba2f16368b56c0a09f876850c4d008621,
+            0xbd0953d640552207b0df37f4ab00cfee2f4585286e008d53eb0124464fd5506,
+            0x29beb31dd4af45a599dbda7e3014c88b4b0173b369e9674313022ec3c39d1875,
+            0x25305ba821d4ecca68275fbdfe54f068a8e3b5435bcef6b7bc4a8da67f912917,
+            0x1bfec9a5d8a1c5ed86c4e7fdbb6b96e302602d14f55488b1b98644e612208088,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x177f31701c5cd86c2135c582fa22d1fa1005ad148e125c80046a52f99a278a07,
+            0x84b44037ca846dc363a64737ed25eae81e47527aad42c8b860d2f167fc86299,
+            0x5db3b44bdbc42b1b4f26c99fe1a2cf645f28e6ce71253d92a406dd86a607bcf,
+            0x1878ea943321eb7644a12615ea82860ffad4e28428239902a7f4fb2fd33464bf,
+            0x124df4728f64270968bda5aef3424393b51e84bcc672db75983ccca6e6efb12d,
+            0x23650e1dad9d21e3b5a1140b178f9d57e838a0938bdc88ad7c23256b09624fe3,
+            0x201a52e3c2b36532a496eb42060c6150fd7dc3ac2db72df850c3a2e3f254654b,
+            0x1f4978ca0763083af095848af1757750ea81d782d96385665df0b60121ede60,
+            0xb98fdbb00789a5b9590ef157c1907a3e9bd3cb67887bba7a251b58cd45867bc,
+            0xa497dff0328c9b639bfb1f441586b3db11c09773623bdbc12c40ce544d90504,
+            0xeb016dd39c878c0b09b6c6e86c6527f9cbdf0992e71d929855f0d4525775008,
+            0x18efdc04259cca1130aedc7167097d26eea98c38db92d699f7140d3148b782a1,
+            0x126f37ef258caacf14662c6e1f6df9dc4fc6d1792a17be1af28439b6b7c98de2,
+            0x288928203b020d9e6a57ee9e15ac29d64e2777ee080493070517c1a3338cbbf9,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x296ea4e3760ee3d1cbfabf9cb73a506d7cd78b9a28ea959e977d056cb07185dc,
+            0x9a7542033713ab98cae7b350528046a818dc1bc4daf2c2119d38abb2e0877a3,
+            0x3034706ae9245292d2aef241b738bd3b0b211757e4c2e0137e2c65c1e3c67d17,
+            0x104ca211af2cb44baee1525e9c4887c1ca96f2d147148d6f8d7083ef975b4fd7,
+            0x1b523f8867ec145c19ff50d4bdb5606c20ff01ab3bce0c0768fc28a4a3d595a6,
+            0xd5edeaf84c1e75e0d4f670c09dfaa070db33640e744336c60b18d1b9b90496a,
+            0x5124b407c8fb40067ff8163af388ac99b168031ecc22aa7423e756fef6c962c,
+            0x8ca29ea50b36354afce9507079a06f06753a3e21362599c3b72d542050c49dc,
+            0x4c3626ce2dbc4d64f6ab695c59f8f51f383a183e5033700af83f83c3189c1e9,
+            0x14bf66fe46f1f1180c24f16aeb7dec3f4ad00c1b6e9988c5642b549609b37573,
+            0x67b2bfe7bce2dfbfeb90eeedba00121ed2622c38d4044ea6de739dfd5f75d16,
+            0x9287eb9fb34d9ff43ebf373466427795393823f8d70c88ea76dbd7ac989bd6d,
+            0x16ff59f0d679ae8e74aeafccd0714d966c4fe1936aa0c7fbaf8828168850524b,
+            0x2051d8ce6c5dcebc2d7ffe11130757bcf7cd14283103d3fde53e7f7a880a8519,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1d360ee3116f0744286da43406049bd1b821cfa4c3e823752c00f0451c942254,
+            0x1f6ccdc7743ba72305a0491a306aacf4e3b036b0f0602daa88feb8fd8cc62cac,
+            0xf8507197161fa267d0c68cd381d423f3880ca56ebd0d7ecec6ae88fa68d7a2f,
+            0x18b4a57860ae5f6b5ac2d4f8c924b2bb3872dca3db783bae02da366fc84b7a14,
+            0xaf716e6f1286cfdfdd93f1417a064cd76b1a7e2347d61d9b1821eb8a4ddeebc,
+            0x14f128af47080db5d122ae1a8bae27475c1933fe73cfe2a80d89380b2147915e,
+            0x1f2f97cd81cfeaf9ab80320e688f2af45c9dfc4a74f7227c7205fb05697ce2f2,
+            0x7a985fca61c3346a08e8fc31167636507b13885850b9cbc64798de9b76cc57a,
+            0x280e7d98a95b9e3ebce1a4d8325d69f42ae8c7f7325a04bfdfcd531a70d0816b,
+            0x1cce1cb692b8c6c02c7b6a2e20d1fc36f031bcc44ff6bff0c4abb5b1c743af5,
+            0x2ac9fd902f4b6bc5f917228507b403859cb67077ec2beae84ca18677858e5686,
+            0x1b69cbf6f6bcec50e71597c63a62a8253a63412612ce4e79b262753831b970e,
+            0x981ecb674c4f9996a0f8f019d64520c9d933ad0c6375f17a643430355113cac,
+            0x14faa8f8184c8aca46363826f864877722020035970dbf1090d4d3911db9a9eb,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1a6906fda19b094b2bd4def4b25eaf4d799cf919d0e1483d9380180064116cf1,
+            0x1ab6dc94517f1a235d1107902b6c034b5535cfbe94ca9096bf72330be04b179e,
+            0x15669b5e4dcd66cf29b6c06a9308f8672f88d069e7e8eac7cb11808b82913038,
+            0x132f02aebee7db7f69fdb68ca8fbd57f387664e6420fe20060941344fe5b63fc,
+            0x46f52fecf6e77a95b31226d34954f28b9d0e2e8008de5b3d11c274d7e44fe1b,
+            0x2b69ede24d4e37f1a8c1d58edf35d0a7f9a0716c3f709cfe5cfa6f069fc7dcd6,
+            0xdc2cca8f0d3eff4d287722ba1c50b9062230d5b6c748aa4d7003385ec5424b2,
+            0xd1b03d009a6a0295cdbc9f23ef32bc2933f30a8baf2360203ab064b69388339,
+            0x1a1972438cf29f99b6802d9a1b24efc501739c6d7278a5f30b1667c2b7bfc5d6,
+            0x203dd92f30579361e8ecfe9e084cb41cbaf7b93fad6d7f7abc9d0f73fba44075,
+            0x9d6f86adffae5e4fa6d5dfa644e97a5b382a1c7e90514bea8ecd1da42773380,
+            0x12d40572e1dbe47334a16c73922e7c4da9675a76d5fe099027ba003cee8f2b8e,
+            0xc3c34e73158918b72653147d1e3d059b256c1657fe50430a778e63f6140550e,
+            0x6973060f725dfae61acbcf3171f17ae957cd862e86f9fc6a47fc7ace24a8867,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1b3a5512b18428893b48c2fe915756e7cc7aeaa8ca36c2eff6dab81568264de1,
+            0x2ab9670c18ff8edc1c84c1ab36ca686990f07e16b567bf9642165edaa5a6346e,
+            0x10660d5082b8fcb7f5f4eb051f926e99a5fedbd706fe191bb18c26d34be30763,
+            0x1aecba1af9b70281bc2722c0d82a097305c208a383c68330a1633fe3b59c94a7,
+            0xd23a06e79761902a6ef30749c86998c3d20bc827cfbe2f22bba0f484dcc04d7,
+            0x282b6bffb062fbebaa4772f808780b00b77da1c52fa648bd74ae0ad49fc62d9f,
+            0x27d48b15b151378a1e738977abc4ce2d8bcab816dc32797ca060ee009ac74444,
+            0x2552efb9ecebe9e17a82574887359facf5cd61ab2ea64bcd60c50e053124376d,
+            0x2e505630db4463f1d226d0e1fcc5be4ce4577e3911bd3262317a4fb32d7f8ea7,
+            0x1d85ef93d9f0524c0d579400f62d8fa7f6235c8631bad07509d79e20db614ad7,
+            0x24bac63bf16607fb32c48e942d0cbec8b7fb18554f342d6973a6fe3a309c6248,
+            0x2403a33705855d9d4456779033eeb1938e9c9bcedc4f1b28f90c7fce3e4f39dc,
+            0xe661908904f5e530a16e3c1184aacd43ecbbfaefe6b55899026b9fc9940db1b,
+            0xee6336e66fcdb3a64d86b979baab0bd235291bdfb213ed532aefa0a72e5c3a8,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0xbc63f41651e844c66007421b547d69d694573b1343b8583aadeb8f39b9c5af7,
+            0xe5cdb3465f12743f71ef5f504e6a5927eb824266a82bd02df035efe08e921f0,
+            0x1a0af69734aab2e4304d15e7a69b2e64956b4214c330d935647b2b127f6afd94,
+            0x2144915f6e6f829e7179c5c005ffe6c9ee3a796e32de5577225696a77e7c381d,
+            0x24b6274d2f945bda6058c3366b6d91e33740897c6e6f133304487b63bf0ba435,
+            0x10efc44751f6ba491452b84a92594336c6ff4012098f9fe85420242cdf082baf,
+            0x36ebc6a6fcb98eed5d0dcf87239433879d99acf6fbdc570510ed6c825055dea,
+            0x17a1b2378fea94d0b1a96ea700505bb45c4318c9b911949a7107414f636a91cc,
+            0x2e455a7518e54ec2e0fdcdd2821e488877c594f854131e6a9aee732db95666d6,
+            0x1e7397644ed4f4cbb8e931b0db4904f29102b50a3ca839c43ac4c0c399c9a8ae,
+            0xdf88ef1f1a67a39feb725316726c97b084981300a496619a38d3fefb6d362f,
+            0x24e11fc9c4c7763829d801dd3a205359bb3792da2ef8b2741ab3b2c54acec8ad,
+            0x4920b3e800f77d7cc99d8ee4d0141a45d27929e6e4a7d7bc4193ae25ae82033,
+            0x20ab7b6abd43a88f684217ef931c13cc11908564c8603e01993b0e277ab29f8e,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x10f8a59f8273eacdb9154a734653e4ff7fce0da404f36b2fd001b3f077ba68b0,
+            0x1652153e375ecd237c21acdc3f96d39088fd656dff8d66f867de878470fb391f,
+            0x12a4756111ec068e3b9c4a1427b09f9a313e018d831f7ae5efe9f3f6c61c13f4,
+            0x11243b19f113241477e4790f89b8ea79666796ebaa31cc2ce3700ff51ed3cbf0,
+            0x93d6ab40a9a4a3bd74f097120654c82fecfbefd1067f73ba5aaf031b1c18c35,
+            0x2f26911b23466c23bdffbb8aba815752b6d0bde3d12088becad0b08fd1dc4976,
+            0x1a03dabe66a3037832d93a1c3c33574c5b28787fa643ec5149830f81ecc92bda,
+            0x223b10c2c547e1a2ba41fb918bb5ab602a9ff21a19c37c157ffaebc95bac4870,
+            0x1f271876f17d7ccebb222aa3da4cc09407aab4dfdd453f1ddcf248631eec1088,
+            0x1adb58add70e22de5100c3f187057e930c9d122e128c3d1159874c304dcc1090,
+            0x27b3f7ea1e34373d8183be5e462f0ec51d5d0c8bf049a2b48d30ca821b368afc,
+            0x1e5ab69a6f006ef5ff38e49fc34b58d101ae90bacc8a638c353a636ac6e0cc6,
+            0x14ebbd0ad1f23e2c7af18b8c43a41e86492189f38299783c3edf8e9fa8a2073f,
+            0x939c8f74cf317552b74f7ad2ad5d0accf3e02ac3b9e67a91964539bcf09295c,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1a55cdf6625cb645cd6090c3f525f6e297864a501041dcbcdb37b6f15af7e36a,
+            0x27af5f96cbc32f217ffe217d4d478a315f2095286d6589ae3510e847a7741009,
+            0x2210a4f1e6607e23b90a45345ccc56984bc8a6256c661f04292b78523bdcc7e8,
+            0x21f9fb0fc7ea61cd6d0ff2d35785d6e7d15c7a9cda7cbd3e39c44166f4b175b4,
+            0x1ee5d14567c941c70d07adfb6dd50467eb0668b7bdd1fce1879bdceeb059f94f,
+            0x246ed97e4eadebe50c8a0afdebd6598030f27e87b89f0bf73090da4d95f12c63,
+            0x16f44dd900dd9f274617e2d614733244838171bf0c89ac30256eeabd5c8ee945,
+            0x1e45e42c3dcea63b20518075c16745af5e20536983b16f632d3c15c91b3d7d16,
+            0x19fac5ce0028674ce8bb40058162e50f9f9f8b8905540fb7722930cbb20112a1,
+            0x1190997dcdb0f5772ca3de8b876a4be62f8ee0b39d6c233c95848d073a8ed6a0,
+            0x96c7db7d0085737934ded26317191715fa6c789de3df7e68f00e8af528530f3,
+            0x1c21d771cd0338f0c0c00ff71e4af2c1d7db81922ced098fe6989afe7d1e4d19,
+            0x2dd43d3c40b768f5625758dc35668efb3ba747347d5ffc980ec0b0cbab709c8b,
+            0x1030059f96d75e04bc5f81b89fb7b5b0fff0361adf04c4f0cede89630d2f037a,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1635019295b65b0190fdd718927dafe4c0c965772665800cfd539d559f0900a9,
+            0x2c17c890b715b3bbec14cfc8f060ea84d7c12df2e51cc1e8a6e987f45c01674a,
+            0xc8ffea42dd7b206033427a512377d3054fe4f8f86357aac58032fa2dfe7c7ed,
+            0x12fa55dfd670309af2d98c8de77c302a5ee4ca3eb08b90f27230f05ff4287c7f,
+            0x9009662a5a28a89ae9d6da9b3981767d2cced18677e42773fd4334297d6efa9,
+            0x25caebb5501e77f1731a54be0e06f8c005176127f3556ddcbe24fb5804e08206,
+            0x195e006734786e591acd92fd233f784503f3fdb5db18299592de56d770028a9,
+            0x47885b986f4d10ab44463042a0bfc3adfa3bb9b553bac96ed40f616291bce26,
+            0x930f3aa1c5410395f9b17a20a1753b721a0291fda6f32bee8aaa6ede298d720,
+            0x24af63803104e8318c3e7a41cf8027ad36a631ea11d56552bedb5f00239f902a,
+            0x27c63e725d17d9a44f47fc73f02d7bb2150ba0f6031f004e600ce008440aef5,
+            0x157270a74e4ecc8bb6f976c5bdce70912cf64fe9c8816d62d42b0eacd9514dab,
+            0x2190e7e822c0508c71e3ab7134fd89a40775be99a1b38c2767f6313835eef8b0,
+            0x234f3cd5e0cf731da507c91ae18d28061082ae9aa580746149d1a48f6a8db2a6,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1433fc6bf42a2541e40c104a24d5cb9d462fb71bf094bd998c85933874eee2f3,
+            0x10a8445d83f3b7ec65128083a39f5c759b9f52bb8ce5c024be8e2d300e0cc652,
+            0x1a1d8481d39a772911f9bcee025d79049764dceb488a8275f03a39870fb4c909,
+            0x82dea281aa11435a7429463b3fadaa3bc680aaf49f02ee5c40d110f63731a47,
+            0x13556947fd0714aed251e0fcf91cd0e8d0fef2dac3db4ff9f3b6c5365ee9ba2d,
+            0x29508794226e7cb06bc170032d377edc210dabebd3a254ecd4df794d65f8cf47,
+            0x3cf4fecc54b529b247e48048a963709b22630ce719ac8a9e9d1f8e74b73e702,
+            0x16cc17305b3d333276a9cb43d51089ead04dc2f1e197fff0012d4c7c4db5829a,
+            0xc36f031884453fce7824bd724f25e8fe71d3e640baedd9398a719d8f01c560a,
+            0x50ff40107aafa9a2e30ea1a24b64129fe55da84a294ca8d0afcb9956ab09797,
+            0x28b18039884a6d69dafea66b723072e0c55b1fdab6b247e801d6cdd52c7f81b9,
+            0xbe18fb2749573c5b7b7534ef3cb0ad5651a801b3c6bb875fdf30cf8b155d8e6,
+            0x2ed3ba243fb561e308a7da234e581898983172e58ce98d9a94aee5b6de925b5f,
+            0x248eb1ee129d515abdd9f65a6fa7711b708374187faa61acbbb6d21b2e26dc7c,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x89fb8b0837e0b7c9598c3bb5efc40e62ff31e66ea4f5e51b9330a20f9d5e553,
+            0x2c17324ec8d80ef220016641f18bb8ef3ad0d18e4de8dec2ca81215591dae7be,
+            0x23c089339439d665507c0e956ab3208b27d643526045f4afcbe6364c44bf1093,
+            0x32af6e9b670edec4744d9be16c2fb05dffd7742b035c5d5e34589f5cae382e4,
+            0x13cb85e74878132b6a20784e3bf61df1818c4d6141651d1dad1efacd58774174,
+            0x2db07c1bff2eeec8c5b9dbae586d6a9e7dff129340512ee92c27fe3acba78c1b,
+            0x9829878aad19da18247b6ee680b5d3f8d94c0b046c24fa5641cc07813031830,
+            0x1eb00d50e3b0c3ecda0b569d961583ba3ba49a3fdf62eab4137ab4ecd16515e7,
+            0x1c92d7b2ab89c954d36a5da4466d4ce8fe3476cab10bc76716e6fa1469d3c881,
+            0x29412e4f79957b5aa484f896baa95977808d2ea76cd61e0be6e705aa9c31c419,
+            0xba6668da5d5bde10cdc9aeda5a050d864ee2f72f84ca600a303aa2f380cfef2,
+            0xe3041c5fe0dabf954e6d9ab5519e5389cb3ed02301755f24be4c400844a019a,
+            0x46f80bc5455aac3228986ff1910d988a8608cc8eea186ab821e5b8cb88a8a9d,
+            0x886037252df484b3b2e909f79ef69e24c2b0f0a9b912d666cf624b888d7958e,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1e5db2e40041ad9d844fc08e4932c2a893f14e107a68534c2f70fed480beedbf,
+            0x2d0e5945cf1ff11b864b86659e60292c1d76e29a88d35e2d25007c3aff574837,
+            0x5eda1c9de06b29e901b43f4dbeef95746bade9533d07a22b08ee2cf948bf827,
+            0x92156bc60919beb0e2c262d9b4ca9c888221b1236839a25a9457b4d475754a9,
+            0x20346a64ef27480102685c39833600f03276e5e4094eba2077457246bb5b0920,
+            0x10807d847901c2b7ae90b281bf84af1645abbcfb22fec7626418273a5c4061d8,
+            0x1a02e561e4e6c7e5c33b9eed477176c2927cd2331f07d9eadd6ec80d2d77c3cf,
+            0x1a20365486ae8bbffe437fff696c78cb344622ae0d25c8b6b1b1deb62fd03bb7,
+            0x10f6bc198813943da2300d26f081cabc8dafd92a953077575e8e2ae4b5b60fb3,
+            0x1d7d5aaea8bfae19980b3c529fab08e7187cd71a706f39115ad1cf0b7f57f556,
+            0x1df1dd45ad494f1a872a88240c1a9ac86c18265890d36f5b57f84a6db388b35c,
+            0x1c29d88c5a7e44b8511c878720f8edbd2ec09956d2a47125ad08cd791a72a786,
+            0x2aee9b55a2f615b6fbffcce84c652a3f41351fcda1b830ff3beafb075d0472b4,
+            0x1c9ca1baa0f3d242d39a3ab72580877c176e28a5c887c004279a59b0bcf1e66f,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1e2b6b0bf7b3b4ed5126b8e8be6b6b070efc28d062f8914ba1b5fc68ed14ee06,
+            0x2b00a882fcafe8d43e7da424366a73da0b7cab19478446f56da7a29bbf24abd5,
+            0x441070dc965c1abb15cc4dcd6668cfa56f1122903318ebadbe52af6495c4e9e,
+            0x1804350e3abaa426cf301eb0241d2f1726387efbf0df6f0c303cd0f983997d57,
+            0x1eafed7d64d1deab8a1b3ef80d833b3aae94efc9f89286a55789c6b87d637b1f,
+            0xc08b894acdae0abb3e1c1f653a150d96e0666a92e8a6f732d8b438e2ff7e631,
+            0x2317408517ec88bd778bae7b26efbba777aa1b4460c3af71cac88aa1d4d2d7b,
+            0x17dccbe73f5a7b036e83f6233c651c883a7957861eaefbb385468785b5592d3b,
+            0xa9ad70b9945cdfa736dbac21e4b4426515ed32fdf0476217415ca4edcdec1f,
+            0x12b21302572045aa13728b65b9e6da2dd6a00b49c9acf7418d03431b663ec316,
+            0x2f73e6061be74d0dbe147fc3de191cf54657e3516a60a6da650dca53c6d4b8,
+            0xb907e76289b21473c0e6491744411e520896aa614d955fa3b7e73d25d4f560e,
+            0x23c6f78eb1f358e4f34d7a1d58577cd8af362c8d7a650c9c70b7cef28c8b77b0,
+            0x1fe537054dffac7ef4fff98a49f253a17562d32eeb1903ff3172e8089f88a5c,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x22420a556a4009accb54c2b2266ba65776d5455a7944ece37405f2bbb849e352,
+            0x1ad1968f9921575a75470f22eb1f2e2e3a6b973c58e22ff30c731f97064bd055,
+            0x2d709e99d4fc4d59e9dab4baad17bbd75d2331e8a448c2595c835e96ece5930b,
+            0xe1df1d829c920e063cdff32342f223e7b4851df78ffcba180df460988e8570a,
+            0x23c4fbbe1b0de3e8b57a6137c331e3b284504bbb9f20fbe9dc2b304194ccb264,
+            0x2ecbb2ad59823898278473d8a768598a22d2be7922c292a964c953080ad8a690,
+            0x5dba95d04fff06245d0f4ced407a98571bb522547bfbba6c61731884c4d4e30,
+            0x1b6b4761d189d1e2db04e13f1702f4a15315e1b4061312633fbd2f7d9c943b01,
+            0x1ee6c5f07a003e7f7cf05ca63ec2c5cb85f0137f55e1e62c81c9b4a40d9bdc29,
+            0x802b4548da3f90ea8a49c26cf583724835d8add489da81917c17ff7686c97e0,
+            0x1a3089854e45defe9e953808e58f14cd0f0edb9d65302732ce5450c92ca79885,
+            0x2133779fb03912c1f1db22b59f3a8e96d396173ce7c5abee98f05119b914b700,
+            0x18dcc23fdade276e5c1ba4f96a47cba57ccbcd1102fb8d063723523e2d819b39,
+            0x2a1b87020f3b905940f757cee7f0b459217ea429b77a9ed2404cf9655763e105,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x47bbdc4836a3ffd940aeb2c8608a75fb37d4e0ed1929fa893124a87046333f,
+            0x2fe188cebef3df8090f27fd40d4e1f557b2a13aafcdbd36d53cdb99ec48fa13e,
+            0x1eefea2f42ed57d18b8bf7591ddfd0f54a4e7434646e84e7c79a15d2f879aaac,
+            0x1394c009ab5cc43d8ea089286a43d30c904d227e9a151549bbb7f4d0cf930aa2,
+            0x2a0bb922c5a36f42819d00bec63da58d50b6dd46ff20d2a3b29c1c2e1e0ff837,
+            0x270b2526008fda515788b4e38ea86c9c9dc4d650ffce9638f91b85453deded4d,
+            0x2ba1e2d2ebe659e779301d63ecde988d55432d5bd7f8a4f76a03e20fa31fddd7,
+            0xf56832b7f06a8a3a1c287b8497ae10dc05f216917450813f21ffda4c0effad0,
+            0x1959a0963b974ace1dbef8ddb09c9ccff9ecbf4dfa10c2c174d42d523098cfdc,
+            0x148da04f0aeb03cea78009e2d1192865f5b99d630681b71ce71f9ec05ed55b69,
+            0x51a40af416f4fb5f9f0f51faee0ae6be210f9b93c4ead16f2c9a96a855c41ac,
+            0x20973f1fab9890ed48723af234150d1ecca066629dc1d07031c6cab5e60a3efe,
+            0x2a28a24ef1bdd75a7e501a4f035c1b431f4d7554df5facd800ecd3f024ec8152,
+            0x1d2ee4e18fa1575fb3ff723b3f9ad35cb0997b436f85746c6857882068333148,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2629999fb52514197199686aa4c0b0961d8aa48404241177e131bc2396fda732,
+            0x1f99369d70a63bad0b76652ea69f388fa92ba1658836fa3aed366744ececdec0,
+            0x4511f41649be85e455ce74338ebb425c895f88540244a554c9947bce88e6edc,
+            0xb696f753615462876b9efe2ee1fed79c49becdcfa3a2d0d04a29051334ca110,
+            0x214f09b5557846662636de4679dcd965611c3d78e8d50a2cb0589c3ec90c9924,
+            0xbf5835b4c0bc4b13a3dbe0fbd68fabd6ea6749b70450547f0c2e3b658c01301,
+            0xc48c640e88a6442ae5ac574221d7f10eb2e67ca30fb0bf169cde004f4ded504,
+            0x1a5935756b57bfe02a3efedbae26e5a13200bee0994712005589ddfc1ab5b8c,
+            0x386ba86a06566ae39b56cda79580aed0647b9636896a47a7e0e9aa9919d9c02,
+            0xf00775e400bdc3e8685b204f07964e28163ecb3c63165d46c3f463e7baffe8,
+            0x1a662d8ba07d915cf7504cdbc01ec2a676ed76347ddd4e07f370e249a7b8ea5c,
+            0x1f06133283ad793171f99a4e8cbd2cfb465d9d6af9ffb4592d90293421750faa,
+            0xf83059507c852c9750d5280c440af49da9bb328ee63d1daceefd0becb214fda,
+            0x14d1ebfbc4c284f016134d6ab56daddb4e647593caa1324ecb302a77ef0b3bd1,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x5d4c4270c1e940348df545abf1e79bf647658d2e79eacd5dcbf97d68d05f3ec,
+            0x275db6ddf370d2f7e21020dfc1106254f1c60fbb7de07efeec3d6722b04bc54e,
+            0xd8e04364c5a23a60f46b4548459c7e7c002b73efa630bd165ab3b6a87f96489,
+            0x17f1de99ff5b961493bef67f162e464c42481e448122fa5baecec8cae0b2192,
+            0x23da50aaa25b76f0dad9f50db23d12f64a4819f547027b6bf52768799362e83d,
+            0x6d4ab87edb0fa0ea037a4f5ea1583c4198129f067829169c06e7440f354499,
+            0x18ff576eac16541cea173c61aeb541e0761cddbefb4a90f144818947d16013aa,
+            0x1408d644973d6502f93fdd2f69a71093a9fe50d7f8061acb474a0a14ba304f44,
+            0x29e8f556928e09634fd0b950e5bf4e90470d45e3c16b13864d598c555e57b1e6,
+            0x1637adc0e2bc513402f3a8b5314017d7ae192c809c41f3348226dd50ed82542e,
+            0x73235d0a9e96cf86e0976953988a3d9a260ceb59ba7633a40cbd7fede78a51a,
+            0x6dd5e9ba875bfe6f6596ba3cf35ec2342bd03422f134ab99ab7dddb9778b830,
+            0x18f491c6c3b12acd06a117563f067440ac753ec468a5df0c123498fbdf0f143d,
+            0x2d09fae126d15952c2b91d311932c93cff8cda2b44ce74c5d1d6dd132f4cf0bc,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x1022b57f4ec134a8f7e574fb62093d415b876af638133d32d366a9b1adf620f0,
+            0x14d51a25fd8d1dc5c7720bb793a275d83d812983965bc9b05d306794cf1dcdf3,
+            0x2c6a7b31575f327009eed05f25f94a4f173a544a0d8fac673474177b3b9a1413,
+            0x304d2a4701c43333827db71975d9c2c4e675056a2ea1e9b72a0eaf127b25efb0,
+            0x11f7c6c76441a67bc5946687a40a28a6cdcbd0ade84c389115b744115c627fb0,
+            0x9a1baacd8b557f09fc35e6434ecfe9182a04537171ee1d2bd603f5378206804,
+            0x8926a69b2d5a4200ee36f786770139781eb60a7d272d31406b75104efcbd3a1,
+            0x21135de3337256600fabf590e04c29c5e0875991a67d17eed5f5131c567bf4d8,
+            0x14b248fabdbbed0fd66c899e0a801bbbef4e1afc9bd0abfef471884bfa160841,
+            0x86e20d28f53332b9e09c5af815694ff83f10f379937f09105e98529fd4b4b01,
+            0x1271f30b82cb798656e4465c44a9ff204325f5fd2d2e204f2b5673f78fefa4b7,
+            0x2224a8d0963f1ac4f3e85695e2692e386a3c1492aa58127086e1385b9c2cde80,
+            0xfae50434b1bf26f790caa16ef2562cad5d238130522db3a97c1893b0c81ffc3,
+            0x3f2a142e4084164ecfa6300a4be6abefbe155f5ad84a684f761e75275926052,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x274d4d833700eebb5cf7c8f4fb81c174a108932a0e987d2889d9b93a95d187f4,
+            0xe9bb8c9f9306791b77582a16c53947e12e0dfed0c2adc1ed2116dd451598821,
+            0x26a098e91130e0d10603be0507dd975431923b338b6c0a3890fbb815af28f7b,
+            0x26d653ce08eff8f162c1033b52ea7e67ba0f6a8036bc64d556a75817579698a0,
+            0xa8ef549b90bbf3af6d9fb4db8656b7de9cf14212989422778c52691a0ca83f9,
+            0xac39f4fce06a27f59b5f434e7ae2808da542d1cd5fd18bb4b90e4d15598676e,
+            0x204aed1de3b314f39afe27b3b1bd589a851183aed39cb3004e67deca646266ba,
+            0x158cb2e73c4aec4c054f1759e9f3293b62ae5fdf18f69be4f6ce1c65cc1c155c,
+            0x13040aca2fbe7c001c14ad386c756ba465796b9ca677735d95861600b3ce6b53,
+            0x2674a9a8dffb96d38295f6edd1c5c008e9320ac1e99672b9d05289ce45fc673a,
+            0x57be234d78a86ab47e3691b67a63266519bb62985701f2072494d6343322a41,
+            0x12bbfac6aed9fbbd81254753e8bf4bd4c562e4af62548e577ebc973f77d9af77,
+            0x103b3e26bbc4767aeb96deacd771b5b694b4d57339e351c10507f61bf55d915,
+            0x5f918dc84cbd6a0a32a65b188e3f1c6e3412b76230fc7f6e5b17612c1abe8b9,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x28e6b736e2337dc438ee643098ef22b69c869252509d605d6799ceacd28d6cf0,
+            0x17326264714761dfead5cf52058e2559b4c57d30fa68b4162ab616d4ddf70448,
+            0x26d0b9ad617c87b600e3b27cb797f4b0ded965500a6548b554d2445f49cb614,
+            0x1a57505d738aff598d51ba2c25a4ed8b41f9479332bf95c4a289537dd22a366e,
+            0xbc9463f62daa20f0f245379c9b36c48c26b8f2e7d393e29a3ab5e30539764fb,
+            0xd2de2c5e221a927d1e90617e8be308d83a905bad2c5a5b29ffa06186bd62c96,
+            0x2acfa6917c256caecdfc13513b404367163017f92c68314e4cee7c465c016bef,
+            0x2300a55d94c34ecc47785790d4cebb3ee14f43f36ed26b8a69b1e7641f5703dd,
+            0x1b18386cd94edcc53b5fc04a4f6463badb0b6f1908c53765eb2953449d3bc3db,
+            0x168523fcd8de4e51f21ffaeb5194c5882350e2926f76d76b4908d3e0932b5ea,
+            0x230836236981243f35eca0e25d7c73c4aad7b8b0375ebc53200c5a169d1ba5b8,
+            0x1644931eb3e15ac27e176ba4a0efa23a8cd2cd0a495e0ff1459ba562c39f74a4,
+            0xbdba47f648104678694d1dc3e485f87821387d63b40b643681f6920ee153dae,
+            0x2934ee754f94b9cda4b4193c2da7abf8854286bd37ce1d10faff250466663729,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x15bca736827fe042d7bd64f77821bfb98ac7765effc787fda6427a9c1a3d7817,
+            0x1702aabda38575c6034b350e4b88a2a6ef6a5bccaf04bc9f99321753dc12b1f9,
+            0xfc69497af71268ae3b232540f8c9e5b16fe351e779646f5cf34bf7d41893078,
+            0x13cf63991c3ea2c423f0069eef61d41d30b7a6d907a6cc3f723b241f676131ac,
+            0x8212316344803402735c663b23ffd17261728f9fbd3d91b2f86e227a34cf2b9,
+            0x1d76ef5ad83cca5d452debe5dd11a2a756924c26b546782299e7c9b9e7f6802c,
+            0xff4763e1cbc755ebb7308094877f3ceb4cb0d393e00545eca169da0f82c6c1b,
+            0x2ee17d2391f5e2ada6745b0a56c5b2915abb69437e28975e466d218efe4346f2,
+            0xcdfcd1cf5fb6f404d7686731a9a326dcbab662736555ebe2964d81d7929c86,
+            0xdfa35c85f23318fa0188cd8ccf7a174e89b324b94484e9f1efed3be25eee2ba,
+            0x3020e7189aa0392850f96adb46c8476a9d62951093438a948858a8bdc3400b8b,
+            0xf7d3dc3a1e33f5b68e2b84d9da05e7163b40e8724c46befb4030fa88768e536,
+            0x2331b3e5f7f1277ecb6ef3e862f53047a7cfbfbcd001124d96437a7559e4d954,
+            0x205334d2a003f29e2eba4a0f115f491e159af79d1871614252a23ec2c81ee321,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x5c88b264202385a48b939b006669c1866bcff2ce9be97fac1e2b7fb13ebd8ce,
+            0x34938d22d020660d0a009ac6a5ed48bb0097cde47bbc0d8ce942fb31c464584,
+            0x22162ccea7bdf2b786c635b0bc7132a04f76645b467df815cc521e977cc4f80a,
+            0x27b9ec9c27c0f868a21ff55cf455c2b3a392dd5e57ce6870b90c217ed051b792,
+            0x1d40a01732b59bc72804d5be3dba2fd2be8208fc2f1ffb9a44fbeb30895d6b78,
+            0x25a3c16bb29635132684ee4964e4f7364c9edb73ff5d41c613347f90519098b2,
+            0x2264db5f2b0206e0b97cebaef9ae578d534c98b8a20894d99ff4cc52dd4f35ea,
+            0x8599a766249f3c836cab54623833af8da7345e0f976fc683d04699c33de0097,
+            0x23a4e769c41d56c98af48d9d3eb4e65d5c3cb8f1dc50dcac0895f70176c65966,
+            0x6863319f9840fe8a57bd754b58b7fed2466e86365ef6e678dbe7c495054551a,
+            0x124f8b0efe11009c8a15c7830dac00743a617798bbabda3df6ac877625f3590d,
+            0xc399275a8d3e83e832aab6df8b0849b9d1378376e90b8a24084074e85cc4e32,
+            0x119e48a1b4a77a3a6f7c61ffb60b93c904286828355b63b3fa1f7efa5cba57cd,
+            0x296e14fc6bee3bc2d9dbf89f2482f9891cf1f7df9ddbb7f98292f2bc7fd9a50b,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x26a69af895a05a3493040f735b754e16de06fa2c04c7d990fa5ff5747f83b413,
+            0x9d38fd6121029734acccc26a34b6c0a9c5472d921ef1db0545ea0d2ee58dfc0,
+            0x9258525c420c9158ae4a5b72f73cf036d988c7dd50700b1ed3796a595c5b6d9,
+            0x240b4844e1a39d4cacdaa8cb96df170cc306bd32b46539a155a91d3dec72d330,
+            0x2f7bfd78087629319d6485647f8267856ac5974200d94d165da35c13dd0f1c2b,
+            0x10c3c9daa9b917522fb7c6bc6c18a2a70968ed139a349805a2242d8587b98160,
+            0x42e830892fd09a016aa5998930a085f20871e7305b361d30690064e8680ad2f,
+            0x1bd229a43207a8eb670f87a25910257b4d6e99ba62c30eaf92c41c887b92eeb0,
+            0x179259aee9804902a592512d691fc31fe7369036e50df52f17899e9f310ad8cc,
+            0xc94864bca0ef906ce0f56586a71ebf9cb21907610f55d0d597c910f1832f04a,
+            0x1b8129aa9b54faded8b6e4594ac9c66268f761b4579bab75e4b84565ec6151f9,
+            0x138fc45fe0e94d2f56d913eee6f4dc8362019d48b48bc11d566fb136a034e7fd,
+            0x11ddf7e5f957f4348bd38cc6c2b7b21db6e688426842fe2790dee3e5c7970350,
+            0x273e3a99347d8bb4443f8803f3144b1c79081762f0c89996e8ca6f41e2ce9eb,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x22e161940b597798709d5732b35b7a4a6b5738d60943450c0fcf0015f74a978d,
+            0x2dc5270b47eb00ed0a19788755286e5153486071d8676de57bf1dcc0c95b8269,
+            0x1a70ccda609d7bfdcd04227a1c7b3b5dc51ed832b3209ad05cfff7f94bd17d78,
+            0x1acb2e3c8872171cf04e8e12bdf4aed98903f30427938ff2ce2ac2ca07e89b36,
+            0x2adaf126a0f5fb02185e741d6944b194959178f84bfcf24c66caa70590d009f2,
+            0x1d3244fd2a96a3c547cbcb56974d8a6286e71ade5e026544cfa6a239e32a4a14,
+            0x1bd9988f3abf3347a931f562d4c26b2c6c7c3b157929f1d3529438687ddc9748,
+            0x1ab2d592b1c45380283e92034c93e5a2e4afdd8082525f32728c8bef6293db03,
+            0x25cb1ebe5ef8d7fe207cd159cf795ceda6553f6819f07ccfc9432344648093e5,
+            0x30337709090c96eb2dd63569df081569d7cb09cbdf4a7c8c1a982b1a502bd31f,
+            0x26767fe5b44f802d1ac590b4af55a4cd28f4a4565a03fa412dac54a2d953d6db,
+            0x206a055992663ba140839fb48dde53a37509d75de3cffe05e543ad10e2a6a880,
+            0x26f63a141092d97b431869438f6f4f2eafd3587d1759eb8dc51129be57d1c9e1,
+            0x651190f970efd04e85ceb47f6bb491b2391e7e4c0229354bdd377435decdf02,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x16f9cc64f644433e68a60294430fa2cb5932712fbcf1d867628561f9057b714b,
+            0x271bd08af5ec9271663f987e6d26c91b496975cdf5a2c6a7c5490b62c94041d6,
+            0x29f3ffb8c6f14251d4e4e6479afc22e84b5c306798067eb2ca8530c01ef8f00,
+            0x3011f9b6793cf8e594cffd490b2255eec2d7c84caf1fceb7276fc50d598c4631,
+            0x1592b0301bc7a225be205d464faf0f2620c9879d06b7c97632c4996b255e8b1b,
+            0x1a6cb5aa790973bd44ffb4ed2981c633750d9df8e6a122639648e0a305870d8b,
+            0x3006f88fc72833b83c57897743bbdade1ab69f52bd8788b4406e17ec42bdae3f,
+            0x2738654c515bfb4dd54512aed800e6c044bdb1d4f77cd438945579a03ffa1416,
+            0xb321f51e6793cb25dcd5261f44260a3b7c9f9c44c5ff3ff64260a81d68eb977,
+            0x1477b46d71b8684f6448203310aaf0f8948c1232cbba64f2e6372b26d3b96f59,
+            0x2e11978278f26a764c2c61c66edb6f2964876d189ead6fdc76731044355d9086,
+            0xab2312a0dfec5f56d70efde481c1222f08750d97f0f378e32416d8911347f32,
+            0x293b455b67ef83fb98b09994d43c30ce29dfb9b499ca17c6774eec84412eae78,
+            0x95b635c8679c2757a0299fba438ec55029818e3de0bb66721004d4fde342a5b,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x230291320aaf817c9bdaf62fadc83c8e9d55690dddc6ab42884102fbb8c1313b,
+            0xebf9d983145fe427a9c98d8467c649a6b6fd0666f80cdc3edde2d6103a0bcb9,
+            0x1b8a2f071acf45649491b58cf5576a862c45978ec121aba4cbc2b344f6adcca2,
+            0x24287f43b82f4a84f3a2500829657e4890974e8321736b074241d6d4c6714cc4,
+            0x2ce1f1627b642c8dfaad03fb46498d7f85eba85b778efaebb2bac14d3d4c2f0,
+            0x11ee152a99a5a0de87751aab98180d05db1e64f3621498bef5a821d813fc7ae6,
+            0xce62d91eb6161313ea7e48273122d6a1774f96e571277109302b68c53dadb0c,
+            0x19824bcea6e4ccef8b23d501840bc4f3d40837dc60b4370146a4b68f6f889b91,
+            0x2d1fc70e199a73668b4d0c37356f575269d258aae7199a266e63c88ab6eb4cef,
+            0x321c2b5f8938df1e2cb30488e61521a99706c58f4237e4c61500bdfe47f5626,
+            0xd7da06b4dec9fc5e1dff140172e0a84a9d147154745f2678a98aabc3f7989d,
+            0x2fc41f67cd32d7ec4ee517c8b667c9a0ee2308f759ebd889f6ac043d8aa82f40,
+            0x1fbd55b07a5725b3de1a9739d36114c9340a987b1e66ac212b12795249bd8102,
+            0xae9b9d9f2101c972f848f0a2b7a8916a3a2987bcbdcfa1d300e0b781d2da062,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x19f45db7aec76df1b89fee8492cb760e8f6d298cac167d2aaba4702d30f3105e,
+            0xeb3de3aa60a1e43df813790a7b02b5774bb93b654bb4f690bbbfd8b2e19c155,
+            0xb506abb65dbe55553fa65bc43d1593be440b9c5227fdc84e142ee9365742ff8,
+            0x1725cf40cdabdda24e0cb35d12315bb0bcf61a681ab3f3b6ca2cd06bb6f9d899,
+            0x5b2e0df1727482fc6597c7ada0624819471e4c4f2dbeef58ced0c2e5a2844fb,
+            0x2cb17d3d8a51790efcfaee971ca9155f0074b2e7622abb74d7b8c984feffa7f6,
+            0x57cbe9626c16bb67d7f00009f1e7881b53643eabf6abf3f4bfadb6cf9678388,
+            0x1d5a175df6dcdaa9375d954c5df8ba5bcfb394070967a231cdf753e2277257d,
+            0x27453d445a464bedd2f943123064cf0d6675c8946f077957772f32e02a0fcf29,
+            0xf2e2a7f140c38c5d932d2d6fb694914a060efe9e6bffe14fc1dcbb840bbb466,
+            0x240f3c285bc1a1c717cc08ef209175ce1efbd0aaf894599c629114fb05024f77,
+            0x2dc62be8336218eb9152ec653c5f2d0eda10ffb07a974bae8ee5a370aa497b55,
+            0x1544549442e755807a39faa19a9e88cbe26fe1f5f4cd27fe68fa952806a6e72c,
+            0x26d85311e5bb436e105c2eeccd768ee32acbcd275b22c135bceb61f6fcc99696,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2d5c06ffb3d2b7cf9a0dc797193cfda855060c21de622962dc73de8bc7e5309a,
+            0x1142dc3dd8bcfcffce00dc87253ce16475df11a72de8b35070e2a947e8df89bd,
+            0x1ef9d5eb72934c51099404ef52f846564f9d5956a61fa690c1a474ec6dd4ad2f,
+            0x1f875fbc8a4be018170a281b3f9c0dab5e91371ee3101e6eeece15ff9ba2a595,
+            0xc7ea4455b4e9ea7958d0549f098eccc22e73f89b049f48558910bb97226db31,
+            0x1781c95b5bb00bfc0c5280da9bbc2d16aeb1ddcaeb2c45644041366c0c57b8,
+            0x7d46f4970f0af1bddb0baa2b45ea78c3e043c402b34fe44600919ebb3bc638e,
+            0xb97d904e55808e8d3d847315766069b15e4eaf6e48533679e0d1dc00c70e6c4,
+            0xa424cfc9ac1630f815e1867b2351bc8a7a0577a06a1b3eebf8e1c012883313a,
+            0xab4976c40bbc9fe9106a7610e3e611f88e46839e484ed2160086e0e83c2e4c8,
+            0x2bd44e217b9b1bd7c5c687ad7653730c6a9cbc73ab2e3eca6533ce3fb568a339,
+            0xcce891fce830619bc5fefea2258df3f5653c3ca6050fd8efb3a653643334ed0,
+            0x6cc269de739b7f75a505392122069f46ead236c9fe14dad4b89ed3be765ab46,
+            0x2ce5dad6f8c706a1e48ebcd989cdb6e79161070d56b7f488b1ddaeb207d81805,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x2e77cf5ab513e1badea5c3c891925f9638bd14587f6e342c5a92452cb2216d10,
+            0x1f0a2a3c8f119ff5dc221cd21cf450ccfd2a13a51992e227a040294c78d05bf7,
+            0x8af508a7bea4393d740ddce0e6f0fb819f6e333f12273739f8216a7de28c19c,
+            0xb7b0b5adc8e5b80228ddc5a3bd90a11a6a58fa87ab21faf6b5ee6b4786d3bad,
+            0x29b2720d570c648e23e12c70c5d903c08897ec38e8f79e3dec9f892429df3f63,
+            0x2b5d0114e15e9a524981ea2e38e06976616413a966172a365e702aeb81a3e8fc,
+            0x2f04e33808a800ed501c43a1cc6aaff9ed0b2431f111836ecc36db9fcaf954d,
+            0x75afde514ea96d4ddf31e02c2e3c59b857e12bbef9188703417fdff2b73f0ec,
+            0x294c6a950fcf5693a8241c957ef737cb0e9a2ac3b7eb618a1bd1684db4353e99,
+            0x2b5cfd45d895ab09fb03ee623cff22321018031c835f4bd9446d13995ebc2702,
+            0xc9cc48c4d979b1d5267a49248134fedc8c18e6678c52f82e0ead42df94bc3d9,
+            0x1ab81cab0d091253489ee59b36258e7f07ed92223988de2adf4f431790b7fe73,
+            0x2586cbe245b6f98d39e52d3944cf6ecd7f6b02fe5125fc06677fa3adb5c4b3de,
+            0x13b2352a38dbffaf3d06de3fa376edf5b2ee4e53a57be01229dbac8729a4fe01,
+            0x1aa4d470abeaa2357079129d114bab1170944f929fc178216ad847d4430f3f27,
+            0x3d877056291c4194282a1028b33bbda54c8c56539d25d3813f0992d563fb344,
+            0x708818327e42247f3895bd0af9998a7f3ab275831a1b7ffa2c0266090f86b75,
+            0x2f6df4925de2c8eedf7a0dd36de0e83bf0ba0e6649447d6fd2a8dac7d4b1b819,
+            0x1333c9e0db6849dd2fc1e56de942f8e59e6ce70f9815f74ec75ee7a710ffcd77,
+            0x12abc89e5164e8c1a20e40cba62920df78cd0d31c641aa3526b5387aa499d864,
+            0xb976c6394d0a9ff18c3ce234a56cf8d9625c11d0fce863278457cb08e1c4983,
+            0x268b0a4cff7f67119358196bcfb46348ca332e1af2efa758b59e922a135d7e61,
+            0x254b8126f45243f14dd8211df41fe5516b35952d56c62678c148e73cdbad3718,
+            0x270712f18b1518fafe093660f492cdbc2fb70ffab31d8a4d8a1934be68792369,
+            0x2bfc3981a249aeaaec4ab9001727d32d4e6fe75598ee964fc85cf30d50df584b,
+            0x16060a17e1b11f851ceab20464572b3d78d582ea050014843101485f65ab723d,
+            0xe73217a106c402e4c6c166cd9ef1fd2a0b16ac1cb43646bc1c726f83177770,
+            0x4b959ca07e7182ca08f2351a03545bd7ab676f740b02331637ea1434c8545ec,
+            0xfc9cc95222f92715cf7476010225e14cc38f314071e50e0f3bc9ec674a8aacc
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_9_config() -> PoseidonConfig<639, 81> {
+pub fn x5_9_config() -> PoseidonConfig<9, 135, 1071> {
     config(
         9,
         8,
         63,
         alpha(),
-        [14715728137766105031387583973733149375806784983272780095398485311648630967927,12450793357728630597819493697261391961392738728208603858426218806728799382497,4427733724068610336929510244982091587998132283636864368924406075658439074153,17863554236640577761956319447874252524561947852685470820159498661269344021716,10723868775598272126873918500257797117892409794706524915527428530195343520361,8041366806917098496431513544630989490693774700064656765914266570204855843526,13046986480231887538692223126751085950758763070227069247275787663666591811005,20228999562936372999611354929112125019466353738760451044697249912024766542482,14238976012080913074226552202264063302466135977295108038770514743089287570221,19486717852389551661121716850619781027370627632295683938875312739716376501717,15733057748709959668511822511174594221965585899587926036013893958610587491491,12041333229715539748857491855115983195198694619439452683631630426350435252478,1829888811413627407640409778757789140470123549237476514374669162490680512211,10288898018349095056494632386514957183841700001184195479721999387950102580094,7360553146019695788111059047354435502690072975650576744373916804385350955674,17476063720528136669048514677420727796180556343667231122803521620226101935369,18384724266969916899691009636435516722111206340289089258767862754828208946542,11046121967047431151707881264774621308937270618998625466342467829704953599782,20018232138773775379089542131722766973741687507582662224374276186775807685863,7926534193496947015875888176706209291021745851605316909116853588598743879034,8826996877877607049084007876351017199517432230182001641783930871320527792100,11760708819943554023765145606995747732169597984739408998714117029765838566505,19598000655770319703844060561747179253151181702222064644764822676806532882514,15036675263180992517064890091049355832990063162957265821390555448206776251789,1053420874580688637503969479036991299021138740018858993455108201424412879748,3723543690610038931361367959096800720510056325209292666118208798533818425035,4599370243050726453512484851927735252841106375733105184316191846221056036380,18291400382386598447603657416871816375751118990979359745849342284893280004873,300341627009231088404894405580745838091318300821994947846008201887884150151,13332605655619720841053062902143052543375741442250678582318225211621890248982,13197729598850829723360679245789196039442968018972826673455394330035263151299,510788688496484172389408566109007465667555285205327059265048317979249570221,1685584118031999835794907889275254096486823415278284757369286336252006457602,15103945090904102223538479231258677032197950627619049222966748226967974852043,6653802896618953033344296077900828173967467309849915708475948018848254380036,9254803560511166426410537422101769642611302194250107918342410310963831784950,17006557344160230194691541621666219420787918477303225545533644141096551358258,773112329554511160545400721342977593377624843987783062638455005748446223137,6671483881284330250685026918783029584764740571210869197688044338476895092050,20812941492969561606721983530907505914064782270990490150214736286311482532652,1156984923268097592347582093730300227184163551449762803735684309575717323017,15303159756724065068145651405407765401796657934219121639364061501460295743948,18999785075801878445291021498876384414176522501978873700451842582224940767334,3782716983967799050957535371991538595453996691838733068933109780481907925378,810443910646366078824923626573819081371243815242873044781414798707744583851,3940687718063184864573934886068875138239553970085689518511531571139105765743,1222092197964451545227395363538155091563596468425395922702697716100572937718,11901775018663948557424314950737290815973735008800495766054692238446226616230,21839369981774608005059280910009281502958794510307248992429390932011110951241,819873152679629471918450179717035855395702808145570990556719950289951175212,2918016794043041559376798791171848118057043459636680115122516324180788251680,10788401265856066217998495397128704450484607734353922353470809976686155443188,13599498756047543641157208425687419183141596017402196474108059160235795892976,4993390793677030007023804867617329393931635615810976661139461248253851471412,973050533401342110180605419751137563184725082821038770229241448201970125921,14313276246574487682858906899808269544140218917497205965354285099641091349756,18746777136177241043722556179260854313319807637092383577312657349740719965076,14517023428366357570216698819722831600577825429761151189605029742824536459972,20223198094330596704408798588338060788093323967112845691364940702136543962642,2924401185705980722600796492514644487545258803954418619331883216838542308543,485440919681570468713530641755278841324413691217763990572458853294843435089,21560476826107225363638525612645382878298890750874072774141701406519608285783,7856508582404120415593106596945280577031904101959961641860467517902309769386,1505151890969527772884247006998953879441745452105187039442954300997320053301,18861812597641777105968621029392243993700881183944538936666186678355756609806,11964609307983840306843122014689504510236749206766494519381451521217569407396,17764783391855759749651949748230026302359698415337858912932633638930034077791,16562247632438820849068750036602367255890087581186727955070681252413797347277,3341595358840888933968836940161983842834749603437573997372892853189756769506,3198140245778498430686233550970322127895441994253754893043542706415030678798,9829840339700031668849847901844029075426216057792062644639239580989060312114,5999422607425238131817993672620301343082348300090537110946144186609066413585,19901271533560906428202710740924807375620638454776660078183104891177283526156,16697165654181109350158134734382046723004976300078845885330478879604895897280,19171906568090360833249366643372143476587242793789646446664643684138123124668,5557557332632668793539639636185643553639926364115539987556075445308999628265,4797522865199880517123583692586561796505378758857130153602827907909887751116,15409514194242892627651944305634286919424076146534027188938906487506413405089,10407013998132974348561594118793213466618426284969698091916131778477581263008,2534925381155806875978186916525958864791165037467997034976228683909613017312,16140842893634434452708565053572928560639256480905937421023970743339301598617,7517617592925372620130293329989654305076737363747701594349097857054039164182,17572708764253481596340159581412737527195601517063980704204677005617144607526,16697796470163537491131716229045730242536059781538196375577575057386248458494,38275164685285960308550480834951641755153240877853193094138358285155638204,19780228589871041196871406056718374983456578990309085234484187723923738516508,4573417308961077301452769955811063226515352449986725327722241421281202736681,4768055042642730073498433238804346134649067788593835428664493008393684000706,17566912618951175959416490797476610679702184562687840273697859062459883449046,11477598695424707935165112148975667441147635429812599883095916948275334113413,3408907078049921938725945268376819484694115736385272440041090673225197146180,2488590561390551829094067182419871806900177001183027832070626654223650976899,12116557895894464059885135778994901345424716569754903115015740397131803733982,15881232965640921626180413777392630630338847181632662075996983398726326426432,20914323757596181391651855665547258251038466184617935369425714249299063760685,4275923143992397246911855313401177253209967573031785993454148836244404305934,13098973753894185378061607442839048669135765294488505596582737281481575045554,7995472162206735324879506324600884378126850726543803581430135236761716527753,3690915804478314734124615543749602171459078573370790663994412906012450478823,1256453655839486811750227055618146120819862944082463957526146264573763714294,4406492967670422538631080907830590263463047897583684262207883537903678091970,13380843970691717863215678292643800288491103227905602355694129412234174194363,19680159398793220289979983679401118779763854719759576408245027038965290325739,8515713472495355510508289305321355004480161123461789103991491891201940557902,18392703846804297332972535728243845000077361414687818948278976164182674947067,19823604647876421559318429394175186838817554072847524297827763377975574273192,17719715026846703054856559310322577442906188886145763860157972477138788247667,8745282777320550983079435446349157218001552450433897097227622172209480270781,3259368608255603766247016957318442624095407655100612967940789373312058996520,3379679235619387594255002628664818227413294377266729211815713998759100259668,10282673789366804521601844018863748004632586596870138135887183100195194767004,8431227731426467642712572981755086675999345721043460063547234289139267810255,14117058124827023634266519281629142766485227596060997608233088670325722698559,17113232771025226173986361792697170950811880770802373827827162227101499645884,9906220434844104062978204733717072107397540599291396561476275675218575564970,711369587296778404961826907371863989722457674941832862265420496583620086218,10995654568685707735109869974152491589223292425449581061000447170660561828729,17197923097868441003908860864777521604587651639410061820516916970875615238246,3121715947184842829391029463556305441693293825061846129844634146823663627601,8817835750782344079827519863863370969960597321588294656839911940551490704717,21074199894730915603594812797833479514843396752652846676596119472522115586998,8903588044620722375103549330291845285230849782400990458525441823641905996819,7157451412319473873395155428325762769952294079544485671397508107346256362850,5366933733103001902997281886950280717532636892191522349820059149392915169558,3729196254269053915687004590799382892429870424157270200083981101426772909827,3918096703119862723362353838062260616080657756068272173354821697584630247209,11073027330528765229119199873305594827907404967404841004751556462671634016839,16424651511178205757967439516888026957937418127900739730326874335888617161971,17036562818332519536292487256920458988625450115083747105277938048739292827058,795554890382567685751618566957270321871701261784565632343709559354970377145,633072079840093073847779349151531317793918731920375040247534587265858418734,19421194221177975514787747427021411300539454454371387008642591623632727982196,9954719107136377193496025917640974425520732567100168938432529522254697824571,8674312532180246290069249621352567303340886011365637785384772665860996736758,14809129550856657213168714888239735820810817787153747648450536960647330811703,18479959092813678391370975524549834571584338614798320263799188362327888537937,11754080849414921164216607793483937490683185256818320971638570891360029327056,10287736699385961112844233987245832756528102056561178731804188514133469579013,14370616700332892416887680617217669883953806003377620695037833373409292189021,12131262377053219810698216976753909777223459611599034218924662817794274728701,15129974113281645648506209149692470898425572316691306513209191313993708898437,7871644959999350003348485402403894487663479920989578076708137744830000430296,1576915733292398470896862707357585951921545131195468346129170132189223165938,13316238922195025030929715018519212370128739646325014577776776032463179349855,15160020868051885495078648274966503057453505806774983308629511566464684311627,1692269682153339201433258246771340974628904846837119864247013056373782718416,19628837155426033423644376042848583705054394443378101622337255362403724735047,19222966046507618124793516210121558272031295169005274768240595331459420997142,12990748614547458190976906297393525840623470679364771518133250166378979874463,10124996030376091099517250678153357142212975502206884325977282211158514276950,17630673366223237394418802287655202715156124721482801416980858260564381593966,6743037447395702022066513290929048145404894812633440602191382691018136524423,3910195434942407507599129230554588207801501224467133349280934483448828467487,2025953242925331197360540874793022332074847486979998082380244277507702608951,17290925253475198968609624243667228472127383792887388480830073536530705682760,15557314422719360545874148111856256188428921052029295715627017447052250706766,19758557148246918190283097589287660972538989627091387035573386136809005998935,10859351185398338650386876904094285059182038967427299340069909694684844129362,3496018793417449121342556434800740598384008787187762642325224753304909741349,13695501250971489187692201493870442254612771332042272465953359508617675704938,13572242195808512474816152630443442412961099907068902213470234329372028271256,6257061132956659095252686302119011010885219692712894010340612889095488866530,4330599809632843338876238530496396340118064854909940219910748808728579051913,9157987606978264109338780586425009211347479724574125407732261019832259951031,2328698634372378957406958821467382289342903425118775270878244960387352862845,20636525922386221727012980541907198653039323429055563362662406273278160984146,15847894355448175995216566821171916679432807087340467956339517156584053817157,1942360378421747943668019094002571732886982847410366696537432314848905467679,9512432294361739988724195228775769058251373607278744642461344881575127503031,7373765909536890992660842391636719615263272667672747352621337161184389163446,16805165862480928364732162070809175154629112007405963636466097184868514458659,7667777941325858499291332847392489530780564386762784335358233711706517931292,6446208647487337326336908745536052288215677968074882840304817109073334759485,11285516171986135785540153632137541881991922296507010937224736080386568662797,10115214387228124714106659470937696440920497755599449040012569123044717722706,15485618097017003479590081826451772255273462073640651108645768569284210541135,14933383877101576453093795963534828854771957327481830015228527838452944594646,12699366929120600543724208703956381057734625711467645612998923493410472579972,12636366946456086231704939526732303791619337704833963854669708252203542584210,12149350767700952579168066320091211427411187251056390220529300991824437924228,7521252564104984899409328139379375498829232271563704354107116269254046402507,12033991121152464927378622393121300999333393690763174606686511857615848602007,17232776948709347607296344257668859070263618035653710252910881198999758003380,8692908682458431891302516268928916165669902656866484222966303081483718910104,1253076047322637463481069610081050841277544153675308425513468857300598987482,17753389824587331559955818909257943804816005297310986968447179587639048799696,5220269242560242526244582743085713945173060875457087963936380952653150665967,17126848126303954156127690428371193690154903947228604938919561454676410821149,16844245036721981603144243350071451732279678956963696493069130132912694448751,16797761350119564409426534689125994845767740388070744929816576998448097719798,19353620610135120026060560134469588460709151673182029068633909633596535108020,19135326024992044270104645311242450367403619348108625528873986701416220617679,17665816362466043406415418194780245586053150534372814020191541209753248047067,11399583108978058354832763133747562621839059603612742599115200702193127837394,10094334549114303273265943473013412623520307578724043117639269488721170750917,21601458494506173036246860827162868889968956934810679234022762622742359366252,6386580477827919478878489737663301647954047211008970416851133263802072756591,4792043837032853062947152822210390150724912812294333339974827814683543135564,20876886123310865680023706563792643033695666593071136348323857270657128199374,5931154799422838405687052216230902279350178420072288819326391251206607447359,5239679324690579237822809044372316561806419523557737441242604861240795339076,10385003741667422202343482240152986976068622687279646189490976516013598227432,8464156248644168452015929033942509092145250244998026718035923409819766539834,13177537753162628205208392995644675716264814191265988042404781479197639366733,5919477377826036950488668794024141041792143979412430063956231337921980979482,1351402666854456730370541080745509803482004768817122599092881844387000676155,6818673776641149273361875347660949176445649468306471072411086367313332518455,1366646945884507587781123424154966453464902291438811059924651777083838835678,16219293249111347900064666257423013936256436002819357345030961998874555359000,779230149490072246312543789505064727370429119089791148581854356816464370377,18480337167389263493513952937037301086055810692872257722500635290543939189393,1345414110418158215433956620396568245327910182467730711109133441878095212920,12518315654451653143886317929532883727219058399486775127781649065277400104111,19716171362713656659833259243590727588692449255201500490000859973307782246016,1865072487559894165339723956247507020827160163812334855490266264867949416605,8915174456326318257703177400411158958853446829269268103252573093652570933472,20191934956657253997484040571514242713447218897800997897558899754776252309230,3900170788760364547006546697350123842323924137566872497612605525517074710000,2242244954905694264442292936230335662862827521454977184433268725352453968501,17212753633823250440920113486091598217346743686574392123683302470302281044057,11939276774333100126191320505078174289237596631307779156488772314461752488631,361355126674011999247836373885105218009746852422112563922207274436194144681,3861054771271956681986534133247127581996350841974597302976225613765246291116,19968479093411941747037123171825881488638273087679549521610505739311299462846,8537196135596544183619390135426012949552627827993128615534814021127294540392,2438879838432432949185118142364194193697006515067980632650379470739663214843,10769366200854175394348657213265947929465261545591304593688343101111720627317,8455019976119342575889554308499186802278388693477937667704910645050957262689,20644389417984700539779514908032253651696357386572813102276555909201716748299,8820039786383750409041489202684137325382534899692778928304664068322226640076,8636461459675525672530300171201543901107046823820677414340465229975162161919,9061524648737340075438868917468774023866583922769991567001812766008277156749,7602969742956570438827438826124187210014769304752116695796494779120606534919,17880480383024583813657184645997268710007005482705400161841684734099773182094,12468433127385453618607022105559942067759302463679348320088817783890080634670,5227335513133160328788197758812517500875193491652227971114102085123079105787,6151293357148965084809035339276030775032864902311425722089088413878852880603,13699219811250783019541356007733829713463891996344484242492968708316395244276,20523944015644472920486129305620987253227711059638489683670518491277805771642,10421521516830672217871475174620176828341870738569247402138774913961149048583,15243709334491280025949017219424981672670169674700467979049999809115231651422,15516151337135073170256217447458198066207320794936363948307836943072374966170,17337341094266438501679457986886656365327787301649468585664115813920643670255,13262611487153423909813660830277859169133522588408913308784951544213550636850,18531665394082016871726276363920851282983017715104457591860421181826617619235,3700454591945927209171569025131477008196191968736477330379417168348613474972,3604972001659087732761769946443190920343158947813896848729866695375607825911,20952949990925307134028293094501736726689724950451065635729323134614933963162,9405357171465854081502883779215538022417071330241830295392540662303830897477,21638057691528924765719568024989208898293733581278465977164525893773900371884,1423261214711655336057796638966786076518765517452404205191550645234914655224,4051452662373209612509106830833400151748328181316060758960838588997502328136,18894191275634392250799133342573131067016712303481664374003128715704286175519,8319722910647187566775047002603641370685637216565762886509056643924765393708,18376807271218398458453428415456722166053637869198381036620575958015471551748,12035584964270041086110602893321059914382792217135345721427943800456312398294,12648928151571890511419082198798501903838843998709266232987169892491925610349,21412038262513052722667255278175073999553643537758589877888129674442282140610,7706735190856341161262212613554225730619876208755452623628315796884166016734,10999966015370832078836488333389544875338251739488999274500058322944383211399,4088296406085952300442596245852961024918851819760395990644634222875937267642,19399822412575078284884340953745677500886533272999950579143260384703504507006,3008499431966541245607724530938385192395211534821775780577277325698653345072,21447244586691806434401916456546893987941039399147865009673973728056412619884,893624395222035047010673050230651164575948871010677581303166873938544655581,21402344785412208717452894839332459679574051179708007417742748857146495441368,9392712010553327328684355664342647815409597079361837524976044019430681532876,11566000613582826375650817776243972243778859250974226949316472392849073658674,12900046757905605731200852057204734685283283637014313056501123642345467590346,2147232762440136333246788660102778148879449441151868600321283583777116020664,16301766972982581403924204059742972933467455194833897714073756335881543890771,9546560122931098895129690583175071306095759562194496054583390881525378967396,3814097068175987733354103462855355721851435755267819873064912557751073632829,10704509016547426355599213335456446765914211024738080860797634337598031536580,11921271012710313311785310319425095342886561942032945429395596578758895308264,21265249694322068914280109016742517903125526413969519857556032179013285196924,7207578215754030787157150149235357460121567678249968060366462431427104673093,20820013978092841458072065536574129286011620075823185493370309064760526240362,16441600678335369077753559950421185577542163640313037056248177018465084864223,297097313501884278852369638329400055327872945847645211148627847628970916078,18298084629287541333205519012404334789930413367615524379442280529941257264699,15206243674059814574375077493088319889784970587286591062649045683132661681752,18726053049188513051286348977772545167577661574609708038977390139794201099882,20262858185621074639529176348089123044694437795099449154711162805012934737131,2249345697973053772423677422936999849381692933292653912080014325442939977122,20814726663898441680439335735982981967722006066824203970896314191676769388296,3816485989624386223507317175678560807682224519267326958526058565555245734714,16741230612980371365533431648017361867585544111098407772560748428499802539906,2436865301432265520692873922135716828388518032014231744012990863912440945389,5265261577128499220460184630262997769060828863581478135168474766310582001180,20550548783058990082416235781987882123241946829605049684648813233836863290502,21523044301008793877416122201092687874337292497403523925455260117417170777735,9283421400783174646451499708802113832695004549893166692004850391713463380536,17813773547838391112844362681067751767404443478918792865885006908077545151618,16486730475669947890512191574075897324037778751496940417084163322433837359720,11367125189013824464048785896422572845103707778462525259651446893275289247873,4759445724467851058773503846834304672223785226936531021666916376323562671488,782273457631193956426744043048759353979593033245260492990657945904665284910,13487130697992008212099652811750242205045881544509489831523448570173633517977,15621563974535086891768796441515013364217522966350445838133979748032034816142,19364835034502915244801518193980688426244659266819997726035650961451415757173,21037385853462058267099182407141652124171361973889761119816789091401609511088,20434791917020905003166852059282129255412677606775079570484129378535005615291,4835039666519156760310260600042269943079463379265872618778854224413385690994,17796521681519947552208651467058827825861565135255248123077469895978163706264,2823350440792171019111081223801188552138104039380675927963458669980277420276,16030935304664378631941573945857397096373696981104104381156313618686049806120,17523561865544155408760007908067668065236326734119657233234283826019015377013,3861341406966982603014220134107636493882146780655211775629734223927755221098,1327887013530867777305056212037691710827939709365211251951525926327942169414,16874372098146373517691588057974501095408377103185981262983559391956463291137,1335930538845994150082853775454018356383085560294444442667355553131066129276,16846954448852864630121063053695845658867759327963014776419090787323732938912,1910615356880143423765930148112668984411979710628153215580997630269783916489,8793723522335768214688108364110927144836722932802666660252079036893034856492,3725321587522884864935206279104882080790553804758085564413847527197687551835,17549397166194503933313005107479073474671951786436058351827338574279485542057,6575272615526665941236934551769345604089554458721499014263130089965203838692,19479945993771870488240738504390121923410154808673876321101554256856036124677,15218540520084042504179141700157006972641510542203443030571191341196460163766,11605382280428426652337162672330854829498688801746852913129963366330544359414,19452583367341408020642116770501289011436457479987875413223766731278874726613,2498463382382553480222037299113185800507848748313035345734629490930688205092,1815123960727364421144419865126922339611466868807520419660969560789979822474,20531692711768862540943545541715345229360673134388506876856593310216372259130,21106443640856542784867046664180461359993554892163126756059125921876166419615,8538925154199646282458477113696635826112766123791239931164489946578874271866,6179996393486486548378164504724190431464526698002381214818146508779777698063,1334556948430115939422649531996020210538905726908545666936164977436729124944,14555087544451841622469763698691954343538388285983305607235034906273022598676,3263678860186354326206053303615515256258748076250020171477442794745232038780,1342606052959540554052550853649027290857482440100275878202185177537473434874,19067318604617984900108104413860593038444834168491290140413988853573796446193,11453576191720077983310542494091726783885546118293459348522522324645101050430,3772400828106882724656632136643514300687950364203707059277582466654856015909,19928616354232846804233301414766074864065580313304404532140360351457581578733,17669618023197654971616078177762451816976570462585423216749814198562722234016,20487504497482961764356160511764652912371612840137405927810776425577238052311,15959943319286858239034503624455112049217253792773599324329593237810330429519,18384331160163107383609864825156022277275076414745740108239579270660154123750,11807744905122445070761653068499781933485269571078706728521902995972849333739,21636069700028297640587439425598371999203459272489053044479958900301869951268,5974406255004817187688462241155741022204236935194897255519053490391727654963,18655439470676485950283686008645538637216956533059508817637925480405213882893,15164692255429309369428108531856612257028649418370969640920631880841690009016,12342219963417210875401056442100023070134657858086394031902694268469750570612,481209231155250366998260270814874408671884781003382050138985430923825730090,3242985953168013112117560001466320034030784952490866310190327264524235633420,13671160391160864796369771052335315926068131063004086507703804642392143876725,16716228406804746939632807079686149044089946710213611348848847599210659020138,9496049727665863372935045496498617414460003517119878231671018103126084599100,16483340875218689502751737973203780724082025375353804209734656041473116836207,2627597076078148403546873341483726933849452415436198036537442451261384383723,20527956374075302103516613197928664717455732919429461243667758971357150882342,11711450220231538029408058975978592998998598526983681112180323327131923215776,14877293714143600802178367397934915488570060506993092692625720179311507474506,17326201000468992158693082078045140389930457394232528033746431682308160431934,8241890704089720408679017565592201736334812957892898769189351788325500937732,6134985085876540657808139826388808003135254271482158519839818774839726308917,6944918715501093472287921248184355748547193680657762762284351108190443908482,20293371855859360749476040038457808453751087076170457949707661658124460443795,12686929429491234226470786986230897140429036877303905464553700071658994784104,17469937611674874489854850805106365496296990924579100118175990663783068480118,4389315288495042551686883151731749050970801790377604942482415778510472384968,11356013296312574683565144017425132580728729177241949155779586695189495537084,5103616537832821778796048073410908442363049367034544148603830689894368565040,17797731362169406634431131949969435652804582561417001546024888062211188454886,14413974530545126251158359344156378502844867672748912889426381728267720393327,18860675036245741580291857551498220749884348391920381715922087052471051304459,2078681010293955893545295223175290151677764183673754633340142745613957031877,11594462210573371469687203943585180057860108341927961420756260896877407822187,8232172476137304604696594035794651005660416081930158074561971898151387789159,16234745736110953717672420346414210260779855851076189537371942811750295876135,12403261277735118438898936378116787991453555210970659659639856670648844247938,10260185954137740247486488192570496092684935183379388125044125653647328054023,12655661577981598013787126068450556825218951206788052328715378240540030673155,18875782029492829253540920061867800401544385695523240332551730645990253683286,13000939909369679921538945109975441940863265779072482929455684540500587590629,239651505606383903278277662841450805219997298453219985892834268956273681444,14053674646208577108881262953518523519057705122297176784230960366018789686467,3606574524342197944154321263420984044427893927972300192386619594198948706444,4925738689374393290519002876270198297196104042467164940497567711764321354393,9820857610236925174040210045575219513594477725958302510866127781620764675531,8644935227560188528158307606853375529544842899940616765747319983176480635667,12589563927120228887319930197852404057542625019034806374830349240796880735981,13728987671030134173563628755348391107370774536000844606094840710456114349003,15280672692530045491619672502933299001869276703035606138561063102232345967821,21236672540209166733321925277807375026701626666734236841532747395149863205571,18193368154219306112046312834283644566129199372283662927472078427038205531636,17828956732555553542546753429670551891943977601119756829631880115504235233984,16641047964358580103472953437535358748387376425127849904658691126285684204504,7196281413799658043487145161620082973834461754768351228587249162400339111893,21279455923934963235610861427104388147894350922169838127737714784897083581830,10868227810739752166142906769497786680491652628709341836398414527811509748689,2545479497580424357309396388184225593698470568625667945691755386799845345027,18560104754451358950174079457178017278416450108044438296553162755384040068059,11209544817144484509471895492404241079181269159060632258040504564376475442191,14007605578670373547623429803718323316371456029307063658189484725071020560017,19316201371814679831554697580647476192318282119512681720915001227483533198021,16788142218280927569387096932066591137887806957079516944927766625343518189548,961359518362994763330685811948798278197676602059504713988410706948791494727,19776591693739287332042935252284088014720557305781829207369487992244783048185,9480779019638564372864984254416095889603560407402750333423136372713778963272,7812061847536565125280880398757948966749177710701972331770694629380983832516,14806224217889264732099766866344263686300132511433376375954468192761174167878,10982734897602724370866115596864634266746118759609469486863878972425453415519,9054801238670111257982773992849940941038784597792282084645523468554872244495,16788499373458165601983802204061832376825550128562541027433580619384299691535,4361212778425224413929793165968418385407821814716394404713983701050982051159,21198869506404830651226227162808186595284220877501140400488215541390720176503,7255012904510681544072472510832565052731304049336267892176928038570971034121,9737409770400739938717035426255379270654933363992002237053138761832402079248,14206577906412186888550704503752653056320975796075254442765439825369882967977,19036632138581200062386943078412086222459679497578993523004498970778925638274,2855178582526872375806959544405581665248537620420194093904041355969926293337,12896727255458884273207928529421874672712973447260798892551468479503233439215,20930350939164528694912500193219456539952966506926646436560438515643683077210,184093243282405111677536457857692693581379037444126410664343605529966199122,15658149328429348710722591333703516363901544310832580304722884306208924451465,17544235160628712643216064131303569753533519783718786133736357990785709619346,9378984995834426590515136439048146470293781405649183047514776402081048834772,15827462476470655610816981948418438654022314364182315935007413461648751735708,13474113844360907776462232979612140726930720201237003164521648175005015977732,1846676454601041085237775396212630553832771346942418764660365576890630152018,8958790186410745003596973786908460746144469347369569174866696175944574520886,16716100142556090678395507171596864615262575578180211444515549196841601774046,17584363243087108058467208592097637069605249776196694465943790236027601639916,15462568643993327150997687623907692370120490318886920754261967569094539968909,11670427917584674115542198398366950879185738970881616803513412243898491416455,5883010686944177614793479335292002976406988590121850032334552332298599405710,20848023045403944451304856285219275218146149181988087184275301094312642906291,20892609628755793476767683891284835591758207667306100001065280698890821585620,11041559416099382923560246079300939393371149141074957197352566129686429429340,17004024027027164912556351303862470964296900000646134239805113699616064012220,110742314120280698533248152539115345099402903868297760208823130532853128340,13611598917097489441998314826578736196564311189470688979687759717921520208428,20362978391139708024092837231934567580385484740720090300868417284017430844864,4130975720087443718484415210347908638971321493417335260526136858657572592254,15799784358302997284875412214187555553319485274948108081666806701893845835839,12410480753305882251320943831026503736012757975027018073585110506521877824193,11835843853657957571888855948788121206617247107501669280697395787347649231752,3326313455005237548503557557286834479752096887215379141590090769222516357133,3193633369267878319453517203588676707547172638050950764150162277144428673066,3543696055990388683071939150214505536733386566291338758519836333135488212473,453840133795717001022433249997110059635014609516452256954528366651276289770,10086004265216215714804100477403907145516617200748655771783383139854288214070,18938459257787140207383332020952460039308194017940327258304986766920440675756,18017538799787896442217663532610710859333377084532654794368604069493775630216,5517691591172342790575564654696650661133600869824307632295945043592492062300,5846204096126701465613249085053971321249645306247508562697696901334354225619,3177064511134248081568628736306700282095095665917536853000298191943047784014,7886005759395499452194553110700824805018792487440311729836576312028682853862,19249432464407391173245558257296856631584193393398113008165174416171947900609,16818455958785909569371690525990846776263170512884599090849081099178789681425,16250344336602567919050898941410625842485562539342327155695417850618940905704,6273998461375119044609362240019558608655450921258416376794979330773412610302,15933077340738498731035173703791932079747269039222967104684412531145625747085,17631878023023477567294765381542867314814954498487832435087010633074888584009,3387656327342575368928488173891176548794878068816523542226413637288662472792,15770343706243316227190526252701886989383556270818375222569120097305537622560,21025947829537149117391184273139276031347299127217645728072786010534368285621,11728430055160129100077268133090903533902452454196978455625432056779499908581,2184576630760971645143677026393147474439766939689140114811262608230414186937,20744811853491523948066896610767067484129121010717068573365370365324040781186,5378129452609441814399329369785055593231824205814541852039878139773312247469,18082900764136659604287793533371380099349929291808230688664846500365863263118,10463958995559323021196963984934883570109613942564610388110191948063546468897,244120224370345949702567256216804961153505781666838608095297311545160357032,17924705581798291273661662368787600134425123985006190354093511903371507000154,3107793385049037773698181795186417899797325916401357881664725445733609110598,5665818573123185227274537904890713907625420710982346291959547939830358917272,967322682615997637785254033877348832211978156650281338584051044602311410196,19419941178285529854771216440310658103611219351729270204884834098822007849679,6901963792883328370624032472781824547409040392368725235274158498520441238159,13721659825627300509722716825333808233371435398666022190921612703736274379535,2784281502858555298249063959836879135450746982163416748737579846439268828933,9904373282060708277943634486822397019446454722637742217276784802015824898651,5782567592658163731724098371574354386783075175203877502094122152538152467682,10854330629450460532485325799036675355255970975925867222693267730198057197195,7162558805520478103072398765799613453839879264508883857822705210986309908966,14561060495007338369036260685346480181377385446422680685283066135483167829865,11521954935420160563214644175207412771411940789064933791820101643809540481492,3893071612329582305940837979511590531534863287842007408024123330272447072664,19982770443796802008915975147614604175753586689418309845602797606117149147490,19714753609495058998670661272525609201695470529132258598980221623379639411831,10656632215192474178114431876399520721084839753473211054259843433641616176373,15519943627473966175746342389219894179761085602008029155282295063466585111230,429220418726674010600368106136723992478318707196454289985261340376476917460,16943119555428737036287647863079565463224985076466268175824843518378134856246,7079268853451648384434335899135383974808119657387366504271184409878695702895,5787261347913259367727842908192773692002199385877294080619854106978539332397,8254314874636465273639128395147895313719165057850599581478980264860146008069,15417738281457065064716789110361253613929614783743035738325702945037527193953,8995940809050737092434676062651493038351424361820394016896779859938155003450,8930952966754141446126393622188683431566029237395186071059700311531927009283,9012970415439810859538557593310902447051948348093454112737452817814629449500,21700461010267441715993595978543322483687194036588160210184366057201658507847,19191426116308521669196161733982754533604260068907220372422504926794231257150,18022413735343984488479130392027693687461867574196874267731354592562070094392,13853879871506882218224060020827336496729967255850404386800036291019021382781,13303720125164503437055631247918150173085142868095887759030649510172293881844,12463581809293287384469946044562671884924464520288697069370030386140109068261,20468619377263375923071378952981485015200979956112400596511865225946853604157,16682148710681177357125570715056314888342059670705617513402649433802720432267,16299073895000203963165709887505572454180623116454760411179563591228007694413,6439155427163506786329349605983728674821430800627321435200421453561910062302,16531483734580605436075637034861280240342858648848575098901014901746112480232,17413802217650584016261506268242623594956116228659732892682224912798301233645,19833018739354446018077109493089909435818386368530968355647208939546565982905,13005203599293796776324509750491064421128717423989464867065044987475986374420,15433711189444672576513248931602290892518442446252602686878477157678233603772,11272192842480959445178012145556234469776261923967845001064211055340129168135,21349777755000957327199310930646977290027138137542241555905014230683052104267,2414795183415356147955181901405712632718942970568205736628916600696077941534,13910388410253717440990758214044472114511432613509643223811561885135488623236,10073917454281511762447567386654530277776617831005093724557094001489771821135,15674657915196276639699997458656008228696751013801231738985398708672037426000,12030695425048598984176709301472822771003849589255577773183310838231109921591,6658172369461756755506276881582345916252610724131747740625283609123100367529,6460801016753822141904293563006139350014125998787400018150863192907944207957,10798491465896968361800574703868612181389697312199241920447162078078725409638,6331917501914253534943383807348566698937757752033630507696817298838693259937,21521172968280414216108032807577565012642487518706778276505136864150789112592,11443202152743097070847729825799673217706162711935940510632741405015900516668,10360970774813507384412119692215277392320350056791930702078433469299837875151,8111678922881662305935841208620197469657237670526301850210945861223648259810,3828566775247110089904016755996284741548002327940628727687176763639903716661,21019871488460899469684764817167629979753844957147537040703291790231271795829,11744049805554498869931942573519884330545637954557542018916739662277241821806,4521092770491436085084640166923844634777984445583984077999595768778116564222,2428018726292924561718904390333390438951211767580762396913313600061529081905,2672992591753804066533616673591169777906973091506536575810912266557203322920,5631180351966611479340932319081124575466459942666630580683510336616679680271,10149209329290376952496655294191511204529081153402908137750268385347783758010,18292794133971639465196495021864699906132845458944945214425906730119328661326,21442863185355178191454777233963814974940050392649316620141474331670970354424,3768420898310640667772098495371174917665155708578905018940113026409140957987,13677778555119984843885943251631654212176086447994430552012266440677394344669,13884681165958999171515885225547717032289759601884108191367706162606597842698,123196094575938824660055152882088188411485715788351262262924974166600702398,1121836698372380581784934880625694675020871234049336489788624481922395781738,20941331435492311592529607715649713508861806194386837398916323083940590908651,2470912827043971002614412337239267059969980871643559631900987795139200233821,10806505189594612637071931546921663393081238567888534876058498530874738324701,667951375802630033661777802749339877422061577764798227349674331630120025667,18416355600415187627018330134584431345513028652497077471935121971918269469363,14167152054564590179475064444026440101215733530475912312508414765738108715862,18633695428427030575173671831485026260967985663658201463236228419717189642766,152822669216765741203342297512101138657182497046533047369566701489981099230,13835701173750333056481994253160471551109858589047436642253159392878873667798,3993942321148722649703549241999711668949060533276325947207349685002693878681,15582244332423092177434976075689385819450099629893355758782548118218073388706,15110236879710270343688993144525012407319759236015974251051640787524859884359,5104405092803829419537383694663582438349376353030379488011426113631155364320,11034886586481561934231698674217393887518948538322130743646058638919797229737,21614370562083755709911993869347579638113152610927033622836963904672826178593,11909716327216431973191112809713028257963610176155315584304717743448686635887,9670047520194835060472941420215502268522351803257892125345072551055025494562,8752044341583145728028411582583224350471084864272507077624316823400738066962,20685513123216586620977713797881862528998788503897607377725195418550074311551,20219162196364967181713755472576994456615542213293827108438968625041058321145,18287830464300889532838439052863785386620820747210980263612361113628554829988,10146051396529576924597355409059465520468869175466632446875430377637660889879,13466459020798488583841582724067017412922317425102130151754649408559458307937,14062280191830459071860023268317938748180670907089383563443465249500572357980,18486553995294693573565546696966437493113894571993019524170031057367640632085,11156566424349445901806390826392443373766529722049710427351550423908421767094,209671637225069235519570008386635562520193585953162475265417907100134848923,17226989944018790920809176115775819865824823495740082575382169759054625372382,15644589951345053163188258692419292119540702867922222648564209455819510994564,3689635641036835670663293726548900381724135109917216986885298700630212836435,3367607896403464195671402279459329078003744183784952830994679539910724667259,6227320552634621985217890398406127207902736210419315868051857823685244516725,7357930890687295365886228617478473072206575811998185548162905341534675558305,9337019296542497689612612043175604595811913796434346282222317112981594913389,14658782859891978670907070276103444826326577838777644289370207112293812556778,1700861002075407761970169168361393086239805454951858464329713573177596208454,8422307882422345667268572118847227804767508317685246864132851358134342544918,3824678171886439611637777800578730196591582015637069631407414390326082519384,7520989644070067743500997565082513560943860081670904302057616063200273050286,5278276919931895959830110725703210158384647399821914390314400092195592076331,14590632939277529585876696200177152214896495867542780671631701634592299041714,14365499645924743985349770983085181263329435144891175678390938245209017764418,2519790270252875654107597063434691592006935573176284731324585122712988059511,17688843544040778657269233842324532395371012201506418912518394656290716826075,16584068781164994465207120381716024087231836173689783891650623302438290695506,12224860044594664185598615945328866758529752520066027818906177267571423023661,13664317767999211366109254182438581912610775541954425083255023643648887081779,19324196860555787958873349597666822462940695051471419602454830948112942481945,15338841226759355791277440652242849878000656382388414806186764010001628984934,11076363155150973228897602285090741665942726007445165132980573631249449594126,11228309866140794620879641097623963859536328868056691748463227126359575786386,4762608512226640372168720665137259637840828925512114281702049841301872652787,18282645934358125859102195916568492018711932725386725562892735740355836227532,12803228415054755333149187333584509982900042807310255834005394843350472605458,17675693156369747720817703064233611574822178844066411565804543111769294187197,9900029048144575309490519431063332695303076438539483419053219772370202428926,3684590949621971596368895784562632626464811455818343794800044114209066071601,5443335602638685057982926800093482287199751584817191972983546508574786160090,11352900694666160844325992247118358443639716695965864728670968730093466793722,9836739435541786452166525951732520477055729763398281521212184905286650567233,8222926590877635625730738050718327099397892409701316035188479123499338707893,8154558268770648194631329585722892880905143452138234292827603893129808716905,20661038342485310632612091028394348057035659683250957045340774030445861865592,9136910062528018177460276667688174167129493547069053533874280111057356360561,4362513385797089229061458501847196255783651860098500705320631416351847846956,2061137061600029258110405980965338431925491466724330216028866028449889153371,14607676885409772552908782897874144975643999944034675480739173900267789420534,215346512487318428553079809620502708407272005519315271404209452927497999118,18044026902282362371439577283764019415115969502361960218708274179281044595578,9652478245641134951513165220881528043195466248948069255527062590256621034842,20994154929281322813927859895894589885437941429166007529912073756113466975582,20752721666010515144550782025078875036488075535083563976118804420187462745253,20857028711523544595627940704882176284224509745902984714255291431664146535922,9631521770540523913735742126933921923952197512938165111866628665235591582568,18950423265182779471595998716023482060645307106263127634953888715515988505533,1436791836740130330138273456892846001841969807914099860317370076565131805680,18145299176463660895047063984288790313564980703886502044680749544519011424826,7008134596456692891696131297028980612714475387065733972352529833092170154127,18054087496593103261596842546955317831262607456582498514349407492750291465651,2460661191051979147731673103829326449069370361298340160666765010767300969003,1121019547339042268901204213478561141018690742635442229019134496736639790078,13486140142607002128358893931572108539446504181590991898872881746144618091798,14485083458755292442253176062192342099468601222388603924363708902524652589634,17684636079328478898730536417772675839399177918554869673260926729643471105206,12382939536995562937141167025903251534081453604974163882762565576243762872206,5191757256912351314880102858899907666377813090645991709894707944196053941770,18397247107649643640823283145149323187327745749077714626730537494597891967945,21508632378351416585385353654317189405917247727406155133342616741543833680788,19108354768686907995261340253443420621814860995097718380505789237761300853182,3649609518051015699386442513879956346519312025847003339036530556474594795760,11893851425092314587513815253407979901615516208632062595457152391110352908805,13296593391067251947204447959241604616835056311051696511507435925462940176830,18493557674615580922923001229788184231889430766683327472934879670006059540367,7669746659590113244880799806073731587177781693253502772068846650012974230120,19370654200032786851343971085637480775724705092664059950989935645178139099864,1331955346226787928500793024038189892044219824334532771311923855914410290305,14488880297827410405382492933041130286687512096290491259710680579157544248910,6760882547908259908954677726421351194118695606292587659467769365205068189814],
-        [708458300293891745856425423607721463509413916954480913172999113933455141974,14271228280974236486906321420750465147409060481575418066139408902283524749997,15852878306984329426654933335929774834335684656381336212668681628835945610740,14650063533814858868677752931082459040894187001723054833238582599403791885108,5582010871038992135003913294240928881356211983701117708338786934614118892655,17817167707934144056061336113828482446323869140602919022203233163412357573520,16618894908063983272770489218670262360190849213687934219652137459014587794085,10883405878649359800090160909097238327402403049670067541357916315880123123342,7439184039942350631846254109167666628442833987137988596039526179738154790587,2727663760525187222746025175304386977552466570311228286110141668880678011929,16992375884417886634716738306539629570444547136030480542879886913528563834233,4178586893949624406750122665277033849762243490544460031634329370298105635905,2517914797385699886738929430037355069462619900197972886482360691236776726214,20164173810534657634631187494276970100735049909727379228976555863615716408280,19970958827248077001061220127605534603528515080207197493660642269195127427214,15606275977308968307194602612931727810866183872589808138812916593200446820753,12261436001550634140750381230737452634746867040398895669545077774504957433511,10405309809257831434323731445544896504541938387524726028487604098725193737428,13408856444092113657034337770571899796129642125690066226794939383190876435468,19768080898957882918527124226120459667739640387901357739011662191034806046251,16749889646056241484852997428132695501278739424507088920371060969471495213919,12331609790192161246735870679870317366088443875784324655482358218146673901073,15769331739277556832196167201116801527901089923090632364403958141614820528626,5227172275505968397128736045169568430462701766148126842874241545343535393924,919073378344729780131814412541912290691661039815032069498359347682919854836,17858725475505870077023114050620337312678855554361132257763133392017321111169,21805188450184460363143840112266872832328782034569970452376470141743078343745,15808413311863154368918155104905222670782553225279887458053980771135357021692,12828907214414139667587331812274388831051429093098655261887619166452245292431,19323880880917307340820066456419195877039970908109908221992925424585030574269,17591732412986269470826282099678922890996647592922237928486497997144096433314,5282593184575641056912422403901924986019740793240905758215569065763629999318,16013130707598525718519250412251656096494468043256226360413191733653074896117,928381583587170989315021718439506896903185927814675820160976165627097308915,13354336789663524324458402003354905134416094005220899335023797754517805691310,8780135673134081873589118311874067764073719549433574820315100541871522642766,3334957744389892864165113989538814646945861179021194859030934481494560681812,10553413566358881045095498839713459314577909144176577153981801574128014927353,18894321506279909207228932263261226433242541255661384643559047811974513999438,20211894014628303327332299342564779073614790317614402383971270594430055013904,16723480621932556506775906903415088312771104391224076734252099577243237899106,1131872547334579236404174618548801749854242069301712398106619948805304881636,17386814048141719093058723520379257085987299288710382497237609774141718421404,13729980537487612221640320393867198844745491357830417754869369043292518007370,15860780436383591737179656321807464721751913977397035980422407138400867838633,14708550460111247278740231297332510059116901767161326454481923990389610737973,3132820559166321299152015048428879769905404947939291493327190426785911502819,8658132367999084824971296219169212568783540935524918908332001856872807119287,21064783047501777742084787259676320053480170916619513986794406566953069418035,20731000104011695148048713576219525164619502119638555785381543866326561323,17189725817866212967650950297463469529475851286172280116066228706121595462088,3310440878606659516028312898499559492876015493892608849966645073367377278233,18463918215326370595980949760897480127622730018343709491036454088497976892863,10894192430593140913557164014343360386192963621862346779515699758352916852228,5060610877870389107953459328006060153180283860738879092399406248484265273634,9068988823145592214189961315730261367007076042069390630024839612151270430414,13160707893890865447331361630522644819624543031829773191665491273833460019183,13920568292534026180186486064598876780779571940988254327823480971820885713801,3894011501178134026216736522445829906312115650019712122802932677318433032635,17895318821130376385979570244603067634449453259842805202694945793852667231847,9777993060458301797155055013115849176281006051494461044565335406558308324220,16521293541516305251718414192107787058980727971856888501176820100904791554730,7744063601405355255689420547832904761861257642931934580021876189691881462544,5444730929053688962452159157646022068806222098484627080046464163159451208522,1524118152994294864739915388438939180298324297960159419600850033701763764640,1334622237342346242862023763160346671504959163544406543315614662442562816653,16126317914306849967682996412350336172782726693375105190424151365140854833923,6345975085253358297751050638846919833013142450462810543971050115910612860460,2703875280053263252177031410407166981522153304496807669518295313468095058674,20550626512184448884716175825490086259235894802178999642552696391947509065676,15013718986700828670892638677446258841869291160144196138236407826511808592486,4682264015512203762723381542642871160915706748420642731100634327658667608042,12834108073603507925748862283503586970613250684810871463629807392488566121352,8422606792378744850363509404165092879785007388646473871019846954536829739979,9339209090550177650528715604504958143078492516052997365409534971861874881780,9141831918422847136631159987994781722269889810731887947045878986971886716767,18329180549061748373684938917948729366786279119056979983310618862430068636631,2009551904565170718789964252583363785971078331314490170341991643087565227885,3859729780601667888281187160881197567257456581829833310753128034179061564519,8535335342372994336873304745903510543599314397287086554558824692658347277251,14148514289641991520153975838000398174635263164584825009402034843810351225518]
+        [
+            0x2088ce9534577bf38be7bc457f2756d558d66e0c07b9cc001a580bd42cda0e77,
+            0x1b86e63908c4b12af43cec6810356c94d21c9e37d73dfff9742a58e0ec356be1,
+            0x9ca022ba1142d170f755212e2edc9d0a4ace33e16825f540d5d50d5a021a169,
+            0x277e69d47a133804241f6aebe9449be6e22c849c6d8ad8c938eaf613bc1aecd4,
+            0x17b57ea03754e24ae0ef425aa2ad931aac9ba5457a18cec594545a235db6b269,
+            0x11c740983395e0f4a026e2c7c939236375c9077755eb1a37a77d5a1fd74abac6,
+            0x1cd85529010dd7e2fb7ea403515bab5727556a479c59b822efc5a81eb37bc5bd,
+            0x2cb9354002cec4bcbfa985de34f43d702ced83d197aa374b5a1f96f87b12f292,
+            0x1f7af98e08f6877923f27a3dad40c525ac52f56fbbd878506544f9acd61aa32d,
+            0x1a0b807de55ef1263cb74d73f1c8bf3403bb3f1e03cc502a9e2b8d423688ec18,
+            0x1fd59a493af01f538eaee9b1cbcb2cd1b799d6093f0159107344047c2158d90d,
+            0x1d3fa4c04d54e5263e743a2fa010370098773853777b73c7c92af64eea079612,
+            0x1dc892a8d006e9b99d597f449d0553ebb51b259319ab9d8b2d02ed9c6582c232,
+            0x2a0537379dcab76d9308d2699e0e900109318a740c75b8ee1ba71120edbfe071,
+            0x149d2cc892e7cbc1f4102493bb96b4a36928dcf62f7dba6d9e0d446f5ffd4fa1,
+            0x1e49f2771b7510aea77ee000e757ac105699c62a33a418ebda572969037b5bc8,
+            0x5649ffbf48a15d39385cb62912bf049e9706155ff3dd43f7ce0e4cb35c86c3d,
+            0x2698b359bbb3686b626831d596fc5b5039f4af516bc683a289876271ed62897b,
+            0xcd8c08efc5d2bc627ee727dac325af99b4f72ac70f61c890b0593eb03c8cd2,
+            0x36a9a9ad327aa70232cfe6c78884ec23aea703814c701a1862789367b45b3f5,
+            0x2b5899d038a234824746d697d38ff423459f7bd4015782f528a3705a6f2feb9f,
+            0x2524bd7a1969744168f11aa03fa82da034edcd1c31141420b2309344d2741aef,
+            0x89189570593679da35b668bd5b3542489bab1022dd790ca6a99c09ed0a79aca,
+            0x6608970a49c0ea65f21a544c215ebd89b4023c387e8339ec7c9cb80b6b87ae4,
+            0x283a6336d81e02e8dcfbd4be67fcd7f8b73cff4ce3f8a7f3451b26e81679309d,
+            0x14536ea1bd43af4d7927054ecdc962563f6f396e372f35cae0e5218d62bff454,
+            0x3036ae3f4cef8a4a0a324f409f290c172e5ec23a34f75d57233a04a055648e00,
+            0x22262d9a1cb0b5941b3f193c381403425b83e6fd9e1b4d930183148e414db99d,
+            0x1555e4726cf5d78d11b66f4969724e64be8dc3047d0953aa84be42c4a3ab4098,
+            0x2a3e9e52ac1fa4915e262406c27cecf24b0411fa674ea5046ac44897629e8544,
+            0x14d8abc9700624bfc54939ff64f75e0ad187662ddd0215e3cfff56a350371231,
+            0x1e0eb685b561bdcc6cb793504a4c1b5056af33ddf6f5e93c72396f6e53eeaaa5,
+            0x2e7e146d9111c11d9348ec2230270bf211b4325c2e878d09faedef98bcd10dbd,
+            0x18c036ef9e573369755af33142bb856437f6498fb1162b8f8af4523c390b09b2,
+            0x195ce383cf5b4e65acdb300d6e359320ea6bac8fa881456c72526b4513ee1d71,
+            0xc12860b292d22e5520d416427e1ff80eeeeee47799b322e0580c2d45d60e6ac,
+            0x2ff73b859f68c9b8eaa94078545f54dd1e9dfd74fdd762dd65f522af19ec3ffe,
+            0x1205dc46155d9cc22a89e838ff1a462738d3ef1972a01864c72af0f342e524ff,
+            0xfecb680ff19b124ce745b6f70fba1b91716e12f664fe93562d93700adf0bc45,
+            0x234391b786f9498db2680c6e7aabf4b0ace0f0368e21eff94528d051128cbc6a,
+            0x2937dad89e2bf12f95cce70dbe3ba4c2ee0184226387421bd18038894ceaedc9,
+            0x22c7ab9a912c2aa92e2afd4749e70968322f7e5750ce6c697dcb34446102b85a,
+            0x1bdd8241cc91cf091780328ea6a0ca6dae8c10c50796006d462455b90e7f600e,
+            0x49e3eb4d3bdb8ea3fb6ec3dc065556eace18a719864184b36da835bf3e8de11,
+            0x20a8611ee3a91a1513e11ae962ec82884ba24f32171939892a34ec6d4622a88b,
+            0x27d281f482154b5c001ca383a1087bb1481782f2bb457fb32505ff63315ec376,
+            0x530c5ee45b6b16abc8306ebbf102a1c0774f8618699278d5d3a99f42495a3f0,
+            0x256f402ec1732288a2ae27f56a2fee2199bde67ca2917984e2a6c7f3952a8e32,
+            0xed544bd301d33d4b9ef359de3bf01e61397f2f29911944c5d091ddbc518e146,
+            0x1370ffbb023d66ee62ec3895f61de73212207ab83194bf6cb1d49d37bdd4f34d,
+            0x2a46d5538a5a9bdaf47e44594f3092112e755cdde1a6c128568994a040e9a04e,
+            0x1f3396d7db31c19111069135ef2d095c1aafbe2c76d7cc387944b2f137edba64,
+            0x225f3203fed96b846724c146b3d3b351d6615ee5cb1df8390a02a715ee206f18,
+            0xb405da3510e7abe759298137d4853f651e35b7660028d9ce680ef29db4c22b,
+            0x162df9d9cf874a89630d906160abd114b09274c010636c440c3773b5f012374c,
+            0x26349d07dbfe862f47393d354491dffd8ed56bcc1424d45dc3292669be8ce0d3,
+            0x1a75a0ebd02bd60bf851e0cc564a07ca5145d4ecb970625acc7f225480e29903,
+            0x22dc35316d34324dc4fc4812b24468a33b94bd1187fde4092670d789f8372ba0,
+            0x1f260c2068ddd344bf8fd0d985ad999e0a2a0b345b5d4e15647c60a0019ddeb9,
+            0x43098906f60ba8b964c3d33854bea3bfc728ebd374b871eb716e1bee8f6fa81,
+            0x17fc06025f7d0132912f6cd189b75845e8a8ebe264a3561610ec2db4cb22f800,
+            0x1853501b6a22237cf790f64d592e46b76bd78d7a6e11a86a5e964bfdf98b35f8,
+            0x13f85a860c328d7fe96970fbb13dac19233067b186ddca81f7b805dc7e8d4de0,
+            0x2553858a2dfdee2556d24923c609eb3bd92e58f1cab1c406317019df0bddfbc7,
+            0x18db95df1ef5cac1f4d5e21dd81e4e7d4fbf98deef329bac3e4744b2f72cc2d,
+            0x218cfa400a003da69ff396f9a2fb282d544a43697b68fc6baccccd9cf9933939,
+            0x15b192afdaf7ccc461209127b95647cd661c37044642f0207cc9cc699ee8a3fa,
+            0xfa2a193cc8addadf7766d712c7af10074bc8149460ee35b5c78d15cf527034e,
+            0x6f3dd41dd4a94658628fa7cfc17eb024a59ceacd9ef0fc0617f275cd9dc0fc5,
+            0x7a9cbf46611387ced1b18c4f371d582cd7b05a50caf7e230a3b5fc9e028bae2,
+            0x135f98871577c5e638e56325377721fbcbd590d85e93ed310fc1c0c802dd06a0,
+            0xe8f8ada4fffe0a6b9faff17f6a926f28ffc38d958ddf259ddf4090083bd66e,
+            0x225df6aa9bc49e9b2f5c8dc81e15c91ec1064db201be633f1e5fce6bc5b9b6a0,
+            0x171c3bf7f45ba571930991e63dc8f4d823ea1d885357a37f7825274e9b9e0d40,
+            0x171207761f4d71c5d5fa62352b306da902f0259f4c0470bc82409144feb9acf3,
+            0x26a8805900a6087f4d916c5f8b752ab3211023d730a1c5f745d9122fd9c19973,
+            0x129433d6ab5a8f5443489c357b69bc0c27cac6ae3c24997e5728ffc76439d5b9,
+            0x1c0c02bd9a4f7a36fc2ad938f9a742c0af5d7745f1f0ac5b664aa3e4057a6f18,
+            0x165ff7309c19adfcc8ee6ddf752f94fa5c24bd0e3ebdbac72c1fb06aef56dfb0,
+            0x26b387d2dcda5acfe48872f1c9077083043981a4d22ec361830489ccb49d384c,
+            0x136f73b20066bf9bb629e14dc8524e6026c159059fdbf51160066ef7c416be4c,
+            0x2ab4b86e7cde3982d2e88235c312d1413d85e69d3f5d51bff97f8521bd7c35b0,
+            0x15ab3bf7cdd8944501d4f6e1fbf9bcc650c5b7a96860f75ce08f5299a560e3ca,
+            0x63757b1ee01190b18aaa9078ce6c59b4ff979a43897f7ac41f667ac1300c522,
+            0x7235d5c897327b9b2dea43a9c924d63adf0962c8024e9486b31c7f7dc93f93d,
+            0xc793e095f24f97300294b90f9c734241509ae31ac0e13f9f1df46e0fe537f8c,
+            0x16c461135e143c6fb08d9c33fe385b0c7a012bc208fa6671e4619534b3e73139,
+            0x3695a3fcb6f3778dd4884dad62e4e86c750e28d14fb31cd59567e3aefd0fb71,
+            0x17501f012f54c4f196aa31cbd91bb126c254f553e55d4ab844f4d4c689d1a1fb,
+            0x20ff8c2701723ebe114d932d485fb4af9af641e52cab0d5390db4dc624295cd8,
+            0x605d48243e21cfef1ed9130f5844a0c14c790624b93ec98930d250c1b410bbf,
+            0xffa032ab9b633d34909bb748a498d1d76f82057973eccae9fcfac45f50ea6e6,
+            0x202d96f16f6276129f835fccc83f52e4cc1a7d5f2ac32ae4363e9421f6704beb,
+            0x97e3fd4d35bd1394cd482c2fe4bc3c02881e452adbf58858a24106a1cbf0ad6,
+            0x277c2847ae8ca64446c9d04e2be45b786a4ffdc7dd1d27d6bc978db85ac85ac8,
+            0x3410aa7a2038d75d33082a5fd6bd77d018578ad7fba9f7712e4f41e7d397e6f,
+            0xff02f1d79d410c828dd44c6338c31048ced79c8aadbc45afe4559dabec02981,
+            0x49e781f466e2561b92d45a40fb76025afb1732b39a48dbae1c5542272b1e126,
+            0xa88c49a585914a1ad99805da9dec850fffb2bbda64f7b509516a6713b884286,
+            0x45e7bc4beec7107b2edf2649f982863c6e106589588189eb0c9de4b0e039017,
+            0x828aea263b9f5db239f9c49e36a2e8cdc8e348f58904138e089cfcb8470ae5b,
+            0x253955f1058a3387b40981cdfb33b74623817a3894b51087d3f9a4b39d716a10,
+            0x177c69bc3df7a463c4d26b065562461ef1caff9c92d3bb143ce2b29be13b2336,
+            0x14d6068c39b97b9a103cb0d40e9a8bf3ef7a6c7bd1d622d7da57b7a22cb1dfab,
+            0x25dd2b57b4799f6110366e0baea665aa42325019581b8901fcaf78864b51f107,
+            0x305ec758fa6ebbe5ce50bb2f16ec00d0430133a0dfd4cd79c12d69f8cc0e8ec3,
+            0x11ac0a8009ce27d3e2183e31dd0175f81284b37c9f6e714e82de746969c98865,
+            0x1d109b8b68f442a09a062c5a663a0935a96a91219587efcf3e95f0aa293578e5,
+            0xc7b0a104e403dadc80eef55d68fd56d56aeffc40bedad4f44b2ebe780d08ae1,
+            0x1807654841ffb72e7b046942c0080d97f43191c6d2e78b70e69ff867015cfa78,
+            0x1b63da1a99ed90f40b0292180dba78b6e09454b75bde64ac9e5ccaf2b2b64043,
+            0xd7e5c4d321bc6d180104e6a134450b8a62034e98d72c9318c61176453c96d4,
+            0x2e252a397bdf1b53547239e3c6e9bb5260c1905930644e22985f41eb6a226f4d,
+            0xbe3e9b1a8abdb889375ae6082e14e37bdd21b8e2a675ea56626e9f4b9d57c81,
+            0x161b52904a998f03ea62ae67b561f1d74804ce154f928c1e086731d68efb5213,
+            0x852f56672fc06cbe726036617efd210b8025c85b96766e95925e17f08564aff,
+            0x21c4e873d8d03af989f22dbe4fa0a6af2a8719d289707ae506b39518349b6cbf,
+            0x1ac41a44314ee18b9f9d4fdca582a052c9b69c09309ae447404b3ba58104581e,
+            0xee333ba934442e498cede6609a1828ffce94cf07fa7b14c1c991889ad1448d9,
+            0x2996c68d007ea8d16c014fdb33190fa58ee5de793f07fe4413ee3a4fca43466f,
+            0x23f678b22fec25ba357cc068eb259f114754a65477022abe24cd07507825fc17,
+            0x1f6c82714288549da4646534547189349ec908aa2fa02729e979df6a5882855b,
+            0x1f818e74b9c3a490b612926bfe89e7947168d343c78084a3bedf771216014354,
+            0x206833435ec4988772ee1f0ebb9313319cb243705c1313de603fdf61a323ef04,
+            0x171785b03104df15a632aaf4dc7cb7acf47934c72c96310f1342500805120d11,
+            0x20b7363891cd3589efe83abb91d9f2e6c59b575b8d3ada6c6cc84faf06763db0,
+            0x2d60609bc685d0925cdec6f78d731df0a040638a754da555b8bfe26536a325d,
+            0x1a91979ab3ad3401872d210b3b41347d44312e5d58df0c1217881d544ba301ab,
+            0x166546d364e42050f2c39d196dd4189ae824a570d39c02ae6a85d82b00419bfc,
+            0x1ac2089f74aa7d61b7c44c57ebbb6751be4c8a22b2f82f13b513959bc2f200c9,
+            0x908ca864a04bcf677dba3cd272c6a1770e7a9c6381eedbf9f0491b02800ff0e,
+            0x24bc8a866d9b7bed9242ed6a482252db77e9d83ace606293193994aaa126e72f,
+            0x17a33b4d4a0821176c406b479e38da80d26522fec0931f218c8e54e269b0ffac,
+            0x12d6d179f18bf6c6c13661026c0fdcfee596af082545f3299e05a8a78bff2e28,
+            0x15c7fb9fcf8f1a92cf0c677fe58b79065a5a502d778ac6967c022f6f31132405
+        ],
+        [
+            [
+                0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+                0x607cd8ff9b889773c9eb68b8a4366469d470cd7c6004106caae95c10c424419,
+                0x1da524cff60b64856dc1f5dde0ff62da7b182da26908f6ba6e590adebf91b40c,
+                0x22f33eaee3c481e65801b761a72832908f066fe21dab5fa5ec1d4c6e99dd6dfc,
+                0x75f84e9c719bb8de8e61083290daff19aaa4337454e5ba804257787470f2f54,
+                0x2084be9a57e9adb80303a8dcaffd4bb77adb6815168b36a1d363b38425437135,
+                0xb303449f1bf4b92d2cbc26ab34b4215b6dd7af010747a705b2a6e3398882922,
+                0xc099bc68243537203f97254f08dfb7efc09de8f96d72f3b3e0aaded45e18b4a,
+                0x1c5fd9060d4e0d999264429a5004c165570bd1675b09f977708b1ca48e616388
+            ],
+            [
+                0x1f8d3a9d2d31ab32d9bdb6375170dbba89f6f8f74d16e4fd02f3675d5fe2baad,
+                0x2591580b73e7b5d5f34d9fdc0cf7fe3de7f6a18a255e4376fde3eb31dfa51d79,
+                0x2bb4565893b6ffc5799139cdc151158749c2c65db48672abaf24c5b3813c0e2b,
+                0x1c5ce77776893d48147444b9f6d66a4da29c95707de832756c739eab8e87658f,
+                0x175505391c619b75530fa83e513184381e603d8449d1e070017ee8ec0a4d25f9,
+                0x6ed1d14dedf763a3065f27e7a46d7fbf20d2b4e86a0db86692a269767d577e3,
+                0x140cdda33bb7a79b2baa851df5ad459e7df569b9f2c3da542d3b8d5b76b356ce,
+                0x35e9ecc464cb431cc92c3356e8a98547e843ed1324c1e971179fd1ad9fd51a0,
+                0x129f06c930edd36fc2fb7044a6332751a2e3bcdbe756d883716cead6bc7063cb
+            ],
+            [
+                0x230c694139416f40422d713e13c056c45c3c631b346854523970eaea58a37df4,
+                0x93cff12150aecb3465c4c99f044be85dcc1eba21d429132c2260dd3d12ea441,
+                0x25081a00fc20ae366b1fe7ea6b09e62a51f6fd377f608368c12ba4e3bf89935f,
+                0x2ab8edd22fbe2a1cd3ce9a4212d0efb282ccac28af4d876fc946203070c920bd,
+                0x29c5ce97710c1578a0990d862cf881badf10e4f6bde629199e803cd1c426be4e,
+                0x1324544a54174cf7b3cd8ffc4b86320f2319d9b88c1779b89b1916018f3fb9b7,
+                0x1d18b25aac98b282e10b5a3a74ce5caa169a5c30bae52bba280ed517f3f82fef,
+                0x2f35e921dae87f1284c0c8ae737dbdc4936cbbb03a03a5918552fe565270a8d,
+                0x14a5ce1603228d6e6fade57c1da536659ba46d1b25566f12c28debcbedc5b4f4
+            ],
+            [
+                0x2063a461ad06315ae5992a53a14bb598367624afc2833ccbb83af92ca0f6a334,
+                0x59116da88a081267dd888204fc6fb79046c3297ccb65f9e0fe0d50b4db44ec6,
+                0x1b43719cd10b60c5647c097d1fa84b8f3c12c9c475ade13b388c7ec47240be11,
+                0x26e49154acca24424d5f8d29f650f9824de82eb7887329cbc83a56ae01dee4a2,
+                0x2caf86cff60521ccc5ec6e2e2c83b4707bb90f948644bfaa8f80b0afcd4cde10,
+                0x2e923ea46d492247e12e0a7dccf6620f5eea6629b7532b3af246809398859633,
+                0x1ec6c32f513b8f30c7aab42e7d91aecbe54aeb188a84f8ca46bd7e9741b9a389,
+                0x23a72c27f4f5e6ea5325d5b368f98b40693b2db1e8ca3d096739753dc5678303,
+                0x143617efcdbbc0d27a091f28039eba8abb39392e2a462850b1f9cd8532f5075f
+            ],
+            [
+                0xc574e628f84b6ba9d17b9d2bfd4747e06dd68cda2383d64ce365927098c046f,
+                0x2c948497373514e7d9846dea9ddf5755337ddb661043d6c628cecb8f55173bd8,
+                0x22dd201ecbab94a2ee393796fefcca63aa54d9a19ab9c7f20a0bedcfb9d191f2,
+                0xbadd77f516d4fa321d1099bc1e51909001591ad9919f08ce9718aeeb2bca4d6,
+                0x24f92793d67638b4abfdf48ce3b62ab5d0e1b250dc274d746f2f7d0544185b62,
+                0xbbbbb87eccc91d5fb07b6c55088ca514d68ddd93cf31c8ed2d2cc7f23b22b,
+                0x89beeb21c346cb9bc182aa2b70f853f1a2258d56893ce5a948d9c645ecbc9bb,
+                0xe07b1d22eed54fdf966ffdfbcebb653b5dac3b2a91f50272876efb17158be2c,
+                0x2885f2d44be0ecff57d92a4384edb5bebfb585bb23eae2a2ea50806bab8b7bd7
+            ],
+            [
+                0x276428d88040a3e0f442424d2ffcb8d19becf3fb6ca02c1b5c61b5ddc53ceb90,
+                0x2c2729812be9ed432e75709133119cb0a14e1b6ea31c1279b7c3e495deaf108e,
+                0xb8e79838cd30707999c621621e77e69c0f433d543b79c668cf379b6623bac84,
+                0x23671c5d1fb556063a64b5f664340936dc5ffedd4bdbaa2e96205704da5864f5,
+                0x2809dfe24c7fd7cd49b97b27150f4d38a340b60f0733fd4530cd4269b4811e4,
+                0x26010a3f5295bb4481310cbca5384a47af0f9905e4c76bf54b870ef0ffefa1c8,
+                0x2790643a66038cce4a6488847d8d2da2eea84961f8134b1be36947f803527e67,
+                0x5fa56d431d4bd09625a86d3623464dc90bd541ea41748f2026f65025ea9d2f2,
+                0x4715db6d86b513d002589f1f9522f7de3b1a8bd702c167559ede97da2c0076d
+            ],
+            [
+                0x24bdf6101b2f223174e869d6aecbe8ea5b04a14c38fdf1494393cc6fdb3e42a5,
+                0x2280d6d4718f9f06b551a988408f0515070e455ed63377e910be087fb79bd191,
+                0x2082d5647658eae648936cefbedfad2cd0538572aa6122ca68ccced68f432f4,
+                0x20d7202ccde24901d6ce2d107e79e1fd78d6c9398ba7a4996f116adef14def3,
+                0x26709688150ed035f959687edf7747ee8ee946b770173dbe50390ab8c08c5f9c,
+                0x751a4a4af246255ce412c4bb47fa34a51b8628f3cd902077775c8fa488e7519,
+                0x159e25e00326a76f25c1143a5be6f53fa51ccf368d9974cc6d93cce8eb81d37c,
+                0x2d6f3e0e98413d5d6a1101b245c9e711bb2e956e27a5870784fd5403b39867cc,
+                0x88887966c079d2e689a8d6d7bd913e92d326959bada59b99a653feaadf6c467
+            ],
+            [
+                0x180fca184150c0e354b4b3a4a075824d4b68e8274943f4dd8b0c64eca25dc68e,
+                0x1b1bba125505ae9675bcec7c9af579c5cc83533c9d555be398afa09cbf95d6a7,
+                0x277bae2fc597a536adbe9c24bc8ee81731eddb574c6a5142c1c5a48c51f82e81,
+                0x1d86496995f14264e7a054cc8224900368775c3e5ac6b5f54285f4a73c2171ae,
+                0x1e5ae4c295ad5a17e00f973f136f1230a6fb85637631b306d3705f80effac24a,
+                0x28d2351619ccc6fb31ad4206e2c064bf4d9b2292b28463e53e4771f10670ddbf,
+                0x2486b884370d49a003fd041e800f0a898ab61b5e947997461ee3284241f3baaa,
+                0x213176bc1a04939fe7d6bc30691aabd6152ed24f309bff3939a0d91d54c67a66,
+                0x12ded41f8047da3e6c22bfed3ec5bb52d027e560048db4c0f96ca9fa85e17bc3
+            ],
+            [
+                0x10726dcff87299c8532159976607633f1bc2ad24453c1bab26b726b82d756ebb,
+                0x17013257716d3cbae28e1c272cb6aaa2844136049ffbca05ca201523032c64d4,
+                0x30354c9f29c920c05e99d7cc747510e76f7fa69a71594a290eae7293c5a48441,
+                0x136961746d34fd196025173c4d79bf8b3d1d05291c584928d97258fd5fb4fb4e,
+                0x2310e2337e4d53c1635da18a2722178d55af583591bcc317eba842df247deaa9,
+                0x1815e4f7b40a7027878640a6cdc4b2854300cf6fd4953c2ac2c77625ef44ae04,
+                0x111efc136a9dfe0ebcffae8943e679cc0fbf62fd0ce03b409fecd932a8281b10,
+                0xa5a1148dad4562eab18162b3914b64d5753e9617a5154e93f7e43e6860687ea,
+                0x1f47c67a4325672f17b8bd1ddbd80e4e9e6c62419a9c204cc7e8821892431aae
+            ]
+        ],
+    [
+[
+0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+0x7341fdd8b6d7c94a710e78e47ae71d8a2d2c45bf48dcd6fe346d2f9263adce,
+0x1c4350bba48cff51ab2e0c56301b9d3b289a6fc4744b61fb90dd5bec31107ebf,
+0xc6c426215bd132ce2efae38e5bcd7cbda5cbbff829320f99be9dbda88fa8a3d,
+0x2810b0317abd6345a234fbe4661070c9bbd1712c64d04bc8430847e6a5435a22,
+0x16ccf6000486cf0ee9eb858de4de15afda028275ae86398b37a27f1586257f4d,
+0x1756383b6b2b1db75e494e291804c5ad7d947d6c79dfbc5e72009f11b69c3503,
+0x55fe8568018f82fd47de970828d3b5f30fa7f671670bf1b615f8ab4b5df6c4b,
+0x21b8cb5fcab5ac1e4a8e968e95a134731f85c9fb488d200998c1152f49d3c599
+],
+[
+0x1f8d3a9d2d31ab32d9bdb6375170dbba89f6f8f74d16e4fd02f3675d5fe2baad,
+0x3d8602794854484bae8cefc996d566594d166c98e8dbb73e70c0ee829da35d6,
+0x1c6b76e0d60e628fd7ca0d7d60de7382c8c7ffdabefcce98d45a1042b4330121,
+0x2deecde3659cb16fae536b2a1d81ddc50da450c1e96c100a58157b0b2707ae8c,
+0x1ecce2c394a577ba99982bf4035574776ae9fbf51aa4b218a363eb0bd1b743b3,
+0xb754798119ccd26f34de2ad1caefa4fc586ec4d6bcad8788a831331802bebe4,
+0xf246352b2864232a8afd890b5a5c1114127ff9e80e539b5d922b3d53b4c2cb6,
+0x1d6fb6b7c89bb84d5f7fa77fcc40ae0bdb914388f6578747f62f388344139ce6,
+0x1aab4fcdeeec99f73a94f5e8503b377394eeea13c9c345d177c7b97923b1014d
+],
+[
+0x230c694139416f40422d713e13c056c45c3c631b346854523970eaea58a37df4,
+0x20151c663660a16fc26c7452d683b1ae0a4bfe25e01e2d2ff682d6f8c5ad91fd,
+0x22d746e18a8eb6059d6913f3d2219fe1d1abfcb21936bf4462f3deabb86ca232,
+0x12bf39e8f879b7dfefaa4be7d615736957975d6b386c0cc89bb81a1b381f05dc,
+0xd639e4276aa71f97d6d061929e08d78b690054d7933907c91989891d7e04496,
+0x22d621427b2b65407fda26214625aa8cdaab5e27bf99cb8f8aef492030fd40e6,
+0x1f9ed3d81ff1494a3e555e532cec14085a7d2897ca721cfb41627fd387d4c6ee,
+0x1202c35b5378961b68f410413270c6c5eb4861f5f016891a9d3101da67f24c24,
+0x1fc69a3e806ab5007fb930b1c0e8837529f3c18357d74533f14c2152147b6a88
+],
+[
+0x2063a461ad06315ae5992a53a14bb598367624afc2833ccbb83af92ca0f6a334,
+0x14be2c9eea6708b8055784ff7a6eaef5f2423ecd3c987507edb4d57f42263c8a,
+0x1c94e3008e7fb1ccf9b36a3b272b4ebf56872e9d3ad09fc7fec8b73f3edc8dbd,
+0x19c33a1bef2695e72cd132a78c4893d762540fa2eb33c56a7e4b6f88a15ffdf1,
+0x129cda4d6b758aae7d636a11364f08165187bfb7cffdf51c90e7f6feeaa44d7,
+0x14fd9137c30861213d9081982e9c1e3627180371bf7bdde642ce8212b70a5ad1,
+0x1835c38dfb0f16b1ec8a341397cfb66317dd543c48852d8ea875827e2d5f68ad,
+0x70a63f4db1f63477a7245d0577d38f8ecbbd9fd8a253adf5e36c86f285598bc,
+0x1c4546e0f6a7ec769233d0ec55edb3cfbe528b846ed015e41d063b9dd42bf1ff
+],
+[
+0xc574e628f84b6ba9d17b9d2bfd4747e06dd68cda2383d64ce365927098c046f,
+0x21e114b50d11303e7d5e39d69abc346d8c062b3bc70b5a88e0d04c104c89e576,
+0x15c4bb533ce05422d3201cd04a12d976dd8d4b41ffb77dbc5f58904d9fee034f,
+0x14f45f4497c4a67c90f50bef58ae132c54459facfda9a6afd38dd06113bd09cd,
+0x154093b24b8ae3e4c7ecb11ce7f6d10326366c410153cec3543b8f8c696f5fe5,
+0x80ef3bf4cf0ee1d45e6e64fb415c76bb901b1ae802c7ddc2f8fcf9a7c4a8f91,
+0x1228c23f9d6c7b75373a17d421f64b589d7f486511f846b19d5b5a7a4ae888dd,
+0x7d4d3ae7019c26ac7038b866eb5f0b9913b54315d879065236c20ed87c3f2fc,
+0x1df9042167db948e9c137df365881a2137baa8afdcc75f9985d2e2a54ff2808
+],
+[
+0x276428d88040a3e0f442424d2ffcb8d19becf3fb6ca02c1b5c61b5ddc53ceb90,
+0x2d764f3f9ddefa066b449acde74eb4270b819cee10a4125abeb091cdca204756,
+0x106913bc4e38bb6868247a3ddb23f7ac12b78d688df4cb4cce0e2a0027317fcb,
+0x2968de39216f3f05107f5715ca891c8cc9a238893d7c75e8684813f9b8f489f7,
+0x20f194b853c3b9aef7a751d3922d17428d595a02f6e9562f568e2cf07c928ae0,
+0x30593e502ac9b6856131ba8d187dfe8d53ad20d4ce7a3b8d89ed228c91045401,
+0x2dadaf44fe7fca4988d5777f9324ab2aa8606dd3c4ab4cec318e0dfa9d02d76,
+0x2b30b0b25fc57a37cb46759047e4c1906a2d64b1da6bc8048d683a3aae105814,
+0x2af620d499b90b1b8bdfbfed437d5c71ffe5112b22d538a33c9511cfe434cfbe
+],
+[
+0x24bdf6101b2f223174e869d6aecbe8ea5b04a14c38fdf1494393cc6fdb3e42a5,
+0x1a8803986af5a84f9aeab49f048c67ee6ffb4689ef31cb51eff59977d250c4c9,
+0x2c95ea22f6df6c0975156b08f16516ca905a828aaa2fae35c5465bc99ebd0b07,
+0x17aa91194ea3c39030e17603d9b8bb80fdfd271fc603180bf0ec0b49206a76b,
+0xf6884885a376b75b81ed233294372cf65cadae30ff9a657ab93592ceb935c95,
+0x16a7398598ffc414f79d6d0dcc11eb3830bc6b97917ae1d9c0486fc6a162546d,
+0x259a2acc8e87e4a08a384199ee3bdc03df7a3a1b07c83f49fff07b4da49e4ee0,
+0x19cfa837f30749fbd33925eabe3b222452dc4f4569c826e602f2397007c0a858,
+0x22be9a5ad9f369512913ab2213536ef1ea927d91f42c69c35be9071d3208dd5a
+],
+[
+0x180fca184150c0e354b4b3a4a075824d4b68e8274943f4dd8b0c64eca25dc68e,
+0x1540dc30a1b9aedaf029e5ee97b63a63fa1a47a7c59304e2bd1fe7947ce6774b,
+0x302fbf64fe705ee3a34e33211937a3cb487838f3a697e0f77c173999486876b4,
+0x202f3f28f786f3047f7030428878b673a3152c0500874263b99f2a3f3652eefa,
+0x24145768e616bdf16b3099e09e9e56f114c3ee6fa6e49513c2c4f2b3d0002b54,
+0x80ecb13362f44510286df98f696ad51beb124014f31fc8cbd9d2dadfede5e55,
+0x10a2dd7c6bdcffcaf5b00340731e2da029f81dea7271c8c19825060cbe5db6db,
+0x17bb125cabad9ea535325629cbca4d37e5f30a3bc3c7f12d1aa1b63326974fe6,
+0x1f5576505ab6cf76adb88b8a85e1bff7d1ccb35691118d4180034fef90d2a873
+],
+[
+0x10726dcff87299c8532159976607633f1bc2ad24453c1bab26b726b82d756ebb,
+0xf08d47f49171fd7d603461458053fb30596012a345aca5e6c8d307c5ef68130,
+0x1e1e54bb56826529a37fb6b7bfd6af40dc9da70e6f6bdf7fc89787a7a2ed0785,
+0x275c0ac30445ca28c7836765c9877e439f0b1308e5b8b5bc30be95808c9b7c03,
+0x1d3ecd8624f2fbc7aee4dbeb91ff442a018b9a60b23d7e607ea9eb2f6ab6c239,
+0x237522466e8ad65c715717c5273d65815a10185498c9e71b48fb441d90b5e3e6,
+0x1f23b760586a694ffd7cba2757f935ade52b1b3593968ada9e0268cd71f6ed64,
+0x36083127b4a9a1671954c4ec341dab8d8419322c722061075861b41df631a9,
+0x236a813f6235546014ac3a47d20bd75b4b6357e043e1fba18a05ac59a9aded9b
+]
+],
+        [
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x152fa675f337216339a9274b97b08d74eba0f31110688589baac5df73d06ba99,
+            0xa60560c145b77121171f32dc6d2fa22fb894749d2686475001e0b4563ddf68e,
+            0x2402bc21cbfc23a80116e7535240403b3e7ada326d3f5f28e7071680d1b57df1,
+            0x26770c5cda1a14d4003cb55ac927d68a843b0a81acbdf4d1871a66201e3378e8,
+            0x4ef6e3423ecb4bd4137b2b7fe78100b84a1ff459cd0a1f7212668bb96ddf0fd,
+            0x16c6d4fe10c08c64f2bb14fc6d8d650b05c56fc689a93d0c4c0a79abfcf96887,
+            0x1069cff9be3245f60606f94c1f214a3ac43d2249e725dc57d45716d06d905ff2,
+            0xaca974e63942bfe230694165a4f72d184d4b7fb8a1674a70cb19cfd61329f13,
+            0x15ea665435c28d287bdfd4978bd127392ccd486c9afa99454e9561fa992040b7,
+            0x2545f2cb24c7a7c7af6beac75e34deeea9d532c0308187f7bd3b47b133a744fb,
+            0x29b34fa5653b3ac5f3eedd790c7b94be1abf24beeb24ee50a34ee12159e94b15,
+            0x3d5d55635085b4d05b57f78094a130400e4b60548da9cf59b90baab8e664235,
+            0x2b4768592e18dee0d620b4bb3ec1f0892390a9177108346f9fc611e1cf592dc6,
+            0x198e90e2b6f066f99bdbb201258054e8758dafdd397a4044af7fe73ebd0b05bc,
+            0x209c25806fd4006da67b80c5f7a3fb03990dcfe087375143a7a09cc99aef143d,
+            0x125cff70ce16a10ff53be8b26683420c895d366fa9d3763f14d376cbad453b79,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2fcc1e873c2460c19aa8ea31876a63c06b6b16c56bf45ea23b2979351661c066,
+            0x265596228bc6c434d211a6340c4a331df2be3b1e433aee26875876ab83840e3b,
+            0x13cd5d84d4458fdf99666b4f567ee9bc2663223fea98383d29668084a67efa07,
+            0xe4546898234e2c9981d06fbe84630d92d6854979472695a2aed5aa1c2fc018d,
+            0x15ead9f1be93476ca2a93c83125918403b835eb9547d3ce31856d119ae8df0fb,
+            0x2209a03017696e3a73afcb978c53731ae3186f4ba315ed5dc8ed6578b3d9e428,
+            0x5b358d46bbf09ffb07f06af770b4c3f695e35af5f32f449a912310c69165652,
+            0xd4ec14ac84189f1e114ad899c7dff8da5000fb3726ba88b6ed828451e9a4027,
+            0x212a27391f1accc7e7e01e05868e41a62a2076efdc6ee94f26c30e5eb5c63359,
+            0x1cf3fedf016306b0bbe65fda50235bc16cbcb1559c3f34ea6ee752f4b70b4848,
+            0x52d3e0d566bd58d8097a8d1389d1caf33a2f2662de98f06518670773f74215e,
+            0x2852bb73795f54c6adc9c635d5e70b03dcd03cc1229046fe2173c31b10efec53,
+            0x23b69fe902f42c3489061de846512d346ad54cbde1d54984e26b551b29cfdd89,
+            0x8a501e4d110e059ea6a0621d18bd4346af275aaebef1f402449c9f675feaab6,
+            0x17f6697583d43520562d008293a70980e2c6564131faab56fd71c285392f5bc4,
+            0x1b7e8e80739ab54fb01d2637963a91622ba49401fd5b961e892f00107781788c,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1cad07b82878b8c153b0278fbb2e90973327826a09fe720d37166bba7c53acea,
+            0x988724d5f424785949062a55133a433e27d8c89a7ec78016db5f064cf786948,
+            0x2d81921df5457361416733155b8135b53f6410a41170670e3fc8204a0bec2d59,
+            0x131cf6530e31b3541b8312eae98495b9b5435a8d32d35e5247c53f3170a58110,
+            0x26ca4df270856d7d89521b850e376f46c84685eb832ff0abc83be2e46d008692,
+            0x148832d14674b5bd61f45b882d08ce10b65eeda4a8d90caeda39210526a2930e,
+            0x19395b170131e4b969e01d8bcd1a6fd6311b3375c0dbd1e31b879fa6835b9dcc,
+            0x2617b1f4ad2fdf615bbf88b4efad44b6a7cd5ec6e2c469a94471d5a3add577bc,
+            0xe0507aca633caa740518c6ed6ff9ca084bb59a7d0d97decf2530fb6ae3cf24c,
+            0x176ed52c8a9f3f7bef3e084c2e5235496a2177f3418364c3eda28fea7f2a6624,
+            0x1b1ddd3ed3c82536d4e2cc47820f37b772335bf4530356e590c69938c1ad9eb5,
+            0x13c8300e2bc52c8d4c12f2cd9442cdbad38235a1e34541b42a274be0146455ce,
+            0x2f5239bdf0e8f441fc01fe081832618bf1b9628cc80ef508dcd4273420cad1f2,
+            0x21a41e1e2c6e4922de2cb723d64cbb9496216429a3a5a3c0c6c0019bbbdda93,
+            0x3825cc9ed4f752a3a61be70f3f2bae0a22416870a8f692206aecf4570b4d751,
+            0x16e3f668cb7ed8c2bd6cb4687d11dfbd02a8265f671cb58a7bb33a03a5238a1,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0xd94596be2cb2587e41dd5ac38707f4a718dda9076b74a2567949a627bcca82e,
+            0xda56e7fef653a7528ebcb12a7a01082f7e23054bbf948da64bf2ec2452d098b,
+            0x22ed449e9752660719b8d34f4962772d7c7b08e4882442044c73a8aadab72c4a,
+            0xca9d3e4986304f7ff2894c105218dab722390273c42c427c4dae8f29d66ca5f,
+            0x10b01235bf874a5b2e184a8410ab01107cbf0648040ed6633d179509f5041191,
+            0x126206165d8d964565d3220cbc84cdec26a7643c68f7cc42ac60d1f8618a6200,
+            0x4878d524f362da3e3aa6dd357f0bb7d5615f26cb758747cdb30490707218854,
+            0x21127103c61b8936aa157eb73855ef46d5b01587aa8a199478424f3c84d9adcd,
+            0x15d5439ab67e845a1f55af2ced4e06ce2d577a29fe250f1e8116500d11681999,
+            0x16a7318212f1751abe1b5c422ff830f1892dfd76737c7b49433e7877358e2db9,
+            0x245579de75e5089b4f5f0de11d5b88bc5e395ff9a0747a2d33b8cb3e3394aa91,
+            0x2ee3d749e038889f77c0ddc80bb7cd55df093664716a75f0274b1955a8712a06,
+            0x277b64ed9137d7914f9445969c33db2f0db95938df3cdad46e6c8d4ac996796d,
+            0x28c9181f359dfa1ecfe51ec8331b999c4be610300576e07d8461d468672e9571,
+            0x18a1ec6f905a49044a4920d0a4a1f74a907db755d1f06d2d75551c6e9b5bb520,
+            0x269587fc49db8b933a31bc6678b4087a12ff762c1a19c3699e0703a39f822906,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1c423fef62d7ed3b20636135bed12f56c33b6ed3866b4deef95935b4fdb3fcc7,
+            0x2c39e9c9ffd3f1acdc23821afad680c199de68c72500ba9affa091fc35d8b230,
+            0x200be427ad5d644255178ffba022a54e5ba811aa0a0cdba615991897d312933d,
+            0x5bc3aef5509b9df5380dc3ff1806ab689428626a44293af5a2bc33dfd98541d,
+            0x19d3a7be7f42755c49327c0865f7df015df793d73c5a036f3beadf16022d1bc7,
+            0x1fce5fb51256a4df3e994252d479c8006547bfa2649b9fcbac1e77699f31e917,
+            0x24d5b2801c808c74305280fec1d16f0a2185f4f7ea2709627454797e1d694aa9,
+            0x1b4a744a7602f165651e06044235910295d5be42f5e5cb902cf1bd0a449f44cb,
+            0x221aa0d3a117f313e2a2a20c6927618baff0fc77188801b96188ad8518b419ee,
+            0x2cff615d12e087e7d90119fc9c184c7903abe446e206a02d1ade996431e0f282,
+            0xcbc5ef09419a755b598b1517a196b2ba15521c55e4b940b410e647a57713310,
+            0x243e638c46a410bef0335b65a5e2dfaef63e3030d9c20894d43dd580fb36aeb6,
+            0x11ae740f93b3cbb1262d1a6232a4d8c32a9b4e2fcce71620dfcb541a6bf3083e,
+            0x14ee58652277e60cf9d5c2690dc83b833c66db0f8a3524d9d73b4b78846b145,
+            0x1bda443673db00ba4dbbe09d15420b772ee22d921a43d236368285d42bced6d7,
+            0x2de86a4384d67c5e44837bf469091304ab5e77d2eea4421edf64ba3321a12718,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1b917b840ef31eb7e0a628bc85f7c2c200daa2c53ed4ba7f6a9e1b24b1ddea35,
+            0xc54f4f9747bf23552798112aec65d4e9ea425c25e4ffbbfbbc3de49009f8858,
+            0x2ebdec8a92cdfa3d690a4419d1928b4b4d93d5f911521cf06140340913462731,
+            0x1b74699cc5eb637115960b5f70998323c9c3db826844682cfb8ea43c375673ae,
+            0xe09a75d4dbde40d4e18b88f63acf3ab1ce50c80252a3012152ac38fbbdaa61a,
+            0xf7c0e52c6acfe356ef5c75f08788edd3e75cbfb209436f7a5d0c3ac9b250c5b,
+            0x250fab500f159fe411838e3ac03d2587f7e358cb6c5847df2b427a6c074df62a,
+            0xdcc8241d56d88000a8b7aa90f6af3a4fdffa80db18bf815ff7a0b02032b2aea,
+            0x1a34b7894985f4d6b216af15dedc398d4ba39351bd325651972de2a64fd810f4,
+            0x277bdbfc7a614412262af936a8be70b47e7e5d31537d85ecf155ac3ee482b920,
+            0xd3a2e73d19987bba8d72256028ea7052faa7e99aca09d9a08bf0035e402c03f,
+            0x1c00718f76c7b7bb506c09b6e1596c137117668022fcab596984aff97c858155,
+            0xdbd5f1c327ae5b775eecb71009a20720365c0e482fde75e1bc1371e5c11fcb3,
+            0x867c2b4fea85a4cab294824e2276bda8a7406fbcd5da41b6e0fdd8b69a2f1d7,
+            0x1d393af52503c0a9aff9fc1da41662cf9a76ad7d3240890bd456a47731a35b4d,
+            0xc4efef6ca45633d4ece8715dbdf4b9abe4121a608606d971845e47c70aa5db4,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x280e2e4d9836fd6f43a90fa68a9220a0e5679ad45fb21c8e396dd7c267e5d3a9,
+            0x50dcf95a7b3b535a88ef70504cc8a444e78f8b5ef48a3486112408d1aab3b87,
+            0x1ded90abdac843e977abebc17ed03d58eacc961cc82dff032df1e60371acbd1b,
+            0xc83114862faa4b053ecd3df00bc7bb610d8f777319da6695211696cacc7c2da,
+            0x2f38535fca1d0fcb6656a7bc9f8d6fb0951cac281e7204191d124ee1f9597056,
+            0x15a8a27ccdf7f31e9c9bdeb0aa12189a62420b3fc3af4c0ccd527bccdfb31261,
+            0x8538ca91007b4af17747450f2d048adfbba6ada49300d46163a6141d0d60a23,
+            0x219358a11f299fe602b8336d6c74c8ed45e0af3437ee3dbd73c7415dd954f229,
+            0x1a7ae67fd2b95fa482e68cfb6adf7a5f703170ef536e0c07c8f45e212331891e,
+            0x2d8a33dc859b421d03eb431ef70e9955863e4bfa9a7650cb11f8cfe45521929a,
+            0x23e68686a4e6ab0a2e24b04c5f89c2db9b6890816e7305ca2c92a912636772ba,
+            0xc27986848ef557c8645754b95ed9edc215e526d52dd369c0777d4f378465d03,
+            0x6e2cceaa215aaabf58f2e6ccb3aa062e24e506f3819645131a1f846cfc24749,
+            0x4ca455e242a91ca2143ae13d31d0ad024552abe39636c4215d7772512868b97,
+            0x20107d5efa2baafdc19cdb78750be25074d5052d77309209d83feaf764ef4493,
+            0x284a8c5b8405a825d8acdd215c16bc5170fb4c5460d6e775207047b109fc3e63,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2617b4b39592cb7eb00834dfb430ac37e799da74e8ea6c2cbac3bff74f3282c3,
+            0x260555fed187679e25946324ff117f1f487d75d8811aaeb6afb29e02bf9e9b77,
+            0x29d66baa1db480fa0976c227b8be2b1dff6206980b543319ab8e6e46bf1af27b,
+            0xcd6ba2405ef9e333036c7567e0e368109489be5791633c12042106eb0dd43b4,
+            0xbb6ef374a10b4538ef1ce3c0cf6ef6c885dbc2f449892bfd17e82e7fe9890f5,
+            0x294e76b2d0fc3b732ec3ed8f73b8e1c616ee0012b69d61417a4cd5f18f893c00,
+            0x2a2d473497afdb60a7008c7dc7ced5a33fed7c5424bb6a1299c24f373e7f16ae,
+            0x60533676e96c73a3e183dd8f585c78427c0cbe99e97f8acdb098889df1439ee,
+            0x4d3ad331506308539d84de77d62f6cb661c870bc064fd3359cc711a06baf4e5,
+            0x23444c530e318b22418fbca527fbf9fff0c2c92d623f365277d65ac7ab90058b,
+            0x84a073506da63fae8ee908965d634da2a789160f1ff73faf58b676e5c914b52,
+            0x6c1018af2ab1b629440d513a4971e62b2dda42233dadeed10e4629fb1e15c48,
+            0xfeae12c9ea34bbf39373aa3c159e553dcf7412caf17269a6c9b7e9dc594adb,
+            0x21f5f23b0e3f44f8768aa1ca35edcf5e919eefc9d9dd47e44efcc99694e51b54,
+            0x6209e20306d5ff2ae4443bffed0948b2bab65487650f1e1f956c9e5413b168d,
+            0xe981747daf6de6e6be60f7ecc28e84be0e4b7e8c07ad2128fbcc12e0c7096b9,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x20802f8ba4a922457a1aefdccc804a9c34b885a1e9f0fd94473479c74e6ae02f,
+            0x19cac2ada760fa14ad038d2482dc86661772ae15de0ebe6a1a767082432bfdb,
+            0x2c484464a823c43053113755869610b16e5116f2bb1f3e024d65d9206c3c63f3,
+            0x20aefc9cd863f976e7e5f601102158b578357e3072ad22e68028640e5513b471,
+            0x1310a6b902d3736b0a50a32048c81feb98e02943bdb12700c714bf6b255f3f6c,
+            0x28a2e47b087e9828ea526825aef8a8b4d5a36020f87b4672c36a0b3bea12d308,
+            0x2edacc0aa69661a65100e4686e467aba4f2c430f61c77707e0ad3c2fac66c096,
+            0x23b811e8af4e671b9bfd2c2d83a00883108e704dfdcd7944fa40c20e72e359ad,
+            0x36cf4860115229cc61870796bfb55ab6da45a3dd204e1e66af397018f34187b,
+            0x1ed097ff6526283590ece731b725b9f734a7f516d6a8b1eabd4120c8d0fce65d,
+            0x2242d9a8c934bd0f2b097e37feea098bb500091a496bf689a59b795c8d7469b6,
+            0x2e1dbf3119ea622492c1f15dce5addcdecb3ec045028e9ad6a8bccc85a456ef5,
+            0x2d034fb552635fa6bd63f5e91ee8d7bfb8a2f1ba395190a177b2bf1aa76642b9,
+            0x12c8e6f621ed980c07cca4bef17af232d32c2fd7cb3fcbfc971947e66ecff2f,
+            0x548b4a31bab4692a858acd30fe523c42e8f2dce046f2f121b0c82cf5bd306b6,
+            0x4985d3b7fc1a4b5fbc70fd37205abe31e33c4beb6f13777967ac5fc07a3df18,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x176ad5e77dbf9eff47130906d9f295bf1139d3cf00fa5ab42bd3e10d357bcda1,
+            0x37fc3c302395fca97bfbdbdf5ff14d1f71300057e7d994fedd19f2d779e41b4,
+            0x67b7fa5f5b640eea5c1173aa40084c2893f0b66c4d8eedf9e48444de48cbd81,
+            0x1ef50a9851144552374b8b175f1a069b99271337c29a94945140eb7e1a9560d0,
+            0x4a8f411eae9b96fceee318a3d82e839354b0999e8354ca66bf7f11281c865ba,
+            0x17c90c447cd83ef7d547209c4644ac95cc1017bd65360faf58a8cfb5210bc891,
+            0x2b324c5a69146a0b1d502937c9f1764757d43065f7c3c7d0a7979552354b3f98,
+            0xcd0a626b860fcc13465134f015336740cef85aa91bb7c919d4f1285dbe4953c,
+            0x1f2baade720437f5af71bd826e87e155552a95da11c06402c76c8c574707de8b,
+            0x1ce2ccd7a415304ac0e6f1b265590359f970553a10bf8df85a55eeebf5cdabe5,
+            0x1498ca31f8887cce647ee52fb4b3a177a3d8256354cfbc83ef0349fe3685d1db,
+            0xe6e210f18faca167bf3d82bf9f9e58d6e094c03b56dcbd243fa737e0ef93bb3,
+            0x12cf450b5228e1b7823665a58c105ab37fb064d287b28f115ccd128cae7e440b,
+            0x1fde1a9a7f3a95883481d25eda60225f3dd6f67b127fd2db690aac68bb53fcf2,
+            0x16b2c4b1a4276fd90d0803113fda96bd017491d592118ed721b2660a5576b192,
+            0x301ae24bfd116b2a5a8ab9c08fe26cbb20d111ec34b7f7b62ad4a95c95531436,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x887f2970f378099bd8129636f847065b81b3cc57e229d2d00a15f314f1b705b,
+            0x19b3b01cb6aabb13901f8fb5dc1490ca360284f262672e7f0d39dbbfe0cf5e,
+            0x1b3a6e328bf97c4a2bb7b62451d8d21da221d9f79dde1d20961a5730191499e0,
+            0x170932e63d8ed05d6b66499f32e6261b8001bddc0ca176081b7fd35f9c2a019c,
+            0x1899457555eb5581fddb51340488569c2b4adb0e7e6e1b59a36293b3aef835e0,
+            0x164f7a46d01b3ed26cf79280d675584af03ef532ffca9b0aa1fa4c046ab9729,
+            0xea2ffdcabe9727588526bbfd56012495f1d56b06a5737726073eb9aa7052aaa,
+            0x7ecb58097193ca637d89cd708a6610e9bff056d5d477f0f0baff2fc922d0334,
+            0xf47e601e82ed174b715554cd3d5529682511ac8dfe48cf7f2ccc1093a892d5f,
+            0x174f79e424542b0e34f0fba0d6451539aa56c56f72fc1b006156f46a7cb7c2ec,
+            0x1609850116dfde24d7cb5510912ec1f4bc416f9a5e57cbba8de63a2556af662d,
+            0x10ab565bb9cf436914f214352b48bdb7457ecada07f09215c9522fc79701ebed,
+            0x25903539c56c72c86dff0d320e4b89921f177b9be69aecca9e52da81175eb5c2,
+            0x24be2bc0726dec8e7e12fa3a18808211b32d0725f4d6414911c250223fde21bc,
+            0x5522494472ece35e80ca3ef35636e8e5265563cbe43e50a14d77ed0d9f894d7,
+            0x2a9d37d9b9bec22eefffec1acf6a2dbdaf5054fd455c300a6763169d4c4c2505,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0xfb784243c37202b1648a784010d674f2ccc662e3e72dc97c1e76f0f815948a1,
+            0x993e6aad24c4d252ac53905907ca3610ef2a5e6e48eb3da752bcca5dca973a4,
+            0x15fab250b63506ef0b6fbe565b15ca337504a59617751f3e91e75891e8f2fa0a,
+            0x22b851ba2d74cc07a36f73cec3f54f2e24f7a5ea54bb5356e5570a4e55ed1f8,
+            0xcc28d557fcbe39f2da5a831f97ab31d4c9748a30c1c027286f47660fca9fc27,
+            0x392cb28a2f6f3e8bd6f869dee34d83fd84625f658d2c6b02a6acec49940d369,
+            0x223232ed91851f7027a7413f23b889f73f18f20ea91b308360b074250eb5b133,
+            0x247502139fe5a4fcceafc47ab0835fab3778866a0387f67c0c11730b7086b423,
+            0x574e7796304031aa15766be5b419486db72f2cc43798e8a8ee6ade15ea64cb3,
+            0x1d18392864858785d134b2848d7fc32cf91da60461efc01731ad49bbb99ce7f0,
+            0x2b927f1d1eacf0ee5d3246fec97f13ddb9ba2e34419a7f0fe151f8d366df48a6,
+            0x29ca195348764c2600076d9a475508b7fae52d6a9c92196241ac3f08d090459,
+            0x291930cdffd0acc873be352600a12a6aa056da7621cf3324e7636f25ef4d905,
+            0x13e6e58779312fd8a2ed9368587b5e4c207cb8cb99621f4254a1704c41477656,
+            0x74c6fc957511e7287e7b6065c03d55ab19881e2cabab988bcaf997d96b90802,
+            0x1da0150f5a7104c25413c83f1edcd3dbcc49a91881af8b3809d40221bbe8cf09,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x17b4a6a22f90ec5575a31b71aa505b70cc19abc0fabedce5dfc7108bd5472ed4,
+            0xfb75a413209d1ea511b520b3ad4e96dd0a548ec6d5ce2de9b0edfaf667bf213,
+            0x7229fa12e5e9aec5a258249b3667fa5a1a7e9bf69245efdc66a11d4cf9d16eb,
+            0x29344527ccc73bd6ae01d4ab76d7d8205643e8c39628e5975b0e68ac647e7dd7,
+            0x2e06815f466128d5b0fa1325a96d6f63e513c3c3590f612d01f0ef02fdf74ef5,
+            0x2381219c79d22ca23e9bb37cf7f3da8125510c1a9d7e9e26d028ad61f3ba94ab,
+            0xf724878c378b234a5bc4fe6f51c000682ce95721afa4c802498ff5f4e3599d,
+            0x2961aca4c9ed99dcc5db33902857ae905af926ba044b93d1b8cbfdd82de72c6c,
+            0x1a661c53d875032769a8a89ff224b3703864fd77adba88076f9507884ea8dc0e,
+            0x20d8c84a77dbf187d873feb492185f9341bd7d20d4c82d4c588009102389aa1,
+            0x273944a60bd81f3c014cff9a5e1b1d99079a7db63860abdc5b850138c3ed89bf,
+            0x2c3483ea9e8733bc2df8605d84cc2903a10a4f675f803e33090bf1b96d7b6f5,
+            0x2c1570fa771ac87f6c1c7dcb0f5efe2ae8bceb26280adb11f1565bdb3234193a,
+            0xf8f2bcada2b15807d4e400663abb7ad2a6c653bd3e27352d2aa03cfacebaa3d,
+            0x13b356322af7bf7ed892859c3512f21831d23d6ed46bf4c3514762c2a468cddf,
+            0xe8ffc445422b035202aeb459085298e5c3d52ad57a4e0c982e4bf6bc430879a,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x266878c7dbb3ebf725baf09bad62441c2a05a8cac838d637371bcb71f7e637ec,
+            0x69ca7aea6fe25ee984031f308b491f2a550e4134769d30dd374c0c97ee16568,
+            0x190c3bdc4ae56b9371806f99c5247c7f6071ccf725631c6f3435075889f34956,
+            0x1d325902dda87290a07b115f3673203fbb2039cf470f229881c786e115ee6abb,
+            0x1b2936a6bb1b221aa267ce939f99c211b758c2128f8d544c4d0b5cbc660fcd54,
+            0xf9fff4eb7e28845be6a783736f297193297a7cc12caf5dea6f07b5eceaf6323,
+            0x20e98cfcb657b1f49c92a069ca501f89e96d73ce0791edd336a7f5e129e5ea11,
+            0x15ddf382f5b945869af8a3bd1a030c98d8350e73600aa0e8e1d4ed5e9a89b5a,
+            0x93aa5d4e7c2e0b87bf1135f3f0d94b40d59bb293a582031adabfc2a8ab17bed,
+            0x83ea048a2fab7aed31a80902174faa9f1960bc2531d18de673fa873fe688207,
+            0x4849567874ad0253387252406f2d8860b26b6b605e98c874a585bc157c57a39,
+            0x10315d0548c6fde9fd87ab4a523f74d3a5c791e455f90c34b399503fd9662149,
+            0x29b768d0c1c037e2c20b133eeeee017166d2797ba47a2e647595e5f0bb433c7c,
+            0x2072b5dd1028087414d36c4fcb845d4e4e719885af8f4abfab39fa404fc68e6f,
+            0x1434175409254eea7c9b9fc3dd93314403e8cdd56f9cd48348198334c700fe6d,
+            0x2da9b2eb148cca6790f4b12286fe560880d75e66bd4c64ef8ee58d7551ca56d0,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x16bfb5fdd4ef9b81e92336ef013f8430727960333b76b5eb81dad8ef220bd284,
+            0xf746438c3f4e612f088a4113940619b5d96eec18099f5b912b816fcacd03ac3,
+            0x25f8d85e6102bc16cfcb5dfe2a0a6850c4f7d045a3614908d332702320cd2445,
+            0x19a23070f8afa08c4a0a2e8a1067db44e95847e5ef5337057437eb68b023ddbe,
+            0x19e74aea657fd4206322de101be54c0a70ed001eb5a3b897aadb178cee98303b,
+            0x2a32e9f7f76615c5bc2cea017e1e937997d33d011ca2c543dcbf08664f247607,
+            0x2eb2f9782b5103cce27210e54c6d760ad28af00a23b0252a608ee0536525990f,
+            0x324cbb7ff16c463fd8860a5c6719122702f8f055f721f7c2ad5121d03ccb6a0,
+            0x4fb92743eed5177e7a4eec1917d48ba4bf2df9864f477edd9984b5a1b37d95c,
+            0x232e90742d5251ee73e1e55ede489421aa4d9b7f731d9209e18ae772b1dbf163,
+            0x2888b0287bd050425c3241bd7d5336708c1d2410434d0bb8a094320552499791,
+            0x5e878a6e2dcb5fb6176345fb830caf6edf06061a452e94d1d49a862b1563411,
+            0x603e7150eb9b06c9c0b94832d53bfacc98e26386e2de0047d289e44483331cd,
+            0x40392b8780bb071d2acf492bc6c49d03ab66a7d7d1689f16a47160923d6303e,
+            0x27005786e8d1cba94d005f8821f564a42500562da999b4c40163fd15d20a7188,
+            0x2f6ee6456256df4b7b4534f97dc725df7d9e359a8af4f84035db5ead72d85594,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x249d2e3a72d67b9ff1c12f00d2e2d15213b2c3d534ee1fa7e0726235d5f8a76e,
+            0x66af81c271fdb20f0f7947ba7689567fa0acec8e8760311b200713a3cbf2915,
+            0x2d07f33cec08d772afc8a847245583d60fba733b2874e3f14d59770a6eecc1d9,
+            0x2b5752992e1969c88ef2bd4cee7cb74d7af5c73b2c43c148d47c0094163b7a03,
+            0x17eed7f1d2c6c6d5a9ead4a939871196848682bc2aeb713409769599c6fb99d9,
+            0x2b0443e7dd8fa52629acb60c4d9f489a3b485f9bdaa3049cce07b90494140c99,
+            0x52e92369cc40d1c0cfa00124ea29c928b85c7b64c1b5a9111c07a33d28cdb7c,
+            0x2d590ad359f3f6d0aaf8317cc35b62d92b05b0f5c685cc8c3a369de6d1d1ca99,
+            0x2983673217a3388ea6ec1746e62fd0c1d2b2d774e63564ae271d77dba331817d,
+            0xd5ce1123b37edc685e8c234f618c830e87b1b95c108a83cd9d5065ce002130f,
+            0xf9b69256d0d0e083ba08fdf1bcc73a95b7b378ede36d8066cb024b8820bb003,
+            0x290490f51237cd7ab3824f2057a7a2eb725f946442c7987f7392e4c85e8dbd77,
+            0x2bd1c921b2655ffb99e5a5de025d08c692fce4e57a3c401fd655e2d05d92a653,
+            0x3fec0bf41ee1a2c0a7a0b7ce73053431a26d2b7db92d42a41911e6129e3fa9a,
+            0x2d6233e08181a3c9db09017c0160c2ef359139513990884baeee525b2597eb81,
+            0xfbc98b8d3b0b6f2b8eb1e780db16d98ef5d4bf4e65ca518e62dc72f693544ac,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1f04cf1ca4f6db30e843ddcaabd4cc71fcda39b55533db1a8b61488aafaaba74,
+            0x1a6f6a78583cddaa58898327f4ca8e00ed729dd41c464fc9ab0c5e0d1b2e9bfc,
+            0x3e70e81573bda5c6ab953bcf41581cfe4c65e2d3c04cf1ecf43a2c8ad250d06,
+            0x13fb5b6c8df4a5257dd67b782727d8a7d90ca92c5d9a755847a1d3b6b71cdb90,
+            0x4d54595c25b41536d1f203e1a367acda8feed3369537ca2557f5da49f290e84,
+            0x13671d8ca7ecb93d29c9123bca96103e22f68fc5a16968fe903c0f30e8bd0b44,
+            0x1486a9a8302df3771d974c562e1b03b96daff1e1fc6bebe86595d32608a85bd8,
+            0x7cd279d7d44931e437f59bef5027f14e49400b0847f4117c762ce21ea66775,
+            0x2358686de458647dcf3873e187eaa940fca529dd9398d2eb002a1e6f0878ac8b,
+            0x196d60cd8de82119c9360e9ab96b1bc31029ea6bc5a9c891584febe494ad5d53,
+            0x1e18e5d708702aec708672582aebcf2e4dad6be0100a7d84f4822e156f2370b2,
+            0x18d0a6119479f34c41acce9a1086c6b1a340a3d4eca4bfa561e4205eeeb8438f,
+            0x41e39755ed3b12972463551f41d5f1739433b966b759014bdb9d214ad9a6fc0,
+            0x1becd98d1916cbaabea2082b8e7f1765f838f2337121baa896e437be5d4278bc,
+            0x2d11307d21979b68119899fc08b91e02822cfb7c49ce878ac58584913d6c8a29,
+            0x24b7d69ead7cf1c4c204d6d3e23368fd40db0f2df00a4a8388557b6110917538,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1c414080171ef43535efed9c5babd2275b89e5b175f3b71314f6c59040c97808,
+            0x397889b8011160475bb4d6d3379351bf5ecf90800b9cdf57bd3aedb21053cce,
+            0x24ca54f1fda634f9bfc0e39b0d4d6a738f7a012898e9c2bfa4a42ed533e52845,
+            0x171598e7caa20c990e43306d06b2fbd5879619ac63904e4395a53ad5d60e60cb,
+            0x305dda5b8003c236ca1d724beb0335d07aa3b2ade1ba21c59dd763f3019b5ec7,
+            0x1ab2ed07578120b399df57c5f109a40e47eaa956e66a6629e1796bde7174bd21,
+            0x2a47862d2f0d0629863c878ad7fe7df592ba7f8f3f94e5e5a85aca3958229f76,
+            0x1bbc9591c66436dc5cf4bb562468584632cc91a200b1f08e1a28ae61e5c30abe,
+            0x265e971c9adce13dd324bc968020828cca064ecf477268ab534265d7e5e2ea21,
+            0x1df96d7436aa2918ea082546a9e3e149130fbae6776590846e0632f3570657e1,
+            0x10a8c8aaeaea0414d87c0c1553784b744ff2e8965942d3828e14c484f84d2535,
+            0x63e4901d2d6197831f94a5ead9b058847ad67bcd8514eda44ca69a0b0ba9c19,
+            0x1af00487deaaba2511ec6bba34b8f248a5106b11d69cebe26fb5f35d2745feec,
+            0xceb1792ea63e2bace5b317ceff4597ccf3071a67199612396650e8defea646a,
+            0x7fc963b8ac37064379d5a652f999038ee4a250e0e3948cba3b899840a119387,
+            0x17aa663de33227a947a00ebad16999a905bb2976d0c997a9a5a9fda6690754e2,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x27e7f01f7e5850decff3c8f5c3ee53951fbe076ca41a7e1807cbfc4b8eedda63,
+            0x13e9c09190f744dc7563c578dcf432de2522b7c7f995b2880957c5d2c54b27eb,
+            0x291cdae728ab7b72e119248c0646d1a7c305afcf50c9dc1c1eaacdc9660d21a5,
+            0x2df268da059255b2d959f934bc217781108e61710f0e3c460419d11f1366f45e,
+            0x959f13f2c04b17e795093b408f590b85f707e54795f5df80bb57b35c994dbe,
+            0x2d83db369e2b48848a27b55553a8bdb77e067a93f1f28db9de6c65b14818558e,
+            0x2cac7303cf0462f21c4c154984fef173c428c47215feb2c0355c15de4dc64ae9,
+            0x1f16c3b17497d87c65b61123d1954717fff18f21ccf4c86b4ae27444b535222,
+            0x211a857b06dfe2df621d3a89a4bc05dd0247add6ce13502fe7fa37e63888f7db,
+            0x1bebd0b81ea6cf89919ea765ea6d04d035d73cf7745eaa757cedfe625d10573b,
+            0x2cb676f0cac23cd80bc40f3269d2610fbdeb7f20f5a74d72224525c6e3ff69e9,
+            0x1e478ad6535f1ecc579056c6ac6ac8744f8e35209b7a081f47a5b0c33bf144d6,
+            0x1669c72208abd4ae25158c9c73156e966504dfbb6a4bf9b6fe37a1e1053b049c,
+            0x18a94771fbadbe268f58cc38e48ee81e3cb5a94b8b2cffa8cadaf75a171de693,
+            0x203411c7e08bbc6a10164451062b19e131ea52d02dc1588d3591c8abdfe1fde6,
+            0x6cff9d23d331be245ca3ea0e37355132a367f5ceedfd64c842dc9aef97651ef,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x167961cb9db6a7f1e253bf7c7d0711beed69fc736276820f1f7df8cfd1305bf5,
+            0x251b413e3039cec0af54ae9d0dc7ac5ccf5feeb9ccc482a4a4e93df5dff6eaa1,
+            0x22461b5ae9c4937eff6dd0c2ad5475f20abd4c5d13aa3894f20ce1ceef0511d4,
+            0xd3c8cb0ca400d52f3eb96f6e403aee53c9e2283a19826f9b770d5270d3f2316,
+            0x14fe9ead6519febc01088fab56bdd7826c35952169e8c60782ea746036fcef1,
+            0x9e8b9302c470b946bb4e24b13b1692266be83cbb0f833527e1971abc11676e5,
+            0xaa736ba6817640b3613ce5c87cac8f64ba74ec23f8f5c75f0cb1dd2ee552f00,
+            0x195c4f3bfe08a064f19d6fbb6690f5f723ccf6851db01e64dce49b82640d624e,
+            0x10bf96df637b9926a92efe91a6095501db10b10b9b8207e73eecc3147dfbe14a,
+            0x6f9ea58e02e97445f704f68bc535b1d9d6ecbcd4d151bf2bf9f6bace985c14c,
+            0xdb1da59cb0bc70afbd95e428861a2b708b9894749a2a88e62520a767c4e6d48,
+            0x41dc2cccf102bb7168276813ff0dd2a3ae59f4f35de8aa1404160be701d566a,
+            0x33b21d96a57d2c1d44c1482289bc607254a0395fbefa3bea25983d6e1d70893,
+            0x27b5df4b4bde32d934353e58dc214d02a835318804ddb812a81effded6706985,
+            0x16c436812dc3bb29c680d81bbda2fc964fc0cedea2cfbe4f9f0bca7451e2c26a,
+            0x1075ab0069e8017ef2b84b9034c0e4e981de009440f57ffc72ac633624caab5b,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1f158c6c1065f78b5f780520f03c584465ffce26ad183a50e11efb956a8ee412,
+            0xbe6ce6cad51b6bc14791f01fbc62bf26f20be46ad5839ddc356afaf24dbb219,
+            0x226643746553477c60b99089eaaeac4ae64b308a3c56ab343e55a6174922306b,
+            0x2e82b3412adb8919fea66a8e2c0d8c5fb6376944728224b79ee3edbe56334e2d,
+            0x25af6deaf2918fe03edb3989dc037a834610d69bcc3409e13e7fd657b6c404f2,
+            0x10168c4b7ba5c85008a4f87c0325d238562951366b754259c06402e69422398f,
+            0x20441555acd94f03732b606acbb25afa0e3cc39c7f0602214eefb497b4a340de,
+            0x200658fc08ceb25b3e1ecece3989b682546d415f3eab6596fd7f63a9ebcaf3a5,
+            0x8dbbd95a7fee39cb863987f4a9dd8c40ec8c1b94f21735819fa9d6fc524547a,
+            0x1679802a70dd63806557cd2d8dbb8788a91dfc982c672d9c2df04efdb12c6980,
+            0x18b5ee46c9ef30ba46b5c242bddd68c8a1f891122ec62eb0a1ce4e0efd408297,
+            0x1760042648d3c88f3800bbac32caf5e5fd6b808f50af91cc5d834f3aa9bd2128,
+            0x2bc24aa17ef22eb5273e6812a0e597bde1cb74b65fc35ae06f09358d966b243f,
+            0x1871a1352a74bfb73dc35b7245903c1906a12dc3d9448667225b1d61a83e8cc5,
+            0x15ffecc09ae5dab7e235644f38c84af5aa6ca42f2d23b64bdf7ec536f9e7d5f4,
+            0x2c9c4d817a1351cc3f659d10453598cddcb7369f9f5978f44025b9d847935a55,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x258f6b7174e2619e3c94d65ab10273d210ddb46eca06a22f81117fe5f02bc38c,
+            0x7b65580ab28befad1640084a12ab11bde32586ed38470937985e2ea07eebdde,
+            0x2251fd1d0a5bd91d3f958b9377996bfb6f7e777f3b2a3bec54befd9a19b429a0,
+            0x226bb0f7370463f705b99cade44a76fcd63a762a9685f7a254d9bf67d9711d19,
+            0x125b1f6876e2cd4548eff5a6ea0598ebe43aa0748cfdc53c83987489c871d0c,
+            0xd6400436f874ac40bc4e3e392043675a8f8bd071e38ac56d630f810a6c382b2,
+            0x152557b0f424f9188e7c816e36f83ff9be71abffa7caea38fe42b0b7d2731395,
+            0x2419922a2d394b1837d8687453eed9aac005a6128ae835110a204cd57663f4e5,
+            0x28de832e55c53a37639618510388ac059fac106d2833311efd450dea8b112d6d,
+            0x19e9bcba7b55e568c983d797460754fad7f04c39a4d078a0faa9868557f34ae1,
+            0x283908c8bb48fee64ac955e7fcb47040fee47edd7810e5ea26e1d9bea337e1a7,
+            0x25c8ea766fae5e6a1a1a20af4b178812c0e3e38eb4c5c2340b1fbf4468c9bcae,
+            0x18cf37ce25ef86d2f7c9aeef0e79f0abb007fee6222e9952c9f734480bf974ab,
+            0xd41106aab9ca69696aaea2184622f814fe087b12f716e2dae58069776e1cc02,
+            0x25a1462f1d5a2353e1af93865e7ebaa573bcdd2271b268415b05fe113c8851d8,
+            0x2d96abf52f1de16d6ed6d4d9279035f5bf5b825754dc21d11feb94e3b1700cb8,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x18e5610502d2a1bdca2d2cd38baabc9fd641ca4e9ab4be237ad32c72dc880c85,
+            0x2bc2a1228621dc365cacd7d5607b93181b585843070c12a7abe98c2ddf0b8ce2,
+            0x3e57b7e7ba3e4e3caccb663416bf20ba7df9fd5fa25d95ad29970a6098b5d47,
+            0x95beee076b8de68c794636c1a75a0f1f79e694e9470af6557dd0a756ecec4b,
+            0x2063d0dce7c0e4dcb6eda83c1d2e9d2f8fb7d2754b2a116c80a5fce17ecbdfb8,
+            0x2793560a50cb73953010b7881649cf034817d3803411649c83fe7de6c7dddd22,
+            0x927b8161885b12371bed6743e7f3cff4e26596f26ca6e10ef9b62824c6d9408,
+            0x21e570ce0b93102f53c6621c813a62dfef04444d67147e86bdcf6d89982174c2,
+            0x4da2abb8299af33e497e76256a8829bf2e90fdd6e170ae91514dd25fef2450,
+            0xaed6f83384c5c1b36797223e5b98e0dc7e322b205d9946ad59be72a56401995,
+            0x1043df1375a10cac3d79397e2572c2de5910c9b0cf9c8a36a8597362e2cad2d7,
+            0x102b5227284acad6650de094677a51bce725c6da6fc1043a7668e939829a5593,
+            0x71b883401c25bfdce86be56ab497a10814bb19804c57834b4eefb6990b0ca4a,
+            0xee706d85983efe15078748f8f19a299283737b33a3c7a74f3c10d2e8d938fa,
+            0x1e3ea0d9146581209b7018ac5660e20c5033641c101f09823d5f305220da9b2c,
+            0x1135f9d772fcefd07385bb7c8b5fc0bfd38c1c41ab6de2da8c8b3bb3dc6ba093,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x5580932f510469f70096c820d9601ad87ef2f66990c8e6eb98d6a6dfde27a7,
+            0xc072aa3c1344e5535661baaf0855759b2489b40320116ec0b304f81402a9a73,
+            0x2c5e60d6d9cee50f3880234e54b391aab138c81550ffb9cf7ffc83e118fb1612,
+            0xea984db0b29d0ceeef9eb065131137d696b4dcbe9b29e12d0bdb74736fa3cb9,
+            0x1461bb4b296851abe76ef1ea0df56b555c76879960935307fce97eba31a58550,
+            0x217814f2d889b58d9728a46eebe679760022e1d564c5024f6b77667d3a31838b,
+            0x2e34b63991a98aeef1161f9c02adde896d1be685e9887af5ec9bfe845d2fbd25,
+            0xbb51a53298cbb5297405c865b6ed23804c9926319ae9c5c7c1ce2478d90c59c,
+            0xf0f1ad048e7b93df29617d62561ac209b488f58234f3461286e592f64a1dc90,
+            0x24856651f6c6c72ccdb29fdf1fe0a24388247c5dbb8973c1c87f3a933fb1a341,
+            0x13161ed9d7133008bfb93eedf4c667744c0df4cee0e0ad9038fd0968f726087,
+            0x1ff88f2a80b4078a90df72d706725ed9e450488f975fd006196208e399d8dec1,
+            0x2c300ce9260279a67bded94acaf125b7c98cc2208455fdcbff7fe98165c1d4f0,
+            0x180152334a015c3e7d433b92f0ed2365345ba1b3dd06e556eb6a39b45b924ba5,
+            0x1469185941b34b5a4f529c1b5a724dfac28aa98c8f830f8b1045ecc65b787f4d,
+            0x7be7c3b4de9f53e54e3f4f871cf62f4c7720d3a2e7baccb74924faeb3bedf89,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0xdbd81cdf5b54b534485c26ecf29628e9e8070fec90c34b780acd5bbd4e7f0c3,
+            0x1735ed9f6fd2ea72803084da6d7e20c4735bf3de68156bdabb3888dd500476b5,
+            0x302871833d038dc61a984da78e5037234c7b2f114e495451bd388879b8ee1532,
+            0x5bf32698276e20768a54f9bed48935b674ac85bb3d9251e1075207c1edc0060,
+            0xae9a1e0aeffd431594e5745e8f4d3e5800361e8028ea0b4ba98419fb0fb578,
+            0x2b98b2ea75766211d9a125db8e6e7fb4a913812216365b1f6d2663deb1f0c19d,
+            0x15c0f1926bd600c94b15ee1c00e0ff93c7de8b4a935023bb59c664fe01f30bf8,
+            0x18f86036c6136aa605da0ad3d4251e64ff31cd436d72b90ee5d3157af6d79e40,
+            0x28542871e40749022211b244fce0bd160867865206c873f6668ec51a429f9a39,
+            0x2432259e7f4740024bfb2b71fc694fa8460971ff8869fa46f539faf994d23d42,
+            0x2cdbbb1f729d6ba0040b0fe63e0ab2e24a1ed05f4c2947f2a4dc78d49bf68617,
+            0x1f7d6c170f7a83d6241fbec95436b20478184b02ff7f4cef3deccc92da64b3a8,
+            0x18e6f168622d4679b6579a5bbe6419d8c868d67294944f8246a81415b30e6119,
+            0x9a3e52a4ddb98644cf4a701766c1ca5ae4a35ef1c11a017dd6aa11945fa53d4,
+            0x136a031823304ab94c93e3bf39b189e240a81e0a42b6060e38c7c2064b8148fb,
+            0xd82d0c90c41c41fb24d7160c8f1708c258222ef0539a2776a20c742dae0a624,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2b0f98b255bc9fbaffc4b09dfe423873babfeb16c64a31d8f7ba70db133e8425,
+            0x137ffcc374ae9e222e733fdf9d0c515946baf3c1aeacab2c6218180eec5d6a48,
+            0xe6a056e92c767cd1fc970b338fa5c7377240432e6bd45aadd958d48f15d6033,
+            0x264c9a5c6eda708da60f401ff1171c9ea279af17f1df202bb27cc56773a37853,
+            0x1862618d4abfaf9e176dff2dfa86f1b94e291ee3e02dfea816637787edf4f37f,
+            0x4d0d2b042b8d971610b3b9433f373d693a306f1082186a35a8ed6a758e0c11c,
+            0x8854bcafc5f356516b2df46f5386a116f14de1b197290316d49869ee6dd0187,
+            0x4b8696c509d9557bd8cc6227caa099f002c5101ff6d5b7a4e48284e31992562,
+            0x125c58848e89261172f9ad256ef6cb755841d2913f2ee2ae9d68fd2eefa84d9b,
+            0x181ffc981c54778532d7ddd39ede7dd3e54d655cfe6681b049df6d85f76439fe,
+            0x198f1451b611973be77cc3ae7c744af71b1c94e3e87056b7af1e949e92cee5a,
+            0x4c9f885fd1b69729a871eb611c4a9ef1e009b0605a0cc3befbb806701b63853,
+            0xaafeadc15dddce6b214e3991babc93af04e3c6db03ae0e1408a503e1eec3433,
+            0x225622d35902840ed662b3dc9480d941545df10f2f1a8199260a65018d7af93,
+            0x209d4d14e8b9192e061a42f149c09d0c9831a1f02c35412f4563cfc03304ff9c,
+            0x1192a624780a6633d00dcfc49ab6cacdbe3d4a62f6c7d8abff6094a678714f2a,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x23278ece68d054afc53c1489204000d720cba66a63842ba7269e35e0bbc6d14,
+            0x9177ed9f3f33508db8be8f15b53360afeccc2f208bc7143bd226b4c885786ae,
+            0x175a7d6713e16fdb34e680606af50037ac78419ba5cf0dece2aba5d849184975,
+            0x1bd2f6eff3f24489dd492eaababe1b0c09b50e983658c1dafb2bcdb69a724195,
+            0x16b53ba34c5215013c262d62007837ae1cbfae155bc7cb3da840bf945becccce,
+            0x2c062183d49d2fd7140548607e86ab487b7a6f4da0109dc8b37955c866ba91c9,
+            0x22451ab479c09eecc408145baafa7f51fa598b3ff2d057365903ea317ab9064,
+            0x82f7e3f789ae657cef0f342c994968f47fed29262d4242964e0e793edd2af9,
+            0x11139d29901eaeae25fe8a6b8b27062045be218be37844305ca3b7e348b0438c,
+            0xcbb2e8c216cfa7779e8085a1a8b24ea1ca6446a664b48d576accae16c0e12b6,
+            0x48f7ffdaec0a2144b28a00ffeb5b61300386fbeee792be38552bfc8363561b7,
+            0xe0bba24d78116594570dd93a932c82b5b6730cda14170f58b73105e29fd59cd,
+            0xa4dc036fd4d9bc2561d3d0c35a0222670c59e5a0626e36811b56646b345a0bc,
+            0x1a1f2f87b5b4221b764e44a68abc8f56f6a97936fcfec06a3022ce00a3017373,
+            0x1dd702226b6b31fede8c6b8067fd51da81ad5b970b023875c1ae5bd2d56cc29c,
+            0x22c40118e01863b586d4bc9b2640c4f6c903410c17f5bffc7032420d494d5058,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x18b43cb399d143c97d4f8de9fe9c4aaffb6dd3785d9ce5dc9651b975b9054167,
+            0x12c599db262111be3d9842cd39f3a6f34e51abe1c1bc0711e12f69c3cc973e7e,
+            0x8bb47ee7a3961cbb9c94a68b2ccd3cf4ac95e8836f7538addff55f926bf496e,
+            0x2f5694920b9644b4396caec1b4c4150eb46a18cca0ebd71c4be28cedb456b39f,
+            0x307bc951cc2c9d4eff936eb6098bc1fb25254728e3906bf089bced7826fb137,
+            0x17bcfa98efb68a8236a23a716d27b3cc4539c8e79ca9026a9b5423a6442e2eda,
+            0x14787ef740948dfc067ea4f81bc1346453f77806e6bc39e3defdaf82eb952e96,
+            0x257a201998e59bfb34cf5494e14c65dc3f2fad4fcc76aa9dbaefd0005446972d,
+            0x12a8d99dd91ae7dc9bd892be2c72d980ab6459d3a6fb8efb96a54dd414906257,
+            0x200bf208f11f7a4a4de085188220177b52da270fcaadd23e79e9e879dce364c1,
+            0x1a9f530729b8ca369b1d5e6937ae365f01dde06c24722bf111ce4ca5c764cb06,
+            0x651d7f9fbca106c4e8b3b5a1ce48b2db6bc1657f7aed28d952e28711132c0ea,
+            0x2a3316648cb65a090f0faea9d38323345b7d4a91a9587a9e8d1cae632896dcc9,
+            0x1553ad82056a8d74b3bb80bcced6a7779eeba7eae923ca8b492b9bdae81110ed,
+            0x130aa152e81341ae6952e6732a315d1567f3ab12cdff38449e42c18ee55e388a,
+            0x2162c9c868800aabd5be303b798357d4530f56e0d8c94c99e095740337911cc9,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x138ee349a5126b8c59ffcc05c3e58041d520f8cb80be3db2d0b72af7a24d090,
+            0x2e59364c831ea593aad5fe14da76a1d7705b7af94f331ab85362c4b5943b8b68,
+            0x24b0f5945c543f6ca8126782d2337ef8dc930a1b77c0e133c6fa94fa2a19a462,
+            0x2d8f29c644853834a8f1a61a8965a9890fd8460a82ed2520a9fb332e6a22b983,
+            0x1e408424ad586d58ca0a0481dc08b8ee63f96c838175dc8a652ada892c293dc0,
+            0x1cae05e2d2ed01ae5077fea699a2119531fc30938a5ae2c55ce656b6eef33b8a,
+            0x1f0c1735c782a57b3049ebfdb7de3238a608fb6fa9f89bdfe199c3df1c1db15f,
+            0x1c9b672560571e96a5590c64c2c5b799e1e317634d8de5b731bd7a51a68d5d4f,
+            0xc6e7bd2073ed42eaf2db5a728b6d4f1245a87e614b322c25fc51eb0ffaa6eaa,
+            0x1fae1dfd513367218a20406dde57d573c62196c4e12f5347ef486102e809cef3,
+            0xe408e6db3d016f993a53e864198deee0f2aeb8309bd66f33fcfa38f401c780d,
+            0x2684ad738e6116f3db8dcccb6c61cbb27fcba040b598ded972d6422299e0c09f,
+            0x2ccc5b6bf5cfb7ba1e8a89e76404ba0067c3d817bf3ebfbbe4635a789c7bf067,
+            0x2e3dcba12acbf09be187f2b4d453be5dd4f3cce2994f18cd1226c63de056e868,
+            0x23e70e3f73723a94ddfcbba70771ce2f5a4e15b4a8f51b2828c05cb07ad2a19,
+            0x169c46ee7bf4e148cbe64b6cb8aa1abee9fb5fbb04997f18ed315345a8594c5e,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x7cdcc3b6498adde2756987e13560d7664f1e805180ae0fbbee1dcf1fa417d7b,
+            0x2d9b8536ae52537df2579df0ff0a06d4a99757ad71652f91d3d724b4eb970acb,
+            0xa1f0085c5a9cd49df855b92dd309c3681293e5af0417301e9e5e68d1b34128c,
+            0xd1376badc16946a4a5f324390a4c6fb00baf670827048805a36b06357c39c1f,
+            0x106d0427df7fc4dd7aa26de279073df7fa15370084bc27e16f5f12a8b01551f2,
+            0x1cadca4ffc5bd9eb861f7ef6e7ba8aa20d7709c633c90111b98e094af29df8c,
+            0xff923b3ab95cf5a3957cd89d03319b4bba3287807830e11073542019971eab2,
+            0x1202a33c0359b51491e38826ccf21bb0c545e660b3da916ab91b0e02e30484aa,
+            0x11608aa64cc3dc635c119d0691f46b0a479e142e0532f9256d3414369f5e3010,
+            0x127d38a920bd78f2b5feba943466e85100ead21ffb0bd048683c7e7ba457443f,
+            0x21f792c3d068276d10650a4ef8c8e6101d763990945f044ebfc6f51126332d07,
+            0x1bdbd707d55dc4709b586695c5708e9973eba79a19d6504181cf8692f7f636be,
+            0x123ed252de9f1a986305fb990661544d1f0bb2d12e3e5abf36130d680d61450c,
+            0xead6abad94e79729b5e708c60dca274356c3e5142349c43382984d4df096650,
+            0x21eb504af959f21f9c7a6b50a58bf5278209a2631dd62bfdf6175af8f22b3c0a,
+            0x27a7eed4d44ade3583fbe7ddd6fe43796ab32266aa3f4ee382c20b99debc6e1d,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1462238c5857d995aa2c7ccdbe788cb06271537ea1a299f28c307a825e8cdfd2,
+            0x20c2ff1b99b7a949739ea108f5f462a0aeea077303cbd515bc7591ae02a0d43c,
+            0x2aaa992acebf67c5ac50fce7824cbf41e6e5a9f87cf42926fb964505ba60c198,
+            0x2797fd373735895c3192ae84ed39007478a4b3435d8a497549edda3d559833c0,
+            0x135eb9d0101c2a78ca1b03ca53bc556a8c9af537d77bacafbff7f9bc66be9b98,
+            0x2f594669789d1b805b611c27ca33a5a102ca3854938369a172c78de5a4083851,
+            0xb8f930192502857b534625bb6ad2ff73e94ef4db9565a7de5c513f46fbc3e83,
+            0xa520b7ed463311aa8ab8e7b8fedb2fe271214127264cb3a0f7a32d0fb871735,
+            0x17198721be91de95ad64e64495b07d2dfae45ea67b2c824debefece304d25858,
+            0x12b591844eeeeb06eed46691ba7e1bd4d6615d2aee6f1c040e6334596ee06d0d,
+            0x2e1d81aaa4a22d294a4f57ca1199bdd171c6bdc0ceb9e9e4f7371b50bf3fc969,
+            0xd18e43e3b9d5671e7f8080d1b451523e655cbf183ccccbd58793628aa689057,
+            0xaca56cd420446d0f57751deb06906cca2c88c5bac6d35a2f721702b1bb56c53,
+            0x18370450204ee070cab3e252535bd279023c9ade36b971986e9f4a821bb0ca0,
+            0x10717c1af2308a9d4ae527c637257974d71bf361d742cccfd9cbeefb04120e56,
+            0x229af48ad01840fada729de64d9ac6c4e2ced8d16820f464b60969310998be7a,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1f6027d1806f3db36b0e2918305ea28007622b62282d0aa7d2d1c38bc3a14580,
+            0xd023c3469f5337eb7ad3f6a1a9a3cc877415f1aebb7e9e5a955ce93ffb786da,
+            0x2b7436beb1e205a4e723df370f2c669857eff6da7fc85771e7dc8256f511c547,
+            0x2cf4f5bd0389a8d20b9cf97d0b2e75a429f36d01e1a1e6a9eaebc6002e6d7f27,
+            0x2c689316dee7e23d23cb31070bf6225d9cc562fb57e3fbdcec3def3143d073db,
+            0x1dbe68dff3088f0cb02990e0c030039e116d0196eed2410a30e91c08cbde3dcd,
+            0x16a3fcc3080e28463fa4da66d305d58b74885dc099dd32b159209361fda491f6,
+            0x2f84ea8936e6f0e98529bcd5d666e87d8c7e68aaa1787fa673b8920669b10a6f,
+            0xf67f541e326dfc3555b54a5a8089013085f3cef05dcdae0666cbe4d1476c1ce,
+            0x22c68a5cd419b439a367b742715697ce0d2e09a481dae8751d7c7726837211aa,
+            0x2063328c09ac22652283d91a52d9851b919051815bb5ad070ee015040835b157,
+            0xe78527a4658f58dac40430d4ddc9043ed3cc910a8a0e30b03ea904a781ba8b6,
+            0x1935fe3bceae0bc5b8a13b073b2678048252e77d85f393f84a1bbf1911b41bfd,
+            0xdc76ca0df681fe5c3b9ccebaf864ae495c8f92b48bb3d9d40274154da97286,
+            0x119aa817917a73d46dec3e58fea0eb8ebf74041c1b069b1a83ad4856b1809ef7,
+            0x2aa46d04f1238c646746e8df5bd0cf9dbecafd57d5de4f743fdb593379ff138,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x100148238e0ea61c5b6b81fba32193d55597904d4b1220500edcac81ad52f68c,
+            0x8243c72e44e0114151fd9b102eaaa569fad5df40df83a1b52accee13fe49fab,
+            0x156b1e5836f0f59be75c7f198a5d153ca30f0b79882036489937fa8c3b6d8323,
+            0x2c0e264b43ed6c4b0c36fef6aaf1aaed9091f35a830550ac4364d602bc9e9e4a,
+            0x534b4de30df58163e970ffa0ecef0738a9fec8c0ec4e7d9d15a666a16f45c07,
+            0x4dfc3e86105970cac41059c73d5f2ce55b16f40cf638a85521ff270c6e11e29,
+            0x183720d9443c6a59364afe5312050095e335b211598478c7b005249e89ced914,
+            0x1dd461fcefb3549ba9a151df4013b323b1183ebdf913126b53003e86c08d99ef,
+            0x2656efdbacd1d58ceac9a0e79d35044753ff9b7f6dedbbc6d8a48fa48028fb5d,
+            0x2ef319b13362ac4e82896c082a6fd4a64b9cb25efe1e0f5068deb6fddf95d02d,
+            0x13e976b891949cb18b46fe1130d4fa1b16342e954779fdaf98258da7192b9c91,
+            0x8c80492d0cc609e181c3f9d8e2da90f68390facc7e468d29d49ad9257f55c28,
+            0x1aa3c7c7a08d082afa7fb91c6f1c9f989b98f9619b56dc62c7ff1e18c6b72c86,
+            0x1d115ed240331ec2adbd0a398df0d4dbbbf2f6392bdb03085e088d60d7f02ba9,
+            0x1444e0fd467ba09ef9c1c6ce9a80b4e7be755d0e9f81a90f74f0ab7d110015da,
+            0x3ce99d4bd9007aff4e13c2679d14a31d6467b32827e68f234314d3013266217,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1129b914cee489016fc3ff8d20e2be4c9abc873041ba82bb7e7781e976961b24,
+            0x21dbd50af59bdf352310dc018015a605fe2dfe0e8e65ce1feb72f2972b985640,
+            0x25a5291beb01d9f13ed31c588755e56e5e6158b2f46341c86eddd86aecd52d7f,
+            0x8de172c56eebbffb029ee873bff13163cb2d06caa46108bae1dbb2c40d22216,
+            0x1dd2d55f238308639169dba6066e0922ad620678106ac7a1091b7f7ae0d3090,
+            0x189191a64c9e4d960a7f281e378669034e779be7ac0cdc6e4fee4da0659b04ff,
+            0x141fd736c823aff77ac2f28632342c25d14a649b026ef03f36961bf4eb85d4bb,
+            0x113a24d1bc9d10e47f90f308781ddcc9b9249d95bbacd113d88d5a6ea33721b2,
+            0x8f0b7b38b133684b73d01fc731f895bcb30ea14364715ea92920501722d81a2,
+            0x1bf14ce82aaffec31f46bdce8d22f3baff0f96b8bfa00499581fad99e61f6076,
+            0x14b7be33a41e00d0333a0917a729539fdb90ba42f12451c63de66fd411f6e379,
+            0x2107e9e2811d6ac968dfadd3ae015e3f71f87d0c5d5c5ce4f9f7c66bc92a3931,
+            0x9e1397c5f39d763040b82fc2be1a64262cd5a4d9f32491ada436ce437bcfbea,
+            0x1d1a01986546a0812d3a4dae34ab33abe9cedf2060a4f654c7cb05d1298a03cf,
+            0xda3f22ff498a9cfef80f63e2c92dbd95928e85463777018a0d3204d1e50f38,
+            0x25b74b90af9818fe0fd8fbf33e539dc037a45ad9f433bac8dd3717b64600b622,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0xf3d58dc69226c994ada311ddd4f11174b51c490cf3fdd93047540be437cfc8c,
+            0x1d948e7f1fa4705b5ae3e5f030a59ef966fa374f1d6bb87fb74d57b76f2b61fc,
+            0x224176ed89ccb581b45f6afac435d9b2fdf08a0f2622a5a20c2ba4ca8738fbcf,
+            0xf5cfe8147eeb9451b966cc087d2a9927396a83cd407d7f22afbea6ed6313ad5,
+            0x1b73e95446d5beaad0bb2c324a27dd0fdc5445ea8a553289a88cd540a7a8a633,
+            0x1b0f4b75472ab2e5ad4482742bcedf3b45d90177dd52680bc781786ea3e96be3,
+            0x2e189fd270377427f98adf8a3f49917ebddffe7716ad08db78761da20e671fa,
+            0x7c0a2036465c336f0fc397665c86a87ca0173ee19696b8fe7e6075283e5f0fe,
+            0x2fb5497d60412c8bbc14b961d96bcd9d2cf82a25da250d7860453dc0c36d3760,
+            0x25aa324c8bdacb11e81d612e258814beb13dd01a7de07d57b721a6c83101233a,
+            0x29266b9fc1cca7e41d3c58443362cce77c81557f56e3b2a9a0e3165f38fb28dd,
+            0x1557e3cbcfa7fa080014f6ceadf2ddc22cc1c6debade1eb605d0cc2755268dd8,
+            0x28ad3d8ba97896df26b3281b73de59d9d3a055cf84e24bf4b7cfca4a6f18e1c,
+            0x27692be22a3100758923b4b09be3c0e1ca34c62eb2875d4ca2e95199ef57e13f,
+            0x26cb523869e976355b8b2ead6493c3b1af3b24b9f619648976a925dbfb9c2520,
+            0x2a943b5d83171ed1ba5b2d0151f770d05cf117e28c8a2d0bd07901124b7a78ec,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x24917421c163008e468b59990ce9c9659723c7a143eeddf00b22bea911a23faf,
+            0x20347f9b860c7318d8abb5924973a6032790ed146dd51c2b175890e67c7c14eb,
+            0xc7b4b3d63f3985e07d15f46bff54c7f1382c7fcead2fc4d2732369ecf62312a,
+            0x16c3c15bfb090d3c32b6783b8f35b56bf1ed17cafab462123eb872e18f40bc84,
+            0xf4bf0d79b3a4f157a77cb759e8c3a950c2bf08d3b37e6e2252feda118dfeb6c,
+            0x207bc2820e9268ac4529e9415d7094f6c4a3dd32c21fb6f34a6721806e60a66e,
+            0x46d6e4942fc73df5a5c24e50a1390fcd3971f81416ec30338d988421d471e62,
+            0x25d86cb7ab23b7d7829d52fb3d3c2dc42ecb745bc74e6e29c00faf2eceda60e6,
+            0x291e27d656977488568245f7d60e5d31f7993b3530b6e7a5d2ecc5ed8bfcab9e,
+            0xdde8d80231232c0283b7ad84aa356bbf7a3e7605dba21f29b53fd949cd378cd,
+            0x16b9bca3f4757ee5bd884c08642d294730db13f90182970a962c956d5ded06bc,
+            0x148e1434a77d59aafd26c76dfcd0d9dd58709b43c99173ceae6ddc899e39d810,
+            0x23e38e3fa1713fb566e00717c0a22fe7e056067f7f455cf67c239fed5313c484,
+            0xecb380bf60702c006a2e0b413bb060a7dafdcf4d8c736483da381315d128380,
+            0x1504e0be27d971001c9c52f6ddabd8839fbf3cda3a42dc01c201788063ece2ad,
+            0x204cd425d4fe74aa1fc3966950209bd6e9966aa7df1f515e5ff4eb504623704c,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x26b0354a46c4b6f840abef50577ae0160c403ac2ae154cc44dd1b3ef95cc9a32,
+            0x76acba1cd92e4c02cec66b997f2136e03c86a5099967b8d2d6c3fa51ce470a6,
+            0x1b9f835efd362eced66b1b4feb359a5a292e5179eca20536bc05fcf71ce8b0cf,
+            0x1554b5740239a036650e957cf54880a05ffda13bd4a40b9946d1454b6e5ee619,
+            0x2337f0f2350dcf2d2c4cb2f2e3c8cbfe8eac44b18a4e7df6ab9659c6d3bd51f8,
+            0x2f70347a3e263a829f4c9524c0528c57aad8197d74f498c96618b82d6e38c750,
+            0x2ae047c01e6b790967c9af15fe9700bf12a32cb4742c75ec4f2264355251b598,
+            0x12bdad753525224488f0df2411e45b18e6d99df86b64ee5c2e1eaaa26b6b1165,
+            0x7ed14a9dec030c79ab897464c9c31e89ac5d398e5fc2330ebd747dc62704e80,
+            0x2586c2f08326503a7ccc396ada19284c6381f5402a1ddee59134036c6f9f4c85,
+            0xe28de3e58815af816aa0e449cb6b0b68151fc3b74c8844b0433fb556e13bf35,
+            0x15ed9ae17b48708404c20e204de218462f5c1de7a672c0400b1a4a97d82be2fc,
+            0x2897a3c61ab7e1096d59db7d062d3509dbbe5288e8503eb723a783668f39363e,
+            0x19382e0101202bcff4c8186a39e4ced12ada7adcbc0d3d535a37fd8e4e65d6a8,
+            0x1dccf64cf1043efc8ff525df9a110883db70b13bb644c6567c0ed56006979547,
+            0x14f753284093a5bc753e6e4516dc5f1856c363cde9ecc95745dde82f8f475dfe,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x47ce0768d3b94501b69470f61a3279af86cceda48efc0aeb4f755ce355a8c06,
+            0xa838da94e6aa2b7e3c8d24fbbd1abf9fe09cda8242afff691d57aff64a307c7,
+            0x2ccf7207714857e1b96f90a10f6662a0a161fef6f8554acffb454b475cad2249,
+            0x2c964702e998844a760e735d74ec7fc17e793f656653128910e08a1c48b27399,
+            0x26c73fcc286358f8a8c45940e32da21acecd2723a3e6c00003b875972e7e4215,
+            0x2503bb71691693c6cd6c045d3f40b4cd2885a71adf5348642d80b44b4274164b,
+            0x21abb0f3aa09de0569e24a9adf7863bd965ce656e4ee30611d0f063c1b6b1d49,
+            0x1e6c18a3ca281852b9738876128c7d16d2fd27789043907cd624471d1356d10c,
+            0xbb323797079be60788e8c257caa1e1e9b52b8f58128eb49dfd8d7595fa8275c,
+            0x16ed4d5164745fdda2328ab28d0ef0350a3bb50589d72655d0e0d5a8f1dbab81,
+            0x1719e6626ea03d94441eddcffb00dc8e76767224986c45f5f8bf746f72e33805,
+            0x20dd2444d1b30a7e45a076776b4366f04e9c5d1b32a43b260d706f646a098db7,
+            0x2276006ca87d973c1f5841a3b63aa9e6a4f8446a8a0ee03e068fda23a8a2e0b1,
+            0x2d3e7d6feeaad7f3c8700e6293a0d896028d4149d57c219935463621fa77998e,
+            0x26f15d4ba4736c73750ddbff4a7d9865f06d5676e449e9d249d3dc9ea62053c1,
+            0x3636803242973ab91fef85aa46df13cba4ac9f6537aa3730c0da88b9d05c751,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2ef01bca238ea43551e5857e412427af1daae81b8d9aa0c33bf392bb9e71f123,
+            0x3030333648057d1d46a7a3973031a86637d6cdec3559bc12fa3bec6c0aab01cc,
+            0x24dce91bc3df505f0593715987d3e6bab8f1847e5eea91341a9d1e83bfc39abe,
+            0x27a2aa95ce7bd870fda385fc945d76269a9cb6d64b85f943430c796311d03868,
+            0xf32e1ed6656688b400c42da52ffa8fac2d25ee877612e565f9271c1cdb216e,
+            0xd69d7d99a58af860357adcbab763a96d048806bb1b3352c3ddcc0795e6bfc0f,
+            0xfca01158c0aecddc404d7561a6d4ee7c6e7baf54eef93f1b4c72bd9468d8140,
+            0x24f65dd1622f5993f172c7a803a71af6d9936a45fcf2f11c65a2291693c409c0,
+            0x23b6c1c4a9697834526084cc56e8b53ab3ccb20e06ed7bd94e752cae13e04650,
+            0x6b0b0674f9e70ca31b8658df5a918b6aa90ee4da8272d7ad50109ab73af2372,
+            0x119ea3133debe120feb5b0ff2128b745ade6329c228d8c93ef9ecac933de75bb,
+            0x28fe0921f3e250bd0d74df9669ece211330111bcda65ff19fe8bd02779da7686,
+            0x121bc322c37b3a84cfa33407bca08421c76577f4ed5009151ee61de9538906f0,
+            0xc6c6d133c64df4a3f148d03064ab681f6754192023f96e5c660181bf6708e7a,
+            0x1f357b000c8ec106142c05d7fcb45bee3ca8602aceed83c3254d1596854d8e9c,
+            0x2c635fbb8a475d22cc9388f33298ca3286d55e529d8167d036cc97e28b5c1109,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1416e46669e99f6376ed9f1b60b4c1cbe2c13f36ac1a0961b28c0a4ded622be,
+            0x83b993a01c06914fae37498067d1cc7575d4d6692e905a76c01012829848e35,
+            0x7d66eff962ec6ddaeb23a84cb8fc53fb2435fb0779fdc6de042af8cbf653e,
+            0x243493ca2e9aefca93b6f729cd48e89c5b6977dc8b9f128e80f2181a0c9321f9,
+            0x25315cd8d5b5f0935df3ad290e18c8fbb1aa8a200af1b3b7acb784f2b1eb65f4,
+            0x219e9f27376ebda36a9da6a406a6c2346e6db6c35e36390500ffbdd24c754013,
+            0x2784f770d363c088139614dcafe4e82fec4aff60cbb9420b2defa1e5ceaf52ff,
+            0x2ef0972f7624a2c71c7339890b350f716c7fc3cb884c48df73788cb38e8efe3d,
+            0x2638005f1bfa951f04d3e6967a19ba68e797261d015fb0b4a200084da0520420,
+            0x19952bfc2b15a1b7a44e59a4f007076a56aa61c9cb4fec45f42301ef9157a095,
+            0x21bfebd7f0dbfa952f62f95d4475c079f623f56f67ec13f29e51fea4b142befd,
+            0xabe0cbbdad752e9c30c665546f1b68cdd2d556f659c98c9d0c4048cbf0ba4d4,
+            0x20c4f2c291c5f0b15e54fad44d549bdfa06e8405141d07446ecea299bded58d4,
+            0xc703a5af22bea77a163ee98e379877fc276a2e60a134bfa6b3e0f3674aad830,
+            0x23898a43fb970529f4c12bd16e98f891aed64fcb59738bd5c2ef1d7f5b9bd4a7,
+            0x27de205e3b4f798811873af0dc39f91c449bae168ea2b2ca268f0fff421969d,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x34e0217aaa3133ffb88fd09bad59e44d8f0e74e1a64c86f3e9aa4587000464d,
+            0xf0d2954a3425d4ef6291aeeca8d1e1927250f8e566688bf01f77206b6a0e0da,
+            0x38ae6c953b05fde8ec1997151d62106c38561a6563b7c5c42c3ca3f254ebba8,
+            0x129dae3e6abc9b3eef8419054977e8ebb35956b5da4731f87a1558b93d5b676a,
+            0x43331ce5bf13e212c36bb6028ea5edc909d6807630483960ffd1e472333de8a,
+            0x6edd2bca6596515c7bfa7f82c123947366efc923072442cd0d6cb3cb95b6590,
+            0x218d39e5cb24a98ff778833ec9cc9c97154a2f0dcf576e36841e61f2a9d53c10,
+            0x7babdb5f969df1056dcd1a4d25ecdaab931bdcd410f51443221f43ee9ad60d7,
+            0x51f51c6edca7ad20f95cbd07ce9c5c51918dd6639ecb58e2db44f9da92ac45b,
+            0x18d0cb9110ed2c13ca697c51731265461aa40cbff3eec69770c471bfab8547b5,
+            0x151c0d100750fd3fc64ac7ca148c41bf2634c161746e664b6403e1d5ff99edb6,
+            0x1badce073db9156bc6bc0b05a5f9ad32826ff80c20dbb90991c59b84f1887631,
+            0x1d09611b11f20c357da69b64b7f235ea79741583cf177a43141caee3928bc88a,
+            0x15903ccf8bd20aaf86dc7a0c1919a20b2beefa10ee9373ba62a75da5db50cd54,
+            0xa3ed89f4229594227e8d35c0f775d81daef83cf50f6daf6c92584dbc86bbd7f,
+            0x15c5a6fdd9b6ba06ec2cdeb9f465fb29a83a9345daed49e0c27064b2a745f832,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x29c47b21c3c1399dcde464739cd972c2ae7dd8511ef4dc4ab062de40904cd041,
+            0x5d20c3e118f7e163803874435eb8c4f939fad669606a0f8823155b46636b40d,
+            0x2a8adf7b64ebaf6bbae4363b8de139b047e49cc258d86927cdb17f64d7a76365,
+            0xcfab49644bb24735309134d8f1160397b61c23766c13afa2f67350700ea184c,
+            0x978c1e24a56e9f48e04a00ebacf84a971bf524a94ff82c9fa6cf2a4145ea323,
+            0x1e7feb08ad0759f1632751fda2c80347296a181f33553bfd11c84e3b99e4dca1,
+            0x1636f1c4c6be9b16647fd56e418b432d81dee2c09c00d14df526a491d03df083,
+            0x1d0941c7678aa3814c49962f80f06a3b6ff48c4563cb563925c87b621392968f,
+            0x1ba792f0e7770d294979a396e2c55b21baee98d0be48705b32f831f2d09f470d,
+            0x1adfb90be5993e8a8e82466fd94d2142e05c507c38a0095535894369079e2858,
+            0x1701417adcc7a63515f58d3fe4840f96d7b87646be925abf5831c7d9f6839e9a,
+            0x16669c07129defa028d468884eec4825c1852e6ae60f5acc4a7a7754f9383ee,
+            0xc030db661bf66032b9e0abfe88cc482f134b5f39b13e8aa20b540d23a5cb4d6,
+            0x6c29b50030b9f9653c8cfe80928a76e6ba1fe5385109b7e606ef07634d53130,
+            0x158eff715b637ea2e1c4312cfcfc154d3dcae6d2e240826e791dc661d4122a0e,
+            0xb7414bf9dacff0d87b4613d9bb448ef0583f07948cb26d86963b0442a478865,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2fc5816a8a9d54f1397ed6dcc705505ca28a50d608f2d6b0351d133ea65cf8aa,
+            0x24d04d2b53f9f94b51e0300c6bf97e655ab6bb25f790365c64949876fc8e400a,
+            0x12c2d385c706f78b68d132d1677f1c43fe555d3d9bd6622de8dce6a01aed702a,
+            0x2cfc07b04b7ac6bd6ff67cc6d32ace4717cbc56974a70b9e3dda54b1741ce3e,
+            0xdbec9e92d14512f3a95f1bd6eb87e7684fd099d747641e16956e281834fcbde,
+            0x11110cac8dad45362476f50536e03d139076972f5e03db946753ed0034ed3050,
+            0x17be085a196605f2b021add82a2fefe6c062bf2042537e054642c521dda6e462,
+            0x2d30434c0cef5fb5dd60f6b52c01556819bedd08f87f0c191941f95b833853d0,
+            0x297804121986231c72d5f3db2bb23cfc41d9091b7f085eebf0905f59854ad640,
+            0x263cfbe2843370e8f2352bb41b51d59a8f9dd4a39552922021dae9bd777d64f3,
+            0x1ada1b57547ba0b44cec18e94b273c02af369be58ba4ca5dddfc0c54c6d952cd,
+            0x1a022e3c7f181a5af4ca6b68ea1e8636ad7a51eb2e49779fea2abda08058ce2a,
+            0x1a51a742b5e2a8cb02194fe5442fe8160f887d71a8c624097cc751e6fc9e106c,
+            0x33a3c4fb2a336862528fe456e4b28417f0cd5b8d702fa598648593cb27ff95b,
+            0x275297e881159b1ff115beb9741fefff245fcebf2267fb7788bcfdb710ee11ec,
+            0xc4330cf0545fe0d4d56dcebff69cc7564232b0ba94e58e879f9a838fa43b50d,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x7b613d8cbe7c7e104e3144d883270530e6b3190606a2df92791fee2f3f0db30,
+            0x328bb8607f89952c7a0e199a914abfe679afd366f57160513708a57b0bc0665,
+            0x2797d2a42bf2c3f860818f92783ee5b77ea5c8ef3ac3433a4ba8f8934fe40e7f,
+            0x233e6f522a14ca24067c5c09affc7b53af6c87776525bb21d9058d01fc106af,
+            0x390562c095c160aa786394027404bbd6a3882cc1118cc8ed82307c6e8d80084,
+            0x17106e1ac0cfcf36e9d75f64a39807c812cc85b77e3c5ada491629f71d978f6e,
+            0x1aa28e48122d0a44733a370e5031375a8c9c648cc46dcf3344621e6cd4ca5c76,
+            0x18f6e768b9bcf25d37f90fae8b9a4c5cac181b9b05c6bceb922d50d8444bb79e,
+            0xfa9340f079ddc476b10060bfb852af827ff712c5c9fea03f62d13d0c670d988,
+            0x1db99f295b05ab42a946c2c3a5c73b225ba99ee53dc906eaf360675867efafeb,
+            0x97578aeb43a7d6b1b10240c0a6b9b771d65b7c5a3a5555226e3ce45de3d3477,
+            0x1974c34d88938d66ade5546a726dcba9bd76c31f1b4ee763af03f8d5698f4a87,
+            0xe25a828aaee6f1168bbd9ca2c177973a8f20f4d8bf3aec06a0c24512df222ce,
+            0x2e13ee7394e626ffebeaa09712936f8402400971986556871516f2a0eca9057e,
+            0x20be54787d3e6d7e91de4a052172de99a251cb83be6fad47ec5a56b053717254,
+            0x2019386dbf15958ed2efabc0f81184a6710e0f8239e8932e25827ccaabb750,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1195db45235e0b286717bbb0e7fb7f4bd5f1346a8d6d47dde45513baa490207c,
+            0x257be62b59d6f54c021c27f0c3c0a7ca3222dc5ecfb298bed986f1b6cb74f79,
+            0x2fc61e8c69f1b6a89a698d4bd390f1ad961ef1c979c315fc069d1d3364630829,
+            0x4ed6dd96dd4ba79b9474bfe10517c93ceb5a6dc5b95497a71a38c42c4171dbb,
+            0x10c8d7d4846014d1d37d7aa27311dce9257ea1de1700a7175a03b358f12c0dd1,
+            0x7f833418697f43d68c6792ed1b6a4274500d96c2894313f43d9185129ed01b8,
+            0xaa1fb14156f9db59737b23efdaccc40d8f609b346809f66d96402e5f9a2c102,
+            0x1a3b635b05a022877abf26c5378da756752882d30152a75e75095a4992926de2,
+            0x5ff6852ef2c7807df8c68cc1fb842fe07ef08892e6706f4ccb3059f1d80714c,
+            0x18e93ae4b4c092b271ce21881f133bb369d09e3726967ceb0484698a6cb02374,
+            0x5f1d71fc99fd6e8dd1a4ff1c6fb4d16aad3445b2c5b2698a8ca995b3ec32fdd,
+            0x260b2c665cf863248a5c9a03fc5ec713c1d32dd3bb17f3a6dba7af1690317514,
+            0x199dc26831d1b81e333ea797e6aa2e76ea2e6cfdd888393682076ce77fbd4cf3,
+            0x1fc7841c3762549185cf197f765c50f4da97358c40cb69cf74940eeb165417e8,
+            0x3dd8db3c33075dc724dab7416f943e45adc39e147443ffcbf3fbed8068089fd,
+            0x1415d87f2ece25dd6da8a9b56a5bdcef4f235a1b676ac4fe0ece8bea54f0d620,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x173e973d92b03e8f7cd54b5dcbd49e5c93046288c5bd8ac95f711e384807a40a,
+            0x1e9e9e8f087fe7eae21b84385017d6306c73ee4dcc5b09efe1f91b9df6396353,
+            0x2cd39e6fda7b0a75926254d1b4bd27ad6018ea559290d2041a6a1cd485026cee,
+            0x2babe32c6ad1c466c0923e89242ff07997ad91281972ca9690ad77806c79f9a8,
+            0x1671e3aefead10c1eab057577cef2d003653275ea183f956583dab5e6717aef6,
+            0x638040b4e068d6330e2073b9042e25763872c4564b413d1d8df3dc5271cde9d,
+            0x13a1be086b1c130fc9b0377bf5f4c7ab4166b34dc1442af15bd9ada0b316489f,
+            0xe92a08c67a64c7e267acf28a048035d8d702bc0e49b7157132781f3f912c04,
+            0x24fcf21bb660a9465b6a50ea1e0ff6c88d463e5c14cc82e7f333bd8cd9e9da57,
+            0x19c3400c22778ad2608cc33d103d7558b909f2bffe1128945021cfa3996b90ce,
+            0x1804ddf73341fab213bd15ac4fb0b38b210038ab3097df363df15449ca092955,
+            0x2d030e104eb695f158216f2d17baf589c6b7eb3174702acffff3459faa369209,
+            0x2ac28b5273536d5520dbc0f2d1ca6225372569f2c1f815eb0d98ea23bde3e0a9,
+            0x132369e44fa5b49f309bdb51e3f76481bc7151112c28ee7c6058d4404d326aab,
+            0x1030d8dd6355ef0e8b3bd213083f0540158a13dc059335b0a68471c1d8f995cf,
+            0x10754be6667d0c88da8d27c8d885c68c2ec53e66879efc8664a313846c8db7f4,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x245fdf24ed7cac6d987a5f1098a3dc2094e8445ea8a34d409caa0de9ee8833ad,
+            0x2ddcd4b1ef28429efb5371343d7c1aa34394b214ba4d3786a72ff4a260f80341,
+            0x9796da1c54e94658988e1e47f2ab2a18fb54bd12c0f69761a11428d2bf8060b,
+            0x2b820079829572e4737fd84b55e00d69b9842681762d614c4cc9f4c83dc7c88a,
+            0x2a2c8f2dd7ed7049029ac58e2483bbc92ca9deb979598179962834099a206d0b,
+            0x2e5131ed99601233301a58544eb5b390adc2aed2f7bb8975f4e3089ba598e03d,
+            0x6f800a70d479c89318ce14ace0c1f7ded913cb3186aa67acc7290b35f941c80,
+            0x848edf27122e8c897ece8ff31c76e8e3da4ec246480e769809bebcdb4680146,
+            0x3032a7d711f11783b0cfa12d0a9bbaff62fb9d75cbe50aa6e684f9285d55840a,
+            0x156bb4b89a15827370ed5326bc516f90e80da2b33bfa976b4c9a26f4c0bcb5d4,
+            0x104b800aad84f2de01925253de1300447944ff027999bf3a113dfe28236e707e,
+            0xee24634e1374e506d3186a10f60315beb8a311ca69d595c0afa0e4dfad5ec22,
+            0x886f6c8618d45654de796ffb0a718eb65e5236deff84adc493e6a49308509bf,
+            0x303f792b77de056334bf4b95c535b224edccc1d65b28e52d569695fe0a86f7e7,
+            0x2ce5f9bdc64ab48b32e5ed411be107b280119255d976673c14ca2e70c76fa68a,
+            0x26f0252f0b0b6f638aa04dab03f6a8fe7875a84fe5c6763aa9443faabd36d6af,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x895eaa7421d5c92db73111875ff0e97d1f1cf13454c8d0ee65ae0c86cb9f0c6,
+            0x5a37e53d3c5dbbf9cd972b637bfb018efcfa1fd5cbe8b5dbf9f37608783392a,
+            0x2151abfa55e801a5dd55f82b711f05b3e61fd9c94dc77201a9e62c89091da8c0,
+            0x1df7040bdf6398bfbc5dc0bcfd52e2cb6acc1e32ea9eec40e1c14a173615a901,
+            0x82d9c0993ae4a12a039c11aad12743c5f5d286c648a89b4342169aa4100b9aa,
+            0x295f9f8fa059d54d4b582213965eabc5ed6f785e4aa71196f6238be2c511bd11,
+            0x11489075194474f063993741279cea5cea810bce027e64ad900225ced81b35e,
+            0xc308adc9b0dea53e1c37e06d0576f4ed39c2aea66bf429ac00575a9105112b0,
+            0x1c8ae9521d6579b43520c3cbcd712b3dfbbd2b1543d1564f7d918c6e330e08a6,
+            0xc69ad644957599bb3eda1d9f831ca67b021b33f6407ff2e56870e7ab3d5a569,
+            0x17de4f74815fb3a0f45728b381e2ddf7c1157e5d65989ebde47f8bcb88f36836,
+            0x1fc13b76344108f12af68f0bc80c99577f09a266368f0e274794a3cf65b48d17,
+            0x2fad04c4a1bf440fe56076df74e5c30a58a6e26fa9da0865bd0374b6ae37f4a2,
+            0x20766bcc7f359bfe765ce87998097a7501d7924730fe7325aacceaa054e2ea5b,
+            0x14eb221ab65d0dbc5edf6a2065188ea9057f935d028f7ed14729ebdd66ed5fd7,
+            0x1cade81c4d562aff84daadd630392b735b948175c064ace958e0c789c9d93bf,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x19b64914374910bacc33326c70be0a8518e71f26b4e1aae5d33fd5dcebbb1f44,
+            0xec087bc39e5058e0c5c1432b20c612537441be0107ed759d3a9468ada975dda,
+            0x25f6ade6e9833696c4dbc19c765ca2ced09f47f0745dfc850efd26e3a8bfc5f6,
+            0x842f674f65a495938dba020f22a476840e0591f179780d72c00153ddef5a9ae,
+            0x24b3232f05be57ef3c4c22af9cc37a73f0ae40289fb0fa880630f7e3d00997aa,
+            0x2f4b230d825a682520ac0b5326d130a24bb89363318961ef5f65391b8e7f6bc3,
+            0xf1644020d8a6c0dde5068f18ab196d348172aadcfd6391c31ff1b54f513509d,
+            0x73fd850ca9561f8a645c9e4af943d372a4b8620b78bbbc357a97d14f531797,
+            0x284f86b9cce13fbb6fd660d8e52cf27f7bf2723a494278f3cb0c3bad0574d104,
+            0x16bee52d1d6d362b9430ccf4d2f1afeafe3572ae4eaa03be6af6f1bcc05de855,
+            0x254cec1178e80740cca318d1b5db37b5dd23fa2c44abb7f1535200618b9ba0c5,
+            0x113069cf767ed4afc61e592e98a63edaef98278c2ce59db109c94ef6dea9cf,
+            0x2829e1532b4fcdb2df9104cc23b3331a1d51c7d0da9b645a4a43dbeaea77d229,
+            0x24a03c0f7b51b6e24a889690a3341f55deacaddafc1ff871af6fd6a76dce8bee,
+            0x24a7c2c124131ab37ed62a0182114a5dce4ab7e62b14ff632703b23a78f391a0,
+            0x19529e943e466da82e6bae8f1750de8620e060306d9df5a9d20a83a4b68fc09c,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x274c0f68f679da53bdcdf9c11393c34ef8fe59cdeeecf859d4ad53069a88789c,
+            0x1c900ca5882b107a3b8a8938140b127cd3ffbf539c9145f385cea5e7dc6978f5,
+            0x55a3264b130bb4316f4503af137f0d964b753ba575456a74581b68c6789df33,
+            0x290033424503055ab2e6b8093a758db0f02dcfc4adaf26a30f467b0e8aa1af13,
+            0x1b415d6ec7893774bf9a598a8496f83a5422861a044211e0d525493f75c7bca1,
+            0x2d5e6a92650786e6ab35f3a62c5689a0288849d1eec7ebf89b9a6df75cdafd39,
+            0x15b1c6c75717d38e94265523f0f6491e22d8b79a791b10b21139f008651e3037,
+            0x1f929349fb5222c4a6f17fde7f0aaca6430b6785cc5f65c3e1b7842c338dc1e3,
+            0x23034bb8b8618de8c8890fc8fee6422147545d11d45e41ed6326b767ff099cba,
+            0x2ab706c6d21e887b5906d4db350e41b176323ed39f88a75b80f1eb2680169f69,
+            0x4c1031dda5e43ef325b33a80e6cd32cb22b16ad324fbd90ccf79c1f7e9ee062,
+            0x1d663d31705eefca25d29b8894223a7daf06bfecf4e8e0bb845682fce0b1a41e,
+            0x18c97bc6dc2ee1c3d66bdad7046019b6d4aba6592823a51ae2a8052824c6e332,
+            0xdde410729932dcaff0490adec752faade582e2eff9d05896da43fac32e1ad3a,
+            0xb12de1270d788dabec1456611485a6841cdfe411a09f80c0e132828568d8eab,
+            0x5194088cb1b0f39c5b1527bd0a3ac4d16c845c2388cd22dee75544eceab640c,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2a2904f92bdc035f347c6fb6df54ac6b482a2642dd8e798f9df0915fcc86872b,
+            0x8bc0f22b597fa12cd8189c5fd0f79b2b10d6c65946b287890dc5f594761d665,
+            0x2bb55a554f9bcc5ea8dbd4d5453e188122c66c507fdd08d0589706c1335619d4,
+            0x2471e91078add335f5c48457785ef1b469484ed697e2e9f80d0fc73852492508,
+            0x2ccf72b7324cbdd4a1b980d883532ef2887c798ef446408e885f8cbd14ac42ac,
+            0x1c3b75aada78c1b204a35386f68e09a8ed700bd88685d0e38cedadfbd88a583d,
+            0x11164ea9623704eafef86bbcfecad592597038fc1b097380effca4502577c733,
+            0x4b961c368270196ac2ada2e66e44a4440905eff5b58341302ceaddfa215f691,
+            0x39dcd1dd3ff8d7fe019dda64104e9bbfa1c60fabd54065c85e727302d8335db,
+            0x90f27feffe276b6c1d77f6a80d2c25680fb854af9ad1be11268064e735060b8,
+            0x202922769a226e1dea3c39d791bf28ec93639c7937eb7be2c10912ee896fd3e2,
+            0x163bb1b115962019e41bd1c7cf0d8783d4baa163dcbf6e25d368c543f9560a5,
+            0x255dd24ea1b49972007c3b74fd98c3ccc682fde58858a2073be4b90b39e57cf8,
+            0x2be5aecc70e89fd7fd3e2683bea0ce600cf42759ec5941f0746f126b11beccdc,
+            0x1584587c91f57bbdc41e85ea3ac8ea67ed261cd8d5014b424a1dc01bac478b91,
+            0x2131be5b4387d226c22bcd102973756cd7ff955452e9eae429107ab244294b14,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x254b0e91bf714a1b45748d756729102fdab89301fc89d029d5537f9226e042f7,
+            0x303c21aa2f173c290af9ea8e0a10f7858ffab7519185843d2049a22946026b11,
+            0x41e6ecfc8a13cdf52f9c21662906f395ae172f944c7575073c0eee9962941f9,
+            0x19eb35e2795098faffef9ef5baca33da9ecf94d5973c0ecd25e6899630af7a76,
+            0x1142d22ec011a94a940fe203deb1997b64f780bf35d06276644f98e48e2c9ff8,
+            0xfddc36dde84e16a5c2f631470943ce31e4be6305bca6e5c753c6186f1059f62,
+            0x5b14ba6526be3dcc17bf7d609a42aac1adfe0f449a3d9374e0c22e26b2c2362,
+            0x16152ab0a00c391d450290ae825cf5ca2769fbbf2e7eb69f8764025f68e9ff5b,
+            0x28cc90877e4cce38fd08c1af95cc3f885a5c5328fa0ee0bc89ca190694d8e484,
+            0x2df5ab9a480bba00072c401baae420c1800155b9f7d1ab9b31e976ad800929d1,
+            0x12640a01d9b60560290065a3fd812afc07a6e795408f988071aeedf22ab75e66,
+            0x1b2792d807f55ebab5f4274d43ccdb9d23c155b8b9f6df8694ecc6f67e20028b,
+            0x16c2ea687479d257e26a655b5c6c27bc1f455eeeac28c3b3ce654bc76cac38f3,
+            0x26da8fd5fc478751e06453b0ecb6cdaabf231a58e603ac4ad14717d70db2f27d,
+            0x14f3a3e34739d7c727b010a5022d9f0f3e035e91db3aa947e3ebe3366eed27c3,
+            0x366141d1115aafb084cfa866c52ef40a5fa57fdc8e06fc2f1e46b967c9c6615,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x15658afd9b2c13d4bc0c637cef9717e943c50f83b67c8676d67d17050494e5cc,
+            0x1f318dc3e277bd895a88dbd9e3c4febd43cdb9064683ffbf1be9e6f9b2a71669,
+            0x141cdd5f2c18d63eec6e82248935eaeac4ef044ee76cb7ef0e9259ab6f93daaa,
+            0xe4b254bc67d3857f499682863a0f95b76e9d5cc9fb7c2c59729db203050299f,
+            0x2cc2b90a7bf9f3663b0f41ede34f60d63a99860760ed6027fe17d4fa9eb1b396,
+            0x2e0819713df7c7a942c08b3ea50add92e39214104120803a5806aad10234abc1,
+            0x24164a433840a28d2615c719c716f2f7c01f7c3854a327da6c5db75097fef1ee,
+            0x272543f2284921391729ae58db1d9db0807629d9211778b0756ea7e4f88297b1,
+            0x194af27987f50ed8730d267dcfd98a9a284a3582cfb7356e3dc46bbca1eeed6a,
+            0x2044ba55f5e44c7069590bd2abfcb2b7b163d47e0e1bf2e2524c0948da4b1a37,
+            0x19d37fca1b67b7ac626349cbf2928b9457863637baa2613b494d9da18cc384f0,
+            0x1230ea231084e3641817b74662caf5732556c3d94a01d209fea1f6777ae6cca1,
+            0x2f924a42d4d9446cb488295883fdadce8debda5ac727901eabf2d8627dc6d698,
+            0x2da745785ae0d3eff1a3281d7537383abfdfba2031a880acd8dabb3388a4ce95,
+            0x72fa635414d1673fab8d057107792b3039c033d924cc0b1530497c2c810428,
+            0x19db329f086a50781b0c6eb2552ba454db2fcbbc125a5ec41ed2c0e840bd6774,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x1ea4f3fe9b4abfce9e655b05c4f64a0849003f9b349bdbf349ea2a249bdc945d,
+            0x23c87854133b5d392742dce58aa01cf376e3983dd939634c4fee6326db21db4c,
+            0xbc4774e1e80349b9a704c01709de843f3b20a75be630d1b6c6555adf3bda042,
+            0x143ffd0adddc79c51edcfac6ffc1aa3d99ebf2d55349df53a54842c945a82f55,
+            0x2b813146b9e70f53e3cb2549a91e68963928c40e02c08729e0fd3f5941b3d602,
+            0x13de9ef153bd22f5063cb42abc061c09eec510e4b694a4e9b9bf6de56cc2f206,
+            0x30015dd143c80d113c290bf94ee9d7b10cbfb93959e846751c3b3ef9f8d07490,
+            0x2515eeb903d6537674e4fb3cee0b3a4c5051ef3cfc1a3d1dd2a25f4ddf96e05a,
+            0x20ec5ec6cb5f91d860925a6341af5cb15fcf4b2694083235ebc7ea78ccf6421f,
+            0x77160d3b99920220fa591a49f79c56a282b6e368cd1419ef09632e869599f14,
+            0x2dc01f61427888cb2d5ae9d8a0499cafc03945dbf111727b1a2cbae73bb41b0d,
+            0x1df3b805da3b583cc8f736372e7b16d3d0407e634b6cb7ebef2b168932194147,
+            0x224a6cb7f4e964e616ca5b0f23c77859232674745d32072096bb9f12131f0075,
+            0x7f74f0de535231775307017a09328c7491bf0fb7ce86ad5fb589594154983fd,
+            0x2816d118f59d3cead1cedf5cc76a1a87829b2d8c1fa10adbb2fd4eebc0373b26,
+            0x1698c0df24945164067e5d0d9b0321a757818a0cbfae969e28c76dc470974440,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2d878d0119485477be8dbf01a3aefa927a230065cefa169e34cdcd8e97efee48,
+            0x2af377e1ffcb6909a07fb9d03937ce4a8fead2190cabda6baebd5943445dc0e4,
+            0x110ffaae8772ac77a0fe26f368484344ff681843ef616c6d73e0dd95d5f1f3e8,
+            0x92cde477438d1a1335b795d5a5ae15d0949877c734a0eca249865ae30a4ce2d,
+            0x2cb1dcc78144adfca1e53dc251c2e4084970c941855ee6a772d30dfbb1a6448b,
+            0x1e80f366933f00562d3facb54015e72fc4cf46897bd71f3f3015bb3f8895231d,
+            0x20c5d9b2e153f4787a765096aa7c1f47f990e810004ee7737c211150c40b79ed,
+            0x12e81ecb7ef55b86893278ce37c429400af30b34c10b0acd786fbd7b25c3469d,
+            0x1cbbeabe0289ed5942f50531a647530f105e72d1f912eb11539d1fc5588ce1f7,
+            0x213c4970760a5882661e0e818f43450b8cf9e02dbd0046f27ea4d66403ed0ee7,
+            0x286f73e14f72495fbb280d713b0161ff695a21091150ee6c9ae96eddf36e212b,
+            0xd64a21cebd1f59801551216c693b181aa963bce18a7f4439f179e7105836296,
+            0x14bb39c836c00f33ea9903dba3d3d434ec33deaec35076eafc1a4c5a01a417c3,
+            0x2ca5b88e6bb11f61e5dcc2a4ef664b49a3801009f1eb74208313b7b04d59edd8,
+            0x2c44af041ac89242a8bd751d96ce0f86eddf8c312e6b3127c53e6017c0d22e77,
+            0x1466d21f848850fbea559a4c76b1a00787f997c1a4a5bd40643036ab684553d7,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x220cecbc247151bc202a81a4573f923bc92a2208b17e1c0bf2dfba0de4fd26da,
+            0xb71d939b546f609ccb189dcbeed82a34d8f2faa2c597a3b3678369a471d817a,
+            0x2cfba88722ad37fda1b7ec9489a96e09e88bbf6649c8b7014bdde34ef18a64e0,
+            0xd0debc0f0d5dcdf74f2192da068f87631213a52aaf59eada0bd59bb99ba9510,
+            0x1d202504d57a61c4cd6bf007e478d9588d8e6585ebc602227379aaf25bbf6ad7,
+            0x251253367a3e28a691d3b6fff1209f6cf0e03736928725dea0f9f0824ae70dc2,
+            0x260c55e9c06f653d9202d03f1c184fb70df2f937ad157719685863e4338fb4be,
+            0x200b2246239844344cce8854c24c9a9b14e438de6a3ea445151882f23168fd20,
+            0x2e3e47be40c7216d9db75470bd8193c3558ba3c61c552bc56dab2713af62506c,
+            0x2784c2b142bf3e8639e090358a1a3c81e25f23edcab18001514c617cd0918a5c,
+            0x125de24f4fbc6e879b4039af38a1d041e6c38a270b3b9502e10c09f149445d66,
+            0x29740adacf9d3689e443639c25e367b23d07d690c9ea8da6e12fa6443502f903,
+            0x2bb9d36c36a107db72deb4262776967926f923df9c96cf07708d5659cc04ac81,
+            0xb3d9827d898e83333c83c65818f7fc1761fcf632d1b5f03ee95085b518dfb67,
+            0x10a6e860715f76969d739bd3c393f1af2c6d27f3f8c21e101dc8cf7a515eef7e,
+            0x2d8b0a8bf894b7d607d9a49dc6f8725431f69ef0541debd9a41ccec4b7c1853e,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2f127fbd7f50d13e1ed144760d37a375a507ac1f0475fd1fa1cab401ecafc7fb,
+            0x1577d27a4a8983d54a364994db2232806dc6a3f1ae005960adbcb4352a88b9e2,
+            0x52914cca13bf1c8dd7b8ae8329393ccb24dcbb32c4625ea2ba6cf935be4f231,
+            0x3ae3cb86c125ba7e22c68fc612f2928a961ba4967a5afc661ed2c32de93fd30,
+            0x297797def82244ac873c64c1e3b0586725adff324eeb9b15a9b476823e6179e1,
+            0x124a7a8c6e44e7135b58fc2b76062171b5054af0def6044d99637adfdb5b403,
+            0x1122cd468ae5a811791bbfd990f5ef430eb1e1f1c6f7469e5746db7ec0426892,
+            0x2409be076f6bbfe87a660f865fe5aeb4abf064c12bdada933eed7824ba271cdf,
+            0x300cab922f89292915e01a78def7ae323501694f122737b9ec6739f123278b3b,
+            0xd743547bd321fbd1b27ebfc7d52797b2f97323d25f1a374afec19a1630ab63b,
+            0x9563550bdacc55218984e8413a1226c22b38c12d69ac16bf6e3f952a787a504,
+            0x1985c8553ee8e78bd1c65b3f375fe99cb0c14d60e69fc6d205cc54bd173f5204,
+            0x1bd7b38a27edbf115143764d25bdac7e921e83b29964101b494f8075a7800763,
+            0x2766850751254f44f4e93db5621839bf0eced728a6d2b8cff05b0fcda945e,
+            0x135b92c76b52af013119fdf43e9ff79cb40208b2c78cccd727781ff1f456039e,
+            0x19da226a03cebea345c9a56cf3b4c7e6980d613471b97894a7d5fed6f3e1c743,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x92f4acca2e0ede5ba901916da9e1f67bf4458f8495eea238d17332da63aa71a,
+            0x1641d2d820f16a7e3f48def116b6cd078de47aeb782d8295c5f505d89a9e4ba,
+            0x85201a2d77102c3d0c63353013c47c2adea146120e8d6b3e2319d8e63ba0cca,
+            0xa53d758d0108ebf22dace7bbbb70afa26f400485dee9e4e7f4f7ab7d9299677,
+            0x262d9423cd20852bc68c46fe5eae59a81d1d814a66a638c8c00127fe2dd98761,
+            0x2ade8678e1c4e5a88001f70873e9c28bb8b86bc77c1712731057b410468c8f30,
+            0xee8ff3fc24bcd3063e995a4cbcd34f46142c9f3abff0f8e46a86795b5b46552,
+            0x2b825f9cd4585ef46a5da502209c12464c824adfb18032718bb37e4738cb3292,
+            0x1ac8101da6ddec552238fcff3932ff2eb40ba38ed0c39eb5903e3adccff791d,
+            0x1ab95f20ef0daa5ceb85f821413b046e9fb8a70b61e77f8f5469711f508f178f,
+            0x580d8b79189de04500aa5749909874f8b5968c9204d6511e05ba1a3953362c,
+            0x275875a979f31b1c8db47f6dba4c553c8732aa37c4c74d7fe9f979274dc27c95,
+            0x13d84732bb3b9bc97162533644a7515d91f08d970584510db56caba62dfa0d66,
+            0x4d47f94ed591c3969fee09e23f392dcd0831126d621ff5a07784bbb5178e876,
+            0x268be50015a5f4676f202ecef15e094130bab5822d63d777374c8a0b9f4f3832,
+            0xc44a75d5020d4aed139ad7294f27763391f2be6bd3343691ea6e122c4356fcb,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x212e7e2ecfce78922708fcaf276bbbded3c0e2d8804d66a13fa020749c48ecc0,
+            0x158fa860b8267b4011780eeb782c4d2b878ae2615e317b798961be28a7ca2462,
+            0x1def7622e54639fd40813cf1bf8162198af19e07d88a0d42d436368745e3cca6,
+            0x145ad4994d42ca69669e4c78ef8db06461047f4976dbc5ad4a6cf2c3ff78bf57,
+            0x197d0463b10a21649f25670cdd2504ba58621ab912b643293b32a515f50afdfc,
+            0x23398d180006069a68c7742caf4c669b87742b603d5ec75c13d2a835103a0fd4,
+            0x1e0258bd63687d7b17c4fa3789f9fd82108a3d38ed4458e50a071c4b622866c8,
+            0x423f6744b5b95af35bb9caa720088b05e7fe89176569010e96792e0fd06a28c,
+            0xc50436db6d99e5a8933aef29ac83fa2817395c577d0ba3e0152fd383542088a,
+            0x10a22724b783a4ed75e92202a6121ad76eec88c3f6b6d2b0cd5a2f829d7caa37,
+            0xf49f1ad9de4f057eb3acadbe2279d617384c0f594503c616c8a1f7c05fcc886,
+            0x2141c09b30eaac9f355f49e98905435476bfa52fa5339ea30fc48beabece0f4b,
+            0x15c1c2b59c45dfc274c111fbcc2b79bd7440d738d0b433518ad3c8ce8d064ed,
+            0x1db3bd1d64fe08c2dae2ddaddc2c339ca0402bec8b41b74d74998aabfdfb7bfc,
+            0x29a5a2015c3c31790000852191471c62442721881310f01e2fb0b92157a6adaf,
+            0xc8dc01d3f82d41bd600fd0759bfe0aa674a0b7d089b0ed0ea9127fd0847832,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2a824ce1fd2a8c476123e3a989bf2d6709db1ae25b6003b35f4e9a63b414a58,
+            0x12ebc9623cf8edf6e519f0b679939b74b2e4b4097992d2ed382afa7dc08b484f,
+            0x16be2e58e7c791d1a9edeb27d648d697ac592d085c504517cac06dcccc9b80b9,
+            0x11f10e1bbfb29ef8257b3f13add23550576bae71f723613ffadbda16f76e67de,
+            0x1ad4858514fea633d11ef8b8460a55cbbff262b90a7704fc2ae9f4de51d43328,
+            0x215f4b249b5c5e65fabe4b485656a746d564d4451568c1949d28e35624cd5d60,
+            0x1fbad1d2ea18f2f77723b3dcf4acde26751b05615c0af9d607481ae4155b0b31,
+            0x21662871d695f76be370b37b3214a511fa6a186c5c856af4f830950ca601a9e0,
+            0x23ef880efe39676ca81b90ff6258371415feffe1514a33fb3b944360cebab527,
+            0x2821c241fcaebd3a0039501eb930cf9a84760a177be827540ba0f3c7aec6e354,
+            0x146be2228a62f0b2678d113c1e9bc68ec984fbc98358441882c3223c5d08ddac,
+            0xb88bf45643cca07b10d4c2d229d9f4f8186e5da1b4a7921bdb81082d525ff22,
+            0x8fc9cbeac386e14a1121a09f0ba01977c6a4b444528bf675ffa538229fd0b1e,
+            0x1b50431a74a6fbb3653b07cb93b41b31f4b8e8f0069132630d85d6247c754a05,
+            0x1e406be857f7f834e34e4366a64203a4587e3d15e3fb68fce7cd1648bf281d9b,
+            0x148eba772251ed3515118d4b1cd35d1dad67cb449e93053aeedf6c90725deec4,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2e04360710f57315981909dd928e62c44c44034647842dfa31526f83f4e02671,
+            0x2aafcfc0a678286f879baff9f360018f642f5dc0fcdd24efede6f42ab41f3876,
+            0xc056d71fbe0367362ee12d47779dbac6784d03b9effcfdeb97b91c57f65e433,
+            0x115524aab9917d448fef5342d3773f10c7bc33b0fe015fc39851bb6afb542fd7,
+            0x117e6ade5e05bc5efbd21dd42adbec70159c427bdabafa5df3bafe8d48240958,
+            0x381334a0ddf5db66871f8bd943e4a54dfd1f9b7d13c52944fa0ff2562250fc8,
+            0x43e8c4009abbada6a3350bee3e92556368245a5aac0c1b52f2338e1ce1121c4,
+            0x2e88167d899544487a1cff38e196dc25b3b8ebd01a2289b382c965e11128cb7c,
+            0x1c308d8fbd04e1e349b4e0ce629b3fbac322460faa3a3731112d44c3a4db27ae,
+            0x34ef7e4e0ac0d3d85f4adb5bef214c96512accc1c0f3a11470b493d4a6e7946,
+            0x2b6f7ec4e66fade014011c277952b270953966e9fc9def4bcd21052f62315a76,
+            0x2a8510585ae4c162b269375af5bf36d48824b1cd4d323125f061dc90f06fe318,
+            0x19008b99b3e1da588b1094f3110f9032354d1aaf9c93ca9f1dd0010f974c3fde,
+            0x2560926db4543ac9b3ec4ad64b12021d232944ba8ddc47bdc494f5ba051f65e3,
+            0x29ccea21d8edecf6359058c36019960b8e0cd6e0878f835879477fa3ba09965,
+            0x22200c2de87d7552604e1ecc47c639ec983525fe8484a3d24655d5dec1a4ba33,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2ad7a0d2da92e10ea6eb68264ba502da9a0a5b35bab9699cbc29fd8fe2e30ab1,
+            0x20590023505117aecc066d41c1adbd5ad4cbf0e9b8dfeaf9f9e8799f07534408,
+            0x222c46e262ca50113017fcf937c68bc5a2ce66216ece4254ac3d07fdacbff44d,
+            0x18e7420a44ea5b1e13f4779818b97a2081be214baeb62671e0dae86c4023ae13,
+            0x22ea7ca068c59b65cc056374a848ac65417a6f02d8caa04407d1394ea1ba8256,
+            0xd3a07b74e65318c9e1879c337057cc712c0f533ba49c1c626d1b7ab155936db,
+            0x61d5292ac1d8dc58ab73a0a48f6f631262c6601fb7c0b48c1a16452b546db6d,
+            0x5833012960b055133c9ba572828b91414cd7ba31d68ef46f5f76078c3ca1841,
+            0x2f2764c49d1bc1427e519f7690e301a620a62a89bd44dd766d6ca181d02eb406,
+            0xb8a8d7bade0db2c62bb09b73bf7444c087ff5e82ef4df25cd0f9ecaa12bfff9,
+            0x1bd2b4b1504d8c446a5125fa97754b345cce5966a6e0ece3586933510071283c,
+            0x87c0b8b7b9ed1a7f917066f04927482b71b00120114f6eb57c272cb26ab0ab0,
+            0x20fd707a8cc61d2a031709dab4ae58bf5032a09b570e7497c3415596d3d5fd24,
+            0x1a33b2e800ae297e35eeaf4e3bd055dc56e533f4441bb24bfd130b924d71cf72,
+            0x18415cd52a959280d64154df2c538469ce854f7561e19b7d05235c9fa478ce0c,
+            0x2e6a310ed3f24d835969e401ff1df8540801ab6fafa90e70e50a8230f334ae66,
+            0x190f922d97c8a7dcf0a142a3be27749d1c64bc22f1c556aaa24925d158cac56,
+            0x2fc4ba3b1f7871a2df1a801b29d1eb494e3a4d072b6638da905d5fceefd93c51,
+            0x1162c765b187e20f079a417abec80c369b6e1efebdd9a6bad7577c1722b597b,
+            0x9a3571080ab89c41d2c53279c9ab9ced52efb9cd1526d24dd58b31771a75606,
+            0x2fdf9f81c2ad998f2229e64e084f9149ea3f0948cd928136086120b68ae69651,
+            0x178e83d7f2f9ed92d3d783287f25fe8d0d28bef0cbf2315ca03da314aaeb94bf,
+            0x278d681f603da186319befa5d2c5567a9fb52eed6061787cefa92b27c28a64ee,
+            0x108fd8bc50dcc43af4d73686abf8fd70b42245c1af2edcf11090784a24aa5fb9,
+            0x4ff765c30d4e035bcfbc196c646541fa1d27c05d5d087e01c03ef11224b78f3,
+            0x607cd8ff9b889773c9eb68b8a4366469d470cd7c6004106caae95c10c424419,
+            0x1da524cff60b64856dc1f5dde0ff62da7b182da26908f6ba6e590adebf91b40c,
+            0x22f33eaee3c481e65801b761a72832908f066fe21dab5fa5ec1d4c6e99dd6dfc,
+            0x75f84e9c719bb8de8e61083290daff19aaa4337454e5ba804257787470f2f54,
+            0x2084be9a57e9adb80303a8dcaffd4bb77adb6815168b36a1d363b38425437135,
+            0xb303449f1bf4b92d2cbc26ab34b4215b6dd7af010747a705b2a6e3398882922,
+            0xc099bc68243537203f97254f08dfb7efc09de8f96d72f3b3e0aaded45e18b4a,
+            0x1c5fd9060d4e0d999264429a5004c165570bd1675b09f977708b1ca48e616388
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_10_config() -> PoseidonConfig<680, 100> {
+pub fn x5_10_config() -> PoseidonConfig<10, 140, 1140> {
     config(
         10,
         8,
         60,
         alpha(),
-        [6377232663526537440095439257883018477761342422116697881186123375221738885878,851539971462439380385862352460596759101811723695394639617127852578681769809,8777577262325190174206575699458733195047013200879424709893142671840513604890,21694543997668766291509756109744969193435163886467863962355853609369758783238,9577278996811393500051721677710083593799044422389686435650597107832854019185,16323954252044716897246121150114593642230197187021287621193086593549237094775,9789909425016820105251161906130605326280235056822272235912508431951118212950,5766700650277227528545902607164112169119010038912902265869378685414299620760,14342521005374081251816746055115831251291272287569749723238975882435091047876,2566050045458470252423704003188705777658084864238473334290159653618543192811,8762700051029310248153110133778709519032029454737126719215892745208105815416,4708553466520767412303631379034292236924119642035476122997253385705160556618,4755252554118675759917549980023743559070421272488077422007409392838436797712,8781462767081720534606018702554359272062136386754094559457527802951016005606,19167810216492792969016670752653089791475857662598893252819620255611011677188,12379801295054424513880366937656969081677178004556540562031393564676230427743,3873349522143254287251699452075145107916086554326675869006906246349942638560,1683302064923931554193379270562867202085645938091131834974486624990867609624,2777362700160137801933468204963311934247500177582714816722898763176642740860,5330041075666088752029210636784758218847391095319460299231210692948196701638,11849341704739004206642161112350419905150271791787570525216826204427280723792,7477184099861050355308565098520563835117942875101546634259876195229073147282,18811741129290507103385501216699521500514849038287903802256059864942452310117,15644162092778325718506673614750051639809307056147336506838023349115605106787,15072682042494620166496832302000289519302436589952610199010633012972669445593,7385535266916101728534366006042662339391797772494836337087929961280561819695,10606300178546340442574451452231017670874690381506662581848460294140286741651,343808333592012682122858022517390819973432303579818622412786360520154826142,6686378289544833739489172513893542192299224296746579469451376125664696638046,9325668720082019512834072623751272154060473105966456255302021143714657867878,13237356616132921941407245964289360960304194019926733744472216846697663447262,1723892942664599421365079138681309575413323508685958773158319650163306910931,6845174279248890961319599668687600484787455619619716546069389087383603254137,14429592766972645051919899517480716657546426049902884218808698177731678278944,2012555589304829161260427679955782678928810146332132910441113793264100264511,15162287124358358727307007568219331690174000191414576263088727973180750593247,6171544970310792508799412092397912280594923286679674322244394636145740843662,11560360683323732335070294251287274796083850957500974817278726137032659811346,7954890646285422519425515982220441977570181574595597355546782742910060927756,2121066076676892095526555416241546752515994960009188371572036715916593676611,1030002705665772802770205305890036009903459272665864721338890073927102958060,16664112528630425414995233349042921759383114978671010908728891678245502701008,16224205339340335222764551648549356562936176805367408466634736640263613613659,5567916191875465998022755280584031341089937668974064792042640432034217833475,10561503261915825576621563677167739482566911623771072553907339314680805249099,1281495108038254322634503929806042733441491866895195579580212370919762081047,9600700315845518751455006692480832601523246124684033595437676082879283709816,15989333248905201890715282122260615227836016238448185882687783867814184655170,3846245593630362971844915233982274952290718501967612724027782949411933001202,9981027954269438386336412342904724691774209648042702865994578173145958992921,8623595877941915162474742420309695649920307514068323484728910858137792561119,21103940025922636831675399050467233863786411927021772979799068688191712316972,18892924253208304354853962839524897599416779246859691035714354037906441368765,17137414752196927825772499610314584261795745874954692214656847237011815603711,20412422497099028107138997806006051244688526968840932637543351831550882135155,11225636734520002481404086272590673372060731353304957503311626880321065568136,18380442589598191047463232737740533198002604231823107797039491680652883496794,1080201698768913889646664841066956319958767123758689784419321296338840961295,14348402455238680465583355269916779409600823120873923092214453448424409970818,3841435364722615893087024818655055436552226081083242159440517874888324292581,3408210599862246992363134715624815235769905293647431849706383726509064300506,12828232946525727915578787875290899244261094596690184893334123105536745936334,5483797730688489537248191960281635992343565537360149542110268773175134131314,15646042484365011867018844828962923289034117590475224947755290094723626891273,2658047411395048849255440353544966399245817841159701280361972904541325691434,19496407504291857422030801612379213952698163884670351003527359060477191854359,11599969200544990318778456235768317543324325704256981991953010275435791017626,12534635949431553834868179572769836881352677117158862189611147293522496413113,14223314197724082301050736397492110631416043159307338723464864105007185825079,19822547161504065277026677714514212915462043072809743766437313193660041742198,18248624683501549165279508462273639851850239430868786828229911137041335077425,1772507929668430466250295341031184282507314702999122972093244182511342701791,12698826328883589821004991321815018437184890565199562478819948777685095680390,2107256591274868946942358544310209350935597133418111664653447540003390113607,8347096431391887603955816523197766644723983907921702200049607244690524226105,7546736802459880596530318577784618006564482951653292089248497980343037655783,7337317896163766810388205540011597034395961854295494001017429381228506327036,7657535373588628884973408484470050620893383237179421367090832333743641042323,13132621069544809006163499228792832380417930375502811639756010731409020775733,3045981446877420174701593721028589257508837379178848429319604486793747007869,1665034234802535695418712526119528879364535660712727125979361452433857586005,7153904853002570654968228858836861252211159237410458977141045356668538557384,20486065252261216388496191302294274939758504298167574880569796877079451248375,21146476302842253436461025615017889905755773199293419435978649511293941220143,4692883070549935264853696204165792104522817067387529940796053065681435988854,6240088307004733902463222083449545201088681283438656231355545734118814247048,11555561118019341206516697020813127391202363312629469259248586095720628837415,19260547999655668000047734411254185932378393753746099027853756019009568507886,20469506109273046972497148219051635976793704979896239651651205124084812945608,1236647274759658638933992315999684238758461477931896092313814863963831171033,11384423918232921171964979139440160725835135313593824548598134875347314405204,19785250372370249720518667471906851686135385809175031332352733767471970846466,4246521523867165828929729227115582186945308737715737226156399485201514735146,9952732737001449699912255226665360960719170484486452179287528363081995818191,16411145939754797754686024918808322973332629854064127851496226070432060579489,18478056933955827759744830164752062474839918604932227276753757763884050277828,13204687970556138498219183195522996570326298997850204255083662628089078309770,6486083806326529246393301553077241033740361238170679962888274443184188794118,9215573806816888307072467120643373006129084289252457249266574218300367297487,5157456141970297671458245970390083650482632128904852982724214364911239574334,17822680498490868828738779948851745357227318213932493146619109948725716270324,8322423511882718045936027421959946860221136505721064786938368517081088404769,1146280240837664421126981150154328736275224000612293306261498532925677882509,20006445160687044351950305884447426432577260116801089758873885688911862838124,13132217654381318972692935199671458140461723506405656953229384472487720023845,2321904844688587860096390475332685957247396755436885306389445060312694195758,17673723499361727802425795357032445257876321564734597671004472729727016538966,17836648739374245973743495166940645001620159031723548669336786509810303589036,19509523664323410269318198214695596019790796169778932865716910251136766472034,21365014298519541792222476772118358897898683224332026502540401938408420183049,2443777802329356458012563966932795162347891060116795715814546844741577072487,6373148417441446230918754690291753760232604931431996749195267137425734054207,17543938461501434657363693054851238526018672792888706636605942303973500302856,13900881200135928840365427722717255359580153642574547892815287601924416317614,9982616108044216660339683982954165936737826707471259937628917232293660834440,16457765153339087464480638859689501343872608914611554385236118860039346779707,6882633521418674793651640056518599843365736128725139938457347614662141371026,6558481420440543921623853603383694405865402572023705828527015346924767906364,21119564418700154632542186570611885700968350571284986971813890102274419338575,15668498634043584871060292933787839904928585875204605204028656239629550300891,17754567428791571673016885915321661773655444664247443414002133544771398853149,11486839919314218506003227795241691164988634920977758623356018460082101365168,7521215937712438604222096500164256001666624136838511497877267672752282058366,1168385489601974578347279341199760237159478798101796567718644776242789923601,13117296414138131801834212262010987517820472685866772554743932452738843734333,7749628482107487230728683638475509704638633069294493147970362304145477016517,17102526463093059579604328209955502975564943362848110499048688895825859834607,11877937469390065191819717631885427975032604373385026940117533544572408798485,9490483077873795676333795591814325768750891664453067983811838122306462917887,10191097995163502256819397252907242166733175440759424521233105453843778654820,20532048353899648065110204116821557712236052515292993984913500569982446829913,17354150523998248091397848718695616500251280749145663998809707730330346369346,7747355680464214426243190602078017576496231133574539162185621451748634683393,8756715326391069596985357282435500586860011252775122994945356255643854963530,21536474090524236379254986352553305027867958936847041677436373000730213533274,19764807787330426181831011653714787282097837960248105858049804952757136862708,16451394978386784206980716591328721244692005310628203853347165858510983157051,9958807580185090358651106618892828843813431270139145526116189671892797920190,8667474404638571999095228348352836564567923532278597424241711463350637692261,9754527193113710990714009078343561220541479581342251031659489697296746296505,11755501121260346797952875679164705763574741595098729931802001980529024314166,17343653273660706017905395390969914833245644319150049521732399082825162090569,1010378412861729818622385301577181571311206842734096023690850995284550560689,12422787992288066268619146495902983268274452848893191113634050431879037454803,13351916057777123695069150362950067630454763506856720439068955445038740053267,3268740447474291563746626019604727880178668296496938516526099943483641022899,17039539378002212101604857371251026489627400179253250833603358068705093844865,12719626976782614661983190476189661930540289684710840404911817755168256363569,7334691511591452788631693316255271478502517924558055271367172394856435073355,4177321927122082121158728850724807513004613701936483594734414988911849675880,8517156232219806038206488131493677748028421797072860831547349043281348142926,5916342138159497146131772146268734765710150180676587683832045824388433290036,21136252379072914855830890952695340864582847490462136128874077543348574696616,10470343058787342159878702644341062172468027793693540114390435145428370707552,9367903847960780027900264774906616911120367129803429048363499797310012009648,9181708529218875829085211480957344367690955470310754169594385873272587183681,5161879954208731149141751476094480416185338457043041781556700389106447006281,14144603730790033561496908848503636331176898859925995171200576238014458649562,17528475461722173509900495818763366567939364295306035018228011778228457876695,449678858200791083139507971543902712490268199763356935472396275788444419520,16677139862336739737616497869711537864422474730319606529800927093596292773684,5307258894824770781811695261046705160386034275400321369052582330095447609528,7066455454850758706236264136180958260707829859148436565416678574940588976717,17464972536694182038180604993012612781624892485542021128713500864406129068272,1827574381303563082711258077787177320452649985803311391711223171032580182910,5005224603218153811845694200896301756909926774436577539307979565859865998867,13761569869627153404623558442531816440237410187883129666707204029577726405280,7377645231791556592153877817212695036000405157132509030366572797100109551371,18929000938053222386693378771208400814166536156735504775432130183653620422676,10277912490419902146704238375228669373848088391763413912903062245600018539005,18100670309576234559559738539779745691447892297890679181953368845735547051936,19792596568315968292503371918803163404916721074550555295039247624601141857094,6568943725774928078767297883788056758405958920376813493652098209237338819058,9708751028820311560873537735196353024741491886920686045780276405320332052014,20999195425108372543557431885250084840784235258564621629580763574508120639473,4668167020556593094762451685509419403613005848434427529155545560914783238805,10260166712816802791730167674468655124354432849926388591536360669342400828562,3588854010476278115364011192514859807683141010842317346600561233941024545452,955642453625490778540666824328669289325333312941525596301926803494785606357,4102026113333601512449185655242077481750021570821512149654744152647996823622,12901729067332459436197297782018174449541114313233855185609986472102830633274,1432400515841095916662233518576616625504866912337953671606919993429647264779,13448330934580056368019676193029108114576729981976748604441994201646531786832,18698774355061680075847219006041299002465669495077065798256778682757699200357,6114255237222848342826972972054203376750041293553715842262723528673741797160,8290432657858704891136963220676191057527195528510584103201077577863568506432,10245893420315465808958329213978599152040050245022584266757834865645078424612,16235075160725310956334026818354575166666144493784149178325740173109469893465,6096223185593495310139379444667947750109489326578429517185410779366192202063,15140535409353326038030605492985074291044727716595244779768492745470176024609,2176086602170005476358821348469239586548222322021168089824748815230407069862,13619789468668594404222482251836770591464929359372018436289664558758704681508,8310543107961996371575168146304294641952910047046695374038288287522235989972,7738370036488385965043396010845927300705713772735513648600973583706126470834,4479339978160586717158719172802732929733916533373426058515465717943672025882,4249199078635815430904933856748414549211196022798648243994671515262509861644,4217767457132611540965149700331359170343442048612092095364557557503970133933,13153296757017742961007840475261159306564053749538202546045661292791402275573,4396888098805340064553349190742819413046668458070694926676742098287729413444,16734434548572604008363129496559919254718993826492605430831689587940707338899,9015659000250675923210953833943081286931414181352124970688626484896488861379,7859006238840384066905305454236928888746240833462349287375399918976884871408,20111156231978127386472936347996655414872475039138926155687856551161732442682,20628144438246471187747981572742727430082255446467380395647482352559593647287,10829450719086027299358038584474043478547531034689618353624096053194488185624,3900905003848877440680433966861518022290921312029158328541666844523704712962,17855611209216805679188603521771950395726550847102335142668673883933213178620,3545647030011914165273791133303433140616659042668342263053968795372726840341,12285059161807384662955183653994648298401051593713604819454219983692697182696,11819552939527124997493513022814576182004246358800352547817016502521627790011,14301577158059901977856927221571457807294693699285069296999743154546478489569,3571634356329355229397931369891424491520267531585441552581855575412868351910,4493956823795845864156868703591503758707793967931549819151350879135230170242,18261935892851512416084887686097384445742684392402688030129684935728742717201,11603603642132262206403092178979219208473125803069223229133184466185736048060,4847487817017177565347080569283215504545281846426948697937793918200171528656,4069745589764729706654816299792297539062872486670505242875943264008484198412,21282151145529600768369623290936085172906963145870658008436208961308948924585,10721916615176439690683002129869911178402752315827226965537395702918089626824,20400924989628432852029073867249809947097995745931036434033577251949709693425,13612038717302251316998414209460162307179960669236088330389280060785328588738,2142054298626034610320009155682451576863946725173133307732467701538715335347,6814074799679801916559787533428482395152765022569535278039545933747386331226,3320993272550636151137746220977818986579019792097013138902071906802378678391,14404588996507110096126959822135132305375204264088975725278990285893078946890,19449156048766944910033639666691724350749810714682158108539166281157709899569,21600390672948543610212878389553096169635598817477527886039588952230732642418,16122909565998431497578901034409662715618749437754826295511086000491610510803,3814026203802323919937341565517130280297397500968227915639071188757380515963,6912908852134560099979027891279882003635111070588372993239339154823206466274,8991012532130902495044589989450658026455069044478725949828656540931441650779,19794616058753707346170576299297623557371037336156984230370345545981446397931,2577593820399732466692625387687370505160505291664134162589397465829320209836,10545990182245838392125531729060296377668723705525703355179325185018108067002,12532592142366733026886391992589159605208721772700692225488484422366892623887,19135911891605926936423877585461852787990719411437518367185457251216578059981,11635603342092216271740512684448806260427922119693878652222869987036671146111,7718247137511759231158297248913810065531288952022630354624599924037308251451,15449533941190926955831618735652142785144234166497064450979389633622292725920,14793399192194938994493676084408874396657844744757917843286252680102153699293,9379880417179271734210305738187417887144762048262218697049423795232738616822,10001585874846875226646763599153358317197291234293545431914341192928883246454,17564611789675170872923370710570629576001514727841256489502945348076745512773,13526676577413987112607573245391605865887231830025935262602066777025060147701,18771091487566471187260929156402254761992313431761027006794035379840343952064,17672790933843778353408361605666344788858296349839035375070469185645819063077,10136925806345148466019786355963896194230642602748938687391144254701550469628,11669469369568255529354542182318275079656673415035219767446071893709388727608,8717156787967537877037123555054580463721012975068417092258849467938967272751,3574689732222366081898222156809576015147776290993716837975298246375762980084,2936447189567283726966987004410103389002644634186413346432130822474131530801,1699723231413680239740710996339133622208402062115605498128909025253321290927,20239438661176091033530372775196947702401783521122338633601531691101072063415,509222199143055079823531599510182326541217708021228426946045537726376153595,12460587031004227589188413497497959758507406039249371767737225675508588807598,9172361948368872306701383997811949982264909388810393902913358291336142380374,15024321518919789320143737927991052999071746110692384451602809887435324670247,19363337726355099236128975299462078599854604247644073095764375371642393487744,11352512845451687563998689687452223516295911399723160879302208800753615647616,5033097489048897691788022265636063060230313291173145751178865731392231547832,9342768693529219155995840295623046316860027403351256239528640640660995546250,11343407235843410518451234635552443892628096773317032816539735746541252484029,20271637634427257791277080766628733956630399511643807969496831759934416995624,12979118904307784600641734806775453265865076574307149193300157552133646759000,2609049561347471594361989318849223604030501563821990609941361801853208873325,16638136645184843973996251461253142824084602885453534706330402604048300209367,6290150467317840195062942193162131367777911299731759519747208884085640022080,21846903793348064415550139579740558481601211918214432128739680250084492380404,6881355315007836102200696266576401649721953812561017678365140505591991478449,11991852144633415808902015898168146769921125504309617193757255165202163636329,20579180498569037366675392921380645532641402855187025365767529341564826966764,4127941604046459390852849136716344563624191244387948802112999500161867081345,12726445769512078351769013120614118104254671239018619408743816227993876252991,12822824504588887927083519548290538468815267612767490908011540889502830894241,3525790082239104371118456157894419087904422095178764587616607951352330724979,5534817540911273750657456222142677256882873311813581893871590176089715612985,1615881228089658726040568147025008122728572958650432110106281742560315865517,1471725164982594409495579793735446246197281099521356897919523009694047660159,1375309198078109412495220212570536673190607625762682203229827372752214429058,19114911117517497826908513598723039822664580418797141695087511229965144677908,9628666313906709051161166309431160628627430386029173286325286404453712266410,21852518218578549606473925058864730694915463701150591631085298334480610743316,12775432117186202301959614842766511797651599815903402927721712100175714308106,139892473068642488659633517109052420816080027074176062905422560867217142259,8678567564479314009205848092936065091488089332028298130303782323700697895584,11749646464324896227459490085151303579078783519261033148424203540751860385879,20522934943803615109303532925965718163549240564060985032796290524829499285217,20661244899066232726889114470941159662948096319289349895724712936883638757146,1712076112157842791409364964341168524175271666408017461435914200921357859979,5274198338007371549113715286886410970476178374473353058525495747031417868052,6737897812641394021946938592351495323837784050553060267876717564065727066209,7802413308864463219891658906834234180067201307743855789866460725804890591074,10598878996622948168711729113266592565050867869138946404948068606726933771770,8999501853368885436259381006393167420075229434053961224100936590306072807402,10154159140828416502096070052350440839365634698281866510618130671547713671046,10116420503162714112005525549243891887026278400783073704446798028762825422117,5545266571933610687233921232979606259360579780771113897229483385986421780729,21233107093610116862049125654360754386798111684938073821049243264439651570366,5307392033140435516838295705521564813869712246929667484768640666687057034707,21375317482759736213193607973501605926935171024163842355374965533706641104549,2517892809920213533018018674089754443879541674948230773132283920676903837393,14360345633113115894388501084706102426582517876835778852281477705852716869669,17053269301717416242405268053150416723822210193991005718303172171427452536837,9906602428995106334942925928993621430906117671319208771657883136890126991982,10354603022009709342018106446249264303223237761462844795940043835225457441783,13398916116699661698644750814188836272580610770712272177556442659081018605804,3191149493139822128538617654520106298782669019011287540692938944153323592958,4691984423256762483396977170887219469164634656601998705889064679728271695271,17844101314007938193168524989091446035911779338131517299817551328197378135054,635635940269936042377013194809642013073936660346940411744079076043939544740,12630888356903717277892931534313436641457206712723665520324533786104375264085,14140466574121870700874387789856251566070511990708575066948924661369491559256,20370174501238434846223710470633284656345430614321812270231526837854520663574,654339196866659831266130941576738975707930915283825590200406138066808189370,5107706503321722709363385752813500904785775244074262870879244969961234309572,12198789333458214522406820255828653820578540569170284513887146039452722146485,16249136895399135618027043741098607972773831911496869243661084436243711109565,11074204104909151859533339603597929732173550047640253831218390211736882449440,17207343273400097590016935219508528858538698779767314862863101225959250875891,21262587236682681589242692923329018584317630804742733118429592061667487058638,2280753183511690306986430331340197673251265546818209861935234085004534230414,10254003274920664842497725816382563578440196723429688051808776569200020879745,7759959068226022198572347902743272598191759849179433231578496544131111538092,14214316923200364820492127575076874888948881174491573576707716667988807435892,9095544195644789922175839073929462149959586189940443682544660563790242551416,12649782796197868227327830841571149621604197483943737926454728454326532192518,16667983042241619901264223140344714132852698906756725392221839503187142280785,18383173644675687530390651274503384113459403614974472825953064896216388971884,14628141534803375030737634780152921077373561843078668533631869027351905379871,4561456211241649459019745200365185624320798675863426759321227045069329801664,12289778497980320566229781933786841623485008232338420865642173363101571189872,11975067175623680843959076988032062157059134808170430074549557650028254491562,13608090049838182253377471459358669610089588259298499702848843266957511619603,18788677463812827554544269966162484344784391485047475243938219549074331613206,4881667965195655156201239071358064948072146968570883219541497388280721871638,16809375763554448903183355905513828131657823301396908506126469252462160193891,11654980193951434743713680917141406309927211470940308818720103124789012440740,5948986090649283108120495678646398398833638108013243775975352725637369743753,13726437662355203524944601292802877111764435687388166013301616156301223567122,17457684154769676997584569814978347304006793119360850469355899127743508915640,12768218426713967613672155360932690915682228245638743313771591055379281067565,18615157783057763780308448635283319685644271696762198401466573335150909781420,17036103965935103170115214353570299052411478859579659720326549902160146217969,7150547909167136034355368387927463942994048322819447869013206336674786486676,2719491185384365067577935615529406253538979948934035375021293885648964670289,855254098406697810192507782360318218871612459371212156821698546331701832542,17895542168549626634871327801987932137768300191314912757298899767762396172426,1291731410872228901975204398582554998148747251553901848273154130903421546804,11405841699040163552814729751623598889450140001218648787184675782417123019196,20354628821067577915648505449000078769730992376974982139779446148223962828730,10728669080369994464716817080074001337835696213713101955141340296929303809038,12274798389677182426524706446934567986140214102647161938159083665963012760572,9739537323825422719175243872981907235223292084323462340852187679763167385510,6755543715589769777862111458854566169790920787355600259792850662088606657716,12126305553295538434422174339664597983843351746744739132557070380077267264590,21398878068159838390422213444802849205194012142590812651530393856342428295355,2774987220129009778448086748836270418387857350731020745311729965596748575420,12913355749231079157637607439722332211156795881932799993926379679617800720875,14002442102691266344434178456827064608589741346471232083579257521903268988567,3222000382376546717389770889292702303294866053055569943089969635516575396692,3351662579522271904655802780809448930926900026265684873057471441126697202347,8791346592452796050710862947776730913908702488104309880248248201823569029744,9103312554290751080966931020955359921020213554904162168782078094097630022273,11400762474859869669799163954742952133400547669811496311736883651700759825519,21705862854411927719091657128107442151318579935925212397760983799549487960024,43293469326476059594440269130071583321324378720711508957751360314337673988,15189563636069530033236842376689049504908622054060814965474910283072587672143,8828581874201341688220445093730125081012615712886123840297097551587278948881,4848334665131642773713411076824550175891079883511516252808850475348208758729,12614662329834759430739626588497950629642362637723265950380896878486239042155,14266355110863104530316810105072189601641436180167942829728212140901379263956,17294822327168915058983104150822364346325840621309612804535067234675456850670,455077676048323303580854786776522812365753723694705688462762996845811407009,1883008531326217838820507370543781882290544271112198177704053499351851681273,4529982458238957976485223202768823175919650810452913863593242825418350872543,2955110035783314707155321084983433537364088072013879095266124577362993635626,12967684942790110900749491528799008728014372120122130310632754743394775825471,2505175694719163834796124853767853797404065196427012487113935936321224863546,3664644243909527501109080877083112285282350623935581596506736195569817810680,13149615309511991949247749473495035486060198385636687198656459619774102038819,11675634552285986901460163850174089221624080337542386824203554725353862698973,13792241875469760333807839408609766753472484847219134966123237707758891089388,10227619387285566606296112062328719372414665296090743089679008143127205545123,12205580044090621048077686897527020579927082420674484835775119696613313405371,15208177648579495968812696435767989756568450150931633443711377393141060828911,6203604398339912597796330237774861234098507297133105016255969208311447220376,8763991852009928642943035844463232737815423121200913107779495834216057423172,94997075732443240393502290740081268967228130793200255689370554790238240979,5269706528648934838705302424114829386876854870088873864481541735257304941866,16262872163060208420029150392453401749302720607531142669546071916932112668551,8143677473154806611855981628530143157024134934286519271401846470427527147543,11345763412284980808950171535310000445785575947246043879446971501610507015402,11334003190684962190461352102674801284421167648666972792173808801060633658405,16679481501466111466382494296272414977838924060754574747550155015005991797168,8717276046214261706367755700328685033217888501922395351508483646143935055357,7961818553714372394804939036958306706260485011393197807672306728909086465660,11525513262393719593247460022637862437588876074380005892794471847411833011017,606475753731577839300896422047168640216288859417610094202862133247546805011,16216814510391154599441870283663624434960433363418315765904453229709017881340,15952802892860522124812654660125132147349553268606042022775941410073735145502,21186206422036180717988803903908106965745591204944021637150186904241796046981,6944713991333056327587649834988524981544213700413795245346955488518554424877,10185921515443194095530439914620341794217076478391514698779175769548747359464,2855919726997577698604215361496800379220625688194012864111223639042676660976,10433229026112136773123800168383892031427061365180473556460194903407247351339,19427072191035469870347195569940358526740232693667547123354147821192789102650,15644214414239800285411872105206002044880495869535621299007907341206661859610,17127893436675976263942308327239908450163069123121279064123261885014993455970,14398850115453023364458586202624524741971410970483408578015632196929131043640,2352925542671141920909613532344506652984644250240272091365991738093178607788,10172679680316429884824619312723045840067903978738893283037233244389430249509,5772194565812391639885669321239603226420464592665765672957012371288977540856,1472565977275775489403659554782408548523807638115405629626295474159727078930,13025952383827165156872004962772766979272981810832459552230024272976389350529,17564758020035152957739819749712385631015761969283204715352893305611222727560,16405514590762165467156068648660873304776064039873164250553927264160414855875,3690038285204558326066250230248548873947936562327070117434442040765096220855,17531140782998595396669833094850381400841695523035934903128529012616296113949,13168227885444297954910232183764567700890648537512256626187184942939569199780,18839532764289221356950914594613087164434882227921649252297932780104554074257,15690093187279544523035828189537219904387587938956853550130942856247262425989,4880718242480815050016604653617276367751146942554754727539176934739417585000,5767740184065294852679113060036925102298292735253600173647375101014669432601,15274885987576180935369267696345371924274924872703997373047266442038483500100,3761934589481780435501384301483991135823312027596840500386086136996196777919,17076314579416028845718050745024649043011795764818118471181221546277962595385,15977291426665432194805519962451891500931039499992781917651419845757747435870,16614058019242709692964725060926415535596693985378737640811775269245183858531,1462290731020299561638622134991867491216642860791478796650694102212515942203,15285513431606451603488599544624561225569394909979737124945690710031449859251,2108108609418057784389651014871434275919186190456064517027979476451544519949,20785453923508177251995968212118965193411372702846000862603422090322205734041,10673883530097564269607463521683039178512337022363698173454334902283390457863,5454676180617583613153450533396644120109614173104204009158828769649771925347,2308424025465899393970422846699273218513861797562089060060302466408498727592,7521209677407171946300925747807233725946342430543358547121236461545495788103,20573024021944297233730031260403312250074182051596062256738574515403295322803,9021049816696497696749267473705619787233696328020950183323376943545740004437,1865524799085825018345305851095200435959748376626055576269783687778950437080,4246459257342056987998012962024687622955192847494871592608632692951161262129,19427245695591302750338395658196139112041609989862338102918570832807123117503,21526088318229932910068935959652342185575362039375447361171773752278498069664,16191911454644420751852228901282854304136684923356871310294001321086062307024,19158667047991453406718020435447139785846629820299132383267410641682384370576,17700355947456307421977232728703295781949761612179494776757369350093380226828,4397993077875324081650432554749300545148338322818494126385494799541152486594,7333345984549245920976934899658584162392463672999208699449239323807521633803,16152786000399924760932165522677937364378936868710087711558780050692283598645,11094138063712503930108269043784479707229515809275605844595768164840752472377,1142389644011176261530925136868504263430131536560167284105696375014595703389,7947253178759456244011070491140902256859556283134055577001208685178146652802,10134714213573683528928794197545260748403530346308318902760067810116839777206,10883490621674448000789965625707254871804535943755669299023415555830424281655,3066669045698349285650257964282463204141692000014900401186330770537030238642,20081606580658665084706560391544166403289461596409550084066896490552960642479,6155695406737593769799569079058291297835886186017961489006277167996716002247,8515542419918302650566740947332213674125125387478669670818010011334680546574,20110138544602147391149732696810223660265845787019234225223667638537351747051,10742562600839811890186721654855708402836531506887842079602293928208078373859,1525909842404376057305890458989201366856740974115647536551418424527131666169,9234236770964972467234889051483942687447344616202849085905582739078803045160,2606008597707158849245186414604531348516676367660138989733829835914698874012,11796760152309688912186437926169763667717914107947289133346750725444306914631,3851377590989618761627509080069107348568977801140383151662774695134986557597,3154796336225549288800236024241376487736097402096695364582935878596928093781,5510420220665221034838403251084456079592641926247054056939582862556776533398,16879696361470925506825934570612427394067380616879319126544582610342257894977,17284649816450637986813517327310560148892948427878914253815654865007623581799,2833030338755501226260678429168722114253235114087325082893557705288230185302,7251727070132476220556183457711849452579027647540936257172964240637390843337,9575600794079237337218029036087316899348403790684983148717343996829930177678,5979306342004680208572077566967420789575741134560343288662733429960668391430,6933647198431187357226909706624729057428619440859131169201765838043283476077,19168763196217781731628598897969332495895458624888700544934409934147951462602,19829437720109810470479999873902618673477593710269745617035524777507262876935,10801527657674630131387061424571233632050383122132208702068470808513632048030,3324631869609728132956796851449123815871495758162118183753705724979320742705,15660020223439851550062020388305149722004313049334322631321250103301499692604,5967221174170233933880215190156392465136752773253659731223749128915793467895,11552412840249358443126681313794466948899653896063684296070673264241626555196,18888906666917921069717332466525186303442592625253328171173131193932302764004,9002714106167484391528827546180572105064179104525774089102236612700713696717,11048302793662652213631623254022096575352405761944396370134943300004028917865,16407259962762436968310192538354523615684343650696199890141991953040162326636,2164382359471710099213275616027528225843146809226250465653585796261822737346,10534211142437421383941598776341383955315039281979396571221999789915575101599,10666069653734320813631520107249402109728041265475244772290972049841823847727,1065893272480854115563003062650162503958098706206084024581187831004515125777,7996693710845330472615496754914137367924796497947601638820266498225398515015,779460584637732468426955849206233546264346430125102128427414524469939157403,18123487244613769854380966736011971128129435530397043581264858565849669710522,16483639590865705054952634993109499660754781472434181022666579985294889582777,15847717171578788545161470441065692492419364914649476971042627117577578420712,20212509548766945890162316166677458350544092615956421310024681889193656903241,11915838540527285091679839305488591026042934314354878896592571753630253407873,1911170159637126384084881836969666801716554202345435461162520643252230842951,2519681707616189243873692429706701363981726227724944939887394039132311807155,10525548620009931418869190498282964825273460634626042574365806552478535675090,1007287689974936217568163398662729361983046876939574893360458678319961439943,8918601076290071318953673276836220960249911431394510238963515695083601259416,1730552670090087588255812224149698933189694835321291448382024953001539943933,2692212389857059051251821082045515561682372012597270034725442717100828072430,5182752960118030069130081328243349382982053565156074602369672154634481788415,4186223293158399083027342405464955373429347225209836842209182753945871255191,20698226478040525601636369286446332773903307913544069889209490555501069209140,7848961029873906562639009619165977234892385836769337804546327846501965814365,13921935366749820642106107225856381492084238464963488385755265898574906919842,16615913254044390064369275838835406299949293202833109553557777908673881552518,17884323890135880903838623664692905800576770771455839982202688346472867240539,7671240599961467753478651569648667266853727017714987691902517051845809028276,20540170969725852651721054123169504183251616229771312133024479630289328600435,10885911618876068300178014171685162848957603467763239389113505729594133953822,1821956738503711086168534921235313501143676686594517809385967874500584768914,13900019517803309945097308036151373598859036005433194049333364013307418921490,5611521340578197244418404931199594069340846248086844299279812110836336410894,3871676825880602831129014665958446397148564007925285835033897270539554583982,8660883522091722908446182204212531338997991855689061026827047565345925404852,21369377758054514487929500216341215576252815582773920801000959327560535036910,2412441365534353741053138780929948381707801794421791967644299920632399699760,3962365750665624098182798369136001622041855947680873409890054621414139629589,15001230629104674518532645948322038846835064889071294141298776340346988584355,14880674002301694876681052915629907300219131310128131182663986425102259721980,1824158054562585980316309768551123828629842232225429989383412402628330419987,2859240361399565691265380107352020662064288346296545444794991049234114013603,5166447910779952920543762328108096228333459621541947567522578212254733957716,1007490453560275100906582245944853446313521002614529198832736321283620962455,12357031909288499920427512282658173574064133416008366625033457013843709684703,4908601693798278768903637729333835430381717019653632816739154645536641464365,3707521788266753982537350852704241176639571081938875735935799519005785641932,843648473424733414090549470297108007717585086811320449394192229155836735429,15745469357122732280411707850429686485179261034785562466267026969795211925342,10805521614324416411410037641243182724170403739698507241460822321812492198235,12065996971764501469604703952781437881524721789450462435182323617647626062291,18470487586372818033539023969236693307855263683332928699228943202064060965843,9678881733477238994400069917737562227773718359505757479334487914298656155782,14188770590313091787681039051598250350716760439974403531322107017294575035366,1689506610383677575502055715917181866056070036146379850885318902788859831848,7506643906911078844726412866492372822643011138706243954480387034094577464841,8878900588521598109866546176968107824348718386295453778616479348498221694856,6870283245627392817090238076492510507322368840526195161203457308149059064709,13770891113056770539767147807436112954402870897635701688432832537357791153049,8780360192411651104527843471573635887257900701816701590232913021169255451999,16171874311798197525909736376097249943669070404511356154621097034937309906406,5735048971584791925371366175024708991668126697294479025115320761565490442773,13229825087263355390945471875664433936256658682181329545626347347763439801377,7075776235062840728475772028477434335481293337646194082436681309306082067951,3621624535897102185304108550400513064448572525424419762329290603569136345699,8909048763816678806291702062491546272181098732106818908949274412295033032278,5679617488269393681126385387791795896201443046828191787132461584904242222704,10105279386430545635207898937992374339634464824905552041741267814807859103503,1875089455725008938828188584567435691926878726057441578850433616115151436992,7477746898926143788312536189451854889707733370802231032871868774692083118085,16386910598448767875426039948412876247096832715449382492730559004257126956048,6033432876275593677037331179852069653085950234927263672572175689211500790655,791047936106933006999775822964245334290371384592876255418502363688874468612,3694863804142244539430013086697918876101028434198177049748051320963196192691,13376682105243214738309576815193178135837123827716063891638620885853287922296,13805679067029770984721773402288418271927678860935425166689344094492548637057,17136756160106085935819446871311843510549583818138636089816199715569134828084,8109923439508142364330425377154151984256104223553589804214354752109994937475,11286249512402084538299269911568404171399278286810916548813396237061620605376,2584359677745194465235893977254941998996461095474372764450843406506578038395,416048929518775256195106483480946138344969950953407172345234478269849793039,13382468529403508085121262401866099849753365548098731797553497976873204205709,18439376867491626480684697800985907843592103465829293677253579863338320195923,17849262151524731521717998935547978553691621192854239431428238124396600612632,14944765584636478787586231666077419063063746476683640145827104348311750508175,5770158920816863002535760768793204546036568907423666489027939717423021627834,8964766646616906071571735802649575322546984330618572612076303377141821583837,12741361066585979303854420163873489016934487106922559130204774618881492938249,17155650977068989655844853330647332708031817408933941319367040661444377002549,15853135222927269109853709968587618568449580274775781838704992776508260190624,18643405831130205120436044797258461126994691116505008303058249039104682298143,18381699905134802759607923737176411134148483921733890751508148644565049938661,20771413818150322305462626795715653983446198751749952090107489229813229842550,6565230743597462418756949526565014729968376635326046194605417268756666319845,7773589221172310936780704579925742277511016906417542067089964629576305572209,14322739515259154048217383149571029180760938501429981700631245079741667837826,2211777926093208827662641428669122029599076421656786665814449320380720581777,11959359909854207341226535525210590494408522984553921513181278512110987087969,15631964544474412103208297614910610111786652867610037534463100143218625118186,6469947677147265061709088012775208497425320831040679910475868641704170242154,14273192286218513903657400373354426033843730885130815917604222619132646117025,1642305946822726119533692746690241550779067996073465721872854402290979482744,12434472654594642340204970901697561562492434882039006954954548364905225683590,18258333676501263903599077497799178704676070138517903780843551776313851126197,3154393734777301102615783657097778679162307608952237328943250741895135803910,21442924273325571860480847088112128477994226721014369494483203254968684948447,12633492209679682779165226815843032818326050497846354378961630197925565487104,5676035885913185017175294353150288993325590895201150557890586619719458353554,7971989338965840486933559372839713095797443968865735128939127037392334228821,21734085994605079916025200907658739534755548178328895704833631044593482792710,2240615781815075893018901266381250882106533308854256044823388761533658366337,19418757086351270137870941178188715468785231202435740939860626745964359442005,17658978545567285097910442499706845586224912649469751675828983048696346031860,5266889563561183172939683250833485521316204021724495164611029326138684723583,11128996685041402949333841527417312168812141699419947558499636572258705639448,4876070090528783965375514438749842173086453529590096369168455769565070437109,21181864929467364713132566956143162901336986129207766576689052262132856884478,6923705508410326350945166370499325965219890886201185955752583121521122421736,21369826512764035509040463750392604795868027299873193291279213169276615858803,4704097774288345414783119239472343512761071550401447208590340029300816575296,19335571041256357691347835994830129551703141581491004773597606130380555930148,13594634273515260829141229000646270213542265375428591690952060475706589483636,9015254066149037983117828022107604427546915195306105494160093361353622246415,4212072016320343773172520900223699632828574585381041109390033407447488634385,1102272748190005338904701274717935307889530536456982005034282115032583335111,2736300324710728232038909644774832551915915663932530690557461126955645530086,4835822801818378290852301048163831283974282641105089345434084063764482095069,8984658187927452678459930452346646248663512083082894198317485712426204609811,16633394668571656740012069555016467267297836103775110968049070854163114237249,19001311544890254637467757524866604779430904938238046630395635640108752440416,1519708912837962563938791348422981399413816048437970967955664087668434079252,21331841844372791543710397499630585987940452814579176990050363535517182938392,8907423080053260966677751803467685389883909962381980865910698188903614425511,20461083176034684313938738010980183835826228331514122093950995340802162488751,5841016603634386755712428070725428370463826644379529834480138063613116133165,6169966163271811065481708286709332934104602048421028222790926506913444959185,11123503881380576416779399092503011764979780788355198614717104650873109848686,5910862578643213547409014086432565110080048906429291885019036113399453987536,15326247930625028665035962093121096584742207235393215425729927190450227004180,11869108106148533163877422279522558694860624980410176225979111384418155447592,11642189959177792725300751489041811935498998846917246538427709581655066866054,17383982459896791073091103411713034950019457760840905433100761135071197717377,12914884881288305014413720371780941499071473169305332026567402160980899728234,1208570539962036907751277903184876797538221568150857585830629441131315144451,2323312703274674937703540014228631818729280611690694743543061204714949346767,17526158529185414889134597474769916490357130956125485429641429836800727655323,16037781653504828212828867735133494813590828457250361954137565662868257318996,5407222038113928707955890035984954296613370389143420455278606330416003035740,6601323218218927237946555844476405370566012808107313139506360075146521702852,21534867504549849931394770956914633425223988570769925897030241609788158519056,11391084204734238133980784274225569005339670690396227409155789097373857915450,19888681657658973285687297761078939800531741094128408699392512189997402853670,5332577406232753436405602237019361733171667669604896195130680826397119398314,9059600173937645065621009092166260440988612068018047518892978276246308722168,5301647598491778367767843695092267888185214608095464352349739315757388259345,15071875841892141860455823800612444188659593796102096590428526661356131692597,435778089283152858387915635050172265804266241934673566488879021420875384052,7253178577349028822394834490127746885621571949621301778647260365262978601526,1165301643600280009322317413038719889346104283514223548696059636052018656756,19642265897347119192967952847445594557926149874981543320111550169192389374838,18546070171142820328487316603855788669722411491547154393382552167546945234264,7547722208697813989490512139624144757215998986985181672151192221427497361833,21765466939205480830726051696775103538365853268148356693813986094780619132689,18066916718526031105430041386116904278122614509807635157495047212689329422097,5567247965934318360602471432895130358745239227464728512128895794990091560111,5268155242325913085615961568740884974081158441192412337454790453319219641639,15275184776514682919662155241139211655693258637032715569152004434925162363584,2179932316974455074499483491372661376888522799119184614149917286749483028849,4621405833740121725678441855520519041228014222881228746009997774516764304847,18479339496682302897017710580780845640172065272400836860950352488372424120096,18557033214894447033261016367420154444088029564584596463030003672186270737859,17200647521217215683722635843299601233863161230648748208816378327209201596867,2688200399163263049122461117289599907708945179806531635658550456745433215543,17415923022624960613510570384321832458760537169605919976471719634183381965151,8535568676654346647569376193583594529721160524940659464514765031328360321359,2988350233499987577118772810582267364198360724494195915351933486792072227259,6210620559937378902878629998722853418159056595764204463986805098114518009318,18310997638100731876764014221687199913435941820864752235028122857262977059320,13808863093029019329144013239638801163784179422135484562563156294580677444841,12914098780625672320372746314998075565042263956380764233047047668841824625393,3305953095296069725576430940963322680842934544212876613078125492458854044556,17822002370183286453254419050088898676184956527990121400547957986510775899261,14649614548507754711891632411080554775651572143141206447218484052001553765684,8109105787614676314388565737575005920261787167569229710081822989465469152070,10883787415840547710621559198296269932318487849486120162467244238276174398529,19330421887539219495728995383446553835046303504116353064676615752269857951508,10124601385542856860656799235536724683363368315551234368605365576161456958605,12586681054057195636996904714881904902720157016325364273875514276164279959735,3757165144866249284026269096089043031459271594379869902321741804365836799544,462405354647627586345675602760959074379157140949064478801734872040710235207,1920260561025181767428737283255569518557618670101985233779064285550376374001,16427781514757709627041602025461703818581117100125480080881962557048804215419,11285710669637766333985664845741699850953316015510407645702772350620723934913,12651159368793078896654108663982020308442449053255003548814357252262150375808,5416603170144910655254279621683623582654125103494176617805338836184837812634,11735378404903665808621855768545179642393017572035737886573368447383433091210,12201557541429330882554855185927797569372240536806738921957792139394552229540,12315234857861194987612137097457466405047598720463755079786381945885951345726],
-        [5029285279710800539227619495938136407778783814400587102957398897867261120664,21661833903534656620291231766157513264428291380933208423519374035927473262119,21013170147855726227668315492699186959893088673047129690411646575996043835024,15893628062504267735591398483514002406192781085288489283447316241330749546879,9860639032243003377544947110034203265885715041305770375052648470285182020229,10431760628292478929366440566994655480900443273305000842144090945543100651218,4662341343242273661833461144031815716144681076466659112993661636426666579986,6674279191498784183427663914511569570797862586816649467168170855788360268943,16895097041920841073767278653214275321407577186751547609698446652984399225877,8168606076413192332279322347673356872630772122089948509553934257426773045038,12091567755121016869657080116466607855522522017768906776539212195551888602502,4684576201081771194613696765517034834984066296253124029929753160055156611363,16693488266039456124835102259365515976900969074532557489095946797080826193662,7638443036775258881709317582832080783911189229963788890221615286494482929025,10111436214822932149781668218956845833675824936886829015449750181332010388640,896682691957564465177669890535917423987915406885797833670239687119295318467,12612639059115228106858238115822505521432423470330120640591982767272085175034,1851711744209473345586117150836616408053748535684022739058625441026889320297,14132260688735080257390420980422269734275443926576061985351678038992087770902,487493866037948515547037886552479973316400139387425953088274857424154262588,7712516772901240105339429973116360243232161870164307482409826131312962380842,20295556720945067049585659016570679551265845058805648954004989969704769135170,378208946912325140295069471345064814132951473534378635003955801655986417900,15111601008893945567629460471315838423301021468457758533702272669431620017222,1503682435556321218669089857094247703956565058167121192612334331910088441071,13084874799693933186811120569396911285611047490876409383659779579088985591229,17464483161247836988344436558341194021876261750085348252730901647076441211862,6628743087463083391707355927377412170189936607932592258517748766250528223430,15153763588458144568353947674975114179172744555450771328418442212716084083525,11217853102739260248713425002157925483291370125178251466195670948291389406199,11275485266433075885440484136400353724892671196084163231314370685019444807048,20167106354875398113371399754994549089359568833089630824992752829251678891797,14151330869211746069130604993916224881047448810615413435448712767752320095045,17260356243574396880210370581740651566334589568095587416844511054569255137183,12436078462666286197074526218535647721230687376129721353230123441759960021666,12001627458343654011606323250787666795709808266974343548842843520227918922255,15944850302839498288636342399223012131590208876255723227505947857641523034493,8444103924869263585176528654612076203716402818569041992813095331662367021655,13015682914180762871967848617514355587762125694235380084430680565032083402270,16200183380426364054409550129683752323493215428097334915015688753327665325485,13717643109958965551675619584464549580820722892266661529182798599670194908199,19801725181447377274232761944437523251067599053402428862557912155522673980500,8260354277364856843022982286494019620277496829494935775254726797533957063267,124621144162335766862972192337737579448571172779117809776129849377329817478,16488884047551411705397223604196364132975353217876182634038895586664127388979,17336432076451490238716890901095007360946878388179175784603587179384718443321,1210338460555723584699132156502555539583432069430631008706741082485009017102,5933432012048351362807861976737945204535374770355507745694008880123055490802,5127952499969178010015035020598142881788437616516517827214405489972695632240,21100924218139544842807404598627913291698574448527131003096325470925085906016,7683521602764604419863026286445694988900727173175219514555132623764360793654,20928394065137007852706990901925870323120588543710137320004640014111073449000,21375535333469484792161302750563386607223088895810564711097025913956371171769,8663517227154706072248636076587789834246541965140682871530851124960776424787,9182938389356039217318590654716613493414550996824701664670650439783557720226,8327338979442122743919832154397496089418582414082199116629974300650113777515,2474727241701323049333019668054716886184808783449917153147248751503852312804,8543922237501430855864877057711792269479294116675004771113148647309219620030,7863611214303285947093025404346084345102544167615769255495752297507346719791,1448902069752048144992778676670381235906144579949631101518897035253311063307,19501657783346989621892787238946890715709847672294934508902622542828235185048,17076525025777667838921778388186176564387475624769926249793144074465528465933,2381176586418291387279201678056498732033435079507661703992537801751492053086,20723508866659831749949206314442193102431573526415976696387848305764994281574,17461795780729443663350296040956479984433953861306521086706732257263430387445,14849025218838139413138931958408289986915143240245452275066866730847749323920,21207204042106390965753782189145584243052148578812105334769740484186308017901,3105302592226642624386332562899903659948819667537402316192380465808886843623,8765266846991616382097124552983206033439769882065573909634090515268812396114,9950016446092650730639179912416912603745831292536616469358668786853463197224,11739731747351277092817771330729393674312591071236310446088293450266807414263,5424991773995591044103668717299468589013142114099340604018933512575789323446,14582885509715812510585748465607279869582209618804039923778041514988867577359,12468934763690970929325823037406509081405444759649987929912706732364016057892,2792793293657306144108993077959195845478902430027171873963281969527327256602,8841327809851437433386666692145437950603022633472031964220924157605803799391,7845859360796082275932181771457755704129556353505380746504571839006944723429,10731793207832149137187382442869034250153492853628224932026933458041993639295,5597792614864287090861003890414825257635680048696075527563498604714157576447,2638669099010916296300870639816763122907432841565512299246441500223692345671,7150832464835357604208338666096132398994318721877322228060899549998179405057,5470477812928960639347760417261508685840724903499112719517942324191018679706,1063854480993555660259858748055514950231824974684462401269695511649059715242,14508243449586598349750829047481358081191713699373322296041764577478835760927,14872220983064543437506211589956319796231014912750035729896461676577407407598,9523202653584689553554068772241228948237208444616905879849472383190180438058,10557133197819890801524243760013157188954914093770589635201319240903423455316,4973822148190287060777561091733583032026446820262414806412485028147721872972,12017319043066808147670914562193696608548297038020764496633388575589573229927,20958507279974171556413354796214800332148109902768069171659933168603089927180,16142225389165963605704721785850680620029805525816101628767304750729950332962,21691255103889531967215183091383836488808797368461467004501598817850515277674,13360009791215314413428942977255018953699328534302248245107197249816193370823,5270206696221786165451075835596925139630328202641350960582852969440862939023,2626561181956261201864606929566987806068271006198808163435823619705436605447,5520368836328496672510351296660387187466158872913871354651108826881774455909,21597143280250120305740582323272730661347349587666707484376745221123282421748,5891209530846741397700015863630938364586207627850850447237189083999656313978,1202436381171550812585103405636986166232789491390007497511342220946215395818,9920320882147650877649039705433660083926352954797066179512349368247190410310]
+        [
+            0xe1962c232fd0a6bb54ad8962a82b9838cfef19d290a55fc49d6debd061cd2f6,
+            0x1e1f45cff3e74168accd0a94536fca6317128953eb47d8d2d79b847b355cf51,
+            0x1367eec3b20cb74953618fd9261047755ef7f8aae5ffe96fc8f7d9a02e37bd1a,
+            0x2ff6ad40533afa2acb78c9b91650d7ccbd274b09f78c100479f3a4d72956d706,
+            0x152c8c3d9e43d90ad8094831a74af8151fdcda0b18d7bd8374ffda68d1a5fc71,
+            0x241707db26f96df502364d26712c7f465d0ac5597a309559b075406351a20977,
+            0x15a4e4728a197dae6303d0cdd2b6d1e4114a9fad38a530bca6fd06ca1ffc1f56,
+            0xcbfd63f363978c387d656e93f11e336987a68748c8f54f385887e64b1075598,
+            0x1fb594474b8334f9aea6fe5e323fb0e0ac27d2895921ac64e93e524e4ffd25c4,
+            0x5ac55361da931c1b4c560aa8dbabc8624ba225871bce224addb5af901676aeb,
+            0xe7266f909395b5d42ec298ad3eb73f6c11149f491164f997ea76b64282b9af5,
+            0x1d928ce916ec0178a2c0d8a890af90468c8af68c4c128c68f042cad51c6d7895,
+            0x11521e378f229844263410fe44628fca9ffad17eae9965dee900ef14a4d2d6d2,
+            0x23f3ea3b55ad3710a0052d7a4b9c9a65456ef71bc4eb16c1e908034b3cd3b2d0,
+            0xd4f972e795bbca8623bb08503764a90e4384be644f57b4a56f1e7e1548922bf,
+            0x2a53e60ecb9c00dd99692d57d7a54d893934468203995267e83954859d21b595,
+            0x18583bb0a83ad2e710369475bd54ae1d821d75a9e1e870df11c154f41be1a632,
+            0xd45688dc986f78e71c463b76ed2c056881c76dc552ccf8d3a1d795d7682efb2,
+            0x1448256830ab79d2618c6ebc5af5624fd064e2a16194e5a0c35c76fcb094d371,
+            0xc0c7912bf67c273baae265c68f378a3fc06eed7778ba6ad3181428bd55a148a,
+            0x900cfc715edb109d3e6c02b7a578326f57efeb3da6f58e64792dca3452a55f9,
+            0xb84b851d9d0d621eb2872fd75b848ad6a905911a988b46a3d0d70d264c8790a,
+            0x69b8105bc60bee13097c0fb14d05a1b932d37db703f6ff557675bfbbda8a5b0,
+            0xa0ad082a6226840334524022e1d3c7168423449df9c2ffcb44cd9d4d2302325,
+            0x18c350500a7bb9fecc04b286ee0ebe76cf71281b4463dbbcf8e266221817d32c,
+            0x2da317c459c0b0d973e04bcca9c112726c7618ce9760c2228c308b7433d907a0,
+            0x232a07d1aef79c1113e3ffe7094ac379cd67c41981b9dbd30dc691eddeddbc6f,
+            0x6f8ebb8cb046c0aa7ea795744cefbc827e5727dd16d0f27675d99f8964492ca,
+            0x10db78837d0652586afa0666b721e1c94180173183300992c4602c8c1c415478,
+            0x12f5fb7778fb2b8e1b5ec306d3d8f2a497ee4e9aa5bf1924a694d04cadd5c526,
+            0xf6a94bf66121d5993932988636d0aa2479e0299aff2cea5b7efc311a15007d,
+            0x18b818a1c250d6f8b77870c1ef5942250214655460e4b5aa09c8066489041732,
+            0xd25185fdb4a3c65e05963b80310584f2a6069c2c0b07ab2b6df2d04bea0f52a,
+            0x63666f719c9dacd3ff39599926802bd9e07c61050b10ee79adf0da04c59e8e2,
+            0x25f9e2e4766cf4b7bf91a63f7dbe954b2ffa4cee7269933134b5309eaf9d702e,
+            0x1237a2bfe7efc853fc4e9c4fb84d8e7c56b125286d8bc81a5434c6d8737206d3,
+            0x149b17921a60f02551a03ebdd0a3a71f7048d0f9f47893075c625341ae06159,
+            0x21e129ee052da457e94cbdc1ac5738ab300aabb76a3cc3c23637cb6221874630,
+            0xffbccf818cccf47beddf8558b8242c90e41fb603f137b02f0774228d6978d94,
+            0x13018c64072bda036ce65310501ef57816d397a9eba56f87b56024bac5ebe9e6,
+            0x1b009f2e8abc03f498fdb84857c2091bbb0095778f990fe799d0f2c97e2c2670,
+            0x101546fdb71f32991c1180cc07eaecf47920cd0704691e555b3bc44de5c5289f,
+            0x1d1f66a2ec0621f229c3f8cc7b153683d993e220ec5a1f01d42a14db46a785c7,
+            0xc0d0d8c79f76f62eb8ea785853ee6aeaac59256172a14479d34101dc8e63ad0,
+            0xa3f038a5f37073c1ea7a4edfc1dcb60859c1218e1fb611ba59dd245399c9572,
+            0xb7e89abaf697afea2ab793f7cbc3e807dba45231d4fbe6b657a95f03f1b1705,
+            0x91c47a22bfbe8cc067f70019ea1a2eaa9b381fdf90ffa8971b247812b977f6c,
+            0x23502619e347553b5bbd886ba0ebaf4b63c07c289da07b0c7728fbd6092241d1,
+            0x2f5d5281749be90119354e751ea126e578ccc43a4c372d67ae66d87c0c01336b,
+            0x1ce6855b5db80c42971cc52c9c35275e8bfc7705684a391bce4151ad9fcd9be7,
+            0x4f03f23505d6e117603510ef25bf46de44b95506011b5642b120b76c4a7a277,
+            0x2f0f36a6ecd8f53af95b4b9514997ae0a208d89e974bd3359dd98fe2e2b3d41,
+            0x1cf3c4ff9ab589d0a5660b86b5fdf8f38ec3ca5e92c445bd4cfbe6c70de64929,
+            0xd907e14510611fc14612e406616cfcc0b3b1258278d802a5a3d7dd785284e63,
+            0x148575fd984cf84d0f3dbb49564b397c17ac817e6ffe348881321ce76e35c44,
+            0x13c32c26889cbbfaaf4d1f25e64bcb720e1cca45312f90fbdea8435d9e6729af,
+            0x2f28f702d684198114e721efafb6922c3a42dd08fbb1fd6831902df4b55a6a96,
+            0x5fd91ec054800f61ee128bbcbe332ec4c4eb25bc57781c436c931d5a44b6367,
+            0x2a07137e0211d40057d39d707b177cb576f3399b29b9a7019c3dfc7d7a22d27c,
+            0x1b9592c1a0852470e5fa045d32725f7ce17982505aa3317a7daa6cb31e3e359c,
+            0xcfd305387cda42a1f5a8e00a0ef5286e0504738073dcc8713a43c2439c170c1,
+            0x2e10c62b1b5566b5047f18279f4680073494290584c69708553c7729b6a04da9,
+            0x2bb1653a56221c6263b0c62ab8a0a773d225b414a984994b6d3d5afd0892e67d,
+            0xf270ab89bd220ddf62f18fdf8d278f678379e7b616006a8bead9fac9f473c70,
+            0xa1301e2c189208513673b88d6b3238759488f79b99a79dd11d0bd1c973b95a6,
+            0x24cb02fc34a8ce75eecf534184d7373b7e1c90fb5f7e24fbe8ec8ea1ef54e393,
+            0x1603165537fda2e431b75d03df01dee7b39fd851a472243dcebc2c96d0deff54,
+            0x287166d87790f5cf540ecffb1bf65acdaf18cc46a4f1164b5bc0778022e11a18,
+            0x2a81c998baf847bbb21f7b7141efe84f7ac56a834c7967ea6f45429fa2fb1a5,
+            0x20c95c47c2ce176a500fc18e5b798ebf4df4eabeba1d695fe217e003ac2f0e10,
+            0x54cfe239b46d49baf4568088a72b2bfed0773be27f6e7e9a2c02bbb1ffa515b,
+            0x8774564392fba9a0289bd2012b509bcc7b126d9ef3378da0769d8af37cb44c7,
+            0x24a7f216983732c11ad301538184100e2cb090742dd81c09783918404f1c7538,
+            0xfafa523ca9deb758cc5c0f54e485919a3b1c6caab6f322a36b014821c74645c,
+            0xc8b11f331a17d83848b10efb6f8716baa92e649d9ee1c9584b334d0378b5318,
+            0x2fe8b8a523a08c2e5ea7600b7876fa4b75938fd56c03c74ee2b60b9d1e8299a,
+            0x1d039ad8acc6c9515c4b4a78f1b8a85784c287d5fa0eccef43901435c1c41942,
+            0x1b89217c5104374c0b74a3a3ee0971ca583f59d0980c37566ef8ef363b1a417a,
+            0x228b4d065bd84d6104e3828caed06fe9aa11d7dd8ea90efefc28489330674b2d,
+            0x1d57f64ca6fb25d9a4b65736683dc6f8f90b4d5594fcffd6034443e98733af72,
+            0x11ece5bbbbb611968ad64b52d89d7ae5d1eebc4169217e07b99dfdfea0fb69d8,
+            0x21ca2fb7b186974b4bb67f95f943a07adf662eb02c7392d9f5e7526764e7b986,
+            0x1f47138d833b0c8cf6294ef77d0ebede94ea57a28ac0a3e64bcb5df91320f10a,
+            0xb95be5cad31b06ca97ca74289d89772aab0e8007d0558228d88f11364a1496c,
+            0x794a48d6d0201d4b3af86c0fcd5479391f98f75623105f3e266dde215d76157,
+            0x2455a03e833b1dafa17f29a71fd76f94d8c5d09fa1fb1665373d509a88f3763e,
+            0x799ea93d781c35dea4b487f9849ff1800f1b63cc97842e2fde69f547bb76763,
+            0x28fd070e349d506942cc217a50064cfb2e3ebbd3cde16c09fd68b7e4eab1b822,
+            0x1cf5001c9cfcee852fcb9f8d89e19e336dba95bec545410f4435b5b01f4b80d3,
+            0x8edfc4e49ac404861074e34237a1b124e4d8e5d6ccde29d1ee9c043756c44f4,
+            0x2ee5b6524289cdd37ce4ccc8dd19e94cd2ee72ff264b468044bda8227b110dfc,
+            0x2775a93e2b3eef8dc0bf9bd322e5f14281eb5bbbff98cf7ad93d35f4c4392624,
+            0x4c564ee74a1199444d3dc4261e90b1886d760a7fa68ebaeeb5b5e353684e24b,
+            0x25ffe7b20eaee8f694fa81039440b5c63eca1cac712f5e3b21af1b9a7be117ad,
+            0x14a1035368093069b2a4337027fa695e985b6e56ca818ff944780c1677a836aa,
+            0xfd53ab1fc6def97651d2d66d0f58976b39d07db8c4c9ac195db0dab73060274,
+            0x16476bc3bc364193912051b64c939c0001e95953c76f7a748957d78ccc881040,
+            0xc5a52339fd84b1ecac4a163b36d41941a156f53b2559061602e64d2dd031039,
+            0x21b63c30dc0baf2b71ee86b7d5c91da1c17cdcebe5a0a0e5f2c8446584e05c20,
+            0x1bccca220986d8fc3d22391a70bfba575a47b4f83230652e1772e2dcd1a06ed6,
+            0x162a9696d6df2a13038e0bc6da2f52239951a204bd05a9e2a09066cf6b13a6bf,
+            0x1d661af4be59bd53da92acdf5736a7dce50da796c393b4e43001d27f88d58d6f,
+            0x1fb43feff48b0a4e5ac9b17a6c93e241f17b5dfc76523b65dc366bc04c9f06b,
+            0x1e70af5d289fea2ef26141246e9635fd007be3c3d755abf3bbcda9c4e4a600b1,
+            0x148928433fc03d3a878b420efc8954f04fdd4958bc822a6123df1d4d15d02dfa,
+            0x61b30453d8edaeb5a0e7a3a9f951a7211a50fc360903c4b25a51e4e36dc434a,
+            0xacad4bf22e14bf31537f39286d25fb493fe67f163bddebc3e94de911a9556f1,
+            0x5a4dc602f73e13984177dc0a6f2d7af269988f872b817c837c8559c79b03819,
+            0x1d1f813dca1d8f54d73441c814ccb0e84beae8ef4463effb612eb6ad131cf05f,
+            0xe82c3574b61d4c239a3024d6822bfa186d5989ba1ae0597092560e8694ad9ab,
+            0x17ea9ef9ef7da806c992916b2409a277fff09d36339cbfdf4687606793fdee9d,
+            0x19454e5c7ffa9716bd1db5d707d4d24b909f4c718137ebb73a9661ef41a7ce44,
+            0xaf8dccfbedea2064586771a23ac776db9ac4df3787fdf857db4a2193e934a3b,
+            0x2748872a6ad3a07b30161ae37440d5dda279a12cc2ffe14747bf9082e72630e2,
+            0x1a529a39f6519dcdfe38e311c7b0f661550e388870772650e1ce02135bdae984,
+            0x8a57affe13513b3bb19680381a17f82101be9f5ac7be0cf9c7e61f710e63892,
+            0x200d13b0170c124a25026f780273c4f557a3e95cbd68684e4e4df5ec00610f60,
+            0x14c79a357f53469f91d01f4432b728551db863ab232525c2d95cf616f7a098d8,
+            0xc513fd43af43ec6c905092c6d5d50aac833f144b9630e99483a83c3402f4832,
+            0xab802177b395f6b6ad3dc7d1995f60eddb63e9c378a75247a08002d2986482f,
+            0x589d228f316da74fbd8f0806ba45fcc1f31dc452e37430050bd9cb8f3e0acc,
+            0x1b46df6f8889fd075b585d61925fe1f08d15900074bce706ea5fb211dcc63d43,
+            0x1d2b938132acf70f122b64ae172ec1a822ecbde5a188b478e789c5c3e91cefa1,
+            0x2308c203544d162d54a4b87d92102ef85cbbf1ab4c3c02d6642af038730333da,
+            0x2eb7379bd69996d813136c99c2e66f45ca467bcdfae03a315cfe39ea99eeda3a,
+            0xcbcf8be09e77a9b7004faa49c560e84077038326398196c04f948d09ac57388,
+            0x72ed6973242f117e5fc1c344d9bc38d5fb3e94bcc02f48843a057e19bacc917,
+            0x6670c3a568d7efb7f10eaebd727e7a424a5e2b40d7201fb66d0b74723081ee4,
+            0x1e2105cd356ebeaaa12233233a2a22e0524c822b84fbb368b409d448192ef9d7,
+            0x10f3092cb126d913e829eb1e09cef850812658485e5ac06c140bd1b549f53907,
+            0x2bcf1b9917cb73d1856ae5dad349ff08660e800a5b69a959add19af6558884c4,
+            0x7bfcd988feeabe2fbe03ae71408c1a394daf2943c8d32e41f6b72f2493bfae,
+            0x2a977dd5735a9110178e2bb0989c7129bab2c6f9276ff1a9c4b3867a115b815d,
+            0x229f01e653f7b280153de1f8d4e9eaa0e18e81c3ddfe9cf0f5185b63dcf8f3ae,
+            0x272ebef10616ab9c79e34eff00b0faea7521fcea55df526bdc9e342592da9469,
+            0x2c8a5085170dc8e626fd9f5f1186f99763976ea6ac08c253d025fb46e1526c7,
+            0x2b77b7c7f7b862b6bd45b894af1cd1cca444f426d63571ffe6d57e608f12441c,
+            0x1518209639e513d5623184871ccc1a02e82536b68d48395774930dbd4f130ddd,
+            0x2417244fc99acce8d1da6685df7e33876bda3dd632cd684242a60d54555b0ef4,
+            0x12dbd5616e93afff056e7402afb361f5753ed668d6ded08cc8be3febe58ae3d1    
+        ],
+        [
+            [
+                0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+                0x1abb95b6e33243a050e563b5c4fd059de5513ec28994a6f60e57c98d3bc8f586,
+                0x110d213a836478aa301bc1fd4edd388507d87745b3abfba5bf282afd21f7242a,
+                0x18edb2d105bb53b768ae0137850dc2d2bf6d1303a1f8ee4aadf76d8f81990588,
+                0x1e53e92df6c53ecec4c0de5b07dc4c9a0c5545f2abcc1fabf4ccb84a0a6e2c27,
+                0x10fcb817e10f69f7074e64c393b807cdddf33c84a8b5cfe33f44b73fe18c0e36,
+                0x2b1d8c11fc652c593543b6f9800bb7d0c9371dedb96f08bbbccffdc6cc44db98,
+                0x19f473e40c05676d5f8d51e11336e9c65cb32828c397cc8125f1dc667b6cadf7,
+                0xfcf3a4d9c6c3392de1bdfe25cfb86817ecb80c51be17d47f79750201f1fcd01,
+                0x23b02d00fe2634889673a7d04736fe15b9f62652b1c0626a19af8d6085d70822
+            ],
+            [
+                0x2fe429db8068e61b82624f25766273cd9fe6368ff097eab97aaa09be4c630e27,
+                0xa5b604c958bc90071ad10618b1772599e0c8dddfb641131fef39daa58a39923,
+                0x2cdee0c635a4fcd9549f0f91b4f4a9b628aa7319e2eaa094a693b38b5cf9a242,
+                0x2c962d7d54a98c3a82a638d8c82450813f42071a17c6c05f470b44958f57ef15,
+                0x2bc761185f59efb7b67bcf1d3e54da00daea067fe49e3f1d9334e5470438b454,
+                0x2e450d1fe7773c9889a0be55e44453bcc844c94b56fc0bb806eb9982ac553428,
+                0x25c0f87c946f375e341f72f6a8dd63a94e86f4ad182715bcfcbf2b28df6b4a0d,
+                0xbfe6fc08e2a2e1b8911ae065b985388fcd105a490a4ab943b25558cf3d054b6,
+                0xc182e438257c4ad7e7b79c3b68d60984e507ac597cb47dc31d913a7a540fd9a,
+                0x2ff4d0b8798a82667793533730083c25223d589cdd079362f1e8c2e01d54476a
+            ],
+            [
+                0x2e750867942439083365d21fe760c7dfec9e3593c67de12a4255c6b01648b690,
+                0x24e82df5873953792baca345b7c19f61039adeb1190592bca18cf4f907c1a6fe,
+                0xd60f0585755d48577b465746de8e286e49925150f1784f29fb6b96dbd8f0ec,
+                0x1f495e93014314988dace5e4e867f5109e09fa00fce87929d1e0ece95a449345,
+                0x124331e0ecb1d9808a1d91efaa98950abe930c46fee5a30d5ad07976a5bc0263,
+                0x2f421fcf54d77dd38930cd69076f9baadd3d3f1947371215a66c894d637e89b9,
+                0x543b2bc66f3b2d93d4c1882039ddb37c70c0b437ac23ac5bb9868e6df24485e,
+                0x203d9ee6462a586914fe7dbfc1bfa29773b7f9b3d63aea4120c601129c16660f,
+                0x25a1ecbd7e7893f646f35d3e07ee997c94354737884fe6c26ae8155760db8aa,
+                0x1d897f60e87fce5ceed8da7f2f4a63fdee7ff9dcf179c08e05e9e5cdd8238ac7
+            ],
+            [
+                0x23237985a96b177ff7c01486ab0d603d29991b8324abd6b07dbb96f5c21ba17f,
+                0x10e3349eefd3a112417e110fd9e832078e54b5f4537cd018aee3dfbb90541581,
+                0x2168dcf216d8369a626ccc61453236a389d02519f3052e87eff9ccb8aa299c46,
+                0x262903f36acf0dc055f610397df0794fbc30927ef185c6356bc33e5c31faef9f,
+                0x46887724f29321895c2ef8bc0cf545df773c04baa097c352a4165395cca786,
+                0x13276081db012d1d4f4b7dd2d8a2f8a5180d2ecc33854cdd35f9ceb07bf40d53,
+                0x2dd117218538e8acb0301eb40adfa2435f5bffa8028ff52f96a99d77fe927066,
+                0x1b912abf2e1649ad4834ca5b2a3831cc9c207d4d08e4bf274a79dca80e52fe24,
+                0x20135ff263867f708ee0275170cc9788689c088b2933a361c775cf430748ef1f,
+                0xba6d4ceee2182d3f2ab2e4a3ad08fc31f7f4cc0fec91ad53e92bf8ada3e278f
+            ],
+            [
+                0x15ccec857b25934ffd429af92c910db31d00dc1c3fb83745a31d8131ea5baa85,
+                0x165adebe00c7ba019499018c96f5c5870eca5679c90c843d9527184a525fcca0,
+                0x3530dd962ef23dc16f79b28c1fc1ddafe9458be15174cbbbf3a806de5f63cef,
+                0x1b7e922b3dd503e6441ada966c8b3ba7b908cb2b98b5fbe1e4c2fb982455baa2,
+                0x247460ad4580a18639eada69b904c91b19f7d4387435707696c40bac3bfbdd33,
+                0x144d5be38d44c5bf8f3c5735334fb1a07c13702d86af39ba0b4220ec9a7568a2,
+                0x269b06b31e89ff132daebc200efdc8ab068136fce65f2fc55a1dcb939b7fc6f5,
+                0x62caa3c9fd39b69864faf701dc8a4588571cb31bfd5c9c3c59dfd97e99f701a,
+                0x20e160f772998a2f7d0064c7efa15884ebc6d8b71821cd5336e2df14341c95ee,
+                0x5ce94b8e9a60b28947710461d87c7757246266ae8fa5d3af3ea81776b5b8c07
+            ],
+            [
+                0x17102ad2d98043e5509e76c331e6b22d5fb62d074760806aa675764660eb56d2,
+                0x1fb81218feeedf4e7e0e33dd8ecbe62d65c6b7d4233f32e073571ff862d89c3,
+                0x1cedc6d4e1476741c1099557e58e642c42892aa36e2d0a793f670781a21b0dbd,
+                0x1a88ae2fde12ba32e5f4eccacf11c25bc163bdedaaa8824474cae5869e5ec20f,
+                0x265412a4e3b5560aba502d20ed833deff707b7d425ba3c09f3b6392b6f1f4339,
+                0x12691b599d32edc48ae99c7a73abd59e5b18f4bf773fa1051cabd2c49aaabf6b,
+                0x20d4401cbbf92877ecf616d7d28551cb0aec552fae9518dcf9218c38c1a0bc90,
+                0x138c03a2ecea183cb8f265eecd7e93275b0bb98297c1545a72197dc6ddd9335f,
+                0x150df11291b680e3ba925a0471c7fbb30e704ab4b554ea5d8c07b70b2b96202a,
+                0xc346b046af03cb9048c29353e1107d6b75e590bb2d422ea83c09a5da1ba0c65
+            ],
+            [
+                0xa4ecaabde9d1ea11c81dafa8d5d4869bee7ad0bf4eb78397b71b8f989cf9812,
+                0x1be2802fbea51003aafae82ff4499d1158377b108f8b020c82b8460a8d603afa,
+                0x269c8c139a4f61e16bfaae9e8bbb1c69808c9071083b0a339dff9e4904b443d6,
+                0x23407728269c70fe712b021915059dc8dc2124ae648e2cb549fc76362bc2b97d,
+                0x2ad06fc9f81684542e0458aae19c0a7c18be94f1de3fce6a3e5d2335a01e90e,
+                0x578a55f0fda29909b9f850c3d74be6668e4444ac691764f1644a626498218e4,
+                0x2ee2da24b7f8e7035fb73b08c3414833ffa38e14b1faac198a860a5767d2feed,
+                0x11589959fc2493292fb6c50730e74994ad7cd6d3533c3b00a57dae833cc701e5,
+                0x17572029e8e897202d0e65c2172c571d4b91ca856e7ad3f118ad922127b87054,
+                0x2fbf8cc6ec7efb30106423f2e67b0aa9403360e56e88b6c5cbaec34a80bdc7f4
+            ],
+            [
+                0xec1821648fddc448a1512aecc8ac37714923981940f5542737a468d4d887c8f,
+                0x418081de8c2958355a1e45e28ee51ba2c66cad04835f4fbd81e696de6398769,
+                0xea7bc52503e2039d277912e022fd6d0ded5bc687c6ff97194976f3a28bd30c6,
+                0x12ab318626d511c23d28baa9fb5b5802e0ab95e3cb17aedbaa25f4d084cfda57,
+                0xd1e34192343d66fc1b6591cb6a3b0602b0835a403c7227dbcbd72fd8000c6f2,
+                0x12e3b04924b2cf6e407bd26b3cd47bca61d6ffcf7efa1aea1c2e0d8a49de64be,
+                0x6dd89fabf92546847b9c13b3a36bbc7e679c5bb0dd785403f3ff49bbe61c8e7,
+                0x17b9facdbe747d7c5163ca00e3b0b825d012ed4357604e7185750d677c6b357f,
+                0xaff15650b805bff6f8b3515d5e29cf914b7349af8924e796009f8a4f1b7264c,
+                0xd064e72449efc11d1e90b97749de3909490b912bb1f72f542f41d62ab2d847a
+            ],
+            [
+                0x255a493aa4becd9d137eb76941c4120784c1233f6c5fdf5d65c0832af543e415,
+                0x1f3e937ab29f3a88c6fe438698a7198a5209aa6ac9f141319f3bb201e7fd6716,
+                0x2180b9eb156eb33cad1aa750ea0fa3ddbfa4127296e497f86e6441e052a23b45,
+                0x1cc69d8f34ee877838950e20a9d4c4bd3e9acaf3d693aa64cae04faa225a2e1e,
+                0xb565179887ee30e381631d8e5dd357c70ee2ebb410617d2321f6d8537f98970,
+                0x1162a56ed3bbbb4b6760a16a300ba7202130086da4d5588a70926423ff8c242f,
+                0x1360f719034572b59410c529b62a62aa94565654597e42779f33400f1d17d652,
+                0xc603d03f92860da8a68c6dcb1924d1a45099aea50f1a362edb2f2a7ddfe90ff,
+                0x1a918fc117d9a6445e363ee5833dc01411034b95384d98eee47ae896f92a7d67,
+                0x2a88e0c35617665f3cc2fc77d90afc7a8d1001c71debcf2733ca0c71a19e1ea
+            ],
+            [
+                0x120f44670301b1435249294d9833d59e01682af4c8658719727678fd9ab7ef2e,
+                0x113e968769b0ea32cb7b5ff70484aacc96f13dc2827a8e5e611695e0797fc3c,
+                0x18cd1471430adad31e45b529494fc8a7e319bd2fc0619c99207dfacdb657bbf7,
+                0x23d0fa965e920dfc530b52670b1e32e2d5fc2821fc918c0844a003b7141825ad,
+                0x2ea6b32af37cd765d728ddefa30918902a21e19b291400854f56393c56d69460,
+                0x3340cacb04d5a85614eacc4be3352938baa3fc714c2575aa9d85f739113c50b,
+                0x15ff827e034c02a90767f0152840e7fc6db983e496ea0519c0ff41dea8180628,
+                0x5d56f0c844d169248503135e4deb9ffd6329d54cfceed4b947d78a568681147,
+                0x2e5618411efea30cc7de310d4872597d087c1e122e02ebb117db0c2dff04fc0c,
+                0x15eeb3e0541bcf010da0c47adb12f6df540b974d439c93e19ea4d02f9975d446
+            ]
+        ],
+        [
+[
+0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+0x2376caeace68ac7d5504c33a2219f5c7c5ad25784cea62a8df008c4fcab50d07,
+0x11738aa054dba194b2e82013feb222a4257eaec8a01f131fc657ee766f408d04,
+0x22683ac3c69cb11bc0879ea8b2a5c88aecb222d25c68a660a2f4999cde166655,
+0x713c79d90ea4f0449b01031fb6149994fc9b764fa494a3b0bbaea522d4e48d3,
+0xc372107400e1f8f8e93964c84da46d78197aa045614a1dd700f1dce65779437,
+0x5abac870bca413db4ef84c71b44676ff7e7c741c9b5e3f3c8efaa73e446c02c,
+0x11c5eb9e0e5c1669df902352e35eff4517033d2a2a946a8e5fd1492a3a141229,
+0x20caf8e87737232b8c429d7f8e9c9827cd7fca92cbc159a319567e646480c7ca,
+0x185ebe5ac788074f48748c8b4f66564a581e615b3df9c78fc5ddb70b80475d3
+],
+[
+0x2fe429db8068e61b82624f25766273cd9fe6368ff097eab97aaa09be4c630e27,
+0x1b1d1d024385e8a3b81c435ef9079a52dcec3cf811253a83325e7432443ec02a,
+0xa5f2f19c49d9ae6d6d8acab3a944b93221a074e7a84939dead82506063120ea,
+0xba8903c5a36e9ed67d21b2297f06616760d8beb3ef96c69dc9c843bf52a3015,
+0x2a850b071614649f6e6ea4c4382d7aa9981736848c3bdc0cebccf3bd795c65dd,
+0x20090c8c6b2e41e84178c0700c9f81b1e128b15f65806648c6166ca8769ab30a,
+0x1f9c5c5cd58a682a6155b2db3923cacc1944362035acb2eef2b421fe5bd91f44,
+0x2a2190daf9de7f46b5c80235a0a468c68226c193ff86cc8a6ffaa7033626d093,
+0x2dab478180d47e197cc91da2f1ff30bc0fb35da934ba38c8e5587e005cdc2f05,
+0xc38b0564f60610324268079496ce366271d5693ed6646a6470acef4e779aac7
+],
+[
+0x2e750867942439083365d21fe760c7dfec9e3593c67de12a4255c6b01648b690,
+0x77d21c1db0df5aefc4a82442165dc0c6671bf7c8ae708c8f9b6d44b033f2139,
+0x1b974a1b3977e8bf679394da2b702e724d2fde8aa4e60b83c631de610d1eeb30,
+0x12f77c314190ff649ec4a608780c3ef7bd065902802f2bd41a93a0666fb8a90b,
+0x7626c698acdc1e4ec6fd26aa192bb334d96a0f3935e5a88a8d7abfbdade4f03,
+0x269aa03a5af8a48e20ba3147943c07e1d1ac7760edad58d9d03d0f45157935d1,
+0x45f5c794d9706b43bd71f2a4d4f376bcbb76c7276da8fa942eb766955c53efa,
+0x6ff77c4c464330deed91103d652330809d17045c75cca24e8b1b0a61d572af1,
+0x29e529381ccf3f80fc5d54b7c39adfff8c2ebb5dfb86745cb974a21e9467455,
+0x6b50f490125ae0bc287d018d60c4d6752ea3f61ad3e939622c1773df67a7f4a
+],
+[
+0x23237985a96b177ff7c01486ab0d603d29991b8324abd6b07dbb96f5c21ba17f,
+0x2b9c40e97f4e7e6eaf4d342b420fcae7bfdebc3460c120b7a4b99240ea0db532,
+0xddfa16097871dbb1337b5ed7ae8d2bca1e5ba44e482df13dc7ad593ef27a5bb,
+0x165e20a2a8ea0382f56df39ade0accaab08fd9db8a7657b74ee54b114393aeef,
+0x174b9be8f359863993e57e21e4c6fbd4b4a4d339d943ede1d85255ee48b3ffa0,
+0x304b87fcdd673ea0ae58bba75c29249f964913b2170aa9f23d4d03894208ed87,
+0x278ec34449ad1c5182395a44f2826314db9fafa533e518a5bf082096c2484918,
+0x301cbe6e44e903ab193531261770925dacc71b88207e18f793f59f69a4347771,
+0x20334328490fd8682bd47066200b77f9509a72a11f2d91d456220c629280aa44,
+0x2301d3af42d47b43c8a8052646c069e046ee7d180c62a5d36e52dd6f215bf37d
+],
+[
+0x15ccec857b25934ffd429af92c910db31d00dc1c3fb83745a31d8131ea5baa85,
+0x2655c9fd294d40b9dbb9566609c264c9e602c777c8701b1b2b542a5f08cf976d,
+0x29898ad417130c472e0c1da3b017f7166e3a3eb80481efa32503e81a3772e5e7,
+0x1681ed2917381cd1217a0c9a2f675353982a438cb3e9108fa5b2048e6b7e32de,
+0xdc075092f8f83009ee73cd35e511ac13eedf5e3999f9bf5b41ef3e1a15a8fcd,
+0x837fd755c29dc2c29036c497fcdfc23f95c7bffb90a62db5cc43a25e20054c2,
+0x19d489fa1fa1ec6441b82b735dbf0b84788c542263d4c1ae5335e49297ed4bcd,
+0xeb25d1b0322624190db666759db3c82bc9718a990288d865116787e8c527351,
+0x19084cece4945482947cfe51a1f6f4e2e216f5b54742b9d71cc3840bdcbbaabd,
+0x3a99be2c75989dccb246bf31a58f88dfc494ce2569c5d8b18a9a876317ecef0
+],
+[
+0x17102ad2d98043e5509e76c331e6b22d5fb62d074760806aa675764660eb56d2,
+0x795d5914d87c0dc8fbaedfd46afdd6451258f80779112edfcdf1a71d23af4df,
+0x2c202548a326cadc3ee595a16a2c2d54ada779390f7bdd4c4fc9417d3e463d03,
+0x181db647369841eb58ceb7a1b9ef841a7f3358cc6f224152dc7ad3c1d3b1c1e8,
+0x26e7aa2ef4c91ee3f704849f4c181fb83b860da15f62f2250c792e0ee66c0ae6,
+0x17189249537630e942f5ac39c1498bce39996c15400d052dcb6cb839aa45322,
+0x23bb4a76f79b77f9f6b4940ef2538c7d60d69f1fe9922d66cfb92af9dcd0867a,
+0x1ab80a8b5fbd7923f0cf79707d56f7677d1071e924cb497486766a4c4bd7f6d0,
+0x1f8f4c40a0cfe0d05603433a0ed2d424c7fd040077b0a1642c25797c20d22d16,
+0x29177f698bc5a897ef9aa6b915189f689efcfd88f3da8e60b84b9bccc2ae33b7
+],
+[
+0xa4ecaabde9d1ea11c81dafa8d5d4869bee7ad0bf4eb78397b71b8f989cf9812,
+0xc066f7a1e10d00fd3e97cd8c67212c28b43423b03ca4ac03efb4d8a376ae098,
+0x1a6947c4e87ca0c30ed9f47004e53b7a45455b14da41f79045c2405d2e3cb859,
+0x2481ff49ed6259def9fa646c167c8864061c04cfc022051f83ef8a3ef8db5819,
+0xc13692adcb86437a860d6296d74b4253e790cae6f41683b99c1760d09921d37,
+0x27a6be35c45e5f46b2eca0aedd98f67638b6645acecf50351c5a9f3c428b0e27,
+0x4660af4e63d1c9ff6f059b75dd870df938980e43985c5607a38dc0ac8d273f2,
+0x2eb8302f1381d9118d9c713d50e117f92837dca8a8610e9de759e76e8ee987f9,
+0xe9f931dd923dc4398ac12b101aa7b5e2a22f09caa416ff8745821ff165b07c,
+0x209945fe475f6767f668abc045e0c47ae6cb25cdb1efd5586da6c4e655d68e82
+],
+[
+0xec1821648fddc448a1512aecc8ac37714923981940f5542737a468d4d887c8f,
+0x1049076d8dd43ffc6f4ea10a82dcd60dcf4d60a2125a1b4d8c4ff954e7da3380,
+0x192a1bc8e7dd6203116a0c40d58111850edd5b50f9d6e882d16f95fa6a76d80d,
+0x1beae2daa2a697afd9b1388dbcd6c93731fbb4eaa0fa439f92bf777769055293,
+0x1a31b8769a838df03348e01462b564e08849955efb968d1f41342f02fd627de0,
+0x12f1bd9058590ca45a76e19b5891f5bfdc95d653394adb4f32090c60505de408,
+0xaac3c820280c7658321df7aaf69274032fccd21be96174582a8c0c9de580068,
+0x7c216183f03a4b7c77070c68b3790b31b5fa6d1df5ae42437b6a2283d5b8891,
+0xda9d210a43aae4d13625782341ece1d0221bd6ee0dc4a639b7f13a6daa3c93f,
+0xc0d8ee0a08021baca7a5799ed7b03734e4b9bd35430279d3f7b2ed473c48c6e
+],
+[
+0x255a493aa4becd9d137eb76941c4120784c1233f6c5fdf5d65c0832af543e415,
+0x19a05dc5bdf1243b57474519b375ba67bd83e122b095e4272c14f9646e733666,
+0xdd31347136b2eba27f0528eae1c25a710c3707bde9dff3d76ecbe33f188bb02,
+0x248cdf26597e0746d01d8b7ab0e9f88aa452d90eeb039dbaf586563945972fae,
+0x25718cec512fa137f8a5851510caee0dd2c000af55af09dee767e2084796a71b,
+0x23688bbb9cf13bb7bb972d0d18d0e05c51bff96ba5314bef0af2d912dc5e8d1d,
+0x1ee8c54669e6f0ab1fb6a54c809d1fad213e8ffb7a7b40387ef594b7cf50f4f5,
+0x282e578ad2799ca36191b37835889bca6e2e8bdf7e4412628bed5e39885d688e,
+0x831616989168d514c0fa151fc3874b8cedcf88d27185e7e037cbe93391022e7,
+0xbc5380f3490175b28f01eb5cea3914924df2b1f745d33a9e39ab872b19c4fb5
+],
+[
+0x120f44670301b1435249294d9833d59e01682af4c8658719727678fd9ab7ef2e,
+0x2a25bac660d90d85f22fe81abdc80c403a86e75d4f1434ba2eda3184dc5f2833,
+0x2d19334d3eb5a9781f3b8105b0b1131ee95d4012e7faacf71864762b6fcc7011,
+0x267b655f26896341492acd89edc7ae96dbcc24161d1e73ac652ea55d61efc3e3,
+0x1d9c8ad973feacddad16da2be2ed7eca235b3bda01521da956f1c8a7d65ea58c,
+0x15b9ffc66af5ac2aafbf2dcb199a57bbd334c9f971d903d7da7fd65e920cc9bc,
+0x25814a817412e861b4318985ff3cb706db6e56dece08c2c6dc20584ed6fa6c7a,
+0x4190e2e1cf613602ba331d0185b43c960ff5c57bc2f86f5c8bcd84b95c789a4,
+0xe3999f52ed0ec7f486ff150acc84c266aeee72529234a010988f95a1b5885fd,
+0x1fcfdb43cbd7992f0088a9a85c95e4621873666105510f25ae576bc08d7f2084
+]
+],
+        [
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x199593eecc85367004177e717d8adae09206aac28506281403748f85ebe9985f,
+            0x8dd94e1b09d8b9823fde4d4fc4a3794d631616a2c192a47fe257bfbdbccb7d,
+            0xa0cd01bd7b3c21552ee7c0ba8783ad231802aa4f847d00de820e9176e227744,
+            0x287eaab3e59c1cdfce30b6151543b6ef49a3be7206f3cea62db4e80fe1ca1529,
+            0x2a8230f7ed05f7e334f91cf214c7bf12852996083c456a506eb316c249cfb4c8,
+            0xa38f089600747a6b6e35342c2e321042ebf690726aa9431031351cbaedfb5aa,
+            0x1d5301168a7dac6891b7a9f6dbcd505fbf7522f875a61254149449869d316e05,
+            0x13abafc765fb2e45f793640bd7f1ea2f88d202f0d7b4200410cd96128d3ef472,
+            0xda7e244a420237fbd8730ebea03fff45156a52ac87b9ff605ff1ba20f7e83fe,
+            0x271d315532755b1d48814699af18654bb310bb94d1258dde0e589bcc2a5e28bb,
+            0x12fb6f92ff04b5d5de41c9508842798a8b9454a99f0cc49a92afead482e84bba,
+            0x24cbf9280b713f95571b177799a76e23f555db290a1187aa5ab7db69a2dda2b6,
+            0x18f43c99a1b72e7cbd6fd781a46c13c38202b4b0ba7ee75cd36fcb79b5ea67e,
+            0x1c69528b3df94c6f7e8a794ea0308fc165f1bc1c1e3ef090c7aaf4405f7cf3bc,
+            0x1cb0d8aa6512a7543bd8e8bae1c0f0d2db1b3457e1bcc0ffd372d4eee3c6fafa,
+            0x2e1fce1597591bb776ef16340aeddaffdaf039487cb42bfa6752a3ea0cfe18f7,
+            0xe486a7b7cdf0fdb88306d96e72161d4549b281152c6cfc98d84b031e95ca166,
+            0x1141e26a80698b742d900fd1e734839d51e4d50e0176303a675809ac47201782,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xe3f8ddade546278648095cc835e94063972b1d55c6414506592ab57e54c8042,
+            0x21933a3bc4989347b0703d7cdeddeaf6588a166e6a3f984e318de63ce674e8fa,
+            0x2ca6f945f5f755039c8e1bc30935de1ad33312a7cf325b065f91083cfb001a78,
+            0x129a9ad876815d96566600a97d41f958d7df9ef97291de611d28d7d9b2af46fc,
+            0x26b8f200c0d0371558755081221dc59767afc5a4ddbe6f7d403c5ccb4035289b,
+            0xc7c739377b0ad2ff9d3b0a8fa53e39c7016f049ea860e8113b055ec96ee3d64,
+            0xd17a36749f8f9d493a0a57bd87618c969cbcf83edb4b207c89aa5ccb3feb20d,
+            0xbcfe1266d757503881d56c7e64cfbbc3cb6a47ef4e655565864e01b9bd3f872,
+            0x13f89db06ca471b07ac0ad1f4448cb225868b63131700d1ddddda16e6d5fcc7,
+            0x24d344ea0550d7720827b6be6c09b027c8e4ad104d57d57771c258177a302b8f,
+            0x208ce89913e633aea3a855a854e7daec40afa1939dc1f728dde6b349e39ba30,
+            0x1fc4565041d810a750e306a14d21695074e31eda2baf0821774add15c0e2fc3d,
+            0x2fa22f80d4309be21ab298ba4bc16a5b20f2ce8f3ed7bc3453135655da269649,
+            0x26f3a23903d1e7d835db70f3005b3d5a67043fca7eb62aa8d78942a0c1cc8add,
+            0x1ce0343fae8a12e25f2391eb038b2377e7c0c21aa60100818539d6092eeeafb0,
+            0x244a2bb870f1e6f4ba5e20f1c225723f305841bd0ab932b7334990cb0572c33e,
+            0x1ec61e9126f4c8fd6f0d00b28c5f02334c077e99ecb358d2536b2d321cc00aad,
+            0x18b2ab087e3f0a7fa8a6bc1687900a5481ea991ffddf017ff52a7f371c22db87,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x140b91ca0e53110e898a67ba8853d04821952e760e56de985180975ad237ea52,
+            0x3385f50412cc6d4caaeab9aaf1099e8c3c61295754345534a1476144a9c2678,
+            0xcc396f0b80e2638615bb4a250f84e54dfe33ce76386edf22da2dbb233546ac1,
+            0x2810d8ef50de86e04cd8a07f6585a06eabc4ac5efdc4410904d7a906ecd172dc,
+            0x1f8b8501e9db678cc274b33246e39eb95635ac4ad2ff759a9201ac0c3f16c12b,
+            0x9b10e50dc0703b65199c6cff8510a9ef2172545f366ec2aaedbb2f5ad4e391d,
+            0x158a6e9ae44d1ebc7fb99b5b38e5139257c68f0ddea96593ff7a87dfe79cbbe2,
+            0x68dba3eb9f1b909707e666c1e7c745192f6ec2d8439c186faf6d3bb978b42a8,
+            0x100be98775675cb0864cb56fa3f82b66b216071d10cdf87358c7e46be055c723,
+            0x1684c4b116063b5e05cbf4eb9b3a6ba6d68ce1f30ae3978e1bbea7a71bd20cfa,
+            0x678cf4e455f8359f498a22b87a3dbfc50ce233cbbd99995cc259e419899e53d,
+            0x305d111beaf3f510a104ed93aa254f20a4c539eeca95756ae03bdbdf0c8eebc1,
+            0x197b0550e8e09c375f4b1976395ae6051649d6c7a8c39b78676e45d33a8630d2,
+            0x190712928fc6ac88f24cd9179348b4a2832748dcf708e01c50efcd32e2b83de6,
+            0xa77bfa4113e98b47e8d705a9f60160ba144ba344c274744f135f207b24929ef,
+            0x2962a7083e7830d287de0a3436cc093e0fd7c2d9631b4937ac124d58fe3fb901,
+            0x91a715976bd99e40777c119f68ebec701e3777cc9b9e52602588a5ff89583eb,
+            0x61e3488cc92892520449518af4f4133b52412a19fb8b98d3d0812dea2636e3c,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x197ce59bc87f624e9629b7383452b9858362754ba76cabd0e3d3161eb8ca76d6,
+            0x276e2e6272ab2858142f0ddaa038f436e9f4c53eb4d5dfd8812cf10ca5bab1ac,
+            0x9c49831a9e1c453d072ce83e5088666b56dfd1ad0977b2abcb2aa9ec83e2ca6,
+            0x2a4aadbf31a1c58a26626ef9de341f2268bca243eb859a465911da18af0173e7,
+            0x21b0460dfc8645851be88e96ed5f67cc2ea5ee00f4f3025ec4b5253494105a47,
+            0x120a8288745f9dc360cb1d580b012b52543030b53b9b97ac9324df79fc46df06,
+            0x9f0d911f5eb1bbef4c9ee96c2fec0b0c00945de4706b4cbf64f62a02015d7c5,
+            0xdd0124d8c9d7b7c202379a001263e0522ce49d1081f63816134ad16bb34277d,
+            0x2bd803e20cb341debccbad79b053df6e53f567874a52ddeb9422758e73cf6ec8,
+            0x19b2b4b0e24bee790fba0867847f947f975dddfbe3c11b4c566ed4673684c0cf,
+            0x1acda97c75929ac11c21cb081f177a6e550331b2670e6a66c2793e4ca4bcc3e1,
+            0x251c70a93b81276ea3438709b96351fd8004dbee0abc0df79329caa4d932bd62,
+            0x28918984ffdfc01138df3fba5221a8604c954b7ee40de7070fb0e34e7038ea3,
+            0x2ea1cff24f208aed6f4da7cf837817ebfb6f545528d85a32430aba357eef776f,
+            0x15b61ada681df7de801547bc9937b1c2e75a4f9728cfb5586f765b058735ccbf,
+            0x16a4ad2b453006d9fcef31919daf7ded6dedff3c5b3ba4fed692e2350899167,
+            0xe8cdd7c3d33927077543bda5b1777f6369d06876b8636cb95a9060c7936be90,
+            0x26152760e5dfe9f0a2fe901bed5e0dff3049827e43a1091e24aee4d457490a63,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x1ce56e15f41c99a2a005acc7f78b735e8330dba4db4cc96c524b4638010937ac,
+            0x2b33ef11fc26750d1497df0fa1b969f1c01c5556522150ff976912649af06a99,
+            0x47e2b54830ccb7ac893e39afe89b1d7eac35c7ec0f28b343e0249b924f15d37,
+            0x2e820332c7266af2a59ddcb5206d404827e9563ca2c5dde5d2d34be269c82612,
+            0x28fc123f79ace39838b7af8f86be8cbf89a3540015bed059fb7a55868edee623,
+            0x121ae712c922e7ef55ebb73809f3036db42852c52fa63bff322237bd883dd555,
+            0x3002f25a7ef8e035c0e82597953a107fc73a5a406770dd47ca93a34cdf8040a7,
+            0x23ea2cf159ca1b8a17ca61b73bc84b33ca7204c4120cec087424470dd062076e,
+            0x179e72146176bd15051df789ddc3d0f48437c973232846e4223daf05529248fe,
+            0x25edc52b2cd7bb6690692d75c3f1b999f2ae0749c5d2741d2b53284b5655d46d,
+            0x1cdbea76c865750ceb85ec17f20c955f2edd46df09f0ad90d04cf416b10fcaae,
+            0x2edd29ae05591244e1124edc195033a404aa98a863678d3769ddb5797a2a748d,
+            0x2d9d2a342475cc1662da5b26453efb92f1549efbac72a1226373414a49a13590,
+            0x4783348904bbd884be3c608fa349287d2e4d4284baaac9b6ffed192a641406e,
+            0x1588ed490b8448cfb883d790bb0f97a2f1962d14289c946b8ee49a4ddcf7a3eb,
+            0xbf107dfc33fc7e66153c7e5d6beedd252d17b8ca1bf1f6499a9dafea570fb07,
+            0x201d0f15aef01a1e0b401f946f7b29e6f01147b6257d7ee235c6d319c4474326,
+            0x1015804003503668b1dbf9bbc98eea304dcdeea4eb7dafc67b41a6446af10385,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xbee3e128dae75005ceb095d9e6e0e55285ff7edd96dc89654f5b83570593503,
+            0x1853cf3ebd47b13b2f218990eb3ea26379c1d213e70feea5b84882d76241ceae,
+            0x2c25e50d363cc08774bee7d9e6232855f6d8977ab169e38fc6fc76de9a63e6f,
+            0x21ccc1e8f8b5ad39b401f79c51ed881ec892d2a7eebb8ffbd848ef158afcaf68,
+            0x2193aa94ecd57e962604ab428aa0a8971644707c6e85663ef9b3720a685d71b0,
+            0x1d3b5cd3133a0533eb15cd908cbbb5dce76ecf5b711f2535e852aa472ee4c9d1,
+            0x11f29d358de76ef38d31d6d7247b64d41c42ebddc7ef5e4445c7897f57ad08b3,
+            0xfcc2984d1d2b762d6fa16a3a407f4d3eec484a9129763864265add7c900836d,
+            0x2f79d03e732317585ff9abb62a371800553f1eb717a71437e225b204c18f9e9b,
+            0x2f4f14eee6382dd0c54d10739b354abf104cf134babadf2dff9b8cf286f9733,
+            0xd0c5aa4bc4f774d03ef5b2f9619f618edd9afb37defcc420b0aa4f4fd145e85,
+            0x9b150f8dc9342c87a8b7e871345e5998c084662c897899df45d73157c4fd0f0,
+            0x28148860436280cd8a5fd6645fd1eb86abdb72dbcb02e8ef47065a4a681e9eb9,
+            0x2cf619fe3735ed9bccedfbdf3de64031cd203231a0e178417bbcdeaf69c85d15,
+            0x32f164c4f4e5122d438a9e0309459141505621343ab1c19abb63ce7c036ad03,
+            0x2a3efdef552208ce3441637e2cd610386f41f402bec452d674bd2fe16c273581,
+            0x1a9e7a13e4d57cd1ab3e38f0991fcaa4cac542f66fc2a46f9cf7d20029cac792,
+            0x20871908a0ec043e1e43ee1f520584f15b3a7f24a2d03aa1de50e27ca599d872,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x4767ef42341d3930d7e5219fabbff62f44e103b3a0905cffaea5a2dee73c19,
+            0xc4a1786e515cd9bcab2b7c9723c597e730c532555003cae4e36131a721f6ff9,
+            0x147f468c58deafdcf47e57114df0ead2c77452a45020e73955cb150e10153520,
+            0x1d1309f96110c70d9ef884374676b9cc3a599fde74388ef68d99e54b5802c760,
+            0x134281c387edde8b6f807d253bc0ace7a625fb3c1f65b88e4537febff52e1d62,
+            0x2fec2d972ac4b8ba14bbc95cee2ac6cb8c669abc35e77ae2f7dc962dccdad59b,
+            0x1782c9e451cbde261da8b4ad3a15e23ef7f4daf7b406732de05570c73040c663,
+            0x261bf6a9f68e313088d8b2016d3e7763a6f6eecd9b506fd2baa8d8f3593b4c4b,
+            0x133315cca34af406eae080edf7ce27574fb984710e4e8ec39aeb6491b97f98b7,
+            0x216763174ddb0395182ebe57e4feb91be8f13746e89949557e023df397cb679b,
+            0x9dbb42bf26459d3f9ba2ed5f491b4f01fff6222c6bddb7776450edb6c652ce5,
+            0xea832a969ad1d94f55cb34f35c7327f62f24fa140817b238bc676edf1f77b6c,
+            0xda7dc395978e8ee00ea5ba5103a39930e284533b1a51fbcd3d7daa542142dda,
+            0x183cf55053b7981ac506fe1c56fee73fe3a39ae042171e21541b2b7312618722,
+            0x16eabfa4236b9b61ba1b336ce55febf1cc84343f0449a54873cccfce0ff9389e,
+            0x2b62c1083fbc23f58fd694646499bcb90368a2e63794b1d39dbaa36bf782e363,
+            0x11ecdbc47a72138aafe44263356d01e931541ad49ac28c048428ecd233fe3c6d,
+            0xeb0e1c7cae7c3f491cff7216ddce50aeb98935e405316c6daff1c21046af99f,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2323c898ca30f7e8fce9b31d21283d3545705a71d0ce9577c5012fde6caaa11f,
+            0x2373f9b1c4df6c500768ddb13eedecf0a82bda6029c0abf90f3f15f2e7a9f87a,
+            0x2b4a1e59a52b1b825f6f8dca5ef66b929032dab32a9d3a58ebb44887f84c18ca,
+            0x3034ae984f1538e2163148617760f62569231a619a0e2b620d206211b232ef29,
+            0xf1fb16f83c8ddd6959d01a9576a8d70c226a1a422ffae89ee0baeeb37e9a8be,
+            0x58d583dcf975f97dbf31e32ebfb0841298f765476b2e4833260ad9bb82f2f2d,
+            0x2b1060a96e8a6de59e2deac81b17d40ecaaa4087276b7d5a9ac2b47598c2facb,
+            0x70579f1869154a6efcb59f85b43b90affe755efd5d4e62686aff46646e0808f,
+            0x21444d26f9de3b9fd22efea95d62f5193c3eb0b2e1a6b393e85996439aa43992,
+            0x138671f92f9ed9a8131ff4c7da6806dbc33f6c02cfd3d946aa92288df2ff9d9a,
+            0x1e629d7b8f61fa02a5fb2fb163a5a57a593b158df70413fe868b338307a449d6,
+            0x10f0f884186e996c19ce4939bf317b3d12cd24bb87bba0d3bb763ab716ed41b,
+            0xe2f06ba65a2c7c8500850ba6a489879252d0db2af69dd23fa3ed106c92739c1,
+            0x19823b0af9feb33ea07566495f0de05e7ebfa52aa89f5a5d7c66f96ad60c828e,
+            0x16b0527fc6aac4b4485dded0afd8905e6b53e056efd33df7b8fc2d3d4b54cd,
+            0x8a584f510af49572ee86cf723346066002e5e7621e502e946f8f35003b793fc,
+            0x8a63466c0bbbdfe79375f181ed0266c97e6057653d0b285696a5ef3e93c27c7,
+            0x28ae69c874a3ab1ee6360bb1ff560fbab69591e837a4bc4d80ffb4d253e232c5,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x26751aa290792a4fb3921d9ff8b5967efdf68b1fd85981b4d96401bc621b381,
+            0x1cb215d90f4015cc5934293e248b2d6aca4e0afd46cca219a89eb4f676199481,
+            0xb8f12cbe7152d6f3e5fbbe978884a5b7be6f35fda4c00f5c5975158df2f338e,
+            0x17d6d8fe5ede1ba531918c33df5c6c9efefbc20304b2fbee19c01aef81299774,
+            0xb53ad598a4e14448fd044b8ce15b6336af6b91cfb81c0da827e7dd68e98e59d,
+            0x15e20ee8fc573330fa52fd42ec7b636e28cede5437be371b1990898751adeb74,
+            0x154fa8d9c7f09c1ffc7fdfcb58fe7b91e6d81b03adfb8f9e2fe0522f6f7c2541,
+            0xc17e59b4750d7443f8030f26ebd82d25623e2b8e5540cba1f310828e5e66988,
+            0x7dfbe56e6ae749917b93471525255853fba26222d45e0504d8f74784b1a86f3,
+            0xae4cd50975a86aff25632e8c9b7c0e915bc38159c90dfd9459e29ea9432e467,
+            0x1fd9cc61b67d700ec892a8c09af677c9e28097463010126823cb72d07583754c,
+            0x1bb36856ba8992334e795626486a4608c5d9a076cd93c8aa0e1a934ae4e8f3b4,
+            0x2f9cce5050f66f493cc95213db4336536a3a0e2a17311cecc27cfd9d88e339d8,
+            0x14839ed69feeab49ef110556d96b4f1793f8c95f3a38de800e9ca0df690f958f,
+            0x7b5c5afb6a826ccf1b740cfc8aa6f0279ab50c3de8a98f6692bff8cedbe5f0e,
+            0x142f7788b72c5fd5a9065ebef59f6e8d32eed74588cfc22ad0962aeb24a7bd0e,
+            0x1d07d62eeb6dabe9df4fa00ad642bfa7d36687d6ca9c8f023a40b5d04bc78ae8,
+            0x13e55cabc0bfbb9ed41bf205be0674e8668a8908c411ae821d2539d8cc587fca,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x262b44719763ef2a486e59231d9624bcf1ecb95f576bde1e7088dd5a7e4a5f89,
+            0x2dfde9e5ea549d50c4497d25b4a4cecd096226253b3c7c3874057fa62b8743e2,
+            0x21a567f428d745b4cfdda7100163871a5383e5d8ebbda66f7a305a4c6be0abdd,
+            0x1dda63eedb6364b5da1fd1acc28b6a57b9a4033ee7749a8c2ac152a1e94d4b4f,
+            0x685e2a27b7ec3fdbcbe3e017953374976ff85371aea9109c2d76f0ae1ceecd7,
+            0xbadd4c6541613422a3c2b71626af0df7f380d6f3f6da676b7e6dda463f63ffc,
+            0xe270311e05a64fe34fab3018b68616f08a2bf4c06a47ca457defa4c199fb96c,
+            0x20782abf7216f6c5e781a8f0350099551c5e9a1a3d4b3ed2d985e5a7f566b24d,
+            0x2b1a699f26b1fc4beb031df4f37b8d5cbabf780572fdc64a56de00748a65c07,
+            0x791e4fd31ebc85df2e06aae29edd808f129493f8583732492fbd7056e93dee5,
+            0x2cda35be891732bed62392cddd00557b6f4b195e000c1bd4fcfb605f8e369d64,
+            0x6b17710849d27210afb3ecca7e7c7ad3bfa36075ddf1b46d7bf0a557c7afba4,
+            0x2a1ad86529da724870dbf3bd6fc20cccc1998102cf0d7007a6b2263999e4fcd2,
+            0x2ca7a691f176d709c8799b5094d28a68db601ffb5d133cdfcbfae9e565f1ed84,
+            0x92ee47cd58d3038bf80c70d798516c0dc371ee7fc7715da95ccdd5a1e820347,
+            0x2f0a3f3ab9033e8640e9c1b7112b31242b7eb493837b84bbdc9cf56ce5858752,
+            0x2bafa447b4f5b878e812ea7b2467c72890c119992bd1f6e3ca60f926e812d2c6,
+            0x6f980dec5d6b3665f1cf9fea725ecdad874c5c9cb63e7987fb41e7430a3e352,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2d69490ba2ee43e841922e9a426a5bbc264f17ed379f8bc91ae3d275e724c21a,
+            0x55c6b789c7c9586e4c88fbf4eb60783cdf8e9e58d356bba1ef92f8ec3514aac,
+            0x160f356a6a05a6919dc7d2e03878c6eb552a14995edcab05f623273c0cd29a1c,
+            0x2a178e1d8e4e4609710499245dc91e66f3795b5c0227a2ba8cc8a9f8830aa212,
+            0x2dff2498b5124e3bc2587f3b1cfef4dbc1168c2172dc43f1d801cb75c7e18ff7,
+            0x3062dff835ea1ef8f6960d05f57368fb48357ece82fd7ef12cb5254a55e3d102,
+            0x7f83dab6ad44900a3be2e049bac44fc5eafddc0e261ed5d1795fd513f12722,
+            0x1a037c2eb85f1dd82bc9988c67646efed697444ea2739b6800d214e8fc52c8d5,
+            0x17cc92ab3464a089e4f7747fcbee5043b59bf9d7cb744346cc2d889051463061,
+            0x36ec634c1127401f9a2206720e26e7198702b85deb2314a37c1f06217cfad7,
+            0x13e7e74a49ed94c2a714a46b12c19e3ed6793364b22763ae2c28b53318669510,
+            0x304fecd133011329f98954047995691c6991eaeba7141494506fc3876cf8268b,
+            0x4e860ca205e4d78f0d93d3b743e2d82d77737faaf2704e5540e163aefe75b51,
+            0x128cd6494ecba913473703b110fbd66d627440384a6187aca8088de1d51aaa60,
+            0x2c7111b9259f4fca63e218ad354e9107e80a436a3e82d62f180c0ff1c7055743,
+            0xb3901ec96ea864778a698866a852170eac53ec5c05c024373cb38585977fcca,
+            0x9aa27e7fd140dff6a20f7696c85702c3f60ae58e60233012be3996d839f8d6e,
+            0x1e3d51555af4c3321630aa1d1134ff631ce25a12b77d3c2f3068a4a981f79491,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x19b9a37490c9b0507423635e95f10a0f27a2dd48b840393432eb41c3fb9aa265,
+            0x7783facafa95b276e52a4e6957b6145806c64f5c0305fac11c14095e6770e7b,
+            0x1dd174936ad30ba73ea372209ca23d51868b21e533cbd15ffd438c51c9515c89,
+            0x1fa6bdba3839fafe0ef67bb8f50f2bfcca95ff34ccdd072bcf4451e1b3a8f098,
+            0x2a3116f7f050869bd4b0181245fb41613f482cf81d09b95898f9f813caf7c97f,
+            0x2c16907e9d82fe0a3799dd07efc106bf60d114def959261470623220d9d9224c,
+            0x3c373a0664f0389702f966c124355796a3819e6fcbf29583b4a33891961bff7,
+            0x2e67195c545bf86e5737e4d28dbf075c11cd21965127da4aeac13b49fbadc2de,
+            0xe0d816cd83dfd0535a9706aa8d7225342cd76b82d2c3df0425857d92aec38f6,
+            0x1d623c057cceaf69f4438d54e954e59f7f04065ab72132da788b28fe08ae403,
+            0xd7f30107ef57c75975e5a489dd2e39053d12cf5ff9f74bad3e647d6b4278659,
+            0x32f7466d62e6c9dd8c02064ac112042b9082c7ea2e8caa266d04a68f9d9b15b,
+            0x2a4bc62d27e720a9e53c02e6519ecdc684ed42222c063c698a9fa024c1bd0669,
+            0x2f11dad1623f57beb48f1f781bdd9cf57752dab6fa75b6442db3834cebf6d5ae,
+            0x7448b576267dd9d742ff7a7fc8324ddf3f340df575917d1583256b8a26c001e,
+            0x10c06e0e81bba5139387282c3883c5967d1ebad7ed164f970dd697de036db5c4,
+            0x30c7e1595a11101143f8997b7b9f63d265bb69efb4afffe36eb47ac4e170960,
+            0x2081add9a69f880110449f883df1816b141c11bc52fee4c355821501e3fcf05d,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x288949d7c29bca2b52de67a970192cd195390c7ed0788f81d85db64c98c78aab,
+            0x2589eefe89ee66a650a27700d7ad9ee3ced14f507536405c21a90857b6a3c8e8,
+            0x28ff008aa0b3a7732cd4059620a76a9d1cf8286a5ef84ee4df54b435656f14da,
+            0x2155df46713041cde67a10d82c7c13921f0e394bc66eb78f9047782cd17ea643,
+            0x2c16fb8505a4a94a7b5c775792cabfa62e014b33a5479a81c2fc8a52e8044d36,
+            0x2b1e314362badfaf84b4d272a4b6509698305104e27fd317fbbd0178137cc708,
+            0x2c27c6d894ba49e73659ae668667796a1547338cdcf3c35914b3d3e004f935c1,
+            0x24c4d70a62d779e831a38a510142c88b2071251f2737dbda104dc3cd5585041d,
+            0x172cd6c4cfcaa0085db59ffa6051971fefa9934458a50b5e3b98bef6053f7fa9,
+            0x1068776f66d6f04edcdfc6e6cb9473ee2f57d670941e4a191f6f69e7bca61a,
+            0xb5fbd532099ded25d17a8ba4db930a0c9655056fa6a01c56e825843d763790a,
+            0x20d62b8df28b9d5677bd4f3ac8095772befee8b2b761f9a4a7d9b9aa719209ac,
+            0xab9f332e0d0c4ddb998fcd6da668a8f744260e3ea8947b6f6189ca82c5db01,
+            0x2953639aa84c6c0feedbc71e3af4e4a15bc408f5cf3ba2bcb98ba5bc01c9875a,
+            0x1afc3b62187190e90184c6f1f1878020f0efcfa38235f5980ec372c2d9b4a56d,
+            0x2c67d12ebccd059b365736302f01da9088f2a40ae49d88e58c7ecab80621db4,
+            0x23a3292e40578b5fe32b0c7ca158b298fc7d6397ca3d46a50157a528a6ada69a,
+            0x2d5a92ce3878d73e89d645f35ea2b179fadea64310ff752a48a94aab957cda66,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xfb3cf3d82f7442edce7ae58c2fcbde983a9991bfa8c583cc9e8675176f5f500,
+            0x1441b92ceeaf3e93bb74d84875b7b32f66218d23cc25b747d522344c853e69ce,
+            0xc66500308b0fbfef99d8dda3ee219ee7faeeb6ac7c993572c13a93b172c09a4,
+            0x104281140d7c64b5bd415c250830aec689e5868c58a2396c8f4af87c06c0a617,
+            0x297d4462db9786475248b39bcdc40ba0ec662e5e772f6d07c3178964c86bb6b0,
+            0x882cd69f5f1b0c14f1a5f1473f44952e042d81134a25c45a01e4d997761b6be,
+            0xa663c1280a5f4d285524e6163aef8f83a42ac4a8fd6d3c44bf01c5f76393e75,
+            0x64ff7dc46adfef44b40646c79afa99d0c14ca6bdbf7da5aa322f346f169bf41,
+            0x901c9594190b84ee79b7282a6a5bf82cda6d28d1c513fcc679b42c5da8570fe,
+            0x21257b75cdd1fac9c5a38abc15274df2aa318adfad33a5263ea3cdb1a1990577,
+            0x255cf0a823fa7cbf9cde67161df7378969730138f3bab39b5be3575dd62e8b51,
+            0x1d4b1fbaba2e064f59db8d8a6e72ab84d49a8d82f6a2f9fd532caac3530bbdb7,
+            0x3e5ecf7a394eb453de6cfd3fe8da36f826abe096b15add7bc22ada6d2ec83ad,
+            0x1f068ef1dd48f8934037a95c94b3740ab3d399a0e36cdf8c91adb39ed90c5151,
+            0x13b5b483529badcd3ea50b491b6a042ffe9c38f2761e8367eac4e11a85210971,
+            0x28955844381caa81ec9032541abdf3f00b77b9a80b9f6e363cf4369e0b1b6642,
+            0x2a3fe34d0e5e72044a5af113255b129d78fdd2fccc280f3d6b81c985d16cd288,
+            0x8757825685a90d9476b5bcf376eec9556c41811a9c017fcd7d6ac44fbbb8a0f,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x5454d37baa3a2f999a53fb59504aabfee05108628378a3a9feb587663d274a4,
+            0x129a7b8af836412572e06774394c69bdae4033b15dcc2a4efc10d5b4d850fb05,
+            0xcbbe121aa60c9979b941f94e86121f984e67334708eb05850777184734a08bc,
+            0x1925ac7783c308bb5aa53769d434c44de6faeda6015848693c50fdfc7f465d86,
+            0x1e24206b35f67393f1d61933aede02c01ecbd9cd12929e48300e37e1def7b1f5,
+            0x4276737b519ede14db1b652fc56169408d4cc1abf043d8a9ce90a16447a06fd,
+            0x27b946d91e4453a4854c29cd248e0cda329d67a2ea66450d51b57f8b159df5fd,
+            0x2cdec054ad08c8c5e31588959e605ab5b0518517fd809d437edc27f33da7580b,
+            0x26e434190d53125fc7718bfae9f34f2124d41bb51bb2c23c37deea8407da3523,
+            0x519d0e4b6c1228368f420926c69ff37ee7dcf8e3dc45c4e95c821477d075eda,
+            0x2aae1f5ea6015e4acf22f950f6620cf74e7d7bb7a33ec09b372cfe562e5f2e12,
+            0x2ffb9c618799bbf03e071bca26d130a936a380f74f6e475f567adfd9adc269ab,
+            0x22a6091317f474f780d2c4e11d78e6eb875686f797f82a8ba7b3212879dd63ea,
+            0x79b093f80d89162556a653dbe714975928ba10cfd5f1d0bd47c0fea68f03493,
+            0x2741b4234834eca3dfd3ad4a3064246c4496defd8197e450b8416e4852028c44,
+            0x15adc0ef2ac09ba1689bc3bf21e4fa50141c0089d00a80225f39a8ee63ef0032,
+            0x168017fe19343b5d7d8476c0936a0870ac87beb8ef2ef9b02cb773dad72d2401,
+            0x2dc5d64afabdf089bffe3152fa2b290726cbbb4d52e3e08ab52b1876070a8b03,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2631312e2a6d973442d5dd7efea28e5073c5cc17c878cc594e2c39dea7a51950,
+            0x1ae2f96df9a1a71be2965eb1f504ffe75742ff7f81a45df9086822ea4ff83f9a,
+            0x17a4bb48a247c563499f4b71a2ed4763c579ba38009184f3607d9b4b5b2594c5,
+            0xc9a0ebe3610863f0da6992f19a565911e14e72687f798d90b98f2c2b24bda63,
+            0x2f2731211090929d349ecff21490ef33747d4a402c8c1995b827292ad299201a,
+            0x9b7a78ed8d062af7d0ef55e464376fa6a4ef0de0e0cfddb6095156359825480,
+            0x28abb1d3e1bfd68df633d19408b66ec34a580540eb92794fbaa033f8eb0e01b3,
+            0x1e2014bbd5d2db2f97744448f2d57d1e27b6dfde486085a5d8c128058fa0e656,
+            0x25f9ef11d4ff48535b9301a31a5413236fbb50568745d44af96d5d307490eb62,
+            0x241b430c52d322bb0971e127e4e68fd3fad0a845f235b3e80bb514a00b75ebd2,
+            0x21b6603896d2fd23cfa9b8db8fd0e550decf29eec015b5cfd665313d91014bdf,
+            0x2066a222ed385ff7d9620fdd0343bc67d3fe9027c450917deb4c126ab9c5843b,
+            0x148ab2277866b9d0c72eab8df30a3abb6fab1610e164a9f2400ea397e0de92a7,
+            0x22b514cdab8e05d5b1289978bff23e2aa763565fe504c7e3bbc86069e0352239,
+            0x15adb32fd53195fce581f92dad1925b14c6273d02a73ce8a21e988944645e829,
+            0x26514ed0266951c35ca0ef8ce1de46874ec132fffec62807e01831664eb427cd,
+            0x24a1401fffe3c86451355add7ffe24db5672d8656cf51377c38351f1fef09a6f,
+            0x53da14e5e7a25894a0b0efdb05617d4f0922398022d656b13d24ac31c66838,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x23d4d5f42b19c73015c0c481446416d929469dfa05ec46df0163b835b30d08d0,
+            0xc34142c7d90f966770924de9bd02290f2a25d7e627ec80bb3d7ba339d0e8829,
+            0x15693ac825018e52a0d4c3aef740c97437e4dc3331d552a1c8e4b8a3c9e176f4,
+            0xc1d7701d2b195781d2ec69c9c91b532a326163ec4fa2f0dc4afcc58540acd57,
+            0x29f55706b8105e02770e12158f34ebf47fa7ef35f2ca62de699524be584a17ea,
+            0x15948078ad1c9f08c03facc3daebcba846a02cd92994d709ae047be01ae1c676,
+            0x1fff985fd1db0e045d0ac983e602592bdaadc7ee35c696f55da0bcad75e20a1a,
+            0x16b370312e2012c15fa0c6b9619f0ce24ff0586c10b4bd02589d2b7b2dae4eff,
+            0x2358120a60a01628aebf65fc72181ff9a0ecbee9ae148ebb4ab4bdc9b216e76,
+            0x2f1a1712d5a7eeef8647c7a32c2c9491c10ec872fb7a8280bd5f360a3411cfc7,
+            0x23b8d022a8e866d4095cac47c7ba7111429f6c08950a19de476ba2fd836b6cf1,
+            0x139ad96c1432a53b6fee35ecd66f2b9da8ce4bea3ebdfbd2c4a75961efe0d892,
+            0xd1a3762903cf32fffb016810eb11daccbff2d7dbd6b2a447ad32f810d88893,
+            0x1e2fcaecfaaa32924f964b021dd552cac420f822a0a71e37c28654221d472b7f,
+            0x12102994668f97d887812f0151144111aeb19e748eb198c3a75a9965176f8f07,
+            0x2cb68b7e634347542711e393d188b6fc2eb0f6aab7a7cc9177543b3ec6d7d,
+            0x215a89522290e4cbc142deb1584f336ad401aa76d058da586baedadb4c0b7b9d,
+            0x508c70de806cb78a62250db957fe5ed69e4c335b86635be74a068f200768a,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x3f5d10d3e2dfdcaaaf5d2251baa6e7deef7fe6016e0e33f67413b576e78439e,
+            0x5160b38288f77fe866c353e3fc4bdfaf39b54fb22c0361c6bdaa645131dcd32,
+            0x1a1f53585e77207de93ff07741144e90b6f8858f6c68d52b62c96efe319aae23,
+            0x2c48ab25015e0bdd2cebd18df7edf7766a28d757827818c284f15302df3d0285,
+            0x3001d8c6b2c0a9c4e7f80cb2688f909dbb1bce96b7abb884f405158aca90ad9c,
+            0x14ba759b81b8115d220b3bb5e077e597f805e30d961d02b132ed6d6dde416d8d,
+            0x2e3b3d96803a71c846f5654d3bc43f69edd66885224a46f6c5b67967cd9b0476,
+            0x1515804d3972a797545bfd5143cd3d3c2b85b18b734fbfa60e28a7d8024cb8ca,
+            0x2122b140a17e84a1ce854a0f924abbb7941eeb8af8831dedee228e4ed462e38,
+            0x1efeffb998ae5510b386fe1687a04b18411e23f5300e26b0dae71a1da6a16ef5,
+            0xaebe0890cab1a8d389ad98ac4e56b74e1176dde08cd90b0b69037167d221c07,
+            0x1392810e135502a38d126a0dbc2cf8d1977357dbefa4d84484d36a4a6e4c7799,
+            0xafe48f0248af7d2f35057667e79a08c2c2bffd8225b6219d94e785c41a796e9,
+            0x198eb323d5b100e891e9327f661d15848df9f2e3bc2e34692b0c644ff091b62c,
+            0x29c62456a430517fcaecf1a752a55dbf245a88ccd664e1c824da61000919c45e,
+            0x2817a686e5a15a89212dfdcf69fd15fa73b8bf0a5c5cd893372a7deb18d1a7f7,
+            0x12d401440bb03153830e9adb349d891ae4fd80cbbe414250d9f3c2d71448d93e,
+            0xfa1b160c62129071551cfdc0d384b81866bda034159475cd5107b92044b8157,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x3046d1d934cca5a2f7039907e78cd8dcdbb50c5e8cab13a78dafcef27ba5597,
+            0x2d724a2ce967f1115a32a74ee7cf63760165fc405621008476db3bb65b346b47,
+            0x6684ffbc3e9a720f7ac9be9c867f2532240fc9ed20c21430e2685abbae63ca0,
+            0x1e4caa2fe0f585e91bf011c1755396d39dcbc30e94aa4ae3ceefd381fefc0d43,
+            0x24a9509908f6b0a4aedc444647d1de173078d900d23e2770b410624472bcfe70,
+            0xa444eb331e3a9d4f98039f6d9a7a45482ad85d6e9d0917486bae82a5047f729,
+            0xcaac550d739a7699d5dabeabd3bdb5e37449e87f07b95ccb82fa742471b8ef4,
+            0x4e0c67a911f80f93720ce27d4ce2815f7c4f2e5d234c259fecbf562f863121e,
+            0x1ff8f4767dae471c0c2a4c2ef44275aaf07e1e155989a5ccf1e10537f860f72d,
+            0x2f6863db06c9adeedb84708e3b7c091cf44b4251023fe8f6bef72d61519e7651,
+            0x2e788ebb5af871b9ed5e9fab07da7b58126109807e5915e6f54d7cf7dc79199f,
+            0x2cdafe599e42909bc0475abddf4f10a4f14df5a2c0f429bef913ced315d116f6,
+            0x1b0a72225d8796640b16fec15a58e11d4be5a9a473d1337fbb495ad93b432f6c,
+            0x1cb387a29a3345bbf6cc407a81958e61fe98f7708f40bb8b96741f730c7e7081,
+            0x15ef88ba22652780eb14b3ab276c1dea798361f7631344cac3e771a16910179f,
+            0x26893d124895c43a1a271e72a5f99c4fa9fce6ffa7bf6c31e4926a4efb888e67,
+            0x9dc58192b21af8f6033bd84e9f5d696c602e0bb4c924f790b27df7db675049a,
+            0x1d659f67ea472288e942baa853889e47435056a2da4398acb9ca288c2404c7f8,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x17812ce47ed47b09cf9fed086e7764010e70afef63a806d9890a0c3113fdd15d,
+            0x5bc448e17449644d41ef38b762a183d1f9c0bd6f6008b4c902ca3fda45d9e4b,
+            0xb8f14bac67ece8b1f9a960f436bfc6a75ae541945689bf78b89e2d768d1b1c,
+            0x6e843ac5711fe5e7551ae25506875ba9eefc93563d15e03f15bb5d6e307b294,
+            0x37c5948a6f6dcdd4378f4e6220a96e4fc27c8fdb102c6f2fe0988b199ad2860,
+            0x9bb55e5908b10cca78ddac3e7a880cf469fc418c8b0ec0e2f96220fcddd983f,
+            0x549938eec4ef16ad9d89081f27be2a2c4af49ae918988ae5574965b506f0126,
+            0x13b4215b89af0652d5598eb29b34ca980cb1a1eb44eaff0e83ed8b6ef5c5cb73,
+            0x2d8f43577fb26728a6f2305e2f868a4298ac5f4bebf8419f072cf709b9bf6979,
+            0x58782a9e8860cb1b60314d2b18e437f36c169b5362e07575aca80c3bbcf8242,
+            0xf6ed9ca8c19eab0c5100e7dff2a1e4d09b3c2ec9e19a9aabddfa4de4903cbde,
+            0x11c3ba734cc607cfaabc73f220cc21f2422ab5e31d04818137793092015a1150,
+            0x1ecbe5795e0f92f55c9784d7687271c7f1d99474a4c9f66fa41618d17342666a,
+            0x2ed6fa55a83b01452c9e30b9888dea9544c10db14356cace8dcddcdb0a2fd223,
+            0x79287ad9db6ce54e8902962f53403735a76fb7eaf2fb92e8fc7e6cec890885b,
+            0x2e26aa5ce56c08151e6c8457e0ca280a1cd8117e7b4fe6895058b964859d73a4,
+            0xa889a87584a87178ad4b8ee2230ebc06301c08cf8407e631e71d6467079ac3a,
+            0x9c2891001f2a119d1126659c30f6123f65be071bf93729d2a76d9bdd41798ce,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x51fce24183d75c4dd506c99b7be05f0d326a972645730c2a76babdd8c7992f8,
+            0x1094ccf4dbff390c02df760b78ae8360348f9ceb187059aff7dcc1a3b5d9e8cb,
+            0x2d4966667b830669b5fcd632c6f3cee90687341f51653aec9f0214ab5db4a847,
+            0x1b6e79f0b003e313be5fc611155d4322d1c56f22957bd201a45b53854291012c,
+            0xc9d7ef70784cc153f1a325031dbb8dbac58625dc7610fd453c17cf8dee3b489,
+            0x2eaba31d2ad4b02948ea76ed4d931d5a42683adb9edeb564d065363190e766ea,
+            0x3af6bf9c7eaedeabe073487509937cd73b00a8fa5aeeccd8d4a9b9ccca1666,
+            0x24d4c2116faf69b99c84e389413f710cef10de5cd87c041669ca51c21f3b6318,
+            0x1f5cabd4bd22948e2c5cd975f92fd0850731301e6291fce364d7f5d951157b0b,
+            0x32aaadbc1decf6ecf33b074eb63f5fd75bcf94af261ed3b75e049d63dbc66ee,
+            0x194830799464f8ee702d72e41ac3aca3c4ab419b02428605b00829948a201752,
+            0x1a88bf75b55c097681b6c07feaecaea5a7e7a84c2d9b549381c51c9b0cb64532,
+            0x2c7969063d1fc97a8d063049637ca6ba63a6cdd9200b95c1ff1c941c390b89e1,
+            0x79a0abd9ba495c5859ff6e10ce393b50c9f04bd92a9261ec1ef7f99f77e46cd,
+            0xaf8f7e9f3eac9e6e82bc956dd7c53bdf91272cc7ae955d734c8f9c6a4e7385f,
+            0x1f45d6872234334442f08c99bce292c089d3f34f4763419d02ca14f24c4b1b8,
+            0x3a4a9d99286b1752d6cb735b9cd0fa27d4f1b8f0a1521d18d1517f6148b677a,
+            0x19484e61180700e93699ea2a7d64814841cf11535480dbde83f6936f5ab68fb1,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x68117f11b7f8d736af79ab2ae3328e576a95d12b637b944cdff9b5758499915,
+            0x118a504d77cc49d22cf454a7cb3d9ae8049efe9447a78201468e90ce576da872,
+            0x1e21ecd473c3deacf25a495ebb4301092012529381b52e0d1286fac898e3c370,
+            0x2e38b65fab0ea1b8152773205f8d39e6b81976426d0d64cf48cbaee81818ee56,
+            0x19414eb55e2b2717e2affe4f6a520a87977e938319b9b49d02db373469bf6ccb,
+            0x1f04b3026adc9f2f0995631d4ee83ad3910fababe4e78dc8b211e9c72084ce4,
+            0xc1cee5ac82b0ba4ac8578c934c415a0f2a50bc7521d2058853b0a59415f6f72,
+            0x1a0b86be3ba0c37e5fcba4f8f33d0af3333cc3bfb74aa262d3d484cbd60fbfb9,
+            0x277f4d465b4a3f950592907b651c5ada6dbad43f7ad0dfdbaa4b5c0edbec7e4,
+            0x2cbc8485f96542fe22965a7bb768cfcf79f4cea845cd70eaac0f6c383f542fd5,
+            0x13b306fd43acac725673d286fbabe249cba9a5194a6b2062953b75149f02cd19,
+            0x19bb715b15ee11c3f973eea2656300c00d6d96576c3724b070f38a764cd58add,
+            0x2579c1bbae48a8bf9c43de695574e7d4576c2c73358b18dd15a1673528fa4d21,
+            0x29bb732726698d3e98745354beed55ada619a0d0e5b8d05cc29f0ce1bedf01bf,
+            0x101b8a972da8e777f74c68fc481c37f0b999ef0df3c90b6505ab2a6527c95d77,
+            0x28d282b4a80e8079287ad62249731647b36221be836c246e9176c6e243623602,
+            0x30f5a91d4bd3a7a00ccfb936619a49c9cae07fdd02d5f7281ead5ec765a5c68,
+            0x23aeb8d675cc85209a4f47d7ce9374c6dd1bdc34caedd947a05836f8f3880cb,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x13efe2b7fcf22b13dde356329022c10caf94d0a67e448020cdf70a2a1bac2de4,
+            0x20116d8a08ef558a247c6f5f943a982d94b63e8a1580c81a049ae62db7550d8f,
+            0x2d082ae4142d9cf00383067665261118fc20b41dd5e3844d95d283ee935fd9ce,
+            0x103520a0cf36cd976f2243249d25d74bd11b4afad705051b28f5677e7726d5f7,
+            0x1e820f7db38b24a06bbc3dfc78c47d040c9dff7d8ba0160b522c6313c107852e,
+            0x275832ae1f1cd86102dd968a76e57d3df95b5c1cbb1ef28dd38fa2bef749dec,
+            0xece66ec104a392cd7d1e5a11f16cac7899588ee5f523b93f779b80f56ee42a2,
+            0x174586e5d012f172439b4d437e58dfd9c58e7d29ed659a7471f0b80151dece5c,
+            0xcc17b4f871cb91bd63924098c54be2744a3131d8a9ad21b1a55069f005ba35d,
+            0x24e6611ad441830b7fc88414d4902bfa9043e60933a6d1ba6e12d6795c3c1b37,
+            0x9392f480df40275b9d639dd95f8a1e0a62fb3b162b41efdb5625c90155fd3a5,
+            0x19fd18a6a69d2e9327fb48fccd6e0549395b2c9362af152d9d7e9901c68154ed,
+            0x174bd47eb0d06dcc5f5121b04bc3c61e02a262ef3c77f11c548b8f2580e664ff,
+            0x1be5877032c20df6d798e8bf265fe511739db9d9b1042b2a9843a261cb5a53c2,
+            0x263fdff0aed026e3b8654e2711dce2aabdc81bf44695f0a6694ec29174392aa2,
+            0x1f71c71eb6f683d7b8516f7de5b5f0ebbf0a581077fde56843c0dfaff80acad0,
+            0x115b998963794a6c504dd65e1b7d99ff4ccfe24b04462b5788cce32861eeed61,
+            0x17f43dba64c1eb81be96ed641cf7801b3a45c614ccb85daa14a8153d4e57e6da,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x1e1c19e05021208ac3fdfe2d3f116c8e72ddd60fb5530005656683f528bae627,
+            0x2596fa2a97ea6905c598c64a25768fa5bde504ea3004705ada129f936ed946ea,
+            0x429be063b1c6a85e848627ce4bdb658eb148f89887b08e4699f37e1c4d63888,
+            0x2571cd3671bb7bd7b52cc19e2291572e4dd8f8d077e295a22907d15cec049643,
+            0x23e2edfaf71fb3796d9f00bd618d48df5454e6edb91a509d173c431668c494c,
+            0x1a9b4db70aa7cd04e33a10c5f4188b7b7546ddb4b4215611965194caec7d961c,
+            0x115d0f27b177d1bac2960bb00feb3be427e4e0184f8f6324d0a06fb47ae2366,
+            0x24158958a69587f1c15512552045620f1fe1569c9f3e3668ed06dffbf0a73686,
+            0x1c6761dde78638d734eb9eb1a1b33a98cef7efa4255fc3662bae703182c01fb8,
+            0x2750d8eade4dae97328c60a645fd3c8431d96ae7482a818b0ae3b4cc46b9bdc8,
+            0x1fd32b82dcbeb8c048e9269c2e53002f6b7fad13aa737f386a6cdfc1e2c5a9e6,
+            0x594fc59fe25d24b2545c6650795cee8ba30d2ae04dd07b5d676b089ddbefa9c,
+            0xc84ab77e8af0ba2da61c55b53cf3534e766735740836aac2427587fbea5c8bd,
+            0x53cb97662f38bb4b44b958d4ec02f8c25fcc795969bfb079e664b87cef93dff,
+            0x1603ca0816ddaba4cef9853184cd3a94d6c881b73d2d6d893db88a48c3de3447,
+            0x18ea8dd9a27ca4410a40bc8becd0b6d42338881ac4c31a3ba7caa40cd1b56131,
+            0x1a527748bdf0057723c86acbe4909490d3e2415647a82f1461a42f3296bf4c07,
+            0x14175f91c0ddb823543a0167ffab7bd8c50273090aead801da30b25f4550584a,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x25f932ba4af84ae43ba5291e604cf8ca5fd208fd16b78c38eabc57286298d557,
+            0x25475d7d649f8bff2630d97844bdc0fe8df6efb89baec75e5ab9bdba2777d431,
+            0x89f1655b69d28450d05c9dfc610305d46a77dcd50eaf28042ebc878caf30d5c,
+            0x123980c7cf8538b96942135959a4af1708aba866cba105e1f5a382e9bb6aade4,
+            0x78cc219ae73e2ecb4025d0e0d90cf09f82f948a63243ddc062872b1070b6b30,
+            0xcda20a3684d79a2e18078fea3261650a2cca213f705b56eeba2949ca203b816,
+            0x21b9c66d1190ff2ddb30db322ca2508d231f7aaf8f7f5f5b95bc1711a672ea6b,
+            0x22016741afc2d1ee9549ce4b74318bef293bb2b2d6495d424cdf700060dc813,
+            0xd722902b755cd16c7977247cb28068a616adeaa13c00b1e2ff628c892bdc6d4,
+            0x217793a53d0ac28751e3fda8caff3f8003b084c474e2458cda30330e338e22c3,
+            0x2d31e0c6e311f327b0e780f291a81e25aebd9660648b0ff51fe8851d29671cfd,
+            0x216d14211de9aed77200602ed78caa665a310ee03fafb5b993ddbb5ae2230f83,
+            0x2681c24a56759b77d5e0a7afd37d286ae3422745564fdc15d25e0dd158c9f4e4,
+            0x1e3b6edad3fcbd9d991c34f5e4d838fb76c255542d27f82d58989912b5bc7dd2,
+            0x2eefb7b5eb265aa610c4356f2282dd92a03744a1b8484dedb115321df7518c2f,
+            0x5a848b35a8e270224242f52686cf785d9f11ec3bad27529c02f6448a432ec41,
+            0x9ff782048c9d9aa8690ed707e82164ad320e1daf646a3b30421f03dcf772423,
+            0x2b294de4467526f4914af8f9895903124f2a91249c23e8d012a04e3b6fefd504,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x27d44f13d66a77a645f895ff821ddcf8cced8c8af984dbb8cf82b84653a5db10,
+            0xe50c72da36c1a968102edf30c6b810795d41ce41c49783028cd0830acc37c98,
+            0x2341aeac831f989ac84a00d127c0809fbc0040495ad77e1d1f589cebe120904,
+            0x2071faf6e96fb5cd4400b6c58eb4ff5e527bf7d9492180bc2f4534cd0ae0679f,
+            0x14da2ed4e175cc095a8d68ac6e7f9e2d702e82b1791204921bc4806b157be02f,
+            0xc6232c7e84ea35400bdc0f7b8d0cd211fb5186df1fe8e927bc51ce0247d13cd,
+            0x1f65c4563e9f61ed7f7f2eb3fedcde581ad3b660c5079c16e7ddb053facc5396,
+            0x144675f4c54bc33e1bd7aabe8685c740738cf1c7891c5c659b07c6281fc67a8d,
+            0x14ece2c3c47e0435cbb019db4708ef6c904b4af975d729a0fcd75e65abf744ab,
+            0x118f931e904fffde6ba4e22eb0429be857819f9fd64f1273253b3f152fa18b0e,
+            0xbade4f966d523e4656c44854982d4546abfe2f5dec203a45cc463da1093ce09,
+            0x1783c94f37d6d9057a1c2e78e0d0f78efeb161a14dc2107a21661829f135d226,
+            0xdeaffffd0feb209c00793e5f800761b5419d8725f4c88286eab224160ec43f1,
+            0x8746a72fb64c2cdc1ef14613cb535911394a29c802d4a6a94cfef844610c609,
+            0x4882711fd9c5508fdd0a1ec5a2a0810b93a6cfce441a192047a827f58ddb2d3,
+            0xf2b738d3eb3b803bca325347b7af954cc10492832479183808b3aea72435c2,
+            0x2b5d5eba00e09e21bd9202d72e53306361608eddc951ac1f08a53dc3bc6e955c,
+            0x16d96e78a6078437404b5bf21aacd5a43d23ddd5bc2172412ad36390b3ce4512,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2f6fd52b25a9485df2878599be34808517d5eed6c1d83ce497e1a9ea8d1c3844,
+            0x2f0dc0c61f11a53d419b3fb805fc2d476837c53c1c990c66fd1539ec9d2e4e44,
+            0x1b004ab51f77388c427453263ea600792a6be597e6f736509c2dbe87d4a298b1,
+            0xa690789ef915053a2ed12aa90a8621340337bcae525139c9e1ab973e1bf8881,
+            0xc925171c7431dace3626b7e5036dfa622bc08747fe849d6a6ae5c831143d104,
+            0x27e2a355bcdae99405fcd39ac25b9ffe773ae5b0ed9a87a9e470715fe2bc271,
+            0xd44cd56f0210228281e116260bc8aabf64fa0701601e98781fbc6b14faea9ed,
+            0x1ee8d9f2950080571a9605c7b454c3480e64876ad27891241b8f62d71d6ebfdc,
+            0x13edf09ae8addbf851e00d79fe8b990277b431d72ce0d9b48b55e3095b483bfb,
+            0x1d2c7f3a44dcbed040fe5f5dabd49064622c34af68c5b4afecf631fd998de93,
+            0x17e04fb5f49c12a6a91bec113708d943cdc774e64c6ec431bdbda3a6c1c0f57a,
+            0x21d9dbd68c54cdb2ea8beaf7de31afad1cd404c478c62e8f59653895909a18ba,
+            0x276950c5f6c44bacaee68fd94f14a44a07a0033515b10a76203ab2b12bd60440,
+            0x2ca5b12a8ff6ee0156650ef67333a07ff08b156454897b370734c4b98977c6d0,
+            0x2379fe3fe77b505f5fad59cc93f5fed7624e99f5359c30d56efcd0915460668,
+            0x10e790cb3f6be51c0b4fd7f6e29519bf9bec842ac6e0f6f5584d5cc1431b5c56,
+            0x20a94567158dc5f7b21cb0358dfd6fcf75abdd806b150bb4ef55756701d568ec,
+            0x191a6a82b77415d9a305c90b8189e93ad9d915a411a544d0fd090a157113d557,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2ce2a89b4c51f97166c6adb43491a88c24a3276110055a0deac88f7e71f976b1,
+            0xe85242efe6b78087e6f76495c7bef828bab7776b3b6f5b4ae77b9a3d854933,
+            0x92654dcf9e69fc2da394139bafb0592b4cae24d00e34981bddcd4b089dd948a,
+            0x152d35166a3e900ca89d58fbdbe99caf3bdb1f984deae8e02cf703dd55e78a6d,
+            0x250159b61c5e545befaed62a349cd00e1fcd3ea588f29ead5deb675a0101d936,
+            0x1e66442753c8d95188bb9f59bad17a6ab9018f052ce8e1de58790b59bc4cd7c7,
+            0x1a91965586db156cc0d4fe08208ea762030e390bc498435d3a04d41b95e854cc,
+            0x205d22ff80ffd23060ee1aeb5050c709a63a4eaba0847ff587171db7d9ef27f8,
+            0xe92e1e54bc59e642a77b5333ddbb2e15594a1956a3ed0e2605dbfe4cd29dd9d,
+            0xecb39d5fb42dc2dc2f2b74c13e24307a1f3be67f35ab79b0ac974eaf4a0c41,
+            0x77aebae118635d5a0e0160df4961f3c5b796887d878ddcd2688fe1d618150ec,
+            0x2d0db6e2eb4386d10a3719148038523ebc7baf66dc538818b0b5d843002e07bb,
+            0x1dc7e3849dcf39a59aa7a87ef122afb09009aeeea37dbdef6e850e57ea37f604,
+            0x97559815d3b62c28056095e39c8b1a8e366bb8aa42af85f673e45273d0ae1ee,
+            0x7e08fce9a5121c2188a96e591b92b958da520778ac0bca67b59da2b3b06f0fa,
+            0xe3d58fdb4543949957ea33bd03e3abbfb109a1691de6696419d4b1207f542c,
+            0xc991fe43818ea306d3b776847d14f4019bca2070d200e07735c62da31a3138e,
+            0xaec16bb8df541908f11df6a64c676183c76bfcaf7748c503d6099acbb3f2a9c,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x85b7265354e883298caeca1761cd19e2c5c2119b36c37d6f5d666ba8ecbf19f,
+            0x10d7d5e67042939ab9d5eed4d520c3fe081f9ef97b3ea8f7ffec5d5e1889e031,
+            0x1cfac1f08b7bc16a7482dede1d624a8637eff2c6f5b38e5fbeda6f6bc5cea6d8,
+            0x6b10274305c15e9adb7f7fe7cdbb4071c1e4968e46e461c6642a861d0ee68fe,
+            0x2cf401be1c32c95cde4ebfc65cbbea9c09f9632239b314f53acc63bf37d86a56,
+            0x2fd0c9ebacd03258bfb689a7a700d43b1fec422b22299d73e478801d9533a36a,
+            0x4ec21b44c21c6c358789f92b5d126597e1b60f05050975b924cd7042087e630,
+            0x2d42130581a19be2488f98c4473e80511c275be79f5077db40b74b43881eb4db,
+            0xdf73be8b64e045f882edee4f17e9da2c5f25b2859e904595844adcf3df8f7f3,
+            0x1b05101b32ca2be2837624bd01f437abcd43cf6c4b561052e0e6df3d5f0ee39,
+            0x8a4f42ecec6f626427ce116b20f3405898759d0531091a87936427a99d5c919,
+            0x67eb4a3514d45d7e6468f85a7a606eb86395bef7b23018f25e133f7416cfe65,
+            0x3037c22112964f6f3d8e4a607f1f35ee562d505e4a22fdf24b41e6c03e506785,
+            0x23c4745c095e5970dac166326b875df52d94db0c9456b5afb55077d92996a8b6,
+            0x12ca85b142f5d2d2d87b44b4f190810b0a2ef1cbb96ffb43fe4094ac0bb450f4,
+            0x262501f3e02e6a5c95bfcf11749917b22125ff7d02ecdfdadfa374a45173c662,
+            0x2c3ec00db9c8e44aaf94ea99dae52f7688c663f0b42d186fc1d030813a4ca1b4,
+            0x120aa50356c54653eb5399b101bac1eeb8d728626800003f8858a183cc1320f5,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xb6c1dd3d2dadac79672ca69e272e4dede9b2bcbace5d12db15fd6c855bcc7f3,
+            0x1dc5cfb71f9c9ff08886866b9270504c330bffed807e5f608839afd49bef8961,
+            0x2ba9c16f49734f3bbf98296629f2a1a4e6d1b10063193206528ea39b11869cce,
+            0x21c37ce612e1b0d5fcb0271e20f27c062dd81f2c8efabe92c73f54d87aeca299,
+            0x29ca29c57a516f80006150ba546d332ace95854d3dbbb9ceb57a80f221f45b75,
+            0x9644e84f727604d62f2d77c2d5c1897f8b90f362740a8c6eef25ed898e18ed2,
+            0x18488a89e78505a807ffca282555f117bc71bfbbb9443d7d06e3060d9798728a,
+            0x17f99a49abde27c74d8fe51bbc0a223591121cb9c0efdb32a6ef4bbbc976049,
+            0x1106936fe4d91cad9dc00af8b85f8dfdca9298ac4207788a47c97ebd5adac9aa,
+            0xb19213f24f13dd43d620c6d4fe77574e3ba66807d606f96055af06344a953cd,
+            0x284fb79d4b5bdeb823b0a7e93566380739c2ddde6f2c1cb102f491389af88601,
+            0x2bee8122aaeb513f5cd47546f15090cc6730e39d28df08a9ef4f0726dc69a1d4,
+            0x109712b4385f9d1941bc8ed4cbee06fece38379f962681ff1f49f2c7577aaf01,
+            0x1cee8dbc9e7c22eaa815aab454705b2c2b61ccf56bcc5181d8eb9acd08a4b708,
+            0x123f9868d7ebd3d7c576a79f4bb3f0f6f8466aa50c642b2b8fb2938b2533acb6,
+            0xc0fbb5f96f795f870d7a4affa961ab0a80a95f9814f2231debbe27352088c5a,
+            0x3b268cc3e3aad22d4f8e5edbd7c5179e219201ba62987e3b4a5aa484a30c651,
+            0x2e3ff582310fb1449330c0dfed129154d2f8aec3871d2d593b73926a70d8e5f1,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x18b0d069fd19a7ac7776eb39fd607c75bd860a3b2fa17f90f1c016881eba042f,
+            0x12f75e7771d5d27c66ce2bf10cc3e3d6d542f3d39f1847e2fa726386ac83c28e,
+            0x107b04155a7d9c1881def05be1797dbc8018beb8fadfc9935e569e2f2a2aa474,
+            0x17318bbc96a3594382626c795cc986dd77a81a983bf0bcdc9aa59e6d71a59,
+            0x132974c4fafdf621f1fadc45daef9bfe5a92a1b59d33056448a125ae2654d20b,
+            0x258538ea87a962769068037de62fdd272eab79bfd68489fbbd478a7cb72e068d,
+            0x2cb1201c76a7fa15f79b9ba6ea261d17e0b62c2643709e0f984c937c42115e2c,
+            0x2e65cfe91bdd49c663d8749f335176abaf6377f582d48484f6748e24cc816647,
+            0x2cd3d763fe99f1b6627e6352b95ab5489d191d0e5d41df07810fd7c52b9db26c,
+            0x27bc4a5ea2a66172650286cbea4ff02ee1869e854ed4fcc270c8679a38cc8ef7,
+            0x88ff579628efad419d54070c10f57b7e69348ae96ad0fd68b5daaf303ee96da,
+            0x1cb43928e58efb24ee214ce17d29752fdce31605fe517609a60f8d2edb3ac6ca,
+            0x1dcbf79109a7193b75fd86b82c1590b31abb899d0fc5da91e43fe9cefbe45a4a,
+            0x2758dee8dc30394bbf30a412c6dffdb1c7b3c1588f4a93e9620db80265e128c3,
+            0x18d1cf4a6c8482ec7330af0eafb66fdd2e4289ddfb61c36f76fe87c3648aafe3,
+            0x2485597cfdf560f34e11989c881799ceb14143e0d5c4de20ee4a407904cf1e05,
+            0x6151f2ab033782abc7bfd3aaec47dd9c428681acf32d745e37d0be4642aa764,
+            0x6d2e5ef950f679c0195dfda3966ed8f2db4ccdea5739731627c012a453a9d99,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2d3138fdcbae36004b71f47afa0ec092b328d2205d4952b47e9c90f286787d9,
+            0x1c8e178d93f93f9cc56b13c437128dab31456360dbe2415edc316dd0a4cef579,
+            0x25bea2246bf9516b6fd6299407d737b445cc6e2f158cd5944c194852cc32956,
+            0xffdd4b3b72bb34089f3b91170fae0a6560efbd23ad5c76bea5e8ce46b7c9f3b,
+            0x7c622418ddbf99ba65d8ffe6296f3907c1589d4ea2087034bcda1f7c52218f5,
+            0x170dbdbc927d2213df51e928d1288f1bb989cbc074537cf64485b5ff05ab8f0a,
+            0x6111fd3b375eb2fe504987aee580cfd1acfc7c39cb7a9171adedaabfa2656a2,
+            0x25b706a850ee172c03d98a8a1a04dec56d264d07d7995a7bd3b50996f552f9ea,
+            0x13a5b2bbccfed9c5c5f846496df832e8b3166104a183299b87cf2e0dfff8964,
+            0x256b7b5635f25f506009162f09e2aeac9a24a22d194db0987e9e0196bf805ee2,
+            0xa0d91ff25cbc2ef3a667475f91299ee679bffce4ece8eadf3ae0e86713e6c4c,
+            0x1f799a5f2a9fe2846d8fcbe9fef4004f2aab2cfbd8380486985787f9e82f739c,
+            0x8f8a5d38982c8c9eba1afb2d463d9b87cb412064271a6d721823ba76b13786b,
+            0x13f2f9a571f61c75b4485d9f3f74d84222f1d3258f5446e9afb9d82bbccd5c5b,
+            0x1ada050207bf232b77af0445cd3ad24ac2856a32df135462c196b718a4e2818f,
+            0x2270c97bfedbe3b54bcabf5df1b60fee20cfa8b1dda8ba4c832b580d71930c59,
+            0x17e429879da51390e1253592134df6fc0e6149656142baace891a5ac0b3dcad3,
+            0x2ca1a03e86b8e8d2cdc32f998a9a2ae3d604104dad81ce44d7b70b7d2c147b1,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x179e9cc5ce81c3b957469968a01d8f4155d1fab43566892efeb4aac8e730bd1f,
+            0x245436e222f18f0a95c5edfdbe70beb3cee0bbe4357c0ad27ec637b8276be10b,
+            0x12082995e500dde2a8f5e3db03cfb08fef2e717c59536b6a48a757fe897af0b7,
+            0x1ed351a76be7e560be38729f4c221d52e1b2e6b1c9a9906925d9d7fc659af29,
+            0x22cea0520bc1691068292d1320ab844c4ff641bd0f3f8b3bce4e50b5302d4291,
+            0x10d8cefa20bdf64f680f9f65e2f7f1181485743849125ee5009bb535fbd6737b,
+            0x7cd86f2f3733907b2893e812f536766b45c7590516b8e0da820af563de5053d,
+            0x18f7e2b8ed7ea1c7ccf0675a588747409ffdc5e0d9a1bd80b54bf47833ba43de,
+            0x11ad65aaa14357d137232ee3e2460a65310bfeba447590580d165a80bb87bac5,
+            0x149ddeff968dd3e4873a88f82aab2252e424934d62cecebf3c05e04101232c6d,
+            0x216e4879dbeb136adcd2e2f9c79d1a899123ec8921531fd19e8f3db769e9b9a7,
+            0xb32ffdc93ba89e798035496aa0f0e5f35173420d9605df5c29176b9c8fea9cb,
+            0x10059787e4b7b91491cad89e95af648197aab657bef0347224aafea1bd70f0f8,
+            0x11feafbb6d30aba9905fc46b2cfa8bd5a1cd6685c3411924f652003f98ce61f0,
+            0x18737f1b8ed644fcd203182f9f71ec606dfe5722848319eb06addba0862192c2,
+            0xdb96451b25bc2211c315c94b7396080febd132e48883ba5be7c6352454b2531,
+            0x14a12c8868c6998c77975fb80588dc50121cb3fe9070179f48ff086ddb44cbec,
+            0x64f7699ab015d1466ce5ba0fd8a92531c592eb91011e024e3a90dda0d38d3c4,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x27370d48e084e132bff2e3af0f91f787a9648ebd4fe7cdbc1cedec26c11cff0b,
+            0x16f9385f9edfa3dcc7c06b94ed2c0d8609451634db5a4e6e1997cc144e1415fd,
+            0x148bb2cb914552eb1ce755beda59e784541d31b0b9743c10e7d6d798afcff7d5,
+            0x2e9181388b5eb930247bb3bf036adace30496887c3fe5e51a08501a57834d778,
+            0x45e39ea727e4ff254ba2593f698f79e8e4b4f538d1b263912ba9f0d572a8eed,
+            0x1174f11359628820efaa3cca1f5f19974f475fd989692911a7dd59754df86a59,
+            0x2ed2ce65b2ae9ab3e5c33366e50e7f9a2622b21df40b38e6f0606ebbd6399143,
+            0x14a902e483b773bd59d298c316ba79c4abb6bf6e625312672fc529ad2e1334af,
+            0x1e68f7bd5130ceb11d06b8075b2da5fd09c5e2401fd816ccf5e6b14f3ce77b4e,
+            0x29827cb7a70ff0095050678d19f2eec6994c2db9aac20c2328029b37cc1d94e,
+            0x18b67ae206c91b0907dd5cb14430d2d00b7ca10382cfc464c9451accb64b3da1,
+            0x1bab9c538b70fbb24712c9c9fcb250b2725138131fc8887dd31c0ee10d7853,
+            0x1bb888723fe04304ff56a7c1aaa2a13edbb8c6d9b84c95c34cfaa32c44cb18e7,
+            0x15b938c5888d46730f0efb92f3829ee53afc9b4b9b3e2a58729c31f21c078085,
+            0xe56668d5e18b59ed8afb9f3b66f03bb0d8d0be49b2ff0ee4cf05802a6840a2e,
+            0x286d890c9e0b00dc5a3185b312d61f861935f4cf230267dd147843d085cb9814,
+            0x169b367b1b5b432d3e5f13374bb46fee87ebddae52745969b4d80b371a52984,
+            0x2616061981a127f1f90517d00c67ccf537e6a1e60f76e2c18ceca5b4fdd39ac9,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2505d3c4eb01aad3e3759156410967fcb1309f9028133f32b61fe8dca05e7039,
+            0x6582da47cd85c00d4e318a61669afe8e1969d2c486e76ebe01968bc21302418,
+            0x41b8979d269f6ec28ac184c5b2f02af58c26351c6cd943cec6adf2369cdb1e5,
+            0x1443d53abe81ab259cbbe0494e98dddbd8284c1145321c2fe24b0fe672cf9115,
+            0x78377bdb2570000965c2505997614b99e6affb63d0f8ac1d8909ffc8c2b7826,
+            0x21343622cb874753f0d2c35633e7877c6f2f35247f080a1b0ef7012721579271,
+            0x2726e864c23bab466a4e2e9c1e6c90bccce6114a31f4283b8a87be3eefbdac02,
+            0x8c3cb7979e51a25092b8e3667b5ab696327cedf1db257537071a718d7a4a347,
+            0xeadc7f0735863ae63f6d3a2d980cca143ddbc94203075b1a9341fb52b54e7b6,
+            0x302733698edfe476ce1360d9dd8885e2fac48f10fd9b6aa494ccc84663016071,
+            0x390d135ec3fb0cc6bebb4ffd755406169d4b71ab559edfc3d03da2739f99c35,
+            0x29814b855ae75985f8c5a6475383bd701e5279d430aca51d87671614a2eec37f,
+            0x1c8271bcd402c844d59746fbb8c809265247177b175fc929101de73f741709d5,
+            0x2ea7af5aff4c8335a4556b1e621c3fb76e507132971a4452635d76310c241990,
+            0x3758c3722cb764b0eef270fb45c6c76b9d03816b0feae879a3436fdc9ba2abc,
+            0x2122e9a87a29841216a1c1e5dcc02363eb1185edc68f6eefdb38fc43454b588f,
+            0x2e5132a0aed649314c6665d51926a7a15bdd6a1a5c6f5134faf96d52caadd140,
+            0xaaca5b7aa27811dea3376af9fef0cd8275e8f98e235db83ab1361b4c49a834,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x203898b92bb3f8344f220e9f0790ab77acd669b383111e300fdd94d560eb661a,
+            0x1d55edcfada4cde82093e306a8a85e703e70d62f77f83aa4158c7ae06558e2c3,
+            0x1c57ec21152ef1becaac482ba2cd28adce9bce68434b291a73dafad3a2a4ab1a,
+            0x2c77f75ff6857d39dc5e0ede6ee9b6574764e4ceb3d2235aafaf9d8c296bd1fa,
+            0x264024c571ae242f530a593ade47778e04de4fafc1998d04196b3f8dc466b672,
+            0x123a17496bdc1d2ece7ee0ab1632b43c278328056b8609eebfc76de77780e8b3,
+            0x15d806ca8c7a7c727e02ed3aeb1210453d4d39cc3f2d188f421b58b7fb9b5fe7,
+            0x2938fef22503472ffde7a36b04c4b36b639064aeb9d77fdebff756e82ed8e6f,
+            0x1d5bd19b2c05765e3c4b83781b4d0037fec97bda292e3167002587051efd0445,
+            0x5a5ea7612d82dbbecd031202c5503ab73cf5ac0eceefea81ca45697ad5dfbae,
+            0x1dff1bb202e9a71287d999a4436ab81298e44daded91984d6422477266da4fa4,
+            0x1a65f01a835cc6df08fe1168ef8dc72e04f3c84bc4129d8b1c57c7055fd528dc,
+            0xc6bfebef542cd78b44786f865317d384a64ffabde52f6a5bc29f405d3e45c49,
+            0xa06a55ed8f52246944ba9e1b351b0f04e95e8e3c80337f7bf4c4cb3682ccbe1,
+            0x237af0b506f0185fc81451144bdf3ccdf7b66cbe1ad77e2ce4212f62d6271006,
+            0x1d6b421f3143a560e5066eca69e6939c13cb2fb22bcdbfb96e8d55af76d0a7fb,
+            0x1ea4cdc48eeb87bdc70e034a0ee1ce699e94b5b1126776f3bfa43c2facbcaf12,
+            0xcfe1b82dde8c5eb500403f5ddedf6165106b28c70cd941f1b65e49725335b68,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x10cd524d82fe05ba307dd3aab96a838f6b1fb98e10e284ccc8f8b2b9585a647a,
+            0x29069f8a102d5fd5db23e1e81b42867620f6af7e64b36f7444176a9febaf9a1a,
+            0x3021dd41004ec315704a8d77ab12c93d89a3baba330666cf8b96cc8042eef1b6,
+            0x173dbe8f25c7fa7ebb28578e0fd3103fda835507d8b53d905189757d6638eb50,
+            0x1ec7dcb5fd4210ff0361f44b48f4818dfce283dcbaba35c96d77ec9888f43718,
+            0xe52deb0da59b5f92497e0ba6a2a358342a8d731ce2f8c19c8df9d58ecd818d7,
+            0x77276a2ab3c0fad69733ad1fd53ca148350ba77681b6bc98a0cc52bed3ee671,
+            0xe62986c860d75a4502cee8d7d8932b7c77a9330c4b0884cd7152383cf21301d,
+            0x1977e4ab4ef72d06317496905d6cde467a424f82f7491ade88b7027645c05600,
+            0xe5fc86e5a4aa5897a6653760a4e72555f0ff79de77d4de9f5aa20db5afbc65c,
+            0x133c080c57426c50ae24fbe4145ecad201b964fa12abdf7ed16ba45bb76c0d56,
+            0x9809f0d9404684e91754565e4ed714b4853b2dfe29e44aed4df3df632f9664c,
+            0xb9ea2ad9eb74df89ef8f3132245aee0f0d0b3c91975aca7660071a8066b9fcc,
+            0x2bb6bbb4b8f9011e6167cefd64bb4874f6527a7eacdaa10ef403474e332824eb,
+            0xe7505f5d74a168934234e8a83b2fd267bccfd4e6c79dd64fb024268dba03ea1,
+            0xa96e9aab6d37e9d1a4d3e0ec375ed16cf201f7bf07d2db66c43d48f7dd06d2e,
+            0x19109a9f6cbaa378475c1ae70ad79d2f83100b33653b9a16bd84cce3e651616f,
+            0x2455d14dfc4e34f8b2f0c411722c66ec626c1727fc695abd1c849780bd746a0d,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2720fa35b76500f2acefffd7ebf331c17d96a400b4084b78253e3284f942f855,
+            0xaf8af05904f43895b5e9236f1782ff4338cdf90b962a3ac0d086812ae628cbe,
+            0x25f57c83e4d1831829078d17e98537d56e3c3ca16318f2792b71a07055b11f8d,
+            0x122275903e7cd0419e6c815909fd6b655ef0f3516f9c9767ef7c7eb3d8f22465,
+            0x20da2a3fb1adcba29246bb19e16ec3a9f51abbd59aadf30737ff92b8efc61ee0,
+            0x1942ef506c145d9b15ee431212e1be7bc2861b49e7e68c6ac9dcee40344749a2,
+            0x29c8628087cf8197c8538332d6f0253bfa46480244ba31e30d23704022f55a13,
+            0x23ec0870cc4460faa687538179bbb9f395a1715195e86a6bb5240d5477ef3193,
+            0x220e9648212c6250017065d86188b9612f73f9039803bd329ba7040a9e53f14e,
+            0x1e424309dfb1a00240f4dda0e4ddbce8f4ff4a57017fe888e78790e7bce6e92c,
+            0x22dc20b39997ba1b40288caabd9dfd3e9f9dc4fd7bcd9fd11079bd602a2fe535,
+            0x22275186225901c11a65a53e0a89f199541fc1212b4e96aa7bd3c5bf875ab52f,
+            0x17ad868f1ce516279d8d50fd809a1c40e78010418c7aa4ee6a09f9b523a2a61a,
+            0x27dff28396bef2873c44964b33b30e44b27a8fc1d08a09175f1cc9641584359a,
+            0x9022e1272e97e9aa32634bc3bfc10224a2eed161b9b60f101595f8df207cff8,
+            0x10e1f1602cfc30dc4ab3920be41ec7daf5bbe3d96dab568aeafbc350c5ee934a,
+            0x1b1aa6b279c2a5fc8dd9a622891bf4878aaed7122fddeec0a20bcf2f9da868b8,
+            0x283b86d8cbfdbc913ffd3849a5e70f92b69f5f7917a0401db92f6f1ea11ef2d7,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xd21897ac3d9b9e3be9e5d182d1ca0441cb3b92776df8798362a4bb4035aa424,
+            0x20b3d4db18dd6de3efb359c8e60c86f1d21c20e7a9f1dbe67c4505ee7a3bdd67,
+            0x27db9f494aa78c119ef8358a8b122f4aed87152f92391ac9d187f9cecb07237d,
+            0x203a42bc685316f63fe61c9146a7426525fff758fc625540d9ad7a5602c6cda8,
+            0x2786086cb07a5e84a7bb5516818a0139fbbb33881cd289a36d55dda334f0dd5,
+            0x17197184f893d19475737bd7202447e5ef385d2b5f0a5e75533cbbea61e7d791,
+            0x505d0e83c6b5bd0ba7da5059689f8f448b27321c23ab4da273db77c954d55e0,
+            0x167393ca748cc53ebc1ae07b28ec6a3a2f0d4113b4bd302cec7c0b398a48715,
+            0xd479338ab58fc837c9197c0c1c5a3ec515cc52a1a9b2d42b7a3134f2fa13859,
+            0x21c2423dd4c9fd1d183de5619442f91ffda880143e43f16bbfd42806fa6c7417,
+            0x2cf480612db52dc3cbcd0fb630a07a92e2ea594304763509450bf2d199a2cc55,
+            0x71f821a426e22b9a20cfc997f266c5a7a9bb521f6a7353e25dc163a35c07522,
+            0x1461f8fe38f4a760b4f4d09b51e6a126d4c5e9ea529eb18c7c94cfadd1ed45fa,
+            0x1357d0271c479b5dbfee4a3cb14ddcedd8cf50365a31166c5462acae0b72b38c,
+            0x2b328c0d80b8e81a1de5804422b454f019947f4cc167476ae5ac14862181abda,
+            0x2e3b540ace24978dedde505b42c9bfab888ae08d442362449012e0806891b93b,
+            0x1ce4c3196ea44d6a2aacef87560cc1df5d652527f00924c598abceb3fa9fae01,
+            0x2851d688c92c184c79c18d06e3d80ef439074686397a5ebf0800004ed10b715d,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x196637f7373413fc37b3ac318b969590ff0be31ced0513dca26a263d5dd965d9,
+            0x174d93a947b4b73d687a5ebb5a4fdac7afce1d9c34af4feb7ffc41be2aa210ad,
+            0x1a844947654e868c7ee686ab18a2224639739de7ade503530f19e2743f3640fa,
+            0x2ca2906ae9b528c0ff4e3e3257c8d319f8c1368eb73a80ab26cdf1ce15cd497d,
+            0xa94ad92e43366cba7b3db85cb00b7b950f1d221f05642cba4d9519a6afc9a1b,
+            0x22bbc0a3d2c1cf2c8556116779eab7110ea892f32dfb0ba1db5ed38c6fde17a9,
+            0x1e04ab6b0dd11b6c3f59c29bb6fd62733161d74a9952794eae23df935454357d,
+            0x229f3e8f6afdba218d948aeb539787170f4e836aee874123698c47fcf37c175a,
+            0x995cb64172f8220d642030a21f1d525c39724738d58054d8cb6ac84a16aec03,
+            0x12b8663b8e3a6bcd9e2d7d334c88c0fd315117db2052793a7c2434776efb8358,
+            0xe306e47bc917fa7e38db51ab6102290228c40250770884029469817b112469e,
+            0x290d8cbe5211d46c41f561e89988de784422a5f75088d0cbf2679d753af7ca2d,
+            0x1e0aefaf9cd8ef424965e8ac51a7562e11506da29886ec17006b289370ec77d2,
+            0x4df18fcce60a87f50455c9d563db8f7630a0dd63c55df4a3f549ce98663649d,
+            0x95973dc58f6505b00c033973bcc95f1d068c316710b63260c75e300e8f20f98,
+            0x1d18acab418de031d02587a3df05d9dc50321e206878959871c7c2681d9e9ffe,
+            0x213d73843dbd3c4e90fe3ff4afb54f113a94a1e94ae7c93e062ab7cfd7ca42a7,
+            0x13807261e197788f606915b736d04f3127e3a532870f6a2885a09e47c7a9bb03,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x250b609ce88f0983f177aa4b1293825acf49cbe1ccc1d0d2218eb7b54d8720e6,
+            0x2a3d7388587ce77ad142e1762efdf17d8904edd69a6a90161b19a806ca2e5361,
+            0x1905f00fc3b1cf3fadde47cb7e1b25bfd0fc503fa90b34c13b3b1d660fa8478e,
+            0x28d30399b0b09d77d5113875af727910162825bdf73eea4dc375729c8b1b4415,
+            0xf6056c7c8bb29f47a2337228d5bf342fbedffd5237d233b3f1505e09b063b94,
+            0x25e6ecb2921119f783a410b7d24c83a5d9c917461edc62d0cf95d21be424a561,
+            0x28da486586fa7a6ee7a2505d51be49e38100470b4ede3b1ee7a5c364ca500cf3,
+            0x1e7a7c44e72cd5a635bbd41a543c9f46945b7851ee8b482871b3176557846ad5,
+            0xf8529665d21549208b12388dbbd55184f23fd713258c518249d4ee7f3acda6,
+            0x1632d84a0d31502ce509b0149da1a5293df1f8c11b2e2f10d214a2f52e4ca22,
+            0xe576e8ba8cebe7bb81ab72d7bf1a08c9830ad49016e9bdb83765bc6a05dd3cf,
+            0x116f9f8556eac9dddd689100fc4e27dc9a42c4534322f4e18379bee32b53adf3,
+            0x2617cb3f694b9d35852d5341c15fa51a47076430dc407b88dc708a57a4dad9f7,
+            0x2e1dabfcdc2242aaad7c5601c45aa376f8bf128954b04c477946e91893bcc19d,
+            0x20561db57fda4a5d18be48461c4209d39b3fd760fcbcee93874249d4a56dd4a0,
+            0x25ff336f1b5fa16576da765273bde6d1966d96264cc4e70766d170cffa123475,
+            0x2ebcfead11a0a9f882539b2129420c8c952361a46298713c3ed4d5d6af8ec602,
+            0x17f4133aeaa19e905765128b43d633f345bd34b512f2eef16a1dccebc1cc56db,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x1b3a49687cfb69278fcec9c9024c2cca61a3ef43728c21bdd11f378bc219aaf3,
+            0x21c2f9fbd8e7212a57051f8e39c6e68f3849797e36692723f44e0861264a5676,
+            0x115d3df00fd3bd6e540dd0390165eedc883ee6efc07b409f3675deb598eade42,
+            0xe5729bb5e9bad3ee592068ecaa3e9fe83de56e38603925bdb9862a460ef4615,
+            0x285440545506adcfdb2776c74d3aaa25f7a7b0de3b7c55f0e5b87fb7b6e0db46,
+            0x233f80e930f4324a6a0b146d07acd6fc8f3d9bb48cfe1f072d75f58da84e1eba,
+            0x21f9ccd305b8bc81a6b2116e883c69ad27c8455063e66e31d6da818ad1e74de7,
+            0x28fe2473f0cfc0914c93b9a49af57b809d9b205f2631dae15c8c9efc67c5ab3d,
+            0x2ec03f45ffe70531d6caa30b55289cff6ce7f852160797a2b9c90768c5c4692a,
+            0x1b6d0de6db03f0bad2f0d4879bddc431708a821df4cac5ee89cc9c9ef70dd9f6,
+            0xa11e8876f08f694ed493dd39340e775eb7a6a41aeeb94b274f24be97e39a3b6,
+            0x17ede99ae68e039acf3cb8d353b0db916c2f2e721f19965a474f47f1341cdc16,
+            0x18fff4f3ec52c43729d8294575f23f8bc41d85b9bea877df8fd12726dccc4909,
+            0x21df71f2c6a62f3945fddce6d52d2aa7d326b29262ef4b298027c26473b9eb10,
+            0x11b89da0475d9f041a5380c999272eb4f787090d1d55b9860ede80ba3983400e,
+            0x8dc1602808b04a2f3c3a15545d364304f4f7cdb9dbddbdd6f632991d0a5bc34,
+            0x7faf1ea463a24aa2845460d38458855ebbfcc9e1d4e775a350a0e88275d6fe8,
+            0xee38f40f3c1ef1102552cfd03824d68bea40bfde95785d7a4c3adfaeeb4ea1,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x17fbc184678cfb88bd30c7b1c3d7b28864204d74133ef42de469187f5ffdeda4,
+            0x1cf9d597555605a940cde10452784e867f46a2ae74fe0465f4938c46a546c3ea,
+            0x1c092bb49f2b4366b33e2dc2f6ee171468f95570188e4b2995b925b5539e8d63,
+            0x12f62053127e2084dae1db28a6d94ff62ef6a1a4732ab052b20395d0cd4ad478,
+            0x1eeb4476ad29cbea12ad7cb44732113e58c0ff598ab4648df979c474eb3835,
+            0x2c38250647fad3eedcae687b1ab54f6daa582bd29631c73fea1d2f5c403ddb7d,
+            0x2eec86ab0272f57df25d8453fb38e9fcf0dbcad228ed15b9e7ff30dc91feb902,
+            0x254f0f4597efcac8bf9ee78bbbfcddc5781f71565217ef7af0beec6e5d5f06fa,
+            0x12a47fcdb1b19d720a4398b659b2c74c27adbd2c24ffae0101c4d129bece130a,
+            0x1bc890c0199da7edf2f39365c4118f3c1d1ae24d666af9ffb83ab48b3e00a204,
+            0x125272075c48ad5c41dc73c2d27de0026796d6b47932bbeef89bccdf92fb7598,
+            0xaeb8e71cc24b05d8b4a1aafb1a16f8400cddb91e6d42fc8588ce50a191b8c4,
+            0x60ece14c283b3465418c6b9a9f56cf9c96218b68576081014122ba05654b3,
+            0x14728be414cd1dc79e436e4d72fd9392e44ec7d6093af846a49deb20f2823269,
+            0x21d5f66e745ef28c0f7178722cdc14bebe02412911433fb460be724281ec8361,
+            0x6bc631335961a7b600aec2c433a850ef58c811cecbb74bd1244e0304ec9b6ef,
+            0x125b7c277f162a0a077cd6f1981e5f22dbda2a0b0bec465a384387527ce3ed3,
+            0x2a2a1ff5ede20300c015be7630d8f1060ea8aefcc7ec0f9606e8aa8cae99bf4b,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x247c5ff976e2ad2713b0ed0c228a561962155f3455fe766e747b3cc613629cbf,
+            0x28cb0837980e09daa3e697291898baf1629eeac4e46342bc071da656c7bf5fe,
+            0xfa57cf86065e02c71402e6dbdc251b1b76c1205eb14d883d95b957b376c6bf3,
+            0x1333d78ac8096483ce1959d954323802c853a4a0369fee7ce1261828501ced20,
+            0x14d5ea7f1472388751201a664b15f402974aa24f6cda9a91a84d56b1b6eaa776,
+            0x77a697d92ad2c070d058b32564a9efc7e1a037a1d03962db5f2719de5cc6c7f,
+            0x27c6793303f3e75361c67fe56b8ede9c3b13ebc8d10e6ff787e69aad56595064,
+            0xd69340f71fbe2b9772464b2f1fdb25c5d93cd365e24b6926705a77a890e08d5,
+            0x1e2d709a891be7d5411fcb2eabc3cafcfcfdabab79964189758d1afaf70a6970,
+            0x2cdb124943fc7c3287733a0a3c078eb98adc3938120ca02b14a58a46a44f4fa7,
+            0x27af11497cb4a8d207471064e855bb48d8786f0b14366f833c710766612908bd,
+            0x392c9300d049ca31025170880a47ad61b80b1dc03f3e6db3264ed1219db5b04,
+            0x2aa58c8c95a91bd321d83ce2682a4b7d2f6e869a0a4cec637a272b0b30d58434,
+            0x16f7b5e9d83339c0a151b1142423fcd8d2c1758d677a0ff7d1dfaedd525762bb,
+            0x240b50d50ff6a5930a55ed800af55fc621e8b5f0333e022a49e1382ef80231a4,
+            0x16e43d57fc3ecee17611fafe5e8e7b053808f780dcb1112d1841f4ce52c15f3a,
+            0x18b989d920dbb70d51598fb2a6ba22b1825c2f3f05f7fd4897516fd749e8cee4,
+            0xe4db6c770ce5d662b21e5b463d99371bec01b6220af53375b8d24bf76685d9a,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x145563ae8e6e1472ade73ff73dc88ec306cf540be2894be758c99953826664f6,
+            0x1892c99793221d1f11e9c5637757db12c001ecef9965c00c697cf49ba9b881d1,
+            0x1f965f8daa018ee30596706f17773d33e6835e66b8aad44e71955303fce6eda0,
+            0x2935511ac83c99085b247a68119593d44307b95394392d8bc1e4366b54021442,
+            0x907907697dec1e1a3bd179fa8ca9a87265997bcc1bed376bbb2647430afceb7,
+            0x3396c267b0ba914a9c4ba45fe06a86a8b3960aa1dc12ed7943cc8a45fcd50e4,
+            0x679ebb051d64df99a0b2c93744857adaa8802bbcc6c17cf0cb29776fa229e85,
+            0x2f93483d03549c31b606b33224139de1998c0be6f9e4b900d9fe9728588c98d4,
+            0x1458fbe748fee53d852d83b0e7e032dea42fc174733ee672f833d8c91b811a65,
+            0x1a90f8cdc1c63f289f22cd6e4eb3bdd3b7ac9f04cca49d7d7d8cfb0f725805ad,
+            0x132a4fa82d6276051f33621249f4c6692cdde99766e52b21a0896e2faa1ce5ab,
+            0x1d79444933015ed9a7b37b53da5f35dfdd9da1dcefe3a454ec98da690ef1880b,
+            0x268a91dc77ae88ff05486fed8eddebea679c01bde73d634f5cfb29babdbefd07,
+            0x1e011a8f14bd69d6439cded45b157075e5d44ce51f4f9fe6279fa269e999e1da,
+            0x9d4ccb992e2ed6a7d1e09649849084e4c7af1c79db784e239c39daabbc69a66,
+            0x4bd333ef75b6e20a0a9566c7f072498868dbe38e028bead637408c6aa43f232,
+            0x7a22ff875664c4db8334871b434ba01e949c60a4264e8724abbec4d9822994,
+            0x2ce7c0aaa7d361da7d2d170270aa48f0a962db88bc02f6779be5a5079e40c85b,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x5c14e041616b9d457521c279f662e02245266a12b5164bfe05a7503440ef15b,
+            0x302134832f0832bcb9fc6fbd7f03c49e7d5d081d455eb0e3267a6e48677a417,
+            0x1ff1fc0a5041e83cf8c145b226ba9e4f38e42e58d15479caf6102d5f0a46c1b9,
+            0x743a2f884e7cc1bf16bd83352a5b3324366cd09838da3b7af8c09aa8b907ffe,
+            0x1602376f4173d959749ec5daed8394b50facff3fb8765a89b59b6fef0a7d1b41,
+            0x7d2cb9c94b0a81818fce3f94e82bdfbd1074e8c5159e7fb0ffe12291e9d833a,
+            0xbb2f1a3fa920981b76feca1519db3aa3c26b703facde82423479b244bfd05bc,
+            0xef15ab6018db6f518505668756a151c50ce609657ac3a1390df76759e9eeffc,
+            0xe6e886b5371587ec93eadca0b54cb77c72d4a709bfd9431c5e4eafdb1f3f3bd,
+            0x43868f796a09019cee928cddd4779ef6de4ad17578c1eb5ed9ea01761f46a30,
+            0x244a691b12e0202fd70fb283580700f2e25747c504c2a0ebd58993becaf84eba,
+            0x7db83a16d8673bbf160b3b0d5d96e7b14040490acb6787052778aeab1bbd9a4,
+            0xa38eb2851046d266aa8aa6d124f312e00bd995992adb16e47a60a086d5b7819,
+            0x9afd14102f5641fac42f5aad7e1e04fd5779dca6d20f21819ef3eedc779a27f,
+            0x17f1055f567a079eebc36cb46488e34062e598ff88e9e4280f0472021891d500,
+            0xe742b77b8daced0467679873f984332608e5cf5f573295ab6ff101c86bec259,
+            0x1e0137861ce424e6fe1f8161847e1c804525945db0267bf56e8af64c14cc2d2,
+            0x26af9938a85c56e60ad89ac9ea7ac83e04f574d33d340f143ca5f058e2ae18ff,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xca3bbffa94a2440660ee1481664e28729a7a581eb47fb1e7f2b8d19b33a7633,
+            0x56ddf288c8533174801eb64e46e332ba077df88559d617bbfdeffeac12c935e,
+            0x18f68bd602682d1267ce57ab65f27dce1859bbbf29ea5ca4c1a7c47ee6921f3c,
+            0x30595b7e6e83bacac2e1b9744f97c045f81ba17ab940a093f0786aebf107f4c7,
+            0x636950f2ee62115195d570a6c43d18e92a3edafb2eb0389482211b486f979bd,
+            0x874eb8555f4444b951b3e3134f96d75ad8866a0da0775fcaea7d80cc0be0c95,
+            0x165b30894e68376015f8589abacd55512eb63d272ce68ce7d478beab7672b55a,
+            0x19e4b9ddc57a559648da219a93cb0ddb0df84b89cb0192814743bda58e7e025e,
+            0x25eccd6b96f10e2a0da8fe7001a7458e10c3e669cc6e9df84e4b108c20a7802f,
+            0x12cee7ff70207b2601a5198a71c1430fe3754958721cb810b8de2fa6c464488f,
+            0x1f99c9efbb41738ea513af1bb140f11e84ce414f08168e165620a36032e844de,
+            0x12529d825e81e3cc950c208d2e40375f320daf93ae7e401dd21f31f69ec39dd1,
+            0x60570f962275a45bde460c929edce1c9e56d5bfdea7f5165a9ad1f338e43278,
+            0x13d11f33f4e872a1d7fca8fbe95fa47baf3e57002783f5503c6522c2835d8c20,
+            0x2359f3c444f7908a0e3a80861a42251115f650fa4e66febf815cab17676fde4c,
+            0x137c3d8494fafe8b81567121140a8933a957e06a86af79f21aa0786ee032071c,
+            0x3527cd631d2e66d0f82218ec1a2ae78d58abbc17519750f028e010153b5476a,
+            0xd67de5a809c3c17ec81f87ea47056557cd9a21c12e615f68b5a3b8b2be5ce9,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xe0a49d17b5fd53e41c716eeb7c3170aa596a3d994cf780bb4fb099a3e628ced,
+            0x1b7180247c35af01d58bf18ce746e193c5f9d6cb530deb707cc81f01663c2409,
+            0x2093c5ad6ec79e87b4c99af53c32b7c13559735acc74ec744a45da050d6d56b,
+            0x26c4d026b6da4a405fe6d74238747fd571561b7265ee49910c447438e9c0e1c4,
+            0x1fd3b662959f05a5ca35ae543da8095f78a4544159475be1e9d84592c526f777,
+            0x1d8a119da46c01ecd28598b1843020f2affcffbd0d2ab74513903b0271176911,
+            0xdef9ecbfc4c245d08fa20010a22886c01234245042181ccad19ec06eecc5aa9,
+            0x2f389eb9dd0db3310260a089bb9d0846ed025ac437c1eea56dc5c7159e8474fb,
+            0x192d09f6e1f97e95858b09dda316902de5e0b946d3050a296e86fb90c0824460,
+            0x2abe84bdc7a81e92248e62816419516f31b9df3c36088df8b0dadfa242af8f96,
+            0xec8036ad332bbb0d8eb631bcc55ff0dd1c71823b8ebd6b8e0699417b22d64d9,
+            0x212d905745129480f6496bff628cdb728a729394f7e5dfaa13004a4dd6d7ce01,
+            0x28b10eae188741517e25e6abdfb63f5c0b8234a453ba5f73d55731b126b8c442,
+            0x2b55e73628a3146399c9c4328e7b7c2b06c3f9c6b2d1c2f06de3b2b54c2c50cf,
+            0xa288f1c2c2e7b4fd66632360642bd18970ca489714681efa3a79597368000cb,
+            0x2a98c6af21ac38e6d8f70a8cbb5988d6aa929c6cd8a7bd41de02d6a461e00398,
+            0x28131733b6f0f9dcab73a997d3de4c14bbfbe517135d1a8d0559f0974ebb89e3,
+            0x1a0422b448652f8ff28c4099a5857e35474e8864c82b0705aa291052fadb42de,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x759e02ddcf9c02faeb9b1441d3e04e2e26b1c3c21c1a69dd452798b1ecebff5,
+            0x1e6e510013a7d26108d160b3bfcf269ff0f51a0759e1e1b2731f7c3fd9f65679,
+            0x87b228c959aec21d112b82be8167799104fcf2f6a1311a8f8c6ffbc9b91c0d6,
+            0x1db2a8fdf80413cfcb6c77e97c570ad471dabc38e8cb2fe680016f0dd6d2c5e1,
+            0x2c866e9e002f7ba0ff4a92bfc05fd5a9cbd2c4497ad9957ac9434acf2a3d3aad,
+            0x29032ecf930c2a41ff93c287e9bacfe4ed6435f5bb377527f945ddd90f02269,
+            0x21a948d59bbbb4b75d7e62e29f28fdc1ad21e673c3d895d264f3cbc0b9c0e0f1,
+            0x1dcace62396a9c5fefb317bf0771ba35e345a4e113a9be8b9ad3bb4f6a62a287,
+            0x29f8ae5c1ee78bcc95db21cba9113f31c1046c41d866a70383ce008a9e6aa748,
+            0x27c5c8707b69d2ab24fdc16a043d24f3a2aacce0994aafbcb79754e26d7a3c0a,
+            0x2d34b96bbc3259695bdc35d7ddb28d896f64b94f0923627193d50d82930a61fc,
+            0x150254ed341e43d3a5edf9fd4825f8094317dfe0f198f908355c9ffc0485b4a3,
+            0x2c4ca99c167d67e6ad639409ecf7669b0a99ace688c6c9c33a34d71dd3ef3c97,
+            0x3930cd56e534c58be531f7e9e2b9cb3efd62d541bb6580a1246dc9a4067a7e0,
+            0x24f69e897348f292f1ff886d4992b6b108f1312a3b194296f07314af94c27016,
+            0x2334c3ba5fd553bf774f53d77c3f556d404f487ad7597abf505626e5fc34a054,
+            0x2d72d7bd580f41990e776a68e9a1252d1c5d003fbc9bed64162a1dda8952ca5a,
+            0x2a311a00f6cd8196a6f12a725b9791b49f46a20955a0cc05435e136c3ffaf3e2,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x15eeb7dc60695985cc24a901b81f2c2ac6aee050695ab1de79e300d546b1f043,
+            0x1065fd42737ec473c96a3741ef8119bfd955ab6066955d4cdebaf9761ae33e3d,
+            0x17c3d9212a09026f12794eee3b04840280b12ab06bf5c688f02cc772608fad92,
+            0x1b3d7424ea8664710a024d5f57c9d3b372e2c1f5428683da382464e39154bfb0,
+            0x1122aedb98479614cfe5927434d6cb11a1ddea539e33c7771ca44535c510427,
+            0x55e9bded4cbbba7dad989d9b1295c5230d5a799a6211895bc412ee24086d628,
+            0x30263db0209be791391ad08f2108574a6a882f05b6c8055b0ba9e0ca8715217c,
+            0x643bec3e72fe54060c78a6188b7098bbbcedd5ae549f5d0f95594d03501c1d2,
+            0x24739ac04c239ad6549658ca1b7e0f62067bbd53c3f0ae9c3a0160dc8982cd4,
+            0x831cfa01b84554e6f26b9d604c0f91447c6c5ac03ed1d318b7944c5773827b3,
+            0xc0570121f291d8fb7b7a62cae11ea568a394915a9cd70f634830a5e36f93025,
+            0x2994d07daf7152b5024957f7188fab4452714606c505530854cec14a582bb6e2,
+            0x2e5ad16ef38f802fc789dc46eced2ccca71fd25cead1d5d1f14c482061cc703a,
+            0x9f1fd3fd77d399d36089d589dbce43f1f563d8d4d927122bf29819a0224053e,
+            0x1cdd5d1efa77002334e3af50973ad87009b6d26818bf78396b7d8924c7aac675,
+            0x2bfaf90c55d63a08a0ac948874f9b1fb60c0faa0a530926acf868296f8478e0a,
+            0x12d3e6c5009562c1647269d1b507123a2f0b7729804b66643f081bb782ba7cfe,
+            0x36e9be313a952e3b77fa42cf13942e292982a7568964ff200356a1c6f82e473,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xc34e42c97488447c321d23db64b398c6c25d4d9fd1fcfd3b5626674a42d1cba,
+            0x27d82eee53199316ed144a5591fdae1f6e2be76b469f606e7ff6759a8920dde9,
+            0x895f2c2986316092a0366d6dd018ffd6439c477996b4d2eb5c3aed2cb0c1025,
+            0x22ea26e3404fa1f74ca0be2b73237d0a44014f6036f9a96a1ad1b6a1393622a5,
+            0x245f9c36081e0229dff1c693e33858b05299349c921d4163c12b8a60cddffd9f,
+            0x120718feaf2106067a3dd824dc15c3639312811c1d8e57825aa782de88a2c3e9,
+            0x1cda330df4f05747f9fdf518d146f9160556d32d06f8c21f9f22432ae2abbf0d,
+            0x17c8bde1641bf784599b38a3ed9568cb3e2a8366bcedd556711e85bdfa71fcc3,
+            0x3b039fece617d27bb74f64fb7c0e24adadab1215fa077988fcb513b7990caba,
+            0x2585f69b3b7caeb08b4fd4403b72457ff3953e708f20a2a0d40872d5571dc707,
+            0x1cf1dd7016fc72885e841cbf7e92c931d99a2cddce535f72b065485b39fde3c2,
+            0x11f30f1bb28bfba19b81bf60611b0f26c1a2a7f6623aab774f999ed62be03449,
+            0x179f6c3ca3fcbd7aad8e1ef759216d589ab51482a6f7395c93d5105ad79c5e00,
+            0x5193282c4bce9d58154eb75ea6fa29683e2d2376d1e2b9d2265103b323c014a,
+            0x13f144857af17bff0c12f0fd177a6da9b1b3b10842f4805689f124d52d1063c7,
+            0x290400f022f09b1359bcb9812dcb353472449f4be850a28d949f914290aa598e,
+            0x26a590e2d283ea4e4bdcc39fe4cdfcf9b8e974b4603ee78ba0cef07e042da923,
+            0xb0bc561fb4ba346db8f28d41eb0bcc6bb1c40217610f165c5ccf4f2940ca1a,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xfc4b28f50f749c8b55bb53cfd3c76ed13a11e16eb3816520d732174b68f9694,
+            0x1c2ea86841afa29997e495b0e1cea881562319d9edc2aaefde7b30da0118baf5,
+            0x181f1de1e627bc0229055b2c08f12ad3b70d540b24fec6128e359cb8f32a8a,
+            0x2a4b0a0fe77c7afd26b08ac0eec6a30854cac5eb8c070db07a0a3c5b80626747,
+            0x13f62bb9fa1cf209e303e7626fd734710668d02b4efb3ec507c1f5a4b59ea94a,
+            0x2b5f4bcb8b0c0c1aaf90e370e93b611bd34015d4f4083b6feff51c60fc7f90da,
+            0xf61bfbacfe1eab14181c0b9ccda1da0272742a0c64ac873321c85af7c0f4253,
+            0xf29b98701d484f65bde657f17209bb04d1cdc52d1d45b8357d64153ee0639e1,
+            0x4f50fac0a62268e7cc24a64ce7f784bb1d7982be69a9dd168b0f191da33a5bf,
+            0x31b6743a6fee9be625862c05ffc4d4c656e30e17a4d1e9a68cd906ba9c5c784,
+            0x1b2d7a1f0ad3dce2e4b7fdb43de39d6044b9713b47c82097fb72721de84b629,
+            0xf2090d83056f23a0a8519ef633ad3f7454196a1da06db6aa93bb72bab913dac,
+            0x1f36ea15e1ef84a869d23f3fc7c3fc0bf425301e98022694e534a564ef69610,
+            0x1e7fdf4b6edfd3e8e19e73fc8f938b96bb271f0a8b5beaee67efb0f5fe1d8945,
+            0x58727d0875e0a1a590634c527e8b69a4c6e443265d013000cfdd5f00b9faac0,
+            0x65c67297180d56cefd31cbde7691cecd344e5517d93d36a2ca00b84f2ac6406,
+            0x26efd963a80f4104192b1e66102143aa18c6956b4edb14eac83399cbb957d426,
+            0x2d36f46690e480d2cbfe0f647ac99c753cb01490ad79327a1192e7c5bab301d0,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x1ae20386490ddf16dc579da580c4736d5e20066e4ca980efec6c412d6c5fbf20,
+            0x13855655eb53d070d6a3b9283176ec875cdd04a2310a8bc7da3778bba3a8bf65,
+            0x216a5047fc9a6423e0dce5c2fc7ed22e17a889ecd7dc313ec97da530b0012dcf,
+            0xce0a7fe4c77e0d037ce338a7272ed67864f566705e5422b954effa901c1190b,
+            0x295c4b9a9a97eb19dd9bc5cbc4704fd57c100276b7af57e07be392c18a953bc2,
+            0x2989d23a947312faab571c5ddaf9c4d09c22d1876e7d007847511d6e42c2f407,
+            0x185d73d77a0e88f9a67e2c1a59d6473706e24c79b845ce5f9950f0fe26d6c794,
+            0x182b0ed46716f64fece882661791a29bb29986afb83cc9e194efe397288aad4e,
+            0x22ff21a0030a575a4c62a82b286a37188b4cddf6d4285c60b60d030db206b1c8,
+            0x1313437aa7949a4ab64fe85327645748fd2a58e0e3d3b85626e88f7339d7b261,
+            0x6efe22994b02451beba2f6d0dcbfbe9b920817d74cb212adb7f738178ad2f40,
+            0x301063036e4697bba8d213d35d188697239bbd1b369e7bd294ff4dffd10885f,
+            0x1c90fb3a46ac9ade74d20bbfe8403ef060fda9603773064369d4c344bef5e817,
+            0x2c52c601cc0042b449329c045fea856de70f98ea8d1b5ce3a30ccf0fa3dd8a52,
+            0x19034b0b0a87c257ac4944e0500e97bfede7ed2dcb148c9546e3b581aba9db21,
+            0x27b086852644a1c773f0ee6c7cb6e58d7bffa32638b79b2990bd7f1dd683eed7,
+            0x16cec1cfec5d548a707a44ddc3afee7db168b5e986eaaa885748a368d1fc7607,
+            0x23e0d5c20594133dc55043bcc80a422dc9d59ff92f3e1a9e934d7c7486bbd410,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xfc871014612f0f2153585878907f011cca957eb00e86bc50f319ccba20a005e,
+            0x179dfedea941ec28ce16ad4a6ff320656632b0750e6616889e853719bfc6e88,
+            0x2200eedc6d000a31ba05af605292a6ac3db87e5e852b7edcda9ba306192823e0,
+            0xe0627308b4486b9922aaff007d2dc88a4cb80da9d90be1bd13d63f3ed7e1fc7,
+            0x941ece97766c9dd37c07cae87220151b9672f02bff4006700310b95efbf4f4d,
+            0x2d8806727504e7c422452287f378c0a9b859897254372eeb4e4cabd2c038067,
+            0x1f44136953c36a85d85da27e57a6dfaf955dc7e1d456790e53526625f470624e,
+            0x2ad2db1a37881b1f73e5ae98d404672ece9487a08ccced17974e1c925b0f0234,
+            0x1ff27989f4d74b500ad47ef372b8f08396499e4461ca7ccc5914675365cbdc8,
+            0x1d9e4bb1ebbf654ac8d81380ab49c45c698f4552fc2b385d61f1729f9a434fee,
+            0x269d2125ceaf4911300dab597dae2d4d97714a48abaf059f0060c26a6b462411,
+            0x85fe9b1797ff4833c76f23b0dad53a01728edbfd28b9dd5097a727725bae3f6,
+            0x2a1e5b7a8bbde19a0e4e3e189a5375543ce6879b8ac6c94b3541aa7b1ee5d73e,
+            0x38f9b328c38f8ceba41d67319a3186ece9be1bc9d16142abc3099e2a910e1a8,
+            0x3ebea7ba2a89695b6be00973736a209479d0e834a37f5ef2863063552d840a7,
+            0x29a1eb861aafda5c9a36ac4c094cc8763b491902b18b9dd29bb1b8dc216bd96e,
+            0xfe28a88001c17b2b1ceaeef8891bfc5abdb937c7fc6d51b2dfb56e5347c6294,
+            0x26ae83ff720fb65932e831bdb0705d7ae60c0289f7bcfd89a020a5f3b30eafdf,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x1492bdc61b5ceb6fc3b3d91065f585e0d1b037bee203ca82743459c1ec00c65a,
+            0x275f2dd31c5b79b5f188ae669923494e6ffed430e8c75bf202132e50b25c1a3c,
+            0xb327a4ebdc41f56502186a656ca06819d1d29a32a6e70588f548c4fdb2f689e,
+            0x2c5e3d0108521c8af0d038a617f2a0725d5003a5b9dd824a95a59ec6bde20b1a,
+            0x1b611cb1e5f7f2a0c4fbcad4e9dc65da5c6a34190fb27a8148359d465165f9f2,
+            0x22365c55c48c5736cb4b7dae8fff495e9c661e9e130af620cff5f40fa1210e96,
+            0x73fb93220556a2bfae1e07d2d076caa44c085e2ba6644bf4256094af48ebf3a,
+            0x213fb8bc8c11ecd95bb3311eb046398f377c3ea4208d14b80eaec8c4aff2bff6,
+            0x1a617c5b998762909c55ac93513a6d19ed1c1e28ff8b78fb3f551158a9d0d99c,
+            0x2e1284a59a10203966d53cdd502405dea6889490f9bcfc5a33ff9d8b6fee17c6,
+            0x27c73897b8aea1c08380d8ca28d0405351b957b064abd17afcc647b73ab348cc,
+            0x2bc53359578a242289a79806c04853ab89fca02a6232f152d05b3d1dfbeb6908,
+            0xa8ec1ba29e112cfc42aff081ccd3e7e01410696cb5510377072bbcb2f9600c,
+            0x2e0634f26f73f112cc5f285e4a232f694b79c05ac5bb9c9dab89dadfd0112ce4,
+            0xac9a6885431d005e4aedee93dbcdb638cea5b17c363289adbba9ae9e3fe744c,
+            0x216854bce3077af7b8294565ec200c0c455b9d5fb35cc98ca36a323620b5eae1,
+            0x1603ef2a582a0adbbac5655b3c3202b60ed3c22e59fb442c2a7962b9031a33ae,
+            0x2cfd0eb51e60c1c0869f5dd163666ee8630bb2f3b527af9860f8e23b2fe1a869,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x183f34db24beb7107f0f5bf9fd4c2532033855c37b5463ccbd658b68d870e6b5,
+            0x1a5079190245f746de5345f0775f5ea91712edcb4f165f391e9c8f0b1268280b,
+            0x249da4641b8f13206d3cb7b3943d4ff5d0813654aa5d8ef4eca39cc6cddcda09,
+            0x2e99f0d1ad289d3d780147284155f335f34224f7f8d3db6b008d952a84a12f2d,
+            0x1a95c807b653b762910fb0b9d8d0b4a32b000f490fbe925e0e207842a2dac0c5,
+            0x127a15cfbd88e0c122b2905572c496df5eac209879a235afe08e8d2e631cf46d,
+            0x1c22d61ac34f05eab74aaff0cfc01689132754d26de62038964b5a8acb1fb340,
+            0x2ee46c0fbefbfd75eff882d395294889d915a1a1e858e18a5b14c4200754f9aa,
+            0xab5eff34c9c0bd9fc90db5b058bdf68fab4f25eb7602e9369060fcb6df9139,
+            0xa91d479dcbe07bdbda4249188361f7aa7e00c8edd81eb74dc176f19bf05e8f7,
+            0x276a57e2c21843be0b10b8877849309b33d19089838744ffc2454199e6833f63,
+            0x2a56e477fb4a285b4edb52b2f19fd159914ec3b384dbad98850a19dd9f44c2cc,
+            0x2fc33d4b761a6ffe69a5f4f2ef4f41f727d7131a2ce15f74f67ba17236e89263,
+            0xb9ed85bc3e43eb0c395ab7dfdcff5da94fa809bcf5d20da866a2e0712dddcde,
+            0x2921971bfb16df44acaf0447858eae04720bff84acedf57d1059016932c0a9e3,
+            0x1ef4f47e8d9e92d554c8bf9312e0c80f5850fb5f124421a4a032243627170429,
+            0xb099dd3d5498781141cebbaef8b3c9a071d88ccca2efdb8d97071e878718f44,
+            0x304a086e6735ef7a00c6d5fbc6a55daba181f3ca901f5de3c9a29f6161ba5f36,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x286686a6d53d085d60793a0815cc1b77c61ea45fc4451e7b99e9c8e6bc80dda8,
+            0x1609e1fceea6ca88af1bc5075582363ff305d5f39683e70710f2f85501f4ef87,
+            0x124f27013e00d9b8e11f6550ccbd6a2b9426da5f482ae5746601d82fbabad65a,
+            0x2c47c743ff1069ae71b811ee87050e9e176a0461d8f6e0472af4a7d8328071bf,
+            0x11a058b976dc5fb8424c68192aecab8f56b683f5eaf1559420349281d849d746,
+            0x2222ec9d6eb62f5f431eb27a65f792b19817580562d8482027c7e84dbee5d7a,
+            0xf866b167acb845b0905fc05dcf985849cc7b32a76c532fe2774353ea37f1fff,
+            0x7197c02fc0c5f1e13bcd825e1f0df47111d16be06e4f90e1ce2452ed2758089,
+            0x99aaa6bef62d6b1f3098bd34ec2916caada19756bfa2dd222cad7fc9b296c66,
+            0x1a210aae2dc13bd0bf76b45124f771c486cd2c4ded5f125600ec961e3eff5d16,
+            0x4ae93e4ec96ef4a97132edc6219ee43d41d3d3820331152a83374b363cefc61,
+            0x2140d4f69e842e9257960fa14aa526f36d6b3204952c5763551600a17e9c5c06,
+            0x16f77df72961ff15724b2cac0f79106cc9bdb2b3d25534263883e2e379722303,
+            0x2a679813106d2d1a88e194dd55641143a5aebcc2204fb4e8f2cbb40f637e506,
+            0x12582d2bfe22fab8079bbfcd7bffcfdfa6a33221fefe31e74edadd5e0e58a361,
+            0x390e71fefb45b223ab77d04c90727eb97540b7d3d9ca70798bf3b3f97d91f21,
+            0x26b440f48d1c54c8300aaa49b9ab8afe622d6f7579857ff986966832584f82d5,
+            0x1dea175296f5bb238d04bdb371b31bdfe62974b0a219f55be2c3e644e82b5bfd,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0xe0e6eeab1dade829f7d80aa510ed423c86bdac7b39dc5fef6df9b6932cc812a,
+            0x2cebbd5b0d62b44d3f06728f5db838c617d933c08491c23b707220a2d6060af3,
+            0x2dc31eb7528e36ab16fe4e845b1858b44b7f4ebcff8c5e2916b5dbc93aada42a,
+            0x1eb3bec02ab6b2a2977c89984273b17a0156202f622edd7adf787246ccc75f2c,
+            0x220f79359bc26509ccbbfc429980c2e65b195b3c8b0695c8765057a2d025a67e,
+            0x1590491b1dbde002f869c666a1f9feb983770740ede60e726926dfff31f24806,
+            0x2feea161ac374df1bd1e90c3d84f0bccc39efcfa6b34e12dae7ddcd0b3d7257b,
+            0x1a29866fc7a388cbc6c3c93ff3eb7f37e1c5e83659b05b0522bac1dcb33534d8,
+            0xb8199ba3edbfd7da088f17687da77fdbcce7f4730915cd9f18aa86cd03574f6,
+            0x2791b7c58a031d038d076f7d6ac43730933a76ef48f203fe92400d60b98d6a2d,
+            0x2f454625556eacc7f31439c8f2b0ef06ff37ed616f19533f9266f28ca846019f,
+            0x249369afe3c0b2111d448303abcbc18110aed1a1a4456e4b3bda7e8e2dbefc7e,
+            0x12edc078ee15bebc5ad4509f3d44d7c25607fbd61e9d464d84ba3223582de54a,
+            0x22580da134a629da679be562a7a84163a1565af42558a04c64579d98bba260fc,
+            0x1dda309f47e45f9a6cc38c7ec04588c51a650c8f0f101044ad6c0b14a5b0e6e9,
+            0x2ad483577232eb393cb943dcde6c616285468d4b5af36779d86bd789c499482c,
+            0x28ebef81b1b34667338b9828e4858f956349d34cc99584e1622e6e676c221847,
+            0x1352a39d4ec27f0e72f991c448a1511e1e7ecc4f4e76b705ff2551f2cd17233f,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x2697ec9fcc93302d5f66b3e1c1ad9b203521f05ba99903596fcdb8fb70e4cef,
+            0x957519127bd1afa0826384ece846813066831571e2aaacca4494fbb2a628c48,
+            0x1d8a3eb38e9a520787f7b37c59fd309e3ecf19a45e4e4855b53dc670de8d395,
+            0x13ca248a44825ad1fd500351378a1c873fcbf6fa6aa3da48c274d1227afc90eb,
+            0xde6ab6ae985160148e09d5d5b35acc7b0f61cdd119ca66ba72a11c89ffb99ae,
+            0x6177434dff8487f01d4e7fe5dc1f5963020409384269ba24b5751da9470fd57,
+            0x195ff62cbbd66aa75406290ea773f0e6ffecc1fb8be9b6313bd30a4e0626b6e5,
+            0x17ca97378ab5b95fd548bdcf531da28e4336edffda8d3c5adbed45b7f224a04,
+            0x5b258f2284fff0798c69fe24b70f96038cef3a3e7bee367a51a7e62907669dc,
+            0x20a38dbc01d5a38c6908056f5c4862c351754fae0750094c93cf54bdcfe75b25,
+            0x27649f4bceebf6d71f6581d40e0407b020dc73ec56bf16748c61854c6afc6c84,
+            0x12eba7df6b9e4a5a1b7b92bfd51d12e756831af7133a79a622338cc53e19fd5f,
+            0x8487f84ccd636bfd508b5584d1cdbf24cc1605c779e5300d4328bfcd4dd6db1,
+            0xe780d26ee909fc75487670a4cc043740af57e89d045b69ee6babd8089746bb3,
+            0xa58128a2fdbf500e89c8b81a8b883bb5004b4b29507158b7947178b58421d30,
+            0xb680246f8aeb38b7e4eef807ecb493c3aabad1d705435fa2bb37cedd04e9695,
+            0x2909a2616f3a24ab48ad9f50e4f18c75bee2c2f434bcba5ce605c1dab5721877,
+            0x143f55ba8ee25793ded43c6f14c92025153c79c964b44b35c886af59bcfac0a3,
+            0xb1e797eee3f15b88ce3a1fafec88da1d6329ac3c34712db570de886cf569098,
+            0x216f405b93971c6d85d700b4d991a983737006cc1099f0cc1c6c98a366d5e28a,
+            0xefb44ff1e32edd4f8db74ae8764f6493bb0f76744f41f2f1f35205975b49020,
+            0x125e52e4d58e859809ae43a4865b821c65e630a0de0a2f4cfd5188ce3cfa93f1,
+            0x4c652e865b682c60c57f60bd33a174e9b9b22b52a1d47aac4aa084b1174b929,
+            0x9cad80a5de2e6e280dd9b65d56860754dce0ab2becfa07b30853a32af5b011b,
+            0x81544e3cace3761ab3563b6666160aec7a52d7331dcfb34e7b035d46d9aa6db,
+            0x29c9f89966182d3c7c4bdb1c751fabf9dec6ca6fd0f3d2c4b2651fcd35916a67,
+            0x25ae65ab6ad76f18d3423dd2829bc059e43251ca5491c2e11c04e3e241db0e5e,
+            0x1821e88b8cdb1686c33ad7c1dcd41c61f47a6435beb00bd8d68644b930e7c317,
+            0x1abb95b6e33243a050e563b5c4fd059de5513ec28994a6f60e57c98d3bc8f586,
+            0x110d213a836478aa301bc1fd4edd388507d87745b3abfba5bf282afd21f7242a,
+            0x18edb2d105bb53b768ae0137850dc2d2bf6d1303a1f8ee4aadf76d8f81990588,
+            0x1e53e92df6c53ecec4c0de5b07dc4c9a0c5545f2abcc1fabf4ccb84a0a6e2c27,
+            0x10fcb817e10f69f7074e64c393b807cdddf33c84a8b5cfe33f44b73fe18c0e36,
+            0x2b1d8c11fc652c593543b6f9800bb7d0c9371dedb96f08bbbccffdc6cc44db98,
+            0x19f473e40c05676d5f8d51e11336e9c65cb32828c397cc8125f1dc667b6cadf7,
+            0xfcf3a4d9c6c3392de1bdfe25cfb86817ecb80c51be17d47f79750201f1fcd01,
+            0x23b02d00fe2634889673a7d04736fe15b9f62652b1c0626a19af8d6085d70822
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_11_config() -> PoseidonConfig<814, 121> {
+pub fn x5_11_config() -> PoseidonConfig<11, 154, 1386> {
     config(
         11,
         8,
         66,
         alpha(),
-        [3312280834382673867321630616941760639861515464094877629805120494360011490649,2977163727414618213643725802224710174200189681501907689708278449275625624600,17077799405481633745546679084486353025600250694578521370656758513725453934742,16210306379465933080277173890273457210762404430253284947889895341785601089390,12306944281360832043572721821716739944034354411349456264300159795863030116042,18510116198433364516004461541873904955505055486081639325191415467980353992665,20171004681243290383397478639749648403640483231061520437292129889020927831789,14216817867363924461443287436236130110420963767734530602158091056747850914504,1744244489393376249430799522637230427855625055124494576876957852023791759325,7129585843913921821110812028399979173266826966429993304814409727296136874103,13988404968409685403326663187671698975733642730286219911002602918437679901860,16920638563061193407835052036305459051417920006020130846290964059193276218943,13427470979587753937642822251845898994765547507421045262408080469011197338416,4951343674183369875263494313821909834781608226183187917185914650592996842297,8735432128376864913532575297691608527208524295369583136876379560735670033436,11506191123509320764309490571835590914265043835723578099434891464809664894670,11860937155601787389575216601739962955686948385964703064981923542694893487713,10828014814384016644406621862814561467981545748254521286078083584574739936124,4776443388323724363690349417451836132533385226194261923508005690866227183177,16639991477904781874568583121789695884424899367435699700192357030587346907362,63646460855616590932366082663720069120195784636826940928051354727568777173,13872046592464170980392921000435473279488582870563366687909512908597101541579,2903974073963148433036990643522953333905364588702098342158750794553468542208,13972003294927197976860685316247379324920372226280483226377669417062686947906,13868504415208879955736997036981136359599594082926486546672963310629609974499,8628454286960990606041697926325623221475249983044062173729208432417417750989,11883151436851199698252725037318235080760967011947670552161788839027156740653,12343286145222861673187914724623142745362406729785896500578210646320713733295,13240444180513188371213070455300718988708567038226911680564203350475184135088,17225520781620743741263824011599257737446498734177523099795883619924078366351,19655364901125310778629982245392767297984820167114789563931170716695750865678,10695212283696096281132213692300627346215324066996398339089365835910730561368,17455827037964560948521638828961298975187156274841334841074216120311558804710,4382628454630801450077593442523632674983545561122254229775876033334437860489,2989679808908579687765205532943224072820070594304724633625888454150084631070,11805110513334566809098991762079653200819786354513225301120697798603509678793,11155601993809199490094826448585668454159517005968097566996288487138255635079,20815808565222781796761554019974947099963702926722486604443826341123930622896,13761986205307878615460321377264044874010177269812603883540272922422883198979,4128370443753246025606114169149035926146394950057754901868026654335917771101,9124459754124711043815747649012164723935008821275709951889811488049411892152,9090302853448501945809598864330384875455576758214379286451409039855851539841,2611158043123761410817152601927516372222739024190920897371539155273224585905,7810155525349201315441227323507184944737106980192978514457375337581213081055,15249792920950763850993517571920601821568311809174912509031437118050063777525,9921562618684201533699293485620188871082795988970107962425978745591461148033,5414565587238798987874533039507833069864773781235217517734130524969939419113,11085088558016600803149927568829483866020077054827488081829062938808919799801,14625818170426402577283649455001357862456467374537021301451880577607106726350,11633423263664104506250995123678976351167359685182986641330218055115412525059,850899676511673590463501492472742017261347013078251845952824541653369171366,1151196396804070641219917031443763313740170846357000808196046482153806050391,14335865562369989392722415692597018596062508514718062574213639729550753584518,16165235837546690396792041022833296046736592940683337326949013823518030323769,6408098377682813619850142098164780329355428625834955152400958576961120931380,21423078154100258346688828020904418548554497199114189102725137286930868022538,21410217312460027364452766052404349950133415202888862471159726884511205456308,11096458349387432633781125315606380225216758142658673665437375204143306261827,8325016245207932555950059013310928498109578689420634828690059159861280125058,19120379171572846193451984132488836287003157955913585086569467602620121544962,15548527549295346334479152412121638073047322389003226521019746206475690857238,18510388922178653264949279980605433471616208226685385338922150015851847524587,10348792093961922144290405029634579505420677504732581441616360506905620826544,15620530873228503134208333316448182712901874887467615537478242394290577386453,20675095206674416295505702734315255961699360732886837937979451051773488542601,21623072135556656816074223163769126264910877148099315666172910436076676028248,20081866552983231525843337497912436927329172443916196026679813450860013966767,18951602909834406133815764463249536936478826139929746486734639774975812472830,2378298801465585253495854322066504889300467395616155363977621341822205588163,7488881447347091058309495011922138185162376888083687541108039236558708660027,7225960736862847948475548065508931552528126330579521291190635548005260333390,2970482373109443685421063487292183827150496377598629996362474558885993864176,21734396161383902760672518999845141937065773419899625136190973118533490737305,18986003927424880427453510819113519633513383085919786483726156674699889468820,9438591792749742425198760386567115998731905494024392289196006582112950891516,1973470346155075248881651300830631935042830364217214073906277058522882105581,13791817954605171888781711015587425735543149752618332811612012047724803625120,19907506629242812934309078271817109951335091294976452370249234742626462372763,7913144809845970358468253448033359382532594356254540499933138806226450398795,18786719915196826164016145948631708915544945593653634575689240810328854731069,6216910690440344513687669938632060553287695043116654216600911463719413604341,13963849909448408572632889978998938642084255012365277702934245702305832007005,15044749345099947962217476120263824356898437745229321420257770262954985403569,16364542436173489908162544844694842746117292595057249540926274681176755002520,18582462045999492294572047486602601352613220856614634390669602502489215736186,17106926147340558311732938581031578597532846523271406141897942990261560966411,21322204968737434192679865858477095835509790782891920152044718985713652659654,5180799590809942717590072710973007480225145652031514943521639316776384894144,17327427769240537767056224186269899694170666500703858813203303301835294225360,12795226231932513901983143961810913124288321956641191561823103283353203953207,21372571405151778511626450096485639101933984498294796899325401511071517993005,17332300051629640554924347563178488077648079908152291094969979591786473880576,15196566643676483159109284476812079407469293035334983717971092729005139246767,11231435533605861369104078150337976075098864909987541459896164149690464379912,2542242881481757350297627187544723135156543853134475677976341602496676452300,8414397814915895101029770303847330205837773505982623383796193602695811122514,20884120591077768210550361293303217187539921930869577755703150175746557517590,890887689926165781226591337399563217015154445631688026491595317246205069769,7911456647213080390137926613780820211986390960677915664339039845274033704843,8086506254215085366863905182926378819432294332631815038288539116592866850975,17073560037383161517623747613125771654997798954263090273202401066518468858416,7837662874931236958961077774488634261606966280628598881837875736120392183663,1858593536177571875355498014960393860692560832490490994119420708212532861823,2029815832061982114925482969267067531992443107339599745974909462412297854269,9638056659007828434670080110322180928336402529095853481855440674860675897358,12340090961747329883452841216385303705169146011720720105809463143491658552866,8529510825845236935037301291679257193837435275552609577171369718448324660013,4191225223853834143599110761318464286196261585898512902425773974473427757456,21023319679135760820789157052868478773370737850886002789313940767424256194356,2142526213326613906831098262446296658577569180284637200640763867788179991570,4585042017455545746057351957720948202590802829528217263388726369695890670411,10010708638531752335740573636867640657039858389864446260449096531856416238708,12350783923218275606957028867683130968505845112714635024839732952215498877130,11964414264447046767815837108295373861475122940092369903025175128013924386713,18615506936496648840383399989920850970951406181285583088268789582149764054418,14310480127014971068920522498055725465578544829224822580493909725079522528728,19209887743481507043830894286806384055543596834772181434542567255388724841969,9558553005299269735641084020216560749888705968385627813150807919487080187993,16359179198438658598155755638987769554841536772865629517841526255130745409879,13009386603860183254204895522650012288119732961876401784040013994677688723325,16165167702867558446013999607792716532235725666199142971707303433269257270111,9526255138490973975321568846030367381138407886665647949792126204681244064012,11173959697998471600463637717719289778917744248391051771189332133876606070906,8924806383303834750473706479936998674798746387089627706877519918521882863256,12086306023907343271920056592137012844278234154616893254064962297944646888123,20523426725749375175935122656912302902564898343946638208821839160006976692150,5207650950010803883388912523741229153368067016192964642079270816449299041225,1323145474328028634780912405048390126320417262412962953050466352509016682042,15985641921260285694054233699922160344414776687043687582488491933807565444789,13031771899737217701535545098380455304311851135903656399978477292561795000214,12687226379083740035799525440904048416465917656850081330730343990236073218003,5180214195408850700722613770944601169370584228844657891855699394648642429923,1934847650429153525882808430984088614158092322287601778579498068360011630130,13221691213669397834454903625729859574410480120034103769424898865047475910400,7358428584159841472154153892839275459119229492180053472830555381908577651936,10890590867941343184378544765218808644776443230231834463183835780142311216436,18106794932751537043075991633023418950145862470753313409722049187095789146702,20653121417027117499755994750040261936029675942959877982604976723194002882577,14917693547715740204091617501230563717468258023142717832164274356453628117609,12588115399854852983923905079011727575933343603816172388719899888494451203866,8737187804839661132607601320524529444256555649101505512380882940221377341037,20181178129036534248081631452735124104458169744675071995191727629040780050092,11847774883596070919125373409969812806188814542338127843683622869859801757028,11792352762436629909341171173296810156800556812208317414203786807634354583560,5039046929001603921830951923781308597413960825857893817665425268295870771062,12894400705986579725245788498699203221654445738734999525700614560206785491732,791109735149055364851227398853119460170782218988367975658618461497391330160,9962476109282060862882002156903460806939219308562214446822701651882476052460,1691961422009775486402337895262889415967004356867228407841177856000156435254,13137802539241815005932694907183711832661205367415214501122657136334369092290,14887252261014844625921142022701177088174316290502741584519763408145964517832,4710184813279024135486906523528903891606006797755655291767343324947631364837,3801875732725114698561125696836343357073399124260852478317754268545097096329,9198233237012512530002016044631468704269680036230256629514440524866699707396,19696310211066978020836317292330659233588020682368119069383469865122133603780,3893729283153055478198590025767324126269879907832064182575052081004216821718,17970322286541481482483545514302125656124172449128411566036569217140609597331,3173691464765770821621367532348960211199783691357143005417355252781889173280,2243542900289123996173306626857758207765925487218044091235839910321809834188,9813067765525696381929832954440764980538359181380263390331469145209686852182,7510903347384066721813722580189668539045635640361656120910145998846374499699,6798424040308056706713925899327404372610976624998869962003671422212921682045,13151104198292309578579089832681402880200764912297978086539824832412224275732,2808835590734075710953411057250272995919027932824027538775542577464926767888,12588027297759258617444062604210692398005597744782878589643963326768133974361,20852428689501418456174033597851660248293428726014401905473174242849532966301,21296758342898944987847487225137782473520558597036376704831839057822676021941,17749269130031982625604134600446353874123371420684509963863640790293640598822,12696062143950532198094822890688877675740383270827145944853466311043725527586,10234631072965977425954576972633890272283449053659669736631819751429358646105,15090656934406651728161310654614148547687401766770336347796859883364028754099,20297283938807526130287519089364625872430415084303524848853727877999978340129,4196012712072569404315829685460688625941300450108222372646584487742105064258,7048902004425912498834833883033670218379565315927717075817051690008258707008,10997088676112427186865690409423506551772833502185768664867716439827194601092,16660341545280246485425051709291678711850828822636537086457121822086705580853,7507040282824500274626435275567162035280839409294222666356976034789594111255,16582934771732736721752353176711248084060824111646755305570354937871610952840,8438441158635690733311342509710555256926785449251473129940736660330253698675,5997879363655967621652122271982901641685668225243330913415373444659935275798,377781155818540738714095913828188470350179572448699653767572496979822660266,21256042944489939677834126729197446597005830228623173527229465226360970832340,13462424045682641929202812263623136219335301688716109209361496824976128063539,16369985325316675741289392258637854017776166143141100299636544614904713590628,19352389303901189710313048379405187204819083083443266317372096723889889111665,10276552469336314142974101263431204498273961662600910736694134016860746072245,18939965576088516958025629296747895354615121399053610843001474455787438484084,16990956322664851054201977827659189601868639970054898553161570861097544812211,9274107214677498542007885890977699632511964198928324688228114708372115109190,19938102848869576488504727710754065647382136279175127752338128473551869244856,10947279549049485525804912961584261533182913140524900494781425525696586998449,17561385783620224695956276284426542193322408499898012489406312644517964425011,18549237431132768472559432396178388563409301393950605704070488347475233640622,4658944912168763919889884489643908669977608714692544551960581141528777169667,14358732577825715965736448712278683090180078342840106686279626250756225140484,12281258853616996819181958497578187729715864708853144319900642420503103456870,4069586715276899433893814672543891090785738315323966746105563017207510306537,15392338154382717986608388646339008932890583126043490476751054331156284554276,4517279215584833397018875849825808766631742728356316383241841280072723947253,11495036315995422771228762992950108862694073551665420165823433137577472792783,3488400840286926839516544735442894876148193865245875295688572119503866691461,4483680161275568275540790250446502401130629200290761781427443716038558729253,3942379126490099533582685851970104926928015397351808560877929535138811915511,11401623410099323944960285754389435394954200879740972352984594598244147798394,1704354226179051409424294551695786920602664449209459493691051505451583669264,6126483205301561395856828080510799275633402498512671992649940369928504550860,13606061849345999397793916269931170782757704442972401347887622528829626440142,15164492401059698496285802476110470458129619713288710918549993367398699891422,3351459252264231792942138342057542378418534651418845818443384064630601195925,2825813294993932054460723098369264495005871082754465730530978747926493034970,10630213694333677464069113775948160876773011480314305970870772509710784295967,17166444840808098079862920467594387590120730690478215313452389257289409232274,15584725536763467888732670366582920601197464509911998898151204840990765872853,3842723796922381697995350228115144219456021393259361082360164730224542750465,4831891679443026612628331848829793784542170442278947325598774522135713804734,7600866468317146506151393588648544489445105617254544624521183070936649742997,10583687645778325936823793169279337717905917984785560251868239070559362307278,6634607933824414124502549710741812867975263049249231353927669720791801705509,21200609344869125199593456019818101515444150712862469998882355110348140005358,14361714336789127058022203168794208348007919167174968797533361168719704534209,1575806469795254200103212820564180016945577757735332906646132503588215912546,10628306906313535336091114056786842183955113155572070406112143573768388478883,3089301712473516586340147971264840334080312453733093398291612940108596635146,8645795529068430110488497380845362622141451911891312096721911200350500642213,16022924422796267113820566797422451700895182144910797483992348492987850640540,21668559624091676943635408329170173151410363888407430983622558174006481336306,2072754212505196807037151376956574080111414803663052483852517767215769333105,344312312360359816789223515659978323664333965848417356296539814750513103748,8220091259162471818305840126401210949950597324344081712931466340258084434570,8081153019090920515448830088459971939645826679918559179389404338475619307845,21449241241855558649730447089457892378091011965030006823417837265982774602267,6067510299282418337933484892144351034696356612154920492037935939636907603847,21026143172839641048848076059364862575379425612028621103404211601411048352556,6070438567473697541030303531314185338530006003062193748841965554522662407077,8255130291759907832990229603685682560848952190335394603030993899908706198932,9546680581091867708464426246566048171085730057856647964775027268282058986619,19031748019605060953238957886441808197649034817040423262874632275713470713752,17096522586030137478189913833428299115382271406265963567569748424828047092166,14391874539708946761001075594593462740437739522325069415219274013650732876769,5044944855410335767979170189040984719402886766879289090117403978287180516155,12039442478120524220891851909305716836138223152615593874775855237995395028479,3523930243951081542915282337519662387190599423550808129910485998252637662407,21645562630446380089971004272761942543158290220498842219097308729146973947053,9635476273420949200636403482900193969961822409725076345852310152023632001652,20108896868320980092863545615065555118659548096203643467891646750271137801454,9185755445384903374596265352827852278482253313517817304360514098507824628136,15729448650969486701474329849747687235995473855623732466626603841221282908291,17997496197003273211403721001065741564292124821674411166555153239941325690779,1543484160386036195130212436149054066156454121707864502325718576708010327712,16363634132599571248968010449034783328746466576733841612125967259037812456762,11430550344567145066773020651025090506980499195413761807852670685184554749682,6562474642758509619875130343887830140546824045253242049540363976665708088792,3689788469446976140319903688077885060368720863836266384022598571957269060684,946161443553297471232017467760713330784613638346698353392670707850882897488,17775152994890017803033120420023910950366134526347402563464114996856742054838,18013595561755224808896799093133992096629438550898908281663802197342115179235,19550347733494203322271272376490635125389454301454207200256111665786140278650,12387591141491143807678990173849961323772837586376210707337202980616282598236,15615445216195972598868146032329101929277001754848917412471279643674750521844,11157377570334948360516367332475698893237579888172217677485190937247699033770,7130958205578403403951515578418204249480908544151977781217247531796937245530,13077463747714835214281685128657845926832593706922024570198457201391820941874,20874866618752897980777992983172936086725928829995747401713185587049763764007,9529341163966534350579350780474173060797076273832542721772111561732792505333,11142469391388881243303156644691476683457853027534314004453288809998298235798,15759641247899199119184149872340402267600476479959598970774176792522105838715,4932052011278518183097054145820640615211087138945458940865038794988474891006,10432003521315545222242540576886148188507417318972677351911763831484066879233,17415623007807480250676335953220588929877876653555913668269587494499596716638,6058502442301803313347169632367675883843035525640290470399543491756905404121,4937981332834016148179351587580087161307555148093009345111656135565068163315,4767276541447291442260238717093680167532207332378535289044385385412677713720,3479278227276561004751092786681066281912177752486503430342235086646969267132,7943278285140068849348170498689330975011840215116541312829451500334428180149,17789865444817191695636689430256327163274376252861234888599341795716694863906,11313788642745794682263060233193097297009786646629777858110154245289610960322,15451318802981646436556355654707114069777551322432702430595933898879175343955,7517270022604650172540378758621070031306040808100514057036893386092388842581,10009597627594120061689516706238257978394705225993629762944338270984243419952,16287228641302237661911798504390175297327206600486567815634358152959586818336,16488249714776419229986970659608164306511103745532215897060984940903927940510,13354728687549843942265910857129412843774195483459170542959107134210371522923,5514821690255816781301952402733589181643174815400146100135235253605240813486,5770103106430309708547950317514210165673407448643264387718101428086149468878,2694023365380190286709306630457152471177911482921639231487592222438630988204,2596360308486910596331175398746479488324950265788021808703834738076552537175,9039714509260386661160667890165090643713802650277924766536703740888044388658,9604908742305952316295642934650340892998619318487917447839433792965436657411,10397877232904834686750242142278095498016920001087513253065011131758634311960,9647356378465005298504489726754445992380752731297711041297431711301119823740,2901124847048448064485279495316677205686659456282057720583010224075223188929,19604711253175713682339631659824057587938105276478055043815802354580551412854,13814073762260094871340458282144499467492241477826265605381954643255652812563,19191277082146641271114112092268339387374938745710902056016346575725741574791,4351438127825195342433511764688522108908810411430938576079426214421798123584,13791103210113222833666019051739255444684344392875106989928046003279497788407,21004705702783423413965111534445421935934565517891538415275359891592731977145,2271618466337144497382665490697115072125990892802659816927722507215828359501,17558902460062424775395394774553055038697408789830072471787389990226026812332,19541727150539905151936633341362726755459275099586077305409909896489919664394,13692791587272861333747931194991249996571271400946738920492512367046518055252,16261859926552105019169611795692937520291616941485096436900016176047007140288,13364750885171681175943985569408970262762845797040643237076315743322239541667,13621972138767941419375174302334978784396954063748685093059444353200957635883,7816366958996751828525267034982378444982423551198678280151852851213963203655,5387588357364980194077356588147257085032575072648295273044945567343418708153,5561769804258805723102666784326040807434856561620360208220095378441903055863,2759015372384926293713393955452664141507032820282479368223024343744582995438,13981134543106614704319578938205751472742054796552637642168049339888724312989,7990257879146478669584929211133379459065259065980981194790047745364505663434,11876127927930413842997415069288338406075999315865409152476435081888707100248,16570551097531678234333612414250188586376313376162262758608423816369347322204,2912142129158840181609698148893520848427743435752721748118484524307819669362,21302711682094568025057587941584825132522581272692339045586256377620698610739,12312191496853376716581371884132892074646637957572159612619070514615509157537,6766172753918389200603997763713298721859536050788836585740520353915599111166,11495484070470791342676704007304510997655718568304345126153023374072812971624,20811664890504244597768955277493527673608205732118233091518542968150115526854,16063703627762167667966504135478113457485558849729490090362731172389730931393,14866560644094965611504947304610358591133796414154206860995591970456047599477,14070826318654672995642970624813758954945583937085129314124463556918282721543,2479865882631638665546581282869746245766113042059506929860680221143260292935,17398990555602339276684995684280302899074008602689308101178965669933564447317,608876042484390223586509032355843816374709085426455763238940304845396291392,19093816648588316664468783915406437520968219066632631005915358745999525844761,6752057404464894771427129594636749868828376343179986455821808045648379935245,19888182199106435309043037013966294783272588579928340631894231065863897158437,10082296017960550499269875102368612265371627577709879253045116718197037435449,14616172738414901831631177911088055616005574740810051337096702495520738285374,14075121030661423148825920501776601474873747801291899275268094618775991305078,186569155903133115291205664388893859453551519692185893083420327670792162388,21299949831814715974370318270705239305629929085336938013302553408219032200083,10073139629403946009284887013173459030563893496973388848686052378045073830551,1412198475257996126786641438141729921783447169582336707894995512036569315500,7779964092821851708726534513875342218194584080198381624983100710844846404634,948257338952437735532120031007610523249359469819114853137850805544224196883,21258332661476723168534084283213459804574003007208501208541743948207937371185,3571248067320885077052671052657329120832155265049255115581589211873377624342,18767668432875868101830472546043294158876614861521938962321471373462978174897,9300839292250613795491408219504842564421473000721822643979051375966405606193,7064697496603343927134791624768930499810256237088252983584462738613126284623,11853953981626198865163123682396255427116155876021473995289924391523536239496,19771876990095842377875081223218001588478929046615599374496234715810020326293,14316898881193279100266501073998404340884941240727243537292505454856307190130,14519359582636080510571261582400983934670011637905562203617314435861115398211,15526562931305845620715599917553561556373761549853248996847605985788604583130,13078262487107679022841832022599167182597313495640194703513299650288211974881,8245559318515118189428376002847388656528865763199194533482833563489439004385,14003329258302578586391126522614048791257224051921678844212914592624869865893,11725000422609501650997806599141176528384787601555518111375908215801780233121,16350891150329350826705554113837971740496662498788954571303936439413078899269,6411076187467760129645481080704474318810486795627076355267125729971512535475,21018151777353913573383620107187764987866574825379316352340980146357643078382,11358423056150266238825561031091840555431271536659827607676154506546242135862,19065833030377987569441381994102534825367123386452612836837050555888073644388,2562667974917478689245733861669928078902565222389031120733094553006681886960,3471326938285931978123873023764646019622642761349433536231294291602304868485,2563009390241284210001442885151389460822558817932742264596703331331069807625,1840397005312580276560341795534676176103474806443827954038672349702326279641,13608853165319143662474434916965520937512197511217746962619929048696566631710,19629513285164329969551640449451527909298649847319347893901982383162686335860,15394390010333989214892827255905093646577605209323130947826658910240751517983,12111906652703403073758441298171362667165880553934054594322507856217299245492,4297972575899320549167090598678621826992022863628750628394635867928789323371,13452780308396674980210210234355016032880538147426066947029982271570560372078,2831837563806484576977992168295535809035697292555489411927347217736327891352,16435334356674630023459784576727565801947528558756855054741604645713144334059,4127342592978010203327455190780821692230702238156658795505993209368069797198,19169399182658468533946629204100516992531108319585640665183465573285725904462,8598406387986750884545663645357594697293280337319305106433909682884489291980,13371924317816745712309163118606793190008424593275425616115063429517298127531,6966840677637301630181597160079353321163372268840965853806074036299182143344,7360050884120437815429010939441335996325758450523147733433611465713273074289,18472779235592140583651215638681270421642809888489121199352426980884551699243,20418315222771285674269327640703205319629639584244730201946908647328012868945,17026399731940643956418206353642733600139323525975091345342870617418039094945,12615211028716399762155462346481728092959316603121559521948867446476882144221,12396056279980752806946158389419170236239219009894918041607073720841998512650,3020267183116758520311575446823726815087071183512473845404855371056317502914,4656542918173262538192266136796850668036544742787442489947994092170369122585,6651580153776746866797134628474708113133308603326248742448594405127096716435,11937440848975251505322944134185172341897441221500443657141975704868428110206,1361826966800566560222081321267933925488529241685130208478269338961124266689,19943953771229014728170188452413560878330164558859793245021220185499985258316,5000555778712004519940673290591853777960346285299451454158729230859752281548,8421588432304272431559534311544652626307929129739056740355326524785204863675,20295164315900629557422352618552527295246432971816033569783057482727719683327,19373368537162638225474243050103347264636555313351270279300938524044041811781,19301584842175411162376576546656332386749822306022512981007234449440059593206,10803063363791701506227503212696578672701333662552932509544627248354076467851,21190447586310863247879892773912245039992873717104751727825265558975676297878,10001943442280168315414950100438358800275893831224620600570013850341287546634,11419108205602584425734602189435177828356990665164795815514509894518490834107,9176365528060199110731574560388345526295591893454204513780413140739307927521,14645264015971411259428809172021065485340465742768211283864072707152051283922,2059680394752128527783641175137415159902594391639901766513696812385555753758,1362210878544210374207986445190412893419873862912439530157828224644264948744,1767020623225215375042202191031932704135774649037849280381750341452687445659,12814227243430147774278313161816717185894261558098935373927981841389635793984,3650392274313221017884542662769899210301363377135174682150190146413571526895,8605030053804448166307797789010404548793085578661466947278557642849458591843,16243873345435203695859375103717652101719490281058055690129195139240095336348,18253688126813406708458581768662237883226849901952565733241285746065046225854,16894577548232574374120767026426945561995165201786189772245769116072691636300,6423863987901820348928069732046971656713531289251833729857903917381295249467,2313252375346549956530493743826026444705500798866360084159932659530274395286,14351648867218654569586186362113600409735374191851776253843321710353903071560,12748602702906129786642754668169435482057869301200357523545630557138115816573,9709541611470508424169916733595066328177420935464065317839768365879702321494,7178910033786777709713498702843323736165699178795466682345863412805925816311,3353312211975166615897632007255179570864390972587901806985844706830647691440,21333017166590824659869638126407263965780255207193356400088734092911593056348,5028007188794597820037691911407426228966175740057746443994889279713514676932,10712123321028508395224612143524241532236128389312765281020405990000255535908,9585591632158092894254183832493550005011787447364800638915694118244958639233,19409055735214428219964362626158681016506721676720000843605743187110212915626,7013515054956821958187738653419570061640238138610196975216698509582854871893,14195757172805460680435532998286722310304400118130745528870652671654335152142,21642947172805342858920270288264451136332732954445458690700494722054302963125,17447291201981220908729619112892222175870413627521563259423394750686485556049,7142752135376494645636618098683429493620847661912582079125447091506892873792,11965386305718013298615263282817897360134689279593443592649060011294217114060,3269287439460269094755519346810063037578116295811194645623863516503159243267,2159120529508493457616143785556394024190164584915596617279717229000244189542,13216089736556667969033672749174760723927614320685905176389819791237404133418,5739580235677403106179902507340026453834485061930671765794215270028117113169,10146496637166180435280660177294964473638207568055892239396905092844948797979,1559489237751880726567698923572583310388557924219345825351973445625480867548,2596197625765120503438747432434144655985802369868414306286213301002200644404,9161937832793127953923149604860857118908349157525975074572071369698144813595,6530106539927673920262526515085998672101393587740796643755609207665748320714,3454043461578374982297475090824066193432500488323777575207325753404726668622,3344507163548616813143529013320782527939556912905450999614978312225536850079,3495919320773160724078129285494188621289377270658655167666727615227933095154,5516726577701478990891722326081439827260225708304904918582005618283443949920,15205180713187999862939063125387810274995561110852513151225711366795547591281,6648123555675422871529580981673252698816139021904779960285680145979314385726,15841058754930028584592543963971426098015345537516384042315342065435733026794,11980445534925903182700789375967305825089780148976633769394511063611931605378,13752792603594569707463845404055123799321888887568435005345905056744143696677,451907199992567080921227130990235823262116394775607208182891587168397627680,18806959341268394516719451015233616843300011700855654586308376758853129828525,11666933396513215238559883168577675591860013867821037377342211197150469047378,18261858072527055096686249862512380033913481610225001662137639137871862029384,21560391742011390943072232187892257373961479111877969400490351307926336615662,21610883506787217615067001898587573081135488752397283684823910785658887961932,8408073424459585535553155824732179764716727837637392334926567945546036849813,15210371269884178529776581719481988665617111145372052101377092280056914506280,12126920168856651470145408021353708994570254510986190646194434994722466503351,5069682791790920726869832051575701989172948895827442056320603681340757243410,5206562653380935478898854557078389821615981777078527007269200218469247241072,20147037355698495391549064646435751868583938479186070809834102358533096530919,21648765692141622487379563405180427559394486974406039602691179361899957186441,20151743655500786952430656789085402151537047806266385436562459773879995501836,5934394754413383977455838937623522376367295023125030069688154658727645145368,12603931706566171371403975785994747990660901389421654410200684089833302667483,10026374951811566765702661526223829303823304592138671853309110795200798195351,20990348049520375634430049514368373247447730079841716683325070058824866344618,21619384435032220705428130345438986008128830023896849505537357845578039663569,13891656325513979012692764566925054630715484836057215275096343649598208636064,10516755320080836193722788097986010349704472844888704193817055904209452357159,1187924241706018031195408222997566778745910130631759501304388015015493122577,18176236836230977144874543476758297865658817104610686283126581582188371550406,12485836949850082215229286502965907740610097753180405472080386359153328488121,11294821091195763819640094447903397628795163768975434879119673473115769322204,15235618132532149904626305329048631193060570832794115447207190941624057752196,5247748280389397626917162873894276536157877881047135043409628106456158304439,12327729816009770868743571696284061855435639336028566901611215454206952326402,16602949418050455338609614423670909880567257158111141482461606053345944875474,19481131052077011331591495382924133179323957631986844309716638852480977994007,14534922095860994138017014871440884145230839148117198707882202478464336849118,14698138249781405938575978017673685687915842935570150501408655390412744761438,2268825110634009232539217412695133214837154986621027045784924577498202527005,48564023730318244345588908855562476416102457310638224830024196372769683274,13911429573364091016107598756829373924944177606409768266066645212252032518222,3072739629129037084628601278178937800555134277149245900071628775426363271424,17673164704069533606602950374212967524179027652656167791832581708629862878595,13337993423730131992645864661190106010697884214050744564788997133642079615746,10864361443255322638825945640705455870794346349925711501403405779308411872877,12776251935559898232336391171201768361485692108948381787636663233683642720570,5216617488642405414264845781989153364217494006051772154230377224854279460364,19003202417167005941636726827739223707886908723467287344441657245420838333458,1782933238160323149082341139973263731861637960761110984576354403382733192508,14049307335094461452125704957817909153045723261672970005965857346428556786126,602292860913070228058919352868668861608870961459967730841598276439118039884,4532222937868395031497077142687900610420285824272982687191592830322532698890,2099811981776987988652353966067242893298763890123265819355994207644365313244,14963517993601358850130080519783504904964131507655857293183966569857011289997,5628630657751613134050345890283140633799644494629647136869171968642164797575,20616991532748403949152312405329497795753361035307036075488592441729795933793,9449735601866166994904286297362590639752895462487835902681383517319419222042,4855933188947772127110139132590210785552455770275991391814399396690242166773,5236021116842873402180213939626155398638345682608182461380158609761274518585,8831771317829874397651604675303149337495578376535991692269465791612651585623,3088758799070584868972772977513492687395394215140736055156925465547111629717,9647320052871832007164877116869148540664111922421469306708391658695763892785,13710265959446629407575266748628250489155448638018691055085275421674700880156,3990937300186809757319839603902135620837406120640478356311388415953195593911,14183797850975043036582133930342253303942122026304366900989797745492038794070,7977072622674677196160507229659485240881624765782396719467815964585050639939,19241094982310069445586766283605264689470697759972104264399773392459234417767,1955047691838825101723033568109446280275825112435318858983042058841632309045,19123726709557210987172343550395139275104840920797922301604764165695899093438,11017985516143054945716095457545428692165844636350104202156363406141221710733,6698050162913212144220380056054973138261583127187888344395668170533632399574,9966258961247618428931643789269822918034016436345337589754558490493039380634,5992044103018260979899747087179477222620402658511576502983751749529532417546,4323136703775346257297028867845707816483717723305960372757928628051725499745,21794175040927871006132858751099842549067139289302899933403157116500725993565,4135205477235797120209733594064542822286242795709961420067213468324705376738,10502424667236605030274589825431626273558506810276755098371543260305259735173,14846816339594032738719600614652189538461600190221870378597670293625955865265,2524366986896165752091070306635323844562001546653320749202855717200081979142,20323646694453380576115350130108187509393437723558716335846490151009228206070,17922328316124774235198837264790120266787900323072144966876142176581863552114,1182636510606531787673615350114833983759075243161678674924493347851641505038,3207389967170019411093119580069334588690357331504170475184259410760933425232,8369192092815635351510306100580533943309224255100566350954698456188479225517,12030967886392195699293618525716046167148513246572831396936379799444387335164,14022141444250217995147289887822373716179013971005541169826207913322588624137,1819830254074794257713310243249746692467827341614315920377358118637602832394,5214222934428733796770137135908910242359102117443480657729178969918179851403,18138416073511031005117669443972799853597050093891426716335475360173308913456,15787040542336098200132680028140910620950068073851656692331927514281562129727,821824702031897351041935750619058900741428025283533564678462466715419856156,13945650681120508256113693182498673378848691411623235404408416652983710360306,21565424898814963463657730321537398782420569248706699928677873449861325896156,19609389297655053996872511820224772969554473578452634334180619061868015512289,11052162512235765382251445485034453773059444701618444976454738201341222665559,12166351899911550354968692629609980749815884172876848625284742219657445788950,9357004866878440721090407569238169828150449366762652916034388742054494762892,12114234396159313460221530030197986658691629189646106573755288837341527114909,20697910091918282046230152102481351960195609070206375824763685775389954486953,21217736707553075351032987119547432929010871168087324138739787787951139001106,17381364776399568820088774691862728632279841729367582228657079823795538435769,20943148878105082737615418415826125298002846495574584317442899738454169666093,7269215523851335046672197634746347471983448536436098948086942864058221294848,11453469784625194830295468663538063129244082440999065497133984430619118688913,21018146386490226380790917971415394820859127890200962707883416995754459780694,4499764602796942905287899120539899295087557389188509075023605344029409757976,6253534478331781543005728896589051616547370996281199587944537185086057029207,11552217017582571341399470106065323830802102428782340770897703340827468796773,10819374663920577173719455195284609222419659549106826920462161534187158953031,14349899656862395011953779288216924779057701185080247070042551534943737976358,909510146269051589147289065017979551607491214019225341737807929286505047312,7822991049400510485087251716608572124487352922137650148085367861004077510787,725869830997965165130427627260429551001667760503255008495920045139979612999,16876874328062330437058858063404447748425817762641981976045186363782457609729,5386742002628492275210178331450945300388007254427357938003565527570148075266,5628231453725040085705711150750978455046683883113398227942371706440013519778,5207331605257641510707403983352805778295440159078505882865873548456617745902,10535586157456772677635305329613970037048119551546559771279117980166707049697,10634858349767776643334691454267563140934605084766184133586786266071708634005,8194830686373761187394649827049013218313677678976649876752071409303459578949,7100588172111463994475475315895964854310052675103208262359133193362837864219,12698529806569743134165801249102690453926582725077752506169518961941228191732,3192504222109013167359339531059877081526474219178099463731713708944911915094,4863002263813052668246974534880517465192842993905851311847938713684622052826,5692128778265216733946522388190452257048514412064102477216511313048856040820,10126422206202050217110361146045359045967276838268265874082659894234609632351,5816818864633980489627669987512782856651289984181002178349070605011354887917,6571596820513333489228887403836877987952738840623146829273932098108053062770,14089943097204317257370418561461590134190932157472606744328891293369209454647,15650892875459028952140088123225234819706577582764200222337535746289113550733,15234537030902822319330116055095343429285315370864285347784850359841976501754,19442144493035982963093880999374393289974808397308087180018619507528159896278,4787721462177588970261549242306006751465139812381940463247588627972131957846,21188266388402646362923963971922131649215999518682418035026104849712460470697,7670120618673949888866627327541465118295930474243507723982310418317698793909,5278076033158881738611446681468941913572289692389442858337761263328869905538,6812114686357362596670812436414685361641526159356770435320544521002690748983,14512519858142345768369977582630083215640443350401036244408402584958380156234,2883669043634370578290606585906686768752718215322315377961330865510599230166,1390031372189262099215439174834826964629551818632345640955909690959488475368,2621604580741170950714666893803390793334876512814103152393976192943909783864,16238046050182542127054230631321316896861946156551854572617517416519877517341,17244586605437271554745538098470023522850216211045683035769492251097903894816,19367233841767536085266806989570452145418274769895229567119343509637411304432,60922694691641059020255299196606231058588207683679919735176896931621476211,11404572340596870708576661187798839793333697334049619025922813709736021654992,19297195320049214749532857744175644917624562154332216539771469808458364580570,20000477679980055675786972902810034261882771620364631737011618258163102706803,5145215345848317594229128468995966108988375785838942899274867896011577909800,12745405048448113216886186019434813760835051470566703617056298583393105029140,6134671602520394562619244398452258969460576801019889394876295515660617122846,4914589878992627637690178006894707570950584383330674027731006564533772285206,12220903700447451099363813812957915640017509928028867600267100643383476677026,11628588304761135026225316417404056298817057087404654319307918387873030085506,17423007615206678675839176821651284038190814226425327926691523730687305701329,8965704645750924279210398083172931641857031322145961884520939048845530423732,20213900813945518409362660921232075042618186257655700796304283970465683248159,14023473417795456589963878717505287517669917599805973068283274798230783465678,9113725901633633321816296721315176702107873006937820201651085782607150391484,548172112211359610960958872299753762974328909291797522208085351481742658142,21706861375052844683595820457538688901531393763031119579322611763049792865067,12400834297098033195346480176669546452877127463842848395269580039592533946307,18693408652472113120418656602007998722418946699666834214243410738193362834090,5734025542584829419095063290697837279993460564092839068131370421231150830964,18924630076511631254945042871273344212804227110396594419618744375738473997458,21814215076304113439159605823570645338718666334965210428557308969012775849083,15874497347478704100595228569012157674761828758432798819588001847304550645894,15630701992043410338260010633128892269216736379332650587736588580296378591400,21182316539430719202319661920312710080481096926576230463259085025268931402724,13427632056110349253603837202352903590918428276805663374267217475392463207302,10911219508671048309975190269088900191221091803425594935965400900508004506426,9158857576095512666804740759126852985161480036845995629848333137432364744220,3061727900948996735547324485012991687515955796128872254459502313385493651603,9484087600338383596528641950981362023967545451847364854943599173866192324557,15244438304843092101886329998640757457334825678432810119480500702489267475870,966872391220567196912397735096848312956568724961332613947113843660023937964,11463695793311663093741054432425795718511021724948561649345772770204331282701,4301779131461344863695073848029046722184482171568650483218315300688393400530,503085225024315480816360605760267420357374543116157267432728664696709665901,2152733644489285468694016160698899213530839938744988003049661235638107035210,15311799268435674361916200869320882308334015315600749428161144697607223747926,8821276262247279528293843357774532114304424863546634692022624148120506964899,15012215707563410212327951685975753138452396938302623171526151974041926043490,3832600555460338220245921307060619972944914111584149730708347861160918312276,4945512356937128186743764272299580525076021077689098424357488427223926571902,6352619611110096346414873193740535134097751304211531527845737802795592283759,10487432688972604512516548109465855881572886261854521534610720416206960307854,17622489873780167264774227253975567347204222125869234241462457566132215071928,7633353550826098030742486107449393642153730338494606903118637850284315354119,14024635247358847977026819464107185157647377185834445176147145227141238505750,3839080266490755896783758766005919524636645447105234209420661161997449147283,14295400414627547924873035695592309131547135626435254888679625991957098691157,9699346383521400413122931609905328425995515996718354291677850659748262244552,15892775179188924258683368801772704553840476123482448500492733919344870447160,20199645131225911044918007618559374867899861460760047877106143132248914945273,12001320852019564045161245401305456578767647373680507608908849898281736831048,14109337051994798438391426281455499687696832970217465295841248395157195678143,16327788711327335703187954019173408665382603544801329348791567767829649582022,14165345295389244679058422302892574411018017024852263235622041585515310700440,18098328140605761490641355018350075852862336947591383947449899194910504851997,17531934292095415392849417096338882004139134123682574245576387314018394586354,1733676683546726275638177172968959379163822515869952716090548401850898249951,15390925956113897743988821133394062442365524479421281886945584164621467664839,6308234777769318028945248133710542338224131559387923000379414195599812605031,18195940437872982705964842501287028751711989848794835251153117845868361639502,17490283477945958076039190253339223109810835246475119772790163703167194121322,15408396829836728115954873718864748500411741345264521674331031030247235075214,3551438511462216897614311415123740632223550882497302889988823516019801455881,1211190935634033568807015118513121103447278874630092924424376539010769615279,17406162668797550222384115208538224445727151774389004540678231208053715695274,20479453675762626017106163313206256229631927324901802475043478933123265498282,14782425647559744167182627327791886056751281195680302914811546501028210982186,925131908338441634745517290354664216337826881101842522634123686010539186420,8849707997196192490777875561563208206085973382242717199438345627124299133090,2076454320990941741925816538401596397546951763404696804371822796867698785368,17173134576726258494214130646402838956462459094351663199002055284799185636563,8278507153110957550422039807446721030659313329793830361362606551912544734153,21454855413436031867439010732150284197408206511012140387650556740240705522088,8938141846612216610282603832016394896549074914747256157702516831379429923666,3753004427655295864092888874901033504634515083469621309422669489429783662244,2366435134561993720630980767268361780485124472309182242565985427615594260755,16165357231356434631067514709216775568766632800191759830231349057343507534434,19619001519241758891959372143573350428188652312535228885075978087065138604446,18529730720102625006097708392875275467779439015225330756494090875760858662324,5652897308997297007169294392190006281027830654965418415676327691132517009477,13575260089385236342970650047136574844156206796954949409405285738862382638131,13051488122183433321152129519814259420249179451391427892934958106760313757814,16675947070785780493219656951197382898525312482169747446344506906972920892954,7175175603774065686796811506353067100604576034944842446058484596637779839013,1400986416499873501628131339252214540318552035055662222249409246587339999877,3464466866466806017745751012761954006390229805750136348643137486103734148919,18217858987033907489494644734206558680641423556261333390037659204834788684410,8406086726746620686898224574302006639796660679494669881199476338693847188630,17762341698784805474670945153199304225802481228485479435097247827908738620552,6223712186181276291315191942450380783893133091457934083606193355728586611122,4282900419919891825156385371067226030543529098387005106356966928605004273721,21245665052422749020204481966374990873300815343268950998971123603215733315757,6982432590923765268313576400153302843651774940912624901824133236148956994132,14604328114465343527250129263480156133215257207190011581958944554537477242146,4419171346687102376610201013900704798965178967312178557853149472731770706501,13245918223750947891398096117311260221538002135539665270124077712098715822692,3347693769680689230259648405537595614327886881079646330652620517715295020391,11097962153704048182055796266608903112109780112107618586656031611021161690259,103842991820173997936966388104541957651469231887516072360536421395334472158,10458487052445928020397135451416595147106158179032040258831628955988702925482,10900270612365580629478084761129851570116267768979394602611763172198923647648,9903203205178879991225339006690459919299342990467545909511182892622541268992,7206476963459461034052924246171589839665793743462578906114104789862742647145,6264046538214382166095990603552597379083154170591970728068583459736905241469,15208506074912456921421298757607137779904668310165212805848069781063650192568,14399898497646210477881830976333295219807765057833256267205543494652425724063,14270878504405431259159385066097540588788179903719271466546150744452837482681,2299469207691207005105135549235035285287116575059039549352935321891742095084,16821622844104951063765780536072686283845403348056960050391910562149383647957,9956020421344380373447956054462292461416421439742573500231969663699680679093,15930825774426452340437887971015387876460967360948156787859264923789690195070,10985728214199775151782154608793108221074450547445302100877022826701613291080,11760641126739413999815391346325702178866867588284525333479386263279622799779,12964764722311909921385583909124655151898642200440943348322605636391779313939,18379853927966213921019716164768637873544788239921704156188954474082485441441,15296912762863693782000299085702814599512114536531293086824435743573000852798,11055306663322542945964813101077231103838051414460193023274311763885249453027,8057951225246999526336336507654165264870114340865557474750852826611325059180,7217454204491887928591297314854022623729750971598154127245160014826014134117,14565102336180706753392276751790538414003260023904084675564779334184014612773,16932806574869520697162166869588187543526028859439455500295852309668070598166,9179898117866495045233038402762881324885778157159220317172535561846474551689,18779105085403868166483619694881906385652758088668461143173550878413116028260,11214136111470281555815079365242861297786837712776840366750250043823307862209,11442992999493383524983810131599863922453401327420664873617599429059754849857,16271323289864628346209913310699661044288655850612550590359075955707090062050,17108025350334840622180169650569770852833940341473970170517727066627050749958,13146248878892216294361188166665572028549000139712229260161108594416711673870,11427372820077962289622241022478467149286157602797953190515658164839928300751,893014835995617411380095483743111031917691099253220683676712243294883268295,8517095300100078150575343693630592663417209558229239005971749331683768522616,17927627171733468726764817859266182414919024487868681391571481635385817509424,2910874756516541331498135086483127887295864033618596807255973264881493597680,10351245804237587891981133156579115865490473264567370459691707360959684413970,12694211070090545997357986982035119982901819345677093614248046140600061957940,20283022323110075954579979019632104756139185475301167929737027848763705068147,15931844873010780159923673780071721836876296130477744289335217834580073984287,21827223850924748993974869213271539530659373002293617263857321497283795014386,2216130285102621170883691491664557599377015082391517585865064633069426967470,11373405503815639839270612384753272139664561558477978654573651197371057815151,12313875735580427829620793313088533328915412934622924938520740599744871213525,15142465061035421304605695594042142745567585293979295525147576522422528415408,19911123862342914329674984568751978176595422003509172434076759943963715219260,14262659769499978824697304563726231560538953195673261355416096174585413608681,14610683638141173050828300939153196590488444327501938863403192781649951814095,6637311287977459850936997036417480664822288091481538821362996372726159029429,15501657635921439788956110615190078759397404083654787694613599184616807587119,12415917438013473637314666005336278137449129158908612828862230927356476129214,3977073659694868689017260754925680384676839395821102222683036599314487912596,18021973030966989893231530982789547568199608264409750239459349680822956679629,4358661372125150502295103743733014495017362384424029473164385391234779773434,12150574573348685676904261170022340625206210894206500162919624199154445311926,19059564947466261856206182248882637129860510906425942015878496836349348075264,457803388293300831659933030795457353247367081441494540658944608302089214573,5212046878650303869536834084593989055518385481488493726863247051727387374999,10866963984944634834508529257930003255650324224099527428753028080514409460102,1567398629202166035061920213544077752133493577343656913517034032663760331227,1641623291671542299150077964313362112100008772415510478337935841080756871031,1814807183609065925468700221459835599229505862471630844515076416397596161921,18676591284813153230980779135662585498854259214169962891045023401932640144792,14582715392475730800118541203172619815507444658499922254753619352141615271717,5971201190012257917828174333108220091030383280212145099110362036705465802488,9745736062659480171553506036948675113562718355498342585124081392171087285152,20654605762814031873434196876396785695406369410937473580199071780191334325949,11844011087342569590330041590202444612516395732736950853259915342942395929104,12960729918447154570349545809398065983315955190065107446283057843674060399978,1912969365260456210218541172655492769437123937988143458973053151759348812779,6751278463897225433246228986310134589363747158535699169746372748837067912354,1405433090804402720301319240257714728362644500702704160642087476923303165683,17334203531491537592342457272578981899701055200802551766264091441355104806736,16575765689548766530893504204590870417122916172019674976779799591211403721688,12220976854598379181285138460526335801169364473128100040253401652070229420610,18565358629024373944198152078259356971563125515748886809957420832630624111647,18999218340435052500780578040305741910732238048488832712380773170203478504280,828469997232485965462944215365058139980461203417902215718115878220834198655,2385864265255813442011864217087321326832147642514277043179825610035123479208,11753087538734344167619786844012793078263845468062416000491296071906848786208,15297341509659920002867070368227904487875907462849401568145592054120947559782,17451904737564664855895845058410281315610351460549944647244100267528838462231,16288687708586503845827496209229686543350756101251970070831852982828263987682,17372190154611010904681208309570706747429785600046317069452832284803213135091,15112572862198958048036722322696004521384539985617885597335257056722713402392,3090030985871039557449539908126365491166718509536148045184016492804246563853,7579986120189318071341140006570025802626137718385790787108832330451957404666,4656625991418301006397045145531617124589866163929416672123076523538862286851,19496020801558863926434816068743011465607626373023757648812447085667986307007,13805329389975072362759970417944582121050551902725997016013251740633448473430,18188229086122124131780255528737492392822604407289151260248713532509782736083,14611835504502434276576475613524726992333885650957002636192032800434268523844,10917400920268125157880112072188560060076995206390296416305594303287585051306,13972231301490257961012583958703459454850999751676553092417436936263553366685,18328503113772388769765260234570641415081417900145352728842854263561232438288,237123037398988309289930744284813441581716633481073379308753775064025864085,1703922543704124573472350868371820728886443372137290454699485327716109471338,11303106151640297276547682977648977961130813769323129464984120148868796657869,780835119818217499025356174332702814577120774118181250962295467182217505278,7513776436281774240010548782707301011961852707217067098086617267751060890346,7053386733865795782344919942070418964042982090173077686333893187474076408826,15388377229685250353999590264475768848666849601695837177100149716633411294502,18619784384287698574679414094727959444475916860934398666937358687019863556637,6843956467116800550015577789758902600855297665349663446001269088726857226048,15027464760260005079316932218316611292633334115528481474392667994765319146064,3113497944921123135464097580210634621999169473508798646842600013742294203321,13922875552185745353363519166943408041900501129716418917715862175817917028807,6529143033058355347608548436453630783222625692384446386966623567146527415664,10224300829854530831381318053279338710395220281107133842738514322747972858570,20406735123273907201110501114056492687992916259913310564107896450511212255632,14266011897697023567365526625467367950062937074006135166584691625548787309637,6266823350995327247595338658995148275348018579417278062676982980758032485160,13382224019010393958018966744541120649420499028243672845532376433487586111361,17219221786488657036851893458562210759167416100910882352030211878162886142909,20162856829897101788693886235042939518715128237037117615656868509223185121680,19255871117980259796107225408238738190418971755264416661458453217281817348088,14978990393744959794726413403754476561984809686673856442658550453303982912228,19671827853594912540136789344716532059747421261482796306917878259275666282337,10732390517629598846596313835253769945253387192277550975463036830136687386844,17133415435299159639005309603217597288690767318016826234871049396559867937550,4238294829801619171082019239832000810131476156600856298143082034448277968560,7722327574874647121890494265704613777043492303801725732359520952354380593844,12398521387704975769381094211621106917110829744392349946808293674617176531795,11200776058775831613393435187103560072186926574904464246036376746754002391683,1438209332219971409989076556134294085612745796338690516891328286502107803440,2937570830929161760131625263024599999319751748792625900610926821498514203833,11043761204766219739712866580984621876221567501998807492499956572251345283273,17161703263657344245212174231645949667297741070344916641526821962829393621412,18619070492541478298708071132730313137437250499943292747935022132254737182602,8379242582671699656964937417808578910591927550726975853520669689659712748923,4461581878275014470922963327129159901508275066328903674248853463321568123734,8814779309876923204577653695802478749454337142645142889405691969158642344463,5916090197404556150255058868159426544438846565532168821258584401868379000295,13450130187167769463125976820336122102195298233114472585228206936434118870547,16312137321831916960674847439149202523298938366384118998520447019250845846949,3523905992883153108179926090860559860264215076129040324355490516029055984441,9941544263434232818617581658227915119072214833223636007382930887032695504069,5866421591020072450638507367259603444231034674337808358938713064987239652864],
-        [1098498142837982582047608372723518751721607512716925277273595859756333857326,498382712248562027578374863343601618793781182132084383060312181008958381971,19040726265283429618662679510157690394832296024968480927415996691029230011306,10367579130776133414495805974535693744211249758950881275217429221792836643614,1229596364469449066712193908302977020022727834238778132871229393863406546866,5594347757215876411130934611555467571639435097442631641074898978663329410864,625275312666547608222628560378372315159605662141936411119837279426221363981,15485529557721639677666143827295121022852505628489596851713462276650737776670,12156576509577081554587930818670905775536581975823788207855134544267814269606,1981640929928975005466842670997136169304057407742291166386016130552621471939,9375079124430521740651903984797221620963928972304905809259607327125669559872,268697279437287801043057266739136500465135819021738115532631740070584831216,9310725094036396036773344350803037792624399505581573214229419814378683970851,6144934044671205976376028664002834283864020049596457260475210339996948797436,4985941506647510031967748765284991041503308370910665002557248958100799063851,15851062719909725150709309168582658649310704358483047683106225599004779349418,9869770840966008659377598457679699092337106962689936558150689057592239644963,4964286354328869036674130011248598806906438908586967212984901377099285878228,13408525694456518383125684465410538061086669117275911801498275369395798296201,18263306792332242197764383101132914152275840410710698264525919817458731671889,10401786441956087930118823951510684636068781082958380915651220354850381871543,12496745101887166473879957440401384727148915595227764657145046356182346897947,56825204182651219072479187681186238157981743937496557304633023935549648224,7949519580094467639897040111470236633243836928348452962417270559805860514707,3509286722306670968352119363633866055096352721394520084890481975258162907251,21359945526252146173553061920944871506626324563977081669248710516265311530589,14649491209868365229844087258057697734286269047837985905275053819765825128984,12122186136173879572357400046587658543826161883897136171993927935307093999926,2666476328185593105035429309804341325262753927547102747066987631391232293139,21005241858197204874543384881533661499138265185107903730534607574687765896488,4866331653274711303641000079325074227730641553230218424779550288347820225149,938689939079340009195180604139206414955240264736983491692686499992823741696,950493909161345219342597929783079468041198261349024441783356363638640688155,8227093387774305505218050843028014038423742476679149203160700406235271548925,298899716277443866412562171123535849674476895336539413683307522836440058745,6985094123716229565713211140430519589886023406928617334981414752732877292051,4561102873171162160916461632027561255705058072826965137552144392802414262261,15422356128912397775473168682864290042256748428952418907369066530964035265216,21534011877473706794700774934355764894917955655606512952257743854629820348396,9461908500272520643111839486963426035162115487175673718316249722520977894185,9042969964854694648113546554619141983055960736166619708191725199599555275062,1441104948831954255692318866730011748129225465895791664253095290347818907280,19417400621113450826458192671383621002793369580946623762558060167661227354799,8244773274459817591888745631242804467035454174608673362960589130536385507190,17088086767144106377842029064730946925009348520592888187451688601493882340857,12886019902209719236096958359125451092745638766392722988311451127550961945660,20280862819329644063010032903732505647194710429034928708829957501178343790858,13239701144341900586601825324587185682073736334523805955933121583949546821724,2994618864933374534869864629648211464657674590007913715843569952783382900518,3072221011986428615228338853345294533299624086589539664037325300531050793357,13594276105600327401961157952766116939399999497643063180657161489419638074478,12904364780884039213184464580277965622079185353283126471569179129906875486852,15088962493677593800057541234990587773412340265413268221386103386021880406010,14138285403526705785804535000245522290348086552790608567368815987904186155718,13481415964846572771441311017814910258609608797603836070350286657768815710822,15459769479990273742477151452466966963353767555965255520456901549474045452607,8586052864861352028352866296665876117392195296860481710367953704812400661703,180502622991267551120688532508657597773982647209049478186474242637299204110,4785745751361586866577727263713743688205421961646731269452058881240942369409,4583871856798894230250707953295146343968130822948818555994825096960225600041,12377924729639905725281972784629126900954187435957722012223715002490809152047,21554415644278070156493674075483844873249829791940344144484983897474364915950,8390225843490125870104241611355504124284851919520955291024552578484662824128,2330476067094130593913781764168287559468546989640021387799865123741354870445,15749497374252464770935521609391859230015300749964554524771184068776070217841,16817654103281917947623051388088441309787140809596505043937473012669498321704,9987656178378986905964646161927549614205785047077068310684205046327286932204,21450061958292240283686535241652971764195183478875921481624114699420928365160,3904617432242099936494425054740854886663050476318725032541401300619628714123,21454964104289781104446533610149551385791852085041524046710270949744081353102,10768409462143965702783360646769759623397882338491564999208626639994081655791,19385613828688830964519526099114207553837496617978489639408163709100497624509,9385292780799468553063371906778802189174789542685475364513544798199315486080,19882577122462819381545089778080532575686772634821281258975533828284349988146,1462201549484596350490921057903425036211202388283463006651220816599917679116,16564642856725628254155356607086672564976261497486137590399143770170930986182,11606470848655267736219046910932382494518380844147406842964119623341701511194,546921055225672463086391798419385468083264065960104350335293012629066408625,12676737821548820987278730174038033161886561534502963159950183188070064038340,16429180804851559661054910451008618941371882312211198495282444364589225325606,8318514508896823373027050528521007144041407638548138855564062559664141902892,18546910687432012966956995548470714600618104024117576926439677823609854961263,12006683905722730408249989907056432037202625403043550391187503858618155798348,10816814135685807143320832554644398181525372167669730953193258726693903362148,1969445073620598650457101028079888612893685228913473332116076918643068711808,16873795316557869761040796336264749169213884122126281483001377666183529927793,8441268321647668856014389726368355391497206989491787976537908376817970369132,3378086906271763133245748026584767009750550242946195995254881868035794898559,12721353531573613369892164015903035636498816100971168742462654106875931342664,14969430369156214890953989610124286618925370029259450629468188666450865580556,8545723361883060050915916338313252821252873299513393695440138873537985282439,947668284380905375962163908708231363459059635485281084900173592739603282382,4418352807772484492818068921024797225893951828921880350002134747344565378254,18146914067008843660990756743559427698617136456156926109157771781314720068545,2353279078725994188579023195684884389261433430819033940093641668202046052763,18228226015329570627220992288018909552101992748538110505558715089403194764144,2251557590571495628913478692960173580728135227602564510397207128937882297417,20421664597091787362209209474226188711714308866665750343509458297343168321800,8187951594294388715811532560312339537604737243977265499957088579012554679278,15810834190411667509425096842396102750984990364193499272150958331088983323159,16884308240478579935994044823717491481297317573500280152191710196639752382061,234497484353824748419812158321111328486478789224631887096763967543932891899,21452418791072076854500976656696245147472896609273403517249960331326136475572,10860322289080285812992522532751459911253736747190334349942615321085283282595,149826608572716492570322179195234088797160854886751475825283168005807771516,11491761442863092383423796629001188933840969144934642247702733820824608517603,12099180244453415217270377899736157198045626379801787493348249001794558732373,13177983303979037999809722097100345612970493007300007493855625634642663397908,6849052800275826145043024580348093078809773712986428314364827674907764829568,21486255029472594818259653174918852363002807142725698741685253190938680807594,11451503340703054732459437884000132607423536025797075877436151438425159994269,8462539135531767509735697608276067216182907546891182278996691315801807234639,19944711893825824667372913293784300313762563232409638194240029859435259601775,10396631238556297232793544122243237485091433966091043100758266678889110827200,20667999270580360504376758654763163152764187226267414436968564661080084475852,10424436665500877000658892169756884171624649701456443210945810183301667922053,13894422482417998868290238401966517700776990643618129177567797594771207188055,9076475964444407787992938909179730031379198268423789105813333967195259669658,20479003631920854685589262232015009286810147171298477411667705150903826855301,9928015403359312830073752955992978705151208358029077246413002475277600546387,13981618256931763962905358530247354996931923386029793318275706908114940457317]   
+        [
+            0x752af3c6fdccaf3868276685f0a69b9749e1706a82917b64ec2ef847f804559,
+            0x69503d417e25f4568c7858ba8334301c0fa19c1b348bc7e18a4c1ace1d15418,
+            0x25c1b121f33f4cf7b308ec4630f27b603d22aa81ca3595e801c5fa7d9770a096,
+            0x23d6b55145bdb32827c1456af4d7be4c2d213e825c1d2f0c9ff99b2273751f6e,
+            0x1b357bce3ef3f2b76afc2b5804805adb14cf6bf37fe2357c79aa7d6b32acaeca,
+            0x28ec5ac0881c1e6426ba499409894a6f3c276fe5689f2c35c9027e80944877d9,
+            0x2c9862524ac8a07b47d211c9c504c8b0bd398d028acf690e4b8ed4005dd06eed,
+            0x1f6e6f0ac4aeb7a52343f30418078b40644cd43e290da0baee92891c4c065ac8,
+            0x3db3517e233f8a76d21b2fb23c85fa7cacc577769edea09aae39407b9af2fdd,
+            0xfc333dca4183dab479c5962eb05ee4b79a8ac6e0cce9e9b0a2142247bfd0877,
+            0x1eed281978a8395c04289b86197673b0f2b65e1a135264527e250a5cdf99aca4,
+            0x2e370db23857de3689fc9b908bf45ad8f42da900fdb4cc94a7a416286555a7f5,
+            0x109bb6e5e04c0eb5297130c6524097470f3375c12fc9092d21ed33400617a0a5,
+            0x73f4a17d45ce4cb6f4db87d6f3f5f4f1650c618e403e1873ea3b8c4dc187cfb,
+            0x1a3bcd45a2b1dfb8e75686d3651cace13e1a22f5d838cb4a61b17417665eecf0,
+            0x27214751aa86fd2654ea05fd2611f0d907287433875a8b0c3eb4b22d24d73ab7,
+            0x1c5463d40460415dc684ef2415ba66628b17ab5f9fbc9597ba65b74892d34401,
+            0xf934ec1ecd7ad74de590817347658a22a783496bab9943ca1a3c604d4cb745e,
+            0xec2ad1eca0b260c4c6573f2f3b506e946d2a82aa5f9e65c2fc4bf65d310b1d1,
+            0x10403c6f930519af3177a82f2be1532e5758127ca9fc84c93c652279618acab6,
+            0x12cb8319683971740fa81660831ab6dbd3d93c7bcd441a912810d963582bf346,
+            0x2c7cbab33b6294f292ee0eb31d53daf2eb8494d96a81c0fdbd62ffc681e71302,
+            0x19e16c1b9123bbbf8fade03b4a36c5df8580f8de0163679b1815dc90ec581bf2,
+            0x2d2734fdaea6da570313df4a533c0049e44b72b64906ae9cdcb3c86708637a4,
+            0xfed7ce5d50ca2d33d1adfa990161fc780cdc30c5bf2d588184a190f686567c6,
+            0x2533b8b3df21fce8544a6e12fd4c3c1fa09d3e1f146ccfab52af1ea4d6ea361c,
+            0x254a9b0da17f1d13495dfaf68cde98e224f80697a0c31b89af097f3cb270f277,
+            0x52a196789e7e3c6a020a0d2f82c246a903ad7f8ce3cede8153db72ac41ce566,
+            0x21df9d899981e100541aafa28753e763a4c5a2af9845b0e9b7c4ed1e7beee2c5,
+            0x10e9254d95c04bf4988f6de51fb019c8a7c5a20168b6a59479355e880028c873,
+            0x1872d404afb8424952958f29d07b60d9f868d5f26a4d260f843373b706c3e850,
+            0x2f7fbbb32af67d88737201022b56a6df47d476dafa7b88784aa9ab73c57a6f9e,
+            0x27b5ad383fc085d2c2639e80629d7086e4030ae8e08ebb403860b4eb2b4ac487,
+            0x20a04ba73975ea1af86ea418e5b9fff424b93a3807ecc3aeccec77de9c1d5b1f,
+            0x4d2735db418968e804766f579f2a4abf79deeb66240fb29907b034db93472e6,
+            0x210ba11f3526101019b98aaf9492c04491eeda701ebac8c66c453503176fc0d5,
+            0x598c75413f3f84338c4ddf176e856f6ced73ccac8d5bc8fc6f12d5f306ec8ec,
+            0xf1a2d9fa8407e310c58af407bf730becd9192070d7aa4215379d1efd9e6d2ba,
+            0xbaf577ac2621cabdcf7ffed4073e27d1f711f9eb5a9739c12bd6df07a3cf257,
+            0x23ba3057e5d9f1429ec7848b893ab3b40161bdbc6387c958c5872b4491b366a,
+            0x1b6010fd6990d3e4928fdff736fa857bd517e35935e54a1d6cadd941eadb8408,
+            0x2943fdadb96607530cd9f1000db50da2fc5cb030b03985d1d3cb53dcd6937ae9,
+            0x9375b98fdd737f277a2ec26a56d374658f448c690fc8e376e0f1012e4da40fb,
+            0x1c124f9f3a2672361b19fabaf0f2e1158b313fa2374b72c370b4662bf96e8a26,
+            0x10e282b93792c2a893c54294446a63bb36a5b3565aad7504499fc22ebcc58836,
+            0x4bf8cd673199f41df6b67b76dc46cefb40971f0fdd5e1fa15ee1921ab5d8603,
+            0x1410cbdc261964a2ad500e3b6eaeaa50ea8b119ea11666f6558f9b3d5855acf7,
+            0x2b17833b6c99d8d44c68f1a662a47493daba582bc549c3cd8ce47d572ffc9137,
+            0x1ac55a0f9d9d4983292eb30427f1ca01b861f17809f2fd94d3d89b2f72627ec0,
+            0xa5efc41de76c914410e9147e5e67f89c7792b20285cd0d15a1c1891e91ac293,
+            0x1344b6db5439c46a22d144f4d5843e29c750b1acf7b0727106bfdb94cc023cf3,
+            0x1a041839e844cdaa0f7c2a61ca9259e860599258495fb00d6a75b5c503e71977,
+            0x2555c529d366e3d95899d9c4ad4c2d4ab284de4a45d6060ad91b8a8bc5fc24df,
+            0x137894d2c7ff06b141e601c9a95f5664119ca32b55dc5e1667ba62524954a724,
+            0x1f2ed1b26cfa389194477925f4dd3bcef79e89829c8c9645678343a13ab2f637,
+            0x2072b0c4af46fd5d200122be5c5011f1bff2d44ab5d440ad946db4ba11b52350,
+            0xcab3a8e77c43896efc4ab5bb12e3fd6d234a0dcb236c7c935c57a00338511ee,
+            0x400e867efb3a8887126f96ca884358e969f14ba81be4df7668652e15a581cb7,
+            0x594f14af7027250911a4b05478f659bab181ab426631fa4c369c361fef0e09d,
+            0x171345094adedc87f3840f78d3f3ed67cef3b6a6a269b97198e012abf0ebb722,
+            0x1fdbee4f85800afcffa10d76c25c01867b472d48da1296ecaab478190f81e242,
+            0x1a37c8b010fe5a7f299fcf41738c50f5a904cab582e411ac14828e0c18ba8753,
+            0x59cbe918d4cc5dcf2d3a31b3af2c2cc107b6cfb03b1be9a939a7f73c5075b8e,
+            0x2f0054d719e7f0d3991e52178a020d3b7820a7f2a075695df201a5e292831b33,
+            0xd3353ad739baccf5ca9a56840d99776b5a7fb60f9179dc15950c0639d18fb83,
+            0x507a8c3d3f5f3965e2e9fe62fe9e824691cb53afd7430b625153661da3e94df,
+            0x1eab1d2b44f79f50e2ba917a96b21934ebd43ef50caa5b21def5efd8c38d9174,
+            0xfff97abc5a6318b03b46ea4361c8d29fd8a5a4dad51286897e77c2aba9f25ed,
+            0x228907c146b4efa56af5b8f2e59beaa01741ab10f3287369efcd78e1b16ded07,
+            0x183a209d14af4a1a9db0c647ad826fb75aa67506d03a50e6e937e3a4dcc2d0ce,
+            0x17052b40860ecfd4bae684ae12271e93a32e1b703c3127d5d23558bd75496d2c,
+            0x3a61810b60e019e3a5fb53fb055f81600c8f269b3c97fc228b373bc6a5e564d,
+            0x296d0434d977a105b07f8e8d537a8381e885dcfe482c3ab773cf1c39b3bde3c9,
+            0xbfac73b8e7f9882bf69125684ae20c7184882d3763ce87911dbc3eaecfe86c4,
+            0x13900e213c48cdefe3e7090111aaf1c0873e21ba0f0b124daa1e9089677ea937,
+            0x19f5725d859bd99469369d8a5b029401d90a4c7cf37267b4700ddcee31f78bef,
+            0x10f8c20b30622bb769d902fec064d87fe8700497de4c3a32673414603f341f22,
+            0x1a5d44a9d6eb166727f3bad1e4c9e4f20dd9e5c09b8ff1685813e84875f7c267,
+            0x285812d1f7e9c5652ea549efde3426019405bb080408b01f51ff04af5ca4f7b9,
+            0x17b5d657ca524c4fdcb6421bbf15dceaaec891e7a730177865542a3ec67644b4,
+            0x1512120e54def6119fc731a80ebf8b9aa449a5e6a5654dcb16ee8781b55c40ef,
+            0xce6fd9ff326d991817ed66f0fed93298dc8116c05f09e2144830c07afa25700,
+            0x14c9e544ffe86f310c027522adca6e667dbf138a586e6fa425bf1f2b2114bf80,
+            0x2e8ba8e57fe1c4ea06a941cdd2242c414fcc9a1e645b7e137ce61fc4456dfa25,
+            0x1a1fb2e69ebf43dcb8ac7cf0e6856170be8c62ca1db0f77120d36aade9fae908,
+            0x599e10ddc716d701d5857e23dec1130b5509c3913fffc727ce207783a2acca0,
+            0x2908ace556ff1f368f843e0842ccd0dfaa42a34faf67e0b78de6c47de2b6a036,
+            0x1e80d381cfe184b2f11fe38d64454a6292eff23f524d6fafae34ce150d1b8405,
+            0x32c3b2a8872c39fb3edc92ef95e76fdb6381f829fbfcddef26004da5b5d720e,
+            0xf058306e4f397b7b02a58ddae87d5165f21bb6109be64cd3175097f63d0d402,
+            0x2a978242c551fa8626d0def5ee59675998dd8ff90eeafa7d935b58b8a2d0d1fc,
+            0x2c646cf8d9ed14746f8a2a438cdfc86b70fa1c31033d4afd8694a7363d1ca0b1,
+            0x1cc7d59c756a8e93071f95f1eb8a5cbc2aeea366715432873be8f94e3f9c8733,
+            0xd09d0e6b64757bdfd7128d041c430b0d21a80a3792d0674f0028872c14fd8eb,
+            0xc28d39d145cb8b6afe18576403080ed19451473b578949a491a095b6a19d082,
+            0x22a2a85f132915aa09898077bcbd76e572e4340d8085708eefaabecc37ceca1d,
+            0x1ad68c4e148a6c6197fdd9fa2c45f8c6f3111ddac52db08bd2ae77860e203a6d,
+            0x19b59a4eb2398896e27a0e670529fbf4b72c3953a82c2bba9541a52186cf7477,
+            0x1e3aeed61e3a7bc6dbf7674f8002a59ee28d3d5d51abbeb5d850dbb3af50559d,
+            0x237d14fe10cc10d41cf7b9545c5dacd245207725227ee5d5578a3cd163c4c161,
+            0x7a561b03c03a856f5d7b15e895448401a8a4ddf1de311b51663640c81cf44c0,
+            0x20e3c12021f53fc206893985647a3ddd64fb1660257a4b9d7d33fba8be729a1a,
+            0x11cfdd5386f9ddf36e9e1a271c0a8565e03aa7e427c624c5050dbeab40b10b65,
+            0x97b90f7016668c55385a0f101b699d0c924d1556918eb58c9d9a16c7815b3cc,
+            0x23dd4f8205e9cb9e123e27e80f46b8ebfb4554df41528acdbca14166af70a8b1,
+            0x2004cf48392d1d3492069d0b20c5ea636c7de4704668bae0400f32d0678b5f90,
+            0x10efba7ebb220de9af4af5b3d2cf4e3a463d6f61b3a51b190b392897922b15ae,
+            0x26ca8fa32860470e9ba95f2b328f45b6d3aea8c6694f52f7b2b6139b31f0e659,
+            0x2e7a6096889e932c3bbdc1234b042946ca8dbc3bd9d42894e227abe994b3954c,
+            0x2b2a5b222000c7485717e5134d31d966d01094d20142ce0be0ed5bcd238fa4fc,
+            0x5d252566db243c26ceed95719ff4e6b2db926a82a90af66c3913457724d688b,
+            0x3016d7a342ccaefff833834f8c85e4cdde502f4cfd2e5e67a434ceea8e7e8734,
+            0x22e4a5742720cc545f5a8b5ec81fc76c856674c2956c74e93d09da15b9ea85da,
+            0x158c039583d91471651b425b67a9c428746b7d2ff4d3f9c7805cd097252882b0,
+            0x2e2b9193aee7573ba18105d36d5452636f0a4a23f6bb808dd7b8351b3104288c,
+            0x15288eeec077977863bbecc27af0e88653434f9db50041bc64cae3a4ab0267d6,
+            0x294ac3d23fadc39ffde4fc51c231fcb1e9043d207384a51281ec6993806fcbc3,
+            0xc994f0154a6042df030cfcb8775ea9baf8790d101fb004f7921bdefee4dd,
+            0x23be197c83df334c3818a4eb54f3755fba5ad61c6ca408d6fcaee753a2e449e2,
+            0xabe4f60f5710062df7838a25e613eec5c7c500292cfcdd88c4b104f92e66dcf,
+            0x22d9eea2ce981be68d03a627a1ac38ae17393b42fd589e8492df86bd03f69ba5,
+            0x17fd7f4e675f456e77902bd68da43d7a0cc8ba75075bdec73800b670faef2c81,
+            0x3cbf13917d8f6962b85bd9b1b475e083a9a6503290264d732bc7045eb4c0e7a,
+            0x13e3842e78b6be3414c29bd5528593673bcf7a071c9e547d4a6a8e8c1f29f43c,
+            0x2638bcc34e7ec977e6205a356d8073edaeb37d6d0cb2ee15ccc657e00884f71,
+            0x1824a36f9b33cd88b29d9d56794c02f0498c8c3520cfeb8d7d23df01dd11bcb8,
+            0x2f64d3e9e9660efd747a28a181719770cb89acc868f1db0b42a0d41424d5b97c,
+            0x27e976b95c1db0a431cc63d2bcb77b7420eab7240caafbd4f6ed94b771d7ee20,
+            0x71017cf059038a6f1ad9223c843e6f687774a7b677edb7d7dd6d4d8aaddff,
+            0x263e1eb69b7b2c87f3d9f4d492100367041a00cc20091402d6bf495d74deeba5,
+            0x1dbd8f7a790ee4fb6123d8162e879b6d334e137c224da75baf9b00dbd5b14a27,
+            0x1df0f444008cdfef43484dc04f5fdd1694d6c90e8f2e35a1850831879d9d7a2b,
+            0x2ac29049462ba770408914036f0fc449f4ac15c4a5c16768e95e2486c62da8b9,
+            0xafee4216cde441ab47db90ffdadb12b08978ac6f623f3acde4d4f9d8c77f3a8,
+            0x1f5df5e1d3372dcbc83d7072bfbf2ba8914024e3398ebbc3461403d39a1e9895,
+            0x11c09f4be4433544bb604db662a722bb16824fd85c484c45bf25dfa5ea9732e,
+            0x111ea5feb756eb07f942b5fb23849db24d1065b278b4643d55311c0672cff942,
+            0xab7c194763587f1dc30e0ed53aeb6eeb6036acd702bbec9509d649a81f940bf,
+            0x282c5951f988191603f9dd07759a4f653f19976943d20e30d4c0f8faba0daa05,
+            0x23b82721a7cdaac2a39f7b4bd10176e50983f32cfda8bab88ea746ebd4d25ee5,
+            0xbafc22c31e735870dfad91a56a46ebbad29b29e531649c85bf79c8dc91c792a,
+            0x24710e9cd9f6f42f71cc8815934ce87ca0d677facf1f3d89a9abc2da898f9687,
+            0x2475ccab50e2c13fb5d772a07571e0e6be551a55e250e44f22adf1c7a4d7ede8,
+            0x17326fde68e193e4a31782f2acecd7a468493aa94d63833575ae5184e9ba2441,
+            0x1d044be025c79f610d4009ee0a3f3b50dc556e785718d196e67c60fcda498459,
+            0xbc38517b0bedb66a044e38b1c199d110fa36adfa1251d46e635f22ce8fb3b61,
+            0x218a7ed7b5b4e39d21cbd4ecdf0d4f31308cc205583a9ef6d91ed6969b45c27,
+            0x70989c23efe1c0d6089f9bf987be86854b4bf5aa88b37dda3b4fbdddb068f36,
+            0x11f0a1f2d5894630701027346163a4c6974023d321780e91c8df5e91ea930c7b,
+            0x9070202bd144c45ab704c72dcc40a5566cbfd5826f7af4746b4472b1e68c390,
+            0x243392fe4cd6ca6b6747596c387450ce6a1ae7b0a90eba222c3470d8a80138f7,
+            0x1a94265093ab44062e5d0e67df9f4b702df8de8dfadcac6cb4229681117a5da9,
+            0x1ab31ce49e37f690baf9ec7b1443357cd24d7bad16a9e6e95e43b6564d987b1c,
+            0x2179ceef0feee3b0b03c9658e97b6342f25b208d7ed8e526150fc3b559128c5f
+        ],
+        [
+            [
+                0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+                0x9813c803ff84a3694eedaf4b1c2172615275dc18ca654c799a70440946ccf0,
+                0x202973f7fba5bd21ed58bfe7156d7b29010d41090f63f1bb290c1d5da1ad60,
+                0x12305eadf64dac24a7913a62d95aefd45f48355576c671e56fde9cc7c8344ffd,
+                0x25c783ad66d6a1fc6c84770bd637f6207097dffb0378d7e0395f8c0b86b505f9,
+                0x222deb606f13cf28c73a67216d88b16f5958d5d292ba10ef3bc2c10f5a0b613f,
+                0x1614d025472771fd870a9e9d422b3571c5494e7d679824d8fe1212177d5fa2ec,
+                0x1358bdd6b7a51b1f5b5d094dbd8ee086ccdcfb9c27faad0806e8ef718d0e2b1,
+                0x1c2007eba4d1629846bb69404acc84565de5d24620f75cfcd9f11feeeb3f3748,
+                0x22f49d7244077e41f409c0b353afd1696e3aa15ffdb4a0bdb883ffe7a1a87217,
+                0x1951523a4270c54403dfe3218fd3d4ccefa43114f1b19fb2c2821a4374718b9d
+            ],
+            [
+                0x11a131a3778c3774233bc54096419d463d3abbae18322a7e77a511881665f93,
+                0x1495af03dc9180c886f0e1bdaf9d18e32e6b0d1b80370e7cbe5745dafc433523,
+                0x119344c53707f00243983c6d024fd49a0f8af80e5871933e58ff87c3a1f48b93,
+                0xa92bd6a919d1605615786f2efe80743ca57c10ec80cfb926722b5bed408b79,
+                0x1c7d3a92caa435cdd974520bb6fb6cac81634cc9bf4e534df77736e06d768c3c,
+                0x12fb88a0f6f749d68da9250d5adecf088442827248d67f989fd14b5c9cd4d4c7,
+                0x2f6c4e097bb5851be12bbe2c712c2fa906f310b78048d695b4aad301ffc0d268,
+                0x1c06c782fbc0980b9e493b29a5e4a04aefc668cd4255d6cfe208e9e7c8b9a1c4,
+                0x211865b7f9c1c791a33d703ad3280f69756324349afc8912a19b83de2cd06a0c,
+                0x25542e07c1c13979bb14f8d4ee93dab7a3dc750806cf37f2c02ff53b4bb9e66d,
+                0x12b5a09e1e95e0d01fbcd234fad473d8ee2ba976fa22827ffa6dd03c8b25a64f
+            ],
+            [
+                0x2a18ab4dc4777e13cb8358c1c423153570d1cb909544243abdacd4547c8ec3aa,
+                0xd95e8cf8a66b56c32e7d11e0107e41e1297122d1acc41332f1b49895a3c97fc,
+                0x7c22f96f2f55653d04edc63150567a7a04609b0b79eecfacb1485dceb7bc873,
+                0xf716c54de41920c401a62df8f9186e19b9523e98637a5b113d61ccc30ba0213,
+                0x2cd68fc31b67dc45fb6b16f42b5eb89dba2ae7e9aa50c5f1915275a81887190a,
+                0x66292e64e6a2c64673aed365cb50f7bd4e1d3b5270f6b2e9982590c3f8400e,
+                0x8a1ef65f52128eb3b22df2b6aca30509b0af8af2f7888eee766c0c24871188b,
+                0x24529638ebcdf26de8816287fec6370614e112e10c039190c103a75ced11b426,
+                0x12e4b5408f48641951739ea27e521067240b82aa51a42de2d4dc1e8225908187,
+                0x84b88b1ce4598b701cf96a3379a02a3157d4193c8a8f1157459f6a34ec32fb,
+                0x2c184e904d7bfd368d4495b9e3027f9af6b9313c8f193f929ac9e24d10d7a36f
+            ],
+            [
+                0x16ebd782cbcf6d63c38b87b27db2a4a5af5847a9a60889c4cf6aa318d6866b1e,
+                0xb05f16108c4616a973b01d82e50d4fc9dcdcce67d2d21f852816bd234e9872b,
+                0x2f394cfd3e442503c3a22512aa4b76b95b743c7076ca4115a9fbbb7c6b07ee5d,
+                0xa157e244f939125d57f9c8e66f7d88ec0fb3c05b90f526bac0871bca84677f5,
+                0x1d4567c12db648d4a9c41324c0329325b76a07730fad72ef9e490a748674985c,
+                0xa94a2d7c4093c638823b095733f37176d7e747ba24645b515ac2a241ffdda81,
+                0x2f6f14502f20d958a9ff23b696cac3ae24967517ae8b2e9592daf451840bb98e,
+                0x12641cc3cf50ca67bc93bc8c19ed89d4613e9e281a51cdf313cbc8111922242c,
+                0x2185c7a4ad8cb21f19009396f134a2c3fd614d305e475ddd19f26f6d4b3f9ce,
+                0x2f6da385450911cd272e13601e7ce66c2b91d809307492f7ee578ae34d6f5fb4,
+                0x16fc48e55d64d83010ad573377ea2422397fc3a7e6c88af808a566de0223f0c0
+            ],
+            [
+                0x2b7ed47fac275d34f842f09b01ef9421014de040c26a591595b227ba7bc6fb2,
+                0x230b62315b30bc49d73dff8a9de79c620e03c747b14c432f170715e588d605aa,
+                0x206351750037bdc90d4f3e7918619fc690c2b5857f8bfbd86d7c001e4cf2ca18,
+                0x2218be861d524eaf03b9420b1368e9c5aa7cefee72d0e6ef80732ee9d7e6e2c0,
+                0x69ee4eb20b4860d4af91afe1781338f53aa354562ecd873e0e625af70746f26,
+                0xa226128da1d9bd5b329f55f52c75682def3369ab13359dcb7d212eefca86229,
+                0x17ceb42a19de6dd32e3b38cc2990e64273b52a5618263eebfa49d84518ea3bef,
+                0x29012deffb112eb14034159c59162f866d4a1803b4d192a4329359f0f903266f,
+                0x9c4b2f61adf245266168cc918e96f7f8dfc35bd3df7b23fc641ef01bcc71cce,
+                0x1802b97e54bf3a8978632cbe10e429705b03680325d26ea190c0f1ebc7362ea3,
+                0x2db1ac4c2b1c23a00027fdcf0f663af896d87415bb035b149d28ad3da98c6fcc
+            ],
+            [
+                0xc5e49e319fb9535073f07f9e055accaf3e3f24a35dcb46cab67dfc648efaf30,
+                0x15d217a31784741048f326e155af96e90b5aae734f06779e698864039c92e123,
+                0x1accea09c2bfd17f4061725c712fd1976a07e773e54d906da166215201a58136,
+                0x2f9bd19d0c8c3887a7fc0173f863f075e66b183ad89f13704930416e1d5cb7ec,
+                0x6cad0c2bd438c4dba2ed64bbf75066e731484c36d1f6738b6e98601e9fb498d,
+                0x1b5da83966361586e8810fed032435caa80a9b476db21290474ed1977fcef22f,
+                0x2adbde5c7b73e9a7e22b913f99e40d95e689c65c428c2397cd273923cf68ddbd,
+                0x1a8b8ad1ecb6cb888273a90bef8b1a2cfc03dd44e0b28b18e1074e404a9e0f4c,
+                0x281eca14bbc3920919e001150451c3e44ff18e1dd1171412ff5e663d74a073c1,
+                0x54cc81c7d1d59581ebcd26b16ccbdcbf1968d77f87a2081d13054f51118f7c,
+                0x170c05a5f8a55d5c9fdc5e8238b367be358917a19a28b4c47e46f3e73d42a085
+            ],
+            [
+                0x161e4ae5b2d24cd638ba5c32bc2317bf90d404e37e003f1055d9a96e406d30d,
+                0xaf9afbecae1761cc17d44b51ca66d1dbdeaf341e85f1082958f9cb72f7b55d4,
+                0x5e52c0ff8c04a8e5e3c7eafa1d0902fe63e35898934b00f4333b38fe614f913,
+                0x14eb401c1084a9ddcd5d0092e5d1a299aa0f55c351545c781703c01ce87d6b29,
+                0x1e0e166d734aa614c6b53db4f691179841a33f8105430a3ee70abca83ba6ec6e,
+                0x2fa75deed281db734faba5b70eaf57962f93e2eea1d3dcee34c81ab1e9fcc0ee,
+                0x14bfe33115df293670393e1dc8da4d6947acc4b60249e5b1c8cae376665cd580,
+                0x17ea198f3ab261da000152f26b0eb0ebe088a709e8b06a18a3dc2108c2096864,
+                0x533e8a454b8cd6df8d48fa9b0a9cb2952933e1a6b1d423cbc54d0533a72599b,
+                0x19681b4242d11e28aa72530cf33a7d15719f1a888fff625e04652c77ee2b2de3,
+                0x1eb7f6e5520215c15e274355b19bbf71abbf04aa426cd07da536cb3f909f6e57
+            ],
+            [
+                0x223c7fc6d24fc53d1b428edb8f1c52d20ceec592187d2c7a6b0b147b6292b81e,
+                0x1da4f4e3c6790ae1b89c4118861d8ca2a50cc82a4e7f1ed3c5ba8cb944ba4689,
+                0x2e708baaf894bc5835e5fea81227fa8cfaef99086d12b0a3a7f3f85bbca61d28,
+                0x13fe23be24261ba5b92d363989f58e17fceed4a858d1c61fc2cf2b71dbdb6936,
+                0x1c879c9428e19607d647f5ef1415e76f7c59fd01e52afb80486081851f9a5284,
+                0x128cb3150b15cbc4faab14bf7d676ef3682b52cabfc8d3419dfd98109d19ecc0,
+                0x2bf523cd8aa3be20ce7d891f8727a7b24b72a4d4838484de842acc782fd8bd32,
+                0x45aaa99ce1e06a3c02150804a91087f57a43b79797773e83216ca969e873380,
+                0x284ccf70859547fcb9c3c7b64cf0ad62e51726ec81b58eb01c1a1f8ec7a9eb70,
+                0x1abfe4b1cf5db29d4078e5289bb143498abbbdc9af56720470a26a3dfa2ba855,
+                0x14111a74bd24730c833699eb41b38f1d4ed16fcf0fecc1655b76f2437d4a0c9a
+            ],
+            [
+                0x1ae060e39b338d09845e2e9ebeb70bfb74cd4af926217f5732be2b6cb7fe72a6,
+                0x2860aa52dc2f967c0c1a0b942ac81e02189d031430c11a919a5aa895bcfb6151,
+                0xac23f00ff015baab1c8be9a90943c3c72d17818be7ad427c45eb3ff1828727d,
+                0x32fa2f166622f057f61a9405c9256223cab2ba82c9495607921755ab018f690,
+                0x215c0cd4e3f1bdb482b93e571879d7931be90023d7a220e8f93b21c8add41ffa,
+                0x52700b19ef6d42ea392e044a094cbfc308eea1f72f2a3428b1e721bfc32c6ad,
+                0x33b93a5cf15ffbafa2726f2527824a11af8e42e01d3a7ee159b273ca0a6520c,
+                0x254e3acdbc75ac592679b032b65a9c91d2e092ab5e5719551b5da635b13e9471,
+                0x4fa5620a2c057dc552a59fdefe50a901068190fdc3df8761991cab50a01a449,
+                0x1d2279673f6cabf0a1c4b8eebf8e9c78361680b2e59d7ec19348819f5b3d5a14,
+                0x2d46b48e5090c0c56a390de373f4c9a2008db311fe31063cf4fed54629113585
+            ],
+            [
+                0x46191ab41e93929ea51f190fd4e773ac8d5083328d4b2f04828dca3e69098c3,
+                0x16ff33d67c85121bcee7d81cff1618927f1c92b4d1d21c2a07b6ae18b2b7b9b7,
+                0x2134798f4ca7fb9928012c937f37de87432b8665aeedf373e7ffa6fe0c13d00,
+                0x2aeddbfa245756ad1e1658629f747b8da7593b195cc950324f95edc9eda42aaf,
+                0x1f41fc67ca1322b37b7aa01b631fd19105281f6c6a4d37fbf68fc1b5f62802c6,
+                0x22d1e64d4ee15e60c459d851ef9f3495e937f5a90990382c97867c45b7940071,
+                0x249f416fae5ab52a435d65201006dd8ae8d54266e4d5643307551902423f7cc6,
+                0x12a996abc8577021ac7880c16f058d9e06e9511187f0aadff6bb640e4316d26c,
+                0x2d2640a74ede9af6c9888e5f68a84fac92b13337dad8fc6152fab34b55419908,
+                0xf246d2fbb4e1217f09631fbc8770827c36751e6ad8d6fb16810e3395143ad80,
+                0x15f30ebdfb8b8ee644241039a26b408dc7a8de77f2cc6fed754b703ea92dde53
+            ],
+            [
+                0x14ba1b5383e3733c63d00c32c2bbffd8e54507ed33bf7544c86388191eca3e40,
+                0x1ba0e835f47626b0d82426900c49170a8be29c39d90337aa5fc10764e2321a1b,
+                0x219f5e28a5fa52689d2b7be432624280c940c9bf9883c1fb0fe929f78873c1b,
+                0x123a6055681023b16570c70fcdf3ae8e387a973690b9e6761be22f9941d7ef76,
+                0x1dce36062af7e4b0098f5590622ced7af9f28e88d476cde1391eb30408d5d266,
+                0x252e74746677fd7584ceb0f8aa6936bd04f9528ef600737e9913fe4b5698eb28,
+                0x19a9079a9897a237074252767912bed7b7635ae8ca0ede2dd3a42a75c1c6b81a,
+                0x777edef4d91520fcd490a22dc569a97e540a0fdb527b4b1a3a854fe346b8e7f,
+                0x121a3764269fd35cdf1e621c3dc6318f47b862380ba00357849d8840059463ee,
+                0x2f80ca151b077b50767281ea5d4c1f7457f8da444dda16d8149bb6c1061ed0aa,
+                0x1ee950c45a0c2f4a4b64688a7935ed2b63d4fe5b414afa05c1a284674409f165
+            ]
+        ],
+        [
+[
+0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+0x254a28279a58c838f7392034aa21d51ae44e1449433d90824b817e44b90cd22b,
+0x281d2ccd521bc060d152223d46196f27b048f33ce6ffbbbb0884f3d5c64a6061,
+0x10b388ce0c7860c8a70c4e903e61b3bf97b87e324c9150ce576aade8b2d06a1d,
+0x3ed1d46b39ed65512e3e4c8d53cc1d2cf110cc65e1d65b37f1e5e785a6fe6e0,
+0xbbac4700573f9573a123ac6a2735b63c48df92a7c91cfd1e88186a061a102d6,
+0x4083e23f948783c32f671cad0395794a2cfa8aa1c1cb6a0c0105590904b2593,
+0x1fa80347e1bb24e08599758c895a5a13fbc63df14dd9063f5ee23e5cac163b61,
+0x1e465c7a4b123984937605aa07cb8cb830591e22e25b4d94d2efef2f25c17f3e,
+0x125febe3a720ed956f1fdf75648260e56e67d32d0e785788d1cf97ef61f6ff69,
+0xa3e7d3671a213b3184ac44ea74e12085cf5380c688ad23e8300e69333c123a7
+],
+[
+0x11a131a3778c3774233bc54096419d463d3abbae18322a7e77a511881665f93,
+0x11f3eefe7629e655ea90af7061b775bdffbf26dfcb0f67a5578774e4b237376d,
+0x11f896a08f039c3fe481a03e0b8c880edbf71b783d169f4bff14bed5e1b5f15,
+0x127270ce679a10a9b93645264ed270d96f109e3f65a437240d629e59eff1b2cd,
+0xe81abedbcf77d0706b6a4a7438b5a9c42257b1233f0426225c8d410de5806f5,
+0x1bd40e4b13c0eb7bac78d2650586a59f28b7ee26be01fa2a677e734078bdc210,
+0x22202ee3e2df678269ac3833b87fd279d1d045fc42eb3ae75107188ad0e39bc5,
+0x196301b7681fd2882ee086f61a83db475a030017f92f72dcf3ebeaedbc571520,
+0xcb517d9337709a54dd958c64afc6c8ad84fca2f59fe3098f74a7537debe0d2e,
+0xd9be42ce8bb76bd249d36ba2d8c5a70b52d20c9c8686b7cfe346d5c72bdc15a,
+0x2240e2f64b6f5bacdb2d6aa0b444887a91d1ce0eb1bbcbdd58ea71499b7a85d5
+],
+[
+0x2a18ab4dc4777e13cb8358c1c423153570d1cb909544243abdacd4547c8ec3aa,
+0x1f19f9b9169b49713bfbe59154cd93aac19d03b4668733473fefac6eceaf9a63,
+0x1e6425bea9db8ee466777ec75d3103cd11ad6ed24283a0b188b5aade7d496cd4,
+0x22e2d64bc44841b96bb9286970439150d70c55f8d65fa79f1a4ab34befdf3c15,
+0x22ea712a97059dfd8af604c752e478b8d883333e6749b2ace5385f0ba8697f67,
+0xc19fc53d6d946af3d7fb79d8f22c46df2e1b0d0f2cfc983345db3287c44853e,
+0x177800e892cde6dcf66dcb1c337b6f7f6f6cdb54dbe7e2e2776abbfda1fc67af,
+0x133f706a099e95021e46b79e7f0fffdb210d87a4db1d129bd6fa5f62113cee23,
+0x2c540ac453bc95fb61ad879a56126d5fec7ed9300d545938bcd80c2feee7a3e7,
+0x2575061c9a069654a195fe41554ac0f4080dc8f7e808d676f3f33c615978d593,
+0x283d7487aa3b5d0ede9c741fe754882776708f9bf68c745abdd38250ce70c288
+],
+[
+0x16ebd782cbcf6d63c38b87b27db2a4a5af5847a9a60889c4cf6aa318d6866b1e,
+0x15b3fe328216827e93598e15425979e9dc4d9b9ab421f25aee3e49bc6067d6bc,
+0x11cb96a094be409eca05bc42f6d8ad0f6cf09cef2b286fe5945d587cc36862ea,
+0x1e5c6cea55983c991761cf70ca77fc17c3789a8023d2752554b49d0b8fd1be7f,
+0x257d458a2883c760b295e5b2789e6a942b8d50fa6fd3eb093a96ab81a9aa693d,
+0x4603c35c98c1e379b235724bb309885e9b56284a6cdb1cd0d3953270109bed7,
+0x1b2957f0c085f578b4a1b58a21143c551e5451ec46b9fbf6ffdd0cf6e586a00a,
+0x17bbaa8b0ea832469bf933ec6ee5941a1bf97f0b7b1f6b0ce3f708d43795365,
+0xca0c774b1bd1c2b00fe8f6698cb08022e4a3fcecf13d79953485c905b76f8a7,
+0x1b0265724a00dfdba001c87dcd71e5c04736a61821b19f30e02a4b53eb59a12c,
+0x29ddc736b1d7fdce1bf6a2f684702703e857b3be81599e485932a1c03f4fa16d
+],
+[
+0x2b7ed47fac275d34f842f09b01ef9421014de040c26a591595b227ba7bc6fb2,
+0x15a1af15f1f7a77a5e6e760470e7b7cc4da48f3fd35b1b01f019384381e37135,
+0x15810baa26cba809c29275debafe2859cf2350199af232bf920496c5315947a1,
+0xa1c89983188b5230102c213ce35a9fa49743c5490356fa305a8578c716f7202,
+0x2a9243c6a61b2b7464f22e1603009e6b6f7946f31cb71cfd4d291601458ec39e,
+0x14b216d879b61949c8bb2ff6d43bc7fc3c634a90b766f2276b0a5c6b09938cb2,
+0x2b2b79db9b5bdc6a1844c4e5c7f33806d44ad8644fa0117f5bbfd7183754bafc,
+0x20f56843ab66f86615274f77030d662e1f6cec212015e14896139ff6d28116d5,
+0xf2a31d4612576ccc0cb003c57ad2db723008007b066054d114a9ae32d8e604e,
+0x1a265ab962a3796d2cb4ee2980ff3bcfa03e8d6738d59c8cfb899cb771f9a61f,
+0x5f7ca424f02338e81927a8928c0f02fc78eb1d1a08c3bfb8965cc7b43d8e056
+],
+[
+0xc5e49e319fb9535073f07f9e055accaf3e3f24a35dcb46cab67dfc648efaf30,
+0x1d22b55a0b71329ee03adbd79c0a1e7d32efc4d765e6e581ecb349e2940f394b,
+0x825a6da8cf0213b181fba494995ef1fedf1d867f8c777ddb93d10b64f1f3bac,
+0x189642d90074b6ef89e102eefefd69d4d69e106cc6d77281b971315feca3f6c4,
+0x1976bffe10562085862cc586a3cbff8d260055e1ca382a74332328c0eacecaf6,
+0x25195d63f3bc30c2896cafcbcca1f5b73ef4b74929359594e4421c7c9a1c8f8d,
+0x1f523a01526f1b783c2e3760a4e7e9ccf8ade4e32b56002d15baee4eb794465a,
+0x17cb6777e65329e7c510142a85cf3781ba33de3ceb98a4ba021d783d212e7492,
+0x1308c2b9ba44163ab7190c4c151c7f44f2e19eb186dc82a2443446972d667ec2,
+0x3006fd98ea0d9db2b33144f885e201534edcf4c3ba6e96d8a22db2bcfe8ced48,
+0x14f241ecdcca69b025108efd0fbf00ed34448e7bd804d5e85a835619791468a4
+],
+[
+0x161e4ae5b2d24cd638ba5c32bc2317bf90d404e37e003f1055d9a96e406d30d,
+0x2b04ed9f42228f06802c0b537dd014217f3c444670a0c6f88b3b5ce001b0197b,
+0xda48eb83004661d01df489e8156b75d9b661c61a9ee1329fad03ef74521def7,
+0x1ba1cb5df0f9b236e9f7c4f637dd1e70784a2b07f8e062088b72c3a392d44b2d,
+0x2c22be8e5b7f7c91490c46c27a09e91872e361c1e6628793b9674569ab3c0b1f,
+0x83511f996c9f415dbe56786f78ec97fd8c84f5d4ffbda454b3c4d5901ec92a6,
+0xc3e13ba070756735522097a41a9138f5a44cb5856648daf70bca100d2346b1a,
+0xb14339306b1b2e3114e50b0607215d3f92ba684690d78d2a6ee417a73933c65,
+0x25c2045be7d9a915562c78bc1ea2d954155a0289f900c757b7138596edd9db6b,
+0x1b909b20dd52d51184b58d123962b7fb22cbe54881117270d279402c4056dc39,
+0x1afef8497500f3d89345974c67a21f1e18fa930f7d78a1ca691bde258c5e2c7e
+],
+[
+0x223c7fc6d24fc53d1b428edb8f1c52d20ceec592187d2c7a6b0b147b6292b81e,
+0x8bd608629b132b0d741a305ba0002b9ec1470499f5c0ae88e26f269ef00320f,
+0x238b46140eeecb9a32c7289626b692dce13cd51bc3812f1b0d866945c0e08e41,
+0xa5ca2631a8379a163fd40936e6913afa60c1850b9e04b622f2b6e109d179ecf,
+0x1656737ceb63a2d43d462ffd902804d11283820356001961f1239a1e7cd23108,
+0x168df74339cc5c612553d91ce34b44f60123aa40e8486e3177cef84844529bfe,
+0x1d1cea63939b21940f784f77c0f79ed523beb6df5432911930878b59f92c7f63,
+0xa2768ee0edf0b7e5e69a734e4de8129136b926e5ad1891e6cf57a5c39a14da6,
+0x22c57e5689822b5d931e748dec46c5e64c04067f579d96b89b608ab5eb5a1e38,
+0x1d4ee90cc3cedbb9973609382c57bbb1b7629fc5398ba62e2f8f7a9c55496ca6,
+0xf9c70d6ee5ba237f04597a71278dba03151a3efcc594cfe61ddf16b5cf1722c
+],
+[
+0x1ae060e39b338d09845e2e9ebeb70bfb74cd4af926217f5732be2b6cb7fe72a6,
+0x81e512179c27b63294fdc958ac35b91ca61cb3fcdbe4e661ce465eb3b060adb,
+0x64bd952087ea3f724ecaab7ab891c7164148247b3d9534508559f290ab2c455,
+0xf48a6aba18109eb41509d160d2b6e2bb75b73f2d360b142e2253e99285a613d,
+0x2144765053902fbc1577578eccf3fc1990cffbc464b8d5955e387653e427eca0,
+0x149178f36e2a8348229d4e5f829a53620864b7f8c3829adb1ce2f4f8f6198a95,
+0x9e651e10ec1fe98ba2bd23aa05696c4bc5acd233717b7069069a206301f7e16,
+0x2f995fb2fe9a457e970030416b7811a93b31b3f2ed7c7300034cf958575b3ef,
+0x98eccc1107806d905139f5aad87c4dfe9ff0d1eecc1de30e8c6a4cea8c51dcf,
+0x1720f40d61fac0f66408099bb1e34e3a48b29ad05b8910a7bc257e01de20dbe5,
+0x18fce50e6f51644e0968c44adeda32e68bc24c25e81ec37ce5e8771383cb76e6
+],
+[
+0x46191ab41e93929ea51f190fd4e773ac8d5083328d4b2f04828dca3e69098c3,
+0x662f21223a41d37668404a75b278b868ab602e313e8c423798b47c47f1f56ab,
+0xebaf002ad31782757a58dca1b295b2e0ec0ff3115a8c931ebf74fddcfb734cd,
+0x1e1567bb8636626357515a40b0d5ebeb351422e19acc9bb5b7edfda91649841c,
+0xfdceb3ae2d8a55f07822d7b92026ef83ee8bc326e3a8b35225d587bdde25205,
+0x130e0c983de0ad6d15d8770698e39fa4569f38848ee05757951cfefa1f338fd,
+0x2f7be21619fd5f7c05e31d90607acc55e36fcb5b6c55f970170e660f2d818fed,
+0x5338e9847d4e29692f22f938875dcc5610464d7393c6d87dd799bb3bbf810da,
+0xdc0a5c9bf0d5b38785df58fb22ede06709eac85f230639056bbf1333b9a2d21,
+0x10ce79d030bc12a43f0b6fff0d884c15c263113b3a6ce3b24318f0a60164f6a7,
+0x232926077aaf9a6e42e885290c6ad736f29cedc9b0ed5c5a0530e405d57756b3
+],
+[
+0x14ba1b5383e3733c63d00c32c2bbffd8e54507ed33bf7544c86388191eca3e40,
+0xdeb781e30eced913c20323aa3f86be585d4cce7f556abd2c2a0815bde87b775,
+0xa877d868ac293ccec0f559d48e3dced60c81fef80ddffc8f70905664b3bc0f,
+0x1d635d1267a513c78be7288e584254f53012b3f7955147ec7153532760c6c9d5,
+0x120a95649ccf899fc3a8048ec4adb59a84d3ff5c292328f6cf32ee0c14d8227a,
+0xbcf6e6daea072a539fa1030a61bd0c6f425e9982286ee468ae2ab7bf1b8d114,
+0x1c4a6464c867d43eb5fdce8a731867e1b9730ab208fbe77bc9ca7ca010a74192,
+0x562e63099a7630323f701d2fa312c654a891e682a7e0925429c0321f6155621,
+0x1bb2aca445944760eb02e57360e6d3fae93056dc357ff0dd8882d08983be3325,
+0x210f17a9d928eb4f42cc8dbf8d6a7865ab53bd038180c9a1c9a506a2dbb0602a,
+0x277425a5970de392ade13f6ee3752600050830d3bbea3566438924ad5159df4a
+]
+],
+        [
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x239bbee0bd0536587314f5429186856d92bf093cb902a7513b11373dbcbf7134,
+            0xac0bca8c1a15d53ce77475eaa398fc316f791caa305403407056f9b14f47f64,
+            0x11ad8281442fceb40a4c536b728ee79730be6407d603333ba18ef5b7492cdd13,
+            0x2927ae7db23955f84264264e7dc4f4015b070620841d9035f54c501d0d4975b1,
+            0xd9455f3c59c9ea9302e721c00003feb40ec8231463b84c2d66c403cb9110dd2,
+            0x14d50f175c19900cae3eac1f457e2e02218929f5c6548a6e601f3038240df458,
+            0x237b9200970d84323901b9d7a12626a3d828affd132d9ac43ae01d5ac3cf618c,
+            0x19d66d04ca7851e0cbaccbe73156524606cba6bd174d94bb79d3fd99da05a2e,
+            0x2ca5d1e4cd8007c2a6e745ce9d3581c2661d28ebcf7b723bfafdea4a97004061,
+            0xd54ce53ed8160546c3555b48c6dc1a95bfc11a529d863ef3d6d63f3799fd407,
+            0x2c21c6df9e87d0942740cfed6b692c5e4868b781085a292f505a9f53e2969b94,
+            0x6351ae4eccfe35f6fa2f0e50faf512ebf3bdc02a9b61fc2baad2e18c4c7e128,
+            0x1c86e871f69f568ec2e47ce015f7b324c6833ab9fbfa2013173857efc040f95b,
+            0x2175813936c314627ae23d64f217d0725097891f1b1cefeae407bbcddeee09b8,
+            0x2ec44113a689ea96c746225258ebf92460b065c25e979e5bffbf0f8590315eaa,
+            0x2facae956086465c460b678df8d1a10bc8256e85fe5a3dba26ba637f3d4eeb94,
+            0x1865d5f9b9b920317a5751591a3275d233aff5b7f6e6ca7c0f6b2e3f1ea0184a,
+            0x412169c5bd61a200567219a93b8df6b4391fe1da096b22755680536a2173411,
+            0xbef9d4f49681702d6176c94ef8563f7d1cd1556ef5adf986cd9dd6402456513,
+            0x10c7e674a66fb25905751a9f355309c0a6b4a622b7c3b29e93c61f64d95d881b,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1934288830ec4d6ef05046f36c7e664fc0790fe76e390dae265502624f3e6764,
+            0x21fe8f4f8f4fa08615bad7638ab88a92cf8f0a6f9e3e695f3458a459fabf9a8d,
+            0x4e0a4f483d51dd00d1062226b3266d95da5866968c6abdb721d96f8f7e2bb1a,
+            0x2d3806f1ea209c26c7b3fa95f40e8d213829e28811223aeffe523cddb5246ea1,
+            0x5f7a9f8fbc8104008bcca318850c76b19c624671782c0104a04b1b03c16d792,
+            0x1c429b4f17c25e0c73fca45ee8f69e5afff9bbc21b4648ec497276a7366568c0,
+            0x2a5f492892b38ae10a0615eec76d2f514c9f3251000383d1d1e13a90a9dfe059,
+            0x1eb8bd92044de59e84b8ff7e28347243a0cf0a665dc38be0a809245cf2632846,
+            0x65ee5b5e74d35c9e411443393e2462959a11fb9fc95bc1b627cd0f48429837c,
+            0x10829a880633680e7078e1fe50cbbb362a20d7a313647297a99dbdf6578bbe84,
+            0xa83ccb34dc841eb9cc8d2974f083c61a9d9f162d6169db459e0544be9935d3f,
+            0xf8f126cb3833ae566d7020e8bba5f7ee02525d4378d81d36730f97ddd2c358f,
+            0x2783557cf3c6a0b59926f5804752bfd7de101c1e831a4ad421b12d2ec9f7bf24,
+            0x91f200acb6c0436b64c4425917f2fa4c6373133a25ca40a19a28cfda9b219fc,
+            0x1e4a28170c7a5034f70a700fad1088648e97a11fb4856e22a5239385099caaf2,
+            0x29d63ae313de07d1dc59205c4b29f8b95baaf7efeface383982252f1173dfd2,
+            0x188a2d62c5e3519664418fefd0fd0f214b101577643ef5674cb5e5e4d69bb7ff,
+            0x230324a35fb7ded74a04c7fd4cf7ee0f68cd8851e1e86b5e4c2d9c1857d2dbce,
+            0x27e120b07d441aa2864beace6201c4aee9a06aa4357fd66ef765c6f10b3d3c88,
+            0x2d6a0fac700c78ef54b97bd61d43e88b5215f352dc6806201f3e32ef06a1dfea,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x19214ffdc30bd79894098fd3804b092c50b04ed072d36155e2003204e1628efd,
+            0x2f15bce2fbc19f00682f8ef66ebefd1fc0a67d43e4255f72ff9ceda492c98752,
+            0x215fec7c7c775fbdd3bd2317d73399873ec497b6dfcf434c606dc22603b41b05,
+            0x28965510c52457b2b0d9e49812da55f08028f23ff9764622f2af19ced2eb250,
+            0x2798d59530d1d41a6a311e90c9c37f0bd389a39737394a11829181d1f26c4988,
+            0x11542d205011b400201141b40f0e818051b0a983ae9387786906bfa71cdc1f5,
+            0xbaabe59e61426a7f5ebc2174ac06d27ca7854ddc67e51b8bb9573911387eb31,
+            0x268937a0fa2e75f79c04d9f2aa6cc56ca52f3c34352cee551aff2b99eb953a79,
+            0x1bc3e33a03e620069e915e78112c4b39bb36f9f3ce5d75e9d51624f0beb1528a,
+            0x1bc41b054898379199236443a43315088018c303cfa8760d7f679149ed53d3bf,
+            0x2ee37960ab5cd93080139be75dbf02d205adbc6887e96d278ad3e430a43c59dc,
+            0x1cdde27557fa9f3e2540dfe7deec2ea92d7862361a4a7ada6e4b68f2f3b4e867,
+            0x2215b23457c72fb4df6cb05ebb6e695a02c0c7fee8c1ea4553d130e9ab7c3a25,
+            0x2c0a94bae0c8d81169dc3c1b3efbb544d16fcb0a11b18bcdc68c4b6756c1816,
+            0x9c4335fe7a502889970a7670ee8537837526594d94bee1008d51506b0baab6a,
+            0x1d54c7fab67c393a91a61e0e2e38d5b7ad4e43f646286e64e31704c748ba9db1,
+            0x300b58fb17814ea816d0f7bcd9c3aee0c411ef4281917824180a3547f8f41b73,
+            0x27855ac29fa4b1abf74da38a4ce42de382834c90dceb506eb1f1259823889f0f,
+            0x2259c5da3d87b0a065ffb5a9fd340f8bc3ffc41113b77bbf66a2613a03b04874,
+            0xfe5e47f909ecf12bcfb1e96d2f6a5f96e8e95f7091a921d225fb33bace62388,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2cf624bcc1b57941669693a6ee517fe56dcf7ae5f8dc152456d68cd4c839643f,
+            0x284fc4f8f116661b9dd2690be9979691b33a6af7b521472a36c154c5ecf94b54,
+            0x15f336d2348dd647d17cffa8507990c62d9355d63fb15fb7b7181c0aac883733,
+            0x2b097ff93c8883e63327f4009f9d0ad5518484aecc9ebbe42ab9ff386beb2d09,
+            0x2b0e0d9bb68edcc80f960a98b948c1a172236a4461c5f13d2b7d1fb648d1cbf,
+            0x21fb862d3aa99493e303f1fbecb67e2ff829a890338ebf642b1bcebcdd3eeba6,
+            0x1d742e5595d6548a4e5cde3fa1a024fc04ba950de76aeef9d094ef3a6aa80e01,
+            0x2f00e60ddbc4d8cbf208aace4afbe88c9025e161a5b3dbf495f11520fb314713,
+            0x937367d77f41edb078d7efd73191a38ec61b2f7ea633aacc172fc808e6e20b9,
+            0x20cc21ebecbeb50a3e7b6f0ffc58f95d9bd9990c8e0cb2b51bea7cf817e0501c,
+            0x2153722c6eeac70d60abd76aa40279e600a739a3c24b2d9950e7e0d08468ae60,
+            0x170429ceffee65277a55842cc1c6089270d658bc86565a5618a4e1156546957e,
+            0x2881b86019bc624704431bc3ed315ae4dd4c6589118f6a60d920f1c4937696a4,
+            0xf75ac5249bce09549072133d80f299f5e194bd34f820433eebeb5e020817091,
+            0x9a487d60d8c77e941b03d1a4cf0e9a92b8328bc432b437318c0bf096b8c95e8,
+            0xc4c7b8be9ade992204bed2fba9ab541af980a47b389cccf61abf5353640bcf0,
+            0x13c6f29a13b808abc57cdc98bd5b32326c0d37640b2b1c58a988c50dd0a66e90,
+            0xdcf77d7d72c03c43842c43d906862cbfa78b60f89780b9385a2d81e316d96a2,
+            0x1af4ecef93add6d17e589cb3e93a7240f2285e18c1882da49b0996fa64a5f7d2,
+            0x16500f1e2eb13aef4078724a58c869cf7af3bb0a8eb50236c3e2463ce54554ec,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2fb22f7c0dcc8f0710df44a538564fa4835d8297a65bd032793c44d1ecbc66e,
+            0x186c3597d2e95409839a6577665c9247c61d1d4e39ed975d7eab0407571a3cfd,
+            0x268a806ff91bdb7848e65fcffcae8ab72e771dcd9e44918bbbf961d024c4e780,
+            0x22a72134e6b344238cfde291a9c27c8d91a7ce8ca75efc932a3ac0fce7229618,
+            0x2f3d93275b7e8f80483d94dcb59ecbb02d578565b6f3510a3b362db38b806990,
+            0x2188074227737f56f2ed000fb0557da0fce247b29e3fc1e94c782497dfedca5,
+            0x2795cb6a4c716bfb133f5aa5e413d7ec0643932100bee8003e35125e908e92e6,
+            0x168669f585369a0e9e1e1800a4a64e59198f67da9022257ae38ed2dae2f3e890,
+            0x1ffa32112a81bc68e5ce9b45a08becec9463ced766f99e3f70c5295bb287cf05,
+            0x24305de92f0bb0f4bf743d990721957c6147f9712ad12bd0970d35471343f1f2,
+            0x2553d6aca650db381e5a5cff064f3ae81d10dcf60fdc1b88d0b4a182cc3b86a5,
+            0x2f3c1b421f6d478376b135c9d120317b4290120dc11218033e249e6f660738a0,
+            0x245b4bed81074004368bbf0206d685ea4aad9ec2c5c27404550b134d60301858,
+            0x5d189b960a83b4cd0a7038f8a5bb9fc4f86a1195041c3d5aca8020cbf92a015,
+            0x2842fd81790b045c74803f7569b25eff6c992c2e571bbaf1cf9917f9dd45eeab,
+            0xbb806b253f4b014dac7ec4b9150635e5dab4505e9194ce2046af74db06e6fb4,
+            0x1130802bdbf1ce4ad31b52a3b3380ad274eaec3ad8217a45429e7b8bf9f57291,
+            0x236b083a817afa7114155de365d7157d5c45d3ff29a665828689c98c118887c1,
+            0x2b1118c83315eed11ca8a5128ddb9fbdfcb0944e37f30f57ae91e81344f76eb3,
+            0x26c7bf0a07d43c11dd2460b3d339014666f2ccc0d6f926dc5320693ce6530213,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x62d864c511b8873334e836d12eb72f7552810f28b4b9270ea837e9118dd92fb,
+            0x25587eb09d2cdb6628c520a7111ed2287f8ef7d5bf15e7ff0d9415616c14beb9,
+            0x20344cc75c81860502190a88a9753741eb82f1355eff6272a687af15b3370983,
+            0xcee668ab7cafe0c92f12586b73566a59fa7d9e14624394bca99d6fe9e082c57,
+            0x41098b20212f04cc7fed3b8aa272d37dd719e4304f79301d4b7ae6efefeaa72,
+            0x193870bbe39e62100358a649faa3ff6f81d1915da932545ad5ae3dd951529dd2,
+            0x1d86daa8ff221daf2c5910e1b9adc7d1a320575c43ec64b6f8aca53cab46f16c,
+            0x25923c7c452a59c736795ec2d6993a2d27a18b01107b018164dc30ffc6c7e36d,
+            0x166f933a262efecbfefd5d1218289e8306130b9b3ae903564812aae0c357b73e,
+            0xe710428c953a764b43ffbdd166707d10a6a08ed48aaeb562ca63a19b70c1c50,
+            0x14212cc175586510bb7e0107b7e99a1add7be5eca7445e35b23a9bf5e9bc26b7,
+            0x7922b817e326535d89ad077f917aa3f5ca180e982a89628502299515bd1db4b,
+            0x17b1b0209846528ed24450b5b6910c3dac0d79a35c1297c2e0ad518bef18ec2b,
+            0x1fcf8f4d3ba39e14ce346b78e781ccb86fa80a2c9b91b53b2b917d32201bb0e8,
+            0x1328e374326bd95e9a909683113443b309c75dd559c78e48589f91d3d667fd7b,
+            0x186b0b6795393cfd4a4961f0d34cd0f86d491ec8859ed1f39649f4a77d23d0be,
+            0x22866b41e186a1a499d3862f90ed2138b052753dc15fb43f71d071fa54e8ca21,
+            0x1a21712b5674e92a8fcdba2df567658a78f1c6409972912f59a3fca3fe10010a,
+            0x169c1593ef30d80f8f26d4c287a790cec8e41ae53c718b5aca62baea5e7a7f63,
+            0x10cfc561fd16648777627b6f289f95a96fbb95ecd84ee59ed541e7b81edb4d69,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2f44dd9b3903bbe40ed4f0a14f06a691510f25d683942e3fede322c7f27db564,
+            0x1be695baecbf688d6618060b85965e37e50ae175e45f09704d33f2605ae3ed6,
+            0x163a43dabce2f70ea0d35c105ad54d85eea9b0953d028fe4e11c604e8b5e69a6,
+            0x2956dda14554b0ab7db32968d172b733bf92a1efdec6320b0c3c9114da88bb7f,
+            0x10f41dd81a27925bd837952dae5a9c494dd285ffa9a40d9ccb17d71b9098dbad,
+            0x280ad3fca7cff3b3cbdf6781f295bc0ee70275c10a6409b7b8c99157753013cd,
+            0xf12826ee6e2f4690c360410aceaf27726e64d0c6d39bb5eb8bcaafdb4266aea,
+            0xe9f48dc6fbc4706c6375c87d3fbbce3fe78427250b0fcae92e07890d3fd942e,
+            0x1c7a967977120a43bfbfc9351f2ccc84a2e1a2b9f440867e9d9257a1573c1f3f,
+            0x19d6f7ac7339519c004c1893c15b90c6b50fb09410e9ce523bddd88aa3dd3d75,
+            0x1b92f3e79d7fe18dd5a8a7c74fe697b800921cb181be388e65b39cc8114b32aa,
+            0x22998601081051242be4d99570e60ca7ff816acddfc3605f463a1221b11e097,
+            0x17f81154836c1b89e026090ab505be76f2da2674a77bb65196f29123106f15e4,
+            0x27b439487ca8865a03fc7699acf9c74e7589ec1282fbb0eea9f6fc4215fb8d5f,
+            0x2ebf049a07d92affe4877c3e4faa5bb176d58c7b514ce03b85ff8eea6b17011c,
+            0x14b55de484bf2eda58a874c907aed547c35e892592a8704e330457a6927eb9c6,
+            0x2cf300af23253ae125944cac6565ad837e1b4857ac3b9003951c414d167e4622,
+            0x11a0cdf58417864a0399eb08e3af0cfca6afe79e831eb14c2c7e6ae904ac14f1,
+            0x13f038e1602814d23b07765cbcb44033562f7c8192fd2e45ae1372cd3f9100ab,
+            0xa324aa4a2273af5015991b7e47dc180ec2c6cdd3afaa7ca1ffba46e4cb5a78e,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2335a58b2a4893de3bb776a21abcc6bd01746d21d60dc99407a58ec99ca5394d,
+            0x3792e932762b5353053cd478898e7067fa59e0aa0f97bb5d075b83e7f1068b1,
+            0x171f0973baffed9d21be47d121de7717d9200520579e674c345741ee2c0c9af0,
+            0x1ff55845a587dee8b90bb11b2490e5abb7bacf3963f7739421b471e1f3cb589d,
+            0x6db58db2db6fe63f54d05adb8aeaa9cb89f48d8248e45d647b9148d1fd202bf,
+            0x207a78198a8af61712585f9e3aa8fb315320232612f83529fb1b5892c30527ab,
+            0xda95af66e6e0aa2f1a0ac71fa29c74d75bb9f99e9458079fbc43fcdddfc1be3,
+            0x244dff1663f2935bea98c07d041221ff4b866285a999a04e7badb7932a91e7ee,
+            0xf1666c15799e77aab89a2b35be57b29222ba0bcb4c690b05f144b61c61099f9,
+            0x2e9b5aed7ff481e79e49c949604b1d7dc241700cbf5d6e7748e13f74f30e5ac1,
+            0x16834fb2ba464871b1815f1495a872d63e79504d5324e80b34adf43ca7a68908,
+            0x143a59fd2f1e040c91f7230be230101ce4e6323eec738f2906357464515206a1,
+            0x43dbd8535bb232d99c3535dc3d655a963324bf70d1a3274e40e64393030471c,
+            0x7b166c254454f4b8d6fb5aa80087856a5f3affc248c814703364663f08fb766,
+            0x2047d44ad52bb40ba8e9f31f521339de3e41cbc7ef94245e7b9c82e3d5239f2a,
+            0x1e23eadfe8cd5443f15abfde942370f48254cf355214fead4e4d85a0722e3452,
+            0x1371b1a0c0ef71a90bf7c32118ae414f81d593f95f864cea9a1b60607b1ecba4,
+            0x29c9b03f3f02faa3d633b65dbf083f24565eb29e36ed1eee4bc5376889b5a0f5,
+            0x11c0d488111b7ed7b91e9be524819faeb74d64619847d9e96cd916a50d17311,
+            0x2d389c9b04a7aaa0eba8940233e3630c8b98f061a7565a7d5caaf28a3fb77307,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x12e351fea34839d65253cbc1cf32d39e34b1037767f5c2b90627d90d73d3bb0a,
+            0x2e27a42188a58299c9d8044c410844229d17a11812405d3d35537974652ead64,
+            0x14bdf13946d48ef5a08883efab512ddf10596421d031823284426fe729475367,
+            0x9a068a755057ee06efb7fd6667bb62353ec9cd08fbc887cf5f4fcb2ccba098f,
+            0x519b4409ec8e3a7860ee5c90956903fd27fadae89854357f81cf33fee0e8cfc,
+            0x2e810ccf1dd607ec36f7ab647ca38d42710eab334142a8398b5da402a5840054,
+            0x233108c004672dd480bed52d6f25174cd89d1a025a60ff6888a978503ddfd96b,
+            0x5be8a2527d11c6c19b0e5c5a0e75a0b54c5e21e68c1850494e4fe7784cfcdc8,
+            0x1c4d74ec5ad43fa3f3f50702399181ac51aa69d9260f1b32fe7c1ccbc232a0ec,
+            0x2c98c881a993b1aca5ee9e7f559ccdf305e696156bd0ad4515afcf5bd168de28,
+            0xac8b8f35d94988510c83febbd4925feedb7115380f6c4e167aaa9ba11ae739,
+            0x28b2d2b745647c152ad021d9e1e7e87aa179c49626348fcd0c29444aee62d71d,
+            0x232dd2860f628248f1b55a1f1b7f4205d5d8c86139e182b31518eb4fa1eba077,
+            0x2d45676dafb1b4e4f2e5326ad8f2d6a382ccce3969091d48ce0635bccd9f1f84,
+            0x23c9bab33c8ca65ba9579f56ddbd8967db1e9e3530889762e743a32277f4a56e,
+            0x2e3f511a8650b0493951efe1029eac8006bb5d44f214508ae0870daf794eee04,
+            0x1fadef99b87a98d042116dc8d68a6eba75609dcbba24feceedc576a5f8c56ec0,
+            0x13b1c1adee57755d2c3da15fe50fe6332e5d5c5b5929c5ef8ea0387043fc156c,
+            0x22a338fe1a442d6afe886f9cbcac11a4f7f9bdd77fb3a8b78dc8368a5613da63,
+            0x1c069ae1b1241b93546ccf9d02a0279737dd1065e075da8cb88190a71fd2e887,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xcd4ceac7e7f2cd68f2aadd77f8a89a35b39e6fe20795800da208139d3a12390,
+            0x1c2ee3595af8de51bbd5eb8567f18d3e1db383bfa37973f87cb36e72a88c81c0,
+            0xa7c2fc763da1bf375377589baab4d68685a7d3d23f08d106e5326eea97b0333,
+            0x1b50d5a9d6db07dd3f14eb594c51c1cd119a0e734a1f2459cf989a47e557359a,
+            0x30161bd3b8b78d824bd26c4ac8eaebf0c3bf2ac2a428c274b458406cba4799e4,
+            0x7274702734590bfd2fa48046b2b21cd261a226526c126dc9841a00c5b74747d,
+            0x23064c35e504e677bf3c438b120a1c02bd6e8edbc70778e46b7e5f00d1633597,
+            0x7b4b8fcf8c2cabf527256c84aaccb348d19a3d8e41caecab110f3dcd563d0bd,
+            0xa95e011e6866c8550e42efbedd76eddbae2a133a82edd6308f4c8d629d42964,
+            0x180517d31f2656d1cf425f6aaae0751054c71dd9df0a236c6c049a3b33cb4da0,
+            0xaa7c1d96d99bf95d733baeb6e88f4a8536c1f846730f460731b2074f534ff99,
+            0xdd0dfedf6a1d0e3368d8f79d159d585f181aadb93429e0287324179d1e37e4b,
+            0x572df3598f8791d83d3401b87b3d6e6b3a778a9a4a33e1b6c24746070a3bf18,
+            0xf9cb4e73d3b6c128f629e12d409ecd7048781ea825ac98c564f11fabdff8d14,
+            0x1db3c7279ff54baa1b579a2d00acce27d1f80dac5da005ac5a50052cf4ea6143,
+            0x2942a1875714a0c00d3b2d20dc216f466bbc448af3a63e05aef6353073503b0c,
+            0x2522caff7f2a2bf9cdf836ec99ab832e3f792614b5cef40cd3e9f00c9b2df92e,
+            0x1cc0d08465538de8bc30077a0fca970b6bc309fedf4f48c79ac7ec6ba1f4a6a7,
+            0x1be86dc6dca9d90b15bed5bf60edea532e1510007055893ccd65741037c814b9,
+            0x2ecc73f82062b8a6d91bed0d221022331d55436042ce722797c1ab25f77a9f2b,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1e954a04dbc733e4ad843f23a7f402bba126324674450eed047e158c4342f75a,
+            0x1bf6934a5502144b995fd7a26c8be4f9507169f7d29691e460277ce8a06886b,
+            0x10a770647e157ab71fc08d6e560bfc21954d55647c32096c258e244fec48629d,
+            0x2379fd0b045b1b43d59bd7cc2760c8bc5055f3a441fa6288c84a3c7c7488a566,
+            0x242557dd84169e034b9c9ece2f2dc4bf4f4b3520b2ec0c62754cdda61aa13759,
+            0x24d0e65867e83cf7f865e89a44c0fa4f31df8eaf20194cc9e773188322020fbe,
+            0xf08e39c0aca58fd66c96bb21691c0b06fc564cc300040ffd985b0ffdab6ba89,
+            0x1c3119af9b3e6b5bff8c6915f68472b22cf3f9e187ab26981b86c3e90dc767e5,
+            0x18836e6cd384b031b1a462ad8d0a11c34910f35baa8a92fb3e56f9615cd702c0,
+            0x10b2bcb24625ababda8c1c7186890382b9ce83854d7bc4f2460f30d706a4cb48,
+            0x237fdf2809ea511ef064a7c036f29c1d555c0b32dfd257334ff535fe42cd81f8,
+            0x21b9cc4ec4c0832479f7cc5e15b4ad4722477a5ba013d9d359d540afc5737f67,
+            0x258e26b354d7ebe2793cd3fb7c3bf6d170cf9db55cda38f57158d9b865298d8e,
+            0x1d48d2d440fb27a8ed1fdf8212e7b34cc231bd2d893402412f96f938165bf3ad,
+            0x138fe1103d55fc0267df8380c50775947493bf88f75a73d783b21caa92197f3c,
+            0x1edf94fb5b430b784be783f8980634ad92449f73e33c25e9f7d63f3a62f30fff,
+            0x8eae1383cf79a2ea6482185fb4b72345ca8689c16e67bd0a253eff22c5cffde,
+            0x761d160fec46a8c06e3e055d34791703f805a77bf30042a43b6f04e35dde41d,
+            0x2e23c612794a7f8cbce764b156e02bc21f2289396e30ab846536239dc8938efb,
+            0x1539abe4d27172e4ab5380afc595d723f9ef3fb7e8063705f9a07c40a67e372e,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x4d800ab616d72aee2f1cfb8eaa194dbb2bd95d9bc9d8327943da4f45befc2b5,
+            0x2207ae07dccbc047ccce5415be0c4941ccd2aa15ffe4f4a8e07a60c0a7fad9bd,
+            0x64d711ce20b70d512f1ca107456bd158586fc1e3219d09f3de8fdece43088a5,
+            0x56adb05c833c5d1984c7f6bd75b02cfc1c7b21dd7bf6daf1b52522c96978158,
+            0x2efc241aa72e16ff31abc7977dacf9a6df53b26217544c53bb87807d5d61506e,
+            0xf41fed22cb32a447dcf33e989193fff2157f3075848ed1e46a181128ebb7e5,
+            0x169291f2bb1381ce3b16e812c546890ef5ce32c1d768d81264cd719e4e1502d5,
+            0x2f9fc1e4f2924d82d17c7ea7d3b09f67be93560ba39f29537ec0c1f2befd4729,
+            0x13ac8de14556e9b886de3944edae4c601a01f78fb263730f44f7d9991b8c7e2d,
+            0x29a69af8e28052f2c56dc24bda3a5e61cfb3e9c6ede0fdb857a1971fa932aedb,
+            0x180e9a2e161d21013486fb8598113f7a280697e89643400cbefd587893787172,
+            0x29fec555b91dfa57a42cb368560d4bc471c77a2e236a9d7c9c6aab1b6d1117f2,
+            0x231ef485473f733d46f0e2acbfe7e3961d045f30244244ab3bb7165863c1a46,
+            0xe6c1b39867e21ef0c630a99754d1a66a6688192254d40492ce88d47e5fa15c3,
+            0x2e0a260d61bad61b7891e6306df8b2310d8b8db9232fd1f7219e7fba86597031,
+            0x176aa7da52727a85134b313308a4c62994d4149bd6c6fc59d6e6c0f09eac859f,
+            0x12922be1b7fdc58e582eb1adc46890c48e10c8550eb8b9b11d8541694ef3a9f1,
+            0x32268b4c29827a65066e67d71e10cc978a73e0442bb1c9f67bacc883a3f4fdf,
+            0x10beab6538e0141fcfbfa8da4cf3070e69b2b49da1818ec8a9e54757a51b3c19,
+            0x36192a82ba9eea93a2f4b1994440a11a556d0d157ae5da57192e56c21c28256,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x34207380baf33709aed4bf2cf5d387a15f30dd072028305cdce60c1737ac627,
+            0x1eb09b8ad28ff81a7b21236652960fe9bcdc84caa6b21549da93a72d92ccbc8,
+            0x2545313ea42693cc8c0d6315d8bf240ae624d66f60f6f0a356a105ca6a7220bf,
+            0x1269b1b6e6ffd9938f8b4d7c4ae3c7feb7686b9de06a6831fd957cfc3c3bf7b7,
+            0x281e84c6cc599d853fcf8ca0a606f70aadc893adf4a4a099364b8c052f169ab8,
+            0xaeee3f27983d8e9eec8d6873cb1cbeb38c3d5912c74066bd0dbc559edb12c69,
+            0xfdc47ab86a0a3d8e9217faaee18d9b5b86e9d64deba55018f355d3b9a36b6a8,
+            0x2c35a627b5540525beacc313eb5733cf97e1ff3ddb3f9b4e8b4f063b686d2e12,
+            0x332c87526e40afec8b93f9735204bcacd4c6431c60b0b3daab4fb7f120bb301,
+            0xd5d00fda5d7c9aca26fec63f2565a7b64fcb58a67e7c29a64d0e450fb2b956e,
+            0x1b9cb4b5f32f1ba38a685870d7a5f7f44370b9b0e4c12ed349fdf28de5f49865,
+            0x1c63e1e8141a5a498ea10713d8bd8ebc5d61aad6e0ab492baff25befbbb26a26,
+            0x26ab3869c42b4e0139459f133c996241607f280672e2db244466d3e425c50fc5,
+            0xe8a1f3050352b43a39fde443e466884d09945cca09f31f043ef872a85511bc8,
+            0x51d4fe0ed70b240156e4fdd7fb3351d55841c4fd97d1a4fdfe0910932052536,
+            0xb0a1015d5b0b6a572187b97a4427f7e938485515cbe32e0016d11de7d6bc760,
+            0xfbfa326f445e39a06bdb999832f75f80114c3ead6206339d7a5edf276ee54b4,
+            0x9ca06de513672e4bf3625d0cebfa2286a44737b84647df4154d524528e82750,
+            0x281dba97e7243b1d3437c626fda37e43c95cbe3987bea3be9d19860672ed4719,
+            0x26de57caaf86357521f470a899d072f52a41043ff0bf242a845b71b8ba0dc6ae,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2fdb2e183ab509617feaa6e075cb9de40e5165621c2a4266fb894471e9c1946d,
+            0x6188498691a27faf8c8f4a2b3425dada1a87d06c53861823232acedb25d6def,
+            0xbfedca0dd5e506b091baae85be99b391358740f9a7c6578c58349f522323a18,
+            0x78b237302bdc513c9965872103d4588c8b19a002b784ea4217fb04455d3133e,
+            0x25f15182a955582df5a3f58d36648b5cdef4bbbdddeca93eae6c94fafb198305,
+            0xa07fd1f3e8a7d1f026578e5999ed3c7d63d5bffe07ff0c96cf8b23e2e0f7820,
+            0xbd64bd942a57b8c209d7602bf222a0ba5c84251dde43bc098e938f75a0b678b,
+            0x2cbe62c979e608377112ff7050870162a94dc68556270ee7a66e65305d1b16dd,
+            0x9da1c5dbe788effd900ea877c8f099af1c03e112300d9e070e6c6f8c07b6a36,
+            0x7981ab3c73beaa4e1e775d4e4abce3bc86eb79168d6f157f9cadbbc30ca97e5,
+            0x3dced6534fd07a1107d6c54510a07f25c0a10b260c7376bdeb10c4e768d91a3,
+            0x988db118a1974fdd8b434549e13ec8654644298f3388bac401b75b4d550ed76,
+            0x1deff1662df511afe108d5322ab104e70703d65b729c1dfdc2bc74345d4170b3,
+            0x3a1bb1a92965c2cfce4124a8abf82b54e3ca37474728dfbe965f7e04fae0f1d,
+            0x281f0cbf3e036b4ae183795116b65070d16e37621d83b3d88ae69e98d8c44d83,
+            0x15c4576d8475a4291a8db61a22db870c56b013d0849b1066386e859b996d9035,
+            0x675b067ff63a96141eada800b0ad12de8eacad15c7f53e6241feb94cbe87f3b,
+            0x201aa00289c06147c4b86a521818881469fd0e4f91be7bb271afcaeb1037fd56,
+            0x1d590ada5a94b49917ebf20bdc55e03d0362b3f719aab865957c76b84a4413a,
+            0x6011f23c13d5ec3df59516c72371f2ea28e930f73189337762e3d4df3f7193,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x289927a769b163dd67f7165490a1a4d9fc3b8ec189ad4fcee07368a3e75a7573,
+            0x5a0ca87482e1f242157b180cd02fa975c72bec4c25d87f82b7c53e3a6830947,
+            0x2b328309cfe721d78f7a6e8634f54524c4eacc42ef998093e0b77c24d5ff9e80,
+            0x1ddfe1d1e5e9458ffb1d342e1b99a73b0083613406f932d7abadc8442204c061,
+            0x2da94a9b44a2e2681f75ee004c7d9cab662ca66c1ce78fb2ebd617ce449ee43f,
+            0x1efb5c3e6f22f498ced2f4e63c366b9dab0cb06adc4e92fc3f868709cdac330e,
+            0x464f0cbf6ac670c19420e79606bc447e259f8b203a4ba15f72ac220e853c884,
+            0x67e3c61a95e28c26b5628f679c7843e1e042d7841a670219194e99dcc618f82,
+            0x2d1ec49939d788c853f85da08552dd458a48a197cf0b023157ad04a49a72a28d,
+            0x25c69cc3ab094c56e86147024ede9ddabf71ddb294ab37659e9b2be22dd9e289,
+            0xbec17f5afb43e6faff2a6b09a02eed8455bdacf16ca542ccfcaffb119ea2c0a,
+            0x543caae6f7afe71cde9b817c9a746870d2cc62d2e7e1c6fe7fecfed5a98978d,
+            0x142025c358454da1e1cb0de99504766fa297d1f6fc62deb14ae0bec430d58087,
+            0x12b565ffd06708fd98bf8353991bd236bdc518c7fbb243fb05497ec7ae08939a,
+            0x12f287f0f3686375ba8431deb018fe9c28382d0b3f6d42c0c8bfef68b99b0639,
+            0x1b97a4c6e3b1340d563513c29d704429098877af661ac3d14a8e5caf2ec67622,
+            0x1160e192c3592d85262513d57850fa5f8ab05a95877afcacdf616cf742991fc,
+            0xde9cdc2af5b4780acd93ea46be905a8530e8bf89a97d41041cd39fa90975884,
+            0x29a2c79a9dc7c39e8ae57cc00010cc2aec866d9106a8f2c0def35fbc29b304c3,
+            0x1b39fe57a5648b6b19ed40ddeeda02db1a6a0590bcb4ac75d52c016bb5f004ab,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2eaafd2a94018113bfeca9f6f909c380ccb8c99788645cd8169586e66968a6e0,
+            0x27f7e86e479c9eb87a4c05e80dd23700a81c2e720bf0e889a6a5d5d2f2a385c4,
+            0x15fd4d2d4de641f8d803e4942f19aad8bf6b01a1b703dfd0f0b51acc263aed92,
+            0x172a8e725dd29bc4e28ac7a67a7f86bde15c58b1fe2f87bb21d06349bbf6a858,
+            0x11820ecad02878ccdd901bf88011203539ed7f14c17edf151f237b8f3f357bf3,
+            0x157bb0ec622781bd0485ed79ceb944a23eceb119dac4f88f3aa4878f082f60a,
+            0x1a0c8beae4e98f3c36307ba5a8ecb345cc5ff4d33963002e42b36242c7ee6f11,
+            0x19398691a16329089e7dd608cd6ea18749597908b9885b7a3818feddab8737f9,
+            0x2c92297efa4d689e784dd5ca22480de59b1ee91203331f44dc2c33877789a888,
+            0x2b05adc1b6cae6f7b6a2382c527c9e486e825d2f6ba1b1f9aa395fdc793e9bbe,
+            0xeac0d420eaa22d35e8f1dcf344a5bf8c05559171f5b3d8490e7cc58244b619a,
+            0x1f14c4c41d337360748c3f37c2e1c72f831a6f811893d188902688b43ff7ba89,
+            0x2dff4909b43986a532997bb6881979cc68bcae8e01bf9caa69389dd064a21288,
+            0xc5cb5da369f1f4f874bab1f706b652ef2c50b297b5340f7f6c0fad98f6f41de,
+            0x13c2c78c6e2b39691d5e7da33ce14fb2cff83ce3577f1909d2a9b1b73810067d,
+            0x8bcbec544fb37718da2d30fbd757ca63187f342440c8052bd9510314f6fa22,
+            0x12d845717c2b2c79c55769851913284ad56f2fe4ca359ee39e569cbd52c44b74,
+            0x10c0c4538604fe7ad96a08ea533aadf5307c89534a51dc4d958f769a0d225963,
+            0xd2a590e3fc8aa2260656e13a383726d6490425ca80eac6481467c17f1050265,
+            0x3030d8c3cade8438d664d3ebcb0b0889f57ffeef914c655e50cb68ae14c2f283,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1ec953704f6bb2e359a38b99d230ca7a4c8eb37e3479238a282da769f0425beb,
+            0x1eb6626b17b9fe129966d1ae7f272514826a0bb877d54a3a7d6fea8e46c94914,
+            0x2c31aba1b873c7d14d82ed3b033e75b871a7264f4ff1beb961a532d8a3b50698,
+            0xdb6e1d43e7479d449ea8e0fa42ef14a41cc880de1c7699cab480edd8a79ac7f,
+            0x21d8a97ad31f1192c8d87f08764c4f9a8f6c90940a6d444d922151dc812f4275,
+            0x29bd140ba4c910a6d297d316c9bb12f3a67ef0acb14f68af7afe36dcab638ca7,
+            0xa61d2fd60c57f574e19261a4a5f15b98af58e10836f3175d48fa7c361e98ec8,
+            0x1d593a571d4d07b6b677c7c987263c4f9ecd5d264071a49e6a65a9fbea46da81,
+            0xa764ac4206cae37430c7e6554f45e251bf3a4c8348e686d3103d44a3a53b565,
+            0xfc4c56a0e57f381acc4c3d8ccc8f9bc02332375f6a47343896e019f2679a7f0,
+            0x1c34df18abe2bd65c68b1e40a634311aee1429b49de0ac7a0ad890d434665a9e,
+            0xfa890b0f4e407242899e2812dceefc2e8e5daa8d41964612d862b182fb084bb,
+            0x1df4265e4bcb86f8df10427976b496708404d3eb8370ffe06d2fb5eb21597ab9,
+            0x14b74c5d557ec1780f3a0409c6d53b3b97190734d6f48b60ea42c5d54c194ab0,
+            0x112e82b702e99d25a62f79b82d5f0620605381ae21c311eb3b9b6407ef712a27,
+            0xb22a611ecdec54a9e15a98fbaef9be8bffe8c6f65b594fd8647ce0d03b1a819,
+            0x13552102754e83cff6a90cadf9a9fb9c9c4704c65200cb87144e7bbef93823f5,
+            0x90872282ea971f0593587dc8e0f8b7bbdf36a1a762b9d000353407306f7e732,
+            0x101e86c640c3bb179c0805a76ae6f326efb5ce0c7b584c0aeec2ddadd727c97f,
+            0x17a1236e80618f661c6b0932b1332b40802aacd5fea74c8575ab87a38bb7debb,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x12398407948eaecd57ed99dce52b4051d9a7f862241f682e26f29366b26e8acc,
+            0x1846ebf17d453d52ee6bc5f217abe6a0d5aa43084af5ced178a081ae3e204fa,
+            0x2054f2993d487237bf6e4a985c3abaf3ea8f0578ad5eb731f94a0dd533e846f,
+            0x1911b97db6f1c83692aa3a44172aaf316d863adacf721463e9b34e93c3499d5e,
+            0x1e7f11887082042971c2cf546c3fe7031d955ea7e371cff4d270e56aeb0a162,
+            0x12170e18a97a2c89b045eec5263655c47fb08fdc4622c5936d0b9d2aaa721cfc,
+            0x209b3d0342a6bbbcea6b3ec256daed1605bb9afb9adcb0ac9ff0d409751f136,
+            0x6144e781f4197e7402726ed1e01d1a9df01807d8f679e5bff27837902bf4b85,
+            0x129444fc0f4808af8a64b51d94d9be48764ade198781acd87360efc9dcc7a8a5,
+            0x1f12b62b42b308fa0b8677bd62e9b5fb6644cffd6ae43eacad6d127f8437334b,
+            0x2a1e7df0ce57b7a7c3fcbd73c68791c5aaf538727082f773c41e94fa24433fba,
+            0x11ac54cbcf0e6175c34eb7e364adc9a26eea739c22aff79208ae371bfc8b1cf6,
+            0x263230c117421eed84437ed926810a77a756789fc8b3cace2da917ee6311974a,
+            0x10df3a59e7ec06ae62a749bc6791d1b9b2e7cf0bbcf519f3c023e543514e5c5b,
+            0x2ee43f7cbc305d64cddff15cd91b7f6dbc0425e706b107e6b146316a8ed4c433,
+            0x15e9ba236c3bd1b8efe4391047d6de8b2d8ebd45ca5912a619f7667655a1b750,
+            0x1d74abec20aa969ad6f1991585c09cf7b2e4b68998a748fc84fe304511c6b599,
+            0x5ae72091e906e7f9d94e8b5e00f4dd0b43039d0ee9ac1598c3616c86d7ab06c,
+            0x2b548c790a449adefc53712a777b2b90bea7061df2f57d337b9f512940bff3ec,
+            0xc79e3413149346cf672ce76f5181de7604163cd00c9a5263fec43477ba2fadd,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x3017a09725154c2672bc149b4bcd370771a14807833c069d712618e207531b30,
+            0xb93ab490450416ec4a761155768efac5d022a8b3712cb410b78e43826dc07fd,
+            0xf7ef4a57e815865508ac5e78bd6ff37c11dbc4bf0773864e943b14e0f79c872,
+            0x28d3598fc9de7f8e645588886736a239902008f4c0c54525e1927cf66bd0a047,
+            0x178d2dfede02ec9735d83ae6ecb07d875b78360c45d9796753b52162050f2473,
+            0x2055e88d1c4873c3fc760261b724a8c8c852b05773e03e4781e03dcd410c878a,
+            0x201af7d279732ff24a7300d4a63a327a0d152d481e75701bfb1ae60001808de4,
+            0x20b9d7719511885b8e03da08d1289fa02923259857fa5c51a4fd3f6bbecbe8e4,
+            0xc0c12d9eb25cf37cd472d0ec9f4e283832823607ca823e3ad30de69cb10bd97,
+            0xc413585abc142ff58981d211bed7b8d7fbc6c0538dbffe36105ba44e18b38ec,
+            0x1ad95bcc4eb2757c070d732f7f27ca45f4685886ec1a21e6222dd7b99487aef8,
+            0xe9cd75323a37d831825a99061f0920e6594ae3e3e94d45a3a33aae620d670ab,
+            0xfe94376e19c40263ded62340d5042f64e3708e0c556ab677b64a252de7e7201,
+            0x236be50f0fe1b1545413d3a6d2c60cd28cb80b5cecaf301fb32d687ab8639656,
+            0x28033ec35e8541ea37b843d7cd1613c7c95de6d6a3c1e7688cc26ac5c0433dd,
+            0x186eea9c433f8f5ba4318087295fae6003a63a5250cce25ff3127ceb8ea62226,
+            0x1997be30d551c31424dd592c2df897dedf13631320bf71075ebd15dd0eb234e1,
+            0xc86b6e4ec0b7673c81e2a33cfab7f5ebdcf740fa723952f5553a60d7866c0fd,
+            0x2079ea58606d87fa8eb2de37607a65768044990a0329f877b16141d63675cc3,
+            0x17d722901c37847aaa1f74a31f9948d916c880d547bec7b0f2b9b1957ad97934,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xe81a4c71073cfff9bc2053e730c22f6f04712a44b6fdfa3e5d031ae937ba4ec,
+            0x1b643ddf9217a65dcf59a7c4a40f0a8ab16d034cc1281c981940d2ac528c11b4,
+            0x26cd2f5364c6d09211ed0c9944602e97e582b47e93f8877923f0367c25ecb766,
+            0x14e4f38d385b57d8cef67ce66e5199f2fdda3ff261a139a9a421ec1f2bd540b2,
+            0x168e02a829c74f8224d6ec0f2a87b93714d60848920306ad51309b5f2736c998,
+            0x2fb61a6b4f14e47f6ec64e4acdc941829a48782090c2f399435382ff67b7747c,
+            0x2b8353e21e9a695ae8b58e8a11460e8dd7630b073db22e59ef804f570e8a55e1,
+            0x29dc5e33af36ae34947c29d674778729ec99b8ab4fffd5c3d957ce532ae7ec10,
+            0xf36d6ea37c6705c7ea7bcc34950a883ec6505ac89b6b5d41cc743516e6876,
+            0x2799caf6a25f94e81d9f8e362093d9c5440aa9be99dee55c54f7120492a40cfb,
+            0x2bcd01c7e5c45ca9764c04385a1636e247e47382b443d73a905ece066790e08c,
+            0xf0d76223683dfda5320cdafcc711a2038f7ef465f9847a8c1c4904d6066adf8,
+            0x2974f8366a339e664e9b42672012b8ffae9079796783a178ea0009179fd6577b,
+            0x156f973d0d9d785674e3b7e05e96c5b11a582c75655082796018e9dc11bc5b64,
+            0x19da910e2a4be9d039440b18d700dde2f65455708e7cafabb61809e4103c87d0,
+            0x2cfc58b0abe0def0fb166d114edc3d0d3cea117ac3dedde6e6f4fe7ae4768505,
+            0x2c0c40c61c6598dd8aba498ad9199f38bee4e39fc06ea761a2de890aabb5d9a4,
+            0x1e30543b1ce12e136f719a5920cde3bc35e1b94142a993b522b96ea9703d4cba,
+            0x12fc3e01e274c109f341fd2f9869165284c3c7567e2604dd638d0f2267d63db,
+            0x2a9680b2eda565239cab76b7b7aa8089f732fe9f0167c9beeac9ca8b146387f7,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1421e02cf82980b68a9c81a28eeb397e0ccaf80055d5aa562d9b5f68bbebee41,
+            0x217804431d1cfbcd6e2ae64af07ef7eb31e21baa352bcee45c73af5f07db8d33,
+            0x2d15bdfb3a952df31cade21c99f2933edaf8d7aa3f69fc1a16a3e6bef6c7f5bd,
+            0x27f5885f9ddc3ec7e7f2b43d6cb0c0ae1e0e2555ef46cdbb753d13528e239f0e,
+            0x3a37a151a0a4214c78b52217dfb4bc323c833a25e0c6fa5b2c9c4e1c3deb674,
+            0x11a6fda46b867456af4f194a5f0571a3053adde7288f9fa84793b3516dc1ae4a,
+            0x24f22cde459accabe8eba8e9608341086af4cd4c04da2440b067cf6ed63b196,
+            0x532b9c8c9c2627b9822eb7cb4e26ba7356c4c867c42889e19d80903be433a1a,
+            0x7f309d33a4d334ca3179048797197b7f6729a3518735d608057330342520b0f,
+            0x947f36abcd0fad800f8abf23edd43565b6b6c26b7e244af6527036971340f67,
+            0xbb49c33a2751cfb8848554d24c216ddb7e6b88234769ba9304ca0bd580c2493,
+            0x1f791d5f90371b44b925e5fe04c2e994a584fc427e4219f551c35215e022fa9a,
+            0x1618299c6088e1d3a91f6cbc0956c6afbc3c38fd691feadc8d6787ad52d976b2,
+            0xcd4c820d82ae74e29d1915d6eed53be77e06c36f27598cf78773b06b362e029,
+            0x158545181f2bd7b64bfa41c26e3d4f5917ef52851c0046a7f18c26a0544b2ef5,
+            0x1af91ea8fc2319db6925b994492b65f631b416992595c9bfaf93ffe5839d86,
+            0x26c03eac9227b0be2a855f95de0c97d337d763af75f1ba327a9e409cd5a718ca,
+            0x189b176cd8975d36e0ef78f2f39f8780769d4c7411a5ad2724927981ccb1ab03,
+            0x41d9c7ccbf82c77e0580400cf1f9b530aefcdee51dc5a1a4b5a142d4170c6f8,
+            0x274278f69995b40626a7796e2f70b1d6b52f9fcff1dc50967080d9f0332ec782,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1c9a29a3fb7f2b95c153503276233cb8b1e4336434661d97a25389fbabf3037,
+            0x2cb5533d1d73b7b385328261659124419a9a7967483f0e3a3e63e3a4172d1712,
+            0x2e9bf13980f73bc9d03f4d644e7757f4a254235e659364b078607b15841ff222,
+            0x1467a26136dc7c21ae1d2eb531fd9af993c9c0f7923a0f17683babf7847ff5c7,
+            0x188210cd164a330cda3a1ec91c7b55c8210ddf706cbb38ede5d8b6ad98122539,
+            0x21789113e7aad51c02f8b3831e2133e1997ed31239ca267c6682b003d00f46a2,
+            0xd6ae72f4cac38afb4f95f69e9af3571df0ea4d7a726ec3bad4c9c3ce743543e,
+            0x29f63bb7c7b8dfc1a470d95f246c1ce2fd3126baa620abe230e181c191cb7cd1,
+            0x2f0fe6071d605469e17000e29ca7b618efcb9fa7f5b296f7312515b7080ba1e5,
+            0x2c993b62a92c8ceb812cad18de9b0ca96e041be6b12bedb8f64797a6b26fe167,
+            0x2fa9ced73852f04ca937475317f1ca35adfc8c2b89bcc4ceae7fe40a28f05896,
+            0x130264e8ed86dcaeec0aff16f605f7fd4577783b348758655222d4b6c003855e,
+            0x5137ce88eb7162f2c2ee9fa54b56b951a4479f53ffe656fd6a5ff4c9a03853e,
+            0x275c55e247d72ce00068db24abb786eed71968b226330472f6c8a609f2dee36c,
+            0x1cd13cb77f0c869c445fa8f9d6d49189f7ef7ec00cb4c00dae22db33c763197c,
+            0x6d9b6b1fd1e26a4ca07e71e3f9d40647caa0ef100a990ff9cc4b73ecee81bcb,
+            0x169dd62b282e78ff51548fc12731cea18b3bb95e8262d139b1974b2933a7b373,
+            0xc0653c4aa7fefb13ab5210cc32133a9faa456bbca5f4f0a4f4a1b8d14702afd,
+            0x2ddeae46a42784ce32df7b9f7118aef9f13552acac2046005af17748815c23a5,
+            0x2263646d28d39b4b0ff6d2243ea0e67239533523f83fa0f4f6d575bebd7bcfa2,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xf91c7a21016b36d9010165ac8b1b7169da842bc0a274adb5abf99aadb62b936,
+            0x1a2e0a81ccc7ca01220f2e7ecf9189a5f2b9b46e53ff92d8cd238b5d195e743e,
+            0xbf18f381ca8ee6f9ff4bde5897d635bb27dec564132e744ef8dd436d1cd97b,
+            0x13296783d0803516483338c7df1b5fcf81f710522c631a1d6db1a1feb7efe67d,
+            0x21c82f469bf6605a5ee156b2511e0f67e9a242e3d1172f826864a0606ef594ad,
+            0x28dc10865221c98f25307ed8eb2e235e27d5a5d41ab3fba09baa0909fc939838,
+            0x23cdb14dc014cfc69098cffe231e4d43a20c6b3e4db8c6d17fc3463fe94051fc,
+            0x21edeea093570815944d629d7ab442d595b6e468ceb883687bf4a1ad49fb2968,
+            0xae1075937d8413c6471b481f04b5f6da78c486c9ec3a39f166de8edbf6ef5c9,
+            0x2fce3f0792f5cd047fa8bc04de4cdf33e1fb7813fbe14320cf794b05df31e9b5,
+            0x19d1204d38bebb4547c168a8b8e5f9266c5c88f9d30ca6097a5939ec41366bc,
+            0xde612e0e3ff1ec8c10f2f6683274e98c095439b57c178a5bc0c322d94ef05aa,
+            0xefa0f50e18937701c781ab79f263cf9fd325d58dd4d0936c592867f49707561,
+            0x22e1e777da6b3d2afe2a2f6f74ed2487163085e736f587089fb120e5c149f8d0,
+            0x18556105a08859a354db011951e9f9c5967a71ce648bf0aba15f2a559fd3976b,
+            0x1a5931f9bf826e643d72f1e85104e5108ca339af493cf5b1cc364552a309326b,
+            0x19473fd23dcbda0867c0d7655f4a2b99dd34160fd90b3a12dba802b661dad14c,
+            0x29c96a2d870db1de1e35ba02b37449a947dcec5e3708fc592414acb59812c708,
+            0x157097a50fe704e1f4c54a55088edb174721db69c7b7ae1b7394403ce694b789,
+            0x21e90e34302deccd9b3588cc6c5bcf0abdb909e8c75bf618bb5a5334af7a164b,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1d31a42740e431e210fc1553f20308cd05e93fc59b6bf166af395f9a66fdef38,
+            0x7d5c120df5efe5ad44d43cf7966f6260b523a9b25da639017e7f14dfdbe22aa,
+            0x1e4a39cd76190bd1b656e2982671758a893fc7d65985929f0c914553fbe793,
+            0x2762072623790fc85fea72d6c64a298bfb16f90ca429e91a1db2dca2451110dc,
+            0x144554ecdbfe88dc6f0c11c5f6b11fee2a86b1ec4cf9d69750091a7835ed3d20,
+            0x1983b95a2c8b6fc3734c7645ebb497b942da887c3f91c054fb1a48d3c8a1fc2d,
+            0x1113d1a221def2da4cb7faf3684ceb9f6bd2f3b0f52609bf08b2732252e9294d,
+            0xbf64c4ef1310f286504c25a637ec31686cfbaff0c10ddf272a92f6fa8af8441,
+            0x1209796e263e0d9999996e9f742ddcc4d92a12fd58ea384fe0a639da9334dcdd,
+            0xb1eeb6c4cd2d793bf5e7c27bb55c1ccf4a8d010c6e6fd4909619960ab127655,
+            0x4b05da50f761f6e8b2e065c6c6ec74e9277ad16d1829311bbebe773bc234a18,
+            0x328086aad9ebc7aa0190d029b1b9ff8c89bd85b90206799d7f0b9a67806e99b,
+            0x1ddfbad99857e4b84449e1076c3ff7a80585378d2194d944ed9a6fe227b16b85,
+            0x86cc93c30e9bc4bf90c09dffe4e3755ca2272a216434ee6df144c2414930217,
+            0x261fdfb4046f9f04902356a5682d941d98de74d39de11374bdc24fc441d7946a,
+            0x21672ca29365e252389c40a058d9af3cd23d84e9a5c4c405b7197488037cfc09,
+            0x2e04c3ce66b9cfecba87989ded13eba5fafb48fb63088e48010dbe8fa1638dbf,
+            0x2c8b25d7c74be5b163c04e13cbc7478735c966253677c689ea1819e760b20aac,
+            0xe9cd4551fb4ace8e62491b7e6a32d6ac5eb57fb5f801de1b27715cf1c770216,
+            0x17cdc28c38b48f61a48be7d1e5e5c57e8d3caef8f59159cb8017b21d67be834f,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1edcbf1e8c9add9f39b44ea9a4616fa51a90aa8d376e251e034a309dd69330b3,
+            0x123673f7bf110ef3e41b81a4450a12dd2ca03a8e2048aa76f46be766192c68fe,
+            0xee62eb21957dccda2e276ed02acdca3cf83ef2d381de42a0952ba4e2e71a086,
+            0x67c268f3b750898c2a26b57a4018e3be45c9453001a6205ccbb4abb9a07696c,
+            0x15a74bcb36f93b558f2f215ee8d41c64c4780df231ffa1b991e116f0c6e545f3,
+            0xfd15b70fa8970f88e689bcfe746a1357b99a5b73354129d3d49673ae432210c,
+            0x217e872910c020e9f11ea5437b1dbc0f45bff9a2c050bcdcfa2b6c345ac11451,
+            0x1d12a9b49accc9f63862064b6f3d0a2510aa99f1d835880cba6ac0891e172578,
+            0x2c9baba92c77edcd883f32d4c34ff1dd285e99653e602c33ed3a6ebb65e70a0b,
+            0x2476eb407cc255bcb6509912e6748cff7adeb4cb933993b4f8c9643c03988fec,
+            0x629b9717c416be51a6bb98c3716043450d39fc02078e1498121393a09663302,
+            0x1b8a88c8fe80358d0e1532f7ea232f1716e561326b5000f53ae948fa3eff7e78,
+            0x23739fa9f1d477e950ff4d63f82d632390546879165819be81219773004dfce9,
+            0xe7522fcd267e8fac57c87e271f4cbd13d488f4c25aea6719c2a17cfde4aa8f0,
+            0x58a36221cf3818847bd604233233e69a718cecf262baa457cf1e5cccb9ff6b5,
+            0x9e192a9e456d483afc81ea5fc9cf93bb91a03334eb4d239753802785c6c8fdd,
+            0x74cbcb738b033d9e9be837569ad0dff3d8ffc1eb3ede44892566568cb66b68,
+            0x283e0b8b91557645c15defd2d8f6e21f27621adae3ffd0a7d7e9f31359110260,
+            0x10eade70c487ee2cd5e43d51525ccd0f345a69ad735b603cc108c17b498152e6,
+            0x2f01b82b8346c4257c16eff957b22028c5502667fa6874ce956e03fb6939f21c,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x664e78dad6b22d4333a1f9ca0ba708ad6ab875efa8e8997a0a8540a2599b0c4,
+            0x4e1f57eab14954bd0b21619ace372b8d8aead861ac55f082aa3bc1d8245074e,
+            0x41d00073a80f790beb8d4b4e2ac64f807f806d5fe9057aa196f880e653e6c78,
+            0x2d2d71f2fb3d724683423f92661c8f441565d2e5a878b47af687fb9b76e1737f,
+            0x2c80f1f732fd19836516ecae7d53f145076edfe857a6cd0749b85406ecfc14f2,
+            0x2c4c5978cbe976f81116003e82010a291a0082dbd92daacb0a39bcb060a8d5e2,
+            0x13e3c874118b9913d81f2d8bdf4a87a01d6e521d6548c66d7c0421db714dffac,
+            0x1c0abdb801cd736feaa3fe7f98515e72f7a8d72ef56b5952e6a0e807e2c685a6,
+            0xbd705c574e698fafc2d0979e92e9bbf0ff92ecb0a71378be168bda88c33d0d0,
+            0x49067c522e1f0393a320557b41676f2539d7815ef2b21fcf310cf626d13a133,
+            0x1989344c4aa025dd6a33c0f2ca58b22ea3f49ee5d29f0150ec05da44a6babd2e,
+            0x2059839a6b9192e77c6182e6e564002b930aed9f328d24061701ce784408e3b7,
+            0x2e29f425e322f7780dfc808e679480fcaa0761f752420a49075d76a085e80e28,
+            0x2b310e22ebc1bbfa6514fbdee2a48cea36c1e938a6927486fcaac8201ff253a4,
+            0x243b6f33e43a7d1ed19e7f1b8163316c0408e456180d572d52321b622a2296c,
+            0x3028c94e563bc654584b3f335b0bc3312ec0ff0df98d3c7f2d02d710e1c7642c,
+            0xce5a4699a96b251fe3c809248875d0b1d60b90cab8a30ec6f882e5ce1823fa1,
+            0x2b9f25a7fb74acd52831e38877f95297970b3086d7888a5c2e1c11ce1fab81f3,
+            0x2bfb58abfed4844f986fec4419dd8d83eb0d8a097b72b84c81c72a9eb4e4f7d5,
+            0x239bc1e4d55fc6ed2c1e41d18252c011fc588e358fe839e1075fb344ff366d8c,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xa948ca5c1f9c7d679c476d6cdeb6483d28b8fff1f4b3258aca45312da96c7d1,
+            0xc5c83d7d624699c3654b32ca98a4da4723c4601cd7609db406bdcc5a9634a9d,
+            0xfaa398f6fc63cc36b00addcfd69233489a8f96cac8fac8d91cc3c3b502d2e2e,
+            0x1db588b11e10eba9c51ad6d4d990dbb580c64c0bf499a3b41006dbcac277e1e7,
+            0x1cb8fddcaf050feb6977ef7fb82625d63f7286e4a0bfa52a9f601de563bcd96e,
+            0x22154748d72b0e00f0f33d6d49e08b874ed2c638fe4c33648adf8862748b2f71,
+            0x18bd4153a10ebedb78f02b14ea2663a857f458f2708394c628288cfbc802b043,
+            0x111deeaa497d2d32e93d6d783dadfac2726f8487093472ec4fe8c36bbe2bb5d2,
+            0x12edd647677abeaa0d99f2e4596bd64e1604f69552b6971c8ac3b44e7cd10a2a,
+            0x2a1d5873e48e00abde4902969a921782430bec7be01a4284d0455219675df9b7,
+            0x1470d1c0f33d2d5e2b2098376d16cba0738c4fe278ccfc3b824879535448338d,
+            0x16899463366b193f0dfb39b35df617118d55074561482e0a91283bdf40804051,
+            0x2af12631ed9ea59d387e2b2aa14a3ae1d28cc496e7fd28dc9cc149120108369e,
+            0x6eefb335586d1eb862c09c79eda3712bf64ee5f51913c14e64787f59ebd4fea,
+            0x256768779e0e07e677ca90aa7e514bb6eee69ceb47e749fb90ac20923d3af52a,
+            0x5ab1585ae26b10fb8645be74d3e1afe99f25546e0708fd16ee2493844574dae,
+            0x9b5ea9a096902a104e5b1fe5188a98ea78a373e7f9bf27f6218fd5f71f6e6ae,
+            0x2d34bed47cafecc7b37ca25901e9f5e3c658950001d728722dc56b71e2d4619c,
+            0x2d0071d201824d43fb057a0a523c701d2b8a37278b5178c18ed6910cbdceda12,
+            0xa770d994f92bda5a4b63e65ff8cc35f59ef5dbc20732e1580f703d41b5b6281,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1949dfa21e6b27c70609ed2bcc7aaf4f6244e289500c48fd1245566837cc74ea,
+            0x18eacf1750c093e10b18f45702a42766f1803f4d2ad79399b86856d56d51f25e,
+            0x29c3379e427d4e89862989d63a72321fb73197b029092ab8bf24c127183cdc8e,
+            0x29fa50d3448bd783cc59afe8975b7da38d3410fcce680210b3295f8af30929e1,
+            0x1bd6d35f109a3549dc1da7f96953f1c38f069e9a44141e85e69908366cd65823,
+            0x2a58f6745b90dfe97d3f89415e375c43f464351bfbe3d140cabd8a343313eba4,
+            0x1e34e898a082d5a1bb452870e41bd67cc5932031ea8afbf460d6fe4c253ec6f8,
+            0x1f2884e10b6e90a0bb15c6ec37d269489c35a9fd5f2f8a548002cabaf189be32,
+            0x1297717d266d0f55d1a8d83e85c22948a89227f47408b0a6bba88cad4e4064fb,
+            0x2b9d9801a1b0a616582b65b84d5b76da1d6f428807f074108cce867bf1ecac7,
+            0x701f771295984199a107564c0918dd3c397380bd47e0a9f0cecc0d57dec9feb,
+            0x1a294c810d83e3f3b9bcf709dd22b810055dd3e6a11e456b284dcd40e084a263,
+            0x10103201721be8dfdc55548826c8f2c6c5ac249a66079509091b71179eed1d4f,
+            0x22d656009cc9ad0ea9a60cbd4eb058c820fb5387714d8b4ff52609638f3952f1,
+            0x1d493a429f8db9f3df571b9eb1d25d425a09d75e6bac7ea1c8c0da141445ba5d,
+            0x3d1a76c0fecbbd1ebc3b20370894284bbe97b8cf7b14bbc95dca839ec9c4c8b,
+            0x230688c1f26ce65d683b5a4033cc5b781ff38d4a4e28aaeaf57b495cf843b0a5,
+            0x159c9adea02eeb1276c2e1600930929edbd7e47b1283ed273db5ebdc596bc672,
+            0x1abb8a81b4629456b639965a0ffee6ecaae145990d97b2b05546f47fa416e57f,
+            0x12ad1b21a9c02da3018f187ac6a54e376f8f71fce321933f5ec8a55adbcd0ee5,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x3c6c55cca4740582956cee40ce3053e89ed882ea253a366d07dfc9a508c2e78,
+            0x1fad53f449b581d0ed39dd41975d9330768364c1a97d9fd511d0df16cb3f408e,
+            0x1fe8bcb3f7fbf9c21fedb5a0ae4dfb7ca275d535c7847b23cb74c18251b726ec,
+            0x218b93667ede394ae16efa07315ff7616f6864cb8293bfd3418f9d5b14756396,
+            0x41a688c1fb421db3d8716a64fc39d0e0677a5c43de90fd04dd9f3622baeb3ce,
+            0x2987dcb79171d214817a006127171695659ea28858ae18c6fa8e505a4ea02033,
+            0x14f45ac12d071af305059de0fc028778d5c1c8afb476d5b7b3ce2ea6a5f3250f,
+            0x959f1dec81c5f8225c1f2ff4ae2c67c73e4d379756f40ee9f691c82ee08c6e9,
+            0xac0780131779ad691069ecbc4f80886c0bd9518d9e04b99146d29bd7d9ffc9c,
+            0x2a7e23e5aa5668bc719b0cc26dcf781d2ca359987f1bd6f9099b953751c61fbb,
+            0x92c0b897d36323123bed6c99dcb3b50e397c722cdfaaa9bf6740907a4b653ea,
+            0x29b1674c1e4b705e7fd93d10a380145be75934710cf6b43d24817ca38699e702,
+            0x25db198e1a5de34b6974aa38ff53572ccc4036447a654aa7f068602233cdc0c1,
+            0xff3174ad5ae186606ffacbd55936b65838c2be6a635bf8c9941652a485b8c6d,
+            0x1bafb08bdbc32bf6b81d2026005e3ac6390ad3e36f9178be21034262ea674e90,
+            0xebcf6fc297c34138661ce9235e7c0153eda1f0c99173970442976ff849eef13,
+            0xd729230e5d6913a779746f2975e35197eed83aa613b7f9dcbfd2f713b8740b7,
+            0x20870e26b114e1e20c70ad2d6c3c29bd78918bea5bbd7ec8bc0a60980e601dbc,
+            0x84a3105ccbeb8137931901cc0a48ca7426e5dbe4d0095c11d63d0f91c64dedc,
+            0x1b1e9b1d59d5f4518412a828475ca50044fdaa1c3490491bb508d7296436d5bc,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1f4bea0f3c5dbf0b4261b9df35e5cf6a5cc36973d09f0b35fad3dcd0a4c69acd,
+            0x1222849342a144de2b23e8bd848ffd096cd3332f57a245dd3ebfc26032a6186,
+            0xca7b33f1129a98d404e882ed0a70737543706248c7374d9aa6470583b24ab7c,
+            0x18f80a875ca2972a4d13d41d81a1cec56cf384780b5738e59988d9aba4cbb66e,
+            0x2428fdee2ef9912f4693ee9c2a59e82c625e23e9af79e990dd7884410846f8e7,
+            0x154781a2b5c4401f6ad2809fb9ac23f3136a8e3950ea6e3f084600a730c42d95,
+            0x2c554db641533606c10532eafe2439e48d2925c9d6e183dd85f0c24986ae38ef,
+            0x3b8b288b1e1a1fd2faefab9b4e00d9c503f8574e67112bbe603eea37b97ec18,
+            0x93a9b03da561b4ed6aae3a98f4d2a9d1d28146eb0e91464c25a0e8f2f6011c0,
+            0x108843f8d4eee7c9df86bd9a2dcf003d3ece8c1fbb2db80a0e225597ccc54286,
+            0x1f043a72cb5432a4c78f14505ee630bbd2367e83f18db047defb3ff1a495715d,
+            0x15a8fb06e0c14c181244b3f43d4967e28ba32bae1e84223037abb1524fc26413,
+            0x1ddbc950967b1769cdb4f8684b34d9bc25b04deb0fe5fb117ad609a5b7f4049a,
+            0x246a58e326b240d18618908b13785636f051ca1c3d5accddcf7cf4af1362b5c9,
+            0x1cf99a40b8265758ba68441a45b4993993d732a8b3b88b4d983a62044c0bf7db,
+            0xd7de5619f4c546050439e79af5f2d0b964ec40ac92ab9f33c617623c9d0479,
+            0xe5e16504bd5429f1989950e8f41adacc95bc94789df4f29eb5c623a9ce4ad87,
+            0x41f35a7896a627bb884f8fea782cb487c872dcfb82dce7d0e6941765d1ec149,
+            0x1537debc183e50b25642a94332739b9dfa8610ef8297d963ad4f25114897675b,
+            0x2d702440567bcd957920abfe3ca1796dc105a9d6d69df68f7040d45e14825154,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x14849e30e423d2818b033824be79e994d3b294a7745d47ba7a04412c976a4d86,
+            0x136803dc9b44527a2831afd600b224d3be36a4fcf1f1bb12f6f3d9c78a49b55a,
+            0x28ceeac4f3b856158657defc6ec2d98ae8222838625951aba51df3d92323af9d,
+            0x24e2a9e2a33795f29eec4e3e5171cd1a4f102b387032736248d51da2ca097dba,
+            0x176b7c931c84fc51a695bfc635c9b2d7e38c0fc9e39119a5d270be388a7ecbac,
+            0xd230fbc8ba30ea43febe4d7d57cd646c1679a1e1a8066637e19d7b5f783c465,
+            0xa3d177852fb1432eae4cea8005dffe984df233705a362ea87fd318658b1b10b,
+            0xea4e2627f1b0f14a84fb72f14025e3f2d4087b5e23e197b4be18de9bc5d07cb,
+            0x2b5a5586e185e6aff9ca42ddaaf4a48fcbeb342a33b7d8c30334f69917695c18,
+            0x930ff45950e0b3a55c7b5d59b1bb103f43dad87f10dc01af4f029f1334860d4,
+            0x13bf29d884e6f2f7718c62b49b2e4488f78abf3371e60ff6a55f8fe614093af9,
+            0x1347ec6f72f1e6424af5dc07e72c8ed704c1de25df8d0298a06ce875337f16d,
+            0x7f98eec37ea11c6a953ed4074e0de0319c71c5d80c6d9a7f1a7ed1642cdb3ef,
+            0x1fbd5467ac28426e82ee95d4e67c1bf39ddbb0d00c8edc994d01b085e81025f0,
+            0x160ad25d0a5b481711dfd537166e9a758f46ae98705c09a31bb5dc9ca672e06c,
+            0xd1b059d762e26c7b237c2529c1a2c0420112b04b34071f365768e31c4ee44f4,
+            0x576eaf22ed6ba9247a7c1cd5f36da28d3c82fee37029d5a564eae4a149f2ca7,
+            0x189097900e6ed2067403aefd8cb2d68f8be1386dac2cb067f346d027b92c13ac,
+            0x1d611f1ac08a2fd6b50b23612cd9a2dfbc77d3f1f01cdf0c97776885ee5f538f,
+            0x21966ac51d732445609cafb1fa452a675d16df7f7c0c932aa136c7914da84816,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xc4339f0ecf040eca09a8ce68b829e18174e1838978d18ffc85013bc4569bd80,
+            0x20bf882ac8fa2b8a798c0bef93c8faaf79248ddf7520bf6615b8d4438f3e2f4a,
+            0x1e097984b47ab98e3f1af30e8db0aeb16dfb7257a5d717b74a0302c0c65be5ac,
+            0x2124c450afb451c834597afcdeae34d494f42b83ce16525ddd426897cb85256,
+            0xae46f4aac64bbb73cbc4861b9d67dac7a5b9461185f1af393d30e0f14e6c86e,
+            0x29608e35e4618f2d31f77f1222d8461c5daf83f8f96a1c3c22ece574bad1892a,
+            0x8dda504925b8e72976d7225b9348b621d411c42725054f92bc5ac7f20ee1063,
+            0x2d83e776ee847bb606165d71c5395381883eefe3e72db208d05671166672892e,
+            0x158c6db4fa12040276f28c52fc4179c40c0b992ce3ff614cc8a335badcb5625c,
+            0x2ba81ac87e1ba4a0abd35ef4d5e708098d5b3ea59df026301d29b0c639001d1c,
+            0x297ca48636c22e1b41ac10da84d18930f4293297be2de6724d4a1c927ce6ac92,
+            0x1ec2fa366088aa3d24faa8b0857b0ee947e7ac412a5c383d80a52219e3036715,
+            0xef8e90ab9a0d92209ebc7ae7eef599134faead83d4cdc6a35e11486f256f91a,
+            0x1a1ba37ce6b31c46f06b166007b84b1b5a729277769da12ac45a05329b1ab25e,
+            0x1ce58fd6bb4c70f222a00ce15e034aa7f951e55745f7eb0e89d9945dc648ca8c,
+            0xc96b4aebaaf211ee53c2592611cbd815cd8ad79ab87eb426ac951d465200f31,
+            0x2ff556ea91ea4010ae322b26cc3dfdde21b77814aeeecd224d83754b6fa95b91,
+            0x51d4d2e3822d407607a763652423f88ab8ac41d836032e330dcbdeb89dd94d5,
+            0x1f484dcbd4ae03263c1043e2c67dcd871af9f682bd063efb99d6f2c1f58dc89f,
+            0x3625c6bbbeba41cef4419cfc7885a6acd236f23c10bc21eb96fa3329b0aa808,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x132c2bd9c3df321b8329f997d51ea4756f06d20599a69b00d9f5d327f431bd9d,
+            0x223271db36c5a5b734893666d05f8c23472da5750c9cc2185251d1ce898cdc31,
+            0xe442d13a0489c8ff0792219ab95cdcb6aac03d12617b498eed4f437e9e90f8b,
+            0x49bd7714d013f9d4ae5d6b0d8a1966e3b6ec2991f80938e99496db12778c62a,
+            0x16863ace52579a519dc0983e73f391982f34daeb311b455cd75b3c7f75c4a406,
+            0xb043bbb7a835e934403443a871e8b09789e825314c553ddb593c117ed9f7a29,
+            0x2233e42b11b31512cd6662e6e2d0f6123b84428079fd25823e39ac7be086c286,
+            0x1eec2344b54ebb5d2d89282cef20b5a8297eca522759df7ee82f9306cf7013f2,
+            0x7d3c2f7ffa7d307b1b80cfe7fc4fdc571ee008081d1a37b83d83f928aecbed5,
+            0x2040b72eb4e1314e2c6fe28b0e10cda2f444baa97cf15b110a5571ad006f36a2,
+            0x968c69a272239d4657b02e1e1157635654c2493c5dc21c80e459c36943c0c7f,
+            0x113daea091f19279a75d148f3407940605147f41277347181a2eb45da5e1deb3,
+            0x1db9caad8a73497abeeed4ce12162d16c8ea56a6ba6680cee0253d7010c8b0c6,
+            0x323906b531b036a422544f9a789b4818947bd7e1010a9d3147dfb298d747c97,
+            0x2a17b02e605c66f2e9191f6001fe8d0c054e9fdd72aa912d61b14db3e9e5ff36,
+            0x20215701f065bea87da0f51f31fb17022a2ff12ff86a3a7d50bf196b9a1793b3,
+            0x2ffb3a8d5050efe66c798eae2e37fcb0e75c8d3098463728f1258d3d15e9c58d,
+            0x42aafa50849b504124ea788b0ba7d398ce77b42c09f25618b1661af76c42d7c,
+            0x1f0760c47e75e2988c7c5f2729776fd656ca950959500807c33b15d2a20b8d0b,
+            0x1b41324592d37fafa8175af1dae1daf093b7bd074de9dbe0f47bf246fd338295,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1326782be064b822cd54a82d526e0861f69cd054922b7809cb2f1c685b255442,
+            0x140941464435a4da425c24627a01d5d0620429caf2b74c1cd8217f6ec0c5952,
+            0x16d038333ef8265b4437495d35251402386b448bf2c652bd752875cd6abdd7a,
+            0x14b3bded0283d8f82452086053472baaa94214fc64e23eefab04ff3a666ef793,
+            0x265423dd06e1bc30d7ba50361df7b08371080b61cffa5cfcb4de6b840cdfce11,
+            0x28c4d3106aa551425285a62673853db6ee69f820a38010b1e986ecb25a517c43,
+            0xef4196f06abd4be2c6c77cdd3d9fc71b7056fcf82ba878a3c0f4a642184f33d,
+            0x9ae72038e07e063172beeef085b160204d41fff261164869ddd3b35aaa852ba,
+            0x1e653d313dc085a19473cbf173a65a752d300ac1001b2cc6f868c5aed1d5a957,
+            0xfc8d4790130083f7d876b437a36a5a07861bd3fde394a7297affba00cc0266b,
+            0x8889eb9c02f2805d59ad7c1cc11f1f8eac7d10cabb324cd28a4ceb64fab9335,
+            0x5e2245fb34a0b6d4fc8c7d9b98faaaaa578a4bc650b9ccfc08f2f94596579df,
+            0x1f303116020fcf151af2121de29d1237c03b89d27ccddfe6283c1edd985a8e75,
+            0xf0deb6bc06f2954f1ff6e7f2b0f5874a40a67621147f49d9208913e3da2ee1d,
+            0x138bd70bb31ee416686431f11be6768999f8a881cd5ded3fba47b1e715b98a76,
+            0x2323cc181a6d96004077fc8afa78000b67af7eba4a37699675326751ca3587bf,
+            0x2cc5a935240839d0916adf0ba2a13b373cd9a249f3dff29d4e636ea39bb2d47c,
+            0x2c2f7e211539740f135771a5613be1b9d5626f84bd9bd3d086f6e33e497d4301,
+            0x23a3b12944728d9d8aecd5b9ac2c1e8683a6d6fcde6de09f9d4981576f60bf7b,
+            0x98c6085a8de8062c4882a80a9b53bf605cd6d3afde925b4bd97dd0ced63a2d1,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2b1aa48ed061330641b7610a5ca3ba0397bac5aed1220abf1ff3c053799d5798,
+            0x27cfd05fdfaab10d703c5613ac9c30f2fde048b85315e4cad39a76c2625878f,
+            0x2c6768184cf84573a0e970704987f3627cf4f467e72d878aba9ff0e6c32c76dd,
+            0x1660e8db6fb22994cd208878039549f85464278a6d593dd871de03c5fed8233d,
+            0x583531effd84ca69b517fded392f636537ccac39575313c04564411eb381b38,
+            0x1b1f369306d9312d665302317d2ef8ba8a5673364ebb84b82de156accbc68485,
+            0x26e1ae1e46325eef62e0ad0702b7c20411e5687ac8bc8b0c42f2294ad511e36a,
+            0x2267a248407bd8dc0be8d6d60a901e6a6f63198e43ce9ded8b48f35117cca600,
+            0xaf3dae82886360e75e265f24f928417f3404fcdc18896104e07dac544146d05,
+            0x1322272068ace8538671a961e8182ca7379ae8066dfa8824036856446ce68262,
+            0x2ad6d87af121d4b9d388dc3bd0fb2160dd0d43deb5d5fce770b3f66d22a865ac,
+            0x2db628ad83bdb8c87642ab36796e64464a71c8dcc07db41090014d6824e9e55,
+            0xbcc76f8301e3daafd571227cd8dd395fe5b1ef2a88262aaaa30eae1be85a66a,
+            0xe953f3e2a6ea919a39845e34a8fff06874f40fa0c021102551523f0052f2ac3,
+            0x4ed6096b59252ceee6dabce4945012b3afa929619e124fc1674f9742de6ce9b,
+            0xc45fabe45fad457d5e763ba6f401e038a8f05187a50156e2e4f73e9eb0c1521,
+            0x9cd9ddf426f07cd7ca72e4abbc3ca38063705cfe04a002396d91101f41a8ebd,
+            0x37124c13e8f5393d02c7dda6fc39b986e10f7eee7eb4d8e8b6798aea8bf8116,
+            0x12326c23b50b4f2ad7ad2a6e2f81e766da9dbaae3a85d5256c36f54f99504c10,
+            0x27097f5dd86e6bd0c09ec07ed1d565846382d11310d53e11e4ad9dadda2d2a2d,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x213719ecc1401b7f148d90bb4ceb0cfeccb1f84a03670a65cf2071a97c55188c,
+            0x3ce9eb2e5a78e09fd8f99bf3677cfb69d8d81fac2ed57a3796fda4c4a75e067,
+            0x2085f6b2ed31422f2ef8c9e8132320a9ea78f629f40050f9ae1f8d2212822423,
+            0x18c42b10a0239a0788ca80f40bca9eceb54cce28ad7025ad73c0441f46e25d7b,
+            0x2296d46885d7edc9e2f4552a8f61e0320ab91104076ba093415f525ee1bfcb4,
+            0xf464a47774953e1647c8823c1f0e7965faf6e8e51a392f342e27f6b7e1e3fac,
+            0x1afa5a730a377f7595ff598c11a257e2b25dc96a71a536671e98c4fef8fbb126,
+            0x275f04d5ff1c821ef2729f6851a372c7db62bd3d45b68fd05375753a9ca38ad6,
+            0x1ab45e9a2aa1daec4586bc866bac1bae78d8b8aa112962f34c5c19a4588f11b1,
+            0x2c2b2b27465ba8f6c19c1b3e4b52ad9e76df8671ac3817d8c467fb7ce1a0d9b1,
+            0x3cc2c6cd22dd586414a1f19bb9bb0f8b7dfde77369f2033f036bd19412410e7,
+            0x17b6daf401b7e08bd9c414d067a6cb484ee05cb2e7c0791ac2bf415e847705ac,
+            0x43084224ffff7fb2e73981b3d2da64588e746e1ff0a8e41021cf814e846cef3,
+            0x19d25137be34aa73379f19107fefaab7ed485b5d49124232a91341747818b125,
+            0xfbc00ac7aab927fcab38cc1f033d0c79ae42cbd8af8b9c676235361805f797,
+            0x2a452e57d835dfb153c5d5ab716c615586a692f22ee8bb70cd32ce786675b85a,
+            0x14ee41c5beb4f4eebb844ad27cd712b8b7b7d3bd96afb18417b0bd83650ecf59,
+            0x151e1b6f64a2a6ac4afd3ed3adcb59a2f246e4d018a85a4dec29867998bdeb1f,
+            0xdbc95be9577eda26c26b97276780a2c44046eff2d20ef3e233bc513eef1d289,
+            0x2142c00dc3ef56e58d4fa535297d2349fe5a8720609a459de7d10ee2ac206735,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x14f9e34fb8cf902037da0287f7fd59460ee42d86542ea027f5065f4fdb362030,
+            0x1af072ef30b93499a21687071d9596f8c0720959f5aadd473015a320f525f3ea,
+            0x1f79f8f436951eab483845158d798af4940c43b6c7606496ac7787e23d513562,
+            0x32ac1327d91fda3e58b64a629d066b7618b0d2bb14bf0054f8a99ea94a7f9d0,
+            0x1690528ebb80ebae626e4c7ad7808201106c3f6958a8fcccaafbf105bb982969,
+            0x28d5726bbe2136f717cba221424342090f8922b607e61fddb1278c9090879724,
+            0x2b8c6cdb0da43e1a2436f8c43ab3746356bbd0a40ae0f4bc282c8f24d205b2aa,
+            0x1057e1a29e1cf4f016b0ae4b377cb2946f4ecec14d8a9e906e8bcf994968ccc7,
+            0x26175299ec4bce279b5cd865110cb0f7253e035e4dd530dc78e98dd167a02c40,
+            0x2fe4d13a9ea0682f7c6c79e2faa642823c6ec6166864a3becc3aa96a06023078,
+            0x8faf60f2754c6f88af83be51d4d8fcd91a530c7fe1a7e15c04672be2e26ff80,
+            0x1125b0b9078268105061cd44cfd53e59b4441c494e4e621513c0e2a7897f2ac3,
+            0x2ca18674217c0814c200984a2e6d96fa6ad7a93a350ccb857f291dfa0a6b7c87,
+            0x1b654e8ca3777847d7febd35e71555b5fea755b167581b91b8e66e7557a13755,
+            0x25cb5e571aef3c5ea542332f3cc646f940ce1ea986284074b9ec9a26028fc3e4,
+            0x10152a1913afbe44180af20ec59ec32a3935fd2b531d968f71f0365054faae15,
+            0x27d1880942fecf4f9e46d11a1e3db53c0ae9385a676104de122c85c67a61b3d0,
+            0xb4adee6ba01707c232fc173d7db356fd6dcba566709cc81dce13db425685c,
+            0x1e4ce7b0213b39db08d07fb861278fc32ded0de6232c7e050f9e93e4abecf7f8,
+            0x9e5542f2b8481d63429010b3f89aa2c01b07684b08c406d0c85cbd0fd01d2cb,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xe24744fcd2826a25131911f4fa8edcf83597f52c72906932a58f3047f9d16a3,
+            0x17a27cff4f6f9a2f2a1bffc998f0ec03338c0fc3d3ec9794b13af50b3ed177be,
+            0xbf90dbe6022bd7df688eaaf3b9030c5b6ad0c3633b351abe5905c2a2b2eccb2,
+            0x2678e3c1f390d5459696d950dbadb7b264f8284ddcefaebd120eb27e2b19783a,
+            0x26df8104d4cdb377d22ad344e942b76261b457f52d8498fa69de4e1b8ed37599,
+            0x29c0d6adeada68a869e934d2350a77c91eeec6da2c0d7dd111b8f03d73a2f54d,
+            0x1517295c7a2561c1186efce6e54a6070307540b69bffe623abffc8984451bf14,
+            0xd79894bd7300df6fd04a93836438358cc4d6e6921da38520a04fbc8fb4ece95,
+            0xbda733ef7b53f5843811029b9a5c412237a72b96800bcdc6c71223d57157917,
+            0x27d91c5d822f56a78c86f2422ca4786b94aaa2f3e066fbeb35b81c7e16c0a1b1,
+            0x1e6dd8c7e739fadd91888860adf0392f260272a68d32b914f8862493847431e0,
+            0x115d86835c20a27ca16c0aef5afdd73a1b6b7ca6f12116720b235274ca89fb5f,
+            0x24df0f59376b1b5e39d9ec2aad776278fab288047a2df5df60990dcf935aa50f,
+            0x45885167ee8e695c6ac79eaee96e087946c584049012a309ab8ec2087491be,
+            0x44b70f5e0df4319827685be272a32a36ca3c4148b97c13bdab2bd0fe365bae6,
+            0x2cc8eb658bd3afc8f4209a1c99566705cafc79332571f133979940b14d736f15,
+            0x238c44c84ee349b63030b0fb02fa7653e547c4a6329b9902de3602c3c4fdda0d,
+            0x19a32cb6029fcc93db2b01deb8264a9eb157e995ca21aa0e335589b06ff77be7,
+            0x1c8612ec98aa9278caa8cb6afdbd00c02ee2f551d3d521ff5e9f92748557933e,
+            0x2a6509f5e770cc50d718f8590f5f9de7748372d2d39f59a859c9211ee4bfd50,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1bab122c560118bee8f3e7fbe1712ab2b2a7312af61fb9820b77dee8d44d6ded,
+            0x27172e3eb51483dac0c98e32f05fbce687414c3a3cc27ab1c277b13ce2378217,
+            0xa9e3d7f3ef34d138cdaf36b92bff06b4b73bc9ce36156505741195b98d049b1,
+            0x1eca82667b9ff6adea09ea840efcbafa5e206c97037e01ffbb28412fd2bb44af,
+            0x1dd8dfcac157843cf5f94f9b10baa21f00e02a2cb5193944c3d3e970f910cd77,
+            0x23a1e6890522a89b9b88d7db407b00dc68a40692a366936de0eb9a57bbf1c219,
+            0x204f236b39b9136dc92f8135192c87c98c7984f1c77cb6064c71ec047975ff67,
+            0x2c7480b893a528fe00d1ce1e4d22b330bf286443fa443590a63e27aa91eecd53,
+            0xc5370a183a6f75b698c0fc6deb4447cba5de9ef2002cd8eb2904adfa4645843,
+            0x237300db179a8dd6b6d784735cdf4640d61d44b518ea8848d8321cda2b7b4789,
+            0xd9c58331bea02ccab4b9ef03eb202f1955b266c6666ad886272fdce7b289da7,
+            0xfccf4375bda2c5db513e2dd0638ea1d2edaf41c2c754482f833e17c62d92019,
+            0xc414e955b84493a9a6c827f24c39f62a9f9c2c8bdd9f76c3884d16217d30c87,
+            0x20544d89fcc7941ac4972e5528300d0c35d5a650b8ff51f72974008a312d40aa,
+            0x1af59412421b520c1171d8b74057dbb01653f41082f856ba5aa6abb79a43c354,
+            0x2fc1a459440613daf728da1cf3a258c093bf41706724e6260afcecc13d324b51,
+            0x177c1e93ee0ed483c73f148fc7f9891cbfc36a338075bc01498a69b0e1f8c49a,
+            0x98c005b2959ede9425452eee49a4b0803237cf111f046511f8d56bedefa7682,
+            0x15866d82d251f9afc692c1a115cdc5ac28b4771bea862dc26643e6db1d61978d,
+            0x2797e81dc6fc1e231f5051d228081b46fe53fc394524ff424963da9a91070bb,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xfd25da5fe62ce50a1525fe9e3566e9ff0c9587302f778d7756bd05d8c6aaafa,
+            0x2a1a6a789e908952cc8c2e72ef95a937179c9248b091d016f28e38db12312308,
+            0x2bb3bf8f61d1ed85e2175534e9a5ba3d17dcadce45eecb3d58749a03e2b04fbd,
+            0x1a30a88ce2e48fe060eff18e1c7bca6257b8e39351823a819daf303f5fe641d9,
+            0x5ecd325b357e47482e4e749cc8305b45ac1e65aa7ddd915ac37f3098dfd2d98,
+            0xfd33eed2e51061ed5cbbe5de05b6ede9152f36b11468387f518a997e4f72214,
+            0x95e4c2caedb1de02a6c60b086b8d8b67b9afd186f65e158d2748d2514d37b0f,
+            0x1842d38786dbac9400929648db9205d259677647a5024e35caab08260744f013,
+            0x203defcfa6213a500d5a788db1e0ffe30874406355502644de206a7303dff361,
+            0x2941a9e3edbd2aad6138cb7582c8522c1ac4885b719dfaaf49ab0a138c24c657,
+            0x10ff2a2017cba3c024111db07e677587896bf77e0673a928c5c2c9edc53cf2b7,
+            0x26f456aaabdad81d33930cd48342be34c4884d52c17c604b45e9bd80cf3c19c,
+            0x28e34a4031ce3e5b92d5d92f9b4733668ea65762bbe5fbbf82cb2eca7e208d9d,
+            0x9479c03abe2fc4bd11f410d7fe958aa64aad1ed9ce46de12e16dce1aa9007a1,
+            0x1901a62758c3b95378ffd836f543a2c2c1922ebb864000184b1a29167ed608b3,
+            0x24bbe4299e388e01c96d7de61ba9e9ad46256f8d8c186b2e3a387d558cf912ae,
+            0x27c84170d0a49798dfc9ab4d6a96731d0e8de772ca951c3ebb799378d22033e0,
+            0xf12a9b9e0cf4da08c085755f42f2c83cf9f9addaabe06fedafbd1ccb7696e1b,
+            0x2e34fc5a79f3d7859fff73ee159f8a963cc180ce2351f2709dbcbf6ec0a2d7e5,
+            0x6d2b2ce15705618d1574127c9324560d2c222065da0c669ffd2304a1bd31661,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x5b22e29f9914100e09f1d9faa6ec48b849d06dbb567b978c8e2875b8eddf2ee,
+            0x121d7d80eca14c71d3a9d568d1fb3d17d848312ac21722507029ec3df61d64a0,
+            0x248644294d40fc12cf53892614ec0e91eb6261ddb4de5a54590770b5a63791e0,
+            0x8fc50ee296f9fc6e508a23b38d180aa92fec743bb5e62017ee4a3f7c98aea88,
+            0x2f233d2487f18e22836df893982a593c74b7294f6cfe3ba3edb8272bd2559179,
+            0x10f6d94022fd2c078fc6dacb1532820021f50f288ba40ae4016366dfa703e8d1,
+            0x37d5df7e15cf95ac9c4bd02ba53e6d03bddd677a412bee4e0603f88ea1d6ef2,
+            0x12354c8b1801f10dfe6c394b08317c7e86f49e212ec933fff49d8b26553f3e72,
+            0x79679dd2756be024feb1bb2ee0aa5061a39752cf710ed6c9cb588f33ede8d0e,
+            0xd3b424ee9455f137160fa1dd534f67bf068cfce1913a075fdf1cae7e8324ca6,
+            0x227338281ee7da633b4b3938f5bb981f838c40ade4a0710875147f526fbae49,
+            0x234ac22358b519377341651ca93dad434807cce449087bd4384f46fc732f7997,
+            0x2e0c95ffbe680fa7622598933adab2a57c472a0073bffe10c0284739b26700b6,
+            0x15e0c89cc6c36a7db841d4270855d1d9b8849197f9b08131b625d5a6d9ba693e,
+            0x2f8952ad83b1ffb3c1a4fbd1064faac4f1c9cc31d0ff156a17478a1e3d255117,
+            0x1c7c48183ec207dab68d73aafeb96047ccf668318c084453e495ebd5f927d173,
+            0xecf362a269cbb8e56c2b0537f108a412ac9a3c6e351d0d27d365a4db7cd75e8,
+            0x11cd56f9dedcb991c0c6cd9c9a0def911edcb915dc1904390782a7ee90d0de8,
+            0x1ee74e2178baae842dd9658694381cc93b01592c655160923d40f4af2b53eede,
+            0x12a2830e24c8bf4e9c7f019526f71cc57bad7995f38c6ed20306bd7b00f0d7f7,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x14e12ee2c2f82a572d97c0b811a25584bbccc9be1b67ed1aa2141b2cc793fbc2,
+            0x4f32291e7636221ba7905a9a3a1cae812ad570260c81b3ded9af33619fde33e,
+            0x8a081bf1497e5210f6e0413c8b510f000fcf4a46be0a1b8442c5bc7e5fb7751,
+            0x284571ffcffe707510d0feb89560623db7e3bf57c9675b02febce95fb7969e8,
+            0x204b298a08577c1269dfb8ec9b4b3b502ed6fc3303544047d56d4135d3c01ab8,
+            0x484b3ef7bcf5d63934bdcf53d8aa372a0b0363b0241320baa3701e8a1d0da03,
+            0x9da34491e52c865a5b080cb9791a1fb80152c04335b1dabc34ffa6ad622842c,
+            0x1fa3cef56374f00878372c54070d9c41c5ab9ab1d385968daf9ca2ad67d494f5,
+            0x20b55b39b8df6f86a2ca381e2037d64987d1844c599feb2829648955ad16f758,
+            0xff1c5369778d4fd96e295c21bef4dd4648fad9531f669e704ad2e4178674564,
+            0x4c4c92112d998d5736b3f46120404369c9c0e428e47577c857509fa556a15ac,
+            0x27a72f4b6e9896945e7d584e41fbd3cd5f75862fc6ec94651f5033c8da34cd05,
+            0x2a1e46726ed9068504f7becf06cc70a5f645811bd65be579194b54486158599e,
+            0x15dadcb67e30b77d8b1e5dd79edc36c3d8d0afb29b6e7f0207455e92a301dc93,
+            0x29c1bcabaefb4954743a7a04502647c11c9f18de67e21c811c8d2b9f3ed82dad,
+            0x7d089a851d1c43af05e6c9243b69b77b12f0c0b0dd25351c522ce8dd99fe5b6,
+            0x1003d2e1e5368d1318992f181b7cda7786ec3e721be4bb89089bd794c6e9fc6b,
+            0x1747c287ece311b5484adecef423434d71ca807924c54a53e31109e6a502ea15,
+            0x134eff601bde8da30e62898b2e05c17f6e74d4ac31919c41363884ce7e30f017,
+            0xa2d92f328082a3fcf5809958671e304daabfdb5708edc2cc207175526ba3e27,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x4ebed2d43be5a74e8a00caa83989f16c0b9e82194db68d072226148c0a3d710,
+            0x29ab24663cace590f69751506905667079db84d33f78204a31c93e7bea1fa839,
+            0x14351a07d387943cf46b65496c66bc6f3bec8ea200d622074ac2430eaf521d78,
+            0x1c423576a075f1d7376168b207a6d7203712c523c67a9d38882e8642c8fcee02,
+            0x2c0564f1c52ac2d9f46211743b632ff07b210916de258f83d04df68ba0e29228,
+            0x7ae7e44ebe17fc24a06c9caaaf787c2f007c640faaac6bd1790793712a69525,
+            0xc4e1c566871f3484afba7d364ab755b839b09c5771413b0c31ed6a0fd2f4293,
+            0x17c4f2873e2da004f2eddea08a30a9cf2e05f196fd3331b6f7f1227ddd8e7fa2,
+            0x26f0a8ab7b5b0ac4593c98a899ed92d839837d520c5f6f0afd65da69a1205cec,
+            0x94dcf41915c6c7ffa168dc7137afa6778076c2b63ed63d1ab1b787681bd60a4,
+            0x15240235912d9c5ead8feecc29a4d77d8da47e9d1909763294ea18c027f1bace,
+            0x2bfec6d12a548b0fb9fd176c7200df86c3bd785d86b51b2076bd9d3e8247312a,
+            0x15954dffe4cd018acc436b70b029e0146529a26cdb39151468767b88c80ac82f,
+            0x1f430be26a11f722560b348b1c5b526894cb458d8a30b49887713d76368302da,
+            0x1360de1351ff67b63c312a8cacc2a465bb82dfdd3d792244068292aac083c8f3,
+            0xcae448f98a72597e67867a24eb6ef2c1ce5d454fcf1c9eb4d84d21ce81590c4,
+            0x20e9336dd103f61a54f27fab65e5fd1a317e75fbb5b22a81fff27ae4c8afbc95,
+            0x2e36c0ee853342906730e7a2061c3aa2dbdfefbdb554b3a330c0ef34bba74020,
+            0x21be1082ecbbc3a316c9d73495cc08c60082e1c20ad3d4eeb55553eef1a96dd0,
+            0x2c7cec0d47c779dc5b614efda39049642f1ff409a40be89cc93e29366df96dc2,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x287c8d33c0bd8b9ffcc38d1a3501b462711a41833390aa6291b5691321f34f3c,
+            0x524f490297bfff16e253a88a02b039f4d7be41c62a47525d615558fbb91a31a,
+            0x3a6f7a96eb42aca86cff7e2417d245dc19e8c7934e91f3dedb429ac4de7c61e,
+            0x155dd1bf1b5319c5993ffd435ba45f0a0ac8d47ef063423008b858ba214844d1,
+            0x1970a0db54455db508f369e376345b47d7df8dd58f6d69cce8330ed48723773,
+            0xa17d8e77907e26a6c23a52ef2b39064da014f030b5785f3ced98a8daaeca3f5,
+            0x199b42a0db3b829ede26736dc7fef94f2f211679cca63e75dfb6a221d4897807,
+            0x1d492d7c7daa80eb64f335e9cdf306b0be4b418fb7edf32eabbf0e89df5b8e61,
+            0x17c60af0291bf796fffdbc57db59d03897c671fd729bbd4c498e6069d0671ad3,
+            0xc646e58e3442bf43b2255aa0b44c45c87bf5c947ca5192eb906432afb47791a,
+            0x27bc23b6488e38e2ea87dcebd6360dd420d7ec90a58601eb1e312c6998a952b3,
+            0x1c50a70dabeed7c79cbe2f91b2f9a1d3ca9ccad68afa0a419745160b03cc07be,
+            0x120ae724abcc772ec7b0ac90719be72e9c17059b191f6e562620484e691f6e4,
+            0x69f84058a0565f943c4f5cff4c939581975165144f1d21c05217d64978ad803,
+            0x14a086d34d0cb4c050cf996b086aa3a21e451ae658ee0b037e7b0ec28f5905bb,
+            0x2fe2f8e67ac2734b8b1f6eb408f5f62fe88780b37d4d0e3396c8561309f1392e,
+            0x1b125268df7d9e01d789ba26c5956069989aa5328bbd46bb3a1c83e29b54f3b8,
+            0x3006fe14ef14b876c2e1e2c7415c98b78918cec927d8b711c4e11987c2e2cc59,
+            0x19332e6cc8221b23fd7926c431b68c75583036a24b7e6524527eacf775b5be7,
+            0x2780775cfe1ae1fe97897c286142833fe289028ac4e51285719df14c4ec967fe,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1474d911726d98132a38828196f72ba9ea28de0e540822b530d53431c3f787c2,
+            0x29778cb7afc99ff62da1a393d60b87bb8573606ab7ad7cd0ce647bc1984cbb10,
+            0x1483d10c35376ed7a027168198d871358c79afbba7885d27c01b766770646814,
+            0x1a8c31c239faf47d773bdba0f70801eac0ac001c6df938463cce819a72a11591,
+            0x2c58e07b869bc14bb0eeb649f5c7d9c278b6f7639874ec404ebf75f58dec4831,
+            0x1d649850732837e1c07c9f303d6278bb14f5a54ca14c86a26379029023c3c6d1,
+            0x14306d8668280502119170da14128f6a340f1ded7e2ba209004c42fa628b3a0c,
+            0xd417ecfdcb5924437742605073656307d039e23dc9cffe05ef8416e9dba3a1b,
+            0x1b5881474a4679cde79a4b63249d1f98d8b417f1161599f6725471f582019156,
+            0x2c571e0b35cca4cf4ca7121c9de0c4c5aafc7fa6f75498e8ec57928fb1c67d64,
+            0x2637d9a03ba20a6cd7ed99a69c38a6d70b79d05904e37c9dbf46ab2c90583770,
+            0x1cde7eb4a685a52ecd269169466eaa897ca783401860eba2b6026e513d6d393e,
+            0x4f817cbdfd445391ae482fe7248567a0c8b82136358d239d4ef180dde2f489d,
+            0xda99ce6262676118f51f86309d5288eb65c95fddade417046403bfdbb087d7e,
+            0x2505fbe37c3109a4d1d321b72070a152625ff3b0fb76ca925e5aa2c058879ada,
+            0x2783007044f2d12e5db30735edac84614cdb1b19f69901e0f601efb3d44cd5b9,
+            0x1e145eaedf86b1c5cabe622df4cffdd8155e6db891ff498ff0b887f4ceab124d,
+            0x8bd690af3ee78b6d212cf184b969f3112d45cceb738558962382227a434540,
+            0x5a5462e764a4f4780125247cb6befaab7e4dc0d26e2d75f44087af9f6187b4a,
+            0x12c972140783d7889663c3c9da5cc43cd1a9740471de97908a62cc21d43e6e7d,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x16109bf9f0eed78c726bcbde7de40cadd12343460b04ba93a52d969201f97f7a,
+            0x1e85f44c0c271ef8b9a9a29e3cc73b3b782c60d4ed7cc7624d6aeaff8e492030,
+            0x9deb8ecc3bb2cdedba96ab5bd80b15d4abcc49b6528e84c1ed6971fb3aecb86,
+            0x7ebccff0e97b9ffcbc6a2b256bf888739c0db05bc5d98d9e591bea4d74b5c7c,
+            0x2124e4a429fa993d32f641febec0b25b9725342879f76afdf4e9eff7608eb81c,
+            0x1f4217ea25fafd2a62aa709ef72365c70d66a4bd4d756ead776b40521b29e76d,
+            0x10fdddc5f968f32bb7eb9555c0dd44462771f57424a761cd884cd0c152a35fe4,
+            0x201c0f5551305ce9fe25f26526e409c0968c80b9e065553803aa38bdaff0182f,
+            0x1cfeab50c568b3dd5c252b7cbbe28678939231d1287580ff6222d30821191ff,
+            0x2b4c60bb89f1ab1bee21f45cf38de8335a2e85b513fe3a9624eeaa1bf6255765,
+            0x285dc6058b80d18829ee46322acf51d442ec61ac331af40ffab6cd30a07ddd8b,
+            0x13b9bd7d2cc334d2f60d6249ee87d05e356fd182830d3b3e9f435c6240f47603,
+            0xfea707f44889ee47e8d9859c523f99c432083d85fdd6a8c75e1bb5771c10825,
+            0x809a77036dcfb9ecb677ffe4e09ee7fab157ac28330abde61af824725d9e74f,
+            0x152bb1a773b27f82406efdb0e1557c03a9397a6d87d461fa6f2e06ea9dd4e208,
+            0x29da79b1af8bb1fd1dacddbcac71ac28de5fbe6aaa9e30f471acc532f5fe9290,
+            0x252419542bfcaecc57733b02751f5142834e93f4560d7b95b85ad6423073be,
+            0xc9ddd8aed9e907c27fcc361067f1b6c104c2b0a553e6d6053d2f82fd8cf1cf,
+            0x2311bf775d429e2b982ca78c015cfb0a863fe4753625c4b63caf8e4ce36e37e0,
+            0x2a72547e8d5bb41f0623072d419bcf39d08e5aea781b7358e95757a0664d4b23,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x13ee4f15f3b425aa17da17f6b1f5d00cf09454a9515ae5c719a2d2dcfb41112d,
+            0x190daca6e75275d36dd65c372d302d698b1a03757c0b4c7689e59bc1a0169f61,
+            0x994ac0e199f04446e19887d6aea50a4e94172fe29818bf60354e92ba3ec6d37,
+            0x19d35ebcf34f6d72d2cc738a968ff2acee72f5a54cfede510482076fae55c450,
+            0x13b39ce996b064bda9880f5a6ee1677d731851ed9c895f19add559025c0decb9,
+            0xd53028037010842c02855ed8d3143166621d870199dcd06bcb970d30b8adb7,
+            0x26abf84cccb79dab1c143c12cd741320c9811199329ac1b13c240f33cb0a1476,
+            0x2f94d075a38862b56155e5bd18fef09e29267c0fe03259af2122abd935054209,
+            0x1d073e9398a1528b81d2a14baf97ce3081340b03c22ece28408cd284c2752b32,
+            0x1dbebbfaeb42d7d727f73f93ec0644264cd18a0180ec41db0a558f3b4430abd2,
+            0x2fac339c24fe87e3763ae29dd6d341aca13594792f6d48c66fae31b464234fbe,
+            0x89dbbd04d315a29ca4c4ab69cd041eb3f8484a1f4a726139de0103404e073b0,
+            0x7b9bd575f2ab6d2e57a6112b84c02fd38e25987794b65487f4975d098578ee0,
+            0x26563d3ad82384b0c3bdaaf1770c3cd5a04873b239fe06dc21900ffeca0346c5,
+            0x24d55232a8e458e4738c163f81ab363774595c7b79722847e3d6341e1650c80b,
+            0x15f6a6be40f74352caf5e8c0d27c8a96d233f38d778756dd8b09546416a42a75,
+            0x2e195aac1f98bb6fd894b6c8c78d0339d8ad8b48f6753046eb438897ca67cfa,
+            0x240c714f2346df0e0a84bfe85b6f624b177e2fbe84b253cc4dd67c84fb30e574,
+            0x15f8e5e81c571e42d0ba368ff59ad375c2de65558b61c63d08117bc95de0a133,
+            0xbc0472f8203755eea5f4a54c4202293e72cedce2f9e697cef329b4a2e4f365f,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xc8d9a3a7bfc7f53284d3f2d8493110979d2c58fa350b37572ba8ecb87eaf0bf,
+            0x2a431044a8b80f847d099afa8c1e72d7f21894f3946b0126655720f8a6c77857,
+            0x1181a1791fd2439ea67078819652478d6767154c7a9d04918373cc072d53ae2e,
+            0xf0ccfb008217426f92cc5dfec764630d0861c6ff9be2459b227266741a7de7a,
+            0x41f755b4afa6ff133e8e46fc826c9b3e70b45db7edb7ee2ac500e47e9844a9f,
+            0x1751a37439e9124554ecb92e3006d8c560d6109b98570800c2edc590016b5709,
+            0x2abf7e7390de929b5c7d29f75e5c341be84679aebf5cdf21ce295cae5881865a,
+            0x173d1a4bd47ad310c1227e8d26c8c7ac003258ec98cb99c4f5da10c2fed0be99,
+            0x208d34eb4ac78f934ee023480a4b55edb26e044d9a46008804113b8b3ea6e237,
+            0x125616d001a18f80550970d010e57191b13574c8f737e4c82b47be6b1984fa62,
+            0x671703eb5922282742b194f3c2d494840e872e60fa6e77c66fc03868c71abfa,
+            0xe335455fdb0c93b70a21ae7ea60638481071649d6bb76343651667a6205ed83,
+            0xe83b80d5c774f2c4e2a8c7f7dcea61c0b0f000c7bcdca6bae8781aedc2513d,
+            0x58c57cfec4eb7be81eea51addafb135b89b2c5a111bca597f5212eed8547da5,
+            0xb1f27ab7d0817ea3f949179fc135b60938c8c20bb9cc0cec20b1bc8c5fad7c1,
+            0xae5de9d9b873cc4211b1fd9fb2e0717ce46072da5f7d8610560c9582b7f06ee,
+            0x4e515f4aa39a0a8667cf06abff04d87ebef4d85dc32ce64a80be9073b8e0163,
+            0x19f6c6c86ba20bec8725fefa5ee70cd0b1bb88b9b20847927e963ecc6f46d376,
+            0xb97af80e65d5a12a9178351fe47f3c6741b18408ef108cd73a56a785f657fe2,
+            0x11001edf4b5785917fb4ba3f1cb07e46f8f038edd5eba9c657dc39b3f6a254c1,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1f57e91f818cb6ec2ea89a4c5248e21db4ad238c11e2824455224c316c6de448,
+            0xbcbc929529eeab2f4001235f0dc786e792af2641c0db97dbb1780aa611ac51e,
+            0x2ffec2a43cb616c220af4bef1265a368c46b0d1c049e79d489bd62e461669061,
+            0x18cfa39baabd3a1f352d1ff2571411e36ff0c72a2796a40e9fc2238d89d99383,
+            0x26d86eeda466378285e93d468c3686ab5f649a40ed46a52c29c2b9aed41391cf,
+            0x2120bae48bc4d0b019112e48f3daef5b38b9991285c3d03e150a21fc03826de9,
+            0x2872ab1dad0eebe81027996467b9767b38ec6dfbefb43d9537d0ceff4b0d8032,
+            0xcadd0bbb15b10a2a3b5976ced621686e190691ddcf2911a6d7911aace0ee731,
+            0x12f83ac35b2e971f68f375e239c28cbfc8010f2d20a609ffa4bf3ca8078870d,
+            0x247b58e9d413e3b9647f7204b141fb1599eea15d505520b47d61c11aea6b1eaa,
+            0x13e4b5310fafb562358633169e17e3431a821e301a178c33279f5485290de69,
+            0x1da54e38f590b18af24713a270573e2c12e2b569b0e90992eb88312117269373,
+            0x28b85a60621eb6d7d4633f180f515bac0757a3377dfd68181bf6a65a9599121d,
+            0x1a152410d786dc50b32af794cea9b7fcb7fa48231d536b3c18dbcc7509606036,
+            0x92699deed292bfeeb718c76b997538a59e7ac548342832dafd64637e738f1a0,
+            0x774bf3637103073fe707caa2d322d9a9044e4bd92d81c1e0ba56467c591a487,
+            0x1a2f16440b008c3f42154123ee5c0c0f06eca84795d9b104c43857bf528cf79b,
+            0x149a1d50c2c217a068dd2ebce1907172d58fd0a3123debf849d13d873648a8bc,
+            0x246086052d1ce8675e03b097029adfed9a97c8f67f606d7093f6e412a7b4bb8d,
+            0xe2a84c4e9aa19be7da3e5d4dd74a495d308369e4b26a165dab9c4238eafa4ed,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xa62dc9863ad7e45ef7f77431acd332fc30280f65ef1ceda4ccdea63b3ceed3,
+            0x1b2446bbff67b4093c04a6f3e904075a796c5e28a5a6e586d6440753ba97551c,
+            0x165b84f51091009c389eabcd7fbbc992996fe32d9f8435354368e1e5b1dcd59a,
+            0xc193a00c3e7e8e353d0475afadbe369f9a5d17169a169ec197977619136eff3,
+            0x2088473c2b6a6ae33c857f94f2f12b90d7f5ee0569d96d801fa8b87194fc4595,
+            0x8787d2cebcabac086e9e7e1fafc216e3f8fe5335bd4642dfd1708a82a5371eb,
+            0x11191767947a0e4f9c3f782d1abd55624b55ff7087f34478ce0a7aa7b2715cc4,
+            0x2d28a1d818e8eb1efff60aaaff9483679cd5d77a701688dd53df7a9df567f5e1,
+            0x2fe813fab1011dc74f8a18e5b039dd373f0070ab1dd4fd126718a087cb2b8f9,
+            0x170e6e3fcd10c27d012f844c21af6850284e6b19fd5d1fe8258861d9db249136,
+            0x107d6816c1e3db9ea8bdc485fdbcc7f13e6134e807d7e4d686c587b4b02174,
+            0x19758af0d83c9505493b5419c17e6c4dd7f2ff338e60e9609259dcf15f33cb96,
+            0x94462f324ece93eddd9764f77d342e248121b7f1dede3f149571a9d9890ba7e,
+            0x86086b36fcdb387c6dfa2ff39c4910fd0af2fb3ecdedf957350e20ad3c843a,
+            0x2e3cfaefc61b8b4800158fede4808cedd9d7cb5b2280c9b1590e0429a83b3db0,
+            0x828cdea83f97fbf72dbdafad73f0954b8849f09a7f12c3bae6989012f8d9fc0,
+            0x462d87fc2c8185981a6d5efc6e31654b2696a1c42ae60b99eda523fd8c13ec7,
+            0xe8224f268418104de9a75f6bd915d2861e8e74a74057319dec312cf8be4dfc,
+            0x89163233ad979f94876f77c9717a7cc3171425a1b484d1050f7550e31c5b42a,
+            0x13f4fd6d8abcafc2d57797c252abf6319f2d2122dd71b15bec6dde9544f60448,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2cd268e81100d72c444d6246f8003ebbc08c1b5b5850a508f162541e43804c31,
+            0xdece92e3458e7d6e3ed03f44c57b6a597f2a0851662e51f30c7e345ab3fc44e,
+            0x2782c56f48794e225a91ffec94d427fbc775704a57e24c93a1092b003ffbba12,
+            0xdea062e2b07f7c6afba58a89e4f46c9586b6ff9abca5d59ed857f5b65e618f2,
+            0x53f7495e4b1275b15b3f9cd75aa20f9f7693363d4311764a772f2956af6fac5,
+            0x2d8223dd32694c54cbca71235970b8f70f1a7428bd738646ca6a862f46f64ded,
+            0x230d3770de4960732ed1114493287bcba5a8b219308f15bdf3d66ab0303845e3,
+            0xa08b786f3debb023c5ac7f28402aeed473d83cf7345cc4e3ff319ef710c8e92,
+            0x1abec3768c3f0fb09fb3f77f12a70683a00aa39dfa9bb1df8ec678d38d2f59aa,
+            0x285759f5a94427ddcf1462454842a9d1f953a3d2f7ec048846fd78d01a0493e2,
+            0x2b4f0d69284e2851b5e39f369bc98b54d589c08c487f8c89d1eb0c873cc4be5d,
+            0x447dbf76029e36fa2eaa60a6235e5462decefe44e558246910c8f6d57b00875,
+            0x275415ec216217739aa767153b11ae80c6b8b5c55c70f2b971c41ebe8e2b6af5,
+            0x1a7afd3f33137e9fdcb3dc28cadb4a2dc634ec68033c4121f2e55e1fad47d19f,
+            0xda8b0bf0f0197a311ecf8a70c17d6b73882fa3d36a2966583161a3f767a5cdc,
+            0x2dc11aa7fc35288f4c50ead3bec7cc0e75b9e52e8a3fddb61492ba94948d5ada,
+            0x195f7447bdebfa31bd8bb43dd8d1e6875c5c135b15c3b4d609d52345559d71b5,
+            0xfb172e6709df3831ca8632986ef7d85745139a51a45c169c830c4e691b451aa,
+            0x88051acf2f4c7ba673361201ff1639e06fa376b2a6505a1e62038906a31cc95,
+            0x19e57228a8198e58cb5bccca90c63d15e07a0f3e6d5d130d973db1a831af0bab,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x22e5666a758743c42fdb3096ec7a7e4266ad74824b6be3619435d172f438e2d4,
+            0x13ea60e7594766cadf7e4aa1f9f005f9d9e06177456cb4a43d919b4538492a06,
+            0xff1eeeb246ed508d96db973e2c50b126fa55bc7094854acba766574c0889a7b,
+            0xaffdc5342a12d31f878c045e76796ad01bd19a313b08cbe6071c9fa06d37178,
+            0x291973a60e03d9e088f91cf2e0d5d4b814b2d84bb97aec7993175e5d6dc519f,
+            0x11739b8ee3040e282f6d5039784f6b749c3a4d6befe0ec6276270da24f8772be,
+            0xe74e778ce3b28a1acf824de6d089b276e535117c55c361debf0a40573c67eb3,
+            0x1a527cc72db1098870ef84543fa630c207a6094df73caca62c47ebfe12c4dabe,
+            0x12f701614f5391cc72251c38e11391e9aa2d1703c47e84a041ab471ed77450a4,
+            0x11936336d54527a9299aed9f52635b8a53f9a958598336c9848564b86516ceb4,
+            0x272318da87365e9fd6249ec7615961b138ae0c7a36b5175ef5465898c711be04,
+            0x236b144cf42999283d59501e46fe4ea1d60003599b4046d7a60373f0688093ae,
+            0x1a239569e5888ba9ff7c90a4aeb505659415da6efcd3c101e791228149b35b61,
+            0x1e9e91cc7f554dc236e84f167e2baecef5a26769296b73a94648d454028ccf34,
+            0x148af5b46862ea8269491067a96aa3e71f424fe1bee820cd988fd8b19527bb5b,
+            0x24772a606417d978acf26d46756665b3c414dce37ee779c91e98a4caf803b6e5,
+            0x1ed8140073fb5244cba84342b2727e8258108dfb63d1daa824f4330932a7f292,
+            0x109b45b57572882b3de57c6d043e9477acc341231247aadf512cfefb46159244,
+            0x12563836d2c2fe6d077a81786800dbbc8e90d758a5a323f549f9b8d523b630b0,
+            0x1ba00aa80b49e70bd2b3748968ce6d19e9d3fdae0bdbc10cc50e90dde09dfe0,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xf24297c2abe65471b0746d085d394de0919936ec477876d32f44707fe0bf799,
+            0x20eb0b298c48450c7f613bf10e04bdd22ed3115756fa21731aedc3ffbe7cba27,
+            0x176482f9dab80cb5c4d91f707575f2a2b552fced3c3b96a5bf37f9b80fcc9f64,
+            0x1f79915591cfa6648201a28d89355cbc6875e30f78d96a32c3f108bb3a8d5a76,
+            0x2961cce7579ff9f9f0e867a02cfa8bb2e7401cacee24f5556e9d2fce5d0cec8f,
+            0x2a41178e5d6a04a7a1463ca1799dd1ba6a7b5c4782097e585793f987485559b4,
+            0xec4ae2219594ec22f648bc1fd42b82673c47d95bf48e9efdc39e0da9406eae1,
+            0x261794a9029605c2a4aad5463047d0cb96f9da25f3b18f391047e684519a6e05,
+            0x2e2bf6b18878b8335e40349e7f475e2c85cc279f99f76c0bb717d0ff7866e5e4,
+            0x153ca309df24c9e664025e69edcc363ca33cc1a9a2bef69b44f607830195235,
+            0x2db12f885abe64af44a3ee3f8478b92cc71fd91b096d65099be20ef87c64628c,
+            0x1f2c5b4c49bf8be7e7d4d9f83e18e6ff0c70ce913f2e246e65024ce32e0b231f,
+            0x9180876813742a23b9376d01579ef57c1fb39a60e825320fa0eaca8953152e3,
+            0x2ddf635158aef59c7d8a6de274b34eb7a5d0088a7fc4b0f7f4ce699a18e73a5f,
+            0x77f3965e42d9f1951cc9528c4a10b099bf49f4eb00e54d389af199a8a474125,
+            0x23b552370636186071152d808dcf55927b95422529bbe9900d1a1244532efa2a,
+            0x10b40997e86c5be3b64959e84b6ff95dc3afd77d7a8f708ba81d649075c74ebd,
+            0x19e7c76c1b1e67f86073187b4f730e17bab59bf1fa5a00365be2f3541983633d,
+            0x1c1b3ca31b5179b6dcb9ee3ab883ad56a355810877c058d64e345815eb365f91,
+            0x75afbdbd2dab2064406909fe766072f532bccffa959708bd53863b53f1323c1,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2d6bd5f440b052c36e1896ae00904b584661666912e14b5a76917f2a4023a975,
+            0x9fadca902762e1b9b2ea83254c1422c3fdb99ab470149b91d818f74c166448b,
+            0x1fc2ef7556e6b217f26c4ce8b049b857fa69b7f22ae9665d8fe061e57ccd86b8,
+            0x277e0a5d5df37f2272903866a0f10472e3e4d61505b48279dd78f9e5eb18dc6d,
+            0x1926393f89d142b831b5a9463ae3860bb088973ee5ee9008f0e1c7965c79be27,
+            0x2917f5ea018334c0f05c07baf8c846d354e3945fbd67d5a22d058a793275a35,
+            0xf1816fcf77643185cbcd7f0b141007670a027cc2891280006f4e0fb6f700113,
+            0xe5eddd2746b7345563203a3a02ba3f3be5c9de6fa3d6819c1dc8c10ca61962,
+            0x2fc0ffd1f2fb9e525e97afb88c5c1f16369b7864f845a922f56af6b567abb127,
+            0x13a6d507cf38dd7ab84c4fe55fc37ccc00e54ff9114fb7dda131aafaf5e3d8b4,
+            0x209e31eb994b1224949ef724609a754624b12e3e96aaa426519369d729d7f0d6,
+            0x29b95c4e0998e017f9a6efa329e997d750c315a7091995543108bbf2ef92ea5f,
+            0x273017f65d54a8a19e933a2850fe33bcdc56245fc66dd40bd16d1963065a8215,
+            0x9a00a7bb4d3c41d31473d0c97194d90a94a4348aed808ae2d9b68d66ac6da34,
+            0x58f37eb54a0d174ad881009a16e033b0413350052445162508f2e3f1fbd13a8,
+            0x2991d56ab55bed4794d78fbe8ba2d84e0402b704c63e8bb477815b94c0b6e72b,
+            0x2cf9ac97f208cbe23d5daadf7ce8eaf17b949ea0694202d6d3b4f6802c20c8f1,
+            0x2b2ffc8ad52ca2742997d3fb13e13abcb7c44ffea14776362b6bd9e1c5aad18c,
+            0x3f78a9a65aa3f5e30ce1ba2779ac3c5f275ab77961819dd01638a42d14fea57,
+            0x28a9d40e9c58592742de7987c8acdc7fa5e622f5e87508936c5c90e5a2b0111d,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2da971edce5951e175b20231e2caecdd672054df0a81abceac87182f9bf2ab39,
+            0x4852b72a76fcfca8332cf2fca53426d44a81025b049c6fe56186da6b592b8ed,
+            0x12678cd0dd103dbf00c083c3d563aaaa6e6e39e940c80c14575ea53f7da93714,
+            0x63be8111dc061b7b1f827eba7cc5e10703843b6878cf85160b1d8c37f8cf20a,
+            0x1292d1489e40b2b7a96a47889a8c08c9bb62ba92c2fb6ca290d3026828b90a38,
+            0x131928f8c7f6b292af217e6a3798bb3c3740fe744c9754f71e964e739fa84c7c,
+            0x9dd09c082e6ef61242bae94103d3413d8e280c3d824f566b6191d86c3e52e7f,
+            0x13a9b7f650fbebb1c30c63886605cfe65fb13044bbf58f6b6d6d4754a8803d9a,
+            0x278e646f62cd15b671eab2feb4b10833606a737023c50356dbcc6802c47e22e8,
+            0x63a048acaaba44b87639a3d246f7bf5721b2dfef3bc6387eb9a7a1753bc9edc,
+            0x19137d8c7c05b4380c5427ba3589505a29927ad701293341a797f8dfc6b64eaa,
+            0x4605aab2cbf1c8db31f3530518b1b058e8a9fdd52380d4365e7faf99ab86431,
+            0x1a662725c05570d0cb0ce0e3cb83f5a9a0d641d7f7b5f0395b3cbaf27ee8e7a1,
+            0x2f00701e4012136574084fcdcfdb8a03d4370327b6778f7dbe08468a3a221d3c,
+            0xeeb43bee0ce1170554f5365901cc66aad614c7db44ee7d933114e56ae13645f,
+            0x514bd58df752da3a43dd75147804956f833e61091c33e8b6ebc059d1668c3b0,
+            0x2e501a1cb67757564a27a930415497ad671f61899a37206e4bd4f70525dac248,
+            0x16d477454abad4ab36e15a385dfeb9d8ecbbd645a459befd544456bad6de8e6d,
+            0x3c052112963b411255ac9f4937ba4162dcf4dc56fdfb5f11f585a2f973d1ceb,
+            0x12dbfa8b1f22ca2b3338b85b1a1cd75ff557cbb18bf220312b18a91a24d55d81,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x10818548ab73fd03d26ee40e1a406f294dfd8c805e21f8689f1001d1d3808e16,
+            0x24a35e4eb8df49312d9fefc8887e52fe90b836c0cff7f7c07a848a14b01fcbe8,
+            0x2e0f1e7d21d2d04fce40c67c3746330043b7168c16650a4f2c9dbc17eaeeef9e,
+            0x230af3cc2c7ce9edb2179f8615ae8a62e458eb13c246f9b673170f1466dfa17,
+            0x1134692f5f1f941f285cc493c3f2327065c452ad32cf715486dcebfc2d36e000,
+            0xa9d37ced0d525c9d8577b969975227cbfef65e389d902e6c4aadd01322e8ae4,
+            0x1db2e2b5cd0288b1d7c7faf003be7703b5c5e45ed5cd77c0f47bb8d3f2703afd,
+            0x12d629c5fe0a3943083c96e3e532897bb2f63db5519122159b61723410ada8,
+            0x54da7deba9f7f2f2e2180728042a935674a8446804c3cc47c9d15178e8d6666,
+            0x29fc7ab2d3d544f25354a989848126e23d60efc67d30c1d7e6dec4f01c8bd52a,
+            0x14dc9c3565c4d246607923146b654a06c3a6f33ff2e7b285cc339e7e045b10f3,
+            0x257f594d047a720f1ef7ae56ee5cebea62ac2239715a55b1ffcb394af09ac0b0,
+            0x1202ed4a356316e5710f9f1a5727b083c1ab217050e8bbe7d95ff5f826c77669,
+            0x30fe2beb49b890033bbdd087b9e263add126966570888915b43101888b8b962,
+            0x5ca2c86c6b813c5ab7ecc7fa53fbafef3678c328accc49fa70b5f71a1e368dd,
+            0x22b38b500c9b360fc2b4ac16b0f8fe71e8e30a9a5fffb2275f40112e01c59f71,
+            0x1a85a376a332e4ed41c5b9e85dbc2806bb3c3c6f38c7f251fba31eb492d2811,
+            0x30b8dd372a1546b35d430c7592b24a762c0e748b857190aa47ba294da43f9bc,
+            0x58804d2aa2f1e9d511cb4bf4459d8747a00af3f8cefa52c3af281d7b71a468e,
+            0x2be9874c17f4811897b082ce47809991d57d081de49d4f9259bac0c2bbb69e4d,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x10127c52ea1f6d2ae8cb3a7af70916ab29fd85fbde5d15596076ce30524ade37,
+            0x2d887f38f4f5c278b142bb09fa17210717bc38dedc721327c34b5af25fa4975f,
+            0x18413dd99e547cd6112c9b3890a4a927660153967a2fa3cc78281aa3743b7ca,
+            0x2c8375bf705e811aea8583b90f6004ca186f06ba9005d92cf3ce7317b4fbeea4,
+            0x26672152eee139f933ea3a888e343a211776aa698206a6b970cde470ad510e72,
+            0x179472871d26f2e278673df45769f49f3943f98b5bc9e76bc7bd639f5cb94a3f,
+            0x1ed0f4a870226c8afae5b2719e3aa60c8a4f3f491290ecb6a6fa8ed8fec32f0f,
+            0x1e8ab7c5158984fd536a1fcba52e4a9a99d2406c681d0d54c194a1378aae7bf7,
+            0x6e50409b0cc763889daeec7624be727dce09632fe17945329fbbbba7336b56c,
+            0x5ef96066a1106782bd7942af6ee88ae6c642890863ded5c908a70f0e97188f7,
+            0x275a393c79c2e975e32088fa28e808ef7b3a28ed55d7908b3304c6270b68474,
+            0x232f41ac9fb55828ad89fb910fd53a80463ad16ad787e2869f315a59ce7766d6,
+            0x275bb8e491e9023da98884c13b73892f2b1eb2e77dd1dda8b5095bf5c9adc9b,
+            0x761b386807668eee2b21b55ffc77eac91c6081c52308c6dbafc6c07028b4e3a,
+            0x493e9a3b80d179228d2a81e903a9fe8d65ad2dd99a733e8ffe044ec71a668f4,
+            0x304413ebc59f08c82a9e2356ea09341910ff74938709f03599a4f0524ec719a8,
+            0x2d1e1f38f6702b847019dd697437b90bbb302f642fe0d71df7faced0a3dad14c,
+            0x16ac849076bc69c52529d4baa1c20d39991d1d1bdc92c8e0ff1c5bcad374f25b,
+            0x1a85ec6762d6cbe146dc87cd11c2b2daa1ea599f611965a59bcfc3355a684318,
+            0x196530945d3d7b35c950174d0b08a4e423a8ea2bcb1d455f4b5e042d66cf2ca0,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x7052091360f5985cd717c188ee4aa7b12542f1ff3dad0a1996b00fde6e3652b,
+            0x291b5860cdbc43b0f0e3d258bdf8f8b58c839a56779bab5f918e042293b9868e,
+            0xd74d3b457f71267a00679f5b34b57cd193626e69dff827153cb0a07245f97a5,
+            0x6063d52c65712f8ea7af7b3405c330f3a0e1e4a1652cc21d3dc5e0f60cdbf76,
+            0x66b0a3103e081f9125c429640d2db5993037180131ed22bdd413d33d6a830e9,
+            0x1a1ec3ab8c7e73bee5257c0669cb9e5958eed3d51d6b8bb1a43f2683e2082a4,
+            0x25bcddfb7d8a0a191d30fd1325f71e08124ad4b099485d80f41ac677e0094152,
+            0x10436855078393e34186a26936181b385e1f4babccecf88b189a51b052d6931b,
+            0x13fd2892c02f51e42d36d9d6986a773f1cf644bcbcca74318c486e1b1887a8d0,
+            0x2c28f6b8646fe071a4d6eeaabc22f4398d09adc041da503fa5e13d55f280424a,
+            0x8283969c57b0158cd5bf0dd9ee3bf1d6008dcc45c1ef3288de7d1be2423832f,
+            0x1130ad17e3000bea708aa2ea9293faa1bb33c9fa734c13ad351f0409c649ca65,
+            0x741c5c7d36f11cdc84ec58d9e6d7428f8cf2d15110ec45d7218f7991be58206,
+            0x1f449a6d7afec87c3391d5f306fcaa5ba7498feae544c6048dbdc847c7dad3ce,
+            0x13c20e3e2bc12fc0d3ef6ba869311fbc5b6a3a4d779dafed35a96098e97f2167,
+            0x1fdabc23fa86f1b12e840c491a7d7bc267bdccf6eb113729e41f09eb416c0d90,
+            0xb18abdac519be96bae35d898d40a26e9d9e0561f6934be88da9a5c24e498652,
+            0x28b6810fffb6ed56cb0ab3df49bbeee7cf4f978461189f205aec741cbe843202,
+            0xbec82d9037048c805a293a708427fbfb95dea117a6dcd1e6f34f13fc9e088f8,
+            0x2f63a41ae9a12da286de92e8e7d65162eef3e275eeda01b2f1dde4a6b69826de,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x265c4fc58d97632fcf19a923a0667b9e9b28b7add612d7a71061bc93a8db0d34,
+            0x12885bff48b6298f10b722b699ea5cfefd234005c83ff78a16da563a95758d70,
+            0x151d53cc6bbeda594c839f198afdf5419d1c87ca6c45e23b4b5df9ce6590fa24,
+            0x14d55af045f1dfd8f49d4f256e081a6b3ed093f01a72e9e7fa95964d274b990e,
+            0xd2eabd86f01fa64ba065b8ed26f82ce2fc47e9e016448e3d727a7c66a7abdd6,
+            0x28b3060c2dcb657bf0ad4e015552f6c057d08d94e6a7aa8f65ccaf576ae19c9,
+            0x29999685e5c96a1b905f85dc5bd585d018468c52eaf77a65a6a7f7252d015006,
+            0x2cc36566d5372f76a5bdd4fad63e709b1c9a1fd8c638d508d11386a963949d17,
+            0xf45e1a65d563313981d7fbd8646e8b6c0a513e921fa4d91d06d1def1ac535fb,
+            0xbe5a47fdf5f5ebb05760335c19650934d3c9fd5bf6a947d230ec07b04b63361,
+            0x8e06c579f1e6e0130c801b93e325ccba4488227d52279b600cea03c02f55841,
+            0x2f50f7000c45cd941aedbfe73b0022a95ef948e1672e5e4ae7f818c5af7a5da0,
+            0x10e83f3ecde3d5babb785328a70cad7f1266ada3811812961cdd561855792100,
+            0x2391b1a42d1ad62765e51ebd3fcaec9feda26eb1a8e4bc397b4a7692e5036354,
+            0x5dd281f4536f0e512cf632d8fc3bc3b198fcd503172259acd0a43f6f3b2ca8d,
+            0x1805c870c9eaa246e93fe07b6de600b300eb1d2cc768abb8a325d1b35a73a383,
+            0x735b3cb5309a63477b17662d70e873a588e82e15bc083fca92f3b1272de5930,
+            0x15a7b08ffbfad70da2050e2c609621cc2817e9fab3f8e06f0f7d37599f374039,
+            0x1c7725a85e6a7f0ebaac87408b38e5e6ecfb4de63ab1819008926a7d1ed9162b,
+            0x2371b576f67ab802e647290dc0ca0728bf11fa282a106e52567e430aa5cd6df9,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2d76222e6f0ba0ffd8667c9cfb2a8bf2ffccc92e74cde3aaf9d515f6770be25b,
+            0x21a9df030fc2c38623949ccc0e27da5c02225e2e4cb94258767e67046b1c9ad7,
+            0xc994ae387461d0c7104186c1f4e140f224a0c8590490a5d28bf872596eae2d,
+            0x27c61ff34f721d9b86250fdf7a433505b8fa72ebe9a28c0f8f9a5a86e25bd642,
+            0x115aa7aae6b9596eca97b6726a631722dae0a8f630a3368604dbcaa9811a851f,
+            0x18ce760e701aecf766400d3c8303e28aa7937c3c89c3109a5f0b8f9209729faa,
+            0x2e8d27465c96902538919868872618261b07e2771f087e9686a07b02744a0149,
+            0x100661eb6f7639b3cddca06469b717369b84248f18a9a0250198228d8580de14,
+            0xbba9475dd449868c67d4d7394ed448eaafd0384f417ab5ec3582db8962e423,
+            0x2ec4cea2ec233f82b5c3afc658cf0f1d5056dfe434c209ee3d3ae5101c5d38a9,
+            0x15a99df7e6b5ef0315db045932d7a24de603b0b6897f567626fd1dd9f47c8553,
+            0x1be6d866794b25f0ad77226028183b38ba4faffe5a4375d4b2560306acde3c5f,
+            0x27257e94b2e95e861b7120ed9762d8c4c94080b7612d9b58d00691fbeef97374,
+            0x3af51f300cd6fcb4ea567e6c8513d81dad94aa1d0c125a8408cdf1ed9f103e2,
+            0x193b1cb5ebd78dbe0428c993ddefd3df2414c558078f757b3f8035b047090913,
+            0xdc86ca1c3c10a634dba579115794017366d06315b67d84381f4e3d530800e52,
+            0x1235404239a1bd35d8a5d7e41fbf7979bc1132e1316236fce4704951990487e4,
+            0x17e965fa385145f2d79704557938893089dd6a9411e1a4054614bba0f1453b45,
+            0x17cf6ef863dfc27d9e23767c80219a62279a7c1df9553c8c3fba34d8d80706f7,
+            0x568c86457d66bf962613ccfcf294e2bdfdc444406b20a6563eb382164f6b38,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x2f5139526746698879515dc547fc4a18a47bb7b1069cf42d88c1699f37bf70e2,
+            0xe9ec645e63a3358158ca6bc99b354570c61b50ae0b66a9b2cdbd5b7bd2528f6,
+            0x110bf55f969e6beb814a08bedfcc429368f8a65317d9df987fdf690464e82792,
+            0x50a2f40f3337b14663877a5c5c66bbad6bd40810303fc9077996384fb942223,
+            0x9fa261cf5150dae90270799121e56745c2e3aff6c6edeb0d9f37ad73f2e92b7,
+            0x18db0fda1f48a43c15c1d72d7a8e8ec2042ceedc57f08cde78484f8a0175afe0,
+            0x12cd152e6a482b22678e14feb1d2b463560eb39b0a27bd82dc9cc6791c70e234,
+            0x208785a8e7d01f556b883d201a43071c922863abb6b5b9d62b06cdbe1ca198cb,
+            0xa2f6f2777331ff62db3918731dfb0f8981e3f15b0715a44a3e076abf1e29710,
+            0x2e40f60a955d8717e55b97ff156a8bd9c6f2e806d042d0213ceef2356fc97f74,
+            0x15b824ec28269dd4d8e6a563169d415cad68d9c1c7aee1aa279b76abed3cee6f,
+            0xcb83c1917e41f61a32024d11b6d8f43c8a9e9547568b817ea72b3ac253edbe4,
+            0x131c6c3ae3535f15bb791ba5c1f52051635c44d8e13e7c28d60812a763cf62fa,
+            0x274de569e20256784aca3a5ddca5222476b2c06e6976e4b5332578eb744ba058,
+            0x4cd6d293061e45cdf3f30796a24e66007a0aeff1b9c7cf7cc869dda589a8d14,
+            0x2045eab29038ee2c289a564f10fa0ba6377679514a389b836dd6998b4799a07d,
+            0x20f10e37bae5a8193adb95b06981b0f7623baf32b69b61a11696e7a8795494bb,
+            0x1f55e36adac5b9b352d7cbe55651b680c4b342c335bd8562fb45aadd3e83e619,
+            0x29602ba7068d0b754d8a59a67b5cb83de5a6d86092f8ba5da32960ac4237e424,
+            0x16707fcaee953e548b9f04c22b714507ad45c63e242d1f386fe813701e59d18c,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x26443bd83569c93383cc8cd7a2e05eb2bcead4621e70cc188f6405c89e778a7a,
+            0x5a35d0e22be0f9bd2528eb55583ced870d362ee72476e9706625e49bc556498,
+            0x1021e56558839fc8b5fb2205d2c799e3b31e7657cfa3106b0651ca9f6e9def53,
+            0xa4aa165b7771c0810e9caf04fdc8d6b4fa87e2b88cc08aba3c8ec908739be27,
+            0xb711cd6dc591dcf07f400fabe5cc8b78ec01724bb2b9e62d11456b6de351974,
+            0xdb4f89a973ddb25f113a6df8e80aa798cd2107439ca4c3a7cb4787f23148c72,
+            0x24580560fa1df7a3a4921875187ef0cad6db94f0bf7348fb7aeb4c9e31bd8dd4,
+            0x1de8c3e482d87d19a3348c786983ba4bae3ab00870d28ae3dc18bdbc0c8561e,
+            0x35ec9a49296b184f2225b3d68de6d1d5a623236576d838e557b150893bea66c,
+            0x1f7f2e438c0695e2057f62a661aa8e85793ec168e2aac1ce06ef7ddbdad1e115,
+            0xdba6ba79098331b4dc93515778b2497c38c3ddb2b20e6dc9df6ed5ad85c32b5,
+            0x22fa5dcd5070a8f46ad637e3cbf69c256afc6ab58dc0b0d98ff15740abee7e59,
+            0x26a5fd93dff7f5eb49942b51b03b98e9cd2ab261d56db7516afb897ac2706ef9,
+            0x2216a1a787d05bbccce19eff5d852b92e317606d55c6b5b3fb02afd41e69721e,
+            0x2228040c2cc6457ecb0acf3ef4699eab804d0251bc75025ea928d16d15065953,
+            0x1c20e02da095541abc6481a5c1594ceaa688ec99b43ffce38b098ba817af0477,
+            0x106f19142419a86a234f4c8b94c9ad6f3b6f4dab9e47ff3c9d6669bed5ff3795,
+            0x104c7b997f5f83d8da35fab234f56c49716df4b0a7318bdae91786b0a007f857,
+            0x272b659e78a33f1541fcf58f4cb3e64e806f3cd0e2438dce20a9ab7d416a3080,
+            0x1249186ebedf49fac85f76d0e10ade878518daa306d2b586e295868576a13ea9,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1490ad8e9d330e2beaad58cbcbabda75796a6e00166bd7b9de35c84dca1fb7e4,
+            0x29cedacd10b839b576f81408dba8ff1cd699b9b0b11e16e5267c217e574a559f,
+            0xd55f5e0d31ed8c032f1b31ebc07fcb088feba88583dd5815f85431f3829cdbd,
+            0x22c2de78b8f8caee3778d4825710b080807cd14bfb6080488f99e303dea9c4e3,
+            0x256bf262a0b931d87affd8233c61534d9f5f33a3ffe59460ca8af7d0d3ba946f,
+            0x259e4f6cfcc7a4b6d2246333479df052ee0477b9ee8faa7f47da45d1495d909,
+            0x235e716b22b67894aef5bcad49467c7c9e8fb689bfc03f058176c9b2f2cfa6de,
+            0x91246bee1d5f4063a2ab453e658c50c994dae678cfa15b73b14b0f48408e18d,
+            0x1594541dd396d5948b6b0172b31330333f099973d8a3a1a9d299bba6f45d1bde,
+            0x24cc95bb62ee85ac17d1e8c36c15cc50c8c66c7cb12e08f2a8b865653cca586b,
+            0x2dba892c4f9bc80cdfa40ee9aa9b1c37f0d4ea781c3fbe5ec7ebda39e2272dba,
+            0x2f3f255428b447ee2819975595dddeef9fa3cbd71b62f34aee8594771d350a27,
+            0x2f4b81914b52b75c46b6ebcb52605d073fb458f8b1cbf68fb9db225e4919b8b8,
+            0x1e35a658cb61031459363447cde6165233b2bb5107c6dbb4c2d50c459940f2a5,
+            0x21938bd170ef0b687752b8714b803b82a4358bf72b74265a4623d5594de772ef,
+            0xd54bc01b18dcf2553834c7a2330ac8163083186d738637650ae7bbb67e69c01,
+            0x166ef423ea8ce954adec38214c8412bcb52dfc2af3ad407cc94edf187e4d825a,
+            0x304b27a7490ba0e5c20d3b273abc31ab57d4c9c39f2928b81ace40b26ae3454,
+            0x1873ef347ff8231585a15dd61cb7140998b4a07d1ffe2045dd368594edc0f171,
+            0x67a470e0c4795e245e75c97cb69745c9d9bab71c1b8836aeff01be895f3634,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x14189f783f0179d6a700e43b6f3412af189203e47b5f6bffaccbb0faa6cf850d,
+            0x121bc25b16a45c18843035e84ea0f03e550b85c5d5d865c391608764d8f9da3e,
+            0x2e7705b125455c88939ebff9c94d94b32cd19988de9033421ad2497299e1c07e,
+            0x4de92a097cbcd0eda877c95e7d7c623205a82e9264d48093144c02affe35f46,
+            0x56267827dfdd2c8e13c31ffee09c665605e6d0f76ecfce63a1a3e0ff9ba083a,
+            0x214e0300f805ffc715666db69a32b5ded6c1a5e46ce21278ef56df4cf75d6d7c,
+            0xa3e3961aed3e8da84d9b2fe01de35febafd742ba83c0cfcd82c48142cf1c42a,
+            0x2ec69abd5acb3679c257c3814520f5a2d4e15a9e1eda480e25744cc31074d12c,
+            0x1c68a794990b7866dd921b417960123999f52f198f279489f00d5db71205a6ad,
+            0x11838fb23d5f3322bbecdb09dd7f8b581465c87a0f6db0216e23c9231aaa5584,
+            0x5088200a18b6f27d2d094a42fec2247f9b19a17a2f85f9827bf372ff495e118,
+            0x20a562ef82e57831ee85dfb0b18b716e63de36bce2d28fe067a1ce10e365a8c7,
+            0xda77e103a18b438ac860d49030a95756dc69c0118e067bba3732b3a29d8fa9a,
+            0x2e71181976c28449e32e07d66706ca4fd1b6cab8da61b18e712f5816bf7e94d4,
+            0x1321a6faa0815eb83709c5f4bccf3deb91d918ee15267afc6b029d923bff2b5e,
+            0x27c3ea888b30068677247481893caf50ad99ce732dd4549e2f651c3e266187fc,
+            0x47172c54759f37b2b4d64ac2fb6ae6c6428edb065d5b7f185394515114dea81,
+            0x19fa875a5e821b2fa6c2ffe8acfa446ddd4d6f253338376fa289b20e83de1915,
+            0x2db07878d810de30ca07c22cee53280d160186e6e27c4c3a0bf895fe2c3349e0,
+            0xa8c2b4b98315d9c006a0a54992474ac89e5935a1346976400de47d115ca4389,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0xc098e14e0b8ea8d519e73df8da0ef38276518e4e103d8a6101993f21ade6828,
+            0x26a7ab22e3d4701a4d54216b73e906da3d66859bee38d02be8f120e000a5b4f6,
+            0x211a846a0b674674aa04b33558a7d8050af880d13e6762872d4560e3f7f55b73,
+            0x13595dd19c159220e93fc8bf8645c5b9af252edacd343c89bae98a3a37314c7d,
+            0xd839375c08776325c25610cd2e5ecf8a969154c0979ac7f14f1e58a0e7e0441,
+            0x136b3190bc5d892cbe1762bceceb68b500861a7f6b590efd62be25ad1c73b2b,
+            0x8765d20fa4770fa4979632a6e5b500975b173eca79b0300856e7130f6657930,
+            0x3b2d35ea0ad26b1535413a38f690954f224a6f78896baa496b8e8502bf34331,
+            0x290489818e00b9c0ea5d2fce994ca9256bcd9775e9ca5bfdac81972b46a4b82,
+            0x24b7c1b84ec626f59c7952c4098123e690f221504c68006ae1e5815eae2e233a,
+            0x2d256f845196bec5b35c52a663e4cf84dd433348157a3c877a9ad08d41da5d65,
+            0xd1150f01d5d7e30b0fb3a6362c631f4664f6c7f6291e6b889544ff778131376,
+            0x79717001ed6744cae07a2e491a2338a79cb8c95755392c98459c1284c70ebb5,
+            0x2cd2058b448f75bc368a7cdd20f0c67f74206366bd8882235da404d702d2be65,
+            0x1b7a766baff43fa8a52e26085427a1beeddd80b70edd992547818c62bd2342ef,
+            0xd10757ea13e688a4d99cbfe646f4268cb2498d2f2fc8bc352694aaf44f71855,
+            0x1fe27d15068f85f384f63af983d10d1ccb94147d8560d456171c3d741d427f22,
+            0x2ec657144f084e48f4eeb405543606e23fe2c1b581fbf942fc3da65d8a6228ea,
+            0xb71ff8252f9e1c1d3773854103c48fa3857563e8b2de93b78a54d1c929464dd,
+            0x182b99aac23bebb445feb24cf5f4920497d1c735985248f317c36ee35c343115,
+            0x26dba58ade8cda188f49e52fce7167b8f219dbd924d7786b0f98fb799fefa2e,
+            0x1332f4f2281120300496b962963720e68a075590aa803c5c1cd8d3d582bb75eb,
+            0x24c4647a7db1c869bda030a3f816ea27e8dc93909416ff20eaf39ba54576b452,
+            0xf5df55c2bfac795888d3aae8751afcbc3f2c5bc2b2dec28148a252de9729426,
+            0x23a4ad4858fd3c269b1df5858ee89dd659dee776a895dd5acffb17c632b66592,
+            0x526ed32d567e190ff5628e6b64d762447caee284b84fa15adc9384a24ac178e,
+            0x144d89dd1b606b27d51d742d02deda341a5f96e7ae5ee380263f7a23020cfd5f,
+            0x8086e639a5f96c89faaf0ec803513e9c68647bc9778fc779d144991bab029b4,
+            0x24a2d9babdafa3f42f87ab39e269c2edd458cc87e9e3c66dbe8b0cce81db9fb5,
+            0x1fd030e5d50ca388859b18fa5617527cf0064d91bec5c81dda5ad3b611a28fde,
+            0x21e5cd68cdb35c3027433f525cc2fd4f460132cbe83505823bbcb12b11ebad88,
+            0x9813c803ff84a3694eedaf4b1c2172615275dc18ca654c799a70440946ccf0,
+            0x202973f7fba5bd21ed58bfe7156d7b29010d41090f63f1bb290c1d5da1ad60,
+            0x12305eadf64dac24a7913a62d95aefd45f48355576c671e56fde9cc7c8344ffd,
+            0x25c783ad66d6a1fc6c84770bd637f6207097dffb0378d7e0395f8c0b86b505f9,
+            0x222deb606f13cf28c73a67216d88b16f5958d5d292ba10ef3bc2c10f5a0b613f,
+            0x1614d025472771fd870a9e9d422b3571c5494e7d679824d8fe1212177d5fa2ec,
+            0x1358bdd6b7a51b1f5b5d094dbd8ee086ccdcfb9c27faad0806e8ef718d0e2b1,
+            0x1c2007eba4d1629846bb69404acc84565de5d24620f75cfcd9f11feeeb3f3748,
+            0x22f49d7244077e41f409c0b353afd1696e3aa15ffdb4a0bdb883ffe7a1a87217,
+            0x1951523a4270c54403dfe3218fd3d4ccefa43114f1b19fb2c2821a4374718b9d
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_12_config() -> PoseidonConfig<816, 144> {
+pub fn x5_12_config() -> PoseidonConfig<12, 156, 1380> {
     config(
         12,
         8,
         60,
         alpha(),
-        [9531912189466476916568861603725087174113765795321185751191491139118805372511,19478790955972117697384547134063865214385101762783978876290106323878777065880,1060742683967616999946346623778902980408439861665078741681079083728753884980,903807389911706192945621790390189278582333785459643079682311503388875632444,12234856961774107626670146718644057065701939000315796085771709903680607765980,7144222788160875459149511026237781941826966456792731247241581603475033054157,20698157631699630824067955298548696950174021158305550220448729049898476869972,2568732479597962725718653653192533652726437462680484211279054254158600287844,15284734447838568972934847154537240941736455475374750484902463133334986327455,11481338136657097309136761414013103615752281785975103234128467186355727286020,10612154017018914947135783711517517074090274235061056248497547614631916723906,3055604116750189009829046286798613018321687824856056202070161812694453230232,15724356578668121294244613323219019733691132614053416867337612541744349705307,14233178571890186223833398248040498471414046807101676904418988635462870136058,15569884202072601673299042953201725479510195453493088500579693825511613908294,2457655896277475748047646151777860503559023325500398204274047419681119270433,18721554772384051287322049295337473476448259922773695010270945658995924622719,14475562052679553333706265906284533085428658760049287899372861273825967798347,15603408794229592986464670990674550905587371918421438132217255356917740776753,16291020844798157226549685169153735235751877205762229274467406522127105739380,1562912009705461355815110217333069399929165391790667011738168557818438924927,11269000847557922376283381139665491298931690005135341373215203639253515983197,7952882227157644034022652849613475711023423321505769231128945987664804912273,8477623463686474590677390307150152439632807913002306242882220286965657503044,16240923770208341542260111895431885216031871921759466016566105290964433552216,3342849074804996662671621919352322750206307938435597035721084610748972602222,17931702006999673813463835283048793204134166638699010505988519059393386641671,20775104403560355444897460398679593487716638645215251442678183285176599574637,5119120619161234799144523865081220455479981813019860080498855561756227023701,14966757356872002341966020507506536570537078023526508344654458912397759281515,4186575643717625662604368224196455420957673000117335440321019421096129003102,19732993039041335023904970539797704576579318087957672270477209415993860238993,12070985110749915673363345667648496564808814323429491368289711883810537898097,11426729904237322553170474047093755836047277723343283963043397762276736900525,3316549680511845723553051012477874001156246623643069548980284069093192393275,8181145696278572952623145148622555644838658979012817598939443116317742063663,5285104126733708771192424010645473580676014333664755598112717745696037070786,20879460004955312065246827250994614761073401947673232470833608851757692374701,9225423353187148331993357472363957540141522302215231248106234750413173980751,15882456781720382955442431000301149138213435084361689595107598612703885378636,740238561845104412391944006282242126007894120431256540495139829806405656182,180417058725083825889148913143008776006125349068680455724690397852076567353,14174293519955274733372251014027762210778831326913295280840585355009025244339,8589132560109336742397080501737400189892522466285798728529721670916644735009,18608579889305084432265993644262889161778187018060113992221234915464772250895,13255562856310211555141734542720764165551582487712004861593515585281326120780,20040426996876166323258012360708147873405329072458300306708975663127708222443,3623806905318973096995680510049954452579199046783492207512283522220396562822,11410684734000900004860241940266501902598169149094443542781697771532926351566,17135477854627682759515989387435395911766329083966273406049980901836411403416,13593359321772915930716800157828568438953037754245269488538472861500074218774,8851367853862849158416384345517193602505667487160151588020171989122435915705,8486258745426030087193511835657366486234171438833758681014633470174920075557,14747490337504821136965789527401826047053378817043597026988257648138435336926,5328238162919446506214025777104049372124957345257645933410622558507658284713,11965770224330607826076459132274399741504292999992921785782448737931531131492,6397958737008655664539418210486834384969900796875514632281024739857683313517,19298424785220686762403958616740155152857782164943661260316780711617884649980,20019455348785333548837795973650078300677031008828877476192963238765813699604,498876295068369039941891884133922605442597373275805987652958540603151502762,15673948845182330978914854481229214769118100412263880346214990198207268219918,15636974430517603355685549955558840639961287398389993551242671229593610041279,21849352155479133596816471850644588093828045783688624472176874329078465894038,3710541309080539224803365587698192640065043989988405183436118622332060826084,7400908409303343897763329119747918294591391269311551693625176644493777241247,19095563460120996369257805492605849292942048841569757166438202426234116219528,7450358777752652255259382961368280387692895530851667830759412613948095056314,12616362847029801456780520061399223912377922714639139395311897747307063246381,2962396389753936883856793158008198181187288822144777145656778061306062270271,20597083262311447290143345580862519411179427096464102505623468932397345199901,5990063075931255958499395880323163728626495197217954905778613462408195572191,9361904499252311797420064091418454593805808979929563324171298064587942042557,15745983602860127054098117502599813732367772584805282887983680577406906842509,12155753549127535852899642287036910835293646693799050941038502705904075221647,17784550108352452858546269360461997898333463961938370347697582728197589684086,2486952113321483072183664368099776164387734014933893158352223909214365526945,4903545427310923282188595180893897246459463256398425200307382903876773643166,4976787025628832138140129068285715692634473783721132777844066348049003658995,17903848557396420363857191109854268785343114927997153696759251220232810232708,4112316506554809604392743006504568448930584669405889138267627731770713169451,12564921445775298869601661793895717261354052767541351424764087809438338341443,21338339987232841174606235608205622863643553456415651377028015070388899605425,15088854240518267391884187352051335059960134381458770666979402557846290860043,6521785672326022155410896706891346109402758862672817874198014517122929534795,17713017733654015756718215699238009705617793897969373435335184169505068045344,17520588725173134454654213370481559878188684108641520017594192886986887410727,20370353420481573040209617326772538556774101029132132235011046989968543481853,1112630910445876674622022594317693604373148988518983600314476620278857862788,13947879294001229379895373879944689637841444307211953543137372048528771620266,19992733820130513366333925886960985070219788486605690639975080516132656879852,20463686239191469605722985205294798392601180601616445763439546206772797296794,2399836272490730222789561326076432853292090595513010294231690669763899804691,1034212741378241815550350670737161423052400169194393567236687087583799668630,11440929010875860174917763753574001672473682534215635955505970318252592490865,14189960926817818424784917441574757301766760887770685069486059337906765736963,12315331213328078044898516229848174792421271854142211159524426707506661472774,19715153274097520886062594899069030152815615989925596868748132112713500919606,5263645674775021082527379900656937946372398687742691252725061831191269814647,17116922705336407879424247270343125398621621836566941362988393678055183546962,12965075932786028962944831711285166109972351055088920502397645336995474504411,12016029264981766758974787101200878559176627961323691741528038308088561486007,5729800253105809140207889626731612970039128485797787837679696331851897001188,12918441439057112476878371772096947366502166083699226943980929800631997660377,12122801182972566919042281354391366131886072331873675435499031824985283406080,2001381046477673840829875588313268487326797326656965151814712798463828403972,19581992323872865003173357646589705276192927057599589666190396129558198469295,12032241883699803399815479981073900218390137511663730251199663857029681112519,4486673663248066106745570699596745555749344770988892121755846988206654958447,5880818668316784480273321916242537222449799562687899946001667784663774949284,2395463900919111658295342588362130947823185484448880299307422522723986076206,12950983061674357110606111858229311283119838941890561558124046774295323335099,2237414129351562764861995011211505967387529547007150899242139479636758409691,11297958435815311160313316754342324739290776717531068730041530178142477489469,5317255860197359110199894572100590405469568868980740298600361799734023336258,20883201721979021051679862781044901365707874143019054645125857460321063446040,8182241566037373547703812967620649098015366536333588850170211599244447070966,9597640642388296782056528355964209027337895123387144965957122193392739912194,17036534143228977344737945793420370811715806669058615712195620745133828881359,11612810822316258618979762480131695561483235138506664012253801075650313633340,8933421864748994361777741056369848147887887317449099739627452478628920292098,14444070019150868677613599250973948199109012042816076287250439535772792130077,1409252976182963241946410463334709182528602279352691338387472032099813179046,11952347912832393217697966069578145988700552783923451999893230696985016550129,20459418532142116378042115609733769114184932636063412849272885250416180990630,3551971311295052916014184741437675944777358383038912487497306982998424802991,17338671457268891559841041605089015291458737421392337141908035764681448452092,20968343054904260510606682646995696017767749421435540168583945905747214877394,21712394213185895207403184789091961285240129068046002376558625468598692072071,7634967402785998572909457534910529497063727153788753124164657866643377741907,19849927917300065970782875128524194424999119369431340457180683372405088384137,15012913963479022629048645986836271605475934011232886489828149973693122241964,9429717687014890707005420840742234597648724772846627377968206537995029096421,2567188197501474210757971384017028034832891166328657542206945684532913152990,8254698320328328672738727190211578815599233720695888584349629846354725718490,17284254811803472776585305793072871837922263190673228934354908231725144505079,14935255735939697495362584034949670161356891451287847368207930876840786524288,15799240079228766996307573606262831147697506141321254927976890662889015144612,6455095726770008351501849656650198371508317633852287113372325351871125339180,13561632639572229898860364095655372109051739280251390860766414218384828962360,3063643914261015068338656198636076696013594289440915753234546912875968584726,523490668760084285231907250925228161954264885492417167368043075448446094968,8963235882996992436242593243282162189452480942366129170093695041925502792493,2822355405499444122504244694377602321152414880107322020961544617958820110728,9900962978347352867015759419877923426715239847996616012083851486863818525240,8479746689369630997477042503538860863372007378750903762662394891426272525808,16389683851395581748247134197181679668454182692374139436248933773102047859911,53288238128999697340898456182379718764153689572603829218558226366719788005,19367926616347613140684682635393090785537600078242140764999539757098535716540,15865351283225378120524944291419029041302905726785499676495076019805256191362,3306541431760940351422576606963790342897050957331449111434563465335195596604,15691440019263506851813897307599578949230726834044329611626721124859202292981,5471927110529676053035425189646230106778686168719884591627642899285735629074,21754232156244379849332999145646221923063494235010275675811923863906511018870,12691978963824033486319665437354495198660382717956695927101804737187302726210,18287930615191907073854709805749959615454583394829992950666668999967617218809,19651897318700114806760486800306423305046969021116395207725042165875775288623,14108212236437313184992367338426565912378398742941435667080068116020546770682,16999325425454851471000400176480399381440753089661500361295692310681628123507,3115621817064730307934070024882122808835435845590131246374645701268123516395,7664237802103239138782764325077413451892718354904226049706189059570344004578,10628974555344045044380058670185713528581140293158876652923633181919907860739,14113596208322488293154755998142305972509624369829087071590744312673264784912,17464956897498328434098241327703906248729109105264442832066471889452262140737,3306236514619936703817193243747225028048646569484446722868278187142340885606,1623642646505969781806818562148062924427827461950798461560800231691312453957,20812904557023426950178015281581063697341146335603865156046444216576536158479,19408105996475064309045111496637572365855316086113347445820645560307476671120,19899769975875815048945884537401834080401837433178820364413791122141366658704,19592039825831921790276944621603771771915464940035526138844575559711905257984,16653297576149039984587104062729832787430849403617977005988111857683169262526,9600749907793807254814822662348056400280037933879058284466549496283747987313,4481371968429561669477332540784950497549507725682080986909471734800926537000,901971752662861027246344512729868409066847439697888994727629776003122477075,13205641411901359105414809635566186722302364256582520884685762468367549487609,8771921370123544696277176259984315154171500395079224159374189372693912295384,5174975161282723002634664972730414710732925114695376584668768207090019053678,19270513804464040100949263044402755496385234769453916866026752765439740596759,21159175882383323828715178134104379154154907971797847682741774730382256211237,12713085776674794152643870369276859988930155976989577699924346924648017649124,14416880591724909781230787197474161383703110620356522560207527702042764430665,5782775977590089860582593877799736603230821040322957359619681360364621989990,4476458740184410293724437897879594951652562625859170065641235900450054752275,2721806229175990973363729919729809746838498228946916302499795336059265315654,20919749045138523262313225773151110447007311142131682485436367417448435698000,8313744079461516868330165973726769605125778482558912200259619501953066297351,4735608165219550054732197605756732753518722979705458514715803339137012677807,7197734920840596436781335789800800949073525267054200029424794448358957228282,21023118349982419692339995216673708826739468972915634059252379895041124776477,7361684304536881013610906796097454038829033466585052789468836114776912784525,20982662530655024673207268539471241193218964077396502472563124088553292010609,16223276590978113205386347640415975693035764887550533934078089596214147119142,16855050273631391834996719887442993598537594692357829619807594900987141342279,9447886870473301829371932239272857617552029212858469830955734178259213680272,20832064076469714454949991237859093636177561963691091143340405814107144265638,8639667923938888615556970427023258757087537766667818930469506422086574042603,17264766416417856804513499340974616744303058001571461329697855072803549043449,17850880215521300838724196369662075783108857625488733013926883881070746974079,2555423581835096020752363625782761123603321345233444467023623837801470232396,287393475373800420687070196983041262901299109116957212897422666775745916878,8502409129845334137896426506380979458386453989629214624807418474240644490658,17018903560361810748608552810594034468026623560117430817297647108682661433399,3048293276213593502083356886493678223968770697826563060833194090969377703128,21410637907835525984647506144589609474305790431496436733818309371828966617019,11884766464429332615888730245830253775469158860120272524933094891366345545984,1404751133279371734382153067811682787285007352946819870030827863597870240066,18533103709771766357713924189614422821669511650512088621974348524596673777463,2245746843374377731985282335022648129668387693745835052018700591124673151499,7164798246992914028921284523335117888604816694373355756451086598952914018661,6547792475751145534229851742995938089417776974069115284886265458921995253635,20902177810420148842648372790754609922473216539157084210657172695295335305053,6725829188763173291829388608607411327488468861041838394166490103857184986505,14877246205681405878429147764831613204208078224683457409980647858475648710211,12044111044800943869325640584272709159106488829628178962818078442934011738582,19605231155471418918091518582371485038913937726379108169052428896528644150703,7703294969707260451899023373169584023358521879520637237253564638222384534453,8646812596577526500078198446696820195057640949335282980927180585777038852172,21737243780210633072252501142816485256289884504027720271756348514717163502438,11106629219138713431737722416937344915839184447234152498273695046605412717853,10776231601191535915748483208366958548059216019309096513250460388757814780540,9570793764533387448268417521329594330897759769553789809193103230402046525968,17679865315281322154038759337512810633677645281028940369384987651076506608513,20575490035801628850469464797342943234291317406364190353186174477643080398289,1245923103633930975302215942611213577964303545113844948930979175833556792302,14007490679559289327503467618330290757962057021886611213555145469946035182448,11028796735236022300483437389742268989348582903251651368706557599156682851942,1556450270937619861275756908441730263281625715497049030992434005539032147429,7378353234583563315614681819214067843031828330274954124783678863055213281539,14666996645204144598922205770204386241062541706976832276647424877691625110244,753795180391574509648864319525512763100129705111118203505048417049290278879,14153559413038217294172720643039696432149555359470735393924921410988488820985,17643076982867120574893553230100217333463357095994549461637738074442388603622,3578933943193517852178000450144796032210613197873582924120228282439809826887,15520463167953252157432945917399723977264972626433304226673421190651502497625,17211537329205623730168383274756825219539545439487707555783029872192419895198,9802003881898384149235538364488830129822967333024012959168976309447054827302,4277753965394311084543194762939932271526308682615262493526499362805330624922,3936260403240718180440931086768355327655463497858616640513270218914599723610,11517607066800361513856730397176372083814736323098377670788083637850655404741,2243213365229554429675654538157029776597503775940697016289614299870958139625,19764298184704281654348385808308820923079630109704889940202178107926508921613,21440201729469627284915716136426033084639303793622913729895539439609852676483,18865357344271429482320975819341476664123167289165510208121280487753271844163,12062934463233700754743031150573591813637006411260363192982014497532786059086,7253500424782653645261846666860267886758998073654253013071356444451212225059,17688280285743970528696341296072681725398428119833052669003422836815517127146,7296931094727393709963826609746626294291079390951795401509403882666626382710,8944898010968990710934167772370816765379846965311172103743060979737069116954,2895100563060833104606048044246656016901407622471819180004918143679777127583,10049128690674011365994516711808882356477362224046294433720641467109283787161,20809590643316933764584815864182144455784236186778450054494378700964393080470,2552959198983852034601282535517138215015669324552132996051383405020865478519,90024510729703363025920398892759893841503303159824575434815310687587906738,2438402150656393945636277445769226062775867161339657212187540106747284678617,10290839327200266675482043018636710429195359786802953032677212989307055380477,13366445998820331718698457472184546771717827833722684584206646838628538349970,12045715338147601791240214774093449384918104627310882799600088155093595426276,5295711531017416568724842720044505396040371477829249515344865310124246197980,16400063927954668864214504458520657934817841218321732614334739112437744352318,21834268150215228276838182444784793459928322632598421948695291555558497507284,4036405082017497222204927366812040809401891394189816634089482334837550533053,16758010699927998006904853632308429832737059675503937996784758385473294734767,6851323788614107612891077153396783509346340795017622764414273403342247098685,21242220940510077461844092816930517552035812681947928514550083154475902790925,13803558028343943472219115813916734264304316037691831164863336831915596589841,3876897423511600793257560948470150518761848801469200306022138001232700430094,7873917719931107857936523614722924550340227737594948157729078597073258431354,17791290553613199208672721864188024787529313403544902623821727403694762316966,4509080040196139117885863635009327583647452661266153933806446923314670630597,7350149044068266301432651752105457672961955568647004218727518439545294630219,11503072465150450162639608555774152895393875487845468619329760555955360089418,20146546283112595992038998747954746814923105695946909075842241737548546646215,3500661581148278300592438598016870333493992384875150415517341312342838567317,16461061867640825231072403805782329353930546739796841505995525047519357319535,17419473457085759867681212087981664406569947154579733189885809269345147937957,10330084554893529954763451132860402555512473901655458870771994310647661645739,10271306411842332407495000297515719691188342515212338700550984155237667774587,6010614376730465540824294088181704678570427743830238021642540164120787031818,12211956821531047081164047854393417207581329108889222238958146335322243725690,18026227011560759880520787750218090767851915271628616216035782860818091527867,18039053385352422125173521135868691523650276298214786020953324823686654441993,21572961947836757087236508142423227244602094617521885308238188781724980380450,6952631457061838308719934275464119179697248499343745875411129234786468691942,19811900079804396120677471049757957457743518480096470411626681111649768726526,163137711020707070877550733174177256426010367795106166965347507600009523229,1531253433144642057738530256773902523524280331634644205392973718192895734956,1179712150612295194734157884657760659826346075044485388437451245699680152105,2729710616419138683641657553469892671426309689560939345577118202079250084236,14266054344296739494440365684098525973737250786286154516241047965660978988270,15026169712587706365294070206936700891511371850326743083547381843796350317368,18744742519058537072956390943103111325221767611576688631532967525091526599212,6993198712278030093898597400393962073007955430382142820465138278710889662382,2553141820754951085470014997086944345325965756649326165555729099768987826967,9720940197604032044323074196225989267295799246574437528002073812640512558241,17856885570331180579712689563952926777618369125836010409080422245803122826927,9316647413775248445962902207564207480723728241070369123275732644991331488677,14494957198204561202111268006350266984666563257512595231100502951029167863544,20990514914454458611724181917618445270429441499421925167963524958552424564602,4471904645719453756418626304970674400441871174741396875599881395188613340474,4684361390046158999250125407700867527620809473388545037966531069883415383449,21702205249470184149930308057282607474924454457414198304211876480322358864836,14125417641286741606705374243071146588481196226954437992372061774013416347499,3703736300177825900679993762695155186404123107499914435631005694624510941992,11732888492654216406505460448043873705030240266921135732988822696780340208946,11933466978112969006229130396464073172307879223153980062784019174478752039844,15171000950368540171664824924290660122824429581656415561069429955358449308299,10369486846273450968605452628621668108353399309158716739554974304206007657467,13426080534643441487992009643036732384216019130391445221701162507604477874092,17202835976136422766224805235458239972845135749171745123647755691905320873240,13003013510914746051603710434071109936447243726946691715828935535255320452661,1672563195387555152025850519159013960714433928303467231569405674199001377183,3249806644396047380745964934114987054912135505311534093405371566690536038255,10852655605415322578561541069174913253244788503288539822168510897694861970183,21180450898750475729531605846185254439124003420647553715507766256141444893981,17598208134643261198923845998804266441503487273381944592003474913329048411161,10560430398658881239820534975865220513135495522309722014743734708940471341227,15940735766678288146218967299383564752403182243037693045705028442779781161429,19840721391058424508364187473208857771270089687968326863727366457103504697646,15270655938735284505864085399423312069359806468400434801172200215370037695961,1774340315063362619348165557959238806046379939754082379283600857530102490105,1931473872849034457489264575043647960104881629328524494861951197166741512954,16037503795660448209256659529206619750469738788435653064537663524466496564778,11157294725944164923451173319705000360949753554936504404517553331688337467555,1860977382172821235372346764481514761526862185187436148114012977011560461667,7554608809888667328824255380474433026692004240460849082770678269699854930661,3812849161473445621072899414157938525926417912914872301607900000816805333995,3248257538394266288019799770714987078883986769586407060306626631267726656239,8987711810247040851774885826425578893413569065851274558714617106373602624631,7002808931888012021033077336936962976185388694934605760542880449764655464580,16260071391005121724128685673030785454758719454582904114834030329423907463299,17301316944867831355470414388420250906247821380560618462329913428602672908525,19139125176792761113369565771916762091089412261263410641074341972472699592037,8186463001964086803315373078973607488567538876768905527322257145549601226661,19715283945499391078117757449557157262014864431503022516493444981357377102136,10201366877793384824708227219959809605313335011896439133665539069386849213406,18657679796594390529926518390837962343392692362549805385222541270238612706361,7486580570539115306934569904905950241452751461260355433571179343632374451808,13210602081373832317780583229140785143149759155013988676929972636959898239126,20547921916591862189543062064340935912295194861078724580978244369580188659785,11184938862747662895633149920437248716375494917732149572183883382335006977362,4564430184172465843641043220857544376847031874739611967386619487659896927977,7141474497649513954000384074955704105249233034539438859110223132506810864380,18152904455695511183625765039917137650094202440231199346119983777378283365068,3538073603808733813419298816140509998806938194073503117538238879763400661830,9176198085009858977059589400831647890975463959467315677036348254379008625292,5358677810755468005042017406822742639656433122059352601335552810789858869197,14917263528903508585499167331159661105708948785920472586609175307188322712065,17459264445642522670023202416244479198596207282984954048459225794985333792860,18314375996391380435570814127239902609672007999779514985166492867417826496725,3831982114680501270333115239154594098561342624259756350309439921335535690506,20912918104665637113589191778450022009791755974254243256571842103252066396138,13641033990672188411010402475025484333293999311081344333460071084676167264579,11812251882211406110219542299092601278938747815723382992634003397593468524422,6831378526897417143208721431885442730179700977603214290972417120210221051272,20566372962271447276247738296560940562676849411310335464134428317792972599703,12645078398048087182293658191360551774451388858142913314124550234755654392800,18848512616065065931619133098070120448249278799586409723288680340437325332421,1336951976108001940844939305921535183133161033109848951359362159969984671656,12850569062942139371781102794220985236887099863147625303610933201225464388254,17095240610637692323679811976243261972135774635008876108449261858372552686880,9827905280236638995189439521379169431346954052078412963417337148237294494508,21756974284757687824674400821247092844224232050435881799264172836701664225928,21071024335098050648915070341467331164448998348673899538194227711074199728981,4575704980288845009798550678411618457862054601563658773482638217288811407473,17637889149961283902802970141414602882266203898461797433796173000208254839889,11333768795263093043465906246853631488076833683398258097056018834885708094795,13237413177387831469342322098638791101575804381099372225484902457329675766563,17644690723564191319649063794394358703071761592119981992193950976485565800738,4591566130221102246468298018361020201365534301234509687763578673293960293459,16880258892960147740975242226985692424894589139379261939284621634132328476631,10753253761433799332298845732798867046726308621524332340930656512278172577964,6294042736878992012448357827249736553756583459648169754872627240315677645950,2668606416345354198548309314080005930475082556427535177631964192773305378348,5244780336143933367304708103198860683485779489995095073384345019218674347056,6113177497707123341972721698332981926287006839555002718473535918066824223034,19824522867272770281143825792424101858356781501070734931688923418771980499872,16889524920861245550560790459946848535789402393200784095555799980201051324212,8007523897573727144887255293212203546407757295680344011669395834627039767919,10043972607564040581522896355091368769007227979993058004755493078808025405133,10815879623965899246220301442969866254505652264417667341661157537312485515831,11534947289183790267549825879293816175921818072299730180286203718992863665552,19282679238458671513808783870622522462539288436443040483594699323647255140729,20993973658899710060621174143488118082242133512002997296378188507484929417581,2207137584463635998515616548473102748156816296061395772266322132360447742245,1906176303891379788266254493945992658935732580384991589403254257107793504984,356009908103458769499047304270411564071705602811825215044685668712377389204,21267156990661889558161221297711049481880243497825013463587260785886036981575,9511026544995595131578865949819301816364113937202346971334793771967449171857,8732150772674776446232653795368043280414095192666412295836279503085501609742,10433912179719211724964521733928883750833304291050102060071171195374738464494,5892753211405353458072760353770523366305643800457149832130812257775605711230,6072173732058843459603530982418555383917328480859906190255818160437636798624,12537411810282601586400313857613201485446415283134353086651901233218273826014,6917382548294560607950289035591212885648538608975878502811670462230179895717,17522466317865452308300593635805699602531255301383258028599652149794243037329,13441087273853521452830121325700732493909228483089386934391461759499905593163,16343244966838333682425984150791963916204788641990311583878776392583665902296,5360331632046740140575498209972912123753748791093482084409464010367952817372,17326261745640411514384830391871497358293487167841563962966663074154000109605,11832463539058003103012764436368900007479300735896611859760466513560696030373,9332530307651641794919337618798260519292245685937263028043423079258661105173,18589656636963228136343540063542372097923688201290293330159927366465643313091,19867733544550615468612533273987508641098463295160374186223389748717034468502,21122779377039628476144200947919650885809091682970982371472379500808529828990,3027016623356326893238890601376138710903222026620502687697483362378227239102,18688538985571458464198537125324538836996766056814806096466271703920561848229,7011851562043637216927989978271187524190844597096440024970832115577672150682,6976276474543022394298383474157051715295086098335344328214084449502467982887,17332130117530488369551999111592288939240424248347612731261799228734373086235,11760005773828232229811117479200618747574322788890348748345009852749579147876,2298592572354833593457878362078773063587664198044761229360308644323231458063,17955258451898615415362730916130728340133607644716002859752428726933265234272,1495160066997898368260698151648234013994510168440470178901776412293213577673,9194083678217569822513593808499809262580238989709793956568701401108176409146,7873147134182176342443626581580817861100691419143183095128784103924898338758,16767569430250994260298195321407617265691776202802582359934917139510241475993,21740623993440608033243076692676917908105712281956015230238773795741552902992,13259811027098062609299383180292487555512077058811432839971137250443197786014,9862179315713982904488948286370860706178740748908626205136774943873439543978,5283798667794826693954690769969228006851703579605314207478989967594232871036,4252584733067990475653166725237187089775889157323429734580856783776820381431,12973205666610532230766585121029838349435114222222352682635156927179891214439,287633827640277544463301235265949941438188349560881553375976425107945733447,9088334958857736274159987824864641712847858830802240840003039491617952671684,2339929702478917712535010770935571285116447513742167345028949204167372785538,15676860121778371383024352289403909294835655990865877574625753945822204636877,12764603061737711341313014678756180651482961849974746341425597804386430732092,4838308895208597109198370123135942497394705098532245211834944708850927126449,15227615340505775109084051882530634970803647261111629470904659446755110863564,4983488923883229416538630982432842594678976476580011041728398828823305128910,13108944499697608875788753758764556629418014383923261351989967790696566041318,12840723598548611269818280989252209606886290717050913748780108061152527561849,2952676596403552231673795576822772308483388566436384169804788313391241403511,6122163114479319080164532464109940924328926458633830912986940513870140253539,10991285734105320972904604247873526149047475605919579896179431815938092849653,7998273930160782917435322581864589776803914924450929021174489205585585635343,18738565009620163104846733922742158284630011729404799909319718271414375079555,5267789578561581666385683546519898747246978052550117863765974145167441262779,11531529707082144080873135819545917882620969294873081450175882450957416920799,18780101368050367674291690806832757013309591034560713102040071432479406757422,4294785451272921756656022299749163922793391211928749628139961864310109196353,4709384663557124742915933403093691049837232917871836683405730215659929289723,14881387167977166163300411047605462807380624840482159906092434632182882848470,17882364021447094903093424534075826770336257800280425962604559742290433282224,11702502532561044172145178834042891352292518800414731965233576503757342967409,14059864978850405613608096166397211820819484772138676470000521070869797461865,1780174207952381531321288553792322300359882548955331030522024911690744446923,13028727766195703514931384985263026051594836628118028800883341509333550916528,7588265429164678210439639249095081332309245305288210445601269417147124081569,9642265589138009721420730439928969906364025440120910401773575492361904450076,10203823545087224726196594521548654230876294164502500177215475003344697986058,17120058099854629688232575694825768634386944759592366006492580522962871073389,4222192359475448381394699451673800507222765289015074154697111370954996368735,3993784121910007141124454385846036053674166308991223986620192089439929299772,8723933019744566416337803833347252328328807961776170035099333968332078001000,9712660217038548658606833881897330347907173853654574936296015219821374200265,2760535358459121107870901826259907500576486637522442431581134088651955908758,17117109873353435959712351313249763994000699552995926658366410602189225375298,15834046942685590805387820842211523319635967093317938586307927436446892526328,20540611330857822392080560199608407622162192943120548518785800532555099780387,859364761671967022958373408533303411107861007743219314752373993491065278500,2969887420026581030514962118165604753428498019600416703008438822193590952680,18165207804423071202274226128984095583162198441473954125845000361590859071975,1625906472120027348769657238152772240899619610263515830625917309020852034930,20463932955653127762144495520150037479624855783264043490725916287067071124695,4638144661708592747026214570394653618741348169520846615537958570570478926642,14161574596481971299443338101939032775184122775644932228990090697003591542529,8347184524978696917103428134030602422953969299144482352589164719698955992623,15813323300222999983430155647025925955486314051966513470055962106024932062990,15881789235120065904292616653574390818033995432226550640643889297228035707625,7140692095240485283381028349925581289679980854833888018152159900503732423858,19010917339674038277064587622527941116247281757743905062456743932291367865210,14626089726879708665184866329935404127909714172968102824599946119716141024551,7794590602415713436531570478653055404401179384350609462543106242181653823825,8762400452539506415642761970628528841241237486958209742944443338295503154358,8591771034219068368320608087757251879675617969654197927442982939795060041474,16722135923767200283514351262528880285637400101562656889998995533577538049598,89464124861540540773346410834052352014308242060847315373495379383140228595,527363371365063907312062782674442937761539145521639367736772902232593392996,2507841963726490485511335482108618130879932510673214677761709746737826243610,11600559113928855816564236457966654301430060930571013803772049573600205529037,4588632959705258135254026492226920833318427708514752831324568512946022675194,10614112216523109461118034753484116653637318222297437542653638803709000476069,9172525851971416839816439437260881435627775489982516326698553647792223169716,5792656644651436247861358501481981837063028644438334753333821264192324104118,12896881102412475846285309217744373816727588379892851016206737393174951411645,11468716910877986153680082696909131615615571055661580004775449060276352989554,16433370238306953119452573705529989067794419309147323079675422756276020408035,1273883504219371718563834088540759123243117439006904940363157254976913033897,12035946135822991823593467599431819071656367730183582372112230833767543617935,1584468415480349659495095652095228645182004993793756033988320959253925346826,21386287619427343417104905630296265178906342440158736945069239788114458023785,8353771053561995945612416527531464945642582086497086814556341372197660908215,21451387710023590786286131498774138351594763095518652036485484549943942198584,4310607037909191923700937557843586755810945477870372794480216273434853743125,14760194187040766562518106717503624683554510559335502353786749509033100485706,1989722256243159180961728174407914946336713030784288455577084756567680416269,6686508185527220254925691658356528598024140978521686081374828691583660936030,10702736220547282218129581824426150350875608542279410979052446031034395032616,21518832429688884430739158604898893220375510075322761868526168806092202700739,18894734518217824473490018310535147336620281698236505678307171602214420149474,13651080497325379255207286313267854150042736096310351308026009382931418587349,13005423795701931110183481387065874846108794433756894029607220148510576563022,1791508640954698127256430696076954377556671221508186631495000025000560314469,17328036510202475587667192203250772802218778208191122529787186719212302087427,10657963758634548274685968417226435837089760791121929723402922305566484150027,1373906129582260565717689440357805911187492936689152530374097510483815842229,9959127778329368795108284764279846598110110516049484774588901738715030294501,7658768549089819420025961609972525260083323240153758777076357709438863924071,8556349016311563259984530239150734383111823917689615136867121162886430935013,5584784611907644257624218172047384219563403421449130896517357173082649535408,12250428484720929053394094480089037225116943346244386549438429776642627577081,5894587027805929865241808030013307622768224687737099108946198448930484926182,4640000227377695114780725548825120725107463526354871525420448370293105443156,14209260856334030476503172714481690115491571124367768551485878619193949022436,12847259932859893012278918973069680996469229489435970735462165583338364177587,14707765228045361126133465815432967736466274565508518646993164305646449611538,4776938221827642494595066454007024055266353658953900973539209110395754289252,17345634507638246813894504405651157443245008745673515073520154967327741083655,14030342049076255140305545268617582878430218358427444316024303212302433090888,3081608613732784391792246085705209806228642369232320349344206761814264266822,6925544598968002128460287121334907968171640408686960604018975554503413545297,6436833790683001261207201071187060041301666725391276179040664384301147754533,15822971282077757697408895884235910303980603368062126288859779292088533186609,11405645516905544384081084440311050207481018746793339445931815864373601814301,8057851956466271394801907096296448157702512819801554261185443997708792484686,13400701029177845728937105456192536667124279186738602373189177143094323643048,11966218129646969536507242899486947493941404691279766045602150839476320695158,15426703084090770508053125497176086377457196612492405232875849008237608103107,6284964429736232174040445851307654679317453722810844133660225254133335862235,13541475439682330895175095901646773164410091796597408681295206023344696136380,746760486363018018017386520506969904420399625886684141218702464564311095236,17524104887381990279039312517306518062132617046713819525042298049738730617133,879502104476554315787832344079612181105511927448955207253764010183827781938,3322243116889956217287455917347322211093649776443788544812848110324752380511,20993304704177227988946248236539217504266305909163005794546179470620336655896,15297086470600095823350435092749336605284701364464412627268330863173424318784,7926831990131610326614433341787624222916431629609577848917665290693634271603,11271157869866761687706729926953398656059815012440629723619426315368733378302,18299023753364987381538199358983670915973737470621191699559419975990005285294,1896523269277706381575521315908503178186583134996425770080392278759498041496,12890346501512276297101448381578516979954988837373044432656264176509301317397,50683999778726139626379750772467319774169558910797110829251191014869406584,2535823474764747710030290051647541950275171691698903262059516064562837569538,21244438525273542723000364561332886617309030482024380299212725538173747919525,3566180332124074953578668480009215478053830658040437750684892555496819182968,6934760873335280553519652185111971021084408206212600990256329557702647231767,10716990663016621229729175818785901525044168020825517922453745625674725718755,16032906457960033408967366361214250817346739568272864358714497113973437241307,3843556041176221664914001975628278428195138883854078534543734996192939783081,20159201956050700213417267403145919082229292739510798606395981692137742005549,3946206250066677142194595031646387588831888396304269420593204783498093935566,15041638172488186356886629449548027800133537204416329580391498341162500701165,13278796648404195845011313500265526847654531008699937318834233691653233844557,9401997027308433525669054020953469816624994577441846092561461184007344721828,1983197599992175511555068756140439953159901969155075046465287261273690782516,14404434816783701517710626513536590424905462755924351795276920360393132910619,2265153992995968786485646516094566778663253373238301922539677847420824091645,7566790081073938501935204486802755123563765476651717380300659543531475311797,847895502208273199247564103189534214890423186204714047221696858073193176165,11963011786171849258296957535441472428283852585041548938428326288746833247421,17377294274187023009074658259347356248383537938503682836124988411002248431249,1025753579901801011233785198665030697958075722777337374303401815648687864152,19284019504590857558072823196945292661333776228606049953803221551974077538854,314204118013777455817026750462293710777754680076389729833422020056750157783,16480262479960754021966845575947830901794064422051876558808623512389290214607,1118467174052506904085279606913979573425427098904935496893365844271017524128,19632743231294128529717484081406317899334378150630214776880617163102648968680,3911642624469919820429547144355740104724495930390962678347147942124333228884,2066832981312040153658964981292230050110396574171753029116180129049784719869,5311750082320962006044746418239249402583149931726835813032955695199748985964,1668605805291951132468779303736499626803321838797652736089353191224211818512,8117527083300107176240321998574781132203045054266787492339353711594335529709,21295747743511951700871264160352432803897824342737595930859857743511472313518,17388383598447322131131146498858701344049179581377651662282122447439867066027,1285164961547283134680842635704675169007050470102043475645519044978941760131,1875066966449664224570600546742926101175136253576702799078476168727336032193,376316574400845651365366460471492295014146006765806307181242245707469972823,17926797393698382320151787394969682377223530524132422415508830165925306730854,12888413344274698384267384086384474622307363694087246755565655858542934044367,2287154516202749380541196057272317720805230156010471100500251268302509398358,12091269896021030725381711946583875149737687962883250402694805482865888072651,2866048333839936509265230844807967492604533527765757660355779329791008604324,11835071699154512268334373994146252361488263767766913426957050581680705629365,9769574961167512396467538163460983111263497516872198932597594846643533678886,6652717430998307400653769850757364796566010885765190753303419969578998970914,11706514210298927940240806568375915039663039872151275540599047371226868127844,14503173259289644850389467422758670421081762433800521230764199189580041755978,14819563269715549434612532555018280611140077716865566327825448288943759458075,10680481968851597237106707337987338182186447633463836689709242917734021556532,8842568676211857695295830062491586931539601201165478151045194686251206282625,6530738090493870852939715092085577161577833016969257865187421674974986108366,9122348442271830670856465114634608231502719005088669868106730029655164877153,8276880496499930549062062890222235677345093568048001523633692507246467514288,9159103567267771525632277936018480854652194329966882107551346987942837974086,16469319105211987147868896414457254521940280033150431057117354850784171354412,10187807714948737954868581824072203418416253898435396377923197796615888421106,12487902950231724077418777903531512931204649041424531773792238730349062186046,7128847500406995361903929050204217572789701023482188856789540128660376992648,5624482939513897521205456066520453513748417048856589163079298385117683428424,16435310041815433976313715464222273283215148709695464992270777828213079073600,6053110243546717824144224394047966869215089006720239359415188827006018953287,12155283178966050547567835509058470201630806787546132608678364857190533906654,4516299433052637321210501303761417706907638446979735686067715866937355560218,12667848710309960989666753249292981950689410172688589690222261363826904222200,20798966719534261926649504156624517814254561351583702314533431478871413942185,17967549743799112209110259394081841952094330269294500558315036929658897218889,17847714150935110939206476281446907230585782511584357788270839909827513843593,3706525735092193828297046649401002937097518714707649753675691741717374375329,7951431498272893618049118070591089643051946670270891223821638082032777246372,18050610739452223409884731462410705437134574403721907246909018802102148878228,7681233452521913704953218921671929208806506209990716853575264423980840711485,13423126358538883907022095116894303361057277664724853411599423630968340874618,16385186307753207860551232886321416660506143479955163989130433021552655688751,19863338799254785908021006319182666048802363286601429063342266271260238637645,18613864443384979831007688916611349052439959929170133474546815634162799183324,16332951432721718166552572222119667287478083212745997662304261644978474988848,15183520838042840868796366239500461619005160337097541115133209726620419190272,21819632461581352219365791577295628387565956152415171439862191463144627141459,14048533271709057229957508911818231901369646548751751133058494379648714713155,5460165509823151384714546779805746551465260311624889230527298343216031522426,7812320479950772901428223193019468171803323319794359571259026602925413892220,6861047298949697363524436975701264276161947671796912946484193048676968364570,15350000814702190667768044439440847568690389883802239839819456575900015807805,13617689242559757166326885110516025083265117478902533337635065578646035372109,7476843340092386505769477537028758806323421556263090744578424892783190404262,14826737006932111183364733677544376863485041173382717893595766527131815613201,20482222533304950354756700764919164516648372491559583778492129756055561547902,20761958166613639518991371846609568602964716408676516216766187562459779452764,383428479364004198529582849470440881390404766297544454256885030893768964772,9096063532469724072461386558496798312147772678120608720218640484115240695555,2933312980053872879818024429044461919397766967639471518371949595510364515880,9299316327986512295931957414766538459714522358165090755549540858707887390215,13488092390166418062347006407529577052576958127764741552594028975338262414671,9829077383468426688376344724031102291718825262406301642537010429132676001524,17306252922949843274941351200908184305715966839608017699204279919732909328171,17087445274779483487397521683084452362124400111143021068068404568736590545834,12957176730411938817539171430465916443660534484629425102659921020718336935547,13051137677735706323786222675600013609665436923061132301167672971485926193799,16896405620483797393236904159048703206424672638297382666760526590725313874095,12982786219003483259026043754729673677479461289605569386777999422861331902406,2025152781178874327274493576789397778291707054468278801142821085671743579422,4335304794121497318666085856101737871981186359433585080678838732369068576376,12639022425423716913754007933194900468141465623346480681305462334218095484056,8623058240535559764777469232729047628411050024996927445391922152785990079007,20506335897603554545414833361572976187621941529253485759521266317325651663673,21253532477517846630911098846446871983813752932337294199438073014278982612265,7690372912700906813961714562821752274841425123411432854046237798188463759714,14774079281706150157728885377093724231164512116594840467791057304501073046227,2057509476014278951878531863305791034496952436217061173216277825372715694262,11541539364361827516114507593054831030438985642093836719960774810015976254752,14751271529818502394785288765886130704541730104426205431367858892918636267768,20653824984831671829709191706456216192511770845470322444515326861038843106056,21794617070379980226628233360507465028625654800811478227502718633923944312665,12337675699660313500286885345145964244870355316351529815248466118884457457726,9527268832683847687152279087478212995292048665053951255936397859316414854388,9676848840550815858798680133955006115514366150476209999729932493584446713554,13718457801302749437654397628557435190188493872576865462727587887532950355038,3867324761996955514268635801392015956546058763053808698121442586705196957126,3945177530905850250597694151686052963152292050981415927393741981018273529029,9473309264240097344589730948390594137445381539328377904021534848676986947654,9996385364578703060792470002743943020203968343080025005448261317627854389642,7671875350824730767796781844941080563527207835942241721783016221076158519589,21342545963270813418079341151020475012992255268798567166496112378940512106806,8273987785742417777035293384288140933989540189974521462819168552306151314447,16162516432221515902182136237589464594279404001688534734264317844425059661177,13403805360231306331901242144909690435939614369536490494604700225511328976179,21640586272648741017978258285249302214133507217427529405059807093199643534960,13103298902142682492657114828016226525668797790480257241873358498200705227711,3251016042668618943397347852790038985788901898321438389540422820491143534512,19418047092207786422594959190763286166909227118034848590779428639908706128141,16018739283901993654877226905623763753431466873170287728134253742237701259452,17444946939314191179654576411859454283526068144165928707555552999432295774923,15128585121813842824984220733706899232093493608422847549831681212432769497258,14256042951767483060181875165067417249801798477941578288282791927486641413650,9120441102041865153472829977920901798404277796873323854759847010789551358565,16824614118285494743762017938800453590083305489658290570438237922163546634147,14066296536773839458459021526010711790088172526749593960873828093107983908643,5017173601281838065126812757441844223954524936921765951283764327160567691674,6254306109691187702602819001106221686689064495376117914248886700342291435542,8093845266500847743481398069264511597137596242374064050252920004891985410254,3578536483838573103029984288079029549393340013685219142070711310306738904812,4046636520929111297180341957015914921052723918845140326762981717454102872515,7446649718318072281388998859356555024817100796345520325890349758135889404482,12366828085438268177090003236704251656102820345668679675414643578247762288715,10235336658636336826692093860668421345161445948384101191460476320469211290719,21557699385719674753050624572282725191612933706864216121110471118396873804204,21676195031234643974566056999169564975565168161106308063972653296222128822558,6363029841115916180506080615867336124807912331702908898766344258887335068638,6363363442473598630315975560083028488315295047134858188348763022659100540644,7124701104304155953181957655778532711129611550814127577450223681003954918096,7205717562822389401795306034882449236003182581929449060008168502546885140420,9228704321577313703028591075278114440418729713968708821922150367010520752433,17614180549151511016628006398127365390131305608457060951973438257438000114647,6418032200333926158639440620980173724897942384057810379437154014285875236793,1563831431103246736895130173427149853201118983353993792302858411456255839836,2319462743404521965297213055024756354349733992588917297296444679195296432311,11927767606932195981021511932625975307755048477176557643420944859867328059951,11544836785666122785129617591037772824479186137515525949187438698705551844116,1594554937757396474339277849284988438779469013126014780880063013190163371374,3090898925598297656723114627648156566177591433413115455417582215942083585019,7446365483911748580722671015415226813450613606623816089630076567220802142731,7277804562221458254100595374565579800145724793164291138831756170012315181874,6742114513180059066582114839865181272182587124666919323239785847603969045455,17639336822454434815461281360929380680585323524008927548062809039584978130493,3577053914395256679157728351997326335158820293078866565158939674077090010647,8416461669288393104752370629542582785060946946477447413022986748926853429341,6094400991411029253990297530870616276561743402531435382960598226029406844554,17249210115827920255165876773266699947215322191164909559927557290769226533383,16910579881016588643870584852395328514859173042128957721312044020554328803878,18548800605828674358041671058553674062230830447893195908258772241250469878618,19911311709285615075760278233929935358167599770457743440215721586291252049005,14163239340563250030474254441824385465013759375574504142110478434407678615583,11636512441693145656185679602762396225011813780067642639202962721478584613773,11627821975451263242823912745820712501746551642630006051017450144021728526893,8744830043459757570443313311577350804214757169018319227421153827794333111861,15502529014760684785001315229904504412899268461167235130234930235025949266727,6349631474781311552829280885666605465500111601027794362415725063684145078154,3750521632595755853919734934063554601358504982902984744970328457148877834110,9151149071511054371049219579896119997746835784236581257692741291133486546793,19272083712610290647942715418077844472245445971738771938657138000646231164194,4825691749471936225587218745193692386291702673577201485716323799193545312215,10104595857457718843210330892798628518507052980455210862700838136878095844947,583353789674136864282067863249996585561603923757420881823548159264798915805,9605601189839871334439279312434848410060547509366999421152290140420275791851,9086947882810130237770476626970553738390827239675874433366363671998428155733,939087130792625935525433768373221635016459152936104283115879791761930303865,13281505022430256926767514868008519612680654933479762886734630854898956588159,8791789091182070262897704714134448615861594471173394864103714557845783501440,21362425094620759937169033441239641099917726266745789893288044988022041089124,21264794594588373773536904588090499011630449220310853635095227724956212914745,2201440000983888343103152416697093803247262395826184450099145084240341640621,3661470436482399872770855708635287053510507688269721514323020960038319367739,7839180633039164608733079650881737341586893235460147432870429877862925246133,1364292691308802542355455613317294540368840799230835218243676354771769346816,8772467089802087196594680904948784186594877728663145042664601336273257169460,3528294282612889297228918585517392070857581849271784732463382671241778115171,12283613789492092234060914364373118974353698674396863245366831728069561564466,12820604492590938203463369747918352644874868843295488782427665387357902190399,13019897240405241197543377542947534699610589548844172163916774096781016951470,8978439745720039208900766235834036199032761881062736449080983584518864263026,15222275515593239598230012498885809744566950744378381699594010392927659453864,6158846143100676033784762660398310184837175038752344358512599894306514737286,3419255917977463022603617504775890366430819682320515293245827217078337799273,2797549320616484645720845216321636133654549511963540737715630452964584943931,17033753202496389008484483700445909344644255293271694371709019653557282454651,1896525136564670388001069429586407694373044886658459111231294687089652643180,15410846104953506982390647924353051056630524372570695181992786623509940504512,19568185152800187670153137856814273221696851955003399523563214963248234462015,20371827999905064832491002071821973934784290275145413746617942892257828998608,18823477734276348993184895526705908983521278925070561827518170646437136680627,5656115226652970780235535706189807810471572029095698537591078819723656151288,6421434687984511183440563950015895899135677057679953590513947822215985604920,12040384754225464077155439050798210419160821091649797103441177013046869869449,9772259825341200622705640733478002328903138705997041039987261797557503104066,16498280031288829288227785307302736352936199535492502196962915104633784174443,2797879572297199909334218711222177900854374704477138347081058961121300793309,15644078107885262244699428484967291897698559437568086329631330880220396182101,1929505350484341295824323699861178332578728141996333839839142429658318709684,19829107623275996909068882503976730773632786622439634235897400991781002387336,2349581104996259830058120951667460730076264470159293978617685139254844279099,9982268711644224005105745225708318829304834159499232155579405472268549361372,9283048909915207444384413611285315401509676836116090349272606584736947471535,7228184586853275989616881380719765868918305938029647325846170897121335348738,9356148801854782728189493667017091537583121935960987886599900693915567464857,505609318575290577159607039016980344147219758564644283699477849237669899416,14366218774993226370408163695258733389122646477999733966996434517776361579764,2089359639878444205205504625611416181841134778729917955490118311877471215733,698820948911402576486200349924367867353277614409335325450207885100392818369,17294754169238631079500422194295778880256675645147530605338890302947026045725,5743114444764763990137499217919738961538814043960695215081370978081114004215,1532354676442440269809361487929394117850339080897231885482935144216545001511,15429279362464933048379761813318395642886047028548664371898579661267949218379,3996365200571187062769515782559269970838089444839642643284597375210723401466,13855942579438265547807447657820171102227439902714241541267837936207338677600,10017315263017624310653373895363026608166903346797759979504062819071927130663,16907630432341625239068562338272519243551636457245225084107387534876995927261,7499064872525146201613148795250282369576850162788310832273877734938523830020,18958126705503391332983508022395142836904315587480202621370522508346095401093,10592492611778631944134585106195825750734295091365114316628335289401976557048,10233935978161235645487498670591630814869863266947595645533111837358567006403,18003113120454128964459787917100973688362112412222897499908177070949705432002,7039143063746813662581342159908917130120555794319120640254054115394750527325,14642639620523941644124538953496946557379420056235185193901717503194398478844,12510354962778923417991098874785395513418703200631409704677335762559702597729,10937907264762102220987756825649855260366448774314976509103469790406549413612,2856291402269285412222070625188683697884675330846580808282552440813379388545,975737765008679829063246253813268073237541742979444038400325932865440884821,10846579585900798888776933082578183338805087990458930175500622018769094956268,4529602228982157635664617353676370544979061743349920696434925695574883870240,3217171861525061655884750653752887679288235310048470832136609603512214131719,8115945363448342140068934999604399115922267391140037880996539055087195710388,17017061429975823256838374218603998280878588780557395344098357759667769523464,17414822882733297737417491176979790219384604825369331340721407024843872424842,21674124478965998545524545297025636759207453169144537816299040483190680515948,17404327139726954519140759696696303110669221199013129437266401728134593481209,17114525865368445983838697023323950751616885090116888636158517909348665004808,13606067029568271979635008642466621607360271211611257253834134991337929444625,12697011972510852002753203688496604009044404157472710768958968780456921052232,17908262237776925120663573891641823998363270265606050465713306950786509533013,21456469759562487171462776687926242591840822996019886989101706511495101340835,266521013932216168881283771008004557613060760037591295825839278412991410595,4426122336489578598096667658844019947877597098504167195068107491300030650784,9386708946433085177945274757444606300245243689157314090008872819375610588441,17571201661176038894845217669278055388543910674470132087585433795958011317108,4455879691406517778738600662496288227132258098615032267607735047373372289231,10411615872931007756022633910690379435607807745769276655537160609832149769392,1369325193519585971093564667957731115918550810109208821335573114054160355015,11701493479673417478812558973813785951698004134589804881992366063053267216767,1604976076096057025943679983359889701146704427744088265030663068037609417365,5807894190026658662778129602314598491833803649976558289016319277596337255402,6604568830557716159440870492208510177395633789687151427836556682055398194130,13221322798326908033948171538573182873220915914806870794442015701313412462981,4276423994177015753526554880283981182675757973382385661312000468093685717116,20731982721228405909675906960993136550102478961136398510514645316644217252635,5084416110782735943752807643199425478022977025123417839387489101289418017943,2080632875247898509655097068576655654491657659787279629928499240720334125890],
-        [20214838738486568883466588390719332066160511773018226407137866846447805607366,7161524737853996242838650618412058002168848579199128467811556550737619970970,2264369418377007316930430297757084139629356094085160360541578125176213258694,18691044064909968568998201940845291098399339626807500263611343942450116503516,15978743992268694554518277110515494413411623432213713029162001242329212269562,6711615239704822975151699228936015251056551262955961924747531220602950448829,14954997163751606686696628499315041796272082739441018134122451910369305642115,21573550100361192110069886620445669562472881453105471211193858578537227040439,21785281999660091964290541777959906196912107196794342243439922177000502203701,2946923208312508080510106804563669422427642075683605437758174474435322095802,14039283821812338763616072949057938719426671560747126284782727998420210694521,2531474643515410792989587528850930504447014242967363822821359471367799986101,14281461695965914110119049602449207565231627068856382054789426564141005041994,2155595480001027852247471998853878746887483662385654030663226564169133356539,6212474220474204735846033034823136351584003532895558668927059407038678087162,21589299957493491709069669042662513245508573637668760884022386808061869005942,5228547858762057503048110033821407961973668275986265942002757629551762149969,1151995769496843179907951142523838829938796346663877830241077357918848539138,16195901973518083237059346288792924649902586274815274684503783828189220931050,6205461827971201267719191643863468322713562983419848159871959495317073732623,21004710389082547785746156915318076260017385298749146368429985483091499557183,10094301525352802553607719810440185681054064961117719137647202357989110756759,1174362264673060234121108394303385502501621739298129145129042091221378391858,14586772089804608057953886654898255839796797046217599185042293580394420546552,704103301411330239947625288325002010320119746677418877341164806595452864925,7447867166827402056774077383104558156866119014007569966692643297177923018546,4252152864489296917539284690826221964698345550054947572793948075436067436040,3675525234832046985215853449128143168168428943627479235047788418993254287405,20125795627598431311475910664717716586147044241536953058242999762934679572886,9159576094573932436478222856304524043339640337232471953289062354187369243885,10410289328536677868407694844650868516861553712016012272941004725559785872650,18813119519933909103102649065156934680537361290190751928265976568411443987994,15043786404237278119878717250753259786450872051876817420168142382486008024593,16614805203312302723146840789675006378900903626996105116400354962001922700157,899949298359737140980259063526066233582477211127560605822280959405167872532,8350589775626940122507262589996655703528509795097550101006133878991750882468,10881253968160794744779175936360108103824976232977458894007732866457848744711,19359742822671794584060954988237182553116341604406926658049749172292672638977,10716853194721085390661796797973316855886234718612858006131046035921078793777,1194676839570189281149587289656564753779383829131008000754135056646064455278,11530412134598354110310733773537950950490005376234226554463355736782774653810,7158806839647137330333220334046918613209783693378018773439140974716028082046,18873459493111992992450800068055835432261777460679870727272006783676545919785,4597339034364379110034269874329162788488647975988086437272199171979371177111,16047595573111403874356093398802733070084530893238592035018321960924442437232,192949463851654477795020911703008125546432931266166268873310745978202434603,4826544617576366487123936439697751633333779280970103286526767080486441353413,10372441609969764399977561535165700928227575842447057367716683958896898456242,21479608666927871465054861416648367371602717876964759897062141685818604541372,18757812710789932354215078701254559681588101606101822541277700443926569010598,8502339138598356500092304059172334649791727023646195989902300809704249803746,21240184871409684692673423121366677112492469214890212851758021155034260698420,2702659403779176675766431784851669876796725738129029887042678538644093630255,18760062461290937265331504644060340132840729161526164449611377215801441916965,9598514148929007169331478849372274288455651725546984183500169574552892743616,12460679873938368098608659480431260988399308425323633114529665233186673892475,20582262751655750693560201069767758489467289978119794831247596435694971251287,7495462389257720258504478831214292184152544822380786356126692935003910627822,15847020891468169726540675640439992039404102490965287792626266482436024810091,13444178956365729587956577087448840645730541657243126743158358416431709484781,975733333906184480394673719901416555779305044861384485566696694336272649841,3016935868211088289963870855929013645268121688015888423636516996750583017171,20123197829824640950428347870445510232078708523077317828689832072338303017047,18496031799198869774970797646230665906722932354114482887753612521775690376535,448875332457320150287933426080386825611557032389972932765197125881964153702,15686083476904717209874986881961195356503069952883501862704199048297926079733,7399632407841430295111381086121470926608686430000074868388902950170939693998,19157441199146430337309347165554892283908758853741856357912555742738097866135,16120175937370916934366957179931217076202557540631878137626313655342796978134,17363463873417672052573440102339969267068334412527908172228668014397269133762,19764937897808275673467150361977575240242645746672288031015882089680753193420,4264866715026149043371443488601547814355809386242957666273811883512215893986,15361071774597522987390988933793735468585435977940286138223232105339041682390,13444894080484049025660420839638753203298145906295848687612728375851966859563,21344396291142953621865942956005813155481114773979414786364869990164493168988,13658955537084761077271566555621122724333408573482369456630860179831273897019,12249794154563702076745009616085271813195258124596555920372455161542247237218,2325936171131642979629131064685171177284405924159468319138840745089808621723,3077792516542862676300186898187316876000625806438082696997401720196346610884,21531439209065692564653170259849715075994439889756241721092517464459744953429,765723669836774164873260120197059605145439283015732643840276151768662398969,18430565163341347334129211602477703661982280889871625277638214021594755964149,15168574820004856312411802521805000105968244665018577358614174215627811033660,15609931056593305381714243964783225295053513474263648739398875586829969929857,13057901697952283349663465856361305032896972742145291496691475939407531431061,12802339382735521870414423620343194986509343830854539673006232369799979885569,7880620299082787885902391014823825400306816285911629201048471522567587002433,11085221899164994413080236199596538381402309021910771788195135649489784323294,5662061777175931509849062158785593075054461300898808576328927259801174692172,19620207415640534190314969542389551464821476135583607027506853686406083753807,1396012663571482634431038119696061726217340333644346862093678929991918911771,2833239640477482582925766504780450890721725782645633022528100604619065406714,9289278993548596713194730547769009982667061443580050906003394115646319823584,255970566924787837673441110425992267446525707891905710167559324774004600788,1607914894461957709182037732125046273691353312066921168498378132410220447224,18182823650001333075321511247233769219797858542696762318647781137777390858484,7933393968545943401801081658073805133658457161128306876557740191220424567009,20347911076420909832061080138703827506796370399337016973599032573292195453934,21705355682416154516146726727072637540254191883301906287097797468012136754530,4393707213821090202627671673506613966066953344462172841905371093203947245835,20015218870609611793683104277034599032802947064261475029925414549380954228847,1857954279082383201486002148223947538500417662449637107611316684336169564836,17075622394357639776259605879156105089449277115338468776425087829255085998708,7849339039625631210191134106813689727565217371730065596482503614929894173038,21512601485458872387622978217203423557092449252654722032828165846830386134980,18829825907628826679915224363735067358668372607988097049308159580108100510295,20145344934445170391525281095510437469996020214770888614087514859850402376676,9313354461544201805378332544085825218707302313348145137439630918018863309279,10073510764514576042491642785075889098754556687860419668420630560526859371108,11174613823246619246542059297257164876488140873425479553593597508295299674750,14486836623332191458290523271325176557072260063250466764030358280051240942286,1932726606175618877183776650118686155013167275195994452359992776843317764341,10586981584735794740885178709528523597770788130558769643251430679627096503451,17058731514535449611097320348142652958393616886312564975789110366863616539420,21546144187559470183347034044609056404441744756503592317087407561629774536920,5681882870231768621749544290358493454695957383787481123871436386675876219635,6603033703828934401094376159910456525337139277249114676008536852402499584614,1075347119451441392402288921187671249679641364496638526228862984392689015760,9887880282527621962449293235959776308591956208594163166185549404667941094205,3081779595493746844428351914840666042619592907445560123915127502392400574614,11109844704163389102553826717541117344605357734084342755776036340022417198082,5060345909602600407449982784585458050225699107485058131116856520723613936306,20049893406143885619592680397871697055896501875354968455865404394786911398458,11740809795693360891733016778293494519471041728488086332325924371909574885493,21414777615318644939200434569971788107661288737252832241371433802590137831626,19926309906539946638451151936495517057597377615887396199326446649447508281702,5833294070005894544680949322571753681474561462111500624110195335953784263127,20316262126697618722223967532370347145297985363803056816800332573538115921683,20118897454905330779316757365327082825225674670546613715170828215358297124461,15893782176793316439240260419014348246083695310846638270933249304684265430800,12847296795001788271556697499714377689095182754228824085698104180563585670787,17258109440267943312537478894153608811927087776527641627893802618672319064807,3727185744255496747036491258134142468721926815259510264718979349995349167789,2377620008282598351802066487452475263179928244128123362464911386705146759528,20330733534745333298462159658402131849518313653717741882717272744687077336453,3063488930518144343621406800230347607891775381984489334408858649400823600099,11822391183098027641060542512210687183510613996100060945754635806285989372827,2697686870567304805976687716601580249659499813659634827192211658186812105269,19466890284409856892962357589067669895394760875472697889494886746493744150398,1006970646211395884475799222625896618366447925898943829426435645426534803620,18668143903499292595688863135570950175417970684200058312498191992564173409237,374118929819602952730503470915153310582862106749955863047933775501492632816,8098759627317959799834443934069068232617039455327629644555780572940389866941,5647931789489182000343586961287147762347200093731102535565999902997464444183]        
+        [
+            0x1512df0135b6692589f071140a60749cf775c642b300da2fb4ad5c6e23ad4e5f,
+            0x2b109ae037ed30361cf6544b2f4ce58f356589896d6a8849482ed3f9b66e1198,
+            0x2585bece06eff553d485478a19eb149e2111ae4e1ecb1d61fc10cfe1c077f34,
+            0x1ff896f4c0662f4b2ad926741b481d03b813a8cc343b9c2d2bc4819c70b2f3c,
+            0x1b0caf02f434fa3d4cd4fbb13d3116ac8b7386a5afd6c67076ecbc3704aa45dc,
+            0xfcb7c9f13c85517a7805894ac82b57c06f2f153a6f51f60f8e508684dfe5bcd,
+            0x2dc2bdf7f43812e39cef210e42e92b4968ad8bf554541182354504d32cbf9954,
+            0x5add9df20c1898da46bbf74594438beb07c9a65635c90f45c0a08febad13664,
+            0x21cada6641664daa997fd55ace8b88191cdc4194fbdbb6ca5895447c8a58859f,
+            0x19623504589a60f058b04489b153324d16ed66667a04df572b103590b848bf04,
+            0x1776442d850a436a005e02c6475b72fd2d5f84452890c444162848ee1d57dec2,
+            0x6c1691fd6d2ee98396610f3c868d70874f24eff853938d87face89234a09a98,
+            0x17f0d5cf360c354a57e7fb986dadb3aaeba094920e772cdd9abc75850400aff2,
+            0x3062c0db9c925c48cc2f80b698d9602642a84cfa30e1bd36408e2cf82ef3358a,
+            0x239ec7e4b4723c8ed35b987db03d62c2a07c447bdd6ef183b0647821f6874c2f,
+            0x2bd39ed7f4f6a72d02693e967740b5fa0314d9a1f8d9f8911c28dad3f15ffa6d,
+            0x20350e75bbd562e339269cf7fd221fb7c6ed2cacfcc9036568bb4ba5cb17bdc0,
+            0xe97bb9d9784920fb39abf35a433437ed6fb631525285dc3c126e24ef54e4b8f,
+            0xb12ccc871d3272e80a216461403559048e4a5b3af445eeebd8224a7edac685d,
+            0x1dfa3b05c202cd982e3d73cb81709d5d48b3cc105fa78ec8f0f216436826be2f,
+            0x8d9fbb0715c9bf131d6de70b288d94afc02d46960459fea30e0733ed3be6b,
+            0x292b7514248f1ae662e5437705ce49153e5be27c212e86107df1725ff465332e,
+            0x1d58b0684f64db621ab3ad0dc98263fd7285d6bcd86e07a145bdc6aa75c901ef,
+            0x4e7bbd68e9989a91190082f0b29b0b0adc2be282761c44d1ba687757514acc4,
+            0xd93a5374677c75bdc1b4071b1948e53a1b67308e70ead178725b08fd9ed8d22,
+            0x11eca18889e9f49b1f97d5998d235f97c163d1706b4d3d4c380d9ae1f3e79a28,
+            0x266b924e67a868a585b398c2e3f28e3218783237862bab3e925e6e7a9d659a60,
+            0xd2e26ad58eacea3b6a14c1c7803caca7ab3c5881bc6b5b274531c2d461867fc,
+            0xbccba4532b7eea6c3e40135655171fbd92713ef6e8218169591e5013a84bddf,
+            0x17a12ea9750405b3d59030af035c18e4f362e183da6b84e985808f320211d061,
+            0x76510bb9eb19070dca388a1d3a95aecc5de4a2c69c3181665f982b60e0183c2,
+            0x1b7034b3beb0680b858bc8f19528e8c122d6f68059b15c70599910c993b6bc00,
+            0xeacf7ac9862ff85658521517138795da59f4273f1d969f815baab2382b28bd9,
+            0x1344043beef1afc165d094c8c5da43e793bba98b579f2417a19fbfe538e2cb80,
+            0x566dca10a0b92ce177b6f7282493e6b31391e6edd3ff4563277e504c441b1fa,
+            0xc9c6b5c46b9877c2eeacd033f184fef497d2ed1a1ef276ba4548d05f3c78387,
+            0x1a5f92921d4f34a7445fef0618f1b1a21d68714b80b6850dfb9c834f988a96ca,
+            0x14d14e621cbe627022809f07ee078cb2b3fe4fa024715e3f7192a510f1d8e106,
+            0x1b6f67ca2ff07a2de58f7a0ac8607c92fe8c4133355938cc9812c32b12b8fc75,
+            0x4c3bb7f555a1a8747edde5fd33feec3ab52f53dbbe6ef23f7c26e62de26fa12,
+            0x1aca03a3d87c90e7a3ffbb8233149beb0b6809492d33ce3e507951aa38a66331,
+            0x2294ab2f143e49a23d279c6fe914d67ee878b3dc54f9d7ff107bbe78ac2ffaf1,
+            0x2fb43038c0b4433ac0c9809f4e7d7e688f5c1d3c08f66ac64397fae941e6aa43,
+            0x274479867a616c602e87c7521fffbaa85fbeb330128a3bc8c8b8360fb5a3296b,
+            0x18a3410d063b4e72016500228d8889dc623201b4c055dab660b65347fb4ef820,
+            0x2d6fe8d3d694ba5dadb904fd6904a251aa2d351f3cc11c6d1aa94ffeee452619,
+            0x1ec5182518d6d3490ab0b3ff899ef89b61119743188eddfebb254dcd2a787e20,
+            0x263a061f3ec9228bdf93eb93f2695fea629925d6dce82f18e6dba79b3be9ed0a,
+            0x2fe0300a8196b9a46eb1f7d529b4d4c09dbc58765a42a9f3b61ef7c107bcd226,
+            0x862f4486dc03350ea63843db9da09a5a3c3012c0854a7acb75ee18363dc0414,
+            0x9ecd01d7dd15316f2d3df72a9e731274dae116592adae8a81eece51a4453353,
+            0xfc127ceee377fedc0d2da69617739fe790bae028858dbe5db8a93e3254eb8f8,
+            0x15d224160265df8e5e4c1b61e7f9560b3dfc57649f3038f440b64e928bd32970,
+            0x110f785f7d04151a37b44935a1bbf4782afc72ad28e042c42fe63e6302550f50,
+            0x17fffee137039b42943e6f8d044ae87ce06d5fb1c3e2e51e3009a45fa1873f70,
+            0xacb1888950067efa97acad9291f63c05245cde116d7e0bedfa1dd90dac185a1,
+            0x22a4abaa581375452fc3b531bd4ed54fef9bbfee016e665e42493f09c393fed1,
+            0x25adecd63680d23f87be6226ec05a2bca8524963ddffaf863379d4c81fc793c4,
+            0x220ce90ed6442f459eca1fe1f2027e6377e7189e0f6ef43e1cd364e9ca1ceb9e,
+            0x2372d4e4009fed5ef65a3641db3c8d6ecb33040fc25989039394481a94b97195,
+            0x11926b0acd944afe2030cf0e8994d90daa535f465967b64ab0b6cf69e316a51f,
+            0x1229359753fb4a0dc741da84bc9758aa0a7662b314a31fe003474faad18e3800,
+            0x2b3a66d166c51a62bf6af2e54897c51e45fd08bda74d5857adfe8fe3e4bc3977,
+            0x1e7f4fa362bd86d6927781af2a4cac46a77a19b28c4ee55b2ba0881d2f7b8e2d,
+            0x91f7d66fc8ea2e7ea95ec1876a93d33688f9f9d47d3c8b07df92d1554e38cba,
+            0x2c17ae7d9af800bd393b5fa0f8b16293daf49e5afcada50847795b87e12b6bbe,
+            0x266e76891b0271bcad1644b852ef8de9d3c3e7a53e22f6cf096ef44fb35bbbc7,
+            0x24da30c34e49b417e6ce696fef7eb94e67b4d74db6d2d5cdaa4777c2602166c,
+            0x4c3d31703ffeea22ef8509edd468586bad669b74c25fc9ada49a185937c2c94,
+            0x2265314c66e182feca755f9a0cf7c5c7f7db6b501e010c283159f5fcc5bded33,
+            0x1aa1766643eb30f96329fa3eccb67964d510054db9599f5f2536d7c37f5c1149,
+            0x107e8da68896a4d3ab40eedf2fa75e025f787dd92799357218e823fabebc8947,
+            0x191aff44b7bf99027bb1d6954ca0901c950f7ba8f1e1549475f0f28ac6e72d60,
+            0x2d6a00ed5b8ab0055a4277b39d178918744ec5b4e5a392205dd4eae9b4f1f507,
+            0x8bddd13ce3e6d0add2babc5f0da3ed9c24e10aafb289d03e968163c44f4e669,
+            0x2f0575cf9b7deadb634320f90d84678d771833f9ac9d1b67c318973fcab18f13,
+            0x1366a05d3047d5b3452fcc62417343245ea727795fb0d05efb80a75e1e4d7cb0,
+            0x234dadc295579c62b1080fd64f340594eaf258b94225fcd6beb10e5efb4d6fe3,
+            0x1f78b1c152a40027a2c7b0ac19bff6ede3202ea1b95e5d0af43125a33cea7821,
+            0x1532e8db5fd0a6c2c785a0bca111741903fd089d9b73715bf0dd70c2e14df9b2,
+            0x9012747fffe05e8b4482f278d35a28c6f58e6d502d69a5f351225225aa0279,
+            0x105b192f778c42354f2a979d91b02fd33c52c59d542a128fc08e5d11c96fbd65,
+            0x24bcbd8a492f542d2e6faee6c503c9c6f7a67cfc7d8e756759e0bae679920b81,
+            0x13e55913295f26697ea8ce1aaffb07373dfbe24b8f41e789e05d8b96c2dc9e2b,
+            0xac524f2908d8e1292a18ee6d5ed583c29626eebd03a593db01a61599c286139,
+            0xdc402c7aebe3f023ca4b75dd5f69acf8af6607edad14bd806181077e41168a8,
+            0x6d687b70f200804cb3b39546609c1ac2309c4b59fc96c7673ebdf2c900d9400,
+            0x1e0c2662cdaa91336e10c7eb3c6eab12330a99da8a095e928f73a8b45accc8b3,
+            0x14be0cbdb25a5f84d36b415f71ff807f9df89dbe6a9850213a288abde6db6264,
+            0x2fc8c8938e2554d9d02e135eb0d2bd251390902e82d6ecb4ac37b8ab6d12233b,
+            0x2059f3ad1d4ffa2787fe0577dfbf12701689bb3359647219d84a000e95c62c95,
+            0x1e90ed09600b1ad7e5f927ba5e40d6fb87bb537c695d5ab6fef166da18fe7f4,
+            0x64fb597e3bb0a3fdb8ed25eefa943f6ca21150b4e029836fd31d63cb81223ce,
+            0x710644314ff7d6091eab77327421b8b18fbd64ab6f6756b61ba96d79854d6f2,
+            0x17491b622e2f47caf07a2abf0b623896e973647d02be011f099b84af45dfd1dd,
+            0x2c7aa4382c1cc1897988dd51243facdbb7d37e8cab2e27a26dd7fb0795d77712,
+            0x14695d28c7fa12ea6044e898a6d8a6592a5f111a293624a45dc24944f77bb711,
+            0x1602e77d6ee3a46b60aca6ba65c81457c4d36c8ee14b3559966cbea0ae32cef9,
+            0x1ab02e5bfaf9d4ceac75f53983bae994d12d0c44a280d7e2df3283ee1f429ad5,
+            0xd2b3a148b13d8a541e3cb82d624cb30209b4f58fef5121bb74e8eecacabd939,
+            0x2e682ed8f03c5e95d84007e89a92043c968111cffe9d18665258df0d3a6a9b8e,
+            0x1428a6b9c8cccc597a9eada39c3cfff0154fd9f5ce4878d9963b89c7a878cef5,
+            0x125dae4075bd6f83314ff7172c70f192173a2d4eaf09d887b942d45b7cf7ada5,
+            0x273aafea62ef6ad185bbfbe54a753e59f639ab2dff85b1f4c0a28e2136d4bec6,
+            0x179314705df4e0b530f1d37f9d02c3a88b66e2272edca161365615999b1cf404,
+            0xdc05aa8617d57fdbe30d76d7407add6a2e95fb73e9f942e4c242e2ed1016318,
+            0x18469f35a1ad56b258b1e60243c962ee6dc99faf274f02feb42a8a51182652c1,
+            0x2f79b79663182739a2fe0c607077163df7c0e9193143234337b9007cf472ff7a,
+            0x1bb4d4ae946d5ec7cfb22cea828d263b7e574ea777aa891cb0ba07cb412c2413,
+            0x27270b27dc8fb9ceb1c5aa5a49f97a795c1dc652f9012ea2110ac6877df6c20c,
+            0x14da35468739dc3ff0110c91ef540be904c73e5d71e5b0b5eda5ec6dcb2f6eaf,
+            0x2e90d9ee3e7c2164851b64afbcde004b6c0b82ae7ccdf6f78849fb981a35a2ee,
+            0x2b15612eb94247469bd9475ae4bde9780511cacabd566c1e74ba1761d60b6158,
+            0x121c521576ba4ae4a05ed2565651b2893d5f704e5c6f0a642c60e50df22c8ef9,
+            0x23863fd0801582ee9b9a4c83f3b6eaef83c59068c0b1d4b9e93ec5ec1a0c2938,
+            0x13a597a19307e90fb04778f82f2e6780a9e2c4e03cb0515e2cb960c51838693d,
+            0xfe4f11040f7ec803ba86cc6dcc6ba00ed7569a00cb4aaf5685d014beeca35a8,
+            0xc30eddac033e3f113894327db9763aafd747b32d1344b65ff7108177125de2f,
+            0x16449ebb71737c6513326b4636914fdc9f7864c7f10025a09734880d423cd1c2,
+            0x267f1aa1162b7284cec8df83403241884bf4a29547e2d0c470f6abc19fbc4e75,
+            0xffa65c12b20f5ac05ab035a3b9cf0983bcb4cd0075d9a9e5be77ff9b4f17bfc,
+            0xfe550d9e4e3eadc68883a977b6869a5887db153f6bdba49233f60bef77bf44a,
+            0x255002f14c45aecf8cbdccc25c25cf16c9c771c653dd213a2ce22e190d7df111,
+            0x160c6500540f89b145de5aa9fe944604eaacfcbf1c17550ec91da6078082ce1a,
+            0x1383faf37b866d99769fc32b68e45a753f803ea36e351bec34222729356c6393,
+            0x240b1af70af648da4ae6886dcad5c673e5b36aecfb7f2e58bd12564c5a77697c,
+            0xdf9f10587e99fc6280b6a84f0ab1dcb4eaadc8958518ea2bbd5e648cca49e1a,
+            0x26e4261f23f0856aef429a307bafdf1b57335d7a0f38ab992a77a5cca9b50ad0,
+            0x145b8482c15986fbc1a4085dab239bf2d5b524632baed39273551273ce1765a5,
+            0x25101aa4715ababd467f91767d0cd0e8037741883381e392c8521b08c6cf62dd,
+            0x2896258f1d13f8b556b92d0b5fe0684f67a8665bd97747eb0364ed9b41cb2b9d,
+            0xbfc25af60e375f1a7e09ec5c0411ee14b52346ede9837df5703420189fd877f,
+            0x29a042bd25d6f3aa5df99619a794de17432fbd1c75fa33a1010c1af30cbcd828,
+            0x1cd0de72b658cfa8975dce977ccc6b6cd06e4f8f49e620e72d7ea84ff2373c01,
+            0x2197c4469eecca78bd4629b5d53bde29a8d3222bbfffc5948052e039f18e3461,
+            0x59c6f40b2b1bb82739356c24e78eeb900d1d1057fa9d48289157af603d05dd0,
+            0x18ce307b89e3700870c70a6e9460f1aed5169f729d2e75f7e6c7e6d0298fc334,
+            0x27c70ab7d57ecf0b8348df89c42e3817450b3f018519673f9f508e5e1ddcae89,
+            0x1aad5aabf3751e7d413b8138c2769035e8591227395d0d1ce29d1c5b3b42a54f,
+            0x165634b54770542a49ff684eca304c99d9d06315412252bb82a2ce5efe24fde9,
+            0xbe7826f267e77ace74a4eb0e10e5268f07f52cefc1d7b74e7a5b82a08c85266,
+            0x263fdbeaa2840c05de52dd10fb42817361a189d2abd54ce145fec18cb11b7ed4,
+            0x2c1ddd2e896c9dab5533d8400df17eb353a0191b9b97282df18774113657b473,
+            0x894b90c18b05d7ea347b8dbe1471fe0020b9d0b1eb45a07b0f70d4b3bd90228,
+            0x3056b80856c9e6ca2d92a5bb3ba46c03de22785d58565aba508d2d898068d741,
+            0x1b3395901b0049172ec09a314e4a4183563727d32a87767a094d70535336be93,
+            0x143e65a2a879b7a35660da4fe2141be33c17ae0e6f1324fb3cd9a1d061a15757,
+            0x2f3f3a50c82372cac6815322698f09826210a571a9cd64c68dfec4711a5fe60b,
+            0xbcc338d5a9ad15519aa00e89fe52cc24491416e1ab69635a67d3246e58b12ac,
+            0x2a462fa9c4a682e118cced65a4aec9212496ddfb5de743729cb281ec3a76a8fc,
+            0x7391449ce7efe315f816f0c1c3ad33b520007106ef8d11c2a2463de270ab282,
+            0x8cc2bc080753c7730c57f179e38cbf95b95db1fdcabfae0a8d239342fc68c8b,
+            0x1ce160503379a007e38ab3cce61d6fa0d78ff6b19526e1546023cb6dde3551a5,
+            0x2fe5f53e6a16d7430ec9a765d640bd5de6587509be8bd773be71073e4e652975,
+            0x2b9d6359e3de7b25159b8d2fd42c96244ad92bcb54f26ad8a6a10b2713de4d73,
+            0x2f730a0fbf24810d49065521296809b50c5e96a6bdc4e3fe44d9d4517a259728
+        ],
+        [
+            [
+                0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+                0x1f930557a284998225f5f4e4dfbcf5ac211f1b12d91b0562ed3d63285d7a714a,
+                0x18e8222f6907da5745eeb9cd4a9e62f28b8b710aa85fe729f9ea73a3ef0099d,
+                0x180e924d757d0be4066feb146ed56212e38acf9df4957432653f370f905b8b07,
+                0x2f7d0715d1391190e7b14a1242b6799eac3142e21f08ca02c21755eae77a55bc,
+                0x2283ed8d5e6f9470b3f4f49a771061e4a4fc7dac683defcc0348a8862c6ce71,
+                0x21f60efb132b62909990b9f994f381a9c02abc3ccb54c5c8e8c9c5664c6913d6,
+                0x1cde82acee60b84424e9bcee49a5464ee05d1cf0b70469208a675635ac715495,
+                0x118a24510a2153f818f0a996c87de913587805f16cdb1939d9406941f958e8e1,
+                0x164567b0de16b7a5550fca229bac7cb0779524325e4ca5e78a86078881660264,
+                0x188ff303194112a7034527cc9dd0b4deb0960c9c106ce115178dd7087e4e8c02,
+                0x83d832adf9bb4a25f686abeda9f16ebf53263dcf9ef4311781d09920d094ead
+            ],
+            [
+                0xfd547840f3a30a533a994d1fdb3f60ae5073f4484f34be951ee16a276fdeb9a,
+                0x4c4061820cda9bf472df3f64d6afa004f1e8623d0a4f6142cca1f19a4c275fb,
+                0x107757eb0c0799f781308d83d2e057ef8106f6b656b45e7636181e113a2cdf32,
+                0x2acd39e3892ac429ed812863efa05eda746b55bb974694a4e77b9a19abb55001,
+                0x29788bb6cd947ea9efaeefd0eeb7fd563fcc2e40bd623ea2b2442b55d98dc5a6,
+                0x6ab8672c936070a10757adb45031a5e2922f0fb8b5fab3a4f5e3872fb582ed3,
+                0x1db98a562fcd1a5e4496e61264aad5ea3b455f46eabd8957ba671e9c31e5092b,
+                0x1c4dde07d0f94d1aaa832ac2f5712d438b4e1804b5209ce55942d7afb24c6401,
+                0x2cfc82712ed9d71ff4fdf63ee4ad116fac195794f8d910286c152efd9f959bee,
+                0x18b49b773f5799888e9abe3f6883d7063333835b6cdd333580b2b4bf48f3b27e,
+                0xb300de5b99c27d332091f8fb0d97cf04a86a51d4d2037788e0d4f38e8f4eab2,
+                0x541af6b96524662084d1208d71b6b2a8d66d91179745b213679c2a2bbc94968
+            ],
+            [
+                0x5019671bda026670c7ffa9081795105963f56ce327fcf78451fba2bdb3ac1c6,
+                0xdbc22c3e54c924a882c22000951239cc263755dfcb38b27ef4f880e202cb5fa,
+                0x966a21b9615af2b7563dfe41b8b9fc06039512dc9c8e1196891eb77f856b608,
+                0x17b18621dbd61df085da4cf8a03395e3700269c7df4d98ce4851f90abcbb3631,
+                0x12cc274647fc572bb79035bfc3332a4e566a28011f69dd0874f01c56bc44c3e2,
+                0x2c7d538b9e6d2b2e06e72f8aaab26dbddead1fef6a740a11e9953f8e8e9ee057,
+                0x2f30800c0ee461010569d36b60685a38b02912a020bc4708598854f65822f15c,
+                0x116c45e4d88ceae4565c0e94da844eaf2775d5f5b435d94d2d3d38b583fa7841,
+                0x2ffccbc40031ebafecfc3a97284bd0f6dc4d45eceb8b8998f1a667bee369ed62,
+                0x2007424b129ade2194c73e6e2c9d79360d1360c4fbb8c5f31330f938558b3ace,
+                0x2c53d6676d4d4c87d9eaf5d4da08d1e98d103a3388d59a7c0c3de51e2623aa3a,
+                0x2cf2c992c02a36334ff5dc851646ee7da04b44eb544ee3c0fadb8dc5eef2a585
+            ],
+            [
+                0x2952c18c15558f29b2ae77fc39e51a395f173a9097db404db765ab02906b27dc,
+                0x2fbb1c59e9e8999d91c40f4d44233122ab35ffc975edfb43c53ed07dbf0d9c76,
+                0x82046081498eee63c287c6fa3efcdefeba1b5272a77bba9cfddb56afa53c82d,
+                0x2a429c2d06dcf34d34730c3af8bc19b04abd652468de5a85b5d5cbfd9c23e6e,
+                0x2ef584c3aaeedbbe2b4b103a61e94ed40a97294156ad7ddf0de43b845249f534,
+                0x28e4620d210536bcaa42ee46b1cdcb21bf215933bae4eec639efbd51f4bb6557,
+                0x1e32b1e2e6b59273a113d609663af6b30c95b36884fe5faf371de3d564213c3b,
+                0x18820364804d22119347b728135b409956f7933defa1059d634b977d9d3abcde,
+                0x9b6c00a37df2770cec0f1bf62a6aac3bd380c6ce9f4f96e0f0879237ffa510b,
+                0x445e26e26f91707da2df5c188baf80ea2f48c703614980fa798971cd8ec60f5,
+                0x19f5101715162976766e2b57a58674bc58e1ba2be18a59b07a07e4a93e038075,
+                0x6c5df8fd61eca2fb4923f0a46dd4e416a3a3b48c10ded13133ffeab6fd153e3
+            ],
+            [
+                0x2353a60af6bd61e5eac2c9a4263d451fad07380654d4792378daf752e5cc33fa,
+                0xb8f40d2c4d28c472085203a0e460af73bbecec3b2b3a63f27028f2ca8a71251,
+                0x2c7ecbf14b2d6049a6439d0f29f10e26ec975acc3e3eddb77c831a509af59196,
+                0x197dfb64189c09aaef94a1f542d8c34aea27fffba704202d5286d62bd0eed372,
+                0x5f9a6a8d64cca12725dd15110f74aecf99dd30e57a7d99829cd8757b75b772f,
+                0xfe0def70bfba40679aef8d5a239b3a1b5a52fe8fd7edb754aee2b182d64b66,
+                0x1b1523463a45a2982889048681a422c02ea373f8b8c1bf16c74a375d5060c662,
+                0xc849d07b1d9e6ecbac517fc19237ff73424a0678f94699b23f76952afa4514c,
+                0x2c4036616c156006337771c1e355fc0f2f238e64cbd69d068aabb4b58116886f,
+                0x176804ec1cf85d35298351245d32236546838d9b98cf4242d601c7e8e501b49b,
+                0x2f5855a876a37f7bbbd6104accfcae507e9ddcd2a7219b487a76b17c525b50ca,
+                0x1a233c7cebfb0c6eb72dfd07aa2b537ccf291e84093aae36cc68002ffb83639b
+            ],
+            [
+                0xed6a3bd48174e370b4f264b37488b03a5e3f4c0f61cf32d3157ad3e3b86f6bd,
+                0x28c01a9f01601bb46417ed466be6008595052f782e46857d81229e64e6bda02,
+                0x144022e7e077ff22a2ce3dfe9923107d5aef046d0a1f2cb5f36191ab04eae4ed,
+                0xfd3bdb79cad913432b7d3828e072dadc26cf4903d56b8976200723846c6577e,
+                0x2979d1aeafdf97988560d4ebbacfa6e2b7f3d026946abbb9d5397645e6e81825,
+                0x22ae023520979741e5c58fb04fd25d12dc8f5fcb6ad15223a5da7e0f91c7b4f5,
+                0x5246ee7854b2e20e8612da021b30798e5f0d02a5bfd5e79d3f9ac6c79fa609b,
+                0x2b60a4d43d12cf31076e0690e931716c47a86e7728c34b2d3cb0cbcf95bbb74f,
+                0x41b909a658d136993b3f509a9e9d50138baca48f6b66399ac5c649e68dd3aa4,
+                0x25b6e65e90ffbf910d19fe3ae23d037f8f64da9fe3df483fc4f4977ca36a7b1c,
+                0x2c0de448a88dfeaacc9bcf2850b6ff4f701e1a538d69098bc94087cc35930966,
+                0x5f6d62f54518f039e79aa726bf15a5983583eca4062405400acca58ca9d2235
+            ],
+            [
+                0x21103a7aa20c8d15501be8c23504c6a912c6100c5d88085cc2e42a52302f4483,
+                0x23ce8e402939cccf36176a5bd83183a0d54a24ee6cabe4fc7f814dfbf26f85ea,
+                0x170403d414148f4681b8213550951e238edc009f46b00693ce3d9c5800fadd0a,
+                0x29b9ffe05db2c52ddd1bf0e5c532eefe70497c7df4b97db2f0624836576a6b29,
+                0x153891052fca1290fbf83240d334fd4ce05de78adfaa2c9686488e0c47ce1fc0,
+                0x105c0b246660c4bd8a6f1b36fc3cff86a2c432c0dc9321cb50abb98a10cd1bae,
+                0x6cdf8055439ac8424c435e7e9bea3f0ae93eab171ac383ed2cedb460fcb04c4,
+                0x3161d7b94e1b0411fc01dcfbd748a6df3156ff04536b3dd3101f7b2ebc3811b,
+                0x25c075b41ea2d827a4955b6469db9d41760faf885f2c6e9c09407ebb1c4dc274,
+                0x2fa2af7970e131f7efe3a7c788890ab860f76751e55b4ff634dd46cc4de660d8,
+                0xce587066eae0c345c3368c53dff2170cdb081bee52b243a1e6de6d4f82451d7,
+                0x2b09de93c6e3148cf7ff5731c8e144debb66ca896ecbe4089d2d22cbdb09777e
+            ],
+            [
+                0x2fb232573e85d68c536d100c3a6ea9172884451e677b0d1cd0fb4dc4c27536b7,
+                0xdb82abbcd3a1b56f7fc8d116cb54c54fe26243702bd3d57e71f7ce0d470a40f,
+                0x2997d92a5e9bc66c84f635e8cbf080eb720ecd4ca3e42c3ab8d088611880861a,
+                0xa2a006e3b086bf502c5b1540eaaec14b9c15bf88471cb6d479fb4563f016497,
+                0x1b8c7eb04d351aff4e76af7f9fa1114fe45aaedafdeb42c1c23503b122639c7b,
+                0x2a5aba3b45e79eb2606b2a5b47eb907584aecfbfc0b4cd50cda1ce4854338597,
+                0x2f9a5cdb79645e3454c617d77a774feaf24ef603454c02076fc4c9d7548cc455,
+                0x6438e8b0220464039a7b8022f06beaee502c5de269db82f91d88fe1b72834fa,
+                0x115a91867233cc75d1c906a42930e93cb9c16afced390cc14435e5cfefb4e96e,
+                0xc8fd4ece5c205190cf6c842d1683444079bf49835d5c8b8dfbb11af956ccaf3,
+                0x2cea98cc64abd926df963da57f2ef4c434141cb53ac6311b2566edb957982713,
+                0x239ecd92517825174f796345db296562223760fb1b81c091b74a6a4a82968a4
+            ],
+            [
+                0x302a085be040ff9a709ad0c73238b0d1e11e1d17409abaa34fc45de29b541535,
+                0x2e703ea9af99161acf9949da7afb18d462d85b671656d61c2cdee3a72390213f,
+                0x21427b3a9a2cdf1e2e6c628906b21e24271d72c18b0261be68cca44865dece11,
+                0x237a9e020908cd0edbd9eae8772350e0e731e3228b892fc5f64fdfa9b9daa670,
+                0x2d8125dbef602bd970d11fad7cfe06c3c64f5687b09b960ab92b14f69efbea57,
+                0x23a3b23d5edf5cb66160fd2523b3a383142291c0e0ee666682e946b1d57937d6,
+                0x1b1625d757786a19a93b37adf7f22ca8a502aa4462ca78f7da2d7c22b37d7f9,
+                0x14898babc8810cbc626688531511a8473ed89a22569d47ba586c284e45bd0ae0,
+                0x2f8fb37178b525758bf6aa527f25773e1ebcf8e1425379500c8245c741ba3fc4,
+                0xe992f44463e2dfd267e6a4a1c3303ea7a1186252efd6c9fae9e5f0c1f6d8266,
+                0x2c7ae475d90c475f73c0d29be8889d0c4b8536fee6c0389984bf9e4dbb1aae6d,
+                0x2945cb85e34532e3a22fc576703797893ce290d0156430a8dce61c9df89a8bd5
+            ],
+            [
+                0x683e640e6154ef73c3cd6b1d0f0fd86ebf7e292e63fa84cf0a883c2f1faa8ba,
+                0x16512c150c1d2fb7235efd2d4f0fad5fdd78f8d0cde53a66bc90206c82c4b597,
+                0x24bba58086a78541a8ebfd535c107c36946d78ba6cb26d227e615131f71d337d,
+                0x6d349d6182ec30d68c9be010587c707f7e1e175c0d324e6added6337a72c2b,
+                0x10924807f6fdc4e9e586792e3ace3001f16bc02e84ada5df51d7bd37243ee1ee,
+                0x26635f4df7172107dad6b7c3068d2d438bfbf486471039f9e65a9c8462a2c9c2,
+                0x28bf5488a525f5514400dce722430287fe8e4c810154056eb0f4d6fe61091cf5,
+                0x90dfcc0327a541672cfc26c7e1370583c5f9214177093010fd3fbf279aafd4,
+                0x29a14dc4bac0a4c52bf30aaf6b9b8e05453d0d797246b64732d50f176a7ca257,
+                0x2609ff97ef574fd68d16a3de0872c3b59a5b928258dd1469826a191dcbf5bd0,
+                0x23238fda1417302dd03ce54607749610292945bddbd587241714fd3964af5f10,
+                0xd3be6a5b12bcf1bc705c20c30f320b8881c6c2ec00e857685c0599262a3cf0
+            ],
+            [
+                0x1f09f3fb07f7f6476fac98946b7375095e014b28f23a07ac9fc7077144ac3979,
+                0x298aa5d5a44565b75ef68df902d791d01d98a75e822ef553b1761c58d6fdf32,
+                0x1fd5a6eba52e9ea1db389a1fc8dd3d0283d737c18eb06e090b6fd2dc88e0a14,
+                0xaabba39d220f30604d0c44dd47c3c70de3b79f5baa70a3a7a0ca02ae1b080c5,
+                0x230918919b6826faa7124c5bd15d10c036d565e100b696a3be7afaedb2abba6b,
+                0x2bb28ef42f5fadab6a6ffd5655b36580deb063ae3081d587bb1598878590f1cc,
+                0x21891bee31fb7bd89f0e4422b3c8f5b393299af0d9825db9be73e7b20097923c,
+                0x38e0c2e29c79ccf46b5ea1bc589276aec95b74e8bb82e4385c0585637c885f8,
+                0x2c89dc7562b91d8f2f7daa209b7560520b6bc62ec631db41cc5edac1fb142be4,
+                0x15dc57879cb41d6015da9881f948b40d20f0e03fad87746d8575af009c96033d,
+                0x1c674ff2ead27ce002f4befc7ad5f0f5123e59793c0fe21075e819ce56ce1e83,
+                0x11e7bc4a39d2730196b6c334f99750de5bb5e4fbca5d6a19eb7fe14abe845dbd
+            ],
+            [
+                0x598c38d2e2c78dfe4907c74e82325cb191d52608955b583e5826ebebd1857b5,
+                0x203fd2078ab2a8f88b7606543145ee34daeab2aefca31bc04a476065697cabf8,
+                0x1276442d9383c52d50fc9b5ac34442a4ec8e9cd7aee6d6ceacc1a6f521aae4a4,
+                0x16ee980a2c67de24fa1a34082f11c71b7c45966a6e8bc6aa1a1dbc7ef6a9bab2,
+                0x1db922b8c249ff7bf96121eae9d9555ef7770f3dd7b056191ae9ab38a5ccf6ed,
+                0x96dd43a832ab68e35e57c98d7b01f2a2e5936807704593ac72c74001383f7e2,
+                0x2282e86ade85855d4ea0657c4add20625c6daa90bc93943b59a92dbb77b63681,
+                0x28331d0d31ca8675ad4767c490261bbfe5b84adb4ca2c5599a87f331908130f4,
+                0x14972bfc85de037b07e55332e6bc5b4f08f39ed4eb8a9721dffc4a586dd9a1df,
+                0x6d039b64e82d7975dd21a37b5ee79308f20e82e23489382ec2d176190587896,
+                0x2627be68d9cd0ccda3828d51621ba409f9acf09f1a9cc503a29ec306f8606ae7,
+                0xc7c9db952865fb9470f8aa1402536cb3b82276d9e288082ac7f83b10bcb6d17
+            ]
+        ],
+       [
+[
+0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+0xc894a150b70154ed3c77c170df947769ac6fd8f4170d341613e7adaefc605c1,
+0xf784c25d3497fb7f058d93af7ae1a182bea00ebc2806c19377ea19a77db346a,
+0x1a4f48dbda22089500b402545867e341b6b6f14bcedd66ab59a1f1482e4f2d8c,
+0xf61b0bc7dc5911ba7d353e201a1f480cff116ab06d9e735e01889b688078347,
+0x15f5f8ed095948c58f2cb630b9b892b1289429c3c6169f26d4501cb4b24e7d72,
+0x2644c801ffbcdb796abf1036e3a240514c45708f0bb0616dc9f5475ab7ddf80c,
+0x15580d2d80baf18dd310bbce40e0447c78518aeabd02fc3d66bd0f573c1b7b4b,
+0x2103a7704b61ecef423c74fc864f57077ae9e68fedf93c4c24b3191c05552e8e,
+0x254310df353b2d1c72076f34db3ad823aa35b7fcea7124714bd5243d90c788af,
+0x23c2a54a64588d3672e1e11e0449fca37349013eb30472982df8935a727808d7,
+0xe25546d7af425b5954185a669c63c9fa25d3d269e036e2770451d2cbaeb887c
+],
+[
+0xfd547840f3a30a533a994d1fdb3f60ae5073f4484f34be951ee16a276fdeb9a,
+0x39f5e3ba736458d66a7276a3f7fc143f4d2e10cce779a0288fa042477fa8111,
+0x2834c6a4b3a7068b2959204bd9df5f9eb21582db300ac6cc9bc06188814e185,
+0x365a1836d0c970acea6a65b34b4018ffbfd2334bfc29ea050300fbca592da7b,
+0x7b2fe7cb2612a4b8ce45aadb192514490ad985b31686b75cb895938a99c35e9,
+0x4c72c3e92bcf3c9450146921952051dd7b932e045c56d2b8d1225c557a02fa4,
+0x18d459655484dea4af5de8922eb66fae69bf0b742ae678e6ac5ef937fd23f145,
+0x28d575bf09788e6c9f404c4f2a4794c51393c9fd263cebc2aab4f575a88c1ddf,
+0x15a78c5f1d6e0176ed4e931e25aa42576e7d172bc263bb5b22fbe2a1dd096b76,
+0x253af96dc191b1ddcc7da399cf751f0531e2db5cfbacce3efccf23e9aee0635d,
+0xbd6477a4e98ed1b6a052a7fe6a3d111fc2478b3817bd7c2dad8b1a813dd9445,
+0x1c371f42917639fd59992e6dedb5a144b079a25f242578b21baa3fd6fe98b51a
+],
+[
+0x5019671bda026670c7ffa9081795105963f56ce327fcf78451fba2bdb3ac1c6,
+0x1c9807d9b8968d8f620640d590f151e0914406af2136f902521b8f4da19cdf64,
+0x10cbecac3303667992c537c54deaec58a34528a2fe041591a98e64a8d6da5588,
+0x1bc32304ad49812a051886f8904e1af0a76149223fe72e96523937f339a5d9a,
+0x15dc91d6fb987bbdca99c78dd90a57b386e9b9ff7e4a4faf70d5ae18f431edce,
+0x22b26a76db2dafefccea7be76f0e139a0c568e92a447ad288257ef310794df28,
+0x1c76650a0527fe929be54a7e8a47efc654b515547f9cdcd58c146a0bd11872f6,
+0x23d3b9deecba2482b107832457fbbe5ff670a61069cdc34a6470d2293471231d,
+0x2b9a6b170ff9ce22246aa0b5091a7f33ac5a1b39904b61f0a7360c435feaa593,
+0x316258271c5c2be65d5e41b0bf6f9917c8c60944d1be7f60891236cde4c2676,
+0x1c67cb4dc98d5f02eb96d20f1134177396cea0f4fe4c04f856b0e2dad8e1b56,
+0x25a8f4490a5df4e1eb13e2e146e0deb4de3d633d11bc4a540c5a6a21934b94c9
+],
+[
+0x2952c18c15558f29b2ae77fc39e51a395f173a9097db404db765ab02906b27dc,
+0x1e7fcf514768abb1800ff4f4884ff5bb6af1ee7581b96e2984c2b2c4033379cd,
+0x21828d603ee0c7651c0a3bf6b18217e1fe33f283bfeaa1fa9ef9eea3b2c32fba,
+0xde712fca9d7df5e0f67d3eb731a53dfc7d1a7cbdcc34411f6138d6de60fa369,
+0xc58a3374648de30ed82a9ee0f4294d493710fe813edfa46b09aaf44b3ce6d86,
+0x14be55982212ae54cb8f0ce42a162a7ecb440a4c0c4d73189528e4b12d34e5c8,
+0x9da7079e3ff632329ed76acc28bcd293d69f9298fa25b9d5231f9611ece2c22,
+0x2d865f77a39255aea1b29c483eb4a3acbe7fdd909cf17d91a0100143979a18bc,
+0x2a39a308231582d0a1d003b5244fbb85588de1df3ac866dbc2fee6d1d8248c0f,
+0x474c582c59ef66cb29b984f6e4bd97bfeb5a41c6485aca67dc0555ed1eea61a,
+0x65cc505a691aefd234e572640f6c731993aadfdb529a9aba4bf6377ae28b69,
+0x2aaef152c413b4ef991bc228242822e2a6377aaeadc7ac22e502def3d839f2d0
+],
+[
+0x2353a60af6bd61e5eac2c9a4263d451fad07380654d4792378daf752e5cc33fa,
+0x28d0997942c3b3b0a4ae3b17ba382c8fa4e1809be0ec701d01501f142aa401f3,
+0xecf00f71b1814ced4f6525c4765846440aa3d39e7ba0e4e4610b70b5a38209b,
+0x1258d5a4d495bd4be6c704992ddc3e89f7ae5c6cbd7430014491fd234be89fc6,
+0x30513cdc3149663999036b87af10c4a183f71722572b4d958cfea9e3dca618c4,
+0xc658aba90de155384cd4d63e285ac2d004cd95a2e95da1540ef7f1237d851af,
+0x13bf5098cc05b1035e2f22bd47ab4041d8adbeb53c40aba04a75fc5d2435df46,
+0x2339c682b7084d04d3c9b6072b20b63b12003e5c52043c6336ba222397269a5a,
+0x2cd36c4bd8257cf74834663fcc1e38be2c3fed64f7b568e1f0eb0c269b0e14ff,
+0x37b5beeecf060cb73d6e08ebb984eb5d9075b31b128fa3e5234e969036ab5c0,
+0x118fc51eea37540b35bc2ad77d91af14dacc152f86db157ff4c48db58e325225,
+0x29efcd78bf5b6b7c9811b6e838f5563b349606a1959751d63d28fa4c1124b5bd
+],
+[
+0xed6a3bd48174e370b4f264b37488b03a5e3f4c0f61cf32d3157ad3e3b86f6bd,
+0x287cd855b94877a396d39c336dacdb13452eff5917a877edce1412b7ab24ebb8,
+0x4f06b7fdcc319605d038881cb47f61748f1e9f14d47dcf824abfad47a73bbca,
+0x4eef0886e398163b9f0009c8204cf2d9b0a4a30fb019b3cc46cca6ab3ffe666,
+0x2fb04567ad27a42a4ca2ea90a0f27660e1e10acefe62de96607aa26583695932,
+0x1f1c7c6bbbdecb7ad8a2c8a91b983b075f4998fc620c36e28e2b59077ab57704,
+0x78a3fd180d76eea922e4237fd65bb83ed4561b268751a20ec97d3e0d7460d27,
+0x11ce8d6554294777e161cfd91ca86ac2fcf71bea4228f8aea857187d579b606d,
+0x17607b33a1043bcf034c42feab79507a82488808f988fd0e13f2e2982ce55e0a,
+0x2c90418c775ce44e34d9de72d06a7c2c9cb072518bda77828b1e82fd1d19525f,
+0x1cfcedb53846d090e72523914eb33d6d2781bb18ff1a7c885eac1326e93f7a46,
+0x2a4d8464358084800c89f6fbb98bf69d589164f9a648f48d3a42aac8c5cbf177
+],
+[
+0x21103a7aa20c8d15501be8c23504c6a912c6100c5d88085cc2e42a52302f4483,
+0xc783dba69038bd1673bc3bed51afbf51ecde783af95067c14de12f49e49570f,
+0x1cf80bf06f3525aa85416d6cacd0e8251bf1b3a771be49253b60ca83f49b2369,
+0x1b6e663aa128709d83c7e5a86284927920043926cf55678bacd8ee0322178495,
+0x6146f62b14c25c15ac08d1756f2302395505138a4ee1184000a38f4c7f53905,
+0x1c5eea7863fca5bdfb2f4a3dad7e2a16572998329ab695adecd136fba4f4063d,
+0x197b13f8af70f642e878063aec6e21ba8978ef2322f2d64bb512ebfc7bc2c7c2,
+0xdfce2c65e220994dd2deaaef6e04537b35ee47eb92cdbbd7c61cc6189ad3f5e,
+0xf4b71f3763666a3dfce7517b6746ac033b2392ef742470ff7365ee5976bcfcc,
+0x6fa7b6308e448573f3fdd11a2ae8e44d33c3d3cf0d9ff8601df20c55c6aafa4,
+0x2390d163c2c0b5d461be5ae1f2dcf4c38c2aa514cb22b4b5e104dbb6889f8a9b,
+0x21c9120f90988cffd032feb1aac143901de9cf42ea3cbe83015e9275cb67907d
+],
+[
+0x2fb232573e85d68c536d100c3a6ea9172884451e677b0d1cd0fb4dc4c27536b7,
+0x266913da539f40df5123e01fb748b241795f1aeedaf1f7ae3cef0e5728d23aaf,
+0x2f6910e50cc8a14ddd99b667c6255bf66dfb3386e62bce0d74cbb47419c31572,
+0x24fe05893f5e7aabb44d705fe83fb319d29b511eba00b2705561c6bb0afd7b37,
+0x1ef5275b46a65f69edccb39f50fb90cc578ce4e519d54c8e61c31e6ae0710a45,
+0x137569526eda65a31fefc352a005bd0b10fff52cc5692edcbf46cc5f03538ea0,
+0x8552774a893c4dc375ee4efca4dbb742277f07d8980c54581b5d4d0dc1b7688,
+0x2d9b07507a9df2a587056f988c7caa44693a118daae6660e160561d276c83482,
+0x2c90b4ad79e2316e7986b75730418fe5d2b1f252e77817385d78ebfa34710afd,
+0x275fbe17c666f61f6cf5484db2e52083e856c718ff2b8f4d4e17f130d2989e9d,
+0x17f57c813764e728dd240398690408ce71dc8adf83e53f5257ac34b643a3ec15,
+0x2700ff01dce092807c3f143418c11a2f9db6bee6f478edcf7145d69af66e13ef
+],
+[
+0x302a085be040ff9a709ad0c73238b0d1e11e1d17409abaa34fc45de29b541535,
+0xf259a3b7e18add912cdcd8674b0f8fa910fdbbfad967bd816b33c778feda3b8,
+0x1e43f0a896764c42eb93be791fe26928f91c7bdd278b7c810a2f588268314b95,
+0x268094abd638ee0145279900f8755e55e1adeaf2dc222f402d1f08ea4953abb2,
+0x2e1bfa1a1aea7b44c84b866d9e7445e4acac75f82e0ea8ab03326214c84faa0f,
+0x2e1e2e2f2065961056bb63f04c175c1682eff3bd9073fd7fd76e7df0e8f12d47,
+0x3a2adbca7945b9a6367799a20c37944597333320cd815d054a5794f68460c83,
+0x2ba338308820d232cdd019154fc49774b0c884c7f82b9aebce6ea211db294991,
+0xcfcb2e3744279efac866e0228c1b3464a4048f4910d17042ba1a6b8cd12c8e8,
+0x24cb3811355775bf9bbe6431305ffeac61c7de7c629d9a5ef84d960cccb940df,
+0x257540e571a74fbe3ec524ff58f183ee0560d506a8d10973d77e54c9d9061161,
+0x2652e1e037bffec0d7be1355de11170b7f916d148a7c3ee3ba8fa44817d48fea
+],
+[
+0x683e640e6154ef73c3cd6b1d0f0fd86ebf7e292e63fa84cf0a883c2f1faa8ba,
+0x10017188ff4a2e0e9b05536c8d07e27d0f194cf0689d834af2be2b93ecf20ab,
+0x2afd3c4028b2ada5d194c593bb5e4e2710cc5c32edcd5865b59d4c7ec037e251,
+0xebfe1c74eb49cc73b0f6c3f32f096c2fa6288b0a04823e290cd02dfb5e5dbc1,
+0x2be96b6dc6b5dc0f78ebf844a52f6c1d50562238dbe7b95c47a2ba4ebc0e1c17,
+0x2eeb27f0c5a205ead76c92eed0ac8a112c171711b1d12d1e066fe3527174f6bb,
+0x131560b779c80ad8cdd22a9c3ba80290c76de761b1dc6e788f7f9493f84d413f,
+0x7039d5dc74b4dd2f6a0701a3179b502b212c3a4503557e6e8af0193f07a5669,
+0x16b1fa736396549a38076cdd9df36cc3385540ac1d7e42c79aa0c9cefc66a65f,
+0xf5008caa5bdfda3401446482b3ce891ca497cfac4a24ca2571a02a8ecd6e78b,
+0x427946475c0460b0fff4ad995eb4a9c608e260007589d7195b5cfb892bae4f5,
+0xad2c3c083a08091a9566bf29eb7506952d2ed27eda2fc0f51894b5d2e28aedc
+],
+[
+0x1f09f3fb07f7f6476fac98946b7375095e014b28f23a07ac9fc7077144ac3979,
+0x2bb007eb9685bfa373e688be53f5d6dafd6f87413c9805d20c579933c6ab1124,
+0x2b22adee2ededd40c3dcc8e1b15d38081edf590a9a7ec2eb630cbfc5292f238a,
+0x6ac8237c50116ad33685d84005ae724cc52e0ff4ade0d47b194f7923231d67f,
+0x217cef9e11c01178da427e2b9f7fcbe4c1f1525d76d3ba7c8850191545e58295,
+0x46e7d8895837a4a02894e5d6f3ea8d51adb0ad4897434ab0d0e8079253f2fcc,
+0x1f478986f1820203e99247b23f9ae06526a085c84cd31655f82c17037b1de5ff,
+0x3a1fee4f5ef14a50af278a0b62247a6669570858ac9b2074df28b0a4e9303ab,
+0x188a23c2b448e79af34b9b4866c954e698a6163ab9326f25f2dd746cd1347d35,
+0x1cb09fac676323645d322c13c676eb4645446638d83fadcb37c4f1788acc1252,
+0x263d998161f060aee0e6bfb95f1974efe466f739715e92c278128c7f18ad5e7f,
+0x2488b89af9d856ebc2f9053be37e13f9e1e546146198b764e0e0ed784115d94a
+],
+[
+0x598c38d2e2c78dfe4907c74e82325cb191d52608955b583e5826ebebd1857b5,
+0x27fe7a3879727f44da5d035c1ee30fd12b4a6d37a488981b4903d9340b67b7dc,
+0x11033939341c415cf31321211e351744c0831403f53a65832694b35adfea49cb,
+0xf47bcf189e8e4ba1b486290d0c9ee89ead181850d2ff29b97bca91518d8c2f3,
+0x53090370cc10eadfa09d586810cd0da5ed707080999f1211f0094108e1b3d57,
+0x2e2c801404eebd30297f3ec0ddf5e0dd9c1e0aab055268e647c3fd4712dfc84,
+0x203f12fe19f06faeaa77bc8baf4983c763081a7af43dc5e7bb83f789eaeee5b9,
+0x18837bc92a8af3d37214cb2724b4c8b904e641660e5a48f79ae4a49a7bc37ff9,
+0x9f0706eab57f151b23e4b968ba0b6bbd4fc82700acd601333382757a15de2ed,
+0x1e7d6dc15eb4669f914899901e7deaa91d102a4e4d569b40b9a11d1241167ef1,
+0xbc8d092c5d38d087f9f34faaecec3a55ee916469ff5e23e619b73468ee8eb57,
+0x2bfb96f78ef7fe047373d118c0aaa0140ff43e5dcabda257cde23856a654b6fb
+]
+], 
+        [
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2e57ee9089adcc51f2ec7d5fc42821e67fdf0a2f3d1add870823002a1e9ff4a9,
+            0x2346c226491dde21f38b9eb1be8c16084774e9dd941895eb362c2bf763050cbe,
+            0x2c294fa2466a0a9f1f89b1af5bab1ed3b86a0ea730770854684c754750efdcc9,
+            0x2519e073c3abea02f7784cd8c841ddcc10d65507cb4e85e8df3bf85a8e41a70a,
+            0x21ea0bdd27e0b8b71b91ab46798b907ee094cfaca4c68ad81f9c0c107e7a83a4,
+            0xda23ea74cc325d3922665cba17876a643c4f6ed46f9813ad0f403955757dd80,
+            0x1207beb18149148fb6f50f1090b05de32ec5d438fb30604f4c63c237a8cc1d55,
+            0x1c357f783a3df3f09e57ffb971a7dfc50c1145da9f3f67f323b4742ef3ad7f82,
+            0x234747b2d98835ee8b90f19b5ea03c13baeb410f21211383ddb20248608c5862,
+            0xb38e11da34730bc74b7f3add58779f2e0bc55734962a059306e4b950276725d,
+            0x14732e1bcc452fb9fa40e72910575640b674bb5f90353a52356a6133f26cbb9,
+            0x197d6117415de8855e11099ed6c9c4d76433d39fc7f4cc800d5beba27dc7b40e,
+            0x2b3a311741f8b94d8255d87810649ef6674c7a6c7711a83ff88f2ad9f7e23c53,
+            0xaff38c1f5500a4ee4949e5eef338372179779bb29c95142b3ad18efa9e673ec,
+            0xdd0c48ff292bc764e9fd84841939694a761178783ba99381df579cd3385d8dd,
+            0x723a053723b6cab73e72b36722bfc52c957f8c7fe0322d77348955575e841bd,
+            0x25ca5081fcbc5b5d8b808627af3c9494e0ef74245f9aa45419d3c400dde893f7,
+            0x2df552ff14232529c8216996f16bfab8d5555923d2e4a53706da66f4bb013969,
+            0x876f56eb6844dda9bf30ab548c8f0b3c4127ebe7fc31e1cb27e3ce62bb940b0,
+            0xa8f10d1b35ca9268bf4403635f76f1b9ac2e39ef1b5c9e6d8174f4bcf095df1,
+            0x1212b888592b16b273c55c09e887270a15efdef111fb3f0bbab6f34c4cc24d81,
+            0x5f5771bd30e0b5160466f322ecc23f28e563a44a80a3df85eb30b2a6da5681f,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x26bf7fced0bbe938cd67479fa2f03e67cb8a775892e972ff4ad493655237bd8d,
+            0x10a49b9136eea6f2c3fc79d946f8b8fd64854ddc3a964c57462ce17262ad7d93,
+            0x5bc772beda5709a6fd33b3625682927678d5d7db7296f5703ccd7e40e0d8dc3,
+            0x15d73afa88e6fb1b74cdf3ea97c694ce695fd39695ff3b7266371d1870f610c4,
+            0x20656f69e483c5b05a2c5e26aeeb9f30d17b01054be5d002b4c312a32df35daf,
+            0x2629526c99e13dd1862ab8d125a34cc68db0f3bc297d974044668daec9e567de,
+            0x1e204bb473dc75bef5f17f5f828e521f657d8c58db1f4e096f5046589275609,
+            0x2a4fc3c7b54eebcd023dd0907ea97d73cefc2955a5a8347bfb5c41cdb10fb1cd,
+            0x374b0643d980373a12d798e8ce0f9e016a3b3d9c71e56e0b979534aabc3410a,
+            0x2d54f4a821cd3a86fbeaa914483d0fa23a7cc04a6be217b4144b668ae70770c9,
+            0x29fcf234a9344cc6a8541f6da7b2ec3b0cdf256408c362bd72048d808e72893f,
+            0x4254caca99daf3eb34030e734085eb2171f7346ca2e9f43ae8f61a4ee43c358,
+            0x2b4c8db3065c297d08b7f1cccb32a84a4bbe657c16ab0d9dee4bfe59465030ff,
+            0x1248ae908fd75fefc42b13be685cade6bc106684ae4a4513ad415029374ae02d,
+            0x1cbd111af62201c242a38f3a1bd792501cfdc5035c71961c29199a4a7167edbf,
+            0x2eeba2b31864903d017a3036f11985a8361caf73d4fdb215c5552d9e477a7a52,
+            0xd32eaed9cd5aba29a1f8cf029d022f77f5eb2011fbd7b8bcf442df70261c724,
+            0x20971ff3e27ffa9dc609a839e591d688d07dc636d2cc79ce570c2e5b79f63b6b,
+            0x2a8bdd4b9b1ef96bae00899ca737d2e1dca4917679af1c64f62677d2d626e314,
+            0x26cfb0174d91280bd05b4e9553c044886e8b8c8b30c36f4316eff726808ec638,
+            0x29f510be57ad8e8a7358c0697b8f2d761e7e6237c8aa2ee452d645c4fb5f3548,
+            0x1c1cbfacde1ca981ae5f91b44a95f4252aacf086637ee431dc81a89d4db6b41a,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2b7856136f545d69ebac3c459451f28a2a53aaa144ba679023b2161887ef1250,
+            0x250c047260e50160cd6586bcf0ea5180821fc71c3788567481a78e7c8b9514b1,
+            0xfbf82f8a52984b9d4153dd6e78c05163c8d4720915c19767cbfccd0c3973488,
+            0x6bbc95542ed85d6012d232b16d3d01deca662a0f61bcc164b6554b32e61f31b,
+            0x28186714392c789ae58ef7134248ad33a5f12470e416718a3354f34056fb12ff,
+            0x53afba658da76de92084f426da8b4c0330e7725be947aa266b8c2f9c0c55c4a,
+            0x1844872b8235f851728c66e0b29d5cbf1cd0a0ad5ea4885b2c9967508965c9b1,
+            0xb09ec5a6d9b68331f53ca5fed46443c6fadd52ea4d9c4640de3fc2940c0deb7,
+            0x638529db7cc2182751ea21241763d10d34cbc099c578b2603cb0d0c0fcd89cf,
+            0x5d066dcaccac1ac0448d43671f20833fae00c106de7fe28c9803d7715feee67,
+            0x65da2f374618a50e6fa3a0164160b1e6af42a76e9b187115b330d60a548b3af,
+            0x2e202380b8f6d90705a135c42066f1cfb905077d39e7a02231a740a3262c1e08,
+            0x14570c40a4e7ef1c096e9d8fcc0a46cbde32dbb57916695206ab03aac2e82f37,
+            0x2d87c245080329821da248b17456f9e7c106ce8a803d3d015a8bfbf952897c4f,
+            0xda8c6fc810ca1891938b417de296864f3af15c28d6cb1d59e2de28ebd010fc,
+            0x2018992835e00507a6f2d97c728ca059eb76a7fca5237a36e9aad99a61265cc0,
+            0x2d9099c975eb32f31f10f807baea25ddbff205c624a66a4966aa59bc8aaae718,
+            0x298dee77db6b29e44395264887603d287c45850a18582a8ac9bd09d292882344,
+            0xfcccb87f04870bca6382244b43a0f7f92d336e3bc4d7e7ddef48160e2de989f,
+            0x1297b03aae9b949e9a5186975613ff59bea3a058d34baad1b3c15178f19e7ffd,
+            0x893a222f29077408802aa74dc37c833df480b350eb1ae31eb1b9f9b20b3f02,
+            0x1231b1b0d91bc7687c3813b2da32e7c71fc9189641ea0dbaf1556ead8f36182,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2077a6155ab34ab05777651d0151e0320005731dc875986256e103209606fb1,
+            0x11a4f3347aa9f08e59856002487fe97a4ac16dcb9a7962d139a3b80ca952809a,
+            0x146016f8ce100f6cdc37afd22f00aa5359d531ce7179a2fc691fd12b00c12d3,
+            0x25045870f9da8f4c97e11825c52cf4ce40bca1271ddec4ed01b774fdab83886c,
+            0x156094487d4626cd97ecebbdcb8d41d7e70f28a6734dd3fc3382765ea111fd63,
+            0x24ade6dedeeb900110df4f92bd790ebe1514d4b24bc88062d6249eec85805471,
+            0x12ad265f80d855a7adcc2ab7b6bb9f49b50287cbd36e7d9e41860fc6596734ad,
+            0x2f16237203d13c693faa6da2d3162b25d0d1be895c8026cafdeedacec7d7c835,
+            0x1868f1766d3e2f9bb152b15a718ecbab287f6d9cd2e9bc5e66423b5bbc76e43d,
+            0x128e30bad26f11c3be9a689a10d093822b5d2b920a1b78ddcd7df1a8bfca5d60,
+            0x2e72c3b1f6bd3a793b27cd802532d2768deb9668ef00490a0716e95431abbc5f,
+            0xa3e8c07a5a634ea815e1f57afe9494515da623e363a408e505e01471c5a2bc4,
+            0x1a5c7a54a81fd93762ce79db6dc604f03bf519d683cb2702839662e69271bd6d,
+            0x13222674c9603db4a5e5a36398d24d77543ac79a4a31db13b48c9a1998046035,
+            0x333b7ef8d75e61e9f44ff11182db70311648a7b78addfe4f2144291ab5987a5,
+            0x231ef3a554066132798e544505b11d50106c4406a937c9702c7bde44457d4f47,
+            0x3016482ccd1ff28db55d6532420e95b9d3c66d1b8fdcee5b45fd94a4ad77088e,
+            0x284acbcd8d3b7c6e7e7fb246fa9b39811c045820eee55e57e68d7a6cbb7f165d,
+            0x17751244cbe20f816b7490b7346b8ddaeac1635588b765fc0e7cc337546999d5,
+            0xe3b27a81103dd231517acad6c69e41fbf488237d0fbee8f0d652ec72bf09a21,
+            0xaaeffcbd016b27891ec8c80384a7356211b9996a5cc9adebb24700a976d71b7,
+            0x118f45236c875283cde478df3bd4ccdfed53d087ecf8d85d24bdfdc78b4018ca,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2cb4a528ebaecb5ce5044e609a9ec5f36057185a88022e8340d74cf48579595d,
+            0xb4aeb2205324cf9c91474b3909faa82059ace7d53f4ece6e91971c11d212adf,
+            0x2e879ff17f31aa36666dcd42303d4aad9f55bc8d55ddcd7b8c54ef46fbc8e66,
+            0x1bf5f6555edef79bb094218b0980f27db57f9709b63a9c94b18552be085a62c5,
+            0x20a3689b70840d755fbf88c8fbe323fa7c7c5aad0e8923a165370511585f07ec,
+            0x10a50b432864883bf92a5fb77e6003514f43fe4a5a1c070a932dd8340eaee2f3,
+            0x6162a58c2fc725a6cd4746c8f229a99f9616dcfc54014a2c41e97b9ec1eb29c,
+            0xa12e5fbbbd66f0de0d49810e948220591fa478abfcdfa1ab0fc5fe861b2140c,
+            0xb899ccdc1131b112724493af11636d6421db516a59e8fc7f6e8240bd7581bfa,
+            0x12506c3ee2d15b082a2cf3111e9bca3d255a2aaa48e16eaf5130461f5d8820e0,
+            0x2135481566f8d976d6c776c65949849e7dc5a3097d8a7570240223569350397a,
+            0x227608e1587276aed4b92b8c602d81fc32bc957826e2c4c83d8e82a46d8ab68,
+            0x1f4fc5d8d275e923bd82f8f2fac04f63bba4fc9558326ac9ee895fcf682b158d,
+            0x1de5b21d942edc83d8c79bfea64f54e681143399bbcf58d4b31c8c9d671355f,
+            0xc8d9ae8381b7de88ac2894407c8158fe09fec7e372a4548cc0dba4d9283aeba,
+            0x28e6f24ef229a25016cfaa7e3007304951e75ca14e8eaf7b19c7e1df58033833,
+            0x16c93e94d5ec1faa31dbe2a105286d839588fd1517dca2e03d6b01d381adb9a4,
+            0x12c51f2640a3c05726d08197e01fabf7d5da91671d33e40e00f924027ab24ae7,
+            0x1ba9324d77e86ff6234db66d6183912bfe23527e2c056744231d99982d1cdedb,
+            0x6616e7b8b4f34595a4591bfac7429663b852e626d20bce6ee7805367987d67a,
+            0x2b291b00aada886311dbd8e92fa67673a2e9061f87b43a3d4570515dbe9656f,
+            0x24bc1c978fcf44441f251c075eee52c7b0b733edab05b4d2081a4b52ea798fa,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x258a9d2af52b4fefcd409d763bd8e406c4355a9c488878a5a2c282adeafa297f,
+            0x2fd82f70d05f4bebd46634d329f317e76cff5149a81424d1da18580f5c1eefc2,
+            0xf4b503f7be48c09319c5a9b034ce2dbf3040873c284ac09f254f5ce86e88f63,
+            0x276d0381d413ba30b831d3fd4a292440091a1f7f4ff919fca4bb2b2c900c1115,
+            0x28e661e4cf942f9c9f95c503ad1d0a2d078ac4644c5dff369d5543aa7c48f798,
+            0x2173c6794694634cce267bc21991598f3debac70920c9d8775947bcbe3f51124,
+            0xa3fba241019270d5cd8bcb540899795fc593b5dea208cf016a8af970cf7cc2c,
+            0x20fcd9c08eea8de9d38dd10180e9622d5e7c7493d0f8c511a4d2f9e5da45fefb,
+            0xebc5296052433f86416ac17583ef06db0b6abd8d47110b6fc40bebbe02ac291,
+            0x1d76be7dd20256408dad6674c8d0e51d5a5a5cb8fac79067d3796456168d002c,
+            0xa94d77bf887daf01ce54f21c6891f3a9fe14faec2a1401fa3ee22a0244ed155,
+            0x1174fd29cb4654d093226766b105e7ce63f0016a0bf790d847522e906c357a86,
+            0xfc72bc5d051c4abd69d91c14cec4cdc87fb115049f1b08aa482f7ac7d7c4e2f,
+            0x845158555b18fab6a2be184849b6569c1530d836d9ec37f9e4e14c2067420cd,
+            0x28220c506fb21d1ff3ebbc47c2c8d766d427a30b53a3964ba575a21021d8b9d6,
+            0xf45897a8f2b5c4214db423321f9763aa25692e0c05d46e9a45e5253aa696a20,
+            0xf71e156500b67e356c98999c688c8b2a354d0537660e0852bfe74d038a4785d,
+            0x1b933d41cac25dfd0de679e86cafc7d13855e4871d9b61e119b04d5199c09f0b,
+            0x19287775fc90903925ac37f60e269bf68dc05675079d212bfc9faa6ff6a49821,
+            0x207b6ae3483a8ce2bc1b2f428c1ee240acf3e1ca010f5820b0655c9d8eb868ae,
+            0x25d71d41264bd75fd50528062bed8223a243f25d2768169b343334d708740ff9,
+            0x2eac8212fc2ad788f72ebe8710f3c6c98625e52894645f3d714ac951daf2031c,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x172fd12d4e03af148aed931034e7060af7b8e8546e9e4e7935a32fe7727ae3fc,
+            0x154dd36eb45f530fd949b85233eb745aedb76297c33ab036bca6f2eecfa030,
+            0xd6fee6e12761c3832a48a89989abd5c6ac7a245be31dc258b03c12cc30818c9,
+            0x1be1815b17dc7aeca4440d5850f787c64f7b251ddb137da5319dad8d9025fa8a,
+            0x2be2edb8867a2c4cb3fe2653db4b526e7edabc44418341fb708a6620509b8bfc,
+            0x6c0fe57a444d90391ceb5a94ad1de1443bd026cef8763daace23a3b701a5cd2,
+            0x1544a456bd7e736ec88816982cbaeef38530e1c8480dc59bb74ce844de7ec438,
+            0x13dcec7c410c82a7cf03cdf661e4c477cda63b31d34274653980cf3f6f04fe70,
+            0x28832482d1891b799b37a9f34f26a72a8ba4cff953001ad0581cd4080d039492,
+            0x1453cd3bc8d13cfcfdb0ca235673e3fe47f91772a386b11b3108faaa8b04446d,
+            0x2948c35a60690dda3b5dfabbc2cc392c585671d64ba338f5112d4ac46720e3fe,
+            0x15bad7a6723fea31ca2cfb8b79a656a16e6020406193e22d51897bfa4f5a2d0c,
+            0x2a3eecdd1a4f9ba57ab6b9d31a359352c49dc129d68d9c509a74af0d1a27a25d,
+            0xd1a72d9a9f731b1988ba20f99d8b3d81572f27035d9288d8bbd3685b288f94b,
+            0x2099ac63775453e12762b57075cccfc6fd9574a65f15bac95091dd9475351a60,
+            0x60d681d211c02f7909fa329f6e05dbe7455ad5879ac8d3d191138b05d207b82,
+            0xb751b2674878344d13b251440475af9b37154209de0760456b1dadd1bf90288,
+            0x12c11a657f6024257b1d2e79e5a9b76a1efbc3c3fdfcf0392c063086ac58a01a,
+            0x17c91cad834837b9a48c46400d3e25e1a9a7154c8fcbe0115452d3d23d265b,
+            0x1fc3820af6ae6515fde45a315961e27549884e2b367ff88b4ed93ceb05de6154,
+            0x17a167b5b9014ca6330036496095ad717f6e37a4dc776aab1b82ea7fdf751ded,
+            0x46702f62b69daf94a105978608dd2c3a8daedbe7823e8f8275c8cbe16a97dc7,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1c44223b01de8fbda664ca95848b813295f013b8c208c88e9947d3fa8d244cf5,
+            0x25c7179c48928fee7e9caced6240b851052322c5820ba2bdc329868ffdcc17d6,
+            0x1958a68f02408107fa1e5de776901270181b3eecf421c6aeadc11866a64e2b55,
+            0x17ad9adfd56f8195f4cd55cc87a833e9d6a12e091b59529d00ce604e99307f4a,
+            0x5638e90a5883705652412ca5cf9fe315bbaa74743995b600072dd4be5f5ccf0,
+            0x2467cf163474afc71287ec56cd6d8c6f53479aeb3fa0dfe5f5129db4385e5ef7,
+            0x23427150e60b6fc48b7c8d5140c07d0f97f81f4397c0959fc851c88699c8f02f,
+            0x16f925f73e091b1749ba5560993157d7259fff13c2010e4734eb77e7ada60aa4,
+            0x2dfd7d6796e20ddac5fa12f1e533957c671fabff0c8c74bc5b8ea8ea4a4c87ec,
+            0x664c8b4ddb68209c1253e424883a0fc059fd49be46a468ffed7bbb2c8978eba,
+            0x1f3ce48c3ee2922ba46f2bf0ed51535e1d559d223b489bea2989116d48e7bd25,
+            0x84ae17ff7f684885a4f21d24613d733fa2de7c694722611fc1e86c144618455,
+            0xae2be5c975fc9c57eeb14791c5234c2f3e74c8ab151d4943fb98f4391888c11,
+            0x28ae3fb3896a81bbc583a2715c9e2193209c79be2a4e9a894ea265010fdff87f,
+            0x1a66346aedcb602f39974b69bde3c83fc72944ac6c2dd32a32ea5b3384b4173c,
+            0x224a43476e893bd20cae3950ebb698bc5594f0f70ec5be20708dc428b2aa0b05,
+            0x1d78ef43d9271f5718da099a5ad658993aa6cc4e263f0227433c1c0700be9a13,
+            0x1c2ade57dbe0afc29e9c116a8b52dc653e3b67e891ddd363e1dbcd515c7f07ba,
+            0xd3432e9b73c810f7b1b013cd2c9204574e75dce2c85d7279ba1ee5cfa912acd,
+            0x10c5edc9f4201dc2b0366ea68593aa279438745e4e98024b5da5300bbf594f95,
+            0x1424d5095a3ed3c98e8d59c21743e2ee18e6cd2fb87a4f8fb566a51d550747bd,
+            0x1ec3fdc3a02833039f3ef99f01c641c62f0f90af4e2d9a961048e9b87698f117,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xd9abef260b1cb444cc28166a74e729a2833e12445aabcf151c1cd036d1cb5de,
+            0xed6cbbab2f8701da54b8b692304d8a4e8cb2e08f655c88924e27f4f15a9a52b,
+            0x2c637eacb602a657668bd513a7a1007d825cefd98444e38b021b2c1d950a76f1,
+            0x20fa81a9bf57087cf32bd01facb98697426792c6ebc73d02db7e5ae21b750d19,
+            0x4f1d239fee709de5b0b5e5d5de370404d7df82d22b08c30e38a7550738aef85,
+            0xa1de402ccd1aaafecbf31017e71429162b1c6d80579bfdc5b1eff7c48bfb810,
+            0x1c14d03118d712c8ec5c8fcdc25ec9f15bfe8857749a7d43df91232dd65f37b5,
+            0xc5e0c42722e6a74e7c9d75d128df4a564da3e0fb809cf7768615a2cfc0e9183,
+            0x78c4b7313d470130efab6d889ce7c18832e610f66981841824e6f1d812072bb,
+            0x3668b307c93ec14fd047713c1acdbb0b9248574ee5d6fa34fe883f1c22f3cba,
+            0x23d9be76930ec686660aeda8b0cf9753e10c87300ebc641ba98e09dd2f52fe4e,
+            0x29a3b2345ec04133c77316b42130de0131eb92263c4dde2ea07063c5c128680,
+            0x2094711a12812e287d245d3c3efef7c17f18aa907378ad5060d80712b195d4c4,
+            0x5c8d6aed39e2d9fa9a2eba112b4ca0aea1afac2c3a68622b50484a2c356a567,
+            0x15235ad2ec7319fc572119534453ceafc36bc0bc2e4507a2a8ef1f7fa9e3e856,
+            0x2a25158b0df94b0aa9db35f56bae7b9935418e9d6ae0d7004e23fcbd38de35e2,
+            0x12db88ed4056400b8f336eb2d50eefb47c8cb34c31708093cd4f7dc30a13e2d6,
+            0x10f2112348242ce97f64d304a108694283ae8959e5c91731b625900540bed1e9,
+            0xdeb481ab3456ccc232dfcd50eb82acb8feca59538be59659fbe39426181f3c4,
+            0x2bae45f1c2ff62e6048fb24ea8b3f732f6ca9620040285b5f89bc2d4db28e16c,
+            0x2b93089446d7130073970ca2059fb0c06102fc91a6288339b687470613fdbf77,
+            0xf0115aff5d6fc582b77c744e7a3310f569a0e786e12b526a741ad7e958e1052,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x116ba64981344053dbb50022cf797b7cc2fdd015965ef309453d3f249d581b04,
+            0x15d813aa4208144a30d1b4509db1009a7eea4f4a8ba43145f72a0d9231a45553,
+            0x1347fc037b2b26fb2308cf417715a9cfe43c2c65f2c71c7bb6c5c40ebf730e8b,
+            0x153cbb5ae6b6d48a1360870cfd5f5e0f4c4ea591acd14df7a02b2edcc2eee347,
+            0x249ff166662ab43663e65ec0789c6ba6bf1b8594471a26162cafe6c32106a003,
+            0x72bc9e678fbc25cf9101f49cbcfc48cc0a51b86aa9d7e66c52897a5d3f5dcab,
+            0xa6577ae2a5cabf4c9f00eea76f9fc2196288f1f8b3c16d54c21fbcb28a1da20,
+            0x1c610a46a4eca6c1215870d8d35d92712544192b256de5f82ff6d3cd6eb327d1,
+            0x2b9a13cbeb3acc4a615f45dcaf18828c844a1d61be9b59201a8fbd9db0cb2640,
+            0x2ab0560dff6af3c0ff49de6b343eae05c665a0caf15792d3cbd8321119ce2b9b,
+            0x16de08dca0ad6de9eb247866b16cf89da11890bf1285318b92cf302d8fe144fc,
+            0xcf760300b2969518645ccbbc9d94ff315b966d828ce76e9e665fafe496dc979,
+            0x260d564df3dc0db676e22fa410e41794fdde75c4f19584b43650ba909b44ef55,
+            0x78c91572dd1477b07006fb1b5852ee50abd789a190db81c0c51de867ed1fc11,
+            0x2280039d47ad466e5af645f064e0c10cf12e92c3d40675008d4c4eb9e873807e,
+            0x57e2320efb4234e61691c9bb57aeda4fd11ab282b2cda1f69e91871700c81d,
+            0x22f771ba7d2d275cf543283250aea007432a03973c77a82744bac9fd942136bd,
+            0xf01220ddd07023709c7b55a1485f0a5443030435aa02d9ee677fe4d5ea0e62d,
+            0x2e1da930eaa52749c15bb6bcd34b131e7c33ea3ada98437dd9b7eebb22db48e3,
+            0x6d621c55789875af6fa6645af8da7331e54044a5ba01c54891ba11af10a36c6,
+            0x1ac30223485713604244857141dacd036ab088f29363eb51c3113eba8ef808d1,
+            0x24f06bb121eece3bc8c62e05fa6c0ebe28925e2a47a6d16e3269c5984682da4f,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x146b2acd097033a165d7525b2ce6ccaab4d541d5ea58e215166d393cd5677dac,
+            0x1fb587e5904d58efa007310b9d86684fac658ed406c70d0e2af913ea416003b,
+            0x2ca7217280f3cb8744c3c3824e46c6de85b654c41b19f4b662f8250f742041ea,
+            0x1ae6ea2012fe1e87bca1988cefb126d63082cb3fa74a717b3008a4026a6eb28b,
+            0x2d80fe550d7a4f7f67d2b170a430270679f03d119839d9ca72efbb9982dabfc4,
+            0x137557593958b59bdbce0dc6594c99cb85c80f3e518e99179d8000b339492575,
+            0x1def05089b4444afbf11ff8fb6e10259ee3b837fd0dd3d9be17595ecb5480c92,
+            0x201b23b3cfb13fdb40deb239b3ece158fd8c67950c242ededb39540f9d71788a,
+            0x22d9d27ccfb5d874defd155bdb5e0f9255e7be972f912c44ada9b7a2831116bd,
+            0x239a279e55c2fd47d5872597cf2ce10ab41dba4cde5bf4cd7fd478342234b264,
+            0x137724d6aa363143908f50d990be5f70794e6b9fe17beea4dcfea9dc0b6073c4,
+            0x1dd6e3fde1b84a0b4a9fd1016d1c6d22fa80abedf000368d34d8c069be2fee72,
+            0x2c94522857162e4e67bfbd495e823aed177c8a5d87d237fc57e5355b177e73c7,
+            0x183022fedba6c78d0076bb2c2c6bb4722444fe77703e0a6f462dab5579dabded,
+            0x2252e07ab4d0fcf8dcda2fd18514f0314282297cc99819dfcf0a5a9f35544430,
+            0x719e632cee131b853c0824f527980bf00f18d8a16aa7f265480cd10ed3428fd,
+            0x302441b28d3b1cf39dda7be9eced59f318c188274c6adec584737856495fd875,
+            0x12692c7d7301e18bcff106c275cdd2dbc67001502b21aa890d6bd70e95a76934,
+            0x1eada016794439b4d460b47956301225601ba9273266a9e955fd3e3c347aa7df,
+            0x5cb3b0ddfcf2ea8552ef578139d19816d5c3ea7084f80c8cfcc43960ac2c980,
+            0x13b78f0215ed7f48f40363ea5640fb9a41bfe6ff5044ad3aff51d755d9bcfb15,
+            0x1b3a63d2f5d84163f48ff24f99ccba5ef05b29ca80019907e1c3a789296b22df,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2957ffc8d1b0a3f2dd026ad7b90fb7eeb555d3772d8f2c7f47e37e913a921fd5,
+            0x2a1c6c7b345e260cbe11154aa6a062d87725bb940dfe9798e794d551306f75f1,
+            0x300cad430463e7de043c54011a594b2e5aa9f0aaf6558a5194a68a3285bda986,
+            0xab63cd76eadd01e944a13e73f2f03afffc11b4823380c6d0f653cf2966b1eaa,
+            0x26227ae79cdec5b80aff802dbb9bf4e8659ae92bd8a83be6dcba8d5917c4d34f,
+            0xf30d1719ff31c8ac2175e5fd863b5b04516809e3c7ac6ec41a1a53d866a71e,
+            0x11c786871cc25ea48df5ad070b2fd3969a4841f05885a80028d910b7b6e6eab2,
+            0x2c7a714da7b75d6bb3eb16b8d1599f3729105bae675a1924f43c3239f9c1335b,
+            0x24b7026b296c245b47ddbc1e44492034c4b7a8d35b2887cd539513c5d0532403,
+            0x2c247c7290fbeec55bc8593b0f859b43451002df189238934b16bf1a20d3624a,
+            0xb94893f2502d38fdb691bfd23b211fac95d934cf913f4c52eac9999fc059e6d,
+            0x79b6b8524b8270e480562beac696afed88406015d4419a8ff123329050dd3b2,
+            0x27e2e1708fc82a7868b3a0fabf059d164ed3dc38f0e6220534928b1cdf59e26c,
+            0x3040afbc8482759cedf03abb41a1ee858cdf563190eecfb2a24424d4964911b5,
+            0x1741752784ea1fc7304aca0447b2878de168c87b78e2c3ec32d6805b4d2a41e3,
+            0x13445ec326f4aefaa2a84547767b65d8884679aeddb391598b219ae7ffd41830,
+            0x2b23df120933a79eb1feea325a521ba5d53372e29d279a8c32dec33a83dceac5,
+            0x2c6adf68e43f02f6721d9fd6d19e8934ce3a462ec543ff34210e828239177789,
+            0x2e9faaed5c26fecc4672723370623d6f563537c06d1e98292134f4ae26f1cae,
+            0x22c261e0c7bdfb933e808382fd75da681f46d90e703407326630768407e0c27,
+            0x15605ce70aa2918973c4bff136303580b51fb071d5224a1732c10424b1fc7a82,
+            0x21ecd0341474c3b4ce81101d267ca95d7cd2647fa4bfbc823956a9e348ddb877,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2932e8876d985ea09549df2c64e8097d85c3578aa46adf5eafac039999835c5,
+            0x2c1bf660a1dc8b26995b0e78875b0c28de9ef7b591fa2bc01a15ce7729b9ac5b,
+            0x1e88f3c4efa334fa5bf313a919c4de396bde82e124f0002f1c00229f8dbcb67b,
+            0xc774d6acb4fcc45b139d92323da82304fc4e29a919c9468746dd20a6e03fced,
+            0x17c11174c9104e2ea1a374b75bea6925ec45a1d9e5293741944e5359d4d34408,
+            0x221f6d3412048020aa832d764a5b5e80af3b014139b28f06920cd3a3d3c7b7b3,
+            0x2c0b403d133861410859b48131001ac956fe4c9e5a368d9c3f085560e5d37699,
+            0x1da9a5cdcc8d5c8e8390afe24b8d801bb87b9fb9eed429aae52aba17570c9d03,
+            0xc3e382527280ac6525b3922388b310dc9864d9fd11815a2c94f7378f3d52f53,
+            0x2e733c656ab7308a5f77b1747c7c7562f0b48d9bc42b4c1392632840dc67eb83,
+            0x5500ca3eb4bd08bd91997d4fc698fa050d5d80d881f634f84feaaac57b15b2d,
+            0x112aac301ad5ced619c2925c297d3387bd0690d0972aa21f88d7437f42bb5cf9,
+            0x273c9c5526da6130164e2360c9cf111e2a1fb2b5f02a5a463c6c64d55a6c4760,
+            0x5b30e5e7b01d8730fd549eef232bd3824b3a670604ccfa2407f2a63eab5f5f2,
+            0x26e905c3889e46597070e8b67d4ac9ed44f5a89d59efec7add002494da376c6c,
+            0x3a4bd09500b265238ee8fe2cc149e058d35559d4af804be07119815b5b98960,
+            0x301e86bf4790028b674b2497deb4370f32b2410defc6a4f3ef6e500a0f29827d,
+            0x86d71db143455444d99b9993964b827cadf4feafebddcf019c278f32c8114f5,
+            0x174ef177c132d7a3e91f02639d7dd88248435018525f095ef18cb846bb060e62,
+            0x57af114d2416184735fcff06d88e734f7d8d5dd412b7c407bb3a0f09bc2d44b,
+            0x2cd21076d55f5c9c8c3c3afbf7f0eb2faf05ff80d267eb692d93b8400c9b5fd6,
+            0x1ab2f05ede0b3e9790517712ef714568d570da3a0833f8e8317c1644264ce97e,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x134ff00b65e9a214f19212b4750781ba3dd2e28511f61cda7a69553bafb44dc7,
+            0x144774a605bb8a7d11b2f8fbc2a0d05146812a9f1d03c4be608a544d18ad8f6d,
+            0x2f1de3b0835804059ddeb1d93bbb9821f6e2070365ff34da2c43dff65d3edf8d,
+            0x930a41a901ddf9dc66d27b2238016500aec43b06bac6e7113beaff39df69c74,
+            0x5ea98895839deeb637c0693c60994afe4950a088d1005946b20c25f48b1f4a9,
+            0x2b2ad0eb96fe5e5ca0062109b8c535d32ba984e38547f3d1050b72526884e14c,
+            0xea3a0fc0b46da189a9dca213c0288e3369573fa66b3d3379ae56df2a25262f8,
+            0x272ea64f54ab3526e4679a0d0982560233af7b7f2e85147a86298fe62afb073a,
+            0x281aa6e665287f9540fb2f6d13a077d52e145ed62b38c64899b92a123357c089,
+            0x2a432fcc6ed2fce50bf214a31f9546baa2fe8fb3d1d00145a7fca7482ae2c390,
+            0xa9809138f12435ad1150f8fc74d401d992c42439a44ebd122991bece3824ed3,
+            0x109adc1cf8528ec8f537cfe978e320e2a4027abba83a3781aee0b88444805154,
+            0x979b7716c8be6bc4091a376ffd1fc1313e19f3266095bc753da2cd4df883ed2,
+            0x163c946685c585d46b6eb8a3edaf018353549856ff6ec0a238f45a1f0d593af1,
+            0xd3d1890201c5bb1a7e40dd5575b4267fad63ae91f429efc5f57f52f498f4203,
+            0x1f4adf58a1ca1586815ac26a76d8d6a25c313e9b2b0ac7f830e6e1e0cee2dcc8,
+            0x2916cd6ca0ee56ce79345046ce1a91a231895fe24628a840852474b240b53459,
+            0x1390ae730e0297f1c7ef2e27b3c050d6713015a40370d6a281f1c985dbfe86f9,
+            0x2b747562e4956de74f4b115e082bd95c00a7e2a175255c7ebef7cdc70598de11,
+            0x26d57a5bdf2b1da9eda88e856c4909c4265ea86d8b7f630caf123aac328e0207,
+            0x24410235e3faacc2da4215b96ccc5228faf00709dac6542f589409ee5d833901,
+            0x2bb0d85f9daad9891a6ca76117c5912a19e2b959f03e59ac52ca61c6fc90bf32,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1c53d25cc30ee67b9ca5de92e574ae8e006378568883a35ec673078c5cffffa3,
+            0x15809370254e24135947fa4d4c9bb5366a809244c42e44d58ad51041ee0ac0a1,
+            0x1c7feb95c74dfad69a598a6569b5544b3138c293c78957c281e16178dd4d2ffc,
+            0x7160482689f59cfff868ce436b6135ce5b8d2e15aeddfad236cbbd174fceae6,
+            0x1e1716d8a49f0c324485bc3adc0f6a47ca4d7921e079fec272d79aa4d4f5036b,
+            0x2234e7ce1e40056deb62ede7b86c7f6482f7a253ce49aa78aa5c636a5f0f942a,
+            0x1134d89c4cc64ecb35202fc26b51689c745b812587ea60ae3e2636908b428a0e,
+            0x13c6c021a7904ddd8cbf3d0a7db61e044403812726e369bdb97ca31cd05142a4,
+            0x1c750f568881fa07bd9d06cf2c36356c5b824b71bf2060b763fb2895667b54af,
+            0x8170199a5b260bcb05638100428def3df9efdb5233441d14fc219c1bcfb0a7a,
+            0x1c0bf7af434ae20e594924e912515bbe260e21afd030f32eb7b0bf5cddbfb1e0,
+            0x1217414da7ee96629d16d8d7b906df0c15bb7bd5bfa5595974714aed8b3de96b,
+            0x19bcebdd18dd8cd827850f36a3f6849dc028bffcc10fd5864c0e37c50156964c,
+            0x67a8b7fce532eaaf198ef0fd1126b45f7d0aa8645e35b0331d7eefdc9c7b364,
+            0x2a92c17b2ba923484475d4bbf164caa1a8f16523b6a23b2dba260d7178530eae,
+            0x21bad2c773c7b349b2930be09781138a061c06f4f06fc38e71332b942ff2939f,
+            0x28d0786689c5a9bc8c7f2eb62f2fd0b21d776f3cd74725c0bc2aeec801048801,
+            0x222cc9d34695b0088ad166a5defde21377627fdd32b789575085363d6d5ef907,
+            0x2a54d465647c8ac5df86ec2bac782e9aa560977f7fb60b87ccf3cde01e40ac60,
+            0x13822f37a288f99d881dd1e6f6df9a8ffff482f84179be0924e7768d678a2a90,
+            0x1792175406aa3a9e7056233f4a70042e8226c943b7aba99805727ff7a9565071,
+            0x80bc46879014fd6b55a3e4d7698925b2a6710b7a5478a51292964f64de1d762,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x8aeebda8fdf99667caaa1b7f570e579375edf7fb6438af9b689bfc12e2c8ba3,
+            0x4b0ff272995a13fede7f4465a2f0ad2134efef55626e1824c08ed67ad981bd7,
+            0x63c3f451fb64fd5e95d21c8eab8fb98523a716c8f83e0f764b41a8e731daeae,
+            0x1928de8cc64d6cf21107045a7fcc4e0cba4706e68cfe779044583f2aaf6e885d,
+            0x1ef2ec873dca7eb1092b1835b74cdb403726d8fab6cbef50b231df9ab87ce725,
+            0xae02db0ea401b8a1c747f50e885d087eea93fb3037870bd36b1440d88995031,
+            0xcb7ba6cb4e056aeb2bde61a38521aeadd877772701fa572fc77915050db758b,
+            0x18e89e7317025644f8043265ce00d61382467265fa055598066b9b19b47653f6,
+            0x167a003eddaa7d10f96e547b66cc2bd9f2ca99d267e011fc69669f71d0b71fbb,
+            0x573cbb272daa570f35256fd3826e34c3e2f35f300adea697a306f914db7a584,
+            0x7fc9b6fdf58ee181a0141cff89e34513e7b4d61e01786c176dca84b9664eaa1,
+            0x2b3af74c7a1c0f396429f7e2d70e68b014b3a268d92897330cb9fdb1615674c6,
+            0x22580eb83a854a817e4277e8cf1a05f663d198c0b2b6458fa4cc45120b48883c,
+            0xc03a653e7e2061d62e638a0931b767a550722b318ebfc8bd924b22c8a009b40,
+            0x1f0f1d34546815b4410f8ddf67bec129e8ae08fe617497a70e85b80802e0557b,
+            0x1dc998a827321537333b22cdf7bcf0a5fd9a72cf9ed9d9e05ca82df4105c02f3,
+            0x21305fbed36a0b611ccd7139a48b7d36985041687c4b76483eef93d98e28debe,
+            0x19caf75550855e1b4d0e580444a73db1d86d507b72031d11925f33fbcf7e9f10,
+            0xfdea1098aa89298d72ddfdc5a47c8f9141955ff5a612b4c52ad3ea0461f3df7,
+            0x15e15542d8176284cb1b007f4655236b1f6795f045634ec815fbb5f842bb3c64,
+            0x24b51f84f0737f35c038d3801de3102fc32dbe223491c5367af7baca0e933482,
+            0x22231a672bfb82faf7b867475382c2fc174937b53ce765f4b6fb9737177a0ecb,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2020cec5cf125567b97756ed7174259dec539b4c40bba51bb64779221b4bca9d,
+            0x16b7ffb1a4af4b1dae8d82824c542e81b7380efebf3183208dd87f3368f2cd73,
+            0x29474e7fba2de80bedfa9f2f8bcaa38e6b154ba2da3454fd1436fd5bacaf2bf0,
+            0x29f55a4fd3170647fad71cf38c80c4cf8af0b1039acbd193732ff1bdcb049368,
+            0x2383d1015508e17fa9ff282c175ea5ed655f74bd5793bae4700459b5600cceed,
+            0xb21347d3f2e1ed0ed02262545a6aeb4209b1809b132f7f1036af67f9ecc114a,
+            0x1c3b4d79046a0030b73e4ed03746ef2898778560012f14b8c151f4166e0c9cfe,
+            0x2bbdcab9bc95ec1509f2aec2af8b117c34d8d8079173cc099e658c863088aad5,
+            0x32c3e39a7299f29c816d761fbc2abda28743e917547eea1eeaa75975b22b7cd,
+            0x2402ee3c6cfac01e1fb6551c34b1591e2b419d4ec69a0a9f1331cb546c31dfb1,
+            0xffbdb63b86161ab9648a7bb7e5c25d1541847070efa58c6240937eabd05acd,
+            0x2dd50132157285954cbfc6ec6f2e73b0d1218c699a07fb09984690d0fc8719bc,
+            0x116fcfd48ab31fc4b622f442566be132d688edf27d5337fd8afb80932769151c,
+            0x2c3c7ae7989bf23c86279e146798a3ecdd80898acbb6c2ec1f716eb7a91b017b,
+            0x2b7e60fcbeef2020823e799448da1cb0b866d776c8f74c031de2f5452010186c,
+            0x2b4a3e4a2db9c0cba63a23100fe5b9ad29b63e1e004b40a16fc00e20a83b7d0b,
+            0xd1527b252bfd505f375cf86b9fc95dc55fe1ca65dcf37409ec48da8b1207735,
+            0x1b0a396a158fa717511114766ffadeafc6cd82b72390aa908e1c5b496eaa2ed,
+            0x25b7181ae26411c1705d3adb389716b615f7c1bb3051ab9b9af4df76cca672a5,
+            0x1ce6e261ad4d6353538814957c5184ff343521f18ed1e8ac24dd380978f1b1ff,
+            0x2114b703153c05d8a458b86daacb8a1180a0e0e06313c69f0319885218d57254,
+            0xbba93da8fd45f0232aac88e242f83553799a5dd893a27697169d9ff3f628dbf,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x234620365d9e508d8b7a01a20c8b84cfe78734bdd7a480a6f3c0270be6c9e031,
+            0x18773402938384bdcf3ed2931a34af760d3401e10cca02854081209ca5bf9c71,
+            0x12f489609e827ee3dd6a53036f1f8fb80243c0ba7ac2720ed6997504f7f50d3e,
+            0x98af099212892af46e34cedbb21e88b9184ab2fccb8b8665a5324601d8c5909,
+            0x229c5955c3b6f26373956d4e3ddbce6c4c97dbd1382ed1c141c6c6b8cbcfa95f,
+            0x204c3dd1c157600ceb1cb55072ee278292a3003a7777febb080a33168f4fd9f6,
+            0xfe2cb3ac38a35f9d943e20a4cd370598e5c1b128edfb9cb877f2d424cba56a7,
+            0x2ae0af8492610bc178f36cf8887b6bc86f02da15b1dffb674706df0d9b62e9ee,
+            0x1ed1520997dc0364683540a32fe3e4368385d140b61b09672ff0e0bc2b398115,
+            0x25a0c2f522b7f27667a93c435c2bdc67d575da8a808bfdf2a43558b1eb12d9fd,
+            0x24d9bf46734bea252329879adfb65782fa5c6809a1520a3656d7f67331348d3e,
+            0x2b5277817669cc8df0c6b82feb1587ed59210f1414ae609f40def4c314d96e05,
+            0x724f33acc2c20822fe7f8d3d1f0ac39b2fa1025dc18dccaa4b258a2654e705b,
+            0x173f609ce483747dc7ead26598dd2227107af0521fcaac5efc2bdc3f48c07c99,
+            0xcf0b2b3f0ab40d718173aad7993e6213ee48804e3e563f0e531e2c937abdf9e,
+            0x17ce34f45aafd638238ac5846997636b58aa04d76b4b0bb46aa0cd078ae14f8d,
+            0xaf51c9e93fa5991104504bba90149228d64eece560e4c8bc2ccf1b943cfa761,
+            0x67a323bab4f3d03df325818a393ba5dfabd66405cf74e65e9dd52ee2d8fb197,
+            0xc3d3445a27d7a042fa2b4c5e2b5d03c1332d38bf26a781449325896df57ebaf,
+            0x1b5b3c710b37f195824a623712b2104d821ec8d859940bf0d27a3c50faa2e886,
+            0x16fbcb1c414031ba771845e6f67151fa983a4e32972031ef813e5f43ff3a8cb7,
+            0x2dbb1e93d3cdcff3ec3bb01debd9211951fab454e9a019fa4658a98f148cc8ff,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1f580786a86e622d9ea1bfd87c2d7a3a5f19f25105f0247f08b0e1ed89bd9dbb,
+            0xe2debc6417cbce9356f75fb55b7ef0347205dfb84b5b0de2c02f4e130453c16,
+            0x286b399e2ca189612a8d7dbbe938a61a273025779047f72ac5fc902847dfc0fd,
+            0x13144b54692e577de4598ca0783dde7af2a3a81cc5f0030b6c3bd92d3bf76dee,
+            0xaf7247e59389d0f9509b168845f46a72b4474d9ef66dd7e35f58450fdafe9ab,
+            0x18b3c1a2e20476cef58aeb4b8ec1820d80c28a5309d85f974fa62a19d262f5b9,
+            0x22d6ca5d958faf4940b74e3f50fe6eef888799302c7c99399331a9db0a9dde32,
+            0x28ebcdb416210c7ea0a9c44cdcc1763bfeed08267cc7a17a935f0e75dd6beb6b,
+            0x264522a85698bf1cd24c21e937f975faa4cbfb3534cdbaff55a89a17f947aedd,
+            0x170ca38dff04f179223dcbf96e15609225436e47f6aad10c21059b549b8ace87,
+            0x1980e8052c47daa2a7eceb160ba3cb93291acf7b84c3a1b83977766d78e7ca83,
+            0x2ef55e77f32308739f0831d0a98f7a6961e4822e53027d86a46aa9c9ad39b64a,
+            0x284ac526379b614a14c7ea0567aba7a459c269c32fd5af192240c11103a308c1,
+            0x1d5a978ae2de2380a458d23f2c2c1f7bc1791d4fbeb38b6c7a356b6f033e6dc9,
+            0x1fdd8752355eee4ecb1e8924b6541942da0c3f56e2f6c12e2ab75eebfcd1bd98,
+            0x274b47507df843c5fd2f4c823c4c22057b76336affc6631035f28e57f6a6d387,
+            0x2d46b1ea87a9f2ed6d8665f43aa1b4f6fe399bed08d9c77bd98e82350be3f379,
+            0x21e50a36ee2e6ed562fd73013bb2d34724b4ef34525c51931610076b81d49eca,
+            0x2f0a7fda21c19ae55233db913f1dd886bf71e9a0fe12f425d479f462f1cf4b06,
+            0x2dc7e716c1b4d182cdb078f38ee7148f0ff45a65f7f6360a66d6a29fe78172a4,
+            0xa24d8de1362fe9f8f23609dee59bbb4230f39236e6729ffdd95bedcf8f404dd,
+            0x2b1c087ce01523c9e0f97d81c67a77014e6f791a656f8edca33133fe9206bbbf,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x243ab6d29d356d147b7915a7a11f6ef485a0f3ef8d003ac239c0a926df820271,
+            0x10f0ea299cfd16da7c54cf4315a4bf993f6c8ed21e1f1b629258655bb569f3b4,
+            0x1057e97ac983fedfa508de5e9055c24629b7faa279f1e483a2927e621a45a16f,
+            0x13ecb96925a985173e792bcadd76dbf62657e8aee6e732e1fef9ceb1d86688be,
+            0xe6f9b2c64d9d97e1dcd59691a2944c4e610f2c9361a93284853c335ef448b93,
+            0xf5130dfaac7698c83247ab7d37384c6f4fdea4c423691dbc0466cc847d22240,
+            0x719c66d510d88d51a80f22c9ee06cab506ed395847532f0b0aef79e94ff5c37,
+            0x19fe7de3a53de3d0cbfbbe226c6d9799cac73c343bb7f652246d3314de2cd748,
+            0x1fb5113860f9c3717742da8ac8dc02d3d750447ae00236789ac400ab7b0a4a5a,
+            0x28637c9718b8c1053ac27e6ccb68a14daced5c24c3932460d23aa40fe066611f,
+            0x1049f5f885c559fe26f7d811c660cc9c6ffdb5103dd3217111b99808a28a10ca,
+            0x11ec2b02d176c222bc479f6fba4e427738b96aca1b7c3aa11db89b27ae10f0e3,
+            0x194af56781953f69e1b00c8040eae1bd59b4861dfbb3969d8161d77552233c16,
+            0xe752eda03c9dc685060d7d0625d4882ee9ccf2748929286db03f0a453d8c21c,
+            0x1440c319ce47daf613542b6085053ac22ace7246863f49df6488292e7bc72a2c,
+            0x10cd79d6139155e4208ddc71ac9646aeb4ac61a3eadfaf337ff97ed9109e0971,
+            0x2ef23590604b7f057aaa0583333f5766d25a43366d99ab87f9e290600b3f749,
+            0x2ef2c45fc47b175cb8c6e23c2cd7d26332ee65470759893d167772f18b799f97,
+            0x1e769953c74901e1cd39e0a9d7ea12db105fa2a0c3fe40cbe36965e11152482c,
+            0x2713a7060c9901b904ee4efd31cbe1bb0ac6efee3756d59392e8b594db57a617,
+            0x15b3bc638f4556ac765e5c60678b18ecc5a7aac5bcabef247da9cf116cf4249a,
+            0x1df44e6b43f51e3a708b7b6f7a05c67e7817d8fe6f36e357e266265e3183535d,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xda3ee283edb0e4256891ac9f4166ba14c17436c1ff8b6870f6dea7962f36c3c,
+            0x2eed5fb764a1fa6cd387d19322790c87a6b6a0b13f832f24f0fa54f36aadc0d5,
+            0xcb9fce02c3f2f82704477407a46991cab311db6e12f14e388c2a4b6093de75a,
+            0x2eeba73653edce41cef62722997e5df9d2f76d799cf112d29bb5706a6eadad08,
+            0x4318c41475504dce0c6bbd1e76fed829f7c8a71f1b02f45eedf5c3a71e63909,
+            0x2a094657153ecc1710c0583c1c3b7e7966e67057c8faedd408e505127a78605e,
+            0xf40aee2532a088cda6d1b13c48569022dea6023f85231a5544a9e6cc4edcce2,
+            0xd97ae723214277576911235bc25ed81063fcd21b59e6279275f11f57c054459,
+            0x82f1e5e8e5087c1aefd0f4fc62167bca4b73b8009e3a67e07cefaef1e475cee,
+            0x284f24d43d09bf31c1b59d84a8f2ffd8b1b903a2b88827fba8b02468ff57a971,
+            0x2b6538eb36991fc2429f8c38483f7d4ae728b7e105b4ac6bb449258eb89d3aa8,
+            0x82e7991093e92b53c575b9f51f8bb8d1d2a405bb94359544a3106e033b3f2a4,
+            0x288593b3cdd201b3f6ee7d9ff217e0badc9dde2bb6ca2a63359ceca59ed12d81,
+            0x2762b0c05f66a7d3a2c4b46f6da9e207194c32a91a15d0c8c7a8601874649bd0,
+            0x20851ccb233ef814435570f9435eaf7cd22baf2a89720b4b09d035dd42d0305,
+            0x1e17e4ac7afb5980903d9faaa355d2d4bc00f661cea435cd563a0c08d89f52d7,
+            0x11c64762f6e40528ef5f60c4905cd442e137348737ff11ef9fe186e85d88cc81,
+            0x135a7893f0df31bdb093e2f1936efde3bf6c80cded53bbf23842d5cfa739c10d,
+            0x670c942b19efe0e24ae667f88cf25482988d4fd289852b59c7400bb291fd22a,
+            0x2feb899196016827ef03dffaae29bd9f7df66f312f728ac0398d2be90a10c46d,
+            0x23bb8acfb809bdb5ed2b2306e5870465cd881e8517cf8d60b6eacb23993ec19d,
+            0xa2f66d3d56165a8357ad4ede386e8bd3d2c1a6a51ec4a928d02aa9cf2c94025,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2621d53d90f51a97a82455d448359f1f876b08ee77917e55298b4a4f7f2c80c3,
+            0x2e1713aa13a1ed2a7b57ece72d5599b6e239d5fa53866e407444290254f10515,
+            0xb0e3135b9a9bb3900a312bce8cbfaa6bf7176bf09974e9224d63f81eeb9cdde,
+            0x1b37ec261be552d7f9cacbdc0d0f22ebefd7c123cdcd54a0b493db30a65359fd,
+            0x100051565c2e4d9fed118b55fbef6f060608dfe4555e486a44e6971696042dd1,
+            0x298819bac61778b218142e4fb26533f0ab1f8f40c8d8070fe2f1d4170d93c58b,
+            0x2cbb90e508952c4b5ed26079f85f11f3bd728140e3b8cb91c1da9152c8a82560,
+            0x18e9de503cef0ae3f8901d7d9004170e4661e3792b464e8d7e1a7c7f8bb17091,
+            0x240a6c59aa72438261cb26070ca93ef35db217770a207e7cd9af3a4df60768af,
+            0x1c5c0274172befaeca201df876ee39b582fa848a0bc9454f6834b073c4ed7f73,
+            0x1dd2fcb227876523c5d075aeaad2df556ca76939be98462768f94940ca73028d,
+            0x1e0ebffd9567e4222b322bd16275af85e3a09c6db8f053a7027827bcfba8a0ce,
+            0x549e3fd2d8b4c8f5e1f6e5ada4adc3125ece6af1041e4f297d14cc80bd7a865,
+            0xa43a7e3ba83061b5379f61580f17fdb5068f57a18cf3d8f4431ef14a7fd8bbd,
+            0x2a8c713fa0bf5e002dbde544aff988ed8b347afe2b3641a08eab979bddd4d2c9,
+            0x307b423ad05a7c6c5a7feac041de1c236cf3db8e0da46368ab0a5113dcfd4d0,
+            0x1202dca5513d8609b3e911ffc3c1f8da4138f56287f2837bc1f8820469bd5839,
+            0xa109d2e7176796406f7fc25caf837f5c8d2306962baca62457fd49673b0e48d,
+            0x2158fe72a1672fc1b0aeb56bdeceff410de2a404c9f4d7a2e39c4cf0800264d3,
+            0x5e83a4f3ed30f863a148e66c1771a4634ed52e73dc1f9c35e479744dacb7c2e,
+            0x15146f0169d0dcb2e678a62443c00442cc342091a6d18a293a17882adaf6f146,
+            0xe27f3790482529695293a0defd1f44495f0adae815cdee0d3ce9f91512c1be5,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x216bf6d0d240ce8a0b430f85259b74084cf9f998823dbf13091042a32b4ea56a,
+            0x177227662dcc7ef354ef41fdb3f234ad93e7b70a6550e09be2c947ea462597b0,
+            0x1864bb94cc95e4e33b7673809909ee3a156c892cea648f047f2864db12278e4a,
+            0x2eba9c8ba56d6b800654a1e805d403bbaf22af7ff1aad92ab7cf420c129a2616,
+            0x24133306f286c04d2c2e174c0cce34c64c21f81e0df67c2593de5b422dc1eb20,
+            0xa1aeba71ae73f2846cbd57f9dda3c3e24b82291d22108a6a05a9c06e002b8d5,
+            0xd2d0af3b16bd738a5e01bb7af549f842a2a9f847063845d36d7424e1d2bfeac,
+            0x8e4a4d4fb97473cfd880c9285028c2883d6d08164ae7db26e6900b532e848d5,
+            0x2b2ae02b9d6d53220998acbb749c29f4476c9f2cd34b74c66e4f2c4abaab6520,
+            0x1fd0ca0b29e63609c2f6a3150ef62616a5fe2160266382030e48b29806298756,
+            0x11e7f1f91826d815902e2d9d79e027c44e78197f4450cbf14128d704c2dd46d7,
+            0x25ae141d31ff22370a99693adb350858a307e1fcfb60fe175a3279d99879e2dc,
+            0x13047c24823af0bdf17ccaeda371552e8834990abeb7ee7a9a646aa7bb9f4753,
+            0x266358e11e5081dc2944990007644733445e90ddab20cd50912c06cf1388e92a,
+            0x1247a2077d577a1ef6f0aefe8a7a2df21828f69c44bb89b6ae70fe9c3ee1af91,
+            0x2c338524f33f321e6f2e5e420edd47f14caca5bfdb7d3e065073b7b20d2814fc,
+            0x2ced7c9cfc6cb9727179bfeaf0ffc028a759aa44e97257f72c3467f9a0974c26,
+            0xe633982a359333b017dc5b4e683bfa274e74153f4f99d639e48de02fe239c9c,
+            0x2ea0bf1ed70f15fc196a395ac836e6a579d4923fd13be32b1416d351a05afaf6,
+            0x238f38e3b7a1d517e00c666c6670c099cd2bd7d8418c55facd6e511ea37c64e0,
+            0x2da765692bbfefabcaeb0dab3ee18797ec0032c1feb257983ce753a8f286a75a,
+            0x2cab9bc1d925ca3f6473d56a4c57ec136f52fcf02c9ee0e25ad07fe24dc281d1,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1210303a7705212e81f926482699c6d6b6aa13ba342f4576c873ce976435efe,
+            0x2e1fe52ad49d5b2cf4c43c7fd551fd05bb0cad132226c92b47e4bd24bde2852b,
+            0x16e6198e30d06c12d5535709100d47d0ab174704e4953b696bdcb8318c78d80f,
+            0x11087fc4daf5c010f9ea8b66e2f01e9032597965c811afb9ca9c7004e01a7eb8,
+            0x268cc3c909fbb19b2d737b0feb4aaafd6a2c0f0da4f6b391ead88673c187e8bd,
+            0x1200152bacfbb5e21565b19d0e6b47ae2714cf2bd9ae7038fe9132879d4b4688,
+            0x28db252e756f0ffa83fd845fa7d06ebaa301d37edf474a3b71f60539a630f59b,
+            0x184e95906f85e4e36b0b77e9d862fc27a56ec38c3178f8904851700c703c9db5,
+            0x14d66e67decb7a7f74926f2d5ec6497b965b4de941bddbd77371a3da470e5d96,
+            0x12a5b346904fd63b6c52f603e8a0c351d2284ec345e50518492ba935b07ba7b9,
+            0x269094e291d79246bb735d3c4a3df2ec9fb60a6b2f2340e63c91cc6d5dfb083b,
+            0x13929b4087a818cd5f602ee40afecbc30ad8ecb2b7677530094d09309808ece0,
+            0x14f878c52f6d09cc1b32f3ceb6f2459a5fd6668860b945b74457d819a6d18757,
+            0x2d91fc38379e50d8addc35fdfb88d27e100837e513f329afc4fc9cbc6fa0140a,
+            0x27b4dd2629f029c1ec11bb5f235252371947313993a0111e4f5cd14d47b505b8,
+            0xfcf71b4f58f1e845394800f32015de09e4107ce8a7bc786810e3cabb67d5d5e,
+            0xdb4f212a8d9f8036174d995937618dc8074ca32f5ca1bb537fbab6898dc679c,
+            0xfa6cd0c9a74c1973656d44ae21323b5d29ee26065906f0747bc3364d9fa8ff9,
+            0x2f5d612a89e3ff0157b8c05eb81cdb030b3aa80728ee5f2b484e027e9d7b587,
+            0x12bc2f8ea309d0aae7cf1fd15767dbe97c288b2d72e1ea489a383169d7e5cf07,
+            0x20e5a78984a6e437e16aafd2e43f119233b4bb35cfb628aebcca0ab3b102b4c5,
+            0x155ec9570cd3e503fc1c73fabd38c4ae24d31e5a38bc56c992b5817c9a58c18d,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x6a4859991b82108283b6091195b9244714a1997a97833c55c4e15c00747f5fa,
+            0x1a17c910b931d2fa7fbf8d41a1ce86a3496148f0a62cbb541a94310c3bb931d6,
+            0x13c27123ab15ac6f964022f94aefaa51f07391afc1095d7480acffec7e9cd6e1,
+            0x171c742bb0ca2a0282f5fd7628191e6ccaf3e32c38305a00f6593b4fd7527f9d,
+            0x16cf4b06cbdd21c5afd1ec787847f6956fc45cec34e95739af5ca67c27da7729,
+            0x11e51d4503b1aedbfe993befc9c8078b70d4db75556da4942846d22f217dc694,
+            0x8afd62076c7f946b4dd61967b32a6d09e794888c2702acfacead811a4fb4846,
+            0x4158c5f8f1b10efa12aab63546ffc8f065ade0bb494a31a58391c41f62fa841,
+            0x2f87837b6f5f2807659ec7565173893f91a4ac26b6c2e26e22d09a417309dd32,
+            0x7c728d2e8d95bc8842ddf8db4c76412aefae425c2774ebdba4317ea783345f5,
+            0x1455d8963d76e99083c896bf0f68f63db992b86a913f3b123a98889fd61a3b0d,
+            0x8b4bf22aa0e03b5f857a51c0e04b64565f59c87efb6859f8c7169dec09e2841,
+            0xed823b8b9d0f2e0b0c6aaaf3e5621308414d4be94ca3ccbc6c8aa0ce8e1b4b9,
+            0x1642b64b6547c137ea9d16920d1d4273ec49148369a457cd28f73cd9098ee6a2,
+            0xc9d91924e007af49ba20f16356373ae9cdd408bda9255583e41c1079c5c06ba,
+            0x2f1518b8bcf463362e1e927f733dedbe8817de8dff121a6a5527b33e70778ce5,
+            0x2114e089d96c5a4b64b2a6ad154fc6880bcad9eb3e8cd1d3ef980efda445281,
+            0x1abc25ed5c0fae93b3813bd8fda0cf773df41cced07a8ab762fb36b6564922f7,
+            0x2a5eddd216f0eadc4c50a2618f44a4dffd68ec6af8f7c0bce1a45894e6cbc010,
+            0x75e0d34b920790fbbd21418ecb62663464bcfa06db3581dbec635c8cf864ec9,
+            0x27b7beb430a31d0967dd287dea9fe9d0a16def46efb5518aba65fa025d82579b,
+            0x270bcb008b10d32d8b92753219422002494e30327ee71b2379b09d5a8e519b9a,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x26c4a3b0ff9b7f29c97c01b4fdc65d8ed1a07717da9b297d3d2a855fda54bee0,
+            0x2c6dfb52d9648d18f5ff9db4e213c6c94f2fb8151aeddd80a1cf95df1ab4862e,
+            0x2f7b7e795fd4f392f9810877d44523a6fd9ca59bf9f6f15502f4449b6fda8c85,
+            0x5722aaa2080e70ce91c67932130feac2c7ce93eff67e453c4a10c7923d8282b,
+            0x305247769dc2fc18b8f32cff8b1a08ebe60b0ce5179bc0fef9e41893007050db,
+            0x25c0007547961e0f368c5bd7bcd2335c7d35c1dcd4e04b169ea6676a2713ebf,
+            0xaf75b019c88a07fb24d01cbbb2ea86e75ce904560f06eaabd617cc627ab0cec,
+            0x4707e08232d55d9c5a37b7378d94cfd74933b1f483a6db89a7f7cc83d17a228,
+            0x1cb2bc2b494b4a6f9e502992730dcc6b94aada6d0a04a350087b3c9866c448cc,
+            0x292295bf6257bde873af036dd6932b623fea12bb31928bdfc800d1a6bdb7dc5f,
+            0x235b612e67013ebf3b74fa41157682a4169a17315695f54c73f290afc4574a3a,
+            0x1f412dc0da42db6a648c19e9e9119b157483bdbc7ad3936efb9dcb3e72e12114,
+            0x1402bde219d915bbc5f2958edd28a107072ce6cbf62346462754c21d6d5c9d16,
+            0x265eef82382e05522d8c113ab42ab0b09da4c166e107b2fd0cfa47aaee5f4756,
+            0x2b329efeaf663ff307ee9a682f883da59ea63242aacb620b61ef85c0110fde26,
+            0x6004617ad663a46e41d79103d1de6e8364d2fa582271da3e8b39c01adc8aee2,
+            0x1a10c1c3bdcd43ffa6ea4d58f408cd7d0e74a5ea38656a1b6fa88e2013025d55,
+            0x9c705ca1ee96783e0530b69117d99337fa1aaf04c5fd26e5309c0118f4bdb32,
+            0x978aa5435db1ee6896c737ba36d79120681758793e1a1d56718f6cde533dc5a,
+            0x1934fc546cb215a23bef42d7124ceff70e1d469081c2cca343a9ebbcef1ffa60,
+            0x1ea452043466f1c5d8f26fa48267014833214842b2d204fb253b97c9b3deed6a,
+            0x876bcc65ef05f89d90f3a96070a57d48d6a2a09de2aaba161fd6b9e80cd6ccb,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1c9f9742d4bbbb6c9dec076b4b9c7ebec120c5740e04e3c62d0c786af006a303,
+            0x18d9f9aee0ce3ea08d9164a5473ac114ae755c25b4f9566aee1c90d0a06e7029,
+            0x22476bc02607cc745322595d63b98eb70db2782762e548e023837c9fb06021ac,
+            0x22d83381d8f8800abdb2cced36e1c1d1c2f552594bfd9990abe06d0757eacae2,
+            0x16382c1df41e7d0a3a4958656a42e3f1f314b21ff463c5f959b51d1a6c40118c,
+            0x9e76815d09daa33a324f5d1d2404b3ee419b8e9b8833db59110c8d38f1373cf,
+            0x1b0d5ae4cde6fed3fdef9312557d22f7da589e71e8712ba7d2986b4bdda6206d,
+            0x2940f972586e13b6af08d49b838fbcdf24fb2a8a03f069ba612b0535ef94bf6e,
+            0x19edcab2af3f18321eacf5fc4f3a933383d26aa37b1e3049d3c36c11c25f60e5,
+            0x2deca7587b2175d50de4645fb5601b2599f5eb15ffdca763f0a24dd1dd4e735d,
+            0x1f816bee20400357b01555222cbab8bdb2b5a6ff8aadc19f911042092e96a26a,
+            0x2e950640b9cb8d14e70f81b06a9dbd4f5e01b81c448cedf2c2ea0b753d550e9e,
+            0x6797a59fb805d4ccc041166d71d077763b50b1fac685126c84402f02f565179,
+            0xad20de820c01db5e4c800abd15e3239b53a390d4a4a60348efc2dec244f81d8,
+            0x174a6b87cea8f7dc3a7aea08317bcde182eb2aa39c927d46bb9b0dcd70954da3,
+            0x2cdb547394356c92605c7b43aba9aeed3ec33a6ad515e55d8df4e678487186df,
+            0x2d001f86169c7feec284389e39745c1a64345f978bdefa862e8c73f7fe610d98,
+            0x2e40bd1d9e8c6b483f91eeea0e7f4f210aa786503d225e1fcf41166735737b44,
+            0x149aa5d1015e9f2c509e36e547de312d41fa3d5d4a8062b05aacda70ea3923ce,
+            0x284295e910196398945ebc9090400de8e5c509dd18ab3f4743a5eb521bda7d66,
+            0x1a1f21bdf16296101dbcba94854f7c4b05d206a1d08b8796e6830077ddf99070,
+            0x257f8d5e69aeed2ff7e194f398daf84d053941bfc75fea450fbca498389b2218,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x215c6089e0a9a6256c901e33e306ac9c415abc1875a49add4de6d0429fde8234,
+            0x2cbbb480fa68f33316f0d301f3cbcaa7eaea71e2784a0fabdccff2aeba9f718a,
+            0x143619ab2212d1911a586be0f6acb6b8381e47b5a3e34b91eed83ff54937a34d,
+            0x2385e3c9ae95a0459e974d29cf0e35f283144cb2ba13aa914b4e17ae5c988557,
+            0x2bbe7e909fde4390a7cd944e0f309103447e91f3fad40b752733063fcea07054,
+            0x24303758e4ea42a45a0419d88e426c95c68ca5811974c5b0c3abadd9c29d2b5,
+            0x260bb40c5f1b22fb87dedda1706c608f78fde0e5b9735ad1fde63459244d4674,
+            0x21f27302db4f5b28fe8845806f38ff1f0a04e28434a3e0043bcb57e65f6f75fc,
+            0x16c95bed15dfc954a1a4ba25327ee14c5b0dcf76fd8dcc529027230e9c4a0d97,
+            0x20996392773e30c8e64d792b010907d8848f28f691e8b2de13ea8226baea34d8,
+            0xe20275c14333df445b794b515bd07b8bf90bd8035cf43cfd845976af63519a0,
+            0x16422819af615c4a947afa3e272275b5d5bcd75d494042bdc81d84cec30f7f1a,
+            0x16329eed1887886307c5a94706efe31795136ede8e9511bc42c77ffbdf22276f,
+            0x1e9f59aa3535d598e32de9a4a370c6f4e5f8e6090a9efb2181560fea28519269,
+            0x303df7dae20bb862e852232d75fb4f6468ab85a1d36472c3dcf567cbb233dbe,
+            0x103c4294a67544648daeda2ec0a2bf81ec40e4c01d75d35be0a04fec32907b03,
+            0xd9fb810fe920a795ae2c3dc1b9bac0ec25aa7df2e3628241ace688bbf78fa7a,
+            0x235f2eded2c0024a03e1f050c1a32820b3c33f03445a830bd06bedc4654bd320,
+            0x27fe4a10ee48d2ced432a47a2a6dd4083e4fdb9d9cf44ce4889b9c7d581ba529,
+            0x5c97d4fec77f242636ebf0933f378eeb74467faab3477d6b8230966db1e9e56,
+            0x17b0b7d570dc76bdbf3cf5d3def37e0a005c9b4e0b39803490c012b453ed60b7,
+            0x4013b73ca35eb02837465c016ae8bd13994c335fa05de42835003ac53ce46c1,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x4ed491d2af18388da53711df4d29318125bdaec68f9134c1b3f5e3bd7b831b9,
+            0x16e1f43d878d2cfc40e58b5e77386d360cd3937828d8630ac2e736de89b0d118,
+            0x45f7d97cd4d95f8e4e65c183869d4c15d354db95e5334ea1a5f3a0c34ad3bbb,
+            0x242af80de0ae9607f5aad4250667e1cd450995afaa5293ceb1f184cc97ef25e2,
+            0x2d149e6319f8dfea1e2c1893f5afd8325013eb9fe57e79b3655d626e748d931d,
+            0x78a606fb0fae37d1e1a6fe99977001472cb272a670901f0da8e5126b3ef0899,
+            0x1548a537c3810897af4f919f5e48b512eb727f3c47c53cd3ffcd5e3a559640df,
+            0x1e3e9d29194598291365b7b7deff55f05a137b343cdb74c00037051b96cdc202,
+            0x2ae46fd5b2a10a6908761a50c2f71e5f944abf11b568e0a070fb4a4cde0e9d74,
+            0x1d5dbbfd82c2f3704059a5e3bf3db7b7f4dcfe27bde2786ea26063cd0921cd0a,
+            0x221089932e5ffb0d72b8d896bb8243ce3d6adebcf7bae4ee56967e2b34a63946,
+            0x2a5ba9e0c62d377751d13b5fcf5d8e7ba1087e74cf277212405440b3a8fa55ab,
+            0x1ed96d07a94876906d0828524563f987414b2a45b4891092481659e053c7294c,
+            0x1619ca922cd3654f97cba5f102327d7d6a0695bb3af22e94e33607f545c24641,
+            0x93f881501a90112f530fd9185176fd85475f3427ec133cb5bccc6f277a16adb,
+            0x2417824b008ac5a7e819ea42ac2e1bf2becb58661528bdc20ef63cea2e355a7d,
+            0x1efb091123948573d0c0e6b95a628a617567971c5807c5d3e08bf566a3dc874a,
+            0x1f2fc25f030934b6115600b1453820c4c70f8b454da461bc03cf773d033c0fe4,
+            0x263a77c0aa2edd316947006fbbf4b3cebf660809da89166c7041c52169764b61,
+            0x15d37f58a9589edadb9923907f947842ef6fb4b61251f8373b973dd422a1b940,
+            0x76d6d847fcb997548c2b12beaa6a39876569f53e881ce861d85d9c41ce40820,
+            0x1e220162696cbe1575cc2f4dd2fed5117c116d52a9965b434ddd7913272c5c6,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x12eedc290453cd77c01e543e57d4d7ae0f6e7a76b576e880e852ea8b8e98bdc6,
+            0xbdc3d78a5d0f3a92fd690b227d948ae6ca94d4342ece41593514efad7086439,
+            0x2207296649856f043e2d7158f68f5b758b354cd022cfc04e811e1bbb4d3468d0,
+            0x21430ade4c0144f819a79b2b6f849a968fb758f76a30f3e20b5f7999110f35f9,
+            0x1a70bdca6f11701536dbe4d9926b6bea87a08f6f0efa754b1132dd4e123f7c0b,
+            0x285d8e90abc1496915dfdb9e2a4c4d8c42126a3f15f4bcc1d8dc721fd813fae,
+            0xe57676068d4b4e3a856f2cb7b22531f5e51bf1c6f09e35a645aa8953bc45ede,
+            0x1053abdbffbfcdaabe5b794ee6bef5dfa367d198e7644962afc90f37590c025e,
+            0x11660d7d44db731012b02f55c5a19e4b1a10041e0085aff26ff088797f54a057,
+            0x2bbee9db0a412ba731979594cea45cdea2a1ea40c90bea1f3ace29d4df767920,
+            0x119c59a67e312da970edca383f4e1cc1752e7fec6bde83e437acd6136e4dd63c,
+            0x2a861198a0bdb354abc6d273b4f13854cd31d745e627c21ea107620242a8d233,
+            0x1a8ac82f57894230abc7f3d010003d5914170d820095f3bbd01e977142351f12,
+            0x3548b5e02d4f1f988144421ba37cf75fa0963b14c2ac961ac494828c1e655d0,
+            0x2cfe3bafce8aea2bcb3c145ae29dedeb9ec7123b4f3295bfa5d05681c366709,
+            0x274f38fbc034b51b94982df30832c69961d65637f808541c50a395c8e0dcd32f,
+            0x1154c2e042ce659dfe447ef58e09e4514726945cc5abde427500fc5411a8a365,
+            0x2b6203e305e19b7730ed2731f994303777fc1c2a52422d929ba6488c2c164c3,
+            0x51917b944afa399ea1e621ee2ad62ea629a35d29387be06c077b79b9569e2aa,
+            0x7cf3b4f4f274f711a4bba652eae5fcf6c950fcdaf92e77c118dddfb738d9ba7,
+            0x1184568d03c28368300bf5724d6958355470e629221f5221676f69e22b717352,
+            0x1857839c2d8b0d6d08c21279cb8a2cfe6138df1eaf6649888cf540965ab3c168,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x26518ee75c590976af8e213b42e5988a7185438e593c9635a28ee89c60bac357,
+            0x23645455ddb929ee2b596cabbd5f40df59e219b4efd8c1fcd4fcb67ae42bb5b9,
+            0x16d0126c2df72ad69f419c74741165bf6e9f6c2abbe95a022efc903b62d25ebd,
+            0x195050200adcbdb5e72bd63ed3e1d4d3d54e4cffe5a5fecd932e9c5684021dde,
+            0x23c26b8f07749697bf6982f2e715c91f541b173fa0a3e8dfcb6bca01499134ce,
+            0xffacbd7cec2233ce5a4b911dbcc61f87d759ba6e46780179e75f91ae5a720e9,
+            0x231a2beac360f4917f433d7ea9eaf185e270778902e6e090ee5e207fbd0575a3,
+            0x208cee18da850a2625d1500f835a216ecce022c8b08235c387b8cb1865ed8a59,
+            0x2df938f310cedf2df8530cc3ea5ef1254ed966674bc08ab3f1ea148057b6c9,
+            0x5cc71f44f496cfe8d69850022a141852f7dac001fdecce67de6265b69dde3ef,
+            0x1e04cf375796f4714e6b51552107036d16f71fd0b77e357b61a2014449ef845b,
+            0x177060e5eea7e3b800aee099735b074d3bee92ac18918a1be042ad000f861c17,
+            0x27f7183ac04ef3b5307e450873f5a4cbd1ff709677de1a3de89476a7562127fa,
+            0x272c4143f3f48b711d9e78964d27fde0614c2844861b23c1ba5ef6321fe64877,
+            0x17c29df44b208e4d5b70aa3b57c92d0c65e0c4d780793000ab5b3ce79e90ac48,
+            0x8426585ef062b24b9c4de439e0dba038e9d539a54ae8c4fa6554924c0f6b03,
+            0xafaddc71d356bb01e344c03336f6c97fcf6c0ed9822cff5114e85b7fb18f3c3,
+            0x27de3d9113a625f578e74566a25e54bb1d311364887d455699d89e65379e11e5,
+            0xe8ae5a0eca1465645dc6b31f66d8356d6fcf434daf1cfba59ab08a91417e81d,
+            0x1e41011401e99e5e548f813eb6c091f1ed7d03c1005affd1984e0149a2e59836,
+            0x2fdde0adafb47ce46bd4e5d31bb8e840e8b2edded884c6c0522a0a323b078403,
+            0x6d047a14724da146ae1314d38a559303e53808f6ffa90af4f2db3c52d2946b2,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x27e98739b0e44313ce32f7c5b552a0814abeb32da96cd82de769b4d0f5c94c25,
+            0x96c0e16b0dbf141e6bcfdbc0e2f49d013f35cac3e4235db39c5cb35f96a5e83,
+            0xa5a4adbd74977d24c7cee2d6421ee7cf5e0534388e5f9e09b811a0544d1ee3,
+            0x17939f4a2fe98de1c4f37b079b35e28f9fd918492317fe59311ee844fc3e773,
+            0x2fad1489f14f53e5380db86b119e1fc4ab02fa84ec4b0f283bc28cde6b738aa1,
+            0x2765769537137039a892f1c38aeb083dc07de1b728a580fff63f9bcaaf455bc1,
+            0x1e31bc0fe231bae89cdd1ee8c3df3d8b06da2f88825e635df9bc7ad5c128f2da,
+            0x1e516c3b9ae36f836ab9824f1c10b86a622b2f49f081cd7a50ae5192d296eabd,
+            0x47cc90a4be717883e0189e898fa7d9f1dc998f91d255553a394b6b798326043,
+            0x1c56d70a6472d972e35698eacd7ba8d40c9fe9fc9b04927d06404ae10ba35f53,
+            0x205c05088541f74e95a23f5c7ee1d9913978e98fa759b621d0d2e3b0d57c5807,
+            0x16874f1578735735add0540440cb042a966b8ddf3e51b4d812c673776bbc47c9,
+            0x240f602afd2d97888bf4b64b23d6e44cec734a2746cf4580c430f72e46feb453,
+            0x1abe8b11e0bfa0a5829568b66934e5da83b778ecfa452ee2a6b7140e191e7b98,
+            0xc276760c90c65c9f228140185e42f3a7806840c8825bce562d0766a06dacddc,
+            0xab7dd18d0804d394424f2b9e37439eb4bf3324198c44e7acc78d2e595d7dddf,
+            0x74abe46b34d1daba12f1e78e3cfbe69a30dcc2b090897c040564f023ef7b9e8,
+            0x2f240ffafdd27616a2eac36181dd8e9d9ff82f62b54537c48d497609858280bd,
+            0x1009c918f84e7180e4864c0e20912026c62699bd562ee5bb24a00fd69a30332e,
+            0x9e29496159b70b34f9707a8de9ec2cad82369b2d16885e98bada319d69e4512,
+            0x21afdfa37d1b9218daef0b7abbb26e4d623f8ee412934fe8ebca9d9fcc2c6672,
+            0x1ba7bae9ba2546ab2fa904877151066a9c5cdd44107d8aa829ba8ea0610b18b3,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2048256f57c9c8c24337bbfbd097c2627dcc0c2ae00ff560c3e82d32a55a4d4a,
+            0x882758c559a9a38ed60d1113da22600ac3de62a8cc88e904342dfbd81f58058,
+            0x54f6c1185a58025ca382d00657cea60c9667682c060fb5f2fad74f3d070d5a8,
+            0x18da33071f0ebc4b2962d4b061144009608aae89e8285a326c0ba8eb0c370153,
+            0x27102a58751c96a0afc1846801937ece25f59ff76675758d5388cce403ab4af3,
+            0x234028cc85b8345eda398be9f3fefbd6d59973ded29c6ee52fca866a07b1f7a8,
+            0xc3762675631dd7b529256732681b5b48ba5fad34019a65b1ef191b9211bbcc5,
+            0xdb907e69984fa1f803f9f19d603391ec580bb3dc8357d170e3d4dbd9c107e6e,
+            0x1c5a1126b94c62d06a2b2ec580e5e4a165deaa7cd1bfb0872440de9606900dfe,
+            0x2e3aa301ead4fdcb606e9aee72ba7a2cb90ddfd72162ad9478e94699f776f6c6,
+            0x279d20b786fb6a7ac5d4fc5d78faf9c47a3090bd561b2fa430c5db64a552396,
+            0xa951ccbe5d7d13404cce3fe60751477ce1088102dfa3732e323d055cf38340d,
+            0x26a8d4b18704a5aa8e41ea652ce2f60e7975c0b7eb478abc55ba0ccbaf8149e9,
+            0x787247335760468918257e7dbb38f97dfadb60256f603d51104f62e4e662953,
+            0xb0a7b524cb7c7519436167aeb4b5b185d16c110c2b36f162abfca872b3f489b,
+            0x1efceec837f27a592824f15644f3889165bb1bc56d5566179a951333b255398,
+            0x2ffa74a07ef6aa2579a1f68f1de64b58eec51380c7dce9b8966c789b4777fe01,
+            0x304582e03ea48dbf3043bbaf216ea5970d49e23aeae55b774ffc615ae80d1be3,
+            0x1fede6f02a4595564cd768fd400cb5eaa28b2ba191240030e1d757d6a019537d,
+            0x1e33187373750a7f284427194876c8ff05ee7aa94d5b3514f6083990d4ad0561,
+            0x1c5a22361e914dfae231d634ad2c502b20e84feda4d506a1b7955128e9b24bb7,
+            0x1310273c02734e60e3b1f4c7607a48961c3ab97ed9690c2b26c38e36cf56361b,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2eace5036bbf892b106d6ad25bf3acdc3c94834e60cd380a1815cc4620e79dcc,
+            0x2cf399b03624f2fe3ddbf48c2fa326e788f3b6e4b4469ef0d3e6c0cc241b7ba9,
+            0x22d41054830f4b29ce6882b49839e9942ae7a1ae84b6d366a98f42f7baf9e188,
+            0x15ae7d83075b047fd367659fb588806f23b6be3b4690cfc3ca92c61e71f5c765,
+            0x2825fd5f33d362703d2fc902578dab75ca7076ecbbf7cc916d4ed3dc43b3a0e6,
+            0x12d12504ba541ca2b28129a673acf96d4f246e340574ffcdf24dbad99bd572cd,
+            0x29653490a05368030d3690d4497e930fd4370b0c89d5996b75b420ec803189d6,
+            0x21188ecfc9b8a96b6dcf99b67bdf3866314046229ec07c8767cc26ac6d2bc169,
+            0x4ca521fed16e4c8271f4101514280093d189d84bb4129d2e54bbb1508b72908,
+            0x27d867a046afbb0c3cd2eebda088e476752b08c462fa1a91effa16d22403e4a8,
+            0x1e754e7744482f6d43e6990f631a35d9564f0485a116ab971d7c1ba0fc6ad629,
+            0x1dff12c679a235887e6c896304b46e3833f216398da1338be75ddfba2d77bcec,
+            0x1029ffd3ca881002e4f00872e7af3299d9ae979a0d9e0236d8bc4a6dc36dac09,
+            0x2099a9d66b52f0ff88a110bf3247146dc2a39777bc01bae0ca27f3b3ba3f1f5b,
+            0x212ed3e424ee90af48f2dfc1828a78e4c50fab366f51ce3fa716164c89787e85,
+            0x3fe48adcb5e56246e6cc8968bc0a62eba94984a1472b01f5a4475628aa38cca,
+            0x2d726e790f68ce53fee0841e1a8b8fe36b8a756b3a0444ea08af369ab6ff809e,
+            0x168de57f2f5a7a31b7b9c96ccb8fb7b33fc545cc19452cc7a5342b70cff74ba8,
+            0x1bcf256686de35f672d4e52cee81f74c552e08099b3ecb8c8e8348cd3f36f2e5,
+            0x6f7d1f39f8bc8fa314984d88fe0283e64b452e260d4745f9514a012c31cc946,
+            0x267158ac0a27dd2e94f422285ee979565877516c414630ca5911efee1a8e311,
+            0xc4d16ebd4cb046bf8e0e7fe3218a3f23551c79e8388e65b1c7a557e2034f957,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x22e7f291772140723c33a8ebfe15373f0468e295d1b724f6e94d522abfd5f535,
+            0x2c5cfb9974cb2299069f8e21329d54e5ec4f6b837f1727daf66a21af858b56a8,
+            0x27a1b5dc716f8f70f18e6eef36ca15ba5df295f9b6023d0c8b860ff0948ae9cd,
+            0x1510814b5e9ea61f47e924bf9b21496b391e2efd97554b057bd9d6905eaf28f9,
+            0x21ce0a7da429a54515927fcc1791f25c658766ce48934cc1937dea204f64996e,
+            0x2e2617468ade83de353a5a7cf3ffb4aadad12b05bcb65cd570c7200059956b87,
+            0x284052fe9e822298ea89afab784617fd413448012b8a713d8b8db7db9d111f,
+            0x2f1299ecb664233c145d53e9ac62772c9f917ef5fd354f595fd151a739610f2,
+            0x2a89d81e36b4e71698dd2968fe86c8bf4acbeaec381985f3a5e67a5ea1318d1f,
+            0x1bd908426f44f80f02514742b4860a72c00ae90ded7aa472090e5c1062c3e764,
+            0x1a43e9dac11dc11ac20f3cf1edc5eb8a25dab4389d675d9322237a05cfc6b95c,
+            0x2692699c30d2cfceb23d589df2a5aed5a8219ba6c436d0d920033b2254ca6a28,
+            0x28857f7da86b117cefcc105f4e504eff5f11dc71e1e3718d7ab027ef6383aba9,
+            0xdb4febade50738b1ab87405bfd46d20cbd4a222a1f1f8627752cf1b9a76c6e3,
+            0x18724360a40cc50d7046eab1f3ccd6ded2edafc5cb4cbffdb9bf734c1dff33a1,
+            0x2187d4118b5f752636e205eb4982247b95dab037310349ddde471c782e60fb2d,
+            0x709ba7ecd374680134ef58e9403582339e3a55166f7f3943f281c57a275e588,
+            0x202fd3f05d2bd8e2dbcf6e44d3ee0db6cf72ed53b00b7f0785605d89d139ce0,
+            0x9a760b6af4b4eed3ab69ecb0498a75fc71b815b6bde4a569d39b6086096898d,
+            0x2218e6abd4e31c4e2c4e21dfc8a266e946c599fe44b9813f282ef3ac6d24ece1,
+            0x3fce74af211c178898a2bbbde84568bc09b8c2228481f7ad87e7b1dcde6bf8b,
+            0x2201d6ae9382dc02c5345b141db249c120b288860ec8f99d504eabe8e7f23573,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x17b549a98305619700b722d1392e3f22f3515c947ca97bde2cd79a761dd9a7c,
+            0x1321911b787b6c29f58b50a53d66c5f436848103f333aaeba5589e43db1208e0,
+            0x9ba5765272979602f4c59c7d7ce1516f48137e61938e30460d262b22efe1fe2,
+            0x1705b7f07f5aabec51703713714785de6f86c899d97f3d89ab53459801ad77e6,
+            0x18ac4517cd9c3d9b13dd398e5ce614022042b3ccc82fc8bbabeae938af1e896a,
+            0x2d2dcf4a755c21bb49b4028fb3dd8bfb641a08f00d045285c0ca64180234a26f,
+            0x2420e764bc7ba63b706b6b39a10c092ade7b1873fc1ae1bcecb8374934383116,
+            0x10eaafb36f88f19fdaa78ae39af01dd9dd5c3126eb87df41aa55ac344e440b2c,
+            0x1adb582c6692385a8cefd33e6ed3c7f23a3252dbf4ce0ea80b2cb5d957844a53,
+            0x17b3f1bf0717764c2f01570716b665e2ab308ec61b511dd3e65d6bfca9030a1b,
+            0x27953c6c48de10d405e8225bbcc73ea9fbfdfcccaf0a3eda80ce4d7e5ec27214,
+            0x15e794fec75f7c4f7e63dec570cffae247d8bbb1d0114270d44bd7ddb5ab3c80,
+            0x40632b4454c59b282560f814afb01e9f60c4f24013cb1a8d450f2e23bce9d5f,
+            0x1e9c0e04247d8e1f43b71350d991413eefb67c273a3ada726e15d81737717a6a,
+            0x2f8dc731a366ddd2b76c0bd1418bc03b207d7065556f4796cb325b8dd1db30e,
+            0x24463e539fa612ef3028038bdadfcdade3c8475e0637fa4b1dd3ce10b0aacbbc,
+            0x28762b41feb35e6509ad33ea77bd88983e6fa85ca2f6738a1a1653d3bf54d52,
+            0x247c44be326d67af902022444d80ea90776936a81592baa6702002b27d6b0737,
+            0xa8ffb6524fac8a3820378ee0c9adb2345fea97112c2bdb9a57dd3b04be7f63f,
+            0x264d334f14801fe44177ccf924d22e91f3d98e1cdf5c6388b735d60fa32c7000,
+            0x1a96bd9bfc5432ea29a24ae3c46b126769d2d8f05cca70dbab11711117f2ed6f,
+            0x16542734a0c4983f8b8203a8e67f1c2290f7de67a02b2e4285bf5d1c3049eb14,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x46208656464d4ae0a420f4aebf63b775d2974ee08535ef11014d4400cca822c,
+            0x15f6a9ef383741e16882272bbeb9ab135f295272ad7e45a26e063aaf656094ab,
+            0x40a8985a8323dd3b2ad3c285159f2f158db48b9fdef72c8c859a462d7f117f9,
+            0xb9b4c7ded97f1a7fbb1dbccb8fad09ada8183cfedb790e2f11c77074634a80e,
+            0x10700446bc61701c9dd17bc4354ad727247a997ec9e541ee42d9d0d2acc376e4,
+            0x98a404fdb1c37a38842752a31bb1d2bb5112fb422bab40a1b546b97c719d923,
+            0x1843b850d5cef8871bfd1e31525996416a8550b748cc9fd13fe42aa1f7193bf6,
+            0x279c28f81499a1d819fb67132c84220d124b668cc206dbdccefe9478358a97e,
+            0x1d6fa109f9d33d9e144c5b25fd5b2f189273545fdadf88af3c4a7ef1f7189e35,
+            0x1e89c2383d920c8a80837bcaabc2ae9060bba4a520fc7eaa7fa5dd3dfc18d5ec,
+            0x180670edb0cc070ca05eaa724cafb4ed020561150ba343ac5877fd8585edcdb,
+            0x44a14d1f731de503ecf2a6438ed17ff8a552a01d9fb66a36fbd08aee8a27a6b,
+            0x1391644b83aba3c7c86a81f240efb147fe4c1c53e08ae3d3b0aa02fc1033b02,
+            0x1a9373fa92867334ec17aedf833ef19fe6f67a68d031f7a088091730b2d5bc91,
+            0x1c5c46a6852eefafee39b8f31935c3325f450000caddbb35538f8dfa02b3feb,
+            0x185b3aa7a434a7225057c6bcc8e68180dd404e58e3f0a8733fe64a0c1d534102,
+            0xb562eca994127ec94b90e76255955551cc1d6e8412918f9aaed138e19cb903d,
+            0x1ab2db0ae479301dee234d231988298fd46bdcf3d1ad8cc11389ee780c0af1f4,
+            0x2ec8c3feb4e03afb11402d5929fbc332b5bb7109fe326a5af8613dabe9a6a94,
+            0x4dc3fb12329b17a70b760ae75d620133889283cbf88035505ffc97ce4641bc9,
+            0x1297d2ec92df98f1ac1a318dc100557237dd9c4a96685f1d58d0fb61ffc4c094,
+            0xa84c5d2f491a40654df4992df98f681f157bc9fb4a0a6ac1aad9e0e994cddf9,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1be6b03ffb55eaa0fcfa4ec007ad655c776ddcd62e7184dde03b1c90b1af001,
+            0x2910d31a4ab9e0aca79eddd220c56905bcaa2dbd29b6d7bf389a4c50666219a3,
+            0x2839abe3d67b01e69ced2af2ca20db9b2bf359230d7bf3c6bbb79232624a57f4,
+            0x2d0c50609fd4832ac428bc6ed4606dc5e5cc48e9965c600c81325a8d4ef87ae7,
+            0xa9180406884b203bb35bafbcf2f4abd0ffe90aa9e3e1a82ceaff556d2e22dcb,
+            0xd5e3761475ba3a3d55133eb45a945042ee26b747e3eb42a077749f4f3676e4d,
+            0x811919e5bf03ee004979e2164e244f1ec510eaf5fe6e5107e5e6f4bd123f77b,
+            0x23d92b35fed4accbdc074695f6d1393c5c2bf6f2167fe239b2029d56579405b0,
+            0x100576c563ad00ccd2b07afd817dd2f8dba2535b5c38de7bafd08691b04933e7,
+            0x24cd184d143196317be3f594f8ea091f3442abcf3647c50be545e510994dd90a,
+            0x128748993a58cefd65bafc84f486488896bcc8088006a3f7afacc28afd6fa380,
+            0x126980393d9f697cfeca3c8cf5aa466cf7699c7b24ed1fe2bcdcb3d98e01eda,
+            0x3d53b1b0659c95cef35a515696e13d67643790564a80ee3fbe3c5b2ff7dbb69,
+            0xb1cbc1218a01ccaf22711fcaff805b05bffc45d21458e41527f06dbf423fb10,
+            0x2d2b944d4f9dfd80472bab4f0ce520fca635f74c8b9f1e1ca0fd52ec8af49ee0,
+            0x286ea70600778faee3383939faead69a24821fb400920778c7529a1b1c90f54e,
+            0x1238e08378044550a836bcfb7129f0f0d6253eba654e96035de06513f6ee738d,
+            0x20d38b283f1f0abbbd99af81d226cc6503ad86ea1a2ea8e9419ef15a74f8ad57,
+            0x25f5d1c94a4423c994f81d1f5726c8133c5d2419fa58f226a94c09b61815c2cf,
+            0x1ba4948c72f33685df0f9eb2f6678fa6bdde0ee261faab0a63917fdc30f0973c,
+            0x2a306087a9453e96d0007ac70600c3f1e08b4fb5cef04232b64fe8c0598674cf,
+            0x9e528bcade9d9b1e99ed53a6ca87dd8dc46140d57d0699a8f120e0c77af65bd,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2a779727d7ab06dbd553a840294589296f3aabb6a314afb5b083f650e39db967,
+            0x11aa7127dce97c6f4beee5dbdde1d5c7de812e27376e249f41a52171c108324c,
+            0x2e6df565cac73a4a04c2cb1fe541d9e3df002054622c790a6c8c778e484da06b,
+            0x224c4dec007432ecea73e548cabf60846d0e6b72ed2f4c907dd9e03dcb381e92,
+            0x2095194e2ecab4e0e731ec6e1cbb0aefb3bf646f6e6c804be5971167ebc58f76,
+            0x2ef057063be57233d59137db76c7252f1d2cbf5f3c4c6c8ccb22203c98d6e2c7,
+            0x15185ba1b9b8060768c5af0f70636dc62fc29ca5100d76fd4f9c4767e8f87fb4,
+            0x1ba274d2184bfef2d0be986fc2d41617f43d29a30b328b6ce3fe41a406669532,
+            0x27528f734c66543901cb1afad7414892ae14cdb75ed5fc59fedcfaa399fe74c0,
+            0x1185229ce9c183d7dce8a64999623a469392ca6d2e4f72bc2b6c4772a6b04896,
+            0xb36b20c33f83d20c1c49c00c65ba85deee8345f8563df448993a99bebbef6d6,
+            0x1ee843386b3aa0c38471fe7c60b638218ef9266b542a9b1526deb8dc9aa3c559,
+            0x107972f77e0382e5d3cff5b6858e85fe6ca29cfe95b60159a9dba68cf55ea21,
+            0x2fc46021b9841db9dd3cde3ce58785eb5f5b9600c8d5c0f4086130cbfb261f5c,
+            0x22b8c705b7b675b691343c7f19f68e23745e55aedf5eb931c37bd89563f14a8f,
+            0x1db0aae1de8a581770c890de5e66c763301cc6d522ae042db366f330e87013cf,
+            0x2b17c19b2ff64a3d9a5bd5cd0d4a21cae7b7d7c899228050f593b2da46652d3,
+            0x1e3a4c2c9686927495d6cc3c6e90b519deff0b55ee3124d69ce5161c91119baa,
+            0x384603dcc8e7748739a4f85462cee5fbc25345e02db231f40e50a851758452d,
+            0xe842866ee1599809910ecde3d7ca9f1d867f96459985ba119b51066866224aa,
+            0x19c09d8567e90a622516fd1973ce27ad5fcb66aba8b248d06de9ea306a6fb2c0,
+            0x134176d3a40f1bcad9f536bb92b8aeb9a4c3d424b14cdec9beed77bffbe754cd,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1918c06693a26c41f0025c99e93ab46213ddac227215fbe5d1972dcdb6265afa,
+            0x2c2d3ad00fcce75da6a5f510d5952918f446016a8fb4b1dc41af9321803468f2,
+            0x18ff4731631733dd9f048503b481b9b7abd2ad7dde5a002d8e0ffc425f574c09,
+            0xd14a3159cb458b4c5d65765b15c56653be2cde202d8b285f5c2cac7e01d57eb,
+            0xaf7d40dbf6a9d2e138095f1499e6505c326422282f1bd30fe98d19590298e96,
+            0x1f728b62200f84d56fd916f1033868066c5ff9eaf81726ac8f43f08f311bd806,
+            0x2f1509a804a1e612847578f49ef3d4cf0067adf3c3575dbab3632f6e6e3dd5c,
+            0x41c67e015b3770721ce4b96ae6219e6813ccffb152dbfa13fd37d25ba812f06,
+            0xc336783fc41679f67e808e2eed1be9cda3fcee2b04394812df95f9febd467a2,
+            0x1e34badeb3d92a88aa84decc7b70ea344c8852c9a17d3e0dcfcfd49f9d103548,
+            0x2539fed64ca5f8bbd4016404921a292c7652ee3a7fba314d675e02ef29f01095,
+            0xa83942d60d14f46c3c9cdaa90390faccc4fcd2e9c3ec8cc06604cd51ac820d6,
+            0x2724f8dfd70e0094d613f65f6b48d42e22a961d06f589ca1a64b74e0ba9af8a5,
+            0x226e101fcd7f365ac33c608817ee6a4c143504927affab95f4d7f95da55983c5,
+            0x295d81ade71715f0c9071986b3771fa8621bf634006463df3b53dee9bf37b189,
+            0x14aaf0e78ca5884fbdd6282dc2a2008a1b6165adffa6e9160a9e36190eb81afb,
+            0x2652e6b66e323877eacdc4e0f32dc9f72d692ae7501d7fed6c96154529f45a39,
+            0xfaa22bf6ee7ed51ebb087c35bd33ed34bd4474073349a80e9c9654883091a95,
+            0x12bd1d8d922cb20e1d0e02d066b120f26a1979f4374bf0fae43cdcc0e5a366f3,
+            0x158c1a5307ed0d18b58986c274968b23e404084a78aba5687e2e2c4f009606e6,
+            0x28b5ba99540925c874c6b815bd7303dfbf774c5e1012ef2b305ca47559f597b3,
+            0x2b845d95e442fcc4bb8a49be773609957b578e19ee28baa880226e3f911d26ef,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1b66e79c663bec66bf23b5cbbcbe9bac308c47817c3f242d3f66b6d565be3b9b,
+            0x79f775f411c9c90149e59e6a34d6f6f47947db4337d9d3c18bc4b51d4cad270,
+            0x3009d6cbb50dc688b7404cf82d589fbad43d0742333927bc049e48da6913e606,
+            0x1fc70661054fdb2111e49907222387ad311058d73c0befd6314478175e356942,
+            0x1ee04e8ba0265fce330585518894029b62d9bd50c9d0a6f87f1280e82859e9fe,
+            0x644f526b432da58421456fd00e0e29291e8d0df2ed27626c42d503c62e4fc9,
+            0x27e99dd0f8fe2ca6883ea897815b333de616c56c483c0c9e45283067dff3c4b8,
+            0x581ac976cadd2b1dfc14d8b3cc604f1e8e79dcfef24b8f67032c18b90c17e9c,
+            0x6750f648570d1eea536bc3842e8a9673cc564c9784e57793475bcdb399457fd,
+            0x15822b758ce9dd864fa21222839e7eea4132d1b800819ea095a6465d9ce6044f,
+            0xd9ee290eeb8ccad8fc7bd054d7e10ff3eb0e3615f770151fe6a276d53da7738,
+            0x2aff79aa26d195d6001c0805b35a8c05a08b59a0e819c7689f176ab29deb33fe,
+            0x237fa4d9fa2fa84b58ea68d75927afee778a5e476073a9b30d6328ad62f2d807,
+            0x5d20936e308b6eb8373a899e602831ae0cb091abea22cf044de6f0cbfe6723c,
+            0x20470a9f2d2a3cad5d2f92c333444b429333625d0e07e064fde8454fbee764af,
+            0x2e5ee062393b836f391171b5c738e5d731de49e833031ce97055486def2d6a1b,
+            0x15066a745e56deeb113b9dfa9e92ec1fc4003f8dacebb4f2f0a591e9491a96fc,
+            0x15af3f3747ee7d63738b4b137be08c44f0c90448307d1d2d97788fdcaf30238a,
+            0xa9db2ebd67bcfd0c5c2e2baf93fa206537a0be5e295da9334c19515018d4dec,
+            0x9d819663eeedf9ce5b97d71abcaa195f6ac0ffca2e4a99d89510bd29da37cc8,
+            0x43e45a7ab55e8ed770c8bb140c5cf98a079f0a286c76abd11486adec2b9a69a,
+            0x267390f339be917c18588ec7f9b53eddda42bbad0e44351d1cd46421389b06d7,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xdd2adfb2aa3b4128b087b5250d5e754672ef02ca8495a5b8f9c2e51d12fe27f,
+            0xe44bb76a256740fe47a818596b6dcf40b9db85c744d3701bfb808a00f7ccbe1,
+            0x68a25d2e27da4305caea7b47ed35d9712720f654d72d094e4d9b3796ce88a27,
+            0xa6624b2e2d3551843723976c9168b1acd3ff196804a6cfe61555ed0048c3554,
+            0x2830c3937da98493bda628849823e656aea96f309f417ee6a4907009a4957fe3,
+            0x1dbfab542ad1a8d1b064c18f2da82b6e5320e8285d33d524229aed44da0fcfcf,
+            0x12f049967453bf43dacf198aaac17d184f44850bf49820b37f36df953e57b08b,
+            0x2ff0b4f794179f6cd4d0431d7aeca0e320270aa3b0e3f63d832f1830ced770f3,
+            0x287045969073b1ba8007b65f351ee152d9bbb0e68c75fcf8a3a3e0dc9cb9935d,
+            0x88750a390f67a5b19a63ee69e6055949015e796d41a2150f8b83f58c1086b4e,
+            0x2a1b684b9357c3b9b675c9a56d3690d3b101ff4c50d5b7f97d68d6a247ad6e3f,
+            0x924a953beb10fdabf6088068bc42d18c47a292d33fb12b1dd11c0942051a5f6,
+            0x5fb81ee2e1ac5e198c62ea767270d3b52af1e24d4d6857f82c2ef4b94f39740,
+            0x1afe1a783a2d68ce8f79cacb2bc57502c6c5ec9ac0bbe35f55b34bd4d944e15a,
+            0x128e66b9d177d588af9f9a10ebd195f03030cb2806560ccec1c0469ece8ab9b9,
+            0x2a89bbfccffb647312f31a2b0b68d731f65279273447021b716f8d7d1b9eddbf,
+            0x2d2c1cc8346008effbe81b219d8dbec37bbf2a6f6dfeeac3b979b761663404ed,
+            0x2a10df4948ebb56a6d1edf6b2d7bc7d7bc3b3a6085565a90bccaf53739093eb6,
+            0x29f0a91579b0418cddeb5fe403d13c929178124713655833284ce4386673625d,
+            0x2d60032c705ab2c8e457ee0d225acb206a5cabbd75b088d97656de6df83db165,
+            0x1adc61e3889546408f21d1e1cd9533415a7cc177598464799da86e31778ea854,
+            0x15d24ec281355e28a085dd996ea0c90aac7efb5d87f9bd70a2a6b9db6b50b7ba,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x1be40669c4305af08dd9cfeb05bc7fcfa40b998bc74ffe11302c4f5b0553a38b,
+            0xde0e333621fcd0fb11e36805f9722b7d5b53bc39cec2c63a02ff853f30c04fa,
+            0x20f0930ce2a982f6372e84ab5310be3beae1b0b7f90b8e562c26c2e757702d47,
+            0x299a425dac7d3a4c877808a7459597fda5984c422b6a994d81e195f30385f8dc,
+            0x2f3b6c085ecf99a58b7507dde8971a225c511bd6f802ee3a6cacc0530e8a33d2,
+            0x1dbfd1be6281a5c77b4fb2c7dc937a25dece301dd371ff67769ec907ff76c72,
+            0x2057718828a717820912bf7aabe85d74d0e759d3357db223cfa111b82ef48f32,
+            0x2634e710d328db82ab3d5c000a6e16e4cab4cf0b5c10975bf684488df5d7767,
+            0x1508d73e31efd2a02b601a7151ca176fc79f3721fa686f737d66b4a43c1597d3,
+            0xab1c757a2930fe704ad42fd54b19104397077d5e52947a92f810b0ef5d87871,
+            0x9da497dd64c5e3273900635d09193df06c1d2426a0fd73d7dddc99c18daddf2,
+            0x2381572e35bbe9d3fbdb3bb1f1963bdccc535817b1d3c077e51d7fa9cd9a6cab,
+            0x1435a49f928494a49e2a67e4028810e23b7f26843d1e22e2d737b40f01da11ac,
+            0xa41cdb54589156aab59180023dd35374103e5a4bbe746ed8f2fc3ddb26f8e25,
+            0x14c484fdbe36491934a1eda09b63b86d803e7059cd8e3314e8d774b7910a7cfc,
+            0x2a77a4002da2b4e2ab43232ac86e8fab1586b84ef60705d4f5aef26aa5421749,
+            0xf63b8eebf3c4535bda0b094c007bec3bf0ebb888ceeb957858bfd41e3b33a49,
+            0x1277d3fe5619089508669b1a53372f2f10ea0acfd07e684219b7526be3566d69,
+            0x242bed90744413a413be2f93566487aecf7ed35f2f6886e79b95fced93648d2f,
+            0x2f421f7536d6fe02069b4a2be1adef885983ef7ff87af5bdbb73904f96cc7044,
+            0xdcb8d37d53a5df0f9ff37d9f8e111e005d70c93bc23557f6041711a167e62a4,
+            0x2b8d52018de42ae27a896a6100b02cbb428bcef7fc95c21e0631a0edd273ecf8,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x20ffc046123c9e7c161ec2fc0033671938b1bdbbb51504bb48a6bb7691f867c4,
+            0x37fff4149f4439e438ce162d27ada4858d0292fdd5cba6ad88b72e73e552b2d,
+            0x1de8c8e615fa608fe89f596053f7f2aa3b21158cf1116eb6bf12e98bdc5cd339,
+            0xbe3251cdac6825fe72f5f701c19215869c21db3e146faec1b7d83e291deea6e,
+            0x25cc68e0156fb406fe6a1d01bf926214705937bbb2dd5af7d2feb70cda04b273,
+            0x1e6d41a49f875455a20e395c2f5466ac44d906c5b77e21cab176934d6ec92fc5,
+            0x2e67c91faaf0d61303858bdce074a2f61220d62977a4d6963640808413273f31,
+            0xd12fb42faa45cee5774d38145639dc1393ec43ceec5d54b8d81f8ce3d74cb49,
+            0x23e70a4146133f0a77a4e1d743720692125531e4b83edaf6cac156afc870df9c,
+            0x2df6f710ec27c2d652198613afc234f4c6d65ce1cf6b5488b3984e0976f75cb6,
+            0x195ce59e69ed9141b51479ba07aebb50eda0d40c16335c1dc3371581b006b9d8,
+            0x210f8fd97f1707c4ff9610daf5bece6fd2a7e0b4c61801662ba3aa177decc92c,
+            0x25f1b7680e11f44ff74657d2d3bd43aab044798def28b435e75686606d12aa67,
+            0xb2c75ac5a5fb6d2b4fd51256d3aa84daf97cd4611e54b1ce9aec26e298bbf88,
+            0x78398cda47317311211740262c08710b86d61c54ae55636a4d15220da5b85e4,
+            0x166af5abc6ac2210fc2e48e17a3426b597bdcaf849cfb535d3a4a83a16fabd84,
+            0x27194ca79ac4773ec964accb35e09bfaf60f65fec69f6c53a45ab6a7720410d6,
+            0x10c46d3c254d57f49a985c74732f27a402232da4419eee8d59c39fe0d25674ff,
+            0x1621881967985ae3b969ef554ded7e95027c80a3fd24ac8233b7204c46b67b15,
+            0x28e893994343597be2f4993da693ab68a1b6530fa187e0708e6dddd65e19f65d,
+            0x5b240574850357b93cf99c2a4fa39529f34cd568be5b51fd6bbac19d66a13ce,
+            0x2a3e91c0f5583245a4519e6d5fd37530ea97eabdcd9e0d2655ac4709a88e6b58,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xbc9156ea781bb2f4a48a6971a1463c341447af7640c0dca22fee678aaafa67f,
+            0x216532d67a620605bc236aa3d9967bba132c18ed4dc9fb1c7d0b6e414b69ed68,
+            0x22ddb91daa4a4545901d12772b1442f5ba4e85eee6a77637fc31bf513fb116ed,
+            0x2683cdb3a1a277aef9c2b9cc42d9835ac8731f42ee8c1d97c91843e330cc797e,
+            0x2be49377140f55de27dd9605e7ae0438bea87e1027be1ccbd27547bb1882a71e,
+            0x3aca5d3892e4e23a82e32970ae06cf7944979744108cd4014495820f3f3cafb,
+            0x67c57ee42c925a4fd7f0b70805e871b1dea5c0c64eecf286f01a7f82496d0e,
+            0xae7cee32928e8bb4b2e5428f6ed56733a955dbb415961e58bda4537603370eb,
+            0x270c6be726a888900c325fce8361fee0766b4178288e29892e43ac4bc5a7a53b,
+            0x2dc8ef31b5b489de3a0218cca5215bcd23860891d4be8eae01bd6b6a9fd89e0e,
+            0x19643edd20d71982a49a09cb1e0db7d981d928413f5aed74a20b339a45cb3a1a,
+            0xcac86cfd70c7bd0f964e2186efa830356866dad5402655391b164da07230607,
+            0x1e28a98366dc2b5a1dd651c8cc239f7d6a65784260e4f99d5f22d3acbf089df3,
+            0x65e579467ee3caf9abf6427ee70e3f04350efd4f240a721ecd614bf510a6d15,
+            0x625a0ed5662a51dd09f1b361ee979a3d90999de6544dd012e0a3d0ca7f54290,
+            0x14ca160eca3dcf16f63e65745c1fc7da76bd228af16cf74d2a322a02c2e63e9a,
+            0x174e5a80b5654227609644c29b2ae1f7346475075b95bcf09781b29dca6da8b5,
+            0x159f373903a0a9fa1b30f1e77887b7f4a13c034eee827f0bdce9efc244d50300,
+            0x1e6a451f0965435e18b8c68ed523a5f5700731fee946b446a4a56d697a65e136,
+            0x292002d89878ccb5914c5d7951b45952eb8a48c0d4b8ca78af9db15c0fffd2b0,
+            0xcc6c8b2dc526673c038b258a850a754ad3da11b01690ed359b1073e37ace2ba,
+            0x2abfd63285e9ac80fb865ff2fda5da230f278f9020001f8172727bd6f257059a,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2854b5984bd6b9e733809dfce1d7fe5ba63fa8d58d57e4cd9f540c2368db0dd3,
+            0x2e88865414f2b4557548e383c7f525f471c9fe0d8d64f0b8001e630ea88ae41e,
+            0x23790eec3f5a240f8398eca3719dd949c4e1b4c483a16aeb268afaebdda79a0e,
+            0x2fcc8669dfcf04fa06c75b022b77b84d090df3b822dbbaad1fb8e3ee948e86ee,
+            0x67fef650a45711037a1f204eac29045803fa922ccf8ad518334c03a29178838,
+            0x248f8c46bb3f0bd3aaf83f0c410c0e56d9dec620820ae91d41c03c288c0d998d,
+            0xd3b6a0004a85b63a85061b171d87480cb262b1fe4ccdb71be2114f4a8b13fa0,
+            0x7b065a9ccab6b970669bc32838db4c48147f0661f53929f561a7a835fb9d567,
+            0xe02b6d12d48362677df07056afc1bf5eee55cdeea65044de0648a0c7c0a7894,
+            0x2fab90c9d26772010fe914e4b88a71e32f5563f4d4a138855f7ab4247252b84e,
+            0x1989c2e54741cdcb6cd94407dc6ed84e7817384af807ba6ef8b85d4bcd313c5d,
+            0x28de889080866bde3f19d84b253477607071c34e59569f2fb0aa180b44df1418,
+            0x2804b79f457cbb808d034036efba0011bd3ab0419c39b094a7341eed26a322e4,
+            0x24eb9b802012e11386b4ed5ac52da70957cefac5d3911ec1f042917e479bfa80,
+            0x1666ca210112c32bb19b256acbacc96f58cc0fb7dd93874d50021fbc631b80c9,
+            0x20799de358137dbfbc623c6e4acadc25845bd214d4073f52b8024ca43d99cd34,
+            0x1bc10c44525f82f98f44fe8951d669c8bd1087ec8fb25d08c5da11ef1117e052,
+            0x1d8dd037d73544d78d4811ce0d6b48264449172217cfcf67186eee425e18cbd8,
+            0x2fbb2fcd6bbca136c183d5f94582c61f194aab068f915bfe0d85cc5d4b82bc08,
+            0x1eeaaa5f7e1834a19655d80bf2daa1d2cf50d73d18e1973e6a74c487030474e2,
+            0x1f7eb06d961fede066bfc2773ce8f36dd7aa35a727a60780719f0b9a627f56fe,
+            0x2981fa5e6672d977bb169d70e070e73ab9d7c3f20950b3242e9295b45390f46f,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x28776c75f54ae00f3190d1e711194bc03ff39d248d96027523b166f942920a86,
+            0xa4ab73336b833957012f0e7bcc36899849b2db78f8fd707b692578e14b80328,
+            0x21ebae99beab3aff541833d68c75fe506d857d8919a97e07e3902b919d3e143b,
+            0x3029aa9bc55b8d1ae128f45ba368cfb20896feeabf39b966d0c12742bbd28bd7,
+            0x239128973757a7e9c8d29d5336d1a53b277387b48afa946628f45d03eba49de,
+            0x10a0435f8e32fcd6cd5d8ceb3a3c078227b5cbb69966a76d7f1d751e594479d6,
+            0x2f5d49c2ab9c95d09cb160a6ddf47a0763fe11fc3504478e45d1d07e641ab29a,
+            0x1181af9db194b4bdd65f61e51a4f7d562307f5745522e265198b320ae649556c,
+            0x1b9d2c4a0df2bc6d9d56c76317180d89b9660b0e3ac54e2e7ee83868ac39a621,
+            0x1f5c2501487912b1ef65f072a108f1e6cd640b1eeb0dc7dc0d579032000b8570,
+            0x72c3f6dc95aebfeabd7b79bff8d0073670c5fca43b5b067caa4828e67bfee02,
+            0x2328cc21742ae15efdbbba3067e95d0134f49ca25303ae9872315e29eaaf3d1e,
+            0x1a2d67aba6dedc8f6838af4f2318ef7575a0de251cd8bd4b9944c0a96d703b20,
+            0x2eaf6ca068bbcffdf36dbd475ae928d10a2055dc10da29f77ccff5204c506876,
+            0x233188598d95df9ea9c86b38db0027051e6a4bbf4bf27711ed16489783187d5a,
+            0x7b462ddad87175e51fe8bad7cb756973ce7763ea732b3f64dfa38a0a0cbde51,
+            0x14bbd08ca052562716a460cd30d0c3d20a21db0742da1e4021feaac3a8da738c,
+            0x17bab12d3266540f45d4ee8beb4e4f01267e296fc291ed54d0f4181a87e0a53a,
+            0x2a168a263170030f88743436b706dfe82da391914f492e7c48a2f62d56cc9d40,
+            0x233927efe170a047d3d309380bcdd2d2c7bba7541dac277c6cfcf3d1bb16571d,
+            0x10b9e5f24f1f4ef89886d8ad3f571f8f3e8633eb6a3ce7a00551d123a1de0548,
+            0x2767b7f7b872770da90c9b9fa57bbcd766b878f7bf6db0a1249ef4dab08c56d8,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xded85a7aa57678558da049aadb3f84b88357510e6424702731b6f39e9824eb5,
+            0x66bffbba5403655a7eff0286ea82797fb1b78ad448612d5e5ffdd513979fe8d,
+            0x2be44851213461736ad1c62746a446b9b9ea157f592c1d54f3bdbca0e81b1d28,
+            0x13c7aff223c351a0136cd825f10e41da937896c3eb153e712cabbdc0dafd01a9,
+            0x1e1295fede0148bb32d784c659938de19d63cd8f070b793f4af6987d4b0a2ca1,
+            0x108e731bd672ffd58f3bfb3d66c3281da9a79214ff667756c3193331f15ec2ca,
+            0x28ee2087caa404a7b9c88d871ea969073c05aa2d7f8c8afaa372fbbd29fec908,
+            0x1929e70c3df9677a16e6bc3ca6c8f45435f1781bc7d3fab5c2d9f21836bca492,
+            0xb328f15c14da87621bf2b7b1482557b0e1e4b62ed771ef0b5c0dc2839391a9b,
+            0x2463924e854fc278f78d41ac3ba4c82e9ae33933c1f673d8fb988f5257ea48cb,
+            0x206b2c50fbd93e4ab16f20b5e1dd4e31b40b410bbba02146d1a7e7120a0bde78,
+            0x22a8169f4dc83f66b725c9db0aeaf6944c49f7f59e084741b74dc75f17a2d582,
+            0x131beaf6c38d2a148c91b01285e728d83c5b40309f89f2ee1d69ccac916cf9cd,
+            0x1f2f76bc23a46c9ed5441b8e0e91058e2eb16165ae943eba8b61f7629f38708e,
+            0x350963d2c0aa84941005b7fc8747fc61365ae03a600af938753c62384223d64,
+            0x1f43a719acb173edf3cef4ff57b3e3b54434997e03bca2ac3164d6d206298ce3,
+            0x2ff2c8be1964373563d96804dcba6db4f2004109e4d73abe431271981c9c8004,
+            0xc8aa745ddf7f419258d9f829ce7abbde1f5be1343ff89d90a597b8101cf3317,
+            0x8ec029d60cddffc7b81dc89586a6afc233826c1641ccad7dce7da7a0d552002,
+            0xaf6f27d2211b12aee10a405ba1959fba32e4da7012c94dfa822b683857685e1,
+            0x23cc9f4ca99d30fe0d7780397d7281775e7359c3be70471bc6482193ca3b318c,
+            0x5de7e88f631488d23cddebbab25e128f8cdfb524acbbfeaa7d2d0bf47c2e7f3,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2ef97e821dcfca90bccc266cd3b7cfe86037c961414b970511a845251204cdf9,
+            0x1e74c0e015eedebe75a4d569561ce744107d8f4f5406e65685a60f97c00c0c77,
+            0xb9e7e57a6287f13cbf8760fcbd1bfb988e1dea2f70bb4352fe9acfc560d3a4a,
+            0x1daceec3e24e703f54a27a8804d960d841af5a0a10b4ed8f2d5aca46b61ebdb4,
+            0x14add4559507a7ff29e4e915a30bcbc79787408a6cc31c071199e81f03ed1b12,
+            0x214af846405e33b9747a25b176edcd7c1934c101d36a2abb81c958a8be7c06d7,
+            0x8f62c1e4c1e9fb62f1ffa5b262df316e32b769414445444c4e345b6e6a8e3d1,
+            0x281cfbcfd9fe3fba3329b1e3d6da6ac72e3d401483efa9946cab0ab530342c59,
+            0xc4930b204d10bf30ac793f21dd5cf84cf084aff28fbea40474f34056c4b81b8,
+            0x75717917a0d4e210ed37f81df652af88c78224d99d13d46dad5a3d040907c65,
+            0x10236e639476d565e1de655b0f816e859b5b3b38897ffea9ccdc9d95580dd0fa,
+            0x16535568d792d43083a2c8a155e09645cb214c088e40b70589a610675f2b9bdf,
+            0x209b82d2cbe5617f7cf4b7ca05f0bb1dd80dc2a652b50a23e68de856334edd78,
+            0x10d0843c37e9ffcc0692fe6018d480df45f96e2ad41bf9539197ebb12ae5dcb5,
+            0x175f7935e1d6d289b963b039c85cb1a3ffcba2f681cb27a6364566acf5ff2d1b,
+            0x12f9631f7d9cba5b34733142a23a76a4e9bd76fc838bbb865a72aec17a3ba09e,
+            0xa27aaf6ad1953f49c5240425b509144c9998735a59e27906e98518f7bcbcdf6,
+            0x339c108d3ddd07caeedccf45ba3a1729cec3387338d45fb0b7b896faf618118,
+            0x1c7eb764b1b6372c8a7f18549edb2dec9e713ec618365f169f0633181ed21da1,
+            0x2d06b5cc446ac8715cd21b1c8889728aab4d3b5e7f4eed7faef3530fe3766440,
+            0x183445f90535b07b08b20073ba06950f500eff3d0962ef609a221fc0df504b0b,
+            0xe05fc0656468b85eab718ee19bcd04d0154edc633843570adc6e7d10592445b,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x6941082d94398eebb54a701966a9cc45b303a0989725381645fbd0ff97d9d66,
+            0x22ea9d22606530112502f8e40f9277e1a334e8eeb307a03e3924ab8c6701f186,
+            0x16ce67e884bfd1782872fcd65b18b3f27af8c1edfc8ddefcda53f3669651df33,
+            0x11fc35853f485f0ae0902c650b9749b481e336c553fdd90f9767d8bfd52c63a9,
+            0xf04c0f3525c56f533b23a4dd4deeb7b31938dfb1531863ef1c2066e8758dde0,
+            0x2e15668ff3beca65235e7912fed8b7ccad0928136db06090fb6938ace207f363,
+            0x2fafbe916d3af6fd0924cd2973e1e2474b10be1db252cf038fc32e732484bf7f,
+            0x9749b2bb5e6668839c8be56fa468598f7292780e294e47b155c12322e34a0be,
+            0xc81643458c5af368b81dcb405aaeb3000b4c0ba29c376855470cfbf2c35e3dd,
+            0x2f7745d6f815dd3cbe2c529c63f07d4a646015842c6678456406a248252d0f78,
+            0x2540261ae5b2a3becfe0ccde660cf756cfdfbe8fce0713c061da7eae6e5bffcd,
+            0x1af533c9109087f14eaf413f798f4f0e8d9453e7cba136d9f5b2e680e80ac911,
+            0x27115fa52689f8b86f2966af42504d25dcb23d541dd6a1f5d328b37b9f982352,
+            0x1f955bcb282c2c0e74b4169a61a510d4fa506ec8a905051cd4fbdc9ef1130654,
+            0xf13fc20a68d983add2992ef921aa7d9294e574b8a0c697c5d56622a585ef6b6,
+            0xe480c1fd8e61a5ed800036d9110caa9a55309bc46a4fb1d7756b7e96ebd2768,
+            0x208a8b0cabc7890d78e18028768a0a37120ff1e0d81cb9541bbd781d3fb5a679,
+            0xa4bd40c175726b644c3dad0e29d158fa1b1753a4a59a1606738c57026eac391,
+            0x859bd87fb95504fae2c58816724777f1c93a172de0b231da82c08935a950dfb,
+            0x1572f4f0f2f44e7ab54f3d0ee208d13bd9f4a16a2be71600d10651b35483ccc4,
+            0x2595802b887ba581a6463dc3dd4e29be1b0977c87a724078d84fa16da9b8adad,
+            0x28290084f5f35de74591e06a61e7a1d696a79b2fb8db90d5a3deebdccd483987,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xdd61a5489d4bb7be05223e75e80040cffa4469bbc1d2ecee02d0d5d99412e85,
+            0x6c52f4f90d713744ace66a17d3171c6d83f5abea58367a3aec7d538736ae17e,
+            0x284ce8cd77c9caeb5222618bc77d4c3d299b41cc74812489591bb1f23a5e8a14,
+            0x1e914c2446466051f961f69baa9b00c56f018232a1cae8c6933a1a54efdcf1aa,
+            0x1f9f1d5d61c22831aa9647a5b81bc92666882640968d63c03a338173c0fc392,
+            0x1381629462428cc21dea769021a08fb83f68960303ac1368cba88b871865f06a,
+            0xb272b9552f9201b03d7ebe1a1887c7f8271ebab08e81ed125a70c8f7764e1e9,
+            0x7b4d12c7e949d4ee6e2e0ea93dc105afbfa277b9373af2d12a6ff64e45356a6,
+            0x1b38520ba1c4589fd42014d6e8049acbe95daf2c4c2d910c44ab141a86e21ac8,
+            0x1f9ad110bf1bbcba3edb9173790599a653793009ec8ab285cb9567a868e41952,
+            0x2e5b599ea8d25fc97e621eae08d130909178d450803edf6e853584304f3bb0ed,
+            0x1b15f498744dd45c644224cbc078e921f7c1b3e1af764a8467257d6c069fa18f,
+            0x1d4cec7d699719620437c0a48f205caa856cbfee94146fb0d1d8dc66c465f4a4,
+            0x173543ba0e2d1b252191c8b9392abd96810103fa3057903aa1697429a9bb9185,
+            0x1b9df3514d0b3177ea22b6d61bbba61e6ecc5ef8766404333fcf6f91da0127cb,
+            0x2befa98a6a5c83888ab8f22f9504c9db9faee563278a894ce253b34980873ec8,
+            0x295db1d483a66191171deb6a0b95d08b843827b02f5e691aaedb0845baa64d77,
+            0x16fce7e0da0af20b730d87e50ff3b8153e377304d9d262bc3c1e2b4438d0e189,
+            0x1660401c207ebb47773a099e512b117987bc8d102a2ca0a7cff9947e2f2cbd4,
+            0x1bde105e9ebf2795607de216e544e9638fb23ef1f598ccc6066a5b1acbbdc1db,
+            0x5ff2966cc2aeebb42f6cabc2aff4ba67881a3653168b1da8919ea64188d4a4c,
+            0x1de18595180cdece76bc7a389c725303f8114625785e4f8e7cb987366b7d8b50,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xb75306c52e9faa2532157457ca751484e5de2cbea41a357481e6be641c4feb1,
+            0x4c7855c4b3a6e6db0595c294ad58c4c3a41ab7a671608e04eadf389a77d5dcf,
+            0x2596ff7a33d026067f427e76dee78cb0cc93819ab599c3bdf93191bb9797a3c8,
+            0x8aa0063dc5903d4aee032268c89e865b3269d7545ddb1084af2479f55225ade,
+            0x1548a8bb67459d26258983882563f449a56c01e3df7a608d086eaab22f93708e,
+            0xd5ce47fb827e13d9eafa9befefd32eb089ccf1c0275c85946e2dfe1f43e8cc9,
+            0x1b5f4423b16a0cb4af1f7bcbdcaffdf51b021924dfab1be7fd33a56647a51999,
+            0x18d535b7160e89968c9633cc71fb2d97df3139814c12fdadc1e5a6f7622a7c00,
+            0x16a0d6cd63bb6b5ff4c2808707201602da7d6b0f44b701e8393f98db43c24fc7,
+            0x232c12d6ce6ac0ab8eaf31cf01f9f8d2cf50d24b18ed216c6292672c8d5b490e,
+            0x27fb96c5c58c40aaf14a9cef49cef5a5c0b60471fca8e907c4d56c092d8ba385,
+            0x21ad1bddeb6296215e8e20714f3c301769cbb0436139ebe0db55fb961cf97738,
+            0x19b16870babade7b8ac30c9e62817064ae98a876c93675b2398533783343e63,
+            0x16fdcef57ba6577e0c963d013271e70215c8a3bf9e4a0d6f93be6a4e9faf2d00,
+            0x830ce701a93a0d7f92677aa65d53ff28af57c823098c256fc1470b3005f546e,
+            0x2295d7c8b14f2ad4cbb0f762a54c58383fb6a8feaf9d4e9bde35b95fe58ca05f,
+            0x9b1e43bce3e52d112b238e8f72d93493f41a8620de6e4dc9b52cb5a2a1f3dbf,
+            0x87c2f1fe382f705024d1bdcb8fe8adb33b82361d8cb931ddee3f9fafca2e4a2,
+            0xb17d752334a51d02c091a68034489d30b3b4c7e7659422e50b32d07a17a10a6,
+            0x18d4520269ba2bb7428758e1c74bdbcedf8f058f696da3bd8fafddc3f2543e88,
+            0x6d0e15f1f1c2b037bfdcaf6b1e724b26ef28d76640e68110d50e426cafe5688,
+            0x29b7bc033acd92ae8a6df93def58d498b79d1de519f6aed8de984fa296d8d9f3,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x186d603bc6d93626732b1f85ea4ccac141cc8f45799dd48af4123a4f2e7a13ed,
+            0x1e9fb44d51ec4915ed9a5809c50dd0bfe11b4edc69e99befd9ec30604445abc5,
+            0xb48f62bf60c1124bd7be4e0b9ee6c66a642918a465fa1a50e1ab500d677cf85,
+            0x247318154581bff6dc6333cbc14ae74202b1d419241b047dc891c0f60e68abe3,
+            0xb26cbe5ceca89934bce5543f84e42bc739f25f298e556225742d987b0e6c269,
+            0xc60ad9c62b74abf92a69f3f0c2559630ac51bc8f84c426130401b7890278a30,
+            0x1b0470a9e3485e6cae2769f6a9b7aa5e3b56f101d7be6bb7c91178d594560e44,
+            0x264d68f9e933b7f8263a465260aa839011aaa117eb02358945fcce72e0c93e2f,
+            0xd93de8429c70415df7229fa233e610689e3145d5346511eaf5b8de2543517d6,
+            0x24a99012c1ed7a1245f507ad4a9c8534658a4d1ae47ad653903dfccf66b4403e,
+            0x7da99b57c2bfc56693da809691737e832191a765a51a276971f167c3a82ccb6,
+            0x1cea1b13af00acb6c1f1596831afbd4be16fc313d954baa221204eb1035a8a1e,
+            0x123bfb0630e8aaf56cd3744661919b2a88c0dff13bb0a571aab5253f98bb4762,
+            0x1af132231252bfc602eb9d982d46f7981470c1f81d33bc2d50764daa4d0c33d4,
+            0x2dba0bc37236d5b612363efeec5db5c4b8dabe365af1de7eabc4307d5d13a0e0,
+            0x221ca65c9a1d3b45b69170b26e5a64921485f342c9d1796042a9d691dfa2b626,
+            0x497f939c6b45ccc29d57e1291021d7fe4186becb765967766b7ef50e5f2af6f,
+            0x20b8117d0bc5b325f5a6985deb0ea6c119add748d4432aaf52f1f18100c4c4cf,
+            0x1fa73e129c14d72a4e3d45e1044b4e0237b38cd5f7a44284bc0e35fdce08e666,
+            0x19f24a1c686e20b06039e60a1d522f8d521491a40698ea48a43219d401615c11,
+            0x21f4738cd989617c3e28dfb8072f349b44fadd5bde90f169420bec4a0a89655e,
+            0x14d1cea4227f6d369bc6015328bec36f0dd3cf1d9d2d088b5fe413ea7faef3a2,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x985ccba651570f4575a0ed92fc815c4d262c6bf7b880a4a2e9a6f062e0539b7,
+            0x21370081514ca3496f035319fa817e42c182855c938b09f5737bd5e0b040d387,
+            0x28d51de160b191dfe5213005f019a3873bb60f2b9679a3df65617502d21538d4,
+            0x1ccdc75e435b8deeaa4b0c8b715f0831dc225c7538266e90609f6a6285a2bd48,
+            0x15ed8a603516e1f5617875a6146dc9c8d511cd100f9ee41a1fbdfd5810408c6b,
+            0x1cc5e7a4d7ecbf4bcd15e2c0d54532f2c6f367980d5afe4e148b7bd8137373a4,
+            0x2289679ed75bf564bd924ff42f14a4f63663e95822eba74b35f6c58d6ff54ecf,
+            0x28a844dce08ee0b8fb55e7df9630e357928dbef92ee9be0c0163b51cd555503a,
+            0x2521735424459701359a4c27c2cd0d55baa5380e4f4a06ef897b2ca89bdec56d,
+            0x225abd618e11689670409cdb1a66ab70d077cdc0f5efc2b387258f280a24c36c,
+            0x4d7a23e3eb7a46679ac5fc1d8a13d1670dbb5f00343cbb20893fc5576120b65,
+            0x166f7e2b14c9b1776ef74e4dea3147b014234f58ad5ca5a41f5cc40775185157,
+            0x12681987c944d15c132a93d6dfecbe502b5b7ae4daced230eafdb89d3e8d4ee6,
+            0xaa7558052b83cea0ddba30060b4b443b3a4f00ef388d98aa6081641e7ab58e3,
+            0x2c817b2fd2e5ec32c6bc84f11b3c63197aa4ae8c2f372952bd016162c5d71cb0,
+            0x11962159a017e25334049df13f2bd013d77cf18b3decc7f66ff81041dcf354a5,
+            0x1d63c9e5c4b133a0511c8624795f54474b2e6e465afd90330f50a44eee9e57b9,
+            0x2d82e29c044d1096b8c16734a6f9c726ac5c5b47a199dbd7b1aa0792a16141e2,
+            0x1b28d232a19693543110917b0ac82983b78b48fad53f25fa007748f630d524af,
+            0x147ba0f7c38d875d1eeee53ee9112b75fb0ae91010332de8f9325aeb85e2e22a,
+            0x1ccf269bf476fecbc12491a10b7a031a43c6df180a74fd76340546abe205a7a1,
+            0xfe407a56ba91ac174fd49efbb61e8730a4397e8df24abef0666c46e1696f27a,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x53ab7883a6bb37977a9f6c04b7430e1f23259c71bb63dbe2bf0fc296793b2b2,
+            0xe791a7097b6e2ee5dc314d57432975400f92d69d4ffa60d7c9a004e8a8326c,
+            0x4074d5f47b8529c9d8c79f8869dd7e53944046be065d4cf1d9e400cd30e005a,
+            0x105b47899898ce40b7b74ce948c42b1a7f1c064c17a5588cab02b9f593b55744,
+            0x2514168dc134c9550d7d4c5dd03dd3b6fa0f4c10fc363137f17a1cb71b8dc451,
+            0xaf1d61be25cc6a191184e77234542f4946de687cbb08aa8cea91a61ada0548f,
+            0x1dd5bea55d34b381ebdc842200ecaa4ffb28b9edc96025a7025da4d28af0c053,
+            0x1c39e9f8a25300f88afc1d5aeca648517719f5c2f8977865deddc3da451f739f,
+            0x3adf474709643e45b573ffe296c0cf64b0bce9705b91f83fc1092121474942,
+            0x2e2bd30c5a414e196095e3e2e7acdf0762c6a54ea74dd82ded60f8e6343c44ef,
+            0x2b53a13cc27545adbed481418cbf2bc4db7ac6aecda56492735ea2e9c828e876,
+            0xd90f7595963d4c470a559f222fa2b6e9588660c9ab42474fbd3502b14cffc96,
+            0x263b73e3488bf2c208876b22bee8e28aefac9d3a4b76768e9ec0b8395d2fcedb,
+            0x2a0dbef5edad1d5b0146a0630de8e8588c6e9f8e343ceaeb1e90f1163e93e477,
+            0x18c06136a1e2c542dd4cabafbb9232a98301c91bdb294072cef62ea4944b1f78,
+            0x1652c71884fab33b816d894c62c6c773cc63179ee35cb7e73a568533547d323e,
+            0x24c895fe21900e49b6c1e90825ecacb474a9e919a9d3451e170ef22189f5ab17,
+            0xdf80fd4f963e8fec47fd44bc51d94d1a0489477b2963ea46739a99a3ebe343,
+            0x1f03fdd86ee29e48309c79e90e0c1225a1ffb47ba0ca25e4e261e17e82567266,
+            0x27ce3b368152a24912d9493bd7f75d54666d1633a7f95ad94ef9cb63b72b73ad,
+            0x75d95500a93ba86bb52fde581cbbbd7ae1d288b85e9862fdb6a8460cd9a4d04,
+            0x2987891ed79215bfdb0513344a736a5faef636e4dc1aafb953a27e60763bff4f,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x2fcf686a3213ddf2ab8630b29d271f1c038040c01d6d40917e7665f59c0f411a,
+            0x261ea88ea2119c8ee660600c1c26964559b0345f3360be71685620821638be7a,
+            0xfe04a27aa636785c583c247067d0fe0328b8732b173b20171573497967d8a02,
+            0x2cf0912ac2237a5091ec27db0a7d5284f13bd4630fb6b58f221a68f5f4fe3232,
+            0x3041569dd972c73b88e73eccc715d7043f36ce79412db0df57ed902957facf9c,
+            0x2a4f9b5c59b09834c07365f58f63ed64038366bd9d17c7016f04505abb878b3c,
+            0x1fc17fccc2b1f4d051595c0e4151406c29d2eb02537696aebfb7b85e98371718,
+            0x16fc002eaeadbc610d53818fb1a72c47f07e7834b9433e0276eedf4e0cc779c,
+            0x2fe0f6bc3242cdc940d4ad67a40328a51da22100cea8628892a20d3680e6d9dc,
+            0x43423406385c4db5ea885da5766246096064fc77dda460fe8d8deb97d34ba44,
+            0x90ee6fd231f2b7fa73ff9baf6db0a47a0057e62664ddfd9355924242d050e02,
+            0x3005c2f73ab58a8cadfadc4dda1e3422d7c0f6ad0fe7a752045ac72001c6d445,
+            0xef228d7667c66faed8d7e3c7bbe5925a55d7451df7f51a6afa3bbe0747c1ba9,
+            0x2161f7618113ba7d7842db94ad2ef24f21f8a31b4c1124688a2e4dfac810f01,
+            0x20f085669bf228d7ba11d93866cb3c268b2e031ddb9697d80cf62628686938e,
+            0x294372804d6e2359003c9cdd1677565423edf025a9933d0b25faae3947171bc7,
+            0x15d37890f0af5bba4b3abb37bfa5d5e115ef5a4e805505e2cd021c4807ac901b,
+            0x287ef1d880b317586e978d5fc8ea277aaa451ee6be1bbb8de5cb447b7db251cd,
+            0x5d0ffe0d01c752afbfbc3e2c49f0d34d35ee5198603300d727a11b8e7eed593,
+            0x42e5fb819552fb66da7667d664838b4bf65a50c422ab1e9a85b1ff6e92d30d8,
+            0x1fce9b344a773117d21974d9c3a070368065377845171e46936cb95a3d38051c,
+            0x217e2377d39a2d534ef281f973ae22fe8ec4f87500899431cece3c75c410248,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x30073c53bd5375c642148a247e4260a05b56613dcdce4a093e85e10d296999e7,
+            0x237c0bac139ca6595c3dbe7f8130d399906ec0710818ff44c05774b479d54fd8,
+            0x1f2e23fcd2259faa7cb33a243bd212e89baaead143a7edbe6c6b1c295690db9c,
+            0x2ec7439229a284f2c48edbe15599d462b1d073b3a6037e8f7c8020777f26ee4f,
+            0x23c268b84e8c118733c2adb6b3b0935ff631f3b47843b112e80cd9ec5b5acc5e,
+            0x136b39ab04af56cfda16f3f99411b1c3cbd3ef198b5f056e65718f52fabc7c9,
+            0x29358a02315a9f5180f23577b3336be58d4039e6ce4fa251c4cf8618a955d9a4,
+            0x29139674f1ed5967476c8dd777624e49bc90890a5c99750922a4725c81105775,
+            0x2fce35cabeac14beb49bab9ade7e3811bba9f32b99a78e3ad655b77c473aa32e,
+            0x2d0fbcf9cb5fb78fa20bd878ee7e6bdccc2eab0eb7d232741932c0e785301f0c,
+            0x2ca38f6f88d6a37b8e126f72a82237850d9f26edc5b577558da58c2e55b0767b,
+            0x19e38d09cdb939e187bfb8822e5c2297a897da1f16555a191157bb8a5af115a0,
+            0xf61a58b977b2fd7323b48941cc010140e9b7da31271dbf3e4691b767dee7f9,
+            0x22b5299787050ae04bf9fb86cfde9589253870bed1a0213b143b33eba1153df4,
+            0x2becfc510eced53a873daa537c21d79a1d5071aa734f60553ee809520a9e22a6,
+            0x14d5be5c690883ea5b406c10b0120725bf1e4c5de2177267d9e38e9c792bba8b,
+            0xdcdc68aaff548dcc7842f194b1b30b604e4df04bca89830c0bc367e7703ddf8,
+            0x1b0aa07f9f3f5aedc37e1f7266bdb1ade79a62db3714cdb833d1af86cb89d9d5,
+            0x1e7b9c8adc9bee22f859972a13e0213314d43e1829f4f99fbf019de8ef79f3a2,
+            0x3d090fdc48ebc009b4cc7ed3546d69ec87dedbc67970dcea6052642e517fe39,
+            0x2fedb8119885c38398860a6e6c5db18431e4f0d981a2fa274a36d5c31f9cefaa,
+            0xfa5fa0299ea7aeff8d357bd332f13abd6935460588e15adcd0ec76c8dd6750e,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x12342a1391a6b59ff25a5c84f352a01a24422046622625d79588a43c40f4ea8f,
+            0xe21849b6b4969714a121558331c18a2a8969004cd750c3fec6bdda6384f5a30,
+            0x143fa84e95c7893e11c17306bcb7c7a64e395e3fd9f1f4f086ce3594728931d2,
+            0x216b7f99cfbd8ab9e124fd7ff4b172c853cf23a2ac95cb41b3a42190f035b144,
+            0x18bad0594a462f033d2be7d2151cddabc6cf21ed59510c1e56d080872fb95490,
+            0x2c5b49fce206c612947ff5f4a12cf1e4763a3a1f7b9407c328e30b3497d69f3a,
+            0x13fbbb66309924fea1153a649786a33fcd8dfb3e4222a3d59393b40ccb39b9a5,
+            0x3b44f905e3c8a2b3e7487e0ff0e1277d5abe5e1301c165ed1c9258829622f7c,
+            0x56c2fe32c1944e7c9400d0a6ec21aa54cc056562006c48458386c8d92f565ea,
+            0x29c47e53143446f7bfc43afb3ee84548b5caa25f4987796415d68e318889ab19,
+            0x2e43c52d27448282177163200168574de40c584fe61d4fae5dcae495890217d,
+            0x2fcce12507cd0630f06a2992a515f45c2b469f2742e328e07555d22c75e51e40,
+            0x1d2e6d9c5e8c220f9402b82ba4ebf641b2173e94ae76eaf7ee5559d43dec7611,
+            0xb1d1a4591f233e710a8f245cff5cf759fe0b4e55f46307bbbbf5d4573a860f9,
+            0x163aeadf9697fd15898344233a5a30236499b728c6fe54b2534c7c9fc648bb99,
+            0x2e3345617de88523b5d09b27c9669fdcb2472c6cc832ae304ff960c0d4a5a348,
+            0x1859a9bfd50b4bf8d40885c992654775ce35ec41a77b896206df0ef2281efc08,
+            0x1232a777b5141ee4296798cb37ffeca708d0eab3142357e4e917b65e424ec478,
+            0x10c4ce967cef015fa466bcf69079f8f23bb2826cfea14c78a3b4509ab2aebd8c,
+            0xb980e8a923bd3a2a9d5e9192337f070f18c11a16c809440f426126ac390b7c6,
+            0x2b1d91f4222d2984db754e4133fd4060d12c1dbe6158eb34fc1c1fd0f6327b99,
+            0x19ca1b4e01a1671c771897b741b03ca691c2df986c339c6f2c6b24663fae3129,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0x15e4fc48c95a30a9b34e39c7e2e5b23cf96e72dca78d25cbf1d07f6bd1f35269,
+            0x2d23fdc4c0c81c5cd12440066758541d7e4b9c6bc29cabaa7bb3217fe5580c65,
+            0x1e1db0902c0b9743d3e60f71c53bdbccbb995466f39a9e044074a32086f519a1,
+            0x24b7c98c30ccfbd3b3c87479bccd71122f3a41e0eac0c5a82916ad9e1c77ae80,
+            0x22ac75fca4d3bb5bf0f9f25bee0293c50901c2d45f4c2e1d19d7433b2771cf91,
+            0x2d0777b0c575fc2be9b13118b4bac03bdc856c03c9b7236f61670dac5da95b1b,
+            0x2252fa35e811593e627c8d6ffedaa4503728b6d6d9676f2e3270545cd190be5b,
+            0x20b37b4ed7445a96acb5891bfe84d9a5b96e8c5a67dd111cc4dcaa8269f4f0a8,
+            0x2347986652295db79f804ba06d9551d3e2a6b5a1ae358d94a1d71c34f36fe0c5,
+            0x19384ebe245dce94d5e68070e3114b1c5be9123e2a3728ac3af9d340058a35e7,
+            0x1fc74a00232310ce6af9e233a4934550b0f3ef063f221a3dab64c2d907138a35,
+            0x104721a9a6568d9e67db56ecc61ee18623e89e26a47b9e9e44f8977da8a7c16c,
+            0x16d9fd4e5dcf75863f3ab7971dd72de63e09cf77787931b0868a5c15be47c163,
+            0x392be8203347a51c9157a219aaa6787f54494b61e62c54e1c91bd995addd474,
+            0x1728a3905a9130b0f570af0165bd2d00dea61d61f7d103ff7c13172b179099c7,
+            0x145f03cb3abe12eb5f0cac73c11dba2bbcf94c72f2e30e22193a33906507934,
+            0x87ae2a368db5f3d666730029fa0ae971b6f50432881c9c0d86f5f3aa716b842,
+            0xe386543bef330d6c3cc14294ad86e2408894da265fcc041225196ab8064c737,
+            0x1faaf3ab79da2b30406f111cd42aa6fcf187b19448b18f4617712bb95aea6ab2,
+            0x1c68410bc6f75d9d773c5cc57af29ab138e98480e1a0de15195e64afdec8c525,
+            0x5b529d09da83d895ddf1aaa9849f98955d81280eb9f4b71cb7694b2a21ecc0b,
+            0x5b8ef58138e7c3284d9afc4541e7f291d87b2e26b50b7feeb75cd859e3ddcc7,
+            0x2cb13179d6e8a4ad1b9fec37376253cf64386ad905e240575fca86539b272dc6,
+            0xd2abe6bb0c097deeeb3f2162b41f9e969035ad6ca31e71eaaebaa590edae407,
+            0x1909ae6f86d6d43332fd32caf83152de39aac3f2701441302012d3b4349c458,
+            0x2f0ee3a8676b72e7e5ef4794aedc88051f0911ae43d036449d7c07fcf2f5dfe1,
+            0x1e378a1fb4fb0b0e168121f86be8de342265f0d9443de37ff6e24a8f31c63003,
+            0x2583b1b0912cdf162a046daec4856ba80ec6df1f1fa080101ccfd225176a0e8b,
+            0x11d9e38aabbe2391dcb7dd17706edc894dea224f6cbccef182edae298800e746,
+            0x1d486e5b90e3f3c789830bee968e6d544b54031477fdc8c9d002d6f9cefd598f,
+            0x234434965f05028a4f5330a590ab06619914476348aeb87a1ebbafa1e568eb18,
+            0x3eb55944fa1e36fd16239f7b3ddf108ff5f27955e2f386139493ea05c1bf509,
+            0x22d683ecc91253d08e6e535a4b62627738c2cb877d2b125aa9b190b3ed2ed9a,
+            0xff142864b0e14d2734c2ed0642a474fc1f0116d7e1c5dec18bdceacb2721958,
+            0x1f930557a284998225f5f4e4dfbcf5ac211f1b12d91b0562ed3d63285d7a714a,
+            0x18e8222f6907da5745eeb9cd4a9e62f28b8b710aa85fe729f9ea73a3ef0099d,
+            0x180e924d757d0be4066feb146ed56212e38acf9df4957432653f370f905b8b07,
+            0x2f7d0715d1391190e7b14a1242b6799eac3142e21f08ca02c21755eae77a55bc,
+            0x2283ed8d5e6f9470b3f4f49a771061e4a4fc7dac683defcc0348a8862c6ce71,
+            0x21f60efb132b62909990b9f994f381a9c02abc3ccb54c5c8e8c9c5664c6913d6,
+            0x1cde82acee60b84424e9bcee49a5464ee05d1cf0b70469208a675635ac715495,
+            0x118a24510a2153f818f0a996c87de913587805f16cdb1939d9406941f958e8e1,
+            0x164567b0de16b7a5550fca229bac7cb0779524325e4ca5e78a86078881660264,
+            0x188ff303194112a7034527cc9dd0b4deb0960c9c106ce115178dd7087e4e8c02,
+            0x83d832adf9bb4a25f686abeda9f16ebf53263dcf9ef4311781d09920d094ead
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_13_config() -> PoseidonConfig<949, 169> {
+pub fn x5_13_config() -> PoseidonConfig<13, 169, 1625> {
     config(
         13,
         8,
         65,
         alpha(),
-        [8798508051216852101945770298446195263426534955832706109793971883081428107277,18986509933027080134736570007084643366993581436980149915398754460582000677690,12888632176077676513526604615863975427335143923557716212154194444095746278696,15218363940991075171925464923999816479227567707705088260324253815128900522726,5123856245344699442960347063644568841985144075867098178729206123344695866632,937497109650566529304426914695525196119182564119552807475810542139513078711,824338985948318627675352935105995425917124279032809525354560876904860400681,13942203133811236390194976449250445722833065335401645546668049734024419803027,21193497547768556525501812324063541319364865851059424372272833186043647143451,8250588221665279725951753271334754148372733354841465281007604695074534688729,19810263445128123914159130235504848033923366950322026683325764129239721093372,14320576994914109414332501339118128158228930675887122896979269439627163060693,18889264041663920880871940494605753485014632588652805059026615325416030193719,10698608730721598729809918763148392473410663742558667693804099019738511427166,5471531298285601691838160103499608876767872950664004448938449413930813358696,11457601248269622750970644898105156673192281665198367584690238105651871243849,16992951642443963917535033612483493956841253647152989134657936764458589935104,10681874111209657199770620844475073359855652721773538207614365548304774934508,21875342192304323235337862160226992419479798345905340775869689347883470787957,18783598503862573040343207522848147282351537545213737188311758281500392127423,1221270316640374234025430293653174054626512367600614548099335037611485538579,3803127350594514565431185919859613836470412459545124433755604579955078714169,4692704173297526575662787527414813729052368393667564364621548376076502682045,14877344233698668087821753402566363996983618742746012792982725192235615274582,1054560579819817802724755404438987869385528807680314510667741074193700268397,8052216208184446695555642950254618937388238814298100142455645263386380520432,21528486310986712871728288619461268100617012373791428855787397091733571140849,9607239927604256097021258716815750648977424271874860033430637795556811442682,2196312812082021938532541315765264710074289763312450521728804241715253452502,6605540160838083938636248853297421723407665107595785929587574408377531474397,6525948153406525772960169117380395975817023461160134354401655738067058124631,1003556227519998429556476568497227440137917634405973503866888411893650518666,13677584968475474622689223355399150668790874783709262452797580070344541448836,4272686670447940608576804106249107479440735969672981187306042096242258850880,7723948150633857131095670967217469617626942590283045283879017721699420758313,9563761958679910727099148022742805150896356950128100201760652748527446140573,2850052690445041465388681891454371728435601558220304706587137488583335087257,8526775100524058290507772716277462650712450825299014127801740914862834880076,3867865860920444582361195032750323847757212456942796852256870663055781206979,9531131437985240947539412881613144640386246585015365913532093261866651903759,7876176264763636659141490167245054739857019306622806711043600468363729864093,19195073274099628437757763039411307254419435216466391625117296911023053159082,17201596318516267959242478674525331020962456681235714852429128354797936423512,16429987001981270427843548313178399452962937303668954688438246688799503164984,2808058398896238113910841463946229560728543614115874664163904810633100174930,14219106904819518684382581834179422938681605045169559176622588393807041033595,10530037691301443797595179975755234137332257307745168342967468344289118325757,1780683171090951191330938815635375996828930714110381590102230999415067289139,20631152509228411005601100836698224543066495368069041690921190101674287477942,808499207021654020396580110067573161997188131641925849629551231827774305643,16396331554632517617174441423319546296247483740125085437207362257874071846324,2856734177282633594896606301173852733142847026457749184584827572766646232552,10322006004350928347565262203595059371944943723449117022023179276501731876345,2683049508597401695548071522846046195699870016352617057472448981851954812059,16247545910658018105089170383534659574306111291405960552997108542031333797235,18622054704352443244328095600847746501599243235049513145116519278941866455272,8702183185743408572844482710294629749653378107594727106707156268893318308842,14401120539669001367195063486710670290450638416936122540739824928865783084126,1008932491940705147356558882115440120351684984366727805937095853000783157110,3335415470820584035672268458205991064638866247863327497697585974180788121327,675348271572506248948949205284720732296364868854507020989147277054109697307,11425495584918585085965114263893597096866227224211705734884180990929134229634,3139501819004172358132939651256683854267531704642601593201346365873114559764,5783084359807455756426365693604321435940832494660634548089377362001475784943,12095094864547001070709219304829411865589880746021553931719922191437710414601,16318907049539057156624360879403805284297767691522365017367114160528018468654,11395679267999229912686944592292906403252965050428182621076890662342583575672,20304144520028193526915712162937805381528012861129116050582705669151951550558,9782367134866186358061353221055410602027546275400836771195060684844149613708,5028029607389470804476265609647401798747012470860555590083631854016382301797,9007627713847325367341162188681367076476205669132463414398773746849014673910,14471089911822534831111187815987523323244485794708545360218598163622346282781,8019180100611273479652907195647951337613619920735853449223048779220663542855,9047131412613791119405208650892730556330287685760678509615107996866748231916,7335839265467743759482091707230237155828204454352010285192894893585057443442,14787708665825803366954624175778735065630831061644057898061768895034788739773,13527353131634051756987040962797036674382517083826397597671775590484363794989,14976182354818370036095296869648510633049821903988384882639150664375161429327,1560099560219605560187324067315095140041097722845226997637592687804174779694,571671177230396783003670900588907847431348620829409362554250135027808522430,3595401819266532411007886403698316446251107730632935527816690692561072394769,5582619801223860759886119158956613012355932421337001876528290847176002785551,12913958465964733555039885816821695149723050623118481194340346951472209298707,10229385924925018504492473674441213223237935733123654864337438778499472034702,21343876046925805512584981384457719270702482935633311830189677174062117124219,6420204451041321645976980917151646516083600244123365393849746698818033299571,19251614427061141498566572096097506725955838624383486128732046911906166384020,3637855341628865891325364423447146770285076487178203925892266081818756628695,6291095057555542758591776864498618016939082736178179913313186141723218066258,15680673126007380386463552533962308522676179674235002556809204723523731273305,14161910492383069106925371061927425194676913565753916851706224000847740857190,8408124204639665996401588312942126836254203358943885876199057731364731921137,1799578340300310412035304211591366593871976523584701800579066126447600019902,3622312705549913151631696033404711371424834689912295490477655370864706883384,13273792131373119117124844835198348538764494606049066494384531598904652565002,14270260908863510838028225519201826231421616414346395482851862560529215543207,1633715375341396582749269086363023314520014551113162582725277839347569228786,3306641014838747329624593360740422499925312234577578401365800985267347686108,14198045292969051397674853108255956449504264447127690313478218267366467132592,13392638089393029927126006202520304645547980480174653070691229667854016527907,3343885948493512216041748082192584170148231918609106413514016808164860398278,3168199878854830552224332084447744849594328418779455928665560385861883941432,4414580242526682670231711868212166617171432599055299074136917305689841663873,14102753845056293060191802617344737652392043747319090694003879675100249630273,5573924339361534820906966230551252047468623512376332682801232194633308271653,21326161716444219551593862645873877150197335577674154159730974795774063715301,19432958264517639868400987651848393946587739437911153002798497064389336859842,11213890749343283806487445619338898013466071000086191642490563684623068539710,9198922780305686612592947154769134303077110139729181291466776593119643796878,21136183246673473125620223552691909911094171966517655547561646692807715461191,18418245895226184084223713341727403858051315526021187444511237652982687814864,10761950212602122725874752124635327020166823895511275020048089638533400314021,16715137911831586771799460729625653907150059087921720918100590730689273071536,17773351327415330719066508685011039352345666357995827941409702750841801825772,20231347041576378765333233596636479502524461869780149044300194060543432934519,18064563634590190884918686050639690971635922850408462075670660991277444012424,19311806793959939929201104461555154688516767798907269687984909834335608414545,18574604846458382436863152415585348247597412723601050266815439019897542533749,6791419133329459189167506884324613003818238896866734783035998091675242101498,16020026112470750192482231650248429937269643957555877460849721131766422051297,20044512180053459577124670295358045421070313597307221323295226934357969810703,5766192039785553259974801912149788259566859976619902528741727877731329189756,13160650100556144411626475539530712035286115503483655434606927361569861225444,9256036311849117781394603817644061414251138927392105895934210116699839233747,16660304826343536533933296919943639532544710122612011090406376521894383168856,5613106871918486982198177086366936520094704188389198685078718794779139126942,13070598684216243718425316519583985756848433332087820965201044383296972346897,20442537178749694119236982549472062379434941056035907413284316764767638577672,7934380525369255820244941077363404413659578389361986061643146925957595190009,5098727584136148023264970031064585917675686576590855834683443649082028079965,20311250985440103383589841574737981968195820548330595923330987127317084128947,3768224286214159313341476585351274256214081884717440852909749729584659454712,9851045187544813632080431293737874643968516290829960553238754661188963821885,19015242154372799267961042586541854827581444440949327264389997835941454171864,6579883332160451787803375748174162900180016921849643588581107525271529605849,10040045688615204420748720492172111994988850765670088109590569954563466338788,16200830095429004437461800470410149972585288873073724430176128378316485348605,9682955393234868764418991570718636989945366768432593131049879027562290804128,12304247432606946020923001398973669839540045070461170795482951827192644001957,18191542513141047176662091981681722742011120542435182371090664849144982674881,18914155310347961884616925389217412880576183372588965807237661684331120845382,13251661686687775186900604006618374427674252707179991219741046747323389941232,10249194086135063113459170280632696947988284060709952681203426883826751049011,18372233147890747575375422462203968154682646712463764047424428288714397527619,4638790386282413677458315728120268440302827185471341027696814407017634332517,16623961311962310335126734990913554770362581939583424145026358913546809927380,17860493200690068167535851968852986582339867469465298666834410487621188113531,4608305735853858774877121807982873005510358307902418229099062852681969399389,14245817054597951763417586258404021745844024655622942045401677661648532977993,3809843434538253198074703856325693344260532607506586917570357443895551048805,17962207143381407459791220803798424686492359980872541932770670422523978330935,328196272784453082510222579442282995329426913454628381427614217629272010096,12374354866281475555079168690683958365929973901084398491477273797832999248789,20853802547446175043916531515983184048009878116903616041233975407782898112824,21496110961478435785328603969876614135441859248001892605282920516413194792470,174344306580108774551764089189043165870298462272157912012996952342994211137,20687536797191141044727224925607387673330130224876076220260820047611716395831,13067331728561732140381851790951434625007152955086246816336518249186949048391,3797862935019829095677036741096081889651388634128316641681020782687008662828,19718547173056417343715166978970272483152981364164960220358919266690668222316,4038867288048886379019053981446145278427073511478003014108759946240227146792,18486919751583655613568544119169758176904901075587096135301780773087898879007,9808503221335286135961820380426080374193561918865479543141400875074697503967,11673653729232546119337900700609058880494248359777926756321171038104786463073,2206576012107962093523647385331312771747616647783007209109500521090968991064,9800772269959998996051474306860888030671933506518907174943285018516216530078,704115937219213713489981656324169840669771632134921090864597729550810437103,10450936455424589171986477572900171091143445830786569605988162504754224051029,21102186642636060890935221995324710172830713161820423345683707273376266063905,9163879187976750746407679763920281609583516506018439539723656773309855786163,3472157821801145643950882966615731480318387993084591537527672102896556538908,2411890225861629547000508300507629335095483162292985158748687911181232049540,4985409929001444812993021607654361988376208034496482520498705351994820408485,11553789937761176964063895958945223002657928340200203811287735666719305693830,16847788791386791842258653027481339013349340413294800029138566625971691859716,6760556724223230789549789607828387138865070021837886343220335025271850431529,20596400847159894247975659733452116044170283916549483164302854789226390584120,11672317719239435686809215238371249803784157167042393847476181444969645566102,2540677976918908199177572390470632080272842549139729131369041579508211107531,19442658692908544356400723297250992586408893464353224580638700020103731410947,3126219492402213962620193562481318950501969435505738692018385930122987610651,13815812651475874136168661258439176421344570120756240838952907916838907109528,21443943680756083274641262528830913057368026549878765925197792130996882062057,4605307168758134905354332635309004486671872776946937049460665298426311628483,7482893834680785986692353891953868933021236845332400077427554963067657007377,5511796194740668281350270549653399801893104530256753635073935873703864854017,1743641818114051150153510266165400817966589635697948934570080374390326493276,479348932723256576178997677888058436058269610751399398192779646687149113652,2911895727864385123299618342188487304466499987531177084686132082340794352256,20721945554748282229818069151690746976633856763939126384250406858494706697945,12250582445106986808691543043877193096050336861542243284061992098674816799798,1203513568724767846410309911297210537295690041996158208540636591896498697618,6015583439542775167098811213988699848659623500530189193065070507681443523926,13090526755326389175310761634465981673176179379933796187486632857997253599596,5204691423542830100481358117753845481374238423707185894207602712512441617128,13451357406880550276974168929055560555273701366887507611491312211347374906677,10327523031922710495308957226255708193968398139079389167803483310323608563088,20154372727310541088852354530646786495003018189623626400646862775892232254942,14022574434398251358742711545518515409780772767696241502841372748111287365393,5800935164580219886597276061890276866350374777469717717325353972942679889986,4950159996548574497193804912590478284182513481419060390699450490223901282265,16651189959199821925513089100199135327590269582473005780223712025001916349248,21313574815160763657406207917526347065428582824748947465014119238740065134827,16527537328830884258876707902602749401809299353104838028680907493128406403510,15328203752181180061659863584748718494669846163715366299567183721088123843121,12748724793783078481516963303490468110393403014501561235873124284244901317221,18960625031156828010763136389916953653374660277691326636541170359289051172470,3539001622988573864365704884620979405364663891195701665878843924015974631139,19440492503123228668247641573804742990539424862427319298139890001019307139951,20663734806319981969735713814960326046259899097186434280597673603867647826563,5638550801924521462873676353658824547611149604620661155399127974706744652941,1371302213304057480201653073728712066696195910046203705054614806040591336203,14916746318031473743643312292935459967335724866678950897137588157969538011797,21398978398848411648231431125400371920346497858046605440294787662089399525957,17030308547789363149594169656019066171879481623126106541463663868095060483032,2440921987343876776494963936103708492610319137255329185550543355589457647052,16578274606037635679209783094809437790602872464993592428997022911117833097149,584917957795662537423624049408930838570931949382380283787668885015699442922,16787159358764578324620871006477408253726184555269443751955596568136636185295,16078611438600534298861481344414944861682463507987217038328914463538066716267,8692607842423869778858860521189757647588004328790444839011233818764128397786,17461551965098847063794186994739508584146822190403534677972847044656722703432,19452713388671907333636730760656181158378071792518077405629847148635099895953,12121230247359921951208053896624893871654915559955364031951409301929413070034,4704830575919764561517254527427722789804729564629801789022427396957683932024,10670972751746137966064978863033768730585193577203300636726301560193269271720,8049285218762936069773906017628569610476710004139648882735854791085139873871,5327956364112241273910968805653529609896670219677653687154759819173833984314,16209531049562245939203780811684066382629831507349840609244051677227948603148,2041493598600414785071850826176044493717208172684229753087779307523403234108,14983712813504746225033809615975227528832540720868897893292242774973221269350,12085999002734552992271490964670175347983721486216238101789957598273374406404,2010148192415347724117376912318888220341164166588569584654147279107677185092,14204865408877079652583508111640133693635228399739312350971609944706493769468,13330601146337713429471908542961289712020817519764634531830442337284933922809,9363311761287060295640718461317428792455498134298183595944737677775311452049,326899109513011756995862753231193478723114246336082392308214181273112126881,21599711748797254989207108046977874436425859822146104148381410251216892766416,4801349866375335173289265243677780019445351052028447809305464229839535867723,14155733033291624452674783678844450106798515225633669031829757876654937709468,6249525168453913775215814309255487077884826362528424439922890888603955052499,14928369633463338040897134982481546746234350670771618196847518086862393490357,9125617238450534926549876296505645845116172794938106232962454586773357787390,17103886312678741706528259762965004480595318892735191450742885850881411200483,9561133527164819548073730465187187729026229121272078865756229410363525806403,15499339092812475393717971205752228601033972883632736148845868837711619810573,4039978125105304479934956398755842410107811106124175538862554473225969256475,2947887467809254352800319275622693352512539235808226814612313636217910816213,10793550355337981917672616521499626144068251539193270238994640132315408061844,15282024117559604646251556024222379207458577842775127240432856222129525583388,4938487600404790095807201685235688647996095712925228362099985579653367819830,1580271313232748704254579894100134003454608977989565849293374431242287188203,17650488790850180925611249978112046323146336603695505846749648092705166179072,6318477650409317961441518371381185077182540555690253948041195660104038462403,18703841587534276582593528858657361438697750302064291203982535124189673569022,6570410039872146139634976314211122538651252189045191357367613723647837080131,4058984348953256905202616995215664252962770887032362374636631606975462596559,18730155671005907941866324013560951043352315199408210078231145351355402093830,9651860366009425828519962206873795166909640005109793700260660519169015873934,5838396248515026677336009419348618624164637668061855829375740686597759055073,15333954343347884216807246400300286008899152705372200767215516907035196412750,1930765848863686695612705389177613542562429368163669004940380022708446841540,10766617427881894379670242247746203663519351900247145805786260703840625869300,5568751333625760749025074267385171935854368145626703295693077672484816860148,1572988267140272358245681202814159120843671145631424724491020423275325461878,19938390788588115516825752214441323822601991108943527563767657270216212171610,7571912702211887911260059806577378242621772456912160075153794388926572849145,6858979093205494695976875629144179789647553123886814202229119872013338208712,18762692183810081055439753242004382629435200839335768813270546391733006575124,15741259924712306779754554541398522471185852133913466875986860727321229948852,2627808396704584386154002253183040546217470699174068260518444240974395718442,13588659892026426409480708338634242111974891480475426278869635762077927444692,19520457627758833811699878500944809253730386938893290068023237193482219846683,8924178241223608091232956607418048641173985923478293687667819226283386788940,5816806026738575389886097663948769844875803508574710698349454181988557080269,12475579687915690911104520027833630083645170013159764349224529153441972577879,21056333315327274333873056478119184274531121536034759580035646721078602460263,21444457911856423029054975409869505918084415765420838103204937942386934191806,9510785855264774762445687543927870120017463057252636764104600528992946593471,20924833468200564542464376523632289762564405387275694375761127017107713239560,10520571364539530696429244627292574117914912315372596265076914837029323332385,15676633242665585964368692080238475248556973102970746891067091503318954352189,7605218463440663468653884707661331637891252539306862971462289235362996643878,8655416175027898012639173297596079731611447754405890380300192905812736625807,6587158966606269464624627411770696301475420343587060761712532930272301692115,17855802086555955087208003626983743721607218545075932831175321330674668519051,19637270878895908891611772385398729322367589125936403809351999767233932966110,13844120079506591315671522711954211929776840478156307979285069853392230439385,3896487627666829488959793133071741228529962458688538373863209568407375861949,8072922412250331052234441827200394762964253395032633720559799911487619573310,3446650687448682504274462997312106041057536787701884723175991150707212663201,6750980474265223706441237350209360446038939446132826129894534048737231433466,7932667749655660682554204871450377554998925079055538597319130615505233358592,4551937123821223485620220711817547511116227596903370212234130807711068597972,8450248183513826743946014093205824327880033986070570398677443659142729011179,20523087403588105156975104084680617581362696346833272310988747947340344564064,8021873326844086700417206574915335220587232800373998588094532336448721297757,21537680614486477925570839538957839593006098192503694567393749587557940631967,16568393458463797316294547173419555682646841229029462217197639056287054602566,16910235738263410812877183305130636228751042299094737782744154576712268208807,5629150734321853465674510845327410940323442617216962413835214171701329559576,12765131184498380847448550948920304867469527623961001350816744753387093810315,9954645632746218155245325585480173993199044803581756137160936155060542951690,4353999640943599221118281386228426498583991413938542575297776232303344359940,4598711079993417664489400987736110506328223791894077517963275447468098340703,17317745377506102303500052440899062192892945727209124468437255966617200532771,12259326473392165107331141130100680225887121989921120777667514143912156322366,11811238683014115897858309619999599808008425203222607881921631505596453270838,16699081706307776306233318220897168744889069844294482997417168581249408879966,2568026780472621467236485312283731374848886964214142251868040165224695316461,14887991441574434999687627633546581501365901473545173785249018184685706196387,3569299155477721143892535842178855295807355615071744617918410766174933059043,5498879700681283951662042539400107058426136148099967700430316029080607629654,11559660278391175834668360323261696294263059777402960440249595574565141656556,2245933817469402341452987887837905070237745132811239554297372991710914298182,16951354954717164970902473060335333600574402706601527686301478774700332367102,21515931335312240603168050753263038826093559960430063520103206567658032925825,1249411708644964091210440756030782120444589186855809089574669034358018078687,5918980335509160299664261285796224662727132279493574691223062837411060350013,17739377184579332650035245294019601185834503109963479023132769460626331642282,18469744224495747473457470133545294362819142862108342977835066995529981406258,5759336781416534390511113561800934668877971293662332789437681884454072500101,21332416097583521698710421619829192185814871724795352151990455290564854827164,14991738373834450996520664429440490206770501447625984036209559286781489862494,2292383959319987392245961291693765909376521855421393945872334290076611679644,20271880109317422113691100242542434637543023179088091376781918851828907851136,16343203714510839250939280610780086672320399980775100100207359519193914733737,19668001496569040779289443981105684833630116796777138243208746501411413314400,14867270521039301446053304216390047301289545979306959364422905455339336587211,9929001722154986846461251622116577110986506194975595510541659282347340459331,2420696236635890839197290329114608036709859071844599545644710485458818798726,7023164250260724184662962208964026963022579890290101367655364067452762770181,20508512038053113727358039673385440054337319672353371627416928672143778575477,824002554707189532054522614675201805472052085843409216867120989167259938133,8081396930643908204119214488991799751072819763127464506132047127093449268743,6146669896192112367311424975035875525640347544666981144388229137148737996133,13917552221424458749711502489369248582964839439204214559672563587245770000377,8550914481815010035465313609214308578203171728075688232687655725801893823141,17861710896808118014581828397113186358973121215643160735097781787683890541230,15595160929818874035046864313228963482705740989418337036962890306288699599497,19810339910854592376336564454416808551332919752503671392907063850461349060479,14234414635213293332305234819580453743707554476430770368421971402668862484872,19388187253394163585379147543203559718098061800153070411989058669962446974654,9996031022330018431773704931033232677865134703871368350999928908636869707277,4533799599412452199761684722747577946145532223581271248962115254510905734009,21793143524581931493773122340799146504825838409926910431529124937257399233338,19692292712401787423885461139555179726227035221831860547833110141089023723875,15361825934066824966062130821388513267446230286103312548685290096230989843672,5736434899097417592114701714539404395501559559582922276628268708302331297718,6034516841645751575815362526363553327142008775019507199148571280847313939846,3103941851061425456578524836013350351780973108926423482048781831843642166611,5899337062497322191697133509006899741055733585263214548357752956989422491317,963781557317112122222004641921550021210279319264222273713987285679221730138,12218612067667826360750451807845242059538814081271178077944945859470451709133,19859087159769083790343803575983864397266266537354870798907672197319357964101,19984410602577911276019354715470427122599274838994470055478829965861962241047,1510088699001180548764185585999030426586790568209473093795384481408826277110,6626530934788897049551186952232009297818099583639020036000874279734503731588,11102385732315753875246033828526944990963999730005798544082045825035822583016,6109966799003077547022556221879889867437672084424732190493586606121191686895,11639465666095459063122039730377449150155515188121884615987948657973378713177,5087119226269603720517452201720024842953062937909041658414079638720935374157,14200979596305023031605438052846373683912540635435718213758112152603438068044,10504614528473632996392119937661213820553616805799536317962705212982659337252,16896136248461578519387122861681641687612480673542507251813953270071486348436,19381803511891750827107737252264239897475475490344583112691529084617905175082,17541407330179013144706644068775388402691308134663811736351559302382670708984,15072973642203756087665519422382641458207399650896006837784917038035882610771,2308847250281515017414251485377760361489324048295236605725148595795546323946,12235376578863551481515043248404435233298457594750687771966106520323367004722,234919702386651406701334351738513931283772159856053034152613436560637774413,21637694258900941342752268794989465303386552780774074413553118735507317693719,5017784917192017182377763628730148212610872485218540677293490321169201123948,770314504054605850178900177028157853527192178178763005605945816624700149604,15876814891128030074112970202145286137873841691080700504603122203177789175573,21396093758862368540558980838454280107203592525118989209906020509719986520353,12395505038782995420136281017345429633379095201006284425785781752730355509942,4615582568807690433357570528319145785065741006112040062899881545600179737110,8043772689074175830138340191606864001269151441770005593654367646112660385954,5087060495541107066427394344208368671085864351635929517190622637786924485857,16943670806889779731197043466545390303516518769717829999301840370920339407796,13534112488771797914884729261168139500575711545907958816183168317604824618336,16825197446319806977233945546803116869802796446301133858223973227155555550786,415637162126135168159032709770391274308945193836031409779140830879628784155,18387406758235678040900363524694503366739497074863830200933011303909731885356,11179137042211084753827842203552443809484306307318317082624519139125401844623,21558283039234113122805760097265638181763687038555764258857715920818106215523,984886258318300688046776785673289560458722425831829175079944141959971496951,15742677322520864401961943379313620949320295584851281667782848443614715444083,4674404119733957791400958869998857022224647524150794463860851329191601384751,8650727403827795422786989886519743572356271096745868930429292580249174286422,13805664248894834838953946033892670782284990791974158822573815009987148935892,16425836039758852245186956621689031634149287919733928973102442742483370034636,12636984265967190523588079564146349074168180793368546716527682276529007569774,6817261026014072560057398041777830163991050944713581458081292224492038152943,3842591846766588833800550804121369117907947886204778461433916219752157723658,37271592202861207450496704231110333036724082963271323982767766566562691532,12329580473492550135339911865680237906360631219143722403158320079104416996484,15059957190605121115530324002634619045808465757564252411076061916764353063726,11049964099753534691591813062197785153610766318641253048434615460367998657091,9547664187984679827610628603629867733891345475510185082362431432235944303887,18137012162384412674879864487567137486356542869085283721914855801046173331814,3685098687651674532509991642879131752314328195366675630043049707942891170584,4350994188192128309646975341689829464702598370274816402210557114155641708487,6257821888636845714306847817710237763041012260573089876542080703522920377274,13253018959425522927774577647502632317700972755867567550168937147898302735178,16128520328840705715994832968486859989808820923410546017533359121760378044520,20170678152633918405966535017048153387865751946705242558406886703664743352398,3126527212972403378701842254033672681067914451311377332339121677604578433846,6867262232134903047018643171960682024396916574079628095990181177262447593546,5158367668931323144529189475506903329651812153505452886267986731006143844385,12754662355373887343223103245500264953264637968818954284520990187567577818296,8184207275666143481387081482876989547621596168672026673494737134509515879012,18182047594483210481213043235431614943690478827150601132558952379296218497290,4111619186005075315994626077421177613466749589414703176717884282581714875444,12594743600504910896656839099899310633582995354714016930508253088263104106919,5906863249972407611468323572776947701049556100204019241509444413033282677489,1980080210708070252092652836439362225685565242001269004929621280778029319218,5317272650834519781155258400716302959016815255066834148961703371077671280690,6755929511172704567967900822149236127789264783942356076752317952971695408598,756653592358533438118443361825151465623048518178327516109550024774438883797,13279387228067311574007940426672455425799739197632963751860641037826906383836,3438061374000905227745499451129047661964429059615559246017344409320261233525,7182178722730387940200728260680152279805701386434851756285719594136478079342,3232238101879637288089008409532896629862152604458430213480076264229233742462,18349073713456068979069801924492847615265826078935260207982474961526062084683,14669461622305417414928378093274931180941168738663334898025953986981156308555,21025953377099738424497295026970813014051167806216418684116056037559447904210,5255626714680656571286256248936450375168592101301691959500945926924371301668,17282802977887473307860913184523745285865757781571388182716814513918008763083,7631811346302144382630250446520799917692672405169780636309223495193617534466,20646156492067995141068212601070346054539051558428492870963989969028947901818,11672162857509134152068238052735772663152403666766041363264045356497052787977,11887096806532260110007600390059506485935624620297229185953255478078857108029,21264877166054737412301473554803422700628127592263555002579170780541880711583,17943121804479032447858025131006451946994591698842739992603829945304217132668,21741868983463662771047103688885133076855201341036000119862339617136906339944,1382607011220387511006322153920014038613273342046755883486188937618436917353,15178143370568504520122235741397126257210602740650018201900729283546561696689,19508797361068986472532319429763120919434246449052564653746851758275251767862,15432472447501574952637182729640656917161000067956855273526749406835661136043,3646314932117173966129769917469131878046956851972292537742853525040261895364,9954239280150263233476434487622548184763162539776975088510280448547072413987,2860206851873890237457963710655623849107446413141590367626845970849894602577,7624884329556925103103971646513913063945080531848229875878001163429377892391,13360943796731806773064110741074091445121635972973177327949717322801106153527,11667836424651042501953164038576384835169183507720986280095771344954386965055,11905856768069261907772799745883705412557691028383268959241049562161180720782,12186322648958524087383458213507970038354441682650936942717890758775537576715,6206377886698888214976033056004148608870783801657981445534961772175420895794,9985786843211942401460306610504559890644549482837388550821870421722527522129,7131871091468632512858311810874313071133138864883788963707243539301333044473,6863753977467122978046292703800221264317404999280683794261458513920582107611,21254007028585610870255249088819596192746568962023826736493046170403367390748,19316740566828302369845437096994220205932229807972164794086423967490376053120,20911390901671963410235703071566058542087894960862283015326592608742412435513,10947283094344459246570251013404575174415295611564471102942451430110207789270,6629514866202977686466275098623310374411361176607669574816969946802287210730,4306637640746831336889157874035984930432037257905593217438853767758187627966,17842812026941818985973284751293083233650807309923063938909281923223690155081,20979787799837328650256681706033358558090809594843147876018416522952145532570,1084395234163143750754914936597532036526030294466367212427999310133490427432,16411000398229165199635990982959651490150157098065257264356189234661735382064,19529434083761568271396183578711196610141016284281861529889071952129275189455,16011589790708451889651677332030836112945970875991060135355201890489173794391,18538965510307116327958097310749618403759736800399477577603041239573656036369,575597941676167484590243546673541695594364334533047994047106268896055691965,10154888807896331879146339491538875786991737788606023861857914666322797287434,5751458975032524671409758081174846089867075271579936974413090425599016414105,20537352507069134091732836326103935751238399876923560688100837864640768370820,388393267636951339744357828936678047569934289925965154807382118853267759467,7988929055663996471299857775851374803891818939607048669296465149104280329338,15854279006908524023292733986043025770694447645646628114187722686173514956837,4521251106518907970739816189092928174098228189505033700492425014567434676545,8157530011801905607623371429913769514135441595931542848447134013030997901186,17210220909122096186649472888037140871466614174061205406900504999283153448361,8320732794514386532143557744115700882386234810376915665505736773284988176468,18545875500168811775790253714678031231209184655369087385271022571392488988409,1254781372250935292066700779746601577560528849791669968836092329802026798977,15937651643466826506099692353730922248216886908526960483039790489122416783291,19652922102341829730840072437940487297445121681514373922080785529489772301904,10503757973376634172224417598657275807288376059467419568957007645015644121173,21061128242218898797612547848348324784465891245956046422267179077655910293944,10184102990558905165359578703213338644155257878926023646496853865036973561949,8666994074867894594122739436332358585611317775525945925668413909058593367375,6295777974744736354234904948599345763309384248069989076851179466032501025536,20085880035576919555482594174603593248431976403050445801147514535176924689286,13336325268431575611445366940808804882241012554243123490613520755178670444338,2851570355537839451958385805591947257368741486463662868962800334058987150319,15338540229139367100976188303076834527818508966890772601613851240301217961568,10371461591548028790292642751110580057135152343433828303350260803216047518940,4721084162843564631441880187545375946421625038671651491284453281351611614059,3995968148066851603072141668595964652983129138292929197582737382184727007080,7098475965261931921667649758515107427024701354618287208328785191069896296466,4781012573672976409656547624587641549313089733225902702392506095387529662756,20670752440000061451737406274881546918677944716345491651236710839944182745380,12418063571138285842036790076814486174694060062447109012153384823149675212111,7811816758498775303698763826175925041786332617584902402713486064657610670887,12183449593956360154917192849776155473122126272381798975678273623416489913308,16618893942934404572687811463808390124523121286530811532642072424179325845074,19406638405969722482660214331214972298000686566522726077456272338753715959695,10114896891602590148908922343663289384078633766105057337614271468528428689648,12530180531394196901972330325311958484582015641092775027610123114239686805374,11041683014697540482690315932778449428117122302594146671576370088141482310955,1320027017053531867758788220662625751339386035447221928720928792758652779021,13527787960362675982060947767740337401799422304150087254060335221227857899395,13729174130954201937892395283664312766703232538508820386345658917013576288760,17930242209772558948222336463641867165312462566025913611385142785331060524930,271824668681816275326818116439977879809479607030794905583278884369947027319,21830554400118502077887728598392792929421142621825963621109394022313090676569,6549136256809735363529860847857612644334750418268339758975670928910634751983,7685854228210998769567354902455601859064733599194469796921674884534065104568,10199783250519025166562439623829544304874659364288345176426181874053651581987,5943875072296398061174787119165901172801385563744445220331957391085927545285,13636089974665970650510341064071559084615387545694695884611938887433039781695,15691183714733597776429523227229000727289026713809002490626629956876436864306,8559680887315082801378048339294171503207432568538176257628851229613536726966,18821447832687547445675145256777518497433117070692725937727249438327468662992,6902270693879104513901555672223877604634815519768564032457887408714154308149,12608804561676097764962511762420917859780577008987930524021637882085147011561,7174750477556160125005376833627217199860110410544187422988321767638233689286,8781965602133662570225157578692327961234407570869748187793896100695809894931,2495257954047729673944010345252038964921244093254482708244520480856454194795,12653575930477027537985334989917636556832984698125835912664116078189272484883,19470590483773048893847572401709923514063082100887826438398963400593333077944,11678017778870321267772215799288011478356485408686518093768970488464471570815,9301784115496434107640350077213193580405719087632828834385703690626291479546,16099421215741601628246289398699744194733547679841291314995675269636375173366,4867605962743281143953362108297759970476738545503236589613425112307423983682,4859206625232481008184446590986037965722621081800881620559019195768715084241,16443855645256733949926481287606183123363410685496841842812427755007713532892,9353805991413463049534222956121131872491808501219007024034024595326412518624,14757310122557726344690376086282772240920466622515316103858910465445116386412,16114284659120061956470765697027372797086020387576070056735297826889023849274,18127578981196629851526283391389653885301579188814495702848892722544020055239,19887508599212070022669423370158309019634146887428772891372609912344825709907,17077080577854056476313617926548386910187074435097123438936357029443634140037,13226301328255541197539849574625779242079524439809722670248005223174137129917,4960598616057280250789993806465640165902417481299684068727179165412382990160,1556369617946500605910052041338863524761596681612901076288655800401759143728,8895728155072279486251055328673751534060735340135019245331916382281698263288,2289316141803713796617375788451106287296998047295030310234564594074457471782,5743949466604344050156379807720583796608463915463812355649877415948657877907,4559156913695113135073666675680811432586708455776982064075705161369076248306,15885688417651643378493200422346595912547116850227590423936072108251702846077,21139883658951849592430718453383511736537035608453172046329191674046781461328,13189533415954149093943176775514655876533454488327933935436293535694805743518,17844001788757965004299951292259913492254300676101367510089343929865197748634,14359892033284780014175740986504899257072848573639227540808851637993574775227,6889876198036781721490463051636227217181360455045088258864933221139868422058,4553935378945711471651589030479778870996380701114996688086418055402491525866,21810472237273957206786186837441232294905360772841197216403531161190353859134,9053152935239668672905478856994179206897589996100634932367989982680043213185,7903591118665286176079138425128951407213501136276774569998580497121699548452,3172076359801796733031209099819054888498110723937314354878294115265190182330,20407097360746745587552307442773353270033615342704398250066232913190814364080,7972160291863108260254701271534596191348694866685225653124288422099219831356,2512979638327596184144169725891221385374685508088897591186666227523755823449,12288114406943148383409449156486826621388266177895423682705260002640229785204,2564780208026103504658010005943517057775957652807715289383367743075323562762,1819044074894043026843741029300477751989386054356309111356865205713103547767,15212165170979376853314159201892286112393022743512259361106527770911103031833,14546339564581115494538806968483958415473632518920533358183015375037245948160,16595063968058690402196826920205083730698910363019110917303832709685137640608,15141874678776355759677532828036793885858184118820760885539425739465598163481,18904695587436094037528024957965408339655627593105121455062940021234808627517,19691835186381553427610210595631576698057108693742599090126967830113381498354,8924094782966746617987215970302687574282302360164926405994916025579749820763,19703754039872652879247596753980834118500205932499483040527802680246732547089,1222369520366776525212393255592594259431640497623436777492426726914294313696,3172344047869282929514752164510333501174713324035401216632890990510873753170,20343327187307675920101255252384731549311614062918830229591450503470004905005,21822953127524319865522817898285572788301109254914611303940997016471607290917,4119200650145180459943542547991468255860361677520024595215679941381226516262,884147971363709313208000703986053560492302821976778288962675801741886201394,14179192339259619376051698338290832703239802203346051877647263334899616811424,6257894125748014033621520751032796530871364895580315426488126143829369988797,17601756798422918594467038792255913560794153830062518652267418453154739852356,2915639491551461190644833247357672612074490352906156209159755564104341441334,3231102949049971084860869512445280179160209744399934744399854930563348405672,13021414206859086129077179016730508855909534243359809624497206694614763740073,19605385510680022189244399663099114503798708854480688481468264949015383978657,17021346162472827600023529413773560471771827295900312703532075252918830714763,797420759229039341104668808766016498233266139304135256309887013677831743527,2664903618363391534009727112222679446988960947334573306133164042707563086517,3385549618192271440433411525547058485954511711526716925876581944420956285378,1363918352372003902477247159358100870270143261694504161661979865477181878601,17725129391688775312434400553484246750421349715293800612810825705415551685950,5565167518043825254697387383458520114240098359236753821784350172714709788630,12992626143189731743865280272360549263209967124441767673953882659571766635538,11778225061486552005541072536540594809710403539663018251279263069564781285228,14855802626429861561613008610208237167206379805668816510881008293269978954622,4625126357862179281586979391899300109486628847801168774082540966299465334987,6276441096446918387723860737716070503136385106381280295004924708881687527278,1795411699207968753627657631153296652726915050129212264930465577194539027180,3713335398598470745490569816543380122933539387356971485299483223125101783622,8168117481656071903083355331291793306622574934522412245021942135108094609781,2572110912790333345146174163319527254651486901580412685997510630243717870169,7025592394229454054105021012166569277499787182283497117950324822835039311263,4277841334216388876550672363276475272389275617444687843049115977026804420380,13307361877516070836117482544809649307840244674059174145753388549462990581425,3541353704173386321602971434547681828071166901335602064587889348895191485268,7930538155879758019336102161941128485659185437630747910453735785539584502699,16450196550849346986145420593545138121140944184099182530791513972233505276989,20317647049317277971067996601837330680914292615460278222929651175763284855258,12350794170306113031197271161768360871903372891508108500893141893703359009096,3619108225491731892480788907918892224372271737626523316019551923666189881560,7777524276793695474644184635794903798228263960698425657257115554422141857963,13186962355302544705310483262369096768297692231774754772442065918802639434148,3194922763633786447595049582526939577788731446948460263029416154575517633713,21764951733983707370163229447076318279945301269175491715317016754083795809766,16974123712053830964644120202072593533882217585039161631414357628477067270637,7898037946204257594215947941255236785530939710112474014338432350690918260891,13624131700578417700359325726622999876995826287578399131977467236788609909029,711696429159123395134741628515974061981015372797792603239801873522576934606,4454694656802154477610657384658122890655367951456133773797632953453271645583,11258512209244601689743240316900203988033840864814099786180897714348264963892,17104789493255338246571119977680210285205025930099647162805883642403493155704,2453935444829235217884190831569908545427042660161097975703593935054598308172,14865321440470518031331143407868649683664573698762400527582797926467679386433,2136979677653477082590579842429661891149048368379361009535231454875783700576,4168503404348819959713764969732410335826536398112246387116198899646877476352,14962916637001251079646555121263487095246900845890500033998976380566908488027,17784806976263484298477702017969482877962979780736193065620735094916915015057,5811232683701857296108715612406368550641241305997590112572736833619623657335,1137391750177492513773516911880446733365510948924761786959001414998578780190,10377533661461362184186134231677823404558478220398261395966741229154302153880,18289640374707184240721457180013244890344288557498104400868875166742835064845,9860550380532355283228261241815983394260110595913388936133793178666677861361,4874241362571018447675014656968369345960496639223360836208429603461250621707,16865415500549523957415217905648921092860879005547743663493860402980518775170,18108918097362824701832555936428153547583210042204293837516231255476913995307,5814882735302537469013996470647050035634690283351899637246825700230993102653,5547108529079575186420571231950116618134926722630598104799502651040507258925,15206849009490203249915056590647669409740170384956300636367240071539934234123,1640644832819090575801198338202018591671247888384450305015978486631872758131,7653538136953954504326423293731449069773903668694073045541918594328126765475,15742666466329712178554069131786945235650635594806638864788722339397338233904,11117991054142148551955400250530241420008368948211075786946321189997485480110,17233487593470788370048183367208371204821743424889641470669677410605695176177,1026146833779113517033720464553035587620506307190537032842523110750653300409,10367733177218458884804949015952210383318098385156812709591442491050289560766,19795952047370883108661392932328291359892331001341014799939338429402797554384,280679929395977649114582242142346138466205172264485418126097892277002431011,11242092785741474644852794535567939603118987148698147008638503870866024069513,5042585848515676287159684547630780418802525904631814404423696800729724702441,18076295265515176256373769387621576799326851284582393083567912446445089657195,7379637951216509909219158222610656534687563904425133806818053082443647546922,3558112975941340025714332950698945379582897448619066846171473836063116876320,9573479360636272045463430387538379484130343682411115582933078720270296582700,15319039730033276973173680817870390182683166144884901717164880903880948070156,12614337451840522588925552004159363860236857822744920028925848657320885223697,11264872143423037953370674414336573063122101340016831919048747444897009600345,63551039484071672399844495086043200468124594386399597718753671627443264469,16482682562437246084957175194240509231216838776265462897558195414149416246757,13173166853778783824789219649923900522843999506901247221151336885046420684780,1129677032059045391430942335190974518204360360119509444502890845544005628775,20501934327919041700769005911882447290880962332107224642437572131655999551570,8568499318929533224876840771639984749494220751421895884374508523238084517848,21259500369117112858046793730986192593905655365067722159200063822227414197523,18511737784245858621248028192284641888665848600116211193811323135518967443130,18603594203971848110309624617834986072777858306337940642153570206399896731227,10817810567854821052648176407774626914880746517118466269332776843576340211709,11799868341887426863553231699803195039814149532556595741528976577115279703638,3757945008672794110380903983621818494776340526769633536295923729698796873418,21147309772231799704776665377393022398575359474581992532654566514687692622381,10106161080097685505341186856462439849936096425798398803226308955853233801088,14262263816750661321610690116851316864336319623922717953366014185440110799541,15141933436196205178645622716666344645155868155385407285733185900575537844179,2528094772114073897461542081006497820213677180486542945691028610950494870091,5348148742466995347556247741747876445951253226718284728036059196493410775291,9450763449774399387985728640759709076413273047954552646207186077905960887466,4298191617478880606290362740003112985908172107645583722035275913358222519724,17030410720819419348097350980058866817562528502379090451415524440163140111041,20216724013881673832814480585345314476760112405406761404693215284600396014822,3030458477787500523997196317647453871345579139634715247165773460115609582330,4498462169050723804654682081938858063245557243640516301148855502903911071559,21824371776439248570562107317467644300343374167209593758174011062336014366712,203060629973198497909844961226448148781283822023116446785885526153889141133,13138719392503582101372758211337939905779727766832919837180755391232674501632,20854865022095468190800800251894006373048202378274232848293926367900444699099,18588694216199791340977948229034824338778108765317256872571104367383806683819,2107723674718153039822163382990954569558924075626979445723435572951885590282,17271751087973139804430243764301653129405836972234862722312699991367221547648,6601353498913454241063626951167220829716071681800808284181512008975791453478,12008446685921630692928691914657961114819560167122558958661337441533504934249,2546793791363939452366278657165405700949349144309147725354170056455546924821,7509639228703028871971491982924543490428017835786144030628769546327315651842,7823420836979374535855612407590511724416995784427817183396908887631615569374,14440328435891567217327191606342183091806515070572157964854472183381142306857,13108790694241576486381404587677845524627865147145072471473988738194261674445,19983383938241398968439231728950534655853676209193309061102635732967764422018,11284194381233971884183176274626185331731276627680969047259362251065411330490,1897088360814614813239622717000987185543144416227464749796311263447835372290,5857538086726776983838909617047765193294143035705320425608254315461849915283,4535962484854275896801499258204616949002112470323390523101255172552516276853,11469688959565470671946358524828946654780293319597759366277869041848383938506,20012499472065515722935879215306365340460493343044867272369823908813586319215,7237913775106599492643101364689422933623029044428357142837972864389129948204,4449045505867908852965142075471111990333999619831208332535528566178225482875,18979580728127588847832634342765381189070401746541099544183581604411319882119,19208895793797113211677254952138771238229741398313608749033216609457932026240,5693339887541566707818870620263679026120058867908674300592248504295030161683,5766336473322649734565794453161873006745293312886382597938223884039108263098,10170500372500319676592379791726967782477062446940064561124188934689788907641,10715178415744481025577257316838846623444784908902638764026977772991007652177,9619234464729169347469055561718306819745671419829947117176160764784203967441,1725396226859654685724455004555068750501182150139117204170589152838896682582,12812488682187532465982035305360477706619015575668642434536603051988822585780,11634913038840687277143479351580381035995147077852960651195662158592298943782,590921624537670966145684975359593307845422616174883518035926979611039297697,6994357700776589034911446516222866144704328090940819982199063011389928815878,3578735612848960352693685408184960756564585180098599373883079061082850989193,21635405933646037549623279995086014983969914199701848464885184930399308788578,12427020649229929152974948764411072254994310665316587507041988661972823471907,5659276116329803541059701770846868827421187991242679567541795719989019960482,14409569205409757172710837837486699395207656272569912916147975142886221411048,20174498258690846561506592709929532887311794985051466436061305284714705004116,16144749571419779339987554753326186342500618892721832987727063682036648217899,5806868382318732909919594488299463205875390466419224655308941273678069453955,10943981499006299439884803446608501609107021429051016441936415463311572940454,1924938839701254827227113595273674646757106690922839787536830436278569286096,13979276902289154914577571664895855335838520340557113744304695510562836235170,6432081587087260245919599999151100148827877257649626745290270317469081484560,5063153002404552050282559105432952932908381495673902142745313078991883601735,10740439837861405332126185761433228439796897508030224612484767505999462329793,12737167379130609027705740172196108812439282784347836729589408028420120550933,9849845512381592257963507051167559787679646439786540183276617129759373853388,16005888832870175950940829700448047001850581165998249926419521156267014986701,14353647838770412975928759605442634240665383526900174470441397150591603642336,9246400563934815769990941385821129793696094365581285133233487333862515377594,15148965960125250145435338272790355289745702742252704183388935133186551786499,16453015856957375440870560801879892220374643048047546023962049108638908959772,19594591292469468407344408128396176069613863801953800169935974455228391704047,4786494574332708919915792733222077450535137127349578261762663721149074161698,11960730258074073655703739602687794653921577208052039888289111813676118677358,9848013027466807250590439150605527564079804116846510943688041755058752584380,12899034273953092771018315472337883592076632199623658827592500124277160375343,7444799755957099892747756300128576168091670485463138298855357993349282405924,12078602067619785815908569606330383217651816461769668980367782310218465279082,13207091244585343533434026539671489949734093160191356902826819065281696899279,15052325250252549646358568907141836154046676521102037138442805194847473405285,2221581370746975227443137026410298234625504939466881398515488592571828181681,20243663867674839549278772384366563405687275170339456055149452630358919741102,9989690042997457961300135390803031791688603090074435089369924996763771804683,2394175383139107454721858241476296570939299158552117381451586030928104650195,14935488700038770608988697394320688627203362240444723637257364275046157727507,12264662514829291661352518974189445073203160920355111833291657311513159477694,3827639321249325764386581723986872585672536887010319153929792264348424272953,13487908627465024716967075008462681337662334712641104635432980395748705243220,2271300450003775887579228062020983806396606091928055215698274988642377017880,9536464905154879502929074042077088011040150301676217212058440880221802373843,11224187363394886568032176392622806663752975492652881881608898287407285044670,16348011463839183311989740909923102224397330137023072134870626410011917574109,658746784212845073728972419644775580738462236799285816112006815020578863053,10913847351958014923157235635013414182776322060119409210360083568773647202922,5174660898410477334415120015192903322111803813558785977142572971088703464181,13435625677277740540867428279095038525759637068783477185816475988654675258528,16042236961096516425577672868221946711334425239903980281947225696871186016946,5966732498522491800452631630164751678119619125003570554878083612603498334850,19244421524004466175382168721538493986709062021717633087544245374056859990844,8953835349510092921386508744116096000868233729683707705475555286120350297772,19400107730527891751069598685513048198266948717144299472180340676627124394816,1788315965311520067508595535605409766732846405132796308898593684888230118195,4155306741635339863500551353079678816173576578036039224848730508326156410064,314333752297483020587573946457568012126281776266668278461087690408622762890,5814056308990522321998868808930979798909264311720790843253044589964499450995,8139572664280730177398240130505806903517588262678422575082094265546418213115,5891945033023051894996849367995027817716659752927558196235762187145542665778,15816119508706283096011330636590931848201515685282376441014894443298875354927,19765585883129509218113831432898646175337020355613337867993568030797990428267,7571142440759701899321724284276618755088451471808734385481644938761653631281,21372154727662886563674173359368281518527052830463392775221052936073944196548,7081252182490962865977081179238366944226264513969472284114001831030270956045,5223967788855971504613125877205268444815856778995847146009869071113923642838,7616031404430100022715089975212311635761004286094499406826744277117238450802,2964922410519663416704982602737862878081135021433460716313695716253990013571,21452022130413843576926752262576843465698254258090353961686699256674273446998,5615506565720477707126907662373732333382367798591588442255590186949548315516,13758529852543878424689721858680184284389257236387722027067085472062441696813,12270911407050929770266474860904788952698196744336477194920983584641315683723,2263765921105974400584982144019036516750696376273595921030243162454245412438,3726743207790008961875115608784686494039367610419333613620227882409630379219,12237143845448219572451550465877077742264329541226110387544727976984528388742,2409964261853228751087973651622025781333933822306168735290950339250464395333,10085433407143766997440158468408095154887290417940533218330090781308733416929,21228510717137782368419571997756416328932321564657530623869061270948157027291,12056471592273332515153939599576024781202771932636795778229482480420755693571,18213366556788088673353762707270651486693693110301565439057413547158475404035,16502444929714671396753943873426599559613041594477504659253173973027014569781,15099656057998038622782214961934296168421711158711759920714280998215172598701,20662687648270300297638887955756931826210498273982273406811895752232434295545,11319823310823640550774639562916849455005127799420683680222546170719181512525,343967214752520057864245186069476394037815047607811439097329864410341714737,17503305564468603693734885462989691651193248463782636796950758256530838277067,12741605036457271400687978857670758064474033476970216981099556950125969853613,20739683061558313403494347679816765721522415874620086168947803143944678465016,7946584883804172227025447539224245968128890222556746649628342784345139347190,8360187202053456670989734732945943173170474770371603015342370151451116337951,20059356712109588518115933733238896878411826141623495434229710888297572857371,8908929255369499016159063161703140212756115979036668550222341666828086389886,17260316215848220480068274186000229981635360232751196604952216075987952224195,16051483806631795891066047812303438046492064609198644392699337542232076970683,13616797129917979734082711158569544985901822934952385632710806021914842733604,7121878885265063724099916056725320671644022545379534508159519935129387437912,5095784041111849236518098036393508072376638346067943869740820917637881991288,15064740101319510049989912367011238454044423307266600930402588789041306100213,12407265211081220177754043474825255990635653794940031741483370307852381609406,20223426484470923566833281385864037127075416246760538371032215131656571722149,3668052915108225265616930005001596789890471435407321351170819088999432868806,11366073886283256473381607209905269811061951337531274662130606966429881340996,12582247379355857288799702955077607346019480970920005735329811307693949234935,20186938619235157734865577521404397515633405422805778974853873925656656294650,16122019959033821849412382360062366364664833933984337294691025029563985515365,254648902211450148074737989547563835748091091484232032343713819397130138530,12172833228273710344765296926585753189586602769025493553315361303084014018635,19945409419975886341220734130071717017479702410716315294907303154809664173135,20712004789058289094102947689666173023011192678139675809444116843756511650735,21105077263104009643989508074340105423304108979860049556255519287288188396634,3538342015671194745411221642090452794460666099501316339752121561502241774127,16008085602703591565147288064897579335322875565262127586367715180903703479852,21422197449727241817827580893411034314307602976542729347805156844487333432241,18799547353759539084890273894754702756999055145524208124647385295339036997359,6376647829380850860365386439681035038162788714588766405462355210239582784337,15847703763893026451216792359491847622491103863033823028942752373064363683711,21753518314824757010443592444509359716445873322887601064788806456493419038035,8018616956493930393966420225569393035642655431019891986498475494315186954398,11747316959744110931059298678334515105505609504722662598929370282308351440074,17893257331206244838570586905501874457956496735362457086282197258342214145307,15961328802051806619901962582575367866289226289028087772591680471434203677570,3236169926687880505076444874746358996739587258202752103445199991661738621601,187795190351727293099714304116924667408668969503996281039583636956966649638,239392318624502435385014551926381415338676314268675338353695671324466753801,18674319341781941734600473869568608233805776945980535084119278717005726916471,2771345443147472606857365655976656180452504182686204076714773790025740827296,19450913042313320002652706987083488807755986380163327474873550819278969177372,17088122609555961904069874590098938791545854926952758736324719542173158272235,4614324608780439388145100049836115973615823562529414178724078049067318464093,480346578559945500918475024651677711916332481019644166207062710283884336501,3976896258432286534710425248577923525874780501683135711905396303214796569813,19747713021879142821191045416534012039092734284665942138998895512844748934520,18114341948852128544591474427791645861453096798290403362024577582905309063343,16389740922636415377645046847550552757683160597807953014971200028725848855677,14347956677754622309732029695580580261895229653511993172444407254733241454730,7001790022045736128714608604018732713668075078108360908557371520612055210303,19272993806385013542500911534969336370461053778032527920746797814743961064937,20666992739220376856615766377753030050985727426420972006419425641580077380709,18907720165776367637548948232402401955322000052328805042740522159109944714138,9414327783699575006459158047005978347088459439117502202158387157394567126641,1092342932834424845294743018087259301897007735031966382725140810717192908054,3953337326499755715834998572085254989073834902724154050737740470058759118498,11743581671122680453195477167432558941219274023697487318378655108983631999472,14292519320039108746758578387893135567048390166844266988895150640926606231575,3463895766707893138928153619402823425980920627031760477180165727285868840115,17329024693549080975670914737054013479227561926835421032215803061920086593805,17069029917639740020306921281456148921331852897276386771126788265397483239836,17757973687563632162101087414879272203562112761746273122681647748208587693311,4657037101807059847480820087972588696422739806756490960821623277361176723008,10031688077390763868641078069309072895683953752120759377432369407780311740458,13372959422785941027234359900894463458148714364727687916236363488102034358213,21074689968655856473305620806477766182958744184789493409758269023421704332636,19863757339575916461434905195916835719746715041076078424686010055572742030617,20973060471220514134365115793881078818914475917880454352814198678201263612788,20786322802664930407040804724442246307149058272537433665345242730163006184858,13503324543441706240017837835235888103455201530371938269103987765298019164241,21516545371414182695629550949358554432241582789246093981854557932438611855051,4189468076924692882857105215398697213714749255613940842113064700527656187139,6356916718613787191898160559615069566270314091650855868585425220261360364619,5420879043826588690498755027108627480358930425000012254678542105050717051191,20559290756493460657385989162478253178529811977588548661414171937311774738356,7472237964286313816282734103247675024752524054147218881654824853569171740182,5587656354563280475935968622322500135733558246449238814064790207486002634312,10477445403396666334274248654801801931117602962284736619479124362799824273546,6964581565574090633894249931196779138063582556737680018364077690424381812379,14818621060919997284977287223747030674994127751231587714382341838934955054844,1561884120897562502024552266455149126373072574485245753929487036177604271779,15924114719216774839217247278498830109576711552882853826759218581616445364187,4632899269214938328686734061038562662617634605056083586217293196683107383226,414275447940334199421265067114189311498845927325050140106659496782723706629,5919841635132642392689439793932385370460582843320887853171556097049171723480,18213825499960993231734509662843099396992046367870190109129172304011496568015,19071949566664135927732333412944575018103341781608323568493744120181505633727,8055738556659889630969832748361502052460816679489752687851823555653740856922,18552532582629910542384644188750599556440125083583835015670173118025699825513,2484657787081400262201491424080522833403834349414361745080712757081157295905,16983418852456608800545535696543676988540233741050842886180695807863040864765,4238493546779457743228884918170815223308340385056120983013226844661472349292,3630132677030524902934720712211822367613329466140887879132884750998038269473,21054939309368014542663397737839771438999660373085660928983975055849174262524,7764728564558131555197022370274162477498111431299751237388301945333560774986,3593305607441900907267751550709584072658973999555174092879673804077111387503,932359123290353753331737736031582956463161520044366983625790109891741693526,4731952008769040870131753442142911445224559732127188801247458162044777478911,1306090977867005427161468095288389390649620350907397989639122170049060845154,7759081335204598570892984361955322222987825766180300022358547686895179745422,6447993445251075592811527795404536687284747599271434406060192746881971850885,8266912047004162765439491557705745929139857757706428454484671294796825044391,1314461175505921794571050454800604608649221187723852105188152934159567388084,5074821468464653205102869421665358795805465509804176663850666382476895922210,587081217806702661903500809062925367993834792468594461022841500167739579474,5264606314717935678144297576598053656417231843504500779254542039497862460981,1236480134248818593225404950925034920588295884010411301784531216110810413323,13089489778236095768305861425107967360517148121020346060932975978601131790499,17291786821946523371971061686693758035121148041300868933078085040228288669056,18124176342257558638062889896829524322479803409217207498687844328613679520644,9905839015283285144616603221521153361618378103985458187286841556656656429741,11809535677454857598311615002421831170743476213662971184893106000202355262469,4105258996829645758179809917480600473288889890938687299484408634005613929027,7249994723657380623014328438319457303659016324967581867420756005957067258456,8317023308476962783876206275099298475926201657427120954368652120829272222159,2011843005377857984465704450777581623363347938947142463422784260490016214095,6478487501062645568595261797056495837204909062128557523543545066559983302854,11332891765024246297067848612322823673574497640669814572890785705324624377152,11310396674827683007586339726668223579107272179969446205517750064367092175748,11099104200525710724155767594487158698174345291601467682384866473391802992487,9363361473795780293736671173763300702046469200956940247194666073284271734887,15151887186592767507545683753579108698447339021705506097120199743211891524973,19881265730819081878858384565138117903272592569639633426872725304622695029688,3011117599368717267651471428189462533336275598139751114483084233022831296797,17520576180525374756578417994075832591962992432186234756248866458711765589626,6155276852486738773749976144225301808688416984253808800735523464178476071704,8631372484444450448190767419844298467817852912545286035361602469665228507964,12205507917633391792796810613135648610406161967483463808645931187075958213927,18222453239521787308656394705559544583576244681888667325435264246411012699229,9033412577366915161372037999993563962295812571996632039862860993305238914757,19454897503553988644403623432258520403053811767663131188695520064462224816016,19817199370883464197796219716426529872878349643708961034403389904486407134637,21290720498988312226623568214384902017696056682729297309424737295532449054922,5006872489582777310304924776769064242968147807589802114955067857036564413999,16420397542367588392786684585727906891797023280517827697299749514608736021404,1300345640934139074405647472243803688216465663235066735522675025627248393466,15474333493788166084607018352361187159147026284793436327548632778313351493399,5141280817333171025837036045163967613491344199994520722703718097693724060240,1674845241197502896336080529694883486542569529162942594482168089081833468174,20749587232360151357799983517636847191215950040853109011833662933435613635469,21065338667581575565163875505871743203827212418043845343534420193848874866739,7051564661861006096495144384640210161011647325580302475305699820188085915761,1121065721208670659965039607998179107433568481023836429952089959263844401629,2114003185799450303041425285829091463889299614202766352631616657722513595953,3334382524507526203206024024777692800878664806770692329489928846721311223692,5349561335050661854855918228516028812586933810356904077294751460675531266141,5703041280392778021418588942391165300974701557007394123618062308100870196445,13673663050707034371520553032876769213055293448602317144467901970892454938354,5483873888673148302254721546416819014852587382013956934541598037319090821435,19318734450985860065269203041456593881321456849029001758521815811241052123018,12851330354839827372437628165464795441114428848058858241484775351172304561256,10041542640844175943995712334828870579034783871076347036534323366252583734600,3589445341963638025665117050103495399260947312205835568650192524332423143081,6240962307810325966231999724200767949498419326824465195783823947519631917688],
-        [5891205978627836991071144083270417159015157070199928807771268303875194037650,19534191765629085451497649051014772157774065629075791332793195826681584551273,5154833515272483128294702820663628026710043323095920240638701304804298499578,7917593571945709638335150893778153193741477651398934233734658265336884279055,5133163238095742835090645087711007173805146496653007212988348307349716673728,19458003745533910239158707983408152209004063097952693956218574434126899070042,18880819400751577287416293176849355951596193714265500681157024197361640709188,11433257809059443065528679883569438998689217744131300496692049205047550090935,12190874701550908088290603272755607342096152398135156662834905887211629834704,3673886960353993252497154566539843726250940370616316569888448647738018022083,15676037835112699420746702265028664494892600184195941373794207326709270851677,5045635616511022726309482514512221209262777381751689684810362174166837266849,2127981970274354891783037834911068612842150500572698772082540184222710046966,20602209860969247631763456039704661822909928028055826436834118113792574371849,4493454930923344041221912772221535937546211498548091351164191172571413962846,9203273896007845628978022785284502260659411177801743914849998536940830966257,8789969715987458351416076625905723956294447007026950650495844175328857015476,11215930522605102963220331022508304708093835095809374254680583403572809751875,15586225257380986275249577321891268850474446160605827963612996219805386502932,10011841080310254678847831138830289501574615297642717372149423820287945856079,18753960408421275836614693391945489354883623026056573684871883182548779915774,19761678450406536764850099419131825403291221931719095841429266089353917202891,2072721799733232450097521331054430993573774079728747665078766019206508544636,10615297085623730419003352440151421233872764050371800287995783143303761635742,11342862179098306415193268089882628716478112844171129584590093902612740081938,19276661508999391381559540866976056457016683157876039262437370976462342153704,3487982371390545412669202630006964510064537478038100559383689697998101381695,18019611455528497754832260490613820837001396745087990928355304172772344827985,18731969803319425707048526160946688629598037600738751037795347491343115736279,18895516979789867152215547520753345684534505439453679476362827176682322481937,8262582236770254192527817333585360308520228688394271238254948357217070957179,20124670759706967221386035867404978156598790198778905768160002435038055915086,10113512603622787997151768792636528607526786828914243169997168136386113705095,915897670578586705347124681284501818659263249883815809455861196950322359631,4168315355477923626825760085789663510629998017921421169386695143739645254818,13671994112691093230470350971338683534216964112891455368255908216954091232088,16886224211742114996348237388698196253930997227482938831037908300450123060344,3345133367703042017339663005080189359441174937067366586009093723866269451347,21528583089657067992968569213666076092311468898762774519530397406988724032331,15876161034145690426475777675897218203065468785806228994483284137836054650127,11419482087592638487692501143058453465931464811952523437138882421550619359191,4688593371456663565609532492788107789533208004746508669973851893459273665535,1201806670097794327812047975382630669548999745861216990648173033237996826404,4317641195125807665177432835324854194367911827066332519796115671103402289320,7278153623621857829571838333149240184056003767208572498343141321166882833584,5645725384264681461759518050072125001915558414870126637288820197391715227313,7876944044995178879031614460771670730631140542631541219377182212657483769883,1817650660807237476840344988506407016951597837358142384730920692904089879519,5477456541807551375261337022497006230056471139241891672239301675658950367705,8048211508931499636316723219242009338536169470228918968914286373316199192147,11051780522682663717015921863167554166331060525740053284975151807269395431450,13621239165564266256293257623306520070257833884735472109300551735647149439281,2212937635665982737914958126511628913962157442295931340442990688391698941226,15995366165560744217392074544914614299200056620022955679432568011246760194348,8186603384193770310414376291688089375415922904100458138117461272757184852177,19591014640167727612037871145675698427320771791339346286884839214170680861630,6878084246380728147562027775456286883121281123291292075367753371891198993189,2177050211387664317673794964274713735596159455191994291603735988793477650579,19810792753868883549077084303872022596455081266982011682803771833184330522738,7185072414158632003497987061744951789947697798790757573674746012007540132625,12527008463897431318214816404214269326472255194708737027196205809865368523993,6934500447964393691613594947677420114877610140521721836488732706620555412923,9978011727059765171039296158502240318826874847845043732001483806732259491882,21367223873262404675887107131444254925505042466133465670356500592380419754092,12370989539828127569760369184182336850673006315469364895069603190681475159813,4771734208255151020750966033073146490824522462970752283771863328392876062708,13551343845317029011162863399460125746613189002552375164523344552618567494698,8714428409330855425634336943651573814895603648572558273360471650145732556280,1770920281347553432035718101936298919487500537138994976517066719980578590089,3110069281490803391353365800012007306367848815614936878141004366920256162421,587101336788172489216190547515347729725635829809300681040400739386253763168,2745547964008447408503376832407161412155228373377123760513770235899201269964,15688219884606649780982718944113231917978875761031663915052600865004707442286,18825709614401251798160680403375685428394659815656068061728877494732182115807,7344398268236623675422623600003139537460576229211381042555723883054380022043,14666515770263042245313469306170077834894759906373286169967918153150186862642,6262353441640473491135912890626291592970997790093308164286742582769628052614,16647307543328963728423591228360400112670150511841037950484862728187168155597,11187123547390829437191210933751439038277808812390863028310714957203862953416,13431586020033401007013925927716006954532655767977222332198563123215088393612,4290575536028694423523505804878297212249395907285796384174966179335089734293,9525030500997851642842588010076299538258273880797610368114449809143832950303,8240494019366037169932737683997756281590058122972608854062263901069681117554,20634410655079842888667296641045124414486057143740858179591482529433244800210,2021226937398532158458585055746155459624344885692396128118875161667614679890,13363628208058779432402710458326211021009444288989875416757721068391318188214,14662421589311461388753832631349921077594459767269924751258576584313288868105,18478701421001679788418312436274921897007545359172305786472370930338255515306,779644354087716689348274274240595541489283221242495213448957276905050464536,16071592196394048404777963063722475415819376772419538934537115615105548954438,5095096770582161819227893847981354649325178848130636101047350986634230116037,1243295118881144894548654933667320243992122811397983231810580344448403973343,11884934205846782297010667633102865650294795721122133935339824653150509106639,7458968983251027899406062962031140351528726088472453510482489928822496580100,19572605475586099575374380909719328911692508931262625802140140705257944509766,14705309817743162695613012501115465410697971407093611587529338557210155341093,21814585268359946040619047839768523980706543116273413618895661291550785045639,18720305501197276565912107809183977276090965285535057360911917408689742145019,2134301697439195186325742384937390317718398738774895777564128344393744278579,16999326242022117650983709520661797031983791094852258286603416430772587131676,17897483181215416614794986081059087805317610826416633427262022077916365348849,19707797946013555426424189263942163273279448488563211841018471715309464788783,14555678829341308540860562709255991938855501651550888461483653488337939676588,17257409408848021559108687223120061819076248102607600439065783833668882002860,3083159817330696927114122348973911210253613266522114299928693807761894470034,5736074496230638296274343498461296106748247754169694274901381380232637436330,8207744709591183622611260068351833593643143431375276434360211505091128037806,16073710603427960567922233549405442518423088068367439127980767364626490766482,16125801016656798988611163501719363451449395969542389751490084517803061425074,16681204974924630782971582682795720527615927905982945319130944791490607417696,4072675318306311800303326010748274698511258916524447342766005819081244518392,4639558473350853876171991553789446979158416238030006798108198266387155784407,21611752344375994669307116989730257280581712049771305171467376136735830835317,14260028812889714557229612460335412900866192266288236233734870104907234066106,10936007367915129326030460455513265303372033050181411601450223671258879981020,2935032369592212871409648743766195391225915910970902425024269583756879977136,6634946569637959135045435256486295750841113686207268069245788404426148269439,11165382706437522214793349607928919108508947068233467479625942161240196013032,11449774151698349588558943383567398137746718964787475388291636245211033594857,13380655477865684658511486065341626238240224687038830357479380314844874141318,1556090800260299290436338214947407050034615159120446561828975680392439133850,15775229412830292677008903643751483031582598935755329498528261914480871637362,8325948986690458545596228454116700887740572176003019243020371356605705227449,1530006957398320461897940887072398082651602436763497487522949690691142033613,12096799031117418724262752691656478204625211872574986459351576236141568686903,9795222686269696766812901618791046177266354705263547407732303299461050133927,6370027108686216641431817942352503637286925173249339052075608610090399016749,16881432515653361341795686702127944966732199129855247935726797972793170639701,15351738821101585856536273249878864428731819041333447251288973888111661451683,14781212701946742438784746658712056984412254191444809612525158953148214912100,8091550554023025707193058566806958042583606199181127012808071174695106343115,20490495862854672187041438553984493686275844004543178578410057111061213880755,17273768908086623408127314492263145283983205996943328025810362733169697859553,19294495315219029609698328900049261980545541811825479502505060031138576089112,21659964890056395567978937545379633715401240283937936880886676845913261767053,17982445074266408124204445317785538167802060185652418682509052997213396963809,5844393214733022541634389892381973171593154485646342141850588851005973351855,18594392739980641449638044568401634303115397702236811642652121212412266849233,8182160648431978634742268417253967926524505311200391645921674911687111696608,11615953679796573972512524871850400010935503185676276201708450621253942540441,21529769273680682324960067458105490598252059794192747768640910191459525561125,20132110404365493609540330952369583903023878161175287878881490874880122068662,3315629685104800403477925330007368560121731964009894641262206418774875779654,20760167657218552641600617661638902204729190730886821404831449731791027856388,1071944235595105837840075721866496337725631499557288435858051131598364359180,4555500238184379140256400675916267083899817767012366155141824954325999920862,12550383095401941417929336389002623533497339330808819244458405679309028814897,16242206659396631583090203067480642438705316999988728264056381863300603790054,9739751068073084582742270086389269366580429568378316378361121134559060472609,16116599372526867528428771037225046273420084760475362036998100512782645537424,1491702476187736766465155485454380021314952117101776564498935819251125640550,15487639992401023512588653485898591177260483949656489128772103961337143916568,271607781293753174262565976623664759968566553298322241892863651425822643900,19977950168772761551778240748644447848771422612925087742515420134526515662483,1983058998587842721058540590280805932874010898105761473162166721490888500174,16107724245058262116195892590046753877901405295502298275519986777803068771465,15598969808860428995774387003121151871293432204528482957206560135604646381090,10303850219152079194793643117738367623863138704730923818757626414538626924093,18042134015692222011976424010811982750427479608456170876100049843530175591980,11698490610713203406365860893495577403678312400711273827266244766764136895745,15094763799279956189651458728729592947034549021140257103479085265792492443257,430096731859098382312819496464652103427606481282347941948051379574546904741,13960717870097098006695192936395126361902142536383841733120824678277505383661,4016844697779547662080765040347308557842613782172342555085194018348439875647,21390612758814913695838461279472506230937295081984131634720827665924667792338,15210153052017283712229693210655704356560541803226219169450332030313730637768,1405020343631287949667260064722407285384539868534544303707265307694982887517,923081188208761071201163943024810005498690637139303388717205039798310044759,11733793144318360060340673323677375331041661345320756410073354731608712531433]
+        [
+            0x1373c771cdf15121a224f330d84b6688ef9fe0038a3bc26a28e3196578a0000d,
+            0x29f9fbda3c999836017f76e121af3aca5ce78bb48fa867a6a95e5b9db387533a,
+            0x1c7eb5116a20075c169b786d9dc86a24ee7a2525b565bbc262209a8cda490528,
+            0x21a549eb554f0f859f61d68f1b6bbe9aa3449a6238546bbdf2a1c308c9cc52e6,
+            0xb53fff701347d1b9df98b46175800e0d3250ac6d4a1afa71a349ed195873508,
+            0x2129ac4742415c020db2473999b34dfdbabba3cad4713718f95e6346e1583b7,
+            0x1d28f305e8b0ec88da37c8251b0c8d230b68bea9401a15f5124d64c5454bc29,
+            0x1ed301e02e3fc930999fce6d3744c23596700c03720705939d61cee451faff93,
+            0x2edb1832966e34eaeee0903858afedb13dbba9f7c802c83ee628530d0e26ae1b,
+            0x123daaddc930c65fc67bc77ca8bf4123fe81fbd0501e8f89ac31a698756d87d9,
+            0x2bcc36362c90210acf67d5fe21d53104e9d5478d057141d3b17259fed8e4a8fc,
+            0x1fa928cab5938207e898e61d99c7d616269144f7900815b17095f7ff76e3c9d5,
+            0x29c2f1cfa72a0fb8f53a631e84cfdf5cc18fb426c254f5a905fd3e831fc7c837,
+            0x2da58609f78b29ae6889f95ea2e8ef01a6a6c2814ed02317ae9e7142a29d301,
+            0x2bef1f45efbae1a4f77721631df4f6982555d05ac5f5ed215dd25939af5c1b06,
+            0x69266bb89813e77b00e34743aee026a873b7e31fc6f64ed57da189c460142f7,
+            0x2b7198b043ff31d915deb9d5fdd0338e5bd8028992cdc033eefb9cebf92c9f55,
+            0x20ff6cb38e8d9501add93d1684e5420d1bba60394e7c02787a8deb9573878000,
+            0x16afd4f19d312cc4b2568dda85d89dd7c834b05b4d8ffabf4410f15c22b77cbc,
+            0x2bc96c4bd9eb8f09c17483aa57c5c05f002c6a21aeae2201e882335bedf4f1fa,
+            0x1827a11b658414b98b8f76dd10bd5e0fec96568c2fe059f71999ecafbab0a00a,
+            0x202d1bece537583634b6e1e70659a1bcf1afe1c7775c478c00648b437578d9a9,
+            0x218b5b58b3333e735ce7c88a6e2f179e907322150a7833fb841325bde83845,
+            0x117267f052b39319c4ce34bc8a543b13e80784662c208ce378ad6118fdb0ace5,
+            0x2979bc493ae1eb3e0df74316cf12fdef6dd1674174a00ae9ef908b3a2df98ab5,
+            0x1925313243795f90651c448c814b13f2fa988cfc8895c9a2bfa8551164461a47,
+            0x309b8bc3b0ab07525a643105acedd0ae664e53332f89a185ed3d7f1da80203,
+            0x2c514d1803b41345f96cadcf983dcef5551b7ebe8ff78f23ecde23ebd5a36831,
+            0x23d56ffd6d38c9ba909730fbe6443cb5b4cf9a9702efdd98696652c3f2d1775d,
+            0x1eb7ae2f9df6ed33760e51a351cfaa3f4aaeba7c854b85bc6e2b63cc3f2a3dc6,
+            0xb3a63736983f365880bedfae6fb8fe5eea0f32e0b398e16d610d62a82407957,
+            0x249f511f31c4ddeb74d919cda9133fdbc1cf2d9b66288c9ad13e02c719c39612,
+            0x121d3b76e65bd665f5f5d2908435c2571441546a9504370a0f0c33de6fd7e738,
+            0x1e1fd57e79cf042b1b3b883d4f4265f15f08839a8b5c3f1802ab7b62d55eb238,
+            0x16fefbda0580e528dbf2648ec82d6acc114c3c1b720d56af01c542ed6d656b22,
+            0x83a8b8f4854d599ee237fbea3239f9090e06c223b77d130f591036be8209dbf,
+            0x2a521323dfe7e7e2cd622674f46cc5d64123113e3423406966ed06f2e7d37935,
+            0x10fad028a543b9445ee6841a44434121317b9a163e423a7bd6c0852ec521e965,
+            0x274bdd049a73b6677e0ff3e64a8d76d34009e467760819a9b0189a94ff14f79a,
+            0x2669e29b8bd468aa3991639947dfe76fc166111d6ff1b24139d2ffff1e1259ee,
+            0x12f59494b5695acd76123fec001dd777e40278b7342b34863e61dab94779831f,
+            0xe45ac1f353f45ff384658f34bad47b3b03da93784b770b607d22ee036c8ff62,
+            0x270d5a7fc5af9d4ffbc6edc57c91594348c60f3ca8a794d141f57c7aea7b0e20,
+            0x1c57c847fdb709bfd38776164af9aae7175005861f6cce68e7179dc8eb8d59da,
+            0x97bd4c74c9ef8617f364e87d90a2e4f461c57f2e7b42dc48b245973a25f8198,
+            0x9399dcf5fdabe6afe6c02a3fa831bf0a4f92cce46654d7aeb4aab80067863e6,
+            0xa11daa6724ecf2f75d8e368d31ed437dff1bba0acd32ba12288d4428ab66d9,
+            0x95ca5b00386b675738ee39827f9ae5a43ce09cd2b7a708c526c9d478f650906,
+            0x1161eb2d96d8f5e199a01fb1712c5f4b29ebc97d5de98e644474aaa34391f75f,
+            0x27ca09bcc614752905359dc489829b9ca0755de8b9efc1ccc6d83477db1bd60a,
+            0x2f2ddd101005b0d76d47f4440b2de8d982ffcb26416bd7acd5b1218327097968,
+            0x226bb0d31a8e961ff7925de0e07d33ae63c3e806ff19f375e8e96b150ac2eb9c,
+            0x1e50f8ce5e8e48a47693351bc4c95fffc274e75aad2fe7e6d607d8061e08da17,
+            0x17e98bdc10062dcab33e194593186fd29f06a5a3cd95a6bf373e314047ea75da,
+            0x7e6d38b28db0d587b13ac7ca4056fe27cc6e51467253b9e1b9318b181f61ad9,
+            0x7a06dd6230750e3f59b57edf6b3fdd71a4a1485e2b9765bc85402de6c539e15,
+            0x224bcbf9e7ad9eb63bdaa8e679c0ba67c594e4c8bebd2e06f1d736c4fa5b9c19,
+            0x14e43b10484fd331ef027a94de953dd133c14e823656e2a3f7580376d90b778a,
+            0x21c2c69e30546f53363e24e6032202627228f2d32c61924ff4f64b7b3e93a8c8,
+            0x3fe37796dedfc13fa0160d2da3998890a3f20e8c3522c4fa717e10796f40715,
+            0x2bd5b2e11cda485bef53bb4c2c654c39bebb5814b06134902858ba1c79fe0883,
+            0x1db6d06d30d62c08ffc1c2249d3297734c08dc141e9ad9abcc251bf4605b3b63,
+            0x350d5175824d117a97a0c758ffad0d3d23df500f097a25f8e061d79dd42aeed,
+            0xf46d145eace6b1dc1bb7f218431ae9af0c9278ac2912ca102627a656be2fad3,
+            0xfbd2953a1cdb40ce84ca589f711a8aae5e75c745c5ca4826f65dd2bb50813d2,
+            0x2e6fee6ff51b2abf66db3ce9c23271ba35caed4e6893762161bf7283e0c27982,
+            0xeb4c21214c0ce434010f1fe4733a327820e1afe53ba7233312df51615d5897,
+            0x149a01e3644a9aea475d77e728a2e9826f6b935ccb5de9f060c0a05d8904a470,
+            0x3051abcbd422db239b04ed4beacd3b4db8bd045b8d4ab36a872454e362f82b22,
+            0x138a0119816ee4ac8015badfe5abb7114820f161375b6074205af54887e788e7,
+            0x16c8e1464970e0d76c1e3c4073e63fb2e514b25858bf46adef59b1751480f452,
+            0x179ae599e009a3f1027b559b07961307ef54673d52e8bf8c4f87ac5f999a9ac2,
+            0x13b3518cb4a884686be5ef802fe3c9a0761950f2e5f66a469df47c4980fbdbce,
+            0x52a354e6f8a8c482b9ca8fa51e4732763bda214a65fe575ff12c954a433e27b,
+            0x30348154b1407f9bb3b3d8fe8decc41c770cce188d64ba7b0218515b3622fe7e,
+            0x22493fbdd06dc2accec415de98a9d411e393393e648cdf86ad3efb60373da4dc,
+            0x2bd33c38d67da9e28ff22b4ae3b6e0ea68c6c8b275d64408cd7c0bc7f3c20746,
+            0x18ca35802730ebd5aabf25fc7cd352283442bbfa6e925e66e8344345932ec3a0,
+            0x123a15b31db64480736ee720631ab0088a24167d1460be4dd420f7cd40acf2e5,
+            0x1ba31fb49dbfe083d1f4210e344596a9c61e6f4bccbfeddd88f3beb168921b07,
+            0x10c73167a97d9141097672c848cf3ee8116d380e6f1301778533933a078f2a27,
+            0x12b2f0963b677d68900fbe2500bdfd4b532085e5cafe9db9c2e636a8ab0c98cc,
+            0x1feee9a8c818254bec43c0bfea4e01ce2a7e6faa9a4dd01208770a6f0bbe7c35,
+            0x2388c6a47ec73b9c198bf0ad3d5922e3598457cbca82d0b1d2cdbcacf56ae36d,
+            0x1bd9b76b67a672ec982cdbaeb55e14628a4db0792bc0f52451c475cab0ecf3dd,
+            0xb2ee64ddecd3f26acc1c6c44ef1643b8eb6e589d0304fea3b7b7e1e91c2f534,
+            0x107f80d883fd761322467565a99dc8786e69ac197fbedb7636432ec5cfcb2678,
+            0x19f0a831e164772368d5365a0107d0ae264ba97bd5160bee069f1e2b459babc4,
+            0x99ab87e7b852429782bcaff58bd19649ea26b24e493b243c71d411b48e36375,
+            0x18db42f8cb42180422587e68173a24cd0dd62f6b17009897541f16263a405746,
+            0x2a22132453db2d68d388b700545cde863d652bdbc5f733c692a1863754fc7294,
+            0x2e3f81e949bbe1a2e8a06b70e21d433a1036aa684bf39b7e933839973867ea3c,
+            0x2c21f85518cc932c232aafbca1e4eccaf6d7375a80b1542828e1aff7ad8d8442,
+            0x21c0239127fe8b2965a32cc7ee8d063eb792ff468703c54cdde10092fa9d922d,
+            0x201c6b5b791d42b85000a1011ac52b25bad5309ef4f482e26110310001bccb4e,
+            0x2db1d234cd755ea9599fe56001866bb4b711ed049227d67ddb35c03bdb8c6df3,
+            0x18498b6b4ebea39d429c25e5aab1b5fc97ec880e736331814a3cdf799bfea718,
+            0x1e5d12fcc0c680824e0934a64153a1dedd491ec29effb629e35a45d889028343,
+            0x1ddc4b9d3159354a45944b963b54081d3584448192659625d3f06fa98181f43a,
+            0x11fc72e4994e6b2e99f8b58773a5eb8ab282dd06ef0607051371bada7b80c40a,
+            0x21bc7461e5160f2dc86d270fbc2c8f91605a49e5c75ac57c7ae3481bf1f4bb4f,
+            0x2d16510a22095aee95dac7335895a70e0ec56a9a9b33201d94b5f7cb6fc626b7,
+            0x2fdfb1134a1f54ad7dd904be3991e086e1b8e0c4d5c0eb80420da5c0fe4b0944,
+            0x28646d4e0061355d5cd936c08f7e8419701d959482990a46d4cbe164badafb26,
+            0x1dbb1b476c0fdd507664a1c03624038c2cf2232c87bea9e711fd32dc9150622,
+            0x81dbd4fdc8779da9472fc7c3dc8b35418c3f670643b4ec8e878c256f6cc22a4,
+            0x886cdaa0b431c97d8463419ac5651ff457a7c15673fb88916e94fa55f584d31,
+            0x2838331687e032e9ba3fff6492c1c547f685ebd7609536770c09dbd7ec3cd2de,
+            0x2621bc61696ec99cf22f64501b131655f498c95fed719edc34691e18154354e5,
+            0x2549d455daeaa01b7b52782493fe1b0b7c14dfb77087c9151b4ca36f15306ac9,
+            0xa4c236eb53846ff3488a5bcf59fe22252f78a20e953516f22c88b4c06e7f4a7,
+            0x10c077e94f0d3852b3e3c2b14eecba18c27b52cefd6fb1a1ff6a26ef95e41815,
+            0x2eb187c8e8b5d69de44971a4b370ae917ecdd0286b75560c1d3036ecc54b196b,
+            0xb395bd209a15083fb3a580abaa376a1fa397c54f91cf8a0c141ec7b4d7c1e97,
+            0x2a1aa4e24d835d8a3f9ead7881aa391fa930752f8c9c1a448d53307ff930d8bc,
+            0x1a3959bfaa6e5ec9fa45a9939b47676ed773b545d372e5f8403ce000528605ad,
+            0x31eea5b773a9e18aa6a29863ff6c51130f4e76974071207bbca7f238e4910e9,
+            0x109a8a86778d80cfdf86b4d6bbb1e57e218ab8fd8495f1fe051b576ff2e77c98,
+            0x361d334bf2e907948c05b6252bff7903afddc738f2952a0dc893b09fb034ecf,
+            0x11f636b7d7ee19603bd7eda90e668b7ecb2399750d002d9cd2978364b632ea0b,
+            0x23af2f1d6a7dbe734d6006377fe06a202a5482cdf7cf324bff2c3eef417e8d9e,
+            0x20057e0887d089856cd5bcdebb9e75b12474add58e57e3a77a26cb6cc36bb61c,
+            0x2657371dbdb26288e4a31975410dd5772003e2255a15e5419f11e97da00aa5e2,
+            0x149681e3e7671ece7381c6981fcfb46ec93264cc242f9a6140b3344aa641758d,
+            0x4483482a502545fce490d73674becc29dec91db3a6721869a92856252f5ebe3,
+            0x1afb1e247f5795105296f8f075ebc831ede8b5128e378bfc374343ee6f93197e,
+            0x23140be54f97f6d1cc5ba00847848e4fc973656baa56ab3e1b754cc12a296bbe,
+            0xae6ffce46e6c0bc0ce6341f9d308c792436f0a07142988a937db3fd8a333539,
+            0x129231c0dfad986f9c0c2f9868b00c22b314e22b24b55a438770b320ef193ea7,
+            0x1d62b56618a967c7d128e45a28062fe7f0bce6dc55083b58374ab6806e01573a,
+            0x17e3794052d48c4aa936c5e189fde01b8bb4607fd478b67fdbbcad3e8aa9166b,
+            0x24af4f43a91c5c51c6b2f3f44eca59bdc79ac86b06ca092cff9fc7d9c4691fb3,
+            0x215075ce41bd685be3c97d2bc28bec174421398024a8bbe4d9122008e6e027c1,
+            0x10ff29fe3e761d9f78518eb60b2a1daeb394753487490c9f5ef937df3b87699b,
+            0x160ff9e43a764ba2280d5ff675a9db049a29e7924f5ba24583b1d6d90caa0324,
+            0xad301157c28a1200715676e5ab5b2469fa39559c1a847f7787abf487d828055,
+            0x3409e3a83bbf52d16fef10fbbeebbb40ba299ef770e3640651a48602f13d108,
+            0xb1232364d87cdbc709442909811d0a0241d0d8b7933b59471799d6b30a58da4,
+            0x195dcc72dd9f2629db85af3e0c9a3ff52fed868038cb27103d9f30c8c70e1fbc,
+            0x192d2d9e31fb65b409ab273e7e2b050c1bff596ae56ca4687ff8e86ba8bc27af,
+            0x2ad9eedb67e8bf182bb967045b906afce866e00258a320380a709b818521bf3b,
+            0x2ddfe92956df2e751715ede80573cfa5308b46be5fd0f77def8a519f113a4107,
+            0x1ef0dac6020d7b376e6f0fa82187820a0a4d8be7a8effda342f7f8806565f2a8,
+            0xe4d6efe23c1496d8275f8a4dd536bf988a2c8ba2d2beba328f28606a4ca0f91,
+            0x185b30ee2d3a166f2f59a03c7ee9f206411f74f777873b92045b6c128ff84202,
+            0x19ea7d6275a6dd167757942770dac2861057e16a988d2e93e4f61849d8427aa4,
+            0x23c3b4f5e49e16ae69e639b956d48ad6ba696f243a669aab13ab2c2855e1187f,
+            0x29037d64b549d1c9ec4524ebbedb8069cb23218bef3cda811134b36d3551ddc7,
+            0x2ea8637b89b798a2f731d98f2ab89ae9814f18deaa7effcc9633fe829a9d109b,
+            0x2bb4bf36b15be77b7374a026352644b8e70b1ac9516eb87eba7672ecd03f1202,
+            0x1006f07533b6e5f33d613b89b858bb6616c18f8478f225af2f4e3d726780cea8,
+            0x1749f416df7b4f43257d9b8555e540bb0ad0d7c8ab0a4ae1296021da0d90ec59,
+            0x26c86b58437b04557a96cc74b511dbda00e9c4c57bb86c15d49bce318da8b592,
+            0x2679dc5e56ae1f6a54d38287c7ed606d0d9505a5cad5a0699b09041571c4560a,
+            0x133eab2d7a718f3f741eb10e973bc5e29a021e83f6442418a832b091bc2d6136,
+            0x1684a4b71cd72ec3cbee67151c638d5588e3705820c468c289c52e73d69a8fa0,
+            0x17cb936bca97a37f63732c01e6c40f6807360cdb73f62d792eb910e034b4041f,
+            0x1bf4b473f0c77aa5ac94a46972216b339d99c933a8f5034044b4b535adc388a7,
+            0x2c6b76a42a2fd9fc8105378de5176d60c2f8129cdcca89fa0b00f3edc64e079b,
+            0x2893d0cb426295edce9b5506b56a2b867eaf48b08c5242888ef79766f8d9aed2,
+            0x192d74bf58f3dfad901612983c6bcc753902e2241a371f9880e351150e68292b,
+            0x1bf69bb66db73ef6a0e04689e9698896ebed84d97966838113f5df5f5710736d,
+            0x1f8201a8020ba29e8521a1a0cd3bff50603daafaf084f0373f2edb68fee7308d,
+            0x2fc51d7afa548b449f40ee7c48386655db021f9e34e143c51b1382399bbf6e4c,
+            0x1f4e909114c65d62e1a1e466d4968ba9f6fa612578d474e25cc1ea13888f360f,
+            0x2957f8aa51d126b9961950fd72e1c7224668a359da4e5c0bf761d49913d147ec,
+            0x1a80f9577c8384aeb8889b63361078284ef552c62d2cc0880667e85f01d0333e,
+            0x1de416e08ad386d654b37fd2b61eadb5b555e0fec1b7b09d8435bee97e57b0e1,
+            0x1ba2ce3d6e352d0643b2d3c5c7c023b6d1777f246278cfe6e1654e9e5413b535
+        ],
+        [
+            [
+                0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+                0x2d8c70035731ad9efba92821a88119f6b8183a362be641729a93d6a327c03809,
+                0x7b620c8a78e09e49ce547aa783aa78f3e4594c49ab3dd6f602bc6c0351d823f,
+                0x231996b592528575567d39d00645a83b13929093bbfa00d6a661e4a690351d0f,
+                0x4e47a72e49b9c5aa3f69f6af22fa0ab640c93fc524dd3c508486d66f079852a,
+                0xa8cb4b2bf3f0c5da671e48f83e5c1b3018f0d31200a6f19fd5195db22eef7f4,
+                0x18bbb002b46f2e5fec2b120faf87822ca8e77ace94e03aab5c16c4b931739dc8,
+                0x2bfae1b054ef2e924d75a8a01283da29103c57bad129ec8396ce274ba4524df,
+                0x6d101b19477d1627b9542581bf0cdfab38b05cdefdcb81965c5be00d780f192,
+                0x18af61f6184ff85f104c2bef179b3ec5a5d242dfbebe8e27a2918f620e8a5be8,
+                0x11e3a7c2d5f74371beb188c6e3d7a14b33128af8ee3287546d12d7777cef70cb,
+                0x2de5d6a7a27343dd0422ac71b8d409b43ccb0b672e978f8fdfd214f4d7866404,
+                0x227cb43b9818924f2a2588964a0ad7ddfa3df62284b4b3b10199a501ed970622
+            ],
+            [
+                0x2b2ff5f27531b6f3d6a85d75e3e08f3a2f0dac3680a6c26d55ecbf803ca80569,
+                0x9ef3492ad19dd1d0bfbeb191330a880ee7933c9d3b36bb5fa02283bae5d605e,
+                0x27d6bd18703d7ca92aa24076d3187b6c0028d0b6213d9e5d2c66115237a19051,
+                0x193f32a3f839f76049c9cbf2414590698a2118e83658327c4338aa3648d8f7d7,
+                0x235d0e71a350f1f23d9bb5182ac44ec9e4615e77801e5aadcab8336aadb1712c,
+                0x1df5c9ef694afe61bc253ae908a8f6af0a08cdb9e78a9f322c22388322f16c2a,
+                0x1db2021eca3a3624a7d45bb16cf4a44e2af4fae0dc280030e7ebe55394f69d8c,
+                0x1a46a26691841c26109a32ae07eb584a6b8af657273cdc4d8a112dea0bcc85cf,
+                0xcae80cc05aedb66d6e649b057dbc5ae9759da5d7b43d5e25a400e1f92e9d1aa,
+                0x195057af1319e24df1b905c6e2eb2957003cfc34b001c0e54b9dcf2ea5df6be9,
+                0x2d4d35acd9f28a3e6bfd601472948293c1e4f084c714ddb1a075f2eae9ce21b3,
+                0x25eb2ed84c520aba164e33f0353b5131886c0fbd18e55695541512dec563a0c,
+                0x16c7c5c6161eda32c65bb347655acaa80bcc98bfc023f4ab12f5b2a899f37e3d
+            ],
+            [
+                0xb658849ce620bbeeff233b7d12258015ea9f87a5390f5614981eb6e4cb4a5fa,
+                0x1458de516a534190c5550c6a1bed3af535c38b242eb9291373096ec60e39c1f1,
+                0x2969eb5016f24b31accf173ca204668dc2229845bf6446cea007c113349bd4d7,
+                0xa5da659b6fcb1a4273e1b7e3b544d2cbd362cac497afd004b8ea920fdb04bff,
+                0x1219740c424743dbbf896996f0ee7a4076ba960a57e8d7679b828479218570d1,
+                0x134431128e5ffc0ab60136c5d851a11dcdd63cdcf17ad64fd77517701de675f8,
+                0x97c6133aea8fe48f3a5fc416bdf5e46d05de0723bc49e53b9fb5e83d350c295,
+                0x107da0784dfb314d82859be44d37b4d2b6345c174b91651c65c98449682a5204,
+                0x12256b3b99d31d8a372986f95d66cc139dd23e935487da26b3e249ea7cbf91ae,
+                0x1d952ebffcbedd26036c54a1e8a2828fe320adf07a286e7f2c211b47f6c3ee86,
+                0x26309b52cb55f6ea5a9030b01378f65d2e6b7a9619926d9b1b1e21cba01fa7e1,
+                0xa12525f0781322371fd70b0928cce6e2eaaa67b8970dcdf319df25e8019a6de,
+                0x27e37c68a01530f092cd37c4a26dece2737868dc2c3519435e1f2cb88f07b62c
+            ],
+            [
+                0x118132fbc1cd83f95167cb4473d54c6bd2c417e2782e5efea16e72d47b48b70f,
+                0x136ef2515955ff6619498fac59424816189f896ac0ed69b59854d105df47c4b4,
+                0x29c67bce04bfd020f4ff7eacab6cbde034b22fb86334675a361f059e50395311,
+                0x2a832ceed3837e742196e09491fe23e3f6e51126eab9acec96e71953102ef24,
+                0x2b501f1003e27aa809dc9e5cd84976a3b8c169c1e9c63977d7823f80d3f823be,
+                0x3ea4e2bffe02da5977ced1f1a6e852e921abe2e015f35b36ce4bd0246c2cd89,
+                0x150ef9e932a74b8debf670080641339b12684ff5a303b2fb7c1d8d56f56ab61f,
+                0x2b45b3be2674fd820516acd6cc6183c4fae0f7edfa9afcd02dfeeccd02bfed46,
+                0x238965d658967afa2bce50ff18cbbe535327c65b0b76e50da30739ded25eb492,
+                0x370b757ac6cdd46610eec0c22d43a543d5e0482577bbdc14e71090307b5f69a,
+                0x2aa84c1ef9e848a64f748b80e279ddcff871e9c4c3e2fafaaf79159b0b4e4018,
+                0x1bbf43ddb5a0b0d2845923b1ce128292359cbb313c5876fbb52f5e6b1fcb7031,
+                0x19dd1c6d45298248ad499531f33ce002505458d76178eca26298e39a62fb9501
+            ],
+            [
+                0xb5944768d61c1b3562a5749f4f06c4dd085bb562b838d7e2ef14a21fdf524c0,
+                0x18cbfde0cd21c183797a2f089594a81cd828f3b0742371ed02eb83fb0064dd43,
+                0x124474b08829d9b717c50884bc895cd3f81d519859d21235d7a74450d0a9427b,
+                0x98bb2c4c6334dfea474d04cb2e9761861f6b18a8058a52b619d6227a26228a8,
+                0xf34db93ea8d2ad7d1eff86db5820cc7ada47bdcd8c82d01821f5c21a3ea2325,
+                0x6e03ca1146705522bb5e9dc73560eeee6b9b4bf51d48f953fbd1f006d758a75,
+                0x1237f44f036b2da0067a94947334e3afa2ac4cf1009896766f5b191cde284972,
+                0x2082e9103cc45245924289111527312860f6e7ee94578f0118f4a920d0f8d525,
+                0x23a6e143284e8f238c4b632ad78ace5b0dcd94a897cb05d1e297b4880e7433b2,
+                0x22e076a3aa6ebfe996ba068bf5bffb17fa724338cd67f67ea25330195c628172,
+                0x2fe31b0df04f276a525b619acc4a5ba3eb58d8c321c62390febab05ecdbc798d,
+                0x23e8c3606aee818d2afa8c4465d5ecb9c45bde78dd819c0f35a620593c1f42e6,
+                0x215f5563464e2df6a8daa8c34476a465e4ee9fa0ad01fc4399b649b2e07d1679
+            ],
+            [
+                0x2b04d6ffbaf7144012d92c5c6212803c0b5bcc0d7b1950b889d1fa6f3e56445a,
+                0x22757da9e822345297bd060a3f71bb1e70ce977049c393235035677e84357314,
+                0x2c7e28f59fe8a8a3bb2fa2b2b1e114ce283fe22a978a3df9f62a171cb1d65e4e,
+                0x101749f9dd2605191c1963f25694ae267f6b44bfe2d1af34fefcb65e958784b0,
+                0x4d02ab05826fa50bcc5f9af9e396477e68542d076b683ee61b85869d4535893,
+                0x14c499ee51925b231da17ee7b55a75f96f462e431675ee36c7be4e9b069e260,
+                0x2d9ea99d2d237328266d59dd7e018bbd6bcc7941d9ff5f07a17baf0099f614d2,
+                0x303a9e22855d95d07e8172f3a0536d4b95142f962b006a8ab09e7bb6335e8487,
+                0x24e13a38f04d5e0fc0b6b6e0f782a6a523a8b3b0127224b8e23751b9cb9f8960,
+                0x126851f3eadc0183288a750153910a41e074b3544f0610a51273ad3698be0cb9,
+                0x27c1b406bd19ed13d533550b8b621186b1fd47f671e6604680317e6638b091e1,
+                0x158880f5adb96dd1398128b9ff339f3d827da6463891cca129c012c06b16b321,
+                0xf36d166e99139b9bfc1ac3270a3d98c4afa81bf97436076f57383da50436a5
+            ],
+            [
+                0x29be2a42834ae32de3320fb0ee46b4c102a3d1ae44c5dce152fdeab5450c9c44,
+                0x1622805125ddf344c18e351d11e82291618b975822ad0c903efbeada5a51d44f,
+                0x165c0b978b4bb646a9ff225ac4900521292be54c879882d3f11eaa3103341487,
+                0xc7b5e09343db5c63c110d3175d01bb498290d971b1e6dc0e9a0e9e7158356b1,
+                0x2bcc82e75391be4ea9cd0f8a505f9e4f684778fc7a9b1bceb7868bb299cd2072,
+                0x611ecd1f379a0062b05c4aedb100bc015244c6a88f1631a456cc2acca8930cc,
+                0x477f951e19f531b8434ad755b6783d61b679efbb87fd956e394db9c434e2352,
+                0x2963514313f046f844f950ffea80f5e5b424b707f16599662e5a2e3668cbe5fb,
+                0x9010d73677620aae1b0fa8023ff1c812313ae9c3bf43066ea60bc1ab477a7f8,
+                0x361f4082b75a6ebd23f9a6e7309d8c4e7520159da23441edd631a6ac14c20cd,
+                0xcebcf30975b37267aedf521ee2bc753c3424dc4b6edf3984fb02ae1ead44daf,
+                0x23a1ac07351946a974c8841e92092a4ffc6aefc7fa988e3c1f7e7c87e1512a90,
+                0x1edd7c7deaf249e0fd3f5768aa92e9dad64118b491bcce12340c46f210b07ced
+            ],
+            [
+                0x1946fe9de0a943d5a716eac08561cd91f9031fec82da9ab72883c7b218b11eb7,
+                0x29765d8cf77619a580658d127fb6faa44d6c70a0f4d65dbaa960754b4195d9fe,
+                0x2066134bb299d9e359cb82a8380feb63b60e4b9859d9b9872edaf9152f92d4f,
+                0x116a313d00cf99dc18e21f93a5bb198018bbea4b7cdced3e4d210971dd0a681b,
+                0xfe29b5bead54c5bbf426bb12844a2920884ac447906101cea9888986a030b11,
+                0x22af37c0e4a88deae9f7fad83819910735cb4b49311e0aae11cb7534d0bcee6e,
+                0x1d8b8ba772c4cda72e8ef9b19c424d55d57251b247c632bea255271afcfc70b6,
+                0x4b7f8d1d5ec8bf689adf12d656b94e15b0b229c1638c9c4757faf0d18fa6433,
+                0xa41e5a4421defd5ed7acfd48401395a409a67c3edf4c168ce3368ed944212d7,
+                0x1abe8badb2d12353b9bb98152086a9421b7cee17761730e25ac284d6b1ed7b37,
+                0x291c0da731c016c0d6c4c75387030a962bf7a2eb35e15aac02fadf530278a3d1,
+                0x34c460fff28862ef7a509a1750a26ed1e5960fcb58c4f48c7d267c77e58dd66,
+                0x8e1741a97f6348ed6d68f4b7bc6ec8b2dbf03f426769cc779ceee4ba1beb03f
+            ],
+            [
+                0x1af3ca6240a55aba55df8e49835b92fa17e39ad5701ef70f8144109f894bf1d0,
+                0x2bb0b6b08fc1bd11070edc42f23e807b82e8b88ef70355dfc74e096a7ff381cb,
+                0x9372ed18ba1a774eafe1bff6deec4bc0814b0899c6196fa15a7acd15ecc5ca2,
+                0x404c0fa1bd1f7e059054cbb87f6b5c69d11457e59f90419ce4bd10bb8a803df,
+                0x1bb2091870a4fac03682fe5b1e2eb56b14ad6e48f4676fe41454bfeeb0ffd4d9,
+                0x299ef95aed8c75494db82e8679fbc6d5a3d2e29aecdcf6979a9b272a607dd5df,
+                0x206aa2f36e32b2b06d6be48ad493d354ca7468753f526e6bd82549fc36cd4109,
+                0x259547168b64b2a228941a542f394a2699c081c149463dc2c3d21fd8b2e4f31c,
+                0x2fc7d17f3a9afc1de289ad0f94126aeec834498120629cc87c4586c627780075,
+                0x15a7e64a5a46f5973e4e82a263ef905ed64f182b2041baa00a1359e7e9c5eda7,
+                0x1216f05607e032e49038ac1458100e89ac8519a5a3cee4545b08850d8bf160e0,
+                0x223db18f31c85e98e1dd7b7245dddda0ff8e319bd7d1a67fdbc7eef56d667818,
+                0x2f4aa8641ea4135031f4d97a7a2f679a8cbca562ba6aa54eae7d32ff7d04dbd2
+            ],
+            [
+                0x81f58a91a4e0d100e0369fdd81a190035342fd0677ee1bf5215e47f8e58c2c3,
+                0x4951e747b7ae6b99d9250108c5d2b70181a93ff1d4bf723781e1b938029827c,
+                0x1e3a130e8caff9b5e563e8aaf84b2fc73668e351cfd28cf66f5012de61345b58,
+                0xc1c216af33054c497ef04381f58582298b54335f632bd62add29e08067a59d9,
+                0xf54c9c522a5c74e0d4e0c63611a7502657575b7a963c0e786d2a761c4e845bb,
+                0x103cc8384be1be1087b9bb47c0eb6049f85e0413f7b408f1dc2fa1e6fc4af91b,
+                0x28da9309acca103ecf19df72a722134d530bae6c660db3c364d0ebb200c2aeaa,
+                0x27919dd2f9d3dc9fcbda1a23b95cf23e3630e6fd5210faca6acf4629b88e5ff1,
+                0x1f86e3e9d147ed604c71e1fb6ef8459cfc40001bb4fc5ccc2661669b155abeba,
+                0xe154ebd50db3c2864dbe1ed72b0816210851b86c353692d1744cb3372bfa72d,
+                0x19ae65945a1dbed3965f2de3a39ff2d54ab1dee0f333b88fb49edb3fc9ac7899,
+                0x99b97c878ce35c957d01b43dab07f8003e2c379b41ca61a6e56a9204fb16bc,
+                0x21a0a43c88ce26effbf8b9ad668056b5b0362e5009f3d80033db473228fb7fc8
+            ],
+            [
+                0x22a852af90680a8ca9688b71ed27c157d02b406bd6c7fd8121d7c7793ad2305d,
+                0x17780b9469e81ca70c7cbb4347e7fb40c63ef68f3dde51d04cb47b3b83fc299e,
+                0x255543a314afc5a2991413228c75eae398b90576b23b6cd86128665cc3bd9478,
+                0x11cb20544f43437a688a7dcb573a7da4f8c7b4437349eedf3fce432a6f3c1653,
+                0x160f5ac0b2481f8019e95e0b26445ba64dc03a4be8a15461496247e6ac29002a,
+                0x206cf4290ac984434fa774bb0f8901a233905632b793c80b1d59966e96a73832,
+                0x1b9435855d6cc4339240e9fa3819c2ff420980d6cf14721b75e4cb1fe57e118,
+                0x2b9237e5941e1657efa507b892c3b8dd57fc8d52876ecb599dd5e1052b6b1f2f,
+                0x182d8f91ee2a9a26215b35f3c0eecf8ec5cc360124cf6b903e70ca83126975dc,
+                0x25528d5d31dbd77cfa6e7b1847f8e84c81c1ed5bae2a51c9e403cc754c54bb55,
+                0x2f996ae620d00a3d4e55ef7a6ce0b681388f1b7ff3875b725aea6eb9039d8b25,
+                0x2c2b1e7c70fec2f58ca01bef5ac37cbb9471ae7914bf08df7e47dd8e3bc3ce93,
+                0x31b369d011f219e4a8fb21df9352878d93ff8035bcda834c3dcc41c3c2df85d
+            ],
+            [
+                0xb27ba82a0ffb98368981736ae927a227828985c00c3e5df8c1276b1001089a1,
+                0x1913d51d9c71d042bfbf649d9e6e6ea5fdd82b4fd3173ff2fe02b85582528912,
+                0x76547449fa03845f185e61578a5a8f2683a19733fc04c73ac6a0b89bebb8453,
+                0x186f160ae866e10c4be0ea7d204cd64e57337c60c40b34c3a371d753f2ff001a,
+                0x2f3d6b8e2361166089501b9147e84ab6b09792ac17a5f080d75b3e320affc86c,
+                0xdd85dcf08fd38d22f316d91d812cb2a884308775afa9f667c6ca80954397c86,
+                0x238832e643158e96689b5803b0b77601b59bdfb4926113a3455f1ff4df6e2b46,
+                0x202e38e669883619ecbc6a6a45368b9b9a3e9ab67efef50f896dfe48b78d3dac,
+                0x67d2b612d75f4f974312d04ae0fef43a35b60ef054c0f475302c55fc10bdab0,
+                0x21f0c6b896fb14220d811441629c78f8e8e27746026220e331cceb89a0ee89a3,
+                0x2c825ee561c4ab6a22331177999c89806fbc34518387e807c20c359739ba9eb6,
+                0x4625f2258edf0262ba0647cae426a486fc801dc0b59d20ec0f4d0af8cbd23ce,
+                0x20a72083579059cb659952d3f2a01ed90d21002275b5ea11f209c763baa8457
+            ],
+            [
+                0x4b46526207edc70a0d23c8438bc49a365635552dee240661a2cdeef966f20f6,
+                0x2a9e342a56c8b6466d3fe533b89f1ab441b62dff3153d3ae6500c2c3be6365e8,
+                0x2f98bf081e0eb78f8025c03ee9c199f2e838c51e5a0aefd333e9f7cfb38f534b,
+                0x1e1d5920edcfe9d6b2d0ddb2f6f741afb06590340fc07b182ea7c3ebbd933931,
+                0x1b59bb60e986194987fcea070498bcc7c93dd561ce8af5fade754ceac07b1705,
+                0x24ce0acb522da527d3eab72865cf073d954babbed3cd1706aa69d767e9afe7cd,
+                0xb43b8facc43cfc067b5513abcce846504b9395cdc14df96861a528a52ae2ec5,
+                0x262758fb3e076936995ff3140ef7d1b0a1e0fe4240a50747e2c3c120d977f3ac,
+                0xeab3f26417e6b53c532072de92d4aa78ccdf1da91660a461abb0f9fd7bdcd7f,
+                0x20addeb2afd20e752a39d2f21ebddc2772773b062922dc8dd3ba068836dba464,
+                0x754947436c3cded29a60c9e898237c2183a49db7e70e7eb73aefb4b5c693246,
+                0x239ca61a6ef7e501810aa89ab4996dbea8fbd47fd2f7a2c96a818e93a3c38c89,
+                0x19f11771049b5be81b43ca81e3611f4108a4b9dc30cd122441f74319c3adcde9
+            ]
+        ],
+        [
+[
+0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+0x5da987f17a176320a821339189d24ff783be07f5a6adba84ea72fa0d7faa9a1,
+0x142b410fdf81d2489b47702708422b35a9c6c3580144e7f3e94b971bf079585e,
+0xb98437a312150d8171b81b1891f3cfc75b9d14473319a77c7043d8d2ec320bf,
+0x2f88cac82b777c1c7b751129e0bc1d038481129c546e80007a6a6b73c52c7f4,
+0x2b37af1db29d45113ebe8892bd41ba43e82d045eeefca95390f4a7f816639416,
+0xe0fcfee5bd6119ea196992bc58dfcffba632cb20e07d9bd7f1f4c0738edf767,
+0x1f801f49cc72b3cb1ad6d83474b3e98cc9ab427ac9d1807de151ff591c2d98f9,
+0x5aba81d049688ec509fbf12aa240297e0a4cfbeb91c87e4d1d72bac8acb33ae,
+0x1efaed0a28bad9712571c0f7200ed332ec1342c08a9270774ed84817ffe8943d,
+0x2765f7a0abe74654c9182787a7d252f964c3e38c946a1f459579923b061b206f,
+0x540383aee2f7779742ca518ed4d4d752980f2b5dff48339c128acb79daf88e1,
+0x198d160f1f80e78fd1e93c5244d636d72185966e93e62dcd0fa8cad1b772f781
+],
+[
+0x2b2ff5f27531b6f3d6a85d75e3e08f3a2f0dac3680a6c26d55ecbf803ca80569,
+0x20dcb39566362206d4b38ed042277d966f03092b6910f3a05e5b1c3071f4a070,
+0x2e3c5d5b931ba49c99edded32e4f404eebef7eb08ca9668d82c912cb5d428585,
+0x11c900f3b1c7732081074d0a58091de7f826a4f106a930899d3798c6b02d7735,
+0x2cfc4c4f3575a5f8bf5f2ef6b518a47fac9fe853558d584ede340b5e32eff61c,
+0x7ba6d2ece419d75b37c87da9b00fd277259b4232542eaac3d6c7d85c8677a21,
+0x2ad1869717ab4c539dac1f950998c537d101504b008b46b47d239eed0702f8a9,
+0x6b21b6e86693de4b43f26771aa347307be78fc9585a91fc28b6f0f802850576,
+0x1e54ea10d6b7cf0607b5224797eafc3b651b492aa74c92ae9a70a692a1965e2,
+0x23b47244bbd00be19b1c8046145626bac795b4ba22beb692810bdff4794ae97,
+0x16ba1b0ff54dacc9d88f85fa6bb69988a0633a3998eff403bd55f352a195192c,
+0x2fca163547569280e953a94133047f3f9281b220b0c6334645e432143edbaa4,
+0x262cc29dc7439873e862e94b1948eaef1068da52d8bd493fe44a9e48b47b88de
+],
+[
+0xb658849ce620bbeeff233b7d12258015ea9f87a5390f5614981eb6e4cb4a5fa,
+0x2816fae6fcd39053c09df75bc62f75875e635472e790e295aaee0c8158961174,
+0x5849562006496b3a32966a1a53d29f1c667a80e69e44993133184456ecc57a3,
+0x23bdb40dc2a5072c7d0cde89e1baca83c53b963f4129487c1a68ffa36cfc46db,
+0x2283767ef21ee3be90dac5aa35e2d5c39f7bdae014bd63b63039d19b042fb575,
+0x1a2dc35b3c29c763895e67b7ca3ebb9c34484431cd2d1080544cee9d03194c13,
+0xdf23b54c9ee2fd50b58ae1043cc7e0dc3a11f183ee0f815fe9a97caf186033,
+0x160a65dbda0b6f118906dc50e0d5a8e64ce7765f4327700e11e753d7386e7392,
+0x24b39cab2a81551d5d529ed57986b8ecded02a7650eedf67925eb9efad60dc20,
+0x226f8e8bfff7dcdcd1980eed6f88a2566cd997d4f7bec484ef25bf8ee86eba7b,
+0x2aaa2c1202b74f2dab3f58dbdc95eafd2ea49d5e3abb47f3b33cbd4ea13474c6,
+0xfaa06fba9421c021c6133baf90169f65dcb46cc47ee532989d5ced54155f34f,
+0x17af1f8b71c3656ec7d3262406399866d91470e4b912040132b923f891e63720
+],
+[
+0x118132fbc1cd83f95167cb4473d54c6bd2c417e2782e5efea16e72d47b48b70f,
+0x1df6a4c43bc5c69763183d36c26b6b37fbd5e4252de4b5c3c0da6b81d2bc00e9,
+0x2fcd5953b4af9a49fd90b23229198d09fc8fc8ceafdbb53599b133d01023ef76,
+0x24c66b7856c9a5d78819772b35eef0de88ae882c19af36039f785a48a75f450b,
+0x1692394c144aece305a7f02749a63a355ed6fe024be532af2152a0d53d590a30,
+0x2e0f2af806c4c37a9cee0b9d31be62616a7dc6eba5e51ed9854c1be1d9ebb9ed,
+0xfda8fed741c4382c69bc3f63c48c052ef784b8f67ad573451a418f2f6401127,
+0x1734a0338c0a652d147ea6c26feaa378580ac91d0c8801b3b06a4f50b580d01,
+0x239102aa73485d2a291639612b53c10c8a729f09dbf45984e80688332199990d,
+0x15c8103fc31eaee1fdcceaf57ff198cea6eeba5237969b036135084cd15e1b57,
+0x1ce8ba9e5353bc50ec8a7cada1fb238a643d6d1c03449a5ad1b6826807821747,
+0x13cc546736c859756b596bacedfd88344e4cfe16abcd44dfabf1234df19fb7e0,
+0x1dcecb2dc57bd3cb8ed9aeae4fbae4f40e7ffc8dedb72e34c84a9318d9863678
+],
+[
+0xb5944768d61c1b3562a5749f4f06c4dd085bb562b838d7e2ef14a21fdf524c0,
+0x251e1806f1951c2a33eb6ae39afdf9be6b971da924ae9920246d98bc435d9c59,
+0x2995212cf7dab0d9fe609ab9e441218c5181d91e3e2f6c5b6a07800c8698fede,
+0x23f10d62357467c7e71eaccb73ec7cd5c44d69abfb91849559009504f81aa57f,
+0xd435e4564d33704bb176ee01b59499df851abc0dd5bbd64b3ebdf9635ca39a5,
+0xffb4165b1b9e112cd77c00ea81f751e9a2d46e3071e5bd3007fc3a987e842e,
+0xc55394f0fbacf892378bbfcf44b8e9475af7e5d7e2373b65c205da9b1b8188d,
+0x1563ed24f45a7e60b65a0379df8dc871aaab1b5cbdb24f9f675daeb6fa138423,
+0x270dd42f73034ebbfbce9182a6e41fb80cdaa78c06605db3c342c0edcc22e577,
+0x11293baf366c075e3cf66c9f14a4899e1d9807460f30af948e44c06d43d37653,
+0xdbe92f1d5f635e182354a066756bc119c14060543e78a467507983a74f9707a,
+0x22b8d93d76a89bc36f0b5d6a1ec3c6053510622713e2b833499ba773dcc0c217,
+0x23b478d2e4e21e478ea7c859da3dfa7229f6a2fa20a2ef1f406d9fb0a7f62f28
+],
+[
+0x2b04d6ffbaf7144012d92c5c6212803c0b5bcc0d7b1950b889d1fa6f3e56445a,
+0xfdaef081ffa41b2a3c6f8f4c23a5980f85b3301bfc3c342c938199cf71aeb64,
+0x33a135f38b760028fbd4b2270791912b0e3008c2007a89b30621086f994879d,
+0x2e1eb1ea7a1684486cfcfcffff8c926be2670f226bd883d11591addbea75adda,
+0x28bf473bec9d8842b84cdf474a435da4108204b09ca3512d6ef73c19d0be40b3,
+0x2edb397ae478291b9f48edd50660fbc1b5d7d906947fdddc255ba787d02b0366,
+0xfa157820a600d4a78390b8beac81aaf6e8d1607d7f4eab0afa5d7ee6abc605b,
+0x283fa69d06b072eb8b27c7c655b71caec057124aa1669240971c1d04fa881c3a,
+0xeaf5ba40262c5feb646c4f32ebe7cd2a1ae38a83c48a04e0c1d452730d63058,
+0x2306577578a3acb6a7c070ef0649b6eb67c58224662895d470542fff984f5570,
+0x2f204614994166d0a9fabf6bf5db5fc3daf0bc16645f0f202989de9df97c1161,
+0x2a93e968eafe2ef56b6e5ef823e29d96b551221e994f08806f148c8d318e7920,
+0x2f4f684d1f698b3aef34a939ddab2b80696f2246a13250f8978d597a6a20e202
+],
+[
+0x29be2a42834ae32de3320fb0ee46b4c102a3d1ae44c5dce152fdeab5450c9c44,
+0x2ec317d402fd363380a63c205dd966e0a9fdadd78b8b9485273b6902b17ed49,
+0x1ac21ee4c3af5f8d60fb78d0c764adcfe0c20463b3d0abcd3b602409f2770743,
+0x882e85d15875eca350c4e7c4e59a820e47a8381321dc5c7f8f78aa3e1aa68c5,
+0x290075bb9d48ea0db89e805f26952bcdb6f96b1507580b45cf56e18c21871cb6,
+0xdc29c413aa32c2199a2de5e9605e1129b1e681163b80f82cf846ec5f54377fd,
+0x2dced935f82c932e7a2a837e2816cac70bf50da3aadafb7f8136bf973b0d3987,
+0x104de5f8e59f98489ffa42926a8aa9701c422e4f13abe90507106f2a5a60f0eb,
+0x23b7b05c996c963eaec7c5817eae6d0bfc78c01d9c5da84ef4acde5204c4997d,
+0x177a7ae9bc58e64a1b3baa1975c6824cc81d32302740709b0c6fac0ed9fc1958,
+0x1552bf00f696b1ec39debdba504f79ea16c9ac75458588eb8a879908c80c22c7,
+0xbc4a8170c368a03c40fdb65123bcaacdec1f9ab057747d5a2562d28f4785ccf,
+0x2593132f444b3731469755f9a76b92bb29f2e89e264ceb1e2881a4aeeec2751e
+],
+[
+0x1946fe9de0a943d5a716eac08561cd91f9031fec82da9ab72883c7b218b11eb7,
+0xb5cfc2a2895a6f9f5ce97bf05bcd5fac012d6737d93be00df14f91d0e6e8d44,
+0x1176eb406c82709b00e6c8aeb7437aee20d0e14b34c91b6d4759d425cea472f1,
+0x151f15179f562e6fb43c853c9030c7d95da9bbcc9350b40862350b4339f74320,
+0x1d83dbd5511b6cd9e553e82ebce5a91dd9f423bc9e311a211d6509e37e3c8283,
+0x62edb4cec259e007c26a95be576fc925088cd487260bcb67fe88dbba993160a,
+0xa390e27ae606a3530759c877186ef25fda97764052ade30cb5533f0ae878927,
+0x17a961c4c7f021105e4facce2011ba1f6f7e4c18c6522a8879b371bc53eec16f,
+0xfba90a3180e89f49b981d7f2d369f14b354f586ca695d5be51d562bb24f01f,
+0x1b17b06f9727550affa91416dca65e6940ae6266c426f46a5b2a72201c9bf48f,
+0x24aab8dff690a59f7a16863d2987edff9d240c46885a5fe39ce1400c1c6638e5,
+0x48ed2132edee472d9b39de6eddaa2ecd7c1259af7c64ea368e66882d3cecb15,
+0x3ee389275c64f648e0ef79dd7ef8d7c4034d8b0ff91a834705ad383278f1f7d
+],
+[
+0x1af3ca6240a55aba55df8e49835b92fa17e39ad5701ef70f8144109f894bf1d0,
+0x2566dbba85110cc708700743aaa5c7061b174365a8efb5938b4bcd82ea79929a,
+0x205197098d6814100ccf6c908eb3792b0294290afe47949c85b0cc054a60bed7,
+0xcced1f9a364f77fe44b306c4539575f8b1ca45758c4fcbfee234e8dcd973ba6,
+0x305e20ea1b93c0fc73307f4825e80471da211c98323f23b727919b63e42501e2,
+0x1e473b357377aeb6c9eeca4adacf0ebbe72df720bb533055f056eb9f2c13d536,
+0x56d703af2f1982a482cc560c2f4f2da32ef0356c73ce35f7b667b8f825b2451,
+0x46beadefd1c7353469794eb81f574d38910f72d81431159d4c532eecc18d67,
+0x2ad6ce3498864f0ae788665262f8b99756997eccbe50d70338ecd68dd1e92522,
+0x8b39764e398e29ffe39a83c045a1218036653fe8071ecd3779cc6e79e643fe7,
+0xffb07a9dd49578818cf9781beaf8940764dcd2f07aab4123f4c9f030513f622,
+0x2e7b46afef5262f60443669d526b99983678236c8f5433cd130defb06a39023a,
+0x13c717906e68279fd9e57e6419986ee2cfdf96b20d200e4adb31353b19a91470
+],
+[
+0x81f58a91a4e0d100e0369fdd81a190035342fd0677ee1bf5215e47f8e58c2c3,
+0xd94283e58978ce187d463c50a7277cd3c80e044e15729a6f8ec0422f2ef8b84,
+0x440a6e12fefc1ebdb82b5e69c461e3e332fbd297474c18a65390fc8649a3d55,
+0x12146efb02498c13aceac7fed685b0dd88fbefe8f5993c0cb21b0b4bb85b11b7,
+0x64b0712fa159104820ac07e0d2723a3bbc1d1295ab39a108e2eee8230131f6a,
+0x1e0f62f785734194e76cfced2e91600716eb46fa4d9235f28e47e366110af98d,
+0x8204690216d1d2ef851dee5e4edd9fbfe66f098fb61c231a0e89bbbd9e9475e,
+0x20bac589a995937086cb727fc2561ed052489eefb58cfcc260eefd58502b1ac6,
+0x1f4bd25093fafea78a9db91966e6145c46472a4ed46af710826accac2034fe71,
+0x278c85ceea23e4c040b66e41ad9cd09a7d0ac6d3457a6e596df14505f071de2e,
+0x45ee69f0bcde13dcc97f5910d8228124b16945cbdf38db33cfd3933d2c15c97,
+0x5ef0c0803ce631e81fcf86a7c270ded90e8127485d424abfcfa7c4a9da7d8f2,
+0x12b584469f8cb8b5c200bd721bb2c299c5e63422d730a3baa52274093f9fc085
+],
+[
+0x22a852af90680a8ca9688b71ed27c157d02b406bd6c7fd8121d7c7793ad2305d,
+0x239a362ac4f07cd888facdc5e32f0b42e7ce6485e9697d14fb4089bb6074ead1,
+0x101185b0a8c7d142bb221c50fc9840e9c5a0bf1110e9dc717b354f100b514422,
+0x2719aa9c388ab97e084241110f428722c8f72de23a6ee33f7040c781fa5ae476,
+0x18aacbd4af9ddb42418648314a53accac4af473cb54e3dad906a0210b98bcdf7,
+0x28d0ac11170cf9ad662a2f31d00633af17b9f0e345889ce997829747120aef6,
+0x1c76cca8e7372edc737fe1755f75986a465863a66539143a5f21f8ff9b0f8970,
+0xafa7a7f02200447c0e943dd60c468ea6d1cd1e001505ce16ebbcc97297d6cd0,
+0x28efb92a44b7e421bca73b274bc28bcf74f94c7212d72ab6913c1709386c5e3f,
+0x1a03af000cdc46ccc12067c560bbda2a98119041bf9ad3ccd9053222fd2eb4c2,
+0x2409f6c3cc378966ffae28eb4adef67f8c282d8a902db3ba471d9540c0039451,
+0xad59025aa1e7d4a026d1f819695b3f7890b3d9631dd06f7da00abd0ecd94ab6,
+0x7591d69aa28fbfb5b65dbb6f4420106f0b0906151307b976f6baeccffe2c488
+],
+[
+0xb27ba82a0ffb98368981736ae927a227828985c00c3e5df8c1276b1001089a1,
+0x2ceb1780957827f9d4fac39214a4e82e89a82a760a9fdd85393b285dedbd8114,
+0x18259272125382f107a04abdc0d968efee527d2242e263015e121fc4b090b582,
+0x10c97f58b9ca58426bd89a59173ce8493d2ea8d3c6cc827ece2453ef193bedae,
+0xfdb0710ff8ec599e7ad5086a29d53a9d1834e1a4c71f0b6846849eb0dfc47bc,
+0x2008c67e2365d2e73a882fe3ffe416e8e0edf4a3c490dbb05d6daf56b4da0546,
+0x874dbfdc6d7035655981f935798b58b755c7a9d82876352cd26244518d67062,
+0x29d294ae7d02f2371a16b483b2102e0055080956b53331aa171f50de5d9799cb,
+0x2aa10edd36798bf46c3cb7bd749017867c029a54e0ead556e2f15cfeffb4d9dd,
+0x2b457a5ddfc105f203eaeaaff9af5149e02c6cf80a9327ed502b29f4c3602704,
+0x29ccc8e6be785237b8d99009dffe037979c7da79ab22fb062d6fc1f59d48a708,
+0xd829ea3c10abe53f0153b4446f6e2a250dbd79f9ef7c45745572826549109e8,
+0xcb3680ad25a34e351089474c8ae39b6091e553be4b67c2bd1fc7a62a04287e5
+],
+[
+0x4b46526207edc70a0d23c8438bc49a365635552dee240661a2cdeef966f20f6,
+0x1ce71edf5b935a231b0ea60402ba756a4bb45d65120cc0845f6c2ee2ba32e7ab,
+0xea85373234c815ce2693a734fe28705dc6fd3fb29cacd0b9f4edb694c15672c,
+0x10e60b02e5c0abb8dae47efa17b0582df94a3baebc52bcce8820f858341d7188,
+0x67ac96b7ae162e5d0b43715f4c24b9031c082baa68ac7638a00f8594bc3b127,
+0x293dc450b0e5c560a15853129e238b046a419ac6f0c8ec19a69bf8c409a73cab,
+0x7a2dcd14fb017674965e82174a35decdaad75e42acf3d5ac1a1e235257d1fb9,
+0x5cf8b0f380d29befa5eb75a0c032b7b7eafa895d98e0bc0e86f03ed066c9876,
+0x2d00dde97b4150107fd9bd859c5832844e6be0d5a99cc6752d97585b560c4b2c,
+0x6f2b210733fa0605a0cd753fb6ac80a0d893b2bef2d5453e5f6cfcbc6a14302,
+0x1588e892f9f2d3c6a7dce89f132b3dbec142bf485e2142ae05db7fb5d7ce211d,
+0x14c92dfaa3a1f830b20150093fa670dbef3c0c807f52321e5fcd28807179cca6,
+0x1bb4555d8c5f8bbb268361d5e1c22f9555f7c9f4fabaa24355c963edc263af6a
+]
+],
+        [
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x235ce940dbc6ae2af119016151581b3928bbf5dc663dc5f4b6cbf02305a440a5,
+            0x1f41f49e23f371de6ee0539e873506283ef7303dcf1d6171a47311e9fabc25fe,
+            0x2761de8796f7e0b5915f56fdff180ddd4f22001dfbf15bfc83fb8b76c2ed95a2,
+            0x2030fa119e7ea727117fa18d61bebfdc5945b9ccfeb4173b77b373a88362544d,
+            0x16fade125075ec0ee8bfb5acc676076d14b76e79b2daa5acd76fe6719476c017,
+            0x154054c752e6e827543db8d8d6baafb02726fd7cdcb71489510e89dd2faf5d5d,
+            0x1b492c6aa52f42a57aa6d9e9680c14875ca28a129fddb2fedbeebccb5c83cb4a,
+            0x23d1d1bcdf6c2c14376e6619ef855a718aebf7d9918f578b59025e9808936311,
+            0x1e509e854698b837ae62db6eae7730006480f64ecabc6189a6e923708d4aa5c1,
+            0x104a16aecc2dade9539007d7a631cb12e7ea1ab9fa18e4c8d158941e13322bfa,
+            0x167e341698c1e47880a08b21374178b7e318714eeb40b54504aea93443249f9d,
+            0x16ff745c57280b832126534f65a36e051fcf161483d1a9ac4d2a882d55c4b3d7,
+            0x16556da3145b12699852213b53eddd1859bf0c06464a69887a6ef1319cfe3dc,
+            0x1f52e72aec02c1085861bec46d3c952a7b17e3b859e1e119e29f9d55b00a9d20,
+            0x1439235c136533951e994a422857fcf8fd137963c823113e777cca92d5772330,
+            0xa70ec5c87c2873d1927e525972dfef236ff91f79962eac7db98fec13c3ca6b,
+            0x85c4d1ec109d4fe0daa8548c7b641d62bdcad7b01f0257ea54f9e6371d00550,
+            0x2f4b2580ce56a2b5941abee8b7f98ae4b89e652a005b6d378edca751823992b8,
+            0x134520116944cb30a05c694e90ccfe26376a23acdf44719d5e94a40c0cb4eba3,
+            0x2c6f46236b3de631bb23dded37fe4349e986b9c26a99382a28125b2123e9612a,
+            0xba54fa736725c45c9aa2edb10e2d160ee499707fc5d3fad092c6f6e60830363,
+            0x9fec55075da3b0d949af21227dff641435e920034b8f3a054f6ceee03f8bbd6,
+            0x2123de2c4d9657466e2c0994fc75161b658fccebcadb25d03e1005480ff65dbf,
+            0x15190bff5104801efbac26fe09882fa5d5aa2bfa702efcd1b9e8ae4aca9f2ee1,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0xebeb78e24789d13e315aed03d6f9a7503f8027ac8c07bb31cab7d9f7c867273,
+            0x1a7408d356b546b06ff9e11e706fe10311eddeb564d15f77e406c4a17eda0fae,
+            0x7b909e9b3d766c0562bf5eae630eb1eaa3f486b67385e9f15840dcc75a4695c,
+            0x2fbfae64d96df063622736669771b3763fe4d7e32a253b2e9a432fd404a5a1d7,
+            0x2e8bae55338b9e7a202278022d1f4f1641e8dfedcb10173f8ffa47a394a792d3,
+            0x95cf55bf75f13b6986a1d8dc6e23ef27c6e20049be69d275cca08a95c4fafd,
+            0x590c80761bacb1996152bdc843ee9bc8d9e1106d6b44143cac61a582c93c707,
+            0x2e2c9e1b232536be64e82e3fe38c9f83cc1e2ec77eb98d690ed88972c55d4dc1,
+            0x2a0bdd075038ef925104da5f80d436819a8896b46194b795f9ede6451882f668,
+            0x25e3f54e8788cc765abcbecddd2326c7ae8720dffc3df2e7cefb06bf572b019c,
+            0x2c4e38ce29ded57148964df0816fa57324061c515ed02d9f5ca4cb4231e72d9f,
+            0x17816a3115471f4af63e353a891e5c63a1de21b079324c7376c7fb778162d597,
+            0x16b1e612a7910bdbb55b44174b22b72b63ccf452f485aadb834a8883f7a1129f,
+            0x1cdbce6ec5631b7df36d7fbb1734c066329559906cf4c9cc7023b75445f2cdbf,
+            0x8527bb0455abf9205319b4178ac91c89d27d73af39ca3eb5e267b407dc122bb,
+            0x295a5be07d3fad3d9622f92a52742786741d19fa1f85424e6bb0383b2b3184df,
+            0x1d10e15e892ef5c67b06061e9230a13aef08e3a2422e59ce6a7de3bdfced494b,
+            0xa1cd7913f731a263b47880b483792d1eafe766bd397d6a37f9b03bff649ad97,
+            0xaef18db0541091f4d0a8c6c0e04bb191c3b3eca9abfe91b336f37688f82381,
+            0x2c240c1f57384c0eb11da2fefef668be130079616fbe953378ca4cee358ae80b,
+            0x1ef04e55dbb7768b7ed264223a560b7462d131ac387b0e06e091075b036c2903,
+            0x19df6cfa53448857b40764ac927e45c59a4ae69088b7bfec231217fb49bde976,
+            0x1b794d61ed2a335a1b6ca4fb2df93b5de924f51c742c97eb1f45262f4cee3ddf,
+            0x62906482824c01daf001d0b01e1558d7a2e921bc124099fa704a167305b0432,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1ee5e91ba44d3919a02a4c05a704d15dbd6665d3a0caa7534f062cb702e12ea3,
+            0x124e5670301689bd1d21125260ac980aa77f9927abfaf6625cfc4aea0542c38b,
+            0x17f39c51b4f9aba0b50cf36cdb63d6485b3f79e0f4c56fcdeb1668eab22d2ee4,
+            0x1e47876883221f61f5a85cbcf916e4255c146208100bdd75df2550b7f23d9ab4,
+            0xf6cfbc348d0c46f2b4514fa4aec63685b7b4a77cc187f39f90352aeed2d4196,
+            0x1ec916f0f8ab3534a45fb8b6fd52a0db612345f94a7d1047b9cb15bc4354d259,
+            0x2299e8cfa278c8ff8acb571283f8d58b07285fd3db093f52816286f8059d745e,
+            0xe63ae084d4165ef23463637d3c6c962642acba1dad62f5df322c00aaba6788b,
+            0x2c652dbc12391bab6e6b1642278935adc57f028d75ae594e23e869dcd807a04b,
+            0x23cca3a96c87c09a758f977f1e8e382898bdcc82debfae4df05bc7c16e74aab,
+            0x2f5c19ae2b06aa09ff617a2dad69858ae545b8a63f5c730d50312ca740d538f6,
+            0x185c013083f0dc7b1eecce3045555f593a1516f7c0486900029a21537acf8e03,
+            0x2e4ded90ce2c40cad391f536718a6f107838719e6cf002f2e914ee1db3fda861,
+            0xba3626706fae4da22a59bfc7d0b7c3cfff221ed8a6984553a6b605fb7ce4cae,
+            0x228687cdc81f4bd727891f41911dfbfe24107d60dda4ea79b5b094886e89c4cf,
+            0xc1a4374bc29963f2c4e68c51518e098dbe906d9c3a664e24938a403009ee28e,
+            0xb49ed175ec0cb65d9fb76b9dda5859af6f7eb12e0a4895c3de51228e33662a4,
+            0x26be812425de5be3e6f4fe6694d8b883ad156e67ebb1aacb6cb64fd41d64b19e,
+            0x17cd4b4c75b978ac369c026e0e34885bab4c745ef05c471d7975300eff003dbf,
+            0x28ecb3b468e0867e4dbe29f05490b90f6210108a30624715634e3cd6144085f6,
+            0x2ad2a688d5e1fc7a853d17ff8e29487e6a9fe8e234b6423425afc192fd6926aa,
+            0x177b3225d90e7c43f46ea85579f408bb2394983faa33d3eea7b7847e10b71a09,
+            0x18c733d3fc6d5c4ed730650c512b0b2922fa4ede0e4281279df25cb57faf1749,
+            0x25c287190fdd3f0fe552c72c747c521b8e47f042dee30f90c88cc49c425e2269,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x17223e88c5afdce6f98c3d3096fdaeb74fa99a0bf6237bb328466b843b5b481d,
+            0x17edf7bb609e24ab634349d03bbac5d92a99f1f54571cdac8e155a3767946556,
+            0x16384369e8e866d47b74c849496796fe485290080acb6d05a78b399906654ec8,
+            0x38414054cab9daa6484886487f9b1491a0424c75dcfd6e69c00f88391963260,
+            0x2add2a9f58afb253d9e9729b8510c6ded8cac2647871b4b2daf92c1ed8026670,
+            0x2f59f831ed16663ae1e72b27df74f8878583b088726e2f77e2a9b71bd5eb4e8d,
+            0x2c8563397614e4c977762b73467f74812d61eb6c921df0b18bf84dae0a448cda,
+            0x10844b6d701b264d333ea6d5496ee62b7f99b0f3e81e4774f271acd4e6dfc452,
+            0xd90e1221b226621bab0f84164c6bd657cedf457c1691c6492548cb503962f2c,
+            0x675d5268e859d734fadfe6aa6a58f5bd47e9d9bcbf7311d928562f772a44312,
+            0x231539abaa71d18f3c100449d2dbb5a78c8c6eca61debcf495670ab6881cdda7,
+            0xc5e674c55e57e981b8de7f89d00aa088f47c5b01c39bce85ede170519bceb81,
+            0x2e6b1e65cf7069fca7f5ffbf0760e5d2c6acec8da85ff34f2c3cd55f744c8446,
+            0x348474ad39c09ecfa686a8710a7737acd19917fb66e90a3df84d110b5b26048,
+            0x22380985f6c92bddd7a02d0187c845fb834c9b7e3664e1b064ec580536d1192,
+            0x215293044ac2044e97d2d06e714e937bb16844b2c4e834bc3555633a31ce1d33,
+            0x1076db0b38f462a6a9829ed423572f05d1658c390fca109dc6a5baeadb39ec85,
+            0xe0b3b39e33b5f0f7689976066d5aca89f070fb078152378bbe4cbf608330e0c,
+            0x1decd713548d0f04ca0fc3af31ef53eb04fafa773cc696bd5d7959d5b8781f3a,
+            0x8eea1ae2e1dbabf4e3969bfba914a7a5be05a672d16aee9029c3477ad75c0b7,
+            0xa3c813f669fd0550005be2ed025fd263f496cfc0c88708c5723fb6d4783090d,
+            0x1482b39a31e48749f37e6cd63f9fd7498b70623637fae3183f1805deb488df4a,
+            0x92c09a074272c56f7611ae231544253242fb998f1faf5a04032c897705cc180,
+            0x218cae97227d24e5501a8c68d0f9b298d102b5bb4870acec8ceb068b219c5de7,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x19fd38d0a9fcfe44eab81a88bf83e966f625dccfb8c8e663c92783d2f36f435a,
+            0x105b69e0c16b67fb448ce467efb92c03c0a03d0ee652aa1d3f57276bcda15b48,
+            0x25d1fb19588b96b835cf451788b64356dae74ac4b1dd04105f4ff71ee538e69,
+            0x1a3d3f0584d9937628708ae5bc1a677ca0d9734ba13f9f9bafd4d40ed09efd2,
+            0xda29cb284f0b19e45ddd3688a097cd2fa147726da98e7d7565480753c3d69ff,
+            0xbb245a4fe17933f1a323de946e9c79ecaefe27cb72746f02dd7f8a12fb97465,
+            0x12968abc1e49e916dbfd8d32c99add0f2522613fdfa603384acad50adb3c93d4,
+            0xb72090055db8eaed15c53223be0d59f134b6e2bc190ff8aa145de2bc81fd905,
+            0x2ec92e332d64bf0a6d53aab3202f16e8f931b0b3a19d08397981e4d67f7e6149,
+            0x10875e45751b9f7e6d229bcb6035a0f64d2fc266087bb15b46ed8dbac225a875,
+            0x20a28d7e7bf2393dbf1e8fd1b5957d6696a586df80ea755679bc922b32214f06,
+            0x2dbcb5a066131fe70e1035acecb96d60a3c48394ef025f9469318ae141b59474,
+            0x5d382b11621ce81dfa3b2a5b9fce537f18f3e1a3c11b744c44b7daee0f539a4,
+            0x2aa1cbda3b7224be26b553b60967d1e49a79cc1fcea1e28dcceae95257195fa5,
+            0x119d098ff4fcd15606264dca209fa31b8f90d343d73408afd99cbc60bf31b38c,
+            0x2d6a5ec1decfd860f606bb717c2d6fe04d5da0a512677bfb3b88c6eb828ccaa4,
+            0x1d44cdd7e0f9ff30fa262b991bbd4b25b9798c52b5475288dda93773873b70f1,
+            0x1a52bfe42c699db0584e9908947654007f895244c01b0827637fff73ee586351,
+            0x26bc0e722f88daf0ae3100dd3603409108756c81c2d2526d432135867248f06c,
+            0x2151d6544b541cbe98b57b17bcc32174691b7dede6da01a85964ff4d03c63ed0,
+            0x1dc401101c1f1df1931569efaa9db035fb7eb1f94ae9ce86cd6dc0540b1a1fff,
+            0x219d8e0b575d09e774acf4018fb6302ac990e13959c8bef55814abe703d0a4fe,
+            0x7107aac0c5aff7df10b39501354acdd1ab5dc0091d0166c55cd063c3a3100e7,
+            0x1541846836b18159c10af51567f8cbd22556df4f20dd74ed1cee58b3144fb464,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1a21b2733e57ce5cc36d9770c7eff1ae09c59af2a97deb649f35e034173963f8,
+            0xaa74005a1aba9f35de88f256300d0f55c9a568a0a3f962547fff0a2ffcf3faa,
+            0x302cc36dbcf39b2bb8f4ff9da06a95c8a904275eb4ef75a5b82fb7cb80133143,
+            0x1ba8fadf54ff193f90ce70d81d068ef1caff816cf4298a9e9c359b78c7b3c77c,
+            0x177e25961a6d2d2538623d70bd43b86651ec63b0ab29b1e706308224a0b7f68a,
+            0x29ade22a14cb16e95939ac85e6c50f089d187069df8659609634290249efc500,
+            0xc3cbc360d3cc87126d6dc733e8c0276e1b576ca318d256669a2777f70d89308,
+            0x138a5c75420e198be86010c147c10fb0b6c882ec10683dfab0ef1b8cc023639c,
+            0xa350052193a49d3255030214d15b36a10e7b2561890a4c851128603b6a5f092,
+            0x1002580094079011e6c17ea867b391cfe05b5e73c6de87869cf2545c10084594,
+            0x8c06521680fa7df05e7c8fb8a3a2ffdc0526051a59411a0cdd29e5f993e8f47,
+            0x2a3a540122300f3070651e9198f9d5bb0fb52546c35ae90a4deafd9baf4e65a,
+            0x1416a8824238910444767922e320d38b543cca200ea6c5591db9092e224be615,
+            0x507def96242fbb9a1ab87fef1da1a03f4c3349723ec4ae6de894e171a1b4af5,
+            0x2d03148012d730729390a74fec2d3e7ba9fd23f45e801657fc5e2a49b43744d,
+            0x19446791471a6f03c3e0e557ea0d4b24bbd2930669ed23dd286e81b7fe17abe5,
+            0x23c198ae993dfc34a55d2cb02226db49afdaa1b8cfb934a05ca594e616f43f35,
+            0x49ebd2c1b2507a1399a21690d0e6a900184d15280bda27f5b53099933aafe5a,
+            0x28eb35a44903f387f0b17a692fc99cc80826f9f36eb1b9576e2c5c4c48ccec56,
+            0x2e217b29bc22f5d1772b5bc1fadc11af5afbe87b223fd501b1b63ec28a77435e,
+            0x5d617f4148cb5ad818ca83e3e25d1aac33119f4862592430498b6c044ae087d,
+            0x196ddf78908da3e629df88726541e8f3dc6bf7b3434a93b25434b2773b546eff,
+            0x19f43813c7b1361c536509de373c74ebd978b0f3613d0457e59295ccb3447940,
+            0x1dac98a00317e1ad75b44dfd710de43a70e1a99afd151dec478a8d0b4ebd67dd,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x248389b6c1215ae80412361e031f9d19e83e305fade25b5151787bac24151f30,
+            0x1d6245849595c3f2e658dff1f825202f744288c73d5b6fe3e47be01c85231a63,
+            0x2828197fc5ec3d0b61e3cd35b39ff7ca0582844ea9893e47575ac698fe0fab44,
+            0x5f98baa94403cbee299a7c38bca231773951a9b5ec47809445687c1fbfcae21,
+            0x21c21725d982bf880516bdd009e9c82289429fd8470ee4f009281b6d610f86d7,
+            0x25161628bb96c434fcdfed33abfb03d4492060f9c12e5d6e11a30da401f65624,
+            0x98dfc41ac8db685ac12e9fcb277ab8b38fa0b4b943b5f5863189e57a4ec1726,
+            0x20e5160dbc32bb70dd2b667ff122aac9c9a209830d177d065eedaa37c238b6d3,
+            0x2282b92a3302808cdc7032e874419ad5b9445a5e6948c67e35af7b59647e6072,
+            0x19183560ff143e5d855665e03136bd60d6e627117857e45ce3b170d335d19805,
+            0x1cb1080ee04da98e9a546b1eafbfac68d7bbd31acd6602818742e1dbd035345,
+            0x2e08e6eb7f7299ddbf4e83adb2f544c8e2bf1733140eae2a24ca09e8e190ba93,
+            0x17313eb73d301839abcd85bcb243a96c662a9225d70e923f4966024ff3fea376,
+            0x115a8fa0b0211dcf5a0625e77bf00d4eec93b313811c61441d04e2e927f99a1d,
+            0x10671e260167bb4a73650275e517b30cb040d62e5d8bc65a23e2bab6fc0927bf,
+            0x697b10896487efb0a81d149a959b22c8edd1b130e18ab45dd5e4f287fc567cf,
+            0xe23561be0a6b6e5616ff582cba30e707dfb2d85aff42daeeebab0a41fdd2a9c,
+            0xe6c17540a1832e4aa8682e0c1ca4471e2ad131c70a6abd6333268f39568dc32,
+            0x77e8a2a9d0da541d9357eb1b603ee9410d49eda3140ba9abbe1b6cfbf8d4e36,
+            0x1ef5a47f9491310e04e85c853bc42a12227721bc8ef99acf866256c6f0ac2b05,
+            0x2d756bd8508664fdb9623bee29f62db368e7e9fb8c2f8cf806a2028a34a54ed8,
+            0xb6440027e32df5bd12e4075461952f0c0a169f47e498833a0338776f3cfee4e,
+            0x103b3141b18d49495ce38d5e0ab2a691e78193978da5888e36604c51eb757e96,
+            0x4502bc324657c18c59a6bcadcc0735e706677a556f0ab33468abf64bd434649,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x226880584a57a7c552da325ea532bf382c67482108870675bac5d3d9b6a71abc,
+            0x178d0b7b044c806c180b95dfbe188f99e7dad714554fae1365264f33b5204d38,
+            0x110cbd05beed208043ab1cba8a604abe596258c516ea0c68b804d2e262989e28,
+            0x2b4f9ba6e2d2e31078ed70f6a147e329d1c4b83c76119951dc7bcc6d2a944cd0,
+            0x1712edcd1662f4dab78bdb08c5d2208e096d26aea6d8b5a2f1ea1a575dc29dbb,
+            0x20e7ac1985805214842f811423601b3f18c8634e87b1433382bdf397b28b7e21,
+            0x5e6b0e267ea884c7a767266b614d9f23883f297a9c40b2be9daf6af85f31fd6,
+            0x15adb275543fbb0e083a10e1ec448b8eebf82185f0a99a06bca805737f0d7db1,
+            0x23f2e8816906f5fc349e99c8241230167b50d8db22c5e752d640fc319c7354e1,
+            0x8a8a0eb412422e0ff3bef4e8f9e98d0937293d8bd96c9ed823de14c7a60fe44,
+            0x147392d188c52fe487d5e14652ff175b37253bd5fb04ec9e316de4cf5100500b,
+            0x1a1a69d5bda4c559702d87b8ffbab347d61d5d5ffba016055b540409e90d050c,
+            0x26265b87f8fac4c16383d9763460242746a0fbfc7fc375a251a39e5cb12c8ae,
+            0x562af273c7d6798ad1772d383417f8baab7feffa3f8fe1b5061e695a63ea362,
+            0x2277d743f99daccb8223eee9ed2647e6bc22c5f00a0dc9b45c26898227530c02,
+            0x2ab7551e6b4731a0b2c00c1a1c57ad9dd66b2239a2754f64328d4023249f331c,
+            0x67e6bb5600490688a67ca30a941a68f15dc97eb418f8cecceeb1d1f49af1cd9,
+            0x299b048827a0cc67b44e53fb5897f27c57c448ed25d4be88b1b81b22186c0017,
+            0x4ce6cdf689338f7df3c3ba84e7ef35ef59adce460340ea0d161a45123c4051f,
+            0x17631e8c563356367e1607096074fcd220d0256a60e1e6d145bd243c5475cf9a,
+            0x25be84baaea86bb16bc3de4e5578c796e1888ac898d37f1f835ea87f1aabcc04,
+            0x7fd81c59493a306dec9f05c012a96c113a950a44cea7de572af401db8804f2d,
+            0x2d71abfab45aa0b3d4689b2518ae16f87cb60b0fd9d40c3567e5dea122815ae4,
+            0xbf1dacc9ee49263420b6b40b061e1de77884556be4629a011bb73c3cf8fd282,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x207e38309d97a6bf02d2c9071fb8c0243a8f6570c15c1dea211dcc2cbf45ea49,
+            0x96401efc3b429395ea5c187ccef5c551ed99043ce3abe10e0b2f6c0fa0d29f1,
+            0x25e2fb13f405f8cdc60da80af2df8f7aaea21aa8c5ea1b80edc22261c424810f,
+            0x14f942438d0b6308e88366af640e59b35e7b90dafb9949cd395fb9edb36e57a,
+            0x1a732391895868212d93a33c0c4de589333631c8260c991f7885b916d0037272,
+            0x1e29088ed2ebabe07ada9617c87d6ae3eea384cca222ea5983550c9d25bb0648,
+            0x5ee285acce6181041543d01d650e8314690f337372341336b4fb1b27dc1bdb2,
+            0x252b8b5dff5e6788b2389b2e55c939e69871912bbcde09be55a0baf9f8c7a67f,
+            0x5198e4ac3158c2f1f30e9c7333b8f185372db43467e884f9961396b75f7d60a,
+            0x245a5fd31eed8204f89bceedefb467b89e3cf7fe91d24a33a3207bb6f083e19a,
+            0x57bc812c85f04480fe94410a106b281d8f3e2d54b39e4fb45e0a5ead0910dfc,
+            0x1afeecd7c598ce3f7281378c2e514c5be72109df6efe311497dbe12a819e406a,
+            0x2fb8c6d1000b2bf11eac94956464fcdfb9633a271fa8b070f4b63efd7b5007b8,
+            0x32899458487c72b4c48dc1f717a0b2aa3ce53b6a4b38558b7737ed21cafe78e,
+            0x662f06913258bafb5bdf1aa929332c7c97d4c4490c6fbc8e798335ff76e126b,
+            0x1584478d313986eb0ae24f5d342d3ec738138d749b5071e839c1693af46f3a3,
+            0x2dba025efcaba3d1c4cf07885e8fbc1f11c012bcdc009087f306a399a7645111,
+            0x9883180be89d40f292405a2d44f5b9bba1c37613ddf84bf28c4fe593fcf06ee,
+            0x1ba2bca86f0f3a73f392649f65c1eeabb57e3527588289b4820a391a46475dcd,
+            0x148b95dab3a784e6f57042365a46a01e5880f17e09f3141bf99c53ee8a1ff06,
+            0x209b90e92015a18f13bd1343a34d905fca3ed55b88bf1eeabd3e542987a08628,
+            0xb50cbb98c4c16293795735e6cad9a458e2d37f1c02af95b15272aeadee5307b,
+            0x28f083282c1dc347bb8049f59580fc82bebfaae2fd4d5c3198eab42357656c01,
+            0x1e3cfa063b3cd467a69c8a628a627faf26187744a879ed796956bc1e3b1ba00c,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x22063e51a25b5a045914651b3b3fbb41a432a2cd49fafa1a6da1f1b3abac6b39,
+            0xed1ee65d2b2cb52e5c72dc18084cdaffdc8eed2dbf45309a9b31afa3239e0c5,
+            0x9f1f1407a395396be8efd490907e71b2a1e1a761f5599060b1ddf9babe3ec3,
+            0x24e22c3cd40dd01dea8ca00b4ac1dc8cf2fe8ec7404f09decdb5f2e27e4f6a51,
+            0x297d190c65439de912d9b19a51a34f3af3062388bc90dcf02c95ac55f827f393,
+            0xcbc6af2a7286736fff8c442d20accea23f927c42de68c5965be6b73f787871,
+            0xbf4731c628503367f3a0979d34ebfc4e1b3a6ee8cb90f8e145ea71108f77b19,
+            0x74ef632df5709022478511a69f0c35f167718dd3943a871dbabcfcfafccb99b,
+            0xbf311d6ae97647aea1524d5c401392a2a6242420918607c8595073f00163f2b,
+            0x2fb17a27e5d93c8fa198091d288eb25cc9a75a3cc2bb29c73b7c4962ba6b02b6,
+            0x17eeb974a4bb33ec349adc4e3c5e9141c3fe5b52b8a9eb5f55897fcd3f13dff5,
+            0x16c75dafa94b13f4baf5a849aa93deda4486711f92188ee41083f8ef0e2a19ac,
+            0x122da8189ad70e3c28109ade01566f47039ce2a35d85eee2f2212139d7e6a83b,
+            0x260972f4d1166f0a53272aaf203d54909f372f9ef5175fa8d15f863299bbac2e,
+            0xaddc83c8f239eb4617cb1a6a99b9ea314b775252379d4a28092946834ec18d,
+            0xcdfe4ff760184a4b1e1c7df835824830c35d9ae719993e1c8b61968341c74ff,
+            0x6cb7b1d7ee8b715c2b325853d8374f2f1edd1c47defc42d560fb1ec2ec4093b,
+            0x8d48ac917970f6318a8b999fcfa64bd0026915cfbbaf2356c0e68415b42cf64,
+            0x20f5eca934a922f2324ec4f5cd1423fb342004e24db642dde32d4f49b020f19d,
+            0x2926c1107b74752a5b0b0326f9775d3c0290079b81f1ee7b3540c857a2e6e7f3,
+            0x2ad7b40da5583cbffe41e7ba8a9dcfa0aa04526e17a359e380152ab05659aa3e,
+            0x157176042c8c3678e6a57db77c420cd2aac6658f392eefec6bd96ec3d75d16e1,
+            0xd6e65707b940bb40ce868be699f58d8f328c635900db4f738d9ae05b337e4e3,
+            0xd794b0f796362925d3c3f8f7a5fc0fa8995ff16b7cd198a7a4f2978033d3e61,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x20a525ca48bf502bca0dc9aab020e141e26b38ec47a44e1580c0d1b616351398,
+            0x1ee320963332762900b4744bd20f6f06d90663c9a45ccf876dfa46ff7b6a648b,
+            0x22635f8210cb3cd5a5f3d6f3c05db35f48f4dd99ce9689a4a49c1396fd0254b4,
+            0x236867069537dc76045fbcc34387c0d659f274038f60bd46092c7c5c6d2a93ac,
+            0x2949bfabb09d51a438ba0c845a569c3cfd415a4767babba43d49b4a7d23efe57,
+            0x1834d2d0982cc3e0a6783a1817d0a70935296a1e1cf6ced2fb36e49399ff129f,
+            0x42688f81e90f021c645ab69ead85df5637e8c35e5f747da2b9353fba3614759,
+            0x2cbf3eaf39ad0427ce377701b0aed081ab11a4d8425a5d85eb6ed545e02a3e67,
+            0x28ee79339c57962491524337981f039783042a61ba46bc4b6d27842ce253e295,
+            0x2dc6b0d76d332c582bc225e0e3852a84e670441a34a35271183dd071b3a8b9f1,
+            0x7cf8620fb65b2763c494dda02d454c32d86918bcd972c81af8896daa2e25220,
+            0x19d3305037fe6d5dbdb1c2cf07dbccfbb3771dd745a1a776027e76b829c38e15,
+            0x2e6f19575b0e917c325b5455bfc97e65b080d5ca3b0d866a13315efc1f5afb43,
+            0x1e726c0acd6e169de2eeeaceff128e7691b7d4fa8a046ed41a828563547a3270,
+            0x2527a428504d8fbad1a95451f6968dd7750e9b88eb737094d0d22806ea461bfa,
+            0x1ee0e151bffcaf72aa962734818b53086af9a5eeeaf821fa85a16ceedf5006de,
+            0x1332d8ea514225643ee26cf14ed13c2936780d3b0df8d13a0d80c7593339dc1a,
+            0x67440d1b5c5c1e37921583ac6081d7c0b614430461abbce3445fdca1c25e52b,
+            0x217e15b68bbd0d70328ba92eb9848533a76fa177015bbe167d9648e216d72fb,
+            0x1d5f55517167e8f4e07ae1d8fb025baafb68072f0ecfc39c2ab6917e2883f001,
+            0x1ce431894721293173604b5423cf3be2aa2a4c602244ca33cfc474364261e219,
+            0x1870cdd25b0026ceb6ca8bb7a4abe4c835cc54fb5d4a2bdcab837776e4a41f36,
+            0x13b6c4c8a9796559718d72ff32d05acd285d4e36b24a0dda09181dcc0b821225,
+            0xe59398cb50c995ddf9469890c14f7eb35b6d1ff21b54fa88d75105180cc9c84,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2471cdf128c6570022fa1786a35b379627cdf4a1cf0c888cddf80196fad77864,
+            0x1eddc8c186b5952235d179801e4d1f5526b26e72d637d482d34aaf8acdfbc678,
+            0x41287596ebb654ec2703cb288320c78b03e252a98d304b5c670d6a9f3b75f11,
+            0x2d27cddd60f27e931720ad20633a2e0aa9e9fb34e53a1c92449c42539836cc84,
+            0x386464e269edd20cd4abedb92ea083d5251633ec2ed40b9c9298a6b03d0c47f,
+            0x7b28d6f381e7fb054165533e6c22be7235e01dc2111c2586c88cb6b13915daa,
+            0x25a51836e32d3111c1ef3a5b222a45a8647f491b251a0e7d548aa579f04dd532,
+            0x4133c14bb36f4f02735144703cf36b0e6eaec35a23b23a5b3d7bbccce729e3b,
+            0x1a107c44417a85fe63fa5f32beae1188f7ef9c7e9887840e06c41442065fb590,
+            0x11963a7f8f62abe87fd0e9f059bda23e56ea044fff31672c16653096035d6e60,
+            0x63942281da7187cf115521332a5480ea6297764540daf35e844f9a9db14df1d,
+            0x28323184f7d03f5fdb8c55416291a0f2893f3f8f704345fd197335bab60e6313,
+            0x1d5ee3c314bccd0507e0e1f3d22cde05f8beef4006bdd196d1cd972a00f328b5,
+            0xe3e7e1bf77551287cb3436a06bcba1356aee949507c50da7075fba70259055f,
+            0xbdb1ba75288ad45c653e6731b73fcf8c2e5a06452a7e9b1055349ca1b954a8d,
+            0x163efbc5313a19dfd299b4f7d24ac36fc09dae316bdaad22f2e7354890487b3c,
+            0x655a2ee9811be4138b87caeac43693187ba723a4a252e1fe5aa481cdf35dcf0,
+            0x221ab7029ca41cb3703fd26fdbfd99f83da62e3d6aed9c715fda493e703ded14,
+            0x17e06a11e4766ab95ae693ef77be2fd5a816abeb8af48e77812af31a9bc97556,
+            0x24fd79ff869a80007553fe52dae87841d271b05d3465e21632e97808db658a79,
+            0x2937964cb5feff56156c0a2d36e7d717f5133c52311e8a9250e3e538c6d6a2e4,
+            0x115b54ca59723ddcf0b8b72e014a3532bfb9461db00c87b805e6eb6f950eb2fb,
+            0xb83ba59544995c109fe67c59e1c6682df4f0a94420449255f2e42125d1522e4,
+            0x856ce0b9c472642563a58f67fbe8490d213f1e60c841539d6593ce72c8caa75,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1234cde55f1ce07e8add8919dc2786c2a2e8baa0699f9309a24a6977cf4de312,
+            0x2728518406453c21f80cdfbc5ae5a7e5bc660853c39c07f08f4ca48b866fe708,
+            0x263c6e870681a568879af7059e9eee6c2107545775a707e5d397e090bb406681,
+            0x264b910c5d9c7677ca26b01c95b2eabda02155d239a7525aacc9e7c3a1b31108,
+            0x3626d5425f196e0ecc625c95caf99c1788ab08826db99cfc994dfc07cf7cde2,
+            0x285b7fc8640c5644ef5acd76eba635788490408488d4c1c7fe5e154882885b20,
+            0x806dfed34a9e837d6269442a1ac7f06b9329bc91b841651f866d001457a7e47,
+            0x17d501d18a443c458bc2987ac700a167935fc95c0b43b2bc31d3d1e66f4f4185,
+            0x1c265144d850ae945f896d29b8d25558fe572437cfbb23c0d2974ed75a8446c1,
+            0x2d349fcab317e2f10486728b85b73fd55ef9e72913db57a96de3799d79331a5b,
+            0xe3b16089c86c7518eccbf3e7b5d6c93a7f57dd663e313bd9278599baedbe8d6,
+            0x16842185b0a19379239ac6fc9576f9662323e9ccb19c73ca551dae5a204363ba,
+            0xafddf6a0ff562cf8cf83b9b4aa7f77ca5944dc203e6716ee136947b7774d185,
+            0x1a7b9bf02113552d2267b66a6a183c58bd9b0a71b607424034ca249f48056aee,
+            0x1b292db8eb2df955d186044eb865b53c345855fb04e0e7aa34728f3a33dc8f61,
+            0x1166bc2548e4dd1a597827e1ff6b873b8c029056733c2b15524595f6646fb9ac,
+            0x27ef791b1fb45f73950ca3297ad2eff668164240ca0fcec4d505379347a4b32f,
+            0x94e36712d3e0387be23f4e8d2e8932333c2b5b329ff01b0bded642875aa8d8c,
+            0xc3cb8c9451dc65e2baca4021012b4107b1277ec1e8cf85684523a86f4452caa,
+            0xc16066d636413dba5340f2dc58657da3d04fd4f649280bed2ad6c43dba22557,
+            0x26f53db3a19fbbae833e6dc50733326512531bacac05e1142b5169e0a6f37b16,
+            0x17bfb665418fec0ddd649243c3b77515e92eba58355437ecce39a21b3da565de,
+            0x21ed66971a5e0e1451a9657918e2bacc2cb244d2f101e4a870b7c40400d8e004,
+            0x2fc72d372345e9a20344054b130f91cc301d409bd2ede08380b1d2cc9296a0a0,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x242b4eadff11c6d3d54f5372755d36c9829ab3f1ad36cde7fad1b4927bcfdf7f,
+            0x85e6d5205bc517634147ec300edcf4d8e40d319b2774da859a677ee823b3474,
+            0xd7857f8c2ef1d3f6cc0b9d269080a8352f716ced9a8541b58047570931c9a8,
+            0xb8a79f4d635ec38c11720fdb6bca9a37e4ef8bbfd3c3a753815ecc975c6b1da,
+            0x2d581f4dd4f7a4870f6924d8ccc3aead2778ef1e6dd93b766faa89733c57534d,
+            0x26a82a89ac34602384406faabac1204664088042b012c62c312d10597d4473e,
+            0x119c9ce0168defeea8eae1085b57836db28898019661e84f988bb0c5dd3cbb1a,
+            0x1fdc49eac128a24057128d92ee2b8ae3a28d2ae331e53e898a9cc4baaa67e144,
+            0xe63791edc085e7e68fe844a1e288175214f53697c447a06af668ebaf9624d7c,
+            0x8e8a95d72c8b0f5572e434cd1e8f29a22c7a051beefe38bcc1c8c67021b6cd0,
+            0x150bfbe651cb129452581c0ac0582068914d6b6225eee54f3d041e8a04ee959e,
+            0x1f67b188cbddc9dfe73228557f41e28d562eb71233399c51a1120b6f6aa84fe4,
+            0x3a94eec3b3b00da129a13059883d56b89d02876861ccafd677f1b692e74dedb,
+            0x8a03a992c391bed4739308e90e2039caf26422b0fc314841229d9e65e29305a,
+            0xf5db68b751ab629eab8876005534376e79c4cf2a3c0ce2c7681a9a67787afd5,
+            0x14c1cf9ee31fc11c4611f6def094e6928ff1469cfad92b71c27eb02938999dc7,
+            0x1c8430170e0d27fc8523ca6c5878db717b75136669b58b0582278e4b6a43207e,
+            0x2eaabbe95b7e6d41e239af122c392f2c8a422309ca8fdf3f73fd18c4e266b50,
+            0x28b85f746bc03b1a6497f9a85fa07e337b664a8e01bf96a096195cdd8dcfd78d,
+            0x2eea090dddfab6d9d45f8fdc01e0697db257d6481ecee44eeb736310a57194a4,
+            0x29461ccf449b9fe3a48b3527a1b792f31761ce88a12a1bd185d02989048c6723,
+            0x2d1eba58a7196aeec7ff60c922a6a37d238bda29e3578e754940fe55f6b44f6a,
+            0x1d8488523480035454dd45ab1136e55b48ce729fc37fb3bdf07cd401e3df9864,
+            0x169904bf4f7348ccd343513cf038cc546cd137c740b77d3df58ada6cdd49b292,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0xfaa555c1adf771edfa1b4f67a73108c7325be034cbc2c2e6d24554e62efd737,
+            0x1a4ceaae57de9dbb19bb3701ae021b7b246fb7550aa505df8f95be742293b7e2,
+            0x22d8eb68a906dcad75da8ce62f6763cbeda8004739851057965302696e185ae8,
+            0xcfc82aa08b2bf7faf7de17be9adb759389c398441bdd294ed0dc25d3f7c4f8c,
+            0x216a462577d231190606ef2920c63455045b8d51fbc6981a103a5135335f83dc,
+            0xe63715ac0c89614281493e16b0bfe6d11194b36c1247e22838771eb1ec766ed,
+            0xd024106eade54b9f8b5874bc7c3499487354afa2db7df3be1a971c8d2405265,
+            0x11daebdd919b5622e294312a5e34121ae33104fb3e1f9e89dad0668f0517158,
+            0x274a0198961e0c98ea0f75fe1e38ee5e5962225738d6c8edcdd5623e7b24eb6f,
+            0x136d49834864e42917bce7dbb0e439d28c2007fbf09beadc78497d1da2593b58,
+            0x18daff02be933186319ae1bab91e42256c5b56ea3d2d0698189294828e2a9076,
+            0x13fbadf8255db09ad6b28d0a13874e8586fa565155da2145f80fce40f0c175f8,
+            0x75a76152cb77f3a74ebb64a8b949d032a2e1ef7ef0f35fddcfd89473b5c1e71,
+            0x1d1a9d3eff8079f2fd739a8c1ec1a1d2c391befa15c4497ee78e2cca6a327495,
+            0x29132a7d6dc081cc6d7a5c3524f2805c9ae3c66a7de1714c4e75a9ed06206bb3,
+            0xc1457b4dc6efd6f506f14d2cb839adb6995e2565223add3079801818a2b3b9a,
+            0x66406956a8af95c2f8e84f977161005287832eb4860d0e333bc2a6738be404e,
+            0x2be8ce6965272c3ea5fef305d80056972b0cc10cc89ba56df234736a8168895,
+            0xc624c5b84f86974e5992e2bf99aa7406db0bfc77db799e680ceed051578bb65,
+            0x1c9fc7b076255b1dd44a3f77be12b8c0c7136880ef39f02aa002253ff808aab5,
+            0x1ed5752920052d66ec89e671965ba4ef5beac9b982b7405174c8c2cf62ba9c2c,
+            0x11a79d9e71816d2f90a16813583dbcb286ac19f81016b01ffa4318be074997d1,
+            0x2332f2f0231e1a5f4adae2661a4988c773f58f806ad73cec7fa8410327c29ef9,
+            0x92041cd3c1f24dc8700053b6d0b4d130f9709bae71ec397d1ebbcd08281e1e0,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x23402a04a12ab3776b14119bbf85cda4e8866dd1c8c2ed209c5cf5a94832d9af,
+            0x21f6d7c6cc0750868e0310bb8a7fe02b70afad0229fdad5c5cf38f7231d80528,
+            0xaa11c91a5f547de0061ad5ac646b4f17580e985d926dc48303da965dd994672,
+            0x2542d51f269de541f7040d7d707fd4d8a045f02c7f0a662e0458abd1c787cfa,
+            0xe9367b46e6b89363dc9cfd523f4abb4d123a0af9eddd5e356e63e3d49092542,
+            0x13d2aae41f6b1c1b5bdd9c576c7458709c75eeb7af22fe0b7f5d98ea20609007,
+            0x19a2b2dc5988a9ffdd458384dd5e0cee7970afb38c1823fe897e485fcda9dad2,
+            0x8dddcf32490be94e7be38105e717382f7966deefcdbc67432c312b8aab15a1b,
+            0x1a30ac3889e0467ad2178fbd85b93ccc493565c376202982dd16ec9bcced261d,
+            0x2dd2470d7ca5e69e5728e76adba044e821425b245bb5cdfd48132b4df5f362e1,
+            0x104563d762464be13f51050d3d210162ee31e4b14f0e37202aad99f8723f0ac0,
+            0x121b7e910a0ccb4e4d5f220628cd64c2846fc5f470a7c2b6ea38170b9d058b38,
+            0x2fd423fe5d1899fe054ff1b9684ff93540bc396589289388681b90fcb8e76c11,
+            0x298f732a1a912702fa4c4090d00861d99bbd4eb800b20acdf1c9d4a6c8226a62,
+            0x26f56ce61eaed10294727014eb88ada99fe5015c911705cf7ed7bd8f04269daa,
+            0xc316eb74780def4c7c08420d1a887d3f3b8028f2d65ef3e18822ba972a50c96,
+            0x1db5c65a2d669c928e82c2ba7a85213d03976e7355bd3aba90444c8d8ecbb108,
+            0x29fbe3f0b5d6936f4e42cf5ed294e1a18f7c597faefd0087653f06f1cd7ce55e,
+            0x133f5377394de76650324177d895cff11b4edb902724138669df63d064254274,
+            0x1762e6a990654a18eb15171a84030e43a93481ec520b86ff65263055551d19cb,
+            0x2bac62e64e374a494b9ba34ac9cb872ccef42966e1c98c9d12696e1b7b9caf0e,
+            0x1dc2f5d192b065461e410a353b6e9ed48f8dd9a5b59e0d4567add1ca1edbbf74,
+            0x1e78930fbea45070dc63eb82fa3b44feb8811842c8040f584482e5529b9c08fc,
+            0x1161dd83445bc4ac05e88f82b6d4b395dcb7bc08bef6bc0394e2860e1b91a45d,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2d84302b2f1ce369033aa5de5bb8498f718102642636ea98a13d9f2f9e03d70,
+            0x3aa0b6d1722c2e927078f0d0d2a9e1651a387b0a50aabe4c3e9f9e29ce5808,
+            0x1851a25520c47c40439abf21fa5b9007ae1557a0d7a737ebd36922e1ec2fe713,
+            0xc88238b7bc582be65a3d9780b1c502a8b2a6bbfcf63863ea988e4caf6e75767,
+            0x1231dfe4ea1c60c263b7a7f849c8d8cb42c5506161b7fa87e527e917c942c5e3,
+            0x2ea0849f20d6ff258c0f184ca8057bfe236245dd4b8642c64e42ef4a1a9d8ffd,
+            0x1ba62148f57f420101c599eeca0abf930464f2c0444acb90d2fb96d3db62f7b6,
+            0x21f4a3066fad0b05bc69b92e00cea13278d1a5a67436c1f3f2139a6ee79bcbda,
+            0x1be4c6e03d2807854d234372f267581058b173ac8b3c7483c6e8dc3352798b79,
+            0x369cf9d45a15633cf75d2234f1014f60d1ab30cca21b0fc60af3c0fba6cc06,
+            0x251ba00e6136bd990f4db7457a27df54e6e6a986726cb005ee21e173dc9c982a,
+            0x290465aa219c5f39fc7dc5b210ce805d70d3137c43ab354abadac718f5357e1,
+            0x72153d3d9304bcb121e16ac43ba352e3492aa9264e39abd0ad500003b2c1a0e,
+            0x9ef6ef37f5f703229c7c5171a54a9e7d70151ab47b6312a3b592208c192cc2d,
+            0x1041b9436273bece36bfd9801372251c2e753b50485953908c35b63979d9fd82,
+            0x26afe74d2bbaa76d568a55b8fe35f02e5e913285cb5678ad631654ca03e11f22,
+            0xab136a0298a4bbe0d53250d7be1179123aa3f7390c39c08d76facbcf387efb2,
+            0x2154df61438fa728853b1e34064bf3bb988f36af48ac6097d2845a4ed924a360,
+            0x59b12d8356358cdf3690ca2259447a7147e0e6d33dd5e0c62293c1fae3c7057,
+            0x1a01646ed40505df3ebd020f7aefb2dfcd2b194d697f78eb2c6706193e25c783,
+            0x27080e00f575ea9dfced456747507b55a0612618d5377ba4745b1a2c007fc4a1,
+            0x3b12781eea743ad978032243b55ffa3c23ba980f8f1fe48f72ece1ffe09b1f7,
+            0x10ac2c9f77fcd414c3bea9acf7308733892b1802d061fbe3e5ac7d93a437c85b,
+            0xea74b2639185bdaa176c285f7e674e4ade050bb08aa1eaafe0a0516d5814623,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x42b91f98007bfadfc37f8c7be01e1e6d1a5a001f4163dec7e6fa8ecf7e5e9c1,
+            0x4f0196b4cc4a2fd24b603ca65fa4eb23ce4523b695c34e9323a1f55693f09d5,
+            0x20687749f9cbe6aef88c27b6bccc40204246a670ede772decba2f34a61bb824f,
+            0x2f9039a4b8b4ab2278d0fdc4b35679678b1d8243ad4bb814b8b7bc3e1b8a4b43,
+            0x6012407ccdb4f5accc26888a094e35750aa5d88775cdca0a9881e816fe240f5,
+            0xe35046c49cc56a7ec8463053e159925bf55109e8fcff58caff08765476d823d,
+            0xad83c2a587b98cb240f3feec78c6578473f99bf7224acc545793094333b700f,
+            0xbda24254733d7bcd642ef47c6731761aa67e1ba0ec64e03609d3652e495fcaf,
+            0x1eb04acee8c325faf51f6ac53200bd56b052e48806bc12513c165e90c0ea75cf,
+            0x25f00927a77b2fc8aea3e3df5a038ef8249bd29e7f6422529dcce7692efd6376,
+            0x86ff48a930b5807dacfe436fcc67766ad4253e352907c1957127d6a41b6387a,
+            0x22d31103b21aa0b791235ce90ef06cf972c8165bce3c68b3714f89446a42f265,
+            0x21f10bef68e2b8437330ebda744e2c3e1f26a92c3336c7de3b645a8f4369dc8f,
+            0x2e3ed873b0f6ff7facbee3a110baba8af030fbccaeea386ce3a960bb31a71951,
+            0x16d86751cd45d37bedabaca6ad75277e9864d3f6d30e4c0cc2dd25a9ae58dae,
+            0x3d059764e5aac685b59387aa484960ed4ef9639843fe308f8cc3dee87e3314f,
+            0x63f962a68390a818e545995d2b3d53f8a0a5f0aa23451e6d14b0851ab8bb573,
+            0x2d7df484595413f83861ed05f30146f9a4efd46b0b90f7ca9440e30c27c9b931,
+            0x5d966e25cf9cee974e405c86aa2a1b7ae63f5a8928e136e12249dae3cb12132,
+            0x16bda6eb44145f870e0818bf6f60a068288a5ef23da1bc264e01a11fc1e013c1,
+            0x287f1bc804ef51375cf720b680501f7ff1c97cbe98074ccc226d18bd5e18b381,
+            0x27b1edf001e3a0a8562b991a2790a5b48e3bf45f2d637ae7b5f1ba7a6ad5822d,
+            0x74ee1772d860b6ad09b16d82e458eb305228b24a28c70c5f690abbedf70d506,
+            0x218ef3d8be2c4cebf3b2c6a75ddf98e77d79729a0f9d6b111ac0895ebdaba6b5,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2e130f21aa3bc952d00ba26b10b65c1f55c92f34a51e0d6d6224d2daba241788,
+            0x1e6f16db6a97a384c7164733400ef142c41deb040573adb8b0fc71efc2f76468,
+            0xda66242a6a2e27b519dd2335e559ebf8334bcb00614dfce963dc07fdd7612f2,
+            0x201d2a470fdb240a6d4008cfdebd4b579df34c273ffb66a52ec89962e1a59b5e,
+            0x4d1c70932221e3983756ed5d5ca38ef603caff2d2168f5f937c1510775b0e9e,
+            0x2a43db76fb42a082375f5e21c4daf3853e9c57d8627c2caee2d837ee857fc6e,
+            0x188d71e846b0e63c5d65535a6d121a9648d99af72f72c3f38bc33751e999918a,
+            0x1cb4d77c20517ccf346b92567ca15a4b7f7079a150a3b7fbc95b474d2c07d241,
+            0x2de6abda392578254c6c2949559b851ca312e5c098ea17bdbff8815ac4216810,
+            0x97bac96307e8ecd42940e30d9bde2904025715f5ddc8d6237691c3689635adb,
+            0x11ef6e021d4e1b51f156a1c1863d497c95fc1df010d906859d510a2c2d01e537,
+            0x54ed7f2b2e4cfea2ea62cb01379d94041481dc85e94cdc4bde08da9b1ba57fa,
+            0x16d8390b0ba3174141236bf21283588887ce3eb966b7d45cde064d5cb2a35738,
+            0x2db8640099fae4b29bc2ff73424df4851e33eb823b577e4354ccbcb1392ee0ae,
+            0x1de2025f4beb8b5b58acbe6126a092ec0a6f3a664325a88e9a28bce898edf98a,
+            0x21a514a8d477d92a308095092224f5562af41cf964d34be181e95370590b5788,
+            0x140ce2c9605e31576e464e6cbfc8c9712ec8fa2e46f97422d52b0b6401aa5b55,
+            0x20313b2273dbcf225f74da13f3e0d0909f47e77e53e833e4a12e439e185dceae,
+            0xb8251930e6623b8c062163d973ecdb0f171608c126c7db4791116621f2869aa,
+            0xd0b3893c4f70d16172884b37d6242f07ba39e4c7180462dbed175bb0db0714c,
+            0x26917b241a12390182932069a99420c31580ecf06449a9fe7871e3193cda0bbd,
+            0x179bba9ed0bc1ad6942990e43de2abcd2e7094d7d9fbc02dc2d82b50d9970e4a,
+            0x2184a1b9adea49757d59d0c17c369efdc044f11ffa1598f2f3bf4bf1dc7fae58,
+            0x65a085cec70ed53a9d53827c7766989219c6474bc5d415be1706e953de20273,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x13ec63dd902be70179d9a190f2e5f1dded28d2feda5d6ac4c9914c3bedcae90a,
+            0x272d4b6c21e2f7d2c83b28588f5b0f462919554cf4faab4bcc668ab86c877eea,
+            0x12e29b20a5157f1152c41c4e832287b963b6c774de743e4d3d7a5554cc39aac7,
+            0x2c73520466905c9230aa6968c6ff3d7bed3130cdceb68bc5a24e51da861c1153,
+            0xb370f950332b70ca2c247e2349d2e2e22e2d4a4f519efed6039504fa2b2b280,
+            0x1c58bd926fa20dfa0ed3b7e53fde4e4d7bc4df78d13969fac999dd858f0df678,
+            0x9d50596628e021f264983ab61a7bad3bcdecc9d6cd3ec46ecbd83bab569b66a,
+            0xad3dd8c790db77df35aa78dc84ad3571f0a70fd70b5ec02fb62f4a459bb7d74,
+            0x154ec11de0ba022622b33a918364a375f4632bbbd3a6c0c7b8fd77c3831584db,
+            0x2bedf29086a4a80d125df6fca693c198a424226bf0eeacbf4c3990b7ac08c7cf,
+            0x204ba94b0e1a592391c9fb397701c62d724b55d28665ff3908d277f2728c37e6,
+            0x1191741fc0fcbdf5976b32953adea3cf062a2da42a317f0a9907426567d759ce,
+            0x8453abba1a812cd70189049a362f26960ab98640e98233a9799ff9aebc15bce,
+            0x2faa16a34bc765b803fc320e5c9c3d60cc7a62bc4317fe5996cb5352ef391f08,
+            0x1073a4c13414e4f47e3dd58f411b86f1269b4662a27d153b2ea797f3af9d840e,
+            0x20827cf24daa915decca0be0018f95f33da122dbc9d31890b45831132296dff8,
+            0xc184be1457cd3f30372671039b63894ec186f79ac12d4155c363cf60da9c2b5,
+            0x1d1037585c8c002e4fa645846b83aa46d418a7ec475f36a310b5e93ef30b4f19,
+            0x1bfbe62e3714574bed5c8915cc913e23ce5654d217fa8933208cee6cd2a7a733,
+            0x9ac8a47968e147d7abfcbfb80e479a5aa83ec32fc9a21fd80277a05e36d6900,
+            0x6673e8c09274a6b074bac39a9280285cb628f4c90f329c27d3ba1d79b1cc17d,
+            0x2a513229a77a36862deffa4a24f4e1d5602d52e7abb7734cb6a5bfb006a14c70,
+            0x7aa8c2df4a2083e46169b3e24fb2d0a9867ea17103a19c13fc08f832aa17dc2,
+            0x212c78bf0b03c88fe1681497cea1b03064c87db0aa244f061d8135a365168163,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x3a58dde40365d7a0250fc75c67454329da04685e04a51bf51854954a6af915a,
+            0x70e75afdcb3d8000ab4d459e8be1c4c0dcac213e37c3443d5d33de59a31a0e1,
+            0x1dc99b8142e7cc81ec21bc7e5b37dbe2b29e69c290c6c67aa4fc3a7d4d6f17dc,
+            0x2f160a3625bcdb7eec2ebc6a27f6d3aaeaa28e9ab85df1d2c1a34126d2c648aa,
+            0x1ae4132fe8261cafe562823d0e2f059cf7917203bd3e1ad0d71b58a0f0804a67,
+            0x24d5f4bd7441dd4ccb80955ecb60b72e676401239370ad526851b7b2358809fd,
+            0x494f46648ee996ed2e7f654ae6c07216c090b6c4f3599c6eb18aa4e7cb761e9,
+            0xf5f67afb9c5934a2d662532a7ecbae90ad260df4189e76f71bf51ce6600ab1d,
+            0x135cd20c46aa1a429fae22bac540071d4baa5aa1f7cc662549c2a115e1a0152a,
+            0x10b14b45ef38b4d3bd1247e2da3a65dfe290fd02ff1a15ca598b05548d1f93c8,
+            0x22bfb1953a1022f21f1738c8067d26e250c3da6d950f0c17a26a420f898c166c,
+            0x22dd1a3efcada96371c4b909e8c42dc426e0e040d152910bffacca1ec9dc4b72,
+            0x2ec9e354b5f7415057e69782bd7c0db477b2ebc45909255dc90dd3e6fa157173,
+            0x1d176d1f403b4a44e598c6dc34fdaf9c08e582e542748d9f18c9c89887a7ca06,
+            0x57d65c1955ac40ed215d39c30bc61d015e505e3212fbb230cc61caf6dc9ca16,
+            0xc16cadb3191773117e0038e8fa48c9c200bbfe9f61359979c978de8dadb9220,
+            0x228354c24667b494d2cd53dbd85eef57c0b3621228cfc75ef08ee11fb331521d,
+            0x11dae093fb04008a9d994fc7cf27d09ec0e19ec3ad1d548b5e1d205e97de99a7,
+            0x1e24d8a3371d286d6a87358c6acd6757f732bd816b6c77e2193f456c237f95d3,
+            0x14f5fa99460312481bf2b2c6082e5fad5ac3659eb5a13978b2bf2a26627d076d,
+            0x274f78864eacb329a3ebdef354bfba6a7a5d20aa8ca57917c01d5ea57bf5e449,
+            0x1aef2197b2a3930a466c9f2f8ed512af424ee99cdedf0d939bf5323cc13ddc8a,
+            0x241e5e13407be4e0e123f9106ba3342a687e6c966d288b3b7feda4af532a422e,
+            0x7914b11b3cb937283ee3129dbde2435825df1ed64d760a62c30aebf0ea6d522,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2ef64fd1945065ca12f48afffe7527ade3289ad350ffe9dcc51b2cb05886b4ae,
+            0x1e903fd8974ca0ef97c187e30a5dacd75151b3de2615bb2b832a6c81801e82eb,
+            0x20ecf1440148c2b31f9a3c33f59da812efa0755507284665a1d5d4bcfe47ef85,
+            0x15e956ab5a1c5a357e9de409a19386abbac37b453bd1ddd174000079b106366c,
+            0xde22a61fd6607441d0894264777d660bcfa0cdab9d1da887c81e70c7bb8f7be,
+            0x14a1ab44de8546185905ec2bfb7e9b0c8a330266a62fba53b8c5356cb5f20e76,
+            0x1427c18b34b9b1962db5e13937a3bbd61a2af9e9b3760eb42ae17394b9c64ffb,
+            0x276b0876d63e316c4eb32dbb64a4f4db99aab13bff6d666aa985abba4e9c0b74,
+            0x1856468cdd489ea75e75dfef8d33539afb3c3e8d57e0725554897319c692bf48,
+            0x23da22d7fadf8ce07944da0d1ab4f4fc9e2d2bb2ba50909ad99c86f556db0481,
+            0x1c41fdd0f5fffb3d99ddb3a2b67e62a13e0dbb521bb4afedbc54c7fda3406bf7,
+            0xf0bfb6289d76f0eebab2d4b5fd854e030f11672c8f362334290e0cd1f9fa051,
+            0x18ac33130e605df004d682d08f9b16b888f88c3e1562bf08a24f7d254ca270ad,
+            0x2befdfb192edf72525e96cd3aee3a1e54d4068121a0eb34d1064e8b7c8c44267,
+            0x7839fa38ddc35348448d92a9122d84ba951ccefcc88e2618712d4ef896b7a2a,
+            0x2bc35b2b57bc9b2be7b8a728125403c5a78c2f4d645da33b408e6cc79674d515,
+            0x1f38bf25ca2c67ef958d3e92a44c3b4b80b910d3e10c3d0ee768f28628d6d7c1,
+            0x1cd11f045b25737df9183843f5fa01f7b5ab00714100f0a05bff9372f063b52,
+            0xa7f87799313df2c5edcaf10983d8abf938467fa5df74bcfdf0d51efeca406c2,
+            0x718d416b20114551ccde2747cb6b15e889cc3233fad8a339465abc3273dac24,
+            0xb45368b0cf6a77ac6e73ed23f94d5f8fb90a77421972dadc0d70c17ce39cd62,
+            0x262dac40e77efee5a07345c63e77e946aa5d7640408dfc0dd0f27be77f97ae9b,
+            0xea488fc1f7afec912267c19315412c10754a080c11a7873ca4d027935fa8b89,
+            0x297db1b6f71749696ce48fe0862fa63d5f28306715a19762ef8ba915b9fc49a2,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x156c90ff4f955e0fc967223524cad6608e4d9cc8715c249c3492353730d500b6,
+            0x1f4644da64c00905c3a6e15ada27cf593998574f6ee744e85fa9723345632886,
+            0x10d4e58ed6e17089661c0bccd2c4564df12ebd6c4a88115549e7147491c671cf,
+            0x2ad782fc25c4f0db520280f8dd92871f7bed6d0e23337d36df2141fbddd7049d,
+            0x2928371625d6dd4de31102aec7726a15d88df0da173ea8a047e46e4562162e5e,
+            0x2665ff9e95204c0eba710556e91dbddec9f5060ddda6e898a06b9078d170abc3,
+            0x110d5e6488836ae4bc344cbe2406f494dce067adb21d69eb96b43bb7083c0b1c,
+            0x16f7045c1cfdb025d926b966bf994728ef8a9647acd20b245ea1c41ec07bd704,
+            0x21533d8130aba1fda6a31d4be45e3b6f27e1165cc7acf062d9170a874f44566e,
+            0x29b6d6e0065b8aedebd2048ffe74b6ae857373d583adef571b7ef4d8c1376cbf,
+            0x2bd0d29ed27a49e3cf5804bc515475bd2482830530485f253279fe3df313651f,
+            0x2e5a5bc179f78f549317605f271654bbb727f5b35fa38918a308374a221b30f9,
+            0x17aa3fb8d187b2f16771319c0890cc9a814c4fef3c8fd90277eda73a7fc9c1ea,
+            0xfecef506e9a1c5363eaabd2e5d75ff06657ea4a701577bcc0d31cec282e6e99,
+            0x104e7bc5cb52c3949d4ced53464aa25cbd419273c7159717d4243b8ba3e66289,
+            0x2e2d87bbd2649ee3d7feb4a665a658432b9864c9a4d3a5b52bb2813f43af845b,
+            0x2a737d085c1ecad2baf1eba7d7b79f76f3385ec88cdf0d8823bc721e7f7d5ef6,
+            0x134ffef044d6db42e7de09eb3151188391d4a52ed4df145749fc20b4d0aff94a,
+            0x1f46b43cc2e57fb9f22aeb6cd6c9d671cfd6fa043702b613f3de6cf5dcd4a648,
+            0x1427b946ca939159e1f36e6a4e88d850c84f00698173d8ded2dd3a649ebb811f,
+            0x20efae422eaa4272a255d02f80c304ceb0eb99dbe70e734901ce8303b7e75996,
+            0x1fbcd3f2b5a6b08a9f835d2c56ed46fb2b9b9f0008e71fad6f072cc23ecf4e73,
+            0x1ab1d914d85a78fbe7db057ad0251cb103d0f1fe4fa9f1565bb1defeadffb560,
+            0x185d3cbbbd397b4202e6d2d23a5475ef93aaae25e9c720a849189b38475f3ebb,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x9a33338a814ca4f92e0eb0145510136d27d1a970e859c461b90350506c0ec73,
+            0x134919acbc6872a886527ad4607df32a93f8d4f86cbb15cccd389e3cff0d5595,
+            0x2988cc231f59a14253e978202e190e60904d3641819600eec68e3bad58e6321e,
+            0x7a7e7e0247dfb327857f6cb9b2cf9102847c8c16209be817cc8988f4aee731e,
+            0x102415cfc2e84e3b54b636a1125c5acc86ac2414aa2a4a36fca51c0902e99a2,
+            0x1205491dfda96dcd74d0ea64c9d05b74a7eb0b98cc4dce972e3c65072ec779b6,
+            0xadef8dd1998f07ebf85734cd2d480c380b3ceee9c1669827f9590f1767dc148,
+            0x225f99bbe94d5c93ee09123f4655dd2d6bd80aca624e4d8f0a064054e232848d,
+            0x1e8c19265e6565151258ea11206b5d8a9356cb614709c31e4167046d52dba14b,
+            0x452cbcfd4d1de35a869a85ac1013082dd4ac1470e430452d4a8ea1530f5a3a9,
+            0x29bb179886a2e49631442fcaf681e790a8903c96d1eff6647945ed626dc4d68a,
+            0x1e06f246e926b517f3de008067cd6bc9f52e8d382c458098bed8c4d2cb183ed8,
+            0x92a8624e09cc127fd7d1a32aac8383e510e37d6beca3fa117cbb1355e6eb8ae,
+            0x29e31cbd24fa9de5d401438492f9b920ffa56adef762687c61ea562893ce02e7,
+            0x1d47bb665d1bf9254c3ea59be757187acbc504b5378076fe029c4570f835722d,
+            0x224f1c92c0c3e84e360222c40aa0f4311563bbf62bc9f255a3d7641378a2cb8e,
+            0x1021a099460d801d171bb0db1c7972013146d1b09625f028bdb55242d8c51f8c,
+            0x1cd67c97e764b8097f62c6402fccdb45a9bd18e0bb4b41ae08c2a25c276426b,
+            0xe5dbdc0ab1a14125d19d7eed9cc36af6bdd5fe07f8ff269842f0aeba902c2a1,
+            0x1649e0489cb0aa3844e97f61bb769f039f60b9638524408e3425b3f030b5b068,
+            0x2d8611f69f27f599ac672277c1f0787005b6fe3c162d836637fc1c890c6c70c8,
+            0x19a828de992f3bb86650a8a9f3844ff27f70b612e158170f81b7e6b6f4eae660,
+            0x157a427811761757bec0b2decd1c28acba88e70e8e2b3a7b53d732a471572981,
+            0x1f66ff45f17e0ec5690cdff99c1ae5d22edbb0ae12aab18ba5c1adae5b36e52f,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x9c9fa00fddcf694e98845212afe04048b34923d4fb41d05f99d24955c609c01,
+            0x1ac154fc3f42165840c54a350d8243a3a28f55fd038dcdff628c52e17f72aa94,
+            0x28859cb23ee55c27bc363dae264a0494ae77617ba92f595dfbb1454aa2678ef,
+            0x1fd179a66fdb3cb0a06e90d1404c50c38d2bacbfa030bcd0b26e6ae454e3f5f,
+            0x87dc7319f4e880c7136373d13fd6fdb2e433f31e099efdde56de5f8297a69b3,
+            0x1a93bc3018ec7d3475863fdfdaaab0233df37c3f6da5a966538b13818c15c43a,
+            0x1174a66194739850644d05a902b25d188c67ac7bfa816f1a3b9b73ac9731c400,
+            0xfde9ecbcc6fb8a9ce490e809277b9dbb717369641b96f84b3ddbaafa39d1731,
+            0x21d4b10d2e577a751a1284d0d079d066f6bb300db35a9289c5f5eb39e1e4adf7,
+            0x1b491207581efedddfcdf23376324b9969e36f6ba8018ec2eb055a5dd6f4f8e0,
+            0x12490e92c38fc269311bdc1acd2410502ac8d7b3334e65ab644751d1c6e3ba4a,
+            0x3c569375b94a021a27a56b34dfddd14c01f7feebe14e231e53eb811c0d4fc89,
+            0x12f5ebe6a436e8551778858bb53f9780439eb09fa2ac457096d7158e7af3afb1,
+            0x2817dca315e7d8c25ce85bca47ef2424701c91df547407c8920d4a974eeac9ce,
+            0x237f87fb2661d3a16840d8b115116d7b61d99ef94043ea2fc2e311f63bfeeaa8,
+            0x13b8b1ac45db6a26c854d447f2750c09dea12c26f6d4083e9e8b3df2428aac6f,
+            0x1429fffd68050249e1275110a16addcfb1300f294d63c0b50b7d4764f4797077,
+            0x27003d2b7f980530014a1f5e88c4cc2c4178613f657c2b40afc3816ae14e4e73,
+            0x1e7c9269b68e8ff2ea5f21c376fff7f3c1dec1df43a0207dd41aad1ac7213378,
+            0x73bccfee0274ee3704bac0788527f8708883699084d3ee9facecd19acc02d5f,
+            0x1a23c2e99e22f60e0ecc9dbd269a6f8b56aa74bf318961a085e42375d92823f,
+            0xb0b38a1ee81114a35eeeeb54d419459b1729450789f14202fb84f009f728206,
+            0xb08bf53cdcd498a9fca9a0775d19a3fab7cd6f7709f007b0d2fb07d8ea7452c,
+            0x1d37550ee8724571acc9ff409226d2075544fbe2b38276726ad1c8ef3d096283,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x8fce6150b67f549ff898958587c36655277440c4c8bd9565a7ba547580f81f1,
+            0x9a3d90307cac625bce9dd71e513f14642153c7c4a411d59f5db597fde888b44,
+            0x5e2cba2a305c29ccfe1a49bf1cfaa3f00f097ff163feb7308c40ac654c594a2,
+            0x151eb4fa0b1ce608925e2459726afddd5ab7982d4749e6185e5f033d1893ade,
+            0x2e3299bef41097ad9e56203ac25eb52612145c8b411375b15be4c60faf9a0e8d,
+            0x2b5a4ff11bba3074f0e0c3dd34eb3e21bd00c753717f19509c49e2ca01ee48ce,
+            0x1ec7a76d764fcac86c55ce076344f7bbc51826ccba7e90ac703216841fd78931,
+            0x19fe7d31b79e7b1a85ae430ba472cf699a814227f0325d957ce13df654430b3a,
+            0xc1066dc7ef478b2ed0fe10c9c7a0bcb9a7974a4f782d03f248087fac50ec851,
+            0x23b371f53de43570805ed4c382a4e2afe26207f1e280bd963347f973cd8e26b0,
+            0x15b58fbe273944415ee68b4e237fad7005ced82fd6c2f8afd13c84eb29488b19,
+            0x23d8929ce30fdfb078938a291dd88e7f7a802f172c7f9d792ab7aa6ed0866b77,
+            0x340691f3b793cee0cadac0b96aa26bc7072c5d1815117e302afa970e6449ef8,
+            0x274ddbc823611ed63e8cbc2929430d025088373ac3be564a44a739d11e4b6ef3,
+            0x23a37eb726b1fc29841728eb657191d290fa6aaac92636b177bc582465f1af43,
+            0x18ee2248d9512725ba90308696beb3102e7ea86de2719d2c52b4efc02fd0223a,
+            0x40a14cf4ef9e74d44383ae681c3ab35d7c6cd0ad5d94ad8fcc5050e203ee6bb,
+            0x2cb32996313c6c6cfbcec54c4f5d5b5057bebbc4fb0c103b9d1436726f0b7083,
+            0x2b7dafb754789ddcb1dec0ce4ec50fe340d6a3a37c8d81bdeda0755dcb14c344,
+            0x13e442da971a4c71620b80f9cad48d7105535596d4b8f1fe550c3ee07328c440,
+            0x198e90225a0ed6b87bd847a0102a61267f6cee4d77aa631e355cdcdf93b477d3,
+            0x2006cc86ed54bf7a5fc389fa5bca90dcd5269aba4ddeca95de1719ed8ab63777,
+            0x889ec7712c598251a59839e389dee66f6d9946d275a60c2ea2566cf586edf98,
+            0x511826135536efaf9f5f21aee371125bb78412a608bb6c2b6d97882b672a08a,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2f10170d2aac17a22b211248629533d81da00ca55cd8d70c6fe1b0689aa550dc,
+            0x2a35dc09d4488fcaf436c893a13d4489677901a07f875537c538048ef51dd771,
+            0x201b1978cbd392f6ce28a5c8d8296732f503ad63e6fa616fa639d7010f2455bc,
+            0xcfdef165aa6bea35bddbdd97133f24fe5861913c9b6274f61bdb8ba42e68ca,
+            0x24a14555c418ce41b24b5bf1430ba76791abd955022ba31e9ad2cc3a2bc72868,
+            0x58d12e15c9d023ea1348b2dc5c9dc2b43c5854d72e3fe9841e1a2b084859ed4,
+            0x29e5bd1a9bad6bebb5aab55558fc375c88a8a84cc5d7f3a569c7553f6b4abd29,
+            0x1d203c249094728621279f6b8d53a7d2aca571edeae202f72656ae21c825f638,
+            0x1cff362b0f9265141da25915b3ff9e4fd8b33d301a1cfb4f606b475fb5d2153b,
+            0x6c0b55e10a02f6a9e5e8653b6f52029e076963f51f5a7ef4c2483781303db61,
+            0x29baa73ca3725df97d26afb6e2a1a781059b81f8109082c3db2d2d076ac910a1,
+            0x16bc71cf059b627baf4fde8702141c5c2ac31a8620a25f36f0f479a2749be7a9,
+            0x1cb4f4979c4ba37235dbd8de125bdd0bfeeda74d1dbc8f87a9108468651cf8b7,
+            0x1d9097b4f48e52e207dcb5ada14a004918dca62a16f28760d0516c3ccc9090f8,
+            0x2cf444d1a5c6ed508013d34ff40f271027c9a9395cac64e6443cf88ad7481201,
+            0x1af6065e84bc5d9f653c36a0c86b0f0d9fa8ff396c0cf722c97b8736aaf6ff0d,
+            0x2e2c4ecf622db6f1e55623697c70b3dac0850e0369a2eeecafdca37bc120d719,
+            0xae82700364dd6c301ef26d8440a1e0fb71e410355cbf7981fecb0e8ebf439e0,
+            0x2b3bc2007b383da42e4f34269a47f629392643c0fd903029da5d60540aece8cb,
+            0x9bf1b127c22cd17f462ed4972af3af610b5beb2818a9f405d852a168de34c87,
+            0x1230f23e20b6011d5c3871017482fd38f82923d9eb4fbcf6c4c12fd744c8b7f,
+            0x1b47c720f543277cdb27fd57b57e4a88be4a17f9367f5cc58a541ecd995005f4,
+            0x2550ec7018dd8a12e43571625d58cbffc02e10c95e0e9297ba171d6087dd799e,
+            0x2d357b96b3252065e81b5f1406be8027ac20d3919c668a746fec4e3205260dab,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x8500e01d94de904d7223966859b160af3f73ee1f67208935a726ef1f04a21b3,
+            0xae88a58cd6d7dd1d38d427daaf10cbaf3be27e5abc2c2dbf94e6f4782cdfeb7,
+            0x2356cf14cd716531ac576e30978c3e9af33fe0f5465c6928a70ab06769fb7c2b,
+            0x4c9cc7ff1e61240f1c0cc8239aaf4522f564780415fc47bffb1c28fcdd5efed,
+            0x2ac119534017f94c103fb6199dd0c4bcf237d435294d16269d69dc39be170eb7,
+            0xf0389ce2af0f62066e0f0aaab541c7f1e013fa0edd0bad0c454a9befcff9b60,
+            0x1df984d5fed72bed8d287cbe3bbff9ac811b56155a8d8f768b7222620bab2ab4,
+            0x2464b6b8837edd47eb61562a8c1339d59446dc30b12bfe3feb6a676a5754fe1c,
+            0x11e670fa739dc17de5939770830d3aca8a79190d413a8a69280275aa8848096a,
+            0x8241341db938388de2e2f02c9f6dab7f2040a2a0fb2d674bd160c8fcf7513e1,
+            0x215ff7a8bfce31939d8413ba030f72544092ebfe06f99f61100a6def22089576,
+            0x2c7cd496518937ec37c1a7ce9e231f15087c0f266a2b6d894bee197b94b9cd58,
+            0x9bc5b3a291f8de24754a6479956a704772bb305f1ab884a7a57a49c6ebc8d97,
+            0xb15a0dfc22c6eba5d6617504732df69e30cff2c417d0dd2f1cb49545a026368,
+            0x299e24a6a2df4e3dee797a9d9b309af7f38aa11c61bec87b3d9e01bc1b283474,
+            0x14a1683e0ced5006fb58bd5f1e8fe10b5b4d5db8af6ee11f3542683d5cfa0e6e,
+            0x25595e5888505e87a18dd8e2f3fd998387901198cc9823557e34167d2b6f4220,
+            0x1a8ca160cb03b1c6e074c7ea982b1bb406e4b996a70f430da8a7855435dbcd8b,
+            0x48fa511c78d046fa7b3f960ddba5eb39e753e40c03e026a13fdf2509362717,
+            0x28606b25ca030890e0ab9d58ccb09875465d368c8fff1a9401a18a046d929341,
+            0x99c988ee50b5a86686570aade7a07d7f3de7d1ebbe4a72161214fe1f59501a3,
+            0xd423b8393f806bb9445a55f82aaa3663b257bce07981b55a9dcc640f9b3a6bb,
+            0x20fd15ccaffbde08b904a96f9a18ce5e411128da59c299ce6a1886ba554e8858,
+            0x2b8b731f93bbfd2ddf132f1b9f37f820ce2efc76485de21bee2229d03d986e54,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0xbcb4654350348f216da47f8a9085a24211feb151a906c5852a36eb7a590e5e8,
+            0xe0bdd096a483b3c7159aecbfbfa52a4b66e7704b05a7df05c3fc79bec0aa903,
+            0x2cea662f7c24e8a6111990ca10f7e539dca435c022fa5447ad17f1407b9e2c3e,
+            0x260494fff3079a35eae887c593cf5791509815ae31538dcd7432ecc6c00dc0ce,
+            0x15c010a4fc6cc1e54cad7f89188e2392df27f7d6fceb4958b7ac68c23b8deb0f,
+            0x2f199edbca4bb59669b0e4ddef33a7b45821852699ad8b03c8d3dddd75e8b58e,
+            0x1b63017c3c4dc94e32f7c17d67a31901875b20dd6757cbc80eefd96bbf73685e,
+            0x21819c86119eee2a93533cc0557b7095119a6c6347e702aed6c41cdeb5436677,
+            0x2c7ae6aae298a99a0dc53e2a0aae2cebb636e83e80f8ec2c0ca5e6d30c0de075,
+            0x241559cb0c89c416bea1ee0866c17aeba29fdeca75ab98d2890d7e10697d7eb5,
+            0x21de885c1616f460af9be2385dcb90a8a471f9cb4a4be8e76b45d0d0fe3f8e50,
+            0x179ba320374c3c6c268f02176e13cb0d883f1ae24b145769035ba0cd28879e67,
+            0x1ce20457c1471d83720591f79a33979ae70ee1e3830011d9494b7686f90434d5,
+            0x9bc17ede919cfcad02017b4c83cc9e1ca6d4695eaff8e983c8451643cd7eb5c,
+            0x10993c2085ece5f1f09343dd532543213ba3f046c5a39fca941374a9e8975c19,
+            0x11e0deb1da2857341a2c4e2e59d5731fd240da2dad90a1e815b706f926a8f657,
+            0x15313d500d879d6db9446e5465f9c08112330c9d1dca21b1cd298117456dc175,
+            0x1a3da97fcba266c29d2f3b755892c4438cca1703d3685fcd263728372eb19dda,
+            0x1ac3bc17591802ccf54210da2d2bf627725e11a8605503966732d16d82c7c0b6,
+            0x13fd9ff54bff1a560857af2a620b2cb2d725ecdab99603c58d4b3d8311f86bbb,
+            0x10cb890d09d7922b970d479473995d79d935256c9fd28f62212104d69f3c38f9,
+            0x131649c6c37c467b3f8d6bd684c6cd121e1414ce5a2647fcf8d29c84fb22646,
+            0x2784296e81cbe1ba5262170b35d24f5a9f428577c73f51888deee3bffb1245f3,
+            0x262b646e6406d39067ecf4cd1c4e7d6dbd8f0929a1fa778906f709b8ddec0a7,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2b78023b50bcfbb73b4497ddb0b519c703dee853fbb53438f906e8f03379822b,
+            0x1834d6485429196629dfc50775e881aa5bc653d6186ebeaba1fbfa70d5459977,
+            0x1e223eca065f07910015985c8185846bc6104889355c02eff9966f18aeed7383,
+            0x21ce2cc395f1ea9eeb8a83f76d5ef268964304f891db51b907b57a39d40c74c0,
+            0x3010da41b7bd91017bbe2f73f28d4847f1b15f7caae6f197c51aaad94942d5a7,
+            0xfc7aa208e89f615b2b5ac6c1c84db0c87ed0354d3da012a505d3718205f8898,
+            0x13153924c0fe679002dc1912a9669bde6c0bfc56893155fdf2e96e05a186b0aa,
+            0x1e7ec9ca715167872d062b6a2f92ad6b425a3aeb45e5a44e0798451a5f3c6af1,
+            0x1839eb87798ae0b89e6ce405734b770fa2e6092b0670b2f59fd93500ba32bc1d,
+            0x2bd925800a8f95d0b2b6ca1ae4aeca0fedac4fbc889f464be243aef61e35d531,
+            0xf1ec631ddc6f753f4288baaec5d90881966062d8e00a94d1c35caa5c1f87d81,
+            0x9ab5e15c1e1cf58d46c55f0df4fa3a56cf3a41e52664b1a125bf3388887a1f9,
+            0x2048f6f68b4dd0127d915cd6d7056a0104145aee77618077505619117f588ded,
+            0xeed124614cf28d97c99c85a0a1456d303c6cdd2d2703982a42dd688b65559a0,
+            0xe8fbccfb62b0842aaaaae01e8418d005687d3511606ee56c978d0dcfdebd825,
+            0x7823b7784daa9ff5853129e7555f2fadb3898b5c4cbef6f4dd5d7e8c78bb73b,
+            0x161e2a1db0ee0e75b26abf038ff6ba8b396d0c03d27b794a2eb64394680db0ed,
+            0x2816d7a51708d99490bd97f5443df9a5203608feb1bcae4268d3da1e5198dc79,
+            0xb298bfafa57aebe549b8f2b0f98554ae00a1761427298040bc8104ad81843e8,
+            0x5b5779be0c8c88b6ef985df851f754310267048c6e68139baaa4b41d02cba63,
+            0x2954e80ed49eb91d655f32571d6ed24724dcd6d013c62fd8daa0661b4c2e6f75,
+            0x11f97bde1a830e979a7647e0eaf37967f2fbc2952bb50ca4575961a34b43ad70,
+            0x2edabd7a99b98c5f9f8570c778e460dc19c4accd2de09381db2ae25b87affe51,
+            0x285b59b5e4153c7188c7e918dffc0ef798d15695c9fa2921aef01e87bdf9bf98,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x8ebe850428b3b2e7534420e85cc70483a11f33d2b5fdf04f61382f7a12e9594,
+            0xbc84e22a29a0c39bf8854d51235e45e1857ea3575fce20e891ea92d8f56de81,
+            0xc546f855e8fe5529a31ced2d538dce04cbcc05379ab4f8dcf5a05b8e0030f98,
+            0x4beff2ac6db7fc5ba1a66114ef2591000f8822497b661cf15e052719c05209d,
+            0x17fe23f62d221e08af428582244a3a31d64a2fbb37f58f8e94bc719b2c4291e0,
+            0x129c6ab33dabbe60b52c9444dedaa047775dd01de878636cb80b7d014fc98606,
+            0x1ecc6d3b8bbf86ab614c85e5cf2c5dca31d86d2abc8ce91af23d37b52ed78562,
+            0x2fa06eb4828858d3a737fa5170fc77e726e8a0cda438a8925fd55e593e204419,
+            0x123d6c4cc8a7fd77c53de32f88e0e06bfdd78986842c8691cf7f3aedc43fccfa,
+            0x29638f75c4d7ad4d6da92cc3681384bcaa6bda0aa14503de403f330f87700abe,
+            0x2ca5b3f0ddb7a5c6ef388e33e501e0fc41a8b16858bfeb10882bd838238ccde7,
+            0x1e7e20601229dce04a57f23005d7b8ad0375d4efabb3e276a38a0cb2cce2b7c2,
+            0x1bb9781ae7d7cc141e7b72e2fff39fef57bdfb922f8ff88bfbf395738bed4043,
+            0x2617acaac7e8547ebdae0bf2063a2056e5b42e39283fcef6578b256fb8ae01ef,
+            0x1524426376418adb2ecbbe82913bcf05a08c0db6b1f3d80b5ba1771d72b80f1a,
+            0x23b9a081fb49052cf4b2521ff600c471b22cec1c9b9c32097bc91192099f0b44,
+            0x1c6cd0f87731287ebb12883e63991ce5aa8c768499f5c976285019b41ad6a272,
+            0x564f9765361d0141a69ada9ac521ba33139a1bec81b1c39f9fc79d56f93d89f,
+            0x18fba1f537d0bc06888730bcff570f62c8eba352d2890666846ec5c102bbec55,
+            0x2ecd94fddc5654494fb41d46c4c91d264b3e17d5f37791df25a42cb680e12a55,
+            0x25168b700310216d4ec9fa5c3e3514e712d694a46f169f7791bf4b01cf23fa0d,
+            0xddf38a36dac9337b4add0d9a33a2c589134aeeaf141ec5a5b059db0a5466905,
+            0xee74216109c48451af32cd7914b41734bdcc37c60e505a9845e5689313cbdf7,
+            0x20b4aabbb4bbb48c4fa8155538d772088fc0ccd14ec9ed274c7f3356f9799e0a,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x18de85783488e68b46584675ff74d2bad45d686a789aaf80f0ccf3e3c331d973,
+            0x23ab29889e8aeae37282dae6aee3a16624f058208c74af503deda66641d5b82f,
+            0x2fbc8d06de03926ff1c3114b375d87283388625872b2966b781d26fb2ba5d7e6,
+            0x219e0c4d566bcb09609118df2231e65e9e95f6b6e1c6149617acea7083fd9ed7,
+            0x5b21b2c119617eea6edcd24e1feeb1cf75560b65b80af1027be2e1f14a15d9,
+            0x5456d41afae3296fd4b13f8a096629d0b471691a4a29d9fbe2493c3ec377ff,
+            0x14001dcf0234cbe8b3cf799bce377883176a4904360f83fb5908b5b7df92a447,
+            0x2a5e9fdb1272447d7e50bd0ef668bff9fbc860f191c1e0cad1560e74f6d231c,
+            0x22949879c5b83ea97413d666ae0eb3739decdbaacf1a33742bdc04f9e449f2c8,
+            0x21eb23c8742f8d498029de7d0170a12a031c49f992f07a96af0494454e37d96a,
+            0x70541062150a2f25267a8476f41bdacb2b3579c7856ba4904999f92d0b32bf1,
+            0x2664518ca87044340bfd8c5a7c2b863601b8226dd566368da36b808691b9454c,
+            0x14aa81c9279f3505b744bc86c3acafd4c5b03da18129f6a2b67d73a9d8e7b5db,
+            0xecb94b163b561ad361efd85db88614c69a89bf74f5ef3a9387556ca3343a303,
+            0x5a6d9a1efabce0a10d3389ed1571283698c90e766363859acc910968968b676,
+            0x16b4dd09c4b2b3942c0019d9d39d4212626c492b7c0e7178196899f497f83082,
+            0x460784ded949d3691d5bdf7d6029ece2deccf562f0e12482f001714895cbc9a,
+            0x2d634ad66906cd6bea2fad599e45912c992901508aa915f0c219d66373c4f7be,
+            0x1658eb086b54351ec3573b8ad8201f5a4d1f0026b8f04aca66c44c16e7516ef9,
+            0x135a011e081cbe5475a1d316b78c724e181126ef44a9a352515afce9665a9d92,
+            0xb4bc94836903c9787cd22b2962a05c42c7bd08182da579e277ec3977418fc64,
+            0xa0a37d07785069f47e18f245effcfceb19f2405ca009947c9d2cd95673d3caa,
+            0xf8ecd23da135c880c76d216fbda0267d32aee2b4a8039aa5783034d66dda113,
+            0xe88eda335ac1a2204aac356a58a3ca503ae4543881ddd282bf7492f253e1930,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0xa4da37955db5d2bb893a0919e4d928361880aad89e87973b93638d9f46323dd,
+            0x182420fd6b1d8bb94b35d9587499825eb5055d95f24c5a061f56af516e71c5b8,
+            0x12ed236d1a3dec40061f9af7aad3cdbde95e5d41763d8b235c665d25b01151ca,
+            0x2d2c50e36f2c2c402493fd98edbb914d591700011d383e289384c0fd26e46088,
+            0x2e8ba0e65f5ee53abb58da0c792869bc7429749fdc88ccf7a429c1f35575c11,
+            0x8491031ef5da5f6a50fe3e9fe4abccfeae091ea0992cf72a239d0dcc7000c0c,
+            0xf4894b8ed58741566403ffb6a468cbe036e365d3b391b72bba73b3f916aed40,
+            0x22727bcc3e3f1e76bbba95aa7aa2eb558063af92b5f624433aadbbb0ff33c700,
+            0x1b120f999042730b4d2e9f4e22c528510cc26f6076905f37d5a3a6bfa19fd87f,
+            0xb37ff36e5153c7abc2c0bd36db33be84dc7378340a8c6259deae5d1422d2f76,
+            0x1655564966b05b47d171db24f81917a2296777b02cb30f893571217662009b93,
+            0xa64dedbf4dabe0685fb8e4bfb4db52e4a3e1bc178bf7f49f1335bc3cff8fa6,
+            0x21a953f0d0ca1d43ee920c54a8a1884a2dc58366e195f4a03270587bf385ffc2,
+            0x228dc2c9d913d4f4588376be12a9cf6d55d7c59a14a15f9b8ebf8f0cb801a264,
+            0x2b487e5c9abb4812830141572d8b1936b4b8cc3119a0038f773f3bcca83d49b0,
+            0x285712493e67ed422052536731a32ab1920437cd807dcd658836beb912022bea,
+            0x26c1b715b64f4ba9d47c1f97d99f91ea4b83ea105203bb5e4bbe8b3e6fabcc95,
+            0xc188a42d4758ecbc3d35a73e735f3daca1295d0d93d01eed6c3a085ce1d95e9,
+            0x2796103374b26554557f1efbf137c3caffec020e1de9d2e75f8a51b5dd52524d,
+            0xe1523d8bab27bbf5fdb85ea4eeaf57bafeaf50481cdb89b80483698d4b47604,
+            0x172ac77c37aa38790506830facdab06d091a9a98ba0a445020d87a548e68fdd5,
+            0x1ea828b052ccc8c21c1417b2479bf21dbbeb8b07f1d294542e6b776c17a46ca2,
+            0xc530e36f104f93cd29e9d5f6cc76b4982c8f06d52684ec9b6b6dbc6cf3e1618,
+            0x257497d432a5ddb934157c1cf3218a104aa3fe58ec7de5002f82be85ff4a2992,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x9b0b4483df9298317fb5b068ecf3291dcacddad122d4f98ca84868cee25fdf6,
+            0x1569ffd3186a443252de5569661c3f8eac7dfd987568aacb86e576d3f6894290,
+            0x2335942544da68a26bb05c3c44845f0e9612fb8a6b33a4bd81b0da1811b1538a,
+            0xf3fec305e46f3dec280a826087df17baaaca704840038f56f94f35406e6571,
+            0x1c4fb366b69eea6c1ad580af7130f33ebe1ec91b044ea1c5697bcde572bfd4e2,
+            0x11066a30034b0f5a0ac2e2c5d00720c5e11c1fcb71fa57e7c8dac938e7f4f8ca,
+            0x136aece7d25ab58170f452dd50dbe69b1f9a77f060fb99b0e299e9bdbbfd244,
+            0x656fe108785a97dff386df1e4e2edb6d68dcfc9cb961e7d44ab0d14847f3810,
+            0x2132c9a946b2cacecc75bbd0b90e0fd7f1c864ec818a13cfc266379a48740a1a,
+            0x26ce19f30359f871b860f7e740e1361a8dc3d4faca80890059f68742b50c1bb,
+            0x7b34bb73c69a8befc171d04fdc512c2e6d29993be2aa537a5a927503d327f19,
+            0x1d2076ef57a75151297521fe1aead57b361a0cfd90d9c56e5a4d94a03aea4d59,
+            0x18b2d7645f44465de9d875354716726e36f092b43e11aa2feb4f749f5cc30552,
+            0x29d9e936a88283376c4cc4105b7bde94ec648a2b02c4be0325ba0ee4e8e59466,
+            0x8433318e395064bc720a18cda24df578cab51b13834e03f8303e988a8ecec7f,
+            0x2981efbb1e761374fcb20715527de197d32cf4d87871619b505d3f5f67e0cfbf,
+            0x28a84e7609bc4d9de494b53068730c0ffd154de77011ac4baa3a00bc1f565c94,
+            0xb98fb0a42ca497662d3655e0f0b215aca776b94b0e842e7cc7bd80f6aa01470,
+            0x92dfb1809ccdde8ecf61a6602a69fd7ab9ea0f883798425b9ca464637ca1feb,
+            0x2229fecf42ca2b725ec5ab861ed051b30ad8dd362a8445e6e7f6e6d888cef6c9,
+            0x2efa745708462a56d941659e4d63bbf2b15d7b5cb00f57f7d96de4987e0eb545,
+            0x1eb88f6512326db22d5bb8e8ab1ce26efb8b551f8d6010438d0f26f972c9c868,
+            0x357f464028357825ef34691fc07baabc77653105a5f895777bcc9fef6e4ca9f,
+            0x2574b6b6eac59402740cd9ef0f50e229e4db641825d2fd7f0018dcdefbae67d1,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x22cd7ad481a520d21e467b2fa248d2cb54462c3dec29de294a16787befb181ee,
+            0x1ea716292c21b4a96dc9e245738f17f364b4a9dd5cc762c7ab0a24b8ce63a95b,
+            0xee07db295084e877f193bb734548249c566945980a987e853cf283e0de49c43,
+            0x237a31e787ffab6bd803d4683ca9a5bac9ddc21219d119d5470a45678d916af5,
+            0x22d591498fce7c5903d695cb79fdcabebb591fc68fe7a8ab4376279f3c8799de,
+            0x25730debdf5daae2460cb78aceaac1540d1b32c4ac3fea8494a832c0ab9f4969,
+            0x2f54afcc0ab9ef598814c0a9f83a16d44ec48ee96a06fb1dd7d8414ef40bcbff,
+            0x110855e59ebf6c99c61bb7b3728db0141b0c7eb6877e3d867433277bcdb12ef2,
+            0x100cbb38383038a7f72dc76e0ecb80487a1bd2afadb85eeaa6c4b38a6e2460d7,
+            0xcf9ef03acb7eeee16d21ff6eee6b658c426551d5a346ec3d2226a74b9bbf085,
+            0xd047f79f1c409f542bcfcac407087dc0968f9e0b82bc760d1ef72639bf0d3b3,
+            0xc8d35b27373860acee2d851f3ff195897a5429797a40948ab0c18dd279cd35b,
+            0xb34d4ccd429b28324635894a84e2d095c29ad520bc5434bbc004e43b79a3f90,
+            0x15aa8094e890c3ce98ce64cd97f7c21445ceb3c863bdf8a788d49e233cc8926a,
+            0x11637553427ccd52d28ef04c564ee9af0647215f7f4a764d97e34b3da65e664b,
+            0xd77424bd2852d485495d929abc8ea1e5c2a07a938463db4e75b35f11646ff09,
+            0xc48776d02d737edc95da3941a1f78a976c5051bd630deb38b10240cda1dba1f,
+            0x23efafcc9a8ff43a2ee5067e9a631b0be21c1e4f028e4fa7cef38919e4f149c2,
+            0x24dc88d6144669f65e8c8b0e0b84081de41ef00c3f872dabbebaa4ae3db80522,
+            0x27b45f6635340a77f857c72220ab866f70739196835a22952186bc242cd69873,
+            0x704b24632239ef816e17b12e0b1f95c1cf7b8f3367a263ae87cd628582563cd,
+            0x176cb4987f9f3df738f3bc87712a4635656b484c52ca7624bd1245c2aabf3e79,
+            0x227eb80636039b0ae67aa169b29b1ff9966feded7d239c51c6acb427cfb61f9a,
+            0xc315aed179cba6ebf5470feeace0db2e1693c9fc11931f51265541c508ca784,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1b8b75d83e3e955dbb4063f6ef293b4aee18c4a3be9227c3102d29c2a85df08b,
+            0x62a3721fc4009918e908846ba5635032aa2eaa7489d5d74b13994486e1b621e,
+            0x1f58606cb7e61fb55157784342ec52455c66fb882e3360b692a4677360134a68,
+            0x41e93249e317db4958b8849dea281ea81d0e2041006620c78636354e20c45e1,
+            0x156d561a4bfbc4b557aacf5ccc4701483f4c44c8256e619b6f7a7dae09d23c3c,
+            0x11ed5fa9b46ad4b3f57a8c5084724469f36ba46cec847825e6245c4537a0e217,
+            0x88a5d5188be741cd0e0ccdb10875d3fa01889e4f80e5be6ea7e127d5b28963f,
+            0x271a632b843846485e2ab0f5c7d1e14f7275fc53b8cdcd8a743b7566461219d5,
+            0x26c0a1c6632015e8689db93c50a3dc2e408d3c0521774aac099b931d7295c6d8,
+            0x294070b0ef4e6a55e885a12b5874de04df23adf8f0a84f875cb18c4ceb8d101d,
+            0x2f78931d96c5fd9d0ff47089e98809c64f5aff58b2d70080998bc0fe5e364303,
+            0x230be21d8ea9e4c5d2139afd1b0eb61d14b227ea864c09175b23ae4a647d67db,
+            0x23835945ae05c678cb2b9bf9100f51e7ffdaca93e74329a968c392bba321a232,
+            0x187c39fab3ecc634166d78959fae651ab19b169817b7e508762ee36e8a88033d,
+            0x194c8955c7e620135e624ff5abad58e58b5332c390e60f772e8b4dd477270dd,
+            0x651970e3e8b816227d307071d84fdd9f417a2f1b844b7ec56a21a7b0241a684,
+            0x188d9c9d0fbc3459f6a82532f1109a06c591d2b37df750c287244908f193eefc,
+            0x3b8367be80bf4f8e3b9008aa9fc640b6cfac804451c91a6c51d60840f9e166d,
+            0x8762e109aff306b803a0c90ff1031403458429b82dad5066a7c61c4fcd52e10,
+            0x7e877480703f745c67b8bcdd6a1182bfabea54eec3b62b87f53e9eb6da0d5bf,
+            0x83a1d0511d5576651a78abb8a14ac92d9d61a43f977cb5dc9befe2150e0335a,
+            0x108f56572334a765f54db2146eaf1b44fa39b91203a58d3771eea19e46f3b58b,
+            0x253717f1b3a60553ba8c5608d2e9b33db2e5aae1cdda665006620589183158a,
+            0xf7d259d6a6986193bb88f21b9f687548b9793b1120e10386561ca5be801e762,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2caec1da928de3ef257ea69d514c718f70d8d3820fe135dc81523d2e13494c2,
+            0xffcc49b0327d4dab23fe993539c71e78cece70c65060fecf775248a4f3097d9,
+            0x7d2f814a0d52f1676986648041c5ae57ec9b5fa328dfee5a22206c0f554fdb8,
+            0x563d7a79d5f32dd2397acda206a6fa4947572ed4050aab01dc732ffeca2369d,
+            0x2783fa364653815b9474a9972f573d171d08b4dbc9771054f0bc376a70eda070,
+            0x26d7a7687e6c207f5fa597c84565bbe9d511243c1917de8656babdd38ba0eb81,
+            0x1567832cd70e77ec20ef1041351577510628ac2a1c7d5c179c98315ff78c42c3,
+            0x1c59c4c25db5ec760ad403047f3182e0c2db7b557883b227f8bd1e384a7b76e6,
+            0x2fb984c5c36a06d07601fecccbdd1466c38f2ee47b7dd526a34bbb9e859a1fe5,
+            0x193c691789f6f175105e969cabbbbc781119daac0927a2694d006edbc0845084,
+            0x2934cca891879574e44e4b94f5554dce2e55070b19de421b4d2b743418b287e3,
+            0x2223f7dc3c04faddc22f1c05e786dd4fb2837a1425c62d4defdcec15ff6fd6a5,
+            0x267a1cd4eccdacae7277169d9000761606b0bdadf24dc97b6b50ad18f4084e57,
+            0x23674c9dff69d9b06d1a41103f5b241f788624c972203d3a4804e2043eeaf97e,
+            0xc86000f5a940dc4c26b7c2dceca10416c0de08242d8057506a867b181691451,
+            0x237c120402aba89b701d7db41968e81e7ca9e63b6242e56d9e89b1e94b7b56f5,
+            0x1f2adefdfe27e85d550a268e382e6af8e51b93d0303444311050a0bdc3a86b13,
+            0x21026ca9e6c15e7e7754c24c15ef12d36969bb2505ea8eb9d24f21762063639c,
+            0x257dbf207d8341ebe71a25c67f0bcfc71edcf46f5e655c2f94bb0027683e4ee7,
+            0x297fc3567244be37e4b1ad88a0c3008e1f1326146b6588add2e12b812c53c7ea,
+            0x2415eeb2220c514b4b50cee8df2f4f605477b540d75325287fa7df4957c388ed,
+            0x2d1efae2ebd54890a00e868372dde24a8ab026c7397b54827bf51bf259371921,
+            0x1f82db95c67b46b630a40310d8081c760e1bfffc39e91f179b99995a8e355615,
+            0x2e817c24b08cf9346a21658572796f90b8132b6247e43a1d099c17b7823592c6,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x588c5021b24ccaee3b77fce64c0122f3cf21280619404967af6be821ac9e37f,
+            0x191e71b4c665fd095461c7eb21794e3770c3b40b4bc0e22a210166e9c74aa0bf,
+            0x29cb8c9eb9c4cf5bc6e1c2a782ac0503015efefe2d640a154e26b4b934dc9713,
+            0xec1e3897905c451e98b774b636e1dcb80edbcaec959ba90d20a0286366ff74b,
+            0x2ab786b7ffa171bb876603834679f4be8a18485f93b7b89f2dafeff334d5469e,
+            0x204bbc64ac07613fd02f871122b8ef0206d670cff609fc1b2fdef7b8f1e1542b,
+            0x1172cb8f6bfe22d7851f746626399b3c0536bdc6f8969c3b5ca6b697a87aba5d,
+            0xcfcac24e6e99ac6a59d2946dfec1c87d4c14c95a9ce2e81ec8c8405f74ea79,
+            0x25787156a9a5949b6493e08da731b2e15abb30e1d460dc238207d04302a7378c,
+            0x246ac305851f4cc5079ed10d769d337af9649c46f374951dc674b2734840fe38,
+            0x2db9cf683684eb9e2cc772571cf8da1bca70e222aab6ca7e60df039de8b23ff5,
+            0x166212a0652ef46c22f6d8d8d8c53d99fe339c7aadc68b233c882f57925403eb,
+            0x98c9afc1526b5729198f7f58b905563596143c611e1b2c8ff90dffc677d1e66,
+            0x2358d524ec260f839956563785d1a727fb364547edecef5bf664e5706301a599,
+            0x1901be07be45b4f8d3380b0a5e52c1e6aa94dc4f6f2e40baabb9f98fdebc91fb,
+            0x92d99a4ade91479cdf8bcc22c05309ba07d86401532aafdff17bee681dfd12e,
+            0x13af4969555a7dd69482d1c130eb70e05f0f9af3a93769f7fb5437173c71e1f3,
+            0x28d3aae218aa0b296476d0dc373481f4ae746de4aaa1c8328370f17655614a51,
+            0x14311125be69290b098c5ccb7e7a9534732886959d25d677e564d71ae1ae7647,
+            0x1454832e2ed446d6ac9a981f567c57663450bb35ed147e4dddf8e7fbe30b0bb2,
+            0x11055b5dc675e97c22358083da749bb066f8a99cf11a37083c1c991af56736b5,
+            0x20b2ab6a88373738fec32590661140fc911f31be20d8a9b938717954ce5f1720,
+            0x2171b013bb62ffa512500bb1ebad0e10cd39cc7094cbf806b10133a9f6ce3d68,
+            0x13d9ae507067e98e67ca97ac691f2808251ba846c97091c99e46f8c03d6896e5,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x292e6fe5591c886319d394a3218aaf4a8fc00b2c98fc57a395ed2b52d72e5d1a,
+            0x2e555bbfc78425a4fb2d9d8922252a1edb14ee448532800a36538eab6d3c3134,
+            0x4b797fd25379849c5fa7039cbface5d5f01d17102671767c51dcc547a7c7f44,
+            0x2bae8ca68718d729374e99bb9991ef4399fb9a5a14ff7361c52e4785781521cc,
+            0x5ddac723ffda8067c2147fbae890884bf8572fb7b30810101de4369defb5612,
+            0x1ec8e17ebce279adc46dde550fda171ed22736ce4e102cc8e36f3844ac67d77d,
+            0xdc57f55bf67c1b68aa35126491d6e6b78f9883b5efa10b8f695e2a8fa0b83c9,
+            0x2d3f4bced64b64b958b8d91bd0b7b168ba52bdfc7d5df18bbc1a176fde11b23e,
+            0x2f10a6d7f877c814bc7693395dc357075d1c816495a4f03b0ba49d6d8d97a663,
+            0x144b40fba529a8d725cf78c898112fc3e4826c83c1961332ed3bb0e17051bc67,
+            0x9708226dc1bcda85d36d65ad6d0ca69340523e970daeceb5cc48c16db6cf3a3,
+            0x1bc361e4208a017e152377add553852dae1b334c7948e008f7064f499916c154,
+            0x218d7075025c32bd6ca4e15ccce886ef42a54823955d50d1abf906be69a1a10,
+            0x2c36609083d08ad8df8211a51e75bc9b52691cf5c9996dee6cb39a13ab18de9a,
+            0x2ee25f7ef8fed9bfb691d8a5e21717736795bbfa76df861492715c4b41261112,
+            0xe02bebff560e49b14818c02e1535c5cae326071c0d74703b8ea9f1950e78e5c,
+            0xa8e935c09bec781f68587e8aea897db4d3e8d643d4e8b65af941e6b56b35d82,
+            0x24e4c8a3880c07950af15e4dd7785fdff4f46709f7e8a2dff46ea7670af9e69c,
+            0x2d680316bb7fde988136fafd42ba36dbed8d09522f48ddb19a14d39e2305e4eb,
+            0x151fc0242f88cb4b820f7960e519aa333c50260f1fac77ee841873ce4830a5fc,
+            0x2a930a97b841a2680717d8322c463e7b4258340f87258c90f388f322b86a173,
+            0x1a2d3151d244173a73624601b54782801bc6c0f8f7a70a3afc708a23b0af75bb,
+            0x30ff291a9139cab6bc0b3568c21ad6e4542cbb3c6ec6970f01f4ab3f4e65a8b,
+            0xc6142a38ef9e3709c786cf42056291aa1581aa5cb1e1c2aa01326501552075f,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x4478466a9c94183c431e91e2d96fad76caebc38cf4b6bd63d40a883887aa0e4,
+            0xd2089c7872a5e0d120339c683d1243e0f56dfa30bd8ee38e9e9020be57cf9d7,
+            0x7835f14f646ef12bfae699393ca8771079e5e5b105c549a6f740989bc71522d,
+            0x2eb138b8e96a72fed66f988d76a56425930f788d23294bb16c006c15ba7a830e,
+            0xd65fc46a4f555afe4d613d16960139d1b0ab9e97409be48d2c7d0ad708d57b8,
+            0x5cb9d6fb0ea5d7c36af03889077124e159baf3f95d68f5c74b98db89b1fc3fc,
+            0x1228b6eaa51d6497f12fcf864b7dc9d681b32176cab3dae788d5cdfd5fff3732,
+            0x2c74a92c8d33ab0a358ff988fce0aa0ba475c783989734c9bcef6aa3d92e39aa,
+            0x1800e5ce9cf840e32bbbe62d828c95e79c3e1c493ef70ff8743a88431b34dddd,
+            0x58ff670014f46b7ba4bdbd48feb903fd37fb5eec4bccf5af21bda415478ecc2,
+            0x21c73fcf9ad1b0107fc527d61e6d1a289ca1eb4616db1bf402579c7a9f141c61,
+            0x2dab5b1427ba55d3fa1a90d83b0c569978e3ecfa9247509dd3f9e303b58dd0c0,
+            0x13b905c6ad4434dbff6e782cf470c7f37cc129dd74580eedd8a8f85f984486ea,
+            0x16542d30db773c54daf9fbbe3cc6329b0f1e30a5f27659b5718e073a6a3ff993,
+            0x2fb9d2c332734cfd46c26f65328fccca168f58711368560028e2953c2a70965a,
+            0x1bcbc6b5cb163a446455ed0879da1196a6bc4abe45d7b81af746f47db5292e7,
+            0x1ddcf7b0e9bc54a5074e021add723164c981f6bd04db9e150e2f0e21a1a6a3d6,
+            0xe49ca4ac1a6893b61701a02e1dd02a35f49e32a7efa7f297ac4d2c3e545b7be,
+            0x268309dbe299749682f7030227677e5013880137014437f7433ad9e14ca8dea4,
+            0x1bac242faedaafd205ffc4e05cecec603beadfe07666a7f970934a2ac6f629ca,
+            0x28e2305a80b016478868cf732f9013b976fc92a34d1a4dca77ae572c3c69cdd2,
+            0x145de9f18f59e36a93415b33aeceb48554a84eba20c56044880e1466bec0d0c6,
+            0x1acb49bb5f0d3c9385fa202a23350e945f57259a6ece8a15afb3bff94fe92e13,
+            0x26add7d9ed34ea73566b208120678707b1da9f64243c55a41189445672f974d0,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x16051748ed54c9e8d56e45a45a4eb202c4c91fba4ccfa8a05ee3a99100ef028,
+            0x1a51e1a75bd54dc013a8365e8be4d93fc365ed1f85a41e451913a035c1a975fb,
+            0x26dbf99d1718983964d70e45be99a786dc590c2b06726631e73e42cf19bcdad0,
+            0x1132f8662c582598c12b82db868060fd02ab2dafd730d149f0f1c3dbb5c7540d,
+            0xd20abd1b87b2dcc09f4abb60b6b936bf3196166849307a146bdda7953270fbf,
+            0x1312f989d76c6cf93d0386523c2b447be5eee1a76770859a33e08baf79df94f6,
+            0x28c79fe778abea865b37cb9fb6fcbff83eb5e3a6539a22c18cb0a7bb1ee3fe,
+            0x19b577228ad8e6ee6c9b669d36ba8e0797ac74616e3efcc9e6a7e819610005de,
+            0x152dd9b7778d894130a215abe32065d7adfe95428d02982301d4390896ac4a40,
+            0x47e6db3dad97b60f47207eaa4dbf769e64880abba447ab42a64b4e9bf580f,
+            0x16f9ad0b2919753c49509ba57e9c915aa32306664ce92ada426a22c9f6360d66,
+            0x2921d7437d72b2235761183fef2292d581d60883f6f05163c7181e8930598142,
+            0x361282380fd4190823218380191766a8c2eb6ef8f084426f9ab27ed7503d0df,
+            0x2661574bc57b6eaa30224ba10cbf4c961ec5d3beafa17d846e660915b34b9ffb,
+            0x2b50d64c6224a9fd03f14c5142231a82b313392062d70bb835116f71f861931,
+            0x2e43be4ca9acd39a0b869ff361bdc22679619dbd7fb937ee499ef99c14b929dd,
+            0x7458dcba827b917c731799c95185ebf349165eb8bd8837ad4c9a7a946acdbcc,
+            0x2e565ac1c012c9b7001654e5c4b389eef1604d14da21e2cbf4682ddbde00ffee,
+            0x2be1797b6ee4dab5c76f370802650571f72ff37afcd535e80c02a984257a4a31,
+            0x13df73795946cbab79f5ab95a1ae07beeb368b6a672eeff9533467574cd5b637,
+            0x271f3f4aa97903015b64624f4d65b15cd2fe5f18fc8dd6ccace0c520d5daf9ab,
+            0x45e4c5231979d20d30f98e26acdd05b44c6101af23bab61b22b9f2ed4c2bacb,
+            0x265d868fd9eb462095cd18e40ea2aeb074153cfc06fe0c62d268fc86e3fa1e9a,
+            0x1c2acbdc137e6a8af39ad351f8e89255387e69c7d9cc4aa0cc0b4a3c9a2b2dd3,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x18b4e73dbe4d9c83510458712484b5a88154a64e4f000efd8a5d2d960b4d799d,
+            0xe2fdde439a5f899cd7f813089c26f68018a3b0ecbfb2de15589e589c77c691,
+            0x4f2b25402a03ac3a6fd61ba2e73b5acd1dcc221704afc22ab41ba3b158b7a5a,
+            0x2ce09acd57a7c33da7a3083fd7336f59f1a21bb7403cc3152101127083df270c,
+            0x1dc51c0843736ba1d7b5ca4ecace075a61486b9781deecb73ec0c9270880a5dc,
+            0x24c96270bedcecc4ec08285665474ba417e43f1277878e25f64c7ed59d518993,
+            0x1567b25ea10aa7639e7754e07fb26140e6b196466301266acb242ce0f80baa9e,
+            0x1b8405e13b06a1190bf60e3fbfc762ee365d6e42a551c9449ac6e78c25c313bd,
+            0x1ae7fcaa790af2f4aec1458d5e8fb9d2f6e9c4e1b3877eba711ad016a8f75883,
+            0x230ffda3cf04839dda573ecd6cf6a765f419096e19c41a27e219f7624f63f918,
+            0x1c821c8db96ded0ea28c83e01769d47e7cf531e5ee167154c5942dd1552c99c6,
+            0x654e2ce5de54485cdbf636ff35aa519d3bb0ad0f65553c089035b399cd84ec9,
+            0xcfb61bad637440ea70c21616c0021531b797dcc910b94583c7fa278feb71244,
+            0xdde58a2d3a19ca8daced15c92f831571b71a3bedfff56df64ee3d3fea7c11e5,
+            0x121e952932b7e95de7ec84c86576ce61bbb862ac2f13270054fe25b95540345e,
+            0x77174b4e7741e4131a2adb24c6c9f223bf77e2678d9ae5b3279d86e55f87fa0,
+            0x5d3eb46a0d9a2f0f47f0962a63d534c9a77d3927234620d2c928bf09ce7e5c2,
+            0x246f5a9f3cb48cf1f4a13aea5a54ba53d8d3046b61871dfc1fb5d9f358cb51bf,
+            0xa2e62faa91efb3dc7d4c6482d41ced93aefae8d13275135e509bb3a117b19fa,
+            0x21eaba42c45ccbed93fe3468dc8b98fc42a9855e60ce78562080053784c20256,
+            0x1e2cfcac1e924008271b086131dba3dd0044a03a28dfbb2f008611fec230994d,
+            0x2c97d275a36bfdd250e2e2abfc4953d8e04d5e92795a914aa91a168f1a993059,
+            0xb1d67cb1a69e071bb57b3f4eaed9fb9989c12e249c0900920bbfe0fe7ac6c93,
+            0x1f0f655f87c30461e7c2d6a3b55d5092e4542c805f29ded8c499fe4603df979f,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1c9a4884cf6e9cc19782fbff77ff6a2df0b1353c2e1bcc80f80685b4da9a9962,
+            0x2031dbc469ef5d2ab8bbf080e779c81da08a138d18b1bce086d9650d044cda52,
+            0x26d411c661443edb9fe290206a84618128d1e85e1a8fbcb9908859876db87376,
+            0x21083c2f6587d4d94351b5e8d4d37ca1ed3bba605bb05ac45151c5b828acc8e2,
+            0x252aa5220ba089fec5d79e776cfbcc3be42167e2b24ba6245dc60c7cf0fe818a,
+            0x15aae505663cafd83758de1e586058a24e69295863d59c1221678d0a997af128,
+            0x2d8e7eac5ca3205436aa38fe08be53a0fb7b57e4c35abb9c8dfb722eabc4b4f7,
+            0x1d4b0338ca8f97e7f6da84d54af30e30d065138190d0c36098a69db08f44b97e,
+            0x1af838255d6973d5b0b19585c52f4dc7ac7ee024b541e4c103942b7485a5f82f,
+            0x301b9339d3863e05daac5aa39aa79eb948f6be9a56ade53ff27fe98531f1ba11,
+            0x1e03df8a06e4161781c43cd5da85f9c521dd1f5987bcef858048020944852c7c,
+            0x2caddd2b00b5b15d18a3ecb0d013c71966ca47d579403d64d0b41bd736ddb7ac,
+            0xb87a369e470ab99e2c4349ce109985391d848aa3b60202f7a17ef6a0e4adf1b,
+            0x21814ac94b3e32f6f295c65c4b234aabde202d9607b171ec00d826f998a6c92f,
+            0x29b1228b3346a79953774564fa631d8aa6f2314f2c9216d4aa8d89299909f352,
+            0x1a5e40ae67493e00371f4796181b9c0ed9f909bc5a6d9361f9b75b4c5f48d270,
+            0x1ac79eac0e5bd64eff5d74fd02f19cf0a066d6e5ad8d169a2ae42a935f454e3c,
+            0x1cc1592df343627349a25bda9ff38febef99da952ea6d33014b9e062d0b9c65,
+            0x246ae2ade241e443bde03d8e2b323db4208434d53428628bf92a2fad2058ec10,
+            0x18d00d6e9f9ca8e1f315aa97fa121430125eb2ed841bdd81f1efe69379f786f3,
+            0x2a147b464ef73244b29cc4e4fd24a29f0fcb62711a840ed075c77682801b54f9,
+            0x30188a7d39b26173b10d7767135b841640c15708089e2be2bf8f5d31861ae140,
+            0x1cf70ee72aeb25c85554b6de9c01877c8ef5164a1e118250aa14bb0ff8cc5d94,
+            0x2a27cb25999e82f8abee1351c8083c8393e5038113619e783649651c286967ac,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x16f3b44e7a69563f9b9cb04a43140d2c51a2a2641b9dd9ad5dd7b942b3898e6e,
+            0x1ef9dba4b9fd5363a7c5855a1c3ae00c1874ef693336b606b1f25c4fd32c5b3c,
+            0x3be108cd7d21185b6364bd86883fab9fc63c9356edefc708c05882280b75515,
+            0x21631c522c8f458394bd234946f326f0a0e0caeb2dab4014e8e089f36b25d766,
+            0x2b469c787003cdcf37233bdb9f3eed9dabeda742284d6f7286a426bc9022fa9e,
+            0x409e474d3841d04d8f6a521cae62224e4d15d729a48f7af7357288e1af200af,
+            0x239db39ca9b31c21ec61b7f3306cfd1a9c20b3aebf0ecf4af7df18c2a498ac32,
+            0x3062a14d58830bdfe5c97f9111ca779b253e09f8337e457a6c4ecc1ba1bdd8fa,
+            0x22e8958e08ed54020aeee58d8bd6bd816c3b99f53d664fe6c1bbaac2bb5c12ac,
+            0x2689f68f2ccab8aba87dad5aaf8f24c89f24d94c33a3554413ec94c9309c2201,
+            0x7ddcd764dbf337080c16b4c68e93eede25a567bde1f7dac0e3bcf6edfb4c472,
+            0x293c704451a1aa66e1aa0d4c7dd56cc5392fd8cf7b8cc998f6a54b8c30b24e19,
+            0x2cbffa47d2c28e5d0ec4a2dc0a168ae258368feea0ba17662168d4cba27906b2,
+            0x208c5ef46b238daa217fe46cc26ae7460c70eb25fab5f1122f4edbd48318946,
+            0x24fe6c2e5f21c4cba02f4c15ba1d07c732017ac72f262626eee292a4c3484c8e,
+            0x1dfde7457418ea9643108cc1d13371791b90fb3a4346f4ea6830fc8601afa196,
+            0x19eba78507eb7f4332dde5342776cffb8b3f53973e9d191b0f312f7f05c1e732,
+            0x2be0c4e211e0892ff5d3f3b7aa0281e1602cd23684b82ba12cb61be1eba411f,
+            0x9cae53a049def9f8088909b1ba59670f0d8a2180b04062eb2c8cb2c3893c11a,
+            0x2e2adf7ac157ffaddf5ba5fd0b3b009b13c8e1454b54d298e5a50f15ba24a957,
+            0x960206a1b5fd7f8caa23c6f979a77b2df76e53ca4071a30e96e203f6d611945,
+            0x1709ed8801ed661f54156b3da294eb591aecded73dc4bab8e884618899d61929,
+            0x213a699fb63a980c7dd352008ad46d6c423e77fdd87348879208531b1dcf7de3,
+            0x372666a5afcbe6f5458e78471e9ef6fcfa3420dea49e713a8ce1c19cad53b49,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x17f4a43fbcf12508a933527a8912f2842333780fd30c0c46d15af216dbc9251c,
+            0x2c5744c9ae7f6d8c3d5b66d4d43b95afd79ca38594b9049d886488cf10cef463,
+            0x2dafa6f3c603c4c0b0ab7dea2b559314dff4f7b2a1a65894613d2194595f4476,
+            0x2f7218004fcb62dc5ab37c7b3803626296dd6f876ea5eb4834eb7626c1d82217,
+            0x6dfa42020ea166652a7a392a6cec8a63171b943d6853730df3c846e32176cff,
+            0x23f87a617f1e8f021b83f41ccfe5e7526864953a9eeff56d62d85731ec090826,
+            0x1cda3fe46da8e3f2595bd22ae9327c2d2968ffc0c686741a13456fe5b2185861,
+            0xfa8625bd9c3af09956eb74e2f983eb6079a050c0186221b1a32ef5050969007,
+            0x111520b0f559fe2476e6a6f48060038efb0166ff9f6bda812a02f793228af23b,
+            0xc23dee172299609bd3dbc9f2ccfd1e3f76e594c5ac2c3e5ddfaa62289ed7656,
+            0x105f42aec8a1b60c20e7041acb94bfeb6f6b5f8c5b71218fee02047d57c0c218,
+            0x299f915785e8adc1c2378fedef3083e487db1f6f1807cc7bc66e51b73bc39147,
+            0x1ef3836591f803fdb8a0bd89373dd79176fbc2e92ede7006faa5d95e9397d81,
+            0x1a2785db4d9a3409adf3b7ddca9ec408b2f93044338ac23122588de468c59408,
+            0x1a6ead13bcc1a5afbc63d85db0a41c4a031e480585fe7ae5fce9b64bc866a216,
+            0x1f5996a035a306096eff22ff3aa805378e9f4e3ed56f9834f62144f57eb2d414,
+            0x238498bc99b623c9fb4daf8ca4e4c87607338433a9bc2546c9f37c86af431840,
+            0x273915d627d37ede450dbc5e96ce9489b78ee048f5756082227e62db6b9a56df,
+            0x21c11618cdbabff657a20c8d84812b984a017810e97ffc169c585ee296fff9fc,
+            0x203e0bf4be8fe2ad1f1eeb4926647caa4f6e429ce794db082fc07ee5330e7cf3,
+            0x294ba4a28f070410c4c4f8cb5c09a56252ad05dbe4b5bccd24a4adb4fdf71df7,
+            0xe403cbeb904d1582f7872035f81eeab4010de844540a9b2bfe5419d43f8bbb3,
+            0x27c86e516b80bede0756a21db1a6ced3ac126996f64f9f6edfb2417fcd3829e9,
+            0x26c02ced384da01a247d225b0931e3310f7f689426b3384c65bcfcf1a1e0d8f6,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x23c28b7d927210270a66d02ce14454c7608540c1c4111989c66fa5c83b953441,
+            0x175c47171e64b9fcfd9a0e5ff2cbf87d0911c01f7cfcb4287a219dfb65a3c946,
+            0x2b0dc6705e72fb39676c099284f87987580419e380019cec6529297780e9f143,
+            0x2cd30e4b096b2ac50182c596fc4bd8de276e1d1f058acc010bfe056b50498347,
+            0x213717e1ab4fe340c8edaa0f2b003ffa2adf4890ee9ab0bbe6528a2f4e436184,
+            0x167ce1eb87442469edc20f5be85f41176a2bf1a7e44ad9a920605c5be99bf975,
+            0x2c0874699b7fbae13046dae49db97858a6950199f9a3f3bf8238aeeb73501797,
+            0x1a565a10adafab01ae826b619cb79c9c7420a140d41365669ec361b37cb5c8d1,
+            0x2c8c416f3d61924456ecc73119c6ee327dc717b411a4ebdb673b48e8ccd1d4d5,
+            0x267fd0effc34952354f05332b71fe925b3548f0159ee361467784ef8fb986315,
+            0x2bd251e35bedda84bfaff55de37d2835277758a60db4a9bc4fda3571df5ae523,
+            0xb7a443712b33fcd61028542457a0da3ab1f087b58aacb25439af6e1e55375a2,
+            0x2404133570623570acc718f19ff26c6b47ba03857394f55d17e8ddafd46cb5d1,
+            0xda485d8a8d3a97968c8b0789dde653796430641c4dfce40db5cbaea4f392071,
+            0x2146d7115c9adecdfd5ba061103729167ca82a2e9e58df7177d10645a23744f4,
+            0x2c957d723ab55cfa5de8995ef9904c3be5b70b5774a12d17efd71d7fb10b2895,
+            0x80bc3e98f6ec909c5161c498e0613bb736889eeed8ce7bcc93bed02f4bc5be6,
+            0x19dcf73cfac4b44c2761e024d6cb2678cc104a528c02799bf3a091908ae780cc,
+            0x199422fe9fa1f5d2dbf402c9bd634d4bdc9cdaf70fcab9d0ebfbafd12a02e49e,
+            0x1a4077b1cf49f41fc3a2240a37ae60309d6941b839ebf51e1e118c16a23c6aef,
+            0xe53e5ebd64346a83c1e7f33878ac8753b1b45f0e1747f680311eeccadd89a17,
+            0x5aeff75c7b60d39afafbcae4f99e77e223c35e301db1dbea5becba73535885e,
+            0x1f9764d4b036ee9b186d5dc379c2826b17595849ac829e2d52230e243fff309b,
+            0x1cbd64e54e94a1499df6fd784df7709f93942071463eab3db602a804337a436,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x190f2a683d41d29fa79f653057c0851c76bf7301c355e46d514e62a2116d7188,
+            0x358bdeb885279de421d0b5bced75e4b0b909340f8a3445a3dd17d76e4abcd1a,
+            0xbf755f699b7e4252b3fd62793827e613c40b0c1285a2eacd4ef65e3abfd281,
+            0x26753dea98885ca2c4aa18a49b9162277722858ab51e3a482275278c53842496,
+            0x2c3bb4bee55f665db599acbbb270af82a9f8320f7c3adf113cfa86d9cfb4754c,
+            0x149ba255f720eda11444f804e9814260008b187f26ce17e4152c092dd477b00e,
+            0x21344c682b1f31453cafeda3081b76096340dac56062762ca80a78870dab3bec,
+            0x11b6c7953ad5ab4ae16f501101b9b577f0b8a1d7c6a793d66e4fa161b1e06e52,
+            0xeb1bee9bfa6eac0e22bee9a13fa2155ebfcabd0908e74145bbf9428ae0b0209,
+            0xf89e6f767ef77ce6ec818807d30706fc114d9e02aa610c0f3f77a3a08aaf9c7,
+            0x18a72ade9ee9765de8ccff2950b0a3e8c8abb4a336ad417ea75837e8301b8dfe,
+            0x239367bf5652c2b293bf645bd88f1169b6f872ccf8405c2b4f09f4d135f6fed9,
+            0x239747dfc96f5ef11b8573b4714b20381ea4ca958761b44e11872f306722792b,
+            0xee7d51ee88f040e9c21d5362bfa085adbb01485abe1ed5717b55b8687e40b31,
+            0x216277a3d920e1266639f61d0c22d76858e85daf5fa83d6230c6b1628a077051,
+            0x43527556626973735d511d252e2a1dd3b55026e3d5b38324a50d1cd44d0f9f1,
+            0x16e435ebcff7dc72244e74fef07cda6add05c08a52cf07309bd2eff2ea896b39,
+            0x128020b31dce80e89ac5e01bb13329cea3c62ad115a5d65ce68555e4494a867c,
+            0xc840cb172dcdbb1502749bb1beb46e0439aa167caa4317282fc78056262eb46,
+            0x542b0852563c2bf928db174369c82da60d6d41e9c61425d417f009c46fac67d,
+            0x22452f2d9043bcbab68e526d22af55fb835a3e554e5101a82ddbbcc047411884,
+            0x11b919c0b7abc6b28c582a84c158d5d68c928475503c312f86ad3a2ca97c0ec6,
+            0x2d1e6445ea67dca7ec1db0b08659adb177c9379f4569bd3efd060e06d0bd01e5,
+            0x251ba02f642cd5e0ff35e008a0a309c4c6780dafa9fac55b163256d39a4e4119,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2f09e5f58f262c5f4c9ac2458e58dc1c3f5e0a409ff3f095d8ecec957ac50f2b,
+            0x1315b742c5de4460a27229e970e546750da9ae91fe8ca5e51548c60c12aa8359,
+            0x60e6ecb8723e793eda04e490c818bd07cc8a972dd900d0cbdc4c28c9e3ac13,
+            0x1677aa582feef6ec348f1b194f4f978d6af473133203d0d22a81b08bdcf26a9,
+            0x106e8e67c7213d1c649b08f8163f849d0e0cb36391672b3dc5e632983451f457,
+            0x218baabcf27c9046b7ce52309a3d6d3a2ca1b3924bd2fb64c157353a88567c8e,
+            0x2b2717d36fdfce6e134f255adafaab3d1a9f719b3a661cc1fe490b1e190f2b10,
+            0xb0b2c3bac72604b4c5d568e4f4cf53596050af1e7bac3627e9b2cce934eb482,
+            0x217a15b51fce1bdfb5678864acc464e95225e47ea40bbc78155c14a41f2be20b,
+            0x1ba5231ae9c793948686f7dd7be9c44435dd6a981b3e880f344e2935e14b64b8,
+            0x253e39215ddc07e604684a22eb2e7bff9c138b17d2089ba9f451cee209f14177,
+            0x291dfe1da2b968d3837a2b2b94f8eea9606535776a260664e8227e212354ca64,
+            0x1d3a7e1e04c422de9b7e0b090180518372473ae8ecd8d1fb81f4981bba63122d,
+            0x217d25ca6a61a6551abe4bde579165d171513a7c15fdd69e62b46269a1cefb04,
+            0x1d65f0b99037a8506c7ac7811c3b8ddfec719fd951a7337dd01e22c6e00f4d34,
+            0x2288e24daba6872e61c70d8a4b8dbc67c63a495d41649761198efd7e4275882c,
+            0x29811fb1aa54a2592816797a866eb8126f4b333f1526eb6e25bb626224493360,
+            0x2d8f4b4f41d9abbc9f03c50e4da5e64fdfe87c5d07545cefcd30131f20f00d9,
+            0x28d7a552fa2a86a8dbe41059439b0e35614cfdd841e0d6ef1db1af78d7108e4f,
+            0x96cddca2ab8c7ae201908ba1a671a9117e24ba7bbc16b331babdea12bcad5c7,
+            0x23e387be7e8d63cd8b769e13b718b560bca4a602c8992be3d75e71747a10dcfc,
+            0x1f77dc7b1dd84dd7ec1069c065121f51c036a41237408070c45ff15d2462a60,
+            0x7765f1e2b28bac34ff4c1574654563e8f672a14fb105676a57f2554f49da9c,
+            0xe1356ea8e8068b1ef8287fe1362ced74d7e1ec18a1bb36e6fd2f22593b51e9c,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x9d1f2588934f14551f899de997bdbfc9192ea76d1490b6bd5e1d691d3403af8,
+            0x1d48285a000b66b39acca3bd48ae38d761b590d846ebec486db4899d1d3c4d72,
+            0xbc56781b0480256d3661ac6e0898a7084005d607165224d494103866e256c47,
+            0x88867a8bfef1eb88b2ebd34daf3524cdc118d232bd1b91646c11a2a54556b06,
+            0x29938e679bf6bec4d293fee8615186bb09287291d69bd50953790fb09db7ff36,
+            0xf3078e2dba998b8202b3eb91f500e8cdf87e2ac9f86edccd8b907b1d73f10d5,
+            0x2feca0ea4cab180c357b1dcef1e8816caa115f572fb2da374e27b2f7d2a17108,
+            0x19a53e4e1a8aa7a15029ff45f528f42c8dd0360c8dacfc125ce7d192a0a70765,
+            0x18ac83f6bde2bd90432ee9fc03f0e62871969e8ba27aa1dee2c72e2fb42e9351,
+            0x2cf369a36a64a81b17c4521b17c8ef65d09442ac2858d03785fff1f8ae4e3881,
+            0x16d6acb3b445a2dd2ce6c6bb79f1f61f15019a090285fca38fbe54e04704c55c,
+            0x1bfa4fdd27298d16aa06bdc9ddb3c29f48aff4fef45b5ce80b4acdfa43fa1355,
+            0xc6d30e4b903bdb97453a996931ed19b556b3887f54d63084263d278bc2de531,
+            0x173ca2118a8b85e6e3667d2dcc1c480e163a338cc2d47992b0e6f09f2d363c24,
+            0xaa825097578d91eacb40da93cb739f9a435c8a9bfe2ef8f63d4d392672506f1,
+            0x2869d724819d09fb172258ab1fddded25d8f0afb23f1a87b331d229eb61e032d,
+            0xfa3dc0a38fbb92e5f714183536dd2cec7163726a64117973fd1d927ab7b0c42,
+            0x1f0f50f138ddd25e9c77dfa15f2201bc43fe818595195782fdce833664fdd244,
+            0x1a8bd852a6a8a26b23057e5bb85facaf706a6487a0651c7c226d0cdff09f4507,
+            0x20d045353b22be410aad1286b4a362f79c73f96103392c5c4ed31889729807d7,
+            0x2830a23a528b1c1e7e277f97424cbb153b3d316fe1b167ea01309bdfa6a0f623,
+            0x1f8f3d87ef4767679cbf773af4a2f27614124d5270015c7d64c0b13d25ee63b,
+            0x2843847fdedc907101ab1b8915d7151dcbc7e27419d2cc24490d2020f3193683,
+            0x1fd3dcb19e924d226e9b428d29f70978d7715bcbda1ec70e5984a67ae61537f0,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x22afc2a215e589f41511280dcd9a4d2f7714e205f2c4d0b663c9d2da07a231d8,
+            0x256117a01b4903a52e27a41f92d7a65de53876e832d5d0013fbbfdececdcb17e,
+            0x1bd505fe2027ac17a51db28bca97087a4336103a375f5d726c4957c63c1377b2,
+            0x1370beeb7c62a69367b6d83f639e5eb0744df8b7197e44410965c697938a9e3e,
+            0x1b23ee8b148269858c2f44c34f1058f44e4f066b2b97a357f81a0694bbf3baa2,
+            0xc11837fa154861251a3c6d09c4590cf5b738abb440c9f221b6fdd86b62b950f,
+            0x1e41b6d8be08383c6279628ffab3e3329bd391e954f5333c2c24bea41b1b6107,
+            0x7921a5cebe4c7e339b84f0e635a48591367584d0c12a64b5637d960f35b3d11,
+            0x14969d5919a6d85c58ba30919c0f0e52cde9197db39681160c5be3b98aabb92f,
+            0x1d6e48aabeb209860512a8935eaf23b1bafea8797a6a81284fbfe6e81c1f7a34,
+            0x2e3ce888f840d34ed8c660bfd5a48b4f4a0c040f5b39165e2615427831f86803,
+            0x3383db94e9d7ac3e3abfe0d27482c9ba837264a10f482ae80f226e51042cc26,
+            0xaf89e9e5eee9173993784fb566e6d538efe46346ff5cf61b1c993b52a42e46a,
+            0x1ef03efbffd92cd2da93741eef43a8bed80a76f4f68cebb61493e971b8b7e7e8,
+            0x274067b2a04222952d6577de3245f38219ae54f0582d9e05b7d8a01330395345,
+            0x16ba37bbec0a43c8f30d001bbecb30bc3cf3db728da538ceee4ef9ff4ba486a9,
+            0xce229b9c289b8e7cbc4e020a0372a370a7f282201b47781caff3d01642b8c2a,
+            0x2f80729c7338be1c0dd613c22e836ee2e9a9d0b06a2fb5e52af024ba8678b5e3,
+            0x1cdc6d2ae50c1329a117d13ebbfc1fe86d5526a9f9c59a50e031f37b6710dc4f,
+            0x2530a467ba204bca45d83f9ca4c5ac9a568c053266ee1126607ac33c7e94650d,
+            0x371303ff0fc68a7c62e17b71ff98bd5715c6717d794b69df439a6d7c00011d2,
+            0x378305e20bbf96aa0c633930f4011bc20789b5c1be3f2929d693e704c552bf4,
+            0x1a3636567c1ef3005e7d5839bca900888aa34197fbae582cf6826f855020d24,
+            0x281e2a06fed1cf5b0e0b6e03fa2652cd608fa474299b5c7d0e59c6aa35c0b17c,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2b3d84e5c61b2b97939674b7ef13780988f0c2da109e71d17d0598f080236a27,
+            0x29e2b9bdc8dcba3617e5663dedd89fdac40bc1714f767f327c6503d7f146fa2a,
+            0x216f7ae6ccd7bac97e2bb068168cf18b23505999ad5916e52ce95a23894806e3,
+            0xe8d298cae881515ab0f74ec935567a5b249314023b3856d5f9ec1a5599a9b55,
+            0xf1e1e45f847cb03591997bc8812b0f422dd0db2fc99c2417a81989f2e46,
+            0x5132e56caac6351c00de73247be0cf09de357c4780bf705fb1d12954047a302,
+            0x2c1f7dceb1501489cd4782c13dce297dfe75af4b4065dfd0fd51191e0f03489a,
+            0xdd3f24843220bcd4a66586631e888956a0ed26f717c556dc5e20f38b455d4e0,
+            0x2f3224043392306423d22f0e9e5c15889df84a9c1c6e2bd406a469139d132844,
+            0x2b572f7e5208c5e52a759e04500a1c7d641ff06df5984a926dcab2e17ca28503,
+            0xb1988858934c8a353456d44c461a763b6c98ed3cbf72a21e2e4690083399907,
+            0xb0ce76163a25f724929f8ffe5592bf64313660ebe1b160472466bc091c5c3de,
+            0x173b128e873c2dd53e94e438b4cd066ecfa28eb42d13bedee742efd4ebe4dc3d,
+            0x22f7d627420794cb514df36097c3dd8d2e92e2890af2c1afd4b5f5bc26a6629,
+            0x1f343201df3060d03e313eba7690883ba77fdec3d663fc6884ebd401938af261,
+            0x2472c968883b169ab912d4327cef96e6d4fb7b2c00959bde150b5ed9708929e9,
+            0x134c248a14ff13c4202f997bb87ee93058de60144cf2f5141236f01455438526,
+            0x206b6361e6139253e6070f905d6b7d08eac74e4ef2f54ce09643926bf5c8e814,
+            0x2db2cff5528de7a26e0643b161e7b318e554aaab93fa72f9f475d9aa7c6ec8bf,
+            0x25e05b8a3965fe0a250aa7ca030e3a7439445478e59dccab16a621928d014571,
+            0x2a8c5a77c61420b6b4ebe974da7140a25eaf9dbc9092f063111283e773adfd1d,
+            0x13389b7bf63bef6a68983125b86f93b62b6d9e4783f96b710e2ebed3adbcbe2d,
+            0x2731cadff040622fccb533fd62a0d43090455881080a898488d55c89083395db,
+            0x1886f751efed6e401c5851f88bc285e68de3b94062bc810b092c3e4160b0e12c,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1a1de7217c640816ca96d69dfa3a9ead0a32f62b2d864c5cf3d66e2977616a60,
+            0x21bfb88e0d52b7dce5432f55c443964e46e72879baaba7aaa04577b59fbbf100,
+            0x1e1c9ba5f1413166786c96401b61f687ba50dc735d815a4e811570bdd8954a11,
+            0x378dd10a31675f7bcdb8018c96cc8da6d034a42cdb62b406c5bc00900a3377c,
+            0x274d6dc05dd550d77fb31d349b2adb5f38eb4b27ec15e8f9cfaf56fe2f8b318b,
+            0x24fe1bc328cc95e0857e89e99d2ca97f327c21aa4de5c111a72c2c37235e7d1c,
+            0x2a98fa37a16d2f8369b3ce72873960006ea67075c023fed5b32dfe407e636057,
+            0x1097f947557042baf445bdf5b8a92021976c14cd0354ee88e43e8c8c5caec4ab,
+            0x7734a2111d925edc13496d0f5922ab36acba8467999f5fb727ebfeb37a38077,
+            0x2fca881eadd43cd4b9b3bde9046f6a2505bc46132b2c24da4e27c102d63eef34,
+            0x27c952411017987d666bec758d6036c17e440940b77db47b40d539ee1156c1a2,
+            0x1b329d612f773e77721b7a0f9154b359c24a6ff2ee0f5b9733a78a798caf0f28,
+            0x2e165793b072eaa3576cd18b9027582368581339ba3dc1acba9cd4a202701686,
+            0x218665404266df9d5ba6ba1f5a7d9a628ad7c74a092860e287be14f0bf58774e,
+            0xf42176ddc2c84d12bb3798fb2b3a06e44a4c33ac39ebe036c7d6ac6ffdaae80,
+            0x21dd47b40fc1e454614ab099787fe65d6d8ea9eb0e4055bb51e34c51bebc1dcb,
+            0x7d3a26830f8b14342a63c1ab7f713db81ad94ee6e5c519cbba0bf6d2b87b265,
+            0x13a106fb1b648c8490a71e9c16886e0049270240189d44278c63a46f744edbaa,
+            0x1caa59825f86da2ce09134f4ad823df1faec3d556f9756312cdd8991c3b56d60,
+            0x15cdad7e7f40503431e7a8c20a7e1b48ace6d194ee7d7829805a38d04020426f,
+            0x35c2a4fc2c424ff77ca180b9b522abf519f1fd8b5bb7ef7f1f8fc7d31c117c4,
+            0xae2ec57575aeeb3814613d2390f8ea28130ed34725d1605b585b4e8cbbfb4b9,
+            0x1ded456ffe562fc6df999ea5cc80de0ff6ca5fff1b0fb2607273ef1ba5262edb,
+            0x2ae307a4f4670d11f5ac1c7a3a23b6dac613d3f104e107d0438e2ca6d0ed55f5,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x17570a15226e3cb10d0e0cf627fee157af900cf4b22d8bebfa0f05ab45d56306,
+            0xec2cba7becd9f7b3b07b59be1f747b3fe3f40ff31873dd306105ffdfba14106,
+            0x115a73bfcecc700e34ebe87a02338ec4c9e1bd0d95c2554b12cd5cafa1f75f87,
+            0x271882e1e88d3a90e536ac91109d8940ae411f75de7cbd43000d6316c5ef48ab,
+            0x28d797cb88e36cce87e39090fedfa11dfacdf2adf148618d262e46fda6ecd899,
+            0x903165475cdefc056bf3cea7cf26e39e87e7d1c8e1497271df24330ad02d8fb,
+            0x521dc03abcf3c15278e90552e8162b2dac92220d99e69ef9e449b5a0370afb0,
+            0x1f80e4baee043beb212593df11501a79c07c898df6cc578190c679e64c34a2ed,
+            0x1133a6e8c5d0315d2775206b849588eaabb0b63a8faddc67806ac13faf127b7,
+            0x22af22b064becadae113b24d113f0cc3dd0d178f9cc56d78e84bf341354918ab,
+            0x16f91f204c2bd84fb907a7ab7442742ff24ab831ba252806ca7b6e69c77ce94d,
+            0x1d2c02fb8f7780faa24f3da1f29e9101c1cde4461b7d567b949bff5ce1c71ee2,
+            0xf8e78d6c9a055af147b74439decce135691562dc5b8bac4e471fecb73562363,
+            0x134cd1d2c86faa3bff3a72cb6226109880094173ee2cc808abe6f9586bd47844,
+            0x1b9edce59f36f20f7acff0cd78bdf614f6a8f1bcf95ae9d6ddbf5c8c7fcf625f,
+            0x5a6771daf1f2b83d0a92a118f30d42178846e5e209b82491656febef65abf3,
+            0x1508cef9d99fd03d1b6479b90399ca9dfe3792fc63bfbdd35661e0d44bad8096,
+            0x291cc5c3f65ae5bf17598f432aef5de08724ab30026f25adb70f85fb3bb0d455,
+            0x2c7723a807b3944705b71db8c04cc468820d3bfb99706528f66965bb8c9734d4,
+            0x9bb171d7c99e8b5b35def3624957074dc2f0a6beb861bdf417b2ae290832dc0,
+            0x1943ca5707ee772b8391b577e295dad4f10c2db1c770e33d8c37fc2280d71ae8,
+            0x1d7852588ccf0c51663abd65b87004ad5880721019214e00190cc8e939eb22d0,
+            0xee871118f882a42a8acbe733a64b7333a2d14413c511b6a79d58aa96c08ef8c,
+            0x1ae19930e083754140dd85378ca87078feea1703c3c0404e2776bbfb4cdba8d4,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0xa7c934a0347f0de7e9e7dda8b1ae9b094bd6a309b8323e06780821d7894fb5e,
+            0xfcfbe728f5c1f06572e5a750260efe423bb6992a7b1bf8f0e761e7277e71d30,
+            0x170dca9f0f6e9057372e380cfa924e65cb86afad866a330ec9ed35ebdae1973d,
+            0xa4a917f344bce3b5f92568450a4f17e6a17e251c7357e708ec3d6e559bd89bb,
+            0x127ff432555f7e08beafe0fedba0ea990b49ca5df42cbb999c3bd7b911195362,
+            0x65b6e437cbc026c1623071777b10b8dfd605a3598fbda0687c74eaf525dc1b8,
+            0x2faee8e6ee2f7bdd25ff36c3189aedc3b05c4bdaffde640c0e4d9284f7d9a8a5,
+            0x1294fbb432ac3864a9c12eabef13d07f732b652836e66a954c485735899241d8,
+            0x2dd3ab4f03573f3362bb7ddf9648bad1b43ac6939d6c4fa9ee73dc7fe66deee3,
+            0x2029b79d88ff15c860971aeefb2ebe0d523faafdd6096642b018856793e74b4c,
+            0x2e5c56ab0934eec6ff8c8224ffeea657f1b99f880a002f6ad5352d30f7c0b85b,
+            0x24888adee436dd67b6742858809073a5c4393d61283a825b65b883114d44220e,
+            0x1fb80c654292d64f24d331f4f6fac1a20a76379865a6331e7528de236f44eb11,
+            0x3e8ff048f23e53a5c6ef02dc7d37f316cd4528da4e1f6cbc4582889e1470039,
+            0x23a4cda868726fac1665985e13d800d100b56bace43f67e29da05733c2a351f8,
+            0xe25a1b132ba0bf76f1e361bff6b9bb9fa2d3aaad114f589e100625225a04b9e,
+            0xf534c5ad59c9d1c4a37bda4e52ade866d305b982309a004f3b2c6f8b10e9854,
+            0x1269fd5d157f5bb62bfdbf4f3f88c1b2b684e40ce07749cfce657a373e1e4b91,
+            0x1fb70d1ec4776f91b42677c88d2983442b78ef00e03b82b5de606a45ffd3b4e6,
+            0x29eecc22d8e5725e00c85a0651edaf5f3e9530505cae2d7a3eff6ef496d7b1d2,
+            0x2355c9e8fd9fe0eb681e8aa1e3ad43740a79cc9d930a029fd161c3ee32f7257e,
+            0x390f12f658c6d9291b118f5e116727e2f4a07140e8f3563ec5b12a0ff6f6a7a,
+            0x140256a4a9cc33d93eb486b96b737dbd17580a77f20924e4a3d87c23b25b233a,
+            0x2d2be9983d14c81d2cb8665b0c08f89d6140539c712cf4c2ac8cc75b2daffe46,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2cdce0a94aa8c1acc2db79358c3e67d954983ef0927dc6b26f9abad820f1d420,
+            0xf49eb6531ab1674ea9a6ff88bd8148690c04addf9a9164b13ff2c4cf008443,
+            0x26403014e3cc48e1cf112ed79bee8ee1467acd303d0da5c88b8683e38bcb7205,
+            0xc5f602b9f3fda8e647ef7a42af34741d11abbe0a99f464c101e534b51cdea4f,
+            0x18ac38aa55e95efef98c347335a80caf7fc5c3efc95901321e3b13b12cf46a2d,
+            0x2b1960c727b10b666328f0c37f5cbb3b06a1ad54f61b9503f23b02e5c4678519,
+            0x16f13b53b3c6a47f01c73f7e26c2fe6ab61b3e1f5e553413f2ca127e53ce4879,
+            0xfc4ef669021d86d29dc04139b88f55a5a57fe0bfa253631918e0d808b1236c7,
+            0x8834ddf96f673a786dc5af125eb83c9ffe1537fc773c21d101768aac7ada57a,
+            0x233f13c0ce9b48867dedb88a15b1461cd1befdeb99a9c0acd863dd45e0672508,
+            0x2099a619097f9565ca65ac96aff19cbea16a90e056a33b9b49dcbb725903edeb,
+            0x269898a890a0eb11e9b84db6ae0735714123d4f0aa0a30db183134d279f1a90d,
+            0x27fb03bad7fa46a625fb06a4799bf7a07ce3bf8dc01860cf6174f5d9cd49522e,
+            0x1f0a5bd99fd979d0edddd243d6966152706bffc8326fb088545b38d95fda103e,
+            0x1b082065bfb2e151552d1aeb3f2435ae8c522db79c1c3fb847fe73b728dea05a,
+            0x196840a15a65ee462a8312520b868084ed0213c1a881adf907ebff992226833a,
+            0x1bb7d7bc4ea0f7b8fb5a3b059478ce7f5ce2069e7d62a307c21d0400f386049c,
+            0x2c0b3d687226a36e523c0677e0f3949eaa45d0d3b9c9c2d11b0431d8ecc7410d,
+            0x2a22096acae1d75aedd8fc843d8130cc869b142405d3967781ecf9ff0062cfa9,
+            0x11d3df41e1d31751c5b00b775f33925b4fd5f8f66dd2c5b2e2e04cb090ffb97b,
+            0x29d0fc08ded332bba4a34cedcb8e3eca9d9a6929a5efbf58a72e849856a9cc67,
+            0x1a0ae664c389dbc11046bb170c0ddb422c4c6c2f10c68ee98ae7ac8c00c4ee83,
+            0x6f3c77706973637c7f2d5b9bd92d6e2424b926c38a2cca7bca5dfa0794e5845,
+            0x56965616b2df66e2918ba840e0809b85a567a3e7d13ac5f1e532061af856a57,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2dfcf11eef61a008f27f61a5de96abc2e329dced7092f941def6b523960afc93,
+            0x4f73f5afb82d2297d4e51498f0828eeb3eddc016ae0e15a2a9e3cfff340d500,
+            0x26290fc492220c99dd821c4a4d1acfe1b7f40b37a13bbd3ab51405a9f958ac93,
+            0x7b53809466ff55e2e4f5ad0f029ccc5a1ac5d261732ab2b010037e8ad080317,
+            0x80ca5188ef7378b939057774b2ecd1f98abf27dcd473edebccc06ac7a942e26,
+            0x2b6b01434a47ed188b43157e1964f3725cf4f8113fb0a6cb4c01ec7dc2bd47e3,
+            0x2c2106b5cb401bd68e15746349b56238f670e58a021ee2ac8915288d5361475d,
+            0x88ee10bba489475547984b890d7e794ab25535f1fcc8fae04a33d300a5eb6c3,
+            0x29108e4588512ad0ab28e432c789fa3d3e0dc0d6002e19cc3fb6795a75d6971b,
+            0x241c4817a914814ced21c06ec5351e85ed7a90f2843d23bd5363aebbcedde7b9,
+            0x22ecde699dc8dbd7cd3d81e80d9a81ad023c57bf3aec5a8239871472fabc551a,
+            0x20dccbfe3e84b40f3908bf43f0512048facdd8686ca5f17192f983599daac6ed,
+            0x2c96389333c5459ec65960d848b06bad4d6b8abc6f2602bfd81824cf43c7218a,
+            0x28c59dfea6fcab6ae73beba612e62083a58bb80306a3bc2746ace09d650c83e6,
+            0xdd478a62c6871c699ecb4ea12e454027212fd8f1e03a8efc005df6d20ecdd40,
+            0x28772e7be45e36b90c2d439748c0d77c0b523711ea398e7dbd85b0d7df1300d5,
+            0x2a37740039be074389e76e1ef0095d7d111f778072d4a57334ebca290d667a4a,
+            0x2f37845d94aec2d63ddcf2cbd3fb56fead92ea8ecd819d7eac3c2b036c6c2cef,
+            0x15edccc5a7e695dff4db9dacf405612f00ba80a16dfda1b55cf4beeedf90ddbf,
+            0x2817134845b5ec6aeda4961644d513269f86e07a21ac3b7344d582ed07b5f46a,
+            0x1ef5390790a2a3214140b10962d9435bfb0b4e6ce24b7a1ea0c9af689234b6bc,
+            0x18427d6f7cd9bf7ace6341d16dd845cd1bd18ed4b9b8ecdcab36fa45860855d0,
+            0x9de33bc7e2ef786db74db7eecc7ff8720454637bdf51b281a4a1478f198bae,
+            0x5d2c63aa2de4534fa4df7a6c5f6d10599412fd247a59f778366bff5706110fa,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x23aba695154e684ff482751cb761dcc1637ec5e99aaea18d0bf2e2fb26eb142,
+            0xba208c04ac11ef4543112dbd88212917dbaab5a87268d8158a487ae3241584e,
+            0x1cfed0b58000d3ef4cac1e6fe54e64af54f393accaca4d5b8cb05f61ad9cd776,
+            0xba1df4ea027f8349fcb15d1edb328a76fb536ab65ebd535787945634d09c5ae,
+            0x1e136b44ef141c91945c8768805ce01001958ecdac9b065874d21717da99b408,
+            0x20643e3f3c68b214605c6df2d802e1e539b465b98307fcdd0f8d5bfa1778db69,
+            0x2127d0e7d940b3132fab6b1cd719577f51bf8db531e37edad5194875ee74936c,
+            0x17249cdabe9c9db4a1b88bd5636d3bdb48eb0ba6a17357452c97f695b080d5f9,
+            0xa6b94822882ba1ca1da954566ad30322e3458a6e0ddb143e4f5f306fc9e3336,
+            0x2486410df8f9b4817d82adfbd24aae41ebf7c4bbd8708d3a7c3b18a999cf79bb,
+            0xc0b7684e8ae46845e7766bf7620d2791a3d218bfd812d008f73ad351ba86aae,
+            0x97d3ee321f0db8c04cede13ecfa87cca6ffc215653dbcdbf62825059b8521e3,
+            0x2bff71dafae458bf4854d7957865e2362b99a7891cdd38e17f76c5828aa16531,
+            0xfe15f8b13351058806bcaf16fdb68f3ccdf3c30f15a85a58df2dcfad72e296a,
+            0x2bd586480aa18c155f688c75ba812ff81990930c1aafa4058ebaf667d41e53ca,
+            0x2b91cb72fc45f6dcb1dabf0473e2455f28be6eb1b59cff91b5fef3b81d628ee9,
+            0xcdacb5ed20f18668a7c3f21366e04150d0e877756e2ee1cee11921184a31a71,
+            0x9239d69b632ebcc1f559752a2fab086bd46cee120504a8c94b4427a2fecd5b8,
+            0x12bcdb6b20dc77d3d5741b3fc61e1ec6f53137b01a23f48c2a267d6fd59ca0c2,
+            0x11ea73b3f04690ce2ddefc2af3bf8f8054ba74dc313b09ec09c96fa29e865b0d,
+            0xdda6467c64b0249d2f065df90fbc7a685022ace6d9cc6d9c983dbd7d29eab53,
+            0x15d7c61e8a8308e4a43d992947c0262b65bad163a8f101423dee64c22bc3ab02,
+            0xa825acf9f09d653e06be5dba7ca63648ebd6060377101080daf3de7bd9d5380,
+            0x2dfbdf5d427e2fe6892fd40d4e97ed7808dd823ead27629d894982b7aba08a66,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1c9ea68943d8c846364060646de0e33534d528a23ad82b8ba6870754281db559,
+            0xa15008aecf43fe4b9a3bdc26ff03e3867e974352926cb3ad1535f7459648a98,
+            0xab17a8ff84f7fa5d0daac95c36e606fc6e133e7cb04f0f7b5334e8e6c44ea88,
+            0x1495d888378f7e12c016cab0bee2534903fe878d5650aeeafb3814b3a8b1ccbc,
+            0x29a054aa447d63b2124f50ddbc4c2d943636ed53f22651aaf90fd93dcedfc941,
+            0x395b15a827e37a6adf3175a2691c288aca68e16154c2d98d96bb0dbee6a3f47,
+            0x2f47066bab9349dfa62b25ecb43354246a47eca6216c1d12c36601fe3413ea6b,
+            0x1b1ad81eede52f8a8c0aff49a041dce0b55a1f06c826b441951b6d654b804012,
+            0x137f27f0b79cf88476110b34e7ef630d03ea21338c200322990157f50a8f3fec,
+            0x131ff85cf21b1a68336160757d135e1d605144f82b3adac0fda110084d120349,
+            0x5f848d592e921b0c3c7a36a84765487b1357d0ec01f8f329aa8c6f266f4a85,
+            0x2f8999412ae8dcb4475413e72f68817ec1a094272744d32be4b8a0ff74bfdf1b,
+            0xb42e032237f3bf21ae95c4062868751dd39d0f68c06ddb849f691288f33e261,
+            0x199c8b45cac96bb0db0f2dcbf92c361191cedff0d949606a140d3420dfad31dc,
+            0xfda38b5f5bd1100dab719bcfb3889371f5ab9ce9c42868e7bbb1ce2d5a85f58,
+            0x1bbfe63a7558b0e9a002b3983058c3cf399d479f7e2193d2491d585d541a086a,
+            0xeb005763e3b3d55840741f0cbfc95fe55483854e817b4d7cfb4549ac79cb34a,
+            0xae77d49a777e5a22a3fc6aec242a7a80f52af3e1cd395cb8862b09bf3230ece,
+            0x25c1db48d2561608e3478c8238b3872dea6de1de597c4f26ed8baa958480e5b9,
+            0x150bf881bbd323068ed07cea87050866e7b29818f3d36e08fcd35b31de21b85e,
+            0x2e9d25423c272d1989d6ec5e983812e73575f6040b3f775fc9bd1c7817c55,
+            0x229ed6f052976bcf9f11e48f4fccbfb450a7b92efcfaa532c1c85a059db33cae,
+            0x3ba04ce72a78038c64773239e8f8c1da608b93fbde21c2ce94af9615ae10f44,
+            0x2ea6dd6483856ca2a36102227dc147fbb29fcb62ef939915a9db66c103a99abb,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x29e75237c1ee6bb877b6e95b7355cac03170fbf57421be8dbcc50f08693db587,
+            0x137b76a84a30e906a38827cc4b62b1a22e942d835192a98c514eafd9013a2dc5,
+            0x1e2a3dcda8868ab407f15b612c405069a5c1c545af827bb0f8f6e32dc55e0277,
+            0x5b71c5d1613cd9b6b3cfe9400cb5d8583a16dbc1142cf760ca6aa9f816e9f28,
+            0xa7603ec122e8e0178a7cb29db181e2a9a71f825effc8415b8d09feb7bf6ed31,
+            0x12e4a61dd3e9834662b78d9a820c25660926039237ef579fd1eb260bce13112,
+            0x17c89d0343777a479dea31744f2848ac06045696d8f0017b7fa9d3abf88cb373,
+            0x104a21bdcb8e49245acd6fc281bb1263976f138797f19634c79423f349d6dded,
+            0x1e6ad3ab8037bed2e36c872a9757a796696ee2950f97cf31eb83bcd4f63805,
+            0x248ad6966b401086060a913af010da4ea282c2d1461e3dc100569b3bd1685a16,
+            0x1b4d21b426441caf2545938d41bcb3b37c32b3fa15ed8ffd1162e65242ea4d39,
+            0x29c4422c99599bab17470ab9388ee796951c249645ab164e90530fc851ea1fd7,
+            0x1ce500e40779238422cd47a0a6d7f3dcfdc0c6902869966211b0b6a9acf5171d,
+            0x19102e3c727844fb898c083bc1ff45d106a293d8dce6ed43895782daf691a7b9,
+            0x12947f4ac2f6fe4b1125a28d17cc4a3e2db92fab0e0b97728c8b7bb2047078f3,
+            0x2a7639bcd6591dbafef49fb61db710e9ca0d712cbe81cb86340d0f1698103515,
+            0x83ac15141e94aa73277ab521d9eba44ee30f4e02d6e9c1568172bd18c9b7e6b,
+            0x480635cff8314d917d8a55b349529dc633170a143f4865713f10007f7f4b7d9,
+            0x1c03ca2e6ebcce9a2f4ce66bb039d036b2b7424ae916bda6240280d5e5ed0a1f,
+            0x15e7db7d25266f604b8f942efb4e0c32c1e45621336d280f1b904c3f4052936a,
+            0x2215b41943b064cdbc20179c98c4a6948c8cf249f04ddd18f519e9595aa33b,
+            0xba3d24e5581d6959c2bf9c0c69560f1dcb6486734dee56834898b97e8c04b7d,
+            0x10de6cbb712419d84dbecd375963ae617b7496be8ca89c5cf3ece9d30f4f854a,
+            0x2a4f4573863cbfb189e17e80bc465161a508dd069ee4fac346c2b024c88b5cb3,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x79c218efa2fcbe1cac587faa89bcf970134391c8edadfc9d54c666c091a6829,
+            0x112316416efb7fa45be2c134395b446f048902531554fd38e0bfbb364d196924,
+            0xd77ef457994c37f8a3bd0068572311673ea26b0fd473aa1ba9c25c6a627692e,
+            0x189bfb671bf421730764e771fd68f01e883f98b0aeac6e5c9b623bdf1505ea70,
+            0xd77f35f4ab33fd80625be829594190adface4ea623ab12520920ff8e707a591,
+            0x26288f7ab16b1812ff362b7d283539b18dfd08362e2a7c4466744a8b815b0fe9,
+            0x26f1bd644a7b3118e55d6beed008d72deffbde92815b8871ff8d861153eba032,
+            0xeb8a1d5ae4081352c7ef3d50b0622816fea17a0fb9cb163c0e544da8a7e8ae0,
+            0xdb56b6264829c99f094eef0b8c5baf36f6c9518555a9b8ce5845b4d32eb96e2,
+            0x20883c599a195873758fd917f44d2079778ccb41dc128b8003cc007b6fd664ee,
+            0x19f29faf9c5393cd0b7c07a902457096ee6543d1dfaf22a4f897d2ea6599860,
+            0x20a2bbb3ebc1f46f939e64356d5d1609b5e50b5b3fdc7462b4faf735cff66ee6,
+            0xdf989faa8055df73bc2acd9e8d9842bfdfa81140488ecf67db886d58d2a84d3,
+            0x1c208f8e89b2c7fd65a95e2fcce432f5da8e71640467d21f351b169d03395c9f,
+            0x1356fbcda43f79998b2833fe6eeaaf63886cf799f55505d81164c882009151d4,
+            0x2e99fece2dc2aa38fc4055171969feafb838a5f2735ecba803bb9f4d18a5dae6,
+            0xe39c64bd29c62c85340ab8eb5f7086e1c9bd733945179b108891f966b220874,
+            0x8432d0352bce6861217bfb3bdf0a04f3ecbeeaee2d360cd5a28c5d2305911d1,
+            0x103424d7f89182df35cf2d59dbc2b453542beafd78d95995a5e386aa2e55aacb,
+            0x10e4ff8e36e76842ca11e222592d318986689fed7328b94cc15104c8d86e2def,
+            0xa6b0020177e766bb234bec7dee733678251b1c8899c516ed2832aec23623c5a,
+            0x7514523d425b76b3a7812057725c07333577023bc38d70d079eb2d524d94f87,
+            0xe666408d6019b0c96d7c9dd5ab9e08a47cc988d93292535265f710873da5b08,
+            0x2339395b0617cd94dd101a4d03051e9436327044ac470ed0420b6e9bd876bb5,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x823e9cf59d9e29590ea5d5caa60265f1eefb9ef497a8a653e21e6b884bf380c,
+            0x25015bc12c22856eddaff514db520795225428b8b63b82d54e6ead88904e716f,
+            0x147f4836af834c89e12c52da5d778726c878bc2005e78e9c0bb46ed47740bc8b,
+            0x695c3ae3f6aa362df3220e3b4b230d3aea7ce4dfa4629a0b3da2cf68ab08b2,
+            0x2de7695bf1b96fcc94dd6b9f46184a9843a90ccf1891093670cff21e6f9a6fe4,
+            0x21326346451906a82345ff6a916bc7ffa139b3edf1ccea12b1ccaa554eee5faf,
+            0x112efaadc386b3c1abd2d173beae1b5a9424fe57fbab2c2825c2e6a7e663fbf3,
+            0x1a2a5c2b2990f00cb8bde45b57589cd7fd1c5e0df587d6718999a1893f0bc8c3,
+            0x2087e95ae6df27098e3ebcd46f3e4feca4aec7df172d5ef293849f671322789c,
+            0x254c2d79bc6811203b55ce01f1e8295095201f0f03613708366a7af5f7b9600c,
+            0x10f23dd383d2ea9524e512e2c7a3b75b76acc7766a95067116493a0d1db0efd2,
+            0x80154347a02980ff5274996369c7d439951efb11b19c3607010b03de802b81e,
+            0x155940fc6e3236f82e7b7257f0828b1f43cad68677571d814eeab2a6986b223e,
+            0xfba722c1bb656ed1c16203506d15a78c79088a9dcbad00a18e707b71f326ac7,
+            0xa31c81db83a6746fb9747989509010c547d619d1823298f1f5674551479bc09,
+            0x16a2ffcbe9959f75223188ee2d7bed0c4cb9ddf552c98fea86a6c01f1c7e0dd0,
+            0x2e7e9b9c74526581808097354419679f2d878fe4312934613b01820d66080fe7,
+            0x2df5d5cf7d48de207d7ff06b292961084478a6023f4ee1a0da7619008977d815,
+            0xe1c110badcba8d0d3190b37de62dedfdc2a25675f54d4c5bd6956fa5b6c1d91,
+            0x1257af1a62fb76f7a2abb3ddeb256bde2cc31596ed9a5aa2da5df05cb56b9ebb,
+            0x1197774ef4175d674951e91d56afee6229e236a6112a802c20621423b0a66f3f,
+            0x15787ba0abf814438a3c358e48b84cac38c4dcf66441e29b5a89bb17b6dc50af,
+            0x10df04b3f297cfd58260e1933420a96f126fe4a3f9d53000e140d4f55c2217f9,
+            0x26522aedb4ef7245ad2e50ababed3e320f4ec30b43f2bf1904c956cb3b9f430e,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x30084328d537eeb68e55d5593d350824f01bcc9a9d8cf28558982dde43bb8ddc,
+            0x5921d17d596463a98fabd2e90e2ed92eeca8b791f75134c9aa7538ecf90e450,
+            0x1349f05b3e3290ea030b6f2696ed6df35c27205e6bd904b569c363d985c81fdb,
+            0x1d92c460a4cd6ffe4582a5aa95ff6a8369a804f55d0341dd94d495d538dac09a,
+            0x1e27ce95b6ad61a67da6b7ff01d06998a5e66b70ad7086962f8b6f6687fbe00a,
+            0x260b78052f342b0f62c4a6d75c2aec7321b71c084fd3659255713de667cc742,
+            0x131e63069626670c022ddda083bfed93280ed3db252d51ad6a7ea8948ebc9a63,
+            0xd89b6c7f1e046e139cd4b937b5f30e293b478845aac1e1e64cd90738dbd2fe9,
+            0x13b662585b95a62cf47a3d74e971dd1a2195a9987ba5c35349b2ac299bf6daea,
+            0x299cddcb1afe110299b2c4589888afdfc8b33293a4b4f7cf822a74a922f4d61d,
+            0x243f933137a5377ca39a64f788a1bdd25027e4c1579908aa2329c18f13654b40,
+            0x152517da46773ba3a5708a14db3239e59b4cdaf84ca55ba6b7c61e9bffb6feec,
+            0x1811c08f29173c3ffd29aaeb2d9123a5e2b5bc32e5d74a23f0dc026199f9c8db,
+            0x2beb86f7fc3941962809bd8c7209613eb2f403a1db90acacbd487034b4e734e0,
+            0x22d40f04d25617323bf6481a7116f5c77922d4a98d867730e9717a181c24ebdb,
+            0x7984c5792dff5a244e45e8d9ca13d787cf5725f45513595bbff1405f8a12f62,
+            0x54f16dcf84267fdbd028fc4e88d51fa7624405920d6f85771606130c735454c,
+            0x1e14b42a14dc7272d18f47c28dd8050fb3993b0c0571a12f3b3e4a4c49ef788d,
+            0x125ddc89a4aeecea6d3620f026c2a9372fa856b53d8ad5d8ad495a5eec7ba24d,
+            0x149d09583cb39f4124a7145923205b3bfb7121c62a39d6238cfb380c782475b2,
+            0xecae7698bbf994d656a1d3b3df5668350112f80a5787730c8d32436aae6ee32,
+            0xd48fbb1cd222f052942818e73b12562f7490892f474402274151763ea668369,
+            0x21ff6e0e9dc2c5eeb19793fb2b3e64cc11233b81df41803b6524ae510cf0a29e,
+            0xdee76eef76340680e4f3d4a0c51b87a162db5254e981a7684756e55d8b513a2,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x1c72c610ee727a6dd1e885a0607d35cca9127f006e26ce1f986bad89bc3bf3b1,
+            0x1d8bff20f53a1b7fbd3ed4f015ca18fa484cc6fe4fda3821016d43a62db85681,
+            0x1c13c5149e5fabedd52729f4e4502a7d0d5058c532728db8377aa92f1c3e70e8,
+            0xa2044c5c41c0e874f005528327e695ada2337dc81c9257b6663ad1e37416a31,
+            0x27a159845c8347dce715b4de7d305d529b7c9bea09d3fb1615b69d5d0e2e9991,
+            0x28a37316b111822f43ce287c632cdcde70bd0a094fbb0ded49467acf199cd86,
+            0x69b007be4fffd6c1611b22a1f73aba8d334eb39e36488f6dcaf8f61b07cc842,
+            0x159cfe01b040d2ed27293355e3ddc2727906018eab4f0be23a0fbf924d74bd12,
+            0xb538e8f3455ff2d7f95203ec7c7d12262d7d25b224a92500923726f20f4dffc,
+            0x1f188392740ecb474a4a589a3b83deecab0c1c583c390ae1e3654bc90d0705dd,
+            0x85e8ab77fc680dbfddd3a41d1f749a5b25f207a10fbb591b2b2b70705d88911,
+            0x18038e5ab85927a21df17e8a5db6e3e62242f7bdf6e662a2f973a794d132ecb7,
+            0x25975674afcc9637d27a23b97bbd8b82874bee41e7b84057be13951531fa9fc2,
+            0x2ff9d4e295691f9979acf589c59991f2f8917c6358b76e61a1b53e1184dd3611,
+            0xff8d053d841882947fb4d33026c489c53b410dbb7afd04a3461f2c6b46869f,
+            0x1c6d41952c53460b094bb1d727059e7ef08feb073f1d844845d53b9640a09f64,
+            0x291c286327312c533d3e244d73732e212202e546807d2b5d7582e7bbdd28b10f,
+            0x2c29cc08dd040a2ccf3c5ceb34882c68f0c773d055766b389051276b2dcdafd6,
+            0xb51d6531aef720d40d878bdfb54a8dc43686066cf85e6eb5188c094b173930a,
+            0x2eff7e9766928007d29d2555f466ae211166ddc034d13531728246b23850edb9,
+            0x1c856f1e898cd9241df7e1bdb20857061acb1d825ce2b9c05c785be35a5066c,
+            0xa88dec27698d5f11c3e2619b75601bb5f8bed6c59defa4270341b8048cadba9,
+            0x171ca4dba69a7f21c315e9ec1d4324f8a365828508d62c205a0c8ab55322458e,
+            0x2192264db77dda74e05a8c7389bf314447eccfea329054f694fad2ac11a8997f,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x2f9db1272bf8daf7461f68a046226bf5eb50de5222634ff09f06cd08c8d90647,
+            0x2dcf0a905f69dcc006ecf519557f50b60cec57e406fbe85ce719240ac8ad4d96,
+            0x1ef1e8e3bcabdd9c59f5c8bbe9c8eb2fee860feb4aca30cb0339394dd9aa845c,
+            0x1f11157aed6e03678558e187e731f4e6c70b98fc36b5337562c565680e64bc04,
+            0xa38ce884c10d28d82a3b6316f30c7fc833f4e1204c984b7c20098a13a0d5a2,
+            0x1db78e384fc722f1290a337231d3c8986448b867adde280ef5eb72c45fbbde08,
+            0x1e815a5b2ff405454bffb88b3d8ae428682375fdd858d9fc2fee3f76cd3a6d4c,
+            0x370b02885c192b687c2cbb330888c9f4b3f26a6c054f70b092acf96d93f7c90,
+            0x8203f9ff8db7576e14876f45be708f58f48e5f951be08bbdb4e9cfb23c244b9,
+            0x29dc1ae19a1f06c6d67ad121f185ece6d0751d0ac335a9b7c879bab33dfb0e84,
+            0xd3c1af0faea85e54e7da575cff80e5c027cf3876da141377410a28026ad4619,
+            0x29609aac1d88be4d5aff5dc808e01361309a1a6c8c0defde126fb554c79944e2,
+            0x2da5231bb84b05c467f6fe2b9b3e3bda77854f6de32ceb380fe0309c3c8c5d50,
+            0x24658abc45d1109f9cb4ef1cfcea11de3ab442f13e710d10c0bb6bebe5b012ee,
+            0x1f38ead2636865f16a72e393dddc1622ffc5417e5194d6c15ad8bfbd0073946d,
+            0xde6a95902d88df02192471691daa4ac55617b73f448a4611f3d89172831542a,
+            0x1cb8cad4994c3af3a2ae4584827640cd9dd5012fe4b55136bdf53357b4c168bf,
+            0xc4b166f5e4c3ebd2ce9c84e88b3d42cfaee7aad923d9807b04a2bde61151b1b,
+            0xa125c564bd818b114e3af44a87e694061155e19cbc84c50e0d29656de2a03d9,
+            0x18cd16fb943e369664b89db857f6787b1d82a17b3940f15add4047f8bdf4dee1,
+            0x22100b866fb7d36e656990a2c832bd09d7d0036ffc7d2693b22fcf5c26b05735,
+            0x2228191716f3aed9191659eeda5fe346b80af580b666159ff25456172562c5e5,
+            0x2dca6c96c30284bb8f7cf3467103d39f922aeddb431bfa3b62a7bc1f61fd9baf,
+            0xa242a4882954de8d3d1e8cf0984236cd4665abdbb4d980c625c1d470349380f,
+            0xd064dee824928d39f2a8be7d2fa583223c33995784d228839adde2559592592,
+            0x116c85a250d461dd5bf2249536e50de23ab8e0287f5cbc62363c54c690c6d716,
+            0x750eaaf76a03769c97c684d448ac7ae2ad93950a75c24f3482340bd29f566fc,
+            0xde057ca401a6fa8a17d35a643f71515678944f33d6253778d116b55b7599cfb,
+            0xc944093f1183d2fd822cf70dc124a07ac9397f3a941a50d0c35da8df5e35180,
+            0x19376e5bb4d2266f833d7fae60c8c5f2f484b203f008003038515c66e2677233,
+            0x169bcc309d7b6f8c73594d7563262ecd332ed38cb317d2c43f6f8dd704d32178,
+            0x304811527f616bc8ef59c55565337f63a42094023b3abf89ae99193034cbc9c9,
+            0x24bfb86617225eddd82f86320315dc68e8a7fad755ec408012968449dbe1ceb3,
+            0x242f4b3a3535d5307261e9a75c570e6c06174ccdf398c934958ca129e7bde3a2,
+            0x2b2f283271455095d3c2012a1f4fda54ba8f365cdbe014328e0753d94824f643,
+            0x35a852e7bf5cf60b00f15be184e707d345fa227d8e44e1f4c37050d79a53a1d,
+            0x150f777da222071015c6c4e025f67bc356fdfd678d9840dd2c93ba1a43f98ef6,
+            0x2d8c70035731ad9efba92821a88119f6b8183a362be641729a93d6a327c03809,
+            0x7b620c8a78e09e49ce547aa783aa78f3e4594c49ab3dd6f602bc6c0351d823f,
+            0x231996b592528575567d39d00645a83b13929093bbfa00d6a661e4a690351d0f,
+            0x4e47a72e49b9c5aa3f69f6af22fa0ab640c93fc524dd3c508486d66f079852a,
+            0xa8cb4b2bf3f0c5da671e48f83e5c1b3018f0d31200a6f19fd5195db22eef7f4,
+            0x18bbb002b46f2e5fec2b120faf87822ca8e77ace94e03aab5c16c4b931739dc8,
+            0x2bfae1b054ef2e924d75a8a01283da29103c57bad129ec8396ce274ba4524df,
+            0x6d101b19477d1627b9542581bf0cdfab38b05cdefdcb81965c5be00d780f192,
+            0x18af61f6184ff85f104c2bef179b3ec5a5d242dfbebe8e27a2918f620e8a5be8,
+            0x11e3a7c2d5f74371beb188c6e3d7a14b33128af8ee3287546d12d7777cef70cb,
+            0x2de5d6a7a27343dd0422ac71b8d409b43ccb0b672e978f8fdfd214f4d7866404,
+            0x227cb43b9818924f2a2588964a0ad7ddfa3df62284b4b3b10199a501ed970622
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_14_config() -> PoseidonConfig<1092, 196> {
+pub fn x5_14_config() -> PoseidonConfig<14, 182, 1890> {
     config(
         14,
         8,
         70,
         alpha(),
-        [21845584790817078371458083471368949437776490472877850604640045078191512294989,19653529167194186573342031346879012675435131167180408423801998487681049609228,2161640783454164110262374377277313793192503897274785966059544028153063342839,3054385704838408049711788708109646820127990212588286684954516786776077717445,16635301713639076283966918721405743045341739008997361549904617279107633739991,16225725689449395070421553385264743934675104858051374243666267106604469686859,13459300344588917210133884568970491767131781128923804903594902942358152425193,18076808066595657160589765822638228194586496301618971676220813553508533309824,15694780501519741286439086116053845024521602672078716577385749258673935540935,16872540725652861460604107748085417998883467929955001131816309200004825208678,18265717256656085201140362928095712147159090935193139243454994794524622317396,19947609676398163035598483882491861002323351300468831661031717096486749401185,7065348755377637300800426777670517297442798705186719592553630280930183590981,5932961695686545421777788171001317503890223201383043783424823453778021729657,2576876576710667081195577161905871971928185892200731156106299121736713352612,12555802030075275558510564984903031995058560722557285963258561359487710166944,6675427211912119210966904017515062933064977336124153512189140864737663166184,12222599141329943348111473622063042423140762381594560767061296463113725630598,10362975561623981137760844569177506781739504467939943515494131756563631401384,12107531632347826132438108083855485290921771214734424618157420540758495466114,3236413362865617508850894632024597913345632839215458268170009274560894755059,13269640842689962370480760671727240164372687082286848502921603339956981268889,8634391395282326489812410144806386699066840792624899435283359752045476380023,14222253145252965302168372301361324351891663598874510374220732501857922860417,8638897321585802770244834010345336579513350450350318876059595307827518698264,3865974821285567306249300995778666703191077355251395536574998983854299535502,7110975263857442529682465175399830853738223819847928136560110618272170902664,20747849667914457283564964533975989346418433637631755372433299771504842519646,8525337218586373689263383636693181730826089466845186214607593322372086164902,15284698092379128147447314807096025894174546974949762301780223877793581148749,7697267363768037767923915437621109821518467158489394234232803683407232938777,18552464418403713636184903318257896949762751716606049583572368219578636617127,8197992130246671682417102475937137101180310399693221498504232752936385287840,6267215711691005252092821645736755217101102985763928035625443919819600833817,17433952956528062441211440388577119958754746388457390005635829394680376947181,4412646415700345908595327060988016573431087490581498127967913815901104779675,15833191543444816612091389727640172975373200401937212078659643034429446372420,2496738022051529758808536908421531340554055955151436808600608028881270179985,18865821309368781007158439319264225124435320863391412688953283839208730853556,17356853444859379852104523062654303386446700475095103588258687890090805160214,13809314487709569674040696128771324530575306163394456992422515709961741509179,16441057642509466688507318755613056920894191930223829210993196564779122458374,13126203992288988176378067141418363395032818736472538500506274256104409609416,13787967697762688988712839398243982920760030565931489906532854488857802399817,19656786571615920765259702874045834039087950126970888730192726308970074475638,9496155930249199891836650339371004045437843955429376625371983436016490755144,6133650980214690439646563353939486183333374330790371938934927663849630407389,9878750392407472855744714788091164958447986838940220983459727015586370325700,17172636845539329981401043696407061375416986816086343858560846660524543673690,18266068074968659293646594793202575012585251834459743250538629833034512472364,88170009072279647351671114053985696295758726185186407584170034409102883821,7161623553009701438320582200845261728475099875569530553253147102879319777702,19053465421328592764143131116469165876378776722378567877265112443326967288533,15787821054928042708896412640384007326676625326396861263135967977164294783653,9615173323505112477217305395762776033870692647990635021315350642536385774258,10748585844981412663149047472971001536312431184916168605042111548221680655573,17193496554920138070905215774356694517155445370515924892481894322048517125340,20981027561373479728773182418686452188471940655764396684028110979140369006827,21262972686125563821794309741130556914165641373895499794098515843451753652777,17107658081493676403630365275304097003600155220274082934263833389505162130032,12511894931761241561787052333055670047472612011302194769826693935710455626001,17806912269440585736864672280987816575618315620498245554921738316327046304192,19545292022072695979212345737390709562681030627834519269858193519314537426533,7543800958185166098093959246645025070235714806654195385000743554473922936618,4625475082534149232161405731224600013881237737740742465433231001161153655617,12763413547514960206069967971684559703789391875445961922711624474020658766608,16881857439631059221437594346198587121133192812269921863116602807689099485795,3231850141984038920375478271531925025564375094627983241106994584163478821676,12025284448956248150398233143375971306100458475218939512492496426861431663478,4525425011555084029555870990647344303529266577387030581756537915893006804174,3795501990414375556011654275060518399449630146003978757203023617760680325709,4509128642188781738213513757207125341975604363824265606323571895455672910764,12203047758734592203615462366516348191118610129553686354997732038970187121007,13638687018405787761639420673973367506339916347486774445588648879776248875396,1480604348496719441038523415355764543336234934845679094037807499653490493865,10692361717579001228187212442602435054487474561573499974105521910665132275515,5007773285184019093586454921139763432640822738583548849737728483623941935472,14779176361271780821074929551122175132746249520990325894754727749064980218318,8810869743928256631039877155210471039332035226261305285283609913565228857800,18154173501970140404154140565370264376529820426626464552253141823874364956900,11656303509442573507998921894257944851336988233800378817636452696829680890350,17658875741559155615021995850723408238216088494443352771306394733637591342379,18902160612986281748775835015982844003483334222891067179969353562662106908838,21595310045201809412620701470963174488544609749637202383626402540041734306075,19479000691333638193560008307308022198954460138615126342769742031420251871629,2972632723219534905306782557604159867920608086253824361540409985645334537267,3847529854347283694984727631990010016411937091308711649053729266492176961919,2403423343103741792664345548178046472942690163193710191494177026621927723840,4715026270007766325068951713831542483223564562870257986931331836552507312912,10050946066792704139911540686518561899625455529845988837175998569612056291645,8462612443675205626907647847435181314299724037672159352834910195653278990554,21536131862603746518459731430650379927614037990254564979711500405913555717860,7888269140704212528047592848167567446827917489655456773861487833453406017069,1170377169572693438349285053961454675716678619265656860173330864613871015536,19621259602533287127007734174330694952187330430513568066156633937834027643682,17165866032840109673438683878903959007172818091757219456373859826178202458170,14933333727688891927411002006378277183547380244506194877231532901665762194033,9343867619319423527260818064767777717418825720619434299636538864535443951928,20583768764298760141290708372295636534035063275069820261065362331153347542719,2577125135040205550039517386386446603255535410845714513971957864613256569227,17000415305135911202592785659979381300200707282766529883690542305214226820231,12511346220893686853445962138128902612419766727072608028194026193211924059518,4149764657828794758957335209849218835702975200988138041342768571619211624011,12689460200478357229673533402655824055278729189265502524126586766684281271735,13400421547966647260602415862775725767930791927979420926402318903131836007467,2276424802663141757392692926366037451925020546827329479674513290273559843227,13207120510498253902527141512742067250437249796266587317279641215901655830896,11305234940211349140158920206630802129159533495623653407204084399910372957174,5497774303468738593952657049388763226915569613134333653497976925327612433620,11780989050042171707300156320134237383624870460000896361633114513125178671303,11197132624111031475729914540831613691695800675640925983729890209473799714664,16140443794881450163624886684327741887016098106725788249967592676372285999349,11051595327889397185166361039119529941213436445931880650633610124485963060123,4836646605031570157308209197698105249544981108702254887271797808619270080413,8209009069949005083422618473679185090070432230901987251869909206753231145136,16474909562767173375575972470108350369290532718799369728226238753027802729614,6086055204212098936385823679317209054285543683998660974885049732319143968166,15845663692001601094665565765687773803894441337616861842355695214969875896066,9098420601018427903226168857535773321796962623728010568581252061114961655465,14398020486027915166775907825392652502550084557499300430668649177321914768934,2529766650486869899750453189656713618464482405989854109458777379339220142554,10340604539765718682878802989600110179317791699890691229388614321680034249914,9878876288226000720310995235539201725902546228232202248134844052052896121876,15598631334601739991411156353640870142866768421111507060679644747315412727160,12476036027414150699365888926628033468852849122092016651897900659667567319806,20803031063635652861008057675598133287087428947752503544588637173888166669892,11219667600899420706469792543049361323110081262796605270588885844619718041942,9239500483618882938511561535687911499489200513580468310964041871852656042420,2295137860333409753273134561401486593645236761709753752653034489900637997862,513840239484316074257070195372896343613221099656421936676995152626965728304,1240423160571920455132480263739570027604064696559298170495781456216075158172,1000335770452092111597579881696386094005166181014081250146819592415429840281,17732477784640275643871498532120858657597895452427536145089468999578047484919,17170981021801009209909418054936322243367033572422755593175460758882664580508,10474002915893131225108722048498342055539813455822038310171605686332057287523,9603348396520941909404735719689357385027896452682306755794683717883589365434,13997990766251226080324180880591113480591220558468819674906322487254600879864,19165322589470665586312376362321121865643126447966933590462565164041476345514,15889877351963901365648141054999234691357421706029208812358207119735767519856,8668047067682657740038874191537478915165931784511538119786089297082841482372,17366185630903586492716760756481097015828466883331247688174482412238176387717,21876355395221655909209577718688727663428003322801196411166438189091863032706,8342495812890419318878301820827026193204690451839354912098079931173365213850,15887225707174335160711915570149252929623026695369026542224074924735308390993,6378295267974387238182583304654614405910401210077434367173120406371155400542,8599288341856208016511446109829802753279910611437057243892303163654271528710,14384569526991087242726852106274677884712683003324629101047489219988189168985,12554858483255821944447983588851327925753928086067377749529759729841684476442,1244202115364291386279329790002693224358694897412189477392486275482043163127,12995340746860271768506969399635216407185990298275348495956441603189500195767,183027008509741755078232756367286076025735908110463758323021771971495606238,3573731114015522988150416514182944755210001235963017910935079689853918043877,18230391763740278339288441222957881377176531304894832542129957275399074045651,5937391935832132177003018978899438941930145516233683431615177125757010459652,11430996404641585372503695535042106445550893936697962891622779166741655729488,9708207568505790825432073778606679121879367766370067169784170835562004694648,13398805456168802594406839007653458669253514721606724093311019328402863953525,9509172607193998955864433140854270981598209332315830561489225794322679022459,15502257451151630587420754221500874210427552449899109970701467342791400645333,11123898636843146818131986172543146864729611142704598768652657993190010179131,14756654073235850387277128827870550186598788932163678015197111219905127222330,2775596743802877046549055877116659535653734622828894792515801349479916697007,19393614735747455293764838818808226619563895886462373669050764399041257455003,1249320178045456927170274664240781660345447736835400684416240818258732622074,12796406917637014666646024992328239080230785967810042823382614274279812889313,8731150020101451449969760761271583792743252060005019647239509560664328018351,9933789898048906634037638211430912333233899173340437080629891912049447301727,7466451925704968193666093494894304477671721132981190905063657961063858961172,18149794038935586919422942907608353967008376245075544434132167909292547581560,2645338086907790474420268058095037943265764190369965623902938950146047558570,3805226260777608297922168382052882356808083423152211373837998107098065055539,4989302370880302660583716899846990066057960576662320219898456979014043515025,1070415851697739963236557454136444292508409566097266743684211383600964969141,12944245506579810779814853939016758644439439209107032516878032396119045414701,11769349237256342071683275569967616595926207710668472449278925821680308524365,7515880964846644263997052091312985911975830135506678004303761824155773875060,12464357909913670578721898201968110981078170975300784494985401212355213230335,12531063240134560397069746994123636136169642575111678588073390651101761449521,6147041690306761331612194490775813268707261569782473045839636103273693189609,20058953556654404269207947758850631052629168082562724690664696238258819343333,10671449076032051862717464872993019906670729457438083279869852502398951441572,9263778898906682528709315203073828182663073896201474787696895934306219116039,4280018790033654530253273135477384827165889895493311470077828964783579313988,830995672310831856642518343627405480722960393571135174568745694822266602592,12314576340884680561277987296413286687270775984122709242612931854296075085360,17095784374018350334250759671947431499861842886424783004809423482855754115377,1870276341686143971262732849057691846357227120913088159474346497974038463590,13105414947588023527779026549450388391878972150198998416931943855651155797800,18101033009026370452679604491367700242633788731529564744613454397646795133212,19518878118392884244142849835491751668891129028130325012169949275103156284312,10048097099868399020473369161831917580618232227587941412911792567651718843249,13720988503976110065971074438615366180970893755318530444813194189426744566454,10206920761042395073417518236713913313307032364045319534823111708069826397746,18034670825630502903409981952109964720282628088881306395156166316305807778803,17265902307488235822005808880948915593987424296023174321440226533612013329935,9429365481099850064016032865663594803605999180077296169535937496741805848481,13186685927810765291293578499657740344232117785406437983769041709812502541933,8033401834359804746763731113146503141828920003868357417085510169143014612168,14829873372988191912376824090708426813704721449621613864198115299064092181833,18455257181054398358097306328798734574318231150508108527392947186444436439740,8119199559569330746396633117116309013908934582593556748077373019932279318500,1284108314616459045915004998457007728060914233392140668856369685125999999332,21852625948025981910963631951406283302114607467722317806583142816175293668265,14294796340840469579766310516350659401625921390409030932793069064155351769891,1783113620816999591947201004404230259494066685648885624939940386561651976668,20631226309571056417714477834545747594141696200863258945898766619654143617824,6903938062054591003542771080232078653298889568458433305746325082721608484955,8256881116864939888001716449324731552833717991541507741291129726788047573071,13687405621147199886679388919812090637070670174751017085656416653029285459311,3996906960213710686419471713152378445913261990655942335471489495797584984773,18609485914058202995712970621084391939086418713703752883448366703199989106805,4737790485362149715518348725962346663474900881645708435962411601476490671749,2822552925802124863166593828171280409095683790486058849977885272116463701928,10894109234909999803847798036461479359595641981247612273970502633226141682614,7246294570777241116302579516225659482637719855779307083700855528941826872713,9013198024264523556163293154624511496427558116561774530941327330691750043628,15151960056770776873319338589377108700463507419234056013408936730718825997019,13896307757522598026854039348754398062744662686124720657491498342048635150631,936098917227958663269717535799277732372546413929626514061262842640907378836,5762347306349503820330412402395950955095460299470544346332901816556543923381,9011672463961728692091882997147124758454879881989902775354620290305441817434,8298508790377315029478690089877957774356278876814712068800423484382883105746,18441738918640842202469737660313781809854248733890462980130113721522272925935,11674356714078179732189659380227960024612632400322071192164520398757529418670,21741531861742185590228910897294372846694047325677774428196013372184305103642,10726909710822683151420187237143914110905744739798587383554354069582246136039,14605794533892313551961292244462849563801666394421863533658628423573613615452,18252321089326369077368015604893296999452816437445326292408407276685442204248,16489511737082127400599277690755867907347415222776413612685047279770378853014,12335271216576477339942530570019671580774683415225712107993157387028894905764,4626127015007086021549442631728304324061443778286284381465764558652325702889,20204422163930758830873934092037602825061261159909688022442254278786267559979,5908008139766198991903649413759936674892226062609391695798412118889649830013,18949218162516421406624855541340518738013110700902674485216824630035967277648,7857158354961323527996104954036841386964344142685428573605787682122921808752,18862506387045373228977985979058776771998946696427211846227485792071994347569,21130307920872379374988363214010414716464915978170248808030666261671221223543,4313228149429751211745340097430041420420928800665815874510443032063502322102,14718887479978402714517595897896626933964355973039392802299204272000024809808,6557683321264859885031038170253446373377122179252187766556430383002360480784,17122476831292693338874176268140351589680349774087615644242938775777697017452,1742427015172593656128486448061422456944242303531295475988475807736737942042,2027235762831193006217486738647428392424417413253628143597055373587736173882,18820467606179165158872620834655197843967670286762404094202648563691406576741,10125524296683464483537740904779830909043887085914486254166411012113004643542,449309305485238804235855079592488366640797157061432847068620096879828248038,18174298857888178621780055946769726501913338858930582293820343672195281946232,6524685458133323533884653748284163312203275737781993034758692071803006590911,5779446108310889204396522202292098396120321905868746440329327547028173740638,12117601207346032264472777912492513317230650895345305236204051403325746076935,17386891799362994472985052445984141822367941805998642899269245566076967495748,9179366996073356039318771265789433069240332535719540885945532359919512410546,17951430600208154118507690771734790328820535928178248368783575740656844500941,14192271756367781523935569988212364655718978403224403387301537958961554173399,8221174165933793163901377098818684602634389528051583218569555199418881843300,619524678975534727395248661178123212036053322038080027161284774894885656968,6811391538547034359716390364062047260775039349151599816482953672829058524341,10339322550348888691122766885623110168053574406341544663827975995639398303045,834547622517043358034390288436661677632262995429052976763390684889069201500,4521430246419400790694482286290497928487157243703675820424059696776489816307,2856429439451475378239016597030439586695051951861405539943990631405466607827,4111906549409128541352401705521383327041723912730932911918947847640475304547,21238392279368838153073998702772069142756942255081903718049634748881681359750,8024413919212120225608654701439440497293912481641002166919294547045993866155,19638917754035941400580825054915831416618623037514650566052024405861982044782,6363298127640737755043533904928034878703559551572444680730376201407773738099,5951378579926778764731263132308899303911912211097125509228135617058018449106,4299191983632622048727922852687899517860127872286225781380066638217198421795,13147530014153459600370443470203975351218206668086180214214011567772265521187,8932462500427500118784677946351185252169486521981702322459979960456999825085,12898236202423618599592389067167172325929052486002381527830813712396261626227,11097514049007489440587570256998525432340163981998515135891661207289091581098,16939217257331433664860194883658557949066598882598231827843396489027582239493,13558314929316884214321653422030897165706985165664325794343497050086242614930,19068785933927002693740188802713137005358154768592984493993019480794959714772,16219047234078325455733500620647043268680743772219676241027699492382953851822,11566125486619880337971321232314420701391596877779136632592874470668332390604,20247803830618639726625840441081484205981495541890152476410337155981008644211,10982561928418184138823352638412764796110898816926174525705905870653768875109,13865455597687551061085338688013943905732507438297014744008229213490729171094,4623686187146061526075222395870304599606839445854872221666055672567414423759,1297323969860517810025547983969849541225259454470688019030850877270479215579,14722215188887952104786572716523684038024407798912988920497316253897978502603,6270780574886929570568937279666637132374218041131318249843841984676427785096,19252799885324088942740034016032302070594496616562387546044018090542659494091,18789886326443791197255838067795128702043473536108855579944353350374719120963,4004428942869607083699086726311786949460607919907288923307322356602295441411,2877506877897472797549134443444956093653579146599656174810841010891875571228,17100820986561348145097462952844272816935030845535472396118435485954197036467,1347748684215721199150368750223253727950390142032926135229664962610534785585,4154005697105794859947043472401749393077233408100643568245878899626874345951,20933456016305992700551258430315019036248529816811141758791937748005878705139,13670472427221544431486503737474464655536253995920989690199387492221273597238,4887586768965099882782231950154450807371608927535862225573402423957578253712,20873520765554306935202238707923195971241799663989834594965009759362455236319,835408880898587261190035308896108471998627156220026699783039947254106997118,1168560772528590466033559747490971813513190425644816736321133758228053063362,11336620716299236865855310989061343228509583886619209006261263862998075759368,12980812954661261543443724949390081395650693161075132555819949729859873154552,10084252406967656001546402499122907140953995723236718543311202294822930374906,1644532730355076490850165587814950390528959259229216666472798276024619697665,9132885938811460827145905853169583367514769405887568204387077749084430489477,2725900975136309543580364211869546121021875237274249313229081305044972484552,16649132526365476017376435851279563056385888284228253635122650167497125722498,12731917506454877589272897239554773638029036473865906141458475592969608419975,13594653727945200481903485136384279897657772670755085103508581365171774040719,113624989360858461940510511528457240403880397732971520793552365714387680115,7789436153009366426158912863312519977840172895511546817589361831513864987768,16143950714560148477045714466178426422461079160482754992311521791041688103078,1313437798365489562563299651704767522651128839986029835665434483203980839176,11252213995691856633725287186457035931029344732702134439407400361778220541650,17736157138183214282785525992210357080431726331346127883418866302441793685861,7180555369115773227093283745784562042441101566557650242391581159039035173198,12210449409908576791549312007483796989239766997007433768188337654528776461829,21645736522624670721457131423612680680560891552619001261475935027688037968464,5181231859976513481992166491356437447372643837921293039933901630631480168455,1822647984377309820943781894578040991064004363022862403681677456868041924061,18871375493748399832446064841374255973869421566131394074253151764055941485971,17104418810613244184376069439022653413672092602368197196666088607272531673120,21352793177578730013875622823471064860889253282644816974785905687738185801553,9232438288408252188083609458343687653050330220889343945216702072572457878290,10304159048240945355136802455474936548590756836618851032143486546904634881690,20884395191144673183897559585241012685606665510456998263218110825947409467914,2819516448715556874313717913942313640504691377816634987702668983716292161632,7032608084905515886212514778954491987158299018684745883187663518324250619807,7559036428305013706113865872782652760220550823937161831466421604635377603666,6166475941379369323404906159647871547076193215494151224037609592313271326716,16084803679651600781285997577643662084204923480676236051120275962952234677286,6658815199061181195201720843092877884603511322340036305618980989430727251871,11532335040368550811455379206918215244397070466594500713220916970398105300183,223243445248411375033016341241378810903532891138952541245228108341484828711,3833279990355432746436294779672706393587026552206068860301259597964955244359,20021860409670140006280261770552932742716715786145482153861376747693162890815,3960940475385499730462877864983553000107482077213680397288242993303568324972,15345391775733994458108231909936015494312151716517317512597014646307002937890,18277195779471824870812914706668217603589292191686932445872231693455894425796,12683998657212817923655738438553698764065257310760896868569072930043411914592,2381616850898069714423289625050293940364468416728632275660762167225224591308,17069254001556064617313013226218540738464402615134272312196301018778835133248,18389457738365086195717208767239120166429330517506018082718782715649157736034,5051258247116083013584227503078370155132486498229823799712010421955209135014,7997986980169935581373258514853533781209293632678320920663489466999553296266,9084231611273069170288134842362168520424117219722297893241580415854843050029,9612017102514059830687104062100896777017998502712927457146148255553769995330,9213917869163068338076473790268314749980273391311658654819685979854193078147,3968414534544698110694188177667553264094402034823447016934487565301236025995,13588240166210590726886944410340082403890007139576685347416857458181479170063,8425770643762906660570072207190993414304346471106950840911695090319487814275,1652806391920335323990555627698612547647520442841733871570123598479115999627,18130776043151518739068856550215769502964647168112043888178493846726550417660,19135684176515473484108881204420762325009779099777199113513850601885029049659,18523926306415003163998391622948236629256503699057039444767412461271077678701,14918281748682691271882204320979112338671695483566718123583225923120856316295,8780852767944315665594165432479024772720494001116664689088446074574987494813,12668508386943347180515022360355291044387148272127255261058463414454846963242,4925095646155669413280350202274427260281996843455607837164490899877054944846,2595801235413574965831438899756848851934934001108314616806171013774086568322,16016207465062828688275342866097975914741628027802243675066228993942777558633,15024416797683381415563755573423733835281624847950439607885361353822729812986,13470695612540254635863734898909669181168896043111281127113964919743317383261,16896649112088097145823038767205812267673142507502911459577638240816340032813,5645009976160313260833270091943535119457478455011072475922688828021639421410,602871159134715892643983949134724748180211299390344137568222174867411670803,16865933848430240952665445021880291168087114172384742393439371745277930120747,10638616947682848797128584610899807071800790542581123346366834113610995491100,15823119882352004895965266205059246906297215947121418230976223923682971872516,6335662959372125109139397987508104273775067107064186843021683240893850916670,9015302195224176847832179354591500534302983921972567063156768309852422127379,2916208839246568972516202976435804092919863447720049244313355052730101892832,12462097677706957512887764105458513125712391543206668564860335255817545411462,12645432056886268747459912808478608940565989560801243474226148714998374680219,3180920336675161838114354449885404230480750260525222632193238650778186030194,2765038069658052652090069059291472962961753315554068900506936144102952443412,5456153930594691794518876425254629839890061712982880399455001410106283524009,475588857464770407073340860667255085025964024669275489020055454066130988320,11604422213771358649337761367286746573670774367844043829963235653833716835011,21672531595983328080827235954964353440581013778240609331813180834517858151965,4158282767336475980124978163165153479336138216933325437750412278000398054990,6032343652765967766200639763117076693275022773598878447445516751911914770612,1408994971542022766817088410277637989937031937486427645416181643240579694602,5675369397167644827707774427966283386689036453227097867563588663607826158481,16553836408556819911384314376537283029998074714786222283151724244687848945589,11305817545614916257748042736988000193121142053044277161651567885557438654074,830935697282120891923075627410843569046784310505888414612692179620161520408,7111327705324010951262975966073430392141084274376586856008212260205185475707,6041014280799995292240499899142298082182090482839684923821947404991902712715,6861532079489296739625909197765090537384733717891476126939216899495278356435,19512767336722762932902171703888917915267449700217444230295060094846152793374,11362087145491820831916999481856548088963000118526088967383804499026380829346,5345785713105818128869449775136443413167434948951799284901802489769456439786,17034353050546517551433657764343123751855407033689772581554238132654775360523,20948587704598096549680941899688868509854524167514075706787714294359604474171,4994911941995400553330254818898448719600721576253446166237206475949959408151,9688152172628114951713346942216519356583583295750612146456768853572234580639,1343745797764784294443121474436370243518251011725658365765145682550385976553,14125032499992691719199426991191077310874247595141214711018898761632184485555,7693434862282992683488101124262547552730705787109948156284399632991566403920,358969526543359888045815665915036908949414956460937733680920722686744813444,10388303602140838746049100800433273910870825475060431768126678575590491651119,12003019672927505670536349874007900046436859031431459357691867861903891807068,100475008966885612365204906854412018822648141035087921833385587863034960276,4380976634270985228665957813264807511324931231158992383372104805973515660993,6796890817241810905532067210297629305992402701618394901609217064231507595098,7688772779168713577464553940881893522916379475003769246647902913600123216803,3719641128095581959416223705616297841752773711170097329183166123897200928969,5811339040244843745049016703193592081836868671814750017107506365287109556605,10595470132919677811136446867941153163237789139416696690218064678877242827885,13030722908918648575860840375066614839148197698661025042088986261543919080554,14270313844057453712442736904892342369114041625795108985761645871570953543978,20755955200977796735614094726104970512145122846293966132203844248531587786651,9582579815411229200777590264696860160165980649555432144848137253789895405534,4350662320089661964064338788392477540031840065706369837322029959874552780000,11294656075067466938178599864610454390092206885966775647004601601555888026051,18946972646213006149468901853070557711933198234858050136328420076856760929327,6183788518442229735210652665497651321434896307527846329693517674734369795163,4357012315121006561105620778754114894493832281520086713987988030701496525309,4220425144490786998849301484441980495606132822919030749888073325247349169938,14847262709636261703845309954203315918152776098063861666522433996841734492983,2207604061881398535333278399637137320820424466179707349350037157354962490429,10374520449793714488752224568044645973292278262497536584844249765683309087900,10046752763001031505421631811000499551831682948464981948135908582555522139635,10191830759680421095919984376117799343794470779618993576052513294297834150862,15076222662591944075232357720469485509899269012588377631779056491168825321779,10030346249770809877262359992756272056670319300684833869196768465826414079904,4720507975531560789365265597577186025064384475474978173798769571327267599028,17191621856092434134985786932980111138837305571579695662259528942970338620884,20148399372131987633026319910847242205929076170415419364579318442517450329463,18536741510173922435024204045457609239829288683624474544615917164289358647693,13631750264342742049519923217689863850040711017202360015936348405918551837067,15610854494548438731317902472235239790464071411103741562289565846725908998069,18387668285066173974072893371855420071639764562065930624890442086525580978084,14766673420520500288514312076124802867192062521660406237863986898959550205282,3732185864446238105520935485353063605521423641525603230547743875428671598696,6726861976047081116380559824755952195618930495454092484512720173680677582718,14230102015194545129058653592673168907799074203765469344837164009883877641547,923698051441061755360657704655014798009775419003226945193621553062258046271,9689434574353223411824004165283477169808920117596652474458537007050145695959,6653548670473374668472111797166160911158340899061222339537692495508721251614,3795538039750942962828904073106200577850807348658267681985654384336620251059,16992880538370345570685975897913090022139738512471371596260168908478239467806,2201111019550353407862043052634082471477202486461462021878536956251970423986,10288260758300652435946350416864664136108249309736639494191503136475372654927,15709483617520776431567199768118570957603227217270596124343406544848127051229,15072326085023560939831375504206736581668538451241556883193631319058350825383,12561979699882391671048614617301093740097194439650447103774288376923816448076,11578577676104716528266269909528660737784973170422409028333858070522660907599,4774024940257712349371248845501840009544530180895035663519273410524858053238,6492684254039247711120616647406430763803059236762636509335603649550553435616,20771468823570726361366818215861608649059576818091620623157713556101748134372,11770234809483645852438195876591109251904813195909801267796013610714277347278,10322220982623441869990996687272667519839773221084466704263092761447901512117,3873750796549479014998049182061589742243147534079044128452565125163635863792,16822068107147748367260830510353037256008422122115738671496285709779217814945,9894626898191884524351933214321095257519558205219922050393534754827614996074,14601192892171927905999982540260020693712306290426245380657926166256138073598,9507456803001734658737641235710642159379435011566715643921196640676158132603,17204767985326745166438450937743889339302038750836189001173941240117259581627,11493735704785585407432943012768068237407868899310349385901453142043105992145,20264601365705944529765978188292560353562052194559042151183990689436087045415,6396166643103201291451232462310280514789516631380296812005611744416636341945,6058445133237719937803819124490281802427048168421128127070586670707895911082,17832742609350217271111001369998668554917153176201832135065834598001176606174,8301910681660121964370976371283430908357731729231997961142961954342095329645,21200700180783276860226125147359033530111487784446376587831447494082008760372,1364486141742658225769231963526281625713690163326935801558529383187840699159,20160669267302086336804098028492246933121636960809421351182280337233197662342,3635162620064198915033858334726014494627531534027138539712906873727339940152,20185829971410353373403938384712968683319708682735072330111840928607967762630,201523690073703194002962504757428126542763652704293724447838128821998746350,9709386469732131146744455888595822333747765095732359649526137736669486544832,6214797208590500165345122859363723824928963832472111818012074756679462353515,9545179136572857559578932159310632305901168870225039498707457861463081350889,7958214991370581593237224161079745627463630298171564909746677637838740804837,10143975143960280812282386246733660505472918014880729933237691446362785576312,19887571710409013601609612720342170573208042935750400481652798519320490462147,4385901431531790517574018221866017216283585679251714390188554453215701245125,1664624586830909279573419685895566313699996183243836877427547144869129575305,15793134038802395204513915871355486670799044444942914383804421551073411566881,20470704207635104884647349860077097804311221255557839038451274311052027499926,6142526726838860239230170135812194898945683787933736938595250804972260353985,13855192186192101570267811921410903075943095341965742420598451678343592386178,21061758735696246985536203700046768078820850320825204373370639318620908053680,5662817483820503797666808429029051672943117302178352551614788456216271483237,10333519634297417737172450445440333857302089078097476871967805971949123871529,8218569982501149814702324407474792474686368395700170296571212557818282461359,20233400137285640555195780437569385053497789288081872387339896466294226099158,10072372834150094335098617649200237176564672558260325152023334458902878530776,9266800412877476308026297272156162694485705323044163059710847355278349659379,5276337117659173276438760052296857124207008171563166875174912047683077401125,2006436301001583347899849869571017812498189722949517889639315185888688453745,21001242218121797019239763758294108685115914209711313091446808028690842184156,15200074016374430224281445993551091543367930754541238817021042732526880610544,19710826528876999823124699885521051879572010811534557471867248186884736123929,21404362987802009741223312847298906544768900296657310719715972255986007016585,7600530036229891939971232581797836974827849142680304648314541550980439417795,21632454463616985503979878539576013805183337895553881618120668190150301665261,6334758595723856085036854188165101506598081801208405745986881361560891199193,8057222251861033664666134852961391247267479839150238989503146436301385103200,3219721852432286392418844864881031568045047266727931843416507933961433025545,15429997317679838542619650717630685653076454689042566593207301547187192181410,329174031237742757022307048272693803097641581155976690924186132266202912753,21732746139483704151357074738923965870601454140619898689390165872304758524581,12807082000874685484816248695921308340943213652025179667821051958845707861874,16064026146032729000070008033632737632876654216683451632905581465015365908257,4212217153278443796283906098959531995688364954974810176542537190766858609818,21143229289970553639173591837823586981543332391397328546878889800049585920625,16608191574158019592113901126750079565651977188938492362618874182536574927398,3624421885419003645925287958934125046517213705659854889615838255824651468218,19316501828231774431815118527212477451661840620435061360743197812130426231605,7662891999266634580053960517366506438335835205004858023405036760628949585740,16083409929948531376998108923041427957606534473459279085237388567102877584234,13084239861882397209044914415955882241492175271640738785828432132564815850793,18210156525345343590423422394059177051429214768712959878778772626339164549874,12315464041324428320313158873511378501430493994363943547122434404767709664853,8954605304811330146055184939317681861245665333018873540562258152334326318605,17293224339343743174562117843833611404589728024045173960633854068798646969854,12077428955835955218060944701333382577662880272982277398053344529073555194830,7126046228531607392073289758329125358329379287853920330519927955077178144953,18588044234272060286987286081803360761513524944191766041826466047510554640918,20890448514466943340126201065304171306189507157689256667534257974304306634091,6801003349507087476371788107799511762780253146305342273491215439215969413940,3780619510354109448305575837112860323918556596060836509041441555683227828678,8767334354313558924867811651574408725653000725545478833889044301516199439630,21066572358677074507410523123848261256731407535120503516033231013762098795269,18362039042064137510549303809539961459419339855353944845069477034687076489851,8913523920256755688178316396983509800293437764919338700779034854771483564854,11723401432613346160205532396432709544892024270048469362382924649893252868073,13215697753311268652932970590975269015978051881025604765698398517094385751294,10096875802507022627888049762027565166660383010058121573194339315127497644823,20585340774134656767573027722172296226739825364200221949739798500696627689159,10445154974790139558211972190334915738383718443406895551366524953208899973439,21673116720904254079937605482525822519756033862602805679958950491098633276310,8625969092860470813380520419082444422545844964279894335272441710185243798934,4025288875907887520103326512414690750293134922246866469493778161136380894049,14323499257030290650454481578106573336673758956871892054979745929234879010775,4477626471847050821212591107628903165841822822191648560679737237549532746098,6035678895480961290473069135353807694173152744259585744720200702817852056059,13087537929005319145430419950489154179166101298384003566794942619862071759110,15034538492744821867836124336381708186593112293438604485661643830336837149153,8805139564894882006885168301537536158944953788019925854273090624783308357258,19958581387726270611337524069699729934757503443234146496516617463929755531372,18594586877352581063978277344172832910008313781358399221576815775414535759101,20126420557250610569978010728469817957691099256920991551072367148797364737827,12608220343122929299383466116607513455913710378844501818574872277345002049133,7472029840435729707246144983643315764441672074448478483499047549570431985698,9145534859649655987690711448922451001707059796425112511085875363972462746054,14833791973699407961392823324214593517418186311389016446279089810253909982772,5890565022258491346280610728283677536409667465411457717498759331136098626193,6036941096143250281821883413338948223454138251490770618188682101941802166158,21282043678033183106352077009071810571452663281954166213888935238324321673748,20333804372144772829649652869275200527604963503726633269029046116798625871599,588131164750999180590569033490334261814498911261696634224331209454245047082,6825251444721740074952317618082720927334521807162055931163012547596328197449,917697824543986394290655655205290161739195186499427989467675782006019774097,15041830455925245428849291972925354368991606611607025955853683450026323915411,18474239974098280549955893651580150846097530768719853315252027744284466692200,3611784158748153035104121136455977264222066374809674800505557964617331443457,20604659450393945231663570065906647078596881678092078709858521111095167311757,12029452301550033145724326108003255082656089254479215038003174967331098163936,15356676148621236051968257733981998213914051180019702757440018429006515803587,9423362269266211501814985604120446961293044110825100766698681717935266136618,15899728330782424719479421593102373102438201721567285551304437858855478298992,19106020154064303782722594063821106692950347246115176981502414167189733529368,18908465093637028691441981127932774442154173676388632144231302290143899401470,14007866203893293106212925571168282959988090650409909185874688109550330526342,5342742216767912627176491444663860490435717482395442556665323768598286007506,3597106827456013501397704575480537495681742041904755766922490829038770978602,19345954862705630389044258042054882168728404897041130532396992253851595567599,13651761202893618441816264801125692678934609890284167560926428043317180108703,16448172308101926626190311626973854215995348130429072972101942893358814042334,13856649049195496934480457183055513754814884703875171340785294070612325977764,2593658379576055879381789234288074898757591156526450196693707683508079496462,12697568363447920404231218962893478531573733618972364303216707079428387821529,10578645587798138343532931014102095372709438567484299904261443385326645475306,9492492460728662705158180596118275120458955222134204696298182307017420905508,18064023256112871749609279367679203109309609541901431681842430343172099602354,1989944422169611668560419735240024090899518972063746001231995750158992709746,19903230879435744155012664241474498197586597172440005182506995303093565641777,1728511243862152479724441453437511013527085523030423049007411340644871969509,1750200860549110325737825369011951368084185262869489413254703181129282667828,8859957468047988361338455823958226995655820770262073750796277641227321341998,19127783638542055071733839851815229696558338746338070032734486927449049698521,7078877955496438548183194474726026189811269821062629263278508622456589680639,3091324818623570240229136118759236075549426086908228304466341498471627762399,14195346783292343393569267444162421134560117165562018311694222203790784872224,7366930408724527902650425878366319531313526362168392830194685421619273052822,2217598702761121052299380093973147900304006951260118283287015270774119856107,16027808241528674736324615318588531063352235936452195394658431080548186455840,9737799828204615060867766665537725835381601825573025977613959705161843611093,8064501393540602388259218046920616332801811052858376733153856073004571475196,16842422805430821078995618361206787780503480464556310995070028960079907202166,11112062472802799468234830097050518793604563281810316763737206541428998286081,3996143098194824093843968965659132847407504849137530967999278126450907191255,6307499143062236655628471047117923013144505466650278288900215043429516667827,13925586587992763438435497293527949989397459231522640308463502932206077961500,13087452945182453051277972085750711303320428980713041081211383304385877763691,18093207370226721487749634577199906992299418255969574006908138736154443387826,14272048411789712231464337625432600879032064592923947963806042930999866142049,5112973508688401012277318169584325529641020499005098236869086381676918059371,15127813438826152618698293752642344087924814601034550461410899877754994198299,6969695649962440087033894050377257471647257275605050327543911409064993144574,6755033946723836072389613036793975461823169166252828563832361834388266522342,6630309846049050707531890910192358661458908514573775713066783149977348075866,19770918646745678079472470109308561511682083548143260940369403377403283034557,21433670531093667302664653834628387344084043216006808509497422477800438816334,20400712430451351419962326556923150417233487338363092310732550512855900177990,9914702749825526925254257687000920413318621895298404563035360292451257098124,18640006733688503648022700222053193091432820833842731658823766601630552120045,15001143407594668782401370718438100322710708950874705625981291998887962398836,6239670443845313966789296359213657096108058977356600364820415786936148776478,6433425223024186602967246363501689243341949458306873394092764835636608100956,4675918067976678709774913862522295500806856576135412363070396552169178386308,1601751749870408670839362316137379218159388455643443723425257645986433854434,13458041123361531838745263080315252882353509187267791623642428828275334206638,14471699013899259577738777309533960354293333303365529990782321200494073324178,20280430398960027135010448240285550337237252858424335652593355698129656795752,15301671314764260006262782923235826735016067425075232061024349010859210176138,8527420415370243636986575303113397012724035052720519440118106033441076019119,3475125085974928986675306749785419160190213748540322213576708845513558192234,9006980194944928107206620529900294492273459999862240882500316250867368209534,18341113199274904243447557429147408702772610985345439625451614852727142466679,641303854841744162878167226844505402377828908784963225549380412498130669293,12717068536550964634894133707393353175533641253913906785707227145457684209533,4743152264042462778433711542894756531279965736412696362852105777475691147133,12538011691198347241319721961633309700824171196141123297965193643240835576405,20609816220088637782952524444771775704801169004700347625707989982325840582078,5706720205331708334089980420369782946367580993809969730038974418250776704373,13670952207260779576827977242585356546757059123105172869720468020067882252702,14767430839071230390516499921530329576551075490453331584132978354378461913602,13855121278897572089789093806573448194721330823581341784260637700156610112500,9029464346382645337824607466955710618425900404147532427117006888589723750841,1522014999882036268928376276435422913665212355063956230967744832498304066925,8291362624704304963260873050727236420693946064959013721544766852407674345583,13589063181500587026605394799486087482543530017803239994475549538732438667645,13329949252386676079710645426263377053183751810973538969788279784055444085091,12386680681590613307772862225908657100001403625719832791304530216719729923003,7313059443635334631417408104276385788845981785748211548782869561833456731323,20041885136971069417608157269779303040508951822068411540615824115716811017904,6497376869042504752008054895287149835408180730990917088183191265348284326357,11125724561218240201117500197186012921479012541837342663628667709300377769139,19153359808996709649541642396803885814514927865816858283729145733607372609049,20152572433538554395328147373104228881714506304708579989936661727209606561409,20016439558639474267285355593250644884337484988031314831332037478976434317958,7527238505813249238885718653381005755459117986453125478349742303052560976989,18157976047185465548629298047288220777638494790360987385974875362640599836871,12215475598068312355286440209098941716275384959997573662132780937926913300161,19661498481048830903134453807971238540013636804700867840177613880955309016673,16552339415724980921932277403793066165528259484794112971750640492538556458696,18694143444126088750994041983752049518157493949000498621268553485531912882317,3713967579039675465490867111467075244841382142654006118952820645091137343179,18003791572957152311824638498878311682370695010264579557670846595111585019742,12786965212577099174577804313633357821910340940882518052929431837084369088642,19196303109560878004701565248872597636081713248916827960361832879728708100252,13503920737086542355495290621258674491187655992864087131383678759555676293479,11236070378728091455898747203990505205014449224981497050563648348504784872625,9626632821060958086537183012642203130268418644318548991569123722985663518084,13034637881184844942276438495251249937482750510182566475651230823087848537016,1332579251268852603948763724532278782861309157968811258504214239247723497919,4440487054089857105584789445239911365602192945489433191329897791642671641022,6061652828396333618822938589797622370923339089332057787863230635686741988906,20443625886285957158375952392918402164453450517610142032850159380049279019890,4971727988681610479349722318571442785499756930724120997617079739694258077982,18834174333023112536455562602096071615163100988222060601738058925300216483554,1418358707619290124642186511810240322979679442148132663647788839527968980321,9146563693745266063334532013679253366507504975079644933043489415067653903203,10198203189192787713857436708411760529883983417357336104059303759507359385362,13457105298809247477659188594503481428440666731107167805254859937557834208828,17541364687047908905500996158296679129819772711555398152345796866338919060112,20692063470613585148684100931411467587781915529223705941251811918651910411051,255059205539662129885859108675295842232143503986252525395037544865412535350,12717171726844166947240066436059787676718930218202178144871226850052045252628,11844159733516000729567466032644347431569093736490287481873540624836993897027,11002794037358979127166193862990494036532493412598623614028528989937231393875,74143635505641635571137692594773070124419429312664778822553090280375104361,7056329304173643667817989532223449288690091032171349984912618184745639839146,18641921263165235968711057500989010664480104039807002554029677125998810936539,19559632820551845243777081617723524038257569278710484296878486836843940297771,20335178684657665532201643783226288715290471620876336715869115375508863124376,1400810679146237783184309652518065868576549410755675655514372408922313217181,4901107318137271229016627403293875571324832946427895930672961592355892796524,5432919409806696890084817096600220639163358481346859637851564223110298016918,7553857716186244958951458648858814979749280269320630962042771757992327513590,10889701053782808013047326782283414392744894366555627960860238324337962809504,10225055313049541990073049693496605844127702734102449597528239569584063842673,3178201789995579607967020188792297279206559603024986232709441132816492873170,6847656471793158091195364320441056206778429470543211654532315995128613054310,12528583474708786099486823217911492959125739967840882229222854187982855300696,18467266119817551899238434875437425808022051394845724810256998883759435014686,17038264911128891077018547486438046001433165723713308233430847345626729200927,17955218916742955831569749120296633004126823963586826720707041154002710061824,7211241300282304354221867200910811631523632613327223837945134059614958044309,3903314564827641199204912578257298318982395101598969445634590319788688787892,5807166989004370646148664081075213577472290526426314941919217927313093625705,7286215868775919967580841436085988310805057373157718787975640918960675793864,1250176112708058341117534856693109443612022505613546634776485361294747168622,16240306074762036443870399577875028338427695244117010393369806321281281115890,15136410716022250493730454911117704953380153308032786787731835907574927894490,12835091061815802274496704101037812141879397401714459083078081237987781157602,9740091907879287748866588073726349058132835900960520906530105112062664428632,15914692134543071914048151066306389736053927516189539093172532429297748396169,981367411385768085119476192577825808403597700860420619441932576179905250934,8146729957224132449602418119478334118295844780357577983658167000941734233326,590349410629703152398401018217258970865749864711821880028353966569788201764,1825395473256187220041087977011184605194426952605089376835233620262931194993,7123515738169356759148725471278134181610254795201025187792320024480691382570,17726785796913877143757425784904469412799726913909454284181133920507167220504,11651205611193223879329620496932918885123654427491270580240367578782038527170,7363492115511936228845261039013774575631247230570693094937015313770023603570,12933273009260754826631125313953911983930122727552157672205237418903525642215,4587914992471995247205971137457571771256946895956563575187244174461900917940,10792746122808647351065474080470836119851772052088452562229191086431179404978,20854485826587742461285159604615271614646978291370447131740817759213177014870,7837325030066353684135714390699866228186086140255598480265046489057880448954,6126605304840233971990826423459339578353618021565536707601222973624714560789,9552503931384803960142614388346661043921110897228435044165354206374121160883,21548322368276531554717543098918449676251611754505041151177909568762524391378,18180071753020516412865055548290459200005267908156340472690024449103604081545,19794881883035632088168728687250887611858393833912902865301935760311201163703,12697056234954492550471667283339416001528754790033934829512770385731960713685,18997188462081688420104936253788181208943789361069483606382840563484861418437,13583525090048988441168973253797491422796978202781056749054729098883924623495,19314654753949754551488116156913608959581776089474885903850748881648064831000,15181859580303507964634708303997342165949140724201743603210372837522352052588,1716462370658876925282526879979978257325560447381441363811430134855582914078,8712634103130722740728459133380535370865755065924597276965974996780521350960,9765286726648838325814219419835139491993130621932376855733750920135287306908,19656947946994771960907781244127562602401277628142459052853670194718812445557,19486837510931007596539998551154014974137134735704825357816939421451262185625,21628438018144169767837932394788626973405404712219671990762156320628259145217,3756950750264795710121609861402232041406397600142239597456522141772347776528,17539873562638205978340064500452614593864489286304276949397837992418594034919,31501567535731664761828271772320938243617735864979347171792246363428922702,20352331732176385362929127748957145775981304217223745596870640808444167485233,11226695452056490225554147366326688917799653401898260586559601210633144658136,11279669284613566548129429232553360604072423151872075897074160621145515173607,18292000567925132069216498991188575797602397842406377969706321176845302551280,17394537715319668724138949078062966852069669620345676386188677668125466782838,1758531732991926253426465239898570102024009352558916489602014827893071642025,10665213752467842898072683993424618781459586563812993734884914172018996230127,8324794334508227576619756931916312729743681044831168054976090310260143855664,6775442988166121274859488523805155937302608291295720635827623408019663108145,18295585939863028658565671525942083548149809167848494003118620027469243247255,12098041580596728911973293152187391806099106269046962124832995425376587592750,4179756701368801644640767039230959196272720402682759516084041748778250510583,16793512481702225401381949294778305375341554886405623120613660547710034551886,4048682207452656355407948755890074205160404299490847582459375283758637453365,1909268909139397440485048370655601811806256012192941212480683118923705439669,3957160465110711873678443805553768764193925226448354732024034759529771356073,19248605214573594176390251265821595013690814611654024253657271349217548577373,13868854211319335141393401333112190211632180475309484073606978199113030773403,18603198177495186944736198329095228547417364118472010561530819889899131849965,14961608796326843943228062129500114917120869339277918579779470648489101516583,1868951368661473960034964936590962790214375788389753455318330338723533775732,10905586386180037341368454391941851073795645267274288454955833628477189437397,14954127679800529819463733123869358237687206843820983026443645382142721727317,100097327222806530673180018653982439008319453432490738486899052539918122124,12805546034879808469495394895280673159114129337420886322224562831326122327785,14806980879080756440413940765209361196073245400503251970584575890653655885707,11244087337738788153622356037614703414595488262581651455100475566242231927775,18570222240753995928776550172488765352849447095675359684346868515783858763055,8341186767195379582987673341587963265518616797937499770780867790468554256976,16417432689254526830515766295056137071443518160358174458760640472715479776587,16841713253514960386433216886097940412703740575768017997853214356595383383598,14194887769957144867963380965988802472719946120213216012427494993012946567028,11529543378722012166333054004374317420377342192547947476057235546295927556027,6228288822288755015903485852969606389475962987032899088796179982251184963398,7936701363023944576389877378554772776727492414245244625252565794409904100031,15001498940712434912521276724772034272928752268882108797824422534795904619598,8473716056033059546731002019964120133827043541589774095605930332153697155158,13622250811616358253729853546023741257702106070523773564774458974873057917325,365025468139420802765331768400644334625920629446545823780682161731304140845,15188301566744221387195339021364877229016833910188161414607699674936046087814,15485783106434451702559510093123052549288846753530302451778527951586674987922,16738591797575541545215307991580378005049794467812864864257667302719418546088,20925739023580534811148616300343740428924012857265956692833219002712597286911,14889383841375932440118953385212403650477118619024418302909728838111026909639,16907126208352189929083708812165010150781216847422378013750129578871272492354,14806337329187045580963626107721698864963698880842972656340333617747451702084,18421538430347165869364634373319132341572867349320823968976066555816366184444,2434665826886017086044423893890240566257398976888986717506547657107156268130,4107084864210868857776853415457685723648054900688044144581857773829680966286,9975696437638488842544898875508262421180359453753428380941136617917797565651,4271657746853939228219168189957401961257189278944783942462379137544482211389,6197095881644784733476508213210037292053663537272178396466755799876037787454,17213367299854554180584426411972899951945067477706586927352113350447914118348,459213126097844409580498104618008133837044548373643874721876534610892189686,11543212578280368772068695265607222577889093375221336525779600349460584250291,6403298899310300874478654413460079479003477532791552465502800475489780616607,9679879153779101961935393514698788441597495345714510688032433497970373876200,13406313792037016685976311954559553063553089970578743589839464948184425020319,18447061183141116334003130470774130153225311547501637266696790170481921881877,8380490825353548292894683756629385493171585978110314915970595197861650821468,17748778220767931278266669246252235981422317813726374848817938354712043425250,6989443852838917282085440504075239616539844445576232297589557657622451430824,7831657729066776489302369169030303662771324770284845700052063314128105065459,3925294941359174220766529276974428294409483857727579665373968233976340302182,11937917292063962829330707841648838486196775641195800632090436249316243167473,5653419633240940595644007985875227652581749358539968324306529520430709397246,4710671638294627998538116427765044043262338916893456876128991289569569324348,71394869385825610742630406624465024289788832054180269745498390791493509963,14738615985593994376179875742690333041302941042023229128451420345640432224466,19352351801479363044593690690009745314348194116715421753626607893015433391861,7828134540699329284695760683671979636145431779072416908240193138816504514982,21767328407325385326066972839469738803639297445302836419167176746643393964398,4363185783182535592354777041764733165968243966270266866378133278599205816107,12861900092547198665663242905083918119082751367916515401033164113207531942792,26199715195773805806030726371679979491296157888969354080702618784507347327,11422842882875515086151723214834881230789142279246505109137919711737652087050,19051762302341786952522177542948673906514656868374502102797859778503069987555,15304419135175746829806105353267450572438302765436283477928256874309497427510,15459263896362250252603436487314027681146892842462223021544635764438917687246,8022722450368098005612162808615173120915189731064159685566153653273958491689,9933514811147109956084664025371824141534792260321581906034445537159964992688,13658822996647839872436185744737341749492205026854185105317636224609004876375,14379624233209822191260559290771588358188218543089774948098229868966603288924,14958992313261503520770373701642009455846990471215730792533739030356906680013,3008264124109355458910031641850139041159853342729069847393839537381972950880,19920038730043462715603813734444323019432755215636179923851277692610637123174,17230906594400326225968287949357928337332875589057677202822764136401667097576,3295851897757873055813703602696670024935942454512523388333117755329662151138,18768678356443319065659286382395610390856779982946155969362775884999359596659,12460586127165955570640740026112067337902936125125513451212701690418329829958,11058259665604247832957658651506896706861484197660414347806317812760432481190,4480738127714472007170345890289828985073762836671874831610164101698497828459,20356672216023774813369271811683185179666462848912908217024611254147608738543,14909200607508800723484308159953932832836734953149954532962622450689109093081,9061041843468229886389838095513813426084716371809563990186852970500432288083,13877210447577198749973239837374936528445414390167357430100753821987322195433,2839635391670662085450211408709683689698694308308101424896263880864913513894,446790459594546823193048947973948688374393610819268956164912891701746906791,15513394297485200475424313247005293190116598898090270540649465364671255026149,6430544300458423909335482367339522552006494240640365398487065900428380674587,167620735842959596421416387102879695919480795342009064535989276983300514975,7851629689216713462310956055612887013872895546158054432042649792702892211944,6972603886636382162328373670318167574093559853635999968924151410796861460213,19413944499150555955013296242054320685906330193520693124525832782341915610104,12263527706889748735493918123122221596983902069097405802497958581677957096038,12724987466750360537318099905062339029588038359925927031456282032606443592484,9708897601683631082524518294366690107466919479336384437075715215088985624241,5574496517333770677326807465934080003942242224011251056548046091202080747952,4426233947499799157064891373345188337862104712594055992042177154581455374210,3323616387049914826284182817146044206680302487334156840960948301224727078983,13004254604656434940963009501076991894817629784556574456240824509876544606284,7301157702835275823143922645275544869236677259284614641634323459896004519527,18085948818621221598774302236513376768745135801526414290158313790799455691975,15187850571325688566534378765892972581891242830408971491252049503437712864152,1246313402425855943486273052355580345666640430821848725745627960892819218740,8647394846748193532697036206738902082890058434940110730560542269988727795912,10064655809228901737773717896104022245084200167358447082271876992404069509689,11849936299337845059630533008021049942767799074160683892846518986534992566533,17222503330227123082665055850287821041983218187459530901865330120583332963245,13182290359799776528759669559625168410983932493170206108456280901111876076502,16922308846046171347608544335458702314243928203269931669473214292617484140503,7558805163644194610710740916145749972491144028571940176012011742150030513578,19569775351485108268007779638227959360722563519500120339858146797114197471682,11059423706111256170971735544260170713544645580527143674901672982061741530101,14932750633257527497920398771292456029356930315768552640257901217840963910603,3437896142924792262479946438539259423504563537021031548773393821349707014872,14782805101152549038431586973278748014002447400847124060642259960939628565044,19682001999640336579725059393603666122104885151774112167088565361216155864092,4233558995266469322360257198354042357488781625226686110373130567271844168385,4047511689246902987779521780711143086427724115291088073014684434358317932158,13856430748589477860039479213633534029749590309123560510004500567115861827367,5679747763871928801801426015291106236767446876847749477902392536633742028903,2480123750122829773963967496725275864472046134363280592972001159541781284867,3193376214066985989527250356837102042223952356102254301113166141443841024511,8062756153672663466999843325461563174537500405375937887043564985230465866772,20934273497132536703003386629581299436206618333301538059074736379428757199398,3964142000339408965627671968349646710437601305543271274636785761452376263382,17659047756049778260030257809618419752271933594271518827815853540916989127582,3930343349615664221386794926953117177573248229077177174315534154624751347076,2895341264817391965072938270159088942930942041694844772295944189135688863196,20818043348799096204572140288297522915577162783223193328931006646915252532953,2323581855503968054101786162741712103392782241966098143187644164748998373979,21506950445835751487883729097676565482258136522526260378635240810473639421131,15652663761688777314836638604018575636259220826467294056546736904699739444415,7055942973426557227578535789272026034619140718369524980726263182702440802766,4949575918974841751734514119081067078445927926837555007268000255590820633720,1398399621038450203083960309132739969264364773648996881599178794373813964423,15732506799197618296258053128654220838812930643001991164136863850944185860296,7794835596508268056707656540537636605902268233816181487738953353424162592877,19334780957038992630028385332334147629399375592719839985802296503565556738324,21635034093671076768880953665214862813027411650977124864184274112296716574632,10688534301651495143056852052149424865722511689194196231759927113549978532269,976280778878149721615236526300424224199708100054560296745736876703945737879,1661236337347680899528966953581439111854379099437324147973193626090712244045,376684649999303144466214973033408609742031466036082108742020038605665915381,4455377013377822379614998251281676782235647079572422444530523356359416320717,19050227778954804843017265242388770579299436899390433258601701002663268793950,20176738847900667540339144241305449384029623393968373234965844794399275414945,6563336600400724498009526486444642892816244088883489205001024055715188696046,1774742053125969896553337470644410955775448576794083561882186570750312466523,4720344938456070076793371724100707050168913253766155392188169516296487837219,12386484928350266729292976320659720907387619673269670145583838638028478942370,16511156064543308562970376025636430728255148453048880933972883964686852788569,20161060548546289109867983393573712303980348945862267966490524939511877278515,15745678416495620522776570951840736496696200297848371457414809276602866061937,4371269787269411959190919691547618186773560770535442840395153562222650962400,9183286542027774648383851710226269089477011745654659545146528858483988667073,6831030131135399650979313302695351819580359371445002328037898607795789751628,13808316624446561665670975675845412570522644424965154154503596711464812129094,16573850887526809906244420164574513771138034770054149931125695105829690192839,6536774143914522904090235450413350153861560318210355846585220439397199352760,7433401028165144185448409996814186253264882020047922839648723974949988749262,12023679188187515805015064799648457297092902074185758947196154639017034370941,11526239531876823273618354625960431640864995247037473959040869772406787371745,9965606134640358953439667616539308986324141554480312185321082780157059913160,3745993460581557715489390110730324720335274000085036229679909083358071037494,9383224303353982312273937680493563948228572509816601479265308820357851069284,1487827268845002359294235769079867448539095616058866371843794273898817464325,12752425410737476015270360130920506733622111261208379938979967899453342006543,8485480321269023262044616550897625372838041041299338618725089063696829309383,12576415359894007789769349543504370901641305511107563487651205088993508989632,21051289172896982928450490300579871201387152257916628019163266526462496896736,15867382033370376377605746630898769390447074387330276410404020451043720395429,19175636645506837972748760370147539503389959528500852183571848133179892449157,18562815464677471696203191443459870050160752363485379734113024945295929018010,10670914301723557472895334516073215554660627986142935452136687134270343499283,15711527071984806338686904487656233279759984782956970430068615997429454331060,8708497335606838864375996732302168404094513852034309829472484268061328157580,4188819471869628756655847772489988754984005896205326092058226221066145721122,6512127543122355053584585699891817324589817660150620823656474181624359941201,485283184789889690494624068272585257719678055879291431306025716514618916201,12469998319178098719636931437231251055837496888416524814745527432538031712785,1296020106178851400649855820617531046666668928599018437234450345456859444266,10011446468770184926016968173857732818096269728811257796162165899021103326404,21669153150071610384945525175896288044525929994331131233225247540220566590451,20224127309865911841696813826362911446819981503618978937382553360215894705096,11995994988481623386912855165099904216709109375061333173068533008232786187218,9410915142880940758336239494539529470909530692135279575732428340046078892946,540343796196110456420764600417592095932817965626261174892651237721778500283,13684306082150121243464309606855998092353075421168995445316517423697818489078,20162825761581699251737493230139692067729837621407892263730870777826880180708,5352686262532923758786328475456237662420216644156835779261605606151509572690,14736042040902670309572407869335525984156459843045648740121852458089457172710,15139196852186360494919007897486360521240977399849539996614669434222882428974,15545525411887550591483485994597179301368938856348279539852576272926020931130,11742635236612776978185392287408975566560283293946133146948657681925156152641,15933911044011218543142885674144914931062698638612248403425430247045038884929,11224528638969252327238392070525091272297579382723799722332333037066879094771,10619901685741876140226157641208788563882472537632692937793306998778377039845,735284898318336599638540292516453331642892791568249331436388578312138627149,12167882615164420400306427908818494367178873976878804005748498778042330871045,963476496798286039732969224933550470500612316061831761002103352026702296408,10589214229258115348033093903975219788029199245856576715398082842145004049938,21557152519616203688970824263287584036198859167308821872261472006356046725775,573869759526051245236872936984426432239686428333700586079723439581218874054,9487380087795664760223154980070289042545005448274508346993861027000032902237,15336219129184315874932697305233742095099896250996970622669888209373427981768,18404646237880969912286263998117686518695361809473583072241508209656556652987,11799938531163685220849832019747758716514224719376128562353011229084757783628,16344281677414470708413218213072185241641469290932113189992078158350700334823,13411067297619308137174262243170594092291209705703155674514006442224279302094,347096376483719141995221552155578565668868956459941108952060114777596679497,21711034316629345478518202673372708169627878437940325626238942704003376069559,18882050099612599842940192045274010067786778900079004241849918566254608017530,5764257238170917062706360501552002326820365975520365982521494644422134554879,15701229555594307124251301047127236083745198814231032790649389796695363681317,19380342180431843316217793484208165905833096992510614135124089140124740832734,5309407894979098314097225178362235237148427064335413702368413584568729847810,19819307748431076945425543888401840319829139172119377623119035071741874422686,20514761050842041997240240118048816505140382250318444479066954659053422537618,1344402086478653057873064952452423683387555289301580402150577440089615404706,16697255135945674012509919105064086681485448643989533271078867487484115301326,4621832835239804428359762201398927678345509964776233571546153039277467113103,3806403786653298341904285490244574263470519864399252904304315511448068846106,19829858960657679259830225387994355131769725454664502533894857362311545270016,14331370957097049770140547885384829422939088321033246508644491038102571773100,17602213870111183187455849162801944225604239824059691632957781727843794239813,13431951289066965496411295925849182623784324208488725900281691974104907065599,16717461480909222952301202387848079129664321734166452456973177865963036285419,5335304795187086185403562863303763030150108130150704291401586263249269328606,12084224077193103457678419187386990486069302392148214780322095375978824542075,16562074867094659170642419054272949287052074902139533680078784684856883275478,5593185214695460463728593774938986800789091570195563391333689785627694694435,20794081973744988874029976307272029218401016626938878812907621515041534590160,15290613354786940528909115982493729676786892068577902693057827852601851859953,12549551509495378488198674258192692896591847320322918116198744545244343099813,16172760618549958023639071988927160267123900859890153325976796899698706870529,21355970775695686114097146789571025790146162225961276367865670606869296144640,6758388446832091660422761046124378827605916325205674642673860154638138778023,14106404069959859167123546389809591376301394503370836987998148793984105405167,9246221316655556670219438263600949328330249756179668376432941216174575243170,17439153852461693097676073072037755599321185173017314957734642307684740219597,8081777382362242695298005068719699951526876053236775057946263871745968444089,5955062815471620144467538738332476050500085920379711183343040972831100802372,7135549743533376618652729621156592228493633259664287822661943632128030927327,6448789306286809743113676641229641365524354356867853498363388856986312333060,3836133206442752775823759632522089911744536837043185745585363415112795166600,8306967267195429229901513132397768469414281874455321140328179401973148164445,14279081291461540920232629360665447603436685365844514491245275283801357455033,18801535274021869273717064373621101183756544015062966551566128881569524508060,1290309525505162730469471418279301124342110934722264762505649909318202025429,3684482296351796270499952631629720483486993312250657634474107248508746062899,13174517099719760880623841117042663715711430443825712743356469456554740491052,12367323038661460523248093127080567074978912019587769246568174104058982359108,5328098381011440170293483375144450438184897394389341853376147620924621832373,12027556664769952184858265393953265399418219730267455116938121684665358512140,5729732888348277625941886883620484887709258694699060380279441089816970092500,4021085134780294168590418396176917282024838594185209785357282466818023080991,17212964584402772629081731052343755101208077509065176631705574779383125014657,20917432005010641713392920477403385909781374146458276502002720501978360592707,15295563898035514774486916635776497660635050791955975586488426545424778559212,1359821178683766445655942489230783986383452848368510940932965034076334706033,8110406013405532283463947127567634123149268608919736912581466809002624991926,827196241038734359771319428856617658913932049877272548875698342240161957065,3791462512735380195191512407306530846222290938359064542531485381855595890578,11406017533405938491480863229977030648871769070115386849200353035840595881771,520670302347263967262738466276891414776779776742458165836379179429124641366,2448606803226047006259184225386977543879941109635656602752172963011710994490,7191227529515483786577983572625758056228282372415415309332838080598142611412,3307446417204024568218448979093609311776086880103323372856728466529459088211,3813554883592508538818724202670630447381185344079357801330890767369937578758,5250709431012867357277423372041580897716232143432581463056922412233378167706,1091692079685509315891403580607856616782786079784896146193867325719999481531,4469622327160639333299363654867070539113198566013450831894562184457403911597,17323310137022557438196735285237348172608407585356043526322906169573029382454,16687301461250715912904355201855034952586622338354151885963080312175524252322,4918535113766539148632870060160447192025270821762409737556656897638575667317,11072593994523457387389747805751581908149754361901108358077132406445033545004,3195233728052289389067022539306995714028010328554486938319749354377057516714,20817686894891259203267112342163112292566908705837357461445233267117792429649,17690940439879640319699865226478735545090209049084370958835445823603146902951,21690628807014351230241926358993998569388931315165663025074689739408667261702,20459556268654252373755265495950372631044421643418312123931432417755203158692,2615012003869030558909061586486157199297754407476408867239954327608829725401,10416424720480840919038397124331362407722217483977166150169359209212504823727,21194909967788113390574471899389319930586662664636393856442773352403088570772,21522774899908415003330605964114671001565200771087582504208866633533540017562,5506611081865651016465481008237511873335242056816344474949867549242155650988,9546865422597752417260521115459137295056544614907437375816616393702205361356,21830596616035544007289279751950703469521180388685936491933709578982542912017,749611610802485176586202226352686769865522163389912514564999424571463284657,6755555316754154503813947597597343604907450943684878399336695170747270471709,12170672505455181293754012516713072944675179516356563083524964881029055628483,6707337549725648754250613641063009246814657413626673293152655855698987287596,10796498904992920132771232449170737749742455370471689413932089087977711623836,8377594495858973573128154823903039902710916666748285670520960751078778241055,3984683583649079079845275538974168947709880082512288559917193166572776389589,3342097912826432514400613460588054784328673911636756618761620185294261653370,16454683529696451672086473280821594992928717172228276559555553609303793416523,18807899744562842658522302889072060930222870278511178161869216361165074271071,15733467702619867688911165419464811721151813607792971238595067966297846247623,18142314765654743253383559257284245535624730148238939832089390410939642651454,11195224772751371350570884976842181779831961285896963666553011681145523971069,439244367736881667144534860370666344402105076566699968755250684892603338082,10704735720989025726743300184412677969903347430627186939154207946469729017738,18578876165452990292495920166540986834727225658030437088905164910953626259691,8557967377050572410782106944750290348752651270453684627569664713996263383548,8761045577121588487744533431678957572685193486431511842082771483510204390408,21449005117895748002614414579158497856671036353929407470614229969798846654314,8742763699897193075490808534988551410985191733407596422193467672281063172120,21640560187468057824325948244870722744182743184907610616373323268039154063822,20504827051323136179653341596769205909304116951166709098994304340550034816775,16172525553351370894318080522373536864524825253487998830365706514360525527841,3591685457927038924948528662301423116917211093679974227116322357454330018554,6023337410706762262272160833625601604408129024083079173527188974815598816732,18314718271070348604361238020618683829686900661152269809595508349472847942062,7836153641990744469550400020392942083885339413553995305082889896550143678297,17661458352757891434962464787581216134089171454741034624471153568868635718017,4122036760441574620764812242429576792598439550172741100479310420694208068906,20862235339890611718235387895311549206105487705288574136561783190763219344570,2850551701806552645458448511649317843914427882049290827414738885733429831896,11247005361958789340696615426808536553465247486357927152826112838641725799209,595377141566787974548956333113514797724094819448399289547808025689225222483,11650535249856393960142913145219442364845834591244773725262296147168383099202,20317269079309969728497469029861008772266846936951222269809633626856816105008,18373353028723033673212698815557995243796350917201491012576826029280066160567,7414281571887634589036890397094381209738607746338326059409587963803891852201,18038763738650749116346354096722212724532913209902202281075842225944189538168,1770786615956839194004148114013826935077292967352199469327501774219607260953,7488031997643483244135856650059587771856081877857609929648968340004445042854,8828420155416920637244885570572746512651260806059857940333819295380848667606,10713758486859145329962611447140189455100648474003892294431344231535672892839,19425964738010714594065721309197326935753724219070408633462182732050226443166,2074939531697630696938698501714595125993887544292881866150005180791766942998,12047170609336587447894029543834769407220306562179617939497216596360229783300,1264730939976742978058162525644425945405879597356760675420608373469615068174,16770820387947475117163540876143499701759349964098540413422664664028819497801,16280068293625117002805552395286584356701604835446863786447466051605766622630,5829399622833188992426267462479081456743106260845929463922917463933701539334,10637584899633814574790036401685386209425675304700886428980902763634911791837,9291782595793252587833322197337655894886134207930378095811922971339860144588,5951026341599354622946777675133435736866407426534732764305509667517377130324,4403580174404926097288523091529640188805282235669930524399146786861723458014,5003639966922553172252470768563093188889050306376650665702227782913343083764,6558197410800499965347594156873334155413890035105551024236266846011615264982,2475377503098365612622742300317283313185534384082772531168342518799898155594,13480086440294256226712366993542304396509909765502683907895525126405850150623,6847184584651376043889746562956674365958636593745423518578010394007380039425,834503921046130599339994952233856873876410737494970024102211605603428829597,3623466614124962325494185109684730979089103423795285554788413052641061197022],
-        [6418344278839121997761558068555633277874924383297235060428040203550148460392,8184778893153361724502825398680471446632259194563037088246379746010351701224,16103007220917684483813510789286348056519805127857943417823167430289370248882,1664056765289606259902279533842090994664529145577166075019619213360544081038,8189267971733078428327714274800548471520787418839983750528172780925243373109,20200362011107872066803394413626937903139046091127740529060907959370256880701,20173744990845412211550008592188171997284132875646553363208340317991304601908,6100976759548353184263451545777211359935324012594548692714862113681123862281,18589557631793259794347972680714314322014920073994928130094285735070065431315,774191617468212021433032703138192471679212014828288788368078839883023639562,20846157077077136618808870082870348881758556999252332666235423866411633465885,179369838162302125553370844232732082673907343764950159722856079645852949296,11918621764929568738238867861947162353407822663185301208219638335882724852664,11892816132266551039449220442540498829071526084314780371963132054098089857199,8372083054789567618141127024727893763407629214826505908070525202510871464376,16053969929668995455194287538126250235271805322133461918670713060143921845064,2376335354846722834191665301267088635977856417140218787958824096999457654386,8473768787638105406889032631028566536048259675966039382891971280359035809717,21341339254986951084972542739281440827262568377712659704364142966685544694259,17589661461505870684154172724042456165609752814624225501433267429299923279866,15569410058783548405562051853887675489795673100717406458705097884992918832740,17136771849960699223133648686528512780844440317239376836819594891344485260741,6846911134505306255484642794298233221271816466086606204236441947984501580805,6155197242495613968880604860842601809115711093712877692064968695514089066009,19128637117872288039529749360298403408432890998345732113683578733270478526860,13897081066927368111242039741190751095002227555149381235627883407347099966197,15568696369607733677931070776042128239961624292553408918258251667007167792827,4872469898347155985390501972210222637651779849978701189099596399070936407527,15828528305683107589096901962734302130704783164486093165237194118210566499447,10871050448146531061933214597828428556087596885695624079458134367495768692641,12715634392841723603484337993449575047813504874083783048519693646075495401499,12461797447292058643518857326956961860724022201671935652194772338021756072767,7893478478385050482361413970069327892342442172936930424757486435631374257835,13837601157198138379089270567935062044589875195895421018230835162664685103799,2902437942374588332095798046833013227638771976745087670719351344275677524328,15243444720000907684100993103252257759861356192301299607302082943722781818072,13807772002950549127635782715429970069282430778664455286304012934232212216437,3330690659470353458591000516836956263198779643900957759109026769401030561064,9121369550752168091283493588432030055987339875340008013960004670271046125246,6735940425069065421825600687003545396352913420833444906054707032006918504438,10202597085447755780667010145999569476263425973948073114389503196598866401333,5502428069812047253902185475715178213199056100606031376530298129227524479345,16644412428296109976288812904703533310452124314681543539244699753829624611041,1464363769917768267070780357984170193149530071521363359029977430003041058712,6585015011013232733155666746473112211355795487658434466373981554623709413097,4801399347914387190330170488585953929447785020623558112311440395749307391856,4112082032915966312546686950757741516554419896344654985273514512341960565972,21751105223203500709422523072334627517145925318798961657655356624798705469220,5444707496026644829581718915396971639630623832272466243662913303978147462160,5176202236175268355216491019205403607765794084697970681965844070084688885903,9306814982626014542830328909308268815941037317672165275254890008767120833129,18534005003473959617581160840952814838772020918476059581821124675494141739706,6315286473605163880327953940950267064586093973100720152185112301408202766527,1300066066523772310953083996541204931152213396378337235691979863222476540925,5067928636570884230858740896001720688497565237268231912398775294420405805509,2247332707031505717534336329466562637772796336116582429349574314234357562544,20247738241445291688801934041857783193064556313940428743035963593744371184825,18242310613256758222060583109097399506427347785291803988073944852458874238653,5027570650503078047623512055050961603632044524914664539379503584245086748701,5171024028215683374631525538977404535998938725569475537905229563957776539718,14944506678316768982115249709678873125670683211913646815567280613875065136559,12712774808537003317921729077604843728755135888798177519726799585299850232729,9704917525949617705578174784620125192847872142914494686332094535178307346294,17607293541936391773356775760016259535976314844718033784671775110177131099056,2540563558441922228123722363766317044293335648393481767268774186670778379682,675334497725789143197575210295522345522852999942555409554666160997486976627,19406946394055111935833464724872576724279555593094398662505995447037826031689,8556081865419484437161415079267380957278647215963771014478927152338629734722,10894080579102201350420363592007910695129177124810422954037601558695648517625,11291505870061211613677608925985023369330908318817731122393740145823745286941,8111345701049008354923033690718534410144029586027127161268652239467844080405,274549942856353845785392053622966579448945647367587770109876363273061435394,4517253471300397604524436610993375842851058850598308811197142784491633632173,752091920065645178354359484693693144698238715470242001046768604290011335506,11638201273705718037686872429810169270152128290712392950719778292205581621583,347106139963113855692776969661437659762102942024424980057845079543094637582,1650860247124995235720423411540903470864782697117302631679816892337391491913,8807792864573824348524944774842835780541376663413796103538010142332713129239,10125706840777901469452374931444076850109537279493387272544675392762656076263,5796395502360267028606772833560634747652475684290748049574810918512176530377,14560087906294745333868694378307270211143393355422503000240374502300675908843,5122547319055760404581514483238475236540700695938727023605315976547513018758,18167310745991466802649320845690518166441060923615799361858509593334862918793,10537655786889979411145772153623144374332103428122704649668615330715372491734,11129217221221505592409814225825346415830118409870141057639470413354985898470,18539905463366886572265160849053355497514707079972544561033138019460289616722,2634262960559341073751666364573144239402802922297326052528609874036724778513,1017221748705774701515487698826243372900579204850532621904642815268966836932,17514607882958712820434977243901228312981191640605665595923587928949930664369,11518730158165740016295488007249832672982237183652963149460237152135828893220,5440554707898671641433725775650782970626686693839748603607869391440450924607,9147974268228093219515993293158817299424235911620662153289209094112083583914,2705991777416683673465834362340927783587369064825521543877658261521166181909,17763220243034576321349123132976335282008457858814906290437636386824597776861,8436811158855395670172615633911662578819734431001698203244903207934616540973,4138616319619099661442960332848564292509386403496259477312793995345740346110,9291305887217504987438822522544685995385674372729325355668719643387679293273,14247130176192495492949419984506575479387281081069847984799112525576996955413,12065917784915207956255864287163607339403293417584561373088222422519855200010,19602746430676351974790620090862300757670420200072717172839368523905726952498,5634613092261261536249683912838127927279222476821160426063089671641025921660,5043354945289735676261322233679902891599697472766188245131942353534121350357,10504830582720502950783794220870443419986496189960249704278002268186024527222,14773755085011014730752864609252484899166588993023999143755304644745097411069,15143011250372146369484566133567610168314155803929775363148643430052742055690,9296771043817098875687880718048618354875037373605143322099708291917193542563,6699308928121904151061270394393246387724926649022798867634982215175491150673,8773562200655600334022608356584787571874596251190350038742467377669146368640,14351113364159322541281738731216101468935785403577478179790191188832046493458,4850132968055386067280912095292570467587181719320385350609813213372507065742,4016458733475657342057293585429845015911706822034026494547861057484844319736,894041043510502707790816962794342134661931379046385946357294445947889380857,6102901509904208647404960172211548023168535043766794923435155807898706549347,10993930772305308408754972248679389846078570700140268311987303413959565163567,11304109937008720250639855591630423562437629896442798574433639679310105935745,2101572929952921976477335632619843501489349436900225186251308254022656908969,13379549674365217138865497711163371499213584223441782700932894243483907931587,14594340674649653462364863346385318403203482098904810919462071947226757935441,10647634642733631076053157841634424396589261258510712678605967658799137793311,16930068860033006574251855928288208559689461032565007963103701897524112820278,17170753006961827437085793102001841977757115057767702296590976802337127094191,1342928489123424058754093123906133488378103161461686346784407392402405815911,355084123756415397117817901422581736826549282147584490336790542339114994995,1823092998982212793902589678970070284970565355035702454684653415443223765731,8048898551230697881244098474076915607341905762324328681953519068200924158237,20856146965109368880184165603695312280799455722407374791306423939515039038196,3432336669019104452964292940253917813738689308738628946720655243686051453920,7245438991832359030357502486353272155562833935372540938834365796871211337300,3373527222057951116939099747150655397463396105930227294848620975346900604136,12572707687046208161448564696692430877391470466184921096766838283998472321208,12384937031493229201662431219560608524659573369707802134091983819133706078063,20462122407152292556380602425948480298757076111535435284512383591498863731385,6622785585380387259638611864923325325049433660844748518649420260935388464763,15605049021670133989806310757216368923392900885847286376362426319164543334301,14810486805240500676478878806350063220126440203863567013665308737654824897393,15365995118119349988306703047684161019037838200991362610041019844939301169864,6214064907470154787016516294417895267553707205697453843662274325114029144555,21692877109550228305351038417910800050989918141485758185602644390604582268196,7958034635501608074408556743462969750498597833797740641656952760348926890967,3158783210920420629823137370399691077131051120551658723733852791768119909942,18819671751132769006885776104610704012597692175792895108910904654781356258396,4790325452934584098003515312147561388538271922609950099121379835100064976005,20767398895337785696143628393192433940154143348446221959395714109953426025406,21100955173515864394919601160078443835098475047602620649008862351655083694950,8821416529246363042674973639302381036248538012124317741611227124444469290957,11914021995756592924439683950035443074155751236836696847913625157420325157778,12885168008148287764892654933214399102034605991806678959486007885552095995306,4425275709248360981167156075250953689813562430283330510520431316578062369047,18741351324856319300007832572892392651059227679283122747711533395263296376480,684786537545646459534722549414114801405982388707719975074226812265976115381,13474309605538568830758681457803561340228343878559353019653388997246494295147,3099805728977762711509412402176547022850118685798164610570416531465753528610,5600770441217208920894248156825173605916487562076226390167638135518086562704,20319458329312269677818220957673767032133429098791178878849925747919552800984,14900034607445803864669093098274289660238359682591825230729114910199159461945,8290880045417869099036293157381173265982569186829040493570954991061128070937,8462436298566072387124764625279911648753174589013128335782578822029407672023,21859976115370951722195695482147975930683297060804395404861331672395447064815,14955925753372802734448760267566451635799685206346879293698701403481312089613,4065981601972608953318716423564125873552717375448854762316325928896715511302,16523330234791629267329601436136683980570251446067965291433875700044665982992,4829516041540259457263557932051130738530942234255982016822863700315113125159,2798840870433591285859944008589519120500790120158397573735407833376475300691,13606709616318037902590277227595176470474803011913892797662975188860939656033,18594031070203820621139505381680984797252179318940256457018473319622484612714,301595919185954926511829797241004376609778538475902874115890821742528188064,13821866899865257052128875138353714301663063129600329885914206051645789155403,17834817495579398016717972195069792832976969906967797534885124084571666971093,4636638693344568063056245513561087534038777759740617868439601311740450428791,19461094558355290408553329139619939302588770167904059927666632659470708174566,21540578068459849172758651661944081878533817564350404794583097681041474789761,14656354515483866868842463518575118611017107704362419507056354562832024225447,343560765432454876700403976911389497782754407830340801930660700142029455668,11849359483183996767521484728570765305101196328390648813094255236259946055317,19924264286421201319107239943837407504286665549555105416180422159851955997381,17166797941774367858319514708612731492719223682833034509589752159955652705269,214236542688014950402766598120744795751883810511956979430464011049570919618,19396313302865541199110558245182888004201133198902041449761385765703954241755,12933296125492490585010683271492258153065303286717891025958189212827073719981,17844270568289843619005627429285364222068221173113885235581641198349558307966,10272636157097124940050637562161546985351212351240072791897429490752295849402,5635761628763643716582314870927054669889487541831762994265390120663404976213,1986614715532243876888195532508093896345436225715262830320266933005235142097,1081989267417492031457620947123272024310181199896785177670601875483149154563,4271010751492446271792663900865386872716262596127435260947966701647960153580,9432817034096362918055925335622289410018247097406473925807967486887418646785,8420506466048434939907866067225441403679080978454172178355845135440301602325,7476612931957868870953074766426582066042735713430654491467754928300129405389,7004218213610744415525118134908394594325377744218316765510260162880307132371,7571768879245095309014348656876595924444469219593531275918644914891061799835,4094897072683886403820666572344492999293005026807228977160362626188210714131,16648450944544843693538650431603587114533063135176857105384828552675810607958,12887042974366913908128212909540148628955501312789089034196573637089727885967,7707639242815954375609957852547086529799646052590213478924819089112009057667,8823950326593148986044014943552213420762296615584865468926316064433145020153,3784973153813546220636380916429273484146041804997715013288159720673291711004]        
+        [
+            0x304c29aeb6f1873847879576d30f1f6e8a3ce41082c15c7632df920d6db5164d,
+            0x2b7380d8b25bca649b3f8bbd0a86ae417109069be27066f46fdd1c7c87d4c40c,
+            0x4c77200e5494b1cb8a3d334f69ae5bafa7e8775ba1924e563efe591eff302f7,
+            0x6c0b8966df93080c3ac1576486e61ab0d027637aac41bb35e482bfa10e34fc5,
+            0x24c73f425903904f40dbff590225f251ce1980a5a5ce2d07ae436e1d090778d7,
+            0x23df6f6f4448273c745ce53d5d7abb5d26c46724a58d68844d3c3ee45e9b924b,
+            0x1dc1b1ac389280188e937566071b84bf8189b955d0579b6de5ea8a5136bc2ee9,
+            0x27f71c5ca774ce20028b8140f144472043917cd4919cff64d848a745bd569180,
+            0x22b2ee53b302ba2e836b98783e15eb6de9d15a72cc7caa374e61b51dd0d2e2c7,
+            0x254d85065f87271e86d7b411d6acc280f9ed257c098c9fdb04a2ca4df7c7d766,
+            0x28620793f378bfe881e098bd2ec62beb46899f37a54abd053cfb0b3bb8d5e754,
+            0x2c19f26d0836635b04f38fa30ee5c648fa0ea1b202eb0846821acd3c699cf061,
+            0xf9ed87e9a1ba7ee7c28bfd7ac38ff3ba10849fb04d3322898ba9fe0104fb445,
+            0xd1deff42263b7cae8a123a1641b7258015476161ab881e1dc20e165b3f04579,
+            0x1ad882b228b5f22b9f6a02e10ba09049c9281b32ad71818502b66ac77ee3ac6,
+            0x1822ba8c558e0e6bd0efd1ab4b45129879e43b7a6acf07579b1e6343c531a248,
+            0x192c005d746c0d045f5530f10f38a29b50cb6c86039410e634d25a809203f492,
+            0x2e9e6de4e745193d2eb8b89b5b573eddf8a6506746afb98a2db858134acd808d,
+            0x13373a062c71d0754ee8b1872dd2861bd4c2545e807dddc654d68af43ae87f0,
+            0x130c94f39a9a07d71dac7df61fb56cb975c9092ac2ab73b113b341e8198eab08,
+            0x1934eeb7210877c3c2e07d9ace7b72ab4d659bb1431f8e8ae79a1a5e8daff5ee,
+            0x22547365b9069f419ae8b9370816f030a387cf0ce6b88fdc54fce91c485dcdf1,
+            0x108b2099b7264eec50ebab5ccd3558a359e34fca1cfb69df4e3f8c9da9faaa73,
+            0x22b946f1886cee07fb01b7f8e3bc585ea8f9a7fcdb2aaec5faa878f378eb200e,
+            0x229337b2b316c279097644d8fa861e5e5c07377cbe3ba168b55613542874681,
+            0xe9283cb85fa800120344cab9a7f792e975f5c25d64f5cb6a521b62665af7451,
+            0x112956bf9c763ec101af9a335159df07d1b0bd90bc84be291aff9a85f30f5163,
+            0x26f27df4fdaf33f3d12d5948690653ad1ee625cb00aef92b73527d37365c4726,
+            0x2ed4c4b73e2547622bb78403cd983c6f1d33b25534127e98a7472897a84e4b3a,
+            0x9f0108ead7dd31504de2b846076a8019827086a0c4dd6570c1b7423ca05b0cd,
+            0x1172c6ec16cc502fbc633f8a4c308b14551d2c4822b5918179946e6545e9de5f,
+            0x26488ee5f0d4f8b5766c5b8cbf414970b750e7488aa316976dff5ab72f349f1a,
+            0x392aecd00da38bf4e39fb198ef96e70bb8774b8152970dd2e1629b51ff10ae5,
+            0x2f6d971cd5f9931144acd9b9e98bad6e1e78d60cbd966fb18e6f630a76dfa6b6,
+            0x5a795d1230d3c781b9717735bf45464f36c41df07376364986d0fd12c8317cc,
+            0x1e238a362ffe560b31e3b050539e6c8fe0da221fba18b12ad661945e22e5f5b9,
+            0x35fbe3e0d9d9276c990a3b1719e27550545a077f6215eacb2479af1b3686364,
+            0x7ed14110e9abeb3520e14682efad791ad5c2feb51d558ed013675289b1c6bdc,
+            0x11dad822671724ee6a786e210e9536e0ada0796d4aa0fced69c1d411e11e0c06,
+            0x110b32907aac869005443ad66a33ce28508c925f505e44a34b53f70a3aa45385,
+            0x55a8f4be4acd26e362a4dbadf39c198b43ea025ec429df6b2011177dd8e6cfa,
+            0x1bce99ccd0f37478be3ecc5b67ec7c0a84b03f7231630dffa5e16ce6f90d6bae,
+            0x1d61595a714a5f1b32a5255dd5522d633a0ebf7fdf82a9cfb22271cc962c801f,
+            0xde4fba8ef10768324aa1e91e606f2a3c3f3f6a29dc8d31bf7a670d31695bf02,
+            0xeeaf11740f270654239779cb83a05182d0c98f3d4bb8a7a118ce4c0de477e3d,
+            0x25c397489e65820a955d6284c002427a1784233faa7089c6677f103d2fafdb7c,
+            0xeb3a160356c8929495bd9f58d3a8657f69f3eecab1517123e724a946dc50c4,
+            0x19122ffd9b6430a6f6c81cac0bfc8b488e1a28758e9407fdef8f77aa1fe4c0ee,
+            0x770ca4c67aa40a1659365097ddb70eeed6d6230739265f76786cbea0899e823,
+            0x20cf3df7dbbf47bb220ccaf0ecd8f3d54e0575628a7291a72cf8db5e42e1498b,
+            0x21fe2c9c9625d66a931fa931bf7fbea6c2808ffd7d07fd3bde15775957c62768,
+            0x2ad158bb675ff14b1dcddc993d9d60a5b4e9f3648afbdb5bebb2cd9a98ccb881,
+            0xf89c7c34499d981c6cc376c6fbeafc88b7ddf87515dfec65da9bbcdcd68eaef,
+            0xd6f33ac650e35d3d642aa3fd35912fdfe5014b86cd11e8a8321794b9a9c2992,
+            0x9cdcd7858f273636fc033c778e5f588b9fe6315476254f17aa602c20065caac,
+            0x2bc68e029d800355300648a36fd8a24157750a0d6fb2f2303906451f3b3d9820,
+            0x163f8a2427805d02620c54bc1d32186ee3d07dac41d9289e9aa3dd2cad337601,
+            0x2b72cb042e079dee8d56b1762d0052790105395fa0299e79cc72f4c27bfa20f4,
+            0x1aa578a5ee2c66ab8299fe99133089e90676c4a2e6d56cb9da0679fff6cbdcfd,
+            0x262d1529ab1e7f58925030e6caf0e79a14c436e5926e33cd79d321388b966dfa,
+            0x1aa6b71c17be336b1b1cf2384d6d3ee0a7ece1ad2003ca727f636bd4b70617a5,
+            0x286a8a2c71f53994524a189eb5bf41eed57904d91f44eee40976778362547af3,
+            0x37ade52ed2960d80bc2d92b815a5315883cd42d26709ae64a822ff92ff373e4,
+            0xd641f097ab6260b2dc240a85b7799541f6e73a3a25649ce98b4b64a6c499dcd,
+            0x1176510cc674b0f0caab00f4e9be1f8c6efbac7b7315ff6d4169184b8ef009bb,
+            0x29b6783918f37a8015d122ab39713848ca84008abaa716882b0492c6ccd15642,
+            0x28a8be58f110dd8c2b90428fb4feb59b67eff815e928fb7d75747d35cbc40ebd,
+            0x183f2632e3ca6ec2377e8358c3205d23f9211b759f62fcabc5fb2314d0728a9a,
+            0x6aeb9e100b47eacc2dacdeca2ea990f7066a79e2c7c83f2490bdab3eb43620a,
+            0x212949467cdd807e8f3576d403fef09e9bb63ca3754897541c6cd77de4ceedae,
+            0x1858f747bddf594d663ca49fd2aab93402ff9d186cb230a025d53b8d4c626e70,
+            0x19a293adeb09485ccc03800b821707060dc27e8663e355e908e368e2e8bc0150,
+            0x1d4241ed038279263a184eb3aab7f2e14326b7faf040a48628ce8a38c7b0abf8,
+            0x1692838188071f73ff82734223e5999c726b055dd19bb5a68e513d57055d8bbf,
+            0x81d819dda57265e88fb9eb5f7454ae7dcde39a14b00f45cdb19406e8bf24efb,
+            0x1fa7ad5a2bc799dfa38a9c581b0d17990d1f53a145e26e7b10a0901a9dfbe8aa,
+            0x140107d97554b55ec285011aa53f372689e16d68abd763cdffabf8718bcc77d7,
+            0x1aa6e52c05aa7d40dce61bc38b038a69bb36490d2014dacf4fa46e71be012ad6,
+            0x233c7ba71f9e0ca09ec20277fe09a96399a1474e4dca5158e97536892de72b56,
+            0x223709deb8827076f29c20778d24a2006fab590092c7bb34f212c331b4b1b932,
+            0x14187c4e94d059b6565591e16dfe2cea40731d582c1487e3efbe1cf305a9b459,
+            0x12d57f9c3775b0509f5c95f1cc2e17f1264a5121afa6355611de2a71ee23d803,
+            0x23ba06ba8305823e5e62cac1ed25888b6234f13294c93e1d36d5f2f73c8b613e,
+            0x9018322b8f274623a4ef0562223a166c0fca597d4527ae8fbcdf297c8f6d1c7,
+            0x1a8d0fc5616edc0238e5287d9fb6869468a83ac168452c5cf3f9a4063452f22,
+            0x2b1a8db9aa3b060be428900b352808a1821e9c9f34f8c8e75b172def7f0b3d07,
+            0x14e78cb6524a7125d7718d49dd76525f58cf2739ab9cbb0d408dcf2e12f604d0,
+            0x1208b734f978bdae45714bfb76d3fa83c558d0976e9c9a1fa93a1fa69f7bead,
+            0x26cb6b7c1d65f9e5b5235c3f31f9d7ff1d817e4b5b945fac94a99b3cffac3d5a,
+            0x11344656431a0d87de96e6806fc0abb9e1514cdf175d617b70008b1cdfa7fb17,
+            0x28180778e94d900df231aa7e551f6d7207f3344f5b4164d19ad4627e53aade25,
+            0x1497cc0587aa9a662cb2e9bb2ae6bf3e75a0716db37ff072d6c5cce6ffa65277,
+            0x1155b889f1798c1b597cdf4ea98b7a22e2291aa2f49d4628179115ad19817a1f,
+            0x136bcfc49ef4ecf9c613bfeface129644a00a283c8e9567c0b0149ed7d7e0268,
+            0x2c94ea318df6e3131d85a4681682551ce652db2f76ff670212c5375994d2da9b,
+            0x11a008577edb87e5285159e1655d70b5f6ad4abbf3f8f19d66ee1a7172623cce,
+            0x14262b879f58b553126cc175743b09b5deacf5aed297fe3e4124417ed2016a99,
+            0x338d86b8e84fe8bd613d57a3a713ac1e971d52a586e94106b49d7d390c92658,
+            0x1ad169875101e162c49ec27ec32be37ae3d379f347930fbb656d718b87c14c36,
+            0x1e33654824c915e16fad4a166ee216d1b3a36428d90443dc9131f818df850f6e,
+            0x23d15701d8f5da053866a07f4788c49476c5518c8a812295dee3aa1074db6d9d,
+            0x2d2fba372de705aa005c21db4d71bba12c9d47dd0161bcd45409c883423948ec,
+            0x168371dfb98b380fa2d2630c612f8613042e6df90658c2350b270eece90d67d,
+            0x412112ecd0cac61c445ce46a8518b56e0f2baf839488591ead4aaced85fa01f,
+            0x23ad0edb1f4fe974eef543fc17fcd7dc1a0f05e2ce5ac18e374c87bc09f75c78,
+            0xed6be3eeb0b9147d7c509a9dab4ba2d57c7b9d4b2780fb0515525fea4278eb8,
+            0x690d08198823c10f51a7ea3cb473a6d98ed0cff6a17069b50971a68567a7b11,
+            0xbf5caee488cee887f67db3206cd5da24ecd1baa6badb44bc761757e2137ce3a,
+            0x3dc319068295544dd33221944b9e285f7219f85e8855975c48f69f77edf0a17,
+            0x164c0f9fd358e2a011e55931b51e5654352bb6fdc6cb2dfa4d8a75722f2621cc,
+            0x7e8978e88b1c0789e9397e09c9eb10e368fce8724ca948f6f2ac92cf230e6ea,
+            0x22c5462508c480867b3cd96e18dc3c42ffd90e1586ca41fa67158838cdf1593,
+            0x922b97a92d6a11fb18178d05f054345b43db4f5c6b91c73e28f6ce3a22dec5,
+            0x17626303d1bda8e47dd6d0da342e4327eae6c4200525217a20f6226cb54bd44e,
+            0x16ed2d702c6f848039b31ff87fb1daaf88b23f6b00acd7f6409a7cdef83b5ae3,
+            0x1d9552a42def1750b55d27edb09ce26409f8f89050fb74cc53072f788feca6c9,
+            0x93f2eac6c08b0a43d4df37c1b20d1965c77103de2e6dd88862f77b322a32dd3,
+            0x63648259abf1b9feb8c0b03db31f559e47f0e11de2b371b299043914d0ebda0,
+            0xa8db8ae7570818bd9ce7c02dce89712cfc04f800d55f1562eb1ed27da9deaef,
+            0x2addd8a7fa94a011e12910a98b2b8ae5387701242ee2281df132f9e9dd3fc7c6,
+            0x82532cbc9a72e056668946fab08eac4817547cf26ef3eb8f159e76f9023dea7,
+            0x2abcba0aaec141d7742c0f0785daa2726200b6ae69d464e849afd70465c9b557,
+            0x113ac02d59778ac96902e3fdd0562c504b418cf8a8e349da7d61450a2fc6d685,
+            0x193a7f639d4ce4d62dc7567ee718853f5c5284ba09de428fdf02846ee22331aa,
+            0x76d49b5c0dc78dd9c8e7ccc9b5a35df69dce86805aa47fe3f8cf062e47e95cf,
+            0x23051faea37aac8e12ae94b87a02411747b14de73751aa1a3f6a07fee98695e4,
+            0x2c3a84859c46bedc24120441bb6dfb113c09dc8070b2e0cd139ed49c9647b737,
+            0x165df45e8460cb7b423a9468d2935c14c93c33c700c654e32c2e6743de59deb,
+            0x243c1dcf2e801df1b53ab72ad31fc24cccb07b2518594c4e5f3024da67121454,
+            0x2d4f07748851869bc581212b431c20cb3e268cb7f6aef272deaef66e929bd859,
+            0x1445dd9248e8bfa4e6698e7f51553ef1a152d37d88949e15b9c50c3e8074aca7,
+            0x3f3128f5fceea223432d31ceae2f8b11b38a15ca9c3fce21cb8756e8e09642,
+            0xe574b6201e927e5f369a966151ddfc5c06fad66e64d5e09702ef172b5ade467,
+            0x784b51a7ae1076c1737eae2fc4c3bdbc2187b28f714e56cdde0cd322292aa4c,
+            0x289012d3d1fb3419e3fa81294f3a64c15685ffaa658927c09c1833ce59ce5ff7,
+            0x2bcf3e35ab8919e05d55166908beca23a711c712284c45695c6558e0e3da22f3,
+            0x3df5cdc10feafd361d978330cb95515bc2e587e7dbb89da4ecac57461b75b6d,
+            0x19dc65b4afbaa8127015b3f68d35b557c8fac9938dee95ae35ea12da61b7dcd0,
+            0x1fa279d539fc9bf724da2e7622bc326f9535d00adc596916791d77d03bf016c8,
+            0x237dd96ce03469858cabff18944f05521971d1ad373ed6e041987754dbfcec17,
+            0x31261638cc3762eb025a716ad3bcf1d6447a080f3ccc60f8117315254f568d4,
+            0x24fb403026e10160607af2e0a214aa725637f19af7ed44130a9400365bf61a7,
+            0xa773f9bbec6c35b5d7a95005477796366c4f36ca634e94b283233afff57521a,
+            0x2ff29b7dd04750f926b880f54acc39f2e828852f40698afac2661b3053278580,
+            0x1555a820b4069893e6625d113049c46bc5b4394d627c2668adccd3ac0c6492e8,
+            0x2a5d25cf71c81e5b129e7d37a5e2728dad5d99d3109d23a18c4627b4afcf8fd0,
+            0xd749c5dedcefb1910ec9450ab388da7aeb25adc78cd029a75bcec29559e8d51,
+            0x2134979a55dad645ef838322058e7bc8ede30969481ff2bbe496d8ccd6aa8ca5,
+            0x1a5d28f1ec79a8a70d8cfb783cff4c2b96e4ce5beb97665a0f6a52e73a70bb6b,
+            0x2248fef1cc977b18bf5051a571374c36cad0b338bae217bcd9cff038fcd7bc57,
+            0x1a3105c3234d4afbc112d7a9f38d22206c0a1e77112d6ac26c6d6aa63ef50088,
+            0x6ff45e6cf264bdcb9e8b3b4f13a44d1c197ad77ee53d02fabd0c0a78ddf6ae4,
+            0x7ea34caf7f9c9734f489953d428cad95bf98cd32d5c18e5b51e01d1444b8f91,
+            0xbb9bd4ea562fa887d4e6723a798e7641a08dbb42cd72852b8002a86c57f1f92,
+            0xbe1e28fd888e42fad37e72eaf884f6c6c5d037afc0957bc9ebb4893e4ca121d,
+            0x1de8955b5f752e29e7e7d92d6345da11bcf32937a8c2abc93c497d1affaed055,
+            0x140faed032e51900fe203d8d32fa61d9842d6b7283864ceb9a4d1857d6a9cb5e,
+            0x653a45ace7457b472ead1b3438668c57d36faf59e2a19134756356ce5cbe131,
+            0x6d23369e024dfc31a1e36cd9114fb7892316dc57da6613ecc41ca0849a1a7e5,
+            0x106a234f7e4c5d097cf00f256609b029de983d04044a66023d477897b91adb19,
+            0xd5907c353b674540c20db872cd6e0de8bd66f9b3d691396aa06678b5a9b8bd4,
+            0x1c8cc4858cdcd5f36aebcebb9cf185feba809a92308ff5f63b66c2b1f52dd14e,
+            0x18709a5ed55ee4f8614ff04e503872021e88f83d488d8a0567597b60e8cdb3f7,
+            0x20573eb7a426d39fdcd5f46fa19973e6be531160e75ae9401b99ddd7e2ac25c5,
+            0x1b68b1cebbf59b96e23aec11f075769b54ac1e7de44ff13708fab5a9bfe17719,
+            0x1e74628fd280b451eae0d00add965f95bf19fba43425c3c0589207782f702b7d,
+            0x1adf6672bbada9f83494ca2bab97f2e90f630525f9c68338ba4b34ccc484b478,
+            0x6ba3daddf68d283a85f65a0ac15913461a7ac09a320e394d09aa5ae97a50db4,
+            0x23613483e811cacaf27820d0a9ca552ad22ab29d4f1d579f10bfebd39f14ee66,
+            0x5ba1370283ba319cf17f631a9291fce5e0e682ec1d01bd6df2843528e363db7,
+            0x130a1c1a83e91a21cb376e0df81b196d8c229ec60df85a30bce4ca8f466fc589,
+            0x2ad745158e0bd5aed17084d5fe12d671b0829a83392e6dd0a90a1c0292eca0,
+            0x1a4703eca8fec84cd8234d5fc467737761e6d2d6bb6d502a40e25f94044e0aef,
+            0x17eeda53608b4be7d2c9b6664dd8fc672bd48641e29f6402bf55443c667bab4a,
+            0x1af9e7886090fcbbe73d9b70b729ee9f8a384c4862626ea685673b4837ae2627,
+            0x2c300d04412f79e15c95dfd44889ef4a7df828c6b32776db3797c674fccb5fda,
+            0xf617c15c41c424a39aa8a1601c5ca44207b3c6e44b003bc13179fa7afb8232a,
+            0x280e6721e233a91f7f26004f753a82aa3403fbd9ff420411c058ef275fb54295,
+            0x391c3b4c6aad3203ef3e9d7d217d4b77ff1fdd8c63a9fecbe5e702d51c53f23,
+            0x203f9c14aedd6319d3ec84ed7517d5fc4703aa085f45f590e86504213b17fb6b,
+            0x10842bd57c470e718b75553ddf18278b60594ad3bd7fe120bc46cb0fb450d424,
+            0x30250c77a64030f322e0fce46eb9783655a93645784b5219c09eb0ccf3fe88a8
+        ],
+        [
+            [
+                0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+                0x12826e5b9be1c9b85f7c98aaca9ce28a870687d3628d60def0ab3072b57b09b8,
+                0x22fea1297a4a5f08904d555c2e15d016102a4ed29c32b4bb10809ef14af42c77,
+                0x24cc6751894087b831598b5bc7f9db3cbb48ce294d9208e1aa436cb5fa2e80e1,
+                0x2cc3d0503a0e1da952b081ba5dc5b117e646bed572a645266c6ec3ce0a1474b9,
+                0x11eedbe5a5969f33446503494b469a2b83f88d3aa477e5d6d7963a8333a61315,
+                0x189ae9e9b162ab1a19d599cedcef428bd1325c78740aaad6715b710bfac4c1e6,
+                0x1aad11449d6e2c6e1adcf9e89114c336c0145528f356ac049f52fd8cb084370a,
+                0xd7e1eae2cfec406402d34c259e5966f6e2eb261d4f08e29088325a6bb669a63,
+                0x796a23ad6ed2ac995104a0d3e6c75e977ce29aba1d25e62a9a8a20364ea1be0,
+                0x299b8e8621d7d8c8d3d6286cb126b34ee53b2dc9a3697b8380c6e47f5711345c,
+                0x20f11ee81d2ac9a9ed1cac61d9cfdf10bf1b49cdfbb6d232872a1df1427c1839,
+                0xa403e979943b8d2f947f6eda6d41170881341bb5e4fbbb3b4fe3dd7dccdd777,
+                0x4646253380f4bf642972ae81977779454aa0833fda36b1822cb9c09719e3dd1
+            ],
+            [
+                0x12186bb22000ad84b6bf29179ade2d4e7e94ff07e51627e09580571061fa8ce8,
+                0x237e39980f9007bbf8699dbece054fea1f19766be6101885d421fa3ea46b5348,
+                0x1808cbe7ddf2a3684d8a164fe2d150df62206f6be33d577dc5798f193aeed7a1,
+                0x33cccef05b0bcf7b77aa5560a0f949c90be5cc2c57122f9885d24a117c63f98,
+                0x2854c82b4b5f5df6dd3872e3f371372de0d12e16e9108766920b5458105e76bd,
+                0x9b63c75dfcab572d280b057fbc3640d35dd5f16244863ab8a31e0956da8802,
+                0x28fd36f1c761ea7bce29e6f00067fa40b32e6b318f506b6c94bb847bf72b5b52,
+                0x2b56c2e44f703a3b143da03c25749367f752b16817257e6d123b10bc85543432,
+                0x184e5824689e4f81438567df435f39e1d35a819041d7eaf3af908429beb2bc2f,
+                0x1004c5ecbab6b7d12f6bb4caeab33dd56c1f829ee28f47c29fbfbb147e884654,
+                0xa973a665693ed09434edb2cb0a971ad277a82b3385788552349ae09e8bd0c85,
+                0x125478c8973bc395b648c822091f8df469504a71ca4fdf1dab59a708d0fe4719,
+                0x2b0696d45980020a2a421073440e3a4fd39edc5288e6900a5958e0cd81e0eee6,
+                0x264625c74f2a3bbbdc19481b7866757e639c124b4eb560da531fcef99773903
+            ],
+            [
+                0x2399faa648aedf9024c6ac3ceafea248216e24a9e56caf5acd29ce2546a9f6b2,
+                0x540f5492497595e13080f02f6b1e653e2e51895160ffd5ca14d26aed93b8672,
+                0x1c1ccb44ff8ab6da854e9271f4bef26d2ac26cd7441f1b69d16eee0d7a7b481b,
+                0xe8efc85cfebde295ce589de60aec0db43c81f4be7da44eb26fa4b71f7cb7ee9,
+                0xb1d810fcc721551e2a596e9009367fc6a924857ab29b703207b08c95ecd001d,
+                0x9fcacc3998065124de01bf7c0c8ba26ac4241f1f7deca1eefe5ef3d5015e3ad,
+                0x5d2f0a3c223122ac01214250320b52ff5a3d242118e19778b2c8cd1a976c611,
+                0xc7513f762b64022a151d62302099dffd51791d9afd3dcf96cbfcf6035a2c27c,
+                0x18fde6451062016edeaa32e40a8fc30751e17e9bac192f8ca891c11f39ebff81,
+                0x77559473737549dfb2016dfa72558bb2c1c816d7318763a5e4fd516b04914e8,
+                0x2de9ee6529e5abc7aee93b794c4eefdd517c4fe12fa56bce06a3708d86336bbe,
+                0x12b591b7af35ffd997b3a613687e449225625dd5d101cef2d6f2af02d9dbd6d7,
+                0x2f9f88fe9be36457e8a546455aa00a0f5100a7f32580b78f26a77bd0b7612181,
+                0x9714e717daa3ceb3e9794d24abcd172831cba18066c4c048b0995e9e6df1dec
+            ],
+            [
+                0x3add29fe398ed2d44f233125ecd1509e3cede77e6be08b94af4fec87eb3e48e,
+                0x12bbfbb110ec2971007ddac5f8e36f655465d05f2462996b2114efacac70afb5,
+                0x1b8d209d66b2c1acbaba435e304ae20662d336d10330beb3355cf801f194733f,
+                0xa9d7ee7ee91677affd3ca4fc674625be897df79f82ec438e80f1e000c8b1f70,
+                0xb6eb2254edfae1d7503c3518e64cf19f3443d6cd03b71cfbf1be5936da4e046,
+                0x1a9ab3fc2059b0cff7e3cc431f7db45f59d8f7f724cd10a03f31a36638f8b52,
+                0x23fba23ab4bc24d4880ba5a6ffd6eb5050dfb8d0f56476d3a30290eda372ac4,
+                0xb26700fd4e950c25ad78fedb63fcb0d9ba73ecab858c071664866a9096f14d5,
+                0x4a572b86105dba5253d7ed1e76d35a126e6718551b976b208f593f08158dea9,
+                0x1bcbe67ed5fb7522adeafd1d9a150f8d57ada218db346915c86e6c00c00e38b8,
+                0x2ea6b7a7265c503fcb284c2bb19512dae71ef357125c3ac755c6bc6cc37bdb66,
+                0x30544eda9c322c6c872671d667fc5fcf09cfb8d34e8e5812b6e738e7ab40d8ef,
+                0x206733e327a64b78d3c48b6f7580d0887c1778343b67768859e2532d7d1c46a7,
+                0x14dac9059c9e78d96c7ef807ba342b946870679782231d2af0f6e4ab76cbd101
+            ],
+            [
+                0x121af61f4dc5bb24890abeb9251e5cea94770ab062dc0c28bb8995dd8f183635,
+                0x2f2ec51c48f8b73c51b264a70d2ba0b46bdb43f933de0faea8a7da2a97cb41f3,
+                0x11738ced3933c4b27de13911db71ccd58b7b31344ed9153dbddddb91fbdbceab,
+                0x9175b1fafacdc0e62b5f95e6ca67c3ffc96a26e37cfc734795b92f1e46124d4,
+                0x210a4a80e6eaa799f7ce05752bbda4d4ff0520742c943e1efeeb12a91229a5af,
+                0x19bafd0d7942b839f36ad3d70d9c87b55674b9bdee02a7dc30e4f99ebcc1d94f,
+                0x26b8eab0dd0d95b7a8439e0ff7d3438a73a27b5993d81fcece729a824a3521b1,
+                0x173985fe17f3b0fb85de6104c02b46c3d79eee9dc28b567f02ab1a1c0ddec576,
+                0x1d948e8774b180fa5e1a3932439dfe8c5f32a437657d21277e42614b4c9a3dc3,
+                0x1b61a03e218362204fd20b67536e5e6ca7b96dbb53d53ed1602302988614876f,
+                0x1380beac7b062c6b89914a976a8d0b9d3276a13c82c23fa21f4fa4403e3267cd,
+                0x2110c105efb481b679ceb2f112d6ea704442763ae2ac65edf8f15cfd169c560d,
+                0xc272d10af2ef78a98dff7486c49d7505edd88c922e5672a3abb15cc49f4134,
+                0x129dd677c1f8aa2d36d2a7d5340645dfac34a64ae456f91b97de9f8e91313615
+            ],
+            [
+                0x2ca8ffee2d58f2945297b00cd0b511da167080d53949b3f1fceaca9616b6143d,
+                0x26e36544d0b5952dde4007d11818465bde91c4dce65abc015e7556ba58b95ffa,
+                0x1e97ce013afaa6e9c993e9cfdc9aaec91b06787819830985a72e9f7c6e516ab7,
+                0x3016b074c814225e2d5c1091a8303eee4be476b1458ad54c16b4e1691f6b4724,
+                0x1c1b2cf11f0d3a3a121be7d0ddfb24dc71f54b9bef943aee32963966922a8399,
+                0xc474824afd2a880c6a85a7b7a5a434ac422c7a63aaf8ddc7c4d9325edef40e,
+                0x19775ec781fd4089859f6b7f127c91eb83eeb7ec9eade14677b0a6b10b9e6e24,
+                0x20a9a6284cfc4381795e3b06837e9596815fd5b6f162bde02f97db687c8479fd,
+                0x20441aa5f4d5638e64d7ad9982b1bfcfde158f6a3cd6af62941e05cc8e533151,
+                0x2d3d269ee324e7c43c11aa84cd15bad65444ef8369df15749a8a6b2c8121e2b9,
+                0x1a5718f4a92dd8d179b932b0820f65c7bb93eabce398f997324f98ac76323b92,
+                0x8fd4397aa8b3a84dd1ba4e2d0eb7c6d1c5eda1f764814b5ffe204c8ec735606,
+                0x1a327ff2c46f5969fcacb463506e102d682502381fc3f999b9ffbd4520ba4695,
+                0x10879ceabc3ad045d76f6cd5b26b56dc47b512d6509458f9ffde8da79e6649cd
+            ],
+            [
+                0x2c99ef5e064147da9782b914a294b6c14d21ea7eec1f72e8761671069d82a134,
+                0x226bf94b86b177cfe7f03103d59e3f9ce2393821954708e7c723f8104a68c664,
+                0x66ab8beadae7bebd26a33adbd6bb392d6825da37a679e8af9ae8bc4813c3168,
+                0xc099861545e013a687cdd49a3a296a8d2c2e99691c2535da712d351d5e63c10,
+                0x1574c9e5caaa8a6a7fb4894d2c45d1901d1c42b3214fe9a72fd3cc668e399f76,
+                0x3a65a91d35b6e877908d5c419e7850f645f62b1c913765a214bb0f7a2915b49,
+                0xc073eaddb5d3f79e5bf83bac00f37700bd64502d8bf7d5a099fb3eff7d3b03f,
+                0x217aa400b2b625bc36432a545e533124f99c1cb98eb85df747319e85d530470a,
+                0x178a58ff122d168cd4ff11a47280a4b8e5cdb313411b6f6e9a947c7fb577a51f,
+                0xea45d22479ef5773e58b0fe740868fc1e8b50bff76049d5b6ed5e723711867b,
+                0x1c7cbf2448de7114eed701b041809034e07b946a0340b777268529d582c225aa,
+                0x2487df9d5e066b76ffcb2f0ca190abf5fc1e5872c4b6a36a46870e9159201010,
+                0x2c0cbbe46422917152ca1906462bcb5a13ef536322a8715237da09b8c594cac5,
+                0xf7c3f3cc96ceda039e43c86c1b680c77d6f49f50e94de23e4db42f8e9caf7d3
+            ],
+            [
+                0xd7d07cd3798f44d832a6571c21706758693e5e93684ce2d1a5e8a53e0cc6709,
+                0x25e311b37cee693545e2c2efc2043bc073552115b3a065cef13d36547b6b9dc5,
+                0x21b37be521835c32b673a31d71aed1bc7f3ea96fe1d4c23f14623a0a851a3cd8,
+                0xb71a06bb75b0a10bfd28a3788bf54a8a144b3287df9c591a2643c4100fe388f,
+                0x26ed5fff06ef9e1942bd3d0d3ba6848e47ec045cd26f93049d80cbfa6bcc73b0,
+                0x137908baac2e35e13f86834abfe98d1b54b7c25d6c85fc6c05ec7cded9175517,
+                0x143991e8386d62334ca0d87832a0845b48416ef5158c18e7b9db8cd6aee223aa,
+                0x148dc9335f621fff9c8d2fa72a9cf5b6febabe1f5ce77689c1a29e393185fba3,
+                0x256e145378d2604db8c509dda4552452b6c4a891fac5da199c7560768d948836,
+                0x2280250e212be2a48d293796a88ac62b05411012f46a66f87a0220a3dff3f79d,
+                0x9c89e06cad5430153dd52cc66ae4f521bf4145df048681beb2e06a385050117,
+                0xaad68c20fade1e3e2bf70fcef4b550ba00d6399e20d83402fe09b52ddcdf527,
+                0x25f4103521e36d55e418162ef8ebfec6d45695520ef47b8548ba38b52a27fbf5,
+                0x10bd7824fc1b883b3da0072d2c6194c4a1e5957156594e908adbf6e6b1912b9b
+            ],
+            [
+                0x29195117106623ffffb0af525c838686d0d97259fc73a5194609ac7b7b171313,
+                0xf2336e0eee4685741ca23828c34c24f073491f0e72c139610524a56f71aa405,
+                0x1e86ec086805bc7712b7510def651249ba1d491076241d99d00c692880f39a75,
+                0x14937879c4c7127644c765b6362f8b98cfd32f8572d7aad9cc329bed5b507a69,
+                0x59de873c59806f55114bc3f8309f9b64cfcba7434aae220447ea0e9c4a66da2,
+                0x1662f26cf04f5b969cdd6b93e890ef2b5b1124f51822888dc2167bbecf7c31e7,
+                0x5fb897d71edd8d8eb1f3b5c823a5882a06d964056afd532e6c88893a25f2615,
+                0xecfacaad0c147e0b3c7e049771e6d4072b02ee4d171c0e53224214d17ade351,
+                0x25f64d42a750971afcb8023070f6ec97bb2362b196a5aae2af6a70f2e7b357af,
+                0x20be703f86d7c0b9dad98ff8bb9fc92fe8ac0a84c6897a75d851146f74840b71,
+                0x296f3a9c104222692a44ad24f0f6fd8190027e0755567e9a7009ec71ef440ea0,
+                0x6301679b6cdb17aa6c212ce342ecf681ab7cd96bf0bfb93350368004d97c353,
+                0x7940eb04b61ec5341c1702f03993faed167db6fa2cea92290cd821b15fe4c2,
+                0x90da12e1595551d2500f90310b7701df97676404113c33e475b2e7749adb613
+            ],
+            [
+                0x1b62d4b17de67375b58f248a88dbf707cc9d1491bce0095644ca0219a01e40a,
+                0xd9bb7dab4a189a3b6990a5526c82b0ae50ba7dd558f951bb9fd343cbb4b0e19,
+                0x75d1aa6cd2b8d181c9e0f42275c9884ae6fa09186fe227e5c4673e56e3acd28,
+                0x28f9e0058ebcf1591bc007cb02ac3acde0851427db20c7358dbef9fa9c57c2ba,
+                0x17e39ccba3432a135c0075d720c649562ee4d31b6da2e9c90bd72a039765e73,
+                0xcd0a4c27de11aeb6460e32fa2bcb289cb83321723155304929eb0ca4eea03c9,
+                0x2745a059d0962f1bf0dde1e1b97e0bbf4c4143d10fd3fdeb8d2b295ee4d7a9dd,
+                0x1365a904c7f6721002dbce17077a89a92bb8038bd27af53333f447c4cf035a80,
+                0x2f812121e2eaccc7d51bf266398d5ba8f601a2aa6d335eb69f7864642177667,
+                0x21f8d854091ddb601dab1b01fb30c3d4f77cc3167fa3332c3b32377a07e6aac8,
+                0x18393505ea6230669a8030f6e76130a14c1070a901ba5b640b88ae80d7d30b5,
+                0x1e151fedfea11659c189a31ba27f2ccf6956084188eb2c4c99b827f645f1db61,
+                0x2ae1ec9e09577c82c97b4b09142ace51aaad1df7dc352cd4e5813d8cee9c98db,
+                0x24ceb0766de25fc22789286a09287be740310c41747320bdf2eb5c956e040356
+            ],
+            [
+                0x2e1681bc7c22d24c433f81dd3a326fd0242bfc7e2bdeb6307e4d2aca32adda1d,
+                0x2a4a6cc884cfd08af4b0dbe89b6d8e0e58113207aded8cbab2d075053efe998c,
+                0x142a83206747200fdb02773e766f504c65af82b200c0e7fd942f92be23d586be,
+                0xdf653524fff92dde8ec1c9a51c1bec30bf36a4f01e9b3b62eb13f8ffdf7b8bf,
+                0x2ae7f1414f1443735318163e1bfb1e1bcf5c271f37f6abf1aa86766b2e59e049,
+                0x2030b7bc2a70905d031674efb420336fabb0769ac0125c35dfe2ff372c1aa4eb,
+                0x12a710de6d17f91af890102226853bb64209f1b41331a1d17305bf5b7b52172d,
+                0x1fba713b98742311dfb3fa356ff83eef234ce8bf2b0d4a52de7af4d2519f2f12,
+                0xc8f8722892a2f06c5ab454e407bd557e9c2ea77ef807ee0e3d89c6785b0d33,
+                0xdbd093dc16e73832bde62d05cbb06f8271fa47229470462d8c18cf8a124f9eb,
+                0x1dca3060a6bbc4c324f7efba22274fd8d1f2560a4eeba8c8b0d38997e0d9c46b,
+                0x291bd9401de20916b9002a0066114b3bfae4d3c8308aba4afdccdf0aec12d66a,
+                0x1c97fc775f962fe05a7b66346b93c3260c8f6a90a7f5c63223a3386e19852ead,
+                0x1c7dcecea59e6f7beb6d702e2fe74588415d30e5dc09970bb2d56acc8e08328f
+            ],
+            [
+                0x65850d11d0eca87c3697b6f5e57f78ca86952bad1c9047dbd2eb6be9e9db30,
+                0x1eb97819b3531ebb640ed6b42134335419101d1db60dd1a924ef9665f7a91af5,
+                0xee4683c8da536b6b50773a469bbbde2e417a1cf9be221520af1e755968d7ff6,
+                0x2dfcfb280a3d372dbc15639eace45c0bac562c44e292f1429bc916578fb0bfd,
+                0x12ea921acf5b8adc6a4e36be85713576d658099230b0b1766c666f12d92ab142,
+                0xb5342503af446ef824df4df6a088195fb67276657d420e6f312b2628e922986,
+                0x9265fb314a676b6b3f827f07283a1ed4f300e8d90f967b20ff61f455d2ab2fe,
+                0xab913f65e1ceb39ed8b83bd5d7fd900e78511edabcfe62314dd10d567858d8e,
+                0x407d585a6a7efb561377e5f3972319a3e7285e146c5499ef6c8504a3d0b62e3,
+                0x2ff5bbbc022d1b74fe184c064e58d967f1aad1f0926c906a5e356cfc3b81ad24,
+                0x6da6d88c233e3182c5fa5ccda1392c0f89f7c6bec4e60da8df8054807eb0922,
+                0xaab27e6279952c7291f036918f0b279d3b1d9f8e4e8ac380da77ec2fc24ea0,
+                0x27737fcd76dd296c28817646d30b1168c4d00e1f764c4565caa3276defd15c7e,
+                0x110a5e84de09209e9363c03c22b537ac6a7aaba2f6a9d1a1f6bfab71a960a583
+            ],
+            [
+                0x1a59b36b94f9d723577e504d600c493f2810f0e67112672c743abbb13abf43b8,
+                0x226b91e352c65de4fcee112445bff20e4a67af0e110957319b2860d5087406bb,
+                0x168e771e9f8f860c49367ef919a00d4f128bab01c13d7dd72ce8d36bc6d1d835,
+                0xb345890b33c23d167396c583d12e4f3d9efc904f261202512350190ab1961c5,
+                0x1815d4c2e6a18f4f3fa538a004146d7f540fbe80a4605857714fba2795615df9,
+                0x282a555f9ad4fb57698faa1fc3279bb8c28c1f8dc8c693225bd8520db4313489,
+                0x148ab15972a6925b714602710fe9e64c0a015053acb838d0e876a46cb5653f59,
+                0x8e13c2e61c446b53024d2116ab176c843600d00e676402c4641745158c243f8,
+                0x11cb83e01ff5803b049a2b59ae9915b3e0045e1db694a6df9de9c4e7152d191d,
+                0x119816862c8226e9e5dfabf3167b3b2bf7fb3d19063989b24a16d97c94bd53d7,
+                0xc61ec79b106e9dc6494a6359f175ff637839ca53ac8e7a13471c56646180390,
+                0x1e8ee641308ba6fe5600b2df492cf2f14f9892ba1025826c53c77aeb7bcdb04b,
+                0x16b61b242d41e1975843309a01a36a14397d7c8e7beb4afbd9233b453aaccdba,
+                0x13822dcc3f6271b71549c2cd917b859cdac36af6848804d15a354d4de0f67ef9
+            ],
+            [
+                0x1a4b186b77cd53f961c8ccb7815d9781cef7a52af64d0bf746cb522512d3d0af,
+                0xac5b86128ee47944c12af531cf1458042c35adfcd9e5b6a7531973714559de7,
+                0xc2a439067121449c1ef3dba6be1ff84f6ab7fac4bbd54ad7539e61826ca1971,
+                0x4f7f1fafee121bb811344f73f54f4a3583076739dd9dfc462b3ae6343c93cb0,
+                0x18f6c40e3ccf885804b374433af0a962b2963fb9aa01e8bae8cc834b3e17a31d,
+                0x174c1a1095e95d4f098c8d60826776c2f73691db37ec3b937835b65b01ba13d6,
+                0x1f7f9704cab1cfea2b2471d579ef99d193b234af90e62ca09b5a671c2428a515,
+                0x1fa02616024cd9bedf643ea36d262d1b24f38a557a77a82c686618c3c33edf9,
+                0x2e1c292e06b7f8a6e4344f10540675a63ca49e452f69565fcfbcd43bac0f3af4,
+                0x6fbced52576a913e6cdc5c5c96fdc8f9f4e931fa90beeb46d9b3c2d775e1e36,
+                0x2cec67e62320bc6a0ca32518ec81c74363a4b6d259bd275a63425d6cede468d8,
+                0x276e2623828949e6a2fdc917e2ed45dce0ee503cdaffc9add815f6d1d3c4f9d5,
+                0xc75ba60f8e0f6afa126e75703b83d9908116147b8b2db45ef24f3156b8f1855,
+                0x85e380905eb2cb7e753d0ab0ff4918b232c734418b6bfe1331de492fc76b21c
+            ]
+        ],
+        [
+[
+0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+0x2525da24e1d134d9e989838304af65260bc9e8f31225ca603420c6f22782a31,
+0x138f42d30ae01982ed697be56da923021ca5ec09fd9fdeafecaf1b815a8eb44d,
+0xb68eaed660cd2cafd2ac447e6b5f44a4acc0acc59379fa1e1d6d6c23e29fd18,
+0x23a87eff7dac26756048b8a99cef16bbd4ed93f085177da15c763bfbdd413a72,
+0x298b224b535d0d32e971977b9fc2b3f83df09ab550af80b838c2e1308a388aff,
+0x21fd7ef66c4ff374e85b552f0c1162831af7f2e1feaa30e4d42c9ffe585e730,
+0x2a75ec0f43bf0249456ef5cb1e58b4716e135e1033791b706c1198e370cf5912,
+0x217005316ff983a988abb4150d5b89fd58f5e7ef95d275207afab9bc736dcf79,
+0xd200fbac6500899253294ec3394f5fc2374ca3e3243c34cd97c5f8f31f78edb,
+0x225829f1730cfeb97ccdb5b1df418bac0f761d57293a39d5ec293014c78f38cc,
+0x17b09625ab3ab20b7be3da6740eac6450972d5297ef55ff4bee47857841685e1,
+0xb98d9ccb5cd1979a0c45a9ff8f87be8f15ba1cb758c602775d2a5711dab8f70,
+0x26c6a596dcfab11f05dda86122034b6f2046c51c0024c4c673dd93c63ecca6e8
+],
+[
+0x12186bb22000ad84b6bf29179ade2d4e7e94ff07e51627e09580571061fa8ce8,
+0x945c0594d96052f702d1c0c8d423cc5f054bca11e54a939531e5c6616696a8a,
+0x1a8993400bafdba532b42fe60fa719ee2bb70744c9684c87431ad462b69f6234,
+0x271684ec4ed2564694dd8fd7f7ce52f573c22c72e8268ecffdb3f3256cf94d86,
+0x199d5f44df92c42cdedb75daae78948bd1b812ef63e72c6d01d77c9d513bc32,
+0x1554c7a78e970212db02a0c7478c02343ddeaf350d52ad460966c2198475e5d5,
+0x222ab7be52097210638f70d1bcf3ad6842230e0561e1ae556519ed6e44ab56a9,
+0x391e74d9ce9444812f42cfbe156e7403ec00c10888b716132c819542982da3a,
+0x145f48fde51a4c7f0469cca2a20bd5c5794c594c08ea063412b82e4c21fb67ac,
+0x1c346dc47106b6a9c0e34f2b6a59aa07c0e23a7f0dcd72f98698b6bbe2440a9e,
+0x1d881f9bc6c0a69ad8c4cf8ae0854f5e39d7f120543ee72fc776156a6dc41e25,
+0x1d6405c7bbef29b6526df75b9b3a43749f55a7cd60c2956e61ce35446a14055e,
+0xe1f6e07f1a7310ed0af6b08fba57b93adf17ac40ad5b334a7b5b8d2b21822b6,
+0x1dc01119987d2a025898bddb1d79385b99960e97c100208b5e992d9dc74ee608
+],
+[
+0x2399faa648aedf9024c6ac3ceafea248216e24a9e56caf5acd29ce2546a9f6b2,
+0x14a0f9e89a7bd2f9e93a28113256f5909e18bd8f2d4c6a4b91fa764f5d6e9813,
+0x223cf3744fa802eecb6e33bb5d345a4e2e494e2e0868296a075010d891596cf3,
+0x1cae3329696575edb1c98df16a20e97a0dba9988601fe24a6ac327233edbd7ef,
+0x2d2d2d79eedb473fc052705abd07b5d7d13aa9a52bfa0a34b29bccb2768ce812,
+0x13d95f949c83e09efec7464df18f95b0f569fb43aacf2e2b2b0d1b8d6a4ad5e,
+0xdb367b50c96c5ad714104e535fcde5cc2d98a7358dd85bd98cd4e7398985874,
+0x24d565383969b188f2900ee27741e48500dfaab461965ccf6acc7290c5c07b38,
+0x2c08d33aa07452ec8d30fed9ac5f8218885c18de68857395b7361d06d5d50c64,
+0x2eb969d5960104432dbec4c924f829411bcd4eb2582508844fb46c57e4b971de,
+0x1899d3ef6a66651b27035f47a0030d77085b988bfb2595392d46a09eca668e9,
+0xdcd018b542eb51472ef63566573192f167b8a41b243d2f9cf7efe0427bdc769,
+0x1e76abfe0e0c0907983d49bc07cd22392c9a9fba1cad773f87877d8514e4103,
+0x270775b57362a96f142cf0560a3c1f28f8b8f84b1695cfa20b271217cb9460b8
+],
+[
+0x3add29fe398ed2d44f233125ecd1509e3cede77e6be08b94af4fec87eb3e48e,
+0x292e485c257794ef8e1fec5dacdd6ca69f168408249a6e203853615080cd2cd5,
+0x22a26c25e3631f154c6447ba2e8543b1d0f8454bd027168e715f21c86d09d399,
+0x2013efe5dd2c054f547d532fd6f38d63bf3cdc07c1b3beae0b830c536936dfc2,
+0x10b99b04d7a8e09059e28c723db16cb75528957858c3f9988f0050d18a30e660,
+0x17e35329c9aaa754c345d6eb317c368788b093ed1d2d136714ea1b2f793da580,
+0x28ec7da8ea43b28add669ec05c0866c2498ffe99bfdfbec896bbd70d08720f64,
+0x145115518f4ddc7a878c4a4c3a0cda353142b420cbfcaf2f2eb7d67c6817ed1b,
+0x21c96a22d60f44c34f543b5086ab4fcdec036b280b9f5a64a3a2003a2a79e906,
+0x2fe67a3792bfa46545ba3633c2d504d9735e7d03b58f9208f584a3ffb3f04a82,
+0xc27c0b2f86856b2350007a8501222d7c7d89c02919d2a310032c4ede9da6d5b,
+0x76eb0679a3bc5901abf1204e92462dd0049c8b80f0d0b110ea12ca6d9da5808,
+0x28b6ca5d7278ca2537b3167bd0e8c8094a06ff3453e060a1f52f077ce3c0f9cb,
+0xf7036425c9f4bc087576419d0534698adef68a0ded0fda90b211bdcda6e05d5
+],
+[
+0x121af61f4dc5bb24890abeb9251e5cea94770ab062dc0c28bb8995dd8f183635,
+0x1b75bf6cc3265511f786609179f18b582a1b6261e9e6a9f05ac7e9a4bb015a3a,
+0x26b90bebc295253c79bbc8d0324cec9805f3730a7c7e3c8cfe7220cc90b2ea91,
+0xca34892eb7fa3d7bb497043be8462cb387ed055f83566b165a7dabc75bcc623,
+0x1ce0f7ea351be6aa78e3ded0a3d69d69de3890cabc1bfcf40583226decc32d54,
+0x1b5b9f9ac26a2e054deca324c9c92bf4d64b0b7be729631f2350c4db32232768,
+0x94707149dc563db7a45c5cdd80091c3972bf52a6ee3f8eaf0e6bcc6ac0e3976,
+0x25ceea2ec9fe11994d5d6c2e2af196963dfbe8112cfbcdb49c5b80615cbddecb,
+0x2952f32d846a2cff15c9f028f02fb60bfcd8a7b34ed120ab6e393a1ec2794a4b,
+0x930264343e7f5af2b7e5a4f7f25d0be85825666a68d5c02c5a813e958c3253c,
+0x3f289db20976c1ec1aafcd0daba9c386dd8edb8e577311dda9ae8082369891a,
+0x183e186c2c72f4a35c4fbb1eef8237e1aaa2379dd8d61facc59d6e5f44da0a83,
+0x1c921c4536be42aa8a93ec0ab11a37231dcbc0ca9ab7749e3d5cf9913adefa8b,
+0x8ecaa57e55d210f56d9c8141f70394e59185625df57435ee2cc924602212203
+],
+[
+0x2ca8ffee2d58f2945297b00cd0b511da167080d53949b3f1fceaca9616b6143d,
+0x23894e025a72e4ffd1580bfc4748a2725ab6f214a8f84e40d266e5183c6db8ed,
+0x2600d56e9f728b982f23746da7a2993bce578e7204b9edd1f474405bd7593103,
+0x23e3b3568798af43a561614af2c8aee40d2249d9f58452847c453594dc8f38d4,
+0x2145a0959a46b3c43bc559b8811d309d48a452423025b85cbb3febcb24f4066e,
+0x2f172acf4fcd26f6f939157d0da15bcbffa981ef6b22f7525c69f9ebf801192d,
+0x28f529934ce9fece64356acf523f32443178669ff77a0ad6e7b86020e413ca4e,
+0x9385ccdd032e8784bde4412886e9a590ec85ff5cbfee02a6c5dafcaeb90250e,
+0x2a4b9eb8b2f9e4c4f2fd334185a45d0d2349163bcd7b808815b2e89543c09412,
+0x3bb2a5b659f1f5c2c82bbe5824ad64a260e21e688f5fe01c61632fcda348adb,
+0x29e0c22a0db446552403a18473a2e5d923f0d2a81b23f593877de4657fb1e877,
+0xbb85f352ad58d8e5998cac57a0fba1d49349aae47164fba3343ae32ccbe4206,
+0x24e9c71c5607519169015cca5f0be8e416f21194fc7d610a38d3e48df56dd40f,
+0xa098b67cc231ed6a2b72bee29f823702b67dd0bca78f7316543097856b478cc
+],
+[
+0x2c99ef5e064147da9782b914a294b6c14d21ea7eec1f72e8761671069d82a134,
+0x1605b0bd96a60af6d3ce4feeaba7498571b693596f79c09a3485cb6e37b1480f,
+0x1b322f4a92d336fb2b92e1347e0f73037655b344fa6ceb1275eda5baabf61dd6,
+0xde44974e91df8151d38ddb337dbefb7b2423f8c2db33c95249664256049447e,
+0x1cbf2e32e48308fd5254bc8466ee1b448825badcd0d038171d39d77bd61c122b,
+0x1e25aef828ae1b75374d1806053383a3afeb4c247bb3f4fc602a31258129088f,
+0x28796af2b46e4481c8c68767d755b2f28c2229892c093faa86ea6daccf4f403b,
+0x2b9c2881bdbbcab60ca2981c28b4228f8ad48e64a7b393ef4ed080907e6a1774,
+0xd00d400c8809e16db25f2f1593dba403ceabbe3d0b868399bf12c1ce2a6284d,
+0x17767169e7d1636e0cdab5d29588e903e1d4343000d5b54f3e523e956af6fd58,
+0x12e4b3d7107e8bbf73c227c3fe04ddc9277aae8cf8b15a769c7039d282661866,
+0xf53bacde9c9005381ed7bd0d3a35048f9b04d99b54cad41bbffc9704a574abc,
+0x241e0bb48bf63003f858adf8134bfec90214a7836f7af1bdd263f5ac91906803,
+0x106f70b5c82b6a41e401fb3c05ed0d4a5c1d6ab66ab048d2a928a323556632f0
+],
+[
+0xd7d07cd3798f44d832a6571c21706758693e5e93684ce2d1a5e8a53e0cc6709,
+0xb6ea459a3eea9912c01005ac024cdcb60d77df03bf6d57f9de9277855f5669c,
+0x26f749e039b1b58e9fd714e0b5edbadd2ba23f0faece28348ab8eb36126e4a7b,
+0x1a8077b3370f7e65d450e0e536e1e73c9ce33596023de1cb2d4f1321896f5184,
+0x2f6784fa0636348e5b73d52307c09dc7de28dac12256995b7d2d8014be1511d4,
+0x1b4e7d76dd8cbb42c1e90574b4f832a07a53912dc74b2f1983440252c232ab0a,
+0x9367ecd533634327435fbb0317bfd4de720261bd6c77f2348f0547d4dcd155f,
+0x290e7fdfa796c9a6a1b3c2e6d746601f49febda2af0d2e7ede804b822400e81c,
+0xd532c4429d77c08679ecb541865f7230787381786f7d98d62a06e8a7f33f3a8,
+0x78ec6b19c1d89049a01ea1a959df4525e1fa2b5c6d9c7fe00ecd899af5b8693,
+0x27932ea804885d901c0a89103c29995ef207e753574a7ed679b162342c54f27f,
+0x20fdd250fd434a5fb9072c597b940cc96fec2986fd603526b2becc58e431c8a,
+0x211dd323ffb6bf1f7a0c747597593c44053c3d5ad428b1145d04f0a728f4199a,
+0x437b94aeaefff8e636816d1f7484e12de60de9199fe298c3a8466036fde9053
+],
+[
+0x29195117106623ffffb0af525c838686d0d97259fc73a5194609ac7b7b171313,
+0x16be4a147414ff8080b2a744735ee85e2327c3645e26a4d21846bbda0f5f6ac1,
+0x15302004242f418b70c701b89e3585ac1d2cef27046b512c7fa841e1c7fe564d,
+0x103099f79452ce6c8848e50bb04b50723aff5ef915d2d7ffa0b8f72bfbb6a906,
+0x1cddc847d2f8d9e6c20ff55628cc4e9cefc59a283a38842462cbe60a9a1d0336,
+0x29bb557aa48769cff8a9d0ab0e7149f835c5552e5e5ae7e6384043790e45c1ed,
+0x1cb2f7fda98a18a6fd20de6fbf412d07f0f41fcdf2088dfcd0e0b852fdfb1aad,
+0xcddfa96db02b40d78f740716d6aa26c2c6cf125772a9835c9a34a9046702db8,
+0x1f0f734e95a45cf07b70b85846b65ffd3c1eac10a95e0b917f27ce25c0ee4afd,
+0x14ec222b4b95c3b602c222640d8d6dcae21dabbf1e805637ec3bfd8984577c08,
+0x18f31da4274218b2691aba9611a798cbc9e9405f111267cbf424a67799ef67ee,
+0x18a38fbc04f4e85a687161544a2e3323bc7bf504a5ce34e8ba4335767cb4eedd,
+0x218b8f679b6f2f6070519663f49d69fd9043ba6d1bcd7b7b85e825abf8bfecdc,
+0x1a3d570d5a331ae41c938e81e8155ded345d180ad5ba49b4e1bb70eeab467a36
+],
+[
+0x1b62d4b17de67375b58f248a88dbf707cc9d1491bce0095644ca0219a01e40a,
+0x23dfcb4155e378ef7d127383d66785b33808a3223e22a226a3e3a0f7bc5200a8,
+0x1bba25ef90c2742d6bab9309747fc14cc73e4024c803db5e58c7d2525839b2ae,
+0x4b3c3687111107b6b39fde1f5eabb0de5e2fafb481c0845f0e9e3e5f90057b7,
+0x189aeb454f60721eede010a005c4ce55509f152e6d0e93e8c5f9a9a6d3adbbd3,
+0x18572091465cabeb96748f5482d37d3926bf7c1d6680dc932f45f55a7042b02d,
+0x1a5ccf7ef451a14b3fdc531a52831728f5ec26b86ba77c952701db2913a698df,
+0x152f38cb9808d5c942c23624abe88852a59f2813392030fdb7b1753025829991,
+0x9e543a62e93aa3005be9112a49c5308f5b6f79591b4824f6355ae12300988e8,
+0x1a145f49ae38f332ad67bd90734b8bf9d97dbc5912cbac8f57417e334f14230f,
+0x8857c8b3f0b9a7649805371c01a74c84c67575d9a17be0e5590aab52143377e,
+0x25fda357cdab4ca130314a01d381febf812c14473e4bc9b13ce8849eef1cbf96,
+0x27b831fd2727802f6a873109adb4196ece489fb5b48113565d8113427aad42d7,
+0xeb8c6eb7b2a00cb45db63f58e55d78f1130d92a56095b485c662be692644733
+],
+[
+0x2e1681bc7c22d24c433f81dd3a326fd0242bfc7e2bdeb6307e4d2aca32adda1d,
+0x22415ca10b65c83a039f1a749e649fbda0cfe2fe3403477a40c10689ad5af158,
+0x21c92d239c137b9a280a728acbd058a8c75f321e0d254c346aef2b0f3390b07e,
+0x41fc409e13a628d9632b87385d24bf4f2a712e3642a36c9875cbb5e90028065,
+0x6850ae560ad9a7e89bf454f4300cac5f5184453afe49fd3552e63e44e72ac55,
+0x291f4b78708af2e6d2021bc67b8b43177e7c0533ae1d89287612d85cbd16a4a3,
+0x22aba2a6f80e91b2b4912240c72983f027a4c158910c03cc1cff66c545f8750c,
+0x22e33116da2228316bf3d68b2f1506bb5b5b87ed556aafe4f1c1638f723b0a5d,
+0x27885fcd66e6a1bda1f55599328bda53f0dbbf8fe39d8e025fd500e44ffdcee2,
+0x28dfb66df089941c1b64c42f01e015b5f3bf8764452add9b24f4065b7d276244,
+0x2e5ffb493cfee9eeaae1200f360829d0c2c09ddb592d37d0821363aff6ece299,
+0x21157a29f47613a80bdfc774d1c8278abc3f76e15937ce9b24176e1b4c9e3b7e,
+0x1cc9014506211730afa1e9e45c9f38b6e6218ec646e79dfd38ae0cb8d96ccffc,
+0x210396c1be722404813dca0f052e321e183c00dd1671044b18bdf1560b04ed6f
+],
+[
+0x65850d11d0eca87c3697b6f5e57f78ca86952bad1c9047dbd2eb6be9e9db30,
+0x854fec1c464e2fbad9ed6737f451f4ea27b6a1d97349941928b5911b5b7e3b9,
+0x2c240af2cced1a6d0d5aeddc36c875d3a8e74325772748ce1cbd5e01801b188f,
+0x804921684796339f40259855eb51f118262da54c1ead0364ed73b7b6f328dce,
+0xfea56a59a68a9d3131f96672be04f078937cfae01bb185c074be5f74a37b226,
+0x11f61a3860411316eee42dfb735b05e0ab5a905a2478b9d446acd0fb1403d00d,
+0xa80fee34581fae3188ac5f2c5aac9493e6db12ee7a2782a036aa65ed89f3825,
+0x75c8623c44462e495ac4b62536c790a89875e9fb559e29fb51c32d6601ef297,
+0xd4ee74163fe389031e01f793b3cd7f76971649372ef075dd3f2596333c5a6f8,
+0x2a06bde137eb0fec584cfe2f11c2ca43be25ba8dc31e0522191cbb63ffc50b6d,
+0x237277467500a6589f208fe577a0ed6bbd805f5bb1fc0543a22f21cb98b46108,
+0xe20cd93d855c7f14979bcdb315d2f9891e09e4099cab4f82b66481d013eac94,
+0x12dfaf2a058c0890bca0bc89b72eb4a575f10b43a009c6ae22207149884b4638,
+0x299298324b7b1e7cfb05fa7c62c2c471b5a8dcb233f8c9e1becf67d8bdcb4416
+],
+[
+0x1a59b36b94f9d723577e504d600c493f2810f0e67112672c743abbb13abf43b8,
+0x258e09e408d6f662f3539a649aa156f18cb46302fd0fe34f007b731db06825ac,
+0x2049f9cf12d0e210a7d82a56694e58c76d2f1c5ac572aaf9b6fb770c09f8dfae,
+0x2d4687de2ad43600f6852c2a191cf74d0c3e4a7ca0506f974610833fa201a72b,
+0x2803e055305e45f9ba2d154206439c02a37e8a5c3fa8eb38d883c75137d96216,
+0x7ec1b96a04d4eb1f0728f1fa0493019c6f1a95456997ba5003bc2bfdcf43ba0,
+0x1dece2bd9b515875c114246d055fbd55492a7d26aa8022227192600fb17c8c82,
+0xa1973619cf434b77422536477683d092d710c68a3644946e11dfc5daf4c3e35,
+0x1e4a2c836090a5c960931f020bd616629e93cb093ee02285f8b9d850a74f8b57,
+0x2a12cbb75facd8548f0d464d85c961acb166b73aeb3422edcd1c3c0400824673,
+0x2ba25258891906648372370673f8b9701a7a17f5159c26f83acd03dbddecb683,
+0x19e70fe4bddddbd1a2010dd7f35ad802004b8486a6a1296b75fe87c2c5246908,
+0x27d1991b6be57840c86c76792fd9c3b44cc9bc56569d8f5d78012c17c9d01b20,
+0x26a6b81d5d4c3e4df5e93aeb39266b56a536c153210b9f4dec10ece36e3f9e
+],
+[
+0x1a4b186b77cd53f961c8ccb7815d9781cef7a52af64d0bf746cb522512d3d0af,
+0x8b39f702949a0a1a5906339e83e663519b264c3039aba4688bf2e3788b3ecb6,
+0x152877c59e07350aa9f0b36db00c436234c76249dd0099607b03567b4e7f056f,
+0x1156a55febc770d3e72337b4db1bd2fd680594a9c9dad08777aa5d898510e5c,
+0x1e2cdbd10cd7e2993c0a41fb073400ff938f590e30b3db6855f12c129d681f12,
+0x4f089c87cb7babaf031a4d0d0f5c08e00bfc99cc7befcdb22e55256170cfea5,
+0x2ebc3e6c61ae6901d3047afb5095d5f86071a28026a7351945d6fc4626c2f1f9,
+0x230959791080b2d262131ee7b43c2de9422a9b3a59ee1241e762ff0da380856c,
+0x10bf2e728bec374033c31e16bab6772056a1ace43bb4c3333a086256e0ed9d8e,
+0xcf6a0317dc98ba7fbcb0dcef53d804271bb932225cf3c2fb8c0564b898c13b,
+0x1306e43717156fb4e21ac64165dc5fd04b3f5dcbf52314fc0c84d09ba5b6578f,
+0x9a6e0063c05651d63e8365f4e17415f0ab59d07df4916e9f3c6f649c4f10250,
+0x211a3b4e93de320852f06668c192079c3d65a00de2a7cfab966ce0fbf9322ec0,
+0x63781e7bb64e40ef54a4ac17d47785b8fae5da0c4b3bdfe4de8edbda7029bef
+]
+],
+        [
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1578623ddfe303311ac327a432aee9ac8552cf37d7be9b4323c9a792c5776c4,
+            0x17536451518c265209c2d9d8512a80f5abe4df372bd9aeb5eebc2b799fb1d978,
+            0x1025b7c8b5b38ccd6fff7dbea3215f6a1cc80c64973d8972c0bc7674c733a157,
+            0x1a7c14617cefb39cde217f3c2583bf35d538750ca9818e2f04268322c282012e,
+            0x27993e8fd8e80385b78a6214675405361deecbf2c86441634eafb7c99fcdda8d,
+            0xeb7c2b5ac700501da181caaa6d42837f6f51713924eb3e5d6543801ee3c974d,
+            0x22313b179534e4b6af14a56f8eec32f02c41988093cc7f4fefb281956250b170,
+            0x277988ddf7fa2eccfb2560b2b169e12a48dd0b3707ba3cf1c0a514c4852ca68,
+            0x2aff90506172c4300c94d20c37a877bdd98630c899aaa00bc83f1b7d99e6c943,
+            0xad7537b0825edcd460d01970323bf5f0c336d57b4ec04b155e361068216f859,
+            0x16573e4361e87edabb67f04a10a84b8655a796aadaf0ace71d282a03ef73369e,
+            0x7befd625351a2e970860afe5ef0eab07dc7dd518eb6145de77252bc4769a4b4,
+            0x250d2c639105c9c5a3ce4b6df01973cc41819fb85be886084076f4114fa0e654,
+            0xcd782c85933dd07ae0f3f6b0e3c440acbfd915c2fd7da79cab1cfa57f634f4c,
+            0x23b6198a0c85767848c17cbe8708eb23bf53938a60a99576e4c2a7caca25d18a,
+            0x1f7e50e68a089b2286a3ab4c8764b2cb8d0da8b26b85c0f3a468c781f7cc114,
+            0x258ebf40c08515d8976fb6d05da5f7a43455448d998e8682aa49acf25a307d24,
+            0xde67b3b49cb60cf0f2074e36325065707c58c2fed40ac7a1e2856a8fcc3211c,
+            0x178c746273a2650cb608c7abed3bab595e8c1403a7d01f8a8d1cb4197e3e96d5,
+            0x2ab3c9a0a6988f6fe5e3739e7ab333de77084e6177b0778931f004083f807de6,
+            0x2d86755d3a375e8b14ef5aae6e2eeb5105e7ec1607de4d61258de2617f790ea,
+            0x196725d332dc50d6d916a1a6347fd70973f461d2a1fc2b941ab891aa04b3f5e6,
+            0x132d62cf82833c79ff5136eb2e396d5719f76ec0c556565b5a7869234afda829,
+            0xae37c618053667860b08f31cd97e4e266191da715708bb84444741d9eb591e,
+            0x604994f682990576a6e1c907633bcae2b29d2b91ef8af1911b41fd3fd168,
+            0x182aa4ce666d170a3aa6bb17e7ec00bd00dcbfebd02f3fa500e8a01d6b094a49,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x10f8dbfade79085f2d9cc0a15334272898e50848407cf0d1b6866cde260a043a,
+            0x1953bff54ebfac7d02d5cb8e079d56c84eed51d6f341dea31c6eeabf1a65967,
+            0x1344c0e662baa299ac79300aef7ef1387b1926b0c323ea279be046775a8ead2d,
+            0x2f027dae71476ebb6b5f3b1630f9a92126bb31a72e50cfbbe9e19ba8942feda4,
+            0x2b5570a23123c5568920deaa8d1f8882ecc0404bf73bec01f67562b600568862,
+            0x2485dc5ae845e8acc0c38c7ac313607479e4ceeb25f35ebcecab10d829fba247,
+            0x25b7907ad098b9a7ec9773bdef17a1d315baccf502a2a303ae9292fcf24cf86e,
+            0x25bb66388a0f8630d499fd04740c16ae3f6f8481b2f9637a370e921489558902,
+            0x2a00221d8edc58656999ae7406d58758e795a9741c004d3b99e0624d1ed9651f,
+            0x41ea47bbe1f576a1bf165e9eb6c82b74cacc22011c02d1295aa68a734108477,
+            0x2fa5eca22a4bfc0739f0671dadb74de19a49bcdbc6b23b3e4acd659b3ab7e2ad,
+            0x1a103aceb4a30c1289f86ee6d359ee808a1075dbaa86a9b590da829f89e0e56a,
+            0xea6e1b215fdc970b74cf8f31e3e78129cfad0e545939cb6ea55b4e72f348838,
+            0x1017db78c2c1d169597ed69a3dcd02467e30071dd418eb6e9db209805314814a,
+            0x22002c2422ecc59939f303b6e3d02d35aafd288b4f7936838314e2047b669672,
+            0x7c83bfe3e0cd2efa62ff8cdf694ccf8b3268c2356be960335b45c9d57751940,
+            0x256b5d75847a3cfd5c4a79c7890ff08c58b73a31f14bd07247241b70e3b892d4,
+            0xaa8d8fe4f42d5ec00f582f56d0d64aad9977a43b185d66000c139614d9ea30c,
+            0x221dd9b914aee821ea23c359b337345a22da01eef81613e55c97fe275b42c4b7,
+            0x7a71841bdf7ee0dcf51ae4195cc8adf79be1563616fa5f6b5d932eab3cf4d9e,
+            0x3f7813649d46bcc7419f8ef37cf29e9b486e285da3045d96b5e3c6b636643f,
+            0x2e4b8a3c581c527e8a12b4778ff69d8405b2dbef389d6bc8ed143f72cf2e3b89,
+            0x17c1a87f4f960d913f5eea140959526f4c8ed7a7fbc2744fe37ed332e26bfabb,
+            0x2c46585ae9f6cb77c3217988da69423b71724cff7fbd8cd879a0c4479af148bb,
+            0x2d54300c647a770fdc4340e7422d79b643596ee6ac6f7e1b3b6339022a1768fb,
+            0x1bfe46241f2211c6ed0e7723765850aa6da18b5d6c692d33eea7647a73d097f2,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xe2cbddf65c2ae0452e3eb2578ac21a1e5279c42481e4a41affbad2969721705,
+            0x16ac1278c3b044618e61a767b13dee22fe364509ef89845b2fad1a47c2b9b5ad,
+            0x224149478db068fb7141fdf2746d34283ea9e42313f8bfa3e9dca597a23ffd95,
+            0x1a8f0b2c1be34d3d04ea78b2c38118f6e05ec781ab95c964e9fec00e9da70f45,
+            0x9ac6d36b9a63d40259a98a78c9a223de633299b75cd49a944ef361e6f9fb9d7,
+            0x12810af0ee251f24fb86894b758bc4e0db0db4522260a9bd5406baae536b23e,
+            0x13e21a7cb8f49dfb990df144ce9b950ace2762a38331d90bfd5121a7d8cbeaf6,
+            0xbf46bbc35ce9bab54a45c3b9a308df40b6b771b3a0c82634e86f0e8369aa2e6,
+            0x2d3905ba22fd54bb55e4ca78722d0c3c6d922ebee33c024e3b530414b0e27819,
+            0x21e94a20b029bd68674fbe1179ca813dfe61b3ac9a2cbec68fc63f4625ddf20d,
+            0x2eda11aa8cf8a13cc36a5ee865c465bc8a7b91e41061abe33ba2a48945be03b2,
+            0x1e86878d1a99e02c9108ca361563f8120dd46552dee8cd864599bd965905acfd,
+            0x213f9fb0da20d21d4bd549eb2cd60f2e951cdf11bbaed2e8347637c28e90dccd,
+            0x9ec04662663c012175d047b3badb9cefdd56abd0e1bb8824f8b1af84c81cea2,
+            0x2cf6e22ebf6b69c9dcfb9b5e66d03f2c9dead8b168be2671fa0c900dc0349c62,
+            0x1cb3909eae030fd0ae2a623232e8daf5a527642386e6a1a5cf8cbf36e49c9f41,
+            0x2a954bb1d6463b7b6723ea7a79b331b5201cff98ebdf77311f8eaab7a4bac880,
+            0x1d232685a73dc553d0e1b8099acd8936bddf42a40813d52edb2ba0e2a72a3853,
+            0x252d7955742982802013cedab484c8d461f9315fd6c30a13a076ee1fd84ac652,
+            0x2144739dc6440cf4f08908cadc61413b30e9fdea3d600ff64f05c5afe2742a52,
+            0x26d2ef597c02295f490a26be40bf56c9505e4a977f017b0ee1b4539bab40f92b,
+            0x2effc6807ad79b837e532bf4a9f65a83f920df891e563011c34c585b8b5118ff,
+            0x2e095a7e1c68ccf1cebbfd1d9e6b10661fb3cef485f2ecc8dedeb107be1a99d2,
+            0x226f0b52596d08e12c5d979f74cd74461c37b9ca4b74c2d3d72a467f682f67a1,
+            0x27e4dc61b7f4c719754040db80c2c2103197f34a54a5de92fde3460eccf92b38,
+            0x2a0121e238a13d0dfb1507f0ca6c1686f838aac334cc1ecb2f7d1ffb7b89c130,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x33c6d4d77acdece9099b3b1c2820a64c2f753582562ace2cc24fb4bf2099d13,
+            0x8158a4f4a451c60b9c190787757dc064f45712636cf0171e54775a94bdf1954,
+            0x1d18e0af711abc6617c0385617d21b4c1896f0199ba927f33692b3c1171294cf,
+            0xc8ff9debc6b5b90f826623c99e25cc8ba5b83f810b1c2be42298e445cd1e516,
+            0x7455ff7474bf2511d200716e916cb97e0842864cb89a42fdb87a479a63f5055,
+            0x2b796bc4350006ffb852f826d4261ff6fc792aebc1cd37f273e652180dcdd65d,
+            0x2231f46d69ae4d0ae2429ba6080b7fe51f3f934c3d6607aea12139450e394dd1,
+            0x2e37b2806360065a4e80fa3e6f3acf0cc90fbfee5e8e29fe20367345f8979dc5,
+            0x1e52b1dad965f7d359b8dec0592575d918b48baf65dc217a442db727e46ff8b9,
+            0x266f2edefdeedb61c866a0ea64d019f31d1ddeff9607667a5e89412393765810,
+            0x622b99a4f10e3ea4c1a9f0a2c0823602a1f37fcf2d70b6e729f8a50751dde06,
+            0x20b6fa4bb93ba74bb91a9680f4dc15e2436baaa16cbd85173881a89d2d39bf07,
+            0x1edf9a959b552bfa30461615955d8bd5ab7a2d826fb2b440d363029b7d8a16c6,
+            0x2352faffb1f4d71dcc7870bade6df391c49d4046451de035837feed53448ef50,
+            0xbb1c8476707800ecb7b2cf40d86e6a7d5aed4214b9d535b21a0292790294b29,
+            0x1a004861dbc666a632c6ef9fca6214a36256e7b0ca97cee63d02d5740f7f72fa,
+            0x115cc0fb69c30646288e34277bb9d59f5cffd364b3a48dc5df13936780e452cf,
+            0x20b9d6ea816b25eef2eae178eb85edf16d922e259758611f8ca73a8560e5f612,
+            0x1b7650b9721a1589244d0bb8910acba3020e5a849738c729261d229252d7570d,
+            0x228969388482a46d9d2c33e3cee3f07ce2c8d2438e0023a20c7d5e7c1c84bdfb,
+            0x1a1c5996f580dd93a0d48654c03d9fbd053a6d4a64b21d4487b7d16d586b9575,
+            0x25c69df2d6d1a1203df21d682d24907f08c34b941f5351caa2b3c26efff3d1cc,
+            0x12848ecece4c7385b709ff7c98962c528865e86bbb652a874c495e5931986f75,
+            0x76bd3756046b7989e8aa9115b57abc352f470b3e8e981200cf37548edcc00fd,
+            0x2884069a9ac9139181cef297a585728448ac6a74a26a6fe56bf9ef62d13ec6a3,
+            0x7feff811d5e99b474c5fa155004bea6a6fcdf03a681acfef2e25ad334f71e5c,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1d20333ffc3cf745d561f12c425d8e1148000b7d042aeb5f26c5dc223fe31865,
+            0x28abbec7c9caa428c519415063a6f2d5e1a0d349e3061f05c40ef35803686d42,
+            0x3a8e10fe7fabee8686830b8234275a3abf3cf888d9ac500bfc643c47d476c3a,
+            0x18c2e2dc3d8b832d050468b7a71e26bc0d6e887165176ed06c07fbecd3d15a5c,
+            0xd50f1334b2bcbc0cdb0117a17c5542080751590a269f4530441ee1a428cf53d,
+            0x13806f8807551b28f4a063f853d51c621cf08b2f67259b03c7b1b10734945688,
+            0x2b08fe6c94ebbbcaa380b0dd6bf50430c5bead290a5cefef3e75aeaeaf7b63fd,
+            0x20196101b753985b8d81c33fed2d02bfc0594ed7b25aec355a1efdee746c5633,
+            0x3745c143e9794534ba8e09393a84d537e45a0d9f4777e77fbc14d22daa2f067,
+            0x23e0047f3bcd71895bdb2030e2656ed5ba74f2340b2cc87626a6739b65b69299,
+            0x2b7432db324f5d63ee6df8a327ad7d03752feaea63b8483523e1b1ac50af5356,
+            0x3230e5463fa892ae37f38ff6bffcfdb09a881baeb117cd45199c5f78498334e,
+            0x6d227987110bba2e393ccee1a5d01fb046f88e9e82c975d69c25505fbe2f7e0,
+            0x2137c2037b936b9af605dda34fe4424a2f095aa784956c7e1a8410602381d2e,
+            0x1b85811f361794bfad1d365f9278b8ecccae2e29f16e81a4e81f8a76980b06df,
+            0x18ce9e29cabc3a88ae1032aa09a664a307f07c41d0d495fd88f4729fa471d83b,
+            0x16117eb08d088c3146a297600420e21723b75d24767e3e927a465ce543a442e9,
+            0x143137a07224a1f3df382f66ed1eaa0000006ace56412ba51954dcecd725f03e,
+            0x104d16d80f93f2955a067d5b615b3169cffa4c95c7bd28c57df7a098608b52cb,
+            0x1d486d6cc1ce7b6f2b3aadc680d663e9afed57c6df3948a99edfd8d21f3283e8,
+            0x26b9676c3f4be27618037e6b8681c624cc2badc95e3dcc2858f44e4227b90ec5,
+            0x1b9d6e78b161f530bc835a17a56ce26bb302ca73846a159744389cba664d9309,
+            0x133c6470bb5a345bbb1e3a3650b9a5f39295bcfb97ce888cb775b07188be130e,
+            0x2eb4042daaad9726c71a3b6be579dee9df64b6aca59cbcdd4e014ddaf860cc82,
+            0x2b7e6bf97ec1a114b17e6bc4b4808ddff15614a70e43318f7840ed715603338f,
+            0xa1125917e9750fdb258e4113f2e3beff8cd77b2e4840d2a0a3efae84324f1fd,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x28f2406d5b2006a8163fa449cab775337ec435075e08f76dcb360575f1d0f9a8,
+            0x2833ed76d81d99573f405e2418760ecbfad333f71b35f293fb3fb2550d32fd32,
+            0x1329680ba1700fd38f42d6f88a166d7128ee68baed48025f1bd8273c6d13d5b9,
+            0x2e406c465948d552b82b4d0443d9b4393e9d034c1eb96779b25554850f8d582c,
+            0x16870864c7481c37732c1226601c0fd0912ecaec9c4986893da2ecf1e7e9bea5,
+            0x16f0206a256a1eaf579b789362d74a6df9b4e8f4c3bc43a69d5d84f8e2b86e1b,
+            0xd3769821a46417d7c41de7fd8a44cf0e6b03851b33d35f9105b91fd045f4364,
+            0x208072d81c7b1e0c7fb8bcf2e372a3a6142d3643084a78bfad3232dbc4d0421b,
+            0x1b00364bfd8258bc091a61caf85bdb512a8319ce47c9dce782e62103c2c7a71a,
+            0x39d9478f244268c4803f9dd0dd5e63217be3c8118476c3c36c463acecc573cd,
+            0x1702787253c770367113ca024f835dbae15b5c16bcb2121cf3d89bf60993d771,
+            0xd424c24ab70fe46dc0b70ac44f1560b98a7c179b6fd59f87b51cb1580404f3b,
+            0xc8eec67747155b02438d197c9d55437492eae235c05e385f5aff238ecbff493,
+            0x19318a85cac2967adc34c434ced1261abf43e1bf1184a43a0897436121191ff7,
+            0x100d0e39b0ac4162d13e523a8308b3d1185ff1abc0a44f80aab198f4d4af2e77,
+            0x1dc9edb515bd622a09d6f164eaaf2cb987aca23e7a0a79c8e00d02ab44c71cdf,
+            0x2cb0a4d99188559afba7226f3a7dc66b1293a6d5dd7ebf396ac96d3bb1b0dc69,
+            0x457e9defe2b2e3ace40217181c5cf8a361c3303bae8d1b867e62386ee0aec8d,
+            0x27cb603ef3700431472d85ceaca537bcaa301d220e8cd68c8db9b2e1f53e99d2,
+            0x2a0f737481bfdbd65f8fa4cb4463e56a31bec6e77c94e27216f4d5aa734df9ed,
+            0x88e30685326b92f6007d6efa42d8af737bdf42ec7e1c4d565318181d8295ea0,
+            0x185dee7ffc1c09332fc1436f1c6d67eb3c6dccb36bb98177de5f2802302c68a8,
+            0x1a3c2ca9dcba78005a28af3b621e50155295f14ac746057dcce986f6368d3d98,
+            0x2c899f8d46c18eea46b9b431d69f5449bf5c896b07343a5199e587c748443f7e,
+            0x12b7b81c78c7112c7f79de2eba33f1859e77ee9bfe54d5f3ee15bbae2d6b90aa,
+            0xa9c41fcacf18941604fb129682761803f162c0e7cc1152f70bb76a28995aee8,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x18c2c80c193bf893f8e24328bb79195e1cb8ec5c30fa4d0aeb228c820e7edc8,
+            0x840212cc8df69cdec9a5d73b33f77e6630cd08a0462709391407c8857b09be1,
+            0x23a2a69b4c1f2a9d5da9bbc185ddfc88facc9958428e06fba83d67a6bb7cca8e,
+            0x2990a00237ce280ba705df85715600a7d425d4ebe2b13ed3b42b1b44ae48fe01,
+            0x268d4b3af37b5f5ec11836ac54c1ced9c569390d0463c316c2caaf71ff452c50,
+            0x151286c34d2d1a88fc9f696e6c762e833309a6710e03831212d317296b1c211c,
+            0x5a0f37b771fcb8d26bea09722510af9bf510ae84c5f0106d3824aa274e80f4c,
+            0x2186448573dabfd800c596cf64703bb0bb45ef5b8a91fa21009862ae3aae0c0,
+            0x27ac5eed415340d9907c6b414708cde2b99de1a550be1c26d6ef95c6ed5fb9ac,
+            0x118baf60eb743773cde629142c30f86d49d633c5879f1977aeb8496971b3b956,
+            0x2206f4af9dc21a5e94a00775629d9eb46a104ecaf0d2188122187fbd9c5f666e,
+            0x1874fa5cd6fedd8dce56a38552b35512bbbc6ca56a4bc6410406ad149bd30589,
+            0xf22dcdbfea00f4bc89dbfeac7b3dee60b16ee9a74f13588f5879ba714c827aa,
+            0xedf94bf49c040df972e27701e16229766d84197b29f023406564e32cfd8358b,
+            0x2d24ceb96532b06e751d109a7efcd29ba741e61e3472bece30c7128c47042813,
+            0x26fb8b8eb2d90ed4886b9982bd3255b9df4690f84047ccd4bdf21810720bda44,
+            0x1952641fff4b577803eac12d290acc39f4728e3fc086f3f76313fb2b78da5b20,
+            0x2233ba51923c10394d1ef8718a6e82d84d9054de8c8498bd05d52787faa25e32,
+            0x10550f7d00d83f1e7fb7e1c9772f545e32e0a60ca3ba0ae168c750147df29eec,
+            0x7e5e890c3e62c5109e3790d2bd1406f8425883abfdde19cbba3b5aa7b7f2bfe,
+            0xd611acfe2f91f645a07af0ed66ea813d7395b09b4e4b3cb92afc27a31e7cfb6,
+            0x1fc4f96fd7c7a69fee8092b6d11c7bada79e851324da48e658a166d00e66820c,
+            0x10b23d2c5bd7e976228e19064ff33921faa59f2eb4c8652d39546479d26ecb7a,
+            0x2f21166be2ed1b2da47425d6bbf4ea1f2c5aac82b83265913f6ea70a3321cdf0,
+            0x2ab0952fb29bbeb0d5728f07aa4d67431c1d3c348a0f1db6126e47cbefdde394,
+            0x2a10c76f857e47245d3c145ce70c87a1995448579647698c122d3c7f8087639b,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xe8bed4d86934cc84383480e2301331becf2a8756e9098c8a5541d39b3be2084,
+            0xbdb68bb05cbd1a32bea32b8daee97ede7a999c31e66621b4ecc57e806e9b68b,
+            0x1c68215101419d83d15a0260a0d19456d8a4d552edcef12b8eb3c8d0fce018b6,
+            0x14c45f6a32e995585ac81545545d2803fdd9cd0fa462a89f2cc8d2f2869289fe,
+            0x3c63147df05188262fe56d1991f872b8069a6c07b7358d166003ab422a2bf67,
+            0x27b093996711ee7e4d1d6566008eb46b53bc45925a385ba64c4b314e68f5f939,
+            0x1a67fc8776cf402c94587340f50ff6a0037570c50f24daf71d3b14f12c37515a,
+            0x368384bc98a519dd78434f63f92be511aa6ebe497a0f202c40dad53cc9ac41d,
+            0x1cb8fa7ce16b44e38432742589d4857c290e41ddecf1c04d19475381588dbe15,
+            0x23597b850f364b4569de68f1ac728565dc30fa8ca25fbc7cb04de5d7c4b97c62,
+            0xdd8ff19d5e1308fe4266a519030fcbe2a9dad492bf87320fee1b56378548b74,
+            0x20feb7de1a5e96b834f33f0cfd2be704639c024c4d40b2e130272ee52abd43b1,
+            0x20885682bab854ad9b308b29e93bcd9744b30a32a86b43656eb9eb398958c569,
+            0x19d3a25bcaa553994b945b1966f0e88877b49a0eba7cfb7436425ac980d1f4b1,
+            0x2ac8cfd84802b67174c30e48b6b805af5ae5c0e308beb82cf3734fab1cebda79,
+            0xe7309eb986b717f72684842ee44266078aa935820e854ecc26e86b304a3aaf8,
+            0x2bf7eab7ccb382e902533c265b264ffa63278fa298fd28467cd075a7e3bc332e,
+            0x83dd2953c55d5c2b9f2835c418fabe9f31d712601bb68964101149a09100404,
+            0x714ed30fb5590de5189a271e1a8c643e52ab0e5f138671efefe328d85eee14b,
+            0x21148f9fd3b0722bd321a3f3fb59dfb18dec828c71a820e50e2dc0b77ba06c28,
+            0x2232e4d97bfb4af6fa023ed73bdf899e040c85e086ec61f64d9e76bc8aefda1e,
+            0x2f130c81592d14daa4a108219e2381a3c3d43f9a7fd9407eac791568a7290d97,
+            0x1bc3006aeca257aa1e0a79238a6aeca17b61c6dd8c5e38ff259cecc70c6d957b,
+            0x1e2cd754d9765e6bf4ee604c3027dd1553e6bc4c96f0a1860de5ec1ed4e7789d,
+            0x1b03008489762f18d350e6f59491be94b91125f6d564810b226020fbf1266feb,
+            0x4139587c94008d2ae2862f17f4623e00a60f095650f0f954d33e2b3e028c8a3,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2e92d0d003478aad469bcb62a9ca4fc6a4b8b7b54aa20082421047b49526bc1b,
+            0x2fa9f127e186da4adc277ed2d0fe8ecf65d7686171b3dd9b5ba57a41d94be782,
+            0x16b524b227c91d14ae22fece795ab7b4e0672f93bc0be11a4bfdedba618ec632,
+            0x1bae132d3cb67233efb7501a87ef7d5304d43d84795422a5980fef6deb8d9e0f,
+            0xd64e85826004f524fa9633ff3dbd2acfe2147df88df435e71935e5184c0b5df,
+            0x7a8991e9213182f06e7f27126e583ff1002b732d48fe69898c3dd1854468c4,
+            0x78a71ff06f3a7037e3acea1df2f04e326774ddb20d6717052065d5b48e4d9c6,
+            0x2bdbcc0653dff0b864ba7c35a2053688b9a13ccf83fc78b5857a91183c634ba0,
+            0x135c4770b984ca724061061017f6fac63ce3fd5f42e3271af748221eafa486dc,
+            0xbe4b3d77e216a0284da484fa0ec171130980d6648a10e81494264284df500af,
+            0x1d33a1eac83aa2e8e33f90bf9ac51bdaa186d7714de7cee4357b5768bdaa03cf,
+            0xc80a19a319c0095d10de1473bde0636e199b13b8d838336a0133f86e9fd280c,
+            0x1fb00a5d5448228839fca9b108ddf4cbeee2e5c6a7cb8d6bbbb33daf72e5dff0,
+            0x3428c5cf5139a60a19d3faabaf6d8571c01242000e216e3e417d37476da91cf,
+            0x15313c7636e93c90281b5946d1223bb25d849c6b05a9c6e58e3459d4058b424c,
+            0xbe94e5c44e86577fbf39b9db0d3ab08a8e90a14881360a3be8e77b1465d6a08,
+            0x215f4fc3b36e8ef41ea226080fa331489bb1f5d5b2e9924b5f419a2900390614,
+            0x16b0162d774c50882a9f2739bdb279317918d0f75e2fa75bf24e9ec3f1a21102,
+            0x12c30feb12fc441d6dd5059c269074f10a69decc148bd2283dfbe594d2a538a,
+            0x1649c52ddf7788ecb2150a1a48aad096b4dcda9f517ab877a11927cc3eb7fe9b,
+            0x6edf4bba85eb1927ffaa307aa9385c0e11eff4ba249a8e605d624f35af6f9db,
+            0xf61ad25f3641eacf1ca4fcee3830d5222f357f046c474ebdb732e0211e49e40,
+            0x2adcc2f96c95a40d796e0c8bddf303d75badc37ac9aa6cd3173b868f6d177dea,
+            0xa50edd8bd899b1d15dac22136bd3a3ce00ad0d581188aa6c2db96ff696613ba,
+            0x26a9ed9b96681106cac0e7706f4293fe79d078d918f25f07a9243b912f5d5238,
+            0x19595ba4019162353cf21250cafa1aa64a7c0597c0d0af5b1de0a18131520439,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x969363ad2fc56dedd932a66bf1193a1b96276f16e423f78cfd790850bf93477,
+            0xf364b0a5a1b00f7192697f5ca0960680b217e3fee2ccd320cd408fdca0fa7fb,
+            0x100fe28b46e80f15e12ef4d5759fddd560f76bf74cee6051f23ab10c8803f474,
+            0x2dd0aad73d277f8bc1c76d2133bd8c8a8ba8bbd573bdfc1adce1380345bf233d,
+            0x1ca5603c3bd89198d450960c8bef433ae368efe4be568d1f8f63418bc67ba269,
+            0x1eb4203b299398722feb50f86e2131f870ab2fee6f726876b9a213a69c8b34c5,
+            0x20d3eac3a69ed9d9963de0a1d4b554ce0b5e350033c7aab8742fd258af31392c,
+            0x38ba0b5c2b7c3d41293047fb42ed9df347056965c4d73994fd38e0b3d0c3c74,
+            0x226c68b53ad316f22f8aa803a90ffb02c489364fcb807ab2a6dae085a2c548e4,
+            0x1159ad22fb4656dab10da606d298a856831454bfb237a222fa393a997dada332,
+            0x22d898f074eadbe133b38174e7629a3fa47f8c92e8e67f62130a00fa7502b956,
+            0xe118395fc451a7aa4612da12097c4372c92f7b978f5af092a4771e09a13343c,
+            0x5b91237560989a738bbcf80a2175422656dd27e0f5f96741d141fd19392e462,
+            0x1bb3f133c2d5f7930a9decd0caf63f17c5528844db26efc336e5101f1868545c,
+            0xa39ee8089241c5cbd69954994abee040ccf43b9510d54a05056194912963bfe,
+            0x11d1a72d9666be10fe5fef74e6e06431532f5157ee24ada70683b9f0a586b585,
+            0x2a0872f23949f213b46b463ad828919ebe034950429f91fa3bffb275d722b47c,
+            0x1da2741d74cfe7a159666231eb9981749a40bde5cea6f1a069dea57cf460ed45,
+            0x225046f36d161704c26a8c378e2fa58859a2808f94d5242cdc3c742c530f60be,
+            0x2ac5e790d78a3b19e40fb98b247ed9caf78b47d884da4bbd70359482c2f4ac84,
+            0x2a9febeb411787c59c6b8e51108aef6d9dc63aa97cb314907602d5f6b702175b,
+            0x10519bf4b5d77f8397a4e51ad3dedf5b0dee2b25e08cb5b866eeb2a891e0a6b2,
+            0x21e9add284054cb149e67ec3fc4208b9e0f8a8c2011ab17bfb3c4e4419ee700f,
+            0x861419b33d1a9e2a944bd86a22a03490fc560a6e3f3922410b1f4ceadbf2fce,
+            0x204bee088f716345187c1c25fcfad33eef88a8be606b0441139f03be3d39de21,
+            0x21a8509dc07b690f149ace959540eee40d485db5a21e3a2ce9dbe808f621c92f,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2bcc9e799065b89040280d6bfa90d9b0f98ac91d5051d683c4dc19c6d078592e,
+            0x2a2af9ccc8cd9b8976ec203de687836e6025e0197a9e756a094168da234c6255,
+            0x22cda8a2057a524f13ec0bfd8cf44482691536cecc3218c934ca7f21126903d4,
+            0x195abafa1531518d101c427496305c52e3d2c9e5f7192207f23985a15a85b384,
+            0x226c92973e2bf06e8800bce486d3b5c5b086e9717d93b79e4084a9a3cbf41dc8,
+            0x2d4b19bdffed4790eba5957e4545ccc65ffdc300d945b11fead52f83825cbbd7,
+            0x20c83290d5ef608ecbd330a998cde98936060e1fb520652c9d6eb1a57558f91a,
+            0x2baadcb57bf46a22bf299c393d1537bf2d612cfdc70413af5e5d8261f87dd73b,
+            0xf09875c2570527eb866d31f96e357946cf01307d89962db0c6f16a02097d08d,
+            0x2a29246703689c0d7c52136c2b548245b34bd6b6c341ed99c340e114b856e0fc,
+            0x2f05d7232622eba1583bf831f6a810ea116f0fd933e142650c58d6af1bcb66c3,
+            0x1afe5d1e1b64e7741039d6c26a054b7300ecb7d052d89e8df8ce8f1fdb5289e7,
+            0x1925f2484e57a2cf13139ddeddfdc2b9235640c4e40e7332d1d632c724801f88,
+            0x7752556340dcd48531bcb144583ec742cf7539c9ac2347363f9636ea060f39e,
+            0x43c28a9d6f38ca50f057fa71bb6f07c62295fca2197e056160e93a6c82fc15a,
+            0x417aaa17f575f42328eaa4ba22be7207ffe9d26564b42a24b41967f3e3173bd,
+            0xe6da876303fbed7ee756fd87a8f3e1636325532adf26bff8910198c92e0caf5,
+            0x27fa572643a35732cda21571d390600f9188739764febb8ddaf9c01bca807ff5,
+            0x1a510cee95e7b6f4efdba5612e8c5121c1ce9cca1a376d8379a1fdc206a55fc8,
+            0x14424c4b3e51ffba1869ff6527ce3ae53dc13cc1ea19ccb5c8792ca6be287753,
+            0x21a57d8854d6cae5d0818d294fcd9e1a2dc71691a2e3f9b227fc7889cb72182e,
+            0x225cb50db0b73b20058ef3f671fdbd2c0877a0defb8392630a01ceefda042d16,
+            0x58641892ea470cfc83e363c5b880eb8263212533f8ba6728527c4636f3e0113,
+            0x1f4505746ce4f65004b43f9f0017d2602e1bd44ee569e08fdf832d91531cc2a1,
+            0x2a076d8186db2528d94fa47dc41721629bcc2fe83eeedfc433c20e8cf4c3efce,
+            0x1dec0d6f62e19a1d2ab02d6c4d6a6d7a1dd1387a4a1fb15edc8622e1a3def5,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2a48253491abad4561b2ca9cd08cc1ce7ae0335240facfa6efb4fc653a48efa4,
+            0xcfd514f09e0699217166e20a7eda9b00512b6146af51fc1776dd6980588083a,
+            0x1937a11923000d95131baf310078bfeb84b99a77e027e8d0d96201b918132ee9,
+            0x303cfb90a228509ecf58fc6e94dcfa0860d206b34b28a8368a3559a57add1cdf,
+            0x28930e4b9ec17c58ffa7934c216ab1af55df309d115d0789233f84f2c441a535,
+            0x18aabdce0da91d3b644bd5ecaf154ab7148f3c3326cb01b593f8af9efcad0728,
+            0x391f2ddcc9bd6fac600eb0c26e0b1a9a27571629e9b00f080d876ee2f1b648,
+            0x1d765c20a588ab7217fdda5e01dcccde23dcf9a9cccec4d8f424735f39e25f3b,
+            0xd914d807b0fda1cdd76d1955f170ab3616a35ce53516a81e315825f93165905,
+            0x22492619b16183d3180c15994c2508c83737ae2a42d968dac85af30392294e7d,
+            0x11b3baf3833cd4a6039f2bd42af1633a47f240fb88a7f0ac0902fae2a5be3510,
+            0x207c403b77244c8018d8845714e68566216fbfc49acd0107c55ebb88e0de3949,
+            0x2c9e431e04871524a5262b21286d04333dedb393a078f2fed92266ac22fefa6a,
+            0x1fd093032821a7772421e62b4e3c23a195d27ea4798f9a3f5a6c7d4d2db583e6,
+            0x2eaa82b7fd1c061940c2a77bdd2fb653842bf1b0466696b292cd304b490752eb,
+            0xf98f710e410dc1552fb69cc85076b89b4fde8f27428a30b58219f52e422d130,
+            0x12229b56730ba20a6a52d21bf8f7312696e8cf6537f1f6c50bfdcaaa4ed4a7ed,
+            0x1c2fb95b64a0f66b65d9060f1f065bb82ef882af760419aabdc6cd3529431e7d,
+            0x2f2fce632964228eef7908478c90107a5dde45af647f2323ad8a612e41c48154,
+            0x61849aba4451458f718c3be3f76a38347e512cf422d1f907a82da750dc21478,
+            0x2cd60c32d6ee36c374016bd4f1c0b273ff87315f6bfe1dc9a81fa0ecb1264599,
+            0xc3e897a8b91c108ad19b152e9842cfb87c4af0aec8dc950e0fa325ed4d69ab,
+            0x7a38f888ba67b2150b0e6431ce02408681d2ec80c8daca4c51e65b59d329fff,
+            0x1af524a87fddafaad82b5231a1e75e8076c66c44d3b527a259a15422870db619,
+            0x1159290a4743365d781e01a0d6bc626832260b07df2d0f288d15c95272eb1f9c,
+            0x9e51cd15182d20f87b09cf6966f9268578c3d9cc58b3e7f981f67502f9478e2,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xb0bceee45e31b08c0548711d59c548f51b7d1a80ccefe6599b5dbad0db4b738,
+            0x241c6fed92ae4e391bafe3af5103035f9fc1f727a6dc8ee5f61ba9b1e3eadb9f,
+            0x26aefffc4043b22cedde88f2bce76faf6fb3c21b4eda9d682c14dba06fb9e87a,
+            0x2673296dd62cd736659080d030b98914f6f799752403ba5c29bf9af6afccc8f1,
+            0x22ca97c4de769662b071f7cd75657c15e9cb20d744edd0a7911d78b6a4aaabe8,
+            0x188fa74b7eda792dc3660885901c82d57050e74b09a12b5f346d34e1e5f67614,
+            0xea0166cc4c51c2252e4f3dc92fcf33a03964a03050f9f125b87a7fe074dfea6,
+            0x2134da7fb4f089a21363011b08fb72aaa8fe767c618bdf08d7b87810d5fdb594,
+            0x2be62c9234dc7d3db66ac72c758b15628df1cdb781c90d0f2f23de2a29005105,
+            0x282ae8812d729f2eff86f2ec478a65707c4b63d33443bf6d8f872569c40e442b,
+            0x189e7984fa57098dd737293a19d6f60971ea7c74fec600b4e6fa20cc314f015b,
+            0x1e20cd3dbf4a75643421e4fa713f5ceaa35ed0197150182f653ae9663a9e45c3,
+            0x23bd66cfdc54f92e0d532ff413a2e2ff3cf6f561a344463e5e0a0a8c5a010304,
+            0x42657182ee4b72e3e4408528c19b71ccf1d4f5f38acb0e5a5efd641cdfc6b7f,
+            0xa11abc1daf1ff8ed6afb6b0a6370bd55fbbe7507f1da568f39b2ab9dbb6e340,
+            0x200edeab8b94daf3135eb6046388ccf8c7140d91873d2fef04b9c60f509c7de7,
+            0x58546b9e80b2dc22250fe5c53d66aa14be31d5d92b5c04a05e3525810fc78a8,
+            0x1670b9e07e02e88814eb40a43d83bdc010739e9ad6799c10bba24e1f40b8afd1,
+            0x1bf39f979c015af4af119c137d5c8a334ed0bd0d7f89626d4f79ef4793b91324,
+            0xe19dcdf5b4a1ae01fcb6c6579db3fb615bf176d53e6ad047ccf905861acd584,
+            0x28f22053f72ea545761afc9557c84b05c6f736ebe7bfd2c8c5c044d09bbd4d4,
+            0x56e7854a96d6bffb29945d76b51fb9e81f5f19ad767171c568b742e926054c9,
+            0x2aecacf169f418d8f47472db625ac3bdb5403667c61457666d4238bbf39d6638,
+            0x15b04e62d4167a166f14364bed196d1d0e49c8ccde5bd560e261600dda4d3c3f,
+            0x15f88c4b31508718af67c6e3c30cf3cf594fbf481a837e80e89156d9c2d1be74,
+            0x14e6645c7627e744f9e6140679c863325d1d95e1e4786e573a498b0a790b431,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1afd97fac1f6e77c5cfe4bce848b93051a26a3b7d3d6b18dda048863a013cce4,
+            0xdf68cfb65503007db81044af06d38ce63fda1f569a7057f1848ee4597d87c01,
+            0x1086b32477529f9476fa324d6d9552bbab58956c2e2095548dd1bb20e9be078,
+            0x1611046b126acf5767561c32d31a36c5070d645bdf08684240a72b9832c3bf2a,
+            0x1bf3eb5fbf1e5bbde992521837a8d3a15a187921832989b4d357a1b2ced9b36d,
+            0x799a349b10cdde87ae631ad3959d6f9664ce23ee91e010679ddcc6017ef120e,
+            0xc55d0ca35aa0d453acbdd8993d05b479e13fce555b634fc6d3e470035b0de8,
+            0x20444c1bf67d6ce8afb0a20e79d6b691bac54bcb31ce4182b1579ee21ea9fc8a,
+            0x22e8f59cbb4f92639cf517fd119eb650704b00e6eb3f58e92eb31e713c1b91aa,
+            0x1b4841aeb035b2e896d64b59b47873cb9c74cd05ba12436e9d1865a4a74e8be7,
+            0x133d49d56c7809b942db891b424b30d56ca44ee7f73aa028a5e577e82f509968,
+            0x698faf29f83281d3fd421c78ebe694cf5eb371e29a09354741c59f4a4abc6ae,
+            0x9cf68b95e1a447226a8c39440513f965a41fff89a1e1618c70ae4be00e92c66,
+            0x57a0141a7ba203881e5a90e6d422e6d9001eac737fd9860344191026c5fe545,
+            0x1b71aca0b352c5ee4eb06dea7f4202fa1b908f08e2be55dc0834a1a873607597,
+            0x142915304bb01cec99a22a96d1af31c3133829bea002ae98d7011fa1516160d2,
+            0x4aad51b11363b30a26aef78b4af431dd8bd65dececfcd1a6673d8f96a0e6c16,
+            0xb63c18b78503b6a47a88f4d54c4da7a9c23fe346de39a8884224a2a85a9511a,
+            0xfe10d1f3c9b406bfb832e85b8a844c5c4dac7398f2dc3ce2541dfa71260d259,
+            0x2a42420809746917645806d70631564f61103186f9cc644df5b7b0ee4e6a27d5,
+            0x5a66c6f50d393da791e5768de874774d066f0874118f0f417b6a036a657dcb9,
+            0x21a4d71862dccb7c0a0a9b80945c5be92307f147f29917684378111cdbe9d2fd,
+            0x46f855f83e16426aed3c81f5a2f7f92bec7ceb71e3dc7e2453514c1081ca202,
+            0x185eb4c67d4f479827980a96827cdb79988cdf8d31c2f8d2532765f4155cbef7,
+            0x2a4294d3919b5debce649b27b63f40e5406b2f044e1d41d58411bc00719d3e7c,
+            0x2a802da0e4d59259bbaa7dc3227ea2d725f6cce50332661f0837cfb87af4af94,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x154eb8f04d175057207d617931b51ba18ec3c830e1afa755e8ade5bfa71c1d44,
+            0x1c5fbb238cd09b4ad76154a2fadb7e7d732bd534603ff3cbbee8031cdde7b994,
+            0x1c3a7fe14c3ef7f03426643cca0e6faad2806f9dee971ba41c0103d42f4f116a,
+            0x928a9730b25d647c4563b4a7273307c94c347565eee36c781c3b8adc53973f3,
+            0x2aefe39f4fea948261cdbe0accc5c7ccff6714fd741fbdcd6e298249560dd97a,
+            0x1feadf4aecbf7c7f1f526d0ab1ae1513f1b4fc8731187f9b65713377c9062037,
+            0xcd2f2d4d826d98ce3bf08da02ad5866f34c9b43f2068da4e5b33378d93c4c24,
+            0x2e7b56a6409134126d411b560967c46ddf3a46fa47dec457fb82a070bd448b05,
+            0x23ee37d1d1e1f8a3b10680bdcabcb89268a4958051e8230d14a0605af857d190,
+            0x1a910c02479a6795981001f40273c702cfbdcc1c00fd03de1f8057bf2809873a,
+            0x2786abcea27c34cf4ff274769e51787932001c0640033a7c89914f44bca3297f,
+            0xb27d402fc69e2f23ef8e60420a38e429da969f038cfceedb073e12f28a5a260,
+            0x5c8f462872ea76897742babd1099b0aca77864a1b165eaeb8dcbb3fbfb95286,
+            0xd29130c3cd0ab2358ab1683597256a2f7ee611376b9329b8aed30f69505bda1,
+            0x167beb74665c1a02b90450914870d4480472b6b2bd22563750afafe3de5fef8f,
+            0x2574275c7bc58879004d63dd307638b057eb9bf99388ad4788659f957ef5623,
+            0x1bafe22329c00fceba1e48c5f61bdc519b20eb352e183859b2434eba6cbfc4f,
+            0x40f25fb048f262d0b88e5a557234c4f35ab898d104cb2eb960905e1e8ba5a80,
+            0x2fc7cf259a1474e83243039afef87ae87f1a07bd433405084e3e4241c413aecf,
+            0x30144980af35b582d434cab99e08835bb09644dad47fbe036aefd9b19b713ae1,
+            0x140f2ab47ba1a08e4ff8c38a8245b79fc20c2916fc3470e4eaeb0b3654b4a6d8,
+            0x97cb1acd89b5b12e82e14571e4a4ef516f5c2693f0bf70d4c05cd4efc72dd9f,
+            0x30435adf792ba5a8a2c9fb599c91a1de531c7fa809f3fc364761e8e68f3c99de,
+            0x17acbbffacec919a115cdc4c303f9335febbb1dad12f0a1825fd41359ef73491,
+            0x45ac0782c8edd00c6d7c0eb594b799de598bf538c80f467fb7a4eb1f6b01d85,
+            0x1e15d1be8d2281c6f25efc56b33d72bfb59a61bd91518a3de93caf2a357d0256,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x125b96c678d2ef181f7e4bfbb795150eedb5b46a913d6571d1b204790a2c7b0f,
+            0x130be605c83bc01c1fa0e64c79ee75b27d4b4efd892368f66959cebd8ef1d79e,
+            0x3051c6918396878ef98b13b7c484c6695a093ad607bfdcd87f01b79d420e731d,
+            0x2635445a3f66389b4638ebb81a36f4ceb210d5fc5466209ec215c08023aca95f,
+            0x10bce0fbd3a8796152759cc25f72601dcd99b699a8c34686e43fd2b6d1b27d89,
+            0x17dae8299eebde0062043e9e93267fd1b38d6f0bcde5827c10822b137e4bbca4,
+            0x2664e95646ec5ed0536a1ae2ffc84165b5a3c295c21e58606c95037ab746a878,
+            0x2b8b53c8e90382786b60fa50994f281866ace7a311a40af07b633f3c30fc7776,
+            0x16ae53f5d4c63a81f4fd487793eaf5cd2cb03e3c8236be7ccab8c20372f911f8,
+            0x127dad336628ad2bc403718c4983c136f34cbfafdf3e45c616af7c7e1ca8793d,
+            0x10a10801dfd21422b4f5a264c2eff2121e0f716512a9dde5e6371eab17e6e7f8,
+            0xac6189eec8ef4ce3928d7756fac44685b425ce64bee3d4852698709e769f45d,
+            0x6f49e55c72efdc84f7ff6306157d770310b1c4e6e509ba3919b9466bdede393,
+            0xad1247adf1e4bc8665343425bee4d3f35429c54d6bf4a8ec3b16dfdd1dd3a45,
+            0x9f989c92995f86daf29a92cfeeadce5f105a0ae272b2253bb2de3758a771c26,
+            0x1fef396daa237f6467f62441a55b75cb5a09fa94cb1fdb270ac309487fa682be,
+            0x130d74deb88099e35362801333bf7fae8abf96165fae4b8179579761ae1de1d4,
+            0x1b1e63b7d8b5f8d9612dc59e1aa9422f962761a992079a8e8bfc91695ca204bf,
+            0x2d5d5c8feaed5dec95fb9d6674066c03d6cbd0d584084827214b09553adddbd3,
+            0x2278a2b596a3d0af0a9365f954adbdd2c8a1514cc906369d3b0402811c952a48,
+            0x11291006cc6718940fff0378cb6cefa09db4b7b7c84d447ab132a7a47573babb,
+            0x1e0bf04d48d54e8cbe871bcdbfe619ed38fe69bf9d2a61fb5def330b2d7f4078,
+            0x2b0907cd35c62152c10e47e930dca88d4b12c5afa7e2836c2637ae73500b765e,
+            0x2e5051c91020bf6c73339f653843436ce182cfd487c02a16578cfc96d27c31cf,
+            0x1227e0c86ab02adcaf01cfc56cffc815efeab33ece8c164c31bba50b28477b13,
+            0x103b328f8e9fef02f340e3f679d91d9508bb1eed21d98d569a41583aab595707,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1e3d52642e16240dd7e2b0ee21cf4b3b4cc10c805fe52009dc7520457180945c,
+            0x1fde6f3b98df6104d07b84a703494892d8fd21cce53cfe9ea41c4ac6e5125269,
+            0x6934a63e04749754a1980371301caa1bc00ce38505933b1ed0e085a5755856e,
+            0x2897d663791c69c9bfe9b313759be1cea16299e667c3acb3e9f18079d39209b4,
+            0x2f30ba6752d0900a64be8d6be8b718eda67cf96af95a1e0dc91e720dde3eca49,
+            0x219898fe3438a5e5bdc5a79611084e0977456513586fde2b23b5e8e34d7eb7dc,
+            0xd90f0afc59b011d2949f998d7c5e4c2a53953aef58f971a458704fd88f6a27f,
+            0xf21f3710b4f641ddfdfcbb67d13f845216ed16a0f1c0b450acb82e81c85a93d,
+            0x2eb036baa89d926515281aba071798e7397122fb51f4504e07b6acccbaa17af5,
+            0x1adb3f0ad3c7e2300c717a6674e22ffa2611978d8c29e3d21012fbe7606ade6,
+            0x11e1d1fe7ad3865581a1a8930698e676212b04c64773601034223475f91a7b69,
+            0x14648747b8bb5b1e8b433222a964b95c4e143f70d6b26e6aa620e1c57c842ed6,
+            0x14558bf2daf718b30756ccb88e3890ec47f25b4b5e087cf9d47f33423e97a902,
+            0x2e6d0bac325dda6331e2117c682066a1be931e8b6bf889e5aa8f716bc14358b,
+            0x1bbe690c183e54f281bfb4bd843afb3961bd3e428c81dcfdaeb8220a3858736d,
+            0x23528de8742f3238128e65c88122a5e74f26fb2c1162fdba69f65f7d971d52c0,
+            0x13e395afe32392f6fd5c4c5c728eae324d9c247649a6c3412475c4d04c6b0ea7,
+            0x1ff38b45c4e5b8682a7357723d20949f7b792ec55dfca74c72dcb53fe68c92fe,
+            0x245ded3dbd6c3db094bc040def9c4e8a96e67498f9923224388fcbb441109dfb,
+            0x1f6ec4aeaf3545dbe65de9602ff4a22c48911ca6647bcc632c857ffc99a42d99,
+            0x2431b237299f1a5e8ef22569cf8db020247dd0e7a298716462106e5519d3fdfb,
+            0x2e4939b015f27fdc938f5f1ca55e5d7e912045ecbdcffedeefcf37ac77ddbe5a,
+            0x26c061cde477c7011c04505b0126eff13fa555d248df1968878956209d36e031,
+            0x1c6f21300d13f52bed69b2aeb3dba9760a94ed945673e3283848cfa5c4555c44,
+            0xaecfdb86a64315429605fd463ed664f224d10b2e0a32d35d3a5acab914655b4,
+            0x25a11f201fcfa64aede18e05fb19be93cfb4c15587759d5e5110420a267a44b7,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x133fbbd86858b9143bcc298a4d783e5b8b4ffc4290d1d61e87d1ce5fa4f9856a,
+            0x2cf3bb0c00e204f18bbac1f7f093b9febf2ca7542f44072be70cd915d2c43b53,
+            0x13c1a4bbd3a938e8d0399ff791d86962d7ef1504597419c2c00f421d4459c55e,
+            0x1b008db98dcf53332b67c287841ed73838203b2d8598187413c17308bd8cbe30,
+            0x1e42bc2844c8f32ca38ba9a1d029c7250d75a237eadd2d40969ed5674ff88fab,
+            0x5e9909d9b2a8645974d54fd3ce3e734fc0b99236a2a590e6fc564fa00c806d2,
+            0x1e26282b7dbf93f3aab257ba1e13eaac39ab22fc81b7252c079a192c113ed7f4,
+            0x102a6b3d3a90d1f67e639a27e76023612e096c02df65bf64110ba239361e35e9,
+            0x1f8d425b3b39db5096f4897d43838bb2cc77b4ed0f1d99a7208fdb45faa3b3d7,
+            0x3d122f74d869433e1457806b82f38cd91103972e456ced5ca9fbc375497ca3c,
+            0x17943c0d333da5d18d0856b442553e882c75af5684f2a8127a9d52123b350c43,
+            0x1cf484412484df0cb49e3916db14d6bed50eee93dfdfdd081480da21b5388ce1,
+            0x3e41d466271e7fc632ee7e0acd2c4c446957175ebebf55463ef9e16f48bb9f5,
+            0x2abd2c1f5f2ee158080419092b91d64876bb73f9aa94d20824e06448278f88c6,
+            0x1e979043b35e1d57826c8f7192a1866ce1b287772cb266eddbd177b3c6186d8e,
+            0xbdad4e92dc796512c4daf27a755b5c5dc6c666084c648c4bbff65ff662c667c,
+            0x305dfb6283eebb8f5bef8a33e0dad282ca92ba895e85853d210c7cc82f56aedb,
+            0x273238f0bf3b029f5064ad1beb0129b9539edf1ab828a4d113fa7652f12fd273,
+            0x14b12b9068950f98de141ba4b38cddb1e398b0093d7e118651d518a7980cf6e8,
+            0x3015c78de17c6ccb86e47c1ef08680b12b948b5a56da8a371e6e2e0147c42f51,
+            0x1989f7bfdc360a572379c14223f75aebdf04254a589c9a9aea6d80e020e13a21,
+            0x2a65e0ea8cc0ea69c631c16bd174828cc79e80143a51c35a8dcddc6a36e7e717,
+            0x718f6894c8d87898d8db2c9e3fe7e924b9e31221235f56a11d91c64e4d65fac,
+            0x26fcf8cceb403f4ba44219c27d6e595b794f4fa99db88133fe1a031cfd32b498,
+            0x78d5c5f6e5f3e7bc47044a82bab78a85279d741c5f9d5c8f3522d34da3d8b99,
+            0x8f0b5ea35e699ebc6443284da3218e73f20e8c7eefa51962ed8f0706db54bdd,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xfb6c5b68b5bf3fc0bf849c18e813e610eee228716ce01fad6f05e005802d35c,
+            0xc602aae4b39cd1a84195fc795b9f4650d45b791afe4368689339630feffbc6,
+            0x110455540d38fc9c7ae7fece8bcfeda5602ca72823a8162cc4edf21ff54867bd,
+            0xb380e9795f1ae5eef24029c17d3c2f1b77f2dfd1de38d84e4c95a344070ec48,
+            0x2ecac08767288364ad3ab00f106c9d45fe106b02e624bdbf2bda3f92739ff03e,
+            0x1743f85f877aa121f1a8ebde66a3ced16e0e2c61cfea1f89f8f050d872929332,
+            0x4d0cbd1d1dd0a87474e35d15e860233328e67057c1398d9921f930db1c32b97,
+            0x2d22b693ec70adb123adb300d69ae39ccdfe6873afbe66fbfed0fd1170f0e49c,
+            0xfc8ea8eec07829ad468e18f804cb685425a7f56702c78bf3ef9ce424d2ff611,
+            0xf4aa2f3aad32e709a407a80affce97c751d6d188b6c9ed4dd13bffe6ecdee76,
+            0x5374852d2261dadf1e1404368b67bf8377399ab2a4371ac71ec0c6ec525150c,
+            0x496f544992e33a4f0c52c8406887623656aad3f25ef8feb0f485903e94a2260,
+            0x18a9a16e6ed044b20459820025be1a938747b97db166552581a0372127a75ef9,
+            0xa2f1c011a921def0baeecda662d0cd96c5d54efccc20897ff67bc18e6359636,
+            0x22aec007a72e506f9b0708c0dcadd6a95a61bdde90849d9fa0f7d6ca4900252d,
+            0x12f1607ee6f4c110aaa5575fe992f47e024df0955ab3a985ff5797c7447db36c,
+            0x8a0e21aebd5298400802ad68a96d644378b580aed9c46cb70bc39408bb5d961,
+            0x77214bdfbecbffecf5bf823ee5dce410483c9af4906d7e5e3a6966e446924c0,
+            0xd8a51d698768c1f62ff879f0e478e98f1157ffc88ccc234f8322449689ac79d,
+            0x2ca7d5473e3a7a69e048db0b7eaf1cbe2d15bd97dd62c088cc222af396daf89b,
+            0x1db504c331d3895a78674b2f685fcab2081482fb20b16843abd4c34f91e754c2,
+            0x226760b82659919d5795bb171b21f92fdf931045381c5f341d772a6018d78f27,
+            0x2c6ee4af1e71f1f46a56943cd1a40ae76de4db5447ce6603eae52581f81b35cd,
+            0x18f11a6b7218237066ddf0f730b11e52404b6418028f591d2b03dde94bf407d8,
+            0x1c726bc6da34803fc45168badccfbd6d0e90838303b5256be9f3e29ff5f6b2a7,
+            0x230da928c59a36907165396cc12f5155e3358dbb891941e3a70d239183132785,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xa6958be4b971b6fb712329b991d9c28ff15be0c1eae89cdd4610ce27a2c7c12,
+            0x18fb79983ed105bbab4fffc7c6c532808676e702d5d4deeb82ac9bf3ae9118c9,
+            0x2cf2b459fd8fbeea84fe88a081b89db2e7b502d94d149126f6a532831e31764e,
+            0x24879d31eb0e13c6968d486a3bb01ebafbfe6fb47a67f3634d1294334d834e5,
+            0xb2103302dbc0c7c6c86efa0fc45ccff544cf89e07377b37bd81b2e8453d953b,
+            0x2e2e1fc4c5443e2ee84483bb71d753ac2c70e0993cb280e0d6f6e420763fb7fe,
+            0x1a9e105d58a6f8fca7fb505e6240b2fa3f7d84d1bdf1dc5d60baed683049b488,
+            0x2a1042ce88edc0b73ef4c2c44c12d6d9ca419b2f8144c4af86ed8df0379f02e4,
+            0xda87077919cafe94aba4f234b6fb078f93704bb4155e9a8d55f4c7c8b887529,
+            0x10df86ad83b48800b7b66fec0843926e7d958f1f69e0c2ce3305a5aad0d6b8ba,
+            0x5ca67cbd464f830c5633b84cf3d172f88acb852692358e4bed0a5b69fa194e7,
+            0x6f1f54b5acc18eb09f7ac569c51177a0248e9e8e9da408cda7f06826cf19cad,
+            0xedcfcb405af9c2132a3992aed66c0d945d01ef726888c65a260f3c56f208b2d,
+            0x3009525f3f6c8641daa9fce108036bee7bd265e758ad202810cd526101201528,
+            0x943a87f4b786f072e9637b5b58e280b0ef10cf747cf13729fd4edcb5c09d76e,
+            0x2fcfcd4647f625c42f4c129dc9d782771c761134be63d3140279960e6b5e3223,
+            0x12afa4b24ee867bc58bc57d2e55195215bdfc1f29d541b09bf8f1311d8dcdb7a,
+            0x27721fde56e70f248964e39185a35af7c38e46d8f86a160b508fd63b623489b0,
+            0x2bc75c98655a355c8ef7d48b0db3654bb2c579f0fdccdcee9cf277f2af834077,
+            0x1f49b0d6af4bba3a9d89764eb3fc5a63da95b559607ae0df206034450e40195f,
+            0x1ca12480c0ab186896c01ecc28e0a41014814b9a28de45fa0b79b90a7cc8cf9,
+            0x1040b4f3bbeedbd2ffafba407c214cdd8abd6555cb54d590f2edea7145d9a48b,
+            0x131f9b70a247303bf84112dacde19a9b953f26e7274279dc974b643314f51d61,
+            0x102a78fe962133773dcdc7e30a00f87fcf3a3ef135fe4f01f9a9517b572e0379,
+            0x1389adcc893fb4478e38b3f3477b8c23c41382aa0bffed4b8a54f8c87ccc6285,
+            0x59eb07efee98970dd36e2857a183c43d6ee9560b3c90fe54515a5dbe55621b,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2ff7ccae4b6aed16c52d5cd2b2be44d66968914941d91a3c9c4d38d5c76ff881,
+            0x27404d8154cb43997a5d6576fa461096c9ac1d885a17188bb9d7417803697661,
+            0x41f16639e3d600cb3859f701e46e5e38b88927dc20e429030894d0d2bfa5f07,
+            0x280cbce70a5f719bdf3096cecac201b2c79693c13f01d40af06b7dae353685a9,
+            0xaeba2eab11f80d6527144cb8f13afaf2ec9cb4c55ef424bd00e2ac6f09cbbcf,
+            0x11473e38a5168c35404178e0c40b35a7b2e49584246518c521375af70e99e194,
+            0xdb9935eab2a555400c37dcf884cb2ccf1226c4d931ad3167493ff0a272fada4,
+            0xd9a481cfa6ef0c5c441c790cb8c9b30e2be0adfd2723ea5c1cf0b962dc7a40b,
+            0x2e8fefe6bb8a391222b65341bd25b01b02ce0d88b65a496a9c59abaf25ca0b5d,
+            0x19dad0c5b078ac863acab028bede54e6c1f5d8f4b8c8172176ccfb53740bb10b,
+            0x1dcdd9fbaeea72955e6752f92205e88e094fc5aa4e9b75fa0e173e0425a95e28,
+            0x125eb35ed67f035219169de7f612c1bb3eb788e3740b9054ec89352aab2e506,
+            0x1f64f0f4b2802abd8f6ec78b6a061bd3345ddd898998ab9160a12ba55f997760,
+            0x1fb921d2f30b13504d31f42d0cbc3b3e83714a37353246e6426f2a8da6d26c3d,
+            0x241438f09da43d99917952c9f600d47a3f30b79b5ec80924f4427326d284abae,
+            0x2ca504ece10e731645d09ebe52614c3e0fe99679b4e210297887f45f99f055d,
+            0xef909466b00c00c4d39e13ce788fce28c32eb73e1e4575f396110cd78c690ca,
+            0x28aa2ad31f21f32f1b898fd025f6a9d34abd75cbcf29694cc35178717db80d69,
+            0x2e7e619b01a79ef24869bb8a57f0c1668ace7d7b721e253167ad661f279f67be,
+            0x10925878a22951d216c53068b9e2b8d2a2d4c235ee483963c68e75b246392d9a,
+            0x25bf71cbaa22e93f533d72118b04e187d20eaf3c07c96b86a857e4435e870c2d,
+            0x2c12c98fe7f663cc207ffb753b9c099ddc0de2d774771a7c84fdb379fbadb65b,
+            0x2879d4cfc6efd84feb0d05d1546968f98e11c38374db3f72b753412d2cf2e3f9,
+            0x213c205c362aa0d41804809efa5f53a93c4c26ac9d1e91ecd081922fae6346ef,
+            0x1a65b2fcd5d9c0db8dad898a002a9c11ec40412378c107a8aa0ff70d7416d3aa,
+            0xd6ad0b286a355b4026058b97cc6a952a6ca1ae3ae23641e81bcb757831405f6,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x13b5aadba85b01644fae9e2e542b8ebd5003686bc751399421a798a1ffac6d84,
+            0x207a44c8e2044f2f2e6953c2bf4568e8abd69824f301cca26972266e0e18577c,
+            0x20366c61e53dc8718125d04f64ff70881d22e856a3f4d9224cf8633143a9555f,
+            0x7dd546b57abb0a5f0fc753b8a97526ef3417b06a79f30e5a2f2833d205bd29b,
+            0xbb6251b7bbceeedb0b366e3fb117676d1a31802d373e10117cb07c8ef4abac3,
+            0xc19b0d2fc9236505c7c7b6a4b1bea3f91f56b56d2d4d6b0dda2b6e0f428777e,
+            0x3238596803492252af333365adde8b43ba1ea6722b0bef2d89eb8b215e7a568,
+            0x119c3970cc386d6f0e39d351d0d1f308c857c3547373173d673b72c5d555fc96,
+            0x13574c0b39382b249280ca5e86593852ad435417157fcc4a7d7af23b1425bf3,
+            0x2c41dfb547330e3cd1ab36dcd14b2b65f6db6bff0cf3fc858d7b4555e1ad2c87,
+            0x151ac386d35911a265199613ddf17d28ccad77333887120cd6ec04b1ae5d7844,
+            0x2142f184dad54cfab54f49734a6dc8e858cdea2a2039dfdd261319fbd8ed1396,
+            0x232960591ef4ac647c6f02bd38cd0b4e0f26293eb1bbe703603714676de7e4ef,
+            0x2d33e28f33c118eaa8c9a50322e0796a657acca1822b9caa8368199501a577d9,
+            0x12da53680185973a1018f3c8ebda54b5fdbd196a2b192f27dd4e13bda2530a6c,
+            0x2cea06b27f51acf0607fc354f64c2c3687f86bcf5616dbe9e56385ed5f7246f1,
+            0x12ae9658e5e33252bbc1761824ec8131cddd4f006d354f1dcbd17c6133fd84ea,
+            0x1500265313eafa13e4db72b664aa06998f7d0f08603f3b59a2d4109263c8668d,
+            0x121cb82b95c9461189b38b4f9d1535debbe5e49954ed684767d191d8ffd5d613,
+            0x2792672831f5282bcdb13cb16e9049386e09bc11a74c1b34c2ae3a52a3d69dca,
+            0x9c49e3fde0a20b1aaa8e0cfea69eb95377ad867be9df04c11fa23e9e559ca3d,
+            0x2b2ef2807d34d975db74f912e385f76efedd545addecb765209f531b82c957df,
+            0x7a76c4304adb61e8611d9356708e26b98920a0a3fc54bf7e8341e9e189e365b,
+            0x1175aab1e1215106386e7d6ab6e8c8ab11898648556d135e9d779d932bd654e6,
+            0x95881e72157a04b0e21686523efcc318cd810a2d31afa2c20a49bfa3ceca7da,
+            0x1bc2595f9eb575721f2cc048180d6a1dfd39b2c9432c4288b896ff27338a0c15,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2d72542a02d6093f229924f57769054f0c9f2341187cfcb456b25f659cca62ff,
+            0x2a00d2a68a415131906040f416d85a4293bfe098ef6c6cad01deb413ede2cec8,
+            0x1cb01e5cd271049bb0325eb6957d2e04fe46c4f43b88948edd3b0faea5b69528,
+            0x2e83b677673216f321facbd90699c9f22c2e2629191c76f7ef99b51449c8f763,
+            0x2575e049e33d2f09c8ced4d3f663f7721007dccad5ef54af1bf0503a545d78c0,
+            0x27885d131c5352064f2b1dfd7eccc9c1eb563d86f3d11a4901a4ced089dd2537,
+            0xbe09ca0f50c25da57ac348af3c0c51483babda2e62b2c3b55d00f1eab40c7c3,
+            0x20ea980b40600cbe365168750117a9d40e156e1e7633ff512573544ee7be34cf,
+            0x3f0218ea64202e828409a7c012c47419edcf7ff1c2902792c117fe42756ef64,
+            0xe6a42b289d3df7f5355f32dcf2a507735a0b4e6b4ad2ec1dbe976187f62eadf,
+            0x224853c3ca29c4fa226d98c4e2497e21000225c6a0e0902b3d801d8522606b2f,
+            0xc5295480691ee73d8098e95570a794cff16c70ce743bb8a42dd627715648416,
+            0x148645a642117f6c5870fe24306f9b0401ffa1da04908e1aa0f6b9423986badb,
+            0xbe448a3f7e892d80d18a4f34e16919f8547536c517b49ca457fc4ec9162a334,
+            0x2bc573630f948a668f64606f9128f8f0105c11b08a9dce89aff3b02a00f0a5c8,
+            0x2519650010b2b9642414e33338b47f1d33ce4976d19f1fabf8298db70deca1ee,
+            0x2825ddb803da718800beef69a8630fc7f3b58206f06c008c9876772d5227736f,
+            0x2f2c24da651d81f403fdb4dce59e64a2a6bf17e83f562426a52b79ab5e7401cb,
+            0x3bfdef37744dd23f5ac9e47fde12035773eb7a1c666890f3d8115a0c0f1749a,
+            0x2df9d9e9d2c54cc87d0cacacc229d561566b56b0cd00a68b31dc706e3f06351b,
+            0x14c29bac822f6d9d454c11d35520dea723fd79b06110c8135e178536120a0b8f,
+            0x8b6fe4157191851acee98ca63208dda32c9bf73c833dd1caf158e992847a5a,
+            0x25a3dfe68d7513c1a26bcda26c412412a2f7ae80cfda7afbf996bc81cfbccc54,
+            0x2d3c0299af854fc8e64fde3e0ed04c3bc54292273adb103f74bf623e889691d2,
+            0x8cc27272e1668638fe3f85e5ec76f5ee1595328112a949263afc8d1406d3e48,
+            0x2aeb2bd0a8da3fcb57f5b428f850f41790fa68f5b54b506794af4db04a30a1d2,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x11ef04a3823d72d4a7e073114b2e6791e38b5b6aed376228ac4a20b2eea244d3,
+            0x101022055653fcd3d2659d6a42694578ebd518b5738e6cc884192e1091f58878,
+            0x180f05913fdc0f67f5074c976b3ce2137afcd1c1b2940eb951b8de723397d036,
+            0x29ecb8a00aff8bb64fe2df4221cc57bb0cd6eb6b002eef1f735b0231a72c7e91,
+            0x16156078057591db5810dade70d6c21de3a782d5fa3143211da32ed8f22c0e8c,
+            0x29af8f09441dc2c0e1344abf63fd38ba7f08490f435fca75a26390b4e59b9ba1,
+            0x24d8bef242f5ea95cd238844e9134d9519d6682b7448d40bc9f1ed8920eb49bb,
+            0x2b76b5027eafdd7a6a3902665416cb07e713952521c74857cec4a829375fcba0,
+            0x293dcd5247e1143980134b15f9efbdcad3e7700b6effaa97e17339745e004a5f,
+            0x2ac6a13e798388a97a5d9b856f8fa5aee5036fd0422f9444749f3b8c4b9e884d,
+            0x1f5dc64952b9c1bb892ddae76de8212aa15c49508cb760a4f579d608c665eb68,
+            0xeb5587c5c438db178f2725efc1b739d53d261f52cc4340f6488a8242b74913d,
+            0x2f58f77c4c03e9591ab2cc38567d41272c1dcca473cc4bcdd0a4783d2b07bcda,
+            0x1c908cf8e41976b7d63c3f59cdddcf83cab22433870351c60e4bea21aaf373cf,
+            0x23581184440c2ce0f3acbd6ef778e504f6162f1930e06688417c82d85a83e9dd,
+            0x2fca62a378c65e6d2a0b3b6d89489e8ea6bf5d95cf27f40b16c58a15f05e0ee9,
+            0x2390511812e8b21ad50a44d1eaad9690f187541f7ffb8a0ff44e35ce3b2733c7,
+            0x24660a052455c262cfb78be90a43345338dbd808c422e880eed6b19a76a42d9e,
+            0xdb011c8a8f6df9cc0163eec3eba51b230837db2013659415ffb24b3958cf107,
+            0x1bdd458fa2cd40ad49ba12709f1bd117ba67639f7b52a7732c56b98e6df5b2f8,
+            0x21fd3e66b238769774a650e1159c04c47ea364a48157df08d90d4eb53974c15,
+            0x7556eebb12fbeed954d3e9dc4d5da1ffadd578d4ccaf273acdcc0635edc98aa,
+            0x200a1f0fa4e71fb1aa1c9b45949185769e97d29d11caf13185fab33fab36e09c,
+            0x1795336032f18e1f4e392b03b65bc3dd268813b2f9bebbec00548a18ba37900f,
+            0xb3d2d7ddc758d320c61ee6ea8137f08d2f31f3d159bc918b0fae895c42fedbc,
+            0x2bf1a39486382c117a286a19ab96d73bdaa9c9b45096518f69491f157df85c0e,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x22dc5c692d9baea0fa2685d2c25fc510a43bafde0315da1c52c108124bd40b0f,
+            0x1c9a763950a409e9363997de4e3beaa0944b0f1feb3d917238409584e9c8fb68,
+            0x15761f0591d99bc354aa0bc4a11153cfb0b5335993e4e600d4da4ed88fb33199,
+            0x19374736f4b0ebf7dd3aecf4e7cbb669a53b4dfba1ddd4b951769ee44c51edc0,
+            0x1616bc37e489b1559a3e813544f2d3f6c05a33dd8a39c644e0179aeebc274cc8,
+            0x2fbed52ea54d56a8aae40a2f16262b5cab2bee4e964f32acba16067841ef5edf,
+            0x1ee85a9999931500883944493baf240eb51de8e8015fabdcb9ea68797bb03696,
+            0x2b78ea79b23365607e821a947bb4ba8035f28820f1ddddf1caba7edae1eb2919,
+            0xe84e11e29a4b9ac41c2e953f61cc86d33254120f426e217d2e5727424cdd81d,
+            0x2f28c96987a9aeea275da5f6bd86a15986784da79796f308fe96d7b28bc3b2f4,
+            0x2c14cf8c8c895efacd96c501d5461df5c2f9494911100a4c1baa5b40f8751ae7,
+            0xd311aba1168e2352b438015bd49b31d9f5ca1e8460801bbe65ebf019776ce17,
+            0x2d1ff9afaca2339c66e640fde96fdbe0e586e71d79e76d145acdd126066c119f,
+            0x1c5ec2267db567e8d5f1880899e3add17e7ee0c611605320bf32fa2d3b1842d1,
+            0x202908d4f1a4ebead7acbd09fcecf10a8fe557435ecf51e30834bf136827a83,
+            0x188d37c6825523715475a10e21e432d21a8f921b32665cdaa6dc91d31913d982,
+            0xd976b5ddbc8409fb64b65e1c5f458bd058ff8d789386fdd595eef3a064eabc8,
+            0x19268d14b34ccccd93947b6ec6455b6dbaeeda1ca9cba82f33d6e4e682066db6,
+            0x68d38aec68f918213eeb15a3d5e65b3a3a4ff930b59b733e34b0b295f6db1b0,
+            0x24cf117219d823994d2210d2bc2b60585cbf6d667eaffbc726c2b68a3fe466f0,
+            0x122577912131a547f85c741fffc4d5aa5f6e45453119a63c3004f64651e821c7,
+            0x1996ff6a6f3dafad0245a77ba200d39de3371ca2be5264952657ac703241d4fb,
+            0x1c84f6cd3c3b1d091534dff90e04f0675e6c6e60aa660c3dc4366eaab3ddfd33,
+            0x11f23290442ae048c2622f3be83e52ab302660bc6df31171f26bd42a5f356fe7,
+            0x2311bcb36c72d2a3f8b103c39583be307ab91a5b020252f7c8015e1c9ae7e56c,
+            0x125707cf76963d6475a5dc5c1f832166070dad40eaab70cd31b51e83ccadbcfc,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xb4b8a05506a055387dd95d95f3c91bf6a1da689ded43e1f548f703649486988,
+            0x1d0c6ac842eccd47045e4ddb34e04c1938f9e93aa78b5fe2c0f44b00c6131ae6,
+            0x8eae224067879f0830f967241ed0821f41b0e20f9cd8a6121f07aac10e30cc8,
+            0x73f79694b751847664cd5da30f38013f2a52fc2530a56f01a10901cef975cdc,
+            0x1294381efbe257c11ce6136df76cae6caa4ca5ec1934f1a7f5d4895e97391a5f,
+            0xc80e686ab09da319588f7c17b27db8dc60981c0feb8b2dd58be98ff6b3f553c,
+            0x28b442efb75aa8e6b0d277ac13613d59b09959b3a1e90b457f7d93fa7bae6766,
+            0x302904181cdfa19f33aa2838f6ba83cf0202f22054856155d5c10a0d5970042c,
+            0x2b17dcbf694b6ee011663776b422100989f2576d78504227d547db889adc4dc9,
+            0xb89fd0b5f5fcb94a3fc154664390d7dbc7a8f028db060b7a594f205eb554de6,
+            0x29643b0ab6cd148bffeb6bad54e34bf13cca00ea98c538d900e949f8a223d1c0,
+            0x25ac40e12ff5d3ab47779044da20a35fd1ec747e7f9804f951d3e3994f0be643,
+            0x22b19dae475254f480d6ff651654f808e6c99cf54186094f5a4fcb3d9c992524,
+            0x1c5591a266c5ac14f1c83848bbe3f9bc926c83b4a19031af0334da64ebcc0f57,
+            0x22dfd894770188e65c40390d7ef1a907800ab916118530a0c1b736c885a42643,
+            0x3ce73087e6cf15f4c0c9e94c05b1490f58f2cc4ad3fc746bbace3ee6134f65f,
+            0x2d391381bc0ec52a224a9add14af01b875b9ffd69dc115e348c1d6c3c743ce29,
+            0x1561f352a096cb328906c091a612b9ab92a4433f5d65f4f55e78b02c4f84414b,
+            0x25de146f3cc4f32b6cf8694fdd876a1c9f0269e89d63d48a8ae9ca064ab2ae64,
+            0xf410294c8d91a9bcc60d25f4c73a4797913a27067d1f664771da8d1284a77e9,
+            0x11a522b6b25687e258df304954bb84ceb1aaa9d977ba292ef1ba49c652b033d5,
+            0xd061366179c02608f06b6984ad53a5adc8b1effc60275817e79e7eb031f5dd1,
+            0x14b4604d095f37b5974254e48d7dbccb68da55306e08d00fbbb8f06bebf15f8b,
+            0x2f0d5f558fd4454b062fa33f1e52c5a6559ac1379ae507aab152104f511eb53b,
+            0x11b307ffd788170d196853547920b916d6a6fb63a15d4cab5452e215f62674c2,
+            0x2c4b021e2b757863b41bced2e1aa5be7e77c152e396026fbaa09cea515001c35,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x32fbae1fe345271632403da8c2a96a35805c2a3e87c4457c8a251137bcde383,
+            0x197360c47371eb2f8266e052762cbf42283dd8c4ff1446213c1c11752c6c30d1,
+            0x213ae97ea4c10ec4a64720db8810df370ce3e9d8492f6806e06c871f0dcc4ba0,
+            0x23ea027e72e70e5db4ef89316ef3a127454fa082bd84b255763878395ce18af3,
+            0x1a522fc99812fc6ade296385a9f64cefbabdc59b664d33b02cb1c805465e0bac,
+            0x282bdd7da996a1d58ccd9e4797e17d6a30224531f3d773b48ef23daa5077298b,
+            0x278f051ff5a35ad9a0f1e5ce9a99c9e1b669f58b127b174b1573e76b9a95cb66,
+            0x14d2d438ddd5fd9756f4afe9649c2ff2c9ddaf2e6d1ad10b8dc4550862f7424c,
+            0x18dbca4af7f465ad6968bc7a1837c03d10d09a94f03c3e7fd3f2767e86be7b9f,
+            0xb2f4c4bb0ad8c2047f62d2e6b1024da131588d16986b03e63e8ce9ede6c7fe0,
+            0x21316797b3870762390b31a48e8b33b319da5dab6cd4a0c28170eeea58f782,
+            0x6b3f86ee68e72580f8949c7ce7e789b629efeecb5e71a64d17cb1e8f4b57211,
+            0x21a36423378fe8ddd4d3ac4a6ded8b65b8ba023593a99758ab917ca0b67a324a,
+            0x1ff68d97b4ee71f22110b03e7e9f14641d8e98513a9b70c9e1eff000fd537006,
+            0x2e0d1aad3b8bf21314fd506d418cd7f78887789585a28aaed747cdacf7765b7f,
+            0x148bd4a9f6dcf19bbda66f4531eb4e876443c729ece0612fc005dd89c808efa4,
+            0xc11decd7766f5601e8d5dc09960399e2a441254b57aa25bb3bb80724a8510d5,
+            0x653950fb31c1384207cb5f22e6adbe9392e0fd3b6fbbc9eb25f4064656e5b7,
+            0x61c7be518e2a7e7d9ff8af58dcacfcb3f0499cf7c35ed13929affaf57c95818,
+            0x632546dddba57da93cb55ae4fd8dd0065ec22c94686a63cafb6b151d94fefa3,
+            0x1458d6428e6cbba4df84a44ba6aad2a9cb0d1c9041283c1ec5277b2990418750,
+            0x1c58296b3da9f61460610a21dff1ba812b726a9011f0180e4f457874f7d8b8fa,
+            0x11b039dcb0af8c795298f360dc7f55aca201c35487b1b81cf009fefc204bdcc3,
+            0x1fcdbcfd2065473d499a075bf5857bacba94563f2814577e5705a020211dd0e6,
+            0x2d9f02a658742633b88fe4185dc29bc4297d7aa9dd473740183ae46042dfb040,
+            0x100e915a9be179a7cb25c2332a3d48481deec2ed9196214a55d765309cbc8af5,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1a618c68dba0afe90df2de9e4aa3091ae73582b53555822bc903932747e520b7,
+            0x2cc1683d5312031d06b89710f03b3889066006177c574ce3cadb093e7ff5a301,
+            0x16e6197f7c10ac35b2432c0ca10249b3b39a8e3eb83d702482ffdd8a0888fe09,
+            0x221e4bff156c6a15260b4c5651064fbe3b3cf8f10721e87ee9f72e7021759490,
+            0x17ce9f46591fb9ea7e5794a6fa66b1434fec12507de6e8fbc1e4472d27109b28,
+            0x22fce270c4b0961c89d92325c52c85141461e0994e04132d632ee19d9c51e556,
+            0x15cfedfe30848fa55432b62e7791109698a457ecd5469ecaeddb9f083f66590f,
+            0x3343e9088cfc374b61b75ad600de6236aacc4769e5ee8b9aec9f07bd0969f51,
+            0x233d73ed21179810ccace1227dc72f2f8c80ddb446861d6e833a29c4084d44b7,
+            0x20c8fd20ca1ef20c39e6c99478f2bde9c46dbbc0afa8c840ed93cb153fbc0be3,
+            0x696b187d4df08aaa80aaf272d12f72352f6be2e67568dc45b9b22df83b4c672,
+            0x26242eaea95d43830574a5378f27299753c7907135c9350cc0afa30c1873c429,
+            0x2db7e74c58283b55cf6be1fe422fb2f2523020e04549b7cb88815694bdc078ca,
+            0x1c3db6fc9f3fab8d9e62d048cb1a820bea78c43a71f202f779b8996a1559d821,
+            0x14eaa8042ada3a2a7d247d46b7cc0138b9fd124674823942d207c7c6a330d395,
+            0x7de2b61b5d7796c55c6c9cf4808569d61c78671f7484453d201d29cbe419aa4,
+            0x1db38a0c262bf63e0aa7929777ac0914eda83aab24aa47d84e60ac4ff18bfc4d,
+            0x2f2c6dc0cbcc26d091d95038e04a2886fbe8f4b368a738beeb995255fff09df9,
+            0xcc224d62b63572de577993e48205d0a7f574cf32add5cbe518e55163cf540c7,
+            0xf301c14380b822e1f0319cd575d63e603ec8666f361b500d1d6c28494c309a6,
+            0x2e5cbdd4c1599557d596522efbd078c8e2f9deca7503fa533ea5230b622e7a9c,
+            0x2b7b5611c6e8b5f05fe9fd010bda63b3d6bec1a90dd4e4d95da40bb720503d53,
+            0xac828155aa6627ebf486d5491bac13c32b61cecb4d3178cd4701369c2740155,
+            0x1946be8c11cae21fdd176eafd23fd635352031a5df260edc493c820fe05b00c3,
+            0x19f2dfcfbf6dfb65a8051d60ccc08795e63fa53e3a4acf89b85259e6f85f0030,
+            0xfe752a9169dff4e402c76a809563f0d83c6e26d9ed3ab2a3b0e4070ee7baa4e,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x275833d56c1035de1383b7eb6759e6971286af950f5b5b98ceb2a2a9fc52f45b,
+            0x2c02e7a87debeb5cacd4f9c776b5999b8216f0621e87720a8f672ffd3051198f,
+            0x3a6f6d6dbbd957561e33bff1e7f97ce1b8bcbb97e5e363a58810cef7ee91851,
+            0x116fa8d34d5c67d290555db1263b34d2bb0ce83a89a81c5a0bd4110976efda34,
+            0x1e81d2d2d04f5cc16db99fdb340df3e85d75e9c305b541d2d933f8b808b6e075,
+            0x284898f56dcde9b85983aabb51a7324472955b62538c8c6fbe554080a871497c,
+            0x1ff3a909f501d15420e9efb7f8071c0f4c55649d5e0f81a4de0fe31bc4e694a9,
+            0x47be1a9fcf3bc7845474b57d44fb1218bde905cfa1da8c052a9614280bd9cdc,
+            0x2a3787a31e5611ca3856cc840fad2b0a07bbfb4172859fa6fe527b7e0d5b35d9,
+            0x2eb3bf4b3a98c7da655259991393cf7b87eb9f4908c475f00facfc5572c885b2,
+            0x26aa5f863ce3498db1f5b71c96457cf97232cff235365a2a1091b6a85fc94d6d,
+            0x19a6bc7f148d056a10ed1610f5f9b22a827ba85e51144c0414400ff4d2e91edf,
+            0x196f5c78726e289ecfca7a2d2f6f2a5e82f51df54cd54d4ced1627b9e7f30a72,
+            0x1118c048d3dead019a262810944ef9fe5fa017f472d5cbe8d27b7ffd2041db4d,
+            0x4c7b810ff3f0ded46f2d4cf346e22e402a529d4793314a3bc85f963a6bb428,
+            0x2e843295db044df4ab207a6c7aae26693f37a5e5765663f22c6809e22fa0ed24,
+            0x17cbf9e9e90196672fcf0d0530c0a02ddf4879954bccd82f75bfefb4833842e8,
+            0x27ea08561c8d05998b53f428166ca0a25ceccde43a9ca8bd275b4f7c537eee18,
+            0x3491984564105af9bbe74e7d14e96eea58d73c39727a8ae616bdccb8a2451f8,
+            0x287011118b922300780d5ba09878c898c662b7d5bcc838fdd8750170b643eeaf,
+            0x19af1b66a5d2c6e5a4c34856b37a5a2aa1992546461d6cb65190f74d731e7b82,
+            0x438f8d1a68e04ded124f370274324e9db5b35c0114b3d5e19fbea7d867e1b5c,
+            0x1b7df25e02c2d88bafb19b2f9725a3ddac024746f30b4b0232518d3d4b8e9f1c,
+            0x2fca63f9577b3f88ce614fdf17473f7d033bd30f104931fac24fb3878cbbe2bc,
+            0x1a782b1c4732869014b1ef8926206360460ee6e9b7541f5eb0bea1a0ef184db4,
+            0x16bcba1157829125674fa67f49a62a3da742c2639c62cab43c92362c29c8c186,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xfaa456a4f334a6d64ec7443330027c0f6fdc3d0232029ec5e0b7299ea372295,
+            0x21ae168025d871601564cb94712b6fd70efc57a75bd794f96e09556ac9fa499f,
+            0x2659b387d06b87d28b97c58326d60f8a8e9e20956925cb774f4fb99cb0fc7bf2,
+            0x6ecd6537384d3f96bcfd794a53b1cb3d4ac7574d23c753e20185ac05641a510,
+            0x2c47b359757b6aadaf39168580ca135268ee4030f857e83079409db9f61a7a88,
+            0x2e3c4551ba4ea1bd2f3bb46f4b411ca86accc38c54777867e6b6de8b6381e60f,
+            0x1aaa42d6777c0cccdf6dd9c4628cfb4f9091c8c4e19b218d13c5ce8d41b02747,
+            0x101d7175ecd398cf6b5e339400ed17866953ffde1fd49caf2327ae39ea805e2e,
+            0x47aac02ad51c60e7b013d7e76e0219a33395d4103c62d76426b97fb8a720bdb,
+            0x2159734df6ba0ebfcbdb4412f5e985870f836d55eac7278057bdb5fa002139a6,
+            0x12c80a7f80bc5789e17e76a5323cc6e879e26b2eec7f70adc14e91a679d715fc,
+            0xb37ff835c21aa08cf5e82063ef6dec2dfeddcc987e7fe222a78bc9827c797ad,
+            0x136a6d023c29c33b1812073bf0cf9fb61603ad40ddeb3cadf8f202598cb3f7db,
+            0xbdbf9722d2aed63d0059307617c47ac2688d9d01a8bb20f4a61b95252dd7b32,
+            0x1d90c4f4c52e4c8157ec6ecb3fe1a70937ac8c365100935c3ec4c359137d468d,
+            0x25d8cfba9177d817bfe2db087ca7ff74f3a4ef92986c6e5cfdea5703affac237,
+            0x30562348197f23b21238c777e3d7f366cc9e69e796cb218281b210ac3f1a142,
+            0x2e6b5b67a5f7449b426e3fd32efe3df98af0bfad5006d6370b574b40c645c1e0,
+            0x60c72ab89831fbcfd1084cd3dc94aa8f69794540671bee622d6837d41add442,
+            0x949047c842cce9e422d779c80fa13ecf5aca5859086ae9c3759cd3b02d7476b,
+            0x8c9031e3f9fcc8fef60f82e8026db19bdbb5113c77a4c06fa4af3dd7bdaeb45,
+            0x2850905ce0c275e427478ffb5bf44685dd95cf1f57056bc19108d6c85c3e7cd2,
+            0xc76f19ff9f52168d20cb4f0cc0d10bce93d28b3acd6d479ea38b8a96f944455,
+            0xb66fa2f9d2feda710dca114c22cabeaf616c70ed2bb793a7eaa328ea1ca3c99,
+            0x6198754cf90bc048b64a8e925c41c9298890c946aba20953090e05e55e768ca,
+            0xc637cab8864b9bff868591c6bd14424892702a1d3e654037d0625b258126c6b,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x21325a5b2ae982ee23a4c911b190b63005919d1ace55a101818397c73be72f7a,
+            0x48d6872b84e860e934e439b065e7a162d5705b576d4fc14c47535d9e08bec23,
+            0xde725e2f88af9c238e880d725e71d8a1d79c4be4421fd9529cbda976462ed81,
+            0x27eb4b06d352a3404e16264a0fb08537ddcac2add0782481c2e7735d7ef1803,
+            0x1b47254e3cdd4412e01829f03e74fbfcaf9f882b745358294012761106a0955a,
+            0x1b4332f4bc0f47d8728dac5d12fe99070a53ab0ed1462c6add9ba42c2323f755,
+            0x218d22d5f13b09ace89e377cd7e02d3b52b74a1285072d62540842686f728ae5,
+            0x68ad6997a9ced270daca95813e82527f7e6a4d5cc4911c7e0fdde7a1a062d03,
+            0x67a187bc1e0d1740ebc7f7343397b235ce0034bd6f6fdbe43fc50394edd65cd,
+            0x26d27d9b4d504feb1adc50f40bc7171e56e9cc7b17086d68ac09bd337ab9a756,
+            0x6e901afc5dc879d75ef7d324c7b7c8cb8772f7948829dbd2293ab032a9ce962,
+            0x14c8e19997ea7bb4131f9765ed587425a2fe5f91aa4f4c918201e74110bc7526,
+            0x273abe5cd98541349618c993b7192c978fb02fc236bd40dc3a4a4f61dbce96fc,
+            0x715d346135f3b13f84a62b794f2d00bc19cab24d35d168d1f95429d8856e296,
+            0x2b9bcfa6deb252ccf6a2550e198f21b5fe0800fd3af70329500481a1f472f174,
+            0x239f7dc3817df74d0e93174b1564fbdb7e4010b69b32ad0618a169748e496c9c,
+            0x21978d48e2d9c7b097fd4d0cb72c238855c33bc79834ef7b08405b1b6a25b3f6,
+            0x269c70c27b7564c9d24a631fd3604d4238528e20b010912916e2c1927df5b950,
+            0x2c583dc96a0a9dc9f9efaac1de85327f007597a5e812fd564df9e490b5dd8f68,
+            0x121e4187606e3b3382106069e0d56de26dddd453c81d009647a9cb5f48418094,
+            0xbeeab0c615c4acfb17eb9f8dd647bf03917e1169c9c38d0f397c10e9dad80ee,
+            0x1e07049aefd34f62eb9b702cdd93e84e4f5bc2bf88ac583ee4c8f7f358638c3b,
+            0x59c6422f0c9d34dc813948bfdbd3d525a5050122abaa725261b21794a4bb03f,
+            0xada60827cce301bb3aba3c0dbc1a32d14cf5723ab4a85abd48baa37b85b318a,
+            0x10370b82fad9fa38906fc9afd3d2103760b279a5a79803039ac6d7b47fbfb080,
+            0x22b53d470c374ee90f3477d1bb36a57a7cd3e39305dbf4895d1a38df65828962,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x121bac144ebf731b7e106308001501b5aba39256622dc16b6832959ef32d6a8d,
+            0x2ce538366c9cee7a91c93252cb96b7c42b4e4b26a6be57c1e5448524e5acf376,
+            0xe1eb214d4443a823686062d4f44fbecbe3cac0513ec37dc6969a24a5c2f34ea,
+            0x2b10f3aa519015cb9f2d8e03efc3e54d82cdaa8825760f40856158eea75583de,
+            0x13dcdc97aaf8d23d666426b008a02be78565ea485fc5b3175f2a36d3c6589a4a,
+            0x1e179f5a8d8cf761188a1af7f3aabfd0c6586a3ba2da4ac2e609406494d8b04d,
+            0x26350c1076435ab7615ef9103dbd8224d3780d72055c5bf265bd8f5bc459c5cd,
+            0x2569aad1663fbf0c512be5d7549b856f5058b8d9254ba788ab4b67f957703dd6,
+            0x21d296071bb18ffc608d41b9284b25f99e896f90b73c4b6ebc6c7e845dd2756b,
+            0x3403ad2e4edbad53108b19db3580bbeb575989bf763939ace10bf3ac11ac946,
+            0x2e87a068e7e10cd0a27806e4eb87fc4a909b75602e7ef4d9b49732d30f8f68b2,
+            0xfecb01322ccd429e5afeee9ec8f3888c528252874e09ee6c82110bc67e1133d,
+            0x21b1a2e21480c8623fbf9fec55cda799a152e941e99d0d6426d24666ecd9a7ed,
+            0x10787afe51951f551c5ea3de6eecc8c08adae2debcf2c0add7a578db5db669a,
+            0x129a75842ce7f380f4adce069972a00aa0550841e41ad2f46d1665177576f052,
+            0x33844a0d5987a19e66c014e83db7c903b6aa7baff5cae3ec6f2e7f9870a7102,
+            0x2af0d00127c68081dd29a5c0858f6bb0d20d0e8c8c1fa50d0d539436a66b4950,
+            0x2452bc4a8de2db1f282d2d8063ab568d11cf00ddd0ccfb165523b0e7199b4278,
+            0x7053595c4f99205b79bf985336e456422650f494c2f79670c0d34257ec689f1,
+            0x1bad1a52d292401b1a8335df15429443cd8dc8c5e856e185b8c5f9d0c9bd2a24,
+            0x24635b7d3ad41a5bc44a3a17d80a7818355ff8f18379004e5344a7b1713a31b7,
+            0x2e7876129f03a5f90702ccaaa35e3d3c2709756360421113997cfdfb1ed927be,
+            0x1f6028d50d8a7ee644320cef9612807c7ef8fe40223751dbf8f791ac516fa897,
+            0x771c9d46f602c613a689a8334d46e0e5cd1d214a4831ebbc53525ab2d80e5bc,
+            0x269f052ff6df5ae60f76c891df96d8e4a23e80371c82349ef960088ef64b141e,
+            0x2961710040a2b2d6ac5101cb03a28f3bc2fe649baa6efc5100592077f15de362,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x10740ce6766bd5d45ef53a0b79f688c0c9a075938902c676cefec8a82c3da53b,
+            0x27f3dbcb60ac79ca5eeba26c3971c64600543857b0d7a6019b292df5d6084e02,
+            0x21093160140db2a25e4a17cc7600123cee22ba57790926c04610b8c95f1fd186,
+            0x891be8d562bb6feb60c7571f367d6048c3b083b2adb097a27e62e336cb27a47,
+            0x2ffb17d674958fcb7a8da2d38554bc5571c6efebc77e89514688212c68d50a1f,
+            0x94c68828cd769c940b27f645dba1922d26898c64fef55d5638fd6e1d357b75,
+            0xd55cbcf35eb4b2a41cab995bd1b90571e4a87677a90e62793f6073343e798f0,
+            0x18e91bc3e095f9b687fe66cfdbbf8c234c27af317f13fc27707d271e871e7061,
+            0xec0612f29bc32d89f73f7f0926fe0b3f3587dd7eed49c772b3aef2c5d41019,
+            0xccf5311099aecc81a34b567999eb4c663d907a8bf4b22c2f2ab63a324ac3451,
+            0x183ffbe622900edf9b6a8021ab80db00676f619dbc1732dcc8fad67128772d26,
+            0x8f4331aefe28fb6f009e17ff632db3505b18ffaa61c6b0d341fe0b6387ce2bf,
+            0x9eb7f33498704db8dff1c8777ff539d1ded2bd207fae4bb7465c375b8747161,
+            0xa531199830d7120018b3039c7afa9a084d529d930f865c38fadcdc40bb008e5,
+            0x194b3cf28d7b62413f9b837b687bbb4804733c8e174e76bed846f92068c066f1,
+            0x1b8604e1486a35ebe8e6b900127d0dbb54dc8aaca97a4eb0c8956773035f3ef6,
+            0x9b8de36766da341c7e0b810a53903be22879912b707e1f3f752e6f079ade75c,
+            0x1a435eb920d2b84fe3c0b803ca2cf85a6721d31f21778706d4a87a923ad0ac35,
+            0x2566d9e893c2afd892f4702accbcbb979c7cceb980d234de549a3c6c34bdaf59,
+            0x18df8272b0340557ca8fa98dc6e75c6d788484702d389f13fb82bb09dd5edb19,
+            0x20b183f7293c68cc2324f01a2693d3edacf0c28691685520cb6c1ff79f25bb29,
+            0x128c7a2624a1bc92093ebab7ea53e0d5d53b059e21004b19cb0d2bb3dba74f31,
+            0x40287c11b5a3f980d59ec06db46c6fa3b54e9d4fe0f474ca15a7aad1ad0ec1,
+            0x21d7fa42bc56b52d557e34b091518d6a694595207a099c718b87b6f216ffcd7f,
+            0x169dc2796511017c3e4ebefbe57d6f93194a77513fda84ef7457afbada8a5d58,
+            0x1d74ad732a1dc804b9584e557a9c18c0b497200e0d27312bd2432691470566cc,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2aca8e251964d1a3261f98ec83cb17d611d17f5758aeb8b34a8121121f7eec67,
+            0x12e284f43dd76a9f1751d11335d43514ef963ffdf2036171cdfd4f47c99eb5b3,
+            0x5071e18392facabeab0a39fea36c393572e98073e18330d9c4c7e654572065e,
+            0x260d7455c8470a5ca5cb7a63c39b0d1fcca3eb1029d2994c5f2c19a39086eae7,
+            0x1cf8584e37677b19fb7a05446448d550fe72a4fc79c92e93e7576f101dd05099,
+            0x2d19dba2b7658adf60d8840e9c7b115fc37503198335c9050470ca3c098cafce,
+            0xd98ea1ad72116cea32da96c74565bdb292b6f62671c5cc9de0904e1ac8a3918,
+            0x24ac021320aa1f1addee655d4feaf537e470915474a285ab11b80fd166a20cf0,
+            0x216feb63069f6947beb294a1c7240b202d132ae945f7cb81368a2c79223d1131,
+            0x20ecca83ee5156e6092763d78973859dab5cbf438b6782f4d4727f07e7951bb,
+            0x1e632a42fc326036c1f3313f372803cf8912d762b3026cb4b868ffbec464da38,
+            0x2e652d54941af14d90b4347529d6e8734e184f48c5827373e35e96a0441d56b1,
+            0x251ff531befaaafc6933e195e6327a853e70f7956ea16f99bae74ce703e13eee,
+            0x12ac47acb9b712578207e429b989e017e010e2f8e513e5fdca0d5d70cf69cfa2,
+            0xcccf17e0d61b8413ac667303d31b27e5bbdbe2de4fb79272fd26a96a6033c00,
+            0x20f2060a29ea58ae11aed61e371eeaedf8c49f7d2d310a20daa4b08742a9c195,
+            0x1cb9f0d68dd3c14610ff690400ac156b0f88ddb3496842a82976bec878c1fcd0,
+            0x1e75fd54061e8660fb82a6f24ca385580d37c17fc731ecb67aae86ddcbd2c363,
+            0x2d29ebc4f807741c6975700aac34dd02857b9ca3f389a34d281aee269e9509da,
+            0x1871cf71711f4036a0104f07506e2211c40ed44327c7e19acbc2400345eb7bbf,
+            0x630b7ea40ac6a040959e71933395a414a78ef993f03d2306233b0aaffe4a814,
+            0x1ea87ac112d60f22961d5b2da26c0a06bd4dc1e73788a388ca3bee772cc78e7f,
+            0x26a7a6c245da9cf530f87c9b20ed86af369087bde004bb6dc3eee8b32882c7cf,
+            0x1adf5a028ce2b8a0787eca43ebcf427dce7bb7b3ac19fe0a8c0b7016afb25e6c,
+            0x5e2e3348c9fb090e628aa40101db8b4f46b6adfc7d31fa82e1f6c9fe5b55a1d,
+            0x81d87bc2e14f185b9c19f4cec48fa501d99c70a2bc881ccd6ec4f6e677721aa,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2a7ab507906adcb6522c043a1b2cb2f221e5470822f048220ba731b3933f3212,
+            0x1e0791ec0c83cd1f3a0007ff027dd589fb0866c6257c181d293cfb70b62abe59,
+            0x19ad62da7c5d8766ef927edd0f7fbd997d0e6c6555a6c38fdbee7f5299b26d8c,
+            0x1cf518d282e00b1894f86c42ccaa292dd208bd0d3576ecd1cb1c45d426f660cc,
+            0x86e5c668f2c7540e65a379bb9738416e1f43e0b41619cdc040c321aa89db7c7,
+            0x2bcd694a683fb621601f2a5f0f900f6bab1f4291d65bb8c26537029484b38496,
+            0x2b6f0a65bade0adb23efce9c6e3629a07cefca2718b3949029362c6da4baebaa,
+            0x12b25f49fb1cd92da7fe1fdfdbcf0ab1d715ee92ae7e2c0b2a60b8f4106abbfd,
+            0x797c7a863ba81aa2acc620e089ac0afe2f713e46fe4d52ccc637953a4ac2f02,
+            0x113166107727b2ccd9e2bde6285860c912a318ff3cbe1cca006973f444238f17,
+            0x29d8beab8a793123bdb47e3bd56d6e0d6e4c9d957b38d6ac7ca7d53a30fdc94c,
+            0x68f99bd269ec2bcca30a5c05afd5136feb63a3315e05dadb2acad3caad1c7b0,
+            0x1d8a2e95f5012b9744d33e3db84253261797fadda47ae08eebd349753511d342,
+            0x26a6dfcbfcd2a98fa147bd0b18f3e4f66e1f1a329a168e3a61336e4da3bb8f80,
+            0x1d5bdb15bbcfd215d8caa665e9687c2d8add0b51cf54c5226ed9b89866f767c5,
+            0x2bea457b568fc29ac1a23ff4322caed5463a9cd648769e8a1a118aae84df1309,
+            0x1dbe7419ee59dd580a0ab4305440a57fb651830f979f8d21656ff28b1590ce4d,
+            0x17ab1d55da8ff17391ba874c4b6e52c77dfd316a0cd9566d1e28c5dc9308d309,
+            0x4a3a0d0f9e1b091bdd336acd117c4ede9d64621c6b2ea4f07726e065f17e2cb,
+            0x2634ad4e91d1f63da6e2534c1161abec660d92371ed85e8f0e39aa91523b9e60,
+            0x1afec968060a10697a3889bf3456a23a4e98c3781d0ee88e29334b14cf7614c1,
+            0x23a5fd23ec8919d62176ff3954f983577d5ea821cee695387f096c7fbb93808f,
+            0x283039c47dab36071299505922ebc21482295f95632d17c49fb8f07e382641ff,
+            0x1a0084bc1b3e951aeb3dc6388708f8ebb52247527a393209664d43a1812e13,
+            0x16fdfa540f269b40f27696610cac06faa7eba7d87542dfa42d28d3f453a70622,
+            0x638bad28fc8427c2349d2930b08631be095bf0c03572131f3a8132f38f4c0a8,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2b960b4aa6bdb5968fd27106ed926399bf40c9ef7a0abce38158191156d94b47,
+            0x21ee2ffd320737215ba399d91f5287b56286e5f286441b29e7f4950f2a108d82,
+            0x1a912af8a3a82ac944bc34390ad7af703d1e4a8f32996ea0eca203709bd526c4,
+            0x1e2d77fe49d12a919d8ee0b0bdc15475f9d3d5dda831b098a921ef8547542ab2,
+            0x1e461b0bfa65838c31b66e8973fd153308af46e6563e523b4c97bad304ce6bce,
+            0x1222b1bba586c324581ddde55054315ea378754416b7b74406a44d90468839d3,
+            0x231cb90d301a6e6e3f6c47a07a3f262f14370bda5a9844a4c128076b5fdde8ac,
+            0xe3e66e543fb59290a8d57f5fda43c4b74b235e00adf1e1440859d8f252fde19,
+            0x1bcae3acb52de61f2f907f6fc16c142016e053640c8ad9b4e3baecff97b2c13d,
+            0x2a2e7e286f90e3554ac96ed8f80267a3bd9f747d787fb2533bb98f465931f724,
+            0x1729e7b06ac26c624dc5c6cc6d761f94d93875ca170cd57f87cff909e922223d,
+            0x9565b3ec6e63401bcd15d12f12d8c805ec5c8936c2223ca4dd510a57afb12c1,
+            0x1ade0fa28ee13df4d382a505b3893baf5b4568bcce7121b5d48d29567da13a9e,
+            0x2301dc6a1236420c051aaf16a095e77aa88f23f63cb30b410a323ba77f21f7f0,
+            0x158c6a01fb01f542f7dd93ddf2ba1771d726cfaa7c39ba5260a5f6bbbce3b9de,
+            0x2757b9eec4cb27d4e4274cca6e00289f2d12e987465c267b1fa104b02932a84b,
+            0x3043d8b0cdac25b084aeab7475766326ccfd15758870a4b47a8783f73f5e4f36,
+            0x1a1739fefe6488c79c6c32818ff62a65afdefb9dc62a23bcb3d46428cae5cd88,
+            0x56f91cf9e2444d0d477c13c994388d88a2d8e1b88d6080b5a415a53117643ca,
+            0x28c8f42ca93036c7226451ee7ae0c1a7b87b0c560de7b11350dc7f74e4ae51e6,
+            0x18dcb540315a43872fc246fe3f6779a237c61ef5527e87a400b24b3eda058469,
+            0x1ba374f70de60473f60fb7452d42c59f4748debdd345afdcf94d09305b601a3d,
+            0x1b40af6c2e106fd4756b548837d64bcf6dbfb9d9380e1a70e010769efc2281ba,
+            0x2578f4a6e3dbbf2ccc5e1837b4038327925cffd00f96e8d2fdac677f2b0faa3d,
+            0x2ea53ec4f2f8900d39df68853f2ae9e969819d33bbe6ab9686e1185c37933660,
+            0x1cb7cd707a851d764b7c3d2da544afa59cb87f6ae19971eef7f403342c205aea,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x6bd8c397b1e2d8e3b0d32ef2594a311d49a259567ae4c635582de9cd15689bf,
+            0x291adb6944892dabcf5217145ff77361815e58600ea6248b0c0069802557ddad,
+            0x96477873e56e5691171631e4eb74c7d2f9b2806b4f0e45508220739587a890e,
+            0x1ff4f6ed8be43e079ad849d03ff3147fd6b1fc0db8c1b8477d65c096d4b25a48,
+            0x9e5e4056e55464d9d5e6ecdf7127667de411a716e88014861d5436cffeabcb7,
+            0xa73b0495d174fe15185e4bc010a545402736752585288200ea5922c5f8d29a6,
+            0x108e0279556e28f04c5570a6274d115d4b3b1bffd7fbcc289cebae7053f40427,
+            0x20d97451d83aecfb5c0f6cded427ddd517ada729de160d4ebe2429dba9d28a53,
+            0x2d8a77024da1f633ae52a6cf17898c5b908f50ae49fdbe65b4662853337cc919,
+            0x10571ff92352d4e69df05c3cdc65c0e52747e03f86476850a47f092bc272b263,
+            0x18f7cada1c661e5f8f2074f16e72baaa705c2ce42b68e16fdb4d6945a33054e8,
+            0x786ff337450d3614fc75c4d314a61395b71473e735332d78a7aeb270443cb93,
+            0xcefe88f60cb9a382d5eeded9e7bacac15e7c906dead35cec09ee6e6d0016b3d,
+            0xf163a2012b2484e1de36b5991e59ab0ffd4a531574f6c72382fe92576ce82e8,
+            0x63dc4f07d9f069d06a30e7c5a96830d2731ca8165abd9ed89d187753f29c682,
+            0x71a3293473c1dcd0ccd5a08dec6a321265ac88dac53eea581264663e1dff0d7,
+            0x41b8d2a056f60d8d3ce5e3780a341b97592920b170625c1a69f2a23e1290268,
+            0x2deddd6775308aa027b3449357f8abb6a6d10e11cc3a14d0feff23e3a8597ff4,
+            0xac050f54534015c810863a63b7354a35fe52279ce4b7a142b48f5502702a4f9,
+            0x215bca7ae4832c5946f9ad54abc0b3e7c547f8a5a962e4df85d0b82dce914799,
+            0x1efcb27d3c098f574e7fd799e2a585ccf54a59147400ce00c86da0ae0ce90684,
+            0x24ddc6ad9a48856da363007a1923d1106affa889e44ffa7959bf41edba382efb,
+            0x2ef8e41f289aa4c64244554413eb515b9759a6b5ed9e2562d1a674267171650c,
+            0x2f1c219c4d272380eb411db7ef93f6e692eca339fa507b656e0d532801c0e205,
+            0x5f18c83d3464488a90182139c312e753a60ca4499e3c2c13f7c2e72fbf47395,
+            0x179165ec0d175758f57172f5a9f7d1ce6e435a4a1351d77139b92c6ebec86da,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x11c208a0495e0e7c3e473f98dd1e8c61b27b44de88dae7850122421cda7cfbe1,
+            0x297f95f2fbd4565360712a71bf3c80b798b17dfac6c54d884d99f3aa7d673dc8,
+            0x224ceefcf32d746010d8069e79d356d69671e3aa9403f39892e5882a1891e718,
+            0x2732b23001c43c62c459cf0a1f48790deedbdc489a6372138594a5a74e5f85ef,
+            0xcffe59dbecf21803d789c62b67f94bb027de571a963be229c54c84ab106f9f1,
+            0x29b8feb4a9a3585ec376063cff8e0f5a4292f37f7a4b7b1ff228f03f5fac0510,
+            0x26a0c0e60a2ffa10be7d6b2c878312de74cc43fcc7f9eba49e05fcfcaa3a8b90,
+            0x2e570656db41e2f88c3de3c09d68baba727e76e3511dd4d1291443db29aa5f70,
+            0x12bb58e4672200ef2816a8237dfcdf70a9fb07b2ddc8789b748d0b559b7cbb78,
+            0x216e369c8afad59e15e88e3ffdfbb1e137e9b314785632ad2c7c81bab01a77dd,
+            0x2279e39d7921b8e04b6f36503059b1bf2ed79a3b94f15af97b9720bff85ac25a,
+            0x60564813a0ce62e4ac21a85ba36fe359b53e84244f908b866568084e31c4afd,
+            0x2268a405631dae60e8eac4f408fbd5268b40b1c254970e3c22eab22fb8ecc554,
+            0x300263f7d8a2567496a37ab94c57e2015442257c062ecad9d8412f6c6ddc0089,
+            0x1963bc7aa03a152df1eb518cd9588bd04f3fd21a318314fe0e54c1f369be3c0e,
+            0x136b67c2b78e28a9c5276c6fedd9afad286d344700fac868de5548c404abee95,
+            0x29a329f4a94c6c6c9fc81e8cd90f7f1c9e5f6c89875a280dd9ea0b4b90b8ad2f,
+            0xc3d92aec4b647cb21e6f0ebb98ef3c65c3450672ce4694f49f39919ce6da1df,
+            0x2f5235ceb5912869936811f841c3ee0f648bafc9edebcba4aad0168d03f9b52,
+            0x63a760609f24b3692d205c9b3bebfe088c215877de8d79deaa84dff83abb2cb,
+            0x1965360730aaa2fb621c470e9042cf5db28c4824575c994b255c92b02d0b6524,
+            0x1838e4b596dc759d6a97b0b763d959bdffc4ba10f84ab4b1c4c71d50a924d179,
+            0x258cf09bdda431facd55b62aa65712248056e3edd9428b010a809ec78c41ac86,
+            0x1e587e52329f0a29bf3db7337442690422a9722e228dec682be39df28b3bf14a,
+            0x120effe3050205b3ed1c06aa186bcacbe860b61e77bd06b9b71e78a710a09500,
+            0x18213dc619ab928f68d5aac28df923f90282b6ec64d5ac376880d31fa3bc1d5a,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1f02f7e2e07843a88bcaa2797d91edf88cbd70ad743e938e35396628fff818c5,
+            0xdc5a85d95f105d8e4b18eded697c62a032136374296ea9b14f54cb0ecadb9ee,
+            0x219b60e6d5a22578775e83f4474206559204025913238a98fe09297e6c473c8f,
+            0x435530e014db11e2bfcd58362982d8a33e222783a5bd6db56bbd327cc5237d7,
+            0x28c1ffc5c10600c0dc9dc3d193bc58552b235922bdf46161b6f8c4cb5a6cea5f,
+            0x1bf7a2f7bf358cd12302582a3b02600994fce154fffc218ae6442bb46026f98a,
+            0x179d43fb87170d3d97f4a0166d1663da78664d328cadb544dbf5d6c5d611de99,
+            0x8cabf5f7d8a6d458bb6576754fba5a716ae9e484a668217adced3296b7cccc1,
+            0x177be1eacf22f916417a28651e18d379eb44e5c2000e329c1d3c8df516c1194e,
+            0xa5fae0f09f85d5ab6b22833947da6cba0daa2a9671ade494b7f9d8367394987,
+            0x28df87b43e795b370762f1d3f9dc2685e91bbb7a6854acc152f705c89db4938d,
+            0x58de2c0fe8e6f09f1b853dac8eaa473e4f6f80fc20e0f4190875d94cada6ecc,
+            0x1ba657cd2bdb97e5d24bdadfe5cc11a7543f54c18e65039c0e616e138de5e368,
+            0xea5b3a4116ce4ad61e32cfbf9662a60c542aac16016d551149c76700ecc44f7,
+            0x2c219d3a2b0e433c1ff243db27a237fe15c733edf0f0084d7a5ba40123fb7361,
+            0x19ad974a2285cbd14d04045c6414f199a891524b798cf1e3d692b742cd6d89f6,
+            0x2c7d9c944d792ce4b7535207891386b722458c54fbd627ba39521ab9cbc1ebc7,
+            0x2e71a3a451566f8919a27edb83647652520bc5b920531fcdcb2859a5ec77bf73,
+            0x6a4b1b530cc5e64e84e725629950bd7644f65e7223dfd4986161de535cee83b,
+            0xf55042c0a72b5b62d2107153b60482981bda1190bc8b8ce4e30ad101fac7464,
+            0x20378dc7686d64b35b84440493ca10a587a5505169d380fc5c5f4a9ee803fc11,
+            0x26c526f859170915382b65592aa1957e73f3145c970cd7c891dc86b7d3cd41b3,
+            0x194c4e5ab7214877317adfd216f34310e5bc07da13b67139dec08cc25bf2a052,
+            0x29e0d646063e27cfaf0e4ffc0546f1b309333958e0ecaa3632bb9fbdcd0388aa,
+            0x121b4451014b6382209a13bb0fd2727e59f0702a081fd34e04c8ddeb87d349fd,
+            0x3018ea843d3f3f525b9f96b6c6c07e5c86d4a113d183cf66141aa80960048ef7,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x26a889065a9131ee8541587286f27b8ab978d106cf21e7cba567839eb83cf5c7,
+            0x12f2322938e02f96227e539152719a6fa62147cf82937a0c980eb011c62b01d6,
+            0x2a7052a220aa258284d8bcb1e0646c0266349044ca3c17bd0bb628ec5422a75b,
+            0x1e01d825bd60d76a2040b5de5e43b90d1bfbb0876dabf550baa3a5dd47ad62d7,
+            0x3002ff6560000420d0de98e87d335432be4a58ff3eea053d2d332354cbc22da9,
+            0x3d28736a2952e396f2de28f3a567902027214706657773431d54cd10c0a0464,
+            0x27716d5bd3e14b61afb8d6ba91b27739f9075ff2630b19c6c2c26c5d5496e195,
+            0x13cde7afb44e0f9b6db2793a51226e40aee9d5e7fc75ed7c663fc2d06e9b8526,
+            0x503aae89801bbfc5f702f60ffa566477a634dc17aff8f9747d1fd1fbb3cd336,
+            0x1ea910a5da3ba8d8a39930b38b64ffce7616fc9c8bc7fc1fdcf12b650d04089c,
+            0xeb1ff569a325e123ede757ea250df5f41f75dd2b75c6532ab96dfe64cf7f3e2,
+            0x16cc1752c575ce984729208e79714c336bc3224f951fd6cd0b82a2ac4d43f892,
+            0x2653378743d2eea387c330a375bb80e67878a9740fc2425a36315206a140175a,
+            0x175b14e3bd393d825ff9560dc4ee5834c69beaceb5f8580156ef162c6d36369b,
+            0x162b65eff59b3bc39a2ddc923c77da7a17dfe79b7557b8383367922fdd8aa5e6,
+            0x297d9796101df9152043297c780dd5137e6bb2d9a25a8fa92187b5de2399affc,
+            0x292db1438ce4bced35048fa12b049bfa359709bca7dc314c937f0514679f0d24,
+            0x19c2715e87c332adbcd530ce981d8704f0a207e822f190baab421d4d03d24bd9,
+            0x139bf2e121b6694f773a58f70956cb782a37e4949e482d87dc820b034ffd0f28,
+            0x281e06a2a3e9c7ad29265b2ef8c1f4814adc59e5b3b605a05c3cce8a59e321d3,
+            0xbaa4181dbff92f83386e95c6cae0c8efa07f0cd6e822bd3769e4ae8c64e7d9f,
+            0x2288cd08659c856e697d93558197d16c03fac590096ede68e959636d09956d9f,
+            0x2af86b3b3cafb3ace42a0cba5c99dcce7b0fc35313b2edddf0401bc029373c1d,
+            0x173806fe4b0512b715cb7e3cc8679d3a7a4c2b7174e8cd710574b3c142b8197d,
+            0x25b66da637a8d92f088d8faecf034ab77e2b2c3f88fce5c560922f648eef960d,
+            0x12f5922b95ad36bc7a81c2fe8ffc729342bd3aeb1555969590bf2248d70a3e91,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x170bcf0294ae4059d95f36684abb4fc2cd0369a67be4bb919fe185aa39467569,
+            0x17d247983fbaecafd39c9dbb1fc2633ee7ccf02383978abe8bba05e7bf498144,
+            0x275c74ba59d68ebd78d02ea7bfc087b17708544436bb5438b41b053072df4836,
+            0xb97a196195430ef69cf23dfd0906653e5808c3593449bf58c374242ef82bdc6,
+            0x25bf621be7fe04105e8a50b02ed9025840affde6bb3bbdd06df97f2fe9e02e38,
+            0x296928baa83c1016ead86e5c9011b134d5d24179b1970e68dc89794b73d024d0,
+            0x23e6fc3b8617b6b51f35d983c470a99546099a6361ee1626e6e44e5e3e2f7dbc,
+            0x1b9b57f457f685d54e7f7f332af4233d293106f56ac093a07c209205217108b6,
+            0x290f0ac712987d7956e8b4dbdd8b6706399adce9506e3373d229d45605637311,
+            0x262a3b6b3986c250d387fcb734cd914f5e8bb751b571fad1ff366a479e3e6538,
+            0x295b88ac50fee49245bfd9bd911734324c8d00abea718917a4dc6c21b3e507de,
+            0x2e7a6894330ce6d6478206619aff889fb1bbdcec80e6f09de69398f344a4f6e1,
+            0xc3bf1bb2ee94489afed3633b8ec12dbaa4b6a2003eac80e7f1668ff340bbefc,
+            0x2d61629d203317ea4449e200880be2ed8421aa6f2de73aaa56810fc304eeaae5,
+            0x1d94aec8d967eabceea3de4acbd2c3b19fee00212d2dece58d5ae53bfe6037b6,
+            0x2f76d72fd59722c377e315583f91b326ea792968fbe6bf73582aaf7af697d3dc,
+            0xd243da739e905f8b000912519379de3a3bad6de3c3aaf91cfd78f9735b0c1bd,
+            0xacfdf5f69c09506cb85199eacdba0b9b3c5a0fa1a60cf283877ff7efaf3bcf7,
+            0x44de47687196189473b125ea91ec1ceb1481f8f49fcd47becef1b01f4c9fe09,
+            0x27e155dea5a1134466a8e2ba58e2b03cad8c38c20716a7d3e78c483b019e79b0,
+            0x2860ac51f3e70148561d5c109abdb096225aaf9b7bbc17bd7aa31ad26e243e75,
+            0x1a33e054ae45916951f73826b9badc032ed3d0f3c21acc7dd18d46f268cd2a86,
+            0x237acb3608d9158738b6b37b6f6b287531d9683bbe16b463c946b752c089ab8,
+            0x9328966036d95ecd345f77dc984391d09732acf567d010b855e0422365c6209,
+            0x6a41ffd9721ef018d7e9e2d67b8d9820d6a80be401e1617e07b29b3c5f8e53a,
+            0x1bac3b3b9cd40ec41b542b47ff0dbda03997f88a37aa23de69d0d5113e5b448e,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x17dedb52641d9f9e688a673980bf47c462346d1d6731db6bbf0c27ccb2565173,
+            0xd947949f35e75c29a986ed662cf1e1d85c2e3f3a9489da6d7a6a6573bf3bdff,
+            0x2bdb20a8327ea3f509eea1f81865ac34f7e7c5dc43d516294a29c208cd0bac7e,
+            0x2fecb170873731d070ccec6d88733be3275e5be22a47cd294ad7247cd75247f6,
+            0x1183c981f815c35119fe4558a0aea9f533f9d7980195d96d75a80cb1fed40c02,
+            0x5fa320ab5dae365f8a114d10921a5fa13f79f44f18b57021a483eedc2c5bba8,
+            0x2b951512add2c708a010d1ca59bed166f3726cae5cb1525dd379156d810e6c2c,
+            0x11f646514881127c9f1067238c06a7ca39b9c1a0234eb1b8658c2bc70404578f,
+            0x72413e94aca278eeebaca63c7941b548147387d21578f97e58ec27198fd4e58,
+            0x2aace8cefc1be4d4175001aebebe91fc87a46a280be0a90886383ff2d561d7b7,
+            0x69e64230343d9ac3c6130b300cfa24cec6086c85a1aa1c8edd073a7d33adb2,
+            0x1ce84829e4e67cd9fd3bcc8d1169a15c731e06ba76c77ad60e84b045d5d731aa,
+            0x23b52a113ac4ea90a8330c189a63fe9520f2d73db94406abea72150ea2b7ea0e,
+            0x160218f2b7e2d22653b3ca12190f5538563aeb27ad8ac8f2f71943bbdb0c5928,
+            0x84c1a87e7fed6aa9c80f455dd132e06f897f43b6bc12f3f5ff56a4297eaa153,
+            0xcecba653fff37ab5fb266ae654c23b2cab83b0f7ba92c706a078b4de3221adc,
+            0x2ef80d5e15aba6b2652fef7e0419167f804f2cf713200eecf30682cd138781d1,
+            0x14bd930a77fef4cdf7d47bcb46ee6fa596c43e9dd40ba87a488c613d5968cb58,
+            0x1ced050594cb02e43a97cf4126a5dead21217e9b5dec28ffd803a381ada6dbc0,
+            0x2efdbbe781cc22b39fdc48af3424a354c48ceb17113136ec794a9b3319fc9429,
+            0x2070e4e04671601ccd0842cb7a374ff2b93838af86ae464f82ceae2f1539c1d8,
+            0x123741e7f63e77fa3e2d8abd9f222b23dbba1c14e8af53385cad56594f065e1e,
+            0x1b75035c35b201efc55a1d47aada8976f5fb0dc1da22482a6b61d33d555eceb6,
+            0x25d76dabc919ef40ebe597d4bae43fdbd2197e9b0f7b7dda83a1360295e9fcf6,
+            0x666b59c9ad666ed3fc9d1e9af97fcf7ab94ba3387573d8d31f03084f9e5c976,
+            0x654f99795543eefc6e1b1e646108896ea5161c9c9a5e174f2e1cb9093809b4c,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2a4984518cf4d03a9b3598bdc254484a1805160612b943ff7b509637f12a70cc,
+            0x36731a2bdca86fe011dd7bde4043f89ca492084165aefa6ad9f74717ed54536,
+            0xf5fc4d1e67992e65abcde194f07cb07b72800a4f4a26e5020e96c5d4ae3a952,
+            0x20d02c9669942a2fda0de7a67b8c5cfca08b2e914f65652a71044ac9a09190be,
+            0x20b3c785c2072c1016dc316a7933ad541fffa7df2d289b32799e106dc4f9c1b4,
+            0x1007df7ccc98951aae782b87985756784a1444531492615315080e2c80a33131,
+            0x223a10997957b12816110049ac7b56d550cd7a5c0b47bebc1f8b35167189b2da,
+            0x358632186da4fff1765d4d688ccf425c333995bd7438240be0cce1428717270,
+            0x216b1f88bf14a781c99ad7a394781182d40162fddaa8391917aca465382be039,
+            0x108441368a058a30c565ac01d4145056d5a5614892879844c07a1c0289b2c928,
+            0x3df1a412eb02d17bcc82088f46cb5f77ec6279ff7161856c52480d00554a366,
+            0x2cf2d9f080d1219e2dd3d7cda1442b178464a583260e6d9632e12812b08c38b,
+            0xff8f5f8d239c9afc6c9d041ff0805ee22c3ef3cf5248fa2ab198a303597d82f,
+            0x22baee6a9025f961d95afb122fe50ce73d0acd9a913f2fc8d07a050f4de65dd2,
+            0x1131e942fc36296247e9d9013e71cc89498a7090a683bf08bdd23e267340fe1e,
+            0xac6a1c394f929725acb0a1b5e11ad9e28aa1c79da25624596451b04645d8a76,
+            0x3cc80ba68d89cdcc935b0d872d775b3b8f2a0cd50df89edbc3a6269290d6950,
+            0x1db513c2f29ae454a99bf928ffc2d93fbc363d0bb6cd0bcd93106d1bfe5f789a,
+            0xd05dae2a4b1ec3585f98d84bee7d10717da3b17a71281672e3451916260a301,
+            0x2adcd4c6f191ccdbcd5a98bdc6050ba95009e2039de7f0fd9bbeecf0c4f1ecef,
+            0x4d0d5708e1d87ca69eb4d44350313730d9d8403801606def36f035183ae03e3,
+            0x11184dfa1ada7118e79f8890036facdd47001b7b63b74c3d2983fceecf3ecae5,
+            0xd32f8b975e939f7efa097c2a3d4cee8340deae3012758e3b3a4ee0a2fd193b4,
+            0x1a24e9162049895bdba49f57cee0396e4734bcab60d8ec4305a5b685b3ca66ed,
+            0x19873998ebfde4a585f34a40a6e1fa702b7fbd29b09aa141c5a878e448e48e2a,
+            0x2d055b284ae3e229cbe0d4901ce6b687eef40d815da38cde743f3851c774fbc5,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x301d2bd94a2a85a3c802d0467c1cfb28e2aee547d2f7d51c2af108a549462a23,
+            0x19ef6ff9413f7a05af63f528a7f80dac32bb3fe601e02ca15feb99f91a844d0c,
+            0xf1cb5dd8ea58b523d3e9d9de030ea9db932b770ed97d2755da22a1512696ebb,
+            0x151ec2edecad41d2a4a74e8b09748ac3d11acff9c8a825e0f0c539376313fc8e,
+            0xbf605154c6e6cfca764590093b09ecec2e38a0426d4f8f0f6f9ce771d4ccfcd,
+            0x10d1c2b4f3622195ccd9bc64ab73145907e7358d92beb85826770d174810cf56,
+            0x79c01911499171a82059606f1a0e1683eb2f076a4a72314e51924b61259fb79,
+            0x1886095782a7c6abf9faf6549080c2a72f8ececc22bf58073df90be6920473dc,
+            0x261c4081f13edba795488c906dfa2b59917affb44cedf1727cb27da0b0b2c20a,
+            0x2cfdc7ffc3609e9d82b3bd1f2f1d42e15d1e0b7eb24719123e0b67d060800dca,
+            0x3c9ce71c00e243a950dff0d9e0a5d3c42f823983f6c1d3d50e0de1822993d84,
+            0x13714ab10fbbc54e15fa5ff0d6bca9846fc940a9c6bdd87b044868600f89bbee,
+            0x134d4838b8c77e7270460739fb444e60580e951d914a5a20493a2b03d294890a,
+            0x1e6f53eed7f86f7291436624847ef6451457756a213c168c3bd7a5945a4f2873,
+            0x8c4e9815652721c5293235dec1eae97fb8f93ac48d86c37ad6adfa77055665c,
+            0x18d007112ac9205d16ff209b80cf0b5260387ce770d4e6978edee9e0003fabec,
+            0x5140e8f5d27d7248a3e50e84c6bf700fa31c1a1a7ac144390f4bcff5ad61243,
+            0x19f153d66e44c662af026dbe5be9be834a10a3dfeae59729555d709d61e38f7c,
+            0x11e0299ac3f3ed3ee71377dce3b85768cd2a6b65e9d3bea24743d150e19f943c,
+            0x190ab7e9ed8c741d54fc558afc96b35d9319d317ff6d6332ae4ca77a8a3a7911,
+            0x5bf8fc4ad0126d42c22ed2c659b66f053ca3604f0968520ce5c7ef06c5a8793,
+            0x28c05200db6d51df10d8a4986cb65c078001f295343de608d68fae45cabdc5f0,
+            0x1d64d0d4143f869056ecb1026a361b48dd5162f38beefad1a6d139843d3dac9a,
+            0x56869389330224064b29f958f37fe90fc2bb4dc2454425b0d362b892be0fb73,
+            0x21124fa7acd6d96ec308ffca46465e5da69c44814c6e40e705b7c6b4d7eaa333,
+            0x210de4f22732824523dd4fd0587eebdd78cc339e8dc44fbdc2a317244132f7,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xc231a81780a5f9babc1f4137106d456a5cdf0a356e0c3b79b330982dde6c5db,
+            0xd2286ef77f15b562ba8316151a92458c52ab6979d36481abb6ee9420befc144,
+            0x14cd6adb239444df9b510c5e1c2a378f3ddfbc75b61371b688931bf3c6ec2563,
+            0x1f94577cc0cb87a180811923adfca9a8cc77b8ef41c0efef36e1b319679f0f10,
+            0x2bf8ecc53796cac7b1b4b8e8cbfe8f92c31f726dba638783eb063b675fa96064,
+            0x2443dff5793f12826c9195fc95caf2162cb739d837c4e15d426e65eb20c44884,
+            0x28807445f05857e5db18c6ba6c0f3d67cfd08d7ee0a1b5a3ec259c11e57f6581,
+            0x2d7181a0eb717fc3d9554bb1996ee527cc29fa9dd3ddebabf346725d84389a45,
+            0x1d467a0dad4ca6c95707e95f8780ca40fcc983a7e1171b111a8874b122574488,
+            0x2cd6049a0ad06e9a9a9eef6333566fe7558db0007e6e92d71250ce582189453,
+            0x2ec06f373cb79c1143d0ead6ea94a531574b642a2a88ed6cb21bbafbe2932c57,
+            0xdadde1785a6e8705856c47207ee42045dd0360c3cb332e866dd032ef9bad925,
+            0x26ef0863b7b4eb4223c88b5864b903526d84ff81c099ea942fa99ffa0e376678,
+            0x26f1a2490186a61de95667c8672dffbee6bc1451ac11fe2e9d159d308f87caf9,
+            0x913a0a4317ae24b6cbef39c87f10a3f47b4fa74b6e7f9286a6991027af81d6c,
+            0x101d691311e602f1bf45e2bad29994880376f57804517525eb169240d21ef3b9,
+            0x1c55eab0a94644305995dd5b9a4f2724390d88fd3e982be43b01a627accf5b16,
+            0x1f788dca1edff5172b4e948868bc18e7c0ef3602033d72ef3227f8776bcd40b8,
+            0xc5dc41e36fe501aacb4d8f8d33b12da167a12fcdc10626a1cdfc90cc25cd819,
+            0x18a6e567865d428f2dbbb6e9bf298ab8958c5d1737618e5f1c5679c76787bac7,
+            0xcdfb3e5975fb90caee98497768f37dd465586e1669d6bfc512b32a3895c62f6,
+            0x30edc8429fa6230b5bf9553ce19f0a78055f2d68dec10957d0d64e8a3bdb3e,
+            0x5ff6dbf8c00e9f32a61f908e6fa7518e49ce0bc92dab519524887ad9bcb3a8f,
+            0x187c0035a20f42bb04a4d3f172d8dd71761fbe16405a0c73658a18e177012b32,
+            0x267e0e37151a8018949bd766e65170ad7944b54b191df4904b67d181a3b0341d,
+            0xde2f39c45dc6b47bad47d29d8ce587e60c432bf03f9924e3d70152bab232ead,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x284591632913e57214bc02159bb3e8e81c06bed2fe6f302a3d238f14152cb3e4,
+            0x2f6110333487576bb66188bb38170601a18b160a41c655f55b366e138ddc3c88,
+            0x10e8a25fd4ff737b1fd8eaa1ca0fdc107a1d9e48ffbcbd86fe2b388dd10ac80c,
+            0x934ae9d36b935e477c1d92c9ea1b80bcd2d81f3fe0e37a4df894293f7ee2e0c,
+            0x1d48097697bd76fe5b0fe21d8c182a9a032700c0aa94fa147765147a66c7a732,
+            0x26a007b8e7c5a0f095c47c27e9a68c6be8b08766863ba33854b2dfcb6c708f74,
+            0x1db9c979d26dc221830cfd85bb16b9bf6e6ed9032c917ed64046d24b19feca2d,
+            0xeb6abf55ab892abe5ed8ad7223d04460eb7cc6591216c260250ec0ea22852f4,
+            0xaf52963d2d8ca1d85fe433b3e20e360f488dc7ae40a074925f612959482fd7c,
+            0x21a08ad9c5da7fbfa096b1773acb293efdb29b76a2b0d54f107110e7f7e7ae8c,
+            0x6cbf675121397f0657bae080980b2b22566613e0501f74eff8f71826a5aef4b,
+            0x31a23d2ad653f7306b849eff0b4373a7a2eae9279e8f048279d90241561b192,
+            0x2f086707d317470467a8e0ae03ba725ef79ed1ef014395b67ad4da788237769c,
+            0x24360122ee8c5a9ceb21696d69d5456a3166419377b098388a2f19966ce62005,
+            0x17c0f7d233d0fbcc5c520f1ce3a5d4b095bd11fe8f39f090ab7e9d24ebca8195,
+            0x3f293140b7d07e158f63f94792f943632ced772d71cdbd93e171a98a2bdb1a9,
+            0x280d4d680de44f4a35a8d0baa4a1feb3701fec97a152e977b5352563c797f68b,
+            0x1633dd4196cf695bfb9e5138ccbb381b0bab619ad1b728802c0e9b35770503e5,
+            0x549cb9c6b3ab14ade93f695dc31df816e13e6cff79023f91c5ead9311fa37e0,
+            0x12dcea4ce3927ca8c308751550a77c5ce4e095e0e9a417108c18102e4b0aba31,
+            0x78331ac4c2c6702655cbabe212124d4f1a1f5005a75faf2c6fee507b9996541,
+            0x5674b32b037c937ab00bb7ef41befd1c0004014b66acc26b117bd0b462870b5,
+            0x165c541ff3c38f4a9af878034316bc4c08ec15fcccc77657e7aea32c982e26d9,
+            0x16477e2f6956b2a232be8389586b0569feefab7d635f173ebfcaaa06040441db,
+            0x1698424bc862b0a96fe6843dd5c7626ae0182d50f8323c338917bd9e8c8a8744,
+            0x1dfbc6764488855933fe75e10ddd60b09d67d98c622f36cb565931d97e922988,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2f722fe53b252f8256f3c9d613fcb12205dc97de726ac8f23c6d4ee0a9575add,
+            0x4ce7f85039445253ecbcbf393061759062e52a54060331db27947bb0e04b101,
+            0x2ad1ccb6918b4dbb68bbe0389521d418f1930df1cffc91de8e8ee648a6a4e62f,
+            0x119ab9bbd433ff01c7e43079d288d053e7e0c4a76facdecde1a77d544906b4ed,
+            0x17d263f75f3d3f0d472bce50e641017a291f8466e6c03a768c138deb1b50f3f4,
+            0x248be6746b30e18cc13259078ec848411532ad11d4506ac6ccde131495c9fc42,
+            0xb02fe4295790760e1fa72811dd63502ea36bed8eb8652e6b35f4faf9b554312,
+            0x148b519dc0b5daa50f0073094e87db4449c8a068ccd109872696973f9eb806c0,
+            0x1bb5e7ef82c1a2a02827a2f16a34cbe60209f8475d3bfc0b6652e61f4113e6da,
+            0xfb76804e630b9b522d9af08f1b53880f5cdc691bb22c27151f541fc8e1bf2fb,
+            0x25f15fdbcc16e5c1ab1066d294bc774db9166ec45d4dcdadc4597ede1da532c8,
+            0x18cf6ec7ac6dd943c57b9472b58af18929a94dd92a340b3e43c074f62b7cffb9,
+            0x28993fba9683f72a8727701674e3e657fdccac4649f82879df4295e858857317,
+            0x1fdd6bf585ede657728a4e97eadf195c08f8e6144b28bd92ef6cb706e4f6b05e,
+            0x1810b0fdc26d123bac819ba150ffb6ac9455ada7dec6deabf178f0dfffab05d7,
+            0x17935bc39ce241e78bbd64ffc72166b8d8054be62c494f3b89abf88810808fcd,
+            0x23b66feb87a9b7a105923883b0ea0c73f795e445e3cb6f68c9217cc0ffea43ef,
+            0x9f6acc9470a3ca1b06e023cb2f6d68a46ca6c434c521b2d0a799cc3f7b29a9d,
+            0x7059db933a49a59d77c7dd8226ea452868ab183d14aa09ba3f62011a08ca31a,
+            0x110283c2d84ef498d54d8cc89f3ccd48990382ae73b8993a3644ab9961b71141,
+            0x2e0861925cc9b76c5b0046d8178cb36a13b26aa4ce4e5f7d3be453378928627d,
+            0x186d7f00229ad745a0123ad95fae9d1136d4dff9fb693f954ad9fca972ce9d89,
+            0x22c7a666156ed3e7813e98f60d15e23a461d2e9cf389a581dbf8be0bf5afd011,
+            0x1cdeb50c6bcc3f9cd2f59588fd72fb929034685f88506e891f41dd572c67c360,
+            0x2978a2a151c95155411e8acb3c12cdbcf929d675fb978e636c93da663800c33b,
+            0x167e72f7db7e8e21f7daf4f02fa830884851d562c3b51606b52ad3e80d4757bf,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1957be621bd6207736b0374c7077ef66cdcfa4bf575a16d2724ec94e2d764876,
+            0x3b264ea2c2a171ce3bc6672fa95706ae37155fed16218080f33e469bc9b6e54,
+            0x1cac742468595a01d58239fa27bfd73e5e4c811d31bf2307e3ad7d9f7a440c82,
+            0x1308e2503e1623793102a3c6ef79b0041696191d4cd1a089d440e717d15675b6,
+            0x135997d11a8ab3d418e1b34376d3193d0b8355902aedfdb2f29aa43278e2790d,
+            0x6f8a541f16f9f3d8bb1757aaec5ed1fdfbe7990e7b046fe6deb8c6af212ff4a,
+            0x9a4037450ac7d74675a6abf0169890a2161dac550cbdbb257ca22f4026ee4e1,
+            0x1bb22813c573e8209b7100e77ef81cedf79e7ce616b229a7540505854c2612fa,
+            0xd5235d7acd8bad965dbeeaaac39d599543b2766dad81dfa738988f8c4fecacc,
+            0x24522e82642d0c00deb6406ab28a1867dfa50cd6d0ecaa0e18b6e5824005abaf,
+            0x51808f718e4a3898d1266b473a2e0fa470b9ab592f9e1efdfb177a8f1b1a863,
+            0x2ebf139bad53a7408b452fdfaf8847141346688e05da4e0e5b478c178bc36c17,
+            0x18f177bfdabe5eccaa6dc0fc28f75e20dbd9e470ad50337724be79e46f4b4298,
+            0x23f5e3e09744ca3e73ff2660e40ac6b8152e1c0a93e507f311090e6574458779,
+            0x23fc5867bd5b4d52686ae8ebe3c1454e266bc576aec1f682bf18f783853d8527,
+            0xde2e3ab296be75fe02af329d61d80c5c4d29886528315b4698223699ec70de3,
+            0x2f4c1d3cf6793b0f8a707de4909c1df3f888a37f5f8e382065b500936c33d207,
+            0x26bfb7031fd16e59d70dc1720d4d04301d97e07a0023e58765b2b6b735b02443,
+            0x8f0bea4f928caae9d19e71f19dd85c7d700b1b05b3170548784677bcc4dce73,
+            0x206dd86edb0388abd591546b376a7ae6dc433041b7d248ea75d908c4b3740afc,
+            0xbd896df632e39aad4e575444b0bf49de0e10183b09137b8f79f704cf2feebe6,
+            0x2188116488e4192be2569647ea81c6caa45d08b896ac14e497ded7a6b80d9852,
+            0xe95540fcc2df2d1f630191f9e5f48b7e4695fdd5f4e9a7c930f16598b3e9e53,
+            0x29d25da59f9b238929d0eb4c669216770673bba9a48a1160793ec66e75259040,
+            0x998c56e22c0fe57c936f19774ec4368ff33aca06589807db3a1e8138395b4f9,
+            0x1f460a24b80724cb88af9fd2b73b512e6d5fde9ad6d0b73801db0cae1d0c0357,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xdc5b4d3482661089384d18500ed0afdb1a635c006ec67b3137ef97cb03d27d0,
+            0x22c7492f2fa7b9f297c2f0365945ce0e262793331d3cda1cb73d083fc8a0e21d,
+            0x266af95c1174ed0a5781bad21a2397578ec4d16642d729c4daca8f14f6c86a91,
+            0x14c46169d20fa3e4a67fd8da381ac224d61cef48dd27c1971273519b6f9b703f,
+            0x1269bce1327ee515c7de22ced7aa99a4df202cf661ea0f2c520ce2a721a640f2,
+            0x172bcf2621fe4e5c2919490728ee5d19f6d1b3db328addcb2f70a792490e9bc0,
+            0xf26dd040a3d43e4788c20be85b4bf774763729fce73037ae53a5f490ab99c49,
+            0x2fe304bb2aad7c3a3fe30b77087600d1da7ca2d9053f7ed264c1865cc8231907,
+            0x2e365d1b4f6d9946faf2ba71fade06bbbf2f8475eec5a56fc4843765fb4a49fc,
+            0x25a82f1231627dd4fa32b82d274658a1b64e8ebad06ee903aab649e32ffadbcf,
+            0x2cb9324b95c056a7dac8511562fdb8049c4f08e6fbd3ee222bab96ecacb89c9a,
+            0x1e3c03ec4cccb96e93e7b8fa96f6915a0ea2f392b4f5ebac5b2f251013fcd3a7,
+            0x21011730617a2b7c760f7758dfe37725189c39224023ff0d819dbebb1a81c07,
+            0x28b05c0a2e98dbe8f090863730a24b597d97ec3adb4a00f3f1a176d02f495138,
+            0x27355701c30ec033287bc103652855c341a8e80aed9b0bf7a1633b3f0ab11a43,
+            0xfad7793054577536c56651b9585ad1ecc2af28c4065c6fae4ff47df4289d5f0,
+            0x21bb038dbba587b85cf0fbfcd5e69de9f329f6646bdd40e8e27a107161f624b3,
+            0x21b1f094f3e78cbf60067b3b785e3b3f24c4161c91c452318ee990e07e225524,
+            0x52d8b24d73c86adbc8311390a5b2c9b6300671f92717203ad7c463bbe0789df,
+            0xd7039ff767a3d8bb07fb62d6b2ebe8c543277e3da1531da94cc861d4574f648,
+            0x1b916f0851986c4edc2b927aa8bf9d92178ebe75b77552ce47a63ef70409bc03,
+            0x33cab9f4d3c360924e9227254f4f9bd52fa7712fb518e534f9fe69d04d994e,
+            0xe26a5327b3a023b0d1a432d4be5f7f0b09f8c4143ab881b985f2cf7e458fde4,
+            0x2ca57bd0c629753607a4c9e37b783668abbec7e8e306f75b88ba97772d371595,
+            0xb7533836731172ac9dbb56e54588a5eb800fd80d6754af74fdf13460c340ef3,
+            0x28c3653d647bd221d2b3c79f3da382a937cd1be9a33232748f04f8e1c880bdad,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x7fc230b6a36abb1c7f4b7504fa51ab01aa880f7b3c0a60eee1637ff68889dbe,
+            0xbbfe36421ba52a2fc87f6d7976aec0165e41aee0f71cbfc87f41b6b965ca6e6,
+            0xfd2424b028d4d8ac1a8c66e6306af2c3df213a3a7979e367c2957eb631f17af,
+            0x1b674725a1f99e1dfeeb07dffa4d961ec24a31d433d83f858cf3ffdfd2fabaeb,
+            0x12c9cc35e0ea2482935ddba214f21a8c08df3dc9d6b29f75619f9ffe0d055f10,
+            0x1ad3b10f3f584f4811c804d95b3709ded70c5a7d3bbbf6f91339943d85bbe21c,
+            0x2abfcda5b9f799b2d0af0861c17c33253781df51eb186a65eac958b34e8c35a5,
+            0xd9cf52fd20c189982504d02aa80500a5c732434dfc9e7cacaf08ddc0d0c76dd,
+            0xd87620da15c58c50af67bf3533b399edf83c1e7dbc0bd9773d40d5ea287aba4,
+            0x289e55051ec741e27389dce0eca1cfc0fa57be3381c12943fdfc6aa392b60af1,
+            0x285ec1799c195e638e16e4cc7fe5bb7ce06b1c82105cc4d61385dc2d2ecbb979,
+            0x284ce6e7141920ad4159f9c97ee921a24cd188718f7000f1ccb091067d4ddeed,
+            0x2403b3f3f99fd0daa8ad77cb3f8d515055cf80d1d5e8d32e4e4627e95489f57e,
+            0x2ef65bcc67502169c5c5d324e09297b7253302c82a337f00033c814aa33d9cee,
+            0x2b1ced8656b92329d623a85ee61e310495566ce4effcfefb6e6606ecfcdbff4e,
+            0x2cf6166a9183e66bd94be5aae54afff0f02cc6eb68d7456cdfdd86e0e7f0719d,
+            0x60d392a31de88d78b696e7238af3ca3eaa5e412437c66e59d7049b69d2507c0,
+            0xc2b62bd89e35735926f6474264c899eb2b5956738a478b6e76d792bf420cd16,
+            0xe070af64e603d24608847ce8677d0291e08d5c10ec31f23d898d716f1c39d1a,
+            0x2de645e3763155f48ca18d06dd21370f314e26382c6c9e883d84e387bd892893,
+            0x17deebc35147ac645572140ca181a81785e74dfce063b37e326ce6e79c66a6da,
+            0xb035d43bfeca4b7a464054eaa0f892cb035db06a3150ad9ce1ce45f6ad0b811,
+            0x100c78328ef5a499443541c1e27f78d0e77f65f93738e393bdcf4b098681be52,
+            0x180cd1e5a1262087a60bf156e8ed528070936923605d5fb078f4f6f956a55aef,
+            0x1409c9afb266f52723089bcc3b495bb15c9f10cb55b32b73dead030f87e6e24a,
+            0x100ee62d3a9d66d3b6360f540f954493d7af73e6cd95a10ddbcdd79d6739fd38,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xf8533b51bd9ed54a1703fa8399239d3a7fe77b0a55210917343e09342a0fd81,
+            0xa38a8515b1393a083782c40f7261e921d87155c081b7039db8f409beb2dc8f4,
+            0x1dbe26b8ab56c6de11196b0ffe7355348b99083a94d2f2966d227fde43821f7,
+            0x2fae58b811204fbf3232b298e274df120020289d06ba343bc9532fae7ccfa76a,
+            0x2c33c971128abcaffde44567163b071c1c845d5e04e4b3e4f3256c690cc61efd,
+            0x1d6879298603d7ce919895eaaf857157bfaf20b46ebad48c36e85927e004967d,
+            0x154e2b495b2894e24c7b64fb83c0473186b256f83de4e7b5f82abc3e97b9d176,
+            0x1108e6590ee097d6177f9b0e8f6df631e91ca6aad1744fdfc36a5a7cf73689c2,
+            0x30e4cc0defe07e0c0ffc72ec35cfa5f902e564359dc27e6f500c921db4f22c2,
+            0x1c4f81779c8633490f3e3e276603162c4a5e42fe6db58a53316f805c5c822922,
+            0x2954c55e5111eb033ad80c867317b4aaba9d750b9f9bedbfc48abe8430ba3c20,
+            0xd519d7237511791c479d178f6500e54532625fef17aef20782d15be156830b4,
+            0xb18f5604bef3748e0e8ecb40e7f636d2452a42ed19299820a5d41241e3e27ac,
+            0x2719c5dffb3c5e099e2ebe58e16855ef505dd10daf7cc2f213113ff647614b42,
+            0x16e635dbb0038d05bd950a92b785afacb3fd0e6b86cce3d242132d4f1c1c0ce,
+            0x3920a662038566aca072b265532745baf239bb3e60326891222047605015b23,
+            0x2c4f137391f3b5e4e6024a97f1c9cbdedb1297d123add7adf4d6461ae5a875bf,
+            0x2264a7d603db95df9f07582fb03dce9340e2de326cea846bba043b0946f812d9,
+            0x2f1f379f002c49094dd938433a986b519a123c4d9d0189d66533665d0745067c,
+            0xd29276a5ac511cfc3a3fe7b9244d4b7010cf0bdfa90d7df0d6c4000b9585d45,
+            0xac3ab6802fcf30b3b6d2b1a69e54b3699179b4f30b464e0b71b6b4b6b1124bf,
+            0x2dc0c34175e61183601ba4dcf9ffb457defd36abc2e24babedbb0a9450155fdd,
+            0x6fd088a7bca20b5570d68665ae17172c13bb3698f3640cce22ab74ead7c5663,
+            0x1de87003640c024ab5d55c378a74e14e1adea072f8d22ee932b49150dfd1126a,
+            0x2e01b475d78e669a868129b1f173a77a0b28d82a89b4ebbfa274a0a41eff3e06,
+            0x1ba9c82ee2f9ce1b70390faa1d3c40585d751775bc8596e32acf34bcfd58f814,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2a61fb95295b3b5c0949c486673d1ce6ed7328f42c9dd1c82e27fa3dbb0e3bf8,
+            0x156befb6eeb13f52ba65eb7390b7c812ba6aabc5d1acfc189b95f71fb47db283,
+            0x13422f783a978ed5ce35e1540d99c3cbc67803de00a3a4fdbd37f7c120d7aac3,
+            0x1995d00ce7c99415c2727e89618e705a87fd4456149fbd899c40f43320d5ec8b,
+            0x24ebb318e440a45956fae1a46a3303ffabbcad5acb8cf98b6ee6805672ea84b3,
+            0x2c6c1b35e7979c2e34b071a03101db8cf753b5c26193f206e2ad214ed47387cc,
+            0x2fb55d17e5a50b80b168fcdd0d618f2da007510bdbc429c5ed7fc9e9a1ee5c0d,
+            0x117c39033ac0e1f5f8b57844220b7260e3085bb99925eaf937d4a43a06bcd2bf,
+            0x154a4ff3064027d0d4aaba2fccbb05fc4b074ad7bc4443132ed23c5f03d38ef1,
+            0x16ea33e7327d3fab4e15cf66ccc4e99104aa40a4ae0eefbd478517475c274d62,
+            0x7af162f6a41d5623cd47181367c6f1f5ee0be7b9e0b53fb8097789ea9a0cdfb,
+            0x1a732e3765405223cdb6eb28abd2d425dc7d1cdbe575e08568e1028d8ddbc398,
+            0x1208ce1a3a017db5d1024920a6a0f94fba55f5b88620ace2e180c3d517163641,
+            0xbf9ac6ccc83f71dfb86d40b19b7609b555fbc1ad465b09f9b47b21cb230e174,
+            0x1ae8cbc6e5e4b91ea924aa8045967abf4d22d687639e7f64df40e1baec14a3d0,
+            0x2a1be1e4d0fddc88eadca5e835f30bf7ee39b0aadd995b48a7ba601b87d16380,
+            0x1dcf4c29bab85ce96ae81703ff26262a09c8895f886a71c01413d440a2f783fc,
+            0x2bde5bc567bc599e209587d01a8e5b83c9f27fd4988c978294ed9b680b03047d,
+            0xd7f63416aaa46e1a5ab07653c98721b3848f7f40dda0cbe24f5be957249bfd6,
+            0x201c0d5ba18737cce0bcf6069d82ac70b7c6da968029939fd793e7dfc11997c1,
+            0xfd4dfde771c21adf5ff971e0bd0301b0f9c0079a5ccbebf6cc05a578218cf9f,
+            0x6e26ebfae0d7f5596bc1719d578b1645bdccb473c802820e8d1e73ba95fdae5,
+            0x153a90c4a4df503ade4670a019c1c539fa9abb1d7bd85c5627e2a236816e9e94,
+            0x268ddb0d3607d6d88ab21623db322f70881c865d1baa284eef7b6f504649f5ca,
+            0x10ad938c2c97c8785232011e8e9956ca87ab31b6e9947a3f5a9cb2dfa526c178,
+            0x100a9d42b7617d60e4b3aea5150d059bbe751456c4249f0d807247629e61f0c4,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x13bc85e2ad431df8a6705d1990ac925ccc3df1282405746025b8a5b9dea661fd,
+            0xcf2d89cb39c2d88605c0a34e07eb31436a77a2909604c6917c1c8ef5b490d8e,
+            0x2612eaba8d6b833432665b1334d612cd9bc430a3bfe2ebb3e34b7a9d878f4054,
+            0x17f2915802e376c5827e719a6890d90fb067762c96bb3bb86bb34f2f14211011,
+            0x1ec7edddf6e2543f5e457ad0adfe66ff55ec07302a6051d90797b65380b8f07e,
+            0x1d4406aa079fb976bf4d8a3bfac81347bcea2cc9b8ca732d3064f9413f202082,
+            0x29b71a20d311389c672d8a857b34b04e5b4c95624ca72067879cd312d8b17cb0,
+            0x6df0c4c7d3b8552c2298f518a19665ec355cdedba299b20eb193c67c0e72d43,
+            0x26779e10800437760c7bc212ceaa5d63d53a234368296d667f1d19784f47cda8,
+            0xed1c5edb7053068b07ee60910ed3d1c1e41684b276a0ade50c654de10a44cc,
+            0x24b4046af28ee5013cb1662a81ae6b60c9431724b3b16202a5d9d5ecdb0dd322,
+            0x2710607671674451e9da2932f51616f1478e7440017bcbe5f1df1031baa582fe,
+            0xba845a38009864ca2478e043645bb6d035ab0ae20053ae65c99ae914819878f,
+            0x15c5c54f3efc26d2836a2ce81c045bcb20e137945f8a64ec93b50b05fcea1624,
+            0x2f416e4189aeae931290aa08d84764da18dce217ec716ec1ad530d21d035c1a6,
+            0xc92385c63d6c451389a83dd7a46784f98852b6ded3100b65a8b7c5b96d89305,
+            0x222e8105aa188083af23785e36e1eb3b483fec353b832f97e2d66d79dd0e2926,
+            0xe98d7f5e45ac6610fd164ed687041f2952e6dd3c9fd12ebc8395a6893ae9fd,
+            0x11591f35ad1543a7a8398cc80d8d46980fb2d5a91848942956072a3b58c3fb7c,
+            0xfda43471cb17ed2c9e4ad1bcdaa962da09fb99a5bf74024d3223784df4e043d,
+            0xa12e81049a88849ad74b40f381be30c2c2e9ec8d8c50bacec5d1868f498285a,
+            0x7c6d194a73f848f7d716d6f30acb48ac7baec5affc571b6b8b6b84996168339,
+            0x194f847f3c7d048a1937426a78e0784cde6075dd3ecaad21a4d8b0c29e6dcc58,
+            0x478225c0df10ae1047eaa6bb766c7cba55d1b2f4ad2c92b579287d4afabd622,
+            0x7098d85221394b7dd9d5e01bb8d8fa324f52cc50a01d04959f7cf47a9d426ba,
+            0x152237727876536fb0492b77e2ca5083d39421c48dc34e5079a33fa3d2a86379,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1420a14de2cbafff2579616faf1bfa74f7c6542b053a499ab551a3408f0170c1,
+            0xb9d1c211a3135cf248f2ce8bbd1fe9c687788d37dca581e76ef796a06abb333,
+            0x2d90ad8b96b95e07f313d485195a90e8cdee4c30fd11b740617caa864d20ba4f,
+            0x1841439f401d20be41e3aa8154a1ffb5b06a7cba6987fec7f41df5f92a6bc91d,
+            0x2388640642c291a6a1eb98d73ea78b7d176c2b70c6d9bb637abdb842c0f4a78,
+            0x26847393fc7364e97651b2b787111e2863ae61218c0a21b8ef93292d6d3f59a3,
+            0xa97aa86b7cbf546c5722540fbc3257e37e701c44023e6382785a6b8f5e2aa6d,
+            0x1e66c9e1d497faeee46a478ab27fbaf5f9af29f43fde16f9a6385e0d05b17930,
+            0x15dd9d1744c08352420e756cc25e76537e8dcfd70c5e0dcc445f77560b730ee8,
+            0x907dbd7263cf90b8cb5dfb3bf60610d4fd44beeea309945d8205cdaeadd2a2,
+            0x233dce7ca21fd1e909e98dcf2b584e9ad879edeb0f395bf9a44aa7fd588ff23d,
+            0x28d0f25cc88f3d33af54d011063c0a2900fb50e18d1517d52d63ce72b435a3a6,
+            0x20db88c936bfe7c6e86126581cbf8bd7edddff26237df67c02777070d012ac71,
+            0x27531eb0037dc5b938ef188fb167f38039f82f2cffbb8fb6511b05676af6e230,
+            0x174c8436d7632117178d777c3174aaa21b1908cedef20997afd4f9de59dbaf61,
+            0x610a7245fb111b8632cd43f8d356a839751a7ea383870e108f45815e7dfe527,
+            0x51ec3ebb56094e6fd5fb48401dc97a7aebc08c0321260a03ce15a64401d57f7,
+            0xe79a17117660b79651058aaa102bf530a98c0fc27890c0e572ecc6d6669c36e,
+            0xad64295a0a164517040af0cef26fa9e39b1ea67db4ab22db5d607c4fca3de99,
+            0x2861d3d53c2665d9ac962a2a78fa4fe8cb6e81e7ab229f66c432a80dde7116c7,
+            0x2ffa7a7a62d5e1bd03cbebfbc5c758444ae0d0734c4a5d667a158fba11a9ac8e,
+            0x2fceca53023c3cc3e8991961644decb60806c5e26bd2ee6459424033cbea06df,
+            0x1b315dd83c8b16a2aaeb9119436076344d2fa321f3359d6a9ef6cc15b45aaafa,
+            0x27c786865b0c424bc2e21f43f42168d668ece1b7707b62b6ea77682a60a4b1c8,
+            0x2f55ac5fe9c4deeb92cd318504423f31894b80e6a340fd21ada215856fcbf5b5,
+            0x8484c73576645af031da8d059f7cacd28c66906a7ae10ad91c196373601335b,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1f1e99a24da4de93564a110744d481be210f6020ad98006f0bd4610a054bb397,
+            0x1313ce9497a6e074c155fc0218d858202308ed1c1241013fdb1b23967fa23167,
+            0x20dd2b7ad2c4f1f1d19f18b29a3ae436405b6866b8dfc4fbbf0877fbb3e7eb1d,
+            0x1d9a3b14077a7c4d585632de9c1e0d4a68c71203492d5911cb16f3afa68bd2e1,
+            0x1731badd5397325e2221f6739002faa9da0372fef8043ebf93e4627a3fad156c,
+            0x23e7e3fe8c10b5580a79f4c3298c8e1862b7f5237942f23a5455d4eac9275685,
+            0x2c014180a6ecc47452808fea233b82f39e3b7caf0175687777ace7544a29e37c,
+            0x292a5b755731fa19173af35e46536550ab67aaf5f7302a003d0f6df204e8976b,
+            0xed8c6981ca41600dba450a860b85784655bc05193481ddbe475de4f351d243a,
+            0x1a19597908036c20ac63ccefefe74a7d4a34247f7471bfa743f7d1858c8fbf19,
+            0x21d82813886827e8c1985bae1dd3b8377bfcaec6e7fbe0924232f059501eb278,
+            0x1a3ba88e071dfb03e2af64d4efbbab382517f94566c7268650899eb6bb1971d9,
+            0x1d48d408a857660c5fa36286c7fddd68d2a4831cb0cd055f950be3c3c9607347,
+            0x23a912ee06a717208ac5f8e94a3ef1c0dccb7cb14a2fc32be71d8d25e65827e0,
+            0x24f16318b8064d97d3543dc09c0c2895745bdfc96371bcc99b5c6d6ff6af3e13,
+            0x732c0b040e6bffbae6ac8cee5748cc4b1dd79559d2b84d73347e7868ee45e36,
+            0x28d961a33687f15d8e4239aaa2edaab1dcfd543bd30437afc151cba1d8b6f93f,
+            0x295338d4f509a0e6ac18622299635bd3930bbfaa4dec3b885b817bad870885dc,
+            0x20bfa91fd05c7fbc2fab0619637bf4fed31f95731d89c2f7040f4c893cfab9a3,
+            0x40df188035ab2406a932606a391e146c51463a5129c2bc5ab3416e6455dcc03,
+            0x2483ffcf685a6a42aba1af8b1c9af41b66796946957e69947f9790615422c61b,
+            0x285aaafdd3180b1543fc1994846ffac22fe06908e5a6bdd3fa3d22b3644b6ea7,
+            0x2dc5f343de5cf59a69c9429e96289dc1c4c8cf08fe69184b68690f33e233fdc5,
+            0x6e3d7b62ce4436fedd0a240d7a777adce79716f5a22b5efeeaad0abf1e8b5f2,
+            0x1482cba9741ff1dc43ea1fc5189a2a59fd5b2bc2f1959c164241662658f2507e,
+            0x1348498420e5f9e977c9db960818c96b1f93cf370a2380138bbd56e0c9d0d526,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x14fe503bb439d34ea8eaa57cfa1caae71e4284521ba6240b0afba874b93ae8f7,
+            0x1f9c9a83a952c1e72697d8a93b00a57bdb092d66ebde1ad8b169343f93c3f8e0,
+            0x24fbb0c0f2ace05a5faf061867d2cefb35494ed9fb7e5b590db562486c88b0ac,
+            0x10f738bd7905a3db9f0d6fb73b2cf3c4877dce60cea5925d5bbece78cc5516fd,
+            0x2a62e245b8b68d45298987ecf40a0a3419ea8653e4da0d6a6f55b2152d85ca67,
+            0x275b72887f4a3fd32bea4bbf47394106963761ef3e007f2f1e4460140896c168,
+            0x1552e36d16435150e476fa6665c4f058355854cf2202d91573072ba3dfd2807f,
+            0xbe9ef904aac486fbddd1b8da7d57f9ce8d1bc5fc7ba2abc179c1fa20873b597,
+            0x1e81ddff4f76a1b2dce1bd10aaa16530f8636a0e563bf33a02cb9801d7f762ea,
+            0x1c9d6fd38c151b16888ff3ee7dc7a8f653fead50f462a6045cc6bdaa72231de2,
+            0x249f6caee2d3f22549b753cc0857a89a85dc00258402594a5ebfbd7235c85a4f,
+            0xa5bae6c55380bc6c3c5cef4aadbee3d7ba2e30ace0dec7fa2c3e852bf030798,
+            0x1a591bd8ba8f5c6e64b984ad9274257d38caaf25b99cab177c84c8f0ace22c47,
+            0x2f14e7a4d071ec394f43f46d60b1552aa9980bb50e7c963d42f483da3211a0ee,
+            0x9dffc259c60af5ff5822cf8a170477695ac5775dc1b90104503cac64914f86f,
+            0x295af9152dc405a43b353775e93828dc0dd1ad4657f1f324f75e25fc67d355bc,
+            0x4ed39653bd52f01b25db50f75b0f9a7868dacf3c6f2999c23bf95f58cd5333c,
+            0x10e815500f22b57ba8056deff42b51f4a4130f6e6d364bc1de7117b9023c0b37,
+            0x2286d75a72832bab29d58395c45ad419d3d1273062c893a70c56fe9e38750886,
+            0x111df543f14f2ae7ada849b80d01be30e23fb49ae805d09afb7a1cc98057a27f,
+            0x25c1d1e13619f1ad04831b2339d163ad83da3809a89efc10610d5c62bc03da3d,
+            0x2fa4fe7aa2dc0ece1dd482768838b9ab913010539fd9a94c00528b037e4f8ec4,
+            0x1950f2d47f38a0976e8801a03edd51f982faa74392a70a0d381194dc258770ea,
+            0xe6945795a878954644fd4d36dbdfa856c6b1513c8c38dfd71e3f6f648d568cf,
+            0xf15e86e69bf0d747c7eb9d100a26930e44b558de46b2e9246c4cd269f4e0707,
+            0x132cccee9c47ea27484dc9d759d93d560988d9a42ac6f90be4737761e0d438f7,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1f19d5b58c771b1022d6aea73259634d1c9e1db227bd7face0cf3d7ec6f04a89,
+            0x9e99a9892ec5c92fcb2db34f0a80d01f93db6675b839e54ac081e2616efff4c,
+            0x2e39982857d71f53bdfa8b2d2fd8481727267c00bf284a011e75de1090b5ea11,
+            0xa4c0ebe2118c2ac564272eb8f8996dc8ffc649480a144bda57e7c33f14ad552,
+            0x25451345b35213964ce431f6f9ecd15934443b435a7f175abd80d97d999fda60,
+            0xbbc4376c1f85523bc7c8ae9fcd8a172f4a4f9905d09f1de0a6d48e273ee9809,
+            0x2bdd1037469a47d75d5b8994731ede44306e137f4460f2ac7c178bde7bd9fc6e,
+            0xf677b2a55e756de8223dca8cbe59954989d27ca87f57b8b8e59078ee30b2748,
+            0x2fb0b17b679ed6fa3e528b009e444bb34b173fe18925971a3b6777863a936411,
+            0x8e4988e8ab1a27420dc600aa4fd13ea9d701291e005defdaa33e0df72d180b4,
+            0x2aa3f6fb81b544fa5d338c2a7299d28d499bf86f77109ef9cd91f3156595f0f2,
+            0x202ce667a6cefe69a1d12ec6f0b7674cae7fb0e02dde42e47fcfeb6afc011bd,
+            0x13fc451c175cd7d0ac88a8b7013cd460af9f68982753e01eb0b9ccccc2c7b57a,
+            0x1b86a2f0867f4a97d6f2ee4701f23d7e05c7700ae53c0d57284c69e170e90858,
+            0x1fbf812f6d014d7c0134b54d9d6aff50f0dd76d7889926aaf59e86e69c720821,
+            0x11ae5f1bc0b2f10956e35b2a125ded0ea4b312aa52707bd5e98452f6ed0d9d2b,
+            0xebfd2844a28d08df2ccbddc8d52e51bf9714e9279ae25b7f7015d37769c76a3,
+            0x1c9e2830d53d2fb38ec3fb2cd6f45061058949dd18312b212fde7082778eb970,
+            0x2c89a19cc675823c61843f218bdcb0cccb5b9b4f0069ddbf7e900fd643c2963b,
+            0x8da85ff8b6200e090cff0a2c2f05042e30c79e425907ad9a055a9a2a496e73d,
+            0x960180e5d5ff549130360038aac26bf7d2f5828e88327a1fbe2227194ee270c,
+            0x17ea53188c77a5760fd3da3213f549e5a45c743db6b27f4f1af87e4ef28609a,
+            0x1cd300160e5cbe7b9cd7ad1180598c065a08ea594897a8b2c667508e93aad2c6,
+            0x1b8db86cfd31fb27ffd05312139ac8594e4b9a587927f1d5fbb378be75fdff94,
+            0x9ce92eb753807b4cd89cefe94e7f31b0eae43b4cd6b97d8248731cca7817df9,
+            0xf953e8b043a5bce5c459ae0c1758ee52707f6f0dfbddc5e407483709df22a70,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0xe61fb7e75ef9295c4189d5926940c65bef29f9460fd6acab96fed3d1be3e626,
+            0xda574faa3851b0f89ee096792e722ef02c0e09793b829579e62d43e9745078b,
+            0x29e8bfb4394174320d8c3521f9a665b547cb0560f726a0d70f52f613b0f24686,
+            0x138864a60c066835f127cc7fc18ad0bc92774eed55a5735b8f4e58f1c4de54b0,
+            0xc4061a8556cba5eb98d6966f7014b7f093e6c16ca1c498bab266918efd24982,
+            0x29a31f9aaa8ddea5ffe0debc4ca6968854ac196215df67c09fcbd03352180b8f,
+            0x1cf3ae0b1b9b5d99445a7f94998c5e59488c6041a6205045683c42f7417b8a57,
+            0x297c9cf4083fe500908bd1f4c886306df9b080e77569a534c558ab552bc61a14,
+            0x1fee3441a345869bbef74446fee4f51e9303d36e0a3316905b917db8b33ee846,
+            0x29f81a706163b55c6e55324777703a9303ef8bc5650160e0f46e5b800d62abce,
+            0x82ef985b1721ecc770cb73b1287f745769f9652c7aa177e43706ffb01683fcc,
+            0xd2909479aba19cdf059dfd28915cb101756fd0be6fdd65af27163d3d4db80a2,
+            0x2f9cd946fd1c2dc74bd0f3ce5737ac83b1071b7d4e720bbb2d8f138c24e9f336,
+            0x24ec8557ae626b291b510d9ec1bd354247dc3727f72832da7a79c4fcaf8cbc8c,
+            0xf11a41f841b89ce70505543d7028f8c852cc0df7c8d840917239c3724114e6e,
+            0x114bb82795b43471c48a7d4f21e17c270f98c6907c37f2fb1f99856266cb8089,
+            0x2b62ff5f01bbb491c744a8286db0aded602f287abaec3b1fb1b4212e58e6a4c1,
+            0x65601f8bdd487ec395b20fa5fc276d78ba591835f481113b3a5c59b005e499c,
+            0x1fc7286cd0168e84301b48ef87d7cab67e45883e166ce3d5b398389230d9ae4b,
+            0x795f23bad239c2e465601e109ffcb16e153f5e47a47354138940d99088c5069,
+            0x2e953e715e0c47fdcd618c2c5291215a73d3c1a29bcbcb7b9b7d362f211072c7,
+            0x577b3abeddb1cba0385cd479d5b80be73ac18ea5564d9726681d8c29857b509,
+            0x17f68ef80fe53b639194195275d6dd5671d2016e67b777a0600d69fd4e72384f,
+            0x20ff4e58659cb0932f9be3455d13d0e6591b12da8f4c61489013cf9060b12ede,
+            0x1e22384181c19d8b6c515b275db8401e900192f0ae54d144fa7c43c0295de2d2,
+            0x2b73bd9ba3aa22ee4fcb81ac91cf8ad03f66f640dfbb1cc7b61a83c4e7aa2ea8,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x6e077d5c2e4e5c9705827a87bf1d03ba0d1ad0d1ad6ca1d634d25e4c66a0a15,
+            0x121a212dacbbbc0ccf4c3b4292f681523da7c9e1a46e1ba0856b900911e4f84,
+            0x14a5405a71e3bf12ce347c54fde1d22398fc616db34d6d6ec57d8d0395589341,
+            0xf09fa7c4eeaba22ff000bda61bd7d4e87734f3f8195b38bfcecc6ff221d2863,
+            0x16c25869bd517bdef88345315641374ea86e66541f12724938ac7dff3fc14353,
+            0x293cf96970b904d201ef1baa8bdaca1321ad3ff0d67548d7ad07287d2908518b,
+            0xc5f2232813e8dd413410645a1385493ba715260b3d968149f307b53ecc793f8,
+            0x2e620a39a57898eba4992b7a1b2bd9b0c28573a1ff470f544c625a60ef624173,
+            0x1c68b64c8887d3dba495c6bb3608065f7b26b8d39050099770330891de2e8722,
+            0xfe00e735c41fd0086afc250224c2d48cd0e771edab73eb5e75c58f957082478,
+            0x1b668eca521af2f9222ae86819b5aef6d32d8179275e7b98f6b9c314b62653a9,
+            0x285025c188e98d4e6e58b0eb6dd46fd1f8d26ad5199eb9b647e99f70472dc4ba,
+            0x20dfdbeabb8900090725b38f84f661cd2ff5b11ceb3c6835ef698f7d8e02d2a0,
+            0x7d91adadd5a4f674b69907c533d124ee9f15988cb71a732d1c31888924d3729,
+            0x22c3db5b12155b945c7cc04c0cdb534db2f8836b88742cb32db40fd0e46c9f7e,
+            0x14b640a03dd9207764cffecd90500a5f0901946bf55e6f37b4fb1764baf8382,
+            0x1e9b912709e85957b58fa0e0d424c7262cfcf3c0840667012cab0d06542c6594,
+            0x1f4a75e965d66b9d9665ddb5a15ad09a9d688eb2b774fc8a86af46fd72796bd0,
+            0x3d5c637f69677e08331c185d53ba9759ae018a832da036e31f00dcee14513bc,
+            0x1e42641bb29a48b1b9c8a187dd6cdf6ba6029cb0760df90734b5d3bad8e212b4,
+            0x2d80ba897d626e0d3bb15479044bb007cb55262149e10f53e63f42a53b3e87fe,
+            0x2071abfa33f109a693fd07c4da6a5ca1175ff0413513d36add5bc72012e73a1b,
+            0x2857675a3c236532833e6c04c6c9cc91d4aa3e18eb8f38cea6e421c4933f058f,
+            0x9d0978a861b9d85265039a22191824e4974b2b113622dd453c71b0b1f8ec663,
+            0xb1ffb601c946e8089d531bbb8bc34d4a36e257e8596c47a3c773d71c68602b3,
+            0x1b8cfc651b9b2a51849dbfa72c4f39ae01b098997b226f58616383513c76ac0a,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x27d167fe78708447e11dd1f9e1342f67a9d2be1dcccb7c0bf1cac60b0d1f956f,
+            0x2d211a9a9b13bee0382fb707a0744ca47b3cc0f5a0afcdabb5c34e52dc8fa277,
+            0x41215a7139109b953e3f75f039c3019d9a32526461cb1e749bb5e4ae9e6df14,
+            0x139255318820d9f769864e4b9011bdcac24f5491a409c8d0088c0687554d0d28,
+            0x26dda446062c11b3ee8a7d9f8383db1f189859d91a03d35e92c2ae1399b994e5,
+            0x2a9d3359aa3ab359799d23c03f3ff677ece3080df978214c9ba08836846e31e7,
+            0x25571de296a11ec26c7f5b378dbc5837c3e8cf09679fc63da463d5a26e99f24,
+            0x2e9d042c2deb3cabd6d758a54cdeb282891e695d463cadaac01a44b64981e963,
+            0x1ccfe17477787c3bd72741265e5ac419cf04f60ebab95dda3cd74efebf34af95,
+            0x1aabcbbff42769176f05c33ed6e957f6efb3f404451d83c6c107313eb098d57d,
+            0x1c3a79dc7ac79b401429b1284780f82052b0217a69adc6ce431fb6de7075da31,
+            0x2451bc265dac3547353b487c443d19230f1d4f305ecb2d61baea643f183fd1da,
+            0x146ee9dc5bc8dddb22c7ce8a3be636d69c0c0609709b7d183bb8a5230f490c14,
+            0x1722db13180d33ba99b8199a7e6e14bfba7ddceec3bf35161a7e875c336fbdf3,
+            0xf90b19061d11f2a032bad6982196c3ec2132eae07e73a7d7b7aa1a1353712f6,
+            0x29dc1b8c70a75052d431288905d64240c6979f04290472b941f943deb7f7893a,
+            0x1cbd570d3b626cbff744b8fab455a37c54760431142aa6780e7b346a93f32fa5,
+            0x122e0d5aef6a9d944211b3087266a4dfdc64c2c1e129b146e4b45c93e8128789,
+            0x6a2e87f6c251c2f8a54661ac4c177f2ead8c66bd42cdbfcf0642e4b025375c1,
+            0x121b14b512f2b6767bc67691906e59d0c6f1f4be4b77e15e277526a51dbe1a62,
+            0x24337459df3d36f14130ef1c8950fd267b58a86b37c30ab87d57245719f3843c,
+            0x2d751407d72c38bd7803630b12fddc7a076db32d9016d3b0a938231b5f667540,
+            0x1fcfa3e97394e1057eb5ef247b47a0f610ed67d67225f4c8a246f54bde575cf5,
+            0x1ce46568fc2b31fc458c65d79893bacfb0cc96b0e08b51e85d4d5432e2447e84,
+            0x2a2035389af7aac382d3515d999e6a687c9c2e93918c56253c6ae9695d16d79f,
+            0xa7485a573492c38febb77b703b0675290ec615974c9f705fa63b175628b8548,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x3c0b95d22504012438e7da78b1a5dbeb4f95569d68fad5fa51f126e434251a,
+            0x12422748193dd5410de675c58584a4b6612ee3cb8fd929320a9e70720756cba9,
+            0x560d13602278afd0f96096d2554342cf3bc86970f27fc807dce69bcc0b874cc,
+            0x1339418b7b039d8e68260015f55b9d91fac69bf8232722f941738aabea21cdc3,
+            0x1cbb466b02755d32eb5d7924147801125833e9020af6f52be688e5d8c071bc77,
+            0xf5c38aa299be85be03b8f06c2908f0aafaf67662a714edaa407df93fd1a327f,
+            0x6445747eda857a8191b68e27d640cfd91d68273e54d888ff057001e476f00a3,
+            0x1604659a656d9ed6e5dec461a593c3eeb6a5be5dd722675425cf883debc696ce,
+            0x11fc146f9aa45f748a6cce102854720cbfb60f5297ed2f77b16c9f8ec9a4acd5,
+            0x22ebd4f9bcd07c59828633805fc99370cc17c8a818e04281fc862f425a83fae3,
+            0x51c3a4921bd206f65a1cab1bb83da2ec6128b927e2376508c74a7bba353712d,
+            0x1b04cf2d7a71282e57b33b3a67235c89acc5a03e6e5b8c2fc784891eaba9e221,
+            0x242de34ed5316ba97ae4f46f05aa9e7c2c1c15dad9dbf8695288c13171bea890,
+            0x2046c91a59d50c271c09271aa40ded980c91a88ea5f7e3b2b08858464e082c12,
+            0x26cd545999428c5142048b641af7077594238778d17196da2e5c8e1b253b36dc,
+            0x256b2f4800071aee94ac6b9031974f26fa6dc520938c96952878364f6f9790fd,
+            0x164a0f897508f50e81a4a51e1abe56413d3b53306c3761dd408e1743fb060a33,
+            0x1f7569343079826f0b1240702ec507915173f38d7a39bc75ad1c86cf79bd4414,
+            0x5272bb3e84e9d0cc586a7d6af710026f809ea06526ffe9da350fddccc09d1a3,
+            0x22ac9bed266b94c00d2f9d34f71a2d36c0d09bb30d9ef6587be752ed8b7fbc26,
+            0x7674836517777ed3779e8a584732a9509e49db9d94a77161b7870cef981c1e7,
+            0xffe7a0170bb48fb6c3e0b80e6244e1d6ef99ccf3e8a3061aa3136b1f7956cf1,
+            0x1afd9dce91b191147c5f764300d8eed362eee907616d0bd56c931aaa7683194d,
+            0x1ae34688936fcc0968249cf2077a1a982df5358dd5abc8deceb6f33b848b455c,
+            0x3386d6e82aedb6f4bc05d34e96805cf875bbdcd9f59da3b3b95f7063442b228,
+            0x1a1c06ea0926bd024640936f97377319fab6833349ac323240167651f3a01037,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x30192336409d16bb77389625d09d75f79f82e3e249b9b80a56d541a463184498,
+            0x19c8967febcf45820a2fac7a8f7475b591f3dc87e263392789d247b39eb74b29,
+            0x97570b91ed5d59d977e8e71ee895a590b529db6ee364fd82bda34ac18fd21c8,
+            0x1a4393d778fea4efd093c5a43b4f0fb318caedd91ed30e2affe80054b6cd8e4d,
+            0x31f540e1c1038a98ad3b80d8fc9bdfaea35d1d153da0011063b2472004b67b,
+            0x165f001bcb8a3a0f9d4e00eeaed05614063d65735dec8c39737a83da4a293f6b,
+            0x22e6b223b3e435309ee74f4920584e681c03c0382ad4d4d45f7f1e04c8f1e29,
+            0x153d4c74f674e56647007566cfc575d08220dd89f88e9199174e81006f4bc589,
+            0x46d4654e5ea12ef7d79ea7b540efd8cfcb0f8c803be7a9f3133227f8b673919,
+            0x872d96c258f6400c031024c81eb9e49f1aefbad34225fa5633347f615910152,
+            0x15e8a238d295f566b70246488ae7ffd1465a0efd12d2d688ceb2ad1cce50fb28,
+            0xa7c019933d1c0a25cb8de67da2926591274ac799ae7a0800e79dfb1a66b09ac,
+            0x1271c70f8805321068c895e1e0370f17bd49d7b75cf8e055b87f7615892c6c3,
+            0x11356c90cf6bd40bdd299859f2439cd098f43baf710198aaa457bed29b78dcd3,
+            0x1cfed55f4f804d76ddbdc211f248a7a7b9441ff124e31bae6f9f7a734f75abc0,
+            0x2f9fc15fa8a7aa7217dfcb63bc31e6e9a2ec67668ef14499eb4a6b932234aa3,
+            0x682ca8b867c78c917f04c2a7745a9a79182816677c65a771b019e64eff93abb,
+            0x21dca8a6aba3d3f01bc0e27ea518f049bd57897f1354141d461b4a0c8682e484,
+            0x227615abf38c854ee4abdef8b53b2687832b44eb05210ca355082ae06d9b5f6c,
+            0x2921d807cfeed7a85927966f1dd5bf26835d3877c7227ad8fce96f28d00b66f6,
+            0x1c9045d27121eb200e99a9df2b8e956f570e7cb06aaa424872e64da24668fc04,
+            0x40850a1c2d1b7b78b59dccb79077605dc647e3971b26679142cfa657b3e77a4,
+            0x4800dd5d34860acc745f73e61c474dc48e5ed88cc2a6556fd7d8ba47f7fe19b,
+            0xcd605cc107283534180cfecb268068cce0e324f8eed13dc548d238559feb80d,
+            0x265a4560a8a1ccecfd48264d9ee16af19c125244c13ee626b23d72bd6c1b69dc,
+            0x2d72b58f878e0d96fe819ac630ebae41297a09fbc79fff372928e6bf929a0850,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x783e03e1c20687dcfa329bfe762847ef8469b9a16f1aff46e721bcfeb4ed9a2,
+            0x7c549879769b6127b1fdd9e119c7f1088459b2444ca62f946f80265c08d96b1,
+            0x1025885c29c40db31ca8f1f490caa4bc621924e88725428fbc670555e4222db3,
+            0x21f0feca587fe54622a731ec88768d986581c07465c474729691e31a8b4fdb75,
+            0x66df9e27127d7003f397e03dad246027125ae6c99200dad3cd5faf2fe43de22,
+            0x27f3ab0ce10f55f231d7d249eaf38aa45375dcfae6add9b21783d1ebc38e4913,
+            0x1e2dee4d94a3cbe678af8b0a8bf277469150364496efc0ace58540865a6288b6,
+            0x9972d0bc51270751cf7fdfc95ab7208812d7e9d93a9b45386e0bbd3fb23c709,
+            0x147d3302a23dfa4867fcf2168badaff8e987e90f6c141e92bec278ce816a9566,
+            0x2e95c0b710cc179b4e39f3d45c97d0555437195d3e894e5bf238ab9fb9929c54,
+            0xedff84d026026b621e6de741849300748078db140c9fe04236c2e05a35d7f0d,
+            0x245d05ec0b5dc822bea9b8a2cd6c56da38bfdda0a4fa5744da442ba833098574,
+            0x138874360b6e98e6ccd8fef742dca0d8ec44826aacce221b311cf421a6ec0292,
+            0x1cc05be64c2f3cd2b68699c52f15d6265d493e7bd5ab4030a53c8be2fed67e89,
+            0x2f5edc508ba14e8271fc7fbccb3e7d8750f4322606b2e5dcaac7239ba72143d2,
+            0x1557d4eee207353143eed1b01c37806b4f0b6e688069a13b296214439bbe0949,
+            0x258650e8ca6e1162e19f92302d2a6e8e40b00bb161c7f2ca5b92364cb553b5fc,
+            0x12ec2381a018b71858df6bf6b0c9e02f14d8ca492878055dcfce660c7d915532,
+            0x2aecb59a26510953e9d38b5669447df6bf4c2dc1a9bae6f4b84ffdfdff6a2a29,
+            0x13201907ff8421dc74e517a6b72e4f997135c8f0e8ea5446907c6fd26f1609cf,
+            0x1db130e5583c812ea25e107e27899c895214abb225bb3807ea80232015d21e2,
+            0x27db99bc289ac5e1ad7b1192ca0c0f3b1614c77a77781cf00ee2e411835185bd,
+            0x21a326712c5b109272d6aaebb73cc74cd389543fd17e6f12cb3a6c201ae735e6,
+            0x2716f822617a359b60ba9d853d76a5d051c9bebe9ea9425d51b98475a9485809,
+            0xe99f2580adcf372f1c99d009a22816c53cd5272d479fd64016a45e75eeea381,
+            0xa3113a6affe5598d9d8ad2ddbf83ff94d56ca7f078a48713d0af15c4529291a,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x2cf67d5d1a9383ce14adf8d7b63005e058980ca148deb3bf0f17855cb115097e,
+            0x14182d28f17d764f790f9185a15a6a03144c9e41ed22e8a2269619775dd3365b,
+            0x2d63510ce0f51ac8f325327191ae2e8dac8775c05f87b87897e73416a53d1007,
+            0x11d2023fe50f1147998bdb7d03b70f70f1a583a67646b055be252e3393bb0fde,
+            0xd5beabdfc8def1c0fafd2b625bf1f4eacb6d3dd8870d0557af54c9c98b5b799,
+            0x2e8f4e6bb6f7a28422636a7d3b0fe12ca20ab14cd0c5c45c4ef13f326ea5fee8,
+            0x1ae5ebcaae05bedb59194e96c92c288479dce2ab43fceb24541ca2648245762a,
+            0x24cafb4c21af1cd16216dd42b7e5c42457d5fbf4bf87bdb65730418efd682a5e,
+            0x2e139e0df93864516aabdb86d6ab65d6598a0017346fd732e7f895aff36e9481,
+            0x2ff83bb2884713055564970f1e39cded077a9205cbd74adad70411e2f963159c,
+            0x2552f8295742fd94e0f264d182e9e34023f4163fc929c6b143cb35dbc61a32c5,
+            0xb05c0f1defa2ff4e6a56a7582a568d650a7a2ae9ccbc478be52bb4fe3452299,
+            0x2c0588283e0bb713ea7a22fb189fa359dcab39f137c9d5953ccd0ae136770f8,
+            0x18bfcedbba1f9279d2dbd1d0b4b728a4836b9682905e03f6d9ab9992ee702bdb,
+            0x4b314d086daebc4f33a7e8fb2ee578c668e91adff3ac3168dd3183965f51ec8,
+            0x6cd84135ffdd74d9c315bfe319d01b17060fee963e8373d1458e181027ff005,
+            0x29eea9039c59c939cb82a69a7def6a60623b9868e1a7137590b930140bae4ec2,
+            0x1972fc96c24121bddcc76c44074dba6ac02ca1a10bbaa7bb49ce6d7161b4ffe4,
+            0x1bacfc2d72d57f6bf695f3d82859859b329b87539e0c18313a1d3f27ab9afbe7,
+            0x1069e2eda47e9fb6bfddfbb48d740256acd9be07d2ea9883b63e3214d0ded0f8,
+            0x1d87dc8c8e73c38d20d2edd3f6b5abd456a881deeda90d0780176cd7770419c5,
+            0x1d08c8a0952b5e4fd915b39382a0ee45893e3c207e339e6c78f28f1787bce94b,
+            0xfdbab60a929d492017a0691032f8042201a3223c7ad628a6e1b6340d0893c,
+            0x13f25826edf3001e3d8ade5dd2965989ae6c2578b7e886116949553b6f0ce244,
+            0x44fa02e1da99bc4866c220784a4ba55ae28cfc47c4b9e5ba488f43b6141c7c3,
+            0x7492d98f774f6c8f67583aaa485ac632906a19003a7757119536b19ab78b9d8,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1fbb89d438ac14128a40437352ed7182d10f22964833efe6fb46eb21b780ec01,
+            0x6ae819a8e0c57d44ee1ab07a49be82ca5544d89ab8518f844385576aec43234,
+            0x2b3d3a7605543d350b0838b9b3fa9656cb91a84287d6f06e9338154f316cbadb,
+            0x1620323cc24fb81854d716dcd972c108ea5d3b062841752a36c994c594199774,
+            0x53924bafabdf89232353e5c853dd8b946f617a28f094f9f92badf1c233c925c,
+            0x199241c82a57014e3375029b265ea7683611ead5148a8f83a231065c7887951,
+            0x1e8b6db0d447c099ae7433fae22a2e779d110bd3b8feca58aee056f7ec325a4f,
+            0xb3908d2ea7af26d42a913972fe10c3565f627cbf3b05af7b03a03b455d2745a,
+            0xc337f61785e502287e274c817e5f380e5cd314d1a3ce42887dfe19bd20e8348,
+            0x965a7d0f2799aa6f3ecb0ab4fdf5f02e0fd5386bf137cd2bdbc3e6aab74b608,
+            0x18d8dc79d76890bb7586c65d83acce6185e11ba38d288f4933f33db74234eaa,
+            0x2048602c11e8e771bb35415db4519798c36b593ea0b8fd4560410a7057d5d6a0,
+            0x2966833633f29aaaf9d5f8d206fd1353f140d989a7214cd13bfed0657b0b5407,
+            0x1c6ba85ab5f85ed4b53dc40cedaba63e5ef8006c724440b9448d64ac2b394b08,
+            0x65adc608aa6dc0878f5bfcc2b89b3dbc18c5944c5b868dbd6d263cfd386ccbd,
+            0x2f5c69bd32960af29ce7ab14150ba089073d74b14c18b63dce9242df8da666e6,
+            0xd4e47c2eefa2d97991d58198e147c5dc3f856665f35905c8dcc0c7981979669,
+            0x21dc79896380c9936d5da47117ee730c16563d40826cfed9a1415636bb6d9f6c,
+            0x11393d10b1b89df9a2e7c68df33f1ee41656ee8509570cd4aec6d68917732245,
+            0x2501a832c4be33ce1a4752aa3c3840b89c7eb9d7a2a267b16f076d9c90a6e98c,
+            0x29417a7ecc3faed51f8f4e599e13699d32073c5f3865d8ac92f664016060c84a,
+            0x1e6ee4be7b5f89fe5eb7f50ea73935fbeebc6ca8756580099b3c9a41a8a66f3f,
+            0x24b1094cffa81631dd9fc78b33cbd8d7a93d0269ac60501af8ff82fa646e30df,
+            0x1bad44f174f12802c4ec1dcafb6852b6b99dc3723bef629361b5bea594a7e3f6,
+            0x2aed2c26dc890d5283b53ad5f30f9354e22804016335e4190b551be5e28e4e44,
+            0x247d59448600ad981156c2e19e2be924d7b83bed1bacf16899dab7d7a8bf7f51,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x105097314bce2c2588aa56f191b813fee58479e8b541c13bd6c9bc8e654172ae,
+            0x28d5354a0ceb5dbb339ec880b3b6fbc0e7e4f07ac0ecf5348429e1af57069bef,
+            0xa31c76780b39b494f7334a7a2ce004b80f56d898ac155716f65172fce3dd454,
+            0x1225a8ce4e27af6625ad1a92530a1fdb3206135eb09f679b2b38c13869b9370e,
+            0x98a16fe6c6a2a433a045fd0d02346e5c024d7b4bcbe12d2594469a4a7a2925b,
+            0x205ad0dfc7a7298bcca92aba3ec23f7dcee21785c96aea116bcf71e07d9ba361,
+            0x148f1eadc8be731f95ef81b8e1f3634f44182101b2f13d8fe46bb3aafd2300b9,
+            0x4372474a7938acc947df6d261fbba26850a09a16587d069cd877151e287e1d4,
+            0x2ca6979a079cb2f455da4e23b90e191cff23e2d76b7d0a6d613e0c1a4507c4a9,
+            0x2ca59df55ad4923070a4669629aad754a88b50fbd4643d544045d76148451dc4,
+            0x2a7055f1e24448b52bbf572d0efc12754593d59062345f918ba7d90a27130580,
+            0xa644e2fe975a3d062ff496a17e7113a395ecf678289de53b2137df5811be1c4,
+            0x259bb7d88bf3f1c2f0521ff84c05423a250fc32477823c44d53e11cae6028ae3,
+            0x27d551eb8809df2e1c200a661838fd96bea30a7a0b7ffb20795741a46ec359c9,
+            0x17e37e4432360ed9a16dcb9cf0584b47ba049cba55b53ad5b5bfdb55cbd36ac3,
+            0x263693f36da574e9f6b1af2e2817e803080035a19ac1c2ff754f0f970d20c6f9,
+            0x1a893c4de3717842ede135fdb2a63f3c05c834cab22572bec21d57db7c3cb052,
+            0x9bca88fc417d85c16bc98e2fca531206336226ba3a02a51a7fbdc2310e26f51,
+            0xfe6944c3317d58ffa98fb3a991c22698ff20765d34c2b8b95802b83fbbd9cd0,
+            0x1ba3d144274a073e17ed52348cd82eb3e00c743b7d9d3e944a1e3f5a361474f7,
+            0x2cc42995586265e9cdfbaa845525177269b37ba7fcd3294074613d2d12af4070,
+            0xa83811bff1e7f22000720d598ed2e3508ee14a9e12ff6125dbdb78cf07a2d62,
+            0x4242918a5fc9ca3c34867d674dc7d1d1136ffb519de0eace1e6f911ea197350,
+            0xedba1a161aae781bab92363fa0d12d8fcfb5e3b818cddef8844f94e9db890,
+            0x230942de72fe0db9196d787b929144bf4faceb69b6f12aacb6e0d6b51cc7931a,
+            0x1a9561c0d020fb28ea2ebf3851832058ad1cf972e99841f4772a8c578b6ef48f,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x22c0fc9c00f53d4247c908976b1ed1e55c4138b96e9c3ac1dc1f4d268e64ef49,
+            0x22729d77b7b881af2f484a1a8438f52cb7be3b93c607310c5038a1d07253a184,
+            0x14883acec95e824ab505756a5336b2c5e1b984c6a193d4bdbb014c097734b464,
+            0x120d96dc5b428589ffb9f37b5001c6f5915b3ce4460b25331c62d59d65adc01c,
+            0x130325a89c8e74b5feebd6340dde992f569aaa3f9350e45d0904027087e89b2e,
+            0x16e6e793c81a10719f613ab182ad57ebec76df8dbef775cf03e1e316646d05f5,
+            0x18bb788f4ff54dc0981e35a7178809d1f2518cbd12e5e78a77c2e366d0543cf7,
+            0xcedee51d5b87d9ba52d6f12490b24cee9e61c1889ef46f2f882644046626461,
+            0x1bfe0f0059a451175348f8af855e1f384d1299adfd1f8d852df6c325130bfdc6,
+            0x1ca82eb1aa4d6081a46094f403954399af76a7d7dad88d5a9ca921a30ae1dc9b,
+            0x11e1d384eb2a64472a26e40594253acd255027b2bf1f7a9a518b954d0de04321,
+            0xdc70139469e918276bb65ff8334f64ba442cdd64bc1865efe3e788ff0c74341,
+            0x1896f5f3c754db9d8812e99665c89c873620d9f0e599c0b2db25f9b186c05bca,
+            0x2b1eb292fbf05207b3a916692003abc04683db775eb3e97bdd5f388df5b9e6e9,
+            0xe822a8b6bdab9cfadfc98982d3d27df53300922ea795b29e1ed4e61f2ef6b9e,
+            0x14447323538128d076a4a7c5e7d487256a671dce167e1a37f69601c64783ee7,
+            0x1731ac8243601c9ad1c2d81f6ca118d479b9d71d03ab34c282bf68f3caaca5a5,
+            0x1efef24cd417daeb7fbc1789fc2381fc194f515d6bf1b7a61bccd70a0fd13c2a,
+            0x26c6de8f5b580b7d222bfee2f19dbe02580da4e383217b4870f1d4c8f7b692cc,
+            0xd3823efb4c4808c275f720c340a733ffaab28c36479978b485b346e4ebb1ab4,
+            0x24a2b1d438ee871cdf765b899d2f068811a6f46d02422c133ff6695a7f304593,
+            0x9fe29e36bc74cf6d477ce054610f63a43855a08c27b86af1ff58e98c9fe686d,
+            0x123e4ce6ab585e748a6424819b24aa2fd60e371b9842355df95ef13318346c10,
+            0x257d0d633e7b8e40fa3a0c30548ff79d268d90296d8b5d3e9e7ee4f39ec814f0,
+            0x21f4b792c1fcaf55e70e1b1804cdfd952a7ea45dcb9982c315024446e36b4b5b,
+            0x18cec0d331cbb93e5cb4c1d4f1080de356f465e2ffb2fa712feb858bace4f5c8,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x1e5f08ebfc9f997ece7730536dd4cff8b519ebf519ad1342de3c2e26473a0b5b,
+            0x2d77d34a218a752dfa4b941b63d7b02ab6078037ce22ec0608d3b7b402e4efbb,
+            0x19004b8f6ea39ba279e5ecf8210460c112c1a563cf106736d9a0a46b7b842695,
+            0x11fb4988936908db3d50905adda5065ee297a7e7187c36212ffdf5f81220f256,
+            0x1081ebe3ee722e4f687bedf259ccdcb6fa46420c44d0ea88389917cf6717c04a,
+            0x185aa8d933cc96791097565775894b15e2858ec2980311e55d9827471bbba810,
+            0x1ab306868bac9a5ba65245b93f2c9b936de449a9091b45f3473bf97dd425aedb,
+            0x2f1fc8f6cd473593cf38527156e482897df8441db84c875587c24966f6523973,
+            0x17770ba5bd03c9275e2fe0ebf158ca85503ce65969cc9f86e3fb3be24e1fbada,
+            0x1d0d275c4971978edab4b7a7cdd85ad72c204a13415f140d9d28b8af514bd692,
+            0x1ca07f602b20372b8d50c9863fb5ec9fa033c63eeb293015a4bc91038be3f7fc,
+            0x4782f31c8fcdd4898af76effd524fd0739c8ac290480fd0f32ddfa082dbbec6,
+            0x68de12e587aa2c26e2e509faea0fadf79602aaea46e45b608be969ebf46ede6,
+            0xf47f3f88ec297c36cc16581fe223a95388c7c3baffe6cabc7f4f669bf746e96,
+            0x17bc99581c7bd39bae9f593ae1d72e99d7628db94135a65c2c510727f6148029,
+            0x1d85dc0db735b4877d9f1639020da87afa6580963e0c2dc95c30a77ec57ee2b1,
+            0x27c21a6c642486aa075c9a7757b96e68419cab8ed819e40d179992652eaaf1d8,
+            0x1c15013e0719650306487b07e421e718ba9c35256964071760ef99c6b8aaad28,
+            0x26bb2e4e2bf9a53e1147608d79a93bf730b09f4e651d6b08db6a509ce44ebbfa,
+            0x2cc7e0fa1e964c48a3e0fc90f35e4e74cc01b2f74cc4de884a2dfde37331faa2,
+            0xb9c87dd914a25c9d75070b7997507399970d9add413b9a8e4397f46ab8b97df,
+            0x7f9ce6c590326b73f00c860875f2c7d4e6bb52725d8e4d6958caac8f46a4ae3,
+            0xc289d670c7e2e743fbd60fd2a2a5e3ca077b4bf44df78babdffa232626d3900,
+            0x190ce149a93a528cb01fb27da9eaa39de2bbaea50552a99286d4fa80b8e7b22d,
+            0x20633ae2a05b6d69d765ab6fc2e335ae0c5dbcac130b204c01f88f9cd091b12,
+            0x2543a932d6cd8dbd7533f3bf5a905c366dd1ac737290f6671e7ad6adb557778d,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x22187dc1425cbf505392f976a839df01c17067dd9a7e67d09e9078f1ec43abac,
+            0x274579b98b4831b89a42351a2bef67f33a0741af871e3b1911edce28d6b1320e,
+            0x2c52925562b2b08d1d1b2696af293157692f2a0b7f34052cbe8e26e80071d256,
+            0x2e2f8231db4f3786fef48e7b65f9c890f1aa834729f769feba60a3554b9284a8,
+            0x521922aba91806b1e4e13a4bdf92fde9737099751626a1c4d6011cb0d28d488,
+            0x2ee11408d02e460309bfd46344e5557bb6711504030c84d81d127a17aa72c787,
+            0x175981ace0eca15153600235260b821b4b05013f3e0e3cad3323bd32588b398,
+            0x1d17093c739566880702816f776d54eee78164e5716335708fd67bae6407b863,
+            0x7a6e2b3a2495845ca96a757a279b823bec23e6e2c2ee41f3ed6705a9df22548,
+            0x1dee69a0aaac76360a66e057a8eef5bf7d845cb09a3eb27bfd152239bc8a6818,
+            0x15df16ae54e8e3e211eb27f95f7da0bdf38da9530007085afc20553468eee2e0,
+            0x2d85cd78c80244f0900115c6f5f5cc4cfbf8295c2a0b685f987144b9151618d0,
+            0x1e894f052db0012cb83762d3fb2a824db10684db641c6e3eaa9fe45c9561541f,
+            0x19bde06d6e7eb6c84a02e9a0f224c77c0b2cafce0fba9fbfc063a46b69e81406,
+            0x2897de5d9c274ad4302ae652103f0d8d3a041ae93c0d461ac15d30d36a60edbf,
+            0xfb0ac77f9a6cfe96bbaa646fe280d4b5449eda51b5cc1ac36325c3af0f4f830,
+            0x2c3f06f6f736cbfcb1b6927b53543c31a95c648d4828ec34401c2474c932a48a,
+            0x23e564383465f1d1f7cb62a80d4995fa2145cf6b06fa2f1e0541effffc19f5f4,
+            0x18c139146446dbc956ff95270022370c93ee09947cabee3b0377d1524ec20807,
+            0x2bb3b1a1771678092e80390f181fdc6df345e7641c8b7e4932708ac1f332f0b9,
+            0x8df0d04a0d8d1b2b80f219c33a9266675bfc080532e9e66430bb67e05360f7d,
+            0xd39efb103e032f986c875db6b9f6a6748cfaeb333c93ad7cb45e755eafe48c8,
+            0x5f47c6fdbbd7b4e59cc7877eeaf63cb8c16c4dd77f214428dc94b9b2c0214e0,
+            0xee1051b33292d8a7dc350916b62440745f2f47981721b80496d2aae0c9ff288,
+            0x2bbf58da087230463a98b210824453823aed830f60432ce3156c583e06edf08,
+            0x1674e5bc670e98029ca22d400ffc19a4200352fb152c784da88be0b67ffa14a2,
+            0xe30a774c353a2cbf244d3d014d1a0e5ff0bac5e242673ae33f1bb2030feff68,
+            0x8a1e55de3e637ffa6b051ee33ab203483029584daf0c57c454bba30cf6363a8,
+            0xe5b4497c397b27ca78254adc0c66a45514929a3dc0cfe2ed3c447a5d3926088,
+            0xbccfad82d3fbec329e684d19569993c855483814fb2547e7b96cf79ba875616,
+            0x1908c79adfdad4c4aeda2295a9db560a33e91b01050448491632705b189ae1d6,
+            0x1299565dbf2547b30db50f5dd49ca835c3213eeba0130e835aea4add65037abe,
+            0x2b4906e765f1e80f6e84d5852f34da89ec6d996c4a40a066c68b6a98100a2f9c,
+            0x124a247b0b866c09ee5d3783bc715de3244599016f0fbe385738f95cb5dc0a28,
+            0x77d1bac0f5b226607b2765d8d48118b1c55380c60aaac2ec0940afd0c05b24b,
+            0x2ac41a842793f693dcffbebc5c08ed6b4aecee7db956ec59ddc230a7b3579c1d,
+            0x137d327d41a9c6e42e20bb705fc3da5a282c911c8e7a79cab4e3665fbc3b529b,
+            0x2dbd1fe87204abe2f9c27a8343c7257a93e781451d8e159feb4ef12f38b28e58,
+            0x20d9cb838e454e9841ddd4792e4ea7b8f51cd7d7f271d6e32f3fa963a6d2cdf6,
+            0xb34270663039e315f63a5c992e31d5d09451221504f85b37e1480067fe92174,
+            0x12826e5b9be1c9b85f7c98aaca9ce28a870687d3628d60def0ab3072b57b09b8,
+            0x22fea1297a4a5f08904d555c2e15d016102a4ed29c32b4bb10809ef14af42c77,
+            0x24cc6751894087b831598b5bc7f9db3cbb48ce294d9208e1aa436cb5fa2e80e1,
+            0x2cc3d0503a0e1da952b081ba5dc5b117e646bed572a645266c6ec3ce0a1474b9,
+            0x11eedbe5a5969f33446503494b469a2b83f88d3aa477e5d6d7963a8333a61315,
+            0x189ae9e9b162ab1a19d599cedcef428bd1325c78740aaad6715b710bfac4c1e6,
+            0x1aad11449d6e2c6e1adcf9e89114c336c0145528f356ac049f52fd8cb084370a,
+            0xd7e1eae2cfec406402d34c259e5966f6e2eb261d4f08e29088325a6bb669a63,
+            0x796a23ad6ed2ac995104a0d3e6c75e977ce29aba1d25e62a9a8a20364ea1be0,
+            0x299b8e8621d7d8c8d3d6286cb126b34ee53b2dc9a3697b8380c6e47f5711345c,
+            0x20f11ee81d2ac9a9ed1cac61d9cfdf10bf1b49cdfbb6d232872a1df1427c1839,
+            0xa403e979943b8d2f947f6eda6d41170881341bb5e4fbbb3b4fe3dd7dccdd777,
+            0x4646253380f4bf642972ae81977779454aa0833fda36b1822cb9c09719e3dd1
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_15_config() -> PoseidonConfig<1020, 225> {
+pub fn x5_15_config() -> PoseidonConfig<15, 180, 1740> {
     config(
         15,
         8,
         60,
         alpha(),
-        [9296474750911444465025945061626611450573261102544117494435956219223872045013,5146180402642819236271333772846779841277266622562021651959982317806096554632,20454733758478774733902661862471466785458678414673417084919753466149262477949,16939720779646471039361700224425387363963401457766730187304254365590145685643,16508379613071589632225608856524646606497744838305343752126125339777944056893,20867355466989514329400908378893992018169546886162092188544040547127653338003,9562028189723224670918372808954372258890790835333923497839294908971703629044,9227509288281899178360094205033853851646604997619773877005168383222677033411,8509781355418257783679010460137433931646066572707591432255985024195888527301,16352397893201944000231474199631274335610857147594743875684031732171609392779,7168331327842901194795012403324475179802342440545189729818235304752196473490,6805437858781519809721294519096505646809998863249026857458359222740400480093,23666102285914319661214067066621928648019777016465806627627356483470384578,4937167589168346771422573562192746031838523475116047879790134471501476035621,1346691375815699628539641638232212515770545677194558930872887124097351576509,40983635009581820916284370715993074471281691288657861297464948812277259151,9682480346612414028382424944197316598030638601235308149341398931369789543950,20156146228109066705562831124708208402478981918458654302206305397911512087980,20244794515708180670563002449620617650597057411850557162891558214158122324521,5973431503164625202944413714022034366590666955289560873103517106326649624937,19003031440781649161524015602474761488168160816940423515211864494962159501828,20712605099727052887180337155696823289955789009114447705180663042338119444677,15751263674652110912724722781530878809312788917232502379399572977178318108528,9759440007076373606849230657528653877996372541705166313887529308971932175875,15753864581145946158736383142711883662973744817981456049085179548487345401534,18516736976984654236711834595195133682620758902795528251669085852778367276210,12505762035583653640932505661921159087471940695093437071026827168265805916842,17973475260212324625956540069233265735155253700466680406635575121618318752819,16893238145591341977099515648275086133943062918579997543738633084157810726656,9669071880586595648023284909288486812190820353718106940661900367937844527179,9349088318894477564190440283477178116641834248883927901328258581942583077569,12186865849936919100247208155624431297953689379595363409626510899600302936538,14191429059221279746000430832297028082244506830783856999765158986408198377932,180235525898780969912044806879591313131227292826139844018949863600387171682,10889092107911649889040150092427122550710450427668385404292705974881857473203,20693842198933957663269842304864226322478103663024796211607837700737760050747,19741631810531886646761927581354810838182866370317964412790883870153217103250,20514964832794580053019916730141871673725635044918093569735954402314586611172,1563081830952767432323468775999289294801679977848773475307184358241727189864,6541733180459084604825913391805383670644609126706479690307729028795470985900,14338950551652503213249338133071776308134322059752479422120853035176120166434,9445962403225070324948180958168278025259517118659455884585920056598191781467,17673503748974627902616087621827013509215108587044719385816919777868083778907,6529067669277048252246949093210874205656745103861744893697681349157159395382,18670351688014831561846153455584274335550086431574922181801742319576494275746,16087198812208315804697003049026004024678636407919712012630915190666161641979,5409244980912243970485734262038475969739470891565229610070736907935180643717,68998709875023468479905615300134369445692715997447916337587330860748485243,20797106660136416987264043187693969873379408007710762405000375236313842719688,5277839105793767851333321356647781091931078040812937205152067116052352239761,19813316014421099365974197500618281012606383357022846408656988057396247542705,14651854807736789020692970167659260203349703129364255901280500438993569147591,1953950121645869390891017290629473806985703435547819703015178261443018199466,16966986407661837074189113052135209905137771226341312735335483526986039302676,12196911666087491240035929989808617508758866763772938948559650992149525851273,6748262588722620715981149705241221174138004527637005241186672382866432164292,12351853389756326378242661122644604232955500481743248231924728979085806709527,2565243335980149108987604508873860765952308183381198225102084152967125103373,20241307878322245036836862464964995816180104231642798486998859049422772672116,6173912854438429518808824631217531662651777757438489861961683800252069642271,20373949892834246498138105881327221987245360841655169052122063615887220321147,13269719501466581754706990055797732063851220874637620573076979035861249715318,1578162066274870756439515512829351279665654675138074205960935197210851459902,15699466465478499203883101572116714566818501168342041974225130392829754730992,11504917391580472762574218883359632564098492996052059988389474392975779673931,2471534962918953214626354556158558932844702538697900698209059019370494276871,4461270721380837522838335428169036184773145514356202591842435276161887233701,17625308215993897091838888595388246859096597033404108848402595233466786865507,18815388073919190191562579690732647812407368396854637581401819367329270645091,18268550843300936597164339843045347137811481798420250960800057984676328312298,7226998309855583456700105258532413039112576746166962016437941756495852856370,8072980663193342911861442510877605529321700341477138509973424538392015970628,15269265747158306563417251524571764365372430081923021726955952481038826679058,19910037920320033458941731683391812599895690039363377502140416867160565960964,15486045363368901308969563040163325835584354680260407824152890548047474173382,16416166568440710996186902352749667794644450153896415669656858302452107263361,16719876352169334284151333613847626557780385036803676145001883066946186048592,21250242709366561537300491285945444276614074599553674495821079421382627519383,18996863118748910427791883574992010505069161233259708625680518449974859990560,17413984989888387572882804568722637770904232773299911698227583956354366272051,21597529235679499224130811468867862981087206894945208547265972184954721846149,17271950603399986802591192304636434671723720851969778588610595038101316019146,6798909530322911571363098835602980477334813891267210720952461019098407212259,15221754151466299785203667902143040752208351220550667002070154445706666401776,9969565572595685753856723561942014758757583006296150732797865871416014191612,213937728610177048236193694412457038661914578783162813372436128728852762482,15615646173777239619093550417838782753019556951599702936217300723011405507797,7718045694050546136660011535056217361530495049313202420611728185159583583910,6681562236645975908164269312121030538373320810986198141132181047805166475529,15406190007218505433124772738477886033924738791369244099805663445061334497251,12748925302440648174656014197639220978675653093966691038521528280766659388490,18792405480956246176786158899722364426273579869771820318487342148987615503627,21034833205180901867479986245412384531166379419487221053266758595893395608147,14993530305792055254503672111497655292586320227932876629369830030730566504041,9717186869050569007497148725820161576480205291215534893842038294586234260310,8846581556095542298416062056868302371695747263219967935160771313384250848220,5719380810982615524673837631402222949910527678512468701059039624789965209167,5973398204091658428913223841081738015584068771535532858878785900515770169284,390665721029373984714826019392824960041229454845430836402699997231854884676,16884099579377843869279635395084651641533249525144181522512029929860550566335,16716976662979247989662403288430439465273241484103184167374388250697744962395,1289338592939287230201589454150014946433268062090374613616251000166621302313,9317927644121595578754625372882467923006787730797841509740916536436754202554,9792346806272266839932159619375452292987210695578600955864989901266954094960,9296083977157792888817756474494818556822681079104304334773148774182988756476,10323608200914404656342379674401080164220099943588034731349775904877409752904,5665882510779783554356611639475035143817214951779938939820232711292028607543,312967658452369621468725894369965307895839161467077935727514890821777198625,20664282841391311519597819314930060269576136022608505709992590417893434920589,5323350315725158992622594066490821193659726275127554898433661812401256218478,16039351301369040724720782620886565139379163954982512295794534252600896786349,13820693026747418768344065399393852077420709727979822490883114289330249839237,13797176144228246839971555725332102191019905588045129521304130064480669479604,20861818286081952786814445160300163171950644955642439845329412070095760317081,6607366884537402504576829976217056754321721309944806800456553075345742381854,16676075047056109258708765855713030298752565264610707737757882684833916800885,2596872657894796835537858907147863451585796495210087845405329734139833282637,1129905770296794876904745792895109768657958745069004656310552795892948378584,3524768344101236852745306230236516385903870540974561871381448404874187920054,990706121628678949689364737717640674078492689689565457695471004362978678643,12808278123975447545284898374625872643451056414444411676912801184092083815084,6358161990036632946294642058872786712712883111056083194592676110308231876108,2793873016535929696420652383221830923887713214117784093571041985641508474546,17305928010614439499134847438771424617226147912488714899621343734884653872709,16284502064199759145361743401051151176267685561605421586130298595070638086967,16669378724978577155412758169912049188272082311653969294949527064226374258950,11861408925173541719238679231659983919027526756130925399544116580983984008351,20319862771317637561778652893808792643716731292949307597222212602977661607952,9965217723779805596104842963458526859730058546126612755023280528059812781678,2231229143040861060383699098560329742848948229177358362095200642518040448582,13286704465412914480712873676020914803973411257385854321890647189069199504571,10047635595882320884409798135378777636448641999630707194378323292740008960417,17087336000400458291414525340830964856800142468906625956701637877370905283650,13535594575282729223473509709844990145664370669908108705760692736046179136608,18619202345418036145538258744454149503028380077256559127312056952610301046510,17607804586369163727645967551963527279187781470886431384954240254070602283137,2633042556450301220705608140363996319867584411611510879359782399294296770849,21731768638998447189300033743436435314153248129574741734083353285598244080117,17469131737454037935821691482173830563221091395109883834897114256467877636669,7750519651616125729362402583651846123740462681349952291880562002377909054050,9447081032000164239615272903502339392629921187510175841323135270498903409976,21517411732531464267453023393592251500842566572268409532461770072252092958721,7876501141846244962862794902521772277174190799788868978106856756141641727971,112943796512817751182977688559740204117088697116147815915631198815244286561,21045605911504121416853713285261007893735116973950420994950288232723845218749,1753558144636632850096274509984476357404441186238175375676398948118672743832,15932527070583999576056453444162361416070384829011926782656187054064561647022,10670345925352776542283780467580832901477001176626927666485810080031890388634,7579612604695836258451031149594628860115515363868399672164640908835805063913,16678286807861813265032290142015890821080993558199809221760573633471452514219,15414078726286200869397977002633905619706559151321201886825291326757189172060,3948850363929702397926233515670425547474212215810847662989169477642088807390,16676527723244281555583733536047809454744760551541688199219131455695588765207,14087355065973222250918209290719451048172913300838805685888196087459492418503,8104074033209440421654249234822181338065658024406724406758136674393332631833,5187207728881418438225188748028865692950088102865770071392557429006545519499,10194509841193628413711183989804813746356025348148221750035788743075560349210,10011332996303549537072329954668024063758462809797094286213034989313201039795,16531650268844669358279021502930777186663937554425443224519161588787088219270,4198803426144178314296362723890875454161257236407666607766866723687553739691,4796265297638646381399181426481493643799772847333437062194249373663993441511,5547609802231005143723955844984958632609857658378828698100141356246667308579,9238958429509576319892727665041354560043563806656332888234436819654598656915,12517630133819614217261779870726755029108748195491643235440705119352058557308,10368014234449326131235994433740216752312468149182650354075154587397704894585,487465315883418182347663117280302929984519597673016955398438666336416216955,11185034244837678424376295011043645561088905841730131726788873681031338174455,7421225151165727634904994585688522807152162423870550118585658136113463984936,364806019968570676099566454292016788351689833960119434834370974516536828706,19587762041779243275917908822520467733740516572707471226884058208850887204874,17699580368555821903526305272862177569486615328343491839828472034082952960813,15739138573269259325517597876326746482937619260543240058947651429318524320399,17749815771695585990262895269645295514834869871993754550237121995617786628911,6001281843453332722738415535953496883454214144943230146026585272790933236244,12226248842279453247400486197034488006724059955941344491855600110495696624034,6471818050024319863197241387509891745688912297463370650154695351698691437030,17643944916136214612858153024594861226464689685432825152621939791565281052364,21110507073644152221308742247603861828087429176260377204494317652281698346306,5767681379026755049166284789191192306599058359643996830685583640018326835809,20268516002780303771030074402103352053711651542638490897887552979541377898692,12422024375924323315232423143442023050941283872688585715847426230444960244284,20694378016149655833849108581703458975143197158248183642690852771732423212333,3589864715711417186674798636588069952164879749159939425060725590030374075726,12536189236026623553502052145542282538682809966098904986394409008189339523570,2807680329090948893979159370041090163078264208853025987363628558807228757758,11134364423913486029994525311335222090667061028008118303028273833566959977738,17354950677485256631166408496835881692979370134492552889236570818914175381226,9148772489395197941519683034415731069796332771510468178434252005940900987586,11051248410353114396778661421385387052304377861539041695630551535039137025728,18136540266852326106685174083549032333515525540247442551401150755180487725743,3985310545130175559232554478662499499843818415947765870117105273186277940709,4596525943567680471287409788454878169502290977680316722474714256040545023213,21372340401058762695712005390221995267277180470546612925471076506446695116009,14075257312640062020412482491643121652025454294874360644194100265009640244905,16944503245314408069496787236107780704688926045771652862339257733069860638621,6654085263135548167634225627185378533095825854533316762555824971264586187651,14273015308464032668640083373269579252065688901233915918278293118708191497972,11764478817260526126925152191588101018315006712336605965222952598280968869260,18155813367404719470487615677791656111973118264369674303621800593085173024524,10850039649283761393985741586943649861203783935137056310000609328911733104269,14974871370837446170027589325430324426484756076474120128444445200816418916077,11027268992558661543645635853060250199670617750348905948352231500166030736735,7737561462151958609897925089803246494900406501278116203687665387696545068888,8536397585289585667363111427598616854125268561779225310999422087929379230845,20520653588911738970276129298340919743898256960050723343166349159335019506767,15573689478722985997422248150576705853901581704550704092699815959211941071233,14024637413191434115623282477558112970843649259330326803453616105375507215588,21353180477994165001466351039795610246389619571796579650797005446278678838787,10956420585038523642301267761059211443146357574323727078003385100699325814188,17634836995596798350536418601573649005517540866687768902898663209263471034753,9073831830223507407321206741538426673038288500939999264368323867070102600399,8100061233881358546546217363648928017848251671613674228091904606518338839516,14292884686436880002999028765738013651173249817687065086024117836878136072418,17843666610704256421074257091600372846189412242040711501888312601205476877610,7418496999733433074316279404200997784331208365418356982886646484553701153757,21292338796777812243292835631771215001169911232666037289555901315952974221584,21287440813442297789932443224883752220885368198719782335487617798315717278443,12316285862536720021079405901921917335504024672055930573734336005894401174699,3187192338760815459509556016254324490807541427929108750144803145054500486833,6482850190067117044880439000213252508905126459059393355671593783930481002065,8071947666795842917503687890154152458243669781913953337362618950188906690910,21450848111897538423936810899713904909897296879883982984541189476327391575319,10587193221429670115264727936502940314613396351335733485096445152378181351510,3385684482890050363671196710999686076700864071377274740326856556910758812375,15982506074704654515559890904595916307715088473006256644287900474899011899187,11051707205631537861946095917392475702553421314274237258592689190929368154151,9251268179161501251470629870144065342881530535654006637177099334228872748754,15384401424299601275458808814042231311961518546060835375991090955541715971658,15147611899621647169760029554894128666862161642594655274320073446753024250644,10615109639224170479859701634647953864795396211020891058926612120687182210257,14404478161927699835476596901422616937403414811611272602635749875651680921447,8066178271733489868262162784101440625233465103401108911752234818690246453789,20248276648316419325977215090702991722051292305169422329958075780094418699373,2029002457916171156303194520244672392499138634810303216935386602108547985314,21075731183134253416827200425853801562619807215475840771703429923133977728069,14328824218343127380036695796575765857116907766196272954596277912518546721093,19160580257616407097132379087560824295215411994049928358528355359904099586504,8132787339090119872084216324271073977022107784441826475259174173324397592845,13163912407679060956610455137901723175820157380216990622789851897632818074059,8592347632837509846508131492057017267103172209796052768156176559923311880083,7893378189384253642782385691967744125589477790209699483381677762080196748261,12191210041395050728454216483522186705806341251170673836903099334267999015601,2618630263994051322846776438484808085311498796047898764787894432257296575984,13304976328362334711292646669717074062694791647749224129724116074506061700957,624484185190294110172011007497433523891084548746061325634035014633317325140,15930533828823189720011923265223664488732840218774700941123034073028585645207,8694885217655511794794497743599831016837108207363203834593510913033381737488,17331704109224667609742217259848258607875799984699711250101367091564505664522,1143531962761362035993655799963451435028684354850849659611727546724143302608,5414384052493950126841753058585655621007207302558963578017856767058437816718,8343436020075567035126766344602793013516161248129384290738181959425998466132,4832334637017830367140676637457267590768883455902783371477346052893423021577,15960489327340978673041589758216206637417346222123069896632550487782527402630,4557633726568362237945959401789921266559833502098724828463753976542737136513,21292745345591415194683498267204047392092318996401128975083535124377610645118,9328286636803072400168705383927986130049573701928015781654594560657277940196,4380226305886799411237881027947999265683595948968607979382183326525427173817,9767464780410766464122903880954110687963200055038905098288212464855640106788,2341077008076389666838372736815646466482189988625828995627083487505977087946,20374148380136094638123722089889049817432074134077941767483383760377289749825,15787533442296590591714142770598935669897792586470392297628568666971956576563,7633568663576517885027652011215374332444473983000466204175445586239040766264,9580455424171239687884724329420941872151195359863514187490663550878551019919,19911295277809179559313541842789165346180998073715101124443882860854846201169,4696263765841909122685466774945153879000521574484303419094957852664345027123,6118063668634440692631158765198200090955204724365488531804099825202234531440,19475295610121478762637598544231725416556110773059271107863119783250115177307,20179584065699439977644558242108004135948300904465438207718184556293527131765,2676625519221951651755843575492662910087680586300055636532952929295968711540,13080027857034076796318609243033548218531614593023186061246772929628249264284,14263363493033688982783626695159053510832721506041125050282934376406154340703,2706925569052822828207630841519123914917406668054471879280093987418440726365,4296262245978655924075197707705805754837595446469608588294115404804858164512,18695068331082119185822574502658840301072706119995753204333012565779354028154,3337114200744822151016415017664070914837554273478224716426789950128003958134,6975962532267211837956893753783559781855104297873769130878094791004904433267,12231027575978562434100945363599501995871801149646690231633189894762835916126,3888650643207658707541674459822797638642380807202524073478543941467788883170,7676102615198465271172138409531332193754467889637067928466752449336805364120,9811623913757464238022803188199125269665959963552692281954397128646993550529,156972936087215783948417984577273879197745728180593700417440323304914519034,16588845615557743733989563376260327418375621586848888397570715079613783522187,12011819284668339582414804793555969540908484357893010282713633444914261107919,9658635959610321892309182692375199095125363721825304507540533137281497868500,12870566947850007704602286722292111587887779596594529150836676091488336717955,17017505534531720639069672825866463960388881234646040969078396172375695830933,12828756987874340466657656310127299330830014385503837959876241551509225608029,18359630725137047619220866091928132852289131876343072040435717392635728807670,17863140285101027979634946030001422306163257009614315954049905801373677640874,3360582341611046517265570944669154454984314353967466888538655993528259823694,17502670755424560054495200659249586316206934247721147538443383457515937914644,13927649797430421409818392324255621487749881718200898095569535249421816857631,7898469048097586242538236499785851298058905177690518852139435937277393454608,5393613856505501947177492775058221051864341377769606207857027894289988034452,3985540196927201732264077382523049411262602519666474163140081018404802939018,9933548682032172763206440650514545057762401680471287764841975167579530669418,4792769546077532311825527426101752293398958175332337087633556291257147047450,5156370681902535309417699137971512021677704826447998658592162481410036210325,4763178997526214364264420973622397594953864683634906055109407846288865926145,16580450694184328601228411647550657642835283837702883837525078295714435399937,18999059441252116518985471589622428967202991051386298987587330050320210739909,10924663926297817693040648165612355343542542868891379772060513577838006191064,21154439824594463741340124378173590149781737214921140238108168355994559155084,19866718036982650474956880892863081255204850747846301678102177541466640536845,5726341152794890743559900317356587749078768834368131432915420083753465739652,9721930072810562138700262351588760483759343649062887160202262013979665248772,8692713109320385702126858931428174471319167530336355188864897071149715822466,17412352102001079694372298819013833514973940827985696439109156982412245617083,12672821032755011921233434696998986247906307111868736700673800862103166163534,10172970004738576173270726006846527765711642326938611469845242801391711907951,9780618262465502284058891490165578338456400832996467543839344602761711940182,18851700024286130309776897830342991020297865786362943013731692845791157935866,1702470413617318930175864989944938294024268866839160834076264568335720361305,4126610465068493007303692923323412316073023198781919888394734000856090363586,18923463588257096056764527998950010226471775437259486940005784970583303111186,21839276475997615446044485384539051285181302015654907519320251876081314334359,8307810470154672938299109640101353533274474986026012646848648110658880568963,21681710504784331775159894287594944141623698915845714535863219742158877134446,13673546849110664891321911520052734162092211680871085198884137808051757614727,2216218889963359247084339208809391515747106874740680794343547186367655541588,19115757323666287625233094721549891816100455942516447718127879700062782999180,9695759088071708435257280035083149593819491025470776577904130348886983773393,14990538824992915759805383740971251128446161760292769615173978580109946105509,13500547160059033639084125020765777005399100253116035721012986936873938870871,11690620517343570003741441631732985155983668292416671376092598551135607742688,14092995167301878045390831717670181419253620142006537525508736966592448309458,3134074644668983555014847848317126775181820544161601574897784886291988720093,21356667096328346522478877399307107750543924879742810010071567516379232573327,19328894389922014017090671733282649341431509867352021154566219841026028128702,16777200051435195914695940482277275703598221309253917444691069340963118078548,12283150914371601398948839801032083610952821665268602559004246563482653048467,8031025780211541530328680242940535108474848337234033825435617391087509668168,11393488534594129202264782038673712630583567081414606145740976603672179543089,9489545274708587303435157546929129885054870357881034831999260754593859728111,6440297901700932642712459656137166095980435930130325599953289987347675780242,6894515864899267480052927589331916028154612433273964297048946097044117290367,16589536620737203892631819952021004148548871602361830198268389856564419047101,4583341011172551024562134025995013510576215116397573125685762514159294995879,5241434939346739917434576806032039711895865193494390109560604956906855912755,17826720085025179303670747265498956093868413968174402515352860124554701720680,14064177224800231170886754123172947484113558685092392153296947056267698509591,20746239761736290080585462212523994318855974409743295600262800987044075760592,9275091732796562047971474774056076192970912855497078395575768670699769126364,19100348980922843718890560618583044384034028895423544873772560921345167893474,8069571373226602742410885815839523915870737256484068502291195820379222033494,1467293981248465102656318727619114500592839521238995988554329217082570049573,6381288201275521270245376318098534380164014423572839901345374016424121324717,15155207472765568640645705040738739058676005958167290460723767903432317983809,11827307205908787524136950608324322915050519697651400085361964512106546953617,21374803923432823385981703420361272374739614104998515368780896432531799636069,1620198401197709963530631727016287708030541032398661971728351531077981225770,4800625217713746765755573372019630732124860961049092382553729057755156854314,16885045113746325978276736698359862381890909478720549186885416774857519433844,18940059701033384450370562570502818829119108154708321114250461189220553261490,17028163572961360646345264113167539623561504425952365941615928454393252072957,1611295667261368131094571297996490796385397691978293531693197200319130547745,12046456112369511110295802643603369841325461255354393474919590204243253663937,7754599975225661234551263660451457408477000193002987626530262268904609507135,2313209556333942391083901663566216617901599085931440197682535151404828238681,11201045085233852526555327068198185072847585214550933934267941732063511616826,4467724481011544137869960218540384367398804813150942792543111067523429032279,20757297420378962887523157926616026028995120570567878138398997747263606554197,17461435854008784993561933203163122288937104371480871856334630516397129102735,11233240529972088933066139644647717712375997842172826165553170491212908480221,13986517480527430903609790838030615892444640383875866009325809535938190376249,4301929714047907689515030408708811722641058401192285565408232097014641811166,17696794946098216231804098416293622660221918490072683908415671549432039016947,7439888160491058128389941744272690247182736763968209695016076283096704865863,18423890552826544443227868172047086037747632248290044990903922658938527547680,2138999949837278709489832079964510183830385901897653052233908704951853637094,8615970277754580973564280361114435711269905378483503993334701750963152744511,1245284434872653312507712347938909167594598148561528981150147522912318212857,16245768201990863935411700653063134435976966358871420800168843470345424885412,12879861318323580145511978223564804504159396722688932396568245995032194740594,2552284675231253239834976615340003107373525651900622595931449498227491766869,980488019139379194961142515231528163966929536082343598209628148732322981564,7264750621517252424008399274736151499285393886075664598878039391991523050881,2234522067987218377738399151771319350093309605278907663987720519875860528325,3115352127411243786318531509959426596747177553864136971519102170874744602976,3667866402502198123848250630765454744061857715778956702490214141676773902196,3070805472938376665214561241692318374677535766486562510422267606125416243825,7823349275852374866499481666710330223055954666864547234510846404777769619933,15260540996982618345416395328474127890176746670866447824367770359510137832585,16879450644311650077796590833984905697151358442225768059780947025899660370589,15320151525992649849875202875042133283365355535963553893454329179458534031485,14632268633016875179098944659717422356155019599115523094512078700042675723400,2897293850461343844445387032809649396366859437152990471719742534237008502809,19666002760225463497556206571085469154515092232825812732816997876615778032614,20118956923652349866364311940594053676005949829436315819799225245413961818420,11744985056755246878773405286931074634975698324846162530423833591918403445926,2015290434884472026423323399096281629968890595973845384920383969402450506434,18249544278720359760062826368546772272198884406461513288445757927068468076813,10696154943059697598572810332978032400281533074175542497867727183214332201316,3971341798054170372777083512695270701169903687966221904151853325481552612966,9959663659512617071119055590004415036736845473755952682208877124936249722622,2181868782404294694165345801562667214869325590275262047722759281472694906368,16543662218198449396015118334228119894116585978443535797616874635898860943302,56444853332991525451220607324577660725674378827134771417770990653696578708,18053264525785010356112278932118420278769989354317119094784720416230380388033,963511433856494437037779480692599956325036862396765985497581773445785537789,1640548195682821030419870544261428767973895477020340173398587128599119014650,15577232677357883687312806010171709394572550002708034453277797023283497421495,11090954381098620504472251563901051846520004004959525348540953956152044818938,17126684395012300883745178409829259734795520186865031009709416122834152378303,8422844186088908124243365558762687987341862957152073183459572023886741121702,14662184649744589649763530324217861015549859438835398957469773613387857845572,21031377022606130696364565229626602575982595290181000993536506695259062820250,12689389963301532909415546365757541009330035137990488344057816579888146178666,5214588312023400585366048036841380932988375130807938893042700215898846591858,15041893128824524382738883860992957588596383766546394405410998279035324015705,782192460855406809992878758154419200401389375934686194113667662665836876265,5661239444927590688224044135973292706791664398184824354673135332710484834774,3817944105257087067488946967989598283409314186886285679195995872866829761906,9462770371773357009169408492776891016388486549772557694482752113820123322232,15769763308905916572724877727092407815390795595917044619305377061254245212113,13771914451667791497863967930538877162560051760275863288476375824988661915333,706561967078473376761233253052150494577539018705821668938338502999740910843,12390235197745683286169097117092390888206044377209705969844343148646378449506,11145596728577531179888406424537808841248238586984730649700720979694309693930,15681641822349110677199695953283484509740812777386467296516920337242539284544,17574569459993920657262688380744386356573422289886331853177778938058648912158,5624326259006122381461763176192388804186780246412847832931645688163746289220,16496277716358307095107833912170230220700599576045238114071305799889738129888,13435082168481898917836725813624706153275101528359222531631402061384065427333,14145359265331851785705850315135126451460028716020850520657056103361268407457,7994845231841309191598369070742738315856499258678582728014902950258896103570,15231733338108258465034981184038200743349384534550555337079556783807466295081,7713361220902077511242971379188205561979775701167781811837114504665826686675,11242747039712276301478013037107867308448907318991409117791290960665848463140,578482125379746689637837359294794469152617864738083364508568444154322295070,10411717957746838375775334848320973308009407649021455865417509560443692302903,20227006425680272844667600313609218155469920109215388465037566152370252232679,4086233333215814731082706125141659248745981704236593522409792368006446650781,6808584534953180557531972017829075410964510413317063595166364533912498333198,14933356623681974917513408843614143743808832277364712291262158931793965369957,8361829936147528340154802497787058714748584629340813748839621641190595526650,5538387899076347863195504194335672966840748823754653039217054113809390157835,6615705984888160955628612086123920128735091346352058978084487503753552928718,4247091362085081761865598677360777173802067597672781739780149117241511260340,4974625254311074298909209418614844254599548567616598303359921500987075775722,9907284404283923304330882823688663208972219438730081750092058981162203620514,14238658152145851054995618234965786835935641311230999365757330392464542182773,5602036166343678358319941150088594172266643715315669628685676756102877898852,10315461382975117983285315435824656113503983463182219407091635205239799886780,18907680493658247637744313142676664986314600274326418373879671192300682190898,8553303723584937031207437681614026720261370015480962759264727133956998736136,6891145490942460969785177369488530687011218911690606251233112277697487049464,19170245246106596353570021916624717497160367167030242670159454715827568730304,12963872577905157066479007532642021260793201956955966146918319119859824768103,19825143672793576100800645640010743262329532693712002233459160547290155991184,122363237387596939334930000068508772338726942066663977131612051418977350004,14083010722716557573128541885186700095072789367734739290283132018427397490175,3438988943822218606847460625826294857914025511956848084069535393649532189446,10824463893276561180588773956898041497815337719354064658470380006885795713398,16647020853733827256761129360155419271528077519934494581063879760642045999108,14779736608400098952280783906738683105991809429340153405681057429405486938750,13142746404873014842415191205878004285381311757484122253939053617110681448928,1386333773150414920705543260472370744952980454893569383627231135209073588228,9697679119976816079822213749536923969219789272727871054723095487806154942217,3460404774244857416356250946884568630025797822298777944076755223444927083223,1247968706400267099989617117009880060043946421405967563604685657862139452642,4507768933023927635709805634829365165299253230159842263645571663212665854586,3426290614024232855381062903753364259178390841306198547519682507770097215868,14446229460062832266543880366376059431654246279317515826580297094759435628761,8067953446832743759173288639514778564060677449303509306198517269476636669111,21177512050925009490126830107933732327927737774182499659239090599165030659885,17012508948587701524178526490941665696519922093511307343255635334215277408110,13790566627669249053646494281027520203709518820977624221038904711079372230598,16958540834863372886175563802155893167203339755555003665356919890498736433754,13423323660143533006628485455163236538714121124914329148003611317540843114521,18732130441148222818743122719599795831305992743627249485606912380686722650328,21744582565522883116221789698750442373155722956313850154199652336110648496029,7144354002506963954801968243991190427536676772300009377345054067229788469802,546773555852952995236535448961524872583912665647152978722419200006698017228,4115449488659159484679292884434524602598250771770554945188450323754895822199,8595752591492411960378746550184866534422481915151040676780917721787338199480,10165757572338172851680092102888140824090130405358311565741520039277283108819,13881202481966783370628597357006999877307398877082297393247431527668438855111,164079380527758195225075822377759030452558671627014461867366308987961032431,16597854725561663920154725753244355279782548142174519652163898109297275062756,18782804026635015341133877400860675283426234307512052057983648925359584161851,11803457827110915157916889714293161979623605698803927824089144848270204757888,3790889121366006080676961526219702764983373811240106724685417109395959845261,547387322589169298813085629174571402766705427171260176930124272482922852550,2250336107342267953278191463235028062291289397936525878162948482155007182474,18878522248575655887331882357174227152771300904536167927922454904180276940063,5479817494658339363150524278522534672218076031607309533533517453567105458144,14471434214677769494999424343272645790653559928767779107202935041996962964627,15118605967190623209837537416237887934162874725496448474965882020979641133025,3039022034764509339398468046956573675942916248030956764556346100611315129267,11040960503243486479242227243433964824049773842453715686240136222246114618507,14522024554516641986547166200505804498300840654246791399797761270595590503741,6835224295711983166071915743041027338226822865794125690776093851440377194137,13366807550844486078755421216059218883003148232530961590657899207604510596943,13252007130485429909186723432146549270562877209239528962258894291232641470721,2492164358128252077612941728095518049849413853275094452844245158937134153493,17908308295682961911088181370570531617402259473536245650574431533231050717409,19598815799287079436414455405296166262841941910574843546435474727483962158191,12296683988787359527811189035096536832943622321600079901820428531954001883453,3034216468239708296411368036093482845790159680213461245275097466511477145032,21365662921308444671672644376862924257055009191312934218262773003828812482536,21643121605272677508602911313799693744649969093302740901187983246336863173757,17106474623853535335864151625226941722837229436558906235895607080504648969673,5170493063367583327862860118856811567748934103888623432970286709351028834594,16157297782580756629356992582192341437261969693717401640006420404649789675283,12726902817862860900369295542623896245980247290073629666117912397630392192361,3081548921497703421223514856379500960238907095191066190890406228882786538855,13383733165408518558908753036431726341720113406574723548828112868926423953299,17114711170811861625673949085444809223764181246137324935055609379301828432643,490084821539048617783395755779188347718107877537460289908857747116706971191,4649874458515161549974867873095987666703831126237318082002364917533053056940,18309757296672459101064597681764458207032523283974093139605613289699615669226,7819183041486966141608141659813055168335432042159899601871834502038946555307,21341796073041881721040729550176895226179046215340279859887156449076052673189,8964280440056181910087237574225882257648057952084687707991537684955336080915,17214415387533445163014526685896715822410886705201252936359885537015585673030,1103535976918892886566275197010540828604931300309949743647411661976344710321,18989472017473838846112035962614068658032619400049135145786394166114140582702,3261305106935504628452223922938937365963307399148885220969836911471709180672,8250352610228962368545929233808273614693022774196635878184474970985288333646,21336821559645974200167373849850832540612240140661136750527391104897925746090,4804442184264650022914507746660662354579855239722797010340948536245079163068,2980351069317208287298989743520302917458165906618872700838358045014403829821,20789178264137518066753395738491570400211130020259232167860189045958431732223,7043197173168479199982037485481873468680373055205806152875339535752299138160,8803416368756444354155108122527515347994446936702934474369040166131196644971,2327814593413519022021694520242495352706688146726587158472403609475455845031,21198136442842149822575509914524766455809483419897291889042050133491478146813,5588816308782619790412052393435292678862962083038610001710149574381906419148,18457707371647662280814248200286355752809748069618488571669726734664943098742,1234389524319480772210519595012254096434562205385972935754568629194134383384,8590188161561261795686801611365857510200794054668578839168287669047410512276,14470989978325106127256991312163042779416463931400090968073878504946069484989,2305522070968512786738458204005001050714630746016184992510479809638463479749,7477355783744938536562522733347415235458953622739577251175967178186753572312,567290291622042941074701939710650764088062581452752653943609540087956251460,20440460641466928749670992266608077799893623138336747959135603955102479614007,3054829023148086310176268593952124817160009906490401089445995945337990758835,1115018683950178281685995685874075286310060333362422341896901389981346771770,7809307874649635295815564328714298840313171873184814252455880392757245438416,16435322760021026161995603943756578712245360106977256514516858926570158830261,15538054347747268689904146479533221617920707373984233068744782064536586402847,2145106610221843472170037420099674539983626911224263405264737836509031499186,10469489855508967606640238771767546316388755621910047798817316247787439887327,19269976274347330455450094587958438145203987980029244301223712026832424496030,9442647357194564700611387347788116150552532746010343621293769302924097756012,3958820742734683830021295040986048520026707752457985546687457778678735761219,11348329600459394107897118896385152488024741286593365288318995787678872184581,7994061748163511046803584801099079098965771882190345699910054751589174660915,17839452077827445141859404251925903822746019560954563061323642101356666431414,13232228834563301156710808377438125900543901439977087615805079133929315161755,21820445178921591403441486524597609508081666751352389500190809234730066099269,16335255581063466649418326314739202718270800342509998411094897137707475468574,7815038267931398026175910302031438514210779836695664391140597883647619726660,6108907775060665614604453427927916450888778767561273091208488690292223394553,18731401306874205485033288380603219954710608893214981010860304692443381676445,9207310842136026530277150017022352541117999932757777916196896007342718304978,4275597059348294910195928059046438407683127030809544814087898068951365707578,8551726143850685533914504884506052366269066663000473253249997846823470852089,17722307737167433007678801800007589919417323324870850217087785924251047414732,9659885913999670803985648240505723928144853579243576606650908903914665975845,4127785260298795455679482228123141201810011802311941172182140342819621401490,7995480315864311476694461046721076190059098585527103653430045699541205743090,2710887853573837837653751249029686223333938865050270571041154550753948687821,10929954836518904033304553904442567770321295457957205208591304372724905918438,14001950425766109615209637768509276336684867788731325954527529665290504740308,13093798171633818149701610236482430519636222108426384974269506295925166461929,341112534319506600537441322030652722098845095671561271148940215817004993097,6110906587902719841743444555887325466851146812889558891609843725163499179004,4611067237252812652698946201052371234192768537459773069641551009583406296376,8813661389433335471770742946393259278020908342551057181562786643750538648664,4082028201221928661179738646263379819458232996637786410627338568216272942842,4387150015663192481675842540873436578480016784260152864928968972841893485475,5798957359608013690581519427700262504660783802132038228115867574470007647157,19722104754281068600204006779633412991974614044671884281702255273995426048636,13237763289640918787304198678609438981723281080085860502804175876747302592942,10350397375768871942356366001436797697061286173475393119069375716517495164748,9716754658986776864790426519095473979615270133917036668138857377100462313944,12559455792963077442707649745319068600669837985026401838048238001273610719876,15691474792343664499590886820783843178573436351948842211318848415073250926238,2315152971409777702150694033027032394728963326020928261979764797562368859984,10145932773746660365948684949555749309408495540108698054181994778319619682499,21031755674184251231918386922772885560228556184297650283520145773416227622020,9656774539408247026483766906298154647226870877463506520381115258572281833777,3703366867036538119931629591865173960052419475390100010069369247148720449735,1155849517605989105668895794996696646805146181003961935923384046079365333956,9462523438649504157500459081869061592673258626587962773726459717365228540892,14558942402093706312345858485376818615887511613771478694966109228129293547963,2812048253376149161843484904554248272181353897695109556171864471465530141300,14581264237688674105789045795632866727938915214983870169917226308316644895751,11806517668379902968824386871470726201210807458248501270142903146174354419162,4072157532402496076820064418241903939352389786658517709744366379045220383162,21813972253527564887362886309776329116642260196272043100875592141144150622785,10464853353887659405357329005361733216328104382848677769669050984745487501147,14772015460668233451710325522019255336227111235340236488781640750731630746977,21527357780259989210243319716428302865642384867695769975035672624351025254966,10891794486798293092627071927690327494090905691269827842959180201330098409394,13485855904336418644657500553650073084861569474830727752625752553358760580285,11448242815253167183767068865945471000243774132210813929164325622036544013989,19410155802742110833632454245227392555968304439001009443806761608484053045554,12167659128474886745250741538637209499739823457162062821474270919941304684088,16680628007927224771777485144832808896272748488695838488671868152342742322186,21298757047923195531118553955836039383942072424271519371368119907422148509278,11697718923718927022148851233178802389523673168156063462791132046990360699116,14786267704709019791824267590492332247783919098705756794174245591027365669638,4029431706248165284072638415134780930697313346853706588481402470852714029894,6637339357364931518321345115064554926275905427738668939829923099637974821930,11721089735875799137502005413616822380279134029969641544449026524015093316862,11258510956066696357188198767462611223354755428568008829233602610737417570759,17382216798452684990847332797566093767764854060615116426813871855967998298795,4497813725838018324398390685637602656336499793658559967801659260213189483769,9309905740467289615895980718346712749846725019185323382202916800724200146653,4554312255934480823406477691403023661425250519363902231000470326223736059080,15877126774677139396238817617140527789790929268045936819000883506734809330678,102909811737053415440204213495606488273727867104784554516589930311835745189,18412616692627375517300170963764173086100899052204830988805458281556342306704,12497849254798953635808071778933029738229621492383212989583296055326390275927,13190130371739872388747884175792586030658495147350847435106581404654633998344,6569505978975360946878354767391913708682729333577071120385232557177773967150,5486573030999616702165020120135398562758060949059349810688840632469582165448,10402649247177704342444720212899468852439313211834653468379224661013914061054,14870393688688048179476829039887867662050219694351765548412705799226912185902,11112866336990864101289111553915677602536611363742637349719791431991672470238,786378775702052024749700197105312354581130448431768994347811552323325137023,12804314666740390639363966758718513558509859637020806917779321368800352250093,16383777838797313001717025761299072170493145903921192845224827276088079299324,18390795790658866542478563024059495583921996400061610405032233720404354578517,19071180375782447479569450482330188708754447860024817674265020413221587566028,7064459298524756483115092315588548572944660746058573142372140457074172044435,1201661337668100759364810191918525473246105501963149603200893010746984240574,14673821426225418930674597108599685172091690120026694257549676255194170791868,8007695637892306475030605880993450528464588921978475145792244443873714795074,11523933430814198704411556653252358930965476928606503642553530463689321317157,4720685254208822524727003349181010163122046826828742211508555904133729568685,2704641256375089357490975523544121554540568505171014265704664461404637160537,17873735287572402838142305036318020439254672746974064930437541429239252592118,15591377870113101853150486245422804312550411754131695747717894157544182932395,18680866424621452161410252746147706712971801673312117262770403991597018010533,351092121232997110902065296627489736041463573095030601146795248738327912247,21410776897919290439576321311168524383878404907590335964810760611175870803022,17236852113726644484641871544732171570702656662638441976539579805457648241354,5141902767347064892821277441749408218256386923351945667768202586451461154007,9061206488410388460545711706154817066096529615910172728152676288649487389209,21501744386281091461333207234319069661329384520296829009605344252699881602491,20523123786355828261901087089746676928050070859811577818342254696196216070331,16340183952833650334331728750144828293293213803155672739442287164371494962264,11997165266626958619141537683193751516111129514708339075256579474097934990898,11727998419969202419125826890516046584560800158309390774599325003825426052070,13931457202894182485995482691171342703522733597260457019434686547274942752168,8889288417892697124945054364222718721845070552969370183001562339292498026982,10607636906736209971474676586549274600168449611294688931553643349980364319662,13373379279879419696628639312899105244563309886546920506727138704477895635504,7516778707927565776230701116353902556324173125006482617300170811322359880287,284142816263687923446544408203711951081978657997111022490562722442340431026,1663629018772009800050577108421747444431944008366135531327269967377988698730,15976560170935104892839671978479711290979780560451333565745657902528940986567,2821894717706045749560970435026664943807315523436547166205412842765540126279,16411046577927712325274395387891881155718376469810123282180259561336053360599,14830500017171075678309056171812981524309710840633235720674153550980163992149,18516862946535092410308127384088576733043708186179828736204273213102857123131,2803122828384011132142130003641446021361083629354222582787564441368260233535,8655048519095208179618171351501333519098495288987579151859877773818991560313,17628029087309631764673769418575149062296127129914718449980855676793923700717,12213182221565572417730092495989703548687597794044608925789870740387528958423,1942254992896992114200957837548346988692238147738540593160350563013662461747,18572481120445885888145197091838633506611989952111678544191205873056195137330,18140911659901689098303870986888083953843757583911874535981587625576530534701,12576912117641358754786901787127955567685279522839676706223096592944048067439,9853587546273100154686512094544697531675085181100931274409412440600306885014,11051022304629047704897656757884328402546597879242426643246383517726104682373,21747178377575326127773834076417831630856635794535286757990250257220185876652,14802894612148412188667842094308733856318572638297904757997514236587913861527,20978447371728675031404263158195920974895558458780873769079890388209356430130,1037699465155917084450585874080268028561047537346921243992399961945112783290,4796870784617170576045350520159043022811420003073563826183620782718648038813,9853767424749529094226213721882427217388134769321854800041359789143412725618,16909978741728448404835572592895383783360498936047937910269991412415349672326,1843438491269241815751499591631260690521017848626075859779071605413804154431,14341379518602865584962107623594010671519157088756134035711400970326861508492,11148607079771922951721552848779822101435560243853139254657574581631328105418,7236118376476006500577604441648338380683405215283131664289729852364085763863,9771089868728917573774866709686459919517030662395798431632764214674312680212,9110797416046523350769719273137039416172041255824880845510758575776777500007,11171998782921300624880315291878283252073139909993544537205045086249176031551,6662646470172779612845827572259867913830316914285246080650610642251248472832,7840073244312824502623215399534211251667887906747521505446844849673459134791,15746172297311038934003440308705797271829102199583540526113736537482577060229,6886137335014489748489631206590121074634704468637741127875111216297167474235,420232306382434242751186173486850411467398307214919587427625546445400284482,6101917029417345450869344197624899835171925047771043819872045680173320199082,20902767593677591005062278004159629853556955206212143592781424915847484793984,5806682782059166443158221425741828463380368530625835045262822570023351074794,8937322067898730475133772449174500828509823386740428196387523130412301822446,10698423376034838319080023911266285836831986186258448454885030311257173631094,3804139705083664873950903601295520892698549383396840546300663481183626370753,11666167980086510761582909817125709232688171970969608229444060852628732414641,5195343484230074513500630640199601466733948553952258905990513870281939709899,14624340714306078897305540751958284706578556105002276099158477226484579202503,10083361130687068583126496521090418135813124339806220406205408201612392141304,18641596433875997766126569678124500204213295416321224520910179376654463020142,2202590858941069122312246576796422760143586439968023643572584733807707875591,5606778593839139538330184356292709713321311150529135965207704575468867770974,11958475164655758519149540613838246197985233378525766327961909142873639847913,9229670488942629146704143920529444712626724835075235979345002293458105678408,16754443145923358894066339463409997111280948017357151500387305969742481068301,2409255870410101963458063337813762581436752424874011147061097403491760442109,2214559337316973031881614971177447231501212859777889339656681156270831720504,11421110362488121690592793129931919017457696830596130693048382951666066696299,3820500999703948691966833683611482557851819710346178343790665741738753374219,8756218158739871072278901807217627680176358846778830959237385752221505342071,8032449730250468861487267430306584116120245106718506069817646852031479757007,10243677923364935391432160448413375676421376200851541463326287529268288890040,1128776597481264636069298358213640667665677523022374620075432951501260575292,5644093261057489381910165706940112111858706948653266534656144218172488885132,10992382177616530304259484530083164550434687278050566643026419033635199094809,14561508845841116001383562169823893923516132174944052932403904968433057227748,21863964650894297432572505174186286520067123468863642727441839125002713095277,20755119936203820147240015392257516486599536773168698212709082762309828651450,16959073226608628398387152299601201172109169744065562346871992262472923761717,1422360831209405989940170583665509252269399522601915800432845527860741426172,17389326678043835536716857792606285368419240597293609647618693076258681847452,12197527885708217940863852882450902665816552534167940448166754267717839462635,21611570070424770005490607477701523898795002037965850794497143400504853790221,11892102040110397810197867975938039639353004723546075702397206087388005784781,13516538003340091563836438322533954338394185445401173280530387106662595790317,12048467357966566407092445451263285920234083860460644072449020638723740218202,1735010081751908190348908571270511873519447755491670766716880879623393561967,1975466263323070433866371621575002630840361531361829342799564009137157551290,14332158763257273099367529977375112575029271371581919959093592722516585473205,18308662877208906527685104306067008785578317983243580533749074382175572194649,16147771244577038318738675557955640363954546932826136022515936117397152662906,12310104474053287506280911462776789511537301762185944649254713583392295220302,20727834941236374148190412755081722896905078541838912474132444343774737989102,4772017368444066833412562265277526529104319024388995968178984274657250179860,21049615822069603562632099674853063708639208121642147875791882100914627258965,17646394174446098039184464463379581654623553955171175600685924254263103033801,20405917523260600357692281918105892289710334792700216851356175227972968907413,1288067623955526969302061242482178260544140652671589048188723078863398511616,10835537730223027316050378066698794099751744792059501849218931290020119106372,20990157274288749983727934109087848093794137769592917583326461140632177148526,16941875865072358419938961334635058647868180482918222959682613586029647175353,9843778843793690986119532637057920745140536160016368781021998854678847780413,5125414792982533413337556654533863770640044560799521974799727390524971858377,10864462495296760172304401051361158670010031482061392973919136670275578530070,18638188379508145413237672170551928898223721010749214505292285199256581752296,128198311352192300389214509562427846527025583978725552204209143056794270869,8639617857907165397429617535993768106671328412853872156360019116822694247239,4844530255382539675437452182943895677920405337347260379412255490567182702620,1804675521808388615789572941859899805904819249465788091888167545049898256219,13789062391664555041422570123657413036572356127853659660401072142070681096201,2984776938673077398183780839702246034953572367406345432704517332443032892459,2992847031807357662780885550148860874749067596604232667894089534007015158636,8223481330716908812358677489080309112433589978061949842348101802357147464280,15829423985005178435297810317464595131483457001231013788201382741845473393508,7862158982782368203916129371016962734683904219117743973675651114828548094092,19398173801438973209233005992391884365223581634877055780725266290648936529417,19275863963890569296158744143112092383404704340976692571347641477470540348192,21372102182460094800056358406250397703306525384763761377034855645794765423371,9476173056510831081934271835896053957562178504127106649888600367232767217909,8945631126280639679924915282277004291625109402912694487894772245410534789081,7926253519938744933656970287399447078338275573508348380139787090085253922642,16018716520675458445608001155996902645263605619338294478505090713237417816972,14921856253793536148329746401088158240205455851010569917169181161371242017185,2079875574141510421000322245042248069972426430967618609676296915817312672160,15980599742048633141868186018745285129739756803812956666022183903444182047036,12114893033109318668956482804227784987572764113979211644064098174620745412136,2810098426330816525728669143855005497849959012191227510766066867001705905451,9142041039259596869436365631928849454803241725030479248178020744616036193428,16789255887716308252460957605463144609726855240455194269099382954389067176728,17736208027338616948877595063010911429975090558603409155923157365536120955065,21150410646727639080649942919157548722144769190804322567561458114897439673110,8728923715723554965990413741235509264041126517176940864777942728557354521757,18877975508697261368601618378333048287851497514619873601021983336084282573042,5857216433172498779920090709564798696432088771454963449283671260189720263346,3416739349758310085403544797458080484340996684307665591910516201053743952382,10014661157797313244292934148350131996657869525790562708237180274791925878615,5349492492153439871560702687440086188179846024931646961141799958661743380684,8090802326500729500530853058367718173141097881651767619458686010109346379147,3243876699925510348842975998823895571182658963945930929780026879935610333017,2417624030466093278001094443901143647464035143208058634414228940495675339286,14707208083442648370683763592077614356382972898797034092783713393639907619177,17545631002841426592730923010822053419499562660641460363423698482744533869073,4421380624161160840991891701912641613710893511150975452841445166075745805974,1077414817249103950943875081715965937853608110732127257676522759590623460183,3507723951294024188735232556852951953031271591466929388169161213367649583178,20744267413157655820488615250021371239675627876287191610069053435816486296093,10030806611757571510773710000844469375387967668887810533790132098599140714696,4098608919187988291739821341638774871917086915024686655297087774191912756808,13453755776490865531134267856063521315028666076529776333450382526888445047611,11760020934758140446049369723964305600159936563536726075225660675360331528465,6406037247037697473727755924858735296546535018055390677906442691851004797953,11557358458236767995494355298696159281191676229524038284238319440638237580594,6743825309135636487078170799646071187521226570701598888088674184356446519660,1363740300261508449387087660891142217813794297057216573859174333622397381039,17353086088993821287882776856791148032337098217763977250246938079060857079815,6718938715458951426350417166499489427024335443629489544367851434423278337209,18987489742261748676564017446964953975327326154943753293417429206546308211028,15965659332352377592570514074534026676650570619443318860049459797446297666148,20815651494112396184410166336624878644932077115689590904142342335838514032225,13289193671002988855733226768851953818541013880219936597636372756289364866355,1567979574094562858336626709833690822884595003609499722973068728155414218656,1406894286237293229723971624858421702390230552459261102967091748375073005174,127524353461789027170460839609791116742773867221485647945877046573898816494,14964917196913210912898635537202273294898388149888129789323384554911752584731,17573975090037837489354042024755208350546900760352759486497415097145199425437,2810800768573675011848063715305835214048305201677436448513685242208560656239,3182831596404920556846849906787256417421227529749874859977287400581732004348,9293221288281284622603029762317683176118521399756060307438914930508616154161,16673727443492180846335195490607282587311771952172084861120865668023189607968,14861970206393540357193848383493197595010751639867769363872113104941368881368,1947459730453714728047065931026988640356317164613412029204943819757651786269,19307336986855330171250472129691969885469727663168817962206758878226019668925,16272723820736869927531258455696258295545428585773733795358621236250129636598,14067203273048816019998838866277520003916774532401938198162316693809632760951,21551507147108044169777874975479534770240991315165807000112720115356653530622,17717640130827927258645965421731152649890280820567693269781156985346197796607,8341245955737785666220035421009659068228682392298228242003714027037157516189,12339617302318828762816142250616108419519769797732290739230041883942137188888,10123566056273217296763559440410478584111931737336670797432668142672222468278,100330409846079023411270961296323123363585075447874304748480232510662674144,1571586856190083814591643193451371280998279878174710717174319810741950319455,17626078717574459956178559042223066518589738318146553446930321898524763562145,12597474837573442277568310997313425097295312228965354157636545560783225415194,9282629691296360927786998265863490172450342562246145699272852196309154676715,11475383910279033220892799115018315595968658540404734297367799982184306742405,21207578382911046461925166339581302823631975619749313031737447832273859578217,9867737209512713742156966231095908977298144995685201344042106615506717185970,5419250263664842635521293741086549956576183663718321466133029062700646217820,10680301618473120824196964202055452643700003562180874183620820959381512387087,11734118782551011491731695279474438578347930162244424307495336916011158044578,15017496989515336959243556328206095618035482039354824183597442359483266217611,6511621188986288868363472995938291798169517601112511039955221592826262879815,1057116630043531259822644333647831844583791045276219751332477616072560117378,19059685203310882657000346272623187407133972415131525465827340360192915270217,658459778905143381055609790895794611242407110015004801647654573954369450993,7603036257465538034144194526422841628761243007297872008772468055256213693455,9990634061622229590998343828576831787715708492431159246049355339866257946620,8811452869339089802509557934124104823648284438116748217266488878838078556311,377338624779519383654026004940027827544698613282452894117899417005371283013,20372432760811032237009833207612531537192479064270437032142982696970398716892,15755624168218886509358985223476988622172061232118179707766784427029774962558,813530157019364022188179508608879306640863329215682533796638454834580544088,15366777101659035236493629475299055460750095122762878608882821037262385854171,9412569363133467481819948072214644683803929543842857451635373713673797937906,7663229432381596357590875498997196481050744300865119408024986926994876708428,2802277205489381760400127515311144092806348374683690687945106801827615715524,10398607437116928120233501860786387490329760704107357815670770315190035281298,7713454417232694103114115606745926964297583014900008700978733395172058088330,13765632281005573885638376819890884715413389187071206345092080625293363780493,8481595129822383153686510359174155430289248263706955785322350737378030164791,19662013748902527903033807785062252860528102610990787703983459073558867314734,9308675917577065974819002737905225232234719968566022906777214056034139366532,4460305046275724592205653945612957908431797179457871442468403547092050276501,15300682822970503133550740797435695997154332692415846288727432330759835456273,12237959719178772655779639362705631668446778143915144512652426042298606318280,9074337685905972785113091085216241647906400276520026931456332814507320753649,5631451392609103370493346239448329080866515797549576094657011047227839672541,2121343968626452536232091590081231792044261748288461026059952209827486505534,13428337287072393077290174792209446111049614088462784414150825648173933048712,7637923455564736402006004688931010233604652911202725935144306827988683195798,14145144407093909228652602933032447693975357132368479264731012546112843610158,12996083206893173697199261663271430611160188106624571072102983887472126762111,1731425456500536573020772566007405873501250425959888611809221924317821607399,7235256019731839713165664289644294928953374624035695945735560280325779220974,21068041929715170328271489788020516757451181357080748023363808822374772951544,2613269578304019608168678260820703130619030694547890166073793773931717299431,2895580764674798551230549071717806800560472156999393716124982187189744328131,18080627279556321451131957341924578248984242962783250736655220087867816491510,8541787229490752355605354050088489559660583814306921152210039891158051673167,4773003619955976464416147076099271361363813479523212833233541104584120420092,3902657294907605469046100206491238707374466860318674919042657295835038516976,3278680356861257827773728996810819308957995332730291009303523122858553038927,15799387696541061708257049935405397874115977721965461912710489016029411671536,772127417921361022785917422978769290675101599783616547948775836973315286693,21172675246800560416431972802840350117631380023487771635657330436402785697771,18058055216124783386618232874069776997923635894599900180049394490069349321671,6486774126469831729812548493701084245613732338682698890925717889323571075377,15523424894706974280109344562353257665535312014690869100282355992032362528753,1155165761749577539253357611425533199963683430668786603835581376097524220748,12293270303409235416382105881403663503297523019464344830582632347870203818941,3805029697086536368150132668072389131584837710357108954351676850002928826418,10383737378445903520223858424352769490012472500810730319338019642336472424460,19139905240360031959084644666653677709382597275601060683474709422388012451876,20662040367334915413974593999171397527205617639639561319218396170856657836909,20693045501044506792047932972050932132614012706885392044610670760209701329210,7646436833143149025181986338139180317049527836176583246163126009131421429218,18468267029773286403821867293367277456399346317458918979624725373649687804739,3368837325920673645463134045719391515049969019513957645401010913338888270435,11009184090818836540140614853735105475441340244881441725231380311734117124613,16438249098211375676141540117467319174575385934122099955146653152842543524308,1978426318655034633621003481179913733408584009919893346861360079137199026039,10835870076129494328875329193612835430557328436367520958854318265497818180707,9238585128656275231406470048000584932169168279280345637986485301554767537943,9860408784513424998732752702463731273076404557148376009384338221275998841902,6200534253629734756957567067039457925613934220422888818001227120423772581272,17839095320044387599555680620747734440255270476109368494374200849742690805825,15852210333828297391427169949742706715097259872699655846272917384634556986629,13333830495117301018203298033441593118871576320662915411592512406905971557482,20141868252044007123768212581882815770873248742867175012988635705853879924105,19536412434762756561256835516560484981006774488160067264157868466806483409550,13376474825075395326396381198361278687546895119831914117080307993251668968861,5426793384935877497416931155195289044246814775306615779818726668069304816143,7377826504693724659923090551901604172560455391003832805477022207542742841455,15304023433512090811722731808458537014494291201252876199903945357536893662723,21332460757344630529450409218029849205820804076582364819572498755186176235236,10123770219692666599208924625777509883271312561577690589112346574716432563379,19563297971101084260099820862783813929179580711197283960855071977068075400435,4447207254069026895839688542596519844298864167018271339727580848327164733569,10805247891957676953966507705079087855877568284903068495618773980630496028625,15247455859749071900237435930523136345408272002648820316650110622790580875976,1523513713815340967949299977561986680730112913862622151113511170812079722460,2250092345142769832690429177076582432571233932766644284160212961505086786198,5502205194489637815685308301009607192191278776537698439488907603617260091996,12376110094727246736838305034851207905481280418572145688559541407100489476563,10967543165217223191795950135818653456591208931427429972754586323384063916713,3007127915385490247377746617881910295130312971235615226220093403044166435816,15039810425747682043693978030807314591772830040893968588297240388685740832440,21282434502237090849892927101680045504469095017581606642683944529102929897154,17820554077495649709432871866725766383400924076526622095222498536082233385393,3238921346058569633798159055732162989904755716515207404910193961449538091755,6963065779232897395043653410311694992252845745677523471496668662716409139923,12741150889158293058202855298380167280366511627706735086836055155215291856874,8505231440570036863755136868680092759740858472921139738784962359970555463386,16263867309272856871859017360735124501630350380225439505739588230939592341511,11994652030543012675378700484156120788799454178056174639173766735729691200407,7531001745062176388176369578077819605743320864253593427909699809569190244306,11827863847264026226445842677102655786795007713756694062525124054010199531855,16129429107591815909860445595042156146087129962390514833959473605760944146527,7516787161495467824155321560594800913116855117833255279107222188682607365695,10052162714097814491117037623656731155747350728656529965818461926126557689689,15866126693591846474201863966897712396582450897559972801925967203045783070614,1769345590280238074854062499047542732649300047644326060581629862863392048630,6419881722518831944067972549598430355215508824227908646199374367237336336567,8427762909619307952658968866443552584787988597438819510120993141703552873807,7893311334904009120458996652611823451343891633360441850908461624396886564456,19760139770663625588230394835227131962944058142185140281511805786245566094372,3986819882418057034478817109485859706183862449050678809809350743539886112292,19462740190201175689471975116541495793256811137828607475310915853573746549315,4950984269438746319161544135494005780273536398471035822969257463380210776783,5114126436371649572151778297196722433397981560175541938915777654399517384867,6500502433233986724406965295441070598123907669991330544723786166137230830713,16317287950659298477752416750967064455139776512193467637272228586615836234506,14644311768591599882243015624322844079095287900058309581805861693953854143586,5280400910054229241086158902425292691428494311972092134978890627089874392610,15127218399002910266114392708998449241113801821878209170134753716497261629315,2711401246560501813405727886361637939228317090729002412066290100904319360960,1913027325164607464956755298437679573731669261937548387089448543475389709293,19048913840687946111515885036078245399510860136071611921573959765837451269059,21295287720552550910280526966903203926240851680963634134437049744624969307301,3797109693086078196558789257647252246485873371501397666934942661912968057995,17220092189283987679009565165189257352830222471797888201205665583060198133070,15728859045813610297052814756440978974533041326711446421367132340721185641530,7915246674314292718027357038683169057328569313936589479968179748005116348962,3168535062320575750000050980968432832479836571078965478747377498891053785750,13803986818738311305292789973880566948405947108749390476554600214529398575121,2887021549045614886550633658248390500136948561362661868354602793719521054017,9835777853770722919097370759265493857673816349027354889969484370501195735082,9162920843634529872148328448437467777954760966007230180656824492469148201817,1074954035830520777949184022573483523978030205622574039670230048399504082838,14573949395382273725648387764764104587706358354270169802238874779976052312087,392719645589691148855449884443988672799862378880367658864925364810308158541,3685551641667332817505970777889874263257498648047179005679069858878239338060,21636266924388678043670779518381645484139129597308274177295703055588816929542,7321567536895702720774368439707249290671186165402244403568878177007380798611,7172839196695686167303608986523055739039297465612557351529643226329584487820,4229778574282653726990227569322645489471840372440828936529243607112035640074,18782302953492985194605877986375464862209789031757664619583780308051670003641,11974809482173143458078984920442199204778548823433238304966088658895546634996,16243115558222486864600123441049281534776025041710213515085053285162975382052,20774412501254836125508172987964523733402936236671082985700605339729723682856,1483065919525318072073144044234229344901017930590205131905224416619628808251,13859608645215082985012618178187462696738961393768893322969190913266642570277,21405376459105682082984005097612235541120033931778677874212817450507078023807,11689238963312530686999514700594656275688886785400717773550428094425955677451,13770805346049970815658755939543097628223982878203541747699103196190562329538,13464128750778834946158208517080192694313764854534278881787962107045396572111,21407849640224904790247752730042846775377573219483807581870525715728151019912,17742435015936027530371893290930447550842976399042348699434701387859868436168,21607472280994630036571403820711131618277491312399185275464826427174795496015,7688464458545967396781600592854525549649369419708847302997939388491317131965,4387376978957625118504779199367262576455322502411234315349687321331690532595,18931911591990162605728772083755015441650830148575725789586998382906047952930,14640568984073443762298448827081280142493018130989596534711086636304928257387,13306842042380077440486698326492089142513016713060879132515526658677539077869,16831808713587057769987931635351931409992316524094756901264732606403438287007,11322415449116068033081427912158622347193126836157199640557951056169543153666,6851604032522439802523441319645962614365864202922586227207366934548805743971,7865033453112245503939716349145002950003125074081779764874079104952011815860,7859039670086457402270651853161690366745490673814388503748678622683637617076,12915205729177842184089675224634811499690953326168778547490092950902372657871,20937773388247481346344394224147944853257697507105144044681818248765914256516,13287060897761790924722969858390853273555324655965292728828260759103061260482,13306896346810583848301553492224587956204219709116827141735317644044595737290,18219814232296473414944129594782177430971511097498319923644038792152844524438,5428298390273304248312869576101694361963883992477060046151268450358678474516,15201216935560530575994837331432805679558316705524948725894686934721622162910,9185979018761703837993382762881735970994413889163208925197647077666234876915,19181785293325954761013200262201782189994371972312628530578184844339518606203,16637687071791710254394571978230957592057586799407792249481371375691006025241,7540695380854477789623159801158526233798259867148336812702557598270412992232,21033749924623312349444484016552328468392604073844480133610758629121621931608,9900738449713019488539657454744856913719757496206137183076543026413680378482,20521005306019974539700555774138941983710853964949502636832851583991666071090,9148625417956423696904186924742393962087070575705980963607554918018064302410,21162567363216498523188025354796572574708404245885103426215436531517848841283,516078530341213545969683556809078278712251743628535410360059529914040404316,16846240853341179628895683480146570801780199580812523539736983428470139888117,3725063466997152760713869763783030250548722164672702170123853642540240150907,15613553480222544404649584760559934580548305353382956847869893563076098726977,20351109682633578989341194704546173168875553988784930480177729322649037322556,11996883326331293630396983616262966081550223706386102455796773922602029237495,7467763103586466278784854382537524995001493410600869109792768087664508057830,2017508073008218056990628353468704346479637577205333604607959225275229259220,1314798328573144515884513072855778523099366140621231925682355151505185465849,8723657373526005784062072282873485835867170661363188128978957400998918352651,17008566456391889354408264184115222893038736754092176958021304795161250142258,1277201481182954066723110290486484624236238076832533331201564897838632505678,2883326282329572573598657327001707359250291449257261775578634065330832194673,4435817386812736743435792142021329255563452933485604716406076651024269234049,12698961373404268899870565736817085990987024732021219796534551825706597317720],
-        [1954546571818731885139861264947334230782822161673023234242993080695489129982,11606713580838194823093847718802359011098299538034455148401855555744041817997,21778217939341959600865514937973379081571132553754734185669152755967486158807,11867012199835162777599593543744285374463489953452947402200134749407575327780,20668200962959535110219664454556867828577715202494491079283962871771719016091,6796938349934826085352626361055311106987991567096993611616805270698773290279,15108030096316731537404525399718062561401239877230837132486990179727134215091,18618583058942935584876943765894457772128324732451762769633954204661267055617,7446958258820445329937058505234183740111199633995331064868799738609505041620,11019126795578266009911151080068316016022306110283709712693862589215772062237,17644961526468872013219663511656737898249108220341985100127433673616476030536,4959721361611533340499147366149623398780635086479466110353420780375692399477,18273613083607267201259595982191169247452947601227995394305633285537292365096,17816466502776842735116945485728134149282831962573761460376746436502757322332,7013781340485780306773324480395548266877763825891494701746512901494705653158,7793291197073594006386853421213450159077336220644997691715731402410704643042,3426005025972529257284910903433598760993095858232060658495826014698591260944,18530832095369567225742997294004908129637537286260217494648426754251364141983,16489909564793485793960504581924093693287639849995832883358263301067754354184,15126602449686250365534081130480301443166072957206187316416707568927051456663,13994979972845996867477162556668014834350043400046615820474382058282820089898,17892071176071030024436108339592708638442586845389229765280031864359446154887,7094246519433675669226318744483462997736245331529142696208838903133391196837,19739600791550679646703071148379836779124671330492407813260108679076122705926,16577895124793812992345966235533166228538388644746952252700985971901794098608,2190990407832635064016354900528055762572032133913345251583721394536626731922,10838969594099257399038118686024400001327577210604256394537002295046250661365,13742554186879139633322968994905507641568437399912823098239782636831322642395,10281113667801091149613944447670705624056560574926411753502305328318932013688,7661208680673970050246952651218127022141152720979640414729369551173790735959,14369836811580283035547554195559038793886958236571577920508487931208924192768,20603628573396476191496332378884772502350107937108583985752646932901407759112,19296916296835469264085474516279583782033370007674993417080564950885860980156,10983867448590555143664432588641225682254935452824608025544914671100236945380,5670198946055747149234813634846142209283829958947146164536023332201358566553,4904816432035963931263837796941455228547544800276020247096183162764093041386,928528370618860212551901809222389226336726628142306562102221490519648216649,8727385187994811157471310113729025912812882704232858255495018737569420129281,19909768217191699902186248006262494556099457367519802119733085801884256380544,10635786582281955931244778086998962127059196955758207056871772748744817883737,7140512340052162441606422433836236465795273624186668144911701254961330905493,16598081311443832517669265039250197623929992506944409626575335140315057620768,2339664320384903939910962081546057089170206846484766939921698239663651706239,425509623704802982425483674266195224640999670982140442030650575449074971057,7922384239142329258156226873732902413897900318612725000714450267548570680404,8178140403014386057685967488315772252114289881535707170540858306748328725322,12689293740944871195190670877158259851710828253354810002997981152414697198513,13670630626216376948528966598720909229691593992164633421606526176324419533442,20189490101967313329851160663874367593390331759675962821030507426149184002493,18209972608416650990264895614325602746017028678399567737887116829945804399280,20353660437114078502000672122042327871511027701339587880609263231648053792209,367135858451744056025051491593060073950844607000402056456474235270560576836,13355850760886700974133527239382497141869096511168824351814359808886023658462,7206193356029734986150290058613471641978817208643432940709861990432648635433,7885684183122679587266799938650213096329650494585142531776846669540995068168,19085115218990181267812208821832153255121894513890241319104580206329327134131,16305675470941528258170184941405206862153955794946952667798249341324791515500,15443626257895746936982356461453477742473783071787883800166168668037169561924,101832047855527584987088220264952346019960111874606050409415217845556024488,10576438072746903138917852030571732352003417543540340689583487864994727144138,5996861730264922256270512962050361669936822432104376503237345294243995854540,14877973900502178557219336745361213333854789301797456671201806787562463919326,14807962843542542498914061591358875654692300327506360640837865566998761281322,3133673265931719924452668737189159279894652423873815799856403146721022028744,2314426743898183021393131908284299082806555710249089245305873178073379019830,15353836455896084897563929713128028858175788390437902641700134508986437653318,5529981971838869469294842442312128910934708838384001405870007618574232226406,21863108219378799978996648633069571801923287451100447450849597846874069699478,6773528450923012634292634195479655092490402578779439394568805920957004744133,12150245180431051120309675366247495517352377611113958096501103925281912163211,11142442323884902255425165263749428309435092933107089893872191462936441527962,7030165611221942623542847326918501014233687676615371955108018311000952911338,14168907664945894221515023422776939138433274836712427741726190314020662482321,17973846874050037633502661848899122581090847479984048542694367819419188584711,6612448947387099268202244798863603173886774177350810153571814261011002084641,20765273984039816245168454930434370234220284726385931011063596091927027011108,12525833775624943075128880966259784896817535866921245846013552547690890352574,18082141488353658073882233625595393585704703572017716887747923068948432979709,12080205172928213829055364897249628749790838461826174687455161036760925324146,10426041417079669712788047630796875947997831039494087898318197116078426849054,18333367395418670733687742418586004501344157225223371831515062599898496336393,10666844346085567030848134043176991777319226647942683934134661343455999941894,20287202184725945519955164847740850432153598475156573942705745729215691030796,17942851314410450183054332374663618442963349517519641485232231950262698445043,17672277011389568686180232934337352157780343745417630591806280730146798908966,17416106918062278234521335281965623696779795380548750331807903068461573518054,15034390385078628923681181367678507353936042776187855843799428131823528700439,15016371809918204032764565101078018512566551812562861502095795302834732872947,8176229788878503959342848267153225222150151339952249831413185552792554528595,14202549166569309182319866775579092322766621157492056208423752359103429675445,6628758202046565882882491271332141326521031973243028104017889062740759748530,20267845326067450413789379016153439637066264448919236391605812427944953078755,2438946774028723892708023594952994993532105735189593503088246493623252811398,5327774123437518227973303235331602588839413198088244869937007412210139714640,16416517260868931624699960600760845305546648577328049221217547593071007584547,21691457642736313179352706050711464825492028639914839210493298427277168769684,17369736170805089474636304643282290719726533149056710536120639858255935606857,19460761623902421883797374762298555710671254062576987287084819867262496770119,19770570144034267396127078712986043464609355920552337517533085194608634179666,20904722049832148410244764905538463264520496768863784169293376826852051688706,6086931305514615639236334006857789100145606465861722355610937306339550862,5885641636117295888159072068000551173102681944020015073964039109891861226751,2197549059218467728366947205357858398035068309306368786367182781869500529089,18571065033075196607590252486530861399537536653506142751073877421696969841444,8754088881400442345643534933850221698544089985357770542959718766123813634810,13673463077059539437815915980077307152850526782227553623693374041649724049605,827897346385894242944663854685785871137033256170575635435612086616249561082,3256718342276213157296321691616951565542440296040693556287210483669841487973,18851058760089844863118102177423730353882359970674430675542303019981882750705,21009037983427297652279654800570889577926790955118786173230430780907667982896,19370673591737489444054265538393258291592098201577177240415593550679982651270,9712794467513451079466753095103777002587307366322848872714822737566534970868,2452976395290300719873209484043914405675637974162415011707015440506646332236,13967023770779438454858978860214792451127045212657472381516830319420403024355,18974770134907327058718913691556562240688992993972407935785848010954975834526,18005343276101020422248769804338953747590444642920980587346957205121649916277,5364199751574723768938730543610903684616886041855996090009230701935892264768,16915141432748433783158989990154900013143930156431056052460984382677436665679,9810457740455050658326943855759399108575402539560713791636000764640385927272,15711844859260073612371012979328688796642677336582424352155989490394966892994,2523486975208775388230636032695576725855997180931786065064150527465407276212,12939257203114853364537111886847673104871159136302860798643783368852456402126,18563343508729873190283517746040347988882591986176993103658794343898711153424,9139767925154848725661711816797304370425590863714334419686930754659416933343,15630326979358561783620795846763021145439701823262337294600523076394775855291,16709031855693747432049197217266634836607267701623669179857743766059308291076,11081746589259753124653594380015131650915622160245647873370327872758282529429,10263829532434991046602117509549967441368717347217075372460446855507340910410,923380097607272775621985864770232207712801803675470117823528453022294342573,7060362012752050086965449046391069479205357779670943566418766734533864254186,4238871118210220589598309748597547342336859622832314796736348778105851398663,17520061366255155846404852213753339526277619564174678951991892080505590972066,10513625869281904114245087023227471195681135249236672625281292889978751612829,8435396899666453466602702234562279601174578748121165208762270334814881381944,8088078454252433245088686773582075061475116946251984942060002979516553775360,2719987334353537600366656327639544587227927648913835976421439609622334518069,1024019320641379568207362641296952564452568447918936948059464814762366331275,13889412498086825909291896540147715217051215696137185869382874120375855480535,16901630530096437974516169843541514517956751790577876352535912471650304576719,10977539500432168331426791033212854950231005312634634920276038346698892818211,3226460659346175003896135924099734866664778523605375090881255390738403665617,9695421696482260394078309163365413177132015345359377667904366174083251929056,11269053203885423427900382169641426379373759430258387104391167619152696936070,5178750298399029508026924620615685679610392082191932524033828050686124044833,12845878982355860044505488053971997443594073436267126888909625977253125523142,7530981388399357124357431126610695946065175975095472306777796169245607001944,14058213441446348117716607452759269076404820355922112411973297063005877380478,825603012201903073682942337154197674883919500964784037574585377691889312422,10236993586198323123785803013039327931978354285685191819502917433935835639701,9438970111160688934509448828104684236155844660381402912193342504181825365420,11536612122721678319037657954738688943272460041908847457419482683492719528721,4048128893355211133472225346691072554088570917135573376272009214966234274059,17007960555125781716346334106074020327440615260084049810189285619997415816473,2935744638594795881476272405224480626548498961519135317809162650064622710267,6384493312721061401062408865799313573644091862395937725107886310975229942194,10507848115923740198082149097677194763453026968238422206438345199258995348681,18755782391252715265425541321566381935042481942506333926799033963914433188574,1622030934879728521636669415221999170954870898240640125007128754133416241951,19178897048453000979590659690957596324038669245300140765620928017217201486492,7668471074291870526245483897884601792626426080083647233981123797699500787980,17022938204221917796509718984925895198444138607270396412440297468084153383727,10938747411001421463106680010228586254730710894241856448408311145676137003709,1892143994611253681927160695719312882099525827316460372080933907151205825399,2626413664304179483436880400231214693597358131317388676910101259191110264005,10976814250018194880310517382191223839713741375476951941358522267556104616194,3267603976137604608815546917515683877598008503122930381370588099122094818035,18223585230504941070194267966378685287221743128395324427323638965512681791787,4055897021092860484143383650117982675609656498724344612791022670810747280835,18652001434191198724037217430343155151673545332667032591923572773249520166995,1179210983342192637294098069949454912191992256395734070923896011947222260627,4403412539347069757548448548289536146089860634393235869990028179479631393017,18208249577016536190404023195559477353692681610041814639755282640930299265764,5253459060178003600605009461295776576191151024266914967218417406063967602725,2110599375707753504956307604156004992055199034205281989577749327575131764193,16838175205667561737978735977781331049290662487428014461885404122880770700959,6473428079010461623647807107937762759737150259352991014918746820779470984847,8337370031139132243770630686523670334344396638842630818638144451253681713442,5852133535345551978469538570221409138541345120679970583582105205614182914641,7693908046708935218171096369565374697059710647347392990894755587360287791527,6754690467826351700887172852005234976131445583530162984365436173814346372178,4362899351088205531982963806583486557201252717995038448293398829823910923472,11518397041006514564038599401506526387562942749501723393674197214904315107893,20606341697536003623317613291213380804130123512962185582210369767659416485838,16897394754877405156789353426985842311670174197348619627467370676352261158652,11049995264887964858828368499123384474282091734658191426291499678845498016770,18903841016151023909305743424460730902070062204415137089939274033985227379247,14501632343069777665672565757138143573066425682965558756989443143462299059377,11936194426294671569251421865691095594275214629276606276242590758676139955663,8684782852463301178275527204056308121145836348455196441596832143888384190591,13840275015334112173632265864573045139112521216777064496416258170300441524371,8976112149735004651499648151657522459186187854485087924493254571044062238478,2557541446593153253492913007582627823644717754910327615163106890559828872362,17214289010670114093415697072867115184169717632618753776383803280726887828982,9277044732799923560347274951803854995664839245943597020159605756847120319168,8665104485244718969383349524127237156930430459852710098382428996861193438718,2966017993337369327831105148290320997881600321998609267125699685969931023637,20703140915572601301330743722461592884427012015286406537986295678495182028439,12415056396133226456247587270673507158810318408454307171336801889305959276558,14096884501745579659192341381525893498221351476730589189812251926483574089240,11380799045102603249740262962085086862746282867943901718244205293076495402152,11397463999860523006350413477163951990037313029979805067679629038011006323456,3989254560279764593104713297200294887781503399600736805260233256187721580128,12670526207690537332382598355517632246478654103765566238996179271593311461311,3183711571356392622250181639411196710255078687860623143026450897732409025180,5610846600257417510307213084599977483933519996901968341741797171439650039141,3280606490416179974005759319341626407586508917823138878220428529454629673364,1201982324417186063031536229293952219287079604094432487446300310977814955299,5320694228353869326806779260357179675523748849691821041819016623807887766991,1117900147109997141002482710095589298468009897854242933473562031850755107739,3423874914270570048663861326353594445564054387733265522218157141041404209456,15544724812507000325032356684034497915485954044805225704411638706645864153677,5773122431233952373926318394008190376724448498619094117536291976195311877322,6101823265492636176451963193766486622777300610881276372298697176417958756135,15795396300010870823125638802470599845845464744307444307899702370966825169519,1323789030194931509684647858838729962688902410898850967128356366290242773839,5751046064881673173633677922158261597917572500845688735304279201507132509829,1621252171583823353515150633750260236914561977816101468910968069661001399932,12193773521417435700759146251386454694422997324768376620870510312596267301181,6582582178277044206368630428791785430498389945338461249283089656681050213384,14215781677876725356925186332463972498447213260700771466349787162195918816425,5782842445406193701766362226063474843566378485612132749823957396025995938674,5452153017648783662501027666999013472879951066118424395570738985848450672673,54899108049022846277426184613878330780751769989719315816516065174629128493,8847320923102214377720246218239804718366581789144394009065472718259977212062,7818599458828105010909362503034203380908251186730393621503231459166558068065]
+        [
+            0x148d9e4542066b125da6d69ff3fb676ebd27e6a38a1ff4281bd639c97af6ffd5,
+            0xb60a28805324295fcaf51bb88d9692372cbf4eef1cba8b85cbc059346691a88,
+            0x2d38f812ad1d7ac79c32fdd57a56edb861885f20fa4bc6d0d942c2f41e8e4a7d,
+            0x25738acd1163580033367fd8f1ee199d7eb3c37891e06bc20e6b476a0357588b,
+            0x247f6967fca42689ae8e20b5a7a198d63086549b78c1620a51f5d36824ccf43d,
+            0x2e22813077a668b2b75249b8d515a3dcd93502006694245bb087ff0732708b93,
+            0x1523ea89be61be47e1c36b0e024068c28c48da74bf7069ab2d77389c83d474f4,
+            0x146695ce138230e087b53ef1bf81601f2591dd344a7cb509f138939369e0d1c3,
+            0x12d05d9571fa4b4171886d9c2cd44c7d7fc5a4125195e7d28c3c47cb5cb5b7c5,
+            0x242721147084d4613543788977111f3fde6c89326a556e35bccd2a2e73cac68b,
+            0xfd921ba8395a5dde833e6dba4173385007b38d1af5e3841a345c9a480c9d292,
+            0xf0bbdc7a39e5146929f2e1ca9fb4a63550cea8f12109c1d82e601975d581f5d,
+            0xd65008588b2ee1a4dee0313b6d4396952d901385f2e1afe6a0a0def765dc2,
+            0xaea567be31e1c42ce33f589d903363a482f21c1c3d8fe50fa6df018a2dc7c25,
+            0x2fa334757b03dec6be1df758ebe0353317b35316ecfc72934d069f182346bbd,
+            0x2180dd9f972b1eb5e8819a843d24f650e8257e7a8ccf6eef3fa3d744b16f073a,
+            0x1787a3fd66cb49328100d3574d7070199a6bb88b84df6e9b44afce9798233c4f,
+            0xfbf506b6714d64dc8623fc0cf426f918053ae81e5847d3367ae7df02293da8,
+            0x14f57bdb3ddc75b65eb0720e27daa09412b30ecf7b115e8162b9e55faf49f5bd,
+            0xdab0bef8d2d1adc80dcca581e1891ed800bbf4153eed15ce71ee5e0b0bf940a,
+            0x25f6be3a9c5f2a6ff32087b2caa01b3a1b7909811f025196f156319239d359ac,
+            0x25b541b96923b17550e137a4a5bc0d544d00c5da7715c6f00bdffb9bc56d0dc7,
+            0x2b4ad0860f8c3c432f2a037b0e2f7da7a4a5b3601044ba24a56b5b9a3dbda40e,
+            0x7d5817bd123f90a4a3c2d77528fd9366321d8dc69988458cc425581c9643af3,
+            0x13fda3b1d02a53b106c4ba4652cd90f466b97acfd136c9a8431f1dce531aa443,
+            0x2450fd6b1a17be1ec4638786bd3fca4cca4cd871268eb07b1e5aeeade36fcb44,
+            0x1c0753ebf63794a29dfd83eb0d0e76f6d1ead583f72f64c0be39aef9e577a0a1,
+            0xf110dc007ad810c0fae508899bed20aa5cc8dc3d8324f0f7bbc3995119daf8c,
+            0x30623c2f24a7c6ab307f0e88488a009922fc2b8235fc741526a4d3e6a59228af,
+            0x1d895817e78f2f1f18e53130a6ed8bd6e1d189543380f691a969483f0ae3148c,
+            0x3abf174d2075102797f61660105cf418ded1fab324bae35d136b17a0254c01d,
+            0x237478172f073d15dba9d12cae6433ee71521ac294b54d78eace7dc941b2f82e,
+            0x180f820a7408dee73a72ac02f7dcc75f99a2b9f75a9aab82377d373eddca712d,
+            0x2a5ebba744ea7a6e8210f483f0b6b61c1feecaa867c8c11aea0488b822772614,
+            0x2282d8326c3c12e0f7575e1acc4bd941893732e1e7d3c0bcddd35e366edd5f7e,
+            0xeb67d8e687cb2cba01552ecfd4fd7ffc3d5788cb47aa3887a1f2ec3beeb08f3,
+            0x176f406cc04bbcc4bbb82c56e4ec20bceea588f1bef8fd757e1e58d47545b77f,
+            0x1c4d0cec6c8b22be0f1a3e9e32705a8a221d887ea0bee1bea1a8226608905658,
+            0x1e35dec79f5a579a42f82c45b1a191147bcc4e3fd02f45af412eddae08db4ad9,
+            0x75c4a33b1289f7923abb46d7a684eeda712004f974ef5715f4e2b504397e9bf,
+            0x2f416c15f901818152911089ce2a96018e79a8fb7f311c4c6a4d9ee9f7d8a83e,
+            0x7a92367d210292658449ef3d46ec96b982c3448053bffc8d27b17a643f43979,
+            0x168799e51ef2e7c7b435a220052e06295f6c08b1e6b0b5122aba31e2d953e44f,
+            0x2c422cb4040ce223ae9c21dd7331896b68704c26a8f4ddc877bd0659e75c8c48,
+            0x29966fed42c09b35591edb4cac0574441dfcfd4f52bf0cc31b2e624b7eac280a,
+            0x26ddc145a94457eaf0283876d4ea7d6bf10b7827bf3a684afb10fac1d172894e,
+            0x13a8a30590a2c5d476f60d9e9ea7a4c1783a5fea077af03299b8c389641bf4c2,
+            0x21d12e7122c437251656760882eef8f3168c237646f3a58a51c265d8b45184f6,
+            0x271a6257306b4337cceea57039d404e1996058c68e71d63ce1329810af2da4ee,
+            0x1980478607e68ab7961860e38dc78da21f2e453f89acdf82ea62ad9295d8f625,
+            0x260653cfe0ebc0562b54b9599ba00669da343a3cb3a14c64f86149d8510df8aa,
+            0x2c4fd7be2751f8b6129d997351088081e60585ff012498424b526483f8372f98,
+            0x640c9db6f458697dfe17610b0692908cc7f72c1c0bf5cff33168c4867c22a0e,
+            0x925e62b7772164055008f8765b827f251b006f2dd2370535df1a16e872b923c,
+            0xaf4d8cd74eaebbf7a29bceedd1dcf0ab0d00f8de6442bb8626e7f04b043f40e,
+            0xcf6a34e2cd376d6b000d8b0a5ed004e7cfcad8987f3650095f4d9740afda335,
+            0x1e75dc69b7b94f915b925a773280b9b3a2341ab9069eb87c883ac87da102d9e7,
+            0x26bd58259c27facfca63e248ab6a130ea9893b53928f3d373a0a197c5c2737e6,
+            0x1511b6c19aef08f6e79cbc7282cf4b5d3eb07aad10b9f5d65e005e5433db1130,
+            0x26d816f8378615ea31b08673baef673c5151c036a5a34ff11cc0ceaffe4ad982,
+            0x1c38d60817c3a646a15d82ede53a8ef821ffbeb2b16c8feabd6fa7ed02e65c2a,
+            0x2ab192357923d1198143414d448648ba1f60a917f4806bbc2a4ad3b2617ecbc7,
+            0x2920a902ac2c11523c9425ea2fcf9cf430b6e27c0ae9f587dc9bbbeb96536352,
+            0xd4e9bfdc6f8dc1a6ee5aba8e5f9f67ef3b83a526012953a99c83edb0ae1994b,
+            0x295bf676ef95ef309c1d3f8dedef57582ec317807a72ec10674adcd1b79a1717,
+            0x232180e854fede1a3359dc8f1a5e14c3ae7b5186fbb1a3f6a6fd9f5252351812,
+            0x2405a43f35d247ffb75de7586ba2287f9b057bb321bd9ce9bed8c89807d67979,
+            0x18931b27ff3a9e92903717b2eedae0dfdf33e9cb5f0fb10a35bfa8f3badbcdc2,
+            0x1fd6e10af1b3189d42548c7ccb93749c4146adf3997b8d377c095445d90af092,
+            0xc4772ff9abefc798f553554cc392284b2a8ac4b043708c183f18bdf6d69be41,
+            0x227fd4734e7471641aacf664825d3b15ee10d0283c2dc35364c9b167ccecaad7,
+            0x132faeaa250b60ef57f7e0ae17f1799fc9530ba5e6f2baadaf01b089595df9df,
+            0x1fe24af9ab6246e0c85104cc31ba59175c60b155647623f893718608efa2047e,
+            0x2f376b18215290f25c3fb987cc89569a3f18ac443fff16989678e205871becb2,
+            0x2f2fc0ee912aa02875b096e48336411eeeca6f3de85152f51038ca291bc0cb18,
+            0x2cad38124d882410c386b4eb1445ffe1c73f7b789a273a9cd266bc232e4c68b0,
+            0x52002de9c04553df4716c46a80102ed453be8d5bfd9b2f0ec7c1d3002a7e7b2,
+            0x302d680ad3444e026b06cd6e4bf62cf7df234ff9e5a46c48c17c2937507cfccb,
+            0x2b3a9dccd38768197abc3b4cb640ab3c01206f49add14d1d705c371c7f705afe,
+            0x96a6e47d4345707b5c25e86c8a690268f5e831e6df4d864e1f3fa90f2d8537c,
+            0x2e2b005a0a54d0fefacdc8c153e84f5cbb50ebca105fa0f0242343fc4893783c,
+            0x11c8ac2a7f796c7852e23e76cdb576cdf35bdaba6918f90cbfe7aa2265554a95,
+            0x2c2e66451aadb830f1c91d8554f2e39e4ee19b15709052851f481629bbf12b91,
+            0xdb078c9e2f68eb7d8f869554da434b9576f186dd943b1f586b9be61a172f960,
+            0x79328f87f73198430e17dcd7613bf651afdc86b514295f7c238d2f267618abd,
+            0x57924e8f3e798044d6591af796b74ce96bfeb676de3313eb50e0810136b8b09,
+            0x1730b8bb9dd03d8326981225e8e51fb9237e4c03fbdde5f0ee12004339b6b9a5,
+            0xd121b54def21112d91a5bc9fed5249f5dfbde7c63bf2aa63d14cb59b0dccefb,
+            0x13924c1b5bbe6d5c01944d682370c13cfdfd90f17b55f07b05860713ba9457bf,
+            0x1cfaf7ae08968c76279003598eb1f7eb6b76ca3efbaa873f21e3e0ebaa637ce2,
+            0x20908d07c87e65c8c66ae29d2ef20f8b8049e304a818e769a3c3c63ee4eee0d2,
+            0xd225f408959d91768201fdc03575a68e7a855939852c02cf64e3348fb383d42,
+            0x112785d72b09b749a03120b3ed7cf793a99ce5710afd2f07d1eeb39974f03340,
+            0x2dc01fd745f8ec43d61a5b355b459750010ec7e6b4a13acdcca627d7f6f6babf,
+            0x16f35ad4dc8075f6c173b9588be33839ad67fa5883783b0ae6f0601de726afa4,
+            0x1bbc143e6c93e6741dae37037285fa42ef8dae0d6fe3728b9e92e79ea566b277,
+            0xdf7e17da597a37884ec03429b49764d9e8cda46fd656a122f8c61d9123d4aba,
+            0xd73b0c0a745dd49bcddd632d4e41f57b39c28db722520c24cb3d9ced0d8ab33,
+            0x263f950c95141a28873f4ecc0d18c82b89f60e7042cb3e9f128cfc5f03e38580,
+            0x195e19715160d996ce7464f95db19bec2c71c02faba0f2c6c5ce0ad748fd3d3c,
+            0x1cee7204151b6a47ab8ceffea244d1928621fe2661b5c095d1cc24c1a6579693,
+            0x29d7696ce5bb66f2bea6d55ccec4dbd464298d8018135f734d115430cc82c42d,
+            0x26c47c18b71c8e81dd025369e12e24ccdfcec6cab974c0f86da98deedeacedc9,
+            0xfac9631760c0b7f0824bf81492797db8cb3f5e4918040c4af17a4c042b116e0,
+            0x7e7ea789ab2f31184f5a93820b08a4f6bddf02fe83f7c42a6af69a6328de863,
+            0x20eb37fc65efcf8d87ab26c7cbd24ce2b597e7d9a73fb6f2b9db3e0775534bc0,
+            0x20f4028b63bdfeba4e2dad61f4232d2a584560aeb71bdc2f6c3929a7600d64aa,
+            0x60e204b7c08f1784b366a37a86d0d8d90c386989cd167fcfabc8c2741aef9cd,
+            0x408cadd2b0c8fc39ccbe8366e16edee16ef6fcb00bca0b843681ed56a6784f,
+            0x1722aea32703f506f24c5551e3b591dd24fc4ab9d188c149fd1b75e7b90dd353,
+            0x2b056ea316811928d984e2796d56842e444501dbaa8cdcb546af5de36364f4e3,
+            0x276f12a02aa48133e660f6e93ceecfa60a529dbb444a4553824b981e3396d169,
+            0x1199c8941c5f8f8ed0cb67c02c5e014364ad7f708222ef17e82378e4c155a8cb,
+            0x28a3d2a547967bbd877ebb18ed238e91706b259a1723c1e345de5b545b8a943f,
+            0x244dde50ec65e0e66cc3bc269ca9689e25a89c5269a4b7fd5137e9ab6b7b1be3,
+            0x18dd271a54f6e5ac3aa02025470b4612c9044be00c51b80e347938a528fa9d70,
+            0x218e424622d7d41f3362cf743106e890d8d2108695e25d279a2e88beba3db8a2,
+            0x1f05c5f5041b178a54143a02e8850a9e94625955af047d9e658e7cde580fcd4c,
+            0x191da8c6357930716bc0fc614b80b71ea6b2540d14bcbfcf251086764f3f6e7f,
+            0xd54bfbbf8a8cf7c99b0aa8e6a688b964e50e68f2de8ce26038e155ac0632fdc,
+            0x22e1e8bb2d7d1216a9814ff5454f064d67a9c56e4bebf7700cfa1b651decf8ef,
+            0x1f0fa78dc7e2300fa36abd2a40c858fc10ae1455bc43695d121c187a26dfe7c3,
+            0x151c8de5c4d6b41254130c6977f790f13b73f6fe786f47d32d6a0e098dc8ca10,
+            0x191451e550240b9f0f15a5f0ebbb360ea9b98c6730e1097fdf6b7b8028266433,
+            0x88c58a21c4ac05f1169de675c2c543cdd22bc1dd06c42fcc4eb890bf0e518c6,
+            0x1e431a01a34cf72247817b3c5684f042878c6d8f67ebeddd047773744bccdcf3,
+            0x8a6ad0a360a0f2558f78abb268a4c7dce19ccecf989a34ad2abbcea4f50986e,
+            0x2fa7d3a514d879b93b93049fe276e60716c547d4f290126c15e8b666224acfa3,
+            0x2f352d9675da8d7c81494e015133a5b8b4c62020898be4468de2fd81a4c2cef8,
+            0xf6ebe0388d424da0c79ac329f4b571cc3fd8d5bae54d596e6382da769c4fa6b,
+            0x1fe4cb5bb70a9da24e0f598396e434beba5ed2e9ad539951dc93a38c37fe3fb6,
+            0x29f316d8c7f3c8e7929d30849ba99edf66e61a2d414e6960081d0114f45c07bf,
+            0x4febefaae3e20b5358213eef06d52c7b7817a4e5bd8db4902d2ffde8868564e,
+            0x4d6b864cd130aef3a066bace271902047aa0564eb05701efaf55d1f218eecb2,
+            0x159747ffd019c389e54acb68074802edf33332662d5dbbba9b67a3c21dbed46c,
+            0x2116bfbf5067716afcba7419b07b3315f0ee9c8ddb034a6e6b5fd2e78793ef3b,
+            0x2ba76cc7a25af15695fadb8fd7d436d91635eb3f251b2b46dc317c8f5060c4c4,
+            0x238465fd273e538d938139210520a07f2ce3bdf50e381959486dbfd4dd0b35c,
+            0x5c340a5328ed50d2b10d24af11e763ccf9d30906e5bfdc2a0f23fa8f23edecf,
+            0x279ab61cfe4f25485cea4bb3491598d816d5734e391bd1a3edcbbfee0da1c6ba,
+            0x76e2fbd39d4fab2ad6de8d53e70194771528f4ca4018fc56c68b85f041568d3,
+            0x75cf8404428a1a38f04accf51f5ea6a7f7d7cf66ee412149c23bf4c4e61fad2,
+            0x1b45baff5397fea5757900b2499c0aa66447e5e6372253457b9d2472dfc8622b,
+            0x1a39fbeff40b73bbfff7232c26d92db4afe3286cff840d193b4256a66432b09c,
+            0x1a4d4e0e68afaa99c0890c322d58e46ebfdfc24808688b64fd23ddef4e70c7f0,
+            0x24d619da14e5505a0466ebd24a766f2af1fcc6fe2dc4bb58440f618d8c57a7ab,
+            0x274442dd02cb4d494bb38c28a42fc02494ab3eae56e115cb3c65ae4aa728716b,
+            0x26a9f2469481a594f9b546553c12df66c0fdd4b4637370cbe695cab374f5f115,
+            0x19b6db087b1cc1c4b765e70274236d981d5b022a6cf0d3aabd478eda2f895894,
+            0x231b94b5e1f8eda3405c1a9a05024fbb79f8722847c8c4dba6af33b0b5e8d072,
+            0x276a571b8b2cf637ae48734c01c30a91890729cb137862d09b0dee2f255c5681,
+            0x63d0dc1ce85c55433a780bc6ac9fa8bf4511ce6c37a121b6712cd8905787751,
+            0x1b5766499bbbe4410e990a078a5ee8d6ad5c4ba9d0468a056c10e0df4f3af63c,
+            0x121b65097837a750d24e9dca2ca61b8ef80e1ef478c3d4f1cbff64d4256da110,
+            0x155bdd180e1446723320311ebf6ce1668158921dec0c5d9496888eef28fa8396,
+            0x2c8541d4945a6610c164b4a4546b2f3b9bbf6dc9316b5658927b635d8bab8589,
+            0x34a08d31b52da90215ae00874307d421ea20c786605ae7fc87d0be172b8c3c4,
+            0x12552fe7124ee6d20886a7268d73a94850f06a600448641df55b08e7933077c7,
+            0x2d19c9d4694d594c5382702070e7057a9f0c7f7bb2ab83ff684810de0e2106cd,
+            0x20a7d7794bdbe939ba166d34ae843e1d84eb4632122b7fca26f4e341b0e28b29,
+            0x225c213c0a3c9addf32f0c5bdb33fd6957691135d84757b4c44eeba59469e561,
+            0x2eb542a5c77f34c674c1df077e89408f5481f4133e3ba62a4b449cf64f9b2537,
+            0x303a003af9c1e54d9d3189920396d0c752c9affe1c17e3fdbaf67b3811fec7ec,
+            0x2c42a27e94cb62ffb6c169979d09f39387a9e9f9b6e9df71c9ff4165a8ed5673,
+            0xae6ba5ef2e7dd64e3f24af20271927e95859827e9a9d32aa247de70c5af9835,
+            0x4c58d44d2b14455273dda0c92739446ed59599cee1a505d0cb3631118845410,
+            0x2a5c4931de9f553fe4e020755d8b5c10c12ebc234ddd501d6f45b1b2058373f0,
+            0x2fd94eb892152b5ac3b73e6061f3a4f952198f3c330e150d4f44c933e6c8fb38,
+            0x1b5395c281e1bd5763201cd1c72a3b5db71a99ffcfcf7db793704c0bb4d53c94,
+            0x26d18b9ffcf39ae62f03177f4639f37f569b80500e0bb4553466d67b46342b82,
+            0x2c4eb768a6db2db295d215ba0f81dcdcd77e0e34bc123791c03ee7d391812b38,
+            0xc2e3f65db73f4058ec7c6cc3c3ee5c49550dc106c35929f0bd2d04590309313,
+            0x28f15a4dfe1c74ae128ab27ca3208dffd9313d4e87a759136eee3e194cc925de,
+            0x11ecc3e8d929c5be84af974cce44aa80bc74a16f13e9b9627f705e3929fd2119,
+            0x239d451ea3e39517351019674cbc2a84c6a7add8fa6080371768859e9a89f275,
+            0x2a2a9313720b4adb8e4f5795c3224053b31bf2d6016d9096e56cb87f01f81124,
+            0xc0089ad49e3644745a0e3596312b34ba6c0faaf19e362bcb56f4a7974c6db74,
+            0x2ee82c31a946f5d71be03b9a041596afe624c9c6a6c4907a8be5dd274c3d1524,
+            0x1ae0e9d39c6100a8ded3e7ecc34988b75c5338dc936c91c6f1d95c405c07bbbe,
+            0x1f11f75c7d0ac841001b3123c045526e98c203d1a6caa18d635f2f2bfa735738
+        ],
+        [
+            [
+                0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+                0x113ad8b46c3eec20c9965b5a7b2e8a51529871d0401b4de6f63de9e5211623e2,
+                0x1fc50a16dbdfa1c3b99038f47f81a1c5d1ef6e7b221d4ccca6e821220130e000,
+                0x1214a9d6d7288fe85651a8cb83048c7669c83b5ed82ca2642fff01e852a44b4a,
+                0xd421a7c25af5538788f49475836712af5da156f88c5867568cd958e305026cc,
+                0x2de8ba83d2b6ab6a711fb9230adee1cba46de8c930c86d266acb8c1cb9684e24,
+                0xea7be82f1cb493b1bbd83ab7ca285bf0a1559ea05c3f59827b3b013d0a91fb2,
+                0x1e3ae7e5775d352651d713ebdfcebf9ca8e905cfb792bf7874239450f914c8c5,
+                0x5943e3618a32cf050018a4e2375f4d027b8c14ac82a0de57cbb90c5122a64b4,
+                0x603755180f66e98215d61e5346b116cc00cfd058274d7d969b3af95e78bb335,
+                0x19817db66fdb8215ecf70476c4044c3f41d78ac5a549c684e35845947dca0b11,
+                0x73965f7a9ba8cb33a955d42da55fd7c37a3f0226b029d36dcb3fbea95d642f3,
+                0x9a550431430846b6694125b5642b00607f36a1a29485361a3cf427da77eccd0,
+                0x68eb4e9d6e0a588b61a6ad501f380da0f009067666c0853d156e33d59c43515,
+                0x225e00a0da5a7f7496b70d0923a7cf7ff332bff06958cc0f3fad439874f6024d
+            ],
+            [
+                0x19a92ac6087ab89982fe5650e5e799f91003fd8b45400748d2c25e40f04c578d,
+                0x7930cd5256f8ab77ab92b08bbb5b195a44a2382c66e27514619efb94e649110,
+                0x2d8d3d924f2897199e38eafbc7e101d17d7e563488a9f3198060796ae84c1b08,
+                0x1c0de2bfeafce164c9838067a8df6340f9d97edf0122333159b714f45c3f13b1,
+                0x20e4a28303dd55e5cee332f30eebafbd7932e7b3531d942454c344b8b8c17cde,
+                0x1bb15ee4d492a8e2cf1b10db1b738c6780066ea8347abe536357a723f6cf57be,
+                0x2ccf31a572412bb7d9cfa637707853217e7db5550b1cc30a894cdf483a3b63e3,
+                0x1d492c34b245bc12941bb163c5118bfcf85bc4f344042b2031ed8662a1f6ffa,
+                0x1c9b5c2c07fccfd9dc6b3abfe05675fc997eb7b8cbd8d8b4cb7e671615b0ecce,
+                0x243930ba01dfd3945f2aa02d588922b47c1bef2ff8023a849b4ca66a1bfe98b,
+                0x8f328e5e66c0b879b36c233f598bd8578d18e2da9f019f0411731524f42d90b,
+                0x284a2f083ee32a6663081c800713e0f2395e348dcecc89fc81aa75a5db2ba12b,
+                0x19772e83816fc2c49b96427c6ad0573347fa49a5df691252592aebc390055a35,
+                0x2dc5900039d4c8523ac379945cb9b58a54e01dbacd67f0c4baee85d353d3fe97,
+                0xcc378b44e58f668b45832fdab4a49372731ef2415c37f40b5ded5594aef3cca
+            ],
+            [
+                0x302608d750f16491df5a285f5f7f6a5ce6b554f5dacf0b69d450b24bbb4967d7,
+                0x28f8144bdae1b904ead70b3b72c7943037de6b48490efd3177783594edd28b9f,
+                0x2aa9aae62cdb852490c650ff9e27c9b33d4cd4020ca66f5e1a6b374e662935bc,
+                0x1e394d80067f0e10baa95de0d99b4e39204a18727d1401b476ec976b5f173a82,
+                0x20bd028c958d57b79e35218fe34e469ebdaa8e8e714e918d58191f65046b972a,
+                0x27fa2120431379cbd86205ff114f34dd2dbce13e1c2a0a8e46a1dc27e7b686fd,
+                0x564651bc1179170e3c97afbc4f493617017b43b213eeed86b9b1bffe521fe86,
+                0x7333cbd0ff13c8ade1febe72892d9ad435c7b451aa72a8c05a7082395882865,
+                0x290a7ae732f4754e0cb91923c9248971932607be2e829163f11612ff8a955b10,
+                0x1eb520feac62e4545f4fe7cdb675e36474b8b1fd19e15d7c73a2b1dfbb23fed7,
+                0x259a2a1f046844724cf992aedc2635f6680f55e8a0fdac695ecd05fbc2cbbd19,
+                0x8f78e6dc59cd4694c41abbca086569a9083ca8cc800bd9134e4d48ed9d89dc3,
+                0x2d8ec6adad3a646843c88cda01285f8f32d29c6b1025cb5421422bf8bdba7fce,
+                0x1b72ac4374e95b7b7d28cd2909507f3006e8352d4af19e47b0b909682a03200e,
+                0xd7d8273de237ba2d4d5e8051c5bd5e312d298b6726ffbd3af7e732af91dff27
+            ],
+            [
+                0x1a3c7daa6b4af5662d0d8407b287674d83eae5b7563405f48def49981c98c424,
+                0x2474f543d1f2f33b5ef3fbb190651135a59390c8a3661fae2df1d3f14432b608,
+                0x1848a60efc89965073b95773f467666687e38d59be208e8377d31903921057e4,
+                0x2ca2d8b0a793d90ed318cdb5f697193137155bcfb942d82bef558be5fab359bd,
+                0x6ed98a185bb2358f334eb257ae5e3183599c054c1b4e2022569b8368da1abc8,
+                0x1ab527614a37c2ffb00c0fad360abaa447ac1063fb9fc656d0148cdce2d7c372,
+                0xbc769cd7b34fcd1b454abff0c00b89b540a619b87c95444679c3ac6be84d450,
+                0x29ad5236ffbb598a2f8d238703608db7a497a7453ef9d579fbf05be38f8f76f1,
+                0x1434ece209d491280c5ae05d7e26cf92d99bb7289a5c1cac09a38ce53b6e03df,
+                0x255dfbdf30553413a1f8f5113d60e98583838d13e11c1ee02b25a387ea00cccf,
+                0x67d9294b4072b12c368c2816a53bb16b7e7e2a79979a416f2d02af862abedfb,
+                0x293ca8a06c5f179d938065ea47f80f65ff21969a9429e400aa177ecf6b6ae853,
+                0x255b96258dc8e1644f1bcaecee773632f25a6ea803cd32a1e01f82573775f6fc,
+                0x1f2a8dcafe79fd0ea22bb1563c3b28b23c5c4d7591d45e06744b3b379d426618,
+                0x22ebe0a315e07be4b0928885f52449b011b3967e519e438c424cc0428c35726f
+            ],
+            [
+                0x2db1c9855ac29acc679367dbf70f08d98894077df2411f91ef68dd90177c1e9b,
+                0x21715a84742c02d057ac41f743b166da023228425681950edfaff8581201a097,
+                0xc893808103549d2030cbfe0004ea6655e24ee71a1f8c1f072d5cf6e17ae2499,
+                0x28427ab007a68c7ab12371f13bd7dba0acf7e97ea6e64ae52d5219210fe8a2b0,
+                0x51deb4b234890e31f5ac8e69a1e532453774ae93a9e9360fe009ed377ae9c36,
+                0x170cee2983fa3d3ecef2f806f40eed8d8e135ceff076fc530bbfee876c9e7f1e,
+                0x244b6b63f8041a5975f4640b18c7d067e4a0627f18751dc906016b8893c35123,
+                0x2e72b1b114dfee7e8d7f0161255c6895fa786070ce62d806c45a22d7d98a0a30,
+                0x228e7399b0e05802852bdd5d5e09966f03c4c3aff53c683eb2f69e0fcc21c0bb,
+                0x18451132581b9adf996c6cae15b92d2e4c09fdc7d6c27b4426f32b5e66a0b723,
+                0xe1d7ec2a54b11b36e65d7551e9a875a88ccc7a6c0470e7c26e199670a0859b2,
+                0x29b68e652deac818824da0c2a11b408d7a839a2e8576c55bfa5f1335ffc5b93,
+                0x186e1360041193e12f38099b0e35e767affc3410f6a8dfce9bc75567e39bc402,
+                0x19294dd22da673470377d671fabdf42cecd37ecbc018386a438706d6106b04a8,
+                0x2ed3cf0214f444d436655e03af8aee2b4d96961eea06e8133bd6e8d3e38234f
+            ],
+            [
+                0xf06ee47558f182d810bbcb214a25da7f70a567a0464b348e1b30eca7de99d27,
+                0x1ef0e0c1f0b5f67644c486fecf02238cb7f4fa63a082a3c030daddce65a4b82a,
+                0xad80718c6e9d1c67b4a37b9e103db32f225fe42a9ba655ff065618b87b82aea,
+                0x2cffc378d2cec76ba7080b37fc671a96328bcdfc4630fcc2f2133dcf29c70dd1,
+                0x21f1f6a630471e32a8b9ac4b7ed4b04c56b96a71ee20a66a5458c6b8d5c6d346,
+                0x288851770f1a13822251da91c84e123593fae1c9cbce6c4ff2317e70bb658209,
+                0x2ff4ee110ee1be62e2715dcd119c95b95413376e88ec3ddc3f06fc9db8c27a94,
+                0x2ad369a84b57f7455ba31064001ca7779d2b4b96b0b4a91f156abec366aab786,
+                0x24f0fa154fcc6d6459d6c56f711f25e38d57e90be7b8046c9e001815edb41404,
+                0x7221cad39d9b5f8db705a8723038b92b6baf87284131735eafbecd533dda6d1,
+                0x173b3b349ee888d934aee9c14e889cd7d785d1e3e4f1eb72a5c2e56c48fd54c9,
+                0x9bc3e40bfe5f616fbd520f3894a0fdd37feb29429fd3a5015953171de3a70f9,
+                0x29cb31e1afef4f252578aabd76f23a1320aac90d4a0a66c2225e3d94cc48d22f,
+                0x1932bc6bb488b736e0d4bf306d41e622e66c1d685aa4598153054b40f75c0b00,
+                0xcb6fa0a5e11b9192a51904939d45a05af8055bdea3f379faac29d1309830e85
+            ],
+            [
+                0x2166d78d948dafa963381cf1560d00bf3a0a1c288a743344c8643a58daf8cbb3,
+                0x278e8dac8c56b28a23dba4d90fba91eb947f5092d4a7a9ec7802f61778488e87,
+                0x20d87476f1243f490246f88736ee5fd6d33191f0561271487e9693fcfd7a649,
+                0xcfcaa1d7d382e1fe1fcb950e14df202a08793d7185255b025d562eb8d97544,
+                0xc39dbdf6e6d24a91a0a45f922c894be252baa127d9ac76909f86dc0bcc68a66,
+                0x1795384e91bafa554dedf5156cd799e11210ffd2afe817b5c63ad5b85e7fdd06,
+                0x2666ec1a67daa7beb057aa0e6e8a10396601a21884372369c012b49aaf849049,
+                0x15793f31caea39de315dc5bf5a3662ad5d8e1a12fa1a7280f2efaadafa97adf4,
+                0x18800bda17a89832fea54f26741d86c6b6fb9e15b02e7bd065533cb5661d2a95,
+                0x156f6a09e6a81d8eecf4dbf21646bb968b2406786cd1dedd4cc732b7532f7fe0,
+                0x2977658a10de6e7921ab9e34bcf07bbca61a72549ae57d0c15691bd143d4d2de,
+                0x284181093e43419789263736e544817111fdcb559a43773f05186608acc542e4,
+                0x200fa20ed1b871313900c01f8b697760d030d8cc0150fdc58e04a0d8a2b344b1,
+                0x8d1d68b8437bc980aa7c59d83393b162a0827de74070d2d34b4eaedc17e7e60,
+                0x39598a1443c009678602b8dd3474f276da5d62425083ec628a1737e8cca3e7c
+            ],
+            [
+                0x2929be9bfe3f93cd34fceae665d96b1de1afb26bcaeea2f4edc454c50cbc4401,
+                0xfaf33843e6733437e98995e6f7bfa6feefa73d7410d8585918c347f3cfe92a5,
+                0x134b86642ff202388f4fe37356ca4f0ec3805566b7d4d412d8937a359ef9b401,
+                0x1d8724c5e641d96f6e372771b0a776bb742fd3c08e1ae250432246cd3bd01bde,
+                0x305614aacdfd4167cd1bfdd8fcdece6892d84d4a65e86e6f7c6349fb75e48b96,
+                0x2cda26473cfdcd185ba28cfdaa15e7de2359646a0287ebe8b60d702df009010c,
+                0x2b0666971fd911529e70ef918d019f44b5c9d77442b6d1866f6e76832d478847,
+                0x56c55df543a8d4043a12f409cd2c4bcf43a770f3e38c3fc79ad214b42da834c,
+                0x16b11f24502aa4cc3b0c2562a18a24ab8f986431b244034d3fc29555402b5f4a,
+                0x18ea0ede9010c7bf0fac361b5b8e7f97c75ed93a13a7ad4a017d920c03c98686,
+                0x396097733de5a1fa4a548749b73ff7c426f98d9e5ad16920614d337897f6b1f,
+                0xb9d5a3a957eef251ae9c26e53423f9be6f2efc24bb18756893a9d80e56a0825,
+                0x1a63a589d1710aa705136cb520c2f1c44d778e490c212d4b72e9f1538e5555cf,
+                0x1c0343816b8cecba48519b59b0fb6d4a9bad309ee38311dc3e8cfe8bad75dfbf,
+                0x1af56e6575123f99c5d7ab7b83770f0fd60fb9f4038c2942644069e3c243793d
+            ],
+            [
+                0x1076d439c67997c37c6c1fda9a37dc2f762dd577946f36fcfdccd7898ec67cd4,
+                0x2ba437d6ae6c588c6b71506c8b508347e634b65cee317af1fbb9cc2a997fc006,
+                0x2c04878b4cb8156e9983d11574ed99dc7562d3fbb1878257abbc68852fdd2680,
+                0xfee8f9731397974100834649ee87a27ac92be7a3810303460141aafb542a429,
+                0xef9ae65eb922605d4260ab2021dfbb4774cd5ffaedc1b79dc681208be6f85c5,
+                0x27ab4b40901465ef59007114ecf1fbfab6157c24f402246b86a60397267308f3,
+                0x2bb5bf03cef933e4ee87f511de3985cff0323ab7b718d4cbca3f429addbf3052,
+                0x1ee10e28c612d9d6ee72f1274850c3e829be5c06f5bb293280152a5610eb01e3,
+                0x20a9d575fea891302b106439ab03a8a951d8b2ef2b562991946eb2541f1fbad,
+                0xb73119c98d25eb6de14246b1401bef485c9dc6accedc23494b9526a39d53221,
+                0x2a66defcf489c23eec5079a0ece1c5341027a59e7c592e760184b826d70dba9c,
+                0x4aa8e91dc30f9ca318fe24718fe595871f7897e92d57f2d87d4b1bcf9a635e1,
+                0x133369b3bcc73ee793e869360cd50d8df60fe398ed9d9c0d0d03e669f796e87f,
+                0x709eab96cc6255f2ae917914f25085025490c423284916e23b608638ccce29c,
+                0xe8d9c0707dc5bf80a2f08c343c69cc659def86630af3141a003acb3d3e90c08
+            ],
+            [
+                0x185c9ad0da87cf824624d02bec3ba4665822a0f6b3b25deff3afcc687ce1321d,
+                0x24a6c1919f94aba9db98a5af38feaa5391cda79f9debfaf118670d7927e41db0,
+                0x1783a45215805ade9d359232120b183db54b43f9a7e8fb8dcd95ba9bbabbba59,
+                0x116f239abe820737b5e1e82b2ace3a45cefac489a6bff084e323036f54277108,
+                0x1adccb898e5fe18b5c29a4708c4b112b56d0fa5d299b5edc07d6f5bc00428b8b,
+                0x27122781df7bb05f6ae9e14e8e99da5c23dc77cc06108c0ebb061e5d1be93626,
+                0x2e37a7440e75b649a0799cffeb7f9dae38fadfc7cab6c5585e4a84f437729d02,
+                0x29f356dcec3b79523c0589a7046ef0758486828b212146c3f5ce987af3fd719e,
+                0xf9c05f609ad14debeaff107b95accd60e62662259905105abfafa9e8e08eaea,
+                0x1c66828552cac1443334ed70b7fd7fb525f907ab64479d117864c92e911986c6,
+                0x10f43368c0567f405aa6aafcf367e3e68beff957c4b0cba17c30c62b3f95490c,
+                0x253a11c66463a6dcafd8399fca58ba27febbc307d8833c666e0d8df072c5f69f,
+                0x1e99516c240d42bcaaad9c73f21a46193db8433349203035eea30398f9df7893,
+                0xc67a06b33cf73882b1c7152d4585b78223d85c77cddc2c7d3594824c5016565,
+                0x1f6dd8e85d3597bb6d37b47a1f063122014c888250b38cf8e82e3e5471ef84a9
+            ],
+            [
+                0x2702b1be39e91044fb73926c1104719f4c037aa4151823ceab24f0cec49f4648,
+                0x4d80e7ef7e27a2b1397678ac42abcc6e2662c880503e4643fdfbace67273b92,
+                0xfc96302e8662de23cc5c8c228ac8ac2dcdbfc488a59f4dd41e3f27095f7e195,
+                0x2a31cadb918d78b96dcd548b394425a42e2aa7a28a6b63e509261bfae6fa25b3,
+                0x18a2661c03ab9b0d8f7d01091c7e563efc033196747e34139d3f5cc7ac001e9a,
+                0x26812acd03db3412cad4bba1aef71bd44b0094d318ace0366c79e729ff0eb2e6,
+                0x371f0d49346df2d88b9f1ada8ac99dd8125cfa6c30f3738fb9932a853268e,
+                0x27cea9c43fe0bf1ce9e53c0c026e839d80a7d869136603102cddf63cdf28b975,
+                0x95f1db43c827e6f0b9cd4fe929e7b8c78c93fd02ec9e0f10992feb753b4ca07,
+                0x10a66268dd9a2f368e95507efc2085eeeee8ce977ca1eff5b2e3d94bc342ff58,
+                0x25a2a43ee612663dbd61814f2deb06ed005a7414f99825f8be66f542f95a7b2f,
+                0xe4fd498778c2c76a02d0d91d8f89825856e706f598337dfebbf3ca33397968f,
+                0x13d84ca7f358aaffb1ee8ebae81c32e01adc01e90d09c9451af36e31af82170e,
+                0x740c1e9b8ed16e9fae204369c554cfb72007dccfd2530f2e34d544003ae5994,
+                0xcc8f90bab68e6de84845da1899bfc52440bdddb940b208301ae94a95777cb72
+            ],
+            [
+                0xaf71a51cd463b9faeda93803cdc03186c7781845252fdf4e0155709d93dd375,
+                0x17f6a3aedb0005a9b0a258e31b8e6e2a48f3f9551cef6812a49075aebb8785f5,
+                0x24b22e5ce671ce79dff8de16d7cd2bd6375d7ecaa016ecf59cfeb246dac80720,
+                0x240caf6d7ab2f7b6ab3d15efcf3074f5b2142a1e804f25012d988454809e096c,
+                0xf8aeec74144d00a3ca38bff10bb0f3a8dbff4af6197847db879745aeb57b5ea,
+                0x213d29d4e1b6c01fc0d109ea6169490076d131d8e034b3040f7bd9c3c373ea17,
+                0xd0327b593042de04f58e0ff93386d1608d33a86872c1d3e7e089120aac7a4ff,
+                0xbdc078b1edd9cb1fd2c2a01a97bdf7d458648439fac1f28509b41a2dc9e7740,
+                0x26bc00d9cd25124442832d97abd90866d3fa7a401bf38bd95fa7ad526548fea2,
+                0x1f14aab5a59ad452cf692b123c65873dd80ffc188798a4570eca792b3f2f257e,
+                0x182f1c93c6eb29867b1559c58207a6aeaf40b66eaaf579ca6bd7ca40aaeb7abd,
+                0x126ec8c200262c45d1133bf9da5f1e5fd62bcea1e493a080af1bd283ab86f122,
+                0x5a78464a4b6bbca6e96d839827bfddbaa9d924840aef6555de643df167d4caa,
+                0x2a84c424eb58f9c38b4380af38e0458468980988faa1f0d4c6e723845678523,
+                0xc0dcf2b13552ec55c97166be347ca2f93b07e2a10164096d353fa280c796821
+            ],
+            [
+                0x28667f9c7332073e293c80b98edffae01af4f67b4c52ab45e49db8b30f182d28,
+                0x1e62029129492c8bdf8514945950681361591a9f5eedc2449e5f229c85bb97db,
+                0x52c33fce08d4a39fd805156c8affb84349428ba4920cfd2e7902ddcf9b0557f,
+                0x2224c85f0c0b4093014db1e817d1ff16918f15e0cd231b848a48cf83324c4144,
+                0x1f53514a97e8b57204e57bd6b1b1d9555f3b50368154154e67c2134fd3151591,
+                0x2132f71ac89892c984a0a73653f2d45222ada34181a9e6dbcea0d63961f934f3,
+                0x4dbc4c8de708e59aa4b2116e53944bec97ed42309b4a184561d8f32d291f9c1,
+                0x2565a17a6bc56e87b0b63664319b8a47bf662c1f49e2ec9251be4fdf33d90f4f,
+                0x173e80596756cd9aee04bd6dd9dc15e4b8ebbfefe3771d9819bd4d444726f79d,
+                0x1d34655b5776e24701621acb41324cacb50165e019bff1e65f98304f7d822a6,
+                0x42eea616d905025147a482eb436a3b75535c9869b76d6cdace118e15c91fb77,
+                0xcf030b10a1b4291e576ebabb39c583fea0fa6decfa98cff7a96dc06cb77da51,
+                0x260ef13ac7e80fd2db3de9eb942edeef3f5e252d4c04508b1e1b130191ad0df6,
+                0xbc367fd93ceacb599c614aa28068783a5d27eec1fc8fa1765015b76dd82f5cf,
+                0x1f126117a949dff900fa5d111a0ce2661bd9d5444577c491a9951cfb58192d
+            ],
+            [
+                0x2763c33f5b2d7bc3a23040afbcdaf998bb13254c272a5f8635a12606a59c2e5c,
+                0x16bae774867656e64fc95f3c249f801f150fd7ee28d195bad9eae43743875278,
+                0xf0d475225c99702bba4fd01276102b5cabff7bd4d147c0e3cdee4c07ac31b1,
+                0x39a288951a0381e3aaf598ef132853b5d694716c20db87923f0bcf14c914a8,
+                0x27bcd639c47482d2dc8b6d13da19fb8d63f3d6c875f6fea486da6ff2ee11e107,
+                0x121395023931f6bb3ef28b6063eb7a2ed7839e083fdb92c1e5593c83edff5f53,
+                0x290ed9ae7479f9be13af13f98bf88507e6fdf018710e4859fd2e48cc66ff9b24,
+                0x15b085b5eb678f8cedf21bfb30e2d64ae1cbdd7472449ed24e6034101c658868,
+                0x12a643f4a327acd2454514dd469551e36ab0e3f24ecc3b28a76dc1f38214fe38,
+                0x16a1eedbbea79c5411a639e3bf0e90f6e3f740f141599af8e6a43a2069572f95,
+                0x5ce7f592dca2148e198554fd64db8c479f29d23f1f16daf3cb8930d9456e4c5,
+                0x110298fe7f2bcfdac0bcdc3affeeb436d7b3a377453ae778fabd37a9acb299a7,
+                0x14829f09d4beebbe6fc30545047243fb3dab99c62aab7364a7a5b427457a02c0,
+                0x278b58503e0b9014104f8c446bed4c6de575c72d4dd9db3d1866846979aab9b,
+                0x138f67fbd9cb91ef5206d48cabb269ac42bd352cf371e43311bccad89acc509e
+            ],
+            [
+                0xf81a8d8e08758e8a32aa8292666c4cb6ba3f5f06c4dcf4fc502ff97f03a85a6,
+                0x10f0172799be23a8fc3f156adfb6c512ba415e35167b563bf7b186fd12a41e57,
+                0x1183e91b7ab7372f157d4c477691eeaffc9e8863fb2d806570c67f4b1858fc54,
+                0x17620d438499f6c0a66bb577add4cadd66ad39e3377d302bf83d3bba126b2aca,
+                0xe9e8373114ad25af97d28e272fc42d8490373cab582193b874a10428ee6cd21,
+                0x1f665ba33da4ab9d9806caff77ced39c9be254fcc4c5da8f570096111fb109b5,
+                0x135aa38339bd927dd5064e4d572df55811b226bab54b0acaee511d60aedb02fa,
+                0x22bc96cbe7f8cbca81b29ba7df848dd6599035ff515b6d485550842e1a35a1c2,
+                0x11e1b0af7f5fc9f049877154ae173a1a72c7bc3ba192e438a9d0fa81fdfa4900,
+                0x14de448becba6ca0adb21b07455d2c2864c7b85382267026e28f0978822d65ac,
+                0x1844a81d4fab57aedbb4c4628e2e47fcb2922883eab0b2e1de16f248de4bb902,
+                0xeef04f24ae210ee0a94bc5621574783e49d4d93365a2b3dd069fafd43055452,
+                0x1328467c87ba73028921a89333bab97f8b24fcaa72f43837cbcfe5dfb7a945fe,
+                0x791d832e976b66bdaaff450731ff35d998595ab9748f695bb45d2c0fef06930,
+                0x11492ba406435f35623906ff45df11c39efb59fff09f501fb893d717e34f9d61
+            ]
+        ],
+        [
+[
+0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+0x312e3298297ce9b613e755220138a61f6fcb449e9f297bd2ab37fa4b060c4f8,
+0x237ee46d48fc4719f3b0c74d1ce32d25ee1a406c86226b14963597d77d3b26d7,
+0xe643d3d4ee78128b65244451e50daa769353d675b70cd9f3642127c70afc096,
+0x276252adc5f9add05d80d4d975aa6c8506e5f3615ad04dd19b6a8fdf44554816,
+0x40e4596ca95fc409132c1497cce79ce1293bf459cbf2e0b1ceda174d0e53e65,
+0x6efbf7c9bf4c721cb0ebff67730a41eb0d4498251681593f54d16da5cf2e24f,
+0x460e5c59d6292faa4ffea5c4f0f5b618c30291ef6259d2d5bf756df87a5df8f,
+0x136b729f22d1ca74db0f67b12512925ab8597467cedf52e6d289407563cb253b,
+0x28aaa152884edf31944d72dc318424c0da3492c9f7154dc8fbcb6537cd7e06bc,
+0x23fdac37f71f97739b9ac6b9862be4bb4075a31e9d2118c7f4ac5074bd7f2692,
+0x767aa1fbc4ea303a476f04423458ac3f6e45404c9f22c30e2ee5dbd7c9348a1,
+0xcc0452c4e5cd956ef1a3b4ae5bbcaa7be7acd4c2f72d22d65077587a91c0b01,
+0x1ceb88c33c35ed1e6738b9ed039e4ab506bf7ab0f08a7aaf7dab0caf13eb0e68,
+0x12a998baf33d6fbf6fafcf03c462c8a5ef7704b181abf2414b689f9eb08566d1
+],
+[
+0x19a92ac6087ab89982fe5650e5e799f91003fd8b45400748d2c25e40f04c578d,
+0x27dc8579136c0e71f75b1cf6f5083dd8354d115bf414dd1fa540e5f39f7afc72,
+0x20428c044d22ee0bcd7a3e6fab424e8b80af5027762db1e96f6580139e2bc093,
+0xd17aad3b6fbd4fd8bae145159eba2a61ac1244b3fb460222167b77139c9da6d,
+0x180d3e114e0939812b91fb0eff3e0b6109043c1d4018d1d2f9cbc79e384618e9,
+0xcf213b1d3f6fe0b137e4524b963bed40993416f8f1b174fe697fd55079f3343,
+0x190b37e8c9b7bd5ee60d0a8537d47a1a377f7a5674c75a99540baee608fd8f25,
+0x3034b01c2fb47a98674d730818419829480394df38d331ade2700d39138a43dc,
+0x6b1dd2a5fd27efc3cd1aceab1969f68e4959b36a0da5ca5b42c10abf0d230a8,
+0x488a359cb7c3cd4063adc6ffe91ae4613f72a681535e35b7b96bc26086bda29,
+0x153a1ae9f00d026c31b3462001a07a114b4276497c8144c42af93d11bb383d0a,
+0x16c499c243fb5cec60a76c3292e05a6217471eacfd3ab2b95b409a367f5a77fe,
+0xec171c476265c4877db3554fa9f482a8d6b647239b89e48a9097f174d5c5b56,
+0x445f4d9f49d4dcb1ae866956c374e1a3cb45419e00f5836b88e5ad16d639eeb,
+0xd9d065a53ec9ea1f2f08c32c30a37cf2b7ad1614e60aaf3b91508a3ffb3b301
+],
+[
+0x302608d750f16491df5a285f5f7f6a5ce6b554f5dacf0b69d450b24bbb4967d7,
+0x298a90da4f4bce9de81be6912c6ffb796d04c14432c8c40a105a28b135ae2735,
+0x16065604a60cf2d7e406310a514e428a734b27a86e2def6fedb3f714c1679c58,
+0x1b8dbca850e849940b154d50c6ee570c32444d12c847c2016b35149230395060,
+0x2e93afeb1b3520058245bebe0d269664b12e730fc45bbf46cb66044d57b5bab8,
+0x2eed04ef2e97eeb4738187710d3c3d598e60a7b9e6484d4b4a2f0983d2970945,
+0x1b76f377622072daa3d1619b1bdc692333d5345b67f36f430cf516ef16eda936,
+0xa20b0fc9107098578122aeef4dd1bbb7ef353e400ff70d382ee8abb7c481e01,
+0x8e34a0ccd379ed1c637f8272a3a4cad64937438043f4ba7f5e5f5b0adf687a1,
+0x1d48b6efe372666fc8519de0f01a8e5d360708e47dadce1fc01000e7dd4527c4,
+0x260f8a62766f0e259aaf537577b1a99d50bc02074e10f624e91c36f3bad5491b,
+0x27ffca574c26cda5aa09d071c5894e0ed95cd93036e2193e84b4e5ea7df06b0,
+0x2d723e71184abac895077f84c811f4135f4d7acf5ab28f532990182a43873833,
+0x278e3dfc235e7b04caeb106a14460dd6a7471b6f19d441c1f738aa625c45f28d,
+0x20fd0cdac44c5b5c22cea47ac2b0d7565819a0e8110932f0e04c300eb32b223f
+],
+[
+0x1a3c7daa6b4af5662d0d8407b287674d83eae5b7563405f48def49981c98c424,
+0x2ff508346df0d408d3d1109b26123bde5c4558bdab26d9cf3c6374a6f9291864,
+0x13674b5d0d749caf2d93724d234c9a3a7b9aa8ced4f854b853c07a6d575b7ff2,
+0x526e69c73070647cd5d45609e6f557bbb3b4cd4ced38e3982fe8fa217a5c22c,
+0x26ea6a7932de98e85daf38c6a9a75cc6c016aa9eb31e78d7b5af1ef3936cdf54,
+0x2ea7c830de80ac304f4a4342818cac408fbe27c811b25a9e6c1c2cd7a3a63ec4,
+0x213b177aacada821231c6bc2090ff354d629cc89617d52a340673497b0c9b294,
+0x178cdf015d8bc8ed5294bb31b6299345cd5a33e5ea30e4f03f4b6bbb2aabb2e3,
+0x28548c8bb786f47791c98c20d6921d39d82a2c98681cd10f1805d4b3384605c5,
+0x2a7d9ae2a915561a62c884f5ac71ef11815fa7345f61466abaae9bb172382462,
+0x131105c4381b5f577a61629a53e074ae66a120d7ef9bb5c27ac675bf90676156,
+0x185c152024c4fd6afd5f7f6f95134da079ce1614a9f4e03f2043914281041384,
+0x1ca9f045f715d29458cb1fbdc8d84a668938b789bb4e9837cc7a2dccf90cc569,
+0x1f22be26d5167ef4bb00117f8e6ea1f2866e602a986289bba484ba2f1e875591,
+0x4bbff61811db870b42bcce9be11642d53a88243f2f8271b60897565ba6a6a60
+],
+[
+0x2db1c9855ac29acc679367dbf70f08d98894077df2411f91ef68dd90177c1e9b,
+0x1347afe5529f60fe7a738494455139994ef976212daeb0289737fc17d67bdc30,
+0x17832a57483ab46808e944495407d84b427a250d2f4d8adedb0da2bf8b00f21c,
+0x18aff8fe5a1798ba94632917ad3e19d4d8eccb81195395d89b7d631cf2962663,
+0xa3ebcde6fceb125aee70284064b2f3524ba816c151fb6245e07cc33c13d97f5,
+0x17230666ed67a7740bdd76a96b3ebcd29eca4301e827b218ea24a4a56cf11eae,
+0x2efaf6a0e622f10e54e08e0e0acd1e4263ccde6164d805fc5317f9eb83418c0f,
+0x2f1240e45287424dd94a661e56b89f0e5a11b9e15fcf896d04b76404ee53148d,
+0x2bab506569e55b5d04ce7afa2434a095d3b43f0329b74519f88c1d63c705ec41,
+0x280c7256bd6775f497c95849ff56a53a8cd9b01a60205fd41702a10532a7ceb1,
+0x3de768cf69223497fd2ea181708751bcb42a0e8cf3f8580ba7d0a86fff12881,
+0xaceb3f030450738e2cd5f1b0177872a632cce047ce9861db835554b1bd9de83,
+0x14b711d1cabba4675d177f17d623824b3a28229a551f320b3355a9e3f9608c9f,
+0x24bb09e90e64f5c63d53580b531079784e4d59d287c933d613aeeaf59add06be,
+0x213b22a447492a79d3152f0ed7ff35ed7f580591cb2dfb8d91ee9dbd67ba64ad
+],
+[
+0xf06ee47558f182d810bbcb214a25da7f70a567a0464b348e1b30eca7de99d27,
+0xfcd2ff5c8f0bd2947b6fbf00d0b81ebfb76064cd51bebbcdfdb6209e6634bb9,
+0x302b344f13b30ca0578bd6eb52afb66c031b33a229b18a61a98395a95cc4a77d,
+0x22b451ac56f38245014eee401568e5cc508bdec222355ab1f7194493ad7f083,
+0x1b3bf735cc8f4d38d737f7fb6d87d70646bcf2fdaaaa2a02fbd0e7585d24f37b,
+0x1df0e1d73bee56ad584211352e7cabb7c748edf107cd8c5750c6293ef7fa1d87,
+0x994b0fad98bd40de62c6a239fd21624a196ff95d2bbfa22e0416be5694d67ea,
+0x4cd761f316ecc1b03668f55b6a6a9a82ba2fd797ecbd57013176ac85d8517ec,
+0x2398afa197096947d567f16acabed2956bb62acd9a5d898be5f7e154b5ce331a,
+0x1f63018449c6f982d1364b473737e009d0004837e9b417d100aeaef53e5571bf,
+0x1b531701fd6b02b680ac96125396ebf4df7f83acf2edfe833893eeb5f2c3a848,
+0x1412ef160245006ba8ffedae4e0a1aaffb7da57e70128959a5b5e1503b4e4087,
+0x3ea51d0d3eae6f814251d648892fe5985019645a2d39bb4d4928e6b4dd9d702,
+0x181a8292b083644b0357e5c5b0fdd3162877cd14d98c3ae8e4e01fa39b19f468,
+0x1aaeca8c009c0588d25f56bb9457a2cb260b14e88c8e81389479edbd174d73ce
+],
+[
+0x2166d78d948dafa963381cf1560d00bf3a0a1c288a743344c8643a58daf8cbb3,
+0x2fd8655505991d7319eaca4c4b736ee81976b7b325c494ab80c69db132e55196,
+0x14b1c418f3c123d91e084f3867dd62b9c73866a494c0646054f7d152824cb0b7,
+0x29e7183a40f1812fd9e690cc6991f46516c6a11b6d63dfb275bdf45c2e830daf,
+0x2d6e071c9a8c12592824b246bc5024f68d7f15780b8e81cb917032ea3448c77c,
+0x2bcd6ecd21d028a8af782686b423a5491be09d311e8b8b311a76c6fa3b6e846b,
+0x2995eda96f028f0d823d390a39a08cec8844eb9ce6c8e081c573263505dbe1c,
+0x190c2382ceb77e73d72488efff7a47394c9eabaa55e913b3876f5c7425e5072,
+0x1cb68d0b5a7d1e5ec01d0604e9ada4e8b0e5d657e0c3a4b981d9a89585b5b1e4,
+0x17258254d8e0d6f925e7c0185f2098d534afb0760706557c11cc93481dd34dc,
+0x559f237de62143ce58c3f3ffc6fd45cba5c2cc03d7a5b004324a2673ff6d5b6,
+0x2d1bae8c0c7b65e609125c9900ed01b4fee0b246e1d5b40f26a321cfe962044c,
+0xbb07c4601eda15ffa0c7ed3e9b5a7331deae9260915c930d39745da694ded96,
+0x29a3328fef53e260a43f8fde8842280d1b74ed96c3233c5058fcf5748459fc26,
+0x2694a19e4af7c2b87a94dbccdd1b3ac611b1373131cd5a9d70bc7837d8f820a2
+],
+[
+0x2929be9bfe3f93cd34fceae665d96b1de1afb26bcaeea2f4edc454c50cbc4401,
+0x19edbb7a983fcd768fb267d9c4a1fea3ce0b2a2b9b443f0aaa46f06e589d14b6,
+0x2c1ddb439b10a092b3971318cad5b08debe8dff603bef4532577c495be1a724e,
+0x28449718fd137470b9cf97b815c2140dd1c972ba998e2fe4822b7c0b33bbdfdc,
+0x1f0655560b2334547cb948d9d6b9b5907c788a38ef864ae0673a78094fe7ee7b,
+0x136fa4ab79c28e0be9bb475e8d02fe991a4c3e1963f8f02bd99fc08feb8af068,
+0x1145dc67ca067f540d071fef09cbb91e1d3deb8202530be3829f4a74b97c83a,
+0x2befa2b6dee51479054fd8dd18588a47a402dd5c3c4edca0c6c5fe3cac3058a5,
+0x1589963f1ad9685037a5090e0a726b46f0d68e01b41fff4e51d7a7ee3ca0384e,
+0x2e23caeb146870890855c6e35016e8fbc54757333d84d986487193341a6942b6,
+0x5749c39afeb687fbf56b6749a6d2422caa3b4a4a98b702a4958b7e4ecb2d37f,
+0x178880d1f6ff2f9b8e1ac338c92a0c8f92803e7f4c277c589d8f4d96102bd7d8,
+0x2458edb63177cd46b51ff3f5054376a76640b495d598e472877d4efb647a629f,
+0x15ac4c506f0e4516834191a3a6aa8cda30a2b3882ddc8d063ec7a9c38c4dc014,
+0x24a5f8b16d150a9683e69c3ae603931192560079eb25d141ff7c2cbaab4dc9c3
+],
+[
+0x1076d439c67997c37c6c1fda9a37dc2f762dd577946f36fcfdccd7898ec67cd4,
+0x2d9c1650b528398e8d52dbc23335384e54aee2432d635c70a02d96243ca0b26f,
+0x1b2c5206d50be044598c5897e0b4b0221bd37b510a437fe5a1b4c1c69c601b6d,
+0x2edd1fa77896a64dbbfced0977e08337ee4bf613f76e8a2ce26414548b231653,
+0xcbb908762517b41e306b6909833d5a107634426f22973fe83f00b0e17f13296,
+0x24cbb3c94a026a76c045e4c6edfbb1367d256acf26d02cc09412eda7f59a7ecb,
+0xa0bd0ea059162db49db00cb2a940d57b4a174de0f3aa95507bbf8bddfe17b1,
+0x1b2b047e9e413d748553f99dd8af9b25efcc5e22d45fe891dd28f8fbc2fb5301,
+0xcb96ace8a27b43f9e6227f6712da13e1fdcf8f3f9908a3a1c26a35a05b14922,
+0x29ac01ae36569271195fe075de8ddfb4380c3a02d43d7342a1fb5117b8de2a53,
+0x42ebef9c6a4cdbd7c6cb04d45d2e0c2aaa80deaf78bc1f58ef40906cf3d0210,
+0x2e38bf07c16b3203bdbc7746fe5f9179277cca8363c860155d140ec63673791,
+0x207e9157c54acea4ef46af721cd9b2f57447ed4e87be8933f1d0b6d814d6ff2,
+0x167fda86032760fe696b4920c81f53d843f93d6dd536f230d2004eb414bffadf,
+0xfdd5ddada0b045a445aa344bc61b1ac05142e1b5641aeb7e767de15abbc9bf5
+],
+[
+0x185c9ad0da87cf824624d02bec3ba4665822a0f6b3b25deff3afcc687ce1321d,
+0x99fe609dce91a41f172017be2754fe99ebf6c15cc57f31bb6f5b7d807b1f7ab,
+0xd8b8636d4598fdf5326235d176c94628e61b4e7c82e78b4e564850ca2b2375a,
+0xd65ab8a42892dbf60587c701d4ee79885301867045a954e709a0b39a96e3432,
+0x1ff952bebf30d706276910172a3cdfcafb099480002dd0fa8c68288188ffb47,
+0x1b317bd89d4ff133f75ab4d3d0b76a79ae01b0dff996cf34a725196ce703c17e,
+0x124794d78885d5936bd03ff734b5c1adac8a4a596ad9f82102c00d3a684dd7c8,
+0x24ffd623daab9fe13588a1c00b7f8c8f1ca8caa530a1c7131b466d950f2518ca,
+0x2b38ad1a7b652e9f8bf0ef32be28b745c099922eb755a34186ac9090567d8bd2,
+0x19babc734091a3be933427e66c377144245e7db110c6a2baa986003947a240ca,
+0xd0289a40cf02926cbcb2747a0e1c1518e9c4f704df6aea14276211c24086080,
+0x28bd66c5e1338f9704ff07003bfc744bccc39f7ce6c8ab5a577dc903cd264016,
+0x170f77a7b3b9caeaf5659fce45eada32edab843510f0c1c1918e78d0f6f250f3,
+0x4bf7c50eb8083a1b1aed2f2eb1e3e6ac6dac94088c526643d43fc4ffd6750bd,
+0x2cacaf80e8db29ba80807838954a59a587b839dae77fae26c3766144af1c1731
+],
+[
+0x2702b1be39e91044fb73926c1104719f4c037aa4151823ceab24f0cec49f4648,
+0x13b4dec836bd9ccf38a503e625ed8e236c54e696c74637ae6a3686a805695912,
+0x1715f73ecf73e36f8e513b1cc9ab6d82c38edc2000876f5d1bae037be5c99715,
+0x133105b55e6c880ddfdf28747478b9cee5fda98c7ebb0dda7501a2798386f9f2,
+0x2c728d02ad11c999b2b9b9ea9e57d496572871e774331ae56374f238082b27ad,
+0x23ef277dfa1c0e0d94bc61cb2e8bbdcea30f4d4024531391a4c3e9cab4543b3b,
+0x16431ad5871bcae4168c2b861ef4b0b01935d119758db9aae06c00bd30db4df8,
+0x28db93b12307f5bee8a6c0b7bcca8b2305b688020740d4345fae2d04ed2505dd,
+0x21b0ef1e524d8d9ebbfc6c2c749d0ec90fae708de520385ea8bf0428508c5d5b,
+0x19d13c633e260305a71528af4eaa906ca4427977dc0c747c8a6a4503fef43e8c,
+0x23d809de14b02c1069c3e14dff538b910e484afeff400b2c1d24fb0e0099cbef,
+0x13fcf2fab4b4b66a25dac0cd517fec58f5ac1850d867be3be4aeb9854eb30efb,
+0x161967aef1a7f7907817e10adad374693d3d1f981ec444384c4db438195d4daf,
+0x1694d5ab473f9de3701a254240a02a4743ed5291b9208af4956404ddb30a4380,
+0x1c710c033318dcb32177032074580a3504f248668c7c53de567b4830f74c9ea8
+],
+[
+0xaf71a51cd463b9faeda93803cdc03186c7781845252fdf4e0155709d93dd375,
+0x5fc3b1799e5b191257c7a3bc75e9fa97b164f3f4edda6ea6649c83267be51a5,
+0x1c4497521275cd86c918551760f4d35becefa8ed08036c9c18d83815a9fc7f8c,
+0x1c65c1b912286c5b2274387fa7965d6b2843b5b01b806bbfceb590da531c68eb,
+0x29d4202e4558503b0449242495fd9ad2381705256affbba80117b4c2287175f3,
+0x2933124ced84942c7077b2ac393d14464d517c7d8f1e340694ed5f1acbdff129,
+0xbd580f80ea79136a9b520cea04461da846d9f23e62277f13d6b3aa6ab108ad1,
+0x57b88d83808d3675ba199bfc5780633adfaa44c9b1e32463d66b79e1c6dff3a,
+0x3a6c87ee34cdae1ddd7982cd318362e1a278dc9cdf1cd1dd03b6c36aff836,
+0x22692fb680511799b8ceec96e7ca0e1cd21de90f94856acf334ffbe2fc262053,
+0x1d85033ba0c5dd804c5237c31ab8b09684c635b8b7578c50c246b15314926871,
+0x2b52e9a0a9a535ae05d79b8b555d461f148db269f49e38dd8ec6f8b8da106aa3,
+0x2773fcd9cd996f38297b95daab22c1e79f179f4c79fd4bf6f4abf8725ecd5032,
+0x18ad7311ad63af100808f64bdc63392bfaa0a3881ab03c3157ca8140868a70e1,
+0x19b88372c544a69321b273cc62a95b006931a64222cab4536e797e578a56305f
+],
+[
+0x28667f9c7332073e293c80b98edffae01af4f67b4c52ab45e49db8b30f182d28,
+0x1d0cea849dc7409b3b26de35715b32db618691bc123cd9c4c5e6f40b4a1e49bf,
+0x161556e03e94c7156607cba64c0bb7fa00bcaa126df8afb5d42976c03b7d5e0d,
+0x419c20a2ef9d70e930629591eae4c63276c5d79d6948e98f2c37acc29f1a4aa,
+0x1d4a3584e3933abffe0977179b8c112f2cf08e409d33362df4775d1373f4d366,
+0x104bd1b4c028b287ac3fea1ecdcbabdfa6a065e9772791c3de84d945542fc206,
+0x267ef84e628bff8a9a85df724e4c32cbd3237d91bd65c43618d86502032a3694,
+0x2d361efa8fc65b03d45507cfb53549b3b26a84ac50b3593dbc052806ecf59fec,
+0x1285c484100d70c992f6b6953a9955f56957e9a17641679bdfd388b6bf60ea42,
+0xe1a46a527394539c39e9f1e4426d3188c0d9077021790734ec0126d0828fbc7,
+0xef206f21658db03fc8d5d6be5b18374247aee43b3f29b430a6fed7fa5102a84,
+0x2ac3db07d831b461f38204aa0454b1edfc1a0de5b7a6e15e49c63bc7140c3327,
+0xeeadf9b5fd85f9405991af7f4cb2bda816e5aca76103b34b891502f921d6096,
+0x2931d38792a3769da52491346c7c6f8f106c2735ef2a1ca03725396983a0049b,
+0x131154cd6dcbb9b469cd6860b861699845abcc41f428331b1d2beebba8ceb767
+],
+[
+0x2763c33f5b2d7bc3a23040afbcdaf998bb13254c272a5f8635a12606a59c2e5c,
+0x27ade810ab16b1c9d9b363d48e397adfc79af3a4836ed63c650053ca057a03c0,
+0x177d3d44dd549944ff5772d4742603e163124583cfa4b673ccf1a25454ea3be2,
+0x2c0de2ff6c43c1d034459dc8458237d808fb0ed445eae2cf7e972c83f006995,
+0x27ac47846175fcaa604d687cd2ed41f2ca52905b2eefa79eaa8583ebae76291,
+0x165a3778b89cc7da792542f4c9a6dba92b85175a60d3661beb77852b238629b3,
+0x27e08a80dc448a0ea08c79c9198e57512968df40d45f08c26ac8242d126aedc0,
+0x1fd804ca6b5d2a3cc76ae1f125a0bee456764db7a553f48bb47f468f3c57a95a,
+0x174de7ca0ebe6a1290ac6a8076d51b85fe8fb4022da95a59a6e9f1fc2fbb2efb,
+0xf3deafe2fe6fbae9417eb6b144885051e5d1642e49b37469d39a6bd6cbbdbbb,
+0xecfff476860b104100ab4d0dc92d93b993024a1c0d6d50b339243e9ae67ccbb,
+0x2cee2efaf90a0e74febcd521cb5fc61304ada5f8760adc044cb684f341b646c7,
+0x140214189bf9a4001311fb36b9e5d27a3f3ceba32a457135a3c66d76e8403553,
+0x2a90f5ad074f3e239345c3d75b7081804b34fdfc2fb9f720a6448818946ee976,
+0x1c373710856290660f38b96ad9baaba487a10183260e1d06f9b9935d36e9b0b9
+],
+[
+0xf81a8d8e08758e8a32aa8292666c4cb6ba3f5f06c4dcf4fc502ff97f03a85a6,
+0xc3bf8b042a0fc9b018e64d500484eeccc8086ec911012ee19a8e94c97b1f8ba,
+0x10539e3badcbe0386b58327fa5ec50e92d483bcb819b41b21dd7c54eda76a99c,
+0x308a3fa0a2d7ab2ef746509f2fb76d1a5db994586a54e9d109448f18b281b31,
+0x3ae04f50079403a7c6f13c02d0ecbbce7631eeeb2f9f284dc7c2a52fbff4770,
+0x6bf4105aeb7839b9deb71934169cc975451f8d76f834499b281eb6cd69c071f,
+0x28cd5b5220315f32a404bf919a9cd01a3082f5cf1ed6e92dd79a323bfc62df5,
+0xdb2421285ea7f5979122022c62e752e1b15c491cca462b4e71b7bb0661990cb,
+0x200d26a5d00a2c154aa75036fc4e24885f7d8e3ecdfa19beb7cc15767eb2de8b,
+0x1a1c643b8d0510676c8afea7a4c4af98432406731046ca882a497b29a7c61777,
+0x1e80c6db7632f6d64766cce10b56d0762622eba0de31b6271e95ac94cec6ef32,
+0x16c8f7d85e411d0f9ba685f0fb815c6ff517ab5463c74bb9984dfdeab8299477,
+0x20830e9933ab9c82b1d99369207399eb347fecd8d8ba430b5925038cc3295055,
+0x256a4d8167c0f602f9f3b663dbde4a7cd3d47353587b017f4f03627650b813ff,
+0x11139f7a6884d0c2efc32997248db307bbc0cba48037fc518478e9634fcc745e
+]
+],
+        [
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0xd4e118218c553f4fd17f1dbb39ba942efd76cd18298bd6b72e1fde271c74372,
+            0x1c9814a36ea57e27bd838375e1c1a562dcd2af6a66aad460bfc8afcf3d63ab8b,
+            0x1c573e2904e49c6abed20981459d41c560544306978535d6becd7106ed3e41fb,
+            0x9e39b302efe7ebc4307cd009e6bd6f7b5128a23298b11eb8e73047cf2f2e920,
+            0x1fc427692601beee8d5f6bffaa3faa89af61a2ce7a048f9a596cf2c38ac2cfd7,
+            0x1e5b7cbf92351abd6a71a235d9d2ba54bebc40e693a66f3b893174ccac29766d,
+            0x2ee69d018063e4752c402c2255b267a05e49736814f2c9b7247240d61e8b684b,
+            0x1eaea919368dbdf57be4a55db999baf940ba81052b4e4d5b8e7e16253274f5a,
+            0x297f770923ed719ff3167e17564126bc6dda16c8cfd27aad29dfa7a466038453,
+            0x13a94e1e1ffd11c4a28c86290a71162f82c03ea2634b67d98c1a5c1d06912186,
+            0x19cea28494b1210a4098ac0e79d99fb546c2c3588f3cfe4a068359bb6082e56e,
+            0x13841448d03b83eea61935f4d495503643436e90a8efa58be47c85e581b050b7,
+            0x2df272af26c5aa5407188de71beb7cdfcf870c778b2093cae868000a2dbfaccd,
+            0x29fe73f14e2420c982548ec713b85e374c1d8a43c2bc2ddb6302bef9fb2b6e24,
+            0x9070c4406fbd360eca9c300edbd0a65fe8f59b876c18ae13bde14e3330e3175,
+            0x2c82ea6755166fd89b688200788ba82d29734ca1b04494d0643b8689ab0b7cc2,
+            0x26e76b10c0dd0dde0a57f9b731be061ae57c1d964e2e525081e1fa6084632b57,
+            0x277298f3554969bc6937d1b5d5fdc5821b3c809206a3930ec894caf9a37240bd,
+            0x287e53a89a23bf624bf6613a821ee5d502838605198c699cdb6ae5d274bb8453,
+            0x2e9f85b46415dab53d2c1820226d4e7117e6cc96b7ddffa9f6a96cc697256255,
+            0x17fcc4d649ce2696bb0e00460172bce45e5deb8c57904e5ca0d056c9df3e5297,
+            0x2c971b630f9a4bca7a950159ff4411578bb39eedee8d9f0171b61ef7febbff4a,
+            0x9b526beea2b32c93c9205ce33c6dd79824ee0123e0ee8309814432299a9756c,
+            0xc8311c2fe1acce872212bc73164132f8fc89039b4b297090ef07e1997704279,
+            0x2ea4d48161c13add4b1dc83b3666ef388ada7a353f3da4c8053efafdd1742bcb,
+            0x447cfb281dd95e5bcf7a195bc52e08d78aed9e64cc9d7973873d06a42b8964a,
+            0x2828d9d20b414b800a028afa5e61ec4362ada01cbd66f3a4e018f941a9edc227,
+            0xf37dee2a8dc76e8cccbcfc527cd8c3383032e1f3f5065e39d2aa70b8fed775a,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2ab166f28cfdbcfc32e51fc1db9264b527e40c696357cbdfa6bf90bf09fb97fc,
+            0x2e156785cef17b7d942ced8e2ee15ce4bbe2ba73c0e55bd50eb898a1bedcf3c0,
+            0xd4641251d71b781208156ca3680d6a5676f749b7588d5db0464c76ab985a43a,
+            0xce5cf743d721f040dec40606144f5bcc8b068d2bbb11c3623eb423b1030e147,
+            0x15e35852381a52021bfaccaff799de57d8dc8606f2465e875c7f9e22a3183ba6,
+            0x7e9b4e0821320afbbb23fbe3a2027192f2ec891fde602faf446d06b3a770c04,
+            0xb743d70dcb58a6acc70835a005c7ce366876fe3efe504909b0cb87aece170f6,
+            0x10643f7d6181a8b5df1e921eb1a841476a937fc6a473185d8322c9a18c487a3e,
+            0x2928df7c94de7ff8a3770980f0fbe3cc4e4f5908537c40b9e75247bc31e6585c,
+            0x168d44f63e58a5c713c37e067709bc369c27f428af5eb3eaa79d445b9d073318,
+            0x2b8845a96842f965343a94e76efa217b83bc1ebe804c7b25e8b3b58dd165e79c,
+            0x1f44fb02f387d2ce14dd149cd24fb411a7c738157715d6a1be66ec028fc01bdb,
+            0x217b5aaf9893ae41030f6c64ee6870bc995427c81e04a265e1774401a5412a53,
+            0x45a1e21cd1e0e5b296cc6e02e249a6cd0eef3f6487292f0f1c742de712a4a4d,
+            0x1901d160707a8edfbb7d4533914b9b8bb06f565b1abace77f7f761eb33f39e5c,
+            0x27dee99b80374f3c665a4dc5c89a8e365a5a93d07e51c727ddd6a896c7ef8a7,
+            0xb1c7058abc3ca4f1633d64c0dd5f068d7fdc10f96e3ca682d1b2ae6e289aaf6,
+            0x1c495d660ada6c32fa2f107a811730d99ec01d9a17dca7001e659fb8454b9a1c,
+            0x100885f5765de1733a91853cf668563b88c9c36005cb54cae61a82b6bb65160c,
+            0x233544636d02f161bfe5bae6e687558cecee34870235d36cace44c6d372f0545,
+            0x222a180a868a589137d947276e3cbaa74ca5052e685e02c178f64767a4e66446,
+            0x22b1b89514b6a597c1331e24ec3f4e3232821a7330a525629d4d7e04950fdcd0,
+            0x229fd163ea1ae80446877d78272ce7c50b8abac8fc591ba25c22661cb1e1d5a2,
+            0x5efb45e61466bbb89d081dfbcc8bd398bbecd324d5950d65151b80c102a0503,
+            0xcdf2465b92dd04b968ea8419be7466b0ea3785fbdf1a7550dc5b99e781853a3,
+            0x2acbe99eeb7c3a167376c64ce28e10b1628cc3f7f480e68dba68bd470f29ffc6,
+            0x21c173647249e75c7c8cb1d097da2d4ccda1031ccb8be5a1d2c3d392fdea5bd2,
+            0x426c0054e199f89ccdd26940f3b6e8e30bb744886d5ae6677ce75f0abcb1a2,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2664a99501d9fcc7afebe82773b4ea88245d531d59a7a0708522c437a2c63c8,
+            0x1dc35aa8ae4c95f4a17d44a790157b7f27045bfea974ef5818a2ad557ae4d1ab,
+            0xfdae6869465240d7a6280616afc83e937cc5821d8cdef8ae9a085395aa708cb,
+            0x1782b019aadd454d509149e265b8474467c1ac219af05a53b8f671a3d1c7ab8,
+            0xe543d031bc1748852a333f2e031cbcb39d5715e8637ffa18f18d620de3b1ca2,
+            0x104993ba9cad115c79a58320fb01233fb0124a73e040581c6621429cf2fd8e2f,
+            0x2aec2aa10254227e5e0cef19dc491ffae856bd5a9b029d926b60cdee38a2e30a,
+            0x14395653083408edce60edf4f3232a9614c781cfd7f6fd183ee22e08e9d46daf,
+            0x2e200704e49142bb68b20d9f7df040a1bd32118b21d44f74dca2b31818693012,
+            0x2797778f8ed2e9af3fc79ec16f248b6209c03036a7f0d5066237befbab16e11c,
+            0x25e0e403bfbbb31be8c5360007aa9f2e36a4dc4b5b2b0823f8cbd4349970ba35,
+            0x2e8423bdead0b3ee1516ec6c5c816c7ea3004a45a0443192427bbc4415251771,
+            0x2a34015d21144652f722f141385ba0510cd38da886bc0df34352ee7ae76a07be,
+            0x2a3fee652dcedc95a0b44a072aaa54f5155b036b22bbaf7eaf0b9c3cde42f4cc,
+            0x135692d47c5a0d4df037949a54fc72f230314fe7629e0dd7987b620c66543505,
+            0x142093c728ea36edf0844de5e3c4b4f1e1b44b72a413b7b2a758b5be41c8d616,
+            0x2a0b459ab3f636567fe0f1330ecb15453f62a6993b748edab79ad8cdd0d535b4,
+            0x330b0a428235522e1d5e4728b882d56a82cfda90452ab9187127ce73658a9f2,
+            0x2c44b22ae15ba0f22763004e8fcf0af6c602a0cbadc67eff70a74000b67017f9,
+            0x1c68c04dca5f72aab61b7b60219e29d1183c8d1de5c7c8c09460738b6bf9760,
+            0x1c74af78ca0448531b773a27c47800cace7f86e68e4969d29a8a12f1b9d59330,
+            0x14e2ebfdbf9c76e96911a23a9f9c7076b38316393fe11a0a7492e605ec7a9c42,
+            0x119a85d4048b76c56f636acfce7dae71759828d711dd6b28ed0e9a236e4d8fb3,
+            0xde9be78e2e3c344a0b76a171b8d7ce1a1d05f25790a2451102e05a91472bf35,
+            0x1e91cd25f12f2f3cffc2490773f8af707fe1a6843a766a3c44eb5b8fc134b002,
+            0x20956c83b24ba2bb0086a91f597d0a902f2d74e53216bbd9592d35c438648061,
+            0xc716d79b1bfa9d016fe75522d771400fcd75862133046a9b1011540d2331e87,
+            0x2c4f3e61d58aab9d3c10abc4656fea493fb3d6374708cdb2e084a67e2fb6ea6a,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x15762393eeb335167599c130b4b6d22fc3f053dbbaf7635f39701683f9642dfe,
+            0xd7579361389b5dec0c5817e57dd5b775c48facbabb151eb0f7e2da5ae19d158,
+            0x265b9eb82ef9bb6fe2f70ccf516bee6b9be401183f0932784a40a61186f47a42,
+            0xad7dc8d9d0b28ae3046b8f23c3a7cb614090e05a3c9ec3fe8e2fab367df2272,
+            0x2a3f87839d7b3e0528e7b9c221379203354304e363684e38f5fbeb698bcb19f7,
+            0x2834e210d211aeb395ae05198f7a1c475be1cb0d89a8c0877d8e88a9d62fc5ea,
+            0x8cf6af0f8c7017f0de1cf6ea6947009c1041169d5b57c49938a6a4c863debbf,
+            0xf9b0115c9097f360d0fb624b14c8b4a1ceff857220a181da4c32f619b164bed,
+            0x10902d17db9823294cebb8706f44e8752e5a3abfd8218ac27718a4c0fc8a458c,
+            0x2ffc17ee98848d878ed4315e3ce007667b4f18bd43993e4d969e9cb38d8d118f,
+            0xf878f0a4df67255f88423ffb527014656515eaea2e9cc36be9c37135041fd98,
+            0x5dd3e66670174cdbc764ce0711c58f427dc503c798e29140820053da7694d26,
+            0x2de49ecdb01104151943ace205edcc81ab91a9ef2af4c33ee2aa2d08bad6c023,
+            0x2cb9a3284c718a566d7db309aa0ce6f8e61dba64a225f746b757ef2eaf0b9311,
+            0x1d1c9593d0c4ea4ed9a491dc73821969ced386145cff808364bc37335ccf5a69,
+            0x23a29371ad7760d5c5de4ae5024a4612743fa77b09eb566c9f41d216c9552854,
+            0xee30c0ca292c3dbbcdc2471f750036531b0cb85eb8464d3f92466008ab94247,
+            0x1727f0d18b422010f97058ff5e8ac23fc850951774b431a38f60a1d9b5560175,
+            0x2ac5457bc236f8945365b828183f8266e3d1b5b3dc2d9ca52febacdcde11b71b,
+            0x166d29ead2255e356ca2170969b7b9b94bbd88bb34ad7e5663f4d3a25a330ee7,
+            0x2e386cdbee46199b48299bcd0cc8ec486f6c6caadb087b52ea86e51d4f39e736,
+            0x7937bbf56ef747bfc1543e6cf5c653434e85a225f09199ce11747da5d44a530,
+            0xae9d9852098390b4a5b9a075d32020a5d61d0a2a05fc6037408840d43bd04fa,
+            0x1181b5e009f4e51aa287e113ed3be581245601ea27ce4b35219c7317087568f3,
+            0x2475a06052db24962d86bfe804db3f65205984e5966c1a8695351dec487b611,
+            0x1e9530a8088a3c241b2e5ced4157949565aa90425ec8b494def155581d6e10d4,
+            0xc9c3bdd72c3442d12734c0f3bcf2bd1bc679cf8fac9127abfb316fbcae53202,
+            0x2fca60f1092c4d48164a2e2c81fe134cb4bea555f4569e095389e181a4ceb5ec,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1115614e19e210b59b4b0e708130dd845be5bee11aa1ce43984ccb99beb3624c,
+            0x26643a2ea75d103a87b50ca1690a55117340ab3f4fe78e63f81187f58a392382,
+            0x699ce3db9d5882c04716cd74bc49c2bcd5cfa34039856d27ac7354b60ab8412,
+            0x147e382354cd1bd30bb3383eff03f89974b035a00897f89d9545cf501ecfb243,
+            0x76e68370ceb55cca9757765b0c2eff1e05426fd3b1eeae4de2bd9f49c121700,
+            0x8064483b1ee3733f6b6e9dae47a7dedf7baa9b67ff8471ced25395fa38cd884,
+            0x26225db4d7860e869a00f54fa10923c8041cf313eb912318aaf8f4f897401f44,
+            0x15ba41ce4e4e0b3c6633aa83180dab522a28b25887f78e8acb61b6cfc6f837db,
+            0x29bf9692a1f8c909bf1d0fac4a04de3804e89c3fcc2b081cd25d44b0afff7b09,
+            0x29838b380b43fda29e4b8824229a76291808c2a9c4864ba8e5577fdac75a85e6,
+            0x165e81bf9d1b5b89ed739b99c84c53dc3fca070e83a818d5bbfeed37630a0b48,
+            0x10a7013127742057201e42ecbc83099b49a60af2365f8bf7cc403a3095ed3fa7,
+            0x223759ffd12a39e3e384c76802544c3778f14149d0123c1280fbb92ed556d9ff,
+            0x707296bc5dc73b70944cfa07f21c77042753a479540db83d9115f9fe9ee3e59,
+            0x205f5d69af9f4bb66c51fbbd99ecd7108c76240f97f758a17e60f46bdcef86d0,
+            0x1210dd2f4c47992f4d5c7150f1bd9346860046534bec9bcbb3a977802fe9037e,
+            0x144ccf1aeb8b78de9437aa82f7a82ffcb958529cc51dd5a283635ffc0b0a6c8a,
+            0xf996b911c7c650ebcbf4bade79e10411e3d4ab0e2ec01fce87928c4c0f77e80,
+            0x1b46a1b0ed04080cb068fdff6e531b02c002fc3d66b3ed2d656137001b7926af,
+            0x19fce53edadf9d4cb5eae86fd8b1c68c238aef46a5ca33603367b8de0927b2f1,
+            0x26b0885672f6494dfb46ed42a401176f2a2f42790725f14adaee8e9638a986ea,
+            0x2db620812477b8d733297937c52ae01076f5928ec0b7488e855dfc5b938b80a2,
+            0x20d30fe0ff4f57a3cc6e6330182f23fdd72c24aaf0a5b372a32a19e80a638112,
+            0x2a5e3d7b9813aa7a0cbd2ba1c425d80e81e12de4060b90ba7eaf832f00f34d2e,
+            0xab8b6d9abc9cf77de47f36daec39db0f7e3c7a31db631ac6ebfa501a4b3f94f,
+            0x16c8438c2ff89c19e2f9cdce14dc380a8a31c1f65d059e23931f69b921e5b4dc,
+            0x13d36ffb25914bff0a9c1b490db18fc8fd7a2ff9fa3b673aa2ccb2a64539c7e7,
+            0x28b8ee6f7ee1d8d0d3ebe26bf4246e8eb545148ca86e60cbd0bfdf4e9b22660d,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x10dd321b7a11a2bc96b3f4719b4b443d94e5aa2ddbf428d32e863d7b956aa085,
+            0x5fc6b8b740e55f5d0690b7e2309f312d089c4555f057172a6214835460a342f,
+            0x2951ef2c77380bae297a4fbc05ea97de562ed3d80aa8a986359c3ff00bcad10b,
+            0x2b7c767b440ca0ddb88adb86af53231819ad6c21c222b09a8fc8f9d61108276d,
+            0xe44d122f91c40d9470afc3e484ec8f8fe6ad0fd24146f1d38d717da4db7673c,
+            0x1ba47ae303c2e76854d7f399c74f48dfaaa3287c07b9b79bf1fd08f9da703c4a,
+            0x11b425d8000810e925867f7a9850aa799aa2338185b6f97ebbeb7b481a52feea,
+            0x27abc591fdfc4152cee25f4fb6d0a1e932a396b72c311c05a99a9f923b1f7014,
+            0x2a7294a73da17a02829961f0cd5b34c67c909acc3874a238637fb570d4c23046,
+            0x8b325e346b09a1eef8be7fc3d81867135e87ee9958f16dab759bfba34b0adad,
+            0x1d8bfded258e085fd2c871a9db0ca38ce5e5d232d2859c9e3da87829057ff232,
+            0x10321b7d5466be1e92a7b8f17a16a37baba2987ed57399fa903b5385d81b19bd,
+            0x1385299af14ad7cefe90edbd656d72126e0e9078317306984f201a98e3e87ff6,
+            0x1b3f863460bd743da42eb33e47d2cfffd9a1855e9fe571674798d3b0d2aaa8c3,
+            0x16f65f24d40213e86452cb242e20a222d8bda274251b4fbd82dc110ad78f1101,
+            0x271aae4782989dad19f84117ce0466a52e16551386b42a74552db0c6e00442f,
+            0x2913b1df62de1405241829ebd6bbf2719510cfde2d374c171f2b0a3956beacb7,
+            0x102108bf4a73ec9abced652ec51ca12fb06e48b5df049b9e37102ce0a77b657d,
+            0x206603d022cc8608f807ace7c0ec31d9dd98c202be6d1bc47a4d44df54bb48fa,
+            0x28c4e8e4ef10710d1e972ee6a4a2f88aa08a0d6fbbd77cbd057ce83ab6b75bcf,
+            0x1431769f19552b0579c9a23e91e9f017ccef784eaf0b52f33819bfd72ae98f42,
+            0x20c42490a8ca07d9f39b11e720b833ccc033e1ed16a310d53222877b0630336,
+            0x27e9b6a362bfbe53ee9fe071410ca804a9bbfd2d2e579b95a50d63a16c988da0,
+            0x2e937b74fb17d63c90d32c1258c1cb4108f5e3f82246fd704d44233653aab860,
+            0xb1b6974c506d78acccb5e1b6c9a5583e9c922152ec0d113495dc49b14a61c8d,
+            0x18554cce997dedb95d27bf135c8bddd3b0c8aad0551a6f372bba51613c0335ac,
+            0x132069ecac9f244a5e447a1cc19a998073aec780e8236c827a66bf9fc6ccf8a5,
+            0x17d40185a9458fc6b98948ad7da77f035fd7a3618233a43af0d0e511e5fa37b1,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x275d28b52043874241a3fbf29f0fc8725346929cb378a7e4e9e8c7a8ac1c4128,
+            0x168eb99c86d705c289b00227d74828339e88cda8ea726d3d9acbb57ae75043b1,
+            0x2a76294553220b5ba2abadf6bc42a902641312f0bc1953286b08ba16ae65f435,
+            0x4f55222eec01a996c9c4c70c11f6375714c601e1547cd47f1dee0b3999be4ca,
+            0x26afe145a5c9d058fd25a6404e4acb62cb13d299de81fac1deb35ff9f4a40c33,
+            0x2cd5c836e175ed7a902fe2334f239d499f51b58db73bbf2b1180cfe4c4df7936,
+            0x29b7a4911bb67a29bd7368c0f42079aeda1fc0d452efb2b129b0ad93fec02eb1,
+            0x258d09a47dffa2af8a1dd733c8b08f63911dff878a2fdb4794e319d46a63df7f,
+            0x22e2643fe45193389fd7981bf191826724d5ff1f0a68651c1c98ef02d81f1b0a,
+            0xecb1213c8df26deaa40d8f6c4f0a1d4e3c72da3dfc1f4370de7dad7e32618d,
+            0x14ba09c0956dddfe7410192712238658b4d65506c78e318ae769d2732c63adde,
+            0x2dcd28c30f44c2ee7d8121acb638debab46d0feee4dce60d494acb677134a60f,
+            0x117c6959729d1d774ce1a8fe1fa28251592f3bd62f86253929ee45ca959e4b79,
+            0x2c290cbd7d76fc9f9cdcfc47b48fd66ab55d20b7e2f73357e68319367c7fae08,
+            0x1f40cb5c53ab688c259fc3a2bdb401115330f3b2850955a39764374e5f2b5195,
+            0x2a58a19ce1744a2411fde6401a6f33d899f9fa9c59eb6375530f45bd8a751339,
+            0xdf6ce7e1bb5c41d366d6d7d5707c63eb3ae9478043fe167f712758a05b49206,
+            0x2a32f08c015e3dba1d7193b31362ea88156b370fccf15c48abb7133747833ae,
+            0xe549b8f127e7ee7a8e67f9dc534fc8e3a627059b406379c63d86a54a593d86d,
+            0x2ad6b517cba39a16caa6fcfd53d3b8a43758e360c703aed8691d721a523ac174,
+            0xe000e82e93b69d72b8385885464cb1531c74d6255f1c1156539c89dfc84091,
+            0x24b57d1e4c920be2b95c0fc8a84f5d5603f0c286e80d71669d60049b94770419,
+            0x24c65f0e2ad6e614ea9a53b058651459f966152275afd3cd6924a1e990e7d201,
+            0x1d0ae8c3033577ea4b1f2dd4b68b83620a1ffcb4d5426e9603d4ccfcb6f1fb66,
+            0x12c81853619d70f737544addf33b8d104af13ee311ed522df131bf24d83dac85,
+            0x50fefb4229d0fbb58756c49b28c0ad0fee9338a1fb239f8d8ef12e168aa162f,
+            0x1dc4a881539b03ca1b5493a594be14ebdcb60bcb2b4d1b58868d3a6558410173,
+            0x1e7e5f574d74633a061ca773e969dce83ad758e4d08c37e3900f62c5f9b805c5,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2d030d498dd22e5f9b3761b019f812c2df002ebbdbe5da92f38be1ff1cd97e65,
+            0x227f6e1b292aeefdaeefeeaa2e7af21fcd012a794ca2c18d284661cb0fb1dcaf,
+            0x9a991758be8db845ca4b488dfd11e27f0c773c88c2507ad584dd73eb1709358,
+            0x5b3c08cb06d23cedf2cd4c5cd248514a89b09ff70ff56f90221492081480705,
+            0x207e60dbdbbbef1f316198b79e4df3e688c3c71b8f82e0480763cf729b6bba03,
+            0x1d94aa3d4e98c691b3efaae72ae18d50d90ae56629eb00e7bc324eb2362d27e4,
+            0x2f99f4602d8a7612c573c3ed2232eba3f91f030f8b5c2dc6de3d8aa60bba2869,
+            0x185a7fb027b40f8efcfcbbde02cbe15567d64ae6ac9bf206781703c07d6272ea,
+            0xeb85ffa7ee5e9fa96ae4697ca527ee7bbfb69b5df611a1b6b715a30f9b69b44,
+            0xe6507cc613c091c3f6d563b24b8b78d78262d7e6a470ffd98a1ca6cd0da5ef1,
+            0xfeb286fa095e4decdc49ea3f57da799b2818746837f591941e67a93f2bdcdbf,
+            0x157de51c339785fabf4ea584b55e158485bce7dd521c0a25160247a84d13e6b,
+            0x118b39a323a6ab543f005f26c89c673480204a183a1f68e0100d6be4d55df254,
+            0x200f0d9065e79bf29e35fa9ce14f0d87038e43ec1c1c2d4fabcca003e2f2d724,
+            0x271b6dbd7bbbf9d98a9c5c8814c58923aed6e4a31d7bcf8d723561f5116df99f,
+            0x22594da35eddc1850dc757649b53c126403a907c6113f39e940e363bd2830509,
+            0x9a6a3e13a6aed0fb709786ffc8a7d560642a59f2cee2dc68781130407455a81,
+            0xd5de9b94917addd8b8ebc8eface4fdc044380a27446e5d0170c4aa965b8e48a,
+            0x1ba4f74d7dbf44f967060c619e429485254c8aa06ac08bb8fb101a4c88811cad,
+            0x2bd393ac0c6602f63ef13835a3601f6c4f84f09cd47cedf02ab0a92f0f59e813,
+            0x132cd8a625910f7fa7a999d0338010825c353659385ea10a419255dbc0a3456d,
+            0x2bc9e5ad597c8f773a7ac2dfe21c16a9d5493a1e319dc942e635067ac6924754,
+            0x21af2adf48b95cc677f255d44aea3d1132115782cea08bb82a526366b7affcbc,
+            0x1baa899af3a60f883362aa1b88ea17778e258d3defa44fec1b3f4f9c13b890cd,
+            0x1083673f89cf1ffe18b41d3cb7084270363c519ef6a16484220e30209f83d976,
+            0x5a5be7182497c5c2ec9e91b1a4af88703cb01ea7e7d8dcc535d72a60611f271,
+            0xff6f076a63edf8d87f70b60ac0d64f311eb1771d961b6b33867a6378181088a,
+            0xab810f3e1dce08d5e5289d8d32a3ab20ebe56a1e3f6cfec818462804b0aad37,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x36339f709425b44b4b4158479da0b011c1a67fc8edb682b0a4437607b9aab74,
+            0x25f49340da53700404b20e59243b4e5158b8a2dc24acb8f072504149481dc8da,
+            0x14b076d2ce8f4cb8d8323ec8d743947a7c8fc96f149c0dc4a74d883939d620b2,
+            0x4a6fdd5c06168268ddb9886b5b9d23f146ee182a155e175d17b07ddce7df8f9,
+            0x8868cbb867db89dc7895e3c2c06466e0cd0936eca7e35ab5fb8f63f7a4722ac,
+            0x13639b2e24f941877911b94bb9a0256f480021097c2f8d713c088c628d8fe61d,
+            0x2487694daea37ed9f66185b6ba5700abd9144c18def2fb87af3a4fcc5b8a6b5e,
+            0x62db9b179c1677bf6cd17e9bab4cbbc17a113c73c137dc6664bf4938f723352,
+            0x25d7d897d92a0fafaca382402a1034b20ffde5b709d6092aad0e89ee43f48fde,
+            0xbc883b75255e0e7b62094e1ca2aa65cb2a2dc7c4b30233f6e057257b25adcc8,
+            0x1e902b42eb37ffe108655260991d4f28d286585d6e9c172b6d87be8e08eccf31,
+            0x41a3b254a2c8446d8e99a292e24bc1858eb3d8fc841bc7e1ab03dd5f1c40ebb,
+            0x21f4b9d60cc5ec13b8e87d116b27d89626bc76c0e8ff4caad5f825f158feefff,
+            0x246be41807bdfd90b7cb066201cb33203cfd557d218cca9ccfe1451a86f4b258,
+            0x13760f834ed0e52211b6d9b36080dafe079c30c279777ed992882ede9fdccf3c,
+            0x24e75fe9b1f75436c465b22fb0520ac1afe2cd26e0a2d7b6476a3c9740e1ada8,
+            0x210a9a4b2b1e03dd5fd270b8303f7bf9eb268844761f67473372cd665b1f319b,
+            0x133c572bc84ed9a77b6651162bda90620f004f61aef467671ff8019ca6c09bed,
+            0x1bc35641ed2b845a94e93bb2b89889d0b9d3338d45503f21f1fe9b0c09394eac,
+            0x1ee1cb63ff99f240cb1d5f11c0abf418d696a0b73560afd9302a5119750daebd,
+            0x25e5840c2abad4b937edcfc1ef54894d9556774b1e921d1a437278f8c3386222,
+            0x137cac7ea18f1785a86b769785cfa6d919af27b77d7e1cf07cb4070275c91384,
+            0x2e39652c251cb2e6a89166be880e1021996ffc55dde4b823cca3c305a1836794,
+            0x3ec58cafe270aa7824551c1948911a0412a4985d79feef0324bd63960c6995b,
+            0x293b947e1e6860bd81442b2c2a6fb3ae59375d12f857b5b8161e0f4bfb430ef4,
+            0x2727bae7d504f2181e1910bb7eee349eaeb0480d214fafd019662edc067a1290,
+            0x1be2f1a5593378d6fc1505e59c4c28ffb6cdf5859a5e2e1bb5b49a36051f77b1,
+            0xb1e3d4a0d6e3bdd411c1f8dd4f2553ae84544b84a57b1f09fbdd26670d4b007,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1f1099181737a09a66b13631030982bf438bf84d3715a0bed3cbebecaacac44,
+            0x249a7a0b3a015a04fc08a2c6cbc7787aba1cc983c94a3d5074f584edfeb2416b,
+            0x237bace2c06976c536b56fb5acdd2ac51fb2be8c204834b011106f03eb3a297d,
+            0x20d83c51cb9e2a1fb0a0fa7f32c69cca88e6af24878f21fad622e364a6be6c1a,
+            0xe65df5618a774c899d19e6a6d8f0aad4a10c347b12ac1fcbfedf7a9f17ed09d,
+            0x16ab51042d2c056da53bbedaca317fb7543846fe6fb147279b5872eee7821e54,
+            0x2e2d8b570da9329bdf02f5feb01f2b6e32fb795631c6be29e03a1c0ce31c629a,
+            0x24d1fd499e7bb80cb2d0ca1fd09039bc4cf518ff43725796bc2b48d237c82e78,
+            0x6a96b7d99b2b7a6e57cbb355217ecb8637bc3d4ded1e046783a6d5f63689392,
+            0x19a143f1c5ff5191d99a6f144d8635ee4e4833b0b80a86434a494a6a97273239,
+            0xd4e60cac8694ce18785f94c5c2f18ddd5eea3cb8a70ab4bc3e533b3baa0c674,
+            0x3062c4cdaf43e790dea387e5bb1bb16a167f30e644e5411f9252042d516b8f0c,
+            0x1b378a25d0cd861fbc9491836aa9c1fc169456c2027b34ac1b61a6d7090faed9,
+            0x21cc1b4f8732b2a733b42718b6a48429df379711208deaa65a7eea4af1cc7d30,
+            0x2115e1786ec90fa373ee1a8f50768702b3b89e4c0aceff138ac487343d707792,
+            0x15ce8b9c8e950b1292ee1f80d7e271d3c0b714c1de34b76063624d00a686a39a,
+            0x1d0e917e058eb6cb8ee32e9da420bd6399f8b2297876d84d997ecf8ab3b0d156,
+            0x24d9b1d31cd6eb19c0c63513a6c3fb04a43033968696e954431d00f128bd6349,
+            0x1e4dae551bca600dacc58fd37cac50bf2713052e2a4935d64471f585508f0d9b,
+            0x11b1cc629721ced48c3494595863dee3de1598c11a681412062610ac859735df,
+            0x26ef5031ab96b02b00df512752c7165e368f406857478f18d7230b6e4a1c80dc,
+            0xd83775fafda795718ca9d4777d79b9c4354a73bba6813c415b3b970fbac6e62,
+            0x20be2cd9b7d6dabd4db0dff89911987ab0479dd9c1c081fa64b97fb97c8d3143,
+            0x255bcd5c215aa3bb5bd9e05f4bae4a68e152e3118fd09368fab9fe69e23149d2,
+            0x1947d75ae45108e7a86d0e3e034bbaf27b7fe718451e3a5c206dd5a122a917f8,
+            0x17af7f16f78c7b517171424fc4f47ba88cf15c4224bbd13afb3bfb05df96d89e,
+            0xf736ed6532f0b90d30bcdcec9b05d1c59070f105255e7d60f8d3178e753c5c4,
+            0x223efe61713a8d50c4d8f00ff69c45ea5f27defce0f08a9bc74e7a82084bc788,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x13a0d52fa98cce5cd43bcb4aae2038de35a787f86d375b019d7279a135ce710d,
+            0x57d3beb3548cc7650f10f293fc2d393227dfb72422e89072dd8b90466bb57c8,
+            0x1a6533a65e764adb163780a18df2e7f0233bef0eeb6276895c76a474998afb79,
+            0x1913a71c0e6f8c87f433ed6ec0bbe2e7397544c0dbed7199c5f4b7edceb06a79,
+            0x2266891fa5e56d0240ee9871ad7107c0d740398f8cc9165a1b09e10a2b740c17,
+            0xf5652567afe30f4d5e934d9852bcee7ea0a8fc142b4822d2340853022128fd0,
+            0x5bbf0f89f5ae6f5713c18b57ab2997abd8bc8c0fce08e2047ffee7ff4e8bb61,
+            0x1a7bcce0d63b580b6779957d56f9abfe5aa8ec1fe610e952c4259091046d42,
+            0x2b775827170698c370c7fc1706cd95b8f6c7750f338ac0fcde91ebe40cad9dbb,
+            0x1b9c97f57c84b5f780373eeafecd7a4ec3e065219785272820672d59e985526e,
+            0x1c89b9708064d8558f1361c6acba6d73eecd06c4e4a157abcdce2731cbea3e95,
+            0x9a22dd01ccbf3e6ed2de7d74e16f58edeb748843b19d0cde8756bdf30e7f222,
+            0x2678274dec9c2180d4f5b5e07cfb42c2489afa4673c61f091a5dd00ab0e6018e,
+            0x1400af0c777fd9934b9fa5d1fab3576164ef9b31a6c8be59f72cbfee446aa148,
+            0x2bb2d320c6f15fc80d7c78fd8110e715403df00154b1d275fe6422aae8d68cc8,
+            0x912b48b8c530838be3512cec8d4c210726e17d660b2a726bdb44f686052300b,
+            0xfce537edac05ca8b03b6b472dbe1813bfca33c05fa1acdc695c6e91d60529c7,
+            0x1be4e4888a092ed1691160e4381ccfa8997237e78cbd7ecdf8c12066a49c19e8,
+            0x28bd303aebbdad8a14ee284102ac2ac5e23680287d8c3587a71cc61ccd6c5b90,
+            0x110b79c0bf8f52881c24f4e7598c5f5b30112675a2655ab183be54c69f8a85f7,
+            0x2d17b110312b5b8d233dce3470269203776b47b85d143e1f45d59c1685ccf272,
+            0xdff609373bc4eed749b401df1e7948ce8c8084f4c816844c29ea7a07cdf320,
+            0x21445547b6584627b60ff1364308b6d6d1d08615de63a5c2ff1ec7f7764304e6,
+            0x1ad2606e3877709593699f24a0287e2be54a2ba74f3551ddb1332c7cedad0d30,
+            0x10c695276f9d6578a7bd5c351c1cab9affdeaf9abedfdbac72ffac057b67d7fa,
+            0x100f820a8faa0bc1165b8a16f64ab9baa87fc7e94ee23f5a16125a71cb06b838,
+            0x7bf7f1faf360f65cdf14fa9ff38b2619b616f2913b7403a4fe0431ec15a57e7,
+            0x7b95e787e34c76215dbd3e1c548e5646bf3a061d087ad6477cf962a3cf73dad,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2ec7afda93383730c9043913c6b866c20a5122081a7744f6d6a317b01177affb,
+            0xeceed2a6602d291aab1064254c70fd4113a09bbf3527f603f67f01336915d35,
+            0x284b37b2fd2c4ddbb2bcdd057a56680d46b7d69fac63b80c991f14db1ab5b345,
+            0x10ddbb4173b040104f12ffb5fcc87bf6730ea0c8aee88f9e2c00eaa1a4231804,
+            0xb87d2c0dab9ff1ec96017e8c43bb5281266fc92231375e78f02354355eb0c74,
+            0x255c350cb26d49d41652f9a27f8d6c223b8756f8797c0c960aaf36fe91b4c910,
+            0x2ffb78c0bea2534d67c0b061f4ecb9cff5cdc0bbb9ba0567b35b5434329ce24,
+            0x16aec970d0f171ac2f7183d67c969ce69cf1f4dc73b38e3a72d8adbad367ac92,
+            0x2e74c92c412e2d6943dfb7946c80f5fa9ae87255fcdbb98c437b65f97fec81b4,
+            0xbdb1fbc8b81f57cf6725c95bb9428bbed046d555dddbaeb02b3fb9baa750fe6,
+            0x7bf15085936894c23de42271ca102d554a45b54ae80fa0c7e6d7aa9c72cb65a,
+            0x12e18b956f687e1c43f50a6571caeee8bde8d7da9ad5e5e27ffad30f833eae36,
+            0x2c45b659cd395880788e5215997b77761c46555ff084f24a0d28dacfeecf5c84,
+            0x2805d6c3bf0de9aa5c7c354947020efa9489995e8baac233ddf04e8ea8ba902b,
+            0x18187c330b42dbf89ecc0435f0d77a7cec28d256f65047d4a3e1ac8aa6cb199b,
+            0x2fef8da38b7959eacb7ec6155488836641655c11b8babc8f12e715afff115d4f,
+            0x88011673864ca6778bb97d51eb1f2962b69d07a496b6b7b370cec217c601ae8,
+            0xf6e83f3c55d5fb8b6b6c89e176a5a4f81a3a0acba7113ebee661b411613438f,
+            0x2d59be2aec0efbc67f59da156d934313e8be205c1460699f0e70e7fe5ecfebcc,
+            0x2aa0544263e125a82d9ca1beea6d9cf22b40afc7155bcb0f1c8b1ac23a24f6c4,
+            0x7e3a92c9ebc149a74d4180ffdc30e8ac7bd6598d78bb8f3530403fcd9b12221,
+            0x1827bf9f11d4061c506954039093e66e60041b2c96b8f7e1e4e550582d1ea13a,
+            0x2e147c8ee46a45f0ecc64de8647e833b1ec708269b37f4e29b17c91b9bab8280,
+            0x3117f4c71dc298ea7cdc53dc55f0a15541a369691622934416026bb1a65b8fe,
+            0x122fefefa669bf51b544de5c0aca38753c8f32419b2ece3a97f0232e523f4cb3,
+            0x18e8e58431e6dd229b88f142f9cdff129883bb54edba0854b29a8add15354d97,
+            0x12e0b4787edc9f9d3b12781839f3edfa715accb3e527bb66bb08d355b87afa29,
+            0x2489282bdb046d49227adbf0c44fdd3abf0bb2ecb21a2886336554389d452c2d,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1e2fa77b090a5c2e5f1d37e25ba7d06596bfa3b546362103a4ff19bbacf7e9bb,
+            0x162a1276d397eeaa3cd6ee80478788dad2650b1433b55b07919d966a1b87ce8,
+            0x26eb2facb83a5a98dd405a0e6a94735a4c04c19ad847c53fbf047732eb114fc,
+            0x2b7496ef4e35f11f739db9bd69ffbfc416a0c45512e31f86141641bba04f3675,
+            0x26792a375f1ca2315b76d17b3f2bc3d6a3edc3c54f8ae682171143a91e48f091,
+            0xbff276591776a997acb59a579846525f8fe7634d66c9477f5406b05985e7769,
+            0x20e9af0c21b5cad7c87e554c98052eba561458f8f6b6534c4a1a0d0713681866,
+            0x1f5e270d7be396c13a4f29cdb58c7e4f267423ce2d242c93049edea4b9fb4ca7,
+            0x26ff7c1cf25310bd71e59d175c3c3a0f068a54c8493c401a3b67030922b5a757,
+            0x1276fdeb195702a6a855465cdd5b807f685ce377132b625b3f1a5e934636e59e,
+            0xfb72a4d993f139baa0ef2fb229cda32db7cde0f10c9031ff2f9ce3f2b883491,
+            0x15a52948bb2ee184cbfd9d2b419836e859f2d39291654c082261a8a1986aac6c,
+            0x1a9d4106f5a30c459a80769db1359ea4a3fa0e42cb32ea4ff03c9b800dd8bec2,
+            0x1d9250e3e49f0b5829ce06d877703ee0c8e9a51b516f09df7dac3410d6a7b5d8,
+            0x2524fab526c690d264888df207397be10a2626b71e97dbc66d1928e358bd243d,
+            0x508f820d3a3cb5e0d30b4a9712a99eddcbd3adac2b1301f123e1556e975d30e,
+            0x2ef65d57e70b07fd0a22938cf1065e3ac3996df77e0c100d354eebb224dc449a,
+            0x26b914f529af1a7e31afa5334e60374474b998ae18e99efdf19e40b2dedd49fb,
+            0x155837584dbdbc23962e00fa5a6115c10eee76681f25c51280a1bb2842d8488,
+            0x222e724b780a46377b77fd83af70b53cb39a1dddccb0eae70e4d5dd6dded8da6,
+            0xd050bd15578fe41175ad1e75a8ad0b27fe8943d894ddd74aed4b463b7f02790,
+            0x5c5f00321782b3d2fa6fdcb67fa63d1a00a9f63d35f4ecb08481ab535907d46,
+            0x207a0c370129f953e15836e8f91d7fbde34553f94d6b899e8645c96f1731f098,
+            0xf875acc749b0abfb86f3bac9e8a8e56be9b9b55ea8815d19bee069150d27fd2,
+            0x38a70dd168196731fddef341631e16a97447553f924d6c204d440dfddc0b1fa,
+            0x1502b8a3411c7391414156fc640e8a51a1171ad07586bd6de2be2e38fc6486a8,
+            0x7984908f8931b938e16c96dac3b58d151c4dd0a92d671cda98e16953c2b7f6,
+            0x694d96a531fe9e369427b3457bbed265de03924ccb0331d4bc445c4260c551e,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x17efc478730ddf82a8540cc83c4770636959f1b0d8cf438b239f60df816d7519,
+            0x6d6d06423d66562ef9caef0773f3fdbdced70fab47b0de7876b7bfc1216df7c,
+            0xc750b14cdfdecf7394c6039339cd465a8a010272c1bff8c9190ffe3f0018d7,
+            0x15000d48d85c719b68db8c9ed7e68cd481437c653ce647bb7c965ef9fc1c07ea,
+            0x1b18af3d53da20198957288dca6a567b798666bc14c13dec46429100e01f94df,
+            0x16e129dc67d5c08c79c6fdaf38def1b90f6257ce0017488b42ed2d46bdec04d2,
+            0x1c958e9abba1ec33523e756e8be1e0fac90cf1ed314b37d21a7b4d3c84e574c,
+            0xa4487b4c046d0e836db729d214a2b6995146b527ea42d9f1b1008d321a4c7c0,
+            0x169b2c93aceb1182e58c94204e285380af13476c86b6c6ab3c3a65c15fa21c4,
+            0x797bc2c0b8e08a4eddead0572838c237d0d825e236b725ef88269b0eea4d28b,
+            0x2179889dc88d5096ee6914c03f347b9d9e7c5cd8c8b9930b5faffac69478b6f8,
+            0x1057d99f4e9409dc2a83b8940d79e8e1c8e9c1b55a2a10f4261575653bcc89ee,
+            0x168c49e73137bd006b0b0996b3da6d2562db2a94f94a8e763ea36f950c0f6342,
+            0x588b7dc72c564a70347721e31544dfac82344701d29b12bcfcb99c951165ff5,
+            0x30052c56471167c83d58a970764a1bb51f602f45b8fe42494182d48386d19001,
+            0x284487bda08c8fb308bd9f50b700e107e82ac7ecc25ce91362303a2a2286af92,
+            0x2e1e79d879db7beb9259bfa882fe3a1a34345451b230d4e27d7cc8358e43dcb2,
+            0x1fdae630269a40c8ab1a64d8fa09af3a160bc7ec218f7aa5ebca2346c54590da,
+            0x1d6caaddfaa7d7f98b2a093524361dbccf489a6d2bcc0ea1e2e13abcb025c83d,
+            0x5c7c0b2bea90e985b2fd8c7e1e9801335eee69801dcd879edb5101739294534,
+            0xee54de6bffe8629a8fef48dc9de7a50885054a28dc85c6649c42abecd607dc7,
+            0x93c826c2837f20a15a7dab825f873ca79fee1607b2a1ed279d561b346aa9e63,
+            0x21c75ffc19ad7b92256ac9ecba8768feb4b6eace676e2f6700c87b8ea6867341,
+            0x2dec2f08ab0884ac001557f139ba7305a30d8c342d4ee53e4d4e6abe61879023,
+            0x12612b1a8d7ce43e1cba045f5c0ff9cd61ff60a4df948847a5f352996c0150a4,
+            0xd0bfc972a52fd760da54a5e78a4d47042f43be8ce046bb4522be2beb644dc8a,
+            0x1bce51a4e501309316d08e24fda303a3f39e962cf2776588c22381009c08298e,
+            0x19e6822defe86285515bdee389f08a4cb9e8042ca87435a47443cbdb76d30814,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2e931e74616f42a131d4a8b56506fbff77845d8bdd66420beb3325097c35d2ae,
+            0x12cb5dfc2abb8252e9ff46727444ac95b3ea73f0410424424488e144f8699673,
+            0xab23891e07d9b14ab6468d8b54083479ddbcc3aa385804af4531058b6f52f21,
+            0x76c297b77611e733d1e889aa59629450dc9a47d6b0f134ccda083f436d85a5f,
+            0xbeb7545c1a73b517a6c89f22ad332b7e343bec5aab4aa67759d1bd5c513cc8c,
+            0x4c7d041c29a50e697120f25caaabd6be874d81442d23142978d9e30a18fcc0,
+            0x564102c95e897c7df22c2a4ebd2f41df79b27754dc83ddadc1e8fb5011bef46,
+            0x2c05ce35ea49db3699362c4b4b64a5ba68cc375ad8aade0365ef5421901a5a94,
+            0x1656b1dd63124d1354b1830de366e2c3e19075d195f6fe6dd5b28a599f37dcdc,
+            0x2507b36b6b8e24780ab4b7be3c26ad57c16fb9da2edb33c3f1dadf3ad05f6119,
+            0x126e91f50c4a00292aef54cd15052c4bc6114e85478479b60318e6dcca5d6c32,
+            0x2f9ab42a46ccd83e7a7005d4553ad3414e5211cc2730424122170c92769905de,
+            0x25aeb979b8ba4e466651dd441683325ca06867a60d27d0b51bab47a73ef3b303,
+            0x1856e09404e55249a6d7114a4554ed94bc09dbe373ee994cfe64a06a70b2cb46,
+            0xb6edf4c57e87dc5eb7cda564eb72f7673631ed91a612fb422487ad732be85db,
+            0x2eeb7ac6201d76d7272b2b8861c44f18045fb30837baf0040fe472d972a0051,
+            0x25e7df19e834ef4fc02b6bc24f1e45c42d935dc8e324467f216fb7456e344584,
+            0x22254c3bfc63bd575812867c85be048ba6f3cd2d2b600594703450a16ba7b35b,
+            0x1f04d9141844aee56a08a3e8b056715e347c668ccc6f1fda6dabf94b2a077531,
+            0xff41228c1c85b1f6d2df6e37422bf7ed8b7dbeaba7da63f6f96bf9b3a525fc8,
+            0x286cc1fd10f3b5e4d3b48d6996d85e284b6a6b215c0b862d5a29972f6ee1b681,
+            0x2cb3455b4afc670928e65d5aa1461ed1f048865f31b87ff6bae6f1b13303a69c,
+            0x23dd832c9d5244d3f7d185b3e8b3d759c11b86ce8102dd3811fc743e62a44dab,
+            0x128a2af0f0d1965fcb13344373cc1bb6f4fda4a5c28cb7eb31fdec881348eb90,
+            0x2b9f84c295307fd52151b60b7b676d157ecad172fc2a8cc89f8dac7dd6696921,
+            0x10a3da81ead6ed37cb8334cf6c7d65b69862ed22f485b092bada3c0e516c48ba,
+            0xd34d3d1a4e840d8e2cebc5d527a72ce929fdc7ef27e482a0f029a7b8c6875f8,
+            0x5a6ae7b5423c19aa7ec80748ae9c1f5d189935cea5723cffe87ee7ceeea8c04,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1578614d9a2967236aeda5f4a4dfff54693efe351787f006c743eb600a936bf2,
+            0x285c79334945bed5f5c307dd65410ce6d6093d95dca5550146995d79028aeb09,
+            0x10b5fbbefe482164a1e9c30bb4631861a12476186ebba60da59a8172a24fbc4e,
+            0x1cdbb43b87d76d420ff6e1adef1ade355edf97a1646107d44993af476b78b98,
+            0x19733eab4c8e4779cc914f07598df3bb1c2aca04fbdd5a116f864a85f7a81fe3,
+            0x3009eeefe893a6b04a2d51a027b63406170c305d525e5b959e057825757a8ff4,
+            0x2fe6c9de6a79e7bb2342a0c0992a9b8488b4bf43da0ce566e53bea4bd24e6018,
+            0x2d40f2520a5df3a80ddab03db8ed7af99ea054e3a159c4a3fb6fe79a769b685c,
+            0x22340e058329ac548f679421e17152d6106de7393cda87a9f7351cedd26408ce,
+            0x5609d6cb0bc2a003ef02b3f62902f51b49bbed72fdf724675ede239432cdb29,
+            0xa4481c88c41e347a2ef5fd6b915772289c2c90b91b3fff301844dabc1c51cda,
+            0x14ade810e267932c4023ef6fea6ab0fc56063c5740a256c89e75a17264fa2898,
+            0x199252b794492b2d35beeae8c1411bd1b5177e17af65c6f86ddd3261c2f8999f,
+            0x1ef0142a7d35ea276712c1b5b86e1386201c18e3f774321cf69b6a0d2ee3f226,
+            0x24cf18fdd7098067ebe68731ff580f7c01de7251814a4666ff518222130aa2f3,
+            0x1087f37b188ac4ae2e05051a05b60e0579df8f4223d874716a6c251ab62e5b0,
+            0x1f0aeda37e4d1e81150239b71a4cda04f0e4d8d7588ce691721df28fe9f18c61,
+            0x1184563ea49c28693ec800bf53d6100048fbed518e1317ad922c095d486778f7,
+            0x28bb14de4caa8db804e9cfd9e92cde9011c829e5cc88a709d1761638c88a0593,
+            0x5e1f290e1cd58efecd18bdb15575356b84677a59c118b465b9671f81639783e,
+            0x25f7a0d0ce8b40f8b02ca63dfa95a68e391df9f6d24180cb3cc976b4ce04fc11,
+            0x480ccb16af84b2184c6f5b529a3d8f444f83dc11781a106ae10da23f61587ba,
+            0x539296f5b7b7008de45d5c8516fa99db18f1a822529d3266f60fbb9959d4eed,
+            0x1e424153fac06000bbadc168cd28c2456abc7b0be95eb89d8dfc7b9bba75769f,
+            0x932c03c10fc912a134329f330f819e8d619aa8a9b6f52599e0761ba32c60e01,
+            0x1211f6c693e1d0dea72aa0a0c505dcf1f9fd56e16545cae0818d554937473906,
+            0x423bc3cd7620b919908d77becca14373a0fd5e3e9ba4470d967da7ee65479,
+            0x2118cbee96964430e47912132f0d6f1c2e6fef1c001c8f55ab591052123d04fc,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1f1e2374f0f17846133ddb87fa54430c6c3ddc9c532111de01eda3684f397a94,
+            0x208b76b6732f2ed681d8ab9f1b5c510c8867ac976a3fae72d5f9d88676a75a7e,
+            0x1fca7fa1aef782e5f42195a7691e73b90033df38495b91e5c38e820426446820,
+            0x17f136e334658510bf76430b18584795cc8bef7a11c33a61b5259339acca3353,
+            0x2c03456c81a5e2e32aaf6ff4f1d5720677c920bce4adb99d1d89a60618da2320,
+            0x1a5ed510e6e51803fd72011c2d6de4c638d51c6d9a57dee093680dc336f5d34e,
+            0x1a936bc6777c2da71bce31f6fbd646a3d62a815680203edc66acd1148132029,
+            0x1b4a61fadb468df53bf54dc94e9a1892f69e693a26623b6c768c9b6f08eb260d,
+            0x22072ccc189a669fc9c1dec178dee22e6810db51fb07d2e1c4aba223a89f25f9,
+            0x1970d123b4ed8e8bfb50c817284430e9349f042e456fe5d518f499c071f89430,
+            0x259064221267af8baa25e034c726164172e8ac0889f3d62d29ef05acf962f9b4,
+            0x2287530ba760334e46b1a49861dd542fcf4151293041712c8544a467a9071ff3,
+            0x840062bb032fa90a3eaad025fd47a6353793130aa0b8626565b48035782aa66,
+            0x1d555f3bbdd6465b30b7da0ecba9891624d6d041bb781264a89aa7b16d346c0a,
+            0x23d4f39d8b478d9f3fe9c56850eb091e6fb14326aa5cbc9b2b0d7d87c283d763,
+            0x2901b8a58d07adf7c3080c1a36cd9d70652aea9b07702d07ad0923d758cdb949,
+            0x2d5fd10271ad1b7fb5f053107e3e769cd3509ed4d501be13cfa1421b5394605d,
+            0x207c3b106d337e3362d760cc41cdb5be011fce738e5f485d2b46b93c64cf9b83,
+            0x1492c0ecb1dbcfa1c6635de3f6b7d9eed6613a602d44fee471a9757bc7b42898,
+            0x1644d335356808c816d04419514ff5ec328dfb9ddf78e623cbbb6b20b4ed3bea,
+            0x2fa67fff02c7d3ca002389d54c6efc4687da94708f6e27d1bc5825f164cbf4a,
+            0x21e1ca08175564b26d688202433c40a419bdaf250b832229f4a1f31e8ace5464,
+            0x2cef2de85c29234f8717a47931f3e7e5d26de54c4009f0cfbed5742defb3bde7,
+            0xf9101275c6d82c585bb03708869626a1b0edf857aa536ba105733f0043efda3,
+            0x13d2ac8ccf60c75462050c8f441e1ef92d1b9a842c36bfc82ddff6561efd49b,
+            0x23a7cbaee856630abc2b423732eeebc1ec3e071391d03f9c9b51351c67943e5b,
+            0x2d3d1ee5d3afda1af49ea526d8f250430e61921b93adf072ac5202b5fd8d0f38,
+            0x2c40a0792e0eec8a8ff8b91a36835ff0774e11e3f13120c7a6a0efbbd6ef1f0f,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0xce2acb8e9575bad440cc92c82f19694f1ef1e5f0dc1dfc83c39ed80919709db,
+            0x255e8b6bfcd73f20e6c4bd3f61ed3b8bd17626c5e5a843858093a7ef55eb1d61,
+            0x71756e3a68459939af3577f77567bf688b996b47f0003c4509df83345846c16,
+            0xbffe3446589b3eea6ac107b311307d20faccc7bb45dd5d6849cfdf7ebcec41f,
+            0x18787bd666cffd2d76b9b7344eed8e34feb8f96edbc138486fbba2cd628ca4b0,
+            0x24dd90cfbf38861e307d9dcfd5507b2298bf6b2618fa97d7e36b07690fa7c13c,
+            0x1410db3d1ff17500d908b029552bfb5c44e3cad85b44d8b7070a60c359be7abe,
+            0x114c5d80f6a4fac9b3962788dc0c542378352eb593c0cf88355d8c8032efdea1,
+            0x1faae4eaa27310edfbc782b40c6ba0969779c813807d81630b192d053d4d5c71,
+            0x1c6a9217a08e3d6b4961cfc839d6e8218df84ad042219111f80d068524566422,
+            0x2779a31633b41cf11d988b3560faa03f2fef06ac2b58f88d89fc5f386f28b6fa,
+            0x1fef33a133dc716d8477f6c00854b9bbbb087ad39704e2aac12ec22518ca42c6,
+            0x51d3217b934abd02e647c9cf0f9642b2c35af886b2a45cc7b50fd3268175a65,
+            0x23e2976b87ebf7b64a5a3aca1926bfb61744e0f4f8360df40500f479e052e17,
+            0x266d4f55ce9e2183ac237c1cb82a138cfec9b415769742b2feb57d27eba7027d,
+            0x220ed82038edb07e0f74092c809db76ce01adf533a42b51200f67cd58bada0d5,
+            0x1739b7715b95db81ac96c21ec1fe7bf0bc6766b37d0572066766e34ee44500e7,
+            0x270da5e7651be197e4b200aea12cc8b88c633d4086a0320fbd7b25ba6bb603cf,
+            0x6f6db411a03949e6bb5c0a24f49967f1eb39c35eae012aa873ea0b3447d6f5a,
+            0x117a292cd83ceb0d341c01e65590f4b38741c3ba51c0d717d273ddaae5c59cbe,
+            0x263e482df03f958b16c2130b9cea9b74b47ee5d7f070ed5a6ab849074386f863,
+            0x2803f7d7e3cbdf5be9306a32a90b58cbfc5490d1d74609cbf6384476b29265cb,
+            0x142c7e2c2e91322de905b8420ed32d6ff157d64e792a38ee29cc9b316fcea3c8,
+            0x147d7bfb2d88839714acc1080d935f9c289434d5d0af4772699bf4732c13323d,
+            0x24bdce338ee348af82a60c960800094d5794d7a2607d5f3ccdd1fd4fe7b95583,
+            0x10a0a7c38506d41a52e6ed0c4e14dc1283848beb7de73e0e92d4a065121c25e2,
+            0x2f5162740cafbc5f21e10a4eaed36ac331b046f846c46a319b54d9e2206c892d,
+            0x2c74369be037f8a5d985bf78b1e89838e0f7c1aa845979b6c5142747a0bc6b0,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x28580a3d76cb8ac7d4ded32ed3b70d34ba761e0b09803f10d1196eee812c8e69,
+            0x19cf15cc84de7c87a59a44d02e83f88120bd3f7d1ab07ffac878a17320f4b2dc,
+            0x21ffb716f9f4688f477d2b03bfb4c4f57fc37c75b46f85ff3d8da6e028263594,
+            0x1c5e5652ee5c51f74663b5612d00e002ecaeac6dfb26d143e8f52a7b62c81346,
+            0x309be74d7ea79ab9868e691afcd53fdd6591a5c8cedf965a1895229eff54a7a,
+            0x8533bd365bcfcca44a62b4a3d7e1b0963ba990d5bc5577aca90f3edae8e319c,
+            0xe7b927fe75b3e3322651fbdea1e01e7b5b9a3022e640476d39738a016e11728,
+            0x2c044e77e1889c9f2efa9d217fefb1003978eaec9d8c99a494ca9c6bae1e980d,
+            0x16ca28c9c6815d47c13eeb8a6baee797a2f9fe8fafccd65bc714c8165737d172,
+            0x10e2a1c88ffa4f4f58ef6974b6f612c37755a1aac408008ab7b3b47160925666,
+            0x2af08e42bfe36b6a795d78d34a4d4bfbba27adc10a144920d5709fdef7977301,
+            0x1312b9ac40cedcdc7154c3a110803222b42b2b0d944ce7308a992074c0fdc257,
+            0x1dc24b75a241225e913226bb4e43d43c7d47be4def03fd1b569eacf726f4ed27,
+            0x13d3a4fe3528fbe42ec423e367bed051490e1b014ede6b776b07d8e15509d882,
+            0x32d8f0cf21c697ffbd788f3f63ee8fdc1dcfd3ab649b39cb5e11a6bd2a24d03,
+            0x28c7587692973d407a133b2fb5502ee9a51a4671568fcb05435cf0b5fbe69ff0,
+            0x28e40378256e3cbd8a7f8cafdbed2021aa49f01a7d7056858bd3eaac1dc0538b,
+            0x25d943e06d1e141cc39bf61f79e7af2d71ee93b361fc7237a2d9a8abc986056a,
+            0x17081444189ad527d5b845af2a97df8c7a4293f485b483f9e8ed7021102f6443,
+            0x1c79729fbddab541d2ecdafb93faac1db19b4de80d06b964cf4cdc81e1e6da71,
+            0x45619b6eb27ecb55a5fa865895e4bb27712f4e95a84af9bd717b58e500de857,
+            0xe2a9db5bdf2e81d036943df530d84e17424ec54f39c8039d37dd85ef65e3dc8,
+            0x2ce50979f6944eb44498a1265db4d51ade51e18ca81bc69c0324103cd4116d6a,
+            0x2a77de1a9d04ffe3b955ddb3ca44d5cde5ab83aca3057ad21d2275326fe032a3,
+            0x17cc644fba9e3aa9ff2cb6b1386494c67079d7904d5d02828a84f100798d4ecf,
+            0x231b0e5dffe1731eef0342d728926ae7c9d14cf32b1873115a3d47b231dff70a,
+            0x2975aca67d081b04e4e00d824d5007a02f47891c5b0e6d74fe4bdc36a2c3dc35,
+            0x12dfba0cbb1703dd03aa3c6e434c14e50ce09615152380a14b97bad4aec1a8d7,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x138e38994513bf4cda526bbb6d9a7ad3fa60bbb5b8922f3fa889be7f81acc688,
+            0x233a737f744a6f8bf1fd4d3099a005b4783893e8203403271ac14116bb96bed5,
+            0x1c8af617088b03edd11e2697f3f1d61aea527eb312465a7d1d97120547e5eeac,
+            0x29e028abd359a281cffcf8e6def73b243c8c0b7dfc781fe16d85c9636647b689,
+            0x11cebc3218317d6a3fc99fa24c0297c3c917d2c79953fe6b195043c1ef2a2911,
+            0xd9eff7d690ca6de96fd8d2f757fabff01e7cff5f9af21a331beb5bf3c2b1384,
+            0x2c10ae179ec436144d591b58693d48867a3080302df8f221f646d00519233ac7,
+            0x195340f99f3142d58a8374368ba7b0aabe7551bdf4c84114c543733fd41633a2,
+            0x175a317578f2686003214142b6ac875027c021572904376694f8469ea2da5c31,
+            0x16ffe892781788c756069f60af49a1edaccddd1252b0add84fa3850c4f80002d,
+            0x82ea1876cb380488c70f7cdc9cbf6c494a3dc6db449b27b2ad55500a9132673,
+            0x1cac7d7d70279321973432ff45248a4497541d07c9a2b26eac2938d661eeee13,
+            0x8755249140b336749da4930b6a82f6f7190eb05c7daf28948aed60049d00f71,
+            0x207de9d69726515af8d068d0d26537798246579d29ba32be2dc2175e53cdd044,
+            0x1405eac8634a44a35197a6503a005446b48e7f415210523162c39a8a8df15829,
+            0x22f87c997cd1bd13a3cbb02d3d534c897528939d9e6714fe0c611c673d67d86f,
+            0x143d40dbf8cd786ae5b20fdc9242fceb6224b64c187b36a7ca66489c86489299,
+            0x2fde0b770674587f1be3feb619b4276125f643518ef715e694213e3134b7773d,
+            0x160ea6110b10e9e3f0d14cacc486c0ba8f9bec3498024257ca96c50b2d2dec4c,
+            0x15b8418dc1c46f3f546d70d983bc32122e40682185698f7f567f13590a1ace6a,
+            0x20d9d10cbe767a538eca9be227274944094b9e9fc01b61b657afbdf6bcdff00d,
+            0x104952b13891c92a6d7f1c5cba983aee4a3dfb31a1772d99192ab343d4e8519a,
+            0x107209e0e414a0e40dffbdc7b52e2ae3de04e4385a8c810e92ed2bc2f67411e,
+            0x1bbff156637ba8444d8679abf776687b8dc2462d876f17229f0d0b62b6eaf9c5,
+            0x61f0e30d8aeca231af662496c1a4a5f4c6b283a79ac0e01bb677cb14fda83e4,
+            0x3062b61d13e9c6d61471833d8e6b52f8669578314817ac28d650af7512e2386a,
+            0x156a1c93bb1bb19c46f2d621ed100918d9f3194221788493be08644da83e4aa0,
+            0x1366584ccaadb9ef95ec40f53e9cc7905204400b52fc6b9c0d21672fabf65753,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x727060f004a12682948595634ffb74c7351aeb401f8c16c31a333c8638cbcee,
+            0xb43e5d620c5f01be5a5a3193bd458a6ee196533aa8fea3efbed64a83ef2ff93,
+            0x711911f15ad7134cb9ff97051a0f73f346b4be3f9754508ffad823c11e60415,
+            0x62c118ab0b9ee4f81d12e70d751dbff7d7047c895aec5d87b0e1dbfb311f9bd,
+            0x1edc90b1e2679d7b61040b272d2ecf8d471417e3df89be715d5a85a6759ec37d,
+            0x2bd026a17123ff82ef6a745e786ce3b69171c73f00a518889c320675a4a31824,
+            0x18b9a646b8279f3242e40800752742093df705aefdc130e903026d7e6f37711c,
+            0x2b6d003cb10653085f4ca141b8674a257140e4ad022a6e85a5681cd3f415f3cf,
+            0x29ca967040bb4ef6fdec0008a3a1821b9a2682629abc6c2f37911be83c4d7b51,
+            0x29c5fe585036f56f24bf281bbe3891d42d867ad8df031759f34586abd4341cc2,
+            0x18250473c36c6b2fc023d9f980e9117d2b7d815386613cf518a5d5e1cd98fe8,
+            0x21ecaed2c0849f445ce370dbbff7a0f4e3ab45444ca614ad818856b057d0b559,
+            0x50f18bada3b7265d2194dcf45262069827248a1f68fccd800ff0c8f498fcf7d,
+            0x1056d0bf8e1c158a403fcba81d1b25ed10ce7bbf7436a0f82af53417d7758da7,
+            0x10ec2167737c5bf2fe50fe1c44e562a4fa629576c43c31c2a067d3f7e199aec7,
+            0x78d695069c5a1d37c71299f3f5667516b76a4507a4320117ed26b3b6c05efec,
+            0x302b34000b8a4c5f411458a6c12a335a1e0f345bd012c03e9afc62c8fc07dc72,
+            0x25110107d94ba32e47336fb64a434e02f723e7a429eb23b8413ba03500c56e7f,
+            0x239c9ad23c9efd9a7be7489e4a1240870a605c5b8e84021f3bace86281f5fe6d,
+            0xa71eb71ed1cfc23167804f59bf51324c69d188602e732e5cc5a6e3f73455033,
+            0x22f12028dd01cbb90141cfdf5497ad73403416e437f063e1ba391cc18bc0bc5d,
+            0x1d2ad4ea7240a2f71841635c52eb7a7484cb97abd94c70bdb187724db31c953d,
+            0xafc6833626de473ca08a5538a64a06cf9b604242f029c4ec576ba6a1376cf97,
+            0x19e01b3ffd3d1c30017cbb3ed8dfd60838f70e001773558fc4a1c9818bd4c197,
+            0x26db05b80a904a64db20297cc63e2d0a190ec9fcf9d528b9db88f7e079ca4d49,
+            0x2d8286dfebb09365859e524291676812918ebcd2b5e25131884e71037a5def72,
+            0xf3c76d71a422101870aca73667ead0b355e8f9a8009aa29941293e5cc105d,
+            0x2c7142225dd5a38f329349d4bed6e06f58baa1c3dc32a6abd057bab3a45eedca,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0xd4830722141cace7a3d588567117cd756deae9d215cdec0d2c55c7dd293cf31,
+            0x826bf62570b5a5f61782845b349810b7a481153e7ec33bb3667e4a2c7ce4912,
+            0xb74da59928d6c22800edc212200770147b8fcbd5d40217cba2c1ae784ac3c66,
+            0xf5da0d1390cf5d4fead2ae4e463fed71d0b1d5095428572009022a7550864f1,
+            0x2704d9998e1e17d5a61ea377b1b78ed6d7ec951afeaff523a406624a99447c04,
+            0x300f822aa4b956ea43ab45b043adc967d41d2f7d67445ecce1bfd3259e62df82,
+            0x43f2876cf4a9b33af023d447bb90b634b37fd6a432b920e2dad4fe1b9f734e3,
+            0x20d982fe655c37b7c046a07110e57fa8649939e376a4fd1bb6bff3f13f88dbf0,
+            0x21d6cba8317dac264ca383630b4da90214d803c503ea5520c5b44dffe2c138dc,
+            0x873018963b4084347ad81b085693cfca0345ab963f656890c90882cfc5dcaf2,
+            0x1e6176f2c8c0e6acb5b02f4e54d245f806b9fa7bc126b3435b79e5819fa8c9cd,
+            0x21d440ca5e509e1ae0476ae546df34414d7abf9152806b4c799177b87b153f90,
+            0x85ac321a5407d7ee948b0cad303f92751532cb1b55ff17e7267c0c9821bcf80,
+            0x225fc6208bc12aaa5deba3688931a2bc8617e6b4ae76c1de0e85defe38e2f14a,
+            0xaa6847f08b61d6fc7ea711789b76255d14b6ad7de89124c962fe57f534be98c,
+            0xbb3bf6dc922baf1d7a9f555396d78f31cfc3cbbc534c016ba6879d02cf400a6,
+            0x24118b406a39de6a222bbb99be1828f9d70c24cce6ae452b20644f3a6730b95,
+            0x23f88043dcf501f06a9ba388b05f1c14ba29078b978e7f9a3aba55cb0bf1a7b7,
+            0x1e9ff4d090215f88d9af53bbf57282d31a835a8a052dbb19b5c0b366b451cda1,
+            0x26ff7979c38be718b092842e02cf124d1cec12b426a5ed8351b832385ddee404,
+            0x62eed7ae94588f149905a7d148f763c8422e7e0b6bf5cf5ceaf80f7a0754fc3,
+            0x2ddcb93912364f750150441743c32dfca87fba3bcfd285a5cdd854cc312a6d7f,
+            0x1a61c812aa97e5dc63b827db3b987d759738826488abecce0592af6e7281336d,
+            0xaf260c0175dc1188ad11222368b122a1f0cb5f71d5df47517f2190748f803ce,
+            0x6c547f8d368f03ec5aa00693a85d2b4cc56aad88006aca1e46b1eabb84a5d54,
+            0x15a040ea72ef3252816f453da8dc97a9b417011e9a65b0a8606248591e597199,
+            0x2e0ae86bd039654fcbf8795450a36958139b3e0941b98778395b8ecbf3b40e84,
+            0x71936ae5ec7e0ec777485d9400a8c414ce233e07352a9ce683ae41943341c9a,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1fc8ace75c85e6d3a7404fe02b03139b6a67dcfe2d14f7af11cc30a2a8ece33,
+            0x263815b2a80b71e1222801ac39bd44faf23d0e21d2f31fd213d300689a720d8d,
+            0x1a91fe38ad898189e9dd7ef77559185a79d80481808f4044daafed03742d3ff7,
+            0xb99a6192c5bbf619624d1c7cc7d90930f1ffb79a6d4cd145bdb58a85f35e324,
+            0x29df5b722979b8c9c63743c5d997b720d1f938edefd5a7359651bdce60c352fa,
+            0xeeffa5c228914c03da9a2eb5fc92f23254bcde82c459c81266223e6fcd3d89c,
+            0x2b3647ce374ceafb0ee9c4f5ed4762db7240d45a5b01f3873f2a4c8b86a68be5,
+            0x21e2872db7718e97286c2239b5b721a58d89ca37d43dde81d5cf049477dd1c74,
+            0x173909ac99ccc3ecd1ab2fb89246a648ae3abbe251ce9c0160bca5712c0626ad,
+            0x2e2fd250ad31b0f543e958e16c10b3cc9e62e52c1a40ec5ebab4061d3880dd32,
+            0x2dc7cd826f2f2b963a180b5a0fb1b5d20d4a7cbc860679267142a707c6ba48d7,
+            0xcdf628de6b0bc2b35d3f9a0b2cac4cad27e7e1966c39af983d63e1461592bf0,
+            0x2bf2f603e91d6eeeb104ac9141798accd525fa3e241b1182753d4ff3f59b1630,
+            0x49c9676b595755be2f328863936312442c1c07504c5bfecd793e1eba7c3f675,
+            0xd1fd4d6ff542b060b3b90ecbb825f0f890820144be4bd0334a2eaf8339c9af0,
+            0x2206a93fd04efa7e79130c0aac582fa50c5ca7dad614331281c3d49ee4c1c67f,
+            0x1b8b1f32ab840765cb6250f4c9c019d994fa5858c67bd585a5f4a7663143ecb0,
+            0x55cbd5d71b787fb96fab44c8c6a1eaf3aea505c675c32f608ae0b6ae2e71319,
+            0x24a63962fa639928e90311ce846f99b35213568b65cc1db5fa65555a0141ea9d,
+            0x2d41835ec9c8dc848bf62b784a9d029cf7632369d3b6e9f6877c671495831bc6,
+            0x1c3ebf1cde47404db2c523c680ea3df60668ad37b67fe50298c632b77bd3f625,
+            0x4d92032856d1eb29140d9825a6cffcccf00f5fea91b85aaeb68d47391a67f46,
+            0x13fd59cdc2da8766343e9dc78d0604c7a453c4a4639f1e1f66b154605dd00cd4,
+            0x2d56a2d39a3db620d7b172bd74553d09cfada80fe7b1f2bef3fc4cc115f76123,
+            0xe8cfc663445dc81cd06b084d36c85d946c6eb49871add263ce14f2b477ad27f,
+            0x2233e0d00be5b7a77da192a5fdd91db5f196705ea0754e4bd1db5a357b335092,
+            0x153dcc887f5dca8999d51ae06fdda165dc03e01c67bd8790316bc465ec4b961b,
+            0x1e3ea34066a170114f0c76573452033360809012bb9ae4c24b6c1fb476d5d5d5,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x6662bced08b16d3d3a50c9dbca0743d66c2b0d5060c68983d8448ba7e09735d,
+            0x207357fa70e47358e4df94e0fe2860bb2ade565460c2f2ac9968718b512fd761,
+            0xd88b7243e4ba947985ab06738bfdbcd72be75c0539fc2c65e016612cf48a0a8,
+            0x29032f478c7b5fb111f8d32720abc1fa050676c58f783bb6740b5876211527d9,
+            0x1f58b00a5be5baf9e1da120d8dbc12a767e304eb63c0c05528efad2b95f6d010,
+            0x5645d027e203626b8a8c15707cad7f9954b915bdf620a343812470c63d6fd5,
+            0xab572420dfe8794515a8ff4fe71b0838d46a42e63b488bdbef2c6721668758d,
+            0x1876c13f9de5d341e254b3d2c4bc8c272e270b58c863ffb16324a178986dd709,
+            0x21ff416c00f6e478e470f77aead4decff3ab847e058e66bb56b1c75379d67d55,
+            0x104056d5d775740ba150f6807d251607c5072fcb6d204b3a92646b76f97db4eb,
+            0x2859bc2f280545367b3844134b23d2fb6ca07c51c42eec18800cfc795464ffd0,
+            0x232f777c06ca70171d09129c01814b57a685224a3a752deefde04487f731dc54,
+            0x2cab0c414d906b4cdd83f08fcd68d3b3554fda8f17967c89d0b281f9e6e8085b,
+            0x291dc030472a4633fe37225419e9e26ab406b12c6c78b40bb17a9ed3af85841c,
+            0x11b3be92352e34d0894a108302d097e94aede2b931b40b162b6792f127d0dd51,
+            0x1821450cf9950eb2f0ca14ee17385735c0c0f6b58ecfb4c341732c580e15289a,
+            0x2c7185a2965a3dfe86d2f88a14e66ff3cde5f1a4072fdc5e903a5367012d6bc8,
+            0x19f8b88431be608148ecc8a862b043c66277c6d244d4bc9b063488d470f91c57,
+            0x2e07597ce199e34f1a907e135ef8c7f1d43ae46459065f5ef56dbfada7b14086,
+            0x20dd50883de922f31411aa269a38a809f86ae985da0dd572a02b0a115e57317d,
+            0x1deb58e4db0e059b5e4233a27f3ebfd5c56fb7c8a2e0952870ff89bd985b7fb8,
+            0x772b8311e52b960baba8f9ccb8d74d520f5653608ba810243854ca306e9c5ac,
+            0x26508ad8ff73d70862d1ec04e406f165c53c04a0c3e466a11a2456656a2008a8,
+            0x2e03dc18ddda2eea605f357d82c0a7a9e05f74d078d0d940a0e7506dd7dbb2b7,
+            0x2651122e5715b7d5d0d396b8b0a6b3b219e1b5c95a0532623d9976330dc0c7a2,
+            0x1d2fa1a7f55da05e2e77eb2c7ce09b4f4c0f832722262e7e57108223bf2e4a75,
+            0x20991d3f8eb785ca08fbf1695aa09c0664465858de5f63e628cfd6dff4dfa7d5,
+            0x2ae4c4986606935874c81b044f450a6ad91c1c6aba4670091cf83dd34d8bdd45,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x22d5dcb58b751b33e61941e034ec6a5da20162b44a67f2f2c2a32fb2bb19efc0,
+            0x18a2197cf988fa8737f9ea1f8f7cf8e1b3da3a130177b80c47efb5fe8ab3ba89,
+            0x56472b01f8796af3bb76fc84acbda7f174f54c3129f03f6b36d80375bef622d,
+            0x28a91c2f74f72ecbe75a6fec418b9ff6bf08c731ca114d6609478e2a498f947c,
+            0xecd04c63ed1ee68ae94d51633155868402dac39e3c8383e8f0d45ffdd1daef,
+            0x2865c65b845d8061dcebbc8f2e91762a9af0a69c4d7692d60e3dfe98400a40d9,
+            0x2f50ae99cf9753fc9a1344a654574dd7d4bec32df7d1d4b1cb4d03dd1f7319b,
+            0x26b34e635792eeb315bf2e03ecfb8b00f7b6bfc137e759436fd0e5285fa5e8fc,
+            0x26cb59e555d2111646327f7ec9cafb3fb4344b894d7746069794c491f71b5f82,
+            0x165c43eda77147c1408da412d24ac1314a327a371d2f6c0e3dc2c7e956e96046,
+            0x172edd07fa59daaeb04cc4a4c783027401ed8b47fc6fbdfce05543136805e1b2,
+            0x2bc36f035f7bceca4001545d9fd98b0f2eae858e5c4b0f0e219121591762b378,
+            0x22d96b2e558884ca077f0fa9c41a38155875af1e91f5e69dded36499c5786cd7,
+            0xf1146e591fc72056c2fa40a35b202e6ae29a5e6d91180713ccf8ebdaeedb917,
+            0x29510d1143600cbda4f235f0c6c480f436e20daadaf9461a032204de009d6fb4,
+            0x1dbad14882314499c14316375e9b8888be4351bdf3b96e2651125fd03ca89a29,
+            0x19d651b0c567b6507eb6a7202081fb6311e8398a80d53195a5b327b7e5810427,
+            0x196d972248e180296caa0f943f4a034746a000205310b155fd0071bf6a20341d,
+            0x2e823807f3a2c2db81181bf7761447252307c8c7e088f9a470c257ad83a1fad4,
+            0xae07a00e65e68f06fb34219cf2f0b819ea6bf147168ab5f982c9513a661e10c,
+            0x1f3ffa4e4b5ac02fa89072fbfa10d169ff5cf382ed54a86b69fe5ec3b025c3d4,
+            0x94323f9b77a979d42a49cb1fd0f4a5ea253e908b0e96f47a308e44085f0bb51,
+            0x7568c62660c919b4295dae1e761a5e9bd1ddbd05f77de4977e99ea46ebddc59,
+            0x1d28e05e1aee78e0a9c10c97e01193eb1771c3dc84ac0af0b7e9b7a5df35937f,
+            0x1479d6a6a967e7a7672a01c2c541bb92b677308c3e365b73349327f39f4593e8,
+            0x6872919996f740aa2559418c0da042d15ccbba1cda06c95daef9f0ddde4a6b,
+            0x587b0974583ba3b84934a500bd726018b08125f5f007d01856fb2c124e00e4c,
+            0x2ee0bbcaf6798f8cc107dc4ec3157dfcaec549f36a87c934a83f1c080035adef,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x76373d256d68ccdb201590f87f661a13d618407140b6ec21bfcffb267e0dad0,
+            0x13a5be09677fa0af3fb23e95428b7cf9e7b8276baebb1a39b87a1bdc416b270f,
+            0x227a7259c3b2135612d12638b5ca5973ab9d6aa6d6a335781d81821fa8be02c9,
+            0x25d96493ac371c2ba8dcdc9bf29b1b512f43aaf38fcc86f17e9d44d59d870cdf,
+            0x1ec1120411deede740e7e3481b96ce1492b47232b208f15afb2127b41189afed,
+            0x12067c9f5be28c0974e55e19274c65f752c82287637ffc5104b35799362b0f0,
+            0x462ea3958f9c42d0b2406bec8e38576c88d964597ae61f1f07d811873c464db,
+            0x20450babc7a6e637d32d8b57f218412a430fe087706d88eac441d6871f5d639f,
+            0xb29f887572517d826f977c371341f2819995e65a2929c078cf4a937dc68558b,
+            0x27d93349e2cac8325e4006aceccfb9ab165aca3895697e42e23b78bb1f172a54,
+            0x1969ee0572799902a937545397b4fecbb83446841ce8525b714d765fb25d9028,
+            0x1edebdf580772f616131435b17c46e0e385b3ab83494207efb4d9a32f4667bdb,
+            0x430dc17c3f1957758e57ca93c94c5623073e5580c28cabafa400c2e5eba5fda,
+            0x1dfdc9b2152615a4dcc8b252f17d97b8998543e84b9b8cedf8d683d917186b64,
+            0x48a9afbd6c11ff4a680204e895b655e004211e495f2bc46dffec598bf40ce49,
+            0x2511be820087db2191a273650de721dbf7abd3ce15bc9e95e2a7153443ca7fe9,
+            0x1b255c37973fada56a1251fe07d617ce802b4ec2f60a002e1fdd9052090d3884,
+            0x5c36fe03574074a04ceecbbcf02d231d9d868aae698b20582aa556e6ee34bc2,
+            0x14071daf49fe401a508085071812c378491178f66712eee8f1cd7f611f8632b0,
+            0x1e8a45f66dae3bf77aced336508d0b566ef1aa9d582d9a44b9028d2e1a5c28a2,
+            0x3470d55418841efb8777bb16984dc9d71ca55b601c6a9acbcc06dd8a3a4e4b1,
+            0x194cd0a75e5edf346e694e78b831d42070d93b69555b692da6fb979a78afce0b,
+            0x22d1fd9d50ef28dfab1c35553601cebb2dffe723e366e956a2d9f2001517b92b,
+            0x64a916906b28a8a1a2df80019b67d7e40dc686d00333fcacd63ccf129d1e281,
+            0xcadf1f120a7ba6a73fb4f5980c5aba2e0e44280b5c9478f5d800e61fc39c824,
+            0x11783cca91ae0cd06b91cacd517e51d4f2e7fb59202993dafde30ee181115b17,
+            0x1563d52bb66c227361975dcdfcfd8f6bb9749f86297a5bd3a6be74b8d5bd2bc1,
+            0x2e3cf2cbb16d4b6a76f171d80a9b92c4b8324721e6c3a29b77e2c9727863314,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x106cd44586872a1e98d029a76a334797c6950fb72f241e344040ec5d1e766ebf,
+            0x267c81eebd4f9bec2d7fb13ae6ab345774192825ec38779a8883265df4b743b2,
+            0x5cde6fbc024c52d0dd9c940b9450547804aa6aae2bf06ab7bb2c3946fb09aa7,
+            0x1db696f29132c9a065e392e606d3bb4110213b88b7125ca0157a776212418837,
+            0x269b78b6fb577d3a5463b0b88bfa91ad56c1f7768b55a6908120ebadf7faabfb,
+            0x1e32a4b9639edbd369aeb322109c919476aa85e28c2b7a8a111f9cd906bdfb31,
+            0x2387b1982e0083a0621b4305c2faf4aaa0abd33dc265069e9b1d59673f5b1816,
+            0x16f2a181e0d79d0a39169a1c9389d0b67e50fc5ecd2598d2d875ccbafc659ade,
+            0x1c418ee3dafe2d97e5b84ecd7625b8598c7323e4beaa809d77cd7a3ab52f5c57,
+            0x235d1dab5f72d1b0c0cad82e5f46ae1972117eba7612ae0581ab85d4dd9b77de,
+            0x11eeabcb505206e74ddf6a4417f4d6c302d843dad5e5c1e536004e100f729c4,
+            0x14b4f6ffdc590f859a491af89cdcff26ec963551676e4e109f333c34a0b3eca3,
+            0xea3a8bd722b025559ae438ef85f1fa8364cebc831084a3129b7498fc7067aca,
+            0x26a63daf3c27700bc4e5a0c13c12a234e8a13dab66deb6ff2a8b805b107a4518,
+            0xdd28ac1c88f9959311bc53387840e131726a6ab9b7fdba12f403a3095034ae7,
+            0x1221db6f8687604bd35fd586e0944a36880fdd1d1da2b771fc06bc80480d89ba,
+            0x5dfb8aad4d6b89619e41ed02e593f0de05dde06b6aeeb1ee8b89bafb087234c,
+            0x10ba8b3d427fe867422065e1b2a8e0d06d567e73717deaec3438fe36b1bddd55,
+            0x13cc217fbf1b60972234be03ee877b96d287e30fb869bf816662d2887d2dc68d,
+            0x1031f3acc4288235e55b67f3435fb1915cba9ce0d0d1f12e0e602e2d605497c5,
+            0x18ebdc6dd67f2d5853541af16af792756aee1dd1132d3a6b1d0734db793a46db,
+            0x10a4bdea8bf3a0440f456c507069645ab3738171f896cfe3b5890c9a0abebc0c,
+            0x21e5b46f2b85977f8e4c67f37c30ddf03556eb1b56d8339f046a7d1aa8d9bbc2,
+            0xa8735e02e11c8a1e0a56b24ebe7a39223e2beccae352597972fadd8f4fd3abb,
+            0x27d5d5655c3a948d91278714a40fab8da89ca600e748a238014c98b932609fb2,
+            0x18b4b6e0794cf364c6d4b5fb44a2899d4ab038d6b15ed634c6c12accead7e73d,
+            0x1b89b8c9a5250e9edb3b9fff6e54be5b8c173bfbecb8eef3847d8718de0fe29,
+            0x27a5ddf99d9c4cdc9643219a9cd3e4f47f63a581af9a499f8e064f4d2c726a01,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x237b081a68e30cacc4213ba3d2b153672483ed173125bad4014448763d2dfcea,
+            0x29af4e6cae10dd99b672d741c5034f91762b99be844b0a938e967009578e6ccb,
+            0x91bd6b2497eaa902ae05480699f34734c7f74b073af6c4c559bfa3a33d4e6e8,
+            0x2f7f9c0d61cb36e331f2780b0edda03598067caaf184dfe95613950f8700360d,
+            0x244d6e7fa5583e36d41ab75c679191497f27583a7ea7f5cb4e87feacf2b4dece,
+            0x1f174e5f54c883afb9ae5b7e955380190767072e59db3a1e1b90d7035521359f,
+            0x97f23268924c4ccf4659499274ee72a1a9c83e43178454d49d675f4e5b27150,
+            0x3d2ab62fef78fb69b7049c41e34e6f1870662b336afbd1518ba776218600fec,
+            0x2718711c73da1e256d1b5c21c6b2e5e43e2b0039e86f78fe5790e04b3c7938a6,
+            0xd396383655c27ca25603d88e3d35c3dc6334506a93d6909745e52aa7854bd4e,
+            0x1c66fd746293e23154ab298c3e4ca0ca14980c6a0a3cbac979d4ed8fdb9f692e,
+            0x15708a52c8abdc860d066e0ab2a6b5b5cabdf1301f676b07feaf5342a971caeb,
+            0x2b821cfd139e0da4c55cfbd8b67a7d7a4e7bf5e3ce1932b96f6701fd39e926d4,
+            0xaafbee598eca5624a31b7f40b836023f364d41b6b24d0d7832eb180a60885e2,
+            0x15c92eb4730eb68b229bb67da73fff3ca720814450162a81d1a7a56c83c3fc7,
+            0x2f7200c5afe273cc787b0add86e9e0380db97cba269f59d0fd264b9ef144e839,
+            0x2eac5180790ad9bb069b4f7e1842ae9fb0b069216c9b412da6094e2a69572126,
+            0x1b7a0422eaf807c0c824c511a7b52be353c2a3789591deba9bca9a99e4d92869,
+            0x1662fa1c78a1621b5bbded5e9e5880a86aee481fbc455b3849d16a37cdeda515,
+            0x28972f5963c0ae4ab2b03cb80b4ae1f1dbd905fdc3c657550648bfefc4c719cf,
+            0x2424d119a1299933b209b85d4af1aa89f8523801efeeebbfcf49c1b6f95ac740,
+            0x262a05cbc85dc177e174047c94905083a27b4d887f8050c1b98a07608ac8e373,
+            0x89d1b0af58744cdb06e1c0636306751f6b6ede06527eba770eabb7195465a93,
+            0x26d8b08764b7240789d927ad67270da8521ffd23995b67f3b25de7fc60f033c0,
+            0x19c594f452b69d9aba24aea1f48887b5b2bd351e7bc6984e56c346264e5c5f28,
+            0x9a984983ac12405239b7d71d7e94ab74a5d7e23b3e651f61988e258147f5a61,
+            0x2edfe7a5c13ee6fcf27ca3a98d230c3158dc1eab9a12a734e78e69d7bcc5ddc7,
+            0x190ac6e66fc0244544a3780ae6c5a0d6e56894965b345a1b731cd96c89defed1,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x24888d5352a17beac4d1196b9ba56563192a21650b6e8cf734abbb5dc6fe0b86,
+            0x27f1a77d912fc4ffeb051b44845cdca1360b3dff10f646cf4e2e31b0b52706ea,
+            0x281d4a45a8beb80c2974562cc98785b37551ca4258c7b7292006e387b20d5f49,
+            0x1d06a2f6b95d207416e97b18e0a33aa504251bd5473313ec4ba4aebdbcac8dec,
+            0x11dc2b5aac6c6b58904b8370d622f408d4b8a22a54a59f060a9336509285500f,
+            0xf03457b87c6491c043633bb8f90a9dba8eef6067f86926dc4df4a6145b9cc81,
+            0x17982901cf92be1b7f477e61747a5450b97ddfe41bb5d7760bd1c25df17eb204,
+            0x848af60d2939b3983df6d9fe56343916aa046933c4517a6c0c29025a3da1781,
+            0x1dab170558f1782df01501d1a810d1f491caf3a03a5563c8638eb6649d852272,
+            0x17c31798bf48cc0a63986b914236ba21a04dd2a2bda0afcf15213df56c46370a,
+            0x2ebd4bfb0ae3e1f540f31fd15a70e59de4ab8ffacd899d56060ba394e224ccf7,
+            0x16c3ea32466b179ebe57bcbbe97e3a7f94b0a4b3e091f15e3aaa9222e8b182f2,
+            0x157740e3058872c28ca7331055f3daf8b9aeb36e9c2d7d231f22171c6315733e,
+            0x6a974a75d941a54412814d68e6955b7f4da2b281f2a9ac426afe81b98ec27eb,
+            0xfa950037d21d72090c5bdcb8bb6be911ff4a359f3e76ec625c64f1202bab37,
+            0x19065585b553aa2649a420625c707e61f7e0e70c753dadf474bda8fba0354fd,
+            0x183bb2b9d85c3a9368017cd1e1cd884967c0b048dc243f35b6813af5b279872a,
+            0x271a9d19b99115dff27a86779104a54b252373c18105cf5f86ab5ffcb2a9942e,
+            0x284fd24cc3cb45ca644f15228d786fb82cbbf3d66f1a276ccc3a1182af4fc1bc,
+            0xe62b392dc27b2b80a868a9501c9e1c72410bffa12b77732ce1df084ed0a7a30,
+            0x265311e1422fc3e5cecb4158eba0b249404842b16e8954bab3d80d6805fc4f65,
+            0x1186e446615d83a940d96d2286d9b411b62697864531172f5e8d3d9ab6a5f9c9,
+            0xa22515b9c7fdeadf64fb896271bd8d96f1f53bdb32ddd9be7cb22400d69ab77,
+            0x1343f2ea91b46be725baaf77a092d6b790c1429ba87a3d4105e005b85c901551,
+            0x2a58da207ab04101d89a09c69f8d8309d8e8a938deddff70e2eea30f4c884bf7,
+            0x1bddc742015df54718d5a89b181f3a0110732b0ab1e014f63202f6d9eca2eabf,
+            0x301144f5830574650e6093a4b75b9a34b59066777ed21d2c008f2636177e9b61,
+            0x1ef4af22668248890aa7ad05b07462d777b0f09a98d8c17d59ed2a127fd2c55a,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x25b20abb9883f59516afd1b89f80c4b18be2270c4ad70f7f9f9b9188c9809ed9,
+            0x27c5f600e46a854a26efc7ede1108cef8b607dcfa047c259ec32934669c1d155,
+            0x1fcb1b54e79f2f06aaee7955186d71564101088f13837f11bf2ceaf9393619e1,
+            0x1d24da31bcb08eb64df9e69b729ab135cf1b63cb23c4c8acc073a9d50f33bb79,
+            0x21c0a2bf8c0ea05f8f319e57408ec4ca46f0003325efdeb8c84b23026d9a8952,
+            0x1931ad5d7ab126465234d8fa1905de0f77eb5858758e6c838d748f23508ac1df,
+            0x17af6e15929f2bca918d404d56b4cee0ccd8969195f2f3edfe56dbd1937baedd,
+            0x36b2cc2645cfadcea80c47cab8cdf6eba7fb8fb2bbad631a5cf24fce6966854,
+            0xf10bbaf98e0b1ce2cca1977ba2e271b89cf46933d4c7a797671c8fb0754e10d,
+            0x1ae0f9bb7b72a3239de677048151e6dc40637e6559d726158debfe779a72a708,
+            0x1912fe07ee7840b055e68317eded61b0283418138b9fa2fee286fb999da2e6e8,
+            0x24a8a1af47ef25f18b39b5caa36c1a6df571d3c833fc1c54fbedad560aa5571d,
+            0x2d3f665ea69116d266057ea4e9ef5225800a1cb2ec6b7d6ba9f3edbbfe1faced,
+            0x2c5b2cabc24bdcc0e95d2e54c52c0fd0ceeea439d8fa83c0036feee0e9730e3f,
+            0x1a79348c882afaa9480c28acb01547d816148bfb8e70f22a0ad3a3f534bc0452,
+            0x3942e232a30d4a941a32ab45958ac49b08b0a8a416ff6dec7edf4f0dd16b8ff,
+            0x24de94fdc7fa872eef8ac471ba7719d5f3f534cd988248c154ee122ec2090ec1,
+            0x13af3a6a5530327a659e6bdb0e3f2643db75dc7e9eb06a5c139d84a2888aefa7,
+            0xfff230d63a7ea1823e5c5eb49fadbb46522853f0d6eee45948d326f54571ead,
+            0x1f67b3c311ad5eee7495b1e9ac1236f8acdd8dbbf5b20aded3c3947baa0d7fc4,
+            0x5be06d2aaece5cdeb721c87ce053e8523c8992c91a1884edcdd72b96e8e448b,
+            0xf3b86d20e5d8b37d9c47c0a1e0e5654edd5bf9fc4202959848cc3951f58971d,
+            0x28047bfb585f17ad6e7cde5bc033d8072f3b3e90d63b884df2ea6f3a24d10603,
+            0x1186aea12da52c270bcaf4bd0f87943cf5cd9ddb63bbbb2d7f34dd184baeeed,
+            0x1e4d65e0bac14ec3fc7970af0d64f4ca9b932012dbee59b3a93ee42b8e52e06c,
+            0x265d09835a19ac5c29f4327b9df3f35988ca8893c1ca8813a1f92b555550aa0d,
+            0x255b843c053e9dd9b00d06db176106b632b4ef0e6e345ed96775e4ae313dae6d,
+            0x1cdbf2d9c9e1f4099652361d830c6d691ec5eb951ae3164acd715f49aae612a2,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x26cd056174dc2477de6fde6a95b7805ed343877ab35f7bd16afceaa9771fad20,
+            0x286c63dc377caf0ca4697164bddfd29a79aec07b52ebe4fff1a4601bf3178ef6,
+            0x4404a2d97266886b3a00244a049d2232727c70f864afa44d11a2d37ba4179b1,
+            0x2d7b33ced5c2aff1ad6b4ccd8482024effb1dfdbfa20ceb1f2d59aed40da523c,
+            0x1a5a78c756a7ee0cce31b132cf6752a1fa0e904e2d6dd9ab3818fbe9426d24ef,
+            0x26634b7dd87a8c0e9878b1383582b9a3bf658dd13c467e52804ebdb1698044d1,
+            0x2222ed015dbbe37bc2578814782740abfa00c4118dcadc8e6a656587aa25bec5,
+            0x243a463d1befd0cce1a46b772f3d11351d47cdd86ff8e0a6e6b8d0f8c7486da8,
+            0xf4a9dd0ccf52f31360db5fedcde0405406d4ce2042b1856c7c14bac187ad37d,
+            0x25c6e507371aba88824acd8974ec363c21ddd450a13b130f38eacd5dbc5e8c74,
+            0x864d7ea740ee93ec7d2ffeb7adf4a03174c89904d9c33a683d8897eaba353a2,
+            0x146cae6d1bdb0318058f424e893e0892b0a1070de370a5f460444ad2e535a920,
+            0x1ebcd64df7ad6f0e1619e26eecdfe6e2ff1e69210578cdc6c052e1451e9c17c4,
+            0x1a7f76a8b9a868b7abf0bbf29992d82728ad277aa0c48d2db00ab45c7a77bfc2,
+            0x32b7050fdbd512fdcbc9e9f530c139f120df1b53f26240c01dfa397e227d62a,
+            0x118e701ff219612ffe9524bfa2e515bbe11f2fd581a4371f18d7f45f64c7aba2,
+            0xae4dd0aa671c0a3dd08f394fc0eda68ab2beeeb58c6c94e60229145f0869468,
+            0x187cd95af561e161bc1a2954e04a82488721c80e7b970b51a11e318b43e3c340,
+            0x13c74e83abff731872630e45384b122ed9fd07176f336d1c3e3b87837adc1c39,
+            0x30392808edc88e0c24a9f0f4a384e3bfdbb65382fba12b4e7ae01b712b5073e1,
+            0x1bb68781b9f841dcca210b93a99320760e7f3ac43b4ed9d621fb50ebc3440467,
+            0x514eeca7cd002d04a4716478bf62c108b3f314a288be687fcba7c6d5103ed5f,
+            0x1a4c1caa217b647d099e3c3de03d9677dc2398277856140804f95848275cb05a,
+            0x1959d1f1414c9a59879e9489315264b7691dacd96ad16f890ebb2ec8c55f40a7,
+            0x2c0e761217503c6c0b20014558eb78e6314e607130844c97ee67dbe1940b3d4d,
+            0x248c9aa70622ffe24240bff18d191276417eff7762d96594e4fdb9d6803b9609,
+            0x21dba9d46e89f5875fd5e925eeffd10ddfc09ac71634e69c61e9805bd0a07d1d,
+            0x21280806713dc524e7eb2c697ee2e197d89bd2e73f1817609be21c35dd5bdd5a,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x3cd1743a3de44e9a172804c7b159ec17a83d2ad838f9a51f5497bb5aefe9666,
+            0x64682ebaf66d718813a4d06db5e8bdf665dc8654df4af96578526fd7eff644c,
+            0x27bdca50a989caa4dcad2f45d2bfa7e6d455549753fb3e8c4c3ff2553803b024,
+            0x263a2119f3bf5d5330c11f3036d2521e40f391da9efb1879bf1af39f5f4dff0c,
+            0x2df2f13f954b1a7cb58e84ca4f3e2ab7d0f4272b559e58c7dce7ef229213c5bf,
+            0x2ac40d567d483e8d671c8e194075fdb2ddf9ec51a174219e8c351dce02d32d52,
+            0x159b9154fbbcadc7209c9978cf5783aa8a47cba1a729bb297182aa674f7fd820,
+            0x1a2295de4f8dc401aaa4a2b1a83d62fdb4828ced253dacc132ec9d5186e1e2c7,
+            0x2404bbdf4995ad241cba1169ca4d85d5ad276ca9d009081ee3e2b5181d46d29c,
+            0x6fd221e32b98c2db6dc1602ead395001edced38761cf45ebbbc340ea35cd7e1,
+            0xaf3118afd7dcf599b5c65b5a3e74a8ed04faa2791f47cd2cce3a31e541032,
+            0x2b2dd6d065365f0b808bee0a2f7ec63eacb1990cc04608b08549d65024113ad7,
+            0x180941c6fd6e1dc8a0aa4fd86020ddc4928884b68074c8d78e52764aba6c9f9a,
+            0xb86cb785671c76300f9e6d4dd23b53aeb9e2d5b6d209f966986aca09ec59801,
+            0xae841f0d25bfbd009e0011201b47e2042ea8d961248d90ef9d44a360b317617,
+            0x1b2f66bcbdb6fc59dda5f34ee11c654d0f2dec29e31928d5b111393c8e0f943f,
+            0x2f16b66d80614604ae85a13440d46bba9d09d98d5161c878be67a0dedabe3aff,
+            0x196328adca8167c649b987ae985e9e54c0822077188b8af34b3c518dc21416af,
+            0x107664f2d3f3bc3ed01013faec284477785f08e9932b4226945efca7fcf56b85,
+            0x2fc54bc47cdc7f7146f9b81462c64093374c71647d4ca27439406ae6e6f7cca9,
+            0x8779b3359720a0f3e0898942f611aeae102f875627f2c973c97356554911cc9,
+            0x2e30be5c5cb07090ca3249386926194684d1f3d2d3ddc114bae2bca9d4a07f9c,
+            0x1ea45a4f0b12b578b58600b9d085aa8d9c68a583cea665805b9389f8563d53aa,
+            0x1753a308b286260ee6ec2934cbd59f0f211c11647cbf22f6bf5fa7c154c0f577,
+            0x102ffeb8a2a94fcde9001e08ab603aa8975edc2465d6de14b73c14df40d61db9,
+            0x1ae8a9e95ee69c8774f8d3a8ff484788ab272d3d174f526a107b2c8ac34ecd95,
+            0x166b84b5e6975b9e8d7ffcb7be641fd89c53d1b7238748e85f32084ddaa3aabf,
+            0x2b2e47acd6445423d9e61e96965da98e206b611f52af1d13becb4ce4966e1a3a,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x10e7554983562b62de4660b318bcd5324003e95edc617d6b1c23a97b93802e4,
+            0x187483dca9aca475f85b9f8cbd78aa6048bd2c848caf3973c8feb07573883a99,
+            0x2c13309dec41b4df5d8fdda2b063e8264c35442bb120e28de7555569ee771f8,
+            0x11710271c6783060aecd410a60cc5c96641c1cb26591b21632914aa9fd94eaa2,
+            0x12bbd77d7be4e06b77b5c40e1f9888054041bdf4f8af2c5378e6386337716b6b,
+            0x23ee2c9a0d3324166028728c80d60cf0e21a7bd9ee90817058ad3b87c6f28cc9,
+            0x58dd3f4009e8ac3fa07e285bbd7391c2dea81930c732c3a769c9c9249084d71,
+            0x128d27c4805d2365d84c754621ca2d1a82297ea43dbeda87c0baef506c851079,
+            0x20f552e4cc3a62cc2f3eb768b69d8549ef4c24d2887d7de0550b17ab4f7b436d,
+            0x235730472fedbab358bc7dcf25b1d0befcc70746de99e78a6dfec8f626c5a9f8,
+            0x280c2ed868aeacb6be7c9e773b08c56f43ea871c01acfdf9ff5ce9d4443d3376,
+            0x1bc74fb92afe9db8c0da68365326cd9944db988b65f46d032989326fd901e923,
+            0x2d9c89c56578fa5031afd1a53d21212f1c3ef24cf7076460ff533ede5fc360,
+            0x1e2413f3b8f23a2304735feb3fde9d2d0f88d8aa72c1c60eac921588bfaf69cf,
+            0x53a4cbf4b57d882174b8891d918af78b40a7caf832c2e2af02b8ba5bf5c1cde,
+            0x5e736b9e5f8a1b93fe3aef1ee0a69234f7fe62ea998a9f2559f650669d76dbd,
+            0x1e88d8b3d140ec659d6cb33736a0254e178fc6c0c37d2fa5b36ae4a85b28b5a5,
+            0x257237c9ee699f5d79a62f2647a3b51c8362759cd955f10872346ab3b401b04a,
+            0x2b6d25849d6b81e36cd329d20ee973c15cd9b62921e27acff048e7589ddf7739,
+            0x1ac7317e2e5e3011420558ffa430fcab50b2f3fb778311bb25b1019c88ced146,
+            0xf3223d7e88918a33250b61acdffacf1965a5ba9807a23cef7c89c837afe5b93,
+            0x1f733faa9efa2db68363757b1a50f443fe9bd4e3b8639f21f1e12ac25ef00b79,
+            0x8e2e6b13aa7a352b8c33d0f52939c16819e6a92f7159986588a09e2196efa3f,
+            0x208995a721ababfb4d527db0b69d35d50e263bb1c7d97b24ac52c2b316b58727,
+            0x1f91d022a78f70863204042dde629c18af85757bcf4863b3eb916a8af132ba1e,
+            0x63a2f4c8d518fa72d9ab87e414eb7ccae4ed3ecb6d24fb734d68b43a92e8cb0,
+            0x2915c64a0bf35200cca5779c140c7f9e888ce72b9c458a9ade0f0108eb2ccf5a,
+            0x17a2028a54a30e4e0eded3f7d8681d6dddfadf26ef5c43cbd1952e584ad5b0af,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2aa225f58d57ec9fcb1d6a6711daed13537cc6db5dbc485b21a8c4b13ee4ef5,
+            0x2a9a824715fb8db1d5d27fe975f011320887f593d36d6ca7e2be7cc305eabbd4,
+            0x9bc4b62c4e071e43c1e20d96810ff912dab86a98b4870d66af75d10ab6578b,
+            0x2d7d326fb2cd64b543ef4afc9d2969abdd53042e6038cf53f12d36ba07c21807,
+            0x1e66dbd30fe311dac75382ed3843cfd75e560bf2634f4213a0d37be91c269cbc,
+            0xa6115e876e097c8651c2370fc0c0a79d4f67199cbca00b3c69891c56dc81cc7,
+            0x2b4cd16c063e8d125a334909b5f9271bef61a5e6fcd117405e24b7a8d505453b,
+            0x19734eda61ff0dc7c62643d71daeb291cd8f18e1083f82a73ff05e5f8be31906,
+            0xf44441cb1795b60b9a424df927fb54b55a53c75a98eb90708fea4b42da18eed,
+            0x1e0b6f3e7526e310b7b870cccf69b9d716929e7b1f078652588617ea0b71feb9,
+            0x1abfb56c8889d36a1cea7d9658016c9ff5418745bc418d8134eb44e3700d56b7,
+            0x450b96e26195e4290a1e94d896daa601b0bdf44651b8575602ffea487fb536c,
+            0x75d3fba1c1f0b0869714cc5b4e54a019e13c5a9b745bf38139f2b0f09c93231,
+            0x22a1e5663700b7b7af22ac5604b120c3ab73294147889f73b3c986a036fdd5c2,
+            0xef19ddef71117af6afddfcb5ba454602d35ebb7497d65ee1e7805dd61d807c0,
+            0x293a52d85a881e3845f02993f54c6af700f6344def2da90a2dc13a714760e224,
+            0x10f47c70823694adb395246c750745eda7fb57dddf5f6e71ce1a41c2e9839cf7,
+            0x5b7b0f8a9586e0ecb9df50b8450b577fa537c94ab7b770ccd883184ae2718d,
+            0x2694639d8fd48e40ba301e56097cb270ca1e4a6d0cb5b09933142aefd1c44efa,
+            0x2b40678245e68225c4c9d8f78d2e660c5e7fcbac631d1299b1a78df3b283b195,
+            0x88322cb02937145ffa566b2f0256d5c8dda53b85ff611a658f4de8aa9ca5672,
+            0xf5f45c91500d38fe1acc462a8622298c1a6f53c735abf1d4a971d3d9fd10cd4,
+            0x17af880583031ee7067fec80f5b3760f9e19dbbde06343e59591da9080b8dbfb,
+            0x1248c5b2d3ebd0f2870307d965eda53ef7d83392cf601d95da0eb124b05c35f6,
+            0x286b506a8883d6f29ebff1bcde7429156792da00142bb1292f378d0f8962a158,
+            0x2fcf9e1e6970e8b883f8f72bb1c48c53541fbf72f7b43ee9f3273f9102b5548b,
+            0x17f7f929e38a4357770f905e9cc5ff7e287e043d06054c78d44097a446174e7b,
+            0x8326d0c8a128c073a72c7d722a129fa450fd429856732886fbda3ef61606bf5,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x244fd94ac9d2b6a02aec10be6bdfde0707d8a95440b04a34feec4eac0a881823,
+            0x18f0be2e75ec1ac912920d0403ccfce0ae11a66068ed5e7f0e60146c1eb78757,
+            0x67d513ea87808ec1cf7f5880f13c4ff07cb83b06a442573c2e74a679363edb8,
+            0x2fad3ebee463c805024a9884e2212288d97d343a199eb1ed449d7f0cf21fb86d,
+            0x29e2c3e0e04f7685d1e2cd797de07f3de790cccbcdaf77f1686f159d4e90b0ea,
+            0x10bdf28bfcacb8635108ea9153bebce77eab04539700acc64c084f8bc3f4a20b,
+            0x10b6a895914a782aa94948c650f6c045d9a15d2706b259acf5fd4da311e1d425,
+            0x2cd506792539dbd2f2cc3c96795d96831c21fdca7bd8988bbaac60f254da8ffa,
+            0xca9da7606615f15506a87151200b468c11dfc0e28dbc306bcddc6d4828ce2d1,
+            0x20d854f50910c52ab1f923102bd6ca5d82da15ba3f0f54f89a1becb7ce1f94ff,
+            0x10de4900ee8ec243ca53404556e6dc15caa2bab8dd7f83148dca55a598ea88bf,
+            0x1b6a8eb28c126c8682542278e4e4b2c922caf387f9f08980c8b469aefbc69b75,
+            0xc2a3124091527d21e1bfd56cd88f9fa0616f2209454b5d1793cbc1dce9d250a,
+            0x1d4744f598a2e98144d017acc5fcf08c5187aedea146de6ec74a5612aff8c7f6,
+            0xbd79ea1a224987ccdd83f9ac4490b76bcbc554fa7c2418e0fe38e9da27dea1e,
+            0x2405592dc81a66a17567e6acc20cca7179ae3c0971658fb792c0986882e57107,
+            0x14f497a9e8110eec107450c0fae64d03bc8a8416db391d4c4770dde9bd38d3ff,
+            0x29f8bb3529da3fe6152c5ef9cd0046568adbdd9daadfca8195ff20a0df7a5bfc,
+            0x2a032300fc92bf19b9cde88cbe9da3f72e3ff50c62b6342e57f713b118a5fb87,
+            0x1b59a7709a531a650d5ec2ac01fb09ced8327abd4588f619f36e0886c16c3df4,
+            0x1fc0a3436f100a4d61ccbc321771ef6f85e421d5663bcb4c01c889ea5049fb5c,
+            0xe9acd5d917d4160434a8fe7037b041c269eddceebb9129b6a176c8a00910d22,
+            0x196cc8a225f2c2986abab4268b3d6342ddb645bbcd692863e93274b717d02844,
+            0x11459356b20c2ca8913d1c0b45087f5a28559190d486f04038c05221381d4aed,
+            0x25e96c07ab87f3f5c0688608c095a86f80ddff5c250f0f6375a45398034d64e3,
+            0x15d58252815ac471aee3a3d097d799e9efeb969cccb08c33ae0b7adef18f0250,
+            0x6546b3b7f85042fde21f23c3949c39c2276f87701537434f147a3cfeec10387,
+            0x1e2aa3704b080c4cf11798a00cc0c8619c8d5997bc3121a17553be7b2dd65678,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x19e24f5e120e53bfe7fc01338211f4faa1f95084f2716e5587660295ecea8d03,
+            0x2ff252a61572b7b92960841bfecc4bf5940bc0d682f1770fc272f70d41682844,
+            0x2b9ce87d63d943afd940ae87979d5ddf50b784fdf8cd4d1ef0e7c4f220c98647,
+            0x18eef6bbabd4d2a581f11e2b22a591364f5a4fba59146a97551fbeebb865fc2f,
+            0x1b094af27259dae5e2f1929f16f00fe53d3acca1867d359d4681ae8a71f9ed65,
+            0x2f2fb2e00ecc111f573d8002c53959067f3bc7b52959d0269ccfea9729d89435,
+            0x48c4f81825c5584e76fa65b19b9b9fff7db07039d3750f3a65faa0a608b71f6,
+            0x20be19e025ea25f85f5998c77a52710dfa5dc65bb2665e58faaa5db7a0c8a92a,
+            0x222a05083d24105754e3f7fe45ece6add87677e8e64df3f44041618593aaf5f7,
+            0x14f3d89c38b0249acb03dd0e1130100dde039b1e442c1c92ba36f8368ea16825,
+            0x13667b7bba6c07aa7e18db6ce06e1308cff4eb1c0aeccc1187798aa1e97967d5,
+            0x2bc234f4828ddcf587bc65d2a2bd5ad0974f5acd1f790d590d66e8f2ec739e1a,
+            0x21464644fa0fb22494f8f6a7f7a929362ece3b3eb9fcd77cfbc23b2c9066a9bd,
+            0x8b65df38447cc47455b407b32c8bc2c740c0b7b37ebc4c61d867b75b844fbdb,
+            0x2369e1c199639bc505ce0da45601e0a51eff0f26588d74853d07b41a40b5b701,
+            0x199051763385672f6f8303896f959d2b24b4cfa4d62faeebd54cd43e190c5e6c,
+            0x201ac20d62b94056b6da288cb5a75fe62dc788a8b0d37063e22318f8c8b5dda2,
+            0x18157f398ab7dfe77094ab6e91a5ef4e0ec471fa1a04e89969d1c11a2cbdce5d,
+            0xf33f8f6546777c507e2a79f099a48d743325864e9e90a927478545a21fd721b,
+            0x23703db4b584d2c4873e7674c6f3df0e16dafd344ffa9431cc3348424e2fbaf9,
+            0x4501063364805e7a5e7d0a9b8797953e7f08a5caaf873917dfbc3da3c5be895,
+            0x2ea0b23d55d50d907bfb16497f56a979ac7f460172477dbeda7b450c7625d243,
+            0x68dadf39001f91f51a0613004e9614a54402b6fcbb0f4b8bd8aa546275e3075,
+            0x241c7eecc6aa39719bf6c6ac8a980e2100d8c341565d138ede2b374177333aeb,
+            0xbb9576b315160e6d9e5878bc54cdd9cea38c935d75fdf8b39daa3479a29b27,
+            0x202599b284bf67ea50cacca315c66218f4c59a49a27e193edec4b9f93bf05322,
+            0x170070a071a8648635667f8315e5412c48c3196d1d551ecd114857cbff9b9d3a,
+            0x302e841876fe659903563549979b9e27ca6d36f004a559bd2461d5dcaa40d2eb,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2731f1ac5dc030ec117fbad7b53c6b02a6c9e04a17f64bc0e56885fba0c2ef3b,
+            0x8e4443070b7fcb1a28f620f990800bf0a23bd32146d7eaa824f2b02f50a48ae,
+            0x7f1ea73f15d8be5ee132c68b1ceb3573909753f86582c57150eb71932972e5a,
+            0x5d68802b26f0b520b248a7d4fc2461df7756641131a1ad109fa2588c462320c,
+            0x2c6db9f72cad44c3dd15a83d5ef9eb7216db1e716bd8bef960e52cabbfca8101,
+            0x26365d95008667a1e1b2653e98f899a378e08643d7bbf706c7d3eedaac0b16f8,
+            0x52ff974b2d04537b8413b1b0c85065f727ad6da454f909dda0aa5994f7cc2ba,
+            0x2b769645daa19e2b07470aae4cd88672e7160cf3c07c7b271b60668382810327,
+            0x25f56a0ae50d333f294efa08376a37c386dc4cf24367139c640514547dbae38e,
+            0x2f2d49b2a257d8aa58b838af6357d865236ecb76e7db136a09a5a094ab7c53dc,
+            0x2b173636674e54aa05d0bf2c60c5df0b31b2e801e6afb149eaa2c6fd73d6a626,
+            0x2eb41bfb627052e1e7373a7392264e7d680a19cde030d8687053755207c44037,
+            0x1841952650b7215b249cf50f8b6c78511c2983145ac405cebdfa1a8f54b986d2,
+            0x16569fbfaa5e330f4ce139b103980e0569db854d701d76a233ec9c5a8f7bce2c,
+            0x60c71281c4ed3a23d7ce20dd30c22aa172e245ce529234ed18a130222a9e611,
+            0xecd53722d116536580be7b8a5c43aedc798e1110c99fe9d806be2140f5c7786,
+            0x213c0693e38ab9e0cd02d2447613d5033fce7f5444387652f03e95b9a18dca64,
+            0x772d0faa6c722c861da9582961e239c0f4554580a5a067f9d9e9bd71f978f85,
+            0x139feacf69de1ee3d14f4fb9ecd06681b58d4ea37d309f6062a2bb34806e4b0d,
+            0xfdcd35d68b9a0a9f0d39ba065449a7ff04c9301927aef113c5f34061299da94,
+            0x125be84a276a6acba551894f5dc8e14f3734797d489cbe94542be8bca82c5e23,
+            0x2be65bd8dbfe8d435018dda75806ee34820686caaddb53f133ccd9877913370c,
+            0x78ee87a14ac262c2d74b17aba71d620685987727ca21484bad37052d59d3bf4,
+            0xdff2aa73f9fc438777ec8be74d494ec8c36fc04ad3f12113624a58ba52abab9,
+            0x282f6e2312ac752d294d116b0308981e7ed45e2162403c5ff705d136fc05ae60,
+            0x2791a0a3c213582e9a272d6b667c740e63cd918d53ba444d23d095df767b68d6,
+            0x17477c566355c80fc784384715356f69c8f104b0154533af3c92e0a8a1319ac0,
+            0x2fe67e79a807315060135431a9b4426982e90f3b38ecd5d8e0ed7a0cf58d6c1f,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x957903e40cf2319059c20c0fc70a5f3f8a79a64f3330d165e2c60b5b2e7bff,
+            0xfc99ae6ab79445327c6d487e32997d5b476717bd26b47b073471c8367a3cc,
+            0x2962bbf10efd8a8efeccd09ff80e9ee162249389094019af228cdacd2e42549d,
+            0x25a909692ae443abd87eddd74f8705c80584216d5be8a42c79ca3079fddab520,
+            0x1c0e8c1b8bdcb489bb68d7239dfcfd5271c4ac39d27e222be925de97750ad5fb,
+            0xba6ee96962c66ec04c070eb3e71285d8c91cc967d20d72de7291f020f2c35ab,
+            0xcba1238e9ce747c7d499320e3bd270db14cd796ba829328556f7c98d64c0d5a,
+            0xc875635083ed6976d068751efdd6cbc3cd65da7c97f642b5361ea734f970295,
+            0x1697dcd735de9b176c4d10fc5ab1228775788ed4beb16dcb0629efa99a6a7e57,
+            0x244cf5956b0289a789aaf00f2e2cad480cf0824afe8eae41e259df395bebf2d8,
+            0x206c3705f63d7b871045c5245bd3bcf720e12e4f0a82fa89a1f913646d38babf,
+            0x20b58ed4e80e868305522f5eb670ce452ca9b1d541897d51ad7b42c4ecd13205,
+            0xaf72e95de70f64d621db85a37f69f5712ce06e7596aa97a1188bcd3861d6c2c,
+            0x1c1d15ca4b3e0508280869c3ef38eee25c3d0cfae188b5f3d59d5c7c5211d773,
+            0x4af306d94e8e36627df09ffc20ec563aec05452b6b8c1a17e93c8a3f30a9207,
+            0x2f697c34b59c559aa232e40024bc6da390426adae165002df519d7f2c71461ca,
+            0x8a7299528acfb65d196dd9a7a136401178a7d03f6fbf5df3c69e6629895dcd5,
+            0x221f628204240732be38e2d0fd3addb1080248592ccf3d655364e171302b4780,
+            0x2b4a05f00a373b8fb7938b4f8812be582796986113ba1d80749be041dac49088,
+            0x16d94da79927c24b7bbd25defd5c0fcd67073d738f31b93ff08bad9078b2a23d,
+            0xb536adba2330baa9a070a63f86c465e3463d4afcebadf59a233a0319d1bd21d,
+            0x1c57a599441a0b1474521bd0470a9cdcce3615e2575ee4baaa38a25958cf1784,
+            0x1f13db4a9d7ce5fdeaebf3a571fa14807e979a23d8f1d426fa16ba9941421c60,
+            0x12b527cd8c1fe08e9d909cfae1c405f11321538cf59af3a2cee67a06b11d9859,
+            0x1f2c0fb5f11e6d74db0c30125e48be344c15529c61d4debb013a7b06f07fff95,
+            0x1352f4a6320fb513348dd5f02ca53ceb1a47d8616892608eff2284ccb7fb1d01,
+            0x146dfeab263219dcae7613a9b5403759d5122c9aa490e36ba5b4a37d489f8e5c,
+            0x1edaf73615e187effe0d876478e3682fef5d63e3a12edccc216dc302d776680e,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1c28442722fb49d44d40b2b6e86e2218f956de3f4b376c3963955666a8f57189,
+            0x20e9e5c1b5d8cae475cd16e899d1c9d923d8d20ec60727d9266e66cb0585a67a,
+            0x2f8dfa1f54af676eea3d05bcc648b8f511ea011b5ad23e961e1b695b4b5267f2,
+            0x1a1a5037e57e4ae723753d3d22f965ad8b911f613d6b0e5d64ca9050ae43633e,
+            0x1ba983e3c28f6398d73ca8f7e2963564a9be471ccd5c3eb0c4f8e96635059529,
+            0xd4adfe4a7dfeb3cf86702e54888304e36057c89f10d46186d647bfa700688ff,
+            0x15c0166eea20cd705dec4b44aaca007e6c9e4aaf131b47789cf70e53c069e6be,
+            0xceafabeda1dca814433c969943e534008012b6555b08cb2a4abf43793fe0e5b,
+            0xbd15d8a31cbfbdb7c36e540f4c70a5eeead9d43a9414023c763d2fb643fbc76,
+            0x17b69dff9f9dfdbf6bffec7c7ee15eab02eef17254a526022d878fcaffaedc75,
+            0x272fe422dd56f28e6375cb725ad469069e1e48aa945dffdc1e9942b46307b763,
+            0x27d2db5651e5293ff051000a36a2c949a7a3e7ce326b8c993845ad572ed1816e,
+            0xe83466c2741c36fe6f5f5e6e60bad5bfe3ea06a7db58680dc4a518f42b6ddb9,
+            0x1b97b0489274a5912c53c18137e918d8f7d3985034c617d9d5dae4cb75990486,
+            0x8b09b027647befc8884bf237a58efd361641e4a25ab1e8831616ad9096aa157,
+            0x22f46a0157b70196720c57a7636285c4b10854721e4533294283652b1911bfc2,
+            0x2f1f803aa4a96a296bc8dae8d07335ad018e77ae6d779789bd718e72d8709a53,
+            0x2245e61dfb52be01fddb5fb4179140e4b5bf8cb1c7afbbb6976382cc712d981c,
+            0x1683f9bd4b791410d1a889953b716d95c440692fe4b4886107d052a8d50307c4,
+            0x242e864ffee30fe0a080e21e4d275db8355560f07b7745a4e5aef58d09b653a1,
+            0x1eb483efd8310203c93a42e06b18be5b4a0cc9612c335cdcc82c104c38b3e8e8,
+            0xa5b1b4c8982984b6ef162eae01f0a53337c0991c27faeed2b61ce3cf99f6503,
+            0x10c25a14e51fd3df8e34f70db38cd60124a4f4837d0b024d5a0cbcfa8e316724,
+            0x17e9f3efea4275ce4dd5a760f4215644cf5fda3659cc82c8cdc1c66ba5336c29,
+            0x25c1bfc4e679b3b3a692755b3313ada05f6d747365325250e0d6c0c566070ca5,
+            0x1356277171f1d2a2e677bcb161d9d760648150d1f297247ea842abf2633d4715,
+            0x28aab6b87f9f0f8c708695594610fc99a820dd994d63ab25829c0eee980d246f,
+            0x148d7520ea0a3d7ab3ee550cf30cdebe434ca7c84ee346a5b8b6d5d35ae06e88,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x24170fadfbcf05e5d3c5d0d5d051f71de23175002d1f02002939eb24ce5d6d29,
+            0x29491e9171d578c03ba302262531a6d8ff03ab25af7db467947e543553b25e50,
+            0x10acd03b983a457e3eb10f10666a7540b46066effdfbb50a1c5996e8e42879e0,
+            0x1fb89a866bed5ce87cc2170f998132512ebfde77a2aafa84f288024ebd9e6c78,
+            0xd98b830d880dad4a0755da7626c0cb7dbc454bef88b16992f3242c9fdea3cb6,
+            0x1c0d9302769b138d161d471195f06bb20a5a59f53f083731bb4b9407af705880,
+            0x299bbd2c9b64bffc601a51ce60185e770765abb952375055e0f8c6edc3c1e7e7,
+            0x1e3e012a3a23cc56b69b92c5a82ddef538fa2745d68bf99e6c4f65670b8a2581,
+            0x11f5e20407ee480fba59b35af723c3c1e7e60fc4817f92d6394cd7a9c65ec766,
+            0x26d3be3bd30f29131705a60fc4f5d51c6617919993bff2a9e9cbfe08819ca686,
+            0x2b29ffafe79893a89844e650ccc01ada03f91f4853166006e0efd05aaf3e3647,
+            0x1fbe32c5de07b6d625c86ff0062102ea1ae1f63e80ea0473ec747ad9a67e8a08,
+            0x24e36875d9f11a3fc2dc23d8ae5270150759b92a7dd422d2bb196603835715c4,
+            0x1859e0cdd36899ba3ea1a15b6a5343985e2429576894dcfcb39b17485e965a37,
+            0x2e823c343fa815b8850dd85825f5ea80cb32e17ed0a8ecddc478609b094952c8,
+            0x27ae666b5dbc3dc0d19c32a000a7df0fdf669ef25691627c4d7b17c6f4348d0d,
+            0x13d3988c983fcb3cb784b222b2bb8d4e947afdd3fb1d0e5bf2ab876eab1ebfd2,
+            0x26055ed2f7cfe90bc54ebeee9ae37eaf62f11d4ce7ebe370e7776167a51779a9,
+            0x187a3031170f0e0ccb8ca67fc2cdab2c2a5274613a5ce191a1790b91cc6c5888,
+            0x979a5a4f896cec804a633285c9457728b5a6fbfacad62593a23aeddefffe055,
+            0x17a9aad3bfa4cd25d929abf715dcbda7ab2933a6868d33720a5e6c60f88e31c6,
+            0x51192a624e65c0f7590c37385cb1a0b52b46205d2ae7109e076c08b307add00,
+            0x2aa14feee17ac6700e5e58952f28d5435fbac37769c3275ea9fd35ca622fe7b1,
+            0x354581b4a29a9ad673f3c57801bbb6f8a57098c9cf5c15860b4dd240d83b536,
+            0x23bf29c02d8d818da4257fadea084078a4f7d772795ddcba9e53030e06cfe36c,
+            0x209923e9cc079197d001f330069b05b75547e48685afb804931af5a3a241390c,
+            0x6d614256aa7a08f67ea8d06bf03ae83b820669ef7d7c1c7fd992acb22ae6773,
+            0x1131b48492673e474c8e23277571bd9f9b892b8ecd3b6af754ef83a1f30a429b,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x17ff3c20af33dcd172bc3042ca7ba8b9acc7c5d35694a795bcc8ae3c35d9e748,
+            0x273eca5bc74073b2f6761b6b0494d48407c4a021056f88b79f0dc3c475802c39,
+            0x24edf79bc35300c727d39b301de82e8cc21435e8ff3f34905436bedbfa6f9d91,
+            0x2cb3232131a5d86145127c61ecc8afd66fcea63e3ed9b1ff1ef3099aeb2047ac,
+            0x1ea49fb0e46edcc3a90651f6e1a4b36175bdb25505cc998a101710a4fceef13c,
+            0x1e40d394feff0707116e1d43c523a36ea293d11ce3059b5562ee678a008a594e,
+            0xfe47524266480df132a54698b09e844745eb540cba498623a93f36e48c63bee,
+            0x1f113b5d7c4a3e1f1156dcc68358318ce699b352814ae0253672d6c185422980,
+            0x1aed347277640a0a0cebbc2f4ce523b9a51b3750672eab8a9e689c488bc416f2,
+            0x1ef98e57380c6a8084a8d77b701e23dfbb56339ef9cbdcb9644460a72a1f32e3,
+            0x297ab0678798b06a4cc7147cc125baa11a058cf0889354e63229f185336cd356,
+            0xee54e4f901531d3811aa6575c60409c7e6ad4b475e249fd3334883b438a2097,
+            0x1b9b0f52375f34b4210e078d4824d0d385e6e412cf177f862aaafc3b6f11deef,
+            0x261fe98c4a6882bf586ce9c03ba90555d428567bd98761ecb57bf8b1ec408458,
+            0x28d8a46abca186e9fe9b326c166870f98acf6655eca805b881ee02ed4f3e8134,
+            0x4da6035fa7dd89980485ac0feb277b1eadc58f522abf010de5bf9d33974f232,
+            0x1a9738d1389ca170c20ab5bc4d39eb39992acf40d0c4da20ef3e3394ef369b88,
+            0x183dd4932830f3f29bf1421cf0e03a90321b974c93a2779cc64031c4c0166274,
+            0x1daefa57c81865e8a1e3163ca39d400cf5ce472f21a1888f300741ca61d61a3f,
+            0x2ae49d27bf8dae3b5f8499fe9f76fd2f247b3825a8f4e89e5c53596a6ac5b13f,
+            0x9063107e2a28ad8dec4ee2a43760006c728ea07dc7eff26f34c0e88becd87b0,
+            0x327db09f5185889ae36e52db244214053b27bf18d3f240552dae62b60badfff,
+            0x6e61b73f704a3cd70cfe843f37956d0c35cafe6bd28c5dfc1be98399c734fd,
+            0x484994555a799cbc175bce4f3add547300ea3bf0597b52f08adba0d0d7478fb,
+            0x1509af8f777631bb65bbe5ae68fb4bfd3e61040cc4c28250704e3e52e393a7c9,
+            0x2502148be563d2dbed722eb34a878e32686eddc63235292ff336430ca6bd5f34,
+            0xa90580e651271747716e4e65ea8dc039345e0609e4596fe65fe9539daa129fc,
+            0x1268ac93435ddc3de28c7401ed6612751f4b244dccfe1a75269da8036a1173bc,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x11aa913289660f7deb7ccff2f4be6dad755ef59eed4b716fc8d87e247a6fdb45,
+            0x29e72a16e4534eafdcdd6139bec5eb95e22b7566508e1b748614d450b54c15ff,
+            0x1a958e6a0b1a339f1d3dcd38ce1328571f35f09abb1686e2fb4c3459f036c58c,
+            0x2ed8337208e410744d73bfaa8049dd98a673eb4734b2f1e6c50dbfeed2532eac,
+            0x29377f640a7f6f76b922b18954b3ec12216ba9c13e0010002b59ea34fa974bef,
+            0x23454f27137134b9af8d43dbeb2f146c9a943bd5ec7fc7642da2ec887e9bc4cd,
+            0x209816b4da19597eda949b4db4754061c72a3c902f9130edc98b592470b0ee5a,
+            0xc1eae8b0bf925b0a155e42b2e51678cf5efc23a07e62a16ce7de2b5fa23a43b,
+            0x86f81d19a31671e41a874adaa71edac75c4eccc6a2115c2ac96bab6e4da91b6,
+            0x4c599ac0280aed84f94db0e328837392ea3338153ff37de61a7e28bd24392ce,
+            0x2c4b7cb11e988d5451ea53bd7bc59c1d92a3250e5cb1b81c8017efd00693ae0b,
+            0x20b49fc26af7d51f043b48670b79a409c4fc366332e67dcab28cdaed5fcb8f32,
+            0x2b2de9914033de3d614ff1cc2a46234dd1f3605a9f4e52fdf2169986b31a754e,
+            0x2a0a9aedae2ddb9eabbe22dedd043c670ff098249bca89b2d7b789c1a200e832,
+            0x78bbcc544330029c5703ad867d374a907efee1f38764e417f6b724ba2156685,
+            0x27f2b059159be5955c9e227e865d0a8add82aa951ebd9b2fe43545704f0c4bde,
+            0x7a6c429e1100125d872120c307bde17b721dc31e16763cc096a989c97df7843,
+            0x10424964905ef646913f708e8d4321e9ae2263875b83e5c65d096516581d4090,
+            0x2c33aae7d921d4b90a0376b93aef9a02975fa8343dc0026066d791e9030e04a7,
+            0x1232983e555c7d4bb4288fbdba3df682913813bbe616c9ef9568820e02459b4d,
+            0x1ab5023e5ffbea8d4fe8e006beeebb3162a26e2a4546f51b1d836d3467816c0b,
+            0x1cbda131f20b33ebceacff9339451b84854e65775fdc1f5ddbe8c35fab2116dc,
+            0x2ba0bb8404000f7361cab18e78692a17d953323a30934ab439e23b6605c023a5,
+            0x35fa0580ae06fc96e0e4af43e63b089591bebe233c526a67973f25cc7fb482c,
+            0x70babb38665a3546e6e23f8f3b26f058bf131abf19d3c13d6d0588a317c6d8b,
+            0xb642882c1295343e9ea28b89a62ceebe0b7919b6ca5e18811aa978bc181849e,
+            0xc68a36f6df8c27deea1f66f891c80fc215aefc646f545d63cadf22ab44b5914,
+            0x66489b3cc989e807be1363d97207014a2a14052de80edcd15c4e2f88d2c65dc,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1026e6257b43e0afee22a0189f28e10718f4cc5e49b3d15405df85d8153e8e1b,
+            0x3947588e943dfdbd95694ddb3a1ba7f51028c847b8a45164e87b5522418aec8,
+            0x1b1cb2c496ae764bfde288ea50405ca6ae4ac6f9ad1998b83b7557787120cb1a,
+            0x24fa4f9ef707a77f4f3742aaac6b8fc5bc59fa8c4046f9d024e3d5d80ac0c38b,
+            0x21dca28d7160687fbc8d0d144c062711e4207f617895fa46dd87922777ff10fd,
+            0x82cd14685bc3b3219e1a76ba6b2cd6b8286405a38705273a7faeda1da62b3a7,
+            0x288c7734ce6cf001742b8e84fe502cf5205a623a3f0fe1d79f0fe916df073c4a,
+            0xcbeaf576571ebb86d175b804c4655da7603096f9865f983a044bd8ebc416714,
+            0x257aece5dd9d7be08e83df64b50b5ff1e31e4cb6ef8610c6dbc9eab409ae7383,
+            0x178df36af677df81aba8a9fa9d31f995378d1f69d782058f7ef769555ad5363d,
+            0x889c87f38b0244685014312d379ae5ae934531ba20b7e89f6e1e975e96d5bed,
+            0x28898ecb6a12d999474f7cd98e7d0e3eb9da404cb45de9285115b647caf3102b,
+            0x1544b607ee25873cc317f6eb88b72ba9371ff52bcb64753b0e90dcef61032604,
+            0x30b741264c73950635ba61ae3be32eb643d9a78fb6a6f695ad4046f1b29a87d,
+            0x25052d3381e118c1995ce20ebee9f1cf615053caf4d2ccc143fb1e6c4ce154f9,
+            0x2f30bea892f8f2b335b8e8bd925f244335e430f0c77a2313013ddd6ed40de0aa,
+            0xb0d65fa768e06aa8e5b1aea32a2d0eaa75d2548296268d7bdc1c4b7a2234989,
+            0x1fa1a1014ba36436c1a7d8cea18580c577928229ed8e30ce94dabd98b873fe27,
+            0x301c506433828eccfffbf89757d52692c7ec633f32e726ade9fb89f7839150a5,
+            0x154a7110569dce2d4dfbb0c4d590669811751558a06207a1602bef10d3428ee,
+            0x2f27c0dd673d6353840612d1cfdec89407d7a23e25678d1fc57aaf210355a84b,
+            0x48683bcd4388885dd3956fb83e1890710c7d1cc5d103b48c2eb7a4e48d3c5ad,
+            0x151c3648a02ad924ee9afe8dfa7f163033d1683aa8ad9508a6c96ab29c08908b,
+            0x14baa70addf9eba4a80bbda03d2fce92e571486eda83f0c0fe59a7e4605eaec5,
+            0xba6cd972cbb3905ed976b62ed34d972444d8211c71f82a79c089fef7a030e4d,
+            0x25adc9138d823eee97b0dcf9e7142c4d791bab92c10215d5b4f44ee166c44018,
+            0xf0416997a418d2a20cdac6c53e67640da3ab4b5cad5aa3c9c442efb895b7744,
+            0x1dc3e4e5d9f2e587fd95028c6372a304d987eda0525879d1b7da7c775f0a417f,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0xcdacd248084fbe79ef314cb06a96f929ce94f525301e8858e6b0ab419a7b247,
+            0x28765df4d0b75915b2000538e00a7dcc8219c6e428e82f452ce8882e609eef99,
+            0xe81a5592eedab517a051cb7235c8bf0dc0c332258a65ca6e29a8625a334fe8e,
+            0x88c064bf7c553c7e4d1b38425883f54d57f18a7f8e9800e06a3c2310f01b2b4,
+            0x1d24333468728c030f01a3c93fe035e9fe913f3222c7149cc22e21d444fa49f2,
+            0x81e4d01326c4596d16d5d9df406a063f0c6b323e2a8e406b2788391a6b2addf,
+            0x352a5a0fac781a16a2d8bd72c9402a3b1d36199bd4ea46125e33c33732ab311,
+            0x26618bc0fd81464f23f6e22fc19fad753df1b3c076275c95e0ffc437760fbbc,
+            0x228b70124680c991be94ba0f8016e384609e7a7fdb2ab40d661614d65a52193,
+            0x1d0ba067834fa54b50347297a3525a6198bfc7d47dd47106072c7901b900a4a0,
+            0x196b16b4a3f2641cc6b343a57a66867f96be45005df9c9fc9d07710010a1df0a,
+            0x2f45695ff148cac7bd348b093d94e075a73f4f60b52227eb8ed6048fbc47aeb0,
+            0xe93289c741402aa1bc152dd82b4889b657db2944dd6cc5c9cbd8e72e69063e,
+            0x123380ecc6c09da5e9f5ad2d298dc60dd0a9d37a4b67d4833d2fe428ae7a8db2,
+            0x883e804219d5edfe1b0bfae68a76df18f1ca939207b6b0bfff7bef4309c7187,
+            0x21588588decbc2f33ff25a389fec95f429fbf43b54ab23ab20d3914ab844eab,
+            0x182c5a52fe6c6d2aac38a2fc06ffb65595a1ca4110cb09ab6f5070f5962fc478,
+            0x6a58def11f1c27cd234bd7d9be04610f52b68575d9560d3dccf8ad9b5b741dc,
+            0x29cbbb5cab2c9dffc5b12c9230afaa59c7d0b1846ff9bbd0e31de3218afb7742,
+            0x9a1d4f4f00323630dc4f2d326a5ca2823e77944ebf1c22cb9343963c627f17b,
+            0x25f5157f8a190e6bfbb1eae9cd55819609220a196fd89cd44b5b4603e80e87a6,
+            0x2f0794e7af6874b7463bf9d7f7f6cd2b9141b2c71754e4a8e487e26b723d0d8d,
+            0x2a816cbc315eb725995b6ab706c6da8757bec6f588849f85d10b31767998bd4c,
+            0x2c5fd92cb6990590e62056205768da25c8132d8bed9cc787e73b81dd9ddc5448,
+            0x2e80276a04b486b1a36aaaf7c15d1b6b4bd48238065cef5eab1c153235ca6937,
+            0x15257a77d445dde9259c6151c0af6a1771f5c23924a4c4f7fed58669ce49bfa4,
+            0x1219c007e9664d8a54be73a03262d03bfe15eb3a2f8e7c9194271235eb435814,
+            0x95144c721ba3b18324e55e532885ce67613444d3cb3e95955d7201d779812d8,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x101a646241a8315f204d41adb7fad83b1a502ea09e7cdd815b21625cc0ebe09c,
+            0x19282d6967bd22091e34c47fe72266e1cadc9f58d4f4679dc9255c09c2854963,
+            0x42b2e9365e95f6b6afec41632d9a933f4744106315e3df2eb6633fb87356af2,
+            0x86ed6b49511d6bd4815c76513809a77c277e506c3052c2beded9606623a4c99,
+            0x58a4f66ba158c1aa28b651917f1fbc744b5286b3f6672ad39fe177be503345,
+            0x28dde10bcf8969aa7a5b6ba1d48e2dcc3f69dfbb224566cb3fc977244a196cd1,
+            0x3842b61df1832bc6b4e0ea70d7131f7b2561a94f78de3371aa976d05d635894,
+            0x2c3bedddafb94b9427993c19bfa19472ed8cc066084c7cfa5c5e7f803a7582bf,
+            0x163541b79f81db7f2742efa3584f07e1e7dd25a19ad934623e14b87f99601790,
+            0x1846f2e5b96f8abbf20a2a6ed0d9a263337310372cf570a318dc3c91c849f112,
+            0x6c7a3cee3f4166e6212f93f7d6eff60103cf16e252df30d110cfa0102331b15,
+            0x25be194f6a3d69e3bf5f0b7cf58030a761e628b1a4de003d9e8a02fc2080ef74,
+            0x2699fb6f71316244c10b2c672b2fbf077f217e1c910ccef06524af80f9c3fe0f,
+            0x20e39137899fc0d2c5391fe185394173003faf87cdf3e438798b1666146b56c,
+            0x22b9615e9d1b58292148c5aaa8c9eee5d540aa62bac93ccbe16c5b657161da59,
+            0x17a4039cf90fb2c8ca78a2ab8474e5fcd1bcc7dd4974302128890f792960a722,
+            0x296a7947ed0816212521f82cc836f1b747640ed9311e5a8432b24f131abf74da,
+            0xe6222d1f658021ae1a8c83fef1078b54fe29719d30a30e33e95530140b2ac5e,
+            0x24a832d0b62d7fedb241b289e95fc7f4507556c422183cdf1bafd1a516301960,
+            0x314978ffbd36b1bf6b6efff9ceffdfd22c3128dab03035bc4d1811ed3a22465,
+            0x23456fedebbef43f154140b56f0106c7b3a5b7cd60f7ce2a085a59d219364080,
+            0x2bdfd3aa4bca894312e9f392192596efe7aadbe7b2c22aae990c18ce32c56f2c,
+            0x1767d8e87ff8dde844b861af172f011a8094f2c93f14a367e3f4008414779996,
+            0x9afea3b803901209c60fbed76494748e3af704cd3d68f6dcd846b5b37efd752,
+            0x1eef9a7f080331471dd29d7d0106b95b1cf30854c201d0c7354699f2c0ff18fa,
+            0x1ac0df8788f7b6b264c4b5fb1d15f9f43ccb6914fa627a6454bd7b107398f328,
+            0x153587dd8856ef1c5ba584cbc5c6206ff27316111bcb089a37000e01fe12156c,
+            0x1ec3422f01d367deb6566ea3f37caaeba6e6f1ab9b487e6adcd9abe7fa2d17a3,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x92ab362071be64ee1defe4c464b18ea957003ddd4fb25ef1ce8c93eb0da67e2,
+            0x2087c4812bd0d03d971979f341256e284a686b63564b913c6203e3a3316a0bbe,
+            0x15e9d37afb1e0877c55cd521cb79c5f20658f8f238b8679a50abfab5edd498ad,
+            0x2d3aef5f158c34c12fe84c4d48d49dfc4b27ef3ad9f6e9c29b9516be85df233e,
+            0x244a3d476b0a0690158a1bedff28cfab8bf6f5ba4491691326e6b1b71bb2650b,
+            0x10e9d046cdec45124f7bd3aac446b7f0eba568df3462c86c60751ce3e51c3ee1,
+            0x2590289589edc3112e5d87b4f474904fa9dd4dc4f26298d1e9666c281dd58357,
+            0x13765e0ca93cb708b9cf1ecb6427f1a0df0b53a7d112bc1a1439c3afc8e8c13a,
+            0x196d3192651b1e8b5b1cf54e775eea3a4f4d67e60db2f0be380ee48819fd495e,
+            0x18c81e4ef19c7276d9cda9d9bde0b3d4334f4748c76db52bdc4cb0de91def3a5,
+            0x25f4226ce2c992fdb6affc2c85c8ca64c9db486e8471f93e30d97045eb4aee58,
+            0x2a152c83769c9a975382957eacc862459e4227080ef497775273995c3f30c3e7,
+            0x13bdc6f2694024b1e21e3fe7b281e44a48e32c31ae815aeea28a283187bfce73,
+            0x18be50dd564a7b862bb9f3fd822a9e6cf8527290d0fffd2986b6efb0e4ec3ecc,
+            0x76b689cf6fc26746914c11187642ad45b934b9dba8499e1e0f645d1e7360976,
+            0x24cb96220d02e7d183cd28cdd89024647df21deba55e20bb0a529909ed483db5,
+            0x109261482d8eefedd9555eaa2d4466e1b9582cdb50dad968f73ad96df83b6afa,
+            0x24f33850fe4d7019ffafbd669532788d02c6a0dbb39948ada0b07f444aa824ef,
+            0x175369adaefa269a66baec32ffd60d1be0ee1f39ca8525dcb73a6357860abb2e,
+            0x25b9fec7cc7f651e8354d7aae86dc9b3964fbdec440c6c8369fea81eeaaae8b1,
+            0x2d0c8b82de5ce4c55025fcd286e9ca575c3b0b90a7da5f677a0504c05a4b0cb7,
+            0x227437dd063cea6ebb85f7b564232d22be29cdd7772640936c3698b7c9fecf66,
+            0x1bbba5bfc8a010cb25f637ba686157eea46f820848fc2c2fc636f933d4014101,
+            0x14471102a5ec4909add2c73da2c60ca518809f1e160be7dfd14a6e9b397683e6,
+            0x1b13fb4a716a8661bd984574b55249784576b8346fc245fa7ff1154e748623e5,
+            0x26344c34f453274463aaf170748550a3e5cd38fb0dfff173a2ffca0a7f2dded,
+            0x2541b62c8a52ffbdd29ea87ae0919225e12dcabe2104b5f4708708a2cf4fc38c,
+            0xfbd922b73f16d661458c67bf7b4b325aaf303c5a12902a667a78c8507036976,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2355f03ba072a620b568e7d310d9fa639d134ffd98561cdbd2297beb13ea0f10,
+            0x25ff4bb05b96f0a0b05562057a8db99f97e1e2951137c0c40fa932de73ca19ed,
+            0x2daf950c80154f6e7c49704d705e14871273499f2f619b86c5c5d157a6203dfd,
+            0x51cefccdb8cf6928b91c3127747d700e86844f1148f0a34c6d77c5b849fe690,
+            0x238262ec5467d6af343b33543cd5fdcdf909062c84f812fe01aed5cc87fc476b,
+            0xb7daca406fc36c69aa958fa616f4838d61a9dde2e45ac8bc788fb2cb21019e4,
+            0x15bc83c5e68048d36ab9dd5750982c086ebf0d155254d898c60e644231c54e13,
+            0x1c63961d501d08c43558a7bbb6adf0248ce7d85c46ed8d18cb57fd255d70da87,
+            0x2509bb8169fdbbd47da25a7229eea6ded1c619d3c047b7838aaace2693656732,
+            0x69a50d4c1eec1a0ed50274c6fa4867ef658dc1379d8fbf9878d4b35e9fa99bf,
+            0x15d74c0872e9b1164992ce0394cab9fd723220e0696d28ea011620716be1af17,
+            0x10b0c815190863422b42d8bfbc68921d1ed561055ae5057b45c5e46be5a6eb4e,
+            0xc11c306b5211eb36fcbe505a754052252ddc622d02f4420c77390851d6c42d2,
+            0x150cfca445b9336ce22dfcad1175f597794b2f4bfd18a9780eaa12eef2ee5c55,
+            0x194de31d0ce18660aa746a9356d96070ce237944e5304630884874a2fba798d5,
+            0x14c2071d9d7df808b50b19e77e314406aee8b339c4a245b2770b802af790ebb5,
+            0x15847c79aa8e1c92c18c3bff302c31eb38f001804c8291fd590cb9025a7d12a3,
+            0xfbba1d54897882de6c7d26203aa96c3db29d788b0bd435c1d354c271b126973,
+            0x1a3b7ee6c4f24ea92d2228b4b760223f9a34d8f70c3872400920bc066465877,
+            0x2ce61015cc1e5520a83c0124f38a8359caeda53051194702485e00cc2ed02bf4,
+            0x2b8be03a29a0e8fb62bbc207e587deb46eda5bdbe99e522e773bf63e6cff6334,
+            0x105e1aedf0cf9f12ad2416a44fbf458d6237ee895960bb8c25299ac72bde12f2,
+            0x120c504e8e99eeb16539249612eb1a9687e2f99e4fec80123f0c29378553bbf8,
+            0xf35ac3925b66d52bde5da31655b11df9975be00efcbca7da24e85509dea2f50,
+            0xf4957169958f20b8cb24ddd2c1fa8668bb5694fb82c2779a93e2d993c2a4369,
+            0x7f61b3cc5f1220535cdc630b9033172c02afa0a7988a57c373a91c13263d805,
+            0xe16429a495a0878289a4e187af2b3b9e0395ca3401938b70f07c0647273ad8d,
+            0x18190cef50589e6c73faf348b5cd88be8dcbb44f37ecdf70e94a3b4045fb2620,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x227f232164c4e3c741afa130d206cd84d835e4817c4bab99ceabe0bf4da575df,
+            0x1b1d09c8b7aea951d45cf1390c95b03c29f6820492ce2478739df09b9bf0fe5a,
+            0x1bd040cdcfded9e6d08d3d6bbbf55a86aba6aa5c13cf09ff4cc6db28420a1830,
+            0x2c4d2f16535632f050256086dd4e2c88479a1d3684ecb8c25fcf3096b3e1a6ca,
+            0xead790bfabc7e81f7ce3b6d68134286977c619a13efef5ac110244721c097a9,
+            0x8900754358a5d9716c6e2fc17133da9069794fadd42410213b5e30e7dba7565,
+            0x24c0631f518904d6a003e225b34d3d02e2e5645f7c6bcebcf4f9944fad419f2a,
+            0x9ec6105a057621f9bd18fe13e9dede1ebedce6d72461dc1c4faabfa1aa7f105,
+            0x79b0343c865e073462767b20213ffa9443db0387c9506503586ee533302e802,
+            0x7df63d142bd6c29ee03aca8d1d5428920a7fde6437b949149327c2967d14245,
+            0x2ff26c8169cec62032f72ac25650a6c94a18afca7d04da0e3291d3ce71a7711c,
+            0x164edabbfeeda046884e4f8595e438127c32f8467d9de721fb50a816688e33db,
+            0xbf8306af475136a305a5a78b818c1f2d49ab9fa181c11de516e38a96ebf9f55,
+            0x16da51bf32b4e134bdb05926f7b975562a7f2fcb671bf0584fb0e4d33f33638c,
+            0x142930caa1828bd842e28c8790df9d033eefae7b165ddce53fcd46f86d3be2f0,
+            0x1ae7e0a72e9bad383d09d0555a1f5a0bf1753ce1a17e254b49bef0fc899a6e99,
+            0x280313df7e066df1cb639a4b30ea2aa78ba46720595d77ee31b55de2a713dc54,
+            0x1ba62055d4a6b3257fa66b471f11be979422c05d3a839ee6aaffe7ac1c0b247,
+            0xfddc6ca4b45778c49a7db293c78628431edc830512b7b1c8e5754ed2f39ff04,
+            0x929d32df53f196e858a97b178b1d47e42247d5dcf37b08b4852ad74f9cc78a8,
+            0xf967d1490ffa3280071a718013b3ae7f9727755d261fa1d85c3ef7b0559283f,
+            0xf5490a89b5fc95c115da17e181a7e95b3d3d2229e73581c6bea89a0edf5421b,
+            0x674bfe177fdc1301f1d49c2879734cae162898d11000050734402c75384c736,
+            0x18e1ade3d71eef67b1499555516671ec9978a13c5da32b3cc87a373a6515eb66,
+            0x1f9179afb7f5975be537568da903fe09944e257b2757934ccf2e36149021f009,
+            0xc11a256c35c638a65f02d745d35712fd303bd7d3137311a1322339402479ee8,
+            0x2ab557843dbbcbff147b3f03de15fe79e8d40e9cd6cc556b12958bee7a900f67,
+            0x168dd127ba4582848eac364d737e87bd02024b8924b4adda31a9a37a3415cea4,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2c4d427a7bec8d19617045360e52794c7a1a6de79c4e919698a87ec516366cca,
+            0x36d01a16f30bd802544df169c77ea02c0008342cd8a415e67e49f2ab20538b8,
+            0x104dada7b72b24405dc07a4feafa385fdd6e87d0eb0d0b0d461bce56c4f574d4,
+            0x1d189ce1540193127426e68c7efbf6116be294f4e39c2ac7fb43eece2a5230f2,
+            0x20969c1c5a7537d61331393f6a5a2ad15ebf51efacf6b61f37c08c8ea0823cd6,
+            0x1727f8b0eb9595229baf305b3fc99c51d538637e2d2ea8931037c7350d5f96ca,
+            0x1897f619c615a92fc082a589d89a7c522625432213d6a92fad9e2626aa0ee79b,
+            0x1f62599143f1f32cd4efb433f14ed14544681878db55878f13e69694a226b3f6,
+            0x118c2c92848d6aaeda5c8b61d8ed6953b7b659a25efae602f9961353f7c781d5,
+            0x18997289e946839e6c3554194b87e6c0d4cbf30f47bc73b126d6eebe47a1cec6,
+            0x130da6eb344dee64037fb513703caa96d8aaba83f7c8099308b4e6c82b14cd83,
+            0x245357b0b612c4aeb12540db9ae1526513e7885ce50ee8ca0b58c5bf54261563,
+            0x16efacd482e07f1fee18c96ad1725aaa33cac494d4e7301aa173f1c29a625581,
+            0x1aaf282a0db417234b2f0afcd782874ec2a635899f3ebdf33f4bad118acdfaec,
+            0xbb16e9a26f6e4449016a392f58cc0abdc15838cec0863a15cf24737b7a9c804,
+            0x1ab091e043a032a1a8a17875c09930f2f3f8f014966977c7672e052387a88724,
+            0x17a1b1b5e07302afe1156372691356ad32f77ab95b6dc1766cfdd4c02d260e0e,
+            0x198f8c2021281502a922a03b04b3418571d4ce4f5359ca251015e477fd983d96,
+            0x1cd705bc50da7642e8f41975abb2ac63593ce9575a0ebe0ec412e33c2955131c,
+            0x2f634bc6e688daeb64b11b71780307d998916ea7db4cd7ac0761a03dd3fb1744,
+            0x70efde061570346ca148955dee284634e28b4f5ef14d09018e289a5b6b5c643,
+            0x129e1fa03e4374b6aa7cc2ccbc35e20a6124b84f3df49bbcc3f5aa1c25f8567a,
+            0x872750e7e4e00867ca29aab19b0221191e89a4e7e17fbc0e0a97a6b99d79816,
+            0x23e8c43c57b9dc6fd6b899818a44200e2544bf0865fdcac5b4256777fc765928,
+            0x2a6b794cd03c70ef06885cb5ad01698f2340877a5a848c8f49ede93b5c9e830b,
+            0x94578409d6462e7e25ad9d0816a6f6e2b198c464796c9c8d4fd566df266099d,
+            0x1b2b611f853458bb3f92b07d97f4a8d0fe323b635959664d7003ace44646b9c6,
+            0x205b0fa2b6f2ebaad41abd2b1feb4f7af003b5e73f91d342dc196ae182fbea21,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x18813c17a1991709dfc3d21cef51ad2b5a728731db369c24f53c9c18f7537922,
+            0x28e2f1491faa1312b2fc0756fc93e6faf260cf3c9a798c4c75567e6e2450f189,
+            0x2456cf94d7ff6e124cf859d5c41e4cf38e76e96c66356df4959af90e84caa6b7,
+            0x19d01fae3e6bf2a3d738e5adc140ccb0566748abd79323db3085fd1bd3a938a8,
+            0x15b9bb8c1653e644f0ce9be50bc599be543d181a965c47b1e55e75c128df6451,
+            0xaf54a3486b44d6cd344d767948c8bab86a3b770730d578d35c946076ba55628,
+            0x2c403933d9fdce9b2356ea5599a17ca6fa2c527472702d33a1bbe1dc6481585,
+            0x1f8600480399291bcdb8f2bd4410cac16f4cc035599a6e7f7fc3896dc95595e4,
+            0x20853b736e1ef67fc8dd165d3fe11a6734287efcbb6524fb6eae1a66a7b1e8df,
+            0x2f4630a0f0018b04c6bb77e84776e06e3b2452d47be2d16220ead1da61106b20,
+            0x2b9036c48f9af1b32085e3eae9f541c4ea7b650f1a5226ea661b9125215e8995,
+            0x16e06530b370ba9ce030ecc30f063bc064d716de78cd74c2262d483406e0e68d,
+            0x16965fc262e0ca879a932d721e95d16953229eea7b3e95cbe325b48bbf4e851f,
+            0x282361e61365be447c940bc7b8caddef10a82e8a51423e7ce17f4ccc8ac6826e,
+            0xe5f05bc3d2f27eaf48ba6efbb95fd33d29dd9d371afdb46065089f07b5aaad7,
+            0x45e49d05e82f9c8192a3fd3c936e73ed07f0edd6db0007205695a23c9272ba6,
+            0x1aec3601dc7eaf614f812cbc025ea069d2ad1eb2b1c8bb602500cdc8b4ec97d7,
+            0x29182e5f19d8e48e13b7a98a19be4552f09b452d0e93fb876b3672cbdbd48d82,
+            0xe82f9feb507fd178f0e2c0c324e07dcedcdc0cb2ad743ceeb4e2b62dd1355e3,
+            0x9c0bf03083c7a7f84dad628b3528a89001d43100039491bb3729319bd75f304,
+            0x1ac08c4bc322282517d3e9201c601823165882a09f83e43fac846c1620aa01b8,
+            0x25661bfb76d976aa63291de2624e7f306a50ec4a32128a39bcbb6cfe34a227d0,
+            0x2dfbf71289f57fad67be3438cc1f0dbc969529942a623a899addfeb77ef1945e,
+            0x805aaa9f12a17bf01288cca68aec10cf08db6bcf49a8bb56edbffb97f6886df,
+            0x2bfea7d79a17720df5f215d42ab5736098c83da075facb964eb2fef730b22564,
+            0x297315ed7ac6f9bc92b4dd4a4052519a5029ce7c97eef84ff11a461864dbf9d8,
+            0x172960704ca74222cdd9c8ebf1821031312b4c21cbb282c1f11cdee3ec28284c,
+            0x14b30a8e90ee6a1e22fde21503094bafa3d61004b38a69cf94b493e101a3dd29,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x25c2fb93758a36327dbeb7dfec90e331cad05a04e5c84e6b40e65987d73ee448,
+            0x15be6f22cbd5f38ec70f9133e8392e8fdb41f28d831c27bcb36e415fcf9fe843,
+            0x1d2187e9af970cefee949d0888c73dc41e7e257e327a9f20e4648928551e062a,
+            0x699ddcb91e856bd25bec8b21980bbb163d38a20d47fa9d813a32324e80ac79b,
+            0xfced0a1de64093947616ade5773e0f7ba22eac4862322dd5ec787fdffe3325f,
+            0x27768b29635a400d365c934202e4bded719df8effad85e6eeabedc24a4154888,
+            0x1b1f6642ad87106cd16ec5421b38c40392423fe0d12f282efc8474efeb957d1e,
+            0xa3e365d3159084cc673a44044bdd4260e1bd25b74f746772a3c77ef3e48cb9a,
+            0x24179d5e64991d45a0634da43510ccf0a34059695e151682b9d356411edb7cf5,
+            0xfbbbb67aa88655564de38814ec6376f4da97ee274586c5287c163d1b0f98dd5,
+            0x11edd5438d9b4168d6e2bbaed31f31ea464dbab80ed5e702126fd82ed38350eb,
+            0x1b76cf5e219ed4bc311a00cdb03e28ffbf86542cbd0252d0715bb48469c15dd6,
+            0x148437b32c2bc48962d356ffcaa4edc05be984134fb75f3956d5d91044f79393,
+            0x10942207a5f66bb8252988730fb82f23a45be26389489f66da6fa113a40ab0c0,
+            0x124681e28623f42196e8ad7bb2374c77487c37485bba1a9075859582d10c061b,
+            0x2f9dc5b15dc408e7e97ead3b9d8cfc654f6914922e33d7bbf4c061cd8583bb2e,
+            0x11597e8f45721d0f8a2900ec7823302003282aafabbbdfffc64e5f3caa274777,
+            0x14ee771b1e80f23b2fc58d2f98d43a75dde2a5c7d37fb0ec3a90b661ee4f191b,
+            0x22142acbf84a03df8d16dd2ea6dad8b4100f864e5dab2f6afaa6a4a36612a4c1,
+            0x17cca25c3d45d22a57fe904ab20f916d9b1890d5b7f70f56e5732325a790e637,
+            0x3120041b1c3a4c87445672333283fe28d18f05deb5c7e9fdce6cda7fa4d069a,
+            0x965b18e93bde84a1d8424a74e69eb6aae7a73fc920e5cf5e86410a46511ffac,
+            0x3601f2a0058f85efa835c5ef0276719f80779d854e881370a3d4150a68a4b65,
+            0x14f0454cb6ddaf09579651aaea20532036ee6f54bd9893614b2eadcfc041d756,
+            0x11844e3d73731aa76edd24afb82a49d60c861eaa25579c45fcb23de6a45667d3,
+            0xd49b3c8de5c8a009efb91116d019f97c01ee5289ca666b6807fc89fa0697e32,
+            0x15ac66208d53f730d995abc5cd72d50ad90909c8cdce17c5aa78bc0b274a8571,
+            0x1c9c5cb02fb78be508a818a070deeb6963c687dce2975aa4593a89ff1ea675a0,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x210b5dd8b7bfe15189d3aea8e53b5bb7b462204e8eae1f9596bfbf1cab727bcc,
+            0x1e72e11f21abc22a4f68b374dd8726a2c72f9891deb6536f3a4bed98cec40858,
+            0x1d0ea48d109e37ba4d144a4251066d6d7b7910bf92f44aefe7081027e1e94ffb,
+            0x19c6c9e54dd8314a776b1b1e8d423cb2fd5b6d4951f3abdf7176875a0837b3e8,
+            0x1722bd20050713407ab428b4a1598dbce86e6a04f9093d0d415b546bc1d265e9,
+            0x1bee9ee0577f4a46e9500f2066dfbffcbaf775211450f521e13aceacd519010d,
+            0x4f1c326c88072a05332ad14d25ede90d430394bd8e80321dd6869a561282e37,
+            0x2db49dfe6b2f6f8f38102e019206a908503e268cdbd5fd7689855932394952e5,
+            0x18cacf5fcbe1e383706c2ae6e294c691eb86074e611439200f39b49db2739409,
+            0x251e39efdd606e5efeefe439a1d01dacfd6c29729472ed884160d4018d1e510,
+            0x20ca4abd314e386d0154234a94bc5b85522a1730c005528a74d7f2147e449437,
+            0xfd8d3092bca7b55b7ccecf94172ad86eeb0336257108ca5a1786cb88be7249f,
+            0x14a262e3bfae15e0345a1f837f1343b2b245fa3dc706956bdd64a74c48e86e23,
+            0x21e54491928f3904814373340aa65a0f97be52dbead9b91011fc454b2dc8f6ea,
+            0x1a41918b8c68ea8d675330f618419302cdb44d7c4821561bf3f75f10824cc06c,
+            0x21930445fb5f525159a17da94a2dd4d28485794801b0c9a694b03b849e0878da,
+            0x17535af3d952f2a356554ad0183697eec1c86ed9db1121036de89df8f758c7cf,
+            0x1a82f3c943c80fe4ee37b238146142decb389d69918a0d7abd97a691e2ab80f2,
+            0x53b942c6f210f073fa9c58f6e607da4fcacadae35e5bea34eeb6a54cca2eebc,
+            0xd34f91b743a6ba52c32052bd0623804fc8cf2bd384bc98002434a2c9614337c,
+            0x2749b7c85c71adfbeb5900b6334c4dabc9925e9885c9a525e74f1edb1e630a8f,
+            0x2284a0f1ee6a86ff447d51e642951ca76a50fc3f4c0d009228aa67f9a9b1f953,
+            0x22c7f25053d11e887909b02af7de7e57f5b5f9d37ff75acd8ccdbb74b717e23a,
+            0x29c30ea916675045cb996f3d2f3662cae115e6822329f93a4d159f18afcfc49b,
+            0xe555cdfb1576e9bb5cb70a9234a6e9238b912c9d65100f2dd5f3130bf5a000f,
+            0x2f16e6a9e0bd6fc0b41d91bd065f60dbc36179607545fd58f0b1e6efbc86e172,
+            0x25f261e99981d3fd2b094a13dfdd14e1ace2d0100973ce0331081826b8c69ca7,
+            0x14d1b4bde07ea82505ebc4f4f9b599ca214a099e081a286a223bf8309e9b1348,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0xc2161d0dfe1fb1b030d25ba9e72e2d0f9c7be11edc3ee0310dff7dec3ed10e0,
+            0x1de725c7f6c995721e1a1d0a90cb31563110eeaf81456a3f8a9809440c9e9e14,
+            0x12389968950116f0177afe2b7732608bafa5e8d50393668844f9db50455729a6,
+            0x17aaa2062cdde57f4a67c7052c0990ba08b3e874633dd41237cb6094246d678c,
+            0xb9984737ec0a6541f484c9fe4837a7639b58d017cdccd2beb305a937a0b79b0,
+            0x320982d756176f852dcd74ce8be156b5d7f92db99df5ccbc5cc96e93d83773d,
+            0x2a4319d0bc04e4c18b9b105983c8744ca4cfc428f20ea477e9a60441ca15cd52,
+            0x182b9434e89db547bd499a5122ad77854562962cf0435e21d960d1c4498edb5f,
+            0x1d26abc0becb0e422d36f4c59b34f6fe77ba771192b2fcadc8cd0965bf0ccfb1,
+            0x958a9dce1b6a17620dfb54c364af3ee428dc932d81d1dc4669503840dcb541f,
+            0xa8a70a8379d71136fbe77851617cbf9d52257c32c9c3ca4c8078c90ced7160f,
+            0x208a9a840025bc0c38b883213fbbb42c311c4d7a3f1c2d53924999892fa9f931,
+            0x1f1acec1766b25775db439929b1550734fd8204b77afab09e4251a2e1e123664,
+            0x387e51920edf06b64c6bbf3aa91d6de80a4c3a6a55493c4cb038f55ab379b97,
+            0x283a3b099b37a60369426569295e1919635a5f557c26e2d9bd62024ed42f6cb1,
+            0x3a82b07486a61e769d4f4a9691129b1497ead1ea2dcd4d44fdb626b31fa4c2c,
+            0x15aea7b6a44e01bd2a1993a824bb751773d6ff20d3459974f00602982b20f837,
+            0x91383aa8ee58024a7d0eaacba661fa0afa042d4490bb02061a005799d8926fd,
+            0x1c4738d32fed84629967a249121d25afda758ec66b825730f4c0171f05981826,
+            0x5e10a29beb202a5238338a3cb6f3ad81f78d044a791cb03cfd63367678373c7,
+            0xe3405582a614f4ec28465cccae382ee3e56fc67f4574846f5a011c2ae4bb316,
+            0x13c2e18736871254346e7951da5758a3bfdbaea4a37c62f5204e2d833c9ffec6,
+            0xe892a08fd4d17f277eb16d8cf6ea60a8ab263ed317c20970c54e02655bbbd4d,
+            0x38c23026542424fca9729f5959d6b7a300d7c8663dc2de7d63c98fb737c885d,
+            0x242560875a24ccbded928c30e4c78e28f36975b1767933888f3a3eedc4e56759,
+            0xe32ec6d6c80d3bac0aad1635fb195ab640de35ed9e19e60033751b9b17b7938,
+            0x127f81d915a7546cb2d35659181f70a31cda6b1c0f011cf3d4d2d908e44755fb,
+            0x2feeb1c3f308139ae4f23ced4a2bd3df75c7dbe7ff9d89ab31405ff4e1f88034,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x1abfd157d65b0faade670c600f964a0582539691f909a27f1342ae7f1d1f1659,
+            0x287edf9809122fe7f424748beab604c04270dc4bb549932ab49db3e42ccf675e,
+            0x574627cd0b8f02033621b45ee0293376d29811f14dc701b6aac4565c5e2346e,
+            0x13be344cefe3cb23d84de26cb8dcef9ec21de4e275675cb81d8e071b52dbbc54,
+            0x2bd04c2debf244a79c22c363e0656dca89ee4a641137602268796e048f222ffe,
+            0x21671759ce3b7fa3b8dd29ef4be836d011c802e90a5bd2850db423f0b84b8f97,
+            0x15e2eca1f4f24c534ee99f492613185b6eee35daa601ef5c73ccc1b2183b5928,
+            0x1ac428a1c403acacea5b19eb5a9db448badb082eaf12a0bdb39e33de1b2acff5,
+            0x18d056fe0886b5342e70987aa78d6760e87ebf840fce54ab3790159a2359ba63,
+            0x103478de82699756c898690ad0431b1a62d0779b072728b2e8f9f1c3dc0fdc44,
+            0x3ad3345d4e0b9af20a5acebcd23f067ccd8aad3109ac7d180430242a083bef3,
+            0x84a2a0a197a762bd6c633ed789ae1c92af3d189421801e2cff4ca4cb7bb4b9b,
+            0xb9fac3f1b5b7769bf369780edeae7d4009586d8eed37df7613d8532240a4b2b,
+            0x2b6c5a5b0b2e999c52d385c1ec41bf6fa8bee62c6be1e4896ec6eebcb6577f,
+            0x2b891566a83432ef436b4c379f8033c4297d73e413ab6d3dde28a446727d6d01,
+            0x215093cbac4cd6a567810f829abc65d556c7c7d81937770546c68fee9b0bc5aa,
+            0x59542cf02d9ed7aee0b72da0ec5092043be68c53e4207e4c9d05cdee2620c95,
+            0x2c5db84b283b99e21c2d7387fcbd3d71bcc262ceb616379ed537e29d3d4f4511,
+            0x23a84bc9d5e7f467120927f9570e3c4646a6ab1d7177df4a0972c42588ea47da,
+            0x1af62c1dd6f9e0526f8c4eb716f2cb087122b6efbab08fe32af30d76825c7e59,
+            0x240df1209a4dc3cfa2e57e4e0b8369b81ae2d530ee1e022f45476ef3d5541f14,
+            0x1d663e716dc9e681f325217cdd3394e128afe26e727a3e74df24263781c370a9,
+            0x280935cb8ce696be4fa88e7502cf01612d955d783b8703024a85cc776ba98bb1,
+            0x13dcbefa8c14a98bf73e722e6aa233610b00c4687a29badca7ce239074b0b6d8,
+            0x10184429c03a6a7dcb093b06a4180cf8c2b1ebe3786a5a58149398a80bf85015,
+            0x2b9b91c8e29a94d655338b761838c1698e4b8cb751a103b0a35bca7380413e61,
+            0xe8036f74c51d11dfc744f686ee20f62dfb45bf99bbdaf43a5512b087566369d,
+            0x1e20b85a64e45febbac3f5fbfbb8b1efc111cd57c8cd56e83dd51bf62a4b2903,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x27d3fefc3fc713f9ddb2e3fb5a4943e55c336d9881f463532e63bd3257825095,
+            0x64c66b3bb1fdcd169d3d15cd51d5f7b598642e290207911002b652693f48a9a,
+            0xe9a5387f39fff6e25b4c460cc50c1d9a9d772e889ad7b3d357f016eb7bbaafe,
+            0x30372e3fd7ca7cf85f5c5fce64deffc2eb2f6bc1f0f81b9447ced714e4dd47e3,
+            0x1c698c1fb76b93d6036f01961482e8db670da8178aa66c57ea8d6f02218046c0,
+            0x165745c3218528545f671cd07fe2a521f2cd6a5cc268601b120b9794a583b2f,
+            0x1bd6ac92ec06f6ac1f1f348ce1f5608e60679a7a13c7d37f881c147233749072,
+            0x646a2c8ed477619f611baf19f5f2315d030d93485d7c72a057d7521b05126cd,
+            0xc5d7ece37cb949c5fcf9dfd72b620951ecfa5411f8ac7f9cf6706346077b2ee,
+            0xe0f95062611089d30cf1641ef9f5142d5c09677428dde2a5b70990ce98862c1,
+            0x1167dfcdef684e802ee0ad2745b448bc9488677fb4a9f21f4306ad438e8a7154,
+            0x8b58d9c87ea695ddef4557a17c6c6ce8b34b20ecf1dde355d4f564f529d9e52,
+            0x2c0c0c0caa80990aa8b3db0b093748f6d4148b7d56d6ac8448363d592d495bb4,
+            0x22cf8f510e15dbb54dd7aaaa9acbb79d93c91caa6790069822f17eadc58f3bee,
+            0x1dcbdcc87c651a39a1cbbf4a2429512ef5d3d5d2ef8c2c272bb11943f15dc73f,
+            0x268f76f1dcf5f445f31a5c3e2f77f9370f0c039da51a0bcf499e89c50dde72ea,
+            0x12ea4be23cef2bc588a2c5d3f0a473d86fe2e62aa05e4993fd8e3c3a04fc81de,
+            0xaa8a1b42480a433972000e6b714bd6205cd020e387ab80ce788b4d244893d9b,
+            0x9c9635e93ef111fc995b0f41181d644507a96adc5036626025d14c67280340e,
+            0x2f19542276afae3f9bf2d8bc1ff25277634b5e44631c88a3ededd309a35fc238,
+            0x2bf08e4ad9318465d011b6fad36953dd572e1a06e6ae04acbddcfde42ea6c978,
+            0x2e415ee818590fff4a8eba14dc2db89eab455471fcb48723a23d28bd07f22181,
+            0x2ba1b1348857a0dddb145fd370c4a5145794b555fe90aaab30eaabbb831e57b2,
+            0x2c45b38c22d1834fad94146ecd9e2084fa0801d4d2500d3c9b02dfdae2c686d5,
+            0x55fde4fa51238ae151360d0bb3e53d6bc88454434e0a3e7e81886971f44f1bd,
+            0x1b500c091d518878d60bb9c1e46487120fafcc07d99070f6abeb94cf72d099c1,
+            0x1507c80ac988a1d66a9b7d7e0d489e3dfa903dccdd39cbe30d66e70a4465cfda,
+            0x2c5389c4c3d7db5534ec96975e24b341bb8a3950817c95fa6886ffa17e3729ad,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x220d668f431ca31318ddab3a7d699e1daccc2681c19e28782245bf06aa393eee,
+            0xf82c73508a680275741c5449a2108b0b4deabb7adce05695c6a9a56491b09c9,
+            0x81d2dcbe555ead7fea3650ec79e20c01aea1bd8694204cfcb53f440ee9f0c4c,
+            0x12d6def4feb3b9695f3a33305c190d41b44360fe4f7edec96b9ac2ee5d19d237,
+            0x188a70595236991b549396dd83dc110ab7848143320ffbd8bfbb8d067daa0dc2,
+            0x1ee5cd9ffc83473d252da6d5f220a32b0f14054ed87e47d163f611b0a03c0500,
+            0x336f443081e4e4ef2f80daa0d427376db59a5cd44d09c4ca4fced8213c49792,
+            0x2e31f59a54ad75b935c7968deccae44c7651c6989e7a194d8eb75db56f3c8e6e,
+            0xfc66fe6e89f9c6b8fcfb1b825a394b791404b4c535db02105a0cf9b814718cb,
+            0x19392614602253f18fff6c6add01041fbf1ac573c430bafd1be9d0bed661f9e,
+            0x26bc696c9022801b5558f13a240c2f2595cba3d923740bb15f857012d65b4e30,
+            0x3e41f8254eea920e176dab66a494aac26a9050a6083321aed3e9c60da60f30f,
+            0x277e13cf936573c9ea57fec54bc20dcb76b9bb22e43dd7d3f0c88ccc4350d4cd,
+            0x100790eb28152be3bbec49d19719f1e819559e0b83cd3fa5f55b3f11e2ba7c5b,
+            0x8a5bcc49a8ef4b71ccba577422b91bf7b0eb873ed4f819a03f84b7b22b3748b,
+            0xfe17cdcc7b34315c294c9afd7ada649e535d66e18bf207d0627af9b985f0fc0,
+            0x8423e16c6102fbc4eab76ad8b96e75ab86107261c8be93c4fd3312a65ab5bf3,
+            0x24659f4e6909f198d2da3d29a4be15ff86b279a012972befc5ab6d55e6d38807,
+            0x145fb5febeebb5b6feb24341d5ad656cbe31346d4146c778f495fb1948270c4,
+            0x13ad1e400a7375f25b79fffb3e0ad1d1022bfb6eec76f9f2762919eabe8d63ca,
+            0x1d087711ceeef2c9423d13cd5d262f9c6d536fb84d1c171bef1feb446ecf88cb,
+            0x2a914d202be77991a1357bb453bd09062b6073f195f314e552608fafea4fb38d,
+            0x1660b2ad261b31ed9a13147bc1ee06a9f186e70cd619111a21b51b33d2d1169e,
+            0x1bcc7790328fa163162a0e8544eed39b1a7a96cd61e0aa49b117ae18af29e75f,
+            0x2ac02b109eeacd4b06cb5378f08cb37d622a856d0629fd3bc03d8e2cabe54ea8,
+            0x30616182ee240c6e1792a51a9bfe54aa6851cc10b377c468021dccbbfa60a3fa,
+            0x37e7fc430f341384ae6aa7f96a7173a91f7d896e77d464e1f8fa8c470e187ac,
+            0x2c238e1df2dcb6d7c94bff7c9e3a4951fe54db4e926c431fb6332e3f6ad23da4,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x200ff178d06931904472b00fe23a8a113d17ceb33d6d0c910068fd5168a541b7,
+            0x2c3afc766aee27aad8b1ba9fb14b3d56e2217c9c7e9ad3363d56fe5b31721680,
+            0x2128f1a125e0c64edcf0d03a397dbca56375f0fb87ce41480e525c2470391e7d,
+            0x9c62fdb776c4fd510eea089910bd2537f8efda0286768d88a2c9ffd4b8151f2,
+            0x20426c548d66b90866a7ecd77278c69e33b3d1ab23f0801342e4064b3be82618,
+            0x7adcb9b76dfa25de61d2902ce37140c9cfc7d51fb2f8ef8e2317163f06641d9,
+            0x914a79c6d02adc94876ebafea2b8e6ada5ac238e7320147fdfda370afed4e94,
+            0x3a5d3e37105e1d08281bb2840176dc462a386409ac1e7eac82be7dba931e9a8,
+            0x12aa83b029bfb3b8f742e689995ddf71c0aa28984dc073e73a38aa8dd8a72de8,
+            0x1b293978db1884bd8802eb86d98477a690036f148d0a07b165b9437a87c8d30,
+            0x29f5d2ca3bbe30251e5228e63e1eed9c906c4d98647410c4a3c74315101fd5ff,
+            0x7bf47ac1aeee2ae48457ad8031ce6b2c072a65acac7427ef29ec2166c2d1f1f,
+            0x1316c94951ec5aa5a37e96922334dc116d22f3e3fb219f8195e25d93e62d282e,
+            0xe5a891e769da4c1b0d10fbde39d81225fa6c48216717edfbd9443541130abd1,
+            0x10a84451b6d2e943ef60255bb33321f4d3eae64981695a27bd75d7c72cd85d,
+            0x344e6fa9e638ded4d99a92b2dae4381ab2401aefd50558fd8ea90764cade9b3,
+            0x28a513ee6230bebef34ead9978b224ec3d8f252f2c3956a781854d04a293d5a4,
+            0x1e21c489a47bf56a811404304e04714ece44f376ce998e3499ba91fbcb0fd207,
+            0x2563badf855b5dd41a35570028bf5d97e9430a60962fba0441d52860765a4120,
+            0x209333ede8112c2a18bed033eec46e7899c53627cbe5d7ff49e932455ab51612,
+            0x1b740c4dce2fa0cf3af1053e8da92456db1f2e31c99caa6918c8297e3350fe88,
+            0x2310a0173db9d135f259497b3f27551d01feb64d4e0cf2233f7823c8d4e16219,
+            0x2362c8df290b748b65a8680c1ce2c43c5fa82837c5f84f8107c12ca823709f6,
+            0x24bf53879bc6be25827e47537248702baa3a4773fb5c17476e142e70ab17cb69,
+            0x193b4986cecdda54bf346868bb20f1d62e3e795ae49a775191a01eaa4bf095af,
+            0x171de60c3b1f06108a0ea4c621016c0400fc9b96af211250f9c25062aa3f971c,
+            0x170208c0bb8840367fc496ede9af48ef98913cc6800a76318fd8fef208860c19,
+            0x19305439f5cd0d17d75d1981b097bf61709a427cc09e83e6e983b41bdee4d8ab,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x14d4a3a0742364a9f659b29349bfa5455751e48da07705179afb0d01e8989db,
+            0x14507c7d18dbf71926567faf318f25bae7d15d1627e930fbef4dc76068a1eb9a,
+            0xab92e37d54cdf29da56dfe18704f6517ee8894c9db8e42ac9d3f8c80009e6de,
+            0xd3a5cce50b706d0e2d5ab6d99cc5ee19d414a99901ae56d8ed2b90c70161473,
+            0x1faacbc551048977f44fdf37a9c68496027dfb6de98761ce68087ca0892cf084,
+            0x82e2d6fbcfedb2a32622e4c9f6d4ced6cf0a570062df9b838c4684f4a8f6c2a,
+            0x15345de0a699ca5370e036b6b65ee4d4d3412d46901b471ca44787cfba69d203,
+            0x125429d4185d9e71c4e428cc2cd6b98da229e56e941f37b846d46c6dfccba94e,
+            0x10f072b77d74f20ba0d03b4115303bf37ea98a20a51f03b54756e770e3503601,
+            0x3a5a00dddccd6eaa0b88cc6ab2ef6b0452a206a04bb5bf2361baa3f2136b2dc,
+            0x301071c4a6d3e6b3e274dd6ecd6f5889e65e92dcb190e6980d8765f946ea5ff7,
+            0x497842511b8c65d38dd10ea79c157976239b771f5ee8a72930b45c15b0ce6e4,
+            0x1a7f3811571bf5bcd0786a27a61702e4165a02f734965b52996a6cbc1abf6248,
+            0x29b6c15ea8aacdc694b94efd98045716dc81aa60c6ae224970ebd0395a6c2039,
+            0x1ac6bb7492d1e4f715604b57a281164ac925c56efc0cd0fe495e189914f1478a,
+            0x1671405a7351ef20e4b093337091a308e1858d50656a24a08993b416dd0750d5,
+            0x29784e4a72baef66066c6b4a580e5ee0d6010543ff0edf90ae6177bccbe3f34a,
+            0x15bb878d0c3129d4ae1e3203a7e88cd90f025c8ba652403e8be7241c2908a334,
+            0x145ff66f889d0eba5e243c1c4780f5ccefc25775a82f555aa6acfbb1e6f44792,
+            0x2397dc005d52a49fe64bcc7e71398f4668e4b1d7d23e2cd41f5a240b7fd2015a,
+            0x104fae947bc81f5ebb40171e9ce8e51d91d558d686cb92d39ab245db3b7f980d,
+            0x11d92195df064b6bc2f2702af25e1d57a49adc4774f769d32b632ad5cb29c38a,
+            0x1de8fb3988b840fedd6f1ec8f4156fdcadb7781b895ac7267ff16635a57cfa81,
+            0x27089624e599b1c50dcca8257a778965238f557d50adeee696f52f5656affbdf,
+            0x1e5b7ee2346227404b1492732b5e6f36722d8bb7c99f2ad8f48c6123519218c1,
+            0x44744daf2989bde9d3d36878bbd2116fb0e6f03f36ec8c360ac7180c6a87a9c,
+            0x18b6b8ae538910b9634a54cc1903d21f0e9a4626abe012f424ff26e7a4f389db,
+            0x1ea586928d1078d44a1a4bdbd2e566b924a14187c428717894ec06f47d01269e,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x299ee7098c20a8d8485fb78b37b5794235fb37625243103d86edaac65fe67351,
+            0x173d58cc84bfde0327aa48c131cab0183f9b471f25ecfff26cd950bfb4c4f744,
+            0x163536baa734cee7b3ed0d01cf2dbefdfa8e8f5b26e6fe1eac9411f87cfbdb7e,
+            0xc348237f64f9f76bae51d147a191aa505fa9134ddf66975b7f54ca99b377894,
+            0x23efe24fb00b171697d7a06849d9eac5e14e032631c17ac0dfd273eecbaaa293,
+            0x1e7878f760e864ef15b4039e253047ddee33b082b6e3ec3828e35c184d455a66,
+            0x2bef7ad013467126fe0cd58abb1dc92d50314c8ae9410163fbf8c886f86fe02a,
+            0x2202801fc79b3c1ce769d85ac6bbe8b8225e81bad63c2a26fdbd813eab14a147,
+            0x12a9c7120c9ac72e58a53bec642e04890a20bd2080b06717d971c5cbc74e9d31,
+            0x2dc68da29a775c40fe59bfb40d1bf330871f453995f7cdef71b67e14356086e1,
+            0x110afe2764fc7945d4fb2f8bee04cf7b8cb3859bf62c54bb37d0cbbc8fa283e5,
+            0x21ef54ad10c3962befed62137a17e8cca0ef4476d68f57cb31290cbd089e9123,
+            0x1c4faa0f27dd17f4d20fc930a295dc90afe4b2b319b72c7ab3d5d67fd659a716,
+            0x496dac1141cce7811aa16c3cc7ee5bf926b19b57e4c2a3fef441f6a4f3e5e0f,
+            0x1124c584f931153f9eb51cc7bf62a908c7d935eeac92ad89be0cf7b3b70bf0a5,
+            0xd60e7160e15c49ac0535919cfe58b9bba626b7a560d187d93c02a2013d7a25b,
+            0x1fb86c2a75e7eb166c625ae15189b3395bbac9ca27fc7140420929c57f254dfe,
+            0x302e9af922d3af8a056f402150e34809253afae3405b769561958e2ece0eb937,
+            0x208a3e5caddbd869846894744991f2d5b855cf126f2fbd0da3c7655f6c44e6a7,
+            0xfd167a0ef538adf695b83b0c7e2b65edf204f994296f4154adcb45d5afbd5cb,
+            0x1231fcf2898720a22a2a98204af8bc2b06e0cf72daacaac1af1b08d1310e2b30,
+            0xad52af94770e15ede8be17b72e4f2bc1bfe73902d78b7f3a52a254898131b43,
+            0x63dedd90276c2738935a71b3acef9d2f2dd3b9bd49e54ea8b62261422d3d77d,
+            0xf58416b4af85510a6f3becec11d8db6c097194ed62d4a04e5a2a295011a3bff,
+            0x15933b922f212592a806daee6209c9a02ecb21ce2bfdb1353862d7629df1ef97,
+            0x1228654cad70cfa7a1f1f30b4cb5d9279d2f49bfc233411477c333cb630256b6,
+            0x1b099efaf6a089382b0231daf9a65505b77b54b6af4491365b9316f988bcdca6,
+            0x75756cb31cafce46aff3d873280c21ab9253a0c587f5a5e107364178091e73b,
+            0x4523bf1a8f284c6d95b310dec2b54e0e00e59b571dd9d46b6201c18e1b56dfe,
+            0x2e36976f35a34be56bf3881e93370f08203d1f8b0be967cad4ccf4d9d2c83c52,
+            0x1650b34e0e8b2ad5ab5de19ff253eaf6dcd3e20d22bc69539c834437e0888513,
+            0x2154f3f4c1b5b2a42078df70bd1c6b4f042ed01adcefe5b603b4830008715af8,
+            0x281286cb63e657f78e369c0f6db3c980cdab1e57fdcf32505ccc325e7a9e8c40,
+            0x3008b3f202e3d206436f7dac2412d51744cccbc8e1ac457c11e0faf6d6060cf2,
+            0x2c0268fe5d032bcf88a2803e4ddd2f3e1dbfb58915b47d0fca518043272d5b27,
+            0x22e8ab4fa7bac348cedbcfd376a8ec6512fdf78adf936f6548594d6584953227,
+            0xbf717c0f092d04fa4598afbcc898ccbcdea3eb9d3d1f5042b0f325ebd57028,
+            0x1f500e6028390530690b82421f359563c768803db6fb3d0135c5366c9cae12c1,
+            0x1b9881d9fb9346520e1e411de0696df0a4dac3684a15c02154dc0e7fae528484,
+            0x24ecaab85ce3beec4c380c207c564f4ba6995c3290f2766a89b73010eacfca19,
+            0x756a8ad9f562abf2600b8dc808abe6a2bfb0d4352824251e07be2c0e64dca67,
+            0x2a1d50d0f3da33a873e9dd5e5e2966bd40445c1e6eb9504dd4b276ecfa0b318c,
+            0x1fad2242540d4366495a5ad4fb69ad25b8261d2e1ee56d56669be07686e9217d,
+            0x113ad8b46c3eec20c9965b5a7b2e8a51529871d0401b4de6f63de9e5211623e2,
+            0x1fc50a16dbdfa1c3b99038f47f81a1c5d1ef6e7b221d4ccca6e821220130e000,
+            0x1214a9d6d7288fe85651a8cb83048c7669c83b5ed82ca2642fff01e852a44b4a,
+            0xd421a7c25af5538788f49475836712af5da156f88c5867568cd958e305026cc,
+            0x2de8ba83d2b6ab6a711fb9230adee1cba46de8c930c86d266acb8c1cb9684e24,
+            0xea7be82f1cb493b1bbd83ab7ca285bf0a1559ea05c3f59827b3b013d0a91fb2,
+            0x1e3ae7e5775d352651d713ebdfcebf9ca8e905cfb792bf7874239450f914c8c5,
+            0x5943e3618a32cf050018a4e2375f4d027b8c14ac82a0de57cbb90c5122a64b4,
+            0x603755180f66e98215d61e5346b116cc00cfd058274d7d969b3af95e78bb335,
+            0x19817db66fdb8215ecf70476c4044c3f41d78ac5a549c684e35845947dca0b11,
+            0x73965f7a9ba8cb33a955d42da55fd7c37a3f0226b029d36dcb3fbea95d642f3,
+            0x9a550431430846b6694125b5642b00607f36a1a29485361a3cf427da77eccd0,
+            0x68eb4e9d6e0a588b61a6ad501f380da0f009067666c0853d156e33d59c43515,
+            0x225e00a0da5a7f7496b70d0923a7cf7ff332bff06958cc0f3fad439874f6024d
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_16_config() -> PoseidonConfig<1152, 256> {
+pub fn x5_16_config() -> PoseidonConfig<16, 192, 1984> {
     config(
         16,
         8,
         64,
         alpha(),
-        [8089493102530595468824649860529717181797071865148765611726566631095271469313,14191702863884040950201894968554909828474263688190658890761244249722339089253,7127251756910107506817428481560230656411897313679770455026102671367474097624,4637045655841785226199626823170615348821917492997807409130873179711115857270,20694397780982417522377524687614391225351058648522092200738043379276991211973,7370528537006777008458800981771544164650999525791518443407240929647301337224,8357863226135085648491488089966537213596680483394798064376015085804610201240,20367087512494301090653054692863377975501664994817680661442168333644299005261,1950307616347822794878104597377932622958317394806719432040871827549672571148,19534568412595886801081532478416580190048212177563706092280027206347120417736,3526428150493332211163778868665379218281231008068537115657136020226387337771,8661888879209475483716403816709663500534119170711151152467249807886559994385,2374871949454649266019269203973683966955509927334059254254180194157352943840,2602346264611026079459352146265308073912201263350931622963181149514761751618,16750875216633927741061710170647391823629779494283192027015930006045661350833,17325348607596842041611786882495470980592459865615213806942169413086586278610,19257833407854296241609506861086921463964253377452883026082737974007723285939,16875536222414380047765946704936299627494679557426090013440678117262080229388,2035577529925145134060996791483051399276402053645795728801937468290487364296,14222296831200170749164428995066771764920247405996747821740895709606052517407,19708208883712347371628256596476366883171584832295648266624355950215220127904,9765600454835189412776212142789582666145342479104764891694616693066517922502,13365055082376018935548592209736650793571432301565333849832704476237136996118,12420692692663472732723794387493491467146971343430969855362995088112286983728,17844493444787722109223680249951335211927705850925719012603471955916755628715,11924944537382281343613401541176014853361783437608625866798343540969055542140,11538333989403053525558050588509973706031711021450280471202165095037142068477,18764881783775503232423409005005138632447539466481045749407270569758537393398,883162740610443285913150132085694648635519837269866659825930623017971541006,10171610390436513861069093903522467940290613868370765425375996220687957422386,3782996878040749700177878799895260702330488343333700969514291046490113056911,2239298968343190621001798397134314102896115970272480212453695048745962826317,8391302051404015178833807081994898536482484463022532956140929200199667853077,18096164030411129129794470313655227930799185448547884977984818798794318221345,14613424916575212836238688482051323957035101724778773648452919665593660234946,21828842930708391060823304507355770719075227415675853536112390374449711667078,16155169369395425892836659730715232159396910561858841286007416017756724971516,6878543234699575736262375462702866780772252779651204219697567141737826275015,6515580357485419559928692633356133128461299871887195169242750902403019378404,3124270150531482035695013416051086970123461406854560487654035672981879561715,10574698281815682641771693421115734396172155905702803455639975437772362072107,16383053320907906491543185419013182425229207444535577699313377451249772804551,14128602818455692582904557734609240140547347183347545360942329621911511704432,5010441108136365108046592406551529565385874487432431586303802326844966531017,20105162467673383983751690623903949493335895059047083944279780871549558030082,4243524359837792598965046978953117623831146922720880550516255054678204683627,13992943040313469850370025986460260524555943628212884466234808367632688288666,1356223459509978352432345061666791804860823828908318470584528377749655994659,18723939192823222870283999271398340959482157197116460943968917507878394278385,20636603031793247786862933945150382157149390912061952007323929980504212222032,2128636310217902240014588202116301452804441854659460379597999718252532068242,8892458127594737495267008183431736534386964959413452688074230438040504386190,11063574691797903196312547816101464620325790434381460261930676459857164737407,6204567085759054728130072959301910137692879386674785283047171198023995380593,801138962072186678791979363551434811728526970692377261272697294596118718403,12941641588837981062781447688458784558606932072335320068724403816548547438675,1341967686547656677059175660053506857201298028878352128737987225407679621418,11183207447266717668611438117401741351804062326702937903525908319309155043524,18507917680426998547390822933408085624123062783706353845158832700169805897057,17600956758590554476691669608345000941959084040124470813766683278150335958657,483394656899715242498310209793599026850663551066988094136788591643990355221,10090827432001200203094010206359607863114405903353400294360808239534902160627,10039403020393871677252553778177538625214464462052976366251977746523421324197,1924712848258707645798108847678093621275398467857399987976700805356929290674,2167923809975069342404582706442301809782773089534518796665536897555762931998,17151337466618795643803903749019481111634005237742283518609358703199930418386,4693404918498880046514671012411195415185134287680728307646808116832211396470,4839381186041991439202094011010050618021148651243083039175474529769659591768,6368336559448535344096548979708211013055912139451892726345028976601375052582,1969826462127986113899121152613324197819709993940588880171966228829834184618,10949071784553227115382687140318153702912633728202525040498248461299029092720,14575837988956266060370685891330921140979730144767405243152428616625585430364,19025750374860322288379311751788635906611708349625974065695544669443137256255,8764838805814072278932908632105809429351124473407135322177352737762640822858,9508966145895699172941574119083482387827406291145211775810415653335356563307,1499853062814132179278896768948580432185360181707926223121987796423000161587,6748895423937754323870965728722563272366114856617067613970193226138372983547,9814536604142267489967579335173323116472525708739068285104384748406479290252,18898551978119284539473648820403307265793266184829523824179430658011490726286,13332891294455702171134399009213907075208764727059236543259960129130320074982,5806223588823614408610900761814632517803554600662169829453323047489266087405,8600992771060584427141790133616651912076186875693672268259185811464115092188,2345229032656719135417406942532115442859563039531904661440827899574284256939,3389225209359511603097670682835778418062727662626674404140526378611375444627,4001034682434006987902788179906586121095610380401857294704332109514659937637,13067063794999809131589470979742146742674772176859338210659998590141023560073,6021149641876662294720012642501582990883570287510418620500730995186581678990,19744062936660555217694711756418639275110313106982456779211457821487189038259,4280146833782122185864346406516267200729946534205141990397627632307276252746,461380210352497258096433274264553487092816458993207056498455795007735775326,9185904966475190600688426658264723956468287249470549941528026771035049026029,14362213733702712122544208087232387435453213772974406963783416068708716342186,3376133122839395926880247692021311631985267298172444834121553500975764354590,15430636928872496244042298024957854104479533547499980110816885404855993587926,10066678820787654667318707571747478964216410231002799394324814978870300697084,13679726663800139966289976616317518761749708307387522908283736372782010246091,14452498713182028708607687209189129972318024710956800636750706657647839477841,4665977443169087186016514814881141858109411469723890078365751966690257156734,20673947333628935106924449469424554002781432367358546714606202194020160454893,8371937803667063739943392730412639954872585103736021824547232324141910768530,4915642891224254203187535229956007243890165147322145197624420790022741880987,17737894427474715513464524059598818432164911920893615068415915800842574129123,21257751286440468433003251296883236318376753833102432675015194790356307947025,11831044910484530710733100158936923549935832556815349526083442021617595246222,6362553671302097483758288321671356788227750730995074141338726755028234269753,14935971406087488699083625022278942628959200513244202282294495763807242526556,15337281352851760799121170871115742187805714822038335053341937333897883894609,11913020597445264316110942608419581486071629740611054234626537590474050938474,1838104841451540707239841220222372684744879960533787766800248740162155353463,12200586110950172266226854658183951607066336178441918240404611233042731023944,19022187774400544497696484163376638844589760125070799280660843859892595613745,20574219232807646025576258258887918895888511977194786423008507430088227970769,16786939539299167614623107235117810634408742454195124075763115939760135086779,17293110551721019748567259052064171353712124247596873005371071440209356535788,3515336831584582569659665150343000056186787768627351931657274076732504326799,281425181255898711371985357453012506419817930424882315501470435479210893648,12703632225346671660598644961986122293501524448004046573092229475506828991982,5589259102510829346047060861494427710966525350274659545392525201677772096380,16136155264962057601674035851031539132207654054954939479993843931937787809008,6577810342827559587628942717478127045802616172145914985109615391025970118111,21163359977438641650165237544426961690819476598192610702649950529921750524674,20111680006656824813833529237249851680178501017371275377838319189183351852836,5575615948519348213741695691025005079345478514823636124237182535409145360452,5523844323060926872300411712160500242292621601876678751811292002367512597282,2341781247790586645587607723874752210647545627417738353111026163429313125329,6287726121450538785847268284295299220404766172163996260292255850387839422364,7510648235102286772333427364079209113816404370140168905255311267436378725194,5010598474035699846534727472507206499428871255705467310762876793528248455251,5700900579731011250748267725185425351062102227041063523439252105791254824347,260864497479086430816275699586473497971665832148788274905912958670548982986,789172560806161139006535038197594038879692565830598745604163919464033838458,8100205286609553283468855217617464988341806863414698413875768149192804914582,8832923720458983936387697888604823914542155000760959167380458346468815941677,16408716740290439442219096309603613006830415688534254451854294128560591562449,1113287770802944863484309232492725673552460311886837538428140710794437752025,6321319205351235108330320300049882062942831936257890309503365991814791003082,18560922321672258596191688202021423732168869299915307979899958586924038420673,5189180998718572459539043290302679421565915950138990634526371489122263353689,21059088895950142731136323564720383671175925416797251043903234558355128937274,1758538453070760465213341124871446098960577889968251388551632606564361922354,8880106936008308891697048583874212287093823544613405494775675377028797786924,478113991762053058066048308336221551443374933771727184756201865704929054005,5364027562586142278013801938849728210749918309705526248720112356632858758221,16060418035757996187280816105829974246762721308664137780198420107462005497738,5211176330971465153824216149376981285606706263050338982115099875409328929990,10368007546243825628853187421535635929255384415227635572356066208437184727920,11427684168459596442778160390157786957054817508127224050241732612892526145073,18949700777601180659579150208396846544227381511915556752893455904600581402034,7164876529024763696100437397763470424696261670104386888341279210050743231742,11672893202716354350665939605724566655297144836947407230492353459173601370992,3909710158111676258105703555994764863745260060728195069107924779522169147903,11345007057187618276350650167405783488453459256756441881422153715183450077456,16177820285119478894470005926103825065477859050875380004945625842748711696023,14605787997931757094644238801452595674783310674883843033832086542610678460710,8394271758834499906719701243007064560791869846306715272114566194508664069904,21873434283102736245937985212570921154785039540401524103800440576512828034687,5288693737755970825903341313388382553570352630888453317445067182115774973600,21527468641133089700262079461319550104586512157305923587305104390806741900810,20906707665998407830558869509347677772600060055286961495556134628147066213175,12592377229521260472205372896527756013482774884841906928184642093380092134349,12910817347876296654185371831758099341950752668436921762585644650086702363745,19707023277054651202681442144426045379962145417802880101371794305270012080065,5370501568233094600905283140114160955385907390235753857797923590879732764547,4893525410028747500809250162311718717246192757157339358355279414251440821369,16933412769230696712087772684638356779344465843185712014276708361284654443016,14752252971762751211424871408209457845535321896357466404820315342528474475265,4381439374316418237204510331759065345075613480172639747277311241150560517970,18983302468109324889867853797358234303151484569217755559414917991855202421044,1720853637877748574561923069656227402993841601703014320322493127808042278354,18055674086054269831422192610284879350534759472987936156359168085840018213729,10022985435599924530950214242280707656465340100733875531414649379326713485700,19489289237398317489155396973411927208825921597467958674111652983018260376467,2483969152386321683533021854216836603663579724438750369420802837936459253247,7096495647820661985493920714559517131838710818830485847136203068929085317377,11239734991193991562092142618442979132467959527040707676033760692044595660477,13964689425465688308583323493745924709191744803740806305195114536185949582431,16765583167493792488003846249322412563932361325466895848165782639635509252698,9258699025821383775657130802030622351199780460158138938453769223645462201380,7261743362549790776698831974802523106349906457536556119083744106556343806039,12174595715224479314914773177369125156875875973781826642881907250708051936707,5012109434360646519756574765661145101042498088812514145017131935992653466441,4700224901573028234520633038757562359543812027452948633531739331172070339917,5524276305760203869547781419982228286567487292869238897177777816144717638402,17095081617164642751160867282346616888601375485714887290060713493809720024377,13598351826191942256399407492736185075239065075291047608049023984461266141081,17308136644455825036504551600136601372687794695239587014243640872267542984788,21730115551932424945388178787861491256026727823117641122401508483473017057216,5949879858200957394974414439063213931632579243992797429658708423363937192395,12803563373135008849577150591968062878999687541475931973931310610530915756774,6197313147432278847012935526443261694774265540021863115632496255704682355001,7028974783929794816060380650452873559926928309476428464943277081506765913122,4456589108827474318002287720505015907920793224049488679883557016295128273089,6100631380538490803600079371988603006023173019183128962118450543769518343550,20177888580254527519697427670797609876974132471313961205784103868094735572841,12073238358529645427878918495905605836088922482621503239707831646933770345610,21856100081180867115422179532992210187999850914786148325024530634866939637660,12466984235357303385071417632152615871825808908890287534009467031177378240877,21079839629488810269856967110699842674750899640941851601070908540874579869846,17874776547285892135748821889881943162098691701279199858985484844123833691703,1051310306073108765618056817409777616413695911463346454738615844650030082984,13201928900083471438265807470373218252839081683324776881761206414378175945385,10190119257010511211543154766347424644241552289850760573785222226686792626364,4688333485355359912766058497543573340825697092661609637162867722200016624599,17123765906835174464437643379916457993692257252235548439872663365295598699138,17134395901615480964750415429455088485278477136528521479550104193427850309670,17940167838269540610857156370913968688439335297994033024607831012271846654207,17211561414938780959438190369003172382648707317417933395371238331823656001285,16098871745352156970746489901084198750790375003919623885201193800062775011577,8110023901773238127710250492301336333009382423651067999842110155158638763822,2422126936887420595943345532312996428472865746519279257114791700143799243285,10404075183720133448708607844137643895914849868988851944394714021532771347787,15058460651933569411128043696753704901683095219148372416995175617698935925786,12723555146577954839266714779606964953587444931552430067661560518513484316738,5711657581065990142612711893585463369566607394626940266394184697079173482347,536257458004844094090200378771107142207864145916201798362001449936167413480,16904097338561724274235483260490381087656469057354151613747001642006805270380,5885951988825802528717928331501311151617037953699202264796404860914064325522,1638374036867203230684496314040773233229976276864977417441853704948079389600,12231982678049991867660964493898657015614690001085229646831798098083877705620,15427058040900308626278462505422407030810836290013997730209614367042825008816,8287021582226423932765127558352821849475385690410389396789209560743363809623,1082920048469231434960727235146664410555571531264546962637788898495946680112,12010985569823806398477426440616395624594456642130882649075614403521532359981,1296330560506042268524168200578272313263311415565810607634491211599523487141,13952994457760775342452243315330031022436205430079469228726234965837656704462,16985743548885988875181345488907967382109958231690477723834234297604193256890,18108965571078287240054765173491615799731924163046353815744437352944165909003,767530387704511846542067425779936904920481384673999726390798572580115466105,13028307645272598127894992332463015335938472044187733546491605798735426870634,7618140648066747223455845067208730203353985191563779819124185938438241329003,9331096408013670718143367691921833484100954507332698681105640867440874379095,18801244145798024592964955007270988394935375648640247134868164095028295260248,3795459656522732094044639001176736675357207553263371458375866920248726997086,837603424793724140470838171288512417218344963365692836088493443407197621528,5831962429370013799978251611601242499647911352287066127245255213245836916243,15608629818832866779793800587027419050315344573115273720682841552596629193016,1032806196152635164955947370516112750756471391006183599859124038948506281039,15696208732714216759620197747787990886188845785832889089576996959760026394301,7234583861372635173862436546128104054595325252312930586077823639855585372879,9351673222157837029929340587547626334173727344379333167413124993232252858910,9944025695384518607461067522154717153892207999526158631473359210163311199905,2388456762928315498284690717786606118379553818175612967295585468860359388241,8762894023280585818322989976434413098781364467068028456427186735232945062041,3982990592887978322236356963193527056120817698005386105106663667178275102339,15305580827228104504176089928458181616132990558748682555478070517971443343847,19329984412710376451608868772829323267202139442902035837598118892290482040500,16858720166203416564086563387111926247316950607110418622245689767918477559853,18241191751089003023961171787624834962373436019307905123520202159673396473314,4235718345809909430818933555490446039661741163040234575769526351800272747420,19336790216312697816897624746946849815032853517670504993859895524588720552146,5833407345693372936993877824926303626341316298366978224289402960052763586750,1246029211601050773151495439169819001283925818386531745942667315981536442422,15220086581176169769190817430254624676596374261069714496878816359393753960898,2365861900029834138601812494207710261363070950725532631535675557556177296586,11098939996500166020441603457997996414027684936264124308565274744828953147961,10188381420146390141161084654671015083379584925005132911919536024814384766817,4842017639583023386245773507388835267437650777401251470903076835565728725044,2473142702350888708640145449504461869356502285425231033191892981515210840933,3420689338060147901034254227618353913575873772273264928595432321920193621195,17283074258384994096612354354366039962078336488852681769982384814157770475001,21006196209784588036771700052971738964442512933084691689593009338899209077510,18493924441589584713280363204662484496255740376612784432044649586411869984552,18050342602178255577111253065667811034294368946566845729063425104069824407598,3678841436690736561960339537207788725774745841190361109044779271967419319179,7229032436003943468306271354423246592397907094971085338195794532946516086746,6074543407778673702938004547803408348112315194664133731027958879041743082105,20066840392762178519205386382693042859978931394221116082945207576871299356172,7392805501563984757154630589230967797392843859128971344647830779113836888313,12821992933916071670969878929371658252743368422895791718047075564423909142719,17668945380988406358182777882021562738916627352451654449781528301527115094220,11046977583853814151360987998476416244370762366051844251247672138778958746421,14002539550635338734484852844372585460419306414704948112807545053902011590061,6606166606298514036368338857611676551502463523513184670555953533985389963443,5446061818493011809543734117506203755719984305445968514525154959975352640311,1111668700238284277732413088411620500087954609586256178652323895010927817926,14149444834268176201304046807022441432518948094788616136522350328948362984806,11145589672768136991149928307436511325152474561287303838823870178226307903252,10735913608001838681702607049464645919999926391398426712273901727922068271016,21604506935173200936527132172076877500255612688310066661071635553990139487164,15839861321575777225084554553361389979179161218821903561853968278717519007256,4119757287481158134674144154651639875410119871143992982693366998676854632059,21215853876753845584435912754954004476252409742434691973232278809063267703513,6474112081529376586123095858950370103982143188298415134572081362206457634840,9652012486829416433331453480518336590399776148133427672040049807230079809918,15197188648271522366095502604900923401004235531330211517976306351199244466155,20653133196783868133525869637730316323485671920172550159454294692576016995406,5372382735415117884334788700701478755716540017619541377211078296573383620529,13207488856826369213621681118482759531513035177166234417284384049787214456366,9796874023172008376751307392327706745295558991768659529793122654595100420492,9923897870015737084413253850361127061692788482930375413255676958440886663490,20345695890485642585927456012849850866425595188379347054737827588286474285546,5970363931303429796131779726714445177344307738485323531135738898520018230730,11099832493605970375935052305980301651220466371839450598182845139430995541342,3984084259485258180085200952180050171170098877962423607492480207306084313759,14795772399510400766677766636479617776597353783628606580152075755214440944984,12411649494499018184602448007465543838785542392797557004957418343044512599298,16626394877225947777126043865023393002546807148362691512796749460115071596438,19056586788697785123807358806982924302021705802715675015657752728604200366151,4434453689868848221439283056960830923558217744100875597646474729523600908085,1558497076513757145941997689136111603376893591128645477322800957597462648163,19855312204158524284458047353907697917092904349885231039917644721609392348549,14296610840588714282305996857377052531476403374009704740496611471123591762688,4255702919775232787836264045412364184259731261431115977947396605020618214051,11933778709913818332041068411271656949772987367132405709674023277986614336789,17039721891026771364303633162265090865698196106396237296534502784700270974342,17677496806049413057414389850646660368467945835594987026827101037177591654389,870853693457310346529819971157542197768087609061398183617507613118675541833,18050709179661944189572532609164386192084249162773126990656248077533050260547,12509892200475964347152748879404468874956023169504780638942472032501158691943,21290469710465436947459252705329759527038443945558987181251205171276803887919,11697948989002333965655987240828667368730889495575710652080571936823918605037,8736925166569662118997397920658489847012314542439353474077461070832299486573,15840706598368315931966990863663232282633707371020640698077565307266653295218,2336556619780315190172318504866216965057876522664932909981631800248874766723,3401386693708589750154291055903211427275255738949699968058464589080271508279,2985234144487193053560662812519604867522985647272968908108472491424983944847,4708870044417079288579972819522537183137753616055169595344370650267781985451,14922125937386550210569417108464732470846637538443952204254988396764974305556,21120247382250540544939703044577215089934389719849213503558017786742393072448,2316928219829771701890891437885406935408196453098584469128414556890718887397,6617231706636202699892427347447707304283374531129890683057423079735568483257,8090371166463272188656489380541987815472988984318384965972491395697937697839,15553944362864127106455863696894507934518908899701997904436263710171474812555,13969363969212770297664533823398202808376213044430873505018872984372178723135,12323663899898371993768411530695190245261583246438004058508426675150745422627,16566875439359417854141203050455423662432117146587478868034846190942245403701,2085197407488705803446596939115235993629808393250087488250514287409223581616,3353163139852271259915937989527822937141797275129253304946488349312180510876,12046433326685614994434242499247496702084910418498830651483913063626259071609,14532850787151304296314608701306827699237853461438425922459530673831764439726,1248026383149472348014634990743396120794718445584945878307644249641199424325,8057577408830637105543973735712037717868264099646638037329061041095961932706,483318248530006664922961695058460281946793595997210254862751288308569479187,7597115662868588435202039449596982590007976221501668730777779068799655592123,20576588045443131888269350588198092656950342341724106762422448997215666028156,1519447772833782137513870714676314005111021965782273965574223992106447841589,4564008647036378562957325007261730909909040333020122431007246472496053026801,20058604285923748821870861850977236730661592466138938301165874489677433369725,7444135345158592582936132362592519965410456021574373937334236087846829245911,2619748000882337075816263795535027848943303678661676628903586805250445194179,16416961968137667392446268131224700809614764673462182053193218154672694280838,11133666903754924307114887742321725054257211678992195923482419349863465176820,18185607668620497969429683073093259678523061297809671850245875139394070019601,21100277417778348195596070047101971906596351310455360764416675735903158404363,19242696527172349562445561603976204919773321047775511674132373901693664836452,17641599298698108341739444819055281386405281781490793437098263180756526877861,3867854105746657505538112984381791148258872175005817045777653312620913799165,13673929044343556285939637616797217757029992003977067790150536754605693560092,1413616068844936743999269099411394796998593026467324669628149625629672193659,17182247321635044788965517464433108044764735758956097220834338897775232927292,20369403412607032840251975012855741679474191692713337906759271231600952698270,3368021137971787382116663997287877185273428758197831072626886100000321343009,4058882993633327642712241699549337354407965426094339469485649412411970892252,16745738472558294852806571713586420783108275141805815749526145532281107769806,15581910313143599067008775890965264886765882549739040775187928885624726340064,18274240790635707268508029122006654280996256674828118427269328392146795445159,20233611060321484677112349983942832171860822463387331585688221516502467246411,9578794697709092641086862842633192064390680557390699768090648655701242260988,2852999879330450264744202807076238853213578558186322493583347517686662265691,10741465223456896033565854764716115079295016404042872162238148987621341827594,1287682441013790555075762279132093640356858755666376578858076731440259199594,2754348824392215081276565702993043505186786457070961060283939332925679390910,11228376276796390660691597656113154929593350154734497204665175991737933493193,3311568804745845654494413785473574358224291288129470978720234105131364795989,13909323234259677397453192122165186938471237491769110758142097116703508140857,16483726454860443352311561107200491233365512138292033674515348800113826861405,9812016698744294015002456058504358834959473085649393839832264042031387688048,15177982625372891489410897122382147270421146795964397363826406495667593673282,7519222254582187388553575935727848524972644886624855076224718541180666103816,8301393036521557606902463799168007719863879180990998631543603658427343679902,12294426767414989378173056202553334768408199886443392931845979330633289559578,6739869506728400044391551988623920236526787529007157619233939477743084008138,20069013437903411974438964103206724858007754851513756279456345172264534005155,2018834934981362435424318060070780595968114685660751661802811774334240763265,9403754976005906248280231838299490163038233707814936394634595857779528197369,10417979303761863711608825801177810340012849177958033395021985945544086842565,19604977682052360618680964990952175014659495782934855476845092758883928933035,2688418347826037364876739676610309530415711729219616027453603183128414252617,19429655781202385023906019671461539686080096105536288714975255299583443223945,21850552082723421744247018249567438591533518178485575560955887428084379635362,5617579950805240697000723938792084314286755653766678432489519653418680110671,9555670299297105865403034351288164766308791892391888668326102655956067266166,11495978801695516791606532228534536491719831441531647897999875880662918322774,13446240540987488159401062110915298027617715146895881354765875946092155869706,7830137135198409572038952404379496414181899227574329472045729197166487746395,9556039398803760338966955211123892534270670688829455928022562515996727400498,16536848921900120010270774925810022257466132951671306792158048247185847693295,14984883995702583492812943326719347992462648669814085270913355351041523830317,4449876409800178139287642958372279285293173800225271693328528758341654973266,7254404965814435397385340781449208987509307430022649779312503908065673947649,13482540945483896073831058930261724641277618328981766008722675404404347005009,8516464109813705017846673381161730340458008814885800650922822516855928737104,1123466447164703934328741246642448511199513706388932930170273400845584259512,3549658554379334242628536166107543119171319090515117171924404150785175614651,20050236656917680705173407104625075641049186986084540346810909246977321174260,4328179367990709150244102496965604541058014472966567986200766436334838205729,6523960484836646945629638483047198947455910731228954877131634689551005111678,840118507410487418552201986292140077062095264830249777356756239948365951505,9443485141542020716795178817254625558092596484849541439794346219916656780924,17517352113160950398700094980635300524550125065948318365273967900505416951637,3558475678500267728084169977682358432036940763329037251571517902892359350060,21782716253294940222641143651977099452381765047328512527623130468565364299843,5143600969269719315523014195013433247337519583796238248783742413790148311283,6937766932051718809641611511685721559694403467477888704545484121202675152929,10248511959409536383597760784458127936162061804351541810962726000050652155800,15584432188633520588792022977848834701354218910295071102828776215462904575092,16507813940325077551530806573175229924530686412372461197571308720671287449933,11975780799589036547299759597975704141323969091612997515060812893050562154894,2743143635303404960353780118079778350398309245035425997562746911685628540405,7772317651868959663361913464992926253491072635393117289337616002993612374782,2337519377771760840047685336751334655527732210909930380948789294151305059244,3616132500009609097754462360087761508553832847286785396472146776175233605533,16840763079152094997371697832566620838881567041180683145570810083272689914599,7660270111053834825889064071065415593147131275236956990950685283090480450184,20762611535627684584459315491847035257226740939101231132494468375819869523509,11042134071344142565200223013849882651956544247603198913312251335786248573941,1940414570916441943786503544322754456611678071701943345167834901237861815275,6726537219661359488596406444614225094882184675245355532878420949418407567309,13510096963519324808490741235975735288120771162631019837713476375721562862601,8622373819062603720895891234592129397052930901106318032071934400492518897707,17024729268332782126190150627072810510918979523772816301096433100167961982933,5587788522776741050743071285424100117576582212221222382824387609679897172811,12388474196602817840033287553175313493977358457560707192943603355479290048023,17628897462697931613283808657115398230150168968257584770836553363771557372104,14065018459890202233327759187460200256630019200670511082974394473420421694399,6104554150616525884927725557698817344144889522156367737688769378902924558634,10992664178398974993431947901729345793474931192615930318284939994040095999242,10969415364246753478074755753965479915045305330246521543663858633748866143603,1272956806332000540144317124032834499397723122931270496707464205344164793800,20231387145101186513751955054188659753720260135170026275339142463242692015712,13619345053559735757194629501334040876412094886252831860426351060385674007066,15232357465863047438256672278087920688704670526832495687820763524016520668185,398623536003273726220923501915643032345957170167431833298597360746684401150,7028250324917735970960317543369047790628992348836498053408852879988541935724,9906086796055827169135574765108677877733074061825927799032011921038506005373,12788056119136131846722253277450922603309904756259034915496788214657808474919,7651468821535297879836173382809170069017662802420683445433781610638854359553,783979512383179545035255083828374733462990002107251717097983319441159249905,8836457559777657917879541925866800908082149812458375523311279635635800064090,20144830911959238621340309337187081519944136818938895654338696747143855879203,6287181334311526693967500402732058645490470512478517679915786729496945390849,6578356433253304325301622313818326592018737710185433748824597250242226401957,7102838428799453179757741468552077315750505008228901893660362447987283707998,497820320926977947430162841325159818293818758853362781494155076005984229339,18160985608878840530944322708383120179552980243808985184923313895763861919637,13151612592624659285402557051397602661028781656351284997191435582230535568502,15780018535650817819214066689149640940245062275718550628416824107970066217991,20500218068755784102392504532520873969817687889455201735073738515957629646567,20888440956803193084788282136946318522770638138510716565517310266646640263708,15971618258529607882347998799169510722902529521092131094419433339204085498306,5293253007777884257810026986010586149314566166761521493811000336947093325852,11581497334099661755434309930999056492294889088823870215073663090290932016658,741799820113052677363038461398206547514107871854645629573511776865766479899,10132388802463968927185535273034278687094388163001210029432141519239006715163,9843127774781963908073388692741045845788815542021009420639678295559452765837,3807159091255176851037359514650776155078897682364934585802230436085278410633,6904224411392552889784909729922790171388456358295280077234569059475136886573,13434461271014860123956911179522881298853645897065359788401689426904150525428,12249944872255100022137726834287337969948262832177273992983186014370317983705,1080721436007830510323005297307130991703868335217850548555329006531295547187,20651452101643029862567543402727347872461377965899451538964773059299839803923,8902465483627533643127758766065785114055357770410218037441501029224645377694,17049203022284218301986830675304595858941437294636126244507847280421482250090,20389632733862984292955678575857173748595770609738193230360968914580393387194,2628553647311400613862969480533814764766703257834731382409245421165389763845,7113709286888238485244587172405174762331565517345483851543315956528264191390,21099219272139712501072896978936944264265953306877942445724732180674664269749,6196322429352603190460567397253889100476004214002852031233332452859780069595,8042719870001485176157425681827371545772290235839006373715151688719449512739,9109639854367609940132679558323551490721386060080938849664245212200893608513,20820097690315610819796383305043844702226083970185755192990081897048903995104,12474580713368057036057537615251118300654026141156267907684197425413737128906,4935701571378317615941939703137616736056472417588666676180454398865436202845,11284674041151323919882446027842742890041719161934493530658741778909469887490,10784274648620717180750449830334448050402020683452763192417352842268830091773,7221763500960709043106304906102942899855402476011030187016839441411503790134,21488573117797078819915291564603086854092528370673732237937703606783710747214,10368071846917543663295415889847910771342838450725996382692227125006143332582,7189971404170280285101021558651838178138415948558212834138150417852815291774,3622212247952623996680563730554546964978269732772060499110124228651174919309,4030261128316895271453652515658449745835613736325708089700420629607904984695,17917906020983172293093657775725231153822157764639429745264576611859524349990,7911943088433991265213669750138013059877768768674246542956611065207230165349,1237568201834766592374215633649772138875843120827112365624718270590862573855,3421335729151995408099494011827853754192179969298834320585486465552812589072,3983646153441614758977318714985842223356917025653336289250912061318144657309,11832501153279122995870584183546009144756312133876131903016034834496067810803,9642188977879773189558548598547584337663289943484049782260608599281971392829,17650631071515565052542834438104124084088724345481542312112093611903334892790,11727835841766435406263157822186528758001431234638936084294421464770985535272,4170985922866379778894675975982515174956777531610306941710536931798155932713,1904373901352853963433078121273558128713374926256562753718137883724136086536,20310106358538316988108567646970248789216107374650929380709349367764652307148,10755444294914746017826019531774644079659674520334374055753829758342372728308,21544150011748410796331015950886967191957797301800349750025078804307553228922,4791178272915634809747385261951447492552726497734131770971381971399880792451,21569911489317541997628510847711750299218484102264583013015022430206018097370,469129421958624587885163292532024178451414238938436764179429972880411747423,17178941568791193515971789991206572943108926053917999875254005411851993177716,10061493654971891913017572469769124056153763544567322059270144080123216592759,20809728888234709563099636671010468945654173909532666727272823672496239666493,13977154471274089663104412732631175732414148541501676926172952880637640768097,17159586220373273602393948660742324700378108883620196368910126875831365156676,4073500643742253412297370658761396932893392648826435730598979045413705716932,11493572320701213886088466735117685416116051720844612287863434228749232164029,20892362924238047571943713393658663337479326222564740924788211586758905169271,11301788649359616808987952401363629750830090004562424782094282760076674679757,5346827191385082048034578496490044229132766705726383391388695220005635473547,2201675309086116923924279562154152714268152257293936509978158351509848697027,17917826577478806664624583743441880347892085028222113450954395295616044284297,16998236939959525187887324821682683276592762127156629849525502305788028877451,4214391906402965555572230230924694640705243512659675242003943183722900957472,2247036556360539125313249919915213027481437766291950011195105972974928736865,9520057428546863347057860284023378728609842187323632161028631359500291204227,1828736612590741052604266070553266072363175828159047049110641125134408628099,18248580838532636162005188449054546706775958322552749296747411333541139803294,4834174634635006984667037697276171446677972706028785635301769650621697899268,489734793278913821067993383657373029590536750171301785048262915525334613888,20786356799510136039282916235428434827695977220581899018592633397684279594261,13145806261364716646031477788186247592609087183869974953048604633861380872823,3841420600164259772367211721293848988818647274121301867288590071853319905062,6882597113948243507685423253840830929482565588666222909972451758645869849656,18980943240416553858613600850285792319483905785062366023956546569017873987439,29028675420319059649770139934414847448931804950673695214332234580922091102,21775882073646833834016763184296217506960385126491507726769771477412306185790,21300410381086030882514625793664995316371660662503398686828472860934288345599,2472267536757789817746114566761390885333410401690592727164834695142144448445,9723880451630142367622302246353057781908243406397604481250639516011253801606,15313110769360181254868962440810453125247644871877064008660684649744823174300,20564192458187565149788272882595180521577855436987831222746293278781628416968,14590472970343049442795311527863765295112518097070620865372037933484660359574,17062841617700893799013325463153088719125540677385032193714935878731444635251,20200256413643364477818739581045874029732018697196252518589192345293202187361,4016942840923529049014357120480338974430876995693135820048221911362323816443,6537662900592412058939229458410964809681215707806173558553209350444735100542,18297886978176179234700005359672839811634650525194200352748308964228483504767,19662609243585750899960608765774063353658909677643282385185291970742157305960,10221731387204953046960523786878755517637874808703460048675288088446619398011,6359039963669314770815970957437041104980907769543152198211817790059980604175,12215821248736109157702052060566873526833550744650237478543432061962195037956,5935095671961849761918916493742868190941272209470285856382557274883130995501,4892952774759542491697203073862387895082272084344610213076129801679488176656,21229502683877666320987735203037721130704543292725579308736529207275811435612,17138707315635877064706472595294259087755028865414511496916808945331553578413,3064016632497858706665392042657089766401657752838410773325693629079632182414,10697546089228176531454125219656376659283555269092429548580998097316823780605,6383154332658396326745467904696030415502846256075951666613157084114882351628,15399057406934719483674477103950525850935787593222687850952111073065008222381,14222385230562109850723354194041721683341002968759594278414075630295191868997,4196055868873306164684774878036056827685013979028843775890547079994909550345,16495894724764636941708778916623546529990869478284583127943604032121307478877,16662872698072302151631604897467020278898785941962087730337008570271651661242,11474333637424192324648146148268767361869344542358721131204304533867910403346,12663733223747936066515430496850730759882234287115648507227477484368789774494,3278587449214209390499027872507714198695688159471276082957385919697290643338,19852281910336140665278848076045642033038867843956224684297984081107396007913,18119827693896204780441288678080897397841525584683046254519435612134656396725,3004914531848687259880590983112983929408762744461212501319599913078181196369,2744805266681634195002030539778050424843533661368265264531107280758966836574,12003425394929552979405575446174684244823087440054609540505332749485291543559,20899617298205776433505248799032591564097087832964850292073852661486959326400,18977355049070793830198782732221581680757588074059967640900502934882545605494,7774492678097446887356009465076901979542998304721485056654902284935411555748,6257979871454846095389581530427518297635929206624687597975380788548536091169,4200362970271656646831473686822497724241729322168501270846014047124987169639,9626555465339955137152373316361342798468143010897667050837558740100066479490,20599104767749131194316802432182162807569082153791773541255180345102031538229,263120164166236772856966508954885356163375871249262527569221312470198863328,14408635566922092915650756800314844499933046455992065014832556500390343919586,5183079049039149593555827045385122348972389627856098826226304101776790536649,9079663711634286747144802677527389482368428094888913737002695282424348199029,1730279784246934965982679327290069428428752739692892522465325889599043152257,19417355737429211343570897838176489391485942830255040228180844510907794134979,4688867852231614618639054238240140493597889866886829462162366294959927124611,9750344066229503722317800976404611879233170071789439067052923419204148303262,3998708829439769920633774213209304480109842139515896658207686741134489049438,21119879197425450902002580651023270363969638681856902851675391960298938692105,21081985423839377197813891376664505429739140831959287968556239547809632016084,2194830658993798006279037291585161216930179214066933009151541946587699367176,10072059773309529038163761158232080490764157196414798621723969165341603556957,12893922413945288356816723514764026149994443040839144958812668568890693761688,6289043885924508250801248626630354568142964747989700154772682955247795752635,7117847768519054206399668810694592559179837439189798231517777441723405148708,12250493458894268361669347775761796626700321541112455611623342396141245275173,7536889841233679602786965527644616779647633163370923759512908958092882343888,13743804807205248364239225685151790362682679734025326476864976250180416573459,15326756679387284645144696476114707028416084124671428061976908306742987298792,14138908940825881278249529554167499601250081601885817719517135886992016259170,18191604052705446018115707722428677617894390137039905732841218263472908863798,5747208788515494994202809520653945260017053266507158973974399964661798663161,16272405226087543462175411026937377018988783482980328154498443115982159189635,14959941590764331840350995267307957753388831891977493365286637018137237442649,17614662493206460042788564726025968337855721129414467376860164849857118120897,20540842142176422103053529661013282478418611089363263097515168740633056607687,3290501693077219671357645003459548779173001871326499393140572778475444534834,6447714071113870576284977914086213514251182728059734289291667058468678194763,10016099876948482641338204267737928588893338645093292975971465694121948536197,14390773887169232315205787249570222449199544947506512428178148864937891297988,14620241431433245619096116183667070956408821753296293274413828291589840475809,8494548643236049061832844399476487754775580533076308093638832054930352314493,13769276515160804060029880354652109198182914994347382081537158871751993099394,12260040442111865637116150785319893997124694704607680451569915655443058209529,18536763786390498498949547812325024712812297365266616445712766917775521176399,17646030323097974380890038898728697538005884509434748880882937861292172824089,20995211004588227271383296369921345208592928705280945008379701434887289620654,14012493030585128283500948776342859322003214361666347021120271800114480256613,13455652757462524273399933538052579123871086976307529744949349716824204294368,13176577891048443118691856747592745460758840755040242121263455031909886205386,10958007047406016650282891454669527247751542376915102729040783130554758505696,2403556896710211170900277969533691258363807287618829314859189083914528732150,21557822641920534343252006226462178185422073111762808253392360322675121740589,21301363144372514699996437466711759383396133417588035206347144265914876911832,21504297452761836117267872934293380498824936327520529664563583098264179167892,19008511347839951812168011659083529710470044770506456216838511009924048532294,20729557973386382250734811255901369475271445538588448251951105355722497057092,1596029835560146984478838415844959546370291207350745477127036146832708172428,18779043981021734310054761701946195503647990042042517453246401248591799960006,18389072889502391007861938373344479996746585336278814994866091596798460590651,11450018471721248431523978933304902015421867719856001119788032399031643640503,4695792303828705800181239521907223047109864872167868532243675764473118182293,7504424077032992561542388084424474665707766373549642837850671808747703476058,16201871852003230376980125294909568327837373609180822015372468013683148626476,9820880186139182810240320436271674897142093850866141441610372427566550592116,4474392152763162487463052318741100507628836016813487468299920576199966718180,6535313881166679884076402867701793095581869448631792643683900609540448349145,10375499075088306448884735241746141379659872937880333028048697275256343984198,3166175670215426596895103003450519990743126408554698027893417949729089445829,11825805020940873618060190367149910908253947573120883350031415196553790678909,15868728010683147011542066925511350470588043768845023267900379312401595633901,439641324715765398013368707995400811722128832670521930633684822154134655293,21389215620992100898484688007707226862245610434491939970737280409708735004882,13567457078921654178980424734811793190031829390199528822285370655562819201102,2491418221701715606532424215068729097730197896717397364135214058133617329024,2700199371443700220147927924846092239465972046042951758397024540313204379477,11101155530024798073181197117436499601132355735889219480985438157046671552075,7696323106369972761130328211405739772776004396041557644397285018363028133006,11874928928175576980576459276992229552831994515252269310033260164062026645644,240537705962136501448280118114493602675578232672944677099273394877211057455,2336277667844723086566433195865965121270861932965343039992167442067222380338,7139477698789264606031986148297940201890262913499702250627665080791275501502,5394022087396393768813205254315732819042275688988698297882925332496064046016,19793961339963600744392705441271116638543292070344579052218623579091649097618,15692138411890707768379631022903362931511371639119812810678572491600193150934,17870790093336984580535630746458834581867280473989239593391879854453602020534,8527221939827993709561548898140031570873635681631994323216682386420609693119,20583146985132338324328431878826670751588212915037908674977314222878838415115,18286401926708183610455794878977380145855167386311409319243563628128439897199,14883280595953108786791995875596640384464375470758397510182264364463199426941,15622372954112461900770387091989505548249197707826335911691325586886540655839,15015231518950399896087228957162542423583966819051318376374846686122344072726,4110275540712809298667287978052760900153083659165519222137609468305797552622,12194886690835058962976784720918154631659193272765999855977381550575603733993,15244557029932516875079143618219344257744782264536288508363832394149847400408,10234512862511661102613686672198745648772485307900923622631623670310818907316,11002446381083289255418443918954072583200871532274996806630154250111947858951,8253167315431388215871891033564848144784018068378784924459677347009078928353,12052362697319720881876615803891693831545089601220691511658506577522506606138,4222271910532283822428121153000170791277438320812055898378713943538215316712,5653799018158152396708984453701593562269544320974176828284977837083044089432,7882074107401771620456811688079120160013843021919844939348749959599330360070,16985024708206545567858733579435707605892308141313442111649869690900835499686,15657638292217617224447239244820122003415140104485558954475025681733455080516,5031435167133277726502623124488830505559857356049078624241295172338778604459,18251569826624635398451261785711619709466995337593606694180128347754947431611,13347210735949290753346060121453479592654490759925951960015474767685667320469,15097256163521186466089214691748103981791931847659339134237546471578704117651,18618539001972002803104792202843684224999903989910895364254642809781793542910,3535158924054577294148391849345768098132565619653646126038220164469413178376,5247111262643738028940705230194040190316748748116050300897903801701767549935,21069968641157288335927634486731267978865294883466175079455493856177243522705,15182016439888624540835624880056168611406902880254574867923247894452951108191,2598270152918575231168351721309733272482825217008498067779287914396446525010,5113774671804063464274403166444533180735260894306271253672198506848528131887,10007988864825946871589264454040608387449058007032979960058775715911078006740,6905160188004006948460048193173293195325586959399957154757620552653693466890,11995759573081381716106152146833656576924747390008060686555489446745383610128,3012863557306381401755965576258357584550751416148424411503270543269480674925,2913988303571063477501511529375194010078206270482236339308347176586704669764,5006524049092266462685266534385319119401827059140718482624293936686566174021,17563183357860154367150870160675168713982368687948283812578969167511639823963,17837755859790999437375156561325979429838685660428780384415700354505074279205,16080522246080742261793784524730583623229678427635608200910206239897175583035,2848708361765680705684254800195178864363439998055587286174501633177530616249,1557519954300916467422364113319270366979873515036760226798787393508368098341,11733665678441137100700293713589760125678167060800184611962879142675741739407,16521409005131685666434785453319000098069672876632224692360259274386316622759,18967967647390654785643258265157841586213408055603172849772769208320302959605,17571504476351312669488808692966809815779784230239825235217863108338926113527,1033277958139146991725614151292577955914352533347610456481561709576150765927,14781931979382308373625511201561097203707487976646566051328122813686985362864,4650875909473177450881505980066567106490273485086660264292847695230525365004,2914409799137239617504079923731151032417003482030433682771204258557926592318,1569377349856381614777306232175508373904011237210172681516586308749045834576,6819560317780627274403497421141083285449699366697573487561555149873327611188,16783037329427380826125478934695948949747971672927005004484739677562779828896,7015004192682971326660995855922915203604605225985220083215349611396572003775,4630816304408133216263172876471813378546980993666459834637527842126471866675,1048974869579541183196305195192354335945589066090693848404581740062134729282,18688715639285068183434963296396143793423259729912639999344372787920282768249,10934347243740746938446533383348729597078488045109074394137337392516949956248,6293725896350451546716316494602770048720703017891567394397586512386125658192,9703640866977553131835948007053717693480506246962404280815291341798629276781,7906707563931146558411066527524578790489630019846849753651156405406896838827,9702629288736663637774512920196886201521548938988112829178357919548773380071,11496918342981223624025423866080407628491859149911166113194854209867880853781,5310797284993667039758118840812749372556974855379167283523727209282978379416,4023078794142040206433592504682005395486039156676105856122688431286266944198,16871217006715623479558921653467262427043486550696934636603562460293483965032,11838323559167998464544738415089027103939009770214130070107400686110312526340,4980088349530490327691411848559646523716982917225546360214229685978505879808,9559603819596004088164413773616676054644268005451072511817132718244048934414,16706530320004737946238925506482163802145108867695620161891008305110107710231,17097818114876900788313405299390647115420321455669519337216918484593668351660,5849414403812965413267782406018277549067364089813096482998057955032613458546,15554882868930267918822925407791760045541474181510040631764755534058258253399,21580870201101672999738147681605702976639626554191473007622680366607482413326,6529597247071863795966038055163209598757897174702699285551712764342047434265,1034354038040835970585668649926410980243448725331655567931872752141342573332,6310767810288764607994771877877727315289627303796831154815613377794983946591,996939452759173758835198197713244238928300388619776170462989538225909183250,17830180799634516986244195887614846195714707335284590299432596686170229130983,19874559606908304758854510017033500134646556009065042866233430268619254302205,14009373839533951923879302153319163529100920268844053529575065501607218593395,14946211767155341356149843492542554767905660369447051530372801216288515919491,20201956319173972615406549564337979402376802300388863728690331165140287483581,10535506466358617363674252301599248223977286129433846317382254624662176433824,11029001794792043521930346330104687908171223556219538577009137251048931299365,8200934006947443074514571335915268415570710146769685554653690866413931711817,3756001813899409241012385101881052052933218317388650253688371184478299762463,18636887900618256435910622299263466888026971253061227337296887637280237818897,12062360063539460494176603336727957703003697981349882838776879968409682697224,11001722900962847730169711618381123657713397243841075174948041047383605406084,1100165499084337642558411348439001505815886538759724357694738775770474410180,17434145857282894864497601363005649089714522250566258141982190265575138829458,7528570688175530782083445771420581373161584322581902670613058236780353068011,19971690728399713343613282829324748110469462189895719072018362834001408037396,2720175852023799717892872520519566779572526301065275372226989199715421627391,14943825869290446747104357486851686014418770156528443888330443464181536442315,463946552619089332690398123288326517388219753658554785664250177816814153004,17828919314250532241077886046465359044175524922026640483099339343132288207680,17254663393643639301497528160788050107293708210389962463123967310041334977099,10548323428945380231342461328951126333180031707800802905121494905097297919778,15741600332199859123106892774234668638862408966232099592590755994226268019056,1447099980864195663747093395834509033779875532198378629216846242387465017398,5634271615965881595424665300014723762842669209816714518648909648355913896267,8004046094319510531556517659927356739393971820240935140962728964910152787977,20150098853172404856553856601505464455083744410516166414862502865711843962616,6051577504932496971373107947431966202921763803799244564057047344716078611429,11153752935200730615392163240542716924397740666674490478903681768299619893440,574571428841330767683871500343913695389489991910772848795148223306401258112,6644002840867033629815195671865575216742798076650013015371202918478434067981,10643887442409207306340562760946079189746204276290341516975302787467861819914,3310054989122793204488875713765468888781168322357480727671652094037000591815,14260109332138908810733885305730437910719800845345795697882239548319688811219,5210296637174697538908079595920299077484266890923778247313974722933789990659,12099525392201549319291916254076192583959301537918452056524775934199172994864,7553233508370030852973625898622143795815488816458055012305692281375143855601,338064484385145371035100049761904487152067475286477053744625247222287881704,21656711030424471443690125986754350631269722127039355499852011488517394872248,21372195548620232488593781254533859082570347959319967220919951808088029020212,6382011083971938503792804272844009960813722135917547320595901431805157825428,10487620314920598491955634712479265679552728563160570833716083687459951803271,12540875281457292616015016392478978686561298989814479837942710114246256185916,18617705893970874028060182711496372099359212095272496239846702650061090540602,18861927157583050522649066858336628481061253205783797036256319572504841854227,697040343546965749510304464460790931385381610135802696124987191773265224046,19957864832901242629222592391639674066674531543245225621817890196632976954948,18958366438463449522535881612753516577920408884030961917206372848340856779454,19038355323356709854907634385093529445778219247035572752290295596750121939785,1288546653652611126768551729241141142059005744057588910355805731786584613343,4046804685697550720337256987447438366138088525717758741922811410001913306096,1660762585827970516291367008365082875857712512262252287267067642443918638514,12490758580574114271593656499165833022285695011717771020275535753216014465968,16141486882419673588223773309048616384177430148674560859754337286781225436609,17480842754700647574286106752058337138867662945102069039800534716529718409113,15604353321749597155917847886619012355001132908396771273202434684314342259150,5617279871415371338336939332259796482400498338204339205308393954394249833452,15174696383871305992552314836076160250704499338484600692522408887766438439385,7427777880578061171924488290292477545896473049748950597878341286830693333925,14092813309756880555589883560674882809640120093304366339387019683168400944554,14371461943490927493590660203698012938705485668960202862586478499151043526062,15747628341829994869775701388730275581025993393892718204096081193836534027616,13069485962326240936812384345060376352182714448869348207061583108709995536141,12897613411832214271030930629934621444235734267985429117525716946550585934838,21009316561423875807053156778128985534726230082102006144117574738389765473006,1961079851137768143186691785724923358396590015729408078834852546188718166268,7449716401041984694438903080808992521397429308993548549788139074686598693961,541840132011603695915673487977337384196812668637554519620724199330714724824,8732237210312418481429872365007927003824155222103189850471564031658954501153,6523310024353124781137808005011914742907908537623530782692226224442022388987,21509127266455930277492767884139578463956043561699345583365079657386805307554,13989299184155011575724091657019750720502004610297338129834280607581254559697,13646882669283186383881254452527864262332184212165662411849024353857046450116,14437939637607347068422046603975325432039018873549816106341419990853530813605,12400256882351762977557053352624357859435580188305833994340851255855777961583,5318260629482404358266028277859623051836786599425915900288734688050650647740,1629695214770269012001751163254712973932233705878496747522731454404864982213,13712071936286520679632088394106925703538964875601961825262229735589116706613,16370398845138146853603171685418735096308178156853614168785529502102183447562,531316798023999736377588166858362632977098508125317800095882267717108741597,9318921203266238488822738977554047526587525733728386955697050423076330149397,270377449844572577022377874031006263208440602734811115345017690504339807539,9815014161182964374794581271513785279039355629218722105019385525592211310401,9645578731676628215511306357368922184828636697072609821617709363109131724528,8278125422456187544426337239756968442258418675393889722193805619331692372756,3793686014229600852890515574697744650225321239380634655110095131274614241795,11274706713173058310395599257524413726315092599580477329306442323879171602089,15700516289342200878818538157175110895267852686641088808116754074662814875793,14231470645515485158149500150154330504733538042275634884479799789708016096981,17009943350256143028237187628790018788978713833977098031809639804676372324573,11807744076512700514106955514318371416449053759940168158181473579522112561617,8941191247819458429052997300931331828693768320666304381154122720332624423159,20810756908118815132070882638097329621005628857845667418135716334205275433963,17633865705062992379853990460318358612898966723353031319355975229233791359833,20574714650596437874739546946725432737055645662464099228865520688481435554952,20753133214966494228304506683244546691191781338293295716113306511488052350935,20891917718961601440155839168193313007436009622881050810291426124657399756167,15254490709565398763344025189458873521593894682543200304507470388535826802423,1579686464441495454543935122179009252394402667945704420064352314351485765393,2776164910982632895181744444931014666522951510059312025217047160140701867676,18493452977704296940835401396385377366306134685072368153755232646737492155884,7466441893052199319529201615576158956429673118460829755667264030485444838721,4862779186474359727417788114204862127925883646628388801420770199523844825968,4332442906725686065471004321063349183397729160637280571390764069298441846158,6235595676847271156438843637266606946005787585155569320931268977334224113102,3283545972614629083851761609721595874215964445590540647737064482671122002155,20190238096841101806664255153033971438119127586536510897732203034569691981419,16218082928311959370464862694396129351602418127064911331498297863184968070057,18169106670538118432467974548733501686430842104311041161699612921427327878488,13082519725061669934177494520541983774227971959053999627907293338903728791646,17917738025521205167709067376626145668664963656058875474248539992479417821761,10201169720940960483107286532267011054369536208475708600788396458879352247717,10086018032281190838410153727159750412677882106214361975307419597102233105666,12682273581371325166244148831560984283003922721179649899812794401686084266959,21151848537444166847396763358911125604594195283585946282585966889014856464069,5870563280212708258714113395803290954804582727013499575940699343839714979459,15818574025355019546843656101475484151535156797083091329572001913076927497145,9172129818981348435701876676880219576808443896350696165457788920197063328446,10390962755465039363458687913467754632739357930439039623432597903165701965254,6161501669511652251380864592245214064026880951608726788784852344316145896868,5405539522259494292389572744962975583699928794990075330665720986459457361914,15953141686281883540154911071743713625324924225902448030996737734044456286469,21879157639189744211597108651045875700807085936267782759316146460177277605878,11434924404918060113007413962226874803102772070441693086168193464929290844877,20757082623598026102923542323531106955538082419998942072958829717667465557131,8919981096169474486495376362947226335482024821650926316923260800584787410595,4288509578096166644556335935101899777779885105511348520519380469688243082096,16046529059566280251436022453196743987059059184968007751447655603059461800273,11219038614950179129482943179862383597500934389713177845014944329948593838918,10043039951240572103842000677370211126438633625308559058041812947576435228523,13424594313385554045395046911081130962489696002268038176721598695954847052511,1211793291463193275930858215285948372240170625699602215748915241438580144093,13956919764638999174327326329058963982898576605238294264300483944344569472991,21763763972390992315030985535287866258485311664824948828240050483482084352503,10420983865433228040050251893025618324702726171912049836799135351770260802977,18753701818722627673883564699398410722354636353042388382508975546895568464372,3775364142286651074799331885877684616693199427012762917550076623916732710822,8292671711306889259828642403052383798091670542487370026886155070540857817510,12071789317828192902441324443833143078458416120447222512665882093850970086582,18221914904286916930821501101975619932383182494940702022220624561466550429056,1015894946220130503079847588005345557311861372219799708101258594371020452677,7497079366974677538814211796849030622236102734688468791057012961185250977217,10412524008150259624425778663311437889796006875864864836590446801100002463061,242804608586097049060214639927231617495599500538071474816862835383660136678,9327321863177171873474299501143270493456472132426279976071195256972553555122,20841963613720468677785103552893139903309688713322442693081971171914472255790,13630784939841089364059908940844732601072559390491244936534430865345773326547,20060990491599613171081634276027504616735657335613608029945430961773413795782,20369723769740268530808565104818084023349274297831884550854878783888535628782,15076862507709493588855118027827375721947856558107489434980647124128748591027,12996451838772518667606758612923003843581729895975567888341928977998771990237,4052235171895745508958823720790274122684550078188920081778152850440806616718,12335377703331511956642047444506386381049513479297082723690490432465187475758,19412573446052112260556809146936739541890274154067075795508039506436684757726,17815752693042999749244044082547565016456928313463444720511782669652296613554,15784264337580227630693723391508440881780776717973842946134335715743491257089,10667492170364941836778050228790234453197448653226319355770388144152747476935,211997855288770996034164566467801948520054169907247985981041869092209280055,4928982790134068590739975426823777812194464923471161503361037698280174981760,18608672135933853582317718913701178979379432491853388463545185599228146691207,2315480928424106999355320576364787114368100799067708928765166041722251581141,7132821772386644248930179957111951717051009389997169728630437453984113307524,11744909558588287567829975231377896922260739746243206347301263424478589809196,21821616737585515642213483301817094657757210129023396850436714925413476278715,11972412756334108055648790188313869962577071423570734765254546184728606861831,9898102092275580917130558353359107455579856499298488646821411779664420246304,9958879822047499292094876401302022972082946727826778952858218178060652972948,19871205375909775929744751330720905649873502681808501037344623586575605895174,16601345490108570384179778033128731955939874176242885190845545230306090545377,3600818319871189164836691793538369796689767756596935154198009735998848369707,20314694248383769870802453966233555256007670655653781360971318867730452026627,13418958906290175260633447769067612135267907574578622587604011162488451092514,14459952906281539694149485094281623760953141057796841403669604773900469687889,19448408956408494949564099234438127422205398424291589853947309097810118078185,7825443276535418239837092010081563810404777554695462770138005656816269166303,8463248112790565810949249352339633764856217758597371912588298951088604363676,9397106702637851943166369067733828452382029530464971824017078972309585633364,15452595095505449307828854722016355425252678164966267614739918073395150429984,10382687268437366227597120935808669117993505555024110738918156422833458968254,8525129123003317464420034009755418250374332671627293582800681623438541074422,2209915653341740331756848895690532824379055156318218590971248250386542567791,15183382625497370680223757887016738067273663916736248647060220264288252640054,5914882314939376011130904692287520473675802288813732481565058295269249787489,10737923811176739642308957871008944847331638141618843900584295941869359201136,1019349115878726003171044582547108836234898959299710235354611802499665438533,17364570285151724843778637821645803441762402239038594475632207111794332738860,1251558044831543718478805412133062543617572066062707552512150093969983011815,7568361578986094203490921683991770751640726490619033852251843934473195496119,15439738350303496845805351814211602783597897988159829928947802101119983398961,20009975853963282344191402380547695759759731502702993682892413834957351648692,2363424283223098643833999734510060612126929924822351279904900380971757668501,17136028473467909987260660923882066072229277631411461261810169503965426571985,21423452231832054119549543703585288464249234898851841557254723364015587266501,6300803647873111234660196693510491620063330061194984556803532776163457642510,2749674757601823156522337416483425720076662114029481936093706226193678544468,16123152544885237760040277581510833657110306240025009956733742940484347179299,1449335556475943566914615807167633374850907490355989852917815325720800540092,18225835808858885369557291110939124591374272404427656191824524491194015802997,10406157408365973197865488683230737937923502029339842530701446718978570586144,17998633938868470446795829948946241208954439598754402047898587965138352946507,17256506181869579387781206921456178119308959078547323103229058358574594315926,13094455817799190250176997937777121524540082751332502303810836528817463694222,773415265947842731444676861730775210907581945844672294668103420848288364110,19038336321288882240456993528476377501756672900320404015643432684581055112943,14760627809381104024315295117982862934682028410719221222838112174132134785643,2299176916578536045959722453832883315456156391111537255429863337814706171473,3669114713225196659381574151653298340387887549947282054635076450967251116153,18251972251689708305163349578105700140002711019536040700377516042131395885101,2208114007582253724814286240939815507122998650551224166265438176279104064289,5311319465851004438404228350963430011209528099234009157573275300632566893387,17704997085718018561575909495530243398580104458533121202802306468962737491818,1933762715500501610210207583856164878867609341004969983518458273086102828809,6386814998566871009542498039659511536698234159072885405476628256992102020495,18831772844239784973934592955595859276748324649808851586824036127112826604451,13462121128312374635146040270944207295588795209645130037644415451121036635451,19731805313375129918425060059406339849106971447864245585064948352741000760923,21643500371506858849424889544041572150599889621082729284012490052076449459481,138548710091390954908010216339657754049773930079521223071410504190290814535,6947102089761831011730597399319184690211329034898095828464106850135090631740,12831053427863630744244436108113801672008361468343188269856032816742671083134,4223577351003454708551493531516184634014386163092922955496011474432781253241,2714897164693927923639587351413494956248140707486375397510165870974510685388,20023038420823827383850598062203899779139064378489163672445486337197649825217,1767883277856872395041944981599210930967554162796692711247113543638244036456,11374943081906439317741616342767018365183355349301791743927619930324701508426,11803403776542021481872407152864894420411711895295228328072919482156044458427,10466014303238336135169608931533160584648879880459007777160264124745826740750,20569672017414729176046551969057922112780177375685900568749563089152585958033,17872595105302125548629012813042403567513885359499964690907253660570968601519,10903006438854654900289559455490687959429486945748385817337220540948365309048,18275515870643256842855966776500808668842291767076613550498342673701067299432,630933085628668840611776843471079145620019967645658920379584401715066362709,6825394902701793105668667323441283311921241346208501522910007054667207868452,6858750193485140252798450603380083764362623733369268015553477107387074944232,1478873465931112194691102753288035258894560238829532399713218315372158028033,20647986868364738274961741160207964168903320676158610371768611791255451415798,4340383424522509172928608655219336498337132315044301147894720301443278858359,15694054630954602584443160345828698433451692126398102396637062194669728150097,16587614091042345417694939817299154667821001841573634480871399767976428325370,6780948432583055051074963887359666213579607675322530873343441117551279310337,881888803549941181636901791599886290841557130000792317917044641982716656024,8375540908772391314073560695793592104950470672337969483097880419747173630602,10968989437172024632405943909737990264150382688586767944077705368389009715036,18851349698000339475263334762001556036662188445499369323276947028195614775701,17424154833179596191247217224032955577230090491464139783174467885567507995873,3084264395291045886600299855227253813661906050535885634611163481700929635296,9780424450121954867052166726264263906169948113675811543750657338499901472300,14927658638057710246989480138441311677749528914441518171301964877558977872737,9409069466927713011440733713350127030613235827582038407437204556786573082426,21532551006723685558182869738272976023905972040234419867623013049768952103538,5167833995989484123952079378988963389989994865716472465476503880641449880786,14740174761652743774118447006447618386992142680472177663315668117221175944698,10520805511348878943408706501985230943081177040800761729569633389778724896451,8700454790689589285537042584692084777365997167238651880195034227220137266589,2733945906594382609383183532639154621092632308934603150907320167864486314840,10291836929398020145429078280830166142519086643388813863997726059451399134380,1964652348248051415524467307507959105507630568171154193714989224874728277054,2594310934406347332341406086415178782930670052092905736460388995932291385927,14842121917468246033091527680370186171895171052114757236254597861059412933851,10375528532253513340592396399825408524430850232835146379883683152448199357827,12477762696438196028925893395417443678494787519078936487705085579706421333630,18021944163681185812898833787149788656465569272261580921039580457574363675422,14971348947199715425743490776577354350250241776207063239247262831298628671824,18527079575564336560853661036281436413609153640671180843997315618816477020062,10112969341623453459297605360048147871962444397321717541108011492952113746933,9306811905619197449152929816385830205919355838468334319731910917748600490999,3201856562784023690028197460260731000729676130502544364740684445045551547485,17677019524999624366971265277439539545709248668323859450511125252478150097491,13203760042423946863820551582066224159089369605713946028771025792976332967017,8225744798383097681411492868795146058284602972120901801159373206820642535790,1133207841388716114249120311196903646181388009397557241156806164775023041371,15623890151225925383841140893652872349082273871391477651993101123938000801867,21454879142557364834852736051259149378158105754952971451715419987896242909650,8531552648559366596105198828222595210930697829968414405502802286874489507133,9401758966490949657386555283103887925392012048184105735334446423864991206786,14182985100305261645378993603110572106752819147111838091043200594637885017186,3351125971378624693919014331249933776013465831551789721255791740304274394936,19684429419661111328145464896944065690801463972795522382446603218587092452167,10925858543362322055288327267322188904474484027644138316216578205314218206492,638388255012974167128675944413974318871770367985490338348509002020449680093,14959175299535994556786536841655834078592404933909341983568127492171858384391,4565657688930940961208733539150773567906556683309024875952853834684480507269,18262745015163208046754959923695809473174547423960055443621926543956602209348,20270410959376379064306739018970053272238947330997122046760265674383899359657,15290563044070434983378131412705775525253143318870138946525234035666015420725,584590168302279667271049654248756511695470228213252786062709717390671267095,4966088591187905712289854426727671159168968384675952400787560742388879645568,3319669368740731092651343449167365623382886973437878280133897523197651190312,9912174158284239213664392208740702249961859675813287499135373479592639861287,8516379350240514281945243250529128948244709428452350892659587420308554264613,2460558416671744640916958595519740745483455366236568201673238589517657340142,15249503582713331075672114681569135202331428122201669911203912573537116149514,5355701614078955989983290080356684040651137096346994307217952640790301753843,7986859541259474766804707773691600248831464381736783455743764933501866864285,20896597282789039779549640920767060676459830701472255011776479759676387046352,21156365340242937197411344791352838273101399835862399143303393482855843470763,8810320994466343375413166155559061722877903255339567630911647558329186883195,13305939854322882862383989397499916187143744662574072474260034250574401506438,14276510595076120373993498057833260625756300056428067994615344507361982835166,20071507901284477038407301846126798169150113895071357904039436046848822333309,8183811379732619835362931863732297053435925338898156873268534636771405892075,13219046823251102005239988390708288792968718105445890139009709283489860275155,9185773756453985715582986632685488321665392756676197265712130071752773976631,20421943269702844355893550089604182682047061852707721138511917444304707579860,12300280142885224975710767798713824153348765684179955650717019029210821361254,12007970010282235734724332615090869243055192449773846575955902036212263482679,6158352771477574748962005695592225162907260568470401385862937675095774244006,9907046449530603675289866399335586386847026415848055552734816021036571412645,20848733914096475328182569300389604774285326414256566622667108340302595094373,8365137332145458646854804122757179721555979085847877907343540983873210953635,5631007860876051233682685206319236038053360910127434722172168921859697775602,7724822014604490732390628840430579796440157358556500058829335597037618014759,369071834493409594945180455653375424679250473615867182702388739879310444614,16769246200562822457100153851476834038704115916651426939703296994708244449575,5761928395342052380070450997738075595651684639539927184355295101970822313162,5566206280191314323446398313438814776510866532854163164867370641136219947308,3342359366346342054674985507754083252076489241172458810297886110396010701777,20961070283557581225918432539907379409525514793918155863543775859703676727621,20556180232726542574747935614764094533414324377887922356987347326584809231233,15941149549798383978046697670090370142285790712496734802869937995562571324293,14600396724469636128403441949598983100001916970624980610808650856082650218424,8853454033412621833577484167285435511890615294361962242058729914818351640066,7796912448927288083851300561583091259511345752250157116939318925851741489961,3163019852372632897541834965385695185434873283151315355155397996458747882742,14952700133737822394693717249052150819987738575989807253015506109171868391432,18525964798774229541041472797217632579102334608286281048443267822115517194616,7102118124262431444884005767970969670970778150875473949502505015348122457394,14204638357887780388176917062053732214797428898508168337150295424689096270757,3277315675050465719399614805088484534242274431436504827247668714966713345731,8238377613232984055051747513217839877952472190522754887201501162730400770486,10224258402104106587652987351104010753816241645110952300303846844538654914570,15487805061491340966964538995368847025698196465175525562567846982560655044359,19219815971577427671261496058630992677146093954055100897228392314454716131964,20451783587558695494081025729566916635107391693056303514267562508131052495026,10604908883794901754591456082090038158328418399338332217230293938008589705164,12629655676673767414687101606277783347408094199429831144029123923860076780652,13709603387456116061265164612378749494975357559995793114409724336723134851988,12280342248736515373215500158719410978133041790040105888782814256839967443115,7016009627584978047738165231314996484413117067952510110423917440240605830479,1524894728322552104763656617099911162075578893415210522528939966083567287381,16110348090073067974052480411460325713852194746966461188536450049907379558864,15849314408692105099989833438461121938666945258532089314493985018340786241149,14526266680576776847324515988959661063035583100946967808594725417429124130409,12662059588246809623132277946460950856148161126345911747740066547195150214304,21784234245035153912497219470830935288918016717870099869682681847939205742526,9781991278293660355311618579950123622358901576863101735826839255817708999571,9734447579561113294373127302234593360683756540510409616709038385517649565283,15783703381085552443769424496547949342637297192593569766965137630433735196499,16818302710679242439066482280541233367708597536159643998239357880909455304,17208557330797764065799659085570688998141169399652780006230425322841317471944,68706297573456724111634550544331343558310761429949721000334906561427561646,5166796490382346553866700788131214421083284131608596259217301814881739273429,20336383765590527388425300334919391504612546166109544795528892908246473855987,3743358254907302851720282727384172290999978135762491123193685721554867920482,84015356866358900057683156333277329434974724445531256660202285630028495424,13076432415761967873214874574212608989827734997835707946240987502102677974919,674004304490160746369333425685153534516797008922146231179438460150958899661,18008401489523347421324064960257465802035658427821867761642737239891301877084,9230814159278735889507853746171683425354655931537527400639327580576056029011,2338224170787780983513724541155899891770286010849997183556172649088034621522,13774730216408957127941425099141817093498762972537953648152397183615811260761,2008226192472961561861571910859568903805945585734651871281309234451941696550,18191659524918356873059208424871952262892246019889299985115112751645849510652,9977051090514243658919274826700877766433577306278237326432737577914469740819,1382241145032463690710185532538145321402596788581319285825708537098818318411,19630880072807438067933226715597469053645950344003618599545076855182567392314,13804532717560570932337083609013921209558901545207945868049344755900793666387,19508550180350246129831873366824988420065599516069494466305637280501827380920,2848475116255698304240592397534148356674367429794174368229897070816851620326,12588734179864636951823212209185103123565413699799377322920024420368718083095,2232868200526350302935711180734463487873472319399673090914563494365441045552,21377055866142483679502571618984666212079397034684178104676086894866487789275,4635961124592421709613730717934803195170398911827834468836156717082833802089,4795610144270291375198683497266358163517248476702360287932565598454128564576,19878139464835077446055142241229890663517120197298970825225586650258704320634,9323502139000335770056400844753650839571196769328639117682123746249546059680,21112416038547244178847876677595343035216538411439215223028113590182490455841,12697374728966756322005607409702182672422756890620656219302331428706184232671,9995295835719608174333254715476035051015528223152237761898234348962139965339,19838681448410021391386343877373049070883481927354420971134124213644615857262,13348946731323604604321164467837298053616765723820806627202376009331748334141,14459243825598700354634855807582241585214330632597159841271530816381999251613,16398077966528830249699687699527475156225434078425955606570595942126461545256,7643106356234289086355359290357087474077139338168525601611444369470624871398,20959675452873599571224578970521717955557909237727928302612036851445583012450,4540025033646420810215611052662284909609074316113304153198697292213556037365,12027414908456226247222654846878068961735365399441671468269489072556154853636,1619579475293093356383780863588610629947769633032102520272612883476001600909,8181934427490631780501305508522146234029250148182651874753791841738732508561,15274797459753339681175428319112732573480605162611546476487133996977708752899,5881626303176748491435260832560365957494745248996859086310569735454431253109,3420994635070209394832291125346590627475632172750870826118213841463585026009,3253514739572615120245273590897551489662089732892213994698961442123844511104,20203053841592538933587679570153207252397020205630948336602455897993666135475,11921266577552501086897102705390311185747062744461377484820893183533643304437,13241907169609567850145071795854997578682645559619300976538988140768348089882,6151712987809690919701305472528460675037031217153195032569932714294427052374,12205705969228027397734509241211850240154931572324813086389133244191540704608,12945812038464520921512101569088203002779738300982254987224395885526111963420,11566504805689497712142963920462066842262053081516919575350242192944407040992,15723543550582708278977667347083710027075971342576647975064035406870923269719,7860258127934035634020846943939055662221372673596335233171159964609391837625,15528468237941422862373023290041270186925402725739650209357342065347651170444,11352800656251355849609307793804420136337526597168059373534052608892527331301,17897134085314321992998873273654112498897006369781950634488633467466113054350,17437455229098036757167276638155356442563492876806914963325540308515770959304,14997752382200324825750631040991638912810425809039371028733815341246302297900,14919207184372260640968465889336548904504385718633186760383678178843526009885,11844428225775333775773424762116332026943738109456526441415077427972318646084,15239467296659614730514306837963031027890655569818408146133916080687077630265,20117441496592956911595459290983302272515832294843762087476380541606326158806,11211331365407064571488620323378276965399956667340240900293979889578003659573,8791311092499361250396136430755948222248236194668427353488891370543849807047,1774021261549926243219732938834617869058292002083739109596586460663663531688,2787995130097988538722853640105055460288688373288517482894772682647739193296,14036419256752421574134832204020173449399727322774622383219518631065684283606,2503905040784637175494196915035325275253506707537902487189138102884611289404,21664450508754049721193573452150382260579289185348178882539067755355712577906,18957082022313129842427206117755534129197834418112547991189485282634468396440,16781909482475992329419834248503013105141202009836651280677498803323770600224,6643893904478082560922317503708920766922698054352006836803634579280954593309,20411224098851507032152776776680744497103387047587118749494718067214956146818,6932200046628136855984161612336282559188694975968887215970260451999517971798,13683745075914427134220228573435856137115339570721809234203113630305711234299,12049119081343437729871267418004147930387014906392381996118616615174663353079,2441975952742754201500338273078694079713769380080349023008653075072257968553,1011172201777323348203437837012280331103466286486119939185319004696667574496,4513858889726009970880526008944305706495472698013415303299122950266699858614,1829602352761774082971266699128478520319034089172917557099196106572588528973,20888913280392789424820640494940209099778028785108373950708163556643786717499,11546628016884748339883959858649314450404290142635813671623548341391668641333,21503514976315590685255962605196280426006590386762670744592186136529638021924],
-        [19647061463337916460942375553072101475191437675089764130648797272059706835097,2987900412319695329324667493933426290750629320482434345012869808788189293747,14313117549814523542459271158255968194819696107203500245376504355915249564569,635066671179149779961724809079155342626591882143599249747638714005480456001,14160366375280976850992425663667859199067402849136919009370279834492741756927,6973916440684075662378599037972982797550158082488606172483341283171694141353,407790128607292443078618781455551950270304278197678311107891073846005921099,1875793830194257638983834574124736838833728874912304344706772047211830871895,101555677977911034029979807139724697918613026657646487138174278033141465909,13298961474358064737775518932222238976786587146906206646633234612439936576772,6675018665213382228528485041578965344759847379196981998842754547093440230230,5085649234634970209690321129917296688853246686378177913913323311616242468355,10058141944442728296289308385948277117189357184119821310668675797744136293133,20711981720256091912789603700019290285604375596717389895155646132584571552203,20115432152302860531854002084546199214679745925822431241410388037137709465378,19426738311039094155622173280735935805207149231732138766959497422037163547769,7740589787985988848427674257205602851899971532434369842038308874897481875095,11072265639503386933704945672016505140436978537584329931993329650203494086219,6167282302581750408390138662907316184354012779517813053982109604767767995057,14593714320140781629003483490890381863557111469157054599498274206519671343499,17959188687624917851017921366866983692604241271917787434145985166811823698158,10852786592684215415216400376119268936907433212885674472022333115957039052793,15899441678259173360040901233792251513972059637300348276334545233380063193689,3640175378514868793712597306483649195648235320181954901691448087453970656158,19498930515578230344335483600141550927765501643188753803487668144320311818295,4153883544158745158953668931089517690854504894896391299015592025101035411270,19024468701496237603291237797335586206588375930028220273546773163298357041151,7469727364011292433851252680653746774195189525727608179319902706399363717756,2372143841469285674441303263292066347817168610069150223765733476276718069613,2516526351266496289030890575774410993157441063594813081137075222758309555822,20958751338961200084885567700868871946051162714262967700193597995642229058459,9198209373895042225521605474867845062450002141670817279014351290187429107128,543785608759854122795367682791595958842618445464321379849398930724000250504,10214529630060513503750965897811894289300014475522844219670830726679857175601,11576753654045835303746511804171201194442330501175712221979130082457712862265,6214928611453392028562534794962748192402530967301618657847917468183855957477,6248903930557664471829331572570457764958370320737816568669654972084840708363,3521559114442643806761280511561190556015853803605505266866910604261521098953,14207749404758918058098136067805881181486166837455095244160881284733449919110,9959485107346230833915817969343930335833003289106263613217998567268111531500,17002458248120505483758089120825692383088865286608827557586088545674133219848,9310286746554253001882911152696415122865977191166769045081952245779941262056,833245639626789987010046903814146615257437312131003591772116076699143834195,8257332153195419962290907487481324519003765405123021230564312430389478396079,15127724347963527967475442670935452967842333763417615675896327776913208692165,15791631600664089304301903868070551535052107017766205491164731100213785544191,3248589614829341629004884091016822219853816257771914825780122055933452087513,17215199223989028745431952733663229031216291778213241728328297124270973463797,3857684745108028860654397149812523817069881299315264066597992653650257401551,4707785116452305555993924679316564589154347100943642537399862884483438576343,19430682328356065477111453488344441289467658065205729792227680437122893422861,8005988640968242998051528980068908390083328633663970547195021707967989536508,1972474227742829959658839187518313253567182690341134307491795498427960575880,6504813065413498635983080741406156525863657160083764580567056987831449046042,5823311218891803691266204716746992257279538141703406410574718561307174926795,9892303067707797586148875186586047934481214044907972144908705198351662761557,20467423831764780786043971286447965746242601887189594828393353559483921550575,5337137105639218811346004301122986797373254603744281473362301032791465429184,2653918865001450389595199059314513619487087198676481143857196098234024054997,20026090683375374670866007502511215153733777854247692013299401340222837331064,16088029123818655662676092939046004587731443682967462740467056646463545748825,9880178757459464201483861677712096813007025248923714154921858424834034903165,1227858189983101698453184059397045112686910656353893224019532173573557918655,6965709790321124552058584230424761849742693958580766537537673695015364525547,5275724511243540616354496187333612866929959836267482390875038898914899476257,697708336385781014957549769788950342363636191998726381071876409126144042559,7274584324261857876506709208086520820725839679509101845928052585127373751594,1101072498472320542658663987709974387416478403320298285132888772486638626384,17063249509595154712877503960715103016753273139274556931196815282616091591377,20468232842910222775240425801279694589286852891430236774476461428028768660386,10839957331597622631657614186340514237771754591887181416690281526344756522470,1833441125433983427564061829081424752522350755265858559398836992598910515884,18955730579934733484387457001397648556717991843841809299503396866826874046919,8193171082824386660318148864436464606096456472585333569988889002087311061541,6800731829409783994258949782115883803874917294598056504156236185152975271613,4551221506539437319374784319536342657448457365716669137274070321896962382201,3888700085587860510427705376785182344099574784427861867496328978292244934753,8086322087822351497126170321910559010882234382816099821864406027930561491554,13275797274085199955841117698566970822958536692349164078040808025934114965830,11798506987450083560046523556681776539473600393190500985018551824337777992733,2379081429050928317988088394722736405728459402480510127050576787799908525809,2158947553437093664557813698796314628878318098916390925037304154608297340081,11904049624504424229914369023060185670359894203980447724969113153014864088654,21129595246904679929428089867320350013514202309069019924095527072919847726344,10893562472341509760161513998095439702562664638408764329166649578524495942254,14633782125268548143403043594739012390811363821154748677494041549086652426818,18155420130909256009162482779733306385315875131491307204196352931575522168643,12073522950076264054413053294532869251854443128423131910399999522064467473027,1433592116103756425832298952472313408701354429203600638317025112329710147915,2210939565463298865317782595691956567659826882335372151952428383797077275627,17035360868359161456401993589512915729326589319922635525934508061308509305732,21403800287219776827894322644981677663016408317172756418765747341745060868637,13463317002652268594305080031749651114168039804631789430404782211764311412845,19738499492349409431828527491123847227085394983018723982858408988105307624104,2012548380220619299131832783872761872147153098580334235039922730491934764706,3325274441705326523449614352431988173829782789776117744919906973769657338996,5261611144921901341966147913919865209616390993972727644394713260572315512744,18987697050242894331980397947115962487019662790026980590641254086717180862945,8658141027857622941054124779019043605220504649377920644749538450450805414621,11298428708044619749095290390778425959792777464903586113463716315584533582828,6730200291399992595132121834599191803078178940321882359439272645986988925939,16058286461189478903573915480209402516073069688039571574175048313793344696582,9740895146643188739739241045620497326490653096157416163918867637699590812365,17328668678982472669285290349933801381460489699965770954259262923597437466085,21089229510079204828717685354260991995629733636903215847138008238449607565274,20640971546156771190021485453412235742638585574517108137718546522103899393969,14758279983387100491873648446401986574422791750180622274744397880182747812100,1331898546985028774480334813742156878861378216830516346949642945416964272379,6432287430987511826080726363315893796139259314225964668680871966245781390173,16771287021606049252082476128446106722127174299597407353702759915141825150750,8558856604643032676967156921137773032066151674912302830855999926475047747086,3441849687388033123111488396776112259878496892302987380166582753348946609870,20817116194964519717309108464421257788806753886196720998666047916921548668924,19363239836951813038374327912605477961457473367759250309818663552575087804364,8719722538679135055399244869855972116946451760806505569767286592823561841553,18664054074328463099250618543796241821469021451703648566147509976488389212302,14668897608285076749626150823646322752663015099871458303607991619920343960884,8824985320268620533295858061606775496359110158594681923758227994736311199135,10765520116421824752776648993191019870707037690612646148788741126433863060128,20754227554163810768271776561488490692278680037121708279136293739447289576147,8507072847563043340105426835824153184629689984787563844408253684598778757305,6766982373679017786884251724806484438649942596522690604198707242527640673411,3038766798814116247860373387571799940341461487105503437312437210868806237693,16132175023628563044043762398003871532172614031006064729051923614189729264142,15583173149116838843387513514855791665649616393679968646432984027900294981739,19200443718712964237956082975258333421930476944060656325774330146577168149713,14490821043935432280588585568226041328772039440696419883978899443298638245193,1261830229525183456874822855513761625054204680497477037321364189175040481068,6528746667003363057717101918351735481714469206031070610241614606650021871543,16147698956945808666133328464174436996026072559773234518262594815923002983587,9020387669972688980419006674825908656426016085797207362353154226605692909040,6727316761823910734900206867002954254557029243225097482815337322560175181198,10066421681146255853671223544720366622786875122426340101570461526567311479729,18114193263469715956238812322551819970497722041025850638963351240642707536449,13327552382593937204593701292574430198134175441510741573417228229955049364251,2372604211171385703747757710474646305749482500024237878826421281702483230858,13257727745849193909326785093877285673934675536283265665870765530981203548766,6028193081122651452411463574343231811776375151328081689399842891316362242212,8508301356193721985012355411615100178521599009635936162890863637274261948848,19464559199695905284994131173285166577427724356611906328878634139911049316349,11574946347736941315258330071986157639717219704847732435648573723449097294965,14316018291870434740761571976364226850140038868497601980741769481529398163257,10918196690875147279977362872452345319770767457845834002916792583407449275430,8977373069224380198540140180493576791843577554452269707469880849832228035023,748498829648879147053737200607377785638767247375633990031472844537260809404,7873158704115081877804196477528352958470140833786962209738121862287852609943,8630532424574483719830065132415752445222218233997041715460638881404278125797,8690582614704926771670051368117061261335922283383440650770249469863376973533,11095347717221488007795836937657301037546485308926406743891578760518489637433,14135401679286508502504277387212121656373093920904597158275723422439876100612,14738090907871182095556666808390406734966899260337679732930591106508814238308,69949271807030541733792162811562320986072778465870031251424993196153906266,1261108319753649612663311207745706802298135850234573661502446278242936235395,16817683438765699400477322528948826720336276287491287100775393652707943792575,18841362612982270174762542916999427955157117780377439797570032391179795654286,21870116979686159000730008975387147484906370787640570497473602061164852395071,2765949947644452455039725847864010340741814376903283748968022076584286340602,17243705140322781483942034937718263695017457618400778609034996357553437986248,13677914966377093417490296499705767815775553283213762175449591670735007344873,13297897273167025228957171745153893110275891317806768533464851402665750442708,13343269561671098171091946421541340634645677702710756455899883309946421878045,14317554923995329326292532110843156058636017277221221405605647959782965284991,2449835610256525707119222686954432076774548565002604197859382557987062142872,17311927259294224200654531686487034697399582221230204382526629700762752029323,15886029754147081563564215095016637219622964863827251334461319377673888336370,12975391569205596000382467418571211360327385366404855968892273321920864753986,5192224731376769981697271181929966876988577937843948018413420047649317448463,10676192139479409715075805869252336543157972214291179434959380291895052573000,11177450837775344504988539319102121281143354970746599512770721409890402968920,4593200667847399069176143966880767249193687931869738276411303724780636851859,11038090380551563944847929106606106685586830480239388947878234434263502089528,3953526418885419728011595573117200571065709475826662733812952860173033412620,11423581837569206292763368836201420979900393158634684009052097987935130296343,20821758092880168608657749212670937227806187953778513378055795779476865339010,18497750301637542715216545677959957759969933594321504330433834545748130561538,12908315310864070359072899712184126229744818024807969170422172983759986468742,18124554128224712379655197019948407579501104121202515283344405665022477997811,20982975342803604005070898815103511622812678185245827078739170834137855132820,269825514811016046965635325890713556615518696022373524499024558861784638050,3147172016143608266119085281262979524079358702373693860744797997889998689295,14386832245166477008833710911810567249931220515383598373556096298357174022469,4556487278328022691163443795787718624849832853076824895328263286768388362379,12261472135716169178595791281788338424856082203277018628926152780653238868197,3899423277681311798156637809536718065846612626667684730473026778811334914007,19506309861341587023369919042973949592579256277585657370274971571040135953685,1364959409282923580897524375843789492029158451437094417717346158650761726050,16825446178437335546349323854223244861262257417842514939476542139147191650927,8507209116997169365742612629060440573797814488088100151461758543065101868641,15267004752470933248572062004321128218304784520473623806984809921883550707694,676031704648473427598859615894926588607941948575683685792835248653139785855,5619669402121492986528563034254744932241765329516105050276049374453441613893,14704798323824402102639327448519792804756861685698966598005087155126928897024,16320067378138810368504584396122999292945236808095532790918287639367557973453,8146733655224190459272793912328710535983522769849572460217349885461291275505,1038180418056776651442944028459510265058633383281360520702142043667403503844,19104250152149288692194160087229108962380481983770051876357439473931889382526,7003760916474780870091321276888809099928758016210575511830123521067523691017,10460150809039904156668983747345347198316841366879181914914418086579576664491,15677112907432790716289265075133862681087874169637399306212310599581157175963,15326287388823547786897864243344800490244989953594543352512215080754525987008,3009920542142872962638960374061083879344081833005888204328736035225746795718,1804978488347291728619316877980070589260679228487014904460247370976082660690,1328483773995482788116589592947585572244503408960547493086897090179230375909,5730439196427856076422854580234519707227885379777920110477133774925338997125,12981431367443547352573507131765244291012615436617972351790438163822109185806,4832711978673748239567077367987729540684018769513731999388791063624971084279,19167638139894327951096186708600927728591679782746822664161578344690189946483,9333793061773227893961520586484148770892826436173136355616167263506645189532,21458443518750111068075382716496819469049134888053123021475459386077573760694,10205061553685164402371459751106832224694007401400200656551443744478399832956,9830442925198991171494436686328858756494894392913894165312258843542937207416,13609869649628867442619044498926584416410429910199812031508542862339177409898,842857359216662427573900948838829890161571314532391785590044951074431433210,6704851129269714864143856350805682503777715960622547687053167421313207852468,20114446898395957281817578351485444375476540075666338352767091837280210668931,6130491715603374999851365684496448519606340852139128448851532580625582546602,15813600594451539718733724931622603275717510629305297903420212550967482486778,21327142130781371825633810115678136219928778056926678460292750153897861437357,4961568602907543961625596532526706517274095072299784820035412496941108876522,9960714813540172203971946479714057278358565379915043327324100653488017320531,19766028424299726292403979387148081559608033800073407130824876437622345769610,19128679427621049663909949398415698465159247423858348746959133844645715231748,5570166864868188450021144960131468276106515498742461735810689530781856406802,11574972995586621052272541749980259251569951388173301707052886832340902170154,20877646438494519923058752260065237612204466401313282232221152388173388627982,5249150519585813956946898091205522450918428396100844955321690157312140444303,2017741632554727420098342601911590665808744692822556685407780092354922864904,1195760854074467363227832424961613965990883686618742557387108941759791735821,11466582138640916980683611003811079018804741425452823176665968956853901549307,10985903304141344987201754580174851046824447026961915755527591886735857840658,2130569969210610976943124127703960718576010294778156297713757734434872381369,10738808247531379378397673739325665568136689079862172683794674460448121540040,20614646033198180892625991863201166456931543657809805208583071176938057085966,565997125213498936861304726982380864240733960104507001725677609359585569840,10632097546602816816944445466416073366486654512740953706603375905768461201631,12929362833112356946255271584627031609627907912912902502403907291451582319157,1034235212357952436868793031480652544314617407845212103021627643626485031876,19390762319422155950976700977771604452581304443563816543281343170335005291057,10630153844633439282958810722979033212891017579520387012386923832074337305798,14190876500956732147461925775340768352695586121304109940717530850819588911999,18722506055380266423054060346625995391170752586033471909467419883841861306716,3056819986793075694786756176651004538794778835114033048299678024064951583754,4672570536584218848208255703572454924953635491594309524306431682544106754221,17351556719883029551473146382008643929874047263147825865359162665615894766393,15361589507494181649833267508353254535596250253216356073840778948791727807159,13693471199005207103868448237123737586403755421081623632730820742927025187060,17755277847125531485682000612777686738631414648862078678723432159826928724703,5078737090654746516628738054730387217943533822956354885634428155918832329055,12147601749747781924069337935019031145159705806951967042421913575214356549816,14365231440612787726412058658929032228572314258997026523542183583106877612565,7278303658563994843919131396912585917500535615791945995381401546353032136647,16203755920169126984249498560164803107868240707492521482933949021054510520315,6791925607504018751125155518211487306271141824074365658905258365090537532910,13823494237593720607868138054959291887740146822262268248432322209124930846096,11009501160902109690977091445438703229756969339078969536565574715162502634351,14720462490975063947234490477382491041961626472580003583159938559677559185952]        
+        [
+            0x11e27da7b7ef964948a332974d07cceea778bc33aedbcd09de222fa22ad0b101,
+            0x1f60381b83b44a8fe65a0f4142faaafc5fbf55f79133c5740c53f036a3065b65,
+            0xfc1e1ac8ad3524ebdbfa45dcc51576548234d0292adfe1cd70a706a1b6dadd8,
+            0xa40798ead3a12b78bcd8f10bb15cb0c426bbd2282a81dcdc070084ce78b8d76,
+            0x2dc09d3357051155987ea95594436b6cbf393b0135f51e2f675ea5f462f4a9c5,
+            0x104b9241d534264532eda181de1a154dd175ee150f349033e46ddc54181da088,
+            0x127a6208d98f6cd387b802fa44cab2037b3b91f0622f17084f1b8d8ac9d12698,
+            0x2d075ceebab54341dc02fb1f50d938ce1dfdcde659955a930ec18f8625f86d4d,
+            0x44fd5c2101a20be2ad923bebe15a477f40c6039a3dd0d7443fe72758042010c,
+            0x2b302c8511fbd3702b815564c5399acb8a8f2a8eb77f96c7f0849628e09f9bc8,
+            0x7cbe339db90599455d1eded1e8a870bd302c92a79b1d0f4ee87222cce99e22b,
+            0x1326749312c6e8bd4ef24c97c809f78ae548394c94c3df2f28ffa8105debe211,
+            0x54021406b8d1f8c7080e7c245304e4b7a797cd236dad92d929b223f269780e0,
+            0x5c0e033b589f8ddb23a9d559eaeecf98691a8d018f1279bf406d08f2787cc42,
+            0x2508a8cdd450f969b61c749d566c9459a16ead4330e35d5415b12eca38584bb1,
+            0x264dccc02e574ca7e736da25072bd8fbe9909621fd4f4169b2bae8d368ff12d2,
+            0x137199f796d310d7fe22d83663c8e607d342407dc28c10d27aedc4a45c8ff70d,
+            0x2f6877c1a818cf1f087343dc38dd120833574b9691540d03128a2d051c1be240,
+            0xf418e13a90e4295bd384c4d4764398e1e44865058e6d85f10396a7cb0716494,
+            0x1a6864de7ca70730f8657bed417c428aa5dddafee26ee78b942c86be61a962c7,
+            0xf8be2e253cba2f128e7365d8b1ad95f8986968cc60224445f2bd717c26088d9,
+            0x16a8d9f265a66f69fad6d7b744cf090e490552c6d4ac77f89f09d0ae70095a5b,
+            0x25f1a51ea7f88847cd19c9dfa9c8587ac7a4f4b8a10bf900d20270398b9613e5,
+            0x28d4a6eebf392a9378b7ad9aab8862245279a9f2c0b1678cb6d3141ebb14644e,
+            0xad7537d9d5bb7e34936eadf66fe924d80c893745fdcebd5ea08b79f9137aed5,
+            0x6ae9e1b3a2edb869b5c6f231fede58dc7dfe42bf3802394ce5d62c3a65567f7,
+            0x1f5d4250771eb130c046c8df1e77f7f77da20709346a334dbd22c72191045cb1,
+            0x14bd6a1b5678cda4ea3a16c3b5abbf38ee1d82219849cc37fbcbd934e7de1162,
+            0x22905156b6bb357e2727bdcb8f39a66a09828307046296c6d5322abdb932d0bf,
+            0x2023fcb87f89e6fe4cefc3d315249ed8133834b56aeab6fe07b7fc246b096c,
+            0xeef78e23ad00648fcdb65eb246c737b7b4060b37b6b845eb914108f1316646f,
+            0x1f3030be5da4e16c0468d631074a65f5457462fd6be6db36c3a522453164e48e,
+            0x10dc200b8c1b565d4c2e88d5bc1bad12c490a20d05dcc4cf55e9644f3534455c,
+            0x11a9cf0b8e97ea26ed0d49abf3a09233703333789a390d72db661fa70b1cc2c6,
+            0x15b97860d1a835a706f54a97ff04a15c69dd3beb0f86b51c83803d490c2cf2f,
+            0x1225bfd0d701b349214873ab03716319d9c96e3cd8d962028b17db843e4a7f19,
+            0xf4ebaee2abcbc49d408aa52c60dcc093cb0da884c4a92d0f280d7b100600560,
+            0xadeeea75944cd5d35045ec8cb6a57487287a92d1f70cd0b2389a4f128792ac6,
+            0x1874870c72a32f0d385294a73d0ff67d7234af8e0ec57c63b4f77e72130591fc,
+            0xcd011ee52170682d3777ba0085ec1620e19b1485d9898800dd2b1d74f613576,
+            0x2e72b9107cc1e1a9bef16bb21a308c9fe3fc9221e55f5d4cbd43ee8de297e02b,
+            0x7ad8d8e863868745d2c0c6e1d08dd357803f4653ea2045792edb563399f7d84,
+            0x273d3298e5b22284dd66bb0f5e963f0a6af68c14018c728fc42cc82acc384db3,
+            0x111b832918546dae5a1a71d312b412462b9d2bbe867be4fdf089eb15820bfe13,
+            0xc4dec2328aabeec22bef040c565b1227753c1dbcd9e470f906a4fcb5cdbe7ee,
+            0xd21f2bf0ab2f74a5eb38abf787121f015d88ac22de1490c548d0606b8e6d7b4,
+            0x1e08837512f3cfe1319b8f8babf49e738abd159e322227401b7a5441978f77d3,
+            0x211eaccc37cea3485cb8300994538c153b1dc5b8d63c96b437b91434642a11b4,
+            0x123e045851f8649e6332e3e208b9d4db39099f077a1104555bc38f68c62deee8,
+            0x8b66ae60a35e192963af9ca3e8681012d5288a5abc67065ba52bb151d4042e1,
+            0x2e9188c8e02a08b719f7cf8af307de827d424a166e6f9ebb172ba41855a405c,
+            0x52458b94157b0e5d0b5cef9ffe8e014eafd7cfc1b43611faf31c2d8d59b4eac,
+            0x24bb0266c20a04010addd514bf76e3da1276d13cc58faf89668e238b9ed2ed6f,
+            0xcd9a619dc0621a5f4cdba8303b5f69da6206bf28a04b96d4fdfd3a214e3e54e,
+            0x119949b91445ca55fa6ea8da2c11d93892e5b4cf3485599f41106eef149eea9a,
+            0x265ec37b545cd5dc12a27c1128c314a13e8cb222b5d25c3b9061934e93cb97b,
+            0x6aa84e7c246cd723c78fa394a7ded19596e074fff4ac200171a1f4c75bd7924,
+            0x1b4e6c237527565068aa65269cd73b5c4675b1148fc31fbabcdcaa341f63205f,
+            0x2bc7d97b099113c5ab67254ffaca493041bc43e8d344be98152e98a4fb786da1,
+            0x1e8fd4145c4cda03e17eb62c0f9d8cc97f5b13b83ba8400b57a3d80009c00eeb,
+            0xde458ac4a2ca65e25c6c028b23e73fcad1bdb3e3f1b6a730eb47e04dfa65318,
+            0x2d1ba2bfddb58785ae140c239197729f0c60ef611f3b377d4aae3c6dd444b5b,
+            0x29d94b0688e3236b20967ec747b92e837fcbc396fd6c348b1e0c748a6ee021f1,
+            0x2ec6c5500bc7998c7b821d209c608a630195b734c02a5aeb15b1c755b7857d5f,
+            0xd185c970b8d03fab0cb058605d2c0871c76af2047efcaca0e1be393a4817ef2,
+            0x300c58a0b3c59893a5acfa7a0adc1de29dfa3f16b4689af0535cc2513d60920c,
+            0x2360aebfee8827a4b9037013a6dec8af8f38308d119b3167df19e3eced62ef6,
+            0x43ba139aaacd5a1c1349104235e9855ee8802cae5a30a85edad853b092b5181,
+            0x1b0597b0023cc90297b8a4e996676d65276b1a4c6409d7c3c26008e56cfe6f63,
+            0xeb1857692cae615046d0febd92edbed96417c07b841b462f78b90960771ed0,
+            0x6399b5873506855684d027c760fa5b89721ac3004096114ee2b0c5ea727eaa0,
+            0x92636eca31acead1a2e63131e25a2cb4cb5e5db766615861f4fcb06e4321eb,
+            0x2e1d940f15c6a1f49a28f66c0d539f5ec4431ebc533ddfef8acf0f5463b7d0fd,
+            0x946412137bd02c889bc3f6600635398e5c29347a580994338e44a6fa41b40b9,
+            0x18ec2c5948557c8699e5e425ae42b5f51db8faeadb62bab808d1662253e61cae,
+            0xac166679eb2864d7674a89bda016c235736783820591cb9504b890b9117fe4b,
+            0x4db97e1cff9f2fb62e16077221c20306c32f579be40d7838e6ec15320c38443,
+            0xc4d540ab17d3ba0328f95369e86fb073f3660896d85a679ff9c6c99268bb7fc,
+            0x2e6b4be5eef898dd7bf66b3754ad1bdbab013ab0ed99c1632a489c76987f2ef2,
+            0x15f2072ffd2d6caa3d6ca13f7703a47c0bba942b0d9ba0b141047a297ae19899,
+            0x1ef8155e5c33f8855bfdcc24ac895db935559d5dbc442514d4272e0b2270604d,
+            0x194f4e345835e516564677d1af5193e67f26573afe1d12fd77673126e4b6c1e0,
+            0x2a3fd58a40436abcf4ff7d7a582c5bab55edf2150a786ed51c56c6ff2b668c98,
+            0x11729c1bf0a0f91ac34e4456d39ee6d2dd1c064368c2f0a8b76f555802d9af0d,
+            0x2e13f7ce1f37ee5f2839bacd94feb1063960ee6438f10e01000769bc2856e755,
+            0xe1442f5f0fa8737f50d8935fdfc204cf07e6fb3acd7c7cbc78fd28dce78deea,
+            0x1aac56dc7ff6d0adb2cb7b01c67f487e3c812350450993bccb186b2fba077957,
+            0xdb64a35a35a8fd6b486cf00f5324887f84c20240637b071d462a8896af11134,
+            0x2cf6b1eb727612b4676e65d750a2cb15c82f13bc858e0bf6c1cf87b96f8796f2,
+            0x761d1ff3a90fa0ece518705f2f80055b7667ff667063fb5bdaa950efc805199,
+            0x92a84456e8ab1a26ed09f4c9c78dfbedbf4904937bbbaaae9a23dc680fb01c0,
+            0xcf9cb1a0a9e17a9d6bf4b296ee0530c1b88141bce69357f964fbc22796465ce,
+            0x1fd3b34a7c3a44e18fa8eadb896e5a17ed439bed8efd723246a009446bb95f0d,
+            0x4b5ad182b4ba40ada5f69e436740417c1bc901b58515f969cff2fbde530787a,
+            0x17aed43f02895475ab9427f84c57b965683d44ac92554d140ebd0434fefd6944,
+            0x302772848bcacef898d59e149ef84e4822edaa6091e236aa41bd683acbd43a7f,
+            0x14b66c4b0f5ee36c9f94644a4110cd09825cc8c85f6cb328391e83fcc86c71e9,
+            0x18d6d00bd7b85619dd8b979158baaa87e5fd97a0c6d536c211a3ec663458fb2b,
+            0xc094c29ad77018d4da01ac5d06bbaf353330bafc55a942fbaa30b4876e11240,
+            0x1f6c4bd9672a340c114623c83ff250c8e410f0a3a11b4fe769099f8be230e4d,
+            0x279d9751ee739e974ab65792beb9276773537e2095dbe80baf236adaf2d9de3f,
+            0x2560999bf8b9ba17804b13067dd4b0b0022219dcbe167dab5f9300b68236da2a,
+            0x211d8050a0cc08d433d487381dfee76e39c8afc46292f336565121fddf4f8b4,
+            0x26dc6f484d1445c5f5c208ff1a487e372f1f8782dec0a5da03a85f706ef48e8c,
+            0xd11eab567c463fd6796c3bb711467a6a78f7d847de201eb717dba516808d237,
+            0x239b30a866e3778491b842a8c2df9ae14a6315981c2394c26d99ce97c4e7fce0,
+            0x2e35cdbf79533471e4849a97467eb4d1b21c6ad8ef34691e08b74ef19c27735a,
+            0x2237729ead5273e8d6acd40a63eb08813a2293e21dff54ea02619c6bdbb18c77,
+            0x290c8723936f36b91aa1fc42768007ea904952ec0e41480d074b96d41703d648,
+            0x1c279f1d50860ece8148cc1b59f5c14a850af2f3a7e2afb8fddf72964fdf9c53,
+            0x1938e4214605f8e2fa59e7f90eb10eba0e984c24a5f5c1b719f41421229922e2,
+            0x1b45ae36a32c689150489056ea161cf38ed1506f33a711d6b471657277d770ee,
+            0x2f0ac8b7be349d38f0ae7f7dcd7cc86eb3aa06c708b3faff90f6b24a8b691431,
+            0x1c40238de6c61dc8fdb5a75611be0d4bf7f5c4eb39fe9c065c26ae970e2b1f06,
+            0x1b4baa71e93d13018ae4ebb790bc188c4b46c892c6782a27115bcac4d165f3dc,
+            0x145d0fd15960dfe597187dcdd2927c5170b853928ee08686555ca5a57ab4b1d3,
+            0x83791a423ac40504e7c99084980599a3359ca693c6aacc47b192a325d6df626,
+            0x2999885c947c9dd00616bbfc088819ffe4c0d2f9033b04f408acfcf1d79651a3,
+            0x8d0a62a3ee05bc36241af5eea0b62dfd4f28c31fbe77fbaae392fa7b05af4f2,
+            0x18e93970a8a8070a1835114c4316e7ffc242eb128031aca086d3ce2cd3558e33,
+            0x126590f273bacddc28fc87c100b5bccf95eea5c1607dbbcbf05b6db2992cc12e,
+            0x21a7b2a18aba9b81406cfe7c64c1b0b4037c241e7565b52760d74e7720e92117,
+            0x4985dff243cbbd8eac16b7b6f03603118293966de095b2e057043891bf5174d,
+            0x18ad558446b1c9342e3846c398d05727ebc22d4a8c03de6380cbe55aab7241bb,
+            0x1b055d908da8e662ee4b05c3c66886a35bcefb67946cfa6baeeddd8cb06fb65f,
+            0x1a10263fb63bd4f23fdbacba6fb3f0d7499fea2e1e1547b36b17c4fa79dc0eba,
+            0x114b2c3f7730ae08a1a31bbdc27ca1b3fda63d5d8eb55bdac6578b27633395cc,
+            0x1a3f27e20df3c4045f3a67065ed869377e0c63a9a367f09f7a3bc63d4006bae3,
+            0x1eebb48e654885e9fdc60b3ad67b988530923f65fa76983851b1092640bebef7,
+            0x2ab3b05b9cc58838ee853f9d4a4817c7bbb1efa9deedb84d52c90ad9d80c2b1e,
+            0xbe8d510c3f0d8edd5716971f2452b3106ae0f4933d894404bc0b5eeecebe356,
+            0x300225e792be5f679ad2d4f8b3d070495bcdf876e50523cd877b4fce9bd30543,
+            0x2df4b36388d11c2ca5d95c24c93e8ad10ba7b74735753cd0c7aa4805fadbf0f7,
+            0xef6deac5ae321c054639444d4f0031663195997b4cfde163c75e989eb0629b6,
+            0xfe041753831aa6a6bc0ea08a153bd5a409de14ecf636b3682539074356e5852,
+            0x107105d12a394dbcb31832b57081aedb73e0aa17ac7c2faee1870d2dac147f89,
+            0x1c2618562f04166bcfa93b80c537ea8b35aa07d8ee33703fda76079f7b78f1ce,
+            0x27f7f4d91b9f452211799438a638f0c80e3db58ecb8d194e97e211e158df46fb,
+            0x2a9982f31c9f628b43652dc20217d9a91bdfa94bd125e1e032e4f6626eb3bb02,
+            0x2676c1451011dab5891ee8f715409412396960849613d13334af036176b7f343,
+            0x27c95df56dbab27660262717556e57b6d3d66869a0f834bffdcdf58c80de932,
+            0x50255c8e75aa4e294b921733803da9d6b9a9eeee28606bbda643a9122fc76b7,
+            0x26a0dbba1128c1eed674bf21e7a7d23163d48634967d0daf7e467501768d237,
+            0x16e80c84883b3370e75f1ab266b46f0b839accab3726278ec206998b62e789df,
+            0x9782b1fb5ac39e3124c5e857253337a4503950a6dd151f005963c92254ad7d,
+            0xa6975f45d3f7bb18c7db0a286cfdfbe0d75b79c74e67ad2265cd168c1670c1f,
+            0x9b2d6b4df7d70732ad35eeed1b468efd932a780e9e74cb82c3dc1c47b4c8440,
+            0x96195e37522c163f5fd66f13cac8bee72ae4b445224ebd85340a69b5a322739,
+            0x26d015d70931042ece8bd15db6b08bc1496b7501baf0c8bf4a5534fd60422941,
+            0x39f5d3bf59ceb12854079a2675ecece7b8cc5d9ab9c3d79adc1d181ca6198a9,
+            0x1352b30ec61d92dd82e2360d38137d2fb02c1e78d6f99cc437e8640becc56122,
+            0xbd8e9fb03b03709c0be6510b233fcffbc1f9f63f4d6019b110f77417fe381b1,
+            0x14d37b7920faff9ff10ac3568122fe38221ac783e675bd5f6e69494755853723,
+            0x2208c576d439a6c9c0c380e7063fff76a1f2685bbed6fd7bed23c732f345501a,
+            0x8f4fa71b7c3c71c66c0075a5b7a0cb6271c6f7568979d3742e2847cd650aa55,
+            0x30553e47d42844f4dc97d3b96dee7b6c483d2868125eb7de508164de2466b74e,
+            0xe10c2cb9014f110cb54d27ae0130988b0c32a55f8d111f2bf797dc5b2c39a86,
+            0x2801868c0861bcc953405e4964dfd447a8888d8839aa7e414de176c7c061e238,
+            0x23ea7dafbfe7bf1d8f8b4ec83aa1f0ce31fdfc9ac5d2cca02f14ed1b87caf599,
+            0x22ff012edcab66b7416dca632a59caba6d641e02f6fe47e7510ce945966f3721,
+            0x2dfd80076ffbaecd97311a5c0b2314400005a1f07b6c21d92228583ca5b5a4b,
+            0x23c45a61f4f2c8b3e066a26e232e26db93aaa24e2f65d26601ab2d7a1b95606,
+            0x2072907f984ca35bce9ad3e82d8c30f9acc0ce98d145e4fe277e628489594e2e,
+            0x8964e49de9a9fee1ca762ffbf07f8c4a8122bc4e90e7b567fcff008a6e45e6,
+            0x2dc503267b1497a821453a73030f2a3523213bf0db9d5b061342cd859a1cd907,
+            0x5fd4295ee0e76dc56af4119e7376a593e4bb185af60adddf232b91e67fb2aee,
+            0x2092ffeb6b7760870dfaf471823ed7591fcf6e6bd5b1bcf43775d3c07b462706,
+            0xbf1a49f9b9ac34d30e463ba797e3e08dfb424791ea612b280932ec208c7f800,
+            0x272a88a53e263ff0a56bff4cc645fcc269d3ad5a63f9625ffe9eac93a36b77d4,
+            0x27bb4022b1f689184b10d6f29824311ccc5e2ef14a3914aea8f06ccb7f2aa8ce,
+            0x178f0ee74c834c0d22f7aebc5171f960b20546dd9cb53b3ded78a351ab41ce10,
+            0xbf6df276b3f28afd5206a8646dd6f4c095fd98871a5060502f3a6444be321b5,
+            0x219d4e79092df13b3223f935d2a0a2573c1f7d509a91dd7fc5533d4c3c5d098f,
+            0x20f5702b749f56df810411ad9950ca9f87f1e0f97b8163280b3b2df05b679b4d,
+            0x117284f038872bce68c791ad18246ed84badb692e338f716793f5a6bf216386e,
+            0x2c2dbc65a26b313f84567ed71d40847093d08ce8c2b8a343c62b7f57ef63d968,
+            0x1743373e3858cdc0582049ef7e0284d33403cc8bf56997c508a10b5fb008ae77,
+            0xba28f299d1ca31db5a3bc0e8202e9ce8fe85f80c4f03f9eae2dab5de051a659,
+            0xe46831dc32f73c1086055faeadf047d3408c2cc0dc2e725c878dc9ce68f17eb,
+            0x1d8635cde2ec64aa50d8d979e29ef11fa0060bf86ea00762250e314e2881f70a,
+            0xeb6d86f7e11b1e3dc21882511e03b7aa64063688fc52f655f12e34a343dbcb9,
+            0x20bb2d1b0caed114b06fca648b0703a7346f6b2690f220f82e7710b586b6a81,
+            0x1c4db5ac81e0e47818bfc08f7ec2d66bf15daaab8ee766728f588539eb60075e,
+            0x16eba5f5dd46415f55abb8199b0069ad3ab7a78e8eedfafcae845760a4b1e525,
+            0x46718c49cfcd67cfc27daaf0bc00db0165a8b34bd1801110b85c3f890779f02,
+            0x10eccf3b4cf167cd78f9eeeacc462eed71eb92a2e31bdc1fc4b16c0b19feb44f,
+            0x16e1b2c0dd88527774f18bc53f4274fd15a5afcf3656f149ba7bf0d67050f3dd,
+            0x1d13bd396da5a68e7b801ff0b2c6c2725f961bf633d0dfaf1a4b2c904969ae53,
+            0x2023518104868b1b97d9a5170d7a33230bff0618df4a31b381fbe9a0ea3224f4,
+            0x84c4f9050120239d86cb0d84535ccb94821f0a1def04495ffeb559f153ddc26,
+            0x1ff6f423d94667ef2d79660600e05c570f74d77ae07139d2019069ff96c83566,
+            0x7b5719a1e09b96a5ce2c130b9d3ec76002d81bd6a8b46ad27274036bb363bba    
+        ],
+        [
+            [
+                0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+                0x111d04c083f51a6fdf87412a537f6601076d61f435094ea16946efbfa4893e97,
+                0x133c5913f25ff5eaa860d0318f6a4b4349fd22f2d53530e5c785b70988a3a88,
+                0x8875f47d6f518c8c2df51a786bf2207aade284067228f440e7d0307520a56cf,
+                0xba9f44a107a81cb23fba66f2bc34152728f5f5ca68406649a7efe47c9473f21,
+                0x542832ab23b6c7a4b547a1066037152a2442e998c5381ba97698413153ba6f1,
+                0xba1f764367360952942ccb6edf051c8f937906a816641e0d1e9e2ed26906fa8,
+                0x2e0611fa4ca3985d7bfaf512f21a4081141f4ed0dc4b022834d3cb6cfd8b7ffc,
+                0xe6f23c0ef6f159dec68341a87830fb864b6c08cb954a14a2500876697897fb7,
+                0x1a7a2a4a08d87e75f720302bead7ca21c8f7c2ed2debaced9b8b1b2da461cbc,
+                0x1d8005df48c8565987dbb442b482cae5bfc10ee486ecc5b670ce861345979d1d,
+                0x28122254823f8926acb7e98f557e796282e5e1271618858e76d49d0886da16f3,
+                0x2414d4aefc7b4857df681328e68a582d23b2dcffd579a8e6aeed6c61050e05cd,
+                0x2f710c72d6da19c7d87cbffd55665b472b0265d13e2326a9a33b96e95d3746b6,
+                0x2e285441d0bed90bb41d6480836850e4d76da8211b04a236dbc7c3c30320c00e,
+                0x2964901a2b42e9aea1a6593662aeb9e12077a287434bda4ec2012e36a19dc95c
+            ],
+            [
+                0x69b1779dec3eaded3f07d0c3e6cecd6cffe78d747faedad9c90665aa2d92cb3,
+                0x187aae261ef3ee21b37023518a071675c6d00bde82bd7f5441448abb632a764b,
+                0x169538094d4f752529471e3fddc9ef994cfad4f96dcc7d636f0fd509b8eb9c31,
+                0xa68830f19c0a729b2f89be27373d397ae1157bf507e7799d4220166ea0982d7,
+                0x18ae39086eebb98d1fc5f05fa0f87ddcb149b0afe38d1bbb85a65697895e63f,
+                0x4c5ebc771344cc0612765710bfcb1c2e6097abc3d346f049495f7d7b7f06cb1,
+                0x29faa7dadc8b7e9588d4a601e77bd80aadf272a1bfec3c443ca3ccac81d9e1e1,
+                0x2acf3493012bbd818724e7ceda2431e97c8933bfaeb5d7463b512e6e8e8f7fcc,
+                0x23b34612e7d052f6b312ca0e0cf70034ad232d9bf63c88821085383b6f6ec4a3,
+                0x11680cc6e80b0e430a4cd3607017fa8331d86c4d03a96dfc18767c97cbe0a197,
+                0x1fa772ebde6f3732444623d67fe991116298f8f30a2d1010c8ae6132a3d6907f,
+                0x2e63f1740332f57e8317f2592ebd8db0812714d6604132d525e33e19b3c98494,
+                0x1202e349d1d7b805846e90834efc911eb6b10c2a09eaeaa29ed288bd779b14f1,
+                0x168fdc32d4aa8dc9034ad4a4fafee89f0ed5c980d3db424d38f8ce5cd04c237c,
+                0xb9ae9f5ee6ad70a651b4b66e34f521b130d18c49464d86fe5d4b1820489028f,
+                0x6c2194af72fac58ca13a2a5e3223104ef49a540fd2eaea0d67a920d8567040a
+            ],
+            [
+                0x1fa4effc83498d19aaa598b7771f88a0554dddda89d32dcf8a6f4cf776d13b99,
+                0xda28ede7f63f75596a2568b2dd7a584576e5b282f284795b1a7aa21663822b1,
+                0x199835da95f6eb22c591ebe514c7f283f674fcfa1eb787dfee5781a64f082439,
+                0x2af560600b3e25abcc7f78a4d6e2cd3fd99bcba075ab82b55e9841bef7b9210d,
+                0x101544d131454f20b549b24a65ec84f1b3221fd9b43461ddc6d156833b34c52a,
+                0x1a51740cda5e45ea4d4bd7bf5ce5466a66a11afb5bc93cf10d5309e07d410e4e,
+                0x1324558b8a5d4ba61b17790128be9f2440c0085dd5d6065b88f0a3b2537bdadd,
+                0x13473024ba419fc2a7743e7df8fc8375aab150d3753a54250a808d66f2d06b91,
+                0x13f15bc6453df6f9383446550534dc57aedb10139e3053e83bafdd99356175f0,
+                0x1314b54f8786096244532c9f054b379636e2b58bfdceb3d48dfb2210b529b4e5,
+                0x56a8ecd232a674c63d7b603ef8cd06321c560df2fd3f6c2649af576467fd798,
+                0x98b740976c2a1031e75132e050bf3838b739d061582543c1c7f95c152ee262,
+                0x24b96dbebfab6d23fa32c2c8e7758cb240bacd8143323c53cdb48dc8b65f8e4,
+                0x15bbd5619f0d59790804f2b9b37e069fc909a2796d1f77d0c62609deda2d0278,
+                0x4760054bd5d07132548bed7657f17c61c038ebcdfdd4025c7b802e08948e108,
+                0xa5494c9bcfa06aa72c36fd22d98fe72dc14dc0e4e74e03d1755f38ac34050ad
+            ],
+            [
+                0x1676f5c07417ab54c37ec8ae1a8314bdeeb09964769881592043dffcb26bf41,
+                0x2043bfe52d2964e4a3b2da5e30107716cc764f9b1c8ba463f215ab1f7f03498b,
+                0xdbd8662511dd7000991b39da129f9d03b565a0cd2f218d6eabbb49a25f105e5,
+                0x11b33a9f1818ed7f581cac020051de26fe28dc0bd8cb1a4457d5a8447bdbd6fc,
+                0x26f2f58d63ca6ef59bb95206ce3ed3124885ec21762bbb1db1d6a7771ec6650,
+                0x2eb6ed568377b696ad3cb237064ec68e390c24886e1f122d21d7cf3290dc6d08,
+                0x18faaf1c91e002f7dbbd12f408bd5c5b92f38e02ce3635824821e0347faf53ec,
+                0x29437af1b14f637a1f0e39955f2604bf20439fcb2a090e346aa65a9ebe69788e,
+                0xedf86bf1b1599fe27c66f3494862d75df7764070a8263cf88778f7287938d8e,
+                0x1336b208e00d8ebac83246a96ebdde351063fa3f635887e753a0ce3e29c7eedd,
+                0x2646341eb44b4800d56084cb48500fac48fc533891f557e96784cc6004d8928b,
+                0x6f53c79fed9e09848e112a0742d8ae84a04bd9ba5aa2765b1e5edfb1602140f,
+                0x2a3c9f55afacee735a1b515526426384ad044291f7691974d9c05c634b43947e,
+                0x1e16e9ca2502d696023bce3427244ad6553ce86bbc4c349a34ba61067c6b6d6a,
+                0x2a4c6d3259779c396ef8173ae5fe87bd611dbe25d1c048ada96306db1e3a40d,
+                0x265ca211180b012c378e0198f0b5f7758c155e3675fadf92ca79156bd56fe339
+            ],
+            [
+                0x1f4e7bbc8d42779e58aa07bf54ff324b814fe687b4c8eb81b9b7e74448ee27ff,
+                0x27b48a636a39b51a938aea3eb552091559fbfbe71e096d518c40d908dd2570ee,
+                0xdd0c118f15ae07e5db55077dfa46e08109954d99e18d72cd2caf613920e390b,
+                0x45c617f604c1ac9fb8d76e8d380322e5a3b69fa7b7c2ae2c8ec5966d6a4c788,
+                0x25b974fc5129d82ae4c6246e35f802e03440ead09995865313c8ca91c820c2d1,
+                0x181589b140c9109e492fc3ec7d8ca8e3c25a7ce58df06f13ef43561d58c5926e,
+                0xee1288b29855e2e38dd26292b39e260529841344538d6499996a32e7cc523f3,
+                0x206e4d445315b764280cc643b9479f49946ea86d7304b6a2c692ac34d7c98d34,
+                0x1641648c26b5a2dc297daaa6d4ddb6a2f258ba738f9094e7c5cda6efa8c993b1,
+                0x1887be87f7a352410482ef3bdcf7ef17976e087eb8990c76d7e971c44c048239,
+                0x231f2c98bda8d48bb4a6d9c98bbbc16027235a22a1ed4f88bc8d3a6e582209f2,
+                0x1fcea89286dc1db61fe1111606af396e98cb53dab5199750aa5e5d11561fb145,
+                0xf7bfcfab17db34c144cee44636bdeadfab44a6bf4fc8ef384ec89a4ae9ed209,
+                0x1dd0a5502743aaa9f583bd0ad35de13ad8d5fc98f1961f2612ad4c28fd9f9fa,
+                0x1959db01f5c8bb0cf483490373e75b0451b87b43e59181be0b6016674f3f5efb,
+                0x21f659fedaf6c2617f17d637cd6f54a27782f4e8431f87af5c8591932ce7dab7
+            ],
+            [
+                0xf6b18c98fc89fbfa99a04c8c96ae5db35c296479f484b680df905d4cbd1dfa9,
+                0x17fe75a3d11b4b9d2acf7856d6dea3bbac62ade0c501347b16864f3c73ebb7f9,
+                0x7c921bf45e354848a60b0e5f292bb03c2469498b9c1e4d322f4afd1867408c9,
+                0xe6197fe502328d0ef7f9b930355312b347204b877e7f85d9b569dc34f064c1a,
+                0x2d409bf78bd6f6a4eca7397d065023f0bb6732207925d3ce4beef9f621da2ba2,
+                0x205a6d5aab2d224b668c70fcb41582ee9ebe1ff099292b4bc50af8b292c0ea42,
+                0x2380ab051d0ac580a7d116f4a9337eb31090a4c7ecbd4e638e7717b7a52bf106,
+                0x1382c3c24bf2489fe9efd80a163e650111f5d9885e58a9ed729dca1f9a74e59f,
+                0x280c4522ad0ffd92c391e94c70f87120b8341890c3329af050625f2be52f3a41,
+                0x1f405a9483311e1497568f1bdcd6d58cd6bc813982a0e71561b620003b888204,
+                0x1cafcfb62926fbc04857b0bd7d7392b8d8add16b5cbefb54b4d5312826e89942,
+                0xa12e162620e71beeb203be56594416b083e7e94eec23e0f44a5ffe9e159508b,
+                0x17203c4d2e1a428a17be2c27d1c4c5960dfc6aa36f22bdde8be56a0cd44e71ab,
+                0xed2cfae7b36f470a7d1f6940f914e8ecd322bfd6b50f9ad9f6a2226e7a95db4,
+                0x1849cd0910d72eacc32d891b71faf500bcb93e1cef2504af443b94f8b1ce7212,
+                0x1e463ae3f4c3bd047aa1049f4f091a2f1d5d3550e3d5801fcff68f9a5e6828f4
+            ],
+            [
+                0xe6cd10883e1e11c6c191d36329f30eb0045af06c2d86d0c439f5c1f4fef54b,
+                0x2326c3dca7aab6b1852654fb13fff42a152ca9632124216cc7cc6f6d37522a59,
+                0x1f694d1acbaab0ea5bc026a1864d568be555b89c0f49b6134e9b895ae141da86,
+                0xcdfe099e7a154278dfb6c0388b9daa1e8ff323a20be6a6aa7a8438333f879cb,
+                0x17f732cc1354b1fb476e70568d2dcb0b6683d30b02415dfd385504736aa86de6,
+                0x28239a882dc7b2f3ff7b9aa8de9e3d81af736d4ee6ed991d5c6b4fa540148f43,
+                0x158926b9e94b10fcb321b293bb8a8647627a5bd31315808d397c1c94f650f2cd,
+                0x17cd11864fd2c73d0867d37264b4ca14df935a82f2a6f432c4998135fa5f4aa0,
+                0x1d772098b6154921db8e7506e6f0372ca44f20af3386e13bcf71ff5dc0d61b1b,
+                0x209576be72db7b0c9fe2b8329125e7dff0489a8e900a5f14c1e6e48604134264,
+                0xb7ab1ef17ff6235f7737f044161902f03d594cf4a0cc67b4ffb4711ade1eb0f,
+                0x1b1bbf4e9f706051716a0e28990caf17573086a5d818c038836696808b12d8e5,
+                0x22a8ee74367413eccf7aa03fdd420c6bb6255a6dd82081d6b14eda9a9752329b,
+                0x2c785f9d8834f5cf5d08f106d5f9918340fd414abe24f0a9ff2b8e0492b44d83,
+                0x4b5dc2057b88170a718a102e0ca9177afc757ee26773a0290c6bab159ca4fb9,
+                0x27412191fa2b2e5327a11d290e4b439a4124f48145c61ff4ece8448a4373eadf
+            ],
+            [
+                0x425a9641fb01558bc7170a2ffc24eb6a514198b296a1629cc284d983bca8757,
+                0x80c442909227f4a9da92e33237f9a82cb0c6f7d0c4155bdea5c6517b046eb9e,
+                0x1604de6a2db122bdd5d839540a1005ed402425bac3b85e3a72224d337402bdec,
+                0x15ded859d501c2733feaddde22ff36fa8ae85803aec7a204f42b1f6553bcc655,
+                0x40db0defe6ba4797b74a43125cf34d86a2b33e7a22e2710b0fb7a5568893aac,
+                0x1ab15f2fde6f535e77e615c8c2602193d45860cc015849df578f9fef9a5bb283,
+                0x264fadcc791aa18e76751a895242c30cdbbd1197a90a456dc278e10bf0bff5e5,
+                0x2de279fcf77a270823a91a6cd1aafb58e9e3ab32fdff0b3b05c98d554db6fad3,
+                0x53ed8ad550d8992f4b9814920183dd839bf355eaca8cc7b07020a22614a808a,
+                0x279702b135d144ede943195269c00bf620f058bf0186ce9fff3cb38b22245a,
+                0x179a82b77f2ccb94b38eb582ac4abbb16df429ecc22471be73cc7766f96d9948,
+                0x89efed00e9d993f5fc1d5af2f2b5d47a9b70e6d5a603fbaaa8f65102123efd7,
+                0x21e25f0a7f8edc38de25ba605a86cc08e08ccb03e77c5e0b9edabe74768b60c0,
+                0xd8dbc3fc854c0665c30c48846d7bb0eb18d3d78a4f70fef07f242e45b865eaa,
+                0x17bdf338072884b522ce3c50ef4711091b9daf48a43374bdc0a830c37e5dcdc8,
+                0xb3a769c8b371562260395ee4f348f88bb056a2f0ec0f98e4e633bf7d943615f
+            ],
+            [
+                0x397a7d7434b0aa941348de45aec442cd5cad2c398884950e8233c58dd50335,
+                0x2b1c00ea00893f9f91331bc907397db865c37d3bc6c4b39b81cd931696fd7837,
+                0x25970ce31b7b10cef221267bb1be1656ec29146df06fdb5b4f6fe6607523aa08,
+                0x2d4026bfa7b37a19a300abaf2e1d5c32dbcd42240ed860f681f61dd6d6214cef,
+                0x29e89034942414a1ff6833d6e22742d4106e0f5f37d1f2ab80e5444e5a52c9c7,
+                0x32b6266f24017fde1b281d0fe206dff30b539d5c5ba13b5312e488d8d6f194b,
+                0x2ea014b61ed575392239bd9411c0a6c4202b7334cf2e0dd8c3040528e4a3dfda,
+                0x12ced5254e260a9db7abe0cbea26396680f6e57dc07732a755d409ef751200b9,
+                0x1d4f9ba4fd8ce4ef193b9f870f44956079538d63bce344f9016ac5ed63a99a5e,
+                0x2c9c3135cf64b89eb5b714d7b2ebcd81fc7edae637cc6116591df208b6b2583,
+                0x18b63685f6fed2aa1904856378442151dd1fa01c7ce6121d23e1e9ee20b42558,
+                0x2b202e1d2626c6793d68aacf9c3a8fffb27cdf5a0b83ff8f3504f9ab26a43d15,
+                0x6a78dfde1458ee341a089c15f953a2193527dffb43f552cdad595da7c6fecc6,
+                0x22f62e45e50084696ac2512a25db9925244cf0214b6b543d3a9f83b8e8e58ffa,
+                0x2d9379e69b178208b8496b8a0a0a90d578b21f090c53042be4767e3c10d3b40e,
+                0x1adb4c87433d866e8fe5ae26d01477e3962879c20c8c3a170c0727167c06d0b8
+            ],
+            [
+                0x1d66f208fc04411a1385c22e203dc08f0bac2f7cd9dfaccdec20d3b93252ad04,
+                0x92f03c7e98e61c2a85943ffaf9c04dbb0145fc2055e4d5be90bb68b90109746,
+                0x14956f80a65b01f9ee97e2eb070e9df2711cb8bcb538dd98e532636cc60782e8,
+                0xbccb669cb016d498464944f7192ecff6716e6cb5f895d2715bcbbb65b1288c0,
+                0x121d2ba5bd8f232ecf44aacf1044cd6ab6f93f1e537d7d1541754fd49f51b225,
+                0x4e358f259a33244f4058a056110a26816bbec3c76ab6a5f7be93c9e0c92f3eb,
+                0x2da2603a26d4fdec35318204ba5060663e15a0b1e4d9395258d5e6eecaea8fb1,
+                0xef5f9ee6ba1ae1d1264cf1a36e0fe4b8043ab0bddf9b9c3200fb687a8ea5c83,
+                0xd53d61c8a5214e0c4715274ad67a5d6a2cfb9fc3c1e791d41de22c8ba8468a4,
+                0x252e78b4838ad5007f518bb9c6a4ce501871f71128eee3f0c9784cd64b183fbf,
+                0xa27a8d1af6a0460ae1724f32f21a06b036668d0a863be50fcc47fec5763ce93,
+                0x3048a265d0eeb40e5a531633ac22bb825f75cee9036e66a061be3d4d248c862,
+                0x3fd94e51bbda6843d31a282530d54240aa496165d644d5d7737b1e5a7d60d52,
+                0x2f26bc13ae48520a439c9f546abb35a1222a307e38fafc3e7ffc843f6c77d7ad,
+                0x14057d02e5ebcf33c166e18fe904defa9e342a19e88d42336377f1c5e67ec30,
+                0x1fc26ed027db7b9e7241c2c760176662f634ba05a9ca7a850e184ae588cbe215
+            ],
+            [
+                0xec1ed3ae3beac4ddd1fdb17b9c7c648e7ec81885a07a5bcbd967e6a3676f356,
+                0x2a0f77bb3624fc4826c9a2a66be4ec75dbc21642a16fcc4182d2d65c0fd8d7ff,
+                0x1d799ae83ef6552f30edc47b9e82adc0503dc4b74da40ba0bbd2cc9eb1b0a53,
+                0x5de1099c65f08a990ac0f1f45ec2fb872c771e10275dccfa4fce1146639d0d5,
+                0xf0913eb4ee7d3c02d8ce73d1cec2b6cbb176a92129b34a294adf066243ff6bd,
+                0x25a9ac2d1ef84abd98927b52c24f38796ea60e63858ec5b50196d7e169c93b84,
+                0x20a0e3f4e1249c4c6af100dfdf63f8bdc69ec7885bcd0d2c2e98d98f9bb9d104,
+                0x6b7e18d01b47ff8e4ef08078e8128a06693be657489492ac4195a854722bdfd,
+                0x12cf87253913d45d287e975f2b4f5b909d16a87d89c889057f666f6ba61389b0,
+                0x29a7d554e9ffbee639867842fd0e7d41ea9b1bc9621b654fcb398f71c95b668e,
+                0x186756775058d09c639cdabbacd01bf3c2744152156fbf7e8f3e999fb610ed38,
+                0x2532dd7487fcae0dc3a7ac50b80ec330c6fb6d4cf885f1135988bf6dfc010a6f,
+                0x2efe529db1de3c01d6fe7fb8a71f1eaab6af1641fb1f7aad4f2b88cd13c9fe5,
+                0xaf825f7ca24b4a285f544762d9defdc99f2b85c1b89fc5ff2079d3d50e6d4ea,
+                0x17818dd0254b291d0d8f4f1a458c6a21d8841153661812bbe986b1403cf270df,
+                0x10175fb6f81b16436af30682f36fbab396eddb7829a50e946c75f27e260987c7
+            ],
+            [
+                0xb3e601e36a5d82e0214362c8419474dc1cc2c0ed8126534d69a3f790b27c603,
+                0x1083b742d35332a8b79b80e7dc04a72f7e86692e529b6a1ec5687334b607da7c,
+                0x12417c001be86197013b2b4871c4e9b0dceb83991919a9cafacfe54666f590af,
+                0x2c465d9b5eb852d79338b427b3184d941f34046172a82cce44e2b8e5c4379478,
+                0xa0fe66c0d4de00cc7761008732a0097fb14d6465f9d1df835e0423fb207d979,
+                0x2f521f24bc02286ae2bf8484fbbc39843886755f52bfec7d3dd5df78d340721d,
+                0x2f1d3eed36018f9679711e030bdbae51224b5efb8b1eb1cdca8ab886212f0fb,
+                0x23aa7ccc3751b740eec9f35a29986bc958a4dbc7c4b12eab2be8376706deb20e,
+                0x2b088cd30a10899babc325bba32aa343d329f9a8782469c4d25f0f237ff607fd,
+                0x305a0c2c2c4d35998e9913829f5602504363f21bd720347350b604193e79bc3f,
+                0x8bd9ddd192d797a19dd1da049beb39fa6596598a27031ea1c2b28966d96180c,
+                0x12cee8e3d1cac1ca84517ab3def487c460aec058348ff220c801b78979af9e61,
+                0xcab504b22a3573d09509f85d3fbd94e94417acb25392342bacd684006c37185,
+                0x160590968429f480f55611c6448912fdf423d37bf483c36acccc1ac9a29d2a53,
+                0x1c95c2917353c53b4cdb7f750a0fe86ce10f8d5bdb018032d3f793797d7c0a35,
+                0x23d300373bb8ebf7dbcf314a3c0b1fdecd5cae23f7e7bb915bcdb6a6782b57fb
+            ],
+            [
+                0x163cb4e3a5ec92e57b25b095a3aaa8cfdc4ce59267718cc6090a07e14af10b0d,
+                0x53e95f9455bc6499d447b6cedd0b6aad9cbced97ccf10060f3c9ef51e28e76d,
+                0x2171fd11f94485466a819e24d0acef08b0c87d78b46d93bb9462b443fa40cdc5,
+                0x23918075c8fa0929befc2b171f99ebe9ddd6683594ef9a83f84d4acfd9592d59,
+                0x898ed1ec1a43687ff6aba32de5f819434528a0752b3928331899b0646b2f061,
+                0x1dc3f7a659530a13accad181b6e265474108d8b1469266552dfbc38cb679d06d,
+                0xe388bb105242406e372080e997a31392cf4ffbd9c694163fc366eae770e435d,
+                0x2273c370eb5810c03903605d7cc94d5a92af6aaaa7b844f35189e77406a7e86b,
+                0x19972ffdde7898ec8be4fb28e4b19efaa43c7ee20c88e29096ebe872e1c19475,
+                0x61d78e1953d1943e2d968335b73e15fecef89075e96c943d39702b214ddc5fa,
+                0x194184a825de9e9b63ed7a7bd071253ef5903e1e75a50536db93c26311a72017,
+                0x21c0d1874decaf90613183ea827b91c1b2951839f71f329cb9c9b0753ffaefee,
+                0x1cb33ad2ba7dd0c2063443432a847bccce775a8daf868e0c474905a4fa36d70e,
+                0x2bb32cf60f8d469edb1b6c56493d4c9338b4051ae2514d4b6082ef18b1d5228a,
+                0x2495b3c1bfec60741808149333fc43f04d79dec56582c292829ffdfb3c1a3c4,
+                0xf0417fa6237167e741525261306c17664dc3efa9247aa0d4bcfff38e89dedee
+            ],
+            [
+                0x2dca90f3e5a15b29895f48d7a1290d7a33646b89620dd0a8ccde3aa3a51d41cb,
+                0x5904dae3470d40ce12749b27d646e620e8519e2b17cfa016caeb89d9e34ee6e,
+                0x22e9bf2aa02fe65e3cc74fb3d83d4e3351869bd30528c378958af462efd645ff,
+                0x15d7fba62bac57be5d97452a3c06d9fa757f144df166479ee7306967480a287d,
+                0x11e0b2343ef371d2d6d22805974f2539b6e510d761e0da170d0da90095a13262,
+                0x2ba39845393fcc776fd383e535d567621c7f64005a83a6f7f48222bc902092a8,
+                0x25143649c13e08d4b00bf34d2aa1a8e450f89788e27766896217047155c5bf1e,
+                0x2a7310e75fafe902e20287a91abe388aae8420b1ea4660dd7c159c26b9632cd1,
+                0x1fa6944703fe0012a16ee6042529ff02bc804313ef8c6d8b0f910a75e6f47739,
+                0x261f975babd7692822473b8e39f948b9cf98730a9785de393179d4bb99dacdc8,
+                0x2e08b28bdcc417d9643b3008085a27f4a9876792d3915c8b9da3567a6dd6ce82,
+                0x17e9ed191c5641d768b0e55ec0d4a85f6e5419d32f5668d397d5b6cb805387f,
+                0xaaf37d1f53dd0556e347ec705962379077cd543198e1c27593f4454521261f7,
+                0x2a4a72e9dfe5bf25f6fde750a1847e5b44298ba58fb504be57a595e7fccdc404,
+                0x2adec8549dffde7238b2bda6e7732990a911700c8d35288baa39e67015953231,
+                0x1e8fd20a8030fdd94e2c4353d8f82b4b212bf887bc59615814890b0f92a47d90
+            ],
+            [
+                0x2c78ee5ea16d38f0beb9dc0733c4bb1893cb33ff671b737a1122d64f729cff22,
+                0x2e563b9dc5a3d4d5a93f476b466e371019c77fd6eea506126a4f79274f2f6b9b,
+                0x72ea2f5cdc8a3789fbcea414a91e7b27bbfb3151df510d080ff4ef7cc73f0d9,
+                0x2b6f16f812ba903901355955cc4ddb99f24f1c6e26430947e51811a68311bbf,
+                0x1d59d5c10b0c9dd347899377da35b7e677c7d39ef1b49166b974a7f2bc99c946,
+                0x4730fe04e0108c9a5145a5c48e60c5457e4708522157bfe0f82af5c664d6ea2,
+                0x12ec24239ba1b0fc9f952550a223a52d209d8d22b8b21ac24881a2719276be0e,
+                0x20098399725ee15d93ffd3e481e4a7b95c8c5083f9d69bff1714eea7c7d82d49,
+                0x18237af733bc44418ac84e623f483a6be28b8f21d033fbf099d645ba20f1fc26,
+                0x1e3d6cef37f9bdac23d1b381a6c58d0ecf06a6ebf58dfa7a995a443ed7df68e9,
+                0x28e55b0bed59191216d5dbe1dd05b22c009b079de877fd54aaf5401d2c867e02,
+                0xc6c9ec31c9e3be0744919fc555c77c0c125927bd16de2807712b35ca26dd045,
+                0x2a607facd3936fdd0e84e9bc3e4b4bac86e8102c2b5ad15cae550d28b3654e73,
+                0xc509a4bf48ad76e90410bea34a8919741608bbbb6b5503c93e732036f079d12,
+                0x178074303b90d8985e376584b8b8dfb7f952f8f4cf84d815f90baaa3b644c4c6,
+                0x18572826385dfc6eeca4d3c71d110b04abae013c5450d9e4947a3d019bb41b6f
+            ],
+            [
+                0x2af324ec4f9e7786dcf00439c75a294bff753e3292bbf62e66471fa730f19c79,
+                0x14560083d980d172dd40c9426cff41467acea41d7f48ff11ac5fcc087ba2d5b8,
+                0x260f751c7823abae61b8f3748c84791c0bd84acf7eb6854870250178e9a52cf5,
+                0xf6673b7fb4be8cdea74aaa7802c9c73ff0d53a98e94a2bc60685d890a24fdeb,
+                0x1a15b7e2de27125f2e6a74f4ec7cd2455f1bbfaeb1155f1af819bdb5fe54241d,
+                0x75a09e41e74de8a2ac7fef27591e76a77c851e1a51185f31e99b5e08f01cc74,
+                0x79c04944d50b4777dd0bebe953600645ceca9d65fba020f97365146bef9c6ce,
+                0x2ca2bac7c1aa0c64e684123f0ffe22173923052b6a01f3c29be80137fd8972c,
+                0x13d9035a0dc798b04dcef0f08edd241524fdca0e95ba9cac05d207bd317e19cf,
+                0x1d6657d791831169c56b6e9a201f8b7b240246a2d0f854430489b983454032d4,
+                0x1c89d8f975f0304282ad8f7bd41c12c3b18ac6b80e4065fccda423bbb3ffa786,
+                0x20829ef3df9c183f8965e49c8f315c2995a6446a76053543eb750145f1a77400,
+                0x14a2bd5a56f87009db981546533202f3af812d2ef4d6b037f2830853b9f9039c,
+                0x199733da4aeed8d6cd148461617e8e46de22d3720431fc1605619b12a7fd4e2a,
+                0x1f5fc060028ba07d11fc9477f4faffe79a81040ea9a04c568267644895e6737f,
+                0x208b7c8c1ff8422d4a1bd13a02a94681ce217d925f40d2875f73def14de7a220
+            ]
+        ],
+[
+[
+0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+0x214e865e2eabdb9fe5d563a141ce18bb254029e0e04e59c2fecb0850b5ff572f,
+0x1e0e35883b0f1794db023f80354a83951383b62282dab4129db1d19e605c316e,
+0x5c51080a74b8d28b50b14228c6a6de8ad5397cb9a4b9c6cf86bb807cad76074,
+0x244e0857b01e7d7aa0eb2ef334fde51f16a2411abfec2c3beb6c62f7a7036217,
+0x2a04852a90b74143f3808a150e9f1371e0177a1b6e72cbcb0fb8f1ddce8a8d02,
+0x305a319725a0b7bf3def3f71517cc2bbae386b651550fe9405cec98dee21b1d6,
+0xd92a7b009466985fef388ca3d70c7e2c0c2670d2260df83659d776002843107,
+0x2a67eefc0930f82c8bc66ffad5ac09c107407814131cd645bc18cda6fff4f52e,
+0x99674734918ce9329409e50f2e9041bd072f9d827737de601f09c7ade19d35,
+0x449112125b3f10a53b2c465f2bf1183f03c13825e76d40af75da04b8137780e,
+0x2c1ee387a8c15e7dbe92032a242801d1f7b411a7e5a36bfc4fa2749a22cacca,
+0x1d687a4e31c6b3c91e67dc9d9dd9c47493c839b5e13ca1a9310e6ba011421cf7,
+0x1dc79a5d9de443db444de0f08ac67be4826d018fd86139ee9eea781f4df48939,
+0x2d5cf8172c587c0513f26105419f56319763c5cb42cf9ecb5e27d9a88c5d16c9,
+0x25bacabe48b3f030c806aa879f25241fbbb17534d686bda8f5d478662b2a5ab5
+],
+[
+0x69b1779dec3eaded3f07d0c3e6cecd6cffe78d747faedad9c90665aa2d92cb3,
+0x29fb24fcfdda928bc18f54d5594a0c23bb822c277fe2bb999e04a37830c7595b,
+0xc05c2d8ee022c59521bd441aa15fa2ddf43e6ef9811b10fe9640ee5e888c388,
+0x122ca048d7c6d4b9053b59ab67650d10d22515f1365b2267c086dc7a168de657,
+0x2fbb74d7dd4ab190e6244236580314c820bbfe34045f43ce14d1ec0049afa187,
+0x2cadba86ff66600cf28005f0ac4870914118c62e110e3ae0513dedf3bd846d29,
+0x30d436b101fcfc29d67d7fc4473218360f1a52bb7316c4a080a55c0d01a709e,
+0x1041a8891a37452dae7c58396d225a87ef1985f94485bc3bb94588dd00132b2b,
+0x20e8656cb5d68cf5f5aabd0cbc2384b00cd1b65ea77b1c0495a65f3270e4d881,
+0x17107096614bacedf147ec8ba8ddbff1d99d5ec24df5495279a720144ad00dd2,
+0x2615060f9b8b7972aad3c06f80079700edc591d0e701ac424203a6a7beb5931f,
+0x1406d86f9f6ed52732899488e062f293c681767645a636d8f078dd40672e632f,
+0x47dbe55f778c815cd8c79dac7d59526dc76570fef2224a93640c98770c056cf,
+0x2dcdb0a971c5aa120c3d873cbd072083a649e903145e00829aa8202ef09be93b,
+0x2bf712452a11b06765a0d8c7f0af790527a665863294a32cfa3d762a5aca3b0c,
+0x12a68ac33549f6902b128cb376c2f52cff07f1279106386b26fde8fc49de31eb
+],
+[
+0x1fa4effc83498d19aaa598b7771f88a0554dddda89d32dcf8a6f4cf776d13b99,
+0x19b1577a9e5fe67f71e733732ff6ba035dbb18d129f701a566068c4aad32165f,
+0x82f3674a3860d8034eee2f705933c2ebf23a5ebc7a3d77c46c9279df8930298,
+0x1011963b5e7be95fbbfa2848d56da05d6229a3f0292c50760027cfb98577a2fb,
+0x2ab86635f447d66ea5ef5e5339031197ae8e86b7350744069280de59d7256486,
+0x14fc3fe2445bef8547b023a1ced3ba9e137e16fb0e3645dec813cdd7e584ebc8,
+0x136afe9a53acd5e1d68cfc75c5630d39701cae3744ad5aa2aa34f735ea830703,
+0x18bef702cd3178eb4ba589b84783071cef268ed6828f70c960e379508b9ff1e2,
+0x2c5c474a63c172ea6d6a1fa8be92e4bc6891e74e87c5a65c42b61aa42a9aae4e,
+0x27e3943ac99174b2829fd8ffab17b16837fdb88a0c6060e20c3e5c72fb420f8,
+0x288a44d1afb6a92a5c7dc766d4cde4874b0f49cc3e798fc25292cd13cfc4ebda,
+0x2d255d4f28b56db356773293cbca39f6f9c06bc4cb5275839555db772a969ba6,
+0x262650e9b1667b31877c8d79a5816cae80e222df97e48b574ba91e6cb509e931,
+0x22bf34fc02aa2e215c993994c7cff2626dcb7212975f7ffcf11cd90b07808e70,
+0x14078ef63c2a106c8895143763824ffec7a868e80b89ad6aea82263b298132ed,
+0x1d16de8069581b62949f3e5bfc1188e21cbdf5d67a5bd403927da3a66f49c6b5
+],
+[
+0x1676f5c07417ab54c37ec8ae1a8314bdeeb09964769881592043dffcb26bf41,
+0x286415acbcc8aba3e5b854a6a357f300ba4037eb8b7c5ef6bbac868d1b4a5635,
+0x1aef1d337ca51ca5d2c5c116a275a81a21f90d89834bd1af61b3aa6bed65c7c0,
+0x17e864b0c0ebadbd2fd4f75177b9e7fd801bf3c066464070c6527f096b0b4e9,
+0x2587c2ffb837fcc5be1b5a0d520f0f2145000b6797a9a5205ae30240af69c7a3,
+0x2ad5b37b82f9ac35848de9a7b0bed4262b3074c8047d8a4736959a21946f7db2,
+0xa32e49eccc90d7135c8c66fbb1953bed9da04400221cc606416f0db0b06930d,
+0x24e2c86170a5b4a8c95066d5f553eaaede655dba90c32e485adb53c3db9f65df,
+0x2e90955a65c11aa740e8592c94a983b542bf95bedd9bc24673647687c57a419b,
+0x11ced1dc351f0b67b8de31d678da740e5a0c4bb1e9adb04b119e8de79e908283,
+0x9de8b7bde7c2aa28539fc3f31b1f28538a766c53ca6e92a1639bf1706369482,
+0x12550c43d8d9b152c039868ca4c52f074e02f31e1834978c8b554daf43632d88,
+0x40dfc65f3133acc65a961dfc4b365d21d41b9e82cd7d65aa2a3238a3ac5b92d,
+0x12f7124beb62cae35c093ed96975ab5dfc8e00f2668c6ddba351f458127e96a6,
+0x530ae305c7c8a9ce61943baa1bfc0b2e16199a994469f41aec17cdbd7d074a5,
+0x243efe17e4617bc0c20ecb5f9bd76f48a8dd796fa1058366f55826b80aa69794
+],
+[
+0x1f4e7bbc8d42779e58aa07bf54ff324b814fe687b4c8eb81b9b7e74448ee27ff,
+0x238f0b87f232229a5c7489e1c7edc9d319f816c21e6fe403ff65c60c1ca4b178,
+0x1df906bd755c6a965e2ecd7d32768ae2fd8c522dd0ddcbb002389e90f5c6a707,
+0x2da47d7b5389318990e3d6eb9f9e93eb7404439b362a0d84da24d8c715fa8bf1,
+0x17c623def2d2610588b3c5dd236ac31026a16354f29b2f8a1b0955c391701f5a,
+0x1c6c37b8caf25198a4a9cc93c559e73b7c90ca6df6ac721a2f52cee03f57221b,
+0x27feaf5bb57db47ec317018969e6e767f48d768fb138698ceb4aad474f10fb3,
+0x4e392117390c777ae93ee29db53979f4f0e168595d9dc5fec4eed18ea0e33c8,
+0xa1bf9ddee072347f46524461f66c65582c5533be183c39ebc5325c2e111eb55,
+0x23382c75620eda77c18e3d166fee7b74e30202ae8309890010849e1a79cb90db,
+0x234c33dc7c164b187746919301403d75c58237965627738d9f48d393a44829af,
+0x216ffb6e7e5316ddb852406f11331c24f717439f27d57ca15de065958ea44462,
+0x21269800c6b53df048610f35d1b344e03a0fe15f0a5b21b73c799a48e4d0721f,
+0x86ec72230cd5fc6c7842cd5eb4fd6b75c3051a915deaaeb61e9b22780579a70,
+0x2f54161c4ccd936ae2c3edc204637dc114d4d3d6d98bd9b6d8bdf603bd4b7e72,
+0xec71181ac2bd7226495ff60adb20a3c9a7636dd9faf14db5335d8c4c1ba3a06
+],
+[
+0xf6b18c98fc89fbfa99a04c8c96ae5db35c296479f484b680df905d4cbd1dfa9,
+0x12567e67abc9b35af4ffb381ed3acf244a2f9019839f5f8d2f0b442f51be88,
+0x178391cf8f91a1e3b00f545a3a4a5331feafd2a0d10d9027c56954c8a3f8ebc6,
+0x2abf38b2c05989402c75ec5263e3ac75bdbe9af0c1eb92883d5cda564ecbdc37,
+0x2a2c5e5b24751e4a10e893ec2f7ab96f83a970cdf3a543b20a48357cc7ec8570,
+0xdf7d4b832373582fd4fbcdf7f3c49749f6efb59fd99f4e8fbedbc8190a0d8de,
+0x72011cfb8afcbd8b431269dd5d74aa99e795c6628dc1dcf6c2d8db003bfb436,
+0x2e369b2dc96609f8c17a592f2ce063683d148204c2912b0e53a70a3c46bfa9b5,
+0x59b27028b4f0949345ed48b3e799d1081350784e0042c994243297744e2e226,
+0x222dddba5c72cc2d12f0aa37e940a09424f6e3d679cf725bd059b4182393c08d,
+0x1d4f2427689a1dc5f1d7c68311ce5b0a56a961b3d42a746f356dd81fa147680b,
+0x2b29f8fb4f37691d3981e3fc495ee58c25ecd758d6e24c3f41e5c56221a64fd4,
+0x267bb17bba0da1b457e2fc71493f7d7b9da4ef5d13a62e525defa3d080b766bf,
+0x2e6530de833c3b1d1f5bda0c6f6a244ad8288750865136dc22bb752c8e044039,
+0x1f0b90c52358a8a14da112639c7d2ea2ff1df537b41227f4d3c9ebf7014c75e6,
+0xd9acd7178242914b81219b9a60ef7a0d6dd0fb571609e4335f8d419ff982d12
+],
+[
+0xe6cd10883e1e11c6c191d36329f30eb0045af06c2d86d0c439f5c1f4fef54b,
+0x2bbfad45e5a92d2fccecc514648ba944d35abca3f6570958eda96ab2e03d8095,
+0x1f8bbb7ab0780d5bf4070ddbd1b99eecde357757f3773ce6a8a33cb6d3d6060a,
+0x2578863a750b236e5975de83fceb91727b4f588c453a94e40327a18394e835ea,
+0x28284f2eb4ef38ef729f8637df230532e3a410186dbbe5ae5497c69a7cafac78,
+0x1c535fdc7111ed734def9074724899bea8525c2571335159af33af57310a8db4,
+0x29037a8126d3d81fcaadaff1995a15f9e5113b205c2f7c2d0bc0361f06a9678d,
+0x1cc53180a2b9cfb4978339d086ed54c748a5f77190e30dc2879a76a107553e6,
+0x2fd6d01024cdac4f279edd9fb5219b414815163b384f502b615537e03cff2b25,
+0x205885190c6d00c1420074e1a4a3163c382f7193754fa5f87ddb98a393d032f0,
+0x23cf89940b6418fdbed6f84bbfe0c5f850a9ba88c41e998554a4a4123d0ae5e9,
+0x968d36ff2a38e6aeca306fe28458719e69ba1b0fc76bb561fed0f82255cba8,
+0x2c9814c96a72fb32442dbda9249a412f98a23304a86ba9848567c5b0754554d,
+0xc11ab9629bc935469b9fdb33f48f22db895f5dd5e182575b2cbbb221105fc69,
+0x2b98eb64b8642bf4f5291ffce416102088b471aac3d2f80da585b5fe1f245886,
+0x2ba9f7efe0d61c8460085cdca6c1bb78aa7bc086533f20f301e010d5099ee790
+],
+[
+0x425a9641fb01558bc7170a2ffc24eb6a514198b296a1629cc284d983bca8757,
+0xd964da26287f09bc190e8235411bb9bc9068003fa6d6ee03229dde65db07fcf,
+0x289c0cb7f84d62638c2a2f37f10f30a58d8bd8b4c5bd8f5a3ca448e9c668f615,
+0x6622bf28a5fcb361e0b7bdfd7fa08717b51640d05d1f6f6ba94b50d26ddcab6,
+0x2aca8f7acb59233bc4d4df65b9c6f30479e9a72f5e6821860b39ba9dc4d03f82,
+0x1330fe288bcb4ad27de36ef48f063baa8ab30be65940592fd97623c7faed4e50,
+0x9efcc692545703bcbeb641ece624880f73a10c0d2c2e6132f9624eb5f41b1b6,
+0x2ae8d813634a87b031bb08573bdf237ab3701215b77ee9a4e6a2c01c1c1d4ffc,
+0xc2b9bb36e8ab693866b2885bd4482ed5c89f069b3e6445655d70f4d6687f8c0,
+0x1a606372725698e7d7f3a7280617fd86de9acaf98bbd8971d8ee53932c2eb6a3,
+0xa6632613bfca8afc8939b33e4912ddf18b034be621106ad695ebd5065afe00c,
+0x2479769cd60838cc140a649e8937be28ac92c71980f149caaaf0100d1f102374,
+0x1f925ba0001429fe493f48ea404a8ed283ab2cc2f3275ecfe320afe90426f462,
+0x1231fe074b771ac643d6e188f5732c209c71b768739b22447e6b5dcf499b4887,
+0xeda204f434a347cbc55ef698aefb23df064c57fcd4cd4cdd810e05ece651535,
+0x33bf863141b2b9aea2e59cf6c4faf11466700aa5c383af451d403c9c53160bd
+],
+[
+0x397a7d7434b0aa941348de45aec442cd5cad2c398884950e8233c58dd50335,
+0x1495e990865f559df4c7bd6f21272b8106e2c91cbb1a9e2089922c62b2a76ca7,
+0x125496878120d9ff89d702f58154ba82158e818db90e3d12d6a08c5543536368,
+0xf8ba5444de18d199aabbc5442c1d7c01cafafc79fe095da31928d776bf984,
+0x1eeaa31dabd6b6a9efa74e4315917d902b02760a04b04eedb57e261fa2c6632a,
+0x3776a7d69106118a4d22f86060ea7db0c9c8f3ce3ccd6c88ada43ee175cc811,
+0xcef77234c42547957e950e45ad3b723735c011ef47ceee8ba422bd16759be2,
+0x1cebeac557d2337e4687501f9f71fad7ecb14ad09550b52417ac33c2e8bca21,
+0x6521b700ca47f222ea2e280f3193df67e1a5966b8cebffb01890aa3a87bb328,
+0x100a85e6da4a0b92a81f1512710c889a29c8ed3e0695bc285a71ca5617705fbf,
+0x1a6288255e7a54d4397ca40b3be72c0469bc489e66f916c1a90476816a2f791c,
+0x33125b9cf766513a8e82a0d04374ff181bfa818f67ac1c7dd4298cf32b85e76,
+0xf7e82720135b35277fc54ebdd88a026af545b745fc20449b7068c6865eac1fd,
+0xa9f28e621172d911bffad3b5ea4b73a49a959de5c86e8ac52745d558a6f588,
+0x18a93b5dbdde2e99c234253d4a49348312e58f033e87d4446945727da833c54,
+0x2237324de68d18d407db3fce2a401e8af47ea8c5bc09d862d12b8dbfd3af5f3b
+],
+[
+0x1d66f208fc04411a1385c22e203dc08f0bac2f7cd9dfaccdec20d3b93252ad04,
+0x1014b540da45955bbe759dfc9ec4bdf32a99d56cd2742d269ff8691d915cf247,
+0x1720174606224668a7067c3e8c53b1ee68349144af6d6972d38c90bfa6bca639,
+0x6693893b45a40bc7366925fe7978bb80fbd5b9a3ea27c9dcb456b2b04670c4f,
+0x249c8751e7443e96c6e3b6b78d7f288e8a00c05f12597c984f8f0eb3f9c0d4f6,
+0x19afe6d81031fe1cbdff2b24eb7d691a50bd6bd8da98ef658d75171480cd664c,
+0x2034957e3fc373e94d77e0a050a8a84ba49095ffc6eb3a7776dd86940d90f01d,
+0x1d65f2f3574c1fe006df2d50fed257bb935f902970c7aae131a41f2de4b48bb7,
+0x1563bb61629e83922438cf0723716cd4daed36ae948e74c5c85dbb7e9893d645,
+0x2f10b78f744104a54a8149200cae59e443e74edab1cc3cbc2d8c170ccf2f7889,
+0x7396d51d19d94cb34b304ac606b54399e89273abb22ff7bb6b433e472ce1e8e,
+0x1cbb8fa4be4e9fdf0ec9ea67df8df2c1b796291e75db4f427c843216fe48834a,
+0x14e3a6920a412da81d917e7b9d98bba849cc165e406fb3c43ac421f9ade0c228,
+0x2a8e486afaa01aa8eeda571541d2199b55c8f5f730ca5c3879f246c227809c9c,
+0x7abc38167a01b6bc5831587de4d790de43e68e6ca9eabcb64b8af6895ad968,
+0x1e825483a9f85081590c0ba40059fea7861719e2b7da11323437313b77b6a8d
+],
+[
+0xec1ed3ae3beac4ddd1fdb17b9c7c648e7ec81885a07a5bcbd967e6a3676f356,
+0x1d8385e9787d1456bda399aa4d7f5c643cfaf25d6ed60e1be9ae8b98fbede91d,
+0x2f574b85296045a2b1328f482a3ec674793ea300e0817720e6912d467df067a5,
+0x291fb174e5ee77c060615a7f5a737a57d56e2060844aedd0aa86329b9b361496,
+0x2362c38ea538ee898a12c6458c399d2870bdd8826307d56f03bb28e0e30d09f,
+0x231713410ae9a8da08284c29b8b975410dab6f84f56475da37711345e68d5e2d,
+0x2ef69fc1a737db3abc895f656811e59e7d873355b2e1342aa5134d8bf702ac90,
+0xefb60fb18584fc86d88ee569da71046f765526b11f6c20099a6dcdfeebc4f70,
+0xb044ec6d148637a47f917944f81e9c8b83b0c0c5ca1bd3462a4e0daa7703dac,
+0x202678e431648172713afaabe2c8ea148061205c639f639b5e45d498be1550d7,
+0x2a1e1954e5b010440c1679719e5a0db27c0aa7957b755ecf2c9b3571a8aa0a0d,
+0x154d9e7b0dc8fa67c82016fc687836f61284431fc9d681405edfb38ccf28a6fc,
+0x2a704d1d93253cb1096070fbf26d4df2baf4d92057d87596cadd063176267917,
+0x2a24d4dfd6e9d6435e4ca1994ca11ad7adba2924b6ab7cf7c6a9ef5e7ef9ae21,
+0x1688b9a9cbc3a63df3a2a35c6923aa0949816cb57fefa6e95d7627b7663a6317,
+0x1d1caa8449da721f7c949ccdc38ec8c6134d97d7bbcdf58fa3c471c51a672ac
+],
+[
+0xb3e601e36a5d82e0214362c8419474dc1cc2c0ed8126534d69a3f790b27c603,
+0xe6b936ecb8a59274624533d03746cd5d266e6c5490d3c95ada22f4a22e80e32,
+0xd56cdd730e1401d9d7f93da88d6f3bfb8eb1fba440c552b078bb38a7cba55b2,
+0x12c0b93d829ff5b9641d9f6f2ddb4f92c7a7b147b794139bce98ad87d680d717,
+0x2de07475e19762eb5baccae3e88aa1493d35d276c4d05c670697b43824a41640,
+0x2ea094a22ee4755e5df8352b2ac671e231c24785db343b9145f9e44297b361ac,
+0x2ab4682e32feba55370b3a477ad83f30c88db387bb20c6a9b2e567f5d60a4a73,
+0x1a70ee4fd1e45c498e771e9d0210dd14145cc2740c3607e044e3c68b6a6017d4,
+0x20a815e19a6198e3a2f8a8bc2631c552521182f63e125477cf765a27707035a1,
+0x266fe05c631b74ae1cceb24143a96e0e9fff59304f04fedcf4db3da13508578,
+0x190dd58a88fdd887a0ca830681aca5949ea89050fab84b66297d7d14dcb91a74,
+0x1ae686eecd7623655c55154aa8c5c82136eb56020fb8d1199aff5c8bc11eb0c0,
+0x20ad4678ee812d96e544ff8e5e65d4fb7bf15cc6a524e6f19de6af983c997b03,
+0x2caf670c84f98b68d05f4ee672a1388306376e7886e30bd2b163bfa7fc15b443,
+0x1a336a86dd0b3325933238a53bf68f21ff35e9569fef12cbb61d8ab9c1f50ae6,
+0xe5fc7c1d17854a0673479d4589da85e6e61f48cc950b3cc531564ce5fca874f
+],
+[
+0x163cb4e3a5ec92e57b25b095a3aaa8cfdc4ce59267718cc6090a07e14af10b0d,
+0x19853b1669534b82fee656f037c33af733bed785ab726b0825dee79b629b9706,
+0x1b164a2238c5e107696834ac58de1b21e49a366ff6307159dd461a3dd40c2f53,
+0x2923c2a5464dc991733e46124db74c405e32b3fd9dfb2acb7d889b19a340ce9c,
+0x2fa1a6b0c6b0e9d686ad60801c72955c1ac256d23c545152efa81dca6fe1480e,
+0x27cf8750197630022efad9203e63aea2f195315a1d065a36894a5bed32bc8941,
+0x23f9c83f88ce7c78d0c6cb8059fb86c2110c7c266778ba8169b665dafd9de184,
+0x1d3ce51d11885aacc9a7a3b9fd2813e7ed602b33d3339fbd91bb869c6881ad73,
+0x293f18aa77d8372bc9ca53668a9870de638a706734631c21edaddb20c4a6b85e,
+0x197b9d069564454b7f26166ee1614896f153ed11f6215f06951b834c4da38045,
+0x131c5cce643d2b8d9d294b32abf2c9010ec622bad6f1181e4dadba9545684bf3,
+0x2556b61b7729a527f2c01544abc585ad6da9c92b3df9121f37bb0fd0c03d2cd1,
+0x5a0d89380a2a2a14acb860c3bf32ab6b3c973d84b0d61a308ca73257c19cdb1,
+0x24785c81f63404b46126436afb27fd2340122e9a98a58c467ff14abb5a90241e,
+0x9fdc6f6ceaf2566ee3a618ac4d77e86327ef278b968013e33f0813190472b31,
+0x2afc8316618c153350f4ba229e3382245c1399b2ee4aca25580229fc237f94e
+],
+[
+0x2dca90f3e5a15b29895f48d7a1290d7a33646b89620dd0a8ccde3aa3a51d41cb,
+0x1ac11195f74d7fde657d093a313171f0bc3cfe2fb965e5c352900faac25305e5,
+0x28fae6efd55d9648b0d9dd3b8c6e928c11a5941dd6ec235a9014c6dd35ad315a,
+0x12e496bb2680b7d14ebabfb8797e9c6bbac68a40c8b8fd65b5dfb18e38c99680,
+0x190489ef4eb4182eca51332b895875d6ccb7dd060aa364c1d289e2e1a7741119,
+0x15776583d7d261c6e8b338c3b3fa4323abde66ed0f477d0355119c9ff5482eb8,
+0x1370c01789f712284290ef1cffc5d33288fb504c5763d2801852b960ab98afe0,
+0x786ebb71e920bd16e3ddfdeb748e040b7f1b1a0f04967f55210bae2f76bccf2,
+0x15d4d2c713cf58f480500c6e5916f52b6ea1ac070771b0c83a6fa17cf6c9b904,
+0xfab2ea8e500aed64630a51f8bf9ebf040073e23a3cf189638656d6dd1af86bb,
+0x1338a1a447a9df2fde50aa09745ed3bf09e32e4ff2caea1b3b736a666c715014,
+0x59df1b1e661d317d01a513fc7dfbbd80c9192d33adc60602b0b0b9d45e08535,
+0x2f840b4ac5c9227c0a648693878cf37e955a037877bd5e5ccbd8efcfa38466c5,
+0x844b5753fd61108fd7fb8a707e770af891ec99da9d5df68b013a3a87599ff7e,
+0x2049ee37129926ecd6ff3a08e0632a007ccaadafd0d402a409561a2ce095b52,
+0x1f6570fb39247442fc03a5139944567ea46f6f534a0214b611fd3b2d3b878369
+],
+[
+0x2c78ee5ea16d38f0beb9dc0733c4bb1893cb33ff671b737a1122d64f729cff22,
+0x350e8d2eed84802dfd14d7878b0b77cd9077778c41ff7733d2ce688961a4b30,
+0x2aee7c9d86aeb8744b9d3bd7cec5c292e1c65cb633de0afc101e9d6fd2a36d5,
+0x16ba6796332fb56050e3fc4111f320cc05255c292f34db71e816440fcc452baf,
+0x14ae46529aa1f2b79da80878382a86338323f6a293adbd91cd58270513f4b693,
+0xcf33eddfc73e29bbd785035283f6e805133bf1e34bb9e3cc2f915e06b272e27,
+0x28f704162c3bd521df847d4a8a4f75439e668ef7816a91103158619fd52e5ee,
+0x1c207d7a9081da93b7375312e4ea754523d9198c501f65638f5af885708d23ae,
+0x1cc29ba8eed43aa2f71831b62eca71c1a46ab68007777679aaa8d6121faa5b55,
+0xb39596ec65e453830650f8dd87d0fe8abc96cb59636252e27797920e06b6a2,
+0x162ceb46008b073da8c811a25a68b56da01182fb893ae1c6b03d310ac8944fb5,
+0x1f2526ae9adfccd223ab57e9de7e50f5d3ee83284a8d62a5e40148f4dceafab8,
+0x28ff311d4a44251feee051511cac4832e177edc8a03053e133d206e9f6704f9a,
+0x1c362078a104c738bf6c5fda0edf9ce2cac3b21eb2779e734d14d7276a8e5267,
+0x4458b88b13af0f9d45c2b43df72abe53d6e9b56fafb1d0c15cd45a13d33b05e,
+0x23897eb294a5fa4f300110fb96ec236f8c0e049f29da5078d1224337e256e703
+],
+[
+0x2af324ec4f9e7786dcf00439c75a294bff753e3292bbf62e66471fa730f19c79,
+0x11930ca8a8841441dd799a0e3e78e1a949f05bf99603b382ff771021770f92d3,
+0x1bd210b6e6c2074d94d9f310d6906e81890175e675cc8dd659c287438a08cc4a,
+0x14bb891ffdff2ba6b222332764a72059404e581f328265eafce4faee0637c6cf,
+0xfa8399ba775a9e98ea3fc29231e1ae7177dd8f63c616ed4f4819f0db982aae3,
+0x17749627adaf3ea1f31f149cb0fdb032b9c2f17c262aefa35ec1d516e577e6d3,
+0x17a14cbbc6c3e70e50145daab58ccda20416fa7a0b0564056e0366be14d9754a,
+0x1ff273747279cce54284fbfbb61bbd04f403afba107507f76812a645fa9fb774,
+0x20edba75b3695a0f934c68c90d4ef19ccf1d8b1e3042d32362b5238b10deb274,
+0x26852fe3fdad04b05eaab62ab7fe15fcfa55e0340534e28e2d8a3d8181b1c859,
+0xbb7167ac0c34acc1d3e0b83212f50e3360eb4e967004da532861a8bb527ab66,
+0x957401bb640d15d04d93e3ce3756b5f06f9869e51076b13d42a53be28a36b5a,
+0x4d4b72c6c7a5922a3c9ab0b0154d7b12c45e50f8a237a930802e4c64cc7163c,
+0x38fd3c972d8ed7705ffbf9d462381628ab654b76aedf4f4bb29a2fc6c922cbc,
+0x98ff2fb46bfa9b48439294ce85ad25768cde5510c85175e073f1414a65e4ea0,
+0xc872f10e24c0b992944862abd52152c0faa0aa508afb99a6e9a3d2d363a5c1e
+]
+],
+        [
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2fb280a1f23df0c4566f310cf31beafdc3e238a7d873fdc50655fe827868e909,
+            0x36f175c993f4e409a6275e71558b9e1a0fcd7e4183891a7471ea6f987d6d0f2,
+            0x3be177a0fe1bf76a94d443647e0f69c0a74cc5dc7af217762210b2855e849f1,
+            0xed6491c4fd0f129acabcf5a68f01ebd10df6211d4d1fcf54ed75bf6c7cbc146,
+            0x2158db47b374d9dd31d47c20844fa870005051c013941b2d710ee62e56c0e4ce,
+            0x637d7b15c4259de4866d36005fb17b866227447e5dce4c27794413980eaa09f,
+            0xb745dc1580e5e3d6319028050cb792ad8fcb5b1a156dfac6595edff287d4bd0,
+            0xdc8bdccc8f3ddabca39be41a609714af65f518ef34738fda76e2755e7378699,
+            0x1fdb7856e27d608c397fa9f7f6d2fdc4b31b17f45c8a347124c8c82ace7e1033,
+            0xafff33732a140f6759bfd5b2949356a349c26c64b5bb018665e54acb329d3ec,
+            0x1b1d97c16995fec9aee31a16facade0e2cca653efebee3d5ea70c0f7b39c1383,
+            0x29ea18e6e4c75a1c3694bdbdb3fd274c37f51e2917f9e0b01d81870ef9235387,
+            0x15d5f5aaf91baaebd34d07b9634610b85966c008feec7843fab7e50b0616427f,
+            0xbd8e0c3a167d9eb943bf19f18d765230fd7d224df0645851e669591df01239f,
+            0x129293724e2d76cbaccac841326365a0b92bfc00437147de6390d964cc0e055a,
+            0x2d70576548941c2fb6bed6c525db5d0c33ca6c86f81db33838548d672b7b2641,
+            0x2becbbc12e49825055888292d91ac7439a3cf337d5f9873c735d92e52a054434,
+            0xcefd0b81bfabcb9920230f3a729ae3303943d8e396c5c0e5ca01f4611f3f617,
+            0x6e47e966b1b597c61413dc4f996f1456719742257039015c9c1d0aa33c0b0ac,
+            0xbf90647c85cbc82b06e3a94198e44335720b8afbdff06112e2aca505a43c47d,
+            0x239bc57d7b109caefd8c614767a590a68f658c69cbec21fef283a50324179227,
+            0xa36ae4cb35b4f865d7225191366fe691dd65ad5f2966b74f2adc28d26d2d322,
+            0x11244585fece886e4685fc703c807ec8e0d591b575fcd089a969d684be4ce2b8,
+            0xcaa7779dc16bdbf99a3f45903ace5079185e317efd5733fc7f766ce57e29694,
+            0x26996b9d086885f9bd6908adb4aaf6deae8306e463250814dc66e00674193839,
+            0x135e66a0ee13b287e51f5f1e8f79d4fe7ca55d9135e8921272920ec732bcdc16,
+            0x233e95062085e2dec808029c59a0e8230077331e358613563788518a3972e5b1,
+            0x23ab13b15889f8bb381efebe71172f91a0ad65d9f05af6b59e00d0c99f8ae082,
+            0x1ede4de25a83103e2dea729f0c68a908589fe0e604c86f8d57e058fe11000742,
+            0x2b5b5bee788dcb23bd488533ccae1431e3f3504e3b89e6eeda4ae8b5bbeb4c78,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x257363f01fbb108ce6360b115eb038270946eb8c46b6ececd68596765ed894d3,
+            0xe06611bd4eee1605582fc2f0a195524e57a552ff9f2c76832189c382d763944,
+            0xab70fb6823f52c277b8dd4ff261d965a9427d34af4afbf19f3b24260c15f8e0,
+            0x179c941d644d804a3a4068884fd1c6d7a82d411d4698c91e1b242966d3bbdab5,
+            0x37f916e90d419042d297bdc952c7cd02746cbc188149a51a0987cfefe0dc13d,
+            0x43f3dc3d91b0abb531882dc015e1d9d05dd646d42dfd9f4c1493a085cc00a56,
+            0x143ad19c1249acbef488ea0a074f56afd3f5b89666235cbf8bb5e6fe44096642,
+            0x1b76610fc8cef2eb0f4fa76df7ce299237fe7b3a9d024b7d405ec095719c4279,
+            0x1a5148d68913df74c872a1ea5aa4b542b3ab1b9c0dda2ec220cf2bc36d69ad59,
+            0x13f11022ed02284972037000666e2d3edbeb9a5350c37fedc293be998eba32dc,
+            0x806f266e4c35c6f066925ff73d6abde5e46f5bc55b01015db95162159092a70,
+            0x2e14cdaace09d09b49d437ca48752123a6efe3c75660218f408878871d073f64,
+            0x1c4fa8d7c6c8eaf33116df7af0abe56945403e111f0ed36af029a17a88027839,
+            0x23436fd3d8d48c7de5ea32899d09e601877896e044051e59d481f26c6f44594,
+            0x437191fdcb2c0fccb9dd2b70155e1e3eb91a104b14235a84f9c7f715f666b10,
+            0x2f68a6ebb5daa3c1c0b1f8e1cc3ebbbb29dae51f21dcab1b8f24f30e52f6a1bb,
+            0x2d82def6705911bbfa278a38d385fe17c9810bcafd7126f48ffbbdd197e1fec5,
+            0x15fead0f7cceb9fa5a96b903121d234539c447f776bf13290f0d0fd9cd776a63,
+            0x12390ef95e294ede3c435f9f14ae4f121cdaaa6b5de4f3f79969a8f91fb37793,
+            0xa9f6f1757a4b1abc8e0a5b0fea83cd2b8e565105fc6d52e692dece89a6c11e6,
+            0x996db2a2060b0454ec8a132ee6d810df2df49031ce420e4e790c723f578bd49,
+            0x2670a74f37e6a32596938caea3cec3e05b337ced6c23d2bf2ec5987dfbcc6905,
+            0x28ae07ea7a529805d3aafe9f5a2ae662f908b17f864ab59b98452ef28e3fd44e,
+            0x24002c49771a2fcb63c046d1507b8b2259b4eff63a7be958329f6319fe8c787,
+            0x2703e03745ed8810cc93cca78ea613cf39f492180d6ac47300e4babd4f357dce,
+            0x22930293c333499085eae55a01cbf8c32b04d211a0709bd9b758f733e2ed7b7b,
+            0x2a0ac5d7f2daa3edadbdeaaa440967d97baec637cf48a67a36810430014a902b,
+            0x25fa48cb70003175db4b2241e6bbb08a9d30128c86f68bf6e79e9a3dd4f3f4ec,
+            0xbae040ff4b1f63b97474a971446b680c23ff4d55212a99d03d1e27278770016,
+            0x2fa5db728b6058cc42348c90267158f8e76ab99c646e66664dc2b93963218e16,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x114401a4ccc83c86ae0fa520a3ebe4478fa6d7c4c634b4a6503da334da8404de,
+            0x1ca6273af6d2e51a8b7c2ba869a1bf10de7a5b9786ad947a02c2b1b6ee821274,
+            0x2c7b4af671ec5fa12531b63b511782f1f46ee5428b9184d960caf0deb0e08d03,
+            0x1230182c434b2175e9362b023e55456bf97d514e5332e4753ffeda60f5d97b0b,
+            0x22e041c288ef26f1d07c86d6c24f48eb041d83a8260b6772892181e2120c91e1,
+            0x28acbc69fbf7a25ed38927ba63cde5a18284f26ad6581317782219221cc6bd8e,
+            0x2487337fffaa7fea6440fb59e8e888c1724bbd1f1118d32ada6a3651e46ef543,
+            0x61f4630cd8a70b5c6a1950def1f7eeda1d2cfd750eac8bcd21d0928d54503db,
+            0x3cfcdd58420e81bfedb04dfd4e5b57b03eb8afefb5963b81339d92445458b6,
+            0x1211f09c601c31128561f10ffdef73487c927091f10086ffa889eec1378757e2,
+            0xad6247ae3bacb716899003f881ae2cb44e40ff4863dc07a400bde10cabc91b,
+            0x161bcf48d7d37906ef29d522a6631e22e344ff951be2f5418c1f58ef81106949,
+            0x1615caafce9cf99656045f01b9050872d167219533072672a6261bdafc405e27,
+            0x1f1fd1b64c8024c19dc4c906e121bc5023c76b1c9610fecc02e009e384fde164,
+            0x1a343f06c742b6ea01dcca051e7f812097250e81efa506561817c2accde13fb2,
+            0x1aa5ad37af4cf033774e8cedb40c36cc1bf2fd2e73c135a2145897e255644ab8,
+            0xa8e74375e1ca92003153a84d2a88b38796905e42f05a2aeaa22b6174545679b,
+            0xddcb524f3d1e36d26523b37e7a7a565ca7aafbe8b9d7d21805d79b391345944,
+            0xc64669d92336353367ff746030b946691eed63a8710d15b44907913558ea892,
+            0x18663caed52af3125ff734ea821f2b1c0ff63e253eb8df61c23998b3852eeb2b,
+            0x8aa2a6dc1acace95ae99cfae9f48a5edb8d91e6be62ef97a8e48f7bf9d22cc3,
+            0x1d810d45be42ede9157e37dd929a6b74d0ace0e72b96d6f1e048532027613e9d,
+            0x2cc11816c46e64c6e7135d72c00a7dce65a7614cbc164dfca2be624668a51767,
+            0x6bcac935d9e6233eee8555d901d6cb0b5a18e0baeb0774c42bb2c2216a8d3d7,
+            0x81f422bb15ef7e9b57b79cad63226fc53cb080e6d412e790b5051b5adb01208,
+            0x17233f2458d93db35c213a72c969a94aaef62fd6a76435c683129a9795177bfe,
+            0x223c464793888525ecf5d3c873cdb3a6bd67587499a00b440d924c2fdc45f640,
+            0x12ff515ef3e169b038bbacf953537c2b28dbd1b5ba3fc7a26900188aef36e2e7,
+            0x55e0568770fbc4c9b3d698e621b1980736ec4259f0b09d9f1e820f7da4174b3,
+            0x185b90addcc3b674ecbd0987f9480b74625fd07c91bdcbf048a647d561c756cc,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0xa4ab29f428a1b4040f5510e8b4f10494ebdbf12885955ce937a17360b4b295e,
+            0x2a64788ea96296d7253a3a9e357715234f9318c08376c15de69487fbf9b0996d,
+            0x2385278678bf43e06271b87c3f984f1b425b166ba786b2e1e723739a6752f6c9,
+            0xf8d204bcf2efaa0866818f1c3986627ff998995317a960b56d8aa3f5c10fbfd,
+            0x2d07b5bc553344a4887dc8f3db5858e5defda22caa9a6ccbe23e3332ba18aadd,
+            0x1e1a6765877cb93580433e025985f80aa19c9089c17138480426bcae49aa1c7d,
+            0x15f1a60617344d29b6da60f57ced335da1dadb402ae9a56ebad3c0aab3b69e73,
+            0x6be01da4de9af6b0d2937bcb65697fdc23e8bdbf5343938315ef4dbf045d914,
+            0x204479ba44f6c6079df123ba1a54e248db6d4d0480393913790ff1f10b9ead7e,
+            0x1967ca2365849a5ba9abe3419797885af9736c42439f1481862a00cb4c83b24b,
+            0x37b78ab4c6c1cbe83f197633c4c83e22fd38219786d9c5744ed4224eabba54b,
+            0x21202d9fece3b3517c2d5e79e8a5b47824fe47658704341ba7bfda3a3414fc5a,
+            0x18bd7e46303c3c2a31e68492472578708a68d1d6036b961650057b7d1ce55eb9,
+            0xc5f32f34e129de8d01bf9010b16047bb2c2128ee021fce0ae2c03a2f0b20c55,
+            0x1ea1c77b9ce7d24a4f32fff661e414f0793d9c4477fcc5a577b0e5145c80671f,
+            0x2abb7ec37e2a52a09fa5ba144d29b8fea69efa205b4690330013d2da27fab6fb,
+            0x196d47ff262f5a90329962beb3c403490547808ffe4fe96c699195d9ee5a2326,
+            0x2da5dc389b073e52f92970aaef0d061beba25bbe8520b781911858598682f57e,
+            0x2cce11343f974369dd5fdeb7a8a796d3a83feedcfa0a78db72dbb789bbe1d847,
+            0x131262e283cf0b05fef60886f32f084a47755fcb4cb7ccc4c689e4e7f0437b75,
+            0xae1188d015d3604fb38931c02d790fca244b8b284d547b62fb03f98ac887716,
+            0x7579345afb1c183eb92a630bb7d061969cdc515414bf9399797d7413f8b904d,
+            0x2429aebe4a674a80f0a8ae9b38a3f253e45b897ae71a7b5d0afe4fd77d5d8769,
+            0x1382b92a6c573bb195a953dc0c697bbbf30dcf6806f6ab2a5f7b500a80052de9,
+            0x1d182578837b58b32dd31a315254bb0a49b04b3d5ea49d582f6426637be87413,
+            0x2d9888fc8880aa1e4b265cf60218727c3556ac8d31b7a3dc6a1dd5d51b902207,
+            0x28fab72bbb99f1a6eaf2040a74ff55e87c5a48c2d392a7752c76fd2fb33e3390,
+            0x2678f1ceacfa8e3b48b5eae7f060021a4f58cef56b12d52b9f06a09e4eda55af,
+            0x1f61d359d1619ec4ff2f1eafe57827c9316e10754718b9f51b36c71979cc448f,
+            0x1a1d9f64b52be377e509d5a57f004bcb6db0edc85aed26f51581d912da30e95b,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x23884cfd0f045915025a44e9bdb14491e626edf74afffee874c3e4d125a4a177,
+            0x285d07475f22446af1515c134b10ef890bdd927d0328230d6374ceae21e5f169,
+            0x353d664345c344fa26ce90da4f498fe33a62e8c46e7e05b47ce11b669bcccd4,
+            0xa5f24df76f39b004c073e1cfcab0880702b9e84837cbcb21bd002e2449ebff0,
+            0x12dc4fd8b792019288d665292050cf58bbb2c55be723d6678ddcbcf55cdf5c29,
+            0x193f04538e44b693b5f03c328610092e8b253895beca308625b8bba24229e6bb,
+            0xd40fe93ed90a0196dc17eb24b05dbfd08a2d9b85103dd44d887b78bbf08251e,
+            0x1a1e1f731268025c10698efff9a1898281733296a02ec2e4286c0aa9d766250d,
+            0x27e53cee0536c3e96bd4b78d76b1b99d611466b687c60dc5242304cf2c7f04aa,
+            0x1e131e762835f631765d6a0548f8b99786b3379a5423669f348e63c1a3cd4057,
+            0x18377b53a6b68420631a509767ab747af54ff52fc6a300f6759e89d0fa81f62d,
+            0x2b52851f9a2c117d24b7b3ef861d3d98145e18be0ab17461bef9170dd124f2a5,
+            0x203131dfe05f4f3859a2962ce2736f5f665679cd543440e5bbdf8c9e468f8f1a,
+            0x11ba7216dd386406bd1ee9de577c3015b3b568f612b79d2b901955439b5f47b4,
+            0x6cff68dad82139580b6ee40346acb41a1b88e34344b1ee124cd845ba4d8db12,
+            0x176b605012f38593df0d0e12fdaba43a024327554f045875a394ab6d66596693,
+            0x2bb40088a1add8496b2a0d0774c06d99000d9f7f5e78edefd8267bdc2602823c,
+            0x6ab5edcd1a597a55efb6f5f3028b5d46dd1838af7e0a7618fabd206ae02db19,
+            0x1ef4d4d25e3f6731401c06e2327e1dcdd251e5d868a49615d7c9e671b74e52ba,
+            0x1132917918891833659ae5aa5d4608e9ee52f8bb8c6a15af2bb6c5b2538ee108,
+            0x3ea727908383eb9c0c5fd4c8f4477c7d7cb3887c6b7408097c2a099ccdb436,
+            0x1c671af55a23385b16b41f93bc5c9df9244a2b2917fa26f989936d9e10f58965,
+            0x2877b09253cd0233d358dd5c03a15ebd382a94f65bb32f81a409c3209c83dd16,
+            0x120ac765f71527adaadbb9e91c78bfbd17f30b1c5824bbbb6eb82d2745bd3352,
+            0x1c2a7fe3bb93bafb54e3a35f4fccd2685dc5a59ff6b9e76538f37b7c79110633,
+            0x245676b487e217c63beeb368b204d8fe8e5e051aa91efdbcf6854d9d5ee8aec4,
+            0x1a0f4f24f3fa75b07185d59f382ff63f277dd1af0a902f7107b63fc9f450d87e,
+            0x174bb5947efa62f904759a2e85cc92c84b797688ee8c2f05699d0305f6a68abc,
+            0x93051276353b63507c05bf904de6f8d971f7d386c1748053840b7b775beba02,
+            0x20110b96b513965874eec9b57166abe7a71dbac4300ded7aea9eb190ef9b082a,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x17a51da68d46000951b06fb3f9e3d5b83494d28feae75a0d77381129d1b5cc11,
+            0x19124aeaabecf4135010e1a965341e48ca4fdb7b0cd507710ce685bece85a51f,
+            0xd4eff1190530bdc2e0fad57504ad2d927a0d5d19c94424013818bbedac93ccd,
+            0xc4e91e3b7cef308d9d42940dbf9a496e5e23f954bbf9cd9f6a141bc043c89f1,
+            0x2a91fff770b866c8ca8c530d786a522131c1526c4694d8b7b7ad3ad8678c6140,
+            0x211b948fb5c8a9cc45f8dff7f19d5092c441a1749009ee7b0d26d02d15302df7,
+            0x1e30b1031a24069cc93961bcbe7ae460663d24ac25b376fa8d2a8cea3969e66a,
+            0x18b82e2032f53458de5b5b8f6c69d0f59033e0e843d3523a0e433aac75004ec6,
+            0x1dc22b5bfc2732c1f3481351752d7895f5594716a57b22de0953d8675f35784d,
+            0xbc687ef3b18a77ed8495a8838fa82e35a2be17ae2bba47a9f5abaa26021afd8,
+            0x2371c26d8f7425cee8f66acc9f647d889b78a20c02fef9bc8e65295536d55666,
+            0x1477473a9e49c36a60b0415dba5e832e23ba2575682cb706c5cef38c2ee8b9b3,
+            0x53e482959dcdb79f52e64a3bbe20793fad3af4f4d052c0cb9d36dfa396bf4f5,
+            0x1f1b58b95eaef51e442d66ed24a23e300b3df3032f45040577402279da01620,
+            0x141411af50e95784b5365ec3d4879e78d311c06d3b031a47b7b1989ff8e2a05c,
+            0x2252323b3ec06cc62710778370917d94635eadd0ab946d83c7211df2fd18b12b,
+            0x1f9f09cfcbdcebaea2b1053db41f39406c4bd7c08d69632e5fa88d11d8db2ff,
+            0x69d5da11e6652375d70f87ebbe9b7df0addda9634eae09990b68560ac4ed710,
+            0x1978e5d647456a8b3a66edba35753faa93e3f3af1c89f418aea0f68bb513a0c8,
+            0x25d9a4e603b812f39a20e6e5eb99c0ed2845d383b952b42e23d65fe68209f458,
+            0x234b43e3517f8573d5b4b6c905721747501928557ec4165d9513940880050221,
+            0x3e66cf2636881c8a51bbb3532f0ee3abf099d16c6e029eebc7ae903a9b74d74,
+            0x1e98f8fa7b0e98762453c23bac6735b00b4fadfe63c0448be0ce344456b7f189,
+            0x8aa709b54a8df091ca048763f4573cf9917aeac083ca1b7f7eb84c060d0e932,
+            0x52c7ca7fdca9ac2cd344a294d322f1d71d1384d5e0a6f44d0ac8b34e6aac4cd,
+            0x331b02bc917bfc6691d8d7f52eba08a5fc3f47d16f02e440644390c39ab7361,
+            0xd898949994a6f263a9f8225ca5d4a118b7955a4a79606262394ce69d7a7e127,
+            0x10b47b130c16007b5379d744a7bc19e45f6d92e271a299766420139f20a7766e,
+            0x1132f014fa7599d744c6d40d1be4ddd44e62b3fa4bdc439a48ca4c08caff36ee,
+            0x1c5e38ab4551aaa2ab2ab5b69f5d6478d668719523787df968bec6e67c349a0f,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x11c9a8d1a7cf032ef4eeb3976cb45ab2639e2328e018f2450eed36a42b51724a,
+            0xd68b0ef4859a99d9a3d358f48ec049222b4adc40f5211420ff9792d3380451c,
+            0xf7e3fbe842d222839a6a28926d2b7dbb20cc776f5cc35ebe6de1972a8061070,
+            0x20ee52f4c572121f278ca8f09daad2f1c0ef8541099378b0bae1913528b01102,
+            0x24177470839e90548fe652abf877b6e788dfa4e0f4364a20487089349d2b14fa,
+            0x1fa98b63c69a198ee335de75179b230861470a0f60459ed53930f592106154b0,
+            0x18fed7ca1d352fdd257bd8999e955d46f48c3fb2f67e9c8b29ca0fd6ed5cc4dc,
+            0x1e4afb9b1400def427a1a5c956e761be43bc3d15ef07098cb08bfa994e5c69b4,
+            0x2b8b851fafcc041cedfa64521f6fb53a58788b5b166da469192a1d5aaba1ab06,
+            0x91cf8ac82b6d84be9f81ac1351faa0de2226260a1019d1dfb24437ca34325de,
+            0x6f7d61897e3a765d4e4526de3cc13b4c657cc5ec81e08388c41d94a808a9a5c,
+            0x2862142916a2c23432ee3563951c646c4de7552008c928fa13ce3e3501ed8af,
+            0x2cc6cc5a7e65d688d27ffcf1c4749764e7294c23d0108a57b29af443bb93f5a1,
+            0x140d2a34847cb9f0776176010d8070cec8392f612f3573d63e58d69a4c9565bf,
+            0x19800afc9d05a5b0386e87a855acdcc743a1c80b0f71063d56d0f4d6eafed03a,
+            0x2691df476c22b56f9d6d0cfeb1b706d66a1e41e69de5f6da9f02b9dfd8954d35,
+            0xe3d1a370a2c113f55e8be6a59667f72e0bc9018c6c2b7dc154de2ada843cf99,
+            0x422041cdbb99e9110963285e90c233f1843361d8d36878b2b2425ecc9ad1468,
+            0x18b3970150586c60e36243d9f787e9cd234ae54249bd47d53d8350431027541d,
+            0x2608a620c9370842cc1e7eb75ced965212717b22032cff3a90f1916d5d6e4b47,
+            0x102e638d33d73cd137a4bc97b16ed6ea8ff2114ef025e123a47fae1209212fa7,
+            0x81127c379d08c86b6283e3ba2f7a163f156ff1efbe2d058b68ff1d8198115ea,
+            0x1003330e6c9bb087c4e374163f1d93b51ea2747126942a891b93247dc3b9dfe0,
+            0x26286df4b90a6d6a80afeb845b9b574c8e114dab2b23abd4d92c90d05611792f,
+            0x2fcbce3693a0f365c77f5da41f04606747334c0e21ceaf4719a9c6c55a6db034,
+            0xee49f7bf8d9a6b4657cca9a553b12ee1e0375a2251402b6233f14b3ae43c458,
+            0x1a9ca035a5bba9e01a8339c07711d9c5e79cae3441f272af3e6fd0fa56889e06,
+            0x1202f2ca7d4f98e448e3cc47113806ec2f94885d536976db84ac4f06b7df6567,
+            0x89a14bbb8f0965a914cbbf83049d95598ed83fb7aebbc75a4f681efce3130fd,
+            0x13488f3b0456524d4982305fef6e6c81f959a37da7bbafab57f87e8a2e3f264e,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x155c91db5f59fd8ea52fff20993ddc3285ecff97ce2ad697f4a078e8440361e2,
+            0x5c61ec06f5561c87256ec21c6aa92ab1d3dce01496072af5c5081aed70a073d,
+            0x9849dc13d2eca871c4dc1d117cb0d5eb5b1a98e63a1821f6e0895d0109138da,
+            0x133c60ae1597bcae3f030cf1a3ef515ef77f8dfc0fecfff084411ff40a6505ce,
+            0x120e93850c13de3d06be4ea933f3451cb3d4836d55f8b65b30e3814a1eac7cbd,
+            0xd29374214e1a4abeeb8d36880e6f43a2a899b3bcca7ffe0fc1482411439cf27,
+            0x1650118703315ae3ebf1b4f5e333373428251036a1245ace4134f4c9bd3f7a91,
+            0x1853287541cd687bc66770237fe3e86db9c98208e838ad1c9fbb3c2e9f0d2f5b,
+            0x845a0b9344d795ba81ca6dc433abb5b9d1e083d460254569573e8ee3e9da5ad,
+            0x1903d07b2722c0dc818dda893d74a9ee7fcb8b01d3b24ac9d7604c970f68e002,
+            0x2b153908b83d6a3fc4b9406f891c3d51ee429c8f6906c24326de4baa2c22d6d5,
+            0x1074ad520b1b0be2f4590ce97d9927f4ba582fdbda90f73810e0a75475fd0d47,
+            0x1d7a66fca345168c4cbb549ace2478d1e8f0a1906cdfc1c95d323f99d6602f2e,
+            0x7d8e73fcd6a35b2d8390e56d670b9ecda356fc1da46551b8b4e15380f8cac0f,
+            0x24398fe811ccf72bb1583121152844be014995a9c213ff371d0302d402a22ab,
+            0x303c8e1b06ec487e715699736dd043dd4a6308ea6264525634841f4fb530be1c,
+            0x15186cb1c51f7abd9485ea9ba77cf8fa72584dbc33f909e7e04b01ec550784e1,
+            0x1800e20927198f24e362f7719ecbedecbfd8bf90b0aa0f804cebd483ea950dee,
+            0x17b074100a4dda67b9e89789201ba089d0dc1553f4b75858f689d7f9f2608258,
+            0x12a869d6d8348519d11d32e678bacfd6fe20d7b02422a1e63b958256e786f4dc,
+            0xd400992babe16a1b5aab5e95bccb91660f22e401082eeec8a2a562cbb098832,
+            0x67fa6a735e49401ad6d0d4043563326f8e063be13b28875f6f4a9751bed2879,
+            0x8aa46ab3986198d493b9707ed84a61034da2a8bd1224c5ae8aaa3a839cdb114,
+            0x7d061661185186a26c40bc3d65c84064b6819dc305e3ea6df08716f415e6be6,
+            0x164b5a80cc2a390326f6062957d7d325ac244c8c497448f4b96fe6734dbe3058,
+            0xd267132ff50a0e61e859189065f6bcdafa349aac4881cfeb1b0b68ee179981,
+            0x29b34d0febeb62b856aaa548a5a9b7308936bd163a46f67f972d4cb32634b5f8,
+            0x1b1dfe465e4578869a7a113457037d7d3180b6f8be40346f061524e76f9c7812,
+            0x219d6d65c86a3850cf3648d981b51681ac8e1ac0a5d4d2646b780c9e46895f0d,
+            0x1709bed140c96224597918a6d6e056c2a6f80c4d27dbba0269f35966aaad986c,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1db013be405e1edce86acb997ef8ea68ad542ecb25ffbb8adecbb9e323e9dc4b,
+            0x4672cb42f866056fff733c2d9b23531608c1b541ada0026f292d08230520f43,
+            0x213116708c620427db2bbc1a422b8dbe43c50614ea1ef82ee32a92c71ba78715,
+            0x1810bf41c304da8f92060da2bd4632295b784150716ec8b59a3a663925fbb556,
+            0xe60fe1f6ac34ccee378a7743a96cdc77f27e36027f3ba4439f599547efff8e1,
+            0x150fe3d5f19845673753c10d21683c39d806ba8b4401785d8b993d5d1485370b,
+            0x106f91d87819b33c496345bfc0bdbaf0a4a6da037e2ee628a609716b120378cc,
+            0x27f058d01a289b1ab1bea5dd839fc0db887d68fdfc623085c8aaef5a6cc2a2da,
+            0xe0dc820be1b5a101b96f1536c465ce27a96436616a4fd1580c31e3f0be69d57,
+            0x1150f83988fd71cce9335017391d240512eaa73c15f11973c28c36eb4be580b6,
+            0x605b14fe858aca1b47a07bcafecb571d61c2a7d3f3559e78be31efa13632624,
+            0x18579a82949ea313f07863f545e5f5365a77926f972361cf7104f2fcac832318,
+            0x21b2b1c8062f7650217eb2d090922460361e6f0777c227cb685ea04e70393062,
+            0xf83178738a3442e7e4ce6bbdc1750b29b3fc752d8d529d8b28be179f2808b8f,
+            0x259a80dc2ea8a894232f5592feaa42db627973a90f50443e08bf743273eac236,
+            0xaabc1bbb9251a3069e43205b96a072e8f69fb446dd7410e4819d6298e47cc95,
+            0x18f44db51f091bf261627ab6e0be73c16b257fc358b36508627779722f45ecae,
+            0x2cc4a9fe2f5afe3a0ce906c8339748dd29e2386e5ce4b5aeac22aeee17c3d79f,
+            0x2c254dd92d7f002da3661a83147bcb7ede550313124d99c6288cfa538db4d904,
+            0x2541852cd7c4fbea1361b129e8901ca32d9c4b20b7d51fa12c87a074a7fefe31,
+            0x8c2f801a82520a9a121ffca321896ec7ad60ddd9a50b945cf3f430a05263413,
+            0x25dfc7f152ac74084d93c2c517b91857c51a33f8cde248d393fa1c326916e93e,
+            0x29760a2e5d63406ff254da4bbc97152ac8a6a38ad087702e594955add5c50d46,
+            0x269b6bb00705c31e909147f919817dfc81d8b491b9a76f223e56f81e64a9527d,
+            0x1a02cef4a79e0643edd8bfcdf61a009605843c26ebedb1e9060473418f75f0b3,
+            0x12c0261d1e3b247b69e4582b3a80fd958762b0b3d3ba914a52c9e0be24918f0f,
+            0x263f9acdeb8b3ce3ac83bccb1918a5d5fc712680a72fd8cfaf5e1c6712674375,
+            0x207434df901289e8916ecdff56dee469a913970920c64804a7ed8a26f927f177,
+            0x3a1c03c9f1fa1b8391f32fcbaa1efc6ff4b1dee7f377c8dfa5135d38a9c3ad9,
+            0x1249e6129ef7507c99a866d902312d3876998ad9f62ac34454055d8ff1d352da,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x68d6807831b6e785e77a20b94dfbe5fc6c23484310d36a9fb74220671804ad4,
+            0x85b97abe28e068ee5ef7bb4ccd81fadecedd4818c5a6c9cf4f53dd4b44ecad,
+            0x2d2caa3b84f92053cc406a11ad2985c860c57a75ac356b95a86a83ca504bc4ee,
+            0x230561c2208c63a3d10b95a64358c5bc4d68d01ae4447b5c6993c8f6132031e8,
+            0x151f5672052113e6f14ddd32c28c71436daaadc71d57d830ca551e770c5035a7,
+            0x2733c9d71eb1f1ce45ffba8efb3de22aef7b84fea901bebe793ffcc3ee20cc1d,
+            0x122c0d0a07c233c687e8156be1567492ad00e6c48ff395d98541df9044d26051,
+            0x2844674637b223f5779e688bb8adf49dcbcd9256d5c314a512707b24b7ffcd53,
+            0x13a9188517254bca715d460f9c6f183ad8bdb5fca7770277117e9c477d0d3de6,
+            0x1ddd8eec094dfacfe2f915e62129fcba3601daf332dc8e248b4d423586ebcd69,
+            0x15f2e0c38ac84bf50c136e68f78f913f74562eae48a2c20820841a471208d051,
+            0x1dd71e73cc0baf4aca734d106ac1a48cf85f182373d81a854575e65ced0dc73e,
+            0xd3682c39a2dc0c0808498cee222076cfc00f11da2b929fa5e063ebfe307dac,
+            0x259708945a214cbceecfc4cffd2905b0628b3dd3fa652f3efe1c2af12e8732f2,
+            0x71baec7a429bd060593730c150ff1fdfa050aed0d708343259063796e831195,
+            0x26865eff75e2f6fdbc66213ee03b9455a109aae2e97cce07b9319bda64cfc6b6,
+            0x2864c12ac61c22d4f35fda4911370070e8b588a8ee4a82a89e15c0f1a0e2d7bf,
+            0x2758b8b601674ca5f526d246d221519ec40a0498db997b8aa855545b3659127a,
+            0x9002afa8899112493dca6ca6f5c6323db8f352008f7d18a048d265e8cfebef9,
+            0x173c758aea38f6a7812683a6fa4589e1b4a956e8974af260ddb057519e20f7bd,
+            0xefe6d624981ff5e0b45e575d0b648600bd184973ebf9d9f653d4a5a8ba17322,
+            0xd14a691145b25ca49c49605c64a9bad81678ea4a4e8b03fe39321c87f09e1a0,
+            0x247342aea19afa49a8dbb396dedaa253930af22b2d44fe96cefd464839482abf,
+            0x161febe2355426c2fe883e58dacff6e6cdc5ad5a65b28335275feba43df71f8c,
+            0x2dff5bf2cea76d0888dc40cdc73f00e3057e6ebf33793c8551e211aab41155b5,
+            0x1e6b6e09f8195c35767dd23c82ef5d8862ca77e999d65c69d8dc6860d494e81a,
+            0x3a8fc10bf4a3949e8469732b0148594cb3759123ce90ae3e692966e31040c61,
+            0xb185f3d4ca214b2e833301ff4e99b1f9ed7179b41191c9960797b39776df2bb,
+            0x1ac6b03901fdc40b1329bf3873ff9277c70fce9610151a0ef7921ed08567360c,
+            0x2beb77187ad776989902a94d06a98deefb1312d0558513c3dea6df48bf637ea7,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x149e18f1233f506859275485cf5fc93cebb94ca26cde5d980e6fa2c34a2f7fd6,
+            0x8a54ca25cc50b034f63d2e4d10b4c735aa759c422ebcac71f6f73c841976105,
+            0x1c1210f2ce34c2958d640d0a0aaf146eedfaaaef0d37c0a0caf671a8332d34c7,
+            0x17bfdbafe9e56498cb3d7b15d5cd41ab86ecd47895701cd2d6f26526aafc992a,
+            0xcd27920c0441d98a8992d408c219f85989ad1056f9692e3db6e9e4196bd6d10,
+            0x2dd7fb93c20805f91565bd67877e3a4ce43ec79dc435f8c7a85e82c6e5d16375,
+            0x5b1e6892ff615742f728d3c0cf830aaeedb93ad22d870691a96d951dba7ff3c,
+            0x831d0a313ccfd57b1cdc9f30e113c29aa35e574b1f55321ae09961b87b6d31e,
+            0x600e0c844243eadb86618043d2a618ea1f5ed77f1aca63f5e0ef19f6ae09a80,
+            0x5f0c79e16349cab481128d04a0cbc80b90c2bde9884a94c41ad1b0c4f868018,
+            0x2aa7de5705ea010daaab30b3b20cef0e74874384af31c04de33a4e1ced8e925f,
+            0x585493b750ddfe70e3eb6c9be7e72b18e65de229e357d4782b17c76deb2f566,
+            0x2848f8e38361bd5512352609d7806af1fbc6b1fc285b1c761a78baaa68ff5ef6,
+            0x2848a529d4f7cd4bf115528eb5e88284150af414523e25d1c012f38842d7a117,
+            0x30aed4fbdf98cf0212d56baed9bf952466b5347667153e56bae4b0650d8c708,
+            0x2350edbb556ef46cb8c21bd9841af642ff8b3a399569aa698ac63cb317a280de,
+            0x2ae5b47ed7dbdef58bfa65f573639845e0677877926e63c9929e47338e4cb926,
+            0x26e087a50e753431ab4f1ad7dd65cef00d9da6058601b8525a6c517e5259ce48,
+            0x159d260467ef69e897f646782f03c24d7b3e1dfb3aeb48c469603f51cea2ac01,
+            0x1e6059ee0ece798edbadc0f3c244b4bdcacb5181e9e470d0591fd8cc3c8798dd,
+            0x21d0c6c19bc6bdfe12717c533169baf1a57e61fb65b7cb76be2c1265c2c90eab,
+            0x96ff7a0c18ef35be9bbb3e0af410e1e4b3b902f38cb838150f8db8f034f96e0,
+            0x27d16991da4e246fd333112d5d5092cd3c888d8ea89eb4ab90f3335f1e11fb80,
+            0x8a1e7d8bc46b6d0b60d417e4894bdc5ec1b0da7d468cdf0f5b672544145480d,
+            0x1bbb994d74d79b698beffb2c1360ad7a5da1bc9ed065a38072537bdf998d4ac0,
+            0x6eaa75b2b8fb3757194332442bbe246a82300fe3d9aeb52548095747567da26,
+            0x35066f49fddbb428a2316e56cb7542e5ee63e2b84a38caa27f5c07e37f0d514,
+            0x1a8df2d50679834c0d1d9df72b6a33e1ff4d1a2a02659b635f3908b60411c8f,
+            0x1a69f234855f2099ce018e287b94696abdd504ffdb8695755a89aac7628ec4d7,
+            0x282c66cf66f278b3c8f0ed2e1936887b3f4a41968af38ba8435b4dacfe4fa1a1,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x85cd4807b25336e1ffefc9b4e5d618c7aba4c4c42e34b0ab5ec21f1e264e3da,
+            0x1df72bf6d33b417979d0abc3a5879c9c18059bc954a21b1753f44c98a86531c5,
+            0xed29b17ee6bc79f0d0da95407ff87f10b937c1b72f78ec36499601c536e027f,
+            0x2d8f67cb6abae1b1cfe21f91b55fdfe5e62fa2fe3c7c2d61254d840c2e22d0e8,
+            0xc4a844d33d7410ebfaa0be3c062b2876c22b8f4e6a4459a2942eca9902f72df,
+            0x1597f8a417fa1c847018051e70eedfbb5a6020525e003b207a241f2251c88188,
+            0x2dc8e5d6f14e2d43cf0b273522b35e2acc391774793f09014b27484e7b5fd137,
+            0x2d24d4794146908185f2354fd271608d3098e04ab4e5c6991653a1e31ef4cec9,
+            0x3343e0c40457a059a893250795a6c6ac5085fd7222dee07694f6c562d966312,
+            0xaf7db3d2850fc1037428a9b6913cb57ed2b17ce12775d10a2ea59921e9ba3c1,
+            0x2af76fe3326af61814f0596d1e9c7c981214efab22a78ac52e4c0d2ea5f3a559,
+            0x28c5facdf2832d22fc8c7caebe4d49c28a3eac34e1c06aab03da51f4c675498b,
+            0x67b910e6a3555653b7d646888b1620dab05b82afdb48c08b91422e1d089e617,
+            0x1a8198a68db555bb70cbf396e3acf926b66dd19e4ae5f42a62e1870e17943d9,
+            0xff3bc5a50528f42394cdb10000362e8b645cd1abca45814cae31c0c1736de96,
+            0x17832e2f6a6abcf1dcf5084dfe2cc5ae9a5a9d51f3d68e74743efab4826951eb,
+            0x707d9a111e2bf4971e1c28f0993d0700cc18742f7a217c4c1e2027c536d1d7d,
+            0xd4674bba848291e0bc0b2c36c3e3662f09831f32af732d2163f7873dbd61031,
+            0xb81f95f06e846785c898ae8f150761bdd156f063b744279ab030cee5e996788,
+            0x1a4724e7a15045d9cec46bc059a6e06c0abae7410697e867f97e073e7c059e8,
+            0x195b3b718107bb2d25b6546f49e1a497edc07a78a37c1de15b39b65ded042a6f,
+            0x117c5877ba019563589a57a738d554caa7c8c4e3342dba0f33ecbb81cf46f7f7,
+            0x29f739db99ca7b670979f4a8f3b852bab3b3a2fe0b98a4693c49484b2872ab71,
+            0x8127119728f625a3d35d9dddd7d5393a9086e4192d1b203efbfe9623bd38162,
+            0x143607b15463dc48fd12ddebae93c174396b76933c25dbf0b2433c789b211a30,
+            0x271c4725f01cd9767c7908c9217f0377f0da33e9bc492d187df0a215cfe3e886,
+            0x1053f9e74f700dd3161862102fcbe460e41f0a30adc546b62ffe3ecff5c142f0,
+            0x19f6aa64f3f2298722cd31bb3789c6b74f6d12f0dbd38e6ce1ff23d667a9122c,
+            0x1475d80686b48bab18eb1c32e800912b26b82ac0c4b9db036c513e0b30fa7e26,
+            0x29f8598b62b2e76dfc939ae61c5e7d0a159549f309ebfe2f3f097aee1c41ac2d,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x3010b8ed80e49e580f884d5e98414cb0619b5381eb0b72bea15185c32e7f2ea7,
+            0x18e9d0cd62c490a574aaba9b03b0a11dc0c11b4e632094c91ef72c14266a26d2,
+            0x2495c41de1debd0cb51280193a02d320e978099f54ec96a970341abe80d96a85,
+            0x92517d7731c97a877e552eebec76ee7400fd53d9be12d55ff9c6b170d68ec78,
+            0x643ce7cae313fccba434207e99649376ee888d3e309bc8e5ee454466274d62c,
+            0x2fa4485f1f97ad4c54fa908b0b25424bdc78255af9c77da99b95095619489583,
+            0x1b327749a75f8db71a4c33e8b99e2c01808b9090d049e1ab3c7abfdf5aa908c0,
+            0xa062169c4723669623251a50a4318e3b1381fb5c68556df9fe137474b624234,
+            0x16c33ff536f271145daec8f03d97b56d0f8cfeedb7cc329290fdc1bbfdc2c74d,
+            0x1280d067c4c7eced7dd8afac4e4cb3117be7901d7121ab53f3d43c4630f7b07b,
+            0x479c7cdfb220e4d8d7aca9b5fe7380b2cd447ebf3d8a204320bf81fca29eb19,
+            0x14e024fd7bab2d5031241686c4aae16ee300422df8b41919ccb73fb15ef06073,
+            0x1a80d20677cd1bda8c97762d6b9a006cad73d95e78afb3eaf3b7f3f112e39bc0,
+            0x1434e496824b8ea1ef9ea7f9e324c937492e33eb1af18459d89b29ba30549f84,
+            0x30485e0cc5588a2f49932117b4dde4c933621ab227abe326f429c8688134893,
+            0x100acb69114b53c1027ff56df9de3cfd561d7ccc81e881555696e0eddfb91f86,
+            0x17a974539888ada5b3ee0bc7eaab414895d2111c3a9d5c51784889ec6d41546,
+            0x194dde27e3f6373c944cf9079a28d68c7c73b7b60f5a1f5aeb7cbda3be4b9e85,
+            0x2b563b2786180439fbd6f3bc4ab5f3ad52f9f20d7aa31c40b0f7906f2b0418a0,
+            0x1abd1c97e97d7b5e6e9183f21305dfbc5855ed33636aa7a5cfc39e6329891c61,
+            0x2aebca431ac4c7b1d96c54432751d6d20134cc8429a51bbdbf10d6a5da4dbcf7,
+            0x1e93b372a671214f000aa220af2453bb8431f78694d76311abcdefde664b5bb0,
+            0x195338e68902e870547679d0f4a548d1bc91eb3e144b403b6d9c05ebf879e274,
+            0x2bb7a0b8bcf9f7540697e3bda7793d42e1ff60838f4b59f86a1ada0373bdb1ab,
+            0x11be3da5945ef7d140bf9e06b468ec44aac37eb293dddbf871f9292f6969567f,
+            0x481ae2c70bb522764ba40c7fe992913e56fc640bacb97794fee400861cd20c6,
+            0x919cadc23acaa8b5e19a54a996c64b59a9032c3ee6b6aacde02696ca462116b,
+            0x262de0b03fe8c9a6b04ace3660570271804c66ed640998d93362919e13dbe851,
+            0x2b3c90ac3a4edfbe09b333ff56cec2918a5ef924359ad5e225e08bcf17249df9,
+            0x1bbbe9819a05a6fdbb2827d1bac2c0c9736aa78280f8a81fc5969b576522014c,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x142ac1e836fc30278704b47fa49a84cdaec95cec40a60abfe73a30a10f2d72f3,
+            0x102f24ed9b7cc4a98957278905f772fe4149fb11befc34b05c7556a0ce1a9444,
+            0x59a56c684c34007e174577c81d669d1e0b9741d4d2b9d6077d8f8e8c1803df2,
+            0x1f22f8c87034418d3a79a9f5fbb2ee493c6851499ee2a84800b0e711ba76a918,
+            0x2614d18359d21d25731090abb6877365f49d58ea4e78a44a9e7adb4409a3aee3,
+            0xc414a0ecac4fa0637e9a4c9679085a7bb3b1358b396b2bce7eb9af4f0c337c3,
+            0x11930fb18ae2944cfc25c856cddcff702bbcc81a2c2a8a81ab68e2abd0d63d96,
+            0x2ae750321489ad6aab14cf7f3089bee01f50f6f1b3a1c046060804d204d6d4,
+            0x1532fb2f4f6a0dc23fab57fb2988ae3a61bd61eff35634f11687991465849525,
+            0x29b85c7d9d52c98eaccfab07af6c2aaac1dd55a087ca82cf636f2868dddf398b,
+            0xd50d222652f613b3cf0a36450c848108600b2c98b5d16e4b75b92a1fca288bd,
+            0x16bd29ece6542611c44d90e72ca96e7e81bf04cad858b88f65b3cf059348be75,
+            0x114e95888f1e263e9304531e672fa0533c59aad32e19a6c8e79a0be3daba9dc2,
+            0x7ed4c3caca93550d939fee72f322f5c45c45c3262481dc6d3fc21a39ba4a9c0,
+            0x2cf1d8e95a3b2cf8d4c1a0dd53adee6e975640bc902e05c357d43ce4070f6803,
+            0x3730a82d1114f03ea0f98add20cd73889491c2d362fcf76eaae54df206bb984,
+            0x2201627d02735d6def85f3d4409b5f675e4f5b670fc8fe334c2da72e9ebb74e9,
+            0x1de69df65e50bff05222e7d15bb7c25935a419532031efbea0a88d412658025c,
+            0x199e9757b4a447a466924aeee5f4e3c6c0f7c0f1545808377a8c0c436b374da9,
+            0x1cc1175e9e818a6ea2646c194f36bec3c37c63294b25baa9c9f48ea3c312d08d,
+            0x29d4552088b3053c16c885522c794ca388ba38c6b9eb2c55e011532a5f099fbc,
+            0x23d3b2dc1c7ff3d298997d064606aff743e7df6d7834c775aedbff099d458f78,
+            0x2388ad46e7bff8d8b43e0ef0fef084fa60cfe32993ea7183504ee738f6445cc0,
+            0x304e1e25593dbba07c1aa88ebb4a80684d9147c0b2f9247b49b5416f13fc3898,
+            0xd63f23dde7572c15586188a12a7a1c0b2bd109f6343294fc8f8bc1a778414d9,
+            0x19cf6ed79057a5fc4398ae7569c1b85519c97218ab842723d6212cfa9a0a2dbe,
+            0x986267435a69bf6ebcded378d2aa4a02ee3b7a8becaed9ca1e663600fc90c3f,
+            0x2c1575ee85e8cd3cfb63424d84ea5000786e5927433aa8c0b0211e5d87929c84,
+            0x300003af788c5a7576b764f88be5b3b1ac8cb0b9466090fb331569d4c6672c3b,
+            0x9edd428de05fa06b6410c57a5796fcd1ced4e3d20d42bbdc40b00ea28aab387,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1fcc025724948f53d0456e85fb56f3f81e0c8d4c2bced5efe3fa3af8ff77acc5,
+            0xc37f3e2d38cd3138ea93327d59b885873d41ef32b76409638af6455b5bfd932,
+            0x1cff93735f5e8bbdab731d6b1a60d946f268b082d912fed0b3ccb525d8cb6485,
+            0x115632e11c1704f965ea72407243707ec477c716cc429f1a7eb457f4337a5b01,
+            0x10d1bc0b019f8bc6d1d6f5b74ec4e472b855fb594585e4458e4c269750912717,
+            0x1bfa4745da3b7737814426f2b9dd6ae7ea034a00263dd091cdd7e118a44d38c7,
+            0x42f42c6cf5ed0f29ea6535ba858409145772498174886db7dd44bf9ac54d492,
+            0x27da68d3c98d92e4e93777c0bac6c7cf508e16e748fccd3c0b7b9fb54e605aa7,
+            0x1c0dd243e40090b31d093d35c80719303b7c49b088bdae82b248fc1dc37fa340,
+            0x1c3e2814b6eb0de8347ff2db9de7d3bce67b5a97585fc9933bf45f406edb6ff5,
+            0x4487bf6eb305b13eea5a82659858a64226428712237312fec1f6bd536d7c29,
+            0x1d4dcc7fc6d31a37c95bdb711a21fa490f4786064834c25d2e15aa82dcb762ca,
+            0x1ad252b23919c93380ebfd7fe5bcc221a3dbc4fa59e555b8d00bfad872c0c14,
+            0x1b9bb478853c46abecf434115d5730c6dc59d0c70ae580013d216f9ff259656a,
+            0xaa2849da666039877d1c63803500ddcb59258d9854bbd817c690b32643a696,
+            0x1a80c40302e2c50b3a9a9303f10ffce49d7bb5f7e5e19ddc85838f01df61cb28,
+            0xfa31af23f2b7a127dcc29d7a7896ac68e3ce309a70a86f7e680fae88ae11af1,
+            0x10b6199654c3e28a05df36e3ece1922c3ef4b7641b2fa8fc80a84e3e47d15fd3,
+            0x23002a3e74809dbd3de94260eccf0c50b15ad8f1d0b34296d06ae58e4a28b6f6,
+            0x149568dfaf3fac96b2638c3506a8d25609ca18e846ade9d19afe0c1e05c02c68,
+            0x27e032df87f6c1641dcbed6816aefdfda13783c301c6e0a90c31a98f4c0b9208,
+            0x18d75157ff16e95990d83ca5bc9366251a45c6f7935adcd1eed6c944dc87f5e,
+            0x3019b560b7eb66353bccfe2531464754259870d8246d7f35bbf10c6862bc73b7,
+            0xf4649bbb3013488fe2f61ad0d590433f5c7876a97cf9c83e821f078834c45b9,
+            0x2adab3e8388934d5ba7cf03b98c23defda5c4c153364936b136828d06db12d99,
+            0x149faae0107b1cac1e064cc54d1950602711aa7308dbdad89ec173da0595ff69,
+            0x18601dd152b8ac338eedb1278d537c16f70e1fccd0dd9f1b1ec673b4b86deb0d,
+            0x1d65cc6e7ccb7077ab51de992f4282456b818da240f46de874bdd4f6af329aba,
+            0xfdc0f5a32b65a84e134027c7353503c7e9ed38f49907e28a5969419e8438aa6,
+            0x65d3e753bec13cdbd2d4cb085fc25c8733f52b5372a4aede46eba19258c2a6d,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x180a916e94037f9ef13f05a1ea22bd41ca2d4b0f5eedad386a420ba6188d4882,
+            0xe6fc284e88c1403f06ab873ec9d803191655d35c290740cc682caca22fc13a0,
+            0x2753bb09a0c4a77b3af2a69333e51bb27703615d09d56f86423f85cfc8827faf,
+            0x272db4b6d71f80f52e4aa1061f6a24e98dc041a0bad07dc46aad59e67d96b010,
+            0x2378ce2c52074b027940891562743047b7b57ffc1f6654c2dcc23bedf1cb7608,
+            0x26e90f7cfd4093a277600d2c564b6cd8f4ba3899b646d7427ce907a96d25b4e3,
+            0x1cadb3908ee02353a3c45fbb57dbf6b392d5b1e59a13d58b57b7e0dc71c8d3be,
+            0x4d30d597f9dd6720e85eabb0a7808098f72d7beae23e0f5845283cb04334e2b,
+            0x193da68a7a699b7cf33c3ac942a960c154f447a016d957e241786253101b1c88,
+            0x26484e7897f16c30babb9a4eb821b94e204411ea78e3759bcb55f5f9e1f0ec02,
+            0x26a496b2c2b5ca5ba3dd8af6dc73aaa2d8bfd2f6715876fc5703ad68aae6a1ed,
+            0x385b7c09dd2a1a0c2595a940914780d61b49f081e20149c37d920a06dc8ae7c,
+            0x215ad8b91b54598e0ad7129f26f6eb4e52a27da738fa5ec2aaf3b471c2ef63b8,
+            0x25c029bc5468787fc40f8b968f9542a8cf39632ebdb520496cf9ade72f289656,
+            0x2a8bf45fd684c408e8832341397ec0589167c0d26cd7bb73227cc83273632bb6,
+            0x1621a4527a457936aa11821e0e183c83008e201ac922ef2491a720767d5ac282,
+            0x2146604597997341b5b512c2d30536fa961d09b5195f4ffe20efd22f4e4e1088,
+            0xf469417d25748e654a60d7a42da219c2c1ab164e0ecf4950a3c15aaec9d7b4b,
+            0x854569ac15311adb77dd8f2cee810aca29c09a47b6130b51c16b95178d76f2b,
+            0xe1696a6980d7dafa5bf5a2e10ae664e0c29153272874153cdbf2b303c6c8762,
+            0x3eec28f72099f4081b58deb0a95abcef4ca06afe5250a29f565b18fc8c0f3f2,
+            0xf0359dc677a2208a6b0c627912d16b736e91ab3fa83eb825a7b1ead71d000f1,
+            0x1eb49e2d0f17845b3e559dc12cc37d706bf9e048e6cb55a766ddad1100a07b7e,
+            0x2837d91b1501a5d4b95913f0d2c24966fef7f5c347aaa897c210ba15913def29,
+            0x2bf39f6cf1cef6ccfbbf97a4254acd478c897c8cd9614d3f8f9bbef4de646c94,
+            0x67912e7144d6029b3bc72d448dcfdbbfe0f7e9591293ab205b389d61eff77d,
+            0x191b47b69e8adfc904ff67ab36d19fbb1021c70898b9d657fb6a020bd6bfe684,
+            0x2fbeb5d54229ee582a6275b9977b77ccaa8ddc90265b7c5d59f8d19af69e46cd,
+            0x223504acf848236a0f7cd946c84289c4b4aba0e123b1db8e588fde7de06ef2f3,
+            0x11d8e8ef78b313743937e16395c1193c3e46d4b84c78189076d7941fbff04622,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x20d2e36125e681535785dc294c751d7557e31dc99c01cc45fb67d0e0f7031e5f,
+            0x2108085ae6246ae7dd76f7b3f3e0e731b7e4067602f6026c9cc61321806d4b6c,
+            0x19046a9fb27aa59fd7cbb075905c65e165d16248d948c1fab9ab472c57d8ad1a,
+            0x93a926faf68ed92e943507a893163b433857a1dc564f3f26c2f497164852c86,
+            0x2971a879c70793d54854f7ccdeba099226a7034fa5d9911dc81aee80cf49f279,
+            0xf5f5ba9b74aed76259a159321e26cbe1cd7e5849ae8562ff497c1af96285d1f,
+            0x20e7786221700e467df64d8d73e4c38753a44996aa732da38e621bd270a16e0e,
+            0x1f4fc008a41a25739bd41118baabcf2465fcb0e05605bb2193aaca167737e6b5,
+            0xc4a3ea3f708efc883a4bce4a0651d8517c70a1324de4935aa508c3c0ae24dca,
+            0x2e7610fe10352af47b616891090714c6802f3fc1fb9efb21248694ef6246ac07,
+            0x2eb8ad40c535f3b7b05c2fd963b8569e956259227ef21a24b7afe546effe4184,
+            0x154989e705cf9e62b9416e28834a4a7bce6b573a1235264ce89d4b046b6ebbe1,
+            0x184749a0e1bec0f94c8f3c5be0c76d87976952449c2bfe6304413dea612e2e1d,
+            0x24ad4bf83c2f3341dca0c72a3575fb12805568e92cae4472fe19fdff27f11d50,
+            0xe788a096b2d4192046ee742981fa38918777b65030ef53957571c3b5fb54a6d,
+            0x1e22b9d4c274fad52d4e5640b4acbff2c4810127a087c42f9be9ab58809d0d5c,
+            0xc8a3f2ee3246714404abf0521e74a63b83576496aaff85c2be74a7106846f12,
+            0x21adde943461bfcbd7eb10345a94033b25d4701157c694519fb2b4093b756709,
+            0x1ea99affaa689d6f19f8a6b82d4b81dfd1f17682831e0c00d7f2f8fd4938a37e,
+            0x16949199fe4a38750de73fa737a283a6a9ad40a27b0deab631f9295ade2423cc,
+            0x1e83bd581acd61c3b54afcb7a0a9a0138d9ac4c8739cdae89759da5150138fa,
+            0x42a61a84c944dcf754f5a97b1dc8c2ee7bdfbde233f789210f506eda56973b3,
+            0x2b93c28b157ce32bfa3b8d0f585061e75a03b79c366a75856cdb5ca2273e30bd,
+            0x1f54218a5daea6045fa60b06ab2520c52560282b1cc3ade14b664bfa49752bf5,
+            0xfbfdd369bdaf703669fa5e36a00aaf0b251a50912048adadc83aaf092e7f2de,
+            0x3633bd5a72a51fdeca62aefe9434104b52e152655cc42f06e70455cc15f8e2f,
+            0x2c0eb54b5f8cee8ba898a242dca64def09dda346d06323892957fa30b3c13af7,
+            0x165035983f563b1e3bcbe6c873fbf911d194fbe54243e039b3cf7b6f2afbd822,
+            0x2fd9820b3cbb131e3575de4ecece3471352587e10c96e72ad867bbc57f4c778b,
+            0x1204b919d86a12cea70e977706ab2be78259c6c608dca628eeeccec50b829342,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2f3cd03d82e80e8521a2366bf79e8d4ff5cfc3b4f46db99a4947e1ce4993b2b,
+            0x1cac3fdc9674c64c1614a5f48d65239daa601e26766fcfcf29cc385d6b3735dd,
+            0x65415e4dfe08e357c669d145be5fa6cc74b0126f099faf1d7e85fe9befd30d7,
+            0x28ef19ab4bb2626906730f539497dde648a1a967da5ea31969feb620d115c8b6,
+            0x3e88e9732a1a572e70d7cb6528857143fb51a949fe9e0fa0fa281b85b64b7d,
+            0x2486ab5c5311e4bdc65ab49fc60b172f851908d6753f6a9cc40f9b1535af072e,
+            0xc50469c6c6bd532c6f805d26a30a7e5d703e0537657518cda0e1c6044301ecb,
+            0x28f8be525277b0346bcd664cfb0a24a028f90b89ca402254b4f95833cb7ee870,
+            0xa68990da12f327a6d79b356c1d27642392b1b2cd9cc0b5d675d98436066e563,
+            0x2216dafb41776a1941b1f17a5dd8cca1cbe0f60f81ceaac465861b3dc2ebbe61,
+            0x20e6c97c374891d9328052361d932372efcb6c0c84628b6f3bfcd41c47d1521c,
+            0xa2565ccebd103dd144534c109f53c5de275ac56e9170ad9e3ed0b600aa51ea0,
+            0x1e79a45802b9e7592e60d7e4964e8920a458862cf40212db96483540a62acf3c,
+            0x29f54f1a96514b9b42ec9d74b5d715e61c265b129a7061bac126bfd50f696fce,
+            0x26bb61d61ff279242f1e5c7bccae627e1942ef8e103a915b64527fd0eb31a93c,
+            0x1ed4d606d825d86ddee16689f24ee5d9832a140f44b437258969f41d4c442c7a,
+            0x25131fe12798f1c8712f4eebbc7213e8f80b23e7d1bdebfd255c18793734f251,
+            0xd921ed8053ca270d60349d85ba38dfcd05bc96c05a68677185956707385d626,
+            0x25c7ab17f3ca72fef63042fcfbe1a3d5f1ef5d6e52da6d6dbb5aad46b1e17421,
+            0x1ee03839ca2483009bebf461b58d11cab852212642d38d1d33e48d9956fc48e1,
+            0x15a5a2eecd107f307d9565496448cfdbbd14ef42323275c0ab6597aaf1895475,
+            0x3fe00f465767add4808ec12aab687e16cfd702c1453267b7a2575c6cb557ba7,
+            0x1577821b07e4ba2ba893bf15ce062c0290a2c757ca7140f76c2f03b53d84edaf,
+            0xc00f28af5cdd011907df891669d0a43892fbfd24ae7d2abbb951b67334158e0,
+            0x11f2f4cde668fcb28b27153f0c0d85c86fdb4d0506d38fd5b76d33734868f4cc,
+            0xf15bcf82d1d583869605309b58d382a4750fa8221ebe8126ee522ae696abfa3,
+            0x2a87c83c58f55146158830df52d74403e32569179b409d8e97ca8a27c7446bcd,
+            0x1b655b2c43eaab5b8d104f472d8d84a836246faf3733debaf470b8b68b3c6078,
+            0x2b4c7891572319263680116a7a29e9ee3c39520dd8bbf33016e31b88444369da,
+            0xd57a4ba309a380ed8f907c68adee0e2ec336a33d67abfa6d33c0b34191d5c3f,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x24d7026b9df6dee3dfc366bf883301d2f5b0d769ffe6f625614731c81638a5f,
+            0x2ffa9260d3bc1a98adb5d9a4566a673a4ac815d921f66a78c7b6781f5a45bfed,
+            0x1c49dd9439a135892456c194c0b8b727f5f8dfb8b46332cff79b0e88af0897e,
+            0x20dc0d730c188f571f944cda64df0385f31ee47784649b38bc8b309fa731002f,
+            0x2a57e4f3c1d3410302207d53fc653b091b9215b9914f7e21143c5ec3d6080206,
+            0x18924496a011f1d0f7334c75efc82a756b5fa7b739ac213742e747f0bab85110,
+            0xb488da92db9fb460de597bdff5917bc07393e560b75df7412a23f86782008ac,
+            0x181707ed73abc47ed303001ae6fc388dfd30bcaa57b75d4667fbdedea39addf2,
+            0x2f3fc44c1a30bcc3419b88de657072843f3eb73178989484e010a66c74a4bf41,
+            0x19fc475149f3945f3fa3c88aa7bb166e056cb353a2bb28e98cb2c647aa72601b,
+            0x24e52c7ecdfe59ac393a7e3659fc038f582a29f0907d9130e1615a60e0d8ab0,
+            0x7be6f1cf7191d8cf88349cecd3f83df5493edce1708f65a305c3e749f06da66,
+            0x1f21a4d143a3496cd6736f6462d52ce24b40630d8dc8ccaee1f4fe83d2d8f8e5,
+            0x2d26efa6adf5af54f46c6835f4d6d13874b5f0f329b21a280b19399f855401ba,
+            0x189d55e9c0ea390f2e219fe4abde4c0ec6fafa1b68f5a029e4d2d5f2698c0572,
+            0xb825420f377252cd094db40d6f37806ac50896f01a6b563627b6fbf45bab59b,
+            0x1fba0c700b9f301109b83fad61964385ccde2cde69510b66334feb80d8dc5e13,
+            0xd4c0381cbbb23ff4199900fe9e98b0588229e95cdabde87734b7da4a96728b1,
+            0x76f5d00e73e4dfcf13f558ced96fd848d34ba5ec48bcc141228c22d18689433,
+            0x1dae42a7e24553210ec1d37a83e7e379f118af2833a638cfb2f637c2731b167a,
+            0xa7cc5bf24de2b7a6553cdb103f7b93a2ca50e7b8b2947563fb8eaf4c96ac22a,
+            0x2b027765c2982281f3f552c9fc239b96b0485bcd6b246567189760387d54a530,
+            0x1001976662b6ff1ec3f6510318e518e6dba3e69ad0635a41153e18435653e16e,
+            0x1f0a377816189522f724ea65404ef22847bac0fe95e2a6c666aab27cc4dce446,
+            0x1e7a94ac5ea43fd868784c2943205aa45994575b494a0c0c469f6be322077c78,
+            0x2791206766f62a06b3a0a0d71759944425e50d392218b999a86bbdd590184075,
+            0x11ad87aca6c25e04cb85eb1557e42ecf5851a9d24d20f9ed554ab9de9a561814,
+            0x7d76ff83e9aa3f5924ed313b0d183a5703f49eb17db9b5192bbc1e5935f41fb,
+            0x18eec21072c91937e53d9fd0e38007a1d8ecfef89ee0a848e5c42a73324c0897,
+            0xd7ea1d8a141670f5549461c8e6649e7c0dd2692756c6c25cc4525d437728ac9,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1d9e4a0d2a85dbe20e640964806fa1e5122e2821f6f46ebd2f614f52586612c5,
+            0x1b0529d2ba99f99c7e4958a1dd940160e451ad60a731f482e0eec4f26806ddb6,
+            0x2d78de90b2cb9901ccf75821db641e2619beca024e3356fcd20b0744773bec1f,
+            0xacb58a5c68bfa43b46977a9da02f76727974e24f13f1e6e7646fcc17235bd4,
+            0x133449d082b88b55b324ec110cdb4dab792843e2915a039b52f1399096abb13d,
+            0x1e40b0c57597c9efd9e21aa03b9e60edcfcc6313f2b325a1bb552a227f466cf3,
+            0x1dc4ed7c60899b410745ed729ea5a0066568b97dc007b6e7e804769dcd4d7d36,
+            0x1146cf1be34558e643e2850cbf90d1e25e3ee122f8292a12b8be4cbbc3b02f15,
+            0x24cc8fc4c875a88eca4864b038945f81381b829ae63156e314ab257829531a0f,
+            0x29f9668dddd6103594c092b4955bea42a78b762b014f853d12cc8a435deaf507,
+            0x423f8acfb6425857f07e45bab4474b2746c987eeb3cccec94f838fe25d524eb,
+            0x226d21a206f17d649306ea18a42e50d395d65136d082d91b09f226e63fb6540b,
+            0x50d8e0202485f6ed926f1036d1cfcdc3252b49bee257218aa058f8b7a22323,
+            0x2c6998a3a1d4988893eaba746cf07ec665089ee1498736a1580f2a7b3f840a5f,
+            0x8f07def8f9291f940b044443a720f15109a6602e54670e4ddec4f9bed773f4a,
+            0x15ad9c95848c4eee4228b1da242da640ecdbac2ca6f216306045c794e0cd41eb,
+            0xb6c94ad59e7195e47046f5e2dbdb395bc45ec654b60c49d8f39d9f8b895d1cc,
+            0x16915ac62623b19ce2101c05fe7276c373b329f20e1fe2b86f85e3bb18f2eedb,
+            0x241c174139afa0867f108586e337df3173bca36eb41a669da121cc21cc52e157,
+            0x2fbc48a493da3632871d2de5a8c22f22112afa88b1e71395eced016a149941d4,
+            0x1faedef5274cad9d8a55c7f763fa86841960a0746745c35950bedda80b6f4224,
+            0xe5ca90496f6ab2db273e54bdd99ae0d8bc1c6f0904de14932958f6c837c26f3,
+            0x1783f5edffc02d572faa7798200083b86b2b1ce2320dc7c8a0b1ebffdbc9d567,
+            0x1108f89b2285ad02285b4cea8eed22d0fab841f21df3d4ebfb398606a6ba3869,
+            0xaf33de737c3e1f423c51d89384242ea23bc564bf402282002cd30e3b163468b,
+            0xc5152ce065fcb30be4405cd338d85ca50d6a06e9344fcc7634d82e0e9759a74,
+            0x29b859531add0b7229247872552339e4ac2ae3d4b6ca8c705763cc8193103aa0,
+            0x87622acf27810277fe3cae6e270483d0d53158900fca1849650b0b5ecf0150c,
+            0x228844894f0ecc516411b0b864dba98a8c26ef510627f2de70e1d13bc30a6e1e,
+            0x196d69516c701eb00c670cb577336806429642be8b0e301fe0bb12293dbc2548,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1f70d88a852cd16c82f70637d9d973d59f7e77b8268aacd484e4e53500f72b24,
+            0x141cdcd52cc304528f7f93f23944dd16b3cca1a85b2a84670c504b9792beba19,
+            0xdb56745ee0dd133af6f37bff1f6dac061ec7e40069f9a811e7d034d7a30abff,
+            0x2569e01e00c725b48d55d26fd8c49785fc36248299eda8abd3b92b20b15020ba,
+            0x353c1598121daacd532f8b0ffd175318b309bde28b7ffada32bb73b784d95f2,
+            0x23dd1ba2b7ada18fb1337535b938fdd5318a1ad228cf00747d07efd159cc23cd,
+            0xa449d239c51400de8f275b00787790aa508e1e160bb66e87d0f4e32ac5a5bb5,
+            0x2bcc35ac47eaefc5ceae93b97187f199f4ea9776095a98efa5353da21540b9c9,
+            0x22e49a4378b6b69566529f55b874d2304e24cbaa5d790f76900ee2f8478e3c07,
+            0x66ad5b80133fd0a6391c05b7e20b13416e40c29a06469326768f24276fe1841,
+            0x3f2253229c2810aae5c8411d5130ab418bbe077b0f1122623065532a259b857,
+            0x2662e6c8a1134a005867e103901a5f6c67ac3737a6620accf8034cb83bdbd4a7,
+            0x20a86066eeceb6979baadde6a2359befde49875bab142e57e171b0870b292086,
+            0x13afbc5573e84312a43160ff4045190adc2a9db03980e7126381f4089e7c91f3,
+            0x7d6db6cddf350cc1d59a474d84fbaad04fa0f2bff915f077708df41d5b2a746,
+            0x268e93e46fd7f13e1a359ddf6ebb619a21c1068de6d899590aa1048b8829ddb2,
+            0xf889928b305b304fce28f103f2e4194f2b29cdff231b05efe561e1cff4e70b9,
+            0xc547ddbbf87c32bfe454d8e8b0ad4402c9b979caaceaebd9d59484d43cd37a9,
+            0x20da83182faac059a9d00b35dc345ef0115117fd24a15f6b91b501728497ae52,
+            0x1f6b643b60e535d0f2731a326273576ea723671e6c51e7b74281028ffb0462ef,
+            0x2d14d43ab2196fc70e26a6b9ef3f2e9d18f60026af5833359f2a4f694ff6f9cf,
+            0xe9b85853becdc05429b0a28a7e23baa59377d9037615ba740893eb971aadfa2,
+            0xa664658bab11525d7086e1206ae3c6abb9ec31e3461d6b0b2547a5d6c2ed54f,
+            0x2e0498e8539d8576df187245d0b1222f43cf4d3f8f0209afdcb2f68767633406,
+            0x16c87c7662e6724263b44dec088080333793ba2002fb9669eb63dc3b1189b6eb,
+            0x9c5eba75aefc04d0436380c834da36d20a67fd4e11653498b4ec21b30900f54,
+            0x1066b5230eec70bbde6c98ed4e48e392feb18967be71a12ac18e732a04ba9841,
+            0x2dd2a9adc1fd3ed04eb259dda630b58c0791d7ee79b85fc20ff8b37ca0dc0464,
+            0x2e94a96ea1f18a9d99bfffc3fe43f0f751bcd549d1e5992e366943a85ccf4af4,
+            0x8d72e9dff20d4f5c4543b725e43e01f1cbd2bd0d9ea8ce6b0c1a9b0b2e8499e,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x230050eb9901e2db2f16df59a7f5b8a1c441e5fe9cf3869a4ed073ba25f5d13c,
+            0x1c2f7f401da1ad989e6cbb5c81e3559a7930ceb1916691b9b2d702eccfa3f844,
+            0x9b391cab0c34b91b155483a41334a9ae97203942d7683850100acfa35c51600,
+            0x134816b73312aacf2f573418283f27bca58d4d23624890f7a3b9ca81c12e9718,
+            0x124b47f9ea87c94130ddcf77f87f4bc53ee087699d0e5f62663a63891c1675d1,
+            0xfe5a21251a65261e6cfc3709404711f727a610f94057c304e1ba67b2f006526,
+            0x28ab3b64f6f6f0ce2707fbe854295616d676dfb0d66177af6679b3ffa512e8d,
+            0x1870499da8f58f00acf6b1133119d757220bb54ecbd793f9ed42d65c31760fb9,
+            0x20db70356dd8d855ab92b28a96429acd5ca77cd9e5211aac448b991c1650893d,
+            0x1a1ff1c58192f748174691a98d8c5e733ed80ea5c2fed11b098fcb815b438516,
+            0x1ab2399c7e7ce1f5d3ef6c3cf33f39ba83f054bd73d8c5d7425666ef390e4f69,
+            0x1e4b5f8ea2fa22e568978cfd90777937efc072338e173f49cdf7761a9caa2b7a,
+            0x2305b22483287e9568160f0dfba637f50c63472dd89e56da0611b76cfe869104,
+            0x1efc74710147e4e7df6580d0ca588b6f338befeb4c6f8e8a0967cf5c9dc07399,
+            0x43c5e4ba3ceaec4190acd05a266e8d339681eaf1247af047fd0dce72fb37c0f,
+            0x2ad5f9fe59cb81bb3eb3ae9985a905adbf2fee8426fe0ce3c1b108209aea844f,
+            0x1f36ba0d22839b3176e55a9ed07dcbf0255e386bcea0a5be9823dbb3300ffc31,
+            0xa565b3ce5c2aa38618127678d8aec23595e365f5e51d97474b85b16a13362f7,
+            0x271dfc29144730cfa780f9accc99caaa7d14e05c42df401293d24759c12d8ed3,
+            0x1119a78dd0cbf88014b97e6e5758b64c8c133a5989b758af60df2ee0540348a,
+            0x157970a49dadaf8b39d46ada19fd06b34784a6f33b4d85547c2493f27f389e0b,
+            0x8697357bac4131984b26ea8e352a3c5e5c33ff22f09019646f43b5137d4df31,
+            0x29fecb3d70e1bd21087322a9d0f0db92c65f141f02b45936d9a5b8535f0b955e,
+            0x14297a9dad6ee3dd0ad87ee9c2dc63685caae7391012e267da21ade2aaa434b1,
+            0xc8f3a7ca1b4242199d6a0999b30cf3e61dfda56b98dca4c9bb199a070f9c782,
+            0x2105bc020b9bfa1a23b0b2edbdfd4ce7bdedcad57906d2f58053b8ab35f11b43,
+            0x2deb04f6f90c24a07d2f36e40d5bdef34639b092d395bb4a4fb483f84aecbcbf,
+            0x2964c5940985822a64ac1443efdc41cf37e87dbf858535bc7c87181768091c60,
+            0x20b68c1b5ede99ccfc7cd1231b13e90d5c9235c36f2f955dc6ff5352133ea9de,
+            0x30096e11896ed1672687beb4f6725b749550667e8da418713bea7db5f838efca,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x6e21228ed894978b90a5e0b691d8916aa63720a5c795b9a07381452e22382b9,
+            0xc9bcf80dc5fd89ebeb604437262768ae95fa7263924501540552e7a4f2414aa,
+            0x9a6be7304c6da043de4c03ad5c76101a8bc21f1aac8dc10a695c7c5fc2f9072,
+            0x1d78923d01c8ac2f59ddf5f046cb5bfc8bfd083ec61b1af080c79c2ddb27a832,
+            0x272ae649640a5da291be7915b01cba87251bc6272140ff420b36f27774594209,
+            0x4b1441ef166c520f9309f2f984011a00dfc71d6139603ee90496e59d715f775,
+            0xe8d1281ac76ae45f6f8116bf74982ba76109c42a2ea163357febe0422658c42,
+            0x1c5d4250da762fafbf313804257126fea15085a8ee9c103a9992950ab4af92e4,
+            0x13d55c7c0b5e9acfac2196201e8e4a1ca091505b12b70064dcef6f9d3b1e18b7,
+            0x3e8a03e1e25fed9131b3de7150da5ad0b53da4fdbea9729dbce40ce2535f0f8,
+            0x12623c6993f1c30108c7c79868c88e3943a64595eb7bfb5814791aaad5a09ee5,
+            0x1d38303334b2b1328d7453019c571fc28f1bc5e4e3c9450b491eb870d2c8fe89,
+            0x192231ebe3469dd102a003b41ea79237429cfc4ae4d7d7b5f49154aa70b918e0,
+            0x26587d8d2a074923798fa95b78d558a7357f48989f553ba03bbe800e4d4ee582,
+            0xdbec60681a76725fcf9b009006e1235f2ba2d3f09ec62b50011d19ed58019c6,
+            0xd79206c8a30d26abcfb375fb8c5a117f3cab1c9fda8ddee17c0991b11c63e13,
+            0xbc57e048679764b958ec54b82fa3bc4690e99591f42216447ec6ab89e5752ee,
+            0x19b73a25670160ec2631863fe8b93691a30a5e6cecff4e91e4b56dea4e9d75a8,
+            0xb02dfd4eb79d59d665794ed829d301ce08e2e5285bcf6f75a83f23815f8c5c4,
+            0x2e8eda48e5dfeb71e3302274f516a74131fd336a617126a1435cbed8ef6c9d90,
+            0x282c1f1d562f2927e694715b631a176baaf7621c44a55b90ad2f1af512f2b499,
+            0xe24552e72a2717b254956fce21df810fe3f1fb66ee0224be74aacac4f9bafee,
+            0x619d6bb9fad7fe7a063998dec9888beec2a1c2206bc97f6853c10e62ede2ecd,
+            0x10855580bfa613c21a4efdbb0f302d4d30a87a79a77cad82b37ac76abe5071ac,
+            0x12e7d2df332cc5d618a22900e665529f2c22bd2b2aa387d9cb30da9483f71155,
+            0x108fa054801185a6aff619e7ddd9dc8095884ddcf3c85b8c922aaade7fde8f66,
+            0x2f8cddd8f2c5d14ab14b93182197b8073b4e9c41c138b6764ae3569771e617e9,
+            0x1f4622a6c051e3696414b2024a39391743479968b4af8dcf07186d5c2ff07972,
+            0xc379c514adbbdcce4502cce0b85fd03fae98db9d8f36d3f3c56cb9942ab7877,
+            0x2b139708399f0c23fb51a4d24e7189fb1e619f5c7e03bcb8c8c32945d8e1930e,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1a67fa389778c9489c495deb248e754c3aaaaa63c5ba3c6e5cfd96be4f516c01,
+            0xa82b7efeec16e6c5aea5e99597b098504973c824edbd47a27cb33d65d7d09dd,
+            0x58b5d72d0fb9836dab90890a9a9db183959618b7de3d6b7b1fc07621644bc7a,
+            0x24411fc9331c4465de389c157199ca24f304424c0481d117e7b0ea23657af1bd,
+            0x210351a45fa4ef26b2837ad06b46629051a464602e52b36ef24fae76d1d6d34e,
+            0x1e05e49db66c3340e7db14921c0262a7346c687a8c26137437b510e30840eb59,
+            0x2e6833d4c2d492a05a1c2be458d06a65f6be428714d1d44c2dcea661571da703,
+            0x2747e0fb93ceedf91d0b703ccd88f179e8f10331090321660985bc63897241cd,
+            0x21373fe7342c29074309be92546ca3308e28215172d43899d8b34e336e0c2feb,
+            0x7aca07d0069a023d78e0a91f67dc748ab58990af12f54b14efbf83f6ea3f959,
+            0xd31908df90c1e9debc10476b0f17dabb3ae150d731c20a321f5ad6d28213be4,
+            0x28b90adb926df7693277ffd23ca737852a441517a8eca29eccd732b90dc0db56,
+            0x104147d1f610150c79c7bcf61ef1eb1d1d620af87c49516a193790dc5cb1cd77,
+            0x22704b0eea545e93d8567947f5736159b8c7559da9346851ef034943a9f64ea8,
+            0x12cf13867e1f4c665d952955497197af8211929750dd706a6a65dc654b99e8c,
+            0x2640c797ab409cc3b3ee21869418ced6c6aa32c8d96b9a3da85c99d8a2bc9501,
+            0x123e01798d0948749ff8ed24a732705e44162826c2c7d28025da133ec358b822,
+            0x22f5988c47c36f454fc5c2f982b854b4f4f64ac69db58a7820b10ed05a1c1b7b,
+            0xd71a0b148c465727aec89bdc6601b3bf341159e0eb92672fd2cd29670509550,
+            0x9c4450c0fab5b77b7feddc8f4c50031a113df973d3dbff0101564f4dda5eb64,
+            0x216909b9a7ec927ff4be81f45f34004b80de648dccb64e956e689755c1d08c9c,
+            0x1a676535420e170fdcc7784668b421502d69e5955992d13133f9f53829fbfc74,
+            0x2f45e803db63d86ba61b8ed3af38c48a00d0ce69c1507e85647022d6f39ee208,
+            0x3cf89993c4654efb4b1e804dc5abb423ff507f7abc65cc8d1a660671264a2a4,
+            0x2eb840961ae22d47e776bf9f78d8f09786652eb99782097010e10fcdfdeb9ee3,
+            0x13b3fcc3c156042dd30d9c935a465c52827dba78cde25cc87a436845a38cc1da,
+            0x2ac2949357bcdc53d8a234e1954aa94813a0825a9308ee3659d5d386b2f10e59,
+            0xe15460bf314de3c67d868973288483bc62926bcbd2e7042ea807888f7d9c19b,
+            0x11c767a3163182d5eeb2ae857a5b3010395f9640b440f75a9b859c30ab1800cc,
+            0xde4b8312d23ffa47cccedc65de54ccdf9596a2c26a8177b78890f9a0000f1ab,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x22a306748bbb7276a025b998d053c75dae5fa78e31d6457189abc977665065d7,
+            0x11e89b2f5a9f708391bf115992b295c5df50eb4793379139749cd3718dee76c3,
+            0x170d1801e156ba73911ab491c46bfed177c6cbec44bda6573298cfd6e925324e,
+            0x99425a344bd24801fd74847ee7524054b2c0be72a58c42928008d7163340593,
+            0xcb13076d62a1cceafc495baefa2cb03ddbf7bac1a8b24afbf0a84236a1fc1ed,
+            0x105cd167cbc2994138f2492a42e39c90c71fa1112160c2c3cb86f4a3dc6f36f5,
+            0x2fe235ad0ae252a09231abadf1884793e1479f8953587d08f0fd843c73cee60d,
+            0x27b02875c28bfc1217490eaea552ce39441e6348a660a8dff460564b37002abf,
+            0x1a48ee09ed16a03c4fe2c433bf85bdf4ae6ceaec8706c97bff764912bda1dcde,
+            0x175b14cc4245b469dbffa6970992a1bfd6c61deab13c5dab26b1481b9e616fbb,
+            0xd46b0974195aad4698bfd176ee33fcd84a725be4c13009c15d2d00fdc176a16,
+            0x1aadcefcb3f21adf4b25dc908e1faabcbad408c2b2cc24ca5a35e5649c787361,
+            0xee80d214b808612daf959f09c2314312cfd09a7050243e69cd993c351f865db,
+            0x2b92ed72f750583d1091332acc37a8c11ff616ac98ced2e2ab47e2650b783ec3,
+            0x7bb6c047a0ab37343ed2a2d1809345f72ee0921b06685f6356dca855053699d,
+            0xb27c5c1f4f08810c4c71b00309204a5ea1602065f18c7c9568a073630551272,
+            0x10eb21636ad3cc5b882f8eef50b164f5c0f05e3a45245b1f4517b3ba19693feb,
+            0x139afa8d7c7016d8b50351f05260a2f1661a7be1166add0f281fee3a5fa57c22,
+            0x10a8316597468b2f19a7ede834ff7ba4745e614ddcf43a373a5afebc45849d74,
+            0xe7bc88dca5e934a90b30c06fc33c46eb88311db5ffd138d2cdb2376bcaf4ce1,
+            0x1ed3520f1f7eb308510f20f8ad87099d28c26165a9deb3338c76fbc7b140b4e7,
+            0xa5b057fe093ed51de90edec1f4fc54c24614c3540f8d36af16022affde42d34,
+            0xfe1a3def2a011ba748f9b9f263e88aa32335ffb2e9857bb3a2e0a1d14edbc3f,
+            0x1f6abc03a0caba9732b313a2bc3ee30d379088b772c6ed9e3d9d3cca471c249c,
+            0x32cc35f494c7b826ddc1bb185d14421decdc35c89c4353e13838ec0de0e777a,
+            0x3526b4fb75965e49be0d73d43e706e756d84f80db93afde6863cc49b017f199,
+            0x19033bc3c4271ab5bafbeef999077c33386c044f05405600b0cf174fad12b8e2,
+            0x17775184817378f639fcc8dbd97df0e13baccbd90c83f0b4807ae9a486bc0d4d,
+            0xa9e1c95520650bb3f61a8fb1733069fb5eb759593c989c7c8c91cfa6108c3dc,
+            0x5261006343d0f17ec876854ec7d41315565a07796e7c1735825e9dd2bf16e39,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2fd7377f9006f870d0c079c8b10b62647b7c76cb481b2a330113cc7507effd1,
+            0x1aa6d67de3f86bd58f04498f5e71270a58c7ecc20d81891ec7bcc29d92c84447,
+            0x267b52a174ac8e9d118dd2d021043961fe9686c7156c324bfef84286a70a20c8,
+            0x7131b4b73af0697a2a744e3483a653379f9a6f66e05821b9d12aa2b8fc7f52f,
+            0x678652eac3805c1636bb62390323860ddaf6f1ebe10b167a39b975cdd89bb54,
+            0x15209b10675cab6f50d0496771117e050ce5120126d241672e991c2dcc0cd1a2,
+            0x1a1977bf61184ad35c53ebfdb3af41776eab03b2db826652e35ad3a12f745bd6,
+            0x229644c842f9907a93becb162b12af3144a7c7f25d064d457db70e9c9cd9c099,
+            0x17ed9abfbc0e4103e9e4ce7d1fcc95f2a8a0f8adde891b55e424f76a93f7a915,
+            0x2104040d07bc2a79abc7fe60e6d2bd8ce79b937d7772ecae4e21cd38cef7f792,
+            0x29b17696048b7c8b2805e7f2adb86cc14a6c54577d4d4b741c844203812cc98c,
+            0x155b7c97543d530c1784eb12a8c8e9594d423dc45a5a93a6e2ab2aa25210f1b1,
+            0x2d95cba17ff1a2f3ccb165e7009314c54d1f5d2ea514c54382ec918f0d18822,
+            0xa9d8db94925ee88c53578d0312159ba4568c4c35b2160748f7dafcc99c966fd,
+            0xb6f19b020cbf0eb74ccdceb22d7ae4730f72db5fff4462bd39941cb0bb2298b,
+            0x2f709aa70fb82604e6614b07127fead0d6c889f96277da8085f886a592d8233f,
+            0xc05d5e71c8ff96a669190965b0d7aed88d1c5df73b70de1783986bf8851507c,
+            0x8facf13f8dc731b2f216581d4b35f10f3d54b6c41457fd83347417cc9a4dbd0,
+            0x1bb219a4559f69a5e3ca3241a56ba26e36c86955feac34676c2d13a671f470ee,
+            0x32054ccbfd7840e0fefec1ccafe4b21091c2b9262c0337b269d7bdeffbd615,
+            0xad0e2165ff04113883d2e76bc8d519702644c1e938b80c614ef85b966c7ea95,
+            0x5d0cd6f76ce14c2cc307b211409329b29fe0e80742c329b6468d4cb6c4f8938,
+            0x2ac21c0635d3d249610b57d8312443a9c30fe4f353e75d7503d4cc646c7cc2f9,
+            0x2c98f53ad12c6d2f2c1f4ae0922f10c9319cee3b55e1720799c16fa36c65af2c,
+            0x1fafe9cdd001c028a8c9895b9075a18f93f8ad25632312000154e1b07d6cbafc,
+            0x1c66e585cd1c5651a3b651ceba4e33bd7954af808b69f4e8171a58339b6754ae,
+            0x2b8004d7066672e9c51b5efb0810da89bdc481658149d974641e43a8e6150512,
+            0xf19a8fe86ec9c9146083520d9bd83bad613879a0e422c27e09cbae6558315cc,
+            0x12199adee14b8fef20070207a6ebfa77f4f9202df37972a31e11cab9c622a3c6,
+            0xf34bbf250e5eea168f1772d93ab7f53e1dc570c706dc9818639f0181174d8f5,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0xb2878f79547242381f83f53d71b4a5bb50ae79bac3b09690c2ec04c27952831,
+            0x1636796259d819596441f2418e0c425ccfbfe67fb7b497c4361122748225fff,
+            0x230101fb2086c3e4dbb4e19b17dcc891db81d3eef3b5c031b2b1429e46fb956d,
+            0x2033e660632e0b2e8411b43b8b0fc9d23ba811a64aa846b0882516d954738316,
+            0x244564f0c62510a5e6f69a1a8fe77d6bc22ec9989b0f97dc4113a2fddcf2fd3e,
+            0xea22aab739936a78b3b85cf512de08c6ea303f53fb69e073d2da9b94d60ebca,
+            0x701868cfc18808ef3f8196bdb7bf2a8aee96cd85d269db60a4cd5a1ff9b2e88,
+            0x904cf11c0b58e3fe3aa7d70d8e365f6f20424f7cda13492c3a1089c3e209378,
+            0x1d5930f08045de1418cfeab3a30c08015f77a7a19aba209b992fdae1837e01fe,
+            0x13d07ccbe92ac9848da4c5651b692c3b298bdd002c76c1673e39b0c56c92cc4c,
+            0x29fabafec859d0eaea7b49a815141e2d5e826c1bcf4fe2e2c4d80d0d9026a9e,
+            0x1af5ab322e026a1b28a1dc06cba8585550db1bbfd3ee2355d8dd1c7d413126,
+            0xc60f6e36113ce5d3b8824f68a33bce77f8a963eb0ac4208a35c0fec601a813f,
+            0x17ac4c1dc0678e3afeeef3a11fabd3d699456839342277c4b6a57256a94cd1bf,
+            0x18d140a27d4a76d1daace46e5201c2057b4e1353e6e6a90d250798e59b055209,
+            0xf1336ac56c60c4bc9e27765f43bbc4a25830e514126dedcf518f1f501cab662,
+            0x240e3c3a7dece37a8e4674ca411513bc5b2ef205d6afef56978ecdaa310a5fc6,
+            0xc1f16c8ee024584c6e5243038d7324bd631263e4036e9df5422f78c8b01c9ca,
+            0x236b70f7b76e6f16b6f4d08f6c6755776bbbf2beef38ed9f187294607fba3e4d,
+            0x2fae92d9a4260c0eb67b8b5c535ef6f43913e506e546b3a1f217ecac1eb0ee5e,
+            0x1e69a926148d04785f08760176dba2be1ee5b4ea19bd09135d5b68e7572cd1c,
+            0x2a96f11408f216c5ade40371fac2bd452a578ec23bd220897aa3372513bc4530,
+            0x1522e73fa41cc4c23e9ac6a6df46dc33e6921b802be72ccaeb06de4736cfe988,
+            0x6d2c787e7b336c0556293aa8a6bcf7d31be6d8b6d4a644ce77b313bee3cdd01,
+            0x1f80057bec504946a3e8d5e8d31412d2fb6461b5f174974017f2798fff57c306,
+            0x139e43308691da278944e95e910ff3c4903e2faac75a6533e7f1fcf0dc8985ab,
+            0x2958715623868ba98fd982a092a9eb18fd0f2cc9d3ad44d03970b8c2361ed38d,
+            0x3d037c068aefcaf62bf84b4fe75a8a46a5d85d63b659278b049508fd31d673c,
+            0x25f8654c412e7d630f046c138dfc4c18332573d9f2cdde26683fb472fc8b2edf,
+            0x1874b9d07a26cf2fb8c65b8d47c6647008b42804af1e7ceb2c7ee466a2b5807,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x22b74f8ab6acc3f3ef0d9352aad479f2db3f5171684734ec6d18c69cfe0b14cd,
+            0x28ddd3e0a84efcc63090346d5c5c0b9f7a6b8a20abd001e8ad01328ac5ff90b2,
+            0x21ba1ee2990e2ba981f6e7e97f1aa879eda6e3e4a7f192be055d07d2332aac26,
+            0x8923f775145f7243003eb5089160d2e0b4be6b68e77211d796e567b026e92db,
+            0x2168e1158db076bd2c7503d8d78759b741f3d09e8c2863f1bbf77eb8a52f2bd5,
+            0x2d91a6046ee638587087f34f8f3a45543e5a12e80db1462121d37f3d2f574ca4,
+            0x19a362b36092714b50b86238ca35b3e9106efe2f1cf4a8f091a687cb71344a16,
+            0x93ab3a1ec4ad5be6235fb805314d7e9f07ad5aafb214ceae7ebdcf81db72fd0,
+            0x1e6f239f1cd9a373e4b8a283c86c7dd710a5aeb00a35338dabcd80e14079828e,
+            0xf8b272d893f2288be54151a7c6e3e3e274b96a395616976d267ba31d59c0bac,
+            0x22073c45cb975312538a8a8bed28c0a2858793e1e2a234d5fd8a6ebbf8098fad,
+            0x5a2cdf46b89919b93bff18da44a4cf470a0de6b9bda0ed97d9ef3085678c9a2,
+            0xb91b6af7828f5e23b06d2ec84a5acc0f6f670e64146bf82dba2cd09d8b9b160,
+            0x26919b3ee33e46e95680cc8c216d561996b65915418a84d7b3d7bc0d29e3e56d,
+            0x1615d651e47167b1ee9c70737c1376972ce475a1c66fd778ff5591b2e4e92017,
+            0x1db6ba6e18012adf2f43482f224541dc5b5ffd5522f9336449fcfed6fdede339,
+            0x157aee78ba392137b06bd8104872ec13558753788e044d38644249dde49b63f4,
+            0x1bec3f9426534d61ef5ce8b40e3d9199d929a295c4b2e5768033fa7ba51f628f,
+            0x1cc2614a3be0eef53905687b6d666d957c6f47b4f340d59106fc5add588b1272,
+            0x17cc5ecfa4bcb4d4138bad0db4d25b8bdd921969465ce40c3783190855c0f9b6,
+            0x2b71f219cdc5fca5c1ba861f3bcb51aa08fdfec6c8600ea26ea3f433090d9ec7,
+            0x209098b02905832cc62767fa60e37a962c4cb7e51b23b6510389b56c510d3a61,
+            0x22202b42235a0de23ef43301055066d26d87d0ac4ebfb8d4391b05fdcab190bc,
+            0x27067a1a9cfa43df1faa7904359cebd06abc41ef694c89954ad076e296bc77f3,
+            0x1dda2ec6fd0f92a515b4b9f0b80aa68260fd6570fe28c35acd8da5233c655c9e,
+            0x20fcbe551e628d29e3625c948d92057dfb16a486be9fd88ffe308b886a7f3f5a,
+            0x102b63b63b6594dba0d9502841aaa0bdf0d2aad08d25135f1090f0ed94cadf5c,
+            0x2665d2b3b1f4711b362b28c1581c139aacf681f189d29cccde608c7f44dac4f7,
+            0x2534e0a770bb00179e6f7621d96dab342ff960d361c91adb0f8faea486693df0,
+            0x132de3965797959cbfaf61a239c5f09e1672d3b6387a1e34a53214e9d15c8201,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1b6466ab641f7f30eb2dca03dedb89080833b2bce7b84b6a7b1eefd30677d2d8,
+            0x690dec480f914c6f77ace87a47b0857ac7fdde73463e4b2445d4656c53653ee,
+            0x65e0d65c2a3e1786c2bbfbf47102e427e9e31d2218112a86d821496a316d68b,
+            0x2b5b1af812cfb77b30b821bdb2614c5f09aa73eefa9f6a48bf3eb146148b010c,
+            0x260f7a81271cbfdc27a85f146221b30fa12e9ffba21d654a371bca4455a37bb4,
+            0x2a2b6602a481c04475dacea41b360af3926cfcd4627112a8ed4192f213a823cd,
+            0x11439386af5e26221df0905abda34142ce69f66151192d0143dbfddf3aeaaed8,
+            0x230508e632c716e903e22a44c6002c2d39b1a0ee072bff9cd0901b3c4801e69e,
+            0x23ce4e18ef472ed4e4aeb0dca528f14fb7301c6691d43e9632a65f1ec4e7bc7f,
+            0x237dd8e70aa173bed421d4d488c4326af456322620483fe1a393066187a7cc08,
+            0x24b0ab054d180e17971795754e027a756bc1f68ecf9cdc8b92b30b4af2c078d3,
+            0xbaa7bef4cb2a2cbd1b33f9501ad22e365526a100273b8ef1a39152d779bdecf,
+            0x1fb9b3569c3be925e480fd102a3432ceecdb59d346486b99d22284165df08262,
+            0xed3418179e711b0a2d9bb44fdd0ff0c82741b531058111031cd123f508fc7a0,
+            0x2e92aa6007576a4f815c645abb2e9ee10fe75baa5e13ab2a0b0aa700e084f071,
+            0x2557fee713e3ed365d7fc7c6c07f113506d48dccb98510d84457b6d61c9a448f,
+            0xeaee37321492b0595cc477585c9fe9573da00ad1619c7409ee76c625c11d447,
+            0x1b9c9d4230433a193f315fab4f8cb8a7f4b0946f6241dbb2e858f3cec6c33f85,
+            0x35b1d3045381d5053d0c329ef11458315d69335cd2371fecfefc8a2149a8583,
+            0x2a0bf648759293e205b62ef858612f4e54cfa78dcf1fda84715cdde20acf4978,
+            0x2d1f77f7bb34c7adcaac3e88bf34cc32e7aebb82e1dfec3491ed439c6b71c4a,
+            0x63218d076827fb18e8fd4c14755443dcc3cbfa5bedb57a8aa1ed4b1a69b5261,
+            0x2808b917c9417f47e1893c4a5b0053c64a054319988e721b42713d4abc351024,
+            0x4c1b265648f11a5ed40c135675170ff486f6db120056d2b43e476bcda4e0876,
+            0x1c9625a781c3530ecf4d532c0f1876e8281a454abdc914f34dec624dad8276c6,
+            0xd9c2ef763966292a4585c0d7b4a1256c7b4687b8c19aefe0f2c5afdb8cb1093,
+            0x11bacbb8c80b3caddc7be415c49d19c8207467eca352d2d65b3c950df899cf78,
+            0x2f38ca64de487d59b0332f142c0cc9ee408f947e17bdf1ba7fe217cd50e3b088,
+            0xa5b42f7d3ef308c007e91ad0b859f46582ca96b8a3fc12c6964b4e3ae230bc1,
+            0xca6578515e51c2c7da9e898fa1541a6e93bea88ed529e5c1f411141884743cd,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x986957cb19cc10c36db88648feeeffc017bc7f344eca7e278313887c521b66e,
+            0x2df451c36b1789c3b2a6719818a62d1d40597c6c2881225d9bcc95fd6d090f50,
+            0x2bae223a93b08d3115a949252d906887fbbb2988c127c1e2668c55a00ef22483,
+            0x5bebef52bb08431bbb9e92d219b4a0b2fe15e2f4346d0e837664369aefc1803,
+            0x18842bff3ff8988d29a3737afc113f6bfb80c08d5a2cd06473baced406d3e2ad,
+            0x2f78a8fabd2e97700ab4a2f2b5773ee348cbb2ee491bf33a5671c10e6326be6,
+            0x8b3f1bcdba14103876b7f57f60d08ee3aaf9ea25f5495680a0c11876117feb5,
+            0xe536221242a02f1c78e6c59133ed1768bb7c5805ad1a3e59066ad23dc8ad422,
+            0x2d906eeeb9d7ed09f7fc504db42dfa79bdf74d094eab5d29fd91e70be78b472e,
+            0x25ffc50d32b7badc1066a06268cdfe0a329957c10b2c448cfca1ff6ab6e0451,
+            0xe77d99818d5d95b153667917050e800f778a07b2520e0cb2a8d9f3946a59bf3,
+            0x2434b0943c80797cc13905ed7ee35a700a61bf601c7c3dfe20bd7fa3a62d0dd1,
+            0x15f77d11fb4fc7c16e4a6670614d85b6eb833f0c96c9ef96dcc861bfbe2e1c8d,
+            0x2e1db5f958cefae9e831f4d55d6c883847a2eb9f1b8ea404c6131e9cffcae8a4,
+            0x205947544c2d5c9d1157bc26697d8e3c1949786e6210ab9deca2092dc55d4498,
+            0xb9ba62195d29f54053e5fadce4e75e7323915fb2d047f61593c0cfe351c406,
+            0x233eee9f5e744bce4d408b2c0fcd051285199f5e876fa3c6f6c99a289db64542,
+            0x1818a3f0d1552f34caa7dc40defbb1ed62072bad77ff5a8221fe1bbc655e7dda,
+            0xa8c36ed2f64ff121cceccda4d723afc80e17c1ed150d4d4afd9618a9be52fbd,
+            0x2bbaffb37541a9f521ee370836ae3b6f0555f49b0569032f848e15e5d054054f,
+            0x2dce53865aec616cfd8143aaff05c7bfbb728a48f2b81bc68eed629ffd6537f6,
+            0x26a4a63df26dbff991a0fea4b9d00094354de33aea2f04f04312250deaf202dd,
+            0x47dae867b6ada4550e18f2443c44281584a9b07e9104ab3790d65d0bfc2e15b,
+            0x18672943f827e2833a8d9db988296aa281cac88816b11ea2ce6fc5ebff8566ee,
+            0x1979353fb46d8cdf3b518ffe145af6a533b9ebfb990582fb36f31085546556a4,
+            0x1b394c0b4ff11b67a1591f7d190c74f15bd83812ab056d7ba186998adfb5fbd2,
+            0x2213fbfedeb46fb9bab30d5bbf854cd2945a30d1115a3e2cad6b771bf53a9c45,
+            0x3045a6b98fe71341427e894e351402342da59067fc44b8a1e321de8b75b5384b,
+            0x1e560b922f410efbc72ab3137afc2b4bb9d6d11e3d78ebc0c1ef970b8510b0db,
+            0x793ace2e045d6dce7eb0c50bc654785c69eea92a5ff129ffe2b8224a4e66987,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x515c94018effb2fc24a7bb89b1a1055a274cce74cd1bb4fa3751331c55a830,
+            0x228884947d2d1caacad64b4538521498e6a377f1f531c032a41e8c5999ce7fd5,
+            0x2d7bb807c37a5dba31490c8996097552a930e55198a0c8f787cab498e4adf8c,
+            0x15f5cb124b0a18bde04db081df667eb90d722fe38420c7a6a2340dd57823d4ef,
+            0x2fdb6f2f83a138c09aaf67a5b7f4f2d21f9fb72def9246f8350b3d50fdcff090,
+            0xdcf875be3c34cf38d62be56fe936e1f76d10f01c9acb657e4dfec02f98c84c,
+            0x2f2bf29d6b7637980d02644b98030297e4ee87d51476bfe02e430700993b4e3,
+            0x121dd63b185a3fbbf1e26721e1dc9207ba6ce83246856c780f1ff3f457925f1b,
+            0x20e79bcfbc14855f607ffe7efdc0408b2366241ee80d388f58fc83f1140b4fc3,
+            0x153dc31be4cd79fbc0f1757612c6316f994560d88ba2a0936aadabe71d3ab4fd,
+            0x13804b12bdb77d63ef5f9807e60e1896a5212e1ce314a52f1e65cd6051545ae4,
+            0xb6cecf0b015284998ff23c23a7c003629f8ee8f8e52d85ef6af13147fb8bb22,
+            0x267f992fb1c5fd7a2adea64c4789617a205686c01f9743e29c3a36910902f83d,
+            0x7c739e819b23013c6b2bba0db1f914573d0be98da778fcde3c44a82e8db6a76,
+            0x15da652416fc44056205298e4837860a96e1accf42af4ddb4b6eec42fbd303a,
+            0x1c33739471d1bd4fc613afe1e38b71ff3562acde29dc58bf6cabf73a192b372a,
+            0xedf8c7db59823fb1f76cc67e0e3ebf8de8dd7cbe69ec468515a5f5511c8c1f5,
+            0x8334b72ea2d0d35ab3dfac4f2696b0d980b65d6e0ec61fe2724c896bd3f517a,
+            0xf4329ad37ea22a16517b9b1e6d38afdc75a8398df9b9a32aa2f8f2c3346e289,
+            0x1f8d3e31cde1c2b3564ec9b8acb6d3dc56b946fd1ea3cc6067f04515fe80c352,
+            0x94a21c0489acb58fc118cde1013f08105058d9e97d6a780ed30705c0e54a838,
+            0x133b634d187f62fd2ef6d63daee9d3427ac1c9e215749786a2e17cbabda7dab4,
+            0x18e1b03bf875c00f97c2d24bf7daca95935d8b176bc767f5659379937658f599,
+            0x18242ad22da674a26206f354d85be06760137fa512cc7f30a5e38737854159a0,
+            0x294268b5fe2beaa0c99688e9a9e4f7ceab6a87dd42bb950a25022247c790bb6b,
+            0x1f13839b65eda77875e30eae082527d8b68a45094e0c63295a7130b78ee8ddf0,
+            0x2baa1faf25902d89902124eda3986279278cc6007b1f7b0f193732e5527fc69e,
+            0x265cf033142c6d433d701a040d8f9f35c15475a6c7ea5875d74927d37e3a6968,
+            0x1c4eddd1412f02358286bf07dff4ab2e90e5adf051ff5adc369e93c3fb78cfe6,
+            0x2fb924230c90e26ac6d37357a6df214f13c24c73725995873df37da56f7a3e77,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x19e494853af32baea08fcd358d25c37baa7b42e14a74e62773713083679489b1,
+            0x24663e25937795d723aba2f413377e470b84418061ccbf2e7ab06545d4f69b15,
+            0x28194cd3daa20ca6ae03a8dc12cc30cab003f2a1b784c9b64436a984862ad41a,
+            0x3004d9469414f0a772c99f896e7f27c8d08abf0dc7e30feb91b51820e4591fc,
+            0x4a90138ae63af6d831112c04dce879f943302f37a462f0c84b4f4b543737a2,
+            0x16328fe8bc9d3c883accdd09cf2861ff33f072bc58cfe580113864913a5820b4,
+            0x255342bb3760148dc048617882768a4d198230da53b4ddf87e5178ff4832f301,
+            0xa494240f29dc89a98ec7fd0f8a70c3e82fc12d2894d92b36c5e472b51cec0c1,
+            0x26d9764b65cb6775899164e5bb179aeafcaa7c262861bf582c5d6419f86946da,
+            0xdc64acc51842f225a439b650e5eb3266d2ab80e7ac705ccad646770a338ea77,
+            0x42d122c394166798b946f03da9b3e06fd5ba1fdbba49d3cfc9ece8244426044,
+            0x20715b9135e15fd039a728fe347d6825e7cbadca0c792e2755921003b7cf9cee,
+            0xb8465af4ffc725e0d9d50079c16f1a5a7d8df1fc7067728535b10e19cc70e32,
+            0x1b3fe32fdaf4a4c9b5186604fb4746695561720c1a7886751635b2a416b4e37f,
+            0x1ae2fdac7b7d0b3c4739dd9eb27377b3bad124823940e12d0bcb1177c96e0788,
+            0x1e6b8f955ed56d144d1650f250bb0f8a8da2b631d38d75e6bca34a687eb96a5e,
+            0x262dc534f682c8f874d877df14acf8ed7dc65a6e42198570d15f49520745c708,
+            0xf9a4f0271d5c6aa02c42053a8d2b1fd8179a35cadd4f16299cc0037b0b16d6c,
+            0x6f078c71788acce7f48fcd7271d85077c50ffa7a82ff67d81a10ddaf70d9301,
+            0x2416d74e36b42dd5519bd3a03935b57120b33c05265a40cc15fa0b36e695185d,
+            0x19efbe964add94b60109cf8e6795b8afb31ece021bd1e99e06a39b868ba5da18,
+            0x217825dcb0fb4a2debd0856679d5f138bc28083b0583bcdd2fedd8226d71ea20,
+            0x29ed9e1b8a1e7d0c5dc4e51ea5f277614970693b65758673625a6b81e0ea6305,
+            0x8e7139bcf5e35d8c2826234a00c56696400cff2b012a94a6eddd3d1ea94e4bf,
+            0x23b45cb4566041748ed409f32aaf3b7d59ec85f8ad75bdf008a733d500a24f7,
+            0x59e1a9cc4208e8f4adc17e95a8dd0a0e0824aa4671a24075116ef1cd29ab280,
+            0x1084b6a7bdcc2947835bb7f017c5fa4a018dae7a14db23c1f44e821a65434e3,
+            0xae92ed115475902606d7f3e699d95659acb152108c586a30a912750ed18b0d2,
+            0x11540ba858d368852b75bd5e3d31e289a182f3068ed6c2654ed4c92e9d4a9a12,
+            0x219ad9e087618d15eae3780c3b2fbbbcb68667bbedb9d51490a04e4a2986b734,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1af405bd496121de8bf68db182c52f8dcd863e5e9d0d07c332702c652f103155,
+            0xfb5adb4f2ddee2c786bbd630e10b6af21566e13887264d2627e965b8a7657c0,
+            0x5735d0a20981c3443c26321ce6aaeb22867087fb482f3fc52564231fe1fbfa1,
+            0xd5f25ea7cd06c95915cabc11f61a2a640b5109771238b53526673bf353d8efa,
+            0x276d9d19b50cc160870806a1622acf7cf1df7a5c0afeec2dd77a0962acf14cb1,
+            0x2d52da76429ebef4234a94a2cf6a41afd471193888b6fdf668885a0c578d3c03,
+            0x24f84ab4d1acc7cc1b4f842e502865a26591447b8bf24439782e17e032b6f535,
+            0x21069f3feb18a6d2025501270c070b1bae6035caaa50bc68b6b402a909dca262,
+            0x1430dd6ac598deab9432e5227ff5fa9da4994f08ea28a781f9fdae630aef746,
+            0x6fc0f56ea9867dcc10385217771bae7c1901deb59d89d694a14fdad07ef7456,
+            0x2ae95e39f51c7935a52f31d1e92c2fa1e2a2a43ecfff3849368a226bdf1067cc,
+            0x2b53d9abe894c47db9a2e81ddc1ea0cfeea5ca257e8c0ae61d4c9db5d8a918f2,
+            0x18dd0925e43f821fb7c3c9a72e5d409c13e5c42f35b1268e9b36685ab6c60a84,
+            0xff74b6d96a8d00bb97508280e98c10a1eff834b46b15f474b9f4fe50174233a,
+            0x18bfa382970f3598061f30c5c18b3e71105a5145ca3e6dd21f779395872e3616,
+            0x1dee9f00f2b7548ffa9cc5a39edace63c461c528a7bba8a17f59b7df6e247b99,
+            0x12c5810e9946497e1b6f928182d8511851683ecf234de99c649bcb3dbb8f1e76,
+            0xe5953881e72ff398e4c34b50c3d66fd073fe79073f7ebd593fefdcc7bc4fe32,
+            0xd25061d2528dd5351e4e8367c96fe57446429956594b2f752783f06251e1ddb,
+            0xcd02124b62741431f4baa64fd8a759db1fe86465b36f26e7e91ada1a370e031,
+            0x2d524e2c0a167d163be6863fb345539da3a8fceb3db496b765ea2fd7c4fedfaf,
+            0x9f6ef3fd9b8eb4dd5cf6393f681db544e7339f6a129f9bf8e380041e0a43cd2,
+            0x28bf2b88d392ba9823e2db09d12cda5a103b6e2f581a9a3abb8ce25c5d93476c,
+            0x209e08cbdf5562b051300a64f3cba7d75c25e5032a2cd5331e6cc386db38c373,
+            0xe18e80edd86792ddd92cee432ee33b15fc5102cde0ace9f8f7c9fa0663d51c5,
+            0x27bd8795292bc68b6a8e0ff451cef39f92f7af2d407c1cfcf60297100a9c4841,
+            0x87d2427a36da27e525bb1956015bb2e0811c037a0cc272f230cc4f18a756a13,
+            0x5e017f8cba3d41aff70fd421eddd63f464254d65c086e7f5f07981790ffffd9,
+            0x2eacb959ae5429d219c66b722feea009060a093d33df0cdf225553a0dfc8e7c8,
+            0x27a8c07ea74055992c66e0003c03b07c090d30d45b940d303e51212a974f05b1,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x25b72e38946d8c146ee356367981e74d001803430d4ae023d08a9c68ce8fd58f,
+            0x29d3d7fe8af458f8f444fc49c4cbb3fde970d6edf8ebd7bd3d067d45994075ed,
+            0xdc25ac6f52dfc613dae0197322a98c7700cf04dd9d1627c90076bf2384b32d1,
+            0xaf71c0bd1542973007bff10dfac94ee18f5da9221d3d6fbe04078971e3b80c0,
+            0x1406d8cf97827b7d25ce71e62d17eff80c493bb0e1f2a6b951723431dde17c18,
+            0xa177d75332f2aad209c9eef8004879afd6acd5ce56db116f834053ab51296cd,
+            0x1e42feea60f7d4987938dd58bc9b53d4b5ae4f8ee14b2ad58d723c7c86c130d2,
+            0x2c5921fa4ccd767fd2533f308d1c18c63cfdc3f7d8e10b217fccbeee2aca0ec7,
+            0xac4e3d803a6c602ba6fc373c31988c294649478134d462772dbb91e40c56595,
+            0x68fb1f094571ace723b59d1a0595cdbd2631d93806a5f5c758ce986289ecd0,
+            0xf5a472661affd8730cefc698d6688fbca3ba07b12637beb8f0722f2f5e8c8d,
+            0x2ed5af998e49f3d9c92a5badae4eb43a516b1ad840cc01d11c8a441786316c60,
+            0x9929a608a5256575d7c287db82aacdf5381830b9e18b23ebdfa2adcfb46dbd9,
+            0x26639e520710e998ed40fb1369c7cb039bdbe0e2e5778055072c8a5466ff9baf,
+            0x2b3225c35a88f757d4c773363b825191df51b0e1cd4082541d382aff5f7b3f3b,
+            0x1c1a368cc023f9aee70e3e53341a06e8095022c5413ff1de4286363b4e1b99b,
+            0x1b39049a6f7088294202da65d65bb190d44745fb93f4073a00d473d38fc37392,
+            0x2b966bc8a897d76c04f943c5a7aef551f3c6040d0586eebe1f4989a0248ad79f,
+            0x67a2085143ae9a245bc66bd3374eea946135f565cc0efdb6358a3ccde5b6c6a,
+            0x27c3ead3d76039b10f3bfe13f32df2823fb8ca146d9aa6b14d8cea182aa76bbc,
+            0x13ae8e66bda5f40ad3ce0e83305176d5e73b03f2950d5dd78b1087651446f60,
+            0x267e55ad34a8788497998b79193846c2822a266e8f60799978e66ffbe27018b2,
+            0x1a964c5c4550c29516171a8a8766faa7159a1376a836d29809d5e901a584a686,
+            0x216cce9e5b6062cd063ae93e53efdae64cf5479ae01d7549f8cc7e67a600d184,
+            0x175109dd08b4de441ba589607706769fc506fdeddcf56ad57d0ec008fc3816c4,
+            0x202ed46ac0e68827ffbab076167ceecbc7a9614234fd6621c6eeeb7283e439d0,
+            0x2d265e49f35dc88b63abad32d14302d3555c221ae8eff1d3399a66959ee87e6,
+            0x593f84a55c9e3af185e6e8e689981a9fbe1ab6282f393bf4ac2b77be21d91d6,
+            0x2fc4427295d575a8fa93101a1b916e123f2652e7e9e94c364c4abae0a424334f,
+            0xfd26a5a97c3cbdbec343e616c0d93f25d7c5eb827748114e4da61c017e25478,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x163e039587ae8bed242103f972c58d7b3570846f3a9ed3b6f65ca9935e0599e6,
+            0x17b8c9347540a0cf46955fe40c29fe36680969a074eb4e1b7c40ce0c543df4ff,
+            0x28939f23d63d09adbd1dd196dfd73eb65ffe2fba07a79e2049a8453c7caded55,
+            0x22f4246a101673a3d58ce953a3740bf807f25fed08cebf1c124565310b10caa1,
+            0x1335c6f50549b22023d2a973807c510d8c1b7e228e8629c35b7ea3a701ed0277,
+            0x5cc88a2ab03f9f720d841583cc8387313503e804be95d3311a64d0cc3cce9c6,
+            0x2000d4715746fa36d8abf22861719b23aaecfcdadcbe71d567b1bece77601904,
+            0x3c2c00765201729fef4cb1ae8cef326a7de4f3fd5803521e715257f8b392e80,
+            0xc5affc61d51001d7b0d8aaa6f99d44cc683af806ea1ea1d241ce56f386b5462,
+            0x153a431981ad712ae13b7530797e5b2ab77c125bcf530880ac8566ad3a5ac417,
+            0xd2047081d9a8fff7773d8011bbc0b61a6057fa6f9a1627a3cf321fdd666e8da,
+            0x2eadef1fd011162138dfb0e0200683a3bc27e1ad12dbfb2b94b32203186e591a,
+            0x21a05d0434000fb05886112242958d74bae54ed2b6f37ece00b0293322e53253,
+            0x19732c8f836170ba403a0d379561bc5aa6eaecf21c4fb9fc26cd44bdeba475ea,
+            0xff30532e9f7305c94c298848cf0d54dba01341a79da4db0f2a975c2e4380372,
+            0x2afe8d3ea06405c8fcdab50d6d6e55b6faa676cd36e6acb87b3836581b06b46,
+            0x2fd228d6e4c1a1acaeafc4597d69fa30e56282d8f11d4cbd09c360dccf546f80,
+            0xc203a0ea25b7f9b4066daccb2928dcfb4d1cc0cd2d14671fab5a7928603c8,
+            0x17ecb26056f6708cfa3aeb6274c3352d6bae402e4d2414526e4c2a2bc9b8e0b0,
+            0x2b5745b27a5ba71c7afe5d1bf955c578d1ce3c915f4d30974f225f6f7bad7c8d,
+            0x1a6eb6c48b529c6a0a166e53fa399fb68e8b414869b13ea713c1a0cab8480c23,
+            0xac89d6b741aee6c180408d6006f130ed945185ee9a213dfe3c8baa49330ee36,
+            0x86eca38e64cdf2e252134d79160d437d92537324cab25cd8698c5e92e94632f,
+            0x2bbe2bc0467c7a4d9d1bf2157cd5cc3ee50f10166a0d442c706d9691ee60b8b0,
+            0x22c4c3d27515f300d879e8bb85b0447341cb7a816d6fda516cdcf31386998d75,
+            0x23e31259e8fdc69a23a603b4e5b47a90390966aafbb1f4eaf02f783219acd1b,
+            0x20c0c0f899d24401bf7084d6d0be314dbb3ec267f87a2e8d3769a1f64b469a81,
+            0x2daba47175558a5930490cadff1f3deaf100589f676649a3a2fb1dbd9bcfd3c0,
+            0x1e759b766aa310dc7aba2245608ecaaf4fb90f509cdab694155b47e768af3417,
+            0x135aafeb5b230e030273e42ba704da43085d0ef96408ea8323e7be8b546643c,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2ca2e70a3d8145f60160984452b26220f303eaf6bf539c8055fe2ab037a64883,
+            0xb25881ede6015137cdf99b53a8591aa6e0c042a5a8c6a9e6fbcd11a37023cf3,
+            0x258b19d1bac9e53c3c5cc4c59c87543b0e9b33a5e631fdda56298997a5781a7a,
+            0xd6e7177ca87aa3326c9420369803583d1a1d8d96adc6acc33a3e58cdd3587d9,
+            0x23cbecf6d9fd7bdc4c426035908bdeef9c9c7a801667ff2b62e8ead282bbcab1,
+            0x2841e2ca97eb7de3733f8a6d3299c6038e8b17f9d133ed12efb4dc6d923d804f,
+            0x2bf228ab9b7490f4b0ce01cbf31bed2ee4a6ddc6d5a00a608ef1c7ebcb5a203a,
+            0x22eb1fde7a1c175f0c152d5f7f85045961d2b01397db24d9de95ff0507627f0e,
+            0x100932572c12a0bd1f2ee8c6b0af317dc5191c3bc2a177eee791d6e539e5b237,
+            0x27e881557b4ec0f1128ef0069c22a6e5ce4fe48f7bc9d9789c48d6948bc24c85,
+            0x25862853fd1b44c6aa26a414ab4f295aaae0fe4457e0fa0c4bc5dc9fc2972246,
+            0x3947c7ab7d714f1f8d4503829e2edcd06baa8ba87d5b86354bd7254b841ed64,
+            0x2676b506a75643609e6b0dd8986b8865a93000fc38eeb1f6cf3b026d6191ed47,
+            0x1f45ca8395b4868c3b68b11911f52425202fcd2108aaba02230dddca7b36546e,
+            0x1b5fe89e54f508b5188c8487302834d08095b14c1e0938aa82f9365ca3b2b44e,
+            0x25826f9ae3904e80f7ded17b954c8989a04a060326ca40371dfa204e02b05eb4,
+            0x2b5324e42bec45328632622c82644bde941e015946d2d9219dd0b805dbab5c26,
+            0x25e011cab809208c9447ce75dbf6c90f76c6d50640829b861c2392271a51ee91,
+            0x58ffecff608099006fd59ff7d75f03a528613b3633d1dde3fcb5d6f239a648c,
+            0x26f052daeaab76f2ca8e18584b8586ae9a8f591a8b97a673d82d50be943aa00f,
+            0x15d305bc6e3138c409925caf3968367850c6eed0384e46009d38bae5df81fcc9,
+            0x16f0c3de9b8a76ff18370cc489da46a9bd962742fcbb0a0ab0aee9d12c3c5fb2,
+            0x137a4fc5e63da4a366b6edd41e255fc4baa73ba9662ab7d2b69e0b7d4986b562,
+            0x25a59d3b46f5c8b7a763518797faf55cc4773967c1772b01c7c23f186a75178,
+            0x13df1d61814fda2e0d26ca861adbfe9b6a92c05bc3afc953cfe008d176be2c30,
+            0x15b63fe5843c661cb40dd42feb664dbadbb27866e119a28f9ed8d35b537870b0,
+            0x23352a3a3bae8c2e34359d75bcc9a5d870b69555ddf57948caaf074538044a80,
+            0x2d223c52d6fbcb0e82e9fef6b9bd7384a2b789c4d9c273ebb35b4efe8e51e75f,
+            0x1f208f14c51b48c7776faea01878bce6507182ea071505581658173217492863,
+            0x194984a1a5106ddcb1bce1299b1b043edaf26b85c4afd80cb6785cc5c83b346f,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x28bdf0652d4964a6e9ea2faa6ce2d823253364d311762578721f87736aaad803,
+            0x1183224ea82a68db5fdf6a21052477c8c8ff500e97b8cedc09427cbc02d57e6f,
+            0xc61d22c912bef8507c6b08cbd36f7cb7979f3b56b36549613794515eb4e02d9,
+            0x2ee8c7f8684dedbb1c177fa9f2574a20cc4ff3c10562877bcfb0d53c90649b77,
+            0xf56193999816a0f4b15e38974273b5c5863422b93da9e94f47c5f10351d4705,
+            0x90b70ecafba579d37d6d211358523ed992e26d5a7752598bbb68b637a59295,
+            0x2de97266af0468dc5a587231f1b1e3aa2cdd4d1d7208205be90826491f263752,
+            0x198553fff8aa46adc9af3b38d6c01cc00f1a6594ed0e1a8b8f370965f8a89669,
+            0x192b3300ef2574b4a7053c24d7dbdea81c04da6f3c803269ee85c22c110782b0,
+            0x1f4c7a76da30fd0e604d14833d0ceae25eaadfcf937d4ba5a6bd7507b70fcef3,
+            0x11194b46ea91741f761662d56b64c9d127f2bf36142f681bca579af2e8856cc6,
+            0x13233cba082bb1579428bd4a19847aef4c5031956805f6e2522e00dc9a92a087,
+            0x6fc54c9a27cabca0bd75d53cefe2992bf4b744ee1f1e0cf7c254492e584886e,
+            0x14870645f35e85921f579a47d013cf8812201a133bd14b6f5604f77c10ba8ba,
+            0x246344f1ccee4dab0e0409bc96fbb618937e6bc629d9b1bb83a669055ee9e210,
+            0x1e1c72c73d9444d6bc46a7834c66426ce4bb91446e804909153e6bf86511e628,
+            0x662c514923e41038cfd078fee4bdbe72c8f6e90e5a3cfa51082a1a4f7523754,
+            0x25c7e06ac250334f38bd664db0bba786d54e9d40e7c104b95989232ba0776db0,
+            0x1c63774bb6aa72c366712c86792d85668f833b7af35eb91f36176de375fb2522,
+            0xeef372e915f3263f31e2c3c4d214b4c9aea86fda813ddbe1cb15441881ade05,
+            0x29db12448c6eb73422accef5a2a3794c7f372c283f37b2b194cbcf09b23b480e,
+            0x161b72d834fdd269571186b3847084d251f4765a5b9ffaf77fe720319e0dc7c1,
+            0x2434332138c93a69feb06521af0ef32c08b680bb50eb61398e377447ded461c2,
+            0x140867fa61caa3dcea10be9b46b76871d983e8a7952e3d1f71aab2f531a85714,
+            0x1e3877e58d7f25a988f737f229650cdd345c308a37c66366683771f9e249acd0,
+            0x2e00f80aa5ba054560070a3f21c0bd37e311ce8060a7cc1c64650560c9715088,
+            0x9673ea23dba537a4a0f6dd66a13df85d8887dc3431666a86730becd72f04fc4,
+            0x2a05b10d1faf68ab7e607388f7c9b3de54bc151f0b2da02702e471eb5b786a50,
+            0x2e8fb8bd00af6741fe18ee679ee378e8602ce8bbc429ca9986d016e17b2fb22e,
+            0x23cf3f042a56c7d2da94772521a21ae6bcb3fd0433f8778cbf68fe1c365c8c08,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0xd4d295bd6bcb6716dd82907d89b8809a8af69859728773689e073bda41c709b,
+            0x14f8df38aa9592d59519054d8f0ac2c79b6a1303905a9770731a3a7081b2bcda,
+            0x27ca9533e2a56a644d35c53fa9cb66187a7c0ef7322168932c330724edbfbd0f,
+            0x1acea5282de35d35337503c8c8a221fe22bc24d39164850efa9a7acdf1377f07,
+            0xdde135f69d5ee7253d1cfffdf878b3ea75ca2c56b15907329147969fb120d46,
+            0x8565cb565140d42d33d5b907a0e23f7af7daf91ea5aff759fd8ca916579ce25,
+            0x19343a528505b6b303ed193e33810a005abe738057cb00f34c9a3329ca808b,
+            0x9cd47fc8ac46b3e49d737eb4714d522ce235c1b0feffada0852d8173d4b080a,
+            0x2b87d075e7fab29849291a7700eae8317cb01676a36c0d2c138257b852732a2f,
+            0x106694e160db35b2d35998e4ebbd1769c69c448afd1ce6aaa8e1bc1ce53dbf4c,
+            0x163d91a57022a4734ea17ab01fb85d94622acff6582dcf7e4b46dd0a5d72d823,
+            0x2b8cbbe66ed1e1d9c5a1361ef0a80599de75573c62d6e3aa718ba233e2594408,
+            0x305e4c4a93d931f927f0a213cebe1a5a3b258ec726fc912ca59590febd9b6020,
+            0x26d0c3492063959cd8c3dc0e5c791356b19b9bc6e39b4da13a4d2a612e56356e,
+            0x2076ca2026d04b98f821b9bd52d64fab129526fc2e626fafcc92d0d2e23a33bd,
+            0xd89c4483e40c415d266d3c7f2ff6d1d66412132770be71bcf1178849502d231,
+            0x13671ddf2f49e97410f41ead0e1a80564d862771c7543664bd20762324fafdbc,
+            0x19694e401d2bd6b6ca4d8929129a85c9e8834e40fd1f6089da9bd69f66f840a1,
+            0x1a801c574279164c937f3798748bf115f09f56044461771cdfd67c9606f1a170,
+            0x7359e7661550f4af1bfd7620cedab2b030fb9645b06945a8c166a617423e588,
+            0xdc31ce178e60f8dd171002e2e5849759d9caefc7dc7a1fc551b677b410c4274,
+            0x3b7d51b2b8b3390923b28d0f1e181c8378bfd0910f03835a1edce3ded58ffa3,
+            0x20feaca74003f750c7d517aca7f2c181745a7d26a47051da7209fd1b3ba67aed,
+            0x7c71a9d84dc8d9b2d223b3302e1804f6d6cde6702ebe991c5c976a4aab0971a,
+            0x1ff2e7a7045e92d955d0b3a679eb1168aaf735a7cffec5e90fd0e47fc946ee3b,
+            0x1ccad4ad13abfe58d0a69ea967e9477f20630d928dc93970033796ca8049edd2,
+            0x1d2277a4c8ac3e7ae945f05461d7a72caeedb456f30c1e12911c8e3dcc3a66b2,
+            0x2ec2d28dcd7e75e100c13ef572e9e270d251a774f44b7c59df767ca50fe10434,
+            0x2ea447c02e059970eb92d1fd14b1ecb189dd900b281e67d68b3e742523c6a801,
+            0x2b4adec5ee014b305fdb460cdb1ae30796202ec0fe11d13c23dfd65703f0434f,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1784bd17cb0965878549fc4b0e1b40bea37668f94d8da890caa7bd27d22cb2fd,
+            0x149f1d9787366b84b3fc40ed430e96b646eb16901093590e7b68ba3601c364ef,
+            0xe1161f13b91ea8432e12df3ab58706410da5e6a10ad20b1f62d1c34c09cdfa9,
+            0x7e6d996431e217b60bc4d3e74aa3c337263f1183c92cc73807d19e59c4e6804,
+            0x2086834b2a03db22c71e71dcbc89688aa02cc362496e4992be9845f57e8bee9f,
+            0x1a593864d072783fe6e1ef8ac83665aaadd593b63b3dd3d4919237bf5b2c7106,
+            0x1570ec833fe8f21ec48539c6ae273c34cae3bfee0acc5578c96cde92b493680,
+            0x13b62a93db33b6f0e9114d3f2f19c083b397a193f6ef0f5b087f2079c2581a9b,
+            0x2ab8bd24dd963ee466e2e0c3380cc88a4f82397cf9f7dada2d80ad5ea21db875,
+            0xcedea082a17bcba725bc9633d2e5e67fcd43650e22b22df9aac3037daeef8e4,
+            0x5df20d895beb2374b5ed6d81ed5494a6ae0e9c3bc184d7861bffbe7243b616a,
+            0x1ab529db00143d7038a6e01e23d0e9d56ce89bd34002727061c8e56944e4003f,
+            0x2548c562cab2de540520c050393f949e10bb8d9ed4c3fc387e21e454f1ac83cc,
+            0x29042d35cc97955a80eb09f15a15b66f0c4193a58193a080662b6a5e79e68051,
+            0x685b96bc1e8d70b1a7b70216b5c74a4e5db315dc36faa59eaa39f2e0494ac08,
+            0x2ddbbc66fe69dd188a2e9c306cf6f7de9faa106756186b82f3fb440dd0b912a6,
+            0x18c70260e52a67ab417aeea60b5d3f88eaeea2508829ae7ea3c063443cc0945b,
+            0xfd423845f9f9970561e33fb0f913821e1e3180dbd45815a9238ad515543a634,
+            0x6715e87f1daa773cab6957c11605b0c6ff2ee937057373dafdc2f284d95b1a9,
+            0x20af32b63bd2e6aa4adb6d0f474ccd105b78a2dbb269dfbfcd615d4ccda0666a,
+            0xa4333899e37c411cb633251ea98d8858dd944f73c4378b66fdfa5904ef8d9c2,
+            0x92b057185e62fb11b22b5f3583d1943d561f827c54936cf20d7106b9416f3dd,
+            0x1eda5120d5fdf5f2cfc9e303a45a4ac8710bdc7a9c28b5e801eb248f60ae08f6,
+            0x1282a8b79cc5039edc8852ec1bbd5835f3b8004ccbc9a669f88a331e966db3d1,
+            0x2335e0bc60883b59b1390d2b3652ed0bef230324e7fdab725a5d4743d5fff8c2,
+            0x2e23e4d93a4b72ad0551b740879ffb0da4ee65bdc1ab71f8207d2d9da0f26d01,
+            0x1b06fee7ffca419618d3bb646a203316838a684e7c878024bc058645fad01e55,
+            0x66ddb3bad4a4b1374fed6b3a88b1bdc812ddf9a6bea1b028735dcf90a77bdbc,
+            0x280b71aedbbd3761124fe6fad719c6930ce0ef6695938cce777ab77ea3536637,
+            0x21d130fa258f6e1fe201071b3d0f643832f4aad07a3a983ea00c26890b546e5b,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x305f7337dfc2c6591e5b3d53a4783555e1ea91efc44648529448fa3e463333eb,
+            0x1d69e17e5678ac53a1c046ed0326666c84b909b85e5aa9e34e516d26ab655573,
+            0x1f5d0bf5a9c458a3c9c9bbe3fe48211a1127a176d4f54547aaf34589bf9128c2,
+            0x2385bad332ae963b60ae73862cf86c5f723dfd37e56b05918373912d8f9754ad,
+            0xd68dbe874d206f45efd8724adfd9b10999a7da1226c394c4e7959269a17a79c,
+            0x27f8bff9822ba76b43b54939686caef37cac685d60efd3bb87b468808b480c1e,
+            0xf2cbf2fed229b81bf91c08a642730c9633136dcf1e68907c192e34464560b24,
+            0x27e6783451cd61e229f062e38e360d9d022cc244222ff2128d4901de0c5b3c1b,
+            0xb0bf852c95f2476ab5280b94660b1d9d2cf5439c34d7b6a928d596b13555f32,
+            0x2b543c7e1d2f84fac470489446df876c7f64956d82c8897e268cc4e2af130a2c,
+            0x4367a2851e9b84ece7172ed126f7cfb63d5fb445ea19ef5a31a67517afd2fce,
+            0x1dc8a2abfce437021fed52e83b1e6708a20e07d84206e4c6038bb9ff36b325a0,
+            0xb217141d35c2aadebbad8d9a426b52df23d7db7c3c72f0914963046e120d5b,
+            0x10682c3505cec77ba65f4af68963f3310562527b2bf1c812c04a2eff94d33376,
+            0x2f3fa61cf4696622abc02bd664be628da8ff5f9b49d93db65af12a0ec0d25593,
+            0x3798c88da7c1c70322f72888f6fd783585ad279f4cc06029f3bb23f3c32fd3a,
+            0x154b3f2f885e3d61fa5c27875fc9b03509b9f36a18981b13e1aff4d29b7d23af,
+            0x45e3caacff06ee391f46ae43cf78a2ba1e2134de0405120228cbad0694d2fdd,
+            0x21a443268cf1db0a1edc3f7c366de6cbc690e1939658278de9679814a5ad4a30,
+            0xfa574382520b0170ac21d000d9ab5d2523b5f86758226d49bab96fc1ad9c59b,
+            0x1b8f07226473c28fc3cf78ffe2f5fb3967b6beeed42866814c648f5d4adf5fb6,
+            0xdc48483de7d0df83232e5a41cc287618b7957ad2fa3db03556429286ed6a2d8,
+            0x2327d3dacc8f80fa05d075b7f9b8544356c04f4e600f53d8d4d2d0f147590eef,
+            0x16a6266bd6ed429272c69aac579c9032d9be7e86973b578f27d5cb8d2f6045da,
+            0x9eb4e66285aa7cbb62217465768138d73953baf7eb68bcad15b749419255e25,
+            0x15f3a6b27c8a2ce27e931cb599a0bbaf6042cc6f8d411d2daf1969c02c67f5e1,
+            0x2727c9236d43b41a34c74c52420674daadfafc76eb313b17fcae0e77ccae7bfa,
+            0x149bd00eb1da39e22ab0d8dc78d7abff54bd9c13ba38a6a531f696cc993a3f96,
+            0x13ebcf06a5c9485e1767a124c3e035223eac6be5816041fa077d5cc6fcd10228,
+            0x22aec7f8873c75702e0c55c1b1529b1290831cb4df73c3ae6441da67c21e8169,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1d45f9fa11307f6de88e220e633519a3ff18d9dd8071a39b38ee29d5910fac47,
+            0x215ff3e875d70ad4b7aa08800aebf47f83fdd05a246186a8ec09f674ef5aa160,
+            0x1552de26acf195af643fa2625cbd3e1723284c2cfd05bfbc23495a0cf88aa369,
+            0x1f9836a1eabee49b2d2e6cb1f1f666753813f5201323d302faae128f08e45168,
+            0x1f8cf510bcd58b2fe258f3f812dabf08a301a71ed710d4647cd60fdf5beb779b,
+            0x2c446f645eb661152de44865a3ac149bc20a76447616094884c9b6515ed45674,
+            0x50a3718e48640cb644bb787fc184aa61f4e44044dc0f3f3006ceba81b8dcaae,
+            0xb370b71f98dc10706712c7f348474fefe5dd772f6786fe96cce94999cb09fb7,
+            0x287473939b5c47568612b150cdb25b30808c058b4b5a3633c03af83f7a7e26f2,
+            0x1f5ec7598f6da577826ac5afcd6ec3721b963562999125d9d356eac51d0d513c,
+            0xa9850058f74f3196f58585e6fc80ce0405dc510ea89e33eb1a9c87ff91e58b,
+            0x22227d59d1ffc328aee2ff956f45c3b6adbeb782538809edbb6a1e70f262a23,
+            0xac7b869caf4e71585f9f567e94b1ee6e0d802ed6af49d30b24d41b1c784e448,
+            0x6d671ea1fc8bcd0d824e101c3732425de5a4435fae1bcfd1c85f501ca205d43,
+            0x6cff4c2918d4ce74f4ebde86e5951ad143b09a951d136618cacc9cb40dd5799,
+            0x2d9f0ee4ed51e979a0f1a582077e8e5f6669f89d79225a7da2687446184347aa,
+            0x12dc6ad0e0daf28768e85b026179300312feb26584b2a4b50f830499e14f5e06,
+            0x2f94df6b211d8a8a514facf931d71a3f23e3d9a8a51a11d29c0221fc9873d756,
+            0x29ee741287f545a19cd02af760d56286c27ab5d4122c001fc297d43db2bd030,
+            0x7d43ba525c44a894d64b500aca3b68f2e3c2577927390f60181ed36c0df68f,
+            0x252866633477b3aaa0f9fda731b4dfa0d78905ab39c177ae1f4f76da5d9e5547,
+            0x2308ec0db73437f83200db8f914733431ebe5149e61cf3afe3e67304c8fa8d44,
+            0x517e4ee288992d99e59515e91c5be6957e839b8ba8c9c7430fd31eac44c56a2,
+            0x2ab15d8887615c04e22f1e988b9d8450cddc2cfaf2b582bdb006204a50e596cf,
+            0x116e33a713748ad93004391adb07d5ca64962c8af2a8835e50eb7e1b6662a557,
+            0x68150e1248e7ae44ef5619127e8cc28616d7277091afb4c209ddd504923f50f,
+            0x1e9e3d2964594dd5bc87a93e4bb67e6ad71b037049f90493165954fcd86a1e4e,
+            0x1751f2e99cf8cf643a5ec6b3cbc81def5aa8679977cbd2779f34f476f9496911,
+            0x248ef2921bdf968c74dbadcae0db56cb022ca98b983628d7110c724cdae048d6,
+            0x2fb6d1bd57da1cc3610b201535bd42a2cd405ecb52b28c215237581257354352,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0xce40ef4d37ae58008a4d1b02e78aa4fec563e8840cc28fd1af61144986866fd,
+            0x1f94afec8fa62f53e4bb20f756a08236e40e98a346afea85c78280f0ea33e337,
+            0xf2164352021aaa641a7176ca76674a465b3b728d8af12c7b2a5f9339d6f5e47,
+            0x1b86c9a7cb8287520b3943987397e8c7a742f3059fe12bea664989ae08d00e5b,
+            0x11e4db5228177f30bb2a2f96098eaa7ea941229180bed1869a0d0be04cc60b0e,
+            0x6378bcef2ce91bf24365b51a0970028dda29ebd7da3054a8440207c15eda844,
+            0x192ef0949ebb3224247a83c74eba36e47252f4dd8c3f20eedaa39484ea78ca65,
+            0x21c1cae79f5fa8283d7a8c2acb29a4f46a76b8b3f7d51fd93941bdf32d38fed8,
+            0xfc260daea1f470febcdeb84cc58f03b1100ffe23ab52e88a7832c18b1b13213,
+            0x1f6f7bc07589916ebe3fee5025672ad9af9a3ab798fd01c6c2228ecca20c395e,
+            0x197e205923ec11dafeeb697b87ad973ba4a85d9d9d3817c364c3609ff78c18dc,
+            0x2935c393a884a244b08aa314b2d261c999959d415d00857cd883277d439fc00a,
+            0x2c639ac544a75088ec7aee01a854471f7b6538d83fc1c7541d9018c0a87b1916,
+            0x25b2c9c2f413762e843c10e546ced0572e1a30d1a9b2c5c781d24de864ef4973,
+            0x1d28735cd6da088ff72fe8cd4eadb8bc28268e15a9d754a5eede53d3513e0317,
+            0x205c309b41e6c8bf2fea4671a502abcebbf0aa33c807369adb9869c0d0b1661b,
+            0x2e8e8dbf8f9ab3be24fb4e8b95c2188103a384cdbcc2b65fc5b931a730416e0e,
+            0x20e1291175551be80f70fa6ce6e111ad5403d1765c4bf47f611103fda64b098e,
+            0xba9120de0cb289db8a951b5d348853a839af34529c972296703db5c217054dd,
+            0x2898c38f27c64311d90346dfaaf3554ff6b104e56124b35af7cb322402264620,
+            0x286e3762e815adfe1ce18e59928e04beb43dbdc6d4d1eb52b5741326da3c688e,
+            0x2d316495c1c92a8ab5fc456dd8e7b1ea97f5cb70e90624d1af3e4bbc18cb75ef,
+            0xdeb856e2bb0ca11bf197de3dbe8e8cc5dbaac998dcc275cab91acf7af3ff347,
+            0x247b87e0ea690afabb1beeccffc7c12fb20f31484d684b97302ee67f588d1eed,
+            0x2003afe0fe29cee7641b7f41a31c8a2fc27bdd619f85a8fe53a4536884d684f9,
+            0x25d9c2e2d66052c7d5cf3d56c8865d939cba18e0bfac725dc04f468837112253,
+            0x1a711ba1a3eece6595c4ee4dee4ab3e865dd77e6b58797c3677e1f494d13144,
+            0x7c74f66ff199856f077f29b06acc03305bb03d7a1beae045e199b9596ac9a31,
+            0x1a4d513506c6ae66d0e1a077b9e9604ad4359a6cba7738d9721db0ba826fe704,
+            0x172f82b5caa7f65eb8044ae3faefe81d837e53b8e615c2d46ed02e4036142ecf,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1c81a64c5d581191f40a709788a4fd607c71e461de2ad166b9bcca742e0a9db8,
+            0x65284960bf09eab2773324ead048c3bec54af7ceba50805e3532a5a11b96b94,
+            0x234f635b921f9d7a056c0fe63af46afb8b9b5430d81905bfb16ef051369fee7b,
+            0x1488199577c500214d8d9c4bf6d64db0811d5e69b44f3b86a585d9410f875be5,
+            0x2237a1388bd8962921cc637d8a4c5d0faa6b5fb138d589db98a508bdf9c225f6,
+            0x1b89bdbe9e9ab40f2ac20793f4182a7f33ad93e907304fb0440d1e7d40063ed4,
+            0x20bfe61092f2e5cb0508a73ca1dd8983127a395f6800ccbec4ed56aa95ad8c7f,
+            0x5acd0c7611cfa9170896d7606a8f5c672883ceb42c2b829c29c8dae08df2ec4,
+            0x2e3a22fd34491f153094c93bcf17a8e45940e4a1191fcd2d1741ef841681e0a8,
+            0x26504b2d5b079c4aee6f588f825b8b28c337137e9ac1f945f715b85b5cdae979,
+            0x201fbd4f4c9cac24b23d8bbf86efe15d86abe8f18838bb542975fa10e9f2a895,
+            0xb13dc6afd9a8566a90cb50c82f1876fad84ffd092241c028b9ee470cd64cbbd,
+            0x9c0853fae2070c4ea816a54daecef43a5940c647229be0fd869ef36f23159e,
+            0x1a926cac03b4e6f41bf021460cb129cb4b20253b3c172a6f2b531d57d7a7d645,
+            0x2334c0b56015f6c5a9083193b17d225ea2d977932521f5d7e328c3f0baaf7a5a,
+            0x2cbf73905b5489ed3b0c5763eee04fed6594411a1381d0bd617a208a9e38d208,
+            0x1e06c4d1e2edd5530f226649871f8fc83b9e7b5708d75bdf6b9a31b963be7bfb,
+            0x260c2e5e5364bd914ccbfb785d01ab898a2a961daf708f5f3e34bff953b24b00,
+            0x26689f7259e1061156947b136c0dbd5e8c2c1972b4823f4dcf04df33e95532cd,
+            0x291df0e62b563da670d44db58d0060e20935852eb699daee6e342b3c59b6d73c,
+            0x14e05591b9b889b8899134c8079886d87829cfc39538b78b7a6378b30be1c683,
+            0x2be6bdf824d2cccd56cec6d1953e0f6b3117f6cba035592433b7daca12ed43db,
+            0x1dbbd7c3c3ca0eaa01cd309dcc57d0c6331814ae9640071cc6bb9483ab6f9a8a,
+            0x2227b2d0979591731b87cef94237e7068a5c5e03d609e61df240b7f7944e9264,
+            0x1d351ed4b59e46571e5727529ed92e6ce55aaedb36e3d54cbc6c2a73fc4a2786,
+            0x2312bb7364e690f64210acaf695e5d8d03a9059b261b9f5bc2fd2dd78ebfe499,
+            0x1532d3c7fefda9a7e81fc949f72956bd5f6d55bc4be421d27d64847d81cdcbd4,
+            0x8916c1ca3dc2d21a671ff4989f5f7ae581c2102c172054472cb63e25fd58101,
+            0x199a3556e4c7a370f0832fd385952688d469177c78a0e77107ee586aeed025ca,
+            0x4297e87f69747dad1391582ac26a54249d004fbd16bfc50ec12d7e6b95faa92,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x63db3a46c3e1e822357db637c8910722b22e531454a1da26f2768f59a8457bf,
+            0x82793e5ecd44bfe57289068ca1bd6dcb1a9dac086bfec2ce99aba4d04c46b2f,
+            0xb5214e4d1f2227947a3aa13e7b57a4d85dd94df40e39dbace02df0e7c0eec0f,
+            0x15fde89fae0bd5593e8f2bea040a6f837a7bfd5c5e13b04514c39eb1ae15624d,
+            0x27e7e6eea879199109f7a165585ffcb5da626a4d0c39b2681fc7b55402510f1d,
+            0x82b46075b3da1e178cd6367971caf87a3676229dbc745e031b45136618255db,
+            0x176668330b14e97d4f77547f3b9f430b7fdcfb1bfccd46fa70839bae63df4872,
+            0x10104450f5b03a0638bddb9c1d9db41998094de2cd8a8cf7d3f04143122e5a9e,
+            0x18c84287abb1d81afb7c16b5380aad2edf054867661c07e44b252ed26cc7b68e,
+            0x4d7f1edeed756ae0598fe4b0ff7edc488b75f0376b1923fdc417fe7df3bae7b,
+            0x16b3bcf2e5fe28543072f71ef9d83e31887dc632c0c86b4389ee730449207658,
+            0x2f29c8f376d462946533c1f349391834f2ec826c08eab0eee6a263f759a43797,
+            0x20d394abb3b23967e223f5b9f0a556ce582128c8ac5193f66f8c959a1efc3344,
+            0xb207d38d762517ba978fd184ccf152ba1c46333dbd979194b9ff06b27a792a6,
+            0xfadffe100a5861695b7059f6ad8e0d5426ffe92c2bff0d81825b72f6da517b0,
+            0x279aebdde647b4118234d886bd169f051ed193b0edcf46f54a8aca2f4d3cdb4c,
+            0x119f36daffe8b2be75f4e64c32fc2ecd118f319409499fa007819ce95ca2df6e,
+            0x1242a6c181fe90f95fd6bdb02918b14c7bcef634ee3d02e30bad0caa161b1bb0,
+            0x13b4546c3da77fdc8779f6ab0d770bcd3cd72d927c72c69fc1dd01de9ead8dc3,
+            0x888fd59a93f104c423ecc2271c5926305abadf9f458f70ebbbe28a6fc401f71,
+            0x25a8ff35f85072e4f8ac148e53991882409a73be3156a865cd00ce4f9fd05e39,
+            0x11ebf2fa3b30212183347f0fe5632e3ac31f93a68a3b8ffb47960b505601a7dd,
+            0x24e547cf052f879aed9d43e772fbe7809c500603eaf4ee69e41df75d2cdd213a,
+            0xfc85a22c05e5ea21235ff75ce1128c7bdadfd9fcdf18f1bcb66e5eeb76125e6,
+            0x2a9f2576a85c827399655ee856b94ee757335582e476846106dbccc7028bf19f,
+            0x13a5b0372ba5ed8b2718e46b25d797b56a6cb0a2f03c621e8969b371a5d1f2dd,
+            0x2cf328cd5a7f16316989013b1db59f8e8c148cea1a09bbcbefc464ec3577f253,
+            0x2c6f8ae3d08a528068b4ff4da059a1a0dc88e311f87a1a9c5ba99738369762f2,
+            0x2108fe376f8ae97694e36f575eaa0aa0dae306505c70d5a0575f5697daddf530,
+            0x23a2991e713b01022cbb8d2d3b81cc5b71117d663e3be0f7153757231ad22cb9,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1e9d125fb7c35dfc0064d4351a05731b95b37e5ebee77e1ca055ea754902c75c,
+            0x119d649d362c0f09efab4076c479c9833ccbc80a2f0da6c362d653ecab381599,
+            0xb682593d09250dc35e376127d33a34d30ea21f79f3f112066618f947872c35a,
+            0x16670c641709033c5f1bb409f530b7799d280e7c9025defdbba706d9e1371733,
+            0x16013d4393fb316871311a22728aa5de989bcd030f2a54ff08fbc7317375e8da,
+            0x2a7d4518b4393070d22a8d824b75d8a474fef8ee3eae40cacc38d40cb525937a,
+            0xa2af4ab955f7dc6d09a9c72bbff55d30ca01013651b387523782487fd6bfdb4,
+            0x4fcc21d258b270458eb662ec8b16deae2c8039d68ccab74e19b4573ae413940,
+            0xb5547d0028fa903aa9a2cf2eb9ba2d303bfff9ceb1d4070f87cb2821cf684c0,
+            0x4eb04b4aa22c6ab9e0cd8c331a04aeb1546b58540f460621f2696f453c0e0e3,
+            0x27757b5fad20eb99a306317b872275532a31ae4ac34dcbf20e80843f2511af23,
+            0x23c5cd44bdc3e761827ccfffcf09d470a55aba69e7ad0fc83fd2eb7bfff41e67,
+            0x21bb1a37cc6a1ca1d65febe7d1868754bf85d082215397b8985df2fa8c47c25c,
+            0x2050602a2f6da4117d3257061d22608527508e58e8a578d00f2c3685f601846c,
+            0x2a896c598d40d992207040a5f1629dc61549fbb0dba65e33a8cae98ad46afc16,
+            0xb2f10b968c76b4a1c338057e1c67985cc3f571380db66b1c38ff9f6d630e34a,
+            0x7a1e6e9dd512b10eb0817b56839e3bb85b736442b50f32e18f07a5ebdf3c191,
+            0xc0a72a48434504036597a74ce362796f9021d0dc8d318ef086225a55ca1a9f1,
+            0x28e3e34de5c1de1c85186e7d604e5e4a24ad603b676abbe3674a0ed2d802be72,
+            0xa6d55bc7826b1e2b03850d677928f501bf4c6398104c009eccbc2b2fc5cbf17,
+            0x2c042a68d06b5f7110513182d5c54efd6ab0dbbdce57f1eeb5ab12cac26322a4,
+            0x18cbfbb6607f28f928f1fa2ef21ce8be9d4719a8d7c33a7fd1279b6722f151a3,
+            0x2d7e6e039f81c66f329b2dc40ad3b116bb9bf4db88bd3e44be39acb676ab36ec,
+            0x2ba3cf36a0580465928db18f630e47aaef388d04aea7f10ac3c600df5d2108cd,
+            0x2403116000d75fb1a8bf3d0a18ab068fccc0c149c46a935d91678c45fc948b2b,
+            0x62b5c358a18921954449fd14b3a2dcf3f2974710e9616b9805f715d7a9f9e50,
+            0x14307431f749d428d15fa3fc56a517c677c22e0a80bfd0fa2bfa3f35f323e156,
+            0x2c04854c96aaceae379bc0f7474cd235436186a5f9f01f4d059e0fc83037a57,
+            0x1ba6107ff34a8cb1ec3b4536325f2845a05b0c4b8da6dc5c0e0327419880b484,
+            0x1e7b9fcdcabb49b7aadb17219fb4a0bf4da78d4dcdbb6d1437e7fa56e13ff4fe,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x26968495cbd99f547d94c82d24b714e3cfea387ae1112be450ef48a93752ac5f,
+            0x1ddd4f2ebf1e1ee5b8b6715e69df13d58c524c6b0bd5120777b78e26a054b978,
+            0x1771396e072f342e14fa40e37a4f9e45a385b5badab8a10b8bae6bc325392c75,
+            0x1334b3e12b51d4e658735203dfe259c022ddc5deac72bfc942bd8970c7d3f31e,
+            0x2e7aef8fc027f0f4ed42c4ac674ff86a2314b9a88094a214325ae5f7611d3f5d,
+            0x2f66d8f2e4c63ceff37adcb96812010dec93be84a18b260a659909f18ad00789,
+            0x1cc80a4e8114c2086b90d7c7f0f33007d33b613444a63823b465939af409705e,
+            0x4eee4396019744ef67fd43fa3739511a2370f23f80e2b5ebc5c5a1c9655135c,
+            0x28ba26ef284bc535f288779980dfc0da8530588823a2f83a3d5edb7a5a25afb9,
+            0x2fd84d8520146a01398ac84f33cfb557ac2850195fee0c5b28d2ee1d629b4d9b,
+            0xd831e57b1adcb20c227a1adf2a6ab52a0a1cf4104e493c327cbea8897cbffdf,
+            0x186b1b6b8ac98a038ece2b61971b0c83f28f32e097e28cdcdfb07aa8e685030c,
+            0x7630c5932b486e74bfccc6d06d6ca99e499c8913a3a1a2ace3f6546696d9975,
+            0x2ea3fc0c165f38d9aa02eec6a46e19a5854a0bb2584c2d35354e1c814babb896,
+            0x1c62f3196e53f51fcda6620317b4d088d2132531a7367c8e5793bfdd5dc07395,
+            0x1f352e27dd80d315a273a3ee1a159f18875744c5169bfdfa5ed6a29113caab02,
+            0x193d8985e3f9126daaa4ecb2b4fec04425eafd71dafc86ff521d81fcf62cdcce,
+            0x2271c906b9605c4dd48e925fa831f1267939342ec2a6f2d68dddb62a5241bb94,
+            0x32817d35a0d57fe0fd10584116d3b5c48ddfd6ebe990e91ff469b1e679b7df6,
+            0x164540210c18239fd0e4301e0e729018a7f419f438fcf829294179bb2c076221,
+            0x2de749d2d5c5c9db3652813190e49ecd8ad1d3b3ae308c3c9efb6e98822e8dea,
+            0x2a562decd5b704192adf41195234f4e1bd8d9d58b4cc48cf57a2ec9dee7ee410,
+            0xdd5762ff7a8f652831aa96e9c74370e71b2e0fa1ddd1db85427bd2e79f84724,
+            0x260f24c836dc07efdae65db907fd8390b38f5341faed0fc553cc7c0ad7fa549a,
+            0x1a9d4050de78961851fd12689cc0f93fdf5278e1430d7295cf620713b01f2901,
+            0x27d255a40de38041587f907cc4d84a8ab1a5ca07f6abf6d5342248c0df6dc441,
+            0x2187634627013d30fff1a44ecd3d5a018c06352be5d480bd3146898cc004385a,
+            0x2e0eed49a09486c41002557ade478e57b8ec175f9ca36fd481536189766291d,
+            0x1abacf3780a60d304e373bd2f40ff6112b068c0c5d5966a3327c386e480c9181,
+            0x2839a53cd148fc18db287c3ac9cbefa3a479e414095fe667b74151d2b78c6342,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x121ab2b6ab8e2c5ecf89dfc2bda8337d7f52d76cf7a2e444859fa1b714be8f01,
+            0x23a405c7644f6a9b7106d4ebc99b0f2c6c5543352d391d31a2965478230f2c13,
+            0x3de1ccb8e26e8dbfaf06a08bf5189bb38e8e5cf181d154fbb0c4afed03d551,
+            0xd594c3a1903abb67bede24f66447fa6cc8f8696ddbdd54830a32ef205495e43,
+            0x2d13cfd974b0624734fe4a5127b23dae16f69033c9b1b0d7a8ffcbb55158737,
+            0x4ad4148506cf6e6d9795ef784c6c1875e322ab0cc3b6380311b19f9441d8f82,
+            0x5bba1c4d35ea9bdb593e19848c3510f2450abcd24bc392456d97a6e4f18e49e,
+            0x9236c366e97d741479d565c45311478a3c918e62d52d12c5f54b7366c5bf57d,
+            0x2a5630fe33c0d5616c41d0953c305e67503306f2ab6942e472ee89cf34e4403f,
+            0x2458e51f0164821f0ed092a42b94fedaf0d801a9e7baef3ada586ce5e8cd3c64,
+            0xa3218660ff4767aca5b77aaa3060a4e1fc8f5fcc0fcd6813c9892deefd7e96e,
+            0x10c628fb41830cad0df1d4045657412e0833451d9f6fb341987afcbb98cac300,
+            0x365b8f2fc30b7f0e91046966b67e804b88f2e1eb7ec6c132456467e05d179a3,
+            0xbde78ed9fb95b8dabde79d55c92e119f0ca502be0ed08a0dc381f89ad85cde1,
+            0x1e98a3f1c8e8f9a35eeac2782615c96e12950e627ba89a9ac0b873797d30107f,
+            0xc0308caff3a47cc92f51163e05a00bea0517f621a4d69cb9e680c79577542a7,
+            0xbb209639cdeae029ede39f912e33007334877c0004842f75035a7ee26a5e4d5,
+            0x13ffc065d98f8ba997a11cab00fea19d1efe62e20f1bd7103de4858e210b011d,
+            0x24ce589a99dd7149b8a0a25f95e766a44b081e5d475d17b7cec54daa028418e0,
+            0x2ab971f8aa28d7fb11b7cedc6d85bfb947bd64690e6d6cc0fd9cede6ccfc1e10,
+            0x1b2e15dd9e25ad8b2506ff8f0286f34d26254d2b4732cab5dbb713d2203ac283,
+            0x1f1c3559f788fed19f86c71628547cd1d5092b0d30b4be4ea634b744923cea21,
+            0x1c83b3ff9fa324bc9a5316f0a85a8657123a493a9b0220006ba1100a393919a0,
+            0x28958a5831727ed80010116885dc7c66a1c245f6fcab56362c986ac87caee035,
+            0x282c38627758b1648078b241bbe3557375aed2e83f18278ca6c962963297a142,
+            0xddeead8fcccedced8e4d4376a2bc530466bef45054731d5243454ff4acd04c1,
+            0xbdb032ee13a67d9c75df4c44570244e4f78e19a039b30f9f12c532e9b0ad601,
+            0x651ba2f04803d5f77235caf50305de5e55431a6abfac178f524a5a01fb4f1b3,
+            0x6541fd461b311dfcdc647b2c33e272d9a3733b5ff38c7e0a2cf51a65e22c19,
+            0x32293b2b6e94545d3606b723f7a3149ff5d997ff1e8097359e0e0eb2444fab4,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1e47d96559f3d9eb6bd2fafe210c31f4a8140b853eab986dc12ee2527613016d,
+            0x1aaa3fbb3f33fb63d4504fb8ea859f4156ee20b59e198b531546e6891a2497d4,
+            0x65c97f1a22d2c6561ed6b3e8bb68fbc299fa56e40bbb54d49e02ec33ad6d913,
+            0x2ccf556ae01de7dbe15ba504437271b8a33651d5249fc5282b8cd38fd23ef378,
+            0xab4b8237c68daded18da81c5a6bfb657b4d879d4164db2b2e6ee4b854f34933,
+            0x2c3329b267d11041b788317f56c3fb8a685b69c0f782ab2213d393befc80f0b,
+            0x22f60f1fbc046baeefcae40d2b7843cd95c8dff7d49e0e18851f7fdacf3a4eb4,
+            0x1d22dc88706281f80405f66fb60fbe665639969df32efc6e47d33635da644922,
+            0x1aaf58dbdd1a14018d33f48de1b98e6f7a937d81ae46aa5313e9a6ad886e7f60,
+            0x6f13d3dd83b99f56b8d840e73d3c695efa8ca7a38a891c9df57fb945b8507de,
+            0x2d7c3ec573e9cc8350964a20d0a2ec03d2e948a3f8eaab6d520406808d80576b,
+            0x293a2e55abaf167cedd278dc3d355975bc1f29dc3354310f21f9ce01574b0d23,
+            0x2682132e373c18a17f78601edeea4f8772240bfb889b3db93b2e8ea10b2270e1,
+            0x301508db6c1f9710285b1e6e44d46a133310c29c28426d90417d7c21e4f0b20d,
+            0x1834c2d44e5774a7e63ba311a3896fa595c04c96df216e3f04ed409c2de9b112,
+            0x76c49e633f12eb93ba03d627acf0c95d1d623b6cb42f773f3a20e02f23120af,
+            0xfea2b1df3510f6e74dc89be1a061ec7f8255cff0eecea778e1cca99becab586,
+            0x19c3a8e23b946d64526696670270f49298ee4eee4402888bf2ad3ced11f7ad53,
+            0x86cbbeae69e83af8d6af50cd4f161f345017a925318acc46be5cca969697042,
+            0x1a8a851cf400ea4e9b7a51f0bcd5b636e7894d05f3e0faedeba662bf80e901cf,
+            0x1fb9f1ed4cfe567b8183fb0f9f5edd26e8af56bbae47cfb6fb6a2c5323303797,
+            0xfd5bdd425e00b499e57e34f19cfae9bf0396e405fcd9b4df234a73d15f96f03,
+            0x2dd4591301dce89c25a6b690ce98e4cb6c5603505055f6c84e9fb8980cdd3025,
+            0x11cbe00cf364a4bfa71c70b6a4b180724765a2a4cc0f31035e44cea45c1719b,
+            0x1919aba9eae5d5cbd57d3851ee4011af47be08e151339d0fe9b32602d1fbb827,
+            0x6dc27862b0c4f31489bd8c0c6e2a9d8e1c8d52284f4f381b88f6ca94495f798,
+            0x1911c33355ced9c551e5aadd528bde012e913b283a67667f4f269675ada590a0,
+            0x2facca82fdc63330a3628ec9435d193a47caea8fd2de6617d601bbad8adb0faa,
+            0x168bb7d0c7b38df856af9831f4b1da200df248edab92ab41e638e6800c57252e,
+            0x33864c3cc0a4cc3fc23c51ba07bd1f797a55394f4e0c39ca4dec1dfd6473aec,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0xc732637dd53a9e2035cb048fb5ac32b68613e0cd12f68a8b8d07fabc738cbc2,
+            0x2b44e82a5cbaec37e208762b75b37d4ad4bbc4d83192241a4acb22383f26dd06,
+            0xcf7e6a8815f6122fceeb778851d85155384796be9a1df53639f5d81631a2555,
+            0x976401c8c12d415f389d4bb64621b71f225619dd93897525be9e8134ab912a4,
+            0x1a23f2aa5a0ca939496eeceea3d7a9e386f641a248fb689682a8616ea98202d3,
+            0x1295f50377875eea2b8757bd93e3543b59a727da7874e646cc3ef523ffcb79fd,
+            0x1f4a65f81b3fe858fee5fe292da8d2594efc08a385f89dc60be97c9c7cbd0032,
+            0x12e6d92557037dc2fc85c17c4148e9018fca489e90ea096ea7f400c74297a2f7,
+            0x2f1e3906e4a5b87c714556abde45934dad466c1044609b2c865e5a835667b38,
+            0x102c4d0a2eb569486e7c6c7893f6491c03626259388fc7d55b519a55e377a921,
+            0x2c427c75876fd20b334a45663dc28359937368097c46f7b685eb6e3fbda1a6bb,
+            0x12f1968b1e77f14f0f2e90f5fa44799cf2d5cbb3b77558d1493667db2ae55267,
+            0xb8730598feb9ee21584d55d5447d8bb6540b84e40c7d4f14b6062ec02ae00c6,
+            0x2e13857a53b9dd57a62a790b221ecd3d8ac27dd7ddf4f10ec48e680f1a17041b,
+            0x86f9752b777f6b6260f53770c94056c12f444af68c40c75bf7396dc1ca7ebd5,
+            0x144d5e3d11651e180a16152b3106f937942d48ee746f217a89db2e410f06e08f,
+            0x27956794096d302fe3cec23f3cd713e1e4c7ebf7a9599ac1b3734cc032811a03,
+            0x2464182f248bc3f32e7d5650870a79c371dd8fc8d67034dcfca621a1f1bc596b,
+            0xa75f1c2e431c46447da58c4b53b5a707030003dd525a6746963b144c9a51803,
+            0x441eb396ba8329b88880db7d7b29b57e7165262b02108544170278e444e11e4,
+            0x1c271f16943c48bb48f4e2d178b77e4c31f22355466d641974957a5804e78765,
+            0x209c46dbafa81cd4c62071ab840fa1f138a8289e87150177ce20c6f9942dff38,
+            0x3002dc8c48624cf7f6e207ed3dc4656f6c6fd56f260c96c9362714d4cd667726,
+            0xfcb2bd431b6f99702c0f6b220885e57f93fadf7a8d3a365aeafa0ceb1fb7447,
+            0x2a74154c3f7dc063f12decedcee953b7e7d3d71dc48f867f72c8a75b5dc7ef62,
+            0x129ef0b882070816acf093a88c660245a4e58261b307457eb99fd6c697f0ed7f,
+            0x24f76ebf17e1a43056e1e4767cf4aff954b2f9fde49f05fda6c18ee7d2909471,
+            0x1d099f0d638efa534bd9c758f9856a7943eff18350feb2d90dd7bffc48e80c16,
+            0x2c9f441f31d9aea42026c0e7cd8765aed321ad391f4c869d87118b7a1107e94b,
+            0x7af13e241cfaaec4578b52b9315b5017dad324fd69bf1a6a6aa79ce75b044ad,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x255345cb88354e31d381742d0d5b42072662445df9b98a247d617c92f27cd9f1,
+            0x17e5c7c425cad2fb89e6acb07a2cea4bd5b1cb02fc04fe38dbdb341be1cf7d89,
+            0x146fa4eb974c8faa9f821f63aca3727479d548d9f663f6934c1f458af3999ad,
+            0x727942876c6eda2c90f98458ef4f4d6ed010e0562236f1febfaa72bd11a5fff,
+            0x1bc84a56570ec875efdf985272b5df66c86cfe58a5be052d91787a8e3f8d49a,
+            0x1053ebe1413b33bc188e06fe047235dd3028615fed58dbd6c1d014980ed7777f,
+            0x20b12ab6f4bfecc04ee5c75f4108f2d842f004e84437e9093b15542dc26803cd,
+            0x1ec0cef9e5ffc3472ebeaec671ad6ccd1fc85e2fa7c5e02e619053976eae5d56,
+            0x2a42e9eca9fcaefc84ca320b72a0415eece1512b0afed7bcf4938985727b633f,
+            0x1a172b2e81e2559ff3ab9b31a103e77c71b2e617bf7064f7a910803ef7cc9f9a,
+            0x2f2cb2dcec93e9d768a5e77302b98fe0c291467a8bf3922e270123e45f06bc56,
+            0x73e947e3b071d91accefd64d9242ecf3516181b583e27222d05ac64e57e61ca,
+            0x201e11dd656c3292b05c202ea3916c78752b9a796fb97bfdb2fe67a935b761ec,
+            0x12ba1b074f8b55da42206d4637431163a1aa6c0891681fd604ee17a7b4a4d054,
+            0x1caf77967696809dd4e470183d00c935860fe2758b85ee6c6b8212eab0bad880,
+            0x2e2c8e680ddec801ea189dd679d2e16c364bf28a69d7b79cb81842ee2469b8a1,
+            0x29fa1929e7f6864a6c4856e9cb2dbf44d4c77cca135cee9eae611cb42d1e950,
+            0xfa23e57bcdb977f185df4258bc1ac55957909e6613086a44a6581cd275a7160,
+            0x2bd1a5ba49a19dd33ecc36aad236b0e0b4a03942f42a62fe825750889d4a1524,
+            0x160ac4ad5eec95bc5910faceeb460088ab7d25fa15cb698e9ed17e1612fe2bfc,
+            0x4c78cf3e48577cedb8cb5245a9607cdc9254ca8a8704f78d18db58f2552b2e3,
+            0x1e9ef315dfdc99112d0e410fd65fccc9c7ac728617537da3e977d7afde414c61,
+            0x2b4421616df11dfe94cd2b5500891f07eaf2900bdd8ee8eb42b0175be52be74f,
+            0x8a13f8dbc82ec943c8ecaae0690bd0a4bd51a9762d670c8d059038d4259744d,
+            0x14167eea5c641fb122863698bbf6897cbcd778d289c28685417d02e86db36ca0,
+            0x1b2d84e924984926c742b426b7ccc5841c4bd193d3e05bbd5c5ed5868991741b,
+            0xa14c4040634221a68633cf4f4622251ca34e42c9ae254eb7d02a7eaf1abc3d,
+            0x1aae6b2f56d3acc7ed2fa5f310a29d4e54bdb4e5f531f68c59ca5b430e1f3f81,
+            0x1c6bef1a7a903d4fd215a1754ad8f30011e676e498a3812d4f15d0a8422b35d4,
+            0x260d34eb550364a018d509e831a281cb5b187033ecb4814ef42f240a5c1ea119,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x29455194183fea94109c945206f2c16429d01c0a34919ffcf42ac314a969ba28,
+            0x11f4f3b6a1a747fc1aa22c66926e6511a4cbf6269f30c62f36f54b580f891a86,
+            0x2df1cbfe1e9ff79c44eac7909de01dbee45e899e3500bcce8269bfca310c5d39,
+            0x1e3ed2a6dd4ec05059b8dd11063a93d0b6c48226115d09b7e58d6d0f620be4b,
+            0x235eade019a1ac892102280841960624b179b82bb21f7a571cfbb8f4cae5434b,
+            0x1063dc692e42acecc27654967d85f8c3b48760c3b269565f3581c30cecaeb6fc,
+            0x144c087d0bba6b2651508013332ba01ca36cfa926efb37633cc9423e9b257275,
+            0x8dc44909d34e4fbeded6e5b8802fcb8ac3c31e0c2a966956ecf0cf4c027eabc,
+            0xdbb16e5b88711eb895a12babfb81dbedf8de29ce530aff091a3a16f9d363468,
+            0x2bcf5c9c863de574f3fc6dd7e35b84d333faabe43e1d6cd827ad58061476fbce,
+            0x13cc6568623778319060d01c7e7780d9ddf3e6fdc11dbd6e0d1daf61c0ca5904,
+            0x17a2edcf8bf40ac243662fdb41e4156e987fc66e00d5077523caf74b970cecc1,
+            0x193dcdfd2950a934cc3b92c1b9e826a11e6829cdd6bbf699d702c902c9c8bdf0,
+            0x1f049cb7d14ebd687ac611414b6186ea76938c1d239f8bbf5f83972b778dde5b,
+            0x4d9595ab4d18bed55ef3c3fd0cd99e829d8e55b8c101df09c2acda3acca9af5,
+            0x11a10e1656c16d3c53f889073d9f910945506af2e029aacfd7223cd45b457f23,
+            0x1c84c1b888ff8d6396ee63866219b3e1d7473ade3c14ceed3c1fdfa44b51edff,
+            0xf5531ef3a85171c99a9927bd9d1cbe04e84dc94c7ac68c06004d99a391ed06a,
+            0x6ee08fc691f0b4229dc871b3676f380042f6b7ac1e5344149cd7d64cc9ab46,
+            0x237628e422a57b51577905847eec949cc0938adcda2e97fc960492898d0c8d4f,
+            0x4b4e368d0d486b2d4772a9fb808db251fdfaadaabb59a5bcc20c97bfa38ce7b,
+            0x2a0484d90b9de4de15deca9a4f8795a61a8cea3d5eed0e938bd5c2203fbe45c2,
+            0x2cfa30139fcfe50e07673bfc8029dfd08f511118dd4a4bf0a77a7bb3e1e894ae,
+            0x278fd68bb5971f9d8b52b9e924814f3e07af8931796fc2b5d09605eeeba95c3,
+            0x24ea4315f2dfe3e361e0ec7213e50dd9b25ff8bd654d83f6d26ca562e2a7ddc9,
+            0x8612599ae2e4a878ecd88d9194ec5ceedd16b40c51e6edae2cc43f5e94a2534,
+            0x2003edf69a810b8a3eb8208b455fb3a6e04bfdfa7f6198f2a0475312da1da37c,
+            0x1ed96d9e0748ab37d6984b7be85b6c4342d341113d255cbaca749da545d34981,
+            0x24947686594e925c8ce4f919309d5ddd789f62d268e7c6340022fe0d45a8b816,
+            0xa42b268cf646e69a84152d6323e1eb318392a14827ae3241981f6ef34173e,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2c16f80293a1d647de56a4a26abf5cb6840e67570999e804d434ba92326b0758,
+            0x10003b7c47202671bda6e5bd46c2564c634d600e0fb23f898d73a217eb1f7cbd,
+            0x8f99c641f5a436daeb9e269146b505771e8d18f847cadd3028c959e39e47f77,
+            0x174ecd880d0e89617db1a52d076801bbddcc8f63c753467e7e4b7284f9c065c6,
+            0x124823019c96feb400979fbc9e8b3ea028ba45199a99118e5be4885ea25c594e,
+            0x1476f2bb8bb265ecee769b8092d9687ce6b822ea2d4fc8d9aa75927be24bd03c,
+            0x19dac45643cf0ec46184ef121ab7e9a1c03707c7aec4620bccc80ae83d4ceab8,
+            0x14674e4b8eab3fc1f80cf57e344d0fca2081743241898bcad999dd7939cb9b7d,
+            0x1ed72b8e2da7a2fd16d8accd8eafb4cbb51c59a9d05d221cc608f74b7230358b,
+            0x1da5ab440f2cdb9bc079ecdeceb673ecd86b906ffc33509225c6364ebdf4f9d6,
+            0xc751d0ea79515c1ac0584876431dc1ce6226dd8420077d52dcc644638eb389,
+            0x6a9dda83669129d53d499be9d18471ccc3decdaa7ddb14c4c19981f7937033d,
+            0x280a6226e729cc5a5fef6b66266003fb72a99a97e1985f9c1b2f3d6e1c5f4696,
+            0x277ccb7f226a1920bf5ab883e320f05c6edb580037be022f9a699079c9ea1501,
+            0x207e4c2a1f9d4bfda41396d244cbc313a5a5755ce9cb8780f6a6cf8ff67b090f,
+            0xab72e9f2261bc7dacdf730b02c9772d67b34b71c154f06480e2576995ab7fbe,
+            0x26dc9a65057fde68cbf2b518e47e52c3089085c30015d873da81924ee8117970,
+            0xee4ec60b28b8ae1bde8ab75521531748078f397b9914ed1d600f94f65edb2cb,
+            0x26f7aaca92a139c5e2a653e9ebb132aaa385aa192ed9e1702b04f2c89d9bb766,
+            0x2d2f1c2e5326bf8b3439310ed43a8721d8705e6d1c031af9facfb15f4ff8de85,
+            0x1fd6ab80e45a94d9ee539f3247f22d8fab16026c5d0126cc5570514599c94b22,
+            0xf94a3d03ba6eb3cbb84ecbf443474976b4b610b2c7e0be7bd18ec026f26833d,
+            0x9fda6221cf5e2593d796d7185867ab6576bf2f79813f55b6a1ae9a1fcb3437c,
+            0x26846396de6a8b113b784a7dfb9c63b0b950a69a20e63634954936f520470063,
+            0x19e400a2ed9606a0a39041bba22cbbeaa8547c89ca0eb006c614b5d6d1b9e0aa,
+            0xe2a3a5f42587d60aec0abbbf38902fd54d392c4cf26f8359deeca160061a02e,
+            0x165836d2e5f94bd9868ae471de1b194fb407c3c27a3b322c956f13789d95fa23,
+            0x2bba296744ead7cb7fa4e64b0d9854814e303a8a685433053ada126285b12dd2,
+            0x1c42b83e0bf8cd6e2072b5602d85f5161ba6cc9aa752366791cec9eee1228510,
+            0x2a8345e521ad75f61773023d905bc873ae8754b28c0273063d4970030cf6afd1,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0xdc769889e4e60328ced67e231f45e241283d9435602a724dd8d1f8a709ba50b,
+            0x1002f962d594a9b3a1cf2dfdc940b80a6b67d3fc3148be7c0d11be50e277f1fa,
+            0x11604b56f285ee9acad757b62e0a8679ec868a468c6715500cb84e72be72c7a6,
+            0x2cbee753288f68a90a3c4a83783d30862b6e89e21ec3ae112af1b016ee9445ce,
+            0x2df869ed85aad1cf7a17b58d217df7738c29e7ee5b0d254c1d4976ab71916b6a,
+            0x52b2ba2fc76a7c40e4eebc062b1c353e2c7af8430a11222e64b8f1c09e57b69,
+            0x23446fb653ba07d93115d3413ff7c9676f57d1e17a08329c153eb0e89d3e303d,
+            0x11f1fad8b82ef8c047feb379042297cebe6f2a6d5660e7a993f67fc10e58adff,
+            0x17af0f2c5f514d29665cde2023d8662f453954101bb66e15ff582604b86147a,
+            0x11d7ceb7a58360c894abafcafbbb0b08e302ea940d29f5c403971e7a7a014fab,
+            0x74ad08dcce384bd2df324e56ae0ec65f035aa90479bf25d940ae94f25bcde95,
+            0xa9e0e2b8db72860fd3308d7982d4c51766d89ccc8939e0087c3fc1e15d53558,
+            0x10053dd72d3e24c8040482217ea6d61c3e419cbdefe8709bc58951fd2a0711a6,
+            0xb8feb7949a8116ad1ec2cfe47910318bd5dc9e54ee0caffb08a23e4fa0ea22b,
+            0x1b3f78f18b178ee8df4bad8cf2fade21d1698ef13f78d3598c44a063fefdda25,
+            0x15af1e8fd71f0799f8c7dec891c12d89bb687b8f14d0f12b4a52084bd68af74d,
+            0x147d419b1999d7896f7f2c9ab68937f4e1ddf75ce3615b51e275a33e5fa8fe96,
+            0x28b7cdada2f2cb2b1ae17064a61f03b36fe64faf9db752b7470da8398a1578e7,
+            0x2163e931b6d3e6641d34369bb808b3745c1003771dba9dec9bf9d5fe24c43577,
+            0x1fe3bf03ba1752e0d93486397e28ff2a9350c56abb949f7f6a02575b1436636e,
+            0x2ec24f69b227550297bee72b056181c91364f54f9cb31e0b14d38fc2ac37f147,
+            0x98d9ca655e17d9af5fc7933beb8f6b100d78644eeb19c1e7346bbd6077fef4f,
+            0x2e296e61aafd6d219daefc2b994d52310770830b5767a3c8220c2f5251e4d786,
+            0x2f6884b2602c50e4cbdfb45ed64863dcb689af3b917fb10dfaf9cfa8307d112c,
+            0x5e81ed97199a7c32f5844b9e3c48c60dfcae2e703bb19855260479d6556b63,
+            0x7b3281ec445d3a58654d72a48b86be8a10380910a57602460c91e4efcc812ff,
+            0x14e55ee2871da3b1e051cb0857adeaefa5e9101d9b5d7623580fa70cdd041385,
+            0x53f6a1c6bba5a4ce92962a6a23cdf21096b5c1c0652444a52174efaaa6287ac,
+            0xf55c1add25dc95f9602356a6ad006ec557378a038b09d9f46daf00b359d88e1,
+            0x302ef214c4c4e78688cfe22c58544d3cb8888bac5512044709e1c56fb3a6a513,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1e97abc82dd29d2284a66edf1d38115a8cf9d2316c79b2262afc5a43487217a,
+            0x18c844b544ec0da670ba7fcad86b7e4cc3b790c3269507ce0cf608308e63d5f2,
+            0x27e894e463d2d999c5bb6c29e9f5573603b4e3f55fa4b1eb315b0664794a8897,
+            0x1ec3f26b1af76185f0de2d894157ddf696e80aaa3661e94163e9106a9fbddd3e,
+            0x22978d983a255eae6840d50dcf586263d5a0afd5b8eb552f720cc0affc8cf533,
+            0x1618d7d7b6d7ba2dafd24690ada4cfa7ec3e961f395b9c7fbf7d76d0dd837125,
+            0x1df2e4ba9ba44ca6f24877919be6d84c97a6f6cc318c7297d608f1aa4f050848,
+            0x1fa6c7cfaefb71fe88191e62ec1e69611c76c503ca8c6c2b45e0ae286588cacf,
+            0x2f00266e50bc17514d27873eb92eee8038696ada6decb01a1138f09aaefb625,
+            0x24b0ef6c8ddd8d74acd34fd2977a27c6e584febb5cc1ed119e43333934a5efa1,
+            0x2eba590f514eb52770d140bbb2bfd1909fbb0056559a5bb18fbeb72f9bf1c7e5,
+            0x1c01664f520b12562f93bb93f40874300703ca11b39eb1e8bae9f21944f0c4a6,
+            0x158c6e1a418426179c9216cf35095705395180c264802302c2b5bdda75b4a4f6,
+            0x2609db7fe10c939e0289595aad97807442c4ac5b28205bb6fd6ef7bfcb55adaa,
+            0x68bca148cf00ddb73bcb32b580db9423292a3d0ca547207c281222c5ac64f05,
+            0x17bcbd81a901026df975e1a27ca02b7db2b6c7daa5dc0fc9a7d71e4210c16715,
+            0x2dfab84b8b358320cfd6fe1fdaadd8ee01d4658d701376506800ce70020c680c,
+            0x120819aae37b3d91fc8c0babac388c536f3f091923ca13587c8fc91d2c27a9c7,
+            0x12313b69bd606ca46c7008f6f4fccf3ddef09743f311adba1200581089985509,
+            0x11e9b992c04a4ee4586a62142f37868d6535f948e89ebfc54151c61e1fc4378a,
+            0x5f557dea69dabf8f49032a07a021b292a4cd73e51dc82f9b8e4d96d82569a53,
+            0xce2bc653061b09a271f64d5ac546f7b2f3a270910f2505ed186e11b0d4eea44,
+            0x195b61bc0d16c176128158e7463b3e3ee0df476d31cf641e297c8cb9f5d6368f,
+            0x1d0df7d7da33f468a43a413dfd4e4e188385c6c87bd767486c4a4a6babcda2cc,
+            0x13904564817a3bf9e98b1a21f1f360e5830764da4a300f059268111b51b0b761,
+            0xee010fca95f45250a5ce94a89a91fbd64f2c118e2755127a562ebb00fd27ef5,
+            0x279d86c488716103a7ec21aaf9d2139f72c7f72a18eabfd581ef619e0c3b20b6,
+            0x11b803d7d692745f2ba754f16d795a2c51bc5576576c244edb6f80cd790dd8d3,
+            0x3d093d2500c614852a3802e498bdd965dbb993e8d07397b6ccd9c3832a0907b,
+            0x16652d5f69932fa04272068446046190f9c83f85e9ccbcd36210c5877778f1b8,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2959b7c18c774ae5de1749af01c678a88eb32215afbd962a0561d6d198525e79,
+            0xc26abdc5e7b095a4e2237c872e90bcbee8a10618572ec9aabe2d7b1a377d6a8,
+            0x17303e79bb1728eecb88e18d8b7db784ea1a70e4eed67e7f9e6deba761b863ec,
+            0x8f1351b765587773fc254d4e9c6215178b81698a6e1332bdbb16c5626879b92,
+            0x24587c5be08773ab2fc2250421c4988b332bfc432cd4e283fc86de3882b7898c,
+            0x972bc46f752662ec72acc9851fb74ef8fa89a03f2ceea01849ea839f9a80d2a,
+            0x185382531567193bffc137ce0a17f1f087da191bab36af539545a6929b44697c,
+            0x2f835f068a500a33e6b44b3a492d8f09228c2d660f84558123e6292e93f906b2,
+            0x159abee658fae6ddaf7329b5f76a81e713dfff71c438f7e678a5b64365285949,
+            0x2ceaccfe0874e534eb39a86b066ca9b40e25793df513a2e1a8edeee8398489ec,
+            0x3e5251b721d2cd67a46b4e7bc90015c36a1134a8ec5d25194d5c7c309c0b029,
+            0x1018c8b0a3de1c528680503ffa391ed74fb1b89e3dc09b140f7625249f061249,
+            0x2c0015ecad1833f9b004d902644feebfde2a27e50aee9da314e4e7480a1eb9c0,
+            0x24feb7104d161a328cdf2dc7c125422879578cce893fccf80e5bb265bfbe2e6c,
+            0x2944d98697f7ddec78e5165cbaee2bbf0cea6359981a13c27bbd17a60709b7c3,
+            0x1eb6e93cbfd035bc4f79bd6d32e25c05be28216616655908dd394f8e4beb0c17,
+            0x15274c4215b3498cece507e5a9c78c728a2927ae24b72d580caca25885158c01,
+            0x244439d87914ea7af64471c047d1afb3ef3e4d3eb41afc5ff4551e34e0b2e03b,
+            0x7c60d6d98c85efea799c2d359aebd1cf865015712f99f6f5078776b44455899,
+            0xb4448d85c58321886de5cad02508cb079e475ad06a5691610848e530cfcabdc,
+            0x2d385f71e742fc3698c688df7df2ac0cd06bf1eda4db74246d5b3ef234d66603,
+            0xc3c7aa72581cf03932ea40da64bf0454b26ca6c02b25798eaaa3ee0893f1479,
+            0x2f4091dafd791bb3cf7089c8e714a34bbc2f5fab044416870a1110bd68da326e,
+            0x9a9203152f7c7a322535f3c2445dca0be8621df8f0c9bc63a8e3654145b2388,
+            0xc9944612dd0f8e184d07ec5a44ca257d67514ac9ae15e4f5be49b6c0356915a,
+            0x465c847c7d119bdefe896bf452c77f78e124ee0bb245270d21ed2bd79e11721,
+            0x1725856f51139de9097ed3842a414f8e8f63ea6b9e6414e5eb220842583af5bb,
+            0x276c1b109f88cc834ed8c2e68672a592250c6cbfea5f9bddd0834c5563f9a886,
+            0x2baf5485e19edbc5772e04a26dea28931742966fdf39011b1c16f2832ffbe3d7,
+            0x2042b1e0d4a962b95c5dbcc044fa0ec53a00e8ad677a6dc39e36b41a016eb036,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1eb87ed83839103c87434e39c910399447d9c63134d442335fb3e226f84b47b2,
+            0x80a226b8c5b7ae68105818ce707b2441a0da70860d771bb4d58585ea1a62866,
+            0x1b038c8d59fa36e1dfd4cca8bff7d38b6161bff01ffaad9e95e3c8591174525b,
+            0x2ae9c92470f8f4d5ef9b96d9c1c235c46b5ca275d4e08dd1d193abee581d763b,
+            0x21fb57daf9b4cdf828d74de7723985b3a1b0226d90f563ef1cbc0d9232fe3429,
+            0x22bfeba5a5a36cd515fa31b9da51ef26a15ad6050bb42853f59ffda0277a99c4,
+            0x20f3df888830ae894646d1166204af05d9817613c719cda745c09aa141590c02,
+            0x63b2355acdad1a0032a2f2c7a2ea5f307e3c0321d261c9d7f5fa10934119f28,
+            0x16de60437f4609882b9eafa6ac6ded955b8225b0985fc4e3983ea640add5028c,
+            0x2ab849a10d24540498ba4c7ee7afac4ecdb81e0083fb82ef56b91d025e33756,
+            0x25d60a27489116c12d3fb8af52c877f5691d57ad645946fc4dda53db186e2c50,
+            0x1b1442dc351aedc7917b1008bbdc4a05d92e4639e7f3af1b7f8c1efc9bbc79c8,
+            0x2502537d03523d64eacdc4da240a03f6981a89c3f3352ed51b95231d129f6efa,
+            0x1b786044b15312f04f057fcb32f799f0176237a9e5c70bf309a9860ab90fc724,
+            0x13aa1eb0dde09e3816e83ef9027b5b12fcb298f469d8523b588d728f6fbcc841,
+            0x15d72e8723e077bfbcd6fc983a47dc7b580681f0c4c4225c58011bae84f8e1a,
+            0x1369471512c4227330fa0c25299570db00e2db62554fdaae3159988504703cf4,
+            0x1b7142089a165fc6d053090f4e2797f7ebd8faf20861604b3ca39ffa78d8fb6,
+            0x65028c49121ab4bb6dd4b70ceda8065e546521a801b3690d836602df5c07a4e,
+            0xb0c93a4ca60bd6782440a3ed7ed610e4ae11dbb6d73cbd43bab80e55c0ef062,
+            0x538fe578ac88710d6dd29a5916aa739c9a9ffcf0f692b1f03d0e890a26a7ae7,
+            0x2aaf085390a5682425de02d9feca6b1713d016d1682042a9283f70b773eb8388,
+            0x12d3a3b814c1bbef754dd237698ca763867b464e9a81d9bb031ccc91574878b2,
+            0x24fb699b2d537bd375a53a4cfca82569a0f7bf3417e1d05c2f0a996c5e85eded,
+            0x11dff9e9c33f3786c5cceec919601c95a9569a01502843f7d4ea0a7078111ab3,
+            0x261e407b0cd0b43f5b9e5c229e1372500707db45aca65d3c28421a3583367e4b,
+            0x2351bf0327b143b2094e336337c156efd6dea461b8c2d23baacb18abdab7454b,
+            0x1ccff891ab723798b4de646bb5ad6d3e3da5970a79a4f25dee25aee7ddc543d9,
+            0x476e4b00efa019c97bd3cf545fe7a670aac04ebc418c4937827ca368ed3cbc2,
+            0xc1e697b8e69d9e6cd15a5b7e2d446038e11a06250f693e21a7ef4d9ee11e53c,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1a09d2b7e646521dd535d06cb8c4de0a1b42910ea066edc264f59380e26cffe9,
+            0x17cd99a103a4adc1725b545ef98b3cb45b2bc761caf0eca510891356c0f6b6b,
+            0x6b9bdeed92c495a84a828dd539be8327529a051131bea1a198bd849018a5a8b,
+            0x8680012993a07914e68e1df59d14f13f130cb8c1099833fc0d2d2d11fb311d3,
+            0x247b79afdd0a99fa80e82045bf81474ef05d19174b15ddfb6a5eaee7d98a66a7,
+            0xeace989a2a643839e86a96e5f8a1e99e868ba1becec4171ed39c7bd2aacffc,
+            0x1537fa1eb45e0b8dca81475c350eb64701fd14bacb0a2948609c9fa1b9d57fac,
+            0x9ebc426effe66fcd5bbff51e0aa1f60385dbc0c7feb0d9c6f4fe06384456ea0,
+            0x18467be5d0a4e54aab055cc7dbc4f876d56097c5eec5b27f9a15264059b0eea7,
+            0x2dcdc0099307f6a54c05fe4f82494e0611c4909ebe6643697f44ac932f533934,
+            0x3fb3d6990d8e8da405a112fc11f9caa56723a2f6093e1870a866c21d2f3433b,
+            0x7903dff1ca5b78cd6e95e1284f7a87002f00a81d612f82842bb2af82fb850ab,
+            0x1ccb172a7b0f1139bc8118dbba6bda8ef321cbdf153a4db826b08ad2450cb8a4,
+            0x231cbab35a8a0e9dc999dba368451cb41d7456f2cc0481a14a2a7d72f201663f,
+            0x1185df89f8a40ac6098d898334d0747a5b3d0285d41e2038e38712cd26081dba,
+            0x2fa064d281be156cf97dda9141c6ac20d0e19d85474475ee359e109bc25a5670,
+            0xa2114ecb4bb88293eba241bc0fc4a3b375da6aba30cca76e84810154a093044,
+            0x2bd5621d46d2dcb41cd8f8a22620ef625d6fcee5d6d507250d157b39e469240b,
+            0x1584517e545411ec6c849b82e0fe8cfe70cd715c5a657d78fe4dfa92cf690d64,
+            0x612bd1a5329c91f6c6f6c31809951e143c4b5ecf97e2ff8c6b02463fe29ae6e,
+            0x26d3d348ee74cbe27e5a4745e738151b3f61fbaac3ca334b1c6f0ee18a763294,
+            0xd69c097ff13bad16f04826fcbc91eb99221410fdabfb06a04c69daf5d0d46ae,
+            0x19df85abb6034b86a237f3c2a1849853eea70da522f725111bd78831a70f29b2,
+            0xb67940a72701ac24d81e056c7ad73e3dfad45f6c1147693e8e56ae8759c75f1,
+            0x2d067334ff4cab892a24cb40846b591176ac47451dbbcde9cac1de766bfd225e,
+            0x250e8bf6d939e2294f6723c8b2e001809923b7157ba297cfe107b8220cbfc006,
+            0x106265f59a713f1de605f071461cc7765c6eb2ce12b7494c021e07b5e0b0a121,
+            0x268591932728ffa445ab526d9cb60f6a1de6c10e244cff633ba59b9bdb957e04,
+            0x28a264cf3eeeb2d81d4c1532e63e34496b3500da9e62fc9e8070bd5967c5b9f5,
+            0x2e289ec9d9fb747c577898f2104373a49adc00a51974b8fb1c63793f22414f2d,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x292cdc4fac941966f3f2fdcd0b64ced5ebf1766246e1cac45abc40423575d9c0,
+            0x8f9166b886a64e24bd5cb9f5327942cd66aefe8904bab3ea68f1c93da72ff30,
+            0x1d9346b55cfdbce62471674a48c93173f222039ca540946df8cad8f1adc4abbc,
+            0x284445af50c975330a1d48657b764cf7b19c8b5d8cfd72bd8cd1aed812458804,
+            0xe5caefd895dbae4ac6d9a50ba9da1fccf2e99182801e50def13f656cc52e823,
+            0x2c549e8a4cd3cb9c925dcf4af0af39cc5d419957e85a1734fbe0cd495b4e6239,
+            0x2f691c2890ed7ae20244dd12ee9fac94cbcacea42bbd323484146b83beef3964,
+            0x189c18874e9397abc281643bfa747739e2ab4f51c2ce1c64d8e0f6e0f65f065,
+            0x2eb6705a02c7da98061b74e10ca594d9fa85f2e8a76991313d2720268f65223d,
+            0xb8c7b073c91922a0a25ac24de7c5781f5b95c1d29676b097409380c6e4f0d2a,
+            0x2b254c1c989381315f1b091c685873377c05d1d40e3d20d41f56506756ce5ce3,
+            0x1f9e68c2a44b9a206a5d1c428c27604031de91570926a23190329781dda14dec,
+            0x107e82331d1a1db3aa814c0e3854ceef0db0270c842945e09b352cc69e959fdb,
+            0x17fcb1867c52d50eff04a137a183d3f0dae94b5656c8818b4fe024b7a343dfda,
+            0x263f802111aadcc99cc129d051f90acde70278801f4dcb1781b744c208b6aa52,
+            0x27ecf8ec238d8089ba1393e8bacc856c9b4bb554dfa37c89a6d6bcb0a5954c9,
+            0x2aac3bfa20e64a0c0012512611b5460908616ec7282197ab7345172daf70f421,
+            0xf822bf90a6d6c7e046af505fa63c58152f880dba55cefc639313d104a99435,
+            0x1d482f74f7352cc3b1e07f0c4e0ca4685417ff468574b7694f6ff7e9b438323b,
+            0x9efb3fd5f2af95e1269ca6e40bfdecad8ed10297b2261e7a27cfa076bda8348,
+            0xd70b85544585d7520bc48048e716d4bacc8a357c3efd735e10376c3a68e58f7,
+            0x2a96c2d2c57ff7ff8a1fee90d4f30a427c4ee5faad1bc0c7640dd2628d7be337,
+            0x467014fd75c87da4bc08542150237dc948da566956c03a7734f8aa3d4ce2a0b,
+            0xb26d2f933b0b528867e896f30e7045af1f496d73a13e58fa1456f4aae1a911c,
+            0x25d68e5bef9420f64c42a4d44aee71b216ad9054d968dab70bc5eff77556c9f,
+            0x177f027b0cab57291463ca56e3be569fd5579d89ebf5fd528742f123718a79f,
+            0x2c5132a44be83d88879ea114016e67092bd966a9ba0364ba501fc05b63887493,
+            0x14bf8d2e43f7d1338bd93c4350007077fa9ec02ec8e64e03950d17efa18711a8,
+            0x309414aa73703addc97561bbcecee45d25f19b4591dc6d772fcfe0801a85f30,
+            0x40ea41587d4a40b935571880dcadf45e722e4273f0f2b32dda53e53e70a7a87,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x10b0d37ca26e90c6c139a01ff17861c46ebfb646f348fa543a44fa933dc6c7ef,
+            0x175da5183f974e9606eb7d7e22cd12ae8e27dbecb9bd3c4c12b3f6ee0f7518f0,
+            0xed8273a2cea837930a2c09a3f7b24188cf44b7d3b2fe41b13e03bcf26b925c9,
+            0x1217c887532e425c1502f9fa496dc792acbce0cc79c661b16e4c35009e7d84a6,
+            0x1903752f1c798c095c24ee714d1b8124a4b4b14d2ee2ff49ff7169ddbcd5b4b1,
+            0x2803547df88fabd669511738ffb17cff8919c233c053e2b10d01bb398629deaf,
+            0x4ee5ecf2b925246a34bfeaafc9239f9a5f7277fb1e39131900b432baada6dfd,
+            0x4c37b33555c362050a25021d96f000d1a1dbc15c9965b2536bc4ef59b52fe8f,
+            0x1a68530699df479a39fd71d5699898f91c440b61d7138d4c95a353ec2a60f0a4,
+            0x62492de9362ceef05e663b2e14cfc1065415c4dabdca0d4b49b602228ab9aea,
+            0xfb5d4b500ecd21e402496acd0c39a0ce6aa93741dd846628387324004b15dc7,
+            0x1747b55b705c98dbe7c38903fca5260a313fb1ae77984671f6c2fd594bfddafd,
+            0x2d5a953c65e21d277459d6ac17330055536bc85c49205e6e75cda3a58faf9b2c,
+            0x12246b22f19de420b776858c17df7b57d3dcb9dc48a34167b9b92a429fd7a403,
+            0x1133d3224669f992858632b54a9a2f3cae9a86979684bca621d21fb8a7a84dee,
+            0x42c7ff4112c72f96e2a90a37d0b9755a935d43ada317de49047e45bace9214f,
+            0x20948256d2882d787bd97ceb71a8f9413ca287382dead6b80ec8511a0f820a94,
+            0x1a3624b0bd43a88ac7c7de460e246ca48ff71a5a23098ce0a713ed4cd3b42b7b,
+            0x1df0dccc539de543bb1cc2f5a0747c1a1d39398b7e5d2542ad7df388cb9a2c1b,
+            0x21dfd5ed89c255e1c584093f98d854f81cfc58f92674fe0fe8dfca8d7c1c70a,
+            0x2161ac36dd50d34ad7ff8e2af49bbe1088d3318678e3a8d8e0e0b3f430d55d2a,
+            0x1ed3cc39023610359593bf3e49a58dfbe99ee1afb33acb553bf08012aeac1747,
+            0x24c8d8944de112708df57b28fd012d576868d998ed87276f7192f8fe82044fbc,
+            0x183fb7baba3d12e905bb7184ef691982c1dd489844c06e9f7a048793c46a3b9e,
+            0x67c083da1428ce521951ba41ccef834d99cb41e8b92a4c4cc7ce8dde2de4adc,
+            0x1a18a9c1c45e95a541ac8dfb96cf2bcb5f93ceedd0135bde9344813b3b5762aa,
+            0xddf7ac0878db5f4f384ed02d5fc90adf7215e4c3bc57d37f4c27ce4379db9a4,
+            0x2adab562b4f7991948d9cebbe53a821fa08c96b9100b17a92d2ade4032f490c5,
+            0x1f36cd6e66832646861d1a44378f81777cee66ee7b66ffa4466e9f9827d3efad,
+            0x16c514bc623520a3c63d724ff9f8e2128de3a4e93ec26cd60596d2b74cf90df3,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x276235e6cd6b4ad073433414a39f872c42ae47d5caff6a0fd2b11db226627d13,
+            0x288fc36fe0e39bf7f8deb74d5edcc5d6ac0b0e13f715a911a696212c8244cf30,
+            0x1f6e77bcaf2e10160d53e81aa4bd1fb9620841cd7cdcf5626cd1347714f1790f,
+            0x2c50c513ccdbe60dd9d14262db601d085beb529f9f9809e734b12cee63ad60b2,
+            0x1048a932b87cf43cf61b9fe7d5e7824a9c0be2d3d8a6927819a1dbce4de7594b,
+            0x258802f01620793e2b886ba9978721882e6ede295ab05ad492dfcb56055677d4,
+            0x1fdefe23f71f9c4e4b5a27bb8c5ef9e97f8a272361f8e6ba93334d5292ab1c4f,
+            0x1f46592f6d4c77467466a48358c5c195e12db247070f684bb30caf332e050b15,
+            0x1a0628c0617ed94340450e8b212d19bb6d80e0c336a0c73ebd489718d0245512,
+            0x362fec7e50a9ebf5cbc1bbd06320a44839f3e1a24c6dcec2cea98dc2ed8958a,
+            0x1434da4216548b811c240f289b634c70bd0217c2c78d3515981a08f0b4228a56,
+            0x2a5a298ee338866a51ab733cd5d912aefca609abb924c3b91334ff31968db1a8,
+            0x2fe35de4f8239cb701957994cb678fa76b45ac2ca62d155abc6bd0063d8477f8,
+            0xe81871313b59264be15b4d24465ccdfa520f1aae5e34762e48814c151eae20f,
+            0x1dccfa84663bd168fead0d648a7024cc7f45de299a1552c65c9aee69800a21d,
+            0xddcb95ed4ccd6154052d0399bbb3eed354d1348a26e7e3e3b767f888b7fc1c1,
+            0xbdb5ed04d13305bc7abdc9a1f72a3cd3c325a8d5d0b37b3f6bc32f5bf2bc30e,
+            0x1a3791a5d480f586e225f6a3419d92bc7c93d3c2c941e201aba2db0db9f15d73,
+            0xab254daa5ccaa47e3ea7ddf885a32e8192d280ff8b96254036f22562e3280af,
+            0x10d084b180585ee9000d1537f77b4d6d3befba3b2585edb286f9e382257acbd2,
+            0xe99d44a8d7b3633a48109e8437a866139b546ddc3a43911413edf9c0abed951,
+            0x1abb36484f304e28d2b406edd5d4232f52246a2642bb87e5e8049639a5a7e48e,
+            0x1f24c896eadcd0d5f6b1067845c87cae3897a454e6093fc062b6e9fa9dc327db,
+            0x1f8c613272cb2e0085c3de18d2c0063422bd3a3f7b34ebd39462a54f96690dd9,
+            0x3f8600811917a21e6893b3147b75a987a7ad447437ad24fa472b3016129f86a,
+            0x21268f597b84752db51be08a3a6a2a8b1b2284d8b0442b549ee5aaee395c020b,
+            0x28d3ef83eb355a7d306caba33c70e6e86900ba153ad61f6b8b41ce49daaf52b,
+            0x25d200e83b7288530086b690322a530ec8b502505f3080a7a46e6e822ac90d2,
+            0x2a7f6b2aebe3142b2662d473a358fc1bb9d816498b3c2edfff86866e2ac00082,
+            0x299afa0d0121fc23c6d42fb127eab14f2dd8ecb1ee0c04376b9c732e97a5bb71,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x292e5deb4d74974e5601e05fdd2a01a57ccfce1962e3f12ffc47ecf62cccddd5,
+            0xb7fe07627b2b86b9e560c5c6058f62a23b9cb416af6d749319a5f0a731e9b99,
+            0x1be04625c4aae2000e9e13a7959133e86b7888be0de9c4bed8431578d87ddbf6,
+            0xd6b21b10daf3f589d71fb89c727278c0cce92db0d4b058ddb3b23e379fa5c7b,
+            0x208f14de82a7cdf5b8f2d2c2d77fe963748847574dc8f168c53b1dc68674daed,
+            0x261b3202a10a92f8f818f5c9b768d891b3fed3ae03b189e5a743b6a2f631210a,
+            0x21da24b99fc179077a9f8ecd8f3ec7a3a6d4e8c62c3721f5a3f4a12fed074d91,
+            0xf821357065851a94b6fc9d8d679679a05ca9ca81839c786603a98d92cd3be72,
+            0x146cf2ddedf7045102306285a0322a26b9b312d8ae0d5638e122fa42221bd203,
+            0x1f5595159d4bf74c70466f5a5df27f878727f037c6821bd0b4a16b9a1f9e22e1,
+            0x2e555ab81d4af50711a229745a65dc974ecbbf16d855767d3ee973f261c6958b,
+            0x9d88eb8fedc6dfcad4ab68ce84e1bf329725e89adb094aac5a25e36f8fa1248,
+            0x5becaddb686664747af21bf5a5e4ddcb030a20314b123c58dca055cc8f47200,
+            0x2b5133b32b578393ff342e4ba0169b60ad72d1082fda97c4b696610dcf06bc50,
+            0x209f4bb986abb2671c9ac555ce282948dd3ec049e67812e9add90f3d83d62346,
+            0x2986e1901bec371bcf3f2bfadcc34003a901cf3c6c8fce5a86715bfa70dd05d1,
+            0x36f213f560cda1028bca7da534b8bcebf84ce7b4b275d873de14b03fbb8ecc,
+            0x220d1b8cdb11be75d11b27932ab7026a54326b5b340ab065e1e4e35d26398677,
+            0x1fcd7370575ccadc60429c962fcfd8f4b3ec9614c085d1383a943d7e487c4e37,
+            0x1c49ea5e5ab4635be0cc07f0d40a8f6bf68622bed5daf5c3aae2a2001d19cce4,
+            0x2c33a36c54999aaa2e54efe70048654f4d8fa8bf7001a8c92d86cce2077c8f26,
+            0xe70e72a3a3d2e267a2b6af5dfdd55a25435c6f581a46ff5fd461f08d0e9f7dd,
+            0x6cc0728f4993107d1ad1cc3c083d7f23847df303de20d92b5ec90ff8785e8d1,
+            0x14adb5029eecd4e65bc58af84408697c8591fc5f6f74b6cb8335e7766a93ed1b,
+            0x55d9943e138d24cf72d400134a020e38d4ffab9f52f85610b0e5e678b6ef47f,
+            0x24659e5fd5b9d42642221039b404c0940c7a560dac0e780c59ef19df7fbb1134,
+            0xe5d9ffb29775cf1d63fc54110f1e384ff63a353331c2935bc061eb0bcef7bf4,
+            0x231f3394c59385b1e8bfd5709fd95d00e580cdf3e37f8a940c4213d03e6fc636,
+            0x1d74d876aa5187f518188bece8d3f4510ad7c73380c362ad8252e6c61c4cbe88,
+            0x22873eaa2fc0f1d24d83ad4e8c090f276cee48919965304fffe237a5c555a0ce,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x1cfde7b00570ae56d610b0ecf469c6d5417dae9656a9b36a35c5a72dd38f14a4,
+            0x1a5111cb0a961ae216f5a1d83ac8da38d6910c2f74475efc1d49a8e494d161e5,
+            0xcb1846e6664d919ddcd95c78357bf2029b750dd3cf02f4731b4975b4cac64f8,
+            0x2cf7d663f92d7fb9c20dbd49208ff17b66a023c460eef5837a124bd89e3e607c,
+            0x203ff2de4108ca7567b52a45ca3100b18c3015afbaa01b951010a46fe7b3a2d6,
+            0x2abcc429149a29c4015959567a3aeb77ec781847dd62ce295a4cc9487f58d2e,
+            0x172032b322c260b66b56d12d9f27327bb14859be5cc0238dfcb9d1f3a8a7c424,
+            0xa0e87895274d1193436e943de47d8ee0909c998fa08a714a375656872fc5702,
+            0x21eee81004b563924c0089d162a2a0b5047ad60910a5931ba25103364967bd41,
+            0x19271e4f9e7b8a7f54041ca93fa5005d76e5960bc6d3dc132e1de6b2ea072329,
+            0x42dc1a29bd582fd08c781efc0e67506afacecfb6997ac871b203cbf71df7120,
+            0x6b8d08b07a1b58558a9dd55596a67cd72960514db555a0c21c6ba29fbe1d563,
+            0x116c800fc674c2d6909c1e55568650ca2439ce3fc1ac3a81ef5ad8fe2e9ef30,
+            0x21b9ef80d19679af571fb185e6c0eaa780bbff382e8bb7ed8bbd342c40aeaf04,
+            0x1aed5bf3d3bf68f2ec32aaf43e0b43e380244f25666254b23a0321a33a6a5840,
+            0x276ae4e84f3446a707103550805c52c0510cb0c2e253ec32f2fcba255e90ee3b,
+            0x677e26ecdb28f20a7d565510f73b24c036bb6ee0636010e6bd2654a15ce49aa,
+            0x144b679dfe4fdf64adcc33da78a377591421c486df1ac1247f8962762eec6353,
+            0x2b3e47433e01893ba1416ba93aaa4e39de8ee93f6782e1b1f9d709701d26caeb,
+            0x21007ada7a8cf858670017f02b6f452abbeea2cff05ba63511a32408bf8c55de,
+            0x99eb11c109ca74fd589d0647392ff6056a100ae0659e60d0c34b9da3f27365d,
+            0x256f44ae0dcaebe716aa9569b9373053ba6fa022693bd865017a093e029231e8,
+            0xb43042d175b108a0e9c553cd99a4d288ba1bd0ab4b2cffc049bd63ee949bc2c,
+            0x2820651d09922281a40505d755c0951dbc15977d8f3ac9c9bae3929044039a19,
+            0x7c75e7a56b94c4942d893c12b0e8ba3d7ca49e2435fcafe0ec9fdf4520bb9f8,
+            0x2407140cad6a6c1d58b3e8bb6f083b3d1ec411228763dc4cecef95c56ef9f801,
+            0x19f6713df3399cc47648b497f80707e11c962f694d9486a1884214d63b1e2423,
+            0x126880836b31b2ad4d3941a65eeb12015282959888382bbafb662ffcb146cdc9,
+            0x10f48b8b5d3586007a9da374301e5246ab668094850451f601316f889073b66,
+            0x2b35da385f9daebfec630113748adcdbec531e80323e00627efaaa55b9b9e977,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x413c2aabbde38d94bf1bba05b680f5fbeb526118e75df7740e03c6497fc2a93,
+            0x1f5a1a9d111269b8fc9c4bf295f95df0068a17c12544161132d3d06cc6c28e17,
+            0x212d07b689f77ab9b11d9c58b8eedfbc84a0f3a5c3d011c43558d04096b3c595,
+            0x7c689aeb8426becf2d38e8e501aaee897c6a9aee5e479b40bf1b84a50fee324,
+            0x20ad507d2e6bd8caa8b7b879d8a0f22b037fc7784994576a2053e173b8799f6,
+            0x29a7b5d1df34024626bcd4d01586e1ac5addfc06e8ae7e20e4856705d6921e7d,
+            0x1cbb5f6c2ab4fe1fb5e81b5bf2c583b7f0f6a3e23f51899071e6feda30610084,
+            0x1ddfe3794bfaccff166ddf4fed76cb5ce75606b016aea81a4decd295fcb73d6,
+            0x2b49298bd3a4415198bd2f444de89a1ad359aa90b14caf77d1afb21ce7a50b30,
+            0x2c10b2b301be57504c8689054ac301f071e6aa6d9f60b9c428fce09a60acae5a,
+            0x2672e1c103d7a3f8b4f25389d69b884d9bf997dc4caba63c15f4ae73f7db96a3,
+            0x414ada0c4576f5279952e118e442480aabc46107cfeeda9ef834410483d7716,
+            0x1c20492095f5c09599f0ca32e7df69be7724356280f799fbe074b29870e67700,
+            0x3ac96e8e3ea740c8e808309ea5dcc35d62ebe5d72b66c239d5bd07be9523ce9,
+            0x198f45a7fcf410eb81a12e1b309f0f95abc6608e847c5a68e3c352abf72bc469,
+            0x1f46d6ace37983cc1f2e530296fef1142b1b074c0eb50521de863159edc3bd7d,
+            0x95d0ed6735b0fe101e3b7ee0586f060355513c443ddf49071ad90dc1d05e4d9,
+            0xb912abd1261b825f9e4b3fba00f8250befabfceeb00ceb5d0062b71e99efe2b,
+            0x2fb34c0ec0486f139c4d6c674da593e2a92dd88b4556ac05151754050bf7870e,
+            0xd3eba1daa20eb618ce265bb1da966997f4c131b3ff2ddafc0c71fc035a12f51,
+            0x2364018273755eaac29eaae7e021dc0ee1e87dc603656b32fd3c671b7076c84c,
+            0x1f05f9d5508343ae4597d0f01502a1660a8e5975a4ccf5b8915712c4e4a782c4,
+            0x129498a8fb3540f610123f3187faec3fbd0f49e978dab3781e5fb0b117dff678,
+            0x219e082f6b2eebcf1de778082e847881b9327f906f9b8e27d33e9ff0c10d8482,
+            0x15b6568d2a70fdae1cc8b0ad01d746ff2fecba144f504261995b8c2f116780eb,
+            0x16da3ade68d775f641465dfa1468999906f61926e73d3e08da7509b4a78888d,
+            0x1e0899f2fb6d2385316656b5e8f64867b83dd2800633538a195f6860a750022,
+            0xd5c49a0cfc9aeafaad6415787b8cfa7bfe62c569b7d69552f4c138b12db2710,
+            0x58e978c6c092939294d1e723aa97c2e6000a5ca187653b0dc4858ceac8d1d56,
+            0x188a71a52f914ec4bff04b742907b84cf6e1c57e855aa0097595f86caa7cb23b,
+            0x2b6fd7bc3a3b595c206c43daac752b765a12255c37ab51ae183933737a8b8099,
+            0x2f3a7566a10cf8d3ea9a794c4adff2f557808fc43b07e76fa4c61431a2063453,
+            0x9a8e3349ecfd2e871b454f2b2e931d41dff9a96fccaa7ed0cb60361edd4ac48,
+            0x6a81b30ef222ba0b2fbf14165d46c175989d325caedaf588014d126e7585a96,
+            0x27c859acb50045e87ed4b70aa9a561acf5fbbc8d0a5215fbf0c5d49063f122be,
+            0xe784382f4defe97fb1b1053651feaa5002b9d1c2cb522a0ccf949d59ee596e1,
+            0x179e84bd06bd608d1d8cec72c4d182c13bc7d650ff510cf2b1f4e584eb24872e,
+            0xf23d189f57b74ae31ab04b76d0cc3f67063ae1ff17a9648de59cc281f54fd1c,
+            0x1f0d550989ea2cea26108bde473296824340fd2531a2b2c20ac14327b009d62,
+            0x14a346d622c46513a5da377f73edb803a705ee18f9e447dfed88d5ada5ede42a,
+            0xa71d5e77eb081c8570d2601466bfbea27f143f1b2c726a343034f015c81ece7,
+            0x11fbd1c03b7aa3a9f5c607da1c4164f928055cf6e2a1272506df242230e9945e,
+            0xb5dcbff27d668509bba8add0632d65ee5ddca9bac146648c6caf2bd09d9e46e,
+            0xca07ef6ebaa5ffd1e6f748cac7192d6470b170355a8517eb697724cc1c3289c,
+            0xe0dc71090198288bfffa79d2237c162ed9dfb5354c532f2d6369ed73df6374b,
+            0x191093f164dd4120c06ab66dbaecad8a5284a96ab607afe1b0ad10048ac86920,
+            0x111d04c083f51a6fdf87412a537f6601076d61f435094ea16946efbfa4893e97,
+            0x133c5913f25ff5eaa860d0318f6a4b4349fd22f2d53530e5c785b70988a3a88,
+            0x8875f47d6f518c8c2df51a786bf2207aade284067228f440e7d0307520a56cf,
+            0xba9f44a107a81cb23fba66f2bc34152728f5f5ca68406649a7efe47c9473f21,
+            0x542832ab23b6c7a4b547a1066037152a2442e998c5381ba97698413153ba6f1,
+            0xba1f764367360952942ccb6edf051c8f937906a816641e0d1e9e2ed26906fa8,
+            0x2e0611fa4ca3985d7bfaf512f21a4081141f4ed0dc4b022834d3cb6cfd8b7ffc,
+            0xe6f23c0ef6f159dec68341a87830fb864b6c08cb954a14a2500876697897fb7,
+            0x1a7a2a4a08d87e75f720302bead7ca21c8f7c2ed2debaced9b8b1b2da461cbc,
+            0x1d8005df48c8565987dbb442b482cae5bfc10ee486ecc5b670ce861345979d1d,
+            0x28122254823f8926acb7e98f557e796282e5e1271618858e76d49d0886da16f3,
+            0x2414d4aefc7b4857df681328e68a582d23b2dcffd579a8e6aeed6c61050e05cd,
+            0x2f710c72d6da19c7d87cbffd55665b472b0265d13e2326a9a33b96e95d3746b6,
+            0x2e285441d0bed90bb41d6480836850e4d76da8211b04a236dbc7c3c30320c00e,
+            0x2964901a2b42e9aea1a6593662aeb9e12077a287434bda4ec2012e36a19dc95c
+        ]
     )
 }
+
 // noir-fmt:ignore
-pub fn x5_17_config() -> PoseidonConfig<1292, 289> {
+pub fn x5_17_config() -> PoseidonConfig<17, 204, 2244> {
     config(
         17,
         8,
         68,
         alpha(),
-        [21579410516734741630578831791708254656585702717204712919233299001262271512412,8554993601136913148229849281645942416873068991157116548355045570766869071269,8349770263904395404819051886764727880530744217762197718931556224723090619132,3123463970516625956994178947134086868722089624251980030957656091366977385793,21442360932957798040744480141231788172382126494033577704060991460078536626315,10231325350034913697901001930461380417506010080725776869094346614943052057882,6920436402694617694727322082450000548200664649231576891284834027764418393590,12792717999817516574604019538349201413861750406724026925198874802923611904714,7319083527910098850218832163004092895955809799710817531274971443221833500573,13757426179233640966146754686419290630140910517321420779897314617147307309749,4049033549996591060740078431987567671358359797940903000648212935570542836589,18201423118137949240970920992151778204900119273029679711616513196892916845798,20625824460928171809204757749985517429359815439093046150315733891121610507133,10457729085307334834523167401466014435492132985358294006123747181337070073721,21561527744019186913993064335391813055903937050713577176254373319368609289121,5599728995155490107164072595052340911357670532131511292391179640158683770855,13966745298956307615009517188536529139238646569224392383446375189982202020807,17756603569040095098346793596909383204174838953876788800894937537311312048006,21742079076354402484587060728532755692106347543073105531119578054037775042874,11100784872920528132266123983509067070706469425630493971770997902694662926998,20400085312205960400585536190272432205634747302273829805331461533195763963464,20028967251238446138082148432746545470729859763361092299497853989733022321309,21646094126368547381762879012999402861347883442032865497835121981839683154574,277256790316883617863153728392861425598900309956876809085316502674092638050,829273940377701999291777589563653090200708284690056650568100074655963961702,4606908934947031763433560217361121304957410936748694859993455652227072492205,10769441872728289230396615620861141176949118733537017427393172917499470840245,19521824504454300285368889620047541794275889938757845035419559810899465345698,17161053048471962353174720811774420740284389196847515292313979813334039268748,7908822737820790247231631548479205241063360318010733129560952138908448461427,4877162162397125215823403409232508291458423909077159953565289381413423118030,8487393998302601588798118543133789294087935184558260165377494640490662085979,7454433584826937164880257351721993831542783218228578962943846432869272993591,12600486335574416961082984651671003440366178113351945406282261259087640562075,229943091042136639964977508364517877844589816262259724739584329059854831474,5964363464498190105797451630207382654570897906930358361814931706994649645813,15027885081212300130366181566116370954163923966760653842199145107431036749190,6389712846176883524184535452348872799769012323597964483555439005016828865357,13050625522428562689464418495099691361897297012535198348448952952830181214686,1457960163867278804802442802649716001232992897386781587117754753421449788143,19121642548533119996481133068671203033851078573250942970641264441950592334007,3319626593342830359906793887689227542493167081286725783452961782138075389498,10182025658554317340763807114890885589336807302908478511429803960136159439487,5258867553475471512860996445670851629850555214065072419972647507253648925387,17105844700483111456515253413030059462544811526461544189616915804056937372339,15389507448590279891790879860335127747331525679865083633840630125275096453854,8628144040598587326275852302297295030455205882673458629883629373821226515849,7225764039772127797033872800338173049227188735693607855118081892986058306767,20070937673840272071045130712690506696769042932336737261842298381743641619092,12139783026483217581244209544149124607538399031092603229603855979370010147969,17581810038009568123079980574064070648109195109589787948955203592875730952957,12141791671600953962785570868053442402210784762014326945761482080946083167280,10216251141439191088257104654134450392253712707713481968388586155680061818083,1414175852848441331935246181908753253333655328715371554777242869802352097003,12411223399258687363418284739063179467323133097416451119653175668156302546282,14163252864986479721057694562184281568622251449154036885135516034438034547025,18935280158362457804125825095786762216868621594409914695877661895590787449138,19612073572528301850608997760721508284827614275438129248352825723957284031526,19819295714156197944855748114967530774512172286810045467127912108030396642179,11371593776080642722788656520803479745110058361122399788254568568846349693622,4027805955664709942434150181718117928301673452282014923837288829996079949500,12539691854417510068939338882045915380674719248923282579976372900935687263702,21456335515466708235982252733061551106892811579323562996977622319059624115114,1466175641997386496752167837552521008018514071345728218669064866303097231258,16954396739281784813954958963214415095472216566673098897333193147120371509076,12708223137926559496125521072416503266378368566414170219615449248989766379947,8788739220646322755486256871812144068464402944468818647293944655221095435821,13058732292597055849703973806172477675203122319912563406670103404654094386664,8931344638882118593791237662384261193166536469680242356398517062367452395384,15456845400516927354313637168726345061971892967841823745636300923188629474327,5751588038559337581650296498368532807067353107651773867820816744681643949204,11549544825319477431118343561134281237789591414423676704396089395115754641434,19234147263577254818888926168924920479297919454657521855750553715796101778809,3648349134208466654728357812767145066715472797730454946149007751312314206222,7718151953117918461425809889893754434608769559584222279828239292761893621712,8845522739821256867897474373924647700071798803600128774472020272335057310062,12793577303328701474174653130332291657457728764837263636620978444987214166803,12567791764609503071525053111715537148465248715927771041171097136254310005533,14173284996087186652368776168561110401474338255050963923163796413857580470909,18034666979500281081740131331708674377786999775618310647791265825609322054725,21422354834639531449049641141105504766268284938752536446702823580190877745329,10861911722118463296713372205424749768917665229584553370962914232866310912045,1426840929949909140164228257293070123281693940796332643637029311310121856472,14301944441994042783232016477141675248310618781100688243801831318561916576546,8689261616262362847656173161257424730101884874532916838450695695508844076137,15123977840288488307479771803223205244132730982232338102604391529168092315901,14782587644869453236501780556963556761570896168324364501980524203741590116061,20171126664277707857959263654502050384578410237255325322075457593732181023858,5586442008782671473934242848395070351077466917106669778054075503048330770950,14893034316669944289540729978541666240683450933307479859464390524607307041597,16358386602267214062406516556279496593235072850353941542010428321612942609886,18848866854232312978702044457572917667782740587353338084332267136131275700603,1579215194993191651478809349088803658155969078580739214414910140585581589538,17033458213089087701892498495271710586197475793707993846597834001983636294290,12940326624292849673877504632305122955030021835426715254781235159065401203407,2093340797218797584680567638361507396244460243439847174481303012347581894177,5964973748129501579884254138099588668727348462189690734364404017042795728252,1674681106235348685135834192630054282175690835155947917214719741317698144031,6021317549494232079997036595203156655990507346855425821696978600367848015237,6518804338080390019586997346732962982860290823548982950371646893604360711024,15170463834922876947772409926040699970156014460508617331830728121385518919006,15398930479669448663557196733417026149527004779216987588229439497346738958046,2669700622596766237628533802450875322874330587389952384417956610466102910333,3127548363874797616403801375102757494200866522631068411037184158214286131549,6584403272373574724590091428656742867168271029343425772452216864199113551892,18683280795877134163038651063011198948877602385157504892093537654399764426518,12422086496748175124620724672115957665892586761203533990582978803368996339430,9745099390463439278844126903162955736019504616033755299630228960871294951628,6064302059807957253392579676216068692721552882853761726090911957467256977688,860534097291826421956520903118828583111860517568849548148819591113129410233,9809207437695386100460912579554305365027175459186390700555141956544839955242,6576375143489291749779792018893403099848704832143183847385791291045583986902,2551573667498115865454648920084921687986702958687913960418526064766186248697,13043550024569409591105305093191112805611412364703194793685224224072149855745,5369051621601119248797945023525768932797813569336410551989722329535217332717,10399989003670197520503648853627144005300436598931266893609225004624861627954,6159561484143246751423457452493034991227592994791307133044136210702400602726,19651431183851896182934111830326153107040303776630454129626690653306388341484,14970612719926241839940820046954288242553272322468930717244806728631485407526,20461999502486452961875044483247881758853878278954851693532423676388213697528,5016750536904085805050275769221233811927007383797241751325050175740220466319,17316427284462136919522043989265881044949832745678035885743571937214912552561,14932533665158850512241105212984927846164589888111067103835286341225240509742,16012484446855626574765806641361955141820105388650596409595164514899481874274,4863651915422513654068087402811690721104417928537042800794511645180712743925,9478941069339421252769300213729433894403874553023597073962166402867140590783,17529734771936454727002429801459948360484278991049231778922771896004721758963,12672015814840095133854330679674924244657276110030612294537194913437310163995,13442667219867515606432268873704321985951188504382080502019480975401891351960,9346556839116407181813364316149756946394621057020562307256030525707411763792,11720199480542613604905913885140886560194773593236018605042270421391171700142,17713550818981273796962302212731756472046580671829192490772244177376146261137,10658520565101402948486320613747540160084586467440232263820881394770094857487,19120553688581692745126354026518291549778059267410591682456431863134002720631,5837704130879353469974552270945063041776968090189866547252204737075618880582,10952573317837731274507039100853076769322123807364252392559268333440123751056,16175443191562457274813386127054957574917457114692631929042817125665307085782,15651399869272720599280980856510555798668301135962902383119739133368631494409,17982602271750585864051043003255537160144994845232276906099438195600610259340,15564417296959768207318803300620712620729991326343744282367518107640962243181,20488793123009381941807231432363887878967153580282107905075818200161452173728,20845615892337349138315927113904389806784179140299978993512007141180651572609,13259443846669565093311907999318849863250202720247601058242623542433998488480,19583450200980335366984605451914375573108173291577305129314361755545713207859,838397221216450052117952481963960818729311704107008458344946293696441980221,5011508169974056046810100610889953041631883487165044189687841384459345302746,11361142794005243853743618662384069287777450724025651283005645149554307240000,633456298666951303063125949977139107258301407861096110769739192555903857431,21529743295731761646584336858048296237991767869832124757149704140550994020630,658601336565148638150196750528474813469384561163113116358457661687263150766,7199686023207207605469992040453620774208316115852720699379826196410259893822,6694724393708237460096397340665472114749949954099504252044742926933353832323,16157341357004248687598290467887486980266976396840580002635620741183071441576,18735931046113570691341052792512856145472697573166865032702507242384749856515,6329726929169898271848965669873324332951781357803010027329026944351232247476,7061209522680426874403579559245042585450674594552752972115778072823155787614,8946282535333125111854282749852344921885511854306802144459174056051518348720,3988279129283542026399878866455129212655792613180690875708855315104446444211,19788373916759119069273555853960393438264058803290744373422102428664987314058,14781179276955000841116554151929609467906998220188278865550170013658249984549,14439714507608577761834821622197467839862763277392515730094487176490304118865,7462417821368326183154895363497223167855553631230374112323789393782682375855,14594890619141141626245598750050255728680683081531253962411791337998057959565,10297822643679438597162031819677962851770740929826506853838015287832878785074,4231562753232550403815225933022904310027433526532932589628179163940950572874,10646529230382575523755302352793337142051175018996981972379640368359926883275,12164083461947216214412634084378451605511487715584004827824972078192861740778,14686738730377226817976749475359230017849316512373192440082122302915229733394,1972065207953025646946682878392649299678417507238551179215236414492110157365,2596220810659736571653162812588827790612138851645327014072494893329877375848,19742890478753895876191378843357325113803569368242719397467948082842949716134,3057722811279760312017893583084211485332195649925192440822130571411021625062,5078380046721228959752000757775271056076152925648793679038634805597314364689,13994065550182407605627049394529818937411332791332501915425485445970019749196,8718903390300613451595895490522223543548941022555756021584328963874682051659,2830037047734434537263368457077478915382396457133799070168011318577509852518,6351328336589112831842317252922662854527642572646149728733839010100363641064,2326811025141337415486606567159001979990362270551911801543813258783748664928,20631048108966815289784074608382072458460940973738551134226168800345554951214,14721204648069833595280990040775556291988674304257774357769088964732410863991,4551815408348203166379129282299441425423743023821112768447969406023780214645,16626589364834731158131207695359287961392723773324953999720551575045565560017,2119119902895954746578148914775899257881351646176141505001582342610666449702,21198001320003994532825962721847645202213745138854311312804244693213734456020,16575653563112300802890760228610449333758690368857078853765813869752023855520,19662199829424784148957376290310955285339135428848477356788149061587904074636,14365866723679934269369638167309959664282416562097092385771370076826961535871,10462405794880410718710911820471224752218613463413073336296570316774568383223,2875852545895825315521599376020869827316570932962420930916494831426174036683,9365014190378730240070787324401488407601702337948470069729769089736757502613,10207664772554042762314615033378156185686480986853035052764356129216234339601,14593204638464636358074700677706356615788934459664487787695216859702024204802,16870253735699395936222032450057462746120274245691549241725232755997497777650,10403141045354931831897350467824057442824486714796947030202528195269765938299,13491630075210993306306680088269974619065901790274179689314972497025507972072,11737690900303251277784941365088697342741256105580987740031964012547987099246,6479411522140791199878732386964631711912096436445632282256505752750116503021,1083921069605939352705123162314489784481429719496507658938926140311574639372,17653617267480348306435879910355154811805166995916787026122631473598046826333,14432164328022071373295386637326904766549408251892516429892690428586807444784,7793671760657336901389781721891199068620856343884708391197481940646184551315,1959765449995198342923438542063212054673245344496347360855620191194506656856,13782621216902843666964879695291399503179812919290969771526164415604545126461,19078359557987218636232226316587656499460623053969287998311225512418446587303,15876205697805498189610174935234268016677320029636416200517433249256912037787,7722805406045443730324325528663888753917114626390901464015754094863680930900,19209717507699122245389693034814796437142853968464799877186934474171699195095,6585127313235216502111419023607202115168882276771320178943546160044534358599,20805733952846662054565520828206551321957145521190409450891077526078523041277,1584895259816785676773529464055176663163421450657396866598813628883854756221,20856003384184708896097189495372900159489733605505425206950257455550934589790,14069406225378546242129093232844103602751521581800986668621079503726397000027,1028001874294327945398022002342466649656159450229921471622913285892988310568,17966371882429795190944428324003030336630819228004846253694564940042988400820,12876427863944186509000750451848678588143362805691657085788824358176114653258,8715273966427022806434959651283926754916348745411538421378504642158804932403,4267431569502908019256597205760133122178817596876838981125845973819244098360,19262568227942313166139131845806786518421402326465887345846202580592913547380,4587852954486808043358798482712674466376898718708260090686361850306798447997,14015025676058610927837367157870446606501041323636097276737547710444897937611,1144137690247115846969300874102656726503285917182531654472086138598330367043,9454537148137071892124156670991734830383436460928166061331273469365959775909,13012777452486288707879402995033258068339583475193898659333632638157561913335,14224623168753818289919819482009713832024545924040193705962378465158371078837,9505762419233185123340587169990814384174703626434894051560218285882560747356,7019256137023476309554512440166531052657689673592456244254319500937647800006,17246363017424260106221670693985197925080671704985089438076796011281669775795,14408593968797438981684807585445491387554770474935530894938751288467685293766,11991202914737654500568163346559814604911312199759237827422720619371707311619,17485055588733729741263685618351826350652951158142561188142663313955733134315,12950471790443580303905847354051728755537901376411054363054627208333559704631,1323445558625272814455691764419102369727943978699511295257501714917998936833,8841255445674311239873770890653537908142822789956793926192649058263474173411,9401395313777449751102417028930156506880556083443899378760756340424905478877,21060472724780336112168263494706975132712741930000971588397970288258676527061,3812019230904757099892361572360806117962259446525402823615305574055615634484,3514498070156020200040973833201476402797883738073136493951314455793989266387,7030071313560321306345374157122385026218445152391153750375781343870025689321,5268144785716401601955218888231720448573921710587461252164696334890979118029,8300685363844078100354914067414753644670881295812529449763437785519065857313,18450162872081547013081002634376155990252513846297828484205311669445865332085,13292716648615315298838871484647252965100904015865352978197979561906010036270,21013686439245380148735850740480550290335132408628769676980938610161935118557,3221231898146718165495762474085749772444251029483710808533124131909521295435,21706362586702075336538820540433124172473413960581336734430968480142138077992,13486895089928308553329688303040674812803987395822848864346610815697956322679,17668589109420826004140047157134934003621500937594400640720194981334871115223,15183620307048155399117286900834263744557758459406645835780045985078670266986,3170561135789021599641212581208901692806457808161683895582450799937372092628,6919102281737620426489877909256066802544737782816026767549277126151765906518,4002850049662127756373199253004358198702226377235167238172929008366286605110,1107642403321371666617924914652619792767807515753221818405051786669061003368,11885648350895482809772026695774528865889321558031441531978106387676087338277,15378937381250173939485112486205353769964903768096281219667852296031194688940,16437477998115322080973717158007622249171727785394053923880768422172683727081,7621121366936849931681051136134866470312478335111295204625916349299382392728,21215912298727134138155623335764864420030241120133029649046764814328222738790,3170821186412794476815678730429053912378444748965057631248759273529827834502,16084650047636623354069916778426687798588694909600147172336375822549887134716,5100048383300431022278915674482647701788618482574130930551328380700470664477,6089313816847452477548960449234592795575689699536263376449482717087314881254,3168424144644268762342999941888553529072271091445061821545187264931478820334,10404448021076504176124328273829362151757942013323044839630548232003974036828,4252171300134965718003785947840070216898476595813167252439064205515819918152,6217524790069168495104329195931800727381161902791016429835385350530530741236,10144395323727769803680924125110392290775229805005263966394467735634758369184,16773588435110330580333921944382990185799235928388619755745278707444537536196,7377711139925591251943689121143870901330717424145420584097007639933333168762,21066973161927891686455166855433069549513160220938455527728499561969343776185,19501795117214672544349409001236794757366887214419994956397195381058548371627,2696597170314397939863800656320896858584168884088153464800095340021127302558,21168940252375267860138608985225319663694276566348965377356649424639627399939,8729578229953090469373121531954476034394661891580932672218135172268595941310,2843049930012752804094477290180353526348132895187059237802643422297864799516,11477013052507658297840246977078282722343354831202397750212752940967096033484,15309765532985207981165438737385487871403890172460978621511228072457639715462,5276795386880565031975868524294990841634011123906486763299115154863864095167,16891192769456289619320007723900774808412675144364121907391915236424354884923,16679134204463371830386366769161735700621394109825781706069839015605424451750,3726779668847121591477372195002524410424328772388206362047548845558525545594,309779746952337123192541883987405477861316061278735939472746602872146210577,6116943109304762420893019486121829026477809860415070409858407396285217706031,15461534026148460547793521829520247652146949380168641953893161519404620248399,17490188391720816485403388897026469756907238275881766262188942134609165349946,695497190921838164093269283587166536603898439348751059907333515445935240850,5740644431998005711645731796487090897088650307567273144862464339327188211037,2924287064221347495709747210800576855931727720487579410745268421394700507499,14573731858717233227103947986267826915706941233771169473071405909223613015343,7774646633424887132991406013236011457803238614262239840323638862678503960297,17118778781828713462818509847054627300883191299007086864997977171169360843500,1050282722198137586289457046966751947431030691327586256768002473254440863847,13445581272162801515105119436838273760359267729139949483205892441735924907588,18349340856764570254875357271690106769333653675997142444108297087440025433976,4652091796588614730462648254434910913694389428280196479944835477366269369125,131910217723821243570751713964244292677069024546597890404591990585681690631,21456499410534986907068306761035738313492308692998775099405282472250364294940,16716064024995806321979269360595144737028204641252901859053814928024784155019,20095956414904309942694457361888203543242910622115746869354406017074786974736,3757071258857910927294547413264306476593820051587638010209583502745249383710,10923680137512329262337058371790257353876483628009769758330988714085083694256,9956537089548622902535815248396999405593511084482117014020012399528161074693,20271486778333058297667394153786073312398256884133810048721290976749349792007,14016317906581503528126751971528140956503207448983448742275011042750601060387,8746591469817011275278863986926266284079779997046001490419468813462270883629,8984522535046539605932734670718817033319009310710809111062522425202730307709,2799492130108020790397631531338556641981343238572990117018166640120082230253,20327087348772938506861277218558621387616751140016505866350214286146319911488,16319897245400426733698423830406514849234661290508433522979200712395774573821,1519870284239742680329151132587900987246869312347047206488363104123425891937,16461017950418215698742181372949724919904570515241953684108936425007551365381,18543391801737989528567594217602323229839954429370908362237267818290566814608,8685602143546136106524472764079001485875727469672211204721272795643296788175,12069346074371335540240816613547917114412632205795651309433084773115960400274,11988670992502988905175891565316960155103243235237609851490650832292602385997,17403966780192169176887636449182981656483203656331951842717004987726351707328,11324032593816374026994927363702518223149146507370165210922763265919399924610,20234844998585751045105028410680389242420574978256032494303069254030260948453,6845765195018211653702320958640753289098798259762906597713727891164248375213,3889696987737574856084707743921432094490126858489993810406205011091688718490,18124922133262643422852054628088483763756251512543531233603218549062255836441,12631624196128994950514018157378748957581711189609992774676240830354853053921,16425963978111788432975031188568839119447517807863396285900192209489855884936,8953995026906183527591662774513923704717356851383827135468523305945599975444,19118152579552440466145418131293777218789512388294771840750929877489494176003,1815764556579131181044414049066036485535218062641438722387702702907845125991,879360492005214940756250098489982523077085264774860932709313739626061471725,6498879898701797309689806511256248775170834501358785166173840360873803298370,6056271365753495672454589488039784798700896703812263056079587620516360143438,4967400286944517048147291964513981345417368809842939145340090658371340301574,4566978800722351857193060210384689061165216230883853755194411631523409885319,1472717723310974984615849145251472221350601734805367368974791217038995119259,13776027174095858271746500087697263062688345981919975914318610607049564847265,8855093701782146194984545464090688949611436896016570549019701846352658653421,18811023873792469394695147052306776708450724591075344787347859872893669250403,7691358114878791244762289651247071530769998349760928484062499608910793916658,7225113154421014531794800873967433806904006446284346811024995482075131277430,4255179040498688460969978231175134372259939403539293652133247789357971307025,20794639690572618510879417372961642037150870482839234645523330418091682849183,8794944058569076073698664070073889624033307879863301731569984292406059326253,2823363224083068189197562122730561866372340074232470613435703914053034396662,2975786158778622849913792385919164957459418638496064741275725856836606581091,16980083616151411398660130004732794369729853408844917920819260677159874549034,10213122016673910048073131434217437693976054853300442236815045010440415530751,15622844733073950747464963822187537454489639825890383970141531456136711221220,18921846985235911245949818418983694297719932450371747402698247786766269226032,3046395690298904837024144793490039860680756832120703445515317729068809524596,2583060914190138727980083409436742233507882746342184052904895573386721270220,15629635543342892581496645526353345602210475132913669274084203765913418607483,12153931408209967834920681475366877980388294821029465748773772434628588757707,7196162362609954988171353261930756212243825869655325258155368337285953898704,10832344161051287447174100117756887153534049211780756324764320129746636797806,6499757948467889740913713634114407800462786362067580649690672122741467699071,7899568931631241171429470880810625833615306002278541085808972359443075433638,12736525266255297750005081634236953960899087644399368181751506194282329326346,3885354407428541945392073706505699854042913519198595640992547091062316682031,3816703467689192492336832188741146914005957253921702912680936907951936401119,20505128951308490293180094071215431973523299690572491020108425696662802268726,12432320732362421179661978984313902638822551634634152631489842715192622778201,5512525665270220248672390077644266875095263411830016769341860810913920051168,10270457412178462574290846807202840698511884913948623978547229481110915603115,17881266377985198177178319262577725460740518218103427901653715311091974197536,8510066829287194091329244743814121446186389458433991751573612039633575413794,9055280011331581456260576278219343217137015829507887846588161405525910242827,8463744395607465452751391868824103994906876103054045629692996934328842962296,13446532739903962714217041803396024505862416007402976354796893648172348836934,20461627446006946445871657481203161690018232261049944659088120713658680145761,13772437540389795965930455187657216773904696937414401755764626097076342530873,1466290965505206997895149562488255231958570328271915401528301574657737237351,458020438009477539046680120243558779131470015073376206673948106465783075724,1421211327829956939723172049232055433330521137466148179271043779757165996383,10974718981737058413203531348845889514701700275404265370241257111393906385203,16573626183656890049533788707333278060585059246627869841186891657544526527154,9919036431890005168544961022934926297421650894480789723772572215746478261369,16576030844958446931425212176715038836356393446209694437953952981269181564296,14994178560671337822305816896620048994236927709898591331458613992689693774863,14008584724223915404998855561309674162219693188120257826434623735246475372519,1069086166685137961564210887004146480746150199033946836704942515923278172866,4441018674700315637078726026786902627166868710369033622977939038672598925463,7640939046542807984747271754089880008702702616120100267707112408768750045699,8165588904763498143729494321532511422369875008004817175656306909794360343847,7474879615118088486232080639206966699381035482748779385536890548622822072536,9155173050525839883630603125759778497949178563635870467694197797566249638786,1792459779962272311746727109790955426562388793812453852666007819191763428793,20263099395174426853367767733535578420938395109027150658334981283108594115829,10303451485708370514931418998595531573075964003678715177508051557531947678705,20321308667229656744129683025590573929765537488045735596831342276888215355579,3624395650764060579161285692706624195562301326135878674105170566731046375182,13334418042222364794805341409419804498243524763983861307681793920401725352392,6303209034428307796195867505386756492498981454350686160404486917810670093803,13336041503866400337979868539402126587964669853045701517757148479437143265311,18767353303859794045974955054051240567712613481262860811042439117400294729243,17648775923900705033106796825075257671428721760143056038927896765118752472038,21205320334769131061393260976939399463360336322318482845795119858952799244444,9155233455417262996613263565710157090618649015115334735214563627053911364986,4147290460198895367036286052342502315935666580918696244195287512520682701639,20798839743961894523110712994056132446749297094165852697406325453288254761759,10967475255107274575063249329253351284200208982490877243231819333935797701403,11107733429142106765947338633972307528508245023783319424287268815241476152303,1684156923230048092780410733570635056170405885844154942542264956876312136441,6785232819930341498287206635949744381666087373588334711760162570781902812411,3481752771358613640419060374040695972756380958880755418404724590727014534662,6255654521236333133437711371709951475374611142503566953029069344699939884443,9785296768537417566104801168235697242332552358062255540417443962942437906303,932526381863697246577606288678833611354323840639105626154693740791708621269,9020085732775576234837702925603013416533345825301814972240093864457581450960,9671990085159642158315772309293609967281764349933520964615615069622307368396,19046031964146698646372035717767563096934497588033260517438574042056341692955,4697021545834663993102099542459528774847962616007459562129439303924850728783,834623291329335140949595387679815012162663877433757180177587164505466461752,20037517567993747767719709123741990248999315495577556924410214834773675677458,17745162106287481150568322325139792027305354960331855484108228857447789511536,15954503136290327680020013900783441236098225469294487261574644367048211928766,9447580075462399824000861225221012934395732074158377365412928734066137521046,17638109886139425399034325504572336884601102137123870982594354109676619973628,4210479489522190727435015049116453108500323090316045735249662201929219316543,774908475070259367041407977077109033779248383557848908386935310773126844186,18071521129238587956292632288468255723364769404447125651660575676226691230621,13782927851189257932376007280798546946814788900735661108027866834341111483921,9061904191092017185731693336948023564331336704118962360596629665269886564501,4646677737877430404232975108246717822854320420060743321121290725024507501530,248089340757097041959106969939801712104654938085655092524027449699183655736,1925061776519306799931873233357921480445138537754738082308417409427350959191,15090381222590604653751344079459745088601676165498775998808367167579158825796,1507946310710275058017347456880204243614713444138569740896198937197257762391,9047126832872244897061755443779135724439127934417426920025891305321906533199,13210467659674398263347498463769321394392811495810195742972914861526145024497,14930790949584540337435206846889685669928690545385782178172828133028677953780,16709614617820458913659268544942181680363927832511699782451755998512279824691,21741729565131743651162167923641181853909251404044798652854243082519505872026,485748276371306614511019734420369335387299906747036897161996666725324275885,113729363155019628451995418785166919308643202089193856958029953269497359518,17315235749721747007692514702872348378105966945192310104719562066051041365785,18164826565342651411070681557540176534582615273713551079309038721773735887418,619154088023795178917549465782795919604596935887112076630902791174323663727,6356343581175745844660675205642675571886993827862033572086056964311839166798,9925861911435596968816749828945917008180837850750226489783169376408872855250,20485137494818996958862809145264015810010636121731140334074571507470008401090,19656735537075233905125360479201796779994483024563540752004528779684256455735,15774243068028338132223253794279808721177740456197787086161475053638867039504,10497591647442850110427658608196767909160517521573199077258279280018098065029,210438711366620938094565498037172584426960275594120406278610962685482768128,14574298645311491089278146576548733364636851707576602363349001846285614576119,12543161131818467611229160618197160281328232851440846538778664249828945509460,5869885827840429160723685065960013290766384774919021040094074809404023704797,14800413279643792835835488664661954863340552091411990276270728475507101877386,8706244411264045072904148746698442560958145712983473320099851020229801141593,13670524729264788581176214636184652482954266319986131183163702474027069017797,6632699635952855355682293206130135801472538218093800086693644923578553649842,14292924690435752338909900819628889644248019746008463256978678218121438364347,17727807116656957204562694366530472131199058877798797418410969267673712196106,11223858699504492688371995874202967948461173433281557745471419331000190821973,15274518373659950909975149452889634174127158243424169830798483206460674313743,7047593141729299688704504157654237466438485917193869775780994636019451364555,3378912259124002728608820025874776626345774864595321854977438303831475863909,8837103908146248796259735965370584845236705198353666155001962958984824353698,11869977356793268256679742068396296621649101901864556682314737356997442919617,16469201342422734819465744813830056682872807194264521097865986969265941221776,12990791567002738838300315843749937126679083554067128201599773654099601117791,20519376488199491586810872596388233936561051835647732260479226405592285629272,13549175857035221960740890286176570298280920124622104651989532035707272553373,15234870385685844193215578943145814211167163612264546132211506983633757513134,18704889004070339618907065844757112006583041625995006884582590095948666509530,2234955996987396568560381823250866120960007674191266942270485492312904973151,5564977611394684319243720881013051542355462582947649518330549023416464959605,1112602741380454855327102347931753030221494100363029829630354546334828994329,9128209482091812367673670394219617423875730198454831896130112252113491505252,4376101007428143823621574836425643116618104664163736787280388345260726375856,17331301745157506574267466700454501468193891305005371065208065202603272248798,21846545094192300969525954249087973697025055955155275797969191218036594965229,4498927631211901890366201669629694821005085404418517058539528045609417501903,21785888954457119007377380145673667061898185873161711282742721281162112687992,10412875728643419025694818649503070798945684772972009054835016566542500457165,10759299704717838172704330861378107927462309935609553476471308013349659622009,20590357061487044454315237834494568787816431390448334652405889873515373283815,15673836157910318771949663697819073723405442238797105611030274826598578081102,21475838557209838850221160141181337897147127057878049055974104365046170025610,12207716311215040854533276425309298962214124105108870363296256769166507046674,11559647355273809434894669847822031984160367996613651160672893927347403624957,591243049503910187533030984285442752553334033673422383798814281778102029479,16149820605774446835537612705920133098873928503868848274855310057025837143826,17994206225397988293963936097869072606400130753097128779836685484696065715846,14255641384045583862403050464134422000560975124837558223693835399889249787677,17504545541397972120376845150557483982076571058727369435414053758625774050033,20262964605263856854671661755299361371513888427580858149435552591882491905348,12438123120680430355474353651690582027160630756728481836282192739044572633306,10986893609190710977332579571229244255566870443973548516403950419251545530801,16087745879258651861681909407049342984746351306967389910641236570806978994348,3161560484131968841565856280480697486595651138902139808256180482675228360792,13935262764632300233548760451251751405084774897832419843437366109926436448024,3163708356211087269300587340868486145250960085863061247671736451529273060199,2135858951319828747123196912541413689531634489616050528404576322173340406195,19499372732572987294622585729244698705235805453794292187854255591946466724248,17894089552733756400990786239277662075181623012822588150546768816557117698135,10627476289794518149581909173158184680927686574280550541626159986648732476852,5936760260909841348473330607703047527686233710292277373302498592584078811475,1671632573007285452120449241726645612097503185776127730816609206067570503177,3240964061357526102193296883771275932317464053465161060634703562592821382373,1379991033533041123683674223861213511881534224092884787544607760074673933288,16612309984678362724113323611405699676953754495433780645121123868554119586714,8990362216544353251183644843626621823440172244041771554179888258848070990408,7792126163077137553546721412284336099138469839853005420022151183726709890605,3411642164274869168109174406711447272755835383047387248320765695217678712087,20744964603175609148844959505361532818311810796853446841217756183414690636777,15406348836110379416850862929702053477202461331674247559909297027963274533036,6655070454278595774182716706613320667767771244472415371150701320921454970910,5387596765852619562692588945067153848362301378074547750716364254552830548618,11374645815567953400996409579523063654937913407852397185357281079289695498202,4637259464430266322534397972465849540585061569384580106712860758129812888983,11664424120893756026105365780051433965998344366144921839621845056675798876861,12683173829762047157652990138425355617601406763777942452461639149511855161467,13231456998217432692837253637279353598668867747754119281167569613817285339906,18515103011277984777089818507163076049947207220694092563937098383351447664230,12292599779221056615130747040145001893088895814628302035476053980079114062115,6616224505832681391261988520162269850555430131210843369761179293711760268991,9345928984249349577886491000914566117062182722884874880308419980252230631490,18529045286534814640266328796625676801335117782021569247528965805503339014374,9213994428894984896264727606602499546795637673535140817494171390234365346197,16046191804660661030536723745809610250792224521907784347921533311133924729200,20387305341543872348027149959300247251122586296441271309757521233850527145501,20660888328716295053746457587105952359847177180169600462778173036912653930309,20868619915262427287234582212448052350184310305114553346457821129256743588185,17663781345821195819131504897468846255222386958594579879767055754372925042002,18948627844717262137578097615546021495287533410031083974644721619152121684198,13155646636245265066188794529431453696019006721019099462642586385520674193264,11607002707400435612558884657345015071868104333677950253781252883531031962578,7814494031495579790510272464332992505237344345380518199394208941034262720849,1133679025909186037940532130396250706184367022550359228793807250960294591300,17684405674061959945309711765066024811535672808158415749778270434181980067051,12226477960064982944626820350420332900927073584585614331096659786290796181633,19811925349932047710573270972607617621205677733103349721011497772488325290731,8648978019377605720004678083600719374811142735403518791266825142192290428262,13576053523641184415871793911230224707049224969614290468646557972152185575110,19246597006093201923867388663361027928531131674594730473459152193253618076466,658606426123772934076319360192555383963003130831902899767201848799898493860,17290137813713243852250776166370982880777712118107986170022122607636402519519,5468484217427333109722188824068218191654858622412608074953511216209386470685,21574260030527757195923820887880669668169386788465310192452085714817280961577,16977301410295947721817774534383483730974509825154556215531376468755351549427,15733754299741726976786941703016488589821960074385924955118036049474131193882,673051665852885808394122319132734442090810198084101653348055105938368910407,13398071607416834058601862099131647257306816396251547336997555114713122083633,12550653745423625869263455159672489463891823157792786197798074997479171696837,9401077435832768325771683033269047231487705804464911158715103022642914069963,12470382814922435426465904555965877134678525017061716145587676176477156930917,4934832010550666003820836613445526232712748207490447572633148755378222021432,10147431980198881931337046775655000300780675339813128987464503437796530727819,568707585724749374908018432889236271799675619271430223486579915440515081761,7940313483819289305875198195901580599194224791864182697672727755313391315497,18743990138882019355059105644701125600589318429506940478381096888059645669064,21390103921503672356366200239425679587351838964225860732507169466542370471389,1162301008434626626179696713526875746106593765970497860274277780972785074172,20866648005214775989252883040721823770262915606193206494879341544251201195074,7345491533727875108206436501195735628498565230546589655556895625258093485858,7625514906338569732343456767807169396379912415318224530910677456500209942160,7862757427463847382674463970373593668082249748547169027835585420099101631793,10678296207725321824311910857643347417220081751912275071080081222106552722672,16952109495603736214033791235849594583684019147749856522239399814261672810874,7275820797336428291178396248364001448190236523398157638561627689896470220284,9969981466756203881447261853491208039919719371961809442805550510895150629471,2820683912350770819480104529177445624170795283688064543451455124015297123761,1768227783012842108298280205661549942041342510905211540896799241998425991810,12106377471628405436369258554037168031059303858931832122655790690193581259368,11133684149892568979034305171877692043755100938665306193308979862319584720202,17034299967559262110637856726685484180103963204901371145115468175393665761738,7846191388095544813700988786315012990125413238605101219369138067522789941990,18501907765236851484806470528611625980973567313044760445349490286993727971054,1249778578878632628279160684089277562912849600486367726058714364522238473984,12800296338215947544269523539435530627816725976238738793426232070819346748361,21158276531398412025848449677754681262986399643402199704435277598413275051402,3445704611858969368326297112584817848554583085326694642313172161045347990986,1096936495127696656709715702297708886712481387809916555366077657639639717937,2595620917275871104056107465860277106075411236679259253450463497473275008081,17133880510415980077665570077127522127719512648188691671645676431813033706096,5074434632642876807560017812171878490042102579785821263047865225182212462287,12326838696626858713891707574688276984801973627108664533453869827609207218879,12304708188533179803341734069046800825101691162690698708386871234713091258421,17039317314373515840113235553933676165005713953680758739139458602566292834442,17138392904367957911746841143250516587142345504139102606501472531272348644184,1667176916358419631869035157338470222219117704099667397276080580945958414759,15905657308104601519308683078473840880633544254678278144766436492794698882065,5818790161586099604498469370871887484543304527772047827828829241332373438952,12442306790659206506330372960358262675060765197848150572966156688729178055833,8830924073341698588202301965823165752475570241349344118304602842583809330430,1875325218295968167735653385555759668710537053646457950513379995102733934773,17881009017973237557824378556848686261064176014957336169110006388300690909574,6685909350747636031504999384308339032316756393531361646826148497177153343308,4784523754559868056092042886072700730690109555243230003862073871950864412709,3579228774281988929604104014107948733265891035249209872698544379599035221295,4279085918474431382642565261103862932684902464862097608738233691705350921017,1137759862158982763491809087349360013612105180026300214422560224275715429456,19720837769260646491270657488868445833170057293472427873975392955686128702328,1718964391395646738355239526986888311027176887298320241700031309916500343965,19881985451679395586972172156300827725375888727627109004411614649624414408826,12172287315747539949563617756773178635584674160408496477097950831147264075213,17818348202724817301996509561425729131915819248800408750587580377834731903089,9526094675919376961704973755217702642807170426879590367299173409422751261551,3828510101756167773639196204933352052436416699730184799283196091112205339599,15234684891802383017182920097366274346299756278272648689423306851279308385365,5259340948631483055118623587523845455777103002480150827336361752510452569472,7522204711834833179288206454714805063533565847207420606996829544233502085239,4461024416231372224773966846126492961855795819183621636555920813846035684924,5024379057555899833767820321243484415757741022843259764504133153673503667684,1944348388731771850836911827979470257687115271361319233348322098245989069259,15065306781743278475238637320889039722240861069687500843669623160807616263519,10185565710140214717926900268233420932083773824278146477403635012592608678058,633282989982188437228855410820528038963373266773393154835968536206352769131,15070609296388507673139787908428420573100959040320412658731328587817279331759,21412207865606943642342520185052032190311633739645180935143927525277916223829,7878150466166009547688919693656375135045159152200952621922018706527536944814,21647238538593110963647188691796027858369673773306895927659346354059471769993,499258196791436830394876102694379667868532135110557694409916330175138906869,12884932140229984175244344672594504633237231438569204938753218905028898420879,13897088195397438949124517043146998392030835253375096249186075371152838123957,17292635307267344947001814307009165392877577631472640481991264040854674668918,3402459730835246576414179745580422332982133349475000364518392993042878622965,16196872248846772839551997397431726113069640679308998300903092440097004592538,18016286200009868237596690430345509415593965676022902141045234608328285884800,7857847074246536045428962801424396151797565515320554961976852417962849298458,3893665144753462156875073379241733664547431241880239458489799597153819411492,13248007323269384117634056450668957554780628822533632623855150478480951625390,18276875079677833610517929467816562761552054119550676368999897123627796943528,5189710327122023109841696471286837143455102090557692433286249568240177726287,7945689534444199447942235389147404638251522098536584100372965245456120158597,5423767002711680999240727030908088708424949959926318146878189397264151455693,5995072902526586585223000514086044396450113354893476089124870631086600489121,15275396095782853076485751600594247065910139735226081476243182046971110416839,7337085477458019807945256166142271568824298087615645600806448794391563720590,672727225441339286039441508031715798485173015033624765579287288711179551652,18686118639158601820164163991883068337953517102808111440802394108699280438488,14028695600256037576881239065837481650658243799767033132853744776667874365505,58443191205451688703601063117164997697541381759347793811443271650169777861,21065693836733911343227308560913091721048742432913504195640605496691788221566,330731975523362608415899785414131718097488715216703281999950906065685546389,16761217887229483694018038191674783405871691887163059178481478503168342732832,3038029821773816605245101973977979223409779873144308602734440877027458504742,15321291577034359343843366677170820527712726038561116015047816977743924220386,13707411308735348097061010267850476217721836580681738128758120478182032058809,17436870236156178819421588659602200365388268058796067042132167176029472760360,6398050943215095842335686342334715469621392080870897191300696782676608765887,3437851705781701539278760214561262405409371984542409183492392158766597659391,7124479506211457523573057217353911508610466081033238660465711588737967142974,17234798882124088040334413616145917195326697085511927239835381731514314303940,7189678840883577982600011373449005624085144056595391210996212544957416984457,11759897219791977703855743039753523539327151517291958119140418872939095386327,20863399992661754827674386311991156323060622036945800022666816987897813665853,19303856056826570957071409328135004293560711503205766767776395391371667771674,20145537319102686898024411390314804436660254524742986363357188082440068405993,10703774427752668974576334932100051927133058205544953271144849898179475571339,18572949224433194996605971200517412011627412770605201537755920772491000856992,17216568647787248412779004183002114283399247525457054305327730013550616639101,1149230406252660804924057240581611320485721839789360487426995484240018883527,16555038770640675528229594153638806495397639088923421322231578669556920716448,4570242682115771574920314226681534421057130734296724983202350760375592356599,17057311432878064305365984063315754288324488570316135529616408791432610322138,10528094520692277398437810246572829940408932590689365643375030258637643836256,18372709972473962897678516007961361205643396632377488479769034609756086158014,21838679058944462510227588871439974934573578287277780576996692447397949481484,1580935194501439869947304184720525369376830253681649968786933642354687903995,20467445367185359735288490209436765649401864859115524728703996670394981839178,1991219687938782033642326751499030593324853839359574632972633310438247709458,1439755133435743273361732699887115117694558270034210455263872898360142260289,16300147327505011303454000556020917254890545519131742846543658162285928042977,20520490665047234670156871323008670381517271529350180242819417364083994994438,6542862810250661443960454367170533117465189617181697143331232138215407738369,1321343667823388542880641322895423041177577518845790583045290901719235409147,2442599361719607622459103501177302579953568947914600055748918886479950617614,5868547468478431065596263697373807107429411676393246849408309043501871198941,12236312006031079186182743334640941452854376343312535021115608217162266564748,10096437059927455034494932369876021874913717336999122002472353603141122745838,16855287129299048285700210681474924546365514190517193678115189183373112094664,11157210691115027557284750949314979990011151769293562411757900634452166569473,12647512288244490046752876853167515938997386483355090398954955982145642073003,14545106158760908532417185649648478400561191409850112377631214176889261943702,13380884028176250201501329354617948687842379239413597035170382200236519084210,1405533288610146305353614064658402594063683037599662723217460924638972391780,12520645345847038927033831419634817247041895425958103228961545058464030447700,5466316270148149873459535347452815877745317540692907701390798166221830387727,5692512917835452114275964699861010134159019192212203758647174343214228494998,20406430429993275527714460195190469680616300984772360022156779114506307005915,2464398587529067351284637471629204475741470377175139272463319164375422871700,14514168707742420576792107362849792246555009352726620152895701096554575857830,13270866810108509432782712956020266539382253503195894711776480924657007904548,9134846497886036320932877977667565061646780167819704730891157458029677347762,6968315929580902986583144026090679082271496835598861747834541738159673277903,7271494204378938515839411341192945686765403888626619615653078042877068436796,18286507248612017881101512297381359645934672218434256889911439358758424747545,11110097749119198784554144689049124335810208369471373426127558546444086832925,8247301320031025187145317669710241636727060646792731418249820159438470005156,14294937643948997192288252800043984341826315689719836039426003941357321500134,7348709417616598268612977306891011618520420209855159927526151677200518293152,8241665213979757536094384437357490949853796937135356315008833005380426051194,14613486093064180194908604682667542845871833534699460114586605109597063839130,9113009852475701814533040575255279924173382591876828814441237692300104301457,13165038554179369948431676356672208670169443113631826535771459184335356285593,16086269628133108266869931705626389777530735876369884384351431845165268738278,6087260580031589238539099192443153008156470383537608551794229727048294996340,20512862830064709642749702619534843169107182362836772285105007708471619038567,19533181397104762456673826441378799870077181112746023293729567449839481548356,14705683451830296925170674619865205995188883759493716060771015969186134607704,12605792817445608495860292975716815181045267213200470818664710066347176280047,3592996587655107072245474938139935892949344064921754274126873928977701118749,15294232235999070733030126460937359944041996136808334336982336855120910512334,1582309023481075306597300823293668340335902140969083485284345214470852671798,1088465469116422019323930771299807477223547422484605269302564104323452973509,8883047416031049757538663266985855517015256170002963846635310997205392683864,3176854208559033403336658900147847127925792493324423188639056424099958393072,13232382305984866276823393930594443402152224642505744090163285056748376747918,2245408257366834949733190872330311995971080118654860159924241594642495281059,2379830947280597194685159865267943843813010731722978284837340564719341924509,17826177593330561305441136255554046830158210141415356927118963102466292013052,8247294876117518524724460400399686295737179004092227538368916244669417581296,9784484010004736296495309204028701732510703011300894445280176432324640320289,5252332428538395620048044694806285484695976570037776918613895482295008833982,14121980677685920870338206469007772221567007585360563336746921691628879549127,6873280017888024918917070095341125311616790755139638467124027157089622101088,11318363160576645628856748485098328456894971803038601852118504122294284627221,4121152361595345093207401693369225144531013563993157593094962034269624651820,20683333802753484511610127216996129924370396812165897253170891149253939360760,18647670031404843711327708343249425853609227031502475411522973225042672187860,2086657429367670063332013344180770222302417569271803215009583482264097874504,19709435480590614483363007409253356879041585154641286906159427713982563792526,4258866914660942354120395242129829740747833749509017072799985182732656616800,9040566395371463976833369354842616182669127821598268274888838547664814843928,4116084355554837400529216189356527577376881089426150781634827262283154963048,21605169971906188704396331617487188526616554159276096155817564565239435978416,17937211187232154582564924643486965895957558838414375726168318393094228123633,1992558685702604567028071709121593075020313087150274357559040691997376317338,3218330818271934662263059558699096796852863135305095433439395639068666897513,9251019796910681440348368762961435892628247766190360978557679196269677702320,15836693249656382763970061319175857247542072239256868703809948219144542014793,15037961154776922819548802422798270596812938540093547487192133997609110330498,2832985667948889103643595801116542064299718867280064733138075131374461684249,17231308893316371049725716015653771498326104062757761825930828499226120649063,18440767123713815329857061224743112764715289422724359826699690594664366648275,19107308066370859685275861140608997220650596581264375407813390731366162034891,5404929079073337935336499214267301362161341750373615311934457105389796446473,20619481508117738469430272904911772560595466539395055218439600469328451867796,13952701312362872281963137538185820474584748980975982879243876933687953690941,249746714007340023576169446261897246896602417046451816160506088486861113993,2031064645897563637919423800257706696891919492795925079196751344512608989440,11565396752616415432819810596660051755078386394477458037668058318114060397110,986400357247356567494096182209394879745469890962659581282966363140769490357,4537710479751915891784323654735525989928281714716787626598475607721311119956,6473679789570545843051971615499250002895246840329033388322918048865214899581,9663160517547239942952324390296932496372339501369452594336052141919689254511,5816463053578002459222339447164819661176549623835281810359748779077848682107,15884891878740533639319804312855499125304552172182333174674400304788572220390,3033403576169643300191876532878569681892028128211422158671974606431741064057,10358010399523377550281291332476224381854765291561168350961812145251103430188,5609119676745360689177377631509255444635743595725402489628064332010648311979,9629834817212476647292649072966526100818069994746003213667948679343174132340,9902671572518009781416980720459757101464549561371827438607346753254097417791,7861900468190840021147507239605680877304969442537895993247780719118539599806,17965713539282108900380748546130491121922627970953515439952089259237956451418,11875127160859896409551848475414052588524539216162668112975117611722753563101,12036060586969767703747823124372554748937989587973573397651022172958180951726,9687479700009208904244134411901361698716242095445472067017865326177763818896,9417881715546662771138833677126201059337478279387740105578558474324645551658,1453393784429512178361095160478955627301424316545464923297558140633602643591,3605661850144345838926820161654200172773665263094741288943401786929181563752,9633343945573595088617177094944240138296472849064303543706399640795820973418,12473139325003262775761026452954333162901791070446569863302424457084077761149,12050383798910643577317544771125034193641466979797280393384224161250051391008,10819280347517551331483926007074671789351833709996171469616831904311265033949,13165812145639084020184122275986846677464323294523670942848342958951658208097,4349080070868874275277456883424617452669491031060808106496345174056753179120,10004465749978899491390807601888552616948704671794075232666191099858337042324,5250553500845345497570122559573167112673420661316457421274200097450990672373,12898588403041862218453963458103462644872308284833558427909835998108927951654,18081519381738296094081786403175972446703155704846706982096034153576188388497,17428269008435424731165207394539747495252057789950545989706433801022598432683,21363561515458498091299721959548254375350819182606817501876503845082368630248,7730068437198222255038306872157350083702057866362961468917603557490811496832,804393402354592729694369925125379986785009558185994901175413585942989446396,5734375191529745066389276413443500729878560514347145222515433157787509440061,12298550311942812907291709877922367696701304981384797706564000787234950045527,11599955784759432052811066625229516027776562566066732630526030964712154732575,19052852164576098666742966317699449063762547007283635113650074658720294958279,10025188726400272980943623464270412609902684461295237328964275116870569460545,6716809200457040320003933672999684025455855713745782618771058247491604111902,13265049252191301811995103374452481986951626617983097109447548540667223415855,3243273032455921996687884516398249181181318053856384035604616213401999420878,17596345835810824358133183122550505795231799288513594802190425260560699653345,14128892069525759858946235743223382009747348980906404699362919849705747120829,13560912558482649403704338887070267536467549681310240991684055262800855969142,5146650134021051734120451478394931677954544403196703024645198760974236051136,3656624380537215154312224820978463973302627823287220718508509926228536255064,17192240779422792861455260231600955507004716950247796731699861536149977973585,14505892053752720060006987522044578502315422621292564446333307406645448977523,897766293354199284998764120885006378362273185992111179631631299334090746025,9385522526111341509707107108914634969549440746118599228963287393277576591675,16755551931355332730912571473383446100229118084434859591641172409884703288623,7998487350537565460407312493288045720319128967533762889043801066609578748620,7253071994474199371350196978282275858691584350754099653147319975858840509065,1574915908528094850594155669399292110958198100218448518346743116412237429711,4964033462714392747475438670479181630637512997723146160177292638427948047795,448448106178274062085484969210407935775566171618153143848162702130236340948,10632678501409460480908899293916037077432376165397750836428181066894132950422,6560185425582299240893314836102079088239101938875583740502225690151903320396,1579188680045650467520863974543764324416915154559115370865175124462148613819,7512915739904886375944428372792517861202973027020854741625268080946313568103,11437215569201917203849322845056384272839597879584906569042314064918170663914,12242031850346916661228168797937142001106743366886274501414812437377823138597,20754147834828558255955521879849243373047193258439455093561468286224927742847,8071694345199003059727834592733443749021397716021823212294503054151589204390,20008195907609188950845942022048531038227320303695709133926612651814670959266,3407176450804539102225412244906714437508697739163709736953739213204054495282,7164733851792769372626784323196646242013517015794517414070184073240948375536,9905209321913745841790507726277960404981926942651589731149669818541827874214,6005284264922151317117707687482989323446281090296110762814732182741632133904,3429846891758468105169655789950721158959212737421209807144772069541192906919,8594924739933231799186811828034272621585362372014000894229076451226180774305,11871888849049325223331295756953912508046243621607006393548707001434995954238,5685905463286653736673250214945816154927032180553041236977187605699044205816,213743477607202689216486321834878291503247072102535716407202454507834205331,12562677380228777117621213265298559705423375836884092254836487933903100167894,8185089847800873546122723865396073717154949803733075710451409261160174437901,6833793650798095878312843740119765700866687688998823144083128641706792979819,4953313804596399497426456604424338320630850621290040554640752190475708172557,2236942430605502498740725704270029328474562664606378240692747298661887827319,1513449164658866312019182303051862147479160906256039744485216368678117608853,20317977663255757433651259494490740600408545133225161089258307793180016743554,2805473554735433677734689688066817081805362311169954998301659824970436339447,15815182380045621180846286591593553907538664337286124104922652024183257765519,8995040978147557956715534525198883385024370476405764975921649687446895470970,8204191497925877512228406532110351579276808609895204619986274589454615200331,9804350573365946552974871840565664742492437387015600083520724662514547605734,2670072936416198613788578252423721270352613415834375050844481006480844299140,18981033918047008332984286244333212532097768099085053122971946780791175897494,12954085820551020895974547504930170442441222377530978192526624489157895091072,9097838829535778653934125096834099047122481765699682650259018742771271485024,7412500154264631610614836174268215158855286123479543445207793653417339063427,4570719057023209933442917712353770885061956176422382707340131424665352082829,3764270938841013974016907794451240962927342721628880682930414663597308799660,3003259409352957401069823305356475477293574843963128589242837442372343327078,4364045643562272249326662669199826714126432097046293502341074915354885207241,7862497546139280137858115009924456872495405978857024048016201451567691552233,2320345330709275050815413684718297588549014329479521210951823856644277128291,3472052133118830373581093491758594658278444460214482406644025496494813391646,18719780395522132269892764976785744172160001291971824246311191396996341879998,2052034405003094013719516407189467871257070713148889132320853589752948812286,12668293034393175159240347623878811740389002104040561234210863028172486003814,3030226117016103704707119677479690730613220303512226016348578882444095217375,10328007796868265401669271360208572151985515933147061282836598786351719442924,2936234154384973501504058165728446155253408008794108135203900159696674018692,488196422923618399001126311361138933209773385094782255292621218871598725659,9986243106324062707533627601692123931503570667062976466271294044444369357821,16946417777163299571223971859384083494444080413698624920773661721819621003999,6290655646787769345150128237305014645896272983703662862175950979175390099996,21576354856650767064171440939276202866931509433119578951322323205119147402280,12396222895516500136715256668686614381644469516081823538030375243855459590807,18323538829312240204982678233417444895412920429922269434090001873145951634449,5312977696789603985280968610327711512128871567270265803635161870118441769141,1256303934933114233929368123369287749699533819478400217199836088113619997588,1766722289253438664291189751442574085464717822269757100835532731400395828058,20358149792139162776765514570327167438522971057031059964363017830738523560815,18792275959974477341072288096653531684536236050557537981692565367846354045353,11262334644528432796511003492639130680887823443747110676752140224527884546026,20501847923202184923710061886495102946632889060597711856226126913397710337656,2407267120907499137598716355969720653158717479075795831021615986085480804669,17307860167097742136268530831561503531461792239855909861554172148017416960805,2162289869674344221546800054490037354766673860343307342595970088710829183154,7028199420603561050998184473139307688291589649001033510888359073812068249126,20994672525924208572413211399438489393060949253402639946739540459305617910138,20173431861606460093483867873896693022082731481398426039971589468498814864556,9008871249428555602906292660739315591043104408371562099899839775533895523948,10700805877647067083283505504782153003756758200729717834117016178491024406477,21112465741764258732843126921665151348166174697732269978267747373163853108430,11434984188666323224207642407059759324684918143122828248101482207244887988138,19774670032646206729857931401475084640123741797887602999266543966674579660422,674655537444683637096570248236990032160746930820910298495859277351312061534,12399952541366504233794506479162333424641228812125959815028858786807335765308,10787188444435222346993386033929793480957373636649543232735691292731739491178,8444484958726309128422673453859105535823575309761203789528942642797742183861,6178443234860827296437957284319327879259579261423150811121652495400576061977,9312686778448920745396192252021125483491892057300805307510293202738266404216,21035346041382930907137468070148126300607151584874513632902588011146411628958,21595380874048139145422335028184290720358814546434544789176692636485866078352,18101046998013962303174610041325057852573934184601619434223015638490343790989,19667939085949665955991312921627801957163412888505151951175612729243786613781,6926779782333484660471017512018931263032231687078574887001518725808608895509,21080823663408874605869582733040113428551737099016002655485931862299065393278,3655825253274650356501864672127621389343134570773587805971056417535174536245,3388541056162402337902270805874665052329588330241925030058121260891155159271,21883983703980930327495083710303031860831358299523823198355219501906879066592,6926045735792789706902681099796161456533517354066439495586980016226331896111,4122959111197116982155867189740721062669675590322734927703841118527609239459,13219980757163558837707442934888299444190968070207889541780648207183773341011,13812897721847878024718349018307386755424010495939938584588468146497630813114,12798580293550179822728288481477643428051047081525754174406779865733869649777,19217125674525037886170888487423869066614323854468572412518413433041373346147,375553361556668826677041847695421482571990138873344010326810282960129792132,10834658340690112017927173678735250754641576226700757836412274044036729618775,4000963705080416713341998395751411942820883040862140582570351568343523301185,11715758996898666999645486245570559500678491132871745818362150491793495427655,4263507095725155156517595569654198316584673531155392198157637482244808941446,328008196666170836733724513867841384647787752809351062335576481522598738696,16052279110256413457891846976681654137774297241350913171330588402386482933504,8560435921497695081829647680343824474942212198090196568605135998993570233835,18716362840678189592322462186141719951790452060116008532478803871048621361376,6373296854260461347237798330630093524006414867838125038061282895929391886849,18914705717475623119982002205679946947799155688028604423250694242332863378659,3615848956195277523544974986464432491666056752600413462508649484050878259586,14319383609652049721947038362087013158818175249064317958973877909037224815373,16735322269478335929131611670089342135588205793924787907856943392431725411629,20487989084414161462431324456040544956671737924589348832484117290264531005303,991404779256099913569561460005735823176831315250109345694197087497778707447,12403152875035099961283368388852584749460932263482397452647736730447907363221,4086427505181709923565832636992346270489207870131792488930389136658523450334,6143243951533181757415269381412864770996360748004903845141664179532399602512,866706669878257575355607694505677029531447447184317717274975559227499614511,5892914572161311963309388543417806910338156401784367910536431408323821746054,17195629524346618476376551682847818577110341498528926796026110967915240955181,11821298882555096497181913149211502245650586243756443688232286290083613236253,9353931901221302781036617146700068445151424017933715326811471823048576997254,287161824097962028466164990607592105232453331778514498980389789122436840050,10649681231914156546306210447083574697745999931000675911245824305402757632471,234428462053245029707379734508145490630528735544251100489484083890623632434,18386986463595680658295944092336172488193344109864388929828691162200829447922,12209205038092046905635371865560616384451716418834791040178049545643031921053,14186020280018069417447809370772570171911004194015095921511996859327548729773,18113938321789369780471778880758786581581161378582151974602552514969078582931,4811662992940356526245596671631791612493389462608103550402208802794345444140,20758900083194181903559645045132621401748979651195063688583538188953422299252,9153554145073302417837255133650907646404668180089275208960151746312542076673,9140083548410620433186361969381763393513996980985547052071730395844456832878,1995008884754637182207447536267941537231422109677541855619755654197330974956,20815985241080261061330547616924867409496454481048128927799047536950736307626,3230373257763661238115338374579765087994728137593244037768237534083906441753,15848607284344292541615961379571084541204910796797596203678379270219514113553,10428395164296448020881569101995272889447042680020183589472054992027224827786,13680122146242354024351667942887798315658431983426300974494489056276061013513,4339724378247845795006138666633339576672603219988412146454211158778911139049,16957453138566211779676251195537106997166365265767483860476580167187603818641,6903442910536492004022094150099887848831560470459811862902118892324229883825,13517533794136732881120013247194703467846939834067648417739110803619549581956,8573259981507024845652388913624603863752296398651459450944134507080250987145,7184725885552680253794089893559736740786331382981862187745268057810849566021,7444911651670419666243138241908768267984541319117854062859415506699726860996,11938251205745649282918409002562222384447298563524098642560439931062370036028,18732676061737136378462265890132297759828778436681433094170064283098167411411,8846532794008556689131513011423108042165045871690949838768507118557843169852,18388218263536244281946085549244925864711296342518046885707040924859244937400,17560203902531872086160045342305935339585392467343746359739902020514592872929,13543101793457457855715055504451796018964110256417682942067062541530681224758,12729201216656193290459172785293440324005383463664790973551946761644249872265,20749632282565878390585307142178974866932241415051524225408429188255209021839,2939350463247023543160206627078350892997171197177918468376868549940855641486,479410521971742071578523736929989300479738063431591906751176641695551615616,1215960229051771956876212387168875875104433482328478370485649365955599472636,7395834689442865088318136274271999810879214824816761763663704696957588580019,3437039086902274758103248708959011309309143141844585728091733160570479897488,17467540498235313026126845934481902834360708027699640261573503748997917041831,8422995023428881457749354920047230520807267797593122026229940569066728153312,11738236614524316047928272298201726059224571806912522830504677268234776263625,12990187369429149609670218646295887927962536468837638994349699374218402630706,21623781561819578622543358003640431769369503776252057790027825149203611468091,5669501143149367774701636329186878874504568114693026656335516415399035236206,4575509333922357841125659935390034260822150782714631158836599383911958256934,6033679984514005206127292322842556662338038222728990090780027736088500900555,20960588060390074988596726655693601209728221976889320157850211914560680389602,13413928900186225435324599444732846219399870995843202836070995363431243049194,9234295907731818534748337816708817747432963728163044189490249482655118848141,8555123146188721627588124037374319613226378704908045460846666824116325453744,15273216586585654487893582395632825165015207795457148545076967758704213266502,11125068324382272646583837096728304098536045737064996999867399544054690011336,14959670405320615939216519873622952189488168539376564485090492806106125094875,2609137341445825321095931245531863029306734693698914386115461720635228617677,18022833118482437226280994646426462585862398739142688151319660825030833751162,10525185277608968809171389414591123336341871721390818817629448578893073864965,6744998464824276672348708743166802119889279164929133576466782672127996471038,9344118411856392638882345685982595534877291739896163576786468663773481537247,5834845743289993456669132331911158234826336724070643002101495844260807919180,640787484559876348086629339096900566749702582335998287167888457763777550412,3289778183958313592191132419001427890244410850048418852950969831934946260405,21884067909485911557708530514125998779898644250629017666973972309955096019929,12413233158576537989326032313779399359311922621054801366572548255508592334846,19326971287642001797155516864971431422568657490079056599164481456075851978783,9713216558784550226779073929454993288918740379425900055346553812422457613427,18939709206067618242082635502394826733708666259540151764313557087718564592235,16287201832008230557120811959387085081039691924582377369304872636500446900292,5278016450516276499641394140854299047658079220708153291463991663971826612725,8340962164398516487176161966485950102648589482540787401234013926762930809122,2189360335587469104898894044890322510567148239646828290042687811234738731248,3449789621053765306024986494635371148296184209757783340117745997173900013891,9143283285825049929933624722851126967075894848265558258882809634241528781890,1762589836333836268173539283261821177424666871790048223025892425442664744623,14999716003380172870846520006929664713498492291151583767005426828389694408867,6657396937759865997077915983426704746176142403322137472681086594905173286297,15931240944401174032343453067874387364523175128749141502399457399279513999466,1093656103569127166341414994548826968375416499363412936873802336598768367672,15311996490740753142335607256171022029850671542830487572556180935394970969084,2114569000427676164059607854200438792707180857430926937778356703166016436297,20765151929972334364703309580474623940346949760797265180189525857343032900699,15086899750477019230037863517768898777026828694611906648102458179274814888575,11989598054307650119711820896035556261218721126425285775266572489599541225098,9091334194223602201291135947382348087276953920280768131063598550602333641673,662205156672119277592919023943339579805630811299947870362049797370818219037,1644010308269285824046398201622466330980474102922491226041283891094107089659,10802230809760799055453358968022894649048726749105153336410430294944584338077,10002812375469387387638524822236342839480428168589080127597945114460807065506,19156323136144190554785957482371465262949638224644638616894263767724257422262,17733486484176040486420248003268701811107138651833773383126692059485133299226,11591816707957137858747879818244290349664729458236317322129399152472444934827,13438697403526660565724658068461816155647612966569784134628157461074851140504,13266011411738324637226437761946084145971285033245245813436082422574964132769,19496324867803620550902836425197207665281935127556215366411961309085032313784,17828723725738030742535695874826508863700363541225603578112437608777873288872,1354878734330830246945810749621035198088901780682128075198035721915088394677,14191386869116296861827703975696048379271311137936832987484810982707013486938,19738102036337682966068176606232821315534061860926048846327720022609950683611,10125898950023999329674512710082674945903794489998271114320266993547905724563,9735132529803303628278600229677357854336331158152745512812889827254017680646,11236813353178034372164750145200156935906967316633703292491531523808184114591,2838710343346183231321901296981007702601287106254090132583144723338172491341,2260966150439461282635555159610786965904582998424984888756770014321125334804,16205138689269860259863339330838066928731455712034665818609854024821608206800,14474351689504859217283250911440109599364797953678136799363008066531050767071,6800897037717406782446195419208951974623496109363697062923841346454038837657,12439223794583479313810611548866683769924970108158641553689074442900057207206,13368632268650760591616092601174213792332738038582508245973036690611922918115,13045024155077800673372198196114071407850396125448182263497388710529843778012,15909614634449771616261546064207953846549526793661176217246033322484959782377,6286523689254946058242241932237494136885909209872547435875613686442878101066,1349982286621373054175291479185807897612755726394394337821103602455947583575,1790249021131563196559147247422502568900570496057134946620667686190353467913,6402193114585552816271289059052503078472437339555969654050634927290142355144,16657876151292774412640987426284773353540623435906797018927318161786869839630,9323926757990898215781025566456682055829536111985821344881754566754550287464,333557759600743416321063171376142987411973146341256173569676328325670137868,2979415176549537735678518951412460315394554685744871595392830851604961695296,11399925948142490745007741431204138659570087052831458877959853228053991616097,17621136800256980786736718847997675507300992679800923101555538476888606832414,19796186386112600298425768110232392434623500274218805673491160537841238382774,6150633696896276954724869550196553826388538976047912638783098883173888551921,8007744165470722314410652720217502653722691054745133622163922368886561184511,9311054107030040402449841855464250035701299963653145080544526434268446648883,17483374709267556993216232945834980676370211318754373298278341962960548363667,10342541634151745634549333576310088998125069092773405335947539258498170319639,2491113909032842407846736301373377587232014330531326042787834409966784029431,2868273648562988738033854616949524236294200717479306399357880720258598168313,10742331131465347969746591645056052543770202432577403033214021867405353469410,11262784136416067912059431910504651513874071545823747299137490135956765416093,1202953198131460912225596542947265149450470358249744433218140619832526467659,1357188592392022798249752911997083133072840552839921198518049365021930318735,6860322969159072475760401518666168198209741930191210869338776131213742985903,17512830541972446751364043570597924188477065675882039340228337890464360413831,11068769874220100931580712510878176008480346856568608049014134908792656846759,174592415638141512586004221919684850728269107225502531102930877822615095893,4529660791853304207880649392489892958123653811385478713812028357153062637877,7261086657925858393339848092042570053113017792782297779091045392687309229931,15947797860109427499686809495296483548232719158897790339724183452147879327839,20792174987130011436800220305375988411204569143955960269071283382992617027310,16004359657196683674112642475201997234099915262640166308760622340887283269558,3052232100533123772344258509339894427157169209304015026294337193048877370052,6932731371388662052904698619255543785138918159081404052613363170137706724722,18786344120940971245053939784556033915582618306965577644860589607674568931598,5543910602266336221969634219610367731229996706190750207556121552771043245699,21500331075127237626915881392062922706776178350223005349901601754581763355631,1647168321391235121087005294677186408057439085818209785557656918589059596681,18530920602212288118571329897791681729275409540471839847360270409798512800049,4854705606288041012191490612688235100018679131692705525031856778474580243436,14030500314224264714821884320124695887543721243139555484376859209010937666224,2929002685096227153223014766825090983318157894872369622190343561822695490151,19571082362460435625048830465870659122288859631947561605202388130763965600724,16262018111979731901324396497332329657354718141076944178560644525915310954979,16511368307044025445048172352133100276074403358941934299584092446434550554652,753252068911531248849891296487019536968643055711963719939888051839316478907,4925743538740679971454033971243400511986874154138434310761553437631037517931,6674573928014195188134308196945556256425786164998594495377003561132663149662,12252972387729677079741673273643386252988421977551152663330085764982570989423,8132942533382570630447992711549276375854208836400139615573300103975003948893,1767955113430187982507552626731364143386403228830412651051530991601802225661,15911785581735751807295094148896874484829666426702209837871379520505512480322,8457495441274725464495320737396221038491121993793647195771335087939175598066,4450592062983808718489321963811761580153883581981811699755824744572598554379,17594374172823696288546149573800906143533062920680825959471396256808502015697,5396987646216038506498234734744679865090292329649749592797349235509038812800,21252439428941443609961710022512211297072223091751149596182317370399721579385,18205060096578922655953660066798909616473486532390705801648322522122587090830,18335844957174152986460129513698965339432209604680688295392195893700811299508,2642745947776207344581721189041440984169021288344823913353017838424039626428,12274412791221963394261975707650556785293993588861677826296117405653175236519,9027620387743934195363518529726678172699541005293960006772332651314467807053,447942484646789701542537528994314353531710489288574350580201677777950035282,8057692910194936390243001022339132476522458573171096947792809940102911406995,12466422220613642034159029765007116066052620609909566451840020754182208020143,1171876794208841082635913903308771131102729703148972430947313152931064171577,2996001803829960955342682545650059577915377668754838044698518610136674338212,12306305078198172670943701974214620978597606399214937108559926306737496310941,1710451046983264379967941386456520655992388623198157754427123889803480356000,17294040628260706127805165314917539522165501484257724022309899345383198007240,14850723644587717617416204055806811021029607124589054329504158261611106696194,8626653016235921835569469801636971931942277275560421125462026339476626883966,16134665167778000757091607171765139146858141948472867080489695707419285323252,11129502792062576191937938132554397380912998297589916298721102071015359559556,15130530042530114554524440015929780266039077867502338045121803478767735700077,5922013411157909464044985892976718792018167710191222879749916950629215559119,15641877241146443425426298971354708474362723075989298367558100488623078084763,19807467678520679976886734556492012503982987205100734773481397135264223200444,7230620319188569738319728589376800438996515892335609872222230868954870926930,18168775389925542038768548563310374943094173375522704828602237046711660513509,15879478673208122828337915995586151196586860000621630078538789187695874266640,6026559623764003366786032824563693874782053604114144074018595121889075259493,6581629708588609217727738860658907189729022916858514019350636298557029783381,4392179832866307866014828901921327571555384668846640428849164693147430204259,4039689077078382209094762982217352133778072152116592303105622250221872775182,9439756845261909878224812875899975078023923372686432160229876632562036997401,6300039613750170323909974701574854925454386098696929245502563775636617169329,10245787402060152709811414110506095522941754087902005711632016024561712242938,10770509446150307821311775909967816156602102352374955635502734154581919715219,4445806424060983011786548514585153091691541530320683355086806781784085761841,10891448460108394317032887254041302638257759566726100966329794645560947944086,9055121436695773704587898653339600198373789357537888127317084878411452883579,8149630563292186659644235715307853879418282762593116603286751824944805128957,10164520096412584664920364217937374178249615925628067827666302990156368241543,18787580258401627795053641123916277779446570183960070225650619813208411270515,5840281460603743032409236132633000232507414411373674275076564056089047616513,1156412247030909285380152844453068577291565904060426536020772600017567322066,13125262001118293895463954353229315406286474760130294037415093324929424537303,19341994820951858136925352932235917695982462478372266716377719180643995594202,14230192493251599368583155353256194379698225636722091587422432258409725791125,18604655597949661495485553681980778009433340166469812699886221824297364988905,9484517765495232191823212744512718095318306206191891691619884709082351623103,20661548256453489016691122417433244991048818711049327729621550642733467464794,17946084952153038878596350204495193827996043096722462577062358769356218083033,9008616567490400741620365097652579204686050477332773331876377443733844010527,11222501299614818564801113661500553859475257082250633539503337648966645140931,17547881514301195137575407746474668605213387222566272868597007270413523256918,5795058045621081034219295632641782062332989904715400020698296776847639194943,10503000549984486673912349445691696940798628902104169170719393589667267164117,20627605141977035823281920467011832985049476688278934213570130229801586759490,1617802179061215386952772461423280627948056362689193604176834379576303877113,6791812933391289387114968397366223795809410677008110102514189342693442788856,21469327667867855439208525645169470185070216384607993883382520539336879692857,6209704596259199225388050030516880246912805490686902979517644524792187929012,15048235302521180373501889249113906037936587642496276368753413449431797081949,18778185090591194140890220889049934755279881763207537060835789721322305845157,4164373610491096709440557803327678927854304626112734913682240155408254130319,6352957909818668217728163741226734988658723962520906766539822539894434836600,2081726858060934846688892186400729209835095311388667168398290314717411097500,18997085104017244551079822479039381301947270057658366559839643454880390097993,15381301300391534710642382148869618456973733474322247178000572705046719371489,4198258606721523455517040976251319538290332464337310822593109666080121166366,7557782631251063800473816565466881793101085796415715068491278248627266080710,18931480224318877255548108668163955495398356426693160573742850933557366286581,14006438920977933743471268674953904657230294434994593269165676508225740552815,10552613214353127913757671512246056403297131067811718291694487016254806821431,6942360360107439367031353171424554084301681329082198856946152988574077265518,4821893567676204037011511732637248253220700045205121424698817536976139720741,8570797921121743873772790445200803600261480452613730673514117912909339929304,10210191620579364785116101817818502747961980686320008627354511305745123505207,2219514545666614569412405614553938185242666345781569909039944438048257115280,9472494948236350938478699115530847822498160599193967472596054792264811505177,1966000492511706985369338139654568276174679894528461227404736596640963023833,20046698515808110863133254224236843582890061845803004799852246848232152965906,844879645041461183539563036099295737132271525297913466134251805988318847548,4731835924119595590183070349774829521463227171971888362743688018910258502055,6665591397442095781758927683212527568272080607916992672135848576259567872049,12479020936095094085154050050726399793348028251321297846621658033596298393726,13547094394131143768607425506026982562580191167096570425566382504500825930959,14726791597032654225590630927699963688874228760066722543952181168729825328904,16458751398904781219324882164741165137205147400663608606201428995139003250837,1382702744652547575130131869708589984736039127219433507919721371542416805658,14166947289061517490924648855242003709961143010494793848406604325534604905674,17345393385322406098467895186375277399629828208438881931258894959842597584446,12612093274589904544460621781003810044552285394822234432357810635329000095532,2278721075910399058699498270814807833560549835812826924195171790394865401759,1421362911034706266530649492401610048326109063529762443419685870164992649589,20384150845787594899080953437004222732830782572958598551146508153682280572403,3495056095843097816017033529053032886550694720911641681721955773137850234745,14487246717687560703169821216097612442592434246076605506691782211475316706576,13114661974362015466065924612631881453272278776220284208159815065535423486323,9628837478322926908639029641093928246719582225562091179037197080152788423316,16456984127855989467975376775709400558526389914848937751741445859284106536098,19656266549615253685970702218272816322599871270060998775752454696892588799707,16028536897482325114555541492282064621526855756620164892739323385311597784598,11146275353887579825261271116625263398084632057838305651534583557054398181584,1266798071261939757558459653520435752781168817699931045808536221140555755937,11242956579746912399423902926753108012060763899073974272480062541403588053076,14588608018127887593991920960165305144719061971763947578582110087376128309227,5393054051309402705329828859286427425185515439646193479342950065083063200985,18307950351265411595229078848795494559405008993794506472277342386767679169011,743926999062879465491123202608691059211244131659206478586545917792531513741,11450449580887323007201214040662031298427088361641716342102428346626191862079,8918057399138776974775397421552812822591030597414174436378830421562569121660,14007657148016840281780221954150751472316590653604019267269105557294795817454,8897431240575139049076571283304115052162507033543918057893215164198174868677,17409416377040437657574990618884772475255396933561856228823381810258648281132,16403607054571283311114350132750182990388190855449188101005849970173367695642,1508877263063909922036861471040526805004287450733006660015588614987220564178,2405929790914208591765690668430163058227989428739435027301989746453297508008,18415257845847977290620817418058909465150962144437291827522053905306094819516,20783625745588167215135121578855692267545194811392233146323762172638833678083,12583735518159929222168953087285648797218797099708802919538903595273472024870,15030113532753402263141105846533650021837620483920708638977418255212037916690,2044646201923266135898414814098969242685760821863709223961924291978394037140,9562505824238493762747890608580676752653265912034931437600706699047478680911,8576622443481230638247834729157921300954369512398151853927361194153863723577,13502467573105057302451195240442043465889307076796874707692282952243564124313,8659508751425384756294968991737225118186991099981336883558347987313410663071,992836427155144083079734949008912409782777055146977880211513548288277680936,14478698156814197173486553402886358323315401752422792440407576984439553283243,20204662700070586254342470347097589341087597032672938910846995633724257876133,1812172830570486768023198219726218583158255123460220955281515074543933097836,17992769749806193849727573532001735714323064233429371707200828907106131204931,11275304845104653478990825724663443324387792098049434796341439810037846570595,11105199526118828533245892738176913532701964584183761946009726630431598631704,11393903979182757061241357325556769026145343989318381225525091986823175945546,14383047179623652129287498422471395756755287245693820194038638652931729043624,20453515719997662355844823439261666280107449255435062001366805179715649416520,16342434030539357589118587629035849207895930777526269265833103191510088418049,18401618409669783606190734020469430253158741609682792710560527808266513994586,16076963378432439787360187815002671229026877629938245603309362816936414414606,11529521787481754741418171353792184686967806427253956770441456297160607170941,12602344479327416239042579290059415968931395895265775848606068378636646131638,7874996576706323538862472352643073872193797790899948188898578232811415974069,4845431324532575010258701269749667428252187973009639700566740844013627970107,14802018959157569593654049670448062053140035551074745737518084801052997376690,1438261891736096301511736944301645044858355530036359764344568183983865122024,9702483734495711444970258278431697259819553205295174290488141405714571120392,745629299152271704331537263378566091569916279264951187804590327433939503876,13647050656573274198980106604763314305257288237932552445752822394869548724758,16745795700152546519998532820179128558740146524138261377398336069302091938316,6511309643923082597828923519243281993300211181014429981003702021394673484309,3158509665257424804238893020268668038794684527943417360064521274731483365497,10106711021741632147292275661510721445094446856823798214773373487329113893162,19539597394622940270506324036474158048415508212083560312665281444636039358507,9075752841443178653052367723489194637305474480630925657941805297419704103107,10984322959292625191378844945459317193701661510910417025411449026843907121641,17927313671844804578171839390174936993766288170716470877087434657482712787254,18872143162724264635018175304456023676931184143071101308504884978404622981510,20515902079806118899516548385287144085761546545950360604606371922174253859996,909520465300399063286844098900959690198495601569624327409635184475032912958,20206446745684213293565932220432184473350758436589542174203682990821527627997,18202239467972118142408259480727588505962487821013411792329301914239859726481,7983919062477498484336722979137049758716865253938030483468589967847498836327,8325614337212122905531318376855865321332189692321777599447159536409656516919,8597163804726192574292212854626326634508890118939606311848139014738137868745,18500944130179290196885189330659070775829081695220678669482033354888226989090,7688562031300833340110739922365866810835026837265955101002957176624104705373,19947182975808967149585827952170169153114833389807259043148589247054925861923,21517453591126354047928769118216728006629501856431780724965733122370735013602,19724728051616532722905708549906983762154956430000563385110162693578183573835,12901041676897371025108379309395257314967524835524863357724200518477312324601,3552976975075178791886580855175573474759766023206417049453393296909032090255,19723727023156957738383690313848921568395238875690539785344406327140649751346,8448482122526118108012095036728031952881057181233719818597059954973230302598,19506723656402269183886569439436103718740054288352928129647596321989076586438,14170198227468034198358292107569967739463050831964193487443803219358410981401,2398884471809169728404698398912564280110318964918284340553363751754870608551,20316276154960569208855163430299959763482642890911503054443013025286320052982,16819346170274370820168489515108636849055213099894018965040750518138293949687,14032485862625099598391073907784424901699264655891124043486362510876557553033,3741512032866709198636578814340035900693212341083373891378285003365821212725,12320998007117681710156579111620440763582440787871319835484669927670822914066,18497785580008161471127317447391820533755559610828409772165480020067085485597,4405750113669275276872999085838121306688869906871946649397890860602053182664,9830919490764773329556696442544208406733862221424439787824742578837854955405,11656214840454358128291973754562337687978444406755233034850997851692380129929,16862314752433119612255838474361565358197526603416756657147704910780503202458,13994730783691699927566696508271362101008053907735972055086535421903219406757,1854398114607336170485701571991055833572643201188015258021784624866312103211,20069390379729391520654648717585246938403361904664791681209786618785720069963,19778444821535136400266636630030874919578160245360989612631440824622767847607,21076683052368294199461719450518198858527944040936974409849054794891242446768,20411961758852468040955165630870750226459296665790953169982230333559560296737,7502887992944485334895259919103098713153732704425367381733235650810817022601,8197671201190749689041918593081864258260291777801687985230863071067546597951,570474345973383626887611250305231463005632817815912456645561438458026430574,16187881277000098252637261715701961539204559080071010626416256497925074197451,11845760454453819227975628605163841650771493308562299599588237256809780809041,12496905116588812906791602937225630677262600876144492834414412499317258049345,4202178453449927253051431595142836159883278283876420191896732301089503127871,15280239602029688372093391224297422856227971384132785248484775299588777602819,7675624637796659741242134119256859966414372807758392029058215748145801821134,1558712828795805480069595730092542425736929845400776453853052297930907571419,8635050664405255712941235442916789795311088451605341529181390886210645594786,20012080883240845774134523050094772793782396855825781678689671532280266223297,5332665745663855702669515489737590813722712486482340264533181716182162216492,4485713577378561256572703202440374134284884194291407499970429041545518915674,11594166683437400908552833183389222213106302657616725421515671119008232951402,12334131761060442183744872783660449330900007808735685674075245978195977188916,6469473140282499287719023824549928080797880736382216700350093546124693991876,9636916035199580181413428196442500662713954920605937945590797926723030993514,16259404193045476674338459391599179316200568243819582010383092764410171324132,20780929014533211529148194875929589500835169316324843103846798105106103748435,19665958036420604957261288306620614439114405875604211377014353932489316681936,15722491897648578237100473323139351762887860215830601049261437931157637153597,20474814639824406443111360000192533367769367587690127965461453022108167666929,15306300298273142257702357120212730128497075786589008381550108606914393296015,19116371381269652319147699604019975103087973589614811479290794650138683901396],
-        [11497693837059016825308731789443585196852778517742143582474723527597064448312,9160854578263429171202421862962594026987177464192712717562131193605088890171,16140003334191084124451468943070902129052879491017160345910048022420147165440,13954253824852759534031493316905992731351625718124698909948022659536770029356,21692459647877833789326815072729212414846887919903018341690717828718320112005,9941936267230985844518782624440910125063679135232844826673261884947459743883,13764916706054812213341909699290503443927147550756936312875016380348026052252,19102599208524798070012402067365820884265931087114568811319734727534891174260,2317229314815846955024814528087757341110607641360330608288042339421595574836,18416483069534816725178879766589878658686265350707575814092642317380006218736,1008780931278741447191637805167409477999443010661365677836100477728938308997,2545090804346934163783014162536858416885322260022963915511642447380970940906,20063061892576784746234714844937263854658165123147516223299128773175198821424,10515454963476061878165006305843100325941655508909556343534889232612007413255,14666046876279128708964624720946075308028756066224010008571298456055047416803,1019066804447509488848959767263827580870207313924599851872882869076383737080,12069305948801710705684828347680772060569105557945593846885134778987150642368,8621808318996908879998215444507382011199442894883948814246574848625262495021,2880093917191730817222149621749122107421670637456732204857760380124742164752,6542220672426887509675431131054437027921301676718161645952700116082427886835,5244163576308284656156828799646671881031097312780189786429450879353224489935,6473177356818363685990488940547034234726012773074061935352613261396549623686,21820960109882302233412313690073759484098924860992104203363318963429862834269,776485012941102583811996326817291151707768276005464663608504425462324969189,16008040671461692654565857317129301282959438973184407738728929267807682783872,11432621469217532329151110587073289606303873577842245393046608426744660231625,16529428848681190297024382986484471912959470051547049854507168832330777582917,21022141832384945339899318910964518260971220396886777286264903115370862218195,14654032557013894559632377088090851151746560959506805696507500157500224672350,21354688910115519251326230418165921377662159943573060390104844506964336391116,7752619774088278019865202458496784783724532278543560344508935599686049023521,9970654674664205783578937362441466301698784253920856829108173973533602978434,8766781005151378907464491478911534398597711022218593484510275842885145890118,427418044823104424459481289119034112585817787122063948281766019090147258009,20178400825368362428846659280983736786989246199446877730902913555280765010239,20090950791842994139452610863206653079874108855048809192426038290381481405709,20312256534186716461922298801781816516042265527822903054862895650988285562148,4909922693172591670749898596465752034935631291352031623980892388245203503556,14711873682305388680005649678171045910409841883308457847530167875811246495050,15958770417311022337941451962731041577578914593218560089308342731268531712920,14344571866504726216497643454572836820480317972842515429281824926793932325980,1769397319845168475613819781273574132774109508454697099778007579313922258588,258587389395146525547707547116022862705614858555176588203787762094788370646,7022463667655232121918607020344762877802128330181623732816227821885112788637,19845060031908398041047500648731073426448577406797522741285587091948148114644,8929070527835967284189505459276001504282186650781989399671939877306459603924,3547034362934554702033015610070536051926221082690581599667998618549114761320,4305372853651357563855521637099663044320680997112932657745973067738472275743,12214176886158725776791687535468106829515395407992835497927312162638766770078,11706938131011539306398383828922578377803816015869195385220014980091795489607,11651169608106469169652973769680487604343355235752770879131657116772958352610,13534129170664288430416028489502009030456779206590118389136628926201783734674,17992046595622622161177230469344714863802535922717313714552838880957499215981,10357743233228120740298650287569640748031608153491097653220067758242532130547,14517928487614900276301089165901434951535050275402697067248151083596639118376,8209182069608252268840455827520737704804441580266130568152978886513947166844,7640073974915695432060688995568585354936052110685953897202450273254409304465,6665784939677502535233010310165049782941185917893655988878440622136707103599,5556533518127592657586282330044128807869230494205809390140992474026365014562,408852126690043032125614061393097734033642541042497038832349288207856020928,12457107183372565990532088400464843754189254530767241274690121422398153743230,13376606774696045471509234199808902800235186345177397461276986609303176540711,5984750790245793264714000637029537436625478804219132653560918517073545131213,17088785934598552415567637681327922806463774512289686863420148678865116179843,20571346584413672249720180719864302959756306192295084730012069713189235458689,10563908856437897624492808163035753573292724651291788140893440219493498317425,8196914932493081300314276778567572383087801740102758457948867897900124032622,15351358433647454670571026954149706648025357095082471550411625465102412004635,4691549575923073479244290910433477874429633596189924034857922132851997509067,3824402350445187488499181297883462500055483166807595223590583390670577007868,3079709149206454455742256725666572935951085219797765997598190006202700553625,2933435916857570611285367519434342227981452027299670163614250683347221879812,11563256620627039928684054332499213986056102448749960304814905960272568400553,823982800920919472728462051408065816783743200056445901787723684868401502814,1426387027752743868839120378047531362360888408160839303820390910661721602405,5731997056751920185589748689260608921390513807500493745181552863591316000292,7720993839832885597994588400736035173902383878486875722645777844101744411689,9002464001048295091481045293483875664362475441902824699977741340020558338559,14092406920820325227424145554147519809410886190773484884502907926085878880530,17941121573263204671416572834368313711647830547916231506552438869447449377380,14129082317750218835304685520412323779932243077309313102580200435673568399019,12243264707350346605364305720479795822428336866265087370053925276897423448873,7359586883838006703688461248312304702229090925413466255532354254039350309505,3965462104895971860844762333128974051506845133345812196538391893357098668635,20413404046776512481224629835753522701244606906272947012890416028042446470875,14776939713848231582251698583594764736648030077584017202377553055729297756934,11733430377692682072369036122380634083002891720790435745639760545087660184574,11292503903510690808481905838273174776860675950299588217800551517281190922743,11420684871520848382159461165975179232780830769432469479502922603701278643559,508745459215920279034800716428719752357838311731203417677851933253804443780,13406614833603475717176189537057020401687589054028958458013676908546295198427,139498778461763532268768837474164379463641791532876816780917343085192436149,21267978943610728192699568453293742013765519272282009809779840168468272374983,13427075011225899058346282386775414644140701782157119231274761492276104178003,19408556542747941554117161987423225644412569826994655839704848575188694207985,4344748623903456736892311801593408666061687792073497811421388122550378864729,5249164170024197498338412206444867159273343488553715674803882832943638673489,2429321160057297680775462145791389342017255648014188548442207641044604477112,17633034583356484958669009250049760097861376611937917426871239574846566954163,8589358080626653532622087734866363152181033731195407703922685134228472217961,169706674245923892154983046053808641575955705892301306744269839968148939837,6930563539197568226045059034503291611681517204525149696500944995384070682620,7715180204730071272045176332163669182843407084675929323110162515552729145466,18820951479360410886797033460215573843065563410033088307349452904607006418510,13004571734426490172877737218587476803131320809388224624418159739666018276230,4221983194911935567520445796137770165826124860682996668925096525627918503987,4179458328609322852016864400883248432169808675570811233121213062838243996150,1974895668668582620251979849937803690939422905200315076249511583941627363923,6163089641798041487723906004413611225955533949531028903999813030048150618255,20798314848405704563578428763355242237484138146926032039199072579614133708498,7390763848541838674951447729994978703104555741288179669331719960925737939679,17595709281213749734228944927123024058411855966868873405155429088809356857614,2441295378821425129112278178696474169691086102217838124236465522719015824771,17849999656709233176331949642982487670074039937621948427273232063967495006615,5474039350730649299741439140946492457291098791158740216537321189511814004320,18047496680368319496003204418900793303422432417949101604087210129655489944730,13429638037186326961998474643589136448656547552567706898682870898125573018456,4946359485751570678621380009145072972898871622865400112232372288432448523287,3957822358540559545601980592836183988567881320017369675759228588453032530432,2400564715392273231728553914090327718988368277691346375047322875638060719294,11894303179337833272080120828007835602120013500741388580434416759507002392538,855198138664096487124576201178969627556714572486300747020353650684651888948,16178438790960495615141009256088177242852822581784859562011828222911238142141,10137977256085689928230181030370096331013301569857962720687404778057694535741,20515298296047282701750471139118794292164841708209011112551973440387123890479,7578927989884657210580284649728673292510875058413984297956940891614841867974,15739538064110791981043195085211350004676897766248503311173839899207608217532,8509314140684268376822128791119356380924264099968476717867240237437611156406,17940958334079989608306082569922896755033794405963583994940471979845228834401,6805144082112931458671099527607595264417843202533041916539891329055761729898,17799985834198911964923035884156388240555414131807336706586014102549806733421,1321093977038377443723007121319910985126631474786194145179087170534580192225,7212420993868874204016591911998823569295893131341249414736874789036080080431,16508732240056273863067547854850721821696261984346034975271352570374366672941,19365952558655609049762470933563228578883041309045062714419724629518231309330,7130642306151081144305696424018041594798737863203511582301667374235931034428,15515575256858646879456258778282520667217724217234033369846512585375869363745,9059306962111196078284859952597377729932287486280210246946890053176853282710,4280792737479805409403664514498090636723785279466801897971750554236293020515,597858655089478477234738420519139785711327216887739704481840585427214898574,12083197860096972935386715826619665719725493525449003092099143765304129114681,12386885105651539176174534724546204378869340659228252756723599802198672140462,16104345036536728728283892631581380860380214418375736872156768647788333934514,1354879242449295308208627398119082438254972230604954870747255418847391619159,4337243085646703769896498772355566596731636687256987520433742534413482763248,21848361732679483806572599977716282165817086425830260890883893707113846583427,19219603360817893268138318807528436572901663409914252265449565639651815377666,8493170221045553556330983879086435859112709446579471993956965243640551891229,14527043796091130553415865581526659472541220106744153300268446542314624889828,7937111786465239058321924657743649234315319708955946415168847089269341907969,6983241618969891267833664988834562719925952220932975709556427480787427509845,18465592203176453842524453315376851907098534348906659566313290009668304127477,12577134888425026368283611608059363450080978991251364658919457233283032077618,6518118228984271075704215109336988269949556606855830580887066004852197959585,10874313757780612756454383662805810655295466490423990025119534270332368723291,20050459982999023948350579488832955163413000705527333267976511300912322921717,21437528840108163281775491180120464654045652656938712316426352947376535924261,15993399358508475124653838111269121783855992741631266590611036066175654211556,10666318855988978766724392469406816805194254878125837815249460550109965279109,3728246313656508848829733684629154197051824118611903835393981369401120614690,15672779156766891637063280303644284349935441934769848438404666835306555334745,20385059098581842810391414884461531594818480948222590493458925664185735049630,17350905999329080753256083745369335770368978719306867594625495391694963226620,6853271030225637900654747228083647747830481256853322607732231926920221636638,16945013335725553221697952514726788415224349981949301561114619373330552300437,13958698773337419850196158271441769489630950623502500296722238460406723080346,10720560039907520317176701532328409797933913846226344831945799921818292744504,21881661898012375513399335499754096939362343783241122010305516740752509759219,8000150875389840177411621828177856485533123076967778453164076865957788973133,12006864256015504014085835403867962462497397391751885107034795661085483190829,11134943591559521791276826061536197135026619606969540608969613264694780202214,10460719249321273180939167776515335033037028258913526408809327052344611741158,15622824325483665989612723680117847052463187830077568039968213833454442303285,15410746446975895232352042328675463711076427815985485297730903996168105249910,2891625203408623652388062275887825901052275992286085168525244670232353662516,13945346776936592111645435552497641082181197055210791224507452108313960355724,9948029837520576958543862437428843878940881432043095435233721163595331057646,19462884070334019417166507501239463855294968830363882698967905077860898932836,5520136928844106525731832126160315598282989291025512087174203871698688956372,2261360495098633227748653797124151186175710067614537829940284371045336769476,18416255543912854662465760974639117371049579168655995592136361451572699752296,11463536517819692876416279640167390882172379596277754722588804736317693209031,14766312573746115666714530391277822821010415216258152152785909105008723593246,15974413313983607427146441647805917978765835122483385258268287590594890695726,7395768998784322986017026062700445312131764953109410144512127957624588026520,4984362060666297962621166548113407854009922708767986933509108968930963325593,7856069925664789206382562869453172139307214363990979700110954142509543954720,13392340056392075670742743235567931160245313927053798436913893965097578743589,14474853581934896987119860016624045909083123926480713073931600741515836999440,10281094117655562522718238098582121237113987849950975777935895552307296780258,15651874975250045926713763993802349605521485743295256479167713866101959393837,18837584337473843738351569365992574544592556787094567312567026738414350732486,5422285873429437751528536004788420694267218180077508101272917323525729776286,14483434861134394018133707852914799521209887335043004813883706597879855694501,20781651897373919207655051244184479648667009194959049646213659882342077548670,13257874746816536319517386553976680827294792028033921278407244416529098958298,11687595443717328453023567060513955787814475781716013805208754435947875015986,18166734702075655056906373297658555632769934998914813942424547912757194661408,21844245024899402789239043296889438934444349492098488274411135961103932824086,11576523423366505825808301659798885009429028155669986846400153307591026628871,1148929907457849288972409801053032039492913919668345502756020163532587226569,9833563661199700341560575887921549871699630430379479441644037429312353663854,3530072023449326955819177530541286351102246058096342120743109127661619847487,9578572618820421025088920868463234434017082077820664789170518853528041438058,7903274455513569732248555355877155817202990193424390098928646605922794954894,15657165496965632442135478212817895834512397576120080820666617370995124184076,20874620177603797416855214546759257732117862468392283423272496519554421621175,15225141515575386127960844403303707527145779098407107474807381929305493685913,18969726739742369826201131743053235807095357084892793088520738053078283905792,2273322388759602026766688787958421446004694547879317377854849512027808056744,5432511453110863684214390264939773007164867954188379597097897639266721931777,16573736113133010502307046980851924227669732687124639246608245168226674694938,14442377229880210285366376088368281053151209045775399428755468734230536622166,11507669956883827819118311484641373285663729813488745641363568933392081679659,17839532429606263422276008800408286253970022114288361307186094837217135904945,4014265539378515041529068347957642340321904838486974789543291691351911347680,13003411109936526663340169024379119873659186776343250211166084846025445488231,15306462549196010658398578543921194922332897913051564489815921371400376655492,15374920278441335059913374044144421033417626851032526544458034333565246831914,2323707387573936061377018731706151895551673463355017998838984100857163359959,8763825614293136074070194100490720958859071057754803255698169463529260604989,6460078619951263360498950096593765796985616066844041272594234887640757495947,7787749571541900537576366919010287855513576825542236245962970793208463720908,14155132064389382746286911268123763500605059883946776474093143918456417640061,5273412399684398435707041325417233001212071630727434066521150499193222197699,21782771343726562685905794523874393783448988772056027768682759741108535654588,2051311409953010480673263657665054154914165583084681916263406447692393737285,11875661765858469891704167021983258181748059479218144774825851054326067416765,21068403881106541076710977164706790160208140346094887767675202443752560686192,15758340092420689120259589661569467106735378390624556577895360824207644286190,6348044865909997285104441438862139025250301814988835887095459638724790173542,17932524652786058307278475190078972097828770914834668973535335630530452917847,3228816608788245618072625224844244257443056161113290604232896419878090903926,9551656383427589703749567396517141384933708835078892692797520811547619069163,9020946637763713728445703977273148745690000656147983844173946393849341364502,2943971707938849936044214925657955353752398302351355306608002652427585494465,13685248050363412502458409958081650237171619758299111626717716567774759779438,2868302441860272746035818268943730589208611466934920188905195434962368539498,12942754961762450702258615422302669970585456811961698112554744196254280397924,7774153016753223166594232439290374237307352882928845881491063153885238423849,6049199094489456460150873785624904803705527267070980629871787636829670320696,20845774618508072345571200270048422316984213457783733272821856328966613453129,893781271752145245996199566953390937322128434854461459523685354415462146991,18253521160421279022112163574719081086152283091051794425756555232523003389714,5830356839546054218884630677325272050228211705054095093735137780865196640272,465724850238100756077164119125411924005501292693566847128509233889037994810,16128424014911176575708362980592727342883849823936273728991741993116151256846,16294469866182032082852110477156803007474009685855833013024070339538767961172,16065302076211391028679793764673039756452069543133653373534107626161947643947,16884841668405833752583472630774457863811531316950980947099417366816649918715,6491186733352076588617073683591626846805330965399318749556699217006305107353,2905363039904017404089840194168764066155916074074586587258377722869451022895,12278525316798802696433043227895855967349302508482435733539545800309845622462,17314019937917464307399357201462393625411723762603710024519926241513301595993,17575148837153403621130441476206668397295797814863081080474688530411862819003,15471095648400918007606825575051718247465842587885842548618709676930106301461,12384318072593682092503177281279533170809948746241154089695346932340260672911,485123300957579906724434519828279717066415303115967428444773045074341666269,20783388705359037084238123327815399486599342641041862648140815340928809400500,782158089782171747510228803754257660300288627956397010472288943774913698434,3478639244366860518133129066736643188173227661380443503605881541719237123785,8117881660412001220282982503758841397343065193097821242261528946890929063115,35058721234476129650326366428341402515138917944396335645144933468879076532,16397938679668108498255642177027044558510343548921376375827648132906803583443,2433453154751221667718635947799318194191827076977739122814782387249355591958,10029257080729083671923349509739320383181145104464214096029001591053185820564,10656149073844062963681322014553075060763965763326275398946747079560564035850,16593959744982924702318121631183966060100893770061806448540495161947421822987,2068414540408163070577553011598011878961687148891918803076043034635892035594,7626934390068570344424013149524663454707020514194937543157326823804903603467,4554638618925430597188146675680715151198309496396245054063619103455584547039,13496396626587678250552586498039471308586222626132206600246125554024514007655,9386575758165199373292193827891788760863572720909068403298778509513288095168,7915179166050735066974287284338956896350001911949145779842510041370266325973,8167168351770465939827858686491835211463722244546741051891842055610292036496,2984855641991264563125921669666111398496570671860076360618117725463255935294,13345515131307851631101763161069239153529744919878592460694942948582652858318,1683899377816547722982571372970082226593844001913781056647398610840773630210,18082738493041031740109434905429676829872619916356658605260447196047710914008,3093627219579176143734483600677215286836843343902256951787659223143740127833,13711569243726999863512778161983125470458400981069655361767578939766971032706,2942999073656444791256166118886574877976523928599259988730412230442182398832,13741805436257583212406513632778404280140012772934699700695904335718144229392,2966496260001027437433299921197242880503083867421600405476235949236365134313,12214449406116917832159291589682410934022154504967698746834536840379875421993,14724028677081535225097028894192068729072210977241429998194582705094787450320,18532472576071611894578331306492326674151870705350144561012248059523768664658,12590949238667856614747230064159254583777806754508472794550424398198576585120,13228220894074693515947418568115512670466893414535562052872530653586084906533]
+        [
+            0x2fb583762b37592c6c5a95eb1d06694b6c6f9dc4f1ad4862dd8f5e67cb7a3f5c,
+            0x12e9f46cd8231bb03d4028bf7a11d7c0e331dc05c088e6dc3d1d001da58b85a5,
+            0x1275cd70326f52f816a7c53fe62e323efe61a5b8d3747f6dec5837a825873afc,
+            0x6e7d165b57b0299d23e750a75ea2e12c9c7a16954c40a4d10904a61e8773541,
+            0x2f67f23a93ef1e215a4add2ecb41bef4b9d85ef9135065d992800e34fa98108b,
+            0x169eb9952e2a8623ef38de57e15e242df388019489e01b7c84fa839d864dcd1a,
+            0xf4cd404b4024ca13a513ba3156d4de9cb3aa240c683b3e0eb7253bc98c8b5f6,
+            0x1c486bfae3ab032ff519e8dca6dc41ea060b0ef9083127bd7c2c4e089fd45aca,
+            0x102e745864251ce940c67b1e2f4bc4d27fd3851571ce6813baac665e8cc0c79d,
+            0x1e6a6d620433d22293044ffe36a5f2a729c129cce3eeb0bdafdcd0d52bc3bab5,
+            0x8f3abf97ad8d01cfd8651ff2d576e3d68ecc47aad82b4188d92138bae603b6d,
+            0x283da3f1cf8477d9821ee60378b1c39c72428511a1b9d6683c0302938c248ce6,
+            0x2d99cd8d88e49e0babc84cbd58adbc143a75a26ba16f96466a2e41629734437d,
+            0x171edd6a7456a4c25fef8aa6d8b748ead869369f72a4e502861fd037dda8f779,
+            0x2fab64694369e3a2bd573c0cc383695c02a381e785792a3fabd6e1ca8df2d3a1,
+            0xc6155944f64f7694fc8ecd2a2b9a2370568c3c898db9531dc18c72474f9afe7,
+            0x1ee0e5cfae030622249210cdcda71437f28f0b1730653c0915efbfc08607c3c7,
+            0x1c15154895ebfcbade12f0e02f0cf65f87351b1972358beb0eae6b6976cadabc,
+            0x467fedd16f9e87b3069ae697d185c9c884ed5d9e64bb814bd11f71885754083,
+            0x2b5565852f65969bb087fcb51626b4754b69136d92546fff44b7048b2f9ef8a2,
+            0x2250acc27d5ef8d0f4ae8ede77510a7ffb897d45d9c93fb2ece4fe4c9a520f97,
+            0x2c0abe26ff8bd475ef727815bab8a81d154d2c1e36eecd07574222782b02a8c0,
+            0x19b0bd9e0c5fa1f56885be00fe97cd4ce8e107e95a10838b70dff34051188a69,
+            0x2342fa805eeb2b237633942aef80bafd3af387ec8d472f5d12e8f9834d32eaaa,
+            0xed57663a2a64c73b2870af0065ceb8cdea397599ccd9823747f884cdcd8faf9,
+            0x2c8da824719f86bbe3e601b19d3ee2a9fb766e7537aac2ea9f44ce4896e64bfc,
+            0x242fba876b16361e11c677d62c6aac73930683c0c40bc11938247d2c244a4474,
+            0x180cfd0b1cd3af7d5903e1e638bddc6711876fff6d5b12607290debd5e409b3,
+            0xfe8ce1b265d657e790bb82e6881b2da774713b724b9a88ec36373fa66f915b,
+            0xe8701cb0f031d03a5d81fcf949230dd38dec12218ed937cb31d58cc4640809,
+            0x7ed575f9154b12b0fbc12bff4350c6a4d38859d10f557d38c513b37469f47be,
+            0x22e9f46e17dda4066a4af81a4be19c94de4b12e0921f819030f8352aad050b91,
+            0x2b21049f7b8e6e767d633dcbf2acb264dadc7a85a39b937458c134f652a6ea5d,
+            0x216c5a5bff445ac3a3da1eeb706898437840905b9ff27dafbf38efa470bd0bd3,
+            0x2e14bd4f01462ffd0c83929aa97706ac772f66a3a0a0326c00eac11f9d5a485b,
+            0xf28e51e2f777239205f13ea21e8f33172ae538b21fb69bcfcd82ac51500eeae,
+            0x2c2295ecbad9cf1b3f6a773c69714eb4663a01827044169e7f1edd5838106eea,
+            0x1afe7b1d8ac438739d488ef003f9c3c679e7fe2f0918bbcf93ad1f127f2281e,
+            0x2e0833dafe87279685cd5b5a0105f8b98774b3083833bef43608bca8451b210d,
+            0xbbf4266fca0861341c7196fc15592fa22dce6141935e01fc6077c774cbb967c,
+            0x530c66b07d2db8dee36ab00f91c5aa0a26b48d8940f0b72735a65481e5e781e,
+            0x2ecabeec31877a68058a22f773e92d483867c01df7d050c3fa953ccce90acb51,
+            0x1e379c0d2f9d0b659bc732b57689e48c0262a976379959e12b95cb5d45820f28,
+            0x27767756606bf727b8e5361002c613d6c3a20df9c1788c9c122d3a7736a6b340,
+            0x1be3d832de2196443062c3b42321ae05779368ff46eb68fe57d835d8d656ae25,
+            0xe9b839700b18ef3eba297cb68ad992b3bece0cd5bec65e6e40712425447dc59,
+            0x2760900970a34d2051ae587ec18f502d246070d70c2c3d7fedeeb51bdcb785d,
+            0x370ec3f70286f496692cd5f50f6b06e21c5cd89fa28f9c8b71d42b4ba277906,
+            0xba8f86362e1f301baeebb2333893f7fba2ea082d75969a97ee3095baabb10a8,
+            0x2d683c3cd7b4f544bbe4a6baa9aaf78614434a5915299ffb37f92abcb4a4dd6a,
+            0x25544ccf600d8604bf3e11aeebbed37b77cfb1b22f3b110a930c91e9e7951f82,
+            0x1c583675e423f947344328315280966833f05f91a2a24aeec1ab6ed37376f959,
+            0xcb752efd07c8400d50a06f3e1baba3cb35b0ba28b262f8526f5eb0ab5bc79d8,
+            0x14cf442b6f22ca3f4c16974e2eb56ca084d05eb93ae1049275b8bcbe4dc238f0,
+            0x1af1b935bdb5607897f4ff0745ab08140d6e80878652855b1947576fcfee4fa7,
+            0x2499ad4b7965230d4dd5d1c41e00699c40433e22c2745807eff395a13e6f1f0e,
+            0x2b582ea1669028196e62e62271a36f532b14c0a8109d34ce53df9b75b81d63aa,
+            0x1c335a347abda047c4b5ad93dbb2e9412d526049fe1fabe1b5fee25ee99e0bef,
+            0x1e3451c495c60dcd443730401ef329d70571e3644dd7b5664cea26daf8a70aa4,
+            0x2d96286e6d9eadd63e393335f1217710746ccb928834e73105823acbd2da005c,
+            0xc1033de21891ecce9bd0afe313334f7e65977994e545204d616ae0ec4c1bd8a,
+            0xf0f51cf6db73e970a6b8efc8823bc82cac8403ec369c02a14affe5fb40eee36,
+            0x8ed2dcec016b8eedc067a6da7b562484c010234d84821780662acf9d281b348,
+            0x19a5ec3b7882ec910bf7590e9774b63ff37909995a6d695611d5532d6b81a5,
+            0x23feec5d6235a405f0d53fc16c955fa0214cbb54fe973948a1dd39263607c33d,
+            0x85438dd42c1d74fb0407e48ab1b44e0e42aa3f54b8d7d4f6efb87102c6a00e9,
+            0x1916f1d621aaaf4f9072bfc4e41b4b78e82b595d7510d507591414c005fd0327,
+            0xfc2435156d4ee76e9a85ac6aec2fbb50b0b77795c370c2183fca9bcbbd07693,
+            0x26cf4d12199003f6978f80761784de0919d3a14887a57d4a28b4ff3ad39bd969,
+            0x2c480375d8dbd4ac4f039f452fe1a9f074c811d48dc2b214d3f5de827a1a2025,
+            0x219b5f8126784340f278b77b765dc4c697937b3d81ba2691f8979839f02cc0eb,
+            0x14adc2f2733f55d49fb628c3ba41110e16946214996d1f93262b9347cfe69a21,
+            0x230a5fe366e0aa4dfae1dc35e0206959781a64f22d5c684e53ffaa6614b1df31,
+            0x1279f8d2e2d43a9eb3b7e4149d16451b78c65118b5a80f86678f5ee6fdcacbde,
+            0x2be4cb4144aa4b8e705c37da42b8819f0165ef3476fbc327a3a3deb0a0e8d751,
+            0x283b18f7a149cf2f2c8cc446513b5a03a06022cd859f16da1149e7dc7c60a45a,
+            0x2d5baf88887aebe22d5d9096dd6c45e941f6a67369af01c75479e707803378ac,
+            0x1cd9a6ffdd0daf7ca9890868d9ab398e0546335bf29623aded76e4f7afa5ad55,
+            0x160767c1cb457de2acb400781d8cdd25b99f75af301e749cc46049c8db5563f7,
+            0x1bbbb19bf384f9812aa63685729e0dfe06f3454c12139454707c1789c39fca6f,
+            0xad3beb75c91ceb0b2bb8aba2a1c73c95e7de57b8d5a7984e9f4d010f15a1755,
+            0x1841eb6cc35a1dd64feba1d8ad6cfecd65063e1e6c2cad4fd5bff1b4614e0b06,
+            0x2356eedec4882d9032ce821d611b98779bd344e2abe0a57de4de06b72be6b447,
+            0x10fede6245a9c78b391e69db91108306bee130faf298432d60a4944ee6ed6479,
+            0x2b4f28161c7a843692b07410223d8b5db762ff16ac0cded416c3594de6a53443,
+            0x1f0846b1b26aa3db14ac0d69972c9118051183ed1d1633876b44c92f022e011b,
+            0x28ff7a7752e51734e1f568c6aa3dde3009c22ed210503d5dcd7dc25f7f6767da,
+            0x1a3acbdd739794d252150399c6a8b3d114d97d643d4ce83fe8f64f41d8c34e93,
+            0x290ba46b38179a447cc81d0031d18e9baa34da9a60ba7df3cb2c7654bef3f412,
+            0xb9876589637ee3628c3a08500d67363a1a01da7a1ac81f528c450e9b050c6ea,
+            0x35b7b33a1e17c6d1674cc229068e03d3d1767bc950d68a2e376f0c793a896df,
+            0x7e6b30a0d3c2526be65920e6b873de72db1d761f7935202fce088538741b347,
+            0xe5ed87393495c2a7f3b877578c6bc09653755179159351d8e67470abe9cc690,
+            0x2824873ab7526115957736a5cdae583bfcee10b9d418ef8e17795de3386f21f,
+            0x1db49ff47ea6ae80c26654ff5714e69cf3a1ff7b31b1fa7a3b9e64618305d582,
+            0x1be421809f80b11a626a0eeb927a39c2413e7205d25c89276bf5633565038941,
+            0x3b7c7629b535df5b487211f4e789b9a287abe7c453632ef7d42623c2d2c377e,
+            0x12a9f7f6e0c65acdf8c9fd354f7ec84d6e41638465e347f3063adc04e00e809e,
+            0x1df5905e387f8ec81128c20ffd995fad5402096e3cc6d2e229a23709b6859ac6,
+            0x2d39da8ade615636070e6734fd848368d58428aa3b2aed784d8429f2075d122f,
+            0x327c1d1f0dd35b08df840db2579623243c13d9c073b9d70984bcfc97c9beb7f,
+            0x18a10f3e452a08076aeb6b825004322a48a6fb0f51956f50250a41a49454b6c1,
+            0x1e94dfa0b21f7b3e6047d599b3ad491a693fe458add2a56c5ed16155fac59ea6,
+            0xfe2016941461beb0f0bed25bf31e8c9a36f21fd61cf70095d2da2bb93bf3b2f,
+            0xceb82937c84923d76bf855a1bbe412dd3e35d0378007404477883d885b425b4,
+            0x16985b2ee64b42bf9ba0673beb0e47580763c527f4792fe994c23e3046621a9a,
+            0x10e6ff96c5dad8a34d7af2e3c6ab2e1eb6ef57849233d2945fc0aabd404e5b6d,
+            0x192fdbc53b382b45aa3020d21665ddd656bc1cc332581cc71ec97c3ad71dc542,
+            0xd8431c14f1ff4640fbf6990506d930843bcdeb4deeef3380b5cf2161a3bd030,
+            0x604632b70d1c0dbc74ed29d69d11d37b90669882c2e3d6784b47a5aad03495f,
+            0xf2553c7fa5beb9cf2f6957b01ff7bb7d3ed61f9c2e6fa8a53264704f986c193,
+            0x1fdc2bb41ac0418d8351414dc360ab2dd324d1622807cf59db5ca6aacae5d58e,
+            0x18c42a157f39bfcada57e085c7cd33781cafc7b33d6505dda828972966a9c2ac,
+            0x2645748d1b13c825bb457aa7761b9ce5425c56137e213c8634c87ab29543ba1d,
+            0x2788af72cdb594ac08f41269497e1ae18d44232ed0f80a06bd9e72fd216e3972,
+            0x21ae229ea6529c4f9de897bb849ab6bb15bb92ee41f73d348c10ba8d64acbcff,
+            0x1abcfdf990784706f54792660668ad106d1a6936245785c3fd023a5344cc25ea,
+            0x29ccf1d934f2a647595d1be0900002b9b7a343c3e7d3ab9ac3d2ab8de01abf8c,
+            0x39c2ffda04fb850f5e70d97ca2d93fde05b651b310b1d27dc298b9fc888d9c0,
+            0x1f2ba53bf1c99665fd6f4e862ac08899a41da938198153e4c638bade14719a16,
+            0x2451b8e4232ce9c809e439b6eb5fd2bbad8f51e9bf0429a33bb0ee95b7890719,
+            0x171a629d2c40364327666e0c05ce3097b2be05ea5c75123fa78851ba178980e0,
+            0x8c9b34df311a18764044e24961a95d1b2dcac3c6df9bbe0480659611db8f137,
+            0xb22a3e321a38a3801404091d2b160fc133530e8b7a52d2422c9f1a8b252bc20,
+            0x797c435ebe5c845a743f87a7f0d267f33bfbafc9f1689c2796b392772e7d301,
+            0x1e7306b31a137fcdfb389fac64b5f1ddc6147bd1cc7f30f11d67870454165dee,
+            0x112f01c5aa8b6ae92e2c8ca7667f5d21a0b1e4a8ce00a2ccccdc459ade9b019,
+            0x219de6b42df30699c66921c11e899b888e9ed317b586abed36fb7692b1216b1b,
+            0x86a228ba57047dc5bbbb04bedef0d87c1a78cece6aaf9b698117b292705de04,
+            0x14e98432357efd4cc323da2a344142e74f2aa117cc1aa4b559ad83e541ebea49,
+            0x1e6b895858694eecad78b8b88d54217c879d8b86ad928190789a09147168fc96,
+            0x15e37faf1d08493df2b643576e177c9fc704fecf164b7327481d32313d55d161,
+            0x85d0f567ddacd3f8e5e00c4209cd9b296693dba11d00879629b522270e798ed,
+            0x1067df821f616fc9635104d5b2150f831ff04a1f2b1399db49673e80c5c86db1,
+            0x90332160427de3eb055f9b8748f7e2b88c11f415576e72e4e087416544557ba,
+            0x2dc94749388ebd876e0d44ba0105f8da36fce0d45831e4255092d5c7f8b84225,
+            0x118c857f29e5a253d50b4d24d2d0c29b82c68ac4ec31e88bc43c74a9487e795d,
+            0xaf67f0d07a2fe41c72a457c92e95458a77db9ad0a28768b62b6681adeb11579,
+            0x30104204ad0fae366f11620b2f12ee6bb7c141e2fec7e29d963e6fc94f8c828b,
+            0x1976ac8ab874f49ccd63235f4d81cf0032ce66d53b0d9a910da3b8d0524a5a60,
+            0x2c316de3167edeb721ab1270a0748ee7f77ed7a8a7c727559436f6fb9313bfa3,
+            0x9d2011c83a4c911f4535e741f79432b5f2a5b8e53561d179496ddb63cb759f0,
+            0x135bb87773cca2191cb5d22ed48e633d71149119bdee6569623af883ed734294,
+            0x2d47ce655296753999d0d8cabcf056f0047eaa166f5f8bc3cc5eb601ed2c5600,
+            0x12b3ae2f8d3633702674a4ea2e98ab5bb186da55cb7f5bad038be08a46f8f8fb,
+            0x1941673c79be83924a43b0159e5f0919c3b4bd334df567e23a109d5ad7093a96,
+            0xb524c1bf3c392285d49a42d8bdab4ca454514792e2abb5bb4f62c902c9b9190,
+            0x1515ed77226a3311eadf3fc8f035c016fd3705a08b8a9dfc2175fd7bf58eb8da,
+            0x64862973bd0b7b75f7b4624a84d680fab7da9b6741aa5d6edb76a9d0c40cbaf,
+            0x1a23361fedfc5e494b0b2d4eeb80c93f8835a73100bacb989be5226fcf0df55,
+            0x14752381dfb966594721cd9486750a4f1f8e337b06810938317563386d4e544,
+            0x4a09034e0f69e26581ce66e097f9b5be008d08be687b8122540f2e3262914ac,
+            0x10bb764a96bf402a53785cf2eb4af7b05e20d89ad0658aded12c1b581511538f,
+            0x1499cfd036b8ae372458561c19a59aa635054692818f9b3234707168298fa14,
+            0xa8b3b48ec68bc2fa9e34521099684e72258264b7796eaa9bc2130ca5f962fcd,
+            0x1a46e59c6c21c9d54b9b231fc1403379d01e16680bfe9622dcc01555be87487e,
+            0x9569a38ffb6c33d8ebcadc6029a3ba8ea8c8ade1a7874c3f017516c358cc698,
+            0x16a9c201d574004d0276db42e7ef31592cd49a56b9b768ca73c7c6d1ddd6a2ca,
+            0x19c05f9660f2cb6b113179e32656fe2b39c9307c0d1e9b3e680983e27bc941c7,
+            0x29f4b811dddc6725ee59fa5a28af545cb21f15cb7fa6f9885cb7d6a405a063a9,
+            0x1f99271ffe92b27fdf561572e5f6092fc06fb7faa9cbb2e07608067cdd529b10,
+            0xb9fdcfdc7dfb8724957f00327ddd9372f8fceadbbd41583b66726b252b6c089,
+            0x1936f5a41ce7135c9027047ec1d759bfd91ca70a62324400f15a31debf179ba0,
+            0xe5eafa60334d7cd71251663f5b91dfe10ec503a1b2fe5b3886ad9b10662abb0,
+            0x18065d065c304f7953231240f544ac51d897f58777c69bb9d1f8a486a10c177a,
+            0x2678766be9d2c5251479999760ea8d6fe4a1525095e312fae3ccbaf689e7e809,
+            0x23750f77af3988a0600ff868b61b9e5e3d00de0f8759612d4af260cf4b113ce2,
+            0x7318b129e4789d21bec7920ba354193fdd6fc628eec1513638528431272925b,
+            0x2a7bad1eb2e6418a954869513a7a531c58f0985c64aa07db26f8f7949fb0861d,
+            0x1bab89c7aeb8f0f1c55bf1aebffd937a520cf6330add93cc33846077c83a987a,
+            0x1552d5985864ef2844ae3d20a40a368a4e032a4ca49d8ff6546c450cb1e079a7,
+            0x4b91151b3b35f11f5996365de43d43fe5476e5bafa6f711dc30face2623d320,
+            0x7568334c7a0595b5ac2105b2b5f738a5df0931aba8576b970722d4e45c912dc,
+            0xb162e458aeee52ea49ad59cd7b5fd2dfda24fbd9de8cfa1cdf06016e9d171c0,
+            0x2cef3248eb4dae55793e1bcfa553c9315f6b78c356251508e79af7cfd8ad95d3,
+            0x15e7245ad978573a5e2b912527de7964cd4add05fac3654847cc0b6edecfb9af,
+            0x27c471daf0598daf80d02e06c8171f94dd4b689aa0bee6a68e57b388ddc52155,
+            0x13cfdde932c2d8f94bdceae7ad7a0ba5d545f2ac20a04f7e9397d67b942b09a0,
+            0x19f9a64fb9d109936e840d1cbe108c9c36eb46d237cdc8462ea8267faee7e8b7,
+            0x14169ccdf08725826332bbd522d72ef94b5dc96d07a18359b0cf770331224d67,
+            0x2e8744177cd2849b77040421907fc4a9c356c4cd02ccf32dd8f05386ff3122e2,
+            0x1507d5deb9bf6bfa10e2b432b56daac4ca62d302fd8e37a021ecf111eb42018a,
+            0x26d7097b3269c5d618a95bafb9b128a872c5c85d770515b2815b581e94c8b9fe,
+            0x1c7ab275f1c221bc248d8498dbb05c47f41b97fbdb637bfe155cf1e75849d476,
+            0x2673077405cc8bc1e0d88920eae1a797d7a40f9999385be0da776c0326b9206,
+            0x23fe81be9b9219be0e6312f29022c7d0cec98da3c51c959852d951d6f1cb638b,
+            0x10ba3c183fb3890c360fa562760adb456b01949ef7151ed8ab8103f31c7890a2,
+            0x2d5259daac231ce0e74872c4065e14db8b32679927872701bae243f6842c34,
+            0x1a637c2706a996ff57c037f4f5ee37501fb3e7de4d067c4c0f5ccf30f9d82a05,
+            0x2e6067c558d96831add6dce3f7668546f96cd84c4e227cbce700964431ecefa0,
+            0x1a0c5d35fc732851917ce3bd13a7f28f75898537f6ff8eef1a1ff41b4b7ae935,
+            0x2edc867095cf941cb1ff7887926a4c8c44ceb1927172e39b362d2f7461bb1b84,
+            0x2f2062a65c3fe731e2aea024198e417627f38d6cd91e0a4874a856122a9d965b,
+            0x261a9965be69de3ffd74235c3a239e3e374cfe12090f6929e7c4442bfb8b61a0,
+            0xe51a7f2109df256ff814fc310a3b08efd5bc160698af9ae219c26603e84b586,
+            0x201537485c818bea2b1bc635035c7f92ac4be93b1a732a259e5081c6b10822ff,
+            0xb1dc66c364df6ca43e96ce916012cfc49115a6635e8a76a13c56f966991ef4e,
+            0x1b70f07090ddb1c480c10557d2f818c2355a0d0112f0448f457196db0ef585e4,
+            0x1941694438a139d8dde10865876403207f657a2883117cd3a8cc2e7c5d24f32,
+            0xcf031701838c4ceaa490cd36e710d3619ce54048ea826cf23a2c456f245e6ff,
+            0x132d7fac73535b2c795ddaaa3a69281704e85097d78ac6e8b1e9e8a7721863f7,
+            0x4aeffca0f9922fd0379b69a7fb710b49dcd05026a3f2576a48a6e04f91b630f,
+            0x25f5b5001f87bf2581938f3ede0c2a7a35141c7abc3e5bb7bb8601a22a3cf43c,
+            0xe7119275a25b2b8a4a6aca534650e84ec72b490a41384d44975ed8c80a2a28a
+        ],
+        [
+            [
+                0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+                0x130fc54477fd953377fc23abbd7a41be6764892a8787c759c1440fe0133c852d,
+                0x2c9c91f48661771baeef6774578a78f69c355c8e907156fdf26db39d2446413f,
+                0x1dec0bafa3e8190621e5e095ef751ea03c836dbb8045b2a73f8d397cfb815192,
+                0xa5f52ad6ec4a8aa377d8dd2ae3aaf6eea0c68c63a1d034fbda67133ca0b85cb,
+                0x20ab7394bfdab344cbb6f2123800a0e23508e2125bfe795ab4a767cecb4d9306,
+                0x110ea322b0c26476c67bfa2c1b9d1713f93b3b9cf8320ce0dcd4b64288bda07a,
+                0x54eabe6131681fa01fbc6dbf3e7d53595d0f8809987182142b890ac8af89cbe,
+                0x224d811fbdef8ec0a006d376a019e57c93bd596213a07823b7d4abce1fd8e621,
+                0xe691fca423128a7d4afcaa582b1a94799ba1f5d2a5d53bc2bba56bbecb227a1,
+                0x189e279c92de0bab66707e6e6e310524e615cd4c6aacc665372a3b8e372d8ce6,
+                0x1d9bcbbd17b93b1913d2f79cdf12844441237206f0294746d93f8e5bdceb4725,
+                0x1179184635a9780ee1312dcc3d15c7ef042b18ae9409670e28c4c7f0fb9b608e,
+                0xe48466182ae8333af1891a6aa19736741ed0680d57c931ede13fc07ae82e88b,
+                0x1c9d56f71c2f22c44d3a8c17bf5b40452e05471f0b6dfe9ffe4725eb29f73464,
+                0x2234546f5e8541e8f72ad794891950b32b1cd891cc66775c5b635961642e9c15,
+                0x14c09d155c5d428198c234b553da338f227cbc12b0e42f2b9ce71563ee1495c0
+            ],
+            [
+                0x1440dc2578f44694d18c25f892d98c23cfdb87a772200020e897823d4bc84d3b,
+                0x65e134cb8d84447d6ea1e17932bd4a341ebef2568313c24594faf9d7eca2110,
+                0x2c6b133e80abef84904fa4a75f968fbaabef890286d5fd11b87a1e52b7eb6d0d,
+                0x27c72332f59a00135baa94bde294911d135d1d95f53c52eb8b3b95594374906d,
+                0x87488f735b1fe2fa3c6c7148c4968e7f3479b1418a1a566743c1ca215dcfcfc,
+                0x19f0e2e141896eae6d56d182b687b8a6c64cbb59e031b749f35822fc7ee353fe,
+                0x299c47f1e3ecc557ab1c9abe36f0d2ba0ece01051e07f0858e97a9ce16f5664e,
+                0x1a4befe11c0230c62de44ffafea0de903ba328c6d67af73680312b68f9acffda,
+                0x140762d30c5c3a0b0750b1400a86a9e2f5cfc2531b729370f3ad9fe1dcd43f96,
+                0x180aa4babfa7539753d9c222e5e3359aca59e06bbefc7cf3a3ffa4f961fa1d5b,
+                0x17208ea9cd4dc1a6deebe6a8d27a3181ab5f86c6a706e6fd007fc1eb678e9de6,
+                0x20007a0f5d37798789e0a8ef683536d9cf4831a6566eb727b41191d9f2974710,
+                0x229da441a302929b0bae93741b7c75e11337c797e5721f9d7ee59235cda9a40c,
+                0x1137b5c61b9684bec41e4dfaa76438256622a4378ea4e646a2844bbc85bf81cc,
+                0x113003c1dc7baf35e4536f95f4eab2f3badda2c7a1c6b5afc956234ade3e7129,
+                0x1b61468fab59c925f1986186bcb97965a858523a2582d434319a9525ae71158f,
+                0x117fd528770fb17f718e29a2d91a63ec7c39ef1dd3039f0943f717d1804253d5
+            ],
+            [
+                0x23aeeb0c6499b84bfc32ae3c42df9728798fd2ef774f1518b870bc57d1385900,
+                0xe76c40392bd5f458bc187be54099312a0fefff44b441637020eb92670a6fcf3,
+                0x2ce8546cb59f420ede61692e764e0e9f6715b16a2c8047cd8131c97646f50d24,
+                0x16e64661144d816885b32f3f7809703477788268d57c14b1d939a26b29cb7ef3,
+                0x6cf0db92f86b2732ee5fb881ef0176012dc4adfd849b9be4de17846a6ce5d99,
+                0x18f754a95b0af0e4706ff9024bb135164abd6fc16ee40cc2d6852d88a2ffc9f7,
+                0x1cc053a6a4d6f96da77e5e73adb9d49bc4d0ef2cc2f69fade48040b7f8d71386,
+                0x1e40665f5bb8c5c0dc9c11f39d47e9d33e717afa31ba74f92f8737a55efe134,
+                0x976d7c3844bc8deea0f0337f89b2a131302ffd2d0a870181ca5fd5fb6d4fb63,
+                0x2c54287eee368d5d52dfb068282d68e6b09b76bd1b5c9333b36848ac277744f5,
+                0x228a3488cabbf9f29efc0bce211a09031972b37f25ea35aca840dc2331a0cf35,
+                0x16bae49f5ebb1ffe886b634d215de61ebf4f44d1cdc4f84670df8ed69310bfe2,
+                0x2e269dc78f70f9103b2bced3edbd41e156e64910887b4dddf8a3eee960f601b7,
+                0x1f4b85552b960d1c18b7b8f66af7305a6773d9b05faf51e0ed1a5f2ef2f95e7d,
+                0xd5fb9b0e1503f2b92697c473b69cf76d38fc12912e2c3cb33996dbb0cdfaa38,
+                0x11291ef514a10d6f0651e4ad0da5d4a489e3018927879da942defdbdf701ddd,
+                0x120e7416d74308e24047f6828c68ae28bc288b216e8a25e8b0ebcf738480e390
+            ],
+            [
+                0x1ed9d3e9276acb7b4dae53eba148806fd9bb07b2dd06187212fab7dcbe63d72c,
+                0xb981765ecae69dd7af3b10ffa424b8aeb206cc4f49257265c6753b1cc54ebcf,
+                0xadaeaf28776b813d518f645c793e57bf16067fd80eb921dd5a67e895646c9c4,
+                0x2018db386a3e4e57eada8d91408b155061df050140fb22f9a4f34fb4e2d02428,
+                0x67c4411745db6c6aa659ec737a586a8f4a1cde0352e30aa0063794865fc1c04,
+                0x193fe0e9b48010fa319c33b86b6b18f428f323fa237ca918a38faaa91ba49567,
+                0x9558ecc58bee4f3c578f62489dd900840a9889096c0a62114aa2db045a1d033,
+                0x23c4abfeb83192362aae21b2e9ee5cfc765bf1000f798c3ae70133556abc78bd,
+                0x152604201ca7df05994e9d5f058f3b6749cea63aa0cb5b4e1c3a00b6667958e,
+                0x2f65361a4aed320fcd03a45c44dda740213571f3975ce20b96bffd960cbc6e25,
+                0x22122c6313fc9a4c6d0f944d3ce238272bf35147b1b788aab2b8dbceb6024c76,
+                0x229aa5b547a63780d8d129e209fdb92f85662616d59da908075e668fd817822d,
+                0x21a91fed8bed14914c4fd491b6fa4dcbae7b3b8b3d456303af886c328abf4699,
+                0xba8a54914886fae16700c02efdf7767413a0bec5a19ed0cf0a7d8ac60c1f1c3,
+                0x2e164a524ee22eb5a8903fae1f35a3a78f882f3e3a9892b6ff4753baac934949,
+                0x2df2fb2c2e321e3cce13d16091705a40c5c795f8b41b61dfd6ae7d97d63578b4,
+                0x6995e510fd7669374c39d27903f342ac5bf8a1464807f308bef610b76cb693e
+            ],
+            [
+                0x2ff57f3f7e95b03411db790a86647467581197124d217520ef2e6332a5b35185,
+                0xe4fb044a9fcb4087e351341f25d98b1399b576e2d6654534f348219a0acdf86,
+                0x2086a01b816438a2a41c59e43d73fa9aacf0c24e4f6bac229d65fba59922554a,
+                0x12263b7e3f3de60899a2c22fee919972cd79dc289a87f31f1b44baf2439dc87c,
+                0x19909241cac50288c0d12343e0c12cf9b9790b405ef0a9001aa6be0289063aa9,
+                0x11ff091dd551b6d586203ee0cafae2f7652e923aba82574a53b632a066f4884,
+                0x93d7d5563e3ccd0b5f15a9b093fe6b863aacccf9af11ffea9b295b7dd42b1f6,
+                0x1669e44bf0223a77f48fffbc9f4f20b5814f6185ae11a210f8fdfcb5f71d603d,
+                0x1ab6d8fe39f87bb0ee5b883eea2725caa52c575740d5ac30b058f77113d05239,
+                0x235bf178b5b56262d988bfc62708b0f85d57385cde2b4dacf9e6d592deb2afe4,
+                0x6649a13e65023a713aaee5387d388e3609ae9b14ba4da10642ee0b7b4a16634,
+                0x29a5b1e4e2f25445496adec230ed53a35993b37630aecb5d76e56608d1b78cc6,
+                0x29f07c1effc65b5589e1ca52cbe00bd65ef5e962d01200302670b6dce79eeb00,
+                0x30289c9678c0330f85cf8e362683a6144f22b841aa08f586f219dd9edaef78bc,
+                0x1f9dcbde7d058134a510a711d036d1f1800e473a63b33a7e0fb04dc2e09e3af,
+                0x1baaf8ff96bb2224bc34cf80c38bf13086f1e429bceec12090d8a7c376a9a82,
+                0x1d814b3c17656c2327f94cc02472780b886b88394f1a5cbe34dc4f44ff134fce
+            ],
+            [
+                0x15faefbf8584a38969b4a719ffe5f02c2191a8cceda0b775162203d30b80208b,
+                0x303e39ca88e8da6e5c963564712df8a7f8501a7af4a990e4ccec19e5f8fc805d,
+                0x2348580de49aac01ce8fcb5aa2b467f6787dd8a96ccecd6fb47df7d5a4307398,
+                0x10e420edcb6da76170b24d777ce9d31612edb1593ea6d30e8cfdacfb6974f991,
+                0x1d25b94bb7c49c0170ee1fb2a5824b70e4554bcc54b6c8f8cc0cc9d74f19a5e,
+                0x1da3e00601ca3fc0d90b197bd2a474b46efe3aff3b2cfaf1ebe15fa1afadf2db,
+                0x45dc0579ca66e7e096d4dd86b882e68af2d35d70cf5e3b1783caaa0ec424253,
+                0x2d5b3f523a9668cbe4887881bf7b40184f978713e358de270d87a600e5c5c92f,
+                0x1b62ba8037a83f1261544c307f019dbea1cc6a84d481ea8960b0fc670745e8ae,
+                0x1794ec2b0eeb22fbd753b21fcd949e7bedb305f15a59eaf74a961c3046635f85,
+                0x1ed4c95c6283b45ec0cd88f511976f063ea2beb0695b8af7cc10589593a7978c,
+                0xbfce7b120068b9a30029dbdb36be01d071e8163fa1724f13c6ca89be29b729e,
+                0x506a7a5de6b56ebec5e708a70a3cecb3a2cfd25e7a20ed495e295a93023c5a8,
+                0x4890048fcdbde6366761cd58fcc6ac0a3360d9a64233d3ea4d8d6be8a23ec45,
+                0x285b20799970b58c63ac9f4af564ce0f28209b61802214da5bfafd0cf24c6712,
+                0x7b0d70ccff1b70dad9bb4b0142e3f6dc5bc95d3766affad378cc5042484dec9,
+                0x3b90da34b198cbca17e34aac98b169875ecf73aeb5c6ff1f00c9fe535aa9902
+            ],
+            [
+                0x1e6eaab1191593de0d89cbb2399ab8aa955d829ad959428cd539be30b72fde9c,
+                0x1b77995dbf30cc55f9d4cd4849ced949349da81239a015440fdb38b876abee5,
+                0x1fb6bd6df650d27e8cac05ac0b45eef0700e308b29b4bd41eecff58027edc45c,
+                0xebcb358f95f84b719c631d4045cef03ac6fc238f6834522cebd02e47411bb6f,
+                0x3274e735db2faf186787528254272ee01967e6ae9d825141378b8354d843965,
+                0x4ef41945559c1fb0b2116cb2be1f043bfce8dbc96feecccda47cbf68be59b5,
+                0xda02f6410e24058a1e90412cd5302c57197f7b1af2a99496f9cff3ffd58808f,
+                0x10c1856f282f556d7cf6d4a293621506724ba6d3c582e4c261842f2a4bdb0ec6,
+                0x239abc7c9f866aec28685c26f4e046a92d4360d36cb50890f422e18ed6f8a7b2,
+                0x83e1cd5943461ab505b200311bde4003fb4f7ed16aa58c8bc28f2e08e9f6922,
+                0x15fe62a69b0438294395da1bfc93272d88797ceeef666ba2443f0c146f8ab7ee,
+                0x20055568b33367bc12bf4aed7a0909c173588a5763c6a1a7598ba7c6c7e3c2a5,
+                0xc02b148f4a1559b597cd320f00c02b96a7fc7c83811bd86a1e79cc3106b2201,
+                0x1a4162e8a7704447be0c1d4d5cf2f777670f4841ea27ac2709cd6bffeed2cebd,
+                0xce3dd727fdd11a8bc731500effa23763089ce3332cb730f9fe57146ee204810,
+                0x11f28ee5da80d19e31581b566a439537466d9ca7fdf14b7086830bd8ac13c4cb,
+                0x27fa77a0658791e6755781c367683f9c9333a41364f7870edff1935a347485d8
+            ],
+            [
+                0x2a3bb020c8a50d310ef5b5c77cc408b077fe2481454754c4568ff668fe5f0974,
+                0x23643add30be204734d029cf034c958144551060c1901c420a28c9688ec36a80,
+                0x3e9718237c1700d7dd213e026f307e8000b3851467fed9e6f51fa5020c2369c,
+                0xc48e2f304f730d48e83dae5c78a46188500bc8040a49542eea5ef1a21b9d222,
+                0xcac320362e235b458d6d364cd0fff914f3c056adbb038dc2a861a49f7f70e24,
+                0x2f053fdf1a72d6ad8c9df97a04d637916f25e3425b6dc33e99ca7cac5cc7e4c7,
+                0x2dfb6dd598ada57ea71a8d68e6924608f0ec7838808688ee4b3fcd521f7be6d2,
+                0x22cc4349f6baa3a8e0b61fc40ab97210e4bd3b3dec7f05bb8ef839c84692afbc,
+                0x2fed5a03200417664537df8fa30276b85d91bd2ed21de33d901fb4d82439857,
+                0x22a67a88776982d6a15f577dcf780ac485ebaae6fdf6fbe50b95ea266a7b6059,
+                0x2b079a1d09b9d4a76d4e50c45c01fb7508b1c443a8fb21ebd28533e05def8864,
+                0x2df1ff86644fcc42a1932cf15d314eed407608246f14a8098725ff7be809c87e,
+                0x24a466f74e99a602894f421010f43a81c708b1b4ad076425190b85347f685b1a,
+                0x2e944b449c1369ce9766fa6f4f99a87630b5c1f2d63677a437a537d61b6c7470,
+                0x1079746ca51d9518a0c309296ca48206292798910494277be2bb65a6b134b3a,
+                0x13d7b03e8fc9fa647fca6cdca97146901df7c675a164913c2bd2a3b6ee3cb4,
+                0x6d6ee531ba3fdced05e24cf9103d0962dd227f1de692c0199483e92ab24ba59
+            ],
+            [
+                0x51f815c454b6015c7ebf90c297b90e9604cd36acc6af07f99b5e51fdeb32234,
+                0x1946a26ab8953f9be558105fa5179f175e76a24429dad5d532c2ceb3cfea05c9,
+                0x925af35a3366801ac80a31d63f745fa807bda10560345ad572bef4cf2ce0d6,
+                0xe766f03afbb7af630eaa8aff4fe60f3810f30f3f4438498efe0186333dadc0,
+                0x1111ed7a66ba2ccd4bea0d43eec86ea35ab40253a1209e3637f103dcb84fc429,
+                0x1daf74842c7e79104349ad399592c5c4cce16f79e1a86f50d941598772cca953,
+                0x1057062b40bdcf1fe2aaef45898c871146799a92c87d0fce64302d6bc83172df,
+                0x12d019e37cd1bd76fee065bb7380a9bd8331a4dbcd1c9c776792bc19045c23b6,
+                0x996cae74d9627ca3c56c646095f39730274d25e82c42ce21cf789253d48a3f0,
+                0x2d1188d9e7e6ac24c4b2c9dc3dfcfb0fe4782d689f31b94b1fb15ef29d11f19e,
+                0xc34496a7db5abb330b2f6ce9adaef5ae6e308c8fc2c5634097ae352aa7457d4,
+                0x1d4fb0f18f31c8270b4636e6b5d7a33e455b1050de1164182cfcb739cce965da,
+                0x1fee18888425724970bd2897b54c7fa8e9c367dddbc8484da37864faff9f9056,
+                0x22d6e787f44daa6b6593dfde5576d2fdf5dc0447e65a1d5e7712e4e62c3bdcee,
+                0x23a85d4f91eda69f310c451d7d480c2f40c0d53382ddd3fcaaae627b9617170e,
+                0x2440e786179a7fbcfe8d29ab18d0fc6cfa383cfb747f7a2d15b77d82d9b0d9d3,
+                0x1e507921be7c76124879ffce5b62dd0e96259e98cc64c27208d62b40bfe3e482
+            ],
+            [
+                0x28b75c2ac167fdf184725317c7bbb8083e5ac5bba937bcfa6cefcb69e4048bf0,
+                0x248b533f875e5ee8e751cefa4b1d0732fcd30151c3a5cc4abbbb1e93b4655d45,
+                0xf8692d64a5b69a956c4e2006bfec344477fdf5f0c9aab866609842b9d75269d,
+                0x1b8a7909d7e7bd4f0bcc8003968e384ac2e8b405ad05cf610364d3ecb982db7e,
+                0x13e736cc70b7c828a38dd6394ece76b9ccdae2ca4f43963432502fe8c2ad19ff,
+                0x2ae8da8d0b129a22f834d0d234c8917c2f877ff00dc16215498d4b748fb40df1,
+                0x26e6d18aea75a94861a02333b5364ceceaa78adfbb742817218ca3af607b910e,
+                0x27aa38fa051c434189df57bafd80723ee29bdccd59fbc1aa9af11891d3722e61,
+                0x304dbc0936862356e0024b2a32dfa3085abedbd337f22b89062be614d83cb083,
+                0x265c43c886f07d025200d56cd246b01670b3e82ab482f5879b10608cc05a37fc,
+                0x4ffe27a92cb4300e774388edc3147ab9dcc4ab354c380f51ca7a2e7fe0463c4,
+                0x19d6f1d110d9f873db002ff2ed828905bd6cc5d7921c238d7569daa9b2401d32,
+                0x19711c41d76f64a371aba62f3f46710dee0c3aad217b7cb00bd12613b24ef52b,
+                0xe08ddb69d5efd949c3d671e4e78e4fc7628c65ec1cfbc18ba6a101aa19dbf66,
+                0x240657d67f92b5e4261ace434fd286206c315565378ce8b81661523f0e6ddc54,
+                0x56149221712b88ec291fc218324142d02873cdd53199679fce4dfcb5dda9116,
+                0x681adaea79cf457db5701931f0ee2f15ecbb159ed50cf746a15b85c6f8a5370
+            ],
+            [
+                0x23af324599683d9b71b61d093d63dcbbd97e44957333d2697fdd060c1e4b585,
+                0x2e7a1c51da61dd214a1789d6f1ee2957f69d21b1f16d1f9458eb25a406500bd3,
+                0x2bdfe7eb4fa803bc1dc0052a46d850ee3e091eba8a7f12579682f6f6fd5044d4,
+                0x1d92e4213d840a330ecbdb08693dbf9a971bbd6229047eb88a03f334cadef227,
+                0x1f2805084976b142f7c74a416ff439ff1bcd8b8e7b0570130040754a61b71912,
+                0x99b0a6330926a4a1564dfe94f9a1104bb8374bb518a89de08c591c17dfaa059,
+                0x565b96659025935d9c025c7ab20b1611db00b67ecc51426b342f8c7a17fed83,
+                0xf0b9336db5c16d472fda3fb9ac13b13394c09ab9f484ecf6ad2060217b5896a,
+                0x2a7de8f5ff476d81d393f1d274636ca956f05bd422bc9f3cc0fac0054b58cb02,
+                0xf26d05e938f8317bd608eff0895d352dca712b653b1492f8c2ea96b26f9381e,
+                0x28b73b335c72f0774871a2030d444e5fb954979c1c568e112fb911a46c666768,
+                0x282a01e8f2ce09cbdd862f98fdaba3f9af02443edc962cb34802d04477de1e20,
+                0x2770d14a220152fa7083040be9b3cd38c8ace9e207073486bcfafcad706748b1,
+                0x27a573036509a8a29a90eaa34d2adaed5ed1ec6b207274f3c5ca23dad3880e57,
+                0x2384a384bcc2c4a17ff7c9e3e7d131d39173c431333a9c7c1d6fd7110e25902b,
+                0x162c5bbc81b44427be4e82c5e5253bd66c3054f5c5b73b28b29238487849a794,
+                0x1e6196147508bf2edc872c4e897a967778b119f69fb431a7f646d2018eab4010
+            ],
+            [
+                0x5a07868a7c95f50a015879fe7cdf1eb6c317e4d489d4515208ddf40a32329ea,
+                0x2065e374edb1f3cbbd2919dc04d14adb07062dd01ec1501b85522e7e0faf925e,
+                0x13bdacc137bbcf51d8bc9d281931d6e71122dc6e93e7ffe8b835e3393775c3d4,
+                0xd3b3fb86a44b7422429a249884c85644af1975641206e610070c02ef5a9f4cd,
+                0x27aa50a0e5d5588c1486e8e7fc8dda65489fffb866756c218f87e7280cddfa64,
+                0xb9aebf041146c119199757ea8ceee5abcea9ec42cdb28b921caf21e84847851,
+                0x2776bde52a1259472c1cc020e719f82191dec3ab7699b7d0fd769dd3fe392997,
+                0x275a6f59623354d71d38b4e200ce2e9676aab74ea8b8366fce33bdbc47d0586d,
+                0x12c6f6c83a3530faced60c88f19a82fd12b7d938a79864ed20a545a52fdce11d,
+                0x257689a4e22f6a8768aafe54218d31de4e409fdbf42319582536bb583313a395,
+                0x195821b99af2c217404ee582e29889072ba3cd994b74955c261b5ad364e5a9c7,
+                0x304b679008e8a1f09448423a05889e0df663a2b65055ca9ee5a99dfe13fb9a16,
+                0x8dffe684aa33f911d35e9a644b4bdbfcd15a4da49b6531816b60e8ce4f6b5e0,
+                0x72372083f62195bcc2b5afab1038198a3f0546b62d171ea21c37c8f31551176,
+                0x25547b51b2c6874e4538ca9b34093b714ad36a8f356e4c78e0d66b1f190038fb,
+                0x178f2aa8df9a11ef33558dcc934971f7697e626cfef00ffcdeb6f3c9c1a7d10a,
+                0x68efa35bc620124ab7d88990171bae4102ad21dfddfb387df0de0c8a3a189e9
+            ],
+            [
+                0x2c5b4a65bc55ac5fbeebde53ce5fa68882faed2a92a7b3f5732832c72f7f2c30,
+                0x2f36535a83a09cf09fc38a20a725477aec56668f034a364a9f4a5605fffd33cc,
+                0x7d78ce0c1c87391a06a06c83d300d52524b29f183884e300e0eaddacd05f068,
+                0x25c7e8faf6c48a156cb91d81a997c6673d32694a3fdd64f5e9594e9f504bad83,
+                0x1f3cc6f65d9d34370825a38fd1f48f509f7c56171b9e7a624d9b0ecdf6ac4eab,
+                0x55ef271e388278b1aca34d3cb00116bd6f7cb584b3c69f0de2a7afc8d98deb8,
+                0xc1a324c49d15f87931821989b8c8437ea9eb46ed3aacf8895fd1cc311053e60,
+                0x2ebb6730d7bafeac23fc0b457ea824eeea3c55eca634bf24b2ac2a9a21483e1,
+                0x201e03f1ff672629473a24f32d2d502acdc8fdd2883014de74c98f40a195b3e4,
+                0x1edc57f174e1322b627c6f9dbe27ae2703c3f11c364b38188bf41d8ca0c1709a,
+                0x20a56fce37122b7400ab61a65eac815dd180f52fad2835f7fd9649063523881e,
+                0x1998147edaf3a92ab179c61ac2c36af5caf3e78bcbfb684cfea15db17b835907,
+                0x1cbfab7cb05e2f28254b230bfce017f005fb4f2dd8935ad11765b347d2003667,
+                0x151e0bc2110e4300dd82a4c92442c4751c65b294426c8c320c69e61831958ceb,
+                0xe59e1a990ec00f72edc37248349d7a5a6f7bcaef158110450f1e5985f0a5d99,
+                0x24afd92f80e57788f40fbb2b79f29454dc485fbafb5a7263f462b7c84b4e500b,
+                0x1b012224a4f050df841122d17c5ea4eded7c8ec2034743a432a2cee893976f29
+            ],
+            [
+                0x173f895e472c4eb16a2aff3b8e0417fb32b83eb1e3233471c76a0550505d0607,
+                0x1123d3c97ff8e6b589d118bc40ca0b9ac12ae909558f2582551f7a42345b4621,
+                0x984c132b29a05f2b506ca07c06fe9a6584f36bb87506d2d316a4f353cac5f1f,
+                0x2d7af834c9cdf1b38c8cfed218f1ef0ce0b9908de9e7aa7a5510c4fb917a0281,
+                0x1b11713791ea4cb2e17c8c5867502043d0a8cf955384c1c793c506b75fc0db29,
+                0x26fbf1a351963fbbdab590dbd760ce6284273525a1b46c41f29226c65339f4b3,
+                0x27e68568e9cffd07f9253ef9dbc356251dc6b2d6a903d6c7046b5e90e1bcdc9a,
+                0xff215eb1e38dc67432e262df27eda7c3aa9419d5b6e299bd948e970fc35a62f,
+                0x118c3efe920c9c3f907c867743d35d2ccbff7c89e9c31bb6a17c552ef92b6c01,
+                0x17b39f38636d5eff5e06eff089eb56051a602bc8f4bf1bb0ad2b2cd10cf07138,
+                0x235132912db2da07a4750c5ed5df2590e718404aefc48be6953432f64424042e,
+                0x28a4572cb654261cf9358435923e65aff8f40393752748b76acfd2e3f5755c9,
+                0x21d7269a53d3712b20543b0039aecc9466520133d299e8442000b33184a39e84,
+                0x13f1acc389c4f8e752cc7e4b81c37ae2130c60df9c8b7e87dc5fb7459caf4916,
+                0x66c6090936f6b054f17dea91682954332b3e32d8f20a0ae171d417316d3622f,
+                0x492ae5f5ac2a5102ea96e60ac8375553687151ae44042dbf5899232c8f2100a,
+                0x208d814151bcdcddfcf835a958c259a6477bfe4b3392710edf9d80787a25c5d0
+            ],
+            [
+                0x206cb038cc328526d0c3dc5af19437d83219751c5ee8f61b0e9e2f5881366be3,
+                0x160b30c874d9c06704c92c266c7a5b7fd966a62a5db008f1bffdf443b1099a82,
+                0x1b00faa85136b1bfc496e0ea9a6284cae525aa96612ffeeb514808955693879e,
+                0x175af5e50e5685ec2dbb1cf7a2cd25d45680f6cddf68d7c0795dec98b87f6a71,
+                0x104560e95c49febb7a030862edb3a33c2b2a3d414b0536b2e54e25ab36e8f281,
+                0x12fd67863b2e03b6fb45224fb041ff280e936742b54c8e54d3823e090e144169,
+                0x1db0e7e01722aad210e5296c36e9103e82d15765c318134d177146a1d9fd5358,
+                0x247f9c7fa610322535feb0676cff549f1c177d0d39d3f1eee642e9253aafb82d,
+                0xf705feba5f01cb27b27c104bc93f0c974f561fa26d5614f6a9d9e47d03bc655,
+                0x306094ecfe63300b2f95bc98a0406c7898d86852330a7b69f9b04b5404b3eef3,
+                0x1059db5e97f25826b0bbefd6bfaa6e9496c55ef5a88fefe9712691f6fbdf4298,
+                0x15bd998c2729dbeaccc29b5d6e4f0fd96ad0a6037c84a1a1a785169fb336fb6e,
+                0x21fde580a19886b13358f18a32d5aff685b4bd77d94f067f44f6e7a93350fd2a,
+                0x6823a9baa55623732b02fa270b2f887fd3804a85c1a7f2a355df3fbefc69dc1,
+                0x1b25662843b0986ab1a4e9a766193efca47c70d49364f03d50c5edb5b5517ebe,
+                0x10dcb11f815c7e29c66be1dd3c5f7602c98e9fb1687c2d825b48789c521fbd0b,
+                0x28f901fcaa860b0dc4192adef8ea4ae55af6ce432c85e0ce4d073e514ab24252
+            ],
+            [
+                0x240c57897161666f28d000b88d3353921d967420f401ce86bbee42be287a4f8,
+                0x1361d27c42a7b4bd6eaeb98a339592616c0d4d8fceadfdb16468162bdfa88d46,
+                0x19e1e46536704ceceac3eab991bd806e347be40a0b7956dcd7037352fdbc4347,
+                0x121f4a18d7b7d9650aab625ebe8695a8079439f2ab00c090279de74726234e6e,
+                0x8c45f3c4c486f6b5378c779c607b517200bb70b5533bdacef18519f625b925b,
+                0x600cf26635b2d546431507589739010d1b757ceaae617bf95b8e1efa98643d,
+                0xaef8a4e47d5ec760e0565ae7acdabe7e8e98972de86dd2f447aaf216ab4cc17,
+                0x2ad0bd9f71e2785084aa0b84616b7dada053207c418e65f4035be66a0cdc8c12,
+                0x28d327a1c2d6012d9e69e9a3b4c11ad336d3c0dcdff4c5c84ddddf911eb645f5,
+                0x11afecc85590543bd2df8ab952be164670a3f32593e962d4bd493bcd3c84f84d,
+                0xb050c882073a581e767223705cd9510c04c30168c50ffe0c9875a28b6938299,
+                0x7cdf3309e130f9ceddd688af3885369fbacf6d8a44de4d450667c0d7641213f,
+                0x5232bf95807e48ad82a1eb4bc481e9b0720e95196dfe361f55c4d1cfc7926d7,
+                0x1e41936e6bc0c3ed665c2e2466ab9216b9973fe136d9f9aad95878c1b5607c6e,
+                0x2647635477ee5fa9e7ac5983f92db34d7336646c63c63e2dd53d60b8714bd759,
+                0xa11d587cb75d48544eec662ad27ca6acfec98f7a8b7963a294e4bb329b170df,
+                0x1bd639879731823c871f9cd4714e3cc56a6eb19884b73664eed24b11929119a0
+            ],
+            [
+                0x1aaefc2e9925fcd453996fda804063fdab276b37c5f51dfdfef9255b4ec10cc0,
+                0xf1e8f86860c3b5c78bc14dfb67d22c6beb8992123658842f23f75ae3a92e99,
+                0x19c2540bbb1cd4e08f105437063c945cfef28ae9dd50b97e0b795f8dc5ae34e2,
+                0x21f08f9b3c23f3a02518114a96929b6d1056eb4d1db147ce0c8882e1b0f7bd1b,
+                0x2d2193c677bbcd56a74fc2ae50ab4f2cc69aa77ccfc33c7707452d5adac77edb,
+                0xf528f5912be49455d4323b259e30ce2984d8170601eeb4bd7096b47353ab7fc,
+                0x8c00c4e5b3467f01901f64f9f89c15bb0b90918d488b730cacc3296691e9200,
+                0xfc3ccef00d6a64080abbed4fed90b69c5e5803134c22b42cdca0a60f03ec33c,
+                0x1bce67f4dc99547f2caff1b5c6d63e3ee2565a404190664533c1c65dd9d8d532,
+                0x1a8ba4f37d2315389c8560d74dac572a4447a02145516287053e6b9edefbca2d,
+                0x115e60c4e2937eb53c6e4a5488f801266e84d07547a0b1cd91b18f49efef9920,
+                0x152d47acb9b06c9d12c2138a31416bbbbb991a65dc4d4f8ef91a3dd728e63b6a,
+                0x13602646b88ba31c0d544c757bd9181727835dbe690c30583a23f37f52fe5e3d,
+                0x65766d2980331a55c0a39d83be78bd127baee77d53a24268e064c71daaf2b6a,
+                0x26db2e85a9006ef5c11cd675a267d42efef9f5af90466b2aaf75eea8024b00bb,
+                0x1dd6b095cb68459dcf6bdadd434aa81f80a55a08e6782c653a93afd8a65f3267,
+                0x1d3ee85f078fbeecda2473efc2bedd1ba7ec6f4795faaeae3b0de48d3080c625
+            ]
+        ],
+        [
+[
+0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+0x197fc9fb21309218eb702b935044146cd33407ed33291cc599340b271c399668,
+0xe8ab972df74eec491e4b8c416b4a97c3fe65a38d4e76093ebed05ff3e7d750f,
+0x17af7102238531c988dc665323d3e3348ca13eff7d006be181cfca573bd77e79,
+0x1b0b5e35d65981e836663ab49379580a659e1dda0d8c49c189b8078bcfdd3f0d,
+0x1aa303c6d0552d6fa013df27f7f4aa907d10da9cb9e0881ef2db7ec1a74abbf5,
+0xf4eea81fe11aa323228b430a2f9021e2639d66596b3821e131cd8fd5fafa0a7,
+0x1b47097a86346051d2d42d6810ee8f3fa3b992b90c009040095fe8357b6be24f,
+0x77cdf97e2049e1764e7169aa4ec11ed314badde9e84218bcff380ffebe45382,
+0xb4d6879a54ebc4b74422f70789c1b7a47694f6bc0f88624ad0141721a89f73b,
+0x14ba91f29fb5987a1d3dcab55e35edd10de3acf4199d877b5c6623b5a6ef8d9b,
+0x1fabc01bf1091b88001e832b7ecaee26e5eb867f85b8f1c083832b1db57537a0,
+0xb4d4c2920ec03187d1ff531b4cc1b879c7321315d7aeac09b53bad9439ec93,
+0x2191792ed6ddd6c3ea8ae009cfd1174fb9efc01482488c101502e34db953815f,
+0x162b05a1204ae66ca80d0a89e10426ee4d757f9b34ccf08c1aac697c55245980,
+0x251575500ce3526f4b190061361eb2576591f9ef2f0a7ff9a7005efc3c71263c,
+0x4384592e42ace8c8014f728704ad93695e50a16c5199d5815e00ce818ed8081
+],
+[
+0x1440dc2578f44694d18c25f892d98c23cfdb87a772200020e897823d4bc84d3b,
+0x2ff15351b14d1b852edfd01a8ef108ab001a10c8d66e887daf1817a315289259,
+0x2fdcdec10d3354953fa9ca8769a3799d001626bb715f19a97e772f2ba1abc421,
+0x146deec0773f075175a208469afb87199d1b063c994b98125db22e85844fb455,
+0x20f00881fb533be89b9246780df72a26ecb103c554b9b6fb17844fddccb235f7,
+0xb419e6fc9348d7c69dc15b49fa148232740635cf2e39904cb5bf7e4e1c85292,
+0xc6321d9f04dfd91a4fc850ab7d1f7fa66de38d67faac26599ac62c80784319,
+0x12784ae3aa761f38e035e7ee5f21242e28df65235da8599d80a93646dfdcbe9,
+0x1e09ddd18fdc3c46c7b2aaf6cfd942c62720cd1630b63dca72b42b4a6409c5a2,
+0x2a71a3a65e49942b825245aa127bac8dde2a6fca570c8365d3251b146dcd078c,
+0x197d178b0f91d12bfaef18f402635554efba7da59bf45f6daaf3eeba444c3bc1,
+0xcf6927b15b1b9df1656581cabd0909b7ee2f1dca0258e183b07b030b5db3320,
+0x284151191b230312298ca0d1cc6fbf122b435f7e8de25d9d1927322b0b5a84f7,
+0xcb8f5333099700c6d37c787c67bf7fa6ad5e35c32fc1a539a8df57b910257ca,
+0x15d5a61db8e06697df1da0f06916eb32d90e86ddc53d177abbc7ccc86f14188,
+0x2a9b60e4ae169f3d5fcb4bdd705d89e0a9361e239bc3417c30a42ce645e76d6b,
+0x883b0b606695b0c96a67ccf221ab0169eba895363e66ca88425ce3700c0e7d4
+],
+[
+0x23aeeb0c6499b84bfc32ae3c42df9728798fd2ef774f1518b870bc57d1385900,
+0x101e7e35808991e8cdb0627796f331b89f2646cf0263924aa6003460b351a940,
+0x2bb568a99f55bea84bbf76dbf0f54d5f1331ffa1f62d686f3709a56662e51931,
+0xceed1b75b2f6ef1438b751e8ad4dea24f1a20f1d9a23589772db49baf9932f5,
+0x2af501312e1b653155ec7f8e0e59649b2d078f5ce5121be83fa716e1b5dab2be,
+0x152fdbabfe1a0ded6e2ba5497e140ecd1dbc9fa8df6705237fc8c764317ac751,
+0xdf66c437cbccd268bdc448cbb706f4b179ba223b6bb87a921094257baf2b69d,
+0x15e5521c580b9faa337d9ba06514ac965c373a2e604305b8efb0aad802e72a21,
+0x9a09a903ce4f69ab99dd47c16087feca6fc2126ebc4cfd8def7a0253303f866,
+0x2bb52dc2028e9887b2a82271ac46f7800dd147e706370ee5edb35b9550cf71b2,
+0x9bf3d01f97e22646505f76fdd396b026bc8bcba0e0522ed2ba3079d301fdd88,
+0x26b72c368b0bd0103cb7dcca08e68b4446ee788ef6114f6ba899202f1f19b5b1,
+0x2bcbae8d5471d562e885b4b185b56ae0fe11ca5bf5461a1e0a41205568525f43,
+0x805d6862cafcf5030ab30262a01f2c65b2b7312ac9279baed50c177516bd0dd,
+0x2b8b1aa994b54ee5617766dc812d15d3cabf187d8db4ab8da85130f73f01e746,
+0x1fed5b75b01e9f4af01ebd30a6f355e8b2cd88f19e49892a19403a895fcf284d,
+0x17ee0034bef77cbb115fdd75be9880008af568ed633eb7b2abdf8361c4357500
+],
+[
+0x1ed9d3e9276acb7b4dae53eba148806fd9bb07b2dd06187212fab7dcbe63d72c,
+0x2c05638ae2f83e73ac9b1bac220509e30ff5757342ccad17261a4c30e3bc634b,
+0xf1fa08e424e4691c66bf0a524b81e886da234ba5bbf78cc168c8a13353c9654,
+0x1ee32a96f8d3e8fde8ffba0fcd72859847861b8143052e212bb56b103f6f742d,
+0x20192d8adf841e5dc110994238180267954de29c8953738ae196447acb182a7a,
+0x2419a609a380157d9f6c6e64ae2cfb6e4b39e0d6ec0661b546c1552a620f19c8,
+0x3ce58f147c681728f2a2af586144d470e2231e80161f97200b7aa6d624b8bf9,
+0x12aba963e415f9bbc95c5f1ca8affd59b6c6b03fcccdccb417a9d89a4eebfb32,
+0x167f26eedae299f0e56157c8c7fdda1ecb48f90e553ecdbd4ef35b92ef9f39f9,
+0x486a139560dd70e9054321196ddb973e7db09350cdacde3c1c7817fd2b8a46d,
+0x1e4a632c34dad41873c541c5caeda02bf58f2127994bca0b0780bceae409256d,
+0xa471e606e256e387d5e44d8de55dcdd833b364baf00a694b52e3c10f21f814c,
+0xc52f1224066c212a3667bb2beeda181ea00294c5aab9348e5a71d696c8fcd20,
+0x1b2e51bf0afc16188b7ec633248eacbdc550f592c742edc91b204d49dfac42a1,
+0x25da91e9be50e3762edb77a90706df802461c374a7b90fb2ac018930f3b23518,
+0x29db9bd9f3940384f177d7634721451ddd0c6a868fd047161c2358e9c305ad24,
+0x7062de34f5c74ad5822948fb7c476255fd03a13d9d8781262712946db22156
+],
+[
+0x2ff57f3f7e95b03411db790a86647467581197124d217520ef2e6332a5b35185,
+0x27ca7b8c33207e75a42cba1237e0c568d3b31f475424d23a9fd0ba6ef188df9c,
+0x1b6aeec49e5936a23d2182de5ca78ca56d4ffe8589d3e77d07a34692a7c5b44c,
+0x5e94c1b81bbe16e77c7fd2db254949046cb85834c34e0d8986bff72ed22f6f0,
+0x24a01b8801b2865c3a3d20b6f31df95350f5caa9ea158b3ac240ceb81c8f6cda,
+0x18c647eabc6fb45dec61bdf9007f83863fb6b7827b23437e10e49baf8e835ca5,
+0x523cbdc5787c220da27bcd517d57bf3b31cff9e4e2e97299d44d9f838d96465,
+0x1799989ebc4fbcb84e487b4e42f0e4500c309c2d90e740d03f8f9bceda208616,
+0x254d90f21c923e30fcb471688f64a6115f0f4340b744c5d732a077f5fd6b46aa,
+0x10d8f1c90a94db10a7b730d8c21c69e793cc985e1ef2c62b8815e65c5fa91962,
+0x1032ccd20d4ed4502df7faae0b2d9bf2c5368304a24611597d7651733053ce46,
+0x39bed2152c1cc38fd8a0addd226c2b5d53097f83d826f7e9b9a3556a32c8001,
+0x261d68c368aeeefc167d6b3e2d22be484231b5b800b51394133c7baeef2f879a,
+0x28893305254197bef603078e333db361dec1a7775813bd95d39e386729cc665,
+0x2f570c80d99ea49bbd76c199e961db6bf59ba6e0a47683923716f9e10e913221,
+0x2318f3a1f9ef5c6326960014e622db56d8adfc885e3d0bc2d06e86ec07b156c4,
+0x7946f795fb6251bbe041138607f0ee6e1243dca71d592cad53f634dffd91ccf
+],
+[
+0x15faefbf8584a38969b4a719ffe5f02c2191a8cceda0b775162203d30b80208b,
+0x1dd8c52fbcd6e06ceddbc122ffcc656e4c28ae2e88b94da79f3a276bf5fe2acf,
+0x2915408b3b7c2cf127999ef3a84a0a5c2de70e75bcb06ebac67c73ad36cd7153,
+0x2e655f7e6277f2147665a414632eb3a418acd90f6a29748e4249f6713d54007e,
+0xe0dedcb898406ec36e1ad2e3992b99c8b457ccaba2105b4436ba840e89bf0d0,
+0x270a85dcfc9c8f202cdca355246fd989551495ec57f8b6533342e3af8a1e6d85,
+0x494b4c62731baf8f3338f2cc0dd934f82606e768f563a755cc501504a50a9c6,
+0x17061fdaa032097e06c003d9d719d29df4c30109d6fb86def324435e8176bbe,
+0xf9e56a5af5386c4884ca7d0e7792a22d3b96a801f3e8e79a6ac6578c1ee0a75,
+0x24a746819bb8574eed44e23319cefdd09c0e8c2dd1ce6924a63ffae59eb1a905,
+0x703bfec7b532b9135f72a794d9e3a3c6ff665c08d590677026a06cda66055e9,
+0x21bf1e826a3e2141ad2cd0c6b286146b530927f0ddca59fa78d06a36564b7a3f,
+0x2f678070c83d71945038501c74ba5968b131939a6af6edb297de5f345e6692e5,
+0x1c30abb88b3fb7fff8e97da6107209d608fbd9f2db97e61d74dff19d3e36f3bd,
+0x2a14fabf9e37f4497914de5868daa628ef3347a611f675d94ef67fc317e28328,
+0x9ea8d820c4e6ee47a4fcbfba19cd94e915de9dda25afd1399c921b1b7666854,
+0x106d7b2ded46945b3901ef651245d519ae93b8d2eea8160970ed07fcb6f58015
+],
+[
+0x1e6eaab1191593de0d89cbb2399ab8aa955d829ad959428cd539be30b72fde9c,
+0x12f17c280efa40df0fafdb7148d7ae86b6401f823e47854b7f11c0a87ff00bf5,
+0x2fd97c7d4e331e328d3eda047a68a64f7cac867b6bd3795e2932f350644374a4,
+0x2c1c8f60b63e8cbba016d475ba0483d001c70653c1ebc256c51e18975371cf08,
+0xfb2d646b505c61dc54f56fe9de66641c6797e59e860528aeb52867aabafc2fe,
+0x1a44835e3e9620a13fdc072c1212e942ee95e683d6c07ef097527bc10616c622,
+0x192e49c626530d5965c53dc6e4209856d71226aa5021b9eaaa1784044c8baaab,
+0x80fa9dddf985137bcfe965068449cb6eb36b1ddb1706d8632864e954f5ac59,
+0xff1355d96389f7c74b274950b3f70a3d74bbfe992860c7ba6d9066e59260c30,
+0x237f4f3d794bd3a23cc52c74e0ee10dca1d4edd90a3a519af54944ac91deacc5,
+0x1c94985507159d367f2aa5a1a04857bd44d205ef8439b844386b025976646bd2,
+0x286fb15e9ab4224c0319add3a16b8c82dc71931fe3be2f4b3ff0289a5319c4ac,
+0x236262438ed3acbbf4bd56c39d12be65fdc0126562bcd5468a49da6ba33fc9aa,
+0xf695879295d610d1edb0da7c3fa43c3633e2d02d2e6af6799a2da41e41c3687,
+0x22949d27c373e4447e9814d6f189d064b3b092b4480f8d21c8c12342a956cda6,
+0xbe0a5f05b6f2deb2fb6bf836805d52d9ad224e8bb8af6e0ffb194a49ce026f3,
+0x3070888a62ededfae0d72f144b8ab370f8a54c52597db33d98c24edf1daba0d
+],
+[
+0x2a3bb020c8a50d310ef5b5c77cc408b077fe2481454754c4568ff668fe5f0974,
+0x1399820ddf4829a24bfacbe47f56b793117f599efdfcf9e042bd5780fabc29c4,
+0x2303c2e89a14828a19a9f75d97f17fe08b6282fbc090e6dd69a4d780032624b6,
+0x1f7a5f8fd30b1f9d7f5855c084e8995367889a1a076da17859cdbbfc8301afc9,
+0x14f79e9e9c5998e8cbf5a2f1de18ca7707f5627b5637dcd962725f8ea1804d3c,
+0x10199cfd4b1cca1f0cadacfcb429b44bcf83e13ccc098d908163aeaa1cf5a9a,
+0x34459376fe4246c7ca6f298180c2150367ec05ede0dafdc4806d34e44c180fc,
+0x2933eb342796a75af7e1dc15c04904b5f68bb56ac0478a85233a588509edae0e,
+0xed494f6fb5598ab0a0a7c655890ddf4a7c0684f24522d2af98dbeb0204791e3,
+0x228e31df905565ece7246c261aa5b700f60f6ddd5d7c249264748ab3e521a20d,
+0xd36f7669a52260da523b388c608dc283f107e9578e0bcbe1e3d4201b6d5bfc,
+0x2ee63ea38cc2cee0e08789581cb31eee9b112dd61e4032a8beebedceb6aaafe3,
+0x2be13746d4b19b770fe382bc7e7a56e805c1ade0c9236e3e28f90a5fa874296e,
+0x916249fbbb750e41ce6f9475e6cf6337ca4ace63f7a4a377c14fda9c7b205ad,
+0x17855df635fe8e7fc7919412106e9852ecc57aa0b759b490cfc4773078016f53,
+0xebb48f5378773ec048ac3eb5c84d44cb2585583ce45ff30a93721d70f289d0c,
+0x33106bbde7d027db2f728b2563a62d3d6f8a02ae114bfb8a2593c6a2fc15524
+],
+[
+0x51f815c454b6015c7ebf90c297b90e9604cd36acc6af07f99b5e51fdeb32234,
+0xa44004794fbddceeac78010d88b2146984c75553cec26164754d72598358b37,
+0x22423aac5a0b511923d747148e091d1945c252a77e51bcc62ee173c5483f80ab,
+0x1e14c0a17f23e94ac435bb7f629c6c0ab66fca8c4db085fc56be0ad9da545827,
+0x1958d6547accfb884d50229a4fd5b234a377f5c671fb865170d0a393680ba3de,
+0x14bcc6d4b8326e66b453691e5c948a80a618b4f7ecdc3a380478d43dd4075ab8,
+0x193025256b9871e2afebc966ed68f38d2f906a4870652805e4246353f567c5bb,
+0x1e4200bffb9ca4e47bb270a09e8fd994093dbd4805c4cc15185ced28ff872e10,
+0x1d1fa5a83742eb9bb853197f56a4732625b2474e7aadb9311dfbdc0f41ac61be,
+0x2d650daa87c7e1c09b53b10595bab1e14c32a67142092876c57b4ba68efafd51,
+0x33319bd5b5247a3cb7f63dae46dbd8136f3f3a9b4aa0a232309070d718f7d47,
+0x26e56b19e55c9bb5df436c13eb6deffab5059804552442370be53a951b0a9e22,
+0x1a0f0930bbea65ad095174ed8aaeaa84628d35471bdad37bdd624d2eedb6bf14,
+0x297921088a94bfeeea233c91483a21bc59982034e0c8738c6526cd44f9a11306,
+0x1082b0f264c61f37b71fad404cbc0207f809cf8002a7e39c0290d88a48120356,
+0x25cc52901aebcb35f9ce47457bbc4507bba219c88a5bd1229f6dc46c503c769e,
+0x2ae1b5b3e89117e08bb7385e0b711de334e8fdcbb50ea4bb3718d5e1a0bc8075
+],
+[
+0x28b75c2ac167fdf184725317c7bbb8083e5ac5bba937bcfa6cefcb69e4048bf0,
+0x4eb2ffac1de16288f52a4b74101cb73d53addd56bbed326bec180ed2363c224,
+0x2bd52a360f3328d5c98a6b2de15df151e997cc92c2c72e542819e317c0ee1d2c,
+0xff14782906fd866584bb5e93cd18678c22e320ddc66d6fe0e917e18de1094f7,
+0xa4a053ffb41f84af21407c6151dc5496a9651a519e317664ecdedb017e3c50a,
+0x19dfcf535e723327add95d36e7276afb472408699d7212f34abe32f808b4d292,
+0x155dd9ca7898b0559b3e407149e6dd64bed6f9811d59b1ceca7486a110ec99aa,
+0x2d9c5bcd84c97759e28dbfdbe9fce6b3c1cc7cbc9a2e35f2ce8a8bdc80a3154b,
+0x1ff3d01d32a70fa0911119ebbcb4bcfc1b4fc30b2ec2298832f5da4dce3d7a4e,
+0x44ce295745ded1737be0bf68729d669efc18e7e9b55e6ef65f895e2f9e95056,
+0x117377429e138736228d8762c8c6567a936980b7c043882adad3951b9986859a,
+0x39c17d50605261dabc76676120b2b889ae504138ba722976d8dc822bd1af974,
+0x2a6f067cfc9dc40850f552ab42d6c096da045f8039453d7a9e028c39f2f1377c,
+0x1d7e961151f8a1d1f6092f102a7c911194618a3bae9ef78de349a99ee05ef476,
+0x20431e5d3bcff4bd90372a1eb637c04536317a81b02b48b5a3ae45a4e8380527,
+0x116b0dcbc35fae766914fc09cfc359051f626100151eeb2a762d7a0738132a30,
+0xab340604e81eb37a5dcbf1e7d5ffde8f2221d60b382d43cf75a0f1360ea5c72
+],
+[
+0x23af324599683d9b71b61d093d63dcbbd97e44957333d2697fdd060c1e4b585,
+0xb11660056e02d7f845b79d49bfbb685555febb54eaa503d987ca5299521d16d,
+0x1f209382e3fcb44eb1b1c03dc2be195b3f92faa9c1ae1a0b57c4df69e7a53d51,
+0x22e25afcf23ec18a36471d593ebc8d93372315cd666db66bf398f7730285f9ae,
+0x18eaff4c9d5d00d3483d7b0c74551a4487c452cf672e6a74ca397be38f5d793f,
+0x1ebb9f7b5f7f0c553b03552d104693515ccc17529c6c1a462c0c24473630f678,
+0x1212ba1ac3bfe0c08096c503be351bbaea92aa3d3f6c264b73c7ceda7f8bd721,
+0x2f0256f9b47269790f3f2b46a7ef2536d8661dae60d50a61bab58346e83885c0,
+0x1b6a8442e48b709797a514e36c1f86b13a413eb1f7fef458887833ef4b482124,
+0xc96e617f36391cc516eb3631eb8a18d4dd10d17135bd93f450ef6ae2a945117,
+0xed9dc15c9f4a60f8150e367ba71a4a37a9cb50c9031194f55850a1e5e325911,
+0x2b8b201e13900e638685cdb4d07c110a8f8e8d500cee83566aa733621cc20235,
+0x23bf4e044f678ba1fef62ce070897d6373914ee936f92a2f4d5e09890e238e34,
+0x22c93d459ac5db54f2b6a4f267b5f049b976a93d006b88a98a5fc0ea39f53a72,
+0x1a54b0b47d98fe83acc4dfaf83b8bf7d972684923d5c7dcea9894b6a07d934ab,
+0x22ccb3842b2d75a33b65465a5dcece6870afabb3e3401faeb6504de406348a23,
+0x1e9abeacdd2ff75cca093b6d8826a46d8d2c05e30d1d3995da76a4a8ca9d2824
+],
+[
+0x5a07868a7c95f50a015879fe7cdf1eb6c317e4d489d4515208ddf40a32329ea,
+0x28c53ca5db5ceccab548d154ea6071e47ca73b6cd4fda7e423403cb684d3070e,
+0x651a487e9ef91d9c4fd75178dc57aa1f76edf56c4c5c2ba6ea7c6d919e91440,
+0x16d216f97bdea9f8b01025cb47acd5d03e8469dc6b558a235a23d2ba8773c71e,
+0x2c8a5c7f394b071d0f329d51e451c8738f896a2b8f87c6eb3eaaec71ce1cf71c,
+0x132175ccda95488f348ba37b6c3641dfbca9e4247ec43977e279f844330cb694,
+0x28eba78439ba284229de2b1c6124fdde36323fc82805988501337a3b48aea040,
+0x140f550b1cfe4079f7c44efcca6515f70a9ea190d2cb4a2cf116719737b15621,
+0x1fa08142c4cf49ceb13532ff6f1c453f9ac4035d8ec5514f4f3b52c3dea9bb0e,
+0x592cf45e5a2dd382f1c6ecb059c99232e2b52bac5475c10b6669698cae88827,
+0x2897ccf4f75df225ab5b1c79de477945b24f2ea127c5cbb37954370505957a31,
+0x288ec4309c81a0d2ecf16c037706ea4d526d717285ae02da008d14cb8ea23ec2,
+0x12bd882b0d8af801ae2579a884b11f80f1ba15f48741f61609466bf04f68cefb,
+0x2bbaca431e1d464281a1e6f483cb4e9b2002d0a0ba1fa70b60c1bececddb1e79,
+0x173087cac123e07a0324ea3c2231cca859d7e4d112c8e2f4dc9249551c941007,
+0xbabc1aa6aa0d7b234fe81651f7b6d616607fa766534d5baee6f63bf02995fed,
+0x233f5274aab1d107af4bf7f2b7f4d57d8ee0936005a3525549cbfc75697ca640
+],
+[
+0x2c5b4a65bc55ac5fbeebde53ce5fa68882faed2a92a7b3f5732832c72f7f2c30,
+0x17d5e7e1862b3708cba3d41c556b070da60b73fc3ef198227f2dad5b202d5c9a,
+0x1d7ef8564a9ac7dce945477d529ace63481ace463a86cbdc1140645ed57d0b3b,
+0x1edca4960596d41548199aee6040d39d814e4562492a070730982f9755615117,
+0x258655ae996ae6e4deba6fecf1190c2afbfc1dbe82454558a18bdc9819442f05,
+0x279a42b218cc556132ecaf5666c04e89984f5ffba4225281d3261a48bec6eab9,
+0x24605ce4aaa33a0bbc08d586cafd70bcf4c635bedcf98afc3fb0dd32909e8ff,
+0x292481a792f2dd4979b04822d73eec02e90c1e4ea42ca5414989ba04c31529c0,
+0x19f8effcd417b79016b57398a7bab72f946e75d8628f569f327df5c6832907a1,
+0x279c71db7cc16b9c726b934545c2fdb75d956d16f89210aedfd7dbb4f1d9ecfe,
+0x16f4afc47a61df3374a702f2800a3a39fb4450a9f92e11e240cc6d76c252de41,
+0x1ba7d8b083eb0e83cf9178efe8514e612a5d3905cb9e4279b1c09ae53e8cf23a,
+0xa1e2e12a51722b6e0acb9705c443d148b1334dd897185eedd4c4e87170e42c3,
+0x1d6b7bb51eb9ba719799096e5e0c1aaa594456cbf08b2bf9a479279f7524d3f,
+0x1129fb969355253e7cb31fa942978db34b7ccd3bc0d0cd02ba6a49e159d1cc7,
+0x23e3f31479550cb197235af10741c376d326f85881d1f1076882c928212f8b9a,
+0x1ac5a27a1a2ea0d7035f74d3a9b54b671e58711d79c87b56d32e40983b62c8d5
+],
+[
+0x173f895e472c4eb16a2aff3b8e0417fb32b83eb1e3233471c76a0550505d0607,
+0x500a676c5cd159e6351ef8d2b567646fb4d4c61d3c0b828ec201d4f425991ce,
+0x1aba42213aa1f15e7550ca941d9bc485e195ac204c5036afee992a967fadc501,
+0x20ebc05e620d2c7c362f8d7916ed7e3e12802cdf41c87b06790c40f5efdf724c,
+0x191531c0fa2c547a1eb51cb026e79cd663abf458a2e8630e83c1f11876aeccea,
+0x1ff17bff476047fd9a466842c8fbd711c1b3c1841e109c687ba4620ebc49969,
+0x17d7ef1f4f75295cfe214dce7fc21dfff13ff8a3c7bb86224c8a79566037179b,
+0xbc4494e3d58cd6841d0aab064400e6ae8594c35f7e9672c55f283869e0f3f93,
+0x174a4219c4aadec5921ae738b7cb40a3219ef5dec8db3bdfef39b373b224d38c,
+0xe989d36297ae2397d85b8025bb304fe42bfb8bf93108996d2ba13968bba9874,
+0x1ad84e6a15633eba89050cc15d94e459a6c2d42825986f9c5803c66f08976329,
+0x6f0eee01ada409058a818ba8369498fba956e713a7e9372b4220ef15f954a99,
+0x74a08a71a7e34b1031b63978e329bd0e12ae631100f24fcecb5a60bef5c3ddc,
+0x2185e4a0d25570c435162266b565c1db0f23ce4e61b85b8b8a1872517754b632,
+0x2bcd8e3cf988891e58bf8b8d3a259ce52f86de01bb8e6c4d49dc903f4b3ecc07,
+0x2027fe75d87804599fb66c0d65b287c4e0582a4e8d84bbbc85c6422cfb5eeb9,
+0x1e2dbde2355a4d9c61ac0c0db87447c67e08550ac91bf04d96790142d88cdd00
+],
+[
+0x206cb038cc328526d0c3dc5af19437d83219751c5ee8f61b0e9e2f5881366be3,
+0x255fbd250e6628c5eb540c311936b282c52204f56fe81ef75c398d9f0adebe12,
+0xe14d98de84653e22efab29261c9a36c207fc9f5650ec1a5bdce6ae992239e84,
+0x1342f46c9e240aa8eb2f1dd6c61d0bc79fa6cdc3dd8fa67d79729b02343b6df7,
+0xe41cdc0db95ad5d67946f0ff028aad8c3a3c88acf10519e736f9265ce19a2da,
+0x1cc6d37794a5bf901341db685e790cd7f7427b669069e4d320efae1d55bd7157,
+0x117c39e46a1ae3c90b26b0df85078ebdcb66362515c74d51cdb192f789c9cfc0,
+0x2b4c77d18677eb99a966913f7ba7b478ccda159d0f61a58702e80f4952b37077,
+0x250d35fabe31fb7fd1719ae0c13cafb64e706932fecfe47e475034289443f240,
+0x2c712075e8848b2d26f7c8c6f7accba81a49800ed3515221f03d845407b1e1da,
+0x1d04d22563bde8bff1b425e9bf113cfe2fd15dca666b9130e56511462e971465,
+0x135cce03597dd23591aa6fb38b2e70ca41ef91ca05997adbc11354cd831d57f1,
+0x24716ad2942c2268df507e25be255e45c00d5dba96093df6c63c8a4df733f0e,
+0x11cdeee1ba873dc61888aff7be54fe50e03e3a4a5ea0f32c6acae7d15d9f7979,
+0x1ae588627ea2e0c046ed4f6c208f29803a25c9b2c0c385be294b9c25a3287e47,
+0x8e0df227ca5a17a9081c60caedb5435a8aff99371a70219715b05800ef811d4,
+0xa1cb35782612c7998afa40dc467fd39c882e6b3dabab079e63c330bbc8e5f1c
+],
+[
+0x240c57897161666f28d000b88d3353921d967420f401ce86bbee42be287a4f8,
+0x7c9f836c94eef4e831b3126c06a9b4ba19c11c7e886f65c0d6267e07882dc57,
+0x156f5afd193a11d87249f3422912980daacb8fed225c60a5bdde7c4d93d5a019,
+0x203a73837d577d910d3bce1b15fef96c1bb522d4f02cc4032becb907810bc85f,
+0x217ac1a2f28cb7bd2509d90ee4c03aab4094e3fef4741cf4015e1e823f71c0e,
+0xc2e41be00d98a8dff8b30f5dfbce2708412e200682bd596b2162700a67274de,
+0x1fd5670b294ced78188cfd816a41358ca32bbe8e024a2a200fe11d060f8c5e1a,
+0x2884fd57b70a2305bf5b94c325b01d03f3cc2e8901014e0be3dabb984514863e,
+0x23e772e0725ef73aa18f59f934dc11bdbf5fae9cc67fa18a2319ea13a69b9c4e,
+0x122366ae0642411af291571a8904f0b6c6fb11d1ce750b3316ac35f310e5dcef,
+0x1d0b0c33d83a40412cdaf42cb7ee8e5042d9a73eb17a0d5867a3191aeaea61d7,
+0x8eefbab2c1c522367f543c33400cf254fe07711f94e9036a7558565e7305c0d,
+0x209ed5faeeef4d1d01bf753704574d34febc7afd299a04430bc0f8f0baafedc4,
+0x1cb753a0f4efe61b05e95e099e4b556770b364873d99e1f77e38a53e9c262673,
+0x2a32d7716eba1cf93c98e9bbf805b0e4d27cd7e3f26c560beb2aea41c1782d8a,
+0x2936d36a869b8b2318109412bef3c1a0407a8e0b98b4959ee0b624c116040494,
+0x281ad4ade7262394bc55b71a8aeb4135af3b0c2433070cb0ebd9ec8e20dc7280
+],
+[
+0x1aaefc2e9925fcd453996fda804063fdab276b37c5f51dfdfef9255b4ec10cc0,
+0x2eae17dc561c37084e990fd1bc5057d96e7367c4b801d27f6a6ad8e0d0c0875c,
+0x247ee52031ac073a81f56a957908c200477513fcb9853942a62b06fb6eea3bc4,
+0x275602e8ac1136b245f551cb053d7eaad7dff488df3f645907a5cb151c553523,
+0x6143a7c97a91838b0ad68065370bc9503d3e0c8d11f2a840b2c32c3fe2e79b4,
+0x1f3aed03d37f7b14629aa2e5f086bdfbac862325988c4da943f88f4313647df1,
+0x18fc0aca1d4a45978f6e3fbc4a35a2579a4c12eb6ea700f79ba56727bab87117,
+0x97c4f0ca6dfc073c84e97fd4b2c341ec3c45b6f716700cfd7647e423f5e634e,
+0xde5765593280a32bbb1630216e58d1d669ba575b7d276a2432d9c6ee302a5d,
+0x7475c2b72238b87b0d8cdc92890f037dad0bd67a3c741e5672bc8677a35c206,
+0x244e984c6f2f2133efa9d5dbbc1c60463d26f7748650658395201b367a39f554,
+0x27a55f5103ad08547128724e6c20a4ae7af36be03567e4efdeca9880214d42a9,
+0x14b2c9ae1ec7a0c1593ef29e782b063ed48e580ddc3255c0a1f081e69b634448,
+0xeaf70eb10be27fbcdcfa7ce5e1b289b66fe68a3114038522d61b435f17ef209,
+0xbf40bc87a391c052a56e43aadd307df751dbc47ef7c6c5af3e7bc4ce0dc942e,
+0x3afb962f8ea2cd1affb52a50cf59cd5b1f08f087537859e8a73524c3c7758e2,
+0x240011c27da581b7e91efefbe8f37abfa3c6e456ac5a6da05d4af4884287bea3
+]
+],
+        [
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2cbd265ce3e5beccb09bb3189ca08832cd4fe102f39f9ee2bfe851a8038ce383,
+            0x1e0217f13e7f212053e2de966a7ad7fbde6a7d47335bb58b2b148ac4ad7b8cc0,
+            0xf885c4008d2a4c2992b3337f1c0eb3b21bc5569e7eb6aede116420d33f981e5,
+            0x2e9c594b2023ee628c88f7a8cd002e06fddca13a014922ea4fd489d7f00d0cc8,
+            0x217afd05c2e55b85675cb39f0aa486a11691557ca9ee1b7ee42f06952bdae058,
+            0x1f8f067c1602f54ba576795e16bc269cc4f34416fa619920126eb16da9878c5,
+            0x25f3633c988971494c6c37a0de4b737a88cd5be9c14dfc66ffcc4c5200c3d6fc,
+            0x18cdc8b1d7543efccdebadd46b6e9096117758a3e2c638bdab7767e74f88747c,
+            0x1cd8be04f1ac72a0b7daaef83a36e688046a41b7d4ba83aa5ef3a3a4de8e58a5,
+            0x1a31f69bd76c670a3183335cf97746f6676698514467df13194007eaf8ed8b8c,
+            0x2ab2c3d35698ec035746c4131c8d4cdae3be77eac56e708b6fb6a9832afb3869,
+            0x2217b8cac3e14934002e24683cb6fb96da2b282d12447fb97789670e716b3bb9,
+            0x26d8ecc33cf52610b26d55145f298e5a387c1b4587d44bc89afd2ca81a21cb70,
+            0x19b5fef4d9456e93fe0799c1b568e2f6deaf43067e119ee89cce7b1b0074e8a7,
+            0x2f0ee317d5a1d6c6d6c8b01f100eaf5389bffe269131af9eff36f71b3cb7f4ba,
+            0x1009a43a6a00db52b2d0e325312220738c996b79414b70b2d04f61bf8475759b,
+            0x2881d241ad316ea5b04bb05c86484922c0b6c6f01173a1e84af83d8b69bd23d2,
+            0xa3aa81c611a57f509b1f971352d680f75a03361e74a5c12594987287972c39b,
+            0xbf1eb01ab9b46638fe9d0a135105ed65848bdd9929b93d37369240a6e5ac276,
+            0x1666fad124b64cb1b1fbcc06ee6180e2d3d98bdff534ea0d4fffad2413b15925,
+            0x13006947e1defbcba51ece18add637d08c38b973232ecc68b6b2f7fcc0e40f7e,
+            0x20cef2fdcdcbf581527d5fdd9442d7d80e8c122c60aba74a349e318119a9b077,
+            0x29308abcbb8c3d71812419611e6e3f30b64b8b3670579e5f7e6084c57f8180dc,
+            0x20a651bd8eff8989f70625f7e1db0da19b408d63385e63f8b1f066d0c3912e0e,
+            0x2fe8775003759af3f41c2f923f0b683c27cf89bfa609ec6fc26714b8fd7c5ea7,
+            0x226d37fdd9023563a4d6e2a3bbcd23137d949f36b2d9b1b8dbafbc644ff2371d,
+            0x2f11eaf353125b5b7110a75fde384c14365c2e2cbb1140f8b520204118ce6897,
+            0x7cba6d14f09fa2eeec2242ee401fe0fa089c28bc77f02f0aa90a564c10b4e29,
+            0x757d39b861897f4ca863713452abb9e6c14f8736417fce8359c5b4dac5be0b2,
+            0x58992f42ff62ae08b3daca79a5ac83d258272802dc6556aa757b390ab22d6cc,
+            0x1fa470cc67647213df51fc636fce6b6e69de3a665044696f6bda9316fadb5a1f,
+            0x11049230da628e01b2a11af1b214327c58092bde0d949e8c08a0c929b39a13c8,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x29e2fa62bb11282bff23cddfbd44a2d9fca9bb0ca099f34c63153d32257e8f76,
+            0x2ec58445b13f4e1b14d47aaa8d3c01489e81838dcf6a8fb2e79ae1c420dbac0a,
+            0x2a26d88da92db338a1de3d64aa9f78389c45cad24daeea74fca5c5721cf0b079,
+            0x25240495a831b1128568257ef0c438a227576328351ef52cc3f6a361ad097666,
+            0x10356b86c6b5b46fd0913fe632fef7bcb9507005df6fe46be9089f96008fceb1,
+            0x23967538833c9bf2f3a2387251089e68c81a47051f8c3154b5863fe78a6ff6f6,
+            0x3dcf91d2608f94783343c6c1c9cd24847ab2cd6778f568418527be40ac23e89,
+            0x1185195857959b965104d24285d2f83365412ce31a6abcfc936d74af9fb8fa13,
+            0x14ef1e17d68e5cbcc3a90ead42b8c438fb56b5fbb950d8883c2d1660fb2d1ded,
+            0x1175100c6ed2ddf68ba552b4f40c27047fe02cdd2b533a3b9975454399294205,
+            0x230160f538e3585cff4bd3cf7b4fe333d2b2a35738fb135ae6dadc075f92ada5,
+            0x88c4e4fc1b21270a933a937f739bbc7b6e7eb3e316ca1b3ebe5727e381742eb,
+            0xe3e345debdf5cfbd7bb9a4cb5d36d89c20713e43323d4341795448aabbd76a3,
+            0x1a4ed87c8037af1d025638bde6b974caa276671abbaf0210cc7e9db2fdc9a345,
+            0x11ed48467664df00548f3cfc70eed4039f6a59e826e73dc4b95990c03a313829,
+            0x18ed0bcc41aa34c5556a7ebdf27ccf1a50f32561793053215a03d931c4f72eb0,
+            0x2e73e5ff39e58205a16e013ccd0dd935bebf06505cdcd650935840062e8b1f8a,
+            0xf66bc73e8a87b0b028720dc420534528d2fe5609bcb3d600507a6c19d20cd59,
+            0xbc095405abc012247bc4a7277cf59e25e39834bd5839542cab959ad534a23f1,
+            0x1fc384fdb89e274dad330eef9dc51855c11fdadb0b9b052fa220eb3e38d61254,
+            0x2805a26d24644536da5f7e9f5071443189a5f102b92613098a8c23dbe887cee0,
+            0x2a2eab082079c60e24bb5dbe3549bf6390708e8ccd034a2a94a71aa9c414cfa1,
+            0x5aa87bc4fe90cd48a59fcfa82226cf759ce8f60f8c208cf9632a28ff7b680ed,
+            0x2038aefd81a73ef09b7d0fd466d2b3c8aed99ad9ce559eb2aa80d7e06996909f,
+            0xfaf97c7bbde99e8853c67af9e2187b8ee3708e48da3446b3eac3b3252a057d4,
+            0x5dd570bb1e0feb5e6f13b9dbeae629f6f3ad06a365d9ebcbd2c120c6f76deea,
+            0x124548796b8905caf386a61bc868d1467251cb29948ff1f3ae4847c724ab97dd,
+            0xdf9dc278a65d06f8c477dcb8b562c262dcb7f9ca4d875070b36e9c2e7fcf277,
+            0x725e0e87db61e62269f56d25955fcfea65fd3882320ba3187611e7bca42c2e5,
+            0x2f204d469d9ae7b364fc44f2959956654f613f60cf669afe7b69a944b6903390,
+            0xf4165ffb8c3cd0c8df2a1cdcc6d99d487b204cea36ba8023e6a17c90c50d3cb,
+            0x1ab6363cc8e8594caf364c93385aab21b86de4aea09591b34df2152f6b663079,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x273626b708fec9b5d1d1330bcbb2d80d97ac1c84b89895de0628a0f15fa73ac1,
+            0x232c260995bc29571e821068a7fef290fc1fca974214b45cb6eb63c02f56101c,
+            0x22a91317e4cd0f048e756b7b41c10a9a10f85683df9051b1aac41cfb73dfa959,
+            0x1789ef31e5469c8fa9e265becaf3f6f0b66989dfdddfc52491933f990624062b,
+            0x27502f81423df0f6f223bfcb038b0347be96880b4d9b26d685bc87df88a12f80,
+            0x15944d6894aed7bdec1cebe81ea14066dc63e49db38b79b63b5711cdea0047de,
+            0x2d5d79c75632ff589cea134763ba602c43390e05fcb6ff8e91fe8376c327cfe,
+            0x1f83f223b3a559ac092b5ce1bfe95f81be64ed69bd2aba06181f9962c09ce680,
+            0x1d9105ddf213b013cfd5589de071e9a19becac29cbd9f5699314f7163f14f642,
+            0x2d8879a2f005d4829b5439aa1630fe03cb581dd32be37ec112cbc8fb76715870,
+            0x898f42d31a6838f40ddf7874dd4afce3481b6e1eda04c4f22f82e3a7c339078,
+            0x1e5273fcce91ec174a392d2b384eaeeb2856c1bdb4342e1a38976f97497e51ba,
+            0x24a863988061d2464b7bcc8d4ed630e79a471fe07c829d9d6b5eccdee1740779,
+            0xd3f2af2fde3dc00461fe65fc25d8ef32db567495a78776f0f4eac20d4c23222,
+            0x11130f82fe058dbf04d8ea6be3175f22ecfef9c4983545870967c73267e0dd64,
+            0xf327ffc10a298ab4376b35f28b7eb90e794b6c9617b9a9cb1fd60d1e6208fc1,
+            0x2fc6a08cdc07224db9ed85c48555e9b6747d401fc30b477a376470a19189428d,
+            0x1c33ad6d01026a48305011699dcd1ca89d10a95b096e2b7d60363374c038c62e,
+            0x1e5457fba2d9da56d4ebe957e2a4960a45ce9bb8c941e2b1bcb861f1c1d88bfa,
+            0x29d2839ebf586fac7dd395ce00036e0530bcfaf01c6619489494f78a6f7d5ec4,
+            0x4d8bcbbde662005d7bd4ff16ef911dd1fd74e44d850f665faffe0d4724063e1,
+            0x1f110564e1708c2705cbd95f592a618406fa8ccbcebfe3b4fa9420636764c7b8,
+            0x1588d891ff3d8526d281bfb900ea2b4de960a5d2b3740c2562f6a8ed53f374b3,
+            0x639f2677710d59d2708e3ed851a80e7133f603ae0276ec542b23181fff30907,
+            0x2a2e29702f1ec78a47401585569f7b48e63e397bd64ddbef59fface62fb5591e,
+            0x172b91ef6574d5d044f3e03e69e270257e80c9cd0f1000cb91d7a718971dddc6,
+            0x93f4d3b969bbc023ba1de485797a6ecfc42e2e9f034ead04b17830f297c15f3,
+            0x1eb585e563cd03b430e0947955e5b906db9b169af33cef14671865a04bbdc7c,
+            0x15167514d32350029469eb274806d81d6ba80981c4694fd030f0bd93c8ffcf31,
+            0x1240581c6c08675773597b9d50b9187f160fa7d7a739630f943e4df9b1801237,
+            0x1598daab9828ae0f9490eeba9d3dbd6282a2490db8ec4789605289a3109a3079,
+            0x15f48fc5ee41eb8cb97fee7e78b55d3fda674fedaea91534bb506a4b440ea560,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x6b19393be5286a5cad14b6fd12c51219467aa1dc7c4923753e7b1adeeb464f,
+            0x12ab8709e0b7289c712a002a6f0bfe6e72844177720a0427631540c7695e0905,
+            0x145662a0788a01d81bbc0df72d6eaf0e887d22a1e4aeac090900c432c4132fa5,
+            0x1d403655755dcc00c298137bc7e029f140b9d9e71d30e9145f6dd2a040febb9b,
+            0x2370434b953dd1d26c4eeed6cae501a3758014dbad14bfef1c3d26cd0f615837,
+            0x1f13968a23ad91e74be05489afc4b2dcb41621f6fb8b52f73c27bc2f64d198ef,
+            0x3012f6382c1bffa9df0240a0f66b310a7463e49e7cf74facc054c7fd124e20c8,
+            0x1da5c938033392ffec34887bfb06e6317655c3094671a68247eafa70d630c144,
+            0x1a94414d237c4ad29cdef25e46f49e5e939d9699e9a36824f51aa65ff2adcb04,
+            0xa234e79999d9f55a21dc03c43eaf5e018035d2b588d5ec8cd2d1df72f83cd87,
+            0x9f0c86d7cf4004d071e067316a8da875d4405044b0e799616e22c96a1140c26,
+            0x11bdf8824a0955d04b5fc96abac08049c0fa9cd678bf055fec2d43634170f052,
+            0x20e74a475a9faf92f4998eb559ba0d8f05659dde0ecb757950e8a6abf015d4b5,
+            0x1366321b06c12b977c2c396974a2a6b0c4e58f09a53531213c6206d072f4d074,
+            0x1b2b47e3ea9a39df6a054879cee1ffd2cfd789acd7823e765c675241c3acf498,
+            0x1e94a144e18eafc014b1aac9157ec2faa99affa50a05f8a8ae8ecb152bdb85ca,
+            0x2fc95ebe62bfd5cff9fa2464bfc67b854ab2aae650da63c494d87294735305a8,
+            0x1ccaf110504e1fd4eec6cab1d20f863feff3910d832fb789ec7e31713d262bdb,
+            0x151066f81bfe7b4f1ecd0f7a8fe09a48ed40b0c9450476042bc4303602891d0d,
+            0x22f0502a277cf27f336d9f3ee1fb7d67fa355a2421d4a01d121f1020e44ae43b,
+            0x234465d17d5ca11607fb6b7f3ed5d52d0c06dab7b1761356cbbf0227b5777de,
+            0xee0c8ce14909dc5d73607dba19e39706783488f00b8cac649546d934dbeaa54,
+            0xc1a12f8f600bcd0dd2963fcfb7172d5842b12aff081a8163fccf1eaec3284e,
+            0x27813f720b7a7fee3b44b2fbf89888c664d960bfcd775816ceb70050e6d26308,
+            0xef129ae227544508104a79cdd0fbb9e8247c352c97190b90b5e5892feb828ae,
+            0x1c59bcacb92f3012c6299cc6b43ba9269481cd107c161406349db4f728bfe66,
+            0x8944ab7daebb6884078a8d618105b8843503a90ba51855c079b13b6aaf5b4f6,
+            0x215bf9136c8b81f9bd5b221d37fd0fa327f923dac9d52ba825cbd3d2d62459fd,
+            0xea608a14f0b4b405017fa637237863552a98cbb9bc1e151b7edbe8e6d78b598,
+            0xc1aad9a675df88deccc3864f8c6e16cbee74db5441a6fff425a2bf2a6f84d67,
+            0x243e3a95bad03705f35109af4c8c377983f06fef4cadd95c03833dc06ea51296,
+            0x29afdf61d86b2558a0cf6083069157e5039ad172997c8ae76857f73e05ca3eae,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1a85e806efde07a54e9cc83eac927ee5f534b01fd41388f806298b28501a5f04,
+            0x109d8bbad7c3c77bab1a8506d4d588e7f5b703361a6ce70d47478e7464a73574,
+            0x12f04b1f932511c8596a8c3b5f3dbf1f7f1d91554020fc43db068d95b8e6168b,
+            0x1f28636d87164d2217fb393b23d0bfbfec1d912dca3fc000ba1f3e2ef46b8b21,
+            0x16179a1cfaa92c905e039047db38e288d336b355029b1ce1048168e55bc1d701,
+            0x16c3deac1173e14fc8b54c4da1b1ff61b7bc4ee2b9c62c2871d70a14583432e0,
+            0x176d6148624c45e210837dd7fd87d4dc9e89f8efa4dea7c3cff0702fc2bf042f,
+            0x20dbb69374e977536f1cdc4a084edeef4ebbf0c9c3cc4191fc4a707961fa39cf,
+            0x2bab10e7b585d418399454c7d80fd38bb23190eecc5f85f410d85300487b9ee9,
+            0x1bdb9ff621833468a0476986be6d6d719779ec581cc283a11aaa42c5111d232a,
+            0x6660bc2be087e505eed7f1d4e5d8418d55e799008cdd4f91bfd536900e9f7b3,
+            0xd4beae63787b3447f813f245fd8b7d6f49c83d63fe74a400dcd66cb3d363af5,
+            0x1d76613f447ed37b64000a928b3b48e2e8dd521aae874d97dad7fe9b4c57886c,
+            0x1f84a0ec9dadcd3937a045561b6205385c12c2ea4c562bd420f3d27ce32677e6,
+            0x1f6424f12e6950564745b305080c881ea931d9083649631687a5a302f1d86fd4,
+            0x2bf626dec6b3c130ebf137a656988397de0601250e39822152d316537a891fde,
+            0x134731482b66f87776639ae513fa3245540fa1d34e6d74d32f7e9587b851de32,
+            0xcc894c9be43663bde1317a4e3591aff66c18abdf0d8b90d872d86012e2fc8bd,
+            0x22e690f84991940125c64d8513be14cd3fa81c1efc12bb80a6beada80c7091e1,
+            0x14287659216a6cb96496ea198bfae1408696c5561f01e9504d5904044d9cc1ee,
+            0x237b66703bb797da48e0c64dd6633de18ec506dec2d4d72b28fe93aba30b1621,
+            0x1eb201c3e2663322f85acc8d641a362ac1eb1dab575d105af0feac86d68ebb14,
+            0xf2588703431e1b9b0d059f900572f8222df5e7749dc0f93c09a24285fd53e4d,
+            0x18a8905e765a49b51060ddc06eacbfbfbfcc0736f621216de0f9a1a11cc66484,
+            0x10e1e120dbf75198c342b585b49bd0999633fd5310840e725642ae873af4a53f,
+            0xe65310148d5dc0fb00fc135ad071d9b07e28b32dff7dd8fb1a2e0670238de99,
+            0x1b924a6cd822b0eb0c6227c810a51c540fe9d9d07f906e24a57ec6fece7639e3,
+            0x14f708f7a7c1430e9f6adf3a23f1dc38c92ae2f175b39671aa297d590f7806bb,
+            0x2c870cd5699f7a402a473b3610adc0b1b1dfba1798b30681de9359334891b5d1,
+            0x2c2793cd489f2a0ba8efdda84b35034f81bc47c131a3c6b6f8107f7cbc5ab058,
+            0xf12b486f743b8613685af0b508c3b3c41608d34b82c7dc3d8f15277e31842b6,
+            0xea23cccde8252adc358410548ba3c53e224a3169e6ca958458940f318bbefa3,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1e5a6dba6fde6063136d0d97f46d5f292f065b8a9db8f2ab07bc17d31566ca3b,
+            0x2f5bb6281fb3085c9cf508288a809476a23c142a459949254f99e0461496897c,
+            0x230133fa9c214b6cd63701c3a082ee211c2d4ffa7037d0d0a4cb63a77ef5b696,
+            0x7b9beb8ce1dd13c153d36b636a7af56db3800d97c16400284b5563b192c7803,
+            0x18a62bd663f364bfd0c79d7f3edbbaab5f58eaa44c0fc207291c8f71222059d3,
+            0x909d7276a02aac190974de34558921d3dc8e6ce22964f0e97b69858bbf39108,
+            0x191ce266e49cadd50eb403e7fad07cc9ced8d81d8d23df3dc653cc69a8e62310,
+            0x29cd029dbaf281a5b72c6d730674b53cbc773dfb542428d45a11d443aee0c906,
+            0x1235f2e3aa2a5663b1dc32d86d32a8e2ddcbde4e97a3edd894c7cf2f799e545c,
+            0x11310308464e805034d840a94d25a3b8bd0c206d663f41d145fa66415c2dbc12,
+            0x2007f67c3b1d638da29631206a6befa6e21365aa1edb39a6f3a0abfe94fd2392,
+            0x121d527f117db7b0a614ad1be6fea1f84369a4c6e451c0d5d2537983fb6b913,
+            0x1ca4a6c7ee32ae8f3d55e7b5f8753ffddcbc125e170dc7b7c8ba2d62701aeb80,
+            0x2f4ff9505df9f5dc0ee5584631e6f331213d654435b5d2593d249b3ff4e64802,
+            0x186af707cd1927045cb8ad1b1510d4150928d839d07c8c9a3d93411262351327,
+            0x291caa38b2e4083119c579ad08328807d4ace7deb24f78a5d4d208cce95055a3,
+            0x27e62d562d2936ef5dfd0aaee64cb42d6aa90006a6fa74a7ccee794d78c0faab,
+            0x2706ec2021ef6f28fccac547cfb1aab2da02f453dac5b2daf393ac9bbfa63444,
+            0x2c6c0b69710326e4bf73840601626d94cae75c92ca37aa5b5c6e61706cde5a5b,
+            0x3bc51987425528eee7a4a3177a8ee4571ccbd028c70ada4bbb3f8e6da3f58eb,
+            0x1273940d422f16d7b918e5b6bc3dfdba2b22abb42cd67aa154ed75496186025,
+            0x253094fbc334240ab67c86378c9d8d7435f3d87d5d68f3ae901fad214e0dac85,
+            0x1cda718ea0bd4ae40920c54c9d203f88deef3e00b3a6c3a5bc9243957c20133a,
+            0x125308584766a4ec9815951c72a099b9ef423fab29783c9c8f8ba14ef8221ecc,
+            0x130af16ef6729327847344cdc8439079d47871751ed3f0b871dc248c6b856b44,
+            0x2f730d5dbd23018d8c91be93b9e666cfa9e9c077d3b2724c43a16092170d7040,
+            0x278ad27534ef1afa5d3742e03bfbec8156aa660b0d663b054a5feff049aea2c8,
+            0x6d35c831095f5def4afec1841c74aaf1b18880eaab4256ddba34e49653c6169,
+            0x2a9eb03bb2a3ad110273c506031de6f432b6673655255c4189fd2db2d9956d24,
+            0x237bad6e8955fe0485f4f72b4024855f35903b6d795cffd27468a7bd0e47056b,
+            0xee091319736fcc0a648bc6cb1b31ee36b95b20c4d40f91392c315e5fcf26150,
+            0x40a730f39a665fd9cb0c93989b291d281958057e9b898d0b50c752f9371a96c,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x30478f2543e91a3b1c9b3fac23fc86c06032ca0fca4bee9387722862c449cfc,
+            0x41b7accd8054a88f4ed64394473fba2b13d9b9ea06fccd0f75439c8a09f968f,
+            0x11bcaaccaa00dc4c80c43172a833a6fa50fa47827b3d4df0c221eedcb7e935ba,
+            0x1276b1ec4d51cf23c53b104a7d1e127058b91f5a4cd2bfea420c15355b43553,
+            0x144dc8dfbc21918abb47ec061c7e6a2f7fa9b32babf270047a2f465b7f8f6de5,
+            0x1dd046beaf1e8476308af0089af19da322852346b18ffa584af9d98619dc8f53,
+            0xfa7e283d56ded23e03a16d79c94298143d259d8c53c8e0de261d197a4a1c071,
+            0x2e1a819abacfadb55e98efdbc5bcb57e216fa7ed9d60a4ed920b2a1de8fd1316,
+            0x256938ee3b182642f778f742bc3bc00a60aaa25bb3ce9f7fc96559cf21b28570,
+            0xe6a334e357792b5182d8b44d893ce322996913cab640a006c1a8b73c023284f,
+            0x24073e4154b684459e0cbea690ef583feef556f092b2b17c82c31776725da906,
+            0x2dfbe4b1760808ac37902dfb1e18691901b413b87c6d8c8ae54d79894ded6c80,
+            0x20f447f6a67d3b8929e1efdde6688fa53d47964873d86ea01126f1e0d447d951,
+            0x2c502b5ab202577f015431cc2b64b61f85f486161ac4ecd64c9603fe6d353d01,
+            0x5caa2b6ed2b850a5ebcc686b7198604941d48d30932a09e2de9006ffa61afb7,
+            0xa3d02ec260b02ef2a4d51c2979cc1b22cda27b543a1bad75d9e547b3a5c751d,
+            0x724bf5486c9bd20c2427fbc1d6936ea65d052f442a417215cd089b9e4537843,
+            0x1ea84269caab7c273d92e86ca287a8850995c9adf2624daa858932665fed66ea,
+            0x1d7e6d3695ae5003b9dc6950af38af6b5319cf529a7a1d5076512dfd92b099ef,
+            0x99642d891092eaa8df1bfbc45d79b13934c42f37f8e1dc969fd51caea4fc246,
+            0xb94bf0fd8f907040c14c1fc8aa290aea61fc881aa82da20ae568c34990fc705,
+            0x28fb0d75533a8263ef2ec6b85c97b5af21e526471056355253fc5f6fd3361375,
+            0x10480841e4451bf366c111c8d3fdbf0a7ac9c04b9aa2d8d547285dd891e77eb1,
+            0x112274c48dece347a089aec971f0cfb9d7bb1a15b32ad3678e77d15cf7107ff6,
+            0x1a8c6d411ddc6e2dedd2fac64c324d88ab8a946fef1174c973dc0f658275f5e,
+            0xd0a4a998536c490396be874d02c03de56bcafa3cf45590184f7b53ef5c3cd87,
+            0x22016b957df82fa5c825f4fb8fcf8634e654988b63d9f9933bc7b7f256e7c67,
+            0x26d2a9b0db83259f6c7d081a2d50317039076baf6151f1734883fa6c322b243,
+            0x1593b4f33dd3053258dbea8117f435f21d6876e7fd2907e98bd81d13e1f8aefe,
+            0x1ec80ad7ee2b685fd79b38b842b0d420b685e3c090acf3e7507a57739ff76185,
+            0x10573113bb0d41c18513cef083fbba91266dfa7178674888ace5d566e1308eee,
+            0x2c5bca238c2c3be6d5cf5971ee92ef3174d4a040ddd6b0431354ce434de989b4,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2f77238c057e187797950c50dacd539a7b7a1be7baa3a3f3a617f88ec05513c1,
+            0x1e4b327ddf07cc065b37a9af7f6d97b89c40479908be61b2e6312c351a4d5ef7,
+            0x1fa0048409da60cdb12a2a3013fb60257940ee5f4f8c2b1bb56362e121b0c8a5,
+            0x1c92ce2c35358268ac56a756f5ca943b43db8c7ec965770da62b649c45baf1b8,
+            0x25a62912bc39aacc66055eb6cb404b6a4f09b703a344b752c526dcb93e768c73,
+            0x2f3e3c91be6f5b034b00dafa6fdb33ed00735f48fb2300a783ab3307a6aac793,
+            0x12618073f72606525b743e3ab8c2749bc83ebc31cd47ecff2f851adeb397b5f8,
+            0x7e1a14a5fe9a127930b1ee9a4bbbaf3b33ecc0c23d7b3b906f59925c0670f85,
+            0x185866c20721e1018a4eaf241031b69ed1f2aa25e05310a44a015aed45003576,
+            0x1845f9656990a68b36e47e83b67e6d53f42df6a83cba95b016c349ff191ddbc1,
+            0x285db5bd04516aa0416c2c52cc651c2690bc846621ddec2ff3037165c30444b1,
+            0x230697cd1a79c303489232f2d060182c4101e0fb4b6d3ac38b82a370d59ca295,
+            0x2d5d42436b19bd4916f035f323d6acddae9a252ebc7445adb1d7bf560b464bff,
+            0x1ef94358c904246669907524ba5bffbdbd7c9a5afcf160e44d00f19cd804fd87,
+            0xdc902c1c2f63aaebc2a69edb37331ca6c053513f29991bfcaf6dbf9cda9f8af,
+            0x38cfec7101b2ee954fa5bd1156da5c5662bc77e2b4e16d39139bbf165f5e331,
+            0x23940e1b0657dba41ee3c7edbe86d7ef9f3a45016a61c2dcdc39f0321af50fa2,
+            0x300efb612aa09a721c8feb5775c639204c092bf5adbf9d4268dd3f24a406e969,
+            0x1cdaab41d8141524f40389418576088f7c8aba62feb69e895d39843068dd5679,
+            0x1f035b6f957e84c1eaeec71e31b19518f3dec9964753a2caa1a33ba14879d0e4,
+            0x9ff1b666e47a433088329f94545bc44a179ff61e7988ec8c86715cdd25237fb,
+            0x97ad004ad339a6ab46f92a80e303e5d431fcd77b46a5b4435f383af68f7d08,
+            0x2189b934e1602af6e30d786a0e283f0877720cb8fe77369c37f7ac895886dc1e,
+            0x1903bcde38ddde14e22209d72837f9b813e437099f71263f84e18bc6414ee74,
+            0x81887e6be9c14e1b9ded51e9cdbfeba2001c9e6098d6ece905a0fcea98f6452,
+            0x26c7af1f1cee86563e9292336fb6573a0970af2c6d49d469b682188ad55561ad,
+            0x243e21405367c02b78c9da82c9102df9c32a26dea21da00beb62ca9e4e71fec5,
+            0x16e3e6bb95f28d2f321e7b63f6acddf3dd6c2e9a05aef8ba4b9151b1de10a78a,
+            0xb011142c18c2fd3740c07513612794c14506ad3094f440420d5265f225a84f4,
+            0x836b51afd8ef110a57d3d82bcb1c294a3d0c942ac20f6f407cb20ae9f0addc3,
+            0x1ef12a547707d7dd27529e8675e5e58c3f35bd50de464d5e9b1735ab22d95565,
+            0x12f1b456a3fcabb116586107e089ccb38b8ea0ac2fde6f6d464302c5f62c5776,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x16e23bc3ba612e8d4104a5a608cce0d28bf3a06c6f9024f8f829edd7c84ff5e1,
+            0xd4acfcea237e44009b358d998961b4719fe512aa2cdd6438aa30dd5baa6dab0,
+            0x93cad17aaed41e759cfeb15461f0222addf78c3a0aedea7186431c535ed46fc,
+            0x25e68166acd241fc301db582f896b8e314e398dad56de9f2926f9f131a81d5c0,
+            0x8d9b1a38c7c71b2fd5dac87ef974ddb4f7119523d81f88b0d7e16d577db060c,
+            0x150c5bf06a071be6de288b6deb00b6ee51ee41f96f71cdcc980a366e4049580d,
+            0x1820e0533ea75404ef263e570250e25f9c0bea1228df9fa90a5da8176154f089,
+            0x229fc7b637cf8316edc29145ed5f060a9188f10f71e078dbcb887d195e8da899,
+            0x1cc5470c6bd5d73eee63996481a28466499751a0a9c784abdb1c3fefe643dd81,
+            0xc4da78b5310d04853242a11df821ba84860fac1a2fee9fc04e25c6039bee8f4,
+            0x94cc155e114ff824b23e67ebb28b2bda53aa526fd3f11927db7060ededd2bc1,
+            0xdd872678b808e11045a657250172181e1fc7d9e2eabf893f09fc3c6be3a93c8,
+            0x2177c7830ac6b2cb6d01ead266a371320f7069a0de0454e5dd3a2566ff9eb716,
+            0x232dd9ffd97dd5068b1041fe3ed6e08e162265e9e814b85116a6561430aaf72e,
+            0x87726ff3cabb6294d2106931b3160809d4d1e669ed7de25374390af8ca39b4f,
+            0x364f607b21cfb12929ecdd65f7618ef65c8e9caacc4f42c440994d8b5dcd35b,
+            0x304b195fa0bffadcbb23ae2267693c7da7607eaaf40c880843ba71521edeeb40,
+            0x196610368a8764fcf4f0278601232bc0a5aa7ba6d20e2c5420a7862272b06749,
+            0x218f52826b8e2b82e86d87d7bc87fe5cc69171430488282062d7008069c89dde,
+            0x2a70f39b2d8cf212fe706545d1cc154d07405c1417712b388c919b35263c1343,
+            0x65be4ea4d6caa4125badaf16b830538527414ecd718a923c3417c474fcf5032,
+            0x527abf8fa6b64559c86b69eebb3f0acd94c9f23a01438ff78f034c80291d964,
+            0x263078abe4570cb96d27cea17fe9b493fadb3a020605cc474be08ad173dd424e,
+            0x2616b2e0a8970da8019208335d4cccaa489c6cb8da6a862f1867e246e1f36736,
+            0x255f2df1f986f154768f0fc8a5a2ced1f18d395ff01165e77d6cbda3e8b7bbd9,
+            0x1806ff1795d9d6c9292f980c957038acfa02ac32556c9ab826bc14a968dacc80,
+            0x871baf013f2fb16c067858844cd395a520d8a8bb17abe207d3138bd591dcfbe,
+            0x28f0493d5c747880a71a82644c20dc23cd3bdf84e05cbe0c0a1a48fa27312484,
+            0x2a45ef02fe1dd41641c787b8611113bec4881a56784fcfa21bd896a8205798fb,
+            0x7ed262400e2c66934b968e3f8713d66e85fae72ab73c6cd33eaf5b2b480f6ce,
+            0x17984162d397a2b3b3bf3bb04af70532c4beae81a076d0b8e1b4c54e5feb2f7c,
+            0x296ee291fc63605db9594241dfeb6576603a30c42d6d631d4123982adbf54cea,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x19933fc7d1aea36ed4516ea4768628c08d206e8cae12e53a61147f2301df7c31,
+            0x2efd792c56ad19032f4e2307f7ee338895556de653bcf50239f56a6f595a59e3,
+            0xd6c9475058e6029ca3162b0db37e71ca570a626e7812f8938db5bb9f54f352c,
+            0x2d6e38ed12eda3856592e0348ccb4fad2477619bc8a37237d4e48a8b12d0d7e5,
+            0x1b22798bb6b6e5711236933e2596905ec1a4eaf3c224cb8e18385857df475aea,
+            0xee2bfadc6c771b8279d82f54770acab798e5d7e6b6c93123cd6d871ac0f9cb2,
+            0x21dc8e7e1951b62eaca40550618cef0d32ff82f425264dff2743e287594d7d54,
+            0x1e75bf782b602b28cb11f489a17ab323dfe881a7654af175cfabadf765d2b48e,
+            0x2c49b7045f45347ea8498df2f5d5eb560154f3579016772dc017f6d43cfa563e,
+            0x1a0ac37735eabe257b9c0c25c0e8ced477833e2368678c6449c1aa4baf0f2312,
+            0x1f35e213914c01a5ebeb34838610578a4fba2c4a06d248e0d6b76212ef339560,
+            0x236ab082f2cbd2668f53ed5a9ac5f29822440e4b06543b6ff3944739edb00a52,
+            0x12261534f09c4b4f143717ec4e8b0afe58fc399671ff29f5fc8c3dd302eb70ee,
+            0x1421d8d32235caeb8e90379b3abacea1d7ce42bb1ae928840a8739d85acb3127,
+            0xd330afe8be63d8ace3a3a83b7da18804912e3b3c1a8ab3e556b3256f0c551c9,
+            0x1563b55edf443890c4729a6c84d523e1133d54bec37000b9afda8ec393c0d2fd,
+            0x2f6aaca00913c8a056867f42f64016d72982e3eddd62f7508c4b86651d2fc253,
+            0x2f31927a218ce8d5931907542909a9a8a424857218573585e1a11aac34a4ac59,
+            0x2245d56c69c9bcbe47ee570fa2cae8008a8bc3042410d29f84cf65adfb1d65f6,
+            0xa6d1a50326bf87096bcfb5acfc3a84bdf112eff86b9fd10e935b3ea5cfe52f2,
+            0xdca2fcb2fca35419f3ad6737417350e4fe4b3428e65d4f418143b97204355bb,
+            0xeff0d35806c692f93f365c7ce6d5489b513aca79eca0a6663e9bbd8820f568c,
+            0x761a1a536cf23aa1f57a5a10140d4b1cb968e9e3054833cd33b769db1cdd0ab,
+            0x4fe0a5f272499e111984cb95f691ad3533008ae70634baef9e60bb0808feec3,
+            0xe5e1a69a0f2521a67cbaa96783214399818adcf5104c8da98d45f3951df3d79,
+            0x3042f99a1751ea962828ad563e8a6d6dc438459f9b912b3b5f2567ae31b74cf5,
+            0x2191f2dd5699e7f46dfc7a0fb01c5abb9a34740c534690ed789a3bedbe15fa65,
+            0x17886ed47f13d1d49c9c24836655683cf481f3e89d2b65b9de78b591a97b87e6,
+            0x1913d17541b234d83fd9f7851782516da4bf4ffe9355c19400adbc995c417fc3,
+            0x271e99ead6dfaff8400e390541cecf5146ae0f3b86d0d94898a77b67d0f59b89,
+            0xb57c116f3a607094ae8b3e7a2b7ef123635bf131089ca8fc8d0264715bb72e1,
+            0x1e097d47d4a82b797a5ab64eecfbc5026ad25c9aab94cbcfbeed04e47aec7e78,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0xeff65c0120d6929212be55e8e6ec2e468d7fddeb7951b01ad014948c174b971,
+            0x2a5c1de1bf17f1fbb34987d445e22e3bda9510062ee81821d20944df27d1d6f1,
+            0x106178470931e69d02288fd73abee97994704d2cf4c2142498fdb2487afffc91,
+            0x1f2d17deb1a25ec04570838e8f5caa47250c1bc16c0406017f5b2afb2b2c8b4f,
+            0x1ded3f9efde2ddbca11e2280038ded37eaf9a4542c959d9ea7edb29557118c00,
+            0x132611d30c21b4909aa39e4331d2fe2a1f532198f34588e67dc92a375b1d95bd,
+            0x2f5741043ed87b7272c7a0db20ad4626af621071cd0aa6759fab3518f420e751,
+            0x20749c10519279b7ccb82ddcf1cab67a14b26b3080022997c05ceb47da0211e0,
+            0x2f4b12cbeffe89cc8e0eb8fcce01ad903d14750534b107d1a5095b53f2eb994c,
+            0x19f437a4cf9d69d918e2bd2c1ace4309e128fb911926c4396039790db1677211,
+            0x2189142b8e8e62d3eabad7d3a9c92a2ffc07677dbb3927a55035436a4fe99084,
+            0x26deb902804c50f44397613473add31799f85b20d1232ccdc220357e87e0444b,
+            0x60feb6d13dc7538cdea6274969507ba784301ea76cef8af0eb914ab2339be82,
+            0x76ef42dd0bb069840f761558e2005af793ea5beac349c3dfb9e610933b1728d,
+            0x21718df0edbd2d21670fa990fc293f89f53cb169739bf7cd2b732967fd4e936b,
+            0x21e9e1015d05a67cb7a314fdecdd1dac563dbee2b9edab3388ec4ef9e58eeb22,
+            0x5fc174109c8e7779d39321d9b843cdfc1e0d89d8806e199e15edf3cbd724f8e,
+            0x96aa7b7315c181d4bb6527c1abe5d758908a11d1443ee30c0706b31bb43da3f,
+            0x100171ff805f808f17a40a9e80b4f6516ba5d39cae9cf62919e085edcb46e0d2,
+            0x28a6f6698a4d25726a7e7bcb50264b66a9f377f6dd42e9affc077b5bee5680ac,
+            0x2be4c72e7f354219484f1f1873eb38a8aca5924509c892c1fd072241d02cc624,
+            0x120e09a9b5ba1d13db63a4d011a2ff38845564e057c641657ec24bf5ce8e532f,
+            0x26c044b1e72e2ed87e620c3010acf302d6f19cb8d4d5c8554931d2e29a923da9,
+            0x1621a950244b5d32dae27f189970ae10d14f0803d92f67d8912eb7588469471e,
+            0x5065df755c536ba54bcc816f308c2e341f05d16254116d0e29bac9cd827250c,
+            0x18165ae1001648c8d9987e38bff84bafed3414ba2dc09eb937b73a1e636f43c7,
+            0x2e84dd68cccd069cad6fee65deb27c501b2a0a8c75fa6b012b6451977a1cfd14,
+            0x29868ed0bed932d2ae0f4ef731251a4ae59470cce43250be9f7fd55c543ce635,
+            0x296b41ce4bc8cdd06eef0021c564646332bbed4a8cd4216effa4a09a015b1e22,
+            0x2c1558f35552fb1f9fd96fbfa1cf187ab296c941f0dcf1af18063db872028d57,
+            0x8b1bc5debafe2cc01e92b310a9bd1b62278d9aefaf78a42ce169dbd7ccbc769,
+            0x2c64eb96b29fa0e07efbd86bcdaa1fcfd342ff26fcc11adb163a3e778092fb44,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1942e0e4dc6666d050565e3041b09d79fc20e99b393b2a3c53f67467c3dc9cd1,
+            0x2a61fdc217a0fd51b44cda5669eb8c81b4e4cda33c07d96a3b3abf75bbb593a1,
+            0x27676c9245df29af49d1614b032c86d99dbdfe04e1ae951e91ca88267de9fe59,
+            0x796165a50209865f0c12eb768681ed7107f6e7976c76a36fe196ac36fdbc5b7,
+            0xc3ee0c7cbf8623447c90b90e13d290d313b6d0c466e0c4e1629e54eea175092,
+            0xca789430e09c72971ba49ab8cfbe88c7ee91571c1bdcebdb512adb061597f20,
+            0x55c78ff2ca4e60c8d1fbe3c55b15ecc28f86f30e893fbc001836cc0632c955d,
+            0x1b1ed198ea5aff5e8750e4fdd1b51c9e4db45a651b2d9e1b211acc3b124e31e,
+            0x680a0131921ff15b6f737ed1ef99bbf554e5c41ef4fd6e200bf771134512a94,
+            0x1c04574d4f435df24a38a6afd056c49edd61ce1dcbb160c69c6ab490716f4bd5,
+            0x1f79fb349db705a247e689a2db091244c30680dcbda765fbacf3f36fb7feba36,
+            0x1b6f45bdf0ed13a82c330a5d26eb992dbc9802f11bfc2669e3feef1c310baead,
+            0x1ce38cb2bbdd94c03869f6bd81e5b7a0c359a932b676c0ba6369fc4ee9271584,
+            0x2d918f60f8c7be29a0b6eb2d6c44c56f0cdd865fd8a19ed747f4c83a41a2d29f,
+            0x2b1e6bef26c3c2a5f7ec39c3be4de1c0a5bb8c1dc434570d1cf9811c71c1e2dc,
+            0x18231a4625a11e057412d2789b10144985ad15966fdb26809ab8091b06e3ce3c,
+            0x2ba1777ec04222a9f98dcaba3a5c2023e77a8071a279c726b35482d6347fece1,
+            0x183e2d6301b1e472e01e2360e02bc855b6f1a262a4d03517beca13ac2539fa50,
+            0x4e6c329b88633c6a45be6f77f5a9d0d54eda85a4e015ef7c368bb145c6978eb,
+            0x1f7d2b53a2456c0d398417386d87f4f760fb541cc225d0d84d9d000828b94fee,
+            0x1e7e8f07fc7bd7b462f36924ade2a783ed2ad47f6a7d4a5051b9774d61dc480b,
+            0x8ee6dc4b9baa362c6da82f6c3787aec48eee1f6ed33157d1a9bdff0cab20781,
+            0x1fedf46ce5f0967f0d259a7ae19e5b781a801467ab97ec9b8d50265832471e92,
+            0x610a62079b0c8c00ad3401ad0473fed44dcad28affdde92c74ca927a018403e,
+            0x2f8dcdd501988f6da1f3d80308531ea26ad2eb7017eae7d97e867ccf9e5010d7,
+            0x2bca9ade6aa068f60c0fd6a44e549bfd37df8499a589dbffb64b00d3c48fb730,
+            0x1a145fd2fdce8ce3fd02830d4c4c8a68e315fe92a38fdd0f5ff7a38d698c1c1d,
+            0x3874b554c5bc6c3988b1601616c70756a3f5f9de40edfbfbe0120631da540f0,
+            0x2eb0cb6d015c48ad9d3065a505fd42ad811fb70d9fdb5c2d537843f63b378e8e,
+            0x11454221dfba7bd389e8f03187a0723828428a6bb434c6d7bf20bfe5fd114b83,
+            0x2a10c14110838c69329a80b0b2613bd9943a3ffd25f6a1e951d0a90fed4ea8ff,
+            0x1e52a42d152b85d8a7807288f6f70e69634da7844d995b254f518724e4c3609c,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2d54de07d84381601063b6e9bc507c93cded3cdab6cac3878cdc3c29720278b0,
+            0x2d8d4a2f762f3df73356ba6bede1b007449304d062b2267b388e058c30d321f,
+            0x109f39baaf3fc94e73d04fcc393a6b60af6c6e20d5953ee4a1b572857b4c0e76,
+            0x12d501a7112aeffcc039e330790ffb66ba390d1dde79ab5ffc723f9fbae2875a,
+            0x104a8ca53760ad5d9a630d85bf1d2880fc8e22a97c26864f6597b78ccda8e39a,
+            0x156bf185e618c82fd5622d81779e5538941258d1ea3d26923f59b002ae7f48c5,
+            0x177774923ca426cbb54827e2b0eea99d32c576101bac07394a15d89354e6eddf,
+            0x113a5bceb59274549fc1801d16c19742fc8fc2139fe584c52a7bbba2a329924e,
+            0xc6505ca747cb38e435eed24786617d5bf69034132a74f6464c6e802fa1fabd6,
+            0x118069d4c4bb4779a3c231b4f9bb10c9e51bd7bc57cfcd602ee7a6fc0e1abf95,
+            0x385980d35d14e90d64e9768701ebccc125891654fbb8d6b79a4ea17842a4975,
+            0x1916313365e0bfe0bb7bed5b5f7bd03db314de71ce80422065c503181bb61c2b,
+            0xbf8748279723ba405fc30c18b22b4d1c8bd2ee8a133b73c3e36170fbe2a04ba,
+            0x18e633e3f93f527805cc7bdfa61eab0efc189b556f7c549f1596eab99d2e0e6b,
+            0x152bc76d070352b5e3b4f350f4b07c8cefd23e9fa5c425a8b974d68aa3c07730,
+            0xd27de87e407d89aed983b9db0f81620c9dfe423d47d3de44cfe3b273bc2bf85,
+            0x2b50440572a0892b1c83bdb6fd2037c9ad720f13141798f8857283e01b1290e0,
+            0xb5b0d8f6278e41ff57cbe18be038e3467f1bcc255156a660cfd16aa2ea9ac6a,
+            0x1c4bbc69ba7ce83c1b223dddb0304428eb67dff461b719504d2a55c7bf380a4e,
+            0x224b7d772c7a5d6fde26f2ba95e000eaf6fbcfa50398579c0833093d6ab8d7e6,
+            0x130d060491a6bd90c3e5ee6bcff4181d9126f520c56d7d8233120e8449f0370f,
+            0x26e1f7aaa668655ac3e092b9c8899994ca9e596ba992fa8863b52b3137cda92a,
+            0xd910dfcde2f0b93948f265e861563afd9dd6326cde2a9c9489d22d62dbd3071,
+            0x1a92a6fba93268b439845332988535624c93b616d2e972656ffb15175455e542,
+            0xdb35e6ee7b9752c564e9132696f3052e39a46df1c4823fd05e246e928963d64,
+            0x190484fb8797efff338127ac69877789cb80eaa47f674cae2035e2d903b6dd4b,
+            0x281b15d146c4d56debf9f66bc0c8138b7c5be54cb206a9180987f1104347646c,
+            0x2fa46d89ce68066bf1ab4d304d8d9163c8203f14758eeecbaeec0725cd663813,
+            0x2f2ced28553cd93fd972e231deda1c8b53ec3300e9617dcaad0d2d25f2d61fa,
+            0x2aee5484616632c7511346d4ac900eb5de7a04994eb95b4343d3af1e388fa74b,
+            0x2bc085981337c2500fb80f2259d55e956963ef377ec1e2071c84639a19a581fb,
+            0x232d9177d238a7e2d92ff1260e60e1d1199365f4cd6f911dd08315297bb6c648,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x152e232aa2f0b5ce86a9bb8ec7c916a66ea7d3eced20c3119fa4b32227a44224,
+            0x2d541381556b2db0e934c244bd4f8ebbe198d35bcdfa56c77ad702ce2b4c0c5c,
+            0x2e3dc0bef8262414d80245ceb411511467439879f538701e9ee094f7c14e408,
+            0x16a011d07f05d6aa059d5c39ec295e27d697b94e0eb8ee80d090253627d54ce1,
+            0xf2e71fb8b1efa67f9de9fa1f2a089cf8f1a995bf2efa733b40cc406b6e25cce,
+            0x1231d7777e2dc2538a6a0c854cda59d734f0ce0a877b5271a1d38c67e682068e,
+            0x24d78b8526e7b1c0637f2797968911f101462535e1df4d7a4c151bc6ff2ce040,
+            0x22a988364a2deabc2ce747418dc02fef38ce6c811ee6074febd426aa59e135a4,
+            0x15de00a932e2679f01402db621f4226348b05436f9cf4b4d6d6419e7770d1565,
+            0x299e0373cd69ca5bad2e2ca004ff6dca193a9aa2e0e51de1c89770d2c260e229,
+            0x1f48db87438ef28954de5702992fc180e1204b139cd825af6631d8eb0a4c9bfe,
+            0x1bdff4383ad65036a6193cfd9f77601f48095adb5ffa44bb31a4acb8bf68b74c,
+            0x17644aa682a852335aa5b1532c6fda9a980fff5e94c2b6358ca83ab58a9a77ed,
+            0x1bfdd4600de694368af6447e16dc544f8565534d30f9581b5d81cc24a6503e26,
+            0x18c8230d4cad7c815b3b71d905826a94022a81cd18a26427fdba3236667b24ff,
+            0xe19493f16f0b05a6cbc8c6ee13f334f045868cb36c7e6013b5600e2eae2aefa,
+            0xd2f393e71214f36cfd6a8f7f4f02b164c0bf4116e97f7198440fb9122583e4f,
+            0xfee312ee60e18d3e7a6ba6bfa95e826f27a8ea0a865e3c7a7fb4e130d1c4c09,
+            0x22a056cd7db5815347a2d035ecefda073dcf753bffe9415afd254621fc370eab,
+            0xf5eabc9bc5fbb19864ef2113fc4c756e6b5f3d1dafb8abdedd3b04d0b80ae66,
+            0x7c235ac19bd9379c4cc01b454b43218af5b573522aed311148404f3a5c743d,
+            0x2d942aafd44c4635f7cc2f58e4b9314baa46e187ae91b69a70ce5ad08aae42b1,
+            0x18b7536ddf2baf318f7d95ceae7c059898a997099b0e006b14a9619734d101ad,
+            0x783549372d830804cccf9bfcadf1bb805df0cd74fdfd8a58ed78b2cd5493037,
+            0xd0ff56581899da5c5e06929f9211224abc1701cc590571e4243ac5380251d75,
+            0x10eb2ca01dbc69cf143a07d1ae33d465c21b004d93fd8ab3eccc330e8897a06d,
+            0x1caff794c32f783cee39dee2bf130ea89316a74d9bf6568e1d0be5a2362f4273,
+            0x26e43873787a976ee680508db2668f4e6c8ede06795ce54762ea9b7ca7654dba,
+            0x8d378aa3982d2aee08f51d4ccf75af2b06f52ab03864d95d56aba9bbfcce7e8,
+            0x2ff5d0d03b4b4f9d0b01d3e0db319dc28906e4dca3dfbbb4b37f99a85d1b38e2,
+            0x18520d1a0bea45e0d3d8bf43f25ba325c6f2fc2a854477dd7bebdd9ac94038c5,
+            0x48981c51b77cae321a249b580cb97b327075fbcc0e789b617e8d3694477e52,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1487015218138ffaa0a59fa85396ac51e075d8925a724fd325424d928c654ac4,
+            0x158e7709256be5b46df08d1e1b0be1938aa6f4e5c70197431f5f2801cb81ce9a,
+            0x23ead31e3adb55af0de40f8ec4e5e40494192a137f36d6468cac8b9f8eba7888,
+            0xda52b842c39529943fbff3afa9c3a75d580025df3c708ca7e312396e7c7ba62,
+            0x20641a12ce32094370652c635921aee03831de2dbbe854b52d983dc669a0cfa4,
+            0xe854c479dbc2e4674a8fb297f33513eaca7d1705e71cd403b3bfda7d594d063,
+            0x22e3bb4d657720df9174b5bc721ec49ea213157e0a59d0fa2f2eefe9a8bd2376,
+            0x3f35d5ab9a8715db37918b791480b3190493266747e93b2b922f17c4a8d303b,
+            0x71d91869ac439a23c518effe61ce68bdd578204dc70878ea949b980e8ca5765,
+            0xa5afe6671b39a880f2953d521327679dfc02d2cfa739e10ec0ce898a7e606fc,
+            0x1a13161ee9c83cc5dad2019e320b65c9c0fb13afe6a473b03242fdf77e80607a,
+            0x3026cf4032ab73cad3fb5363647b3617179ff403dcb0738688848252d5b6f2e,
+            0x243e0c7d13dedc00a5a66e8ac3041de9cc0f107c69e38e0a5ac807fc57523424,
+            0x2a9fcc31d5ba75ce13add9a2fbdd4bf8478f3d286638267e8d9889236ab48999,
+            0x12355d3aaa77205407a218c67bf292f7389e48078ead3ad8b44a7f26b193a571,
+            0x2fa06fd721aac5819fb8d72118cfc36835a96a57466c5d9c7ded627ff5f0925c,
+            0x2009a1047f9adcaf5d077ebaa1d827ba73fff81d486a9bde79f66ddcf7b95670,
+            0x23afd3d3c0e2e875b2a847cd2a686c1fc3c5837f41935caffa4bc413af451491,
+            0x2726dd1f3fdfd05c33efe547ed972ad36a60674889b98d1786a505f73bcfe296,
+            0xa1f79f8deb6a176a4a20a89c2f3134f7f2288e5e698d8daf9662f79a7df7253,
+            0x233dbacfc9ba8c6e47588085cefa90f7ccf223ab050c4900ab2b262de8235c13,
+            0x24e7c1d18385735c7be8ed97b21065ad3446b3a44540e129605efcac8b1d27ed,
+            0x2218b114e6a493d7b5b767736aadd097ecad86b0f58972ac0efa546a5f1a4726,
+            0xfe60e24f84080950e79f2dd5dc8ef6dcc5eca3bc6cd608f91b9e05a4575db3b,
+            0x1d3ebedf3c91e56b3331c235edfab0c1de1b37c4fcc7506755a7e90b86a988ef,
+            0x5b18530d7ead1dfd0d305e24244c90f8e66be3ff5195efa2c7f9317db72f17e,
+            0xddd0529998868e7616a880793d4bfb9d9a25f7cbcf4f894d7c91443dd3a3e0f,
+            0x58611fb32de45f6b800200ab76e38d4d88152beb86ece1462c2129509732672,
+            0x2f4954ce179d833366a6cace0bb216235b5fc8331a0ef36ab40cf00881a1592f,
+            0x10dae4642d4de29143dd5ae8b72f56fb7800d664ee0c121c9990e88976ceb878,
+            0x9d1b3f83888c3b9a018f779ca69c7480aa60868a1dd1ae22d328df4667ac672,
+            0x1f8cb04b5c6155dd321920c129465f8033161f66a6629acbf67d0ce8609cf2f,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x697468fa48ffbef2def6f8859c1276f40ed8603b54f336a9f5bf6c986dc4472,
+            0x14845ae5256ccf9f52ef754d6e9f93df1320a86b1d085b642e9ac35fc8c659d4,
+            0x20a0e20ca969d47c57a6fbf1d7c7be6fa22100b7c59f0701d589dc3a150ee595,
+            0x1a54b1065df96a7fe52babdd1c8fc70975c19190d7e3f0cb6ff113eed0ac9601,
+            0x60a95bf72d45427efcf1df7d0374ce564d824bd9371afbf03b58a7c2b8257bd,
+            0xc6bae2f35f833cd1099626a254a8dfda1efb2aa199b74f9fa99777314688d8c,
+            0x2e075d54e2f7837c58a23049c4c5bc210731775ef5ca93689d8e411d3e25c05b,
+            0x7315b60ae704cd80a3649afc32608e8475c1b87ff88966d8e4bddd6bd5ca97,
+            0x1c5f8d20fda642dcd8db43e9361d4188a8f48dae9021b84073ca261ae50f32df,
+            0x13671823102cac626ae6c133fae6cc40e2a2e2d7f8a1191889988154b605a740,
+            0x10f3889ecee1bec4a5e6c7f0336f7d193acb1cd6cc1b5de815daea4b3b760f8d,
+            0x6290c4b1f8ce6ddc74050ca5d58142389edfcaaca0b3b23514e864e8aeade79,
+            0xc359d3a8e6913715c369908a57f93775b7efcc28d300317a9c80812d9915a1f,
+            0x1b7906c8c29ea1eaa52ea3073c80c666a686912cd52e0f8804d61087d3968f86,
+            0x140e7636bb9af6ca0bc1a25757a7ddf14325f99ac07e34c22fac95cc25b47d2a,
+            0x1a2ffb754f4df24371e274a2080def1f1eae921b272813446142b708219a4277,
+            0x8925574c3dd6d39347dcf0d188e603ba86c85d8ad8c7bb96b503be1a4b01fc0,
+            0xc4d557652fd1a40449b5245494f461ae0688771c6f4c6e287632ef3d9e19d86,
+            0x2e9c11f9d848f461f467311174d68af36dd75eaee8fdeb0938fef3412cd09e48,
+            0x198350eea49489bab667bac0f4c78b18f31c0d2fb615f3475ad0050bc0e99525,
+            0x1feaa21fb6aa40e6d3b99d464f0c9f21c0e6d29fc4733bbf6513a40ff15e4db,
+            0xbfe6c87d65833b8b7963d8c909b789d379c0a822c03e33591a77bde69936561,
+            0x9d31ad63366f19f5de31ca26fddf1223533cb9809ac773c664e86ef943a5c97,
+            0x2092b2bc145c4332074825b2deed1cf735a606687b4bd62d6b70147734da47f2,
+            0x2c650be19dcb6005092570c6981b6c6701c999aef85850dd7524c99b0eb50772,
+            0x1987da1e063088e505fe1c22279a2eee2ba492e2daedbf9bb7ff7fa0ea0c2244,
+            0x2d964e6c97f1ce9fe98ec13e03e39a1418f7b586ef6b624c9b14fa7a56d43e57,
+            0xe44e2dd16cd81347aa62325235cdbeac7496fb36bc98a405fb658891be8335d,
+            0x2b3f3be77f4eaf5ee65b1dc9420fb479926f707b6494e45c0c3456c9b1149ac1,
+            0x4510148cecaaa311e8815f62e0c11155a204b9e8419430708f270cc90369541,
+            0x121f5e52b5ed6d974d5d8b5e9d535eb69c207cdfa494e75a99a26aff13c9c3ae,
+            0x250897c08d5b8b109dfb0a60a31e2509ebfb5a453a57044cb4d1cee1cb36254a,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x170ded62e47a24d031e0d09a9739c181a05ffa6c072a0ae4476c8459026ac92f,
+            0x7a7d93f07720b729d0fc11ea7c60a819a915cf083fc5590c8034b3e299ba0c7,
+            0x2b38674819134ea743614550a13ff1e8c4ae2dca4c098dbae7179c8eca382411,
+            0x271289dc176782bc802a40e2b98935e1f0cd9cce1cf75187e8bdbfc5fdaddfa5,
+            0x50e0d49763f9965169c815ad6d976f2c1502d504427294ec650162b32d16249,
+            0x1e16a7619369f7223562609f8571294ff3134b6d2900818958abb801ed25a2a4,
+            0x55be327e8e9177db48e781385c7cb9fa1eaf7f944ad5806b8040d021328ff4c,
+            0x1e218f8a23818b358a930aaac6880250eaa814f4e5f4ab3720bcb53cdb1f06d7,
+            0x344ffbdf73e00c5ac9603bb8205edd7a75d44a8663da028fd643d4d6f4c2ba1,
+            0x127fe6bca0178af93f621d5cb8c0f000c81096f0b6d97dbdf51785ae1d35581a,
+            0x286df223607d95bb861a49f083b6dd9eac58b63dee9aea94b87f4a70e6e06e52,
+            0x8e3e56ff4056ea0cce72cac7f1ab3a3f039d5948bfe24c59667056ede70e1ff,
+            0x5530286c0e7eae0c6b693a0503fd0271785b1a9a8d159ead68b2777b07fb552,
+            0xe5a8dc54f4762a808e384f96b9af4ac56fe9a046a3ce354ce3f7b02fe5f8840,
+            0x12ae091a2d3ceb050262f732366d0461725681ef6a2c98e6cb2246e0821462f3,
+            0x1bb12b01d476fb2d879e3d80e38294091670654bba4f2cc2556bf47a7fa3e533,
+            0x183408f575aeeac085a605ea9934dd45294c7665bf3417c2ee55fed79fa3ff4e,
+            0x13ed068f2325d6098bf97f4201013c9cc366c2212817303a540fa21a530b2186,
+            0x86a1854cc12612ddc29d8130a224448fbb3f07faceef1c457b212865cbaf7f3,
+            0x28e0905fb2b0cda24805076055e7a974487c163f6e275de6f0a79c2953f42686,
+            0x13482a7e8bf17cbf0d729a877b9374b9bdc382818d0829df7785161c845df5a4,
+            0x411f1eba980a1c2246e9dbbfc95ed50786591e99706eea93b50fd4eb7732792,
+            0x2e4d2ef29fa7855a8479c385ee585e191afe05e4948d3afb261713ae3846944a,
+            0x14d0b018b332223d8d3a458536fd4bb2c8ab2765b35cfbd1b4f5af2bc7eebb85,
+            0x7ada6b05a15e228c703ea1deed0d89a090c888e04aeab93b903260d31fb63ab,
+            0x2bf8f1482d4178227da9ba8141f98d764d7d25723d12a474a0aaf2b6f500fdf,
+            0x1771ec5e8d202af9fbb5a6ccd92808069ff98a103ca38e60216f4c29bd138027,
+            0x1cc45818383e71faabb1f0947a7f2e2c6fdf84ce43bdaeb3108eb95c853b951c,
+            0x21ca4fbb38c5efb489a858ed9b5550cbe80765807ddeb5403956a91d3bea3921,
+            0xb264544c114744badd140a81312486c6ece15085107fe41743ffbc42457190b,
+            0x63f973d8f7955b230c3f623e86769a8f1fff6a2f16f542aa5d25450d77dfa26,
+            0xca567c8c6074baf8976cfb1c5d6f2d339dd69b91c3b86360bb72b6cddf2a05a,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0xe84546d43156eca6ea9945a1f0bfe0d070c7b5f596a165d6f5b2db25d70c898,
+            0x255224468137fa5731f4a79531b0e41467fc167a73eff9a2f8606ea4b8854157,
+            0x5e444e0bfb3002592edf3b1a17b61aca96cc4f55369ea0b858d00a2429413b,
+            0x2c9547cc8c30279572f43f6c98e57d007a8d8e00afe3232f22c86d92cfb3302e,
+            0x128d1e7dd33b8a7eff38771210c3e2e32542927ab8a5bf70b304eac65a5e89a5,
+            0x117ea550387989a27267059d04eab27171d97ad177b4722b9076ac7850469259,
+            0x9c2d962801e81427424c3b82a3c2590f3d3a015f5d05dfae03f1646e85b83a8,
+            0x26d1151c34d444d61380f618137cd12d3856a5112c1a229087d5237fce352402,
+            0x71de2aa9593a6be60d825df98f433ccaff569e8f454b57a1a92a3a179419b40,
+            0x78af695ca1926d0211a0c74b15ca6a21b21530751b6c89f16a7653d7b749273,
+            0x10fac024afa92974f4f4b43777c31f0eaec838068e24173416e3e55f18f74229,
+            0x252a24164cb696970f2696824ed7ab40a422cd2f561c1add5a7b94d9c8788416,
+            0x2dc1cca380599b8d9c74524f5f370ecc41d22c4c792717a7ff91893c9e878bd2,
+            0xf1970c566c802ca51f328d7a61668732660b84701dbcdc7388dddb0d503d32b,
+            0x14410ae146ba19441bdfc99f88fd2425a30458ef81a97cb0757278de7c71b6e3,
+            0xea9dd39706c27da7b07438387714c8e986a37c6bcb9cfe0aa413edb1d426620,
+            0x12a0ec57214d783396e73e66cd8d163ae207afdea093f62ca08c1d03849eb81e,
+            0x15f6e3cd0868b4e3bdeed8670ccbd35b084b2ec7d9f70e1b0e1bf9179f4e7aa2,
+            0x273ffa3f96b6f990e5bac3da9121fead4c55e9a53a4cccded8ef7768777e04b7,
+            0x265c7d50300accd451f9d10a056a0a9c4b61960abc7ac07f405544d2be981cd3,
+            0x25704ec82bcf245817c0b0c38428f80e097d181fe4be674c56a431704b81220b,
+            0x2bc004a70f93825fc7dda4611642819d5667d0c84de02d108fa24e7553a8ed9e,
+            0x2c67b0e93decf3dd43ecf2affb6c8ec2681b530e89f028592649fb853ab6913d,
+            0x25d1957093005c4eddf0f50960ec66bb0a71e99dfe635f3882224ba50ea2a19c,
+            0xc05aad7df610539bee690ff338426700ee57012dfe44b456047c168d9f230f2,
+            0xa09feb45b441685f960784f20a9daa679ffed8343997e028fd527f1c9615f1c,
+            0xc3317b6e0f17024f3e8d48d7be78de51e60037b098935f715c5f7afeeee5559,
+            0x186002e006875015c7995b512ab297b9b6a2ace2f8b1f23384f545a47a09eb4d,
+            0x607f219a0a42d65871803946f468fe1a990978f7a7dc0a6565282240befe85d,
+            0x83054c73153f2594282f425afb21bc06076820a2a936ca2e88aa93d198ad89f,
+            0x1d279f18a4b248bbc61bf2647394bdced0fb95c8acee6dd036c0ede0c250049e,
+            0x2e9fde89ba2dcecf4a0d11815b6dd2a93ad007660b67c14e84e4845521b47755,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x66bfcf07a648bceaa19dec1031fabc57395c4dca3503000a98eba19c54fe970,
+            0x276ac7d1569f671ee8f23ea68b34b200488ba7f18d905e67ab0148bca152d25a,
+            0x2f20f2f426186af0ee321282b00a2a641ee2b251399734d15e19af27ecd42de3,
+            0x1c96a460e778f4af5015f52cd38cf2c41a6a9e85f6a30bb5f3435dbccb7b9e4e,
+            0x227da7c9930fdc00476ca6928729411b9e65bdcd361ad27b66ec4c4e5b529a57,
+            0x27b1127b1ce6f0686e0722d5c5a0cf8847ac68dd8eb498a1a2f6124a4e7d3eca,
+            0xa510ccb52f446c48a9d886d6b7a6705680356500e63b4adfc43608a30c0d5ad,
+            0x187297811a78c845dcc821d8193d2ae2ccc8be6fc0552f3e810ed9a2d044d7fa,
+            0x229793d98c198e355838ad9410d16930e88ff01e0a86b8074ff75336afff596f,
+            0x1214cf6c699c46ef88ff3713be9f3beec4ea27cafeed293326c7db4166b31ce9,
+            0x2099cfaccaaacb25e8c1730ff9d91c6f82fcf436589b18d1a092f61c766af9c2,
+            0x2322866854d0c03dbd891bca034f176e411dda04203b47ca04ca2c2a82aa5f23,
+            0xafe4184fb8af7ae9177ded93afb51dff550c90fd4ab624c95b9e0bdb275ffc5,
+            0x18981ec4e7b2dd5b75057171332150d62e2ebed5bc63ee632a6ccb4146745f94,
+            0x1fb6ac0886f9dafcda077d270effeb93aa074c26a62ea6cfd141b82324dff556,
+            0x2aeadacfa8410a4c07abda74bf85806b7034785279a95b17c6ec7a0ecbc4f72d,
+            0xe640d01e5ed243961bd4361e2d3b669bcc5bf35bbd30181e231503e0ea04329,
+            0x2e878ba571f0ae43c5d79cc04becc7c8e65316c9b6b83c0cd56124dd51966ffc,
+            0xe4671548304dc6301e30360016f37d8289e8570c4fdd1189cc7fadbc02f6719,
+            0x49f32a110437e1552ae6163e0890d534b044bbe2ff3839eb980ac72b15ca83d,
+            0x29be7fd214d5ac3a21e930773ea4404cad8e7b751b02e186711e07797362be6b,
+            0x6d4247fe770b6bf51c7b739fbecc3aa418f5920eef7624676835ac1ae061d66,
+            0x21c02a9eec894a1ac2eb56d27410ad620122e3a5adfb8a8f83ee617f9525cbd2,
+            0x232b4705581121f62cff2b79d0c8ea43db47514fadc741b3306a6900a0bb9021,
+            0x2a3137d0e0a9987d06f2fd2dc9f61c22e3df55d4929a2322242d6a6b36e6141,
+            0x12814250a734500401e41c65da8949663d7afe8c6868643a1dfd086389c29d15,
+            0x1d221587e6acdcd041bc0e164a9ca84970807de46a767383c44262cbfa1bf972,
+            0x115ec085da8a3839212ae49e93243a25f3b2f34c53b5786d5576e8a5e626319e,
+            0xcdd08d5c710e497a583166923360d16215ad9a3a1629daaab0587b45de950b9,
+            0x921c454f7b3d19a8c766875963305f4b4d6f7f8be1a2c4119315dff25c111a8,
+            0x1b87d132d08fe5a6478b2ce4f40d73b8d4522fe23a4b26e96b31c9bb6a3bed69,
+            0x22ae2be55bb3c7640477286be689776e1514c8872e1e0361ee36b13138d0f6fc,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x237ac6aaad2e2ade78bbbe46b6d53646c7404a2fba31795c331db8da4145e5ac,
+            0x2877189f4c0d9fe01baa33a2b820b84a4a3a8b92964ea9c7b2149e4a2547d527,
+            0x136a6e0031d277288d586824994cdd3da32221fc94bd9c961cbb4a371c6d16e4,
+            0x18a97e7a120e79f25dc87650a56a580604ad0fe99a7b5c93b295b7231fc13e35,
+            0x298a890330408d2eb3e6aa31347e4d68c1bb979a23d9c7266e63b47580fac913,
+            0x191d5d7b95a739bb75bf19d63f8e787dd14fe945408aa987c749ac01a4e5d476,
+            0x2449e2d526e2920627d993eed7cf4de57155a00e5f071f059b94eaed73645b35,
+            0x1a0364ee68cb9c8a7a0e801daae0ccc07d92b82686bf5bde72c074247f6767a,
+            0x1e88daef2272c0f1f9792a6d85f29b403deeb1f4f234522d28112c466790ce71,
+            0x2c4b0d1c66062af96f71c6b23ea770f5e53c39967f0d3b1a950df67c9766432e,
+            0x7ad869f9d13d9b270b37cf255b577346ca286f8979e546182c4b9139368d186,
+            0x2015d96937e823b49d8eb2f7bcf3be82a8b6ea9bf53b5fdb52a4bf72c4375a9e,
+            0x1ae82e2228f0080b37ac0d77083c3613fad8242b420de1a24fd6376cdc8d79f6,
+            0x27f0ebfa6e2ec9fed23a25c07cdf68a7dd8bec39ce045c15fa0e921b75df31dd,
+            0x1b129211eadf48d228e7a13a9bada042edd5164ea595d523503727419a5b6a5c,
+            0x1541b4e3bd42e9287b5e0bde5ad7c3ce76dd326a0e53418892067a6cfbbc1bf1,
+            0x3cb9cff50f4d9d174ffe46e382184d9a99306f350971156b859d76d13a4200e,
+            0x2191176d2fe6b3607227f17aecd711d31ace1a71987962dab59e2d4dbdfdca3f,
+            0x333a98f84a220a59b23b41a6eec5f1293aae65a9c1412fdbd05b6c730e7fe86,
+            0x1d3133dc479ed041791efd9f449ac6b7a2ab67089c2aeadc033b12389534c8ca,
+            0x11a957c8acc043e1dd0228a3bc3e2ca5054dad13c1c685d3fd1c7015dc541b88,
+            0x9ab1d5764d1ab372770e72a734f3234e944f231d55b4802feeea21ff00cffed,
+            0x2ab07fca009ae3784d9172cd0de7a03ab1b413207754249d54e0115671c61648,
+            0x2f26dcb5b014b72bf8a7df0100847754ec09bf69ab23050aa6ab45b8bd49a8b4,
+            0x12831914375fab4bf02d5923d4fb07f59ea7ec76fc424eada862287fac0121aa,
+            0xf01b766464df2a94717e0b5670db63546816d0ec951e74fabd2070364513e10,
+            0x1eec1596e07215f120c71f3b7fe2c872c0d1f0ecc2447cd0382ffc1b3d74ccb9,
+            0x13a9df3f6c9c0363c8e81bb2ec06ac0124cacc3aafbfcb99ce0d12b15c1d960f,
+            0x9941a17ae1ed8d69ce140125c49306cae9ea0a037563cd93dadcc09c1b8994a,
+            0x790fc3d447ed1058bd5eca57d37adba8d645d5c42e7441e5c508e6cb2a7d581,
+            0xe11f8951edc551adc073326138ef3493ec812ed643400c53da02d49033963c0,
+            0x1ef50d438e0fb3260e615f2044df40bcf70bfadc6b819481222ddc36e39cf1c2,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x19a6c9e51754a1ba0ac6f28381aa453e929951403794d3f57566adca54593cee,
+            0x2fe2b32027a048ab3c9fe57e0e0e63168c1beabe9cc3f5328bfc6e2620d1c0a8,
+            0x252a353865d1bf6df4e243baea612d8d67a58c9b91b68be6f6ab9fd6cfa6f052,
+            0x2445b945a65afd2c8c6d1e12224f0e1b5a7a4ea158a67dd4617f8d408239bd68,
+            0x2aedc3a83dc324a21fc06b06f1394d6a5636c2f191f252e9d927ccab3b8a47d2,
+            0x11ef3c2372ad8e0fedad2ada9740cf104fddfe5f26a74759e174eefa6f5aae49,
+            0x16540a4f6d867388866e79a4f327c50bc06c7abf88df4fab1af55b9693c0833d,
+            0x226a8cf3b4fd93fb027602a84e5c84e19fabdb3c6b0641903107238e7473f4d0,
+            0x15829949331aecf0006a9e8f46f028a13efb7754976721622d65b6f9cac5756f,
+            0x219a0633cbffa129b8be664c32a15d8c6f307fb00fa27267628de8a7cbd4da12,
+            0xdef3ce304e0b1f868a4036fb628bce381a92931de8dd658f9a4db69808c2c5c,
+            0x2bccbcda22270d6c62effb8e392bb7fb97637993bc102538c5cd58e88a228a4e,
+            0x188172fe781d7b1804c9875e732ae5ba92da30e3fe79193172a9b2ad266b912f,
+            0x1f30e5d70cc514c78a878299f52f298eaefbc73811fd69a8af04d6e1b235f8fc,
+            0x36dd7eb2d37c58f0064ef539c409ff1b2866f3e37995a0e6b63d2e12794a65d,
+            0x2943d171cc678d4b3e7bde9fba8cc6bec123fd9e18001704074c6b53b2d7fa55,
+            0x16d3bd98a136cc6ed17d71e7ed150e659bc21e304859d7e91db4a75311b12c17,
+            0x2cc46361954b156f22dea4b4e5836d017ad5e866df6f9179696836eb0b9ecde5,
+            0x2093732993458c1dc5075a90772eeb28239503ebd2aee0b0831f253b5795f431,
+            0x26fb0a33d8ba99f9d666fe22149b4b9c288f7a356f7d4d62ca019c426eae56f6,
+            0x2ca9e5344928b4c5f6f6d72ec4bbf9f331563b93f78c5b6c693f9ca05a03b9d7,
+            0xf86ace9eeacefd133e6f9e5b27e768d4dc41fa8a4b6d0b643d59a99b972b97e,
+            0x16aa6528c3e5ca07060d40caf2050fc7c1199f3ea08c4bd2841f8816f8ddbbb6,
+            0x1aaf0a3512751441abaf663b51bccc82b4aa9e031f95fc5ad831b6f5104b32e8,
+            0x1693d12dc33373065921094c6ffb59f1f0361b0c5ce1b20e8f3f4f1bae805df,
+            0x1a5b1eec5d855cc716abacd6b5ef79ad4813bc74fa3265e0f4966768088e24a5,
+            0x1a98219aa97845f039309ae314e1658caf33c72235d5a045a11231048dc85871,
+            0x27d38feb2f3ca73be6e78b2f51db9e904bd78d3f7ed495634b22c29b28847943,
+            0x27b21eb7516a84220bc79c6ba5a35fde0c5804d4dc2b469f034f93245cd58e64,
+            0x10882cc54c76c057e84e296d8568fd68a41a86bb595cfe644def5dee16e2b60c,
+            0x2a5a015eeff7cd48c5f9d66baee6647ebf41fe73f15999b85aa738249667f809,
+            0xbb55ca8ec263593081a7f140c88ff0eca81548ce6c2fc66d3c9041e7e61a52d,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x11a95faf7782644e66dd690770be8d58aff9b21c252a17353159e8e6a9cd2d04,
+            0x1809bc4f74f8da0e56320179b35cfccf08531a383f8f38f055567f54de408856,
+            0x29576ebe8b472aab3c418866b657b4bead5aebeb46731ac1686234f997c8064d,
+            0x15fdd752a74e076a3bacc425ac17ef974ab4ce00d98e3b766e4e9da506338bf,
+            0xa39afeb11772f20bd44212cc5274dbaaeb912c073ab120a0e3a5cff2f95321b,
+            0x1bd3c83976780db74f4bf261b609505ba17d4269a823fac360138142fb482bc2,
+            0x2455035975952299afab678e90178017ae59c02e88b66acbfd33a9a97e4053ec,
+            0xf54c6e582707940d37a81057e0331967328f0402b139f40a152a537050d4eea,
+            0xf3edf4b1021df9ee75bf77288e35c135bef2e641317adbff2cacd1cd63dfa68,
+            0x15a4b29ef2de3e66e4ecbd99b63fe784c3d163534087d6e752935e3a66a81061,
+            0x22de01c525edac04ce6418e44df62cfce81abc3238c0832a5721e81410124db,
+            0x2f75cfbb2d72a93661691b3c313d73cbf48e570aff4a8981565691dbe6e7244e,
+            0x176215e6dde458ba94fe6cd32886ab490c44d3f35708fb83ac032957477470e5,
+            0x125224651632beae2362689f3f298c3d1cdde20786b700cf154dadf04aea02b2,
+            0x25adc0480ab90662ace18ed71d4ec243b5d118bedf866880e5112278621657ea,
+            0xf1656323cf512ca13dd9d53b6fea48d0bc03b7a0a510a1d1c376d7c879c0a6d,
+            0x1f7fca35f19d9bc9a9c510bd904477a82a779df52b3d938a34ad370bcbe107a9,
+            0x1650f10d70200c4cf9188ae72b638a48efa885d0d57e4eef3bad1908117cae47,
+            0x2efa5eaf0d9848a2ba0426becb0edb4127f4afa0b9532f3cc8f63fdc6f9f14a3,
+            0xad402c14a8aefcb0dc67b5d3c1df188d1cece3de0f53cb313bd630594e20123,
+            0x9874e7aac804e0a72c21eff6800d99327636c1bd05752cd398c2e19210a92c2,
+            0x127d6e66dc4de7272bc0e6174ca40f48618e1c90ce71f173e0363278e6e26edb,
+            0x178b0d219dc9fb0d491fdca28d89d4f41d0e650c29d8097a6ef982a3d45686ee,
+            0x856563611627d9d176f629668c19a7195b0bef83a02011485596c0fb37595bc,
+            0x4f01e13e7e01f0fb607f39a334e5ac5a14649c65007df2e0125d2c07f165f4c,
+            0x2fdd1f6a4746ffc3721fe601b31335874a23c0353b217cc6a65f98b52c48c32c,
+            0x17732cc9a7ab756b3ed24f4b5cd348b27c476b0804a47e8e8024fca28b858022,
+            0x8f9e4a25ef65884dd6b159c396447f11f374cf781a8932b436e428d8407efb0,
+            0x185536364010888ec827263bd36282a0609556021920ad8349159c80d6895398,
+            0x1fd0879f9628b76eaf032db092bb6caf8a03c437a8e7cc0c81c9531213d61b8b,
+            0x122fc02a0d06dcaa8bc1ba52dc7905ca13f2766023a8e7811876071cb0bcbaf8,
+            0x8130052ffef7fbdc6d1bd38334212f34f3715f0bd1dfc1b36eb58331f5e9106,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x21c85453b5c8f53b3e43499159ccef5152fc9bc3b14cf1d67e4a80e49bd83b,
+            0x273d34ed60e945fe972b67c2c155653e1c5c38c4cdff7c5753de7c68d3bc3261,
+            0xed8f8c0b64423895664ee04c994ffbf1aed16eb8f6d2c05b46edf07a56d2777,
+            0x9dbc162c39375cf6247de315a85e1730c451e59671499b7bab9f73ec47c70c2,
+            0x2bcc328db7c571f892d3d934ae7c031792571d716f51494e8b10fad60b9f52af,
+            0xf2333e3ab2c7a3c13420d4380f2a8fc867538db7882a5fa6a8d899e4981889a,
+            0x1bebbd7c3e88b63ed37c373e359a741a38d1b8de608adcc050b051dff7b51580,
+            0x101b1cfce09e9afbcc995aee85711574de371ff76a293ecb26b4796a16bc57e9,
+            0x9866b876de53973d54aa01a3095719031e0a5ea78e26194422dfaa80c7e39b8,
+            0xd34bbeadd10a0556a40cb0e5f84ffd96baa82621d7d850260115312fef1a5ce,
+            0x1dcdcddcc0aa7ee28522e5b331b2805fb95a75d2e90f876940091c4c57345433,
+            0x222013e1cb04b56d232f806664f4b950bee1c8965d49dfe59c7d9a7f37be70a4,
+            0x140eb0a40f600989bc70937e2fb3db0e1cbf4ee953bb5dfb11c3ac257105acbf,
+            0x1c2a10c01046a2bd06eca1a7850d8815dba9dcb5002710d469763ee12ce733e,
+            0x4be5c9c1a16eaf24f0fd62603edfab2a731488c6f0066a29bdd96f8595f903f,
+            0x2aa1bd7546c15d05452c1ecec07be1a96d1a916f6306f11eaf52145be3efc41d,
+            0x1ea9d7108069582c4db4000fe9c999d50a6732feff50099ed5863996a0f4dfc2,
+            0x244b02346c1e7aa223e1cd73cc84de1c6a729e722410bcd9c6c21c10f81aca3,
+            0x818f382294f0d2ad1e50c908d6d58b0567eace452491c7e7e2ec8f02dcdf30f,
+            0x1a889d417861f076033045816bd9d152dc38a64344876435c43145551e938c57,
+            0x2a741e0f1842497fbf481fdb838af76f016c7c7f902d0f1cf91946d9b19b8f0,
+            0x6da5a57ba1e1f0e02b65254d7ba4170ad9f42f8c2e209dd3482d9d100dcb69c,
+            0x2b015d97e986c22f639d439958e5582192ae2a3c5e63a93876ee2cef01cc64aa,
+            0xe6fd84ece440532b1d2a84794a2c0905d14dedf21f1cb88ef011d6d40a44966,
+            0x180cc40f9b1a551d6f21a2616a31fb14ae3de6cd3f90905090112f08cd2a517f,
+            0x113bdae7dcdb55a5a29449e0196a7ca19785e8f406aaf81d74f7c658604d7b5a,
+            0xaea1a111b956238e2034bd82eb6566729d6b744738d0f907c24e91cf0e270d9,
+            0x2d877c0d3637dccbce6fced14de0db189ea37e2192595d31ef7be35042b49789,
+            0x64a1369e5439801597f5f4e2a95058e001cc3b7d449aa87f991c81219590592,
+            0x133405bb6e5e245a0ec3785cd300ed55706f465191cc6af05debfc09ff323eed,
+            0x228bca7f9390e0cfe1125af0b7ceb2b228fe7d373e3bfe077385682669dd6231,
+            0x90116384ea569082bdf437341c03094a1f388ee217c0e6aba3987a55cf62d3f,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2dcedcc12959aba1b815150ec24051fb4dd8440208b0f4eef706f364709fd64e,
+            0x4aa0509e7a94554490885f0bc0055b4f23a003e14a2cdc51a8f1500b738512c,
+            0x1ad3b6634a63d1bd97d8d745888387e7030be2bd5219c84de5a4b21f6e6d5c9f,
+            0x2722ff91fab311d5cd493305ca2e581d23ab35103b7a31d7436fb4351e5167c2,
+            0x1756e34f7af0be32dc4312c914ac48b60ed892e0a941866b5990c475326a0a08,
+            0x1f9681a26d581ac87fc486d845382aa8afb31782fcdc16ae3e996bf79e8910da,
+            0x2c407593aa6fea946d0ec1289e59dc993dbc1d689a02efefd916c42b56d4e056,
+            0x12d5a1f35a3bee7be87beb690bef3b422d4db19f18f457345c5b13732213de41,
+            0x1e444d4510e2cb542a4bd1af5232ab8376e5998f69193243509b05648b59e317,
+            0x1c51186bd573f6d8e39dc9e5f85ad954ee64951ba2455dcd9f415b2ef44813ae,
+            0x24c84617d0f0266fcf18464eb08422f51633915380696b571dfcd52fdcab3825,
+            0x4894d26fbb969454287e1560c81f0bd33e93a0ff0e360f882f03621ffbb724,
+            0xd669e170c4428089bb490e8af37bf2b4885f61f49154eaf4bca6867321330cf,
+            0x54ead1e70a68a2a5bf0f9831c8b37e0c4692840a5eecce2f10842aa9ff4c77d,
+            0xaffcbcca6d353dc0060f6c0e87a7ed6926d6518e2e20181e76b0ebc3e55738b,
+            0x21fca621016a771a181efcaff53647cf8ac55c30813c7e1b7e0c54b1b14d4fe1,
+            0x12f2e46957b88910c30c9554fd01780e074870fb9df0252cb735dec70dfdd6df,
+            0x16baad45361a5052c6008a02803656108d8bcf1ab65f3d1ee9c866e2a04f1713,
+            0x202cfdc4cb85ce703b7ac41cbf904593481c951f9faa52e44594c3d0aff5f070,
+            0x2782837366366c2f9b943714e6a11097321394713577fe59dbe72a78f4d93741,
+            0xdd863bc6e9a0abd947b2684abe555a269da1eb7a491ea6c5d3c44e0cbdbc0d6,
+            0x2b1ab0a5b5516d7a4f31b68c93f21638a3bbb9ed321b9915412b422929e8d42d,
+            0x247c684cc872df52c2396d52f5c691e459e181546cd644fba41843beda35f07f,
+            0x17b09bebdffdacc6d3abdfd4fddeb0a1d04150563119def60d9ae9de6b13d0b9,
+            0x20377c6ac1d667eeaf88e001648da149ea26ecbaacaf079f0a089fd6ec42694d,
+            0x27baae8b9a93a09459ff4c88150b93e9fa3fdeb4d719d37e4fb03b29afde1b0f,
+            0xe105b04d1d6efb0def9dd3f43655181cbe4a1ea329e779cec335e27190d0840,
+            0x1684a9463b01286e5ddac76b990c6ae285c81fc4f7e7715b1ddc827e5caa82f4,
+            0x1a1171d2f0e3c131bab4ed613fa111bb85f3605028028f5c1337b4ab542af356,
+            0x228742f926c112c443bc2e362be8a44c49ed66e17038f7be297d51482c548ad4,
+            0x10bd84eea945febb47f7296e5bb833378ec26f61c36d954b87a5423754b0d1d1,
+            0x2d17cac96f225898038e5ec16560f6563f768a7e127bf10ff8ce1bba63d032f,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x23091d6274d72f0516c11e52c62a89e2c218acfcec269d8588246bc63dafd307,
+            0x9400b7e97812bf8321b96b3c4bb695dab509934e197ef9393d9921a320fdc5e,
+            0x1c9c8e269b7b5d2527e20b5d340f2978fe4f0b969e2b1f33b5ad8ace05931036,
+            0x29bcaf9978fe301ee64f032f3b6c5aee47fa89a118490ece975e4765a688e277,
+            0x2c43ee462e5eaa57409884a4bf82116fc74f060cd3ed87b249066bd753e57833,
+            0x1045ea9efdd2d37654f2f419bc1c1e07dffc13a78e78329d66a80e816b75e0f,
+            0xbdd990f09c0fbfcafb0ad5d2e7609fc639f4643262b9fe6064b1cd9f59fea9f,
+            0x1cc3aecb65d88c117e077773b2ac321f1e35552bb82ecfafc19a6d7f58cca0b5,
+            0x234ca75eda2b98da7aa4bcbdaf01b94a0ba116a7cd4def0864e27ba56623ac56,
+            0x1e5844a479ef874349416efe4ad14c691bbd4d60b6a069ff6fccf0b4268368a8,
+            0x15cf4b909eddcc0af84d45aa2a5ce40f004cea2337de82214b5b1b8bc25fafc7,
+            0x21fcbaa23db9816f459fe5dea6035f4416bfea9e46b1ab150335fc986a5d3454,
+            0x23096d193c542015f5ea72945e427601d8c5213652cc7bed15a26118408f3528,
+            0x11ef3930fae556e5688b2e5c5b646a9bcf2cc8c9ed84699798e380534da1ba1a,
+            0xb2804a0c39e0406220d23e5180ea34743b823259dc5c037e27fa14d97aa1236,
+            0x293618a713ae76e001654396f1e7ce9885f07515d1a52ae6188bb68411cde19,
+            0x2083bc523f48f2310fd04db4378e73b3e4a774c04c82721c347d841cd429c1ee,
+            0xaf7b362c84812df2052d0e04ad07d830100079327567a741f0e33b05f20a3af,
+            0x2f0a9bfa024571a9eaebb8b6c838ee153298f8d66282665b8d413e67fb9cfe75,
+            0x8e5f97cf239846c4bb22151c4fc6b54f6c078339d48834cb674108ebcd533d8,
+            0x2ad7be60b34c132d62758a699ee2b9b9902b5a66f4d0a1732957fa312693130b,
+            0x2bd813ea81fd2be04cf74361aa9ec03890ae9dc9f2c62e392aa0077bcef5c39f,
+            0x2e720551011b0b99d8a0265f870ec80f9b866a0a5f158a2baf5647f07ebe9982,
+            0x2bf18b6a692d4c64185b59523fd75a045a4844d8df2d931c739fa453740b3cc1,
+            0x1c166f7ccb69a59db6b374b355fb08d50eaf4df7760b2c3084b229e822d858d4,
+            0x79b610d77c02e9a71628bdb9524d75ae9822b98d32f5bc8624e3512fadac097,
+            0x1916de884fe9cac13806c4f7061488f0a57abd1ae403ab0257d21b48a0e411ee,
+            0xf107fa1c9d4a774cfc10bcbc3b38fd7078e0f374b5e9bdb38e1e04d26d3c383,
+            0x1b3ef1482c15923666e1cd5dadca82661bfec0a3a58f89e54fbe8fe2428669e9,
+            0xa27ba24a2a7ad35ec53a125a0447abffccc68a9158523ff88cfd738b0212802,
+            0x1a525ed62eff06bd139f3fa58d088c836c381a9ef859bf16d0c4ed2400463a4f,
+            0x822eb9645c965d4f6b677191294e0b5c757d448ce5266f76ae8ff8898b6d0df,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1af46f08f6cf19a75e2deca250a062244a541413cca7183cdfb8ff3496283677,
+            0x1839ce61b8c72bdac116fb26e68db1136b21e762a80dc263434ceae93e71e226,
+            0x7bcd29e7a46c57bad325631b9dc70f779746e4e3e83b6149cf7d65224299cc1,
+            0xa58deb34a1aa7a97fbd6de55294ad6ed911731da0f1973bb30cc4e50f974633,
+            0xc189862d767c9d55128b55fbad2c53c3c7f09f3cc3805404bab81d881c1f79,
+            0x3f08f5db02c8c4197fbb743163fa98e215093b833ca0c1d709a30517f1bff67,
+            0x1bd997c5ae62f46a4fa08c71dd8281fa20da177c45a5b5e0ea4cbe42a9d768bc,
+            0x1dcdc615a1d29786c2a6b9d356e15f14b0516022da0c8237329d9ce31e6c9064,
+            0x2125c1065d8c42af0dbc0d44be29723de30316bb190e487fac79c6c65180c6da,
+            0x2a9dd846b9a9250303ea18da7dd2f67d8525074d4259656b9d0def7f2ee018d1,
+            0x2a1da460ab707f31653862ab6df0bfaf474d39cb909d7b84314482ad8015bcb8,
+            0x2f4620be83dd42a9810cef816801cd8a77d59146753fd9589a4437f43c44e295,
+            0x2390bc3ee228ab2dcae07fd77d2f2b82b39be4a3fa9d15a82678d487a4ced7e3,
+            0xa0245ae7c93aaba110979562f1bb38e2d6e47f8f58146c2e0af29a42a8f2225,
+            0x27e3d9f7c0d6c32a9db8c79a3fff7227825679bac449cc5567f21edc213d94a9,
+            0x2172e74151fc03eb201e3e300b2a085798e6d27426da9b9e2eceac40374c95b6,
+            0x246a685246a9403eb01cdb380b39b49b35d649136870954260afc23e51129460,
+            0x4f050f7043b183cf35f65e5590bd1ef9b1a88b9a1154e5a6b48b90367679ccf,
+            0x1ad58c70ac13714b721c7e1e43474983524bf5ed75ea0a375964c17eef897acd,
+            0x9d3719d52186421cbe870a8dc16ca12d479447bbc1b7209991d2ada9cdd0552,
+            0xb2d605b80d2d16b8bcc936be91a9b58bf372160c58214d5d05340268db293e7,
+            0x15efc1be172f0c1cf80c28816163d6281796fe3f767449dce700031a9809382e,
+            0x18a72ca7580618a6772dc37da2d0ec3721130a93ed2baf7ee8a458215351c5bd,
+            0x18495f1fa2b09573b0122a6f3bbc62dc8eda0c773c24cfec946631bd226a5222,
+            0x22835e515350739783c361cb745419032be6d7a16c27cde776cd9a43509d5027,
+            0xfbf1fa536a4d74e1eb517dcb715dbd57e9c879fdd1184956e1aea742c4b0c11,
+            0x1bfa4ad591bc024f156f69c1c6ce033e65507f6f2a1b50f9a370ea96dffb4fe1,
+            0xb48ee00c1a3b873da040822c8d84a7d413b07806c5ef6ee1670502a2797788d,
+            0x1b0c2c9ff1649fda06155af9c401957dad06ba11c9d6c284ac3d7f6b2e02196f,
+            0x11b9857c7ac1e55d6696b9323eacd2b75e8e64d863221f4c49b50c0af4ddc907,
+            0x4d2913e434864bcadcd0a0f187751dbcfee68f8d42eda00afdf9fcc254a9297,
+            0xd47a86ba4e4c33ab37f00aaefefacf692c1baf9b37db068097f619f44061fb1,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2ee08c0e4d7f163fcd113539b4be76d5b8c6dcc306994016e2f50b4065ac0c65,
+            0x2e4ee3771e570cac361666fbb6230033f0d2e5df5a43207f4c8c4642fc9ca473,
+            0x22e78c9bd18311d225b9f88c117cb18e658747d500bbbf61c291fe7ebe2bed,
+            0x1b015cfa490fa705be3b9f5645d4daa23c2098cb0939f019d1697019b00a4435,
+            0x153d716532b1856b425b07c5cf73f7ec4bad3458ff9e031d6c191da0c5150f5a,
+            0x25ddff7645c1cdaabb52a3ae26931620a4186ed35cb914b0cb76bec51f7b561a,
+            0x21bdea71747a451c7e825e508ee4c40df40404c011cd5f7dd62ced05f3841437,
+            0x2feda62db255b655f3be96a4847d2f1691ce658456697ecc602589c3ff0674db,
+            0xd3187541007936963cd4bb6c93596b7cfa56d828df39d9f8ff05d934def0ffe,
+            0x26e633f970dbba038ffa30d735ff34541108e2f7bc0e58fb25b8d038eb574c1d,
+            0x23c8473f9504bc04266fa76bf7064d8980fac8454fbf44f68c5e93fc37bbfd9b,
+            0x187a7a328ebe30f3fef7620ec582ae3b457ed1d8dff8a30d60c518c1d3f8502a,
+            0x1072a4199dd532ae3d36f2c3f07359148be4d81ca1f1ec06bcec2c94b50030d5,
+            0x1d9c9c64cced19734c56f62f6adedccf54aadb170d499a91617c7bc34f0207a,
+            0x1b09945179822511bc0b3b20afb76f146b119051e2c6c8f5b9dde03cc761b170,
+            0x29d1379f40c09d9a8105f1814f9cf4cfa8419d5442c22575a0f9836ff6728216,
+            0x200809b6e7114084a23b259cc6dd8d4aa9beca3ee806557a250f98523363d583,
+            0x13169f87f4d5bcdc80277fd4bf931744a09d4b0332e4e54dc351ec16f256db24,
+            0x22486dcd2b50c5a6e8b08cdbe012907083817073b975a842751aaa497389a092,
+            0x986aed7b10fc9cff4a80d5e338f69eae4aa25b45d931499fbe7080fe13a841,
+            0x2a3346c974a7faa8f021c72b4b516dc527033dd96dd87a29013a54ff235069d0,
+            0x1ac08487b535338f18f39bbb2410e0c04feed1b023c2b31a69c42843b46c7b4e,
+            0x2db4eb2420d57123dc86f82c289788f4f5882143e70237ed7aed2b318f2f3f6a,
+            0x179e156f0f6229e6259dcb656daddb273efbdc57b78b1800b3fd492ad4e2ee85,
+            0x18f1ed42c2dca995ba6b2b418378159005da5fd6d46f31d424e404fdf85ecd0e,
+            0x12d1ddb3125c15c61e1a07709ecd1782cad928312bf4d32dabc0f3244b98c067,
+            0x19a555ee9a57b0f249f762e63f02fc9dc41421569e40146d27b805d6926dbd17,
+            0x22905039eb92f068da4da7f2bafe65b1743fc2ac15dbd1dfb50b6a8b890fc933,
+            0x2aad30b3fda588c43367320323c66ea6cf3137cdcf1306e93d173f1a5f5bab0a,
+            0x661d95dafea3da65844c73147d86b8a152a0c737c6550d2a590597b6be28986,
+            0x149f69bee6b12529d2a1332a22ff6cae413b864da5232181dce528343488fb9c,
+            0x2f40107da2eba4e1d816cf7cd488861863a460e5e00780c3c07f56c946096b24,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x89517399fdafcc090ffacbfa0f82b1a356c182a9b8bee5a125afa14416693a0,
+            0x1eb0320ce68e5c0a8b9b6c8ceedddf2eec4a8dffc775f43aa9545f4432f1597,
+            0x9b3b380291ed46dae5ec6779af517d4c8253ef609e78a3611e09a6a9ebcfb76,
+            0x2712ea45ea88a54e4899de133f9d02454004209aea0434ed07cd33c9305c0107,
+            0x13e4cec6c5fcb7a55d2c5c9e0dcab0ff3a3f7c26edb5c0c5f5bc00c036817e9d,
+            0x132f73f3a5a70fe12bd077c340752e6837ebebea4e7e8c06672c3e0c09aa2436,
+            0x24f5ae848c7765ed4cb20417114c602e8186fb02d209b22262ef6b2f9f4c2d4f,
+            0x1f3203e2946c3e784da190ea76628d98ce46cec50d7720c6289b9a10b029102b,
+            0x405b17b0927364ef8a190472cf69cc8fb91338ad0a037a6ccd6b71d3d8a5721,
+            0xd7be909c6d203f7ebbb26f688c104599e34edad7bd4fa7fc11c6be8d2005234,
+            0x23b843266076f360c24e39af50a5f74adf3ba002859b6bb7d503abf45cc9d338,
+            0x12ecdca40e7a5ab513a78862d77f90435ce4ca0835a966112e42457c93520039,
+            0x248096c473071c7c2d5c8dd84006c245c6152e0f86221d82f9d0b2ef68a0c1ea,
+            0x1200227f631558e2d83c5b6c386dbccd8c019b327190ae6c21f5e6ab44bfc644,
+            0x1d757abb199a6c84d960aab443cefeb6d6e433b5cebfeb198f803eee3effc0ae,
+            0x273c19ee6be35b4b8999349c7b7b83cb57aa165f0b302a2d852be61e83409d9d,
+            0x2d1ca26ca5d5dce1ea42db19426bd074157d35e28ac98e9d0e25cc710354ed88,
+            0x2ecbd2ea29341b707d79a20744740982390655279542f9837e77f89b127d4a6,
+            0x266a6643f4b1c323fd22d8bd34c4f9c431032f05b0c856e107d92c70d4bd5134,
+            0x1062e99d5dbee4ab0c047ac41ccb0121b492e604fe10e2db4ad43ddf677f4266,
+            0x15f2b18d006fb5f2bf5801f8973bb94ec3d4b03e8d656a59bc09954783ee2b6c,
+            0x72368c0d5eff7b59f5b07b27540e85ea042a1c80ef063554f53982bc581dddb,
+            0x17aa521645020d9a4914e5679bdc70c0772edabae0f82c0ec5ec29289e0cf286,
+            0x2f968cd2126db9260be98ac5a64250d6b1dc60db752ce86342dea9d7d6eee209,
+            0x1824ed09caa77169c3188a0a3287faa284ed7a51977826f1f64a1c2be32c909f,
+            0x2b8fbabf299d9da38fbd033dc61444ae2500c1205b785a5fab8996dd9fd2ce68,
+            0x1be598eea60828e10e0c4cbea95736584eb83c6ac8427320802d9083f5e6dd31,
+            0x463af34caf20c7b2cfc3ba540ac128fae440690c1fbf4bd815ea2b854183ea5,
+            0x2dbc1aa280bb43c06573fd90ab5f0530ad450b992bcec2797ce0adf60937ebef,
+            0x2aa7cd41625eeed2f8e460ce63d2bafd64329959d40cc2e6fe1d5c48be5c501,
+            0xe3c80439636f2b40b1ed8d33f792f2a5d2e602da651491913ba45df63e777de,
+            0x3ae4d78e90fa89f943dc0b4c56d32f5c846734071ea1bf6bafeed9e83f40f4,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1f3ba6f2a0ace67807ff54fb3752a740b90d4098ff54718df07cf6b99b4a3611,
+            0x2b2d8688621a0b62968c64cab0db27f41a51b32a84980ef31760d2365d2c3c31,
+            0x27ecb287f3d9aaf1137d4058abd749febc280bdf70dfb7e5b61a7efbdb32371a,
+            0xda7a17691f64048331fdfa135dc56a636b1bb8e1c08ba7cb06e9bb1a8f5dc22,
+            0x228e87cff48ac1eecddd22fa3f50214fe0505cceb58e8aa515a9b21a22cde940,
+            0xbb1e094527421fde9a1229ff4878eef766152df2998fcfa44ac7b71906bdefb,
+            0x2162e5b127d7ea5fb675aa6be31013c2b9d9429324fab62ba9ce1ca21b3c5f2,
+            0x5e7c2a9c59abe90189615a15ad93e146c27642aadc29e4e40b8dd9cb735f4e7,
+            0x3b7e7cd0a61c8a953ce16bb6adf8f61f49b560e1991497ec3af678413535e12,
+            0x2b48a6d7de08553fae906852fc7fb1661e6f5036185a3f1a75c9a9abd0c784cf,
+            0x1451c962e6d5dd24e45dc7e078dc64fcf59634073c13cbdc5b8792a51ffb8e37,
+            0x22aba4d49ebc306f4b7b4e2bc7b7a1ff4411d89890f9fa5ba2408cfdfbfd18ae,
+            0x8edd76a666b9264c34b0069c62d2cb61bbeee55882ea1625d3e178544cae4a3,
+            0x1cfa9bda9fe33f9db0b1d190eea07fb0dc6855b74ef166743abf80aaa1504fbb,
+            0x21825a8220bc43bf14b06dbd2b92424547a3fcd0e8b0d7ac7543f56382f98732,
+            0x22a03c9f4361294621f902a43008812d5bfacad871172c3004b7b58126690dc0,
+            0x2c4d459fcf7b58e7d7308af04d943530955cede00e37d3ed491b86f05c49beae,
+            0xe099659a946824830b1fc5e17d4d60343f2879ef488fa45a9e3b3af3e80a143,
+            0x3b256a5437fa8edaf6d7bf9a7b2e695f06dcbe80aebdca4f30e28c8c4a49882,
+            0x473c1deeb016648a6d5f3d0fa4bf31d1d4b9b6ceb0c7f4a76051515104a617d,
+            0xa21735e2b1040d8dfc4685c5c5a42ed07a02c216465ccdd3134c157361995d3,
+            0x1a0b96ee186897808d9130525778e13d2259a406282456b2edf84434e081716,
+            0x110d5d3866aa52ac620b233dc0d892c39f9e376307a7310c994c8aeac1233f4d,
+            0x1fa9ce9d08bc9ef43200929b5512236852d4fdfb607f5ef24ccb666dbdf053c4,
+            0x8b8fb57cdb79ddadf41dd3da20efbdcd502e89c8e21323ec99f0aa99b27dfea,
+            0x20e451f487bf7f30afe6895258df980c732440567ef2be720f683b4d9bce93e4,
+            0x18934ccd6b94d3d27af8fcd8f02b3b2aebe21465b9259c7def51799f1d971901,
+            0x2502b2fcb6acfdf7bfdda3e968afc622b949e55d567100c4007fa0b9405936e1,
+            0x1e22a9af8fdfe9185346e22a28e4fa435f64c8e0f382ef20f27c0f19df51e520,
+            0x1bacd78770219cde479b8dee99d460c73a22f674ed0066ecc55d2344c72a0fed,
+            0x1c5dcc7784cb1a230304a6905b05621618b89498a827ea77293b96d8fad9fe3,
+            0x1514f7a6184d2f5de98511d358572d7d89d33bb2c6d27a5fdd768178af4d7789,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2871dab4aed8cf27bf0e9a2f02f0e7f9c46057ea80fa64d358c4acd2bfbf35ca,
+            0x16b48bc071b2d9d75c6715e959788a5c2c634a7ee951f61c6c252f9f4c96e139,
+            0x2423991e2cecb8c7d0cbf1f6c75a96fdd9cc3e1d3404891054070888cf58c027,
+            0xaf6489dcffa0471166ddb75d46bcbae57d239e90051d360100acad86309bb34,
+            0xa8fb4c80f28764fb489926f032e0f6bd6bb878ab5632b94e6f960e841780072,
+            0x2ab3c31cf9ddab37f0742aaee26190292952ba391eb6764ed69434d0553085e1,
+            0x128a537033583b876442e4b5274483d0e766a01ee4ab310839f6d8a66c052ba4,
+            0xec7bfaa62f8146ef2bb13af733cea64631b21106cd47d456823b3da92e41530,
+            0x1d26f27900c3cf2629a540caa3f2fe0896977782cebec4a7c5fc610aaf9f288e,
+            0xcd7296fc0086a3895770b3d0a7e27302c80383a017e432b69fe2503001d14d5,
+            0x5efb5ee8e22ccf78945ddddeb3f6ab0ccdd2980aeed476369011dd2017d2cdc,
+            0x2fd3058e8276c3e1044102e37c8bac9f9ceca3d4898dec5227152bdac4876063,
+            0x3041d0de272cc4007331a1217ba0462b41f9396a251407964e90f77d20d2be54,
+            0x22b44b6dc784db7a40c2e670800e462758b5249d78921516293fe1a51866ebeb,
+            0x1472f9c6b744713482cf7c9f2c82edb0cdcb81f238ddb5305a14e164909a963,
+            0x11cc50e647086a21c18d924e5cb407e0895d44337b760d95fc1254b690b857a8,
+            0x1f6870318a97b3458482c2b2e8f4896d1bbfab317d95478653847bfe27f73a56,
+            0x527b77967bb4404a5a78d8e449466ea5dd85d36d29792fcae4ae26f30c39253,
+            0x114776906608a453804a6ab3ca1fb1357ef1e68772ce78d4fa53c219b47c4ecb,
+            0x227cabf1187a8e8c8b983e4452b407d3ad0820e9cc000ea38d2298cebaf5ed10,
+            0x2cdb16e7154d3366e88217ff94382b8a7dc86b47ecd50620b65ecd5f98aafd89,
+            0xbba92a567cd15cd0923cb79ec491f17595d6af80463e9b7e2b2c9c6e662fe41,
+            0x1621a037774eb85fbb2ae136893924aae5ec0394764f2bd204e6e3c2cd053e66,
+            0x1b2f4b4974fe9c4d2f6ba8f3b51084b886a115dada554e313910e6a0a2a736be,
+            0x17f058954543b8005d9e5cf0393b669790076e523dbb5bce473d67d98b4660a1,
+            0x2a131d0e2c1938f53bfad52e5fb33120eb12d9412dfa7c2c79b20a4a9e618a96,
+            0x1e1f17b82c8ec06747b63629d99e72f5f3cbebe8bded20c0bd7fcd7ff8422321,
+            0xf92dae5b5070535247aa7062d15dff0dcd533f7ef798556b1f704acc72a1a91,
+            0x1e26cb1e67c4ca4884975a5dbd44df8c05f6a7a813d9c3267fa7f735cc144db3,
+            0x278e469316bcd00829620e438af377734719124f83c509d48472294be9910f9b,
+            0x2d931e21c6bd70dd337a21eb006cccc570c8e248358e256655d4eb409db88256,
+            0x1f3aae749c86c139151590615fceb9b55d78b0436d6846e4ab2c30abeed628a6,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x164cecda3aec3963de5deaa919a419e7c3e7ed67b00ed3fe37c941bd3aceec41,
+            0x1ae5c087043dc196e76f2c1fcd004f07bf7622f91480c2f43dff37466824e28a,
+            0x206d121a5d5c0e50c6696a4f6a3ce23d86e842db48b98006111cdf9eb6501362,
+            0x273853516d030f966503bed07d9bb25e9a78daaaa8a16dd46ce4ead8b0ceb92b,
+            0x2a473b17daa8052023496f81ff3471c76bae27ed780b23b659056288f9c80e8d,
+            0x126700ad12b26c87c8f7c90e8a6edcc613530f09d04258d1d0ecf0732d143cf0,
+            0x70f6900e211a2d3ed359a44c1949447264d51580679fa84dace529a0de19d42,
+            0x1d196536166aafe99006756cbbb15e621903ccfb19346cd45ab951b01348abd1,
+            0x16a6413bfd363eee8d28cedff00c8c86e15745dee50b2ae15d45f4d796213d15,
+            0x14fe39f6bc1fb0e0a41f9cdb142b86ff95f1003519cb3a77a05e96a30153132c,
+            0x2f3719862194ed2deca377a1f1b58eca9aa0b726d3d82859ac5acb5513159f08,
+            0x2ca365f66b59cc38857d65e1ab5a841574d5bfbcd0f9c2607b704232d7d85a02,
+            0x1823d36e1b33841eb34a4601668596fe20e08c28f8772ca3958fce53be2c6c20,
+            0x15d27279b7f1b7514d007345f4702852507d07b64a2f1665718efe5b74578898,
+            0x11b3efafbd53f96ed7d09373534f299562335045a51e43cb1aedf4002b7d6bb2,
+            0x12a0a91a6025546911068e6f50fdd1c6e368a52afc769952c4fbd9734f5004b8,
+            0xa9d7fc64fc90b912b49748faa4a4dcaeac8f3e15df09fc92f7066b55904538,
+            0x15371b75e8adea4894822544c8d7cb6b670741aeb1f1c465e35786fc9c645df8,
+            0x25fb2eaddcde34519e511e656d51a90db8518b6375646ff92caa4a914007d517,
+            0x2dfbb6f1e212006c39bd89dd4a6543eb0fcf94882febc1c958eb81012f17cc53,
+            0x29593bb7f971b987c1efaaf91cd3d70478b3b8f519e210d109413adc4de72807,
+            0x134ce1956a848bec4ecf9b6033710c655b425fe7a2e42a9143d989c876e07b6e,
+            0x232e589b327424a374dcc64152ec03029cbc6b1e6935e1878c89f7daca2fb8c3,
+            0x2ac4f4d9d1ed520e21fbfde98b4e9169aad8f701b95f7aa6e1a2799d72b599b,
+            0x13843ac1a48019a500ac2aa8313a9143b045dd338120bfc4b4e91c1750b27bb5,
+            0x123366fe683fee8c58bfedfa072912dc1bf50c906115880d4954763e648a7c92,
+            0x147bc77d1f7ef7f0604a669c3bbfa3aa535711a43a8ebc25f786db8c951dd7a9,
+            0x2bb5eb86f2837f69911dc3afe716c5fc897ed54a1ca84c7e473a92012394166f,
+            0x25e9535591df883d7704dbcd8ee87be36f7a40fa9d360b8dfb5a38892936d47d,
+            0xcf22a6787e93e4af1d585205f039fe30280460e02c64b4aa6a0fd361fa09210,
+            0x15daa89536023119f4f32836140088bce9082cd32db18edc2a4b963ed61665b8,
+            0x26a41abc8b0969da23c9f511b4a47a978406ed147fb0687d146ff73f0a3f2908,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x24603e3d523263ba69d2161f7bd3c01b990b96aa479b47d8e7bfda5779b31a70,
+            0x6f06827f0a52b2434751f1bd23bef70edc803704890114a33bc1b173cd3fa16,
+            0x18821acd1d1a183b3974714b4c15b9aa338da2999ab219a65ef04d6538c9e681,
+            0x25d1c75c19bd34c31e5dead0dbbabecb70a1952af3b9acc945e6bbb7af79ab85,
+            0x2d16cd48d5eb9d3884782960fc5f27529562190c5c9203f1b0b220b07ebe2251,
+            0x1bb2eb154cea451a7591bc895cf9cb65658133c6f63533a7b45362197d883e67,
+            0x2c1c099ec563345fddf03a6c54e2915f1a7c890b6554cc496856553d2b2173c8,
+            0x14de7c8a6f75d5c098439608aefd9d3f2224fd7ff2d301c62ae728c13cedcb56,
+            0x2a12b1666687a8f3a14e61590ab004587a058e42c5f45840bcf0c7a03487f34c,
+            0x124f681268028f4ebb6678e070951caa96bcaf09350bff4f72c093c2973d16ae,
+            0xc61ee197e59676973cb1b0dccda3d618981b93d24285440f223146a7aed3f8c,
+            0x1d6a13345c16963d0fc372a33a3ccb9d7113e42b8336ce4a0cf68c6c1c3bc24f,
+            0xe90fe044265e093e82a00cb140c9ec848c3807ca216ae5ca0608b360547e72e,
+            0x28a0106ab648b3fb1963e8b51f6a26cce8ab62d75ab26214c389e0c719737002,
+            0x1903a3f14cccc405351a0a3ba23106102830c134d14c378226d3a6599e75527e,
+            0xe69b6a45f98dc94d36e7f80045e56fa8927416f96bf9b2b603c32c6d0026730,
+            0x24028083240f0415ae27d250b5e9d2611c5baf6b83ca01c5fa08b2c3984ba37b,
+            0x10b97d7b32b7541cddf569d3fa3ba4fc792f67fb4bc8abf142bb9765ab3fbbc6,
+            0x18514e6b6663e92d0b702f6830542f841872a9865e8116b68bf03d55352ed948,
+            0x7e84a91c22df5f22e465c35f665c6a56c7d41e6f20f3d63589aba4a168981a0,
+            0x24c67c3debacff4c75f5ab6011d39a6ba905a78980603f9b520dc5f07826d2cf,
+            0x2302d72a48f7284aa9dd46013f218acf1551249c22d8331dfe48c181a06ca28e,
+            0x1332fb9ed5a5a86c5f70cfdb899cd053af1cfb9557af1a5137be1e727e3169,
+            0xecd3e7955fa603af46e69fcd1699d5d57db5eac3b9095c0c7e0b6d24dc7f542,
+            0xb7012f95446a6e56b35ba5feabc8183ef882ab5e99b48dda6a00aa4b5282ef4,
+            0x2d9a9de40201e8aedb6c83aa64d6801af749b464ca23db2a743bb6df13c72986,
+            0x29bd4a19c267732d1f213a478c9c677a47804a525df520ae995bab6c79f0c375,
+            0x1462f5ae05431a649833f4d33d7199c6af0a27a33c6aa74514d706bc5facb110,
+            0x291f96083043911e45b87995cee2d52a0c4c1f1a2537b6e890d293b1fbfc05da,
+            0x411cba90e608a51a8d3635d7e842ff58c4137db7eeef0ef16422402b588766f,
+            0xf7b5ea5565816bbb8c16bfa946c6145d607e773ec10b74844511161469baf60,
+            0x338cdfab4ce8fdc9f081c77f3b7a58f5331d3220cf548229c8bdc9f5e49baae,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x124f60ff00a0e62ddc0a356926a83b8892a7fb8602d5d3b955f41f9134953107,
+            0x7ec673039830a0f06701ad707de762e97de268ad8218f4e771ccfef70fcaad6,
+            0x740e5d063abce69067b719fb33e30e4b3da7b6c66f26bd2d7b5320a04dce396,
+            0x7808acd3ea0c249f88efc1360f1c6e539561f31208e860921311b1c29b598a,
+            0x112bf7f10ea174a939adcf38e91511c7c00990bf176d3478ba5c5bcf9c46d89f,
+            0x197b19b25c2afe93631a78cfcbefee4d7ec4f7a5e9c87f5aa30861aa5f441049,
+            0x1ee3070e40c0e0e740a67449c3789b6b1f5b64047b9adc4a1a7f9194a7ed7c62,
+            0x2ea7f970eaef265df0ba7d65c20bf474925bbd7eff4c9af087c38b5bda5c8a40,
+            0x87e362b638c1e17cd837e14f954fc02cc1a020c62e416bcf5106c0e84a42e4e,
+            0x66c70edf98939e555fdc29bc6c8db703afd5f7317a97ec805c1aa28758081bf,
+            0xb7cd01813db20a6c56bee471eb16719fad273719aacdba7c475b9cd9fd6ed2e,
+            0x1baef4e284700ad99e75947e51988f8b21b306e85552c9586159cd2fa62d6208,
+            0x2d70435bb7b0d2242b1bf4cfa9bd48cefa4f4949305956f07c6ce9f40a4f63cb,
+            0x2c9f4b07125840d0a8db29b2c8f723da914abd2357de2d0bdfc761ed1d2cb190,
+            0x1a68c6eecf6121045900f2d146f6e0dc1ffa95afca0130f4023ecc854ac90979,
+            0x2bde9b2172e01e033c899e7dcb6910441e0b26ba61885817c19257c67a704459,
+            0x196364688be6c007d5caf7f0aa60dde7a9d4df5a72201a010866f51d5b8e44d1,
+            0x5e25bdeb203c4c1c10272422c44f883df61bd873a1181005937ac6897b820c1,
+            0xf9392975fb3baceecec89ce8dde33d612f7b51809c70c79560e5aec4ea0f97e,
+            0xb3a94a0d7fa6808d540ea7c94ac84329500fc61c1c921f6e1a02be72e0552e5,
+            0x57f2f77f6f39fcc309ce2227ac987f88020c1156a521d8b4a6298ea3bec1f95,
+            0x287141748ee5782d46d91412095b8ae8a817341797734ceed2fdf000f7bd2ca6,
+            0x1d457716f5e27115f1b3bd602743ddb625242575ce407e78cec5c033380fea0b,
+            0x1393304221b7afe064f39562a25a21c896a65c27cd93ed89f500e9eb5b39b2d7,
+            0x1000b0acd83b8b51113119fd1783d3043017da2eb32954456b6c61faaa2ae29e,
+            0x19c9c7938f860731025bd2bb1cd4add4ad7389433683ec7fd1c2c0a40840400b,
+            0x218bd78be9fe83b8814a959ef810968be0cd8f20ca7778496f52251b1a5703ba,
+            0x2724bc9c179c6b663419051e901b45a3c36d9f59d63f41dddccc120dfc3abbc7,
+            0x1e9130d0ad5daa81b807d86cb977eefe449b9081cdfba59bf8e1b43bba4c1077,
+            0x2d75c84b8825bad22720289707f2709c595d7a5ff8df9b2190359400d2e925e1,
+            0x27628d274cbc76c2bbf5005702ad14bd8b44ab8cdecc65c2f323f232db788557,
+            0x2a39cb3d3633cdbddcd0b7cc3744e46aff3450524dd573b8f67a3c7e3b9c7a09,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0xa09afb1c54f1db4544f6c0073aa43c0fe17ddede4eb2e965a0020b3734b3e40,
+            0x18c1bc97aac4cd9735588413be17348e71d1a7d14a7bf175c8a48b5b85e9b54,
+            0x1a3730dc03e7f844e8876edce2a2d00135702da038a3263faed39d048af8e466,
+            0x25176e26f891655e4ecb9a383846a2aa15bb49936c1fb568519615a0d10327c,
+            0x1190921ca2c2054af278beb8ae7e902f2f9fc032f1ee2e661fc045dd643569a,
+            0x27301f456233aa2eaa5e58ca623471400a5885e066556edac068e8187bd53fc,
+            0x14df7b40c8531784271338eb6101a7c565297bb9fd160f5633d1fe8a24f22b0f,
+            0x201b7bcedc3f893285dd6a8d70641086091db277c47d721fda35ade3354d3756,
+            0xd7ec7dce868dee03f3cc914c35bd061c8c075ab2b3a24d63514e43e61137f25,
+            0x1f4366fbd21731723a6377369cafc1ead066d0e96336a6c0cdf44437ac6999f8,
+            0xd4f720bd1b1d8dd2da533015643abbe2569c2142b3827f769bd4c8fad9eb7e3,
+            0x2555325b985eb37f57ade931b07684d313c5fd72badc53f218cdf3637e28ac20,
+            0x19577c98ebc619f92a0ff099cf5c3c78b18f4e5230eae7db5e2f88a18148bb4b,
+            0xaab15d18bc399969878f0303b29e85aa3ed5b5f0d302efa97073d0580bcee54,
+            0x15a5b74d5f80efff02db1df507fb260724238371f9da217db249b80650fc2ab,
+            0x7863677bac12d9c8acb8e235fed719eca74497e0c85f1191132e72f877b4594,
+            0x4622dd48eab686a6312f00bac77e56ac609832c1a3710062e2d19fa13b25059,
+            0x1bfd373a0dfca60070a9cd0c5f70106366eafac34d74cad65149841c31e57659,
+            0x12c3c104d455c723c30a2582a9fed0478089ecdd6256a6a14d5dd3a73e57e58b,
+            0x1db62d5a9783dd6e3721980161c8e9f40b29066471ec2bb395b4de71521c9337,
+            0xa1338e33d0d79c8c1143c1e94407be350de016aa190237e0fdf6aad194ec3db,
+            0x230cd81310a9978fac2828de4ac38c19fe35aab2179f1e83a3127745dc709846,
+            0x1d46545374f8b8117fe6aafbf40c162cfa3b13f7439191c43572ff8ca713d874,
+            0x2f0bb6daff69ccbe41e11635d1a451816c1a39e3baa7359493754111c0d453d1,
+            0x29329695f168370e3b3156e3ae2824a662edb778c2a23eb016d135caf72cd9d,
+            0x1b9f8f4a4d8cf0878c3b5b57e82096972b7d773a197b6cd412956d9994f42393,
+            0x1150ca485896d1fa88445f18deff9e46639579453dc8bd952deb10c53fc69025,
+            0xeffc5e98f228858e49ca15bb98312385cd06a57a898b82a561f6fd9b5af1170,
+            0x76a9c5ece422164d7689f5863a3752ad3681a28385e022c66dba35b8c87df7,
+            0x1ea44dc1364ca5d1a9c217488e96b1138da5eaccfa62a3418d687da1308199a0,
+            0x22390e0fb5c982881d62f7af9255b2c677559b525e70e1e993120e39cb386fd7,
+            0x283880c9af3c5ee2ad175b97a9110e904ea6f1172b0abedd8726a1942bd21baf,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0xeb1b0ece2af5cde42043430b9c70ed679c2bae1000903072551ecada6dc0a6f,
+            0x2da6e90774ac9bf5a07971085698cdff633c28eb52f2f57935b712c406e37066,
+            0xa8125b935e8da1db2d1ad9a841efb10fab0966b438e0a6dac204ccc832ba951,
+            0xd4e3b2440602bc4d019da80f29ee2ce86a44f098e32e6a47c512fa73173eb0c,
+            0xca753aa57fa52ba572587eaa47c18ad91aa498048483d9a019457d014ca08e2,
+            0xf9ea814187bc6dba58c6f7c1ecb3dbf62ab2ea29d075afb40fa75fafda6ccdd,
+            0x1625e36facb0ba7558f4163e2f69b482cff1002b6e63a0297dd035b51126e214,
+            0x1a8f5986c3af479a950f2f78c1cfb9e6eefc693568db3215ba3da8b95cf59997,
+            0x2092ce2830d91cebd97e69ad4aacbf5947c8edd9e809d33aadff0a9c44c60dd2,
+            0x2c34396dea567e1a3b6bbf21518b8b78bd08527d955ec8c3f71c153351975a48,
+            0x27ef5d907c12b2473a024ef1ce2bf3770bb767118ab957911608ab99f5011e3d,
+            0x1f290b20bef457eebf0ccce00bbc39ea19ea4c2625e54e0dccfe3db112e067d1,
+            0x1db57788c30f2f18fff3908ce919ea10ac851b862b505246e81d61bdb51e0f70,
+            0x2b041dbcf7846c4e72de5a0e5d201fa5306c8e797bc0c43702dee216497eba23,
+            0x22a31ea557261176a10f8036c7f9aa32d7392a33e64ed90dae1fa3d9800f0077,
+            0x2eced0082a7ac90051bfd190d97319e34021bd571d994f4fb633c299759876bf,
+            0x171f3f295c67c80f97bb0678ad05c216e6df17c46995c7c8f801811b47f75db9,
+            0x26de076f9b9cd4cd8e7f4373b3569c9c2ed867b182be695528c71e1dfc34553,
+            0x18684d0ad8f841fc32151dc50ef602e4560b286339d9a299e6451d535596f41d,
+            0x17baf0b6d89621ea69420282c32f94ad3a52db7394baaacc2a1ca3032656b834,
+            0x19bad38eaa92c43ee1bf9289e9e66e32a2856a141ef2e36868975617765c0a13,
+            0x52eda69d77234815d76a5a9b04e8f7245b9457541c4145d00fd263bcf9ac56f,
+            0x2de5e640d8c2fc3acf28e99df17fd56dfb91fc1091d304773638a453037b17b2,
+            0x7b075e004bfea80e69fbe1c460586a50b260289becc26cc92ea6ee18ad5c897,
+            0x24ebb38197057bbdc006a2ed6d1c280e500539f98dc53f83c2b58503bafa8ca6,
+            0x1ce51573e24a435d75b654a1bb80df8ec38f12bf9660d2abad366ec89770c3f8,
+            0xff21e9bcae93244b09bdee7feb1841219d14b6d9e8ce6c5aa07915b5d81903d,
+            0x9f7f1cb180b8111b6a3b22458cf94dcb289ef8addc4adcba913d99567bc43f,
+            0x228a30bb9161835a3ca58ead6b9752d0332fd78608b1412a402fc045ef430f,
+            0x15e9b1e05851c96b3bd7f09459669d852e65623f1b68f9f597ab7a0dda5e208b,
+            0x196b3d652ca59d59663696ef17988ba14ada02ec506cb7e4caf2706001953bec,
+            0x1c8749855c159f2b4cf83932f39f2676dc56258d3cbfde31d526b4b5ae3eeba0,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x221dd8a7d495ade1dfe6a6e119845add28d4fca1736fea74f367acb2f0c2c6b6,
+            0x4b42317716dca3c5d82adef996100935cf38279042de9b6bf50b29f6a202f34,
+            0x475894cb64dbaa6fa6a2ddb74816670bde6ed2bb1f535a9d5f86348369494c6,
+            0x1c3946b391ed069e274939cee866a5f3d4d7dcd44bd28c59bceaa7953ba45dd,
+            0x1825b793fd2ed840af6848d88c10fad3c14234a7dd3834121965a11926c5ce5e,
+            0x282ec6f6215907e0cbece72ec50a5a90a2f17c3f514d85986b9983bb68f73cb7,
+            0xd8f7801683a6488f5d54d9289e6cf33631007771a3580746446e05d48ebb741,
+            0x1855412ba202a2a97b4bc4d141fbd547a4019f23cda4da726fd1aac4d409f48,
+            0x1798f1c6901076abd77d7c40b401c93bd711d58af1b975106de72a6f6e2b250b,
+            0x2edd97865d7faa4649469ad96a5e0542c35628e903e2be373a0ab7f1ca5a207d,
+            0x13676cd7961ec25b87f7ab8b623d2cfad86cb66236386cce469386fd7998d956,
+            0x16c0a91e9e9c2769401f26728c935e467693afac35f6476d7f45c3593496a4bc,
+            0x29553d069f113822ab939a807c89614214d5866a2fc17e32d21c786ee26cd91e,
+            0xcb66808581fe375cd41bb5410977379265c20dfe402d5400bc93ac24b4b03f3,
+            0x243dff648c9f0c7654669b0628882c9309e5bc28587cc2b239bae21dbfaf03ee,
+            0x2e171191951cef52833064fd4d4067816f2e9c892d7ec9595fcf15286fc58306,
+            0x2bdb95923550209fa7cba2a746f0c2681195b0eccc5e6c253227b62c657e662,
+            0x85aa13a52f4b623dd516a6a478fcd88e30c39642c22f7dfc0e4723e31fd0d5e,
+            0x15f5dfb2f22e20cf08c1bf8ca7fe18ee12607615c5c3c1a7c2c9fe740bb9990b,
+            0xfc58949bd8a136c38c706991c5288511da276d6fab95ef315c7ad3043f5f619,
+            0x284e9569fc8ba77b4045b856dbff1c29eec71e850bed17e1533028e2d07cdd8d,
+            0x5fb97885d94f32e89b37ed816cfe79118ab5f70784b3a546a50c32c52c5d7ca,
+            0x1588f5edd5db73e9e42e1038f3e6817fecff001a704d18fbe96ed57022d6853b,
+            0x16814981024fdcea5abca513e5674e7ef7573813b650daaebf34430a930d06ec,
+            0x1b0b7c044e5a9cc60631dfadd62bf75f7976460d0a1ddd54c91f5ac00461ba9b,
+            0x17d68098ed44b6a6c42a6e7e6f9fe2da0ac7059d1ecf0b26eae01afa117931be,
+            0x6a32a1b358cb5288830b273671306d6e1af65718c3b4ef1a3c2c6ddf0ebf48,
+            0x124899206ef866ee3d3253024894741166f53f48ef7f86c2955184d993cb6d98,
+            0x282d1b8005e7c5e21adf146bbc3a80a41207d1ff7ee7b3bd2c3e6bdd5bf3121c,
+            0x2ba860b0e392214dbee6ff237989665c30944617abb4b31d64b2ad85f397e33c,
+            0x8dee425c9230a537b33445ffd0f032a8cd335bb0a6c95591e1bc641cfb5dac3,
+            0x13e1f729e82032ae05a37e3eccdf95591b61a016f5cdfde65b9d61c84e0f0a09,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x234c770889eec5a24bc88f5a31d56e761f7487199276c8a6eee5b1a68997812a,
+            0x245bfff7477831205a76d0aa1e9c55d24bc04143b3bf5dec9010569f945991a0,
+            0x8f4069c0b10875a6c5a474a6632faa9ca5a971d207ed0895fb92f8ab363771f,
+            0x837729d4fc85301d6b047a6dc71d2ed7ba33ee5e25cef22aeeca59f015ea9dc,
+            0x294ef20f328ae6852d7f878918cfdce9ed950be58925d997ac533c91d5b6afd5,
+            0x1f62b4ba6e7650e883f9c53c12adb7ac418d3d48a7514f183218c8d8c9f2e881,
+            0x88e62ee0805a12f7512c58ebbbe7925c8d94d13ccae933af8ce5ad1d9c11fc9,
+            0x2a15acb799a36536698c1471b93d206320f2721c13a32df2d30f40fb9b1fcf4d,
+            0x2255ef233b2e051eb8fe5fbb4f03d5d0450ab225f926cc2ddf4e0f0d9de599f5,
+            0xb3324f75f50fba89249228c37f2c9a3263a1ba03c624ff6b41d1c0eea4f6f7a,
+            0x267abb876cf130e5ec0e545b41cb614e6b0dfb5eb2b668ca6ade5220de6d269e,
+            0x19040678722dac94cc568ff3c0b9edd72deeb3cfce3f3d9fc81af7d49554afdf,
+            0x9015509267d3d74355f8b8cb583ec4d4c41b01774fbb745ca58b2ee3cfed608,
+            0x25792587eee7e693a2dfb7ed5fd429f501a3eeb917e6c17614fd3cd80b7356fe,
+            0x2588230455c1640eef883b2650dea4b74fa7c0b2675869b3680a867f3f9983fe,
+            0xa5d8e426e8a8633cb0dafabd4f32d946ee6b1c9d80e0172d2a9952e0f85ec56,
+            0x2f47894426cb6983d71c100a0326090c8ec978454b359a02d618adb71fad8282,
+            0x23bda45e45e20fb6c274f9a99c7083fa4ec596ec283a78d1b3682bc44c532383,
+            0x6428e25941cf84268604cac47b8986bf3068257d3be89c3d6dac8f57093a650,
+            0x199d93b935756b0e6f1ea60c72667b0e5686eb1b12d6cd88dad5f5d44d9bf6fa,
+            0x171ce4623f0a49ff1f0b33205fbda2909f9c189b275cd7a717f4a38a5abda910,
+            0xe6db378ce7e1de03348d3f7b7b17264be5adf0995de8e0273c39aad38229a,
+            0x17b2b86cd66a73a60e46511acd7dec0fb3a32d6cb8bfaefcf4479b7d358fce81,
+            0xd2ce771ec4979abb30c8a281fbfbe701aae7112066a813393de44e56161207d,
+            0x86998aa35a19fb86ad35a9116c272887a26c95743d8214f1f2a1fc75050f867,
+            0x5be1134da0692b8f92545cb326deb862136255794fa8383e1d3f266f3162243,
+            0x1bcb6b8de9f866a39768466d15f521cf1e75e1e9ddbc30c05a45b53acb5f58e9,
+            0x1b9e926867ec402e4fb4bfd240a82f240eda7df61c9b5ea3af1984f74089a93b,
+            0xf408ecd2413f30c5794e777b8a0bde7dd69ee0e24a918253e9cefbc7d98913,
+            0x2d7f052ebbb9bf5270016f796759f98056b8928efc35c09fe9e1aa26f18010e7,
+            0x2da951984f4f03171413e1739831201e7346a45bbe9af89d3b23ffa2d615a952,
+            0xb557ec46a7bfb8a0bc21bcaa56edb6e1c0be152d88b57fb5750cda2851c6231,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x13d3fef3eaff9b9563a1827637ad00789268d2b55a1fb6681f8b052d049a3fb3,
+            0x2bc1cc959099f62eda527d7385cead603b637a28c9a223e817c9848fd78f4754,
+            0xdaac8774332e509986178344e8caf8a91c6d01a275b9a1df469e5b735bd5082,
+            0x27773f22500cdf92fec80f154847189a3f75f85e8cde35ce9171225d3cd8b676,
+            0x79c499e130ed874a1383b978dd3c00fd5b6d0c18bf3b491cfd63787230cb9f,
+            0x1ebfdb369fc74d1469c6e461f64206e4907b6f5b51b02496368aef1c54198cb7,
+            0xca9e23d1f4071112543d4e8c1b303865a4064ed4e4110eea113130292d1e299,
+            0x2357dfbdcbc869ea8068bb2ce056854f7a0a765a217af4a0a317888b08ae0af9,
+            0x2c9e7d1ad79c49b37dfd93ff2d4aa43c8532fcc606927e975b21564a9c1070f2,
+            0x837ff288c0aa9cfb3fa7cd38312ca6b83b9b2a3ff4dec506aca1af1176a4248,
+            0x23d8de04d32b88a1b5102863416318011b412b11f1e609386c5d8d87da878e54,
+            0xe2564431ced9aaddde433e7cacee42a04d09d3026f3ca1dd0ee3fb3085adbd9,
+            0x61caeaaba163fef7965cb665f0cf305deeef1642cb63e122d845c5f6b095be1,
+            0x23356942ef4d25d2b3542f5dcb54a77cf17d8fa64ba060462a3b71cb3b73d50e,
+            0x1866373902a9a953c0768646f37941c805658c31f761dd39e6b4d292c8cbcd,
+            0x86bb5bb78cb1149afeb670e1ef3470c5634f10b18eaa25450e87c5a9bf35146,
+            0x2451e0f1a7bade779aaf54dd8a628b92d9cc8a7b7c0074076f860f87be2f8fba,
+            0x84bf3740a546012b610a5bc78ae897973b85c2be04afb32fae0e39d0c085255,
+            0xdef7e0528ea820d70cc9fab7935d6cb5b3f47fc8b5aba924bb237b7077f0275,
+            0x1b7af60a579f6d6f9625a8b0f7c4fdb2a6af598daf08501f155665ab376f7ec6,
+            0x4f92ee3832d8c4253278f77e9ed900be186f8c182a39662f59e4700213c98dc,
+            0x147b948eeb385d71922becc54ba12130ff5643e49f71b7327c323ff0e2571c95,
+            0x367fa68c919ef8c6a24c79f6bba07e7e839c9512b92a690d1a646bce08388ba,
+            0xaadb8ffaf6b02a6a4f42e97afacf2b4d49b5d4201becf3a013dfabfa068b5a0,
+            0x1f29fbe41d336788cf666a4378b1c82d5819c08e27115762277637235b9084ad,
+            0x94397da30fa8ee480cc4cbc0cb3383218cef9602ccd1eb4655071c7bdcf3001,
+            0x16a091b9a5cd952667b2f11309cc4e39f2c6c3ac2eb43465d99b409ab07711fb,
+            0x1625cf4e2fbb6f7a25536a24bfe679c793e3bc01574d8af123d61d6b98ddb0cf,
+            0x17f1ddf6108819ad72aa91411e08264c5a0756eef3101351abd131e8332e8276,
+            0x272ac6af8670ef04eac5d621949f3c4ec7edbb65a38c4bd7d5ff440cab1f7a15,
+            0x2ac81ebdf838c893a74deb1a575c929da0a6e12d2e6e1b0729bf0457cd7e134d,
+            0x28198a6a7de09abe545ed428f83f9ca95a7bc9f91186305adc80d9a561045ddf,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x21c8f5212e43a884a0729986fc11af75bb7d2cecdf007a7175d000aad1c89e21,
+            0x12e4a961e1801660228bb592204fc98865260be10e1e0288460f42b527c486d8,
+            0x9ac00881ffcb7ff45a4f4530d1bf63af3de4c3eb7e8982f354d119d099b20c2,
+            0x22b92591debead5bf556dfd040688701939a2dc72264c1b74c0e7b89b4557670,
+            0x2388a2dfce036d5c898a465ab3c88fbde3fcdf8810c87e639f7abebec9decf80,
+            0x9e2df6b54d923dd12bc44406c247281240924567a7a993e41a6eb027e959601,
+            0xb05fccc0674af8deeab7d73646e2a28df0f4d76803a8b6fe7a2a5f9f444037e,
+            0x148c72c32e02a21dbd3c4859046062f7a0a3a0a9c5425a5291beac5f3f54361d,
+            0xcc72447af3608c9090af67a3a683e8d989688f2239bce43734d5808de3c048b,
+            0xd923c01448dd3098d10140067ab3f5eaedb0a5b73fd6f29f28cb1f33a1615f7,
+            0x9145690a8426952481e9c5f53c587aad25faba2f2af7a38d464c6c86e889c80,
+            0xca36fff3a1b4bed7f8769fd50195c1ccff723fb1bec0db30767e922ed5c5bba,
+            0x151f1a9546c4380ac89496bdc078ab54ec09e1ce303bcf99f5f7237cc7b150e9,
+            0x16c046d8404c441eb03e5c0846fb9582414123eaf996781ee0b7268eb4b20682,
+            0x251c3f386e8e92cd6ecbaf2cc2ad9d910f94135d41466698610f072e718ca410,
+            0x1475e6349fbe26512b79202c02555f0fc6b0df8c74f12a1cf459fabdf4ec982c,
+            0x2b4c00677708322d7af2ed6b2aec44c4926456b2d3829b3517f4064933e85bca,
+            0x8c06b592eaeb2fad227fddcd082cbc40359d7ac8e01bf16f8c907e64c170ca5,
+            0x211e364e0eeca2dcde7b7e5e45e21931fec7898963f20579ee0acc0711d66052,
+            0xcd7ab2a448e03f55844c4bfb6b169790a0c8d70638d7ddc4b5e72375970a738,
+            0x1930ac2e4e2ab703874dae8d6d84cb6de266b11470aceb681dc619889e61e454,
+            0x1efe3fc036da6b22a66529ea8f04651ba88c4a88512711a32f4dcba84952bdff,
+            0x1fc575f7be1400b0d7f57217a0993649494f6fd4dc81af8ff4f469ee25f4d3ca,
+            0xf599eeafe4afe752ab67bc943a63bbd559b10d6d7340b19c5a48feacebedb2e,
+            0x13161ff12c338e5fea3eab7086ea1b5c9e074e8c4343f5978dcaa9fe77d23bfb,
+            0x19e8ce8bccf4d36548905830ccc2f9f13c6e0d997fb57c89415dccef20298d94,
+            0xbad7770ce2057b3cc20f21c93a69b44be7b95403e6d4ccd373d8d855f42d48e,
+            0xd68c25929eb71425958c7bb308245d86a52c4dd57af1f03ec17d73bd14a7b15,
+            0x1a20f6c97cd59c0339e095236fb2955b50356fa59244f6173f1caf18deac4c08,
+            0x13fbd61eec52c83d2dfc6b62cb1d1cb40e71c63fce17265ae9d631de6d683f17,
+            0xc5c24fe6a6fce7831b9c8b2dbc30bd9dc8352c78d4431f5afec5d94a18f2522,
+            0xe6f63bed21f2cb9b2886da97bb0d8f0e155f008c1e5039c2ed7080d6be70431,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x13b9e4a669c3fabe0c43f333992a5f698e08a9abbaad77cd400b2912f5ef7e8,
+            0x2b0cbb582146576933f01c91c0dd2b095a2da43cf528f2273131788f1a6987cb,
+            0x2e30fb85d199dca95475521b50700b699c50f1d7aae5b2de4e9b990780ce29d6,
+            0x4ff7ca87e268b4a23af154c1102c8b705ec4682f08ace1273fabb3a865cafc6,
+            0x23b371ac3c5e45d6d930df789f60ad510b784afe9ee4e82876081ec0ca7ef7e5,
+            0x28c5fc831601998b96cccab01c028d613c200eff1d0e2caa7098eea165c119a0,
+            0x1a649a762e15c9e33b6dd3a4c5daaed08ac2e5a7845df289d2c7ddfdc3771f97,
+            0x1b76809608b2ca5793d346c52426aaf7228b7e4a09083c2b551bce8fc3022a0d,
+            0x249de6f6cd65afa7bf206ac6a1fc864898a5135d0b0efaad0f4c86774a153d9d,
+            0x162c8b3b5f7256af0a7bd83ba37d258ad7d4ab4f29d248bdd00ad36e612f6055,
+            0x3a8b1979dfb950c0451ebba4e9137d78943d9eaf889becd291a669031680d1f,
+            0x1fb9ae665dc60fd17dd0b4284b2eeab0845e6d4a5d6fb81b77e9f7c6b43d170a,
+            0xe61edb12a4174e48a7b47b660e8175f42aa7926ff438c90692e43bc396bc6fd,
+            0x2a21ad8241436a75ee8a90867aade180589a8c9c63b05253be876f192641b1fa,
+            0x166620895a93525094f8bece65ae6fb9e14951d4bf7cf10a2169ce5cbd8b4cb8,
+            0x22f7441fb0e816935c8813854ed5fd6ccce5e7b6a85d91d2b5a3a7a5c8a4ccf0,
+            0x2523733ae5275aa5fb89c74de7ec80091727f495e729ea9bc557516b25e2cdfb,
+            0x150f2ac4f573f5f9eda0d8e65fe866581f1bc11e46acd399cea41dc1ee3b4082,
+            0x2e2c6a081127c11a80d60de162c1d5bd70c9e1b1312fd31f974d419d74e72a45,
+            0x288f5e4a35d6a88e411113e8324d2af60b07aabb48650d27261f9e0172c063f9,
+            0x1e94c48d6ccec07a6aec467ce9db1c7cf2f48f20406483bb873f696cb6139c7c,
+            0x2317555099ef118ac1a6703493335db895aeab6cb1d7cb1e46caaa0e9d74ecf1,
+            0x112b653324919b4300a6e9caa08f3a36c372d86bfdd4bcf10526ef3c2e8c8665,
+            0x10d64d9dbfee84b7d8e426404f4f6302cd2f507c9536559f0050b2b77a15b85e,
+            0xce3409a692acee5372266c97c47c2564d3268f5124fd3094ffb35d252efcd1d,
+            0x1976232c6b5bc6ff77e7c6d266ea390c5fbd4fb3cad9ece623ced56ac860996a,
+            0x85fe99053d3f947a665495f68291ade2c706600e56dae991b62833e75d21c5f,
+            0x253875f4394f5962fe07f784c7fcae1df6d36d1840eaeb0e7c236e3d6786effa,
+            0x811ef3bdcd3c837aa541d0df32d447ec54391911911e3e0739b7ffd4aeffcdc,
+            0xbee1c554f9fc98cfc6b2f986fdf207859d78e2757d199e9a92b1501ef92ca06,
+            0x2e46dc3b30b54925c313731501c5f003aa8d1490b16cfe28bbda33fcd0b9b0a8,
+            0x29a557272646a8b096b2d1e8aec172491852af8f055779779043e048ed8edc6b,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2cf567daf1e32b7e212860583eaa1783d871a1aacc61b1e17274d29d43c3d42b,
+            0xde4e81211f6698cf1b5513963530b7b9d0b8ecc11435e75e1f8d3743dbedb1c,
+            0x2441c69e3451809da5aea5422d4e21637469b4384372f06c5d6d9c14c6680981,
+            0x2aeab770ed2acb63ce4026c9fb0bdea02bcd6d0e45b1c89854c2c827f09f8743,
+            0x18086bea417322d173d3b67f0bbea727011d58a1307664d208687d50018c0849,
+            0x1a5554a104ff43a6e64b7db4766e1ce6df735dd7d5d15bc04b224a81453b5a60,
+            0x2372bbb558acc8f0a26eddb623338755aea1b2793d7e1130190fe2c6ec6393a2,
+            0x10c33d11fbe22b97736174eaae79eba40bccf31bc846d8d0a8b44470c2af8cb1,
+            0x3426163d8365dc4847d5bbf779c5577352e34ff6badab833597ddee1bae3f54,
+            0x1c63281e368936ba2046f4c7f0b4279dbfc02ae7af0224d4bb03d847e157773e,
+            0x2192bccee71b6b955f146efcc1a1781c1e1c5ce24dd9a55d2658f054614751ee,
+            0x465383b8ca4136095399e23c44aa9fb454a47ce6590eaaae8517b97e476c396,
+            0x57e4c25881806bd449481ec352088627fba202db4cd4b93dbd1409efcc8036c,
+            0x9075ad76e6eb195188a775ab16ab65a001ac6eed2fb1455282cbfed80a0594,
+            0xbe868e7bfdfa88434281a12e1753cd13b44df13b9e4f31ade7108de24a409e9,
+            0x2e510e83757137479bf6a77478344c10bb07faba1f97da9c0537da9be515c5e3,
+            0xda0ea6a6106068ef55cda415d30f30ac0e30877e2e03abf618ea2d79d980820,
+            0x2452c916a252ad3c7c27a5257f4c8328d9027d66534d98ccc9a43421d70d83b2,
+            0xf9c77bb51cac4d5ae3a97243b5b967a65f647598197721b487afdf40a7f68f7,
+            0x1f9e045050fa171e0ee29df6cd436b6bf42a576b4ff50c2c913aeebc084f9115,
+            0x2e7d45b66ed46a7205c8af1b5343d1d3fe32f2270741c450069783a4c5be0dd3,
+            0x2516935ea1d2480e4350f961e778d72f56e02b57a98e892b0bad80ff8eebd7a6,
+            0x105de12e7429ec594b85708128893f8ff201f6fa6b6e58a2f85403e04b3e3852,
+            0x1fc9f7ca915a6cb6b67ef53d985021ec23469970c5eaf180b0deb0dece3bebad,
+            0x2811b669db5b1a371c847093244ca2f8d653537d382f16c072df917cd59cddd2,
+            0x117cbfbcfdcd7181ea2b182bdc6a43f72a78bc9a6b1c27d5a4d4f073b525f86b,
+            0x1e8a05c84e5252cb9f3f4c81da5c5419ced59382540f32cf949b442f67512f78,
+            0x24337a6b1cba32ffe53d724439c4554a2430c42da902997c096c26e7a3e88c8,
+            0x2f90aa6e654fcb74227af9060991e0a68d47d8021f7968d384404b9d4476724f,
+            0xb181fc79032f8437c5bf21425b264aa28adc4e92ab14a1e57964c79f150215b,
+            0x99da6058ed7f95fe4cc85f3bd708620f371c9b32c18e235c44b415f4c12bf30,
+            0x9212f04d8281e62b36d022532df405b8e5dbd81c15f00dd094130d43009b4cf,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1107d939e735721d6dbf79d5f3060247a39316ea524ab8c0ec617b2ec201a26b,
+            0x2f1c347523299d959fc1590f33534fc2a0e5adfc5de0fce0fa0eddaf5564cb21,
+            0x149ef73788c5149f643a0d35623cfa246b6b83f3883475060ee613f74aec616d,
+            0x2a8fd18e8e3ded0ad1e39b5e159e9b1298bda05646ac66dddb50e64280889670,
+            0x47dbcd211f6c7ca6e60ad171965e1dd49d07b055b8468d33eb7c162b3627565,
+            0x23ca2270b14221c76b77a1f919764a9399db0dec3db5bd28feb2d363e45de608,
+            0xae18b193b1142e262a16d0d122154e48849d5cd821b8852a2cc2a2e7401e996,
+            0x1857d1b6def0af45ef7d3d24dc7529d2826ffb00bc7c7c7aae74c740caba3caf,
+            0xf3cc84626c45ab94e0b872c3779dfe3f41597c39094884678de39d8c1961891,
+            0xe820957878be6285a630109dd71d5ab98ecf1c1e341c7f05be144a6808961e9,
+            0x1dddf5d71605db9aab02d71866bcaa3f304707010eb12963e30f54270684f686,
+            0x22cb55eb86c682ccce666ec7fdd5167af98a04c5731477cee41401f70bf05c89,
+            0x2285685b32e30facba36b7813a94ae1486502f7c550c49b865cec83f46c2918b,
+            0x89eb80349c3dcb0f5b5624debfba7da90f041de9bbcb5f0dd5e915c92377197,
+            0x1ae6a640e952299c2aed2ffdfeeab32732e9c5e2dc95314d217f0642816be3a7,
+            0x2ee58c48db87e8787a65b7adda68a844aa2dce2ebb95b85a0372219d5469934d,
+            0x18e425f1816a3fd2371717b0210df14a186a184c14811245b0d2fb38e34da7f8,
+            0x2d0b4c00ef039859dca8f5ec2242dee07eb08b40c134813ddd20f1e49cb46003,
+            0x1bbf1b9e8426a43da69f0b718a93348b33ab7bfb49f32792d0b40a1df5791f2a,
+            0x2bca73de43111cc97e7c860ff86c75c29b66c5cafd04f36a0673d0be35fbb343,
+            0x1a77d34364e2186eda96a4c0576a632ca53a8579ea24ba17291eb71dc932e5e5,
+            0x12757dbdd1ec1b481648041f49b600350ed839580fe4c022810e1f9ecae80b12,
+            0x2491a75bb6c3231b90483b0f37596f07926a746aa6884f087f1b7694d191b51d,
+            0x998ab89c76bd9f620abd41cff82b3d34203f4e6af0ee0f32e7f72f88e4209ce,
+            0x2271c33914091a7b0760c2752a12ff2fccd4f512175ffdd949bdefe9b5444486,
+            0x2b76d998c8fb9fd7a192e5bf3ad5948439cc061182456f9ecb60fcec97d69ef1,
+            0xba089d24faa83dd9d34426596f4305119c2baac05c4f727363cc07dc37ce00e,
+            0x168be56f3c38107ab39578355ad8f49ac0a80661977c3a758c29a08a3a7733ae,
+            0x2cdd0f5feb4447b5120e670adba86c12d71e5f9860ec4b3eae28524825ca6e3a,
+            0x36af5faba2b1777abb199b35334d12a4a01a92485d53fd6e9211949c43309b7,
+            0x2c1dcb685cc47c1dbe9db43d809ed56ed6f5f9ac92d76bfb271c10b66b62fc77,
+            0x24633d05c06303617624fc379b46a788b0d69bde4057dfc36eb3359055118bff,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2224f3583f007840f77ac63371ade2a22805ffb999a54fd0feabba444ccebe18,
+            0x26714311d757b433c90cbbef69da79f27493dd48c26aa00892a69f49412d71e1,
+            0x2fcc716f7f57adc4e9cf765fa7d0d6f85b2e71b7d495d12d41657da92d50b402,
+            0x294a3f5ca5239bb5a7b165470474ab58b5a07e2b3da2b4543d2cff4e1f0a1624,
+            0x14b4beb63d909345cfc2891d52be18275fd436dfe64def3ee9a056da6df31674,
+            0x84460af87c46a4276cfd2a1ceafadc83ae5e917669e8393ece9d52102d44ca0,
+            0x141bc6edfd3d6ab0d76ccd6452f746e1e2a04d7dbea197c2ca2a6d498585de6c,
+            0x1e757acda92690643a370b9c69cfeac5f2cbddc70fe984afafa7d8eb1519846f,
+            0x9e92da83e2a6b8bae2a65c80e94f8ad0dd5aadd9374f9b666e5292b1c43edc7,
+            0x28b539f7cf1b63612fe0e3f019dd8055760540cd2a998b70bdf5c755554a61ed,
+            0x4f1315a1e31ab3f8eed8312a43dbd1b4b72362ccd637ed4dfebad3d350f2467,
+            0x106aa158cdedbb22ce5caa3df644bde2d9763b32012a5fb391dfa3a761e2e33,
+            0x205bcd60e27251d356cee0c9fbfe5cec10606aadcddf7dee7b6d50429248cf29,
+            0x1fa4539519ef1cc1bc573c8af5bab6df0ef869778770109f8de349b606bbca41,
+            0x17cab2199c1a13dd4608a9e1e4b3bc4965622d8b574ca6533a252aec9395ab05,
+            0x2c34d65810a7e5a4b851f02a66ac4d1ad54ead2ab633ffdd88c95dd364b16420,
+            0x128745a9a55f406ff9327e97690ef8137648a8ac585b1d483e87be00fb1e8866,
+            0xd797eb05630c87b72ac57dabfd5e897f0679bcf0798652a327bb6a02bfcebce,
+            0x2d49ac3f9e3ac8b8c0b37442e804c4487249047cd6a6ba32282c55ee72b9f4bd,
+            0x2447bb4feec91d4b048bffde8de39dfdf87c8a9a3623cb563ff9d6203c6da1d1,
+            0x790cd64d983c721f883cbb6f4aa15ea76aaa19dc39b1f44c4dba993bc9010cf,
+            0x163a3b62e1a26e8604fab78ff1be0a3699a6b08d329feea137062fdac214b0b1,
+            0x64d9003fc12c06923f798fbc0f49b33a6250e352180eedd7fd846b7f9593dd7,
+            0x1f0d94af29f162d084ad70c2b138a6532db8d967573418a3ee82cb31cc8daa26,
+            0xc30c7df8956774687f81e3881acce5c551fa89eaa5ff7369d2c9b68cf97a283,
+            0x1814723bc7c2396b80b93f41ae3773543a232b0fcc80d78f92d48c908cecc77a,
+            0x1efd30a08cf062ea109229b3bc2dfce564232dc6b181030d2c03ee486bca6d35,
+            0x14e923cc919ce767c8d0c308031f1546740d512c6805a48b81ce2bd7e95cd9d5,
+            0x21d74be8e343e93f759588cd7d29cd64a3afa4ebb48e1204a3d573ad1d56f4da,
+            0x1b8e0086de4de522d5c81eb0a996955ea7004aa6e90d3dc9f37b3bf834b08430,
+            0x17e5a80ec135e0c932f063972d785d9f89eb45ffe44dda9a8ffc11468081645,
+            0x1a5caf74532f2c590fee8503a13bb0ee8e931b6cb92e8f1e52c337f3c7e188f5,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1ac42d7b0a6e8b8f0a097d11d8651798aa5f2676574418f23b7fe6168f28257b,
+            0x1ec67557d1bf0e6f851c89835c29d2334967383b9677c71e10f12ceda3593e41,
+            0x2f47ab58a58e52340df845a782d6ce983366fa669f4d9373f849c0e3cfbca272,
+            0x8f212a5650c4b2f68a8b7a14789198ad2c224facc562e07360904f0adb8efd3,
+            0x2592c7276c9fb4e962b8f7f5bbb95018d17303a6e8a5b513b2f3ef87b66d5135,
+            0x28eee34c1029e6eea0cc12e202dc1f4b50e73865acd6a7b69302a1b45f2c1907,
+            0x11bd9407f0c9e1b9ebe379342b2a426ea14d87335522e8aaa880236f5129fd0,
+            0x169f293f396fd012d20b323f9b3eb45362e5d272d2342696ddf1e3efed03c069,
+            0x1e1f46890d389a50ac16e5422f79d449a6011c5be9e53c266285afcc7f5b2608,
+            0x128da78e60b0758189982ebda43acd77c51eb6455d720455955ff631a922633a,
+            0x1069251fcb9d2fdff50a041154e6ccc7579a360ceab1c360d20404630de5565,
+            0x1ed383a4d6c433c6801b6853b5c40f67cc4fef27c2610aac9540d5355c6cdb88,
+            0x6e9b3357bd837d1a5b8c7598412c78216daa02bbb25970182e089872cea4e1d,
+            0x2fb62dd173e44023b3e784ae457bfc93adde1e08e98f3631c6e01bc6343c5bc,
+            0x204797d9b16d45b093bb34c6ef5e27304af9ac7ca7c4a252134d3b61b6954b4d,
+            0x2fa8b35e4e9405e7ef4f2d80820396ca8f026f3e330775368850d423394b2301,
+            0x10c38e859ea854e2c6bbfe3acd613ed59d70053772c6fd7497ed2d4d99b2907e,
+            0x1f44270853132e2b71724021bfd741e39c3414e8c63f7b148371a921355b5085,
+            0x2eb4d6a5f16de3e5b2c2c33801421c2dee87a222374f4cb2c2fca1fee4fb1ce8,
+            0x71e2443b4b9018d2a7ca057b35e2050e59409c688fdca9289c96444378486ac,
+            0x1423a5126a2789082bcfc21a6901111b6b5299c4f76d341c8b0c2e9dc4712726,
+            0x26e1e7b62d89a75f94630821b5385e6c48a97b8c5c5ae1b3b1f114444e8a10b8,
+            0x14fd3ede10aa7bb382991a1128340eb1e6ce0a8d573f643bd8add5a2d8e8a45b,
+            0x2aaa9048ecdf21e06da241868551cf548f683880615368a6a2cf87554d893b11,
+            0x2e083ac42fa88939d480a976e73c6773d26c4583074073d6c2a9f90071bc830d,
+            0x12cc2a0dc5c021316bc97e26a35a9f5b062087b78224526541f528acbde2d1c4,
+            0x22adb7b0e9d4c335e55c7aff8bca2048a59c0101099e8ab99b79e64be46ecc7e,
+            0x158cbe94e139620090b700f9fdef637d70081aafdf1aff2eddbb5e2f6bc02dd8,
+            0xcb42f4bca1dca294e7e897d0a0b9e6cc72531cbc872789265fa904aac00252b,
+            0x63156236d87d3673e07b739e18d79a22a6f1c99c2a4c3de4b982b5765c4de49,
+            0xb7f0818b640763c1268912be50230493391a86d9de957810fb2d1548397a088,
+            0x2aaeda58e831430d69a57059f933fa5deb7fd04fbedbb016a919bf5f4d8857c5,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1d3a013444e777bc4e816c6f9194646b6009d5ed09931bd8011f5d3bbb01378e,
+            0x18e4924f258930420b1fc45cfaa31fae7ebed37f375a17f1b8ec6e97675403f1,
+            0x27c63021eb05577b17d50676669a6d590535b6114f74d6c14abb3efd3589781b,
+            0x159d12a40b8694d9dcda1149dc98bc3228eedeb19040682a2c5254723a60bc61,
+            0x1c04115e802bd71622e1b1425496f939414737bca8dcba1f070d8a44f6da2d21,
+            0x4d0a06d0ce3dc2ac28ee5f7774898d7910714459b385b5874ac46dde92d79d6,
+            0x30128d834fa6bd28116aa6cc19453b6f731a0970df12416c8c4e7830ef3f6f37,
+            0x1ab7eaaaf3e533054595ab5a16d37af4b028bb6612017235432179802e34ae67,
+            0x2a30c413b8cd102148977b0fd1f51d4cdd2684995eb899156438afb7bb4fdf9b,
+            0x1eb6795f1e63f8933ed48dce55d257dbf972298f9186c56d0880ae76fe562730,
+            0x21d1ef33916e6a7ebe055233c5e38e388ef6e2bfbac5530ec587719182cc0b40,
+            0x9e2af7ab3d9206c3f54ded28a08f8b78396cba9de3d7696964d2529a0517c59,
+            0x24564fb0247a0a53e81946f9f0365c5d45257ecef288d6d67d0bdc91055a80d6,
+            0x1b9ded9f11fe5b6dd79066bd0e16b9253935e8d0bc2bfc130db23a8215d0de13,
+            0x192711d3f80d452839ecbfff6dae32c92bde74d051a75bc14170bc690e69f9c2,
+            0x1b3af1fa25c32da1a5467fef1dffb9cca1b7b92c4d50e3f7ad0548ff2c4da1c5,
+            0x22bcbbbe6b9a39e310a03a9bf0e491451698d4d874aa192b828c1a4fcb86f3bb,
+            0x3a947c69e09d64be68d7bf2316f4cdc647c912a6bc4a936232cb2b6d320af52,
+            0x2d21f4596d98ac3b62dd919550859a7592e504009d268bb7f5bea0f38d4aaa46,
+            0x2b2708b2cafc826207f80189733e6c53d6ec1ebb3c54656689c10a8526967bb2,
+            0x13e69bc7a5decd620276116f40f9743e487cc219df1dc1d769b1aab8eb74316a,
+            0x118aaa8f364cff4865df9535488935c34afa1943b1e28aa08d440a7a7d72d80a,
+            0x11ad3bfa094695c23a74b1f23d9cf7808e7916b9f0eba90ec571e06e4f310106,
+            0x2f4b6c06d0b996fac689e922707ad815b411539f857871cd1a6b9aa34386f108,
+            0xa6288360ee10c1b02a2a6a6d34052b13ce79fa1ca91f8ddbed485dba92eeb9,
+            0x25ddb8ea60be41e7e99c97b6b5a7822f071027932936673c02900ebddddaa88f,
+            0x24c8c87f88b21ea24ac03cf1a498d64157a8bfe27ee0df70187f6d11eb856d2c,
+            0x2f958a89827eb535aab871af8f3e1fda9e0b6dd0541d7c9830321202d467410a,
+            0x2d2b3221d9d7539c627315e2422ae26dab5ae103cd8a8bd19d895ce97e19f866,
+            0x13bddf23791d0989c17fd99bd435437bd8bcf676c689ca0595a0d04afd9c2603,
+            0x2c15a1ae35281bd2fe7a611523dd767be99c5a32a8501ca19b1a8940e1062826,
+            0xcec5e18e50beb5ab2c7f5c9eada9fe3f3e8689b0901afac80992dda3bbf8803,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1d23ff4f22dbb142a5d4465aee8fcd2fbdd8e450d1cf6f29182445d4496a2e5e,
+            0x172ee58685e83a795c76191742ce9df18765ec6f1e9d1233bf73ee4fbc53276d,
+            0x352cf61f75587d4a82226e28ed9a38863d7e3fe6647117cd28c736cb2893b5a,
+            0x1e571b53f1260a7fd4ed79e03d32e23b2627804ea5c038618a239b2873961fdd,
+            0x150d7efd3ec4cb7eaa6703bb78913527c77b07e38c93a800841a123ebf3edebc,
+            0x13cdaeb00438b5c6a40c0d8a039a8117269e15f580b8044214e5638f2e87a37b,
+            0x9d76e8da13f87545b74c5f505af00e204eb2414a186b54e6dc3b7b8c24e27f0,
+            0xb6ec96b7f761247ebbc27f64fb4275f1128472e7ed11e8a712a206cb9e16477,
+            0x1e066da048cf035bcc17fbc4fae18348f4bb1140d9519f1bce81144da499a536,
+            0x426afeba63d285758165a95db5df2aa86932ba9f50314c5f7ca4408bc3eaa86,
+            0x2ce68ba3f40fa50262f137219ffa5e343650976b2d5d2d1e80b687e40e426d1a,
+            0x1e1dbc3eccd20a0a96846877182b08ebdba8bcb16492fcdb60acaa42317ef8eb,
+            0x282ae2fa425f91419dcdedfbe6800a0122a5211345524b9c320cf776a201b467,
+            0x14bde086cfb19372690c53b0e04ad0ecaa78a8babbe21de8a47a796ae9730e5,
+            0x114e76d2755ba6fbf01851955b051cb5e7d677db3fda594d6658ad4fc099236,
+            0x2796ec5da2337effa6fc65cb8536ea82b5e60b14f10b005b07308b52d3011d2e,
+            0x252c6e37471afd938b2c840b2818ed18eb7900adbe9209e038939f883a236f21,
+            0x2b6e07212cf2e4304a307acfd16edc984c170d96e7953460d1cacd3e84dc9e75,
+            0x2adaa99cc0a5150cfdd4e17ff6390c973f2491d4e2723918d35ac55b5deefb49,
+            0x17759cb89386f9365fa875620b6f6e7cb6b5cee2d77f0b7355d9c33ba0e6a460,
+            0x111bb071c2ca17121de11f36ba7cf79f699960dd76e09295610a136afd200e61,
+            0xf394cb8fbdaabd31e43d4baeb5523945e29df4f720d026fe115bd1693a88818,
+            0x241d58e1cf3ed5d94bdaf9f0c463fb645b65fa19c52c193ad67f1d38fcb343fc,
+            0x16713a7b5d8cf3ed4c25d780a7968a80f70c566e6ba208859e6cd69801995242,
+            0x19909ba7fd3b8fcb03b6f810f246f384563ebc5896fd61496737f65b5362dd02,
+            0x2a9dfd2dd3048b0347dd42aef6561a277adf3d86fe83203df1778536e6c24aca,
+            0x18532ee14e86e608555da020892086f155c685561272111e7f4b6c91781864d0,
+            0x2509cd9ebd96c0d7cd88a3bab280b42068691da92e03f6de5930ae67ffe04f51,
+            0x11c0877290f334877a26326ce2e6ca7a96dd732288d273efcabbc0294e2daf09,
+            0x26009dbe4fefea6739e28a0a6fb1dffb35d8516e06914862db8738bbbafbfd1b,
+            0xe9f75fd533fa509a499945055cfdd603dd9930a50634e41a935098d571012a8,
+            0x1f3592557428f40b9e6582536aed2b7264c9166093b76df3ed68ff033c7ff93a,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1befd6dac2acbea83cbc882c661e80b50b85af2021c7ce770cbd4e4cd48f69c,
+            0x2ddb55369f02ada084136f4092258eff0be8e170cca9eeb6e2b65311edacdf9f,
+            0x12dd67091b9f1d7101cb2cef74fd216fbf49d4cf33548e6d8310446e562cb7a9,
+            0x1e824766a37cb1d1c7e75e3f9c261f4aefaaf65080f870e972b14132e7aa6cd7,
+            0x4af8f03823d37cedd40c1791ac745b768c735234f5756d638b200e1c134bb1d,
+            0x1b65a271d787e78382a9ee5a1715c9aa23e3570e92dacd75004aed46b5e4f778,
+            0x1b239d4ebb80ce098356e864632edbe6affc3e5a34d92fb9518ab89f16ca4f22,
+            0xa9f23337f4d86a82c5dd9a9216cc182a5a6b6eb6fc5e42797df022e276846ca,
+            0x86e0f2ecc21e30809e1f2697cd036bbd6241d68668b26efcba5a63bfaf84037,
+            0x29bdb60350b498b5e1ff14f7360deee6aa03cca4dee1a94c4181a28f0fd2a9f7,
+            0x2ed66c1da1c54cb685c48a32d650d24c17162a3c758eb19aeb9779fd35ce5499,
+            0x23731d564560385b611877a371f26ef53a64244728a8e8c5fb7af1d793e0c7c6,
+            0x5d2071dddbfe020a1d54d3be85485fda55e94634c3c7f92b6a0e7df8c54cb47,
+            0xf43e2482200419e7d6bd3242598add21ca3c7a6f1297401a48aeeeddf8c42c9,
+            0x147a84a37131c4e46e9f9ca597b984d7b4a4239425a12ce32f8fd114874a8cb4,
+            0x6acec506161a2536df8657ccae9de73d400b734124368cc4da6fd86ef670a19,
+            0x23ca187dab655ca80e1af85d71cb254f05d27b6f8000e366443afbe83c4cc725,
+            0x2f8a17922cd86c60691695f93bf0f432f1ef9f05e2e63e9532ab277fa47c0297,
+            0x1846b9769a8f327eddc2fa52e235b3c54833f35db8c7989f4342d667ddf2caf2,
+            0x243270c2e4a32bbc19d2bd52271b9a8da3f760251ae2f2d783d2854d749d0ab2,
+            0x29e4f01c0da1655d98887dc01ea2faa33baf934660f2c934187ea6902f5e0dba,
+            0x3e46dd55965a70ac8d048f6ef72742efe897a8a5cac24a0a323452a738a4271,
+            0x3032ada92a06e725cfd5cf71879293c3b862c706221b604bf004900182588e87,
+            0x9aa6962258ba57549d5496104be1d44d36adad0118ce7780f470655e7a79b9e,
+            0x24f4c3f9b2fb7dde23f455ab4a5e76ac60617e46bb7900dd97769420911b59cb,
+            0x10e408cfdce8d6f9b7b710d2cc93937cdb43d86d59580ff5417160745c80b7fd,
+            0xc7e1f9439ed6f97010e5539ecf56bf151a2955f8ee20b2ec89879d81cd24a16,
+            0x20bf7ddb42d4c9d7c8bc1e1b110f065665dbe466145402ba3a3febce0fbfb3d9,
+            0x485724e08555b73d84eaafda9702a639baf4de0046875d1f0cf609a1270d720,
+            0x2e67be03421ab1f822047861a72a6d08494e65bbfd13c3f7fe6ff48cb863749b,
+            0xf79509c03da0c16557c73fb11286f9fddd8f86d235071eaa7aa71a85f547133,
+            0x1df1ee0ab120c8673cd3cc8c6ef2e15d74810a03809c61e16e8bab3f20a296cf,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x214e36f5e05f24b3cff586c96031ae938f81cb8624b76697a7e1e79986f1cb94,
+            0x26e5f56af93c25c1c66a64447449b0256433d47d6413c0b2fcf6210ee5f138c,
+            0xb31a4ad9ec066989d7421b0f1cb06d7683bf5a64e0c3067e0b1a3bca5a64a2a,
+            0x8561474777e7f179341123ab782afad4ff632de09860eff6ebe29e4fb1a0c36,
+            0xffb57365252bbf56569562327f8db32f337001a18e56fceb006741a0de303ed,
+            0x186989821e7ba7588a8634d87210552eec88f846e3701bb336a5b7f0507d01bb,
+            0x2b68655758f842d0aa6dacaccd461eafddb981b75166e55dc1ee2c208308e5f3,
+            0x2d399f586c89c60556a7651f9409b01aab8f7d9d9322ecaedc93c590d9cd0fc0,
+            0x2da5bf9c9e9da4c394519580405b41e6545886063a830437dec32d7f1bdade47,
+            0x2b65554e892585688e54d5bb49e321f507bc305fe56fb780e41d816dd9158369,
+            0x2ba41319cdf6a416c9e11bca8441cc610c6e7e45c2108dae471840f71deac714,
+            0x240f23cf9066f8f5308a2cb0f33e1b40cf634980a9f76bb6ff07e28730868f54,
+            0x231ff9a1222347ab20a05faa8d43bf8cb62f0ff9df561f7af015c73d191ffe98,
+            0x482fa25dc024367c8dd5429b56e7a0736c866fe84ea1afffc3f5d0f421fe651,
+            0x2923732da6b8bf6ee5c73ce34d3ac60f9660eda207235d1d5af9784103f0fb3b,
+            0x1753f96bcf7911bc332bcffd151e9e82248a44517474204b3e9888738e58c5f8,
+            0x15e1d217ad8bcccb9a7b3009f26c09576e9a83a00f3751fd4ae4b396667be084,
+            0x18e3a1c74fd50b4cf58f3096ed129eff1e129302507e6efdcc44c577ff23403,
+            0x2ba6780071d6646fbda80d23fabebbaf0272a953fba3249e3af0b56f22ce8120,
+            0x1f7f5e238b103729627d5c22c78d92ede19a56995972ca46a317efdc27fc70e0,
+            0x2ea1bdf6dc4bb3ba6c3d068e085a361ec8676c6fe2ce66e842885b830315378c,
+            0xa6fca77ea6f6437fc2bfa7f2beb768dd908dbbbe87aa75ad303c62790b34d17,
+            0x6ce49d6e3d7f46d2175ae9a176153bfd3a3b8f93237a5e45ca9c4ee04ebc5da,
+            0xa01cdcd06c3f24187bef0d4a83b8e21a54746f27f0f0d919e08b7cf0d241776,
+            0x13c68e6f75234dd86b9568ea56dd98bce6c1b8d64fa4bde97dcd7562d0a9844b,
+            0xa162dbfe59de052c7f1bfd5a6a0ed87c5d6120d538c40a537ecd0f3ac12d88b,
+            0x2af4c78dae7b20fd7e337e83afb1feae26c555a544d8ca8fc5c9555423fe1c1d,
+            0x2f6c75f43301c4a5bdc3d32fc1d66fdaaa4f3b04236427ede87ebcdcb6c7fe59,
+            0x2a4aa9b8b9464b6ab6c584645c872959c9f68ba65c057c235b7e2fde8160e42d,
+            0x2d8dcc78c6658c1188d60d080fb3cd8b34ee5fd1adccc8a47d499e62ca725b05,
+            0x14d6380547e6c54a017d04ca2b2cbe305a4638b32b4163195b459db073fa9872,
+            0x478b43d35f78cb355796e0ea0e8e9f5a8b8d6c59cd2cf58df4dbac1a55defef,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1ef96c51c2b7b30f1e2c59a13e9e76f079c907a4718b3b1827228823b9d8172e,
+            0x29321a97121f289220eb66f5382ef63c56ab3d289391c4db61c9dacd44a823a,
+            0x1481bf24e7b45de9670afe57fdea41b8beeecfb23422e83c83de9f6845ea9576,
+            0x1ef847d3c1b94f7d5dff4319c81691a1354f76fc73dbc600638472570c8c465,
+            0xc266666de2f8bbbaa20aca7b4af2de342cf1930552784c300342f3896703b9e,
+            0x149bb0f5b9d904cdef7c045ee236bc38a33dab8fab24381bbd14aac30b12ebc1,
+            0x2ee176ae76a9196262b1d9b78ce2247cf2133e707cccd952e37d92fd71d88d9a,
+            0x1376c5573ebb7265f70acb843f749ffab6f69d346c01e8fa59a1c61091e53f03,
+            0x1098a7920a98fb50caa3540c5efc8f6db3dffe9b2c806aeb20501cd0e09a5b45,
+            0xb01cc70e8b9fd48f7093dcc2ba65898771cb4302388e39d95095b446fbf6bc6,
+            0x1b0e1d5d686b5c6879413df5c510fb672a6d6622bee86008f32c0c32d237b94,
+            0x1f74ab5e561a3606ff3b9b334dce7c65d772ca2c1d8ab0e2591d7b8dbbd7870d,
+            0x20de7f8e6a491ab79a1d638f7ab760fc5c27285e90c87ad512e86a1bff3b247f,
+            0x2e48491edee5daef9ee63ac52cb1734aa69e15b68d8c9e0da68ad718858397d2,
+            0xebddc875be02613b22701dadc5f3ad1020a797469a02c064545adfdfb73daff,
+            0x171d043f251b701475bf87b388ee12b5a469cf0b5f4c120b34b7b8df3a50b898,
+            0x11c7c2bb7facd8c4d0e37f220026818496ad96f0009975cade5a85dd0b319d3a,
+            0x2b86058c080559f84c11d33ce0dd77e8f4aceff8644a1ccf78907b6f02f2a2e,
+            0x1bd631d67d9ac357a1dfdde1c92a62b0c7fcfddc06376746b45231878b83da75,
+            0x2cbdd86f5eaaeda63428d4a39c788df7e08cbe62027d423d3060f7a04fe40d13,
+            0x120e0960c012805f36743a540c3b89f519e39fa631ba17d2542d13ef27469cb8,
+            0x8e188acf6db761e26d65404bbfd7a0b5537d4e05d85f819de8bb08b1f9e6dd,
+            0x2da3a719e3b97734dec894cdff62842dbcaf8ffc37040bdd3f2249d32df42e65,
+            0x176acedbe2dc8cdbad093b2a591292b231289939391991be3b9ebf27276879d1,
+            0x15964189dfb203bd5cb0a49c9d0fe330bc82a66e62b4bf29cf9a878b74133c92,
+            0x7e6833725a1a694e290a34cf6d725401b7ba6c1b0b740226bfd38b66acd1b02,
+            0xe4fa44c437c0b7871d7db91fee425aef4dec5461c08cb8f7e8990ab8aa30724,
+            0x2e3f0bedffebdd3509be6b792530f2041b04171e729ddc9718a2caf15af84b38,
+            0x1504dc8d0dcecc34da56ea5522a2bc7960d0dd2e0ea24466b84f59aa5db015a7,
+            0x178c9a3999106b047952fb93395c214125f988fb1cebfffecdef4278a076e3b2,
+            0x1af7832596eef3c4cc8630615883a143b7b6993e90b4332e66f36cdf167bc838,
+            0x2822dceeeceb7a2e1cf3f25a018f8ebdfcfc720a39e370c67d4333e515ddc724,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x25ce0d19840e800b798a9033269b14f1726a4fd660cbd3b6dc3cb39c07f27f53,
+            0x175f82195ac38e9f11db0773887a93338ee07d2852587fb4226f11d9422b8328,
+            0x2017bd7838d0bfa3ea272ff2e883a80e63c7288a4433997b18b4c5f0da5f7e3,
+            0x1818b2d93a4d80ce0068fd9ce46ddbd200b6040399f4355194edc9f2c55b5ac4,
+            0x17c59d81c21e6f83f8972fe07e0ca9b352d04ef730fb76dd72931925c9a78427,
+            0x13694ae68e1c55dd02a5b8c1915f878edfbddaf12b45fbe9fa27a2954b213a9,
+            0x120221d8a84571726473bfc84ad47f1b04ff70e7a8d8e9c1e91e1165e9b4f18f,
+            0x14d65cb6f3b2e4bae5ae5ed1cafb3e68ea86144d27fa8f33aeaba929cfef4d80,
+            0x1a6104dae9627992b627b87d84e656009bb69a3a7a9bfee98aa80dbf21bb6ca6,
+            0x1e3af87bd45255572d1d14ccba0d7b2f8dfd79b79068c6f3883ca9fee52830a7,
+            0xf3d0df45aa7bd62a9768cd20f8466c37b7ec5661968b2cd18abd57367319079,
+            0x13b8af0004234bf35f20a7cc7b9fccc999d0d8e4f5ff6f26c237835a1fe042fc,
+            0x16e0bf0c9a24d467e38c3778c76b2e2250fb1c06fd4659fffa3093f493a9eca2,
+            0x26d28c3453b3d7eca08e87a6c46bf8a698385ff358e23edbb1e174efe5c233c5,
+            0x26fcf8eeebb1ea7b1754c047bac9ad888edbece428440fe2102d46969daae640,
+            0x2731ccbaf234079c1038e6ab182efe0f1dba3c47effc3e21d2e195e3f0319503,
+            0xc785f0fe165d5d26f6b5f2a0ffb7ded4408eb4a92f3eb3d13947eb094290d97,
+            0x2581c7faa23de18b2596cfc15ff01dbc84bea0fa4806c7d1a0abc43e76ee0f3c,
+            0x27e3f76b7335ff9fccffc865fffb83b368995521e989bd4dd6a86cf595d4a17e,
+            0x13234d0fe49f03c4a28ed5ec2b8044e9c7dd20cb831e541b7c540db6c1800637,
+            0x11a6eaf2aa5518374eea4199c11f3d937a426494ba614ddbc6ac6ea1dc804ff3,
+            0x1fcc367b6de0eac68cb524cf8008e6adbd783e8c13821889031f886647664a0c,
+            0x1458038bfbc93c12974f7474afe5bdc94cbd539c913100169cccbdd143151a2c,
+            0xf24afffaaa9f04e88599ed696dbd4eae28447c2f05b997194ec832189cdfe25,
+            0x7c8e157325437ae945c3c67c4c757493076bae3ae720b00d0c35c36453f6826,
+            0x11198181950b4a2475dc01088b72115a94285ffec4c2a5ca614d13b1a14fb319,
+            0xed57c8d4abec5e290ca22be70bc5e754e135771d5348f7d711d7383617ecf36,
+            0xcec6b37e0709d4c9d5a8ce252840ada6dd5fb95603720af648319370941bfc3,
+            0x192f0b18cf17855bfe94214aa47604eecc598f8df429d9c7a9f0c807a467511c,
+            0x10323d6e384414dda110f50d67bd06633361960a357f9c6de63f837553cb58b5,
+            0xadd901bde5b672bead23855ffaa43194e666b932d604f47000f08d1d2640511,
+            0x16dd65f412cf9f1325a3cf4e9a8f02c27371b2c3d90888e7d4ee82713dbebaaf,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0xc86afa39353edb39b52bbff89c5c1a2bfbe2b4100df0895fa7c82d8e77c482e,
+            0xc46613d67d66e8ae31191ad6e5bbae2539169134c5311d25c06ca54e9f3ab77,
+            0x395678f2449c3e1a76b5b9df068e5dabe76e15ba8589e0703efa3fc1244184a,
+            0x19cdd035008146af2718d7c2ea72fa725be2d10efb070b303c809b861b788b51,
+            0x1a047c51c9647354891ea4acb582296dfb90bc65c97e8889f1d075fcf217cb48,
+            0xc6cdfe9a0d4271a15018a2e3f2d80dfb7468e216397e85e138d20be790b2307,
+            0xbc59105470408a58ed2e8816aaed1c29dd3af469e2e7eaf3e1ac366d40d312,
+            0x2bd71a360bc27ecd0f2ceddb797ffc5a662dc96cc64cf15e03e2e63a19aa0453,
+            0x45e127feeab8d5df95789dfd96426ae84c34723fc735865f80d98ee53eadd5d,
+            0x153dfcb519caee780dbcf85d14af1fd03d6888a8f8f35e0f5d16fede2fc3be20,
+            0x14e6a09539291352d800dcc6d07e0d0a15b544460b6a00c00b236fe5befec431,
+            0x2eb026a3350a6d92b399aafa7e52a5e1730d63b9212e6431473dec34b227eb63,
+            0x1641bb238c520d7b2da80d743f6325b013f7f2af04f83162314ca4554e4c034a,
+            0x2e2b3857032c8659c4533fdbd59d3e118d810ef879943988e6239fa808bafb4d,
+            0x2c37d689e22b1f332dc12fcb8490ec1b679a5e15b1f4b9b5edcc16507adbfd92,
+            0x3025a60ca5e0d56b9507310cc9a8a7a6dac7bf6e942883c6f73356f8a0c2afb7,
+            0x7f9e146e6c775ceee72b28edabe0f4735ac136ef900a6147570f0ea6de0782a,
+            0x318bc71cb7dc9d5f8b099c165d26545fe0bbf112167860825c84c180493c6bf,
+            0x2c6fe3f7e18010025df5e6b84648d0669067a473d849b4e181c3f4e03d42b128,
+            0x2bfa2ee15d1c06192533994513500e6386bd767c78391160dc4ed7ec323e57a9,
+            0x12f7e0085d724c9e28547f4fb7583a6b0fd4685f1fa9d8c012baf4701786270b,
+            0x58f27cb9e4bb8bc4df8b66ea9b5a5f8b90cdc72b345c4b0a300b1ecb6e2aa63,
+            0x1f34ca32f956eb4e099ab646d95af278ad8db5cd00ddb1c8a44593ea2fef03ec,
+            0xc73343dbd1d62046a2df0d555812babf2ee35b1fc103bf6938d783ad0b44499,
+            0x18e5fde3115a19d207ac2b687e135e438d915cb495c74a0069fda3370f46083,
+            0x120fde4dcc6a7447775ff4e871e321ebdfea69a589ac90714ea4f9a9608e1e23,
+            0x2d4601dddfecfe13175df8d48155e9aff8fcf449dafa39a245b8d6cb1706f490,
+            0x173632b4f61f2083cbb3e04853acb5bafeec8c75dc4407123e2133c060905ed5,
+            0x26b288e1ff854948e38cff794996597108b335f67b1fa2598c5ab2691a927730,
+            0x2a688ae162bad939c6de4d889910df138d1f7dcc8989d48caf72e1e22b956422,
+            0x160f4b8f49b226f36e72359509e3dac329b1372a7fb63f055d7f9b004d5734a,
+            0xddb062d06f99f34542ed03bcaf07a59a456201d26f15d45b8f122e9565d4044,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x13785c4968bb97c8c769257653ae58a73b94a24553fae0e00988b29f47ab549c,
+            0xec91cce07b1e9b778fdac5cb9ff8d8e6438292781351bedc3dda454afee474a,
+            0x22ad585fe3ddddb3233f390ec3cf43a570cc4f56076ed366a63a50b493a6d655,
+            0x11f51cd707f519aa4d0f07de79bd18a1f7b65d2b96b6023d18a87459396cffd6,
+            0x16d2290bff342fae3e0f6366c4a3ccb44c611797e77ebc27d7f5ac31fdc6cb51,
+            0x16d4e47f82ee3b3d81d48a335be28f4521f90a935641a451097b8298daf0a26c,
+            0x269e6a80d58dbc19ef71e682b1faa7dc7394636fc15c747d04ac950496f6e118,
+            0x2c1684229f0eae24af14f894023cebcab0e384703e71ad56199c4c8c70e2dd06,
+            0x2d9ede2e8993c45794928190781b626fcc406ac3a977235f9d6e50267ef18fb0,
+            0x11d67805271cb5d86a927303acd7fc45218098ab99eeef9756e62135bf77da70,
+            0x170206f9a4e4e0d7ef55c5cd644aacce231f7727c7f98d97417b720bc37c7881,
+            0x14a30c6b5536c74f98f7fc57d004129d4f887cf18ba9f869bd5630d66d341324,
+            0x25804cc693b0e118e811f3a191a9d6e47a537cb64129293c947206d9290e7d10,
+            0x1a7a17b400934be92901d4e91ad3cfc98231aa841e09627cce975bab7c15f2db,
+            0x2c0632973f605ced6998435a7d0cad76c8c9c223c280080fb6a8c922ad09dae5,
+            0x3044b16721e5ed81d39f2abd29d5f0a761c13fe26bb4f53d09d5a05620997fc1,
+            0xe2cb4e18b26e4ea445c704748bc7682bc2834cef35ce6bdc043beee286025d2,
+            0x1c033ddc1a9720312cc3541e886cb227d2d37eac1cf86c4588e98203692941f1,
+            0x1ef28ce82fab806a49fa311c6f4e8d0423d051e0a3500db978ff731a9378bee2,
+            0x51d7d3785234a09db1939ae4ceaaf14a46928189efc8ea0fa1889e5ad0d1224,
+            0x462c9e533e4745c52df23623b0b72f3c9eb8e3a9f2a22a71b5ce6ca41927425,
+            0x26a33280331d48e2aa9c5f8f63c4423a6dc8019b9633f49aebbdb6a55ea5cc93,
+            0x8ed8b1b9618a2db7e4746115d96cc25ec51411bcb07985e9529b6111039e90f,
+            0x18fe5d991dea77a7b18f1bd5c183a377cb9e5c9c2591867eb2f8e876c40c41f,
+            0x25a3f5cf66d0e82be05ea92e3a982a6b3289d9a8e51618f9b21ea0e39a30e5b6,
+            0x6182fd61e1b35b6f008e9909fe99904bfaef6519618e435130155d28d1dea2e,
+            0x1af6ad164424b6c90ca4241382ca0cd2660ca388775973b08e6728570a22d844,
+            0x6b534601619e55889aaa855c063a2ced889c6b4ba4190da327c8a612c255544,
+            0x50555bc03cbfafbaaa38191f0cde54e8dcf4fde1ccafb5af5c7e00c316d655c,
+            0x579cf40adfc069a0b3cac02a495fbaab0175fe948dc97ac85f7699ec9be97a4,
+            0x1d9670b720e7af8fcf67b3c832d43a0e9b36c1ce11b679554086d3ebd3743815,
+            0xb9f1b4372ddf2b552fb55e7d029267a0ed4f09c4f95d1b99a08c1d6585a6e74,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x80610bf8946c2cc782c83ec3eaea36684a2cb66366a9a801b63fad3332e8ec1,
+            0x2837c8ba7f104dbc7503abda031731b4a7a1dee3ee8fdc708651a7385e56fc72,
+            0xe4348619aa405bdc4f9fd965dac265ae73dcdfc0f71bfa3a943cf98965610fd,
+            0x199e9e250ce12b1667cb730f801334157f29044410b1d98b2d6f2a261a2f7768,
+            0xa0409a4aedc8480df4a99f9bd0bdb0151e5ec3cbb6707a594d8aad6334d4c75,
+            0x2719d9f1e85015ea06b50d406af582c36d5e937522c974727b1e7a4eeaefdbf3,
+            0x1066a17fec5e6cd2202792015dae55345167ea35b6a65ab7a7f2af91da59ca1f,
+            0xe4b0a49c371457ba0eda6cd95fdc3cb81264ad715202e43e2dec5699fbe4d82,
+            0x24b58a924ae3bf6ac96fc11ffab9221a2283830e95377deb2e5002c2bdd1323,
+            0x259c8606be0c6467b6ef056c6a4192776c6c3536ffa82c89f038c856862af24c,
+            0x21d6c0a2a54c5ae9ef9dd5f2aa73764f38df1e923aafd242e5f523b5332bbd05,
+            0x3c099cdc3f61caaa2e49d484abb2b30e969416f4e1a5678bb025318e416678d,
+            0x1d4d4b8c552ef0d318a9a8edd80a2f363c1c0a1dcdab35880dcc6bf3c548262f,
+            0x7e4cf648e92c276185c416d6ce6f5b0c0e7cbc2eef1e250555699afdfec0a0,
+            0x2992b02301dd18e00482a9940d59a69068127f06aaa50a32322dfa2af211f3d9,
+            0x16871531e6fe81173d8082d8059270e70ac4125d0951616ff37e4b4aa6975598,
+            0x221c08a0b7dc5aca357a52f0127797f9e9e01eb05d73655f6c779ff43f295f1e,
+            0x2756a3d44e88bd6547d02fa4460c09a2e982a4d505a3421625b9bca2604bd862,
+            0x2923fde3bde5751d8eac7a9a156d2444db92b629185e01e5600c4fb5a2ea53ac,
+            0x179ebe0d2b17128a67f8fce5fc42ee26c654d2a892c4eb3c6577448d5fd556ba,
+            0xa1814edd4f8466f7221dd98f8ef29107a18c66320825acdddd8de64feb0275b,
+            0x1cf03d03226c78b2369f79beef10f08fde37c150d4e7aa197978365ad0bd316c,
+            0x2fd3e923ee39fabc387d2170ea6b9a629b0a7e28296c84ba8843f8f03ec3bbc2,
+            0x12c6bd4f25c2d042e4d0ed3a1e5cc01247c78ae90e49ae722d32a584286e1b4d,
+            0x11b78a0b243bd45aaa4f3cdb1c79ab206e95c4011289c44ed4d8ca99686c9b9e,
+            0x8945308107ba56486011898e6bb26a99ec0f0b9071ad9ce0af820d2727f459d,
+            0x2172f85afc450cd67c1efebd6becbc01114bc8b3b62b4081e4cca3418693b323,
+            0x2db81bcc85e548bef5059b2595b4f06b55386b9aeba12f483f49978ec6a9cfbd,
+            0xef5d0ab806be48c7d0b46a2cec1766083eef4ba4373a16abb2226803305207d,
+            0x17caf822e96f4cb68325943442e65736c0f1e01b845aa970824a3b193ccf8b30,
+            0x2315b8f0ee989b11b9835d8ad7adb67e035f85c24835a4d53cc7d7b59ff15041,
+            0x1f5c7dea1a88280a88e2a57c1015af5c5d4e84da900bb30de5fb8c5258b46794,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x92a67467c379af9424ffdcd9a81657b04289992027e3a841bfe322924e000b1,
+            0x8c70f58f02446463906891b2604d2faf312cac00e6c254f30ae85874c112546,
+            0xf4af67e5395b62af989d01c1fa9fbd219ad1aa4aa2be4624460940bc0c12a3c,
+            0x17f7da080a7159316a1994a87177f0a4676e249247a2a577c3fc54ea8cf7fb27,
+            0x1591bba9c620f87132b8ceea1de4c4c5f09872714fe1d63259e0ef80b5f333a8,
+            0xcc30f15280abea47abe01145e5f35bd877550b79ae4262f61be65a5ed0cb24d,
+            0x1fc9cb670a57f842d47bb906223b02a9ab6352ba622804ffa51ee99da3edaac3,
+            0x8e8b798ab602d16910a34edf3f093333041aed6704a66d782d7a319dcda091,
+            0x1548714c734096e2cadef4ae88dde9c8886029e21e9ff5696971f11dce6ca6e2,
+            0xa133a39d296d427598f8acf721bdc057f2cd639a3317bfef3eed1bf38c610dd,
+            0xa4190ed0b3c966b6d7d0bf0bfe4d586e77b84cd55bbf322dd62c4ce7a262914,
+            0x26447ee04686542296d06c8f53902672e79514770b3d6490735ee9f5df35859e,
+            0x2d1d51cdb7a8fdb0cd7da5fdc33db94bdd8d5128123693ab1f4aa3e78e177870,
+            0x17b204236b11bd5c5c48edfde61d817b73d7cf2f5a32a888144c7b088d3ffdd9,
+            0x1915106b66fdf208607ed6888d503f44723c87a5c5aec9eed658514f3692828f,
+            0x1c171f06ea82d218b24213479856d66394e160dbe0b27e659a7294e07faa69c,
+            0x2a4c40c22e17c0bc9f509eb1e30acebedd18ebdda1825e391523a74d4ab23f50,
+            0x20515a5d86581b02f9176d72bec69e785a77c41a16fac68e1beb2ad41ee21f12,
+            0xc401945dd3d8dbcca89faf8e58b0469e7e7520f2e8982214a4dc244dcca5cd1,
+            0x28bf080eaf7736338ce614a62cbb2805eea22b0bfaeac1d0cd2cdeb2830ae0df,
+            0x20ed87ececd54dc49ce955a83fd4db61891865b24bd09c3eac85037bd69c52c3,
+            0x2baf7d6e7863aa68555f8bfd7648d1b4426f6c39fed82bac197368b3d22eaff6,
+            0x1fcf69944cc889569269c5031cc1fe8a1efb0b1953ec7f9573bf63671ec7a947,
+            0x980bdeb30e0498f3c45ed4e17a4ae4c8c3bee91095a6340207b69b4ddabb83a,
+            0x2455522726c3c95dc14e7fcb5fc1c008b5736e569f80505e71454f8aaacfaac5,
+            0x23541590ac6650296ea9c3b935009e79c446280d9bf1010b8e66cdda9f8970d9,
+            0x1d14af4f4b54f0c9398e051d2a223193c78997d591a639109818b8cdd02f556c,
+            0x22a747877bd35dcb97520a0f4a812c7b78702bad181237c01a05fee842840e4d,
+            0x2eafe1740ca67f80d8ae595e84c17039a0560bcb9628b084a97d9ff4afaf6b2,
+            0x1dba84e994a54a21666def22befb81abf49fec76c43c3f20da9043c9874ef2d8,
+            0x137b47cf2f3d3afc02f3469e9d165e49a212ac255691a1bd3565bce046fcf153,
+            0x1eeb1a0edc33a3e69b8445581ee8f0ddf84748fd901547d49440c863ca10caea,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x3e5726f2b2c60906deb00a314337a9c6e4eee70497a4a953ea206d200db8d69,
+            0x528d0374310dd042d5f80b2e720b61c4200539fd1e1a23ee1f8f347041af0db,
+            0x1da41de720a61ccf6e3b9b97ca36d7439da12c92549a11d238475e05f9037a03,
+            0x21c1d92ba962ab12631e4f710fc9b066c369ef4aed709fd5f6992f57be251b99,
+            0x2ebcb6f494b7d06a34d2d097c0f46ef929646c529f6efca0edeae7e733b0278d,
+            0x26ba18bcbe43ee1a2ae6e1b4dd89151ec17e1341839b94e4b2bfbd70761aaf49,
+            0xf05d9b39c0b9b3ca177ee5a8b12de457d00643d5a668a8fb30d6cba0266ae31,
+            0xdbb12012ec467271d189184d086eacb530c1bc906895850bc80af72eb6e49a4,
+            0x1e3d63755488479f0502c34e097c74fed1926b613e979d53a5353ea959ee6c9f,
+            0x2939fe43f4690de6ecc251b7cbfffca082fdf3c841d5ec1aa77de64016d23c0d,
+            0x29b304c4af9503a5a1ed74cfb37c9e98235404a851e915f9b476f96cf97208e9,
+            0x17f58faffdddb92894ca7cdad4cd379da8c174076a250c3a69441d649ce04bc6,
+            0x191456fee87886a7ae3d41901a05e755d8a3cc2a2519cc011a80724d430e918a,
+            0x4301fbb26093e59eb5818971467c137eb7633a00e8d1f51856f2e38596f3d2f,
+            0x127fe9f3329bc33759114950d8afe484a98e33011da6e40a41dc1f4ca2ce87a6,
+            0x201ad991da475d146d85daa85c5ca3d2d9ca48ff7886b06e37dbacfb7ef69664,
+            0x24a3d85006e0ccdd3d6fc62623fc5b36b1827ad57f7511a9677cc36327cebe65,
+            0x273193d9b2986767b8934849938c7d1157ebc32578efcc7528d9a6a18a354953,
+            0x2bb64a3b825a61f6c8b577993aa63ac00659221cafe92405be881026da729676,
+            0xf656e73593dd090547fb5b3b8361d172c93f94a334e5feddc059fd03890690e,
+            0x2889c18fa2eb572d474b6eee810b750942586f2792b146f455a023b89542d353,
+            0x10ed5f7f60bab5b473285acbd59f0e3dd299f6d2d1e6412322ebf9378f4aa031,
+            0x94d0f2d2dac4b549a1ac6b1e112ecb6e9eb337c0086cb2c39c5b98a180391cc,
+            0x1b6950296c9a98930d2acc173d41e4788e70e42e3f568a97daa0fb7ad8d2eeb9,
+            0x227c2f6979d9ca34ed1716207f3d70e78b9b76b1fdbf3ea97ae4b54826190e21,
+            0x33ee70ee09fc264ff1cfa9060778cf77b725d24c55967846f6aeb468189f68e,
+            0x103ab98622a6dd1bd90094a3b69b635873a4bfb0b1645964b8d03390192a264a,
+            0x46f5bb0ba2b9a8cc19af50bd1fe9d3e73e4df3036ee569beef19fb47bba174e,
+            0x1955685f6f6f936a887f4892fd66ae962f38fec2286788bd246f7eca45b5d7f3,
+            0x7eaa9de669ef1442dc6d616ec080d6c921f95e73b87b7c3752782d7846d5a16,
+            0x1103c98bc60cb276ac254178b668e743b6793de46309ff72291767e697516522,
+            0x14e1141e0163ad2a79522578c5025149d4ad0b484ea0837c427ffd798b5c211c,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x4b913e824903a4b78ffbfa9043117402f816d24b695be147d26fb633ace8fb6,
+            0x11b959c95a4da45d9da05602f07e696b8ac0ce6781702a1368d807d21eaab72f,
+            0x1fbfc86fc58e1fa4032309165184ac8b6dc81dc1f81c09ff100758347243f289,
+            0xfa7865327aef8246f45ac73dba9666a853fa8e71e1edc2409647207922a9041,
+            0x3020170de7b6e86b2b0fcd04439ebdaaa8ce01089600b801945dded0c906d83d,
+            0x10e72d8e4629ac7c8fffddca3f8374759040f8f61e1b2419cf266255d68496d3,
+            0x5e90f1892363b99161345ab49317e3792eb9a536f473e85fa47480b90dd2a86,
+            0x240e190d0b92f9aa7cd7bce008719c3f8d5fff587df3958c85f5a1286288f63,
+            0x16e841b2ee682513db27e23b983f5fabbe6ad3a3d44303962910302eaf30840f,
+            0x8a397b575fb86fad288ceb48f43315d70399c8bd9cf4af25faead935d02277a,
+            0x2edad52145b10b3d0bcbd0216574b52cc2b442f9308ab528a018a78ae97067f1,
+            0x1caca2ec3c3d6617fefbe6901c4252ec01ec7cdda757bdbd5f9cc62e911cda61,
+            0x157303e9fe11497049ecf530db42fea5c87d7b14cc153120babb743935f30de0,
+            0x20d93803a35f06d76ab5daeec28e4591d0066271d84edf26660e0350d30a9049,
+            0x970dae33627a299a9cbf049505d94ce6cd1256c80a6322ad47479448bc808a2,
+            0x178b6678bfc5c1d9fad6fa7aea247cb6b4facffbd49fd846c64f1411b2c2f6b0,
+            0x6503b98a6cc525bd286b56e7ec81ab36835c969d4101ac249d3dd65834fd99c,
+            0x21218ec0a783dc924ae7d9f38260750f0a0e039a4004cc095d5bb88e1f9be771,
+            0xc0289c9220673997f0393267b29ab048761034a16f6b6e076b063ec6031846d,
+            0x1984f03779ff4d9b4ccfd87d23700f204b38c3a606b0279327ca81ff9560b48d,
+            0x17aa6042676f383383262058e28ab7c70d3d19b4f8ad4f54a43869e037470258,
+            0x2ee1b009aa9a1ba5894110394a79e739754d9f2356ccf9293b2d851ddb6a6c52,
+            0x22a586eb8ef3b8257479bca2d919afc56fd0846dbff4f3a9db9e42e4334b8727,
+            0x643b1de630b4b9a250b0eb1857c4323bce1701afdb02ff2c6537a04847ac5b4,
+            0x125bab28f5eb5c15dc0b3e9ce2b1e6bb246ebc56c44fe9943dc1ea4915830033,
+            0x1bc10af70f7125d85f34ad4ef6e7347eeba2a11321da19894c5f826880d770ad,
+            0xf6baa6289cf76db86d915ac19af0535773157e39b5423b43b1f3d0df2a4ef5c,
+            0x2e80ef76053f6d815f5a779fba74e9b03bf8dbb8a19d40550c519a35f391301c,
+            0x31efdb5d245fd16283ceaab1fb5d4ac1cd08918c0c22265f7f114a9ef22058a,
+            0x25efb8eac91f3ab3d77ea8ef523c86fa555516d32798397a6ad00622095b9b0,
+            0x14cdcee9150e86793e59fd2690a2aa102c2ec7f78d1da286826a37068c8859b5,
+            0x101320abf4ad5bfdd7bf37fd1b5e5afa8f1b472c02e062a7058780fc215396c4,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x4d0659feee688cc4dbaaea4f05b259f7614cf5a5d970087016cb2f2eb343bf4,
+            0x291dcb25510a3655066e860ade461e23fa4f89bc26f523b65b88aad5a753623c,
+            0x1c40b5589a51a5bc3e746f93c18ee86f51331e8da3a246909b6a3063393a1b6e,
+            0x50535d58a6b20676d9dde187a15c9676781eb6c1e46159f9e63d7db750c6410,
+            0x1532765d3af5aad33c7cae523592894cf354ad9890479d662ce3cd51721178c1,
+            0x8a6818b3d448d43c1b5ef357488c00883e342690a21d3fed21f7d62142dd589,
+            0x17db4c5c59ff1ade79c01c45dbc7b6134c929ca5292cd7893a016573e7696756,
+            0x2a7e1f2d365ce9b5abd3eeaf983c6f6434cdba5ea59222f6bd3a5d3ecd763f5a,
+            0x6261e5b4d7188ac9e84d341f1152a4518f88d3e701ed5bfd7110577ce1dfa8f,
+            0x199c5a8f0703767fe32daa280419f8c6793bb0888ecdfcbb4eb16332fbc028a9,
+            0x13388d9d87929845924e078243a8d7e2476d77ccf84f1c05f7fb7c7da371bdee,
+            0x7d044bf7a4fd698a6757c186c08d7c39c2083c8cbc5be29964e481592ee6684,
+            0x283cd95f4743d216af04c17591b192367280dd2440ef47349a8f384f63887cd8,
+            0x1356391f7516db1ad0481ebffa73034416caa2362bd2612a9f42034e35e93e27,
+            0x26fd7e1f6d657b1bd8333e3f9b548f54941b9d13830bc88b8210e5b359b00f68,
+            0x27ec948ca2028850a977addd6a9cccc697404d4d4b47eaadb54558c57435f916,
+            0x27529d815efdab4fa4f21829ba3103982ab79e6052fa863044394fb5fc8d5dc7,
+            0x1dce3f61f34639eefa0a344fea750a5751da0695e577434f20a38658cee96f09,
+            0x917c97d46d5b4ff89b5cce4bd785c4b68f38c53beae9cec7e8ce31f7b11ab5e,
+            0x1f389f75cde06c7ca3105a2b5769cf3915292ebb44e5819229fe3f33ff11d03a,
+            0x2d9aac1c72b0a36a067ec7776c0ce2138eed3e90c3c381d13b28c43f297ff300,
+            0xb8f7a8e4c0d2d5757c501e44a51e5f5160a01440281ebd4479b858614cfc09d,
+            0xaa15536df2ec5905877e2ebf9d07d3763a3f94e9b4deb5c6639bd89efb86aca,
+            0xb03dd77a7424fa8d945440f077f848e4137323442e11e1b4a2efe97df3214ae,
+            0x70898a71952afad3ef0062e8420e92d94fa7bddc55beb355dcd1d3526f538d2,
+            0x29d5413ba2416a2db49c14b165cb247362821494d738b57897a0bbe6cb53a287,
+            0x7f3f807872bb8ec72dd2ccb223407a19c5b64e086cdb0c38a7b92458c5f7c8d,
+            0x2f69330924f5ca89e8ea41b0334796a9961df24ad0abaef5106d89963a038f0a,
+            0x2abdcf1940bf24e67ab4c8c0942df7d3440d04359da428541b0f128f6f53184e,
+            0x209de37635d57f9ff0ea8a6be7cec5c70d701156bb34e25c0948c7090b319ec1,
+            0x79b485de26ad58268a3b1bd5cdf3a1dbce291e7e30a1d645a7268d340a8f1f,
+            0x2da731b7942de735663698b5d20570402d266df448d8a80110557643a906ba3f,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2c8f848a56c338afe1290f12b67b57d00ff8e974e804ac53b174ea42c9970efd,
+            0x2d02f17717bf0db48ac36ad0a19e621cbf73b049364d945ad2a962d481001430,
+            0x2150b09c7e10ab5208e632f8dfd30bc323807c5c6b122a6783b9fe5458a859c8,
+            0x5b10ef00e618a270ddc6f313e86197af2bb111ec623f2964518938e4d1ab8ce,
+            0x813aef08c1ab8116f2ed8caa7eac00762afad0fcf0fed79077845b2b81888a3,
+            0x217798429df3f4efe0b8010a3305f618cfa40b31226a7f01aacf05750f85e308,
+            0x13dddd98f07da3c85a8a7e584a541a3d1c30131e58fd19a79d3583e1eab08db9,
+            0x200c75e95d154cd5d9f42b940fd7090764594e0179db56e462c80da1b57e0826,
+            0x24c60aa77eec80da564202803e367806e84056ea84571e7702e708eff20350bc,
+            0x2008060f910cd57bd018a7fe79edc508e11897199106323a04369c0b2f110193,
+            0x154b1730e35711d6b5e0596a7e9fdf40a369c96e9889573772e35153780d06a5,
+            0x20b48f4a5019ab0f0229c8613c44f40d6ca7ff80ebc6bd6f4f595947c9e3e9a6,
+            0x8da6678cb4513c79e70618c7f6a247376292a28f4b8a26d7b22cfe89262422f,
+            0x1e32944ecb0c8e538be8b702f45748cbd910c621ba8c0462a03a6d536e8f3cf8,
+            0x130383065e342214003bef6cd7ac224dfc22a799b13a089cefed9c8872c056c4,
+            0x2bb1e946f9019e0f0a3a6f31c54d13d900e95b92657fb49a0bb1d8b085aa7bdc,
+            0x12c6706724626b4a2511d5ef4cdc22e569da5743363f598b0985da3f74ebcc66,
+            0x105f4876b371512fdd868e75e02332cb49f228f7f6c3ce9012fca57b9587fda7,
+            0x1ecdf6fcce9eea60179494be5317b761a337f5c1eea7d4bd7b36c4b136ba893c,
+            0x9cd2ef6d45dbbca0dc657384ddb563f367042010debc24bf026a4b9c59f0da7,
+            0x254ac6855d05046745889295c485aa0d141421c2e7e46907c6ae60a50ee2f8ba,
+            0xa99c054b9a38bbe19930906e64c1126c9f0aaeb16ab6c33d1e0e29418edcca4,
+            0x220b4016fade57782896ac3ac88e5c69dca5e58f1d6ebe25f7caee67371b85a4,
+            0xb1979da1c048f6ef5e0232ef793f134dbb2a9e2c8f83a710944e1ccbdb08da5,
+            0x2eef2d924b88414b5f89ffa9dfd4b62047a12d0e08118d0d39a1a1fa99dd91e5,
+            0x126ae3d2dcacca892ec8b9b2338953d3bd2a0b341b7ed5986138dae14b6bab77,
+            0x19e7c32cf6e235f95e2ff6e9537b23f8fb2ef50b5a1f734eb757352a74eaf498,
+            0x2f9bcb5e0cd5660350ea6151e4a514ac84dc6064adac393e9bc4daa628297fc6,
+            0x1aa496f96372589a74cdb1523691b1fd072bd35560d30b8c48109d86c7776b75,
+            0x2ea5a8d0da13d3a0051a7f1b186b35d6f0eb986a2769aee850d3945ee2409439,
+            0xa633c25ff6bbbd07e365ee018c76dc3be74b40619892f106cdecf3cc4ff8372,
+            0xf412148158955c69a302b9b42e5fedb330d5ab4a6cf31b25d4fd1d8135c9900,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2f2ed1486990b9431be8fc1485b6eac869fef5cd8fd2a94c7d4d5da7e496db12,
+            0xd5140886c23f2671e698c3733a296be1f4ecb97f7520b027d906189fd755860,
+            0xd1b9427080a9865543b6fbe5502899198b228d02f2ee9287bd1bc1b71680370,
+            0x25f14784419e0d86eba62a9cf2cb22f063caeca529be18af1fa084c73287c3fd,
+            0x1cdf7679aeb1784cd81e69e41807377671163372ca50143e5b30eef5a31abea9,
+            0x7abd6f3a4c53c8d3aefe49b257b3e7c0aace886107a6168a9f93e33733c1224,
+            0x198e8dde62e4b800e4a5081cc43fffce5ba02ddb349795a9ba8d2ca36eaeceff,
+            0x2a10fcbbc185ff7ae275115f56640a9ab88dfee8d2f371e21fade31ff9e7d249,
+            0x3f74e702559a149c3ccb5dd839b3f80ce100c26671929236a4d703c6e53d53b,
+            0x1e9cd241f96559366079809b034d98dc345a4814a7e947e17b41a19b4a119b75,
+            0x7640b3b48b2cec9061c87ce4740d281ccaea62d865d0b3da726ffcd67d2d426,
+            0xf224f2a3eeb002452e25fa54b360804dc9dd1a065655a31230e91a1f7896eda,
+            0x296b25652ffb82041356634b505aec0d11bc8ffeab06b6ee76f97d3e90e11316,
+            0x24b1e852a6168ca05bfe0e823f4a984b3b99ed9bf3f651cdd3ca31a2d93a21e9,
+            0x1170380f35b0c131ca5d2ea71f42fed8b3caefc4ae2ddb42ffce4c72df975521,
+            0x2a21146458a9b5cd2232544ec84b9c2e3c07b75cbc4a2e27f1458995a5cf7665,
+            0x2cf40c380da1e84026e58bca73fc8821a6956f7866bbc6591330c7b0876d1e48,
+            0xa4e5a8c25c79291e6e7906a8bb9897dbd91567061abbe4eb2b80f7e591abad5,
+            0x219cccac1ff828ee50d9413629c80b870ed290d5b2197a0b9db61960913eb29e,
+            0x18a4a743a05448844b46abe129001953306236ecccce1b8c885e712084ae40d9,
+            0x23f5c0a65d6d3f4b017a68d513413e702ab2195a12d3007589a7ad4230792a99,
+            0x248649d22bbd35db3c317fb6f1e20944adf80720fd085394e606fe58c93b227e,
+            0x1da45cba740db4b50fc4b2571e40590ad20c725af7393d2e2096f782ca8451b0,
+            0x59c9894d39a728ce35f569c8b59acff2a98903a73d6935236ac6ab8bb65e7d7,
+            0x137afc1da2a1dd16e4049c3e23951f23e5324e12fe046652beb4cda449a21cd3,
+            0x1c67f00b6836091d6642592a40c27b9b875f51cc9eb804221130d3f883d29765,
+            0xbeacd79129b9b6c793b29450ce6458c86475951ca6f0941ffaaa73622709bc,
+            0x1d7194f0b9970b103e3d4bd5a46b5054ab45bd42f537324cb6fec3c672cd5f0a,
+            0x38c741f8607a78f328725ad18d2baf8642c005429c53f5b7f9b8be51c8a507b,
+            0x1d32ee86d0a10d113b8400a3301ee9df0b4f9666c4c962073bab7f02f0c55e7,
+            0xec78e82ba602f4ab67e987ff3eb4562b0818c481c6e8febf4a4a157ecea15a,
+            0x2e0de6aecd184a6d47a6a7ae42b76346f15f98bc4f0f68ee1a55929939a7842a,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x93d13cd9b043a5b6a5acb2de0bc54de68b71c88e8d61c2c3c3bd52febfab688,
+            0x80fab4e2e36da9276e4610197b32d28ecff28dcf155f5db596037e41a2888ae,
+            0x7d2d245764c856372297c49ff64365a99137acfa81041932b4324877e33d9b6,
+            0xab6a369f3d47ab68ba9add80b46b610d39531e22a75a30df3f32f4bede18a73,
+            0x7a683cd3c4e68622283858eff121cf3a5ec2cb48763c290a4984f7e75a86139,
+            0x1fd44c84d9e254b1c6e60cb8c1682f5e78a5c9f9cc88e53b8bd1d8e9bf20638f,
+            0x2ac2bdddae01ecad6c097ec139f7d442b7a5c48c491c0a83a006e9dd1c44c9b9,
+            0x24a03800df78ab8dac3b172aba870efde663176598e2489fe1371f1b8fd9ce09,
+            0x12e453652194ddc8ff5f249f04214d2e0571ae46eda251ed66c9de6f412e08bf,
+            0x592a798f42fe58f27f503f2ac512286fc9a0271edbbb43d263358697b731668,
+            0xa92a96d55b5e02c8fe846f8cfef92f2243cbd535b6b3c0e44d3c6fcafc01963,
+            0x2f43e2c6e8af0638e163e2f4d34aadf2debdb3a5df531296ee2bc5dfd2aa8d41,
+            0x3117e986130d1c25eed39ddb3e1e4afef783e031d60bc17e0681288f2d910ca,
+            0x25cafbb434aee06df5f90241702018c6fe677ba0bfac46f6b5b8314ef8f5d407,
+            0x28b797a499c2b1082b6a674ac02ef5cc2440d6eee1ea1be1ed5a527a6e5ccc95,
+            0x23bf393a579394003e64cc399506807aa684314a29992e3bbb3b67fee7f50e24,
+            0x28656564d677d58df440de43115089a1790d1aa95183b390349688e8c8aa3e32,
+            0x241a69500f5e134c993252fe1052c9cd7e235d501b3b2343ee0e4857e2d0209,
+            0x3744e02ce85e599147162a48b8095c61ef582bd1b4027649a4b706e9d99f355,
+            0x59b7a17e1c0e884def789033664d88ba112980ee5d7ce4320f4b59092a493ea,
+            0x2a6efd68e5dabc912ec2b5f7814e6e1b7b8893acd10e93d8e88af5cece9e433f,
+            0x20826fe980809fbe57d7af7d60262abd566278d70e03c7dbd24798c9c991ce5b,
+            0x181e562d37922bad979ac96f562011311f09187613e196398d3cea64e7fcc7ca,
+            0x1c4e70fbd4c9e09d3b341e1a9ff87d088e6bc4d88a5cb20bc39a2216e9a2e78b,
+            0x170c6ee37a8fae5a940388717c1ed8237f9c2c51e0771fe1c5114f020720b1c2,
+            0x68712f00eae99b3109162c3a1c8a6b836031f7b3fea61477d274fc39cf53b53,
+            0x1937a02e7c8e39d7f3a88a82c38dc1b2b6a7f4326ceaf7aca3f8a2fd163f1388,
+            0x8b99b6b338adaaec87f0f4e4106e1a76938bdcb0b55d66b9af257f46da5c6de,
+            0x136d1108a8d4bcea80090baee33556f59dcf26a8365b6f657a6625029b73f354,
+            0x2d8a56738cf6dc4785fdbc68f440fa3b2d4de0d5ab6d2d7c6c11649ec2e4da65,
+            0x27f16feaf6fe1525cd67eef458297d1696dc45bf5f8f1ea18e17801399f3ca4f,
+            0x340f8d664a1afe4fbd06793842133cd43ee4e0b2173405efa10445f43a1836a,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x14ad435cf9a9f41fbfaa62698ea2b01d778fa6ad3e6d75d628e535cec66f6183,
+            0x229f1484514708285cb6c866fab78878bbc39aec362b9db5e258c101a7382806,
+            0x55104ec0dfbeb910aa081864bd59497cfe65acc2091c2cc675ebb7c7b2a318f,
+            0xd75b1f18144371f5a0de32dc9124230448f17584ef93ed84300270b6ef3d4cf,
+            0xa1da3a581de2337e823d10c00af64ed8152a3375abc7c8e038592893e02f879,
+            0x15ce644c9c753f2b508595d24c0905b3712411f8bd78c1dddb60a61e3574f50a,
+            0x249251029b3a7d83a4442ef27a2f3bca3edbdfca88c33095f557cececa23fa7,
+            0x2190e0657b7f4592ed17884e486aa0983f96d05d497f12d9bb08fcba65e146a2,
+            0x18e7e7d031ea4b865475eca9cfa2f156d2bebd8f57c6c66630f2b3e9bdf3aa1b,
+            0xc23dd68ce397790fa9d48e22108072ad02df0f80f684926ffa4b66e8871b1ee,
+            0x1346be394582712818b12e409e1a2f80f258be08e8f5273e4223048a6ec68596,
+            0x227413a36ae6153e431c4dc592eeb597ad18b0a119f1c644d8741c5d1302bf5d,
+            0xb0ae3714255eb9abec3c60d3e9d3852c33db950e87bc17818ff0242955aa594,
+            0x1f65fc46116912553c6c9bde179a09288bc29ab001fa7f58b2b36e10049da7a1,
+            0x1c35284edba1cd391d618754b17f642eebed4127382b82f7c28b2e70a8f70d40,
+            0x1080a3fde0e42ad7dd86de041cab7fdd025951641942374c1abcf62626f48a3,
+            0x1428eb2a1f2d91707f546af2e0a14fd6f11eee2ca12eff4d36634a08a2501d8b,
+            0x33503c434487731d754e92d6e8ce327ceecbae661711045060e165ed284fd29,
+            0x137a5d67d8c2d7d92f83451a20d0698f3ec69d9bedca8fdf23e4cc761c30895c,
+            0x33ff54a0543a859d10d23919d9353eb1c7df8c37cf77d71c033427f8785ef7f,
+            0x2ef45d95ea7a2a6ebf7cd42d1bb3eede45cceeb3c13124fe3e4bf9bd43919aef,
+            0x1503cc2c9f6869e97c3f356fc0888cee11b122576b7ac19e53e22e64541b864c,
+            0x13b7e00bb153de07cecadd2525f0400ec81c7f3f01b2f8c0d4d923626f5074db,
+            0x1560e82a44438c75cbe5e7bf4242e9b318e84d0f70c247b4941214a54e2ecbdd,
+            0x16e6cbda059ea98cd388bc97b407a150d03cbc54db44314acd2fdcb856ed59ea,
+            0x224e1109c1eb450d665db9aa5a324754e9de0f3645c36a4f42c06525a6a02f17,
+            0x1fae1e95cc145b1b611ae98352921e5621563019bcec54ef9aa0a006c5ca9c0f,
+            0x29c2c9268343afc2448493205d8efe3ca12ff4ba45195e125b1a585b3c15362c,
+            0x1745aa01a6decfbf4742ca4eb4fb46936c593a8fbb1753e4b1bd8ac26107dcb6,
+            0x2b8e149f0ad40ad21c74ba35026dddbf89dce7c2227dfcfc94a55130b282348d,
+            0x21eb20b36f906d2693f37e6b25f10a251dae88ee9e5bed97d0bfea9d95eb6155,
+            0x2e2d367ebd03ab9e863a272a0cb40240222f32d1ef3f7a79de99160236cde439,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2e142d51bb3c63e11687bea27b03d2c1f47ff4617dcf1784fcb06139718bdc,
+            0x2f9a0d8d22bb17dc91fb40146ab611c24fd7aff2721139eebc67f103abaa8abe,
+            0x1cd3446fe74bd3cf4e8790869ca502315e2cb5e61bfd569b79e4bceba7dd18c5,
+            0x4882cdf369a6b624cdcdf140521e2f5d4f056d5be8938eafdab02b2b6b28365,
+            0xdaabd96d080089cc09b753a113f03c79cddb879fcd4fe92f64086af355320af,
+            0x11fada765d840371159d393d9383846a758452164778b156ad07d2f97b1c81d5,
+            0xf1bb77c65687d588f3afdd2e81ed31b0b14e7a6b34b3f194013310a430e72ff,
+            0x1b6cbbda2504b6c7157070cab18a64cfa67b25174430ae34f88f41d06a5df61c,
+            0x2caadb9815edd0b00891c8952f439654bff61c480d34304a559b2ee106e8555b,
+            0x29d647c2ff17d90d8ac500cd862bc7cf3bcd63cae45d13ba2b2f5bd819cdf00a,
+            0xf9577281c0113be755056c5a200c03b651cd175ef4c1c51526a262db78b6012,
+            0x1c7a4104b1eb344a9d10ae34fe9f0d9b944b1f27b9ad60e78d076f14b1579dd1,
+            0x28833764307c07236b8d64f1e872a15f26b93cbaa63062c5728b6a6126a2b3d8,
+            0x245ff91d36df9a9301cc998a11ea027605aea0dac30a20a32fc5b9546ff5f22d,
+            0x9c3b8ddc3c8a83b3dbc098cf547b51d197fa16571ca6ce1bfa603f23474188b,
+            0x23123b0f1690f3c61a3d7877f26f33c4c26feb8579966b878f9313f2a7bb0724,
+            0x2f42ef2f174748c44f63767b95d5e66b2554f75a164e00833336a9d990fe4279,
+            0x1d8000747e03e93c37fe21b889bdbefdc234baa290a68aba51d3517a260e6944,
+            0x103f779b0899d4250da3fc25d27e0444a18498ffc0bf0ce7ad7fb106ba311a18,
+            0x7f4c9eacabf180b840cc30448d4926692e4a4d4b6c970e0e818c5e11d7a984b,
+            0x17e5e03ecf01408a520c1c5bb8e1a4477b011178aec18404e414554fd78da779,
+            0x116cd1a5deb317ac2200d91721cb4c794fd1bdb9e04c80d222b2ae77cdfe0412,
+            0x259847fcd69413a8b787a452950cb9970981ce86ace933112f205b18b20af1ac,
+            0x7244b4174980899193f70318c4c09239a011431b1f0bd3f5c79e8e36347e52c,
+            0x27a6122c5882996b8b87923a9b66a2a4970c9844cd3034e847fecd91d6b13fcc,
+            0x2c0bef6885d9a4d76f43a29ddde616fa8174cd24ab58d4dc707ba5f924739c41,
+            0x2d0cd48e3952f4d64e4f37477e2c0ac65fcb78682dcd8fa4c4e9d744c1205af9,
+            0x8d8edc9e81dfba6cd7305c1bfe73f42d7252dbb19889e125c5c9aef137804c7,
+            0x20860a731c157ac1b7ad854b3b851d0c739f111995a8122aaa7147ce61355a1b,
+            0x2b242cf51e3fc841f925153bac6ae94b84c0e4839da70c3639ae554a2ffb538b,
+            0x71642f8fb008ca366c562ce0755bd0edc2cb3b1851d91871f7c217c6c17b812,
+            0x10628390eb8c9489dd00520c4d1f3bcb7917ee849eaec5d03d662192e40e4c05,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2c657cf556552ac00d3c6a312f941c21752d80f6fb971f6f237b9f067f55ef50,
+            0x2274e5afd41f484d4bb846c23f4d15eec892ed12abfc57aadc71c431dec0ec94,
+            0x21e3eead8292384cd4e9ab89698674acf899b310c4fb1474a50ed68ab15ee79b,
+            0x275b0e09088d1a143b3834ed09babfca45694301eb39680c7e01456918596140,
+            0x129eae0d0efd6629f2846e2659d11190f995e7f7976dba6706d5275f8ae42e2b,
+            0x23c3296abead985b298d2f7359d6fc6b66428469efef7f33cce72f7d261e200e,
+            0x120eb3949a1bc6dadb99eb797c5089f6c81b8489e8d2fdb648759f9b7d950c92,
+            0x277b28338565bebe62ad1128dfd277e71dcc0f5cbf15884f3f4431aaa022ae2c,
+            0x4f36e389ff9ebb3bcd6810d8b233c0cccd2d0a9a86f0c6eced01bccdf453a94,
+            0x2548fa65475658066e282e043fb7e3a2e5916ad635f27977d292b0ad3ef3e4e5,
+            0x4565577c55373eed95c9aaf5c9d202c270ce37dc1a1a2232c856f88dff9364f,
+            0x233e72784c11da8ade7b9f172935e44a748c8cb94959122f9da6c7ed65a6cf10,
+            0x158b72f3087e0267336e27fc3921ee3a3a534b925fecb827ca25f7dc77523334,
+            0x15c260f3c32020be493ac81d6969ece9c8e8aab39cb11ad8c69bd97516886522,
+            0x2396362d574b22bf4f2b162ddb6879ae4aee803609c5af81b0cc96e1dd77fb69,
+            0x2d0bdfbd9147195907ed3568ae8309feb349fdff397c36b567099ae14a3770ff,
+            0x2cd487c6239575748dce9a1b1e9cbaaaa9df4bdbbfa64f68ab6ed9f9685898ec,
+            0x1e73a3297684b098cfd3e270ec4299fc88d970a924596014e9a7f602ee9b081b,
+            0x248862b26667bf9e71255c8473c4d4f498bf02d6fe6c554e9d6a8194b443c7b1,
+            0x12daded6502d15cc7ccfd3998e01c39851611629fd9a6562f628ef83c7910b8d,
+            0x15e998f00cc4dd24ff559089cd43bec5566f2505b8136c5ab74d9a426d875c75,
+            0x217fa23d5b14a9ffa837fcc744c4a64fd13e6fe162777fc834bf119df306c8c7,
+            0xcadcf98c06aba7c6f354cd05bb28857f3798b83111652ddda6e2f8fad6a0518,
+            0x1c5c0906f02d4a6e3fe315f26891dae1132436b3cfd048f897a2988abb14e005,
+            0x8452c4131a7a4f5730e877519de1b927a02260f56ab0e7cf23dd41010093ced,
+            0x72e4518998bb2aa7df1a094e4a1032a4f1651403a006aff7d8d3f8e0431b39a,
+            0xab9888d29232bea4dcd77c9627693a4f292375d6ab81482eb0cd718adcc4752,
+            0xfc2e5df60bb4a189253e73f07025b34dac9f8f6c215a26c53fa5b3b1482e105,
+            0x50e82e90a419f91e690625c51ad3da156afca51ed13531b0e67a3b89385273b,
+            0x2f88a4415d7e88cfd3cdf0a5b4bbc26b243319e20d0e4ce861a2f2a5042e93cb,
+            0x1e10e776d5e15e0786cd5d0ef96d1ab332eb05773833ea20cd5a19891df8da96,
+            0x17de64722cd216df23ac5fc20f4298bc5c23f17de82c80d361a1cc10c3f3b7a3,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1b9c2c4eebbe7516481522714ccefbcf9f46b1d9acd32a7074f6e247ad6cc86c,
+            0x1b40c39dbad124c570125eb0b2586ec99e260411e0dd871cff7869ec3864df9,
+            0x33cd9b171a83f21a643c9db6174fdb0a12ed70e96e4dbcd7cd13888c4b3eb55,
+            0x19cb8e0c054400347facfff66eacd97d794bd61b59323af411ad0fbe2f380942,
+            0x26c218511f870b55f305e1787e4b19e1ab682b8c823153abf87d6b93d808e4d9,
+            0x29e12c794848bfe525ab81ce659d2cf1111feb3fd7118f94e22a86b6f88b53cf,
+            0x3a6658a834c4e3616dc5f917fa062d251c8ba4cccd09532eca0d77981b0170,
+            0x168adabd67838fadbbf46c9d9716f71494ab077f42cacf9c45e489d342a3e15a,
+            0x11742863039a6788df3464d2644c239b1929c3f16f43efaf505e2416f5e23a1c,
+            0x126abad95e2b51fd989173eb24d170db35879d2ed95aeb53fc43f37b92e0da48,
+            0x23c212335569ce5f39553eb328159fefbdba99ea37be97365fe8049e550c93da,
+            0x2f4dd1170cd5681dd49cffa2b31105e7f1772c10277da6436208aa1a496c0ca3,
+            0x1f1add5db460502e7d77a5abe06b5391bfd9363ec845f737ca6c072f46d26164,
+            0xde4648c15ee1c296f4bbc50fcf033680afe8764c93b524d0c7f96a17c8fa0c1,
+            0x2940f3f803b79a69ec13670c3bcef58b3aa6225c5ff1b9fd8bcf1ce7d9da83a9,
+            0x6022a2c0e67a56ca21f209520eb78989c32443d6d66a659def8fb09e41dc3b,
+            0x2614b22ed71c1ebf563048afad7b64934e51c6c1787f79d6cacb0cfa401692f3,
+            0xae0351a3f38218d3f64682ea5b4bbd19c9da2312b6d66c98a4e5793f56037b6,
+            0x2acb14246a8372f36e96bae26d0298d0dec2a8037325848540d092927b247af7,
+            0x4ac1f3bf59ff8258755878919911219c901e45d368e485fd581702935e593b8,
+            0x637c3722f5a87f3c148453456b4bd91dde864a8d689b73b12379558e5fe427,
+            0x2ed10f87c57e6e4d78f31e18f1c7e9ee7c0b59117a6d034e2ead2aae114caa32,
+            0x2db539eff29b1c4e93218c6e10e9552179fb7b03fc7308882fa9ada5a9eb4776,
+            0xcaedc62eb88ea19a6ea5fde158da87c74f591099c56a110467fcbb2dcd21f79,
+            0x485d5824b4d88b5c32a715605487a6b58ae93461b15110f2a7f71887069940e,
+            0x20fa1c1846393fc776c5868c6eb0b841e64eaf613c2005ea361b317dabbca53e,
+            0x2e17fb34208254172d03928de8c56b8cc29f87e29e8aef1f79b13bfb5e7ae90d,
+            0x1d45f577db25f490276008376cf8b59a08f20d469d8676010f7f281d5cd1aeb1,
+            0x48ea8cd9295a1a3e48cb22507e7237d0a6566b58e4747c0896fbefd7aa0c7c2,
+            0x3059196428e054d558d0e6a091559ff419ddfeab8e2aa1ba796e98849098f404,
+            0x1170eb002f68247115722d0638fcea7c2b7f70024953c733bc8cd94a86c23ca7,
+            0x25fcb5f375ff3d5cc49ca2936b121d9591be3e09fc88efeea4cf90521aa04b97,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x23444707325fc7683a461c2dea2173d8472c0b5b13701b34b87203bffe8f4aa4,
+            0x2b272e00da1d1d1d764b7da9384cd2efb8db8604c01b9f2b833a7c1520369e3b,
+            0x17b59a35bca179afddf24993a2a28466862328d66cf18d77e8be5f950d7f957c,
+            0x20460d5c7e4548772c619dbe8a220b477882005180887377c0ecb4b4c20ce625,
+            0xd1346ae8fcfaefc96496235e8a4b6cac300a284f97be68f0a453c55569e2e1c,
+            0x29d5c8e901d6f659e2c9b51f5da873c776a55de9fe0a95910c5893d9d64c180d,
+            0x109297c57950d5ec34e371af14fe40615e26d74a4fd2562dbaf8b0cfc0da67b5,
+            0xafa294b0b8973e74c6bcbcdf0953726679268df4b7ab3a0af0496d80f4e915a,
+            0x1ccdae789483414efc596b7a74d20cc5af2de7595d53c80c6762e599c4c19918,
+            0x7d80df4e972d5962e8447454033d912127d2930fd5229d1274aacb93ab35467,
+            0x19e7ddd05077b3710fc6cf15a1746ff3f2ce7b0ad9355bdcc599e882881b7812,
+            0x19c52a43b8a53bb146faf681e98fc8670800b6b9dde47ea38a849b82c1f17920,
+            0x2ed2fd2f3a2f78c35d4ec54a41b9941d4040bf4f0766985c776b6726746efeb7,
+            0x117e9b92ef305e1cecef90cb404f6b178b1d2c216e8c3bf650ad5b9f675a2446,
+            0x27dbe49809655461a2940850aa8c41ce6dbd5221400a9dce49f9f3ff9b04dd57,
+            0x8bc85ab2f7b9d3152fec37fd1c66ef688e2d71e325dba40eeed84dced4ea11,
+            0x18550a78308e47e5ac75a3cd82d4389a37c6918ed42bffa89dd128c6b4cd6f53,
+            0x22d06c4fb6f2b725a93cb9e97f08f466c2d2078953f43f4159bdafe3a9bbc2d2,
+            0x1f3f2ff5ea4b6044d0d142c2850a8907dece24a9e7c508c09b3b7cbf1d2db33a,
+            0x2985a2e4d66f1b2c18c3f647d444474d432fd597dc23671ccb3bf61c1351e990,
+            0x177e8a83bcc683805e1af7e744206e05fc99f85b605b10f3f0867913ff45a521,
+            0x97666874717688dba3d9546ff71cb3fa829d101f2bec9a191b5915ec120b658,
+            0x15055d2177bd83ae6ef36e4f113f7a53fff218984f73588988acb7f890461698,
+            0xe0197b38f1671c3fb6a078cb443ece122bfdd9f47486f3fc5ddcdafefdc9c5c,
+            0x78b8c01a67c4e5cb15738416497b1d4b3d8fce7631cef919eb4a39015bb5b8e,
+            0x26f58171d43f5d52535468f97f3f4a76a56d43bb0c8560ac98ad6fc409c6895b,
+            0x2db3d892f554ae8b1b5819fbd4ae79f23a1f4627383656c93be2e3ff42f7e7c1,
+            0x196b74fdd43c9fa4f77111911dced6856b397b19da47474fe1a8f0de62bc57fc,
+            0x6238d5e3cdaa238c7670efd64dbcce481815965fdd55efa8ab1706d7a43aa38,
+            0x22332a4ce6b7a223d45c777c7bdc960669e4a801b4a76b88b66d05039a53eea0,
+            0x1f88fecb08e0101e470f5dcee2c8b846d2562f89cd27d92e6b00faacae30389f,
+            0xc2ada53a5fcfb484d0a65c509305fa3f00db8a2f961d4515c149c85e677c8d4,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x1b28926cd83b4658afd2d9cfdfdce6b87aa9a072634889320a35cdcb9215e5b9,
+            0x15d6448f76cf1b20262428f1e416bbd1af8630fb361d7f644639ad5b60d8f180,
+            0x2af5dfa19ccc918de449d5d3b592e6d04d78bd796e6f07098e64630f2079d1c9,
+            0x19d0ff169994b50d9ca896bffbd91f7f3b5c7d9ad51363fe5f0d2fb6185c2410,
+            0x2755fe866df7e2d95bc2c8072e5402ca6f588b7f2734a2a54a4c519ca8297474,
+            0x77a07258bfa21e2ac255e20a0d31d9a01cc85cad4bc02e6921a507ed5df4728,
+            0x2ece250f68cd231dfbbdd343c367626f3cc413a32be08ebaf996dc8150003b5f,
+            0x28d5f29f5df2a1b4fb5dc798dd2fb2d9099a9bb15e06933ccb382d3f712abc56,
+            0x2af8e1fcf37dcf5f55699d9929ef5fc6505dfa79e061782ebc6a4bda3100fec5,
+            0x1a391e08a393750010adbdfa7c621d382a29b98886d241cfe0c567bb37748954,
+            0x1da3f4058cc2ce6554842588dafe5f4517661730183f0b99f9aeacabfc7acfcd,
+            0x1e3b1802005fe7296d11441c07cbea61e32baf5484d40e315cb49e2063bb4942,
+            0x1eca6728a58b997d09ac9d9eae05bcd86afaeec5800dfd73fb0280edc996d61b,
+            0x2991dada2697975e05e0f74b4a69560557d34bef132ff73f3ecce501461f59c1,
+            0x13a9e49e7875c154539d20cfef506535c91422054cd04aa195e12695a073487b,
+            0xe97ef3325ec39935456c2a330435ef106d50b3d24a74e55045c58da778d2733,
+            0x234fd4e50ddc42b1a40b1410ad7d9bbe27d21eb61d1b4ab05516422214059ee6,
+            0xce167e175eb021fe2b91b0abb90c94667ea76c9a1139b958ecf14d64c617722,
+            0x15871010759972a879b18a4d18bac0870013ee1f646d63f4bc63fcde2847ae87,
+            0x168d81f62839ab0e29c4e03c0f570f9e44bd75eecde371611e98bac9a78c51cb,
+            0x2c0c157479d4268e5a40179ab0a915072b91889b1eb06e1bb0e30c5936deac3b,
+            0x2c1c6ea12c4f9343a80fd53d4169686705ffb51d3ff2766fd4c61f803e648e85,
+            0x12c2c9b7086ab39752ea4a0afbd8703ba2ff66c309d48f404d7eb4edb90aadfa,
+            0x16a90e916477870cb13cfc1ecfa73fe9365d36854efe87db94a2d8f019a3ee83,
+            0x1e5674b6f90be35ef343540b191b0ee45707bdd34452407ad9035dd3bd282799,
+            0x2daf0fbad1fe6737f7bca405e34dd0432a4bcd5acaaae29ddf9ed8ffc1f0c336,
+            0x2908cd47730b9b031d14f778c53b64aec2838f3370f8832ac1fd7ab2d10a32e1,
+            0x1385230fd1095a5c478a798071294b8a11c9805d10d4f27b670a868deff0a451,
+            0x1d163c58cf48bb8e02eb3193cdfee3ef9c85133c14f87db1829663e74d10620a,
+            0x2e557c38674c410f4d7c72ee1a36898f9c16ccbf5bf4709f49e1e727dffa2a55,
+            0x1c05ef08c0686e237cccd7c9f7279e5abdbc39f7a27dda7238e73f37526346df,
+            0x2527d4d7449be5d202aec33259a43c5daf25db035ba558b03308203a0e33f717,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x10a492ae5b487f258651a3aed0227cc02f6c7a8761586894c74e50b84ad8081a,
+            0x2403d5c045640a3867d3fff22c33d5a7d4cc9c86fb7f746f0cfaa6cf0009165,
+            0x2d5d1d7a9af2b5a434066ba829ad51a9d596c775d77dce9bb5e539df0869093d,
+            0x9a863c700ddced174ab9a2f52feab6a6fc50d640f7cda128d3e0db7cc6d5421,
+            0x2aab180f6e316fad89afe18cac953fe0795ad3b267d632d4192cdf7a7f09fb6f,
+            0xd96040a550ca9da53410c291bb03f2597546be222c18ecc3ce1a6b934c9e79c,
+            0x162f27f588a7684b059dcfe87e6f50d77e0b2b7c2a04d6b2bfea5e6677c07124,
+            0xb923196444f67bb7b9a3549947da0d1d65c2d863062820159e7b8a15763fbe2,
+            0x2004eab7ce64ce5a33d093bffdb3f5c8c062629a82df11c1b9d0237219653ab7,
+            0x1227bf877742b79ae1f3f94f4a7d99e2ed3a6a9e531f224f865ef504a5bcaea0,
+            0x20f776f86d93c05c559f42775c914befee8b6a77ce89e137ee9faf414a0985d7,
+            0x172aa65c733a6035cda4bd931733ecb05f160dea5fac191c85b7f96c03c76ff,
+            0x8be42f0fb8d0bd0918ae0c9a23d6c350992a03652a1443e10676ef0aab7758f,
+            0x1fd0be6c49952151cd278ae5631d6760f0b7faa1da5cf1f86e88f04332962b0d,
+            0xf9ac50342fd157a0cf0acac7bceaf4498140817dfb573e81bc6b455122abc7,
+            0xcb3dfddba8d704f6abe9c8d4c31c36ba7aabd8b33866d5c34920a61a0971ca6,
+            0xe770f3147cb0e321701d76e1090173d30171d6cb47618e96f0391cfe89a857c,
+            0x737d887efe6fe8f9472901487cce5dd61e60b27b3a3987a5107cc0c747c73d3,
+            0x1a385e2fdbacefe3fc505c0e8866ed36657ae93f963f4d8b9af435a98cc91fab,
+            0x47765901d35e5b9c88c43dd5f4141cba4debe6bc675e49a08069b787252a3c1,
+            0x1da4a4ede36f08e2b6f0000760e022e4c87b4828f5df067037e07ed0a3db70aa,
+            0x847d2c6657d2fa009b736d83e33c9861b0192212fe8edd90dd9dfe16f52f861,
+            0x3039ed5a92b2b6ac7e0dda476285292ccd649442508936442d4d3cc1d552383,
+            0x77951dcf1d2ed93be5b91b720b5387db3a4097e55cc7781b69c27f5eeefe04,
+            0xb585622b1f5eb8fdfcaad1c3cd7f944255a4618ebfc9f9dacf339e874df620a,
+            0x1a2a7bbd62d97bb265d127d44fe34b17d9da8ee75813b5c51b9e16ee8dd7b402,
+            0xdc48ec2dabd95e06d2987fd1824a959e084d4e62d1b2c5e503b33dbe6b30d02,
+            0x290de95aae65845be12406a4585f7187d3d6528bf7daf00a84da01e8dfb69e1f,
+            0xc017e46a4f39a1669a350ee495e7ad68562b222de7114a6c101adef47853293,
+            0x2f0b5fb02d18a781e744403921d82e54c4919d1686d824bf4e62b2e4cc088cf9,
+            0xe7e699b1dd9c60f0018d874e9364210eb920583d0d2d71567d38f4333bfa474,
+            0x9472c6ed2b6494433a9319f2b093f2fd1923059b6002a6e896fee03e19546b8,
+            0x196b76cefdcc7f6a54c71d40114a0bb82694c936f1573ac7ac1ea3fcce1fe938,
+            0x2a8a40093e2bc9627fe39aa84ab78c1ce1265e8cbe28569136f8b83dbf1e1a0e,
+            0x21d9b9f7094b3462aaa61148b272fba6556514dcb39cfb47b5414ac776944f82,
+            0x22be02328bc62605ca6d890565b9726e83b9d8f925e702412edf291b777df027,
+            0x27b5d7ddef018e17569d33d8c4e9003ae36382bb57caf96bb224b724cf237254,
+            0x54ec141c594bace5c88a41767e82517f8dcd8e02dd54f8fdc1c7223d3614982,
+            0x17f76454a7d3b049dc34c09012706560351dd12ff052187ba5228c9fd5abc646,
+            0x189a082f5c10117ffb6b064329b31026c852cd41e01352e6c7b9d12686200598,
+            0xc597daf1c2a8f602322f2796a1bca2aa3101cb8c9a876ee195a9bda90da5d5b,
+            0x2ac2e1037357e29885d73882899652c5cdaf8560ae356bbdf7ded11c139dc663,
+            0x6ca950f38af807cac3b6d74cb2937af0a2287576b78fddfd7200f06e66e5f22,
+            0x736209bdf8c1ac643b8ecd0950d2bb4dcd8745be7c8cf64432da264fc4c6a33,
+            0x1e96d9fd0f2db5bcee16ce782403a3a33acad70b237106686ad0bbd8bbc00d1f,
+            0x2d7f5635e4b127aab06795499bb1a6c97c54806d79823ff7871e519f4081cc1c,
+            0x1d8d18b18dd07bb89fe0c84a7740faed098c6a2b0cde5f426fb8c8b7643bf95c,
+            0x28d51d4551904bbf04ec169bed853453358042ef76a08ea8d155f8677a051ccd,
+            0x189be365face10b9a4183d6f21048d6c36ca9c28b0720c71d72ed529654aa624,
+            0x130fc54477fd953377fc23abbd7a41be6764892a8787c759c1440fe0133c852d,
+            0x2c9c91f48661771baeef6774578a78f69c355c8e907156fdf26db39d2446413f,
+            0x1dec0bafa3e8190621e5e095ef751ea03c836dbb8045b2a73f8d397cfb815192,
+            0xa5f52ad6ec4a8aa377d8dd2ae3aaf6eea0c68c63a1d034fbda67133ca0b85cb,
+            0x20ab7394bfdab344cbb6f2123800a0e23508e2125bfe795ab4a767cecb4d9306,
+            0x110ea322b0c26476c67bfa2c1b9d1713f93b3b9cf8320ce0dcd4b64288bda07a,
+            0x54eabe6131681fa01fbc6dbf3e7d53595d0f8809987182142b890ac8af89cbe,
+            0x224d811fbdef8ec0a006d376a019e57c93bd596213a07823b7d4abce1fd8e621,
+            0xe691fca423128a7d4afcaa582b1a94799ba1f5d2a5d53bc2bba56bbecb227a1,
+            0x189e279c92de0bab66707e6e6e310524e615cd4c6aacc665372a3b8e372d8ce6,
+            0x1d9bcbbd17b93b1913d2f79cdf12844441237206f0294746d93f8e5bdceb4725,
+            0x1179184635a9780ee1312dcc3d15c7ef042b18ae9409670e28c4c7f0fb9b608e,
+            0xe48466182ae8333af1891a6aa19736741ed0680d57c931ede13fc07ae82e88b,
+            0x1c9d56f71c2f22c44d3a8c17bf5b40452e05471f0b6dfe9ffe4725eb29f73464,
+            0x2234546f5e8541e8f72ad794891950b32b1cd891cc66775c5b635961642e9c15,
+            0x14c09d155c5d428198c234b553da338f227cbc12b0e42f2b9ce71563ee1495c0
+        ]
     )
 }
diff --git a/noir_stdlib/src/hash/poseidon/bn254/perm.nr b/noir_stdlib/src/hash/poseidon/bn254/perm.nr
index 890f54fdb3f..b7c022c5a00 100644
--- a/noir_stdlib/src/hash/poseidon/bn254/perm.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254/perm.nr
@@ -1,6 +1,6 @@
 // Instantiations of Poseidon permutation for the prime field of the same order as BN254
 use crate::hash::poseidon::bn254::consts;
-use crate::hash::poseidon::bn254::permute;
+use crate::hash::poseidon::permute;
 use crate::hash::poseidon::PoseidonConfig;
 
 #[field(bn254)]

From db561e229cfcb35f23205cbb7e41fcf5ece68ee5 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 28 May 2024 14:17:49 -0500
Subject: [PATCH 311/416] fix(experimental elaborator): Fix duplicate
 `resolve_type` on self type and don't leak a trait impl's generics (#5102)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Fixes two issues:
- Use cached `resolved_object_type` instead of re-resolving the self
type in `declare_methods_on_struct` and `check_trait_impl_coherence`.
This is needed to prevent duplicate errors, and in the later case, since
generics are not added to scope to be able to re-resolve the object type
at that point.
- Fix a case when resolving trait impls that `self.generics` was not
cleared afterward.

## Additional Context

Down to 112 errors in the standard library now. The remaining errors are
variants of:
- "Duplicate definitions of \<global> found"
- "Duplicate definitions of \<generic> found" - looks to be only one
case where there is a generic directly on a trait method. `fn
hash<H>(self, state: &mut H) where H: Hasher;`
- "Expression type is ambiguous" - from the two turbofish cases that
haven't been merged in this branch yet
- "Expected type &mut _, found type H" - issues with auto-deref and
trait methods possibly
- "No matching impl found for ..." - trait solver issues

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
Co-authored-by: Álvaro Rodríguez <sirasistant@gmail.com>
Co-authored-by: guipublic <47281315+guipublic@users.noreply.github.com>
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 153 ++++++++----------
 .../noirc_frontend/src/elaborator/traits.rs   | 138 ++++++++--------
 .../src/hir/def_collector/dc_crate.rs         |   6 +-
 .../src/hir/def_collector/dc_mod.rs           |   1 +
 4 files changed, 135 insertions(+), 163 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 261a97ec3fb..903751331b3 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -223,8 +223,8 @@ impl<'context> Elaborator<'context> {
         //
         // These are resolved after trait impls so that struct methods are chosen
         // over trait methods if there are name conflicts.
-        for ((typ, module), impls) in &mut items.impls {
-            this.collect_impls(typ, *module, impls);
+        for ((_self_type, module), impls) in &mut items.impls {
+            this.collect_impls(*module, impls);
         }
 
         // We must wait to resolve non-literal globals until after we resolve structs since struct
@@ -284,8 +284,6 @@ impl<'context> Elaborator<'context> {
         self.scopes.start_function();
         self.current_item = Some(DependencyId::Function(id));
 
-        // Check whether the function has globals in the local module and add them to the scope
-        self.resolve_local_globals();
         self.trait_bounds = function.def.where_clause.clone();
 
         if function.def.is_unconstrained {
@@ -474,18 +472,6 @@ impl<'context> Elaborator<'context> {
         None
     }
 
-    fn resolve_local_globals(&mut self) {
-        let globals = vecmap(self.interner.get_all_globals(), |global| {
-            (global.id, global.local_id, global.ident.clone())
-        });
-        for (id, local_module_id, name) in globals {
-            if local_module_id == self.local_module {
-                let definition = DefinitionKind::Global(id);
-                self.add_global_variable_decl(name, definition);
-            }
-        }
-    }
-
     /// TODO: This is currently only respected for generic free functions
     /// there's a bunch of other places where trait constraints can pop up
     fn resolve_trait_constraints(
@@ -494,21 +480,20 @@ impl<'context> Elaborator<'context> {
     ) -> Vec<TraitConstraint> {
         where_clause
             .iter()
-            .cloned()
             .filter_map(|constraint| self.resolve_trait_constraint(constraint))
             .collect()
     }
 
     pub fn resolve_trait_constraint(
         &mut self,
-        constraint: UnresolvedTraitConstraint,
+        constraint: &UnresolvedTraitConstraint,
     ) -> Option<TraitConstraint> {
-        let typ = self.resolve_type(constraint.typ);
+        let typ = self.resolve_type(constraint.typ.clone());
         let trait_generics =
-            vecmap(constraint.trait_bound.trait_generics, |typ| self.resolve_type(typ));
+            vecmap(&constraint.trait_bound.trait_generics, |typ| self.resolve_type(typ.clone()));
 
         let span = constraint.trait_bound.trait_path.span();
-        let the_trait = self.lookup_trait_or_error(constraint.trait_bound.trait_path)?;
+        let the_trait = self.lookup_trait_or_error(constraint.trait_bound.trait_path.clone())?;
         let trait_id = the_trait.id;
 
         let expected_generics = the_trait.generics.len();
@@ -548,9 +533,6 @@ impl<'context> Elaborator<'context> {
         self.scopes.start_function();
         self.current_item = Some(DependencyId::Function(func_id));
 
-        // Check whether the function has globals in the local module and add them to the scope
-        self.resolve_local_globals();
-
         let location = Location::new(func.name_ident().span(), self.file);
         let id = self.interner.function_definition_id(func_id);
         let name_ident = HirIdent::non_trait_method(id, location);
@@ -864,40 +846,69 @@ impl<'context> Elaborator<'context> {
         self.file = trait_impl.file_id;
         self.local_module = trait_impl.module_id;
 
-        let unresolved_type = trait_impl.object_type;
-        let self_type_span = unresolved_type.span;
-        let old_generics_length = self.generics.len();
         self.generics = trait_impl.resolved_generics;
+        self.current_trait_impl = trait_impl.impl_id;
 
-        let trait_generics =
-            vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
+        self.elaborate_functions(trait_impl.methods);
 
-        let self_type = trait_impl.resolved_object_type.unwrap_or(Type::Error);
-        let impl_id =
-            trait_impl.impl_id.expect("An impls' id should be set during define_function_metas");
+        self.self_type = None;
+        self.current_trait_impl = None;
+        self.generics.clear();
+    }
 
-        self.current_trait_impl = trait_impl.impl_id;
+    fn collect_impls(
+        &mut self,
+        module: LocalModuleId,
+        impls: &mut [(Vec<Ident>, Span, UnresolvedFunctions)],
+    ) {
+        self.local_module = module;
 
-        let methods = trait_impl.methods.function_ids();
+        for (generics, span, unresolved) in impls {
+            self.file = unresolved.file_id;
+            let old_generic_count = self.generics.len();
+            self.add_generics(generics);
+            self.declare_methods_on_struct(false, unresolved, *span);
+            self.generics.truncate(old_generic_count);
+        }
+    }
 
-        self.elaborate_functions(trait_impl.methods);
+    fn collect_trait_impl(&mut self, trait_impl: &mut UnresolvedTraitImpl) {
+        self.local_module = trait_impl.module_id;
+        self.file = trait_impl.file_id;
+        trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
+
+        let self_type = trait_impl.methods.self_type.clone();
+        let self_type =
+            self_type.expect("Expected struct type to be set before collect_trait_impl");
+
+        let self_type_span = trait_impl.object_type.span;
 
         if matches!(self_type, Type::MutableReference(_)) {
             let span = self_type_span.unwrap_or_else(|| trait_impl.trait_path.span());
             self.push_err(DefCollectorErrorKind::MutableReferenceInTraitImpl { span });
         }
 
+        assert!(trait_impl.trait_id.is_some());
         if let Some(trait_id) = trait_impl.trait_id {
+            self.collect_trait_impl_methods(trait_id, trait_impl);
+
+            let span = trait_impl.object_type.span.expect("All trait self types should have spans");
+            self.generics = trait_impl.resolved_generics.clone();
+            self.declare_methods_on_struct(true, &mut trait_impl.methods, span);
+
+            let methods = trait_impl.methods.function_ids();
             for func_id in &methods {
                 self.interner.set_function_trait(*func_id, self_type.clone(), trait_id);
             }
 
             let where_clause = trait_impl
                 .where_clause
-                .into_iter()
+                .iter()
                 .flat_map(|item| self.resolve_trait_constraint(item))
                 .collect();
 
+            let trait_generics = trait_impl.resolved_trait_generics.clone();
+
             let resolved_trait_impl = Shared::new(TraitImpl {
                 ident: trait_impl.trait_path.last_segment().clone(),
                 typ: self_type.clone(),
@@ -914,7 +925,7 @@ impl<'context> Elaborator<'context> {
                 self_type.clone(),
                 trait_id,
                 trait_generics,
-                impl_id,
+                trait_impl.impl_id.expect("impl_id should be set in define_function_metas"),
                 generics,
                 resolved_trait_impl,
             ) {
@@ -931,45 +942,7 @@ impl<'context> Elaborator<'context> {
             }
         }
 
-        self.self_type = None;
-        self.current_trait_impl = None;
-        self.generics.truncate(old_generics_length);
-    }
-
-    fn collect_impls(
-        &mut self,
-        self_type: &UnresolvedType,
-        module: LocalModuleId,
-        impls: &mut [(Vec<Ident>, Span, UnresolvedFunctions)],
-    ) {
-        self.local_module = module;
-
-        for (generics, span, unresolved) in impls {
-            self.file = unresolved.file_id;
-            self.recover_generics(|this| {
-                this.add_generics(generics);
-                this.declare_methods_on_struct(self_type, false, unresolved, *span);
-            });
-        }
-    }
-
-    fn collect_trait_impl(&mut self, trait_impl: &mut UnresolvedTraitImpl) {
-        self.local_module = trait_impl.module_id;
-        self.file = trait_impl.file_id;
-        trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
-
-        if let Some(trait_id) = trait_impl.trait_id {
-            self.collect_trait_impl_methods(trait_id, trait_impl);
-
-            let span = trait_impl.object_type.span.expect("All trait self types should have spans");
-            let object_type = &trait_impl.object_type;
-
-            self.recover_generics(|this| {
-                this.add_generics(&trait_impl.generics);
-                trait_impl.resolved_generics = this.generics.clone();
-                this.declare_methods_on_struct(object_type, true, &mut trait_impl.methods, span);
-            });
-        }
+        self.generics.clear();
     }
 
     fn get_module_mut(&mut self, module: ModuleId) -> &mut ModuleData {
@@ -979,14 +952,13 @@ impl<'context> Elaborator<'context> {
 
     fn declare_methods_on_struct(
         &mut self,
-        self_type: &UnresolvedType,
         is_trait_impl: bool,
         functions: &mut UnresolvedFunctions,
         span: Span,
     ) {
-        let self_type = self.resolve_type(self_type.clone());
-
-        functions.self_type = Some(self_type.clone());
+        let self_type = functions.self_type.as_ref();
+        let self_type =
+            self_type.expect("Expected struct type to be set before declare_methods_on_struct");
 
         let function_ids = functions.function_ids();
 
@@ -1016,11 +988,11 @@ impl<'context> Elaborator<'context> {
                 }
             }
 
-            self.declare_struct_methods(&self_type, &function_ids);
+            self.declare_struct_methods(self_type, &function_ids);
         // We can define methods on primitive types only if we're in the stdlib
-        } else if !is_trait_impl && self_type != Type::Error {
+        } else if !is_trait_impl && *self_type != Type::Error {
             if self.crate_id.is_stdlib() {
-                self.declare_struct_methods(&self_type, &function_ids);
+                self.declare_struct_methods(self_type, &function_ids);
             } else {
                 self.push_err(DefCollectorErrorKind::NonStructTypeInImpl { span });
             }
@@ -1145,8 +1117,8 @@ impl<'context> Elaborator<'context> {
         self.local_module = trait_impl.module_id;
         self.file = trait_impl.file_id;
 
-        let object_crate = match self.resolve_type(trait_impl.object_type.clone()) {
-            Type::Struct(struct_type, _) => struct_type.borrow().id.krate(),
+        let object_crate = match &trait_impl.resolved_object_type {
+            Some(Type::Struct(struct_type, _)) => struct_type.borrow().id.krate(),
             _ => CrateId::Dummy,
         };
 
@@ -1163,7 +1135,6 @@ impl<'context> Elaborator<'context> {
         self.local_module = alias.module_id;
 
         let generics = self.add_generics(&alias.type_alias_def.generics);
-        self.resolve_local_globals();
         self.current_item = Some(DependencyId::Alias(alias_id));
         let typ = self.resolve_type(alias.type_alias_def.typ);
         self.interner.set_type_alias(alias_id, typ, generics);
@@ -1215,9 +1186,6 @@ impl<'context> Elaborator<'context> {
         self.recover_generics(|this| {
             let generics = this.add_generics(&unresolved.generics);
 
-            // Check whether the struct definition has globals in the local module and add them to the scope
-            this.resolve_local_globals();
-
             this.current_item = Some(DependencyId::Struct(struct_id));
 
             this.resolving_ids.insert(struct_id);
@@ -1253,7 +1221,7 @@ impl<'context> Elaborator<'context> {
         let (let_statement, _typ) = self.elaborate_let(let_stmt);
 
         let statement_id = self.interner.get_global(global_id).let_statement;
-        self.interner.get_global_definition_mut(global_id).kind = definition_kind;
+        self.interner.get_global_definition_mut(global_id).kind = definition_kind.clone();
         self.interner.replace_statement(statement_id, let_statement);
     }
 
@@ -1286,6 +1254,11 @@ impl<'context> Elaborator<'context> {
 
             let unresolved_type = &trait_impl.object_type;
             self.add_generics(&trait_impl.generics);
+            trait_impl.resolved_generics = self.generics.clone();
+
+            let trait_generics =
+                vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
+            trait_impl.resolved_trait_generics = trait_generics;
 
             let self_type = self.resolve_type(unresolved_type.clone());
 
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index 76cdc592276..2a35467f55a 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -13,7 +13,7 @@ use crate::{
     },
     node_interner::{FuncId, TraitId},
     token::Attributes,
-    Generics, Type, TypeVariable, TypeVariableKind,
+    Type, TypeVariableKind,
 };
 
 use super::Elaborator;
@@ -21,21 +21,21 @@ use super::Elaborator;
 impl<'context> Elaborator<'context> {
     pub fn collect_traits(&mut self, traits: BTreeMap<TraitId, UnresolvedTrait>) {
         for (trait_id, unresolved_trait) in traits {
-            let generics = vecmap(&unresolved_trait.trait_def.generics, |_| {
-                TypeVariable::unbound(self.interner.next_type_variable_id())
-            });
-
-            // Resolve order
-            // 1. Trait Types ( Trait constants can have a trait type, therefore types before constants)
-            let _ = self.resolve_trait_types(&unresolved_trait);
-            // 2. Trait Constants ( Trait's methods can use trait types & constants, therefore they should be after)
-            let _ = self.resolve_trait_constants(&unresolved_trait);
-            // 3. Trait Methods
-            let methods = self.resolve_trait_methods(trait_id, &unresolved_trait, &generics);
-
-            self.interner.update_trait(trait_id, |trait_def| {
-                trait_def.set_methods(methods);
-                trait_def.generics = generics;
+            self.recover_generics(|this| {
+                this.add_generics(&unresolved_trait.trait_def.generics);
+
+                // Resolve order
+                // 1. Trait Types ( Trait constants can have a trait type, therefore types before constants)
+                let _ = this.resolve_trait_types(&unresolved_trait);
+                // 2. Trait Constants ( Trait's methods can use trait types & constants, therefore they should be after)
+                let _ = this.resolve_trait_constants(&unresolved_trait);
+                // 3. Trait Methods
+                let methods = this.resolve_trait_methods(trait_id, &unresolved_trait);
+
+                this.interner.update_trait(trait_id, |trait_def| {
+                    trait_def.set_methods(methods);
+                    trait_def.generics = vecmap(&this.generics, |(_, generic, _)| generic.clone());
+                });
             });
 
             // This check needs to be after the trait's methods are set since
@@ -64,7 +64,6 @@ impl<'context> Elaborator<'context> {
         &mut self,
         trait_id: TraitId,
         unresolved_trait: &UnresolvedTrait,
-        trait_generics: &Generics,
     ) -> Vec<TraitFunction> {
         self.local_module = unresolved_trait.module_id;
         self.file = self.def_maps[&self.crate_id].file_id(unresolved_trait.module_id);
@@ -81,59 +80,57 @@ impl<'context> Elaborator<'context> {
                 body: _,
             } = item
             {
-                let old_generic_count = self.generics.len();
-
-                let the_trait = self.interner.get_trait(trait_id);
-                let self_typevar = the_trait.self_type_typevar.clone();
-                let self_type = Type::TypeVariable(self_typevar.clone(), TypeVariableKind::Normal);
-                let name_span = the_trait.name.span();
-
-                self.add_generics(generics);
-                self.add_existing_generics(&unresolved_trait.trait_def.generics, trait_generics);
-                self.add_existing_generic("Self", name_span, self_typevar);
-                self.self_type = Some(self_type.clone());
-
-                let func_id = unresolved_trait.method_ids[&name.0.contents];
-                self.resolve_trait_function(
-                    name,
-                    generics,
-                    parameters,
-                    return_type,
-                    where_clause,
-                    func_id,
-                );
-
-                let arguments = vecmap(parameters, |param| self.resolve_type(param.1.clone()));
-                let return_type = self.resolve_type(return_type.get_type().into_owned());
-
-                let generics = vecmap(&self.generics, |(_, type_var, _)| type_var.clone());
-
-                let default_impl_list: Vec<_> = unresolved_trait
-                    .fns_with_default_impl
-                    .functions
-                    .iter()
-                    .filter(|(_, _, q)| q.name() == name.0.contents)
-                    .collect();
-
-                let default_impl = if default_impl_list.len() == 1 {
-                    Some(Box::new(default_impl_list[0].2.clone()))
-                } else {
-                    None
-                };
-
-                let no_environment = Box::new(Type::Unit);
-                let function_type =
-                    Type::Function(arguments, Box::new(return_type), no_environment);
-
-                functions.push(TraitFunction {
-                    name: name.clone(),
-                    typ: Type::Forall(generics, Box::new(function_type)),
-                    location: Location::new(name.span(), unresolved_trait.file_id),
-                    default_impl,
-                    default_impl_module_id: unresolved_trait.module_id,
+                self.recover_generics(|this| {
+                    let the_trait = this.interner.get_trait(trait_id);
+                    let self_typevar = the_trait.self_type_typevar.clone();
+                    let self_type =
+                        Type::TypeVariable(self_typevar.clone(), TypeVariableKind::Normal);
+                    let name_span = the_trait.name.span();
+
+                    this.add_existing_generic("Self", name_span, self_typevar);
+                    this.add_generics(generics);
+                    this.self_type = Some(self_type.clone());
+
+                    let func_id = unresolved_trait.method_ids[&name.0.contents];
+                    this.resolve_trait_function(
+                        name,
+                        generics,
+                        parameters,
+                        return_type,
+                        where_clause,
+                        func_id,
+                    );
+
+                    let arguments = vecmap(parameters, |param| this.resolve_type(param.1.clone()));
+                    let return_type = this.resolve_type(return_type.get_type().into_owned());
+
+                    let generics = vecmap(&this.generics, |(_, type_var, _)| type_var.clone());
+
+                    let default_impl_list: Vec<_> = unresolved_trait
+                        .fns_with_default_impl
+                        .functions
+                        .iter()
+                        .filter(|(_, _, q)| q.name() == name.0.contents)
+                        .collect();
+
+                    let default_impl = if default_impl_list.len() == 1 {
+                        Some(Box::new(default_impl_list[0].2.clone()))
+                    } else {
+                        None
+                    };
+
+                    let no_environment = Box::new(Type::Unit);
+                    let function_type =
+                        Type::Function(arguments, Box::new(return_type), no_environment);
+
+                    functions.push(TraitFunction {
+                        name: name.clone(),
+                        typ: Type::Forall(generics, Box::new(function_type)),
+                        location: Location::new(name.span(), unresolved_trait.file_id),
+                        default_impl,
+                        default_impl_module_id: unresolved_trait.module_id,
+                    });
                 });
-
-                self.generics.truncate(old_generic_count);
             }
         }
         functions
@@ -151,9 +148,6 @@ impl<'context> Elaborator<'context> {
         let old_generic_count = self.generics.len();
         self.scopes.start_function();
 
-        // Check whether the function has globals in the local module and add them to the scope
-        self.resolve_local_globals();
-
         self.trait_bounds = where_clause.to_vec();
 
         let kind = FunctionKind::Normal;
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 838aac3f067..05147af5459 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -121,11 +121,15 @@ pub struct UnresolvedTraitImpl {
     pub generics: UnresolvedGenerics,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
 
-    // These fields are filled in later
+    // Every field after this line is filled in later in the elaborator
     pub trait_id: Option<TraitId>,
     pub impl_id: Option<TraitImplId>,
     pub resolved_object_type: Option<Type>,
     pub resolved_generics: Vec<(Rc<String>, TypeVariable, Span)>,
+
+    // The resolved generic on the trait itself. E.g. it is the `<C, D>` in
+    // `impl<A, B> Foo<C, D> for Bar<E, F> { ... }`
+    pub resolved_trait_generics: Vec<Type>,
 }
 
 #[derive(Clone)]
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 536332d8f8a..5f1ef6477af 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -197,6 +197,7 @@ impl<'a> ModCollector<'a> {
                 impl_id: None,
                 resolved_object_type: None,
                 resolved_generics: Vec::new(),
+                resolved_trait_generics: Vec::new(),
             };
 
             self.def_collector.items.trait_impls.push(unresolved_trait_impl);

From 7d8c0a3a1ae143b574b2fa62cae7c0a493005c70 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 28 May 2024 15:14:08 -0500
Subject: [PATCH 312/416] fix(experimental elaborator): Avoid calling
 `add_generics` twice on trait methods (#5108)

# Description

## Problem\*

Resolves the single "Duplicate definitions of <generic> found" error.

## Summary\*

Since `resolve_trait_function` already calls `add_generics` indirectly
via `define_function_meta`, we were adding generics on trait methods
twice before. I've removed the first of the two to fix this.

## Additional Context

After this the only errors that remain are the 5 on these lines of the
stdlib:
https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/eddsa.nr#L49-L53.
I believe these are the result of something from the turbofish changes
being missed (likely https://github.com/noir-lang/noir/pull/5041) since
they were recently modified from
https://github.com/noir-lang/noir/pull/5050.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 21 +++++--
 .../noirc_frontend/src/elaborator/patterns.rs | 60 +++++++++++++++++--
 .../noirc_frontend/src/elaborator/traits.rs   |  7 ++-
 .../src/hir/resolution/resolver.rs            |  1 +
 .../noirc_frontend/src/hir/type_check/mod.rs  |  1 +
 .../noirc_frontend/src/hir_def/function.rs    |  4 ++
 6 files changed, 79 insertions(+), 15 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 903751331b3..10ebd657494 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -295,9 +295,11 @@ impl<'context> Elaborator<'context> {
             .expect("FuncMetas should be declared before a function is elaborated")
             .clone();
 
-        for (parameter, param2) in function.def.parameters.iter().zip(&func_meta.parameters.0) {
-            let definition_kind = DefinitionKind::Local(None);
-            self.elaborate_pattern(parameter.pattern.clone(), param2.1.clone(), definition_kind);
+        // The DefinitionIds for each parameter were already created in define_function_meta
+        // so we need to reintroduce the same IDs into scope here.
+        for parameter in &func_meta.parameter_idents {
+            let name = self.interner.definition_name(parameter.id).to_owned();
+            self.add_existing_variable_to_scope(name, parameter.clone());
         }
 
         self.generics = func_meta.all_generics.clone();
@@ -560,8 +562,9 @@ impl<'context> Elaborator<'context> {
         self.add_generics(&func.def.generics);
 
         let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
-        let mut parameters = vec![];
-        let mut parameter_types = vec![];
+        let mut parameters = Vec::new();
+        let mut parameter_types = Vec::new();
+        let mut parameter_idents = Vec::new();
 
         for Param { visibility, pattern, typ, span: _ } in func.parameters().iter().cloned() {
             if visibility == Visibility::Public && !self.pub_allowed(func) {
@@ -579,7 +582,12 @@ impl<'context> Elaborator<'context> {
                 has_inline_attribute,
                 type_span,
             );
-            let pattern = self.elaborate_pattern(pattern, typ.clone(), DefinitionKind::Local(None));
+            let pattern = self.elaborate_pattern_and_store_ids(
+                pattern,
+                typ.clone(),
+                DefinitionKind::Local(None),
+                &mut parameter_idents,
+            );
 
             parameters.push((pattern, typ.clone(), visibility));
             parameter_types.push(typ);
@@ -648,6 +656,7 @@ impl<'context> Elaborator<'context> {
             all_generics: self.generics.clone(),
             trait_impl: self.current_trait_impl,
             parameters: parameters.into(),
+            parameter_idents,
             return_type: func.def.return_type.clone(),
             return_visibility: func.def.return_visibility,
             has_body: !func.def.body.is_empty(),
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 17c11b88f4a..b6d6cb2cf2d 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -27,7 +27,19 @@ impl<'context> Elaborator<'context> {
         expected_type: Type,
         definition_kind: DefinitionKind,
     ) -> HirPattern {
-        self.elaborate_pattern_mut(pattern, expected_type, definition_kind, None)
+        self.elaborate_pattern_mut(pattern, expected_type, definition_kind, None, &mut Vec::new())
+    }
+
+    /// Equivalent to `elaborate_pattern`, this version just also
+    /// adds any new DefinitionIds that were created to the given Vec.
+    pub(super) fn elaborate_pattern_and_store_ids(
+        &mut self,
+        pattern: Pattern,
+        expected_type: Type,
+        definition_kind: DefinitionKind,
+        created_ids: &mut Vec<HirIdent>,
+    ) -> HirPattern {
+        self.elaborate_pattern_mut(pattern, expected_type, definition_kind, None, created_ids)
     }
 
     fn elaborate_pattern_mut(
@@ -36,6 +48,7 @@ impl<'context> Elaborator<'context> {
         expected_type: Type,
         definition: DefinitionKind,
         mutable: Option<Span>,
+        new_definitions: &mut Vec<HirIdent>,
     ) -> HirPattern {
         match pattern {
             Pattern::Identifier(name) => {
@@ -47,6 +60,7 @@ impl<'context> Elaborator<'context> {
                 };
                 let ident = self.add_variable_decl(name, mutable.is_some(), true, definition);
                 self.interner.push_definition_type(ident.id, expected_type);
+                new_definitions.push(ident.clone());
                 HirPattern::Identifier(ident)
             }
             Pattern::Mutable(pattern, span, _) => {
@@ -54,8 +68,13 @@ impl<'context> Elaborator<'context> {
                     self.push_err(ResolverError::UnnecessaryMut { first_mut, second_mut: span });
                 }
 
-                let pattern =
-                    self.elaborate_pattern_mut(*pattern, expected_type, definition, Some(span));
+                let pattern = self.elaborate_pattern_mut(
+                    *pattern,
+                    expected_type,
+                    definition,
+                    Some(span),
+                    new_definitions,
+                );
                 let location = Location::new(span, self.file);
                 HirPattern::Mutable(Box::new(pattern), location)
             }
@@ -79,7 +98,13 @@ impl<'context> Elaborator<'context> {
 
                 let fields = vecmap(fields.into_iter().enumerate(), |(i, field)| {
                     let field_type = field_types.get(i).cloned().unwrap_or(Type::Error);
-                    self.elaborate_pattern_mut(field, field_type, definition.clone(), mutable)
+                    self.elaborate_pattern_mut(
+                        field,
+                        field_type,
+                        definition.clone(),
+                        mutable,
+                        new_definitions,
+                    )
                 });
                 let location = Location::new(span, self.file);
                 HirPattern::Tuple(fields, location)
@@ -91,10 +116,12 @@ impl<'context> Elaborator<'context> {
                 expected_type,
                 definition,
                 mutable,
+                new_definitions,
             ),
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn elaborate_struct_pattern(
         &mut self,
         name: Path,
@@ -103,6 +130,7 @@ impl<'context> Elaborator<'context> {
         expected_type: Type,
         definition: DefinitionKind,
         mutable: Option<Span>,
+        new_definitions: &mut Vec<HirIdent>,
     ) -> HirPattern {
         let error_identifier = |this: &mut Self| {
             // Must create a name here to return a HirPattern::Identifier. Allowing
@@ -140,6 +168,7 @@ impl<'context> Elaborator<'context> {
             expected_type.clone(),
             definition,
             mutable,
+            new_definitions,
         );
 
         HirPattern::Struct(expected_type, fields, location)
@@ -148,6 +177,7 @@ impl<'context> Elaborator<'context> {
     /// Resolve all the fields of a struct constructor expression.
     /// Ensures all fields are present, none are repeated, and all
     /// are part of the struct.
+    #[allow(clippy::too_many_arguments)]
     fn resolve_constructor_pattern_fields(
         &mut self,
         struct_type: Shared<StructType>,
@@ -156,6 +186,7 @@ impl<'context> Elaborator<'context> {
         expected_type: Type,
         definition: DefinitionKind,
         mutable: Option<Span>,
+        new_definitions: &mut Vec<HirIdent>,
     ) -> Vec<(Ident, HirPattern)> {
         let mut ret = Vec::with_capacity(fields.len());
         let mut seen_fields = HashSet::default();
@@ -163,8 +194,13 @@ impl<'context> Elaborator<'context> {
 
         for (field, pattern) in fields {
             let field_type = expected_type.get_field_type(&field.0.contents).unwrap_or(Type::Error);
-            let resolved =
-                self.elaborate_pattern_mut(pattern, field_type, definition.clone(), mutable);
+            let resolved = self.elaborate_pattern_mut(
+                pattern,
+                field_type,
+                definition.clone(),
+                mutable,
+                new_definitions,
+            );
 
             if unseen_fields.contains(&field) {
                 unseen_fields.remove(&field);
@@ -239,6 +275,18 @@ impl<'context> Elaborator<'context> {
         ident
     }
 
+    pub fn add_existing_variable_to_scope(&mut self, name: String, ident: HirIdent) {
+        let second_span = ident.location.span;
+        let resolver_meta = ResolverMeta { num_times_used: 0, ident, warn_if_unused: true };
+
+        let old_value = self.scopes.get_mut_scope().add_key_value(name.clone(), resolver_meta);
+
+        if let Some(old_value) = old_value {
+            let first_span = old_value.ident.location.span;
+            self.push_err(ResolverError::DuplicateDefinition { name, first_span, second_span });
+        }
+    }
+
     pub fn add_global_variable_decl(
         &mut self,
         name: Ident,
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index 2a35467f55a..30a6f50ad5a 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -88,7 +88,6 @@ impl<'context> Elaborator<'context> {
                     let name_span = the_trait.name.span();
 
                     this.add_existing_generic("Self", name_span, self_typevar);
-                    this.add_generics(generics);
                     this.self_type = Some(self_type.clone());
 
                     let func_id = unresolved_trait.method_ids[&name.0.contents];
@@ -101,8 +100,10 @@ impl<'context> Elaborator<'context> {
                         func_id,
                     );
 
-                    let arguments = vecmap(parameters, |param| this.resolve_type(param.1.clone()));
-                    let return_type = this.resolve_type(return_type.get_type().into_owned());
+                    let func_meta = this.interner.function_meta(&func_id);
+
+                    let arguments = vecmap(&func_meta.parameters.0, |(_, typ, _)| typ.clone());
+                    let return_type = func_meta.return_type().clone();
 
                     let generics = vecmap(&this.generics, |(_, type_var, _)| type_var.clone());
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 9fe0d473f15..fd77312e4f2 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1110,6 +1110,7 @@ impl<'a> Resolver<'a> {
             // This is only used by the elaborator
             all_generics: Vec::new(),
             is_trait_function: false,
+            parameter_idents: Vec::new(),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 70d7c4021ed..de2e575b4e2 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -552,6 +552,7 @@ pub mod test {
             is_trait_function: false,
             has_inline_attribute: false,
             all_generics: Vec::new(),
+            parameter_idents: Vec::new(),
         };
         interner.push_fn_meta(func_meta, func_id);
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 9e03f074ffe..3bd85e94dca 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -95,6 +95,10 @@ pub struct FuncMeta {
 
     pub parameters: Parameters,
 
+    /// The HirIdent of each identifier within the parameter list.
+    /// Note that this includes separate entries for each identifier in e.g. tuple patterns.
+    pub parameter_idents: Vec<HirIdent>,
+
     pub return_type: FunctionReturnType,
 
     pub return_visibility: Visibility,

From f03f8aed34393f7b0f6f68a189ce6c6192f6af6e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 28 May 2024 23:23:40 +0100
Subject: [PATCH 313/416] chore: remove duplicated code from LSP (#5116)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We've got some copy pasted code here so I've added a helper function for
converting a "position" to a "location".

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 tooling/lsp/src/requests/goto_declaration.rs | 40 ++++++--------------
 tooling/lsp/src/requests/goto_definition.rs  | 40 ++++++--------------
 tooling/lsp/src/requests/mod.rs              | 28 +++++++++++++-
 3 files changed, 50 insertions(+), 58 deletions(-)

diff --git a/tooling/lsp/src/requests/goto_declaration.rs b/tooling/lsp/src/requests/goto_declaration.rs
index 5cff16b2348..4ffe6abf88a 100644
--- a/tooling/lsp/src/requests/goto_declaration.rs
+++ b/tooling/lsp/src/requests/goto_declaration.rs
@@ -5,12 +5,13 @@ use crate::LspState;
 use crate::{parse_diff, resolve_workspace_for_source_path};
 use async_lsp::{ErrorCode, ResponseError};
 
+use fm::PathString;
 use lsp_types::request::{GotoDeclarationParams, GotoDeclarationResponse};
 
 use nargo::insert_all_files_for_workspace_into_file_manager;
 use noirc_driver::file_manager_with_stdlib;
 
-use super::{position_to_byte_index, to_lsp_location};
+use super::{position_to_location, to_lsp_location};
 
 pub(crate) fn on_goto_declaration_request(
     state: &mut LspState,
@@ -32,8 +33,6 @@ fn on_goto_definition_inner(
     let workspace = resolve_workspace_for_source_path(file_path.as_path()).unwrap();
     let package = workspace.members.first().unwrap();
 
-    let package_root_path: String = package.root_dir.as_os_str().to_string_lossy().into();
-
     let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_diff(&workspace_file_manager, state);
@@ -41,40 +40,25 @@ fn on_goto_definition_inner(
     let (mut context, crate_id) =
         nargo::prepare_package(&workspace_file_manager, &parsed_files, package);
 
-    let interner;
-    if let Some(def_interner) = state.cached_definitions.get(&package_root_path) {
-        interner = def_interner;
+    let package_root_path = package.root_dir.as_os_str().to_string_lossy().into_owned();
+    let interner = if let Some(def_interner) = state.cached_definitions.get(&package_root_path) {
+        def_interner
     } else {
         // We ignore the warnings and errors produced by compilation while resolving the definition
         let _ = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
-        interner = &context.def_interner;
-    }
-
-    let files = context.file_manager.as_file_map();
-    let file_id = context.file_manager.name_to_id(file_path.clone()).ok_or(ResponseError::new(
-        ErrorCode::REQUEST_FAILED,
-        format!("Could not find file in file manager. File path: {:?}", file_path),
-    ))?;
-    let byte_index =
-        position_to_byte_index(files, file_id, &params.text_document_position_params.position)
-            .map_err(|err| {
-                ResponseError::new(
-                    ErrorCode::REQUEST_FAILED,
-                    format!("Could not convert position to byte index. Error: {:?}", err),
-                )
-            })?;
-
-    let search_for_location = noirc_errors::Location {
-        file: file_id,
-        span: noirc_errors::Span::single_char(byte_index as u32),
+        &context.def_interner
     };
 
+    let files = workspace_file_manager.as_file_map();
+    let file_path = PathString::from(file_path);
+    let search_for_location =
+        position_to_location(files, &file_path, &params.text_document_position_params.position)?;
+
     let goto_declaration_response =
         interner.get_declaration_location_from(search_for_location).and_then(|found_location| {
             let file_id = found_location.file;
             let definition_position = to_lsp_location(files, file_id, found_location.span)?;
-            let response: GotoDeclarationResponse =
-                GotoDeclarationResponse::from(definition_position).to_owned();
+            let response = GotoDeclarationResponse::from(definition_position).to_owned();
             Some(response)
         });
 
diff --git a/tooling/lsp/src/requests/goto_definition.rs b/tooling/lsp/src/requests/goto_definition.rs
index 32e13ce00f6..3a92e28cc11 100644
--- a/tooling/lsp/src/requests/goto_definition.rs
+++ b/tooling/lsp/src/requests/goto_definition.rs
@@ -4,12 +4,13 @@ use crate::{parse_diff, resolve_workspace_for_source_path};
 use crate::{types::GotoDefinitionResult, LspState};
 use async_lsp::{ErrorCode, ResponseError};
 
+use fm::PathString;
 use lsp_types::request::GotoTypeDefinitionParams;
 use lsp_types::{GotoDefinitionParams, GotoDefinitionResponse};
 use nargo::insert_all_files_for_workspace_into_file_manager;
 use noirc_driver::file_manager_with_stdlib;
 
-use super::{position_to_byte_index, to_lsp_location};
+use super::{position_to_location, to_lsp_location};
 
 pub(crate) fn on_goto_definition_request(
     state: &mut LspState,
@@ -40,8 +41,6 @@ fn on_goto_definition_inner(
     let workspace = resolve_workspace_for_source_path(file_path.as_path()).unwrap();
     let package = workspace.members.first().unwrap();
 
-    let package_root_path: String = package.root_dir.as_os_str().to_string_lossy().into();
-
     let mut workspace_file_manager = file_manager_with_stdlib(&workspace.root_dir);
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_diff(&workspace_file_manager, state);
@@ -49,41 +48,26 @@ fn on_goto_definition_inner(
     let (mut context, crate_id) =
         nargo::prepare_package(&workspace_file_manager, &parsed_files, package);
 
-    let interner;
-    if let Some(def_interner) = state.cached_definitions.get(&package_root_path) {
-        interner = def_interner;
+    let package_root_path = package.root_dir.as_os_str().to_string_lossy().into_owned();
+    let interner = if let Some(def_interner) = state.cached_definitions.get(&package_root_path) {
+        def_interner
     } else {
         // We ignore the warnings and errors produced by compilation while resolving the definition
         let _ = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
-        interner = &context.def_interner;
-    }
-
-    let files = context.file_manager.as_file_map();
-    let file_id = context.file_manager.name_to_id(file_path.clone()).ok_or(ResponseError::new(
-        ErrorCode::REQUEST_FAILED,
-        format!("Could not find file in file manager. File path: {:?}", file_path),
-    ))?;
-    let byte_index =
-        position_to_byte_index(files, file_id, &params.text_document_position_params.position)
-            .map_err(|err| {
-                ResponseError::new(
-                    ErrorCode::REQUEST_FAILED,
-                    format!("Could not convert position to byte index. Error: {:?}", err),
-                )
-            })?;
-
-    let search_for_location = noirc_errors::Location {
-        file: file_id,
-        span: noirc_errors::Span::single_char(byte_index as u32),
+        &context.def_interner
     };
 
+    let files = workspace_file_manager.as_file_map();
+    let file_path = PathString::from(file_path);
+    let search_for_location =
+        position_to_location(files, &file_path, &params.text_document_position_params.position)?;
+
     let goto_definition_response = interner
         .get_definition_location_from(search_for_location, return_type_location_instead)
         .and_then(|found_location| {
             let file_id = found_location.file;
             let definition_position = to_lsp_location(files, file_id, found_location.span)?;
-            let response: GotoDefinitionResponse =
-                GotoDefinitionResponse::from(definition_position).to_owned();
+            let response = GotoDefinitionResponse::from(definition_position).to_owned();
             Some(response)
         });
 
diff --git a/tooling/lsp/src/requests/mod.rs b/tooling/lsp/src/requests/mod.rs
index ec56cf5045a..769e9ba17ce 100644
--- a/tooling/lsp/src/requests/mod.rs
+++ b/tooling/lsp/src/requests/mod.rs
@@ -1,8 +1,8 @@
 use std::future::Future;
 
 use crate::types::{CodeLensOptions, InitializeParams};
-use async_lsp::ResponseError;
-use fm::codespan_files::Error;
+use async_lsp::{ErrorCode, ResponseError};
+use fm::{codespan_files::Error, FileMap, PathString};
 use lsp_types::{
     DeclarationCapability, Location, Position, TextDocumentSyncCapability, TextDocumentSyncKind,
     TypeDefinitionProviderCapability, Url,
@@ -171,6 +171,30 @@ where
     }
 }
 
+fn position_to_location(
+    files: &FileMap,
+    file_path: &PathString,
+    position: &Position,
+) -> Result<noirc_errors::Location, ResponseError> {
+    let file_id = files.get_file_id(file_path).ok_or(ResponseError::new(
+        ErrorCode::REQUEST_FAILED,
+        format!("Could not find file in file manager. File path: {:?}", file_path),
+    ))?;
+    let byte_index = position_to_byte_index(files, file_id, position).map_err(|err| {
+        ResponseError::new(
+            ErrorCode::REQUEST_FAILED,
+            format!("Could not convert position to byte index. Error: {:?}", err),
+        )
+    })?;
+
+    let location = noirc_errors::Location {
+        file: file_id,
+        span: noirc_errors::Span::single_char(byte_index as u32),
+    };
+
+    Ok(location)
+}
+
 fn character_to_line_offset(line: &str, character: u32) -> Result<usize, Error> {
     let line_len = line.len();
     let mut character_offset = 0;

From b545744aa01fd7e60723701cb0b6e7cfaff4bb74 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 29 May 2024 15:26:57 +0100
Subject: [PATCH 314/416] chore: run all test programs in brillig as well as
 ACIR (#5128)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR helps ensure consistency between ACIR and brillig by checking
that every `execution_success` test case were compiled and run in
brillig then it would succeed.

This has thrown up a couple of test case failures which I've added to a
list to be ignored for now. We can address these in follow-up PRs

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../brillig_array_eq/Prover.toml              |  2 -
 .../brillig_array_eq/src/main.nr              |  4 --
 .../brillig_bit_shifts_runtime/Nargo.toml     |  6 --
 .../brillig_bit_shifts_runtime/Prover.toml    |  2 -
 .../brillig_bit_shifts_runtime/src/main.nr    | 20 ------
 .../brillig_embedded_curve/Nargo.toml         |  6 --
 .../brillig_embedded_curve/Prover.toml        |  3 -
 .../brillig_embedded_curve/src/main.nr        | 24 -------
 .../brillig_schnorr/Prover.toml               | 70 -------------------
 .../brillig_schnorr/src/main.nr               | 25 -------
 .../brillig_signed_cmp/Nargo.toml             |  6 --
 .../brillig_to_be_bytes/Nargo.toml            |  6 --
 .../brillig_to_be_bytes/Prover.toml           |  1 -
 .../brillig_to_be_bytes/src/main.nr           | 12 ----
 .../brillig_to_bytes_integration/Nargo.toml   |  6 --
 .../brillig_to_bytes_integration/Prover.toml  |  2 -
 .../brillig_to_bytes_integration/src/main.nr  | 27 -------
 .../brillig_to_le_bytes/Nargo.toml            |  6 --
 .../brillig_to_le_bytes/Prover.toml           |  1 -
 .../brillig_to_le_bytes/src/main.nr           | 10 ---
 .../brillig_top_level/Nargo.toml              |  6 --
 .../brillig_top_level/Prover.toml             |  2 -
 .../brillig_top_level/src/main.nr             |  6 --
 .../{brillig_to_bits => empty}/Nargo.toml     |  2 +-
 .../execution_success/empty/src/main.nr       |  1 +
 .../Nargo.toml                                |  2 +-
 .../Prover.toml                               |  0
 .../src/main.nr                               |  2 +-
 .../Nargo.toml                                |  2 +-
 .../Prover.toml                               |  0
 .../src/main.nr                               |  0
 .../{brillig_wrapping => to_bits}/Nargo.toml  |  3 +-
 .../{brillig_to_bits => to_bits}/src/main.nr  |  2 +-
 .../unconstrained_empty/Nargo.toml            |  5 --
 .../unconstrained_empty/src/main.nr           |  1 -
 .../Nargo.toml                                |  2 +-
 .../Prover.toml                               |  0
 .../src/main.nr                               |  2 +-
 tooling/nargo_cli/build.rs                    | 34 +++++++++
 39 files changed, 43 insertions(+), 268 deletions(-)
 delete mode 100644 test_programs/execution_success/brillig_array_eq/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_array_eq/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_bit_shifts_runtime/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_bit_shifts_runtime/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_embedded_curve/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_embedded_curve/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_embedded_curve/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_schnorr/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_schnorr/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_signed_cmp/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_to_be_bytes/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_to_be_bytes/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_to_be_bytes/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_to_bytes_integration/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_to_bytes_integration/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_to_bytes_integration/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_to_le_bytes/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_to_le_bytes/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_to_le_bytes/src/main.nr
 delete mode 100644 test_programs/execution_success/brillig_top_level/Nargo.toml
 delete mode 100644 test_programs/execution_success/brillig_top_level/Prover.toml
 delete mode 100644 test_programs/execution_success/brillig_top_level/src/main.nr
 rename test_programs/execution_success/{brillig_to_bits => empty}/Nargo.toml (67%)
 create mode 100644 test_programs/execution_success/empty/src/main.nr
 rename test_programs/execution_success/{brillig_schnorr => signed_cmp}/Nargo.toml (68%)
 rename test_programs/execution_success/{brillig_signed_cmp => signed_cmp}/Prover.toml (100%)
 rename test_programs/execution_success/{brillig_signed_cmp => signed_cmp}/src/main.nr (84%)
 rename test_programs/execution_success/{brillig_array_eq => signed_div}/Nargo.toml (67%)
 rename test_programs/execution_success/{brillig_signed_div => signed_div}/Prover.toml (100%)
 rename test_programs/execution_success/{brillig_signed_div => signed_div}/src/main.nr (100%)
 rename test_programs/execution_success/{brillig_wrapping => to_bits}/Nargo.toml (66%)
 rename test_programs/execution_success/{brillig_to_bits => to_bits}/src/main.nr (94%)
 delete mode 100644 test_programs/execution_success/unconstrained_empty/Nargo.toml
 delete mode 100644 test_programs/execution_success/unconstrained_empty/src/main.nr
 rename test_programs/execution_success/{brillig_signed_div => wrapping_operations}/Nargo.toml (65%)
 rename test_programs/execution_success/{brillig_wrapping => wrapping_operations}/Prover.toml (100%)
 rename test_programs/execution_success/{brillig_wrapping => wrapping_operations}/src/main.nr (79%)

diff --git a/test_programs/execution_success/brillig_array_eq/Prover.toml b/test_programs/execution_success/brillig_array_eq/Prover.toml
deleted file mode 100644
index ecfed7de213..00000000000
--- a/test_programs/execution_success/brillig_array_eq/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-a = [77,75,108,209,54,16,50,202,155,210,174,185,217,0,170,77,69,217,234,216,10,201,66,51,116,196,81,167,37,77,7,102]
-b = [77,75,108,209,54,16,50,202,155,210,174,185,217,0,170,77,69,217,234,216,10,201,66,51,116,196,81,167,37,77,7,102]
diff --git a/test_programs/execution_success/brillig_array_eq/src/main.nr b/test_programs/execution_success/brillig_array_eq/src/main.nr
deleted file mode 100644
index 90f631dbed8..00000000000
--- a/test_programs/execution_success/brillig_array_eq/src/main.nr
+++ /dev/null
@@ -1,4 +0,0 @@
-// Simple example of checking where two arrays are equal
-unconstrained fn main(a: [Field; 32], b: [Field; 32]) {
-    assert(a == b);
-}
diff --git a/test_programs/execution_success/brillig_bit_shifts_runtime/Nargo.toml b/test_programs/execution_success/brillig_bit_shifts_runtime/Nargo.toml
deleted file mode 100644
index ed8200d8a95..00000000000
--- a/test_programs/execution_success/brillig_bit_shifts_runtime/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_bit_shifts_runtime"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_bit_shifts_runtime/Prover.toml b/test_programs/execution_success/brillig_bit_shifts_runtime/Prover.toml
deleted file mode 100644
index 98d8630792e..00000000000
--- a/test_programs/execution_success/brillig_bit_shifts_runtime/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = 64
-y = 1
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr b/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr
deleted file mode 100644
index cdeaad7514c..00000000000
--- a/test_programs/execution_success/brillig_bit_shifts_runtime/src/main.nr
+++ /dev/null
@@ -1,20 +0,0 @@
-unconstrained fn main(x: u64, y: u8) {
-    // runtime shifts on compile-time known values
-    assert(64 as u32 << y == 128);
-    assert(64 as u32 >> y == 32);
-    // runtime shifts on runtime values
-    assert(x << y == 128);
-    assert(x >> y == 32);
-
-    // Bit-shift with signed integers
-    let mut a :i8 = y as i8;
-    let mut b: i8 = x as i8;
-    assert(b << 1 == -128);
-    assert(b >> 2 == 16);
-    assert(b >> y == 32);
-    a = -a;
-    assert(a << 7 == -128);
-    assert(a << y == -2);
-
-    assert(x >> (x as u8) == 0);
-}
diff --git a/test_programs/execution_success/brillig_embedded_curve/Nargo.toml b/test_programs/execution_success/brillig_embedded_curve/Nargo.toml
deleted file mode 100644
index b92e11d6383..00000000000
--- a/test_programs/execution_success/brillig_embedded_curve/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_embedded_curve"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_embedded_curve/Prover.toml b/test_programs/execution_success/brillig_embedded_curve/Prover.toml
deleted file mode 100644
index 7113b9cd038..00000000000
--- a/test_programs/execution_success/brillig_embedded_curve/Prover.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-priv_key = "1"
-pub_x = "0x0000000000000000000000000000000000000000000000000000000000000001"
-pub_y = "0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c"
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_embedded_curve/src/main.nr b/test_programs/execution_success/brillig_embedded_curve/src/main.nr
deleted file mode 100644
index 89a699448dc..00000000000
--- a/test_programs/execution_success/brillig_embedded_curve/src/main.nr
+++ /dev/null
@@ -1,24 +0,0 @@
-use dep::std;
-
-unconstrained fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
-    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
-    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y, is_infinite: false };
-    let scalar = std::embedded_curve_ops::EmbeddedCurveScalar { lo: priv_key, hi: 0 };
-    // Test that multi_scalar_mul correctly derives the public key
-    let res = std::embedded_curve_ops::multi_scalar_mul([g1], [scalar]);
-    assert(res[0] == pub_x);
-    assert(res[1] == pub_y);
-
-    // Test that double function calling embedded_curve_add works as expected
-    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y, is_infinite: false };
-    let res = pub_point.double();
-    let double = g1.add(g1);
-
-    assert(double.x == res.x);
-
-    // Test calling multi_scalar_mul with multiple points and scalars
-    let res = std::embedded_curve_ops::multi_scalar_mul([g1, g1], [scalar, scalar]);
-
-    // The results should be double the g1 point because the scalars are 1 and we pass in g1 twice
-    assert(double.x == res[0]);
-}
diff --git a/test_programs/execution_success/brillig_schnorr/Prover.toml b/test_programs/execution_success/brillig_schnorr/Prover.toml
deleted file mode 100644
index 2faf2018e07..00000000000
--- a/test_programs/execution_success/brillig_schnorr/Prover.toml
+++ /dev/null
@@ -1,70 +0,0 @@
-message = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-message_field = "0x010203040506070809"
-pub_key_x = "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a"
-pub_key_y = "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197"
-signature = [
-    1,
-    13,
-    119,
-    112,
-    212,
-    39,
-    233,
-    41,
-    84,
-    235,
-    255,
-    93,
-    245,
-    172,
-    186,
-    83,
-    157,
-    253,
-    76,
-    77,
-    33,
-    128,
-    178,
-    15,
-    214,
-    67,
-    105,
-    107,
-    177,
-    234,
-    77,
-    48,
-    27,
-    237,
-    155,
-    84,
-    39,
-    84,
-    247,
-    27,
-    22,
-    8,
-    176,
-    230,
-    24,
-    115,
-    145,
-    220,
-    254,
-    122,
-    135,
-    179,
-    171,
-    4,
-    214,
-    202,
-    64,
-    199,
-    19,
-    84,
-    239,
-    138,
-    124,
-    12,
-]
diff --git a/test_programs/execution_success/brillig_schnorr/src/main.nr b/test_programs/execution_success/brillig_schnorr/src/main.nr
deleted file mode 100644
index 03c635b4f6f..00000000000
--- a/test_programs/execution_success/brillig_schnorr/src/main.nr
+++ /dev/null
@@ -1,25 +0,0 @@
-use dep::std;
-// Note: If main has any unsized types, then the verifier will never be able
-// to figure out the circuit instance
-unconstrained fn main(
-    message: [u8; 10],
-    message_field: Field,
-    pub_key_x: Field,
-    pub_key_y: Field,
-    signature: [u8; 64]
-) {
-    // Regression for issue #2421
-    // We want to make sure that we can accurately verify a signature whose message is a slice vs. an array
-    let message_field_bytes = message_field.to_be_bytes(10);
-    for i in 0..10 {
-        assert(message[i] == message_field_bytes[i]);
-    }
-    // Is there ever a situation where someone would want 
-    // to ensure that a signature was invalid?
-    // Check that passing a slice as the message is valid
-    let valid_signature = std::schnorr::verify_signature_slice(pub_key_x, pub_key_y, signature, message_field_bytes);
-    assert(valid_signature);
-    // Check that passing an array as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
-    assert(valid_signature);
-}
diff --git a/test_programs/execution_success/brillig_signed_cmp/Nargo.toml b/test_programs/execution_success/brillig_signed_cmp/Nargo.toml
deleted file mode 100644
index 3f485df4a82..00000000000
--- a/test_programs/execution_success/brillig_signed_cmp/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_signed_cmp"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_to_be_bytes/Nargo.toml b/test_programs/execution_success/brillig_to_be_bytes/Nargo.toml
deleted file mode 100644
index df6c818c90f..00000000000
--- a/test_programs/execution_success/brillig_to_be_bytes/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_to_be_bytes"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_to_be_bytes/Prover.toml b/test_programs/execution_success/brillig_to_be_bytes/Prover.toml
deleted file mode 100644
index 07fe857ac7c..00000000000
--- a/test_programs/execution_success/brillig_to_be_bytes/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = "2040124"
diff --git a/test_programs/execution_success/brillig_to_be_bytes/src/main.nr b/test_programs/execution_success/brillig_to_be_bytes/src/main.nr
deleted file mode 100644
index 9d78411f060..00000000000
--- a/test_programs/execution_success/brillig_to_be_bytes/src/main.nr
+++ /dev/null
@@ -1,12 +0,0 @@
-unconstrained fn main(x: Field) -> pub [u8; 31] {
-    // The result of this byte array will be big-endian
-    let byte_array = x.to_be_bytes(31);
-    let mut bytes = [0; 31];
-    for i in 0..31 {
-        bytes[i] = byte_array[i];
-    }
-    assert(bytes[30] == 60);
-    assert(bytes[29] == 33);
-    assert(bytes[28] == 31);
-    bytes
-}
diff --git a/test_programs/execution_success/brillig_to_bytes_integration/Nargo.toml b/test_programs/execution_success/brillig_to_bytes_integration/Nargo.toml
deleted file mode 100644
index 991f3d1e46c..00000000000
--- a/test_programs/execution_success/brillig_to_bytes_integration/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_to_bytes_integration"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_to_bytes_integration/Prover.toml b/test_programs/execution_success/brillig_to_bytes_integration/Prover.toml
deleted file mode 100644
index 23f7acea449..00000000000
--- a/test_programs/execution_success/brillig_to_bytes_integration/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "2040124"
-_y = "0x2000000000000000000000000000000000000000000000000000000000000000"
diff --git a/test_programs/execution_success/brillig_to_bytes_integration/src/main.nr b/test_programs/execution_success/brillig_to_bytes_integration/src/main.nr
deleted file mode 100644
index e8e5b9db9ca..00000000000
--- a/test_programs/execution_success/brillig_to_bytes_integration/src/main.nr
+++ /dev/null
@@ -1,27 +0,0 @@
-use dep::std;
-
-unconstrained fn main(x: Field, _y: Field) {
-    // The result of this byte array will be big-endian
-    let y: Field = 2040124;
-    let be_byte_array = y.to_be_bytes(31);
-    // The result of this byte array will be little-endian
-    let le_byte_array = x.to_le_bytes(31);
-
-    assert(le_byte_array[0] == 60);
-    assert(le_byte_array[0] == be_byte_array[30]);
-    assert(le_byte_array[1] == be_byte_array[29]);
-    assert(le_byte_array[2] == be_byte_array[28]);
-
-    let z = 0 - 1;
-    let p_bytes = std::field::modulus_le_bytes();
-    let z_bytes = z.to_le_bytes(32);
-    assert(p_bytes[10] == z_bytes[10]);
-    assert(p_bytes[0] == z_bytes[0] as u8 + 1 as u8);
-
-    let p_bits = std::field::modulus_le_bits();
-    let z_bits = z.to_le_bits(std::field::modulus_num_bits() as u32);
-    assert(z_bits[0] == 0);
-    assert(p_bits[100] == z_bits[100]);
-
-    _y.to_le_bits(std::field::modulus_num_bits() as u32);
-}
diff --git a/test_programs/execution_success/brillig_to_le_bytes/Nargo.toml b/test_programs/execution_success/brillig_to_le_bytes/Nargo.toml
deleted file mode 100644
index c2ce8ad01b5..00000000000
--- a/test_programs/execution_success/brillig_to_le_bytes/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_to_le_bytes"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_to_le_bytes/Prover.toml b/test_programs/execution_success/brillig_to_le_bytes/Prover.toml
deleted file mode 100644
index 07fe857ac7c..00000000000
--- a/test_programs/execution_success/brillig_to_le_bytes/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = "2040124"
diff --git a/test_programs/execution_success/brillig_to_le_bytes/src/main.nr b/test_programs/execution_success/brillig_to_le_bytes/src/main.nr
deleted file mode 100644
index 77d292cf01b..00000000000
--- a/test_programs/execution_success/brillig_to_le_bytes/src/main.nr
+++ /dev/null
@@ -1,10 +0,0 @@
-unconstrained fn main(x: Field) -> pub [u8; 31] {
-    // The result of this byte array will be little-endian
-    let byte_array = x.to_le_bytes(31);
-    assert(byte_array.len() == 31);
-    let mut bytes = [0; 31];
-    for i in 0..31 {
-        bytes[i] = byte_array[i];
-    }
-    bytes
-}
diff --git a/test_programs/execution_success/brillig_top_level/Nargo.toml b/test_programs/execution_success/brillig_top_level/Nargo.toml
deleted file mode 100644
index f74a2a82964..00000000000
--- a/test_programs/execution_success/brillig_top_level/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_top_level"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_top_level/Prover.toml b/test_programs/execution_success/brillig_top_level/Prover.toml
deleted file mode 100644
index a0150a0e562..00000000000
--- a/test_programs/execution_success/brillig_top_level/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "1"
-array = ["4", "5", "6"]
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_top_level/src/main.nr b/test_programs/execution_success/brillig_top_level/src/main.nr
deleted file mode 100644
index 6dfd98b2c3e..00000000000
--- a/test_programs/execution_success/brillig_top_level/src/main.nr
+++ /dev/null
@@ -1,6 +0,0 @@
-// Tests a very simple program.
-// 
-// The feature being tested is brillig as the entry point.
-unconstrained fn main(array: [Field; 3], x: pub Field) -> pub [Field; 2] {
-    [array[x], array[x + 1]]
-}
diff --git a/test_programs/execution_success/brillig_to_bits/Nargo.toml b/test_programs/execution_success/empty/Nargo.toml
similarity index 67%
rename from test_programs/execution_success/brillig_to_bits/Nargo.toml
rename to test_programs/execution_success/empty/Nargo.toml
index a18b769550d..168911f2b2b 100644
--- a/test_programs/execution_success/brillig_to_bits/Nargo.toml
+++ b/test_programs/execution_success/empty/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_to_bits"
+name = "empty"
 type = "bin"
 authors = [""]
 [dependencies]
diff --git a/test_programs/execution_success/empty/src/main.nr b/test_programs/execution_success/empty/src/main.nr
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/test_programs/execution_success/empty/src/main.nr
@@ -0,0 +1 @@
+fn main() {}
diff --git a/test_programs/execution_success/brillig_schnorr/Nargo.toml b/test_programs/execution_success/signed_cmp/Nargo.toml
similarity index 68%
rename from test_programs/execution_success/brillig_schnorr/Nargo.toml
rename to test_programs/execution_success/signed_cmp/Nargo.toml
index 1b598abbf74..642a0924678 100644
--- a/test_programs/execution_success/brillig_schnorr/Nargo.toml
+++ b/test_programs/execution_success/signed_cmp/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_schnorr"
+name = "signed_cmp"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/brillig_signed_cmp/Prover.toml b/test_programs/execution_success/signed_cmp/Prover.toml
similarity index 100%
rename from test_programs/execution_success/brillig_signed_cmp/Prover.toml
rename to test_programs/execution_success/signed_cmp/Prover.toml
diff --git a/test_programs/execution_success/brillig_signed_cmp/src/main.nr b/test_programs/execution_success/signed_cmp/src/main.nr
similarity index 84%
rename from test_programs/execution_success/brillig_signed_cmp/src/main.nr
rename to test_programs/execution_success/signed_cmp/src/main.nr
index 3e3ea0f4b0f..85746ada8f4 100644
--- a/test_programs/execution_success/brillig_signed_cmp/src/main.nr
+++ b/test_programs/execution_success/signed_cmp/src/main.nr
@@ -1,4 +1,4 @@
-unconstrained fn main(minus_one: i8) {
+fn main(minus_one: i8) {
     assert(minus_one < 0);
     assert(0 < minus_one as u8);
     assert(0 > minus_one);
diff --git a/test_programs/execution_success/brillig_array_eq/Nargo.toml b/test_programs/execution_success/signed_div/Nargo.toml
similarity index 67%
rename from test_programs/execution_success/brillig_array_eq/Nargo.toml
rename to test_programs/execution_success/signed_div/Nargo.toml
index 62ce392f96b..5ce137d8c0c 100644
--- a/test_programs/execution_success/brillig_array_eq/Nargo.toml
+++ b/test_programs/execution_success/signed_div/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_array_eq"
+name = "signed_div"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/brillig_signed_div/Prover.toml b/test_programs/execution_success/signed_div/Prover.toml
similarity index 100%
rename from test_programs/execution_success/brillig_signed_div/Prover.toml
rename to test_programs/execution_success/signed_div/Prover.toml
diff --git a/test_programs/execution_success/brillig_signed_div/src/main.nr b/test_programs/execution_success/signed_div/src/main.nr
similarity index 100%
rename from test_programs/execution_success/brillig_signed_div/src/main.nr
rename to test_programs/execution_success/signed_div/src/main.nr
diff --git a/test_programs/execution_success/brillig_wrapping/Nargo.toml b/test_programs/execution_success/to_bits/Nargo.toml
similarity index 66%
rename from test_programs/execution_success/brillig_wrapping/Nargo.toml
rename to test_programs/execution_success/to_bits/Nargo.toml
index a52246ba908..ef47f3b4ba1 100644
--- a/test_programs/execution_success/brillig_wrapping/Nargo.toml
+++ b/test_programs/execution_success/to_bits/Nargo.toml
@@ -1,6 +1,5 @@
 [package]
-name = "brillig_wrapping"
+name = "to_bits"
 type = "bin"
 authors = [""]
-
 [dependencies]
diff --git a/test_programs/execution_success/brillig_to_bits/src/main.nr b/test_programs/execution_success/to_bits/src/main.nr
similarity index 94%
rename from test_programs/execution_success/brillig_to_bits/src/main.nr
rename to test_programs/execution_success/to_bits/src/main.nr
index 7ff3d2467b5..18f65f0bd66 100644
--- a/test_programs/execution_success/brillig_to_bits/src/main.nr
+++ b/test_programs/execution_success/to_bits/src/main.nr
@@ -1,6 +1,6 @@
 use dep::std;
 
-unconstrained fn main() {
+fn main() {
     let field = 1000;
     let be_bits = field.to_be_bits(16);
     let le_bits = field.to_le_bits(16);
diff --git a/test_programs/execution_success/unconstrained_empty/Nargo.toml b/test_programs/execution_success/unconstrained_empty/Nargo.toml
deleted file mode 100644
index 48d0f5938d8..00000000000
--- a/test_programs/execution_success/unconstrained_empty/Nargo.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-[package]
-name = "unconstrained_empty"
-type = "bin"
-authors = [""]
-[dependencies]
diff --git a/test_programs/execution_success/unconstrained_empty/src/main.nr b/test_programs/execution_success/unconstrained_empty/src/main.nr
deleted file mode 100644
index 5e5fb297236..00000000000
--- a/test_programs/execution_success/unconstrained_empty/src/main.nr
+++ /dev/null
@@ -1 +0,0 @@
-unconstrained fn main() {}
diff --git a/test_programs/execution_success/brillig_signed_div/Nargo.toml b/test_programs/execution_success/wrapping_operations/Nargo.toml
similarity index 65%
rename from test_programs/execution_success/brillig_signed_div/Nargo.toml
rename to test_programs/execution_success/wrapping_operations/Nargo.toml
index 4bb9c5ecc1c..3a28b3461ec 100644
--- a/test_programs/execution_success/brillig_signed_div/Nargo.toml
+++ b/test_programs/execution_success/wrapping_operations/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_signed_div"
+name = "wrapping_operations"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/brillig_wrapping/Prover.toml b/test_programs/execution_success/wrapping_operations/Prover.toml
similarity index 100%
rename from test_programs/execution_success/brillig_wrapping/Prover.toml
rename to test_programs/execution_success/wrapping_operations/Prover.toml
diff --git a/test_programs/execution_success/brillig_wrapping/src/main.nr b/test_programs/execution_success/wrapping_operations/src/main.nr
similarity index 79%
rename from test_programs/execution_success/brillig_wrapping/src/main.nr
rename to test_programs/execution_success/wrapping_operations/src/main.nr
index 4153a466057..85fd65b193c 100644
--- a/test_programs/execution_success/brillig_wrapping/src/main.nr
+++ b/test_programs/execution_success/wrapping_operations/src/main.nr
@@ -1,6 +1,6 @@
 use dep::std;
 
-unconstrained fn main(x: u8, y: u8) {
+fn main(x: u8, y: u8) {
     assert(std::wrapping_sub(x, 1) == y);
     assert(std::wrapping_add(y, 1) == x);
     assert(std::wrapping_mul(y, y) == 1);
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 74042cf4e40..53c3966cb4c 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -38,6 +38,26 @@ fn main() {
     generate_compile_failure_tests(&mut test_file, &test_dir);
 }
 
+/// Some tests are explicitly ignored in brillig due to them failing.
+/// These should be fixed and removed from this list.
+const IGNORED_BRILLIG_TESTS: [&str; 11] = [
+    // Takes a very long time to execute as large loops do not get simplified.
+    &"regression_4709",
+    // bit sizes for bigint operation doesn't match up.
+    &"bigint",
+    // ICE due to looking for function which doesn't exist.
+    &"fold_after_inlined_calls",
+    &"fold_basic",
+    &"fold_basic_nested_call",
+    &"fold_call_witness_condition",
+    &"fold_complex_outputs",
+    &"fold_distinct_return",
+    &"fold_fibonacci",
+    &"fold_numeric_generic_poseidon",
+    // Expected to fail as test asserts on which runtime it is in.
+    &"is_unconstrained",
+];
+
 fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_sub_dir = "execution_success";
     let test_data_dir = test_data_dir.join(test_sub_dir);
@@ -55,6 +75,9 @@ fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path)
         };
         let test_dir = &test_dir.path();
 
+        let brillig_ignored =
+            if IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) { "\n#[ignore]" } else { "" };
+
         write!(
             test_file,
             r#"
@@ -66,6 +89,17 @@ fn execution_success_{test_name}() {{
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("execute").arg("--force");
 
+    cmd.assert().success();
+}}
+
+#[test]{brillig_ignored}
+fn execution_success_{test_name}_brillig() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("execute").arg("--force").arg("--force-brillig");
+
     cmd.assert().success();
 }}
             "#,

From 69eca9b8671fa54192bef814dd584fdb5387a5f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Rodr=C3=ADguez?= <sirasistant@gmail.com>
Date: Wed, 29 May 2024 18:58:01 +0200
Subject: [PATCH 315/416] feat: Separate runtimes of SSA functions before
 inlining (#5121)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5043

<details>
<summary>Opcode count of Aztec public functions before => after this
change in the inlining strategy</summary>

```
_approve_bridge_and_exit_input_asset_to_L1 on contract Uniswap with size 3788 => 3166
_assert_token_is_same on contract TokenBridge with size 916 => 640
_assert_token_is_same on contract Uniswap with size 1845 => 1546
_borrow on contract Lending with size 10988 => 10152
_call_mint_on_token on contract TokenBridge with size 1427 => 1125
_check_deadline on contract Crowdfunding with size 1015 => 752
_deposit on contract Lending with size 1699 => 1220
_increase_public_balance on contract GasToken with size 1325 => 1103
_increase_public_balance on contract Token with size 1577 => 1201
_increase_public_balance on contract TokenBlacklist with size 1577 => 1201
_reduce_total_supply on contract Token with size 945 => 626
_reduce_total_supply on contract TokenBlacklist with size 945 => 626
_repay on contract Lending with size 6775 => 6284
_withdraw on contract Lending with size 10715 => 9850
add_args_return on contract AvmNestedCallsTest with size 15 => 15
add_args_return on contract AvmTest with size 15 => 15
add_storage_map on contract AvmTest with size 797 => 664
add_to_tally_public on contract EasyPrivateVoting with size 1496 => 1112
add_u128 on contract AvmTest with size 187 => 187
admin on contract Token with size 495 => 348
approve_public_authwit on contract EcdsaAccount with size 977 => 718
approve_public_authwit on contract SchnorrAccount with size 743 => 621
approve_public_authwit on contract SchnorrHardcodedAccount with size 742 => 620
approve_public_authwit on contract SchnorrSingleKeyAccount with size 742 => 620
assert_block_number on contract AppSubscription with size 920 => 669
assert_minter_and_mint on contract Token with size 1434 => 1035
assert_not_expired on contract AppSubscription with size 910 => 658
assert_nullifier_exists on contract AvmTest with size 242 => 156
assert_public_global_vars on contract Test with size 1054 => 679
assert_same on contract AvmNestedCallsTest with size 138 => 138
assert_unsiloed_nullifier_acvm on contract AvmAcvmInteropTest with size 102 => 16
assertion_failure on contract AvmTest with size 166 => 166
avm_to_acvm_call on contract AvmAcvmInteropTest with size 287 => 169
balance_of_public on contract GasToken with size 651 => 612
balance_of_public on contract Token with size 880 => 710
balance_of_public on contract TokenBlacklist with size 880 => 710
borrow_public on contract Lending with size 1193 => 939
broadcast on contract Benchmarking with size 419 => 337
burn_public on contract Token with size 2426 => 1962
burn_public on contract TokenBlacklist with size 3148 => 2468
call_acvm_from_avm on contract AvmAcvmInteropTest with size 574 => 503
call_avm_from_acvm on contract AvmAcvmInteropTest with size 578 => 507
check_balance on contract GasToken with size 856 => 768
check_selector on contract AvmTest with size 463 => 463
claim_public on contract GasToken with size 3963 => 3416
claim_public on contract TokenBridge with size 4176 => 3457
constant_field_acvm on contract AvmAcvmInteropTest with size 13 => 13
constant_field_avm on contract AvmAcvmInteropTest with size 13 => 13
constructor on contract AppSubscription with size 3376 => 1983
constructor on contract Auth with size 1414 => 994
constructor on contract AvmInitializerTest with size 1290 => 908
constructor on contract Claim with size 1700 => 1123
constructor on contract EasyPrivateVoting with size 1454 => 941
constructor on contract FPC with size 1700 => 1123
constructor on contract InclusionProofs with size 1021 => 704
constructor on contract Token with size 2737 => 1961
constructor on contract TokenBlacklist with size 1925 => 1285
constructor on contract TokenBridge with size 1400 => 924
constructor on contract Uniswap with size 1326 => 909
consume_message_from_arbitrary_sender_public on contract Test with size 2203 => 1893
consume_mint_public_message on contract Test with size 2910 => 2600
create_different_nullifier_in_nested_call on contract AvmNestedCallsTest with size 743 => 639
create_l2_to_l1_message_arbitrary_recipient_public on contract Test with size 56 => 12
create_l2_to_l1_message_public on contract Test with size 73 => 29
create_same_nullifier_in_nested_call on contract AvmNestedCallsTest with size 741 => 637
debug_logging on contract AvmTest with size 725 => 402
deposit_public on contract Lending with size 2286 => 1846
dummy_public_call on contract Test with size 354 => 284
emit_nullifier_and_check on contract AvmTest with size 436 => 314
emit_nullifier_public on contract Test with size 47 => 11
emit_unencrypted on contract Test with size 54 => 16
emit_unencrypted_log on contract AvmTest with size 757 => 685
end_vote on contract EasyPrivateVoting with size 514 => 279
exit_to_l1_public on contract TokenBridge with size 2154 => 1773
get_address on contract AvmTest with size 45 => 13
get_args_hash on contract AvmTest with size 18 => 18
get_asset on contract Lending with size 888 => 718
get_assets on contract Lending with size 587 => 411
get_authorized on contract Auth with size 597 => 443
get_authorized_delay on contract Auth with size 702 => 517
get_block_number on contract AvmTest with size 45 => 13
get_chain_id on contract AvmTest with size 45 => 13
get_fee_per_da_gas on contract AvmTest with size 45 => 13
get_fee_per_l2_gas on contract AvmTest with size 45 => 13
get_portal_address_public on contract TokenBridge with size 297 => 145
get_position on contract Lending with size 3908 => 3623
get_price on contract PriceFeed with size 617 => 579
get_public_value on contract StatefulTest with size 636 => 598
get_roles on contract TokenBlacklist with size 989 => 749
get_scheduled_authorized on contract Auth with size 595 => 443
get_sender on contract AvmTest with size 45 => 13
get_shared_immutable_constrained_public on contract DocsExample with size 438 => 406
get_shared_immutable_constrained_public_indirect on contract DocsExample with size 701 => 607
get_shared_immutable_constrained_public_multiple on contract DocsExample with size 136 => 98
get_storage_address on contract AvmTest with size 45 => 13
get_timestamp on contract AvmTest with size 45 => 13
get_token on contract TokenBridge with size 513 => 366
get_transaction_fee on contract AvmTest with size 45 => 13
get_version on contract AvmTest with size 45 => 13
increment_balance on contract Benchmarking with size 1472 => 1264
increment_public_value on contract StatefulTest with size 695 => 449
increment_public_value_no_init_check on contract StatefulTest with size 447 => 351
init on contract Crowdfunding with size 2100 => 1341
init on contract Lending with size 958 => 598
initialize_public_immutable on contract DocsExample with size 433 => 252
initialize_shared_immutable on contract DocsExample with size 433 => 252
is_minter on contract Token with size 838 => 668
is_time_equal on contract Test with size 56 => 18
keccak_hash on contract AvmTest with size 49 => 49
l1_to_l2_msg_exists on contract AvmTest with size 65 => 17
mint_private on contract Token with size 1247 => 790
mint_private on contract TokenBlacklist with size 1495 => 906
mint_public on contract GasToken with size 946 => 813
mint_public on contract Token with size 2048 => 1520
mint_public on contract TokenBlacklist with size 2821 => 2137
modulo2 on contract AvmTest with size 16 => 16
nested_call_to_add on contract AvmNestedCallsTest with size 862 => 756
nested_call_to_add_with_gas on contract AvmNestedCallsTest with size 929 => 799
nested_static_call_to_add on contract AvmNestedCallsTest with size 890 => 784
nested_static_call_to_set_storage on contract AvmNestedCallsTest with size 759 => 665
new_note_hash on contract AvmTest with size 47 => 11
new_nullifier on contract AvmAcvmInteropTest with size 47 => 11
new_nullifier on contract AvmNestedCallsTest with size 47 => 11
new_nullifier on contract AvmTest with size 47 => 11
new_nullifier_acvm on contract AvmAcvmInteropTest with size 47 => 11
note_hash_exists on contract AvmTest with size 65 => 17
nullifier_collision on contract AvmTest with size 82 => 12
nullifier_exists on contract AvmTest with size 103 => 17
on_card_played on contract CardGame with size 2386 => 2151
on_cards_claimed on contract CardGame with size 2176 => 1927
on_game_joined on contract CardGame with size 1972 => 1733
pay_refund on contract FPC with size 2052 => 1685
pay_refund_with_shielded_rebate on contract FPC with size 2138 => 1771
pedersen_hash on contract AvmTest with size 19 => 19
pedersen_hash_with_index on contract AvmTest with size 19 => 19
poseidon2_hash on contract AvmTest with size 1370 => 1370
prepare_fee on contract FPC with size 1643 => 1280
pub_call_public_fn on contract ImportTest with size 710 => 636
pub_entry_point on contract Parent with size 263 => 189
pub_entry_point_twice on contract Parent with size 497 => 339
pub_get_value on contract Child with size 174 => 22
pub_get_value on contract StaticChild with size 409 => 281
pub_illegal_inc_value on contract StaticChild with size 448 => 336
pub_inc_value on contract Child with size 175 => 45
pub_inc_value on contract StaticChild with size 175 => 45
pub_inc_value_internal on contract Child with size 552 => 340
pub_set_value on contract Child with size 108 => 30
pub_set_value on contract StaticChild with size 108 => 30
public_call on contract StaticParent with size 263 => 189
public_constructor on contract StatefulTest with size 1808 => 1399
public_delegate_set_value on contract Delegator with size 724 => 724
public_get_decimals on contract Token with size 557 => 411
public_get_name on contract Token with size 538 => 392
public_get_symbol on contract Token with size 546 => 400
public_get_value_from_child on contract StaticParent with size 759 => 685
public_nested_static_call on contract Parent with size 674 => 561
public_nested_static_call on contract StaticParent with size 1012 => 894
public_set_value on contract DelegatedOn with size 68 => 28
public_static_call on contract Parent with size 328 => 236
public_static_call on contract StaticParent with size 328 => 236
push_nullifier_public on contract InclusionProofs with size 285 => 117
read_storage_immutable on contract AvmInitializerTest with size 286 => 133
read_storage_list on contract AvmTest with size 101 => 62
read_storage_map on contract AvmTest with size 385 => 341
read_storage_single on contract AvmTest with size 66 => 27
register on contract KeyRegistry with size 6385 => 5041
repay_public on contract Lending with size 2141 => 1747
rotate_npk_m on contract KeyRegistry with size 2592 => 1843
send_l2_to_l1_msg on contract AvmTest with size 56 => 12
set_admin on contract Token with size 528 => 257
set_authorized on contract Auth with size 925 => 474
set_authorized_delay on contract Auth with size 679 => 400
set_minter on contract Token with size 865 => 559
set_opcode_big_field on contract AvmTest with size 19 => 19
set_opcode_small_field on contract AvmTest with size 13 => 13
set_opcode_u32 on contract AvmTest with size 13 => 13
set_opcode_u64 on contract AvmTest with size 13 => 13
set_opcode_u8 on contract AvmTest with size 13 => 13
set_portal on contract GasToken with size 434 => 272
set_price on contract PriceFeed with size 401 => 349
set_read_storage_single on contract AvmTest with size 122 => 42
set_storage_list on contract AvmTest with size 76 => 30
set_storage_map on contract AvmTest with size 409 => 355
set_storage_single on contract AvmNestedCallsTest with size 65 => 25
set_storage_single on contract AvmTest with size 65 => 25
set_value_twice_with_nested_first on contract Child with size 803 => 654
set_value_twice_with_nested_last on contract Child with size 791 => 654
set_value_with_two_nested_calls on contract Child with size 1308 => 1063
sha256_hash on contract AvmTest with size 47 => 47
shield on contract Token with size 2368 => 1809
shield on contract TokenBlacklist with size 3102 => 2315
spend_public_authwit on contract DocsExample with size 14 => 14
spend_public_authwit on contract EcdsaAccount with size 1008 => 637
spend_public_authwit on contract SchnorrAccount with size 770 => 541
spend_public_authwit on contract SchnorrHardcodedAccount with size 770 => 540
spend_public_authwit on contract SchnorrSingleKeyAccount with size 770 => 540
spend_public_authwit on contract Uniswap with size 749 => 486
start_game on contract CardGame with size 2518 => 2175
swap_public on contract Uniswap with size 7983 => 6584
test_authwit_send_money on contract AvmAcvmInteropTest with size 803 => 709
test_get_contract_instance on contract AvmTest with size 522 => 410
test_get_contract_instance_raw on contract AvmTest with size 159 => 83
test_nullifier_inclusion_from_public on contract InclusionProofs with size 332 => 121
to_radix_le on contract AvmTest with size 187 => 187
total_supply on contract Token with size 536 => 390
total_supply on contract TokenBlacklist with size 536 => 390
transfer_public on contract Token with size 3071 => 2512
transfer_public on contract TokenBlacklist with size 4491 => 3533
u128_addition_overflow on contract AvmTest with size 772 => 668
u128_from_integer_overflow on contract AvmTest with size 357 => 357
update_accumulator on contract Lending with size 8695 => 8358
update_leader on contract DocsExample with size 430 => 290
update_roles on contract TokenBlacklist with size 2058 => 1252
withdraw_public on contract Lending with size 1190 => 93
```

</details>


## Summary\*

This PR:
- Creates a separate pass for "runtime separation" where we convert any
Acir function called from brillig to a brillig function. After that
pass, all functions have correct runtime, meaning they'll be converted
to the runtime they hold.
- Updates the inliner to only consider entry points all brillig
functions called from ACIR and all brillig recursive functions, instead
of all brillig functions

With this change the inliner can correctly detect which brillig
functions **must not** be inlined. This opens the door to allowing
annotating brillig functions with inlining suggestions in the future.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/brillig_vm/src/memory.rs            |   6 +
 compiler/noirc_evaluator/src/ssa.rs           |   3 +-
 compiler/noirc_evaluator/src/ssa/ir/dfg.rs    |   2 +-
 .../noirc_evaluator/src/ssa/ir/function.rs    |   7 +
 compiler/noirc_evaluator/src/ssa/ir/map.rs    |   2 +-
 .../noirc_evaluator/src/ssa/opt/inlining.rs   | 160 ++++++--
 compiler/noirc_evaluator/src/ssa/opt/mod.rs   |   1 +
 .../src/ssa/opt/runtime_separation.rs         | 348 ++++++++++++++++++
 .../src/ssa/ssa_gen/program.rs                |   8 +
 .../acir_inside_brillig_recursion/Nargo.toml  |   6 +
 .../acir_inside_brillig_recursion/Prover.toml |   1 +
 .../acir_inside_brillig_recursion/src/main.nr |  15 +
 tooling/debugger/ignored-tests.txt            |  27 +-
 13 files changed, 531 insertions(+), 55 deletions(-)
 create mode 100644 compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs
 create mode 100644 test_programs/execution_success/acir_inside_brillig_recursion/Nargo.toml
 create mode 100644 test_programs/execution_success/acir_inside_brillig_recursion/Prover.toml
 create mode 100644 test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr

diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index 4092cd06ae0..6c6b5968cd7 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -294,6 +294,12 @@ impl<F: AcirField> Memory<F> {
     }
 
     pub fn read_slice(&self, addr: MemoryAddress, len: usize) -> &[MemoryValue<F>] {
+        // Allows to read a slice of uninitialized memory if the length is zero.
+        // Ideally we'd be able to read uninitialized memory in general (as read does)
+        // but that's not possible if we want to return a slice instead of owned data.
+        if len == 0 {
+            return &[];
+        }
         &self.inner[addr.to_usize()..(addr.to_usize() + len)]
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index d38601bfc1b..80a63f223e7 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -58,8 +58,9 @@ pub(crate) fn optimize_into_acir(
     let ssa = SsaBuilder::new(program, print_passes, force_brillig_output, print_timings)?
         .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
         .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
-        .run_pass(Ssa::inline_functions, "After Inlining:")
+        .run_pass(Ssa::separate_runtime, "After Runtime Separation:")
         .run_pass(Ssa::resolve_is_unconstrained, "After Resolving IsUnconstrained:")
+        .run_pass(Ssa::inline_functions, "After Inlining:")
         // Run mem2reg with the CFG separated into blocks
         .run_pass(Ssa::mem2reg, "After Mem2Reg:")
         .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
index 545827df1c5..f763ae52d50 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
@@ -22,7 +22,7 @@ use noirc_errors::Location;
 /// its blocks, instructions, and values. This struct is largely responsible for
 /// owning most data in a function and handing out Ids to this data that can be
 /// shared without worrying about ownership.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub(crate) struct DataFlowGraph {
     /// All of the instructions in a function
     instructions: DenseMap<Instruction>,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs
index a49e02b0380..c44824b464b 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs
@@ -64,6 +64,13 @@ impl Function {
         Self { name, id, entry_block, dfg, runtime: RuntimeType::Acir(InlineType::default()) }
     }
 
+    /// Creates a new function as a clone of the one passed in with the passed in id.
+    pub(crate) fn clone_with_id(id: FunctionId, another: &Function) -> Self {
+        let dfg = another.dfg.clone();
+        let entry_block = another.entry_block;
+        Self { name: another.name.clone(), id, entry_block, dfg, runtime: another.runtime }
+    }
+
     /// The name of the function.
     /// Used exclusively for debugging purposes.
     pub(crate) fn name(&self) -> &str {
diff --git a/compiler/noirc_evaluator/src/ssa/ir/map.rs b/compiler/noirc_evaluator/src/ssa/ir/map.rs
index b6055973f1c..3c3feabc390 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/map.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/map.rs
@@ -115,7 +115,7 @@ impl std::fmt::Display for Id<super::instruction::Instruction> {
 /// access to indices is provided. Since IDs must be stable and correspond
 /// to indices in the internal Vec, operations that would change element
 /// ordering like pop, remove, swap_remove, etc, are not possible.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub(crate) struct DenseMap<T> {
     storage: Vec<T>,
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 1293671da50..e2a7f51d0a0 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -27,7 +27,7 @@ const RECURSION_LIMIT: u32 = 1000;
 impl Ssa {
     /// Inline all functions within the IR.
     ///
-    /// In the case of recursive functions, this will attempt
+    /// In the case of recursive Acir functions, this will attempt
     /// to recursively inline until the RECURSION_LIMIT is reached.
     ///
     /// Functions are recursively inlined into main until either we finish
@@ -41,6 +41,8 @@ impl Ssa {
     /// There are some attributes that allow inlining a function at a different step of codegen.
     /// Currently this is just `InlineType::NoPredicates` for which we have a flag indicating
     /// whether treating that inline functions. The default is to treat these functions as entry points.
+    ///
+    /// This step should run after runtime separation, since it relies on the runtime of the called functions being final.
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn inline_functions(self) -> Ssa {
         Self::inline_functions_inner(self, true)
@@ -52,12 +54,17 @@ impl Ssa {
     }
 
     fn inline_functions_inner(mut self, no_predicates_is_entry_point: bool) -> Ssa {
+        let recursive_functions = find_all_recursive_functions(&self);
         self.functions = btree_map(
-            get_entry_point_functions(&self, no_predicates_is_entry_point),
+            get_functions_to_inline_into(&self, no_predicates_is_entry_point),
             |entry_point| {
-                let new_function =
-                    InlineContext::new(&self, entry_point, no_predicates_is_entry_point)
-                        .inline_all(&self);
+                let new_function = InlineContext::new(
+                    &self,
+                    entry_point,
+                    no_predicates_is_entry_point,
+                    recursive_functions.clone(),
+                )
+                .inline_all(&self);
                 (entry_point, new_function)
             },
         );
@@ -80,6 +87,8 @@ struct InlineContext {
     entry_point: FunctionId,
 
     no_predicates_is_entry_point: bool,
+    // We keep track of the recursive functions in the SSA to avoid inlining them in a brillig context.
+    recursive_functions: BTreeSet<FunctionId>,
 }
 
 /// The per-function inlining context contains information that is only valid for one function.
@@ -113,28 +122,101 @@ struct PerFunctionContext<'function> {
     inlining_entry: bool,
 }
 
-/// The entry point functions are each function we should inline into - and each function that
-/// should be left in the final program.
-/// This is the `main` function, any Acir functions with a [fold inline type][InlineType::Fold],
-/// and any brillig functions used.
-fn get_entry_point_functions(
+/// Utility function to find out the direct calls of a function.
+fn called_functions(func: &Function) -> BTreeSet<FunctionId> {
+    let mut called_function_ids = BTreeSet::default();
+    for block_id in func.reachable_blocks() {
+        for instruction_id in func.dfg[block_id].instructions() {
+            let Instruction::Call { func: called_value_id, .. } = &func.dfg[*instruction_id] else {
+                continue;
+            };
+
+            if let Value::Function(function_id) = func.dfg[*called_value_id] {
+                called_function_ids.insert(function_id);
+            }
+        }
+    }
+
+    called_function_ids
+}
+
+// Recursively explore the SSA to find the functions that end up calling themselves
+fn find_recursive_functions(
+    ssa: &Ssa,
+    current_function: FunctionId,
+    mut explored_functions: im::HashSet<FunctionId>,
+    recursive_functions: &mut BTreeSet<FunctionId>,
+) {
+    if explored_functions.contains(&current_function) {
+        recursive_functions.insert(current_function);
+        return;
+    }
+
+    let called_functions = called_functions(&ssa.functions[&current_function]);
+
+    explored_functions.insert(current_function);
+
+    for called_function in called_functions {
+        find_recursive_functions(
+            ssa,
+            called_function,
+            explored_functions.clone(),
+            recursive_functions,
+        );
+    }
+}
+
+fn find_all_recursive_functions(ssa: &Ssa) -> BTreeSet<FunctionId> {
+    let mut recursive_functions = BTreeSet::default();
+    find_recursive_functions(ssa, ssa.main_id, im::HashSet::default(), &mut recursive_functions);
+    recursive_functions
+}
+
+/// The functions we should inline into (and that should be left in the final program) are:
+///  - main
+///  - Any Brillig function called from Acir
+///  - Any Brillig recursive function (Acir recursive functions will be inlined into the main function)
+///  - Any Acir functions with a [fold inline type][InlineType::Fold],
+fn get_functions_to_inline_into(
     ssa: &Ssa,
     no_predicates_is_entry_point: bool,
 ) -> BTreeSet<FunctionId> {
-    let functions = ssa.functions.iter();
-    let mut entry_points = functions
-        .filter(|(_, function)| {
-            // If we have not already finished the flattening pass, functions marked
-            // to not have predicates should be marked as entry points.
-            let no_predicates_is_entry_point =
-                no_predicates_is_entry_point && function.is_no_predicates();
-            function.runtime().is_entry_point() || no_predicates_is_entry_point
+    let mut brillig_entry_points = BTreeSet::default();
+    let mut acir_entry_points = BTreeSet::default();
+
+    for (func_id, function) in ssa.functions.iter() {
+        if function.runtime() == RuntimeType::Brillig {
+            continue;
+        }
+
+        // If we have not already finished the flattening pass, functions marked
+        // to not have predicates should be marked as entry points.
+        let no_predicates_is_entry_point =
+            no_predicates_is_entry_point && function.is_no_predicates();
+        if function.runtime().is_entry_point() || no_predicates_is_entry_point {
+            acir_entry_points.insert(*func_id);
+        }
+
+        for called_function_id in called_functions(function) {
+            if ssa.functions[&called_function_id].runtime() == RuntimeType::Brillig {
+                brillig_entry_points.insert(called_function_id);
+            }
+        }
+    }
+
+    let brillig_recursive_functions: BTreeSet<_> = find_all_recursive_functions(ssa)
+        .into_iter()
+        .filter(|recursive_function_id| {
+            let function = &ssa.functions[&recursive_function_id];
+            function.runtime() == RuntimeType::Brillig
         })
-        .map(|(id, _)| *id)
-        .collect::<BTreeSet<_>>();
+        .collect();
 
-    entry_points.insert(ssa.main_id);
-    entry_points
+    std::iter::once(ssa.main_id)
+        .chain(acir_entry_points)
+        .chain(brillig_entry_points)
+        .chain(brillig_recursive_functions)
+        .collect()
 }
 
 impl InlineContext {
@@ -147,6 +229,7 @@ impl InlineContext {
         ssa: &Ssa,
         entry_point: FunctionId,
         no_predicates_is_entry_point: bool,
+        recursive_functions: BTreeSet<FunctionId>,
     ) -> InlineContext {
         let source = &ssa.functions[&entry_point];
         let mut builder = FunctionBuilder::new(source.name().to_owned(), entry_point);
@@ -157,6 +240,7 @@ impl InlineContext {
             entry_point,
             call_stack: CallStack::new(),
             no_predicates_is_entry_point,
+            recursive_functions,
         }
     }
 
@@ -391,18 +475,10 @@ impl<'function> PerFunctionContext<'function> {
             match &self.source_function.dfg[*id] {
                 Instruction::Call { func, arguments } => match self.get_function(*func) {
                     Some(func_id) => {
-                        let function = &ssa.functions[&func_id];
-                        // If we have not already finished the flattening pass, functions marked
-                        // to not have predicates should be marked as entry points unless we are inlining into brillig.
-                        let entry_point = &ssa.functions[&self.context.entry_point];
-                        let no_predicates_is_entry_point =
-                            self.context.no_predicates_is_entry_point
-                                && function.is_no_predicates()
-                                && !matches!(entry_point.runtime(), RuntimeType::Brillig);
-                        if function.runtime().is_entry_point() || no_predicates_is_entry_point {
-                            self.push_instruction(*id);
-                        } else {
+                        if self.should_inline_call(ssa, func_id) {
                             self.inline_function(ssa, *id, func_id, arguments);
+                        } else {
+                            self.push_instruction(*id);
                         }
                     }
                     None => self.push_instruction(*id),
@@ -412,6 +488,24 @@ impl<'function> PerFunctionContext<'function> {
         }
     }
 
+    fn should_inline_call(&self, ssa: &Ssa, called_func_id: FunctionId) -> bool {
+        let function = &ssa.functions[&called_func_id];
+
+        if let RuntimeType::Acir(inline_type) = function.runtime() {
+            // If the called function is acir, we inline if it's not an entry point
+
+            // If we have not already finished the flattening pass, functions marked
+            // to not have predicates should be marked as entry points.
+            let no_predicates_is_entry_point =
+                self.context.no_predicates_is_entry_point && function.is_no_predicates();
+            !inline_type.is_entry_point() && !no_predicates_is_entry_point
+        } else {
+            // If the called function is brillig, we inline only if it's into brillig and the function is not recursive
+            ssa.functions[&self.context.entry_point].runtime() == RuntimeType::Brillig
+                && !self.context.recursive_functions.contains(&called_func_id)
+        }
+    }
+
     /// Inline a function call and remember the inlined return values in the values map
     fn inline_function(
         &mut self,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index f6c3f022bfc..4e5fa262696 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -18,5 +18,6 @@ mod remove_bit_shifts;
 mod remove_enable_side_effects;
 mod remove_if_else;
 mod resolve_is_unconstrained;
+mod runtime_separation;
 mod simplify_cfg;
 mod unrolling;
diff --git a/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs b/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs
new file mode 100644
index 00000000000..c0c9c0a1372
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs
@@ -0,0 +1,348 @@
+use std::collections::BTreeSet;
+
+use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
+
+use crate::ssa::{
+    ir::{
+        function::{Function, FunctionId, RuntimeType},
+        instruction::Instruction,
+        value::{Value, ValueId},
+    },
+    ssa_gen::Ssa,
+};
+
+impl Ssa {
+    /// This optimization step separates the runtime of the functions in the SSA.
+    /// After this step, all functions with runtime `Acir` will be converted to Acir and
+    /// the functions with runtime `Brillig` will be converted to Brillig.
+    /// It does so by cloning all ACIR functions called from a Brillig context
+    /// and changing the runtime of the cloned functions to Brillig.
+    /// This pass needs to run after functions as values have been resolved (defunctionalization).
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn separate_runtime(mut self) -> Self {
+        RuntimeSeparatorContext::separate_runtime(&mut self);
+        self
+    }
+}
+
+#[derive(Debug, Default)]
+struct RuntimeSeparatorContext {
+    // Original functions to clone to brillig
+    acir_functions_called_from_brillig: BTreeSet<FunctionId>,
+    // Tracks the original => cloned version
+    mapped_functions: HashMap<FunctionId, FunctionId>,
+}
+
+impl RuntimeSeparatorContext {
+    pub(crate) fn separate_runtime(ssa: &mut Ssa) {
+        let mut runtime_separator = RuntimeSeparatorContext::default();
+
+        // We first collect all the acir functions called from a brillig context by exploring the SSA recursively
+        let mut processed_functions = HashSet::default();
+        runtime_separator.collect_acir_functions_called_from_brillig(
+            ssa,
+            ssa.main_id,
+            false,
+            &mut processed_functions,
+        );
+
+        // Now we clone the relevant acir functions and change their runtime to brillig
+        runtime_separator.convert_acir_functions_called_from_brillig_to_brillig(ssa);
+
+        // Now we update any calls within a brillig context to the mapped functions
+        runtime_separator.replace_calls_to_mapped_functions(ssa);
+
+        // Some functions might be unreachable now (for example an acir function only called from brillig)
+        prune_unreachable_functions(ssa);
+    }
+
+    fn collect_acir_functions_called_from_brillig(
+        &mut self,
+        ssa: &Ssa,
+        current_func_id: FunctionId,
+        mut within_brillig: bool,
+        processed_functions: &mut HashSet<(/* within_brillig */ bool, FunctionId)>,
+    ) {
+        // Processed functions needs the within brillig flag, since it is possible to call the same function from both brillig and acir
+        if processed_functions.contains(&(within_brillig, current_func_id)) {
+            return;
+        }
+        processed_functions.insert((within_brillig, current_func_id));
+
+        let func = &ssa.functions[&current_func_id];
+        if func.runtime() == RuntimeType::Brillig {
+            within_brillig = true;
+        }
+
+        let called_functions = called_functions(func);
+
+        if within_brillig {
+            for called_func_id in called_functions.iter() {
+                let called_func = &ssa.functions[&called_func_id];
+                if matches!(called_func.runtime(), RuntimeType::Acir(_)) {
+                    self.acir_functions_called_from_brillig.insert(*called_func_id);
+                }
+            }
+        }
+
+        for called_func_id in called_functions.into_iter() {
+            self.collect_acir_functions_called_from_brillig(
+                ssa,
+                called_func_id,
+                within_brillig,
+                processed_functions,
+            );
+        }
+    }
+
+    fn convert_acir_functions_called_from_brillig_to_brillig(&mut self, ssa: &mut Ssa) {
+        for acir_func_id in self.acir_functions_called_from_brillig.iter() {
+            let cloned_id = ssa.clone_fn(*acir_func_id);
+            let new_func =
+                ssa.functions.get_mut(&cloned_id).expect("Cloned function should exist in SSA");
+            new_func.set_runtime(RuntimeType::Brillig);
+            self.mapped_functions.insert(*acir_func_id, cloned_id);
+        }
+    }
+
+    fn replace_calls_to_mapped_functions(&self, ssa: &mut Ssa) {
+        for (_function_id, func) in ssa.functions.iter_mut() {
+            if func.runtime() == RuntimeType::Brillig {
+                for called_func_value_id in called_functions_values(func).iter() {
+                    let Value::Function(called_func_id) = &func.dfg[*called_func_value_id] else {
+                        unreachable!("Value should be a function")
+                    };
+                    if let Some(mapped_func_id) = self.mapped_functions.get(called_func_id) {
+                        let mapped_value_id = func.dfg.import_function(*mapped_func_id);
+                        func.dfg.set_value_from_id(*called_func_value_id, mapped_value_id);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// We only consider direct calls to functions since functions as values should have been resolved
+fn called_functions_values(func: &Function) -> BTreeSet<ValueId> {
+    let mut called_function_ids = BTreeSet::default();
+    for block_id in func.reachable_blocks() {
+        for instruction_id in func.dfg[block_id].instructions() {
+            let Instruction::Call { func: called_value_id, .. } = &func.dfg[*instruction_id] else {
+                continue;
+            };
+
+            if let Value::Function(_) = func.dfg[*called_value_id] {
+                called_function_ids.insert(*called_value_id);
+            }
+        }
+    }
+
+    called_function_ids
+}
+
+fn called_functions(func: &Function) -> BTreeSet<FunctionId> {
+    called_functions_values(func)
+        .into_iter()
+        .map(|value_id| {
+            let Value::Function(func_id) = func.dfg[value_id] else {
+                unreachable!("Value should be a function")
+            };
+            func_id
+        })
+        .collect()
+}
+
+fn collect_reachable_functions(
+    ssa: &Ssa,
+    current_func_id: FunctionId,
+    reachable_functions: &mut HashSet<FunctionId>,
+) {
+    if reachable_functions.contains(&current_func_id) {
+        return;
+    }
+    reachable_functions.insert(current_func_id);
+
+    let func = &ssa.functions[&current_func_id];
+    let called_functions = called_functions(func);
+
+    for called_func_id in called_functions.iter() {
+        collect_reachable_functions(ssa, *called_func_id, reachable_functions);
+    }
+}
+
+fn prune_unreachable_functions(ssa: &mut Ssa) {
+    let mut reachable_functions = HashSet::default();
+    collect_reachable_functions(ssa, ssa.main_id, &mut reachable_functions);
+
+    ssa.functions.retain(|id, _value| reachable_functions.contains(id));
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::BTreeSet;
+
+    use noirc_frontend::monomorphization::ast::InlineType;
+
+    use crate::ssa::{
+        function_builder::FunctionBuilder,
+        ir::{
+            function::{Function, FunctionId, RuntimeType},
+            map::Id,
+            types::Type,
+        },
+        opt::runtime_separation::called_functions,
+        ssa_gen::Ssa,
+    };
+
+    #[test]
+    fn basic_runtime_separation() {
+        // brillig fn foo {
+        //   b0():
+        //     v0 = call bar()
+        //     return v0
+        // }
+        // acir fn bar {
+        //   b0():
+        //     return 72
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("foo".into(), foo_id);
+        builder.current_function.set_runtime(RuntimeType::Brillig);
+
+        let bar_id = Id::test_new(1);
+        let bar = builder.import_function(bar_id);
+        let results = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
+        builder.terminate_with_return(results);
+
+        builder.new_function("bar".into(), bar_id, InlineType::default());
+        let expected_return = 72u128;
+        let seventy_two = builder.field_constant(expected_return);
+        builder.terminate_with_return(vec![seventy_two]);
+
+        let ssa = builder.finish();
+        assert_eq!(ssa.functions.len(), 2);
+
+        // Expected result
+        // brillig fn foo {
+        //   b0():
+        //     v0 = call bar()
+        //     return v0
+        // }
+        // brillig fn bar {
+        //   b0():
+        //     return 72
+        // }
+        let separated = ssa.separate_runtime();
+
+        // The original bar function must have been pruned
+        assert_eq!(separated.functions.len(), 2);
+
+        // All functions should be brillig now
+        for func in separated.functions.values() {
+            assert_eq!(func.runtime(), RuntimeType::Brillig);
+        }
+    }
+
+    fn find_func_by_name<'ssa>(
+        ssa: &'ssa Ssa,
+        funcs: &BTreeSet<FunctionId>,
+        name: &str,
+    ) -> &'ssa Function {
+        funcs
+            .iter()
+            .find_map(|id| {
+                let func = ssa.functions.get(id).unwrap();
+                if func.name() == name {
+                    Some(func)
+                } else {
+                    None
+                }
+            })
+            .unwrap()
+    }
+
+    #[test]
+    fn same_function_shared_acir_brillig() {
+        // acir fn foo {
+        //   b0():
+        //     v0 = call bar()
+        //     v1 = call baz()
+        //     return v0, v1
+        // }
+        // brillig fn bar {
+        //   b0():
+        //     v0 = call baz()
+        //     return v0
+        // }
+        // acir fn baz {
+        //   b0():
+        //     return 72
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("foo".into(), foo_id);
+
+        let bar_id = Id::test_new(1);
+        let baz_id = Id::test_new(2);
+        let bar = builder.import_function(bar_id);
+        let baz = builder.import_function(baz_id);
+        let v0 = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
+        let v1 = builder.insert_call(baz, Vec::new(), vec![Type::field()]).to_vec();
+        builder.terminate_with_return(vec![v0[0], v1[0]]);
+
+        builder.new_brillig_function("bar".into(), bar_id);
+        let baz = builder.import_function(baz_id);
+        let v0 = builder.insert_call(baz, Vec::new(), vec![Type::field()]).to_vec();
+        builder.terminate_with_return(v0);
+
+        builder.new_function("baz".into(), baz_id, InlineType::default());
+        let expected_return = 72u128;
+        let seventy_two = builder.field_constant(expected_return);
+        builder.terminate_with_return(vec![seventy_two]);
+
+        let ssa = builder.finish();
+        assert_eq!(ssa.functions.len(), 3);
+
+        // Expected result
+        // acir fn foo {
+        //   b0():
+        //     v0 = call bar()
+        //     v1 = call baz() <- baz_acir
+        //     return v0, v1
+        // }
+        // brillig fn bar {
+        //   b0():
+        //     v0 = call baz() <- baz_brillig
+        //     return v0
+        // }
+        // acir fn baz {
+        //   b0():
+        //     return 72
+        // }
+        // brillig fn baz {
+        //   b0():
+        //     return 72
+        // }
+        let separated = ssa.separate_runtime();
+
+        // The original baz function must have been duplicated
+        assert_eq!(separated.functions.len(), 4);
+
+        let main_function = separated.functions.get(&separated.main_id).unwrap();
+        assert_eq!(main_function.runtime(), RuntimeType::Acir(InlineType::Inline));
+
+        let main_calls = called_functions(main_function);
+        assert_eq!(main_calls.len(), 2);
+
+        let bar = find_func_by_name(&separated, &main_calls, "bar");
+        let baz_acir = find_func_by_name(&separated, &main_calls, "baz");
+
+        assert_eq!(baz_acir.runtime(), RuntimeType::Acir(InlineType::Inline));
+        assert_eq!(bar.runtime(), RuntimeType::Brillig);
+
+        let bar_calls = called_functions(bar);
+        assert_eq!(bar_calls.len(), 1);
+
+        let baz_brillig = find_func_by_name(&separated, &bar_calls, "baz");
+        assert_eq!(baz_brillig.runtime(), RuntimeType::Brillig);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
index 21178c55c73..7a77aa76101 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
@@ -80,6 +80,14 @@ impl Ssa {
         self.functions.insert(new_id, function);
         new_id
     }
+
+    /// Clones an already existing function with a fresh id
+    pub(crate) fn clone_fn(&mut self, existing_function_id: FunctionId) -> FunctionId {
+        let new_id = self.next_id.next();
+        let function = Function::clone_with_id(new_id, &self.functions[&existing_function_id]);
+        self.functions.insert(new_id, function);
+        new_id
+    }
 }
 
 impl Display for Ssa {
diff --git a/test_programs/execution_success/acir_inside_brillig_recursion/Nargo.toml b/test_programs/execution_success/acir_inside_brillig_recursion/Nargo.toml
new file mode 100644
index 00000000000..462532bb484
--- /dev/null
+++ b/test_programs/execution_success/acir_inside_brillig_recursion/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "acir_inside_brillig_recursion"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/acir_inside_brillig_recursion/Prover.toml b/test_programs/execution_success/acir_inside_brillig_recursion/Prover.toml
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/test_programs/execution_success/acir_inside_brillig_recursion/Prover.toml
@@ -0,0 +1 @@
+
diff --git a/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr b/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr
new file mode 100644
index 00000000000..92f8524a771
--- /dev/null
+++ b/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr
@@ -0,0 +1,15 @@
+fn main() {
+    assert_eq(fibonacci(3), fibonacci_hint(3));
+}
+
+unconstrained fn fibonacci_hint(x: u32) -> u32 {
+    fibonacci(x)
+}
+
+fn fibonacci(x: u32) -> u32 {
+    if x <= 1 {
+        x
+    } else {
+        fibonacci(x - 1) + fibonacci(x - 2)
+    }
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index a6d3c9a3a94..a9193896589 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -1,28 +1,17 @@
-array_dynamic_blackbox_input
 bigint
-bit_shifts_comptime
 brillig_references
 brillig_to_bytes_integration
 debug_logs
-double_verify_nested_proof
-double_verify_proof
-double_verify_proof_recursive
-modulus
-references
-scalar_mul
-signed_comparison
-to_bytes_integration
+fold_after_inlined_calls
 fold_basic
 fold_basic_nested_call
 fold_call_witness_condition
-fold_after_inlined_calls
-fold_numeric_generic_poseidon
-no_predicates_basic
-no_predicates_numeric_generic_poseidon
-regression_4709
+fold_complex_outputs
 fold_distinct_return
 fold_fibonacci
-fold_complex_outputs
-slice_init_with_complex_type
-hashmap
-is_unconstrained
\ No newline at end of file
+fold_numeric_generic_poseidon
+is_unconstrained
+modulus
+references
+regression_4709
+to_bytes_integration
\ No newline at end of file

From 3afe023543e301aafaf2b79f0ccd6d7936dd53a9 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Wed, 29 May 2024 20:31:51 +0100
Subject: [PATCH 316/416] fix(frontend): Resolve object types from method calls
 a single time (#5131)

# Description

## Problem\*

Resolves #5065

Probably resolves #4732 but need to test it or have aztec team test it.

## Summary\*

When working with a program like such where `MyType` implements
`MyTrait`:
```rust
fn foo<T>() -> T where T: MyTrait {
    MyTrait::new()
}
fn concise_regression() -> MyType {
    Wrapper::new(foo()).unwrap()
}
```
We should be able to infer the return type of `foo`. We currently always
push trait constraints onto a a `Vec<(TraitConstraint, ExprId)>`. We
need to do this as we can have multiple trait constraints that need to
be handled during monomorphization due to generics. However, when
working with a method call this can cause us to store an old trait
constraint that does not necessarily apply to the expression.

The nested function call in `concise_regression` initially adds a trait
constraint simply for `foo` due to the call to `Wrapper::new(foo())` and
then another constraint for `Wrapper::new(foo()).unwrap()`. The call to
`Wrapper::new(foo())` cannot be bound to anything unless we introduce an
intermediate variable. This felt like it would be overly complex and we
just need to follow the accurate trait constraint for a function call
expression.

Taking the test in the issue and this PR we have the following trait
constraints on master for the `foo` expression:
```
TraitConstraint {
        typ: '23646 -> '23647,
        trait_id: TraitId(
            ModuleId {
                krate: Root(
                    1,
                ),
                local_id: LocalModuleId(
                    Index(
                        1,
                    ),
                ),
            },
        ),
        trait_generics: [],
    },
    TraitConstraint {
        typ: '23648 -> '23649 -> '23650 -> MyType,
        trait_id: TraitId(
            ModuleId {
                krate: Root(
                    1,
                ),
                local_id: LocalModuleId(
                    Index(
                        1,
                    ),
                ),
            },
        ),
        trait_generics: [],
    }
```
This is occurring due to an unnecessary type check on a method call's
object type. This is cause a repeated trait constraint where one has
incorrect type variables that cannot be resolved.

I have altered how MethodCall's and Call's are resolved as to avoid
repeated type checks on the object type.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../noirc_frontend/src/hir/type_check/expr.rs | 118 +++++++++++-------
 .../regression_5065_failure/Nargo.toml        |   7 ++
 .../regression_5065_failure/src/main.nr       |  40 ++++++
 .../regression_5065/Nargo.toml                |   7 ++
 .../regression_5065/src/main.nr               |  45 +++++++
 5 files changed, 171 insertions(+), 46 deletions(-)
 create mode 100644 test_programs/compile_failure/regression_5065_failure/Nargo.toml
 create mode 100644 test_programs/compile_failure/regression_5065_failure/src/main.nr
 create mode 100644 test_programs/compile_success_empty/regression_5065/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/regression_5065/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 336c1cedbb6..6504ead178f 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -2,6 +2,7 @@ use iter_extended::vecmap;
 use noirc_errors::Span;
 
 use crate::ast::{BinaryOpKind, IntegerBitSize, UnaryOp};
+use crate::hir_def::expr::HirCallExpression;
 use crate::macros_api::Signedness;
 use crate::{
     hir::{resolution::resolver::verify_mutable_reference, type_check::errors::Source},
@@ -176,16 +177,6 @@ impl<'interner> TypeChecker<'interner> {
             }
             HirExpression::Index(index_expr) => self.check_index_expression(expr_id, index_expr),
             HirExpression::Call(call_expr) => {
-                // Need to setup these flags here as `self` is borrowed mutably to type check the rest of the call expression
-                // These flags are later used to type check calls to unconstrained functions from constrained functions
-                let current_func = self.current_function;
-                let func_mod = current_func.map(|func| self.interner.function_modifiers(&func));
-                let is_current_func_constrained =
-                    func_mod.map_or(true, |func_mod| !func_mod.is_unconstrained);
-                let is_unconstrained_call = self.is_unconstrained_call(&call_expr.func);
-
-                self.check_if_deprecated(&call_expr.func);
-
                 let function = self.check_expression(&call_expr.func);
 
                 let args = vecmap(&call_expr.arguments, |arg| {
@@ -193,39 +184,13 @@ impl<'interner> TypeChecker<'interner> {
                     (typ, *arg, self.interner.expr_span(arg))
                 });
 
-                // Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime
-                if is_current_func_constrained && is_unconstrained_call {
-                    for (typ, _, _) in args.iter() {
-                        if matches!(&typ.follow_bindings(), Type::MutableReference(_)) {
-                            self.errors.push(TypeCheckError::ConstrainedReferenceToUnconstrained {
-                                span: self.interner.expr_span(expr_id),
-                            });
-                            return Type::Error;
-                        }
-                    }
-                }
-
                 let span = self.interner.expr_span(expr_id);
-                let return_type = self.bind_function_type(function, args, span);
-
-                // Check that we are not passing a slice from an unconstrained runtime to a constrained runtime
-                if is_current_func_constrained && is_unconstrained_call {
-                    if return_type.contains_slice() {
-                        self.errors.push(TypeCheckError::UnconstrainedSliceReturnToConstrained {
-                            span: self.interner.expr_span(expr_id),
-                        });
-                        return Type::Error;
-                    } else if matches!(&return_type.follow_bindings(), Type::MutableReference(_)) {
-                        self.errors.push(TypeCheckError::UnconstrainedReferenceToConstrained {
-                            span: self.interner.expr_span(expr_id),
-                        });
-                        return Type::Error;
-                    }
-                };
-
-                return_type
+                self.check_call(&call_expr, function, args, span)
             }
             HirExpression::MethodCall(mut method_call) => {
+                let method_call_span = self.interner.expr_span(expr_id);
+                let object = method_call.object;
+                let object_span = self.interner.expr_span(&method_call.object);
                 let mut object_type = self.check_expression(&method_call.object).follow_bindings();
                 let method_name = method_call.method.0.contents.as_str();
                 match self.lookup_method(&object_type, method_name, expr_id) {
@@ -259,19 +224,42 @@ impl<'interner> TypeChecker<'interner> {
                             );
                         }
 
+                        // These arguments will be given to the desugared function call.
+                        // Compared to the method arguments, they also contain the object.
+                        let mut function_args = Vec::with_capacity(method_call.arguments.len() + 1);
+
+                        function_args.push((object_type.clone(), object, object_span));
+
+                        for arg in method_call.arguments.iter() {
+                            let span = self.interner.expr_span(arg);
+                            let typ = self.check_expression(arg);
+                            function_args.push((typ, *arg, span));
+                        }
+
                         // TODO: update object_type here?
-                        let (_, function_call) = method_call.into_function_call(
+                        let ((function_id, _), function_call) = method_call.into_function_call(
                             &method_ref,
                             object_type,
                             location,
                             self.interner,
                         );
 
-                        self.interner.replace_expr(expr_id, HirExpression::Call(function_call));
+                        let func_type = self.check_expression(&function_id);
 
                         // Type check the new call now that it has been changed from a method call
                         // to a function call. This way we avoid duplicating code.
-                        self.check_expression(expr_id)
+                        // We call `check_call` rather than `check_expression` directly as we want to avoid
+                        // resolving the object type again once it is part of the arguments.
+                        let typ = self.check_call(
+                            &function_call,
+                            func_type,
+                            function_args,
+                            method_call_span,
+                        );
+
+                        self.interner.replace_expr(expr_id, HirExpression::Call(function_call));
+
+                        typ
                     }
                     None => Type::Error,
                 }
@@ -333,6 +321,45 @@ impl<'interner> TypeChecker<'interner> {
         typ
     }
 
+    fn check_call(
+        &mut self,
+        call: &HirCallExpression,
+        func_type: Type,
+        args: Vec<(Type, ExprId, Span)>,
+        span: Span,
+    ) -> Type {
+        // Need to setup these flags here as `self` is borrowed mutably to type check the rest of the call expression
+        // These flags are later used to type check calls to unconstrained functions from constrained functions
+        let func_mod = self.current_function.map(|func| self.interner.function_modifiers(&func));
+        let is_current_func_constrained =
+            func_mod.map_or(true, |func_mod| !func_mod.is_unconstrained);
+
+        let is_unconstrained_call = self.is_unconstrained_call(&call.func);
+        self.check_if_deprecated(&call.func);
+
+        // Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime
+        if is_current_func_constrained && is_unconstrained_call {
+            for (typ, _, _) in args.iter() {
+                if matches!(&typ.follow_bindings(), Type::MutableReference(_)) {
+                    self.errors.push(TypeCheckError::ConstrainedReferenceToUnconstrained { span });
+                }
+            }
+        }
+
+        let return_type = self.bind_function_type(func_type, args, span);
+
+        // Check that we are not passing a slice from an unconstrained runtime to a constrained runtime
+        if is_current_func_constrained && is_unconstrained_call {
+            if return_type.contains_slice() {
+                self.errors.push(TypeCheckError::UnconstrainedSliceReturnToConstrained { span });
+            } else if matches!(&return_type.follow_bindings(), Type::MutableReference(_)) {
+                self.errors.push(TypeCheckError::UnconstrainedReferenceToConstrained { span });
+            }
+        };
+
+        return_type
+    }
+
     fn check_block(&mut self, block: HirBlockExpression) -> Type {
         let mut block_type = Type::Unit;
 
@@ -416,9 +443,8 @@ impl<'interner> TypeChecker<'interner> {
         // Push any trait constraints required by this definition to the context
         // to be checked later when the type of this variable is further constrained.
         if let Some(definition) = self.interner.try_definition(ident.id) {
-            if let DefinitionKind::Function(function) = definition.kind {
-                let function = self.interner.function_meta(&function);
-
+            if let DefinitionKind::Function(func_id) = definition.kind {
+                let function = self.interner.function_meta(&func_id);
                 for mut constraint in function.trait_constraints.clone() {
                     constraint.apply_bindings(&bindings);
                     self.trait_constraints.push((constraint, *expr_id));
diff --git a/test_programs/compile_failure/regression_5065_failure/Nargo.toml b/test_programs/compile_failure/regression_5065_failure/Nargo.toml
new file mode 100644
index 00000000000..c3dda827d3c
--- /dev/null
+++ b/test_programs/compile_failure/regression_5065_failure/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_5065_failure"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/regression_5065_failure/src/main.nr b/test_programs/compile_failure/regression_5065_failure/src/main.nr
new file mode 100644
index 00000000000..ead1754209d
--- /dev/null
+++ b/test_programs/compile_failure/regression_5065_failure/src/main.nr
@@ -0,0 +1,40 @@
+struct Wrapper<T> {
+    _value: T,
+}
+
+impl<T> Wrapper<T> {
+    fn new(value: T) -> Self {
+        Self { _value: value }
+    }
+
+    fn unwrap(self) -> T {
+        self._value
+    }
+}
+
+trait MyTrait {
+    fn new() -> Self;
+}
+
+struct MyType {}
+
+impl MyTrait for MyType {
+    fn new() -> Self {
+        MyType {}
+    }
+}
+
+fn foo<T>() -> T where T: MyTrait {
+    MyTrait::new()
+}
+
+struct BadType {}
+
+// Check that we get "No matching impl found for `BadType: MyTrait`"
+fn concise_regression() -> BadType {
+    Wrapper::new(foo()).unwrap()
+}
+
+fn main() {
+    let _ = concise_regression();
+}
diff --git a/test_programs/compile_success_empty/regression_5065/Nargo.toml b/test_programs/compile_success_empty/regression_5065/Nargo.toml
new file mode 100644
index 00000000000..b1cb9d9ba96
--- /dev/null
+++ b/test_programs/compile_success_empty/regression_5065/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_5065"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/regression_5065/src/main.nr b/test_programs/compile_success_empty/regression_5065/src/main.nr
new file mode 100644
index 00000000000..36b0570165f
--- /dev/null
+++ b/test_programs/compile_success_empty/regression_5065/src/main.nr
@@ -0,0 +1,45 @@
+struct Wrapper<T> {
+    _value: T,
+}
+
+impl<T> Wrapper<T> {
+    fn new_wrapper(value: T) -> Self {
+        Self { _value: value }
+    }
+
+    fn unwrap(self) -> T {
+        self._value
+    }
+}
+
+trait MyTrait {
+    fn new() -> Self;
+}
+
+struct MyType {}
+
+impl MyTrait for MyType {
+    fn new() -> Self {
+        MyType {}
+    }
+}
+
+fn foo<T>() -> T where T: MyTrait {
+    MyTrait::new()
+}
+
+// fn verbose_but_compiles() -> MyType {
+//     let a = Wrapper::new_wrapper(foo());
+//     a.unwrap()
+// }
+
+// Check that are able to infer the return type of the call to `foo`
+fn concise_regression() -> MyType {
+    Wrapper::new_wrapper(foo()).unwrap()
+    // Wrapper::unwrap(Wrapper::new_wrapper(foo()))
+}
+
+fn main() {
+    // let _ = verbose_but_compiles();
+    let _ = concise_regression();
+}

From b0a7d0b12328d3ed9faed87b78792b77786018e0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 29 May 2024 14:44:03 -0500
Subject: [PATCH 317/416] fix(experimental elaborator): Clear generics after
 elaborating type aliases (#5136)

# Description

## Problem\*

## Summary\*

Adds a missed call to `generics.clear()`

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 10ebd657494..c55438193d1 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1147,6 +1147,7 @@ impl<'context> Elaborator<'context> {
         self.current_item = Some(DependencyId::Alias(alias_id));
         let typ = self.resolve_type(alias.type_alias_def.typ);
         self.interner.set_type_alias(alias_id, typ, generics);
+        self.generics.clear();
     }
 
     fn collect_struct_definitions(&mut self, structs: BTreeMap<StructId, UnresolvedStruct>) {

From e73cdbb93b0714331fef754f862d89c08c28a9e5 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 29 May 2024 14:44:30 -0500
Subject: [PATCH 318/416] fix(experimental elaborator): Fix global values used
 in the elaborator (#5135)

# Description

## Problem\*

Resolves an issue where globals would not have their type set correctly
in the elaborator. This is because `elaborate_let` was called which
creates a fresh DefinitionId rather than the one already defined by the
global, and pushes the type to that fresh id.

## Summary\*

Adds a `elaborate_global_let` function which copies over the new type to
the original DefinitionId defined by the global.
This PR also adds a call to `self.type_variables.clear()` after a global
is resolved so that its type is not defaulted too early.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/elaborator/expressions.rs             |  2 +
 compiler/noirc_frontend/src/elaborator/mod.rs | 11 ++--
 .../src/elaborator/statements.rs              | 52 +++++++++++++++----
 tooling/nargo_cli/tests/stdlib-tests.rs       | 17 ++----
 4 files changed, 51 insertions(+), 31 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 2ad1598c6a2..8acd1867074 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -348,6 +348,8 @@ impl<'context> Elaborator<'context> {
                 let func_type =
                     self.type_check_variable(function_name, function_id, turbofish_generics);
 
+                self.interner.push_expr_type(function_id, func_type.clone());
+
                 // Type check the new call now that it has been changed from a method call
                 // to a function call. This way we avoid duplicating code.
                 let typ = self.type_check_call(&function_call, func_type, function_args, span);
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index c55438193d1..1d66b4b952a 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1212,8 +1212,6 @@ impl<'context> Elaborator<'context> {
 
         let global_id = global.global_id;
         self.current_item = Some(DependencyId::Global(global_id));
-
-        let definition_kind = DefinitionKind::Global(global_id);
         let let_stmt = global.stmt_def;
 
         if !self.in_contract
@@ -1228,11 +1226,12 @@ impl<'context> Elaborator<'context> {
             self.push_err(ResolverError::MutableGlobal { span });
         }
 
-        let (let_statement, _typ) = self.elaborate_let(let_stmt);
+        self.elaborate_global_let(let_stmt, global_id);
 
-        let statement_id = self.interner.get_global(global_id).let_statement;
-        self.interner.get_global_definition_mut(global_id).kind = definition_kind.clone();
-        self.interner.replace_statement(statement_id, let_statement);
+        // Avoid defaulting the types of globals here since they may be used in any function.
+        // Otherwise we may prematurely default to a Field inside the next function if this
+        // global was unused there, even if it is consistently used as a u8 everywhere else.
+        self.type_variables.clear();
     }
 
     fn define_function_metas(
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index a7a2df4041e..9c50e7096dd 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -15,7 +15,7 @@ use crate::{
     macros_api::{
         ForLoopStatement, ForRange, HirStatement, LetStatement, Statement, StatementKind,
     },
-    node_interner::{DefinitionId, DefinitionKind, StmtId},
+    node_interner::{DefinitionId, DefinitionKind, GlobalId, StmtId},
     Type,
 };
 
@@ -24,7 +24,7 @@ use super::Elaborator;
 impl<'context> Elaborator<'context> {
     fn elaborate_statement_value(&mut self, statement: Statement) -> (HirStatement, Type) {
         match statement.kind {
-            StatementKind::Let(let_stmt) => self.elaborate_let(let_stmt),
+            StatementKind::Let(let_stmt) => self.elaborate_local_let(let_stmt),
             StatementKind::Constrain(constrain) => self.elaborate_constrain(constrain),
             StatementKind::Assign(assign) => self.elaborate_assign(assign),
             StatementKind::For(for_stmt) => self.elaborate_for(for_stmt),
@@ -51,7 +51,33 @@ impl<'context> Elaborator<'context> {
         (id, typ)
     }
 
-    pub(super) fn elaborate_let(&mut self, let_stmt: LetStatement) -> (HirStatement, Type) {
+    pub(super) fn elaborate_local_let(&mut self, let_stmt: LetStatement) -> (HirStatement, Type) {
+        let (statement, typ, _) = self.elaborate_let(let_stmt);
+        (statement, typ)
+    }
+
+    /// Elaborates a global let statement. Compared to the local version, this
+    /// version fixes up the result to use the given DefinitionId rather than
+    /// the fresh one defined by the let pattern.
+    pub(super) fn elaborate_global_let(&mut self, let_stmt: LetStatement, global_id: GlobalId) {
+        let (let_statement, _typ, new_ids) = self.elaborate_let(let_stmt);
+        let statement_id = self.interner.get_global(global_id).let_statement;
+
+        // To apply the changes from the fresh id created in elaborate_let to this global
+        // we need to change the definition kind and update the type.
+        let definition_id = self.interner.get_global(global_id).definition_id;
+        self.interner.definition_mut(definition_id).kind = DefinitionKind::Global(global_id);
+
+        assert_eq!(new_ids.len(), 1, "Globals should only define 1 value");
+        let definition_type = self.interner.definition_type(new_ids[0].id);
+        self.interner.push_definition_type(definition_id, definition_type);
+
+        self.interner.replace_statement(statement_id, let_statement);
+    }
+
+    /// Elaborate a local or global let statement. In addition to the HirLetStatement and unit
+    /// type, this also returns each HirIdent defined by this let statement.
+    fn elaborate_let(&mut self, let_stmt: LetStatement) -> (HirStatement, Type, Vec<HirIdent>) {
         let expr_span = let_stmt.expression.span;
         let (expression, expr_type) = self.elaborate_expression(let_stmt.expression);
         let definition = DefinitionKind::Local(Some(expression));
@@ -77,14 +103,18 @@ impl<'context> Elaborator<'context> {
             expr_type
         };
 
-        let let_ = HirLetStatement {
-            pattern: self.elaborate_pattern(let_stmt.pattern, r#type.clone(), definition),
-            r#type,
-            expression,
-            attributes: let_stmt.attributes,
-            comptime: let_stmt.comptime,
-        };
-        (HirStatement::Let(let_), Type::Unit)
+        let mut created_ids = Vec::new();
+        let pattern = self.elaborate_pattern_and_store_ids(
+            let_stmt.pattern,
+            r#type.clone(),
+            definition,
+            &mut created_ids,
+        );
+
+        let attributes = let_stmt.attributes;
+        let comptime = let_stmt.comptime;
+        let let_ = HirLetStatement { pattern, r#type, expression, attributes, comptime };
+        (HirStatement::Let(let_), Type::Unit, created_ids)
     }
 
     pub(super) fn elaborate_constrain(&mut self, stmt: ConstrainStatement) -> (HirStatement, Type) {
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 70a9354f50a..0bb967e7502 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -10,7 +10,8 @@ use nargo::{
     parse_all, prepare_package,
 };
 
-fn run_stdlib_tests(use_elaborator: bool) {
+#[test]
+fn run_stdlib_tests() {
     let mut file_manager = file_manager_with_stdlib(&PathBuf::from("."));
     file_manager.add_file_with_source_canonical_path(&PathBuf::from("main.nr"), "".to_owned());
     let parsed_files = parse_all(&file_manager);
@@ -29,7 +30,7 @@ fn run_stdlib_tests(use_elaborator: bool) {
     let (mut context, dummy_crate_id) =
         prepare_package(&file_manager, &parsed_files, &dummy_package);
 
-    let result = check_crate(&mut context, dummy_crate_id, true, false, use_elaborator);
+    let result = check_crate(&mut context, dummy_crate_id, true, false, false);
     report_errors(result, &context.file_manager, true, false)
         .expect("Error encountered while compiling standard library");
 
@@ -59,15 +60,3 @@ fn run_stdlib_tests(use_elaborator: bool) {
     assert!(!test_report.is_empty(), "Could not find any tests within the stdlib");
     assert!(test_report.iter().all(|(_, status)| !status.failed()));
 }
-
-#[test]
-fn stdlib_noir_tests() {
-    run_stdlib_tests(false)
-}
-
-// Once this no longer panics we can use the elaborator by default and remove the old passes
-#[test]
-#[should_panic]
-fn stdlib_elaborator_tests() {
-    run_stdlib_tests(true)
-}

From 145b90945486907cb6db75d3f3f93a58d19b2a32 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 30 May 2024 15:40:15 +0200
Subject: [PATCH 319/416] fix: use predicate for curve operations (#5076)

# Description

## Problem\*

Resolves #5045

## Summary\*
use predicate to set is_infinite to true when side_effects are disabled,
to ensure that the curve operation will not fail.


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/ir/instruction.rs | 10 +++-
 .../src/ssa/opt/flatten_cfg.rs                | 47 ++++++++++++++++++-
 .../regression_5045/Nargo.toml                |  7 +++
 .../regression_5045/Prover.toml               |  1 +
 .../regression_5045/src/main.nr               | 20 ++++++++
 5 files changed, 83 insertions(+), 2 deletions(-)
 create mode 100644 test_programs/execution_success/regression_5045/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_5045/Prover.toml
 create mode 100644 test_programs/execution_success/regression_5045/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 5110140bfcc..7517b54aac3 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -123,7 +123,12 @@ impl Intrinsic {
             | Intrinsic::IsUnconstrained => false,
 
             // Some black box functions have side-effects
-            Intrinsic::BlackBox(func) => matches!(func, BlackBoxFunc::RecursiveAggregation),
+            Intrinsic::BlackBox(func) => matches!(
+                func,
+                BlackBoxFunc::RecursiveAggregation
+                    | BlackBoxFunc::MultiScalarMul
+                    | BlackBoxFunc::EmbeddedCurveAdd
+            ),
         }
     }
 
@@ -340,6 +345,9 @@ impl Instruction {
 
             // Some `Intrinsic`s have side effects so we must check what kind of `Call` this is.
             Call { func, .. } => match dfg[*func] {
+                // Explicitly allows removal of unused ec operations, even if they can fail
+                Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul))
+                | Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::EmbeddedCurveAdd)) => true,
                 Value::Intrinsic(intrinsic) => !intrinsic.has_side_effects(),
 
                 // All foreign functions are treated as having side effects.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index 690c0244f62..e07f947db8d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -134,7 +134,7 @@
 use fxhash::FxHashMap as HashMap;
 use std::collections::{BTreeMap, HashSet};
 
-use acvm::{acir::AcirField, FieldElement};
+use acvm::{acir::AcirField, acir::BlackBoxFunc, FieldElement};
 use iter_extended::vecmap;
 
 use crate::ssa::{
@@ -769,7 +769,38 @@ impl<'f> Context<'f> {
 
                         Instruction::Call { func, arguments }
                     }
+                    //Issue #5045: We set curve points to infinity if condition is false
+                    Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::EmbeddedCurveAdd)) => {
+                        arguments[2] = self.var_or_one(arguments[2], condition, call_stack.clone());
+                        arguments[5] = self.var_or_one(arguments[5], condition, call_stack.clone());
 
+                        Instruction::Call { func, arguments }
+                    }
+                    Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul)) => {
+                        let mut array_with_predicate = im::Vector::new();
+                        let array_typ;
+                        if let Value::Array { array, typ } =
+                            &self.inserter.function.dfg[arguments[0]]
+                        {
+                            array_typ = typ.clone();
+                            for (i, value) in array.clone().iter().enumerate() {
+                                if i % 3 == 2 {
+                                    array_with_predicate.push_back(self.var_or_one(
+                                        *value,
+                                        condition,
+                                        call_stack.clone(),
+                                    ));
+                                } else {
+                                    array_with_predicate.push_back(*value);
+                                }
+                            }
+                        } else {
+                            unreachable!();
+                        }
+                        arguments[0] =
+                            self.inserter.function.dfg.make_array(array_with_predicate, array_typ);
+                        Instruction::Call { func, arguments }
+                    }
                     _ => Instruction::Call { func, arguments },
                 },
                 other => other,
@@ -779,6 +810,20 @@ impl<'f> Context<'f> {
         }
     }
 
+    // Computes: if condition { var } else { 1 }
+    fn var_or_one(&mut self, var: ValueId, condition: ValueId, call_stack: CallStack) -> ValueId {
+        let field = self.insert_instruction(
+            Instruction::binary(BinaryOp::Mul, var, condition),
+            call_stack.clone(),
+        );
+        let not_condition =
+            self.insert_instruction(Instruction::Not(condition), call_stack.clone());
+        self.insert_instruction(
+            Instruction::binary(BinaryOp::Add, field, not_condition),
+            call_stack,
+        )
+    }
+
     fn undo_stores_in_then_branch(&mut self, store_values: &HashMap<ValueId, Store>) {
         for (address, store) in store_values {
             let address = *address;
diff --git a/test_programs/execution_success/regression_5045/Nargo.toml b/test_programs/execution_success/regression_5045/Nargo.toml
new file mode 100644
index 00000000000..8f56d392fec
--- /dev/null
+++ b/test_programs/execution_success/regression_5045/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_5045"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_5045/Prover.toml b/test_programs/execution_success/regression_5045/Prover.toml
new file mode 100644
index 00000000000..5444a86ec82
--- /dev/null
+++ b/test_programs/execution_success/regression_5045/Prover.toml
@@ -0,0 +1 @@
+is_active = false
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_5045/src/main.nr b/test_programs/execution_success/regression_5045/src/main.nr
new file mode 100644
index 00000000000..015fb1b2555
--- /dev/null
+++ b/test_programs/execution_success/regression_5045/src/main.nr
@@ -0,0 +1,20 @@
+use dep::std::embedded_curve_ops::EmbeddedCurvePoint;
+use dep::std::embedded_curve_ops::EmbeddedCurveScalar;
+
+fn main(is_active: bool) {
+    let a = EmbeddedCurvePoint {
+        x: 0x1d8eb4378a3bde41e0b6a9a8dcbd21b7ff9c51bdd6ca13ce989abbbf90df3666,
+        y: 0x06075b63354f2504f9cddba0b94ed0cef35fc88615e69ec1f853b51eb79a24a0,
+        is_infinite: false
+    };
+
+    if is_active {
+        let bad = EmbeddedCurvePoint { x: 0, y: 5, is_infinite: false };
+        let d = bad.double();
+        let e = dep::std::embedded_curve_ops::multi_scalar_mul(
+            [a, bad],
+            [EmbeddedCurveScalar { lo: 1, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
+        );
+        assert(e[0] != d.x);
+    }
+}

From 8ae3d751b49648f997bde337649e798c04083b98 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 30 May 2024 15:04:37 +0100
Subject: [PATCH 320/416] chore(ci): don't raise MSRV issue if workflow
 cancelled (#5143)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're currently getting a large number of false positive alerts such as
https://github.com/noir-lang/noir/issues/5137 due to the workflow being
cancelled when multiple PRs are merged in quick succession.

This PR changes the workflow to treat cancellation as a success rather
than a failure to avoid this.


## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/test-rust-workspace-msrv.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index ccd431ea879..ae016169830 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -111,7 +111,7 @@ jobs:
           fi
         env:
           # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
-          FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
+          FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'skipped') }}
     
       - name: Checkout
         if: ${{ failure() }}

From 29baeb41e15918935c437e0a2759c6b936f125a4 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 30 May 2024 16:36:02 +0200
Subject: [PATCH 321/416] fix: wrapping in signed division (#5134)

# Description

## Problem\*

Resolves #5129

## Summary\*
A negative and null quotient was computed as -0=2^{bit_size}, which
wraps over the bit size.


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs        | 12 +++++++++++-
 .../execution_success/signed_div/src/main.nr         |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 4a0f9f798ff..93200d4f841 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -979,6 +979,7 @@ impl AcirContext {
         let max_power_of_two = self.add_constant(
             FieldElement::from(2_i128).pow(&FieldElement::from(bit_size as i128 - 1)),
         );
+        let zero = self.add_constant(FieldElement::zero());
         let one = self.add_constant(FieldElement::one());
 
         // Get the sign bit of rhs by computing rhs / max_power_of_two
@@ -998,10 +999,19 @@ impl AcirContext {
         // Unsigned to signed: derive q and r from q1,r1 and the signs of lhs and rhs
         // Quotient sign is lhs sign * rhs sign, whose resulting sign bit is the XOR of the sign bits
         let q_sign = self.xor_var(lhs_leading, rhs_leading, AcirType::unsigned(1))?;
-
         let quotient = self.two_complement(q1, q_sign, bit_size)?;
         let remainder = self.two_complement(r1, lhs_leading, bit_size)?;
 
+        // Issue #5129 - When q1 is zero and quotient sign is -1, we compute -0=2^{bit_size},
+        // which is not valid because we do not wrap integer operations
+        // Similar case can happen with the remainder.
+        let q_is_0 = self.eq_var(q1, zero)?;
+        let q_is_not_0 = self.not_var(q_is_0, AcirType::unsigned(1))?;
+        let quotient = self.mul_var(quotient, q_is_not_0)?;
+        let r_is_0 = self.eq_var(r1, zero)?;
+        let r_is_not_0 = self.not_var(r_is_0, AcirType::unsigned(1))?;
+        let remainder = self.mul_var(remainder, r_is_not_0)?;
+
         Ok((quotient, remainder))
     }
 
diff --git a/test_programs/execution_success/signed_div/src/main.nr b/test_programs/execution_success/signed_div/src/main.nr
index bc3f5c3bdc0..04383a459bd 100644
--- a/test_programs/execution_success/signed_div/src/main.nr
+++ b/test_programs/execution_success/signed_div/src/main.nr
@@ -4,7 +4,7 @@ struct SignedDivOp {
     result: i8,
 }
 
-unconstrained fn main(ops: [SignedDivOp; 15]) {
+fn main(ops: [SignedDivOp; 15]) {
     for i in 0..15 {
         assert_eq(ops[i].lhs / ops[i].rhs, ops[i].result);
     }

From 7ea5962e77b7183374a4e14da3a237ccd63f00a0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 30 May 2024 11:19:20 -0500
Subject: [PATCH 322/416] fix(experimental elaborator): Fix `impl Trait` when
 `--use-elaborator` is selected (#5138)

# Description

## Problem\*

Resolves errors when using `impl Trait` in the elaborator

## Summary\*

Desugaring impl args was happening when elaborating the function when it
should have been when defining the FuncMeta beforehand. Additionally,
I've taken advantage of the fact that the elaborator also combines the
type checking step and have shortened the `desugar_impl_args` function
significantly by converting to resolved types instead and pushing to the
function's resolved traits. This way there's no danger of users
accidentally using the name generated for the implicit generic since it
was never introduced into scope.

## Additional Context

After this PR only the following two test_programs are still failing:
    tests::execution_success_global_consts
    tests::execution_success_hashmap

I've yet to test to see if any of the frontend tests fail for the
elaborator.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 89 +++++++++----------
 1 file changed, 41 insertions(+), 48 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 1d66b4b952a..a0ff3c12ae3 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -273,7 +273,7 @@ impl<'context> Elaborator<'context> {
         self.trait_id = None;
     }
 
-    fn elaborate_function(&mut self, mut function: NoirFunction, id: FuncId) {
+    fn elaborate_function(&mut self, function: NoirFunction, id: FuncId) {
         self.current_function = Some(id);
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
@@ -303,7 +303,6 @@ impl<'context> Elaborator<'context> {
         }
 
         self.generics = func_meta.all_generics.clone();
-        self.desugar_impl_trait_args(&mut function, id);
         self.declare_numeric_generics(&func_meta.parameters, func_meta.return_type());
         self.add_trait_constraints_to_scope(&func_meta);
 
@@ -373,49 +372,31 @@ impl<'context> Elaborator<'context> {
     }
 
     /// This turns function parameters of the form:
-    /// fn foo(x: impl Bar)
+    /// `fn foo(x: impl Bar)`
     ///
     /// into
-    /// fn foo<T0_impl_Bar>(x: T0_impl_Bar) where T0_impl_Bar: Bar
-    fn desugar_impl_trait_args(&mut self, func: &mut NoirFunction, func_id: FuncId) {
-        let mut impl_trait_generics = HashSet::default();
-        let mut counter: usize = 0;
-        for parameter in func.def.parameters.iter_mut() {
-            if let UnresolvedTypeData::TraitAsType(path, args) = &parameter.typ.typ {
-                let mut new_generic_ident: Ident =
-                    format!("T{}_impl_{}", func_id, path.as_string()).into();
-                let mut new_generic_path = Path::from_ident(new_generic_ident.clone());
-                while impl_trait_generics.contains(&new_generic_ident)
-                    || self.lookup_generic_or_global_type(&new_generic_path).is_some()
-                {
-                    new_generic_ident =
-                        format!("T{}_impl_{}_{}", func_id, path.as_string(), counter).into();
-                    new_generic_path = Path::from_ident(new_generic_ident.clone());
-                    counter += 1;
-                }
-                impl_trait_generics.insert(new_generic_ident.clone());
-
-                let is_synthesized = true;
-                let new_generic_type_data =
-                    UnresolvedTypeData::Named(new_generic_path, vec![], is_synthesized);
-                let new_generic_type =
-                    UnresolvedType { typ: new_generic_type_data.clone(), span: None };
-                let new_trait_bound = TraitBound {
-                    trait_path: path.clone(),
-                    trait_id: None,
-                    trait_generics: args.to_vec(),
-                };
-                let new_trait_constraint = UnresolvedTraitConstraint {
-                    typ: new_generic_type,
-                    trait_bound: new_trait_bound,
-                };
-
-                parameter.typ.typ = new_generic_type_data;
-                func.def.generics.push(new_generic_ident);
-                func.def.where_clause.push(new_trait_constraint);
-            }
+    /// `fn foo<T0_impl_Bar>(x: T0_impl_Bar) where T0_impl_Bar: Bar`
+    /// although the fresh type variable is not named internally.
+    fn desugar_impl_trait_arg(
+        &mut self,
+        trait_path: Path,
+        trait_generics: Vec<UnresolvedType>,
+        generics: &mut Vec<TypeVariable>,
+        trait_constraints: &mut Vec<TraitConstraint>,
+    ) -> Type {
+        let new_generic_id = self.interner.next_type_variable_id();
+        let new_generic = TypeVariable::unbound(new_generic_id);
+        generics.push(new_generic.clone());
+
+        let name = format!("impl {trait_path}");
+        let generic_type = Type::NamedGeneric(new_generic, Rc::new(name));
+        let trait_bound = TraitBound { trait_path, trait_id: None, trait_generics };
+
+        if let Some(new_constraint) = self.resolve_trait_bound(&trait_bound, generic_type.clone()) {
+            trait_constraints.push(new_constraint);
         }
-        self.add_generics(&impl_trait_generics.into_iter().collect());
+
+        generic_type
     }
 
     /// Add the given generics to scope.
@@ -491,11 +472,14 @@ impl<'context> Elaborator<'context> {
         constraint: &UnresolvedTraitConstraint,
     ) -> Option<TraitConstraint> {
         let typ = self.resolve_type(constraint.typ.clone());
-        let trait_generics =
-            vecmap(&constraint.trait_bound.trait_generics, |typ| self.resolve_type(typ.clone()));
+        self.resolve_trait_bound(&constraint.trait_bound, typ)
+    }
+
+    fn resolve_trait_bound(&mut self, bound: &TraitBound, typ: Type) -> Option<TraitConstraint> {
+        let trait_generics = vecmap(&bound.trait_generics, |typ| self.resolve_type(typ.clone()));
 
-        let span = constraint.trait_bound.trait_path.span();
-        let the_trait = self.lookup_trait_or_error(constraint.trait_bound.trait_path.clone())?;
+        let span = bound.trait_path.span();
+        let the_trait = self.lookup_trait_or_error(bound.trait_path.clone())?;
         let trait_id = the_trait.id;
 
         let expected_generics = the_trait.generics.len();
@@ -561,6 +545,8 @@ impl<'context> Elaborator<'context> {
 
         self.add_generics(&func.def.generics);
 
+        let mut trait_constraints = self.resolve_trait_constraints(&func.def.where_clause);
+
         let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
         let mut parameters = Vec::new();
         let mut parameter_types = Vec::new();
@@ -575,7 +561,14 @@ impl<'context> Elaborator<'context> {
             }
 
             let type_span = typ.span.unwrap_or_else(|| pattern.span());
-            let typ = self.resolve_type_inner(typ, &mut generics);
+
+            let typ = match typ.typ {
+                UnresolvedTypeData::TraitAsType(path, args) => {
+                    self.desugar_impl_trait_arg(path, args, &mut generics, &mut trait_constraints)
+                }
+                _ => self.resolve_type_inner(typ, &mut generics),
+            };
+
             self.check_if_type_is_valid_for_program_input(
                 &typ,
                 is_entry_point,
@@ -660,7 +653,7 @@ impl<'context> Elaborator<'context> {
             return_type: func.def.return_type.clone(),
             return_visibility: func.def.return_visibility,
             has_body: !func.def.body.is_empty(),
-            trait_constraints: self.resolve_trait_constraints(&func.def.where_clause),
+            trait_constraints,
             is_entry_point,
             is_trait_function,
             has_inline_attribute,

From a9a6cee501ce3e8b6a6570238057f3b7a0cad799 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 30 May 2024 17:22:25 +0100
Subject: [PATCH 323/416] chore: default to using bn254 in `noirc_frontend`
 (#5144)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR sets `noirc_frontend` to default to bn254 if no feature flag is
set.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 5f1ef6477af..5c196324b7d 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -741,12 +741,10 @@ fn should_check_siblings_for_module(module_path: &Path, parent_path: &Path) -> b
 }
 
 cfg_if::cfg_if! {
-    if #[cfg(feature = "bn254")] {
-        pub const CHOSEN_FIELD: &str = "bn254";
-    } else if #[cfg(feature = "bls12_381")] {
+    if #[cfg(feature = "bls12_381")] {
         pub const CHOSEN_FIELD: &str = "bls12_381";
     } else {
-        compile_error!("please specify a field to compile with");
+        pub const CHOSEN_FIELD: &str = "bn254";
     }
 }
 

From a140dec4580459c5856d44337de3ea08aa7fb44a Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 30 May 2024 11:40:51 -0500
Subject: [PATCH 324/416] fix(experimental elaborator): Fix definition kind of
 globals and tuple patterns with `--use-elaborator` flag (#5139)

# Description

## Problem\*

Resolves two issues:
1. A type error on some tuple patterns because a `follow_bindings` call
was missing
2. When elaborating global lets we were setting the existing definition
id to a DefinitionKind::Global, but it already was one. The fresh ID
created by the let should have been marked global instead.

## Summary\*



## Additional Context

After this PR and https://github.com/noir-lang/noir/pull/5138 all
test_programs are expected to work in the elaborator.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/patterns.rs   |  2 +-
 compiler/noirc_frontend/src/elaborator/statements.rs | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index b6d6cb2cf2d..12b0b7b5e64 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -79,7 +79,7 @@ impl<'context> Elaborator<'context> {
                 HirPattern::Mutable(Box::new(pattern), location)
             }
             Pattern::Tuple(fields, span) => {
-                let field_types = match expected_type {
+                let field_types = match expected_type.follow_bindings() {
                     Type::Tuple(fields) => fields,
                     Type::Error => Vec::new(),
                     expected_type => {
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 9c50e7096dd..40de9a3983a 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -65,11 +65,13 @@ impl<'context> Elaborator<'context> {
 
         // To apply the changes from the fresh id created in elaborate_let to this global
         // we need to change the definition kind and update the type.
-        let definition_id = self.interner.get_global(global_id).definition_id;
-        self.interner.definition_mut(definition_id).kind = DefinitionKind::Global(global_id);
-
         assert_eq!(new_ids.len(), 1, "Globals should only define 1 value");
-        let definition_type = self.interner.definition_type(new_ids[0].id);
+        let new_id = new_ids[0].id;
+
+        self.interner.definition_mut(new_id).kind = DefinitionKind::Global(global_id);
+
+        let definition_id = self.interner.get_global(global_id).definition_id;
+        let definition_type = self.interner.definition_type(new_id);
         self.interner.push_definition_type(definition_id, definition_type);
 
         self.interner.replace_statement(statement_id, let_statement);

From 80fd901ac723e8885efc442683f34b5fef169660 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 30 May 2024 12:01:33 -0500
Subject: [PATCH 325/416] chore: Remove hir to ast pass (#5147)

# Description

## Problem\*

## Summary\*

Removes the Hir to Ast pass since it was only needed for the previously
proposed metacircular evaluator architecture where we'd globally loop
back to name resolution after the interpreter expands a macro. Now that
we're using an elaborator it is unneeded.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/comptime/hir_to_ast.rs            | 369 ------------------
 .../noirc_frontend/src/hir/comptime/mod.rs    |   1 -
 2 files changed, 370 deletions(-)
 delete mode 100644 compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs

diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
deleted file mode 100644
index e0fdd91adb4..00000000000
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_ast.rs
+++ /dev/null
@@ -1,369 +0,0 @@
-use iter_extended::vecmap;
-use noirc_errors::{Span, Spanned};
-
-use crate::ast::{
-    ArrayLiteral, AssignStatement, BlockExpression, CallExpression, CastExpression, ConstrainKind,
-    ConstructorExpression, ExpressionKind, ForLoopStatement, ForRange, Ident, IfExpression,
-    IndexExpression, InfixExpression, LValue, Lambda, LetStatement, Literal,
-    MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression, UnresolvedType,
-    UnresolvedTypeData, UnresolvedTypeExpression,
-};
-use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
-use crate::hir_def::expr::{HirArrayLiteral, HirBlockExpression, HirExpression, HirIdent};
-use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
-use crate::hir_def::types::Type;
-use crate::macros_api::HirLiteral;
-use crate::node_interner::{ExprId, NodeInterner, StmtId};
-
-// TODO:
-// - Full path for idents & types
-// - Assert/AssertEq information lost
-// - The type name span is lost in constructor patterns & expressions
-// - All type spans are lost
-// - Type::TypeVariable has no equivalent in the Ast
-
-impl StmtId {
-    #[allow(unused)]
-    fn to_ast(self, interner: &NodeInterner) -> Statement {
-        let statement = interner.statement(&self);
-        let span = interner.statement_span(self);
-
-        let kind = match statement {
-            HirStatement::Let(let_stmt) => {
-                let pattern = let_stmt.pattern.into_ast(interner);
-                let r#type = interner.id_type(let_stmt.expression).to_ast();
-                let expression = let_stmt.expression.to_ast(interner);
-                StatementKind::Let(LetStatement {
-                    pattern,
-                    r#type,
-                    expression,
-                    comptime: false,
-                    attributes: Vec::new(),
-                })
-            }
-            HirStatement::Constrain(constrain) => {
-                let expr = constrain.0.to_ast(interner);
-                let message = constrain.2.map(|message| message.to_ast(interner));
-
-                // TODO: Find difference in usage between Assert & AssertEq
-                StatementKind::Constrain(ConstrainStatement(expr, message, ConstrainKind::Assert))
-            }
-            HirStatement::Assign(assign) => StatementKind::Assign(AssignStatement {
-                lvalue: assign.lvalue.into_ast(interner),
-                expression: assign.expression.to_ast(interner),
-            }),
-            HirStatement::For(for_stmt) => StatementKind::For(ForLoopStatement {
-                identifier: for_stmt.identifier.to_ast(interner),
-                range: ForRange::Range(
-                    for_stmt.start_range.to_ast(interner),
-                    for_stmt.end_range.to_ast(interner),
-                ),
-                block: for_stmt.block.to_ast(interner),
-                span,
-            }),
-            HirStatement::Break => StatementKind::Break,
-            HirStatement::Continue => StatementKind::Continue,
-            HirStatement::Expression(expr) => StatementKind::Expression(expr.to_ast(interner)),
-            HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
-            HirStatement::Error => StatementKind::Error,
-            HirStatement::Comptime(statement) => {
-                StatementKind::Comptime(Box::new(statement.to_ast(interner)))
-            }
-        };
-
-        Statement { kind, span }
-    }
-}
-
-impl ExprId {
-    #[allow(unused)]
-    fn to_ast(self, interner: &NodeInterner) -> Expression {
-        let expression = interner.expression(&self);
-        let span = interner.expr_span(&self);
-
-        let kind = match expression {
-            HirExpression::Ident(ident, generics) => {
-                let path = Path::from_ident(ident.to_ast(interner));
-                ExpressionKind::Variable(
-                    path,
-                    generics.map(|option| option.iter().map(|generic| generic.to_ast()).collect()),
-                )
-            }
-            HirExpression::Literal(HirLiteral::Array(array)) => {
-                let array = array.into_ast(interner, span);
-                ExpressionKind::Literal(Literal::Array(array))
-            }
-            HirExpression::Literal(HirLiteral::Slice(array)) => {
-                let array = array.into_ast(interner, span);
-                ExpressionKind::Literal(Literal::Slice(array))
-            }
-            HirExpression::Literal(HirLiteral::Bool(value)) => {
-                ExpressionKind::Literal(Literal::Bool(value))
-            }
-            HirExpression::Literal(HirLiteral::Integer(value, sign)) => {
-                ExpressionKind::Literal(Literal::Integer(value, sign))
-            }
-            HirExpression::Literal(HirLiteral::Str(string)) => {
-                ExpressionKind::Literal(Literal::Str(string))
-            }
-            HirExpression::Literal(HirLiteral::FmtStr(string, _exprs)) => {
-                // TODO: Is throwing away the exprs here valid?
-                ExpressionKind::Literal(Literal::FmtStr(string))
-            }
-            HirExpression::Literal(HirLiteral::Unit) => ExpressionKind::Literal(Literal::Unit),
-            HirExpression::Block(expr) => ExpressionKind::Block(expr.into_ast(interner)),
-            HirExpression::Prefix(prefix) => ExpressionKind::Prefix(Box::new(PrefixExpression {
-                operator: prefix.operator,
-                rhs: prefix.rhs.to_ast(interner),
-            })),
-            HirExpression::Infix(infix) => ExpressionKind::Infix(Box::new(InfixExpression {
-                lhs: infix.lhs.to_ast(interner),
-                operator: Spanned::from(infix.operator.location.span, infix.operator.kind),
-                rhs: infix.rhs.to_ast(interner),
-            })),
-            HirExpression::Index(index) => ExpressionKind::Index(Box::new(IndexExpression {
-                collection: index.collection.to_ast(interner),
-                index: index.index.to_ast(interner),
-            })),
-            HirExpression::Constructor(constructor) => {
-                let type_name = constructor.r#type.borrow().name.to_string();
-                let type_name = Path::from_single(type_name, span);
-                let fields =
-                    vecmap(constructor.fields, |(name, expr)| (name, expr.to_ast(interner)));
-
-                ExpressionKind::Constructor(Box::new(ConstructorExpression { type_name, fields }))
-            }
-            HirExpression::MemberAccess(access) => {
-                ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
-                    lhs: access.lhs.to_ast(interner),
-                    rhs: access.rhs,
-                }))
-            }
-            HirExpression::Call(call) => {
-                let func = Box::new(call.func.to_ast(interner));
-                let arguments = vecmap(call.arguments, |arg| arg.to_ast(interner));
-                ExpressionKind::Call(Box::new(CallExpression { func, arguments }))
-            }
-            HirExpression::MethodCall(method_call) => {
-                ExpressionKind::MethodCall(Box::new(MethodCallExpression {
-                    object: method_call.object.to_ast(interner),
-                    method_name: method_call.method,
-                    arguments: vecmap(method_call.arguments, |arg| arg.to_ast(interner)),
-                    generics: method_call
-                        .generics
-                        .map(|option| option.iter().map(|generic| generic.to_ast()).collect()),
-                }))
-            }
-            HirExpression::Cast(cast) => {
-                let lhs = cast.lhs.to_ast(interner);
-                let r#type = cast.r#type.to_ast();
-                ExpressionKind::Cast(Box::new(CastExpression { lhs, r#type }))
-            }
-            HirExpression::If(if_expr) => ExpressionKind::If(Box::new(IfExpression {
-                condition: if_expr.condition.to_ast(interner),
-                consequence: if_expr.consequence.to_ast(interner),
-                alternative: if_expr.alternative.map(|expr| expr.to_ast(interner)),
-            })),
-            HirExpression::Tuple(fields) => {
-                ExpressionKind::Tuple(vecmap(fields, |field| field.to_ast(interner)))
-            }
-            HirExpression::Lambda(lambda) => {
-                let parameters = vecmap(lambda.parameters, |(pattern, typ)| {
-                    (pattern.into_ast(interner), typ.to_ast())
-                });
-                let return_type = lambda.return_type.to_ast();
-                let body = lambda.body.to_ast(interner);
-                ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
-            }
-            HirExpression::Error => ExpressionKind::Error,
-            HirExpression::Comptime(block) => ExpressionKind::Comptime(block.into_ast(interner)),
-            HirExpression::Quote(block) => ExpressionKind::Quote(block),
-
-            // A macro was evaluated here!
-            HirExpression::Unquote(block) => ExpressionKind::Block(block),
-        };
-
-        Expression::new(kind, span)
-    }
-}
-
-impl HirPattern {
-    fn into_ast(self, interner: &NodeInterner) -> Pattern {
-        match self {
-            HirPattern::Identifier(ident) => Pattern::Identifier(ident.to_ast(interner)),
-            HirPattern::Mutable(pattern, location) => {
-                let pattern = Box::new(pattern.into_ast(interner));
-                Pattern::Mutable(pattern, location.span, false)
-            }
-            HirPattern::Tuple(patterns, location) => {
-                let patterns = vecmap(patterns, |pattern| pattern.into_ast(interner));
-                Pattern::Tuple(patterns, location.span)
-            }
-            HirPattern::Struct(typ, patterns, location) => {
-                let patterns =
-                    vecmap(patterns, |(name, pattern)| (name, pattern.into_ast(interner)));
-                let name = match typ.follow_bindings() {
-                    Type::Struct(struct_def, _) => {
-                        let struct_def = struct_def.borrow();
-                        struct_def.name.0.contents.clone()
-                    }
-                    // This pass shouldn't error so if the type isn't a struct we just get a string
-                    // representation of any other type and use that. We're relying on name
-                    // resolution to fail later when this Ast is re-converted to Hir.
-                    other => other.to_string(),
-                };
-                // The name span is lost here
-                let path = Path::from_single(name, location.span);
-                Pattern::Struct(path, patterns, location.span)
-            }
-        }
-    }
-}
-
-impl HirIdent {
-    fn to_ast(&self, interner: &NodeInterner) -> Ident {
-        let name = interner.definition_name(self.id).to_owned();
-        Ident(Spanned::from(self.location.span, name))
-    }
-}
-
-impl Type {
-    fn to_ast(&self) -> UnresolvedType {
-        let typ = match self {
-            Type::FieldElement => UnresolvedTypeData::FieldElement,
-            Type::Array(length, element) => {
-                let length = length.to_type_expression();
-                let element = Box::new(element.to_ast());
-                UnresolvedTypeData::Array(length, element)
-            }
-            Type::Slice(element) => {
-                let element = Box::new(element.to_ast());
-                UnresolvedTypeData::Slice(element)
-            }
-            Type::Integer(sign, bit_size) => UnresolvedTypeData::Integer(*sign, *bit_size),
-            Type::Bool => UnresolvedTypeData::Bool,
-            Type::String(length) => {
-                let length = length.to_type_expression();
-                UnresolvedTypeData::String(Some(length))
-            }
-            Type::FmtString(length, element) => {
-                let length = length.to_type_expression();
-                let element = Box::new(element.to_ast());
-                UnresolvedTypeData::FormatString(length, element)
-            }
-            Type::Unit => UnresolvedTypeData::Unit,
-            Type::Tuple(fields) => {
-                let fields = vecmap(fields, |field| field.to_ast());
-                UnresolvedTypeData::Tuple(fields)
-            }
-            Type::Struct(def, generics) => {
-                let struct_def = def.borrow();
-                let generics = vecmap(generics, |generic| generic.to_ast());
-                let name = Path::from_ident(struct_def.name.clone());
-                UnresolvedTypeData::Named(name, generics, false)
-            }
-            Type::Alias(type_def, generics) => {
-                // Keep the alias name instead of expanding this in case the
-                // alias' definition was changed
-                let type_def = type_def.borrow();
-                let generics = vecmap(generics, |generic| generic.to_ast());
-                let name = Path::from_ident(type_def.name.clone());
-                UnresolvedTypeData::Named(name, generics, false)
-            }
-            Type::TypeVariable(_, _) => todo!("Convert Type::TypeVariable Hir -> Ast"),
-            Type::TraitAsType(_, name, generics) => {
-                let generics = vecmap(generics, |generic| generic.to_ast());
-                let name = Path::from_single(name.as_ref().clone(), Span::default());
-                UnresolvedTypeData::TraitAsType(name, generics)
-            }
-            Type::NamedGeneric(_, name) => {
-                let name = Path::from_single(name.as_ref().clone(), Span::default());
-                UnresolvedTypeData::TraitAsType(name, Vec::new())
-            }
-            Type::Function(args, ret, env) => {
-                let args = vecmap(args, |arg| arg.to_ast());
-                let ret = Box::new(ret.to_ast());
-                let env = Box::new(env.to_ast());
-                UnresolvedTypeData::Function(args, ret, env)
-            }
-            Type::MutableReference(element) => {
-                let element = Box::new(element.to_ast());
-                UnresolvedTypeData::MutableReference(element)
-            }
-            // Type::Forall is only for generic functions which don't store a type
-            // in their Ast so they don't need to call to_ast for their Forall type.
-            // Since there is no UnresolvedTypeData equivalent for Type::Forall, we use
-            // this to ignore this case since it shouldn't be needed anyway.
-            Type::Forall(_, typ) => return typ.to_ast(),
-            Type::Constant(_) => panic!("Type::Constant where a type was expected: {self:?}"),
-            Type::Code => UnresolvedTypeData::Code,
-            Type::Error => UnresolvedTypeData::Error,
-        };
-
-        UnresolvedType { typ, span: None }
-    }
-
-    fn to_type_expression(&self) -> UnresolvedTypeExpression {
-        let span = Span::default();
-
-        match self.follow_bindings() {
-            Type::Constant(length) => UnresolvedTypeExpression::Constant(length, span),
-            Type::NamedGeneric(_, name) => {
-                let path = Path::from_single(name.as_ref().clone(), span);
-                UnresolvedTypeExpression::Variable(path)
-            }
-            // TODO: This should be turned into a proper error.
-            other => panic!("Cannot represent {other:?} as type expression"),
-        }
-    }
-}
-
-impl HirLValue {
-    fn into_ast(self, interner: &NodeInterner) -> LValue {
-        match self {
-            HirLValue::Ident(ident, _) => LValue::Ident(ident.to_ast(interner)),
-            HirLValue::MemberAccess { object, field_name, field_index: _, typ: _, location } => {
-                let object = Box::new(object.into_ast(interner));
-                LValue::MemberAccess { object, field_name, span: location.span }
-            }
-            HirLValue::Index { array, index, typ: _, location } => {
-                let array = Box::new(array.into_ast(interner));
-                let index = index.to_ast(interner);
-                LValue::Index { array, index, span: location.span }
-            }
-            HirLValue::Dereference { lvalue, element_type: _, location } => {
-                let lvalue = Box::new(lvalue.into_ast(interner));
-                LValue::Dereference(lvalue, location.span)
-            }
-        }
-    }
-}
-
-impl HirArrayLiteral {
-    fn into_ast(self, interner: &NodeInterner, span: Span) -> ArrayLiteral {
-        match self {
-            HirArrayLiteral::Standard(elements) => {
-                ArrayLiteral::Standard(vecmap(elements, |element| element.to_ast(interner)))
-            }
-            HirArrayLiteral::Repeated { repeated_element, length } => {
-                let repeated_element = Box::new(repeated_element.to_ast(interner));
-                let length = match length {
-                    Type::Constant(length) => {
-                        let literal = Literal::Integer((length as u128).into(), false);
-                        let kind = ExpressionKind::Literal(literal);
-                        Box::new(Expression::new(kind, span))
-                    }
-                    other => panic!("Cannot convert non-constant type for repeated array literal from Hir -> Ast: {other:?}"),
-                };
-                ArrayLiteral::Repeated { repeated_element, length }
-            }
-        }
-    }
-}
-
-impl HirBlockExpression {
-    fn into_ast(self, interner: &NodeInterner) -> BlockExpression {
-        let statements = vecmap(self.statements, |statement| statement.to_ast(interner));
-        BlockExpression { statements }
-    }
-}
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
index 0c8efae63ee..ab984d2f2be 100644
--- a/compiler/noirc_frontend/src/hir/comptime/mod.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -1,5 +1,4 @@
 mod errors;
-mod hir_to_ast;
 mod interpreter;
 mod scan;
 mod tests;

From 05df0cc30e6aaed70989b31a3b09d60afd1510a0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 30 May 2024 13:53:16 -0500
Subject: [PATCH 326/416] chore: Remove unused `new_variables` argument from
 `resolve_type_inner` (#5148)

# Description

## Problem\*

## Summary\*

This argument was previously used to add a fresh generic to a function's
signature when we found a slice type back when those used a generic for
the length. Since Slice types are now their own type this code path
isn't accessible anymore (*).

(\*) The codepath is technically accessible by trying to use a string
slice type but we don't support these yet anyway so I've removed them.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/mod.rs        |  7 +-
 compiler/noirc_frontend/src/elaborator/mod.rs |  2 +-
 .../noirc_frontend/src/elaborator/types.rs    | 77 +++++--------------
 .../src/hir/resolution/resolver.rs            | 77 ++++++-------------
 compiler/noirc_frontend/src/parser/parser.rs  |  4 +-
 5 files changed, 46 insertions(+), 121 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 090a41fa7d9..a9d9f232b64 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -92,7 +92,7 @@ pub enum UnresolvedTypeData {
     Integer(Signedness, IntegerBitSize), // u32 = Integer(unsigned, ThirtyTwo)
     Bool,
     Expression(UnresolvedTypeExpression),
-    String(Option<UnresolvedTypeExpression>),
+    String(UnresolvedTypeExpression),
     FormatString(UnresolvedTypeExpression, Box<UnresolvedType>),
     Unit,
 
@@ -191,10 +191,7 @@ impl std::fmt::Display for UnresolvedTypeData {
             }
             Expression(expression) => expression.fmt(f),
             Bool => write!(f, "bool"),
-            String(len) => match len {
-                None => write!(f, "str<_>"),
-                Some(len) => write!(f, "str<{len}>"),
-            },
+            String(len) => write!(f, "str<{len}>"),
             FormatString(len, elements) => write!(f, "fmt<{len}, {elements}"),
             Function(args, ret, env) => {
                 let args = vecmap(args, ToString::to_string).join(", ");
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index a0ff3c12ae3..3c9383b8262 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -566,7 +566,7 @@ impl<'context> Elaborator<'context> {
                 UnresolvedTypeData::TraitAsType(path, args) => {
                     self.desugar_impl_trait_arg(path, args, &mut generics, &mut trait_constraints)
                 }
-                _ => self.resolve_type_inner(typ, &mut generics),
+                _ => self.resolve_type_inner(typ),
             };
 
             self.check_if_type_is_valid_for_program_input(
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 059ff857df8..955b4af327a 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -39,59 +39,52 @@ impl<'context> Elaborator<'context> {
     /// Translates an UnresolvedType to a Type
     pub(super) fn resolve_type(&mut self, typ: UnresolvedType) -> Type {
         let span = typ.span;
-        let resolved_type = self.resolve_type_inner(typ, &mut vec![]);
+        let resolved_type = self.resolve_type_inner(typ);
         if resolved_type.is_nested_slice() {
             self.push_err(ResolverError::NestedSlices { span: span.unwrap() });
         }
-
         resolved_type
     }
 
     /// Translates an UnresolvedType into a Type and appends any
     /// freshly created TypeVariables created to new_variables.
-    pub fn resolve_type_inner(
-        &mut self,
-        typ: UnresolvedType,
-        new_variables: &mut Generics,
-    ) -> Type {
+    pub fn resolve_type_inner(&mut self, typ: UnresolvedType) -> Type {
         use crate::ast::UnresolvedTypeData::*;
 
         let resolved_type = match typ.typ {
             FieldElement => Type::FieldElement,
             Array(size, elem) => {
-                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
-                let size = self.resolve_array_size(Some(size), new_variables);
+                let elem = Box::new(self.resolve_type_inner(*elem));
+                let size = self.convert_expression_type(size);
                 Type::Array(Box::new(size), elem)
             }
             Slice(elem) => {
-                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
+                let elem = Box::new(self.resolve_type_inner(*elem));
                 Type::Slice(elem)
             }
             Expression(expr) => self.convert_expression_type(expr),
             Integer(sign, bits) => Type::Integer(sign, bits),
             Bool => Type::Bool,
             String(size) => {
-                let resolved_size = self.resolve_array_size(size, new_variables);
+                let resolved_size = self.convert_expression_type(size);
                 Type::String(Box::new(resolved_size))
             }
             FormatString(size, fields) => {
                 let resolved_size = self.convert_expression_type(size);
-                let fields = self.resolve_type_inner(*fields, new_variables);
+                let fields = self.resolve_type_inner(*fields);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
             Code => Type::Code,
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
-            Named(path, args, _) => self.resolve_named_type(path, args, new_variables),
-            TraitAsType(path, args) => self.resolve_trait_as_type(path, args, new_variables),
+            Named(path, args, _) => self.resolve_named_type(path, args),
+            TraitAsType(path, args) => self.resolve_trait_as_type(path, args),
 
-            Tuple(fields) => {
-                Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field, new_variables)))
-            }
+            Tuple(fields) => Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field))),
             Function(args, ret, env) => {
-                let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
-                let ret = Box::new(self.resolve_type_inner(*ret, new_variables));
+                let args = vecmap(args, |arg| self.resolve_type_inner(arg));
+                let ret = Box::new(self.resolve_type_inner(*ret));
 
                 // expect() here is valid, because the only places we don't have a span are omitted types
                 // e.g. a function without return type implicitly has a spanless UnresolvedType::Unit return type
@@ -99,7 +92,7 @@ impl<'context> Elaborator<'context> {
                 let env_span =
                     env.span.expect("Unexpected missing span for closure environment type");
 
-                let env = Box::new(self.resolve_type_inner(*env, new_variables));
+                let env = Box::new(self.resolve_type_inner(*env));
 
                 match *env {
                     Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _) => {
@@ -115,9 +108,9 @@ impl<'context> Elaborator<'context> {
                 }
             }
             MutableReference(element) => {
-                Type::MutableReference(Box::new(self.resolve_type_inner(*element, new_variables)))
+                Type::MutableReference(Box::new(self.resolve_type_inner(*element)))
             }
-            Parenthesized(typ) => self.resolve_type_inner(*typ, new_variables),
+            Parenthesized(typ) => self.resolve_type_inner(*typ),
         };
 
         if let Type::Struct(_, _) = resolved_type {
@@ -136,12 +129,7 @@ impl<'context> Elaborator<'context> {
         self.generics.iter().find(|(name, _, _)| name.as_ref() == target_name)
     }
 
-    fn resolve_named_type(
-        &mut self,
-        path: Path,
-        args: Vec<UnresolvedType>,
-        new_variables: &mut Generics,
-    ) -> Type {
+    fn resolve_named_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
         if args.is_empty() {
             if let Some(typ) = self.lookup_generic_or_global_type(&path) {
                 return typ;
@@ -164,7 +152,7 @@ impl<'context> Elaborator<'context> {
         }
 
         let span = path.span();
-        let mut args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+        let mut args = vecmap(args, |arg| self.resolve_type_inner(arg));
 
         if let Some(type_alias) = self.lookup_type_alias(path.clone()) {
             let type_alias = type_alias.borrow();
@@ -230,13 +218,8 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn resolve_trait_as_type(
-        &mut self,
-        path: Path,
-        args: Vec<UnresolvedType>,
-        new_variables: &mut Generics,
-    ) -> Type {
-        let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+    fn resolve_trait_as_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
+        let args = vecmap(args, |arg| self.resolve_type_inner(arg));
 
         if let Some(t) = self.lookup_trait_or_error(path) {
             Type::TraitAsType(t.id, Rc::new(t.name.to_string()), args)
@@ -286,26 +269,6 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn resolve_array_size(
-        &mut self,
-        length: Option<UnresolvedTypeExpression>,
-        new_variables: &mut Generics,
-    ) -> Type {
-        match length {
-            None => {
-                let id = self.interner.next_type_variable_id();
-                let typevar = TypeVariable::unbound(id);
-                new_variables.push(typevar.clone());
-
-                // 'Named'Generic is a bit of a misnomer here, we want a type variable that
-                // wont be bound over but this one has no name since we do not currently
-                // require users to explicitly be generic over array lengths.
-                Type::NamedGeneric(typevar, Rc::new("".into()))
-            }
-            Some(length) => self.convert_expression_type(length),
-        }
-    }
-
     pub(super) fn convert_expression_type(&mut self, length: UnresolvedTypeExpression) -> Type {
         match length {
             UnresolvedTypeExpression::Variable(path) => {
@@ -622,7 +585,7 @@ impl<'context> Elaborator<'context> {
     pub(super) fn resolve_inferred_type(&mut self, typ: UnresolvedType) -> Type {
         match &typ.typ {
             UnresolvedTypeData::Unspecified => self.interner.next_type_variable(),
-            _ => self.resolve_type_inner(typ, &mut vec![]),
+            _ => self.resolve_type(typ),
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index fd77312e4f2..35ba964c499 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -538,45 +538,43 @@ impl<'a> Resolver<'a> {
 
     /// Translates an UnresolvedType into a Type and appends any
     /// freshly created TypeVariables created to new_variables.
-    fn resolve_type_inner(&mut self, typ: UnresolvedType, new_variables: &mut Generics) -> Type {
+    fn resolve_type_inner(&mut self, typ: UnresolvedType) -> Type {
         use crate::ast::UnresolvedTypeData::*;
 
         let resolved_type = match typ.typ {
             FieldElement => Type::FieldElement,
             Array(size, elem) => {
-                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
-                let size = self.resolve_array_size(Some(size), new_variables);
+                let elem = Box::new(self.resolve_type_inner(*elem));
+                let size = self.convert_expression_type(size);
                 Type::Array(Box::new(size), elem)
             }
             Slice(elem) => {
-                let elem = Box::new(self.resolve_type_inner(*elem, new_variables));
+                let elem = Box::new(self.resolve_type_inner(*elem));
                 Type::Slice(elem)
             }
             Expression(expr) => self.convert_expression_type(expr),
             Integer(sign, bits) => Type::Integer(sign, bits),
             Bool => Type::Bool,
             String(size) => {
-                let resolved_size = self.resolve_array_size(size, new_variables);
+                let resolved_size = self.convert_expression_type(size);
                 Type::String(Box::new(resolved_size))
             }
             FormatString(size, fields) => {
                 let resolved_size = self.convert_expression_type(size);
-                let fields = self.resolve_type_inner(*fields, new_variables);
+                let fields = self.resolve_type_inner(*fields);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
             Code => Type::Code,
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
-            Named(path, args, _) => self.resolve_named_type(path, args, new_variables),
-            TraitAsType(path, args) => self.resolve_trait_as_type(path, args, new_variables),
+            Named(path, args, _) => self.resolve_named_type(path, args),
+            TraitAsType(path, args) => self.resolve_trait_as_type(path, args),
 
-            Tuple(fields) => {
-                Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field, new_variables)))
-            }
+            Tuple(fields) => Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field))),
             Function(args, ret, env) => {
-                let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
-                let ret = Box::new(self.resolve_type_inner(*ret, new_variables));
+                let args = vecmap(args, |arg| self.resolve_type_inner(arg));
+                let ret = Box::new(self.resolve_type_inner(*ret));
 
                 // expect() here is valid, because the only places we don't have a span are omitted types
                 // e.g. a function without return type implicitly has a spanless UnresolvedType::Unit return type
@@ -584,7 +582,7 @@ impl<'a> Resolver<'a> {
                 let env_span =
                     env.span.expect("Unexpected missing span for closure environment type");
 
-                let env = Box::new(self.resolve_type_inner(*env, new_variables));
+                let env = Box::new(self.resolve_type_inner(*env));
 
                 match *env {
                     Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _) => {
@@ -600,9 +598,9 @@ impl<'a> Resolver<'a> {
                 }
             }
             MutableReference(element) => {
-                Type::MutableReference(Box::new(self.resolve_type_inner(*element, new_variables)))
+                Type::MutableReference(Box::new(self.resolve_type_inner(*element)))
             }
-            Parenthesized(typ) => self.resolve_type_inner(*typ, new_variables),
+            Parenthesized(typ) => self.resolve_type_inner(*typ),
         };
 
         if let Type::Struct(_, _) = resolved_type {
@@ -621,12 +619,7 @@ impl<'a> Resolver<'a> {
         self.generics.iter().find(|(name, _, _)| name.as_ref() == target_name)
     }
 
-    fn resolve_named_type(
-        &mut self,
-        path: Path,
-        args: Vec<UnresolvedType>,
-        new_variables: &mut Generics,
-    ) -> Type {
+    fn resolve_named_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
         if args.is_empty() {
             if let Some(typ) = self.lookup_generic_or_global_type(&path) {
                 return typ;
@@ -649,7 +642,7 @@ impl<'a> Resolver<'a> {
         }
 
         let span = path.span();
-        let mut args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+        let mut args = vecmap(args, |arg| self.resolve_type_inner(arg));
 
         if let Some(type_alias) = self.lookup_type_alias(path.clone()) {
             let type_alias = type_alias.borrow();
@@ -715,13 +708,8 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    fn resolve_trait_as_type(
-        &mut self,
-        path: Path,
-        args: Vec<UnresolvedType>,
-        new_variables: &mut Generics,
-    ) -> Type {
-        let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables));
+    fn resolve_trait_as_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
+        let args = vecmap(args, |arg| self.resolve_type_inner(arg));
 
         if let Some(t) = self.lookup_trait_or_error(path) {
             Type::TraitAsType(t.id, Rc::new(t.name.to_string()), args)
@@ -774,26 +762,6 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    fn resolve_array_size(
-        &mut self,
-        length: Option<UnresolvedTypeExpression>,
-        new_variables: &mut Generics,
-    ) -> Type {
-        match length {
-            None => {
-                let id = self.interner.next_type_variable_id();
-                let typevar = TypeVariable::unbound(id);
-                new_variables.push(typevar.clone());
-
-                // 'Named'Generic is a bit of a misnomer here, we want a type variable that
-                // wont be bound over but this one has no name since we do not currently
-                // require users to explicitly be generic over array lengths.
-                Type::NamedGeneric(typevar, Rc::new("".into()))
-            }
-            Some(length) => self.convert_expression_type(length),
-        }
-    }
-
     fn convert_expression_type(&mut self, length: UnresolvedTypeExpression) -> Type {
         match length {
             UnresolvedTypeExpression::Variable(path) => {
@@ -846,11 +814,10 @@ impl<'a> Resolver<'a> {
     /// Translates an UnresolvedType to a Type
     pub fn resolve_type(&mut self, typ: UnresolvedType) -> Type {
         let span = typ.span;
-        let resolved_type = self.resolve_type_inner(typ, &mut vec![]);
+        let resolved_type = self.resolve_type_inner(typ);
         if resolved_type.is_nested_slice() {
             self.errors.push(ResolverError::NestedSlices { span: span.unwrap() });
         }
-
         resolved_type
     }
 
@@ -891,7 +858,7 @@ impl<'a> Resolver<'a> {
     fn resolve_inferred_type(&mut self, typ: UnresolvedType) -> Type {
         match &typ.typ {
             UnresolvedTypeData::Unspecified => self.interner.next_type_variable(),
-            _ => self.resolve_type_inner(typ, &mut vec![]),
+            _ => self.resolve_type(typ),
         }
     }
 
@@ -1019,7 +986,7 @@ impl<'a> Resolver<'a> {
         // indicate we should code generate in the same way. Thus, we unify the attributes into one flag here.
         let has_inline_attribute = has_no_predicates_attribute || should_fold;
 
-        let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
+        let generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
         let mut parameters = vec![];
         let mut parameter_types = vec![];
 
@@ -1032,7 +999,7 @@ impl<'a> Resolver<'a> {
             }
 
             let pattern = self.resolve_pattern(pattern, DefinitionKind::Local(None));
-            let typ = self.resolve_type_inner(typ, &mut generics);
+            let typ = self.resolve_type_inner(typ);
 
             parameters.push((pattern, typ.clone(), visibility));
             parameter_types.push(typ);
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 890ab795e00..702ea79af9d 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -745,9 +745,7 @@ fn bool_type() -> impl NoirParser<UnresolvedType> {
 
 fn string_type() -> impl NoirParser<UnresolvedType> {
     keyword(Keyword::String)
-        .ignore_then(
-            type_expression().delimited_by(just(Token::Less), just(Token::Greater)).or_not(),
-        )
+        .ignore_then(type_expression().delimited_by(just(Token::Less), just(Token::Greater)))
         .map_with_span(|expr, span| UnresolvedTypeData::String(expr).with_span(span))
 }
 

From d6122eb9e88aa2b1bb6c990e452fa9678ae49704 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 30 May 2024 13:56:41 -0500
Subject: [PATCH 327/416] fix(experimental elaborator): Fix frontend tests when
 `--use-elaborator` flag is specified (#5145)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5146

Fixes all failing frontend tests with the elaborator

## Summary\*

This PR includes a few fixes:
- Use `check_trait_impl_method_matches_declaration` to issue errors when
a trait impl method is declared with an incorrect signature.
- `define_function_meta` for default trait functions on impls when
they're copied over. Also make sure to set `self.current_trait_impl` and
`self.self_type` for them as well.
- Use `try_get_trait_implementation` when getting a trait impl may fail
(which may happen if there was a previous error resolving the trait for
that impl). This was triggering on the test where we tried to declare a
trait impl implementing a struct rather than a trait.
- `check_trait_wrong_parameter_type` has a duplicate error on master but
not in the elaborator so I changed the expected error count there.

## Additional Context

After this PR all existing code _should_ work with the elaborator and we
can get the word out to get others testing the `--use-elaborator` flag
for any errors/panics.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs    | 16 +++++++++++++---
 .../noirc_frontend/src/hir/type_check/mod.rs     |  8 +++++++-
 compiler/noirc_frontend/src/node_interner.rs     |  4 ++++
 compiler/noirc_frontend/src/tests.rs             | 13 +++++++------
 4 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 3c9383b8262..594c0690033 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -15,7 +15,7 @@ use crate::{
         },
         resolution::{errors::ResolverError, path_resolver::PathResolver, resolver::LambdaContext},
         scope::ScopeForest as GenericScopeForest,
-        type_check::TypeCheckError,
+        type_check::{check_trait_impl_method_matches_declaration, TypeCheckError},
     },
     hir_def::{expr::HirIdent, function::Parameters, traits::TraitConstraint},
     macros_api::{
@@ -851,6 +851,12 @@ impl<'context> Elaborator<'context> {
         self.generics = trait_impl.resolved_generics;
         self.current_trait_impl = trait_impl.impl_id;
 
+        for (module, function, _) in &trait_impl.methods.functions {
+            self.local_module = *module;
+            let errors = check_trait_impl_method_matches_declaration(self.interner, *function);
+            self.errors.extend(errors.into_iter().map(|error| (error.into(), self.file)));
+        }
+
         self.elaborate_functions(trait_impl.methods);
 
         self.self_type = None;
@@ -877,12 +883,14 @@ impl<'context> Elaborator<'context> {
     fn collect_trait_impl(&mut self, trait_impl: &mut UnresolvedTraitImpl) {
         self.local_module = trait_impl.module_id;
         self.file = trait_impl.file_id;
+        self.current_trait_impl = trait_impl.impl_id;
         trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
 
         let self_type = trait_impl.methods.self_type.clone();
         let self_type =
             self_type.expect("Expected struct type to be set before collect_trait_impl");
 
+        self.self_type = Some(self_type.clone());
         let self_type_span = trait_impl.object_type.span;
 
         if matches!(self_type, Type::MutableReference(_)) {
@@ -890,12 +898,11 @@ impl<'context> Elaborator<'context> {
             self.push_err(DefCollectorErrorKind::MutableReferenceInTraitImpl { span });
         }
 
-        assert!(trait_impl.trait_id.is_some());
         if let Some(trait_id) = trait_impl.trait_id {
+            self.generics = trait_impl.resolved_generics.clone();
             self.collect_trait_impl_methods(trait_id, trait_impl);
 
             let span = trait_impl.object_type.span.expect("All trait self types should have spans");
-            self.generics = trait_impl.resolved_generics.clone();
             self.declare_methods_on_struct(true, &mut trait_impl.methods, span);
 
             let methods = trait_impl.methods.function_ids();
@@ -945,6 +952,8 @@ impl<'context> Elaborator<'context> {
         }
 
         self.generics.clear();
+        self.current_trait_impl = None;
+        self.self_type = None;
     }
 
     fn get_module_mut(&mut self, module: ModuleId) -> &mut ModuleData {
@@ -1059,6 +1068,7 @@ impl<'context> Elaborator<'context> {
                     let module = self.module_id();
                     let location = Location::new(default_impl.def.span, trait_impl.file_id);
                     self.interner.push_function(func_id, &default_impl.def, module, location);
+                    self.define_function_meta(&mut default_impl_clone, func_id, false);
                     func_ids_in_trait.insert(func_id);
                     ordered_methods.push((
                         method.default_impl_module_id,
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index de2e575b4e2..65a3186b004 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -237,7 +237,13 @@ pub(crate) fn check_trait_impl_method_matches_declaration(
 
     let impl_ =
         meta.trait_impl.expect("Trait impl function should have a corresponding trait impl");
-    let impl_ = interner.get_trait_implementation(impl_);
+
+    // If the trait implementation is not defined in the interner then there was a previous
+    // error in resolving the trait path and there is likely no trait for this impl.
+    let Some(impl_) = interner.try_get_trait_implementation(impl_) else {
+        return errors;
+    };
+
     let impl_ = impl_.borrow();
     let trait_info = interner.get_trait(impl_.trait_id);
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 60cc2580bb8..e28a0a64ad0 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1145,6 +1145,10 @@ impl NodeInterner {
         }
     }
 
+    pub fn try_get_trait_implementation(&self, id: TraitImplId) -> Option<Shared<TraitImpl>> {
+        self.trait_implementations.get(&id).cloned()
+    }
+
     pub fn get_trait_implementation(&self, id: TraitImplId) -> Shared<TraitImpl> {
         self.trait_implementations[&id].clone()
     }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index bd81752c046..99215c8f173 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -494,7 +494,10 @@ fn check_trait_wrong_parameter_type() {
     }";
     let errors = get_program_errors(src);
     assert!(!has_parser_error(&errors));
-    assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors);
+
+    // This is a duplicate error in the name resolver & type checker.
+    // In the elaborator there is no duplicate and only 1 error is issued
+    assert!(errors.len() <= 2, "Expected 1 or 2 errors, got: {:?}", errors);
 
     for (err, _file_id) in errors {
         match &err {
@@ -593,22 +596,20 @@ fn check_impl_struct_not_trait() {
         bar: Field,
         array: [Field; 2],
     }
-    
+
     struct Default {
         x: Field,
         z: Field, 
     }
     
-    // Default is struct not a trait
+    // Default is a struct not a trait
     impl Default for Foo {
         fn default(x: Field, y: Field) -> Self {
             Self { bar: x, array: [x,y] }
         }
     }
     
-    fn main() {
-    }
-    
+    fn main() {}
     ";
     let errors = get_program_errors(src);
     assert!(!has_parser_error(&errors));

From 1252b5fcc7ed56bb55e95745b83be6e556805397 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 31 May 2024 12:38:01 +0100
Subject: [PATCH 328/416] feat: place return value witnesses directly after
 function arguments (#5142)

# Description

## Problem\*

Resolves #5104
## Summary\*

This PR preallocates some witnesses to hold the return values at the
beginning of ACIR gen and then adds assertions to fill these witnesses
with the return values. This ensures that the return values will be
placed in the witness map directly after any function inputs (reasons
for this being desirable are laid out in #5104)

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |  13 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |   8 --
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   | 122 +++++++++++-------
 3 files changed, 75 insertions(+), 68 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 93200d4f841..93dd47afe68 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -255,7 +255,7 @@ impl AcirContext {
     }
 
     /// Converts an [`AcirVar`] to a [`Witness`]
-    fn var_to_witness(&mut self, var: AcirVar) -> Result<Witness, InternalError> {
+    pub(crate) fn var_to_witness(&mut self, var: AcirVar) -> Result<Witness, InternalError> {
         let expression = self.var_to_expression(var)?;
         let witness = if let Some(constant) = expression.to_const() {
             // Check if a witness has been assigned this value already, if so reuse it.
@@ -1027,15 +1027,6 @@ impl AcirContext {
         Ok(remainder)
     }
 
-    /// Converts the `AcirVar` to a `Witness` if it hasn't been already, and appends it to the
-    /// `GeneratedAcir`'s return witnesses.
-    pub(crate) fn return_var(&mut self, acir_var: AcirVar) -> Result<(), InternalError> {
-        let return_var = self.get_or_create_witness_var(acir_var)?;
-        let witness = self.var_to_witness(return_var)?;
-        self.acir_ir.push_return_witness(witness);
-        Ok(())
-    }
-
     /// Constrains the `AcirVar` variable to be of type `NumericType`.
     pub(crate) fn range_constrain_var(
         &mut self,
@@ -1538,9 +1529,11 @@ impl AcirContext {
     pub(crate) fn finish(
         mut self,
         inputs: Vec<Witness>,
+        return_values: Vec<Witness>,
         warnings: Vec<SsaReport>,
     ) -> GeneratedAcir {
         self.acir_ir.input_witnesses = inputs;
+        self.acir_ir.return_witnesses = return_values;
         self.acir_ir.warnings = warnings;
         self.acir_ir
     }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 6c79c0a228d..9a09e7c06ee 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -45,9 +45,6 @@ pub(crate) struct GeneratedAcir {
     opcodes: Vec<AcirOpcode<FieldElement>>,
 
     /// All witness indices that comprise the final return value of the program
-    ///
-    /// Note: This may contain repeated indices, which is necessary for later mapping into the
-    /// abi's return type.
     pub(crate) return_witnesses: Vec<Witness>,
 
     /// All witness indices which are inputs to the main function
@@ -164,11 +161,6 @@ impl GeneratedAcir {
 
         fresh_witness
     }
-
-    /// Adds a witness index to the program's return witnesses.
-    pub(crate) fn push_return_witness(&mut self, witness: Witness) {
-        self.return_witnesses.push(witness);
-    }
 }
 
 impl GeneratedAcir {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 13677506d0b..6d7c5e570c1 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -36,11 +36,7 @@ use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{AssertionPayload, ErrorSelector, OpcodeLocation};
 use acvm::acir::native_types::Witness;
 use acvm::acir::BlackBoxFunc;
-use acvm::{
-    acir::AcirField,
-    acir::{circuit::opcodes::BlockId, native_types::Expression},
-    FieldElement,
-};
+use acvm::{acir::circuit::opcodes::BlockId, acir::AcirField, FieldElement};
 use fxhash::FxHashMap as HashMap;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
@@ -330,38 +326,10 @@ impl Ssa {
             bytecode: brillig.byte_code,
         });
 
-        let runtime_types = self.functions.values().map(|function| function.runtime());
-        for (acir, runtime_type) in acirs.iter_mut().zip(runtime_types) {
-            if matches!(runtime_type, RuntimeType::Acir(_)) {
-                generate_distinct_return_witnesses(acir);
-            }
-        }
-
         Ok((acirs, brillig, self.error_selector_to_type))
     }
 }
 
-fn generate_distinct_return_witnesses(acir: &mut GeneratedAcir) {
-    // Create a witness for each return witness we have to guarantee that the return witnesses match the standard
-    // layout for serializing those types as if they were being passed as inputs.
-    //
-    // This is required for recursion as otherwise in situations where we cannot make use of the program's ABI
-    // (e.g. for `std::verify_proof` or the solidity verifier), we need extra knowledge about the program we're
-    // working with rather than following the standard ABI encoding rules.
-    //
-    // TODO: We're being conservative here by generating a new witness for every expression.
-    // This means that we're likely to get a number of constraints which are just renumbering witnesses.
-    // This can be tackled by:
-    // - Tracking the last assigned public input witness and only renumbering a witness if it is below this value.
-    // - Modifying existing constraints to rearrange their outputs so they are suitable
-    //   - See: https://github.com/noir-lang/noir/pull/4467
-    let distinct_return_witness = vecmap(acir.return_witnesses.clone(), |return_witness| {
-        acir.create_witness_for_expression(&Expression::from(return_witness))
-    });
-
-    acir.return_witnesses = distinct_return_witness;
-}
-
 impl<'a> Context<'a> {
     fn new(shared_context: &'a mut SharedContext) -> Context<'a> {
         let mut acir_context = AcirContext::default();
@@ -422,6 +390,25 @@ impl<'a> Context<'a> {
         let dfg = &main_func.dfg;
         let entry_block = &dfg[main_func.entry_block()];
         let input_witness = self.convert_ssa_block_params(entry_block.parameters(), dfg)?;
+        let num_return_witnesses =
+            self.get_num_return_witnesses(entry_block.unwrap_terminator(), dfg);
+
+        // Create a witness for each return witness we have to guarantee that the return witnesses match the standard
+        // layout for serializing those types as if they were being passed as inputs.
+        //
+        // This is required for recursion as otherwise in situations where we cannot make use of the program's ABI
+        // (e.g. for `std::verify_proof` or the solidity verifier), we need extra knowledge about the program we're
+        // working with rather than following the standard ABI encoding rules.
+        //
+        // We allocate these witnesses now before performing ACIR gen for the rest of the program as the location of
+        // the function's return values can then be determined through knowledge of its ABI alone.
+        let return_witness_vars =
+            vecmap(0..num_return_witnesses, |_| self.acir_context.add_variable());
+
+        let return_witnesses = vecmap(&return_witness_vars, |return_var| {
+            let expr = self.acir_context.var_to_expression(*return_var).unwrap();
+            expr.to_witness().expect("return vars should be witnesses")
+        });
 
         self.data_bus = dfg.data_bus.to_owned();
         let mut warnings = Vec::new();
@@ -429,8 +416,19 @@ impl<'a> Context<'a> {
             warnings.extend(self.convert_ssa_instruction(*instruction_id, dfg, ssa, brillig)?);
         }
 
-        warnings.extend(self.convert_ssa_return(entry_block.unwrap_terminator(), dfg)?);
-        Ok(self.acir_context.finish(input_witness, warnings))
+        let (return_vars, return_warnings) =
+            self.convert_ssa_return(entry_block.unwrap_terminator(), dfg)?;
+
+        // TODO: This is a naive method of assigning the return values to their witnesses as
+        // we're likely to get a number of constraints which are asserting one witness to be equal to another.
+        //
+        // We should search through the program and relabel these witnesses so we can remove this constraint.
+        for (witness_var, return_var) in return_witness_vars.iter().zip(return_vars) {
+            self.acir_context.assert_eq_var(*witness_var, return_var, None)?;
+        }
+
+        warnings.extend(return_warnings);
+        Ok(self.acir_context.finish(input_witness, return_witnesses, warnings))
     }
 
     fn convert_brillig_main(
@@ -468,17 +466,13 @@ impl<'a> Context<'a> {
         )?;
         self.shared_context.insert_generated_brillig(main_func.id(), arguments, 0, code);
 
-        let output_vars: Vec<_> = output_values
+        let return_witnesses: Vec<Witness> = output_values
             .iter()
             .flat_map(|value| value.clone().flatten())
-            .map(|value| value.0)
-            .collect();
+            .map(|(value, _)| self.acir_context.var_to_witness(value))
+            .collect::<Result<_, _>>()?;
 
-        for acir_var in output_vars {
-            self.acir_context.return_var(acir_var)?;
-        }
-
-        let generated_acir = self.acir_context.finish(witness_inputs, Vec::new());
+        let generated_acir = self.acir_context.finish(witness_inputs, return_witnesses, Vec::new());
 
         assert_eq!(
             generated_acir.opcodes().len(),
@@ -1724,12 +1718,39 @@ impl<'a> Context<'a> {
         self.define_result(dfg, instruction, AcirValue::Var(result, typ));
     }
 
+    /// Converts an SSA terminator's return values into their ACIR representations
+    fn get_num_return_witnesses(
+        &mut self,
+        terminator: &TerminatorInstruction,
+        dfg: &DataFlowGraph,
+    ) -> usize {
+        let return_values = match terminator {
+            TerminatorInstruction::Return { return_values, .. } => return_values,
+            // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions
+            _ => unreachable!("ICE: Program must have a singular return"),
+        };
+
+        return_values.iter().fold(0, |acc, value_id| {
+            let is_databus = self
+                .data_bus
+                .return_data
+                .map_or(false, |return_databus| dfg[*value_id] == dfg[return_databus]);
+
+            if is_databus {
+                // We do not return value for the data bus.
+                acc
+            } else {
+                acc + dfg.type_of_value(*value_id).flattened_size()
+            }
+        })
+    }
+
     /// Converts an SSA terminator's return values into their ACIR representations
     fn convert_ssa_return(
         &mut self,
         terminator: &TerminatorInstruction,
         dfg: &DataFlowGraph,
-    ) -> Result<Vec<SsaReport>, RuntimeError> {
+    ) -> Result<(Vec<AcirVar>, Vec<SsaReport>), RuntimeError> {
         let (return_values, call_stack) = match terminator {
             TerminatorInstruction::Return { return_values, call_stack } => {
                 (return_values, call_stack.clone())
@@ -1739,6 +1760,7 @@ impl<'a> Context<'a> {
         };
 
         let mut has_constant_return = false;
+        let mut return_vars: Vec<AcirVar> = Vec::new();
         for value_id in return_values {
             let is_databus = self
                 .data_bus
@@ -1759,7 +1781,7 @@ impl<'a> Context<'a> {
                         dfg,
                     )?;
                 } else {
-                    self.acir_context.return_var(acir_var)?;
+                    return_vars.push(acir_var);
                 }
             }
         }
@@ -1770,7 +1792,7 @@ impl<'a> Context<'a> {
             Vec::new()
         };
 
-        Ok(warnings)
+        Ok((return_vars, warnings))
     }
 
     /// Gets the cached `AcirVar` that was converted from the corresponding `ValueId`. If it does
@@ -3079,8 +3101,8 @@ mod test {
         check_call_opcode(
             &func_with_nested_call_opcodes[1],
             2,
-            vec![Witness(2), Witness(1)],
-            vec![Witness(3)],
+            vec![Witness(3), Witness(1)],
+            vec![Witness(4)],
         );
     }
 
@@ -3100,13 +3122,13 @@ mod test {
                 for (expected_input, input) in expected_inputs.iter().zip(inputs) {
                     assert_eq!(
                         expected_input, input,
-                        "Expected witness {expected_input:?} but got {input:?}"
+                        "Expected input witness {expected_input:?} but got {input:?}"
                     );
                 }
                 for (expected_output, output) in expected_outputs.iter().zip(outputs) {
                     assert_eq!(
                         expected_output, output,
-                        "Expected witness {expected_output:?} but got {output:?}"
+                        "Expected output witness {expected_output:?} but got {output:?}"
                     );
                 }
             }

From c93c7380c705fcec5c77bfc436c2f5ea085edd77 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Fri, 31 May 2024 16:44:54 +0100
Subject: [PATCH 329/416] feat!: separate proving from `noir_js` (#5072)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This removes proving/verification functionality from `noir_js` in favour
of interacting with the backend.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .../circuits/assert_lt/Nargo.toml             |  5 ++
 .../circuits/assert_lt/src/main.nr            | 10 +++
 .../circuits/fold_fibonacci/Nargo.toml        |  7 +++
 .../circuits/fold_fibonacci/src/main.nr       | 12 ++++
 compiler/integration-tests/package.json       |  2 +-
 .../scripts/codegen-verifiers.sh              |  1 +
 .../scripts/compile-programs.sh               | 12 ++++
 compiler/integration-tests/scripts/setup.sh   |  8 +++
 .../test/browser/compile_prove_verify.test.ts | 11 ++--
 .../onchain_recursive_verification.test.ts    | 10 +--
 .../test/node/prove_and_verify.test.ts        | 34 +++--------
 .../test/node/smart_contract_verifier.test.ts |  9 +--
 docs/docs/how_to/how-to-oracles.md            |  2 +-
 docs/docs/how_to/how-to-recursion.md          |  9 +--
 docs/docs/tutorials/noirjs_app.md             |  5 +-
 tooling/noir_js/src/index.ts                  |  4 +-
 tooling/noir_js/src/program.ts                | 61 +------------------
 tooling/noir_js/test/node/execute.test.ts     |  2 +-
 18 files changed, 95 insertions(+), 109 deletions(-)
 create mode 100644 compiler/integration-tests/circuits/assert_lt/Nargo.toml
 create mode 100644 compiler/integration-tests/circuits/assert_lt/src/main.nr
 create mode 100644 compiler/integration-tests/circuits/fold_fibonacci/Nargo.toml
 create mode 100644 compiler/integration-tests/circuits/fold_fibonacci/src/main.nr
 mode change 100644 => 100755 compiler/integration-tests/scripts/codegen-verifiers.sh
 create mode 100755 compiler/integration-tests/scripts/compile-programs.sh
 create mode 100755 compiler/integration-tests/scripts/setup.sh
 rename tooling/noir_js/test/node/e2e.test.ts => compiler/integration-tests/test/node/prove_and_verify.test.ts (82%)

diff --git a/compiler/integration-tests/circuits/assert_lt/Nargo.toml b/compiler/integration-tests/circuits/assert_lt/Nargo.toml
new file mode 100644
index 00000000000..f32ec18cae7
--- /dev/null
+++ b/compiler/integration-tests/circuits/assert_lt/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "assert_lt"
+type = "bin"
+authors = [""]
+[dependencies]
diff --git a/compiler/integration-tests/circuits/assert_lt/src/main.nr b/compiler/integration-tests/circuits/assert_lt/src/main.nr
new file mode 100644
index 00000000000..b8e255ca492
--- /dev/null
+++ b/compiler/integration-tests/circuits/assert_lt/src/main.nr
@@ -0,0 +1,10 @@
+use dep::std;
+
+fn main(x: u64, y: pub u64) -> pub u64 {
+    // We include a println statement to show that noirJS will ignore this and continue execution
+    std::println("foo");
+
+
+    assert(x < y);
+    x + y
+}
diff --git a/compiler/integration-tests/circuits/fold_fibonacci/Nargo.toml b/compiler/integration-tests/circuits/fold_fibonacci/Nargo.toml
new file mode 100644
index 00000000000..6d8214689b0
--- /dev/null
+++ b/compiler/integration-tests/circuits/fold_fibonacci/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fold_fibonacci"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/compiler/integration-tests/circuits/fold_fibonacci/src/main.nr b/compiler/integration-tests/circuits/fold_fibonacci/src/main.nr
new file mode 100644
index 00000000000..e150a586086
--- /dev/null
+++ b/compiler/integration-tests/circuits/fold_fibonacci/src/main.nr
@@ -0,0 +1,12 @@
+fn main(x: u32) {
+    assert(fibonacci(x) == 55);
+}
+
+#[fold]
+fn fibonacci(x: u32) -> u32 {
+    if x <= 1 {
+        x
+    } else {
+        fibonacci(x - 1) + fibonacci(x - 2)
+    }
+}
diff --git a/compiler/integration-tests/package.json b/compiler/integration-tests/package.json
index 431fe408a8b..b789f1f05ce 100644
--- a/compiler/integration-tests/package.json
+++ b/compiler/integration-tests/package.json
@@ -6,7 +6,7 @@
     "scripts": {
         "build": "echo Integration Test build step",
         "test": "yarn test:browser && yarn test:node",
-        "test:node": "bash ./scripts/codegen-verifiers.sh && hardhat test test/node/**/*",
+        "test:node": "bash ./scripts/setup.sh && hardhat test test/node/**/*",
         "test:browser": "web-test-runner",
         "test:integration:browser": "web-test-runner test/browser/**/*.test.ts",
         "test:integration:browser:watch": "web-test-runner test/browser/**/*.test.ts --watch",
diff --git a/compiler/integration-tests/scripts/codegen-verifiers.sh b/compiler/integration-tests/scripts/codegen-verifiers.sh
old mode 100644
new mode 100755
index abc26c4c465..bec59eb6889
--- a/compiler/integration-tests/scripts/codegen-verifiers.sh
+++ b/compiler/integration-tests/scripts/codegen-verifiers.sh
@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+set -e
 
 NARGO_BACKEND_PATH=${NARGO_BACKEND_PATH:-bb}
 
diff --git a/compiler/integration-tests/scripts/compile-programs.sh b/compiler/integration-tests/scripts/compile-programs.sh
new file mode 100755
index 00000000000..a7071acc401
--- /dev/null
+++ b/compiler/integration-tests/scripts/compile-programs.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -e
+
+self_path=$(dirname "$(readlink -f "$0")")
+
+package_root=$self_path/../
+
+assert_lt_dir=$package_root/circuits/assert_lt/
+nargo --program-dir $assert_lt_dir compile
+
+fold_fibonacci_dir=$package_root/circuits/fold_fibonacci/
+nargo --program-dir $fold_fibonacci_dir compile
diff --git a/compiler/integration-tests/scripts/setup.sh b/compiler/integration-tests/scripts/setup.sh
new file mode 100755
index 00000000000..37db38474c0
--- /dev/null
+++ b/compiler/integration-tests/scripts/setup.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -e
+
+self_path=$(dirname "$(readlink -f "$0")")
+
+
+$self_path/compile-programs.sh
+$self_path/codegen-verifiers.sh
\ No newline at end of file
diff --git a/compiler/integration-tests/test/browser/compile_prove_verify.test.ts b/compiler/integration-tests/test/browser/compile_prove_verify.test.ts
index dba51895bb8..f18ceb85276 100644
--- a/compiler/integration-tests/test/browser/compile_prove_verify.test.ts
+++ b/compiler/integration-tests/test/browser/compile_prove_verify.test.ts
@@ -51,19 +51,20 @@ test_cases.forEach((testInfo) => {
       throw e;
     }
 
-    const backend = new BarretenbergBackend(noir_program);
-    const program = new Noir(noir_program, backend);
-
     const prover_toml = await new Response(await getFile(`${base_relative_path}/${test_case}/Prover.toml`)).text();
     const inputs: InputMap = TOML.parse(prover_toml) as InputMap;
 
     // JS Proving
 
-    const proofWithPublicInputs = await program.generateProof(inputs);
+    const program = new Noir(noir_program);
+    const { witness } = await program.execute(inputs);
+
+    const backend = new BarretenbergBackend(noir_program);
+    const proof = await backend.generateProof(witness);
 
     // JS verification
 
-    const verified = await program.verifyProof(proofWithPublicInputs);
+    const verified = await backend.verifyProof(proof);
     expect(verified, 'Proof fails verification in JS').to.be.true;
   });
 
diff --git a/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts b/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
index ca7f19309d6..f4647c478f1 100644
--- a/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
+++ b/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
@@ -56,8 +56,7 @@ it.skip(`smart contract can verify a recursive proof`, async () => {
 
   // Final proof
 
-  const recursion_backend = new BarretenbergBackend(recursionProgram);
-  const recursion = new Noir(recursionProgram, recursion_backend);
+  const recursion = new Noir(recursionProgram);
 
   const recursion_inputs: InputMap = {
     verification_key: vkAsFields,
@@ -66,8 +65,11 @@ it.skip(`smart contract can verify a recursive proof`, async () => {
     key_hash: vkHash,
   };
 
-  const recursion_proof = await recursion.generateProof(recursion_inputs);
-  expect(await recursion.verifyProof(recursion_proof)).to.be.true;
+  const { witness: recursionWitness } = await recursion.execute(recursion_inputs);
+
+  const recursion_backend = new BarretenbergBackend(recursionProgram);
+  const recursion_proof = await recursion_backend.generateProof(recursionWitness);
+  expect(await recursion_backend.verifyProof(recursion_proof)).to.be.true;
 
   // Smart contract verification
 
diff --git a/tooling/noir_js/test/node/e2e.test.ts b/compiler/integration-tests/test/node/prove_and_verify.test.ts
similarity index 82%
rename from tooling/noir_js/test/node/e2e.test.ts
rename to compiler/integration-tests/test/node/prove_and_verify.test.ts
index dbb9abcc964..1cfe36f31e9 100644
--- a/tooling/noir_js/test/node/e2e.test.ts
+++ b/compiler/integration-tests/test/node/prove_and_verify.test.ts
@@ -1,6 +1,6 @@
 import { expect } from 'chai';
-import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
-import fold_fibonacci_json from '../noir_compiled_examples/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
+import assert_lt_json from '../../circuits/assert_lt/target/assert_lt.json' assert { type: 'json' };
+import fold_fibonacci_json from '../../circuits/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
 import { BarretenbergBackend as Backend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
 import { CompiledCircuit } from '@noir-lang/types';
@@ -30,25 +30,6 @@ it('end-to-end proof creation and verification (outer)', async () => {
   expect(isValid).to.be.true;
 });
 
-it('end-to-end proof creation and verification (outer) -- Program API', async () => {
-  // Noir.Js part
-  const inputs = {
-    x: '2',
-    y: '3',
-  };
-
-  // Initialize backend
-  const backend = new Backend(assert_lt_program);
-  // Initialize program
-  const program = new Noir(assert_lt_program, backend);
-  // Generate proof
-  const proof = await program.generateProof(inputs);
-
-  // Proof verification
-  const isValid = await program.verifyProof(proof);
-  expect(isValid).to.be.true;
-});
-
 it('end-to-end proof creation and verification (outer) -- Verifier API', async () => {
   // Noir.Js part
   const inputs = {
@@ -56,12 +37,13 @@ it('end-to-end proof creation and verification (outer) -- Verifier API', async (
     y: '3',
   };
 
-  // Initialize backend
-  const backend = new Backend(assert_lt_program);
-  // Initialize program
-  const program = new Noir(assert_lt_program, backend);
+  // Execute program
+  const program = new Noir(assert_lt_program);
+  const { witness } = await program.execute(inputs);
+
   // Generate proof
-  const proof = await program.generateProof(inputs);
+  const backend = new Backend(assert_lt_program);
+  const proof = await backend.generateProof(witness);
 
   const verificationKey = await backend.getVerificationKey();
 
diff --git a/compiler/integration-tests/test/node/smart_contract_verifier.test.ts b/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
index 79a0520da32..e109cbcab6a 100644
--- a/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
+++ b/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
@@ -38,19 +38,20 @@ test_cases.forEach((testInfo) => {
 
     const noir_program = compileResult.program;
 
-    const backend = new BarretenbergBackend(noir_program);
-    const program = new Noir(noir_program, backend);
+    const program = new Noir(noir_program);
 
     // JS Proving
 
     const prover_toml = readFileSync(resolve(`${base_relative_path}/${test_case}/Prover.toml`)).toString();
     const inputs = toml.parse(prover_toml);
+    const { witness } = await program.execute(inputs);
 
-    const proofData = await program.generateProof(inputs);
+    const backend = new BarretenbergBackend(noir_program);
+    const proofData = await backend.generateProof(witness);
 
     // JS verification
 
-    const verified = await program.verifyProof(proofData);
+    const verified = await backend.verifyProof(proofData);
     expect(verified, 'Proof fails verification in JS').to.be.true;
 
     // Smart contract verification
diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index 5f427f1e23f..2811968c634 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -194,7 +194,7 @@ For example, if your Noir program expects the host machine to provide CPU pseudo
 ```js
 const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
 
-await noir.generateProof(inputs, foreignCallHandler)
+await noir.execute(inputs, foreignCallHandler)
 ```
 
 As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
diff --git a/docs/docs/how_to/how-to-recursion.md b/docs/docs/how_to/how-to-recursion.md
index 4c45bb87ae2..aac84e29fac 100644
--- a/docs/docs/how_to/how-to-recursion.md
+++ b/docs/docs/how_to/how-to-recursion.md
@@ -70,7 +70,7 @@ You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `
 After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
 
 ```js
-const noir = new Noir(circuit, backend)
+const noir = new Noir(circuit)
 const { witness } = noir.execute(input)
 ```
 
@@ -155,8 +155,8 @@ const backends = {
   recursive: new BarretenbergBackend(circuits.recursive)
 }
 const noir_programs = {
-  main: new Noir(circuits.main, backends.main),
-  recursive: new Noir(circuits.recursive, backends.recursive)
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
 }
 ```
 
@@ -173,7 +173,8 @@ const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecurs
     proof,
     numPublicInputs,
 );
-const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
 ```
 
 :::
diff --git a/docs/docs/tutorials/noirjs_app.md b/docs/docs/tutorials/noirjs_app.md
index 3dd9fe7d2b0..cbb1938a5c6 100644
--- a/docs/docs/tutorials/noirjs_app.md
+++ b/docs/docs/tutorials/noirjs_app.md
@@ -263,7 +263,7 @@ And instantiate them inside our try-catch block:
 ```ts
 // try {
 const backend = new BarretenbergBackend(circuit);
-const noir = new Noir(circuit, backend);
+const noir = new Noir(circuit);
 // }
 ```
 
@@ -288,7 +288,8 @@ Now we're ready to prove stuff! Let's feed some inputs to our circuit and calcul
 await setup(); // let's squeeze our wasm inits here
 
 display('logs', 'Generating proof... ⌛');
-const proof = await noir.generateProof(input);
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
 display('logs', 'Generating proof... ✅');
 display('results', proof.proof);
 ```
diff --git a/tooling/noir_js/src/index.ts b/tooling/noir_js/src/index.ts
index e7f356a582e..1feca8fa275 100644
--- a/tooling/noir_js/src/index.ts
+++ b/tooling/noir_js/src/index.ts
@@ -1,6 +1,6 @@
 import * as acvm from '@noir-lang/acvm_js';
 import * as abi from '@noir-lang/noirc_abi';
-import { CompiledCircuit, ProofData } from '@noir-lang/types';
+import { CompiledCircuit } from '@noir-lang/types';
 
 export {
   ecdsa_secp256r1_verify,
@@ -22,4 +22,4 @@ export { ErrorWithPayload } from './witness_generation.js';
 export { acvm, abi };
 
 // type exports for typedoc
-export { CompiledCircuit, ProofData };
+export { CompiledCircuit };
diff --git a/tooling/noir_js/src/program.ts b/tooling/noir_js/src/program.ts
index 86aa0f60ddf..accd89dc385 100644
--- a/tooling/noir_js/src/program.ts
+++ b/tooling/noir_js/src/program.ts
@@ -1,14 +1,10 @@
-/* eslint-disable  @typescript-eslint/no-explicit-any */
-import { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
+import { CompiledCircuit } from '@noir-lang/types';
 import { generateWitness } from './witness_generation.js';
 import initAbi, { abiDecode, InputMap, InputValue } from '@noir-lang/noirc_abi';
 import initACVM, { compressWitnessStack, ForeignCallHandler } from '@noir-lang/acvm_js';
 
 export class Noir {
-  constructor(
-    private circuit: CompiledCircuit,
-    private backend?: Backend,
-  ) {}
+  constructor(private circuit: CompiledCircuit) {}
 
   /** @ignore */
   async init(): Promise<void> {
@@ -20,27 +16,6 @@ export class Noir {
     }
   }
 
-  /**
-   *
-   * @description
-   * Destroys the underlying backend instance.
-   *
-   * @example
-   * ```typescript
-   * await noir.destroy();
-   * ```
-   *
-   */
-  async destroy(): Promise<void> {
-    await this.backend?.destroy();
-  }
-
-  private getBackend(): Backend {
-    if (this.backend === undefined) throw new Error('Operation requires a backend but none was provided');
-    return this.backend;
-  }
-
-  // Initial inputs to your program
   /**
    * @description
    * Allows to execute a circuit to get its witness and return value.
@@ -60,36 +35,4 @@ export class Noir {
     const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);
     return { witness: compressWitnessStack(witness_stack), returnValue };
   }
-
-  /**
-   *
-   * @description
-   * Generates a witness and a proof given an object as input.
-   *
-   * @example
-   * ```typescript
-   * async generateProof(input)
-   * ```
-   *
-   */
-  async generateProof(inputs: InputMap, foreignCallHandler?: ForeignCallHandler): Promise<ProofData> {
-    const { witness } = await this.execute(inputs, foreignCallHandler);
-    return this.getBackend().generateProof(witness);
-  }
-
-  /**
-   *
-   * @description
-   * Instantiates the verification key and verifies a proof.
-   *
-   *
-   * @example
-   * ```typescript
-   * async verifyProof(proof)
-   * ```
-   *
-   */
-  async verifyProof(proofData: ProofData): Promise<boolean> {
-    return this.getBackend().verifyProof(proofData);
-  }
 }
diff --git a/tooling/noir_js/test/node/execute.test.ts b/tooling/noir_js/test/node/execute.test.ts
index d047e35035f..7c93a911042 100644
--- a/tooling/noir_js/test/node/execute.test.ts
+++ b/tooling/noir_js/test/node/execute.test.ts
@@ -11,7 +11,7 @@ const assert_lt_program = assert_lt_json as CompiledCircuit;
 const assert_msg_runtime = assert_msg_json as CompiledCircuit;
 const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
-it('returns the return value of the circuit', async () => {
+it('executes a single-ACIR program correctly', async () => {
   const inputs = {
     x: '2',
     y: '3',

From 2f573ecf195e7689b12f3275d1fdb034707d3604 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Tue, 4 Jun 2024 06:59:48 -0400
Subject: [PATCH 330/416] chore: move acir docs to code declaration (#5040)

# Description

## Problem\*

Resolves a few minor inaccuracies in the ACIR docs and moves their
primary location to Rust.

## Summary\*

ACIR docs get stale quickly when detached from code/tests. This PR moves
them to the code for now; we expect to move them back once ACIR is more
stable.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 acvm-repo/acir/README.md                      | 335 +++++++++++-------
 .../acir/src/circuit/black_box_functions.rs   | 197 +++++++++-
 acvm-repo/acir/src/circuit/opcodes.rs         |  76 +++-
 .../src/circuit/opcodes/memory_operation.rs   |   5 +-
 cspell.json                                   |   1 +
 5 files changed, 459 insertions(+), 155 deletions(-)

diff --git a/acvm-repo/acir/README.md b/acvm-repo/acir/README.md
index f7fccad0799..902769e3ad7 100644
--- a/acvm-repo/acir/README.md
+++ b/acvm-repo/acir/README.md
@@ -1,214 +1,291 @@
 # ACIR documentation (draft)
 
 ## Abstract
-This document describes the purpose of ACIR, what it is and how ACIR programs can be used by compilers and proving systems. It is intended to be a reference documentation for ACIR.
+
+This document describes the purpose of ACIR, what it is and how ACIR programs
+can be used by compilers and proving systems. It is intended to be a reference
+documentation for ACIR.
 
 ## Introduction
-The purpose of ACIR is to make the link between a generic proving system, such as Aztec's Barretenberg, and a frontend, such as Noir, which describes user-specific computations.
 
-More precisely, Noir is a programming language for zero-knowledge proofs (ZKP) which allows users to write programs in an intuitive way using a high-level language close to Rust syntax. Noir is able to generate a proof of execution of a Noir program, using an external proving system. However, proving systems use specific low-level constrain-based languages. Similarly, frontends have their own internal representation in order to represent user programs.
+The purpose of ACIR is to make the link between a generic proving system, such
+as Aztec's Barretenberg, and a frontend, such as Noir, which describes user
+specific computations.
+
+More precisely, Noir is a programming language for zero-knowledge proofs (ZKP)
+which allows users to write programs in an intuitive way using a high-level
+language close to Rust syntax. Noir is able to generate a proof of execution of
+a Noir program, using an external proving system. However, proving systems use
+specific low-level constrain-based languages. Similarly, frontends have their
+own internal representation in order to represent user programs.
 
-The goal of ACIR is to provide a generic open-source intermediate representation close to proving system 'languages', but agnostic to a specific proving system, that can be used both by proving system as well as a target for frontends. So, at the end of the day, an ACIR program is just another representation of a program, dedicated to proving systems.
+The goal of ACIR is to provide a generic open-source intermediate
+representation close to proving system 'languages', but agnostic to a specific
+proving system, that can be used both by proving system as well as a target for
+frontends. So, at the end of the day, an ACIR program is just another
+representation of a program, dedicated to proving systems.
 
 ## Abstract Circuit Intermediate Representation
 ACIR stands for abstract circuit intermediate representation:
-- **abstract circuit**: circuits are a simple computation model where basic computation units, named gates, are connected with wires. Data flows through the wires while gates compute output wires based on their input. More formally, they are directed acyclic graphs (DAG) where the vertices are the gates and the edges are the wires. Due to the immutability nature of the wires (their value does not change during an execution), they are well suited for describing computations for ZKPs. Furthermore, we do not lose any expressiveness when using a circuit as it is well known that any bounded computation can be translated into an arithmetic circuit (i.e a circuit with only addition and multiplication gates).
-The term abstract here simply means that we do not refer to an actual physical circuit (such as an electronic circuit). Furthermore, we will not exactly use the circuit model, but another model even better suited to ZKPs, the constraint model (see below).
-- **intermediate representation**: The ACIR representation is intermediate because it lies between a frontend and its proving system. ACIR bytecode makes the link between noir compiler output and the proving system backend input.
+- **abstract circuit**: circuits are a simple computation model where basic
+    computation units, named gates, are connected with wires. Data flows
+    through the wires while gates compute output wires based on their input.
+    More formally, they are directed acyclic graphs (DAG) where the vertices
+    are the gates and the edges are the wires. Due to the immutability nature
+    of the wires (their value does not change during an execution), they are
+    well suited for describing computations for ZKPs. Furthermore, we do not
+    lose any expressiveness when using a circuit as it is well known that any
+    bounded computation can be translated into an arithmetic circuit (i.e a
+    circuit with only addition and multiplication gates).
+The term abstract here simply means that we do not refer to an actual physical
+circuit (such as an electronic circuit). Furthermore, we will not exactly use
+the circuit model, but another model even better suited to ZKPs, the constraint
+model (see below).
+- **intermediate representation**: The ACIR representation is intermediate
+because it lies between a frontend and its proving system. ACIR bytecode makes
+the link between noir compiler output and the proving system backend input.
 
 ## The constraint model
-The first step for generating a proof that a specific program was executed, is to execute this program. Since the proving system is going to handle ACIR programs, we need in fact to execute an ACIR program, using the user-supplied inputs.
 
-In ACIR terminology, the gates are called opcodes and the wires are called partial witnesses. However, instead of connecting the opcodes together through wires, we create constraints: an opcode constraints together a set of wires.
-This constraint model trivially supersedes the circuit model. For instance, an addition gate output_wire = input_wire_1 + input_wire_2 can be expressed with the following arithmetic constraint: output_wire - (input_wire_1 + input_wire_2) = 0
+The first step for generating a proof that a specific program was executed, is
+to execute this program. Since the proving system is going to handle ACIR
+programs, we need in fact to execute an ACIR program, using the user-supplied
+inputs.
 
+In ACIR terminology, the gates are called opcodes and the wires are called
+partial witnesses. However, instead of connecting the opcodes together through
+wires, we create constraints: an opcode constraints together a set of wires.
+This constraint model trivially supersedes the circuit model. For instance, an
+addition gate `output_wire = input_wire_1 + input_wire_2` can be expressed with
+the following arithmetic constraint:
+`output_wire - (input_wire_1 + input_wire_2) = 0`
 
 
 ## Solving
-Because of these constraints, executing an ACIR program is called solving the witnesses. From the witnesses representing the inputs of the program, whose values are supplied by the user, we find out what the other witnesses should be by executing/solving the constraints one-by-one in the order they were defined.
 
-For instance, if input_wire_1 and input_wire_2 values are supplied as 3 and 8, then we can solve the opcode output_wire - (input_wire_1 + input_wire_2) = 0 by saying that output_wire is 11.
+Because of these constraints, executing an ACIR program is called solving the
+witnesses. From the witnesses representing the inputs of the program, whose
+values are supplied by the user, we find out what the other witnesses should be
+by executing/solving the constraints one-by-one in the order they were defined.
+
+For instance, if `input_wire_1` and `input_wire_2` values are supplied as `3` and
+`8`, then we can solve the opcode
+`output_wire - (input_wire_1 + input_wire_2) = 0` by saying that `output_wire` is
+`11`.
 
 In summary, the workflow is the following:
-1. user program -> (compilation) ACIR, a list of opcodes which constrain (partial) witnesses
-2. user inputs + ACIR -> (execution/solving) assign values to all the (partial) witnesses 
+1. user program -> (compilation) ACIR, a list of opcodes which constrain
+    (partial) witnesses
+2. user inputs + ACIR -> (execution/solving) assign values to all the
+    (partial) witnesses 
 3. witness assignment + ACIR -> (proving system) proof
 
+Although the ordering of opcode does not matter in theory, since a system of
+equations is not dependent on its ordering, in practice it matters a lot for the
+solving (i.e the performance of the execution). ACIR opcodes **must be ordered**
+so that each opcode can be resolved one after the other.
 
-Although the ordering of opcode does not matter in theory, since a system of equations is not dependent on its ordering, in practice it matters a lot for the solving (i.e the performance of the execution). ACIR opcodes **must be ordered** so that each opcode can be resolved one after the other.
+The values of the witnesses lie in the scalar field of the proving system. We
+will refer to it as `FieldElement` or ACIR field. The proving system needs the
+values of all the partial witnesses and all the constraints in order to generate
+a proof.
 
+*Remark*: The value of a partial witness is unique and fixed throughout a program
+    execution, although in some rare cases, multiple values are possible for a
+    same execution and witness (when there are several valid solutions to the
+    constraints). Having multiple possible values for a witness may indicate that
+    the circuit is not safe.
 
-The values of the witnesses lie in the scalar field of the proving system. We will refer to it as FieldElement or ACIR field. The proving system needs the values of all the partial witnesses and all the constraints in order to generate a proof.
+*Remark*: Why do we use the term partial witnesses? It is because the proving
+    system may create other constraints and witnesses (especially with
+    `BlackBoxFuncCall`, see below). A proof refers to a full witness assignments
+    and their constraints. ACIR opcodes and their partial witnesses are still an
+    intermediate representation before getting the full list of constraints and
+    witnesses. For the sake of simplicity, we will refer to witness instead of
+    partial witness from now on.
 
 
-*Remark*: The value of a partial witness is unique and fixed throughout a program execution, although in some rare cases, multiple values are possible for a same execution and witness (when there are several valid solutions to the constraints). Having multiple possible values for a witness may indicate that the circuit is not safe.
+## ACIR Reference
 
-*Remark*: Why do we use the term partial witnesses? It is because the proving system may create other constraints and witnesses (especially with BlackBoxFuncCall, see below). A proof refers to a full witness assignments and their constraints. ACIR opcodes and their partial witnesses are still an intermediate representation before getting the full list of constraints and witnesses. For the sake of simplicity, we will refer to witness instead of partial witness from now on.
+We assume here that the proving system is Barretenberg. Some parameters may
+slightly change with another proving system, in particular the bit size of
+`FieldElement`, which is 254 for Barretenberg.
 
+Some opcodes have inputs and outputs, which means that the output is constrained
+to be the result of the opcode computation from the inputs. The solver expects
+that all inputs are known when solving such opcodes.
 
-## ACIR Reference
-We assume here that the proving system is Barretenberg. Some parameters may slightly change with another proving system, in particular the bit size of FieldElement, which is 254 for Barretenberg.
+Some opcodes are not constrained, which means they will not be used by the
+proving system and are only used by the solver.
 
-Some opcodes have inputs and outputs, which means that the output is constrained to be the result of the opcode computation from the inputs. The solver expects that all inputs are known when solving such opcodes.
+Finally, some opcodes will have a predicate, whose value is `0` or `1`. Its
+purpose is to nullify the opcode when the value is `0`, so that it has no
+effect. Note that removing the opcode is not a solution because this modifies
+the circuit (the circuit being mainly the list of the opcodes). 
 
-Some opcodes are not constrained, which means they will not be used by the proving system and are only used by the solver.
+*Remark*: Opcodes operate on witnesses, but we will see that some opcode work on
+    expressions of witnesses. We call an expression a linear combination of
+    witnesses and/or products of two witnesses (and also a constant term). A
+    single witness is a (simple) expression, and conversely, an expression can
+    be turned into a single witness using an assert-zero opcode (see below). So
+    basically, using witnesses or expressions is equivalent, but the latter can
+    avoid the creation of witness in some cases.
 
-Finally, some opcodes will have a predicate, whose value is 0 or 1. Its purpose is to nullify the opcode when the value is 0, so that it has no effect. Note that removing the opcode is not a solution because this modifies the circuit (the circuit being mainly the list of the opcodes). 
+### AssertZero opcode
 
-*Remark*: Opcodes operate on witnesses, but we will see that some opcode work on expressions of witnesses. We call an expression a linear combination of witnesses and/or products of two witnesses (and also a constant term). A single witness is a (simple) expression, and conversely, an expression can be turned into a single witness using an assert-zero opcode (see below). So basically, using witnesses or expressions is equivalent, but the latter can avoid the creation of witness in some cases.
+An `AssertZero` opcode adds the constraint that `P(w) = 0`, where
+`w=(w_1,..w_n)` is a tuple of `n` witnesses, and `P` is a multi-variate
+polynomial of total degree at most `2`.
 
-### AssertZero opcode
-An AssertZero opcode adds the constraint that P(w) = 0, where w=(w_1,..w_n) is a tuple of n witnesses, and P is a multi-variate polynomial of total degree at most 2.
-The coefficients ${q_M}_{i,j}, q_i,q_c$ of the polynomial are known values which define the opcode.
-A general expression of assert-zero opcode is the following: $\sum_{i,j} {q_M}_{i,j}w_iw_j + \sum_i q_iw_i +q_c = 0$
+### BlackBoxFuncCall opcode
 
-An assert-zero opcode can be used to:
-- **express a constraint** on witnesses; for instance to express that a witness $w$ is a boolean, you can add the opcode:  $w*w-w=0$
-- or, to **compute the value** of an arithmetic operation of some inputs. For instance, to multiply two witnesses $x$ and $y$, you would use the opcode $z-x*y=0$, which would constraint $z$ to be $x*y$.
+These opcodes represent a specific computation. Even if any computation can be
+done using only assert-zero opcodes, it is not always efficient. Some proving
+systems, and in particular the proving system from Aztec, can implement several
+computations more efficiently using for instance look-up tables. The
+`BlackBoxFuncCall` opcode is used to ask the proving system to handle the
+computation by itself.
 
+All black box functions take as input a tuple `(witness, num_bits)`, where
+`num_bits` is a constant representing the bit size of the input witness, and they
+have one or several witnesses as output.
 
-The solver expects that at most one witness is not known when executing the opcode.
+Some more advanced computations assume that the proving system has an
+"embedded curve". It is a curve that cycles with the main curve of the proving
+system, i.e the scalar field of the embedded curve is the base field of the main
+one, and vice-versa. The curves used by the proving system are dependent on the
+proving system (and/or its configuration). Aztec's Barretenberg uses BN254 as the
+main curve and Grumpkin as the embedded curve.
 
-### BlackBoxFuncCall opcode
-These opcodes represent a specific computation. Even if any computation can be done using only assert-zero opcodes, it is not always efficient. Some proving systems, and in particular the proving system from Aztec, can implement several computations more efficiently using for instance look-up tables. The BlackBoxFuncCall opcode is used to ask the proving system to handle the computation by itself.
-All black box functions take as input a tuple (witness, num_bits), where num_bits is a constant representing the bit size of the input witness, and they have one or several witnesses as output.
-Some more advanced computations assume that the proving system has an 'embedded curve'. It is a curve that cycle with the main curve of the proving system, i.e the scalar field of the embedded curve is the base field of the main one, and vice-versa. The curves used by the proving system are dependent on the proving system (and/or its configuration). Aztec's Barretenberg uses BN254 as the main curve and Grumpkin as the embedded curve.
+NOTE: see the [black_box_functions](src/circuit/black_box_functions.rs) file for
+the most up-to-date documentation on these opcodes.
 
 The black box functions supported by ACIR are:
 
 **AES128Encrypt**: ciphers the provided plaintext using AES128 in CBC mode, padding the input using PKCS#7.
-- inputs: byte array [u8; N]
-- iv: initialization vector [u8; 16]
-- key: user key [u8; 16]
-- outputs: byte vector [u8] of length `input.len() + (16 - input.len() % 16)``
 
-**AND**: performs the bitwise AND of lhs and rhs. bit_size must be the same for both inputs.
-- lhs: (witness, bit_size)
-- rhs: (witness, bit_size)
-- output: a witness whose value is constrained to be lhs AND rhs, as bit_size bit integers
+**AND**: performs the bitwise AND of `lhs` and `rhs`. `bit_size` must be the same for both inputs.
 
-**XOR**: performs the bitwise XOR of lhs and rhs. bit_size must be the same for both inputs.
-- lhs: (witness, bit_size)
-- rhs: (witness, bit_size)
-- output: a witness whose value is constrained to be lhs XOR rhs, as bit_size bit integers
+**XOR**: performs the bitwise XOR of `lhs` and `rhs`. `bit_size` must be the same for both inputs.
 
 **RANGE**: constraint the input to be of the provided bit size
-input: (witness, bit_size)
 
 **SHA256**: computes sha256 of the inputs
-- inputs are a byte array, i.e a vector of (FieldElement, 8)
-- output is a byte array of len 32, i.e a vector of 32 (FieldElement, 8), constrained to be the sha256 of the inputs.
 
 **Blake2s**: computes the Blake2s hash of the inputs, as specified in https://tools.ietf.org/html/rfc7693
-- inputs are a byte array, i.e a vector of (FieldElement, 8)
-- output is a byte array of length 32, i.e a vector of 32 (FieldElement, 8), constrained to be the blake2s of the inputs.
 
+**Blake3**: computes the Blake3 hash of the inputs
 
 **SchnorrVerify**: Verify a Schnorr signature over the embedded curve
-- inputs are:
-    - Public key as 2 (FieldElement, 254)
-    - signature as a vector of 64 bytes (FieldElement, 8)
-    - message as a vector of (FieldElement, 8)
-- output: A witness representing the result of the signature verification; 0 for failure and 1 for success.
-
-Since the scalar field of the embedded curve is NOT the ACIR field, the (r,s) signature is represented as a 64 bytes array for the two field elements. On the other hand, the public key coordinates are ACIR fields.
-The proving system decides how the message is to be hashed. Barretenberg uses Blake2s.
-
 
 **PedersenCommitment**: Computes a Pedersen commitments of the inputs using generators of the embedded curve
-- input: vector of (FieldElement, 254)
-- output: 2 witnesses representing the x,y coordinates of the resulting Grumpkin point
-- domain separator: a constant public value (a field element) that you can use so that the commitment also depends on the domain separator. Noir uses 0 as domain separator.
-
-The backend should handle proper conversion between the inputs being ACIR field elements and the scalar field of the embedded curve. In the case of Aztec's Barretenberg, the latter is bigger than the ACIR field so it is straightforward. The Pedersen generators are managed by the proving system.
-
 
 **PedersenHash**: Computes a Pedersen commitments of the inputs and their number, using generators of the embedded curve
-- input: vector of (FieldElement, 254)
-- output: the x-coordinate of the pedersen commitment of the 'prepended input' (see below)
-- domain separator: a constant public value (a field element) that you can use so that the hash also depends on the domain separator. Noir uses 0 as domain separator.
 
-In Barretenberg, PedersenHash is doing the same as PedersenCommitment, except that it prepends the inputs with their length.
+**EcdsaSecp256k1**: Verify an ECDSA signature over Secp256k1
 
+**EcdsaSecp256r1**: Same as EcdsaSecp256k1, but done over another curve.
 
-**HashToField128Security**: This opcode is deprecated and will be removed.
+**MultiScalarMul**: scalar multiplication with a variable base/input point (`P`) of the embedded curve
 
-**EcdsaSecp256k1**: Verify an ECDSA signature over Secp256k1
-- inputs:
-    - x coordinate of public key as 32 bytes
-    - y coordinate of public key as 32 bytes
-    - the signature, as a 64 bytes array
-    - the hash of the message, as a vector of bytes
-- output: 0 for failure and 1 for success
+**Keccak256**: Computes the Keccak-256 (Ethereum version) of the inputs.
 
-Inputs and outputs are similar to SchnorrVerify, except that because we use a different curve (secp256k1), the field elements involved in the signature and the public key are defined as an array of 32 bytes. Another difference is that we assume the message is already hashed.
+**Keccakf1600**: Keccak Permutation function of width 1600
 
-**EcdsaSecp256r1**: Same as EcdsaSecp256k1, but done over another curve.
+**EmbeddedCurveAdd**: Embedded curve addition
 
-**MultiScalarMul**: scalar multiplication with a variable base/input point (P) of the embedded curve
-- input:
-    points (FieldElement, N) a vector of x and y coordinates of input points [x1, y1, x2, y2,...].
-    scalars (FieldElement, N) a vector of low and high limbs of input scalars [s1_low, s1_high, s2_low, s2_high, ...]. (FieldElement, N) For Barretenberg, they must both be less than 128 bits.
-- output: (FieldElement, N) a vector of x and y coordinates of output points [op1_x, op1_y, op2_x, op2_y, ...]. Points computed as $s_low*P+s_high*2^{128}*P$
+**BigIntAdd**: BigInt addition
 
-Because the Grumpkin scalar field is bigger than the ACIR field, we provide 2 ACIR fields representing the low and high parts of the Grumpkin scalar $a$:
-$a=low+high*2^{128},$ with $low, high < 2^{128}$
+**BigIntSub**: BigInt subtraction
 
-**Keccak256**: Computes the Keccak-256 (Ethereum version) of the inputs.
-- inputs: Vector of bytes (FieldElement, 8)
-- outputs: Vector of 32 bytes (FieldElement, 8)
+**BigIntMul**: BigInt multiplication
+
+**BigIntDiv**: BigInt division
 
+**BigIntFromLeBytes**: BigInt from le bytes
 
-**Keccak256VariableLength**: Computes the Keccak-256 (Ethereum version) of the inputs, restricted to the given length.
-- inputs: Vector of bytes (FieldElement, 8)
-- var_message_size: number of inputs to hash; it must be less (or equal) than the inputs length
-- outputs: a vector of 32 bytes (FieldElement, 8)
+**BigIntToLeBytes**: BigInt to le bytes
 
+**Poseidon2Permutation**: Permutation function of Poseidon2
 
+**Sha256Compression**: SHA256 compression function
 
 **RecursiveAggregation**: verify a proof inside the circuit.
 **Warning: this opcode is subject to change.**
-- verification_key: Vector of (FieldElement, 254) representing the verification key of the circuit being verified
-- public_inputs: Vector of (FieldElement, 254)  representing the public inputs corresponding to the proof being verified
-- key_hash: one (FieldElement, 254). It should be the hash of the verification key. Barretenberg expects the Pedersen hash of the verification key
-- input_aggregation_object: an optional vector of (FieldElement, 254). It is a blob of data specific to the proving system.
-- output_aggregation_object: Some witnesses returned by the function, representing some data internal to the proving system.
 
-This black box function does not fully verify a proof, what it does is verifying that the key_hash is indeed a hash of verification_key, allowing the user to use the verification key as private inputs and only have the key_hash as public input, which is more performant.
-Another thing that it does is preparing the verification of the proof. In order to fully verify a proof, some operations may still be required to be done by the final verifier. This is why this black box function does not say if verification is passing or not.
-If you have several proofs to verify in one ACIR program, you would call RecursiveAggregation() multiple times and passing the output_aggregation_object as input_aggregation_object to the next RecursiveAggregation() call, except for the first call where you do not have any input_aggregation_object.
-If one of the proof you verify with the black box function does not verify, then the verification of the proof of the main ACIR program will ultimately fail.
+This black box function does not fully verify a proof, what it does is verify
+that the provided `key_hash` is indeed a hash of `verification_key`, allowing
+the user to use the verification key as private inputs and only have the
+`key_hash` as public input, which is more performant.
 
+Another thing that it does is preparing the verification of the proof. In order
+to fully verify a proof, some operations may still be required to be done by the
+final verifier. This is why this black box function does not say if verification
+is passing or not.
 
-### Brillig
-This opcode is used as a hint for the solver when executing (solving) the circuit. The opcode does not generate any constraint and is usually the result of the compilation of an unconstrained noir function.
-- inputs: inputs to the opcode, as 'arithmetic expressions'.
-- outputs: opcode outputs, as witnesses
-- bytecode: assembly code representing the computation to perform within this opcode. The noir assembly specification is not part of this document.
-- predicate: an arithmetic expression that disable the opcode when it is null.
+If you have several proofs to verify in one ACIR program, you would call
+`RecursiveAggregation()` multiple times while passing the
+`output_aggregation_object` as `input_aggregation_object` to the next
+`RecursiveAggregation()` call, except for the first call where you do not have
+any `input_aggregation_object`.
 
-Let's see an example with euclidean division.
-The normal way to compute a/b, where a and b are 8-bits integers, is to implement Euclid algorithm which computes in a loop (or recursively) modulus of the kind 'a mod b'. Doing this computation requires a lot of steps to be properly implemented in ACIR, especially the loop with a condition. However, euclidean division can be easily constrained with one assert-zero opcode: a = bq+r, assuming q is 8 bits and r<b. Since these assumptions can easily written with a few range opcodes, euclidean division can in fact be implemented with a small number of opcodes.
+If one of the proof you verify with the black box function does not verify, then
+the verification of the proof of the main ACIR program will ultimately fail.
 
-However, in order to write these opcodes we need the result of the division which are the witness q and r. But from the constraint a=bq+r, how can the solver figure out how to solve q and r with only one equation? This is where brillig/unconstrained function come into action. We simply define a function that performs the usual Euclid algorithm to compute q and r from a and b. Since Brillig opcode does not generate constraint, it won't be provided to the proving system but simply used by the solver to compute the values of q and r.
 
-In summary, solving a Brillig opcode performs the computation defined by its bytecode, on the provided inputs, and assign the result to the outputs witnesses, without adding any constraint.
+### Brillig
 
-### Directive
-This opcode is a specialization of Brillig opcode. Instead of having some generic assembly code like Brillig, a directive has a hardcoded name which tells the solver which computation to do: with Brillig, the computation refers to the compiled bytecode of an unconstrained Noir function, but with a directive, the computation is hardcoded inside the compiler. Directives will be replaced by Brillig opcodes in the future.
+This opcode is used as a hint for the solver when executing (solving) the
+circuit. The opcode does not generate any constraint and is usually the result
+of the compilation of an unconstrained noir function.
 
-### MemoryOp: memory abstraction for ACIR
-ACIR is able to address any array of witnesses. Each array is assigned an id (BlockId) and needs to be initialized with the MemoryInit opcode. Then it is possible to read and write from/to an array by providing the index and the value we read/write, as arithmetic expression. Note that ACIR arrays all have a known fixed length (given in the MemoryInit opcode below)
-- block_id: identifier of the array
-- op: describe the memory operation to perform
-	- operation: constant expression having value 1 for a write to memory and 0 for a read
-	- index: array index, it must be less than the array length
-	- value: the value we are reading, when operation is 0, or the value we write at the specified index, when operation is 1
-- predicate: an arithmetic expression that disable the opcode when it is null.
+Let's see an example with euclidean division.
+The normal way to compute `a/b`, where `a` and `b` are 8-bits integers, is to
+implement the Euclidean algorithm which computes in a loop (or recursively)
+modulus of the kind 'a mod b'. Doing this computation requires a lot of steps to
+be properly implemented in ACIR, especially the loop with a condition. However,
+euclidean division can be easily constrained with one assert-zero opcode:
+`a = bq+r`, assuming `q` is 8 bits and `r<b`. Since these assumptions can easily
+written with a few range opcodes, euclidean division can in fact be implemented
+with a small number of opcodes.
+
+However, in order to write these opcodes we need the result of the division
+which are the witness `q` and `r`. But from the constraint `a=bq+r`, how can the
+solver figure out how to solve `q` and `r` with only one equation? This is where
+brillig/unconstrained function come into action. We simply define a function that
+performs the usual Euclid algorithm to compute `q` and `r` from `a` and `b`.
+Since Brillig opcode does not generate constraint, it won't be provided to the
+proving system but simply used by the solver to compute the values of `q` and
+`r`.
+
+In summary, solving a Brillig opcode performs the computation defined by its
+bytecode, on the provided inputs, and assign the result to the outputs witnesses,
+without adding any constraint.
+
+NOTE: see the [circuit/opcodes.rs](src/circuit/opcodes.rs) file for the most
+up-to-date documentation on these opcodes.
+
+#### Directive
+
+This opcode is a specialization of Brillig opcode. Instead of having some generic
+assembly code like Brillig, a directive has a hardcoded name which tells the
+solver which computation to do: with Brillig, the computation refers to the
+compiled bytecode of an unconstrained Noir function, but with a directive, the
+computation is hardcoded inside the compiler.
+
+Directives will be replaced by Brillig opcodes in the future.
+
+#### MemoryOp: memory abstraction for ACIR
+
+ACIR is able to address any array of witnesses. Each array is assigned an ID
+(`BlockId`) and needs to be initialized with the `MemoryInit` opcode. Then it is
+possible to read and write from/to an array by providing the index and the value
+we read/write, as arithmetic expression. Note that ACIR arrays all have a known
+fixed length (given in the `MemoryInit` opcode below).
+
+#### MemoryInit
 
-### MemoryInit
 Initialize an ACIR array from a vector of witnesses.
-- block_id: identifier of the array
-- init: Vector of witnesses specifying the initial value of the arrays
 
-There must be only one MemoryInit per block_id, and MemoryOp opcodes must come after the MemoryInit.
+There must be only one MemoryInit per block_id, and MemoryOp opcodes must
+come after the MemoryInit.
diff --git a/acvm-repo/acir/src/circuit/black_box_functions.rs b/acvm-repo/acir/src/circuit/black_box_functions.rs
index 33c14436c85..419c0266b69 100644
--- a/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -1,5 +1,7 @@
-//! Black box functions are ACIR opcodes which rely on backends implementing support for specialized constraints.
-//! This makes certain zk-snark unfriendly computations cheaper than if they were implemented in more basic constraints.
+//! Black box functions are ACIR opcodes which rely on backends implementing
+//! support for specialized constraints.
+//! This makes certain zk-snark unfriendly computations cheaper than if they were
+//! implemented in more basic constraints.
 
 use serde::{Deserialize, Serialize};
 #[cfg(test)]
@@ -9,61 +11,220 @@ use strum_macros::EnumIter;
 #[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[cfg_attr(test, derive(EnumIter))]
 pub enum BlackBoxFunc {
-    /// Encrypts the input using AES128.
+    /// Ciphers (encrypts) the provided plaintext using AES128 in CBC mode,
+    /// padding the input using PKCS#7.
+    /// - inputs: byte array `[u8; N]`
+    /// - iv: initialization vector `[u8; 16]`
+    /// - key: user key `[u8; 16]`
+    /// - outputs: byte vector `[u8]` of length `input.len() + (16 - input.len() % 16)`
     AES128Encrypt,
-    /// Bitwise AND.
+
+    /// Performs the bitwise AND of `lhs` and `rhs`. `bit_size` must be the same for
+    /// both inputs.
+    /// - lhs: (witness, bit_size)
+    /// - rhs: (witness, bit_size)
+    /// - output: a witness whose value is constrained to be lhs AND rhs, as
+    ///   bit_size bit integers
     AND,
-    /// Bitwise XOR.
+
+    /// Performs the bitwise XOR of `lhs` and `rhs`. `bit_size` must be the same for
+    /// both inputs.
+    /// - lhs: (witness, bit_size)
+    /// - rhs: (witness, bit_size)
+    /// - output: a witness whose value is constrained to be lhs XOR rhs, as
+    ///   bit_size bit integers
     XOR,
-    /// Range constraint to ensure that a [`FieldElement`][acir_field::FieldElement] can be represented in a specified number of bits.
+
+    /// Range constraint to ensure that a witness
+    /// can be represented in the specified number of bits.
+    /// - input: (witness, bit_size)
     RANGE,
-    /// Calculates the SHA256 hash of the inputs.
+
+    /// Computes SHA256 of the inputs
+    /// - inputs are a byte array, i.e a vector of (witness, 8)
+    /// - output is a byte array of len 32, i.e an array of 32 (witness, 8),
+    ///   constrained to be the sha256 of the inputs.
     SHA256,
-    /// Calculates the Blake2s hash of the inputs.
+
+    /// Computes the Blake2s hash of the inputs, as specified in
+    /// https://tools.ietf.org/html/rfc7693
+    /// - inputs are a byte array, i.e a vector of (witness, 8)
+    /// - output is a byte array of length 32, i.e. an array of 32
+    /// (witness, 8), constrained to be the blake2s of the inputs.
     Blake2s,
-    /// Calculates the Blake3 hash of the inputs.
+
+    /// Computes the Blake3 hash of the inputs
+    /// - inputs are a byte array, i.e a vector of (witness, 8)
+    /// - output is a byte array of length 32, i.e an array of 32
+    /// (witness, 8), constrained to be the blake3 of the inputs.
     Blake3,
-    /// Verifies a Schnorr signature over a curve which is "pairing friendly" with the curve on which the ACIR circuit is defined.
+
+    /// Verify a Schnorr signature over the embedded curve
+    /// - inputs are:
+    ///     - Public key as 2 (witness, 254)
+    ///     - signature as a vector of 64 bytes (witness, 8)
+    ///     - message as a vector of (witness, 8)
+    /// - output: A witness representing the result of the signature
+    /// verification; 0 for failure and 1 for success.
+    ///
+    /// Since the scalar field of the embedded curve is NOT the ACIR field, the
+    /// `(r,s)` signature is represented as a 64 bytes array for the two field
+    /// elements. On the other hand, the public key coordinates are ACIR fields.
+    /// The proving system decides how the message is to be hashed. Barretenberg
+    /// uses Blake2s.
     ///
-    /// The exact curve which this signature uses will vary based on the curve being used by ACIR.
-    /// For example, the BN254 curve supports Schnorr signatures over the [Grumpkin][grumpkin] curve.
+    /// Verifies a Schnorr signature over a curve which is "pairing friendly"
+    /// with the curve on which the ACIR circuit is defined.
+    ///
+    /// The exact curve which this signature uses will vary based on the curve
+    /// being used by ACIR. For example, the BN254 curve supports Schnorr
+    /// signatures over the [Grumpkin][grumpkin] curve.
     ///
     /// [grumpkin]: https://hackmd.io/@aztec-network/ByzgNxBfd#2-Grumpkin---A-curve-on-top-of-BN-254-for-SNARK-efficient-group-operations
     SchnorrVerify,
+
     /// Calculates a Pedersen commitment to the inputs.
+    ///
+    /// Computes a Pedersen commitment of the inputs using generators of the
+    /// embedded curve
+    /// - input: vector of (witness, 254)
+    /// - output: 2 witnesses representing the x,y coordinates of the resulting
+    ///   Grumpkin point
+    /// - domain separator: a constant public value (a field element) that you
+    ///   can use so that the commitment also depends on the domain separator.
+    ///   Noir uses 0 as domain separator.
+    ///
+    /// The backend should handle proper conversion between the inputs being ACIR
+    /// field elements and the scalar field of the embedded curve. In the case of
+    /// Aztec's Barretenberg, the latter is bigger than the ACIR field so it is
+    /// straightforward. The Pedersen generators are managed by the proving
+    /// system.
+    ///
+    /// The commitment is expected to be additively homomorphic
     PedersenCommitment,
+
     /// Calculates a Pedersen hash to the inputs.
+    ///
+    /// Computes a Pedersen hash of the inputs and their number, using
+    /// generators of the embedded curve
+    /// - input: vector of (witness, 254)
+    /// - output: the x-coordinate of the pedersen commitment of the
+    ///   'prepended input' (see below)
+    /// - domain separator: a constant public value (a field element) that you
+    ///   can use so that the hash also depends on the domain separator. Noir
+    ///   uses 0 as domain separator.
+    ///
+    /// In Barretenberg, PedersenHash is doing the same as PedersenCommitment,
+    /// except that it prepends the inputs with their length. This is expected
+    /// to not be additively homomorphic.
     PedersenHash,
+
     /// Verifies a ECDSA signature over the secp256k1 curve.
+    /// - inputs:
+    ///     - x coordinate of public key as 32 bytes
+    ///     - y coordinate of public key as 32 bytes
+    ///     - the signature, as a 64 bytes array
+    ///     - the hash of the message, as a vector of bytes
+    /// - output: 0 for failure and 1 for success
+    ///
+    /// Inputs and outputs are similar to SchnorrVerify, except that because we
+    /// use a different curve (secp256k1), the field elements involved in the
+    /// signature and the public key are defined as an array of 32 bytes.
+    /// Another difference is that we assume the message is already hashed.
     EcdsaSecp256k1,
+
     /// Verifies a ECDSA signature over the secp256r1 curve.
+    ///
+    /// Same as EcdsaSecp256k1, but done over another curve.
     EcdsaSecp256r1,
-    /// Performs multi scalar multiplication over the embedded curve.
+
+    /// Multiple scalar multiplication (MSM) with a variable base/input point
+    /// (P) of the embedded curve. An MSM multiplies the points and scalars and
+    /// sums the results.
+    /// - input:
+    ///     points (witness, N) a vector of x and y coordinates of input
+    ///     points `[x1, y1, x2, y2,...]`.
+    ///     scalars (witness, N) a vector of low and high limbs of input
+    ///     scalars `[s1_low, s1_high, s2_low, s2_high, ...]`. (witness, N)
+    ///     For Barretenberg, they must both be less than 128 bits.
+    /// - output:
+    ///     a tuple of `x` and `y` coordinates of output.
+    ///     Points computed as `s_low*P+s_high*2^{128}*P`
+    ///
+    /// Because the Grumpkin scalar field is bigger than the ACIR field, we
+    /// provide 2 ACIR fields representing the low and high parts of the Grumpkin
+    /// scalar $a$: `a=low+high*2^{128}`, with `low, high < 2^{128}`
     MultiScalarMul,
-    /// Calculates the Keccak256 hash of the inputs.
+
+    /// Computes the Keccak-256 (Ethereum version) of the inputs.
+    /// - inputs: Vector of bytes (witness, 8)
+    /// - outputs: Array of 32 bytes (witness, 8)
     Keccak256,
-    /// Keccak Permutation function of 1600 width
+
+    /// Keccak Permutation function of width 1600
+    /// - inputs: An array of 25 64-bit Keccak lanes that represent a keccak sponge of 1600 bits
+    /// - outputs: The result of a keccak f1600 permutation on the input state. Also an array of 25 Keccak lanes.
     Keccakf1600,
-    /// Compute a recursive aggregation object when verifying a proof inside another circuit.
-    /// This outputted aggregation object will then be either checked in a top-level verifier or aggregated upon again.
+
+    /// Compute a recursive aggregation object when verifying a proof inside
+    /// another circuit.
+    /// This outputted aggregation object will then be either checked in a
+    /// top-level verifier or aggregated upon again.
+    ///
+    /// **Warning: this opcode is subject to change.**
+    /// Note that the `254` in `(witness, 254)` refers to the upper bound of
+    /// the `witness`.
+    /// - verification_key: Vector of (witness, 254) representing the
+    ///   verification key of the circuit being verified
+    /// - public_inputs: Vector of (witness, 254)  representing the public
+    ///   inputs corresponding to the proof being verified
+    /// - key_hash: one (witness, 254). It should be the hash of the
+    ///   verification key. Barretenberg expects the Pedersen hash of the
+    ///   verification key
+    ///
+    /// Another thing that it does is preparing the verification of the proof.
+    /// In order to fully verify a proof, some operations may still be required
+    /// to be done by the final verifier. This is why this black box function
+    /// does not say if verification is passing or not.
+    ///
+    /// This black box function does not fully verify a proof, what it does is
+    /// verifying that the key_hash is indeed a hash of verification_key,
+    /// allowing the user to use the verification key as private inputs and only
+    /// have the key_hash as public input, which is more performant.
+    ///
+    /// If one of the recursive proofs you verify with the black box function does not
+    /// verify, then the verification of the proof of the main ACIR program will
+    /// ultimately fail.
     RecursiveAggregation,
-    /// Addition over the embedded curve on which [`FieldElement`][acir_field::FieldElement] is defined.
+
+    /// Addition over the embedded curve on which the witness is defined.
     EmbeddedCurveAdd,
+
     /// BigInt addition
     BigIntAdd,
+
     /// BigInt subtraction
     BigIntSub,
+
     /// BigInt multiplication
     BigIntMul,
+
     /// BigInt division
     BigIntDiv,
+
     /// BigInt from le bytes
     BigIntFromLeBytes,
+
     /// BigInt to le bytes
     BigIntToLeBytes,
+
     /// Permutation function of Poseidon2
     Poseidon2Permutation,
+
     /// SHA256 compression function
+    /// - input: [(witness, 32); 16]
+    /// - state: [(witness, 32); 8]
+    /// - output: [(witness, 32); 8]
     Sha256Compression,
 }
 
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index 20c6903dc52..984422c5e3a 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -28,24 +28,85 @@ impl BlockType {
 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Opcode<F> {
+    /// An `AssertZero` opcode adds the constraint that `P(w) = 0`, where
+    /// `w=(w_1,..w_n)` is a tuple of `n` witnesses, and `P` is a multi-variate
+    /// polynomial of total degree at most `2`.
+    ///
+    /// The coefficients `{q_M}_{i,j}, q_i,q_c` of the polynomial are known
+    /// values which define the opcode.
+    ///
+    /// A general expression of assert-zero opcode is the following:
+    /// ```
+    /// \sum_{i,j} {q_M}_{i,j}w_iw_j + \sum_i q_iw_i +q_c = 0
+    /// ```
+    ///
+    /// An assert-zero opcode can be used to:
+    /// - **express a constraint** on witnesses; for instance to express that a
+    ///   witness `w` is a boolean, you can add the opcode: `w*w-w=0`
+    /// - or, to **compute the value** of an arithmetic operation of some inputs.
+    /// For instance, to multiply two witnesses `x` and `y`, you would use the
+    /// opcode `z-x*y=0`, which would constrain `z` to be `x*y`.
+    ///
+    /// The solver expects that at most one witness is not known when executing the opcode.
     AssertZero(Expression<F>),
-    /// Calls to "gadgets" which rely on backends implementing support for specialized constraints.
+
+    /// Calls to "gadgets" which rely on backends implementing support for
+    /// specialized constraints.
     ///
-    /// Often used for exposing more efficient implementations of SNARK-unfriendly computations.  
+    /// Often used for exposing more efficient implementations of
+    /// SNARK-unfriendly computations.  
+    ///
+    /// All black box functions take as input a tuple `(witness, num_bits)`,
+    /// where `num_bits` is a constant representing the bit size of the input
+    /// witness, and they have one or several witnesses as output.
+    ///
+    /// Some more advanced computations assume that the proving system has an
+    /// 'embedded curve'. It is a curve that cycles with the main curve of the
+    /// proving system, i.e the scalar field of the embedded curve is the base
+    /// field of the main one, and vice-versa.
+    ///
+    /// Aztec's Barretenberg uses BN254 as the main curve and Grumpkin as the
+    /// embedded curve.
     BlackBoxFuncCall(BlackBoxFuncCall),
+
+    /// This opcode is a specialization of a Brillig opcode. Instead of having
+    /// some generic assembly code like Brillig, a directive has a hardcoded
+    /// name which tells the solver which computation to do: with Brillig, the
+    /// computation refers to the compiled bytecode of an unconstrained Noir
+    /// function, but with a directive, the computation is hardcoded inside the
+    /// compiler.
+    ///
+    /// Directives will be replaced by Brillig opcodes in the future.
     Directive(Directive<F>),
+
     /// Atomic operation on a block of memory
+    ///
+    /// ACIR is able to address any array of witnesses. Each array is assigned
+    /// an id (BlockId) and needs to be initialized with the MemoryInit opcode.
+    /// Then it is possible to read and write from/to an array by providing the
+    /// index and the value we read/write as arithmetic expressions. Note that
+    /// ACIR arrays all have a known fixed length (given in the MemoryInit
+    /// opcode below)
+    ///
+    /// - predicate: an arithmetic expression that disables the execution of the
+    ///   opcode when the expression evaluates to zero
     MemoryOp {
+        /// identifier of the array
         block_id: BlockId,
+        /// describe the memory operation to perform
         op: MemOp<F>,
         /// Predicate of the memory operation - indicates if it should be skipped
         predicate: Option<Expression<F>>,
     },
-    MemoryInit {
-        block_id: BlockId,
-        init: Vec<Witness>,
-        block_type: BlockType,
-    },
+
+    /// Initialize an ACIR array from a vector of witnesses.
+    /// - block_id: identifier of the array
+    /// - init: Vector of witnesses specifying the initial value of the array
+    ///
+    /// There must be only one MemoryInit per block_id, and MemoryOp opcodes must
+    /// come after the MemoryInit.
+    MemoryInit { block_id: BlockId, init: Vec<Witness>, block_type: BlockType },
+
     /// Calls to unconstrained functions
     BrilligCall {
         /// Id for the function being called. It is the responsibility of the executor
@@ -58,6 +119,7 @@ pub enum Opcode<F> {
         /// Predicate of the Brillig execution - indicates if it should be skipped
         predicate: Option<Expression<F>>,
     },
+
     /// Calls to functions represented as a separate circuit. A call opcode allows us
     /// to build a call stack when executing the outer-most circuit.
     Call {
diff --git a/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs b/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
index 2147e7430b2..90e3ee0563a 100644
--- a/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
@@ -9,9 +9,12 @@ pub struct BlockId(pub u32);
 /// We can either write or read at an index in memory
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
 pub struct MemOp<F> {
-    /// Can be 0 (read) or 1 (write)
+    /// A constant expression that can be 0 (read) or 1 (write)
     pub operation: Expression<F>,
+    /// array index, it must be less than the array length
     pub index: Expression<F>,
+    /// the value we are reading, when operation is 0, or the value we write at
+    /// the specified index, when operation is 1
     pub value: Expression<F>,
 }
 
diff --git a/cspell.json b/cspell.json
index 4497d0bf9da..88cf6e4d4f0 100644
--- a/cspell.json
+++ b/cspell.json
@@ -97,6 +97,7 @@
         "hexdigit",
         "higher-kinded",
         "Hindley-Milner",
+        "homomorphic",
         "idents",
         "ilog",
         "impls",

From 1afc6c2c6cdcc434513a9cf6653d9bbd7992867e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 4 Jun 2024 15:26:34 +0100
Subject: [PATCH 331/416] chore: start moving lints into a separate linting
 directory (#5165)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR starts moving some diagnostics into a separate `lints` directory
and out of the main flow of the elaborator.

Eventually we can ideally move this to run on the node interner after
the elaborator has completed rather than being called during elaboration
but this can happen in a later PR

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/elaborator/lints.rs    | 221 ++++++++++++++++++
 compiler/noirc_frontend/src/elaborator/mod.rs | 109 +++------
 .../src/elaborator/statements.rs              |   7 +-
 .../noirc_frontend/src/elaborator/types.rs    |  92 ++------
 cspell.json                                   |   1 +
 5 files changed, 277 insertions(+), 153 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/elaborator/lints.rs

diff --git a/compiler/noirc_frontend/src/elaborator/lints.rs b/compiler/noirc_frontend/src/elaborator/lints.rs
new file mode 100644
index 00000000000..da3e033cd4c
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/lints.rs
@@ -0,0 +1,221 @@
+use crate::{
+    ast::FunctionKind,
+    graph::CrateId,
+    hir::{
+        resolution::errors::{PubPosition, ResolverError},
+        type_check::TypeCheckError,
+    },
+    hir_def::expr::HirIdent,
+    macros_api::{
+        HirExpression, HirLiteral, NodeInterner, NoirFunction, UnaryOp, UnresolvedTypeData,
+        Visibility,
+    },
+    node_interner::{DefinitionKind, ExprId},
+    Type,
+};
+use acvm::AcirField;
+
+use noirc_errors::Span;
+
+pub(super) fn deprecated_function(interner: &NodeInterner, expr: ExprId) -> Option<TypeCheckError> {
+    let HirExpression::Ident(HirIdent { location, id, impl_kind: _ }, _) =
+        interner.expression(&expr)
+    else {
+        return None;
+    };
+
+    let Some(DefinitionKind::Function(func_id)) = interner.try_definition(id).map(|def| &def.kind)
+    else {
+        return None;
+    };
+
+    let attributes = interner.function_attributes(func_id);
+    attributes.get_deprecated_note().map(|note| TypeCheckError::CallDeprecated {
+        name: interner.definition_name(id).to_string(),
+        note,
+        span: location.span,
+    })
+}
+
+/// Inline attributes are only relevant for constrained functions
+/// as all unconstrained functions are not inlined and so
+/// associated attributes are disallowed.
+pub(super) fn inlining_attributes(func: &NoirFunction) -> Option<ResolverError> {
+    if !func.def.is_unconstrained {
+        let attributes = func.attributes().clone();
+
+        if attributes.is_no_predicates() {
+            Some(ResolverError::NoPredicatesAttributeOnUnconstrained {
+                ident: func.name_ident().clone(),
+            })
+        } else if attributes.is_foldable() {
+            Some(ResolverError::FoldAttributeOnUnconstrained { ident: func.name_ident().clone() })
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+/// Attempting to define new low level (`#[builtin]` or `#[foreign]`) functions outside of the stdlib is disallowed.
+pub(super) fn low_level_function_outside_stdlib(
+    func: &NoirFunction,
+    crate_id: CrateId,
+) -> Option<ResolverError> {
+    let is_low_level_function =
+        func.attributes().function.as_ref().map_or(false, |func| func.is_low_level());
+    if !crate_id.is_stdlib() && is_low_level_function {
+        Some(ResolverError::LowLevelFunctionOutsideOfStdlib { ident: func.name_ident().clone() })
+    } else {
+        None
+    }
+}
+
+/// `pub` is required on return types for entry point functions
+pub(super) fn missing_pub(func: &NoirFunction, is_entry_point: bool) -> Option<ResolverError> {
+    if is_entry_point
+        && func.return_type().typ != UnresolvedTypeData::Unit
+        && func.def.return_visibility == Visibility::Private
+    {
+        Some(ResolverError::NecessaryPub { ident: func.name_ident().clone() })
+    } else {
+        None
+    }
+}
+
+/// `#[recursive]` attribute is only allowed for entry point functions
+pub(super) fn recursive_non_entrypoint_function(
+    func: &NoirFunction,
+    is_entry_point: bool,
+) -> Option<ResolverError> {
+    if !is_entry_point && func.kind == FunctionKind::Recursive {
+        Some(ResolverError::MisplacedRecursiveAttribute { ident: func.name_ident().clone() })
+    } else {
+        None
+    }
+}
+
+/// Test functions cannot have arguments in order to be executable.
+pub(super) fn test_function_with_args(func: &NoirFunction) -> Option<ResolverError> {
+    if func.attributes().is_test_function() && !func.parameters().is_empty() {
+        Some(ResolverError::TestFunctionHasParameters { span: func.name_ident().span() })
+    } else {
+        None
+    }
+}
+
+/// Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime.
+pub(super) fn unconstrained_function_args(
+    function_args: &[(Type, ExprId, Span)],
+) -> Vec<TypeCheckError> {
+    function_args
+        .iter()
+        .filter_map(|(typ, _, span)| {
+            if type_contains_mutable_reference(typ) {
+                Some(TypeCheckError::ConstrainedReferenceToUnconstrained { span: *span })
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+/// Check that we are not passing a slice from an unconstrained runtime to a constrained runtime.
+pub(super) fn unconstrained_function_return(
+    return_type: &Type,
+    span: Span,
+) -> Option<TypeCheckError> {
+    if return_type.contains_slice() {
+        Some(TypeCheckError::UnconstrainedSliceReturnToConstrained { span })
+    } else if type_contains_mutable_reference(return_type) {
+        Some(TypeCheckError::UnconstrainedReferenceToConstrained { span })
+    } else {
+        None
+    }
+}
+
+fn type_contains_mutable_reference(typ: &Type) -> bool {
+    matches!(&typ.follow_bindings(), Type::MutableReference(_))
+}
+
+/// Only entrypoint functions require a `pub` visibility modifier applied to their return types.
+///
+/// Application of `pub` to other functions is not meaningful and is a mistake.
+pub(super) fn unnecessary_pub_return(
+    func: &NoirFunction,
+    is_entry_point: bool,
+) -> Option<ResolverError> {
+    if !is_entry_point && func.def.return_visibility == Visibility::Public {
+        Some(ResolverError::UnnecessaryPub {
+            ident: func.name_ident().clone(),
+            position: PubPosition::ReturnType,
+        })
+    } else {
+        None
+    }
+}
+
+/// Only arguments to entrypoint functions may have a non-private visibility modifier applied to them.
+///
+/// Other functions are disallowed from declaring the visibility of their arguments.
+pub(super) fn unnecessary_pub_argument(
+    func: &NoirFunction,
+    arg_visibility: Visibility,
+    is_entry_point: bool,
+) -> Option<ResolverError> {
+    if arg_visibility == Visibility::Public && !is_entry_point {
+        Some(ResolverError::UnnecessaryPub {
+            ident: func.name_ident().clone(),
+            position: PubPosition::Parameter,
+        })
+    } else {
+        None
+    }
+}
+
+/// Check if an assignment is overflowing with respect to `annotated_type`
+/// in a declaration statement where `annotated_type` is an unsigned integer
+pub(crate) fn overflowing_uint(
+    interner: &NodeInterner,
+    rhs_expr: &ExprId,
+    annotated_type: &Type,
+) -> Vec<TypeCheckError> {
+    let expr = interner.expression(rhs_expr);
+    let span = interner.expr_span(rhs_expr);
+
+    let mut errors = Vec::with_capacity(2);
+    match expr {
+        HirExpression::Literal(HirLiteral::Integer(value, false)) => {
+            let v = value.to_u128();
+            if let Type::Integer(_, bit_count) = annotated_type {
+                let bit_count: u32 = (*bit_count).into();
+                let max = 1 << bit_count;
+                if v >= max {
+                    errors.push(TypeCheckError::OverflowingAssignment {
+                        expr: value,
+                        ty: annotated_type.clone(),
+                        range: format!("0..={}", max - 1),
+                        span,
+                    });
+                };
+            };
+        }
+        HirExpression::Prefix(expr) => {
+            overflowing_uint(interner, &expr.rhs, annotated_type);
+            if expr.operator == UnaryOp::Minus {
+                errors.push(TypeCheckError::InvalidUnaryOp {
+                    kind: "annotated_type".to_string(),
+                    span,
+                });
+            }
+        }
+        HirExpression::Infix(expr) => {
+            errors.extend(overflowing_uint(interner, &expr.lhs, annotated_type));
+            errors.extend(overflowing_uint(interner, &expr.rhs, annotated_type));
+        }
+        _ => {}
+    }
+
+    errors
+}
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 594c0690033..24902c395b8 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -30,15 +30,12 @@ use crate::{
     hir::{
         def_collector::{dc_crate::CollectedItems, errors::DefCollectorErrorKind},
         def_map::{LocalModuleId, ModuleDefId, ModuleId, MAIN_FUNCTION},
-        resolution::{
-            errors::PubPosition, import::PathResolution, path_resolver::StandardPathResolver,
-        },
+        resolution::{import::PathResolution, path_resolver::StandardPathResolver},
         Context,
     },
     hir_def::function::{FuncMeta, HirFunction},
-    macros_api::{Param, Path, UnresolvedType, UnresolvedTypeData, Visibility},
+    macros_api::{Param, Path, UnresolvedType, UnresolvedTypeData},
     node_interner::TraitImplId,
-    token::FunctionAttribute,
     Generics,
 };
 use crate::{
@@ -51,6 +48,7 @@ use crate::{
 };
 
 mod expressions;
+mod lints;
 mod patterns;
 mod scope;
 mod statements;
@@ -295,7 +293,7 @@ impl<'context> Elaborator<'context> {
             .expect("FuncMetas should be declared before a function is elaborated")
             .clone();
 
-        // The DefinitionIds for each parameter were already created in define_function_meta
+        // The `DefinitionId`s for each parameter were already created in `define_function_meta`
         // so we need to reintroduce the same IDs into scope here.
         for parameter in &func_meta.parameter_idents {
             let name = self.interner.definition_name(parameter.id).to_owned();
@@ -429,6 +427,12 @@ impl<'context> Elaborator<'context> {
         self.errors.push((error.into(), self.file));
     }
 
+    fn run_lint(&mut self, lint: impl Fn(&Elaborator) -> Option<CompilationError>) {
+        if let Some(error) = lint(self) {
+            self.push_err(error);
+        }
+    }
+
     fn resolve_where_clause(&mut self, clause: &mut [UnresolvedTraitConstraint]) {
         for bound in clause {
             if let Some(trait_id) = self.resolve_trait_by_path(bound.trait_bound.trait_path.clone())
@@ -510,6 +514,8 @@ impl<'context> Elaborator<'context> {
     ) {
         self.current_function = Some(func_id);
         self.resolve_where_clause(&mut func.def.where_clause);
+        // `func` is no longer mutated.
+        let func = &*func;
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
         if self.self_type.is_some() {
@@ -523,26 +529,28 @@ impl<'context> Elaborator<'context> {
         let id = self.interner.function_definition_id(func_id);
         let name_ident = HirIdent::non_trait_method(id, location);
 
-        let attributes = func.attributes().clone();
-        let has_no_predicates_attribute = attributes.is_no_predicates();
-        let should_fold = attributes.is_foldable();
-        if !self.inline_attribute_allowed(func) {
-            if has_no_predicates_attribute {
-                self.push_err(ResolverError::NoPredicatesAttributeOnUnconstrained {
-                    ident: func.name_ident().clone(),
-                });
-            } else if should_fold {
-                self.push_err(ResolverError::FoldAttributeOnUnconstrained {
-                    ident: func.name_ident().clone(),
-                });
-            }
-        }
+        let is_entry_point = self.is_entry_point_function(func);
+
+        self.run_lint(|_| lints::inlining_attributes(func).map(Into::into));
+        self.run_lint(|_| lints::missing_pub(func, is_entry_point).map(Into::into));
+        self.run_lint(|elaborator| {
+            lints::unnecessary_pub_return(func, elaborator.pub_allowed(func)).map(Into::into)
+        });
+        self.run_lint(|elaborator| {
+            lints::low_level_function_outside_stdlib(func, elaborator.crate_id).map(Into::into)
+        });
+        self.run_lint(|_| lints::test_function_with_args(func).map(Into::into));
+        self.run_lint(|_| {
+            lints::recursive_non_entrypoint_function(func, is_entry_point).map(Into::into)
+        });
+
         // Both the #[fold] and #[no_predicates] alter a function's inline type and code generation in similar ways.
         // In certain cases such as type checking (for which the following flag will be used) both attributes
         // indicate we should code generate in the same way. Thus, we unify the attributes into one flag here.
+        let has_no_predicates_attribute = func.attributes().is_no_predicates();
+        let should_fold = func.attributes().is_foldable();
         let has_inline_attribute = has_no_predicates_attribute || should_fold;
-        let is_entry_point = self.is_entry_point_function(func);
-
+        let is_pub_allowed = self.pub_allowed(func);
         self.add_generics(&func.def.generics);
 
         let mut trait_constraints = self.resolve_trait_constraints(&func.def.where_clause);
@@ -553,12 +561,9 @@ impl<'context> Elaborator<'context> {
         let mut parameter_idents = Vec::new();
 
         for Param { visibility, pattern, typ, span: _ } in func.parameters().iter().cloned() {
-            if visibility == Visibility::Public && !self.pub_allowed(func) {
-                self.push_err(ResolverError::UnnecessaryPub {
-                    ident: func.name_ident().clone(),
-                    position: PubPosition::Parameter,
-                });
-            }
+            self.run_lint(|_| {
+                lints::unnecessary_pub_argument(func, visibility, is_pub_allowed).map(Into::into)
+            });
 
             let type_span = typ.span.unwrap_or_else(|| pattern.span());
 
@@ -588,44 +593,6 @@ impl<'context> Elaborator<'context> {
 
         let return_type = Box::new(self.resolve_type(func.return_type()));
 
-        if !self.pub_allowed(func) && func.def.return_visibility == Visibility::Public {
-            self.push_err(ResolverError::UnnecessaryPub {
-                ident: func.name_ident().clone(),
-                position: PubPosition::ReturnType,
-            });
-        }
-
-        let is_low_level_function =
-            attributes.function.as_ref().map_or(false, |func| func.is_low_level());
-
-        if !self.crate_id.is_stdlib() && is_low_level_function {
-            let error =
-                ResolverError::LowLevelFunctionOutsideOfStdlib { ident: func.name_ident().clone() };
-            self.push_err(error);
-        }
-
-        // 'pub' is required on return types for entry point functions
-        if is_entry_point
-            && return_type.as_ref() != &Type::Unit
-            && func.def.return_visibility == Visibility::Private
-        {
-            self.push_err(ResolverError::NecessaryPub { ident: func.name_ident().clone() });
-        }
-        // '#[recursive]' attribute is only allowed for entry point functions
-        if !is_entry_point && func.kind == FunctionKind::Recursive {
-            self.push_err(ResolverError::MisplacedRecursiveAttribute {
-                ident: func.name_ident().clone(),
-            });
-        }
-
-        if matches!(attributes.function, Some(FunctionAttribute::Test { .. }))
-            && !parameters.is_empty()
-        {
-            self.push_err(ResolverError::TestFunctionHasParameters {
-                span: func.name_ident().span(),
-            });
-        }
-
         let mut typ = Type::Function(parameter_types, return_type, Box::new(Type::Unit));
 
         if !generics.is_empty() {
@@ -682,14 +649,8 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn inline_attribute_allowed(&self, func: &NoirFunction) -> bool {
-        // Inline attributes are only relevant for constrained functions
-        // as all unconstrained functions are not inlined
-        !func.def.is_unconstrained
-    }
-
-    /// True if the 'pub' keyword is allowed on parameters in this function
-    /// 'pub' on function parameters is only allowed for entry point functions
+    /// True if the `pub` keyword is allowed on parameters in this function
+    /// `pub` on function parameters is only allowed for entry point functions
     fn pub_allowed(&self, func: &NoirFunction) -> bool {
         self.is_entry_point_function(func) || func.attributes().is_foldable()
     }
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 40de9a3983a..8f2f4d3911a 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -19,7 +19,7 @@ use crate::{
     Type,
 };
 
-use super::Elaborator;
+use super::{lints, Elaborator};
 
 impl<'context> Elaborator<'context> {
     fn elaborate_statement_value(&mut self, statement: Statement) -> (HirStatement, Type) {
@@ -98,7 +98,10 @@ impl<'context> Elaborator<'context> {
                 }
             });
             if annotated_type.is_unsigned() {
-                self.lint_overflowing_uint(&expression, &annotated_type);
+                let errors = lints::overflowing_uint(self.interner, &expression, &annotated_type);
+                for error in errors {
+                    self.push_err(error);
+                }
             }
             annotated_type
         } else {
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 955b4af327a..3d677d8740d 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -33,7 +33,7 @@ use crate::{
     Generics, Type, TypeBinding, TypeVariable, TypeVariableKind,
 };
 
-use super::Elaborator;
+use super::{lints, Elaborator};
 
 impl<'context> Elaborator<'context> {
     /// Translates an UnresolvedType to a Type
@@ -502,44 +502,6 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    /// Check if an assignment is overflowing with respect to `annotated_type`
-    /// in a declaration statement where `annotated_type` is an unsigned integer
-    pub(super) fn lint_overflowing_uint(&mut self, rhs_expr: &ExprId, annotated_type: &Type) {
-        let expr = self.interner.expression(rhs_expr);
-        let span = self.interner.expr_span(rhs_expr);
-        match expr {
-            HirExpression::Literal(HirLiteral::Integer(value, false)) => {
-                let v = value.to_u128();
-                if let Type::Integer(_, bit_count) = annotated_type {
-                    let bit_count: u32 = (*bit_count).into();
-                    let max = 1 << bit_count;
-                    if v >= max {
-                        self.push_err(TypeCheckError::OverflowingAssignment {
-                            expr: value,
-                            ty: annotated_type.clone(),
-                            range: format!("0..={}", max - 1),
-                            span,
-                        });
-                    };
-                };
-            }
-            HirExpression::Prefix(expr) => {
-                self.lint_overflowing_uint(&expr.rhs, annotated_type);
-                if matches!(expr.operator, UnaryOp::Minus) {
-                    self.push_err(TypeCheckError::InvalidUnaryOp {
-                        kind: "annotated_type".to_string(),
-                        span,
-                    });
-                }
-            }
-            HirExpression::Infix(expr) => {
-                self.lint_overflowing_uint(&expr.lhs, annotated_type);
-                self.lint_overflowing_uint(&expr.rhs, annotated_type);
-            }
-            _ => {}
-        }
-    }
-
     pub(super) fn unify(
         &mut self,
         actual: &Type,
@@ -1182,57 +1144,33 @@ impl<'context> Elaborator<'context> {
         args: Vec<(Type, ExprId, Span)>,
         span: Span,
     ) -> Type {
-        // Need to setup these flags here as `self` is borrowed mutably to type check the rest of the call expression
-        // These flags are later used to type check calls to unconstrained functions from constrained functions
+        self.run_lint(|elaborator| {
+            lints::deprecated_function(elaborator.interner, call.func).map(Into::into)
+        });
+
         let func_mod = self.current_function.map(|func| self.interner.function_modifiers(&func));
         let is_current_func_constrained =
             func_mod.map_or(true, |func_mod| !func_mod.is_unconstrained);
-
         let is_unconstrained_call = self.is_unconstrained_call(call.func);
-        self.check_if_deprecated(call.func);
-
-        // Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime
-        if is_current_func_constrained && is_unconstrained_call {
-            for (typ, _, _) in args.iter() {
-                if matches!(&typ.follow_bindings(), Type::MutableReference(_)) {
-                    self.push_err(TypeCheckError::ConstrainedReferenceToUnconstrained { span });
-                }
+        let crossing_runtime_boundary = is_current_func_constrained && is_unconstrained_call;
+        if crossing_runtime_boundary {
+            let errors = lints::unconstrained_function_args(&args);
+            for error in errors {
+                self.push_err(error);
             }
         }
 
         let return_type = self.bind_function_type(func_type, args, span);
 
-        // Check that we are not passing a slice from an unconstrained runtime to a constrained runtime
-        if is_current_func_constrained && is_unconstrained_call {
-            if return_type.contains_slice() {
-                self.push_err(TypeCheckError::UnconstrainedSliceReturnToConstrained { span });
-            } else if matches!(&return_type.follow_bindings(), Type::MutableReference(_)) {
-                self.push_err(TypeCheckError::UnconstrainedReferenceToConstrained { span });
-            }
-        };
+        if crossing_runtime_boundary {
+            self.run_lint(|_| {
+                lints::unconstrained_function_return(&return_type, span).map(Into::into)
+            });
+        }
 
         return_type
     }
 
-    fn check_if_deprecated(&mut self, expr: ExprId) {
-        if let HirExpression::Ident(HirIdent { location, id, impl_kind: _ }, _) =
-            self.interner.expression(&expr)
-        {
-            if let Some(DefinitionKind::Function(func_id)) =
-                self.interner.try_definition(id).map(|def| &def.kind)
-            {
-                let attributes = self.interner.function_attributes(func_id);
-                if let Some(note) = attributes.get_deprecated_note() {
-                    self.push_err(TypeCheckError::CallDeprecated {
-                        name: self.interner.definition_name(id).to_string(),
-                        note,
-                        span: location.span,
-                    });
-                }
-            }
-        }
-    }
-
     fn is_unconstrained_call(&self, expr: ExprId) -> bool {
         if let HirExpression::Ident(HirIdent { id, .. }, _) = self.interner.expression(&expr) {
             if let Some(DefinitionKind::Function(func_id)) =
diff --git a/cspell.json b/cspell.json
index 88cf6e4d4f0..cea0dd7ed38 100644
--- a/cspell.json
+++ b/cspell.json
@@ -57,6 +57,7 @@
         "curvegroup",
         "databus",
         "debouncer",
+        "defaultable",
         "deflater",
         "deflatten",
         "deflattened",

From 888b94cf52f1f6f5fdb256d503b4949962cab59c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 4 Jun 2024 15:59:03 +0100
Subject: [PATCH 332/416] chore: avoid manual creation of contract artifact in
 wasm (#5117)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We don't need to construct these manually as we have functions for this.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/wasm/src/compile.rs     | 20 +++-----------------
 compiler/wasm/src/compile_new.rs | 16 ++--------------
 2 files changed, 5 insertions(+), 31 deletions(-)

diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index 57b17a6f79e..f1495e0b438 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -3,15 +3,11 @@ use fm::FileManager;
 use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{JsString, Object};
 use nargo::{
-    artifacts::{
-        contract::{ContractArtifact, ContractFunctionArtifact},
-        program::ProgramArtifact,
-    },
+    artifacts::{contract::ContractArtifact, program::ProgramArtifact},
     parse_all,
 };
 use noirc_driver::{
     add_dep, file_manager_with_stdlib, prepare_crate, prepare_dependency, CompileOptions,
-    NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_evaluator::errors::SsaReport;
 use noirc_frontend::{
@@ -220,19 +216,9 @@ pub fn compile_contract(
 
     let optimized_contract =
         nargo::ops::transform_contract(compiled_contract, compile_options.expression_width);
+    let warnings = optimized_contract.warnings.clone();
 
-    let functions =
-        optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
-
-    let contract_artifact = ContractArtifact {
-        noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
-        name: optimized_contract.name,
-        functions,
-        outputs: optimized_contract.outputs.into(),
-        file_map: optimized_contract.file_map,
-    };
-
-    Ok(JsCompileContractResult::new(contract_artifact, optimized_contract.warnings))
+    Ok(JsCompileContractResult::new(optimized_contract.into(), warnings))
 }
 
 fn prepare_context(
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index 4f11cafb975..d5f02833521 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -4,11 +4,9 @@ use crate::compile::{
 };
 use crate::errors::{CompileError, JsCompileError};
 use acvm::acir::circuit::ExpressionWidth;
-use nargo::artifacts::contract::{ContractArtifact, ContractFunctionArtifact};
 use nargo::parse_all;
 use noirc_driver::{
     add_dep, compile_contract, compile_main, prepare_crate, prepare_dependency, CompileOptions,
-    NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_frontend::{
     graph::{CrateId, CrateName},
@@ -148,19 +146,9 @@ impl CompilerContext {
 
         let optimized_contract =
             nargo::ops::transform_contract(compiled_contract, compile_options.expression_width);
+        let warnings = optimized_contract.warnings.clone();
 
-        let functions =
-            optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
-
-        let contract_artifact = ContractArtifact {
-            noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
-            name: optimized_contract.name,
-            functions,
-            outputs: optimized_contract.outputs.into(),
-            file_map: optimized_contract.file_map,
-        };
-
-        Ok(JsCompileContractResult::new(contract_artifact, optimized_contract.warnings))
+        Ok(JsCompileContractResult::new(optimized_contract.into(), warnings))
     }
 }
 

From 90632dac6c493e4c7886503d71e682b611341e43 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 4 Jun 2024 16:47:05 +0100
Subject: [PATCH 333/416] chore(experimental elaborator): Handle `comptime`
 expressions in the elaborator (#5169)

# Description

## Problem\*

## Summary\*

Resolves some remaining `todo`s in the elaborator by calling the
interpreter on any comptime expressions within.

## Additional Context

The interpreter is mostly unchanged. The main exception being I've added
a new `Value::into_expression` function to convert into an `Expression`,
and renamed the old version to `Value::into_hir_expression` since it
creates an `ExprId` instead.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 compiler/noirc_frontend/src/ast/expression.rs |  19 ++-
 .../src/elaborator/expressions.rs             |  96 ++++++++++----
 compiler/noirc_frontend/src/elaborator/mod.rs | 120 ++++-------------
 .../noirc_frontend/src/elaborator/scope.rs    |   2 +
 .../src/elaborator/statements.rs              |  12 +-
 .../noirc_frontend/src/elaborator/types.rs    |  96 +++++++++++++-
 .../noirc_frontend/src/hir/comptime/errors.rs |   6 +
 .../src/hir/comptime/interpreter.rs           |  41 ++----
 .../noirc_frontend/src/hir/comptime/scan.rs   |   9 +-
 .../noirc_frontend/src/hir/comptime/tests.rs  |   5 +-
 .../noirc_frontend/src/hir/comptime/value.rs  | 125 ++++++++++++++++--
 .../src/hir/def_collector/dc_crate.rs         |   3 +-
 .../src/hir/resolution/resolver.rs            |   3 +
 tooling/nargo_fmt/src/rewrite/expr.rs         |   3 +
 14 files changed, 367 insertions(+), 173 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 21131c71217..749e41d9c1c 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -5,6 +5,8 @@ use crate::ast::{
     Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
+use crate::macros_api::StructId;
+use crate::node_interner::ExprId;
 use crate::token::{Attributes, Token};
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
@@ -33,6 +35,11 @@ pub enum ExpressionKind {
     Parenthesized(Box<Expression>),
     Quote(BlockExpression),
     Comptime(BlockExpression),
+
+    // This variant is only emitted when inlining the result of comptime
+    // code. It is used to translate function values back into the AST while
+    // guaranteeing they have the same instantiated type and definition id without resolving again.
+    Resolved(ExprId),
     Error,
 }
 
@@ -108,7 +115,11 @@ impl ExpressionKind {
     }
 
     pub fn constructor((type_name, fields): (Path, Vec<(Ident, Expression)>)) -> ExpressionKind {
-        ExpressionKind::Constructor(Box::new(ConstructorExpression { type_name, fields }))
+        ExpressionKind::Constructor(Box::new(ConstructorExpression {
+            type_name,
+            fields,
+            struct_type: None,
+        }))
     }
 
     /// Returns true if the expression is a literal integer
@@ -451,6 +462,11 @@ pub struct MethodCallExpression {
 pub struct ConstructorExpression {
     pub type_name: Path,
     pub fields: Vec<(Ident, Expression)>,
+
+    /// This may be filled out during macro expansion
+    /// so that we can skip re-resolving the type name since it
+    /// would be lost at that point.
+    pub struct_type: Option<StructId>,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -522,6 +538,7 @@ impl Display for ExpressionKind {
             Quote(block) => write!(f, "quote {block}"),
             Comptime(block) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
+            Resolved(_) => write!(f, "?Resolved"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 8acd1867074..abd8781a213 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -9,6 +9,7 @@ use crate::{
         UnresolvedTypeExpression,
     },
     hir::{
+        comptime::{self, Interpreter, InterpreterError},
         resolution::{errors::ResolverError, resolver::LambdaContext},
         type_check::TypeCheckError,
     },
@@ -58,7 +59,10 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
             ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
             ExpressionKind::Quote(quote) => self.elaborate_quote(quote),
-            ExpressionKind::Comptime(comptime) => self.elaborate_comptime_block(comptime),
+            ExpressionKind::Comptime(comptime) => {
+                return self.elaborate_comptime_block(comptime, expr.span)
+            }
+            ExpressionKind::Resolved(id) => return (id, self.interner.id_type(id)),
             ExpressionKind::Error => (HirExpression::Error, Type::Error),
         };
         let id = self.interner.push_expr(hir_expr);
@@ -68,6 +72,11 @@ impl<'context> Elaborator<'context> {
     }
 
     pub(super) fn elaborate_block(&mut self, block: BlockExpression) -> (HirExpression, Type) {
+        let (block, typ) = self.elaborate_block_expression(block);
+        (HirExpression::Block(block), typ)
+    }
+
+    fn elaborate_block_expression(&mut self, block: BlockExpression) -> (HirBlockExpression, Type) {
         self.push_scope();
         let mut block_type = Type::Unit;
         let mut statements = Vec::with_capacity(block.statements.len());
@@ -92,7 +101,7 @@ impl<'context> Elaborator<'context> {
         }
 
         self.pop_scope();
-        (HirExpression::Block(HirBlockExpression { statements }), block_type)
+        (HirBlockExpression { statements }, block_type)
     }
 
     fn elaborate_literal(&mut self, literal: Literal, span: Span) -> (HirExpression, Type) {
@@ -365,32 +374,34 @@ impl<'context> Elaborator<'context> {
     ) -> (HirExpression, Type) {
         let span = constructor.type_name.span();
 
-        match self.lookup_type_or_error(constructor.type_name) {
-            Some(Type::Struct(r#type, struct_generics)) => {
-                let struct_type = r#type.clone();
-                let generics = struct_generics.clone();
-
-                let fields = constructor.fields;
-                let field_types = r#type.borrow().get_fields(&struct_generics);
-                let fields = self.resolve_constructor_expr_fields(
-                    struct_type.clone(),
-                    field_types,
-                    fields,
-                    span,
-                );
-                let expr = HirExpression::Constructor(HirConstructorExpression {
-                    fields,
-                    r#type,
-                    struct_generics,
-                });
-                (expr, Type::Struct(struct_type, generics))
-            }
-            Some(typ) => {
-                self.push_err(ResolverError::NonStructUsedInConstructor { typ, span });
-                (HirExpression::Error, Type::Error)
+        let (r#type, struct_generics) = if let Some(struct_id) = constructor.struct_type {
+            let typ = self.interner.get_struct(struct_id);
+            let generics = typ.borrow().instantiate(self.interner);
+            (typ, generics)
+        } else {
+            match self.lookup_type_or_error(constructor.type_name) {
+                Some(Type::Struct(r#type, struct_generics)) => (r#type, struct_generics),
+                Some(typ) => {
+                    self.push_err(ResolverError::NonStructUsedInConstructor { typ, span });
+                    return (HirExpression::Error, Type::Error);
+                }
+                None => return (HirExpression::Error, Type::Error),
             }
-            None => (HirExpression::Error, Type::Error),
-        }
+        };
+
+        let struct_type = r#type.clone();
+        let generics = struct_generics.clone();
+
+        let fields = constructor.fields;
+        let field_types = r#type.borrow().get_fields(&struct_generics);
+        let fields =
+            self.resolve_constructor_expr_fields(struct_type.clone(), field_types, fields, span);
+        let expr = HirExpression::Constructor(HirConstructorExpression {
+            fields,
+            r#type,
+            struct_generics,
+        });
+        (expr, Type::Struct(struct_type, generics))
     }
 
     /// Resolve all the fields of a struct constructor expression.
@@ -620,7 +631,34 @@ impl<'context> Elaborator<'context> {
         (HirExpression::Quote(block), Type::Code)
     }
 
-    fn elaborate_comptime_block(&mut self, _comptime: BlockExpression) -> (HirExpression, Type) {
-        todo!("Elaborate comptime block")
+    fn elaborate_comptime_block(&mut self, block: BlockExpression, span: Span) -> (ExprId, Type) {
+        let (block, _typ) = self.elaborate_block_expression(block);
+        let mut interpreter = Interpreter::new(self.interner, &mut self.comptime_scopes);
+        let value = interpreter.evaluate_block(block);
+        self.inline_comptime_value(value, span)
+    }
+
+    pub(super) fn inline_comptime_value(
+        &mut self,
+        value: Result<comptime::Value, InterpreterError>,
+        span: Span,
+    ) -> (ExprId, Type) {
+        let make_error = |this: &mut Self, error: InterpreterError| {
+            this.errors.push(error.into_compilation_error_pair());
+            let error = this.interner.push_expr(HirExpression::Error);
+            this.interner.push_expr_location(error, span, this.file);
+            (error, Type::Error)
+        };
+
+        let value = match value {
+            Ok(value) => value,
+            Err(error) => return make_error(self, error),
+        };
+
+        let location = Location::new(span, self.file);
+        match value.into_expression(self.interner, location) {
+            Ok(new_expr) => self.elaborate_expression(new_expr),
+            Err(error) => make_error(self, error),
+        }
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 24902c395b8..649a93b0bd6 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -6,6 +6,7 @@ use std::{
 use crate::{
     ast::{FunctionKind, UnresolvedTraitConstraint},
     hir::{
+        comptime::{self, Interpreter},
         def_collector::{
             dc_crate::{
                 filter_literal_globals, CompilationError, ImplMap, UnresolvedGlobal,
@@ -21,7 +22,9 @@ use crate::{
     macros_api::{
         Ident, NodeInterner, NoirFunction, NoirStruct, Pattern, SecondaryAttribute, StructId,
     },
-    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId, TraitId, TypeAliasId},
+    node_interner::{
+        DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, TraitId, TypeAliasId,
+    },
     Shared, Type, TypeVariable,
 };
 use crate::{
@@ -58,7 +61,7 @@ mod types;
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
-use rustc_hash::FxHashSet as HashSet;
+use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 /// ResolverMetas are tagged onto each definition to track how many times they are used
 #[derive(Debug, PartialEq, Eq)]
@@ -151,6 +154,11 @@ pub struct Elaborator<'context> {
     local_module: LocalModuleId,
 
     crate_id: CrateId,
+
+    /// Each value currently in scope in the comptime interpreter.
+    /// Each element of the Vec represents a scope with every scope together making
+    /// up all currently visible definitions. The first scope is always the global scope.
+    comptime_scopes: Vec<HashMap<DefinitionId, comptime::Value>>,
 }
 
 impl<'context> Elaborator<'context> {
@@ -177,6 +185,7 @@ impl<'context> Elaborator<'context> {
             type_variables: Vec::new(),
             trait_constraints: Vec::new(),
             current_trait_impl: None,
+            comptime_scopes: vec![HashMap::default()],
         }
     }
 
@@ -685,98 +694,6 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn find_numeric_generics(
-        parameters: &Parameters,
-        return_type: &Type,
-    ) -> Vec<(String, TypeVariable)> {
-        let mut found = BTreeMap::new();
-        for (_, parameter, _) in &parameters.0 {
-            Self::find_numeric_generics_in_type(parameter, &mut found);
-        }
-        Self::find_numeric_generics_in_type(return_type, &mut found);
-        found.into_iter().collect()
-    }
-
-    fn find_numeric_generics_in_type(typ: &Type, found: &mut BTreeMap<String, TypeVariable>) {
-        match typ {
-            Type::FieldElement
-            | Type::Integer(_, _)
-            | Type::Bool
-            | Type::Unit
-            | Type::Error
-            | Type::TypeVariable(_, _)
-            | Type::Constant(_)
-            | Type::NamedGeneric(_, _)
-            | Type::Code
-            | Type::Forall(_, _) => (),
-
-            Type::TraitAsType(_, _, args) => {
-                for arg in args {
-                    Self::find_numeric_generics_in_type(arg, found);
-                }
-            }
-
-            Type::Array(length, element_type) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
-                    found.insert(name.to_string(), type_variable.clone());
-                }
-                Self::find_numeric_generics_in_type(element_type, found);
-            }
-
-            Type::Slice(element_type) => {
-                Self::find_numeric_generics_in_type(element_type, found);
-            }
-
-            Type::Tuple(fields) => {
-                for field in fields {
-                    Self::find_numeric_generics_in_type(field, found);
-                }
-            }
-
-            Type::Function(parameters, return_type, _env) => {
-                for parameter in parameters {
-                    Self::find_numeric_generics_in_type(parameter, found);
-                }
-                Self::find_numeric_generics_in_type(return_type, found);
-            }
-
-            Type::Struct(struct_type, generics) => {
-                for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name) = generic {
-                        if struct_type.borrow().generic_is_numeric(i) {
-                            found.insert(name.to_string(), type_variable.clone());
-                        }
-                    } else {
-                        Self::find_numeric_generics_in_type(generic, found);
-                    }
-                }
-            }
-            Type::Alias(alias, generics) => {
-                for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name) = generic {
-                        if alias.borrow().generic_is_numeric(i) {
-                            found.insert(name.to_string(), type_variable.clone());
-                        }
-                    } else {
-                        Self::find_numeric_generics_in_type(generic, found);
-                    }
-                }
-            }
-            Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found),
-            Type::String(length) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
-                    found.insert(name.to_string(), type_variable.clone());
-                }
-            }
-            Type::FmtString(length, fields) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
-                    found.insert(name.to_string(), type_variable.clone());
-                }
-                Self::find_numeric_generics_in_type(fields, found);
-            }
-        }
-    }
-
     fn add_trait_constraints_to_scope(&mut self, func_meta: &FuncMeta) {
         for constraint in &func_meta.trait_constraints {
             let object = constraint.typ.clone();
@@ -1190,8 +1107,23 @@ impl<'context> Elaborator<'context> {
             self.push_err(ResolverError::MutableGlobal { span });
         }
 
+        let comptime = let_stmt.comptime;
+
         self.elaborate_global_let(let_stmt, global_id);
 
+        if comptime {
+            let let_statement = self
+                .interner
+                .get_global_let_statement(global_id)
+                .expect("Let statement of global should be set by elaborate_global_let");
+
+            let mut interpreter = Interpreter::new(self.interner, &mut self.comptime_scopes);
+
+            if let Err(error) = interpreter.evaluate_let(let_statement) {
+                self.errors.push(error.into_compilation_error_pair());
+            }
+        }
+
         // Avoid defaulting the types of globals here since they may be used in any function.
         // Otherwise we may prematurely default to a Field inside the next function if this
         // global was unused there, even if it is consistently used as a u8 everywhere else.
diff --git a/compiler/noirc_frontend/src/elaborator/scope.rs b/compiler/noirc_frontend/src/elaborator/scope.rs
index 6ae43bd3c49..9fd3be0a354 100644
--- a/compiler/noirc_frontend/src/elaborator/scope.rs
+++ b/compiler/noirc_frontend/src/elaborator/scope.rs
@@ -115,10 +115,12 @@ impl<'context> Elaborator<'context> {
 
     pub fn push_scope(&mut self) {
         self.scopes.start_scope();
+        self.comptime_scopes.push(Default::default());
     }
 
     pub fn pop_scope(&mut self) {
         let scope = self.scopes.end_scope();
+        self.comptime_scopes.pop();
         self.check_for_unused_variables_in_scope_tree(scope.into());
     }
 
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 8f2f4d3911a..5bcd43da6e5 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -3,6 +3,7 @@ use noirc_errors::{Location, Span};
 use crate::{
     ast::{AssignStatement, ConstrainStatement, LValue},
     hir::{
+        comptime::Interpreter,
         resolution::errors::ResolverError,
         type_check::{Source, TypeCheckError},
     },
@@ -30,7 +31,7 @@ impl<'context> Elaborator<'context> {
             StatementKind::For(for_stmt) => self.elaborate_for(for_stmt),
             StatementKind::Break => self.elaborate_jump(true, statement.span),
             StatementKind::Continue => self.elaborate_jump(false, statement.span),
-            StatementKind::Comptime(statement) => self.elaborate_comptime(*statement),
+            StatementKind::Comptime(statement) => self.elaborate_comptime_statement(*statement),
             StatementKind::Expression(expr) => {
                 let (expr, typ) = self.elaborate_expression(expr);
                 (HirStatement::Expression(expr), typ)
@@ -438,7 +439,12 @@ impl<'context> Elaborator<'context> {
         None
     }
 
-    pub(super) fn elaborate_comptime(&self, _statement: Statement) -> (HirStatement, Type) {
-        todo!("Comptime scanning")
+    fn elaborate_comptime_statement(&mut self, statement: Statement) -> (HirStatement, Type) {
+        let span = statement.span;
+        let (hir_statement, _typ) = self.elaborate_statement(statement);
+        let mut interpreter = Interpreter::new(self.interner, &mut self.comptime_scopes);
+        let value = interpreter.evaluate_statement(hir_statement);
+        let (expr, typ) = self.inline_comptime_value(value, span);
+        (HirStatement::Expression(expr), typ)
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 3d677d8740d..d4cbdac3507 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -1,4 +1,4 @@
-use std::rc::Rc;
+use std::{collections::BTreeMap, rc::Rc};
 
 use acvm::acir::AcirField;
 use iter_extended::vecmap;
@@ -22,7 +22,7 @@ use crate::{
             HirBinaryOp, HirCallExpression, HirIdent, HirMemberAccess, HirMethodReference,
             HirPrefixExpression,
         },
-        function::FuncMeta,
+        function::{FuncMeta, Parameters},
         traits::TraitConstraint,
     },
     macros_api::{
@@ -1362,4 +1362,96 @@ impl<'context> Elaborator<'context> {
             self.generics.push((rc_name, typevar, span));
         }
     }
+
+    pub fn find_numeric_generics(
+        parameters: &Parameters,
+        return_type: &Type,
+    ) -> Vec<(String, TypeVariable)> {
+        let mut found = BTreeMap::new();
+        for (_, parameter, _) in &parameters.0 {
+            Self::find_numeric_generics_in_type(parameter, &mut found);
+        }
+        Self::find_numeric_generics_in_type(return_type, &mut found);
+        found.into_iter().collect()
+    }
+
+    fn find_numeric_generics_in_type(typ: &Type, found: &mut BTreeMap<String, TypeVariable>) {
+        match typ {
+            Type::FieldElement
+            | Type::Integer(_, _)
+            | Type::Bool
+            | Type::Unit
+            | Type::Error
+            | Type::TypeVariable(_, _)
+            | Type::Constant(_)
+            | Type::NamedGeneric(_, _)
+            | Type::Code
+            | Type::Forall(_, _) => (),
+
+            Type::TraitAsType(_, _, args) => {
+                for arg in args {
+                    Self::find_numeric_generics_in_type(arg, found);
+                }
+            }
+
+            Type::Array(length, element_type) => {
+                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                    found.insert(name.to_string(), type_variable.clone());
+                }
+                Self::find_numeric_generics_in_type(element_type, found);
+            }
+
+            Type::Slice(element_type) => {
+                Self::find_numeric_generics_in_type(element_type, found);
+            }
+
+            Type::Tuple(fields) => {
+                for field in fields {
+                    Self::find_numeric_generics_in_type(field, found);
+                }
+            }
+
+            Type::Function(parameters, return_type, _env) => {
+                for parameter in parameters {
+                    Self::find_numeric_generics_in_type(parameter, found);
+                }
+                Self::find_numeric_generics_in_type(return_type, found);
+            }
+
+            Type::Struct(struct_type, generics) => {
+                for (i, generic) in generics.iter().enumerate() {
+                    if let Type::NamedGeneric(type_variable, name) = generic {
+                        if struct_type.borrow().generic_is_numeric(i) {
+                            found.insert(name.to_string(), type_variable.clone());
+                        }
+                    } else {
+                        Self::find_numeric_generics_in_type(generic, found);
+                    }
+                }
+            }
+            Type::Alias(alias, generics) => {
+                for (i, generic) in generics.iter().enumerate() {
+                    if let Type::NamedGeneric(type_variable, name) = generic {
+                        if alias.borrow().generic_is_numeric(i) {
+                            found.insert(name.to_string(), type_variable.clone());
+                        }
+                    } else {
+                        Self::find_numeric_generics_in_type(generic, found);
+                    }
+                }
+            }
+            Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found),
+            Type::String(length) => {
+                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                    found.insert(name.to_string(), type_variable.clone());
+                }
+            }
+            Type::FmtString(length, fields) => {
+                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                    found.insert(name.to_string(), type_variable.clone());
+                }
+                Self::find_numeric_generics_in_type(fields, found);
+            }
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 34cecf0ece4..20e3fd94b7d 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -52,6 +52,12 @@ pub enum InterpreterError {
 #[allow(unused)]
 pub(super) type IResult<T> = std::result::Result<T, InterpreterError>;
 
+impl From<InterpreterError> for CompilationError {
+    fn from(error: InterpreterError) -> Self {
+        CompilationError::InterpreterError(error)
+    }
+}
+
 impl InterpreterError {
     pub fn into_compilation_error_pair(self) -> (CompilationError, fm::FileId) {
         let location = self.get_location();
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index c0aeb910f22..82e7d70141d 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -4,7 +4,7 @@ use acvm::{acir::AcirField, FieldElement};
 use im::Vector;
 use iter_extended::try_vecmap;
 use noirc_errors::Location;
-use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
+use rustc_hash::FxHashMap as HashMap;
 
 use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness};
 use crate::{
@@ -36,34 +36,18 @@ pub struct Interpreter<'interner> {
     /// Each value currently in scope in the interpreter.
     /// Each element of the Vec represents a scope with every scope together making
     /// up all currently visible definitions.
-    scopes: Vec<HashMap<DefinitionId, Value>>,
-
-    /// True if we've expanded any macros into any functions and will need
-    /// to redo name resolution & type checking for that function.
-    changed_functions: HashSet<FuncId>,
-
-    /// True if we've expanded any macros into global scope and will need
-    /// to redo name resolution & type checking for everything.
-    changed_globally: bool,
+    scopes: &'interner mut Vec<HashMap<DefinitionId, Value>>,
 
     in_loop: bool,
-
-    /// True if we're currently in a compile-time context.
-    /// If this is false code is skipped over instead of executed.
-    in_comptime_context: bool,
 }
 
 #[allow(unused)]
 impl<'a> Interpreter<'a> {
-    pub(crate) fn new(interner: &'a mut NodeInterner) -> Self {
-        Self {
-            interner,
-            scopes: vec![HashMap::default()],
-            changed_functions: HashSet::default(),
-            changed_globally: false,
-            in_loop: false,
-            in_comptime_context: false,
-        }
+    pub(crate) fn new(
+        interner: &'a mut NodeInterner,
+        scopes: &'a mut Vec<HashMap<DefinitionId, Value>>,
+    ) -> Self {
+        Self { interner, scopes, in_loop: false }
     }
 
     pub(crate) fn call_function(
@@ -468,7 +452,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    pub(super) fn evaluate_block(&mut self, mut block: HirBlockExpression) -> IResult<Value> {
+    pub fn evaluate_block(&mut self, mut block: HirBlockExpression) -> IResult<Value> {
         let last_statement = block.statements.pop();
         self.push_scope();
 
@@ -1077,7 +1061,7 @@ impl<'a> Interpreter<'a> {
         Ok(Value::Closure(lambda, environment, typ))
     }
 
-    fn evaluate_statement(&mut self, statement: StmtId) -> IResult<Value> {
+    pub fn evaluate_statement(&mut self, statement: StmtId) -> IResult<Value> {
         match self.interner.statement(&statement) {
             HirStatement::Let(let_) => self.evaluate_let(let_),
             HirStatement::Constrain(constrain) => self.evaluate_constrain(constrain),
@@ -1098,7 +1082,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    pub(super) fn evaluate_let(&mut self, let_: HirLetStatement) -> IResult<Value> {
+    pub fn evaluate_let(&mut self, let_: HirLetStatement) -> IResult<Value> {
         let rhs = self.evaluate(let_.expression)?;
         let location = self.interner.expr_location(&let_.expression);
         self.define_pattern(&let_.pattern, &let_.r#type, rhs, location)?;
@@ -1265,9 +1249,6 @@ impl<'a> Interpreter<'a> {
     }
 
     pub(super) fn evaluate_comptime(&mut self, statement: StmtId) -> IResult<Value> {
-        let was_in_comptime = std::mem::replace(&mut self.in_comptime_context, true);
-        let result = self.evaluate_statement(statement);
-        self.in_comptime_context = was_in_comptime;
-        result
+        self.evaluate_statement(statement)
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index cc6b9aa7e9c..02010b6886d 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -82,7 +82,7 @@ impl<'interner> Interpreter<'interner> {
             HirExpression::Comptime(block) => {
                 let location = self.interner.expr_location(&expr);
                 let new_expr =
-                    self.evaluate_block(block)?.into_expression(self.interner, location)?;
+                    self.evaluate_block(block)?.into_hir_expression(self.interner, location)?;
                 let new_expr = self.interner.expression(&new_expr);
                 self.interner.replace_expr(&expr, new_expr);
                 Ok(())
@@ -229,8 +229,9 @@ impl<'interner> Interpreter<'interner> {
             HirStatement::Error => Ok(()),
             HirStatement::Comptime(comptime) => {
                 let location = self.interner.statement_location(comptime);
-                let new_expr =
-                    self.evaluate_comptime(comptime)?.into_expression(self.interner, location)?;
+                let new_expr = self
+                    .evaluate_comptime(comptime)?
+                    .into_hir_expression(self.interner, location)?;
                 self.interner.replace_statement(statement, HirStatement::Expression(new_expr));
                 Ok(())
             }
@@ -249,7 +250,7 @@ impl<'interner> Interpreter<'interner> {
 
     fn inline_expression(&mut self, value: Value, expr: ExprId) -> IResult<()> {
         let location = self.interner.expr_location(&expr);
-        let new_expr = value.into_expression(self.interner, location)?;
+        let new_expr = value.into_hir_expression(self.interner, location)?;
         let new_expr = self.interner.expression(&new_expr);
         self.interner.replace_expr(&expr, new_expr);
         Ok(())
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 41475d3ccf4..43f6e21905b 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -1,5 +1,7 @@
 #![cfg(test)]
 
+use std::collections::HashMap;
+
 use noirc_errors::Location;
 
 use super::errors::InterpreterError;
@@ -9,7 +11,8 @@ use crate::hir::type_check::test::type_check_src_code;
 
 fn interpret_helper(src: &str, func_namespace: Vec<String>) -> Result<Value, InterpreterError> {
     let (mut interner, main_id) = type_check_src_code(src, func_namespace);
-    let mut interpreter = Interpreter::new(&mut interner);
+    let mut scopes = vec![HashMap::default()];
+    let mut interpreter = Interpreter::new(&mut interner, &mut scopes);
 
     let no_location = Location::dummy();
     interpreter.call_function(main_id, Vec::new(), no_location)
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 3c8b6e92445..f2ff93b8929 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -6,9 +6,13 @@ use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
 
 use crate::{
-    ast::{BlockExpression, Ident, IntegerBitSize, Signedness},
+    ast::{
+        ArrayLiteral, BlockExpression, ConstructorExpression, Ident, IntegerBitSize, Signedness,
+    },
     hir_def::expr::{HirArrayLiteral, HirConstructorExpression, HirIdent, HirLambda, ImplKind},
-    macros_api::{HirExpression, HirLiteral, NodeInterner},
+    macros_api::{
+        Expression, ExpressionKind, HirExpression, HirLiteral, Literal, NodeInterner, Path,
+    },
     node_interner::{ExprId, FuncId},
     Shared, Type,
 };
@@ -78,6 +82,108 @@ impl Value {
         self,
         interner: &mut NodeInterner,
         location: Location,
+    ) -> IResult<Expression> {
+        let kind = match self {
+            Value::Unit => ExpressionKind::Literal(Literal::Unit),
+            Value::Bool(value) => ExpressionKind::Literal(Literal::Bool(value)),
+            Value::Field(value) => ExpressionKind::Literal(Literal::Integer(value, false)),
+            Value::I8(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                ExpressionKind::Literal(Literal::Integer(value, negative))
+            }
+            Value::I16(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                ExpressionKind::Literal(Literal::Integer(value, negative))
+            }
+            Value::I32(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                ExpressionKind::Literal(Literal::Integer(value, negative))
+            }
+            Value::I64(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                ExpressionKind::Literal(Literal::Integer(value, negative))
+            }
+            Value::U8(value) => {
+                ExpressionKind::Literal(Literal::Integer((value as u128).into(), false))
+            }
+            Value::U16(value) => {
+                ExpressionKind::Literal(Literal::Integer((value as u128).into(), false))
+            }
+            Value::U32(value) => {
+                ExpressionKind::Literal(Literal::Integer((value as u128).into(), false))
+            }
+            Value::U64(value) => {
+                ExpressionKind::Literal(Literal::Integer((value as u128).into(), false))
+            }
+            Value::String(value) => ExpressionKind::Literal(Literal::Str(unwrap_rc(value))),
+            Value::Function(id, typ) => {
+                let id = interner.function_definition_id(id);
+                let impl_kind = ImplKind::NotATraitMethod;
+                let ident = HirIdent { location, id, impl_kind };
+                let expr_id = interner.push_expr(HirExpression::Ident(ident, None));
+                interner.push_expr_location(expr_id, location.span, location.file);
+                interner.push_expr_type(expr_id, typ);
+                ExpressionKind::Resolved(expr_id)
+            }
+            Value::Closure(_lambda, _env, _typ) => {
+                // TODO: How should a closure's environment be inlined?
+                let item = "Returning closures from a comptime fn";
+                return Err(InterpreterError::Unimplemented { item, location });
+            }
+            Value::Tuple(fields) => {
+                let fields = try_vecmap(fields, |field| field.into_expression(interner, location))?;
+                ExpressionKind::Tuple(fields)
+            }
+            Value::Struct(fields, typ) => {
+                let fields = try_vecmap(fields, |(name, field)| {
+                    let field = field.into_expression(interner, location)?;
+                    Ok((Ident::new(unwrap_rc(name), location.span), field))
+                })?;
+
+                let struct_type = match typ.follow_bindings() {
+                    Type::Struct(def, _) => Some(def.borrow().id),
+                    _ => return Err(InterpreterError::NonStructInConstructor { typ, location }),
+                };
+
+                // Since we've provided the struct_type, the path should be ignored.
+                let type_name = Path::from_single(String::new(), location.span);
+                ExpressionKind::Constructor(Box::new(ConstructorExpression {
+                    type_name,
+                    fields,
+                    struct_type,
+                }))
+            }
+            Value::Array(elements, _) => {
+                let elements =
+                    try_vecmap(elements, |element| element.into_expression(interner, location))?;
+                ExpressionKind::Literal(Literal::Array(ArrayLiteral::Standard(elements)))
+            }
+            Value::Slice(elements, _) => {
+                let elements =
+                    try_vecmap(elements, |element| element.into_expression(interner, location))?;
+                ExpressionKind::Literal(Literal::Slice(ArrayLiteral::Standard(elements)))
+            }
+            Value::Code(block) => ExpressionKind::Block(unwrap_rc(block)),
+            Value::Pointer(_) => {
+                return Err(InterpreterError::CannotInlineMacro { value: self, location })
+            }
+        };
+
+        Ok(Expression::new(kind, location.span))
+    }
+
+    pub(crate) fn into_hir_expression(
+        self,
+        interner: &mut NodeInterner,
+        location: Location,
     ) -> IResult<ExprId> {
         let typ = self.get_type().into_owned();
 
@@ -133,12 +239,13 @@ impl Value {
                 return Err(InterpreterError::Unimplemented { item, location });
             }
             Value::Tuple(fields) => {
-                let fields = try_vecmap(fields, |field| field.into_expression(interner, location))?;
+                let fields =
+                    try_vecmap(fields, |field| field.into_hir_expression(interner, location))?;
                 HirExpression::Tuple(fields)
             }
             Value::Struct(fields, typ) => {
                 let fields = try_vecmap(fields, |(name, field)| {
-                    let field = field.into_expression(interner, location)?;
+                    let field = field.into_hir_expression(interner, location)?;
                     Ok((Ident::new(unwrap_rc(name), location.span), field))
                 })?;
 
@@ -154,13 +261,15 @@ impl Value {
                 })
             }
             Value::Array(elements, _) => {
-                let elements =
-                    try_vecmap(elements, |elements| elements.into_expression(interner, location))?;
+                let elements = try_vecmap(elements, |element| {
+                    element.into_hir_expression(interner, location)
+                })?;
                 HirExpression::Literal(HirLiteral::Array(HirArrayLiteral::Standard(elements)))
             }
             Value::Slice(elements, _) => {
-                let elements =
-                    try_vecmap(elements, |elements| elements.into_expression(interner, location))?;
+                let elements = try_vecmap(elements, |element| {
+                    element.into_hir_expression(interner, location)
+                })?;
                 HirExpression::Literal(HirLiteral::Slice(HirArrayLiteral::Standard(elements)))
             }
             Value::Code(block) => HirExpression::Unquote(unwrap_rc(block)),
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 05147af5459..096bab2b47e 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -548,7 +548,8 @@ impl ResolvedModule {
     /// Evaluate all `comptime` expressions in this module
     fn evaluate_comptime(&mut self, interner: &mut NodeInterner) {
         if self.count_errors() == 0 {
-            let mut interpreter = Interpreter::new(interner);
+            let mut scopes = vec![HashMap::default()];
+            let mut interpreter = Interpreter::new(interner, &mut scopes);
 
             for (_file, global) in &self.globals {
                 if let Err(error) = interpreter.scan_global(*global) {
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 35ba964c499..8f5e99bacb9 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1637,6 +1637,9 @@ impl<'a> Resolver<'a> {
             // The quoted expression isn't resolved since we don't want errors if variables aren't defined
             ExpressionKind::Quote(block) => HirExpression::Quote(block),
             ExpressionKind::Comptime(block) => HirExpression::Comptime(self.resolve_block(block)),
+            ExpressionKind::Resolved(_) => unreachable!(
+                "ExpressionKind::Resolved should only be emitted by the comptime interpreter"
+            ),
         };
 
         // If these lines are ever changed, make sure to change the early return
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index e5b30f99b7b..9a704717ade 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -171,6 +171,9 @@ pub(crate) fn rewrite(
             format!("comptime {}", rewrite_block(visitor, block, span))
         }
         ExpressionKind::Error => unreachable!(),
+        ExpressionKind::Resolved(_) => {
+            unreachable!("ExpressionKind::Resolved should only emitted by the comptime interpreter")
+        }
     }
 }
 

From 6d3e732e06033b53506656acdd3d7759bd27f106 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Tue, 4 Jun 2024 13:39:08 -0400
Subject: [PATCH 334/416] feat: support casting in globals (#5164)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5160

## Summary\*

Adds a case for casts in comptime globals

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 .../noirc_frontend/src/elaborator/types.rs    | 12 ++++++++
 .../noirc_frontend/src/hir/comptime/errors.rs |  2 +-
 .../src/hir/comptime/interpreter.rs           | 29 +++++++++++++------
 .../noirc_frontend/src/hir/comptime/value.rs  | 19 +++++++++++-
 .../src/hir/resolution/errors.rs              |  5 +++-
 .../src/hir/resolution/resolver.rs            | 17 ++++++++++-
 .../src/hir/type_check/errors.rs              |  2 +-
 .../cast_and_shift_global/Nargo.toml          |  7 +++++
 .../cast_and_shift_global/Prover.toml         |  0
 .../cast_and_shift_global/src/main.nr         |  8 +++++
 10 files changed, 87 insertions(+), 14 deletions(-)
 create mode 100644 test_programs/execution_success/cast_and_shift_global/Nargo.toml
 create mode 100644 test_programs/execution_success/cast_and_shift_global/Prover.toml
 create mode 100644 test_programs/execution_success/cast_and_shift_global/src/main.nr

diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index d4cbdac3507..a106f6687df 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -10,6 +10,7 @@ use crate::{
         UnresolvedTypeExpression,
     },
     hir::{
+        comptime::{Interpreter, Value},
         def_map::ModuleDefId,
         resolution::{
             errors::ResolverError,
@@ -498,6 +499,17 @@ impl<'context> Elaborator<'context> {
                     BinaryOpKind::Modulo => Ok(lhs % rhs),
                 }
             }
+            HirExpression::Cast(cast) => {
+                let lhs = self.try_eval_array_length_id_with_fuel(cast.lhs, span, fuel - 1)?;
+                let lhs_value = Value::Field(lhs.into());
+                let evaluated_value =
+                    Interpreter::evaluate_cast_one_step(&cast, rhs, lhs_value, self.interner)
+                        .map_err(|error| Some(ResolverError::ArrayLengthInterpreter { error }))?;
+
+                evaluated_value
+                    .to_u128()
+                    .ok_or_else(|| Some(ResolverError::InvalidArrayLengthExpr { span }))
+            }
             _other => Err(Some(ResolverError::InvalidArrayLengthExpr { span })),
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 20e3fd94b7d..7b38f2fd32e 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -5,7 +5,7 @@ use noirc_errors::{CustomDiagnostic, Location};
 use super::value::Value;
 
 /// The possible errors that can halt the interpreter.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum InterpreterError {
     ArgumentCountMismatch { expected: usize, actual: usize, location: Location },
     TypeMismatch { expected: Type, value: Value, location: Location },
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 82e7d70141d..314ea26e52c 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -290,7 +290,7 @@ impl<'a> Interpreter<'a> {
             HirExpression::MemberAccess(access) => self.evaluate_access(access, id),
             HirExpression::Call(call) => self.evaluate_call(call, id),
             HirExpression::MethodCall(call) => self.evaluate_method_call(call, id),
-            HirExpression::Cast(cast) => self.evaluate_cast(cast, id),
+            HirExpression::Cast(cast) => self.evaluate_cast(&cast, id),
             HirExpression::If(if_) => self.evaluate_if(if_, id),
             HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
@@ -929,7 +929,18 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    fn evaluate_cast(&mut self, cast: HirCastExpression, id: ExprId) -> IResult<Value> {
+    fn evaluate_cast(&mut self, cast: &HirCastExpression, id: ExprId) -> IResult<Value> {
+        let evaluated_lhs = self.evaluate(cast.lhs)?;
+        Self::evaluate_cast_one_step(cast, id, evaluated_lhs, self.interner)
+    }
+
+    /// evaluate_cast without recursion
+    pub fn evaluate_cast_one_step(
+        cast: &HirCastExpression,
+        id: ExprId,
+        evaluated_lhs: Value,
+        interner: &NodeInterner,
+    ) -> IResult<Value> {
         macro_rules! signed_int_to_field {
             ($x:expr) => {{
                 // Need to convert the signed integer to an i128 before
@@ -943,7 +954,7 @@ impl<'a> Interpreter<'a> {
             }};
         }
 
-        let (mut lhs, lhs_is_negative) = match self.evaluate(cast.lhs)? {
+        let (mut lhs, lhs_is_negative) = match evaluated_lhs {
             Value::Field(value) => (value, false),
             Value::U8(value) => ((value as u128).into(), false),
             Value::U16(value) => ((value as u128).into(), false),
@@ -957,7 +968,7 @@ impl<'a> Interpreter<'a> {
                 (if value { FieldElement::one() } else { FieldElement::zero() }, false)
             }
             value => {
-                let location = self.interner.expr_location(&id);
+                let location = interner.expr_location(&id);
                 return Err(InterpreterError::NonNumericCasted { value, location });
             }
         };
@@ -982,8 +993,8 @@ impl<'a> Interpreter<'a> {
             }
             Type::Integer(sign, bit_size) => match (sign, bit_size) {
                 (Signedness::Unsigned, IntegerBitSize::One) => {
-                    let location = self.interner.expr_location(&id);
-                    Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
+                    let location = interner.expr_location(&id);
+                    Err(InterpreterError::TypeUnsupported { typ: cast.r#type.clone(), location })
                 }
                 (Signedness::Unsigned, IntegerBitSize::Eight) => cast_to_int!(lhs, to_u128, u8, U8),
                 (Signedness::Unsigned, IntegerBitSize::Sixteen) => {
@@ -996,8 +1007,8 @@ impl<'a> Interpreter<'a> {
                     cast_to_int!(lhs, to_u128, u64, U64)
                 }
                 (Signedness::Signed, IntegerBitSize::One) => {
-                    let location = self.interner.expr_location(&id);
-                    Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
+                    let location = interner.expr_location(&id);
+                    Err(InterpreterError::TypeUnsupported { typ: cast.r#type.clone(), location })
                 }
                 (Signedness::Signed, IntegerBitSize::Eight) => cast_to_int!(lhs, to_i128, i8, I8),
                 (Signedness::Signed, IntegerBitSize::Sixteen) => {
@@ -1012,7 +1023,7 @@ impl<'a> Interpreter<'a> {
             },
             Type::Bool => Ok(Value::Bool(!lhs.is_zero() || lhs_is_negative)),
             typ => {
-                let location = self.interner.expr_location(&id);
+                let location = interner.expr_location(&id);
                 Err(InterpreterError::CastToNonNumericType { typ, location })
             }
         }
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index f2ff93b8929..6cf0a1d9011 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -1,6 +1,6 @@
 use std::{borrow::Cow, rc::Rc};
 
-use acvm::FieldElement;
+use acvm::{AcirField, FieldElement};
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
@@ -283,6 +283,23 @@ impl Value {
         interner.push_expr_type(id, typ);
         Ok(id)
     }
+
+    /// Converts any unsigned `Value` into a `u128`.
+    /// Returns `None` for negative integers.
+    pub(crate) fn to_u128(&self) -> Option<u128> {
+        match self {
+            Self::Field(value) => Some(value.to_u128()),
+            Self::I8(value) => (*value >= 0).then_some(*value as u128),
+            Self::I16(value) => (*value >= 0).then_some(*value as u128),
+            Self::I32(value) => (*value >= 0).then_some(*value as u128),
+            Self::I64(value) => (*value >= 0).then_some(*value as u128),
+            Self::U8(value) => Some(*value as u128),
+            Self::U16(value) => Some(*value as u128),
+            Self::U32(value) => Some(*value as u128),
+            Self::U64(value) => Some(*value as u128),
+            _ => None,
+        }
+    }
 }
 
 /// Unwraps an Rc value without cloning the inner value if the reference count is 1. Clones otherwise.
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index fa4ea96316a..e8985deda11 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -2,7 +2,7 @@ pub use noirc_errors::Span;
 use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic};
 use thiserror::Error;
 
-use crate::{ast::Ident, parser::ParserError, Type};
+use crate::{ast::Ident, hir::comptime::InterpreterError, parser::ParserError, Type};
 
 use super::import::PathResolutionError;
 
@@ -94,6 +94,8 @@ pub enum ResolverError {
     NoPredicatesAttributeOnUnconstrained { ident: Ident },
     #[error("#[fold] attribute is only allowed on constrained functions")]
     FoldAttributeOnUnconstrained { ident: Ident },
+    #[error("Invalid array length construction")]
+    ArrayLengthInterpreter { error: InterpreterError },
 }
 
 impl ResolverError {
@@ -386,6 +388,7 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diag.add_note("The `#[fold]` attribute specifies whether a constrained function should be treated as a separate circuit rather than inlined into the program entry point".to_owned());
                 diag
             }
+            ResolverError::ArrayLengthInterpreter { error } => Diagnostic::from(error),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 8f5e99bacb9..8f15d7688de 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -36,7 +36,11 @@ use crate::ast::{
 };
 use crate::graph::CrateId;
 use crate::hir::def_map::{ModuleDefId, TryFromModuleDefId, MAIN_FUNCTION};
-use crate::hir::{def_map::CrateDefMap, resolution::path_resolver::PathResolver};
+use crate::hir::{
+    comptime::{Interpreter, Value},
+    def_map::CrateDefMap,
+    resolution::path_resolver::PathResolver,
+};
 use crate::hir_def::stmt::{HirAssignStatement, HirForStatement, HirLValue, HirPattern};
 use crate::node_interner::{
     DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, NodeInterner, StmtId,
@@ -2067,6 +2071,17 @@ impl<'a> Resolver<'a> {
                     BinaryOpKind::Modulo => Ok(lhs % rhs),
                 }
             }
+            HirExpression::Cast(cast) => {
+                let lhs = self.try_eval_array_length_id_with_fuel(cast.lhs, span, fuel - 1)?;
+                let lhs_value = Value::Field(lhs.into());
+                let evaluated_value =
+                    Interpreter::evaluate_cast_one_step(&cast, rhs, lhs_value, self.interner)
+                        .map_err(|error| Some(ResolverError::ArrayLengthInterpreter { error }))?;
+
+                evaluated_value
+                    .to_u128()
+                    .ok_or_else(|| Some(ResolverError::InvalidArrayLengthExpr { span }))
+            }
             _other => Err(Some(ResolverError::InvalidArrayLengthExpr { span })),
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 549d8138f1d..0d8a9f3e717 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -28,7 +28,7 @@ pub enum Source {
     Return(FunctionReturnType, Span),
 }
 
-#[derive(Error, Debug, Clone, PartialEq, Eq)]
+#[derive(Error, Debug, Clone)]
 pub enum TypeCheckError {
     #[error("Operator {op:?} cannot be used in a {place:?}")]
     OpCannotBeUsed { op: HirBinaryOp, place: &'static str, span: Span },
diff --git a/test_programs/execution_success/cast_and_shift_global/Nargo.toml b/test_programs/execution_success/cast_and_shift_global/Nargo.toml
new file mode 100644
index 00000000000..92af6ed8333
--- /dev/null
+++ b/test_programs/execution_success/cast_and_shift_global/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "cast_and_shift_global"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/cast_and_shift_global/Prover.toml b/test_programs/execution_success/cast_and_shift_global/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/execution_success/cast_and_shift_global/src/main.nr b/test_programs/execution_success/cast_and_shift_global/src/main.nr
new file mode 100644
index 00000000000..577de78465c
--- /dev/null
+++ b/test_programs/execution_success/cast_and_shift_global/src/main.nr
@@ -0,0 +1,8 @@
+global THREE: u64 = 3;
+global EIGHT: u64 = 1 << THREE as u8;
+global SEVEN: u64 = EIGHT - 1;
+
+fn main() {
+    assert([0; EIGHT] == [0; 8]);
+    assert([0; SEVEN] == [0; 7]);
+}

From b8ba9e65bde5f11de579b5a5bc7d7af60fa4ee20 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 5 Jun 2024 02:16:15 +0100
Subject: [PATCH 335/416] chore: loosen trait bounds on impls depending on
 `AcirField` (#5115)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR is some code-organisation after #5114, rather than having a
single big impl with an `AcirField` bound we can break these down into
smaller impls with looser bounds.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acir/src/circuit/mod.rs             |   4 +-
 .../acir/src/native_types/expression/mod.rs   | 130 +---
 .../src/native_types/expression/ordering.rs   |   8 +-
 acvm-repo/acir/src/native_types/witness.rs    |   4 -
 acvm-repo/acir_field/src/field_element.rs     | 543 +++++++++++++++++
 acvm-repo/acir_field/src/generic_ark.rs       | 565 +-----------------
 acvm-repo/acir_field/src/lib.rs               |   8 +-
 .../acvm/src/compiler/transformers/csat.rs    |  57 +-
 acvm-repo/acvm/src/pwg/mod.rs                 |   2 +-
 acvm-repo/brillig_vm/src/memory.rs            |  44 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs |  12 +-
 11 files changed, 682 insertions(+), 695 deletions(-)
 create mode 100644 acvm-repo/acir_field/src/field_element.rs

diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index 7632afda423..7f3c1890717 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -204,7 +204,7 @@ impl FromStr for OpcodeLocation {
     }
 }
 
-impl<F: AcirField> Circuit<F> {
+impl<F> Circuit<F> {
     pub fn num_vars(&self) -> u32 {
         self.current_witness_index + 1
     }
@@ -425,7 +425,7 @@ mod tests {
         };
         let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
-        fn read_write<F: AcirField + Serialize + for<'a> Deserialize<'a>>(
+        fn read_write<F: Serialize + for<'a> Deserialize<'a>>(
             program: Program<F>,
         ) -> (Program<F>, Program<F>) {
             let bytes = Program::serialize_program(&program);
diff --git a/acvm-repo/acir/src/native_types/expression/mod.rs b/acvm-repo/acir/src/native_types/expression/mod.rs
index b34862429e7..1feda5703c8 100644
--- a/acvm-repo/acir/src/native_types/expression/mod.rs
+++ b/acvm-repo/acir/src/native_types/expression/mod.rs
@@ -42,29 +42,12 @@ impl<F: AcirField> std::fmt::Display for Expression<F> {
     }
 }
 
-impl<F: AcirField> Expression<F> {
-    // TODO: possibly remove, and move to noir repo.
-    pub const fn can_defer_constraint(&self) -> bool {
-        false
-    }
-
+impl<F> Expression<F> {
     /// Returns the number of multiplication terms
     pub fn num_mul_terms(&self) -> usize {
         self.mul_terms.len()
     }
 
-    pub fn from_field(q_c: F) -> Self {
-        Self { q_c, ..Default::default() }
-    }
-
-    pub fn one() -> Self {
-        Self::from_field(F::one())
-    }
-
-    pub fn zero() -> Self {
-        Self::default()
-    }
-
     /// Adds a new linear term to the `Expression`.
     pub fn push_addition_term(&mut self, coefficient: F, variable: Witness) {
         self.linear_combinations.push((coefficient, variable));
@@ -85,6 +68,19 @@ impl<F: AcirField> Expression<F> {
         self.mul_terms.is_empty() && self.linear_combinations.is_empty()
     }
 
+    /// Returns a `FieldElement` if the expression represents a constant polynomial.
+    /// Otherwise returns `None`.
+    ///
+    /// Examples:
+    /// - f(x,y) = x would return `None`
+    /// - f(x,y) = x + 6 would return `None`
+    /// - f(x,y) = 2*y + 6 would return `None`
+    /// - f(x,y) = x + y would return `None`
+    /// - f(x,y) = 5 would return `FieldElement(5)`
+    pub fn to_const(&self) -> Option<&F> {
+        self.is_const().then_some(&self.q_c)
+    }
+
     /// Returns `true` if highest degree term in the expression is one or less.
     ///
     /// - `mul_term` in an expression contains degree-2 terms
@@ -122,21 +118,29 @@ impl<F: AcirField> Expression<F> {
         self.is_linear() && self.linear_combinations.len() == 1
     }
 
+    /// Sorts opcode in a deterministic order
+    /// XXX: We can probably make this more efficient by sorting on each phase. We only care if it is deterministic
+    pub fn sort(&mut self) {
+        self.mul_terms.sort_by(|a, b| a.1.cmp(&b.1).then(a.2.cmp(&b.2)));
+        self.linear_combinations.sort_by(|a, b| a.1.cmp(&b.1));
+    }
+}
+
+impl<F: AcirField> Expression<F> {
+    pub fn from_field(q_c: F) -> Self {
+        Self { q_c, ..Default::default() }
+    }
+
+    pub fn zero() -> Self {
+        Self::default()
+    }
+
     pub fn is_zero(&self) -> bool {
         *self == Self::zero()
     }
 
-    /// Returns a `FieldElement` if the expression represents a constant polynomial.
-    /// Otherwise returns `None`.
-    ///
-    /// Examples:
-    /// - f(x,y) = x would return `None`
-    /// - f(x,y) = x + 6 would return `None`
-    /// - f(x,y) = 2*y + 6 would return `None`
-    /// - f(x,y) = x + y would return `None`
-    /// - f(x,y) = 5 would return `FieldElement(5)`
-    pub fn to_const(&self) -> Option<F> {
-        self.is_const().then_some(self.q_c)
+    pub fn one() -> Self {
+        Self::from_field(F::one())
     }
 
     /// Returns a `Witness` if the `Expression` can be represented as a degree-1
@@ -161,74 +165,6 @@ impl<F: AcirField> Expression<F> {
         None
     }
 
-    /// Sorts opcode in a deterministic order
-    /// XXX: We can probably make this more efficient by sorting on each phase. We only care if it is deterministic
-    pub fn sort(&mut self) {
-        self.mul_terms.sort_by(|a, b| a.1.cmp(&b.1).then(a.2.cmp(&b.2)));
-        self.linear_combinations.sort_by(|a, b| a.1.cmp(&b.1));
-    }
-
-    /// Checks if this expression can fit into one arithmetic identity
-    /// TODO: This needs to be reworded, arithmetic identity only makes sense in the context
-    /// TODO of PLONK, whereas we want expressions to be generic.
-    /// TODO: We just need to reword it to say exactly what its doing and
-    /// TODO then reference the fact that this is what plonk will accept.
-    /// TODO alternatively, we can define arithmetic identity in the context of expressions
-    /// TODO and then reference that.
-    pub fn fits_in_one_identity(&self, width: usize) -> bool {
-        // A Polynomial with more than one mul term cannot fit into one opcode
-        if self.mul_terms.len() > 1 {
-            return false;
-        };
-        // A Polynomial with more terms than fan-in cannot fit within a single opcode
-        if self.linear_combinations.len() > width {
-            return false;
-        }
-
-        // A polynomial with no mul term and a fan-in that fits inside of the width can fit into a single opcode
-        if self.mul_terms.is_empty() {
-            return true;
-        }
-
-        // A polynomial with width-2 fan-in terms and a single non-zero mul term can fit into one opcode
-        // Example: Axy + Dz . Notice, that the mul term places a constraint on the first two terms, but not the last term
-        // XXX: This would change if our arithmetic polynomial equation was changed to Axyz for example, but for now it is not.
-        if self.linear_combinations.len() <= (width - 2) {
-            return true;
-        }
-
-        // We now know that we have a single mul term. We also know that the mul term must match up with two other terms
-        // A polynomial whose mul terms are non zero which do not match up with two terms in the fan-in cannot fit into one opcode
-        // An example of this is: Axy + Bx + Cy + ...
-        // Notice how the bivariate monomial xy has two univariate monomials with their respective coefficients
-        // XXX: note that if x or y is zero, then we could apply a further optimization, but this would be done in another algorithm.
-        // It would be the same as when we have zero coefficients - Can only work if wire is constrained to be zero publicly
-        let mul_term = &self.mul_terms[0];
-
-        // The coefficient should be non-zero, as this method is ran after the compiler removes all zero coefficient terms
-        assert_ne!(mul_term.0, F::zero());
-
-        let mut found_x = false;
-        let mut found_y = false;
-
-        for term in self.linear_combinations.iter() {
-            let witness = &term.1;
-            let x = &mul_term.1;
-            let y = &mul_term.2;
-            if witness == x {
-                found_x = true;
-            };
-            if witness == y {
-                found_y = true;
-            };
-            if found_x & found_y {
-                break;
-            }
-        }
-
-        found_x & found_y
-    }
-
     /// Returns `self + k*b`
     pub fn add_mul(&self, k: F, b: &Self) -> Self {
         if k.is_zero() {
diff --git a/acvm-repo/acir/src/native_types/expression/ordering.rs b/acvm-repo/acir/src/native_types/expression/ordering.rs
index b0e5e88454f..f1d217b3bd9 100644
--- a/acvm-repo/acir/src/native_types/expression/ordering.rs
+++ b/acvm-repo/acir/src/native_types/expression/ordering.rs
@@ -1,5 +1,3 @@
-use acir_field::AcirField;
-
 use crate::native_types::Witness;
 use std::cmp::Ordering;
 
@@ -8,7 +6,7 @@ use super::Expression;
 // TODO: It's undecided whether `Expression` should implement `Ord/PartialOrd`.
 // This is currently used in ACVM in the compiler.
 
-impl<F: AcirField> Ord for Expression<F> {
+impl<F: Ord> Ord for Expression<F> {
     fn cmp(&self, other: &Self) -> Ordering {
         let mut i1 = self.get_max_idx();
         let mut i2 = other.get_max_idx();
@@ -25,7 +23,7 @@ impl<F: AcirField> Ord for Expression<F> {
     }
 }
 
-impl<F: AcirField> PartialOrd for Expression<F> {
+impl<F: Ord> PartialOrd for Expression<F> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
@@ -37,7 +35,7 @@ struct WitnessIdx {
     second_term: bool,
 }
 
-impl<F: AcirField> Expression<F> {
+impl<F: Ord> Expression<F> {
     fn get_max_idx(&self) -> WitnessIdx {
         WitnessIdx {
             linear: self.linear_combinations.len(),
diff --git a/acvm-repo/acir/src/native_types/witness.rs b/acvm-repo/acir/src/native_types/witness.rs
index 3e9beb510bc..a570968f948 100644
--- a/acvm-repo/acir/src/native_types/witness.rs
+++ b/acvm-repo/acir/src/native_types/witness.rs
@@ -17,10 +17,6 @@ impl Witness {
         // This is safe as long as the architecture is 32bits minimum
         self.0 as usize
     }
-
-    pub const fn can_defer_constraint(&self) -> bool {
-        true
-    }
 }
 
 impl From<u32> for Witness {
diff --git a/acvm-repo/acir_field/src/field_element.rs b/acvm-repo/acir_field/src/field_element.rs
new file mode 100644
index 00000000000..a45e8c9946a
--- /dev/null
+++ b/acvm-repo/acir_field/src/field_element.rs
@@ -0,0 +1,543 @@
+use ark_ff::PrimeField;
+use ark_ff::Zero;
+use num_bigint::BigUint;
+use serde::{Deserialize, Serialize};
+use std::borrow::Cow;
+use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
+
+use crate::AcirField;
+
+// XXX: Switch out for a trait and proper implementations
+// This implementation is in-efficient, can definitely remove hex usage and Iterator instances for trivial functionality
+#[derive(Default, Clone, Copy, Eq, PartialOrd, Ord)]
+pub struct FieldElement<F: PrimeField>(F);
+
+impl<F: PrimeField> std::fmt::Display for FieldElement<F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        // First check if the number is zero
+        //
+        let number = BigUint::from_bytes_be(&self.to_be_bytes());
+        if number == BigUint::zero() {
+            return write!(f, "0");
+        }
+        // Check if the negative version is smaller to represent
+        //
+        let minus_number = BigUint::from_bytes_be(&(self.neg()).to_be_bytes());
+        let (smaller_repr, is_negative) =
+            if minus_number.to_string().len() < number.to_string().len() {
+                (minus_number, true)
+            } else {
+                (number, false)
+            };
+        if is_negative {
+            write!(f, "-")?;
+        }
+
+        // Number of bits needed to represent the smaller representation
+        let num_bits = smaller_repr.bits();
+
+        // Check if the number represents a power of 2
+        if smaller_repr.count_ones() == 1 {
+            let mut bit_index = 0;
+            for i in 0..num_bits {
+                if smaller_repr.bit(i) {
+                    bit_index = i;
+                    break;
+                }
+            }
+            return match bit_index {
+                0 => write!(f, "1"),
+                1 => write!(f, "2"),
+                2 => write!(f, "4"),
+                3 => write!(f, "8"),
+                _ => write!(f, "2{}", superscript(bit_index)),
+            };
+        }
+
+        // Check if number is a multiple of a power of 2.
+        // This is used because when computing the quotient
+        // we usually have numbers in the form 2^t * q + r
+        // We focus on 2^64, 2^32, 2^16, 2^8, 2^4 because
+        // they are common. We could extend this to a more
+        // general factorization strategy, but we pay in terms of CPU time
+        let mul_sign = "×";
+        for power in [64, 32, 16, 8, 4] {
+            let power_of_two = BigUint::from(2_u128).pow(power);
+            if &smaller_repr % &power_of_two == BigUint::zero() {
+                return write!(
+                    f,
+                    "2{}{}{}",
+                    superscript(power as u64),
+                    mul_sign,
+                    smaller_repr / &power_of_two,
+                );
+            }
+        }
+        write!(f, "{smaller_repr}")
+    }
+}
+
+impl<F: PrimeField> std::fmt::Debug for FieldElement<F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
+impl<F: PrimeField> std::hash::Hash for FieldElement<F> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write(&self.to_be_bytes());
+    }
+}
+
+impl<F: PrimeField> PartialEq for FieldElement<F> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_be_bytes() == other.to_be_bytes()
+    }
+}
+
+impl<F: PrimeField> From<i128> for FieldElement<F> {
+    fn from(mut a: i128) -> FieldElement<F> {
+        let mut negative = false;
+        if a < 0 {
+            a = -a;
+            negative = true;
+        }
+
+        let mut result = match F::from_str(&a.to_string()) {
+            Ok(result) => result,
+            Err(_) => panic!("Cannot convert i128 as a string to a field element"),
+        };
+
+        if negative {
+            result = -result;
+        }
+        FieldElement(result)
+    }
+}
+
+impl<T: ark_ff::PrimeField> Serialize for FieldElement<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.to_hex().serialize(serializer)
+    }
+}
+
+impl<'de, T: ark_ff::PrimeField> Deserialize<'de> for FieldElement<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: Cow<'de, str> = Deserialize::deserialize(deserializer)?;
+        match Self::from_hex(&s) {
+            Some(value) => Ok(value),
+            None => Err(serde::de::Error::custom(format!("Invalid hex for FieldElement: {s}",))),
+        }
+    }
+}
+
+impl<F: PrimeField> From<u128> for FieldElement<F> {
+    fn from(a: u128) -> FieldElement<F> {
+        let result = match F::from_str(&a.to_string()) {
+            Ok(result) => result,
+            Err(_) => panic!("Cannot convert u128 as a string to a field element"),
+        };
+        FieldElement(result)
+    }
+}
+
+impl<F: PrimeField> From<usize> for FieldElement<F> {
+    fn from(a: usize) -> FieldElement<F> {
+        FieldElement::from(a as u128)
+    }
+}
+
+impl<F: PrimeField> From<bool> for FieldElement<F> {
+    fn from(boolean: bool) -> FieldElement<F> {
+        if boolean {
+            FieldElement::one()
+        } else {
+            FieldElement::zero()
+        }
+    }
+}
+
+impl<F: PrimeField> FieldElement<F> {
+    pub fn from_repr(field: F) -> Self {
+        Self(field)
+    }
+
+    // XXX: This method is used while this field element
+    // implementation is not generic.
+    pub fn into_repr(self) -> F {
+        self.0
+    }
+
+    fn is_negative(&self) -> bool {
+        self.neg().num_bits() < self.num_bits()
+    }
+
+    fn fits_in_u128(&self) -> bool {
+        self.num_bits() <= 128
+    }
+
+    /// Returns None, if the string is not a canonical
+    /// representation of a field element; less than the order
+    /// or if the hex string is invalid.
+    /// This method can be used for both hex and decimal representations.
+    pub fn try_from_str(input: &str) -> Option<FieldElement<F>> {
+        if input.contains('x') {
+            return FieldElement::from_hex(input);
+        }
+
+        let fr = F::from_str(input).ok()?;
+        Some(FieldElement(fr))
+    }
+
+    // mask_to methods will not remove any bytes from the field
+    // they are simply zeroed out
+    // Whereas truncate_to will remove those bits and make the byte array smaller
+    fn mask_to_be_bytes(&self, num_bits: u32) -> Vec<u8> {
+        let mut bytes = self.to_be_bytes();
+        mask_vector_le(&mut bytes, num_bits as usize);
+        bytes
+    }
+
+    fn bits(&self) -> Vec<bool> {
+        fn byte_to_bit(byte: u8) -> Vec<bool> {
+            let mut bits = Vec::with_capacity(8);
+            for index in (0..=7).rev() {
+                bits.push((byte & (1 << index)) >> index == 1);
+            }
+            bits
+        }
+
+        let bytes = self.to_be_bytes();
+        let mut bits = Vec::with_capacity(bytes.len() * 8);
+        for byte in bytes {
+            bits.extend(byte_to_bit(byte));
+        }
+        bits
+    }
+
+    fn and_xor(&self, rhs: &FieldElement<F>, num_bits: u32, is_xor: bool) -> FieldElement<F> {
+        // XXX: Gadgets like SHA256 need to have their input be a multiple of 8
+        // This is not a restriction caused by SHA256, as it works on bits
+        // but most backends assume bytes.
+        // We could implicitly pad, however this may not be intuitive for users.
+        // assert!(
+        //     num_bits % 8 == 0,
+        //     "num_bits is not a multiple of 8, it is {}",
+        //     num_bits
+        // );
+
+        let lhs_bytes = self.mask_to_be_bytes(num_bits);
+        let rhs_bytes = rhs.mask_to_be_bytes(num_bits);
+
+        let and_byte_arr: Vec<_> = lhs_bytes
+            .into_iter()
+            .zip(rhs_bytes)
+            .map(|(lhs, rhs)| if is_xor { lhs ^ rhs } else { lhs & rhs })
+            .collect();
+
+        FieldElement::from_be_bytes_reduce(&and_byte_arr)
+    }
+}
+
+impl<F: PrimeField> AcirField for FieldElement<F> {
+    fn one() -> FieldElement<F> {
+        FieldElement(F::one())
+    }
+    fn zero() -> FieldElement<F> {
+        FieldElement(F::zero())
+    }
+
+    fn is_zero(&self) -> bool {
+        self == &Self::zero()
+    }
+    fn is_one(&self) -> bool {
+        self == &Self::one()
+    }
+
+    fn pow(&self, exponent: &Self) -> Self {
+        FieldElement(self.0.pow(exponent.0.into_bigint()))
+    }
+
+    /// Maximum number of bits needed to represent a field element
+    /// This is not the amount of bits being used to represent a field element
+    /// Example, you only need 254 bits to represent a field element in BN256
+    /// But the representation uses 256 bits, so the top two bits are always zero
+    /// This method would return 254
+    fn max_num_bits() -> u32 {
+        F::MODULUS_BIT_SIZE
+    }
+
+    /// Maximum numbers of bytes needed to represent a field element
+    /// We are not guaranteed that the number of bits being used to represent a field element
+    /// will always be divisible by 8. If the case that it is not, we add one to the max number of bytes
+    /// For example, a max bit size of 254 would give a max byte size of 32.
+    fn max_num_bytes() -> u32 {
+        let num_bytes = Self::max_num_bits() / 8;
+        if Self::max_num_bits() % 8 == 0 {
+            num_bytes
+        } else {
+            num_bytes + 1
+        }
+    }
+
+    fn modulus() -> BigUint {
+        F::MODULUS.into()
+    }
+
+    /// This is the number of bits required to represent this specific field element
+    fn num_bits(&self) -> u32 {
+        let bits = self.bits();
+        // Iterate the number of bits and pop off all leading zeroes
+        let iter = bits.iter().skip_while(|x| !(**x));
+        // Note: count will panic if it goes over usize::MAX.
+        // This may not be suitable for devices whose usize < u16
+        iter.count() as u32
+    }
+
+    fn to_u128(self) -> u128 {
+        let bytes = self.to_be_bytes();
+        u128::from_be_bytes(bytes[16..32].try_into().unwrap())
+    }
+
+    fn try_into_u128(self) -> Option<u128> {
+        self.fits_in_u128().then(|| self.to_u128())
+    }
+
+    fn to_i128(self) -> i128 {
+        let is_negative = self.is_negative();
+        let bytes = if is_negative { self.neg() } else { self }.to_be_bytes();
+        i128::from_be_bytes(bytes[16..32].try_into().unwrap()) * if is_negative { -1 } else { 1 }
+    }
+
+    fn try_to_u64(&self) -> Option<u64> {
+        (self.num_bits() <= 64).then(|| self.to_u128() as u64)
+    }
+
+    /// Computes the inverse or returns zero if the inverse does not exist
+    /// Before using this FieldElement, please ensure that this behavior is necessary
+    fn inverse(&self) -> FieldElement<F> {
+        let inv = self.0.inverse().unwrap_or_else(F::zero);
+        FieldElement(inv)
+    }
+
+    fn to_hex(self) -> String {
+        let mut bytes = Vec::new();
+        self.0.serialize_uncompressed(&mut bytes).unwrap();
+        bytes.reverse();
+        hex::encode(bytes)
+    }
+    fn from_hex(hex_str: &str) -> Option<FieldElement<F>> {
+        let value = hex_str.strip_prefix("0x").unwrap_or(hex_str);
+        // Values of odd length require an additional "0" prefix
+        let sanitized_value =
+            if value.len() % 2 == 0 { value.to_string() } else { format!("0{}", value) };
+        let hex_as_bytes = hex::decode(sanitized_value).ok()?;
+        Some(FieldElement::from_be_bytes_reduce(&hex_as_bytes))
+    }
+
+    fn to_be_bytes(self) -> Vec<u8> {
+        // to_be_bytes! uses little endian which is why we reverse the output
+        // TODO: Add a little endian equivalent, so the caller can use whichever one
+        // TODO they desire
+        let mut bytes = Vec::new();
+        self.0.serialize_uncompressed(&mut bytes).unwrap();
+        bytes.reverse();
+        bytes
+    }
+
+    /// Converts bytes into a FieldElement and applies a
+    /// reduction if needed.
+    fn from_be_bytes_reduce(bytes: &[u8]) -> FieldElement<F> {
+        FieldElement(F::from_be_bytes_mod_order(bytes))
+    }
+
+    /// Returns the closest number of bytes to the bits specified
+    /// This method truncates
+    fn fetch_nearest_bytes(&self, num_bits: usize) -> Vec<u8> {
+        fn nearest_bytes(num_bits: usize) -> usize {
+            ((num_bits + 7) / 8) * 8
+        }
+
+        let num_bytes = nearest_bytes(num_bits);
+        let num_elements = num_bytes / 8;
+
+        let mut bytes = self.to_be_bytes();
+        bytes.reverse(); // put it in big endian format. XXX(next refactor): we should be explicit about endianness.
+
+        bytes[0..num_elements].to_vec()
+    }
+
+    fn and(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
+        self.and_xor(rhs, num_bits, false)
+    }
+    fn xor(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
+        self.and_xor(rhs, num_bits, true)
+    }
+}
+
+impl<F: PrimeField> Neg for FieldElement<F> {
+    type Output = FieldElement<F>;
+
+    fn neg(self) -> Self::Output {
+        FieldElement(-self.0)
+    }
+}
+
+impl<F: PrimeField> Mul for FieldElement<F> {
+    type Output = FieldElement<F>;
+    fn mul(mut self, rhs: FieldElement<F>) -> Self::Output {
+        self.0.mul_assign(&rhs.0);
+        FieldElement(self.0)
+    }
+}
+impl<F: PrimeField> Div for FieldElement<F> {
+    type Output = FieldElement<F>;
+    #[allow(clippy::suspicious_arithmetic_impl)]
+    fn div(self, rhs: FieldElement<F>) -> Self::Output {
+        self * rhs.inverse()
+    }
+}
+impl<F: PrimeField> Add for FieldElement<F> {
+    type Output = FieldElement<F>;
+    fn add(mut self, rhs: FieldElement<F>) -> Self::Output {
+        self.0.add_assign(&rhs.0);
+        FieldElement(self.0)
+    }
+}
+impl<F: PrimeField> AddAssign for FieldElement<F> {
+    fn add_assign(&mut self, rhs: FieldElement<F>) {
+        self.0.add_assign(&rhs.0);
+    }
+}
+
+impl<F: PrimeField> Sub for FieldElement<F> {
+    type Output = FieldElement<F>;
+    fn sub(mut self, rhs: FieldElement<F>) -> Self::Output {
+        self.0.sub_assign(&rhs.0);
+        FieldElement(self.0)
+    }
+}
+impl<F: PrimeField> SubAssign for FieldElement<F> {
+    fn sub_assign(&mut self, rhs: FieldElement<F>) {
+        self.0.sub_assign(&rhs.0);
+    }
+}
+
+fn mask_vector_le(bytes: &mut [u8], num_bits: usize) {
+    // reverse to big endian format
+    bytes.reverse();
+
+    let mask_power = num_bits % 8;
+    let array_mask_index = num_bits / 8;
+
+    for (index, byte) in bytes.iter_mut().enumerate() {
+        match index.cmp(&array_mask_index) {
+            std::cmp::Ordering::Less => {
+                // do nothing if the current index is less than
+                // the array index.
+            }
+            std::cmp::Ordering::Equal => {
+                let mask = 2u8.pow(mask_power as u32) - 1;
+                // mask the byte
+                *byte &= mask;
+            }
+            std::cmp::Ordering::Greater => {
+                // Anything greater than the array index
+                // will be set to zero
+                *byte = 0;
+            }
+        }
+    }
+    // reverse back to little endian
+    bytes.reverse();
+}
+
+// For pretty printing powers
+fn superscript(n: u64) -> String {
+    if n == 0 {
+        "⁰".to_owned()
+    } else if n == 1 {
+        "¹".to_owned()
+    } else if n == 2 {
+        "²".to_owned()
+    } else if n == 3 {
+        "³".to_owned()
+    } else if n == 4 {
+        "⁴".to_owned()
+    } else if n == 5 {
+        "⁵".to_owned()
+    } else if n == 6 {
+        "⁶".to_owned()
+    } else if n == 7 {
+        "⁷".to_owned()
+    } else if n == 8 {
+        "⁸".to_owned()
+    } else if n == 9 {
+        "⁹".to_owned()
+    } else if n >= 10 {
+        superscript(n / 10) + &superscript(n % 10)
+    } else {
+        panic!("{}", n.to_string() + " can't be converted to superscript.");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AcirField, FieldElement};
+
+    #[test]
+    fn and() {
+        let max = 10_000u32;
+
+        let num_bits = (std::mem::size_of::<u32>() * 8) as u32 - max.leading_zeros();
+
+        for x in 0..max {
+            let x = FieldElement::<ark_bn254::Fr>::from(x as i128);
+            let res = x.and(&x, num_bits);
+            assert_eq!(res.to_be_bytes(), x.to_be_bytes());
+        }
+    }
+
+    #[test]
+    fn serialize_fixed_test_vectors() {
+        // Serialized field elements from of 0, -1, -2, -3
+        let hex_strings = vec![
+            "0000000000000000000000000000000000000000000000000000000000000000",
+            "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000",
+            "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffffff",
+            "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffffe",
+        ];
+
+        for (i, string) in hex_strings.into_iter().enumerate() {
+            let minus_i_field_element = -FieldElement::<ark_bn254::Fr>::from(i as i128);
+            assert_eq!(minus_i_field_element.to_hex(), string);
+        }
+    }
+
+    #[test]
+    fn deserialize_even_and_odd_length_hex() {
+        // Test cases of (odd, even) length hex strings
+        let hex_strings =
+            vec![("0x0", "0x00"), ("0x1", "0x01"), ("0x002", "0x0002"), ("0x00003", "0x000003")];
+        for (i, case) in hex_strings.into_iter().enumerate() {
+            let i_field_element = FieldElement::<ark_bn254::Fr>::from(i as i128);
+            let odd_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.0).unwrap();
+            let even_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.1).unwrap();
+
+            assert_eq!(i_field_element, odd_field_element);
+            assert_eq!(odd_field_element, even_field_element);
+        }
+    }
+
+    #[test]
+    fn max_num_bits_smoke() {
+        let max_num_bits_bn254 = FieldElement::<ark_bn254::Fr>::max_num_bits();
+        assert_eq!(max_num_bits_bn254, 254);
+    }
+}
diff --git a/acvm-repo/acir_field/src/generic_ark.rs b/acvm-repo/acir_field/src/generic_ark.rs
index c1bc7971922..1e0215223ef 100644
--- a/acvm-repo/acir_field/src/generic_ark.rs
+++ b/acvm-repo/acir_field/src/generic_ark.rs
@@ -1,25 +1,21 @@
-use ark_ff::PrimeField;
-use ark_ff::Zero;
 use num_bigint::BigUint;
-use serde::{Deserialize, Serialize};
-use std::borrow::Cow;
 
 /// This trait is extremely unstable and WILL have breaking changes.
 pub trait AcirField:
     std::marker::Sized
-    + Display
-    + Debug
+    + std::fmt::Display
+    + std::fmt::Debug
     + Default
     + Clone
     + Copy
-    + Neg<Output = Self>
-    + Add<Self, Output = Self>
-    + Sub<Self, Output = Self>
-    + Mul<Self, Output = Self>
-    + Div<Self, Output = Self>
+    + std::ops::Neg<Output = Self>
+    + std::ops::Add<Self, Output = Self>
+    + std::ops::Sub<Self, Output = Self>
+    + std::ops::Mul<Self, Output = Self>
+    + std::ops::Div<Self, Output = Self>
+    + std::ops::AddAssign<Self>
+    + std::ops::SubAssign<Self>
     + PartialOrd
-    + AddAssign<Self>
-    + SubAssign<Self>
     + From<usize>
     + From<u128>
     // + From<u64>
@@ -27,7 +23,7 @@ pub trait AcirField:
     // + From<u16>
     // + From<u8>
     + From<bool>
-    + Hash
+    + std::hash::Hash
     + std::cmp::Eq
 {
     fn one() -> Self;
@@ -84,544 +80,3 @@ pub trait AcirField:
     fn and(&self, rhs: &Self, num_bits: u32) -> Self;
     fn xor(&self, rhs: &Self, num_bits: u32) -> Self;
 }
-
-// XXX: Switch out for a trait and proper implementations
-// This implementation is in-efficient, can definitely remove hex usage and Iterator instances for trivial functionality
-#[derive(Default, Clone, Copy, Eq, PartialOrd, Ord)]
-pub struct FieldElement<F: PrimeField>(F);
-
-impl<F: PrimeField> std::fmt::Display for FieldElement<F> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        // First check if the number is zero
-        //
-        let number = BigUint::from_bytes_be(&self.to_be_bytes());
-        if number == BigUint::zero() {
-            return write!(f, "0");
-        }
-        // Check if the negative version is smaller to represent
-        //
-        let minus_number = BigUint::from_bytes_be(&(self.neg()).to_be_bytes());
-        let (smaller_repr, is_negative) =
-            if minus_number.to_string().len() < number.to_string().len() {
-                (minus_number, true)
-            } else {
-                (number, false)
-            };
-        if is_negative {
-            write!(f, "-")?;
-        }
-
-        // Number of bits needed to represent the smaller representation
-        let num_bits = smaller_repr.bits();
-
-        // Check if the number represents a power of 2
-        if smaller_repr.count_ones() == 1 {
-            let mut bit_index = 0;
-            for i in 0..num_bits {
-                if smaller_repr.bit(i) {
-                    bit_index = i;
-                    break;
-                }
-            }
-            return match bit_index {
-                0 => write!(f, "1"),
-                1 => write!(f, "2"),
-                2 => write!(f, "4"),
-                3 => write!(f, "8"),
-                _ => write!(f, "2{}", superscript(bit_index)),
-            };
-        }
-
-        // Check if number is a multiple of a power of 2.
-        // This is used because when computing the quotient
-        // we usually have numbers in the form 2^t * q + r
-        // We focus on 2^64, 2^32, 2^16, 2^8, 2^4 because
-        // they are common. We could extend this to a more
-        // general factorization strategy, but we pay in terms of CPU time
-        let mul_sign = "×";
-        for power in [64, 32, 16, 8, 4] {
-            let power_of_two = BigUint::from(2_u128).pow(power);
-            if &smaller_repr % &power_of_two == BigUint::zero() {
-                return write!(
-                    f,
-                    "2{}{}{}",
-                    superscript(power as u64),
-                    mul_sign,
-                    smaller_repr / &power_of_two,
-                );
-            }
-        }
-        write!(f, "{smaller_repr}")
-    }
-}
-
-impl<F: PrimeField> std::fmt::Debug for FieldElement<F> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(self, f)
-    }
-}
-
-impl<F: PrimeField> std::hash::Hash for FieldElement<F> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        state.write(&self.to_be_bytes());
-    }
-}
-
-impl<F: PrimeField> PartialEq for FieldElement<F> {
-    fn eq(&self, other: &Self) -> bool {
-        self.to_be_bytes() == other.to_be_bytes()
-    }
-}
-
-impl<F: PrimeField> From<i128> for FieldElement<F> {
-    fn from(mut a: i128) -> FieldElement<F> {
-        let mut negative = false;
-        if a < 0 {
-            a = -a;
-            negative = true;
-        }
-
-        let mut result = match F::from_str(&a.to_string()) {
-            Ok(result) => result,
-            Err(_) => panic!("Cannot convert i128 as a string to a field element"),
-        };
-
-        if negative {
-            result = -result;
-        }
-        FieldElement(result)
-    }
-}
-
-impl<T: ark_ff::PrimeField> Serialize for FieldElement<T> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.to_hex().serialize(serializer)
-    }
-}
-
-impl<'de, T: ark_ff::PrimeField> Deserialize<'de> for FieldElement<T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let s: Cow<'de, str> = Deserialize::deserialize(deserializer)?;
-        match Self::from_hex(&s) {
-            Some(value) => Ok(value),
-            None => Err(serde::de::Error::custom(format!("Invalid hex for FieldElement: {s}",))),
-        }
-    }
-}
-
-impl<F: PrimeField> From<u128> for FieldElement<F> {
-    fn from(a: u128) -> FieldElement<F> {
-        let result = match F::from_str(&a.to_string()) {
-            Ok(result) => result,
-            Err(_) => panic!("Cannot convert u128 as a string to a field element"),
-        };
-        FieldElement(result)
-    }
-}
-
-impl<F: PrimeField> From<usize> for FieldElement<F> {
-    fn from(a: usize) -> FieldElement<F> {
-        FieldElement::from(a as u128)
-    }
-}
-
-impl<F: PrimeField> From<bool> for FieldElement<F> {
-    fn from(boolean: bool) -> FieldElement<F> {
-        if boolean {
-            FieldElement::one()
-        } else {
-            FieldElement::zero()
-        }
-    }
-}
-
-impl<F: PrimeField> FieldElement<F> {
-    pub fn from_repr(field: F) -> Self {
-        Self(field)
-    }
-
-    // XXX: This method is used while this field element
-    // implementation is not generic.
-    pub fn into_repr(self) -> F {
-        self.0
-    }
-
-    fn is_negative(&self) -> bool {
-        self.neg().num_bits() < self.num_bits()
-    }
-
-    fn fits_in_u128(&self) -> bool {
-        self.num_bits() <= 128
-    }
-
-    /// Returns None, if the string is not a canonical
-    /// representation of a field element; less than the order
-    /// or if the hex string is invalid.
-    /// This method can be used for both hex and decimal representations.
-    pub fn try_from_str(input: &str) -> Option<FieldElement<F>> {
-        if input.contains('x') {
-            return FieldElement::from_hex(input);
-        }
-
-        let fr = F::from_str(input).ok()?;
-        Some(FieldElement(fr))
-    }
-
-    // mask_to methods will not remove any bytes from the field
-    // they are simply zeroed out
-    // Whereas truncate_to will remove those bits and make the byte array smaller
-    fn mask_to_be_bytes(&self, num_bits: u32) -> Vec<u8> {
-        let mut bytes = self.to_be_bytes();
-        mask_vector_le(&mut bytes, num_bits as usize);
-        bytes
-    }
-
-    fn bits(&self) -> Vec<bool> {
-        fn byte_to_bit(byte: u8) -> Vec<bool> {
-            let mut bits = Vec::with_capacity(8);
-            for index in (0..=7).rev() {
-                bits.push((byte & (1 << index)) >> index == 1);
-            }
-            bits
-        }
-
-        let bytes = self.to_be_bytes();
-        let mut bits = Vec::with_capacity(bytes.len() * 8);
-        for byte in bytes {
-            let _bits = byte_to_bit(byte);
-            bits.extend(_bits);
-        }
-        bits
-    }
-
-    fn and_xor(&self, rhs: &FieldElement<F>, num_bits: u32, is_xor: bool) -> FieldElement<F> {
-        // XXX: Gadgets like SHA256 need to have their input be a multiple of 8
-        // This is not a restriction caused by SHA256, as it works on bits
-        // but most backends assume bytes.
-        // We could implicitly pad, however this may not be intuitive for users.
-        // assert!(
-        //     num_bits % 8 == 0,
-        //     "num_bits is not a multiple of 8, it is {}",
-        //     num_bits
-        // );
-
-        let lhs_bytes = self.mask_to_be_bytes(num_bits);
-        let rhs_bytes = rhs.mask_to_be_bytes(num_bits);
-
-        let and_byte_arr: Vec<_> = lhs_bytes
-            .into_iter()
-            .zip(rhs_bytes)
-            .map(|(lhs, rhs)| if is_xor { lhs ^ rhs } else { lhs & rhs })
-            .collect();
-
-        FieldElement::from_be_bytes_reduce(&and_byte_arr)
-    }
-}
-
-impl<F: PrimeField> AcirField for FieldElement<F> {
-    fn one() -> FieldElement<F> {
-        FieldElement(F::one())
-    }
-    fn zero() -> FieldElement<F> {
-        FieldElement(F::zero())
-    }
-
-    fn is_zero(&self) -> bool {
-        self == &Self::zero()
-    }
-    fn is_one(&self) -> bool {
-        self == &Self::one()
-    }
-
-    fn pow(&self, exponent: &Self) -> Self {
-        FieldElement(self.0.pow(exponent.0.into_bigint()))
-    }
-
-    /// Maximum number of bits needed to represent a field element
-    /// This is not the amount of bits being used to represent a field element
-    /// Example, you only need 254 bits to represent a field element in BN256
-    /// But the representation uses 256 bits, so the top two bits are always zero
-    /// This method would return 254
-    fn max_num_bits() -> u32 {
-        F::MODULUS_BIT_SIZE
-    }
-
-    /// Maximum numbers of bytes needed to represent a field element
-    /// We are not guaranteed that the number of bits being used to represent a field element
-    /// will always be divisible by 8. If the case that it is not, we add one to the max number of bytes
-    /// For example, a max bit size of 254 would give a max byte size of 32.
-    fn max_num_bytes() -> u32 {
-        let num_bytes = Self::max_num_bits() / 8;
-        if Self::max_num_bits() % 8 == 0 {
-            num_bytes
-        } else {
-            num_bytes + 1
-        }
-    }
-
-    fn modulus() -> BigUint {
-        F::MODULUS.into()
-    }
-
-    /// This is the number of bits required to represent this specific field element
-    fn num_bits(&self) -> u32 {
-        let bits = self.bits();
-        // Iterate the number of bits and pop off all leading zeroes
-        let iter = bits.iter().skip_while(|x| !(**x));
-        // Note: count will panic if it goes over usize::MAX.
-        // This may not be suitable for devices whose usize < u16
-        iter.count() as u32
-    }
-
-    fn to_u128(self) -> u128 {
-        let bytes = self.to_be_bytes();
-        u128::from_be_bytes(bytes[16..32].try_into().unwrap())
-    }
-
-    fn try_into_u128(self) -> Option<u128> {
-        self.fits_in_u128().then(|| self.to_u128())
-    }
-
-    fn to_i128(self) -> i128 {
-        let is_negative = self.is_negative();
-        let bytes = if is_negative { self.neg() } else { self }.to_be_bytes();
-        i128::from_be_bytes(bytes[16..32].try_into().unwrap()) * if is_negative { -1 } else { 1 }
-    }
-
-    fn try_to_u64(&self) -> Option<u64> {
-        (self.num_bits() <= 64).then(|| self.to_u128() as u64)
-    }
-
-    /// Computes the inverse or returns zero if the inverse does not exist
-    /// Before using this FieldElement, please ensure that this behavior is necessary
-    fn inverse(&self) -> FieldElement<F> {
-        let inv = self.0.inverse().unwrap_or_else(F::zero);
-        FieldElement(inv)
-    }
-
-    fn to_hex(self) -> String {
-        let mut bytes = Vec::new();
-        self.0.serialize_uncompressed(&mut bytes).unwrap();
-        bytes.reverse();
-        hex::encode(bytes)
-    }
-    fn from_hex(hex_str: &str) -> Option<FieldElement<F>> {
-        let value = hex_str.strip_prefix("0x").unwrap_or(hex_str);
-        // Values of odd length require an additional "0" prefix
-        let sanitized_value =
-            if value.len() % 2 == 0 { value.to_string() } else { format!("0{}", value) };
-        let hex_as_bytes = hex::decode(sanitized_value).ok()?;
-        Some(FieldElement::from_be_bytes_reduce(&hex_as_bytes))
-    }
-
-    fn to_be_bytes(self) -> Vec<u8> {
-        // to_be_bytes! uses little endian which is why we reverse the output
-        // TODO: Add a little endian equivalent, so the caller can use whichever one
-        // TODO they desire
-        let mut bytes = Vec::new();
-        self.0.serialize_uncompressed(&mut bytes).unwrap();
-        bytes.reverse();
-        bytes
-    }
-
-    /// Converts bytes into a FieldElement and applies a
-    /// reduction if needed.
-    fn from_be_bytes_reduce(bytes: &[u8]) -> FieldElement<F> {
-        FieldElement(F::from_be_bytes_mod_order(bytes))
-    }
-
-    /// Returns the closest number of bytes to the bits specified
-    /// This method truncates
-    fn fetch_nearest_bytes(&self, num_bits: usize) -> Vec<u8> {
-        fn nearest_bytes(num_bits: usize) -> usize {
-            ((num_bits + 7) / 8) * 8
-        }
-
-        let num_bytes = nearest_bytes(num_bits);
-        let num_elements = num_bytes / 8;
-
-        let mut bytes = self.to_be_bytes();
-        bytes.reverse(); // put it in big endian format. XXX(next refactor): we should be explicit about endianness.
-
-        bytes[0..num_elements].to_vec()
-    }
-
-    fn and(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
-        self.and_xor(rhs, num_bits, false)
-    }
-    fn xor(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
-        self.and_xor(rhs, num_bits, true)
-    }
-}
-
-use std::fmt::Debug;
-use std::fmt::Display;
-use std::hash::Hash;
-use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
-
-impl<F: PrimeField> Neg for FieldElement<F> {
-    type Output = FieldElement<F>;
-
-    fn neg(self) -> Self::Output {
-        FieldElement(-self.0)
-    }
-}
-
-impl<F: PrimeField> Mul for FieldElement<F> {
-    type Output = FieldElement<F>;
-    fn mul(mut self, rhs: FieldElement<F>) -> Self::Output {
-        self.0.mul_assign(&rhs.0);
-        FieldElement(self.0)
-    }
-}
-impl<F: PrimeField> Div for FieldElement<F> {
-    type Output = FieldElement<F>;
-    #[allow(clippy::suspicious_arithmetic_impl)]
-    fn div(self, rhs: FieldElement<F>) -> Self::Output {
-        self * rhs.inverse()
-    }
-}
-impl<F: PrimeField> Add for FieldElement<F> {
-    type Output = FieldElement<F>;
-    fn add(mut self, rhs: FieldElement<F>) -> Self::Output {
-        self.0.add_assign(&rhs.0);
-        FieldElement(self.0)
-    }
-}
-impl<F: PrimeField> AddAssign for FieldElement<F> {
-    fn add_assign(&mut self, rhs: FieldElement<F>) {
-        self.0.add_assign(&rhs.0);
-    }
-}
-
-impl<F: PrimeField> Sub for FieldElement<F> {
-    type Output = FieldElement<F>;
-    fn sub(mut self, rhs: FieldElement<F>) -> Self::Output {
-        self.0.sub_assign(&rhs.0);
-        FieldElement(self.0)
-    }
-}
-impl<F: PrimeField> SubAssign for FieldElement<F> {
-    fn sub_assign(&mut self, rhs: FieldElement<F>) {
-        self.0.sub_assign(&rhs.0);
-    }
-}
-
-fn mask_vector_le(bytes: &mut [u8], num_bits: usize) {
-    // reverse to big endian format
-    bytes.reverse();
-
-    let mask_power = num_bits % 8;
-    let array_mask_index = num_bits / 8;
-
-    for (index, byte) in bytes.iter_mut().enumerate() {
-        match index.cmp(&array_mask_index) {
-            std::cmp::Ordering::Less => {
-                // do nothing if the current index is less than
-                // the array index.
-            }
-            std::cmp::Ordering::Equal => {
-                let mask = 2u8.pow(mask_power as u32) - 1;
-                // mask the byte
-                *byte &= mask;
-            }
-            std::cmp::Ordering::Greater => {
-                // Anything greater than the array index
-                // will be set to zero
-                *byte = 0;
-            }
-        }
-    }
-    // reverse back to little endian
-    bytes.reverse();
-}
-
-// For pretty printing powers
-fn superscript(n: u64) -> String {
-    if n == 0 {
-        "⁰".to_owned()
-    } else if n == 1 {
-        "¹".to_owned()
-    } else if n == 2 {
-        "²".to_owned()
-    } else if n == 3 {
-        "³".to_owned()
-    } else if n == 4 {
-        "⁴".to_owned()
-    } else if n == 5 {
-        "⁵".to_owned()
-    } else if n == 6 {
-        "⁶".to_owned()
-    } else if n == 7 {
-        "⁷".to_owned()
-    } else if n == 8 {
-        "⁸".to_owned()
-    } else if n == 9 {
-        "⁹".to_owned()
-    } else if n >= 10 {
-        superscript(n / 10) + &superscript(n % 10)
-    } else {
-        panic!("{}", n.to_string() + " can't be converted to superscript.");
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{AcirField, FieldElement};
-
-    #[test]
-    fn and() {
-        let max = 10_000u32;
-
-        let num_bits = (std::mem::size_of::<u32>() * 8) as u32 - max.leading_zeros();
-
-        for x in 0..max {
-            let x = FieldElement::<ark_bn254::Fr>::from(x as i128);
-            let res = x.and(&x, num_bits);
-            assert_eq!(res.to_be_bytes(), x.to_be_bytes());
-        }
-    }
-
-    #[test]
-    fn serialize_fixed_test_vectors() {
-        // Serialized field elements from of 0, -1, -2, -3
-        let hex_strings = vec![
-            "0000000000000000000000000000000000000000000000000000000000000000",
-            "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000",
-            "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffffff",
-            "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffffe",
-        ];
-
-        for (i, string) in hex_strings.into_iter().enumerate() {
-            let minus_i_field_element = -FieldElement::<ark_bn254::Fr>::from(i as i128);
-            assert_eq!(minus_i_field_element.to_hex(), string);
-        }
-    }
-
-    #[test]
-    fn deserialize_even_and_odd_length_hex() {
-        // Test cases of (odd, even) length hex strings
-        let hex_strings =
-            vec![("0x0", "0x00"), ("0x1", "0x01"), ("0x002", "0x0002"), ("0x00003", "0x000003")];
-        for (i, case) in hex_strings.into_iter().enumerate() {
-            let i_field_element = FieldElement::<ark_bn254::Fr>::from(i as i128);
-            let odd_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.0).unwrap();
-            let even_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.1).unwrap();
-
-            assert_eq!(i_field_element, odd_field_element);
-            assert_eq!(odd_field_element, even_field_element);
-        }
-    }
-
-    #[test]
-    fn max_num_bits_smoke() {
-        let max_num_bits_bn254 = FieldElement::<ark_bn254::Fr>::max_num_bits();
-        assert_eq!(max_num_bits_bn254, 254);
-    }
-}
diff --git a/acvm-repo/acir_field/src/lib.rs b/acvm-repo/acir_field/src/lib.rs
index 9b8919e4bcb..1ad9a5b0037 100644
--- a/acvm-repo/acir_field/src/lib.rs
+++ b/acvm-repo/acir_field/src/lib.rs
@@ -2,18 +2,20 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
+
+mod field_element;
 mod generic_ark;
 
 pub use generic_ark::AcirField;
 
 /// Temporarily exported generic field to aid migration to `AcirField`
-pub use generic_ark::FieldElement as GenericFieldElement;
+pub use field_element::FieldElement as GenericFieldElement;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "bls12_381")] {
-        pub type FieldElement = generic_ark::FieldElement<ark_bls12_381::Fr>;
+        pub type FieldElement = field_element::FieldElement<ark_bls12_381::Fr>;
     } else {
-        pub type FieldElement = generic_ark::FieldElement<ark_bn254::Fr>;
+        pub type FieldElement = field_element::FieldElement<ark_bn254::Fr>;
     }
 }
 
diff --git a/acvm-repo/acvm/src/compiler/transformers/csat.rs b/acvm-repo/acvm/src/compiler/transformers/csat.rs
index 6cf74c04205..f2a3cc2c84e 100644
--- a/acvm-repo/acvm/src/compiler/transformers/csat.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/csat.rs
@@ -326,7 +326,7 @@ impl CSatTransformer {
 
         // First check if this polynomial actually needs a partial opcode optimization
         // There is the chance that it fits perfectly within the assert-zero opcode
-        if opcode.fits_in_one_identity(self.width) {
+        if fits_in_one_identity(&opcode, self.width) {
             return opcode;
         }
 
@@ -409,6 +409,61 @@ impl CSatTransformer {
     }
 }
 
+/// Checks if this expression can fit into one arithmetic identity
+fn fits_in_one_identity<F: AcirField>(expr: &Expression<F>, width: usize) -> bool {
+    // A Polynomial with more than one mul term cannot fit into one opcode
+    if expr.mul_terms.len() > 1 {
+        return false;
+    };
+    // A Polynomial with more terms than fan-in cannot fit within a single opcode
+    if expr.linear_combinations.len() > width {
+        return false;
+    }
+
+    // A polynomial with no mul term and a fan-in that fits inside of the width can fit into a single opcode
+    if expr.mul_terms.is_empty() {
+        return true;
+    }
+
+    // A polynomial with width-2 fan-in terms and a single non-zero mul term can fit into one opcode
+    // Example: Axy + Dz . Notice, that the mul term places a constraint on the first two terms, but not the last term
+    // XXX: This would change if our arithmetic polynomial equation was changed to Axyz for example, but for now it is not.
+    if expr.linear_combinations.len() <= (width - 2) {
+        return true;
+    }
+
+    // We now know that we have a single mul term. We also know that the mul term must match up with two other terms
+    // A polynomial whose mul terms are non zero which do not match up with two terms in the fan-in cannot fit into one opcode
+    // An example of this is: Axy + Bx + Cy + ...
+    // Notice how the bivariate monomial xy has two univariate monomials with their respective coefficients
+    // XXX: note that if x or y is zero, then we could apply a further optimization, but this would be done in another algorithm.
+    // It would be the same as when we have zero coefficients - Can only work if wire is constrained to be zero publicly
+    let mul_term = &expr.mul_terms[0];
+
+    // The coefficient should be non-zero, as this method is ran after the compiler removes all zero coefficient terms
+    assert_ne!(mul_term.0, F::zero());
+
+    let mut found_x = false;
+    let mut found_y = false;
+
+    for term in expr.linear_combinations.iter() {
+        let witness = &term.1;
+        let x = &mul_term.1;
+        let y = &mul_term.2;
+        if witness == x {
+            found_x = true;
+        };
+        if witness == y {
+            found_y = true;
+        };
+        if found_x & found_y {
+            break;
+        }
+    }
+
+    found_x & found_y
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index da4510db63a..4f88e17d109 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -637,7 +637,7 @@ pub fn get_value<F: AcirField>(
 ) -> Result<F, OpcodeResolutionError<F>> {
     let expr = ExpressionSolver::evaluate(expr, initial_witness);
     match expr.to_const() {
-        Some(value) => Ok(value),
+        Some(value) => Ok(*value),
         None => Err(OpcodeResolutionError::OpcodeNotSolvable(
             OpcodeNotSolvable::MissingAssignment(any_witness_from_expression(&expr).unwrap().0),
         )),
diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index 6c6b5968cd7..1435e514eac 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -16,6 +16,29 @@ pub enum MemoryTypeError {
     MismatchedBitSize { value_bit_size: u32, expected_bit_size: u32 },
 }
 
+impl<F> MemoryValue<F> {
+    /// Builds a field-typed memory value.
+    pub fn new_field(value: F) -> Self {
+        MemoryValue::Field(value)
+    }
+
+    /// Extracts the field element from the memory value, if it is typed as field element.
+    pub fn extract_field(&self) -> Option<&F> {
+        match self {
+            MemoryValue::Field(value) => Some(value),
+            _ => None,
+        }
+    }
+
+    /// Extracts the integer from the memory value, if it is typed as integer.
+    pub fn extract_integer(&self) -> Option<(&BigUint, u32)> {
+        match self {
+            MemoryValue::Integer(value, bit_size) => Some((value, *bit_size)),
+            _ => None,
+        }
+    }
+}
+
 impl<F: AcirField> MemoryValue<F> {
     /// Builds a memory value from a field element.
     pub fn new_from_field(value: F, bit_size: u32) -> Self {
@@ -44,11 +67,6 @@ impl<F: AcirField> MemoryValue<F> {
         Some(MemoryValue::new_from_field(value, bit_size))
     }
 
-    /// Builds a field-typed memory value.
-    pub fn new_field(value: F) -> Self {
-        MemoryValue::Field(value)
-    }
-
     /// Builds an integer-typed memory value.
     pub fn new_integer(value: BigUint, bit_size: u32) -> Self {
         assert!(
@@ -58,22 +76,6 @@ impl<F: AcirField> MemoryValue<F> {
         MemoryValue::Integer(value, bit_size)
     }
 
-    /// Extracts the field element from the memory value, if it is typed as field element.
-    pub fn extract_field(&self) -> Option<&F> {
-        match self {
-            MemoryValue::Field(value) => Some(value),
-            _ => None,
-        }
-    }
-
-    /// Extracts the integer from the memory value, if it is typed as integer.
-    pub fn extract_integer(&self) -> Option<(&BigUint, u32)> {
-        match self {
-            MemoryValue::Integer(value, bit_size) => Some((value, *bit_size)),
-            _ => None,
-        }
-    }
-
     /// Converts the memory value to a field element, independent of its type.
     pub fn to_field(&self) -> F {
         match self {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 93dd47afe68..ac7f2c09687 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -261,7 +261,7 @@ impl AcirContext {
             // Check if a witness has been assigned this value already, if so reuse it.
             *self
                 .constant_witnesses
-                .entry(constant)
+                .entry(*constant)
                 .or_insert_with(|| self.acir_ir.get_or_create_witness(&expression))
         } else {
             self.acir_ir.get_or_create_witness(&expression)
@@ -724,7 +724,7 @@ impl AcirContext {
 
             // If `lhs` and `rhs` are known constants then we can calculate the result at compile time.
             // `rhs` must be non-zero.
-            (Some(lhs_const), Some(rhs_const), _) if rhs_const != FieldElement::zero() => {
+            (Some(lhs_const), Some(rhs_const), _) if !rhs_const.is_zero() => {
                 let quotient = lhs_const.to_u128() / rhs_const.to_u128();
                 let remainder = lhs_const.to_u128() - quotient * rhs_const.to_u128();
 
@@ -734,7 +734,7 @@ impl AcirContext {
             }
 
             // If `rhs` is one then the division is a noop.
-            (_, Some(rhs_const), _) if rhs_const == FieldElement::one() => {
+            (_, Some(rhs_const), _) if rhs_const.is_one() => {
                 return Ok((lhs, zero));
             }
 
@@ -1952,7 +1952,7 @@ impl From<Expression<FieldElement>> for AcirVarData {
     fn from(expr: Expression<FieldElement>) -> Self {
         // Prefer simpler variants if possible.
         if let Some(constant) = expr.to_const() {
-            AcirVarData::from(constant)
+            AcirVarData::from(*constant)
         } else if let Some(witness) = expr.to_witness() {
             AcirVarData::from(witness)
         } else {
@@ -1982,12 +1982,12 @@ fn execute_brillig(
     for input in inputs {
         match input {
             BrilligInputs::Single(expr) => {
-                calldata.push(expr.to_const()?);
+                calldata.push(*expr.to_const()?);
             }
             BrilligInputs::Array(expr_arr) => {
                 // Attempt to fetch all array input values
                 for expr in expr_arr.iter() {
-                    calldata.push(expr.to_const()?);
+                    calldata.push(*expr.to_const()?);
                 }
             }
             BrilligInputs::MemoryArray(_) => {

From 967c0fa76da9384afe918a8b23eef60f12f29292 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 5 Jun 2024 11:58:42 +0100
Subject: [PATCH 336/416] fix(elaborator): Invert unconstrained check (#5176)

# Description

## Problem\*

A check from https://github.com/noir-lang/noir/pull/5165 was inverted
leading to CI issues in https://github.com/noir-lang/noir/pull/5172

## Summary\*

Fixed an accidentally inverted check for checking if a function is
unconstrained

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/lints.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/noirc_frontend/src/elaborator/lints.rs b/compiler/noirc_frontend/src/elaborator/lints.rs
index da3e033cd4c..d228588d367 100644
--- a/compiler/noirc_frontend/src/elaborator/lints.rs
+++ b/compiler/noirc_frontend/src/elaborator/lints.rs
@@ -41,7 +41,7 @@ pub(super) fn deprecated_function(interner: &NodeInterner, expr: ExprId) -> Opti
 /// as all unconstrained functions are not inlined and so
 /// associated attributes are disallowed.
 pub(super) fn inlining_attributes(func: &NoirFunction) -> Option<ResolverError> {
-    if !func.def.is_unconstrained {
+    if func.def.is_unconstrained {
         let attributes = func.attributes().clone();
 
         if attributes.is_no_predicates() {

From b769b01fd06a6a2c66c72f9aa4e1d346b0fca123 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 5 Jun 2024 12:36:48 +0100
Subject: [PATCH 337/416] fix: Fix panic in `get_global_let_statement` (#5177)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/node_interner.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index e28a0a64ad0..c223017d752 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -891,8 +891,9 @@ impl NodeInterner {
         match def {
             Node::Statement(hir_stmt) => match hir_stmt {
                 HirStatement::Let(let_stmt) => Some(let_stmt.clone()),
-                _ => {
-                    panic!("ice: all globals should correspond to a let statement in the interner")
+                HirStatement::Error => None,
+                other => {
+                    panic!("ice: all globals should correspond to a let statement in the interner: {other:?}")
                 }
             },
             _ => panic!("ice: all globals should correspond to a statement in the interner"),

From fe3ae09552c6cf2a8def74ba1f5517aaa6830ef8 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 5 Jun 2024 15:54:52 +0100
Subject: [PATCH 338/416] chore: break out helper methods for writing foreign
 call results (#5181)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR breaks out helper functions for writing values into memory to
aid reviewing #4053

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/brillig_vm/src/lib.rs | 108 ++++++++++++++++++--------------
 1 file changed, 62 insertions(+), 46 deletions(-)

diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index aaf55056589..46550fa4994 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -468,7 +468,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         destination_value_types: &[HeapValueType],
         foreign_call_index: usize,
     ) -> Result<(), String> {
-        let values = &self.foreign_call_results[foreign_call_index].values;
+        let values = std::mem::take(&mut self.foreign_call_results[foreign_call_index].values);
 
         if destinations.len() != values.len() {
             return Err(format!(
@@ -479,22 +479,13 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         }
 
         for ((destination, value_type), output) in
-            destinations.iter().zip(destination_value_types).zip(values)
+            destinations.iter().zip(destination_value_types).zip(&values)
         {
             match (destination, value_type) {
                 (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(bit_size)) => {
                     match output {
                         ForeignCallParam::Single(value) => {
-                            let memory_value = MemoryValue::new_checked(*value, *bit_size);
-                            if let Some(memory_value) = memory_value {
-                                self.memory.write(*value_index, memory_value);
-                            } else {
-                                return Err(format!(
-                                    "Foreign call result value {} does not fit in bit size {}",
-                                    value,
-                                    bit_size
-                                ));
-                            }
+                            self.write_value_to_memory(*value_index, value, *bit_size)?;
                         }
                         _ => return Err(format!(
                             "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}")
@@ -506,28 +497,12 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                     HeapValueType::Array { value_types, size: type_size },
                 ) if size == type_size => {
                     if HeapValueType::all_simple(value_types) {
-                        let bit_sizes_iterator = value_types.iter().map(|typ| match typ {
-                            HeapValueType::Simple(bit_size) => *bit_size,
-                            _ => unreachable!("Expected simple value type"),
-                        }).cycle();
-                        match output {
+                         match output {
                             ForeignCallParam::Array(values) => {
                                 if values.len() != *size {
                                     return Err("Foreign call result array doesn't match expected size".to_string());
                                 }
-                                // Convert the destination pointer to a usize
-                                let destination = self.memory.read_ref(*pointer_index);
-                                // Write to our destination memory
-                                let memory_values: Option<Vec<_>> = values.iter().zip(bit_sizes_iterator).map(
-                                    |(value, bit_size)| MemoryValue::new_checked(*value, bit_size)).collect();
-                                if let Some(memory_values) = memory_values {
-                                    self.memory.write_slice(destination, &memory_values);
-                                } else {
-                                    return Err(format!(
-                                        "Foreign call result values {:?} do not match expected bit sizes",
-                                        values,
-                                    ));
-                                }
+                                self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
                             }
                             _ => {
                                 return Err("Function result size does not match brillig bytecode size".to_string());
@@ -542,26 +517,12 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                     HeapValueType::Vector { value_types },
                 ) => {
                     if HeapValueType::all_simple(value_types) {
-                        let bit_sizes_iterator = value_types.iter().map(|typ| match typ {
-                            HeapValueType::Simple(bit_size) => *bit_size,
-                            _ => unreachable!("Expected simple value type"),
-                        }).cycle();
                         match output {
                             ForeignCallParam::Array(values) => {
                                 // Set our size in the size address
                                 self.memory.write(*size_index, values.len().into());
-                                // Convert the destination pointer to a usize
-                                let destination = self.memory.read_ref(*pointer_index);
-                                // Write to our destination memory
-                                let memory_values: Option<Vec<_>> = values.iter().zip(bit_sizes_iterator).map(|(value, bit_size)| MemoryValue::new_checked(*value, bit_size)).collect();
-                                if let Some(memory_values) = memory_values {
-                                    self.memory.write_slice(destination, &memory_values);
-                                }else{
-                                    return Err(format!(
-                                        "Foreign call result values {:?} do not match expected bit sizes",
-                                        values,
-                                    ));
-                                }
+
+                                self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
                             }
                             _ => {
                                 return Err("Function result size does not match brillig bytecode size".to_string());
@@ -577,6 +538,61 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
             }
         }
 
+        let _ =
+            std::mem::replace(&mut self.foreign_call_results[foreign_call_index].values, values);
+
+        Ok(())
+    }
+
+    fn write_value_to_memory(
+        &mut self,
+        destination: MemoryAddress,
+        value: &F,
+        value_bit_size: u32,
+    ) -> Result<(), String> {
+        let memory_value = MemoryValue::new_checked(*value, value_bit_size);
+
+        if let Some(memory_value) = memory_value {
+            self.memory.write(destination, memory_value);
+        } else {
+            return Err(format!(
+                "Foreign call result value {} does not fit in bit size {}",
+                value, value_bit_size
+            ));
+        }
+        Ok(())
+    }
+
+    fn write_values_to_memory_slice(
+        &mut self,
+        pointer_index: MemoryAddress,
+        values: &[F],
+        value_types: &[HeapValueType],
+    ) -> Result<(), String> {
+        let bit_sizes_iterator = value_types
+            .iter()
+            .map(|typ| match typ {
+                HeapValueType::Simple(bit_size) => *bit_size,
+                _ => unreachable!("Expected simple value type"),
+            })
+            .cycle();
+
+        // Convert the destination pointer to a usize
+        let destination = self.memory.read_ref(pointer_index);
+        // Write to our destination memory
+        let memory_values: Option<Vec<_>> = values
+            .iter()
+            .zip(bit_sizes_iterator)
+            .map(|(value, bit_size)| MemoryValue::new_checked(*value, bit_size))
+            .collect();
+        if let Some(memory_values) = memory_values {
+            self.memory.write_slice(destination, &memory_values);
+        } else {
+            return Err(format!(
+                "Foreign call result values {:?} do not match expected bit sizes",
+                values,
+            ));
+        }
         Ok(())
     }
 

From bdb2bc608ea8fd52d46545a38b68dd2558b28110 Mon Sep 17 00:00:00 2001
From: Maddiaa <47148561+Maddiaa0@users.noreply.github.com>
Date: Wed, 5 Jun 2024 17:27:32 +0100
Subject: [PATCH 339/416] feat!: restrict noir word size to u32 (#5180)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../acir/tests/test_program_serialization.rs  |  9 +-
 acvm-repo/acir_field/src/field_element.rs     |  4 +
 acvm-repo/acir_field/src/generic_ark.rs       |  2 +
 .../test/shared/complex_foreign_call.ts       |  6 +-
 acvm-repo/brillig_vm/src/lib.rs               | 91 +++++++++++++------
 acvm-repo/brillig_vm/src/memory.rs            | 14 +--
 aztec_macros/src/transforms/events.rs         |  2 +-
 aztec_macros/src/transforms/storage.rs        |  4 +-
 aztec_macros/src/utils/hir_utils.rs           |  2 +-
 .../noirc_evaluator/src/brillig/brillig_ir.rs |  6 +-
 .../brillig_ir/codegen_control_flow.rs        |  3 +-
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  4 +-
 compiler/noirc_evaluator/src/ssa/ir/types.rs  |  4 +-
 .../src/ssa/ssa_gen/context.rs                |  9 +-
 .../noirc_evaluator/src/ssa/ssa_gen/mod.rs    |  7 +-
 compiler/noirc_frontend/src/ast/mod.rs        |  4 +-
 .../src/elaborator/expressions.rs             |  6 +-
 .../noirc_frontend/src/elaborator/types.rs    |  2 +-
 .../noirc_frontend/src/hir/comptime/errors.rs |  2 +-
 .../src/hir/comptime/interpreter.rs           | 12 ++-
 .../noirc_frontend/src/hir/comptime/value.rs  |  2 +-
 .../src/hir/resolution/resolver.rs            |  2 +-
 .../noirc_frontend/src/hir/type_check/expr.rs |  8 +-
 compiler/noirc_frontend/src/hir_def/types.rs  | 37 ++++----
 .../src/monomorphization/ast.rs               |  6 +-
 .../src/monomorphization/mod.rs               | 12 +--
 compiler/noirc_printable_type/src/lib.rs      |  4 +-
 noir_stdlib/src/array.nr                      |  6 +-
 noir_stdlib/src/collections/bounded_vec.nr    | 10 +-
 noir_stdlib/src/collections/map.nr            | 18 ++--
 noir_stdlib/src/collections/vec.nr            |  8 +-
 noir_stdlib/src/hash/poseidon.nr              | 12 +--
 noir_stdlib/src/hash/poseidon2.nr             |  4 +-
 noir_stdlib/src/slice.nr                      |  6 +-
 .../execution_success/array_len/src/main.nr   |  6 +-
 .../brillig_array_to_slice/src/main.nr        |  2 +-
 .../execution_success/regression/src/main.nr  |  8 +-
 .../slice_dynamic_index/src/main.nr           |  4 +-
 tooling/nargo/src/artifacts/debug_vars.rs     |  4 +-
 tooling/noirc_abi/src/lib.rs                  | 16 ++--
 40 files changed, 207 insertions(+), 161 deletions(-)

diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index d4c7a8782ab..dfcb1a8bb86 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -267,7 +267,7 @@ fn complex_brillig_foreign_call() {
             brillig::Opcode::Const {
                 destination: MemoryAddress(0),
                 value: FieldElement::from(32_usize),
-                bit_size: 64,
+                bit_size: 32,
             },
             brillig::Opcode::CalldataCopy {
                 destination_address: MemoryAddress(1),
@@ -335,7 +335,6 @@ fn complex_brillig_foreign_call() {
         Program { functions: vec![circuit], unconstrained_functions: vec![brillig_bytecode] };
 
     let bytes = Program::serialize_program(&program);
-
     let expected_serialization: Vec<u8> = vec![
         31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 131, 64, 12, 77, 102, 90, 43, 221, 245,
         6, 133, 246, 0, 211, 158, 192, 187, 136, 59, 69, 151, 158, 94, 116, 48, 131, 241, 233, 70,
@@ -343,9 +342,9 @@ fn complex_brillig_foreign_call() {
         91, 154, 75, 208, 205, 4, 221, 62, 249, 113, 60, 95, 238, 40, 142, 230, 2, 28, 237, 1, 28,
         73, 245, 255, 132, 253, 142, 217, 151, 168, 245, 179, 43, 243, 115, 163, 113, 190, 18, 57,
         63, 4, 83, 44, 180, 55, 50, 180, 28, 188, 153, 224, 196, 122, 175, 111, 112, 68, 24, 65,
-        50, 204, 162, 100, 249, 119, 137, 226, 193, 16, 251, 169, 50, 204, 235, 170, 41, 139, 214,
-        130, 42, 82, 253, 168, 253, 23, 222, 25, 236, 58, 176, 237, 20, 234, 207, 107, 45, 78, 184,
-        55, 27, 124, 191, 104, 42, 111, 40, 121, 15, 94, 163, 77, 128, 65, 5, 0, 0,
+        116, 178, 40, 89, 254, 93, 162, 120, 48, 196, 126, 170, 12, 243, 186, 106, 202, 162, 181,
+        160, 138, 84, 63, 106, 255, 133, 119, 6, 187, 14, 108, 59, 133, 250, 243, 90, 139, 19, 238,
+        205, 6, 223, 47, 154, 202, 27, 74, 222, 3, 234, 73, 242, 82, 65, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
diff --git a/acvm-repo/acir_field/src/field_element.rs b/acvm-repo/acir_field/src/field_element.rs
index a45e8c9946a..7810578ff73 100644
--- a/acvm-repo/acir_field/src/field_element.rs
+++ b/acvm-repo/acir_field/src/field_element.rs
@@ -319,6 +319,10 @@ impl<F: PrimeField> AcirField for FieldElement<F> {
         (self.num_bits() <= 64).then(|| self.to_u128() as u64)
     }
 
+    fn try_to_u32(&self) -> Option<u32> {
+        (self.num_bits() <= 32).then(|| self.to_u128() as u32)
+    }
+
     /// Computes the inverse or returns zero if the inverse does not exist
     /// Before using this FieldElement, please ensure that this behavior is necessary
     fn inverse(&self) -> FieldElement<F> {
diff --git a/acvm-repo/acir_field/src/generic_ark.rs b/acvm-repo/acir_field/src/generic_ark.rs
index 1e0215223ef..3d93de5a992 100644
--- a/acvm-repo/acir_field/src/generic_ark.rs
+++ b/acvm-repo/acir_field/src/generic_ark.rs
@@ -60,6 +60,8 @@ pub trait AcirField:
 
     fn try_to_u64(&self) -> Option<u64>;
 
+    fn try_to_u32(&self) -> Option<u32>;
+
     /// Computes the inverse or returns zero if the inverse does not exist
     /// Before using this FieldElement, please ensure that this behavior is necessary
     fn inverse(&self) -> Self;
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index 0d6fab0e1f3..8ec2ddd1cb2 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -6,9 +6,9 @@ export const bytecode = Uint8Array.from([
   192, 187, 136, 59, 69, 151, 158, 94, 116, 48, 131, 241, 233, 70, 28, 65, 3, 195, 155, 79, 62, 47, 9, 25, 166, 81, 210,
   97, 177, 236, 239, 130, 70, 208, 223, 91, 154, 75, 208, 205, 4, 221, 62, 249, 113, 60, 95, 238, 40, 142, 230, 2, 28,
   237, 1, 28, 73, 245, 255, 132, 253, 142, 217, 151, 168, 245, 179, 43, 243, 115, 163, 113, 190, 18, 57, 63, 4, 83, 44,
-  180, 55, 50, 180, 28, 188, 153, 224, 196, 122, 175, 111, 112, 68, 24, 65, 50, 204, 162, 100, 249, 119, 137, 226, 193,
-  16, 251, 169, 50, 204, 235, 170, 41, 139, 214, 130, 42, 82, 253, 168, 253, 23, 222, 25, 236, 58, 176, 237, 20, 234,
-  207, 107, 45, 78, 184, 55, 27, 124, 191, 104, 42, 111, 40, 121, 15, 94, 163, 77, 128, 65, 5, 0, 0,
+  180, 55, 50, 180, 28, 188, 153, 224, 196, 122, 175, 111, 112, 68, 24, 65, 116, 178, 40, 89, 254, 93, 162, 120, 48,
+  196, 126, 170, 12, 243, 186, 106, 202, 162, 181, 160, 138, 84, 63, 106, 255, 133, 119, 6, 187, 14, 108, 59, 133, 250,
+  243, 90, 139, 19, 238, 205, 6, 223, 47, 154, 202, 27, 74, 222, 3, 234, 73, 242, 82, 65, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 46550fa4994..da9a34f1044 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -645,6 +645,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
 mod tests {
     use acir::{AcirField, FieldElement};
     use acvm_blackbox_solver::StubbedBlackBoxSolver;
+    const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 32;
 
     use super::*;
 
@@ -927,7 +928,7 @@ mod tests {
 
     #[test]
     fn cmp_binary_ops() {
-        let bit_size = 32;
+        let bit_size = BRILLIG_MEMORY_ADDRESSING_BIT_SIZE;
         let calldata: Vec<FieldElement> =
             vec![(2u128).into(), (2u128).into(), (0u128).into(), (5u128).into(), (6u128).into()];
         let calldata_size = calldata.len();
@@ -1029,7 +1030,7 @@ mod tests {
         ///         i += 1;
         ///     }
         fn brillig_write_memory(item_count: usize) -> Vec<MemoryValue<FieldElement>> {
-            let bit_size = 64;
+            let bit_size = BRILLIG_MEMORY_ADDRESSING_BIT_SIZE;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_tmp = MemoryAddress::from(2);
@@ -1083,11 +1084,11 @@ mod tests {
 
         let memory = brillig_write_memory(5);
         let expected =
-            vec![(0u64).into(), (1u64).into(), (2u64).into(), (3u64).into(), (4u64).into()];
+            vec![(0u32).into(), (1u32).into(), (2u32).into(), (3u32).into(), (4u32).into()];
         assert_eq!(memory, expected);
 
         let memory = brillig_write_memory(1024);
-        let expected: Vec<_> = (0..1024).map(|i: u64| i.into()).collect();
+        let expected: Vec<_> = (0..1024).map(|i: u32| i.into()).collect();
         assert_eq!(memory, expected);
     }
 
@@ -1102,7 +1103,7 @@ mod tests {
         ///         i += 1;
         ///     }
         fn brillig_sum_memory(memory: Vec<FieldElement>) -> FieldElement {
-            let bit_size = 64;
+            let bit_size = 32;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_sum = MemoryAddress::from(2);
@@ -1198,7 +1199,7 @@ mod tests {
         ///     }
         /// Note we represent a 100% in-stack optimized form in brillig
         fn brillig_recursive_write_memory<F: AcirField>(size: usize) -> Vec<MemoryValue<F>> {
-            let bit_size = 64;
+            let bit_size = BRILLIG_MEMORY_ADDRESSING_BIT_SIZE;
             let r_i = MemoryAddress::from(0);
             let r_len = MemoryAddress::from(1);
             let r_tmp = MemoryAddress::from(2);
@@ -1265,11 +1266,11 @@ mod tests {
 
         let memory = brillig_recursive_write_memory::<FieldElement>(5);
         let expected =
-            vec![(0u64).into(), (1u64).into(), (2u64).into(), (3u64).into(), (4u64).into()];
+            vec![(0u32).into(), (1u32).into(), (2u32).into(), (3u32).into(), (4u32).into()];
         assert_eq!(memory, expected);
 
         let memory = brillig_recursive_write_memory::<FieldElement>(1024);
-        let expected: Vec<_> = (0..1024).map(|i: u64| i.into()).collect();
+        let expected: Vec<_> = (0..1024).map(|i: u32| i.into()).collect();
         assert_eq!(memory, expected);
     }
 
@@ -1301,7 +1302,11 @@ mod tests {
 
         let double_program = vec![
             // Load input address with value 5
-            Opcode::Const { destination: r_input, value: (5u128).into(), bit_size: 32 },
+            Opcode::Const {
+                destination: r_input,
+                value: (5u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // Call foreign function "double" with the input address
             Opcode::ForeignCall {
                 function: "double".into(),
@@ -1362,9 +1367,17 @@ mod tests {
                 offset: 0,
             },
             // input = 0
-            Opcode::Const { destination: r_input, value: 2_usize.into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_input,
+                value: 2_usize.into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // output = 0
-            Opcode::Const { destination: r_output, value: 2_usize.into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_output,
+                value: 2_usize.into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // *output = matrix_2x2_transpose(*input)
             Opcode::ForeignCall {
                 function: "matrix_2x2_transpose".into(),
@@ -1444,24 +1457,28 @@ mod tests {
                 offset: 0,
             },
             // input_pointer = 4
-            Opcode::Const { destination: r_input_pointer, value: (4u128).into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_input_pointer,
+                value: (4u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // input_size = input_string.len() (constant here)
             Opcode::Const {
                 destination: r_input_size,
                 value: input_string.len().into(),
-                bit_size: 64,
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
             },
             // output_pointer = 4 + input_size
             Opcode::Const {
                 destination: r_output_pointer,
                 value: (4 + input_string.len()).into(),
-                bit_size: 64,
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
             },
             // output_size = input_size * 2
             Opcode::Const {
                 destination: r_output_size,
                 value: (input_string.len() * 2).into(),
-                bit_size: 64,
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
             },
             // output_pointer[0..output_size] = string_double(input_pointer[0...input_size])
             Opcode::ForeignCall {
@@ -1538,9 +1555,17 @@ mod tests {
                 offset: 0,
             },
             // input = 0
-            Opcode::Const { destination: r_input, value: (2u128).into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_input,
+                value: (2u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // output = 0
-            Opcode::Const { destination: r_output, value: (6u128).into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_output,
+                value: (6u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // *output = matrix_2x2_transpose(*input)
             Opcode::ForeignCall {
                 function: "matrix_2x2_transpose".into(),
@@ -1629,11 +1654,23 @@ mod tests {
                 offset: 0,
             },
             // input = 3
-            Opcode::Const { destination: r_input_a, value: (3u128).into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_input_a,
+                value: (3u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // input = 7
-            Opcode::Const { destination: r_input_b, value: (7u128).into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_input_b,
+                value: (7u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // output = 0
-            Opcode::Const { destination: r_output, value: (0u128).into(), bit_size: 64 },
+            Opcode::Const {
+                destination: r_output,
+                value: (0u128).into(),
+                bit_size: BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            },
             // *output = matrix_2x2_transpose(*input)
             Opcode::ForeignCall {
                 function: "matrix_2x2_transpose".into(),
@@ -1718,28 +1755,28 @@ mod tests {
         let v2_ptr: usize = 0usize;
         let mut memory = v2.clone();
         let v2_start = memory.len();
-        memory.extend(vec![MemoryValue::from(v2_ptr), v2.len().into(), MemoryValue::from(1_usize)]);
+        memory.extend(vec![MemoryValue::from(v2_ptr), v2.len().into(), MemoryValue::from(1_u32)]);
         let a4_ptr = memory.len();
         memory.extend(a4.clone());
         let a4_start = memory.len();
-        memory.extend(vec![MemoryValue::from(a4_ptr), MemoryValue::from(1_usize)]);
+        memory.extend(vec![MemoryValue::from(a4_ptr), MemoryValue::from(1_u32)]);
         let v6_ptr = memory.len();
         memory.extend(v6.clone());
         let v6_start = memory.len();
-        memory.extend(vec![MemoryValue::from(v6_ptr), v6.len().into(), MemoryValue::from(1_usize)]);
+        memory.extend(vec![MemoryValue::from(v6_ptr), v6.len().into(), MemoryValue::from(1_u32)]);
         let a9_ptr = memory.len();
         memory.extend(a9.clone());
         let a9_start = memory.len();
-        memory.extend(vec![MemoryValue::from(a9_ptr), MemoryValue::from(1_usize)]);
+        memory.extend(vec![MemoryValue::from(a9_ptr), MemoryValue::from(1_u32)]);
         // finally we add the contents of the outer array
         let outer_ptr = memory.len();
         let outer_array = vec![
             MemoryValue::new_field(FieldElement::from(1u128)),
-            MemoryValue::from(v2.len()),
+            MemoryValue::from(v2.len() as u32),
             MemoryValue::from(v2_start),
             MemoryValue::from(a4_start),
             MemoryValue::new_field(FieldElement::from(5u128)),
-            MemoryValue::from(v6.len()),
+            MemoryValue::from(v6.len() as u32),
             MemoryValue::from(v6_start),
             MemoryValue::from(a9_start),
         ];
@@ -1770,7 +1807,7 @@ mod tests {
         }))
         .chain(vec![
             // input = 0
-            Opcode::Const { destination: r_input, value: (outer_ptr).into(), bit_size: 64 },
+            Opcode::Const { destination: r_input, value: (outer_ptr).into(), bit_size: 32 },
             // some_function(input)
             Opcode::ForeignCall {
                 function: "flat_sum".into(),
diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index 1435e514eac..95e28f7d863 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -2,7 +2,7 @@ use acir::{brillig::MemoryAddress, AcirField};
 use num_bigint::BigUint;
 use num_traits::{One, Zero};
 
-pub const MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
+pub const MEMORY_ADDRESSING_BIT_SIZE: u32 = 32;
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum MemoryValue<F> {
@@ -167,18 +167,18 @@ impl<F: AcirField> From<usize> for MemoryValue<F> {
     }
 }
 
-impl<F: AcirField> From<u64> for MemoryValue<F> {
-    fn from(value: u64) -> Self {
-        MemoryValue::new_integer(value.into(), 64)
-    }
-}
-
 impl<F: AcirField> From<u32> for MemoryValue<F> {
     fn from(value: u32) -> Self {
         MemoryValue::new_integer(value.into(), 32)
     }
 }
 
+impl<F: AcirField> From<u64> for MemoryValue<F> {
+    fn from(value: u64) -> Self {
+        MemoryValue::new_integer(value.into(), 64)
+    }
+}
+
 impl<F: AcirField> From<u8> for MemoryValue<F> {
     fn from(value: u8) -> Self {
         MemoryValue::new_integer(value.into(), 8)
diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
index 9c8cd826360..69cb6ddafc3 100644
--- a/aztec_macros/src/transforms/events.rs
+++ b/aztec_macros/src/transforms/events.rs
@@ -158,7 +158,7 @@ fn transform_event(
             // Also update the type! It might have a different length now than the placeholder.
             interner.push_expr_type(
                 selector_literal_id,
-                Type::String(Box::new(Type::Constant(signature.len() as u64))),
+                Type::String(Box::new(Type::Constant(signature.len() as u32))),
             );
             Ok(())
         }
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index bd9fff3c3d3..a1c21c7efcf 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -257,7 +257,7 @@ pub fn get_storage_serialized_length(
     traits: &[TraitId],
     typ: &Type,
     interner: &NodeInterner,
-) -> Result<u64, AztecMacroError> {
+) -> Result<u32, AztecMacroError> {
     let (struct_name, maybe_stored_in_state) = match typ {
         Type::Struct(struct_type, generics) => {
             Ok((struct_type.borrow().name.0.contents.clone(), generics.first()))
@@ -394,7 +394,7 @@ pub fn assign_storage_slots(
                 )),
             }?;
 
-            let mut storage_slot: u64 = 1;
+            let mut storage_slot: u32 = 1;
             for (index, (_, expr_id)) in storage_constructor_expression.fields.iter().enumerate() {
                 let fields = storage_struct
                     .borrow()
diff --git a/aztec_macros/src/utils/hir_utils.rs b/aztec_macros/src/utils/hir_utils.rs
index 7ce280c4c7f..d4b55e1311f 100644
--- a/aztec_macros/src/utils/hir_utils.rs
+++ b/aztec_macros/src/utils/hir_utils.rs
@@ -320,7 +320,7 @@ pub fn get_serialized_length(
     trait_name: &str,
     typ: &Type,
     interner: &NodeInterner,
-) -> Result<u64, MacroError> {
+) -> Result<u32, MacroError> {
     let serialized_trait_impl_kind = traits
         .iter()
         .find_map(|&trait_id| {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 9341db2ead7..ebccf7a0bf1 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -34,9 +34,9 @@ use acvm::{
 use debug_show::DebugShow;
 
 /// The Brillig VM does not apply a limit to the memory address space,
-/// As a convention, we take use 64 bits. This means that we assume that
-/// memory has 2^64 memory slots.
-pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
+/// As a convention, we take use 32 bits. This means that we assume that
+/// memory has 2^32 memory slots.
+pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 32;
 
 // Registers reserved in runtime for special purposes.
 pub(crate) enum ReservedRegisters {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index d9109646338..fee3a450119 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -162,8 +162,7 @@ impl BrilligContext {
 
             let current_revert_data_pointer = ctx.allocate_register();
             ctx.mov_instruction(current_revert_data_pointer, revert_data.pointer);
-            let revert_data_id =
-                ctx.make_usize_constant_instruction((error_selector as u128).into());
+            let revert_data_id = ctx.make_constant_instruction((error_selector as u128).into(), 64);
             ctx.store_instruction(current_revert_data_pointer, revert_data_id.address);
 
             ctx.codegen_usize_op_in_place(current_revert_data_pointer, BrilligBinaryOp::Add, 1);
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 7517b54aac3..e21deb9ef79 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -580,7 +580,7 @@ impl Instruction {
                 let index = dfg.get_numeric_constant(*index);
                 if let (Some((array, _)), Some(index)) = (array, index) {
                     let index =
-                        index.try_to_u64().expect("Expected array index to fit in u64") as usize;
+                        index.try_to_u32().expect("Expected array index to fit in u32") as usize;
                     if index < array.len() {
                         return SimplifiedTo(array[index]);
                     }
@@ -592,7 +592,7 @@ impl Instruction {
                 let index = dfg.get_numeric_constant(*index);
                 if let (Some((array, element_type)), Some(index)) = (array, index) {
                     let index =
-                        index.try_to_u64().expect("Expected array index to fit in u64") as usize;
+                        index.try_to_u32().expect("Expected array index to fit in u32") as usize;
 
                     if index < array.len() {
                         let new_array = dfg.make_array(array.update(index, *value), element_type);
diff --git a/compiler/noirc_evaluator/src/ssa/ir/types.rs b/compiler/noirc_evaluator/src/ssa/ir/types.rs
index ded385d2d3c..76b5bc43384 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/types.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/types.rs
@@ -3,6 +3,8 @@ use std::rc::Rc;
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 
+use crate::ssa::ssa_gen::SSA_WORD_SIZE;
+
 /// A numeric type in the Intermediate representation
 /// Note: we class NativeField as a numeric type
 /// though we also apply limitations to it, such as not
@@ -92,7 +94,7 @@ impl Type {
 
     /// Creates the type of an array's length.
     pub(crate) fn length_type() -> Type {
-        Type::unsigned(64)
+        Type::unsigned(SSA_WORD_SIZE)
     }
 
     /// Returns the bit size of the provided numeric type.
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index df14ee99bd3..a16e0f93c61 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -20,6 +20,7 @@ use crate::ssa::ir::types::{NumericType, Type};
 use crate::ssa::ir::value::ValueId;
 
 use super::value::{Tree, Value, Values};
+use super::SSA_WORD_SIZE;
 use fxhash::FxHashMap as HashMap;
 
 /// The FunctionContext is the main context object for translating a
@@ -587,9 +588,9 @@ impl<'a> FunctionContext<'a> {
         address
     }
 
-    /// Array indexes are u64s. This function casts values used as indexes to u64.
+    /// Array indexes are u32. This function casts values used as indexes to u32.
     pub(super) fn make_array_index(&mut self, index: ValueId) -> ValueId {
-        self.builder.insert_cast(index, Type::unsigned(64))
+        self.builder.insert_cast(index, Type::unsigned(SSA_WORD_SIZE))
     }
 
     /// Define a local variable to be some Values that can later be retrieved
@@ -837,12 +838,12 @@ impl<'a> FunctionContext<'a> {
     ) -> ValueId {
         let index = self.make_array_index(index);
         let element_size =
-            self.builder.numeric_constant(self.element_size(array), Type::unsigned(64));
+            self.builder.numeric_constant(self.element_size(array), Type::unsigned(SSA_WORD_SIZE));
 
         // The actual base index is the user's index * the array element type's size
         let mut index =
             self.builder.set_location(location).insert_binary(index, BinaryOp::Mul, element_size);
-        let one = self.builder.numeric_constant(FieldElement::one(), Type::unsigned(64));
+        let one = self.builder.numeric_constant(FieldElement::one(), Type::unsigned(SSA_WORD_SIZE));
 
         new_value.for_each(|value| {
             let value = value.eval(self);
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 698a2b0471a..254e907fb0e 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -32,6 +32,8 @@ use super::{
     },
 };
 
+pub(crate) const SSA_WORD_SIZE: u32 = 32;
+
 /// Generates SSA for the given monomorphized program.
 ///
 /// This function will generate the SSA but does not perform any optimizations on it.
@@ -244,7 +246,7 @@ impl<'a> FunctionContext<'a> {
         let elements = vecmap(string.as_bytes(), |byte| {
             self.builder.numeric_constant(*byte as u128, Type::unsigned(8)).into()
         });
-        let typ = Self::convert_non_tuple_type(&ast::Type::String(elements.len() as u64));
+        let typ = Self::convert_non_tuple_type(&ast::Type::String(elements.len() as u32));
         self.codegen_array(elements, typ)
     }
 
@@ -400,7 +402,8 @@ impl<'a> FunctionContext<'a> {
         // base_index = index * type_size
         let index = self.make_array_index(index);
         let type_size = Self::convert_type(element_type).size_of_type();
-        let type_size = self.builder.numeric_constant(type_size as u128, Type::unsigned(64));
+        let type_size =
+            self.builder.numeric_constant(type_size as u128, Type::unsigned(SSA_WORD_SIZE));
         let base_index =
             self.builder.set_location(location).insert_binary(index, BinaryOp::Mul, type_size);
 
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index a9d9f232b64..39b23228967 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -143,7 +143,7 @@ pub(crate) type UnaryRhsMemberAccess =
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum UnresolvedTypeExpression {
     Variable(Path),
-    Constant(u64, Span),
+    Constant(u32, Span),
     BinaryOperation(
         Box<UnresolvedTypeExpression>,
         BinaryTypeOperator,
@@ -307,7 +307,7 @@ impl UnresolvedTypeExpression {
         match expr.kind {
             ExpressionKind::Literal(Literal::Integer(int, sign)) => {
                 assert!(!sign, "Negative literal is not allowed here");
-                match int.try_to_u64() {
+                match int.try_to_u32() {
                     Some(int) => Ok(UnresolvedTypeExpression::Constant(int, expr.span)),
                     None => Err(expr),
                 }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index abd8781a213..5eee7ee6c7c 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -114,7 +114,7 @@ impl<'context> Elaborator<'context> {
                 (Lit(int), self.polymorphic_integer_or_field())
             }
             Literal::Str(str) | Literal::RawStr(str, _) => {
-                let len = Type::Constant(str.len() as u64);
+                let len = Type::Constant(str.len() as u32);
                 (Lit(HirLiteral::Str(str)), Type::String(Box::new(len)))
             }
             Literal::FmtStr(str) => self.elaborate_fmt_string(str, span),
@@ -156,7 +156,7 @@ impl<'context> Elaborator<'context> {
                     elem_id
                 });
 
-                let length = Type::Constant(elements.len() as u64);
+                let length = Type::Constant(elements.len() as u32);
                 (HirArrayLiteral::Standard(elements), first_elem_type, length)
             }
             ArrayLiteral::Repeated { repeated_element, length } => {
@@ -220,7 +220,7 @@ impl<'context> Elaborator<'context> {
             }
         }
 
-        let len = Type::Constant(str.len() as u64);
+        let len = Type::Constant(str.len() as u32);
         let typ = Type::FmtString(Box::new(len), Box::new(Type::Tuple(capture_types)));
         (HirExpression::Literal(HirLiteral::FmtStr(str, fmt_str_idents)), typ)
     }
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index a106f6687df..5e3ace423e5 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -415,7 +415,7 @@ impl<'context> Elaborator<'context> {
             .or_else(|| self.resolve_trait_method_by_named_generic(path))
     }
 
-    fn eval_global_as_array_length(&mut self, global: GlobalId, path: &Path) -> u64 {
+    fn eval_global_as_array_length(&mut self, global: GlobalId, path: &Path) -> u32 {
         let Some(stmt) = self.interner.get_global_let_statement(global) else {
             let path = path.clone();
             self.push_err(ResolverError::NoSuchNumericTypeVariable { path });
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 7b38f2fd32e..df4bc941f66 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -171,7 +171,7 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let typ = value.get_type();
                 let msg = format!("Non-integer type `{typ}` used in for loop");
                 let secondary = if matches!(typ.as_ref(), &Type::FieldElement) {
-                    "`field` is not an integer type, try `u64` instead".to_string()
+                    "`field` is not an integer type, try `u32` instead".to_string()
                 } else {
                     String::new()
                 };
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 314ea26e52c..8809e63d00a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -332,7 +332,7 @@ impl<'a> Interpreter<'a> {
             DefinitionKind::GenericType(type_variable) => {
                 let value = match &*type_variable.borrow() {
                     TypeBinding::Unbound(_) => None,
-                    TypeBinding::Bound(binding) => binding.evaluate_to_u64(),
+                    TypeBinding::Bound(binding) => binding.evaluate_to_u32(),
                 };
 
                 if let Some(value) = value {
@@ -395,9 +395,11 @@ impl<'a> Interpreter<'a> {
                 }
                 (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
                     let value: u32 =
-                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
-                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
-                        )?;
+                        value.try_to_u32().ok_or(InterpreterError::IntegerOutOfRangeForType {
+                            value,
+                            typ,
+                            location,
+                        })?;
                     let value = if is_negative { 0u32.wrapping_sub(value) } else { value };
                     Ok(Value::U32(value))
                 }
@@ -485,7 +487,7 @@ impl<'a> Interpreter<'a> {
             HirArrayLiteral::Repeated { repeated_element, length } => {
                 let element = self.evaluate(repeated_element)?;
 
-                if let Some(length) = length.evaluate_to_u64() {
+                if let Some(length) = length.evaluate_to_u32() {
                     let elements = (0..length).map(|_| element.clone()).collect();
                     Ok(Value::Array(elements, typ))
                 } else {
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 6cf0a1d9011..43d461ad043 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -59,7 +59,7 @@ impl Value {
             Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
             Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
             Value::String(value) => {
-                let length = Type::Constant(value.len() as u64);
+                let length = Type::Constant(value.len() as u32);
                 Type::String(Box::new(length))
             }
             Value::Function(_, typ) => return Cow::Borrowed(typ),
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 8f15d7688de..18e1a5a22ca 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1987,7 +1987,7 @@ impl<'a> Resolver<'a> {
         self.interner.push_expr(hir_block)
     }
 
-    fn eval_global_as_array_length(&mut self, global: GlobalId, path: &Path) -> u64 {
+    fn eval_global_as_array_length(&mut self, global: GlobalId, path: &Path) -> u32 {
         let Some(stmt) = self.interner.get_global_let_statement(global) else {
             let path = path.clone();
             self.push_err(ResolverError::NoSuchNumericTypeVariable { path });
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 6504ead178f..50af9dbf34e 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -54,7 +54,7 @@ impl<'interner> TypeChecker<'interner> {
     fn check_hir_array_literal(
         &mut self,
         hir_array_literal: HirArrayLiteral,
-    ) -> (Result<u64, Box<Type>>, Box<Type>) {
+    ) -> (Result<u32, Box<Type>>, Box<Type>) {
         match hir_array_literal {
             HirArrayLiteral::Standard(arr) => {
                 let elem_types = vecmap(&arr, |arg| self.check_expression(arg));
@@ -81,7 +81,7 @@ impl<'interner> TypeChecker<'interner> {
                     });
                 }
 
-                (Ok(arr.len() as u64), Box::new(first_elem_type.clone()))
+                (Ok(arr.len() as u32), Box::new(first_elem_type.clone()))
             }
             HirArrayLiteral::Repeated { repeated_element, length } => {
                 let elem_type = self.check_expression(&repeated_element);
@@ -131,11 +131,11 @@ impl<'interner> TypeChecker<'interner> {
                 HirLiteral::Bool(_) => Type::Bool,
                 HirLiteral::Integer(_, _) => self.polymorphic_integer_or_field(),
                 HirLiteral::Str(string) => {
-                    let len = Type::Constant(string.len() as u64);
+                    let len = Type::Constant(string.len() as u32);
                     Type::String(Box::new(len))
                 }
                 HirLiteral::FmtStr(string, idents) => {
-                    let len = Type::Constant(string.len() as u64);
+                    let len = Type::Constant(string.len() as u32);
                     let types = vecmap(&idents, |elem| self.check_expression(elem));
                     Type::FmtString(Box::new(len), Box::new(Type::Tuple(types)))
                 }
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index cf9aafbb308..ff8b11f3916 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -102,7 +102,7 @@ pub enum Type {
 
     /// A type-level integer. Included to let an Array's size type variable
     /// bind to an integer without special checks to bind it to a non-type.
-    Constant(u64),
+    Constant(u32),
 
     /// The type of quoted code in macros. This is always a comptime-only type
     Code,
@@ -121,10 +121,10 @@ impl Type {
             Type::FieldElement | Type::Integer { .. } | Type::Bool => 1,
             Type::Array(size, typ) => {
                 let length = size
-                    .evaluate_to_u64()
+                    .evaluate_to_u32()
                     .expect("Cannot have variable sized arrays as a parameter to main");
                 let typ = typ.as_ref();
-                (length as u32) * typ.field_count()
+                length * typ.field_count()
             }
             Type::Struct(def, args) => {
                 let struct_type = def.borrow();
@@ -135,12 +135,9 @@ impl Type {
             Type::Tuple(fields) => {
                 fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count())
             }
-            Type::String(size) => {
-                let size = size
-                    .evaluate_to_u64()
-                    .expect("Cannot have variable sized strings as a parameter to main");
-                size as u32
-            }
+            Type::String(size) => size
+                .evaluate_to_u32()
+                .expect("Cannot have variable sized strings as a parameter to main"),
             Type::FmtString(_, _)
             | Type::Unit
             | Type::TypeVariable(_, _)
@@ -457,7 +454,7 @@ pub enum TypeVariableKind {
     /// A potentially constant array size. This will only bind to itself or
     /// Type::Constant(n) with a matching size. This defaults to Type::Constant(n) if still unbound
     /// during monomorphization.
-    Constant(u64),
+    Constant(u32),
 }
 
 /// A TypeVariable is a mutable reference that is either
@@ -551,7 +548,7 @@ impl Type {
     }
 
     pub fn default_int_type() -> Type {
-        Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour)
+        Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo)
     }
 
     pub fn type_variable(id: TypeVariableId) -> Type {
@@ -561,7 +558,7 @@ impl Type {
 
     /// Returns a TypeVariable(_, TypeVariableKind::Constant(length)) to bind to
     /// a constant integer for e.g. an array length.
-    pub fn constant_variable(length: u64, interner: &mut NodeInterner) -> Type {
+    pub fn constant_variable(length: u32, interner: &mut NodeInterner) -> Type {
         let id = interner.next_type_variable_id();
         let kind = TypeVariableKind::Constant(length);
         let var = TypeVariable::unbound(id);
@@ -962,7 +959,7 @@ impl Type {
     fn try_bind_to_maybe_constant(
         &self,
         var: &TypeVariable,
-        target_length: u64,
+        target_length: u32,
         bindings: &mut TypeBindings,
     ) -> Result<(), UnificationError> {
         let target_id = match &*var.borrow() {
@@ -1383,17 +1380,17 @@ impl Type {
     }
 
     /// If this type is a Type::Constant (used in array lengths), or is bound
-    /// to a Type::Constant, return the constant as a u64.
-    pub fn evaluate_to_u64(&self) -> Option<u64> {
+    /// to a Type::Constant, return the constant as a u32.
+    pub fn evaluate_to_u32(&self) -> Option<u32> {
         if let Some(binding) = self.get_inner_type_variable() {
             if let TypeBinding::Bound(binding) = &*binding.borrow() {
-                return binding.evaluate_to_u64();
+                return binding.evaluate_to_u32();
             }
         }
 
         match self {
             Type::TypeVariable(_, TypeVariableKind::Constant(size)) => Some(*size),
-            Type::Array(len, _elem) => len.evaluate_to_u64(),
+            Type::Array(len, _elem) => len.evaluate_to_u32(),
             Type::Constant(x) => Some(*x),
             _ => None,
         }
@@ -1787,7 +1784,7 @@ fn convert_array_expression_to_slice(
 
 impl BinaryTypeOperator {
     /// Return the actual rust numeric function associated with this operator
-    pub fn function(self) -> fn(u64, u64) -> u64 {
+    pub fn function(self) -> fn(u32, u32) -> u32 {
         match self {
             BinaryTypeOperator::Addition => |a, b| a.wrapping_add(b),
             BinaryTypeOperator::Subtraction => |a, b| a.wrapping_sub(b),
@@ -1824,7 +1821,7 @@ impl From<&Type> for PrintableType {
         match value {
             Type::FieldElement => PrintableType::Field,
             Type::Array(size, typ) => {
-                let length = size.evaluate_to_u64().expect("Cannot print variable sized arrays");
+                let length = size.evaluate_to_u32().expect("Cannot print variable sized arrays");
                 let typ = typ.as_ref();
                 PrintableType::Array { length, typ: Box::new(typ.into()) }
             }
@@ -1850,7 +1847,7 @@ impl From<&Type> for PrintableType {
             }
             Type::Bool => PrintableType::Boolean,
             Type::String(size) => {
-                let size = size.evaluate_to_u64().expect("Cannot print variable sized strings");
+                let size = size.evaluate_to_u32().expect("Cannot print variable sized strings");
                 PrintableType::String { length: size }
             }
             Type::FmtString(_, _) => unreachable!("format strings cannot be printed"),
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 15c27ee344c..99ac08ddfc2 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -278,11 +278,11 @@ pub struct Function {
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum Type {
     Field,
-    Array(/*len:*/ u64, Box<Type>), // Array(4, Field) = [Field; 4]
+    Array(/*len:*/ u32, Box<Type>), // Array(4, Field) = [Field; 4]
     Integer(Signedness, /*bits:*/ IntegerBitSize), // u32 = Integer(unsigned, ThirtyTwo)
     Bool,
-    String(/*len:*/ u64), // String(4) = str[4]
-    FmtString(/*len:*/ u64, Box<Type>),
+    String(/*len:*/ u32), // String(4) = str[4]
+    FmtString(/*len:*/ u32, Box<Type>),
     Unit,
     Tuple(Vec<Type>),
     Slice(Box<Type>),
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 2e74eb87e60..b4567bf9af7 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -573,7 +573,7 @@ impl<'interner> Monomorphizer<'interner> {
         let location = self.interner.expr_location(&array);
         let typ = Self::convert_type(&self.interner.id_type(array), location)?;
 
-        let length = length.evaluate_to_u64().ok_or_else(|| {
+        let length = length.evaluate_to_u32().ok_or_else(|| {
             let location = self.interner.expr_location(&array);
             MonomorphizationError::UnknownArrayLength { location }
         })?;
@@ -896,7 +896,7 @@ impl<'interner> Monomorphizer<'interner> {
                     TypeBinding::Unbound(_) => {
                         unreachable!("Unbound type variable used in expression")
                     }
-                    TypeBinding::Bound(binding) => binding.evaluate_to_u64().unwrap_or_else(|| {
+                    TypeBinding::Bound(binding) => binding.evaluate_to_u32().unwrap_or_else(|| {
                         panic!("Non-numeric type variable used in expression expecting a value")
                     }),
                 };
@@ -917,16 +917,16 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::FieldElement => ast::Type::Field,
             HirType::Integer(sign, bits) => ast::Type::Integer(*sign, *bits),
             HirType::Bool => ast::Type::Bool,
-            HirType::String(size) => ast::Type::String(size.evaluate_to_u64().unwrap_or(0)),
+            HirType::String(size) => ast::Type::String(size.evaluate_to_u32().unwrap_or(0)),
             HirType::FmtString(size, fields) => {
-                let size = size.evaluate_to_u64().unwrap_or(0);
+                let size = size.evaluate_to_u32().unwrap_or(0);
                 let fields = Box::new(Self::convert_type(fields.as_ref(), location)?);
                 ast::Type::FmtString(size, fields)
             }
             HirType::Unit => ast::Type::Unit,
             HirType::Array(length, element) => {
                 let element = Box::new(Self::convert_type(element.as_ref(), location)?);
-                let length = match length.evaluate_to_u64() {
+                let length = match length.evaluate_to_u32() {
                     Some(length) => length,
                     None => return Err(MonomorphizationError::TypeAnnotationsNeeded { location }),
                 };
@@ -1304,7 +1304,7 @@ impl<'interner> Monomorphizer<'interner> {
             Expression::Literal(Literal::Integer((byte as u128).into(), int_type.clone(), location))
         });
 
-        let typ = Type::Array(bytes_as_expr.len() as u64, Box::new(int_type));
+        let typ = Type::Array(bytes_as_expr.len() as u32, Box::new(int_type));
 
         let arr_literal = ArrayLiteral { typ, contents: bytes_as_expr };
         Expression::Literal(Literal::Array(arr_literal))
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index a12ecf01b56..d9c9c7f9731 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -11,7 +11,7 @@ use thiserror::Error;
 pub enum PrintableType {
     Field,
     Array {
-        length: u64,
+        length: u32,
         #[serde(rename = "type")]
         typ: Box<PrintableType>,
     },
@@ -34,7 +34,7 @@ pub enum PrintableType {
         fields: Vec<(String, PrintableType)>,
     },
     String {
-        length: u64,
+        length: u32,
     },
     Function {
         arguments: Vec<PrintableType>,
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index 8a8a1fad01c..6fba197dd05 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -4,7 +4,7 @@ use crate::cmp::Ord;
 // by the methods in the `slice` module
 impl<T, N> [T; N] {
     #[builtin(array_len)]
-    pub fn len(self) -> u64 {}
+    pub fn len(self) -> u32 {}
 
     pub fn sort(self) -> Self where T: Ord {
         self.sort_via(|a: T, b: T| a <= b)
@@ -31,7 +31,7 @@ impl<T, N> [T; N] {
     }
 
     /// Returns the index of the elements in the array that would sort it, using the provided custom sorting function.
-    unconstrained fn get_sorting_index<Env>(self, ordering: fn[Env](T, T) -> bool) -> [u64; N] {
+    unconstrained fn get_sorting_index<Env>(self, ordering: fn[Env](T, T) -> bool) -> [u32; N] {
         let mut result = [0; N];
         let mut a = self;
         for i in 0..N {
@@ -110,7 +110,7 @@ impl<T, N> [T; N] {
 
 // helper function used to look up the position of a value in an array of Field
 // Note that function returns 0 if the value is not found
-unconstrained fn find_index<N>(a: [u64; N], find: u64) -> u64 {
+unconstrained fn find_index<N>(a: [u32; N], find: u32) -> u32 {
     let mut result = 0;
     for i in 0..a.len() {
         if a[i] == find {
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 65f3716dd34..aae96e5943d 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -2,7 +2,7 @@ use crate::{cmp::Eq, convert::From};
 
 struct BoundedVec<T, MaxLen> {
     storage: [T; MaxLen],
-    len: u64,
+    len: u32,
 }
 
 impl<T, MaxLen> BoundedVec<T, MaxLen> {
@@ -11,12 +11,12 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         BoundedVec { storage: [zeroed; MaxLen], len: 0 }
     }
 
-    pub fn get(mut self: Self, index: u64) -> T {
+    pub fn get(mut self: Self, index: u32) -> T {
         assert(index < self.len);
         self.storage[index]
     }
 
-    pub fn get_unchecked(mut self: Self, index: u64) -> T {
+    pub fn get_unchecked(mut self: Self, index: u32) -> T {
         self.storage[index]
     }
 
@@ -27,11 +27,11 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len += 1;
     }
 
-    pub fn len(self) -> u64 {
+    pub fn len(self) -> u32 {
         self.len
     }
 
-    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {
         MaxLen
     }
 
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index 5f8cc6dab62..84e94166869 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -19,7 +19,7 @@ struct HashMap<K, V, N, B> {
     _table: [Slot<K, V>; N],
 
     // Amount of valid elements in the map.
-    _len: u64,
+    _len: u32,
 
     _build_hasher: B
 }
@@ -262,14 +262,14 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
 
     // Amount of active key-value entries.
     // docs:start:len
-    pub fn len(self) -> u64 {
+    pub fn len(self) -> u32 {
         // docs:end:len
         self._len
     }
 
     // Get the compile-time map capacity.
     // docs:start:capacity
-    pub fn capacity(_self: Self) -> u64 {
+    pub fn capacity(_self: Self) -> u32 {
         // docs:end:capacity
         N
     }
@@ -292,7 +292,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
 
         for attempt in 0..N {
             if !should_break {
-                let index = self.quadratic_probe(hash, attempt as u64);
+                let index = self.quadratic_probe(hash, attempt as u32);
                 let slot = self._table[index];
 
                 // Not marked as deleted and has key-value.
@@ -328,7 +328,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
 
         for attempt in 0..N {
             if !should_break {
-                let index = self.quadratic_probe(hash, attempt as u64);
+                let index = self.quadratic_probe(hash, attempt as u32);
                 let mut slot = self._table[index];
                 let mut insert = false;
 
@@ -368,7 +368,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
 
         for attempt in 0..N {
             if !should_break {
-                let index = self.quadratic_probe(hash, attempt as u64);
+                let index = self.quadratic_probe(hash, attempt as u32);
                 let mut slot = self._table[index];
 
                 // Not marked as deleted and has key-value.
@@ -389,21 +389,21 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
     fn hash(
         self,
         key: K
-    ) -> u64
+    ) -> u32
     where
         K: Hash,
         B: BuildHasher<H>,
         H: Hasher {
         let mut hasher = self._build_hasher.build_hasher();
         key.hash(&mut hasher);
-        hasher.finish() as u64
+        hasher.finish() as u32
     }
 
     // Probing scheme: quadratic function.
     // We use 0.5 constant near variadic attempt and attempt^2 monomials.
     // This ensures good uniformity of distribution for table sizes
     // equal to prime numbers or powers of two. 
-    fn quadratic_probe(_self: Self, hash: u64, attempt: u64) -> u64 {
+    fn quadratic_probe(_self: Self, hash: u32, attempt: u32) -> u32 {
         (hash + (attempt + attempt * attempt) / 2) % N
     }
 
diff --git a/noir_stdlib/src/collections/vec.nr b/noir_stdlib/src/collections/vec.nr
index 56354438c89..18aaa8b9b3b 100644
--- a/noir_stdlib/src/collections/vec.nr
+++ b/noir_stdlib/src/collections/vec.nr
@@ -17,7 +17,7 @@ impl<T> Vec<T> {
     /// Get an element from the vector at the given index.
     /// Panics if the given index
     /// points beyond the end of the vector.
-    pub fn get(self, index: u64) -> T {
+    pub fn get(self, index: u32) -> T {
         self.slice[index]
     }
 
@@ -40,20 +40,20 @@ impl<T> Vec<T> {
 
     /// Insert an element at a specified index, shifting all elements 
     /// after it to the right
-    pub fn insert(&mut self, index: u64, elem: T) {
+    pub fn insert(&mut self, index: u32, elem: T) {
         self.slice = self.slice.insert(index, elem);
     }
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the removed element
-    pub fn remove(&mut self, index: u64) -> T {
+    pub fn remove(&mut self, index: u32) -> T {
         let (new_slice, elem) = self.slice.remove(index);
         self.slice = new_slice;
         elem
     }
 
     /// Returns the number of elements in the vector
-    pub fn len(self) -> u64 {
+    pub fn len(self) -> u32 {
         self.slice.len()
     }
 }
diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr
index f40ea2738ed..c4b5f0fcb6f 100644
--- a/noir_stdlib/src/hash/poseidon.nr
+++ b/noir_stdlib/src/hash/poseidon.nr
@@ -57,14 +57,14 @@ pub fn permute<T, N, X>(pos_conf: PoseidonConfig<T, N, X>, mut state: [Field; T]
     for _r in 0..rf / 2 - 1 {
         state = sigma(state);
         for i in 0..T {
-            state[i] += round_constants[T * (_r + 1) as u64 + i];
+            state[i] += round_constants[T * (_r + 1) as u32 + i];
         }
         state = apply_matrix(mds, state);
     }
 
     state = sigma(state);
     for i in 0..T {
-        state[i] += round_constants[T * (rf / 2) as u64 + i];
+        state[i] += round_constants[T * (rf / 2) as u32 + i];
     }
     state = apply_matrix(presparse_mds, state);
 
@@ -74,15 +74,15 @@ pub fn permute<T, N, X>(pos_conf: PoseidonConfig<T, N, X>, mut state: [Field; T]
 
     for _r in 0..rp {
         state[0] = state[0].pow_32(alpha);
-        state[0] += round_constants[(rf/2 + 1) as u64 * T + _r as u64];
+        state[0] += round_constants[(rf/2 + 1) as u32 * T + _r as u32];
         crate::as_witness(state[0]);
         {
             let mut newState0 = 0;
             for j in 0..T {
-                newState0 += sparse_mds[(T * 2 - 1) * _r as u64 + j as u64] * state[j];
+                newState0 += sparse_mds[(T * 2 - 1) * _r as u32 + j as u32] * state[j];
             }
             for k in 1..T {
-                state[k] += state[0] * sparse_mds[(t * 2 - 1) as u64 * _r as u64 + T + k - 1];
+                state[k] += state[0] * sparse_mds[(t * 2 - 1) as u32 * _r as u32 + T + k - 1];
             }
             state[0] = newState0;
 
@@ -97,7 +97,7 @@ pub fn permute<T, N, X>(pos_conf: PoseidonConfig<T, N, X>, mut state: [Field; T]
     for _r in 0..rf / 2 - 1 {
         state = sigma(state);
         for i in 0..state.len() {
-            state[i] += round_constants[(rf/2+1) as u64 * T + rp as u64 + (_r as u64) * T + i];
+            state[i] += round_constants[(rf/2+1) as u32 * T + rp as u32 + (_r as u32) * T + i];
         }
         state = apply_matrix(mds, state);
     }
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index e5a82a596c6..04d922b581d 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -12,7 +12,7 @@ struct Poseidon2 {
 
 impl Poseidon2 {
 
-    pub fn hash<N>(input: [Field; N], message_size: u64) -> Field {
+    pub fn hash<N>(input: [Field; N], message_size: u32) -> Field {
         if message_size == N {
             Poseidon2::hash_internal(input, N, false)
         } else {
@@ -95,7 +95,7 @@ impl Poseidon2 {
         result
     }
 
-    fn hash_internal<N>(input: [Field; N], in_len: u64, is_variable_length: bool) -> Field {
+    fn hash_internal<N>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
         let two_pow_64 = 18446744073709551616;
         let iv : Field = (in_len as Field) * two_pow_64;
         let mut sponge = Poseidon2::new(iv);
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index ac542a960ed..bf05ae0cf64 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -1,6 +1,6 @@
 impl<T> [T] {
     #[builtin(array_len)]
-    pub fn len(self) -> u64 {}
+    pub fn len(self) -> u32 {}
 
     /// Push a new element to the end of the slice, returning a
     /// new slice with a length one greater than the
@@ -27,13 +27,13 @@ impl<T> [T] {
     /// Insert an element at a specified index, shifting all elements 
     /// after it to the right
     #[builtin(slice_insert)]
-    pub fn insert(self, index: u64, elem: T) -> Self {}
+    pub fn insert(self, index: u32, elem: T) -> Self {}
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the altered slice and 
     /// the removed element
     #[builtin(slice_remove)]
-    pub fn remove(self, index: u64) -> (Self, T) {}
+    pub fn remove(self, index: u32) -> (Self, T) {}
 
     // Append each element of the `other` slice to the end of `self`.
     // This returns a new slice and leaves both input slices unchanged.
diff --git a/test_programs/execution_success/array_len/src/main.nr b/test_programs/execution_success/array_len/src/main.nr
index f846cfb9844..45c09b8a282 100644
--- a/test_programs/execution_success/array_len/src/main.nr
+++ b/test_programs/execution_success/array_len/src/main.nr
@@ -1,12 +1,12 @@
-fn len_plus_1<T, N>(array: [T; N]) -> u64 {
+fn len_plus_1<T, N>(array: [T; N]) -> u32 {
     array.len() + 1
 }
 
-fn add_lens<T, N, M>(a: [T; N], b: [Field; M]) -> u64 {
+fn add_lens<T, N, M>(a: [T; N], b: [Field; M]) -> u32 {
     a.len() + b.len()
 }
 
-fn nested_call<N>(b: [Field; N]) -> u64 {
+fn nested_call<N>(b: [Field; N]) -> u32 {
     len_plus_1(b)
 }
 
diff --git a/test_programs/execution_success/brillig_array_to_slice/src/main.nr b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
index 8f7fcf24bae..262d3b5d86a 100644
--- a/test_programs/execution_success/brillig_array_to_slice/src/main.nr
+++ b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
@@ -1,4 +1,4 @@
-unconstrained fn brillig_as_slice(x: Field) -> (u64, Field, Field) {
+unconstrained fn brillig_as_slice(x: Field) -> (u32, Field, Field) {
     let mut dynamic: [Field; 1] = [1];
     dynamic[x] = 2;
     assert(dynamic[0] == 2);
diff --git a/test_programs/execution_success/regression/src/main.nr b/test_programs/execution_success/regression/src/main.nr
index 316c0d6bad6..e60791aface 100644
--- a/test_programs/execution_success/regression/src/main.nr
+++ b/test_programs/execution_success/regression/src/main.nr
@@ -1,4 +1,4 @@
-global NIBBLE_LENGTH: u64 = 16;
+global NIBBLE_LENGTH: u32 = 16;
 
 struct U4 {
     inner: u8,
@@ -22,7 +22,7 @@ impl Eq for U4 {
 
 fn compact_decode<N>(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {
     assert(2 * input.len() <= NIBBLE_LENGTH);
-    assert(length as u64 <= input.len());
+    assert(length as u32 <= input.len());
 
     let mut nibble = [U4::zero(); NIBBLE_LENGTH];
 
@@ -32,7 +32,7 @@ fn compact_decode<N>(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Fie
     if parity == 1 {
         nibble[0] = U4::from_u8(input[0] & 0x0f);
         for i in 1..input.len() {
-            if i as u64 < length as u64 {
+            if i as u32 < length as u32 {
                 let x = input[i];
                 nibble[2*i - 1] = U4::from_u8(x >> 4);
                 nibble[2*i] = U4::from_u8(x & 0x0f);
@@ -40,7 +40,7 @@ fn compact_decode<N>(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Fie
         }
     } else {
         for i in 0..2 {
-            if (i as u64) < length as u64 - 1 {
+            if (i as u32) < length as u32 - 1 {
                 let x = input[i + 1];
                 nibble[2*i] = U4::from_u8(x >> 4);
                 nibble[2*i + 1] = U4::from_u8(x & 0x0f);
diff --git a/test_programs/execution_success/slice_dynamic_index/src/main.nr b/test_programs/execution_success/slice_dynamic_index/src/main.nr
index 9b97c0721bb..2ab633eb98c 100644
--- a/test_programs/execution_success/slice_dynamic_index/src/main.nr
+++ b/test_programs/execution_success/slice_dynamic_index/src/main.nr
@@ -124,12 +124,12 @@ fn dynamic_slice_merge_if(mut slice: [Field], x: Field) {
         assert(first_elem == 12);
         assert(rest_of_slice.len() == 6);
 
-        slice = rest_of_slice.insert(x as u64 - 2, 20);
+        slice = rest_of_slice.insert(x as u32 - 2, 20);
         assert(slice[2] == 20);
         assert(slice[6] == 30);
         assert(slice.len() == 7);
 
-        let (removed_slice, removed_elem) = slice.remove(x as u64 - 1);
+        let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);
         // The deconstructed tuple assigns to the slice but is not seen outside of the if statement
         // without a direct assignment
         slice = removed_slice;
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 3695fa47842..d2c0bb3ea00 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -96,10 +96,10 @@ impl DebugVars {
                     PrintableType::Array { length, typ },
                 ) => {
                     assert!(!*is_slice, "slice has array type");
-                    if *index as u64 >= *length {
+                    if *index >= *length {
                         panic!("unexpected field index past array length")
                     }
-                    if *length != array_elements.len() as u64 {
+                    if *length != array_elements.len() as u32 {
                         panic!("type/array length mismatch")
                     }
                     (array_elements.get_mut(*index as usize).unwrap(), &*Box::leak(typ.clone()))
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 0acace71fb3..b1ddba26f15 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -51,7 +51,7 @@ pub const MAIN_RETURN_NAME: &str = "return";
 pub enum AbiType {
     Field,
     Array {
-        length: u64,
+        length: u32,
         #[serde(rename = "type")]
         typ: Box<AbiType>,
     },
@@ -72,7 +72,7 @@ pub enum AbiType {
         fields: Vec<AbiType>,
     },
     String {
-        length: u64,
+        length: u32,
     },
 }
 
@@ -137,7 +137,7 @@ impl AbiType {
             Type::FieldElement => Self::Field,
             Type::Array(size, typ) => {
                 let length = size
-                    .evaluate_to_u64()
+                    .evaluate_to_u32()
                     .expect("Cannot have variable sized arrays as a parameter to main");
                 let typ = typ.as_ref();
                 Self::Array { length, typ: Box::new(Self::from_type(context, typ)) }
@@ -160,7 +160,7 @@ impl AbiType {
             Type::Bool => Self::Boolean,
             Type::String(size) => {
                 let size = size
-                    .evaluate_to_u64()
+                    .evaluate_to_u32()
                     .expect("Cannot have variable sized strings as a parameter to main");
                 Self::String { length: size }
             }
@@ -198,14 +198,14 @@ impl AbiType {
     pub fn field_count(&self) -> u32 {
         match self {
             AbiType::Field | AbiType::Integer { .. } | AbiType::Boolean => 1,
-            AbiType::Array { length, typ } => typ.field_count() * (*length as u32),
+            AbiType::Array { length, typ } => typ.field_count() * *length,
             AbiType::Struct { fields, .. } => {
                 fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count())
             }
             AbiType::Tuple { fields } => {
                 fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count())
             }
-            AbiType::String { length } => *length as u32,
+            AbiType::String { length } => *length,
         }
     }
 }
@@ -600,14 +600,14 @@ fn range_to_vec(ranges: &[Range<Witness>]) -> Vec<Witness> {
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(tag = "error_kind", rename_all = "lowercase")]
 pub enum AbiErrorType {
-    FmtString { length: u64, item_types: Vec<AbiType> },
+    FmtString { length: u32, item_types: Vec<AbiType> },
     Custom(AbiType),
 }
 impl AbiErrorType {
     pub fn from_type(context: &Context, typ: &Type) -> Self {
         match typ {
             Type::FmtString(len, item_types) => {
-                let length = len.evaluate_to_u64().expect("Cannot evaluate fmt length");
+                let length = len.evaluate_to_u32().expect("Cannot evaluate fmt length");
                 let Type::Tuple(item_types) = item_types.as_ref() else {
                     unreachable!("FmtString items must be a tuple")
                 };

From ab0b1a85cc91f8ed748ee393ece54f5c3b43d7ef Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 5 Jun 2024 17:37:14 +0100
Subject: [PATCH 340/416] fix(experimental elaborator): Fix globals which use
 function calls (#5172)

# Description

## Problem\*

Resolves an issue where we would give a type error if a global ever used
a function call in its definition.

## Summary\*

This one was more difficult to fix than it seemed since fixing the main
bug revealed progressively more bugs.

## Additional Context

https://github.com/noir-lang/noir/pull/5170 is included here as well to
help me see that all tests are now passing.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 Cargo.lock                                    |   1 -
 compiler/noirc_driver/Cargo.toml              |   1 -
 compiler/noirc_driver/src/lib.rs              |  20 ++-
 compiler/noirc_frontend/src/elaborator/mod.rs | 124 +++++++++++-------
 .../noirc_frontend/src/elaborator/patterns.rs |  65 +++++----
 .../src/elaborator/statements.rs              |  54 ++++----
 .../noirc_frontend/src/elaborator/traits.rs   |   5 +-
 .../noirc_frontend/src/elaborator/types.rs    |  32 ++---
 .../src/hir/comptime/interpreter.rs           |   7 +-
 .../src/hir/resolution/resolver.rs            |   4 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  |   2 +
 .../noirc_frontend/src/hir_def/function.rs    |  25 ++++
 .../src/monomorphization/errors.rs            |  23 ++--
 .../src/monomorphization/mod.rs               |  17 ++-
 compiler/noirc_frontend/src/node_interner.rs  |   7 +
 tooling/nargo_cli/build.rs                    |  88 +++++++++++++
 16 files changed, 323 insertions(+), 152 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4b140a513f2..61bfdd08c0e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2775,7 +2775,6 @@ dependencies = [
  "noirc_frontend",
  "rust-embed",
  "serde",
- "thiserror",
  "tracing",
 ]
 
diff --git a/compiler/noirc_driver/Cargo.toml b/compiler/noirc_driver/Cargo.toml
index 495410b7b06..a9949f5093a 100644
--- a/compiler/noirc_driver/Cargo.toml
+++ b/compiler/noirc_driver/Cargo.toml
@@ -24,6 +24,5 @@ serde.workspace = true
 fxhash.workspace = true
 rust-embed.workspace = true
 tracing.workspace = true
-thiserror.workspace = true
 
 aztec_macros = { path = "../../aztec_macros" }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index d7368f299b8..848d9987ca3 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -24,7 +24,6 @@ use noirc_frontend::monomorphization::{
 use noirc_frontend::node_interner::FuncId;
 use noirc_frontend::token::SecondaryAttribute;
 use std::path::Path;
-use thiserror::Error;
 use tracing::info;
 
 mod abi_gen;
@@ -117,13 +116,22 @@ fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error
     }
 }
 
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum CompileError {
-    #[error(transparent)]
-    MonomorphizationError(#[from] MonomorphizationError),
+    MonomorphizationError(MonomorphizationError),
+    RuntimeError(RuntimeError),
+}
 
-    #[error(transparent)]
-    RuntimeError(#[from] RuntimeError),
+impl From<MonomorphizationError> for CompileError {
+    fn from(error: MonomorphizationError) -> Self {
+        Self::MonomorphizationError(error)
+    }
+}
+
+impl From<RuntimeError> for CompileError {
+    fn from(error: RuntimeError) -> Self {
+        Self::RuntimeError(error)
+    }
 }
 
 impl From<CompileError> for FileDiagnostic {
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 649a93b0bd6..9403e12496f 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -18,12 +18,17 @@ use crate::{
         scope::ScopeForest as GenericScopeForest,
         type_check::{check_trait_impl_method_matches_declaration, TypeCheckError},
     },
-    hir_def::{expr::HirIdent, function::Parameters, traits::TraitConstraint},
+    hir_def::{
+        expr::HirIdent,
+        function::{FunctionBody, Parameters},
+        traits::TraitConstraint,
+    },
     macros_api::{
-        Ident, NodeInterner, NoirFunction, NoirStruct, Pattern, SecondaryAttribute, StructId,
+        BlockExpression, Ident, NodeInterner, NoirFunction, NoirStruct, Pattern,
+        SecondaryAttribute, StructId,
     },
     node_interner::{
-        DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, TraitId, TypeAliasId,
+        DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, TraitId, TypeAliasId,
     },
     Shared, Type, TypeVariable,
 };
@@ -134,7 +139,8 @@ pub struct Elaborator<'context> {
     /// ```
     resolving_ids: BTreeSet<StructId>,
 
-    trait_bounds: Vec<UnresolvedTraitConstraint>,
+    /// Each constraint in the `where` clause of the function currently being resolved.
+    trait_bounds: Vec<TraitConstraint>,
 
     current_function: Option<FuncId>,
 
@@ -271,17 +277,29 @@ impl<'context> Elaborator<'context> {
         self.trait_id = functions.trait_id; // TODO: Resolve?
         self.self_type = functions.self_type;
 
-        for (local_module, id, func) in functions.functions {
+        for (local_module, id, _) in functions.functions {
             self.local_module = local_module;
-            self.recover_generics(|this| this.elaborate_function(func, id));
+            self.recover_generics(|this| this.elaborate_function(id));
         }
 
         self.self_type = None;
         self.trait_id = None;
     }
 
-    fn elaborate_function(&mut self, function: NoirFunction, id: FuncId) {
-        self.current_function = Some(id);
+    fn elaborate_function(&mut self, id: FuncId) {
+        let func_meta = self.interner.func_meta.get_mut(&id);
+        let func_meta =
+            func_meta.expect("FuncMetas should be declared before a function is elaborated");
+
+        let (kind, body, body_span) = match func_meta.take_body() {
+            FunctionBody::Unresolved(kind, body, span) => (kind, body, span),
+            FunctionBody::Resolved => return,
+            // Do not error for the still-resolving case. If there is a dependency cycle,
+            // the dependency cycle check will find it later on.
+            FunctionBody::Resolving => return,
+        };
+
+        let old_function = std::mem::replace(&mut self.current_function, Some(id));
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
         if self.self_type.is_some() {
@@ -289,20 +307,17 @@ impl<'context> Elaborator<'context> {
         }
 
         self.scopes.start_function();
-        self.current_item = Some(DependencyId::Function(id));
+        let old_item = std::mem::replace(&mut self.current_item, Some(DependencyId::Function(id)));
+
+        let func_meta = func_meta.clone();
 
-        self.trait_bounds = function.def.where_clause.clone();
+        self.trait_bounds = func_meta.trait_constraints.clone();
 
-        if function.def.is_unconstrained {
+        if self.interner.function_modifiers(&id).is_unconstrained {
             self.in_unconstrained_fn = true;
         }
 
-        let func_meta = self.interner.func_meta.get(&id);
-        let func_meta = func_meta
-            .expect("FuncMetas should be declared before a function is elaborated")
-            .clone();
-
-        // The `DefinitionId`s for each parameter were already created in `define_function_meta`
+        // The DefinitionIds for each parameter were already created in define_function_meta
         // so we need to reintroduce the same IDs into scope here.
         for parameter in &func_meta.parameter_idents {
             let name = self.interner.definition_name(parameter.id).to_owned();
@@ -313,14 +328,13 @@ impl<'context> Elaborator<'context> {
         self.declare_numeric_generics(&func_meta.parameters, func_meta.return_type());
         self.add_trait_constraints_to_scope(&func_meta);
 
-        let (hir_func, body_type) = match function.kind {
+        let (hir_func, body_type) = match kind {
             FunctionKind::Builtin | FunctionKind::LowLevel | FunctionKind::Oracle => {
                 (HirFunction::empty(), Type::Error)
             }
             FunctionKind::Normal | FunctionKind::Recursive => {
-                let block_span = function.def.span;
-                let (block, body_type) = self.elaborate_block(function.def.body);
-                let expr_id = self.intern_expr(block, block_span);
+                let (block, body_type) = self.elaborate_block(body);
+                let expr_id = self.intern_expr(block, body_span);
                 self.interner.push_expr_type(expr_id, body_type.clone());
                 (HirFunction::unchecked_from_expr(expr_id), body_type)
             }
@@ -372,10 +386,19 @@ impl<'context> Elaborator<'context> {
             self.check_for_unused_variables_in_scope_tree(func_scope_tree);
         }
 
-        self.trait_bounds.clear();
+        let meta = self
+            .interner
+            .func_meta
+            .get_mut(&id)
+            .expect("FuncMetas should be declared before a function is elaborated");
+
+        meta.function_body = FunctionBody::Resolved;
 
+        self.trait_bounds.clear();
+        self.in_unconstrained_fn = false;
         self.interner.update_fn(id, hir_func);
-        self.current_function = None;
+        self.current_function = old_function;
+        self.current_item = old_item;
     }
 
     /// This turns function parameters of the form:
@@ -442,15 +465,6 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn resolve_where_clause(&mut self, clause: &mut [UnresolvedTraitConstraint]) {
-        for bound in clause {
-            if let Some(trait_id) = self.resolve_trait_by_path(bound.trait_bound.trait_path.clone())
-            {
-                bound.trait_bound.trait_id = Some(trait_id);
-            }
-        }
-    }
-
     fn resolve_trait_by_path(&mut self, path: Path) -> Option<TraitId> {
         let path_resolver = StandardPathResolver::new(self.module_id());
 
@@ -522,9 +536,6 @@ impl<'context> Elaborator<'context> {
         is_trait_function: bool,
     ) {
         self.current_function = Some(func_id);
-        self.resolve_where_clause(&mut func.def.where_clause);
-        // `func` is no longer mutated.
-        let func = &*func;
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
         if self.self_type.is_some() {
@@ -594,6 +605,7 @@ impl<'context> Elaborator<'context> {
                 typ.clone(),
                 DefinitionKind::Local(None),
                 &mut parameter_idents,
+                None,
             );
 
             parameters.push((pattern, typ.clone(), visibility));
@@ -616,6 +628,9 @@ impl<'context> Elaborator<'context> {
             .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
             .collect();
 
+        let statements = std::mem::take(&mut func.def.body.statements);
+        let body = BlockExpression { statements };
+
         let meta = FuncMeta {
             name: name_ident,
             kind: func.kind,
@@ -633,6 +648,7 @@ impl<'context> Elaborator<'context> {
             is_entry_point,
             is_trait_function,
             has_inline_attribute,
+            function_body: FunctionBody::Unresolved(func.kind, body, func.def.span),
         };
 
         self.interner.push_fn_meta(meta, func_id);
@@ -1109,19 +1125,12 @@ impl<'context> Elaborator<'context> {
 
         let comptime = let_stmt.comptime;
 
-        self.elaborate_global_let(let_stmt, global_id);
+        let (let_statement, _typ) = self.elaborate_let(let_stmt, Some(global_id));
+        let statement_id = self.interner.get_global(global_id).let_statement;
+        self.interner.replace_statement(statement_id, let_statement);
 
         if comptime {
-            let let_statement = self
-                .interner
-                .get_global_let_statement(global_id)
-                .expect("Let statement of global should be set by elaborate_global_let");
-
-            let mut interpreter = Interpreter::new(self.interner, &mut self.comptime_scopes);
-
-            if let Err(error) = interpreter.evaluate_let(let_statement) {
-                self.errors.push(error.into_compilation_error_pair());
-            }
+            self.elaborate_comptime_global(global_id);
         }
 
         // Avoid defaulting the types of globals here since they may be used in any function.
@@ -1130,6 +1139,29 @@ impl<'context> Elaborator<'context> {
         self.type_variables.clear();
     }
 
+    fn elaborate_comptime_global(&mut self, global_id: GlobalId) {
+        let let_statement = self
+            .interner
+            .get_global_let_statement(global_id)
+            .expect("Let statement of global should be set by elaborate_global_let");
+
+        let global = self.interner.get_global(global_id);
+        let definition_id = global.definition_id;
+        let location = global.location;
+
+        let mut interpreter = Interpreter::new(self.interner, &mut self.comptime_scopes);
+
+        if let Err(error) = interpreter.evaluate_let(let_statement) {
+            self.errors.push(error.into_compilation_error_pair());
+        } else {
+            let value = interpreter
+                .lookup_id(definition_id, location)
+                .expect("The global should be defined since evaluate_let did not error");
+
+            self.interner.get_global_mut(global_id).value = Some(value);
+        }
+    }
+
     fn define_function_metas(
         &mut self,
         functions: &mut [UnresolvedFunctions],
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 12b0b7b5e64..411caeba7b8 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -11,10 +11,11 @@ use crate::{
     },
     hir_def::{
         expr::{HirIdent, ImplKind},
+        function::FunctionBody,
         stmt::HirPattern,
     },
     macros_api::{HirExpression, Ident, Path, Pattern},
-    node_interner::{DefinitionId, DefinitionKind, ExprId, TraitImplKind},
+    node_interner::{DefinitionId, DefinitionKind, DependencyId, ExprId, GlobalId, TraitImplKind},
     Shared, StructType, Type, TypeBindings,
 };
 
@@ -27,7 +28,14 @@ impl<'context> Elaborator<'context> {
         expected_type: Type,
         definition_kind: DefinitionKind,
     ) -> HirPattern {
-        self.elaborate_pattern_mut(pattern, expected_type, definition_kind, None, &mut Vec::new())
+        self.elaborate_pattern_mut(
+            pattern,
+            expected_type,
+            definition_kind,
+            None,
+            &mut Vec::new(),
+            None,
+        )
     }
 
     /// Equivalent to `elaborate_pattern`, this version just also
@@ -38,8 +46,16 @@ impl<'context> Elaborator<'context> {
         expected_type: Type,
         definition_kind: DefinitionKind,
         created_ids: &mut Vec<HirIdent>,
+        global_id: Option<GlobalId>,
     ) -> HirPattern {
-        self.elaborate_pattern_mut(pattern, expected_type, definition_kind, None, created_ids)
+        self.elaborate_pattern_mut(
+            pattern,
+            expected_type,
+            definition_kind,
+            None,
+            created_ids,
+            global_id,
+        )
     }
 
     fn elaborate_pattern_mut(
@@ -49,6 +65,7 @@ impl<'context> Elaborator<'context> {
         definition: DefinitionKind,
         mutable: Option<Span>,
         new_definitions: &mut Vec<HirIdent>,
+        global_id: Option<GlobalId>,
     ) -> HirPattern {
         match pattern {
             Pattern::Identifier(name) => {
@@ -58,7 +75,14 @@ impl<'context> Elaborator<'context> {
                     (Some(_), DefinitionKind::Local(_)) => DefinitionKind::Local(None),
                     (_, other) => other,
                 };
-                let ident = self.add_variable_decl(name, mutable.is_some(), true, definition);
+                let ident = if let Some(global_id) = global_id {
+                    // Globals don't need to be added to scope, they're already in the def_maps
+                    let id = self.interner.get_global(global_id).definition_id;
+                    let location = Location::new(name.span(), self.file);
+                    HirIdent::non_trait_method(id, location)
+                } else {
+                    self.add_variable_decl(name, mutable.is_some(), true, definition)
+                };
                 self.interner.push_definition_type(ident.id, expected_type);
                 new_definitions.push(ident.clone());
                 HirPattern::Identifier(ident)
@@ -74,6 +98,7 @@ impl<'context> Elaborator<'context> {
                     definition,
                     Some(span),
                     new_definitions,
+                    global_id,
                 );
                 let location = Location::new(span, self.file);
                 HirPattern::Mutable(Box::new(pattern), location)
@@ -104,6 +129,7 @@ impl<'context> Elaborator<'context> {
                         definition.clone(),
                         mutable,
                         new_definitions,
+                        global_id,
                     )
                 });
                 let location = Location::new(span, self.file);
@@ -200,6 +226,7 @@ impl<'context> Elaborator<'context> {
                 definition.clone(),
                 mutable,
                 new_definitions,
+                None,
             );
 
             if unseen_fields.contains(&field) {
@@ -300,7 +327,7 @@ impl<'context> Elaborator<'context> {
         let mut global_id = None;
         let global = self.interner.get_all_globals();
         for global_info in global {
-            if global_info.ident == name && global_info.local_id == self.local_module {
+            if global_info.local_id == self.local_module && global_info.ident == name {
                 global_id = Some(global_info.id);
             }
         }
@@ -332,22 +359,6 @@ impl<'context> Elaborator<'context> {
         ident
     }
 
-    // Checks for a variable having been declared before.
-    // (Variable declaration and definition cannot be separate in Noir.)
-    // Once the variable has been found, intern and link `name` to this definition,
-    // returning (the ident, the IdentId of `name`)
-    //
-    // If a variable is not found, then an error is logged and a dummy id
-    // is returned, for better error reporting UX
-    pub(super) fn find_variable_or_default(&mut self, name: &Ident) -> (HirIdent, usize) {
-        self.use_variable(name).unwrap_or_else(|error| {
-            self.push_err(error);
-            let id = DefinitionId::dummy_id();
-            let location = Location::new(name.span(), self.file);
-            (HirIdent::non_trait_method(id, location), 0)
-        })
-    }
-
     /// Lookup and use the specified variable.
     /// This will increment its use counter by one and return the variable if found.
     /// If the variable is not found, an error is returned.
@@ -404,6 +415,16 @@ impl<'context> Elaborator<'context> {
                 match self.interner.definition(hir_ident.id).kind {
                     DefinitionKind::Function(id) => {
                         if let Some(current_item) = self.current_item {
+                            // Lazily evaluate functions found within globals if necessary.
+                            // Otherwise if we later attempt to evaluate the global it will
+                            // see an empty function body.
+                            if matches!(current_item, DependencyId::Global(_)) {
+                                let meta = self.interner.function_meta(&id);
+
+                                if matches!(&meta.function_body, FunctionBody::Unresolved(..)) {
+                                    self.elaborate_function(id);
+                                }
+                            }
                             self.interner.add_function_dependency(current_item, id);
                         }
                     }
@@ -555,7 +576,7 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn get_ident_from_path(&mut self, path: Path) -> (HirIdent, usize) {
+    pub fn get_ident_from_path(&mut self, path: Path) -> (HirIdent, usize) {
         let location = Location::new(path.span(), self.file);
 
         let error = match path.as_ident().map(|ident| self.use_variable(ident)) {
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 5bcd43da6e5..dd3e2778726 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -14,7 +14,7 @@ use crate::{
         },
     },
     macros_api::{
-        ForLoopStatement, ForRange, HirStatement, LetStatement, Statement, StatementKind,
+        ForLoopStatement, ForRange, HirStatement, LetStatement, Path, Statement, StatementKind,
     },
     node_interner::{DefinitionId, DefinitionKind, GlobalId, StmtId},
     Type,
@@ -53,39 +53,27 @@ impl<'context> Elaborator<'context> {
     }
 
     pub(super) fn elaborate_local_let(&mut self, let_stmt: LetStatement) -> (HirStatement, Type) {
-        let (statement, typ, _) = self.elaborate_let(let_stmt);
-        (statement, typ)
+        self.elaborate_let(let_stmt, None)
     }
 
-    /// Elaborates a global let statement. Compared to the local version, this
-    /// version fixes up the result to use the given DefinitionId rather than
-    /// the fresh one defined by the let pattern.
-    pub(super) fn elaborate_global_let(&mut self, let_stmt: LetStatement, global_id: GlobalId) {
-        let (let_statement, _typ, new_ids) = self.elaborate_let(let_stmt);
-        let statement_id = self.interner.get_global(global_id).let_statement;
-
-        // To apply the changes from the fresh id created in elaborate_let to this global
-        // we need to change the definition kind and update the type.
-        assert_eq!(new_ids.len(), 1, "Globals should only define 1 value");
-        let new_id = new_ids[0].id;
-
-        self.interner.definition_mut(new_id).kind = DefinitionKind::Global(global_id);
-
-        let definition_id = self.interner.get_global(global_id).definition_id;
-        let definition_type = self.interner.definition_type(new_id);
-        self.interner.push_definition_type(definition_id, definition_type);
-
-        self.interner.replace_statement(statement_id, let_statement);
-    }
-
-    /// Elaborate a local or global let statement. In addition to the HirLetStatement and unit
-    /// type, this also returns each HirIdent defined by this let statement.
-    fn elaborate_let(&mut self, let_stmt: LetStatement) -> (HirStatement, Type, Vec<HirIdent>) {
+    /// Elaborate a local or global let statement.
+    /// If this is a global let, the DefinitionId of the global is specified so that
+    /// elaborate_pattern can create a Global definition kind with the correct ID
+    /// instead of a local one with a fresh ID.
+    pub(super) fn elaborate_let(
+        &mut self,
+        let_stmt: LetStatement,
+        global_id: Option<GlobalId>,
+    ) -> (HirStatement, Type) {
         let expr_span = let_stmt.expression.span;
         let (expression, expr_type) = self.elaborate_expression(let_stmt.expression);
-        let definition = DefinitionKind::Local(Some(expression));
         let annotated_type = self.resolve_type(let_stmt.r#type);
 
+        let definition = match global_id {
+            None => DefinitionKind::Local(Some(expression)),
+            Some(id) => DefinitionKind::Global(id),
+        };
+
         // First check if the LHS is unspecified
         // If so, then we give it the same type as the expression
         let r#type = if annotated_type != Type::Error {
@@ -109,18 +97,18 @@ impl<'context> Elaborator<'context> {
             expr_type
         };
 
-        let mut created_ids = Vec::new();
         let pattern = self.elaborate_pattern_and_store_ids(
             let_stmt.pattern,
             r#type.clone(),
             definition,
-            &mut created_ids,
+            &mut Vec::new(),
+            global_id,
         );
 
         let attributes = let_stmt.attributes;
         let comptime = let_stmt.comptime;
         let let_ = HirLetStatement { pattern, r#type, expression, attributes, comptime };
-        (HirStatement::Let(let_), Type::Unit, created_ids)
+        (HirStatement::Let(let_), Type::Unit)
     }
 
     pub(super) fn elaborate_constrain(&mut self, stmt: ConstrainStatement) -> (HirStatement, Type) {
@@ -250,7 +238,9 @@ impl<'context> Elaborator<'context> {
         match lvalue {
             LValue::Ident(ident) => {
                 let mut mutable = true;
-                let (ident, scope_index) = self.find_variable_or_default(&ident);
+                let span = ident.span();
+                let path = Path::from_single(ident.0.contents, span);
+                let (ident, scope_index) = self.get_ident_from_path(path);
                 self.resolve_local_variable(ident.clone(), scope_index);
 
                 let typ = if ident.id == DefinitionId::dummy_id() {
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index 30a6f50ad5a..3e04dbc784a 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -149,8 +149,6 @@ impl<'context> Elaborator<'context> {
         let old_generic_count = self.generics.len();
         self.scopes.start_function();
 
-        self.trait_bounds = where_clause.to_vec();
-
         let kind = FunctionKind::Normal;
         let def = FunctionDefinition {
             name: name.clone(),
@@ -174,10 +172,9 @@ impl<'context> Elaborator<'context> {
 
         let mut function = NoirFunction { kind, def };
         self.define_function_meta(&mut function, func_id, true);
-        self.elaborate_function(function, func_id);
+        self.elaborate_function(func_id);
         let _ = self.scopes.end_function();
         // Don't check the scope tree for unused variables, they can't be used in a declaration anyway.
-        self.trait_bounds.clear();
         self.generics.truncate(old_generic_count);
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 5e3ace423e5..159ad1c7493 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -5,10 +5,7 @@ use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
 use crate::{
-    ast::{
-        BinaryOpKind, IntegerBitSize, UnresolvedGenerics, UnresolvedTraitConstraint,
-        UnresolvedTypeExpression,
-    },
+    ast::{BinaryOpKind, IntegerBitSize, UnresolvedGenerics, UnresolvedTypeExpression},
     hir::{
         comptime::{Interpreter, Value},
         def_map::ModuleDefId,
@@ -371,31 +368,18 @@ impl<'context> Elaborator<'context> {
             return None;
         }
 
-        for UnresolvedTraitConstraint { typ, trait_bound } in self.trait_bounds.clone() {
-            if let UnresolvedTypeData::Named(constraint_path, _, _) = &typ.typ {
+        for constraint in self.trait_bounds.clone() {
+            if let Type::NamedGeneric(_, name) = &constraint.typ {
                 // if `path` is `T::method_name`, we're looking for constraint of the form `T: SomeTrait`
-                if constraint_path.segments.len() == 1
-                    && path.segments[0] != constraint_path.last_segment()
-                {
+                if path.segments[0].0.contents != name.as_str() {
                     continue;
                 }
 
-                if let Ok(ModuleDefId::TraitId(trait_id)) =
-                    self.resolve_path(trait_bound.trait_path.clone())
+                let the_trait = self.interner.get_trait(constraint.trait_id);
+                if let Some(method) =
+                    the_trait.find_method(path.segments.last().unwrap().0.contents.as_str())
                 {
-                    let the_trait = self.interner.get_trait(trait_id);
-                    if let Some(method) =
-                        the_trait.find_method(path.segments.last().unwrap().0.contents.as_str())
-                    {
-                        let constraint = TraitConstraint {
-                            trait_id,
-                            typ: self.resolve_type(typ.clone()),
-                            trait_generics: vecmap(trait_bound.trait_generics, |typ| {
-                                self.resolve_type(typ)
-                            }),
-                        };
-                        return Some((method, constraint, true));
-                    }
+                    return Some((method, constraint, true));
                 }
             }
         }
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 8809e63d00a..e1e19ad653c 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -239,6 +239,11 @@ impl<'a> Interpreter<'a> {
 
     /// Mutate an existing variable, potentially from a prior scope
     fn mutate(&mut self, id: DefinitionId, argument: Value, location: Location) -> IResult<()> {
+        // If the id is a dummy, assume the error was already issued elsewhere
+        if id == DefinitionId::dummy_id() {
+            return Ok(());
+        }
+
         for scope in self.scopes.iter_mut().rev() {
             if let Entry::Occupied(mut entry) = scope.entry(id) {
                 entry.insert(argument);
@@ -253,7 +258,7 @@ impl<'a> Interpreter<'a> {
         self.lookup_id(ident.id, ident.location)
     }
 
-    fn lookup_id(&self, id: DefinitionId, location: Location) -> IResult<Value> {
+    pub fn lookup_id(&self, id: DefinitionId, location: Location) -> IResult<Value> {
         for scope in self.scopes.iter().rev() {
             if let Some(value) = scope.get(&id) {
                 return Ok(value.clone());
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 18e1a5a22ca..4988628db83 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -20,6 +20,7 @@ use crate::hir_def::expr::{
     HirMethodCallExpression, HirPrefixExpression, ImplKind,
 };
 
+use crate::hir_def::function::FunctionBody;
 use crate::hir_def::traits::{Trait, TraitConstraint};
 use crate::macros_api::SecondaryAttribute;
 use crate::token::{Attributes, FunctionAttribute};
@@ -1078,10 +1079,11 @@ impl<'a> Resolver<'a> {
             is_entry_point: self.is_entry_point_function(func),
             has_inline_attribute,
 
-            // This is only used by the elaborator
+            // These fields are only used by the elaborator
             all_generics: Vec::new(),
             is_trait_function: false,
             parameter_idents: Vec::new(),
+            function_body: FunctionBody::Resolved,
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 65a3186b004..98e1cd9c72a 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -452,6 +452,7 @@ pub mod test {
         PathResolution, PathResolutionError, PathResolutionResult,
     };
     use crate::hir_def::expr::HirIdent;
+    use crate::hir_def::function::FunctionBody;
     use crate::hir_def::stmt::HirLetStatement;
     use crate::hir_def::stmt::HirPattern::Identifier;
     use crate::hir_def::types::Type;
@@ -559,6 +560,7 @@ pub mod test {
             has_inline_attribute: false,
             all_generics: Vec::new(),
             parameter_idents: Vec::new(),
+            function_body: FunctionBody::Resolved,
         };
         interner.push_fn_meta(func_meta, func_id);
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 3bd85e94dca..53eabe21081 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -7,6 +7,7 @@ use super::expr::{HirBlockExpression, HirExpression, HirIdent};
 use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
 use crate::ast::{FunctionKind, FunctionReturnType, Visibility};
+use crate::macros_api::BlockExpression;
 use crate::node_interner::{ExprId, NodeInterner, TraitImplId};
 use crate::{Type, TypeVariable};
 
@@ -142,6 +143,15 @@ pub struct FuncMeta {
     /// that indicates it should be inlined differently than the default (inline everything).
     /// For example, such as `fold` (never inlined) or `no_predicates` (inlined after flattening)
     pub has_inline_attribute: bool,
+
+    pub function_body: FunctionBody,
+}
+
+#[derive(Debug, Clone)]
+pub enum FunctionBody {
+    Unresolved(FunctionKind, BlockExpression, Span),
+    Resolving,
+    Resolved,
 }
 
 impl FuncMeta {
@@ -173,4 +183,19 @@ impl FuncMeta {
             _ => unreachable!(),
         }
     }
+
+    /// Take this function body, returning an owned version while avoiding
+    /// cloning any large Expressions inside by replacing a Unresolved with a Resolving variant.
+    pub fn take_body(&mut self) -> FunctionBody {
+        match &mut self.function_body {
+            FunctionBody::Unresolved(kind, block, span) => {
+                let statements = std::mem::take(&mut block.statements);
+                let (kind, span) = (*kind, *span);
+                self.function_body = FunctionBody::Resolving;
+                FunctionBody::Unresolved(kind, BlockExpression { statements }, span)
+            }
+            FunctionBody::Resolving => FunctionBody::Resolving,
+            FunctionBody::Resolved => FunctionBody::Resolved,
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/errors.rs b/compiler/noirc_frontend/src/monomorphization/errors.rs
index 3011c26cffe..2db570540d6 100644
--- a/compiler/noirc_frontend/src/monomorphization/errors.rs
+++ b/compiler/noirc_frontend/src/monomorphization/errors.rs
@@ -1,14 +1,12 @@
-use thiserror::Error;
-
 use noirc_errors::{CustomDiagnostic, FileDiagnostic, Location};
 
-#[derive(Debug, Error)]
+use crate::hir::comptime::InterpreterError;
+
+#[derive(Debug)]
 pub enum MonomorphizationError {
-    #[error("Length of generic array could not be determined.")]
     UnknownArrayLength { location: Location },
-
-    #[error("Type annotations needed")]
     TypeAnnotationsNeeded { location: Location },
+    InterpreterError(InterpreterError),
 }
 
 impl MonomorphizationError {
@@ -16,6 +14,7 @@ impl MonomorphizationError {
         match self {
             MonomorphizationError::UnknownArrayLength { location }
             | MonomorphizationError::TypeAnnotationsNeeded { location } => *location,
+            MonomorphizationError::InterpreterError(error) => error.get_location(),
         }
     }
 }
@@ -31,9 +30,15 @@ impl From<MonomorphizationError> for FileDiagnostic {
 
 impl MonomorphizationError {
     fn into_diagnostic(self) -> CustomDiagnostic {
-        let message = self.to_string();
-        let location = self.location();
+        let message = match self {
+            MonomorphizationError::UnknownArrayLength { .. } => {
+                "Length of generic array could not be determined."
+            }
+            MonomorphizationError::TypeAnnotationsNeeded { .. } => "Type annotations needed",
+            MonomorphizationError::InterpreterError(error) => return (&error).into(),
+        };
 
-        CustomDiagnostic::simple_error(message, String::new(), location.span)
+        let location = self.location();
+        CustomDiagnostic::simple_error(message.into(), String::new(), location.span)
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index b4567bf9af7..a25d6488c83 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -877,12 +877,19 @@ impl<'interner> Monomorphizer<'interner> {
                 }
             }
             DefinitionKind::Global(global_id) => {
-                let Some(let_) = self.interner.get_global_let_statement(*global_id) else {
-                    unreachable!(
-                        "Globals should have a corresponding let statement by monomorphization"
-                    )
+                let global = self.interner.get_global(*global_id);
+
+                let expr = if let Some(value) = global.value.clone() {
+                    value
+                        .into_hir_expression(self.interner, global.location)
+                        .map_err(MonomorphizationError::InterpreterError)?
+                } else {
+                    let let_ = self.interner.get_global_let_statement(*global_id).expect(
+                        "Globals should have a corresponding let statement by monomorphization",
+                    );
+                    let_.expression
                 };
-                self.expr(let_.expression)?
+                self.expr(expr)?
             }
             DefinitionKind::Local(_) => match self.lookup_captured_expr(ident.id) {
                 Some(expr) => expr,
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index c223017d752..40ca9ce04e0 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -13,6 +13,7 @@ use petgraph::prelude::NodeIndex as PetGraphIndex;
 
 use crate::ast::Ident;
 use crate::graph::CrateId;
+use crate::hir::comptime;
 use crate::hir::def_collector::dc_crate::CompilationError;
 use crate::hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias};
 use crate::hir::def_map::{LocalModuleId, ModuleId};
@@ -466,6 +467,7 @@ pub struct GlobalInfo {
     pub local_id: LocalModuleId,
     pub location: Location,
     pub let_statement: StmtId,
+    pub value: Option<comptime::Value>,
 }
 
 impl Default for NodeInterner {
@@ -681,6 +683,7 @@ impl NodeInterner {
             local_id,
             let_statement,
             location,
+            value: None,
         });
         self.global_attributes.insert(id, attributes);
         id
@@ -1003,6 +1006,10 @@ impl NodeInterner {
         &self.globals[global_id.0]
     }
 
+    pub fn get_global_mut(&mut self, global_id: GlobalId) -> &mut GlobalInfo {
+        &mut self.globals[global_id.0]
+    }
+
     pub fn get_global_definition(&self, global_id: GlobalId) -> &DefinitionInfo {
         let global = self.get_global(global_id);
         self.definition(global.definition_id)
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 53c3966cb4c..25a69489788 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -92,6 +92,17 @@ fn execution_success_{test_name}() {{
     cmd.assert().success();
 }}
 
+#[test]
+fn execution_success_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("execute").arg("--force").arg("--use-elaborator");
+
+    cmd.assert().success();
+}}
+
 #[test]{brillig_ignored}
 fn execution_success_{test_name}_brillig() {{
     let test_program_dir = PathBuf::from("{test_dir}");
@@ -137,6 +148,17 @@ fn execution_failure_{test_name}() {{
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("execute").arg("--force");
 
+    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
+}}
+
+#[test]
+fn execution_failure_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("execute").arg("--force").arg("--use-elaborator");
+
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}
             "#,
@@ -174,6 +196,17 @@ fn noir_test_success_{test_name}() {{
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("test");
 
+    cmd.assert().success();
+}}
+
+#[test]
+fn noir_test_success_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("test").arg("--use-elaborator");
+
     cmd.assert().success();
 }}
             "#,
@@ -211,6 +244,17 @@ fn noir_test_failure_{test_name}() {{
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("test");
 
+    cmd.assert().failure();
+}}
+
+#[test]
+fn noir_test_failure_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("test").arg("--use-elaborator");
+
     cmd.assert().failure();
 }}
             "#,
@@ -259,6 +303,30 @@ fn compile_success_empty_{test_name}() {{
         panic!("`nargo info` failed with: {{}}", String::from_utf8(output.stderr).unwrap_or_default());
     }}
 
+    // `compile_success_empty` tests should be able to compile down to an empty circuit.
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
+        panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
+    }});
+    let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
+    assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
+}}
+
+#[test]
+fn compile_success_empty_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("info");
+    cmd.arg("--json");
+    cmd.arg("--force");
+    cmd.arg("--use-elaborator");
+
+    let output = cmd.output().expect("Failed to execute command");
+
+    if !output.status.success() {{
+        panic!("`nargo info` failed with: {{}}", String::from_utf8(output.stderr).unwrap_or_default());
+    }}
+
     // `compile_success_empty` tests should be able to compile down to an empty circuit.
     let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
         panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
@@ -301,6 +369,16 @@ fn compile_success_contract_{test_name}() {{
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("compile").arg("--force");
 
+    cmd.assert().success();
+}}
+#[test]
+fn compile_success_contract_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("compile").arg("--force").arg("--use-elaborator");
+
     cmd.assert().success();
 }}
             "#,
@@ -338,6 +416,16 @@ fn compile_failure_{test_name}() {{
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("compile").arg("--force");
 
+    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
+}}
+#[test]
+fn compile_failure_elaborator_{test_name}() {{
+    let test_program_dir = PathBuf::from("{test_dir}");
+
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("compile").arg("--force").arg("--use-elaborator");
+
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}
             "#,

From 070d7e71d6587679721437dd5b996478bd17ed85 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 6 Jun 2024 11:55:14 +0200
Subject: [PATCH 341/416] chore: schnorr signature verification in noir (#5188)

# Description

## Problem\*

Resolves #5054 and #4929

## Summary\*
Schnorr signature verification in Noir, using the MSM blackbox.


## Additional Context
The code is added to the schnorr test case, and it has also an assert
version.
This should be moved to the stdlib once we have numeric generics.
Meanwhile you need to pass a message with 32 additional bytes so we can
create an 'hash_input' array of the proper size.


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../execution_success/schnorr/src/main.nr     | 104 ++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/test_programs/execution_success/schnorr/src/main.nr b/test_programs/execution_success/schnorr/src/main.nr
index 9e2838c34d9..8ff868bc61b 100644
--- a/test_programs/execution_success/schnorr/src/main.nr
+++ b/test_programs/execution_success/schnorr/src/main.nr
@@ -1,4 +1,6 @@
 use dep::std;
+use dep::std::embedded_curve_ops;
+
 // Note: If main has any unsized types, then the verifier will never be able
 // to figure out the circuit instance
 fn main(
@@ -11,9 +13,12 @@ fn main(
     // Regression for issue #2421
     // We want to make sure that we can accurately verify a signature whose message is a slice vs. an array
     let message_field_bytes = message_field.to_be_bytes(10);
+    let mut message2 = [0; 42];
     for i in 0..10 {
         assert(message[i] == message_field_bytes[i]);
+        message2[i] = message[i];
     }
+
     // Is there ever a situation where someone would want 
     // to ensure that a signature was invalid?
     // Check that passing a slice as the message is valid
@@ -22,4 +27,103 @@ fn main(
     // Check that passing an array as the message is valid
     let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
     assert(valid_signature);
+    let pub_key = embedded_curve_ops::EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };
+    let valid_signature = verify_signature_noir(pub_key, signature, message2);
+    assert(valid_signature);
+    assert_valid_signature(pub_key,signature,message2);
+}
+
+// TODO: to put in the stdlib once we have numeric generics
+// Meanwhile, you have to use a message with 32 additional bytes:
+// If you want to verify a signature on a message of 10 bytes, you need to pass a message of length 42,
+// where the first 10 bytes are the one from the original message (the other bytes are not used)
+pub fn verify_signature_noir<M>(
+    public_key: embedded_curve_ops::EmbeddedCurvePoint,
+    signature: [u8; 64],
+    message: [u8; M]
+) -> bool {
+    let N = message.len() - 32;
+
+    //scalar lo/hi from bytes
+    let sig_s = bytes_to_scalar(signature, 0);
+    let sig_e = bytes_to_scalar(signature, 32);
+    // pub_key is on Grumpkin curve
+    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)
+        & (!public_key.is_infinite);
+
+    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {
+        let g1 = embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+        let r = embedded_curve_ops::multi_scalar_mul([g1, public_key], [sig_s, sig_e]);
+        // compare the _hashes_ rather than field elements modulo r
+        let pedersen_hash = std::hash::pedersen_hash([r[0], public_key.x, public_key.y]);
+        let mut hash_input = [0; M];
+        let pde = pedersen_hash.to_be_bytes(32);
+
+        for i in 0..32 {
+            hash_input[i] = pde[i];
+        }
+        for i in 0..N {
+            hash_input[32+i] = message[i];
+        }
+        let result = std::hash::blake2s(hash_input);
+
+        is_ok = (r[2] == 0);
+        for i in 0..32 {
+            if result[i] != signature[32 + i] {
+                is_ok = false;
+            }
+        }
+    }
+    is_ok
+}
+
+pub fn bytes_to_scalar(bytes: [u8; 64], offset: u32) -> embedded_curve_ops::EmbeddedCurveScalar {
+    let mut v = 1;
+    let mut lo = 0 as Field;
+    let mut hi = 0 as Field;
+    for i in 0..16 {
+        lo = lo + (bytes[offset+31 - i] as Field) * v;
+        hi = hi + (bytes[offset+15 - i] as Field) * v;
+        v = v * 256;
+    }
+    let sig_s = embedded_curve_ops::EmbeddedCurveScalar { lo, hi };
+    sig_s
+}
+
+pub fn assert_valid_signature<M>(
+    public_key: embedded_curve_ops::EmbeddedCurvePoint,
+    signature: [u8; 64],
+    message: [u8; M]
+) {
+    let N = message.len() - 32;
+    //scalar lo/hi from bytes
+    let sig_s = bytes_to_scalar(signature, 0);
+    let sig_e = bytes_to_scalar(signature, 32);
+
+    // assert pub_key is on Grumpkin curve
+    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);
+    assert(public_key.is_infinite == false);
+    // assert signature is not null
+    assert((sig_s.lo != 0) | (sig_s.hi != 0));
+    assert((sig_e.lo != 0) | (sig_e.hi != 0));
+
+    let g1 = embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+    let r = embedded_curve_ops::multi_scalar_mul([g1, public_key], [sig_s, sig_e]);
+    // compare the _hashes_ rather than field elements modulo r
+    let pedersen_hash = std::hash::pedersen_hash([r[0], public_key.x, public_key.y]);
+    let mut hash_input = [0; M];
+    let pde = pedersen_hash.to_be_bytes(32);
+
+    for i in 0..32 {
+        hash_input[i] = pde[i];
+    }
+    for i in 0..N {
+        hash_input[32+i] = message[i];
+    }
+    let result = std::hash::blake2s(hash_input);
+
+    assert(r[2] == 0);
+    for i in 0..32 {
+        assert(result[i] == signature[32 + i]);
+    }
 }

From 9c99a97ca8f42bee23cf97ebd724fdc51e647c60 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 6 Jun 2024 14:24:23 +0100
Subject: [PATCH 342/416] fix(elaborator): Lazily elaborate globals (#5191)

# Description

## Problem\*

Resolves some issues with resolving globals in a type position in
certain Noir repositories.
These were an issue before because `non_literal_globals` were resolved
after `func_metas` were defined, but `func_metas` may refer to them in
their type signature.

## Summary\*

Keeps a list of any unresolved globals and resolve them on demand if
needed.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs     | 11 ++++++++++-
 .../noirc_frontend/src/elaborator/patterns.rs     |  3 +++
 compiler/noirc_frontend/src/elaborator/types.rs   | 15 ++++++++++-----
 .../src/hir/def_collector/dc_crate.rs             |  2 +-
 compiler/noirc_frontend/src/node_interner.rs      |  2 +-
 5 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 9403e12496f..964b143b981 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -165,6 +165,11 @@ pub struct Elaborator<'context> {
     /// Each element of the Vec represents a scope with every scope together making
     /// up all currently visible definitions. The first scope is always the global scope.
     comptime_scopes: Vec<HashMap<DefinitionId, comptime::Value>>,
+
+    /// These are the globals that have yet to be elaborated.
+    /// This map is used to lazily evaluate these globals if they're encountered before
+    /// they are elaborated (e.g. in a function's type or another global's RHS).
+    unresolved_globals: BTreeMap<GlobalId, UnresolvedGlobal>,
 }
 
 impl<'context> Elaborator<'context> {
@@ -192,6 +197,7 @@ impl<'context> Elaborator<'context> {
             trait_constraints: Vec::new(),
             current_trait_impl: None,
             comptime_scopes: vec![HashMap::default()],
+            unresolved_globals: BTreeMap::new(),
         }
     }
 
@@ -208,6 +214,9 @@ impl<'context> Elaborator<'context> {
         // Additionally, we must resolve integer globals before structs since structs may refer to
         // the values of integer globals as numeric generics.
         let (literal_globals, non_literal_globals) = filter_literal_globals(items.globals);
+        for global in non_literal_globals {
+            this.unresolved_globals.insert(global.global_id, global);
+        }
 
         for global in literal_globals {
             this.elaborate_global(global);
@@ -242,7 +251,7 @@ impl<'context> Elaborator<'context> {
 
         // We must wait to resolve non-literal globals until after we resolve structs since struct
         // globals will need to reference the struct type they're initialized to to ensure they are valid.
-        for global in non_literal_globals {
+        while let Some((_, global)) = this.unresolved_globals.pop_first() {
             this.elaborate_global(global);
         }
 
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 411caeba7b8..e337726b579 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -429,6 +429,9 @@ impl<'context> Elaborator<'context> {
                         }
                     }
                     DefinitionKind::Global(global_id) => {
+                        if let Some(global) = self.unresolved_globals.remove(&global_id) {
+                            self.elaborate_global(global);
+                        }
                         if let Some(current_item) = self.current_item {
                             self.interner.add_global_dependency(current_item, global_id);
                         }
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 159ad1c7493..1b611d8f71f 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -399,11 +399,16 @@ impl<'context> Elaborator<'context> {
             .or_else(|| self.resolve_trait_method_by_named_generic(path))
     }
 
-    fn eval_global_as_array_length(&mut self, global: GlobalId, path: &Path) -> u32 {
-        let Some(stmt) = self.interner.get_global_let_statement(global) else {
-            let path = path.clone();
-            self.push_err(ResolverError::NoSuchNumericTypeVariable { path });
-            return 0;
+    fn eval_global_as_array_length(&mut self, global_id: GlobalId, path: &Path) -> u32 {
+        let Some(stmt) = self.interner.get_global_let_statement(global_id) else {
+            if let Some(global) = self.unresolved_globals.remove(&global_id) {
+                self.elaborate_global(global);
+                return self.eval_global_as_array_length(global_id, path);
+            } else {
+                let path = path.clone();
+                self.push_err(ResolverError::NoSuchNumericTypeVariable { path });
+                return 0;
+            }
         };
 
         let length = stmt.expression;
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 096bab2b47e..9b47a104a40 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -139,7 +139,7 @@ pub struct UnresolvedTypeAlias {
     pub type_alias_def: NoirTypeAlias,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct UnresolvedGlobal {
     pub file_id: FileId,
     pub module_id: LocalModuleId,
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 40ca9ce04e0..327900af641 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -279,7 +279,7 @@ impl DefinitionId {
 }
 
 /// An ID for a global value
-#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy, PartialOrd, Ord)]
 pub struct GlobalId(usize);
 
 impl GlobalId {

From 3b85b3637f81f3894a7faa07fd299f9d64747214 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 6 Jun 2024 15:50:09 +0200
Subject: [PATCH 343/416] feat: standardize pedersen functions to return
 `EmbeddedCurvePoint` (#5190)

# Description

## Problem\*

Related to #4931

## Summary\*
Replace PedersenPoint in the std lib with EmbeddedPoint


## Additional Context



## Documentation\*

Check one:
- [X ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/hash.nr                              | 12 ++++--------
 .../pedersen_commitment/Prover.toml                  |  1 +
 .../pedersen_commitment/src/main.nr                  |  2 +-
 test_programs/execution_success/schnorr/src/main.nr  |  2 +-
 .../should_fail_with_matches/src/main.nr             | 10 +++++-----
 5 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index ef1cb0889d7..6c295d127ab 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -5,6 +5,7 @@ mod poseidon2;
 use crate::default::Default;
 use crate::uint128::U128;
 use crate::sha256::{digest, sha256_var};
+use crate::embedded_curve_ops::EmbeddedCurvePoint;
 
 #[foreign(sha256)]
 // docs:start:sha256
@@ -25,12 +26,7 @@ pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
 {}
 
 // docs:start:pedersen_commitment
-struct PedersenPoint {
-   x : Field,
-   y : Field,
-}
-
-pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
+pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
     // docs:end:pedersen_commitment
     pedersen_commitment_with_separator(input, 0)
 }
@@ -38,9 +34,9 @@ pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint {
 #[foreign(pedersen_commitment)]
 pub fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
 
-pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> PedersenPoint {
+pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
     let values = __pedersen_commitment_with_separator(input, separator);
-    PedersenPoint { x: values[0], y: values[1] }
+    EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: false }
 }
 
 // docs:start:pedersen_hash
diff --git a/test_programs/execution_success/pedersen_commitment/Prover.toml b/test_programs/execution_success/pedersen_commitment/Prover.toml
index 6ad8c6bca57..0279f7d2096 100644
--- a/test_programs/execution_success/pedersen_commitment/Prover.toml
+++ b/test_programs/execution_success/pedersen_commitment/Prover.toml
@@ -4,3 +4,4 @@ y = "1"
 [expected_commitment]
 x = "0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402"
 y = "0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126"
+is_infinite = false
diff --git a/test_programs/execution_success/pedersen_commitment/src/main.nr b/test_programs/execution_success/pedersen_commitment/src/main.nr
index 83cbe20851d..a3a9aea1cf0 100644
--- a/test_programs/execution_success/pedersen_commitment/src/main.nr
+++ b/test_programs/execution_success/pedersen_commitment/src/main.nr
@@ -1,7 +1,7 @@
 // docs:start:pedersen-commitment
 use dep::std;
 
-fn main(x: Field, y: Field, expected_commitment: std::hash::PedersenPoint) {
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
     let commitment = std::hash::pedersen_commitment([x, y]);
     assert_eq(commitment.x, expected_commitment.x);
     assert_eq(commitment.y, expected_commitment.y);
diff --git a/test_programs/execution_success/schnorr/src/main.nr b/test_programs/execution_success/schnorr/src/main.nr
index 8ff868bc61b..1067d9707b2 100644
--- a/test_programs/execution_success/schnorr/src/main.nr
+++ b/test_programs/execution_success/schnorr/src/main.nr
@@ -30,7 +30,7 @@ fn main(
     let pub_key = embedded_curve_ops::EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };
     let valid_signature = verify_signature_noir(pub_key, signature, message2);
     assert(valid_signature);
-    assert_valid_signature(pub_key,signature,message2);
+    assert_valid_signature(pub_key, signature, message2);
 }
 
 // TODO: to put in the stdlib once we have numeric generics
diff --git a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
index 56ee5cfa586..1f5c29e58a2 100644
--- a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
+++ b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
@@ -19,10 +19,10 @@ fn test_should_fail_without_runtime_match() {
 }
 
 struct InvalidPointError {
-    point: dep::std::hash::PedersenPoint,
+    point: dep::std::embedded_curve_ops::EmbeddedCurvePoint,
 }
 
-#[test(should_fail_with = "InvalidPointError { point: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 } }")]
+#[test(should_fail_with = "InvalidPointError { point: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false } }")]
 fn test_should_fail_with_struct() {
     let hash = dep::std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, InvalidPointError { point: hash });
@@ -35,7 +35,7 @@ fn test_should_fail_with_basic_type_fmt_string() {
     assert_eq(a, b, f"A: {a} is not 1!");
 }
 
-#[test(should_fail_with = "Invalid hash: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 }")]
+#[test(should_fail_with = "Invalid hash: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false }")]
 fn test_should_fail_with_struct_fmt_string() {
     let hash = dep::std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, f"Invalid hash: {hash}");
@@ -63,7 +63,7 @@ unconstrained fn unconstrained_test_should_fail_without_runtime_match() {
     assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0);
 }
 
-#[test(should_fail_with = "InvalidPointError { point: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 } }")]
+#[test(should_fail_with = "InvalidPointError { point: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false } }")]
 unconstrained fn unconstrained_test_should_fail_with_struct() {
     let hash = dep::std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, InvalidPointError { point: hash });
@@ -76,7 +76,7 @@ unconstrained fn unconstrained_test_should_fail_with_basic_type_fmt_string() {
     assert_eq(a, b, f"A: {a} is not 1!");
 }
 
-#[test(should_fail_with = "Invalid hash: PedersenPoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8 }")]
+#[test(should_fail_with = "Invalid hash: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false }")]
 unconstrained fn unconstrained_test_should_fail_with_struct_fmt_string() {
     let hash = dep::std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, f"Invalid hash: {hash}");

From f883ac62bc79022cdfcd4011ea953e480da639ce Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 6 Jun 2024 15:36:17 +0100
Subject: [PATCH 344/416] chore: add more lints related to oracle calls (#5193)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds a new lint inspired by the review of
https://github.com/AztecProtocol/aztec-packages/pull/6751 which enforces
that oracle functions must be marked as unconstrained.

I've also moved the error for calling an oracle function from a
constrained function into the frontend rather than waiting until ACIR
gen.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  3 +-
 .../noirc_frontend/src/elaborator/lints.rs    | 36 ++++++++++++++++++-
 compiler/noirc_frontend/src/elaborator/mod.rs |  1 +
 .../noirc_frontend/src/elaborator/types.rs    | 28 ++++++++++-----
 .../src/hir/resolution/errors.rs              | 16 +++++++++
 compiler/noirc_frontend/src/node_interner.rs  | 16 +++++++++
 6 files changed, 89 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 6d7c5e570c1..2aac083d727 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -839,9 +839,10 @@ impl<'a> Context<'a> {
                         self.handle_ssa_call_outputs(result_ids, outputs, dfg)?;
                     }
                     Value::ForeignFunction(_) => {
+                        // TODO: Remove this once elaborator is default frontend. This is now caught by a lint inside the frontend.
                         return Err(RuntimeError::UnconstrainedOracleReturnToConstrained {
                             call_stack: self.acir_context.get_call_stack(),
-                        })
+                        });
                     }
                     _ => unreachable!("expected calling a function but got {function_value:?}"),
                 }
diff --git a/compiler/noirc_frontend/src/elaborator/lints.rs b/compiler/noirc_frontend/src/elaborator/lints.rs
index d228588d367..4859ac5f97c 100644
--- a/compiler/noirc_frontend/src/elaborator/lints.rs
+++ b/compiler/noirc_frontend/src/elaborator/lints.rs
@@ -10,7 +10,7 @@ use crate::{
         HirExpression, HirLiteral, NodeInterner, NoirFunction, UnaryOp, UnresolvedTypeData,
         Visibility,
     },
-    node_interner::{DefinitionKind, ExprId},
+    node_interner::{DefinitionKind, ExprId, FuncId},
     Type,
 };
 use acvm::AcirField;
@@ -72,6 +72,40 @@ pub(super) fn low_level_function_outside_stdlib(
     }
 }
 
+/// Oracle definitions (functions with the `#[oracle]` attribute) must be marked as unconstrained.
+pub(super) fn oracle_not_marked_unconstrained(func: &NoirFunction) -> Option<ResolverError> {
+    let is_oracle_function =
+        func.attributes().function.as_ref().map_or(false, |func| func.is_oracle());
+    if is_oracle_function && !func.def.is_unconstrained {
+        Some(ResolverError::OracleMarkedAsConstrained { ident: func.name_ident().clone() })
+    } else {
+        None
+    }
+}
+
+/// Oracle functions may not be called by constrained functions directly.
+///
+/// In order for a constrained function to call an oracle it must first call through an unconstrained function.
+pub(super) fn oracle_called_from_constrained_function(
+    interner: &NodeInterner,
+    called_func: &FuncId,
+    calling_from_constrained_runtime: bool,
+    span: Span,
+) -> Option<ResolverError> {
+    if !calling_from_constrained_runtime {
+        return None;
+    }
+
+    let function_attributes = interner.function_attributes(called_func);
+    let is_oracle_call =
+        function_attributes.function.as_ref().map_or(false, |func| func.is_oracle());
+    if is_oracle_call {
+        Some(ResolverError::UnconstrainedOracleReturnToConstrained { span })
+    } else {
+        None
+    }
+}
+
 /// `pub` is required on return types for entry point functions
 pub(super) fn missing_pub(func: &NoirFunction, is_entry_point: bool) -> Option<ResolverError> {
     if is_entry_point
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 964b143b981..37ad74b78b0 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -565,6 +565,7 @@ impl<'context> Elaborator<'context> {
         self.run_lint(|elaborator| {
             lints::unnecessary_pub_return(func, elaborator.pub_allowed(func)).map(Into::into)
         });
+        self.run_lint(|_| lints::oracle_not_marked_unconstrained(func).map(Into::into));
         self.run_lint(|elaborator| {
             lints::low_level_function_outside_stdlib(func, elaborator.crate_id).map(Into::into)
         });
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 1b611d8f71f..3baa7054fc5 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -17,7 +17,7 @@ use crate::{
     },
     hir_def::{
         expr::{
-            HirBinaryOp, HirCallExpression, HirIdent, HirMemberAccess, HirMethodReference,
+            HirBinaryOp, HirCallExpression, HirMemberAccess, HirMethodReference,
             HirPrefixExpression,
         },
         function::{FuncMeta, Parameters},
@@ -1155,6 +1155,19 @@ impl<'context> Elaborator<'context> {
         let is_unconstrained_call = self.is_unconstrained_call(call.func);
         let crossing_runtime_boundary = is_current_func_constrained && is_unconstrained_call;
         if crossing_runtime_boundary {
+            let called_func_id = self
+                .interner
+                .lookup_function_from_expr(&call.func)
+                .expect("Called function should exist");
+            self.run_lint(|elaborator| {
+                lints::oracle_called_from_constrained_function(
+                    elaborator.interner,
+                    &called_func_id,
+                    is_current_func_constrained,
+                    span,
+                )
+                .map(Into::into)
+            });
             let errors = lints::unconstrained_function_args(&args);
             for error in errors {
                 self.push_err(error);
@@ -1173,15 +1186,12 @@ impl<'context> Elaborator<'context> {
     }
 
     fn is_unconstrained_call(&self, expr: ExprId) -> bool {
-        if let HirExpression::Ident(HirIdent { id, .. }, _) = self.interner.expression(&expr) {
-            if let Some(DefinitionKind::Function(func_id)) =
-                self.interner.try_definition(id).map(|def| &def.kind)
-            {
-                let modifiers = self.interner.function_modifiers(func_id);
-                return modifiers.is_unconstrained;
-            }
+        if let Some(func_id) = self.interner.lookup_function_from_expr(&expr) {
+            let modifiers = self.interner.function_modifiers(&func_id);
+            modifiers.is_unconstrained
+        } else {
+            false
         }
-        false
     }
 
     /// Check if the given method type requires a mutable reference to the object type, and check
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index e8985deda11..d6dd1c2cd54 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -80,6 +80,12 @@ pub enum ResolverError {
     AbiAttributeOutsideContract { span: Span },
     #[error("Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library")]
     LowLevelFunctionOutsideOfStdlib { ident: Ident },
+    #[error(
+        "Usage of the `#[oracle]` function attribute is only valid on unconstrained functions"
+    )]
+    OracleMarkedAsConstrained { ident: Ident },
+    #[error("Oracle functions cannot be called directly from constrained functions")]
+    UnconstrainedOracleReturnToConstrained { span: Span },
     #[error("Dependency cycle found, '{item}' recursively depends on itself: {cycle} ")]
     DependencyCycle { span: Span, item: String, cycle: String },
     #[error("break/continue are only allowed in unconstrained functions")]
@@ -327,6 +333,16 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 "Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library".into(),
                 ident.span(),
             ),
+            ResolverError::OracleMarkedAsConstrained { ident } => Diagnostic::simple_error(
+                error.to_string(),
+                "Oracle functions must have the `unconstrained` keyword applied".into(),
+                ident.span(),
+            ),
+            ResolverError::UnconstrainedOracleReturnToConstrained { span } => Diagnostic::simple_error(
+                error.to_string(),
+                "This oracle call must be wrapped in a call to another unconstrained function before being returned to a constrained runtime".into(),
+                *span,
+            ),
             ResolverError::DependencyCycle { span, item, cycle } => {
                 Diagnostic::simple_error(
                     "Dependency cycle found".into(),
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 327900af641..cef49332b00 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -20,6 +20,7 @@ use crate::hir::def_map::{LocalModuleId, ModuleId};
 
 use crate::ast::{BinaryOpKind, FunctionDefinition, ItemVisibility};
 use crate::hir::resolution::errors::ResolverError;
+use crate::hir_def::expr::HirIdent;
 use crate::hir_def::stmt::HirLetStatement;
 use crate::hir_def::traits::TraitImpl;
 use crate::hir_def::traits::{Trait, TraitConstraint};
@@ -824,6 +825,21 @@ impl NodeInterner {
         self.function_modules[&func]
     }
 
+    /// Returns the [`FuncId`] corresponding to the function referred to by `expr_id`
+    pub fn lookup_function_from_expr(&self, expr: &ExprId) -> Option<FuncId> {
+        if let HirExpression::Ident(HirIdent { id, .. }, _) = self.expression(expr) {
+            if let Some(DefinitionKind::Function(func_id)) =
+                self.try_definition(id).map(|def| &def.kind)
+            {
+                Some(*func_id)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
     /// Returns the interned HIR function corresponding to `func_id`
     //
     // Cloning HIR structures is cheap, so we return owned structures

From 8d039c6808bd173f4257bb6eb61c8279d3c301b7 Mon Sep 17 00:00:00 2001
From: Savio <72797635+Savio-Sou@users.noreply.github.com>
Date: Fri, 7 Jun 2024 02:09:58 +0900
Subject: [PATCH 345/416] chore(docs): Update docs homepage (#5198)

# Description

## Problem\*

Description of Noir on the page is outdated and not fully accurate:
- Implies support for SNARK proving systems only
- Defines ZKP as Zero-Knowledge _Programs_

## Summary\*

This PR updates the descriptions accordingly.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/index.mdx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/docs/index.mdx b/docs/docs/index.mdx
index 75086ddcdde..a6bd306f91d 100644
--- a/docs/docs/index.mdx
+++ b/docs/docs/index.mdx
@@ -24,9 +24,9 @@ import TabItem from '@theme/TabItem';
 
 <img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
 
-Noir is a Domain-Specific Language for SNARK proving systems developed by [Aztec Labs](https://aztec.network/). It allows you to generate complex Zero-Knowledge Programs (ZKP) by using simple and flexible syntax, requiring no previous knowledge on the underlying mathematics or cryptography.
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
 
-ZK programs are programs that can generate short proofs of a certain statement without revealing some details about it. You can read more about ZKPs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
 
 ## What's new about Noir?
 

From 42e0eb9145eb375ff42801793843c1333c2ce36c Mon Sep 17 00:00:00 2001
From: Savio <72797635+Savio-Sou@users.noreply.github.com>
Date: Fri, 7 Jun 2024 19:17:47 +0900
Subject: [PATCH 346/416] chore(docs): Supplement Noir Debugger's dependency
 versions (#5199)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Dependency versions of Noir / Nargo / vscode-noir for using the Noir
Debugger are currently listed as "0.xx" in the docs.

## Summary\*

This PR updates to docs to specify the actual versions required:
- Noir & Nargo ≥0.28.0
- Noir's VS Code extension ≥0.0.11

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/tooling/debugger.md                           | 5 ++---
 docs/versioned_docs/version-v0.28.0/tooling/debugger.md | 5 ++---
 docs/versioned_docs/version-v0.29.0/tooling/debugger.md | 5 ++---
 docs/versioned_docs/version-v0.30.0/tooling/debugger.md | 5 ++---
 4 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/docs/docs/tooling/debugger.md b/docs/docs/tooling/debugger.md
index 184c436068f..7c158d949d1 100644
--- a/docs/docs/tooling/debugger.md
+++ b/docs/docs/tooling/debugger.md
@@ -14,9 +14,8 @@ There are currently two ways of debugging Noir programs:
 
 In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
 
-- Noir 0.xx 
-- Nargo 0.xx
-- vscode-noir 0.xx
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
 
 :::info
 At the moment, the debugger supports debugging binary projects, but not contracts.
diff --git a/docs/versioned_docs/version-v0.28.0/tooling/debugger.md b/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
index 184c436068f..7c158d949d1 100644
--- a/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
+++ b/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
@@ -14,9 +14,8 @@ There are currently two ways of debugging Noir programs:
 
 In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
 
-- Noir 0.xx 
-- Nargo 0.xx
-- vscode-noir 0.xx
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
 
 :::info
 At the moment, the debugger supports debugging binary projects, but not contracts.
diff --git a/docs/versioned_docs/version-v0.29.0/tooling/debugger.md b/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
index 184c436068f..7c158d949d1 100644
--- a/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
+++ b/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
@@ -14,9 +14,8 @@ There are currently two ways of debugging Noir programs:
 
 In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
 
-- Noir 0.xx 
-- Nargo 0.xx
-- vscode-noir 0.xx
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
 
 :::info
 At the moment, the debugger supports debugging binary projects, but not contracts.
diff --git a/docs/versioned_docs/version-v0.30.0/tooling/debugger.md b/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
index 184c436068f..7c158d949d1 100644
--- a/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
+++ b/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
@@ -14,9 +14,8 @@ There are currently two ways of debugging Noir programs:
 
 In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
 
-- Noir 0.xx 
-- Nargo 0.xx
-- vscode-noir 0.xx
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
 
 :::info
 At the moment, the debugger supports debugging binary projects, but not contracts.

From 7f08343dfcafddfcec1b238746a69273ae4f4e2b Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 7 Jun 2024 15:17:12 +0100
Subject: [PATCH 347/416] feat: Implement println in the comptime interpreter
 (#5197)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*



## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/expression.rs |  4 +-
 .../src/elaborator/expressions.rs             |  2 +-
 .../noirc_frontend/src/hir/comptime/errors.rs |  2 +-
 .../src/hir/comptime/interpreter.rs           | 68 +++++++++++++++++--
 .../noirc_frontend/src/hir/comptime/value.rs  | 52 +++++++++++++-
 .../src/hir/resolution/resolver.rs            |  4 +-
 compiler/noirc_frontend/src/lexer/token.rs    | 11 ++-
 .../src/monomorphization/mod.rs               | 23 +++----
 compiler/noirc_frontend/src/parser/parser.rs  |  4 +-
 .../comptime_println/Nargo.toml               |  7 ++
 .../comptime_println/src/main.nr              |  7 ++
 tooling/nargo_fmt/src/rewrite/expr.rs         |  4 +-
 12 files changed, 154 insertions(+), 34 deletions(-)
 create mode 100644 test_programs/execution_success/comptime_println/Nargo.toml
 create mode 100644 test_programs/execution_success/comptime_println/src/main.nr

diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 749e41d9c1c..50836add8de 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -34,7 +34,7 @@ pub enum ExpressionKind {
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
     Quote(BlockExpression),
-    Comptime(BlockExpression),
+    Comptime(BlockExpression, Span),
 
     // This variant is only emitted when inlining the result of comptime
     // code. It is used to translate function values back into the AST while
@@ -536,7 +536,7 @@ impl Display for ExpressionKind {
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
             Quote(block) => write!(f, "quote {block}"),
-            Comptime(block) => write!(f, "comptime {block}"),
+            Comptime(block, _) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
         }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 5eee7ee6c7c..a922f552c4b 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -59,7 +59,7 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
             ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
             ExpressionKind::Quote(quote) => self.elaborate_quote(quote),
-            ExpressionKind::Comptime(comptime) => {
+            ExpressionKind::Comptime(comptime, _) => {
                 return self.elaborate_comptime_block(comptime, expr.span)
             }
             ExpressionKind::Resolved(id) => return (id, self.interner.id_type(id)),
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index df4bc941f66..05962420f8a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -36,7 +36,7 @@ pub enum InterpreterError {
     CannotInlineMacro { value: Value, location: Location },
     UnquoteFoundDuringEvaluation { location: Location },
 
-    Unimplemented { item: &'static str, location: Location },
+    Unimplemented { item: String, location: Location },
 
     // Perhaps this should be unreachable! due to type checking also preventing this error?
     // Currently it and the Continue variant are the only interpreter errors without a Location field
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index e1e19ad653c..dd436144969 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -59,11 +59,6 @@ impl<'a> Interpreter<'a> {
         let previous_state = self.enter_function();
 
         let meta = self.interner.function_meta(&function);
-        if meta.kind != FunctionKind::Normal {
-            let item = "Evaluation for builtin functions";
-            return Err(InterpreterError::Unimplemented { item, location });
-        }
-
         if meta.parameters.len() != arguments.len() {
             return Err(InterpreterError::ArgumentCountMismatch {
                 expected: meta.parameters.len(),
@@ -72,6 +67,10 @@ impl<'a> Interpreter<'a> {
             });
         }
 
+        if meta.kind != FunctionKind::Normal {
+            return self.call_builtin(function, arguments, location);
+        }
+
         let parameters = meta.parameters.0.clone();
         for ((parameter, typ, _), (argument, arg_location)) in parameters.iter().zip(arguments) {
             self.define_pattern(parameter, typ, argument, arg_location)?;
@@ -84,6 +83,35 @@ impl<'a> Interpreter<'a> {
         Ok(result)
     }
 
+    fn call_builtin(
+        &mut self,
+        function: FuncId,
+        arguments: Vec<(Value, Location)>,
+        location: Location,
+    ) -> IResult<Value> {
+        let attributes = self.interner.function_attributes(&function);
+        let func_attrs = attributes.function.as_ref()
+            .expect("all builtin functions must contain a function  attribute which contains the opcode which it links to");
+
+        if let Some(builtin) = func_attrs.builtin() {
+            let item = format!("Evaluation for builtin functions like {builtin}");
+            Err(InterpreterError::Unimplemented { item, location })
+        } else if let Some(foreign) = func_attrs.foreign() {
+            let item = format!("Evaluation for foreign functions like {foreign}");
+            Err(InterpreterError::Unimplemented { item, location })
+        } else if let Some(oracle) = func_attrs.oracle() {
+            if oracle == "print" {
+                self.print_oracle(arguments)
+            } else {
+                let item = format!("Evaluation for oracle functions like {oracle}");
+                Err(InterpreterError::Unimplemented { item, location })
+            }
+        } else {
+            let name = self.interner.function_name(&function);
+            unreachable!("Non-builtin, lowlevel or oracle builtin fn '{name}'")
+        }
+    }
+
     fn call_closure(
         &mut self,
         closure: HirLambda,
@@ -219,7 +247,8 @@ impl<'a> Interpreter<'a> {
         argument: Value,
         location: Location,
     ) -> IResult<()> {
-        self.type_check(typ, &argument, location)?;
+        // Temporarily disabled since this fails on generic types
+        // self.type_check(typ, &argument, location)?;
         self.current_scope_mut().insert(id, argument);
         Ok(())
     }
@@ -360,7 +389,11 @@ impl<'a> Interpreter<'a> {
                 self.evaluate_integer(value, is_negative, id)
             }
             HirLiteral::Str(string) => Ok(Value::String(Rc::new(string))),
-            HirLiteral::FmtStr(_, _) => todo!("Evaluate format strings"),
+            HirLiteral::FmtStr(_, _) => {
+                let item = "format strings in a comptime context".into();
+                let location = self.interner.expr_location(&id);
+                Err(InterpreterError::Unimplemented { item, location })
+            }
             HirLiteral::Array(array) => self.evaluate_array(array, id),
             HirLiteral::Slice(array) => self.evaluate_slice(array, id),
         }
@@ -454,6 +487,14 @@ impl<'a> Interpreter<'a> {
                     Ok(Value::I64(value))
                 }
             }
+        } else if let Type::TypeVariable(variable, TypeVariableKind::IntegerOrField) = &typ {
+            Ok(Value::Field(value))
+        } else if let Type::TypeVariable(variable, TypeVariableKind::Integer) = &typ {
+            let value: u64 = value
+                .try_to_u64()
+                .ok_or(InterpreterError::IntegerOutOfRangeForType { value, typ, location })?;
+            let value = if is_negative { 0u64.wrapping_sub(value) } else { value };
+            Ok(Value::U64(value))
         } else {
             Err(InterpreterError::NonIntegerIntegerLiteral { typ, location })
         }
@@ -1269,4 +1310,17 @@ impl<'a> Interpreter<'a> {
     pub(super) fn evaluate_comptime(&mut self, statement: StmtId) -> IResult<Value> {
         self.evaluate_statement(statement)
     }
+
+    fn print_oracle(&self, arguments: Vec<(Value, Location)>) -> Result<Value, InterpreterError> {
+        assert_eq!(arguments.len(), 2);
+
+        let print_newline = arguments[0].0 == Value::Bool(true);
+        if print_newline {
+            println!("{}", arguments[1].0);
+        } else {
+            print!("{}", arguments[1].0);
+        }
+
+        Ok(Value::Unit)
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 43d461ad043..11bbbc7484d 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, rc::Rc};
+use std::{borrow::Cow, fmt::Display, rc::Rc};
 
 use acvm::{AcirField, FieldElement};
 use im::Vector;
@@ -135,7 +135,7 @@ impl Value {
             }
             Value::Closure(_lambda, _env, _typ) => {
                 // TODO: How should a closure's environment be inlined?
-                let item = "Returning closures from a comptime fn";
+                let item = "Returning closures from a comptime fn".into();
                 return Err(InterpreterError::Unimplemented { item, location });
             }
             Value::Tuple(fields) => {
@@ -235,7 +235,7 @@ impl Value {
             }
             Value::Closure(_lambda, _env, _typ) => {
                 // TODO: How should a closure's environment be inlined?
-                let item = "Returning closures from a comptime fn";
+                let item = "Returning closures from a comptime fn".into();
                 return Err(InterpreterError::Unimplemented { item, location });
             }
             Value::Tuple(fields) => {
@@ -306,3 +306,49 @@ impl Value {
 fn unwrap_rc<T: Clone>(rc: Rc<T>) -> T {
     Rc::try_unwrap(rc).unwrap_or_else(|rc| (*rc).clone())
 }
+
+impl Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Unit => write!(f, "()"),
+            Value::Bool(value) => {
+                let msg = if *value { "true" } else { "false" };
+                write!(f, "{msg}")
+            }
+            Value::Field(value) => write!(f, "{value}"),
+            Value::I8(value) => write!(f, "{value}"),
+            Value::I16(value) => write!(f, "{value}"),
+            Value::I32(value) => write!(f, "{value}"),
+            Value::I64(value) => write!(f, "{value}"),
+            Value::U8(value) => write!(f, "{value}"),
+            Value::U16(value) => write!(f, "{value}"),
+            Value::U32(value) => write!(f, "{value}"),
+            Value::U64(value) => write!(f, "{value}"),
+            Value::String(value) => write!(f, "{value}"),
+            Value::Function(_, _) => write!(f, "(function)"),
+            Value::Closure(_, _, _) => write!(f, "(closure)"),
+            Value::Tuple(fields) => {
+                let fields = vecmap(fields, ToString::to_string);
+                write!(f, "({})", fields.join(", "))
+            }
+            Value::Struct(fields, typ) => {
+                let typename = match typ.follow_bindings() {
+                    Type::Struct(def, _) => def.borrow().name.to_string(),
+                    other => other.to_string(),
+                };
+                let fields = vecmap(fields, |(name, value)| format!("{}: {}", name, value));
+                write!(f, "{typename} {{ {} }}", fields.join(", "))
+            }
+            Value::Pointer(value) => write!(f, "&mut {}", value.borrow()),
+            Value::Array(values, _) => {
+                let values = vecmap(values, ToString::to_string);
+                write!(f, "[{}]", values.join(", "))
+            }
+            Value::Slice(values, _) => {
+                let values = vecmap(values, ToString::to_string);
+                write!(f, "&[{}]", values.join(", "))
+            }
+            Value::Code(_) => todo!(),
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 4988628db83..01f58ba4c27 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1642,7 +1642,9 @@ impl<'a> Resolver<'a> {
 
             // The quoted expression isn't resolved since we don't want errors if variables aren't defined
             ExpressionKind::Quote(block) => HirExpression::Quote(block),
-            ExpressionKind::Comptime(block) => HirExpression::Comptime(self.resolve_block(block)),
+            ExpressionKind::Comptime(block, _) => {
+                HirExpression::Comptime(self.resolve_block(block))
+            }
             ExpressionKind::Resolved(_) => unreachable!(
                 "ExpressionKind::Resolved should only be emitted by the comptime interpreter"
             ),
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index fdda271e79c..950697c2536 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -702,20 +702,27 @@ pub enum FunctionAttribute {
 }
 
 impl FunctionAttribute {
-    pub fn builtin(self) -> Option<String> {
+    pub fn builtin(&self) -> Option<&String> {
         match self {
             FunctionAttribute::Builtin(name) => Some(name),
             _ => None,
         }
     }
 
-    pub fn foreign(self) -> Option<String> {
+    pub fn foreign(&self) -> Option<&String> {
         match self {
             FunctionAttribute::Foreign(name) => Some(name),
             _ => None,
         }
     }
 
+    pub fn oracle(&self) -> Option<&String> {
+        match self {
+            FunctionAttribute::Oracle(name) => Some(name),
+            _ => None,
+        }
+    }
+
     pub fn is_foreign(&self) -> bool {
         matches!(self, FunctionAttribute::Foreign(_))
     }
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index a25d6488c83..7ecea5c9eac 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -18,7 +18,6 @@ use crate::{
         types,
     },
     node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId},
-    token::FunctionAttribute,
     Type, TypeBinding, TypeBindings, TypeVariable, TypeVariableKind,
 };
 use acvm::{acir::AcirField, FieldElement};
@@ -216,18 +215,18 @@ impl<'interner> Monomorphizer<'interner> {
                 let attributes = self.interner.function_attributes(&id);
                 match self.interner.function_meta(&id).kind {
                     FunctionKind::LowLevel => {
-                        let attribute = attributes.function.clone().expect("all low level functions must contain a function attribute which contains the opcode which it links to");
+                        let attribute = attributes.function.as_ref().expect("all low level functions must contain a function attribute which contains the opcode which it links to");
                         let opcode = attribute.foreign().expect(
                             "ice: function marked as foreign, but attribute kind does not match this",
                         );
-                        Definition::LowLevel(opcode)
+                        Definition::LowLevel(opcode.to_string())
                     }
                     FunctionKind::Builtin => {
-                        let attribute = attributes.function.clone().expect("all low level functions must contain a function  attribute which contains the opcode which it links to");
+                        let attribute = attributes.function.as_ref().expect("all builtin functions must contain a function attribute which contains the opcode which it links to");
                         let opcode = attribute.builtin().expect(
                             "ice: function marked as builtin, but attribute kind does not match this",
                         );
-                        Definition::Builtin(opcode)
+                        Definition::Builtin(opcode.to_string())
                     }
                     FunctionKind::Normal => {
                         let id =
@@ -235,15 +234,11 @@ impl<'interner> Monomorphizer<'interner> {
                         Definition::Function(id)
                     }
                     FunctionKind::Oracle => {
-                        let attr = attributes
-                            .function
-                            .clone()
-                            .expect("Oracle function must have an oracle attribute");
-
-                        match attr {
-                            FunctionAttribute::Oracle(name) => Definition::Oracle(name),
-                            _ => unreachable!("Oracle function must have an oracle attribute"),
-                        }
+                        let attribute = attributes.function.as_ref().expect("all oracle functions must contain a function attribute which contains the opcode which it links to");
+                        let opcode = attribute.oracle().expect(
+                            "ice: function marked as builtin, but attribute kind does not match this",
+                        );
+                        Definition::Oracle(opcode.to_string())
                     }
                     FunctionKind::Recursive => {
                         unreachable!("Only main can be specified as recursive, which should already be checked");
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 702ea79af9d..cabc788e07d 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -545,7 +545,9 @@ fn comptime_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
 where
     S: NoirParser<StatementKind> + 'a,
 {
-    keyword(Keyword::Comptime).ignore_then(block(statement)).map(ExpressionKind::Comptime)
+    keyword(Keyword::Comptime)
+        .ignore_then(spanned(block(statement)))
+        .map(|(block, span)| ExpressionKind::Comptime(block, span))
 }
 
 fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
diff --git a/test_programs/execution_success/comptime_println/Nargo.toml b/test_programs/execution_success/comptime_println/Nargo.toml
new file mode 100644
index 00000000000..7f8ae3a9cb9
--- /dev/null
+++ b/test_programs/execution_success/comptime_println/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_println"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/comptime_println/src/main.nr b/test_programs/execution_success/comptime_println/src/main.nr
new file mode 100644
index 00000000000..f9770066c04
--- /dev/null
+++ b/test_programs/execution_success/comptime_println/src/main.nr
@@ -0,0 +1,7 @@
+fn main() {
+    let x = comptime {
+        println("hello from compile-time!");
+        1 + 2
+    };
+    println(x);
+}
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 9a704717ade..7ff943aea62 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -167,8 +167,8 @@ pub(crate) fn rewrite(
         }
         ExpressionKind::Lambda(_) => visitor.slice(span).to_string(),
         ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
-        ExpressionKind::Comptime(block) => {
-            format!("comptime {}", rewrite_block(visitor, block, span))
+        ExpressionKind::Comptime(block, block_span) => {
+            format!("comptime {}", rewrite_block(visitor, block, block_span))
         }
         ExpressionKind::Error => unreachable!(),
         ExpressionKind::Resolved(_) => {

From 58c7532da8dd86ee02b20d7e7809f5437f667845 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 10 Jun 2024 12:14:12 +0200
Subject: [PATCH 348/416] fix: error for allocate instructions in acir-gen
 (#5200)

# Description

## Problem\*

Resolves #5175

## Summary\*
When we cannot resolve some references to an array, its allocate is not
simplified and we get a panic.
I changed this to an error message saying that we could not resolve all
references from the array.
I believe an error message is better than the panic, however I am not
sure whether having remaining allocates only happens because of this
case.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/errors.rs           | 5 ++++-
 compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs | 7 ++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index 1e922060100..dd63a254a18 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -43,6 +43,8 @@ pub enum RuntimeError {
     UnconstrainedSliceReturnToConstrained { call_stack: CallStack },
     #[error("All `oracle` methods should be wrapped in an unconstrained fn")]
     UnconstrainedOracleReturnToConstrained { call_stack: CallStack },
+    #[error("Could not resolve some references to the array. All references must be resolved at compile time")]
+    UnknownReference { call_stack: CallStack },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -123,7 +125,8 @@ impl RuntimeError {
             | RuntimeError::NestedSlice { call_stack, .. }
             | RuntimeError::BigIntModulus { call_stack, .. }
             | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack }
-            | RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
+            | RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack }
+            | RuntimeError::UnknownReference { call_stack } => call_stack,
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 2aac083d727..40170e58a30 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -682,7 +682,9 @@ impl<'a> Context<'a> {
                 self.handle_array_operation(instruction_id, dfg)?;
             }
             Instruction::Allocate => {
-                unreachable!("Expected all allocate instructions to be removed before acir_gen")
+                return Err(RuntimeError::UnknownReference {
+                    call_stack: self.acir_context.get_call_stack().clone(),
+                });
             }
             Instruction::Store { .. } => {
                 unreachable!("Expected all store instructions to be removed before acir_gen")
@@ -1307,6 +1309,9 @@ impl<'a> Context<'a> {
                 }
                 Ok(AcirValue::Array(values))
             }
+            Type::Reference(reference_type) => {
+                self.array_get_value(reference_type.as_ref(), block_id, var_index)
+            }
             _ => unreachable!("ICE: Expected an array or numeric but got {ssa_type:?}"),
         }
     }

From 17c859d58da695d64f6a4e203b3ed40bf98df64d Mon Sep 17 00:00:00 2001
From: ricecodekhmer <151774852+ricecodekhmer@users.noreply.github.com>
Date: Mon, 10 Jun 2024 11:17:36 +0100
Subject: [PATCH 349/416] chore(docs): fix incorrect docs github link in footer
 (#5206)

# Description

## Problem\*

This PR solves a broken link in the project documentation that
incorrectly points users to an obsolete GitHub repository URL.

## Summary\*

This change corrects the 'Docs GitHub' hyperlink in the footer of the
documentation to direct users to the new correct repository path.
Before, the link directed users to
[https://github.com/noir-lang/docs](https://github.com/noir-lang/docs),
which has been archived. The updated link now correctly points to
[https://github.com/noir-lang/noir/tree/master/docs](https://github.com/noir-lang/noir/tree/master/docs).

## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docusaurus.config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts
index 2d5b8941f55..29f612b0109 100644
--- a/docs/docusaurus.config.ts
+++ b/docs/docusaurus.config.ts
@@ -109,7 +109,7 @@ export default {
             },
             {
               label: 'Docs GitHub',
-              href: 'https://github.com/noir-lang/docs',
+              href: 'https://github.com/noir-lang/noir/tree/master/docs',
             },
           ],
         },

From 14adafc965fa9c833e096ec037e086aae67703ad Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 10 Jun 2024 11:42:24 +0100
Subject: [PATCH 350/416] feat!: add session id to foreign call RPC requests
 (#5205)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR adds an `id` field to RPC foreign call requests so that the
TriXE is able to maintain separate internal state for different test
functions so that Aztec integration tests can be run in parallel. This
has necessitated some changes to the request format so this is a
breaking change.


The RPC request now looks like

```
'{
    "jsonrpc":"2.0",
    "method":"resolve_foreign_call",
    "params":[{
        "session_id":3789997497881369652,
        "function": "foo",
        "inputs": [
            "0000000000000000000000000000000000000000000000000000000000000001",
["0000000000000000000000000000000000000000000000000000000000000001","0000000000000000000000000000000000000000000000000000000000000002"
    ]]
}]}
```

## Additional Context



## Documentation\*

Check one:
- [] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                             |   2 +
 Cargo.toml                             |   1 +
 acvm-repo/acvm/Cargo.toml              |   3 +-
 acvm-repo/acvm/src/pwg/brillig.rs      |   3 +-
 acvm-repo/brillig/src/foreign_call.rs  |   1 +
 docs/docs/how_to/how-to-oracles.md     |  17 ++--
 tooling/acvm_cli/Cargo.toml            |   2 +-
 tooling/nargo/Cargo.toml               |   1 +
 tooling/nargo/src/ops/foreign_calls.rs | 109 +++++++++++++++++++------
 9 files changed, 101 insertions(+), 38 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 61bfdd08c0e..8e40315cdd7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -50,6 +50,7 @@ dependencies = [
  "paste",
  "proptest",
  "rand 0.8.5",
+ "serde",
  "thiserror",
  "tracing",
 ]
@@ -2485,6 +2486,7 @@ dependencies = [
  "noirc_errors",
  "noirc_frontend",
  "noirc_printable_type",
+ "rand 0.8.5",
  "rayon",
  "serde",
  "tempfile",
diff --git a/Cargo.toml b/Cargo.toml
index 182580f8d67..d23089adb56 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -131,6 +131,7 @@ similar-asserts = "1.5.0"
 tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
+rand = "0.8.5"
 
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 577978939b0..0bd6ab6b7c7 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -16,6 +16,7 @@ repository.workspace = true
 num-bigint.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
+serde.workspace = true
 
 acir.workspace = true
 brillig_vm.workspace = true
@@ -36,7 +37,7 @@ bls12_381 = [
 ]
 
 [dev-dependencies]
-rand = "0.8.5"
+rand.workspace = true
 proptest = "1.2.0"
 paste = "1.0.14"
 ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
\ No newline at end of file
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index 7e6c207b69a..3a639df044a 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -13,6 +13,7 @@ use acir::{
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use brillig_vm::{FailureReason, MemoryValue, VMStatus, VM};
+use serde::{Deserialize, Serialize};
 
 use crate::{pwg::OpcodeNotSolvable, OpcodeResolutionError};
 
@@ -286,7 +287,7 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
 /// where the result of the foreign call has not yet been provided.
 ///
 /// The caller must resolve this opcode externally based upon the information in the request.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct ForeignCallWaitInfo<F> {
     /// An identifier interpreted by the caller process
     pub function: String,
diff --git a/acvm-repo/brillig/src/foreign_call.rs b/acvm-repo/brillig/src/foreign_call.rs
index a439d5c3202..9a45a4d2f20 100644
--- a/acvm-repo/brillig/src/foreign_call.rs
+++ b/acvm-repo/brillig/src/foreign_call.rs
@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 
 /// Single output of a [foreign call][crate::Opcode::ForeignCall].
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
+#[serde(untagged)]
 pub enum ForeignCallParam<F> {
     Single(F),
     Array(Vec<F>),
diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index 2811968c634..62ead1f534f 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -137,24 +137,17 @@ app.listen(5555);
 Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
 
 ```js
-server.addMethod("getSqrt", async (params) => {
-  const values = params[0].Array.map((field) => {
+server.addMethod("resolve_function_call", async (params) => {
+  if params.function !== "getSqrt" {
+    throw Error("Unexpected foreign call")
+  };
+  const values = params.inputs[0].Array.map((field) => {
     return `${Math.sqrt(parseInt(field, 16))}`;
   });
   return { values: [{ Array: values }] };
 });
 ```
 
-:::tip
-
-Brillig expects an object with an array of values. Each value is an object declaring to be `Single` or `Array` and returning a field element *as a string*. For example:
-
-```json
-{ "values": [{ "Array": ["1", "2"] }]}
-{ "values": [{ "Single": "1" }]}
-{ "values": [{ "Single": "1" }, { "Array": ["1", "2"] }]}
-```
-
 If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
 
 ```js
diff --git a/tooling/acvm_cli/Cargo.toml b/tooling/acvm_cli/Cargo.toml
index 72424405d36..1cfd1f3b270 100644
--- a/tooling/acvm_cli/Cargo.toml
+++ b/tooling/acvm_cli/Cargo.toml
@@ -33,6 +33,6 @@ tracing-subscriber.workspace = true
 tracing-appender = "0.2.3"
 
 [dev-dependencies]
-rand = "0.8.5"
+rand.workspace = true
 proptest = "1.2.0"
 paste = "1.0.14"
diff --git a/tooling/nargo/Cargo.toml b/tooling/nargo/Cargo.toml
index 48047d10ea6..8abec267d20 100644
--- a/tooling/nargo/Cargo.toml
+++ b/tooling/nargo/Cargo.toml
@@ -24,6 +24,7 @@ codespan-reporting.workspace = true
 tracing.workspace = true
 rayon = "1.8.0"
 jsonrpc.workspace = true
+rand.workspace = true
 
 [dev-dependencies]
 # TODO: This dependency is used to generate unit tests for `get_all_paths_in_dir`
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index c6b284beb13..115337c1636 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -5,6 +5,8 @@ use acvm::{
 };
 use jsonrpc::{arg as build_json_rpc_arg, minreq_http::Builder, Client};
 use noirc_printable_type::{decode_string_value, ForeignCallError, PrintableValueDisplay};
+use rand::Rng;
+use serde::{Deserialize, Serialize};
 
 pub trait ForeignCallExecutor {
     fn execute(
@@ -96,6 +98,12 @@ impl MockedCall {
 
 #[derive(Debug, Default)]
 pub struct DefaultForeignCallExecutor {
+    /// A randomly generated id for this `DefaultForeignCallExecutor`.
+    ///
+    /// This is used so that a single `external_resolver` can distinguish between requests from multiple
+    /// instantiations of `DefaultForeignCallExecutor`.
+    id: u64,
+
     /// Mocks have unique ids used to identify them in Noir, allowing to update or remove them.
     last_mock_id: usize,
     /// The registered mocks
@@ -106,6 +114,20 @@ pub struct DefaultForeignCallExecutor {
     external_resolver: Option<Client>,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+struct ResolveForeignCallRequest<F> {
+    /// A session ID which allows the external RPC server to link this foreign call request to other foreign calls
+    /// for the same program execution.
+    ///
+    /// This is intended to allow a single RPC server to maintain state related to multiple program executions being
+    /// performed in parallel.
+    session_id: u64,
+
+    #[serde(flatten)]
+    /// The foreign call which the external RPC server is to provide a response for.
+    function_call: ForeignCallWaitInfo<F>,
+}
+
 impl DefaultForeignCallExecutor {
     pub fn new(show_output: bool, resolver_url: Option<&str>) -> Self {
         let oracle_resolver = resolver_url.map(|resolver_url| {
@@ -123,6 +145,7 @@ impl DefaultForeignCallExecutor {
         DefaultForeignCallExecutor {
             show_output,
             external_resolver: oracle_resolver,
+            id: rand::thread_rng().gen(),
             ..DefaultForeignCallExecutor::default()
         }
     }
@@ -275,10 +298,13 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                 } else if let Some(external_resolver) = &self.external_resolver {
                     // If the user has registered an external resolver then we forward any remaining oracle calls there.
 
-                    let encoded_params: Vec<_> =
-                        foreign_call.inputs.iter().map(build_json_rpc_arg).collect();
+                    let encoded_params = vec![build_json_rpc_arg(ResolveForeignCallRequest {
+                        session_id: self.id,
+                        function_call: foreign_call.clone(),
+                    })];
 
-                    let req = external_resolver.build_request(foreign_call_name, &encoded_params);
+                    let req =
+                        external_resolver.build_request("resolve_foreign_call", &encoded_params);
 
                     let response = external_resolver.send_request(req)?;
 
@@ -312,43 +338,49 @@ mod tests {
 
     use crate::ops::{DefaultForeignCallExecutor, ForeignCallExecutor};
 
+    use super::ResolveForeignCallRequest;
+
     #[allow(unreachable_pub)]
     #[rpc]
     pub trait OracleResolver {
-        #[rpc(name = "echo")]
-        fn echo(
-            &self,
-            param: ForeignCallParam<FieldElement>,
-        ) -> RpcResult<ForeignCallResult<FieldElement>>;
-
-        #[rpc(name = "sum")]
-        fn sum(
+        #[rpc(name = "resolve_foreign_call")]
+        fn resolve_foreign_call(
             &self,
-            array: ForeignCallParam<FieldElement>,
+            req: ResolveForeignCallRequest<FieldElement>,
         ) -> RpcResult<ForeignCallResult<FieldElement>>;
     }
 
     struct OracleResolverImpl;
 
-    impl OracleResolver for OracleResolverImpl {
-        fn echo(
-            &self,
-            param: ForeignCallParam<FieldElement>,
-        ) -> RpcResult<ForeignCallResult<FieldElement>> {
-            Ok(vec![param].into())
+    impl OracleResolverImpl {
+        fn echo(&self, param: ForeignCallParam<FieldElement>) -> ForeignCallResult<FieldElement> {
+            vec![param].into()
         }
 
-        fn sum(
-            &self,
-            array: ForeignCallParam<FieldElement>,
-        ) -> RpcResult<ForeignCallResult<FieldElement>> {
+        fn sum(&self, array: ForeignCallParam<FieldElement>) -> ForeignCallResult<FieldElement> {
             let mut res: FieldElement = 0_usize.into();
 
             for value in array.fields() {
                 res += value;
             }
 
-            Ok(res.into())
+            res.into()
+        }
+    }
+
+    impl OracleResolver for OracleResolverImpl {
+        fn resolve_foreign_call(
+            &self,
+            req: ResolveForeignCallRequest<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>> {
+            let response = match req.function_call.function.as_str() {
+                "sum" => self.sum(req.function_call.inputs[0].clone()),
+                "echo" => self.echo(req.function_call.inputs[0].clone()),
+                "id" => FieldElement::from(req.session_id as u128).into(),
+
+                _ => panic!("unexpected foreign call"),
+            };
+            Ok(response)
         }
     }
 
@@ -398,4 +430,35 @@ mod tests {
 
         server.close();
     }
+
+    #[test]
+    fn foreign_call_executor_id_is_persistent() {
+        let (server, url) = build_oracle_server();
+
+        let mut executor = DefaultForeignCallExecutor::new(false, Some(&url));
+
+        let foreign_call = ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
+
+        let result_1 = executor.execute(&foreign_call).unwrap();
+        let result_2 = executor.execute(&foreign_call).unwrap();
+        assert_eq!(result_1, result_2);
+
+        server.close();
+    }
+
+    #[test]
+    fn oracle_resolver_rpc_can_distinguish_executors() {
+        let (server, url) = build_oracle_server();
+
+        let mut executor_1 = DefaultForeignCallExecutor::new(false, Some(&url));
+        let mut executor_2 = DefaultForeignCallExecutor::new(false, Some(&url));
+
+        let foreign_call = ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
+
+        let result_1 = executor_1.execute(&foreign_call).unwrap();
+        let result_2 = executor_2.execute(&foreign_call).unwrap();
+        assert_ne!(result_1, result_2);
+
+        server.close();
+    }
 }

From 3ec7ce4b74d37721fe025a97a438e4b4df85c040 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 10 Jun 2024 14:34:00 +0100
Subject: [PATCH 351/416] chore: make `nargo` crate and debug info generic
 (#5184)

# Description

## Problem\*

Related to #5055

## Summary\*

This PR throws generics into more of the codebase.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_printable_type/src/lib.rs  | 58 +++++++++---------
 tooling/acvm_cli/src/errors.rs            |  3 +-
 tooling/debugger/src/context.rs           |  6 +-
 tooling/debugger/src/foreign_calls.rs     | 16 ++---
 tooling/debugger/src/lib.rs               |  2 +-
 tooling/debugger/src/repl.rs              |  2 +-
 tooling/nargo/src/artifacts/debug_vars.rs | 30 +++++-----
 tooling/nargo/src/errors.rs               | 22 +++----
 tooling/nargo/src/ops/execute.rs          | 53 +++++++++--------
 tooling/nargo/src/ops/foreign_calls.rs    | 71 ++++++++++++-----------
 tooling/nargo/src/ops/test.rs             |  2 +-
 tooling/nargo_cli/src/errors.rs           |  4 +-
 tooling/noirc_abi/src/lib.rs              |  6 +-
 13 files changed, 137 insertions(+), 138 deletions(-)

diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index d9c9c7f9731..dfecd301b35 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, str};
 
-use acvm::{acir::AcirField, brillig_vm::brillig::ForeignCallParam, FieldElement};
+use acvm::{acir::AcirField, brillig_vm::brillig::ForeignCallParam};
 use iter_extended::vecmap;
 use regex::{Captures, Regex};
 use serde::{Deserialize, Serialize};
@@ -51,19 +51,19 @@ pub enum PrintableType {
 /// For example, a toml file will parse into TomlTypes
 /// and those TomlTypes will be mapped to Value
 #[derive(Debug, Clone, Serialize, PartialEq)]
-pub enum PrintableValue {
-    Field(FieldElement),
+pub enum PrintableValue<F> {
+    Field(F),
     String(String),
-    Vec { array_elements: Vec<PrintableValue>, is_slice: bool },
-    Struct(BTreeMap<String, PrintableValue>),
+    Vec { array_elements: Vec<PrintableValue<F>>, is_slice: bool },
+    Struct(BTreeMap<String, PrintableValue<F>>),
     Other,
 }
 
 /// In order to display a `PrintableValue` we need a `PrintableType` to accurately
 /// convert the value into a human-readable format.
-pub enum PrintableValueDisplay {
-    Plain(PrintableValue, PrintableType),
-    FmtString(String, Vec<(PrintableValue, PrintableType)>),
+pub enum PrintableValueDisplay<F> {
+    Plain(PrintableValue<F>, PrintableType),
+    FmtString(String, Vec<(PrintableValue<F>, PrintableType)>),
 }
 
 #[derive(Debug, Error)]
@@ -81,12 +81,10 @@ pub enum ForeignCallError {
     ResolvedAssertMessage(String),
 }
 
-impl TryFrom<&[ForeignCallParam<FieldElement>]> for PrintableValueDisplay {
+impl<F: AcirField> TryFrom<&[ForeignCallParam<F>]> for PrintableValueDisplay<F> {
     type Error = ForeignCallError;
 
-    fn try_from(
-        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
-    ) -> Result<Self, Self::Error> {
+    fn try_from(foreign_call_inputs: &[ForeignCallParam<F>]) -> Result<Self, Self::Error> {
         let (is_fmt_str, foreign_call_inputs) =
             foreign_call_inputs.split_last().ok_or(ForeignCallError::MissingForeignCallInputs)?;
 
@@ -98,9 +96,9 @@ impl TryFrom<&[ForeignCallParam<FieldElement>]> for PrintableValueDisplay {
     }
 }
 
-fn convert_string_inputs(
-    foreign_call_inputs: &[ForeignCallParam<FieldElement>],
-) -> Result<PrintableValueDisplay, ForeignCallError> {
+fn convert_string_inputs<F: AcirField>(
+    foreign_call_inputs: &[ForeignCallParam<F>],
+) -> Result<PrintableValueDisplay<F>, ForeignCallError> {
     // Fetch the PrintableType from the foreign call input
     // The remaining input values should hold what is to be printed
     let (printable_type_as_values, input_values) =
@@ -115,9 +113,9 @@ fn convert_string_inputs(
     Ok(PrintableValueDisplay::Plain(value, printable_type))
 }
 
-fn convert_fmt_string_inputs(
-    foreign_call_inputs: &[ForeignCallParam<FieldElement>],
-) -> Result<PrintableValueDisplay, ForeignCallError> {
+fn convert_fmt_string_inputs<F: AcirField>(
+    foreign_call_inputs: &[ForeignCallParam<F>],
+) -> Result<PrintableValueDisplay<F>, ForeignCallError> {
     let (message, input_and_printable_types) =
         foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
 
@@ -144,8 +142,8 @@ fn convert_fmt_string_inputs(
     Ok(PrintableValueDisplay::FmtString(message_as_string, output))
 }
 
-fn fetch_printable_type(
-    printable_type: &ForeignCallParam<FieldElement>,
+fn fetch_printable_type<F: AcirField>(
+    printable_type: &ForeignCallParam<F>,
 ) -> Result<PrintableType, ForeignCallError> {
     let printable_type_as_fields = printable_type.fields();
     let printable_type_as_string = decode_string_value(&printable_type_as_fields);
@@ -154,7 +152,7 @@ fn fetch_printable_type(
     Ok(printable_type)
 }
 
-fn to_string(value: &PrintableValue, typ: &PrintableType) -> Option<String> {
+fn to_string<F: AcirField>(value: &PrintableValue<F>, typ: &PrintableType) -> Option<String> {
     let mut output = String::new();
     match (value, typ) {
         (PrintableValue::Field(f), PrintableType::Field) => {
@@ -269,7 +267,7 @@ fn replace_all<E>(
     Ok(new)
 }
 
-impl std::fmt::Display for PrintableValueDisplay {
+impl<F: AcirField> std::fmt::Display for PrintableValueDisplay<F> {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Plain(value, typ) => {
@@ -295,7 +293,7 @@ impl std::fmt::Display for PrintableValueDisplay {
 /// A singular '0' will be prepended as well if the trimmed string has an odd length.
 /// A hex string's length needs to be even to decode into bytes, as two digits correspond to
 /// one byte.
-fn format_field_string(field: FieldElement) -> String {
+fn format_field_string<F: AcirField>(field: F) -> String {
     if field.is_zero() {
         return "0x00".to_owned();
     }
@@ -306,11 +304,11 @@ fn format_field_string(field: FieldElement) -> String {
     "0x".to_owned() + &trimmed_field
 }
 
-/// Assumes that `field_iterator` contains enough [FieldElement] in order to decode the [PrintableType]
-pub fn decode_value(
-    field_iterator: &mut impl Iterator<Item = FieldElement>,
+/// Assumes that `field_iterator` contains enough field elements in order to decode the [PrintableType]
+pub fn decode_value<F: AcirField>(
+    field_iterator: &mut impl Iterator<Item = F>,
     typ: &PrintableType,
-) -> PrintableValue {
+) -> PrintableValue<F> {
     match typ {
         PrintableType::Field
         | PrintableType::SignedInteger { .. }
@@ -346,7 +344,7 @@ pub fn decode_value(
             is_slice: false,
         },
         PrintableType::String { length } => {
-            let field_elements: Vec<FieldElement> = field_iterator.take(*length as usize).collect();
+            let field_elements: Vec<F> = field_iterator.take(*length as usize).collect();
 
             PrintableValue::String(decode_string_value(&field_elements))
         }
@@ -372,11 +370,11 @@ pub fn decode_value(
             // we decode the reference, but it's not really used for printing
             decode_value(field_iterator, typ)
         }
-        PrintableType::Unit => PrintableValue::Field(FieldElement::zero()),
+        PrintableType::Unit => PrintableValue::Field(F::zero()),
     }
 }
 
-pub fn decode_string_value(field_elements: &[FieldElement]) -> String {
+pub fn decode_string_value<F: AcirField>(field_elements: &[F]) -> String {
     // TODO: Replace with `into` when Char is supported
     let string_as_slice = vecmap(field_elements, |e| {
         let mut field_as_bytes = e.to_be_bytes();
diff --git a/tooling/acvm_cli/src/errors.rs b/tooling/acvm_cli/src/errors.rs
index 8bc79347159..886c1bf80f2 100644
--- a/tooling/acvm_cli/src/errors.rs
+++ b/tooling/acvm_cli/src/errors.rs
@@ -1,3 +1,4 @@
+use acir::FieldElement;
 use nargo::NargoError;
 use std::path::PathBuf;
 use thiserror::Error;
@@ -34,7 +35,7 @@ pub(crate) enum CliError {
 
     /// Error related to circuit execution
     #[error(transparent)]
-    CircuitExecutionError(#[from] NargoError),
+    CircuitExecutionError(#[from] NargoError<FieldElement>),
 
     /// Input Witness Value Error
     #[error("Error: failed to parse witness value {0}")]
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 9dc5c758c6f..5d0916b4863 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -23,7 +23,7 @@ pub(super) enum DebugCommandResult {
     Done,
     Ok,
     BreakpointReached(OpcodeLocation),
-    Error(NargoError),
+    Error(NargoError<FieldElement>),
 }
 
 pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver<FieldElement>> {
@@ -482,11 +482,11 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
         }
     }
 
-    pub(super) fn get_variables(&self) -> Vec<StackFrame> {
+    pub(super) fn get_variables(&self) -> Vec<StackFrame<FieldElement>> {
         return self.foreign_call_executor.get_variables();
     }
 
-    pub(super) fn current_stack_frame(&self) -> Option<StackFrame> {
+    pub(super) fn current_stack_frame(&self) -> Option<StackFrame<FieldElement>> {
         return self.foreign_call_executor.current_stack_frame();
     }
 
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index 6989936ae93..03b1a35dfa5 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -38,14 +38,14 @@ impl DebugForeignCall {
     }
 }
 
-pub trait DebugForeignCallExecutor: ForeignCallExecutor {
-    fn get_variables(&self) -> Vec<StackFrame>;
-    fn current_stack_frame(&self) -> Option<StackFrame>;
+pub trait DebugForeignCallExecutor: ForeignCallExecutor<FieldElement> {
+    fn get_variables(&self) -> Vec<StackFrame<FieldElement>>;
+    fn current_stack_frame(&self) -> Option<StackFrame<FieldElement>>;
 }
 
 pub struct DefaultDebugForeignCallExecutor {
-    executor: DefaultForeignCallExecutor,
-    pub debug_vars: DebugVars,
+    executor: DefaultForeignCallExecutor<FieldElement>,
+    pub debug_vars: DebugVars<FieldElement>,
 }
 
 impl DefaultDebugForeignCallExecutor {
@@ -73,11 +73,11 @@ impl DefaultDebugForeignCallExecutor {
 }
 
 impl DebugForeignCallExecutor for DefaultDebugForeignCallExecutor {
-    fn get_variables(&self) -> Vec<StackFrame> {
+    fn get_variables(&self) -> Vec<StackFrame<FieldElement>> {
         self.debug_vars.get_variables()
     }
 
-    fn current_stack_frame(&self) -> Option<StackFrame> {
+    fn current_stack_frame(&self) -> Option<StackFrame<FieldElement>> {
         self.debug_vars.current_stack_frame()
     }
 }
@@ -90,7 +90,7 @@ fn debug_fn_id(value: &FieldElement) -> DebugFnId {
     DebugFnId(value.to_u128() as u32)
 }
 
-impl ForeignCallExecutor for DefaultDebugForeignCallExecutor {
+impl ForeignCallExecutor<FieldElement> for DefaultDebugForeignCallExecutor {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo<FieldElement>,
diff --git a/tooling/debugger/src/lib.rs b/tooling/debugger/src/lib.rs
index d7a1337c82f..9168a6228f0 100644
--- a/tooling/debugger/src/lib.rs
+++ b/tooling/debugger/src/lib.rs
@@ -24,7 +24,7 @@ pub fn debug_circuit<B: BlackBoxFunctionSolver<FieldElement>>(
     debug_artifact: DebugArtifact,
     initial_witness: WitnessMap<FieldElement>,
     unconstrained_functions: &[BrilligBytecode<FieldElement>],
-) -> Result<Option<WitnessMap<FieldElement>>, NargoError> {
+) -> Result<Option<WitnessMap<FieldElement>>, NargoError<FieldElement>> {
     repl::run(blackbox_solver, circuit, &debug_artifact, initial_witness, unconstrained_functions)
 }
 
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 5aef12ad8d4..07f9333d51c 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -382,7 +382,7 @@ pub fn run<B: BlackBoxFunctionSolver<FieldElement>>(
     debug_artifact: &DebugArtifact,
     initial_witness: WitnessMap<FieldElement>,
     unconstrained_functions: &[BrilligBytecode<FieldElement>],
-) -> Result<Option<WitnessMap<FieldElement>>, NargoError> {
+) -> Result<Option<WitnessMap<FieldElement>>, NargoError<FieldElement>> {
     let context = RefCell::new(ReplDebugger::new(
         blackbox_solver,
         circuit,
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index d2c0bb3ea00..aa9328432b8 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -1,4 +1,4 @@
-use acvm::FieldElement;
+use acvm::AcirField;
 use noirc_errors::debug_info::{
     DebugFnId, DebugFunction, DebugInfo, DebugTypeId, DebugVarId, DebugVariable,
 };
@@ -6,31 +6,31 @@ use noirc_printable_type::{decode_value, PrintableType, PrintableValue};
 use std::collections::HashMap;
 
 #[derive(Debug, Default, Clone)]
-pub struct DebugVars {
+pub struct DebugVars<F> {
     variables: HashMap<DebugVarId, DebugVariable>,
     functions: HashMap<DebugFnId, DebugFunction>,
     types: HashMap<DebugTypeId, PrintableType>,
-    frames: Vec<(DebugFnId, HashMap<DebugVarId, PrintableValue>)>,
+    frames: Vec<(DebugFnId, HashMap<DebugVarId, PrintableValue<F>>)>,
 }
 
-pub struct StackFrame<'a> {
+pub struct StackFrame<'a, F> {
     pub function_name: &'a str,
     pub function_params: Vec<&'a str>,
-    pub variables: Vec<(&'a str, &'a PrintableValue, &'a PrintableType)>,
+    pub variables: Vec<(&'a str, &'a PrintableValue<F>, &'a PrintableType)>,
 }
 
-impl DebugVars {
+impl<F: AcirField> DebugVars<F> {
     pub fn insert_debug_info(&mut self, info: &DebugInfo) {
         self.variables.extend(info.variables.clone());
         self.types.extend(info.types.clone());
         self.functions.extend(info.functions.clone());
     }
 
-    pub fn get_variables(&self) -> Vec<StackFrame> {
+    pub fn get_variables(&self) -> Vec<StackFrame<F>> {
         self.frames.iter().map(|(fn_id, frame)| self.build_stack_frame(fn_id, frame)).collect()
     }
 
-    pub fn current_stack_frame(&self) -> Option<StackFrame> {
+    pub fn current_stack_frame(&self) -> Option<StackFrame<F>> {
         self.frames.last().map(|(fn_id, frame)| self.build_stack_frame(fn_id, frame))
     }
 
@@ -44,13 +44,13 @@ impl DebugVars {
     fn build_stack_frame<'a>(
         &'a self,
         fn_id: &DebugFnId,
-        frame: &'a HashMap<DebugVarId, PrintableValue>,
-    ) -> StackFrame {
+        frame: &'a HashMap<DebugVarId, PrintableValue<F>>,
+    ) -> StackFrame<F> {
         let debug_fn = &self.functions.get(fn_id).expect("failed to find function metadata");
 
         let params: Vec<&str> =
             debug_fn.arg_names.iter().map(|arg_name| arg_name.as_str()).collect();
-        let vars: Vec<(&str, &PrintableValue, &PrintableType)> = frame
+        let vars: Vec<(&str, &PrintableValue<F>, &PrintableType)> = frame
             .iter()
             .filter_map(|(var_id, var_value)| {
                 self.lookup_var(*var_id).map(|(name, typ)| (name, var_value, typ))
@@ -64,7 +64,7 @@ impl DebugVars {
         }
     }
 
-    pub fn assign_var(&mut self, var_id: DebugVarId, values: &[FieldElement]) {
+    pub fn assign_var(&mut self, var_id: DebugVarId, values: &[F]) {
         let type_id = &self.variables.get(&var_id).unwrap().debug_type_id;
         let ptype = self.types.get(type_id).unwrap();
 
@@ -75,9 +75,9 @@ impl DebugVars {
             .insert(var_id, decode_value(&mut values.iter().copied(), ptype));
     }
 
-    pub fn assign_field(&mut self, var_id: DebugVarId, indexes: Vec<u32>, values: &[FieldElement]) {
+    pub fn assign_field(&mut self, var_id: DebugVarId, indexes: Vec<u32>, values: &[F]) {
         let current_frame = &mut self.frames.last_mut().expect("unexpected empty stack frames").1;
-        let mut cursor: &mut PrintableValue = current_frame
+        let mut cursor: &mut PrintableValue<F> = current_frame
             .get_mut(&var_id)
             .unwrap_or_else(|| panic!("value unavailable for var_id {var_id:?}"));
         let cursor_type_id = &self
@@ -146,7 +146,7 @@ impl DebugVars {
         *cursor = decode_value(&mut values.iter().copied(), cursor_type);
     }
 
-    pub fn assign_deref(&mut self, _var_id: DebugVarId, _values: &[FieldElement]) {
+    pub fn assign_deref(&mut self, _var_id: DebugVarId, _values: &[F]) {
         unimplemented![]
     }
 
diff --git a/tooling/nargo/src/errors.rs b/tooling/nargo/src/errors.rs
index 200420e5ce5..b2248605cb5 100644
--- a/tooling/nargo/src/errors.rs
+++ b/tooling/nargo/src/errors.rs
@@ -6,7 +6,7 @@ use acvm::{
         ResolvedOpcodeLocation,
     },
     pwg::{ErrorLocation, OpcodeResolutionError},
-    FieldElement,
+    AcirField, FieldElement,
 };
 use noirc_abi::{display_abi_error, Abi, AbiErrorType};
 use noirc_errors::{
@@ -40,21 +40,21 @@ impl From<ReportedErrors> for CompileError {
 }
 
 #[derive(Debug, Error)]
-pub enum NargoError {
+pub enum NargoError<F: AcirField> {
     /// Error while compiling Noir into ACIR.
     #[error("Failed to compile circuit")]
     CompilationError,
 
     /// ACIR circuit execution error
     #[error(transparent)]
-    ExecutionError(#[from] ExecutionError),
+    ExecutionError(#[from] ExecutionError<F>),
 
     /// Oracle handling error
     #[error(transparent)]
     ForeignCallError(#[from] ForeignCallError),
 }
 
-impl NargoError {
+impl<F: AcirField> NargoError<F> {
     /// Extracts the user defined failure message from the ExecutionError
     /// If one exists.
     ///
@@ -94,17 +94,17 @@ impl NargoError {
 }
 
 #[derive(Debug, Error)]
-pub enum ExecutionError {
+pub enum ExecutionError<F: AcirField> {
     #[error("Failed assertion")]
-    AssertionFailed(ResolvedAssertionPayload<FieldElement>, Vec<ResolvedOpcodeLocation>),
+    AssertionFailed(ResolvedAssertionPayload<F>, Vec<ResolvedOpcodeLocation>),
 
     #[error("Failed to solve program: '{}'", .0)]
-    SolvingError(OpcodeResolutionError<FieldElement>, Option<Vec<ResolvedOpcodeLocation>>),
+    SolvingError(OpcodeResolutionError<F>, Option<Vec<ResolvedOpcodeLocation>>),
 }
 
 /// Extracts the opcode locations from a nargo error.
-fn extract_locations_from_error(
-    error: &ExecutionError,
+fn extract_locations_from_error<F: AcirField>(
+    error: &ExecutionError<F>,
     debug: &[DebugInfo],
 ) -> Option<Vec<Location>> {
     let mut opcode_locations = match error {
@@ -163,7 +163,7 @@ fn extract_locations_from_error(
 
 fn extract_message_from_error(
     error_types: &BTreeMap<ErrorSelector, AbiErrorType>,
-    nargo_err: &NargoError,
+    nargo_err: &NargoError<FieldElement>,
 ) -> String {
     match nargo_err {
         NargoError::ExecutionError(ExecutionError::AssertionFailed(
@@ -198,7 +198,7 @@ fn extract_message_from_error(
 
 /// Tries to generate a runtime diagnostic from a nargo error. It will successfully do so if it's a runtime error with a call stack.
 pub fn try_to_diagnose_runtime_error(
-    nargo_err: &NargoError,
+    nargo_err: &NargoError<FieldElement>,
     abi: &Abi,
     debug: &[DebugInfo],
 ) -> Option<FileDiagnostic> {
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 42e93e0e3cf..c9cc60d03d9 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -5,24 +5,24 @@ use acvm::acir::circuit::{
 use acvm::acir::native_types::WitnessStack;
 use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ACVM};
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
-use acvm::{BlackBoxFunctionSolver, FieldElement};
+use acvm::{AcirField, BlackBoxFunctionSolver};
 
 use crate::errors::ExecutionError;
 use crate::NargoError;
 
 use super::foreign_calls::ForeignCallExecutor;
 
-struct ProgramExecutor<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor> {
-    functions: &'a [Circuit<FieldElement>],
+struct ProgramExecutor<'a, F, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>> {
+    functions: &'a [Circuit<F>],
 
-    unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
+    unconstrained_functions: &'a [BrilligBytecode<F>],
 
     // This gets built as we run through the program looking at each function call
-    witness_stack: WitnessStack<FieldElement>,
+    witness_stack: WitnessStack<F>,
 
     blackbox_solver: &'a B,
 
-    foreign_call_executor: &'a mut F,
+    foreign_call_executor: &'a mut E,
 
     // The Noir compiler codegens per function and call stacks are not shared across ACIR function calls.
     // We must rebuild a call stack when executing a program of many circuits.
@@ -34,14 +34,14 @@ struct ProgramExecutor<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCa
     current_function_index: usize,
 }
 
-impl<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>
-    ProgramExecutor<'a, B, F>
+impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
+    ProgramExecutor<'a, F, B, E>
 {
     fn new(
-        functions: &'a [Circuit<FieldElement>],
-        unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
+        functions: &'a [Circuit<F>],
+        unconstrained_functions: &'a [BrilligBytecode<F>],
         blackbox_solver: &'a B,
-        foreign_call_executor: &'a mut F,
+        foreign_call_executor: &'a mut E,
     ) -> Self {
         ProgramExecutor {
             functions,
@@ -54,15 +54,15 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>
         }
     }
 
-    fn finalize(self) -> WitnessStack<FieldElement> {
+    fn finalize(self) -> WitnessStack<F> {
         self.witness_stack
     }
 
     #[tracing::instrument(level = "trace", skip_all)]
     fn execute_circuit(
         &mut self,
-        initial_witness: WitnessMap<FieldElement>,
-    ) -> Result<WitnessMap<FieldElement>, NargoError> {
+        initial_witness: WitnessMap<F>,
+    ) -> Result<WitnessMap<F>, NargoError<F>> {
         let circuit = &self.functions[self.current_function_index];
         let mut acvm = ACVM::new(
             self.blackbox_solver,
@@ -109,14 +109,13 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>
                         _ => None,
                     };
 
-                    let assertion_payload: Option<ResolvedAssertionPayload<FieldElement>> =
-                        match &error {
-                            OpcodeResolutionError::BrilligFunctionFailed { payload, .. }
-                            | OpcodeResolutionError::UnsatisfiedConstrain { payload, .. } => {
-                                payload.clone()
-                            }
-                            _ => None,
-                        };
+                    let assertion_payload: Option<ResolvedAssertionPayload<F>> = match &error {
+                        OpcodeResolutionError::BrilligFunctionFailed { payload, .. }
+                        | OpcodeResolutionError::UnsatisfiedConstrain { payload, .. } => {
+                            payload.clone()
+                        }
+                        _ => None,
+                    };
 
                     return Err(NargoError::ExecutionError(match assertion_payload {
                         Some(payload) => ExecutionError::AssertionFailed(
@@ -174,12 +173,12 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>
 }
 
 #[tracing::instrument(level = "trace", skip_all)]
-pub fn execute_program<B: BlackBoxFunctionSolver<FieldElement>, F: ForeignCallExecutor>(
-    program: &Program<FieldElement>,
-    initial_witness: WitnessMap<FieldElement>,
+pub fn execute_program<F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>(
+    program: &Program<F>,
+    initial_witness: WitnessMap<F>,
     blackbox_solver: &B,
-    foreign_call_executor: &mut F,
-) -> Result<WitnessStack<FieldElement>, NargoError> {
+    foreign_call_executor: &mut E,
+) -> Result<WitnessStack<F>, NargoError<F>> {
     let mut executor = ProgramExecutor::new(
         &program.functions,
         &program.unconstrained_functions,
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index 115337c1636..987c7dd9cb9 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -1,18 +1,18 @@
 use acvm::{
     acir::brillig::{ForeignCallParam, ForeignCallResult},
     pwg::ForeignCallWaitInfo,
-    AcirField, FieldElement,
+    AcirField,
 };
 use jsonrpc::{arg as build_json_rpc_arg, minreq_http::Builder, Client};
 use noirc_printable_type::{decode_string_value, ForeignCallError, PrintableValueDisplay};
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-pub trait ForeignCallExecutor {
+pub trait ForeignCallExecutor<F> {
     fn execute(
         &mut self,
-        foreign_call: &ForeignCallWaitInfo<FieldElement>,
-    ) -> Result<ForeignCallResult<FieldElement>, ForeignCallError>;
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError>;
 }
 
 /// This enumeration represents the Brillig foreign calls that are natively supported by nargo.
@@ -62,22 +62,22 @@ impl ForeignCall {
 
 /// This struct represents an oracle mock. It can be used for testing programs that use oracles.
 #[derive(Debug, PartialEq, Eq, Clone)]
-struct MockedCall {
+struct MockedCall<F> {
     /// The id of the mock, used to update or remove it
     id: usize,
     /// The oracle it's mocking
     name: String,
     /// Optionally match the parameters
-    params: Option<Vec<ForeignCallParam<FieldElement>>>,
+    params: Option<Vec<ForeignCallParam<F>>>,
     /// The parameters with which the mock was last called
-    last_called_params: Option<Vec<ForeignCallParam<FieldElement>>>,
+    last_called_params: Option<Vec<ForeignCallParam<F>>>,
     /// The result to return when this mock is called
-    result: ForeignCallResult<FieldElement>,
+    result: ForeignCallResult<F>,
     /// How many times should this mock be called before it is removed
     times_left: Option<u64>,
 }
 
-impl MockedCall {
+impl<F> MockedCall<F> {
     fn new(id: usize, name: String) -> Self {
         Self {
             id,
@@ -90,14 +90,14 @@ impl MockedCall {
     }
 }
 
-impl MockedCall {
-    fn matches(&self, name: &str, params: &[ForeignCallParam<FieldElement>]) -> bool {
+impl<F: PartialEq> MockedCall<F> {
+    fn matches(&self, name: &str, params: &[ForeignCallParam<F>]) -> bool {
         self.name == name && (self.params.is_none() || self.params.as_deref() == Some(params))
     }
 }
 
 #[derive(Debug, Default)]
-pub struct DefaultForeignCallExecutor {
+pub struct DefaultForeignCallExecutor<F> {
     /// A randomly generated id for this `DefaultForeignCallExecutor`.
     ///
     /// This is used so that a single `external_resolver` can distinguish between requests from multiple
@@ -107,7 +107,7 @@ pub struct DefaultForeignCallExecutor {
     /// Mocks have unique ids used to identify them in Noir, allowing to update or remove them.
     last_mock_id: usize,
     /// The registered mocks
-    mocked_responses: Vec<MockedCall>,
+    mocked_responses: Vec<MockedCall<F>>,
     /// Whether to print [`ForeignCall::Print`] output.
     show_output: bool,
     /// JSON RPC client to resolve foreign calls
@@ -128,7 +128,7 @@ struct ResolveForeignCallRequest<F> {
     function_call: ForeignCallWaitInfo<F>,
 }
 
-impl DefaultForeignCallExecutor {
+impl<F> DefaultForeignCallExecutor<F> {
     pub fn new(show_output: bool, resolver_url: Option<&str>) -> Self {
         let oracle_resolver = resolver_url.map(|resolver_url| {
             let mut transport_builder =
@@ -146,15 +146,16 @@ impl DefaultForeignCallExecutor {
             show_output,
             external_resolver: oracle_resolver,
             id: rand::thread_rng().gen(),
-            ..DefaultForeignCallExecutor::default()
+            mocked_responses: Vec::new(),
+            last_mock_id: 0,
         }
     }
 }
 
-impl DefaultForeignCallExecutor {
+impl<F: AcirField> DefaultForeignCallExecutor<F> {
     fn extract_mock_id(
-        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
-    ) -> Result<(usize, &[ForeignCallParam<FieldElement>]), ForeignCallError> {
+        foreign_call_inputs: &[ForeignCallParam<F>],
+    ) -> Result<(usize, &[ForeignCallParam<F>]), ForeignCallError> {
         let (id, params) =
             foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
         let id =
@@ -163,22 +164,20 @@ impl DefaultForeignCallExecutor {
         Ok((id, params))
     }
 
-    fn find_mock_by_id(&self, id: usize) -> Option<&MockedCall> {
+    fn find_mock_by_id(&self, id: usize) -> Option<&MockedCall<F>> {
         self.mocked_responses.iter().find(|response| response.id == id)
     }
 
-    fn find_mock_by_id_mut(&mut self, id: usize) -> Option<&mut MockedCall> {
+    fn find_mock_by_id_mut(&mut self, id: usize) -> Option<&mut MockedCall<F>> {
         self.mocked_responses.iter_mut().find(|response| response.id == id)
     }
 
-    fn parse_string(param: &ForeignCallParam<FieldElement>) -> String {
+    fn parse_string(param: &ForeignCallParam<F>) -> String {
         let fields: Vec<_> = param.fields().to_vec();
         decode_string_value(&fields)
     }
 
-    fn execute_print(
-        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
-    ) -> Result<(), ForeignCallError> {
+    fn execute_print(foreign_call_inputs: &[ForeignCallParam<F>]) -> Result<(), ForeignCallError> {
         let skip_newline = foreign_call_inputs[0].unwrap_field().is_zero();
 
         let foreign_call_inputs =
@@ -191,10 +190,10 @@ impl DefaultForeignCallExecutor {
     }
 
     fn format_printable_value(
-        foreign_call_inputs: &[ForeignCallParam<FieldElement>],
+        foreign_call_inputs: &[ForeignCallParam<F>],
         skip_newline: bool,
     ) -> Result<String, ForeignCallError> {
-        let display_values: PrintableValueDisplay = foreign_call_inputs.try_into()?;
+        let display_values: PrintableValueDisplay<F> = foreign_call_inputs.try_into()?;
 
         let result = format!("{display_values}{}", if skip_newline { "" } else { "\n" });
 
@@ -202,11 +201,13 @@ impl DefaultForeignCallExecutor {
     }
 }
 
-impl ForeignCallExecutor for DefaultForeignCallExecutor {
+impl<F: AcirField + Serialize + for<'a> Deserialize<'a>> ForeignCallExecutor<F>
+    for DefaultForeignCallExecutor<F>
+{
     fn execute(
         &mut self,
-        foreign_call: &ForeignCallWaitInfo<FieldElement>,
-    ) -> Result<ForeignCallResult<FieldElement>, ForeignCallError> {
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match ForeignCall::lookup(foreign_call_name) {
             Some(ForeignCall::Print) => {
@@ -222,7 +223,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                 self.mocked_responses.push(MockedCall::new(id, mock_oracle_name));
                 self.last_mock_id += 1;
 
-                Ok(FieldElement::from(id).into())
+                Ok(F::from(id).into())
             }
             Some(ForeignCall::SetMockParams) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -308,7 +309,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
 
                     let response = external_resolver.send_request(req)?;
 
-                    let parsed_response: ForeignCallResult<FieldElement> = response.result()?;
+                    let parsed_response: ForeignCallResult<F> = response.result()?;
 
                     Ok(parsed_response)
                 } else {
@@ -401,7 +402,7 @@ mod tests {
     fn test_oracle_resolver_echo() {
         let (server, url) = build_oracle_server();
 
-        let mut executor = DefaultForeignCallExecutor::new(false, Some(&url));
+        let mut executor = DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url));
 
         let foreign_call = ForeignCallWaitInfo {
             function: "echo".to_string(),
@@ -435,7 +436,7 @@ mod tests {
     fn foreign_call_executor_id_is_persistent() {
         let (server, url) = build_oracle_server();
 
-        let mut executor = DefaultForeignCallExecutor::new(false, Some(&url));
+        let mut executor = DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url));
 
         let foreign_call = ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
 
@@ -450,8 +451,8 @@ mod tests {
     fn oracle_resolver_rpc_can_distinguish_executors() {
         let (server, url) = build_oracle_server();
 
-        let mut executor_1 = DefaultForeignCallExecutor::new(false, Some(&url));
-        let mut executor_2 = DefaultForeignCallExecutor::new(false, Some(&url));
+        let mut executor_1 = DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url));
+        let mut executor_2 = DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url));
 
         let foreign_call = ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
 
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index ed45251ac8a..ace2e9f0d0c 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -76,7 +76,7 @@ fn test_status_program_compile_pass(
     test_function: &TestFunction,
     abi: Abi,
     debug: Vec<DebugInfo>,
-    circuit_execution: Result<WitnessStack<FieldElement>, NargoError>,
+    circuit_execution: Result<WitnessStack<FieldElement>, NargoError<FieldElement>>,
 ) -> TestStatus {
     let circuit_execution_err = match circuit_execution {
         // Circuit execution was successful; ie no errors or unsatisfied constraints
diff --git a/tooling/nargo_cli/src/errors.rs b/tooling/nargo_cli/src/errors.rs
index 3e0b13a9cbc..b28012ae7aa 100644
--- a/tooling/nargo_cli/src/errors.rs
+++ b/tooling/nargo_cli/src/errors.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessStackError;
+use acvm::{acir::native_types::WitnessStackError, FieldElement};
 use nargo::{errors::CompileError, NargoError};
 use nargo_toml::ManifestError;
 use noir_debugger::errors::DapError;
@@ -54,7 +54,7 @@ pub(crate) enum CliError {
 
     /// Error from Nargo
     #[error(transparent)]
-    NargoError(#[from] NargoError),
+    NargoError(#[from] NargoError<FieldElement>),
 
     /// Error from Manifest
     #[error(transparent)]
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index b1ddba26f15..134dd5e621e 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -620,10 +620,10 @@ impl AbiErrorType {
     }
 }
 
-pub fn display_abi_error(
-    fields: &[FieldElement],
+pub fn display_abi_error<F: AcirField>(
+    fields: &[F],
     error_type: AbiErrorType,
-) -> PrintableValueDisplay {
+) -> PrintableValueDisplay<F> {
     match error_type {
         AbiErrorType::FmtString { length, item_types } => {
             let mut fields_iter = fields.iter().copied();

From 8a322998ee60875f7abe4dc222f8fdc20cb0ee0a Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 10 Jun 2024 16:18:28 +0100
Subject: [PATCH 352/416] chore: remove stale comment (#5179)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We no longer use a backend here.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/build.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 25a69489788..fcc09653c7d 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -287,9 +287,6 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
 #[test]
 fn compile_success_empty_{test_name}() {{
 
-    // We use a mocked backend for this test as we do not rely on the returned circuit size
-    // but we must call a backend as part of querying the number of opcodes in the circuit.
-
     let test_program_dir = PathBuf::from("{test_dir}");
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);

From b1298b85f401b380e2d36c61bc1f5f63bfe6742e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 10 Jun 2024 16:34:42 +0100
Subject: [PATCH 353/416] chore: move implementation of bitwise operations into
 `blackbox_solver` (#5209)

# Description

## Problem\*

Related to #5055
## Summary\*

We don't need the field element to know about AND and XOR as we just
need to be able to convert into byte arrays and back. I've then moved
this into the blackbox solver crate (the only place we were actually
using this) to simplify the `AcirField` trait.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acir_field/src/field_element.rs  | 81 --------------------
 acvm-repo/acir_field/src/generic_ark.rs    |  3 -
 acvm-repo/acvm/src/pwg/blackbox/logic.rs   |  9 ++-
 acvm-repo/acvm_js/src/black_box_solvers.rs |  4 +-
 acvm-repo/blackbox_solver/src/lib.rs       |  2 +
 acvm-repo/blackbox_solver/src/logic.rs     | 87 ++++++++++++++++++++++
 6 files changed, 96 insertions(+), 90 deletions(-)
 create mode 100644 acvm-repo/blackbox_solver/src/logic.rs

diff --git a/acvm-repo/acir_field/src/field_element.rs b/acvm-repo/acir_field/src/field_element.rs
index 7810578ff73..81582b9fbac 100644
--- a/acvm-repo/acir_field/src/field_element.rs
+++ b/acvm-repo/acir_field/src/field_element.rs
@@ -195,15 +195,6 @@ impl<F: PrimeField> FieldElement<F> {
         Some(FieldElement(fr))
     }
 
-    // mask_to methods will not remove any bytes from the field
-    // they are simply zeroed out
-    // Whereas truncate_to will remove those bits and make the byte array smaller
-    fn mask_to_be_bytes(&self, num_bits: u32) -> Vec<u8> {
-        let mut bytes = self.to_be_bytes();
-        mask_vector_le(&mut bytes, num_bits as usize);
-        bytes
-    }
-
     fn bits(&self) -> Vec<bool> {
         fn byte_to_bit(byte: u8) -> Vec<bool> {
             let mut bits = Vec::with_capacity(8);
@@ -220,29 +211,6 @@ impl<F: PrimeField> FieldElement<F> {
         }
         bits
     }
-
-    fn and_xor(&self, rhs: &FieldElement<F>, num_bits: u32, is_xor: bool) -> FieldElement<F> {
-        // XXX: Gadgets like SHA256 need to have their input be a multiple of 8
-        // This is not a restriction caused by SHA256, as it works on bits
-        // but most backends assume bytes.
-        // We could implicitly pad, however this may not be intuitive for users.
-        // assert!(
-        //     num_bits % 8 == 0,
-        //     "num_bits is not a multiple of 8, it is {}",
-        //     num_bits
-        // );
-
-        let lhs_bytes = self.mask_to_be_bytes(num_bits);
-        let rhs_bytes = rhs.mask_to_be_bytes(num_bits);
-
-        let and_byte_arr: Vec<_> = lhs_bytes
-            .into_iter()
-            .zip(rhs_bytes)
-            .map(|(lhs, rhs)| if is_xor { lhs ^ rhs } else { lhs & rhs })
-            .collect();
-
-        FieldElement::from_be_bytes_reduce(&and_byte_arr)
-    }
 }
 
 impl<F: PrimeField> AcirField for FieldElement<F> {
@@ -376,13 +344,6 @@ impl<F: PrimeField> AcirField for FieldElement<F> {
 
         bytes[0..num_elements].to_vec()
     }
-
-    fn and(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
-        self.and_xor(rhs, num_bits, false)
-    }
-    fn xor(&self, rhs: &FieldElement<F>, num_bits: u32) -> FieldElement<F> {
-        self.and_xor(rhs, num_bits, true)
-    }
 }
 
 impl<F: PrimeField> Neg for FieldElement<F> {
@@ -433,35 +394,6 @@ impl<F: PrimeField> SubAssign for FieldElement<F> {
     }
 }
 
-fn mask_vector_le(bytes: &mut [u8], num_bits: usize) {
-    // reverse to big endian format
-    bytes.reverse();
-
-    let mask_power = num_bits % 8;
-    let array_mask_index = num_bits / 8;
-
-    for (index, byte) in bytes.iter_mut().enumerate() {
-        match index.cmp(&array_mask_index) {
-            std::cmp::Ordering::Less => {
-                // do nothing if the current index is less than
-                // the array index.
-            }
-            std::cmp::Ordering::Equal => {
-                let mask = 2u8.pow(mask_power as u32) - 1;
-                // mask the byte
-                *byte &= mask;
-            }
-            std::cmp::Ordering::Greater => {
-                // Anything greater than the array index
-                // will be set to zero
-                *byte = 0;
-            }
-        }
-    }
-    // reverse back to little endian
-    bytes.reverse();
-}
-
 // For pretty printing powers
 fn superscript(n: u64) -> String {
     if n == 0 {
@@ -495,19 +427,6 @@ fn superscript(n: u64) -> String {
 mod tests {
     use super::{AcirField, FieldElement};
 
-    #[test]
-    fn and() {
-        let max = 10_000u32;
-
-        let num_bits = (std::mem::size_of::<u32>() * 8) as u32 - max.leading_zeros();
-
-        for x in 0..max {
-            let x = FieldElement::<ark_bn254::Fr>::from(x as i128);
-            let res = x.and(&x, num_bits);
-            assert_eq!(res.to_be_bytes(), x.to_be_bytes());
-        }
-    }
-
     #[test]
     fn serialize_fixed_test_vectors() {
         // Serialized field elements from of 0, -1, -2, -3
diff --git a/acvm-repo/acir_field/src/generic_ark.rs b/acvm-repo/acir_field/src/generic_ark.rs
index 3d93de5a992..f7228e66314 100644
--- a/acvm-repo/acir_field/src/generic_ark.rs
+++ b/acvm-repo/acir_field/src/generic_ark.rs
@@ -78,7 +78,4 @@ pub trait AcirField:
     /// Returns the closest number of bytes to the bits specified
     /// This method truncates
     fn fetch_nearest_bytes(&self, num_bits: usize) -> Vec<u8>;
-
-    fn and(&self, rhs: &Self, num_bits: u32) -> Self;
-    fn xor(&self, rhs: &Self, num_bits: u32) -> Self;
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/logic.rs b/acvm-repo/acvm/src/pwg/blackbox/logic.rs
index 6e2ade3c49b..5be888c8ac6 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/logic.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/logic.rs
@@ -5,6 +5,7 @@ use acir::{
     native_types::{Witness, WitnessMap},
     AcirField,
 };
+use acvm_blackbox_solver::{bit_and, bit_xor};
 
 /// Solves a [`BlackBoxFunc::And`][acir::circuit::black_box_functions::BlackBoxFunc::AND] opcode and inserts
 /// the result into the supplied witness map
@@ -19,7 +20,7 @@ pub(super) fn and<F: AcirField>(
         "number of bits specified for each input must be the same"
     );
     solve_logic_opcode(initial_witness, &lhs.witness, &rhs.witness, *output, |left, right| {
-        left.and(right, lhs.num_bits)
+        bit_and(left, right, lhs.num_bits)
     })
 }
 
@@ -36,7 +37,7 @@ pub(super) fn xor<F: AcirField>(
         "number of bits specified for each input must be the same"
     );
     solve_logic_opcode(initial_witness, &lhs.witness, &rhs.witness, *output, |left, right| {
-        left.xor(right, lhs.num_bits)
+        bit_xor(left, right, lhs.num_bits)
     })
 }
 
@@ -46,11 +47,11 @@ fn solve_logic_opcode<F: AcirField>(
     a: &Witness,
     b: &Witness,
     result: Witness,
-    logic_op: impl Fn(&F, &F) -> F,
+    logic_op: impl Fn(F, F) -> F,
 ) -> Result<(), OpcodeResolutionError<F>> {
     let w_l_value = witness_to_value(initial_witness, *a)?;
     let w_r_value = witness_to_value(initial_witness, *b)?;
-    let assignment = logic_op(w_l_value, w_r_value);
+    let assignment = logic_op(*w_l_value, *w_r_value);
 
     insert_value(&result, assignment, initial_witness)
 }
diff --git a/acvm-repo/acvm_js/src/black_box_solvers.rs b/acvm-repo/acvm_js/src/black_box_solvers.rs
index 4f2676f8d2f..4cd85a5ed87 100644
--- a/acvm-repo/acvm_js/src/black_box_solvers.rs
+++ b/acvm-repo/acvm_js/src/black_box_solvers.rs
@@ -9,7 +9,7 @@ use acvm::{acir::AcirField, FieldElement};
 pub fn and(lhs: JsString, rhs: JsString) -> JsString {
     let lhs = js_value_to_field_element(lhs.into()).unwrap();
     let rhs = js_value_to_field_element(rhs.into()).unwrap();
-    let result = lhs.and(&rhs, FieldElement::max_num_bits());
+    let result = acvm::blackbox_solver::bit_and(lhs, rhs, FieldElement::max_num_bits());
     field_element_to_js_string(&result)
 }
 
@@ -18,7 +18,7 @@ pub fn and(lhs: JsString, rhs: JsString) -> JsString {
 pub fn xor(lhs: JsString, rhs: JsString) -> JsString {
     let lhs = js_value_to_field_element(lhs.into()).unwrap();
     let rhs = js_value_to_field_element(rhs.into()).unwrap();
-    let result = lhs.xor(&rhs, FieldElement::max_num_bits());
+    let result = acvm::blackbox_solver::bit_xor(lhs, rhs, FieldElement::max_num_bits());
     field_element_to_js_string(&result)
 }
 
diff --git a/acvm-repo/blackbox_solver/src/lib.rs b/acvm-repo/blackbox_solver/src/lib.rs
index a68b52a2a62..c39deb64138 100644
--- a/acvm-repo/blackbox_solver/src/lib.rs
+++ b/acvm-repo/blackbox_solver/src/lib.rs
@@ -15,12 +15,14 @@ mod bigint;
 mod curve_specific_solver;
 mod ecdsa;
 mod hash;
+mod logic;
 
 pub use aes128::aes128_encrypt;
 pub use bigint::BigIntSolver;
 pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver};
 pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 pub use hash::{blake2s, blake3, keccak256, keccakf1600, sha256, sha256compression};
+pub use logic::{bit_and, bit_xor};
 
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
 pub enum BlackBoxResolutionError {
diff --git a/acvm-repo/blackbox_solver/src/logic.rs b/acvm-repo/blackbox_solver/src/logic.rs
new file mode 100644
index 00000000000..95bd3669ff5
--- /dev/null
+++ b/acvm-repo/blackbox_solver/src/logic.rs
@@ -0,0 +1,87 @@
+use acir::AcirField;
+
+pub fn bit_and<F: AcirField>(lhs: F, rhs: F, num_bits: u32) -> F {
+    bitwise_op(lhs, rhs, num_bits, |lhs_byte, rhs_byte| lhs_byte & rhs_byte)
+}
+
+pub fn bit_xor<F: AcirField>(lhs: F, rhs: F, num_bits: u32) -> F {
+    bitwise_op(lhs, rhs, num_bits, |lhs_byte, rhs_byte| lhs_byte ^ rhs_byte)
+}
+
+fn bitwise_op<F: AcirField>(lhs: F, rhs: F, num_bits: u32, op: fn(u8, u8) -> u8) -> F {
+    // XXX: Gadgets like SHA256 need to have their input be a multiple of 8
+    // This is not a restriction caused by SHA256, as it works on bits
+    // but most backends assume bytes.
+    // We could implicitly pad, however this may not be intuitive for users.
+    // assert!(
+    //     num_bits % 8 == 0,
+    //     "num_bits is not a multiple of 8, it is {}",
+    //     num_bits
+    // );
+
+    let lhs_bytes = mask_to_be_bytes(lhs, num_bits);
+    let rhs_bytes = mask_to_be_bytes(rhs, num_bits);
+
+    let and_byte_arr: Vec<_> =
+        lhs_bytes.into_iter().zip(rhs_bytes).map(|(left, right)| op(left, right)).collect();
+
+    F::from_be_bytes_reduce(&and_byte_arr)
+}
+
+// mask_to methods will not remove any bytes from the field
+// they are simply zeroed out
+// Whereas truncate_to will remove those bits and make the byte array smaller
+fn mask_to_be_bytes<F: AcirField>(field: F, num_bits: u32) -> Vec<u8> {
+    let mut bytes = field.to_be_bytes();
+    mask_vector_le(&mut bytes, num_bits as usize);
+    bytes
+}
+
+fn mask_vector_le(bytes: &mut [u8], num_bits: usize) {
+    // reverse to big endian format
+    bytes.reverse();
+
+    let mask_power = num_bits % 8;
+    let array_mask_index = num_bits / 8;
+
+    for (index, byte) in bytes.iter_mut().enumerate() {
+        match index.cmp(&array_mask_index) {
+            std::cmp::Ordering::Less => {
+                // do nothing if the current index is less than
+                // the array index.
+            }
+            std::cmp::Ordering::Equal => {
+                let mask = 2u8.pow(mask_power as u32) - 1;
+                // mask the byte
+                *byte &= mask;
+            }
+            std::cmp::Ordering::Greater => {
+                // Anything greater than the array index
+                // will be set to zero
+                *byte = 0;
+            }
+        }
+    }
+    // reverse back to little endian
+    bytes.reverse();
+}
+
+#[cfg(test)]
+mod tests {
+    use acir::{AcirField, FieldElement};
+
+    use crate::bit_and;
+
+    #[test]
+    fn and() {
+        let max = 10_000u32;
+
+        let num_bits = (std::mem::size_of::<u32>() * 8) as u32 - max.leading_zeros();
+
+        for x in 0..max {
+            let x = FieldElement::from(x as i128);
+            let res = bit_and(x, x, num_bits);
+            assert_eq!(res.to_be_bytes(), x.to_be_bytes());
+        }
+    }
+}

From 21562aeea162d246573967115e7c519715f6d3d8 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 10 Jun 2024 16:44:38 +0100
Subject: [PATCH 354/416] chore!: remove `param_witnesses` and
 `return_witnesses` from ABI (#5154)

# Description

## Problem\*

Followup to #5142
Related to #5104

## Summary\*

This PR deletes the `param_witnesses` and `return_witnesses` fields from
the ABI as the locations of all inputs/return values are defined
implicitly by the types themselves.

I've left this as draft as there's some changes which need to be made to
the JS code which will require some extra work (it needs to be made
aware of the sizes of various types.)

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .github/workflows/test-js-packages.yml        |  27 ----
 compiler/noirc_driver/src/abi_gen.rs          |  93 +------------
 compiler/noirc_driver/src/lib.rs              |  21 +--
 .../getting_started/tooling/noir_codegen.md   |   3 +-
 tooling/nargo_cli/src/cli/debug_cmd.rs        |   3 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |   3 +-
 .../noir_js_backend_barretenberg/package.json |   3 -
 .../noir_js_backend_barretenberg/src/index.ts |   1 -
 .../src/public_inputs.ts                      |  26 +---
 .../test/public_input_deflattening.test.ts    |  97 --------------
 tooling/noir_js_types/src/types.ts            |   2 -
 tooling/noirc_abi/src/input_parser/mod.rs     |   3 -
 tooling/noirc_abi/src/lib.rs                  | 122 +++++-------------
 yarn.lock                                     |   2 -
 14 files changed, 45 insertions(+), 361 deletions(-)
 delete mode 100644 tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts

diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index db162e21269..9f46e6f98e8 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -221,32 +221,6 @@ jobs:
       - name: Run browser tests
         run: yarn workspace @noir-lang/noirc_abi test:browser
 
-  test-noir-js-backend-barretenberg:
-    needs: [build-noirc-abi]
-    name: noir-js-backend-barretenberg
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Download wasm package artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: noirc_abi_wasm
-          path: ./tooling/noirc_abi_wasm
-      
-      - name: Install Yarn dependencies
-        uses: ./.github/actions/setup
-
-      - name: Build noir_js_types
-        run: yarn workspace @noir-lang/types build
-
-      - name: Run barretenberg wrapper tests
-        run: |
-          yarn workspace @noir-lang/backend_barretenberg test
-
   test-noir-js:
     needs: [build-nargo, build-acvm-js, build-noirc-abi]
     name: Noir JS
@@ -546,7 +520,6 @@ jobs:
       - test-acvm_js-node
       - test-acvm_js-browser
       - test-noirc-abi
-      - test-noir-js-backend-barretenberg
       - test-noir-js
       - test-noir-wasm
       - test-noir-codegen
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 609c88b92c2..71dd1b18761 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -1,8 +1,7 @@
 use std::collections::BTreeMap;
 
 use acvm::acir::circuit::ErrorSelector;
-use acvm::acir::native_types::Witness;
-use iter_extended::{btree_map, vecmap};
+use iter_extended::vecmap;
 use noirc_abi::{Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue};
 use noirc_frontend::ast::Visibility;
 use noirc_frontend::{
@@ -11,27 +10,23 @@ use noirc_frontend::{
     macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
 };
-use std::ops::Range;
 
 /// Arranges a function signature and a generated circuit's return witnesses into a
 /// `noirc_abi::Abi`.
 pub(super) fn gen_abi(
     context: &Context,
     func_id: &FuncId,
-    input_witnesses: Vec<Witness>,
-    return_witnesses: Vec<Witness>,
     return_visibility: Visibility,
     error_types: BTreeMap<ErrorSelector, Type>,
 ) -> Abi {
     let (parameters, return_type) = compute_function_abi(context, func_id);
-    let param_witnesses = param_witnesses_from_abi_param(&parameters, input_witnesses);
     let return_type = return_type
         .map(|typ| AbiReturnType { abi_type: typ, visibility: return_visibility.into() });
     let error_types = error_types
         .into_iter()
         .map(|(selector, typ)| (selector, AbiErrorType::from_type(context, &typ)))
         .collect();
-    Abi { parameters, return_type, param_witnesses, return_witnesses, error_types }
+    Abi { parameters, return_type, error_types }
 }
 
 pub(super) fn compute_function_abi(
@@ -67,55 +62,6 @@ fn into_abi_params(context: &Context, params: Vec<Param>) -> Vec<AbiParameter> {
     })
 }
 
-// Takes each abi parameter and shallowly maps to the expected witness range in which the
-// parameter's constituent values live.
-fn param_witnesses_from_abi_param(
-    abi_params: &[AbiParameter],
-    input_witnesses: Vec<Witness>,
-) -> BTreeMap<String, Vec<Range<Witness>>> {
-    let mut idx = 0_usize;
-    if input_witnesses.is_empty() {
-        return BTreeMap::new();
-    }
-
-    btree_map(abi_params, |param| {
-        let num_field_elements_needed = param.typ.field_count() as usize;
-        let param_witnesses = &input_witnesses[idx..idx + num_field_elements_needed];
-
-        // It's likely that `param_witnesses` will consist of mostly incrementing witness indices.
-        // We then want to collapse these into `Range`s to save space.
-        let param_witnesses = collapse_ranges(param_witnesses);
-        idx += num_field_elements_needed;
-        (param.name.clone(), param_witnesses)
-    })
-}
-
-/// Takes a vector of [`Witnesses`][`Witness`] and collapses it into a vector of [`Range`]s of [`Witnesses`][`Witness`].
-fn collapse_ranges(witnesses: &[Witness]) -> Vec<Range<Witness>> {
-    if witnesses.is_empty() {
-        return Vec::new();
-    }
-    let mut wit = Vec::new();
-    let mut last_wit: Witness = witnesses[0];
-
-    for (i, witness) in witnesses.iter().enumerate() {
-        if i == 0 {
-            continue;
-        };
-        let witness_index = witness.witness_index();
-        let prev_witness_index = witnesses[i - 1].witness_index();
-        if witness_index != prev_witness_index + 1 {
-            wit.push(last_wit..Witness(prev_witness_index + 1));
-            last_wit = *witness;
-        };
-    }
-
-    let last_witness = witnesses.last().unwrap().witness_index();
-    wit.push(last_wit..Witness(last_witness + 1));
-
-    wit
-}
-
 pub(super) fn value_from_hir_expression(context: &Context, expression: HirExpression) -> AbiValue {
     match expression {
         HirExpression::Tuple(expr_ids) => {
@@ -169,38 +115,3 @@ pub(super) fn value_from_hir_expression(context: &Context, expression: HirExpres
         _ => unreachable!("Type cannot be used in the abi {:?}", expression),
     }
 }
-
-#[cfg(test)]
-mod test {
-    use std::ops::Range;
-
-    use acvm::acir::native_types::Witness;
-
-    use super::collapse_ranges;
-
-    #[test]
-    fn collapses_single_range() {
-        let witnesses: Vec<_> = vec![1, 2, 3].into_iter().map(Witness::from).collect();
-
-        let collapsed_witnesses = collapse_ranges(&witnesses);
-
-        assert_eq!(collapsed_witnesses, vec![Range { start: Witness(1), end: Witness(4) },]);
-    }
-
-    #[test]
-    fn collapse_ranges_correctly() {
-        let witnesses: Vec<_> =
-            vec![1, 2, 3, 5, 6, 2, 3, 4].into_iter().map(Witness::from).collect();
-
-        let collapsed_witnesses = collapse_ranges(&witnesses);
-
-        assert_eq!(
-            collapsed_witnesses,
-            vec![
-                Range { start: Witness(1), end: Witness(4) },
-                Range { start: Witness(5), end: Witness(7) },
-                Range { start: Witness(2), end: Witness(5) }
-            ]
-        );
-    }
-}
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 848d9987ca3..4030d017f2b 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -539,17 +539,9 @@ pub fn compile_no_check(
         info!("Program matches existing artifact, returning early");
         return Ok(cached_program.expect("cache must exist for hashes to match"));
     }
-    let visibility = program.return_visibility;
+    let return_visibility = program.return_visibility;
 
-    let SsaProgramArtifact {
-        program,
-        debug,
-        warnings,
-        main_input_witnesses,
-        main_return_witnesses,
-        names,
-        error_types,
-    } = create_program(
+    let SsaProgramArtifact { program, debug, warnings, names, error_types, .. } = create_program(
         program,
         options.show_ssa,
         options.show_brillig,
@@ -557,14 +549,7 @@ pub fn compile_no_check(
         options.benchmark_codegen,
     )?;
 
-    let abi = abi_gen::gen_abi(
-        context,
-        &main_function,
-        main_input_witnesses,
-        main_return_witnesses,
-        visibility,
-        error_types,
-    );
+    let abi = abi_gen::gen_abi(context, &main_function, return_visibility, error_types);
     let file_map = filter_relevant_files(&debug, &context.file_manager);
 
     Ok(CompiledProgram {
diff --git a/docs/docs/getting_started/tooling/noir_codegen.md b/docs/docs/getting_started/tooling/noir_codegen.md
index 1c040585340..f7505bef7ab 100644
--- a/docs/docs/getting_started/tooling/noir_codegen.md
+++ b/docs/docs/getting_started/tooling/noir_codegen.md
@@ -100,7 +100,8 @@ After the export and codegen steps, you should have an `index.ts` like:
 export type Field = string;
 
 
-export const is_equal_circuit: CompiledCircuit = {"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"},"return_witnesses":[4]},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
 
 export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
   const program = new Noir(is_equal_circuit);
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index ebcd9ff6569..086dddc27e5 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -205,11 +205,10 @@ fn debug_program_and_decode(
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
     let solved_witness = debug_program(&program, &inputs_map)?;
-    let public_abi = program.abi.public_abi();
 
     match solved_witness {
         Some(witness) => {
-            let (_, return_value) = public_abi.decode(&witness)?;
+            let (_, return_value) = program.abi.decode(&witness)?;
             Ok((return_value, Some(witness)))
         }
         None => Ok((None, None)),
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 5d6754b29f7..b548336275b 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -97,11 +97,10 @@ fn execute_program_and_decode(
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
     let witness_stack = execute_program(&program, &inputs_map, foreign_call_resolver_url)?;
-    let public_abi = program.abi.public_abi();
     // Get the entry point witness for the ABI
     let main_witness =
         &witness_stack.peek().expect("Should have at least one witness on the stack").witness;
-    let (_, return_value) = public_abi.decode(main_witness)?;
+    let (_, return_value) = program.abi.decode(main_witness)?;
 
     Ok((return_value, witness_stack))
 }
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 10fd14a0090..af3011068bf 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -34,7 +34,6 @@
     "generate:package": "bash ./fixup.sh",
     "build": "yarn clean && tsc && tsc -p ./tsconfig.cjs.json && yarn generate:package",
     "clean": "rm -rf ./lib",
-    "test": "mocha --timeout 25000 --exit --config ./.mocharc.json",
     "prettier": "prettier 'src/**/*.ts'",
     "prettier:fix": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
     "nightly:version": "jq --arg new_version \"-$(git rev-parse --short HEAD)$1\" '.version = .version + $new_version' package.json > package-tmp.json && mv package-tmp.json package.json",
@@ -49,10 +48,8 @@
   "devDependencies": {
     "@types/node": "^20.6.2",
     "@types/prettier": "^3",
-    "chai": "^4.4.1",
     "eslint": "^8.57.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "mocha": "^10.2.0",
     "prettier": "3.2.5",
     "ts-node": "^10.9.1",
     "typescript": "5.4.2"
diff --git a/tooling/noir_js_backend_barretenberg/src/index.ts b/tooling/noir_js_backend_barretenberg/src/index.ts
index f28abb9a658..cefef07520f 100644
--- a/tooling/noir_js_backend_barretenberg/src/index.ts
+++ b/tooling/noir_js_backend_barretenberg/src/index.ts
@@ -1,6 +1,5 @@
 export { BarretenbergBackend } from './backend.js';
 export { BarretenbergVerifier } from './verifier.js';
-export { publicInputsToWitnessMap } from './public_inputs.js';
 
 // typedoc exports
 export { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
diff --git a/tooling/noir_js_backend_barretenberg/src/public_inputs.ts b/tooling/noir_js_backend_barretenberg/src/public_inputs.ts
index 75ee0de6800..ed771ab0d34 100644
--- a/tooling/noir_js_backend_barretenberg/src/public_inputs.ts
+++ b/tooling/noir_js_backend_barretenberg/src/public_inputs.ts
@@ -1,4 +1,4 @@
-import { Abi, WitnessMap } from '@noir-lang/types';
+import { WitnessMap } from '@noir-lang/types';
 
 export function flattenPublicInputsAsArray(publicInputs: string[]): Uint8Array {
   const flattenedPublicInputs = publicInputs.map(hexToUint8Array);
@@ -23,30 +23,6 @@ export function witnessMapToPublicInputs(publicInputs: WitnessMap): string[] {
   return flattenedPublicInputs;
 }
 
-export function publicInputsToWitnessMap(publicInputs: string[], abi: Abi): WitnessMap {
-  const return_value_witnesses = abi.return_witnesses;
-  const public_parameters = abi.parameters.filter((param) => param.visibility === 'public');
-  const public_parameter_witnesses: number[] = public_parameters.flatMap((param) =>
-    abi.param_witnesses[param.name].flatMap((witness_range) =>
-      Array.from({ length: witness_range.end - witness_range.start }, (_, i) => witness_range.start + i),
-    ),
-  );
-
-  // We now have an array of witness indices which have been deduplicated and sorted in ascending order.
-  // The elements of this array should correspond to the elements of `flattenedPublicInputs` so that we can build up a `WitnessMap`.
-  const public_input_witnesses = [...new Set(public_parameter_witnesses.concat(return_value_witnesses))].sort(
-    (a, b) => a - b,
-  );
-
-  const witnessMap: WitnessMap = new Map();
-  public_input_witnesses.forEach((witness_index, index) => {
-    const witness_value = publicInputs[index];
-    witnessMap.set(witness_index, witness_value);
-  });
-
-  return witnessMap;
-}
-
 function flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {
   const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);
   const result = new Uint8Array(totalLength);
diff --git a/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts b/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts
deleted file mode 100644
index cfd43eff250..00000000000
--- a/tooling/noir_js_backend_barretenberg/test/public_input_deflattening.test.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { Abi } from '@noir-lang/types';
-import { expect } from 'chai';
-import { witnessMapToPublicInputs, publicInputsToWitnessMap } from '../src/public_inputs.js';
-
-const abi: Abi = {
-  parameters: [
-    {
-      name: 'array_with_returned_element',
-      type: {
-        kind: 'array',
-        type: {
-          kind: 'field',
-        },
-        length: 10,
-      },
-      visibility: 'private',
-    },
-    {
-      name: 'pub_field',
-      type: {
-        kind: 'field',
-      },
-      visibility: 'public',
-    },
-  ],
-  param_witnesses: {
-    array_with_returned_element: [
-      {
-        start: 1,
-        end: 11,
-      },
-    ],
-    pub_field: [
-      {
-        start: 11,
-        end: 12,
-      },
-    ],
-  },
-  return_type: {
-    abi_type: {
-      kind: 'tuple',
-      fields: [
-        {
-          kind: 'field',
-        },
-        {
-          kind: 'field',
-        },
-        {
-          kind: 'field',
-        },
-      ],
-    },
-    visibility: 'public',
-  },
-  return_witnesses: [2, 13, 13],
-  error_types: {},
-};
-
-it('flattens a witness map in order of its witness indices', async () => {
-  // Note that these are not in ascending order. This means that if we read from `witness_map` in insertion order
-  // then the witness values will be sorted incorrectly.
-  const public_input_indices = [2, 13, 11];
-
-  const witness_map = new Map(
-    public_input_indices.map((witness_index) => [
-      witness_index,
-      '0x' + BigInt(witness_index).toString(16).padStart(64, '0'),
-    ]),
-  );
-
-  const flattened_public_inputs = witnessMapToPublicInputs(witness_map);
-  expect(flattened_public_inputs).to.be.deep.eq([
-    '0x0000000000000000000000000000000000000000000000000000000000000002',
-    '0x000000000000000000000000000000000000000000000000000000000000000b',
-    '0x000000000000000000000000000000000000000000000000000000000000000d',
-  ]);
-});
-
-it('recovers the original witness map when deflattening a public input array', async () => {
-  // Note that these are not in ascending order. This means that if we read from `witness_map` in insertion order
-  // then the witness values will be sorted incorrectly.
-  const public_input_indices = [2, 13, 11];
-
-  const witness_map = new Map(
-    public_input_indices.map((witness_index) => [
-      witness_index,
-      '0x' + BigInt(witness_index).toString(16).padStart(64, '0'),
-    ]),
-  );
-
-  const flattened_public_inputs = witnessMapToPublicInputs(witness_map);
-  const deflattened_public_inputs = publicInputsToWitnessMap(flattened_public_inputs, abi);
-
-  expect(deflattened_public_inputs).to.be.deep.eq(witness_map);
-});
diff --git a/tooling/noir_js_types/src/types.ts b/tooling/noir_js_types/src/types.ts
index 0258f2f90c9..dd6548ddb6c 100644
--- a/tooling/noir_js_types/src/types.ts
+++ b/tooling/noir_js_types/src/types.ts
@@ -38,9 +38,7 @@ export type WitnessMap = Map<number, string>;
 
 export type Abi = {
   parameters: AbiParameter[];
-  param_witnesses: Record<string, { start: number; end: number }[]>;
   return_type: { abi_type: AbiType; visibility: Visibility } | null;
-  return_witnesses: number[];
   error_types: Record<string, AbiErrorType>;
 };
 
diff --git a/tooling/noirc_abi/src/input_parser/mod.rs b/tooling/noirc_abi/src/input_parser/mod.rs
index 14d92bc71b3..d7bbb0adfe3 100644
--- a/tooling/noirc_abi/src/input_parser/mod.rs
+++ b/tooling/noirc_abi/src/input_parser/mod.rs
@@ -267,9 +267,6 @@ mod serialization_tests {
                 abi_type: AbiType::String { length: 5 },
                 visibility: AbiVisibility::Public,
             }),
-            // These two fields are unused when serializing/deserializing to file.
-            param_witnesses: BTreeMap::new(),
-            return_witnesses: Vec::new(),
             error_types: Default::default(),
         };
 
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 134dd5e621e..2abb28e2538 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -20,7 +20,7 @@ use noirc_printable_type::{
     PrintableValueDisplay,
 };
 use serde::{Deserialize, Serialize};
-use std::{borrow::Borrow, ops::Range};
+use std::borrow::Borrow;
 use std::{collections::BTreeMap, str};
 // This is the ABI used to bridge the different TOML formats for the initial
 // witness, the partial witness generator and the interpreter.
@@ -267,11 +267,7 @@ pub struct AbiReturnType {
 pub struct Abi {
     /// An ordered list of the arguments to the program's `main` function, specifying their types and visibility.
     pub parameters: Vec<AbiParameter>,
-    /// A map from the ABI's parameters to the indices they are written to in the [`WitnessMap`].
-    /// This defines how to convert between the [`InputMap`] and [`WitnessMap`].
-    pub param_witnesses: BTreeMap<String, Vec<Range<Witness>>>,
     pub return_type: Option<AbiReturnType>,
-    pub return_witnesses: Vec<Witness>,
     pub error_types: BTreeMap<ErrorSelector, AbiErrorType>,
 }
 
@@ -307,25 +303,6 @@ impl Abi {
         map
     }
 
-    /// ABI with only the public parameters
-    #[must_use]
-    pub fn public_abi(self) -> Abi {
-        let parameters: Vec<_> =
-            self.parameters.into_iter().filter(|param| param.is_public()).collect();
-        let param_witnesses = self
-            .param_witnesses
-            .into_iter()
-            .filter(|(param_name, _)| parameters.iter().any(|param| &param.name == param_name))
-            .collect();
-        Abi {
-            parameters,
-            param_witnesses,
-            return_type: self.return_type,
-            return_witnesses: self.return_witnesses,
-            error_types: self.error_types,
-        }
-    }
-
     /// Encode a set of inputs as described in the ABI into a `WitnessMap`.
     pub fn encode(
         &self,
@@ -341,34 +318,21 @@ impl Abi {
         }
 
         // First encode each input separately, performing any input validation.
-        let encoded_input_map: BTreeMap<String, Vec<FieldElement>> = self
-            .to_btree_map()
-            .into_iter()
-            .map(|(param_name, expected_type)| {
+        let mut encoded_inputs: Vec<Vec<FieldElement>> = self
+            .parameters
+            .iter()
+            .map(|param| {
                 let value = input_map
-                    .get(&param_name)
-                    .ok_or_else(|| AbiError::MissingParam(param_name.clone()))?
+                    .get(&param.name)
+                    .ok_or_else(|| AbiError::MissingParam(param.name.clone()))?
                     .clone();
 
-                value.find_type_mismatch(&expected_type, param_name.clone())?;
+                value.find_type_mismatch(&param.typ, param.name.clone())?;
 
-                Self::encode_value(value, &expected_type).map(|v| (param_name, v))
+                Self::encode_value(value, &param.typ)
             })
             .collect::<Result<_, _>>()?;
 
-        // Write input field elements into witness indices specified in `self.param_witnesses`.
-        let mut witness_map: BTreeMap<Witness, FieldElement> = encoded_input_map
-            .iter()
-            .flat_map(|(param_name, encoded_param_fields)| {
-                let param_witness_indices = range_to_vec(&self.param_witnesses[param_name]);
-                param_witness_indices
-                    .iter()
-                    .zip(encoded_param_fields.iter())
-                    .map(|(&witness, &field_element)| (witness, field_element))
-                    .collect::<Vec<_>>()
-            })
-            .collect::<BTreeMap<Witness, FieldElement>>();
-
         // When encoding public inputs to be passed to the verifier, the user can must provide a return value
         // to be inserted into the witness map. This is not needed when generating a witness when proving the circuit.
         match (&self.return_type, return_value) {
@@ -380,18 +344,7 @@ impl Abi {
                     });
                 }
                 let encoded_return_fields = Self::encode_value(return_value, return_type)?;
-
-                // We need to be more careful when writing the return value's witness values.
-                // This is as it may share witness indices with other public inputs so we must check that when
-                // this occurs the witness values are consistent with each other.
-                self.return_witnesses.iter().zip(encoded_return_fields.iter()).try_for_each(
-                    |(&witness, &field_element)| match witness_map.insert(witness, field_element) {
-                        Some(existing_value) if existing_value != field_element => {
-                            Err(AbiError::InconsistentWitnessAssignment(witness))
-                        }
-                        _ => Ok(()),
-                    },
-                )?;
+                encoded_inputs.push(encoded_return_fields);
             }
             (None, Some(return_value)) => {
                 return Err(AbiError::UnexpectedReturnValue(return_value))
@@ -401,6 +354,14 @@ impl Abi {
             (_, None) => {}
         }
 
+        // Write input field elements into witness map.
+        let witness_map: BTreeMap<Witness, FieldElement> = encoded_inputs
+            .into_iter()
+            .flatten()
+            .enumerate()
+            .map(|(index, field_element)| (Witness(index as u32), field_element))
+            .collect::<BTreeMap<Witness, FieldElement>>();
+
         Ok(witness_map.into())
     }
 
@@ -441,18 +402,21 @@ impl Abi {
         &self,
         witness_map: &WitnessMap<FieldElement>,
     ) -> Result<(InputMap, Option<InputValue>), AbiError> {
+        let mut pointer: u32 = 0;
         let public_inputs_map =
             try_btree_map(self.parameters.clone(), |AbiParameter { name, typ, .. }| {
-                let param_witness_values =
-                    try_vecmap(range_to_vec(&self.param_witnesses[&name]), |witness_index| {
-                        witness_map
-                            .get(&witness_index)
-                            .ok_or_else(|| AbiError::MissingParamWitnessValue {
-                                name: name.clone(),
-                                witness_index,
-                            })
-                            .copied()
-                    })?;
+                let num_fields = typ.field_count();
+                let param_witness_values = try_vecmap(0..num_fields, |index| {
+                    let witness_index = Witness(pointer + index);
+                    witness_map
+                        .get(&witness_index)
+                        .ok_or_else(|| AbiError::MissingParamWitnessValue {
+                            name: name.clone(),
+                            witness_index,
+                        })
+                        .copied()
+                })?;
+                pointer += num_fields;
 
                 decode_value(&mut param_witness_values.into_iter(), &typ)
                     .map(|input_value| (name.clone(), input_value))
@@ -461,7 +425,8 @@ impl Abi {
         // We also attempt to decode the circuit's return value from `witness_map`.
         let return_value = if let Some(return_type) = &self.return_type {
             if let Ok(return_witness_values) =
-                try_vecmap(self.return_witnesses.clone(), |witness_index| {
+                try_vecmap(0..return_type.abi_type.field_count(), |index| {
+                    let witness_index = Witness(pointer + index);
                     witness_map
                         .get(&witness_index)
                         .ok_or_else(|| AbiError::MissingParamWitnessValue {
@@ -587,16 +552,6 @@ pub enum AbiValue {
     },
 }
 
-fn range_to_vec(ranges: &[Range<Witness>]) -> Vec<Witness> {
-    let mut result = Vec::new();
-    for range in ranges {
-        for witness in range.start.witness_index()..range.end.witness_index() {
-            result.push(witness.into());
-        }
-    }
-    result
-}
-
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(tag = "error_kind", rename_all = "lowercase")]
 pub enum AbiErrorType {
@@ -652,7 +607,7 @@ pub fn display_abi_error<F: AcirField>(
 mod test {
     use std::collections::BTreeMap;
 
-    use acvm::{acir::native_types::Witness, AcirField, FieldElement};
+    use acvm::{AcirField, FieldElement};
 
     use crate::{
         input_parser::InputValue, Abi, AbiParameter, AbiReturnType, AbiType, AbiVisibility,
@@ -674,16 +629,10 @@ mod test {
                     visibility: AbiVisibility::Public,
                 },
             ],
-            // Note that the return value shares a witness with `thing2`
-            param_witnesses: BTreeMap::from([
-                ("thing1".to_string(), vec![(Witness(1)..Witness(3))]),
-                ("thing2".to_string(), vec![(Witness(3)..Witness(4))]),
-            ]),
             return_type: Some(AbiReturnType {
                 abi_type: AbiType::Field,
                 visibility: AbiVisibility::Public,
             }),
-            return_witnesses: vec![Witness(3)],
             error_types: BTreeMap::default(),
         };
 
@@ -706,7 +655,6 @@ mod test {
             assert_eq!(reconstructed_inputs[&key], expected_value);
         }
 
-        // We also decode the return value (we can do this immediately as we know it shares a witness with an input).
-        assert_eq!(return_value.unwrap(), reconstructed_inputs["thing2"]);
+        assert!(return_value.is_none());
     }
 }
diff --git a/yarn.lock b/yarn.lock
index 8fb574afa30..a947ec56aba 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4400,11 +4400,9 @@ __metadata:
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3
-    chai: ^4.4.1
     eslint: ^8.57.0
     eslint-plugin-prettier: ^5.1.3
     fflate: ^0.8.0
-    mocha: ^10.2.0
     prettier: 3.2.5
     ts-node: ^10.9.1
     typescript: 5.4.2

From 95d0dd514ea7d66219a5c72e2307a2e9e878e421 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 10 Jun 2024 19:17:20 +0100
Subject: [PATCH 355/416] chore: inline `FieldElement.is_negative` and document
 (#5214)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5174

## Summary\*

This PR inlines `FieldElement.is_negative` into `FieldElement.to_i128`
so it can't be misused elsewhere while documenting the reasoning behind
it.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 acvm-repo/acir_field/src/field_element.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/acvm-repo/acir_field/src/field_element.rs b/acvm-repo/acir_field/src/field_element.rs
index 81582b9fbac..2c14aefee2a 100644
--- a/acvm-repo/acir_field/src/field_element.rs
+++ b/acvm-repo/acir_field/src/field_element.rs
@@ -174,10 +174,6 @@ impl<F: PrimeField> FieldElement<F> {
         self.0
     }
 
-    fn is_negative(&self) -> bool {
-        self.neg().num_bits() < self.num_bits()
-    }
-
     fn fits_in_u128(&self) -> bool {
         self.num_bits() <= 128
     }
@@ -278,7 +274,10 @@ impl<F: PrimeField> AcirField for FieldElement<F> {
     }
 
     fn to_i128(self) -> i128 {
-        let is_negative = self.is_negative();
+        // Negative integers are represented by the range [p + i128::MIN, p) whilst
+        // positive integers are represented by the range [0, i128::MAX).
+        // We can then differentiate positive from negative values by their MSB.
+        let is_negative = self.neg().num_bits() < self.num_bits();
         let bytes = if is_negative { self.neg() } else { self }.to_be_bytes();
         i128::from_be_bytes(bytes[16..32].try_into().unwrap()) * if is_negative { -1 } else { 1 }
     }

From ff7bb7287d70f2e854778553dbb8ca7e8a206ee2 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 11 Jun 2024 00:03:33 +0100
Subject: [PATCH 356/416] chore: add some property tests to ACVM crates (#5215)

# Description

## Problem\*

Related to #5173

## Summary\*

This PR adds some usage of the `proptest` crate into ACVM crates to
replace some smoke-tests which use hardcoded values.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |  5 +--
 Cargo.toml                                    |  1 +
 acvm-repo/acir_field/Cargo.toml               |  3 ++
 .../proptest-regressions/field_element.txt    |  7 +++
 acvm-repo/acir_field/src/field_element.rs     | 43 ++++++++++++-------
 acvm-repo/acvm/Cargo.toml                     |  5 +--
 acvm-repo/blackbox_solver/Cargo.toml          |  3 ++
 acvm-repo/blackbox_solver/src/logic.rs        | 32 +++++++++-----
 cspell.json                                   |  1 +
 9 files changed, 68 insertions(+), 32 deletions(-)
 create mode 100644 acvm-repo/acir_field/proptest-regressions/field_element.txt

diff --git a/Cargo.lock b/Cargo.lock
index 8e40315cdd7..3480a785d70 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -34,6 +34,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "hex",
  "num-bigint",
+ "proptest",
  "serde",
 ]
 
@@ -47,9 +48,6 @@ dependencies = [
  "brillig_vm",
  "indexmap 1.9.3",
  "num-bigint",
- "paste",
- "proptest",
- "rand 0.8.5",
  "serde",
  "thiserror",
  "tracing",
@@ -67,6 +65,7 @@ dependencies = [
  "libaes",
  "num-bigint",
  "p256",
+ "proptest",
  "sha2",
  "sha3",
  "thiserror",
diff --git a/Cargo.toml b/Cargo.toml
index d23089adb56..66a19bf7766 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -132,6 +132,7 @@ tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
 rand = "0.8.5"
+proptest = "1.2.0"
 
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index f182c6c4aba..15d8aafffef 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -23,6 +23,9 @@ ark-ff = { version = "^0.4.0", default-features = false }
 
 cfg-if = "1.0.0"
 
+[dev-dependencies]
+proptest.workspace = true
+
 [features]
 bn254 = []
 bls12_381 = ["dep:ark-bls12-381"]
diff --git a/acvm-repo/acir_field/proptest-regressions/field_element.txt b/acvm-repo/acir_field/proptest-regressions/field_element.txt
new file mode 100644
index 00000000000..79b3209d4f2
--- /dev/null
+++ b/acvm-repo/acir_field/proptest-regressions/field_element.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc c1b2755b427c874de3ee55c2969e8adc1b4b0331a28173e9e1e492b3fee6b7b7 # shrinks to hex = "3a0aaaa0aa0aaa00000aaaaaaaa0000a000aaa0a00a0000aa00a00aa0a000a0a"
diff --git a/acvm-repo/acir_field/src/field_element.rs b/acvm-repo/acir_field/src/field_element.rs
index 2c14aefee2a..3c16276adc9 100644
--- a/acvm-repo/acir_field/src/field_element.rs
+++ b/acvm-repo/acir_field/src/field_element.rs
@@ -425,6 +425,7 @@ fn superscript(n: u64) -> String {
 #[cfg(test)]
 mod tests {
     use super::{AcirField, FieldElement};
+    use proptest::prelude::*;
 
     #[test]
     fn serialize_fixed_test_vectors() {
@@ -442,24 +443,36 @@ mod tests {
         }
     }
 
-    #[test]
-    fn deserialize_even_and_odd_length_hex() {
-        // Test cases of (odd, even) length hex strings
-        let hex_strings =
-            vec![("0x0", "0x00"), ("0x1", "0x01"), ("0x002", "0x0002"), ("0x00003", "0x000003")];
-        for (i, case) in hex_strings.into_iter().enumerate() {
-            let i_field_element = FieldElement::<ark_bn254::Fr>::from(i as i128);
-            let odd_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.0).unwrap();
-            let even_field_element = FieldElement::<ark_bn254::Fr>::from_hex(case.1).unwrap();
-
-            assert_eq!(i_field_element, odd_field_element);
-            assert_eq!(odd_field_element, even_field_element);
-        }
-    }
-
     #[test]
     fn max_num_bits_smoke() {
         let max_num_bits_bn254 = FieldElement::<ark_bn254::Fr>::max_num_bits();
         assert_eq!(max_num_bits_bn254, 254);
     }
+
+    proptest! {
+        // This currently panics due to the fact that we allow inputs which are greater than the field modulus,
+        // automatically reducing them to fit within the canonical range.
+        #[test]
+        #[should_panic(expected = "serialized field element is not equal to input")]
+        fn recovers_original_hex_string(hex in "[0-9a-f]{64}") {
+            let fe: FieldElement::<ark_bn254::Fr> = FieldElement::from_hex(&hex).expect("should accept any 32 byte hex string");
+            let output_hex = fe.to_hex();
+
+            prop_assert_eq!(hex, output_hex, "serialized field element is not equal to input");
+        }
+
+        #[test]
+        fn accepts_odd_length_hex_strings(hex in "(?:0x)[0-9a-fA-F]+") {
+            // Here we inject a "0" immediately after the "0x" (if it exists) to construct an equivalent
+            // hex string with the opposite parity length.
+            let insert_index = if hex.starts_with("0x") { 2 } else { 0 };
+            let mut opposite_parity_string = hex.to_string();
+            opposite_parity_string.insert(insert_index, '0');
+
+            let fe_1: FieldElement::<ark_bn254::Fr> = FieldElement::from_hex(&hex).unwrap();
+            let fe_2: FieldElement::<ark_bn254::Fr> = FieldElement::from_hex(&opposite_parity_string).unwrap();
+
+            prop_assert_eq!(fe_1, fe_2, "equivalent hex strings with opposite parity deserialized to different values");
+        }
+    }
 }
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 0bd6ab6b7c7..59305ec49f0 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -37,7 +37,4 @@ bls12_381 = [
 ]
 
 [dev-dependencies]
-rand.workspace = true
-proptest = "1.2.0"
-paste = "1.0.14"
-ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
\ No newline at end of file
+ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index 00c87bbca74..dd7f84e63e4 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -39,6 +39,9 @@ p256 = { version = "0.11.0", features = [
 
 libaes = "0.7.0"
 
+[dev-dependencies]
+proptest.workspace = true
+
 [features]
 bn254 = ["acir/bn254"]
 bls12_381 = ["acir/bls12_381"]
diff --git a/acvm-repo/blackbox_solver/src/logic.rs b/acvm-repo/blackbox_solver/src/logic.rs
index 95bd3669ff5..6cccb521c20 100644
--- a/acvm-repo/blackbox_solver/src/logic.rs
+++ b/acvm-repo/blackbox_solver/src/logic.rs
@@ -68,20 +68,32 @@ fn mask_vector_le(bytes: &mut [u8], num_bits: usize) {
 
 #[cfg(test)]
 mod tests {
-    use acir::{AcirField, FieldElement};
+    use acir::FieldElement;
+    use proptest::prelude::*;
 
-    use crate::bit_and;
+    use crate::{bit_and, bit_xor};
 
-    #[test]
-    fn and() {
-        let max = 10_000u32;
+    proptest! {
+        #[test]
+        fn matches_bitwise_and_on_u128s(x in 0..=u128::MAX, y in 0..=u128::MAX, bit_size in 128u32..) {
+            let x_as_field = FieldElement::from(x);
+            let y_as_field = FieldElement::from(y);
 
-        let num_bits = (std::mem::size_of::<u32>() * 8) as u32 - max.leading_zeros();
+            let x_and_y = x & y;
+            let x_and_y_as_field = bit_and(x_as_field, y_as_field, bit_size);
 
-        for x in 0..max {
-            let x = FieldElement::from(x as i128);
-            let res = bit_and(x, x, num_bits);
-            assert_eq!(res.to_be_bytes(), x.to_be_bytes());
+            prop_assert_eq!(x_and_y_as_field, FieldElement::from(x_and_y), "AND on fields should match that on integers");
+        }
+
+        #[test]
+        fn matches_bitwise_xor_on_u128s(x in 0..=u128::MAX, y in 0..=u128::MAX, bit_size in 128u32..) {
+            let x_as_field = FieldElement::from(x);
+            let y_as_field = FieldElement::from(y);
+
+            let x_xor_y = x ^ y;
+            let x_xor_y_as_field = bit_xor(x_as_field, y_as_field, bit_size);
+
+            prop_assert_eq!(x_xor_y_as_field, FieldElement::from(x_xor_y), "XOR on fields should match that on integers");
         }
     }
 }
diff --git a/cspell.json b/cspell.json
index cea0dd7ed38..9eb6e6f9239 100644
--- a/cspell.json
+++ b/cspell.json
@@ -157,6 +157,7 @@
         "preprocess",
         "prettytable",
         "printstd",
+        "proptest",
         "pseudocode",
         "pubkey",
         "quantile",

From ff67e145d086bf6fdf58fb5e57927033e52e03d3 Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Tue, 11 Jun 2024 09:49:04 -0400
Subject: [PATCH 357/416] feat: Sync from aztec-packages (#5222)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
chore: add example for recursion on the CLI
(https://github.com/AztecProtocol/aztec-packages/pull/6389)
feat(nargo): hidden option to show contract artifact paths written by
`nargo compile`
(https://github.com/AztecProtocol/aztec-packages/pull/6131)
chore: add bench programs
(https://github.com/AztecProtocol/aztec-packages/pull/6566)
END_COMMIT_OVERRIDE

---------

Co-authored-by: TomAFrench <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .aztec-sync-commit                            |   2 +-
 acvm-repo/acvm_js/build.sh                    |   2 +-
 aztec_macros/src/transforms/functions.rs      |  34 ++++--
 .../test/node/prove_and_verify.test.ts        |  12 +--
 compiler/noirc_driver/src/lib.rs              |   4 +
 examples/recursion/.gitignore                 |   2 +
 examples/recursion/Nargo.toml                 |   2 +
 .../recursion/generate_recursive_proof.sh     |  61 +++++++++++
 examples/recursion/recurse_leaf/Nargo.toml    |   7 ++
 examples/recursion/recurse_leaf/src/main.nr   |  20 ++++
 examples/recursion/recurse_node/Nargo.toml    |   7 ++
 examples/recursion/recurse_node/src/main.nr   |  17 +++
 examples/recursion/sum/Nargo.toml             |   7 ++
 examples/recursion/sum/Prover.toml            |   2 +
 examples/recursion/sum/src/main.nr            |   4 +
 examples/recursion/test.sh                    |   8 ++
 .../bench_eddsa_poseidon/Nargo.toml           |   7 ++
 .../bench_eddsa_poseidon/Prover.toml          |   6 ++
 .../bench_eddsa_poseidon/src/main.nr          |  12 +++
 .../benchmarks/bench_poseidon_hash/Nargo.toml |   7 ++
 .../bench_poseidon_hash/Prover.toml           |   1 +
 .../bench_poseidon_hash/src/main.nr           |   5 +
 .../bench_poseidon_hash_100/Nargo.toml        |   7 ++
 .../bench_poseidon_hash_100/Prover.toml       | 102 ++++++++++++++++++
 .../bench_poseidon_hash_100/src/main.nr       |  12 +++
 .../bench_poseidon_hash_30/Nargo.toml         |   7 ++
 .../bench_poseidon_hash_30/Prover.toml        |  32 ++++++
 .../bench_poseidon_hash_30/src/main.nr        |  12 +++
 .../benchmarks/bench_sha256/Nargo.toml        |   7 ++
 .../benchmarks/bench_sha256/Prover.toml       |   1 +
 .../benchmarks/bench_sha256/src/main.nr       |   5 +
 .../benchmarks/bench_sha256_100/Nargo.toml    |   7 ++
 .../benchmarks/bench_sha256_100/Prover.toml   | 102 ++++++++++++++++++
 .../benchmarks/bench_sha256_100/src/main.nr   |  12 +++
 .../benchmarks/bench_sha256_30/Nargo.toml     |   7 ++
 .../benchmarks/bench_sha256_30/Prover.toml    |  32 ++++++
 .../benchmarks/bench_sha256_30/src/main.nr    |  12 +++
 test_programs/rebuild.sh                      |   7 ++
 tooling/debugger/src/context.rs               |   4 +-
 tooling/nargo_cli/src/cli/compile_cmd.rs      |  14 ++-
 40 files changed, 588 insertions(+), 23 deletions(-)
 create mode 100644 examples/recursion/.gitignore
 create mode 100644 examples/recursion/Nargo.toml
 create mode 100755 examples/recursion/generate_recursive_proof.sh
 create mode 100644 examples/recursion/recurse_leaf/Nargo.toml
 create mode 100644 examples/recursion/recurse_leaf/src/main.nr
 create mode 100644 examples/recursion/recurse_node/Nargo.toml
 create mode 100644 examples/recursion/recurse_node/src/main.nr
 create mode 100644 examples/recursion/sum/Nargo.toml
 create mode 100644 examples/recursion/sum/Prover.toml
 create mode 100644 examples/recursion/sum/src/main.nr
 create mode 100755 examples/recursion/test.sh
 create mode 100644 test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_eddsa_poseidon/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash/src/main.nr
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash_100/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash_100/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash_30/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash_30/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
 create mode 100644 test_programs/benchmarks/bench_sha256/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_sha256/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_sha256/src/main.nr
 create mode 100644 test_programs/benchmarks/bench_sha256_100/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_sha256_100/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_sha256_100/src/main.nr
 create mode 100644 test_programs/benchmarks/bench_sha256_30/Nargo.toml
 create mode 100644 test_programs/benchmarks/bench_sha256_30/Prover.toml
 create mode 100644 test_programs/benchmarks/bench_sha256_30/src/main.nr

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index fdbc14d511e..0bdea76121d 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-1d785fd1087d7387fc29213ca3be50b2fc9c4725
+86a33140f9a65e518003b3f4c60f97d132f85b89
diff --git a/acvm-repo/acvm_js/build.sh b/acvm-repo/acvm_js/build.sh
index ee93413ab85..16fb26e55db 100755
--- a/acvm-repo/acvm_js/build.sh
+++ b/acvm-repo/acvm_js/build.sh
@@ -25,7 +25,7 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-# require_command wasm-opt
+require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')
diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
index 0fb13975fec..4d8b6ef7cdf 100644
--- a/aztec_macros/src/transforms/functions.rs
+++ b/aztec_macros/src/transforms/functions.rs
@@ -216,12 +216,30 @@ pub fn export_fn_abi(
 ///
 /// Inserts the following code at the beginning of an unconstrained function
 /// ```noir
-/// let storage = Storage::init(Context::none());
+/// let context = UnconstrainedContext::new();
+/// let storage = Storage::init(context);
 /// ```
 ///
 /// This will allow developers to access their contract' storage struct in unconstrained functions
 pub fn transform_unconstrained(func: &mut NoirFunction, storage_struct_name: String) {
+    // let context = UnconstrainedContext::new();
+    let let_context = assignment(
+        "context", // Assigned to
+        call(
+            variable_path(chained_dep!(
+                "aztec",
+                "context",
+                "unconstrained_context",
+                "UnconstrainedContext",
+                "new"
+            )),
+            vec![],
+        ),
+    );
+
+    // We inject the statements at the beginning, in reverse order.
     func.def.body.statements.insert(0, abstract_storage(storage_struct_name, true));
+    func.def.body.statements.insert(0, let_context);
 }
 
 /// Helper function that returns what the private context would look like in the ast
@@ -597,7 +615,7 @@ fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>,
 /// ```noir
 /// #[aztec(private)]
 /// fn lol() {
-///     let storage = Storage::init(context);
+///     let storage = Storage::init(&mut context);
 /// }
 /// ```
 ///
@@ -605,22 +623,18 @@ fn abstract_return_values(func: &NoirFunction) -> Result<Option<Vec<Statement>>,
 /// ```noir
 /// #[aztec(public)]
 /// fn lol() {
-///    let storage = Storage::init(context);
+///    let storage = Storage::init(&mut context);
 /// }
 /// ```
 ///
 /// For unconstrained functions:
 /// ```noir
 /// unconstrained fn lol() {
-///   let storage = Storage::init(());
+///   let storage = Storage::init(context);
 /// }
 fn abstract_storage(storage_struct_name: String, unconstrained: bool) -> Statement {
-    let context_expr = if unconstrained {
-        // Note that the literal unit type (i.e. '()') is not the same as a tuple with zero elements
-        expression(ExpressionKind::Literal(Literal::Unit))
-    } else {
-        mutable_reference("context")
-    };
+    let context_expr =
+        if unconstrained { variable("context") } else { mutable_reference("context") };
 
     assignment(
         "storage", // Assigned to
diff --git a/compiler/integration-tests/test/node/prove_and_verify.test.ts b/compiler/integration-tests/test/node/prove_and_verify.test.ts
index 1cfe36f31e9..15d39436a3b 100644
--- a/compiler/integration-tests/test/node/prove_and_verify.test.ts
+++ b/compiler/integration-tests/test/node/prove_and_verify.test.ts
@@ -42,10 +42,10 @@ it('end-to-end proof creation and verification (outer) -- Verifier API', async (
   const { witness } = await program.execute(inputs);
 
   // Generate proof
-  const backend = new Backend(assert_lt_program);
-  const proof = await backend.generateProof(witness);
+  const prover = new Backend(assert_lt_program);
+  const proof = await prover.generateProof(witness);
 
-  const verificationKey = await backend.getVerificationKey();
+  const verificationKey = await prover.getVerificationKey();
 
   // Proof verification
   const verifier = new Verifier();
@@ -147,10 +147,10 @@ it('end-to-end proof creation and verification for multiple ACIR circuits (inner
   // bb.js part
   //
   // Proof creation
-  const backend = new Backend(fold_fibonacci_program);
-  const proof = await backend.generateProof(witness);
+  const prover = new Backend(fold_fibonacci_program);
+  const proof = await prover.generateProof(witness);
 
   // Proof verification
-  const isValid = await backend.verifyProof(proof);
+  const isValid = await prover.verifyProof(proof);
   expect(isValid).to.be.true;
 });
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 4030d017f2b..f8043a60f8c 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -102,6 +102,10 @@ pub struct CompileOptions {
     /// Enable the experimental elaborator pass
     #[arg(long, hide = true)]
     pub use_elaborator: bool,
+
+    /// Outputs the paths to any modified artifacts
+    #[arg(long, hide = true)]
+    pub show_artifact_paths: bool,
 }
 
 fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
diff --git a/examples/recursion/.gitignore b/examples/recursion/.gitignore
new file mode 100644
index 00000000000..12587094b0f
--- /dev/null
+++ b/examples/recursion/.gitignore
@@ -0,0 +1,2 @@
+recurse_leaf/Prover.toml
+recurse_node/Prover.toml
\ No newline at end of file
diff --git a/examples/recursion/Nargo.toml b/examples/recursion/Nargo.toml
new file mode 100644
index 00000000000..7c7a8b1926f
--- /dev/null
+++ b/examples/recursion/Nargo.toml
@@ -0,0 +1,2 @@
+[workspace]
+members = ["recurse_leaf", "recurse_node", "sum"]
diff --git a/examples/recursion/generate_recursive_proof.sh b/examples/recursion/generate_recursive_proof.sh
new file mode 100755
index 00000000000..362512529d4
--- /dev/null
+++ b/examples/recursion/generate_recursive_proof.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+set -eu
+
+BACKEND=${BACKEND:-bb}
+
+nargo execute sum_witness --package sum
+$BACKEND prove -b ./target/sum.json -w ./target/sum_witness.gz -o ./target/sum_proof
+
+# Once we have generated our inner proof, we must use this to generate inputs to `recurse_leaf``
+
+$BACKEND write_vk -b ./target/sum.json -o ./target/sum_key
+$BACKEND vk_as_fields -k ./target/sum_key -o ./target/sum_vk_as_fields
+VK_HASH=$(jq -r '.[0]' ./target/sum_vk_as_fields)
+VK_AS_FIELDS=$(jq -r '.[1:]' ./target/sum_vk_as_fields) 
+
+FULL_PROOF_AS_FIELDS="$($BACKEND proof_as_fields -p ./target/sum_proof -k ./target/sum_key -o -)"
+# sum has 3 public inputs
+PUBLIC_INPUTS=$(echo $FULL_PROOF_AS_FIELDS | jq -r '.[:3]')
+PROOF_AS_FIELDS=$(echo $FULL_PROOF_AS_FIELDS | jq -r '.[3:]')
+
+RECURSE_LEAF_PROVER_TOML=./recurse_leaf/Prover.toml
+echo "num = 2" > $RECURSE_LEAF_PROVER_TOML
+echo "key_hash = \"$VK_HASH\"" >> $RECURSE_LEAF_PROVER_TOML
+echo "verification_key = $VK_AS_FIELDS"  >> $RECURSE_LEAF_PROVER_TOML
+echo "proof = $PROOF_AS_FIELDS" >> $RECURSE_LEAF_PROVER_TOML
+echo "public_inputs = $PUBLIC_INPUTS" >> $RECURSE_LEAF_PROVER_TOML
+
+# We can now execute and prove `recurse_leaf`
+
+nargo execute recurse_leaf_witness --package recurse_leaf
+$BACKEND prove -b ./target/recurse_leaf.json -w ./target/recurse_leaf_witness.gz -o ./target/recurse_leaf_proof
+
+# Let's do a sanity check that the proof we've generated so far is valid.
+$BACKEND write_vk -b ./target/recurse_leaf.json -o ./target/recurse_leaf_key
+$BACKEND verify -p ./target/recurse_leaf_proof -k ./target/recurse_leaf_key
+
+# Now we generate the final `recurse_node` proof similarly to how we did for `recurse_leaf`.
+
+$BACKEND vk_as_fields -k ./target/recurse_leaf_key -o ./target/recurse_leaf_vk_as_fields
+VK_HASH=$(jq -r '.[0]' ./target/recurse_leaf_vk_as_fields)
+VK_AS_FIELDS=$(jq -r '.[1:]' ./target/recurse_leaf_vk_as_fields) 
+
+FULL_PROOF_AS_FIELDS="$($BACKEND proof_as_fields -p ./target/recurse_leaf_proof -k ./target/recurse_leaf_key -o -)"
+# recurse_leaf has 4 public inputs (excluding aggregation object)
+PUBLIC_INPUTS=$(echo $FULL_PROOF_AS_FIELDS | jq -r '.[:4]')
+PROOF_AS_FIELDS=$(echo $FULL_PROOF_AS_FIELDS | jq -r '.[4:]')
+
+RECURSE_NODE_PROVER_TOML=./recurse_node/Prover.toml
+echo "key_hash = \"$VK_HASH\"" > $RECURSE_NODE_PROVER_TOML
+echo "verification_key = $VK_AS_FIELDS"  >> $RECURSE_NODE_PROVER_TOML
+echo "proof = $PROOF_AS_FIELDS" >> $RECURSE_NODE_PROVER_TOML
+echo "public_inputs = $PUBLIC_INPUTS" >> $RECURSE_NODE_PROVER_TOML
+
+# We can now execute and prove `recurse_node`
+
+nargo execute recurse_node_witness --package recurse_node
+$BACKEND prove -b ./target/recurse_node.json -w ./target/recurse_node_witness.gz -o ./target/recurse_node_proof
+
+# We finally verify that the generated recursive proof is valid.
+$BACKEND write_vk -b ./target/recurse_node.json -o ./target/recurse_node_key
+$BACKEND verify -p ./target/recurse_node_proof -k ./target/recurse_node_key
diff --git a/examples/recursion/recurse_leaf/Nargo.toml b/examples/recursion/recurse_leaf/Nargo.toml
new file mode 100644
index 00000000000..7af9cd74940
--- /dev/null
+++ b/examples/recursion/recurse_leaf/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "recurse_leaf"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/examples/recursion/recurse_leaf/src/main.nr b/examples/recursion/recurse_leaf/src/main.nr
new file mode 100644
index 00000000000..b6a2b49b219
--- /dev/null
+++ b/examples/recursion/recurse_leaf/src/main.nr
@@ -0,0 +1,20 @@
+use dep::std;
+
+#[recursive]
+fn main(
+    verification_key: [Field; 114],
+    public_inputs: pub [Field; 3],
+    key_hash: Field,
+    proof: [Field; 93],
+    num: u64
+) -> pub u64 {
+    // verify sum so far was computed correctly
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+    // Take output of previous proof and add another number to it.
+    public_inputs[2] as u64 + num
+}
\ No newline at end of file
diff --git a/examples/recursion/recurse_node/Nargo.toml b/examples/recursion/recurse_node/Nargo.toml
new file mode 100644
index 00000000000..db4b3b77693
--- /dev/null
+++ b/examples/recursion/recurse_node/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "recurse_node"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/examples/recursion/recurse_node/src/main.nr b/examples/recursion/recurse_node/src/main.nr
new file mode 100644
index 00000000000..7c983dcf050
--- /dev/null
+++ b/examples/recursion/recurse_node/src/main.nr
@@ -0,0 +1,17 @@
+use dep::std;
+
+fn main(
+    verification_key: [Field; 114],
+    public_inputs: pub [Field; 4],
+    key_hash: Field,
+    proof: [Field; 109]
+) -> pub u64 {
+    // verify sum was computed correctly
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+    public_inputs[3] as u64
+}
\ No newline at end of file
diff --git a/examples/recursion/sum/Nargo.toml b/examples/recursion/sum/Nargo.toml
new file mode 100644
index 00000000000..7a5f1498c3e
--- /dev/null
+++ b/examples/recursion/sum/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "sum"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.26.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/examples/recursion/sum/Prover.toml b/examples/recursion/sum/Prover.toml
new file mode 100644
index 00000000000..eae66cb8593
--- /dev/null
+++ b/examples/recursion/sum/Prover.toml
@@ -0,0 +1,2 @@
+a = 1
+b = 2
\ No newline at end of file
diff --git a/examples/recursion/sum/src/main.nr b/examples/recursion/sum/src/main.nr
new file mode 100644
index 00000000000..722d941d57d
--- /dev/null
+++ b/examples/recursion/sum/src/main.nr
@@ -0,0 +1,4 @@
+#[recursive]
+fn main(a: pub u64, b: pub u64) -> pub u64 {
+    a + b
+}
\ No newline at end of file
diff --git a/examples/recursion/test.sh b/examples/recursion/test.sh
new file mode 100755
index 00000000000..1e9eca35cab
--- /dev/null
+++ b/examples/recursion/test.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -eu
+
+# This file is used for Noir CI and is not required.
+
+BACKEND=${BACKEND:-bb}
+
+./generate_recursive_proof.sh
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml b/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml
new file mode 100644
index 00000000000..bc2a779f7b2
--- /dev/null
+++ b/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_eddsa_poseidon"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_eddsa_poseidon/Prover.toml b/test_programs/benchmarks/bench_eddsa_poseidon/Prover.toml
new file mode 100644
index 00000000000..8cfb63cd80e
--- /dev/null
+++ b/test_programs/benchmarks/bench_eddsa_poseidon/Prover.toml
@@ -0,0 +1,6 @@
+msg = 789
+pub_key_x = "0x16b051f37589e0dcf4ad3c415c090798c10d3095bedeedabfcc709ad787f3507"
+pub_key_y = "0x062800ac9e60839fab9218e5ed9d541f4586e41275f4071816a975895d349a5e"
+r8_x = "0x163814666f04c4d2969059a6b63ee26a0f9f0f81bd5957b0796e2e8f4a8a2f06"
+r8_y = "0x1255b17d9e4bfb81831625b788f8a1665128079ac4b6c8c3cd1b857666a05a54"
+s = "1230930278088778318663840827871215383007447616379808164955640681455510074924"
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr b/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
new file mode 100644
index 00000000000..31c2f1f2d13
--- /dev/null
+++ b/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
@@ -0,0 +1,12 @@
+use dep::std::eddsa::{eddsa_poseidon_verify};
+
+fn main(
+    msg: pub Field,
+    pub_key_x: Field,
+    pub_key_y: Field,
+    r8_x: Field,
+    r8_y: Field,
+    s: Field
+) -> pub bool {
+    eddsa_poseidon_verify(pub_key_x, pub_key_y, s, r8_x, r8_y, msg)
+}
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_poseidon_hash/Nargo.toml b/test_programs/benchmarks/bench_poseidon_hash/Nargo.toml
new file mode 100644
index 00000000000..9024d9a7301
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_poseidon_hash"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_poseidon_hash/Prover.toml b/test_programs/benchmarks/bench_poseidon_hash/Prover.toml
new file mode 100644
index 00000000000..66779dea9d7
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash/Prover.toml
@@ -0,0 +1 @@
+input = [1,2]
diff --git a/test_programs/benchmarks/bench_poseidon_hash/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash/src/main.nr
new file mode 100644
index 00000000000..38adeef6ec7
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash/src/main.nr
@@ -0,0 +1,5 @@
+use dep::std::hash::poseidon;
+
+fn main(input: [Field; 2]) -> pub Field {
+    poseidon::bn254::hash_2(input)
+}
diff --git a/test_programs/benchmarks/bench_poseidon_hash_100/Nargo.toml b/test_programs/benchmarks/bench_poseidon_hash_100/Nargo.toml
new file mode 100644
index 00000000000..b23716b2a20
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash_100/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_poseidon_hash_100"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_poseidon_hash_100/Prover.toml b/test_programs/benchmarks/bench_poseidon_hash_100/Prover.toml
new file mode 100644
index 00000000000..542b4a08dd6
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash_100/Prover.toml
@@ -0,0 +1,102 @@
+input = [
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+]
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
new file mode 100644
index 00000000000..fc9a5b7a970
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
@@ -0,0 +1,12 @@
+use dep::std::hash;
+
+global SIZE = 100;
+
+fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
+    let mut results: [Field; SIZE] = [0; SIZE];
+    for i in 0..SIZE {
+        results[i] = hash::poseidon::bn254::hash_2(input[i]);
+    }
+
+    results
+}
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_poseidon_hash_30/Nargo.toml b/test_programs/benchmarks/bench_poseidon_hash_30/Nargo.toml
new file mode 100644
index 00000000000..dbcbc07b1ba
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash_30/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_poseidon_hash_30"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_poseidon_hash_30/Prover.toml b/test_programs/benchmarks/bench_poseidon_hash_30/Prover.toml
new file mode 100644
index 00000000000..7792a9ab8e3
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash_30/Prover.toml
@@ -0,0 +1,32 @@
+input = [
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+]
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
new file mode 100644
index 00000000000..4d2d94e4946
--- /dev/null
+++ b/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
@@ -0,0 +1,12 @@
+use dep::std::hash;
+
+global SIZE = 30;
+
+fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
+    let mut results: [Field; SIZE] = [0; SIZE];
+    for i in 0..SIZE {
+        results[i] = hash::poseidon::bn254::hash_2(input[i]);
+    }
+
+    results
+}
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_sha256/Nargo.toml b/test_programs/benchmarks/bench_sha256/Nargo.toml
new file mode 100644
index 00000000000..488b94ca858
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_sha256"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_sha256/Prover.toml b/test_programs/benchmarks/bench_sha256/Prover.toml
new file mode 100644
index 00000000000..66779dea9d7
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256/Prover.toml
@@ -0,0 +1 @@
+input = [1,2]
diff --git a/test_programs/benchmarks/bench_sha256/src/main.nr b/test_programs/benchmarks/bench_sha256/src/main.nr
new file mode 100644
index 00000000000..fc873fb4afb
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256/src/main.nr
@@ -0,0 +1,5 @@
+use dep::std;
+
+fn main(input: [u8; 2]) -> pub [u8; 32] {
+    std::hash::sha256(input)
+}
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_sha256_100/Nargo.toml b/test_programs/benchmarks/bench_sha256_100/Nargo.toml
new file mode 100644
index 00000000000..d0c90d75088
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_100/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_sha256_100"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_sha256_100/Prover.toml b/test_programs/benchmarks/bench_sha256_100/Prover.toml
new file mode 100644
index 00000000000..542b4a08dd6
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_100/Prover.toml
@@ -0,0 +1,102 @@
+input = [
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+]
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_sha256_100/src/main.nr b/test_programs/benchmarks/bench_sha256_100/src/main.nr
new file mode 100644
index 00000000000..d78ca8002d2
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_100/src/main.nr
@@ -0,0 +1,12 @@
+use dep::std;
+
+global SIZE = 100;
+
+fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
+    let mut results: [[u8; 32]; SIZE] = [[0; 32]; SIZE];
+    for i in 0..SIZE {
+        results[i] = std::hash::sha256(input[i]);
+    }
+
+    results
+}
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_sha256_30/Nargo.toml b/test_programs/benchmarks/bench_sha256_30/Nargo.toml
new file mode 100644
index 00000000000..c1dc76df394
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_30/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_sha256_30"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_sha256_30/Prover.toml b/test_programs/benchmarks/bench_sha256_30/Prover.toml
new file mode 100644
index 00000000000..7792a9ab8e3
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_30/Prover.toml
@@ -0,0 +1,32 @@
+input = [
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+    [1,2],
+]
\ No newline at end of file
diff --git a/test_programs/benchmarks/bench_sha256_30/src/main.nr b/test_programs/benchmarks/bench_sha256_30/src/main.nr
new file mode 100644
index 00000000000..fa66d626586
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_30/src/main.nr
@@ -0,0 +1,12 @@
+use dep::std;
+
+global SIZE = 30;
+
+fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
+    let mut results: [[u8; 32]; SIZE] = [[0; 32]; SIZE];
+    for i in 0..SIZE {
+        results[i] = std::hash::sha256(input[i]);
+    }
+
+    results
+}
\ No newline at end of file
diff --git a/test_programs/rebuild.sh b/test_programs/rebuild.sh
index cfc6479febf..2d4147cb08c 100755
--- a/test_programs/rebuild.sh
+++ b/test_programs/rebuild.sh
@@ -55,6 +55,13 @@ for dir in $base_path/*; do
     dirs_to_process+=("$dir")
 done
 
+for dir in $current_dir/benchmarks/*; do
+    if [[ ! -d $dir ]]; then
+        continue
+    fi
+    dirs_to_process+=("$dir")
+done
+
 # Process each directory in parallel
 pids=()
 if [ -z $NO_PARALLEL ]; then
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 5d0916b4863..4436ce0ec3d 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -296,7 +296,7 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 self.handle_foreign_call(foreign_call)
             }
             Err(err) => DebugCommandResult::Error(NargoError::ExecutionError(
-                // TODO: debugger does not not handle multiple acir calls
+                // TODO: debugger does not handle multiple acir calls
                 ExecutionError::SolvingError(err, None),
             )),
         }
@@ -340,7 +340,7 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 }
             }
             ACVMStatus::Failure(error) => DebugCommandResult::Error(NargoError::ExecutionError(
-                // TODO: debugger does not not handle multiple acir calls
+                // TODO: debugger does not handle multiple acir calls
                 ExecutionError::SolvingError(error, None),
             )),
             ACVMStatus::RequiresForeignCall(_) => {
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index ecf2e2e9f53..bd76cf24805 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -142,7 +142,7 @@ pub(super) fn compile_workspace_full(
     let circuit_dir = workspace.target_directory_path();
     for (package, contract) in contract_packages.into_iter().zip(compiled_contracts) {
         let contract = nargo::ops::transform_contract(contract, compile_options.expression_width);
-        save_contract(contract, &package, &circuit_dir);
+        save_contract(contract, &package, &circuit_dir, compile_options.show_artifact_paths);
     }
 
     Ok(())
@@ -200,11 +200,19 @@ pub(super) fn save_program(program: CompiledProgram, package: &Package, circuit_
     save_program_to_file(&program_artifact, &package.name, circuit_dir);
 }
 
-fn save_contract(contract: CompiledContract, package: &Package, circuit_dir: &Path) {
+fn save_contract(
+    contract: CompiledContract,
+    package: &Package,
+    circuit_dir: &Path,
+    show_artifact_paths: bool,
+) {
     let contract_name = contract.name.clone();
-    save_contract_to_file(
+    let artifact_path = save_contract_to_file(
         &contract.into(),
         &format!("{}-{}", package.name, contract_name),
         circuit_dir,
     );
+    if show_artifact_paths {
+        println!("Saved contract artifact to: {}", artifact_path.display());
+    }
 }

From 1d62c59a8f02f7d277c5bf9ed637348a3b2f399c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 11 Jun 2024 15:55:07 +0100
Subject: [PATCH 358/416] chore!: remove `distinct` keyword (#5219)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR removes the `distinct` keyword and any traces of distinctiveness
from the codebase as they have been deprecated for a couple of releases.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/ast/mod.rs        | 23 -------------------
 .../src/hir/resolution/errors.rs              | 14 -----------
 compiler/noirc_frontend/src/lexer/token.rs    |  3 ---
 .../noirc_frontend/src/noir_parser.lalrpop    |  1 -
 compiler/noirc_frontend/src/parser/errors.rs  |  2 --
 .../src/parser/parser/function.rs             | 23 +++----------------
 tooling/noirc_abi/src/lib.rs                  | 15 ------------
 7 files changed, 3 insertions(+), 78 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 39b23228967..bd2b45d9c48 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -390,26 +390,3 @@ impl std::fmt::Display for Visibility {
         }
     }
 }
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-/// Represents whether the return value should compromise of unique witness indices such that no
-/// index occurs within the program's abi more than once.
-///
-/// This is useful for application stacks that require an uniform abi across across multiple
-/// circuits. When index duplication is allowed, the compiler may identify that a public input
-/// reaches the output unaltered and is thus referenced directly, causing the input and output
-/// witness indices to overlap. Similarly, repetitions of copied values in the output may be
-/// optimized away.
-pub enum Distinctness {
-    Distinct,
-    DuplicationAllowed,
-}
-
-impl std::fmt::Display for Distinctness {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Distinct => write!(f, "distinct"),
-            Self::DuplicationAllowed => write!(f, "duplication-allowed"),
-        }
-    }
-}
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index d6dd1c2cd54..06f6dda7142 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -40,8 +40,6 @@ pub enum ResolverError {
     UnnecessaryPub { ident: Ident, position: PubPosition },
     #[error("Required 'pub', main function must return public value")]
     NecessaryPub { ident: Ident },
-    #[error("'distinct' keyword can only be used with main method")]
-    DistinctNotAllowed { ident: Ident },
     #[error("Missing expression for declared constant")]
     MissingRhsExpr { name: String, span: Span },
     #[error("Expression invalid in an array length context")]
@@ -220,18 +218,6 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diag.add_note("The `pub` keyword is mandatory for the entry-point function return type because the verifier cannot retrieve private witness and thus the function will not be able to return a 'priv' value".to_owned());
                 diag
             }
-            ResolverError::DistinctNotAllowed { ident } => {
-                let name = &ident.0.contents;
-
-                let mut diag = Diagnostic::simple_error(
-                    format!("Invalid `distinct` keyword on return type of function {name}"),
-                    "Invalid distinct on return type".to_string(),
-                    ident.0.span(),
-                );
-
-                diag.add_note("The `distinct` keyword is only valid when used on the main function of a program, as its only purpose is to ensure that all witness indices that occur in the abi are unique".to_owned());
-                diag
-            }
             ResolverError::MissingRhsExpr { name, span } => Diagnostic::simple_error(
                 format!(
                     "no expression specifying the value stored by the constant variable {name}"
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 950697c2536..d8555b4fbf7 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -839,7 +839,6 @@ pub enum Keyword {
     Contract,
     Crate,
     Dep,
-    Distinct,
     Else,
     Field,
     Fn,
@@ -884,7 +883,6 @@ impl fmt::Display for Keyword {
             Keyword::Contract => write!(f, "contract"),
             Keyword::Crate => write!(f, "crate"),
             Keyword::Dep => write!(f, "dep"),
-            Keyword::Distinct => write!(f, "distinct"),
             Keyword::Else => write!(f, "else"),
             Keyword::Field => write!(f, "Field"),
             Keyword::Fn => write!(f, "fn"),
@@ -932,7 +930,6 @@ impl Keyword {
             "contract" => Keyword::Contract,
             "crate" => Keyword::Crate,
             "dep" => Keyword::Dep,
-            "distinct" => Keyword::Distinct,
             "else" => Keyword::Else,
             "Field" => Keyword::Field,
             "fn" => Keyword::Fn,
diff --git a/compiler/noirc_frontend/src/noir_parser.lalrpop b/compiler/noirc_frontend/src/noir_parser.lalrpop
index 9acb5ef8b58..c6cb788a5a4 100644
--- a/compiler/noirc_frontend/src/noir_parser.lalrpop
+++ b/compiler/noirc_frontend/src/noir_parser.lalrpop
@@ -67,7 +67,6 @@ extern {
         "contract" => BorrowedToken::Keyword(noir_token::Keyword::Contract),
         "crate" => BorrowedToken::Keyword(noir_token::Keyword::Crate),
         "dep" => BorrowedToken::Keyword(noir_token::Keyword::Dep),
-        "distinct" => BorrowedToken::Keyword(noir_token::Keyword::Distinct),
         "else" => BorrowedToken::Keyword(noir_token::Keyword::Else),
         "Field" => BorrowedToken::Keyword(noir_token::Keyword::Field),
         "fn" => BorrowedToken::Keyword(noir_token::Keyword::Fn),
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index 9f9a8200954..af3d4caa145 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -30,8 +30,6 @@ pub enum ParserErrorReason {
     TraitImplFunctionModifiers,
     #[error("comptime keyword is deprecated")]
     ComptimeDeprecated,
-    #[error("distinct keyword is deprecated. The `distinct` behavior is now the default.")]
-    DistinctDeprecated,
     #[error("{0} are experimental and aren't fully supported yet")]
     ExperimentalFeature(&'static str),
     #[error(
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 40180a9f9ac..4db5637f6a7 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -4,16 +4,12 @@ use super::{
     parameter_name_recovery, parameter_recovery, parenthesized, parse_type, pattern,
     self_parameter, where_clause, NoirParser,
 };
+use crate::ast::{
+    FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction, Param, Visibility,
+};
 use crate::parser::labels::ParsingRuleLabel;
 use crate::parser::spanned;
 use crate::token::{Keyword, Token};
-use crate::{
-    ast::{
-        FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction, Param,
-        Visibility,
-    },
-    parser::{ParserError, ParserErrorReason},
-};
 
 use chumsky::prelude::*;
 
@@ -95,20 +91,9 @@ pub(super) fn generics() -> impl NoirParser<Vec<Ident>> {
         .map(|opt| opt.unwrap_or_default())
 }
 
-#[deprecated = "Distinct keyword is now deprecated. Remove this function after the 0.30.0 release"]
-fn optional_distinctness() -> impl NoirParser<bool> {
-    keyword(Keyword::Distinct).or_not().validate(|opt, span, emit| {
-        if opt.is_some() {
-            emit(ParserError::with_reason(ParserErrorReason::DistinctDeprecated, span));
-        }
-        opt.is_some()
-    })
-}
-
 pub(super) fn function_return_type() -> impl NoirParser<(Visibility, FunctionReturnType)> {
     #[allow(deprecated)]
     just(Token::Arrow)
-        .ignore_then(optional_distinctness())
         .ignore_then(optional_visibility())
         .then(spanned(parse_type()))
         .or_not()
@@ -224,8 +209,6 @@ mod test {
                 // A leading plus is not allowed.
                 "fn func_name<T>(f: Field, y : T) where T: + SomeTrait {}",
                 "fn func_name<T>(f: Field, y : T) where T: TraitX + <Y> {}",
-                // `distinct` is deprecated
-                "fn main(x: pub u8, y: pub u8) -> distinct pub [u8; 2] { [x, y] }",
             ],
         );
     }
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 2abb28e2538..514fac2e73d 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -107,21 +107,6 @@ impl From<&Visibility> for AbiVisibility {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-/// Represents whether the return value should compromise of unique witness indices such that no
-/// index occurs within the program's abi more than once.
-///
-/// This is useful for application stacks that require an uniform abi across across multiple
-/// circuits. When index duplication is allowed, the compiler may identify that a public input
-/// reaches the output unaltered and is thus referenced directly, causing the input and output
-/// witness indices to overlap. Similarly, repetitions of copied values in the output may be
-/// optimized away.
-pub enum AbiDistinctness {
-    Distinct,
-    DuplicationAllowed,
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum Sign {

From 2e543b40eb83ef2080e4d8f870f525fadd631099 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 11 Jun 2024 16:31:43 +0100
Subject: [PATCH 359/416] chore: avoid `bn254_blackbox_solver` polluting
 feature flags (#5141)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Depending on `bn254_blackbox_solver` results in the `bn254` feature flag
being applied to the `acir` crate. This is unnecessary as we can just
have this crate use a `GenericFieldElement` and construct it as a BN254
field.

This simplifies the lives of people attempting to use Noir with an
alternative field choice.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                         |  1 +
 Cargo.toml                                         |  8 ++++++++
 acvm-repo/acir_field/Cargo.toml                    |  6 +++---
 acvm-repo/bn254_blackbox_solver/Cargo.toml         | 14 +++++---------
 .../src/embedded_curve_ops.rs                      |  3 ++-
 acvm-repo/bn254_blackbox_solver/src/lib.rs         |  5 ++++-
 .../src/pedersen/commitment.rs                     |  3 ++-
 .../bn254_blackbox_solver/src/pedersen/hash.rs     |  3 ++-
 acvm-repo/bn254_blackbox_solver/src/poseidon2.rs   |  8 +++++---
 acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs |  3 ++-
 10 files changed, 34 insertions(+), 20 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3480a785d70..bd575d0dca2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -574,6 +574,7 @@ version = "0.46.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
+ "ark-bn254",
  "ark-ec",
  "ark-ff",
  "ark-std",
diff --git a/Cargo.toml b/Cargo.toml
index 66a19bf7766..c08e9f9f38b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -77,6 +77,14 @@ noirc_abi = { path = "tooling/noirc_abi" }
 bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" }
 acvm_cli = { path = "tooling/acvm_cli" }
 
+# Arkworks
+ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
+ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
+grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
+ark-ec = { version = "^0.4.0", default-features = false }
+ark-ff = { version = "^0.4.0", default-features = false }
+ark-std = { version = "^0.4.0", default-features = false }
+
 # Misc utils crates
 iter-extended = { path = "utils/iter-extended" }
 
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 15d8aafffef..801935c90f9 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -17,9 +17,9 @@ hex.workspace = true
 num-bigint.workspace = true
 serde.workspace = true
 
-ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
-ark-bls12-381 = { version = "^0.4.0", optional = true, default-features = false, features = ["curve"] }
-ark-ff = { version = "^0.4.0", default-features = false }
+ark-bn254.workspace = true
+ark-bls12-381 = { workspace = true, optional = true }
+ark-ff.workspace = true
 
 cfg-if = "1.0.0"
 
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 132dddd50e5..37d40de71a9 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -18,14 +18,14 @@ acvm_blackbox_solver.workspace = true
 hex.workspace = true
 lazy_static = "1.4"
 
-# BN254 fixed base scalar multiplication solver
-grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
-ark-ec = { version = "^0.4.0", default-features = false }
-ark-ff = { version = "^0.4.0", default-features = false }
+ark-bn254.workspace = true
+grumpkin.workspace = true 
+ark-ec.workspace = true
+ark-ff.workspace = true
 num-bigint.workspace = true
 
 [dev-dependencies]
-ark-std = { version = "^0.4.0", default-features = false }
+ark-std.workspace = true
 criterion = "0.5.0"
 pprof = { version = "0.12", features = [
     "flamegraph",
@@ -36,7 +36,3 @@ pprof = { version = "0.12", features = [
 [[bench]]
 name = "criterion"
 harness = false
-
-[features]
-default = ["bn254"]
-bn254 = ["acir/bn254"]
diff --git a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
index 148accd8b23..35cc68051d7 100644
--- a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
@@ -3,8 +3,9 @@ use ark_ec::AffineRepr;
 use ark_ff::MontConfig;
 use num_bigint::BigUint;
 
+use crate::FieldElement;
+use acir::AcirField;
 use acir::BlackBoxFunc;
-use acir::{AcirField, FieldElement};
 
 use crate::BlackBoxResolutionError;
 
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index e3cea1153be..08e0fb66a6d 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -2,7 +2,6 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
-use acir::FieldElement;
 use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 mod embedded_curve_ops;
@@ -15,6 +14,10 @@ use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use poseidon2::poseidon2_permutation;
 
+// Temporary hack, this ensure that we always use a bn254 field here
+// without polluting the feature flags of the `acir_field` crate.
+type FieldElement = acir::acir_field::GenericFieldElement<ark_bn254::Fr>;
+
 #[derive(Default)]
 pub struct Bn254BlackBoxSolver;
 
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
index 5ff2c269d8c..03f03fcf5ab 100644
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
@@ -27,12 +27,13 @@ pub(crate) fn commit_native_with_index(
 #[cfg(test)]
 mod test {
 
-    use acir::{AcirField, FieldElement};
+    use acir::AcirField;
     use ark_ec::short_weierstrass::Affine;
     use ark_std::{One, Zero};
     use grumpkin::Fq;
 
     use crate::pedersen::commitment::commit_native_with_index;
+    use crate::FieldElement;
 
     #[test]
     fn commitment() {
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
index 5c637207491..152526a9943 100644
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
@@ -30,8 +30,9 @@ fn length_generator() -> &'static Affine<GrumpkinParameters> {
 pub(crate) mod test {
 
     use super::*;
+    use crate::FieldElement;
 
-    use acir::{AcirField, FieldElement};
+    use acir::AcirField;
     use ark_std::One;
     use grumpkin::Fq;
 
diff --git a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
index 95c620aab0d..18ed0b1d8ab 100644
--- a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
@@ -1,7 +1,9 @@
-use acir::{AcirField, FieldElement};
+use acir::AcirField;
 use acvm_blackbox_solver::BlackBoxResolutionError;
 use lazy_static::lazy_static;
 
+use crate::FieldElement;
+
 pub fn poseidon2_permutation(
     inputs: &[FieldElement],
     len: u32,
@@ -543,9 +545,9 @@ impl<'a> Poseidon2<'a> {
 
 #[cfg(test)]
 mod test {
-    use acir::{AcirField, FieldElement};
+    use acir::AcirField;
 
-    use super::{field_from_hex, poseidon2_permutation};
+    use super::{field_from_hex, poseidon2_permutation, FieldElement};
 
     #[test]
     fn smoke_test() {
diff --git a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
index 62e515a0792..8e3a40803f8 100644
--- a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
@@ -65,9 +65,10 @@ fn schnorr_generate_challenge(
 
 #[cfg(test)]
 mod schnorr_tests {
-    use acir::{AcirField, FieldElement};
+    use acir::AcirField;
 
     use super::verify_signature;
+    use crate::FieldElement;
 
     #[test]
     fn verifies_valid_signature() {

From e3287668b772959c24ae05a6f006dbc10ccfd9bc Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 12 Jun 2024 11:57:24 +0100
Subject: [PATCH 360/416] chore: push code related to ABI gen into
 `noirc_driver` (#5218)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

I'm not sure why this code was placed here. This code is only relevant
for ABI gen so I've pushed it into the`abi_gen` module. This simplifies
the dependency graph.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 Cargo.lock                           |   1 -
 compiler/noirc_driver/src/abi_gen.rs | 106 +++++++++++++++++++++++++--
 compiler/noirc_driver/src/lib.rs     |   4 +-
 tooling/noirc_abi/Cargo.toml         |  11 +--
 tooling/noirc_abi/src/lib.rs         | 102 --------------------------
 5 files changed, 102 insertions(+), 122 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bd575d0dca2..a8eab53dc07 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2727,7 +2727,6 @@ version = "0.30.0"
 dependencies = [
  "acvm",
  "iter-extended",
- "noirc_frontend",
  "noirc_printable_type",
  "num-bigint",
  "num-traits",
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 71dd1b18761..e2c7fea3c07 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -2,14 +2,17 @@ use std::collections::BTreeMap;
 
 use acvm::acir::circuit::ErrorSelector;
 use iter_extended::vecmap;
-use noirc_abi::{Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue};
-use noirc_frontend::ast::Visibility;
+use noirc_abi::{
+    Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue, AbiVisibility, Sign,
+};
+use noirc_frontend::ast::{Signedness, Visibility};
 use noirc_frontend::{
     hir::Context,
     hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern, types::Type},
     macros_api::{HirExpression, HirLiteral},
     node_interner::{FuncId, NodeInterner},
 };
+use noirc_frontend::{TypeBinding, TypeVariableKind};
 
 /// Arranges a function signature and a generated circuit's return witnesses into a
 /// `noirc_abi::Abi`.
@@ -20,15 +23,102 @@ pub(super) fn gen_abi(
     error_types: BTreeMap<ErrorSelector, Type>,
 ) -> Abi {
     let (parameters, return_type) = compute_function_abi(context, func_id);
-    let return_type = return_type
-        .map(|typ| AbiReturnType { abi_type: typ, visibility: return_visibility.into() });
+    let return_type = return_type.map(|typ| AbiReturnType {
+        abi_type: typ,
+        visibility: to_abi_visibility(return_visibility),
+    });
     let error_types = error_types
         .into_iter()
-        .map(|(selector, typ)| (selector, AbiErrorType::from_type(context, &typ)))
+        .map(|(selector, typ)| (selector, build_abi_error_type(context, &typ)))
         .collect();
     Abi { parameters, return_type, error_types }
 }
 
+fn build_abi_error_type(context: &Context, typ: &Type) -> AbiErrorType {
+    match typ {
+        Type::FmtString(len, item_types) => {
+            let length = len.evaluate_to_u32().expect("Cannot evaluate fmt length");
+            let Type::Tuple(item_types) = item_types.as_ref() else {
+                unreachable!("FmtString items must be a tuple")
+            };
+            let item_types =
+                item_types.iter().map(|typ| abi_type_from_hir_type(context, typ)).collect();
+            AbiErrorType::FmtString { length, item_types }
+        }
+        _ => AbiErrorType::Custom(abi_type_from_hir_type(context, typ)),
+    }
+}
+
+pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
+    match typ {
+        Type::FieldElement => AbiType::Field,
+        Type::Array(size, typ) => {
+            let length = size
+                .evaluate_to_u32()
+                .expect("Cannot have variable sized arrays as a parameter to main");
+            let typ = typ.as_ref();
+            AbiType::Array { length, typ: Box::new(abi_type_from_hir_type(context, typ)) }
+        }
+        Type::Integer(sign, bit_width) => {
+            let sign = match sign {
+                Signedness::Unsigned => Sign::Unsigned,
+                Signedness::Signed => Sign::Signed,
+            };
+
+            AbiType::Integer { sign, width: (*bit_width).into() }
+        }
+        Type::TypeVariable(binding, TypeVariableKind::IntegerOrField)
+        | Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
+            TypeBinding::Bound(typ) => abi_type_from_hir_type(context, typ),
+            TypeBinding::Unbound(_) => {
+                abi_type_from_hir_type(context, &Type::default_int_or_field_type())
+            }
+        },
+        Type::Bool => AbiType::Boolean,
+        Type::String(size) => {
+            let size = size
+                .evaluate_to_u32()
+                .expect("Cannot have variable sized strings as a parameter to main");
+            AbiType::String { length: size }
+        }
+
+        Type::Struct(def, args) => {
+            let struct_type = def.borrow();
+            let fields = struct_type.get_fields(args);
+            let fields =
+                vecmap(fields, |(name, typ)| (name, abi_type_from_hir_type(context, &typ)));
+            // For the ABI, we always want to resolve the struct paths from the root crate
+            let path = context.fully_qualified_struct_path(context.root_crate_id(), struct_type.id);
+            AbiType::Struct { fields, path }
+        }
+        Type::Alias(def, args) => abi_type_from_hir_type(context, &def.borrow().get_type(args)),
+        Type::Tuple(fields) => {
+            let fields = vecmap(fields, |typ| abi_type_from_hir_type(context, typ));
+            AbiType::Tuple { fields }
+        }
+        Type::Error
+        | Type::Unit
+        | Type::Constant(_)
+        | Type::TraitAsType(..)
+        | Type::TypeVariable(_, _)
+        | Type::NamedGeneric(..)
+        | Type::Forall(..)
+        | Type::Code
+        | Type::Slice(_)
+        | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
+        Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
+        Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"),
+    }
+}
+
+fn to_abi_visibility(value: Visibility) -> AbiVisibility {
+    match value {
+        Visibility::Public => AbiVisibility::Public,
+        Visibility::Private => AbiVisibility::Private,
+        Visibility::DataBus => AbiVisibility::DataBus,
+    }
+}
+
 pub(super) fn compute_function_abi(
     context: &Context,
     func_id: &FuncId,
@@ -37,7 +127,7 @@ pub(super) fn compute_function_abi(
 
     let (parameters, return_type) = func_meta.function_signature();
     let parameters = into_abi_params(context, parameters);
-    let return_type = return_type.map(|typ| AbiType::from_type(context, &typ));
+    let return_type = return_type.map(|typ| abi_type_from_hir_type(context, &typ));
     (parameters, return_type)
 }
 
@@ -57,8 +147,8 @@ fn into_abi_params(context: &Context, params: Vec<Param>) -> Vec<AbiParameter> {
         let param_name = get_param_name(&pattern, &context.def_interner)
             .expect("Abi for tuple and struct parameters is unimplemented")
             .to_owned();
-        let as_abi = AbiType::from_type(context, &typ);
-        AbiParameter { name: param_name, typ: as_abi, visibility: vis.into() }
+        let as_abi = abi_type_from_hir_type(context, &typ);
+        AbiParameter { name: param_name, typ: as_abi, visibility: to_abi_visibility(vis) }
     })
 }
 
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index f8043a60f8c..2c8679eaa95 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -3,7 +3,7 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
-use abi_gen::value_from_hir_expression;
+use abi_gen::{abi_type_from_hir_type, value_from_hir_expression};
 use acvm::acir::circuit::ExpressionWidth;
 use clap::Args;
 use fm::{FileId, FileManager};
@@ -468,7 +468,7 @@ fn compile_contract_inner(
                         let typ = context.def_interner.get_struct(struct_id);
                         let typ = typ.borrow();
                         let fields = vecmap(typ.get_fields(&[]), |(name, typ)| {
-                            (name, AbiType::from_type(context, &typ))
+                            (name, abi_type_from_hir_type(context, &typ))
                         });
                         let path =
                             context.fully_qualified_struct_path(context.root_crate_id(), typ.id);
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index baae2dfa35e..d450b268aee 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -11,7 +11,6 @@ license.workspace = true
 [dependencies]
 acvm.workspace = true
 iter-extended.workspace = true
-noirc_frontend.workspace = true
 noirc_printable_type.workspace = true
 toml.workspace = true
 serde_json = "1.0"
@@ -25,11 +24,5 @@ strum = "0.24"
 strum_macros = "0.24"
 
 [features]
-bn254 = [
-    "acvm/bn254",
-    "noirc_frontend/bn254",
-]
-bls12_381 = [
-    "acvm/bls12_381",
-    "noirc_frontend/bls12_381",
-]
\ No newline at end of file
+bn254 = ["acvm/bn254"]
+bls12_381 = ["acvm/bls12_381"]
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 514fac2e73d..2ebccbad1a0 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -13,8 +13,6 @@ use acvm::{
 use errors::AbiError;
 use input_parser::InputValue;
 use iter_extended::{try_btree_map, try_vecmap, vecmap};
-use noirc_frontend::ast::{Signedness, Visibility};
-use noirc_frontend::{hir::Context, Type, TypeBinding, TypeVariableKind};
 use noirc_printable_type::{
     decode_value as printable_type_decode_value, PrintableType, PrintableValue,
     PrintableValueDisplay,
@@ -87,26 +85,6 @@ pub enum AbiVisibility {
     DataBus,
 }
 
-impl From<Visibility> for AbiVisibility {
-    fn from(value: Visibility) -> Self {
-        match value {
-            Visibility::Public => AbiVisibility::Public,
-            Visibility::Private => AbiVisibility::Private,
-            Visibility::DataBus => AbiVisibility::DataBus,
-        }
-    }
-}
-
-impl From<&Visibility> for AbiVisibility {
-    fn from(value: &Visibility) -> Self {
-        match value {
-            Visibility::Public => AbiVisibility::Public,
-            Visibility::Private => AbiVisibility::Private,
-            Visibility::DataBus => AbiVisibility::DataBus,
-        }
-    }
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum Sign {
@@ -115,70 +93,6 @@ pub enum Sign {
 }
 
 impl AbiType {
-    pub fn from_type(context: &Context, typ: &Type) -> Self {
-        // Note; use strict_eq instead of partial_eq when comparing field types
-        // in this method, you most likely want to distinguish between public and private
-        match typ {
-            Type::FieldElement => Self::Field,
-            Type::Array(size, typ) => {
-                let length = size
-                    .evaluate_to_u32()
-                    .expect("Cannot have variable sized arrays as a parameter to main");
-                let typ = typ.as_ref();
-                Self::Array { length, typ: Box::new(Self::from_type(context, typ)) }
-            }
-            Type::Integer(sign, bit_width) => {
-                let sign = match sign {
-                    Signedness::Unsigned => Sign::Unsigned,
-                    Signedness::Signed => Sign::Signed,
-                };
-
-                Self::Integer { sign, width: (*bit_width).into() }
-            }
-            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField)
-            | Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
-                TypeBinding::Bound(typ) => Self::from_type(context, typ),
-                TypeBinding::Unbound(_) => {
-                    Self::from_type(context, &Type::default_int_or_field_type())
-                }
-            },
-            Type::Bool => Self::Boolean,
-            Type::String(size) => {
-                let size = size
-                    .evaluate_to_u32()
-                    .expect("Cannot have variable sized strings as a parameter to main");
-                Self::String { length: size }
-            }
-
-            Type::Struct(def, args) => {
-                let struct_type = def.borrow();
-                let fields = struct_type.get_fields(args);
-                let fields = vecmap(fields, |(name, typ)| (name, Self::from_type(context, &typ)));
-                // For the ABI, we always want to resolve the struct paths from the root crate
-                let path =
-                    context.fully_qualified_struct_path(context.root_crate_id(), struct_type.id);
-                Self::Struct { fields, path }
-            }
-            Type::Alias(def, args) => Self::from_type(context, &def.borrow().get_type(args)),
-            Type::Tuple(fields) => {
-                let fields = vecmap(fields, |typ| Self::from_type(context, typ));
-                Self::Tuple { fields }
-            }
-            Type::Error
-            | Type::Unit
-            | Type::Constant(_)
-            | Type::TraitAsType(..)
-            | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(..)
-            | Type::Forall(..)
-            | Type::Code
-            | Type::Slice(_)
-            | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
-            Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
-            Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"),
-        }
-    }
-
     /// Returns the number of field elements required to represent the type once encoded.
     pub fn field_count(&self) -> u32 {
         match self {
@@ -543,22 +457,6 @@ pub enum AbiErrorType {
     FmtString { length: u32, item_types: Vec<AbiType> },
     Custom(AbiType),
 }
-impl AbiErrorType {
-    pub fn from_type(context: &Context, typ: &Type) -> Self {
-        match typ {
-            Type::FmtString(len, item_types) => {
-                let length = len.evaluate_to_u32().expect("Cannot evaluate fmt length");
-                let Type::Tuple(item_types) = item_types.as_ref() else {
-                    unreachable!("FmtString items must be a tuple")
-                };
-                let item_types =
-                    item_types.iter().map(|typ| AbiType::from_type(context, typ)).collect();
-                Self::FmtString { length, item_types }
-            }
-            _ => Self::Custom(AbiType::from_type(context, typ)),
-        }
-    }
-}
 
 pub fn display_abi_error<F: AcirField>(
     fields: &[F],

From 3e04cd5e122d83396f75818e78d45c65de178640 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Wed, 12 Jun 2024 12:25:38 +0100
Subject: [PATCH 361/416] chore: fixing all relative paths (#5220)

Making the change as per the [docusaurus
documentation](https://docusaurus.io/docs/advanced/routing#docs-routing)
as this avoids mistakes when for some reason a link comes with a
trailing slash, and other benefits
---
 docs/docs/noir/concepts/data_types/arrays.md  |  4 +++-
 .../docs/noir/concepts/data_types/booleans.md |  4 ++--
 docs/docs/noir/concepts/data_types/strings.md |  2 +-
 docs/docs/noir/concepts/generics.md           |  4 ++--
 docs/docs/noir/concepts/unconstrained.md      |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 docs/docs/noir/standard_library/recursion.md  |  2 +-
 docs/docs/tooling/debugger.md                 |  2 +-
 .../getting_started/01_hello_world.md         |  4 ++--
 .../getting_started/02_breakdown.md           |  4 ++--
 docs/versioned_docs/version-v0.17.0/index.md  |  4 ++--
 .../data_types/02_booleans.md                 |  4 ++--
 .../data_types/03_strings.md                  |  2 +-
 .../language_concepts/data_types/04_arrays.md |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../version-v0.17.0/nargo/01_commands.md      |  2 +-
 .../standard_library/black_box_fns.md         | 20 ++++++++---------
 .../standard_library/recursion.md             |  2 +-
 .../getting_started/01_hello_world.md         |  4 ++--
 .../getting_started/02_breakdown.md           |  4 ++--
 docs/versioned_docs/version-v0.19.0/index.md  |  4 ++--
 .../data_types/02_booleans.md                 |  4 ++--
 .../data_types/03_strings.md                  |  2 +-
 .../language_concepts/data_types/04_arrays.md |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../version-v0.19.0/nargo/01_commands.md      |  2 +-
 .../standard_library/black_box_fns.md         | 22 +++++++++----------
 .../standard_library/recursion.md             |  2 +-
 .../getting_started/01_hello_world.md         |  4 ++--
 .../getting_started/02_breakdown.md           |  4 ++--
 docs/versioned_docs/version-v0.19.1/index.md  |  4 ++--
 .../data_types/02_booleans.md                 |  4 ++--
 .../data_types/03_strings.md                  |  2 +-
 .../language_concepts/data_types/04_arrays.md |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../version-v0.19.1/nargo/01_commands.md      |  2 +-
 .../standard_library/black_box_fns.md         | 22 +++++++++----------
 .../standard_library/recursion.md             |  2 +-
 .../getting_started/01_hello_world.md         |  4 ++--
 .../getting_started/02_breakdown.md           |  4 ++--
 docs/versioned_docs/version-v0.19.2/index.md  |  4 ++--
 .../data_types/02_booleans.md                 |  4 ++--
 .../data_types/03_strings.md                  |  2 +-
 .../language_concepts/data_types/04_arrays.md |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../version-v0.19.2/nargo/01_commands.md      |  2 +-
 .../standard_library/black_box_fns.md         | 22 +++++++++----------
 .../standard_library/recursion.md             |  2 +-
 .../getting_started/01_hello_world.md         |  4 ++--
 .../getting_started/02_breakdown.md           |  4 ++--
 docs/versioned_docs/version-v0.19.3/index.md  |  4 ++--
 .../data_types/02_booleans.md                 |  4 ++--
 .../data_types/03_strings.md                  |  2 +-
 .../language_concepts/data_types/04_arrays.md |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../version-v0.19.3/nargo/01_commands.md      |  2 +-
 .../standard_library/black_box_fns.md         | 22 +++++++++----------
 .../standard_library/recursion.md             |  2 +-
 .../getting_started/01_hello_world.md         |  4 ++--
 .../getting_started/02_breakdown.md           |  4 ++--
 docs/versioned_docs/version-v0.19.4/index.md  |  4 ++--
 .../data_types/02_booleans.md                 |  4 ++--
 .../data_types/03_strings.md                  |  2 +-
 .../language_concepts/data_types/04_arrays.md |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../version-v0.19.4/nargo/01_commands.md      |  2 +-
 .../standard_library/black_box_fns.md         | 22 +++++++++----------
 .../standard_library/recursion.md             |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    | 22 +++++++++----------
 .../noir/standard_library/recursion.md        |  2 +-
 .../noir/syntax/data_types/arrays.md          |  2 +-
 .../noir/syntax/data_types/booleans.md        |  4 ++--
 .../noir/syntax/data_types/strings.md         |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.23.0/noir/concepts/generics.md |  4 ++--
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    | 20 ++++++++---------
 .../noir/standard_library/recursion.md        |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.24.0/noir/concepts/generics.md |  4 ++--
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.25.0/noir/concepts/generics.md |  4 ++--
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.26.0/noir/concepts/generics.md |  4 ++--
 .../noir/concepts/unconstrained.md            |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.27.0/noir/concepts/generics.md |  4 ++--
 .../noir/concepts/unconstrained.md            |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.28.0/noir/concepts/generics.md |  4 ++--
 .../noir/concepts/unconstrained.md            |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../version-v0.28.0/tooling/debugger.md       |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.29.0/noir/concepts/generics.md |  4 ++--
 .../noir/concepts/unconstrained.md            |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../version-v0.29.0/tooling/debugger.md       |  2 +-
 .../noir/concepts/data_types/arrays.md        |  4 +++-
 .../noir/concepts/data_types/booleans.md      |  4 ++--
 .../noir/concepts/data_types/strings.md       |  2 +-
 .../version-v0.30.0/noir/concepts/generics.md |  4 ++--
 .../noir/concepts/unconstrained.md            |  2 +-
 .../modules_packages_crates/dependencies.md   |  4 ++--
 .../noir/standard_library/black_box_fns.md    |  2 +-
 .../noir/standard_library/recursion.md        |  2 +-
 .../version-v0.30.0/tooling/debugger.md       |  2 +-
 139 files changed, 294 insertions(+), 276 deletions(-)

diff --git a/docs/docs/noir/concepts/data_types/arrays.md b/docs/docs/noir/concepts/data_types/arrays.md
index efce3e95d32..95d749053e2 100644
--- a/docs/docs/noir/concepts/data_types/arrays.md
+++ b/docs/docs/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = &[];
 ```
diff --git a/docs/docs/noir/concepts/data_types/booleans.md b/docs/docs/noir/concepts/data_types/booleans.md
index 3dcfa836814..2507af710e7 100644
--- a/docs/docs/noir/concepts/data_types/booleans.md
+++ b/docs/docs/noir/concepts/data_types/booleans.md
@@ -24,5 +24,5 @@ fn main() {
 ```
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/docs/noir/concepts/data_types/strings.md b/docs/docs/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/docs/noir/concepts/data_types/strings.md
+++ b/docs/docs/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/docs/noir/concepts/generics.md b/docs/docs/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/docs/noir/concepts/generics.md
+++ b/docs/docs/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/docs/noir/concepts/unconstrained.md b/docs/docs/noir/concepts/unconstrained.md
index b8e71fe65f0..96f824c5e42 100644
--- a/docs/docs/noir/concepts/unconstrained.md
+++ b/docs/docs/noir/concepts/unconstrained.md
@@ -96,4 +96,4 @@ Generally we want to use brillig whenever there's something that's easy to verif
 
 ## Break and Continue
 
-In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/docs/noir/modules_packages_crates/dependencies.md b/docs/docs/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/docs/noir/modules_packages_crates/dependencies.md
+++ b/docs/docs/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/docs/noir/standard_library/black_box_fns.md b/docs/docs/noir/standard_library/black_box_fns.md
index eeead580969..d5694250f05 100644
--- a/docs/docs/noir/standard_library/black_box_fns.md
+++ b/docs/docs/noir/standard_library/black_box_fns.md
@@ -25,7 +25,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/docs/noir/standard_library/recursion.md b/docs/docs/noir/standard_library/recursion.md
index a93894043dc..f33c285cf4e 100644
--- a/docs/docs/noir/standard_library/recursion.md
+++ b/docs/docs/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/docs/tooling/debugger.md b/docs/docs/tooling/debugger.md
index 7c158d949d1..9b7565ba9ff 100644
--- a/docs/docs/tooling/debugger.md
+++ b/docs/docs/tooling/debugger.md
@@ -12,7 +12,7 @@ There are currently two ways of debugging Noir programs:
 1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
 2. Via the REPL debugger, which ships with Nargo.
 
-In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
 
 - Noir & Nargo ≥0.28.0
 - Noir's VS Code extension ≥0.0.11
diff --git a/docs/versioned_docs/version-v0.17.0/getting_started/01_hello_world.md b/docs/versioned_docs/version-v0.17.0/getting_started/01_hello_world.md
index d4daae605a2..34f8cd96fcd 100644
--- a/docs/versioned_docs/version-v0.17.0/getting_started/01_hello_world.md
+++ b/docs/versioned_docs/version-v0.17.0/getting_started/01_hello_world.md
@@ -74,7 +74,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../language_concepts/data_types) section.
+[Data Types](../language_concepts/data_types.md) section.
 
 The next line of the program specifies its body:
 
@@ -84,7 +84,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../language_concepts/comments) chapter.
+For more Noir syntax, check the [Language Concepts](../language_concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md
index e7b1f33b339..8616feee917 100644
--- a/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md
@@ -51,7 +51,7 @@ license = "MIT"
 ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
 ```
 
-Nargo.toml for a [workspace](../modules_packages_crates/workspaces) will look a bit different. For example:
+Nargo.toml for a [workspace](../modules_packages_crates/workspaces.md) will look a bit different. For example:
 
 ```toml
 [workspace]
@@ -74,7 +74,7 @@ The package section requires a number of fields including:
 
 #### Dependencies section
 
-This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies) for more info.
+This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies.md)for more info.
 
 `./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
 verifier contract respectively.
diff --git a/docs/versioned_docs/version-v0.17.0/index.md b/docs/versioned_docs/version-v0.17.0/index.md
index 2d5e6f4454f..c88aabf0ac1 100644
--- a/docs/versioned_docs/version-v0.17.0/index.md
+++ b/docs/versioned_docs/version-v0.17.0/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands.md#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -96,4 +96,4 @@ Some libraries that are available today include:
 - [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
 - [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
 
-See the section on [dependencies](./modules_packages_crates/dependencies) for more information.
+See the section on [dependencies](./modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/02_booleans.md b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/02_booleans.md
index 885db167d83..d353606210a 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/02_booleans.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/02_booleans.md
@@ -26,5 +26,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/03_strings.md b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/03_strings.md
index c42f34ec3ad..4360893e9a2 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/03_strings.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/03_strings.md
@@ -16,7 +16,7 @@ keywords:
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`std::println()`. See more about [Logging](../../standard_library/logging).
+`std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/04_arrays.md b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/04_arrays.md
index bdbd1798bef..1424ca2df14 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/04_arrays.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types/04_arrays.md
@@ -56,7 +56,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md
index e91e73a4c4f..87a09293ea8 100644
--- a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md
@@ -81,14 +81,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.17.0/nargo/01_commands.md b/docs/versioned_docs/version-v0.17.0/nargo/01_commands.md
index 65e2bdb44e3..e2b0af522f4 100644
--- a/docs/versioned_docs/version-v0.17.0/nargo/01_commands.md
+++ b/docs/versioned_docs/version-v0.17.0/nargo/01_commands.md
@@ -213,7 +213,7 @@ you run `nargo test`. To print `println` statements in tests, use the `--show-ou
 
 Takes an optional `--exact` flag which allows you to select tests based on an exact name.
 
-See an example on the [testing page](./testing).
+See an example on the [testing page](./testing.md).
 
 ### Options
 
diff --git a/docs/versioned_docs/version-v0.17.0/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.17.0/standard_library/black_box_fns.md
index a412de19d06..b4dedefe4c9 100644
--- a/docs/versioned_docs/version-v0.17.0/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.17.0/standard_library/black_box_fns.md
@@ -26,19 +26,19 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen](./cryptographic_primitives/hashes#pedersen)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen](./cryptographic_primitives/hashes.mdx#pedersen)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.17.0/standard_library/recursion.md b/docs/versioned_docs/version-v0.17.0/standard_library/recursion.md
index ff4c63acaa7..5e592a2fd89 100644
--- a/docs/versioned_docs/version-v0.17.0/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.17.0/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.19.0/getting_started/01_hello_world.md b/docs/versioned_docs/version-v0.19.0/getting_started/01_hello_world.md
index d4daae605a2..34f8cd96fcd 100644
--- a/docs/versioned_docs/version-v0.19.0/getting_started/01_hello_world.md
+++ b/docs/versioned_docs/version-v0.19.0/getting_started/01_hello_world.md
@@ -74,7 +74,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../language_concepts/data_types) section.
+[Data Types](../language_concepts/data_types.md) section.
 
 The next line of the program specifies its body:
 
@@ -84,7 +84,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../language_concepts/comments) chapter.
+For more Noir syntax, check the [Language Concepts](../language_concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md
index d28a54a1600..f928370b2e8 100644
--- a/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md
@@ -51,7 +51,7 @@ license = "MIT"
 ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
 ```
 
-Nargo.toml for a [workspace](../modules_packages_crates/workspaces) will look a bit different. For example:
+Nargo.toml for a [workspace](../modules_packages_crates/workspaces.md) will look a bit different. For example:
 
 ```toml
 [workspace]
@@ -74,7 +74,7 @@ The package section requires a number of fields including:
 
 #### Dependencies section
 
-This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies) for more info.
+This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies.md)for more info.
 
 `./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
 verifier contract respectively.
diff --git a/docs/versioned_docs/version-v0.19.0/index.md b/docs/versioned_docs/version-v0.19.0/index.md
index 380368db036..e8d86020a20 100644
--- a/docs/versioned_docs/version-v0.19.0/index.md
+++ b/docs/versioned_docs/version-v0.19.0/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier.md) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -97,4 +97,4 @@ Some libraries that are available today include:
 - [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
 - [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
 
-See the section on [dependencies](./modules_packages_crates/dependencies) for more information.
+See the section on [dependencies](./modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/02_booleans.md b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/02_booleans.md
index 885db167d83..d353606210a 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/02_booleans.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/02_booleans.md
@@ -26,5 +26,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/03_strings.md b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/03_strings.md
index c42f34ec3ad..4360893e9a2 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/03_strings.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/03_strings.md
@@ -16,7 +16,7 @@ keywords:
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`std::println()`. See more about [Logging](../../standard_library/logging).
+`std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/04_arrays.md b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/04_arrays.md
index bdbd1798bef..1424ca2df14 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/04_arrays.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types/04_arrays.md
@@ -56,7 +56,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md
index e91e73a4c4f..87a09293ea8 100644
--- a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md
@@ -81,14 +81,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.19.0/nargo/01_commands.md b/docs/versioned_docs/version-v0.19.0/nargo/01_commands.md
index 65e2bdb44e3..e2b0af522f4 100644
--- a/docs/versioned_docs/version-v0.19.0/nargo/01_commands.md
+++ b/docs/versioned_docs/version-v0.19.0/nargo/01_commands.md
@@ -213,7 +213,7 @@ you run `nargo test`. To print `println` statements in tests, use the `--show-ou
 
 Takes an optional `--exact` flag which allows you to select tests based on an exact name.
 
-See an example on the [testing page](./testing).
+See an example on the [testing page](./testing.md).
 
 ### Options
 
diff --git a/docs/versioned_docs/version-v0.19.0/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.19.0/standard_library/black_box_fns.md
index e0c6d475c1f..985bb7c879d 100644
--- a/docs/versioned_docs/version-v0.19.0/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.19.0/standard_library/black_box_fns.md
@@ -26,20 +26,20 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.19.0/standard_library/recursion.md b/docs/versioned_docs/version-v0.19.0/standard_library/recursion.md
index ff4c63acaa7..5e592a2fd89 100644
--- a/docs/versioned_docs/version-v0.19.0/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.19.0/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.19.1/getting_started/01_hello_world.md b/docs/versioned_docs/version-v0.19.1/getting_started/01_hello_world.md
index d4daae605a2..34f8cd96fcd 100644
--- a/docs/versioned_docs/version-v0.19.1/getting_started/01_hello_world.md
+++ b/docs/versioned_docs/version-v0.19.1/getting_started/01_hello_world.md
@@ -74,7 +74,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../language_concepts/data_types) section.
+[Data Types](../language_concepts/data_types.md) section.
 
 The next line of the program specifies its body:
 
@@ -84,7 +84,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../language_concepts/comments) chapter.
+For more Noir syntax, check the [Language Concepts](../language_concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md
index d28a54a1600..f928370b2e8 100644
--- a/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md
@@ -51,7 +51,7 @@ license = "MIT"
 ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
 ```
 
-Nargo.toml for a [workspace](../modules_packages_crates/workspaces) will look a bit different. For example:
+Nargo.toml for a [workspace](../modules_packages_crates/workspaces.md) will look a bit different. For example:
 
 ```toml
 [workspace]
@@ -74,7 +74,7 @@ The package section requires a number of fields including:
 
 #### Dependencies section
 
-This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies) for more info.
+This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies.md)for more info.
 
 `./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
 verifier contract respectively.
diff --git a/docs/versioned_docs/version-v0.19.1/index.md b/docs/versioned_docs/version-v0.19.1/index.md
index 380368db036..e8d86020a20 100644
--- a/docs/versioned_docs/version-v0.19.1/index.md
+++ b/docs/versioned_docs/version-v0.19.1/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier.md) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -97,4 +97,4 @@ Some libraries that are available today include:
 - [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
 - [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
 
-See the section on [dependencies](./modules_packages_crates/dependencies) for more information.
+See the section on [dependencies](./modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/02_booleans.md b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/02_booleans.md
index 885db167d83..d353606210a 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/02_booleans.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/02_booleans.md
@@ -26,5 +26,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/03_strings.md b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/03_strings.md
index c42f34ec3ad..4360893e9a2 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/03_strings.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/03_strings.md
@@ -16,7 +16,7 @@ keywords:
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`std::println()`. See more about [Logging](../../standard_library/logging).
+`std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/04_arrays.md b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/04_arrays.md
index bdbd1798bef..1424ca2df14 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/04_arrays.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types/04_arrays.md
@@ -56,7 +56,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md
index e91e73a4c4f..87a09293ea8 100644
--- a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md
@@ -81,14 +81,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.19.1/nargo/01_commands.md b/docs/versioned_docs/version-v0.19.1/nargo/01_commands.md
index 65e2bdb44e3..e2b0af522f4 100644
--- a/docs/versioned_docs/version-v0.19.1/nargo/01_commands.md
+++ b/docs/versioned_docs/version-v0.19.1/nargo/01_commands.md
@@ -213,7 +213,7 @@ you run `nargo test`. To print `println` statements in tests, use the `--show-ou
 
 Takes an optional `--exact` flag which allows you to select tests based on an exact name.
 
-See an example on the [testing page](./testing).
+See an example on the [testing page](./testing.md).
 
 ### Options
 
diff --git a/docs/versioned_docs/version-v0.19.1/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.19.1/standard_library/black_box_fns.md
index e0c6d475c1f..985bb7c879d 100644
--- a/docs/versioned_docs/version-v0.19.1/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.19.1/standard_library/black_box_fns.md
@@ -26,20 +26,20 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.19.1/standard_library/recursion.md b/docs/versioned_docs/version-v0.19.1/standard_library/recursion.md
index ff4c63acaa7..5e592a2fd89 100644
--- a/docs/versioned_docs/version-v0.19.1/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.19.1/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.19.2/getting_started/01_hello_world.md b/docs/versioned_docs/version-v0.19.2/getting_started/01_hello_world.md
index d4daae605a2..34f8cd96fcd 100644
--- a/docs/versioned_docs/version-v0.19.2/getting_started/01_hello_world.md
+++ b/docs/versioned_docs/version-v0.19.2/getting_started/01_hello_world.md
@@ -74,7 +74,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../language_concepts/data_types) section.
+[Data Types](../language_concepts/data_types.md) section.
 
 The next line of the program specifies its body:
 
@@ -84,7 +84,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../language_concepts/comments) chapter.
+For more Noir syntax, check the [Language Concepts](../language_concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md
index d28a54a1600..f928370b2e8 100644
--- a/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md
@@ -51,7 +51,7 @@ license = "MIT"
 ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
 ```
 
-Nargo.toml for a [workspace](../modules_packages_crates/workspaces) will look a bit different. For example:
+Nargo.toml for a [workspace](../modules_packages_crates/workspaces.md) will look a bit different. For example:
 
 ```toml
 [workspace]
@@ -74,7 +74,7 @@ The package section requires a number of fields including:
 
 #### Dependencies section
 
-This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies) for more info.
+This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies.md)for more info.
 
 `./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
 verifier contract respectively.
diff --git a/docs/versioned_docs/version-v0.19.2/index.md b/docs/versioned_docs/version-v0.19.2/index.md
index 380368db036..e8d86020a20 100644
--- a/docs/versioned_docs/version-v0.19.2/index.md
+++ b/docs/versioned_docs/version-v0.19.2/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier.md) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -97,4 +97,4 @@ Some libraries that are available today include:
 - [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
 - [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
 
-See the section on [dependencies](./modules_packages_crates/dependencies) for more information.
+See the section on [dependencies](./modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/02_booleans.md b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/02_booleans.md
index 885db167d83..d353606210a 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/02_booleans.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/02_booleans.md
@@ -26,5 +26,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/03_strings.md b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/03_strings.md
index c42f34ec3ad..4360893e9a2 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/03_strings.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/03_strings.md
@@ -16,7 +16,7 @@ keywords:
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`std::println()`. See more about [Logging](../../standard_library/logging).
+`std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/04_arrays.md b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/04_arrays.md
index bdbd1798bef..1424ca2df14 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/04_arrays.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types/04_arrays.md
@@ -56,7 +56,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md
index e91e73a4c4f..87a09293ea8 100644
--- a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md
@@ -81,14 +81,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.19.2/nargo/01_commands.md b/docs/versioned_docs/version-v0.19.2/nargo/01_commands.md
index 65e2bdb44e3..e2b0af522f4 100644
--- a/docs/versioned_docs/version-v0.19.2/nargo/01_commands.md
+++ b/docs/versioned_docs/version-v0.19.2/nargo/01_commands.md
@@ -213,7 +213,7 @@ you run `nargo test`. To print `println` statements in tests, use the `--show-ou
 
 Takes an optional `--exact` flag which allows you to select tests based on an exact name.
 
-See an example on the [testing page](./testing).
+See an example on the [testing page](./testing.md).
 
 ### Options
 
diff --git a/docs/versioned_docs/version-v0.19.2/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.19.2/standard_library/black_box_fns.md
index e0c6d475c1f..985bb7c879d 100644
--- a/docs/versioned_docs/version-v0.19.2/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.19.2/standard_library/black_box_fns.md
@@ -26,20 +26,20 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.19.2/standard_library/recursion.md b/docs/versioned_docs/version-v0.19.2/standard_library/recursion.md
index ff4c63acaa7..5e592a2fd89 100644
--- a/docs/versioned_docs/version-v0.19.2/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.19.2/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.19.3/getting_started/01_hello_world.md b/docs/versioned_docs/version-v0.19.3/getting_started/01_hello_world.md
index d4daae605a2..34f8cd96fcd 100644
--- a/docs/versioned_docs/version-v0.19.3/getting_started/01_hello_world.md
+++ b/docs/versioned_docs/version-v0.19.3/getting_started/01_hello_world.md
@@ -74,7 +74,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../language_concepts/data_types) section.
+[Data Types](../language_concepts/data_types.md) section.
 
 The next line of the program specifies its body:
 
@@ -84,7 +84,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../language_concepts/comments) chapter.
+For more Noir syntax, check the [Language Concepts](../language_concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md
index 7a7fb876c35..10422029661 100644
--- a/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md
@@ -51,7 +51,7 @@ license = "MIT"
 ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
 ```
 
-Nargo.toml for a [workspace](../modules_packages_crates/workspaces) will look a bit different. For example:
+Nargo.toml for a [workspace](../modules_packages_crates/workspaces.md) will look a bit different. For example:
 
 ```toml
 [workspace]
@@ -74,7 +74,7 @@ The package section requires a number of fields including:
 
 #### Dependencies section
 
-This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies) for more info.
+This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies.md)for more info.
 
 `./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
 verifier contract respectively.
diff --git a/docs/versioned_docs/version-v0.19.3/index.md b/docs/versioned_docs/version-v0.19.3/index.md
index 380368db036..e8d86020a20 100644
--- a/docs/versioned_docs/version-v0.19.3/index.md
+++ b/docs/versioned_docs/version-v0.19.3/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier.md) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -97,4 +97,4 @@ Some libraries that are available today include:
 - [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
 - [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
 
-See the section on [dependencies](./modules_packages_crates/dependencies) for more information.
+See the section on [dependencies](./modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/02_booleans.md b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/02_booleans.md
index 885db167d83..d353606210a 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/02_booleans.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/02_booleans.md
@@ -26,5 +26,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/03_strings.md b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/03_strings.md
index c42f34ec3ad..4360893e9a2 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/03_strings.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/03_strings.md
@@ -16,7 +16,7 @@ keywords:
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`std::println()`. See more about [Logging](../../standard_library/logging).
+`std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/04_arrays.md b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/04_arrays.md
index bdbd1798bef..1424ca2df14 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/04_arrays.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types/04_arrays.md
@@ -56,7 +56,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md
index e91e73a4c4f..87a09293ea8 100644
--- a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md
@@ -81,14 +81,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.19.3/nargo/01_commands.md b/docs/versioned_docs/version-v0.19.3/nargo/01_commands.md
index 65e2bdb44e3..e2b0af522f4 100644
--- a/docs/versioned_docs/version-v0.19.3/nargo/01_commands.md
+++ b/docs/versioned_docs/version-v0.19.3/nargo/01_commands.md
@@ -213,7 +213,7 @@ you run `nargo test`. To print `println` statements in tests, use the `--show-ou
 
 Takes an optional `--exact` flag which allows you to select tests based on an exact name.
 
-See an example on the [testing page](./testing).
+See an example on the [testing page](./testing.md).
 
 ### Options
 
diff --git a/docs/versioned_docs/version-v0.19.3/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.19.3/standard_library/black_box_fns.md
index e0c6d475c1f..985bb7c879d 100644
--- a/docs/versioned_docs/version-v0.19.3/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.19.3/standard_library/black_box_fns.md
@@ -26,20 +26,20 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.19.3/standard_library/recursion.md b/docs/versioned_docs/version-v0.19.3/standard_library/recursion.md
index ff4c63acaa7..5e592a2fd89 100644
--- a/docs/versioned_docs/version-v0.19.3/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.19.3/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.19.4/getting_started/01_hello_world.md b/docs/versioned_docs/version-v0.19.4/getting_started/01_hello_world.md
index d4daae605a2..34f8cd96fcd 100644
--- a/docs/versioned_docs/version-v0.19.4/getting_started/01_hello_world.md
+++ b/docs/versioned_docs/version-v0.19.4/getting_started/01_hello_world.md
@@ -74,7 +74,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../language_concepts/data_types) section.
+[Data Types](../language_concepts/data_types.md) section.
 
 The next line of the program specifies its body:
 
@@ -84,7 +84,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../language_concepts/comments) chapter.
+For more Noir syntax, check the [Language Concepts](../language_concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md
index d28a54a1600..f928370b2e8 100644
--- a/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md
@@ -51,7 +51,7 @@ license = "MIT"
 ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
 ```
 
-Nargo.toml for a [workspace](../modules_packages_crates/workspaces) will look a bit different. For example:
+Nargo.toml for a [workspace](../modules_packages_crates/workspaces.md) will look a bit different. For example:
 
 ```toml
 [workspace]
@@ -74,7 +74,7 @@ The package section requires a number of fields including:
 
 #### Dependencies section
 
-This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies) for more info.
+This is where you will specify any dependencies for your project. See the [Dependencies page](../modules_packages_crates/dependencies.md)for more info.
 
 `./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
 verifier contract respectively.
diff --git a/docs/versioned_docs/version-v0.19.4/index.md b/docs/versioned_docs/version-v0.19.4/index.md
index 380368db036..e8d86020a20 100644
--- a/docs/versioned_docs/version-v0.19.4/index.md
+++ b/docs/versioned_docs/version-v0.19.4/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier.md) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -97,4 +97,4 @@ Some libraries that are available today include:
 - [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
 - [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
 
-See the section on [dependencies](./modules_packages_crates/dependencies) for more information.
+See the section on [dependencies](./modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/02_booleans.md b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/02_booleans.md
index 885db167d83..d353606210a 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/02_booleans.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/02_booleans.md
@@ -26,5 +26,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/03_strings.md b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/03_strings.md
index b4c75942bb8..baa3f205094 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/03_strings.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/03_strings.md
@@ -15,7 +15,7 @@ keywords:
 
 The string type is a fixed length value defined with `str<N>`.
 
-You can use strings in `assert()` functions or print them with `std::println()`. See more about [Logging](../../standard_library/logging).
+You can use strings in `assert()` functions or print them with `std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/04_arrays.md b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/04_arrays.md
index bdbd1798bef..1424ca2df14 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/04_arrays.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types/04_arrays.md
@@ -56,7 +56,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md
index e91e73a4c4f..87a09293ea8 100644
--- a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md
@@ -81,14 +81,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.19.4/nargo/01_commands.md b/docs/versioned_docs/version-v0.19.4/nargo/01_commands.md
index 65e2bdb44e3..e2b0af522f4 100644
--- a/docs/versioned_docs/version-v0.19.4/nargo/01_commands.md
+++ b/docs/versioned_docs/version-v0.19.4/nargo/01_commands.md
@@ -213,7 +213,7 @@ you run `nargo test`. To print `println` statements in tests, use the `--show-ou
 
 Takes an optional `--exact` flag which allows you to select tests based on an exact name.
 
-See an example on the [testing page](./testing).
+See an example on the [testing page](./testing.md).
 
 ### Options
 
diff --git a/docs/versioned_docs/version-v0.19.4/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.19.4/standard_library/black_box_fns.md
index e0c6d475c1f..985bb7c879d 100644
--- a/docs/versioned_docs/version-v0.19.4/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.19.4/standard_library/black_box_fns.md
@@ -26,20 +26,20 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.19.4/standard_library/recursion.md b/docs/versioned_docs/version-v0.19.4/standard_library/recursion.md
index ff4c63acaa7..5e592a2fd89 100644
--- a/docs/versioned_docs/version-v0.19.4/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.19.4/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md
index a37dc401b7d..d9d21ef0485 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.22.0/noir/standard_library/black_box_fns.md
index e0c6d475c1f..985bb7c879d 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/standard_library/black_box_fns.md
@@ -26,20 +26,20 @@ fn sha256<N>(_input : [u8; N]) -> [u8; 32] {}
 Here is a list of the current black box functions that are supported by UltraPlonk:
 
 - AES
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [HashToField128Security](./cryptographic_primitives/hashes#hash_to_field)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
-- [Compute merkle root](./merkle_trees#compute_merkle_root)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [HashToField128Security](./cryptographic_primitives/hashes.mdx#hash_to_field)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
+- [Compute merkle root](./merkle_trees.md#compute_merkle_root)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function. To ensure compatibility across backends, the ACVM has fallback implementations of `AND`, `XOR` and `RANGE` defined in its standard library which it can seamlessly fallback to if the backend doesn't support them.
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.22.0/noir/standard_library/recursion.md
index 67962082a8f..4a004fd3664 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/arrays.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/arrays.md
index 075d39dadd4..4c80d50ed01 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/booleans.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/strings.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/strings.md
index 8d76d4ca654..dd6c844f6ae 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`std::println()`. See more about [Logging](../../standard_library/logging).
+`std::println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/arrays.md
index 7f275a2d771..d95346454a9 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = [];
 ```
diff --git a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.23.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.23.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/dependencies.md
index a37dc401b7d..d9d21ef0485 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.23.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.23.0/noir/standard_library/black_box_fns.md
index eae8744abf0..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/standard_library/black_box_fns.md
@@ -12,19 +12,19 @@ The ACVM spec defines a set of blackbox functions which backends will be expecte
 
 Here is a list of the current black box functions:
 
-- [SHA256](./cryptographic_primitives/hashes#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr)
-- [Blake2s](./cryptographic_primitives/hashes#blake2s)
-- [Blake3](./cryptographic_primitives/hashes#blake3)
-- [Pedersen Hash](./cryptographic_primitives/hashes#pedersen_hash)
-- [Pedersen Commitment](./cryptographic_primitives/hashes#pedersen_commitment)
-- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification)
-- [Fixed base scalar multiplication](./cryptographic_primitives/scalar)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Fixed base scalar multiplication](./cryptographic_primitives/scalar.mdx)
 - AND
 - XOR
 - RANGE
-- [Keccak256](./cryptographic_primitives/hashes#keccak256)
-- [Recursive proof verification](./recursion)
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md
index f252150c8b5..4390bda4a26 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md
@@ -15,7 +15,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/arrays.md
index a8bd338e736..ca54d82b26b 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = [];
 ```
diff --git a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.24.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.24.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/dependencies.md
index a37dc401b7d..d9d21ef0485 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md
index be8c65679c3..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/standard_library/black_box_fns.md
@@ -24,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.24.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.24.0/noir/standard_library/recursion.md
index 9337499dac8..ed2ed01fceb 100644
--- a/docs/versioned_docs/version-v0.24.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.24.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md
index a8bd338e736..ca54d82b26b 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = [];
 ```
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
index be8c65679c3..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/black_box_fns.md
@@ -24,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md
index 9337499dac8..ed2ed01fceb 100644
--- a/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.25.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md
index efce3e95d32..95d749053e2 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = &[];
 ```
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md
index b8e71fe65f0..96f824c5e42 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/concepts/unconstrained.md
@@ -96,4 +96,4 @@ Generally we want to use brillig whenever there's something that's easy to verif
 
 ## Break and Continue
 
-In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md
index be8c65679c3..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/black_box_fns.md
@@ -24,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md
index a93894043dc..f33c285cf4e 100644
--- a/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.26.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md
index efce3e95d32..95d749053e2 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = &[];
 ```
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md
index b8e71fe65f0..96f824c5e42 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/concepts/unconstrained.md
@@ -96,4 +96,4 @@ Generally we want to use brillig whenever there's something that's easy to verif
 
 ## Break and Continue
 
-In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md
index be8c65679c3..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/black_box_fns.md
@@ -24,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md
index a93894043dc..f33c285cf4e 100644
--- a/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.27.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md
index efce3e95d32..95d749053e2 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = &[];
 ```
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md
index b8e71fe65f0..96f824c5e42 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/concepts/unconstrained.md
@@ -96,4 +96,4 @@ Generally we want to use brillig whenever there's something that's easy to verif
 
 ## Break and Continue
 
-In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md
index be8c65679c3..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/black_box_fns.md
@@ -24,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md
index a93894043dc..f33c285cf4e 100644
--- a/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.28.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.28.0/tooling/debugger.md b/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
index 7c158d949d1..9b7565ba9ff 100644
--- a/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
+++ b/docs/versioned_docs/version-v0.28.0/tooling/debugger.md
@@ -12,7 +12,7 @@ There are currently two ways of debugging Noir programs:
 1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
 2. Via the REPL debugger, which ships with Nargo.
 
-In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
 
 - Noir & Nargo ≥0.28.0
 - Noir's VS Code extension ≥0.0.11
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md
index efce3e95d32..95d749053e2 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = &[];
 ```
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md
index b8e71fe65f0..96f824c5e42 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/concepts/unconstrained.md
@@ -96,4 +96,4 @@ Generally we want to use brillig whenever there's something that's easy to verif
 
 ## Break and Continue
 
-In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md
index be8c65679c3..e8b62f21d4e 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/black_box_fns.md
@@ -24,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md
index a93894043dc..f33c285cf4e 100644
--- a/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.29.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.29.0/tooling/debugger.md b/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
index 7c158d949d1..9b7565ba9ff 100644
--- a/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
+++ b/docs/versioned_docs/version-v0.29.0/tooling/debugger.md
@@ -12,7 +12,7 @@ There are currently two ways of debugging Noir programs:
 1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
 2. Via the REPL debugger, which ships with Nargo.
 
-In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
 
 - Noir & Nargo ≥0.28.0
 - Noir's VS Code extension ≥0.0.11
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md
index efce3e95d32..95d749053e2 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/arrays.md
@@ -57,7 +57,7 @@ You can instantiate a new array of a fixed size with the same value repeated for
 let array: [Field; 32] = [0; 32];
 ```
 
-Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices), you can just call `as_slice` on your array:
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
 
 ```rust
 let array: [Field; 32] = [0; 32];
@@ -70,7 +70,9 @@ You can define multidimensional arrays:
 let array : [[Field; 2]; 2];
 let element = array[0][0];
 ```
+
 However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
 ```rust
 let slice : [[Field]] = &[];
 ```
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md
index 69826fcd724..7211716f63e 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/booleans.md
@@ -27,5 +27,5 @@ fn main() {
 > `false` in _Verifier.toml_.
 
 The boolean type is most commonly used in conditionals like `if` expressions and `assert`
-statements. More about conditionals is covered in the [Control Flow](../control_flow) and
-[Assert Function](../assert) sections.
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md
index 311dfd64416..8ab5825a4c4 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/data_types/strings.md
@@ -17,7 +17,7 @@ sidebar_position: 3
 The string type is a fixed length value defined with `str<N>`.
 
 You can use strings in `assert()` functions or print them with
-`println()`. See more about [Logging](../../standard_library/logging).
+`println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
 use dep::std;
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md
index ddd42bf1f9b..0c1c27a2221 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/generics.md
@@ -73,7 +73,7 @@ impl<N> BigInt<N> {
 Since a generic type `T` can represent any type, how can we call functions on the underlying type?
 In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
 
-This is what [traits](../concepts/traits) are for in Noir. Here's an example of a function generic over
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
 any type `T` that implements the `Eq` trait for equality:
 
 ```rust
@@ -103,4 +103,4 @@ impl Eq for MyStruct {
 }
 ```
 
-You can find more details on traits and trait implementations on the [traits page](../concepts/traits).
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md
index b8e71fe65f0..96f824c5e42 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/concepts/unconstrained.md
@@ -96,4 +96,4 @@ Generally we want to use brillig whenever there's something that's easy to verif
 
 ## Break and Continue
 
-In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow/#break-and-continue)
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md
index 04c1703d929..2c028d85853 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/modules_packages_crates/dependencies.md
@@ -82,14 +82,14 @@ use dep::std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives#examples), you
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
 use dep::std::ec::tecurve::affine::{Curve, Point};
 ```
 
-We don't have a way to consume libraries from inside a [workspace](./workspaces) as external dependencies right now.
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md
index eeead580969..d5694250f05 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/black_box_fns.md
@@ -25,7 +25,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion)
+- [Recursive proof verification](./recursion.md)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md
index a93894043dc..f33c285cf4e 100644
--- a/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.30.0/noir/standard_library/recursion.md
@@ -35,7 +35,7 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 
 :::info
 
-This is a black box function. Read [this section](./black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
 
 :::
 
diff --git a/docs/versioned_docs/version-v0.30.0/tooling/debugger.md b/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
index 7c158d949d1..9b7565ba9ff 100644
--- a/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
+++ b/docs/versioned_docs/version-v0.30.0/tooling/debugger.md
@@ -12,7 +12,7 @@ There are currently two ways of debugging Noir programs:
 1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
 2. Via the REPL debugger, which ships with Nargo.
 
-In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation) and vscode-noir:
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
 
 - Noir & Nargo ≥0.28.0
 - Noir's VS Code extension ≥0.0.11

From 87a1d8ebaadb5f0f1ed637b96816f971f946af87 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 12 Jun 2024 09:22:45 -0500
Subject: [PATCH 362/416] fix(elaborator): Fix duplicate methods error (#5225)

# Description

## Problem\*

Resolves "duplicate method" error when declaring trait methods on
different traits with the same method name in the elaborator.

## Summary\*



## Additional Context

This was the last error type in aztec packages for the elaborator.
~~After this, there are still some extra unused variable warnings I will
fix but the entire crate tests successfully.~~ Nevermind, looks like
aztec-nr just naturally has many unused variables

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 47 ++++++++++++-------
 compiler/noirc_frontend/src/node_interner.rs  |  1 +
 .../no_duplicate_methods/Nargo.toml           |  6 +++
 .../no_duplicate_methods/Prover.toml          |  0
 .../no_duplicate_methods/src/main.nr          | 26 ++++++++++
 5 files changed, 64 insertions(+), 16 deletions(-)
 create mode 100644 test_programs/compile_success_empty/no_duplicate_methods/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/no_duplicate_methods/Prover.toml
 create mode 100644 test_programs/compile_success_empty/no_duplicate_methods/src/main.nr

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 37ad74b78b0..aee3b5c5807 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -232,23 +232,20 @@ impl<'context> Elaborator<'context> {
         // Must resolve structs before we resolve globals.
         this.collect_struct_definitions(items.types);
 
-        // Bind trait impls to their trait. Collect trait functions, that have a
-        // default implementation, which hasn't been overridden.
-        for trait_impl in &mut items.trait_impls {
-            this.collect_trait_impl(trait_impl);
-        }
-
         // Before we resolve any function symbols we must go through our impls and
         // re-collect the methods within into their proper module. This cannot be
         // done during def collection since we need to be able to resolve the type of
         // the impl since that determines the module we should collect into.
-        //
-        // These are resolved after trait impls so that struct methods are chosen
-        // over trait methods if there are name conflicts.
         for ((_self_type, module), impls) in &mut items.impls {
             this.collect_impls(*module, impls);
         }
 
+        // Bind trait impls to their trait. Collect trait functions, that have a
+        // default implementation, which hasn't been overridden.
+        for trait_impl in &mut items.trait_impls {
+            this.collect_trait_impl(trait_impl);
+        }
+
         // We must wait to resolve non-literal globals until after we resolve structs since struct
         // globals will need to reference the struct type they're initialized to to ensure they are valid.
         while let Some((_, global)) = this.unresolved_globals.pop_first() {
@@ -860,9 +857,12 @@ impl<'context> Elaborator<'context> {
         self.self_type = None;
     }
 
-    fn get_module_mut(&mut self, module: ModuleId) -> &mut ModuleData {
+    fn get_module_mut(
+        def_maps: &mut BTreeMap<CrateId, CrateDefMap>,
+        module: ModuleId,
+    ) -> &mut ModuleData {
         let message = "A crate should always be present for a given crate id";
-        &mut self.def_maps.get_mut(&module.krate).expect(message).modules[module.local_id.0]
+        &mut def_maps.get_mut(&module.krate).expect(message).modules[module.local_id.0]
     }
 
     fn declare_methods_on_struct(
@@ -890,7 +890,7 @@ impl<'context> Elaborator<'context> {
             // Grab the module defined by the struct type. Note that impls are a case
             // where the module the methods are added to is not the same as the module
             // they are resolved in.
-            let module = self.get_module_mut(struct_ref.id.module_id());
+            let module = Self::get_module_mut(self.def_maps, struct_ref.id.module_id());
 
             for (_, method_id, method) in &functions.functions {
                 // If this method was already declared, remove it from the module so it cannot
@@ -899,22 +899,37 @@ impl<'context> Elaborator<'context> {
                 // If not, that is specialization which is allowed.
                 let name = method.name_ident().clone();
                 if module.declare_function(name, ItemVisibility::Public, *method_id).is_err() {
-                    module.remove_function(method.name_ident());
+                    let existing = module.find_func_with_name(method.name_ident()).expect(
+                        "declare_function should only error if there is an existing function",
+                    );
+
+                    // Only remove the existing function from scope if it is from a trait impl as
+                    // well. If it is from a non-trait impl that should override trait impl methods
+                    // anyway so that Foo::bar always resolves to the non-trait impl version.
+                    if self.interner.function_meta(&existing).trait_impl.is_some() {
+                        module.remove_function(method.name_ident());
+                    }
                 }
             }
 
-            self.declare_struct_methods(self_type, &function_ids);
+            // Trait impl methods are already declared in NodeInterner::add_trait_implementation
+            if !is_trait_impl {
+                self.declare_methods(self_type, &function_ids);
+            }
         // We can define methods on primitive types only if we're in the stdlib
         } else if !is_trait_impl && *self_type != Type::Error {
             if self.crate_id.is_stdlib() {
-                self.declare_struct_methods(self_type, &function_ids);
+                // Trait impl methods are already declared in NodeInterner::add_trait_implementation
+                if !is_trait_impl {
+                    self.declare_methods(self_type, &function_ids);
+                }
             } else {
                 self.push_err(DefCollectorErrorKind::NonStructTypeInImpl { span });
             }
         }
     }
 
-    fn declare_struct_methods(&mut self, self_type: &Type, function_ids: &[FuncId]) {
+    fn declare_methods(&mut self, self_type: &Type, function_ids: &[FuncId]) {
         for method_id in function_ids {
             let method_name = self.interner.function_name(method_id).to_owned();
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index cef49332b00..6c5f9b6bbcb 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1466,6 +1466,7 @@ impl NodeInterner {
         force_type_check: bool,
     ) -> Option<FuncId> {
         let methods = self.struct_methods.get(&(id, method_name.to_owned()));
+
         // If there is only one method, just return it immediately.
         // It will still be typechecked later.
         if !force_type_check {
diff --git a/test_programs/compile_success_empty/no_duplicate_methods/Nargo.toml b/test_programs/compile_success_empty/no_duplicate_methods/Nargo.toml
new file mode 100644
index 00000000000..2125d475530
--- /dev/null
+++ b/test_programs/compile_success_empty/no_duplicate_methods/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "no_duplicate_methods"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/no_duplicate_methods/Prover.toml b/test_programs/compile_success_empty/no_duplicate_methods/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr b/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr
new file mode 100644
index 00000000000..2be1d3fa11e
--- /dev/null
+++ b/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr
@@ -0,0 +1,26 @@
+// Test that declaring several methods & trait methods with the same name
+// does not trigger a duplicate method error
+trait ToField {
+    fn to_field(self) -> Field;
+}
+trait ToField2 {
+    fn to_field(self) -> Field;
+}
+
+struct Foo { x: Field }
+
+impl ToField for Foo {
+    fn to_field(self) -> Field { self.x }
+}
+
+impl ToField2 for Foo {
+    fn to_field(self) -> Field { self.x }
+}
+
+impl Foo {
+    fn to_field(self) -> Field {
+        self.x
+    }
+}
+
+fn main() {}

From fde432aacc436b6c57f0d937d7c86836bac0b465 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 12 Jun 2024 10:45:58 -0500
Subject: [PATCH 363/416] fix(elaborator): Fix regression introduced by
 lazy-global changes (#5223)

# Description

## Problem\*

Fixes a regression introduced by #5191

## Summary\*

When a global is lazily evaluated, the local module id and file id of
the elaborator would change without being reset to the previous value.
This lead to scoping issues after the global was evaluated.

## Additional Context

I was unable to create a repro for this aside from running `nargo t
--use-elaborator` on `aztec-nr` unfortunately.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs     | 15 ++++++++++++---
 .../noirc_frontend/src/hir/resolution/errors.rs   |  2 +-
 .../noirc_frontend/src/hir/resolution/traits.rs   |  1 +
 compiler/noirc_frontend/src/node_interner.rs      |  7 +++++++
 4 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index aee3b5c5807..3c88a419b99 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -308,6 +308,7 @@ impl<'context> Elaborator<'context> {
         let old_function = std::mem::replace(&mut self.current_function, Some(id));
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
+        let was_in_contract = self.in_contract;
         if self.self_type.is_some() {
             self.in_contract = false;
         }
@@ -403,6 +404,7 @@ impl<'context> Elaborator<'context> {
         self.trait_bounds.clear();
         self.in_unconstrained_fn = false;
         self.interner.update_fn(id, hir_func);
+        self.in_contract = was_in_contract;
         self.current_function = old_function;
         self.current_item = old_item;
     }
@@ -544,6 +546,7 @@ impl<'context> Elaborator<'context> {
         self.current_function = Some(func_id);
 
         // Without this, impl methods can accidentally be placed in contracts. See #3254
+        let was_in_contract = self.in_contract;
         if self.self_type.is_some() {
             self.in_contract = false;
         }
@@ -659,6 +662,7 @@ impl<'context> Elaborator<'context> {
         };
 
         self.interner.push_fn_meta(meta, func_id);
+        self.in_contract = was_in_contract;
         self.current_function = None;
         self.scopes.end_function();
         self.current_item = None;
@@ -1095,6 +1099,7 @@ impl<'context> Elaborator<'context> {
         // make sure every struct's fields is accurately set.
         for id in struct_ids {
             let struct_type = self.interner.get_struct(id);
+
             // Only handle structs without generics as any generics args will be checked
             // after monomorphization when performing SSA codegen
             if struct_type.borrow().generics.is_empty() {
@@ -1129,8 +1134,8 @@ impl<'context> Elaborator<'context> {
     }
 
     fn elaborate_global(&mut self, global: UnresolvedGlobal) {
-        self.local_module = global.module_id;
-        self.file = global.file_id;
+        let old_module = std::mem::replace(&mut self.local_module, global.module_id);
+        let old_file = std::mem::replace(&mut self.file, global.file_id);
 
         let global_id = global.global_id;
         self.current_item = Some(DependencyId::Global(global_id));
@@ -1162,6 +1167,8 @@ impl<'context> Elaborator<'context> {
         // Otherwise we may prematurely default to a Field inside the next function if this
         // global was unused there, even if it is consistently used as a u8 everywhere else.
         self.type_variables.clear();
+        self.local_module = old_module;
+        self.file = old_file;
     }
 
     fn elaborate_comptime_global(&mut self, global_id: GlobalId) {
@@ -1201,11 +1208,13 @@ impl<'context> Elaborator<'context> {
             self.local_module = *local_module;
 
             for (generics, _, function_set) in function_sets {
+                self.file = function_set.file_id;
                 self.add_generics(generics);
                 let self_type = self.resolve_type(self_type.clone());
                 function_set.self_type = Some(self_type.clone());
                 self.self_type = Some(self_type);
                 self.define_function_metas_for_functions(function_set);
+                self.self_type = None;
                 self.generics.clear();
             }
         }
@@ -1220,10 +1229,10 @@ impl<'context> Elaborator<'context> {
 
             let trait_generics =
                 vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
+
             trait_impl.resolved_trait_generics = trait_generics;
 
             let self_type = self.resolve_type(unresolved_type.clone());
-
             self.self_type = Some(self_type.clone());
             trait_impl.methods.self_type = Some(self_type);
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 06f6dda7142..07fbde4db8e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -319,7 +319,7 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 "Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library".into(),
                 ident.span(),
             ),
-            ResolverError::OracleMarkedAsConstrained { ident } => Diagnostic::simple_error(
+            ResolverError::OracleMarkedAsConstrained { ident } => Diagnostic::simple_warning(
                 error.to_string(),
                 "Oracle functions must have the `unconstrained` keyword applied".into(),
                 ident.span(),
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index 3d355fd4447..4c360731711 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -300,6 +300,7 @@ fn collect_trait_impl(
         let file = def_maps[&crate_id].file_id(trait_impl.module_id);
         let mut resolver = Resolver::new(interner, &path_resolver, def_maps, file);
         resolver.add_generics(&trait_impl.generics);
+
         let typ = resolver.resolve_type(unresolved_type);
         errors.extend(take_errors(trait_impl.file_id, resolver));
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 6c5f9b6bbcb..e29c3183993 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1411,6 +1411,13 @@ impl NodeInterner {
     ) -> Result<(), (Span, FileId)> {
         self.trait_implementations.insert(impl_id, trait_impl.clone());
 
+        // Avoid adding error types to impls since they'll conflict with every other type.
+        // We don't need to return an error since we expect an error to already be issued when
+        // the error type is created.
+        if object_type == Type::Error {
+            return Ok(());
+        }
+
         // Replace each generic with a fresh type variable
         let substitutions = impl_generics
             .into_iter()

From 802cd951d90bfdb44e7a6b435ab852369c3a6f8d Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 12 Jun 2024 14:34:32 -0500
Subject: [PATCH 364/416] chore: Optimize the elaborator (#5230)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5194

## Summary\*

Fixes a performance issue where the elaborator was ~2x as slow running
`nargo t --use-elaborator` on aztec-nr versus the same tests without the
elaborator (4s versus 2s).

Found via flamegraph - `self.type_variables` wasn't cleared after each
function was elaborated. This Vec is meant to just store type variables
local to a function so that we can check if any need type hints after it
is done but since it wasn't cleared out, we'd be checking an
increasingly large Vec for each function.

## Additional Context

With this change the elaborator is slightly faster (but not noticeably)
than our current code. 1.9 versus 2.0s average across 10 runs for `nargo
t` (with lower std. deviation than our current code as well).

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 3c88a419b99..3b8158667f9 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -402,6 +402,7 @@ impl<'context> Elaborator<'context> {
         meta.function_body = FunctionBody::Resolved;
 
         self.trait_bounds.clear();
+        self.type_variables.clear();
         self.in_unconstrained_fn = false;
         self.interner.update_fn(id, hir_func);
         self.in_contract = was_in_contract;

From 939bad2b20f0ca884d9a1ccbcee1ba3451621458 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 12 Jun 2024 14:56:47 -0500
Subject: [PATCH 365/416] chore: Parse macros (#5229)

# Description

## Problem\*

## Summary\*

To try to make it easier to review I'm breaking the parser related
changes here out #5203.

## Additional Context

It turns out `parser/types.rs` was never in our module tree. I've added
it and removed the duplicate parsers for parsing types that were in
`parser/parser.rs`. They've had some changes since the copies in
`parser/types.rs` were first changed so I've updated those as well.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 aztec_macros/src/utils/ast_utils.rs           |   7 +-
 compiler/noirc_frontend/src/ast/expression.rs |  41 ++-
 compiler/noirc_frontend/src/ast/mod.rs        |  12 +-
 compiler/noirc_frontend/src/ast/statement.rs  |   1 +
 compiler/noirc_frontend/src/debug/mod.rs      |   4 +
 .../src/elaborator/expressions.rs             |   2 +-
 .../src/hir/resolution/resolver.rs            |   2 +-
 compiler/noirc_frontend/src/lexer/lexer.rs    |   1 +
 compiler/noirc_frontend/src/lexer/token.rs    |   9 +
 compiler/noirc_frontend/src/parser/parser.rs  | 283 +++---------------
 .../noirc_frontend/src/parser/parser/types.rs | 139 ++++++---
 tooling/nargo_fmt/src/rewrite/expr.rs         |  10 +-
 tooling/nargo_fmt/tests/expected/let.nr       |   4 +-
 tooling/nargo_fmt/tests/input/let.nr          |   4 +-
 14 files changed, 220 insertions(+), 299 deletions(-)

diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index 4706be2df25..48b3b25747b 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -47,12 +47,17 @@ pub fn method_call(
         object,
         method_name: ident(method_name),
         arguments,
+        is_macro_call: false,
         generics: None,
     })))
 }
 
 pub fn call(func: Expression, arguments: Vec<Expression>) -> Expression {
-    expression(ExpressionKind::Call(Box::new(CallExpression { func: Box::new(func), arguments })))
+    expression(ExpressionKind::Call(Box::new(CallExpression {
+        func: Box::new(func),
+        is_macro_call: false,
+        arguments,
+    })))
 }
 
 pub fn pattern(name: &str) -> Pattern {
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 50836add8de..da2d3646b20 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -33,7 +33,7 @@ pub enum ExpressionKind {
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
-    Quote(BlockExpression),
+    Quote(BlockExpression, Span),
     Comptime(BlockExpression, Span),
 
     // This variant is only emitted when inlining the result of comptime
@@ -179,19 +179,21 @@ impl Expression {
 
     pub fn member_access_or_method_call(
         lhs: Expression,
-        (rhs, args): UnaryRhsMemberAccess,
+        rhs: UnaryRhsMemberAccess,
         span: Span,
     ) -> Expression {
-        let kind = match args {
-            None => ExpressionKind::MemberAccess(Box::new(MemberAccessExpression { lhs, rhs })),
-            Some((generics, arguments)) => {
-                ExpressionKind::MethodCall(Box::new(MethodCallExpression {
-                    object: lhs,
-                    method_name: rhs,
-                    generics,
-                    arguments,
-                }))
+        let kind = match rhs.method_call {
+            None => {
+                let rhs = rhs.method_or_field;
+                ExpressionKind::MemberAccess(Box::new(MemberAccessExpression { lhs, rhs }))
             }
+            Some(method_call) => ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+                object: lhs,
+                method_name: rhs.method_or_field,
+                generics: method_call.turbofish,
+                arguments: method_call.args,
+                is_macro_call: method_call.macro_call,
+            })),
         };
         Expression::new(kind, span)
     }
@@ -206,7 +208,12 @@ impl Expression {
         Expression::new(kind, span)
     }
 
-    pub fn call(lhs: Expression, arguments: Vec<Expression>, span: Span) -> Expression {
+    pub fn call(
+        lhs: Expression,
+        is_macro_call: bool,
+        arguments: Vec<Expression>,
+        span: Span,
+    ) -> Expression {
         // Need to check if lhs is an if expression since users can sequence if expressions
         // with tuples without calling them. E.g. `if c { t } else { e }(a, b)` is interpreted
         // as a sequence of { if, tuple } rather than a function call. This behavior matches rust.
@@ -224,7 +231,11 @@ impl Expression {
                 ],
             })
         } else {
-            ExpressionKind::Call(Box::new(CallExpression { func: Box::new(lhs), arguments }))
+            ExpressionKind::Call(Box::new(CallExpression {
+                func: Box::new(lhs),
+                is_macro_call,
+                arguments,
+            }))
         };
         Expression::new(kind, span)
     }
@@ -447,6 +458,7 @@ pub enum ArrayLiteral {
 pub struct CallExpression {
     pub func: Box<Expression>,
     pub arguments: Vec<Expression>,
+    pub is_macro_call: bool,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -456,6 +468,7 @@ pub struct MethodCallExpression {
     /// Method calls have an optional list of generics if the turbofish operator was used
     pub generics: Option<Vec<UnresolvedType>>,
     pub arguments: Vec<Expression>,
+    pub is_macro_call: bool,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -535,7 +548,7 @@ impl Display for ExpressionKind {
             }
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
-            Quote(block) => write!(f, "quote {block}"),
+            Quote(block, _) => write!(f, "quote {block}"),
             Comptime(block, _) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index bd2b45d9c48..c09ad75818a 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -134,8 +134,16 @@ pub struct UnresolvedType {
 }
 
 /// Type wrapper for a member access
-pub(crate) type UnaryRhsMemberAccess =
-    (Ident, Option<(Option<Vec<UnresolvedType>>, Vec<Expression>)>);
+pub struct UnaryRhsMemberAccess {
+    pub method_or_field: Ident,
+    pub method_call: Option<UnaryRhsMethodCall>,
+}
+
+pub struct UnaryRhsMethodCall {
+    pub turbofish: Option<Vec<UnresolvedType>>,
+    pub macro_call: bool,
+    pub args: Vec<Expression>,
+}
 
 /// The precursor to TypeExpression, this is the type that the parser allows
 /// to be used in the length position of an array type. Only constants, variables,
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 9b2c0fbfee8..57a62324064 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -608,6 +608,7 @@ impl ForRange {
                     object: Expression::new(array_ident.clone(), array_span),
                     method_name: Ident::new("len".to_string(), array_span),
                     generics: None,
+                    is_macro_call: false,
                     arguments: vec![],
                 }));
                 let end_range = Expression::new(end_range, array_span);
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index c222e08e77a..f5866f5b756 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -581,6 +581,7 @@ fn build_assign_var_stmt(var_id: SourceVarId, expr: ast::Expression) -> ast::Sta
             ),
             span,
         }),
+        is_macro_call: false,
         arguments: vec![uint_expr(var_id.0 as u128, span), expr],
     }));
     ast::Statement { kind: ast::StatementKind::Semi(ast::Expression { kind, span }), span }
@@ -599,6 +600,7 @@ fn build_drop_var_stmt(var_id: SourceVarId, span: Span) -> ast::Statement {
             ),
             span,
         }),
+        is_macro_call: false,
         arguments: vec![uint_expr(var_id.0 as u128, span)],
     }));
     ast::Statement { kind: ast::StatementKind::Semi(ast::Expression { kind, span }), span }
@@ -626,6 +628,7 @@ fn build_assign_member_stmt(
             ),
             span,
         }),
+        is_macro_call: false,
         arguments: [
             vec![uint_expr(var_id.0 as u128, span)],
             vec![expr.clone()],
@@ -649,6 +652,7 @@ fn build_debug_call_stmt(fname: &str, fn_id: DebugFnId, span: Span) -> ast::Stat
             ),
             span,
         }),
+        is_macro_call: false,
         arguments: vec![uint_expr(fn_id.0 as u128, span)],
     }));
     ast::Statement { kind: ast::StatementKind::Semi(ast::Expression { kind, span }), span }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index a922f552c4b..c1c6945707b 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -58,7 +58,7 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Tuple(tuple) => self.elaborate_tuple(tuple),
             ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
             ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
-            ExpressionKind::Quote(quote) => self.elaborate_quote(quote),
+            ExpressionKind::Quote(quote, _) => self.elaborate_quote(quote),
             ExpressionKind::Comptime(comptime, _) => {
                 return self.elaborate_comptime_block(comptime, expr.span)
             }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 01f58ba4c27..133f971da19 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1641,7 +1641,7 @@ impl<'a> Resolver<'a> {
             ExpressionKind::Parenthesized(sub_expr) => return self.resolve_expression(*sub_expr),
 
             // The quoted expression isn't resolved since we don't want errors if variables aren't defined
-            ExpressionKind::Quote(block) => HirExpression::Quote(block),
+            ExpressionKind::Quote(block, _) => HirExpression::Quote(block),
             ExpressionKind::Comptime(block, _) => {
                 HirExpression::Comptime(self.resolve_block(block))
             }
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index 2d1ebf530e3..3d052e22e36 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -141,6 +141,7 @@ impl<'a> Lexer<'a> {
             Some('}') => self.single_char_token(Token::RightBrace),
             Some('[') => self.single_char_token(Token::LeftBracket),
             Some(']') => self.single_char_token(Token::RightBracket),
+            Some('$') => self.single_char_token(Token::DollarSign),
             Some('"') => self.eat_string_literal(),
             Some('f') => self.eat_format_string_or_alpha_numeric(),
             Some('r') => self.eat_raw_string_or_alpha_numeric(),
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index d8555b4fbf7..2199333e90f 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -85,6 +85,8 @@ pub enum BorrowedToken<'input> {
     Semicolon,
     /// !
     Bang,
+    /// $
+    DollarSign,
     /// =
     Assign,
     #[allow(clippy::upper_case_acronyms)]
@@ -179,6 +181,8 @@ pub enum Token {
     Bang,
     /// =
     Assign,
+    /// $
+    DollarSign,
     #[allow(clippy::upper_case_acronyms)]
     EOF,
 
@@ -238,6 +242,7 @@ pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
         Token::Semicolon => BorrowedToken::Semicolon,
         Token::Assign => BorrowedToken::Assign,
         Token::Bang => BorrowedToken::Bang,
+        Token::DollarSign => BorrowedToken::DollarSign,
         Token::EOF => BorrowedToken::EOF,
         Token::Invalid(c) => BorrowedToken::Invalid(*c),
         Token::Whitespace(ref s) => BorrowedToken::Whitespace(s),
@@ -349,6 +354,7 @@ impl fmt::Display for Token {
             Token::Semicolon => write!(f, ";"),
             Token::Assign => write!(f, "="),
             Token::Bang => write!(f, "!"),
+            Token::DollarSign => write!(f, "$"),
             Token::EOF => write!(f, "end of input"),
             Token::Invalid(c) => write!(f, "{c}"),
             Token::Whitespace(ref s) => write!(f, "{s}"),
@@ -840,6 +846,7 @@ pub enum Keyword {
     Crate,
     Dep,
     Else,
+    Expr,
     Field,
     Fn,
     For,
@@ -884,6 +891,7 @@ impl fmt::Display for Keyword {
             Keyword::Crate => write!(f, "crate"),
             Keyword::Dep => write!(f, "dep"),
             Keyword::Else => write!(f, "else"),
+            Keyword::Expr => write!(f, "Expr"),
             Keyword::Field => write!(f, "Field"),
             Keyword::Fn => write!(f, "fn"),
             Keyword::For => write!(f, "for"),
@@ -931,6 +939,7 @@ impl Keyword {
             "crate" => Keyword::Crate,
             "dep" => Keyword::Dep,
             "else" => Keyword::Else,
+            "Expr" => Keyword::Expr,
             "Field" => Keyword::Field,
             "fn" => Keyword::Fn,
             "for" => Keyword::For,
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index cabc788e07d..5107e10f4df 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -24,6 +24,7 @@
 //! be limited to cases like the above `fn` example where it is clear we shouldn't back out of the
 //! current parser to try alternative parsers in a `choice` expression.
 use self::primitives::{keyword, mutable_reference, variable};
+use self::types::{generic_type_args, maybe_comp_time, parse_type};
 
 use super::{
     foldl_with_span, labels::ParsingRuleLabel, parameter_name_recovery, parameter_recovery,
@@ -35,8 +36,8 @@ use super::{spanned, Item, ItemKind};
 use crate::ast::{
     BinaryOp, BinaryOpKind, BlockExpression, ForLoopStatement, ForRange, Ident, IfExpression,
     InfixExpression, LValue, Literal, ModuleDeclaration, NoirTypeAlias, Param, Path, Pattern,
-    Recoverable, Statement, TraitBound, TypeImpl, UnaryRhsMemberAccess, UnresolvedTraitConstraint,
-    UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
+    Recoverable, Statement, TraitBound, TypeImpl, UnaryRhsMemberAccess, UnaryRhsMethodCall,
+    UnresolvedTraitConstraint, UseTree, UseTreeKind, Visibility,
 };
 use crate::ast::{
     Expression, ExpressionKind, LetStatement, StatementKind, UnresolvedType, UnresolvedTypeData,
@@ -59,6 +60,7 @@ mod path;
 mod primitives;
 mod structs;
 mod traits;
+mod types;
 
 // synthesized by LALRPOP
 lalrpop_mod!(pub noir_parser);
@@ -674,41 +676,6 @@ where
     })
 }
 
-fn parse_type<'a>() -> impl NoirParser<UnresolvedType> + 'a {
-    recursive(parse_type_inner)
-}
-
-fn parse_type_inner<'a>(
-    recursive_type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    choice((
-        field_type(),
-        int_type(),
-        bool_type(),
-        string_type(),
-        format_string_type(recursive_type_parser.clone()),
-        named_type(recursive_type_parser.clone()),
-        named_trait(recursive_type_parser.clone()),
-        slice_type(recursive_type_parser.clone()),
-        array_type(recursive_type_parser.clone()),
-        parenthesized_type(recursive_type_parser.clone()),
-        tuple_type(recursive_type_parser.clone()),
-        function_type(recursive_type_parser.clone()),
-        mutable_reference_type(recursive_type_parser),
-    ))
-}
-
-fn parenthesized_type(
-    recursive_type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
-    recursive_type_parser
-        .delimited_by(just(Token::LeftParen), just(Token::RightParen))
-        .map_with_span(|typ, span| UnresolvedType {
-            typ: UnresolvedTypeData::Parenthesized(Box::new(typ)),
-            span: span.into(),
-        })
-}
-
 fn optional_visibility() -> impl NoirParser<Visibility> {
     keyword(Keyword::Pub)
         .or(keyword(Keyword::CallData))
@@ -724,187 +691,6 @@ fn optional_visibility() -> impl NoirParser<Visibility> {
         })
 }
 
-fn maybe_comp_time() -> impl NoirParser<bool> {
-    keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
-        if opt.is_some() {
-            emit(ParserError::with_reason(
-                ParserErrorReason::ExperimentalFeature("Comptime values"),
-                span,
-            ));
-        }
-        opt.is_some()
-    })
-}
-
-fn field_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Field)
-        .map_with_span(|_, span| UnresolvedTypeData::FieldElement.with_span(span))
-}
-
-fn bool_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Bool).map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
-}
-
-fn string_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::String)
-        .ignore_then(type_expression().delimited_by(just(Token::Less), just(Token::Greater)))
-        .map_with_span(|expr, span| UnresolvedTypeData::String(expr).with_span(span))
-}
-
-fn format_string_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    keyword(Keyword::FormatString)
-        .ignore_then(
-            type_expression()
-                .then_ignore(just(Token::Comma))
-                .then(type_parser)
-                .delimited_by(just(Token::Less), just(Token::Greater)),
-        )
-        .map_with_span(|(size, fields), span| {
-            UnresolvedTypeData::FormatString(size, Box::new(fields)).with_span(span)
-        })
-}
-
-fn int_type() -> impl NoirParser<UnresolvedType> {
-    filter_map(|span, token: Token| match token {
-        Token::IntType(int_type) => Ok(int_type),
-        unexpected => {
-            Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
-        }
-    })
-    .validate(|token, span, emit| {
-        UnresolvedTypeData::from_int_token(token).map(|data| data.with_span(span)).unwrap_or_else(
-            |err| {
-                emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
-                UnresolvedType::error(span)
-            },
-        )
-    })
-}
-
-fn named_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    path().then(generic_type_args(type_parser)).map_with_span(|(path, args), span| {
-        UnresolvedTypeData::Named(path, args, false).with_span(span)
-    })
-}
-
-fn named_trait<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    keyword(Keyword::Impl).ignore_then(path()).then(generic_type_args(type_parser)).map_with_span(
-        |(path, args), span| UnresolvedTypeData::TraitAsType(path, args).with_span(span),
-    )
-}
-
-fn generic_type_args<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<Vec<UnresolvedType>> + 'a {
-    type_parser
-        .clone()
-        // Without checking for a terminating ',' or '>' here we may incorrectly
-        // parse a generic `N * 2` as just the type `N` then fail when there is no
-        // separator afterward. Failing early here ensures we try the `type_expression`
-        // parser afterward.
-        .then_ignore(one_of([Token::Comma, Token::Greater]).rewind())
-        .or(type_expression()
-            .map_with_span(|expr, span| UnresolvedTypeData::Expression(expr).with_span(span)))
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .at_least(1)
-        .delimited_by(just(Token::Less), just(Token::Greater))
-        .or_not()
-        .map(Option::unwrap_or_default)
-}
-
-fn array_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    just(Token::LeftBracket)
-        .ignore_then(type_parser)
-        .then(just(Token::Semicolon).ignore_then(type_expression()))
-        .then_ignore(just(Token::RightBracket))
-        .map_with_span(|(element_type, size), span| {
-            UnresolvedTypeData::Array(size, Box::new(element_type)).with_span(span)
-        })
-}
-
-fn slice_type(type_parser: impl NoirParser<UnresolvedType>) -> impl NoirParser<UnresolvedType> {
-    just(Token::LeftBracket)
-        .ignore_then(type_parser)
-        .then_ignore(just(Token::RightBracket))
-        .map_with_span(|element_type, span| {
-            UnresolvedTypeData::Slice(Box::new(element_type)).with_span(span)
-        })
-}
-
-fn type_expression() -> impl NoirParser<UnresolvedTypeExpression> {
-    recursive(|expr| {
-        expression_with_precedence(
-            Precedence::lowest_type_precedence(),
-            expr,
-            nothing(),
-            nothing(),
-            true,
-            false,
-        )
-    })
-    .labelled(ParsingRuleLabel::TypeExpression)
-    .try_map(UnresolvedTypeExpression::from_expr)
-}
-
-fn tuple_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
-where
-    T: NoirParser<UnresolvedType>,
-{
-    let fields = type_parser.separated_by(just(Token::Comma)).allow_trailing();
-    parenthesized(fields).map_with_span(|fields, span| {
-        if fields.is_empty() {
-            UnresolvedTypeData::Unit.with_span(span)
-        } else {
-            UnresolvedTypeData::Tuple(fields).with_span(span)
-        }
-    })
-}
-
-fn function_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
-where
-    T: NoirParser<UnresolvedType>,
-{
-    let args = parenthesized(type_parser.clone().separated_by(just(Token::Comma)).allow_trailing());
-
-    let env = just(Token::LeftBracket)
-        .ignore_then(type_parser.clone())
-        .then_ignore(just(Token::RightBracket))
-        .or_not()
-        .map_with_span(|t, span| {
-            t.unwrap_or_else(|| UnresolvedTypeData::Unit.with_span(Span::empty(span.end())))
-        });
-
-    keyword(Keyword::Fn)
-        .ignore_then(env)
-        .then(args)
-        .then_ignore(just(Token::Arrow))
-        .then(type_parser)
-        .map_with_span(|((env, args), ret), span| {
-            UnresolvedTypeData::Function(args, Box::new(ret), Box::new(env)).with_span(span)
-        })
-}
-
-fn mutable_reference_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
-where
-    T: NoirParser<UnresolvedType>,
-{
-    just(Token::Ampersand)
-        .ignore_then(keyword(Keyword::Mut))
-        .ignore_then(type_parser)
-        .map_with_span(|element, span| {
-            UnresolvedTypeData::MutableReference(Box::new(element)).with_span(span)
-        })
-}
-
 fn expression() -> impl ExprParser {
     recursive(|expr| {
         expression_with_precedence(
@@ -1073,14 +859,18 @@ where
     S: NoirParser<StatementKind> + 'a,
 {
     enum UnaryRhs {
-        Call(Vec<Expression>),
+        Call((Option<Token>, Vec<Expression>)),
         ArrayIndex(Expression),
         Cast(UnresolvedType),
         MemberAccess(UnaryRhsMemberAccess),
     }
 
     // `(arg1, ..., argN)` in `my_func(arg1, ..., argN)`
-    let call_rhs = parenthesized(expression_list(expr_parser.clone())).map(UnaryRhs::Call);
+    // Optionally accepts a leading `!` for macro calls.
+    let call_rhs = just(Token::Bang)
+        .or_not()
+        .then(parenthesized(expression_list(expr_parser.clone())))
+        .map(UnaryRhs::Call);
 
     // `[expr]` in `arr[expr]`
     let array_rhs = expr_parser
@@ -1097,11 +887,23 @@ where
     // A turbofish operator is optional in a method call to specify generic types
     let turbofish = primitives::turbofish(type_parser);
 
+    // `::<A, B>!(arg1, .., argN)` with the turbofish and macro portions being optional.
+    let method_call_rhs = turbofish
+        .then(just(Token::Bang).or_not())
+        .then(parenthesized(expression_list(expr_parser.clone())))
+        .map(|((turbofish, macro_call), args)| UnaryRhsMethodCall {
+            turbofish,
+            macro_call: macro_call.is_some(),
+            args,
+        });
+
     // `.foo` or `.foo(args)` in `atom.foo` or `atom.foo(args)`
     let member_rhs = just(Token::Dot)
         .ignore_then(field_name())
-        .then(turbofish.then(parenthesized(expression_list(expr_parser.clone()))).or_not())
-        .map(UnaryRhs::MemberAccess)
+        .then(method_call_rhs.or_not())
+        .map(|(method_or_field, method_call)| {
+            UnaryRhs::MemberAccess(UnaryRhsMemberAccess { method_or_field, method_call })
+        })
         .labelled(ParsingRuleLabel::FieldAccess);
 
     let rhs = choice((call_rhs, array_rhs, cast_rhs, member_rhs));
@@ -1110,7 +912,9 @@ where
         atom(expr_parser, expr_no_constructors, statement, allow_constructors),
         rhs,
         |lhs, rhs, span| match rhs {
-            UnaryRhs::Call(args) => Expression::call(lhs, args, span),
+            UnaryRhs::Call((is_macro, args)) => {
+                Expression::call(lhs, is_macro.is_some(), args, span)
+            }
             UnaryRhs::ArrayIndex(index) => Expression::index(lhs, index, span),
             UnaryRhs::Cast(r#type) => Expression::cast(lhs, r#type, span),
             UnaryRhs::MemberAccess(field) => {
@@ -1272,6 +1076,7 @@ where
         block(statement.clone()).map(ExpressionKind::Block),
         comptime_expr(statement.clone()),
         quote(statement),
+        unquote(expr_parser.clone()),
         variable(),
         literal(),
     ))
@@ -1300,13 +1105,26 @@ fn quote<'a, P>(statement: P) -> impl NoirParser<ExpressionKind> + 'a
 where
     P: NoirParser<StatementKind> + 'a,
 {
-    keyword(Keyword::Quote).ignore_then(block(statement)).validate(|block, span, emit| {
-        emit(ParserError::with_reason(
-            ParserErrorReason::ExperimentalFeature("quoted expressions"),
-            span,
-        ));
-        ExpressionKind::Quote(block)
-    })
+    keyword(Keyword::Quote).ignore_then(spanned(block(statement))).validate(
+        |(block, block_span), span, emit| {
+            emit(ParserError::with_reason(
+                ParserErrorReason::ExperimentalFeature("quoted expressions"),
+                span,
+            ));
+            ExpressionKind::Quote(block, block_span)
+        },
+    )
+}
+
+/// unquote: '$' variable
+///        | '$' '(' expression ')'
+fn unquote<'a, P>(expr_parser: P) -> impl NoirParser<ExpressionKind> + 'a
+where
+    P: ExprParser + 'a,
+{
+    let unquote = variable().map_with_span(Expression::new).or(parenthesized(expr_parser));
+    // This will be updated to ExpressionKind::Unquote in a later PR
+    just(Token::DollarSign).ignore_then(unquote).map(|_| ExpressionKind::Error)
 }
 
 fn tuple<P>(expr_parser: P) -> impl NoirParser<Expression>
@@ -1452,11 +1270,6 @@ mod test {
         );
     }
 
-    #[test]
-    fn parse_type_expression() {
-        parse_all(type_expression(), vec!["(123)", "123", "(1 + 1)", "(1 + (1))"]);
-    }
-
     #[test]
     fn parse_array_sugar() {
         let valid = vec!["[0;7]", "[(1, 2); 4]", "[0;Four]", "[2;1+3-a]"];
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index 82dd3dad681..a79a2ef67f2 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -1,22 +1,38 @@
 use super::{
-    expression_with_precedence, keyword, nothing, parenthesized, NoirParser, ParserError,
+    expression_with_precedence, keyword, nothing, parenthesized, path, NoirParser, ParserError,
     ParserErrorReason, Precedence,
 };
-use crate::ast::{UnresolvedType, UnresolvedTypeData};
+use crate::ast::{Recoverable, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression};
 
 use crate::parser::labels::ParsingRuleLabel;
 use crate::token::{Keyword, Token};
-use crate::{Recoverable, UnresolvedTypeExpression};
 
 use chumsky::prelude::*;
 use noirc_errors::Span;
 
-fn maybe_comp_time() -> impl NoirParser<()> {
-    keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
-        if opt.is_some() {
-            emit(ParserError::with_reason(ParserErrorReason::ComptimeDeprecated, span));
-        }
-    })
+pub(super) fn parse_type<'a>() -> impl NoirParser<UnresolvedType> + 'a {
+    recursive(parse_type_inner)
+}
+
+pub(super) fn parse_type_inner<'a>(
+    recursive_type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
+    choice((
+        field_type(),
+        int_type(),
+        bool_type(),
+        string_type(),
+        expr_type(),
+        format_string_type(recursive_type_parser.clone()),
+        named_type(recursive_type_parser.clone()),
+        named_trait(recursive_type_parser.clone()),
+        slice_type(recursive_type_parser.clone()),
+        array_type(recursive_type_parser.clone()),
+        parenthesized_type(recursive_type_parser.clone()),
+        tuple_type(recursive_type_parser.clone()),
+        function_type(recursive_type_parser.clone()),
+        mutable_reference_type(recursive_type_parser),
+    ))
 }
 
 pub(super) fn parenthesized_type(
@@ -30,29 +46,41 @@ pub(super) fn parenthesized_type(
         })
 }
 
+pub(super) fn maybe_comp_time() -> impl NoirParser<bool> {
+    keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
+        if opt.is_some() {
+            emit(ParserError::with_reason(
+                ParserErrorReason::ExperimentalFeature("Comptime values"),
+                span,
+            ));
+        }
+        opt.is_some()
+    })
+}
+
 pub(super) fn field_type() -> impl NoirParser<UnresolvedType> {
-    maybe_comp_time()
-        .then_ignore(keyword(Keyword::Field))
+    keyword(Keyword::Field)
         .map_with_span(|_, span| UnresolvedTypeData::FieldElement.with_span(span))
 }
 
 pub(super) fn bool_type() -> impl NoirParser<UnresolvedType> {
-    maybe_comp_time()
-        .then_ignore(keyword(Keyword::Bool))
-        .map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
+    keyword(Keyword::Bool).map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
+}
+
+/// This is the type `Expr` - the type of a quoted, untyped expression object used for macros
+pub(super) fn expr_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::Expr).map_with_span(|_, span| UnresolvedTypeData::Code.with_span(span))
 }
 
 pub(super) fn string_type() -> impl NoirParser<UnresolvedType> {
     keyword(Keyword::String)
-        .ignore_then(
-            type_expression().delimited_by(just(Token::Less), just(Token::Greater)).or_not(),
-        )
+        .ignore_then(type_expression().delimited_by(just(Token::Less), just(Token::Greater)))
         .map_with_span(|expr, span| UnresolvedTypeData::String(expr).with_span(span))
 }
 
-pub(super) fn format_string_type(
-    type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
+pub(super) fn format_string_type<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     keyword(Keyword::FormatString)
         .ignore_then(
             type_expression()
@@ -66,26 +94,61 @@ pub(super) fn format_string_type(
 }
 
 pub(super) fn int_type() -> impl NoirParser<UnresolvedType> {
-    maybe_comp_time()
-        .then(filter_map(|span, token: Token| match token {
-            Token::IntType(int_type) => Ok(int_type),
-            unexpected => {
-                Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
-            }
-        }))
-        .validate(|(_, token), span, emit| {
-            UnresolvedTypeData::from_int_token(token)
-                .map(|data| data.with_span(span))
-                .unwrap_or_else(|err| {
-                    emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
-                    UnresolvedType::error(span)
-                })
-        })
+    filter_map(|span, token: Token| match token {
+        Token::IntType(int_type) => Ok(int_type),
+        unexpected => {
+            Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
+        }
+    })
+    .validate(|token, span, emit| {
+        UnresolvedTypeData::from_int_token(token).map(|data| data.with_span(span)).unwrap_or_else(
+            |err| {
+                emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
+                UnresolvedType::error(span)
+            },
+        )
+    })
 }
 
-pub(super) fn array_type(
-    type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
+pub(super) fn named_type<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
+    path().then(generic_type_args(type_parser)).map_with_span(|(path, args), span| {
+        UnresolvedTypeData::Named(path, args, false).with_span(span)
+    })
+}
+
+pub(super) fn named_trait<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
+    keyword(Keyword::Impl).ignore_then(path()).then(generic_type_args(type_parser)).map_with_span(
+        |(path, args), span| UnresolvedTypeData::TraitAsType(path, args).with_span(span),
+    )
+}
+
+pub(super) fn generic_type_args<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<Vec<UnresolvedType>> + 'a {
+    type_parser
+        .clone()
+        // Without checking for a terminating ',' or '>' here we may incorrectly
+        // parse a generic `N * 2` as just the type `N` then fail when there is no
+        // separator afterward. Failing early here ensures we try the `type_expression`
+        // parser afterward.
+        .then_ignore(one_of([Token::Comma, Token::Greater]).rewind())
+        .or(type_expression()
+            .map_with_span(|expr, span| UnresolvedTypeData::Expression(expr).with_span(span)))
+        .separated_by(just(Token::Comma))
+        .allow_trailing()
+        .at_least(1)
+        .delimited_by(just(Token::Less), just(Token::Greater))
+        .or_not()
+        .map(Option::unwrap_or_default)
+}
+
+pub(super) fn array_type<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<UnresolvedType> + 'a {
     just(Token::LeftBracket)
         .ignore_then(type_parser)
         .then(just(Token::Semicolon).ignore_then(type_expression()))
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 7ff943aea62..1d450bb7e28 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -63,7 +63,8 @@ pub(crate) fn rewrite(
                 NewlineMode::IfContainsNewLineAndWidth,
             );
 
-            format!("{callee}{args}")
+            let bang = if call_expr.is_macro_call { "!" } else { "" };
+            format!("{callee}{bang}{args}")
         }
         ExpressionKind::MethodCall(method_call_expr) => {
             let args_span = visitor.span_before(
@@ -85,7 +86,8 @@ pub(crate) fn rewrite(
                 NewlineMode::IfContainsNewLineAndWidth,
             );
 
-            format!("{object}.{method}{turbofish}{args}")
+            let bang = if method_call_expr.is_macro_call { "!" } else { "" };
+            format!("{object}.{method}{turbofish}{bang}{args}")
         }
         ExpressionKind::MemberAccess(member_access_expr) => {
             let lhs_str = rewrite_sub_expr(visitor, shape, member_access_expr.lhs);
@@ -166,7 +168,9 @@ pub(crate) fn rewrite(
             format!("{path_string}{turbofish}")
         }
         ExpressionKind::Lambda(_) => visitor.slice(span).to_string(),
-        ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
+        ExpressionKind::Quote(block, block_span) => {
+            format!("quote {}", rewrite_block(visitor, block, block_span))
+        }
         ExpressionKind::Comptime(block, block_span) => {
             format!("comptime {}", rewrite_block(visitor, block, block_span))
         }
diff --git a/tooling/nargo_fmt/tests/expected/let.nr b/tooling/nargo_fmt/tests/expected/let.nr
index c57801155a0..7ff69e74306 100644
--- a/tooling/nargo_fmt/tests/expected/let.nr
+++ b/tooling/nargo_fmt/tests/expected/let.nr
@@ -44,12 +44,12 @@ fn let_() {
         }
     };
 
-    let expr = Expr {
+    let expr = MyExpr {
         // A boolean literal (true, false).
         kind: ExprKind::Bool(true)
     };
 
-    let expr = Expr { /*A boolean literal (true, false).*/ kind: ExprKind::Bool(true) };
+    let expr = MyExpr { /*A boolean literal (true, false).*/ kind: ExprKind::Bool(true) };
 
     let mut V = dep::crate2::MyStruct { Q: x };
     let mut V = dep::crate2::MyStruct {};
diff --git a/tooling/nargo_fmt/tests/input/let.nr b/tooling/nargo_fmt/tests/input/let.nr
index 67c4ab8bd52..37cdc6655c7 100644
--- a/tooling/nargo_fmt/tests/input/let.nr
+++ b/tooling/nargo_fmt/tests/input/let.nr
@@ -20,11 +20,11 @@ fn let_() {
 
     let person = Person { first_name: "John", last_name: "Doe", home_address: Address { street: "123 Main St", city: "Exampleville", zip_code: "12345", master: Person { first_name: "John", last_name: "Doe", home_address: Address { street: "123 Main St", city: "Exampleville", zip_code: "12345" } } } };
 
-    let expr = Expr {// A boolean literal (true, false).
+    let expr = MyExpr {// A boolean literal (true, false).
 kind: ExprKind::Bool(true),
     };
 
-    let expr = Expr {/*A boolean literal (true, false).*/kind: ExprKind::Bool(true),};
+    let expr = MyExpr {/*A boolean literal (true, false).*/kind: ExprKind::Bool(true),};
 
     let mut V = dep::crate2::MyStruct { Q: x };
     let mut V = dep::crate2::MyStruct {};

From f846879dd038328bd0a1d39a72b448ef52a1002b Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 13 Jun 2024 13:30:42 +0200
Subject: [PATCH 366/416] fix: add support for nested arrays returned by
 oracles (#5132)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves #4561

## Summary\*
Generates brillig arrays of arrays during brillig-gen for types having
nested arrays.
Populate these nested brillig arrays in the brillig VM when data
returned from oracles does not match the size of the outer array


## Additional Context
For this to work, it is required that the oracle returns flatten values,
although its Noir signature is a nested type.
It's certainly possible to deserialise nested json arrays but I could
not get it done easily so it'll be better handled in a separate PR.


## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Álvaro Rodríguez <sirasistant@gmail.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 acvm-repo/brillig_vm/src/lib.rs               | 154 +++++++++++++-----
 .../src/brillig/brillig_gen/brillig_block.rs  |  40 ++++-
 docs/docs/how_to/how-to-oracles.md            |   4 +
 .../regression_4561/Nargo.toml                |   6 +
 .../regression_4561/src/main.nr               |  44 +++++
 5 files changed, 201 insertions(+), 47 deletions(-)
 create mode 100644 test_programs/noir_test_success/regression_4561/Nargo.toml
 create mode 100644 test_programs/noir_test_success/regression_4561/src/main.nr

diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index da9a34f1044..862162ddccf 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -482,60 +482,64 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
             destinations.iter().zip(destination_value_types).zip(&values)
         {
             match (destination, value_type) {
-                (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(bit_size)) => {
-                    match output {
-                        ForeignCallParam::Single(value) => {
-                            self.write_value_to_memory(*value_index, value, *bit_size)?;
-                        }
-                        _ => return Err(format!(
-                            "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}")
-                        ),
+            (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(bit_size)) => {
+                match output {
+                    ForeignCallParam::Single(value) => {
+                        self.write_value_to_memory(*value_index, value, *bit_size)?;
                     }
+                    _ => return Err(format!(
+                        "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}")
+                    ),
                 }
-                (
-                    ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
-                    HeapValueType::Array { value_types, size: type_size },
-                ) if size == type_size => {
-                    if HeapValueType::all_simple(value_types) {
-                         match output {
-                            ForeignCallParam::Array(values) => {
-                                if values.len() != *size {
-                                    return Err("Foreign call result array doesn't match expected size".to_string());
-                                }
-                                self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
-                            }
-                            _ => {
-                                return Err("Function result size does not match brillig bytecode size".to_string());
+            }
+            (
+                ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
+                HeapValueType::Array { value_types, size: type_size },
+            ) if size == type_size => {
+                if HeapValueType::all_simple(value_types) {
+                    match output {
+                        ForeignCallParam::Array(values) => {
+                            if values.len() != *size {
+                                return Err("Foreign call result array doesn't match expected size".to_string());
                             }
+                            self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
+                        }
+                        _ => {
+                            return Err("Function result size does not match brillig bytecode size".to_string());
                         }
-                    } else {
-                        unimplemented!("deflattening heap arrays from foreign calls");
                     }
-                }
-                (
-                    ValueOrArray::HeapVector(HeapVector {pointer: pointer_index, size: size_index }),
-                    HeapValueType::Vector { value_types },
-                ) => {
-                    if HeapValueType::all_simple(value_types) {
-                        match output {
-                            ForeignCallParam::Array(values) => {
-                                // Set our size in the size address
-                                self.memory.write(*size_index, values.len().into());
-
-                                self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
-                            }
-                            _ => {
-                                return Err("Function result size does not match brillig bytecode size".to_string());
-                            }
+                } else {
+                    // foreign call returning flattened values into a nested type, so the sizes do not match
+                    let destination = self.memory.read_ref(*pointer_index);
+                    let return_type = value_type;
+                    let mut flatten_values_idx = 0; //index of values read from flatten_values
+                    self.write_slice_of_values_to_memory(destination, &output.fields(), &mut flatten_values_idx, return_type)?;
+            }
+        }
+            (
+                ValueOrArray::HeapVector(HeapVector {pointer: pointer_index, size: size_index }),
+                HeapValueType::Vector { value_types },
+            ) => {
+                if HeapValueType::all_simple(value_types) {
+                    match output {
+                        ForeignCallParam::Array(values) => {
+                            // Set our size in the size address
+                            self.memory.write(*size_index, values.len().into());
+                            self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
+
+                        }
+                        _ => {
+                            return Err("Function result size does not match brillig bytecode size".to_string());
                         }
-                    } else {
-                        unimplemented!("deflattening heap vectors from foreign calls");
                     }
-                }
-                _ => {
-                    return Err(format!("Unexpected value type {value_type:?} for destination {destination:?}"));
+                } else {
+                    unimplemented!("deflattening heap vectors from foreign calls");
                 }
             }
+            _ => {
+                return Err(format!("Unexpected value type {value_type:?} for destination {destination:?}"));
+            }
+        }
         }
 
         let _ =
@@ -596,6 +600,66 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         Ok(())
     }
 
+    /// Writes flattened values to memory, using the provided type
+    /// Function calls itself recursively in order to work with recursive types (nested arrays)
+    /// values_idx is the current index in the values vector and is incremented every time
+    /// a value is written to memory
+    /// The function returns the address of the next value to be written
+    fn write_slice_of_values_to_memory(
+        &mut self,
+        destination: MemoryAddress,
+        values: &Vec<F>,
+        values_idx: &mut usize,
+        value_type: &HeapValueType,
+    ) -> Result<MemoryAddress, String> {
+        let mut current_pointer = destination;
+        match value_type {
+            HeapValueType::Simple(bit_size) => {
+                self.write_value_to_memory(destination, &values[*values_idx], *bit_size)?;
+                *values_idx += 1;
+                Ok(MemoryAddress(destination.to_usize() + 1))
+            }
+            HeapValueType::Array { value_types, size } => {
+                for _ in 0..*size {
+                    for typ in value_types {
+                        match typ {
+                            HeapValueType::Simple(len) => {
+                                self.write_value_to_memory(
+                                    current_pointer,
+                                    &values[*values_idx],
+                                    *len,
+                                )?;
+                                *values_idx += 1;
+                                current_pointer = MemoryAddress(current_pointer.to_usize() + 1);
+                            }
+                            HeapValueType::Array { .. } => {
+                                let destination = self.memory.read_ref(current_pointer);
+                                let destination = self.memory.read_ref(destination);
+                                self.write_slice_of_values_to_memory(
+                                    destination,
+                                    values,
+                                    values_idx,
+                                    typ,
+                                )?;
+                                current_pointer = MemoryAddress(current_pointer.to_usize() + 1);
+                            }
+                            HeapValueType::Vector { .. } => {
+                                return Err(format!(
+                                    "Unsupported returned type in foreign calls {:?}",
+                                    typ
+                                ));
+                            }
+                        }
+                    }
+                }
+                Ok(current_pointer)
+            }
+            HeapValueType::Vector { .. } => {
+                Err(format!("Unsupported returned type in foreign calls {:?}", value_type))
+            }
+        }
+    }
+
     /// Process a binary operation.
     /// This method will not modify the program counter.
     fn process_binary_field_op(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 1fa4f41b29c..f165427233e 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1737,8 +1737,7 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 let array = variable.extract_array();
-                self.brillig_context.codegen_allocate_fixed_length_array(array.pointer, array.size);
-                self.brillig_context.usize_const_instruction(array.rc, 1_usize.into());
+                self.allocate_nested_array(typ, Some(array));
 
                 variable
             }
@@ -1765,6 +1764,43 @@ impl<'block> BrilligBlock<'block> {
         }
     }
 
+    fn allocate_nested_array(
+        &mut self,
+        typ: &Type,
+        array: Option<BrilligArray>,
+    ) -> BrilligVariable {
+        match typ {
+            Type::Array(types, size) => {
+                let array = array.unwrap_or(BrilligArray {
+                    pointer: self.brillig_context.allocate_register(),
+                    size: *size,
+                    rc: self.brillig_context.allocate_register(),
+                });
+                self.brillig_context.codegen_allocate_fixed_length_array(array.pointer, array.size);
+                self.brillig_context.usize_const_instruction(array.rc, 1_usize.into());
+
+                let mut index = 0_usize;
+                for _ in 0..*size {
+                    for element_type in types.iter() {
+                        match element_type {
+                            Type::Array(_, _) => {
+                                let inner_array = self.allocate_nested_array(element_type, None);
+                                let idx =
+                                    self.brillig_context.make_usize_constant_instruction(index.into());
+                                self.store_variable_in_array(array.pointer, idx, inner_array);
+                            }
+                            Type::Slice(_) => unreachable!("ICE: unsupported slice type in allocate_nested_array(), expects an array or a numeric type"),
+                            _ => (),
+                        }
+                        index += 1;
+                    }
+                }
+                BrilligVariable::BrilligArray(array)
+            }
+            _ => unreachable!("ICE: allocate_nested_array() expects an array, got {typ:?}"),
+        }
+    }
+
     /// Gets the "user-facing" length of an array.
     /// An array of structs with two fields would be stored as an 2 * array.len() array/vector.
     /// So we divide the length by the number of subitems in an item to get the user-facing length.
diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index 62ead1f534f..2d2ed5c94b9 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -166,6 +166,10 @@ interface ForeignCallResult {
 }
 ```
 
+::: Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in json as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
 :::
 
 ## Step 3 - Usage with Nargo
diff --git a/test_programs/noir_test_success/regression_4561/Nargo.toml b/test_programs/noir_test_success/regression_4561/Nargo.toml
new file mode 100644
index 00000000000..90deee74640
--- /dev/null
+++ b/test_programs/noir_test_success/regression_4561/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_4561"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/noir_test_success/regression_4561/src/main.nr b/test_programs/noir_test_success/regression_4561/src/main.nr
new file mode 100644
index 00000000000..138f7e805b3
--- /dev/null
+++ b/test_programs/noir_test_success/regression_4561/src/main.nr
@@ -0,0 +1,44 @@
+// Regression test for issue #4561
+use dep::std::test::OracleMock;
+
+type TReturnElem = [Field; 3];
+type TReturn = [TReturnElem; 2];
+
+#[oracle(simple_nested_return)]
+unconstrained fn simple_nested_return_oracle() -> TReturn {}
+
+unconstrained fn simple_nested_return_unconstrained() -> TReturn {
+    simple_nested_return_oracle()
+}
+
+#[test]
+fn test_simple_nested_return() {
+    OracleMock::mock("simple_nested_return").returns([1, 2, 3, 4, 5, 6]);
+    assert_eq(simple_nested_return_unconstrained(), [[1, 2, 3], [4, 5, 6]]);
+}
+
+#[oracle(nested_with_fields_return)]
+unconstrained fn nested_with_fields_return_oracle() -> (Field, TReturn, Field) {}
+
+unconstrained fn nested_with_fields_return_unconstrained() -> (Field, TReturn, Field) {
+    nested_with_fields_return_oracle()
+}
+
+#[test]
+fn test_nested_with_fields_return() {
+    OracleMock::mock("nested_with_fields_return").returns((0, [1, 2, 3, 4, 5, 6], 7));
+    assert_eq(nested_with_fields_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7));
+}
+
+#[oracle(two_nested_return)]
+unconstrained fn two_nested_return_oracle() -> (Field, TReturn, Field, TReturn) {}
+
+unconstrained fn two_nested_return_unconstrained() -> (Field, TReturn, Field, TReturn) {
+    two_nested_return_oracle()
+}
+
+#[test]
+fn two_nested_return() {
+    OracleMock::mock("two_nested_return").returns((0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6]));
+    assert_eq(two_nested_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7, [[1, 2, 3], [4, 5, 6]]));
+}
\ No newline at end of file

From 4aff0cb7764dd519919d4e4a16de4f4b67719684 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro=20Sousa?= <jose@aztecprotocol.com>
Date: Thu, 13 Jun 2024 12:32:35 +0100
Subject: [PATCH 367/416] chore(docs): fixing trailing slash issue (#5233)

---
 docs/docs/noir/standard_library/recursion.md | 8 +++-----
 docs/docusaurus.config.ts                    | 1 +
 docs/src/components/Notes/_blackbox.mdx      | 4 ++--
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/docs/docs/noir/standard_library/recursion.md b/docs/docs/noir/standard_library/recursion.md
index f33c285cf4e..cb3e7a9fcdf 100644
--- a/docs/docs/noir/standard_library/recursion.md
+++ b/docs/docs/noir/standard_library/recursion.md
@@ -4,6 +4,8 @@ description: Learn about how to write recursive proofs in Noir.
 keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
 Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
@@ -33,11 +35,7 @@ By incorporating this attribute directly in the circuit's definition, tooling li
 pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 ```
 
-:::info
-
-This is a black box function. Read [this section](./black_box_fns.md) to learn more about black box functions in Noir.
-
-:::
+<BlackBoxInfo />
 
 ## Example usage
 
diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts
index 29f612b0109..f0c986f1c28 100644
--- a/docs/docusaurus.config.ts
+++ b/docs/docusaurus.config.ts
@@ -14,6 +14,7 @@ export default {
   favicon: 'img/favicon.ico',
   url: 'https://noir-lang.org',
   baseUrl: '/',
+  trailingSlash: true,
   onBrokenLinks: 'throw',
   onBrokenMarkdownLinks: 'throw',
   i18n: {
diff --git a/docs/src/components/Notes/_blackbox.mdx b/docs/src/components/Notes/_blackbox.mdx
index 9fe9b48fbff..226017072c8 100644
--- a/docs/src/components/Notes/_blackbox.mdx
+++ b/docs/src/components/Notes/_blackbox.mdx
@@ -1,5 +1,5 @@
 :::info
 
-This is a black box function. Read [this section](../black_box_fns) to learn more about black box functions in Noir.
+This is a black box function. Read [this section](../../black_box_fns) to learn more about black box functions in Noir.
 
-:::
\ No newline at end of file
+:::

From 51506ffb30f72f8d1365165eefd693a5b7231721 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 13 Jun 2024 12:57:14 +0100
Subject: [PATCH 368/416] chore: copy across typo PR script from aztec-packages
 (#5235)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR pulls across the typo PR script from aztec-packages so we can
use it here as well.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 scripts/redo-typo-pr.sh | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100755 scripts/redo-typo-pr.sh

diff --git a/scripts/redo-typo-pr.sh b/scripts/redo-typo-pr.sh
new file mode 100755
index 00000000000..416be65a449
--- /dev/null
+++ b/scripts/redo-typo-pr.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -eux
+
+# Configuration
+ORIGINAL_PR_NUMBER=$1
+REPO='noir-lang/noir'
+NEW_BRANCH="chore/typo-redo-$ORIGINAL_PR_NUMBER"
+AUTHOR=`gh pr view $ORIGINAL_PR_NUMBER --json author --jq '.author.login'`
+
+# Step 1: Checkout the PR locally
+echo "Checking out PR #$ORIGINAL_PR_NUMBER"
+gh pr checkout $ORIGINAL_PR_NUMBER
+
+# Step 2: Create a new local branch
+echo "Creating new local branch $NEW_BRANCH"
+git checkout -b $NEW_BRANCH
+
+# Step 3: Push the new branch to GitHub
+echo "Pushing new branch $NEW_BRANCH to GitHub"
+git commit --amend --no-edit
+git push origin $NEW_BRANCH
+
+# Step 4: create a new pull request
+echo "Creating a new pull request for $NEW_BRANCH"
+gh pr create --base master --head $NEW_BRANCH --title "chore: redo typo PR by $AUTHOR" --body "Thanks $AUTHOR for https://github.com/$REPO/pull/$ORIGINAL_PR_NUMBER. Our policy is to redo typo changes to dissuade metric farming. This is an automated script."
+
+# Step 5: Close the original PR
+echo "Closing original PR #$ORIGINAL_PR_NUMBER"
+gh pr close $ORIGINAL_PR_NUMBER
+
+echo "Script completed."

From 85f40930b36ce35cfb12736ccaed273d96e1ac7d Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 13 Jun 2024 12:59:18 +0100
Subject: [PATCH 369/416] chore: thread generics through ACIR/brillig gen
 (#5120)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR makes various structs related to ACIR gen and brillig gen
generic over the field.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/brillig/brillig_gen.rs                |   7 +-
 .../brillig/brillig_gen/brillig_black_box.rs  |  19 +-
 .../src/brillig/brillig_gen/brillig_block.rs  |   6 +-
 .../brillig_gen/brillig_block_variables.rs    |  13 +-
 .../brillig/brillig_gen/brillig_directive.rs  |  15 +-
 .../src/brillig/brillig_gen/brillig_fn.rs     |   2 +-
 .../brillig/brillig_gen/brillig_slice_ops.rs  |   4 +-
 .../noirc_evaluator/src/brillig/brillig_ir.rs |  24 ++-
 .../src/brillig/brillig_ir/artifact.rs        |  26 +--
 .../src/brillig/brillig_ir/codegen_binary.rs  |   8 +-
 .../src/brillig/brillig_ir/codegen_calls.rs   |   7 +-
 .../brillig_ir/codegen_control_flow.rs        |  27 ++-
 .../brillig/brillig_ir/codegen_intrinsic.rs   |  12 +-
 .../src/brillig/brillig_ir/codegen_memory.rs  |   5 +-
 .../src/brillig/brillig_ir/codegen_stack.rs   |   6 +-
 .../src/brillig/brillig_ir/debug_show.rs      |   4 +-
 .../src/brillig/brillig_ir/entry_point.rs     |  45 ++--
 .../src/brillig/brillig_ir/instructions.rs    |  38 ++--
 .../src/brillig/brillig_ir/registers.rs       |   2 +-
 compiler/noirc_evaluator/src/brillig/mod.rs   |  11 +-
 compiler/noirc_evaluator/src/ssa.rs           |   2 +-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 195 ++++++++----------
 .../src/ssa/acir_gen/acir_ir/big_int.rs       |  16 +-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  68 +++---
 .../noirc_evaluator/src/ssa/acir_gen/mod.rs   |  35 ++--
 25 files changed, 292 insertions(+), 305 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
index 5576d673f1d..ee61a9d13d3 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
@@ -6,12 +6,17 @@ pub(crate) mod brillig_fn;
 pub(crate) mod brillig_slice_ops;
 mod variable_liveness;
 
+use acvm::FieldElement;
+
 use self::{brillig_block::BrilligBlock, brillig_fn::FunctionContext};
 use super::brillig_ir::{artifact::BrilligArtifact, BrilligContext};
 use crate::ssa::ir::function::Function;
 
 /// Converting an SSA function into Brillig bytecode.
-pub(crate) fn convert_ssa_function(func: &Function, enable_debug_trace: bool) -> BrilligArtifact {
+pub(crate) fn convert_ssa_function(
+    func: &Function,
+    enable_debug_trace: bool,
+) -> BrilligArtifact<FieldElement> {
     let mut brillig_context = BrilligContext::new(enable_debug_trace);
 
     let mut function_context = FunctionContext::new(func);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index f56c5daf315..367cdbe4973 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -1,18 +1,19 @@
 use acvm::{
     acir::{brillig::BlackBoxOp, BlackBoxFunc},
-    FieldElement,
+    AcirField,
 };
 
 use crate::brillig::brillig_ir::{
     brillig_variable::{BrilligVariable, BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
     BrilligBinaryOp, BrilligContext,
 };
 
 /// Transforms SSA's black box function calls into the corresponding brillig instructions
 /// Extracting arguments and results from the SSA function call
 /// And making any necessary type conversions to adapt noir's blackbox calls to brillig's
-pub(crate) fn convert_black_box_call(
-    brillig_context: &mut BrilligContext,
+pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F>,
     bb_func: &BlackBoxFunc,
     function_arguments: &[BrilligVariable],
     function_results: &[BrilligVariable],
@@ -341,7 +342,7 @@ pub(crate) fn convert_black_box_call(
                 let inputs_vector = convert_array_or_vector(brillig_context, inputs, bb_func);
                 let modulus_vector = convert_array_or_vector(brillig_context, modulus, bb_func);
                 let output_id = brillig_context.get_new_bigint_id();
-                brillig_context.const_instruction(*output, FieldElement::from(output_id as u128));
+                brillig_context.const_instruction(*output, F::from(output_id as u128));
                 brillig_context.black_box_op_instruction(BlackBoxOp::BigIntFromLeBytes {
                     inputs: inputs_vector.to_heap_vector(),
                     modulus: modulus_vector.to_heap_vector(),
@@ -426,8 +427,8 @@ pub(crate) fn convert_black_box_call(
     }
 }
 
-fn convert_array_or_vector(
-    brillig_context: &mut BrilligContext,
+fn convert_array_or_vector<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F>,
     array_or_vector: &BrilligVariable,
     bb_func: &BlackBoxFunc,
 ) -> BrilligVector {
@@ -442,8 +443,8 @@ fn convert_array_or_vector(
     }
 }
 
-fn prepare_bigint_output(
-    brillig_context: &mut BrilligContext,
+fn prepare_bigint_output<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F>,
     lhs_modulus: &SingleAddrVariable,
     rhs_modulus: &SingleAddrVariable,
     output: &SingleAddrVariable,
@@ -465,6 +466,6 @@ fn prepare_bigint_output(
     brillig_context.deallocate_register(condition);
     // Set output id
     let output_id = brillig_context.get_new_bigint_id();
-    brillig_context.const_instruction(*output, FieldElement::from(output_id as u128));
+    brillig_context.const_instruction(*output, F::from(output_id as u128));
     brillig_context.mov_instruction(modulus_id.address, lhs_modulus.address);
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index f165427233e..b441e8be3eb 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -33,7 +33,7 @@ pub(crate) struct BrilligBlock<'block> {
     /// The basic block that is being converted
     pub(crate) block_id: BasicBlockId,
     /// Context for creating brillig opcodes
-    pub(crate) brillig_context: &'block mut BrilligContext,
+    pub(crate) brillig_context: &'block mut BrilligContext<FieldElement>,
     /// Tracks the available variable during the codegen of the block
     pub(crate) variables: BlockVariables,
     /// For each instruction, the set of values that are not used anymore after it.
@@ -44,7 +44,7 @@ impl<'block> BrilligBlock<'block> {
     /// Converts an SSA Basic block into a sequence of Brillig opcodes
     pub(crate) fn compile(
         function_context: &'block mut FunctionContext,
-        brillig_context: &'block mut BrilligContext,
+        brillig_context: &'block mut BrilligContext<FieldElement>,
         block_id: BasicBlockId,
         dfg: &DataFlowGraph,
     ) {
@@ -944,7 +944,7 @@ impl<'block> BrilligBlock<'block> {
     }
 
     pub(crate) fn store_variable_in_array_with_ctx(
-        ctx: &mut BrilligContext,
+        ctx: &mut BrilligContext<FieldElement>,
         destination_pointer: MemoryAddress,
         index_register: SingleAddrVariable,
         value_variable: BrilligVariable,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
index fb9a8577d94..ffbca256d28 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
@@ -1,3 +1,4 @@
+use acvm::FieldElement;
 use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 use crate::{
@@ -50,7 +51,7 @@ impl BlockVariables {
     pub(crate) fn define_variable(
         &mut self,
         function_context: &mut FunctionContext,
-        brillig_context: &mut BrilligContext,
+        brillig_context: &mut BrilligContext<FieldElement>,
         value_id: ValueId,
         dfg: &DataFlowGraph,
     ) -> BrilligVariable {
@@ -70,7 +71,7 @@ impl BlockVariables {
     pub(crate) fn define_single_addr_variable(
         &mut self,
         function_context: &mut FunctionContext,
-        brillig_context: &mut BrilligContext,
+        brillig_context: &mut BrilligContext<FieldElement>,
         value: ValueId,
         dfg: &DataFlowGraph,
     ) -> SingleAddrVariable {
@@ -83,7 +84,7 @@ impl BlockVariables {
         &mut self,
         value_id: &ValueId,
         function_context: &mut FunctionContext,
-        brillig_context: &mut BrilligContext,
+        brillig_context: &mut BrilligContext<FieldElement>,
     ) {
         assert!(self.available_variables.remove(value_id), "ICE: Variable is not available");
         let variable = function_context
@@ -122,7 +123,7 @@ impl BlockVariables {
     /// We keep constants block-local.
     pub(crate) fn allocate_constant(
         &mut self,
-        brillig_context: &mut BrilligContext,
+        brillig_context: &mut BrilligContext<FieldElement>,
         value_id: ValueId,
         dfg: &DataFlowGraph,
     ) -> BrilligVariable {
@@ -154,9 +155,9 @@ pub(crate) fn compute_array_length(item_typ: &CompositeType, elem_count: usize)
 }
 
 /// For a given value_id, allocates the necessary registers to hold it.
-pub(crate) fn allocate_value(
+pub(crate) fn allocate_value<F>(
     value_id: ValueId,
-    brillig_context: &mut BrilligContext,
+    brillig_context: &mut BrilligContext<F>,
     dfg: &DataFlowGraph,
 ) -> BrilligVariable {
     let typ = dfg.type_of_value(value_id);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
index 74319595795..ae159f2c45c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
@@ -1,13 +1,12 @@
 use acvm::{
     acir::brillig::{BinaryFieldOp, BinaryIntOp, MemoryAddress, Opcode as BrilligOpcode},
     acir::AcirField,
-    FieldElement,
 };
 
 use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
 
 /// Generates brillig bytecode which computes the inverse of its input if not null, and zero else.
-pub(crate) fn directive_invert() -> GeneratedBrillig {
+pub(crate) fn directive_invert<F: AcirField>() -> GeneratedBrillig<F> {
     //  We generate the following code:
     // fn invert(x : Field) -> Field {
     //    1/ x
@@ -28,8 +27,8 @@ pub(crate) fn directive_invert() -> GeneratedBrillig {
             // Put value zero in register (2)
             BrilligOpcode::Const {
                 destination: zero_const,
-                value: FieldElement::from(0_usize),
-                bit_size: FieldElement::max_num_bits(),
+                value: F::from(0_usize),
+                bit_size: F::max_num_bits(),
             },
             BrilligOpcode::BinaryFieldOp {
                 op: BinaryFieldOp::Equals,
@@ -42,8 +41,8 @@ pub(crate) fn directive_invert() -> GeneratedBrillig {
             // Put value one in register (1)
             BrilligOpcode::Const {
                 destination: one_const,
-                value: FieldElement::from(1_usize),
-                bit_size: FieldElement::max_num_bits(),
+                value: F::one(),
+                bit_size: F::max_num_bits(),
             },
             // Divide 1 by the input, and set the result of the division into register (0)
             BrilligOpcode::BinaryFieldOp {
@@ -68,13 +67,13 @@ pub(crate) fn directive_invert() -> GeneratedBrillig {
 ///    (a/b, a-a/b*b)
 /// }
 /// ```
-pub(crate) fn directive_quotient(bit_size: u32) -> GeneratedBrillig {
+pub(crate) fn directive_quotient<F: AcirField>(bit_size: u32) -> GeneratedBrillig<F> {
     // `a` is (0) (i.e register index 0)
     // `b` is (1)
 
     // TODO: The only difference between these implementations is the integer version will truncate the input to the `bit_size` via cast.
     // Once we deduplicate brillig functions then we can modify this so that fields and integers share the same quotient function.
-    if bit_size >= FieldElement::max_num_bits() {
+    if bit_size >= F::max_num_bits() {
         // Field version
         GeneratedBrillig {
             byte_code: vec![
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index 000d1230ece..f0752c80c46 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -28,7 +28,7 @@ pub(crate) struct FunctionContext {
 }
 
 impl FunctionContext {
-    /// Creates a new function context. It will compute the liveness of every variable.
+    /// Creates a new function context. It will allocate parameters for all blocks and compute the liveness of every variable.
     pub(crate) fn new(function: &Function) -> Self {
         let id = function.id();
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 491086e8c0f..d17b15a13b5 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -372,7 +372,7 @@ mod tests {
     use crate::ssa::ir::map::Id;
     use crate::ssa::ssa_gen::Ssa;
 
-    fn create_test_environment() -> (Ssa, FunctionContext, BrilligContext) {
+    fn create_test_environment() -> (Ssa, FunctionContext, BrilligContext<FieldElement>) {
         let mut builder = FunctionBuilder::new("main".to_string(), Id::test_new(0));
         builder.set_runtime(RuntimeType::Brillig);
 
@@ -385,7 +385,7 @@ mod tests {
 
     fn create_brillig_block<'a>(
         function_context: &'a mut FunctionContext,
-        brillig_context: &'a mut BrilligContext,
+        brillig_context: &'a mut BrilligContext<FieldElement>,
     ) -> BrilligBlock<'a> {
         let variables = BlockVariables::default();
         BrilligBlock {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index ebccf7a0bf1..9785e073be9 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -25,11 +25,13 @@ mod instructions;
 
 pub(crate) use instructions::BrilligBinaryOp;
 
-use self::{artifact::BrilligArtifact, registers::BrilligRegistersContext};
+use self::{
+    artifact::BrilligArtifact, debug_show::DebugToString, registers::BrilligRegistersContext,
+};
 use crate::ssa::ir::dfg::CallStack;
 use acvm::{
     acir::brillig::{MemoryAddress, Opcode as BrilligOpcode},
-    FieldElement,
+    AcirField,
 };
 use debug_show::DebugShow;
 
@@ -76,8 +78,8 @@ impl ReservedRegisters {
 
 /// Brillig context object that is used while constructing the
 /// Brillig bytecode.
-pub(crate) struct BrilligContext {
-    obj: BrilligArtifact,
+pub(crate) struct BrilligContext<F> {
+    obj: BrilligArtifact<F>,
     /// Tracks register allocations
     registers: BrilligRegistersContext,
     /// Context label, must be unique with respect to the function
@@ -93,9 +95,9 @@ pub(crate) struct BrilligContext {
     bigint_new_id: u32,
 }
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Initial context state
-    pub(crate) fn new(enable_debug_trace: bool) -> BrilligContext {
+    pub(crate) fn new(enable_debug_trace: bool) -> BrilligContext<F> {
         BrilligContext {
             obj: BrilligArtifact::default(),
             registers: BrilligRegistersContext::new(),
@@ -113,12 +115,12 @@ impl BrilligContext {
         result
     }
     /// Adds a brillig instruction to the brillig byte code
-    fn push_opcode(&mut self, opcode: BrilligOpcode<FieldElement>) {
+    fn push_opcode(&mut self, opcode: BrilligOpcode<F>) {
         self.obj.push_opcode(opcode);
     }
 
     /// Returns the artifact
-    pub(crate) fn artifact(self) -> BrilligArtifact {
+    pub(crate) fn artifact(self) -> BrilligArtifact<F> {
         self.obj
     }
 
@@ -200,17 +202,17 @@ pub(crate) mod tests {
         }
     }
 
-    pub(crate) fn create_context() -> BrilligContext {
+    pub(crate) fn create_context() -> BrilligContext<FieldElement> {
         let mut context = BrilligContext::new(true);
         context.enter_context("test");
         context
     }
 
     pub(crate) fn create_entry_point_bytecode(
-        context: BrilligContext,
+        context: BrilligContext<FieldElement>,
         arguments: Vec<BrilligParameter>,
         returns: Vec<BrilligParameter>,
-    ) -> GeneratedBrillig {
+    ) -> GeneratedBrillig<FieldElement> {
         let artifact = context.artifact();
         let mut entry_point_artifact =
             BrilligContext::new_entry_point_artifact(arguments, returns, "test".to_string());
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index 99e922c1580..2d0bdb5955c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -1,4 +1,4 @@
-use acvm::{acir::brillig::Opcode as BrilligOpcode, FieldElement};
+use acvm::acir::brillig::Opcode as BrilligOpcode;
 use std::collections::{BTreeMap, HashMap};
 
 use crate::ssa::ir::dfg::CallStack;
@@ -18,8 +18,8 @@ pub(crate) enum BrilligParameter {
 /// The result of compiling and linking brillig artifacts.
 /// This is ready to run bytecode with attached metadata.
 #[derive(Debug, Default)]
-pub(crate) struct GeneratedBrillig {
-    pub(crate) byte_code: Vec<BrilligOpcode<FieldElement>>,
+pub(crate) struct GeneratedBrillig<F> {
+    pub(crate) byte_code: Vec<BrilligOpcode<F>>,
     pub(crate) locations: BTreeMap<OpcodeLocation, CallStack>,
     pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
 }
@@ -27,8 +27,8 @@ pub(crate) struct GeneratedBrillig {
 #[derive(Default, Debug, Clone)]
 /// Artifacts resulting from the compilation of a function into brillig byte code.
 /// It includes the bytecode of the function and all the metadata that allows linking with other functions.
-pub(crate) struct BrilligArtifact {
-    pub(crate) byte_code: Vec<BrilligOpcode<FieldElement>>,
+pub(crate) struct BrilligArtifact<F> {
+    pub(crate) byte_code: Vec<BrilligOpcode<F>>,
     /// A map of bytecode positions to assertion messages.
     /// Some error messages (compiler intrinsics) are not emitted via revert data,
     /// instead, they are handled externally so they don't add size to user programs.
@@ -73,9 +73,9 @@ pub(crate) type JumpInstructionPosition = OpcodeLocation;
 /// to their position in the bytecode.
 pub(crate) type UnresolvedJumpLocation = Label;
 
-impl BrilligArtifact {
+impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     /// Resolves all jumps and generates the final bytecode
-    pub(crate) fn finish(mut self) -> GeneratedBrillig {
+    pub(crate) fn finish(mut self) -> GeneratedBrillig<F> {
         self.resolve_jumps();
         GeneratedBrillig {
             byte_code: self.byte_code,
@@ -94,7 +94,7 @@ impl BrilligArtifact {
     /// This method will offset the positions in the Brillig artifact to
     /// account for the fact that it is being appended to the end of this
     /// Brillig artifact (self).
-    pub(crate) fn link_with(&mut self, obj: &BrilligArtifact) {
+    pub(crate) fn link_with(&mut self, obj: &BrilligArtifact<F>) {
         // Add the unresolved jumps of the linked function to this artifact.
         self.add_unresolved_jumps_and_calls(obj);
 
@@ -128,7 +128,7 @@ impl BrilligArtifact {
     }
 
     /// Adds unresolved jumps & function calls from another artifact offset by the current opcode count in the artifact.
-    fn add_unresolved_jumps_and_calls(&mut self, obj: &BrilligArtifact) {
+    fn add_unresolved_jumps_and_calls(&mut self, obj: &BrilligArtifact<F>) {
         let offset = self.index_of_next_opcode();
         for (jump_label, jump_location) in &obj.unresolved_jumps {
             self.unresolved_jumps.push((jump_label + offset, jump_location.clone()));
@@ -154,7 +154,7 @@ impl BrilligArtifact {
     }
 
     /// Adds a brillig instruction to the brillig byte code
-    pub(crate) fn push_opcode(&mut self, opcode: BrilligOpcode<FieldElement>) {
+    pub(crate) fn push_opcode(&mut self, opcode: BrilligOpcode<F>) {
         if !self.call_stack.is_empty() {
             self.locations.insert(self.index_of_next_opcode(), self.call_stack.clone());
         }
@@ -164,7 +164,7 @@ impl BrilligArtifact {
     /// Adds a unresolved jump to be fixed at the end of bytecode processing.
     pub(crate) fn add_unresolved_jump(
         &mut self,
-        jmp_instruction: BrilligOpcode<FieldElement>,
+        jmp_instruction: BrilligOpcode<F>,
         destination: UnresolvedJumpLocation,
     ) {
         assert!(
@@ -178,7 +178,7 @@ impl BrilligArtifact {
     /// Adds a unresolved external call that will be fixed once linking has been done.
     pub(crate) fn add_unresolved_external_call(
         &mut self,
-        call_instruction: BrilligOpcode<FieldElement>,
+        call_instruction: BrilligOpcode<F>,
         destination: UnresolvedJumpLocation,
     ) {
         // TODO: Add a check to ensure that the opcode is a call instruction
@@ -188,7 +188,7 @@ impl BrilligArtifact {
     }
 
     /// Returns true if the opcode is a jump instruction
-    fn is_jmp_instruction(instruction: &BrilligOpcode<FieldElement>) -> bool {
+    fn is_jmp_instruction(instruction: &BrilligOpcode<F>) -> bool {
         matches!(
             instruction,
             BrilligOpcode::JumpIfNot { .. }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
index 4ef279bd532..a9c4f238491 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_binary.rs
@@ -1,8 +1,8 @@
-use acvm::{acir::brillig::MemoryAddress, FieldElement};
+use acvm::{acir::brillig::MemoryAddress, AcirField};
 
-use super::{instructions::BrilligBinaryOp, BrilligContext};
+use super::{debug_show::DebugToString, instructions::BrilligBinaryOp, BrilligContext};
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Utility method to perform a binary instruction with a constant value in place
     pub(crate) fn codegen_usize_op_in_place(
         &mut self,
@@ -21,7 +21,7 @@ impl BrilligContext {
         op: BrilligBinaryOp,
         constant: usize,
     ) {
-        let const_register = self.make_usize_constant_instruction(FieldElement::from(constant));
+        let const_register = self.make_usize_constant_instruction(F::from(constant));
         self.memory_op_instruction(operand, const_register.address, destination, op);
         // Mark as no longer used for this purpose, frees for reuse
         self.deallocate_single_addr(const_register);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
index db65849a6b8..2d93cf70181 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
@@ -1,10 +1,11 @@
-use acvm::acir::brillig::MemoryAddress;
+use acvm::{acir::brillig::MemoryAddress, AcirField};
 
 use super::{
-    brillig_variable::BrilligVariable, BrilligBinaryOp, BrilligContext, ReservedRegisters,
+    brillig_variable::BrilligVariable, debug_show::DebugToString, BrilligBinaryOp, BrilligContext,
+    ReservedRegisters,
 };
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Saves all of the registers that have been used up until this point.
     fn codegen_save_registers_of_vars(&mut self, vars: &[BrilligVariable]) -> Vec<MemoryAddress> {
         // Save all of the used registers at this point in memory
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index fee3a450119..10badcd7308 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -1,12 +1,16 @@
-use acvm::acir::brillig::{HeapArray, MemoryAddress};
+use acvm::{
+    acir::brillig::{HeapArray, MemoryAddress},
+    AcirField,
+};
 
 use super::{
     artifact::BrilligParameter,
     brillig_variable::{BrilligVariable, SingleAddrVariable},
+    debug_show::DebugToString,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Codegens a return from the current function.
     ///
     /// For Brillig, the return is implicit, since there is no explicit return instruction.
@@ -36,10 +40,11 @@ impl BrilligContext {
 
     /// This codegen will issue a loop that will iterate iteration_count times
     /// The body of the loop should be issued by the caller in the on_iteration closure.
-    pub(crate) fn codegen_loop<F>(&mut self, iteration_count: MemoryAddress, on_iteration: F)
-    where
-        F: FnOnce(&mut BrilligContext, SingleAddrVariable),
-    {
+    pub(crate) fn codegen_loop(
+        &mut self,
+        iteration_count: MemoryAddress,
+        on_iteration: impl FnOnce(&mut BrilligContext<F>, SingleAddrVariable),
+    ) {
         let iterator_register = self.make_usize_constant_instruction(0_u128.into());
 
         let (loop_section, loop_label) = self.reserve_next_section_label();
@@ -87,7 +92,7 @@ impl BrilligContext {
     pub(crate) fn codegen_branch(
         &mut self,
         condition: MemoryAddress,
-        mut f: impl FnMut(&mut BrilligContext, bool),
+        mut f: impl FnMut(&mut BrilligContext<F>, bool),
     ) {
         // Reserve 3 sections
         let (then_section, then_label) = self.reserve_next_section_label();
@@ -112,7 +117,7 @@ impl BrilligContext {
     pub(crate) fn codegen_if(
         &mut self,
         condition: MemoryAddress,
-        f: impl FnOnce(&mut BrilligContext),
+        f: impl FnOnce(&mut BrilligContext<F>),
     ) {
         let (end_section, end_label) = self.reserve_next_section_label();
         let (then_section, then_label) = self.reserve_next_section_label();
@@ -130,7 +135,7 @@ impl BrilligContext {
     pub(crate) fn codegen_if_not(
         &mut self,
         condition: MemoryAddress,
-        f: impl FnOnce(&mut BrilligContext),
+        f: impl FnOnce(&mut BrilligContext<F>),
     ) {
         let (end_section, end_label) = self.reserve_next_section_label();
 
@@ -156,7 +161,7 @@ impl BrilligContext {
             let revert_data = HeapArray {
                 pointer: ctx.allocate_register(),
                 // + 1 due to the revert data id being the first item returned
-                size: BrilligContext::flattened_tuple_size(&revert_data_types) + 1,
+                size: Self::flattened_tuple_size(&revert_data_types) + 1,
             };
             ctx.codegen_allocate_fixed_length_array(revert_data.pointer, revert_data.size);
 
@@ -169,7 +174,7 @@ impl BrilligContext {
             for (revert_variable, revert_param) in
                 revert_data_items.into_iter().zip(revert_data_types.into_iter())
             {
-                let flattened_size = BrilligContext::flattened_size(&revert_param);
+                let flattened_size = Self::flattened_size(&revert_param);
                 match revert_param {
                     BrilligParameter::SingleAddr(_) => {
                         ctx.store_instruction(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
index 42f3b34aea0..b1cb2b19764 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -1,15 +1,15 @@
 use acvm::{
     acir::brillig::{BlackBoxOp, HeapArray},
     acir::AcirField,
-    FieldElement,
 };
 
 use super::{
     brillig_variable::{BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
     BrilligContext,
 };
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Codegens a truncation of a value to the given bit size
     pub(crate) fn codegen_truncate(
         &mut self,
@@ -43,7 +43,7 @@ impl BrilligContext {
         big_endian: bool,
         limb_bit_size: u32,
     ) {
-        assert!(source_field.bit_size == FieldElement::max_num_bits());
+        assert!(source_field.bit_size == F::max_num_bits());
 
         self.usize_const_instruction(target_vector.size, limb_count.into());
         self.usize_const_instruction(target_vector.rc, 1_usize.into());
@@ -55,12 +55,10 @@ impl BrilligContext {
             output: HeapArray { pointer: target_vector.pointer, size: limb_count },
         });
 
-        let limb_field =
-            SingleAddrVariable::new(self.allocate_register(), FieldElement::max_num_bits());
-
+        let limb_field = SingleAddrVariable::new(self.allocate_register(), F::max_num_bits());
         let limb_casted = SingleAddrVariable::new(self.allocate_register(), limb_bit_size);
 
-        if limb_bit_size != FieldElement::max_num_bits() {
+        if limb_bit_size != F::max_num_bits() {
             self.codegen_loop(target_vector.size, |ctx, iterator_register| {
                 // Read the limb
                 ctx.codegen_array_get(target_vector.pointer, iterator_register, limb_field.address);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
index 15761113f51..81c1c3847b1 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
@@ -1,13 +1,14 @@
-use acvm::acir::brillig::MemoryAddress;
+use acvm::{acir::brillig::MemoryAddress, AcirField};
 
 use crate::brillig::brillig_ir::BrilligBinaryOp;
 
 use super::{
     brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
     BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Allocates an array of size `size` and stores the pointer to the array
     /// in `pointer_register`
     pub(crate) fn codegen_allocate_fixed_length_array(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
index 1c30f0f848f..943b0b9d7a3 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
@@ -1,8 +1,8 @@
-use acvm::acir::brillig::MemoryAddress;
+use acvm::{acir::brillig::MemoryAddress, AcirField};
 
-use super::BrilligContext;
+use super::{debug_show::DebugToString, BrilligContext};
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// This function moves values from a set of registers to another set of registers.
     /// It first moves all sources to new allocated registers to avoid overwriting.
     pub(crate) fn codegen_mov_registers_to_registers(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index def91f82bfd..075a776572e 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -8,7 +8,7 @@ use acvm::{
 };
 
 /// Trait for converting values into debug-friendly strings.
-trait DebugToString {
+pub(crate) trait DebugToString {
     fn debug_to_string(&self) -> String;
 }
 
@@ -169,7 +169,7 @@ impl DebugShow {
     }
 
     /// Stores the value of `constant` in the `result` register
-    pub(crate) fn const_instruction(&self, result: MemoryAddress, constant: FieldElement) {
+    pub(crate) fn const_instruction<F: DebugToString>(&self, result: MemoryAddress, constant: F) {
         debug_println!(self.enable_debug_trace, "  CONST {} = {}", result, constant);
     }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index 9023183eb36..dc06c2fa0d7 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -1,21 +1,21 @@
 use super::{
     artifact::{BrilligArtifact, BrilligParameter},
     brillig_variable::{BrilligArray, BrilligVariable, BrilligVector, SingleAddrVariable},
-    debug_show::DebugShow,
+    debug_show::{DebugShow, DebugToString},
     registers::BrilligRegistersContext,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
-use acvm::{acir::brillig::MemoryAddress, acir::AcirField, FieldElement};
+use acvm::{acir::brillig::MemoryAddress, acir::AcirField};
 
 pub(crate) const MAX_STACK_SIZE: usize = 2048;
 
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Creates an entry point artifact that will jump to the function label provided.
     pub(crate) fn new_entry_point_artifact<T: ToString>(
         arguments: Vec<BrilligParameter>,
         return_parameters: Vec<BrilligParameter>,
         target_function: T,
-    ) -> BrilligArtifact {
+    ) -> BrilligArtifact<F> {
         let mut context = BrilligContext {
             obj: BrilligArtifact::default(),
             registers: BrilligRegistersContext::new(),
@@ -42,8 +42,8 @@ impl BrilligContext {
         arguments: &[BrilligParameter],
         return_parameters: &[BrilligParameter],
     ) {
-        let calldata_size = BrilligContext::flattened_tuple_size(arguments);
-        let return_data_size = BrilligContext::flattened_tuple_size(return_parameters);
+        let calldata_size = Self::flattened_tuple_size(arguments);
+        let return_data_size = Self::flattened_tuple_size(return_parameters);
 
         // Set initial value of stack pointer: MAX_STACK_SIZE + calldata_size + return_data_size
         self.const_instruction(
@@ -74,7 +74,7 @@ impl BrilligContext {
                     let pointer_to_the_array_in_calldata =
                         self.make_usize_constant_instruction(current_calldata_pointer.into());
                     let rc_register = self.make_usize_constant_instruction(1_usize.into());
-                    let flattened_size = BrilligContext::flattened_size(argument);
+                    let flattened_size = Self::flattened_size(argument);
                     let var = BrilligVariable::BrilligArray(BrilligArray {
                         pointer: pointer_to_the_array_in_calldata.address,
                         size: flattened_size,
@@ -88,7 +88,7 @@ impl BrilligContext {
                     let pointer_to_the_array_in_calldata =
                         self.make_usize_constant_instruction(current_calldata_pointer.into());
 
-                    let flattened_size = BrilligContext::flattened_size(argument);
+                    let flattened_size = Self::flattened_size(argument);
                     let size_register = self.make_usize_constant_instruction(flattened_size.into());
                     let rc_register = self.make_usize_constant_instruction(1_usize.into());
 
@@ -121,7 +121,7 @@ impl BrilligContext {
                     BrilligVariable::BrilligVector(vector),
                     BrilligParameter::Slice(item_type, item_count),
                 ) => {
-                    let flattened_size = BrilligContext::flattened_size(argument);
+                    let flattened_size = Self::flattened_size(argument);
 
                     let deflattened_address =
                         self.deflatten_array(item_type, flattened_size, vector.pointer);
@@ -139,7 +139,7 @@ impl BrilligContext {
     }
 
     fn copy_and_cast_calldata(&mut self, arguments: &[BrilligParameter]) {
-        let calldata_size = BrilligContext::flattened_tuple_size(arguments);
+        let calldata_size = Self::flattened_tuple_size(arguments);
         self.calldata_copy_instruction(MemoryAddress(MAX_STACK_SIZE), calldata_size, 0);
 
         fn flat_bit_sizes(param: &BrilligParameter) -> Box<dyn Iterator<Item = u32> + '_> {
@@ -154,7 +154,7 @@ impl BrilligContext {
 
         for (i, bit_size) in arguments.iter().flat_map(flat_bit_sizes).enumerate() {
             // Calldatacopy tags everything with field type, so when downcast when necessary
-            if bit_size < FieldElement::max_num_bits() {
+            if bit_size < F::max_num_bits() {
                 self.cast_instruction(
                     SingleAddrVariable::new(MemoryAddress(MAX_STACK_SIZE + i), bit_size),
                     SingleAddrVariable::new_field(MemoryAddress(MAX_STACK_SIZE + i)),
@@ -169,7 +169,7 @@ impl BrilligContext {
             BrilligParameter::SingleAddr(_) => 1,
             BrilligParameter::Array(item_types, item_count)
             | BrilligParameter::Slice(item_types, item_count) => {
-                let item_size: usize = item_types.iter().map(BrilligContext::flattened_size).sum();
+                let item_size: usize = item_types.iter().map(Self::flattened_size).sum();
                 item_count * item_size
             }
         }
@@ -177,7 +177,7 @@ impl BrilligContext {
 
     /// Computes the size of a parameter if it was flattened
     pub(super) fn flattened_tuple_size(tuple: &[BrilligParameter]) -> usize {
-        tuple.iter().map(BrilligContext::flattened_size).sum()
+        tuple.iter().map(Self::flattened_size).sum()
     }
 
     /// Computes the size of a parameter if it was flattened
@@ -193,12 +193,12 @@ impl BrilligContext {
         item_count: usize,
         flattened_array_pointer: MemoryAddress,
     ) -> MemoryAddress {
-        if BrilligContext::has_nested_arrays(item_type) {
+        if Self::has_nested_arrays(item_type) {
             let movement_register = self.allocate_register();
             let deflattened_array_pointer = self.allocate_register();
 
             let target_item_size = item_type.len();
-            let source_item_size = BrilligContext::flattened_tuple_size(item_type);
+            let source_item_size = Self::flattened_tuple_size(item_type);
 
             self.codegen_allocate_fixed_length_array(
                 deflattened_array_pointer,
@@ -276,7 +276,7 @@ impl BrilligContext {
                                 .into_iter()
                                 .for_each(|register| self.deallocate_register(register));
 
-                            source_offset += BrilligContext::flattened_size(subitem);
+                            source_offset += Self::flattened_size(subitem);
                         }
                         BrilligParameter::Slice(..) => unreachable!("ICE: Cannot deflatten slices"),
                     }
@@ -328,8 +328,8 @@ impl BrilligContext {
             .collect();
 
         // Now, we deflatten the return data
-        let calldata_size = BrilligContext::flattened_tuple_size(arguments);
-        let return_data_size = BrilligContext::flattened_tuple_size(return_parameters);
+        let calldata_size = Self::flattened_tuple_size(arguments);
+        let return_data_size = Self::flattened_tuple_size(return_parameters);
 
         // Return data has a reserved space after calldata
         let return_data_offset = MAX_STACK_SIZE + calldata_size;
@@ -357,7 +357,7 @@ impl BrilligContext {
                     );
 
                     self.deallocate_single_addr(pointer_to_return_data);
-                    return_data_index += BrilligContext::flattened_size(return_param);
+                    return_data_index += Self::flattened_size(return_param);
                 }
                 BrilligParameter::Slice(..) => {
                     unreachable!("ICE: Cannot return slices from brillig entrypoints")
@@ -376,12 +376,11 @@ impl BrilligContext {
         flattened_array_pointer: MemoryAddress,
         deflattened_array_pointer: MemoryAddress,
     ) {
-        if BrilligContext::has_nested_arrays(item_type) {
+        if Self::has_nested_arrays(item_type) {
             let movement_register = self.allocate_register();
 
             let source_item_size = item_type.len();
-            let target_item_size: usize =
-                item_type.iter().map(BrilligContext::flattened_size).sum();
+            let target_item_size: usize = item_type.iter().map(Self::flattened_size).sum();
 
             for item_index in 0..item_count {
                 let source_item_base_index = item_index * source_item_size;
@@ -462,7 +461,7 @@ impl BrilligContext {
                                 .into_iter()
                                 .for_each(|register| self.deallocate_register(register));
 
-                            target_offset += BrilligContext::flattened_size(subitem);
+                            target_offset += Self::flattened_size(subitem);
                         }
                         BrilligParameter::Slice(..) => unreachable!("ICE: Cannot flatten slices"),
                     }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 03a9216b73a..a614f93fa30 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -10,12 +10,13 @@ use acvm::{
 use super::{
     artifact::UnresolvedJumpLocation,
     brillig_variable::{BrilligArray, BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
     BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 
 /// Low level instructions of the brillig IR, used by the brillig ir codegens and brillig_gen
 /// Printed using debug_slow
-impl BrilligContext {
+impl<F: AcirField + DebugToString> BrilligContext<F> {
     /// Processes a binary instruction according `operation`.
     ///
     /// This method will compute lhs <operation> rhs
@@ -42,8 +43,7 @@ impl BrilligContext {
     ) {
         self.debug_show.not_instruction(input.address, input.bit_size, result.address);
         // Compile !x as ((-1) - x)
-        let u_max = FieldElement::from(2_i128).pow(&FieldElement::from(input.bit_size as i128))
-            - FieldElement::one();
+        let u_max = F::from(2_u128).pow(&F::from(input.bit_size as u128)) - F::one();
         let max = self.make_constant(u_max, input.bit_size);
 
         self.binary(max, input, result, BrilligBinaryOp::Sub);
@@ -63,7 +63,7 @@ impl BrilligContext {
             SingleAddrVariable::new_usize(rhs),
             SingleAddrVariable::new(
                 destination,
-                BrilligContext::binary_result_bit_size(op, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
+                Self::binary_result_bit_size(op, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
             ),
             op,
         );
@@ -77,8 +77,7 @@ impl BrilligContext {
         operation: BrilligBinaryOp,
     ) {
         let is_field_op = lhs.bit_size == FieldElement::max_num_bits();
-        let expected_result_bit_size =
-            BrilligContext::binary_result_bit_size(operation, lhs.bit_size);
+        let expected_result_bit_size = Self::binary_result_bit_size(operation, lhs.bit_size);
         assert!(
             result.bit_size == expected_result_bit_size,
             "Expected result bit size to be {}, got {} for operation {:?}",
@@ -213,7 +212,7 @@ impl BrilligContext {
     /// Adds a unresolved `Jump` to the bytecode.
     fn add_unresolved_jump(
         &mut self,
-        jmp_instruction: BrilligOpcode<FieldElement>,
+        jmp_instruction: BrilligOpcode<F>,
         destination: UnresolvedJumpLocation,
     ) {
         self.obj.add_unresolved_jump(jmp_instruction, destination);
@@ -369,12 +368,12 @@ impl BrilligContext {
     }
 
     /// Stores the value of `constant` in the `result` register
-    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: FieldElement) {
+    pub(crate) fn const_instruction(&mut self, result: SingleAddrVariable, constant: F) {
         self.debug_show.const_instruction(result.address, constant);
         self.constant(result, constant);
     }
 
-    fn constant(&mut self, result: SingleAddrVariable, constant: FieldElement) {
+    fn constant(&mut self, result: SingleAddrVariable, constant: F) {
         assert!(
             result.bit_size >= constant.num_bits(),
             "Constant {} does not fit in bit size {}",
@@ -382,10 +381,10 @@ impl BrilligContext {
             result.bit_size
         );
         if result.bit_size > 128 && constant.num_bits() > 128 {
-            let high = FieldElement::from_be_bytes_reduce(
+            let high = F::from_be_bytes_reduce(
                 constant.to_be_bytes().get(0..16).expect("FieldElement::to_be_bytes() too short!"),
             );
-            let low = FieldElement::from(constant.to_u128());
+            let low = F::from(constant.to_u128());
             let high_register = SingleAddrVariable::new(self.allocate_register(), 254);
             let low_register = SingleAddrVariable::new(self.allocate_register(), 254);
             let intermediate_register = SingleAddrVariable::new(self.allocate_register(), 254);
@@ -393,7 +392,7 @@ impl BrilligContext {
             self.constant(low_register, low);
             // I want to multiply high by 2^128, but I can't get that big constant in.
             // So I'll multiply by 2^64 twice.
-            self.constant(intermediate_register, FieldElement::from(1_u128 << 64));
+            self.constant(intermediate_register, F::from(1_u128 << 64));
             self.binary(high_register, intermediate_register, high_register, BrilligBinaryOp::Mul);
             self.binary(high_register, intermediate_register, high_register, BrilligBinaryOp::Mul);
             // Now we can add.
@@ -411,18 +410,14 @@ impl BrilligContext {
         }
     }
 
-    pub(crate) fn usize_const_instruction(
-        &mut self,
-        result: MemoryAddress,
-        constant: FieldElement,
-    ) {
+    pub(crate) fn usize_const_instruction(&mut self, result: MemoryAddress, constant: F) {
         self.const_instruction(SingleAddrVariable::new_usize(result), constant);
     }
 
     /// Returns a register which holds the value of a constant
     pub(crate) fn make_constant_instruction(
         &mut self,
-        constant: FieldElement,
+        constant: F,
         bit_size: u32,
     ) -> SingleAddrVariable {
         let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
@@ -430,17 +425,14 @@ impl BrilligContext {
         var
     }
 
-    fn make_constant(&mut self, constant: FieldElement, bit_size: u32) -> SingleAddrVariable {
+    fn make_constant(&mut self, constant: F, bit_size: u32) -> SingleAddrVariable {
         let var = SingleAddrVariable::new(self.allocate_register(), bit_size);
         self.constant(var, constant);
         var
     }
 
     /// Returns a register which holds the value of an usize constant
-    pub(crate) fn make_usize_constant_instruction(
-        &mut self,
-        constant: FieldElement,
-    ) -> SingleAddrVariable {
+    pub(crate) fn make_usize_constant_instruction(&mut self, constant: F) -> SingleAddrVariable {
         let register = self.allocate_register();
         self.usize_const_instruction(register, constant);
         SingleAddrVariable::new_usize(register)
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
index f756f06aa69..ae506462b25 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
@@ -82,7 +82,7 @@ impl BrilligRegistersContext {
     }
 }
 
-impl BrilligContext {
+impl<F> BrilligContext<F> {
     /// Returns the i'th register after the reserved ones
     pub(crate) fn register(&self, i: usize) -> MemoryAddress {
         MemoryAddress::from(ReservedRegisters::NUM_RESERVED_REGISTERS + i)
diff --git a/compiler/noirc_evaluator/src/brillig/mod.rs b/compiler/noirc_evaluator/src/brillig/mod.rs
index eda1ac97c1e..70c0959517b 100644
--- a/compiler/noirc_evaluator/src/brillig/mod.rs
+++ b/compiler/noirc_evaluator/src/brillig/mod.rs
@@ -1,6 +1,8 @@
 pub(crate) mod brillig_gen;
 pub(crate) mod brillig_ir;
 
+use acvm::FieldElement;
+
 use self::{
     brillig_gen::{brillig_fn::FunctionContext, convert_ssa_function},
     brillig_ir::artifact::{BrilligArtifact, Label},
@@ -16,7 +18,7 @@ use std::collections::{BTreeSet, HashMap};
 #[derive(Default)]
 pub struct Brillig {
     /// Maps SSA function labels to their brillig artifact
-    ssa_function_to_brillig: HashMap<FunctionId, BrilligArtifact>,
+    ssa_function_to_brillig: HashMap<FunctionId, BrilligArtifact<FieldElement>>,
 }
 
 impl Brillig {
@@ -27,7 +29,10 @@ impl Brillig {
     }
 
     /// Finds a brillig function artifact by its function label
-    pub(crate) fn find_by_function_label(&self, function_label: Label) -> Option<&BrilligArtifact> {
+    pub(crate) fn find_by_function_label(
+        &self,
+        function_label: Label,
+    ) -> Option<&BrilligArtifact<FieldElement>> {
         self.ssa_function_to_brillig.iter().find_map(|(function_id, obj)| {
             if FunctionContext::function_id_to_function_label(*function_id) == function_label {
                 Some(obj)
@@ -39,7 +44,7 @@ impl Brillig {
 }
 
 impl std::ops::Index<FunctionId> for Brillig {
-    type Output = BrilligArtifact;
+    type Output = BrilligArtifact<FieldElement>;
     fn index(&self, id: FunctionId) -> &Self::Output {
         &self.ssa_function_to_brillig[&id]
     }
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 80a63f223e7..f7b6dfd3771 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -206,7 +206,7 @@ pub struct SsaCircuitArtifact {
 }
 
 fn convert_generated_acir_into_circuit(
-    mut generated_acir: GeneratedAcir,
+    mut generated_acir: GeneratedAcir<FieldElement>,
     func_sig: FunctionSignature,
     recursive: bool,
     debug_variables: DebugVariables,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index ac7f2c09687..56b869fbf6b 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -20,7 +20,6 @@ use acvm::{
         native_types::{Expression, Witness},
         BlackBoxFunc,
     },
-    FieldElement,
 };
 use fxhash::FxHashMap as HashMap;
 use iter_extended::{try_vecmap, vecmap};
@@ -48,12 +47,12 @@ impl AcirType {
     }
 
     /// Returns the bit size of the underlying type
-    pub(crate) fn bit_size(&self) -> u32 {
+    pub(crate) fn bit_size<F: AcirField>(&self) -> u32 {
         match self {
             AcirType::NumericType(numeric_type) => match numeric_type {
                 NumericType::Signed { bit_size } => *bit_size,
                 NumericType::Unsigned { bit_size } => *bit_size,
-                NumericType::NativeField => FieldElement::max_num_bits(),
+                NumericType::NativeField => F::max_num_bits(),
             },
             AcirType::Array(_, _) => unreachable!("cannot fetch bit size of array type"),
         }
@@ -106,13 +105,13 @@ impl From<NumericType> for AcirType {
 /// Context object which holds the relationship between
 /// `Variables`(AcirVar) and types such as `Expression` and `Witness`
 /// which are placed into ACIR.
-pub(crate) struct AcirContext {
+pub(crate) struct AcirContext<F: AcirField> {
     /// Two-way map that links `AcirVar` to `AcirVarData`.
     ///
     /// The vars object is an instance of the `TwoWayMap`, which provides a bidirectional mapping between `AcirVar` and `AcirVarData`.
-    vars: HashMap<AcirVar, AcirVarData>,
+    vars: HashMap<AcirVar, AcirVarData<F>>,
 
-    constant_witnesses: HashMap<FieldElement, Witness>,
+    constant_witnesses: HashMap<F, Witness>,
 
     /// An in-memory representation of ACIR.
     ///
@@ -121,13 +120,13 @@ pub(crate) struct AcirContext {
     /// For example, If one was to add two Variables together,
     /// then the `acir_ir` will be populated to assert this
     /// addition.
-    acir_ir: GeneratedAcir,
+    acir_ir: GeneratedAcir<F>,
 
     /// The BigIntContext, used to generate identifiers for BigIntegers
     big_int_ctx: BigIntContext,
 }
 
-impl AcirContext {
+impl<F: AcirField> AcirContext<F> {
     pub(crate) fn current_witness_index(&self) -> Witness {
         self.acir_ir.current_witness_index()
     }
@@ -148,7 +147,7 @@ impl AcirContext {
     }
 
     /// Adds a constant to the context and assigns a Variable to represent it
-    pub(crate) fn add_constant(&mut self, constant: impl Into<FieldElement>) -> AcirVar {
+    pub(crate) fn add_constant(&mut self, constant: impl Into<F>) -> AcirVar {
         let constant_data = AcirVarData::Const(constant.into());
         self.add_data(constant_data)
     }
@@ -156,7 +155,7 @@ impl AcirContext {
     /// Returns the constant represented by the given variable.
     ///
     /// Panics: if the variable does not represent a constant.
-    pub(crate) fn constant(&self, var: AcirVar) -> FieldElement {
+    pub(crate) fn constant(&self, var: AcirVar) -> &F {
         self.vars[&var].as_constant().expect("ICE - expected the variable to be a constant value")
     }
 
@@ -270,10 +269,7 @@ impl AcirContext {
     }
 
     /// Converts an [`AcirVar`] to an [`Expression`]
-    pub(crate) fn var_to_expression(
-        &self,
-        var: AcirVar,
-    ) -> Result<Expression<FieldElement>, InternalError> {
+    pub(crate) fn var_to_expression(&self, var: AcirVar) -> Result<Expression<F>, InternalError> {
         let var_data = match self.vars.get(&var) {
             Some(var_data) => var_data,
             None => {
@@ -408,7 +404,7 @@ impl AcirContext {
 
         if lhs_expr == rhs_expr {
             // x ^ x == 0
-            let zero = self.add_constant(FieldElement::zero());
+            let zero = self.add_constant(F::zero());
             return Ok(zero);
         } else if lhs_expr.is_zero() {
             // 0 ^ x == x
@@ -418,14 +414,14 @@ impl AcirContext {
             return Ok(lhs);
         }
 
-        let bit_size = typ.bit_size();
+        let bit_size = typ.bit_size::<F>();
         if bit_size == 1 {
             // Operands are booleans.
             //
             // a ^ b == a + b - 2*a*b
             let prod = self.mul_var(lhs, rhs)?;
             let sum = self.add_var(lhs, rhs)?;
-            self.add_mul_var(sum, -FieldElement::from(2_i128), prod)
+            self.add_mul_var(sum, -F::from(2_u128), prod)
         } else {
             let inputs = vec![AcirValue::Var(lhs, typ.clone()), AcirValue::Var(rhs, typ)];
             let outputs = self.black_box_function(BlackBoxFunc::XOR, inputs, 1)?;
@@ -448,11 +444,11 @@ impl AcirContext {
             return Ok(lhs);
         } else if lhs_expr.is_zero() || rhs_expr.is_zero() {
             // x & 0 == 0 and 0 & x == 0
-            let zero = self.add_constant(FieldElement::zero());
+            let zero = self.add_constant(F::zero());
             return Ok(zero);
         }
 
-        let bit_size = typ.bit_size();
+        let bit_size = typ.bit_size::<F>();
         if bit_size == 1 {
             // Operands are booleans.
             self.mul_var(lhs, rhs)
@@ -480,7 +476,7 @@ impl AcirContext {
             return Ok(lhs);
         }
 
-        let bit_size = typ.bit_size();
+        let bit_size = typ.bit_size::<F>();
         if bit_size == 1 {
             // Operands are booleans
             // a + b - ab
@@ -502,7 +498,7 @@ impl AcirContext {
         &mut self,
         lhs: AcirVar,
         rhs: AcirVar,
-        assert_message: Option<AssertionPayload<FieldElement>>,
+        assert_message: Option<AssertionPayload<F>>,
     ) -> Result<(), RuntimeError> {
         let lhs_expr = self.var_to_expression(lhs)?;
         let rhs_expr = self.var_to_expression(rhs)?;
@@ -531,7 +527,7 @@ impl AcirContext {
     pub(crate) fn vars_to_expressions_or_memory(
         &self,
         values: &[AcirValue],
-    ) -> Result<Vec<ExpressionOrMemory<FieldElement>>, RuntimeError> {
+    ) -> Result<Vec<ExpressionOrMemory<F>>, RuntimeError> {
         let mut result = Vec::with_capacity(values.len());
         for value in values {
             match value {
@@ -597,7 +593,7 @@ impl AcirContext {
             (AcirVarData::Const(constant), _) | (_, AcirVarData::Const(constant))
                 if constant.is_zero() =>
             {
-                self.add_constant(FieldElement::zero())
+                self.add_constant(F::zero())
             }
 
             (AcirVarData::Const(lhs_constant), AcirVarData::Const(rhs_constant)) => {
@@ -615,7 +611,7 @@ impl AcirContext {
             }
             (AcirVarData::Witness(lhs_witness), AcirVarData::Witness(rhs_witness)) => {
                 let mut expr = Expression::default();
-                expr.push_multiplication_term(FieldElement::one(), lhs_witness, rhs_witness);
+                expr.push_multiplication_term(F::one(), lhs_witness, rhs_witness);
                 self.add_data(AcirVarData::Expr(expr))
             }
             (AcirVarData::Expr(expression), AcirVarData::Witness(witness))
@@ -681,12 +677,7 @@ impl AcirContext {
 
     /// Adds a new Variable to context whose value will
     /// be constrained to be the expression `lhs + k * rhs`
-    fn add_mul_var(
-        &mut self,
-        lhs: AcirVar,
-        k: FieldElement,
-        rhs: AcirVar,
-    ) -> Result<AcirVar, RuntimeError> {
+    fn add_mul_var(&mut self, lhs: AcirVar, k: F, rhs: AcirVar) -> Result<AcirVar, RuntimeError> {
         let k_var = self.add_constant(k);
 
         let intermediate = self.mul_var(k_var, rhs)?;
@@ -695,7 +686,7 @@ impl AcirContext {
 
     /// Adds a new variable that is constrained to be the logical NOT of `x`.
     pub(crate) fn not_var(&mut self, x: AcirVar, typ: AcirType) -> Result<AcirVar, RuntimeError> {
-        let bit_size = typ.bit_size();
+        let bit_size = typ.bit_size::<F>();
         // Subtracting from max flips the bits
         let max = self.add_constant((1_u128 << bit_size) - 1);
         self.sub_var(max, x)
@@ -709,8 +700,8 @@ impl AcirContext {
         bit_size: u32,
         predicate: AcirVar,
     ) -> Result<(AcirVar, AcirVar), RuntimeError> {
-        let zero = self.add_constant(FieldElement::zero());
-        let one = self.add_constant(FieldElement::one());
+        let zero = self.add_constant(F::zero());
+        let one = self.add_constant(F::one());
 
         let lhs_expr = self.var_to_expression(lhs)?;
         let rhs_expr = self.var_to_expression(rhs)?;
@@ -829,7 +820,7 @@ impl AcirContext {
 
         // Avoids overflow: 'q*b+r < 2^max_q_bits*2^max_rhs_bits'
         let mut avoid_overflow = false;
-        if max_q_bits + max_rhs_bits >= FieldElement::max_num_bits() - 1 {
+        if max_q_bits + max_rhs_bits >= F::max_num_bits() - 1 {
             // q*b+r can overflow; we avoid this when b is constant
             if rhs_expr.is_const() {
                 avoid_overflow = true;
@@ -843,16 +834,16 @@ impl AcirContext {
             if avoid_overflow {
                 // we compute q0 = p/rhs
                 let rhs_big = BigUint::from_bytes_be(&rhs_const.to_be_bytes());
-                let q0_big = FieldElement::modulus() / &rhs_big;
-                let q0 = FieldElement::from_be_bytes_reduce(&q0_big.to_bytes_be());
+                let q0_big = F::modulus() / &rhs_big;
+                let q0 = F::from_be_bytes_reduce(&q0_big.to_bytes_be());
                 let q0_var = self.add_constant(q0);
                 // when q == q0, b*q+r can overflow so we need to bound r to avoid the overflow.
 
                 let size_predicate = self.eq_var(q0_var, quotient_var)?;
                 let predicate = self.mul_var(size_predicate, predicate)?;
                 // Ensure that there is no overflow, under q == q0 predicate
-                let max_r_big = FieldElement::modulus() - q0_big * rhs_big;
-                let max_r = FieldElement::from_be_bytes_reduce(&max_r_big.to_bytes_be());
+                let max_r_big = F::modulus() - q0_big * rhs_big;
+                let max_r = F::from_be_bytes_reduce(&max_r_big.to_bytes_be());
                 let max_r_var = self.add_constant(max_r);
 
                 let max_r_predicate = self.mul_var(predicate, max_r_var)?;
@@ -897,7 +888,7 @@ impl AcirContext {
         }
 
         assert!(
-            bits < FieldElement::max_num_bits(),
+            bits < F::max_num_bits(),
             "range check with bit size of the prime field is not implemented yet"
         );
 
@@ -921,7 +912,7 @@ impl AcirContext {
             // however, since it is a constant, we can compute it's actual bit size
             let r_bit_size = bit_size_u128(r);
             // witness = lhs_offset + r
-            assert!(bits + r_bit_size < FieldElement::max_num_bits()); //we need to ensure lhs_offset + r does not overflow
+            assert!(bits + r_bit_size < F::max_num_bits()); //we need to ensure lhs_offset + r does not overflow
 
             let r_var = self.add_constant(r);
             let aor = self.add_var(lhs_offset, r_var)?;
@@ -945,14 +936,13 @@ impl AcirContext {
         leading: AcirVar,
         max_bit_size: u32,
     ) -> Result<AcirVar, RuntimeError> {
-        let max_power_of_two = self.add_constant(
-            FieldElement::from(2_i128).pow(&FieldElement::from(max_bit_size as i128 - 1)),
-        );
+        let max_power_of_two =
+            self.add_constant(F::from(2_u128).pow(&F::from(max_bit_size as u128 - 1)));
 
         let intermediate = self.sub_var(max_power_of_two, lhs)?;
         let intermediate = self.mul_var(intermediate, leading)?;
 
-        self.add_mul_var(lhs, FieldElement::from(2_i128), intermediate)
+        self.add_mul_var(lhs, F::from(2_u128), intermediate)
     }
 
     /// Returns the quotient and remainder such that lhs = rhs * quotient + remainder
@@ -976,11 +966,10 @@ impl AcirContext {
         assert_ne!(bit_size, 0, "signed integer should have at least one bit");
 
         // 2^{max_bit size-1}
-        let max_power_of_two = self.add_constant(
-            FieldElement::from(2_i128).pow(&FieldElement::from(bit_size as i128 - 1)),
-        );
-        let zero = self.add_constant(FieldElement::zero());
-        let one = self.add_constant(FieldElement::one());
+        let max_power_of_two =
+            self.add_constant(F::from(2_u128).pow(&F::from(bit_size as u128 - 1)));
+        let zero = self.add_constant(F::zero());
+        let one = self.add_constant(F::one());
 
         // Get the sign bit of rhs by computing rhs / max_power_of_two
         let (rhs_leading, _) = self.euclidean_division_var(rhs, max_power_of_two, bit_size, one)?;
@@ -1071,9 +1060,8 @@ impl AcirContext {
         max_bit_size: u32,
     ) -> Result<AcirVar, RuntimeError> {
         // 2^{rhs}
-        let divisor =
-            self.add_constant(FieldElement::from(2_u128).pow(&FieldElement::from(rhs as u128)));
-        let one = self.add_constant(FieldElement::one());
+        let divisor = self.add_constant(F::from(2_u128).pow(&F::from(rhs as u128)));
+        let one = self.add_constant(F::one());
 
         //  Computes lhs = 2^{rhs} * q + r
         let (_, remainder) = self.euclidean_division_var(lhs, divisor, max_bit_size, one)?;
@@ -1093,8 +1081,8 @@ impl AcirContext {
         rhs: AcirVar,
         bit_count: u32,
     ) -> Result<AcirVar, RuntimeError> {
-        let pow_last = self.add_constant(FieldElement::from(1_u128 << (bit_count - 1)));
-        let pow = self.add_constant(FieldElement::from(1_u128 << (bit_count)));
+        let pow_last = self.add_constant(F::from(1_u128 << (bit_count - 1)));
+        let pow = self.add_constant(F::from(1_u128 << (bit_count)));
 
         // We check whether the inputs have same sign or not by computing the XOR of their bit sign
 
@@ -1163,10 +1151,9 @@ impl AcirContext {
         // Ensure that 2^{max_bits + 1} is less than the field size
         //
         // TODO: perhaps this should be a user error, instead of an assert
-        assert!(max_bits + 1 < FieldElement::max_num_bits());
+        assert!(max_bits + 1 < F::max_num_bits());
 
-        let two_max_bits = self
-            .add_constant(FieldElement::from(2_i128).pow(&FieldElement::from(max_bits as i128)));
+        let two_max_bits = self.add_constant(F::from(2_u128).pow(&F::from(max_bits as u128)));
         let diff = self.sub_var(lhs, rhs)?;
         let comparison_evaluation = self.add_var(diff, two_max_bits)?;
 
@@ -1214,7 +1201,7 @@ impl AcirContext {
         // compute less than.
         let comparison = self.more_than_eq_var(lhs, rhs, bit_size)?;
 
-        let one = self.add_constant(FieldElement::one());
+        let one = self.add_constant(F::one());
         self.sub_var(one, comparison) // comparison_negated
     }
 
@@ -1251,7 +1238,7 @@ impl AcirContext {
                     }
                 };
 
-                (vec![domain_constant], Vec::new())
+                (vec![*domain_constant], Vec::new())
             }
             BlackBoxFunc::Poseidon2Permutation => {
                 // The last argument is the state length, which must be a constant
@@ -1276,7 +1263,7 @@ impl AcirContext {
                     }
                 };
 
-                (vec![state_len], Vec::new())
+                (vec![*state_len], Vec::new())
             }
             BlackBoxFunc::BigIntAdd
             | BlackBoxFunc::BigIntSub
@@ -1297,7 +1284,7 @@ impl AcirContext {
                 output_count = 0;
                 let mut field_inputs = Vec::new();
                 for i in const_inputs {
-                    field_inputs.push(i?);
+                    field_inputs.push(*i?);
                 }
                 if field_inputs[1] != field_inputs[3] {
                     return Err(RuntimeError::BigIntModulus { call_stack: self.get_call_stack() });
@@ -1306,7 +1293,7 @@ impl AcirContext {
                 let result_id = self.big_int_ctx.new_big_int(field_inputs[1]);
                 (
                     vec![field_inputs[0], field_inputs[2]],
-                    vec![result_id.bigint_id(), result_id.modulus_id()],
+                    vec![result_id.bigint_id::<F>(), result_id.modulus_id::<F>()],
                 )
             }
             BlackBoxFunc::BigIntToLeBytes => {
@@ -1323,10 +1310,10 @@ impl AcirContext {
                 inputs = Vec::new();
                 let mut field_inputs = Vec::new();
                 for i in const_inputs {
-                    field_inputs.push(i?);
+                    field_inputs.push(*i?);
                 }
                 let bigint = self.big_int_ctx.get(field_inputs[0]);
-                let modulus = self.big_int_ctx.modulus(bigint.modulus_id());
+                let modulus = self.big_int_ctx.modulus(bigint.modulus_id::<F>());
                 let bytes_len = ((modulus - BigUint::from(1_u32)).bits() - 1) / 8 + 1;
                 output_count = bytes_len as usize;
                 assert!(bytes_len == 32);
@@ -1339,7 +1326,7 @@ impl AcirContext {
                 match inputs.pop().expect(invalid_input) {
                     AcirValue::Array(values) => {
                         for value in values {
-                            modulus.push(self.vars[&value.into_var()?].as_constant().ok_or(
+                            modulus.push(*self.vars[&value.into_var()?].as_constant().ok_or(
                                 RuntimeError::InternalError(InternalError::NotAConstant {
                                     name: "big integer".to_string(),
                                     call_stack: self.get_call_stack(),
@@ -1359,9 +1346,8 @@ impl AcirContext {
                 output_count = 0;
 
                 let modulus_id = self.big_int_ctx.get_or_insert_modulus(big_modulus);
-                let result_id =
-                    self.big_int_ctx.new_big_int(FieldElement::from(modulus_id as u128));
-                (modulus, vec![result_id.bigint_id(), result_id.modulus_id()])
+                let result_id = self.big_int_ctx.new_big_int(F::from(modulus_id as u128));
+                (modulus, vec![result_id.bigint_id::<F>(), result_id.modulus_id::<F>()])
             }
             BlackBoxFunc::AES128Encrypt => {
                 let invalid_input = "aes128_encrypt - operation requires a plaintext to encrypt";
@@ -1376,7 +1362,7 @@ impl AcirContext {
                     }
                 }?;
                 output_count = input_size + (16 - input_size % 16);
-                (vec![], vec![FieldElement::from(output_count as u128)])
+                (vec![], vec![F::from(output_count as u128)])
             }
             _ => (vec![], vec![]),
         };
@@ -1420,7 +1406,7 @@ impl AcirContext {
                 // constants too.
                 let witness_var = self.get_or_create_witness_var(input)?;
                 let witness = self.var_to_witness(witness_var)?;
-                let num_bits = typ.bit_size();
+                let num_bits = typ.bit_size::<F>();
                 single_val_witnesses.push(FunctionInput { witness, num_bits });
             }
             witnesses.push(single_val_witnesses);
@@ -1531,7 +1517,7 @@ impl AcirContext {
         inputs: Vec<Witness>,
         return_values: Vec<Witness>,
         warnings: Vec<SsaReport>,
-    ) -> GeneratedAcir {
+    ) -> GeneratedAcir<F> {
         self.acir_ir.input_witnesses = inputs;
         self.acir_ir.return_witnesses = return_values;
         self.acir_ir.warnings = warnings;
@@ -1543,7 +1529,7 @@ impl AcirContext {
     /// Variable can be seen as an index into the context.
     /// We use a two-way map so that it is efficient to lookup
     /// either the key or the value.
-    fn add_data(&mut self, data: AcirVarData) -> AcirVar {
+    fn add_data(&mut self, data: AcirVarData<F>) -> AcirVar {
         let id = AcirVar(self.vars.len());
         self.vars.insert(id, data);
         id
@@ -1553,7 +1539,7 @@ impl AcirContext {
     pub(crate) fn brillig_call(
         &mut self,
         predicate: AcirVar,
-        generated_brillig: &GeneratedBrillig,
+        generated_brillig: &GeneratedBrillig<F>,
         inputs: Vec<AcirValue>,
         outputs: Vec<AcirType>,
         attempt_execution: bool,
@@ -1561,14 +1547,14 @@ impl AcirContext {
         brillig_function_index: u32,
         brillig_stdlib_func: Option<BrilligStdlibFunc>,
     ) -> Result<Vec<AcirValue>, RuntimeError> {
-        let brillig_inputs: Vec<BrilligInputs<FieldElement>> =
+        let brillig_inputs: Vec<BrilligInputs<F>> =
             try_vecmap(inputs, |i| -> Result<_, InternalError> {
                 match i {
                     AcirValue::Var(var, _) => {
                         Ok(BrilligInputs::Single(self.var_to_expression(var)?))
                     }
                     AcirValue::Array(vars) => {
-                        let mut var_expressions: Vec<Expression<FieldElement>> = Vec::new();
+                        let mut var_expressions: Vec<Expression<F>> = Vec::new();
                         for var in vars {
                             self.brillig_array_input(&mut var_expressions, var)?;
                         }
@@ -1619,8 +1605,8 @@ impl AcirContext {
             brillig_stdlib_func,
         );
 
-        fn range_constraint_value(
-            context: &mut AcirContext,
+        fn range_constraint_value<G: AcirField>(
+            context: &mut AcirContext<G>,
             value: &AcirValue,
         ) -> Result<(), RuntimeError> {
             match value {
@@ -1655,7 +1641,7 @@ impl AcirContext {
 
     fn brillig_array_input(
         &mut self,
-        var_expressions: &mut Vec<Expression<FieldElement>>,
+        var_expressions: &mut Vec<Expression<F>>,
         input: AcirValue,
     ) -> Result<(), InternalError> {
         match input {
@@ -1714,8 +1700,8 @@ impl AcirContext {
 
     fn execute_brillig(
         &mut self,
-        code: &[BrilligOpcode<FieldElement>],
-        inputs: &[BrilligInputs<FieldElement>],
+        code: &[BrilligOpcode<F>],
+        inputs: &[BrilligInputs<F>],
         outputs_types: &[AcirType],
     ) -> Option<Vec<AcirValue>> {
         let mut memory = (execute_brillig(code, inputs)?).into_iter();
@@ -1740,7 +1726,7 @@ impl AcirContext {
         &mut self,
         element_types: &[AcirType],
         size: usize,
-        memory_iter: &mut impl Iterator<Item = MemoryValue<FieldElement>>,
+        memory_iter: &mut impl Iterator<Item = MemoryValue<F>>,
     ) -> AcirValue {
         let mut array_values = im::Vector::new();
         for _ in 0..size {
@@ -1821,7 +1807,7 @@ impl AcirContext {
     ) -> Result<(), InternalError> {
         let initialized_values = match optional_value {
             None => {
-                let zero = self.add_constant(FieldElement::zero());
+                let zero = self.add_constant(F::zero());
                 let zero_witness = self.var_to_witness(zero)?;
                 vec![zero_witness; len]
             }
@@ -1893,13 +1879,13 @@ impl AcirContext {
 /// Enum representing the possible values that a
 /// Variable can be given.
 #[derive(Debug, Eq, Clone)]
-enum AcirVarData {
+enum AcirVarData<F> {
     Witness(Witness),
-    Expr(Expression<FieldElement>),
-    Const(FieldElement),
+    Expr(Expression<F>),
+    Const(F),
 }
 
-impl PartialEq for AcirVarData {
+impl<F: PartialEq> PartialEq for AcirVarData<F> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::Witness(l0), Self::Witness(r0)) => l0 == r0,
@@ -1911,23 +1897,26 @@ impl PartialEq for AcirVarData {
 }
 
 // TODO: check/test this hash impl
-impl std::hash::Hash for AcirVarData {
+impl<F> std::hash::Hash for AcirVarData<F> {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         core::mem::discriminant(self).hash(state);
     }
 }
 
-impl AcirVarData {
+impl<F> AcirVarData<F> {
     /// Returns a FieldElement, if the underlying `AcirVarData`
     /// represents a constant.
-    pub(crate) fn as_constant(&self) -> Option<FieldElement> {
+    pub(crate) fn as_constant(&self) -> Option<&F> {
         if let AcirVarData::Const(field) = self {
-            return Some(*field);
+            return Some(field);
         }
         None
     }
+}
+
+impl<F: AcirField> AcirVarData<F> {
     /// Converts all enum variants to an Expression.
-    pub(crate) fn to_expression(&self) -> Cow<Expression<FieldElement>> {
+    pub(crate) fn to_expression(&self) -> Cow<Expression<F>> {
         match self {
             AcirVarData::Witness(witness) => Cow::Owned(Expression::from(*witness)),
             AcirVarData::Expr(expr) => Cow::Borrowed(expr),
@@ -1936,23 +1925,17 @@ impl AcirVarData {
     }
 }
 
-impl From<FieldElement> for AcirVarData {
-    fn from(constant: FieldElement) -> Self {
-        AcirVarData::Const(constant)
-    }
-}
-
-impl From<Witness> for AcirVarData {
+impl<F> From<Witness> for AcirVarData<F> {
     fn from(witness: Witness) -> Self {
         AcirVarData::Witness(witness)
     }
 }
 
-impl From<Expression<FieldElement>> for AcirVarData {
-    fn from(expr: Expression<FieldElement>) -> Self {
+impl<F: AcirField> From<Expression<F>> for AcirVarData<F> {
+    fn from(expr: Expression<F>) -> Self {
         // Prefer simpler variants if possible.
         if let Some(constant) = expr.to_const() {
-            AcirVarData::from(*constant)
+            AcirVarData::Const(*constant)
         } else if let Some(witness) = expr.to_witness() {
             AcirVarData::from(witness)
         } else {
@@ -1970,12 +1953,12 @@ pub(crate) struct AcirVar(usize);
 /// Returns the finished state of the Brillig VM if execution can complete.
 ///
 /// Returns `None` if complete execution of the Brillig bytecode is not possible.
-fn execute_brillig(
-    code: &[BrilligOpcode<FieldElement>],
-    inputs: &[BrilligInputs<FieldElement>],
-) -> Option<Vec<MemoryValue<FieldElement>>> {
+fn execute_brillig<F: AcirField>(
+    code: &[BrilligOpcode<F>],
+    inputs: &[BrilligInputs<F>],
+) -> Option<Vec<MemoryValue<F>>> {
     // Set input values
-    let mut calldata: Vec<FieldElement> = Vec::new();
+    let mut calldata: Vec<F> = Vec::new();
 
     // Each input represents a constant or array of constants.
     // Iterate over each input and push it into registers and/or memory.
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
index b9c596d80c7..30297b42ecf 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
@@ -1,4 +1,4 @@
-use acvm::{acir::AcirField, FieldElement};
+use acvm::acir::AcirField;
 use num_bigint::BigUint;
 
 /// Represents a bigint value in the form (id, modulus) where
@@ -11,12 +11,12 @@ pub(crate) struct BigIntId {
 }
 
 impl BigIntId {
-    pub(crate) fn bigint_id(&self) -> FieldElement {
-        FieldElement::from(self.bigint_id as u128)
+    pub(crate) fn bigint_id<F: From<u128>>(&self) -> F {
+        F::from(self.bigint_id as u128)
     }
 
-    pub(crate) fn modulus_id(&self) -> FieldElement {
-        FieldElement::from(self.modulus_id as u128)
+    pub(crate) fn modulus_id<F: From<u128>>(&self) -> F {
+        F::from(self.modulus_id as u128)
     }
 }
 
@@ -29,7 +29,7 @@ pub(crate) struct BigIntContext {
 
 impl BigIntContext {
     /// Creates a new BigIntId for the given modulus identifier and returns it.
-    pub(crate) fn new_big_int(&mut self, modulus_id: FieldElement) -> BigIntId {
+    pub(crate) fn new_big_int<F: AcirField>(&mut self, modulus_id: F) -> BigIntId {
         let id = self.big_integers.len() as u32;
         let result = BigIntId { bigint_id: id, modulus_id: modulus_id.to_u128() as u32 };
         self.big_integers.push(result);
@@ -37,12 +37,12 @@ impl BigIntContext {
     }
 
     /// Returns the modulus corresponding to the given modulus index
-    pub(crate) fn modulus(&self, idx: FieldElement) -> BigUint {
+    pub(crate) fn modulus<F: AcirField>(&self, idx: F) -> BigUint {
         self.modulus[idx.to_u128() as usize].clone()
     }
 
     /// Returns the BigIntId corresponding to the given identifier
-    pub(crate) fn get(&self, id: FieldElement) -> BigIntId {
+    pub(crate) fn get<F: AcirField>(&self, id: F) -> BigIntId {
         self.big_integers[id.to_u128() as usize]
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 9a09e7c06ee..9d271f7cd9c 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -19,7 +19,6 @@ use acvm::acir::{
 use acvm::{
     acir::AcirField,
     acir::{circuit::directives::Directive, native_types::Expression},
-    FieldElement,
 };
 use iter_extended::vecmap;
 use num_bigint::BigUint;
@@ -32,7 +31,7 @@ pub(crate) const PLACEHOLDER_BRILLIG_INDEX: u32 = 0;
 
 #[derive(Debug, Default)]
 /// The output of the Acir-gen pass, which should only be produced for entry point Acir functions
-pub(crate) struct GeneratedAcir {
+pub(crate) struct GeneratedAcir<F: AcirField> {
     /// The next witness index that may be declared.
     /// If witness index is `None` then we have not yet created a witness
     /// and thus next witness index that be declared is zero.
@@ -42,7 +41,7 @@ pub(crate) struct GeneratedAcir {
     current_witness_index: Option<u32>,
 
     /// The opcodes of which the compiled ACIR will comprise.
-    opcodes: Vec<AcirOpcode<FieldElement>>,
+    opcodes: Vec<AcirOpcode<F>>,
 
     /// All witness indices that comprise the final return value of the program
     pub(crate) return_witnesses: Vec<Witness>,
@@ -58,7 +57,7 @@ pub(crate) struct GeneratedAcir {
     pub(crate) call_stack: CallStack,
 
     /// Correspondence between an opcode index and the error message associated with it.
-    pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload<FieldElement>>,
+    pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload<F>>,
 
     pub(crate) warnings: Vec<SsaReport>,
 
@@ -80,7 +79,7 @@ pub(crate) enum BrilligStdlibFunc {
 }
 
 impl BrilligStdlibFunc {
-    pub(crate) fn get_generated_brillig(&self) -> GeneratedBrillig {
+    pub(crate) fn get_generated_brillig<F: AcirField>(&self) -> GeneratedBrillig<F> {
         match self {
             BrilligStdlibFunc::Inverse => brillig_directive::directive_invert(),
             BrilligStdlibFunc::Quotient(bit_size) => {
@@ -90,25 +89,25 @@ impl BrilligStdlibFunc {
     }
 }
 
-impl GeneratedAcir {
+impl<F: AcirField> GeneratedAcir<F> {
     /// Returns the current witness index.
     pub(crate) fn current_witness_index(&self) -> Witness {
         Witness(self.current_witness_index.unwrap_or(0))
     }
 
     /// Adds a new opcode into ACIR.
-    pub(crate) fn push_opcode(&mut self, opcode: AcirOpcode<FieldElement>) {
+    pub(crate) fn push_opcode(&mut self, opcode: AcirOpcode<F>) {
         self.opcodes.push(opcode);
         if !self.call_stack.is_empty() {
             self.locations.insert(self.last_acir_opcode_location(), self.call_stack.clone());
         }
     }
 
-    pub(crate) fn opcodes(&self) -> &[AcirOpcode<FieldElement>] {
+    pub(crate) fn opcodes(&self) -> &[AcirOpcode<F>] {
         &self.opcodes
     }
 
-    pub(crate) fn take_opcodes(&mut self) -> Vec<AcirOpcode<FieldElement>> {
+    pub(crate) fn take_opcodes(&mut self) -> Vec<AcirOpcode<F>> {
         std::mem::take(&mut self.opcodes)
     }
 
@@ -127,7 +126,7 @@ impl GeneratedAcir {
     ///
     /// If `expr` can be represented as a `Witness` then this function will return it,
     /// else a new opcode will be added to create a `Witness` that is equal to `expr`.
-    pub(crate) fn get_or_create_witness(&mut self, expr: &Expression<FieldElement>) -> Witness {
+    pub(crate) fn get_or_create_witness(&mut self, expr: &Expression<F>) -> Witness {
         match expr.to_witness() {
             Some(witness) => witness,
             None => self.create_witness_for_expression(expr),
@@ -140,10 +139,7 @@ impl GeneratedAcir {
     /// This means you cannot multiply an infinite amount of `Expression`s together.
     /// Once the `Expression` goes over degree-2, then it needs to be reduced to a `Witness`
     /// which has degree-1 in order to be able to continue the multiplication chain.
-    pub(crate) fn create_witness_for_expression(
-        &mut self,
-        expression: &Expression<FieldElement>,
-    ) -> Witness {
+    pub(crate) fn create_witness_for_expression(&mut self, expression: &Expression<F>) -> Witness {
         let fresh_witness = self.next_witness_index();
 
         // Create a constraint that sets them to be equal to each other
@@ -163,15 +159,15 @@ impl GeneratedAcir {
     }
 }
 
-impl GeneratedAcir {
+impl<F: AcirField> GeneratedAcir<F> {
     /// Calls a black box function and returns the output
     /// of said blackbox function.
     pub(crate) fn call_black_box(
         &mut self,
         func_name: BlackBoxFunc,
         inputs: &[Vec<FunctionInput>],
-        constant_inputs: Vec<FieldElement>,
-        constant_outputs: Vec<FieldElement>,
+        constant_inputs: Vec<F>,
+        constant_outputs: Vec<F>,
         output_count: usize,
     ) -> Result<Vec<Witness>, InternalError> {
         let input_count = inputs.iter().fold(0usize, |sum, val| sum + val.len());
@@ -388,7 +384,7 @@ impl GeneratedAcir {
     /// Only radix that are a power of two are supported
     pub(crate) fn radix_le_decompose(
         &mut self,
-        input_expr: &Expression<FieldElement>,
+        input_expr: &Expression<F>,
         radix: u32,
         limb_count: u32,
         bit_size: u32,
@@ -414,7 +410,7 @@ impl GeneratedAcir {
             self.range_constraint(*limb_witness, bit_size)?;
 
             composed_limbs = composed_limbs.add_mul(
-                FieldElement::from_be_bytes_reduce(&radix_pow.to_bytes_be()),
+                F::from_be_bytes_reduce(&radix_pow.to_bytes_be()),
                 &Expression::from(*limb_witness),
             );
 
@@ -434,7 +430,7 @@ impl GeneratedAcir {
     ///
     /// Safety: It is the callers responsibility to ensure that the
     /// resulting `Witness` is constrained to be the inverse.
-    pub(crate) fn brillig_inverse(&mut self, expr: Expression<FieldElement>) -> Witness {
+    pub(crate) fn brillig_inverse(&mut self, expr: Expression<F>) -> Witness {
         // Create the witness for the result
         let inverted_witness = self.next_witness_index();
 
@@ -458,18 +454,14 @@ impl GeneratedAcir {
     ///
     /// If `expr` is not zero, then the constraint system will
     /// fail upon verification.
-    pub(crate) fn assert_is_zero(&mut self, expr: Expression<FieldElement>) {
+    pub(crate) fn assert_is_zero(&mut self, expr: Expression<F>) {
         self.push_opcode(AcirOpcode::AssertZero(expr));
     }
 
     /// Returns a `Witness` that is constrained to be:
     /// - `1` if `lhs == rhs`
     /// - `0` otherwise
-    pub(crate) fn is_equal(
-        &mut self,
-        lhs: &Expression<FieldElement>,
-        rhs: &Expression<FieldElement>,
-    ) -> Witness {
+    pub(crate) fn is_equal(&mut self, lhs: &Expression<F>, rhs: &Expression<F>) -> Witness {
         let t = lhs - rhs;
 
         self.is_zero(&t)
@@ -527,13 +519,13 @@ impl GeneratedAcir {
     /// By setting `z` to be `0`, we can make `y` equal to `1`.
     /// This is easily observed: `y = 1 - t * 0`
     /// Now since `y` is one, this means that `t` needs to be zero, or else `y * t == 0` will fail.
-    fn is_zero(&mut self, t_expr: &Expression<FieldElement>) -> Witness {
+    fn is_zero(&mut self, t_expr: &Expression<F>) -> Witness {
         // We're checking for equality with zero so we can negate the expression without changing the result.
         // This is useful as it will sometimes allow us to simplify an expression down to a witness.
         let t_witness = if let Some(witness) = t_expr.to_witness() {
             witness
         } else {
-            let negated_expr = t_expr * -FieldElement::one();
+            let negated_expr = t_expr * -F::one();
             self.get_or_create_witness(&negated_expr)
         };
 
@@ -545,17 +537,17 @@ impl GeneratedAcir {
 
         // Add constraint y == 1 - tz => y + tz - 1 == 0
         let y_is_boolean_constraint = Expression {
-            mul_terms: vec![(FieldElement::one(), t_witness, z)],
-            linear_combinations: vec![(FieldElement::one(), y)],
-            q_c: -FieldElement::one(),
+            mul_terms: vec![(F::one(), t_witness, z)],
+            linear_combinations: vec![(F::one(), y)],
+            q_c: -F::one(),
         };
         self.assert_is_zero(y_is_boolean_constraint);
 
         // Add constraint that y * t == 0;
         let ty_zero_constraint = Expression {
-            mul_terms: vec![(FieldElement::one(), t_witness, y)],
+            mul_terms: vec![(F::one(), t_witness, y)],
             linear_combinations: vec![],
-            q_c: FieldElement::zero(),
+            q_c: F::zero(),
         };
         self.assert_is_zero(ty_zero_constraint);
 
@@ -571,9 +563,9 @@ impl GeneratedAcir {
     ) -> Result<(), RuntimeError> {
         // We class this as an error because users should instead
         // do `as Field`.
-        if num_bits >= FieldElement::max_num_bits() {
+        if num_bits >= F::max_num_bits() {
             return Err(RuntimeError::InvalidRangeConstraint {
-                num_bits: FieldElement::max_num_bits(),
+                num_bits: F::max_num_bits(),
                 call_stack: self.call_stack.clone(),
             });
         };
@@ -588,9 +580,9 @@ impl GeneratedAcir {
 
     pub(crate) fn brillig_call(
         &mut self,
-        predicate: Option<Expression<FieldElement>>,
-        generated_brillig: &GeneratedBrillig,
-        inputs: Vec<BrilligInputs<FieldElement>>,
+        predicate: Option<Expression<F>>,
+        generated_brillig: &GeneratedBrillig<F>,
+        inputs: Vec<BrilligInputs<F>>,
         outputs: Vec<BrilligOutputs>,
         brillig_function_index: u32,
         stdlib_func: Option<BrilligStdlibFunc>,
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 40170e58a30..aaa483b91c9 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -42,11 +42,11 @@ use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
 
 #[derive(Default)]
-struct SharedContext {
+struct SharedContext<F> {
     /// Final list of Brillig functions which will be part of the final program
     /// This is shared across `Context` structs as we want one list of Brillig
     /// functions across all ACIR artifacts
-    generated_brillig: Vec<GeneratedBrillig>,
+    generated_brillig: Vec<GeneratedBrillig<F>>,
 
     /// Maps SSA function index -> Final generated Brillig artifact index.
     /// There can be Brillig functions specified in SSA which do not act as
@@ -65,7 +65,7 @@ struct SharedContext {
     brillig_stdlib_calls_to_resolve: HashMap<FunctionId, Vec<(OpcodeLocation, u32)>>,
 }
 
-impl SharedContext {
+impl<F: AcirField> SharedContext<F> {
     fn generated_brillig_pointer(
         &self,
         func_id: FunctionId,
@@ -74,7 +74,7 @@ impl SharedContext {
         self.brillig_generated_func_pointers.get(&(func_id, arguments))
     }
 
-    fn generated_brillig(&self, func_pointer: usize) -> &GeneratedBrillig {
+    fn generated_brillig(&self, func_pointer: usize) -> &GeneratedBrillig<F> {
         &self.generated_brillig[func_pointer]
     }
 
@@ -83,7 +83,7 @@ impl SharedContext {
         func_id: FunctionId,
         arguments: Vec<BrilligParameter>,
         generated_pointer: u32,
-        code: GeneratedBrillig,
+        code: GeneratedBrillig<F>,
     ) {
         self.brillig_generated_func_pointers.insert((func_id, arguments), generated_pointer);
         self.generated_brillig.push(code);
@@ -123,7 +123,7 @@ impl SharedContext {
         generated_pointer: u32,
         func_id: FunctionId,
         opcode_location: OpcodeLocation,
-        code: GeneratedBrillig,
+        code: GeneratedBrillig<F>,
     ) {
         self.brillig_stdlib_func_pointer.insert(brillig_stdlib_func, generated_pointer);
         self.add_call_to_resolve(func_id, (opcode_location, generated_pointer));
@@ -151,7 +151,7 @@ struct Context<'a> {
     current_side_effects_enabled_var: AcirVar,
 
     /// Manages and builds the `AcirVar`s to which the converted SSA values refer.
-    acir_context: AcirContext,
+    acir_context: AcirContext<FieldElement>,
 
     /// Track initialized acir dynamic arrays
     ///
@@ -189,7 +189,7 @@ struct Context<'a> {
     data_bus: DataBus,
 
     /// Contains state that is generated and also used across ACIR functions
-    shared_context: &'a mut SharedContext,
+    shared_context: &'a mut SharedContext<FieldElement>,
 }
 
 #[derive(Clone)]
@@ -274,8 +274,11 @@ impl AcirValue {
     }
 }
 
-pub(crate) type Artifacts =
-    (Vec<GeneratedAcir>, Vec<BrilligBytecode<FieldElement>>, BTreeMap<ErrorSelector, ErrorType>);
+pub(crate) type Artifacts = (
+    Vec<GeneratedAcir<FieldElement>>,
+    Vec<BrilligBytecode<FieldElement>>,
+    BTreeMap<ErrorSelector, ErrorType>,
+);
 
 impl Ssa {
     #[tracing::instrument(level = "trace", skip_all)]
@@ -331,7 +334,7 @@ impl Ssa {
 }
 
 impl<'a> Context<'a> {
-    fn new(shared_context: &'a mut SharedContext) -> Context<'a> {
+    fn new(shared_context: &'a mut SharedContext<FieldElement>) -> Context<'a> {
         let mut acir_context = AcirContext::default();
         let current_side_effects_enabled_var = acir_context.add_constant(FieldElement::one());
 
@@ -354,7 +357,7 @@ impl<'a> Context<'a> {
         ssa: &Ssa,
         function: &Function,
         brillig: &Brillig,
-    ) -> Result<Option<GeneratedAcir>, RuntimeError> {
+    ) -> Result<Option<GeneratedAcir<FieldElement>>, RuntimeError> {
         match function.runtime() {
             RuntimeType::Acir(inline_type) => {
                 match inline_type {
@@ -386,7 +389,7 @@ impl<'a> Context<'a> {
         main_func: &Function,
         ssa: &Ssa,
         brillig: &Brillig,
-    ) -> Result<GeneratedAcir, RuntimeError> {
+    ) -> Result<GeneratedAcir<FieldElement>, RuntimeError> {
         let dfg = &main_func.dfg;
         let entry_block = &dfg[main_func.entry_block()];
         let input_witness = self.convert_ssa_block_params(entry_block.parameters(), dfg)?;
@@ -435,7 +438,7 @@ impl<'a> Context<'a> {
         mut self,
         main_func: &Function,
         brillig: &Brillig,
-    ) -> Result<GeneratedAcir, RuntimeError> {
+    ) -> Result<GeneratedAcir<FieldElement>, RuntimeError> {
         let dfg = &main_func.dfg;
 
         let inputs = try_vecmap(dfg[main_func.entry_block()].parameters(), |param_id| {
@@ -919,7 +922,7 @@ impl<'a> Context<'a> {
         func: &Function,
         arguments: Vec<BrilligParameter>,
         brillig: &Brillig,
-    ) -> Result<GeneratedBrillig, InternalError> {
+    ) -> Result<GeneratedBrillig<FieldElement>, InternalError> {
         // Create the entry point artifact
         let mut entry_point = BrilligContext::new_entry_point_artifact(
             arguments,
@@ -1897,7 +1900,7 @@ impl<'a> Context<'a> {
         }
 
         let binary_type = AcirType::from(binary_type);
-        let bit_count = binary_type.bit_size();
+        let bit_count = binary_type.bit_size::<FieldElement>();
         let num_type = binary_type.to_numeric_type();
         let result = match binary.operator {
             BinaryOp::Add => self.acir_context.add_var(lhs, rhs),

From 8bfaa93c9b6f0f615faa29bd2889eb96a8e9b85f Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 13 Jun 2024 14:27:16 +0100
Subject: [PATCH 370/416] chore: add property tests for ABI encoding (#5216)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5226

## Summary\*

This PR adds property testing to ABI encoding so that we can show that
any valid `Abi` + `InputMap` combination can be abi encoded and decoded
to return the original inputs.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                         |  25 +++--
 Cargo.toml                         |   2 +
 cspell.json                        |   1 +
 tooling/noirc_abi/Cargo.toml       |   5 +-
 tooling/noirc_abi/src/arbitrary.rs | 154 +++++++++++++++++++++++++++++
 tooling/noirc_abi/src/lib.rs       |  67 ++++---------
 6 files changed, 197 insertions(+), 57 deletions(-)
 create mode 100644 tooling/noirc_abi/src/arbitrary.rs

diff --git a/Cargo.lock b/Cargo.lock
index a8eab53dc07..7b96737f241 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2730,6 +2730,8 @@ dependencies = [
  "noirc_printable_type",
  "num-bigint",
  "num-traits",
+ "proptest",
+ "proptest-derive",
  "serde",
  "serde_json",
  "strum",
@@ -3329,9 +3331,9 @@ dependencies = [
 
 [[package]]
 name = "proptest"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c003ac8c77cb07bb74f5f198bce836a689bcd5a42574612bf14d17bfd08c20e"
+checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf"
 dependencies = [
  "bit-set",
  "bit-vec",
@@ -3341,12 +3343,23 @@ dependencies = [
  "rand 0.8.5",
  "rand_chacha 0.3.1",
  "rand_xorshift",
- "regex-syntax 0.7.4",
+ "regex-syntax 0.8.2",
  "rusty-fork",
  "tempfile",
  "unarray",
 ]
 
+[[package]]
+name = "proptest-derive"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cf16337405ca084e9c78985114633b6827711d22b9e6ef6c6c0d665eb3f0b6e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "quick-error"
 version = "1.2.3"
@@ -3578,12 +3591,6 @@ version = "0.6.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
-[[package]]
-name = "regex-syntax"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.2"
diff --git a/Cargo.toml b/Cargo.toml
index c08e9f9f38b..639807819ab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -141,6 +141,8 @@ jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
 rand = "0.8.5"
 proptest = "1.2.0"
+proptest-derive = "0.4.0"
+
 
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
diff --git a/cspell.json b/cspell.json
index 9eb6e6f9239..2fb20ae2ba4 100644
--- a/cspell.json
+++ b/cspell.json
@@ -166,6 +166,7 @@
         "rfind",
         "rustc",
         "rustup",
+        "sboxed",
         "schnorr",
         "sdiv",
         "secp256k1",
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index d450b268aee..e8f57060367 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -22,7 +22,10 @@ num-traits = "0.2"
 [dev-dependencies]
 strum = "0.24"
 strum_macros = "0.24"
+proptest.workspace = true
+proptest-derive.workspace = true
+
 
 [features]
 bn254 = ["acvm/bn254"]
-bls12_381 = ["acvm/bls12_381"]
+bls12_381 = ["acvm/bls12_381"]
\ No newline at end of file
diff --git a/tooling/noirc_abi/src/arbitrary.rs b/tooling/noirc_abi/src/arbitrary.rs
new file mode 100644
index 00000000000..aecb620b79d
--- /dev/null
+++ b/tooling/noirc_abi/src/arbitrary.rs
@@ -0,0 +1,154 @@
+use iter_extended::{btree_map, vecmap};
+use prop::collection::vec;
+use proptest::prelude::*;
+
+use acvm::{AcirField, FieldElement};
+
+use crate::{
+    input_parser::InputValue, Abi, AbiParameter, AbiReturnType, AbiType, AbiVisibility, InputMap,
+    Sign,
+};
+use std::collections::{BTreeMap, HashSet};
+
+pub(super) use proptest_derive::Arbitrary;
+
+/// Mutates an iterator of mutable references to [`String`]s to ensure that all values are unique.
+fn ensure_unique_strings<'a>(iter: impl Iterator<Item = &'a mut String>) {
+    let mut seen_values: HashSet<String> = HashSet::default();
+    for value in iter {
+        while seen_values.contains(value.as_str()) {
+            value.push('1');
+        }
+        seen_values.insert(value.clone());
+    }
+}
+
+proptest::prop_compose! {
+    pub(super) fn arb_field_from_integer(bit_size: u32)(value: u128)-> FieldElement {
+        let width = (bit_size % 128).clamp(1, 127);
+        let max_value = 2u128.pow(width) - 1;
+        FieldElement::from(value.clamp(0, max_value))
+    }
+}
+
+fn arb_value_from_abi_type(abi_type: &AbiType) -> SBoxedStrategy<InputValue> {
+    match abi_type {
+        AbiType::Field => vec(any::<u8>(), 32)
+            .prop_map(|bytes| InputValue::Field(FieldElement::from_be_bytes_reduce(&bytes)))
+            .sboxed(),
+        AbiType::Integer { width, .. } => {
+            arb_field_from_integer(*width).prop_map(InputValue::Field).sboxed()
+        }
+
+        AbiType::Boolean => {
+            any::<bool>().prop_map(|val| InputValue::Field(FieldElement::from(val))).sboxed()
+        }
+
+        AbiType::String { length } => {
+            // Strings only allow ASCII characters as each character must be able to be represented by a single byte.
+            let string_regex = format!("[[:ascii:]]{{{length}}}");
+            proptest::string::string_regex(&string_regex)
+                .expect("parsing of regex should always succeed")
+                .prop_map(InputValue::String)
+                .sboxed()
+        }
+        AbiType::Array { length, typ } => {
+            let length = *length as usize;
+            let elements = vec(arb_value_from_abi_type(typ), length..=length);
+
+            elements.prop_map(InputValue::Vec).sboxed()
+        }
+
+        AbiType::Struct { fields, .. } => {
+            let fields: Vec<SBoxedStrategy<(String, InputValue)>> = fields
+                .iter()
+                .map(|(name, typ)| (Just(name.clone()), arb_value_from_abi_type(typ)).sboxed())
+                .collect();
+
+            fields
+                .prop_map(|fields| {
+                    let fields: BTreeMap<_, _> = fields.into_iter().collect();
+                    InputValue::Struct(fields)
+                })
+                .sboxed()
+        }
+
+        AbiType::Tuple { fields } => {
+            let fields: Vec<_> = fields.iter().map(arb_value_from_abi_type).collect();
+            fields.prop_map(InputValue::Vec).sboxed()
+        }
+    }
+}
+
+fn arb_primitive_abi_type() -> SBoxedStrategy<AbiType> {
+    const MAX_STRING_LEN: u32 = 1000;
+    proptest::prop_oneof![
+        Just(AbiType::Field),
+        Just(AbiType::Boolean),
+        any::<(Sign, u32)>().prop_map(|(sign, width)| {
+            let width = (width % 128).clamp(1, 127);
+            AbiType::Integer { sign, width }
+        }),
+        // restrict length of strings to avoid running out of memory
+        (1..MAX_STRING_LEN).prop_map(|length| AbiType::String { length }),
+    ]
+    .sboxed()
+}
+
+pub(super) fn arb_abi_type() -> BoxedStrategy<AbiType> {
+    let leaf = arb_primitive_abi_type();
+
+    leaf.prop_recursive(
+        8,   // up to 8 levels deep
+        256, // Shoot for maximum size of 256 nodes
+        10,  // We put up to 10 items per collection
+        |inner| {
+            prop_oneof![
+                (1..10u32, inner.clone())
+                    .prop_map(|(length, typ)| { AbiType::Array { length, typ: Box::new(typ) } })
+                    .boxed(),
+                prop::collection::vec(inner.clone(), 1..10)
+                    .prop_map(|fields| { AbiType::Tuple { fields } })
+                    .boxed(),
+                (".*", prop::collection::vec((".+", inner), 1..10))
+                    .prop_map(|(path, mut fields)| {
+                        // Require that all field names are unique.
+                        ensure_unique_strings(fields.iter_mut().map(|(field_name, _)| field_name));
+                        AbiType::Struct { path, fields }
+                    })
+                    .boxed(),
+            ]
+        },
+    )
+    .boxed()
+}
+
+fn arb_abi_param_and_value() -> BoxedStrategy<(AbiParameter, InputValue)> {
+    arb_abi_type()
+        .prop_flat_map(|typ| {
+            let value = arb_value_from_abi_type(&typ);
+            let param = arb_abi_param(typ);
+            (param, value)
+        })
+        .boxed()
+}
+
+fn arb_abi_param(typ: AbiType) -> SBoxedStrategy<AbiParameter> {
+    (".+", any::<AbiVisibility>())
+        .prop_map(move |(name, visibility)| AbiParameter { name, typ: typ.clone(), visibility })
+        .sboxed()
+}
+
+prop_compose! {
+    pub(super) fn arb_abi_and_input_map()
+        (mut parameters_with_values in proptest::collection::vec(arb_abi_param_and_value(), 0..100), return_type: Option<AbiReturnType>)
+        -> (Abi, InputMap) {
+            // Require that all parameter names are unique.
+            ensure_unique_strings(parameters_with_values.iter_mut().map(|(param_name,_)| &mut param_name.name));
+
+            let parameters  = vecmap(&parameters_with_values, |(param, _)| param.clone());
+            let input_map = btree_map(parameters_with_values, |(param, value)| (param.name, value));
+
+            (Abi { parameters, return_type, error_types: BTreeMap::default() }, input_map)
+    }
+}
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 2ebccbad1a0..b3d80099137 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -25,6 +25,9 @@ use std::{collections::BTreeMap, str};
 //
 // This ABI has nothing to do with ACVM or ACIR. Although they implicitly have a relationship
 
+#[cfg(test)]
+mod arbitrary;
+
 pub mod errors;
 pub mod input_parser;
 mod serialization;
@@ -75,6 +78,7 @@ pub enum AbiType {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
 #[serde(rename_all = "lowercase")]
 /// Represents whether the parameter is public or known only to the prover.
 pub enum AbiVisibility {
@@ -86,6 +90,7 @@ pub enum AbiVisibility {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
 #[serde(rename_all = "lowercase")]
 pub enum Sign {
     Unsigned,
@@ -142,10 +147,12 @@ impl From<&AbiType> for PrintableType {
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
 /// An argument or return value of the circuit's `main` function.
 pub struct AbiParameter {
     pub name: String,
     #[serde(rename = "type")]
+    #[cfg_attr(test, proptest(strategy = "arbitrary::arb_abi_type()"))]
     pub typ: AbiType,
     pub visibility: AbiVisibility,
 }
@@ -157,16 +164,20 @@ impl AbiParameter {
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
 pub struct AbiReturnType {
+    #[cfg_attr(test, proptest(strategy = "arbitrary::arb_abi_type()"))]
     pub abi_type: AbiType,
     pub visibility: AbiVisibility,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
 pub struct Abi {
     /// An ordered list of the arguments to the program's `main` function, specifying their types and visibility.
     pub parameters: Vec<AbiParameter>,
     pub return_type: Option<AbiReturnType>,
+    #[cfg_attr(test, proptest(strategy = "proptest::prelude::Just(BTreeMap::from([]))"))]
     pub error_types: BTreeMap<ErrorSelector, AbiErrorType>,
 }
 
@@ -488,56 +499,18 @@ pub fn display_abi_error<F: AcirField>(
 
 #[cfg(test)]
 mod test {
-    use std::collections::BTreeMap;
-
-    use acvm::{AcirField, FieldElement};
+    use proptest::prelude::*;
 
-    use crate::{
-        input_parser::InputValue, Abi, AbiParameter, AbiReturnType, AbiType, AbiVisibility,
-        InputMap,
-    };
+    use crate::arbitrary::arb_abi_and_input_map;
 
-    #[test]
-    fn witness_encoding_roundtrip() {
-        let abi = Abi {
-            parameters: vec![
-                AbiParameter {
-                    name: "thing1".to_string(),
-                    typ: AbiType::Array { length: 2, typ: Box::new(AbiType::Field) },
-                    visibility: AbiVisibility::Public,
-                },
-                AbiParameter {
-                    name: "thing2".to_string(),
-                    typ: AbiType::Field,
-                    visibility: AbiVisibility::Public,
-                },
-            ],
-            return_type: Some(AbiReturnType {
-                abi_type: AbiType::Field,
-                visibility: AbiVisibility::Public,
-            }),
-            error_types: BTreeMap::default(),
-        };
+    proptest! {
+        #[test]
+        fn encoding_and_decoding_returns_original_witness_map((abi, input_map) in arb_abi_and_input_map()) {
+            let witness_map = abi.encode(&input_map, None).unwrap();
+            let (decoded_inputs, return_value) = abi.decode(&witness_map).unwrap();
 
-        // Note we omit return value from inputs
-        let inputs: InputMap = BTreeMap::from([
-            (
-                "thing1".to_string(),
-                InputValue::Vec(vec![
-                    InputValue::Field(FieldElement::one()),
-                    InputValue::Field(FieldElement::one()),
-                ]),
-            ),
-            ("thing2".to_string(), InputValue::Field(FieldElement::zero())),
-        ]);
-
-        let witness_map = abi.encode(&inputs, None).unwrap();
-        let (reconstructed_inputs, return_value) = abi.decode(&witness_map).unwrap();
-
-        for (key, expected_value) in inputs {
-            assert_eq!(reconstructed_inputs[&key], expected_value);
+            prop_assert_eq!(decoded_inputs, input_map);
+            prop_assert_eq!(return_value, None);
         }
-
-        assert!(return_value.is_none());
     }
 }

From 1c19dfff286f1a4d65b95c907e21d1730d40d270 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 13 Jun 2024 14:50:02 +0100
Subject: [PATCH 371/416] chore: redo typo PR by dropbigfish (#5234)

Thanks dropbigfish for https://github.com/noir-lang/noir/pull/5232. Our
policy is to redo typo changes to dissuade metric farming. This is an
automated script.

Signed-off-by: dropbigfish <fillfish@foxmail.com>
Co-authored-by: dropbigfish <fillfish@foxmail.com>
---
 compiler/noirc_evaluator/src/ssa.rs                             | 2 +-
 .../noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs     | 2 +-
 compiler/noirc_frontend/src/elaborator/mod.rs                   | 2 +-
 compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs       | 2 +-
 compiler/noirc_frontend/src/lexer/token.rs                      | 2 +-
 docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md     | 2 +-
 docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md     | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index f7b6dfd3771..7e362599fb5 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -146,7 +146,7 @@ impl SsaProgramArtifact {
 
 /// Compiles the [`Program`] into [`ACIR``][acvm::acir::circuit::Program].
 ///
-/// The output ACIR is is backend-agnostic and so must go through a transformation pass before usage in proof generation.
+/// The output ACIR is backend-agnostic and so must go through a transformation pass before usage in proof generation.
 #[allow(clippy::type_complexity)]
 #[tracing::instrument(level = "trace", skip_all)]
 pub fn create_program(
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
index c59134e4ecc..de75d34565e 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
@@ -304,7 +304,7 @@ impl<'a> ValueMerger<'a> {
         let mut current_then = then_value;
         let mut current_else = else_value;
 
-        // Arbitrarily limit this to looking at at most 10 past ArraySet operations.
+        // Arbitrarily limit this to looking at most 10 past ArraySet operations.
         // If there are more than that, we assume 2 completely separate arrays are being merged.
         let max_iters = 2;
         let mut seen_then = Vec::with_capacity(max_iters);
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 3b8158667f9..7bdb7d2886b 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -247,7 +247,7 @@ impl<'context> Elaborator<'context> {
         }
 
         // We must wait to resolve non-literal globals until after we resolve structs since struct
-        // globals will need to reference the struct type they're initialized to to ensure they are valid.
+        // globals will need to reference the struct type they're initialized to ensure they are valid.
         while let Some((_, global)) = this.unresolved_globals.pop_first() {
             this.elaborate_global(global);
         }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 9b47a104a40..4511537a1cc 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -404,7 +404,7 @@ impl DefCollector {
         resolved_module.errors.extend(collect_impls(context, crate_id, &def_collector.items.impls));
 
         // We must wait to resolve non-integer globals until after we resolve structs since struct
-        // globals will need to reference the struct type they're initialized to to ensure they are valid.
+        // globals will need to reference the struct type they're initialized to ensure they are valid.
         resolved_module.resolve_globals(context, other_globals, crate_id);
 
         // Resolve each function in the crate. This is now possible since imports have been resolved
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 2199333e90f..d204191796c 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -460,7 +460,7 @@ impl fmt::Display for IntType {
 
 impl IntType {
     // XXX: Result<Option<Token, LexerErrorKind>
-    // Is not the best API. We could split this into two functions. One that checks if the the
+    // Is not the best API. We could split this into two functions. One that checks if the
     // word is a integer, which only returns an Option
     pub(crate) fn lookup_int_type(word: &str) -> Result<Option<Token>, LexerErrorKind> {
         // Check if the first string is a 'u' or 'i'
diff --git a/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md
index 6446e0b2a76..3dd9fe7d2b0 100644
--- a/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.28.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
diff --git a/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md
index 6446e0b2a76..3dd9fe7d2b0 100644
--- a/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md
+++ b/docs/versioned_docs/version-v0.29.0/tutorials/noirjs_app.md
@@ -24,7 +24,7 @@ Before we start, we want to make sure we have Node and Nargo installed.
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash

From a2816dbf7f9d31967fc95205a43fdfdf181029b0 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 13 Jun 2024 09:56:27 -0500
Subject: [PATCH 372/416] fix: Disable `if` optimization (#5240)

# Description

## Problem\*

Resolves #5202

## Summary\*

The linked issue was coming from our if condition optimization where we
assume the value of an if's condition to be true within the then branch
and false within the else branch. It seems the `map_value` calls from
this weren't being reset properly since the nested `if f1.sign { .. } {
.. }`'s else branch assumed `f1.sign` to be false, which was not reset
properly after the `if`. I've temporarily disabled the optimization
until we can add it back without breaking this test.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/opt/flatten_cfg.rs                |  27 +--
 .../regression_5202/Nargo.toml                |   8 +
 .../regression_5202/fraction/LICENSE          |  21 ++
 .../regression_5202/fraction/Nargo.toml       |   6 +
 .../regression_5202/fraction/README.md        |  10 +
 .../regression_5202/fraction/src/lib.nr       | 201 ++++++++++++++++++
 .../regression_5202/src/main.nr               |  23 ++
 7 files changed, 270 insertions(+), 26 deletions(-)
 create mode 100644 test_programs/execution_success/regression_5202/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_5202/fraction/LICENSE
 create mode 100644 test_programs/execution_success/regression_5202/fraction/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_5202/fraction/README.md
 create mode 100644 test_programs/execution_success/regression_5202/fraction/src/lib.nr
 create mode 100644 test_programs/execution_success/regression_5202/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index e07f947db8d..58f70ba9192 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -375,7 +375,6 @@ impl<'f> Context<'f> {
         let old_condition = *condition;
         let then_condition = self.inserter.resolve(old_condition);
 
-        let one = FieldElement::one();
         let old_stores = std::mem::take(&mut self.store_values);
         let old_allocations = std::mem::take(&mut self.local_allocations);
         let branch = ConditionalBranch {
@@ -393,15 +392,6 @@ impl<'f> Context<'f> {
         };
         self.condition_stack.push(cond_context);
         self.insert_current_side_effects_enabled();
-        // Optimization: within the then branch we know the condition to be true, so replace
-        // any references of it within this branch with true. Likewise, do the same with false
-        // with the else branch. We must be careful not to replace the condition if it is a
-        // known constant, otherwise we can end up setting 1 = 0 or vice-versa.
-        if self.inserter.function.dfg.get_numeric_constant(old_condition).is_none() {
-            let known_value = self.inserter.function.dfg.make_constant(one, Type::bool());
-
-            self.inserter.map_value(old_condition, known_value);
-        }
         vec![self.branch_ends[if_entry], *else_destination, *then_destination]
     }
 
@@ -414,7 +404,6 @@ impl<'f> Context<'f> {
             self.insert_instruction(Instruction::Not(cond_context.condition), CallStack::new());
         let else_condition = self.link_condition(else_condition);
 
-        let zero = FieldElement::zero();
         // Make sure the else branch sees the previous values of each store
         // rather than any values created in the 'then' branch.
         let old_stores = std::mem::take(&mut cond_context.then_branch.store_values);
@@ -429,21 +418,12 @@ impl<'f> Context<'f> {
             local_allocations: old_allocations,
             last_block: *block,
         };
-        let old_condition = else_branch.old_condition;
         cond_context.then_branch.local_allocations.clear();
         cond_context.else_branch = Some(else_branch);
         self.condition_stack.push(cond_context);
 
         self.insert_current_side_effects_enabled();
-        // Optimization: within the then branch we know the condition to be true, so replace
-        // any references of it within this branch with true. Likewise, do the same with false
-        // with the else branch. We must be careful not to replace the condition if it is a
-        // known constant, otherwise we can end up setting 1 = 0 or vice-versa.
-        if self.inserter.function.dfg.get_numeric_constant(old_condition).is_none() {
-            let known_value = self.inserter.function.dfg.make_constant(zero, Type::bool());
-
-            self.inserter.map_value(old_condition, known_value);
-        }
+
         assert_eq!(self.cfg.successors(*block).len(), 1);
         vec![self.cfg.successors(*block).next().unwrap()]
     }
@@ -471,11 +451,6 @@ impl<'f> Context<'f> {
         // known to be true/false within the then/else branch respectively.
         self.insert_current_side_effects_enabled();
 
-        // We must map back to `then_condition` here. Mapping `old_condition` to itself would
-        // lose any previous mappings.
-        self.inserter
-            .map_value(cond_context.then_branch.old_condition, cond_context.then_branch.condition);
-
         // While there is a condition on the stack we don't compile outside the condition
         // until it is popped. This ensures we inline the full then and else branches
         // before continuing from the end of the conditional here where they can be merged properly.
diff --git a/test_programs/execution_success/regression_5202/Nargo.toml b/test_programs/execution_success/regression_5202/Nargo.toml
new file mode 100644
index 00000000000..da3da06a306
--- /dev/null
+++ b/test_programs/execution_success/regression_5202/Nargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "regression_5202"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
+fraction = { path = "fraction" }
diff --git a/test_programs/execution_success/regression_5202/fraction/LICENSE b/test_programs/execution_success/regression_5202/fraction/LICENSE
new file mode 100644
index 00000000000..929af4807ca
--- /dev/null
+++ b/test_programs/execution_success/regression_5202/fraction/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Resurgence Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/test_programs/execution_success/regression_5202/fraction/Nargo.toml b/test_programs/execution_success/regression_5202/fraction/Nargo.toml
new file mode 100644
index 00000000000..82e929d0bc7
--- /dev/null
+++ b/test_programs/execution_success/regression_5202/fraction/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "fraction"
+type = "lib"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_5202/fraction/README.md b/test_programs/execution_success/regression_5202/fraction/README.md
new file mode 100644
index 00000000000..17c81e5555a
--- /dev/null
+++ b/test_programs/execution_success/regression_5202/fraction/README.md
@@ -0,0 +1,10 @@
+# fraction
+The Noir repository for accessing Fractions by Resurgence Labs
+
+# usage
+To Use as a Dependency, add the following line to your project's Nargo.toml under [dependencies]:  
+fraction = { tag = "v1.2.2", git = "https://github.com/resurgencelabs/fraction" }
+
+Note: This is a highly dynamic repository. The code will change as more features are added, both at the repository level by Resurgence Labs, as well as at the language level itself by the Noir team.
+
+
diff --git a/test_programs/execution_success/regression_5202/fraction/src/lib.nr b/test_programs/execution_success/regression_5202/fraction/src/lib.nr
new file mode 100644
index 00000000000..4b20eb6b76c
--- /dev/null
+++ b/test_programs/execution_success/regression_5202/fraction/src/lib.nr
@@ -0,0 +1,201 @@
+use dep::std;
+
+global MAX: Fraction = Fraction { sign: true, num: 3050913689, den: 1 };
+global MIN: Fraction = Fraction { sign: false, num: 3050913689, den: 1 };
+global ZERO: Fraction = Fraction { sign: true, num: 0, den: 1 };
+global ONE: Fraction = Fraction { sign: true, num: 1, den: 1 };
+global NEGATIVE_ONE: Fraction = Fraction { sign: false, num: 1, den: 1 };
+
+struct Fraction {
+    sign: bool,
+    num: u32,
+    den: u32,
+}
+
+// Create a Fraction type variable without lenghtier code
+pub fn toFraction(s: bool, n: u32, d: u32) -> Fraction {
+    assert(d != 0);
+    Fraction { sign: s, num: n, den: d }
+}
+
+// Swaps the numerator and denominator
+fn invertFraction(f: Fraction) -> Fraction {
+    assert(f.num != 0);
+    Fraction { sign: f.sign, num: f.den, den: f.num }
+}
+
+// Changes the Sign of the Fraction
+fn signChangeFraction(f: Fraction) -> Fraction {
+    Fraction { sign: !f.sign, num: f.num, den: f.den }
+}
+
+// this method will only work till numerator and denominator values are under 100
+// this has been set for efficiency reasons, and will be modified once the Noir team
+// can implement dynamic limit for loops
+fn reduceFraction(f: Fraction) -> Fraction {
+    let mut a = f.num;
+    let mut b = f.den;
+    let mut j = 1;
+    let mut gcd = 1;
+
+    let min = if a > b { b } else { a };
+
+    for i in 2..100 {
+        j = i as u32;
+        if (j <= min) {
+            if (a % j == 0) & (b % j == 0) {
+                gcd = j;
+            }
+        }
+    }
+
+    Fraction { sign: f.sign, num: f.num / gcd, den: f.den / gcd }
+}
+
+// Adds two fractions
+pub fn addFraction(f1: Fraction, f2: Fraction) -> Fraction {
+    let mut an = U128::from_integer(f1.num);
+    let mut ad = U128::from_integer(f1.den);
+    let mut bn = U128::from_integer(f2.num);
+    let mut bd = U128::from_integer(f2.den);
+    let mut m = f1;
+    let mut n = f2;
+
+    if f1.sign == f2.sign {
+        if ((ad * bd > U128::from_integer(2000000000))
+            | ((an * bd + ad * bn) > U128::from_integer(2000000000))
+            | ((an * bd) > U128::from_integer(2000000000))
+            | ((ad * bn) > U128::from_integer(2000000000))) {
+            m = reduceFraction(m);
+            n = reduceFraction(n);
+        }
+        an = U128::from_integer(m.num);
+        ad = U128::from_integer(m.den);
+        bn = U128::from_integer(n.num);
+        bd = U128::from_integer(n.den);
+        if ((ad * bd > U128::from_integer(2000000000))
+            | ((an * bd + ad * bn) > U128::from_integer(2000000000))
+            | ((an * bd) > U128::from_integer(2000000000))
+            | ((ad * bn) > U128::from_integer(2000000000))) {
+            let mut ddd = (an * bd + ad * bn) / (ad * bd);
+            let mut factor = U128::from_integer(1);
+            for _ in 1..5 {
+                if ddd * U128::from_integer(10) < U128::from_integer(2000000000) {
+                    ddd *= U128::from_integer(10);
+                    factor *= U128::from_integer(10);
+                }
+            }
+            let np: u32 = U128::to_integer(((an * bd + ad * bn) * factor) / (ad * bd));
+            let fx: u32 = U128::to_integer(factor);
+            Fraction { sign: f1.sign, num: np, den: fx }
+        } else {
+            Fraction { sign: f1.sign, num: (m.num * n.den + n.num * m.den), den: m.den * n.den }
+        }
+    } else if ((an * bd) > (bn * ad)) {
+        if ((ad * bd > U128::from_integer(2000000000))
+            | ((an * bd - ad * bn) > U128::from_integer(2000000000))
+            | ((an * bd) > U128::from_integer(2000000000))) {
+            m = reduceFraction(m);
+            n = reduceFraction(n);
+        }
+        an = U128::from_integer(m.num);
+        ad = U128::from_integer(m.den);
+        bn = U128::from_integer(n.num);
+        bd = U128::from_integer(n.den);
+
+        if ((ad * bd > U128::from_integer(2000000000))
+            | ((an * bd - ad * bn) > U128::from_integer(2000000000))
+            | ((an * bd) > U128::from_integer(2000000000))) {
+            let mut ddd = (an * bd - ad * bn) / (ad * bd);
+            let mut factor = U128::from_integer(1);
+            for _ in 1..5 {
+                if ddd * U128::from_integer(10) < U128::from_integer(2000000000) {
+                    ddd *= U128::from_integer(10);
+                    factor *= U128::from_integer(10);
+                }
+            }
+            let np: u32 = U128::to_integer(((an * bd - ad * bn) * factor) / (ad * bd));
+            let fx: u32 = U128::to_integer(factor);
+            Fraction { sign: f1.sign, num: np, den: fx }
+        } else {
+            Fraction { sign: f1.sign, num: (m.num * n.den - n.num * m.den), den: m.den * n.den }
+        }
+    } else {
+        if ((ad * bd > U128::from_integer(2000000000))
+            | ((bn * ad - bd * an) > U128::from_integer(2000000000))
+            | ((bn * ad) > U128::from_integer(2000000000))) {
+            m = reduceFraction(m);
+            n = reduceFraction(n);
+        }
+        an = U128::from_integer(m.num);
+        ad = U128::from_integer(m.den);
+        bn = U128::from_integer(n.num);
+        bd = U128::from_integer(n.den);
+        if ((ad * bd > U128::from_integer(2000000000))
+            | ((bn * ad - bd * an) > U128::from_integer(2000000000))
+            | ((bn * ad) > U128::from_integer(2000000000))) {
+            let mut ddd = (bn * ad - bd * an) / (ad * bd);
+            let mut factor = U128::from_integer(1);
+            for _ in 1..5 {
+                if ddd * U128::from_integer(10) < U128::from_integer(2000000000) {
+                    ddd *= U128::from_integer(10);
+                    factor *= U128::from_integer(10);
+                }
+            }
+            let np: u32 = U128::to_integer(((bn * ad - bd * an) * factor) / (ad * bd));
+            let fx: u32 = U128::to_integer(factor);
+            Fraction { sign: f2.sign, num: np, den: fx }
+        } else {
+            Fraction { sign: f2.sign, num: (n.num * m.den - m.num * n.den), den: m.den * n.den }
+        }
+    }
+}
+
+// Returns the closest but smaller Integer to the Given Fraction, but typecast to Fraction for convenience
+pub fn floor(f: Fraction) -> Fraction {
+    let q = f.num / f.den;
+    if q * f.den == f.num {
+        Fraction { sign: f.sign, num: f.num, den: f.den }
+    } else if f.sign {
+        Fraction { sign: f.sign, num: q, den: 1 }
+    } else {
+        Fraction { sign: f.sign, num: q + 1, den: 1 }
+    }
+}
+
+#[test]
+fn test_sum() {
+    let f1 = toFraction(true, 3, 5);
+    let f2 = toFraction(true, 2, 5);
+    let f = addFraction(f1, f2);
+    assert(f.num == f.den);
+}
+
+#[test]
+fn test_reduce() {
+    let f1 = toFraction(true, 2, 10);
+    let f2 = reduceFraction(f1);
+    assert(f2.num == 1);
+}
+
+#[test]
+fn test_floor() {
+    let f = toFraction(true, 7, 5);
+    let fl = floor(f);
+    assert(fl.num == 1);
+    assert(fl.den == 1);
+}
+
+#[test]
+fn test_floor2() {
+    let f = toFraction(false, 12, 5);
+    let fl = floor(f);
+    assert(fl.num == 3);
+    assert(fl.den == 1);
+}
+
+#[test]
+fn test_globals() {
+    let a = addFraction(ONE, NEGATIVE_ONE);
+    assert(a.num == ZERO.num);
+}
diff --git a/test_programs/execution_success/regression_5202/src/main.nr b/test_programs/execution_success/regression_5202/src/main.nr
new file mode 100644
index 00000000000..e41b760b83e
--- /dev/null
+++ b/test_programs/execution_success/regression_5202/src/main.nr
@@ -0,0 +1,23 @@
+use dep::fraction::{Fraction, MAX, floor, toFraction, addFraction};
+
+fn main() {
+    let g1 = toFraction(true, 33333333, 5);
+    let g2 = toFraction(true, 500000, 33333333);
+    let a = addFraction(g1, g2);
+
+    let f1 = floor(a);
+    let f2 = MAX;
+    assert(f1.sign);
+    assert(f2.sign);
+
+    if f1.sign != f2.sign {
+        if (f1.sign) { () } else { () }
+    } else {
+        // Test fails here before the fix to #5202.
+        // An optimization which assumes an if condition to be true/false
+        // within the then/else branch respectively wasn't being set properly
+        // causing f1.sign to be assumed to be false in this else branch.
+        assert(f1.sign);
+        assert(f2.sign);
+    }
+}

From 1849389362e22e8236177f84b735dadf840cd637 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 13 Jun 2024 19:06:40 +0100
Subject: [PATCH 373/416] feat: add `set` and `set_unchecked` methods to `Vec`
 and `BoundedVec` (#5241)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR exposes `set` and `set_unchecked` methods to `BoundedVec` which
allow writing to individual indices in the array without having to
access `self.storage` directly.

I've also documented the expected behaviour for the get and set
operations.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../standard_library/containers/boundedvec.md | 40 ++++++++-
 .../noir/standard_library/containers/vec.mdx  | 19 +++++
 noir_stdlib/src/collections/bounded_vec.nr    | 59 ++++++++++++-
 noir_stdlib/src/collections/vec.nr            | 39 +++++++++
 .../noir_test_success/bounded_vec/src/main.nr | 27 ++++++
 tooling/nargo_cli/tests/stdlib-tests.rs       | 85 ++++++++++++++++++-
 6 files changed, 263 insertions(+), 6 deletions(-)

diff --git a/docs/docs/noir/standard_library/containers/boundedvec.md b/docs/docs/noir/standard_library/containers/boundedvec.md
index ccce62562f8..c476c877d87 100644
--- a/docs/docs/noir/standard_library/containers/boundedvec.md
+++ b/docs/docs/noir/standard_library/containers/boundedvec.md
@@ -59,7 +59,7 @@ but for now make sure to use type annotations when using bounded vectors. Otherw
 ### get
 
 ```rust
-pub fn get(mut self: Self, index: u64) -> T {
+pub fn get(self, index: u64) -> T {
 ```
 
 Retrieves an element from the vector at the given index, starting from zero.
@@ -80,7 +80,7 @@ fn foo<N>(v: BoundedVec<u32, N>) {
 ### get_unchecked
 
 ```rust
-pub fn get_unchecked(mut self: Self, index: u64) -> T {
+pub fn get_unchecked(self, index: u64) -> T {
 ```
 
 Retrieves an element from the vector at the given index, starting from zero, without
@@ -93,6 +93,42 @@ Example:
 
 #include_code get_unchecked_example test_programs/noir_test_success/bounded_vec/src/main.nr rust
 
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+#include_code set_unchecked_example test_programs/noir_test_success/bounded_vec/src/main.nr rust
+
 
 ### push
 
diff --git a/docs/docs/noir/standard_library/containers/vec.mdx b/docs/docs/noir/standard_library/containers/vec.mdx
index fcfd7e07aa0..475011922f8 100644
--- a/docs/docs/noir/standard_library/containers/vec.mdx
+++ b/docs/docs/noir/standard_library/containers/vec.mdx
@@ -84,6 +84,25 @@ let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
 assert(vector.get(1) == 20);
 ```
 
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
 ### push
 
 Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index aae96e5943d..801fe3da75a 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -11,15 +11,35 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         BoundedVec { storage: [zeroed; MaxLen], len: 0 }
     }
 
-    pub fn get(mut self: Self, index: u32) -> T {
+    /// Get an element from the vector at the given index.
+    /// Panics if the given index points beyond the end of the vector (`self.len()`).
+    pub fn get(self, index: u32) -> T {
         assert(index < self.len);
-        self.storage[index]
+        self.get_unchecked(index)
     }
 
-    pub fn get_unchecked(mut self: Self, index: u32) -> T {
+    /// Get an element from the vector at the given index.
+    /// Responds with undefined data for `index` where `self.len < index < self.max_len()`.
+    pub fn get_unchecked(self, index: u32) -> T {
         self.storage[index]
     }
 
+    /// Write an element to the vector at the given index.
+    /// Panics if the given index points beyond the end of the vector (`self.len()`).
+    pub fn set(&mut self, index: u32, value: T) {
+        assert(index < self.len, "Attempted to write past end of BoundedVec");
+        self.set_unchecked(index, value)
+    }
+
+    /// Write an element to the vector at the given index.
+    /// Does not check whether the passed `index` is a valid index within the vector.
+    ///
+    /// Silently writes past the end of the vector for `index` where `self.len < index < self.max_len()`
+    /// Panics if the given index points beyond the maximum length of the vector (`self.max_len()`).
+    pub fn set_unchecked(&mut self, index: u32, value: T) {
+        self.storage[index] = value;
+    }
+
     pub fn push(&mut self, elem: T) {
         assert(self.len < MaxLen, "push out of bounds");
 
@@ -142,6 +162,39 @@ mod bounded_vec_tests {
         assert(bounded_vec1 != bounded_vec2);
     }
 
+    mod set {
+        use crate::collections::bounded_vec::BoundedVec;
+
+        #[test]
+        fn set_updates_values_properly() {
+            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);
+
+            vec.set(0, 42);
+            assert_eq(vec.storage, [42, 0, 0, 0, 0]);
+
+            vec.set(1, 43);
+            assert_eq(vec.storage, [42, 43, 0, 0, 0]);
+
+            vec.set(2, 44);
+            assert_eq(vec.storage, [42, 43, 44, 0, 0]);
+
+            vec.set(1, 10);
+            assert_eq(vec.storage, [42, 10, 44, 0, 0]);
+
+            vec.set(0, 0);
+            assert_eq(vec.storage, [0, 10, 44, 0, 0]);
+        }
+
+        #[test(should_fail_with = "Attempted to write past end of BoundedVec")]
+        fn panics_when_writing_elements_past_end_of_vec() {
+            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();
+            vec.set(0, 42);
+
+            // Need to use println to avoid DIE removing the write operation.
+            crate::println(vec.get(0));
+        }
+    }
+
     mod from_array {
         use crate::collections::bounded_vec::BoundedVec;
 
diff --git a/noir_stdlib/src/collections/vec.nr b/noir_stdlib/src/collections/vec.nr
index 18aaa8b9b3b..cedae7f5ce1 100644
--- a/noir_stdlib/src/collections/vec.nr
+++ b/noir_stdlib/src/collections/vec.nr
@@ -21,6 +21,12 @@ impl<T> Vec<T> {
         self.slice[index]
     }
 
+    /// Write an element to the vector at the given index.
+    /// Panics if the given index points beyond the end of the vector (`self.len()`).
+    pub fn set(&mut self, index: u32, value: T) {
+        self.slice[index] = value;
+    }
+
     /// Push a new element to the end of the vector, returning a
     /// new vector with a length one greater than the
     /// original unmodified vector.
@@ -57,3 +63,36 @@ impl<T> Vec<T> {
         self.slice.len()
     }
 }
+
+mod tests {
+    use crate::collections::vec::Vec;
+
+    #[test]
+    fn set_updates_values_properly() {
+        let mut vec = Vec { slice: &[0, 0, 0, 0, 0] };
+
+        vec.set(0, 42);
+        assert_eq(vec.slice, &[42, 0, 0, 0, 0]);
+
+        vec.set(1, 43);
+        assert_eq(vec.slice, &[42, 43, 0, 0, 0]);
+
+        vec.set(2, 44);
+        assert_eq(vec.slice, &[42, 43, 44, 0, 0]);
+
+        vec.set(1, 10);
+        assert_eq(vec.slice, &[42, 10, 44, 0, 0]);
+
+        vec.set(0, 0);
+        assert_eq(vec.slice, &[0, 10, 44, 0, 0]);
+    }
+
+    #[test(should_fail)]
+    fn panics_when_writing_elements_past_end_of_vec() {
+        let mut vec = Vec::new();
+        vec.set(0, 42);
+
+        // Need to use println to avoid DIE removing the write operation.
+        crate::println(vec.get(0));
+    }
+}
diff --git a/test_programs/noir_test_success/bounded_vec/src/main.nr b/test_programs/noir_test_success/bounded_vec/src/main.nr
index 22ec291f9d6..e5aa5f88a94 100644
--- a/test_programs/noir_test_success/bounded_vec/src/main.nr
+++ b/test_programs/noir_test_success/bounded_vec/src/main.nr
@@ -63,6 +63,33 @@ fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
 }
 // docs:end:get_unchecked_example
 
+#[test(should_fail)]
+// docs:start:set_unchecked_example
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure. 
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+// docs:end:set_unchecked_example
+
 #[test(should_fail_with = "push out of bounds")]
 fn push_docs_example() {
     // docs:start:bounded-vec-push-example
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 0bb967e7502..70857b4b65e 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -1,6 +1,8 @@
+use std::io::Write;
 use std::{collections::BTreeMap, path::PathBuf};
 
 use acvm::blackbox_solver::StubbedBlackBoxSolver;
+use fm::FileManager;
 use noirc_driver::{check_crate, file_manager_with_stdlib, CompileOptions};
 use noirc_frontend::hir::FunctionNameMatch;
 
@@ -9,6 +11,7 @@ use nargo::{
     package::{Package, PackageType},
     parse_all, prepare_package,
 };
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
 #[test]
 fn run_stdlib_tests() {
@@ -23,7 +26,7 @@ fn run_stdlib_tests() {
         root_dir: PathBuf::from("."),
         package_type: PackageType::Binary,
         entry_path: PathBuf::from("main.nr"),
-        name: "dummy".parse().unwrap(),
+        name: "stdlib".parse().unwrap(),
         dependencies: BTreeMap::new(),
     };
 
@@ -58,5 +61,85 @@ fn run_stdlib_tests() {
         .collect();
 
     assert!(!test_report.is_empty(), "Could not find any tests within the stdlib");
+    display_test_report(&file_manager, &dummy_package, &CompileOptions::default(), &test_report);
     assert!(test_report.iter().all(|(_, status)| !status.failed()));
 }
+
+// This code is copied from `src/cli/test_cmd.rs`.
+// This should be abstracted into a proper test runner at some point.
+fn display_test_report(
+    file_manager: &FileManager,
+    package: &Package,
+    compile_options: &CompileOptions,
+    test_report: &[(String, TestStatus)],
+) {
+    let writer = StandardStream::stderr(ColorChoice::Always);
+    let mut writer = writer.lock();
+
+    for (test_name, test_status) in test_report {
+        write!(writer, "[{}] Testing {test_name}... ", package.name)
+            .expect("Failed to write to stderr");
+        writer.flush().expect("Failed to flush writer");
+
+        match &test_status {
+            TestStatus::Pass { .. } => {
+                writer
+                    .set_color(ColorSpec::new().set_fg(Some(Color::Green)))
+                    .expect("Failed to set color");
+                writeln!(writer, "ok").expect("Failed to write to stderr");
+            }
+            TestStatus::Fail { message, error_diagnostic } => {
+                writer
+                    .set_color(ColorSpec::new().set_fg(Some(Color::Red)))
+                    .expect("Failed to set color");
+                writeln!(writer, "FAIL\n{message}\n").expect("Failed to write to stderr");
+                if let Some(diag) = error_diagnostic {
+                    noirc_errors::reporter::report_all(
+                        file_manager.as_file_map(),
+                        &[diag.clone()],
+                        compile_options.deny_warnings,
+                        compile_options.silence_warnings,
+                    );
+                }
+            }
+            TestStatus::CompileError(err) => {
+                noirc_errors::reporter::report_all(
+                    file_manager.as_file_map(),
+                    &[err.clone()],
+                    compile_options.deny_warnings,
+                    compile_options.silence_warnings,
+                );
+            }
+        }
+        writer.reset().expect("Failed to reset writer");
+    }
+
+    write!(writer, "[{}] ", package.name).expect("Failed to write to stderr");
+
+    let count_all = test_report.len();
+    let count_failed = test_report.iter().filter(|(_, status)| status.failed()).count();
+    let plural = if count_all == 1 { "" } else { "s" };
+    if count_failed == 0 {
+        writer.set_color(ColorSpec::new().set_fg(Some(Color::Green))).expect("Failed to set color");
+        write!(writer, "{count_all} test{plural} passed").expect("Failed to write to stderr");
+        writer.reset().expect("Failed to reset writer");
+        writeln!(writer).expect("Failed to write to stderr");
+    } else {
+        let count_passed = count_all - count_failed;
+        let plural_failed = if count_failed == 1 { "" } else { "s" };
+        let plural_passed = if count_passed == 1 { "" } else { "s" };
+
+        if count_passed != 0 {
+            writer
+                .set_color(ColorSpec::new().set_fg(Some(Color::Green)))
+                .expect("Failed to set color");
+            write!(writer, "{count_passed} test{plural_passed} passed, ",)
+                .expect("Failed to write to stderr");
+        }
+
+        writer.set_color(ColorSpec::new().set_fg(Some(Color::Red))).expect("Failed to set color");
+        writeln!(writer, "{count_failed} test{plural_failed} failed")
+            .expect("Failed to write to stderr");
+        writer.reset().expect("Failed to reset writer");
+    }
+}

From c6b42edbc67ed97e0787cdf5d0b790ae197ec3ed Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Fri, 14 Jun 2024 16:54:56 +0200
Subject: [PATCH 374/416] chore: add no predicate to poseidon2 (#5252)

# Description

## Problem\*

Resolves #4688

## Summary\*
Adding the no_predicates attribute to poseidon2 because hashing
operations have no side-effect.


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/hash/poseidon2.nr | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 04d922b581d..4a68925255a 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -11,7 +11,7 @@ struct Poseidon2 {
 }
 
 impl Poseidon2 {
-
+    #[no_predicates]
     pub fn hash<N>(input: [Field; N], message_size: u32) -> Field {
         if message_size == N {
             Poseidon2::hash_internal(input, N, false)

From da1549cfb296261b273a3a64908382e7b71512ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=A1s=20Venturo?= <nicolas.venturo@gmail.com>
Date: Fri, 14 Jun 2024 17:02:17 +0100
Subject: [PATCH 375/416] feat: add BoundedVec::map (#5250)

# Description

This adds a `map` function to `BoundedMap`, which I've found to be a
relatively common need, and quite annoying to implement outside of the
stdlib as it requires raw access to the internals of the data structure.

## Documentation

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.

# PR Checklist

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../standard_library/containers/boundedvec.md | 12 +++++
 noir_stdlib/src/collections/bounded_vec.nr    | 45 +++++++++++++++++++
 2 files changed, 57 insertions(+)

diff --git a/docs/docs/noir/standard_library/containers/boundedvec.md b/docs/docs/noir/standard_library/containers/boundedvec.md
index c476c877d87..98b7d584033 100644
--- a/docs/docs/noir/standard_library/containers/boundedvec.md
+++ b/docs/docs/noir/standard_library/containers/boundedvec.md
@@ -246,6 +246,18 @@ Example:
 let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
 ```
 
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+#include_code bounded-vec-map-example noir_stdlib/src/collections/bounded_vec.nr rust
+
 ### any
 
 ```rust
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 801fe3da75a..6fde9e70f4d 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -121,6 +121,17 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         }
         ret
     }
+
+    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {
+        let mut ret = BoundedVec::new();
+        ret.len = self.len();
+        for i in 0..MaxLen {
+            if i < self.len() {
+                ret.storage[i] = f(self.get_unchecked(i));
+            }
+        }
+        ret
+    }
 }
 
 impl<T, MaxLen> Eq for BoundedVec<T, MaxLen> where T: Eq {
@@ -195,6 +206,40 @@ mod bounded_vec_tests {
         }
     }
 
+    mod map {
+        use crate::collections::bounded_vec::BoundedVec;
+
+        #[test]
+        fn applies_function_correctly() {
+            // docs:start:bounded-vec-map-example
+            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+            // docs:end:bounded-vec-map-example
+            let expected = BoundedVec::from_array([2, 4, 6, 8]);
+
+            assert_eq(result, expected);
+        }
+
+        #[test]
+        fn applies_function_that_changes_return_type() {
+            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| (value * 2)  as Field);
+            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);
+
+            assert_eq(result, expected);
+        }
+
+        #[test]
+        fn does_not_apply_function_past_len() {
+            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);
+            let result = vec.map(|value| if value == 0 { 5 } else { value });
+            let expected = BoundedVec::from_array([5, 1]);
+
+            assert_eq(result, expected);
+            assert_eq(result.storage()[2], 0);
+        }
+    }
+
     mod from_array {
         use crate::collections::bounded_vec::BoundedVec;
 

From d9b4712bf1a62548dd7ed17b181882ae537d70dd Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 14 Jun 2024 14:16:25 -0500
Subject: [PATCH 376/416] feat(experimental): Implement macro calls & splicing
 into `Expr` values (#5203)

# Description

## Problem\*

Resolves #4591

## Summary\*

Implements macro calls `foo!()` and splicing via the `$` operator of
`Expr` values into `quote` expressions.

```rust
comptime fn my_macro(x: Field, y: Field) -> Expr {
    quote { $x + $y + x + y }
}

fn main(x: Field, y: pub Field) {
    let result = my_macro!(1, 2);
    assert_eq(result, 1 + 2 + x + y);
}
```

## Additional Context

This feature is elaborator-only and does not work with the resolver /
type checker. I've yet to add the integration test that pairs with this
as a result since I'd have to add a check to the build step to exclude
it from any runs without `--use-elaborator`. I'll add this later but the
PR should be ready for review at least now.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 compiler/noirc_driver/src/abi_gen.rs          |   2 +-
 compiler/noirc_frontend/src/ast/expression.rs |  11 +
 compiler/noirc_frontend/src/ast/mod.rs        |   4 +-
 compiler/noirc_frontend/src/ast/statement.rs  |   6 +-
 .../src/elaborator/expressions.rs             | 104 +++++-
 compiler/noirc_frontend/src/elaborator/mod.rs |   1 +
 .../noirc_frontend/src/elaborator/types.rs    |   4 +-
 .../noirc_frontend/src/elaborator/unquote.rs  | 306 ++++++++++++++++++
 .../src/hir/comptime/interpreter.rs           |  20 +-
 .../src/hir/comptime/interpreter/unquote.rs   | 287 ++++++++++++++++
 .../noirc_frontend/src/hir/comptime/value.rs  |   2 +-
 .../src/hir/resolution/errors.rs              |  27 ++
 .../src/hir/resolution/resolver.rs            |  18 +-
 .../src/hir/type_check/errors.rs              |   7 +
 .../noirc_frontend/src/hir/type_check/expr.rs |   2 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |  12 +-
 compiler/noirc_frontend/src/hir_def/types.rs  |  22 +-
 .../src/monomorphization/mod.rs               |   2 +-
 compiler/noirc_frontend/src/node_interner.rs  |   2 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  38 +--
 .../src/parser/parser/literals.rs             |  12 +-
 .../noirc_frontend/src/parser/parser/types.rs |   2 +-
 compiler/noirc_frontend/src/tests.rs          |   2 +-
 .../compile_success_empty/macros/Nargo.toml   |   7 +
 .../compile_success_empty/macros/src/main.nr  |  15 +
 tooling/debugger/ignored-tests.txt            |   3 +-
 tooling/nargo_cli/build.rs                    |  32 +-
 tooling/nargo_fmt/src/rewrite/expr.rs         |   8 +
 tooling/nargo_fmt/src/rewrite/typ.rs          |   2 +-
 29 files changed, 877 insertions(+), 83 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/elaborator/unquote.rs
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs
 create mode 100644 test_programs/compile_success_empty/macros/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/macros/src/main.nr

diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index e2c7fea3c07..c71474d7731 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -103,7 +103,7 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
         | Type::TypeVariable(_, _)
         | Type::NamedGeneric(..)
         | Type::Forall(..)
-        | Type::Code
+        | Type::Expr
         | Type::Slice(_)
         | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
         Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index da2d3646b20..075df4ee4e3 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -34,8 +34,17 @@ pub enum ExpressionKind {
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
     Quote(BlockExpression, Span),
+    Unquote(Box<Expression>),
     Comptime(BlockExpression, Span),
 
+    /// Unquote expressions are replaced with UnquoteMarkers when Quoted
+    /// expressions are resolved. Since the expression being quoted remains an
+    /// ExpressionKind (rather than a resolved ExprId), the UnquoteMarker must be
+    /// here in the AST even though it is technically HIR-only.
+    /// Each usize in an UnquoteMarker is an index which corresponds to the index of the
+    /// expression in the Hir::Quote expression list to replace it with.
+    UnquoteMarker(usize),
+
     // This variant is only emitted when inlining the result of comptime
     // code. It is used to translate function values back into the AST while
     // guaranteeing they have the same instantiated type and definition id without resolving again.
@@ -552,6 +561,8 @@ impl Display for ExpressionKind {
             Comptime(block, _) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
+            Unquote(expr) => write!(f, "$({expr})"),
+            UnquoteMarker(index) => write!(f, "${index}"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index c09ad75818a..3492df73103 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -117,7 +117,7 @@ pub enum UnresolvedTypeData {
     ),
 
     // The type of quoted code for metaprogramming
-    Code,
+    Expr,
 
     Unspecified, // This is for when the user declares a variable without specifying it's type
     Error,
@@ -216,7 +216,7 @@ impl std::fmt::Display for UnresolvedTypeData {
                 }
             }
             MutableReference(element) => write!(f, "&mut {element}"),
-            Code => write!(f, "Code"),
+            Expr => write!(f, "Expr"),
             Unit => write!(f, "()"),
             Error => write!(f, "error"),
             Unspecified => write!(f, "unspecified"),
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 57a62324064..48e34ad7fc9 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -728,7 +728,11 @@ impl Display for LValue {
 impl Display for Path {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let segments = vecmap(&self.segments, ToString::to_string);
-        write!(f, "{}::{}", self.kind, segments.join("::"))
+        if self.kind == PathKind::Plain {
+            write!(f, "{}", segments.join("::"))
+        } else {
+            write!(f, "{}::{}", self.kind, segments.join("::"))
+        }
     }
 }
 
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index c1c6945707b..a57690878dc 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -18,7 +18,7 @@ use crate::{
             HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
             HirConstructorExpression, HirIfExpression, HirIndexExpression, HirInfixExpression,
             HirLambda, HirMemberAccess, HirMethodCallExpression, HirMethodReference,
-            HirPrefixExpression,
+            HirPrefixExpression, HirQuoted,
         },
         traits::TraitConstraint,
     },
@@ -64,6 +64,13 @@ impl<'context> Elaborator<'context> {
             }
             ExpressionKind::Resolved(id) => return (id, self.interner.id_type(id)),
             ExpressionKind::Error => (HirExpression::Error, Type::Error),
+            ExpressionKind::Unquote(_) => {
+                self.push_err(ResolverError::UnquoteUsedOutsideQuote { span: expr.span });
+                (HirExpression::Error, Type::Error)
+            }
+            ExpressionKind::UnquoteMarker(index) => {
+                unreachable!("UnquoteMarker({index}) remaining in runtime code")
+            }
         };
         let id = self.interner.push_expr(hir_expr);
         self.interner.push_expr_location(id, expr.span, self.file);
@@ -280,10 +287,22 @@ impl<'context> Elaborator<'context> {
             (typ, arg, span)
         });
 
+        // Avoid cloning arguments unless this is a macro call
+        let mut comptime_args = Vec::new();
+        if call.is_macro_call {
+            comptime_args = arguments.clone();
+        }
+
         let location = Location::new(span, self.file);
-        let call = HirCallExpression { func, arguments, location };
-        let typ = self.type_check_call(&call, func_type, args, span);
-        (HirExpression::Call(call), typ)
+        let hir_call = HirCallExpression { func, arguments, location };
+        let typ = self.type_check_call(&hir_call, func_type, args, span);
+
+        if call.is_macro_call {
+            self.call_macro(func, comptime_args, location, typ)
+                .unwrap_or_else(|| (HirExpression::Error, Type::Error))
+        } else {
+            (HirExpression::Call(hir_call), typ)
+        }
     }
 
     fn elaborate_method_call(
@@ -627,8 +646,11 @@ impl<'context> Elaborator<'context> {
         (expr, Type::Function(arg_types, Box::new(body_type), Box::new(env_type)))
     }
 
-    fn elaborate_quote(&mut self, block: BlockExpression) -> (HirExpression, Type) {
-        (HirExpression::Quote(block), Type::Code)
+    fn elaborate_quote(&mut self, mut block: BlockExpression) -> (HirExpression, Type) {
+        let mut unquoted_exprs = Vec::new();
+        self.find_unquoted_exprs_in_block(&mut block, &mut unquoted_exprs);
+        let quoted = HirQuoted { quoted_block: block, unquoted_exprs };
+        (HirExpression::Quote(quoted), Type::Expr)
     }
 
     fn elaborate_comptime_block(&mut self, block: BlockExpression, span: Span) -> (ExprId, Type) {
@@ -661,4 +683,74 @@ impl<'context> Elaborator<'context> {
             Err(error) => make_error(self, error),
         }
     }
+
+    fn try_get_comptime_function(
+        &mut self,
+        func: ExprId,
+        location: Location,
+    ) -> Result<FuncId, ResolverError> {
+        match self.interner.expression(&func) {
+            HirExpression::Ident(ident, _generics) => {
+                let definition = self.interner.definition(ident.id);
+                if let DefinitionKind::Function(function) = definition.kind {
+                    let meta = self.interner.function_modifiers(&function);
+                    if meta.is_comptime {
+                        Ok(function)
+                    } else {
+                        Err(ResolverError::MacroIsNotComptime { span: location.span })
+                    }
+                } else {
+                    Err(ResolverError::InvalidSyntaxInMacroCall { span: location.span })
+                }
+            }
+            _ => Err(ResolverError::InvalidSyntaxInMacroCall { span: location.span }),
+        }
+    }
+
+    /// Call a macro function and inlines its code at the call site.
+    /// This will also perform a type check to ensure that the return type is an `Expr` value.
+    fn call_macro(
+        &mut self,
+        func: ExprId,
+        arguments: Vec<ExprId>,
+        location: Location,
+        return_type: Type,
+    ) -> Option<(HirExpression, Type)> {
+        self.unify(&return_type, &Type::Expr, || TypeCheckError::MacroReturningNonExpr {
+            typ: return_type.clone(),
+            span: location.span,
+        });
+
+        let function = match self.try_get_comptime_function(func, location) {
+            Ok(function) => function,
+            Err(error) => {
+                self.push_err(error);
+                return None;
+            }
+        };
+
+        let mut interpreter = Interpreter::new(self.interner, &mut self.comptime_scopes);
+
+        let mut comptime_args = Vec::new();
+        let mut errors = Vec::new();
+
+        for argument in arguments {
+            match interpreter.evaluate(argument) {
+                Ok(arg) => {
+                    let location = interpreter.interner.expr_location(&argument);
+                    comptime_args.push((arg, location));
+                }
+                Err(error) => errors.push((error.into(), self.file)),
+            }
+        }
+
+        if !errors.is_empty() {
+            self.errors.append(&mut errors);
+            return None;
+        }
+
+        let result = interpreter.call_function(function, comptime_args, location);
+        let (expr_id, typ) = self.inline_comptime_value(result, location.span);
+        Some((self.interner.expression(&expr_id), typ))
+    }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 7bdb7d2886b..93e8b36f4e0 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -62,6 +62,7 @@ mod scope;
 mod statements;
 mod traits;
 mod types;
+mod unquote;
 
 use fm::FileId;
 use iter_extended::vecmap;
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 3baa7054fc5..a9571a6669d 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -72,7 +72,7 @@ impl<'context> Elaborator<'context> {
                 let fields = self.resolve_type_inner(*fields);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
-            Code => Type::Code,
+            Expr => Type::Expr,
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
@@ -1396,7 +1396,7 @@ impl<'context> Elaborator<'context> {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::Code
+            | Type::Expr
             | Type::Forall(_, _) => (),
 
             Type::TraitAsType(_, _, args) => {
diff --git a/compiler/noirc_frontend/src/elaborator/unquote.rs b/compiler/noirc_frontend/src/elaborator/unquote.rs
new file mode 100644
index 00000000000..6767f471f16
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/unquote.rs
@@ -0,0 +1,306 @@
+use crate::{
+    ast::{
+        ArrayLiteral, AssignStatement, ConstrainStatement, ConstructorExpression, IfExpression,
+        InfixExpression, Lambda,
+    },
+    macros_api::{
+        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind,
+        ForLoopStatement, ForRange, IndexExpression, LetStatement, Literal, MemberAccessExpression,
+        MethodCallExpression, PrefixExpression, Statement, StatementKind,
+    },
+    node_interner::ExprId,
+};
+
+use super::Elaborator;
+
+impl<'a> Elaborator<'a> {
+    pub fn find_unquoted_exprs_in_block(
+        &mut self,
+        block: &mut BlockExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        for statement in &mut block.statements {
+            self.find_unquoted_exprs_in_statement(statement, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_statement(
+        &mut self,
+        statement: &mut Statement,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        match &mut statement.kind {
+            StatementKind::Let(let_) => self.find_unquoted_exprs_in_let(let_, unquoted_exprs),
+            StatementKind::Constrain(constrain) => {
+                self.find_unquoted_exprs_in_constrain(constrain, unquoted_exprs);
+            }
+            StatementKind::Expression(expr) => {
+                self.find_unquoted_exprs_in_expr(expr, unquoted_exprs);
+            }
+            StatementKind::Assign(assign) => {
+                self.find_unquoted_exprs_in_assign(assign, unquoted_exprs);
+            }
+            StatementKind::For(for_) => self.find_unquoted_exprs_in_for(for_, unquoted_exprs),
+            StatementKind::Break => (),
+            StatementKind::Continue => (),
+            StatementKind::Comptime(comptime) => {
+                self.find_unquoted_exprs_in_statement(comptime, unquoted_exprs);
+            }
+            StatementKind::Semi(expr) => self.find_unquoted_exprs_in_expr(expr, unquoted_exprs),
+            StatementKind::Error => (),
+        }
+    }
+
+    fn find_unquoted_exprs_in_constrain(
+        &mut self,
+        constrain: &mut ConstrainStatement,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut constrain.0, unquoted_exprs);
+        if let Some(msg) = constrain.1.as_mut() {
+            self.find_unquoted_exprs_in_expr(msg, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_let(
+        &mut self,
+        let_: &mut LetStatement,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut let_.expression, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_assign(
+        &mut self,
+        assign: &mut AssignStatement,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut assign.expression, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_for(
+        &mut self,
+        for_: &mut ForLoopStatement,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        match &mut for_.range {
+            ForRange::Range(start, end) => {
+                self.find_unquoted_exprs_in_expr(start, unquoted_exprs);
+                self.find_unquoted_exprs_in_expr(end, unquoted_exprs);
+            }
+            ForRange::Array(array) => {
+                self.find_unquoted_exprs_in_expr(array, unquoted_exprs);
+            }
+        };
+        self.find_unquoted_exprs_in_expr(&mut for_.block, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_expr(
+        &mut self,
+        expr: &mut Expression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        match &mut expr.kind {
+            ExpressionKind::Literal(literal) => {
+                self.find_unquoted_exprs_in_literal(literal, unquoted_exprs);
+            }
+            ExpressionKind::Block(block) => {
+                self.find_unquoted_exprs_in_block(block, unquoted_exprs);
+            }
+            ExpressionKind::Prefix(prefix) => {
+                self.find_unquoted_exprs_in_prefix(prefix, unquoted_exprs);
+            }
+            ExpressionKind::Index(index) => {
+                self.find_unquoted_exprs_in_index(index, unquoted_exprs);
+            }
+            ExpressionKind::Call(call) => self.find_unquoted_exprs_in_call(call, unquoted_exprs),
+            ExpressionKind::MethodCall(call) => {
+                self.find_unquoted_exprs_in_method_call(call, unquoted_exprs);
+            }
+            ExpressionKind::Constructor(constructor) => {
+                self.find_unquoted_exprs_in_constructor(constructor, unquoted_exprs);
+            }
+            ExpressionKind::MemberAccess(access) => {
+                self.find_unquoted_exprs_in_access(access, unquoted_exprs);
+            }
+            ExpressionKind::Cast(cast) => self.find_unquoted_exprs_in_cast(cast, unquoted_exprs),
+            ExpressionKind::Infix(infix) => {
+                self.find_unquoted_exprs_in_infix(infix, unquoted_exprs);
+            }
+            ExpressionKind::If(if_) => self.find_unquoted_exprs_in_if(if_, unquoted_exprs),
+            ExpressionKind::Variable(_, _) => (),
+            ExpressionKind::Tuple(tuple) => {
+                self.find_unquoted_exprs_in_tuple(tuple, unquoted_exprs);
+            }
+            ExpressionKind::Lambda(lambda) => {
+                self.find_unquoted_exprs_in_lambda(lambda, unquoted_exprs);
+            }
+            ExpressionKind::Parenthesized(expr) => {
+                self.find_unquoted_exprs_in_expr(expr, unquoted_exprs);
+            }
+            ExpressionKind::Quote(quote, _) => {
+                self.find_unquoted_exprs_in_block(quote, unquoted_exprs);
+            }
+            ExpressionKind::Comptime(block, _) => {
+                self.find_unquoted_exprs_in_block(block, unquoted_exprs);
+            }
+            ExpressionKind::Resolved(_) => (),
+            ExpressionKind::Error => (),
+            ExpressionKind::UnquoteMarker(_) => (),
+            ExpressionKind::Unquote(unquoted) => {
+                // Avoid an expensive clone for unquoted
+                let empty_expr = Expression::new(ExpressionKind::Error, unquoted.span);
+                let unquote = std::mem::replace(unquoted.as_mut(), empty_expr);
+                self.replace_unquote(expr, unquote, unquoted_exprs);
+            }
+        }
+    }
+
+    fn find_unquoted_exprs_in_literal(
+        &mut self,
+        literal: &mut Literal,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        match literal {
+            Literal::Array(array) | Literal::Slice(array) => match array {
+                ArrayLiteral::Standard(elements) => {
+                    for element in elements {
+                        self.find_unquoted_exprs_in_expr(element, unquoted_exprs);
+                    }
+                }
+                ArrayLiteral::Repeated { repeated_element, length } => {
+                    self.find_unquoted_exprs_in_expr(repeated_element, unquoted_exprs);
+                    self.find_unquoted_exprs_in_expr(length, unquoted_exprs);
+                }
+            },
+            Literal::Bool(_)
+            | Literal::Integer(_, _)
+            | Literal::Str(_)
+            | Literal::RawStr(_, _)
+            | Literal::FmtStr(_)
+            | Literal::Unit => (),
+        }
+    }
+
+    fn find_unquoted_exprs_in_prefix(
+        &mut self,
+        prefix: &mut PrefixExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut prefix.rhs, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_index(
+        &mut self,
+        index: &mut IndexExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut index.collection, unquoted_exprs);
+        self.find_unquoted_exprs_in_expr(&mut index.index, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_call(
+        &mut self,
+        call: &mut CallExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut call.func, unquoted_exprs);
+
+        for arg in &mut call.arguments {
+            self.find_unquoted_exprs_in_expr(arg, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_method_call(
+        &mut self,
+        call: &mut MethodCallExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut call.object, unquoted_exprs);
+
+        for arg in &mut call.arguments {
+            self.find_unquoted_exprs_in_expr(arg, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_constructor(
+        &mut self,
+        constructor: &mut ConstructorExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        for (_, field) in &mut constructor.fields {
+            self.find_unquoted_exprs_in_expr(field, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_access(
+        &mut self,
+        member_access: &mut MemberAccessExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut member_access.lhs, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_cast(
+        &mut self,
+        cast: &mut CastExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut cast.lhs, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_infix(
+        &mut self,
+        infix: &mut InfixExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut infix.lhs, unquoted_exprs);
+        self.find_unquoted_exprs_in_expr(&mut infix.rhs, unquoted_exprs);
+    }
+
+    fn find_unquoted_exprs_in_if(
+        &mut self,
+        if_: &mut IfExpression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut if_.condition, unquoted_exprs);
+        self.find_unquoted_exprs_in_expr(&mut if_.consequence, unquoted_exprs);
+
+        if let Some(alternate) = if_.alternative.as_mut() {
+            self.find_unquoted_exprs_in_expr(alternate, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_tuple(
+        &mut self,
+        tuple: &mut [Expression],
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        for field in tuple {
+            self.find_unquoted_exprs_in_expr(field, unquoted_exprs);
+        }
+    }
+
+    fn find_unquoted_exprs_in_lambda(
+        &mut self,
+        lambda: &mut Lambda,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        self.find_unquoted_exprs_in_expr(&mut lambda.body, unquoted_exprs);
+    }
+
+    /// Elaborate and store the unquoted expression in the given vector, then
+    /// replace it with an unquote expression with an UnquoteMarker expression to mark the position
+    /// to replace it with later.
+    fn replace_unquote(
+        &mut self,
+        expr: &mut Expression,
+        unquoted: Expression,
+        unquoted_exprs: &mut Vec<ExprId>,
+    ) {
+        let (expr_id, _) = self.elaborate_expression(unquoted);
+        let unquote_marker_id = unquoted_exprs.len();
+        unquoted_exprs.push(expr_id);
+        expr.kind = ExpressionKind::UnquoteMarker(unquote_marker_id);
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index dd436144969..8cb0db3ee55 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -7,6 +7,7 @@ use noirc_errors::Location;
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness};
+use crate::hir_def::expr::HirQuoted;
 use crate::{
     hir_def::{
         expr::{
@@ -25,13 +26,17 @@ use crate::{
     Shared, Type, TypeBinding, TypeBindings, TypeVariableKind,
 };
 
+use self::unquote::UnquoteArgs;
+
 use super::errors::{IResult, InterpreterError};
 use super::value::Value;
 
+mod unquote;
+
 #[allow(unused)]
 pub struct Interpreter<'interner> {
     /// To expand macros the Interpreter may mutate hir nodes within the NodeInterner
-    pub(super) interner: &'interner mut NodeInterner,
+    pub interner: &'interner mut NodeInterner,
 
     /// Each value currently in scope in the interpreter.
     /// Each element of the Vec represents a scope with every scope together making
@@ -312,7 +317,7 @@ impl<'a> Interpreter<'a> {
     }
 
     /// Evaluate an expression and return the result
-    pub(super) fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
+    pub fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
         match self.interner.expression(&id) {
             HirExpression::Ident(ident, _) => self.evaluate_ident(ident, id),
             HirExpression::Literal(literal) => self.evaluate_literal(literal, id),
@@ -328,7 +333,7 @@ impl<'a> Interpreter<'a> {
             HirExpression::If(if_) => self.evaluate_if(if_, id),
             HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
-            HirExpression::Quote(block) => Ok(Value::Code(Rc::new(block))),
+            HirExpression::Quote(block) => self.evaluate_quote(block, id),
             HirExpression::Comptime(block) => self.evaluate_block(block),
             HirExpression::Unquote(block) => {
                 // An Unquote expression being found is indicative of a macro being
@@ -1120,6 +1125,15 @@ impl<'a> Interpreter<'a> {
         Ok(Value::Closure(lambda, environment, typ))
     }
 
+    fn evaluate_quote(&mut self, mut quoted: HirQuoted, expr_id: ExprId) -> IResult<Value> {
+        let file = self.interner.expr_location(&expr_id).file;
+        let values = try_vecmap(quoted.unquoted_exprs, |value| self.evaluate(value))?;
+        let args = UnquoteArgs { values, file };
+
+        self.substitute_unquoted_values_into_block(&mut quoted.quoted_block, &args);
+        Ok(Value::Code(Rc::new(quoted.quoted_block)))
+    }
+
     pub fn evaluate_statement(&mut self, statement: StmtId) -> IResult<Value> {
         match self.interner.statement(&statement) {
             HirStatement::Let(let_) => self.evaluate_let(let_),
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs
new file mode 100644
index 00000000000..58ca345ca90
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs
@@ -0,0 +1,287 @@
+use fm::FileId;
+use noirc_errors::Location;
+
+use crate::{
+    ast::{
+        ArrayLiteral, AssignStatement, ConstrainStatement, ConstructorExpression, IfExpression,
+        InfixExpression, Lambda,
+    },
+    hir::comptime::{errors::IResult, Value},
+    macros_api::{
+        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind,
+        ForLoopStatement, ForRange, IndexExpression, LetStatement, Literal, MemberAccessExpression,
+        MethodCallExpression, PrefixExpression, Statement, StatementKind,
+    },
+};
+
+use super::Interpreter;
+
+pub(super) struct UnquoteArgs {
+    pub(super) values: Vec<Value>,
+    pub(super) file: FileId,
+}
+
+impl<'a> Interpreter<'a> {
+    pub(super) fn substitute_unquoted_values_into_block(
+        &mut self,
+        block: &mut BlockExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        for statement in &mut block.statements {
+            self.substitute_unquoted_into_statement(statement, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_statement(
+        &mut self,
+        statement: &mut Statement,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        match &mut statement.kind {
+            StatementKind::Let(let_) => self.substitute_unquoted_into_let(let_, args),
+            StatementKind::Constrain(constrain) => {
+                self.substitute_unquoted_into_constrain(constrain, args)
+            }
+            StatementKind::Expression(expr) => self.substitute_unquoted_into_expr(expr, args),
+            StatementKind::Assign(assign) => self.substitute_unquoted_into_assign(assign, args),
+            StatementKind::For(for_) => self.substitute_unquoted_into_for(for_, args),
+            StatementKind::Break => Ok(()),
+            StatementKind::Continue => Ok(()),
+            StatementKind::Comptime(comptime) => {
+                self.substitute_unquoted_into_statement(comptime, args)
+            }
+            StatementKind::Semi(expr) => self.substitute_unquoted_into_expr(expr, args),
+            StatementKind::Error => Ok(()),
+        }
+    }
+
+    fn substitute_unquoted_into_constrain(
+        &mut self,
+        constrain: &mut ConstrainStatement,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut constrain.0, args)?;
+        if let Some(msg) = constrain.1.as_mut() {
+            self.substitute_unquoted_into_expr(msg, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_let(
+        &mut self,
+        let_: &mut LetStatement,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut let_.expression, args)
+    }
+
+    fn substitute_unquoted_into_assign(
+        &mut self,
+        assign: &mut AssignStatement,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut assign.expression, args)
+    }
+
+    fn substitute_unquoted_into_for(
+        &mut self,
+        for_: &mut ForLoopStatement,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        match &mut for_.range {
+            ForRange::Range(start, end) => {
+                self.substitute_unquoted_into_expr(start, args)?;
+                self.substitute_unquoted_into_expr(end, args)?;
+            }
+            ForRange::Array(array) => {
+                self.substitute_unquoted_into_expr(array, args)?;
+            }
+        };
+        self.substitute_unquoted_into_expr(&mut for_.block, args)
+    }
+
+    fn substitute_unquoted_into_expr(
+        &mut self,
+        expr: &mut Expression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        match &mut expr.kind {
+            ExpressionKind::Literal(literal) => {
+                self.substitute_unquoted_into_literal(literal, args)
+            }
+            ExpressionKind::Block(block) => self.substitute_unquoted_values_into_block(block, args),
+            ExpressionKind::Prefix(prefix) => self.substitute_unquoted_into_prefix(prefix, args),
+            ExpressionKind::Index(index) => self.substitute_unquoted_into_index(index, args),
+            ExpressionKind::Call(call) => self.substitute_unquoted_into_call(call, args),
+            ExpressionKind::MethodCall(call) => {
+                self.substitute_unquoted_into_method_call(call, args)
+            }
+            ExpressionKind::Constructor(constructor) => {
+                self.substitute_unquoted_into_constructor(constructor, args)
+            }
+            ExpressionKind::MemberAccess(access) => {
+                self.substitute_unquoted_into_access(access, args)
+            }
+            ExpressionKind::Cast(cast) => self.substitute_unquoted_into_cast(cast, args),
+            ExpressionKind::Infix(infix) => self.substitute_unquoted_into_infix(infix, args),
+            ExpressionKind::If(if_) => self.substitute_unquoted_into_if(if_, args),
+            ExpressionKind::Variable(_, _) => Ok(()),
+            ExpressionKind::Tuple(tuple) => self.substitute_unquoted_into_tuple(tuple, args),
+            ExpressionKind::Lambda(lambda) => self.substitute_unquoted_into_lambda(lambda, args),
+            ExpressionKind::Parenthesized(expr) => self.substitute_unquoted_into_expr(expr, args),
+            ExpressionKind::Quote(quote, _) => {
+                self.substitute_unquoted_values_into_block(quote, args)
+            }
+            ExpressionKind::Unquote(unquote) => self.substitute_unquoted_into_expr(unquote, args),
+            ExpressionKind::Comptime(comptime, _) => {
+                self.substitute_unquoted_values_into_block(comptime, args)
+            }
+            ExpressionKind::Resolved(_) => Ok(()),
+            ExpressionKind::Error => Ok(()),
+            ExpressionKind::UnquoteMarker(index) => {
+                let location = Location::new(expr.span, args.file);
+                *expr = args.values[*index].clone().into_expression(self.interner, location)?;
+                Ok(())
+            }
+        }
+    }
+
+    fn substitute_unquoted_into_literal(
+        &mut self,
+        literal: &mut Literal,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        match literal {
+            Literal::Array(array) | Literal::Slice(array) => match array {
+                ArrayLiteral::Standard(elements) => {
+                    for element in elements {
+                        self.substitute_unquoted_into_expr(element, args)?;
+                    }
+                    Ok(())
+                }
+                ArrayLiteral::Repeated { repeated_element, length } => {
+                    self.substitute_unquoted_into_expr(repeated_element, args)?;
+                    self.substitute_unquoted_into_expr(length, args)?;
+                    Ok(())
+                }
+            },
+            Literal::Bool(_)
+            | Literal::Integer(_, _)
+            | Literal::Str(_)
+            | Literal::RawStr(_, _)
+            | Literal::FmtStr(_)
+            | Literal::Unit => Ok(()),
+        }
+    }
+
+    fn substitute_unquoted_into_prefix(
+        &mut self,
+        prefix: &mut PrefixExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut prefix.rhs, args)
+    }
+
+    fn substitute_unquoted_into_index(
+        &mut self,
+        index: &mut IndexExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut index.collection, args)?;
+        self.substitute_unquoted_into_expr(&mut index.index, args)
+    }
+
+    fn substitute_unquoted_into_call(
+        &mut self,
+        call: &mut CallExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut call.func, args)?;
+        for arg in &mut call.arguments {
+            self.substitute_unquoted_into_expr(arg, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_method_call(
+        &mut self,
+        call: &mut MethodCallExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut call.object, args)?;
+        for arg in &mut call.arguments {
+            self.substitute_unquoted_into_expr(arg, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_constructor(
+        &mut self,
+        constructor: &mut ConstructorExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        for (_, field) in &mut constructor.fields {
+            self.substitute_unquoted_into_expr(field, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_access(
+        &mut self,
+        access: &mut MemberAccessExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut access.lhs, args)
+    }
+
+    fn substitute_unquoted_into_cast(
+        &mut self,
+        cast: &mut CastExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut cast.lhs, args)
+    }
+
+    fn substitute_unquoted_into_infix(
+        &mut self,
+        infix: &mut InfixExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut infix.lhs, args)?;
+        self.substitute_unquoted_into_expr(&mut infix.rhs, args)
+    }
+
+    fn substitute_unquoted_into_if(
+        &mut self,
+        if_: &mut IfExpression,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut if_.condition, args)?;
+        self.substitute_unquoted_into_expr(&mut if_.consequence, args)?;
+
+        if let Some(alternative) = if_.alternative.as_mut() {
+            self.substitute_unquoted_into_expr(alternative, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_tuple(
+        &mut self,
+        tuple: &mut [Expression],
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        for field in tuple {
+            self.substitute_unquoted_into_expr(field, args)?;
+        }
+        Ok(())
+    }
+
+    fn substitute_unquoted_into_lambda(
+        &mut self,
+        lambda: &mut Lambda,
+        args: &UnquoteArgs,
+    ) -> IResult<()> {
+        self.substitute_unquoted_into_expr(&mut lambda.body, args)
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 11bbbc7484d..5d91b151218 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -70,7 +70,7 @@ impl Value {
             Value::Struct(_, typ) => return Cow::Borrowed(typ),
             Value::Array(_, typ) => return Cow::Borrowed(typ),
             Value::Slice(_, typ) => return Cow::Borrowed(typ),
-            Value::Code(_) => Type::Code,
+            Value::Code(_) => Type::Expr,
             Value::Pointer(element) => {
                 let element = element.borrow().get_type().into_owned();
                 Type::MutableReference(Box::new(element))
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 07fbde4db8e..2c6461cb77c 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -100,6 +100,12 @@ pub enum ResolverError {
     FoldAttributeOnUnconstrained { ident: Ident },
     #[error("Invalid array length construction")]
     ArrayLengthInterpreter { error: InterpreterError },
+    #[error("The unquote operator '$' can only be used within a quote expression")]
+    UnquoteUsedOutsideQuote { span: Span },
+    #[error("Invalid syntax in macro call")]
+    InvalidSyntaxInMacroCall { span: Span },
+    #[error("Macros must be comptime functions")]
+    MacroIsNotComptime { span: Span },
 }
 
 impl ResolverError {
@@ -391,6 +397,27 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diag
             }
             ResolverError::ArrayLengthInterpreter { error } => Diagnostic::from(error),
+            ResolverError::UnquoteUsedOutsideQuote { span } => {
+                Diagnostic::simple_error(
+                    "The unquote operator '$' can only be used within a quote expression".into(),
+                    "".into(),
+                    *span,
+                )
+            },
+            ResolverError::InvalidSyntaxInMacroCall { span } => {
+                Diagnostic::simple_error(
+                    "Invalid syntax in macro call".into(),
+                    "Macro calls must call a comptime function directly, they cannot use higher-order functions".into(),
+                    *span,
+                )
+            },
+            ResolverError::MacroIsNotComptime{ span } => {
+                Diagnostic::simple_error(
+                    "This macro call is to a non-comptime function".into(),
+                    "Macro calls must be to comptime functions".into(),
+                    *span,
+                )
+            },
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 133f971da19..4583125d2a2 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -17,7 +17,7 @@ use crate::hir_def::expr::{
     HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCapturedVar,
     HirCastExpression, HirConstructorExpression, HirExpression, HirIdent, HirIfExpression,
     HirIndexExpression, HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess,
-    HirMethodCallExpression, HirPrefixExpression, ImplKind,
+    HirMethodCallExpression, HirPrefixExpression, HirQuoted, ImplKind,
 };
 
 use crate::hir_def::function::FunctionBody;
@@ -569,7 +569,7 @@ impl<'a> Resolver<'a> {
                 let fields = self.resolve_type_inner(*fields);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
-            Code => Type::Code,
+            Expr => Type::Expr,
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
@@ -1158,7 +1158,7 @@ impl<'a> Resolver<'a> {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::Code
+            | Type::Expr
             | Type::Forall(_, _) => (),
 
             Type::TraitAsType(_, _, args) => {
@@ -1641,13 +1641,23 @@ impl<'a> Resolver<'a> {
             ExpressionKind::Parenthesized(sub_expr) => return self.resolve_expression(*sub_expr),
 
             // The quoted expression isn't resolved since we don't want errors if variables aren't defined
-            ExpressionKind::Quote(block, _) => HirExpression::Quote(block),
+            ExpressionKind::Quote(block, _) => {
+                let quoted = HirQuoted { quoted_block: block, unquoted_exprs: Vec::new() };
+                HirExpression::Quote(quoted)
+            }
             ExpressionKind::Comptime(block, _) => {
                 HirExpression::Comptime(self.resolve_block(block))
             }
             ExpressionKind::Resolved(_) => unreachable!(
                 "ExpressionKind::Resolved should only be emitted by the comptime interpreter"
             ),
+            ExpressionKind::Unquote(_) => {
+                self.push_err(ResolverError::UnquoteUsedOutsideQuote { span: expr.span });
+                HirExpression::Literal(HirLiteral::Unit)
+            }
+            ExpressionKind::UnquoteMarker(index) => {
+                unreachable!("UnquoteMarker({index}) remaining in runtime code")
+            }
         };
 
         // If these lines are ever changed, make sure to change the early return
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 0d8a9f3e717..bd32ba2fce5 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -143,6 +143,8 @@ pub enum TypeCheckError {
     },
     #[error("Strings do not support indexed assignment")]
     StringIndexAssign { span: Span },
+    #[error("Macro calls may only return Expr values")]
+    MacroReturningNonExpr { typ: Type, span: Span },
 }
 
 impl TypeCheckError {
@@ -335,6 +337,11 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 let msg = format!("Expected {expected_count} generic{expected_plural} from this function, but {actual_count} {actual_plural} provided");
                 Diagnostic::simple_error(msg, "".into(), *span)
             },
+            TypeCheckError::MacroReturningNonExpr { typ, span } => Diagnostic::simple_error(
+                format!("Expected macro call to return an `Expr` but found a(n) {typ}"),
+                "Macro calls must return quoted expressions, otherwise there is no code to insert".into(),
+                *span,
+                ),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 50af9dbf34e..503bbbf79be 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -307,7 +307,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 Type::Function(params, Box::new(lambda.return_type), Box::new(env_type))
             }
-            HirExpression::Quote(_) => Type::Code,
+            HirExpression::Quote(_) => Type::Expr,
             HirExpression::Comptime(block) => self.check_block(block),
 
             // Unquote should be inserted & removed by the comptime interpreter.
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index 163ea10ee02..9547aef866b 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -33,7 +33,7 @@ pub enum HirExpression {
     If(HirIfExpression),
     Tuple(Vec<ExprId>),
     Lambda(HirLambda),
-    Quote(crate::ast::BlockExpression),
+    Quote(HirQuoted),
     Unquote(crate::ast::BlockExpression),
     Comptime(HirBlockExpression),
     Error,
@@ -291,3 +291,13 @@ pub struct HirLambda {
     pub body: ExprId,
     pub captures: Vec<HirCapturedVar>,
 }
+
+#[derive(Debug, Clone)]
+pub struct HirQuoted {
+    pub quoted_block: crate::ast::BlockExpression,
+
+    /// Each expression here corresponds to a `ExpressionKind::UnquoteMarker(index)` in `quoted_block`.
+    /// The values of these expressions after evaluation will be inlined into the position
+    /// indicated by their corresponding UnquoteMarker with that index.
+    pub unquoted_exprs: Vec<ExprId>,
+}
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index ff8b11f3916..f5c90b33c11 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -105,7 +105,7 @@ pub enum Type {
     Constant(u32),
 
     /// The type of quoted code in macros. This is always a comptime-only type
-    Code,
+    Expr,
 
     /// The result of some type error. Remembering type errors as their own type variant lets
     /// us avoid issuing repeat type errors for the same item. For example, a lambda with
@@ -147,7 +147,7 @@ impl Type {
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Constant(_)
-            | Type::Code
+            | Type::Expr
             | Type::Slice(_)
             | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
         }
@@ -640,7 +640,7 @@ impl Type {
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::Forall(_, _)
-            | Type::Code => false,
+            | Type::Expr => false,
 
             Type::TraitAsType(_, _, args) => {
                 args.iter().any(|generic| generic.contains_numeric_typevar(target_id))
@@ -706,7 +706,7 @@ impl Type {
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
-            | Type::Code
+            | Type::Expr
             | Type::Slice(_)
             | Type::TraitAsType(..) => false,
 
@@ -755,7 +755,7 @@ impl Type {
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             // TODO: probably can allow code as it is all compile time
-            | Type::Code
+            | Type::Expr
             | Type::TraitAsType(..) => false,
 
             Type::Alias(alias, generics) => {
@@ -918,7 +918,7 @@ impl std::fmt::Display for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element}")
             }
-            Type::Code => write!(f, "Code"),
+            Type::Expr => write!(f, "Expr"),
         }
     }
 }
@@ -1639,7 +1639,7 @@ impl Type {
             | Type::Bool
             | Type::Constant(_)
             | Type::Error
-            | Type::Code
+            | Type::Expr
             | Type::Unit => self.clone(),
         }
     }
@@ -1682,7 +1682,7 @@ impl Type {
             | Type::Bool
             | Type::Constant(_)
             | Type::Error
-            | Type::Code
+            | Type::Expr
             | Type::Unit => false,
         }
     }
@@ -1739,7 +1739,7 @@ impl Type {
 
             // Expect that this function should only be called on instantiated types
             Forall(..) => unreachable!(),
-            FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Code | Error => self.clone(),
+            FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Expr | Error => self.clone(),
         }
     }
 
@@ -1874,7 +1874,7 @@ impl From<&Type> for PrintableType {
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
             }
-            Type::Code => unreachable!(),
+            Type::Expr => unreachable!(),
         }
     }
 }
@@ -1959,7 +1959,7 @@ impl std::fmt::Debug for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element:?}")
             }
-            Type::Code => write!(f, "Code"),
+            Type::Expr => write!(f, "Expr"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 7ecea5c9eac..c6cc1344aae 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -1012,7 +1012,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::Forall(_, _) | HirType::Constant(_) | HirType::Error => {
                 unreachable!("Unexpected type {} found", typ)
             }
-            HirType::Code => unreachable!("Tried to translate Code type into runtime code"),
+            HirType::Expr => unreachable!("Tried to translate Code type into runtime code"),
         })
     }
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index e29c3183993..5fdce80087a 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1825,7 +1825,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::Tuple(_) => Some(Tuple),
         Type::Function(_, _, _) => Some(Function),
         Type::NamedGeneric(_, _) => Some(Generic),
-        Type::Code => Some(Code),
+        Type::Expr => Some(Code),
         Type::MutableReference(element) => get_type_method_key(element),
         Type::Alias(alias, _) => get_type_method_key(&alias.borrow().typ),
 
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 5107e10f4df..0d8215f2ea4 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1123,8 +1123,7 @@ where
     P: ExprParser + 'a,
 {
     let unquote = variable().map_with_span(Expression::new).or(parenthesized(expr_parser));
-    // This will be updated to ExpressionKind::Unquote in a later PR
-    just(Token::DollarSign).ignore_then(unquote).map(|_| ExpressionKind::Error)
+    just(Token::DollarSign).ignore_then(unquote).map(|expr| ExpressionKind::Unquote(Box::new(expr)))
 }
 
 fn tuple<P>(expr_parser: P) -> impl NoirParser<Expression>
@@ -1548,27 +1547,19 @@ mod test {
             Case { source: "let = 4 + 3", expect: "let $error: unspecified = (4 + 3)", errors: 1 },
             Case { source: "let = ", expect: "let $error: unspecified = Error", errors: 2 },
             Case { source: "let", expect: "let $error: unspecified = Error", errors: 3 },
-            Case { source: "foo = one two three", expect: "foo = plain::one", errors: 1 },
+            Case { source: "foo = one two three", expect: "foo = one", errors: 1 },
             Case { source: "constrain", expect: "constrain Error", errors: 2 },
             Case { source: "assert", expect: "constrain Error", errors: 1 },
-            Case { source: "constrain x ==", expect: "constrain (plain::x == Error)", errors: 2 },
-            Case { source: "assert(x ==)", expect: "constrain (plain::x == Error)", errors: 1 },
-            Case {
-                source: "assert(x == x, x)",
-                expect: "constrain (plain::x == plain::x)",
-                errors: 0,
-            },
+            Case { source: "constrain x ==", expect: "constrain (x == Error)", errors: 2 },
+            Case { source: "assert(x ==)", expect: "constrain (x == Error)", errors: 1 },
+            Case { source: "assert(x == x, x)", expect: "constrain (x == x)", errors: 0 },
             Case { source: "assert_eq(x,)", expect: "constrain (Error == Error)", errors: 1 },
             Case {
                 source: "assert_eq(x, x, x, x)",
                 expect: "constrain (Error == Error)",
                 errors: 1,
             },
-            Case {
-                source: "assert_eq(x, x, x)",
-                expect: "constrain (plain::x == plain::x)",
-                errors: 0,
-            },
+            Case { source: "assert_eq(x, x, x)", expect: "constrain (x == x)", errors: 0 },
         ];
 
         check_cases_with_errors(&cases[..], fresh_statement());
@@ -1610,7 +1601,7 @@ mod test {
                 source: "{ if structure { a: 1 } {} }",
                 expect: concat!(
                     "{\n",
-                    "    if plain::structure {\n",
+                    "    if structure {\n",
                     "        Error\n",
                     "    }\n",
                     "    {\n",
@@ -1621,22 +1612,17 @@ mod test {
             },
             Case {
                 source: "{ if ( structure { a: 1 } ) {} }",
-                expect: concat!("{\n", "    if ((plain::structure { a: 1 })) {\n", "    }\n", "}",),
+                expect: concat!("{\n", "    if ((structure { a: 1 })) {\n", "    }\n", "}",),
                 errors: 0,
             },
             Case {
                 source: "{ if ( structure {} ) {} }",
-                expect: concat!("{\n", "    if ((plain::structure {  })) {\n", "    }\n", "}"),
+                expect: concat!("{\n", "    if ((structure {  })) {\n", "    }\n", "}"),
                 errors: 0,
             },
             Case {
                 source: "{ if (a { x: 1 }, b { y: 2 }) {} }",
-                expect: concat!(
-                    "{\n",
-                    "    if ((plain::a { x: 1 }), (plain::b { y: 2 })) {\n",
-                    "    }\n",
-                    "}",
-                ),
+                expect: concat!("{\n", "    if ((a { x: 1 }), (b { y: 2 })) {\n", "    }\n", "}",),
                 errors: 0,
             },
             Case {
@@ -1644,8 +1630,8 @@ mod test {
                 expect: concat!(
                     "{\n",
                     "    if ({\n",
-                    "        let foo: unspecified = (plain::bar { baz: 42 })\n",
-                    "        (plain::foo == (plain::bar { baz: 42 }))\n",
+                    "        let foo: unspecified = (bar { baz: 42 })\n",
+                    "        (foo == (bar { baz: 42 }))\n",
                     "    }) {\n",
                     "    }\n",
                     "}",
diff --git a/compiler/noirc_frontend/src/parser/parser/literals.rs b/compiler/noirc_frontend/src/parser/parser/literals.rs
index 584224fda46..b25b6acc9e2 100644
--- a/compiler/noirc_frontend/src/parser/parser/literals.rs
+++ b/compiler/noirc_frontend/src/parser/parser/literals.rs
@@ -108,18 +108,18 @@ mod test {
             #[allow(clippy::needless_raw_string_hashes)]
             Case { source: r####"r###""###"####, expect: r####"r###""###"####, errors: 0 },
             // miscellaneous
-            Case { source: r##" r#\"foo\"# "##, expect: "plain::r", errors: 2 },
-            Case { source: r#" r\"foo\" "#, expect: "plain::r", errors: 1 },
+            Case { source: r##" r#\"foo\"# "##, expect: "r", errors: 2 },
+            Case { source: r#" r\"foo\" "#, expect: "r", errors: 1 },
             Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
             // missing 'r' letter
             Case { source: r##" ##"foo"# "##, expect: r#""foo""#, errors: 2 },
-            Case { source: r#" #"foo" "#, expect: "plain::foo", errors: 2 },
+            Case { source: r#" #"foo" "#, expect: "foo", errors: 2 },
             // whitespace
-            Case { source: r##" r #"foo"# "##, expect: "plain::r", errors: 2 },
-            Case { source: r##" r# "foo"# "##, expect: "plain::r", errors: 3 },
+            Case { source: r##" r #"foo"# "##, expect: "r", errors: 2 },
+            Case { source: r##" r# "foo"# "##, expect: "r", errors: 3 },
             Case { source: r#" r#"foo" # "#, expect: "(none)", errors: 2 },
             // after identifier
-            Case { source: r##" bar#"foo"# "##, expect: "plain::bar", errors: 2 },
+            Case { source: r##" bar#"foo"# "##, expect: "bar", errors: 2 },
             // nested
             Case {
                 source: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index a79a2ef67f2..40edc9936d1 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -69,7 +69,7 @@ pub(super) fn bool_type() -> impl NoirParser<UnresolvedType> {
 
 /// This is the type `Expr` - the type of a quoted, untyped expression object used for macros
 pub(super) fn expr_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Expr).map_with_span(|_, span| UnresolvedTypeData::Code.with_span(span))
+    keyword(Keyword::Expr).map_with_span(|_, span| UnresolvedTypeData::Expr.with_span(span))
 }
 
 pub(super) fn string_type() -> impl NoirParser<UnresolvedType> {
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 99215c8f173..1acf1fbf3f2 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -619,7 +619,7 @@ fn check_impl_struct_not_trait() {
             CompilationError::DefinitionError(DefCollectorErrorKind::NotATrait {
                 not_a_trait_name,
             }) => {
-                assert_eq!(not_a_trait_name.to_string(), "plain::Default");
+                assert_eq!(not_a_trait_name.to_string(), "Default");
             }
             _ => {
                 panic!("No other errors are expected! Found = {:?}", err);
diff --git a/test_programs/compile_success_empty/macros/Nargo.toml b/test_programs/compile_success_empty/macros/Nargo.toml
new file mode 100644
index 00000000000..e4408e2ee17
--- /dev/null
+++ b/test_programs/compile_success_empty/macros/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "macros"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/macros/src/main.nr b/test_programs/compile_success_empty/macros/src/main.nr
new file mode 100644
index 00000000000..f466226d575
--- /dev/null
+++ b/test_programs/compile_success_empty/macros/src/main.nr
@@ -0,0 +1,15 @@
+comptime fn my_macro(x: Field, y: Field) -> Expr {
+    // Current version of macros in Noir are not hygienic
+    // so we can quote a and b here and expect them to resolve
+    // to the a and b in main at the callsite of my_macro.
+    quote {
+        $x + $y + a + b
+    }
+}
+
+fn main() {
+    let a = 100;
+    let b = 200;
+    let result = my_macro!(1, 2);
+    assert_eq(result, 1 + 2 + a + b);
+}
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index a9193896589..a3971d437fb 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -11,7 +11,8 @@ fold_distinct_return
 fold_fibonacci
 fold_numeric_generic_poseidon
 is_unconstrained
+macros
 modulus
 references
 regression_4709
-to_bytes_integration
\ No newline at end of file
+to_bytes_integration
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index fcc09653c7d..846160320cf 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -42,22 +42,27 @@ fn main() {
 /// These should be fixed and removed from this list.
 const IGNORED_BRILLIG_TESTS: [&str; 11] = [
     // Takes a very long time to execute as large loops do not get simplified.
-    &"regression_4709",
+    "regression_4709",
     // bit sizes for bigint operation doesn't match up.
-    &"bigint",
+    "bigint",
     // ICE due to looking for function which doesn't exist.
-    &"fold_after_inlined_calls",
-    &"fold_basic",
-    &"fold_basic_nested_call",
-    &"fold_call_witness_condition",
-    &"fold_complex_outputs",
-    &"fold_distinct_return",
-    &"fold_fibonacci",
-    &"fold_numeric_generic_poseidon",
+    "fold_after_inlined_calls",
+    "fold_basic",
+    "fold_basic_nested_call",
+    "fold_call_witness_condition",
+    "fold_complex_outputs",
+    "fold_distinct_return",
+    "fold_fibonacci",
+    "fold_numeric_generic_poseidon",
     // Expected to fail as test asserts on which runtime it is in.
-    &"is_unconstrained",
+    "is_unconstrained",
 ];
 
+/// Certain comptime features are only available in the elaborator.
+/// We skip these tests for non-elaborator code since they are not
+/// expected to work there. This can be removed once the old code is removed.
+const IGNORED_COMPTIME_TESTS: [&str; 1] = ["macros"];
+
 fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_sub_dir = "execution_success";
     let test_data_dir = test_data_dir.join(test_sub_dir);
@@ -281,10 +286,13 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
         };
         let test_dir = &test_dir.path();
 
+        let comptime_ignored =
+            if IGNORED_COMPTIME_TESTS.contains(&test_name.as_str()) { "\n#[ignore]" } else { "" };
+
         write!(
             test_file,
             r#"
-#[test]
+#[test]{comptime_ignored}
 fn compile_success_empty_{test_name}() {{
 
     let test_program_dir = PathBuf::from("{test_dir}");
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 1d450bb7e28..ec8ac4abec7 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -178,6 +178,14 @@ pub(crate) fn rewrite(
         ExpressionKind::Resolved(_) => {
             unreachable!("ExpressionKind::Resolved should only emitted by the comptime interpreter")
         }
+        ExpressionKind::Unquote(expr) => {
+            if matches!(&expr.kind, ExpressionKind::Variable(..)) {
+                format!("${expr}")
+            } else {
+                format!("$({})", rewrite_sub_expr(visitor, shape, *expr))
+            }
+        }
+        ExpressionKind::UnquoteMarker(_) => unreachable!("UnquoteMarker in runtime code"),
     }
 }
 
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
index 278457f82d1..3ad1d9302be 100644
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ b/tooling/nargo_fmt/src/rewrite/typ.rs
@@ -64,7 +64,7 @@ pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType)
         | UnresolvedTypeData::Expression(_)
         | UnresolvedTypeData::String(_)
         | UnresolvedTypeData::FormatString(_, _)
-        | UnresolvedTypeData::Code
+        | UnresolvedTypeData::Expr
         | UnresolvedTypeData::TraitAsType(_, _) => visitor.slice(typ.span.unwrap()).into(),
         UnresolvedTypeData::Error => unreachable!(),
     }

From b351cc07be4ce7e46314ce378f4bef6776b2d4f3 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 17 Jun 2024 11:58:34 +0200
Subject: [PATCH 377/416] chore: add no-predicate to hash implementations
 (#5253)

# Description

## Problem\*

Related to #4688

## Summary\*
Adding the no-predicate attribute to the hash implementations of the
stdlib


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/hash/mimc.nr                  |  1 +
 noir_stdlib/src/hash/poseidon/bn254.nr        | 17 ++++++++++++++
 noir_stdlib/src/sha256.nr                     |  1 +
 noir_stdlib/src/sha512.nr                     |  1 +
 .../regression_5252/Nargo.toml                |  7 ++++++
 .../regression_5252/Prover.toml               |  6 +++++
 .../regression_5252/src/main.nr               | 23 +++++++++++++++++++
 7 files changed, 56 insertions(+)
 create mode 100644 test_programs/execution_success/regression_5252/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_5252/Prover.toml
 create mode 100644 test_programs/execution_success/regression_5252/src/main.nr

diff --git a/noir_stdlib/src/hash/mimc.nr b/noir_stdlib/src/hash/mimc.nr
index 6c5502c2fbf..e90bacb75c2 100644
--- a/noir_stdlib/src/hash/mimc.nr
+++ b/noir_stdlib/src/hash/mimc.nr
@@ -116,6 +116,7 @@ global MIMC_BN254_CONSTANTS: [Field; MIMC_BN254_ROUNDS] = [
 
 //mimc implementation with hardcoded parameters for BN254 curve.
 #[field(bn254)]
+#[no_predicates]
 pub fn mimc_bn254<N>(array: [Field; N]) -> Field {
     let exponent = 7;
     let mut r = 0;
diff --git a/noir_stdlib/src/hash/poseidon/bn254.nr b/noir_stdlib/src/hash/poseidon/bn254.nr
index 54f22884e29..9d3accb1ebd 100644
--- a/noir_stdlib/src/hash/poseidon/bn254.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254.nr
@@ -6,12 +6,14 @@ use crate::hash::poseidon::{PoseidonConfig, absorb};
 
 // Variable-length Poseidon-128 sponge as suggested in second bullet point of §3 of https://eprint.iacr.org/2019/458.pdf
 #[field(bn254)]
+#[no_predicates]
 pub fn sponge<N>(msg: [Field; N]) -> Field {
     absorb(consts::x5_5_config(), [0; 5], 4, 1, msg)[1]
 }
 
 // Various instances of the Poseidon hash function
 // Consistent with Circom's implementation
+#[no_predicates]
 pub fn hash_1(input: [Field; 1]) -> Field {
     let mut state = [0; 2];
     for i in 0..input.len() {
@@ -21,6 +23,7 @@ pub fn hash_1(input: [Field; 1]) -> Field {
     perm::x5_2(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_2(input: [Field; 2]) -> Field {
     let mut state = [0; 3];
     for i in 0..input.len() {
@@ -30,6 +33,7 @@ pub fn hash_2(input: [Field; 2]) -> Field {
     perm::x5_3(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_3(input: [Field; 3]) -> Field {
     let mut state = [0; 4];
     for i in 0..input.len() {
@@ -39,6 +43,7 @@ pub fn hash_3(input: [Field; 3]) -> Field {
     perm::x5_4(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_4(input: [Field; 4]) -> Field {
     let mut state = [0; 5];
     for i in 0..input.len() {
@@ -48,6 +53,7 @@ pub fn hash_4(input: [Field; 4]) -> Field {
     perm::x5_5(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_5(input: [Field; 5]) -> Field {
     let mut state = [0; 6];
     for i in 0..input.len() {
@@ -57,6 +63,7 @@ pub fn hash_5(input: [Field; 5]) -> Field {
     perm::x5_6(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_6(input: [Field; 6]) -> Field {
     let mut state = [0; 7];
     for i in 0..input.len() {
@@ -66,6 +73,7 @@ pub fn hash_6(input: [Field; 6]) -> Field {
     perm::x5_7(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_7(input: [Field; 7]) -> Field {
     let mut state = [0; 8];
     for i in 0..input.len() {
@@ -75,6 +83,7 @@ pub fn hash_7(input: [Field; 7]) -> Field {
     perm::x5_8(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_8(input: [Field; 8]) -> Field {
     let mut state = [0; 9];
     for i in 0..input.len() {
@@ -84,6 +93,7 @@ pub fn hash_8(input: [Field; 8]) -> Field {
     perm::x5_9(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_9(input: [Field; 9]) -> Field {
     let mut state = [0; 10];
     for i in 0..input.len() {
@@ -93,6 +103,7 @@ pub fn hash_9(input: [Field; 9]) -> Field {
     perm::x5_10(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_10(input: [Field; 10]) -> Field {
     let mut state = [0; 11];
     for i in 0..input.len() {
@@ -102,6 +113,7 @@ pub fn hash_10(input: [Field; 10]) -> Field {
     perm::x5_11(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_11(input: [Field; 11]) -> Field {
     let mut state = [0; 12];
     for i in 0..input.len() {
@@ -111,6 +123,7 @@ pub fn hash_11(input: [Field; 11]) -> Field {
     perm::x5_12(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_12(input: [Field; 12]) -> Field {
     let mut state = [0; 13];
     for i in 0..input.len() {
@@ -120,6 +133,7 @@ pub fn hash_12(input: [Field; 12]) -> Field {
     perm::x5_13(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_13(input: [Field; 13]) -> Field {
     let mut state = [0; 14];
     for i in 0..input.len() {
@@ -129,6 +143,7 @@ pub fn hash_13(input: [Field; 13]) -> Field {
     perm::x5_14(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_14(input: [Field; 14]) -> Field {
     let mut state = [0; 15];
     for i in 0..input.len() {
@@ -138,6 +153,7 @@ pub fn hash_14(input: [Field; 14]) -> Field {
     perm::x5_15(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_15(input: [Field; 15]) -> Field {
     let mut state = [0; 16];
     for i in 0..input.len() {
@@ -147,6 +163,7 @@ pub fn hash_15(input: [Field; 15]) -> Field {
     perm::x5_16(state)[0]
 }
 
+#[no_predicates]
 pub fn hash_16(input: [Field; 16]) -> Field {
     let mut state = [0; 17];
     for i in 0..input.len() {
diff --git a/noir_stdlib/src/sha256.nr b/noir_stdlib/src/sha256.nr
index d856043fcfa..6057876951d 100644
--- a/noir_stdlib/src/sha256.nr
+++ b/noir_stdlib/src/sha256.nr
@@ -38,6 +38,7 @@ fn hash_final_block(msg_block: [u8; 64], mut state: [u32; 8]) -> [u8; 32] {
 }
 
 // Variable size SHA-256 hash
+#[no_predicates]
 pub fn sha256_var<N>(msg: [u8; N], message_size: u64) -> [u8; 32] {
     let mut msg_block: [u8; 64] = [0; 64];
     let mut h: [u32; 8] = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]; // Intermediate hash, starting with the canonical initial value
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index 0f8ffcfcb1c..4e46840ebb7 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -87,6 +87,7 @@ fn msg_u8_to_u64(msg: [u8; 128]) -> [u64; 16] {
     msg64
 }
 // SHA-512 hash function
+#[no_predicates]
 pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
     let mut msg_block: [u8; 128] = [0; 128];
     // noir-fmt:ignore
diff --git a/test_programs/execution_success/regression_5252/Nargo.toml b/test_programs/execution_success/regression_5252/Nargo.toml
new file mode 100644
index 00000000000..855507dfaf3
--- /dev/null
+++ b/test_programs/execution_success/regression_5252/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_5252"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_5252/Prover.toml b/test_programs/execution_success/regression_5252/Prover.toml
new file mode 100644
index 00000000000..82776b4463d
--- /dev/null
+++ b/test_programs/execution_success/regression_5252/Prover.toml
@@ -0,0 +1,6 @@
+to_hash = [[1,5,9,2,24,563,3545,5,52,4244,43,2,7373567,2,286762,7,2457,24,2456,2456],
+[2234,2,26,27,24566,132452,3452456344567,657,45674657,4567467,45674,4567456,4567,23454,2345,2345345245,25252345,2435234524366,8678678,67867567],
+[9887575467567,5367367243617,46244567783,64673425,67456573456,4673457,46735,745674,6574,567456,7456,84,683,683,8368,38,32,16,7,98],
+#[465656,234324,4353,5245246,2567345674567,5634563456,7676474,4747,4567456746,56,4657456,4657,4567,46,7,8,98,87,76,57]
+]
+enable = [1,1,0]
diff --git a/test_programs/execution_success/regression_5252/src/main.nr b/test_programs/execution_success/regression_5252/src/main.nr
new file mode 100644
index 00000000000..315807c3396
--- /dev/null
+++ b/test_programs/execution_success/regression_5252/src/main.nr
@@ -0,0 +1,23 @@
+use dep::std::hash::{mimc, poseidon, poseidon2::Poseidon2};
+
+global NUM_HASHES = 3;
+global HASH_LENGTH = 20;
+
+pub fn poseidon_hash<N>(inputs: [Field; N]) -> Field {
+    Poseidon2::hash(inputs, inputs.len())
+}
+
+fn main(
+    to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
+    enable: [bool; NUM_HASHES]
+) -> pub [Field; NUM_HASHES] {
+    let mut result = [0; NUM_HASHES];
+    for i in 0..NUM_HASHES {
+        let enable = enable[i];
+        let to_hash = to_hash[i];
+        if enable {
+            result[i] = poseidon_hash(to_hash) + poseidon::bn254::sponge(to_hash) + mimc::mimc_bn254(to_hash);
+        }
+    }
+    result
+}

From c08799de12a7881f0a228f913ea0cbf15f74f2f1 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 17 Jun 2024 14:58:20 +0100
Subject: [PATCH 378/416] chore: replace `is_bn254` implementation to not rely
 on truncation of literals (#5247)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR updates the `is_bn254` function so we don't rely on the
footgun-y behaviour being reported in #4631 in order to determine the
field choice

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 noir_stdlib/src/compat.nr | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/noir_stdlib/src/compat.nr b/noir_stdlib/src/compat.nr
index 5d80c422c33..30b7f73f130 100644
--- a/noir_stdlib/src/compat.nr
+++ b/noir_stdlib/src/compat.nr
@@ -1,4 +1,18 @@
+global BN254_MODULUS_BE_BYTES: [u8; 32] = [
+    48, 100, 78, 114, 225, 49, 160, 41, 184, 80, 69, 182, 129, 129, 88, 93, 40, 51, 232, 72, 121, 185, 112, 145, 67, 225, 245, 147, 240, 0, 0, 1
+];
+
 pub fn is_bn254() -> bool {
-    // bn254 truncates its curve order to 0
-    21888242871839275222246405745257275088548364400416034343698204186575808495617 == 0
+    // TODO: refactor this once https://github.com/noir-lang/noir/issues/5245 is resolved.
+    let modulus_bytes = crate::field::modulus_be_bytes();
+    if modulus_bytes.len() == 32 {
+        let mut modulus_bytes_array: [u8; 32] = [0; 32];
+        for i in 0..32 {
+            modulus_bytes_array[i] = modulus_bytes[i];
+        }
+
+        modulus_bytes_array == BN254_MODULUS_BE_BYTES
+    } else {
+        false
+    }
 }

From 7de19f5856591203271836f07154abae13f5102b Mon Sep 17 00:00:00 2001
From: Aztec Bot <49558828+AztecBot@users.noreply.github.com>
Date: Mon, 17 Jun 2024 13:31:28 -0400
Subject: [PATCH 379/416] feat: Sync from aztec-packages (#5242)

Automated pull of Noir development from
[aztec-packages](https://github.com/AztecProtocol/aztec-packages).
BEGIN_COMMIT_OVERRIDE
feat: Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6986)
feat: `pxe.addNullifiedNote(...)`
(https://github.com/AztecProtocol/aztec-packages/pull/6948)
END_COMMIT_OVERRIDE

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 .aztec-sync-commit                            |  2 +-
 aztec_macros/src/lib.rs                       |  4 +-
 ...e_note_hash_and_optionally_a_nullifier.rs} | 54 ++++++++++---------
 aztec_macros/src/transforms/mod.rs            |  2 +-
 aztec_macros/src/utils/errors.rs              |  6 +--
 compiler/integration-tests/package.json       |  2 +-
 .../test/node/prove_and_verify.test.ts        | 36 ++++++-------
 .../src/hir/comptime/interpreter.rs           | 15 ++++--
 .../noirc_frontend/src/hir/comptime/scan.rs   |  1 -
 compiler/noirc_frontend/src/hir_def/types.rs  |  4 ++
 .../benchmarks/bench_sha256/Nargo.toml        |  7 ---
 .../noirc_abi_wasm/test/shared/abi_encode.ts  |  2 -
 .../test/shared/array_as_field.ts             |  2 -
 .../test/shared/decode_error.ts               |  2 -
 .../test/shared/field_as_array.ts             |  2 -
 tooling/noirc_abi_wasm/test/shared/structs.ts |  6 ---
 .../test/shared/uint_overflow.ts              |  2 -
 17 files changed, 67 insertions(+), 82 deletions(-)
 rename aztec_macros/src/transforms/{compute_note_hash_and_nullifier.rs => compute_note_hash_and_optionally_a_nullifier.rs} (80%)
 delete mode 100644 test_programs/benchmarks/bench_sha256/Nargo.toml

diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 0bdea76121d..bdaabc69727 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-86a33140f9a65e518003b3f4c60f97d132f85b89
+12af650f0d27c37dca06bb329bf76a5574534d78
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index 2daf86dc643..a36b7b17d09 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -3,7 +3,7 @@ mod utils;
 
 use noirc_errors::Location;
 use transforms::{
-    compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
+    compute_note_hash_and_optionally_a_nullifier::inject_compute_note_hash_and_optionally_a_nullifier,
     contract_interface::{
         generate_contract_interface, stub_function, update_fn_signatures_in_contract_interface,
     },
@@ -236,7 +236,7 @@ fn transform_hir(
 ) -> Result<(), (AztecMacroError, FileId)> {
     if has_aztec_dependency(crate_id, context) {
         transform_events(crate_id, context)?;
-        inject_compute_note_hash_and_nullifier(crate_id, context)?;
+        inject_compute_note_hash_and_optionally_a_nullifier(crate_id, context)?;
         assign_storage_slots(crate_id, context)?;
         inject_note_exports(crate_id, context)?;
         update_fn_signatures_in_contract_interface(crate_id, context)
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs
similarity index 80%
rename from aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
rename to aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs
index f624cde9969..30c0f63a2d4 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs
@@ -14,16 +14,16 @@ use crate::utils::{
     },
 };
 
-// Check if "compute_note_hash_and_nullifier(AztecAddress,Field,Field,Field,[Field; N]) -> [Field; 4]" is defined
-fn check_for_compute_note_hash_and_nullifier_definition(
+// Check if "compute_note_hash_and_optionally_a_nullifier(AztecAddress,Field,Field,Field,bool,[Field; N]) -> [Field; 4]" is defined
+fn check_for_compute_note_hash_and_optionally_a_nullifier_definition(
     crate_id: &CrateId,
     context: &HirContext,
 ) -> bool {
     collect_crate_functions(crate_id, context).iter().any(|funct_id| {
         let func_data = context.def_interner.function_meta(funct_id);
         let func_name = context.def_interner.function_name(funct_id);
-        func_name == "compute_note_hash_and_nullifier"
-                && func_data.parameters.len() == 5
+        func_name == "compute_note_hash_and_optionally_a_nullifier"
+                && func_data.parameters.len() == 6
                 && func_data.parameters.0.first().is_some_and(| (_, typ, _) | match typ {
                     Type::Struct(struct_typ, _) => struct_typ.borrow().name.0.contents == "AztecAddress",
                     _ => false
@@ -31,8 +31,9 @@ fn check_for_compute_note_hash_and_nullifier_definition(
                 && func_data.parameters.0.get(1).is_some_and(|(_, typ, _)| typ.is_field())
                 && func_data.parameters.0.get(2).is_some_and(|(_, typ, _)| typ.is_field())
                 && func_data.parameters.0.get(3).is_some_and(|(_, typ, _)|  typ.is_field())
-                // checks if the 5th parameter is an array and contains only fields
-                && func_data.parameters.0.get(4).is_some_and(|(_, typ, _)|  match typ {
+                && func_data.parameters.0.get(4).is_some_and(|(_, typ, _)|  typ.is_bool())
+                // checks if the 6th parameter is an array and contains only fields
+                && func_data.parameters.0.get(5).is_some_and(|(_, typ, _)|  match typ {
                     Type::Array(_, inner_type) => inner_type.to_owned().is_field(),
                     _ => false
                 })
@@ -49,16 +50,16 @@ fn check_for_compute_note_hash_and_nullifier_definition(
     })
 }
 
-pub fn inject_compute_note_hash_and_nullifier(
+pub fn inject_compute_note_hash_and_optionally_a_nullifier(
     crate_id: &CrateId,
     context: &mut HirContext,
 ) -> Result<(), (AztecMacroError, FileId)> {
     if let Some((_, module_id, file_id)) = get_contract_module_data(context, crate_id) {
-        // If compute_note_hash_and_nullifier is already defined by the user, we skip auto-generation in order to provide an
+        // If compute_note_hash_and_optionally_a_nullifier is already defined by the user, we skip auto-generation in order to provide an
         // escape hatch for this mechanism.
         // TODO(#4647): improve this diagnosis and error messaging.
         if context.crate_graph.root_crate_id() != crate_id
-            || check_for_compute_note_hash_and_nullifier_definition(crate_id, context)
+            || check_for_compute_note_hash_and_optionally_a_nullifier_definition(crate_id, context)
         {
             return Ok(());
         }
@@ -69,14 +70,14 @@ pub fn inject_compute_note_hash_and_nullifier(
         let max_note_length_const = get_global_numberic_const(context, "MAX_NOTE_FIELDS_LENGTH")
             .map_err(|err| {
                 (
-                    AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                    AztecMacroError::CouldNotImplementComputeNoteHashAndOptionallyANullifier {
                         secondary_message: Some(err.primary_message),
                     },
                     file_id,
                 )
             })?;
 
-        // In order to implement compute_note_hash_and_nullifier, we need to know all of the different note types the
+        // In order to implement compute_note_hash_and_optionally_a_nullifier, we need to know all of the different note types the
         // contract might use and their serialized lengths. These are the types that are marked as #[aztec(note)].
         let mut notes_and_lengths = vec![];
 
@@ -89,7 +90,7 @@ pub fn inject_compute_note_hash_and_nullifier(
             )
             .map_err(|_err| {
                 (
-                    AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                    AztecMacroError::CouldNotImplementComputeNoteHashAndOptionallyANullifier {
                         secondary_message: Some(format!(
                             "Failed to get serialized length for note type {}",
                             path
@@ -102,7 +103,7 @@ pub fn inject_compute_note_hash_and_nullifier(
 
             if serialized_len > max_note_length_const {
                 return Err((
-                   AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                   AztecMacroError::CouldNotImplementComputeNoteHashAndOptionallyANullifier {
                         secondary_message: Some(format!(
                             "Note type {} as {} fields, which is more than the maximum allowed length of {}.",
                             path,
@@ -120,11 +121,12 @@ pub fn inject_compute_note_hash_and_nullifier(
         let max_note_length: u128 =
             *notes_and_lengths.iter().map(|(_, serialized_len)| serialized_len).max().unwrap_or(&0);
 
-        let note_types =
+        let note_types: Vec<String> =
             notes_and_lengths.iter().map(|(note_type, _)| note_type.clone()).collect::<Vec<_>>();
 
-        // We can now generate a version of compute_note_hash_and_nullifier tailored for the contract in this crate.
-        let func = generate_compute_note_hash_and_nullifier(&note_types, max_note_length);
+        // We can now generate a version of compute_note_hash_and_optionally_a_nullifier tailored for the contract in this crate.
+        let func =
+            generate_compute_note_hash_and_optionally_a_nullifier(&note_types, max_note_length);
 
         // And inject the newly created function into the contract.
 
@@ -134,7 +136,7 @@ pub fn inject_compute_note_hash_and_nullifier(
 
         inject_fn(crate_id, context, func, location, module_id, file_id).map_err(|err| {
             (
-                AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier {
+                AztecMacroError::CouldNotImplementComputeNoteHashAndOptionallyANullifier {
                     secondary_message: err.secondary_message,
                 },
                 file_id,
@@ -144,12 +146,12 @@ pub fn inject_compute_note_hash_and_nullifier(
     Ok(())
 }
 
-fn generate_compute_note_hash_and_nullifier(
+fn generate_compute_note_hash_and_optionally_a_nullifier(
     note_types: &[String],
     max_note_length: u128,
 ) -> NoirFunction {
     let function_source =
-        generate_compute_note_hash_and_nullifier_source(note_types, max_note_length);
+        generate_compute_note_hash_and_optionally_a_nullifier_source(note_types, max_note_length);
 
     let (function_ast, errors) = parse_program(&function_source);
     if !errors.is_empty() {
@@ -161,7 +163,7 @@ fn generate_compute_note_hash_and_nullifier(
     function_ast.functions.remove(0)
 }
 
-fn generate_compute_note_hash_and_nullifier_source(
+fn generate_compute_note_hash_and_optionally_a_nullifier_source(
     note_types: &[String],
     max_note_length: u128,
 ) -> String {
@@ -173,12 +175,13 @@ fn generate_compute_note_hash_and_nullifier_source(
         // so we include a dummy version.
         format!(
             "
-        unconstrained fn compute_note_hash_and_nullifier(
+        unconstrained fn compute_note_hash_and_optionally_a_nullifier(
             contract_address: dep::aztec::protocol_types::address::AztecAddress,
             nonce: Field,
             storage_slot: Field,
             note_type_id: Field,
-            serialized_note: [Field; {}]
+            compute_nullifier: bool,
+            serialized_note: [Field; {}],
         ) -> pub [Field; 4] {{
             assert(false, \"This contract does not use private notes\");
             [0, 0, 0, 0]
@@ -191,7 +194,7 @@ fn generate_compute_note_hash_and_nullifier_source(
 
         let if_statements: Vec<String> = note_types.iter().map(|note_type| format!(
             "if (note_type_id == {0}::get_note_type_id()) {{
-                dep::aztec::note::utils::compute_note_hash_and_nullifier({0}::deserialize_content, note_header, serialized_note)
+                dep::aztec::note::utils::compute_note_hash_and_optionally_a_nullifier({0}::deserialize_content, note_header, compute_nullifier, serialized_note)
             }}"
         , note_type)).collect();
 
@@ -204,12 +207,13 @@ fn generate_compute_note_hash_and_nullifier_source(
 
         format!(
             "
-            unconstrained fn compute_note_hash_and_nullifier(
+            unconstrained fn compute_note_hash_and_optionally_a_nullifier(
                 contract_address: dep::aztec::protocol_types::address::AztecAddress,
                 nonce: Field,
                 storage_slot: Field,
                 note_type_id: Field,
-                serialized_note: [Field; {}]
+                compute_nullifier: bool,
+                serialized_note: [Field; {}],
             ) -> pub [Field; 4] {{
                 let note_header = dep::aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
 
diff --git a/aztec_macros/src/transforms/mod.rs b/aztec_macros/src/transforms/mod.rs
index 2a6fef7647f..bd419bced6f 100644
--- a/aztec_macros/src/transforms/mod.rs
+++ b/aztec_macros/src/transforms/mod.rs
@@ -1,4 +1,4 @@
-pub mod compute_note_hash_and_nullifier;
+pub mod compute_note_hash_and_optionally_a_nullifier;
 pub mod contract_interface;
 pub mod events;
 pub mod functions;
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 51aea3d052f..852b5f1e57a 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -12,7 +12,7 @@ pub enum AztecMacroError {
     UnsupportedFunctionReturnType { span: Span, typ: ast::UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: ast::UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
-    CouldNotImplementComputeNoteHashAndNullifier { secondary_message: Option<String> },
+    CouldNotImplementComputeNoteHashAndOptionallyANullifier { secondary_message: Option<String> },
     CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
     MultipleStorageDefinitions { span: Option<Span> },
     CouldNotExportStorageLayout { span: Option<Span>, secondary_message: Option<String> },
@@ -57,8 +57,8 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span: None,
             },
-            AztecMacroError::CouldNotImplementComputeNoteHashAndNullifier { secondary_message } => MacroError {
-                primary_message: "Could not implement compute_note_hash_and_nullifier automatically, please provide an implementation".to_string(),
+            AztecMacroError::CouldNotImplementComputeNoteHashAndOptionallyANullifier { secondary_message } => MacroError {
+                primary_message: "Could not implement compute_note_hash_and_optionally_a_nullifier automatically, please provide an implementation".to_string(),
                 secondary_message,
                 span: None,
             },
diff --git a/compiler/integration-tests/package.json b/compiler/integration-tests/package.json
index b789f1f05ce..0638fffe547 100644
--- a/compiler/integration-tests/package.json
+++ b/compiler/integration-tests/package.json
@@ -6,7 +6,7 @@
     "scripts": {
         "build": "echo Integration Test build step",
         "test": "yarn test:browser && yarn test:node",
-        "test:node": "bash ./scripts/setup.sh && hardhat test test/node/**/*",
+        "test:node": "bash ./scripts/setup.sh && hardhat test test/node/prove_and_verify.test.ts && hardhat test test/node/smart_contract_verifier.test.ts && hardhat test test/node/onchain_recursive_verification.test.ts",
         "test:browser": "web-test-runner",
         "test:integration:browser": "web-test-runner test/browser/**/*.test.ts",
         "test:integration:browser:watch": "web-test-runner test/browser/**/*.test.ts --watch",
diff --git a/compiler/integration-tests/test/node/prove_and_verify.test.ts b/compiler/integration-tests/test/node/prove_and_verify.test.ts
index 15d39436a3b..699dcf5e918 100644
--- a/compiler/integration-tests/test/node/prove_and_verify.test.ts
+++ b/compiler/integration-tests/test/node/prove_and_verify.test.ts
@@ -8,6 +8,8 @@ import { CompiledCircuit } from '@noir-lang/types';
 const assert_lt_program = assert_lt_json as CompiledCircuit;
 const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
+const backend = new Backend(assert_lt_program);
+
 it('end-to-end proof creation and verification (outer)', async () => {
   // Noir.Js part
   const inputs = {
@@ -22,11 +24,10 @@ it('end-to-end proof creation and verification (outer)', async () => {
   // bb.js part
   //
   // Proof creation
-  const prover = new Backend(assert_lt_program);
-  const proof = await prover.generateProof(witness);
+  const proof = await backend.generateProof(witness);
 
   // Proof verification
-  const isValid = await prover.verifyProof(proof);
+  const isValid = await backend.verifyProof(proof);
   expect(isValid).to.be.true;
 });
 
@@ -42,10 +43,9 @@ it('end-to-end proof creation and verification (outer) -- Verifier API', async (
   const { witness } = await program.execute(inputs);
 
   // Generate proof
-  const prover = new Backend(assert_lt_program);
-  const proof = await prover.generateProof(witness);
+  const proof = await backend.generateProof(witness);
 
-  const verificationKey = await prover.getVerificationKey();
+  const verificationKey = await backend.getVerificationKey();
 
   // Proof verification
   const verifier = new Verifier();
@@ -68,11 +68,10 @@ it('end-to-end proof creation and verification (inner)', async () => {
   // bb.js part
   //
   // Proof creation
-  const prover = new Backend(assert_lt_program);
-  const proof = await prover.generateProof(witness);
+  const proof = await backend.generateProof(witness);
 
   // Proof verification
-  const isValid = await prover.verifyProof(proof);
+  const isValid = await backend.verifyProof(proof);
   expect(isValid).to.be.true;
 });
 
@@ -88,9 +87,7 @@ it('end-to-end proving and verification with different instances', async () => {
   const { witness } = await program.execute(inputs);
 
   // bb.js part
-  const prover = new Backend(assert_lt_program);
-
-  const proof = await prover.generateProof(witness);
+  const proof = await backend.generateProof(witness);
 
   const verifier = new Backend(assert_lt_program);
   const proof_is_valid = await verifier.verifyProof(proof);
@@ -119,18 +116,17 @@ it('[BUG] -- bb.js null function or function signature mismatch (outer-inner) ',
   //
   // Proof creation
   //
-  const prover = new Backend(assert_lt_program);
   // Create a proof using both proving systems, the majority of the time
   // one would only use outer proofs.
-  const proofOuter = await prover.generateProof(witness);
-  const _proofInner = await prover.generateProof(witness);
+  const proofOuter = await backend.generateProof(witness);
+  const _proofInner = await backend.generateProof(witness);
 
   // Proof verification
   //
-  const isValidOuter = await prover.verifyProof(proofOuter);
+  const isValidOuter = await backend.verifyProof(proofOuter);
   expect(isValidOuter).to.be.true;
   // We can also try verifying an inner proof and it will fail.
-  const isValidInner = await prover.verifyProof(_proofInner);
+  const isValidInner = await backend.verifyProof(_proofInner);
   expect(isValidInner).to.be.true;
 });
 
@@ -147,10 +143,10 @@ it('end-to-end proof creation and verification for multiple ACIR circuits (inner
   // bb.js part
   //
   // Proof creation
-  const prover = new Backend(fold_fibonacci_program);
-  const proof = await prover.generateProof(witness);
+  const backend = new Backend(fold_fibonacci_program);
+  const proof = await backend.generateProof(witness);
 
   // Proof verification
-  const isValid = await prover.verifyProof(proof);
+  const isValid = await backend.verifyProof(proof);
   expect(isValid).to.be.true;
 });
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 8cb0db3ee55..3648881e501 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -154,8 +154,8 @@ impl<'a> Interpreter<'a> {
         let mut scope = Vec::new();
         if self.scopes.len() > 1 {
             scope = self.scopes.drain(1..).collect();
-            self.push_scope();
         }
+        self.push_scope();
         (std::mem::take(&mut self.in_loop), scope)
     }
 
@@ -210,10 +210,11 @@ impl<'a> Interpreter<'a> {
                 }
             },
             HirPattern::Struct(struct_type, pattern_fields, _) => {
+                self.push_scope();
                 self.type_check(typ, &argument, location)?;
                 self.type_check(struct_type, &argument, location)?;
 
-                match argument {
+                let res = match argument {
                     Value::Struct(fields, struct_type) if fields.len() == pattern_fields.len() => {
                         for (field_name, field_pattern) in pattern_fields {
                             let field = fields.get(&field_name.0.contents).ok_or_else(|| {
@@ -239,7 +240,9 @@ impl<'a> Interpreter<'a> {
                         value,
                         location,
                     }),
-                }
+                };
+                self.pop_scope();
+                res
             }
         }
     }
@@ -358,13 +361,14 @@ impl<'a> Interpreter<'a> {
             }
             DefinitionKind::Local(_) => self.lookup(&ident),
             DefinitionKind::Global(global_id) => {
-                // Don't need to check let_.comptime, we can evaluate non-comptime globals too.
                 // Avoid resetting the value if it is already known
                 if let Ok(value) = self.lookup(&ident) {
                     Ok(value)
                 } else {
                     let let_ = self.interner.get_global_let_statement(*global_id).unwrap();
-                    self.evaluate_let(let_)?;
+                    if let_.comptime {
+                        self.evaluate_let(let_.clone())?;
+                    }
                     self.lookup(&ident)
                 }
             }
@@ -1296,6 +1300,7 @@ impl<'a> Interpreter<'a> {
                 Err(InterpreterError::Continue) => continue,
                 Err(other) => return Err(other),
             }
+
             self.pop_scope();
         }
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index 02010b6886d..f2e21e608ea 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -59,7 +59,6 @@ impl<'interner> Interpreter<'interner> {
                 self.scan_expression(let_.expression)?;
             }
         }
-
         Ok(())
     }
 
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index f5c90b33c11..a90bd931496 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -598,6 +598,10 @@ impl Type {
         matches!(self.follow_bindings(), Type::FieldElement)
     }
 
+    pub fn is_bool(&self) -> bool {
+        matches!(self.follow_bindings(), Type::Bool)
+    }
+
     pub fn is_signed(&self) -> bool {
         matches!(self.follow_bindings(), Type::Integer(Signedness::Signed, _))
     }
diff --git a/test_programs/benchmarks/bench_sha256/Nargo.toml b/test_programs/benchmarks/bench_sha256/Nargo.toml
deleted file mode 100644
index 488b94ca858..00000000000
--- a/test_programs/benchmarks/bench_sha256/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "bench_sha256"
-version = "0.1.0"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/tooling/noirc_abi_wasm/test/shared/abi_encode.ts b/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
index f4ab8175700..62eb7658f43 100644
--- a/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
+++ b/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
@@ -9,9 +9,7 @@ export const abi: Abi = {
       visibility: 'private',
     },
   ],
-  param_witnesses: { foo: [{ start: 1, end: 2 }], bar: [{ start: 2, end: 4 }] },
   return_type: null,
-  return_witnesses: [],
   error_types: {},
 };
 
diff --git a/tooling/noirc_abi_wasm/test/shared/array_as_field.ts b/tooling/noirc_abi_wasm/test/shared/array_as_field.ts
index 3698b913c66..8fecacf79f8 100644
--- a/tooling/noirc_abi_wasm/test/shared/array_as_field.ts
+++ b/tooling/noirc_abi_wasm/test/shared/array_as_field.ts
@@ -8,9 +8,7 @@ export const abi: Abi = {
       visibility: 'private',
     },
   ],
-  param_witnesses: { foo: [{ start: 1, end: 3 }] },
   return_type: null,
-  return_witnesses: [],
   error_types: {},
 };
 
diff --git a/tooling/noirc_abi_wasm/test/shared/decode_error.ts b/tooling/noirc_abi_wasm/test/shared/decode_error.ts
index 36eb18b5210..662e0acb416 100644
--- a/tooling/noirc_abi_wasm/test/shared/decode_error.ts
+++ b/tooling/noirc_abi_wasm/test/shared/decode_error.ts
@@ -15,9 +15,7 @@ export const abi: Abi = {
       visibility: 'private',
     },
   ],
-  param_witnesses: { foo: [{ start: 1, end: 3 }] },
   return_type: null,
-  return_witnesses: [],
   error_types: {
     [FAKE_FIELD_SELECTOR]: {
       error_kind: 'custom',
diff --git a/tooling/noirc_abi_wasm/test/shared/field_as_array.ts b/tooling/noirc_abi_wasm/test/shared/field_as_array.ts
index 4e3e2fd12a8..3610c51e6db 100644
--- a/tooling/noirc_abi_wasm/test/shared/field_as_array.ts
+++ b/tooling/noirc_abi_wasm/test/shared/field_as_array.ts
@@ -8,9 +8,7 @@ export const abi: Abi = {
       visibility: 'private',
     },
   ],
-  param_witnesses: { foo: [{ start: 1, end: 3 }] },
   return_type: null,
-  return_witnesses: [],
   error_types: {},
 };
 
diff --git a/tooling/noirc_abi_wasm/test/shared/structs.ts b/tooling/noirc_abi_wasm/test/shared/structs.ts
index ee666e40e87..6d098832b3a 100644
--- a/tooling/noirc_abi_wasm/test/shared/structs.ts
+++ b/tooling/noirc_abi_wasm/test/shared/structs.ts
@@ -47,13 +47,7 @@ export const abi: Abi = {
       visibility: 'private',
     },
   ],
-  param_witnesses: {
-    struct_arg: [{ start: 1, end: 2 }],
-    struct_array_arg: [{ start: 2, end: 5 }],
-    nested_struct_arg: [{ start: 5, end: 6 }],
-  },
   return_type: null,
-  return_witnesses: [],
   error_types: {},
 };
 
diff --git a/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts b/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts
index 82a3e3998ca..b7f1f221b48 100644
--- a/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts
+++ b/tooling/noirc_abi_wasm/test/shared/uint_overflow.ts
@@ -8,9 +8,7 @@ export const abi: Abi = {
       visibility: 'private',
     },
   ],
-  param_witnesses: { foo: [{ start: 1, end: 2 }] },
   return_type: null,
-  return_witnesses: [],
   error_types: {},
 };
 

From d6d0ae26d2fef083dc240539b834d934c84b0326 Mon Sep 17 00:00:00 2001
From: Michael J Klein <michaeljklein@users.noreply.github.com>
Date: Mon, 17 Jun 2024 14:00:31 -0400
Subject: [PATCH 380/416] feat!: remove `dep::` prefix (#4946)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/2307

## Summary\*

`dep::` is unnecessary to distinguish between internal and external
crates, so this PR removes it.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: Tom French <tom@tomfren.ch>
---
 ...te_note_hash_and_optionally_a_nullifier.rs |  8 ++--
 .../src/transforms/contract_interface.rs      | 29 ++++++-----
 aztec_macros/src/transforms/note_interface.rs | 20 +++-----
 aztec_macros/src/transforms/storage.rs        |  4 +-
 aztec_macros/src/utils/ast_utils.rs           |  2 +-
 .../circuits/assert_lt/src/main.nr            |  3 --
 .../circuits/recursion/src/main.nr            |  2 -
 compiler/noirc_frontend/src/debug/mod.rs      |  2 +-
 .../src/hir/def_collector/dc_crate.rs         |  4 +-
 .../src/hir/resolution/import.rs              | 48 +++++++++++++++----
 .../noirc_frontend/src/noir_parser.lalrpop    |  2 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  2 +-
 .../noirc_frontend/src/parser/parser/path.rs  |  9 ++--
 .../wasm/test/fixtures/deps/lib-a/src/lib.nr  |  2 +-
 .../fixtures/deps/lib-c/src/module/foo.nr     |  2 +-
 .../test/fixtures/noir-contract/src/main.nr   |  2 +-
 .../wasm/test/fixtures/with-deps/src/main.nr  |  2 +-
 docs/docs/how_to/merkle-proof.mdx             |  1 -
 .../docs/noir/concepts/data_types/integers.md |  1 -
 docs/docs/noir/concepts/data_types/slices.mdx |  4 +-
 docs/docs/noir/concepts/data_types/strings.md |  1 -
 docs/docs/noir/concepts/traits.md             |  4 +-
 .../modules_packages_crates/dependencies.md   | 12 ++---
 .../standard_library/containers/hashmap.md    |  2 +-
 .../cryptographic_primitives/ec_primitives.md |  2 +-
 .../cryptographic_primitives/eddsa.mdx        |  2 +-
 docs/docs/noir/standard_library/recursion.md  |  1 -
 examples/recursion/recurse_leaf/src/main.nr   |  4 +-
 examples/recursion/recurse_node/src/main.nr   |  4 +-
 .../bench_eddsa_poseidon/src/main.nr          |  4 +-
 .../bench_poseidon_hash/src/main.nr           |  2 +-
 .../bench_poseidon_hash_100/src/main.nr       |  4 +-
 .../bench_poseidon_hash_30/src/main.nr        |  4 +-
 .../benchmarks/bench_sha256_100/src/main.nr   |  4 +-
 .../benchmarks/bench_sha256_30/src/main.nr    |  4 +-
 .../array_length_defaulting/src/main.nr       |  2 +-
 .../assert_constant_fail/src/main.nr          |  2 +-
 .../brillig_nested_slices/src/main.nr         |  2 +-
 .../dep_impl_primitive/src/main.nr            |  2 +-
 .../dep_submodule_overlap/Nargo.toml          |  8 ++++
 .../dep_submodule_overlap/src/lib.nr          |  3 ++
 .../dep_submodule_overlap/src/main.nr         |  9 ++++
 .../compile_failure/depend_on_bin/src/main.nr |  2 +-
 .../negate_unsigned/src/main.nr               |  2 -
 .../orphaned_trait_impl/src/main.nr           |  2 +-
 .../overlapping_dep_and_mod/Nargo.toml        |  6 +++
 .../overlapping_dep_and_mod/bin/Nargo.toml    |  8 ++++
 .../overlapping_dep_and_mod/bin/Prover.toml   |  0
 .../overlapping_dep_and_mod/bin/src/main.nr   | 12 +++++
 .../overlapping_dep_and_mod/foo/Nargo.toml    |  7 +++
 .../overlapping_dep_and_mod/foo/src/lib.nr    |  3 ++
 .../restricted_bit_sizes/src/main.nr          |  2 +-
 .../turbofish_generic_count/src/main.nr       |  3 +-
 .../src/main.nr                               |  2 -
 .../ec_baby_jubjub/src/main.nr                | 16 +++----
 .../intrinsic_die/src/main.nr                 |  1 -
 .../method_call_regression/src/main.nr        |  2 -
 .../overlapping_dep_and_mod/Nargo.toml        |  6 +++
 .../overlapping_dep_and_mod/bin/Nargo.toml    |  8 ++++
 .../overlapping_dep_and_mod/bin/src/main.nr   |  9 ++++
 .../overlapping_dep_and_mod/foo/Nargo.toml    |  7 +++
 .../overlapping_dep_and_mod/foo/src/lib.nr    |  5 ++
 .../reexports/src/main.nr                     |  2 +-
 .../regression_2099/src/main.nr               | 16 +++----
 .../regression_3635/src/main.nr               |  2 -
 .../str_as_bytes/src/main.nr                  |  1 -
 .../trait_default_implementation/src/main.nr  |  2 -
 .../trait_override_implementation/src/main.nr |  2 -
 .../compile_success_empty/traits/src/main.nr  |  2 -
 .../compile_success_empty/vectors/src/main.nr |  2 +-
 .../workspace_reexport_bug/binary/src/main.nr |  2 +-
 .../workspace_reexport_bug/library/src/lib.nr |  2 +-
 .../div_by_zero_constants/src/main.nr         |  2 -
 .../div_by_zero_numerator_witness/src/main.nr |  2 -
 .../div_by_zero_witness/src/main.nr           |  1 -
 .../hashmap_load_factor/src/main.nr           |  6 +--
 .../execution_success/4_sub/src/main.nr       |  1 -
 .../execution_success/5_over/src/main.nr      |  1 -
 test_programs/execution_success/6/src/main.nr |  1 -
 .../execution_success/6_array/src/main.nr     |  1 -
 test_programs/execution_success/7/src/main.nr |  1 -
 .../aes128_encrypt/src/main.nr                |  2 -
 .../array_dynamic_blackbox_input/src/main.nr  |  2 +-
 .../src/main.nr                               |  2 +-
 .../execution_success/bigint/src/main.nr      | 10 ++--
 .../execution_success/blake3/src/main.nr      |  2 -
 .../brillig_blake2s/src/main.nr               |  1 -
 .../brillig_blake3/src/main.nr                |  2 -
 .../src/main.nr                               |  4 +-
 .../brillig_cow_regression/src/main.nr        |  4 +-
 .../brillig_ecdsa_secp256k1/src/main.nr       |  1 -
 .../brillig_ecdsa_secp256r1/src/main.nr       |  1 -
 .../brillig_fns_as_values/src/main.nr         |  2 -
 .../brillig_hash_to_field/src/main.nr         |  1 -
 .../brillig_keccak/src/main.nr                |  1 -
 .../brillig_oracle/src/main.nr                |  4 +-
 .../brillig_pedersen/src/main.nr              |  2 -
 .../brillig_sha256/src/main.nr                |  1 -
 .../brillig_slices/src/main.nr                |  2 +-
 .../conditional_1/src/main.nr                 |  2 -
 .../conditional_2/src/main.nr                 |  2 -
 .../src/main.nr                               |  2 -
 .../execution_success/databus/src/main.nr     |  2 -
 .../diamond_deps_0/src/main.nr                |  6 +--
 .../double_verify_nested_proof/src/main.nr    |  1 -
 .../double_verify_proof/src/main.nr           |  1 -
 .../double_verify_proof_recursive/src/main.nr |  1 -
 .../ecdsa_secp256k1/src/main.nr               |  2 -
 .../ecdsa_secp256r1/src/main.nr               |  2 -
 .../ecdsa_secp256r1_3x/src/main.nr            |  2 -
 .../execution_success/eddsa/src/main.nr       | 12 ++---
 .../embedded_curve_ops/src/main.nr            |  2 -
 .../fold_numeric_generic_poseidon/src/main.nr |  2 +-
 .../execution_success/generics/src/main.nr    |  2 +-
 .../hash_to_field/src/main.nr                 |  2 -
 .../execution_success/hashmap/src/main.nr     |  8 ++--
 .../execution_success/import/src/main.nr      |  2 +-
 .../is_unconstrained/src/main.nr              |  2 +-
 .../execution_success/keccak256/src/main.nr   |  1 -
 .../merkle_insert/src/main.nr                 |  3 +-
 .../execution_success/modulus/src/main.nr     |  2 -
 .../src/main.nr                               |  2 +-
 .../operator_overloading/src/main.nr          |  4 +-
 .../overlapping_dep_and_mod/Nargo.toml        |  6 +++
 .../overlapping_dep_and_mod/bin/Nargo.toml    |  8 ++++
 .../overlapping_dep_and_mod/bin/Prover.toml   |  0
 .../overlapping_dep_and_mod/bin/src/main.nr   | 14 ++++++
 .../overlapping_dep_and_mod/foo/Nargo.toml    |  7 +++
 .../overlapping_dep_and_mod/foo/src/lib.nr    |  5 ++
 .../pedersen_check/src/main.nr                |  2 -
 .../pedersen_commitment/src/main.nr           |  1 -
 .../pedersen_hash/src/main.nr                 |  1 -
 .../poseidon_bn254_hash/src/main.nr           |  4 +-
 .../poseidonsponge_x5_254/src/main.nr         |  2 +-
 .../execution_success/prelude/src/main.nr     |  4 +-
 .../regression_3051/src/main.nr               |  4 +-
 .../regression_3394/src/main.nr               |  2 -
 .../regression_4124/src/main.nr               |  4 +-
 .../regression_4449/src/main.nr               |  1 -
 .../regression_5045/src/main.nr               |  6 +--
 .../regression_5202/src/main.nr               |  2 +-
 .../regression_5252/src/main.nr               |  2 +-
 .../src/main.nr                               |  1 -
 .../execution_success/schnorr/src/main.nr     | 15 ++----
 .../execution_success/sha256/src/main.nr      |  1 -
 .../execution_success/sha2_byte/src/main.nr   |  1 -
 .../signed_comparison/src/main.nr             |  2 -
 .../signed_division/src/main.nr               |  1 -
 .../simple_print/src/main.nr                  |  1 -
 .../simple_shield/src/main.nr                 |  2 -
 .../slice_coercion/src/main.nr                |  2 +-
 .../execution_success/slices/src/main.nr      |  3 +-
 .../execution_success/strings/src/main.nr     |  1 -
 .../execution_success/to_bits/src/main.nr     |  2 -
 .../to_bytes_integration/src/main.nr          |  2 -
 .../trait_method_mut_self/src/main.nr         |  4 +-
 .../traits_in_crates_1/crate1/src/lib.nr      |  2 +-
 .../traits_in_crates_1/src/main.nr            |  2 +-
 .../traits_in_crates_2/crate2/src/lib.nr      |  2 +-
 .../traits_in_crates_2/src/main.nr            |  2 +-
 .../src/main.nr                               |  6 +--
 .../execution_success/u128/src/main.nr        |  2 -
 .../execution_success/unit_value/src/main.nr  |  2 +-
 .../wrapping_operations/src/main.nr           |  2 -
 test_programs/format.sh                       |  2 +-
 .../should_fail_mismatch/src/main.nr          |  2 +-
 .../brillig_overflow_checks/src/main.nr       |  2 +-
 .../embedded_curve_ops/src/main.nr            |  2 +-
 .../field_comparisons/src/main.nr             |  2 +-
 .../noir_test_success/mock_oracle/src/main.nr |  2 +-
 .../regression_4561/src/main.nr               |  4 +-
 .../should_fail_with_matches/src/main.nr      | 18 +++----
 test_programs/rebuild.sh                      | 25 +---------
 .../test_libraries/diamond_deps_1/src/lib.nr  |  2 +-
 .../test_libraries/exporting_lib/src/lib.nr   |  2 +-
 .../test_libraries/reexporting_lib/src/lib.nr |  4 +-
 tooling/debugger/src/source_code_printer.rs   |  4 +-
 tooling/nargo_fmt/tests/expected/contract.nr  |  6 +--
 .../nargo_fmt/tests/expected/import_braces.nr |  2 +-
 tooling/nargo_fmt/tests/expected/let.nr       |  8 ++--
 tooling/nargo_fmt/tests/expected/print.nr     |  2 -
 tooling/nargo_fmt/tests/expected/print2.nr    |  2 -
 .../tests/expected/singleton_import.nr        |  2 +
 tooling/nargo_fmt/tests/input/contract.nr     |  6 +--
 .../nargo_fmt/tests/input/import_braces.nr    |  2 +-
 tooling/nargo_fmt/tests/input/let.nr          |  8 ++--
 tooling/nargo_fmt/tests/input/print.nr        |  2 -
 tooling/nargo_fmt/tests/input/print2.nr       |  2 -
 .../nargo_fmt/tests/input/singleton_import.nr |  2 +
 .../assert_lt/src/main.nr                     |  2 -
 190 files changed, 375 insertions(+), 369 deletions(-)
 create mode 100644 test_programs/compile_failure/dep_submodule_overlap/Nargo.toml
 create mode 100644 test_programs/compile_failure/dep_submodule_overlap/src/lib.nr
 create mode 100644 test_programs/compile_failure/dep_submodule_overlap/src/main.nr
 create mode 100644 test_programs/compile_failure/overlapping_dep_and_mod/Nargo.toml
 create mode 100644 test_programs/compile_failure/overlapping_dep_and_mod/bin/Nargo.toml
 create mode 100644 test_programs/compile_failure/overlapping_dep_and_mod/bin/Prover.toml
 create mode 100644 test_programs/compile_failure/overlapping_dep_and_mod/bin/src/main.nr
 create mode 100644 test_programs/compile_failure/overlapping_dep_and_mod/foo/Nargo.toml
 create mode 100644 test_programs/compile_failure/overlapping_dep_and_mod/foo/src/lib.nr
 create mode 100644 test_programs/compile_success_empty/overlapping_dep_and_mod/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/overlapping_dep_and_mod/bin/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/overlapping_dep_and_mod/bin/src/main.nr
 create mode 100644 test_programs/compile_success_empty/overlapping_dep_and_mod/foo/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/overlapping_dep_and_mod/foo/src/lib.nr
 create mode 100644 test_programs/execution_success/overlapping_dep_and_mod/Nargo.toml
 create mode 100644 test_programs/execution_success/overlapping_dep_and_mod/bin/Nargo.toml
 create mode 100644 test_programs/execution_success/overlapping_dep_and_mod/bin/Prover.toml
 create mode 100644 test_programs/execution_success/overlapping_dep_and_mod/bin/src/main.nr
 create mode 100644 test_programs/execution_success/overlapping_dep_and_mod/foo/Nargo.toml
 create mode 100644 test_programs/execution_success/overlapping_dep_and_mod/foo/src/lib.nr
 create mode 100644 tooling/nargo_fmt/tests/expected/singleton_import.nr
 create mode 100644 tooling/nargo_fmt/tests/input/singleton_import.nr

diff --git a/aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs
index 30c0f63a2d4..40fde39a06f 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_optionally_a_nullifier.rs
@@ -176,7 +176,7 @@ fn generate_compute_note_hash_and_optionally_a_nullifier_source(
         format!(
             "
         unconstrained fn compute_note_hash_and_optionally_a_nullifier(
-            contract_address: dep::aztec::protocol_types::address::AztecAddress,
+            contract_address: aztec::protocol_types::address::AztecAddress,
             nonce: Field,
             storage_slot: Field,
             note_type_id: Field,
@@ -194,7 +194,7 @@ fn generate_compute_note_hash_and_optionally_a_nullifier_source(
 
         let if_statements: Vec<String> = note_types.iter().map(|note_type| format!(
             "if (note_type_id == {0}::get_note_type_id()) {{
-                dep::aztec::note::utils::compute_note_hash_and_optionally_a_nullifier({0}::deserialize_content, note_header, compute_nullifier, serialized_note)
+                aztec::note::utils::compute_note_hash_and_optionally_a_nullifier({0}::deserialize_content, note_header, compute_nullifier, serialized_note)
             }}"
         , note_type)).collect();
 
@@ -208,14 +208,14 @@ fn generate_compute_note_hash_and_optionally_a_nullifier_source(
         format!(
             "
             unconstrained fn compute_note_hash_and_optionally_a_nullifier(
-                contract_address: dep::aztec::protocol_types::address::AztecAddress,
+                contract_address: aztec::protocol_types::address::AztecAddress,
                 nonce: Field,
                 storage_slot: Field,
                 note_type_id: Field,
                 compute_nullifier: bool,
                 serialized_note: [Field; {}],
             ) -> pub [Field; 4] {{
-                let note_header = dep::aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
+                let note_header = aztec::prelude::NoteHeader::new(contract_address, nonce, storage_slot);
 
                 {}
             }}",
diff --git a/aztec_macros/src/transforms/contract_interface.rs b/aztec_macros/src/transforms/contract_interface.rs
index 90f9ce6164a..e6ac43ad2c4 100644
--- a/aztec_macros/src/transforms/contract_interface.rs
+++ b/aztec_macros/src/transforms/contract_interface.rs
@@ -30,8 +30,8 @@ use crate::utils::{
 //   for i in 0..third_arg.len() {
 //     args_acc = args_acc.append(third_arg[i].serialize().as_slice());
 //   }
-//   let args_hash = dep::aztec::hash::hash_args(args_acc);
-//   assert(args_hash == dep::aztec::oracle::arguments::pack_arguments(args_acc));
+//   let args_hash = aztec::hash::hash_args(args_acc);
+//   assert(args_hash == aztec::oracle::arguments::pack_arguments(args_acc));
 //   PublicCallInterface {
 //     target_contract: self.target_contract,
 //     selector: FunctionSelector::from_signature("SELECTOR_PLACEHOLDER"),
@@ -56,7 +56,10 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
         .join(", ");
     let fn_return_type: noirc_frontend::ast::UnresolvedType = func.return_type();
 
-    let fn_selector = format!("dep::aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature(\"{}\")", SELECTOR_PLACEHOLDER);
+    let fn_selector = format!(
+        "aztec::protocol_types::abis::function_selector::FunctionSelector::from_signature(\"{}\")",
+        SELECTOR_PLACEHOLDER
+    );
 
     let parameters = func.parameters();
     let is_void = if matches!(fn_return_type.typ, UnresolvedTypeData::Unit) { "Void" } else { "" };
@@ -93,8 +96,8 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
             format!(
                 "let mut args_acc: [Field] = &[];
                 {}
-                let args_hash = dep::aztec::hash::hash_args(args_acc);
-                assert(args_hash == dep::aztec::oracle::arguments::pack_arguments(args_acc));",
+                let args_hash = aztec::hash::hash_args(args_acc);
+                assert(args_hash == aztec::oracle::arguments::pack_arguments(args_acc));",
                 call_args
             )
         } else {
@@ -103,7 +106,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
 
         let fn_body = format!(
             "{}
-                dep::aztec::context::{}{}{}CallInterface {{
+                aztec::context::{}{}{}CallInterface {{
                     target_contract: self.target_contract,
                     selector: {},
                     args_hash,
@@ -111,7 +114,7 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
             args_hash, aztec_visibility, is_static, is_void, fn_selector,
         );
         format!(
-            "pub fn {}(self, {}) -> dep::aztec::context::{}{}{}CallInterface{} {{
+            "pub fn {}(self, {}) -> aztec::context::{}{}{}CallInterface{} {{
                     {}
                 }}",
             fn_name, fn_parameters, aztec_visibility, is_static, is_void, return_type_hint, fn_body
@@ -125,16 +128,16 @@ pub fn stub_function(aztec_visibility: &str, func: &NoirFunction, is_static_call
         );
         let fn_body = format!(
             "{}
-            dep::aztec::context::Public{}{}CallInterface {{
+            aztec::context::Public{}{}CallInterface {{
                 target_contract: self.target_contract,
                 selector: {},
                 args: args_acc,
-                gas_opts: dep::aztec::context::gas::GasOpts::default(),
+                gas_opts: aztec::context::gas::GasOpts::default(),
             }}",
             args, is_static, is_void, fn_selector,
         );
         format!(
-            "pub fn {}(self, {}) -> dep::aztec::context::Public{}{}CallInterface{} {{
+            "pub fn {}(self, {}) -> aztec::context::Public{}{}CallInterface{} {{
                     {}
             }}",
             fn_name, fn_parameters, is_static, is_void, return_type_hint, fn_body
@@ -153,14 +156,14 @@ pub fn generate_contract_interface(
     let contract_interface = format!(
         "
         struct {0} {{
-            target_contract: dep::aztec::protocol_types::address::AztecAddress
+            target_contract: aztec::protocol_types::address::AztecAddress
         }}
 
         impl {0} {{
             {1}
 
             pub fn at(
-                target_contract: dep::aztec::protocol_types::address::AztecAddress
+                target_contract: aztec::protocol_types::address::AztecAddress
             ) -> Self {{
                 Self {{ target_contract }}
             }}
@@ -168,7 +171,7 @@ pub fn generate_contract_interface(
 
         #[contract_library_method]
         pub fn at(
-            target_contract: dep::aztec::protocol_types::address::AztecAddress
+            target_contract: aztec::protocol_types::address::AztecAddress
         ) -> {0} {{
             {0} {{ target_contract }}
         }}
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index fdce8b81db2..f0e7d0d5034 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -268,7 +268,7 @@ fn generate_note_get_header(
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = format!(
         "
-        fn get_header(note: {}) -> dep::aztec::note::note_header::NoteHeader {{
+        fn get_header(note: {}) -> aztec::note::note_header::NoteHeader {{
             note.{}
         }}
     ",
@@ -299,7 +299,7 @@ fn generate_note_set_header(
 ) -> Result<NoirFunction, AztecMacroError> {
     let function_source = format!(
         "
-        fn set_header(self: &mut {}, header: dep::aztec::note::note_header::NoteHeader) {{
+        fn set_header(self: &mut {}, header: aztec::note::note_header::NoteHeader) {{
             self.{} = header;
         }}
     ",
@@ -488,7 +488,7 @@ fn generate_note_properties_fn(
 
 // Automatically generate the method to compute the note's content hash as:
 // fn compute_note_content_hash(self: NoteType) -> Field {
-//    dep::aztec::hash::pedersen_hash(self.serialize_content(), dep::aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_CONTENT_HASH)
+//    aztec::hash::pedersen_hash(self.serialize_content(), aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_CONTENT_HASH)
 // }
 //
 fn generate_compute_note_content_hash(
@@ -498,7 +498,7 @@ fn generate_compute_note_content_hash(
     let function_source = format!(
         "
         fn compute_note_content_hash(self: {}) -> Field {{
-            dep::aztec::hash::pedersen_hash(self.serialize_content(), dep::aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_CONTENT_HASH)
+            aztec::hash::pedersen_hash(self.serialize_content(), aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_CONTENT_HASH)
         }}
         ",
         note_type
@@ -557,10 +557,7 @@ fn generate_note_properties_struct_source(
         .iter()
         .filter_map(|(field_name, _)| {
             if field_name != note_header_field_name {
-                Some(format!(
-                    "{}: dep::aztec::note::note_getter_options::PropertySelector",
-                    field_name
-                ))
+                Some(format!("{}: aztec::note::note_getter_options::PropertySelector", field_name))
             } else {
                 None
             }
@@ -588,7 +585,7 @@ fn generate_note_properties_fn_source(
         .filter_map(|(index, (field_name, _))| {
             if field_name != note_header_field_name {
                 Some(format!(
-                    "{}: dep::aztec::note::note_getter_options::PropertySelector {{ index: {}, offset: 0, length: 32 }}",
+                    "{}: aztec::note::note_getter_options::PropertySelector {{ index: {}, offset: 0, length: 32 }}",
                     field_name,
                     index
                 ))
@@ -665,10 +662,7 @@ fn generate_note_deserialize_content_source(
                     )
                 }
             } else {
-                format!(
-                    "{}: dep::aztec::note::note_header::NoteHeader::empty()",
-                    note_header_field_name
-                )
+                format!("{}: aztec::note::note_header::NoteHeader::empty()", note_header_field_name)
             }
         })
         .collect::<Vec<String>>()
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index a1c21c7efcf..8b778b4cca6 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -509,10 +509,10 @@ pub fn generate_storage_layout(
     let mut storable_fields_impl = vec![];
 
     definition.fields.iter().enumerate().for_each(|(index, (field_ident, field_type))| {
-        storable_fields.push(format!("{}: dep::aztec::prelude::Storable<N{}>", field_ident, index));
+        storable_fields.push(format!("{}: aztec::prelude::Storable<N{}>", field_ident, index));
         generic_args.push(format!("N{}", index));
         storable_fields_impl.push(format!(
-            "{}: dep::aztec::prelude::Storable {{ slot: 0, typ: \"{}\" }}",
+            "{}: aztec::prelude::Storable {{ slot: 0, typ: \"{}\" }}",
             field_ident,
             field_type.to_string().replace("plain::", "")
         ));
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index 48b3b25747b..4467c4bca4b 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -161,7 +161,7 @@ macro_rules! chained_dep {
     ( $base:expr $(, $tail:expr)* ) => {
         {
             let mut base_path = ident_path($base);
-            base_path.kind = PathKind::Dep;
+            base_path.kind = PathKind::Plain;
             $(
                 base_path.segments.push(ident($tail));
             )*
diff --git a/compiler/integration-tests/circuits/assert_lt/src/main.nr b/compiler/integration-tests/circuits/assert_lt/src/main.nr
index b8e255ca492..47e229d6c8b 100644
--- a/compiler/integration-tests/circuits/assert_lt/src/main.nr
+++ b/compiler/integration-tests/circuits/assert_lt/src/main.nr
@@ -1,10 +1,7 @@
-use dep::std;
-
 fn main(x: u64, y: pub u64) -> pub u64 {
     // We include a println statement to show that noirJS will ignore this and continue execution
     std::println("foo");
 
-
     assert(x < y);
     x + y
 }
diff --git a/compiler/integration-tests/circuits/recursion/src/main.nr b/compiler/integration-tests/circuits/recursion/src/main.nr
index 173207766fb..94cae14daa7 100644
--- a/compiler/integration-tests/circuits/recursion/src/main.nr
+++ b/compiler/integration-tests/circuits/recursion/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(
     verification_key: [Field; 114],
     proof: [Field; 93],
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index f5866f5b756..443267380b5 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -470,7 +470,7 @@ impl DebugInstrumenter {
             .join(",\n");
         let (program, errors) = parse_program(&format!(
             r#"
-            use dep::__debug::{{
+            use __debug::{{
                 __debug_var_assign,
                 __debug_var_drop,
                 __debug_fn_enter,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 4511537a1cc..4d64481bc9f 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -468,7 +468,7 @@ fn inject_prelude(
 
         let path = Path {
             segments: segments.clone(),
-            kind: crate::ast::PathKind::Dep,
+            kind: crate::ast::PathKind::Plain,
             span: Span::default(),
         };
 
@@ -489,7 +489,7 @@ fn inject_prelude(
                     0,
                     ImportDirective {
                         module_id: crate_root,
-                        path: Path { segments, kind: PathKind::Dep, span: Span::default() },
+                        path: Path { segments, kind: PathKind::Plain, span: Span::default() },
                         alias: None,
                         is_prelude: true,
                     },
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index 343113836ed..f3dae31e1e0 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -158,16 +158,34 @@ fn resolve_path_to_ns(
                 allow_contracts,
             )
         }
-        crate::ast::PathKind::Dep => resolve_external_dep(
-            def_map,
-            import_directive,
-            def_maps,
-            allow_contracts,
-            importing_crate,
-        ),
         crate::ast::PathKind::Plain => {
-            // Plain paths are only used to import children modules. It's possible to allow import of external deps, but maybe this distinction is better?
-            // In Rust they can also point to external Dependencies, if no children can be found with the specified name
+            // There is a possibility that the import path is empty
+            // In that case, early return
+            if import_path.is_empty() {
+                return resolve_name_in_module(
+                    crate_id,
+                    importing_crate,
+                    import_path,
+                    import_directive.module_id,
+                    def_maps,
+                    allow_contracts,
+                );
+            }
+
+            let current_mod_id = ModuleId { krate: crate_id, local_id: import_directive.module_id };
+            let current_mod = &def_map.modules[current_mod_id.local_id.0];
+            let first_segment = import_path.first().expect("ice: could not fetch first segment");
+            if current_mod.find_name(first_segment).is_none() {
+                // Resolve externally when first segment is unresolved
+                return resolve_external_dep(
+                    def_map,
+                    import_directive,
+                    def_maps,
+                    allow_contracts,
+                    importing_crate,
+                );
+            }
+
             resolve_name_in_module(
                 crate_id,
                 importing_crate,
@@ -177,6 +195,14 @@ fn resolve_path_to_ns(
                 allow_contracts,
             )
         }
+
+        crate::ast::PathKind::Dep => resolve_external_dep(
+            def_map,
+            import_directive,
+            def_maps,
+            allow_contracts,
+            importing_crate,
+        ),
     }
 }
 
@@ -302,7 +328,9 @@ fn resolve_external_dep(
         .ok_or_else(|| PathResolutionError::Unresolved(crate_name.to_owned()))?;
 
     // Create an import directive for the dependency crate
-    let path_without_crate_name = &path[1..]; // XXX: This will panic if the path is of the form `use dep::std` Ideal algorithm will not distinguish between crate and module
+    // XXX: This will panic if the path is of the form `use std`. Ideal algorithm will not distinguish between crate and module
+    // See `singleton_import.nr` test case for a check that such cases are handled elsewhere.
+    let path_without_crate_name = &path[1..];
 
     let path = Path {
         segments: path_without_crate_name.to_vec(),
diff --git a/compiler/noirc_frontend/src/noir_parser.lalrpop b/compiler/noirc_frontend/src/noir_parser.lalrpop
index c6cb788a5a4..5768e3c1d17 100644
--- a/compiler/noirc_frontend/src/noir_parser.lalrpop
+++ b/compiler/noirc_frontend/src/noir_parser.lalrpop
@@ -125,7 +125,7 @@ pub(crate) Path: Path = {
     },
 
     <lo:@L> "dep" "::" <segments:PathSegments> <hi:@R> => {
-        let kind = PathKind::Dep;
+        let kind = PathKind::Plain;
         let span = Span::from(lo as u32..hi as u32);
         Path { segments, kind, span }
     },
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 0d8215f2ea4..e8838c58772 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1445,7 +1445,7 @@ mod test {
             "use foo::{bar, hello}",
             "use foo::{bar as bar2, hello}",
             "use foo::{bar as bar2, hello::{foo}, nested::{foo, bar}}",
-            "use dep::{std::println, bar::baz}",
+            "use std::{println, bar::baz}",
         ];
 
         let invalid_use_statements = [
diff --git a/compiler/noirc_frontend/src/parser/parser/path.rs b/compiler/noirc_frontend/src/parser/parser/path.rs
index 47bb11991fa..e40268af410 100644
--- a/compiler/noirc_frontend/src/parser/parser/path.rs
+++ b/compiler/noirc_frontend/src/parser/parser/path.rs
@@ -25,7 +25,7 @@ fn empty_path() -> impl NoirParser<Path> {
     let make_path = |kind| move |_, span| Path { segments: Vec::new(), kind, span };
     let path_kind = |key, kind| keyword(key).map_with_span(make_path(kind));
 
-    choice((path_kind(Keyword::Crate, PathKind::Crate), path_kind(Keyword::Dep, PathKind::Dep)))
+    choice((path_kind(Keyword::Crate, PathKind::Crate), path_kind(Keyword::Dep, PathKind::Plain)))
 }
 
 pub(super) fn maybe_empty_path() -> impl NoirParser<Path> {
@@ -43,7 +43,8 @@ mod test {
             ("std", vec!["std"]),
             ("std::hash", vec!["std", "hash"]),
             ("std::hash::collections", vec!["std", "hash", "collections"]),
-            ("dep::foo::bar", vec!["foo", "bar"]),
+            ("foo::bar", vec!["foo", "bar"]),
+            ("foo::bar", vec!["foo", "bar"]),
             ("crate::std::hash", vec!["std", "hash"]),
         ];
 
@@ -61,7 +62,7 @@ mod test {
     fn parse_path_kinds() {
         let cases = vec![
             ("std", PathKind::Plain),
-            ("dep::hash::collections", PathKind::Dep),
+            ("hash::collections", PathKind::Plain),
             ("crate::std::hash", PathKind::Crate),
         ];
 
@@ -72,7 +73,7 @@ mod test {
 
         parse_all_failing(
             path(),
-            vec!["dep", "crate", "crate::std::crate", "foo::bar::crate", "foo::dep"],
+            vec!["crate", "crate::std::crate", "foo::bar::crate", "foo::dep"],
         );
     }
 }
diff --git a/compiler/wasm/test/fixtures/deps/lib-a/src/lib.nr b/compiler/wasm/test/fixtures/deps/lib-a/src/lib.nr
index 3f8fa051daf..c38188d0119 100644
--- a/compiler/wasm/test/fixtures/deps/lib-a/src/lib.nr
+++ b/compiler/wasm/test/fixtures/deps/lib-a/src/lib.nr
@@ -1,4 +1,4 @@
-use dep::lib_b::assert_non_zero;
+use lib_b::assert_non_zero;
 
 pub fn divide(a: u64, b: u64) -> u64 {
     assert_non_zero(b);
diff --git a/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr b/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr
index 0376cd4cb87..23b6659b3c5 100644
--- a/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr
+++ b/compiler/wasm/test/fixtures/deps/lib-c/src/module/foo.nr
@@ -1,3 +1,3 @@
 pub fn bar(param: Field) -> Field {
-    dep::std::hash::pedersen_hash([param])
+    std::hash::pedersen_hash([param])
 }
diff --git a/compiler/wasm/test/fixtures/noir-contract/src/main.nr b/compiler/wasm/test/fixtures/noir-contract/src/main.nr
index fc1dc8a5a17..6f63850e3a0 100644
--- a/compiler/wasm/test/fixtures/noir-contract/src/main.nr
+++ b/compiler/wasm/test/fixtures/noir-contract/src/main.nr
@@ -1,5 +1,5 @@
 contract TestContract {
-    use dep::test::module::foo;
+    use test::module::foo;
 
     fn constructor(param: Field, pub_param: pub Field) -> pub [Field; 2] {
         [foo::bar(param), param + pub_param]
diff --git a/compiler/wasm/test/fixtures/with-deps/src/main.nr b/compiler/wasm/test/fixtures/with-deps/src/main.nr
index 056bcc180b4..fe9e7f9ca77 100644
--- a/compiler/wasm/test/fixtures/with-deps/src/main.nr
+++ b/compiler/wasm/test/fixtures/with-deps/src/main.nr
@@ -1,4 +1,4 @@
-use dep::lib_a::divide;
+use lib_a::divide;
 fn main(x: u64, y: pub u64) {
     divide(x, y);
 }
diff --git a/docs/docs/how_to/merkle-proof.mdx b/docs/docs/how_to/merkle-proof.mdx
index 16c425bed76..0a128adb2de 100644
--- a/docs/docs/how_to/merkle-proof.mdx
+++ b/docs/docs/how_to/merkle-proof.mdx
@@ -12,7 +12,6 @@ Let's walk through an example of a merkle membership proof in Noir that proves t
 in a merkle tree.
 
 ```rust
-use dep::std;
 
 fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
     let leaf = std::hash::hash_to_field(message.as_slice());
diff --git a/docs/docs/noir/concepts/data_types/integers.md b/docs/docs/noir/concepts/data_types/integers.md
index c14fffa7174..a1d59bf3166 100644
--- a/docs/docs/noir/concepts/data_types/integers.md
+++ b/docs/docs/noir/concepts/data_types/integers.md
@@ -149,7 +149,6 @@ fn wrapping_mul<T>(x: T, y: T) -> T;
 Example of how it is used:
 
 ```rust
-use dep::std;
 
 fn main(x: u8, y: u8) -> pub u8 {
     std::wrapping_add(x, y)
diff --git a/docs/docs/noir/concepts/data_types/slices.mdx b/docs/docs/noir/concepts/data_types/slices.mdx
index 4eccc677b80..dff08d63ffb 100644
--- a/docs/docs/noir/concepts/data_types/slices.mdx
+++ b/docs/docs/noir/concepts/data_types/slices.mdx
@@ -12,9 +12,7 @@ import Experimental from '@site/src/components/Notes/_experimental.mdx';
 A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
 
 ```rust
-use dep::std::slice;
-
-fn main() -> pub Field {
+fn main() -> pub u32 {
     let mut slice: [Field] = &[0; 2];
 
     let mut new_slice = slice.push_back(6);
diff --git a/docs/docs/noir/concepts/data_types/strings.md b/docs/docs/noir/concepts/data_types/strings.md
index 8ab5825a4c4..1fdee42425e 100644
--- a/docs/docs/noir/concepts/data_types/strings.md
+++ b/docs/docs/noir/concepts/data_types/strings.md
@@ -20,7 +20,6 @@ You can use strings in `assert()` functions or print them with
 `println()`. See more about [Logging](../../standard_library/logging.md).
 
 ```rust
-use dep::std;
 
 fn main(message : pub str<11>, hex_as_string : str<4>) {
     println(message);
diff --git a/docs/docs/noir/concepts/traits.md b/docs/docs/noir/concepts/traits.md
index ef1445a5907..df7cb9ebda0 100644
--- a/docs/docs/noir/concepts/traits.md
+++ b/docs/docs/noir/concepts/traits.md
@@ -372,13 +372,13 @@ impls for any trait we need on it.
 
 ```rust
 struct Wrapper {
-    foo: dep::some_library::Foo,
+    foo: some_library::Foo,
 }
 
 impl Default for Wrapper {
     fn default() -> Wrapper {
         Wrapper {
-            foo: dep::some_library::Foo::new(),
+            foo: some_library::Foo::new(),
         }
     }
 }
diff --git a/docs/docs/noir/modules_packages_crates/dependencies.md b/docs/docs/noir/modules_packages_crates/dependencies.md
index 2c028d85853..24e02de08fe 100644
--- a/docs/docs/noir/modules_packages_crates/dependencies.md
+++ b/docs/docs/noir/modules_packages_crates/dependencies.md
@@ -70,15 +70,15 @@ You can import a dependency to a Noir file using the following syntax. For examp
 ecrecover-noir library and local lib_a referenced above:
 
 ```rust
-use dep::ecrecover;
-use dep::lib_a;
+use ecrecover;
+use lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
 
 ```rust
-use dep::std::hash::sha256;
-use dep::std::scalar_mul::fixed_base_embedded_curve;
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
 ```
 
 Lastly, as demonstrated in the
@@ -86,7 +86,7 @@ Lastly, as demonstrated in the
 can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
-use dep::std::ec::tecurve::affine::{Curve, Point};
+use std::ec::tecurve::affine::{Curve, Point};
 ```
 
 We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
@@ -100,7 +100,7 @@ Note that when you import a dependency, you also get access to all of the depend
 For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
 
 ```rust
-use dep::phy_vector;
+use phy_vector;
 
 fn main(x : Field, y : pub Field) {
   //...
diff --git a/docs/docs/noir/standard_library/containers/hashmap.md b/docs/docs/noir/standard_library/containers/hashmap.md
index 2b9f4895722..651e7f5723b 100644
--- a/docs/docs/noir/standard_library/containers/hashmap.md
+++ b/docs/docs/noir/standard_library/containers/hashmap.md
@@ -21,7 +21,7 @@ Example:
 ```rust
 // Create a mapping from Fields to u32s with a maximum length of 12
 // using a poseidon2 hasher
-use dep::std::hash::poseidon2::Poseidon2Hasher;
+use std::hash::poseidon2::Poseidon2Hasher;
 let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
 
 map.insert(1, 2);
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/docs/noir/standard_library/cryptographic_primitives/ec_primitives.md
index d2b42d67b7c..f839b4a228e 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/ec_primitives.md
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -81,7 +81,7 @@ from the private key. This is a matter of using scalar multiplication. In the ca
 for example, this code would do:
 
 ```rust
-use dep::std::ec::tecurve::affine::{Curve, Point};
+use std::ec::tecurve::affine::{Curve, Point};
 
 fn bjj_pub_key(priv_key: Field) -> Point
 {
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
index 789d26ce426..1ad42a5ac96 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -18,7 +18,7 @@ fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s
 It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
 For instance, if you want to use Poseidon2 instead, you can do the following:
 ```rust
-use dep::std::hash::poseidon2::Poseidon2Hasher;
+use std::hash::poseidon2::Poseidon2Hasher;
 
 eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
 ```
diff --git a/docs/docs/noir/standard_library/recursion.md b/docs/docs/noir/standard_library/recursion.md
index cb3e7a9fcdf..8cfb37fc52d 100644
--- a/docs/docs/noir/standard_library/recursion.md
+++ b/docs/docs/noir/standard_library/recursion.md
@@ -40,7 +40,6 @@ pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [F
 ## Example usage
 
 ```rust
-use dep::std;
 
 fn main(
     verification_key : [Field; 114],
diff --git a/examples/recursion/recurse_leaf/src/main.nr b/examples/recursion/recurse_leaf/src/main.nr
index b6a2b49b219..4859e84d49e 100644
--- a/examples/recursion/recurse_leaf/src/main.nr
+++ b/examples/recursion/recurse_leaf/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 #[recursive]
 fn main(
     verification_key: [Field; 114],
@@ -17,4 +15,4 @@ fn main(
     );
     // Take output of previous proof and add another number to it.
     public_inputs[2] as u64 + num
-}
\ No newline at end of file
+}
diff --git a/examples/recursion/recurse_node/src/main.nr b/examples/recursion/recurse_node/src/main.nr
index 7c983dcf050..60192493b54 100644
--- a/examples/recursion/recurse_node/src/main.nr
+++ b/examples/recursion/recurse_node/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(
     verification_key: [Field; 114],
     public_inputs: pub [Field; 4],
@@ -14,4 +12,4 @@ fn main(
         key_hash
     );
     public_inputs[3] as u64
-}
\ No newline at end of file
+}
diff --git a/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr b/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
index 31c2f1f2d13..cb853e48c30 100644
--- a/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
+++ b/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::eddsa::{eddsa_poseidon_verify};
+use std::eddsa::eddsa_poseidon_verify;
 
 fn main(
     msg: pub Field,
@@ -9,4 +9,4 @@ fn main(
     s: Field
 ) -> pub bool {
     eddsa_poseidon_verify(pub_key_x, pub_key_y, s, r8_x, r8_y, msg)
-}
\ No newline at end of file
+}
diff --git a/test_programs/benchmarks/bench_poseidon_hash/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash/src/main.nr
index 38adeef6ec7..9900e91c1d7 100644
--- a/test_programs/benchmarks/bench_poseidon_hash/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash::poseidon;
+use std::hash::poseidon;
 
 fn main(input: [Field; 2]) -> pub Field {
     poseidon::bn254::hash_2(input)
diff --git a/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
index fc9a5b7a970..1c9bbfe61bf 100644
--- a/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash;
+use std::hash;
 
 global SIZE = 100;
 
@@ -9,4 +9,4 @@ fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     }
 
     results
-}
\ No newline at end of file
+}
diff --git a/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
index 4d2d94e4946..3edb47e9f72 100644
--- a/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash;
+use std::hash;
 
 global SIZE = 30;
 
@@ -9,4 +9,4 @@ fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     }
 
     results
-}
\ No newline at end of file
+}
diff --git a/test_programs/benchmarks/bench_sha256_100/src/main.nr b/test_programs/benchmarks/bench_sha256_100/src/main.nr
index d78ca8002d2..6df856a83fc 100644
--- a/test_programs/benchmarks/bench_sha256_100/src/main.nr
+++ b/test_programs/benchmarks/bench_sha256_100/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 global SIZE = 100;
 
 fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
@@ -9,4 +7,4 @@ fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
     }
 
     results
-}
\ No newline at end of file
+}
diff --git a/test_programs/benchmarks/bench_sha256_30/src/main.nr b/test_programs/benchmarks/bench_sha256_30/src/main.nr
index fa66d626586..220c1cfbbed 100644
--- a/test_programs/benchmarks/bench_sha256_30/src/main.nr
+++ b/test_programs/benchmarks/bench_sha256_30/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 global SIZE = 30;
 
 fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
@@ -9,4 +7,4 @@ fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
     }
 
     results
-}
\ No newline at end of file
+}
diff --git a/test_programs/compile_failure/array_length_defaulting/src/main.nr b/test_programs/compile_failure/array_length_defaulting/src/main.nr
index 216a9ae3f0c..40543db2870 100644
--- a/test_programs/compile_failure/array_length_defaulting/src/main.nr
+++ b/test_programs/compile_failure/array_length_defaulting/src/main.nr
@@ -1,5 +1,5 @@
 fn main() {
-    let x = dep::std::unsafe::zeroed();
+    let x = std::unsafe::zeroed();
     foo(x);
 }
 
diff --git a/test_programs/compile_failure/assert_constant_fail/src/main.nr b/test_programs/compile_failure/assert_constant_fail/src/main.nr
index cf682607083..b8d5d255228 100644
--- a/test_programs/compile_failure/assert_constant_fail/src/main.nr
+++ b/test_programs/compile_failure/assert_constant_fail/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::assert_constant;
+use std::assert_constant;
 
 fn main(x: Field) {
     foo(5, x);
diff --git a/test_programs/compile_failure/brillig_nested_slices/src/main.nr b/test_programs/compile_failure/brillig_nested_slices/src/main.nr
index 3d8a6748ccf..ee61195cf8f 100644
--- a/test_programs/compile_failure/brillig_nested_slices/src/main.nr
+++ b/test_programs/compile_failure/brillig_nested_slices/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::slice;
+use std::slice;
 // Tests nested slice passing to/from functions
 unconstrained fn push_back_to_slice<T>(slice: [T], item: T) -> [T] {
     slice.push_back(item)
diff --git a/test_programs/compile_failure/dep_impl_primitive/src/main.nr b/test_programs/compile_failure/dep_impl_primitive/src/main.nr
index e61ae82b62c..40578574c75 100644
--- a/test_programs/compile_failure/dep_impl_primitive/src/main.nr
+++ b/test_programs/compile_failure/dep_impl_primitive/src/main.nr
@@ -1,4 +1,4 @@
-use dep::bad_impl;
+use bad_impl;
 
 fn main(x: Field) {
     x.something();
diff --git a/test_programs/compile_failure/dep_submodule_overlap/Nargo.toml b/test_programs/compile_failure/dep_submodule_overlap/Nargo.toml
new file mode 100644
index 00000000000..0d5a6221ef2
--- /dev/null
+++ b/test_programs/compile_failure/dep_submodule_overlap/Nargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "dep_submodule_overlap"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
+reexporting_lib = { path = "../../test_libraries/reexporting_lib" }
diff --git a/test_programs/compile_failure/dep_submodule_overlap/src/lib.nr b/test_programs/compile_failure/dep_submodule_overlap/src/lib.nr
new file mode 100644
index 00000000000..e2e82b2f5cd
--- /dev/null
+++ b/test_programs/compile_failure/dep_submodule_overlap/src/lib.nr
@@ -0,0 +1,3 @@
+struct MyStruct {
+    inner: Field
+}
diff --git a/test_programs/compile_failure/dep_submodule_overlap/src/main.nr b/test_programs/compile_failure/dep_submodule_overlap/src/main.nr
new file mode 100644
index 00000000000..c53630c53ca
--- /dev/null
+++ b/test_programs/compile_failure/dep_submodule_overlap/src/main.nr
@@ -0,0 +1,9 @@
+use reexporting_lib::{MyStruct, lib};
+
+mod lib;
+use crate::lib::MyStruct;
+
+fn main() {
+    let x = MyStruct { inner: 0 };
+    assert(lib::is_struct_zero(x));
+}
diff --git a/test_programs/compile_failure/depend_on_bin/src/main.nr b/test_programs/compile_failure/depend_on_bin/src/main.nr
index 4e03e8eb41e..d7aff600fe6 100644
--- a/test_programs/compile_failure/depend_on_bin/src/main.nr
+++ b/test_programs/compile_failure/depend_on_bin/src/main.nr
@@ -1,4 +1,4 @@
-use dep::bin_dep;
+use bin_dep;
 
 fn main(x : Field) {
     assert(x == 1);
diff --git a/test_programs/compile_failure/negate_unsigned/src/main.nr b/test_programs/compile_failure/negate_unsigned/src/main.nr
index db5f9b0820f..4d3c5abe5a4 100644
--- a/test_programs/compile_failure/negate_unsigned/src/main.nr
+++ b/test_programs/compile_failure/negate_unsigned/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     let var = -1 as u8;
     std::println(var);
diff --git a/test_programs/compile_failure/orphaned_trait_impl/src/main.nr b/test_programs/compile_failure/orphaned_trait_impl/src/main.nr
index dfd88d8f074..dd04aa454b2 100644
--- a/test_programs/compile_failure/orphaned_trait_impl/src/main.nr
+++ b/test_programs/compile_failure/orphaned_trait_impl/src/main.nr
@@ -1,4 +1,4 @@
-impl dep::crate1::MyTrait for dep::crate2::MyStruct {
+impl crate1::MyTrait for crate2::MyStruct {
 }
 
 fn main(x: Field, y: pub Field) {
diff --git a/test_programs/compile_failure/overlapping_dep_and_mod/Nargo.toml b/test_programs/compile_failure/overlapping_dep_and_mod/Nargo.toml
new file mode 100644
index 00000000000..b2c3e5f94be
--- /dev/null
+++ b/test_programs/compile_failure/overlapping_dep_and_mod/Nargo.toml
@@ -0,0 +1,6 @@
+[workspace]
+members = [
+    "bin", 
+    "foo",
+]
+default-member = "bin"
diff --git a/test_programs/compile_failure/overlapping_dep_and_mod/bin/Nargo.toml b/test_programs/compile_failure/overlapping_dep_and_mod/bin/Nargo.toml
new file mode 100644
index 00000000000..57e704462db
--- /dev/null
+++ b/test_programs/compile_failure/overlapping_dep_and_mod/bin/Nargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "overlapping_dep_and_mod"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
+foo = { path = "../foo" }
diff --git a/test_programs/compile_failure/overlapping_dep_and_mod/bin/Prover.toml b/test_programs/compile_failure/overlapping_dep_and_mod/bin/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/compile_failure/overlapping_dep_and_mod/bin/src/main.nr b/test_programs/compile_failure/overlapping_dep_and_mod/bin/src/main.nr
new file mode 100644
index 00000000000..675e889b7e5
--- /dev/null
+++ b/test_programs/compile_failure/overlapping_dep_and_mod/bin/src/main.nr
@@ -0,0 +1,12 @@
+fn main() -> pub Field {
+    assert(foo::bar() + foo::baz() == 3);
+    assert(foo::bar() == 1);
+    assert(foo::baz() == 2);
+    foo::bar() + foo::baz()
+}
+
+mod foo {
+    pub(crate) fn bar() -> Field {
+        1
+    }
+}
diff --git a/test_programs/compile_failure/overlapping_dep_and_mod/foo/Nargo.toml b/test_programs/compile_failure/overlapping_dep_and_mod/foo/Nargo.toml
new file mode 100644
index 00000000000..857d4e722a8
--- /dev/null
+++ b/test_programs/compile_failure/overlapping_dep_and_mod/foo/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "foo"
+type = "lib"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
diff --git a/test_programs/compile_failure/overlapping_dep_and_mod/foo/src/lib.nr b/test_programs/compile_failure/overlapping_dep_and_mod/foo/src/lib.nr
new file mode 100644
index 00000000000..7834e2c9276
--- /dev/null
+++ b/test_programs/compile_failure/overlapping_dep_and_mod/foo/src/lib.nr
@@ -0,0 +1,3 @@
+pub fn baz() -> Field {
+    2
+}
diff --git a/test_programs/compile_failure/restricted_bit_sizes/src/main.nr b/test_programs/compile_failure/restricted_bit_sizes/src/main.nr
index 01e72bfcfd7..a3fea13cc3a 100644
--- a/test_programs/compile_failure/restricted_bit_sizes/src/main.nr
+++ b/test_programs/compile_failure/restricted_bit_sizes/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::assert_constant;
+use std::assert_constant;
 
 fn main() -> pub u63 {
     5
diff --git a/test_programs/compile_failure/turbofish_generic_count/src/main.nr b/test_programs/compile_failure/turbofish_generic_count/src/main.nr
index a360641fa15..4091b2f0581 100644
--- a/test_programs/compile_failure/turbofish_generic_count/src/main.nr
+++ b/test_programs/compile_failure/turbofish_generic_count/src/main.nr
@@ -1,4 +1,3 @@
-
 struct Bar<T> {
     one: Field,
     two: Field,
@@ -7,7 +6,7 @@ struct Bar<T> {
 
 impl<T> Bar<T> {
     fn zeroed<A>(_self: Self) -> A {
-        dep::std::unsafe::zeroed()
+        std::unsafe::zeroed()
     }
 }
 
diff --git a/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr b/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr
index 5446cfbb1e4..9b5d95c11bc 100644
--- a/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr
+++ b/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     //Regression for to_le_bits() constant evaluation 
     // binary array representation of u8 1
diff --git a/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr b/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr
index becd3c8927a..fa6be84c26e 100644
--- a/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr
+++ b/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr
@@ -1,14 +1,14 @@
 // Tests may be checked against https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve/tree/main/poc
-use dep::std::ec::tecurve::affine::Curve as AffineCurve;
-use dep::std::ec::tecurve::affine::Point as Gaffine;
-use dep::std::ec::tecurve::curvegroup::Curve;
-use dep::std::ec::tecurve::curvegroup::Point as G;
+use std::ec::tecurve::affine::Curve as AffineCurve;
+use std::ec::tecurve::affine::Point as Gaffine;
+use std::ec::tecurve::curvegroup::Curve;
+use std::ec::tecurve::curvegroup::Point as G;
 
-use dep::std::ec::swcurve::affine::Point as SWGaffine;
-use dep::std::ec::swcurve::curvegroup::Point as SWG;
+use std::ec::swcurve::affine::Point as SWGaffine;
+use std::ec::swcurve::curvegroup::Point as SWG;
 
-use dep::std::ec::montcurve::affine::Point as MGaffine;
-use dep::std::ec::montcurve::curvegroup::Point as MG;
+use std::ec::montcurve::affine::Point as MGaffine;
+use std::ec::montcurve::curvegroup::Point as MG;
 
 fn main() {
     // This test only makes sense if Field is the right prime field.
diff --git a/test_programs/compile_success_empty/intrinsic_die/src/main.nr b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
index a6c6d3df9a1..c6e269c155d 100644
--- a/test_programs/compile_success_empty/intrinsic_die/src/main.nr
+++ b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // This test checks that we perform dead-instruction-elimination on intrinsic functions.
 fn main(x: Field) {
     let hash = std::hash::pedersen_commitment([x]);
diff --git a/test_programs/compile_success_empty/method_call_regression/src/main.nr b/test_programs/compile_success_empty/method_call_regression/src/main.nr
index 8bb7ebcac45..88b8dc57196 100644
--- a/test_programs/compile_success_empty/method_call_regression/src/main.nr
+++ b/test_programs/compile_success_empty/method_call_regression/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     // s: Struct<?, ()>
     let s = Struct { b: () };
diff --git a/test_programs/compile_success_empty/overlapping_dep_and_mod/Nargo.toml b/test_programs/compile_success_empty/overlapping_dep_and_mod/Nargo.toml
new file mode 100644
index 00000000000..b2c3e5f94be
--- /dev/null
+++ b/test_programs/compile_success_empty/overlapping_dep_and_mod/Nargo.toml
@@ -0,0 +1,6 @@
+[workspace]
+members = [
+    "bin", 
+    "foo",
+]
+default-member = "bin"
diff --git a/test_programs/compile_success_empty/overlapping_dep_and_mod/bin/Nargo.toml b/test_programs/compile_success_empty/overlapping_dep_and_mod/bin/Nargo.toml
new file mode 100644
index 00000000000..57e704462db
--- /dev/null
+++ b/test_programs/compile_success_empty/overlapping_dep_and_mod/bin/Nargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "overlapping_dep_and_mod"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
+foo = { path = "../foo" }
diff --git a/test_programs/compile_success_empty/overlapping_dep_and_mod/bin/src/main.nr b/test_programs/compile_success_empty/overlapping_dep_and_mod/bin/src/main.nr
new file mode 100644
index 00000000000..1d9c917d91a
--- /dev/null
+++ b/test_programs/compile_success_empty/overlapping_dep_and_mod/bin/src/main.nr
@@ -0,0 +1,9 @@
+fn main() {
+    let _ = foo::bar() + dep::foo::baz();
+}
+
+mod foo {
+    pub(crate) fn bar() -> Field {
+        5
+    }
+}
diff --git a/test_programs/compile_success_empty/overlapping_dep_and_mod/foo/Nargo.toml b/test_programs/compile_success_empty/overlapping_dep_and_mod/foo/Nargo.toml
new file mode 100644
index 00000000000..857d4e722a8
--- /dev/null
+++ b/test_programs/compile_success_empty/overlapping_dep_and_mod/foo/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "foo"
+type = "lib"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/overlapping_dep_and_mod/foo/src/lib.nr b/test_programs/compile_success_empty/overlapping_dep_and_mod/foo/src/lib.nr
new file mode 100644
index 00000000000..cb8392ed275
--- /dev/null
+++ b/test_programs/compile_success_empty/overlapping_dep_and_mod/foo/src/lib.nr
@@ -0,0 +1,5 @@
+// foo/lib.nr
+
+pub fn baz() -> Field {
+    6
+}
diff --git a/test_programs/compile_success_empty/reexports/src/main.nr b/test_programs/compile_success_empty/reexports/src/main.nr
index ed469ff77d0..0fd65a33564 100644
--- a/test_programs/compile_success_empty/reexports/src/main.nr
+++ b/test_programs/compile_success_empty/reexports/src/main.nr
@@ -1,4 +1,4 @@
-use dep::reexporting_lib::{FooStruct, MyStruct, lib};
+use reexporting_lib::{FooStruct, MyStruct, lib};
 
 fn main() {
     let x: FooStruct = MyStruct { inner: 0 };
diff --git a/test_programs/compile_success_empty/regression_2099/src/main.nr b/test_programs/compile_success_empty/regression_2099/src/main.nr
index f92373ce63a..660f72f56e5 100644
--- a/test_programs/compile_success_empty/regression_2099/src/main.nr
+++ b/test_programs/compile_success_empty/regression_2099/src/main.nr
@@ -1,13 +1,13 @@
-use dep::std::ec::tecurve::affine::Curve as AffineCurve;
-use dep::std::ec::tecurve::affine::Point as Gaffine;
-use dep::std::ec::tecurve::curvegroup::Curve;
-use dep::std::ec::tecurve::curvegroup::Point as G;
+use std::ec::tecurve::affine::Curve as AffineCurve;
+use std::ec::tecurve::affine::Point as Gaffine;
+use std::ec::tecurve::curvegroup::Curve;
+use std::ec::tecurve::curvegroup::Point as G;
 
-use dep::std::ec::swcurve::affine::Point as SWGaffine;
-use dep::std::ec::swcurve::curvegroup::Point as SWG;
+use std::ec::swcurve::affine::Point as SWGaffine;
+use std::ec::swcurve::curvegroup::Point as SWG;
 
-use dep::std::ec::montcurve::affine::Point as MGaffine;
-use dep::std::ec::montcurve::curvegroup::Point as MG;
+use std::ec::montcurve::affine::Point as MGaffine;
+use std::ec::montcurve::curvegroup::Point as MG;
 
 fn main() {
     // Define Baby Jubjub (ERC-2494) parameters in affine representation
diff --git a/test_programs/compile_success_empty/regression_3635/src/main.nr b/test_programs/compile_success_empty/regression_3635/src/main.nr
index 97a04f9d93f..edc6d8690e8 100644
--- a/test_programs/compile_success_empty/regression_3635/src/main.nr
+++ b/test_programs/compile_success_empty/regression_3635/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     let x: u8 = 0x61;
     let y: u8 = "a".as_bytes()[0];
diff --git a/test_programs/compile_success_empty/str_as_bytes/src/main.nr b/test_programs/compile_success_empty/str_as_bytes/src/main.nr
index 6fdd926ce7f..1330924e501 100644
--- a/test_programs/compile_success_empty/str_as_bytes/src/main.nr
+++ b/test_programs/compile_success_empty/str_as_bytes/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 fn main() {
     let a = "hello";
     let b = a.as_bytes();
diff --git a/test_programs/compile_success_empty/trait_default_implementation/src/main.nr b/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
index 2f5bff8c40c..90c375b6010 100644
--- a/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
+++ b/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 trait MyDefault {
     fn my_default(x: Field, y: Field) -> Self;
 
diff --git a/test_programs/compile_success_empty/trait_override_implementation/src/main.nr b/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
index 85528291870..21d89b1b261 100644
--- a/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
+++ b/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 trait MyDefault {
     fn my_default(x: Field, y: Field) -> Self;
 
diff --git a/test_programs/compile_success_empty/traits/src/main.nr b/test_programs/compile_success_empty/traits/src/main.nr
index ed804559fed..0a5644e7530 100644
--- a/test_programs/compile_success_empty/traits/src/main.nr
+++ b/test_programs/compile_success_empty/traits/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 trait MyDefault {
     fn my_default(x: Field, y: Field) -> Self;
 }
diff --git a/test_programs/compile_success_empty/vectors/src/main.nr b/test_programs/compile_success_empty/vectors/src/main.nr
index d105ceed180..ac02a4691dd 100644
--- a/test_programs/compile_success_empty/vectors/src/main.nr
+++ b/test_programs/compile_success_empty/vectors/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::collections::vec::Vec;
+use std::collections::vec::Vec;
 
 fn main(x: Field, y: pub Field) {
     let mut vector = Vec::new();
diff --git a/test_programs/compile_success_empty/workspace_reexport_bug/binary/src/main.nr b/test_programs/compile_success_empty/workspace_reexport_bug/binary/src/main.nr
index ab0ae9a48b8..a4207794a8a 100644
--- a/test_programs/compile_success_empty/workspace_reexport_bug/binary/src/main.nr
+++ b/test_programs/compile_success_empty/workspace_reexport_bug/binary/src/main.nr
@@ -1,2 +1,2 @@
-use dep::library::ReExportMeFromAnotherLib;
+use library::ReExportMeFromAnotherLib;
 fn main(_x: ReExportMeFromAnotherLib) {}
diff --git a/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr b/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr
index 8e84662ed03..e3a1539ea65 100644
--- a/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr
+++ b/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr
@@ -1,2 +1,2 @@
 // Re-export 
-use dep::library2::ReExportMeFromAnotherLib;
+use library2::ReExportMeFromAnotherLib;
diff --git a/test_programs/execution_failure/div_by_zero_constants/src/main.nr b/test_programs/execution_failure/div_by_zero_constants/src/main.nr
index 58adc5444b1..f90b3ef9429 100644
--- a/test_programs/execution_failure/div_by_zero_constants/src/main.nr
+++ b/test_programs/execution_failure/div_by_zero_constants/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     let a: Field = 3 / 0;
     std::println(a);
diff --git a/test_programs/execution_failure/div_by_zero_numerator_witness/src/main.nr b/test_programs/execution_failure/div_by_zero_numerator_witness/src/main.nr
index f51b26d5ba1..012e823b297 100644
--- a/test_programs/execution_failure/div_by_zero_numerator_witness/src/main.nr
+++ b/test_programs/execution_failure/div_by_zero_numerator_witness/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(x: Field) {
     let a: Field = x / 0;
     std::println(a);
diff --git a/test_programs/execution_failure/div_by_zero_witness/src/main.nr b/test_programs/execution_failure/div_by_zero_witness/src/main.nr
index a814f88f320..eaa3c1f2a72 100644
--- a/test_programs/execution_failure/div_by_zero_witness/src/main.nr
+++ b/test_programs/execution_failure/div_by_zero_witness/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // It is expected that `y` must be equal to 0.
 fn main(x: Field, y: pub Field) {
     let a: Field = x / y;
diff --git a/test_programs/execution_failure/hashmap_load_factor/src/main.nr b/test_programs/execution_failure/hashmap_load_factor/src/main.nr
index 907c3628142..e95da67a084 100644
--- a/test_programs/execution_failure/hashmap_load_factor/src/main.nr
+++ b/test_programs/execution_failure/hashmap_load_factor/src/main.nr
@@ -1,6 +1,6 @@
-use dep::std::collections::map::HashMap;
-use dep::std::hash::BuildHasherDefault;
-use dep::std::hash::poseidon2::Poseidon2Hasher;
+use std::collections::map::HashMap;
+use std::hash::BuildHasherDefault;
+use std::hash::poseidon2::Poseidon2Hasher;
 
 struct Entry{
     key: Field,
diff --git a/test_programs/execution_success/4_sub/src/main.nr b/test_programs/execution_success/4_sub/src/main.nr
index 6aef8e7b208..2b4fc395705 100644
--- a/test_programs/execution_success/4_sub/src/main.nr
+++ b/test_programs/execution_success/4_sub/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Test unsafe integer subtraction with underflow: 12 - 2418266113 = 1876701195 modulo 2^32
 fn main(mut x: u32, y: u32, z: u32) {
     x = std::wrapping_sub(x,y);
diff --git a/test_programs/execution_success/5_over/src/main.nr b/test_programs/execution_success/5_over/src/main.nr
index 313d580a8d1..6c4153e4b49 100644
--- a/test_programs/execution_success/5_over/src/main.nr
+++ b/test_programs/execution_success/5_over/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Test unsafe integer arithmetic
 // Test odd bits integer
 fn main(mut x: u32, y: u32) {
diff --git a/test_programs/execution_success/6/src/main.nr b/test_programs/execution_success/6/src/main.nr
index 5ecb809e68b..8657199bd7f 100644
--- a/test_programs/execution_success/6/src/main.nr
+++ b/test_programs/execution_success/6/src/main.nr
@@ -5,7 +5,6 @@
 // If you do not cast, it will take all the bytes from the field element!
 // Mimc input is an array of field elements
 // The function is called mimc_bn254 to emphasize its parameters are chosen for bn254 curve, it should be used only with a proving system using the same curve (e.g Plonk from Aztec)
-use dep::std;
 
 fn main(x: [u8; 5], result: pub [u8; 32]) {
     let mut digest = std::hash::sha256(x);
diff --git a/test_programs/execution_success/6_array/src/main.nr b/test_programs/execution_success/6_array/src/main.nr
index 6aa05f58b71..d7180c260ff 100644
--- a/test_programs/execution_success/6_array/src/main.nr
+++ b/test_programs/execution_success/6_array/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 //Basic tests for arrays
 fn main(x: [u32; 5], y: [u32; 5], mut z: u32, t: u32) {
     let mut c = 2301;
diff --git a/test_programs/execution_success/7/src/main.nr b/test_programs/execution_success/7/src/main.nr
index a6bba978644..ad3fe1aadc8 100644
--- a/test_programs/execution_success/7/src/main.nr
+++ b/test_programs/execution_success/7/src/main.nr
@@ -2,7 +2,6 @@
 //
 // Pre-alpha dependencies must now be prefixed with the word "dep".
 // The line below indicates that we would like to pull in the standard library dependency.
-use dep::std;
 
 fn main(x: [u8; 5], result: [u8; 32]) {
     let digest = std::hash::blake2s(x);
diff --git a/test_programs/execution_success/aes128_encrypt/src/main.nr b/test_programs/execution_success/aes128_encrypt/src/main.nr
index f6ed0f309c3..cd7fb4772e2 100644
--- a/test_programs/execution_success/aes128_encrypt/src/main.nr
+++ b/test_programs/execution_success/aes128_encrypt/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 unconstrained fn decode_ascii(ascii: u8) -> u8 {
     if ascii < 58 {
         ascii - 48
diff --git a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
index 4cbf1bd8e6d..260d609928b 100644
--- a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
+++ b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
@@ -18,7 +18,7 @@ fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {
             hash_input[j + b] = path[offset + j];
         }
 
-        current = dep::std::hash::sha256(hash_input);
+        current = std::hash::sha256(hash_input);
         index = index >> 1;
     }
 
diff --git a/test_programs/execution_success/array_dynamic_nested_blackbox_input/src/main.nr b/test_programs/execution_success/array_dynamic_nested_blackbox_input/src/main.nr
index 8faaf69dfc8..15a2747eaa9 100644
--- a/test_programs/execution_success/array_dynamic_nested_blackbox_input/src/main.nr
+++ b/test_programs/execution_success/array_dynamic_nested_blackbox_input/src/main.nr
@@ -15,6 +15,6 @@ fn main(mut x: [Foo; 3], y: pub Field, hash_result: pub [u8; 32]) {
     // Make sure that we are passing a dynamic array to the black box function call
     // by setting the array using a dynamic index here
     hash_input[y - 1] = 0;
-    let hash = dep::std::hash::sha256(hash_input);
+    let hash = std::hash::sha256(hash_input);
     assert_eq(hash, hash_result);
 }
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index c454c2b66cd..9385b39e847 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -1,5 +1,5 @@
-use dep::std::bigint;
-use dep::std::{bigint::Secpk1Fq, println};
+use std::bigint;
+use std::{bigint::Secpk1Fq, println};
 
 fn main(mut x: [u8; 5], y: [u8; 5]) {
     let a = bigint::Secpk1Fq::from_le_bytes(&[x[0], x[1], x[2], x[3], x[4]]);
@@ -10,8 +10,8 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
         a_be_bytes[31-i] = x[i];
         b_be_bytes[31-i] = y[i];
     }
-    let a_field = dep::std::field::bytes32_to_field(a_be_bytes);
-    let b_field = dep::std::field::bytes32_to_field(b_be_bytes);
+    let a_field = std::field::bytes32_to_field(a_be_bytes);
+    let b_field = std::field::bytes32_to_field(b_be_bytes);
 
     // Regression for issue #4682
     let c = if x[0] != 0 {
@@ -19,7 +19,7 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     } else {
         test_unconstrained2(a, b)
     };
-    assert(c.array[0] == dep::std::wrapping_mul(x[0], y[0]));
+    assert(c.array[0] == std::wrapping_mul(x[0], y[0]));
 
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
diff --git a/test_programs/execution_success/blake3/src/main.nr b/test_programs/execution_success/blake3/src/main.nr
index 3bfea6c5f95..fb056bfa848 100644
--- a/test_programs/execution_success/blake3/src/main.nr
+++ b/test_programs/execution_success/blake3/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(x: [u8; 5], result: [u8; 32]) {
     let digest = std::hash::blake3(x);
     assert(digest == result);
diff --git a/test_programs/execution_success/brillig_blake2s/src/main.nr b/test_programs/execution_success/brillig_blake2s/src/main.nr
index 5bd52666ae9..2743e02e920 100644
--- a/test_programs/execution_success/brillig_blake2s/src/main.nr
+++ b/test_programs/execution_success/brillig_blake2s/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Tests a very simple program.
 // 
 // The features being tested is blake2s in brillig
diff --git a/test_programs/execution_success/brillig_blake3/src/main.nr b/test_programs/execution_success/brillig_blake3/src/main.nr
index 05a5b31f936..64852d775f4 100644
--- a/test_programs/execution_success/brillig_blake3/src/main.nr
+++ b/test_programs/execution_success/brillig_blake3/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 unconstrained fn main(x: [u8; 5], result: [u8; 32]) {
     let digest = std::hash::blake3(x);
     assert(digest == result);
diff --git a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
index 142290ecbe2..2809668c574 100644
--- a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
+++ b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
@@ -38,11 +38,11 @@ struct Outer {
 // If we don't take into account block parameter liveness, this function will need 5*500=2500 stack items
 unconstrained fn main(conditions: [bool; 5]) -> pub Outer {
     let out0 = if conditions[0] {
-        let mut outer: Outer = dep::std::unsafe::zeroed();
+        let mut outer: Outer = std::unsafe::zeroed();
         outer.middle_a.inner_a.a = 1;
         outer
     } else {
-        let mut outer: Outer= dep::std::unsafe::zeroed();
+        let mut outer: Outer= std::unsafe::zeroed();
         outer.middle_f.inner_c.d = 2;
         outer
     };
diff --git a/test_programs/execution_success/brillig_cow_regression/src/main.nr b/test_programs/execution_success/brillig_cow_regression/src/main.nr
index 1cae9b1ba41..7cd50860978 100644
--- a/test_programs/execution_success/brillig_cow_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_regression/src/main.nr
@@ -25,7 +25,7 @@ struct NewContractData {
 
 impl NewContractData {
     fn hash(self) -> Field {
-        dep::std::hash::pedersen_hash([self.contract_address, self.portal_contract_address])
+        std::hash::pedersen_hash([self.contract_address, self.portal_contract_address])
     }
 }
 
@@ -173,6 +173,6 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA
         }
     }
 
-    let sha_digest = dep::std::hash::sha256(hash_input_flattened);
+    let sha_digest = std::hash::sha256(hash_input_flattened);
     U256::from_bytes32(sha_digest).to_u128_limbs()
 }
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
index 5d84d885567..78343dcd26c 100644
--- a/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Tests a very simple program.
 // 
 // The features being tested is ecdsa in brillig
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
index 9da07f531aa..48debadb012 100644
--- a/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
+++ b/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Tests a very simple program.
 // 
 // The features being tested is ecdsa in brillig
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index 9248bff2f4c..1476c447431 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 struct MyStruct {
     operation: fn (u32) -> u32,
 }
diff --git a/test_programs/execution_success/brillig_hash_to_field/src/main.nr b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
index 53ed85b3ddd..78759bd84c6 100644
--- a/test_programs/execution_success/brillig_hash_to_field/src/main.nr
+++ b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Tests a very simple program.
 // 
 // The features being tested is hash_to_field in brillig
diff --git a/test_programs/execution_success/brillig_keccak/src/main.nr b/test_programs/execution_success/brillig_keccak/src/main.nr
index a300bc18279..9150e38f208 100644
--- a/test_programs/execution_success/brillig_keccak/src/main.nr
+++ b/test_programs/execution_success/brillig_keccak/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Tests a very simple program.
 // 
 // The features being tested is keccak256 in brillig
diff --git a/test_programs/execution_success/brillig_oracle/src/main.nr b/test_programs/execution_success/brillig_oracle/src/main.nr
index 6a9e5806621..0305cb06978 100644
--- a/test_programs/execution_success/brillig_oracle/src/main.nr
+++ b/test_programs/execution_success/brillig_oracle/src/main.nr
@@ -1,5 +1,5 @@
-use dep::std::slice;
-use dep::std::test::OracleMock;
+use std::slice;
+use std::test::OracleMock;
 
 // Tests oracle usage in brillig/unconstrained functions
 fn main(_x: Field) {
diff --git a/test_programs/execution_success/brillig_pedersen/src/main.nr b/test_programs/execution_success/brillig_pedersen/src/main.nr
index 2379818c454..17c79f9d0ae 100644
--- a/test_programs/execution_success/brillig_pedersen/src/main.nr
+++ b/test_programs/execution_success/brillig_pedersen/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 unconstrained fn main(x: Field, y: Field, salt: Field, out_x: Field, out_y: Field, out_hash: Field) {
     let res = std::hash::pedersen_commitment_with_separator([x, y], 0);
     assert(res.x == out_x);
diff --git a/test_programs/execution_success/brillig_sha256/src/main.nr b/test_programs/execution_success/brillig_sha256/src/main.nr
index e76109df9c3..fcc01978a0a 100644
--- a/test_programs/execution_success/brillig_sha256/src/main.nr
+++ b/test_programs/execution_success/brillig_sha256/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Tests a very simple program.
 // 
 // The features being tested is sha256 in brillig
diff --git a/test_programs/execution_success/brillig_slices/src/main.nr b/test_programs/execution_success/brillig_slices/src/main.nr
index 2cf1850f151..89f838a3a57 100644
--- a/test_programs/execution_success/brillig_slices/src/main.nr
+++ b/test_programs/execution_success/brillig_slices/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::slice;
+use std::slice;
 unconstrained fn main(x: Field, y: Field) {
     let mut slice: [Field] = &[y, x];
     assert(slice.len() == 2);
diff --git a/test_programs/execution_success/conditional_1/src/main.nr b/test_programs/execution_success/conditional_1/src/main.nr
index 5064c82bce9..e7d780263b8 100644
--- a/test_programs/execution_success/conditional_1/src/main.nr
+++ b/test_programs/execution_success/conditional_1/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn sort(mut a: [u32; 4]) -> [u32; 4] {
     for i in 1..4 {
         for j in 0..i {
diff --git a/test_programs/execution_success/conditional_2/src/main.nr b/test_programs/execution_success/conditional_2/src/main.nr
index 5b3f64f6be5..ea23ec3cf3b 100644
--- a/test_programs/execution_success/conditional_2/src/main.nr
+++ b/test_programs/execution_success/conditional_2/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn must_be_zero(x: u8) {
     assert(x == 0);
 }
diff --git a/test_programs/execution_success/conditional_regression_short_circuit/src/main.nr b/test_programs/execution_success/conditional_regression_short_circuit/src/main.nr
index d260fa49dc3..de5ad20a642 100644
--- a/test_programs/execution_success/conditional_regression_short_circuit/src/main.nr
+++ b/test_programs/execution_success/conditional_regression_short_circuit/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {
     //regression for short-circuit2
     if 35 == a {
diff --git a/test_programs/execution_success/databus/src/main.nr b/test_programs/execution_success/databus/src/main.nr
index 1cf95be8a22..7e5c23d508d 100644
--- a/test_programs/execution_success/databus/src/main.nr
+++ b/test_programs/execution_success/databus/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(mut x: u32, y: call_data u32, z: call_data [u32; 4]) -> return_data u32 {
     let a = z[x];
     a + foo(y)
diff --git a/test_programs/execution_success/diamond_deps_0/src/main.nr b/test_programs/execution_success/diamond_deps_0/src/main.nr
index ca95c6e0aa8..690d6fc9fc8 100644
--- a/test_programs/execution_success/diamond_deps_0/src/main.nr
+++ b/test_programs/execution_success/diamond_deps_0/src/main.nr
@@ -1,6 +1,6 @@
-use dep::dep1::call_dep1_then_dep2;
-use dep::dep2::call_dep2;
-use dep::dep2::RESOLVE_THIS;
+use dep1::call_dep1_then_dep2;
+use dep2::call_dep2;
+use dep2::RESOLVE_THIS;
 
 fn main(x: Field, y: pub Field) -> pub Field {
     call_dep1_then_dep2(x, y) + call_dep2(x, y) + RESOLVE_THIS
diff --git a/test_programs/execution_success/double_verify_nested_proof/src/main.nr b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
index 95d4b6f6995..5f0eb1a5b53 100644
--- a/test_programs/execution_success/double_verify_nested_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 
 // This circuit aggregates two recursive proofs from `double_verify_proof_recursive`.
 // Recursive aggregation is a backend-specific process and it is expected for backends 
diff --git a/test_programs/execution_success/double_verify_proof/src/main.nr b/test_programs/execution_success/double_verify_proof/src/main.nr
index d832ce0f049..d3b909c3fa4 100644
--- a/test_programs/execution_success/double_verify_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 
 // This circuit aggregates two proofs from `assert_statement_recursive`.
 fn main(
diff --git a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
index 86b4971c3a6..2555bbc4758 100644
--- a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 
 // This circuit aggregates two proofs from `assert_statement_recursive`.
 #[recursive]
diff --git a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
index ac0359e4bb8..7f0999fc360 100644
--- a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(
     message: [u8; 38],
     hashed_message: [u8; 32],
diff --git a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
index c64e390d652..09f427c37d9 100644
--- a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
diff --git a/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
index e7a6be9d47a..b5bd633915f 100644
--- a/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(
     hashed_message: [u8; 32],
     pub_key_x: [u8; 32],
diff --git a/test_programs/execution_success/eddsa/src/main.nr b/test_programs/execution_success/eddsa/src/main.nr
index ada15d5405c..407ca049806 100644
--- a/test_programs/execution_success/eddsa/src/main.nr
+++ b/test_programs/execution_success/eddsa/src/main.nr
@@ -1,9 +1,9 @@
-use dep::std::compat;
-use dep::std::ec::consts::te::baby_jubjub;
-use dep::std::ec::tecurve::affine::Point as TEPoint;
-use dep::std::hash;
-use dep::std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify};
-use dep::std::hash::poseidon2::Poseidon2Hasher;
+use std::compat;
+use std::ec::consts::te::baby_jubjub;
+use std::ec::tecurve::affine::Point as TEPoint;
+use std::hash;
+use std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify};
+use std::hash::poseidon2::Poseidon2Hasher;
 
 fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
     // Skip this test for non-bn254 backends
diff --git a/test_programs/execution_success/embedded_curve_ops/src/main.nr b/test_programs/execution_success/embedded_curve_ops/src/main.nr
index 46f919e947a..4eeda39c6aa 100644
--- a/test_programs/execution_success/embedded_curve_ops/src/main.nr
+++ b/test_programs/execution_success/embedded_curve_ops/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
     let g1_y = 17631683881184975370165255887551781615748388533673675138860;
     let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y, is_infinite: false };
diff --git a/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr b/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
index f9f3e75789b..7d12d63634b 100644
--- a/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
+++ b/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
+use std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
 
 global NUM_HASHES = 2;
 global HASH_LENGTH = 10;
diff --git a/test_programs/execution_success/generics/src/main.nr b/test_programs/execution_success/generics/src/main.nr
index c8616960559..f754fb96292 100644
--- a/test_programs/execution_success/generics/src/main.nr
+++ b/test_programs/execution_success/generics/src/main.nr
@@ -34,7 +34,7 @@ impl Bar<Field> {
 impl<T> Bar<T> {
     // This is to test that we can use turbofish on methods as well
     fn zeroed<A>(_self: Self) -> A {
-        dep::std::unsafe::zeroed()
+        std::unsafe::zeroed()
     }
 }
 
diff --git a/test_programs/execution_success/hash_to_field/src/main.nr b/test_programs/execution_success/hash_to_field/src/main.nr
index 242b5ecbc18..bb4f829ec33 100644
--- a/test_programs/execution_success/hash_to_field/src/main.nr
+++ b/test_programs/execution_success/hash_to_field/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(input: Field) -> pub Field {
     std::hash::hash_to_field(&[input])
 }
diff --git a/test_programs/execution_success/hashmap/src/main.nr b/test_programs/execution_success/hashmap/src/main.nr
index 76daa594a89..8cf70cc5970 100644
--- a/test_programs/execution_success/hashmap/src/main.nr
+++ b/test_programs/execution_success/hashmap/src/main.nr
@@ -1,9 +1,9 @@
 mod utils;
 
-use dep::std::collections::map::HashMap;
-use dep::std::hash::BuildHasherDefault;
-use dep::std::hash::poseidon2::Poseidon2Hasher;
-use dep::std::cmp::Eq;
+use std::collections::map::HashMap;
+use std::hash::BuildHasherDefault;
+use std::hash::poseidon2::Poseidon2Hasher;
+use std::cmp::Eq;
 
 use utils::cut;
 
diff --git a/test_programs/execution_success/import/src/main.nr b/test_programs/execution_success/import/src/main.nr
index 7dcc16fed16..0f5aa7e5460 100644
--- a/test_programs/execution_success/import/src/main.nr
+++ b/test_programs/execution_success/import/src/main.nr
@@ -2,7 +2,7 @@ mod import;
 use crate::import::hello;
 
 fn main(x: Field, y: Field) {
-    let _k = dep::std::hash::pedersen_commitment([x]);
+    let _k = std::hash::pedersen_commitment([x]);
     let _l = hello(x);
 
     assert(x != import::hello(y));
diff --git a/test_programs/execution_success/is_unconstrained/src/main.nr b/test_programs/execution_success/is_unconstrained/src/main.nr
index af40af1029f..ddafc73c598 100644
--- a/test_programs/execution_success/is_unconstrained/src/main.nr
+++ b/test_programs/execution_success/is_unconstrained/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::runtime::is_unconstrained;
+use std::runtime::is_unconstrained;
 
 fn check(should_be_unconstrained: bool) {
     assert_eq(should_be_unconstrained, is_unconstrained());
diff --git a/test_programs/execution_success/keccak256/src/main.nr b/test_programs/execution_success/keccak256/src/main.nr
index eb401fe614c..ff18cae0c9c 100644
--- a/test_programs/execution_success/keccak256/src/main.nr
+++ b/test_programs/execution_success/keccak256/src/main.nr
@@ -1,5 +1,4 @@
 // docs:start:keccak256
-use dep::std;
 
 fn main(x: Field, result: [u8; 32]) {
     // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
diff --git a/test_programs/execution_success/merkle_insert/src/main.nr b/test_programs/execution_success/merkle_insert/src/main.nr
index ac9a7b34ea3..a08088e847b 100644
--- a/test_programs/execution_success/merkle_insert/src/main.nr
+++ b/test_programs/execution_success/merkle_insert/src/main.nr
@@ -1,5 +1,4 @@
-use dep::std;
-use dep::std::hash::mimc;
+use std::hash::mimc;
 
 fn main(
     old_root: Field,
diff --git a/test_programs/execution_success/modulus/src/main.nr b/test_programs/execution_success/modulus/src/main.nr
index 35f63fdc8c5..c7d6a2e2c7d 100644
--- a/test_programs/execution_success/modulus/src/main.nr
+++ b/test_programs/execution_success/modulus/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(bn254_modulus_be_bytes: [u8; 32], bn254_modulus_be_bits: [u1; 254]) {
     let modulus_size = std::field::modulus_num_bits();
     // NOTE: The constraints used in this circuit will only work when testing nargo with the plonk bn254 backend
diff --git a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
index dcb5e6bc5ca..94db8c2b414 100644
--- a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
+++ b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
+use std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
 
 global NUM_HASHES = 2;
 global HASH_LENGTH = 10;
diff --git a/test_programs/execution_success/operator_overloading/src/main.nr b/test_programs/execution_success/operator_overloading/src/main.nr
index 3956ea5c577..c2c831d0c1e 100644
--- a/test_programs/execution_success/operator_overloading/src/main.nr
+++ b/test_programs/execution_success/operator_overloading/src/main.nr
@@ -1,5 +1,5 @@
-use dep::std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr};
-use dep::std::cmp::Ordering;
+use std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr};
+use std::cmp::Ordering;
 
 // x = 3, y = 9
 fn main(x: u32, y: u32) {
diff --git a/test_programs/execution_success/overlapping_dep_and_mod/Nargo.toml b/test_programs/execution_success/overlapping_dep_and_mod/Nargo.toml
new file mode 100644
index 00000000000..b2c3e5f94be
--- /dev/null
+++ b/test_programs/execution_success/overlapping_dep_and_mod/Nargo.toml
@@ -0,0 +1,6 @@
+[workspace]
+members = [
+    "bin", 
+    "foo",
+]
+default-member = "bin"
diff --git a/test_programs/execution_success/overlapping_dep_and_mod/bin/Nargo.toml b/test_programs/execution_success/overlapping_dep_and_mod/bin/Nargo.toml
new file mode 100644
index 00000000000..57e704462db
--- /dev/null
+++ b/test_programs/execution_success/overlapping_dep_and_mod/bin/Nargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "overlapping_dep_and_mod"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
+foo = { path = "../foo" }
diff --git a/test_programs/execution_success/overlapping_dep_and_mod/bin/Prover.toml b/test_programs/execution_success/overlapping_dep_and_mod/bin/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/execution_success/overlapping_dep_and_mod/bin/src/main.nr b/test_programs/execution_success/overlapping_dep_and_mod/bin/src/main.nr
new file mode 100644
index 00000000000..16c940f12fc
--- /dev/null
+++ b/test_programs/execution_success/overlapping_dep_and_mod/bin/src/main.nr
@@ -0,0 +1,14 @@
+// bin/main.nr
+
+fn main() -> pub Field {
+    assert(foo::bar() + dep::foo::bar() == 11);
+    assert(foo::bar() == 5);
+    assert(dep::foo::bar() == 6);
+    foo::bar() + dep::foo::bar()
+}
+
+mod foo {
+    pub(crate) fn bar() -> Field {
+        5
+    }
+}
diff --git a/test_programs/execution_success/overlapping_dep_and_mod/foo/Nargo.toml b/test_programs/execution_success/overlapping_dep_and_mod/foo/Nargo.toml
new file mode 100644
index 00000000000..857d4e722a8
--- /dev/null
+++ b/test_programs/execution_success/overlapping_dep_and_mod/foo/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "foo"
+type = "lib"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/overlapping_dep_and_mod/foo/src/lib.nr b/test_programs/execution_success/overlapping_dep_and_mod/foo/src/lib.nr
new file mode 100644
index 00000000000..09283defed7
--- /dev/null
+++ b/test_programs/execution_success/overlapping_dep_and_mod/foo/src/lib.nr
@@ -0,0 +1,5 @@
+// foo/lib.nr
+
+pub fn bar() -> Field {
+    6
+}
diff --git a/test_programs/execution_success/pedersen_check/src/main.nr b/test_programs/execution_success/pedersen_check/src/main.nr
index 90ef218249b..c71b2b570da 100644
--- a/test_programs/execution_success/pedersen_check/src/main.nr
+++ b/test_programs/execution_success/pedersen_check/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(x: Field, y: Field, salt: Field, out_x: Field, out_y: Field, out_hash: Field) {
     let res = std::hash::pedersen_commitment([x, y]);
     assert(res.x == out_x);
diff --git a/test_programs/execution_success/pedersen_commitment/src/main.nr b/test_programs/execution_success/pedersen_commitment/src/main.nr
index a3a9aea1cf0..81c605a64dd 100644
--- a/test_programs/execution_success/pedersen_commitment/src/main.nr
+++ b/test_programs/execution_success/pedersen_commitment/src/main.nr
@@ -1,5 +1,4 @@
 // docs:start:pedersen-commitment
-use dep::std;
 
 fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
     let commitment = std::hash::pedersen_commitment([x, y]);
diff --git a/test_programs/execution_success/pedersen_hash/src/main.nr b/test_programs/execution_success/pedersen_hash/src/main.nr
index 20c7de12d6c..f8ec56a9d98 100644
--- a/test_programs/execution_success/pedersen_hash/src/main.nr
+++ b/test_programs/execution_success/pedersen_hash/src/main.nr
@@ -1,5 +1,4 @@
 // docs:start:pedersen-hash
-use dep::std;
 
 fn main(x: Field, y: Field, expected_hash: Field) {
     let hash = std::hash::pedersen_hash([x, y]);
diff --git a/test_programs/execution_success/poseidon_bn254_hash/src/main.nr b/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
index a1607956190..cf1c190e5c9 100644
--- a/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
+++ b/test_programs/execution_success/poseidon_bn254_hash/src/main.nr
@@ -1,6 +1,6 @@
 // docs:start:poseidon
-use dep::std::hash::poseidon;
-use dep::std::hash::poseidon2;
+use std::hash::poseidon;
+use std::hash::poseidon2;
 
 fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
     let hash1 = poseidon::bn254::hash_2(x1);
diff --git a/test_programs/execution_success/poseidonsponge_x5_254/src/main.nr b/test_programs/execution_success/poseidonsponge_x5_254/src/main.nr
index 910a17c8c89..137f3e5d2a6 100644
--- a/test_programs/execution_success/poseidonsponge_x5_254/src/main.nr
+++ b/test_programs/execution_success/poseidonsponge_x5_254/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash::poseidon;
+use std::hash::poseidon;
 
 fn main(x: [Field; 7]) {
     // Test optimized sponge
diff --git a/test_programs/execution_success/prelude/src/main.nr b/test_programs/execution_success/prelude/src/main.nr
index 226341f1e7b..4fe6080222e 100644
--- a/test_programs/execution_success/prelude/src/main.nr
+++ b/test_programs/execution_success/prelude/src/main.nr
@@ -8,8 +8,8 @@ fn main() {
 
 mod a {
     // We don't want to give an error due to re-importing elements that are already in the prelude.
-    use dep::std::collections::vec::Vec;
-    use dep::std::option::Option;
+    use std::collections::vec::Vec;
+    use std::option::Option;
 
     fn main() {
         let _xs = Vec::new();
diff --git a/test_programs/execution_success/regression_3051/src/main.nr b/test_programs/execution_success/regression_3051/src/main.nr
index 2e7d10fd7b0..90eb652db7a 100644
--- a/test_programs/execution_success/regression_3051/src/main.nr
+++ b/test_programs/execution_success/regression_3051/src/main.nr
@@ -19,6 +19,6 @@ impl Bar for u64 {
 }
 
 fn main() {
-    dep::std::println(1.foo());
-    dep::std::println(1.bar());
+    std::println(1.foo());
+    std::println(1.bar());
 }
diff --git a/test_programs/execution_success/regression_3394/src/main.nr b/test_programs/execution_success/regression_3394/src/main.nr
index 94b6c818ff2..59494253757 100644
--- a/test_programs/execution_success/regression_3394/src/main.nr
+++ b/test_programs/execution_success/regression_3394/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     let x : i8 = -128;
     std::println(x);
diff --git a/test_programs/execution_success/regression_4124/src/main.nr b/test_programs/execution_success/regression_4124/src/main.nr
index 49ff68ee6ad..2b0e65a0b6c 100644
--- a/test_programs/execution_success/regression_4124/src/main.nr
+++ b/test_programs/execution_success/regression_4124/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::option::Option;
+use std::option::Option;
 
 trait MyDeserialize<N> {
     fn deserialize(fields: [Field; N]) -> Self;
@@ -11,7 +11,7 @@ impl MyDeserialize<1> for Field {
 }
 
 pub fn storage_read<N>() -> [Field; N] {
-    dep::std::unsafe::zeroed()
+    std::unsafe::zeroed()
 }
 
 struct PublicMutable<T> {
diff --git a/test_programs/execution_success/regression_4449/src/main.nr b/test_programs/execution_success/regression_4449/src/main.nr
index 454a93f5d1a..66bab2e09f4 100644
--- a/test_programs/execution_success/regression_4449/src/main.nr
+++ b/test_programs/execution_success/regression_4449/src/main.nr
@@ -1,5 +1,4 @@
 // Regression test for issue #4449
-use dep::std;
 
 fn main(x: u8, result: [u8; 32]) {
     let x = x % 31;
diff --git a/test_programs/execution_success/regression_5045/src/main.nr b/test_programs/execution_success/regression_5045/src/main.nr
index 015fb1b2555..cf39b2f97e4 100644
--- a/test_programs/execution_success/regression_5045/src/main.nr
+++ b/test_programs/execution_success/regression_5045/src/main.nr
@@ -1,5 +1,5 @@
-use dep::std::embedded_curve_ops::EmbeddedCurvePoint;
-use dep::std::embedded_curve_ops::EmbeddedCurveScalar;
+use std::embedded_curve_ops::EmbeddedCurvePoint;
+use std::embedded_curve_ops::EmbeddedCurveScalar;
 
 fn main(is_active: bool) {
     let a = EmbeddedCurvePoint {
@@ -11,7 +11,7 @@ fn main(is_active: bool) {
     if is_active {
         let bad = EmbeddedCurvePoint { x: 0, y: 5, is_infinite: false };
         let d = bad.double();
-        let e = dep::std::embedded_curve_ops::multi_scalar_mul(
+        let e = std::embedded_curve_ops::multi_scalar_mul(
             [a, bad],
             [EmbeddedCurveScalar { lo: 1, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
         );
diff --git a/test_programs/execution_success/regression_5202/src/main.nr b/test_programs/execution_success/regression_5202/src/main.nr
index e41b760b83e..2ebfd7890ba 100644
--- a/test_programs/execution_success/regression_5202/src/main.nr
+++ b/test_programs/execution_success/regression_5202/src/main.nr
@@ -1,4 +1,4 @@
-use dep::fraction::{Fraction, MAX, floor, toFraction, addFraction};
+use fraction::{Fraction, MAX, floor, toFraction, addFraction};
 
 fn main() {
     let g1 = toFraction(true, 33333333, 5);
diff --git a/test_programs/execution_success/regression_5252/src/main.nr b/test_programs/execution_success/regression_5252/src/main.nr
index 315807c3396..0bfd596a777 100644
--- a/test_programs/execution_success/regression_5252/src/main.nr
+++ b/test_programs/execution_success/regression_5252/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::hash::{mimc, poseidon, poseidon2::Poseidon2};
+use std::hash::{mimc, poseidon, poseidon2::Poseidon2};
 
 global NUM_HASHES = 3;
 global HASH_LENGTH = 20;
diff --git a/test_programs/execution_success/regression_method_cannot_be_found/src/main.nr b/test_programs/execution_success/regression_method_cannot_be_found/src/main.nr
index 1a6931a6870..c7db543f1bb 100644
--- a/test_programs/execution_success/regression_method_cannot_be_found/src/main.nr
+++ b/test_programs/execution_success/regression_method_cannot_be_found/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 struct Item {
     id: Field,
 }
diff --git a/test_programs/execution_success/schnorr/src/main.nr b/test_programs/execution_success/schnorr/src/main.nr
index 1067d9707b2..5bc0ca9fefb 100644
--- a/test_programs/execution_success/schnorr/src/main.nr
+++ b/test_programs/execution_success/schnorr/src/main.nr
@@ -1,5 +1,4 @@
-use dep::std;
-use dep::std::embedded_curve_ops;
+use std::embedded_curve_ops;
 
 // Note: If main has any unsized types, then the verifier will never be able
 // to figure out the circuit instance
@@ -37,11 +36,7 @@ fn main(
 // Meanwhile, you have to use a message with 32 additional bytes:
 // If you want to verify a signature on a message of 10 bytes, you need to pass a message of length 42,
 // where the first 10 bytes are the one from the original message (the other bytes are not used)
-pub fn verify_signature_noir<M>(
-    public_key: embedded_curve_ops::EmbeddedCurvePoint,
-    signature: [u8; 64],
-    message: [u8; M]
-) -> bool {
+pub fn verify_signature_noir<M>(public_key: embedded_curve_ops::EmbeddedCurvePoint, signature: [u8; 64], message: [u8; M]) -> bool {
     let N = message.len() - 32;
 
     //scalar lo/hi from bytes
@@ -90,11 +85,7 @@ pub fn bytes_to_scalar(bytes: [u8; 64], offset: u32) -> embedded_curve_ops::Embe
     sig_s
 }
 
-pub fn assert_valid_signature<M>(
-    public_key: embedded_curve_ops::EmbeddedCurvePoint,
-    signature: [u8; 64],
-    message: [u8; M]
-) {
+pub fn assert_valid_signature<M>(public_key: embedded_curve_ops::EmbeddedCurvePoint, signature: [u8; 64], message: [u8; M]) {
     let N = message.len() - 32;
     //scalar lo/hi from bytes
     let sig_s = bytes_to_scalar(signature, 0);
diff --git a/test_programs/execution_success/sha256/src/main.nr b/test_programs/execution_success/sha256/src/main.nr
index d4240ded8b3..4f999d349f0 100644
--- a/test_programs/execution_success/sha256/src/main.nr
+++ b/test_programs/execution_success/sha256/src/main.nr
@@ -9,7 +9,6 @@
 //
 // Not yet here: For R1CS, it is more about manipulating arithmetic gates to get performance
 // This can be done in ACIR!
-use dep::std;
 
 fn main(x: Field, result: [u8; 32]) {
     // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
diff --git a/test_programs/execution_success/sha2_byte/src/main.nr b/test_programs/execution_success/sha2_byte/src/main.nr
index fa8ddfbdf69..aecd9fba2f3 100644
--- a/test_programs/execution_success/sha2_byte/src/main.nr
+++ b/test_programs/execution_success/sha2_byte/src/main.nr
@@ -1,5 +1,4 @@
 // Test Noir implementations of SHA256 and SHA512 on a one-byte message.
-use dep::std;
 
 fn main(x: Field, result256: [u8; 32], result512: [u8; 64]) {
     let digest256 = std::sha256::digest([x as u8]);
diff --git a/test_programs/execution_success/signed_comparison/src/main.nr b/test_programs/execution_success/signed_comparison/src/main.nr
index d020be380fb..0fe72112f5a 100644
--- a/test_programs/execution_success/signed_comparison/src/main.nr
+++ b/test_programs/execution_success/signed_comparison/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(mut x: i8, mut y: i8, z: i8) {
     let mut s1: i8 = 5;
     let mut s2: i8 = 8;
diff --git a/test_programs/execution_success/signed_division/src/main.nr b/test_programs/execution_success/signed_division/src/main.nr
index 6289a2f9ed9..207ef59986b 100644
--- a/test_programs/execution_success/signed_division/src/main.nr
+++ b/test_programs/execution_success/signed_division/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Testing signed integer division: 
 //  7/3  = 2
 // -7/3  = -2
diff --git a/test_programs/execution_success/simple_print/src/main.nr b/test_programs/execution_success/simple_print/src/main.nr
index 6038b995af0..3a68f8cc4c3 100644
--- a/test_programs/execution_success/simple_print/src/main.nr
+++ b/test_programs/execution_success/simple_print/src/main.nr
@@ -1,6 +1,5 @@
 // Simple program for testing the logging
 // of single witnesses and witness arrays.
-use dep::std;
 
 fn main(x: Field, y: pub Field) {
     std::println(x);
diff --git a/test_programs/execution_success/simple_shield/src/main.nr b/test_programs/execution_success/simple_shield/src/main.nr
index 548ba17d462..d84288b9fd6 100644
--- a/test_programs/execution_success/simple_shield/src/main.nr
+++ b/test_programs/execution_success/simple_shield/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(
     // Public key of note
   // all notes have the same denomination
diff --git a/test_programs/execution_success/slice_coercion/src/main.nr b/test_programs/execution_success/slice_coercion/src/main.nr
index a7ba0443bd1..4a83b739523 100644
--- a/test_programs/execution_success/slice_coercion/src/main.nr
+++ b/test_programs/execution_success/slice_coercion/src/main.nr
@@ -23,5 +23,5 @@ fn main(expected: pub Field, first: Field) {
 fn regression_4967() {
     let var1: [(i32, u8)] = [(1, 2)];
     assert(var1.len() == 1);
-    dep::std::println(var1);
+    std::println(var1);
 }
diff --git a/test_programs/execution_success/slices/src/main.nr b/test_programs/execution_success/slices/src/main.nr
index b20e3478898..8be79cdc3c4 100644
--- a/test_programs/execution_success/slices/src/main.nr
+++ b/test_programs/execution_success/slices/src/main.nr
@@ -1,5 +1,4 @@
-use dep::std::slice;
-use dep::std;
+use std::slice;
 
 fn main(x: Field, y: pub Field) {
     let mut slice = &[0; 2];
diff --git a/test_programs/execution_success/strings/src/main.nr b/test_programs/execution_success/strings/src/main.nr
index cff229d368a..d28a9f483ac 100644
--- a/test_programs/execution_success/strings/src/main.nr
+++ b/test_programs/execution_success/strings/src/main.nr
@@ -1,4 +1,3 @@
-use dep::std;
 // Test global string literals
 global HELLO_WORLD = "hello world";
 
diff --git a/test_programs/execution_success/to_bits/src/main.nr b/test_programs/execution_success/to_bits/src/main.nr
index 18f65f0bd66..84ace83903a 100644
--- a/test_programs/execution_success/to_bits/src/main.nr
+++ b/test_programs/execution_success/to_bits/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     let field = 1000;
     let be_bits = field.to_be_bits(16);
diff --git a/test_programs/execution_success/to_bytes_integration/src/main.nr b/test_programs/execution_success/to_bytes_integration/src/main.nr
index 3c43caf1806..21c4ad90bfe 100644
--- a/test_programs/execution_success/to_bytes_integration/src/main.nr
+++ b/test_programs/execution_success/to_bytes_integration/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(x: Field, a: Field) {
     let y: Field = 2040124;
     let be_byte_array = y.to_be_bytes(31);
diff --git a/test_programs/execution_success/trait_method_mut_self/src/main.nr b/test_programs/execution_success/trait_method_mut_self/src/main.nr
index fa47fd5d881..9cc8375b140 100644
--- a/test_programs/execution_success/trait_method_mut_self/src/main.nr
+++ b/test_programs/execution_success/trait_method_mut_self/src/main.nr
@@ -1,5 +1,5 @@
-use dep::std::hash::Hasher;
-use dep::std::hash::poseidon2::Poseidon2Hasher;
+use std::hash::Hasher;
+use std::hash::poseidon2::Poseidon2Hasher;
 
 fn main(x: Field, y: pub Field) {
     let mut a_mut_ref = AType { x };
diff --git a/test_programs/execution_success/traits_in_crates_1/crate1/src/lib.nr b/test_programs/execution_success/traits_in_crates_1/crate1/src/lib.nr
index 62dd5a2c111..e36a263093a 100644
--- a/test_programs/execution_success/traits_in_crates_1/crate1/src/lib.nr
+++ b/test_programs/execution_success/traits_in_crates_1/crate1/src/lib.nr
@@ -2,7 +2,7 @@ trait MyTrait {
     fn Add10(&mut self);
 }
 
-impl MyTrait for dep::crate2::MyStruct {
+impl MyTrait for crate2::MyStruct {
     fn Add10(&mut self) {
         self.Q += 10;
     }
diff --git a/test_programs/execution_success/traits_in_crates_1/src/main.nr b/test_programs/execution_success/traits_in_crates_1/src/main.nr
index 7ba2f63c5c0..2afec29ee1f 100644
--- a/test_programs/execution_success/traits_in_crates_1/src/main.nr
+++ b/test_programs/execution_success/traits_in_crates_1/src/main.nr
@@ -1,5 +1,5 @@
 fn main(x: Field, y: pub Field) {
-    let mut V = dep::crate2::MyStruct { Q: x };
+    let mut V = crate2::MyStruct { Q: x };
     V.Add10();
     assert(V.Q == y);
 }
diff --git a/test_programs/execution_success/traits_in_crates_2/crate2/src/lib.nr b/test_programs/execution_success/traits_in_crates_2/crate2/src/lib.nr
index 38870489131..fe6a94a4a95 100644
--- a/test_programs/execution_success/traits_in_crates_2/crate2/src/lib.nr
+++ b/test_programs/execution_success/traits_in_crates_2/crate2/src/lib.nr
@@ -2,7 +2,7 @@ struct MyStruct {
     Q: Field,
 }
 
-impl dep::crate1::MyTrait for MyStruct {
+impl crate1::MyTrait for MyStruct {
     fn Add10(&mut self) {
         self.Q += 10;
     }
diff --git a/test_programs/execution_success/traits_in_crates_2/src/main.nr b/test_programs/execution_success/traits_in_crates_2/src/main.nr
index 7ba2f63c5c0..2afec29ee1f 100644
--- a/test_programs/execution_success/traits_in_crates_2/src/main.nr
+++ b/test_programs/execution_success/traits_in_crates_2/src/main.nr
@@ -1,5 +1,5 @@
 fn main(x: Field, y: pub Field) {
-    let mut V = dep::crate2::MyStruct { Q: x };
+    let mut V = crate2::MyStruct { Q: x };
     V.Add10();
     assert(V.Q == y);
 }
diff --git a/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr b/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
index b880d3ae047..36c7d2926c1 100644
--- a/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
+++ b/test_programs/execution_success/turbofish_call_func_diff_types/src/main.nr
@@ -1,6 +1,6 @@
-use dep::std::hash::Hasher;
-use dep::std::hash::poseidon2::Poseidon2Hasher;
-use dep::std::hash::poseidon::PoseidonHasher;
+use std::hash::Hasher;
+use std::hash::poseidon2::Poseidon2Hasher;
+use std::hash::poseidon::PoseidonHasher;
 
 fn main(x: Field, y: pub Field) {
     let mut hasher = PoseidonHasher::default();
diff --git a/test_programs/execution_success/u128/src/main.nr b/test_programs/execution_success/u128/src/main.nr
index a403571ea74..d0835ccf30f 100644
--- a/test_programs/execution_success/u128/src/main.nr
+++ b/test_programs/execution_success/u128/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(mut x: u32, y: u32, z: u32, big_int: U128, hexa: str<7>) {
     let a = U128::from_u64s_le(x as u64, x as u64);
     let b = U128::from_u64s_le(y as u64, x as u64);
diff --git a/test_programs/execution_success/unit_value/src/main.nr b/test_programs/execution_success/unit_value/src/main.nr
index f3844e03cf2..a488f267b4c 100644
--- a/test_programs/execution_success/unit_value/src/main.nr
+++ b/test_programs/execution_success/unit_value/src/main.nr
@@ -1,5 +1,5 @@
 fn get_transaction() {
-    dep::std::unsafe::zeroed()
+    std::unsafe::zeroed()
 }
 
 fn main() {
diff --git a/test_programs/execution_success/wrapping_operations/src/main.nr b/test_programs/execution_success/wrapping_operations/src/main.nr
index 85fd65b193c..d8345884c82 100644
--- a/test_programs/execution_success/wrapping_operations/src/main.nr
+++ b/test_programs/execution_success/wrapping_operations/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(x: u8, y: u8) {
     assert(std::wrapping_sub(x, 1) == y);
     assert(std::wrapping_add(y, 1) == x);
diff --git a/test_programs/format.sh b/test_programs/format.sh
index 3c679b8689e..fa63d228752 100755
--- a/test_programs/format.sh
+++ b/test_programs/format.sh
@@ -2,7 +2,7 @@
 set -e
 
 # These tests are incompatible with gas reporting
-excluded_dirs=("workspace" "workspace_default_member" "workspace_reexport_bug")
+excluded_dirs=("workspace" "overlapping_dep_and_mod" "overlapping_dep_and_mod_fix" "workspace_default_member" "workspace_reexport_bug")
 
 # These tests cause failures in CI with a stack overflow for some reason.
 ci_excluded_dirs=("eddsa")
diff --git a/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr b/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr
index 253e999ce07..08a9234a752 100644
--- a/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr
+++ b/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr
@@ -11,5 +11,5 @@ fn test_with_extra_space() {
 #[test(should_fail_with = "Not equal")]
 fn test_runtime_mismatch() {
     // We use a pedersen commitment here so that the assertion failure is only known at runtime.
-    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0, "Not equal ");
+    assert_eq(std::hash::pedersen_commitment([27]).x, 0, "Not equal ");
 }
diff --git a/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr b/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
index 5d73ef96d49..35a0c44218f 100644
--- a/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
+++ b/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::field::bn254::{TWO_POW_128, assert_gt};
+use std::field::bn254::{TWO_POW_128, assert_gt};
 
 #[test(should_fail_with = "attempt to add with overflow")]
 unconstrained fn test_overflow_add() {
diff --git a/test_programs/noir_test_success/embedded_curve_ops/src/main.nr b/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
index 9e3c5d87874..225e86397fd 100644
--- a/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
+++ b/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
+use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
 
 #[test]
     
diff --git a/test_programs/noir_test_success/field_comparisons/src/main.nr b/test_programs/noir_test_success/field_comparisons/src/main.nr
index 105d82ca755..8613e6d6c4f 100644
--- a/test_programs/noir_test_success/field_comparisons/src/main.nr
+++ b/test_programs/noir_test_success/field_comparisons/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::field::bn254::{TWO_POW_128, assert_gt};
+use std::field::bn254::{TWO_POW_128, assert_gt};
 
 #[test(should_fail)]
 fn test_assert_gt_should_fail_eq() {
diff --git a/test_programs/noir_test_success/mock_oracle/src/main.nr b/test_programs/noir_test_success/mock_oracle/src/main.nr
index d840ffaef66..4d3dd8d030b 100644
--- a/test_programs/noir_test_success/mock_oracle/src/main.nr
+++ b/test_programs/noir_test_success/mock_oracle/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::test::OracleMock;
+use std::test::OracleMock;
 
 struct Point {
     x: Field,
diff --git a/test_programs/noir_test_success/regression_4561/src/main.nr b/test_programs/noir_test_success/regression_4561/src/main.nr
index 138f7e805b3..70c447b49af 100644
--- a/test_programs/noir_test_success/regression_4561/src/main.nr
+++ b/test_programs/noir_test_success/regression_4561/src/main.nr
@@ -1,5 +1,5 @@
 // Regression test for issue #4561
-use dep::std::test::OracleMock;
+use std::test::OracleMock;
 
 type TReturnElem = [Field; 3];
 type TReturn = [TReturnElem; 2];
@@ -41,4 +41,4 @@ unconstrained fn two_nested_return_unconstrained() -> (Field, TReturn, Field, TR
 fn two_nested_return() {
     OracleMock::mock("two_nested_return").returns((0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6]));
     assert_eq(two_nested_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7, [[1, 2, 3], [4, 5, 6]]));
-}
\ No newline at end of file
+}
diff --git a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
index 1f5c29e58a2..b713976643b 100644
--- a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
+++ b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
@@ -10,21 +10,21 @@ fn test_should_fail_without_match() {
 
 #[test(should_fail_with = "Not equal")]
 fn test_should_fail_with_runtime_match() {
-    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0, "Not equal");
+    assert_eq(std::hash::pedersen_commitment([27]).x, 0, "Not equal");
 }
 
 #[test(should_fail)]
 fn test_should_fail_without_runtime_match() {
-    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0);
+    assert_eq(std::hash::pedersen_commitment([27]).x, 0);
 }
 
 struct InvalidPointError {
-    point: dep::std::embedded_curve_ops::EmbeddedCurvePoint,
+    point: std::embedded_curve_ops::EmbeddedCurvePoint,
 }
 
 #[test(should_fail_with = "InvalidPointError { point: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false } }")]
 fn test_should_fail_with_struct() {
-    let hash = dep::std::hash::pedersen_commitment([27]);
+    let hash = std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, InvalidPointError { point: hash });
 }
 
@@ -37,7 +37,7 @@ fn test_should_fail_with_basic_type_fmt_string() {
 
 #[test(should_fail_with = "Invalid hash: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false }")]
 fn test_should_fail_with_struct_fmt_string() {
-    let hash = dep::std::hash::pedersen_commitment([27]);
+    let hash = std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, f"Invalid hash: {hash}");
 }
 
@@ -55,17 +55,17 @@ unconstrained fn unconstrained_test_should_fail_without_match() {
 
 #[test(should_fail_with = "Not equal")]
 unconstrained fn unconstrained_test_should_fail_with_runtime_match() {
-    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0, "Not equal");
+    assert_eq(std::hash::pedersen_commitment([27]).x, 0, "Not equal");
 }
 
 #[test(should_fail)]
 unconstrained fn unconstrained_test_should_fail_without_runtime_match() {
-    assert_eq(dep::std::hash::pedersen_commitment([27]).x, 0);
+    assert_eq(std::hash::pedersen_commitment([27]).x, 0);
 }
 
 #[test(should_fail_with = "InvalidPointError { point: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false } }")]
 unconstrained fn unconstrained_test_should_fail_with_struct() {
-    let hash = dep::std::hash::pedersen_commitment([27]);
+    let hash = std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, InvalidPointError { point: hash });
 }
 
@@ -78,6 +78,6 @@ unconstrained fn unconstrained_test_should_fail_with_basic_type_fmt_string() {
 
 #[test(should_fail_with = "Invalid hash: EmbeddedCurvePoint { x: 0x1cea3a116d01eb94d568ef04c3dfbc39f96f015ed801ab8958e360d406503ce0, y: 0x2721b237df87234acc36a238b8f231a3d31d18fe3845fff4cc59f0bd873818f8, is_infinite: false }")]
 unconstrained fn unconstrained_test_should_fail_with_struct_fmt_string() {
-    let hash = dep::std::hash::pedersen_commitment([27]);
+    let hash = std::hash::pedersen_commitment([27]);
     assert_eq(hash.x, 0, f"Invalid hash: {hash}");
 }
diff --git a/test_programs/rebuild.sh b/test_programs/rebuild.sh
index 2d4147cb08c..094c3902583 100755
--- a/test_programs/rebuild.sh
+++ b/test_programs/rebuild.sh
@@ -1,8 +1,6 @@
 #!/usr/bin/env bash
 set -e
 
-NO_PARALLEL=${1:-}
-
 process_dir() {
     local dir=$1
     local current_dir=$2
@@ -62,28 +60,7 @@ for dir in $current_dir/benchmarks/*; do
     dirs_to_process+=("$dir")
 done
 
-# Process each directory in parallel
-pids=()
-if [ -z $NO_PARALLEL ]; then
-for dir in "${dirs_to_process[@]}"; do
-    process_dir "$dir" "$current_dir" &
-    pids+=($!)
-done
-else
-for dir in "${dirs_to_process[@]}"; do
-    process_dir "$dir" "$current_dir"
-    pids+=($!)
-done
-fi
 
-# Check the exit status of each background job.
-for pid in "${pids[@]}"; do
-    wait $pid || exit_status=$?
-done
+parallel -j0  process_dir {} "$current_dir" ::: ${dirs_to_process[@]}
 
-# Exit with a failure status if any job failed.
-if [ ! -z "$exit_status" ]; then
-    echo "Rebuild failed!"
-    exit $exit_status
-fi
 echo "Rebuild Succeeded!"
diff --git a/test_programs/test_libraries/diamond_deps_1/src/lib.nr b/test_programs/test_libraries/diamond_deps_1/src/lib.nr
index 60c001ec64e..d76ce5a05e9 100644
--- a/test_programs/test_libraries/diamond_deps_1/src/lib.nr
+++ b/test_programs/test_libraries/diamond_deps_1/src/lib.nr
@@ -1,4 +1,4 @@
-use dep::dep2::call_dep2;
+use dep2::call_dep2;
 
 pub fn call_dep1_then_dep2(x: Field, y: Field) -> Field {
     call_dep2(x, y)
diff --git a/test_programs/test_libraries/exporting_lib/src/lib.nr b/test_programs/test_libraries/exporting_lib/src/lib.nr
index bfb1819132a..fdd9f139d41 100644
--- a/test_programs/test_libraries/exporting_lib/src/lib.nr
+++ b/test_programs/test_libraries/exporting_lib/src/lib.nr
@@ -4,6 +4,6 @@ struct MyStruct {
 
 type FooStruct = MyStruct;
 
-fn is_struct_zero(val: MyStruct) -> bool {
+pub fn is_struct_zero(val: MyStruct) -> bool {
     val.inner == 0
 }
diff --git a/test_programs/test_libraries/reexporting_lib/src/lib.nr b/test_programs/test_libraries/reexporting_lib/src/lib.nr
index f12dfe01ecd..1bced548304 100644
--- a/test_programs/test_libraries/reexporting_lib/src/lib.nr
+++ b/test_programs/test_libraries/reexporting_lib/src/lib.nr
@@ -1,3 +1,3 @@
-use dep::exporting_lib::{MyStruct, FooStruct};
+use exporting_lib::{MyStruct, FooStruct};
 
-use dep::exporting_lib as lib;
+use exporting_lib as lib;
diff --git a/tooling/debugger/src/source_code_printer.rs b/tooling/debugger/src/source_code_printer.rs
index e298eb8aadd..ad511563477 100644
--- a/tooling/debugger/src/source_code_printer.rs
+++ b/tooling/debugger/src/source_code_printer.rs
@@ -143,7 +143,7 @@ fn render_line(
 //
 // Consider for example the file (line numbers added to facilitate this doc):
 // ```
-// 1 use dep::std::hash::poseidon;
+// 1 use std::hash::poseidon;
 // 2
 // 3 fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
 // 4    let hash1 = poseidon::bn254::hash_2(x1);
@@ -157,7 +157,7 @@ fn render_line(
 //
 // If the location to render is `poseidon::bn254::hash_2(x1)`, we'll render the file as:
 // ```
-// 1   use dep::std::hash::poseidon;
+// 1   use std::hash::poseidon;
 // 2
 // 3   fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
 // 4      let hash1 = <b>poseidon::bn254::hash_2(x1)</b>;
diff --git a/tooling/nargo_fmt/tests/expected/contract.nr b/tooling/nargo_fmt/tests/expected/contract.nr
index 97a6ebd6b77..e3a5877725a 100644
--- a/tooling/nargo_fmt/tests/expected/contract.nr
+++ b/tooling/nargo_fmt/tests/expected/contract.nr
@@ -3,11 +3,11 @@
 // 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.
 contract Benchmarking {
-    use dep::aztec::protocol_types::abis::function_selector::FunctionSelector;
+    use aztec::protocol_types::abis::function_selector::FunctionSelector;
 
-    use dep::value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
+    use value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
 
-    use dep::aztec::{
+    use aztec::{
         context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
         log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
diff --git a/tooling/nargo_fmt/tests/expected/import_braces.nr b/tooling/nargo_fmt/tests/expected/import_braces.nr
index 49c9d09001e..9c74c477f5f 100644
--- a/tooling/nargo_fmt/tests/expected/import_braces.nr
+++ b/tooling/nargo_fmt/tests/expected/import_braces.nr
@@ -1 +1 @@
-use dep::std::hash::sha256;
+use std::hash::sha256;
diff --git a/tooling/nargo_fmt/tests/expected/let.nr b/tooling/nargo_fmt/tests/expected/let.nr
index 7ff69e74306..0edc0eaf922 100644
--- a/tooling/nargo_fmt/tests/expected/let.nr
+++ b/tooling/nargo_fmt/tests/expected/let.nr
@@ -51,10 +51,10 @@ fn let_() {
 
     let expr = MyExpr { /*A boolean literal (true, false).*/ kind: ExprKind::Bool(true) };
 
-    let mut V = dep::crate2::MyStruct { Q: x };
-    let mut V = dep::crate2::MyStruct {};
-    let mut V = dep::crate2::MyStruct {/*test*/};
-    let mut V = dep::crate2::MyStruct {
+    let mut V = crate2::MyStruct { Q: x };
+    let mut V = crate2::MyStruct {};
+    let mut V = crate2::MyStruct {/*test*/};
+    let mut V = crate2::MyStruct {
         // sad
     };
 }
diff --git a/tooling/nargo_fmt/tests/expected/print.nr b/tooling/nargo_fmt/tests/expected/print.nr
index 3bce0941da2..d8404f674b0 100644
--- a/tooling/nargo_fmt/tests/expected/print.nr
+++ b/tooling/nargo_fmt/tests/expected/print.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     std::print("Hello world");
     std::println("Hello world");
diff --git a/tooling/nargo_fmt/tests/expected/print2.nr b/tooling/nargo_fmt/tests/expected/print2.nr
index 3bce0941da2..d8404f674b0 100644
--- a/tooling/nargo_fmt/tests/expected/print2.nr
+++ b/tooling/nargo_fmt/tests/expected/print2.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     std::print("Hello world");
     std::println("Hello world");
diff --git a/tooling/nargo_fmt/tests/expected/singleton_import.nr b/tooling/nargo_fmt/tests/expected/singleton_import.nr
new file mode 100644
index 00000000000..bb1bad500d9
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/singleton_import.nr
@@ -0,0 +1,2 @@
+use dep::std;
+use some_crate;
diff --git a/tooling/nargo_fmt/tests/input/contract.nr b/tooling/nargo_fmt/tests/input/contract.nr
index 97a6ebd6b77..e3a5877725a 100644
--- a/tooling/nargo_fmt/tests/input/contract.nr
+++ b/tooling/nargo_fmt/tests/input/contract.nr
@@ -3,11 +3,11 @@
 // 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.
 contract Benchmarking {
-    use dep::aztec::protocol_types::abis::function_selector::FunctionSelector;
+    use aztec::protocol_types::abis::function_selector::FunctionSelector;
 
-    use dep::value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
+    use value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
 
-    use dep::aztec::{
+    use aztec::{
         context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
         log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
         types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
diff --git a/tooling/nargo_fmt/tests/input/import_braces.nr b/tooling/nargo_fmt/tests/input/import_braces.nr
index 88c7e9562a8..0647bbaa580 100644
--- a/tooling/nargo_fmt/tests/input/import_braces.nr
+++ b/tooling/nargo_fmt/tests/input/import_braces.nr
@@ -1 +1 @@
-use dep::std::hash::{sha256};
\ No newline at end of file
+use std::hash::{sha256};
diff --git a/tooling/nargo_fmt/tests/input/let.nr b/tooling/nargo_fmt/tests/input/let.nr
index 37cdc6655c7..16ce0a9d7f1 100644
--- a/tooling/nargo_fmt/tests/input/let.nr
+++ b/tooling/nargo_fmt/tests/input/let.nr
@@ -26,10 +26,10 @@ kind: ExprKind::Bool(true),
 
     let expr = MyExpr {/*A boolean literal (true, false).*/kind: ExprKind::Bool(true),};
 
-    let mut V = dep::crate2::MyStruct { Q: x };
-    let mut V = dep::crate2::MyStruct {};
-    let mut V = dep::crate2::MyStruct {/*test*/};
-    let mut V = dep::crate2::MyStruct {
+    let mut V = crate2::MyStruct { Q: x };
+    let mut V = crate2::MyStruct {};
+    let mut V = crate2::MyStruct {/*test*/};
+    let mut V = crate2::MyStruct {
         // sad
     };
 }
diff --git a/tooling/nargo_fmt/tests/input/print.nr b/tooling/nargo_fmt/tests/input/print.nr
index 3bce0941da2..d8404f674b0 100644
--- a/tooling/nargo_fmt/tests/input/print.nr
+++ b/tooling/nargo_fmt/tests/input/print.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     std::print("Hello world");
     std::println("Hello world");
diff --git a/tooling/nargo_fmt/tests/input/print2.nr b/tooling/nargo_fmt/tests/input/print2.nr
index 3bce0941da2..d8404f674b0 100644
--- a/tooling/nargo_fmt/tests/input/print2.nr
+++ b/tooling/nargo_fmt/tests/input/print2.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main() {
     std::print("Hello world");
     std::println("Hello world");
diff --git a/tooling/nargo_fmt/tests/input/singleton_import.nr b/tooling/nargo_fmt/tests/input/singleton_import.nr
new file mode 100644
index 00000000000..bb1bad500d9
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/singleton_import.nr
@@ -0,0 +1,2 @@
+use dep::std;
+use some_crate;
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
index a9aaae5f2f7..5a20a92048f 100644
--- a/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std;
-
 fn main(x: u64, y: pub u64) -> pub u64 {
     // We include a println statement to show that noirJS will ignore this and continue execution
     std::println("foo");

From 540bef3597bd3e5775c83ec2ee3c0d4463084b4c Mon Sep 17 00:00:00 2001
From: noirwhal <163862677+noirwhal@users.noreply.github.com>
Date: Mon, 17 Jun 2024 19:30:02 +0100
Subject: [PATCH 381/416] chore: Release Noir(0.31.0) (#5166)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

:robot: I have created a release *beep* *boop*
---


<details><summary>0.31.0</summary>

## [0.31.0](https://github.com/noir-lang/noir/compare/v0.30.0...v0.31.0)
(2024-06-17)


### ⚠ BREAKING CHANGES

* remove `dep::` prefix
([#4946](https://github.com/noir-lang/noir/issues/4946))
* remove `distinct` keyword
([#5219](https://github.com/noir-lang/noir/issues/5219))
* remove `param_witnesses` and `return_witnesses` from ABI
([#5154](https://github.com/noir-lang/noir/issues/5154))
* add session id to foreign call RPC requests
([#5205](https://github.com/noir-lang/noir/issues/5205))
* restrict noir word size to u32
([#5180](https://github.com/noir-lang/noir/issues/5180))
* separate proving from `noir_js`
([#5072](https://github.com/noir-lang/noir/issues/5072))
* switch `bb` over to read ACIR from nargo artifacts
(https://github.com/AztecProtocol/aztec-packages/pull/6283)
* specify databus arrays for BB
(https://github.com/AztecProtocol/aztec-packages/pull/6239)
* **stdlib:** eddsa function using turbofish
([#5050](https://github.com/noir-lang/noir/issues/5050))

### Features

* `pxe.addNullifiedNote(...)`
(https://github.com/AztecProtocol/aztec-packages/pull/6948)
([7de19f5](https://github.com/noir-lang/noir/commit/7de19f5856591203271836f07154abae13f5102b))
* Activate return_data in ACIR opcodes
([#5080](https://github.com/noir-lang/noir/issues/5080))
([c9fda3c](https://github.com/noir-lang/noir/commit/c9fda3c7fd4575bfe7d457e8d4230e071f0129a0))
* Add `as_witness` builtin function in order to constrain a witness to
be equal to a variable
([#4641](https://github.com/noir-lang/noir/issues/4641))
([faf5bd8](https://github.com/noir-lang/noir/commit/faf5bd8ed80fb89b4bb6a2536b9bfa9649579da7))
* Add `set` and `set_unchecked` methods to `Vec` and `BoundedVec`
([#5241](https://github.com/noir-lang/noir/issues/5241))
([1849389](https://github.com/noir-lang/noir/commit/1849389362e22e8236177f84b735dadf840cd637))
* Add BoundedVec::map
([#5250](https://github.com/noir-lang/noir/issues/5250))
([da1549c](https://github.com/noir-lang/noir/commit/da1549cfb296261b273a3a64908382e7b71512ad))
* Add intrinsic to get if running inside an unconstrained context
([#5098](https://github.com/noir-lang/noir/issues/5098))
([281ebf2](https://github.com/noir-lang/noir/commit/281ebf26e4cd16daf361938de505697f8d5fbd5e))
* Add native rust implementation of schnorr signature verification
([#5053](https://github.com/noir-lang/noir/issues/5053))
([fab1c35](https://github.com/noir-lang/noir/commit/fab1c3567d731ea7902635a7a020a8d14f94fd27))
* Add session id to foreign call RPC requests
([#5205](https://github.com/noir-lang/noir/issues/5205))
([14adafc](https://github.com/noir-lang/noir/commit/14adafc965fa9c833e096ec037e086aae67703ad))
* Consider block parameters in variable liveness
([#5097](https://github.com/noir-lang/noir/issues/5097))
([e4eb5f5](https://github.com/noir-lang/noir/commit/e4eb5f539f377fd3c2e1a874707ffce62a5bc10a))
* **experimental:** Implement macro calls & splicing into `Expr` values
([#5203](https://github.com/noir-lang/noir/issues/5203))
([d9b4712](https://github.com/noir-lang/noir/commit/d9b4712bf1a62548dd7ed17b181882ae537d70dd))
* Implement println in the comptime interpreter
([#5197](https://github.com/noir-lang/noir/issues/5197))
([7f08343](https://github.com/noir-lang/noir/commit/7f08343dfcafddfcec1b238746a69273ae4f4e2b))
* Implement turbofish operator
([#3542](https://github.com/noir-lang/noir/issues/3542))
([226724e](https://github.com/noir-lang/noir/commit/226724e3b54c2e0d9ba005661c76b40a87d9295a))
* Make ACVM generic across fields
([#5114](https://github.com/noir-lang/noir/issues/5114))
([70f374c](https://github.com/noir-lang/noir/commit/70f374c06642962d8f2b95b80f8c938fcf7761d7))
* Move abi demonomorphizer to noir_codegen and use noir_codegen in
protocol types
(https://github.com/AztecProtocol/aztec-packages/pull/6302)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Move to_radix to a blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6294)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* **nargo:** Hidden option to show contract artifact paths written by
`nargo compile`
(https://github.com/AztecProtocol/aztec-packages/pull/6131)
([ff67e14](https://github.com/noir-lang/noir/commit/ff67e145d086bf6fdf58fb5e57927033e52e03d3))
* Place return value witnesses directly after function arguments
([#5142](https://github.com/noir-lang/noir/issues/5142))
([1252b5f](https://github.com/noir-lang/noir/commit/1252b5fcc7ed56bb55e95745b83be6e556805397))
* Private Kernel Recursion
(https://github.com/AztecProtocol/aztec-packages/pull/6278)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Proper padding in ts AES and constrained AES in body and header
computations (https://github.com/AztecProtocol/aztec-packages/pull/6269)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Remove `dep::` prefix
([#4946](https://github.com/noir-lang/noir/issues/4946))
([d6d0ae2](https://github.com/noir-lang/noir/commit/d6d0ae26d2fef083dc240539b834d934c84b0326))
* Remove conditional compilation of `bn254_blackbox_solver`
([#5058](https://github.com/noir-lang/noir/issues/5058))
([9420d7c](https://github.com/noir-lang/noir/commit/9420d7c2ba6bbbf5ecb9a066837c505310955b6c))
* Remove external blackbox solver from acir simulator
(https://github.com/AztecProtocol/aztec-packages/pull/6586)
([a40a9a5](https://github.com/noir-lang/noir/commit/a40a9a55571deed386688fb84260bdf2794d4d38))
* Replace stdlib poseidon implementation with optimized version
([#5122](https://github.com/noir-lang/noir/issues/5122))
([11e98f3](https://github.com/noir-lang/noir/commit/11e98f348d1d43a9b28d83ec3308027b7afc0da6))
* Restrict noir word size to u32
([#5180](https://github.com/noir-lang/noir/issues/5180))
([bdb2bc6](https://github.com/noir-lang/noir/commit/bdb2bc608ea8fd52d46545a38b68dd2558b28110))
* Separate proving from `noir_js`
([#5072](https://github.com/noir-lang/noir/issues/5072))
([c93c738](https://github.com/noir-lang/noir/commit/c93c7380c705fcec5c77bfc436c2f5ea085edd77))
* Separate runtimes of SSA functions before inlining
([#5121](https://github.com/noir-lang/noir/issues/5121))
([69eca9b](https://github.com/noir-lang/noir/commit/69eca9b8671fa54192bef814dd584fdb5387a5f7))
* Specify databus arrays for BB
(https://github.com/AztecProtocol/aztec-packages/pull/6239)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Standardize pedersen functions to return `EmbeddedCurvePoint`
([#5190](https://github.com/noir-lang/noir/issues/5190))
([3b85b36](https://github.com/noir-lang/noir/commit/3b85b3637f81f3894a7faa07fd299f9d64747214))
* **stdlib:** Eddsa function using turbofish
([#5050](https://github.com/noir-lang/noir/issues/5050))
([7936262](https://github.com/noir-lang/noir/commit/79362629ed8cf42b6601e9a551ed8f9fe03e0112))
* Support casting in globals
([#5164](https://github.com/noir-lang/noir/issues/5164))
([6d3e732](https://github.com/noir-lang/noir/commit/6d3e732e06033b53506656acdd3d7759bd27f106))
* Switch `bb` over to read ACIR from nargo artifacts
(https://github.com/AztecProtocol/aztec-packages/pull/6283)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6280)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6332)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6573)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6986)
([7de19f5](https://github.com/noir-lang/noir/commit/7de19f5856591203271836f07154abae13f5102b))
* ToRadix BB + avm transpiler support
(https://github.com/AztecProtocol/aztec-packages/pull/6330)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))


### Bug Fixes

* Add support for nested arrays returned by oracles
([#5132](https://github.com/noir-lang/noir/issues/5132))
([f846879](https://github.com/noir-lang/noir/commit/f846879dd038328bd0a1d39a72b448ef52a1002b))
* Apply self type from generic trait constraint before instantiating
identifiers ([#5087](https://github.com/noir-lang/noir/issues/5087))
([2b4755c](https://github.com/noir-lang/noir/commit/2b4755c2b57460d5eb839ee835f8c9acd5773a7c))
* Auto dereference trait methods in the elaborator
([#5124](https://github.com/noir-lang/noir/issues/5124))
([56c1a85](https://github.com/noir-lang/noir/commit/56c1a85056ed338644595f1aa58cc94563786b9e))
* Check for public args in aztec functions
(https://github.com/AztecProtocol/aztec-packages/pull/6355)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Disable `if` optimization
([#5240](https://github.com/noir-lang/noir/issues/5240))
([a2816db](https://github.com/noir-lang/noir/commit/a2816dbf7f9d31967fc95205a43fdfdf181029b0))
* **elaborator:** Fix duplicate methods error
([#5225](https://github.com/noir-lang/noir/issues/5225))
([87a1d8e](https://github.com/noir-lang/noir/commit/87a1d8ebaadb5f0f1ed637b96816f971f946af87))
* **elaborator:** Fix regression introduced by lazy-global changes
([#5223](https://github.com/noir-lang/noir/issues/5223))
([fde432a](https://github.com/noir-lang/noir/commit/fde432aacc436b6c57f0d937d7c86836bac0b465))
* **elaborator:** Invert unconstrained check
([#5176](https://github.com/noir-lang/noir/issues/5176))
([967c0fa](https://github.com/noir-lang/noir/commit/967c0fa76da9384afe918a8b23eef60f12f29292))
* **elaborator:** Lazily elaborate globals
([#5191](https://github.com/noir-lang/noir/issues/5191))
([9c99a97](https://github.com/noir-lang/noir/commit/9c99a97ca8f42bee23cf97ebd724fdc51e647c60))
* Error for allocate instructions in acir-gen
([#5200](https://github.com/noir-lang/noir/issues/5200))
([58c7532](https://github.com/noir-lang/noir/commit/58c7532da8dd86ee02b20d7e7809f5437f667845))
* **experimental elaborator:** Avoid calling `add_generics` twice on
trait methods ([#5108](https://github.com/noir-lang/noir/issues/5108))
([7d8c0a3](https://github.com/noir-lang/noir/commit/7d8c0a3a1ae143b574b2fa62cae7c0a493005c70))
* **experimental elaborator:** Clear generics after elaborating type
aliases ([#5136](https://github.com/noir-lang/noir/issues/5136))
([b0a7d0b](https://github.com/noir-lang/noir/commit/b0a7d0b12328d3ed9faed87b78792b77786018e0))
* **experimental elaborator:** Fix `impl Trait` when `--use-elaborator`
is selected ([#5138](https://github.com/noir-lang/noir/issues/5138))
([7ea5962](https://github.com/noir-lang/noir/commit/7ea5962e77b7183374a4e14da3a237ccd63f00a0))
* **experimental elaborator:** Fix definition kind of globals and tuple
patterns with `--use-elaborator` flag
([#5139](https://github.com/noir-lang/noir/issues/5139))
([a140dec](https://github.com/noir-lang/noir/commit/a140dec4580459c5856d44337de3ea08aa7fb44a))
* **experimental elaborator:** Fix duplicate `resolve_type` on self type
and don't leak a trait impl's generics
([#5102](https://github.com/noir-lang/noir/issues/5102))
([db561e2](https://github.com/noir-lang/noir/commit/db561e229cfcb35f23205cbb7e41fcf5ece68ee5))
* **experimental elaborator:** Fix frontend tests when
`--use-elaborator` flag is specified
([#5145](https://github.com/noir-lang/noir/issues/5145))
([d6122eb](https://github.com/noir-lang/noir/commit/d6122eb9e88aa2b1bb6c990e452fa9678ae49704))
* **experimental elaborator:** Fix global values used in the elaborator
([#5135](https://github.com/noir-lang/noir/issues/5135))
([e73cdbb](https://github.com/noir-lang/noir/commit/e73cdbb93b0714331fef754f862d89c08c28a9e5))
* **experimental elaborator:** Fix globals which use function calls
([#5172](https://github.com/noir-lang/noir/issues/5172))
([ab0b1a8](https://github.com/noir-lang/noir/commit/ab0b1a85cc91f8ed748ee393ece54f5c3b43d7ef))
* **experimental elaborator:** Fix panic in the elaborator
([#5082](https://github.com/noir-lang/noir/issues/5082))
([ffcb410](https://github.com/noir-lang/noir/commit/ffcb410978a362c73783fbfe5bbdc9691499609e))
* **experimental elaborator:** Only call `add_generics` once
([#5091](https://github.com/noir-lang/noir/issues/5091))
([f5d2946](https://github.com/noir-lang/noir/commit/f5d294645e82fc85d8dc28ee2a846ba11af85ce5))
* Fix panic in `get_global_let_statement`
([#5177](https://github.com/noir-lang/noir/issues/5177))
([b769b01](https://github.com/noir-lang/noir/commit/b769b01fd06a6a2c66c72f9aa4e1d346b0fca123))
* **frontend:** Call trait method with mut self from generic definition
([#5041](https://github.com/noir-lang/noir/issues/5041))
([89846cf](https://github.com/noir-lang/noir/commit/89846cfbc4961c5258d91b5973f027be80885a20))
* **frontend:** Correctly monomorphize turbofish functions
([#5049](https://github.com/noir-lang/noir/issues/5049))
([fd772e7](https://github.com/noir-lang/noir/commit/fd772e7a764004373f5a41a54eb6847f4decda77))
* **frontend:** Resolve object types from method calls a single time
([#5131](https://github.com/noir-lang/noir/issues/5131))
([3afe023](https://github.com/noir-lang/noir/commit/3afe023543e301aafaf2b79f0ccd6d7936dd53a9))
* Temporarily revert to_radix blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6304)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Use plain integer addresses for opcodes in DAP disassembly view
([#4941](https://github.com/noir-lang/noir/issues/4941))
([d43ba1b](https://github.com/noir-lang/noir/commit/d43ba1bddbf6ebd56a7bee0e1db38d155fec95d5))
* Use predicate for curve operations
([#5076](https://github.com/noir-lang/noir/issues/5076))
([145b909](https://github.com/noir-lang/noir/commit/145b90945486907cb6db75d3f3f93a58d19b2a32))
* Wrapping in signed division
([#5134](https://github.com/noir-lang/noir/issues/5134))
([29baeb4](https://github.com/noir-lang/noir/commit/29baeb41e15918935c437e0a2759c6b936f125a4))


### Miscellaneous Chores

* Remove `distinct` keyword
([#5219](https://github.com/noir-lang/noir/issues/5219))
([1d62c59](https://github.com/noir-lang/noir/commit/1d62c59a8f02f7d277c5bf9ed637348a3b2f399c))
* Remove `param_witnesses` and `return_witnesses` from ABI
([#5154](https://github.com/noir-lang/noir/issues/5154))
([21562ae](https://github.com/noir-lang/noir/commit/21562aeea162d246573967115e7c519715f6d3d8))
</details>

<details><summary>0.47.0</summary>

## [0.47.0](https://github.com/noir-lang/noir/compare/v0.46.0...v0.47.0)
(2024-06-17)


### ⚠ BREAKING CHANGES

* add session id to foreign call RPC requests
([#5205](https://github.com/noir-lang/noir/issues/5205))
* restrict noir word size to u32
([#5180](https://github.com/noir-lang/noir/issues/5180))
* switch `bb` over to read ACIR from nargo artifacts
(https://github.com/AztecProtocol/aztec-packages/pull/6283)
* specify databus arrays for BB
(https://github.com/AztecProtocol/aztec-packages/pull/6239)
* remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
* AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
* contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
* change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
* trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
* remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
* storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
* contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
* automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
* move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
* note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
* rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
* init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)

### Features

* `multi_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6097)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* `variable_base_scalar_mul` blackbox func
(https://github.com/AztecProtocol/aztec-packages/pull/6039)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Acir call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4773)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **acir_gen:** Brillig stdlib
([#4848](https://github.com/noir-lang/noir/issues/4848))
([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
* **acir_gen:** Fold attribute at compile-time and initial non inlined
ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* **acir:** Add predicate to call opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5616)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **acir:** BrilligCall opcode
(https://github.com/AztecProtocol/aztec-packages/pull/5709)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* **acir:** Program and witness stack structure
(https://github.com/AztecProtocol/aztec-packages/pull/5149)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Activate return_data in ACIR opcodes
([#5080](https://github.com/noir-lang/noir/issues/5080))
([c9fda3c](https://github.com/noir-lang/noir/commit/c9fda3c7fd4575bfe7d457e8d4230e071f0129a0))
* **acvm_js:** Execute program
([#4694](https://github.com/noir-lang/noir/issues/4694))
([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
* **acvm:** Execute multiple circuits
(https://github.com/AztecProtocol/aztec-packages/pull/5380)
([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
* Add bit size to const opcode
(https://github.com/AztecProtocol/aztec-packages/pull/4385)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add CMOV instruction to brillig and brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5308)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* Add expression width into acir
(https://github.com/AztecProtocol/aztec-packages/pull/4014)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Add instrumentation for tracking variables in debugging
([#4122](https://github.com/noir-lang/noir/issues/4122))
([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
* Add native rust implementation of schnorr signature verification
([#5053](https://github.com/noir-lang/noir/issues/5053))
([fab1c35](https://github.com/noir-lang/noir/commit/fab1c3567d731ea7902635a7a020a8d14f94fd27))
* Add native rust implementations of pedersen functions
([#4871](https://github.com/noir-lang/noir/issues/4871))
([fb039f7](https://github.com/noir-lang/noir/commit/fb039f74df23aea39bc0593a5d538d82b4efadf0))
* Add poseidon2 opcode implementation for acvm/brillig, and Noir
([#4398](https://github.com/noir-lang/noir/issues/4398))
([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
* Add return values to aztec fns
(https://github.com/AztecProtocol/aztec-packages/pull/5389)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Add session id to foreign call RPC requests
([#5205](https://github.com/noir-lang/noir/issues/5205))
([14adafc](https://github.com/noir-lang/noir/commit/14adafc965fa9c833e096ec037e086aae67703ad))
* Added cast opcode and cast calldata
(https://github.com/AztecProtocol/aztec-packages/pull/4423)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* AES blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6016)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Allow brillig to read arrays directly from memory
(https://github.com/AztecProtocol/aztec-packages/pull/4460)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow nested arrays and vectors in Brillig foreign calls
(https://github.com/AztecProtocol/aztec-packages/pull/4478)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Allow variables and stack trace inspection in the debugger
([#4184](https://github.com/noir-lang/noir/issues/4184))
([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
* Automatic NoteInterface and NoteGetterOptions auto select
(https://github.com/AztecProtocol/aztec-packages/pull/4508)
([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
* **avm:** Back in avm context with macro - refactor context
(https://github.com/AztecProtocol/aztec-packages/pull/4438)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* **avm:** Brillig CONST of size &gt; u128
(https://github.com/AztecProtocol/aztec-packages/pull/5217)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **avm:** Integrate AVM with initializers
(https://github.com/AztecProtocol/aztec-packages/pull/5469)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* **aztec-nr:** Initial work for aztec public vm macro
(https://github.com/AztecProtocol/aztec-packages/pull/4400)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Backpropagate constants in ACIR during optimization
([#3926](https://github.com/noir-lang/noir/issues/3926))
([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
* Bit shift is restricted to u8 right operand
([#4907](https://github.com/noir-lang/noir/issues/4907))
([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
* Brillig heterogeneous memory cells
(https://github.com/AztecProtocol/aztec-packages/pull/5608)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Brillig IR refactor
(https://github.com/AztecProtocol/aztec-packages/pull/5233)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Brillig pointer codegen and execution
(https://github.com/AztecProtocol/aztec-packages/pull/5737)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Brillig typed memory
(https://github.com/AztecProtocol/aztec-packages/pull/5395)
([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
* Change backend width to 4
(https://github.com/AztecProtocol/aztec-packages/pull/5374)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Check initializer msg.sender matches deployer from address preimage
(https://github.com/AztecProtocol/aztec-packages/pull/5222)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Contract interfaces and better function calls
(https://github.com/AztecProtocol/aztec-packages/pull/5687)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Contract_abi-exports
(https://github.com/AztecProtocol/aztec-packages/pull/5386)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Dynamic assertion payloads v2
(https://github.com/AztecProtocol/aztec-packages/pull/5949)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Evaluation of dynamic assert messages
([#4101](https://github.com/noir-lang/noir/issues/4101))
([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
* Handle `BrilligCall` opcodes in the debugger
([#4897](https://github.com/noir-lang/noir/issues/4897))
([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
* Impl of missing functionality in new key store
(https://github.com/AztecProtocol/aztec-packages/pull/5750)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Increase default expression width to 4
([#4995](https://github.com/noir-lang/noir/issues/4995))
([f01d309](https://github.com/noir-lang/noir/commit/f01d3090759a5ff0f1f83c5616d22890c6bd76be))
* Init storage macro
(https://github.com/AztecProtocol/aztec-packages/pull/4200)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Initial Earthly CI
(https://github.com/AztecProtocol/aztec-packages/pull/5069)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Internal as a macro
(https://github.com/AztecProtocol/aztec-packages/pull/4898)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Make ACVM generic across fields
([#5114](https://github.com/noir-lang/noir/issues/5114))
([70f374c](https://github.com/noir-lang/noir/commit/70f374c06642962d8f2b95b80f8c938fcf7761d7))
* Move abi demonomorphizer to noir_codegen and use noir_codegen in
protocol types
(https://github.com/AztecProtocol/aztec-packages/pull/6302)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Move to_radix to a blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6294)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* **nargo:** Handle call stacks for multiple Acir calls
([#4711](https://github.com/noir-lang/noir/issues/4711))
([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
* **nargo:** Hidden option to show contract artifact paths written by
`nargo compile`
(https://github.com/AztecProtocol/aztec-packages/pull/6131)
([ff67e14](https://github.com/noir-lang/noir/commit/ff67e145d086bf6fdf58fb5e57927033e52e03d3))
* New brillig field operations and refactor of binary operations
(https://github.com/AztecProtocol/aztec-packages/pull/5208)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Note type ids
(https://github.com/AztecProtocol/aztec-packages/pull/4500)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Parsing non-string assertion payloads in noir js
(https://github.com/AztecProtocol/aztec-packages/pull/6079)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Private Kernel Recursion
(https://github.com/AztecProtocol/aztec-packages/pull/6278)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Proper padding in ts AES and constrained AES in body and header
computations (https://github.com/AztecProtocol/aztec-packages/pull/6269)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Remove conditional compilation of `bn254_blackbox_solver`
([#5058](https://github.com/noir-lang/noir/issues/5058))
([9420d7c](https://github.com/noir-lang/noir/commit/9420d7c2ba6bbbf5ecb9a066837c505310955b6c))
* Remove external blackbox solver from acir simulator
(https://github.com/AztecProtocol/aztec-packages/pull/6586)
([a40a9a5](https://github.com/noir-lang/noir/commit/a40a9a55571deed386688fb84260bdf2794d4d38))
* Restore hashing args via slice for performance
(https://github.com/AztecProtocol/aztec-packages/pull/5539)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Restrict noir word size to u32
([#5180](https://github.com/noir-lang/noir/issues/5180))
([bdb2bc6](https://github.com/noir-lang/noir/commit/bdb2bc608ea8fd52d46545a38b68dd2558b28110))
* Separate runtimes of SSA functions before inlining
([#5121](https://github.com/noir-lang/noir/issues/5121))
([69eca9b](https://github.com/noir-lang/noir/commit/69eca9b8671fa54192bef814dd584fdb5387a5f7))
* Set aztec private functions to be recursive
(https://github.com/AztecProtocol/aztec-packages/pull/6192)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Signed integer division and modulus in brillig gen
(https://github.com/AztecProtocol/aztec-packages/pull/5279)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* **simulator:** Fetch return values at circuit execution
(https://github.com/AztecProtocol/aztec-packages/pull/5642)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Specify databus arrays for BB
(https://github.com/AztecProtocol/aztec-packages/pull/6239)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Storage_layout and `#[aztec(storage)]`
(https://github.com/AztecProtocol/aztec-packages/pull/5387)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Support contracts with no constructor
(https://github.com/AztecProtocol/aztec-packages/pull/5175)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Switch `bb` over to read ACIR from nargo artifacts
(https://github.com/AztecProtocol/aztec-packages/pull/6283)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from aztec-packages
([#4483](https://github.com/noir-lang/noir/issues/4483))
([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5234)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5286)
([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5572)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5619)
([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5697)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5794)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5814)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5935)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5955)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/5999)
([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6280)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6332)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Sync from noir
(https://github.com/AztecProtocol/aztec-packages/pull/6573)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* ToRadix BB + avm transpiler support
(https://github.com/AztecProtocol/aztec-packages/pull/6330)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Trap with revert data
(https://github.com/AztecProtocol/aztec-packages/pull/5732)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Use fixed size arrays in black box functions where sizes are known
(https://github.com/AztecProtocol/aztec-packages/pull/5620)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Variable length returns
(https://github.com/AztecProtocol/aztec-packages/pull/5633)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))


### Bug Fixes

* **acvm:** Mark outputs of Opcode::Call solvable
([#4708](https://github.com/noir-lang/noir/issues/4708))
([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
* Add support for nested arrays returned by oracles
([#5132](https://github.com/noir-lang/noir/issues/5132))
([f846879](https://github.com/noir-lang/noir/commit/f846879dd038328bd0a1d39a72b448ef52a1002b))
* Avoid huge unrolling in hash_args
(https://github.com/AztecProtocol/aztec-packages/pull/5703)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Catch panics from EC point creation (e.g. the point is at infinity)
([#4790](https://github.com/noir-lang/noir/issues/4790))
([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
* Check for public args in aztec functions
(https://github.com/AztecProtocol/aztec-packages/pull/6355)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
* Don't reuse brillig with slice arguments
(https://github.com/AztecProtocol/aztec-packages/pull/5800)
([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
* Issue 4682 and add solver for unconstrained bigintegers
([#4729](https://github.com/noir-lang/noir/issues/4729))
([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
* Noir test incorrect reporting
(https://github.com/AztecProtocol/aztec-packages/pull/4925)
([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
* Proper field inversion for bigints
([#4802](https://github.com/noir-lang/noir/issues/4802))
([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
* Temporarily revert to_radix blackbox
(https://github.com/AztecProtocol/aztec-packages/pull/6304)
([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))


### Miscellaneous Chores

* **acir:** Move `is_recursive` flag to be part of the circuit
definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
* Move noir out of yarn-project
(https://github.com/AztecProtocol/aztec-packages/pull/4479)
([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
* Remove `Opcode::Brillig` from ACIR
(https://github.com/AztecProtocol/aztec-packages/pull/5995)
([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
* Remove fixed-length keccak256
(https://github.com/AztecProtocol/aztec-packages/pull/5617)
([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
* Rename bigint_neg into bigint_sub
(https://github.com/AztecProtocol/aztec-packages/pull/4420)
([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
</details>

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).

---------

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
---
 .release-please-manifest.json                 |   4 +-
 CHANGELOG.md                                  |  92 +++
 Cargo.lock                                    |  52 +-
 Cargo.toml                                    |  16 +-
 acvm-repo/CHANGELOG.md                        | 148 +++++
 acvm-repo/acir/Cargo.toml                     |   2 +-
 acvm-repo/acir_field/Cargo.toml               |   2 +-
 acvm-repo/acvm/Cargo.toml                     |   2 +-
 acvm-repo/acvm_js/Cargo.toml                  |   2 +-
 acvm-repo/acvm_js/package.json                |   2 +-
 acvm-repo/blackbox_solver/Cargo.toml          |   2 +-
 acvm-repo/bn254_blackbox_solver/Cargo.toml    |   2 +-
 acvm-repo/brillig/Cargo.toml                  |   2 +-
 acvm-repo/brillig_vm/Cargo.toml               |   2 +-
 compiler/wasm/package.json                    |   2 +-
 .../explainers/explainer-oracle.md            |  57 ++
 .../explainers/explainer-recursion.md         | 176 ++++++
 .../getting_started/_category_.json           |   5 +
 .../barretenberg/_category_.json              |   6 +
 .../getting_started/barretenberg/index.md     |  47 ++
 .../hello_noir/_category_.json                |   5 +
 .../getting_started/hello_noir/index.md       | 145 +++++
 .../hello_noir/project_breakdown.md           | 159 +++++
 .../installation/_category_.json              |   6 +
 .../getting_started/installation/index.md     |  48 ++
 .../installation/other_install_methods.md     | 102 ++++
 .../getting_started/tooling/noir_codegen.md   | 114 ++++
 .../version-v0.31.0/how_to/_category_.json    |   5 +
 .../how_to/debugger/_category_.json           |   6 +
 .../debugger/debugging_with_the_repl.md       | 164 +++++
 .../how_to/debugger/debugging_with_vs_code.md |  68 +++
 .../version-v0.31.0/how_to/how-to-oracles.md  | 273 +++++++++
 .../how_to/how-to-recursion.md                | 180 ++++++
 .../how_to/how-to-solidity-verifier.md        | 251 ++++++++
 .../version-v0.31.0/how_to/merkle-proof.mdx   |  48 ++
 .../how_to/using-devcontainers.mdx            | 110 ++++
 docs/versioned_docs/version-v0.31.0/index.mdx |  67 ++
 .../version-v0.31.0/migration_notes.md        | 105 ++++
 .../noir/concepts/_category_.json             |   6 +
 .../version-v0.31.0/noir/concepts/assert.md   |  45 ++
 .../version-v0.31.0/noir/concepts/comments.md |  33 +
 .../noir/concepts/control_flow.md             |  77 +++
 .../version-v0.31.0/noir/concepts/data_bus.md |  21 +
 .../noir/concepts/data_types/_category_.json  |   5 +
 .../noir/concepts/data_types/arrays.md        | 253 ++++++++
 .../noir/concepts/data_types/booleans.md      |  28 +
 .../noir/concepts/data_types/fields.md        | 192 ++++++
 .../concepts/data_types/function_types.md     |  26 +
 .../noir/concepts/data_types/index.md         | 110 ++++
 .../noir/concepts/data_types/integers.md      | 156 +++++
 .../noir/concepts/data_types/references.md    |  23 +
 .../noir/concepts/data_types/slices.mdx       | 193 ++++++
 .../noir/concepts/data_types/strings.md       |  79 +++
 .../noir/concepts/data_types/structs.md       |  70 +++
 .../noir/concepts/data_types/tuples.md        |  48 ++
 .../noir/concepts/functions.md                | 226 +++++++
 .../version-v0.31.0/noir/concepts/generics.md | 106 ++++
 .../version-v0.31.0/noir/concepts/globals.md  |  72 +++
 .../version-v0.31.0/noir/concepts/lambdas.md  |  81 +++
 .../noir/concepts/mutability.md               | 121 ++++
 .../version-v0.31.0/noir/concepts/ops.md      |  98 +++
 .../version-v0.31.0/noir/concepts/oracles.md  |  31 +
 .../noir/concepts/shadowing.md                |  44 ++
 .../version-v0.31.0/noir/concepts/traits.md   | 389 ++++++++++++
 .../noir/concepts/unconstrained.md            |  99 +++
 .../modules_packages_crates/_category_.json   |   6 +
 .../crates_and_packages.md                    |  43 ++
 .../modules_packages_crates/dependencies.md   | 124 ++++
 .../noir/modules_packages_crates/modules.md   | 105 ++++
 .../modules_packages_crates/workspaces.md     |  42 ++
 .../noir/standard_library/_category_.json     |   6 +
 .../noir/standard_library/bigint.md           | 122 ++++
 .../noir/standard_library/black_box_fns.md    |  32 +
 .../noir/standard_library/bn254.md            |  46 ++
 .../standard_library/containers/boundedvec.md | 419 +++++++++++++
 .../standard_library/containers/hashmap.md    | 570 ++++++++++++++++++
 .../noir/standard_library/containers/index.md |   5 +
 .../noir/standard_library/containers/vec.mdx  | 170 ++++++
 .../cryptographic_primitives/_category_.json  |   5 +
 .../cryptographic_primitives/ciphers.mdx      |  32 +
 .../cryptographic_primitives/ec_primitives.md | 102 ++++
 .../ecdsa_sig_verification.mdx                |  98 +++
 .../cryptographic_primitives/eddsa.mdx        |  37 ++
 .../embedded_curve_ops.mdx                    |  98 +++
 .../cryptographic_primitives/hashes.mdx       | 246 ++++++++
 .../cryptographic_primitives/index.md         |  14 +
 .../cryptographic_primitives/schnorr.mdx      |  64 ++
 .../noir/standard_library/is_unconstrained.md |  59 ++
 .../noir/standard_library/logging.md          |  78 +++
 .../noir/standard_library/merkle_trees.md     |  58 ++
 .../noir/standard_library/options.md          | 101 ++++
 .../noir/standard_library/recursion.md        |  85 +++
 .../noir/standard_library/traits.md           | 464 ++++++++++++++
 .../noir/standard_library/zeroed.md           |  26 +
 .../NoirJS/backend_barretenberg/.nojekyll     |   1 +
 .../classes/BarretenbergBackend.md            | 160 +++++
 .../classes/BarretenbergVerifier.md           |  58 ++
 .../NoirJS/backend_barretenberg/index.md      |  40 ++
 .../type-aliases/BackendOptions.md            |  21 +
 .../backend_barretenberg/typedoc-sidebar.cjs  |   4 +
 .../reference/NoirJS/noir_js/.nojekyll        |   1 +
 .../reference/NoirJS/noir_js/classes/Noir.md  |  52 ++
 .../reference/NoirJS/noir_js/functions/and.md |  22 +
 .../NoirJS/noir_js/functions/blake2s256.md    |  21 +
 .../functions/ecdsa_secp256k1_verify.md       |  28 +
 .../functions/ecdsa_secp256r1_verify.md       |  28 +
 .../NoirJS/noir_js/functions/keccak256.md     |  21 +
 .../NoirJS/noir_js/functions/sha256.md        |  21 +
 .../reference/NoirJS/noir_js/functions/xor.md |  22 +
 .../reference/NoirJS/noir_js/index.md         |  49 ++
 .../noir_js/type-aliases/ErrorWithPayload.md  |  15 +
 .../type-aliases/ForeignCallHandler.md        |  24 +
 .../noir_js/type-aliases/ForeignCallInput.md  |   9 +
 .../noir_js/type-aliases/ForeignCallOutput.md |   9 +
 .../NoirJS/noir_js/type-aliases/WitnessMap.md |   9 +
 .../NoirJS/noir_js/typedoc-sidebar.cjs        |   4 +
 .../reference/NoirJS/noir_wasm/.nojekyll      |   1 +
 .../NoirJS/noir_wasm/functions/compile.md     |  51 ++
 .../noir_wasm/functions/compile_contract.md   |  51 ++
 .../noir_wasm/functions/createFileManager.md  |  21 +
 .../functions/inflateDebugSymbols.md          |  21 +
 .../reference/NoirJS/noir_wasm/index.md       |  49 ++
 .../NoirJS/noir_wasm/typedoc-sidebar.cjs      |   4 +
 .../version-v0.31.0/reference/_category_.json |   5 +
 .../reference/debugger/_category_.json        |   6 +
 .../debugger/debugger_known_limitations.md    |  59 ++
 .../reference/debugger/debugger_repl.md       | 360 +++++++++++
 .../reference/debugger/debugger_vscode.md     |  82 +++
 .../reference/nargo_commands.md               | 244 ++++++++
 .../version-v0.31.0/tooling/debugger.md       |  26 +
 .../tooling/language_server.md                |  43 ++
 .../version-v0.31.0/tooling/testing.md        |  62 ++
 .../version-v0.31.0/tutorials/noirjs_app.md   | 327 ++++++++++
 .../version-v0.31.0-sidebars.json             |  93 +++
 tooling/noir_codegen/package.json             |   2 +-
 tooling/noir_js/package.json                  |   2 +-
 .../noir_js_backend_barretenberg/package.json |   2 +-
 tooling/noir_js_types/package.json            |   2 +-
 tooling/noirc_abi_wasm/package.json           |   2 +-
 139 files changed, 10451 insertions(+), 51 deletions(-)
 create mode 100644 docs/versioned_docs/version-v0.31.0/explainers/explainer-oracle.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/explainers/explainer-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/project_breakdown.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/installation/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/installation/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/installation/other_install_methods.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/getting_started/tooling/noir_codegen.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_the_repl.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_vs_code.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/how-to-oracles.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/how-to-recursion.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/how-to-solidity-verifier.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/merkle-proof.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/how_to/using-devcontainers.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/index.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/migration_notes.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/assert.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/comments.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/control_flow.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_bus.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/arrays.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/booleans.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/fields.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/function_types.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/integers.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/references.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/slices.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/strings.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/structs.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/tuples.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/functions.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/generics.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/globals.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/lambdas.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/mutability.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/ops.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/oracles.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/shadowing.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/traits.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/concepts/unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/crates_and_packages.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/dependencies.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/modules.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/workspaces.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/bigint.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/black_box_fns.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/bn254.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/boundedvec.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/hashmap.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/vec.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/hashes.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/is_unconstrained.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/logging.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/merkle_trees.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/options.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/recursion.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/traits.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/noir/standard_library/zeroed.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/classes/Noir.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/and.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/blake2s256.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/keccak256.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/sha256.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/xor.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/.nojekyll
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/index.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/debugger/_category_.json
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_known_limitations.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_repl.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_vscode.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/reference/nargo_commands.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/tooling/debugger.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/tooling/language_server.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/tooling/testing.md
 create mode 100644 docs/versioned_docs/version-v0.31.0/tutorials/noirjs_app.md
 create mode 100644 docs/versioned_sidebars/version-v0.31.0-sidebars.json

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 83338327d88..a30d3e16ba7 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  ".": "0.30.0",
-  "acvm-repo": "0.46.0"
+  ".": "0.31.0",
+  "acvm-repo": "0.47.0"
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index db4ec8f4567..30678c05fb1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,97 @@
 # Changelog
 
+## [0.31.0](https://github.com/noir-lang/noir/compare/v0.30.0...v0.31.0) (2024-06-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove `dep::` prefix ([#4946](https://github.com/noir-lang/noir/issues/4946))
+* remove `distinct` keyword ([#5219](https://github.com/noir-lang/noir/issues/5219))
+* remove `param_witnesses` and `return_witnesses` from ABI ([#5154](https://github.com/noir-lang/noir/issues/5154))
+* add session id to foreign call RPC requests ([#5205](https://github.com/noir-lang/noir/issues/5205))
+* restrict noir word size to u32 ([#5180](https://github.com/noir-lang/noir/issues/5180))
+* separate proving from `noir_js` ([#5072](https://github.com/noir-lang/noir/issues/5072))
+* switch `bb` over to read ACIR from nargo artifacts (https://github.com/AztecProtocol/aztec-packages/pull/6283)
+* specify databus arrays for BB (https://github.com/AztecProtocol/aztec-packages/pull/6239)
+* **stdlib:** eddsa function using turbofish ([#5050](https://github.com/noir-lang/noir/issues/5050))
+
+### Features
+
+* `pxe.addNullifiedNote(...)` (https://github.com/AztecProtocol/aztec-packages/pull/6948) ([7de19f5](https://github.com/noir-lang/noir/commit/7de19f5856591203271836f07154abae13f5102b))
+* Activate return_data in ACIR opcodes ([#5080](https://github.com/noir-lang/noir/issues/5080)) ([c9fda3c](https://github.com/noir-lang/noir/commit/c9fda3c7fd4575bfe7d457e8d4230e071f0129a0))
+* Add `as_witness` builtin function in order to constrain a witness to be equal to a variable  ([#4641](https://github.com/noir-lang/noir/issues/4641)) ([faf5bd8](https://github.com/noir-lang/noir/commit/faf5bd8ed80fb89b4bb6a2536b9bfa9649579da7))
+* Add `set` and `set_unchecked` methods to `Vec` and `BoundedVec` ([#5241](https://github.com/noir-lang/noir/issues/5241)) ([1849389](https://github.com/noir-lang/noir/commit/1849389362e22e8236177f84b735dadf840cd637))
+* Add BoundedVec::map ([#5250](https://github.com/noir-lang/noir/issues/5250)) ([da1549c](https://github.com/noir-lang/noir/commit/da1549cfb296261b273a3a64908382e7b71512ad))
+* Add intrinsic to get if running inside an unconstrained context ([#5098](https://github.com/noir-lang/noir/issues/5098)) ([281ebf2](https://github.com/noir-lang/noir/commit/281ebf26e4cd16daf361938de505697f8d5fbd5e))
+* Add native rust implementation of schnorr signature verification ([#5053](https://github.com/noir-lang/noir/issues/5053)) ([fab1c35](https://github.com/noir-lang/noir/commit/fab1c3567d731ea7902635a7a020a8d14f94fd27))
+* Add session id to foreign call RPC requests ([#5205](https://github.com/noir-lang/noir/issues/5205)) ([14adafc](https://github.com/noir-lang/noir/commit/14adafc965fa9c833e096ec037e086aae67703ad))
+* Consider block parameters in variable liveness ([#5097](https://github.com/noir-lang/noir/issues/5097)) ([e4eb5f5](https://github.com/noir-lang/noir/commit/e4eb5f539f377fd3c2e1a874707ffce62a5bc10a))
+* **experimental:** Implement macro calls & splicing into `Expr` values ([#5203](https://github.com/noir-lang/noir/issues/5203)) ([d9b4712](https://github.com/noir-lang/noir/commit/d9b4712bf1a62548dd7ed17b181882ae537d70dd))
+* Implement println in the comptime interpreter ([#5197](https://github.com/noir-lang/noir/issues/5197)) ([7f08343](https://github.com/noir-lang/noir/commit/7f08343dfcafddfcec1b238746a69273ae4f4e2b))
+* Implement turbofish operator ([#3542](https://github.com/noir-lang/noir/issues/3542)) ([226724e](https://github.com/noir-lang/noir/commit/226724e3b54c2e0d9ba005661c76b40a87d9295a))
+* Make ACVM generic across fields ([#5114](https://github.com/noir-lang/noir/issues/5114)) ([70f374c](https://github.com/noir-lang/noir/commit/70f374c06642962d8f2b95b80f8c938fcf7761d7))
+* Move abi demonomorphizer to noir_codegen and use noir_codegen in protocol types (https://github.com/AztecProtocol/aztec-packages/pull/6302) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Move to_radix to a blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6294) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* **nargo:** Hidden option to show contract artifact paths written by `nargo compile` (https://github.com/AztecProtocol/aztec-packages/pull/6131) ([ff67e14](https://github.com/noir-lang/noir/commit/ff67e145d086bf6fdf58fb5e57927033e52e03d3))
+* Place return value witnesses directly after function arguments ([#5142](https://github.com/noir-lang/noir/issues/5142)) ([1252b5f](https://github.com/noir-lang/noir/commit/1252b5fcc7ed56bb55e95745b83be6e556805397))
+* Private Kernel Recursion (https://github.com/AztecProtocol/aztec-packages/pull/6278) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Proper padding in ts AES and constrained AES in body and header computations (https://github.com/AztecProtocol/aztec-packages/pull/6269) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Remove `dep::` prefix ([#4946](https://github.com/noir-lang/noir/issues/4946)) ([d6d0ae2](https://github.com/noir-lang/noir/commit/d6d0ae26d2fef083dc240539b834d934c84b0326))
+* Remove conditional compilation of `bn254_blackbox_solver` ([#5058](https://github.com/noir-lang/noir/issues/5058)) ([9420d7c](https://github.com/noir-lang/noir/commit/9420d7c2ba6bbbf5ecb9a066837c505310955b6c))
+* Remove external blackbox solver from acir simulator (https://github.com/AztecProtocol/aztec-packages/pull/6586) ([a40a9a5](https://github.com/noir-lang/noir/commit/a40a9a55571deed386688fb84260bdf2794d4d38))
+* Replace stdlib poseidon implementation with optimized version ([#5122](https://github.com/noir-lang/noir/issues/5122)) ([11e98f3](https://github.com/noir-lang/noir/commit/11e98f348d1d43a9b28d83ec3308027b7afc0da6))
+* Restrict noir word size to u32 ([#5180](https://github.com/noir-lang/noir/issues/5180)) ([bdb2bc6](https://github.com/noir-lang/noir/commit/bdb2bc608ea8fd52d46545a38b68dd2558b28110))
+* Separate proving from `noir_js` ([#5072](https://github.com/noir-lang/noir/issues/5072)) ([c93c738](https://github.com/noir-lang/noir/commit/c93c7380c705fcec5c77bfc436c2f5ea085edd77))
+* Separate runtimes of SSA functions before inlining ([#5121](https://github.com/noir-lang/noir/issues/5121)) ([69eca9b](https://github.com/noir-lang/noir/commit/69eca9b8671fa54192bef814dd584fdb5387a5f7))
+* Specify databus arrays for BB (https://github.com/AztecProtocol/aztec-packages/pull/6239) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Standardize pedersen functions to return `EmbeddedCurvePoint` ([#5190](https://github.com/noir-lang/noir/issues/5190)) ([3b85b36](https://github.com/noir-lang/noir/commit/3b85b3637f81f3894a7faa07fd299f9d64747214))
+* **stdlib:** Eddsa function using turbofish ([#5050](https://github.com/noir-lang/noir/issues/5050)) ([7936262](https://github.com/noir-lang/noir/commit/79362629ed8cf42b6601e9a551ed8f9fe03e0112))
+* Support casting in globals ([#5164](https://github.com/noir-lang/noir/issues/5164)) ([6d3e732](https://github.com/noir-lang/noir/commit/6d3e732e06033b53506656acdd3d7759bd27f106))
+* Switch `bb` over to read ACIR from nargo artifacts (https://github.com/AztecProtocol/aztec-packages/pull/6283) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6280) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6332) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6573) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6986) ([7de19f5](https://github.com/noir-lang/noir/commit/7de19f5856591203271836f07154abae13f5102b))
+* ToRadix BB + avm transpiler support (https://github.com/AztecProtocol/aztec-packages/pull/6330) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+
+
+### Bug Fixes
+
+* Add support for nested arrays returned by oracles ([#5132](https://github.com/noir-lang/noir/issues/5132)) ([f846879](https://github.com/noir-lang/noir/commit/f846879dd038328bd0a1d39a72b448ef52a1002b))
+* Apply self type from generic trait constraint before instantiating identifiers ([#5087](https://github.com/noir-lang/noir/issues/5087)) ([2b4755c](https://github.com/noir-lang/noir/commit/2b4755c2b57460d5eb839ee835f8c9acd5773a7c))
+* Auto dereference trait methods in the elaborator ([#5124](https://github.com/noir-lang/noir/issues/5124)) ([56c1a85](https://github.com/noir-lang/noir/commit/56c1a85056ed338644595f1aa58cc94563786b9e))
+* Check for public args in aztec functions (https://github.com/AztecProtocol/aztec-packages/pull/6355) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Disable `if` optimization ([#5240](https://github.com/noir-lang/noir/issues/5240)) ([a2816db](https://github.com/noir-lang/noir/commit/a2816dbf7f9d31967fc95205a43fdfdf181029b0))
+* **elaborator:** Fix duplicate methods error ([#5225](https://github.com/noir-lang/noir/issues/5225)) ([87a1d8e](https://github.com/noir-lang/noir/commit/87a1d8ebaadb5f0f1ed637b96816f971f946af87))
+* **elaborator:** Fix regression introduced by lazy-global changes ([#5223](https://github.com/noir-lang/noir/issues/5223)) ([fde432a](https://github.com/noir-lang/noir/commit/fde432aacc436b6c57f0d937d7c86836bac0b465))
+* **elaborator:** Invert unconstrained check ([#5176](https://github.com/noir-lang/noir/issues/5176)) ([967c0fa](https://github.com/noir-lang/noir/commit/967c0fa76da9384afe918a8b23eef60f12f29292))
+* **elaborator:** Lazily elaborate globals ([#5191](https://github.com/noir-lang/noir/issues/5191)) ([9c99a97](https://github.com/noir-lang/noir/commit/9c99a97ca8f42bee23cf97ebd724fdc51e647c60))
+* Error for allocate instructions in acir-gen ([#5200](https://github.com/noir-lang/noir/issues/5200)) ([58c7532](https://github.com/noir-lang/noir/commit/58c7532da8dd86ee02b20d7e7809f5437f667845))
+* **experimental elaborator:** Avoid calling `add_generics` twice on trait methods ([#5108](https://github.com/noir-lang/noir/issues/5108)) ([7d8c0a3](https://github.com/noir-lang/noir/commit/7d8c0a3a1ae143b574b2fa62cae7c0a493005c70))
+* **experimental elaborator:** Clear generics after elaborating type aliases ([#5136](https://github.com/noir-lang/noir/issues/5136)) ([b0a7d0b](https://github.com/noir-lang/noir/commit/b0a7d0b12328d3ed9faed87b78792b77786018e0))
+* **experimental elaborator:** Fix `impl Trait` when `--use-elaborator` is selected ([#5138](https://github.com/noir-lang/noir/issues/5138)) ([7ea5962](https://github.com/noir-lang/noir/commit/7ea5962e77b7183374a4e14da3a237ccd63f00a0))
+* **experimental elaborator:** Fix definition kind of globals and tuple patterns with `--use-elaborator` flag ([#5139](https://github.com/noir-lang/noir/issues/5139)) ([a140dec](https://github.com/noir-lang/noir/commit/a140dec4580459c5856d44337de3ea08aa7fb44a))
+* **experimental elaborator:** Fix duplicate `resolve_type` on self type and don't leak a trait impl's generics ([#5102](https://github.com/noir-lang/noir/issues/5102)) ([db561e2](https://github.com/noir-lang/noir/commit/db561e229cfcb35f23205cbb7e41fcf5ece68ee5))
+* **experimental elaborator:** Fix frontend tests when `--use-elaborator` flag is specified ([#5145](https://github.com/noir-lang/noir/issues/5145)) ([d6122eb](https://github.com/noir-lang/noir/commit/d6122eb9e88aa2b1bb6c990e452fa9678ae49704))
+* **experimental elaborator:** Fix global values used in the elaborator ([#5135](https://github.com/noir-lang/noir/issues/5135)) ([e73cdbb](https://github.com/noir-lang/noir/commit/e73cdbb93b0714331fef754f862d89c08c28a9e5))
+* **experimental elaborator:** Fix globals which use function calls ([#5172](https://github.com/noir-lang/noir/issues/5172)) ([ab0b1a8](https://github.com/noir-lang/noir/commit/ab0b1a85cc91f8ed748ee393ece54f5c3b43d7ef))
+* **experimental elaborator:** Fix panic in the elaborator ([#5082](https://github.com/noir-lang/noir/issues/5082)) ([ffcb410](https://github.com/noir-lang/noir/commit/ffcb410978a362c73783fbfe5bbdc9691499609e))
+* **experimental elaborator:** Only call `add_generics` once ([#5091](https://github.com/noir-lang/noir/issues/5091)) ([f5d2946](https://github.com/noir-lang/noir/commit/f5d294645e82fc85d8dc28ee2a846ba11af85ce5))
+* Fix panic in `get_global_let_statement` ([#5177](https://github.com/noir-lang/noir/issues/5177)) ([b769b01](https://github.com/noir-lang/noir/commit/b769b01fd06a6a2c66c72f9aa4e1d346b0fca123))
+* **frontend:** Call trait method with mut self from generic definition ([#5041](https://github.com/noir-lang/noir/issues/5041)) ([89846cf](https://github.com/noir-lang/noir/commit/89846cfbc4961c5258d91b5973f027be80885a20))
+* **frontend:** Correctly monomorphize turbofish functions ([#5049](https://github.com/noir-lang/noir/issues/5049)) ([fd772e7](https://github.com/noir-lang/noir/commit/fd772e7a764004373f5a41a54eb6847f4decda77))
+* **frontend:** Resolve object types from method calls a single time ([#5131](https://github.com/noir-lang/noir/issues/5131)) ([3afe023](https://github.com/noir-lang/noir/commit/3afe023543e301aafaf2b79f0ccd6d7936dd53a9))
+* Temporarily revert to_radix blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6304) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Use plain integer addresses for opcodes in DAP disassembly view ([#4941](https://github.com/noir-lang/noir/issues/4941)) ([d43ba1b](https://github.com/noir-lang/noir/commit/d43ba1bddbf6ebd56a7bee0e1db38d155fec95d5))
+* Use predicate for curve operations ([#5076](https://github.com/noir-lang/noir/issues/5076)) ([145b909](https://github.com/noir-lang/noir/commit/145b90945486907cb6db75d3f3f93a58d19b2a32))
+* Wrapping in signed division ([#5134](https://github.com/noir-lang/noir/issues/5134)) ([29baeb4](https://github.com/noir-lang/noir/commit/29baeb41e15918935c437e0a2759c6b936f125a4))
+
+
+### Miscellaneous Chores
+
+* Remove `distinct` keyword ([#5219](https://github.com/noir-lang/noir/issues/5219)) ([1d62c59](https://github.com/noir-lang/noir/commit/1d62c59a8f02f7d277c5bf9ed637348a3b2f399c))
+* Remove `param_witnesses` and `return_witnesses` from ABI ([#5154](https://github.com/noir-lang/noir/issues/5154)) ([21562ae](https://github.com/noir-lang/noir/commit/21562aeea162d246573967115e7c519715f6d3d8))
+
 ## [0.30.0](https://github.com/noir-lang/noir/compare/v0.29.0...v0.30.0) (2024-05-20)
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 7b96737f241..9a54944933e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acir_field",
  "base64 0.21.2",
@@ -26,7 +26,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -40,7 +40,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -55,7 +55,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acir",
  "blake2",
@@ -93,7 +93,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_js"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -443,7 +443,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "aztec_macros"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "convert_case 0.6.0",
@@ -570,7 +570,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -588,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "brillig"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -596,7 +596,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.46.0"
+version = "0.47.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -1514,7 +1514,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -2075,7 +2075,7 @@ dependencies = [
 
 [[package]]
 name = "iter-extended"
-version = "0.30.0"
+version = "0.31.0"
 
 [[package]]
 name = "itertools"
@@ -2470,7 +2470,7 @@ dependencies = [
 
 [[package]]
 name = "nargo"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2496,7 +2496,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_cli"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2548,7 +2548,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "bytecount",
  "noirc_frontend",
@@ -2560,7 +2560,7 @@ dependencies = [
 
 [[package]]
 name = "nargo_toml"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2639,7 +2639,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2674,7 +2674,7 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "async-lsp",
@@ -2700,7 +2700,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2723,7 +2723,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -2742,7 +2742,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2759,11 +2759,11 @@ dependencies = [
 
 [[package]]
 name = "noirc_arena"
-version = "0.30.0"
+version = "0.31.0"
 
 [[package]]
 name = "noirc_driver"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "aztec_macros",
@@ -2783,7 +2783,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -2801,7 +2801,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "chrono",
@@ -2818,7 +2818,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_frontend"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "base64 0.21.2",
@@ -2850,7 +2850,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "acvm",
  "iter-extended",
diff --git a/Cargo.toml b/Cargo.toml
index 639807819ab..8a4c94d8876 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.30.0"
+version = "0.31.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -50,13 +50,13 @@ repository = "https://github.com/noir-lang/noir/"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.46.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.46.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.46.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.46.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.46.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.46.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.46.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+acir_field = { version = "0.47.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "0.47.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "0.47.0", path = "acvm-repo/acvm" }
+brillig = { version = "0.47.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "0.47.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "0.47.0", path = "acvm-repo/blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "0.47.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 fm = { path = "compiler/fm" }
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index c9bb0d610eb..4db36aadec9 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,154 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.47.0](https://github.com/noir-lang/noir/compare/v0.46.0...v0.47.0) (2024-06-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* add session id to foreign call RPC requests ([#5205](https://github.com/noir-lang/noir/issues/5205))
+* restrict noir word size to u32 ([#5180](https://github.com/noir-lang/noir/issues/5180))
+* switch `bb` over to read ACIR from nargo artifacts (https://github.com/AztecProtocol/aztec-packages/pull/6283)
+* specify databus arrays for BB (https://github.com/AztecProtocol/aztec-packages/pull/6239)
+* remove `Opcode::Brillig` from ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5995)
+* AES blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6016)
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907))
+* contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687)
+* change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374)
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620)
+* trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732)
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709)
+* remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617)
+* storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387)
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616)
+* contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386)
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395)
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149)
+* automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508)
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773)
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175)
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898)
+* move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479)
+* note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500)
+* rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420)
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014)
+* init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200)
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221)
+
+### Features
+
+* `multi_scalar_mul` blackbox func (https://github.com/AztecProtocol/aztec-packages/pull/6097) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* `variable_base_scalar_mul` blackbox func (https://github.com/AztecProtocol/aztec-packages/pull/6039) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Acir call opcode (https://github.com/AztecProtocol/aztec-packages/pull/4773) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **acir_gen:** Brillig stdlib ([#4848](https://github.com/noir-lang/noir/issues/4848)) ([0c8175c](https://github.com/noir-lang/noir/commit/0c8175cb539efd9427c73ae5af0d48abe688ebab))
+* **acir_gen:** Fold attribute at compile-time and initial non inlined ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5341) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* **acir:** Add predicate to call opcode (https://github.com/AztecProtocol/aztec-packages/pull/5616) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **acir:** BrilligCall opcode  (https://github.com/AztecProtocol/aztec-packages/pull/5709) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* **acir:** Program and witness stack structure (https://github.com/AztecProtocol/aztec-packages/pull/5149) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Activate return_data in ACIR opcodes ([#5080](https://github.com/noir-lang/noir/issues/5080)) ([c9fda3c](https://github.com/noir-lang/noir/commit/c9fda3c7fd4575bfe7d457e8d4230e071f0129a0))
+* **acvm_js:** Execute program  ([#4694](https://github.com/noir-lang/noir/issues/4694)) ([386f6d0](https://github.com/noir-lang/noir/commit/386f6d0a5822912db878285cb001032a7c0ff622))
+* **acvm:** Execute multiple circuits  (https://github.com/AztecProtocol/aztec-packages/pull/5380) ([a0f7474](https://github.com/noir-lang/noir/commit/a0f7474ae6bd74132efdb945d2eb2383f3913cce))
+* Add bit size to const opcode (https://github.com/AztecProtocol/aztec-packages/pull/4385) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add CMOV instruction to brillig and brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5308) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* Add expression width into acir (https://github.com/AztecProtocol/aztec-packages/pull/4014) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Add instrumentation for tracking variables in debugging ([#4122](https://github.com/noir-lang/noir/issues/4122)) ([c58d691](https://github.com/noir-lang/noir/commit/c58d69141b54a918cd1675400c00bfd48720f896))
+* Add native rust implementation of schnorr signature verification ([#5053](https://github.com/noir-lang/noir/issues/5053)) ([fab1c35](https://github.com/noir-lang/noir/commit/fab1c3567d731ea7902635a7a020a8d14f94fd27))
+* Add native rust implementations of pedersen functions ([#4871](https://github.com/noir-lang/noir/issues/4871)) ([fb039f7](https://github.com/noir-lang/noir/commit/fb039f74df23aea39bc0593a5d538d82b4efadf0))
+* Add poseidon2 opcode implementation for acvm/brillig, and Noir ([#4398](https://github.com/noir-lang/noir/issues/4398)) ([10e8292](https://github.com/noir-lang/noir/commit/10e82920798380f50046e52db4a20ca205191ab7))
+* Add return values to aztec fns (https://github.com/AztecProtocol/aztec-packages/pull/5389) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Add session id to foreign call RPC requests ([#5205](https://github.com/noir-lang/noir/issues/5205)) ([14adafc](https://github.com/noir-lang/noir/commit/14adafc965fa9c833e096ec037e086aae67703ad))
+* Added cast opcode and cast calldata (https://github.com/AztecProtocol/aztec-packages/pull/4423) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* AES blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6016) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Allow brillig to read arrays directly from memory (https://github.com/AztecProtocol/aztec-packages/pull/4460) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow nested arrays and vectors in Brillig foreign calls (https://github.com/AztecProtocol/aztec-packages/pull/4478) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Allow variables and stack trace inspection in the debugger ([#4184](https://github.com/noir-lang/noir/issues/4184)) ([bf263fc](https://github.com/noir-lang/noir/commit/bf263fc8d843940f328a90f6366edd2671fb2682))
+* Automatic NoteInterface and NoteGetterOptions auto select (https://github.com/AztecProtocol/aztec-packages/pull/4508) ([13eb71b](https://github.com/noir-lang/noir/commit/13eb71b8de44eb6aad9c37943ad06fc73db589f5))
+* **avm:** Back in avm context with macro - refactor context (https://github.com/AztecProtocol/aztec-packages/pull/4438) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* **avm:** Brillig CONST of size &gt; u128 (https://github.com/AztecProtocol/aztec-packages/pull/5217) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **avm:** Integrate AVM with initializers (https://github.com/AztecProtocol/aztec-packages/pull/5469) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* **aztec-nr:** Initial work for aztec public vm macro (https://github.com/AztecProtocol/aztec-packages/pull/4400) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Backpropagate constants in ACIR during optimization ([#3926](https://github.com/noir-lang/noir/issues/3926)) ([aad0da0](https://github.com/noir-lang/noir/commit/aad0da024c69663f42e6913e674682d5864b26ae))
+* Bit shift is restricted to u8 right operand ([#4907](https://github.com/noir-lang/noir/issues/4907)) ([c4b0369](https://github.com/noir-lang/noir/commit/c4b03691feca17ef268acab523292f3051f672ea))
+* Brillig heterogeneous memory cells (https://github.com/AztecProtocol/aztec-packages/pull/5608) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Brillig IR refactor (https://github.com/AztecProtocol/aztec-packages/pull/5233) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Brillig pointer codegen and execution (https://github.com/AztecProtocol/aztec-packages/pull/5737) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Brillig typed memory (https://github.com/AztecProtocol/aztec-packages/pull/5395) ([0bc18c4](https://github.com/noir-lang/noir/commit/0bc18c4f78171590dd58bded959f68f53a44cc8c))
+* Change backend width to 4 (https://github.com/AztecProtocol/aztec-packages/pull/5374) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Check initializer msg.sender matches deployer from address preimage (https://github.com/AztecProtocol/aztec-packages/pull/5222) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Contract interfaces and better function calls (https://github.com/AztecProtocol/aztec-packages/pull/5687) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Contract_abi-exports (https://github.com/AztecProtocol/aztec-packages/pull/5386) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Dynamic assertion payloads v2 (https://github.com/AztecProtocol/aztec-packages/pull/5949) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Evaluation of dynamic assert messages ([#4101](https://github.com/noir-lang/noir/issues/4101)) ([c284e01](https://github.com/noir-lang/noir/commit/c284e01bfe20ceae4414dc123624b5cbb8b66d09))
+* Handle `BrilligCall` opcodes in the debugger ([#4897](https://github.com/noir-lang/noir/issues/4897)) ([b380dc4](https://github.com/noir-lang/noir/commit/b380dc44de5c9f8de278ece3d531ebbc2c9238ba))
+* Impl of missing functionality in new key store (https://github.com/AztecProtocol/aztec-packages/pull/5750) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Increase default expression width to 4 ([#4995](https://github.com/noir-lang/noir/issues/4995)) ([f01d309](https://github.com/noir-lang/noir/commit/f01d3090759a5ff0f1f83c5616d22890c6bd76be))
+* Init storage macro (https://github.com/AztecProtocol/aztec-packages/pull/4200) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Initial Earthly CI (https://github.com/AztecProtocol/aztec-packages/pull/5069) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Internal as a macro (https://github.com/AztecProtocol/aztec-packages/pull/4898) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Make ACVM generic across fields ([#5114](https://github.com/noir-lang/noir/issues/5114)) ([70f374c](https://github.com/noir-lang/noir/commit/70f374c06642962d8f2b95b80f8c938fcf7761d7))
+* Move abi demonomorphizer to noir_codegen and use noir_codegen in protocol types (https://github.com/AztecProtocol/aztec-packages/pull/6302) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Move to_radix to a blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6294) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* **nargo:** Handle call stacks for multiple Acir calls ([#4711](https://github.com/noir-lang/noir/issues/4711)) ([5b23171](https://github.com/noir-lang/noir/commit/5b231714740447d82cde7cdbe65d4a8b46a31df4))
+* **nargo:** Hidden option to show contract artifact paths written by `nargo compile` (https://github.com/AztecProtocol/aztec-packages/pull/6131) ([ff67e14](https://github.com/noir-lang/noir/commit/ff67e145d086bf6fdf58fb5e57927033e52e03d3))
+* New brillig field operations and refactor of binary operations (https://github.com/AztecProtocol/aztec-packages/pull/5208) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Note type ids (https://github.com/AztecProtocol/aztec-packages/pull/4500) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Parsing non-string assertion payloads in noir js (https://github.com/AztecProtocol/aztec-packages/pull/6079) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Private Kernel Recursion (https://github.com/AztecProtocol/aztec-packages/pull/6278) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Proper padding in ts AES and constrained AES in body and header computations (https://github.com/AztecProtocol/aztec-packages/pull/6269) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Remove conditional compilation of `bn254_blackbox_solver` ([#5058](https://github.com/noir-lang/noir/issues/5058)) ([9420d7c](https://github.com/noir-lang/noir/commit/9420d7c2ba6bbbf5ecb9a066837c505310955b6c))
+* Remove external blackbox solver from acir simulator (https://github.com/AztecProtocol/aztec-packages/pull/6586) ([a40a9a5](https://github.com/noir-lang/noir/commit/a40a9a55571deed386688fb84260bdf2794d4d38))
+* Restore hashing args via slice for performance (https://github.com/AztecProtocol/aztec-packages/pull/5539) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Restrict noir word size to u32 ([#5180](https://github.com/noir-lang/noir/issues/5180)) ([bdb2bc6](https://github.com/noir-lang/noir/commit/bdb2bc608ea8fd52d46545a38b68dd2558b28110))
+* Separate runtimes of SSA functions before inlining ([#5121](https://github.com/noir-lang/noir/issues/5121)) ([69eca9b](https://github.com/noir-lang/noir/commit/69eca9b8671fa54192bef814dd584fdb5387a5f7))
+* Set aztec private functions to be recursive (https://github.com/AztecProtocol/aztec-packages/pull/6192) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Signed integer division and modulus in brillig gen (https://github.com/AztecProtocol/aztec-packages/pull/5279) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* **simulator:** Fetch return values at circuit execution (https://github.com/AztecProtocol/aztec-packages/pull/5642) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Specify databus arrays for BB (https://github.com/AztecProtocol/aztec-packages/pull/6239) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Storage_layout and `#[aztec(storage)]` (https://github.com/AztecProtocol/aztec-packages/pull/5387) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Support contracts with no constructor (https://github.com/AztecProtocol/aztec-packages/pull/5175) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Switch `bb` over to read ACIR from nargo artifacts (https://github.com/AztecProtocol/aztec-packages/pull/6283) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from aztec-packages ([#4483](https://github.com/noir-lang/noir/issues/4483)) ([fe8f277](https://github.com/noir-lang/noir/commit/fe8f2776ccfde29209a2c3fc162311c99e4f59be))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5234) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5286) ([c3c9e19](https://github.com/noir-lang/noir/commit/c3c9e19a20d61272a04b95fd6c7d34cc4cb96e45))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5572) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5619) ([2bd006a](https://github.com/noir-lang/noir/commit/2bd006ae07499e8702b0fa9565855f0a5ef1a589))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5697) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5794) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5814) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5935) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5955) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/5999) ([1b867b1](https://github.com/noir-lang/noir/commit/1b867b121fba5db3087ca845b4934e6732b23fd1))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6280) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6332) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/6573) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* ToRadix BB + avm transpiler support (https://github.com/AztecProtocol/aztec-packages/pull/6330) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Trap with revert data (https://github.com/AztecProtocol/aztec-packages/pull/5732) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Use fixed size arrays in black box functions where sizes are known (https://github.com/AztecProtocol/aztec-packages/pull/5620) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Variable length returns (https://github.com/AztecProtocol/aztec-packages/pull/5633) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+
+
+### Bug Fixes
+
+* **acvm:** Mark outputs of Opcode::Call solvable ([#4708](https://github.com/noir-lang/noir/issues/4708)) ([8fea405](https://github.com/noir-lang/noir/commit/8fea40576f262bd5bb588923c0660d8967404e56))
+* Add support for nested arrays returned by oracles ([#5132](https://github.com/noir-lang/noir/issues/5132)) ([f846879](https://github.com/noir-lang/noir/commit/f846879dd038328bd0a1d39a72b448ef52a1002b))
+* Avoid huge unrolling in hash_args (https://github.com/AztecProtocol/aztec-packages/pull/5703) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Catch panics from EC point creation (e.g. the point is at infinity) ([#4790](https://github.com/noir-lang/noir/issues/4790)) ([645dba1](https://github.com/noir-lang/noir/commit/645dba192f16ef34018828186ffb297422a8dc73))
+* Check for public args in aztec functions (https://github.com/AztecProtocol/aztec-packages/pull/6355) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+* Don't reuse brillig with slice arguments (https://github.com/AztecProtocol/aztec-packages/pull/5800) ([0f9ae0a](https://github.com/noir-lang/noir/commit/0f9ae0ac1d68714b56ba4524aedcc67212494f1b))
+* Issue 4682 and add solver for unconstrained bigintegers ([#4729](https://github.com/noir-lang/noir/issues/4729)) ([e4d33c1](https://github.com/noir-lang/noir/commit/e4d33c126a2795d9aaa6048d4e91b64cb4bbe4f2))
+* Noir test incorrect reporting (https://github.com/AztecProtocol/aztec-packages/pull/4925) ([5f57ebb](https://github.com/noir-lang/noir/commit/5f57ebb7ff4b810802f90699a10f4325ef904f2e))
+* Proper field inversion for bigints ([#4802](https://github.com/noir-lang/noir/issues/4802)) ([b46d0e3](https://github.com/noir-lang/noir/commit/b46d0e39f4252f8bbaa987f88d112e4c233b3d61))
+* Temporarily revert to_radix blackbox (https://github.com/AztecProtocol/aztec-packages/pull/6304) ([436bbda](https://github.com/noir-lang/noir/commit/436bbdaadb2a294b94f93e53d7d3cad3859c7e46))
+
+
+### Miscellaneous Chores
+
+* **acir:** Move `is_recursive` flag to be part of the circuit definition (https://github.com/AztecProtocol/aztec-packages/pull/4221) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+* Move noir out of yarn-project (https://github.com/AztecProtocol/aztec-packages/pull/4479) ([78ef013](https://github.com/noir-lang/noir/commit/78ef0134b82e76a73dadb6c7975def22290e3a1a))
+* Remove `Opcode::Brillig` from ACIR (https://github.com/AztecProtocol/aztec-packages/pull/5995) ([73a635e](https://github.com/noir-lang/noir/commit/73a635e5086cf3407f9846ce39807cd15b4e485a))
+* Remove fixed-length keccak256 (https://github.com/AztecProtocol/aztec-packages/pull/5617) ([305bcdc](https://github.com/noir-lang/noir/commit/305bcdcbd01cb84dbaac900f14cb6cf867f83bda))
+* Rename bigint_neg into bigint_sub (https://github.com/AztecProtocol/aztec-packages/pull/4420) ([158c8ce](https://github.com/noir-lang/noir/commit/158c8cec7f0dc698042e9512001dd2c9d6b40bcc))
+
 ## [0.46.0](https://github.com/noir-lang/noir/compare/v0.45.0...v0.46.0) (2024-05-20)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index 101ce7a0f39..7a8f10c98ef 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 801935c90f9..303d7b6471f 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 59305ec49f0..892575902a4 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 63f64e97729..e457b6391ab 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 48c5b2a8644..6085bc0563e 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index dd7f84e63e4..06bd3ceabef 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index 37d40de71a9..cc2d15aaa86 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 245767dcecd..7c1965c8f3e 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index 4735514c9a7..d048d625083 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.46.0"
+version = "0.47.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index 0bb9b803ee0..49956d79882 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.30.0",
+  "version": "0.31.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/docs/versioned_docs/version-v0.31.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.31.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..b84ca5dd986
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have a oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they matches the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.31.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.31.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..18846176ca7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/_category_.json b/docs/versioned_docs/version-v0.31.0/getting_started/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/_category_.json b/docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/_category_.json
new file mode 100644
index 00000000000..27a8e89228d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 1,
+    "label": "Install Barretenberg",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/index.md b/docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/index.md
new file mode 100644
index 00000000000..0102c86770b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/barretenberg/index.md
@@ -0,0 +1,47 @@
+---
+title: Barretenberg Installation
+description: bb is a command line tool for interacting with Aztec's proving backend Barretenberg. This page is a quick guide on how to install `bb`
+keywords: [
+  Barretenberg
+  bb
+  Installation
+  Terminal Commands
+  Version Check
+  Nightlies
+  Specific Versions
+  Branches
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`bb` is the CLI tool for generating and verifying proofs for Noir programs using the Barretenberg proving library. It also allows generating solidity verifier contracts for which you can verify contracts which were constructed using `bb`.
+
+## Installing `bb`
+
+Open a terminal on your machine, and write:
+
+##### macOS (Apple Silicon)
+
+```bash
+curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
+source ~/.zshrc
+bbup -v 0.41.0
+```
+
+##### macOS (Intel)
+
+```bash
+curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
+source ~/.zshrc
+bbup -v 0.41.0
+```
+
+##### Linux (Bash)
+
+```bash
+curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash
+source ~/.bashrc
+bbup -v 0.41.0
+```
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/_category_.json
new file mode 100644
index 00000000000..976a2325de0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/index.md
new file mode 100644
index 00000000000..1ade3f09ae3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/index.md
@@ -0,0 +1,145 @@
+---
+title: Creating a Project
+description:
+  Learn how to create and verify your first Noir program using Nargo, a programming language for
+  zero-knowledge proofs.
+keywords:
+  [
+    Nargo,
+    Noir,
+    zero-knowledge proofs,
+    programming language,
+    create Noir program,
+    verify Noir program,
+    step-by-step guide,
+  ]
+sidebar_position: 1
+
+---
+
+Now that we have installed Nargo, it is time to make our first hello world program!
+
+## Create a Project Directory
+
+Noir code can live anywhere on your computer. Let us create a _projects_ folder in the home
+directory to house our Noir programs.
+
+For Linux, macOS, and Windows PowerShell, create the directory and change directory into it by
+running:
+
+```sh
+mkdir ~/projects
+cd ~/projects
+```
+
+## Create Our First Nargo Project
+
+Now that we are in the projects directory, create a new Nargo project by running:
+
+```sh
+nargo new hello_world
+```
+
+> **Note:** `hello_world` can be any arbitrary project name, we are simply using `hello_world` for
+> demonstration.
+>
+> In production, the common practice is to name the project folder as `circuits` for better
+> identifiability when sitting alongside other folders in the codebase (e.g. `contracts`, `scripts`,
+> `test`).
+
+A `hello_world` folder would be created. Similar to Rust, the folder houses _src/main.nr_ and
+_Nargo.toml_ which contain the source code and environmental options of your Noir program
+respectively.
+
+### Intro to Noir Syntax
+
+Let us take a closer look at _main.nr_. The default _main.nr_ generated should look like this:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+The first line of the program specifies the program's inputs:
+
+```rust
+x : Field, y : pub Field
+```
+
+Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
+keyword `pub` (e.g. `y`). To learn more about private and public values, check the
+[Data Types](../../noir/concepts/data_types/index.md) section.
+
+The next line of the program specifies its body:
+
+```rust
+assert(x != y);
+```
+
+The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
+
+For more Noir syntax, check the [Language Concepts](../../noir/concepts/comments.md) chapter.
+
+## Build In/Output Files
+
+Change directory into _hello_world_ and build in/output files for your Noir program by running:
+
+```sh
+cd hello_world
+nargo check
+```
+
+A _Prover.toml_ file will be generated in your project directory, to allow specifying input values to the program.
+
+## Execute Our Noir Program
+
+Now that the project is set up, we can execute our Noir program.
+
+Fill in input values for execution in the _Prover.toml_ file. For example:
+
+```toml
+x = "1"
+y = "2"
+```
+
+Execute your Noir program:
+
+```sh
+nargo execute witness-name
+```
+
+The witness corresponding to this execution will then be written to the file `./target/witness-name.gz`.
+
+## Prove Our Noir Program
+
+:::info
+
+Nargo no longer handles communicating with backends in order to generate proofs. In order to prove/verify your Noir programs, you'll need an installation of [bb](../barretenberg/index.md).
+
+:::
+
+Prove the valid execution of your Noir program using `bb`:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/witness-name.gz -o ./proof
+```
+
+A new file called `proof` will be generated in your project directory, containing the generated proof for your program.
+
+## Verify Our Noir Program
+
+Once a proof is generated, we can verify correct execution of our Noir program by verifying the proof file.
+
+Verify your proof by running:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./proof
+```
+
+The verification will complete in silence if it is successful. If it fails, it will log the corresponding error instead.
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/project_breakdown.md
new file mode 100644
index 00000000000..29688df148f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/hello_noir/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 2 
+---
+
+This section breaks down our hello world program from the previous section. We elaborate on the project
+structure and what the `prove` and `verify` commands did.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.31.0/getting_started/installation/_category_.json
new file mode 100644
index 00000000000..0c02fb5d4d7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/installation/_category_.json
@@ -0,0 +1,6 @@
+{
+    "position": 0,
+    "label": "Install Nargo",
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/installation/index.md b/docs/versioned_docs/version-v0.31.0/getting_started/installation/index.md
new file mode 100644
index 00000000000..4ef86aa5914
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/installation/index.md
@@ -0,0 +1,48 @@
+---
+title: Nargo Installation
+description:
+  nargo is a command line tool for interacting with Noir programs. This page is a quick guide on how to install Nargo through the most common and easy method, noirup
+keywords: [
+   Nargo
+   Noir
+   Rust
+   Cargo
+   Noirup
+   Installation
+   Terminal Commands
+   Version Check
+   Nightlies
+   Specific Versions
+   Branches
+   Noirup Repository
+]
+pagination_next: getting_started/hello_noir/index
+---
+
+`nargo` is the one-stop-shop for almost everything related with Noir. The name comes from our love for Rust and its package manager `cargo`.
+
+With `nargo`, you can start new projects, compile, execute, prove, verify, test, generate solidity contracts, and do pretty much all that is available in Noir.
+
+Similarly to `rustup`, we also maintain an easy installation method that covers most machines: `noirup`.
+
+## Installing Noirup
+
+Open a terminal on your machine, and write:
+
+```bash
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Close the terminal, open another one, and run
+
+```bash
+noirup
+```
+
+Done. That's it. You should have the latest version working. You can check with `nargo --version`.
+
+You can also install nightlies, specific versions
+or branches. Check out the [noirup repository](https://github.com/noir-lang/noirup) for more
+information.
+
+Now we're ready to start working on [our first Noir program!](../hello_noir/index.md)
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.31.0/getting_started/installation/other_install_methods.md
new file mode 100644
index 00000000000..3634723562b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/installation/other_install_methods.md
@@ -0,0 +1,102 @@
+---
+title: Alternative Installations
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 1
+---
+
+## Encouraged Installation Method: Noirup
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#encouraged-installation-method-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.31.0/getting_started/tooling/noir_codegen.md b/docs/versioned_docs/version-v0.31.0/getting_started/tooling/noir_codegen.md
new file mode 100644
index 00000000000..f7505bef7ab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/getting_started/tooling/noir_codegen.md
@@ -0,0 +1,114 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/_category_.json b/docs/versioned_docs/version-v0.31.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.31.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..09e5bae68ad
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.31.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..2d2ed5c94b9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/how-to-oracles.md
@@ -0,0 +1,273 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in a unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_function_call", async (params) => {
+  if params.function !== "getSqrt" {
+    throw Error("Unexpected foreign call")
+  };
+  const values = params.inputs[0].Array.map((field) => {
+    return `${Math.sqrt(parseInt(field, 16))}`;
+  });
+  return { values: [{ Array: values }] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+interface SingleForeignCallParam {
+  Single: string,
+}
+
+interface ArrayForeignCallParam {
+  Array: string[],
+}
+
+type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+
+interface ForeignCallResult {
+  values: ForeignCallParam[],
+}
+```
+
+::: Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in json as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+    // notice that the "inputs" parameter contains *all* the inputs
+    // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+    const oracleReturn = await client.request(name, [
+      { Array: input[0].map((i) => i.toString("hex")) },
+    ]);
+    return [oracleReturn.values[0].Array];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(numbers, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.31.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..aac84e29fac
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/how-to-recursion.md
@@ -0,0 +1,180 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.31.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..e6ed9abaec6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,251 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straight-forward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract read to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/hello_noir/index.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the 
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.31.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.31.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.31.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.31.0/index.mdx b/docs/versioned_docs/version-v0.31.0/index.mdx
new file mode 100644
index 00000000000..a6bd306f91d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.31.0/migration_notes.md b/docs/versioned_docs/version-v0.31.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.31.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..bcff613a695
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/assert.md
@@ -0,0 +1,45 @@
+---
+title: Assert Function
+description:
+  Learn about the assert function in Noir, which can be used to explicitly constrain the predicate or
+  comparison expression that follows to be true, and what happens if the expression is false at
+  runtime.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_bus.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_bus.md
new file mode 100644
index 00000000000..e54fc861257
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_bus.md
@@ -0,0 +1,21 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+**Disclaimer** this feature is experimental, do not use it!
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..95d749053e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,253 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a < b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a > b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..a10a4810788
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,192 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust
+fn to_le_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_le_bits(32);
+}
+```
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust
+fn to_be_bits(_x : Field, _bit_size: u32) -> [u1]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bits = field.to_be_bits(32);
+}
+```
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust
+fn to_le_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_le_bytes(4);
+}
+```
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust
+fn to_be_bytes(_x : Field, byte_size: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let bytes = field.to_be_bytes(4);
+}
+```
+
+### to_le_radix
+
+Decomposes into a vector over the specified base, Little Endian
+
+```rust
+fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_le_radix(256, 4);
+}
+```
+
+### to_be_radix
+
+Decomposes into a vector over the specified base, Big Endian
+
+```rust
+fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8]
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2;
+    let radix = field.to_be_radix(256, 4);
+}
+```
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+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.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..357813c147a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/index.md
@@ -0,0 +1,110 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..dff08d63ffb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,193 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceeding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<N>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..dbf68c99813
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,70 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..0c1c27a2221
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/generics.md
@@ -0,0 +1,106 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks just like using regular generics, but these generics can resolve to
+integers at compile-time, rather than resolving to types. Here's an example of a struct that is
+generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<N> {
+    limbs: [u32; N],
+}
+
+impl<N> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, N>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..063a3d89248
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/globals.md
@@ -0,0 +1,72 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: Field = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/oracles.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/oracles.md
new file mode 100644
index 00000000000..aa380b5f7b8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/oracles.md
@@ -0,0 +1,31 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+:::note
+
+This is an experimental feature that is not fully documented. If you notice any outdated information or potential improvements to this page, pull request contributions are very welcome: https://github.com/noir-lang/noir
+
+:::
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..df7cb9ebda0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/traits.md
@@ -0,0 +1,389 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, N> Eq for [T; N] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.31.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..96f824c5e42
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/concepts/unconstrained.md
@@ -0,0 +1,99 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = u72_to_u8(num);
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..ae822a1cff4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,105 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.31.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..2bfdeec6631
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/bigint.md
@@ -0,0 +1,122 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L14-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L14-L19</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L70-L78" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L70-L78</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d5694250f05
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.md)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..4349eab67c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn foo() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of foo's return value
+    v2
+}
+
+fn bad() {
+    let mut v3 = BoundedVec::new();
+
+    // Not Ok! We don't know if v3's MaxLen is at least 1, and the compiler often infers 0 by default.
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<N>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure. 
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L214-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L214-L217</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..408b6ba9da7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,570 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+When creating `HashMap`s, the `MaxLen` generic should always be specified if it is not already
+known. Otherwise, the compiler may infer a different value for `MaxLen` (such as zero), which
+will likely change the result of the program. This behavior is set to become an error in future
+versions instead.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L196-L198" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L196-L198</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L82-L86" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L82-L86</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L211" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L211</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L278-L287" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L278-L287</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L299-L307" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L299-L307</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L313-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L313-L323</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L213-L217" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L213-L217</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L356-L365" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L356-L365</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L221-L228" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L221-L228</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L115-L117</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L230-L238" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L230-L238</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L264-L266</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L240-L255" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L240-L255</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L271-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L271-L273</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L261" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L261</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L93-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L93-L95</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L101-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L101-L110</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L269-L276</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L310-L321" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L310-L321</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L144-L146" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L144-L146</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L323-L333" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L323-L333</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L164-L166</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L335-L344" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L335-L344</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L183-L192" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L183-L192</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L348-L351" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L348-L351</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L208-L217" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L208-L217</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L353-L356" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L353-L356</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L233-L235" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L233-L235</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L358-L361" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L358-L361</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L247-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L247-L249</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L281-L283" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L281-L283</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default
+{
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L462-L469" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L462-L469</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L202-L205" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L202-L205</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher
+{
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L426-L435" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L426-L435</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L285-L296" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L285-L296</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..e83e26efb97
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<N>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo />
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..f839b4a228e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..4394b48f907
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo />
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..1ad42a5ac96
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
+For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use std::hash::poseidon2::Poseidon2Hasher;
+
+eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
+```
+
+<BlackBoxInfo />
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..14d7dda7f0d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,98 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<N>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N]
+) -> [Field; 3]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L62-L67" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L62-L67</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(
+    scalar_low: Field,
+    scalar_high: Field
+) -> [Field; 3]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L70-L75" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L70-L75</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L84-L89" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L84-L89</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..18132b9a4dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,246 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L11-L13</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L16-L18</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo />
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L17-L19</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo />
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L23-L25</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo />
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L42-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L42-L44</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L28-L30</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash.nr#L64-L66</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L21" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L21</a></sub></sup>
+
+
+<BlackBoxInfo />
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+use std::hash::poseidon2;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field, x3: [Field; 4], y3: Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+
+    let hash3 = poseidon2::Poseidon2::hash(x3, x3.len());
+    assert(hash3 == y3);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L15</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+The above example for Poseidon also includes Poseidon2.
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<N>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..b59e69c8f07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<N>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L2-L9</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo />
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo />
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..bb157e719dc
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,59 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/recursion.md
new file mode 100644
index 00000000000..8cfb37fc52d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/recursion.md
@@ -0,0 +1,85 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo />
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof_b.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..a14312d2792
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/traits.md
@@ -0,0 +1,464 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L1-L5</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 { fn from(value: u8) -> u32 { value as u32 } }
+
+impl From<u8> for u64 { fn from(value: u8) -> u64 { value as u64 } }
+impl From<u32> for u64 { fn from(value: u32) -> u64 { value as u64 } }
+
+impl From<u8> for Field { fn from(value: u8) -> Field { value as Field } }
+impl From<u32> for Field { fn from(value: u32) -> Field { value as Field } }
+impl From<u64> for Field { fn from(value: u64) -> Field { value as Field } }
+
+// Signed integers
+
+impl From<i8> for i32 { fn from(value: i8) -> i32 { value as i32 } }
+
+impl From<i8> for i64 { fn from(value: i8) -> i64 { value as i64 } }
+impl From<i32> for i64 { fn from(value: i32) -> i64 { value as i64 } }
+
+// Booleans
+impl From<bool> for u8 { fn from(value: bool) -> u8 { value as u8 } }
+impl From<bool> for u32 { fn from(value: bool) -> u32 { value as u32 } }
+impl From<bool> for u64 { fn from(value: bool) -> u64 { value as u64 } }
+impl From<bool> for i8 { fn from(value: bool) -> i8 { value as i8 } }
+impl From<bool> for i32 { fn from(value: bool) -> i32 { value as i32 } }
+impl From<bool> for i64 { fn from(value: bool) -> i64 { value as i64 } }
+impl From<bool> for Field { fn from(value: bool) -> Field { value as Field } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L52</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+  fn into(self) -> T {
+      T::from(self)
+  }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L1-L5</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L102-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L102-L106</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L19-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L19-L23</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L37-L41" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L37-L41</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L55-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L55-L59</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L73-L77" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L73-L77</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L89-L93" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L89-L93</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field { fn neg(self) -> Field { -self } }
+
+impl Neg for i8 { fn neg(self) -> i8 { -self } }
+impl Neg for i16 { fn neg(self) -> i16 { -self } }
+impl Neg for i32 { fn neg(self) -> i32 { -self } }
+impl Neg for i64 { fn neg(self) -> i64 { -self } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L95-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L95-L102</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool { fn not(self) -> bool { !self } }
+
+impl Not for u64 { fn not(self) -> u64 { !self } }
+impl Not for u32 { fn not(self) -> u32 { !self } }
+impl Not for u16 { fn not(self) -> u16 { !self } }
+impl Not for u8 { fn not(self) -> u8 { !self } }
+impl Not for u1 { fn not(self) -> u1 { !self } }
+
+impl Not for i8 { fn not(self) -> i8 { !self } }
+impl Not for i16 { fn not(self) -> i16 { !self } }
+impl Not for i32 { fn not(self) -> i32 { !self } }
+impl Not for i64 { fn not(self) -> i64 { !self } }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L20</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L22-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L22-L26</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L40-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L40-L44</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L58-L62" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L58-L62</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L76-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L76-L80</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L93-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L93-L97</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
diff --git a/docs/versioned_docs/version-v0.31.0/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.31.0/noir/standard_library/zeroed.md
new file mode 100644
index 00000000000..f450fecdd36
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/noir/standard_library/zeroed.md
@@ -0,0 +1,26 @@
+---
+title: Zeroed Function
+description:
+  The zeroed function returns a zeroed value of any type.
+keywords:
+  [
+    zeroed
+  ]
+---
+
+Implements `fn zeroed<T>() -> T` to return a zeroed value of any type. This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types. It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array. The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to. Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+You can access the function at `std::unsafe::zeroed`.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Function
+  
+Using it on other types could result in unexpected behavior.
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..d7249d24330
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,160 @@
+# BarretenbergBackend
+
+## Extends
+
+- `BarretenbergVerifierBackend`
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+#### Inherited from
+
+BarretenbergVerifierBackend.constructor
+
+## Properties
+
+| Property | Type | Description | Inheritance |
+| :------ | :------ | :------ | :------ |
+| `acirComposer` | `any` | - | BarretenbergVerifierBackend.acirComposer |
+| `acirUncompressedBytecode` | `Uint8Array` | - | BarretenbergVerifierBackend.acirUncompressedBytecode |
+| `api` | `Barretenberg` | - | BarretenbergVerifierBackend.api |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) | - | BarretenbergVerifierBackend.options |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.destroy
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.getVerificationKey
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Inherited from
+
+BarretenbergVerifierBackend.verifyProof
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
new file mode 100644
index 00000000000..500276ea748
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
@@ -0,0 +1,58 @@
+# BarretenbergVerifier
+
+## Constructors
+
+### new BarretenbergVerifier(options)
+
+```ts
+new BarretenbergVerifier(options): BarretenbergVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergVerifier`](BarretenbergVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..14dfac681d4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,40 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+| [BarretenbergVerifier](classes/BarretenbergVerifier.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..b49a479f4f4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,21 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Description
+
+An options object, currently only used to specify the number of threads to use.
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..d7d5128f9e3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier","label":"BarretenbergVerifier"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/sha256.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/sha256.md
new file mode 100644
index 00000000000..6ba4ecac022
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/sha256.md
@@ -0,0 +1,21 @@
+# sha256()
+
+```ts
+sha256(inputs): Uint8Array
+```
+
+Calculates the SHA256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..166508f7124
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,49 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..b3156097df6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/_category_.json b/docs/versioned_docs/version-v0.31.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.31.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.31.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.31.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..ab9dd879d85
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/reference/nargo_commands.md
@@ -0,0 +1,244 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Override the expression width requested by the backend
+
+  Default value: `4`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.31.0/tooling/debugger.md b/docs/versioned_docs/version-v0.31.0/tooling/debugger.md
new file mode 100644
index 00000000000..9b7565ba9ff
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.31.0/tooling/language_server.md b/docs/versioned_docs/version-v0.31.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.31.0/tooling/testing.md b/docs/versioned_docs/version-v0.31.0/tooling/testing.md
new file mode 100644
index 00000000000..d3e0c522473
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/tooling/testing.md
@@ -0,0 +1,62 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.31.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.31.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..cbb1938a5c6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.31.0/tutorials/noirjs_app.md
@@ -0,0 +1,327 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.27.x matches `noir_js@0.27.x`, etc.
+
+In this guide, we will be pinned to 0.27.0.
+
+:::
+
+Before we start, we want to make sure we have Node and Nargo installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+`nargo new circuit`
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+`nargo compile`
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from "vite";
+import copy from "rollup-plugin-copy";
+
+export default defineConfig({
+  esbuild: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: "esnext",
+    },
+  },
+  plugins: [
+    copy({
+      targets: [
+        { src: "node_modules/**/*.wasm", dest: "node_modules/.vite/dist" },
+      ],
+      copySync: true,
+      hook: "buildStart",
+    }),
+  ],
+  server: {
+    port: 3000,
+  },
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.27.0 @noir-lang/noir_js@0.27.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+const setup = async () => {
+  await Promise.all([
+    import('@noir-lang/noirc_abi').then((module) =>
+      module.default(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+    ),
+    import('@noir-lang/acvm_js').then((module) =>
+      module.default(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
+    ),
+  ]);
+};
+
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+As for the `setup` function, it's just a sad reminder that dealing with `wasm` on the browser is not as easy as it should. Just copy, paste, and forget.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const verificationKey = await backend.getVerificationKey();
+const verifier = new Verifier();
+const isValid = await verifier.verifyProof(proof, verificationKey);
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
diff --git a/docs/versioned_sidebars/version-v0.31.0-sidebars.json b/docs/versioned_sidebars/version-v0.31.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.31.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 5d3a7d6315e..eb9694a3b0c 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.30.0",
+  "version": "0.31.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index eca3f29957f..3bb2ab5826f 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.30.0",
+  "version": "0.31.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index af3011068bf..2bb142c9fa0 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.30.0",
+  "version": "0.31.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index b2b84b640a5..0de1a1fd4be 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 399a333f157..b33bb159fcd 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.30.0",
+  "version": "0.31.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {

From 55d8e05b84ae23a1a218e7027542af175979885c Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 17 Jun 2024 15:08:25 -0500
Subject: [PATCH 382/416] chore: Use the elaborator by default (#5246)

# Description

## Problem\*

## Summary\*

Removes the `--use-elaborator` flag, replacing it with `--use-legacy` to
enable the old name resolver & type checker passes which are now off by
default in favor of the elaborator.

## Additional Context

No user visible changes are expected from this PR.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_driver/src/lib.rs              | 12 ++--
 compiler/noirc_frontend/src/elaborator/mod.rs |  2 +
 .../src/hir/def_collector/dc_crate.rs         |  6 +-
 .../noirc_frontend/src/hir/def_map/mod.rs     |  4 +-
 tooling/nargo_cli/build.rs                    | 55 +++++++++----------
 tooling/nargo_cli/src/cli/check_cmd.rs        |  6 +-
 tooling/nargo_cli/src/cli/export_cmd.rs       |  2 +-
 tooling/nargo_cli/src/cli/test_cmd.rs         |  4 +-
 8 files changed, 46 insertions(+), 45 deletions(-)

diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 2c8679eaa95..dde2bd08d74 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -99,9 +99,9 @@ pub struct CompileOptions {
     #[arg(long, hide = true)]
     pub force_brillig: bool,
 
-    /// Enable the experimental elaborator pass
+    /// Use the deprecated name resolution & type checking passes instead of the elaborator
     #[arg(long, hide = true)]
-    pub use_elaborator: bool,
+    pub use_legacy: bool,
 
     /// Outputs the paths to any modified artifacts
     #[arg(long, hide = true)]
@@ -257,13 +257,13 @@ pub fn check_crate(
     crate_id: CrateId,
     deny_warnings: bool,
     disable_macros: bool,
-    use_elaborator: bool,
+    use_legacy: bool,
 ) -> CompilationResult<()> {
     let macros: &[&dyn MacroProcessor] =
         if disable_macros { &[] } else { &[&aztec_macros::AztecMacro as &dyn MacroProcessor] };
 
     let mut errors = vec![];
-    let diagnostics = CrateDefMap::collect_defs(crate_id, context, use_elaborator, macros);
+    let diagnostics = CrateDefMap::collect_defs(crate_id, context, use_legacy, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
         let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
@@ -300,7 +300,7 @@ pub fn compile_main(
         crate_id,
         options.deny_warnings,
         options.disable_macros,
-        options.use_elaborator,
+        options.use_legacy,
     )?;
 
     let main = context.get_main_function(&crate_id).ok_or_else(|| {
@@ -341,7 +341,7 @@ pub fn compile_contract(
         crate_id,
         options.deny_warnings,
         options.disable_macros,
-        options.use_elaborator,
+        options.use_legacy,
     )?;
 
     // TODO: We probably want to error if contracts is empty
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 93e8b36f4e0..0b7e5a58849 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1138,6 +1138,7 @@ impl<'context> Elaborator<'context> {
     fn elaborate_global(&mut self, global: UnresolvedGlobal) {
         let old_module = std::mem::replace(&mut self.local_module, global.module_id);
         let old_file = std::mem::replace(&mut self.file, global.file_id);
+        let old_item = self.current_item.take();
 
         let global_id = global.global_id;
         self.current_item = Some(DependencyId::Global(global_id));
@@ -1171,6 +1172,7 @@ impl<'context> Elaborator<'context> {
         self.type_variables.clear();
         self.local_module = old_module;
         self.file = old_file;
+        self.current_item = old_item;
     }
 
     fn elaborate_comptime_global(&mut self, global_id: GlobalId) {
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 4d64481bc9f..216ed5fc545 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -256,7 +256,7 @@ impl DefCollector {
         context: &mut Context,
         ast: SortedModule,
         root_file_id: FileId,
-        use_elaborator: bool,
+        use_legacy: bool,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
@@ -273,7 +273,7 @@ impl DefCollector {
             errors.extend(CrateDefMap::collect_defs(
                 dep.crate_id,
                 context,
-                use_elaborator,
+                use_legacy,
                 macro_processors,
             ));
 
@@ -351,7 +351,7 @@ impl DefCollector {
             }
         }
 
-        if use_elaborator {
+        if !use_legacy {
             let mut more_errors = Elaborator::elaborate(context, crate_id, def_collector.items);
             errors.append(&mut more_errors);
             return errors;
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 19e06387d43..59205f74d89 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -73,7 +73,7 @@ impl CrateDefMap {
     pub fn collect_defs(
         crate_id: CrateId,
         context: &mut Context,
-        use_elaborator: bool,
+        use_legacy: bool,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         // Check if this Crate has already been compiled
@@ -122,7 +122,7 @@ impl CrateDefMap {
             context,
             ast,
             root_file_id,
-            use_elaborator,
+            use_legacy,
             macro_processors,
         ));
 
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 846160320cf..d2822ba11ab 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -87,23 +87,23 @@ fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path)
             test_file,
             r#"
 #[test]
-fn execution_success_{test_name}() {{
+fn execution_success_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
+    cmd.arg("execute").arg("--force").arg("--use-legacy");
 
     cmd.assert().success();
 }}
 
 #[test]
-fn execution_success_elaborator_{test_name}() {{
+fn execution_success_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--use-elaborator");
+    cmd.arg("execute").arg("--force");
 
     cmd.assert().success();
 }}
@@ -146,23 +146,23 @@ fn generate_execution_failure_tests(test_file: &mut File, test_data_dir: &Path)
             test_file,
             r#"
 #[test]
-fn execution_failure_{test_name}() {{
+fn execution_failure_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
+    cmd.arg("execute").arg("--force").arg("--use-legacy");
 
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}
 
 #[test]
-fn execution_failure_elaborator_{test_name}() {{
+fn execution_failure_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--use-elaborator");
+    cmd.arg("execute").arg("--force");
 
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}
@@ -194,23 +194,23 @@ fn generate_noir_test_success_tests(test_file: &mut File, test_data_dir: &Path)
             test_file,
             r#"
 #[test]
-fn noir_test_success_{test_name}() {{
+fn noir_test_success_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test");
+    cmd.arg("test").arg("--use-legacy");
 
     cmd.assert().success();
 }}
 
 #[test]
-fn noir_test_success_elaborator_{test_name}() {{
+fn noir_test_success_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test").arg("--use-elaborator");
+    cmd.arg("test");
 
     cmd.assert().success();
 }}
@@ -242,23 +242,23 @@ fn generate_noir_test_failure_tests(test_file: &mut File, test_data_dir: &Path)
             test_file,
             r#"
 #[test]
-fn noir_test_failure_{test_name}() {{
+fn noir_test_failure_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test");
+    cmd.arg("test").arg("--use-legacy");
 
     cmd.assert().failure();
 }}
 
 #[test]
-fn noir_test_failure_elaborator_{test_name}() {{
+fn noir_test_failure_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test").arg("--use-elaborator");
+    cmd.arg("test");
 
     cmd.assert().failure();
 }}
@@ -293,14 +293,14 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
             test_file,
             r#"
 #[test]{comptime_ignored}
-fn compile_success_empty_{test_name}() {{
-
+fn compile_success_empty_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("info");
     cmd.arg("--json");
     cmd.arg("--force");
+    cmd.arg("--use-legacy");
 
     let output = cmd.output().expect("Failed to execute command");
 
@@ -317,14 +317,13 @@ fn compile_success_empty_{test_name}() {{
 }}
 
 #[test]
-fn compile_success_empty_elaborator_{test_name}() {{
+fn compile_success_empty_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
     cmd.arg("info");
     cmd.arg("--json");
     cmd.arg("--force");
-    cmd.arg("--use-elaborator");
 
     let output = cmd.output().expect("Failed to execute command");
 
@@ -367,22 +366,22 @@ fn generate_compile_success_contract_tests(test_file: &mut File, test_data_dir:
             test_file,
             r#"
 #[test]
-fn compile_success_contract_{test_name}() {{
+fn compile_success_contract_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force");
+    cmd.arg("compile").arg("--force").arg("--use-legacy");
 
     cmd.assert().success();
 }}
 #[test]
-fn compile_success_contract_elaborator_{test_name}() {{
+fn compile_success_contract_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force").arg("--use-elaborator");
+    cmd.arg("compile").arg("--force");
 
     cmd.assert().success();
 }}
@@ -414,22 +413,22 @@ fn generate_compile_failure_tests(test_file: &mut File, test_data_dir: &Path) {
             test_file,
             r#"
 #[test]
-fn compile_failure_{test_name}() {{
+fn compile_failure_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force");
+    cmd.arg("compile").arg("--force").arg("--use-legacy");
 
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}
 #[test]
-fn compile_failure_elaborator_{test_name}() {{
+fn compile_failure_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
     let mut cmd = Command::cargo_bin("nargo").unwrap();
     cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force").arg("--use-elaborator");
+    cmd.arg("compile").arg("--force");
 
     cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
 }}
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index e2e1f147b90..2db3b10429a 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -87,7 +87,7 @@ fn check_package(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.silence_warnings,
-        compile_options.use_elaborator,
+        compile_options.use_legacy,
     )?;
 
     if package.is_library() || package.is_contract() {
@@ -160,9 +160,9 @@ pub(crate) fn check_crate_and_report_errors(
     deny_warnings: bool,
     disable_macros: bool,
     silence_warnings: bool,
-    use_elaborator: bool,
+    use_legacy: bool,
 ) -> Result<(), CompileError> {
-    let result = check_crate(context, crate_id, deny_warnings, disable_macros, use_elaborator);
+    let result = check_crate(context, crate_id, deny_warnings, disable_macros, use_legacy);
     report_errors(result, &context.file_manager, deny_warnings, silence_warnings)
 }
 
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index 324eed340ad..ee30b29b0f0 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -89,7 +89,7 @@ fn compile_exported_functions(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.silence_warnings,
-        compile_options.use_elaborator,
+        compile_options.use_legacy,
     )?;
 
     let exported_functions = context.get_all_exported_functions_in_crate(&crate_id);
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 99c284e5019..1cda8d8382e 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -175,7 +175,7 @@ fn run_test<S: BlackBoxFunctionSolver<FieldElement> + Default>(
         crate_id,
         compile_options.deny_warnings,
         compile_options.disable_macros,
-        compile_options.use_elaborator,
+        compile_options.use_legacy,
     )
     .expect("Any errors should have occurred when collecting test functions");
 
@@ -209,7 +209,7 @@ fn get_tests_in_package(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.silence_warnings,
-        compile_options.use_elaborator,
+        compile_options.use_legacy,
     )?;
 
     Ok(context

From c91186a5c0d9e84767f160e6acd63672b23e8f52 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 14:36:35 +0100
Subject: [PATCH 383/416] feat: implement comptime support for `array_len`
 builtin (#5272)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR implements support for the `array_len` builtin so we can query
the length of arrays in `comptime` blocks. Ideally we'd tie this closer
to the `Intrinsics` struct in `noirc_evaluator` but we can handle this
morn cleanly later.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/hir/comptime/interpreter.rs   | 10 ++++++++--
 .../src/hir/comptime/interpreter/builtin.rs          | 12 ++++++++++++
 .../comptime_array_len/Nargo.toml                    |  6 ++++++
 .../comptime_array_len/src/main.nr                   |  6 ++++++
 4 files changed, 32 insertions(+), 2 deletions(-)
 create mode 100644 compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
 create mode 100644 test_programs/compile_success_empty/comptime_array_len/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/comptime_array_len/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 3648881e501..c473ac7f8a6 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -31,6 +31,7 @@ use self::unquote::UnquoteArgs;
 use super::errors::{IResult, InterpreterError};
 use super::value::Value;
 
+mod builtin;
 mod unquote;
 
 #[allow(unused)]
@@ -99,8 +100,13 @@ impl<'a> Interpreter<'a> {
             .expect("all builtin functions must contain a function  attribute which contains the opcode which it links to");
 
         if let Some(builtin) = func_attrs.builtin() {
-            let item = format!("Evaluation for builtin functions like {builtin}");
-            Err(InterpreterError::Unimplemented { item, location })
+            match builtin.as_str() {
+                "array_len" => builtin::array_len(&arguments),
+                _ => {
+                    let item = format!("Evaluation for builtin function {builtin}");
+                    Err(InterpreterError::Unimplemented { item, location })
+                }
+            }
         } else if let Some(foreign) = func_attrs.foreign() {
             let item = format!("Evaluation for foreign functions like {foreign}");
             Err(InterpreterError::Unimplemented { item, location })
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
new file mode 100644
index 00000000000..3e5ad207719
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
@@ -0,0 +1,12 @@
+use noirc_errors::Location;
+
+use crate::hir::comptime::{errors::IResult, Value};
+
+pub(super) fn array_len(arguments: &[(Value, Location)]) -> IResult<Value> {
+    assert_eq!(arguments.len(), 1, "ICE: `array_len` should only receive a single argument");
+    match &arguments[0].0 {
+        Value::Array(values, _) | Value::Slice(values, _) => Ok(Value::U32(values.len() as u32)),
+        // Type checking should prevent this branch being taken.
+        _ => unreachable!("ICE: Cannot query length of types other than arrays or slices"),
+    }
+}
diff --git a/test_programs/compile_success_empty/comptime_array_len/Nargo.toml b/test_programs/compile_success_empty/comptime_array_len/Nargo.toml
new file mode 100644
index 00000000000..c07deddc6c5
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_array_len/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "comptime_array_len"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/comptime_array_len/src/main.nr b/test_programs/compile_success_empty/comptime_array_len/src/main.nr
new file mode 100644
index 00000000000..c98a3de01dd
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_array_len/src/main.nr
@@ -0,0 +1,6 @@
+fn main() {
+    comptime
+    {
+        assert_eq([1, 2, 3].len(), 3);
+    }
+}

From f8608e61957333707b8e651db42a00a7ed0928c3 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 14:55:29 +0100
Subject: [PATCH 384/416] chore: simplify compilation flow to write to file
 immediately (#5265)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR pulls across the changes from
https://github.com/AztecProtocol/aztec-packages/pull/6488 to avoid
making changes in aztec-packages unnecessarily and get around the CI
issues over there.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/src/cli/compile_cmd.rs | 129 ++++++++++++++---------
 1 file changed, 78 insertions(+), 51 deletions(-)

diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index bd76cf24805..e83b1728c93 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -3,7 +3,6 @@ use std::path::Path;
 use std::time::Duration;
 
 use fm::FileManager;
-use nargo::artifacts::program::ProgramArtifact;
 use nargo::ops::{collect_errors, compile_contract, compile_program, report_errors};
 use nargo::package::Package;
 use nargo::workspace::Workspace;
@@ -11,7 +10,7 @@ use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::file_manager_with_stdlib;
 use noirc_driver::NOIR_ARTIFACT_VERSION_STRING;
-use noirc_driver::{CompilationResult, CompileOptions, CompiledContract, CompiledProgram};
+use noirc_driver::{CompilationResult, CompileOptions, CompiledContract};
 
 use noirc_frontend::graph::CrateName;
 
@@ -121,39 +120,22 @@ pub(super) fn compile_workspace_full(
     let compiled_workspace =
         compile_workspace(&workspace_file_manager, &parsed_files, workspace, compile_options);
 
-    let (compiled_programs, compiled_contracts) = report_errors(
+    report_errors(
         compiled_workspace,
         &workspace_file_manager,
         compile_options.deny_warnings,
         compile_options.silence_warnings,
     )?;
 
-    let (binary_packages, contract_packages): (Vec<_>, Vec<_>) = workspace
-        .into_iter()
-        .filter(|package| !package.is_library())
-        .cloned()
-        .partition(|package| package.is_binary());
-
-    // Save build artifacts to disk.
-    for (package, program) in binary_packages.into_iter().zip(compiled_programs) {
-        let program = nargo::ops::transform_program(program, compile_options.expression_width);
-        save_program(program.clone(), &package, &workspace.target_directory_path());
-    }
-    let circuit_dir = workspace.target_directory_path();
-    for (package, contract) in contract_packages.into_iter().zip(compiled_contracts) {
-        let contract = nargo::ops::transform_contract(contract, compile_options.expression_width);
-        save_contract(contract, &package, &circuit_dir, compile_options.show_artifact_paths);
-    }
-
     Ok(())
 }
 
-pub(super) fn compile_workspace(
+fn compile_workspace(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
     workspace: &Workspace,
     compile_options: &CompileOptions,
-) -> CompilationResult<(Vec<CompiledProgram>, Vec<CompiledContract>)> {
+) -> CompilationResult<()> {
     let (binary_packages, contract_packages): (Vec<_>, Vec<_>) = workspace
         .into_iter()
         .filter(|package| !package.is_library())
@@ -161,32 +143,20 @@ pub(super) fn compile_workspace(
         .partition(|package| package.is_binary());
 
     // Compile all of the packages in parallel.
-    let program_results: Vec<CompilationResult<CompiledProgram>> = binary_packages
-        .par_iter()
-        .map(|package| {
-            let program_artifact_path = workspace.package_build_path(package);
-            let cached_program: Option<CompiledProgram> =
-                read_program_from_file(program_artifact_path)
-                    .ok()
-                    .filter(|p| p.noir_version == NOIR_ARTIFACT_VERSION_STRING)
-                    .map(|p| p.into());
-
-            compile_program(file_manager, parsed_files, package, compile_options, cached_program)
-        })
-        .collect();
-    let contract_results: Vec<CompilationResult<CompiledContract>> = contract_packages
-        .par_iter()
-        .map(|package| compile_contract(file_manager, parsed_files, package, compile_options))
-        .collect();
-
-    // Collate any warnings/errors which were encountered during compilation.
-    let compiled_programs = collect_errors(program_results);
-    let compiled_contracts = collect_errors(contract_results);
+    let program_warnings_or_errors: CompilationResult<()> =
+        compile_programs(file_manager, parsed_files, workspace, &binary_packages, compile_options);
+    let contract_warnings_or_errors: CompilationResult<()> = compiled_contracts(
+        file_manager,
+        parsed_files,
+        &contract_packages,
+        compile_options,
+        &workspace.target_directory_path(),
+    );
 
-    match (compiled_programs, compiled_contracts) {
-        (Ok((programs, program_warnings)), Ok((contracts, contract_warnings))) => {
+    match (program_warnings_or_errors, contract_warnings_or_errors) {
+        (Ok((_, program_warnings)), Ok((_, contract_warnings))) => {
             let warnings = [program_warnings, contract_warnings].concat();
-            Ok(((programs, contracts), warnings))
+            Ok(((), warnings))
         }
         (Err(program_errors), Err(contract_errors)) => {
             Err([program_errors, contract_errors].concat())
@@ -195,22 +165,79 @@ pub(super) fn compile_workspace(
     }
 }
 
-pub(super) fn save_program(program: CompiledProgram, package: &Package, circuit_dir: &Path) {
-    let program_artifact = ProgramArtifact::from(program.clone());
-    save_program_to_file(&program_artifact, &package.name, circuit_dir);
+fn compile_programs(
+    file_manager: &FileManager,
+    parsed_files: &ParsedFiles,
+    workspace: &Workspace,
+    binary_packages: &[Package],
+    compile_options: &CompileOptions,
+) -> CompilationResult<()> {
+    let load_cached_program = |package| {
+        let program_artifact_path = workspace.package_build_path(package);
+        read_program_from_file(program_artifact_path)
+            .ok()
+            .filter(|p| p.noir_version == NOIR_ARTIFACT_VERSION_STRING)
+            .map(|p| p.into())
+    };
+
+    let program_results: Vec<CompilationResult<()>> = binary_packages
+        .par_iter()
+        .map(|package| {
+            let (program, warnings) = compile_program(
+                file_manager,
+                parsed_files,
+                package,
+                compile_options,
+                load_cached_program(package),
+            )?;
+            let program = nargo::ops::transform_program(program, compile_options.expression_width);
+            save_program_to_file(
+                &program.clone().into(),
+                &package.name,
+                workspace.target_directory_path(),
+            );
+            Ok(((), warnings))
+        })
+        .collect();
+
+    // Collate any warnings/errors which were encountered during compilation.
+    collect_errors(program_results).map(|(_, warnings)| ((), warnings))
+}
+
+fn compiled_contracts(
+    file_manager: &FileManager,
+    parsed_files: &ParsedFiles,
+    contract_packages: &[Package],
+    compile_options: &CompileOptions,
+    target_dir: &Path,
+) -> CompilationResult<()> {
+    let contract_results: Vec<CompilationResult<()>> = contract_packages
+        .par_iter()
+        .map(|package| {
+            let (contract, warnings) =
+                compile_contract(file_manager, parsed_files, package, compile_options)?;
+            let contract =
+                nargo::ops::transform_contract(contract, compile_options.expression_width);
+            save_contract(contract, package, target_dir, compile_options.show_artifact_paths);
+            Ok(((), warnings))
+        })
+        .collect();
+
+    // Collate any warnings/errors which were encountered during compilation.
+    collect_errors(contract_results).map(|(_, warnings)| ((), warnings))
 }
 
 fn save_contract(
     contract: CompiledContract,
     package: &Package,
-    circuit_dir: &Path,
+    target_dir: &Path,
     show_artifact_paths: bool,
 ) {
     let contract_name = contract.name.clone();
     let artifact_path = save_contract_to_file(
         &contract.into(),
         &format!("{}-{}", package.name, contract_name),
-        circuit_dir,
+        target_dir,
     );
     if show_artifact_paths {
         println!("Saved contract artifact to: {}", artifact_path.display());

From d08b7b93a981f2e01a3d9754b194c5565ad3a7c2 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 15:00:25 +0100
Subject: [PATCH 385/416] fix: use proper serialization in `AbiValue` (#5270)

# Description

## Problem\*

Resolves slack issue
https://aztecprotocol.slack.com/archives/C02M7VC7TN0/p1718697469796579?thread_ts=1718697265.759469&cid=C02M7VC7TN0

## Summary\*

Looks like when this was added the author used the display method rather
than one for serialization.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_driver/src/abi_gen.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index c71474d7731..300a0592e39 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -1,6 +1,7 @@
 use std::collections::BTreeMap;
 
 use acvm::acir::circuit::ErrorSelector;
+use acvm::AcirField;
 use iter_extended::vecmap;
 use noirc_abi::{
     Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue, AbiVisibility, Sign,
@@ -197,9 +198,7 @@ pub(super) fn value_from_hir_expression(context: &Context, expression: HirExpres
             },
             HirLiteral::Bool(value) => AbiValue::Boolean { value },
             HirLiteral::Str(value) => AbiValue::String { value },
-            HirLiteral::Integer(field, sign) => {
-                AbiValue::Integer { value: field.to_string(), sign }
-            }
+            HirLiteral::Integer(field, sign) => AbiValue::Integer { value: field.to_hex(), sign },
             _ => unreachable!("Literal cannot be used in the abi"),
         },
         _ => unreachable!("Type cannot be used in the abi {:?}", expression),

From 6599f5660a7a209a33a2a1528379c7e4743525db Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 15:24:32 +0100
Subject: [PATCH 386/416] chore: replace logical operators with bitwise in
 `DebugToString` (#5236)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're printing `&&` and `||` in place of `&` and `|` in this code so
I've updated this to match the proper operator.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 075a776572e..b258905d657 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -59,8 +59,8 @@ impl DebugToString for BrilligBinaryOp {
             BrilligBinaryOp::UnsignedDiv => "/".into(),
             BrilligBinaryOp::LessThan => "<".into(),
             BrilligBinaryOp::LessThanEquals => "<=".into(),
-            BrilligBinaryOp::And => "&&".into(),
-            BrilligBinaryOp::Or => "||".into(),
+            BrilligBinaryOp::And => "&".into(),
+            BrilligBinaryOp::Or => "|".into(),
             BrilligBinaryOp::Xor => "^".into(),
             BrilligBinaryOp::Shl => "<<".into(),
             BrilligBinaryOp::Shr => ">>".into(),

From 7445efb05165bf7df2f9dfe325abbc42f839364c Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Tue, 18 Jun 2024 18:33:58 +0200
Subject: [PATCH 387/416] feat: add support for wildcard types (#5275)

# Description

## Problem\*

Resolves #5183

## Summary\*
Add support for wildcard type: `_`


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/elaborator/types.rs    |  4 +++-
 .../src/hir/resolution/resolver.rs            |  1 +
 docs/docs/noir/concepts/data_types/index.md   |  8 +++++++
 .../wildcard_type/Nargo.toml                  |  6 +++++
 .../wildcard_type/Prover.toml                 |  1 +
 .../wildcard_type/src/main.nr                 | 23 +++++++++++++++++++
 tooling/nargo_cli/build.rs                    | 18 +++++++++++----
 7 files changed, 55 insertions(+), 6 deletions(-)
 create mode 100644 test_programs/execution_success/wildcard_type/Nargo.toml
 create mode 100644 test_programs/execution_success/wildcard_type/Prover.toml
 create mode 100644 test_programs/execution_success/wildcard_type/src/main.nr

diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index a9571a6669d..e3f198e68bd 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -11,7 +11,7 @@ use crate::{
         def_map::ModuleDefId,
         resolution::{
             errors::ResolverError,
-            resolver::{verify_mutable_reference, SELF_TYPE_NAME},
+            resolver::{verify_mutable_reference, SELF_TYPE_NAME, WILDCARD_TYPE},
         },
         type_check::{Source, TypeCheckError},
     },
@@ -146,6 +146,8 @@ impl<'context> Elaborator<'context> {
                     }
                     return self_type;
                 }
+            } else if name == WILDCARD_TYPE {
+                return self.interner.next_type_variable();
             }
         }
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 4583125d2a2..f8db9730f88 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -64,6 +64,7 @@ use super::errors::{PubPosition, ResolverError};
 use super::import::PathResolution;
 
 pub const SELF_TYPE_NAME: &str = "Self";
+pub const WILDCARD_TYPE: &str = "_";
 
 type Scope = GenericScope<String, ResolverMeta>;
 type ScopeTree = GenericScopeTree<String, ResolverMeta>;
diff --git a/docs/docs/noir/concepts/data_types/index.md b/docs/docs/noir/concepts/data_types/index.md
index 357813c147a..3eadb2dc8a4 100644
--- a/docs/docs/noir/concepts/data_types/index.md
+++ b/docs/docs/noir/concepts/data_types/index.md
@@ -105,6 +105,14 @@ type Bad2 = Bad1;
 //   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
 ```
 
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
 ### BigInt
 
 You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/test_programs/execution_success/wildcard_type/Nargo.toml b/test_programs/execution_success/wildcard_type/Nargo.toml
new file mode 100644
index 00000000000..e3d7fc636af
--- /dev/null
+++ b/test_programs/execution_success/wildcard_type/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "wildcard_type"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/wildcard_type/Prover.toml b/test_programs/execution_success/wildcard_type/Prover.toml
new file mode 100644
index 00000000000..c7c8371dfa4
--- /dev/null
+++ b/test_programs/execution_success/wildcard_type/Prover.toml
@@ -0,0 +1 @@
+enable = [4,7]
diff --git a/test_programs/execution_success/wildcard_type/src/main.nr b/test_programs/execution_success/wildcard_type/src/main.nr
new file mode 100644
index 00000000000..c27f9987c48
--- /dev/null
+++ b/test_programs/execution_success/wildcard_type/src/main.nr
@@ -0,0 +1,23 @@
+struct bar {
+    enable: [bool; 4],
+    data: [Field; 2],
+    pad: u32,
+}
+
+fn main(enable: [Field; 2]) -> pub [Field; 4] {
+    let mut result = [0; 4];
+    let a: [_; 4] = foo(enable[1]);
+    for i in 0..4 {
+        result[i] = a[i].data[i % 2];
+    }
+    result
+}
+
+fn foo(x: Field) -> [bar; 4] {
+    [
+        bar { enable: [true, true, false, false], data: [x, x + 1], pad: 0 },
+        bar { enable: [true, false, false, false], data: [x + 2, x + 7], pad: 0 },
+        bar { enable: [true, true, false, true], data: [x + 3, x + 5], pad: 0 },
+        bar { enable: [false, false, false, false], data: [x + 4, x - 1], pad: 0 }
+    ]
+}
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index d2822ba11ab..ec750236806 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -58,10 +58,10 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
     "is_unconstrained",
 ];
 
-/// Certain comptime features are only available in the elaborator.
+/// Certain features are only available in the elaborator.
 /// We skip these tests for non-elaborator code since they are not
 /// expected to work there. This can be removed once the old code is removed.
-const IGNORED_COMPTIME_TESTS: [&str; 1] = ["macros"];
+const IGNORED_NEW_FEATURE_TESTS: [&str; 2] = ["macros", "wildcard_type"];
 
 fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_sub_dir = "execution_success";
@@ -82,11 +82,16 @@ fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path)
 
         let brillig_ignored =
             if IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) { "\n#[ignore]" } else { "" };
+        let new_features_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            "\n#[ignore]"
+        } else {
+            ""
+        };
 
         write!(
             test_file,
             r#"
-#[test]
+#[test]{new_features_ignored}
 fn execution_success_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
@@ -286,8 +291,11 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
         };
         let test_dir = &test_dir.path();
 
-        let comptime_ignored =
-            if IGNORED_COMPTIME_TESTS.contains(&test_name.as_str()) { "\n#[ignore]" } else { "" };
+        let comptime_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            "\n#[ignore]"
+        } else {
+            ""
+        };
 
         write!(
             test_file,

From 963b9a3ac1e77f5ac97561d177ae8a6da9b355a9 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 18:05:23 +0100
Subject: [PATCH 388/416] chore: create separate crate just for noir artifacts
 (#5162)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR splits off the definitions for Noir's build artifacts from the
`nargo` crate which adds a bunch of high-level logic. This makes it
easier to pull in and work on these types without having to pull in the
whole compiler.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    | 20 +++++++++++++++-
 Cargo.toml                                    |  2 ++
 compiler/wasm/Cargo.toml                      |  1 +
 compiler/wasm/src/compile.rs                  |  6 ++---
 tooling/debugger/Cargo.toml                   |  1 +
 tooling/debugger/src/context.rs               |  2 +-
 tooling/debugger/src/dap.rs                   |  2 +-
 tooling/debugger/src/foreign_calls.rs         |  6 ++---
 tooling/debugger/src/lib.rs                   |  2 +-
 tooling/debugger/src/repl.rs                  |  3 ++-
 tooling/debugger/src/source_code_printer.rs   |  4 ++--
 tooling/lsp/Cargo.toml                        |  1 +
 tooling/lsp/src/requests/profile_run.rs       |  6 ++---
 tooling/nargo/Cargo.toml                      |  3 +--
 tooling/nargo/src/lib.rs                      |  1 -
 tooling/nargo_cli/Cargo.toml                  |  1 +
 tooling/nargo_cli/src/cli/debug_cmd.rs        |  2 +-
 tooling/nargo_cli/src/cli/execute_cmd.rs      |  2 +-
 tooling/nargo_cli/src/cli/fs/program.rs       |  2 +-
 tooling/nargo_cli/src/cli/info_cmd.rs         |  6 ++---
 tooling/noirc_artifacts/Cargo.toml            | 24 +++++++++++++++++++
 .../src}/contract.rs                          |  0
 .../src}/debug.rs                             |  2 +-
 .../src}/debug_vars.rs                        |  0
 .../mod.rs => noirc_artifacts/src/lib.rs}     |  6 +++++
 .../src}/program.rs                           |  0
 26 files changed, 75 insertions(+), 30 deletions(-)
 create mode 100644 tooling/noirc_artifacts/Cargo.toml
 rename tooling/{nargo/src/artifacts => noirc_artifacts/src}/contract.rs (100%)
 rename tooling/{nargo/src/artifacts => noirc_artifacts/src}/debug.rs (99%)
 rename tooling/{nargo/src/artifacts => noirc_artifacts/src}/debug_vars.rs (100%)
 rename tooling/{nargo/src/artifacts/mod.rs => noirc_artifacts/src/lib.rs} (73%)
 rename tooling/{nargo/src/artifacts => noirc_artifacts/src}/program.rs (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 9a54944933e..16988432243 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2473,7 +2473,6 @@ name = "nargo"
 version = "0.31.0"
 dependencies = [
  "acvm",
- "codespan-reporting",
  "fm",
  "iter-extended",
  "jsonrpc",
@@ -2520,6 +2519,7 @@ dependencies = [
  "noir_debugger",
  "noir_lsp",
  "noirc_abi",
+ "noirc_artifacts",
  "noirc_driver",
  "noirc_errors",
  "noirc_frontend",
@@ -2649,6 +2649,7 @@ dependencies = [
  "easy-repl",
  "fm",
  "nargo",
+ "noirc_artifacts",
  "noirc_driver",
  "noirc_errors",
  "noirc_frontend",
@@ -2685,6 +2686,7 @@ dependencies = [
  "nargo",
  "nargo_fmt",
  "nargo_toml",
+ "noirc_artifacts",
  "noirc_driver",
  "noirc_errors",
  "noirc_frontend",
@@ -2710,6 +2712,7 @@ dependencies = [
  "gloo-utils",
  "js-sys",
  "nargo",
+ "noirc_artifacts",
  "noirc_driver",
  "noirc_errors",
  "noirc_evaluator",
@@ -2761,6 +2764,21 @@ dependencies = [
 name = "noirc_arena"
 version = "0.31.0"
 
+[[package]]
+name = "noirc_artifacts"
+version = "0.31.0"
+dependencies = [
+ "acvm",
+ "codespan-reporting",
+ "fm",
+ "noirc_abi",
+ "noirc_driver",
+ "noirc_errors",
+ "noirc_printable_type",
+ "serde",
+ "tempfile",
+]
+
 [[package]]
 name = "noirc_driver"
 version = "0.31.0"
diff --git a/Cargo.toml b/Cargo.toml
index 8a4c94d8876..5fc9936de91 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ members = [
     "tooling/nargo_fmt",
     "tooling/nargo_cli",
     "tooling/nargo_toml",
+    "tooling/noirc_artifacts",
     "tooling/noirc_abi",
     "tooling/noirc_abi_wasm",
     "tooling/acvm_cli",
@@ -74,6 +75,7 @@ nargo_toml = { path = "tooling/nargo_toml" }
 noir_lsp = { path = "tooling/lsp" }
 noir_debugger = { path = "tooling/debugger" }
 noirc_abi = { path = "tooling/noirc_abi" }
+noirc_artifacts = { path = "tooling/noirc_artifacts" }
 bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" }
 acvm_cli = { path = "tooling/acvm_cli" }
 
diff --git a/compiler/wasm/Cargo.toml b/compiler/wasm/Cargo.toml
index 03e59b3e269..20272dfeecb 100644
--- a/compiler/wasm/Cargo.toml
+++ b/compiler/wasm/Cargo.toml
@@ -20,6 +20,7 @@ noirc_driver.workspace = true
 noirc_frontend = { workspace = true, features = ["bn254"] }
 noirc_errors.workspace = true
 noirc_evaluator.workspace = true
+noirc_artifacts.workspace = true
 wasm-bindgen.workspace = true
 serde.workspace = true
 js-sys.workspace = true
diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index f1495e0b438..59b0e00e49f 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -2,10 +2,8 @@ use acvm::acir::circuit::ExpressionWidth;
 use fm::FileManager;
 use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{JsString, Object};
-use nargo::{
-    artifacts::{contract::ContractArtifact, program::ProgramArtifact},
-    parse_all,
-};
+use nargo::parse_all;
+use noirc_artifacts::{contract::ContractArtifact, program::ProgramArtifact};
 use noirc_driver::{
     add_dep, file_manager_with_stdlib, prepare_crate, prepare_dependency, CompileOptions,
 };
diff --git a/tooling/debugger/Cargo.toml b/tooling/debugger/Cargo.toml
index a3bf12f5368..05b28f9d95a 100644
--- a/tooling/debugger/Cargo.toml
+++ b/tooling/debugger/Cargo.toml
@@ -18,6 +18,7 @@ noirc_frontend.workspace = true
 noirc_printable_type.workspace = true
 noirc_errors.workspace = true
 noirc_driver.workspace = true
+noirc_artifacts.workspace = true
 thiserror.workspace = true
 codespan-reporting.workspace = true
 dap.workspace = true
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 4436ce0ec3d..cb36988bf0b 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -10,9 +10,9 @@ use acvm::{BlackBoxFunctionSolver, FieldElement};
 
 use codespan_reporting::files::{Files, SimpleFile};
 use fm::FileId;
-use nargo::artifacts::debug::{DebugArtifact, StackFrame};
 use nargo::errors::{ExecutionError, Location};
 use nargo::NargoError;
+use noirc_artifacts::debug::{DebugArtifact, StackFrame};
 use noirc_driver::DebugFile;
 
 use std::collections::BTreeMap;
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index 40b77f0ad2a..77abf3093cd 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -24,7 +24,7 @@ use dap::types::{
     Breakpoint, DisassembledInstruction, Scope, Source, StackFrame, SteppingGranularity,
     StoppedEventReason, Thread, Variable,
 };
-use nargo::artifacts::debug::DebugArtifact;
+use noirc_artifacts::debug::DebugArtifact;
 
 use fm::FileId;
 use noirc_driver::CompiledProgram;
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index 03b1a35dfa5..62443d4065c 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -3,10 +3,8 @@ use acvm::{
     pwg::ForeignCallWaitInfo,
     AcirField, FieldElement,
 };
-use nargo::{
-    artifacts::debug::{DebugArtifact, DebugVars, StackFrame},
-    ops::{DefaultForeignCallExecutor, ForeignCallExecutor},
-};
+use nargo::ops::{DefaultForeignCallExecutor, ForeignCallExecutor};
+use noirc_artifacts::debug::{DebugArtifact, DebugVars, StackFrame};
 use noirc_errors::debug_info::{DebugFnId, DebugVarId};
 use noirc_printable_type::ForeignCallError;
 
diff --git a/tooling/debugger/src/lib.rs b/tooling/debugger/src/lib.rs
index 9168a6228f0..9d0059ee495 100644
--- a/tooling/debugger/src/lib.rs
+++ b/tooling/debugger/src/lib.rs
@@ -13,7 +13,7 @@ use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 
-use nargo::artifacts::debug::DebugArtifact;
+use noirc_artifacts::debug::DebugArtifact;
 
 use nargo::NargoError;
 use noirc_driver::CompiledProgram;
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 07f9333d51c..7d8c6e0947d 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -5,9 +5,10 @@ use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
 use acvm::brillig_vm::brillig::Opcode as BrilligOpcode;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
+use nargo::NargoError;
 
 use crate::foreign_calls::DefaultDebugForeignCallExecutor;
-use nargo::{artifacts::debug::DebugArtifact, NargoError};
+use noirc_artifacts::debug::DebugArtifact;
 
 use easy_repl::{command, CommandStatus, Repl};
 use noirc_printable_type::PrintableValueDisplay;
diff --git a/tooling/debugger/src/source_code_printer.rs b/tooling/debugger/src/source_code_printer.rs
index ad511563477..e9586b786bd 100644
--- a/tooling/debugger/src/source_code_printer.rs
+++ b/tooling/debugger/src/source_code_printer.rs
@@ -1,5 +1,5 @@
 use codespan_reporting::files::Files;
-use nargo::artifacts::debug::DebugArtifact;
+use noirc_artifacts::debug::DebugArtifact;
 use noirc_errors::Location;
 use owo_colors::OwoColorize;
 use std::ops::Range;
@@ -224,7 +224,7 @@ mod tests {
     use crate::source_code_printer::PrintedLine::Content;
     use acvm::acir::circuit::OpcodeLocation;
     use fm::FileManager;
-    use nargo::artifacts::debug::DebugArtifact;
+    use noirc_artifacts::debug::DebugArtifact;
     use noirc_errors::{debug_info::DebugInfo, Location, Span};
     use std::collections::BTreeMap;
     use std::ops::Range;
diff --git a/tooling/lsp/Cargo.toml b/tooling/lsp/Cargo.toml
index a599b096e52..ac3e3b1d30a 100644
--- a/tooling/lsp/Cargo.toml
+++ b/tooling/lsp/Cargo.toml
@@ -19,6 +19,7 @@ nargo_toml.workspace = true
 noirc_driver.workspace = true
 noirc_errors.workspace = true
 noirc_frontend.workspace = true
+noirc_artifacts.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 tower.workspace = true
diff --git a/tooling/lsp/src/requests/profile_run.rs b/tooling/lsp/src/requests/profile_run.rs
index 7d06bc87c85..57bc3299455 100644
--- a/tooling/lsp/src/requests/profile_run.rs
+++ b/tooling/lsp/src/requests/profile_run.rs
@@ -5,11 +5,9 @@ use std::{
 
 use acvm::acir::circuit::ExpressionWidth;
 use async_lsp::{ErrorCode, ResponseError};
-use nargo::{
-    artifacts::debug::DebugArtifact, insert_all_files_for_workspace_into_file_manager,
-    ops::report_errors,
-};
+use nargo::{insert_all_files_for_workspace_into_file_manager, ops::report_errors};
 use nargo_toml::{find_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use noirc_artifacts::debug::DebugArtifact;
 use noirc_driver::{
     file_manager_with_stdlib, CompileOptions, DebugFile, NOIR_ARTIFACT_VERSION_STRING,
 };
diff --git a/tooling/nargo/Cargo.toml b/tooling/nargo/Cargo.toml
index 8abec267d20..b0cf1cfcbb1 100644
--- a/tooling/nargo/Cargo.toml
+++ b/tooling/nargo/Cargo.toml
@@ -18,13 +18,12 @@ noirc_errors.workspace = true
 noirc_frontend.workspace = true
 noirc_printable_type.workspace = true
 iter-extended.workspace = true
-serde.workspace = true
 thiserror.workspace = true
-codespan-reporting.workspace = true
 tracing.workspace = true
 rayon = "1.8.0"
 jsonrpc.workspace = true
 rand.workspace = true
+serde.workspace = true
 
 [dev-dependencies]
 # TODO: This dependency is used to generate unit tests for `get_all_paths_in_dir`
diff --git a/tooling/nargo/src/lib.rs b/tooling/nargo/src/lib.rs
index 3deced041f8..c0c7602d14d 100644
--- a/tooling/nargo/src/lib.rs
+++ b/tooling/nargo/src/lib.rs
@@ -7,7 +7,6 @@
 //! This name was used because it sounds like `cargo` and
 //! Noir Package Manager abbreviated is npm, which is already taken.
 
-pub mod artifacts;
 pub mod constants;
 pub mod errors;
 pub mod ops;
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index a9946c8700c..c3beafb7db5 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -32,6 +32,7 @@ noirc_driver.workspace = true
 noirc_frontend = { workspace = true, features = ["bn254"] }
 noirc_abi.workspace = true
 noirc_errors.workspace = true
+noirc_artifacts.workspace = true
 acvm = { workspace = true, features = ["bn254"] }
 bn254_blackbox_solver.workspace = true
 toml.workspace = true
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 086dddc27e5..778009bf791 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -6,7 +6,6 @@ use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
 use fm::FileManager;
-use nargo::artifacts::debug::DebugArtifact;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::errors::CompileError;
 use nargo::ops::{compile_program, compile_program_with_debug_instrumenter, report_errors};
@@ -16,6 +15,7 @@ use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_abi::input_parser::{Format, InputValue};
 use noirc_abi::InputMap;
+use noirc_artifacts::debug::DebugArtifact;
 use noirc_driver::{
     file_manager_with_stdlib, CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING,
 };
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index b548336275b..cf9dc1141a1 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -3,7 +3,6 @@ use acvm::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 
-use nargo::artifacts::debug::DebugArtifact;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::errors::try_to_diagnose_runtime_error;
 use nargo::ops::DefaultForeignCallExecutor;
@@ -11,6 +10,7 @@ use nargo::package::Package;
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_abi::input_parser::{Format, InputValue};
 use noirc_abi::InputMap;
+use noirc_artifacts::debug::DebugArtifact;
 use noirc_driver::{CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_frontend::graph::CrateName;
 
diff --git a/tooling/nargo_cli/src/cli/fs/program.rs b/tooling/nargo_cli/src/cli/fs/program.rs
index ba017651667..caeaafd4ab3 100644
--- a/tooling/nargo_cli/src/cli/fs/program.rs
+++ b/tooling/nargo_cli/src/cli/fs/program.rs
@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use nargo::artifacts::{contract::ContractArtifact, program::ProgramArtifact};
+use noirc_artifacts::{contract::ContractArtifact, program::ProgramArtifact};
 use noirc_frontend::graph::CrateName;
 
 use crate::errors::FilesystemError;
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 7c50e907dc9..3759fb31c76 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -3,11 +3,9 @@ use std::collections::HashMap;
 use acvm::acir::circuit::ExpressionWidth;
 use clap::Args;
 use iter_extended::vecmap;
-use nargo::{
-    artifacts::{debug::DebugArtifact, program::ProgramArtifact},
-    package::Package,
-};
+use nargo::package::Package;
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use noirc_artifacts::{debug::DebugArtifact, program::ProgramArtifact};
 use noirc_driver::{CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_errors::{debug_info::OpCodesCount, Location};
 use noirc_frontend::graph::CrateName;
diff --git a/tooling/noirc_artifacts/Cargo.toml b/tooling/noirc_artifacts/Cargo.toml
new file mode 100644
index 00000000000..4249604f949
--- /dev/null
+++ b/tooling/noirc_artifacts/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "noirc_artifacts"
+description = "Definitions of Nargo's build artifacts"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+acvm.workspace = true
+fm.workspace = true
+noirc_abi.workspace = true
+noirc_driver.workspace = true
+noirc_errors.workspace = true
+noirc_printable_type.workspace = true
+serde.workspace = true
+codespan-reporting.workspace = true
+
+
+[dev-dependencies]
+tempfile.workspace = true
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/noirc_artifacts/src/contract.rs
similarity index 100%
rename from tooling/nargo/src/artifacts/contract.rs
rename to tooling/noirc_artifacts/src/contract.rs
diff --git a/tooling/nargo/src/artifacts/debug.rs b/tooling/noirc_artifacts/src/debug.rs
similarity index 99%
rename from tooling/nargo/src/artifacts/debug.rs
rename to tooling/noirc_artifacts/src/debug.rs
index 21102c40fcf..11a3e1c4dd7 100644
--- a/tooling/nargo/src/artifacts/debug.rs
+++ b/tooling/noirc_artifacts/src/debug.rs
@@ -186,7 +186,7 @@ impl<'a> Files<'a> for DebugArtifact {
 
 #[cfg(test)]
 mod tests {
-    use crate::artifacts::debug::DebugArtifact;
+    use crate::debug::DebugArtifact;
     use acvm::acir::circuit::OpcodeLocation;
     use fm::FileManager;
     use noirc_errors::{debug_info::DebugInfo, Location, Span};
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/noirc_artifacts/src/debug_vars.rs
similarity index 100%
rename from tooling/nargo/src/artifacts/debug_vars.rs
rename to tooling/noirc_artifacts/src/debug_vars.rs
diff --git a/tooling/nargo/src/artifacts/mod.rs b/tooling/noirc_artifacts/src/lib.rs
similarity index 73%
rename from tooling/nargo/src/artifacts/mod.rs
rename to tooling/noirc_artifacts/src/lib.rs
index c7b3736f90b..77873ed9409 100644
--- a/tooling/nargo/src/artifacts/mod.rs
+++ b/tooling/noirc_artifacts/src/lib.rs
@@ -1,8 +1,14 @@
+#![forbid(unsafe_code)]
+#![warn(unused_crate_dependencies, unused_extern_crates)]
+#![warn(unreachable_pub)]
+#![warn(clippy::semicolon_if_nothing_returned)]
+
 //! This module defines the structure of Nargo's different compilation artifacts.
 //!
 //! These artifacts are intended to remain independent of any applications being built on top of Noir.
 //! Should any projects require/desire a different artifact format, it's expected that they will write a transformer
 //! to generate them using these artifacts as a starting point.
+
 pub mod contract;
 pub mod debug;
 mod debug_vars;
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/noirc_artifacts/src/program.rs
similarity index 100%
rename from tooling/nargo/src/artifacts/program.rs
rename to tooling/noirc_artifacts/src/program.rs

From 9db65d8706ac8b67921f2a73163ab8bee3dfb4e8 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 18:09:26 +0100
Subject: [PATCH 389/416] feat: implement comptime support for `as_slice`
 builtin (#5276)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5274

## Summary\*

This PR implements the `as_slice` builtin function for the comptime
interpreter. I've also fixed an issue where due to
builtin/foreign/oracle functions having an early return, we don't call
`exit_function` which results in the scopes being left in an
inconsistent state.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/hir/comptime/interpreter.rs               |  5 +++--
 .../src/hir/comptime/interpreter/builtin.rs       | 15 ++++++++++++++-
 .../comptime_as_slice/Nargo.toml                  |  7 +++++++
 .../comptime_as_slice/src/main.nr                 |  9 +++++++++
 4 files changed, 33 insertions(+), 3 deletions(-)
 create mode 100644 test_programs/compile_success_empty/comptime_as_slice/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/comptime_as_slice/src/main.nr

diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index c473ac7f8a6..07da3398593 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -62,8 +62,6 @@ impl<'a> Interpreter<'a> {
         arguments: Vec<(Value, Location)>,
         location: Location,
     ) -> IResult<Value> {
-        let previous_state = self.enter_function();
-
         let meta = self.interner.function_meta(&function);
         if meta.parameters.len() != arguments.len() {
             return Err(InterpreterError::ArgumentCountMismatch {
@@ -78,6 +76,8 @@ impl<'a> Interpreter<'a> {
         }
 
         let parameters = meta.parameters.0.clone();
+        let previous_state = self.enter_function();
+
         for ((parameter, typ, _), (argument, arg_location)) in parameters.iter().zip(arguments) {
             self.define_pattern(parameter, typ, argument, arg_location)?;
         }
@@ -102,6 +102,7 @@ impl<'a> Interpreter<'a> {
         if let Some(builtin) = func_attrs.builtin() {
             match builtin.as_str() {
                 "array_len" => builtin::array_len(&arguments),
+                "as_slice" => builtin::as_slice(arguments),
                 _ => {
                     let item = format!("Evaluation for builtin function {builtin}");
                     Err(InterpreterError::Unimplemented { item, location })
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
index 3e5ad207719..9216ba271c1 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
@@ -1,6 +1,9 @@
 use noirc_errors::Location;
 
-use crate::hir::comptime::{errors::IResult, Value};
+use crate::{
+    hir::comptime::{errors::IResult, Value},
+    Type,
+};
 
 pub(super) fn array_len(arguments: &[(Value, Location)]) -> IResult<Value> {
     assert_eq!(arguments.len(), 1, "ICE: `array_len` should only receive a single argument");
@@ -10,3 +13,13 @@ pub(super) fn array_len(arguments: &[(Value, Location)]) -> IResult<Value> {
         _ => unreachable!("ICE: Cannot query length of types other than arrays or slices"),
     }
 }
+
+pub(super) fn as_slice(mut arguments: Vec<(Value, Location)>) -> IResult<Value> {
+    assert_eq!(arguments.len(), 1, "ICE: `as_slice` should only receive a single argument");
+    let (array, _) = arguments.pop().unwrap();
+    match array {
+        Value::Array(values, Type::Array(_, typ)) => Ok(Value::Slice(values, Type::Slice(typ))),
+        // Type checking should prevent this branch being taken.
+        _ => unreachable!("ICE: Cannot convert types other than arrays into slices"),
+    }
+}
diff --git a/test_programs/compile_success_empty/comptime_as_slice/Nargo.toml b/test_programs/compile_success_empty/comptime_as_slice/Nargo.toml
new file mode 100644
index 00000000000..90c67b07b2b
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_as_slice/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "array_to_slice"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.24.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/comptime_as_slice/src/main.nr b/test_programs/compile_success_empty/comptime_as_slice/src/main.nr
new file mode 100644
index 00000000000..07c5e344cc2
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_as_slice/src/main.nr
@@ -0,0 +1,9 @@
+fn main() {
+    comptime
+    {
+        let ws: [Field; 3] = [1; 3];
+        let ws_as_slice: [Field] = ws.as_slice();
+
+        assert_eq(ws[0], ws_as_slice[0]);
+    }
+}

From 6cbe6a0c830b2992666e0f9bdbc8f66ec41eed84 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Tue, 18 Jun 2024 12:32:54 -0500
Subject: [PATCH 390/416] feat: Run `comptime` code from annotations on a type
 definition (#5256)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5255

## Summary\*

Implements the ability to run comptime code when an annotation is put on
a type definition. This annotation must resolve to a comptime function
in scope, which is then called with the type definition as an argument.
There are currently no API functions to actually do anything with a
`TypeDefinition` object. The plan is to add functions in the future to
inspect or add fields & generics.

```rs
#[print_type]
struct Foo {
    bar: Field,
}

comptime fn print_type(typ: TypeDefinition) {
    println("hello from print_type_name at compile-time");
    println(typ); // only prints "(type definition)" currently
}

fn main(){}
```

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Maxim Vezenov <mvezenov@gmail.com>
---
 compiler/noirc_driver/src/abi_gen.rs          |   2 +-
 compiler/noirc_frontend/src/ast/mod.rs        |   4 +-
 .../src/elaborator/expressions.rs             |   9 +-
 compiler/noirc_frontend/src/elaborator/mod.rs | 133 +++++++++++++++---
 .../noirc_frontend/src/elaborator/types.rs    |   4 +-
 .../src/hir/comptime/interpreter.rs           |   6 +-
 .../noirc_frontend/src/hir/comptime/value.rs  |  14 +-
 .../src/hir/resolution/errors.rs              |  20 ++-
 .../src/hir/resolution/resolver.rs            |   4 +-
 .../noirc_frontend/src/hir/type_check/expr.rs |   2 +-
 compiler/noirc_frontend/src/hir_def/types.rs  |  43 ++++--
 compiler/noirc_frontend/src/lexer/token.rs    |   9 ++
 .../src/monomorphization/mod.rs               |   2 +-
 compiler/noirc_frontend/src/node_interner.rs  |   5 +-
 .../noirc_frontend/src/parser/parser/types.rs |  28 +++-
 .../type_definition_annotation/Nargo.toml     |   7 +
 .../type_definition_annotation/src/main.nr    |   8 ++
 tooling/nargo_cli/build.rs                    |  15 +-
 tooling/nargo_fmt/src/rewrite/typ.rs          |   2 +-
 tooling/nargo_fmt/tests/expected/impl.nr      |  12 +-
 tooling/nargo_fmt/tests/input/impl.nr         |  14 +-
 21 files changed, 269 insertions(+), 74 deletions(-)
 create mode 100644 test_programs/compile_failure/type_definition_annotation/Nargo.toml
 create mode 100644 test_programs/compile_failure/type_definition_annotation/src/main.nr

diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 300a0592e39..d0b33945f40 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -104,7 +104,7 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
         | Type::TypeVariable(_, _)
         | Type::NamedGeneric(..)
         | Type::Forall(..)
-        | Type::Expr
+        | Type::Quoted(_)
         | Type::Slice(_)
         | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
         Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 3492df73103..a1ae349b537 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -117,7 +117,7 @@ pub enum UnresolvedTypeData {
     ),
 
     // The type of quoted code for metaprogramming
-    Expr,
+    Quoted(crate::QuotedType),
 
     Unspecified, // This is for when the user declares a variable without specifying it's type
     Error,
@@ -216,7 +216,7 @@ impl std::fmt::Display for UnresolvedTypeData {
                 }
             }
             MutableReference(element) => write!(f, "&mut {element}"),
-            Expr => write!(f, "Expr"),
+            Quoted(quoted) => write!(f, "{}", quoted),
             Unit => write!(f, "()"),
             Error => write!(f, "error"),
             Unspecified => write!(f, "unspecified"),
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index a57690878dc..d6ad752b67a 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -28,7 +28,7 @@ use crate::{
         MethodCallExpression, PrefixExpression,
     },
     node_interner::{DefinitionKind, ExprId, FuncId},
-    Shared, StructType, Type,
+    QuotedType, Shared, StructType, Type,
 };
 
 use super::Elaborator;
@@ -650,7 +650,7 @@ impl<'context> Elaborator<'context> {
         let mut unquoted_exprs = Vec::new();
         self.find_unquoted_exprs_in_block(&mut block, &mut unquoted_exprs);
         let quoted = HirQuoted { quoted_block: block, unquoted_exprs };
-        (HirExpression::Quote(quoted), Type::Expr)
+        (HirExpression::Quote(quoted), Type::Quoted(QuotedType::Expr))
     }
 
     fn elaborate_comptime_block(&mut self, block: BlockExpression, span: Span) -> (ExprId, Type) {
@@ -716,9 +716,8 @@ impl<'context> Elaborator<'context> {
         location: Location,
         return_type: Type,
     ) -> Option<(HirExpression, Type)> {
-        self.unify(&return_type, &Type::Expr, || TypeCheckError::MacroReturningNonExpr {
-            typ: return_type.clone(),
-            span: location.span,
+        self.unify(&return_type, &Type::Quoted(QuotedType::Expr), || {
+            TypeCheckError::MacroReturningNonExpr { typ: return_type.clone(), span: location.span }
         });
 
         let function = match self.try_get_comptime_function(func, location) {
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 0b7e5a58849..053de6e1735 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -6,7 +6,7 @@ use std::{
 use crate::{
     ast::{FunctionKind, UnresolvedTraitConstraint},
     hir::{
-        comptime::{self, Interpreter},
+        comptime::{self, Interpreter, Value},
         def_collector::{
             dc_crate::{
                 filter_literal_globals, CompilationError, ImplMap, UnresolvedGlobal,
@@ -205,10 +205,22 @@ impl<'context> Elaborator<'context> {
     pub fn elaborate(
         context: &'context mut Context,
         crate_id: CrateId,
-        mut items: CollectedItems,
+        items: CollectedItems,
     ) -> Vec<(CompilationError, FileId)> {
         let mut this = Self::new(context, crate_id);
 
+        // Filter out comptime items to execute their functions first if needed.
+        // This step is why comptime items can only refer to other comptime items
+        // in the same crate, but can refer to any item in dependencies. Trying to
+        // run these at the same time as other items would lead to them seeing empty
+        // function bodies from functions that have yet to be elaborated.
+        let (comptime_items, runtime_items) = Self::filter_comptime_items(items);
+        this.elaborate_items(comptime_items);
+        this.elaborate_items(runtime_items);
+        this.errors
+    }
+
+    fn elaborate_items(&mut self, mut items: CollectedItems) {
         // We must first resolve and intern the globals before we can resolve any stmts inside each function.
         // Each function uses its own resolver with a newly created ScopeForest, and must be resolved again to be within a function's scope
         //
@@ -216,58 +228,56 @@ impl<'context> Elaborator<'context> {
         // the values of integer globals as numeric generics.
         let (literal_globals, non_literal_globals) = filter_literal_globals(items.globals);
         for global in non_literal_globals {
-            this.unresolved_globals.insert(global.global_id, global);
+            self.unresolved_globals.insert(global.global_id, global);
         }
 
         for global in literal_globals {
-            this.elaborate_global(global);
+            self.elaborate_global(global);
         }
 
         for (alias_id, alias) in items.type_aliases {
-            this.define_type_alias(alias_id, alias);
+            self.define_type_alias(alias_id, alias);
         }
 
-        this.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
-        this.collect_traits(items.traits);
+        self.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
+        self.collect_traits(items.traits);
 
         // Must resolve structs before we resolve globals.
-        this.collect_struct_definitions(items.types);
+        self.collect_struct_definitions(items.types);
 
         // Before we resolve any function symbols we must go through our impls and
         // re-collect the methods within into their proper module. This cannot be
         // done during def collection since we need to be able to resolve the type of
         // the impl since that determines the module we should collect into.
         for ((_self_type, module), impls) in &mut items.impls {
-            this.collect_impls(*module, impls);
+            self.collect_impls(*module, impls);
         }
 
         // Bind trait impls to their trait. Collect trait functions, that have a
         // default implementation, which hasn't been overridden.
         for trait_impl in &mut items.trait_impls {
-            this.collect_trait_impl(trait_impl);
+            self.collect_trait_impl(trait_impl);
         }
 
         // We must wait to resolve non-literal globals until after we resolve structs since struct
         // globals will need to reference the struct type they're initialized to ensure they are valid.
-        while let Some((_, global)) = this.unresolved_globals.pop_first() {
-            this.elaborate_global(global);
+        while let Some((_, global)) = self.unresolved_globals.pop_first() {
+            self.elaborate_global(global);
         }
 
         for functions in items.functions {
-            this.elaborate_functions(functions);
+            self.elaborate_functions(functions);
         }
 
         for impls in items.impls.into_values() {
-            this.elaborate_impls(impls);
+            self.elaborate_impls(impls);
         }
 
         for trait_impl in items.trait_impls {
-            this.elaborate_trait_impl(trait_impl);
+            self.elaborate_trait_impl(trait_impl);
         }
 
-        let cycle_errors = this.interner.check_for_dependency_cycles();
-        this.errors.extend(cycle_errors);
-        this.errors
+        self.errors.extend(self.interner.check_for_dependency_cycles());
     }
 
     /// Runs `f` and if it modifies `self.generics`, `self.generics` is truncated
@@ -1085,15 +1095,20 @@ impl<'context> Elaborator<'context> {
 
         // Resolve each field in each struct.
         // Each struct should already be present in the NodeInterner after def collection.
-        for (type_id, typ) in structs {
+        for (type_id, mut typ) in structs {
             self.file = typ.file_id;
             self.local_module = typ.module_id;
+
+            let attributes = std::mem::take(&mut typ.struct_def.attributes);
+            let span = typ.struct_def.span;
             let (generics, fields) = self.resolve_struct_fields(typ.struct_def, type_id);
 
             self.interner.update_struct(type_id, |struct_def| {
                 struct_def.set_fields(fields);
                 struct_def.generics = generics;
             });
+
+            self.run_comptime_attributes_on_struct(attributes, type_id, span);
         }
 
         // Check whether the struct fields have nested slices
@@ -1117,6 +1132,38 @@ impl<'context> Elaborator<'context> {
         }
     }
 
+    fn run_comptime_attributes_on_struct(
+        &mut self,
+        attributes: Vec<SecondaryAttribute>,
+        struct_id: StructId,
+        span: Span,
+    ) {
+        for attribute in attributes {
+            if let SecondaryAttribute::Custom(name) = attribute {
+                match self.lookup_global(Path::from_single(name, span)) {
+                    Ok(id) => {
+                        let definition = self.interner.definition(id);
+                        if let DefinitionKind::Function(function) = &definition.kind {
+                            let function = *function;
+                            let mut interpreter =
+                                Interpreter::new(self.interner, &mut self.comptime_scopes);
+
+                            let location = Location::new(span, self.file);
+                            let arguments = vec![(Value::TypeDefinition(struct_id), location)];
+                            let result = interpreter.call_function(function, arguments, location);
+                            if let Err(error) = result {
+                                self.errors.push(error.into_compilation_error_pair());
+                            }
+                        } else {
+                            self.push_err(ResolverError::NonFunctionInAnnotation { span });
+                        }
+                    }
+                    Err(_) => self.push_err(ResolverError::UnknownAnnotation { span }),
+                }
+            }
+        }
+    }
+
     pub fn resolve_struct_fields(
         &mut self,
         unresolved: NoirStruct,
@@ -1261,4 +1308,52 @@ impl<'context> Elaborator<'context> {
             });
         }
     }
+
+    /// Filters out comptime items from non-comptime items.
+    /// Returns a pair of (comptime items, non-comptime items)
+    fn filter_comptime_items(mut items: CollectedItems) -> (CollectedItems, CollectedItems) {
+        let mut function_sets = Vec::with_capacity(items.functions.len());
+        let mut comptime_function_sets = Vec::new();
+
+        for function_set in items.functions {
+            let mut functions = Vec::with_capacity(function_set.functions.len());
+            let mut comptime_functions = Vec::new();
+
+            for function in function_set.functions {
+                if function.2.def.is_comptime {
+                    comptime_functions.push(function);
+                } else {
+                    functions.push(function);
+                }
+            }
+
+            let file_id = function_set.file_id;
+            let self_type = function_set.self_type;
+            let trait_id = function_set.trait_id;
+
+            if !comptime_functions.is_empty() {
+                comptime_function_sets.push(UnresolvedFunctions {
+                    functions: comptime_functions,
+                    file_id,
+                    trait_id,
+                    self_type: self_type.clone(),
+                });
+            }
+
+            function_sets.push(UnresolvedFunctions { functions, file_id, trait_id, self_type });
+        }
+
+        let comptime = CollectedItems {
+            functions: comptime_function_sets,
+            types: BTreeMap::new(),
+            type_aliases: BTreeMap::new(),
+            traits: BTreeMap::new(),
+            trait_impls: Vec::new(),
+            globals: Vec::new(),
+            impls: std::collections::HashMap::new(),
+        };
+
+        items.functions = function_sets;
+        (comptime, items)
+    }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index e3f198e68bd..fcb7ac94c26 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -72,7 +72,7 @@ impl<'context> Elaborator<'context> {
                 let fields = self.resolve_type_inner(*fields);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
-            Expr => Type::Expr,
+            Quoted(quoted) => Type::Quoted(quoted),
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
@@ -1398,7 +1398,7 @@ impl<'context> Elaborator<'context> {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::Forall(_, _) => (),
 
             Type::TraitAsType(_, _, args) => {
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 07da3398593..21b6897f5dd 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -104,18 +104,18 @@ impl<'a> Interpreter<'a> {
                 "array_len" => builtin::array_len(&arguments),
                 "as_slice" => builtin::as_slice(arguments),
                 _ => {
-                    let item = format!("Evaluation for builtin function {builtin}");
+                    let item = format!("Comptime evaluation for builtin function {builtin}");
                     Err(InterpreterError::Unimplemented { item, location })
                 }
             }
         } else if let Some(foreign) = func_attrs.foreign() {
-            let item = format!("Evaluation for foreign functions like {foreign}");
+            let item = format!("Comptime evaluation for foreign functions like {foreign}");
             Err(InterpreterError::Unimplemented { item, location })
         } else if let Some(oracle) = func_attrs.oracle() {
             if oracle == "print" {
                 self.print_oracle(arguments)
             } else {
-                let item = format!("Evaluation for oracle functions like {oracle}");
+                let item = format!("Comptime evaluation for oracle functions like {oracle}");
                 Err(InterpreterError::Unimplemented { item, location })
             }
         } else {
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 5d91b151218..a75d4fd2b24 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -12,9 +12,10 @@ use crate::{
     hir_def::expr::{HirArrayLiteral, HirConstructorExpression, HirIdent, HirLambda, ImplKind},
     macros_api::{
         Expression, ExpressionKind, HirExpression, HirLiteral, Literal, NodeInterner, Path,
+        StructId,
     },
     node_interner::{ExprId, FuncId},
-    Shared, Type,
+    QuotedType, Shared, Type,
 };
 use rustc_hash::FxHashMap as HashMap;
 
@@ -42,6 +43,7 @@ pub enum Value {
     Array(Vector<Value>, Type),
     Slice(Vector<Value>, Type),
     Code(Rc<BlockExpression>),
+    TypeDefinition(StructId),
 }
 
 impl Value {
@@ -70,7 +72,8 @@ impl Value {
             Value::Struct(_, typ) => return Cow::Borrowed(typ),
             Value::Array(_, typ) => return Cow::Borrowed(typ),
             Value::Slice(_, typ) => return Cow::Borrowed(typ),
-            Value::Code(_) => Type::Expr,
+            Value::Code(_) => Type::Quoted(QuotedType::Expr),
+            Value::TypeDefinition(_) => Type::Quoted(QuotedType::TypeDefinition),
             Value::Pointer(element) => {
                 let element = element.borrow().get_type().into_owned();
                 Type::MutableReference(Box::new(element))
@@ -172,7 +175,7 @@ impl Value {
                 ExpressionKind::Literal(Literal::Slice(ArrayLiteral::Standard(elements)))
             }
             Value::Code(block) => ExpressionKind::Block(unwrap_rc(block)),
-            Value::Pointer(_) => {
+            Value::Pointer(_) | Value::TypeDefinition(_) => {
                 return Err(InterpreterError::CannotInlineMacro { value: self, location })
             }
         };
@@ -273,7 +276,7 @@ impl Value {
                 HirExpression::Literal(HirLiteral::Slice(HirArrayLiteral::Standard(elements)))
             }
             Value::Code(block) => HirExpression::Unquote(unwrap_rc(block)),
-            Value::Pointer(_) => {
+            Value::Pointer(_) | Value::TypeDefinition(_) => {
                 return Err(InterpreterError::CannotInlineMacro { value: self, location })
             }
         };
@@ -348,7 +351,8 @@ impl Display for Value {
                 let values = vecmap(values, ToString::to_string);
                 write!(f, "&[{}]", values.join(", "))
             }
-            Value::Code(_) => todo!(),
+            Value::Code(block) => write!(f, "quote {block}"),
+            Value::TypeDefinition(_) => write!(f, "(type definition)"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 2c6461cb77c..dad0149ec73 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -106,6 +106,10 @@ pub enum ResolverError {
     InvalidSyntaxInMacroCall { span: Span },
     #[error("Macros must be comptime functions")]
     MacroIsNotComptime { span: Span },
+    #[error("Annotation name must refer to a comptime function")]
+    NonFunctionInAnnotation { span: Span },
+    #[error("Unknown annotation")]
+    UnknownAnnotation { span: Span },
 }
 
 impl ResolverError {
@@ -411,13 +415,27 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
-            ResolverError::MacroIsNotComptime{ span } => {
+            ResolverError::MacroIsNotComptime { span } => {
                 Diagnostic::simple_error(
                     "This macro call is to a non-comptime function".into(),
                     "Macro calls must be to comptime functions".into(),
                     *span,
                 )
             },
+            ResolverError::NonFunctionInAnnotation { span } => {
+                Diagnostic::simple_error(
+                    "Unknown annotation".into(),
+                    "The name of an annotation must refer to a comptime function".into(),
+                    *span,
+                )
+            },
+            ResolverError::UnknownAnnotation { span } => {
+                Diagnostic::simple_warning(
+                    "Unknown annotation".into(),
+                    "No matching comptime function found in scope".into(),
+                    *span,
+                )
+            },
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index f8db9730f88..1dcace82372 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -570,7 +570,7 @@ impl<'a> Resolver<'a> {
                 let fields = self.resolve_type_inner(*fields);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
-            Expr => Type::Expr,
+            Quoted(quoted) => Type::Quoted(quoted),
             Unit => Type::Unit,
             Unspecified => Type::Error,
             Error => Type::Error,
@@ -1159,7 +1159,7 @@ impl<'a> Resolver<'a> {
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::Forall(_, _) => (),
 
             Type::TraitAsType(_, _, args) => {
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 503bbbf79be..46e8db8f5ff 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -307,7 +307,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 Type::Function(params, Box::new(lambda.return_type), Box::new(env_type))
             }
-            HirExpression::Quote(_) => Type::Expr,
+            HirExpression::Quote(_) => Type::Quoted(crate::QuotedType::Expr),
             HirExpression::Comptime(block) => self.check_block(block),
 
             // Unquote should be inserted & removed by the comptime interpreter.
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index a90bd931496..ce36a22cf88 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -105,7 +105,7 @@ pub enum Type {
     Constant(u32),
 
     /// The type of quoted code in macros. This is always a comptime-only type
-    Expr,
+    Quoted(QuotedType),
 
     /// The result of some type error. Remembering type errors as their own type variant lets
     /// us avoid issuing repeat type errors for the same item. For example, a lambda with
@@ -147,7 +147,7 @@ impl Type {
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Constant(_)
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::Slice(_)
             | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
         }
@@ -187,6 +187,14 @@ impl Type {
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
+pub enum QuotedType {
+    Expr,
+    TypeDefinition,
+    TopLevelItem,
+    Type,
+}
+
 /// A list of TypeVariableIds to bind to a type. Storing the
 /// TypeVariable in addition to the matching TypeVariableId allows
 /// the binding to later be undone if needed.
@@ -644,7 +652,7 @@ impl Type {
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::Forall(_, _)
-            | Type::Expr => false,
+            | Type::Quoted(_) => false,
 
             Type::TraitAsType(_, _, args) => {
                 args.iter().any(|generic| generic.contains_numeric_typevar(target_id))
@@ -710,7 +718,7 @@ impl Type {
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::Slice(_)
             | Type::TraitAsType(..) => false,
 
@@ -759,7 +767,7 @@ impl Type {
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             // TODO: probably can allow code as it is all compile time
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::TraitAsType(..) => false,
 
             Type::Alias(alias, generics) => {
@@ -922,7 +930,7 @@ impl std::fmt::Display for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element}")
             }
-            Type::Expr => write!(f, "Expr"),
+            Type::Quoted(quoted) => write!(f, "{}", quoted),
         }
     }
 }
@@ -954,6 +962,17 @@ impl std::fmt::Display for TypeBinding {
     }
 }
 
+impl std::fmt::Display for QuotedType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            QuotedType::Expr => write!(f, "Expr"),
+            QuotedType::TypeDefinition => write!(f, "TypeDefinition"),
+            QuotedType::TopLevelItem => write!(f, "TopLevelItem"),
+            QuotedType::Type => write!(f, "Type"),
+        }
+    }
+}
+
 pub struct UnificationError;
 
 impl Type {
@@ -1643,7 +1662,7 @@ impl Type {
             | Type::Bool
             | Type::Constant(_)
             | Type::Error
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::Unit => self.clone(),
         }
     }
@@ -1686,7 +1705,7 @@ impl Type {
             | Type::Bool
             | Type::Constant(_)
             | Type::Error
-            | Type::Expr
+            | Type::Quoted(_)
             | Type::Unit => false,
         }
     }
@@ -1743,7 +1762,9 @@ impl Type {
 
             // Expect that this function should only be called on instantiated types
             Forall(..) => unreachable!(),
-            FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Expr | Error => self.clone(),
+            FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Quoted(_) | Error => {
+                self.clone()
+            }
         }
     }
 
@@ -1878,7 +1899,7 @@ impl From<&Type> for PrintableType {
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
             }
-            Type::Expr => unreachable!(),
+            Type::Quoted(_) => unreachable!(),
         }
     }
 }
@@ -1963,7 +1984,7 @@ impl std::fmt::Debug for Type {
             Type::MutableReference(element) => {
                 write!(f, "&mut {element:?}")
             }
-            Type::Expr => write!(f, "Expr"),
+            Type::Quoted(quoted) => write!(f, "{}", quoted),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index d204191796c..ec589a816f6 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -865,8 +865,11 @@ pub enum Keyword {
     String,
     Struct,
     Super,
+    TopLevelItem,
     Trait,
     Type,
+    TypeType,
+    TypeDefinition,
     Unchecked,
     Unconstrained,
     Use,
@@ -910,8 +913,11 @@ impl fmt::Display for Keyword {
             Keyword::String => write!(f, "str"),
             Keyword::Struct => write!(f, "struct"),
             Keyword::Super => write!(f, "super"),
+            Keyword::TopLevelItem => write!(f, "TopLevelItem"),
             Keyword::Trait => write!(f, "trait"),
             Keyword::Type => write!(f, "type"),
+            Keyword::TypeType => write!(f, "Type"),
+            Keyword::TypeDefinition => write!(f, "TypeDefinition"),
             Keyword::Unchecked => write!(f, "unchecked"),
             Keyword::Unconstrained => write!(f, "unconstrained"),
             Keyword::Use => write!(f, "use"),
@@ -958,8 +964,11 @@ impl Keyword {
             "str" => Keyword::String,
             "struct" => Keyword::Struct,
             "super" => Keyword::Super,
+            "TopLevelItem" => Keyword::TopLevelItem,
             "trait" => Keyword::Trait,
             "type" => Keyword::Type,
+            "Type" => Keyword::TypeType,
+            "TypeDefinition" => Keyword::TypeDefinition,
             "unchecked" => Keyword::Unchecked,
             "unconstrained" => Keyword::Unconstrained,
             "use" => Keyword::Use,
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index c6cc1344aae..821ae7e7c4c 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -1012,7 +1012,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::Forall(_, _) | HirType::Constant(_) | HirType::Error => {
                 unreachable!("Unexpected type {} found", typ)
             }
-            HirType::Expr => unreachable!("Tried to translate Code type into runtime code"),
+            HirType::Quoted(_) => unreachable!("Tried to translate Code type into runtime code"),
         })
     }
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 5fdce80087a..915093df514 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -17,6 +17,7 @@ use crate::hir::comptime;
 use crate::hir::def_collector::dc_crate::CompilationError;
 use crate::hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias};
 use crate::hir::def_map::{LocalModuleId, ModuleId};
+use crate::QuotedType;
 
 use crate::ast::{BinaryOpKind, FunctionDefinition, ItemVisibility};
 use crate::hir::resolution::errors::ResolverError;
@@ -1805,7 +1806,7 @@ enum TypeMethodKey {
     Tuple,
     Function,
     Generic,
-    Code,
+    Quoted(QuotedType),
 }
 
 fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
@@ -1825,7 +1826,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::Tuple(_) => Some(Tuple),
         Type::Function(_, _, _) => Some(Function),
         Type::NamedGeneric(_, _) => Some(Generic),
-        Type::Expr => Some(Code),
+        Type::Quoted(quoted) => Some(Quoted(*quoted)),
         Type::MutableReference(element) => get_type_method_key(element),
         Type::Alias(alias, _) => get_type_method_key(&alias.borrow().typ),
 
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index 40edc9936d1..a961b32f9d7 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -3,6 +3,7 @@ use super::{
     ParserErrorReason, Precedence,
 };
 use crate::ast::{Recoverable, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression};
+use crate::QuotedType;
 
 use crate::parser::labels::ParsingRuleLabel;
 use crate::token::{Keyword, Token};
@@ -23,6 +24,9 @@ pub(super) fn parse_type_inner<'a>(
         bool_type(),
         string_type(),
         expr_type(),
+        type_definition_type(),
+        top_level_item_type(),
+        quoted_type(),
         format_string_type(recursive_type_parser.clone()),
         named_type(recursive_type_parser.clone()),
         named_trait(recursive_type_parser.clone()),
@@ -69,7 +73,29 @@ pub(super) fn bool_type() -> impl NoirParser<UnresolvedType> {
 
 /// This is the type `Expr` - the type of a quoted, untyped expression object used for macros
 pub(super) fn expr_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Expr).map_with_span(|_, span| UnresolvedTypeData::Expr.with_span(span))
+    keyword(Keyword::Expr)
+        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Expr).with_span(span))
+}
+
+/// This is the type `TypeDefinition` - the type of a quoted type definition
+pub(super) fn type_definition_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::TypeDefinition).map_with_span(|_, span| {
+        UnresolvedTypeData::Quoted(QuotedType::TypeDefinition).with_span(span)
+    })
+}
+
+/// This is the type `TopLevelItem` - the type of a quoted statement in the top level.
+/// E.g. a type definition, trait definition, trait impl, function, etc.
+fn top_level_item_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::TopLevelItem).map_with_span(|_, span| {
+        UnresolvedTypeData::Quoted(QuotedType::TopLevelItem).with_span(span)
+    })
+}
+
+/// This is the type `Type` - the type of a quoted noir type.
+fn quoted_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::TypeType)
+        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Type).with_span(span))
 }
 
 pub(super) fn string_type() -> impl NoirParser<UnresolvedType> {
diff --git a/test_programs/compile_failure/type_definition_annotation/Nargo.toml b/test_programs/compile_failure/type_definition_annotation/Nargo.toml
new file mode 100644
index 00000000000..dc90816e16b
--- /dev/null
+++ b/test_programs/compile_failure/type_definition_annotation/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "type_definition_annotation"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/type_definition_annotation/src/main.nr b/test_programs/compile_failure/type_definition_annotation/src/main.nr
new file mode 100644
index 00000000000..91f9c3a52f4
--- /dev/null
+++ b/test_programs/compile_failure/type_definition_annotation/src/main.nr
@@ -0,0 +1,8 @@
+#[fail_assert]
+struct Foo { x: Field }
+
+comptime fn fail_assert(_typ: TypeDefinition) {
+    assert(false);
+}
+
+fn main() {}
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index ec750236806..43c277ba03e 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -61,7 +61,8 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
 /// Certain features are only available in the elaborator.
 /// We skip these tests for non-elaborator code since they are not
 /// expected to work there. This can be removed once the old code is removed.
-const IGNORED_NEW_FEATURE_TESTS: [&str; 2] = ["macros", "wildcard_type"];
+const IGNORED_NEW_FEATURE_TESTS: [&str; 3] =
+    ["macros", "wildcard_type", "type_definition_annotation"];
 
 fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_sub_dir = "execution_success";
@@ -291,7 +292,7 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
         };
         let test_dir = &test_dir.path();
 
-        let comptime_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+        let new_feature_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
             "\n#[ignore]"
         } else {
             ""
@@ -300,7 +301,7 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
         write!(
             test_file,
             r#"
-#[test]{comptime_ignored}
+#[test]{new_feature_ignored}
 fn compile_success_empty_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
     let mut cmd = Command::cargo_bin("nargo").unwrap();
@@ -417,10 +418,16 @@ fn generate_compile_failure_tests(test_file: &mut File, test_data_dir: &Path) {
         };
         let test_dir = &test_dir.path();
 
+        let new_feature_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            "\n#[ignore]"
+        } else {
+            ""
+        };
+
         write!(
             test_file,
             r#"
-#[test]
+#[test]{new_feature_ignored}
 fn compile_failure_legacy_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
index 3ad1d9302be..3eb398346c3 100644
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ b/tooling/nargo_fmt/src/rewrite/typ.rs
@@ -64,7 +64,7 @@ pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType)
         | UnresolvedTypeData::Expression(_)
         | UnresolvedTypeData::String(_)
         | UnresolvedTypeData::FormatString(_, _)
-        | UnresolvedTypeData::Expr
+        | UnresolvedTypeData::Quoted(_)
         | UnresolvedTypeData::TraitAsType(_, _) => visitor.slice(typ.span.unwrap()).into(),
         UnresolvedTypeData::Error => unreachable!(),
     }
diff --git a/tooling/nargo_fmt/tests/expected/impl.nr b/tooling/nargo_fmt/tests/expected/impl.nr
index 1c0d4564b5e..ec734b57970 100644
--- a/tooling/nargo_fmt/tests/expected/impl.nr
+++ b/tooling/nargo_fmt/tests/expected/impl.nr
@@ -1,10 +1,10 @@
-impl Type {}
+impl MyType {}
 
-impl Type<A> {}
+impl MyType<A> {}
 
-impl Type<A, B> {}
+impl MyType<A, B> {}
 
-impl Type {
+impl MyType {
     fn method(self) {}
 
     fn method(mut self) {}
@@ -12,10 +12,10 @@ impl Type {
     fn method(&mut self) {}
 }
 
-impl Type {
+impl MyType {
     fn method(self) {}
 }
 
-impl Type {
+impl MyType {
     fn method(self) {}
 }
diff --git a/tooling/nargo_fmt/tests/input/impl.nr b/tooling/nargo_fmt/tests/input/impl.nr
index 1f111371a43..ea909dfad44 100644
--- a/tooling/nargo_fmt/tests/input/impl.nr
+++ b/tooling/nargo_fmt/tests/input/impl.nr
@@ -1,10 +1,10 @@
-impl Type {}
+impl MyType {}
 
-impl Type<A> {}
+impl MyType<A> {}
 
-impl Type<A, B> {}
+impl MyType<A, B> {}
 
-impl Type {
+impl MyType {
     fn method(self) {}
 
     fn method(mut self) {}
@@ -12,10 +12,10 @@ impl Type {
     fn method(&mut self) {}
 }
 
-impl Type {
+impl MyType {
 fn method(self) {}
 }
 
-impl Type {
+impl MyType {
             fn method(self) {}
-}
\ No newline at end of file
+}

From e1000176a31140b2abd79c47653cbc4bb1a6808a Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 18 Jun 2024 19:52:45 +0100
Subject: [PATCH 391/416] feat: add fuzzer for Noir programs (#5251)

# Description

## Problem\*

Step towards #5249

## Summary\*

This PR adds a very simple fuzzer which can be used to find inputs to
Noir programs which fail to execute. The motivation for this is to
eventually allow `nargo test` to run on noir functions with arguments
and automatically fuzz them in a similar fashion to `forge test`.

It's currently very hit and miss on how quickly it can zero in on
failing cases. For example, the program below is near-unfuzzable
currently.

```rust
fn main(x: u32, y: u32) {
    assert(x != y);
}
```

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    | 14 +++
 Cargo.toml                                    |  2 +
 .../noirc_frontend/src/elaborator/lints.rs    |  9 --
 compiler/noirc_frontend/src/elaborator/mod.rs |  1 -
 .../src/hir/resolution/resolver.rs            | 10 +-
 noir_stdlib/src/uint128.nr                    | 18 +++-
 tooling/fuzzer/Cargo.toml                     | 18 ++++
 tooling/fuzzer/src/lib.rs                     | 93 ++++++++++++++++++
 tooling/fuzzer/src/strategies/int.rs          | 83 ++++++++++++++++
 tooling/fuzzer/src/strategies/mod.rs          | 97 +++++++++++++++++++
 tooling/fuzzer/src/strategies/uint.rs         | 68 +++++++++++++
 tooling/fuzzer/src/types.rs                   | 42 ++++++++
 tooling/nargo_cli/Cargo.toml                  |  2 +
 tooling/nargo_cli/src/cli/test_cmd.rs         | 52 ++++++++--
 tooling/nargo_cli/tests/stdlib-tests.rs       | 57 +++++++++--
 tooling/noirc_abi/Cargo.toml                  |  3 +-
 16 files changed, 524 insertions(+), 45 deletions(-)
 create mode 100644 tooling/fuzzer/Cargo.toml
 create mode 100644 tooling/fuzzer/src/lib.rs
 create mode 100644 tooling/fuzzer/src/strategies/int.rs
 create mode 100644 tooling/fuzzer/src/strategies/mod.rs
 create mode 100644 tooling/fuzzer/src/strategies/uint.rs
 create mode 100644 tooling/fuzzer/src/types.rs

diff --git a/Cargo.lock b/Cargo.lock
index 16988432243..cacfc06327d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2517,6 +2517,7 @@ dependencies = [
  "nargo_fmt",
  "nargo_toml",
  "noir_debugger",
+ "noir_fuzzer",
  "noir_lsp",
  "noirc_abi",
  "noirc_artifacts",
@@ -2529,6 +2530,7 @@ dependencies = [
  "pprof 0.13.0",
  "predicates 2.1.5",
  "prettytable-rs",
+ "proptest",
  "rayon",
  "serde",
  "serde_json",
@@ -2661,6 +2663,18 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "noir_fuzzer"
+version = "0.31.0"
+dependencies = [
+ "acvm",
+ "nargo",
+ "noirc_abi",
+ "noirc_artifacts",
+ "proptest",
+ "rand 0.8.5",
+]
+
 [[package]]
 name = "noir_grumpkin"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index 5fc9936de91..129661d157d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ members = [
     # Crates related to tooling built on top of the Noir compiler
     "tooling/lsp",
     "tooling/debugger",
+    "tooling/fuzzer",
     "tooling/nargo",
     "tooling/nargo_fmt",
     "tooling/nargo_cli",
@@ -69,6 +70,7 @@ noirc_frontend = { path = "compiler/noirc_frontend" }
 noirc_printable_type = { path = "compiler/noirc_printable_type" }
 
 # Noir tooling workspace dependencies
+noir_fuzzer = { path = "tooling/fuzzer" }
 nargo = { path = "tooling/nargo" }
 nargo_fmt = { path = "tooling/nargo_fmt" }
 nargo_toml = { path = "tooling/nargo_toml" }
diff --git a/compiler/noirc_frontend/src/elaborator/lints.rs b/compiler/noirc_frontend/src/elaborator/lints.rs
index 4859ac5f97c..b86912940eb 100644
--- a/compiler/noirc_frontend/src/elaborator/lints.rs
+++ b/compiler/noirc_frontend/src/elaborator/lints.rs
@@ -130,15 +130,6 @@ pub(super) fn recursive_non_entrypoint_function(
     }
 }
 
-/// Test functions cannot have arguments in order to be executable.
-pub(super) fn test_function_with_args(func: &NoirFunction) -> Option<ResolverError> {
-    if func.attributes().is_test_function() && !func.parameters().is_empty() {
-        Some(ResolverError::TestFunctionHasParameters { span: func.name_ident().span() })
-    } else {
-        None
-    }
-}
-
 /// Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime.
 pub(super) fn unconstrained_function_args(
     function_args: &[(Type, ExprId, Span)],
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 053de6e1735..91d6ba71927 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -581,7 +581,6 @@ impl<'context> Elaborator<'context> {
         self.run_lint(|elaborator| {
             lints::low_level_function_outside_stdlib(func, elaborator.crate_id).map(Into::into)
         });
-        self.run_lint(|_| lints::test_function_with_args(func).map(Into::into));
         self.run_lint(|_| {
             lints::recursive_non_entrypoint_function(func, is_entry_point).map(Into::into)
         });
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 1dcace82372..97de66be817 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -23,7 +23,7 @@ use crate::hir_def::expr::{
 use crate::hir_def::function::FunctionBody;
 use crate::hir_def::traits::{Trait, TraitConstraint};
 use crate::macros_api::SecondaryAttribute;
-use crate::token::{Attributes, FunctionAttribute};
+use crate::token::Attributes;
 use regex::Regex;
 use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::rc::Rc;
@@ -1043,14 +1043,6 @@ impl<'a> Resolver<'a> {
             });
         }
 
-        if matches!(attributes.function, Some(FunctionAttribute::Test { .. }))
-            && !parameters.is_empty()
-        {
-            self.push_err(ResolverError::TestFunctionHasParameters {
-                span: func.name_ident().span(),
-            });
-        }
-
         let mut typ = Type::Function(parameter_types, return_type, Box::new(Type::Unit));
 
         if !generics.is_empty() {
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index 173fa54863a..829ab09ee1e 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -319,13 +319,12 @@ mod tests {
     use crate::uint128::{U128, pow64, pow63};
 
     #[test]
-    fn test_not() {
-        let num = U128::from_u64s_le(0, 0);
+    fn test_not(lo: u64, hi: u64) {
+        let num = U128::from_u64s_le(lo, hi);
         let not_num = num.not();
 
-        let max_u64: Field = pow64 - 1;
-        assert_eq(not_num.hi, max_u64);
-        assert_eq(not_num.lo, max_u64);
+        assert_eq(not_num.hi, (hi.not() as Field));
+        assert_eq(not_num.lo, (lo.not() as Field));
 
         let not_not_num = not_num.not();
         assert_eq(num, not_not_num);
@@ -493,6 +492,15 @@ mod tests {
         let end = a.to_integer();
         assert_eq(start, end);
     }
+
+    #[test]
+    fn integer_conversions_fuzz(lo: u64, hi: u64) {
+        let start: Field = (lo as Field) + pow64 * (hi as Field);
+        let a = U128::from_integer(start);
+        let end = a.to_integer();
+        assert_eq(start, end);
+    }
+
     #[test]
     fn test_wrapping_mul() {
         // 1*0==0
diff --git a/tooling/fuzzer/Cargo.toml b/tooling/fuzzer/Cargo.toml
new file mode 100644
index 00000000000..ef49d707d6a
--- /dev/null
+++ b/tooling/fuzzer/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "noir_fuzzer"
+description = "A fuzzer for Noir programs"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+acvm.workspace = true
+nargo.workspace = true
+noirc_artifacts.workspace = true
+noirc_abi.workspace = true
+proptest.workspace = true
+rand.workspace = true
diff --git a/tooling/fuzzer/src/lib.rs b/tooling/fuzzer/src/lib.rs
new file mode 100644
index 00000000000..42dccc1dc83
--- /dev/null
+++ b/tooling/fuzzer/src/lib.rs
@@ -0,0 +1,93 @@
+//! This module has been adapted from Foundry's fuzzing implementation for the EVM.
+//! https://github.com/foundry-rs/foundry/blob/6a85dbaa62f1c305f31cab37781232913055ae28/crates/evm/evm/src/executors/fuzz/mod.rs#L40
+//!
+//! Code is used under the MIT license.
+
+use acvm::{blackbox_solver::StubbedBlackBoxSolver, FieldElement};
+use noirc_abi::InputMap;
+use proptest::test_runner::{TestCaseError, TestError, TestRunner};
+
+mod strategies;
+mod types;
+
+use types::{CaseOutcome, CounterExampleOutcome, FuzzOutcome, FuzzTestResult};
+
+use noirc_artifacts::program::ProgramArtifact;
+
+use nargo::ops::{execute_program, DefaultForeignCallExecutor};
+
+/// An executor for Noir programs which which provides fuzzing support using [`proptest`].
+///
+/// After instantiation, calling `fuzz` will proceed to hammer the program with
+/// inputs, until it finds a counterexample. The provided [`TestRunner`] contains all the
+/// configuration which can be overridden via [environment variables](proptest::test_runner::Config)
+pub struct FuzzedExecutor {
+    /// The program to be fuzzed
+    program: ProgramArtifact,
+
+    /// The fuzzer
+    runner: TestRunner,
+}
+
+impl FuzzedExecutor {
+    /// Instantiates a fuzzed executor given a testrunner
+    pub fn new(program: ProgramArtifact, runner: TestRunner) -> Self {
+        Self { program, runner }
+    }
+
+    /// Fuzzes the provided program.
+    pub fn fuzz(&self) -> FuzzTestResult {
+        let strategy = strategies::arb_input_map(&self.program.abi);
+
+        let run_result: Result<(), TestError<InputMap>> =
+            self.runner.clone().run(&strategy, |input_map| {
+                let fuzz_res = self.single_fuzz(input_map)?;
+
+                match fuzz_res {
+                    FuzzOutcome::Case(_) => Ok(()),
+                    FuzzOutcome::CounterExample(CounterExampleOutcome {
+                        exit_reason: status,
+                        ..
+                    }) => Err(TestCaseError::fail(status)),
+                }
+            });
+
+        match run_result {
+            Ok(()) => FuzzTestResult { success: true, reason: None, counterexample: None },
+
+            Err(TestError::Abort(reason)) => FuzzTestResult {
+                success: false,
+                reason: Some(reason.to_string()),
+                counterexample: None,
+            },
+            Err(TestError::Fail(reason, counterexample)) => {
+                let reason = reason.to_string();
+                let reason = if reason.is_empty() { None } else { Some(reason) };
+
+                FuzzTestResult { success: false, reason, counterexample: Some(counterexample) }
+            }
+        }
+    }
+
+    /// Granular and single-step function that runs only one fuzz and returns either a `CaseOutcome`
+    /// or a `CounterExampleOutcome`
+    pub fn single_fuzz(&self, input_map: InputMap) -> Result<FuzzOutcome, TestCaseError> {
+        let initial_witness = self.program.abi.encode(&input_map, None).unwrap();
+        let result = execute_program(
+            &self.program.bytecode,
+            initial_witness,
+            &StubbedBlackBoxSolver,
+            &mut DefaultForeignCallExecutor::<FieldElement>::new(false, None),
+        );
+
+        // TODO: Add handling for `vm.assume` equivalent
+
+        match result {
+            Ok(_) => Ok(FuzzOutcome::Case(CaseOutcome { case: input_map })),
+            Err(err) => Ok(FuzzOutcome::CounterExample(CounterExampleOutcome {
+                exit_reason: err.to_string(),
+                counterexample: input_map,
+            })),
+        }
+    }
+}
diff --git a/tooling/fuzzer/src/strategies/int.rs b/tooling/fuzzer/src/strategies/int.rs
new file mode 100644
index 00000000000..d11cafcfae5
--- /dev/null
+++ b/tooling/fuzzer/src/strategies/int.rs
@@ -0,0 +1,83 @@
+use proptest::{
+    strategy::{NewTree, Strategy},
+    test_runner::TestRunner,
+};
+use rand::Rng;
+
+/// Strategy for signed ints (up to i128).
+/// The strategy combines 2 different strategies, each assigned a specific weight:
+/// 1. Generate purely random value in a range. This will first choose bit size uniformly (up `bits`
+///    param). Then generate a value for this bit size.
+/// 2. Generate a random value around the edges (+/- 3 around min, 0 and max possible value)
+#[derive(Debug)]
+pub struct IntStrategy {
+    /// Bit size of int (e.g. 128)
+    bits: usize,
+    /// The weight for edge cases (+/- 3 around 0 and max possible value)
+    edge_weight: usize,
+    /// The weight for purely random values
+    random_weight: usize,
+}
+
+impl IntStrategy {
+    /// Create a new strategy.
+    /// # Arguments
+    /// * `bits` - Size of int in bits
+    pub fn new(bits: usize) -> Self {
+        Self { bits, edge_weight: 10usize, random_weight: 50usize }
+    }
+
+    fn generate_edge_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        let rng = runner.rng();
+
+        let offset = rng.gen_range(0..4);
+        // Choose if we want values around min, -0, +0, or max
+        let kind = rng.gen_range(0..4);
+        let start = match kind {
+            0 => self.type_min() + offset,
+            1 => -offset - 1i128,
+            2 => offset,
+            3 => self.type_max() - offset,
+            _ => unreachable!(),
+        };
+        Ok(proptest::num::i128::BinarySearch::new(start))
+    }
+
+    fn generate_random_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        let rng = runner.rng();
+
+        let start: i128 = rng.gen_range(self.type_min()..=self.type_max());
+        Ok(proptest::num::i128::BinarySearch::new(start))
+    }
+
+    fn type_max(&self) -> i128 {
+        if self.bits < 128 {
+            (1i128 << (self.bits - 1)) - 1
+        } else {
+            i128::MAX
+        }
+    }
+
+    fn type_min(&self) -> i128 {
+        if self.bits < 128 {
+            -(1i128 << (self.bits - 1))
+        } else {
+            i128::MIN
+        }
+    }
+}
+
+impl Strategy for IntStrategy {
+    type Tree = proptest::num::i128::BinarySearch;
+    type Value = i128;
+
+    fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        let total_weight = self.random_weight + self.edge_weight;
+        let bias = runner.rng().gen_range(0..total_weight);
+        // randomly select one of 2 strategies
+        match bias {
+            x if x < self.edge_weight => self.generate_edge_tree(runner),
+            _ => self.generate_random_tree(runner),
+        }
+    }
+}
diff --git a/tooling/fuzzer/src/strategies/mod.rs b/tooling/fuzzer/src/strategies/mod.rs
new file mode 100644
index 00000000000..f5b03953ba8
--- /dev/null
+++ b/tooling/fuzzer/src/strategies/mod.rs
@@ -0,0 +1,97 @@
+use int::IntStrategy;
+use prop::collection::vec;
+use proptest::prelude::*;
+
+use acvm::{AcirField, FieldElement};
+
+use noirc_abi::{input_parser::InputValue, Abi, AbiType, InputMap, Sign};
+use std::collections::BTreeMap;
+use uint::UintStrategy;
+
+mod int;
+mod uint;
+
+proptest::prop_compose! {
+    pub(super) fn arb_field_from_integer(bit_size: u32)(value: u128)-> FieldElement {
+        let width = (bit_size % 128).clamp(1, 127);
+        let max_value = 2u128.pow(width) - 1;
+        let value = value % max_value;
+        FieldElement::from(value)
+    }
+}
+
+pub(super) fn arb_value_from_abi_type(abi_type: &AbiType) -> SBoxedStrategy<InputValue> {
+    match abi_type {
+        AbiType::Field => vec(any::<u8>(), 32)
+            .prop_map(|bytes| InputValue::Field(FieldElement::from_be_bytes_reduce(&bytes)))
+            .sboxed(),
+        AbiType::Integer { width, sign } if sign == &Sign::Unsigned => {
+            UintStrategy::new(*width as usize)
+                .prop_map(|uint| InputValue::Field(uint.into()))
+                .sboxed()
+        }
+        AbiType::Integer { width, .. } => {
+            let shift = 2i128.pow(*width);
+            IntStrategy::new(*width as usize)
+                .prop_map(move |mut int| {
+                    if int < 0 {
+                        int += shift
+                    }
+                    InputValue::Field(int.into())
+                })
+                .sboxed()
+        }
+        AbiType::Boolean => {
+            any::<bool>().prop_map(|val| InputValue::Field(FieldElement::from(val))).sboxed()
+        }
+
+        AbiType::String { length } => {
+            // Strings only allow ASCII characters as each character must be able to be represented by a single byte.
+            let string_regex = format!("[[:ascii:]]{{{length}}}");
+            proptest::string::string_regex(&string_regex)
+                .expect("parsing of regex should always succeed")
+                .prop_map(InputValue::String)
+                .sboxed()
+        }
+        AbiType::Array { length, typ } => {
+            let length = *length as usize;
+            let elements = vec(arb_value_from_abi_type(typ), length..=length);
+
+            elements.prop_map(InputValue::Vec).sboxed()
+        }
+
+        AbiType::Struct { fields, .. } => {
+            let fields: Vec<SBoxedStrategy<(String, InputValue)>> = fields
+                .iter()
+                .map(|(name, typ)| (Just(name.clone()), arb_value_from_abi_type(typ)).sboxed())
+                .collect();
+
+            fields
+                .prop_map(|fields| {
+                    let fields: BTreeMap<_, _> = fields.into_iter().collect();
+                    InputValue::Struct(fields)
+                })
+                .sboxed()
+        }
+
+        AbiType::Tuple { fields } => {
+            let fields: Vec<_> = fields.iter().map(arb_value_from_abi_type).collect();
+            fields.prop_map(InputValue::Vec).sboxed()
+        }
+    }
+}
+
+pub(super) fn arb_input_map(abi: &Abi) -> BoxedStrategy<InputMap> {
+    let values: Vec<_> = abi
+        .parameters
+        .iter()
+        .map(|param| (Just(param.name.clone()), arb_value_from_abi_type(&param.typ)))
+        .collect();
+
+    values
+        .prop_map(|values| {
+            let input_map: InputMap = values.into_iter().collect();
+            input_map
+        })
+        .boxed()
+}
diff --git a/tooling/fuzzer/src/strategies/uint.rs b/tooling/fuzzer/src/strategies/uint.rs
new file mode 100644
index 00000000000..5021e832b97
--- /dev/null
+++ b/tooling/fuzzer/src/strategies/uint.rs
@@ -0,0 +1,68 @@
+use proptest::{
+    strategy::{NewTree, Strategy},
+    test_runner::TestRunner,
+};
+use rand::Rng;
+
+/// Value tree for unsigned ints (up to u128).
+/// The strategy combines 2 different strategies, each assigned a specific weight:
+/// 1. Generate purely random value in a range. This will first choose bit size uniformly (up `bits`
+///    param). Then generate a value for this bit size.
+/// 2. Generate a random value around the edges (+/- 3 around 0 and max possible value)
+#[derive(Debug)]
+pub struct UintStrategy {
+    /// Bit size of uint (e.g. 128)
+    bits: usize,
+
+    /// The weight for edge cases (+/- 3 around 0 and max possible value)
+    edge_weight: usize,
+    /// The weight for purely random values
+    random_weight: usize,
+}
+
+impl UintStrategy {
+    /// Create a new strategy.
+    /// # Arguments
+    /// * `bits` - Size of uint in bits
+    pub fn new(bits: usize) -> Self {
+        Self { bits, edge_weight: 10usize, random_weight: 50usize }
+    }
+
+    fn generate_edge_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        let rng = runner.rng();
+        // Choose if we want values around 0 or max
+        let is_min = rng.gen_bool(0.5);
+        let offset = rng.gen_range(0..4);
+        let start = if is_min { offset } else { self.type_max().saturating_sub(offset) };
+        Ok(proptest::num::u128::BinarySearch::new(start))
+    }
+
+    fn generate_random_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        let rng = runner.rng();
+        let start = rng.gen_range(0..=self.type_max());
+
+        Ok(proptest::num::u128::BinarySearch::new(start))
+    }
+
+    fn type_max(&self) -> u128 {
+        if self.bits < 128 {
+            (1 << self.bits) - 1
+        } else {
+            u128::MAX
+        }
+    }
+}
+
+impl Strategy for UintStrategy {
+    type Tree = proptest::num::u128::BinarySearch;
+    type Value = u128;
+    fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        let total_weight = self.random_weight + self.edge_weight;
+        let bias = runner.rng().gen_range(0..total_weight);
+        // randomly select one of 2 strategies
+        match bias {
+            x if x < self.edge_weight => self.generate_edge_tree(runner),
+            _ => self.generate_random_tree(runner),
+        }
+    }
+}
diff --git a/tooling/fuzzer/src/types.rs b/tooling/fuzzer/src/types.rs
new file mode 100644
index 00000000000..dbd4ba94ec1
--- /dev/null
+++ b/tooling/fuzzer/src/types.rs
@@ -0,0 +1,42 @@
+use noirc_abi::InputMap;
+
+type CounterExample = InputMap;
+
+/// The outcome of a fuzz test
+#[derive(Debug)]
+pub struct FuzzTestResult {
+    /// Whether the test case was successful. This means that the program executed
+    /// properly, or that there was a constraint failure and that the test was expected to fail
+    /// (has the `should_fail` attribute)
+    pub success: bool,
+
+    /// If there was a constraint failure, this field will be populated. Note that the test can
+    /// still be successful (i.e self.success == true) when it's expected to fail.
+    pub reason: Option<String>,
+
+    /// Minimal reproduction test case for failing fuzz tests
+    pub counterexample: Option<CounterExample>,
+}
+
+/// Returned by a single fuzz in the case of a successful run
+#[derive(Debug)]
+pub struct CaseOutcome {
+    /// Data of a single fuzz test case
+    pub case: InputMap,
+}
+
+/// Returned by a single fuzz when a counterexample has been discovered
+#[derive(Debug)]
+pub struct CounterExampleOutcome {
+    /// Minimal reproduction test case for failing test
+    pub counterexample: CounterExample,
+    /// The status of the call
+    pub exit_reason: String,
+}
+
+/// Outcome of a single fuzz
+#[derive(Debug)]
+pub enum FuzzOutcome {
+    Case(CaseOutcome),
+    CounterExample(CounterExampleOutcome),
+}
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index c3beafb7db5..b9d7d7e3e48 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -32,6 +32,7 @@ noirc_driver.workspace = true
 noirc_frontend = { workspace = true, features = ["bn254"] }
 noirc_abi.workspace = true
 noirc_errors.workspace = true
+noir_fuzzer.workspace = true
 noirc_artifacts.workspace = true
 acvm = { workspace = true, features = ["bn254"] }
 bn254_blackbox_solver.workspace = true
@@ -50,6 +51,7 @@ color-eyre = "0.6.2"
 tokio = { version = "1.0", features = ["io-std", "rt"] }
 dap.workspace = true
 clap-markdown = { git = "https://github.com/noir-lang/clap-markdown", rev = "450d759532c88f0dba70891ceecdbc9ff8f25d2b", optional = true }
+proptest.workspace = true
 
 notify = "6.1.1"
 notify-debouncer-full = "0.3.1"
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 1cda8d8382e..de9e8dc5d7c 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -10,7 +10,8 @@ use nargo::{
 };
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{
-    check_crate, file_manager_with_stdlib, CompileOptions, NOIR_ARTIFACT_VERSION_STRING,
+    check_crate, compile_no_check, file_manager_with_stdlib, CompileOptions,
+    NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_frontend::{
     graph::CrateName,
@@ -185,14 +186,47 @@ fn run_test<S: BlackBoxFunctionSolver<FieldElement> + Default>(
 
     let blackbox_solver = S::default();
 
-    nargo::ops::run_test(
-        &blackbox_solver,
-        &mut context,
-        test_function,
-        show_output,
-        foreign_call_resolver_url,
-        compile_options,
-    )
+    let test_function_has_no_arguments = context
+        .def_interner
+        .function_meta(&test_function.get_id())
+        .function_signature()
+        .0
+        .is_empty();
+
+    if test_function_has_no_arguments {
+        nargo::ops::run_test(
+            &blackbox_solver,
+            &mut context,
+            test_function,
+            show_output,
+            foreign_call_resolver_url,
+            compile_options,
+        )
+    } else {
+        use noir_fuzzer::FuzzedExecutor;
+        use proptest::test_runner::TestRunner;
+
+        let compiled_program =
+            compile_no_check(&mut context, compile_options, test_function.get_id(), None, false);
+        match compiled_program {
+            Ok(compiled_program) => {
+                let runner = TestRunner::default();
+
+                let fuzzer = FuzzedExecutor::new(compiled_program.into(), runner);
+
+                let result = fuzzer.fuzz();
+                if result.success {
+                    TestStatus::Pass
+                } else {
+                    TestStatus::Fail {
+                        message: result.reason.unwrap_or_default(),
+                        error_diagnostic: None,
+                    }
+                }
+            }
+            Err(err) => TestStatus::CompileError(err.into()),
+        }
+    }
 }
 
 fn get_tests_in_package(
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 70857b4b65e..5badd76605a 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -3,7 +3,7 @@ use std::{collections::BTreeMap, path::PathBuf};
 
 use acvm::blackbox_solver::StubbedBlackBoxSolver;
 use fm::FileManager;
-use noirc_driver::{check_crate, file_manager_with_stdlib, CompileOptions};
+use noirc_driver::{check_crate, compile_no_check, file_manager_with_stdlib, CompileOptions};
 use noirc_frontend::hir::FunctionNameMatch;
 
 use nargo::{
@@ -47,15 +47,52 @@ fn run_stdlib_tests() {
     let test_report: Vec<(String, TestStatus)> = test_functions
         .into_iter()
         .map(|(test_name, test_function)| {
-            let status = run_test(
-                &StubbedBlackBoxSolver,
-                &mut context,
-                &test_function,
-                false,
-                None,
-                &CompileOptions::default(),
-            );
-
+            let test_function_has_no_arguments = context
+                .def_interner
+                .function_meta(&test_function.get_id())
+                .function_signature()
+                .0
+                .is_empty();
+
+            let status = if test_function_has_no_arguments {
+                run_test(
+                    &StubbedBlackBoxSolver,
+                    &mut context,
+                    &test_function,
+                    false,
+                    None,
+                    &CompileOptions::default(),
+                )
+            } else {
+                use noir_fuzzer::FuzzedExecutor;
+                use proptest::test_runner::TestRunner;
+
+                let compiled_program = compile_no_check(
+                    &mut context,
+                    &CompileOptions::default(),
+                    test_function.get_id(),
+                    None,
+                    false,
+                );
+                match compiled_program {
+                    Ok(compiled_program) => {
+                        let runner = TestRunner::default();
+
+                        let fuzzer = FuzzedExecutor::new(compiled_program.into(), runner);
+
+                        let result = fuzzer.fuzz();
+                        if result.success {
+                            TestStatus::Pass
+                        } else {
+                            TestStatus::Fail {
+                                message: result.reason.unwrap_or_default(),
+                                error_diagnostic: None,
+                            }
+                        }
+                    }
+                    Err(err) => TestStatus::CompileError(err.into()),
+                }
+            };
             (test_name, status)
         })
         .collect();
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index e8f57060367..4c0c1f75e42 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -25,7 +25,6 @@ strum_macros = "0.24"
 proptest.workspace = true
 proptest-derive.workspace = true
 
-
 [features]
 bn254 = ["acvm/bn254"]
-bls12_381 = ["acvm/bls12_381"]
\ No newline at end of file
+bls12_381 = ["acvm/bls12_381"]

From 3ef36458fef36b2a2f6cf99b35a43339f3721b27 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 19 Jun 2024 13:29:38 +0200
Subject: [PATCH 392/416] fix: avoid duplicating constant arrays (#5287)

# Description

## Problem\*

Resolves #5286

## Summary\*
Keep track of constant arrays and the array they resolve to in mem2reg,
so that another constant array is not created for the same array.


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/ir/function_inserter.rs            | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs b/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs
index 68ece87c7c7..a063a7ff268 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs
@@ -16,11 +16,12 @@ pub(crate) struct FunctionInserter<'f> {
     pub(crate) function: &'f mut Function,
 
     values: HashMap<ValueId, ValueId>,
+    const_arrays: HashMap<im::Vector<ValueId>, ValueId>,
 }
 
 impl<'f> FunctionInserter<'f> {
     pub(crate) fn new(function: &'f mut Function) -> FunctionInserter<'f> {
-        Self { function, values: HashMap::default() }
+        Self { function, values: HashMap::default(), const_arrays: HashMap::default() }
     }
 
     /// Resolves a ValueId to its new, updated value.
@@ -34,10 +35,17 @@ impl<'f> FunctionInserter<'f> {
                 super::value::Value::Array { array, typ } => {
                     let array = array.clone();
                     let typ = typ.clone();
-                    let new_array = array.iter().map(|id| self.resolve(*id)).collect();
-                    let new_id = self.function.dfg.make_array(new_array, typ);
-                    self.values.insert(value, new_id);
-                    new_id
+                    let new_array: im::Vector<ValueId> =
+                        array.iter().map(|id| self.resolve(*id)).collect();
+                    if self.const_arrays.get(&new_array) == Some(&value) {
+                        value
+                    } else {
+                        let new_array_clone = new_array.clone();
+                        let new_id = self.function.dfg.make_array(new_array, typ);
+                        self.values.insert(value, new_id);
+                        self.const_arrays.insert(new_array_clone, new_id);
+                        new_id
+                    }
                 }
                 _ => value,
             },

From 19884f161dfc7d7ce75dd2c404b8ef39cdad2240 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 19 Jun 2024 16:41:43 +0100
Subject: [PATCH 393/416] fix: avoid unnecessarily splitting expressions with
 multiplication terms with a shared term (#5291)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR addresses an issue where we were unnecessarily splitting an
expression based on an example which Zac found while working on
`noir-edwards`. We were being overly restrictive and only accepting the
case where both witnesses in the multiplication are shared with other
terms

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../acvm/src/compiler/transformers/csat.rs    | 38 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/acvm-repo/acvm/src/compiler/transformers/csat.rs b/acvm-repo/acvm/src/compiler/transformers/csat.rs
index f2a3cc2c84e..19cc18ca7f3 100644
--- a/acvm-repo/acvm/src/compiler/transformers/csat.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/csat.rs
@@ -432,7 +432,7 @@ fn fits_in_one_identity<F: AcirField>(expr: &Expression<F>, width: usize) -> boo
         return true;
     }
 
-    // We now know that we have a single mul term. We also know that the mul term must match up with two other terms
+    // We now know that we have a single mul term. We also know that the mul term must match up with at least one of the other terms
     // A polynomial whose mul terms are non zero which do not match up with two terms in the fan-in cannot fit into one opcode
     // An example of this is: Axy + Bx + Cy + ...
     // Notice how the bivariate monomial xy has two univariate monomials with their respective coefficients
@@ -461,7 +461,25 @@ fn fits_in_one_identity<F: AcirField>(expr: &Expression<F>, width: usize) -> boo
         }
     }
 
-    found_x & found_y
+    // If the multiplication is a squaring then we must assign the two witnesses to separate wires and so we
+    // can never get a zero contribution to the width.
+    let multiplication_is_squaring = mul_term.1 == mul_term.2;
+
+    let mul_term_width_contribution = if !multiplication_is_squaring && (found_x & found_y) {
+        // Both witnesses involved in the multiplication exist elsewhere in the expression.
+        // They both do not contribute to the width of the expression as this would be double-counting
+        // due to their appearance in the linear terms.
+        0
+    } else if found_x || found_y {
+        // One of the witnesses involved in the multiplication exists elsewhere in the expression.
+        // The multiplication then only contributes 1 new witness to the width.
+        1
+    } else {
+        // Worst case scenario, the multiplication is using completely unique witnesses so has a contribution of 2.
+        2
+    };
+
+    mul_term_width_contribution + expr.linear_combinations.len() <= width
 }
 
 #[cfg(test)]
@@ -573,4 +591,20 @@ mod tests {
         let contains_b = got_optimized_opcode_a.linear_combinations.iter().any(|(_, w)| *w == b);
         assert!(contains_b);
     }
+
+    #[test]
+    fn recognize_expr_with_single_shared_witness_which_fits_in_single_identity() {
+        // Regression test for an expression which Zac found which should have been preserved but
+        // was being split into two expressions.
+        let expr = Expression {
+            mul_terms: vec![(-FieldElement::from(555u128), Witness(8), Witness(10))],
+            linear_combinations: vec![
+                (FieldElement::one(), Witness(10)),
+                (FieldElement::one(), Witness(11)),
+                (-FieldElement::one(), Witness(13)),
+            ],
+            q_c: FieldElement::zero(),
+        };
+        assert!(fits_in_one_identity(&expr, 4));
+    }
 }

From 0ea608f10bdeb26df7dfc17b1a0bad5db1967be8 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 19 Jun 2024 10:48:40 -0500
Subject: [PATCH 394/416] fix: Don't lazily elaborate functions (#5282)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5271

## Summary\*

Lazily elaborating functions wasn't correct since the FuncMeta object
never stored the LocalModuleId carried by the set of unresolved
functions. This lead to lazily elaborated functions be elaborated in a
different module than intended.

## Additional Context

Lazily elaborated functions seem to no longer be necessary to run our
tests, nor to run the tests in aztec-nr so I've just removed them rather
than adding the additional fields to FuncMeta.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/patterns.rs | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index e337726b579..4d07009e064 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -11,11 +11,10 @@ use crate::{
     },
     hir_def::{
         expr::{HirIdent, ImplKind},
-        function::FunctionBody,
         stmt::HirPattern,
     },
     macros_api::{HirExpression, Ident, Path, Pattern},
-    node_interner::{DefinitionId, DefinitionKind, DependencyId, ExprId, GlobalId, TraitImplKind},
+    node_interner::{DefinitionId, DefinitionKind, ExprId, GlobalId, TraitImplKind},
     Shared, StructType, Type, TypeBindings,
 };
 
@@ -415,16 +414,6 @@ impl<'context> Elaborator<'context> {
                 match self.interner.definition(hir_ident.id).kind {
                     DefinitionKind::Function(id) => {
                         if let Some(current_item) = self.current_item {
-                            // Lazily evaluate functions found within globals if necessary.
-                            // Otherwise if we later attempt to evaluate the global it will
-                            // see an empty function body.
-                            if matches!(current_item, DependencyId::Global(_)) {
-                                let meta = self.interner.function_meta(&id);
-
-                                if matches!(&meta.function_body, FunctionBody::Unresolved(..)) {
-                                    self.elaborate_function(id);
-                                }
-                            }
                             self.interner.add_function_dependency(current_item, id);
                         }
                     }

From d2ea8a9a994417b82fefb5ef89eef466737d039b Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 19 Jun 2024 18:12:06 +0200
Subject: [PATCH 395/416] chore: pedersen hash in Noir (#5217)

# Description

## Problem\*

Related to  #4931

## Summary\*
Noir implementation for Pedersen Hash.


## Additional Context
I added a derive_generators() built-in function, which only works for
bn254, and then use pedersen commitments and scalar mul.


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 Cargo.lock                                    |  1 +
 .../src/generator/generators.rs               |  2 +-
 acvm-repo/bn254_blackbox_solver/src/lib.rs    | 13 +++--
 compiler/noirc_evaluator/Cargo.toml           |  1 +
 .../noirc_evaluator/src/ssa/ir/instruction.rs |  6 ++-
 .../src/ssa/ir/instruction/call.rs            | 52 +++++++++++++++++++
 .../src/ssa/opt/remove_enable_side_effects.rs |  3 +-
 .../src/ssa/opt/remove_if_else.rs             |  3 +-
 noir_stdlib/src/hash.nr                       | 30 +++++++++--
 9 files changed, 98 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cacfc06327d..eb058008359 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2836,6 +2836,7 @@ name = "noirc_evaluator"
 version = "0.31.0"
 dependencies = [
  "acvm",
+ "bn254_blackbox_solver",
  "chrono",
  "fxhash",
  "im",
diff --git a/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs b/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs
index f89d582d167..bb51426b33b 100644
--- a/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/generator/generators.rs
@@ -38,7 +38,7 @@ fn default_generators() -> &'static [Affine<GrumpkinParameters>; NUM_DEFAULT_GEN
 /// index-addressable generators.
 ///
 /// [hash_to_curve]: super::hash_to_curve::hash_to_curve
-pub(crate) fn derive_generators(
+pub fn derive_generators(
     domain_separator_bytes: &[u8],
     num_generators: u32,
     starting_index: u32,
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 08e0fb66a6d..6897116e90e 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -12,6 +12,7 @@ mod schnorr;
 
 use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
+pub use generator::generators::derive_generators;
 pub use poseidon2::poseidon2_permutation;
 
 // Temporary hack, this ensure that we always use a bn254 field here
@@ -47,11 +48,13 @@ impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
         let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
         let result = pedersen::commitment::commit_native_with_index(&inputs, domain_separator);
-        let res_x =
-            FieldElement::from_repr(*result.x().expect("should not commit to point at infinity"));
-        let res_y =
-            FieldElement::from_repr(*result.y().expect("should not commit to point at infinity"));
-        Ok((res_x, res_y))
+        let result = if let Some((x, y)) = result.xy() {
+            (FieldElement::from_repr(*x), FieldElement::from_repr(*y))
+        } else {
+            (FieldElement::from(0_u128), FieldElement::from(0_u128))
+        };
+
+        Ok(result)
     }
 
     fn pedersen_hash(
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index aa30eef9156..72a52b43741 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -12,6 +12,7 @@ license.workspace = true
 noirc_frontend.workspace = true
 noirc_errors.workspace = true
 acvm.workspace = true
+bn254_blackbox_solver.workspace = true
 fxhash.workspace = true
 iter-extended.workspace = true
 thiserror.workspace = true
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index e21deb9ef79..8f881b86e47 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -67,6 +67,7 @@ pub(crate) enum Intrinsic {
     AsField,
     AsWitness,
     IsUnconstrained,
+    DerivePedersenGenerators,
 }
 
 impl std::fmt::Display for Intrinsic {
@@ -92,6 +93,7 @@ impl std::fmt::Display for Intrinsic {
             Intrinsic::AsField => write!(f, "as_field"),
             Intrinsic::AsWitness => write!(f, "as_witness"),
             Intrinsic::IsUnconstrained => write!(f, "is_unconstrained"),
+            Intrinsic::DerivePedersenGenerators => write!(f, "derive_pedersen_generators"),
         }
     }
 }
@@ -120,7 +122,8 @@ impl Intrinsic {
             | Intrinsic::StrAsBytes
             | Intrinsic::FromField
             | Intrinsic::AsField
-            | Intrinsic::IsUnconstrained => false,
+            | Intrinsic::IsUnconstrained
+            | Intrinsic::DerivePedersenGenerators => false,
 
             // Some black box functions have side-effects
             Intrinsic::BlackBox(func) => matches!(
@@ -155,6 +158,7 @@ impl Intrinsic {
             "as_field" => Some(Intrinsic::AsField),
             "as_witness" => Some(Intrinsic::AsWitness),
             "is_unconstrained" => Some(Intrinsic::IsUnconstrained),
+            "derive_pedersen_generators" => Some(Intrinsic::DerivePedersenGenerators),
             other => BlackBoxFunc::lookup(other).map(Intrinsic::BlackBox),
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 74e5653c7ba..dfb8d0a8bf9 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -2,6 +2,7 @@ use fxhash::FxHashMap as HashMap;
 use std::{collections::VecDeque, rc::Rc};
 
 use acvm::{acir::AcirField, acir::BlackBoxFunc, BlackBoxResolutionError, FieldElement};
+use bn254_blackbox_solver::derive_generators;
 use iter_extended::vecmap;
 use num_bigint::BigUint;
 
@@ -295,6 +296,13 @@ pub(super) fn simplify_call(
         }
         Intrinsic::AsWitness => SimplifyResult::None,
         Intrinsic::IsUnconstrained => SimplifyResult::None,
+        Intrinsic::DerivePedersenGenerators => {
+            if let Some(Type::Array(_, len)) = ctrl_typevars.unwrap().first() {
+                simplify_derive_generators(dfg, arguments, *len as u32)
+            } else {
+                unreachable!("Derive Pedersen Generators must return an array");
+            }
+        }
     }
 }
 
@@ -626,3 +634,47 @@ fn simplify_signature(
         _ => SimplifyResult::None,
     }
 }
+
+fn simplify_derive_generators(
+    dfg: &mut DataFlowGraph,
+    arguments: &[ValueId],
+    num_generators: u32,
+) -> SimplifyResult {
+    if arguments.len() == 2 {
+        let domain_separator_string = dfg.get_array_constant(arguments[0]);
+        let starting_index = dfg.get_numeric_constant(arguments[1]);
+        if let (Some(domain_separator_string), Some(starting_index)) =
+            (domain_separator_string, starting_index)
+        {
+            let domain_separator_bytes = domain_separator_string
+                .0
+                .iter()
+                .map(|&x| dfg.get_numeric_constant(x).unwrap().to_u128() as u8)
+                .collect::<Vec<u8>>();
+            let generators = derive_generators(
+                &domain_separator_bytes,
+                num_generators,
+                starting_index.try_to_u32().expect("argument is declared as u32"),
+            );
+            let is_infinite = dfg.make_constant(FieldElement::zero(), Type::bool());
+            let mut results = Vec::new();
+            for gen in generators {
+                let x_big: BigUint = gen.x.into();
+                let x = FieldElement::from_be_bytes_reduce(&x_big.to_bytes_be());
+                let y_big: BigUint = gen.y.into();
+                let y = FieldElement::from_be_bytes_reduce(&y_big.to_bytes_be());
+                results.push(dfg.make_constant(x, Type::field()));
+                results.push(dfg.make_constant(y, Type::field()));
+                results.push(is_infinite);
+            }
+            let len = results.len();
+            let result =
+                dfg.make_array(results.into(), Type::Array(vec![Type::field()].into(), len));
+            SimplifyResult::SimplifiedTo(result)
+        } else {
+            SimplifyResult::None
+        }
+    } else {
+        unreachable!("Unexpected number of arguments to derive_generators");
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 6db76996747..c9a6b7bf9c3 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -159,7 +159,8 @@ impl Context {
                     | Intrinsic::AsField
                     | Intrinsic::AsSlice
                     | Intrinsic::AsWitness
-                    | Intrinsic::IsUnconstrained => false,
+                    | Intrinsic::IsUnconstrained
+                    | Intrinsic::DerivePedersenGenerators => false,
                 },
 
                 // We must assume that functions contain a side effect as we cannot inspect more deeply.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
index 6ca7eb74e9d..fd7a1a06fc8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -233,6 +233,7 @@ fn slice_capacity_change(
         | Intrinsic::FromField
         | Intrinsic::AsField
         | Intrinsic::AsWitness
-        | Intrinsic::IsUnconstrained => SizeChange::None,
+        | Intrinsic::IsUnconstrained
+        | Intrinsic::DerivePedersenGenerators => SizeChange::None,
     }
 }
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 6c295d127ab..270de210815 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -5,7 +5,7 @@ mod poseidon2;
 use crate::default::Default;
 use crate::uint128::U128;
 use crate::sha256::{digest, sha256_var};
-use crate::embedded_curve_ops::EmbeddedCurvePoint;
+use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar};
 
 #[foreign(sha256)]
 // docs:start:sha256
@@ -28,7 +28,12 @@ pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
 // docs:start:pedersen_commitment
 pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
     // docs:end:pedersen_commitment
-    pedersen_commitment_with_separator(input, 0)
+    let value = pedersen_commitment_with_separator(input, 0);
+    if (value.x == 0) & (value.y == 0) {
+        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }
+    } else {
+        EmbeddedCurvePoint { x: value.x, y: value.y, is_infinite: false }
+    }
 }
 
 #[foreign(pedersen_commitment)]
@@ -46,8 +51,25 @@ pub fn pedersen_hash<N>(input: [Field; N]) -> Field
     pedersen_hash_with_separator(input, 0)
 }
 
-#[foreign(pedersen_hash)]
-pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {}
+#[field(bn254)]
+fn derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {
+    crate::assert_constant(domain_separator_bytes);
+    crate::assert_constant(starting_index);
+    __derive_generators(domain_separator_bytes, starting_index)
+}
+
+#[builtin(derive_pedersen_generators)]
+#[field(bn254)]
+fn __derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {}
+
+pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {
+    let v1 = pedersen_commitment(input);
+    let length_generator :[EmbeddedCurvePoint;1] = derive_generators("pedersen_hash_length".as_bytes(), separator);
+    crate::embedded_curve_ops::multi_scalar_mul(
+        [length_generator[0], v1],
+        [EmbeddedCurveScalar { lo: N as Field, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
+    )[0]
+}
 
 pub fn hash_to_field(inputs: [Field]) -> Field {
     let mut sum = 0;

From 1a794e312159d54a2bf21ae5f61a3de6fa688127 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Wed, 19 Jun 2024 19:42:09 +0200
Subject: [PATCH 396/416] chore: Pedersen commitment in Noir (#5221)

# Description

## Problem\*

Related to #4931

## Summary\*
Implements Pedersen commitment in Noir and remove Pedersen Commitment,
Pedersen Hash blackboxes.


## Additional Context
The PR is in draft until #5217 is merged.


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
Co-authored-by: TomAFrench <tom@tomfren.ch>
---
 .../acir/src/circuit/black_box_functions.rs   | 45 ++---------
 .../opcodes/black_box_function_call.rs        | 30 ++++---
 .../acir/tests/test_program_serialization.rs  | 27 -------
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        | 12 +--
 acvm-repo/acvm/src/pwg/blackbox/pedersen.rs   | 47 -----------
 .../test/browser/execute_circuit.test.ts      | 10 ---
 .../acvm_js/test/node/execute_circuit.test.ts | 30 -------
 acvm-repo/acvm_js/test/shared/pedersen.ts     | 13 ---
 .../src/curve_specific_solver.rs              | 24 ------
 .../benches/criterion.rs                      | 18 +----
 acvm-repo/bn254_blackbox_solver/src/lib.rs    | 28 -------
 acvm-repo/brillig/src/black_box.rs            |  4 +-
 acvm-repo/brillig_vm/src/black_box.rs         | 41 +---------
 .../brillig/brillig_gen/brillig_black_box.rs  | 35 +-------
 .../noirc_evaluator/src/brillig/brillig_ir.rs | 15 +---
 .../src/brillig/brillig_ir/debug_show.rs      | 20 +----
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 25 ------
 .../ssa/acir_gen/acir_ir/generated_acir.rs    | 25 ++----
 .../src/ssa/ir/instruction/call.rs            |  4 +-
 .../src/ssa/opt/flatten_cfg.rs                | 79 ++++++++++---------
 noir_stdlib/src/embedded_curve_ops.nr         |  8 ++
 noir_stdlib/src/hash.nr                       | 16 ++--
 .../intrinsic_die/src/main.nr                 |  1 -
 tooling/lsp/src/solver.rs                     | 16 ----
 24 files changed, 104 insertions(+), 469 deletions(-)
 delete mode 100644 acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
 delete mode 100644 acvm-repo/acvm_js/test/shared/pedersen.ts

diff --git a/acvm-repo/acir/src/circuit/black_box_functions.rs b/acvm-repo/acir/src/circuit/black_box_functions.rs
index 419c0266b69..aadee59f507 100644
--- a/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -82,43 +82,10 @@ pub enum BlackBoxFunc {
     ///
     /// [grumpkin]: https://hackmd.io/@aztec-network/ByzgNxBfd#2-Grumpkin---A-curve-on-top-of-BN-254-for-SNARK-efficient-group-operations
     SchnorrVerify,
-
-    /// Calculates a Pedersen commitment to the inputs.
-    ///
-    /// Computes a Pedersen commitment of the inputs using generators of the
-    /// embedded curve
-    /// - input: vector of (witness, 254)
-    /// - output: 2 witnesses representing the x,y coordinates of the resulting
-    ///   Grumpkin point
-    /// - domain separator: a constant public value (a field element) that you
-    ///   can use so that the commitment also depends on the domain separator.
-    ///   Noir uses 0 as domain separator.
-    ///
-    /// The backend should handle proper conversion between the inputs being ACIR
-    /// field elements and the scalar field of the embedded curve. In the case of
-    /// Aztec's Barretenberg, the latter is bigger than the ACIR field so it is
-    /// straightforward. The Pedersen generators are managed by the proving
-    /// system.
-    ///
-    /// The commitment is expected to be additively homomorphic
+    /// Deprecated. To be removed with a sync from aztec-packages
     PedersenCommitment,
-
-    /// Calculates a Pedersen hash to the inputs.
-    ///
-    /// Computes a Pedersen hash of the inputs and their number, using
-    /// generators of the embedded curve
-    /// - input: vector of (witness, 254)
-    /// - output: the x-coordinate of the pedersen commitment of the
-    ///   'prepended input' (see below)
-    /// - domain separator: a constant public value (a field element) that you
-    ///   can use so that the hash also depends on the domain separator. Noir
-    ///   uses 0 as domain separator.
-    ///
-    /// In Barretenberg, PedersenHash is doing the same as PedersenCommitment,
-    /// except that it prepends the inputs with their length. This is expected
-    /// to not be additively homomorphic.
+    /// Deprecated. To be removed with a sync from aztec-packages
     PedersenHash,
-
     /// Verifies a ECDSA signature over the secp256k1 curve.
     /// - inputs:
     ///     - x coordinate of public key as 32 bytes
@@ -242,8 +209,6 @@ impl BlackBoxFunc {
             BlackBoxFunc::SchnorrVerify => "schnorr_verify",
             BlackBoxFunc::Blake2s => "blake2s",
             BlackBoxFunc::Blake3 => "blake3",
-            BlackBoxFunc::PedersenCommitment => "pedersen_commitment",
-            BlackBoxFunc::PedersenHash => "pedersen_hash",
             BlackBoxFunc::EcdsaSecp256k1 => "ecdsa_secp256k1",
             BlackBoxFunc::MultiScalarMul => "multi_scalar_mul",
             BlackBoxFunc::EmbeddedCurveAdd => "embedded_curve_add",
@@ -262,6 +227,8 @@ impl BlackBoxFunc {
             BlackBoxFunc::BigIntToLeBytes => "bigint_to_le_bytes",
             BlackBoxFunc::Poseidon2Permutation => "poseidon2_permutation",
             BlackBoxFunc::Sha256Compression => "sha256_compression",
+            BlackBoxFunc::PedersenCommitment => "deprecated pedersen commitment",
+            BlackBoxFunc::PedersenHash => "deprecated pedersen hash",
         }
     }
 
@@ -272,8 +239,6 @@ impl BlackBoxFunc {
             "schnorr_verify" => Some(BlackBoxFunc::SchnorrVerify),
             "blake2s" => Some(BlackBoxFunc::Blake2s),
             "blake3" => Some(BlackBoxFunc::Blake3),
-            "pedersen_commitment" => Some(BlackBoxFunc::PedersenCommitment),
-            "pedersen_hash" => Some(BlackBoxFunc::PedersenHash),
             "ecdsa_secp256k1" => Some(BlackBoxFunc::EcdsaSecp256k1),
             "ecdsa_secp256r1" => Some(BlackBoxFunc::EcdsaSecp256r1),
             "multi_scalar_mul" => Some(BlackBoxFunc::MultiScalarMul),
@@ -292,6 +257,8 @@ impl BlackBoxFunc {
             "bigint_to_le_bytes" => Some(BlackBoxFunc::BigIntToLeBytes),
             "poseidon2_permutation" => Some(BlackBoxFunc::Poseidon2Permutation),
             "sha256_compression" => Some(BlackBoxFunc::Sha256Compression),
+            "deprecated pedersen commitment" => Some(BlackBoxFunc::PedersenCommitment),
+            "deprecated pedersen hash" => Some(BlackBoxFunc::PedersenHash),
             _ => None,
         }
     }
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 362e9ba5936..09b39964813 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -54,11 +54,13 @@ pub enum BlackBoxFuncCall {
         message: Vec<FunctionInput>,
         output: Witness,
     },
+    /// Deprecated. To be removed with a sync from aztec-packages
     PedersenCommitment {
         inputs: Vec<FunctionInput>,
         domain_separator: u32,
         outputs: (Witness, Witness),
     },
+    /// Deprecated. To be removed with a sync from aztec-packages
     PedersenHash {
         inputs: Vec<FunctionInput>,
         domain_separator: u32,
@@ -189,8 +191,6 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::Blake2s { .. } => BlackBoxFunc::Blake2s,
             BlackBoxFuncCall::Blake3 { .. } => BlackBoxFunc::Blake3,
             BlackBoxFuncCall::SchnorrVerify { .. } => BlackBoxFunc::SchnorrVerify,
-            BlackBoxFuncCall::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
-            BlackBoxFuncCall::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
             BlackBoxFuncCall::EcdsaSecp256k1 { .. } => BlackBoxFunc::EcdsaSecp256k1,
             BlackBoxFuncCall::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
             BlackBoxFuncCall::MultiScalarMul { .. } => BlackBoxFunc::MultiScalarMul,
@@ -206,6 +206,8 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::BigIntToLeBytes { .. } => BlackBoxFunc::BigIntToLeBytes,
             BlackBoxFuncCall::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
             BlackBoxFuncCall::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
+            BlackBoxFuncCall::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
+            BlackBoxFuncCall::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
         }
     }
 
@@ -219,8 +221,6 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::SHA256 { inputs, .. }
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
-            | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
-            | BlackBoxFuncCall::PedersenHash { inputs, .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
             | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. } => inputs.to_vec(),
 
@@ -318,6 +318,8 @@ impl BlackBoxFuncCall {
                 inputs.push(*key_hash);
                 inputs
             }
+            BlackBoxFuncCall::PedersenCommitment { .. } => todo!(),
+            BlackBoxFuncCall::PedersenHash { .. } => todo!(),
         }
     }
 
@@ -339,9 +341,7 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::XOR { output, .. }
             | BlackBoxFuncCall::SchnorrVerify { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
-            | BlackBoxFuncCall::PedersenHash { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
-            BlackBoxFuncCall::PedersenCommitment { outputs, .. } => vec![outputs.0, outputs.1],
             BlackBoxFuncCall::MultiScalarMul { outputs, .. }
             | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => {
                 vec![outputs.0, outputs.1, outputs.2]
@@ -356,6 +356,8 @@ impl BlackBoxFuncCall {
                 vec![]
             }
             BlackBoxFuncCall::BigIntToLeBytes { outputs, .. } => outputs.to_vec(),
+            BlackBoxFuncCall::PedersenCommitment { .. } => todo!(),
+            BlackBoxFuncCall::PedersenHash { .. } => todo!(),
         }
     }
 }
@@ -421,6 +423,14 @@ fn get_outputs_string(outputs: &[Witness]) -> String {
 
 impl std::fmt::Display for BlackBoxFuncCall {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BlackBoxFuncCall::PedersenCommitment { .. } => {
+                return write!(f, "BLACKBOX::Deprecated")
+            }
+            BlackBoxFuncCall::PedersenHash { .. } => return write!(f, "BLACKBOX::Deprecated"),
+            _ => (),
+        }
+
         let uppercase_name = self.name().to_uppercase();
         write!(f, "BLACKBOX::{uppercase_name} ")?;
         // INPUTS
@@ -440,13 +450,7 @@ impl std::fmt::Display for BlackBoxFuncCall {
 
         write!(f, "]")?;
 
-        // SPECIFIC PARAMETERS
-        match self {
-            BlackBoxFuncCall::PedersenCommitment { domain_separator, .. } => {
-                write!(f, " domain_separator: {domain_separator}")
-            }
-            _ => write!(f, ""),
-        }
+        write!(f, "")
     }
 }
 
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index dfcb1a8bb86..84a9aa719f2 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -100,33 +100,6 @@ fn multi_scalar_mul_circuit() {
     assert_eq!(bytes, expected_serialization)
 }
 
-#[test]
-fn pedersen_circuit() {
-    let pedersen = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::PedersenCommitment {
-        inputs: vec![FunctionInput { witness: Witness(1), num_bits: FieldElement::max_num_bits() }],
-        outputs: (Witness(2), Witness(3)),
-        domain_separator: 0,
-    });
-
-    let circuit: Circuit<FieldElement> = Circuit {
-        current_witness_index: 4,
-        opcodes: vec![pedersen],
-        private_parameters: BTreeSet::from([Witness(1)]),
-        return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(3)])),
-        ..Circuit::default()
-    };
-    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
-
-    let bytes = Program::serialize_program(&program);
-
-    let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 73, 10, 0, 0, 4, 180, 29, 252, 255, 193, 66, 40,
-        76, 77, 179, 34, 20, 36, 136, 237, 83, 245, 101, 107, 79, 65, 94, 253, 214, 217, 255, 239,
-        192, 1, 43, 124, 181, 238, 113, 0, 0, 0,
-    ];
-    assert_eq!(bytes, expected_serialization)
-}
-
 #[test]
 fn schnorr_verify_circuit() {
     let public_key_x =
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 8bda9221d8a..b3064c47d82 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -7,7 +7,7 @@ use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256};
 
 use self::{
     aes128::solve_aes128_encryption_opcode, bigint::AcvmBigIntSolver,
-    hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash,
+    hash::solve_poseidon2_permutation_opcode,
 };
 
 use super::{insert_value, OpcodeNotSolvable, OpcodeResolutionError};
@@ -18,7 +18,6 @@ pub(crate) mod bigint;
 mod embedded_curve_ops;
 mod hash;
 mod logic;
-mod pedersen;
 mod range;
 mod signature;
 pub(crate) mod utils;
@@ -27,7 +26,6 @@ use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 // Hash functions should eventually be exposed for external consumers.
 use hash::{solve_generic_256_hash_opcode, solve_sha_256_permutation_opcode};
 use logic::{and, xor};
-use pedersen::pedersen;
 pub(crate) use range::solve_range_opcode;
 use signature::{
     ecdsa::{secp256k1_prehashed, secp256r1_prehashed},
@@ -127,12 +125,6 @@ pub(crate) fn solve<F: AcirField>(
             message,
             *output,
         ),
-        BlackBoxFuncCall::PedersenCommitment { inputs, domain_separator, outputs } => {
-            pedersen(backend, initial_witness, inputs, *domain_separator, *outputs)
-        }
-        BlackBoxFuncCall::PedersenHash { inputs, domain_separator, output } => {
-            pedersen_hash(backend, initial_witness, inputs, *domain_separator, *output)
-        }
         BlackBoxFuncCall::EcdsaSecp256k1 {
             public_key_x,
             public_key_y,
@@ -187,5 +179,7 @@ pub(crate) fn solve<F: AcirField>(
         BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len } => {
             solve_poseidon2_permutation_opcode(backend, initial_witness, inputs, outputs, *len)
         }
+        BlackBoxFuncCall::PedersenCommitment { .. } => todo!("Deprecated BlackBox"),
+        BlackBoxFuncCall::PedersenHash { .. } => todo!("Deprecated BlackBox"),
     }
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs b/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
deleted file mode 100644
index f64a3a79465..00000000000
--- a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use acir::{
-    circuit::opcodes::FunctionInput,
-    native_types::{Witness, WitnessMap},
-    AcirField,
-};
-
-use crate::{
-    pwg::{insert_value, witness_to_value, OpcodeResolutionError},
-    BlackBoxFunctionSolver,
-};
-
-pub(super) fn pedersen<F: AcirField>(
-    backend: &impl BlackBoxFunctionSolver<F>,
-    initial_witness: &mut WitnessMap<F>,
-    inputs: &[FunctionInput],
-    domain_separator: u32,
-    outputs: (Witness, Witness),
-) -> Result<(), OpcodeResolutionError<F>> {
-    let scalars: Result<Vec<_>, _> =
-        inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
-    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
-
-    let (res_x, res_y) = backend.pedersen_commitment(&scalars, domain_separator)?;
-
-    insert_value(&outputs.0, res_x, initial_witness)?;
-    insert_value(&outputs.1, res_y, initial_witness)?;
-
-    Ok(())
-}
-
-pub(super) fn pedersen_hash<F: AcirField>(
-    backend: &impl BlackBoxFunctionSolver<F>,
-    initial_witness: &mut WitnessMap<F>,
-    inputs: &[FunctionInput],
-    domain_separator: u32,
-    output: Witness,
-) -> Result<(), OpcodeResolutionError<F>> {
-    let scalars: Result<Vec<_>, _> =
-        inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
-    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
-
-    let res = backend.pedersen_hash(&scalars, domain_separator)?;
-
-    insert_value(&output, res, initial_witness)?;
-
-    Ok(())
-}
diff --git a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
index cfd5523b79f..aaa82f8f1e5 100644
--- a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
@@ -75,16 +75,6 @@ it('successfully processes complex brillig foreign call opcodes', async () => {
   expect(solved_witness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes a Pedersen opcode', async function () {
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/pedersen');
-
-  const solvedWitness: WitnessMap = await executeCircuit(bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
-});
-
 it('successfully executes a MultiScalarMul opcode', async () => {
   const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/multi_scalar_mul');
 
diff --git a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
index 1e3517e8814..120ad0fa738 100644
--- a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
@@ -76,17 +76,6 @@ it('successfully processes complex brillig foreign call opcodes', async () => {
   expect(solved_witness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes a Pedersen opcode', async function () {
-  this.timeout(10000);
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/pedersen');
-
-  const solvedWitness: WitnessMap = await executeCircuit(bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
-});
-
 it('successfully executes a MultiScalarMul opcode', async () => {
   const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/multi_scalar_mul');
 
@@ -117,25 +106,6 @@ it('successfully executes a MemoryOp opcode', async () => {
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes 500 pedersen circuits', async function () {
-  this.timeout(100000);
-
-  // Pedersen opcodes used to have a large upfront cost due to generator calculation
-  // so we'd need to pass around the blackbox solver in JS to avoid redoing this work.
-  //
-  // This test now shows that we don't need to do this anymore without a performance regression.
-
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/pedersen');
-
-  for (let i = 0; i < 500; i++) {
-    const solvedWitness = await executeCircuit(bytecode, initialWitnessMap, () => {
-      throw Error('unexpected oracle');
-    });
-
-    expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
-  }
-});
-
 /**
  * Below are all the same tests as above but using `executeProgram`
  * TODO: also add a couple tests for executing multiple circuits
diff --git a/acvm-repo/acvm_js/test/shared/pedersen.ts b/acvm-repo/acvm_js/test/shared/pedersen.ts
deleted file mode 100644
index 6e3ec403d65..00000000000
--- a/acvm-repo/acvm_js/test/shared/pedersen.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// See `pedersen_circuit` integration test in `acir/tests/test_program_serialization.rs`.
-export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 73, 10, 0, 0, 4, 180, 29, 252, 255, 193, 66, 40, 76, 77, 179, 34, 20, 36,
-  136, 237, 83, 245, 101, 107, 79, 65, 94, 253, 214, 217, 255, 239, 192, 1, 43, 124, 181, 238, 113, 0, 0, 0,
-]);
-
-export const initialWitnessMap = new Map([[1, '0x0000000000000000000000000000000000000000000000000000000000000001']]);
-
-export const expectedWitnessMap = new Map([
-  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [2, '0x083e7911d835097629f0067531fc15cafd79a89beecb39903f69572c636f4a5a'],
-  [3, '0x1a7f5efaad7f315c25a918f30cc8d7333fccab7ad7c90f14de81bcc528f9935d'],
-]);
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index 0ee3a252840..869017f52ee 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -14,16 +14,6 @@ pub trait BlackBoxFunctionSolver<F> {
         signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError>;
-    fn pedersen_commitment(
-        &self,
-        inputs: &[F],
-        domain_separator: u32,
-    ) -> Result<(F, F), BlackBoxResolutionError>;
-    fn pedersen_hash(
-        &self,
-        inputs: &[F],
-        domain_separator: u32,
-    ) -> Result<F, BlackBoxResolutionError>;
     fn multi_scalar_mul(
         &self,
         points: &[F],
@@ -67,20 +57,6 @@ impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
     ) -> Result<bool, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::SchnorrVerify))
     }
-    fn pedersen_commitment(
-        &self,
-        _inputs: &[F],
-        _domain_separator: u32,
-    ) -> Result<(F, F), BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::PedersenCommitment))
-    }
-    fn pedersen_hash(
-        &self,
-        _inputs: &[F],
-        _domain_separator: u32,
-    ) -> Result<F, BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::PedersenHash))
-    }
     fn multi_scalar_mul(
         &self,
         _points: &[F],
diff --git a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
index cbcb75a3291..e7917fa1adc 100644
--- a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
+++ b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
@@ -13,22 +13,6 @@ fn bench_poseidon2(c: &mut Criterion) {
     c.bench_function("poseidon2", |b| b.iter(|| poseidon2_permutation(black_box(&inputs), 4)));
 }
 
-fn bench_pedersen_commitment(c: &mut Criterion) {
-    let inputs = [FieldElement::one(); 2];
-
-    c.bench_function("pedersen_commitment", |b| {
-        b.iter(|| Bn254BlackBoxSolver.pedersen_commitment(black_box(&inputs), 0))
-    });
-}
-
-fn bench_pedersen_hash(c: &mut Criterion) {
-    let inputs = [FieldElement::one(); 2];
-
-    c.bench_function("pedersen_hash", |b| {
-        b.iter(|| Bn254BlackBoxSolver.pedersen_hash(black_box(&inputs), 0))
-    });
-}
-
 fn bench_schnorr_verify(c: &mut Criterion) {
     let pub_key_x = FieldElement::from_hex(
         "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
@@ -62,7 +46,7 @@ fn bench_schnorr_verify(c: &mut Criterion) {
 criterion_group!(
     name = benches;
     config = Criterion::default().sample_size(40).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = bench_poseidon2, bench_pedersen_commitment, bench_pedersen_hash, bench_schnorr_verify
+    targets = bench_poseidon2, bench_schnorr_verify
 );
 
 criterion_main!(benches);
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 6897116e90e..ec69c3797f6 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -10,7 +10,6 @@ mod pedersen;
 mod poseidon2;
 mod schnorr;
 
-use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use generator::generators::derive_generators;
 pub use poseidon2::poseidon2_permutation;
@@ -41,33 +40,6 @@ impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
         ))
     }
 
-    fn pedersen_commitment(
-        &self,
-        inputs: &[FieldElement],
-        domain_separator: u32,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
-        let result = pedersen::commitment::commit_native_with_index(&inputs, domain_separator);
-        let result = if let Some((x, y)) = result.xy() {
-            (FieldElement::from_repr(*x), FieldElement::from_repr(*y))
-        } else {
-            (FieldElement::from(0_u128), FieldElement::from(0_u128))
-        };
-
-        Ok(result)
-    }
-
-    fn pedersen_hash(
-        &self,
-        inputs: &[FieldElement],
-        domain_separator: u32,
-    ) -> Result<FieldElement, BlackBoxResolutionError> {
-        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
-        let result = pedersen::hash::hash_with_index(&inputs, domain_separator);
-        let result = FieldElement::from_repr(result);
-        Ok(result)
-    }
-
     fn multi_scalar_mul(
         &self,
         points: &[FieldElement],
diff --git a/acvm-repo/brillig/src/black_box.rs b/acvm-repo/brillig/src/black_box.rs
index 3887092a8c2..2b39e279aa8 100644
--- a/acvm-repo/brillig/src/black_box.rs
+++ b/acvm-repo/brillig/src/black_box.rs
@@ -61,13 +61,13 @@ pub enum BlackBoxOp {
         signature: HeapVector,
         result: MemoryAddress,
     },
-    /// Calculates a Pedersen commitment to the inputs.
+    /// Deprecated. To be removed with a sync from aztec-packages
     PedersenCommitment {
         inputs: HeapVector,
         domain_separator: MemoryAddress,
         output: HeapArray,
     },
-    /// Calculates a Pedersen hash to the inputs.
+    /// Deprecated. To be removed with a sync from aztec-packages
     PedersenHash {
         inputs: HeapVector,
         domain_separator: MemoryAddress,
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 2053f4e7c86..544963b00db 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -232,41 +232,6 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             );
             Ok(())
         }
-        BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
-            let inputs: Vec<F> = read_heap_vector(memory, inputs)
-                .iter()
-                .map(|x| *x.extract_field().unwrap())
-                .collect();
-            let domain_separator: u32 =
-                memory.read(*domain_separator).try_into().map_err(|_| {
-                    BlackBoxResolutionError::Failed(
-                        BlackBoxFunc::PedersenCommitment,
-                        "Invalid signature length".to_string(),
-                    )
-                })?;
-            let (x, y) = solver.pedersen_commitment(&inputs, domain_separator)?;
-            memory.write_slice(
-                memory.read_ref(output.pointer),
-                &[MemoryValue::new_field(x), MemoryValue::new_field(y)],
-            );
-            Ok(())
-        }
-        BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
-            let inputs: Vec<F> = read_heap_vector(memory, inputs)
-                .iter()
-                .map(|x| *x.extract_field().unwrap())
-                .collect();
-            let domain_separator: u32 =
-                memory.read(*domain_separator).try_into().map_err(|_| {
-                    BlackBoxResolutionError::Failed(
-                        BlackBoxFunc::PedersenCommitment,
-                        "Invalid signature length".to_string(),
-                    )
-                })?;
-            let hash = solver.pedersen_hash(&inputs, domain_separator)?;
-            memory.write(*output, MemoryValue::new_field(hash));
-            Ok(())
-        }
         BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
@@ -378,6 +343,8 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
 
             Ok(())
         }
+        BlackBoxOp::PedersenCommitment { .. } => todo!("Deprecated Blackbox"),
+        BlackBoxOp::PedersenHash { .. } => todo!("Deprecated Blackbox"),
     }
 }
 
@@ -392,8 +359,6 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::EcdsaSecp256k1 { .. } => BlackBoxFunc::EcdsaSecp256k1,
         BlackBoxOp::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
         BlackBoxOp::SchnorrVerify { .. } => BlackBoxFunc::SchnorrVerify,
-        BlackBoxOp::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
-        BlackBoxOp::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
         BlackBoxOp::MultiScalarMul { .. } => BlackBoxFunc::MultiScalarMul,
         BlackBoxOp::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
         BlackBoxOp::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
@@ -405,6 +370,8 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
         BlackBoxOp::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
         BlackBoxOp::ToRadix { .. } => unreachable!("ToRadix is not an ACIR BlackBoxFunc"),
+        BlackBoxOp::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
+        BlackBoxOp::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 367cdbe4973..c62365162ba 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -137,39 +137,6 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
                 )
             }
         }
-
-        BlackBoxFunc::PedersenCommitment => {
-            if let (
-                [message, BrilligVariable::SingleAddr(domain_separator)],
-                [BrilligVariable::BrilligArray(result_array)],
-            ) = (function_arguments, function_results)
-            {
-                let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
-                brillig_context.black_box_op_instruction(BlackBoxOp::PedersenCommitment {
-                    inputs: message_vector.to_heap_vector(),
-                    domain_separator: domain_separator.address,
-                    output: result_array.to_heap_array(),
-                });
-            } else {
-                unreachable!("ICE: Pedersen expects one array argument, a register for the domain separator, and one array result")
-            }
-        }
-        BlackBoxFunc::PedersenHash => {
-            if let (
-                [message, BrilligVariable::SingleAddr(domain_separator)],
-                [BrilligVariable::SingleAddr(result)],
-            ) = (function_arguments, function_results)
-            {
-                let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
-                brillig_context.black_box_op_instruction(BlackBoxOp::PedersenHash {
-                    inputs: message_vector.to_heap_vector(),
-                    domain_separator: domain_separator.address,
-                    output: result.address,
-                });
-            } else {
-                unreachable!("ICE: Pedersen hash expects one array argument, a register for the domain separator, and one register result")
-            }
-        }
         BlackBoxFunc::SchnorrVerify => {
             if let (
                 [BrilligVariable::SingleAddr(public_key_x), BrilligVariable::SingleAddr(public_key_y), BrilligVariable::BrilligArray(signature), message],
@@ -424,6 +391,8 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
                 unreachable!("ICE: AES128Encrypt expects three array arguments, one array result")
             }
         }
+        BlackBoxFunc::PedersenCommitment => todo!("Deprecated Blackbox"),
+        BlackBoxFunc::PedersenHash => todo!("Deprecated Blackbox"),
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index 9785e073be9..a0bf89fff0d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -158,20 +158,7 @@ pub(crate) mod tests {
         ) -> Result<bool, BlackBoxResolutionError> {
             Ok(true)
         }
-        fn pedersen_commitment(
-            &self,
-            _inputs: &[FieldElement],
-            _domain_separator: u32,
-        ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-            Ok((2_u128.into(), 3_u128.into()))
-        }
-        fn pedersen_hash(
-            &self,
-            _inputs: &[FieldElement],
-            _domain_separator: u32,
-        ) -> Result<FieldElement, BlackBoxResolutionError> {
-            Ok(6_u128.into())
-        }
+
         fn multi_scalar_mul(
             &self,
             _points: &[FieldElement],
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index b258905d657..a595584b376 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -347,24 +347,6 @@ impl DebugShow {
                     result
                 );
             }
-            BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
-                debug_println!(
-                    self.enable_debug_trace,
-                    "  PEDERSEN {} {} -> {}",
-                    inputs,
-                    domain_separator,
-                    output
-                );
-            }
-            BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
-                debug_println!(
-                    self.enable_debug_trace,
-                    "  PEDERSEN_HASH {} {} -> {}",
-                    inputs,
-                    domain_separator,
-                    output
-                );
-            }
             BlackBoxOp::SchnorrVerify {
                 public_key_x,
                 public_key_y,
@@ -462,6 +444,8 @@ impl DebugShow {
                     output
                 );
             }
+            BlackBoxOp::PedersenCommitment { .. } => todo!("Deprecated Blackbox"),
+            BlackBoxOp::PedersenHash { .. } => todo!("Deprecated Blackbox"),
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 56b869fbf6b..e09f95508de 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1215,31 +1215,6 @@ impl<F: AcirField> AcirContext<F> {
     ) -> Result<Vec<AcirVar>, RuntimeError> {
         // Separate out any arguments that should be constants
         let (constant_inputs, constant_outputs) = match name {
-            BlackBoxFunc::PedersenCommitment | BlackBoxFunc::PedersenHash => {
-                // The last argument of pedersen is the domain separator, which must be a constant
-                let domain_var = match inputs.pop() {
-                    Some(domain_var) => domain_var.into_var()?,
-                    None => {
-                        return Err(RuntimeError::InternalError(InternalError::MissingArg {
-                            name: "pedersen call".to_string(),
-                            arg: "domain separator".to_string(),
-                            call_stack: self.get_call_stack(),
-                        }))
-                    }
-                };
-
-                let domain_constant = match self.vars[&domain_var].as_constant() {
-                    Some(domain_constant) => domain_constant,
-                    None => {
-                        return Err(RuntimeError::InternalError(InternalError::NotAConstant {
-                            name: "domain separator".to_string(),
-                            call_stack: self.get_call_stack(),
-                        }))
-                    }
-                };
-
-                (vec![*domain_constant], Vec::new())
-            }
             BlackBoxFunc::Poseidon2Permutation => {
                 // The last argument is the state length, which must be a constant
                 let state_len = match inputs.pop() {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 9d271f7cd9c..6a1118de059 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -224,16 +224,6 @@ impl<F: AcirField> GeneratedAcir<F> {
                     output: outputs[0],
                 }
             }
-            BlackBoxFunc::PedersenCommitment => BlackBoxFuncCall::PedersenCommitment {
-                inputs: inputs[0].clone(),
-                outputs: (outputs[0], outputs[1]),
-                domain_separator: constant_inputs[0].to_u128() as u32,
-            },
-            BlackBoxFunc::PedersenHash => BlackBoxFuncCall::PedersenHash {
-                inputs: inputs[0].clone(),
-                output: outputs[0],
-                domain_separator: constant_inputs[0].to_u128() as u32,
-            },
             BlackBoxFunc::EcdsaSecp256k1 => {
                 BlackBoxFuncCall::EcdsaSecp256k1 {
                     // 32 bytes for each public key co-ordinate
@@ -371,6 +361,8 @@ impl<F: AcirField> GeneratedAcir<F> {
                     .expect("Compiler should generate correct size inputs"),
                 outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
             },
+            BlackBoxFunc::PedersenCommitment => todo!("Deprecated Blackbox"),
+            BlackBoxFunc::PedersenHash => todo!("Deprecated Blackbox"),
         };
 
         self.push_opcode(AcirOpcode::BlackBoxFuncCall(black_box_func_call));
@@ -649,9 +641,7 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
         | BlackBoxFunc::Keccak256
         | BlackBoxFunc::SHA256
         | BlackBoxFunc::Blake2s
-        | BlackBoxFunc::Blake3
-        | BlackBoxFunc::PedersenCommitment
-        | BlackBoxFunc::PedersenHash => None,
+        | BlackBoxFunc::Blake3 => None,
 
         BlackBoxFunc::Keccakf1600 => Some(25),
         // The permutation takes a fixed number of inputs, but the inputs length depends on the proving system implementation.
@@ -687,6 +677,8 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
 
         // FromLeBytes takes a variable array of bytes as input
         BlackBoxFunc::BigIntFromLeBytes => None,
+        BlackBoxFunc::PedersenCommitment => todo!(),
+        BlackBoxFunc::PedersenHash => todo!(),
     }
 }
 
@@ -709,11 +701,6 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
         BlackBoxFunc::Poseidon2Permutation => None,
 
         BlackBoxFunc::Sha256Compression => Some(8),
-        // Pedersen commitment returns a point
-        BlackBoxFunc::PedersenCommitment => Some(2),
-
-        // Pedersen hash returns a field
-        BlackBoxFunc::PedersenHash => Some(1),
 
         // Can only apply a range constraint to one
         // witness at a time.
@@ -743,6 +730,8 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         // AES encryption returns a variable number of outputs
         BlackBoxFunc::AES128Encrypt => None,
+        BlackBoxFunc::PedersenCommitment => todo!(),
+        BlackBoxFunc::PedersenHash => todo!(),
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index dfb8d0a8bf9..a9e3570ba0f 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -476,8 +476,6 @@ fn simplify_black_box_func(
 
         BlackBoxFunc::MultiScalarMul
         | BlackBoxFunc::SchnorrVerify
-        | BlackBoxFunc::PedersenCommitment
-        | BlackBoxFunc::PedersenHash
         | BlackBoxFunc::EmbeddedCurveAdd => {
             // Currently unsolvable here as we rely on an implementation in the backend.
             SimplifyResult::None
@@ -503,6 +501,8 @@ fn simplify_black_box_func(
         }
         BlackBoxFunc::Sha256Compression => SimplifyResult::None, //TODO(Guillaume)
         BlackBoxFunc::AES128Encrypt => SimplifyResult::None,
+        BlackBoxFunc::PedersenCommitment => todo!("Deprecated Blackbox"),
+        BlackBoxFunc::PedersenHash => todo!("Deprecated Blackbox"),
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index 58f70ba9192..c7ce3aaa155 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -1379,28 +1379,28 @@ mod test {
     fn should_not_merge_incorrectly_to_false() {
         // Regression test for #1792
         // Tests that it does not simplify a true constraint an always-false constraint
-        // fn main f1 {
-        //   b0():
-        //     v4 = call pedersen([Field 0], u32 0)
-        //     v5 = array_get v4, index Field 0
-        //     v6 = cast v5 as u32
-        //     v8 = mod v6, u32 2
-        //     v9 = cast v8 as u1
-        //     v10 = allocate
-        //     store Field 0 at v10
-        //     jmpif v9 then: b1, else: b2
-        //   b1():
-        //     v14 = add v5, Field 1
-        //     store v14 at v10
-        //     jmp b3()
-        //   b3():
-        //     v12 = eq v9, u1 1
-        //     constrain v12
-        //     return
-        //   b2():
-        //     store Field 0 at v10
-        //     jmp b3()
-        // }
+        // acir(inline) fn main f1 {
+        //     b0(v0: [u8; 2]):
+        //       v4 = call keccak256(v0, u8 2)
+        //       v5 = array_get v4, index u8 0
+        //       v6 = cast v5 as u32
+        //       v8 = truncate v6 to 1 bits, max_bit_size: 32
+        //       v9 = cast v8 as u1
+        //       v10 = allocate
+        //       store u8 0 at v10
+        //       jmpif v9 then: b2, else: b3
+        //     b2():
+        //       v12 = cast v5 as Field
+        //       v13 = add v12, Field 1
+        //       store v13 at v10
+        //       jmp b4()
+        //     b4():
+        //       constrain v9 == u1 1
+        //       return
+        //     b3():
+        //       store u8 0 at v10
+        //       jmp b4()
+        //   }
         let main_id = Id::test_new(1);
         let mut builder = FunctionBuilder::new("main".into(), main_id);
 
@@ -1409,20 +1409,18 @@ mod test {
         let b2 = builder.insert_block();
         let b3 = builder.insert_block();
 
-        let element_type = Rc::new(vec![Type::field()]);
-        let array_type = Type::Array(element_type.clone(), 1);
-
-        let zero = builder.field_constant(0_u128);
-        let zero_array = builder.array_constant(im::Vector::unit(zero), array_type);
-        let i_zero = builder.numeric_constant(0_u128, Type::unsigned(32));
-        let pedersen = builder
-            .import_intrinsic_id(Intrinsic::BlackBox(acvm::acir::BlackBoxFunc::PedersenCommitment));
-        let v4 = builder.insert_call(
-            pedersen,
-            vec![zero_array, i_zero],
-            vec![Type::Array(element_type, 2)],
-        )[0];
-        let v5 = builder.insert_array_get(v4, zero, Type::field());
+        let element_type = Rc::new(vec![Type::unsigned(8)]);
+        let array_type = Type::Array(element_type.clone(), 2);
+        let array = builder.add_parameter(array_type);
+
+        let zero = builder.numeric_constant(0_u128, Type::unsigned(8));
+        let two = builder.numeric_constant(2_u128, Type::unsigned(8));
+
+        let keccak =
+            builder.import_intrinsic_id(Intrinsic::BlackBox(acvm::acir::BlackBoxFunc::Keccak256));
+        let v4 =
+            builder.insert_call(keccak, vec![array, two], vec![Type::Array(element_type, 32)])[0];
+        let v5 = builder.insert_array_get(v4, zero, Type::unsigned(8));
         let v6 = builder.insert_cast(v5, Type::unsigned(32));
         let i_two = builder.numeric_constant(2_u128, Type::unsigned(32));
         let v8 = builder.insert_binary(v6, BinaryOp::Mod, i_two);
@@ -1435,7 +1433,9 @@ mod test {
 
         builder.switch_to_block(b1);
         let one = builder.field_constant(1_u128);
-        let v14 = builder.insert_binary(v5, BinaryOp::Add, one);
+        let v5b = builder.insert_cast(v5, Type::field());
+        let v13: Id<Value> = builder.insert_binary(v5b, BinaryOp::Add, one);
+        let v14 = builder.insert_cast(v13, Type::unsigned(8));
         builder.insert_store(v10, v14);
         builder.terminate_with_jmp(b3, vec![]);
 
@@ -1449,8 +1449,9 @@ mod test {
         builder.insert_constrain(v12, v_true, None);
         builder.terminate_with_return(vec![]);
 
-        let ssa = builder.finish().flatten_cfg();
-        let main = ssa.main();
+        let ssa = builder.finish();
+        let flattened_ssa = ssa.flatten_cfg();
+        let main = flattened_ssa.main();
 
         // Now assert that there is not an always-false constraint after flattening:
         let mut constrain_count = 0;
diff --git a/noir_stdlib/src/embedded_curve_ops.nr b/noir_stdlib/src/embedded_curve_ops.nr
index cd8c421e136..8e768b97479 100644
--- a/noir_stdlib/src/embedded_curve_ops.nr
+++ b/noir_stdlib/src/embedded_curve_ops.nr
@@ -52,6 +52,14 @@ struct EmbeddedCurveScalar {
     hi: Field,
 }
 
+impl EmbeddedCurveScalar {
+    #[field(bn254)]
+    fn from_field(scalar: Field) -> EmbeddedCurveScalar {
+        let (a,b) = crate::field::bn254::decompose(scalar);
+        EmbeddedCurveScalar { lo: a, hi: b }
+    }
+}
+
 // Computes a multi scalar multiplication over the embedded curve.
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 270de210815..b72c1ecba8f 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -5,7 +5,7 @@ mod poseidon2;
 use crate::default::Default;
 use crate::uint128::U128;
 use crate::sha256::{digest, sha256_var};
-use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar};
+use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
 
 #[foreign(sha256)]
 // docs:start:sha256
@@ -36,12 +36,14 @@ pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
     }
 }
 
-#[foreign(pedersen_commitment)]
-pub fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
-
 pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
-    let values = __pedersen_commitment_with_separator(input, separator);
-    EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: false }
+    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];
+    for i in 0..N {
+        points[i] = EmbeddedCurveScalar::from_field(input[i]);
+    }
+    let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);
+    let values = multi_scalar_mul(generators, points);
+    EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: values[2] as bool }
 }
 
 // docs:start:pedersen_hash
@@ -65,7 +67,7 @@ fn __derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u3
 pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {
     let v1 = pedersen_commitment(input);
     let length_generator :[EmbeddedCurvePoint;1] = derive_generators("pedersen_hash_length".as_bytes(), separator);
-    crate::embedded_curve_ops::multi_scalar_mul(
+    multi_scalar_mul(
         [length_generator[0], v1],
         [EmbeddedCurveScalar { lo: N as Field, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
     )[0]
diff --git a/test_programs/compile_success_empty/intrinsic_die/src/main.nr b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
index c6e269c155d..17aaf02c283 100644
--- a/test_programs/compile_success_empty/intrinsic_die/src/main.nr
+++ b/test_programs/compile_success_empty/intrinsic_die/src/main.nr
@@ -1,6 +1,5 @@
 // This test checks that we perform dead-instruction-elimination on intrinsic functions.
 fn main(x: Field) {
-    let hash = std::hash::pedersen_commitment([x]);
     let g1_x = 0x0000000000000000000000000000000000000000000000000000000000000001;
     let g1_y = 0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c;
     let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: g1_x, y: g1_y, is_infinite: false };
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 0fcac73b905..3c2d7499880 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -16,14 +16,6 @@ impl BlackBoxFunctionSolver<acvm::FieldElement> for WrapperSolver {
         self.0.schnorr_verify(public_key_x, public_key_y, signature, message)
     }
 
-    fn pedersen_commitment(
-        &self,
-        inputs: &[acvm::FieldElement],
-        domain_separator: u32,
-    ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
-        self.0.pedersen_commitment(inputs, domain_separator)
-    }
-
     fn multi_scalar_mul(
         &self,
         points: &[acvm::FieldElement],
@@ -36,14 +28,6 @@ impl BlackBoxFunctionSolver<acvm::FieldElement> for WrapperSolver {
         self.0.multi_scalar_mul(points, scalars_lo, scalars_hi)
     }
 
-    fn pedersen_hash(
-        &self,
-        inputs: &[acvm::FieldElement],
-        domain_separator: u32,
-    ) -> Result<acvm::FieldElement, acvm::BlackBoxResolutionError> {
-        self.0.pedersen_hash(inputs, domain_separator)
-    }
-
     fn ec_add(
         &self,
         input1_x: &acvm::FieldElement,

From 318314d6dd35674328f534ebd882d4b0e66eab24 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Wed, 19 Jun 2024 19:58:42 -0500
Subject: [PATCH 397/416] fix: Add more thorough check for whether a type is
 valid when passing it from constrained code to unconstrained code (#5009)

# Description

## Problem\*

Resolves #5008

## Summary\*

Thank you to @nventuro for the minimal example and @TomAFrench for
looking into this. As a result it was a quick fix.

## Additional Context

All type system fixes must currently be duplicated in the elaborator so
I've included this there as well.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: TomAFrench <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../noirc_frontend/src/elaborator/lints.rs    |  8 +---
 .../noirc_frontend/src/hir/type_check/expr.rs |  2 +-
 compiler/noirc_frontend/src/hir_def/types.rs  | 42 +++++++++++++++++++
 .../regression_5008/Nargo.toml                |  7 ++++
 .../regression_5008/src/main.nr               | 17 ++++++++
 5 files changed, 69 insertions(+), 7 deletions(-)
 create mode 100644 test_programs/compile_failure/regression_5008/Nargo.toml
 create mode 100644 test_programs/compile_failure/regression_5008/src/main.nr

diff --git a/compiler/noirc_frontend/src/elaborator/lints.rs b/compiler/noirc_frontend/src/elaborator/lints.rs
index b86912940eb..af6f4cdb42f 100644
--- a/compiler/noirc_frontend/src/elaborator/lints.rs
+++ b/compiler/noirc_frontend/src/elaborator/lints.rs
@@ -137,7 +137,7 @@ pub(super) fn unconstrained_function_args(
     function_args
         .iter()
         .filter_map(|(typ, _, span)| {
-            if type_contains_mutable_reference(typ) {
+            if !typ.is_valid_for_unconstrained_boundary() {
                 Some(TypeCheckError::ConstrainedReferenceToUnconstrained { span: *span })
             } else {
                 None
@@ -153,17 +153,13 @@ pub(super) fn unconstrained_function_return(
 ) -> Option<TypeCheckError> {
     if return_type.contains_slice() {
         Some(TypeCheckError::UnconstrainedSliceReturnToConstrained { span })
-    } else if type_contains_mutable_reference(return_type) {
+    } else if !return_type.is_valid_for_unconstrained_boundary() {
         Some(TypeCheckError::UnconstrainedReferenceToConstrained { span })
     } else {
         None
     }
 }
 
-fn type_contains_mutable_reference(typ: &Type) -> bool {
-    matches!(&typ.follow_bindings(), Type::MutableReference(_))
-}
-
 /// Only entrypoint functions require a `pub` visibility modifier applied to their return types.
 ///
 /// Application of `pub` to other functions is not meaningful and is a mistake.
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 46e8db8f5ff..a1302fd15ff 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -340,7 +340,7 @@ impl<'interner> TypeChecker<'interner> {
         // Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime
         if is_current_func_constrained && is_unconstrained_call {
             for (typ, _, _) in args.iter() {
-                if matches!(&typ.follow_bindings(), Type::MutableReference(_)) {
+                if !typ.is_valid_for_unconstrained_boundary() {
                     self.errors.push(TypeCheckError::ConstrainedReferenceToUnconstrained { span });
                 }
             }
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index ce36a22cf88..772558ec31a 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -788,6 +788,48 @@ impl Type {
         }
     }
 
+    /// Returns true if a value of this type can safely pass between constrained and
+    /// unconstrained functions (and vice-versa).
+    pub(crate) fn is_valid_for_unconstrained_boundary(&self) -> bool {
+        match self {
+            Type::FieldElement
+            | Type::Integer(_, _)
+            | Type::Bool
+            | Type::Unit
+            | Type::Constant(_)
+            | Type::Slice(_)
+            | Type::TypeVariable(_, _)
+            | Type::NamedGeneric(_, _)
+            | Type::Function(_, _, _)
+            | Type::FmtString(_, _)
+            | Type::Error => true,
+
+            Type::MutableReference(_)
+            | Type::Forall(_, _)
+            | Type::Quoted(_)
+            | Type::TraitAsType(..) => false,
+
+            Type::Alias(alias, generics) => {
+                let alias = alias.borrow();
+                alias.get_type(generics).is_valid_for_unconstrained_boundary()
+            }
+
+            Type::Array(length, element) => {
+                length.is_valid_for_unconstrained_boundary()
+                    && element.is_valid_for_unconstrained_boundary()
+            }
+            Type::String(length) => length.is_valid_for_unconstrained_boundary(),
+            Type::Tuple(elements) => {
+                elements.iter().all(|elem| elem.is_valid_for_unconstrained_boundary())
+            }
+            Type::Struct(definition, generics) => definition
+                .borrow()
+                .get_fields(generics)
+                .into_iter()
+                .all(|(_, field)| field.is_valid_for_unconstrained_boundary()),
+        }
+    }
+
     /// Returns the number of `Forall`-quantified type variables on this type.
     /// Returns 0 if this is not a Type::Forall
     pub fn generic_count(&self) -> usize {
diff --git a/test_programs/compile_failure/regression_5008/Nargo.toml b/test_programs/compile_failure/regression_5008/Nargo.toml
new file mode 100644
index 00000000000..920c00660cf
--- /dev/null
+++ b/test_programs/compile_failure/regression_5008/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_5008"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]
diff --git a/test_programs/compile_failure/regression_5008/src/main.nr b/test_programs/compile_failure/regression_5008/src/main.nr
new file mode 100644
index 00000000000..6d9645ee6eb
--- /dev/null
+++ b/test_programs/compile_failure/regression_5008/src/main.nr
@@ -0,0 +1,17 @@
+struct Bar {
+    value: Field,
+}
+
+struct Foo{
+    bar: &mut Bar,
+}
+
+impl Foo {
+    unconstrained fn crash_fn(self) {}
+}
+
+fn main() {
+    let foo = Foo { bar: &mut Bar { value: 0 } };
+
+    foo.crash_fn();
+}

From 508e677cf2c66ac3427932a18f1661f5f4dc4202 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 20 Jun 2024 11:05:18 +0100
Subject: [PATCH 398/416] feat: build simple dictionary from inspecting ACIR
 program (#5264)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5262
## Summary\*

This PR pulls out a bunch of relevant constants from the ACIR/brillig
bytecode so we can feed these into the fuzzer's strategy to ensure
proper coverage of these values.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../fuzzer_checks/Nargo.toml                  |   5 +
 .../fuzzer_checks/src/main.nr                 |   6 +
 tooling/fuzzer/src/dictionary/mod.rs          | 124 ++++++++++++++++++
 tooling/fuzzer/src/lib.rs                     |   5 +-
 tooling/fuzzer/src/strategies/mod.rs          |  36 ++---
 tooling/fuzzer/src/strategies/uint.rs         |  40 +++++-
 6 files changed, 193 insertions(+), 23 deletions(-)
 create mode 100644 test_programs/noir_test_success/fuzzer_checks/Nargo.toml
 create mode 100644 test_programs/noir_test_success/fuzzer_checks/src/main.nr
 create mode 100644 tooling/fuzzer/src/dictionary/mod.rs

diff --git a/test_programs/noir_test_success/fuzzer_checks/Nargo.toml b/test_programs/noir_test_success/fuzzer_checks/Nargo.toml
new file mode 100644
index 00000000000..cd09d0d344d
--- /dev/null
+++ b/test_programs/noir_test_success/fuzzer_checks/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "fuzzer_checks"
+type = "bin"
+authors = [""]
+[dependencies]
diff --git a/test_programs/noir_test_success/fuzzer_checks/src/main.nr b/test_programs/noir_test_success/fuzzer_checks/src/main.nr
new file mode 100644
index 00000000000..2b928db092e
--- /dev/null
+++ b/test_programs/noir_test_success/fuzzer_checks/src/main.nr
@@ -0,0 +1,6 @@
+
+#[test(should_fail_with = "42 is not allowed")]
+fn finds_magic_value(x: u32) {
+    let x = x as u64;
+    assert(2 * x != 42, "42 is not allowed");
+}
diff --git a/tooling/fuzzer/src/dictionary/mod.rs b/tooling/fuzzer/src/dictionary/mod.rs
new file mode 100644
index 00000000000..bf2ab87be29
--- /dev/null
+++ b/tooling/fuzzer/src/dictionary/mod.rs
@@ -0,0 +1,124 @@
+//! This module defines how to build a dictionary of values which are likely to be correspond
+//! to significant inputs during fuzzing by inspecting the [Program] being fuzzed.
+//!
+//! This dictionary can be fed into the fuzzer's [strategy][proptest::strategy::Strategy] in order to bias it towards
+//! generating these values to ensure they get proper coverage.
+use std::collections::HashSet;
+
+use acvm::{
+    acir::{
+        circuit::{
+            brillig::{BrilligBytecode, BrilligInputs},
+            directives::Directive,
+            opcodes::{BlackBoxFuncCall, FunctionInput},
+            Circuit, Opcode, Program,
+        },
+        native_types::Expression,
+    },
+    brillig_vm::brillig::Opcode as BrilligOpcode,
+    AcirField,
+};
+
+/// Constructs a [HashSet<F>] of values pulled from a [Program<F>] which are likely to be correspond
+/// to significant inputs during fuzzing.
+pub(super) fn build_dictionary_from_program<F: AcirField>(program: &Program<F>) -> HashSet<F> {
+    let constrained_dictionaries = program.functions.iter().map(build_dictionary_from_circuit);
+    let unconstrained_dictionaries =
+        program.unconstrained_functions.iter().map(build_dictionary_from_unconstrained_function);
+    let dictionaries = constrained_dictionaries.chain(unconstrained_dictionaries);
+
+    let mut constants: HashSet<F> = HashSet::new();
+    for dictionary in dictionaries {
+        constants.extend(dictionary);
+    }
+    constants
+}
+
+fn build_dictionary_from_circuit<F: AcirField>(circuit: &Circuit<F>) -> HashSet<F> {
+    let mut constants: HashSet<F> = HashSet::new();
+
+    fn insert_expr<F: AcirField>(dictionary: &mut HashSet<F>, expr: &Expression<F>) {
+        let quad_coefficients = expr.mul_terms.iter().map(|(k, _, _)| *k);
+        let linear_coefficients = expr.linear_combinations.iter().map(|(k, _)| *k);
+        let coefficients = linear_coefficients.chain(quad_coefficients);
+
+        dictionary.extend(coefficients.clone());
+        dictionary.insert(expr.q_c);
+
+        // We divide the constant term by any coefficients in the expression to aid solving constraints such as `2 * x - 4 == 0`.
+        let scaled_constants = coefficients.map(|coefficient| expr.q_c / coefficient);
+        dictionary.extend(scaled_constants);
+    }
+
+    fn insert_array_len<F: AcirField, T>(dictionary: &mut HashSet<F>, array: &[T]) {
+        let array_length = array.len() as u128;
+        dictionary.insert(F::from(array_length));
+        dictionary.insert(F::from(array_length - 1));
+    }
+
+    for opcode in &circuit.opcodes {
+        match opcode {
+            Opcode::AssertZero(expr)
+            | Opcode::Call { predicate: Some(expr), .. }
+            | Opcode::MemoryOp { predicate: Some(expr), .. }
+            | Opcode::Directive(Directive::ToLeRadix { a: expr, .. }) => {
+                insert_expr(&mut constants, expr)
+            }
+
+            Opcode::MemoryInit { init, .. } => insert_array_len(&mut constants, init),
+
+            Opcode::BrilligCall { inputs, predicate, .. } => {
+                for input in inputs {
+                    match input {
+                        BrilligInputs::Single(expr) => insert_expr(&mut constants, expr),
+                        BrilligInputs::Array(exprs) => {
+                            exprs.iter().for_each(|expr| insert_expr(&mut constants, expr));
+                            insert_array_len(&mut constants, exprs);
+                        }
+                        BrilligInputs::MemoryArray(_) => (),
+                    }
+                }
+                if let Some(predicate) = predicate {
+                    insert_expr(&mut constants, predicate)
+                }
+            }
+
+            Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
+                input: FunctionInput { num_bits, .. },
+            }) => {
+                let field = 1u128.wrapping_shl(*num_bits);
+                constants.insert(F::from(field));
+                constants.insert(F::from(field - 1));
+            }
+            _ => (),
+        }
+    }
+
+    constants
+}
+
+fn build_dictionary_from_unconstrained_function<F: AcirField>(
+    function: &BrilligBytecode<F>,
+) -> HashSet<F> {
+    let mut constants: HashSet<F> = HashSet::new();
+
+    for opcode in &function.bytecode {
+        match opcode {
+            BrilligOpcode::Cast { bit_size, .. } => {
+                let field = 1u128.wrapping_shl(*bit_size);
+                constants.insert(F::from(field));
+                constants.insert(F::from(field - 1));
+            }
+            BrilligOpcode::Const { bit_size, value, .. } => {
+                constants.insert(*value);
+
+                let field = 1u128.wrapping_shl(*bit_size);
+                constants.insert(F::from(field));
+                constants.insert(F::from(field - 1));
+            }
+            _ => (),
+        }
+    }
+
+    constants
+}
diff --git a/tooling/fuzzer/src/lib.rs b/tooling/fuzzer/src/lib.rs
index 42dccc1dc83..28d7353f35a 100644
--- a/tooling/fuzzer/src/lib.rs
+++ b/tooling/fuzzer/src/lib.rs
@@ -4,9 +4,11 @@
 //! Code is used under the MIT license.
 
 use acvm::{blackbox_solver::StubbedBlackBoxSolver, FieldElement};
+use dictionary::build_dictionary_from_program;
 use noirc_abi::InputMap;
 use proptest::test_runner::{TestCaseError, TestError, TestRunner};
 
+mod dictionary;
 mod strategies;
 mod types;
 
@@ -37,7 +39,8 @@ impl FuzzedExecutor {
 
     /// Fuzzes the provided program.
     pub fn fuzz(&self) -> FuzzTestResult {
-        let strategy = strategies::arb_input_map(&self.program.abi);
+        let dictionary = build_dictionary_from_program(&self.program.bytecode);
+        let strategy = strategies::arb_input_map(&self.program.abi, dictionary);
 
         let run_result: Result<(), TestError<InputMap>> =
             self.runner.clone().run(&strategy, |input_map| {
diff --git a/tooling/fuzzer/src/strategies/mod.rs b/tooling/fuzzer/src/strategies/mod.rs
index f5b03953ba8..46187a28d5b 100644
--- a/tooling/fuzzer/src/strategies/mod.rs
+++ b/tooling/fuzzer/src/strategies/mod.rs
@@ -5,28 +5,22 @@ use proptest::prelude::*;
 use acvm::{AcirField, FieldElement};
 
 use noirc_abi::{input_parser::InputValue, Abi, AbiType, InputMap, Sign};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashSet};
 use uint::UintStrategy;
 
 mod int;
 mod uint;
 
-proptest::prop_compose! {
-    pub(super) fn arb_field_from_integer(bit_size: u32)(value: u128)-> FieldElement {
-        let width = (bit_size % 128).clamp(1, 127);
-        let max_value = 2u128.pow(width) - 1;
-        let value = value % max_value;
-        FieldElement::from(value)
-    }
-}
-
-pub(super) fn arb_value_from_abi_type(abi_type: &AbiType) -> SBoxedStrategy<InputValue> {
+pub(super) fn arb_value_from_abi_type(
+    abi_type: &AbiType,
+    dictionary: HashSet<FieldElement>,
+) -> SBoxedStrategy<InputValue> {
     match abi_type {
         AbiType::Field => vec(any::<u8>(), 32)
             .prop_map(|bytes| InputValue::Field(FieldElement::from_be_bytes_reduce(&bytes)))
             .sboxed(),
         AbiType::Integer { width, sign } if sign == &Sign::Unsigned => {
-            UintStrategy::new(*width as usize)
+            UintStrategy::new(*width as usize, dictionary)
                 .prop_map(|uint| InputValue::Field(uint.into()))
                 .sboxed()
         }
@@ -55,7 +49,7 @@ pub(super) fn arb_value_from_abi_type(abi_type: &AbiType) -> SBoxedStrategy<Inpu
         }
         AbiType::Array { length, typ } => {
             let length = *length as usize;
-            let elements = vec(arb_value_from_abi_type(typ), length..=length);
+            let elements = vec(arb_value_from_abi_type(typ, dictionary), length..=length);
 
             elements.prop_map(InputValue::Vec).sboxed()
         }
@@ -63,7 +57,9 @@ pub(super) fn arb_value_from_abi_type(abi_type: &AbiType) -> SBoxedStrategy<Inpu
         AbiType::Struct { fields, .. } => {
             let fields: Vec<SBoxedStrategy<(String, InputValue)>> = fields
                 .iter()
-                .map(|(name, typ)| (Just(name.clone()), arb_value_from_abi_type(typ)).sboxed())
+                .map(|(name, typ)| {
+                    (Just(name.clone()), arb_value_from_abi_type(typ, dictionary.clone())).sboxed()
+                })
                 .collect();
 
             fields
@@ -75,17 +71,23 @@ pub(super) fn arb_value_from_abi_type(abi_type: &AbiType) -> SBoxedStrategy<Inpu
         }
 
         AbiType::Tuple { fields } => {
-            let fields: Vec<_> = fields.iter().map(arb_value_from_abi_type).collect();
+            let fields: Vec<_> =
+                fields.iter().map(|typ| arb_value_from_abi_type(typ, dictionary.clone())).collect();
             fields.prop_map(InputValue::Vec).sboxed()
         }
     }
 }
 
-pub(super) fn arb_input_map(abi: &Abi) -> BoxedStrategy<InputMap> {
+pub(super) fn arb_input_map(
+    abi: &Abi,
+    dictionary: HashSet<FieldElement>,
+) -> BoxedStrategy<InputMap> {
     let values: Vec<_> = abi
         .parameters
         .iter()
-        .map(|param| (Just(param.name.clone()), arb_value_from_abi_type(&param.typ)))
+        .map(|param| {
+            (Just(param.name.clone()), arb_value_from_abi_type(&param.typ, dictionary.clone()))
+        })
         .collect();
 
     values
diff --git a/tooling/fuzzer/src/strategies/uint.rs b/tooling/fuzzer/src/strategies/uint.rs
index 5021e832b97..94610dbc829 100644
--- a/tooling/fuzzer/src/strategies/uint.rs
+++ b/tooling/fuzzer/src/strategies/uint.rs
@@ -1,3 +1,6 @@
+use std::collections::HashSet;
+
+use acvm::{AcirField, FieldElement};
 use proptest::{
     strategy::{NewTree, Strategy},
     test_runner::TestRunner,
@@ -13,9 +16,12 @@ use rand::Rng;
 pub struct UintStrategy {
     /// Bit size of uint (e.g. 128)
     bits: usize,
-
+    /// A set of fixtures to be generated
+    fixtures: Vec<FieldElement>,
     /// The weight for edge cases (+/- 3 around 0 and max possible value)
     edge_weight: usize,
+    /// The weight for fixtures
+    fixtures_weight: usize,
     /// The weight for purely random values
     random_weight: usize,
 }
@@ -24,8 +30,15 @@ impl UintStrategy {
     /// Create a new strategy.
     /// # Arguments
     /// * `bits` - Size of uint in bits
-    pub fn new(bits: usize) -> Self {
-        Self { bits, edge_weight: 10usize, random_weight: 50usize }
+    /// * `fixtures` - Set of `FieldElements` representing values which the fuzzer weight towards testing.
+    pub fn new(bits: usize, fixtures: HashSet<FieldElement>) -> Self {
+        Self {
+            bits,
+            fixtures: fixtures.into_iter().collect(),
+            edge_weight: 10usize,
+            fixtures_weight: 40usize,
+            random_weight: 50usize,
+        }
     }
 
     fn generate_edge_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
@@ -37,6 +50,22 @@ impl UintStrategy {
         Ok(proptest::num::u128::BinarySearch::new(start))
     }
 
+    fn generate_fixtures_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
+        // generate random cases if there's no fixtures
+        if self.fixtures.is_empty() {
+            return self.generate_random_tree(runner);
+        }
+
+        // Generate value tree from fixture.
+        let fixture = &self.fixtures[runner.rng().gen_range(0..self.fixtures.len())];
+        if fixture.num_bits() <= self.bits as u32 {
+            return Ok(proptest::num::u128::BinarySearch::new(fixture.to_u128()));
+        }
+
+        // If fixture is not a valid type, generate random value.
+        self.generate_random_tree(runner)
+    }
+
     fn generate_random_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
         let rng = runner.rng();
         let start = rng.gen_range(0..=self.type_max());
@@ -57,11 +86,12 @@ impl Strategy for UintStrategy {
     type Tree = proptest::num::u128::BinarySearch;
     type Value = u128;
     fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
-        let total_weight = self.random_weight + self.edge_weight;
+        let total_weight = self.random_weight + self.fixtures_weight + self.edge_weight;
         let bias = runner.rng().gen_range(0..total_weight);
-        // randomly select one of 2 strategies
+        // randomly select one of 3 strategies
         match bias {
             x if x < self.edge_weight => self.generate_edge_tree(runner),
+            x if x < self.edge_weight + self.fixtures_weight => self.generate_fixtures_tree(runner),
             _ => self.generate_random_tree(runner),
         }
     }

From a30814f1f767bf874cd7e2969f5061c68f16b9a7 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Thu, 20 Jun 2024 12:22:52 +0200
Subject: [PATCH 399/416] fix: handle struct with nested arrays in oracle
 return values (#5244)

# Description

## Problem\*

Resolves #5238

## Summary\*
Use nested values when the sizes do not match


## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 acvm-repo/brillig_vm/src/lib.rs               |  9 +++--
 .../regression_4561/src/main.nr               | 34 +++++++++++++++++++
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 862162ddccf..01f45bf653c 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -500,9 +500,14 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                     match output {
                         ForeignCallParam::Array(values) => {
                             if values.len() != *size {
-                                return Err("Foreign call result array doesn't match expected size".to_string());
+                                // foreign call returning flattened values into a nested type, so the sizes do not match
+                               let destination = self.memory.read_ref(*pointer_index);
+                               let return_type = value_type;
+                               let mut flatten_values_idx = 0; //index of values read from flatten_values
+                               self.write_slice_of_values_to_memory(destination, &output.fields(), &mut flatten_values_idx, return_type)?;
+                            } else {
+                                self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
                             }
-                            self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
                         }
                         _ => {
                             return Err("Function result size does not match brillig bytecode size".to_string());
diff --git a/test_programs/noir_test_success/regression_4561/src/main.nr b/test_programs/noir_test_success/regression_4561/src/main.nr
index 70c447b49af..ad40941ff51 100644
--- a/test_programs/noir_test_success/regression_4561/src/main.nr
+++ b/test_programs/noir_test_success/regression_4561/src/main.nr
@@ -42,3 +42,37 @@ fn two_nested_return() {
     OracleMock::mock("two_nested_return").returns((0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6]));
     assert_eq(two_nested_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7, [[1, 2, 3], [4, 5, 6]]));
 }
+
+#[oracle(foo_return)]
+unconstrained fn foo_return() -> (Field, TReturn, TestTypeFoo) {}
+unconstrained fn foo_return_unconstrained() -> (Field, TReturn, TestTypeFoo) {
+    foo_return()
+}
+
+struct TestTypeFoo {
+    a: Field,
+    b: [[[Field; 3]; 4]; 2],
+    c: [TReturnElem; 2],
+    d: TReturnElem,
+}
+
+#[test]
+fn complexe_struct_return() {
+    OracleMock::mock("foo_return").returns(
+        (
+            0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [1, 2, 3, 4, 5, 6]
+        )
+    );
+    let foo_x = foo_return_unconstrained();
+    assert_eq((foo_x.0, foo_x.1), (0, [[1, 2, 3], [4, 5, 6]]));
+    assert_eq(foo_x.2.a, 7);
+    assert_eq(
+        foo_x.2.b, [
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18], [19, 20, 21], [22, 23, 24]]
+    ]
+    );
+    let a: TReturnElem = [1, 2, 3];
+    let b: TReturnElem = [4, 5, 6];
+    assert_eq(foo_x.2.c, [a, b]);
+    assert_eq(foo_x.2.d, a);
+}

From f761b7cb757154db3641e4fc1efb029b2ae30cca Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 20 Jun 2024 14:51:32 +0100
Subject: [PATCH 400/416] chore: refactor test case generation in build.rs
 (#5280)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

The `build.rs` file for generating the test cases is getting a bit
unmanagable imo. This PR factors out some repeated code and adds a new
helper function so we just need to pass in the body of the test.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/build.rs | 557 +++++++++++++++----------------------
 1 file changed, 228 insertions(+), 329 deletions(-)

diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 43c277ba03e..f2da161267d 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -64,392 +64,291 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
 const IGNORED_NEW_FEATURE_TESTS: [&str; 3] =
     ["macros", "wildcard_type", "type_definition_annotation"];
 
-fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "execution_success";
+fn read_test_cases(
+    test_data_dir: &Path,
+    test_sub_dir: &str,
+) -> impl Iterator<Item = (String, PathBuf)> {
     let test_data_dir = test_data_dir.join(test_sub_dir);
-
     let test_case_dirs =
         fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
 
-    for test_dir in test_case_dirs {
+    test_case_dirs.into_iter().map(|dir| {
         let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
+            dir.file_name().into_string().expect("Directory can't be converted to string");
         if test_name.contains('-') {
             panic!(
                 "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
             );
-        };
-        let test_dir = &test_dir.path();
-
-        let brillig_ignored =
-            if IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) { "\n#[ignore]" } else { "" };
-        let new_features_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
-            "\n#[ignore]"
-        } else {
-            ""
-        };
-
-        write!(
-            test_file,
-            r#"
-#[test]{new_features_ignored}
-fn execution_success_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--use-legacy");
-
-    cmd.assert().success();
-}}
+        }
+        (test_name, dir.path())
+    })
+}
 
+fn generate_test_case(
+    test_file: &mut File,
+    test_type: &str,
+    test_name: &str,
+    test_dir: &std::path::Display,
+    test_content: &str,
+) {
+    write!(
+        test_file,
+        r#"
 #[test]
-fn execution_success_{test_name}() {{
+fn {test_type}_{test_name}() {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
-
-    cmd.assert().success();
+    let mut nargo = Command::cargo_bin("nargo").unwrap();
+    nargo.arg("--program-dir").arg(test_program_dir);
+    {test_content}
 }}
+"#
+    )
+    .expect("Could not write templated test file.");
+}
 
-#[test]{brillig_ignored}
-fn execution_success_{test_name}_brillig() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--force-brillig");
+fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
+    let test_type = "execution_success";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-    cmd.assert().success();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &test_name,
+            &test_dir,
+            r#"
+                nargo.arg("execute").arg("--force");
+            
+                nargo.assert().success();"#,
+        );
+
+        if !IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("legacy_{test_name}"),
+                &test_dir,
+                r#"
+                nargo.arg("execute").arg("--force").arg("--use-legacy");
+            
+                nargo.assert().success();"#,
+            );
+        }
+
+        if !IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("{test_name}_brillig"),
+                &test_dir,
+                r#"
+                nargo.arg("execute").arg("--force").arg("--force-brillig");
+            
+                nargo.assert().success();"#,
+            );
+        }
     }
 }
 
 fn generate_execution_failure_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "execution_failure";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
+    let test_type = "execution_failure";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-        write!(
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn execution_failure_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force").arg("--use-legacy");
-
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-
-#[test]
-fn execution_failure_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("execute").arg("--force");
+                nargo.arg("execute").arg("--force");
+            
+                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+        );
 
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+                nargo.arg("execute").arg("--force").arg("--use-legacy");
+            
+                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+        );
     }
 }
 
 fn generate_noir_test_success_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "noir_test_success";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
+    let test_type = "noir_test_success";
+    let test_cases = read_test_cases(test_data_dir, "noir_test_success");
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        write!(
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn noir_test_success_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
+        nargo.arg("test");
+        
+        nargo.assert().success();"#,
+        );
 
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test").arg("--use-legacy");
-
-    cmd.assert().success();
-}}
-
-#[test]
-fn noir_test_success_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test");
-
-    cmd.assert().success();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("test").arg("--use-legacy");
+        
+        nargo.assert().success();"#,
+        );
     }
 }
 
 fn generate_noir_test_failure_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "noir_test_failure";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        write!(
+    let test_type = "noir_test_failure";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn noir_test_failure_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test").arg("--use-legacy");
-
-    cmd.assert().failure();
-}}
-
-#[test]
-fn noir_test_failure_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("test");
+        nargo.arg("test");
+        
+        nargo.assert().failure();"#,
+        );
 
-    cmd.assert().failure();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("test").arg("--use-legacy");
+        
+        nargo.assert().failure();"#,
+        );
     }
 }
 
 fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "compile_success_empty";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        let new_feature_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
-            "\n#[ignore]"
-        } else {
-            ""
-        };
-
-        write!(
+    let test_type = "compile_success_empty";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
+
+        let assert_zero_opcodes = r#"
+        let output = nargo.output().expect("Failed to execute command");
+
+        if !output.status.success() {{
+            panic!("`nargo info` failed with: {}", String::from_utf8(output.stderr).unwrap_or_default());
+        }}
+    
+        // `compile_success_empty` tests should be able to compile down to an empty circuit.
+        let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
+            panic!("JSON was not well-formatted {:?}\n\n{:?}", e, std::str::from_utf8(&output.stdout))
+        }});
+        let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
+        assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
+        "#;
+
+        generate_test_case(
             test_file,
-            r#"
-#[test]{new_feature_ignored}
-fn compile_success_empty_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("info");
-    cmd.arg("--json");
-    cmd.arg("--force");
-    cmd.arg("--use-legacy");
-
-    let output = cmd.output().expect("Failed to execute command");
-
-    if !output.status.success() {{
-        panic!("`nargo info` failed with: {{}}", String::from_utf8(output.stderr).unwrap_or_default());
-    }}
-
-    // `compile_success_empty` tests should be able to compile down to an empty circuit.
-    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
-        panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
-    }});
-    let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
-    assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
-}}
-
-#[test]
-fn compile_success_empty_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("info");
-    cmd.arg("--json");
-    cmd.arg("--force");
-
-    let output = cmd.output().expect("Failed to execute command");
-
-    if !output.status.success() {{
-        panic!("`nargo info` failed with: {{}}", String::from_utf8(output.stderr).unwrap_or_default());
-    }}
-
-    // `compile_success_empty` tests should be able to compile down to an empty circuit.
-    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
-        panic!("JSON was not well-formatted {{:?}}\n\n{{:?}}", e, std::str::from_utf8(&output.stdout))
-    }});
-    let num_opcodes = &json["programs"][0]["functions"][0]["acir_opcodes"];
-    assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+            test_type,
+            &test_name,
+            &test_dir,
+            &format!(
+                r#"
+                nargo.arg("info").arg("--json").arg("--force");
+                
+                {assert_zero_opcodes}"#,
+            ),
+        );
+
+        if !IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("legacy_{test_name}"),
+                &test_dir,
+                &format!(
+                    r#"
+                nargo.arg("info").arg("--json").arg("--force").arg("--use-legacy");
+                
+                {assert_zero_opcodes}"#,
+                ),
+            );
+        }
     }
 }
 
 fn generate_compile_success_contract_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "compile_success_contract";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
-
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
+    let test_type = "compile_success_contract";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-        write!(
+        generate_test_case(
             test_file,
+            test_type,
+            &test_name,
+            &test_dir,
             r#"
-#[test]
-fn compile_success_contract_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force").arg("--use-legacy");
+        nargo.arg("compile").arg("--force");
+        
+        nargo.assert().success();"#,
+        );
 
-    cmd.assert().success();
-}}
-#[test]
-fn compile_success_contract_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force");
-
-    cmd.assert().success();
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("compile").arg("--force").arg("--use-legacy");
+        
+        nargo.assert().success();"#,
+        );
     }
 }
 
 fn generate_compile_failure_tests(test_file: &mut File, test_data_dir: &Path) {
-    let test_sub_dir = "compile_failure";
-    let test_data_dir = test_data_dir.join(test_sub_dir);
-
-    let test_case_dirs =
-        fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
+    let test_type = "compile_failure";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
 
-    for test_dir in test_case_dirs {
-        let test_name =
-            test_dir.file_name().into_string().expect("Directory can't be converted to string");
-        if test_name.contains('-') {
-            panic!(
-                "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
-            );
-        };
-        let test_dir = &test_dir.path();
-
-        let new_feature_ignored = if IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
-            "\n#[ignore]"
-        } else {
-            ""
-        };
-
-        write!(
+        generate_test_case(
             test_file,
-            r#"
-#[test]{new_feature_ignored}
-fn compile_failure_legacy_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force").arg("--use-legacy");
-
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-#[test]
-fn compile_failure_{test_name}() {{
-    let test_program_dir = PathBuf::from("{test_dir}");
-
-    let mut cmd = Command::cargo_bin("nargo").unwrap();
-    cmd.arg("--program-dir").arg(test_program_dir);
-    cmd.arg("compile").arg("--force");
-
-    cmd.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
-}}
-            "#,
-            test_dir = test_dir.display(),
-        )
-        .expect("Could not write templated test file.");
+            test_type,
+            &test_name,
+            &test_dir,
+            r#"nargo.arg("compile").arg("--force");
+        
+        nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+        );
+
+        if !IGNORED_NEW_FEATURE_TESTS.contains(&test_name.as_str()) {
+            generate_test_case(
+                test_file,
+                test_type,
+                &format!("legacy_{test_name}"),
+                &test_dir,
+                r#"
+            nargo.arg("compile").arg("--force").arg("--use-legacy");
+            
+            nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+            );
+        }
     }
 }

From 91a9b725cdb75c08cde888f49e7b8d11257e5de6 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 20 Jun 2024 15:04:12 +0100
Subject: [PATCH 401/416] fix: fix incorrect return type being applied to
 stdlib functions `modulus_be_bytes()`, `modulus_be_bits()`, etc. (#5278)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

We're currently returning an array literal for these methods in the
stdlib whereas the Noir code states that it should return a slice. This
results in issues when passing these "slices" into other functions such
that it causes the inlining pass to panic.

I've fixed this by replacing the array literal with a slice literal.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../noirc_frontend/src/monomorphization/mod.rs    | 15 +++++++--------
 .../execution_success/modulus/src/main.nr         | 11 +++++++++++
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 821ae7e7c4c..07820a70b3f 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -1271,19 +1271,19 @@ impl<'interner> Monomorphizer<'interner> {
                     }
                     "modulus_le_bits" => {
                         let bits = FieldElement::modulus().to_radix_le(2);
-                        Some(self.modulus_array_literal(bits, IntegerBitSize::One, location))
+                        Some(self.modulus_slice_literal(bits, IntegerBitSize::One, location))
                     }
                     "modulus_be_bits" => {
                         let bits = FieldElement::modulus().to_radix_be(2);
-                        Some(self.modulus_array_literal(bits, IntegerBitSize::One, location))
+                        Some(self.modulus_slice_literal(bits, IntegerBitSize::One, location))
                     }
                     "modulus_be_bytes" => {
                         let bytes = FieldElement::modulus().to_bytes_be();
-                        Some(self.modulus_array_literal(bytes, IntegerBitSize::Eight, location))
+                        Some(self.modulus_slice_literal(bytes, IntegerBitSize::Eight, location))
                     }
                     "modulus_le_bytes" => {
                         let bytes = FieldElement::modulus().to_bytes_le();
-                        Some(self.modulus_array_literal(bytes, IntegerBitSize::Eight, location))
+                        Some(self.modulus_slice_literal(bytes, IntegerBitSize::Eight, location))
                     }
                     _ => None,
                 };
@@ -1292,7 +1292,7 @@ impl<'interner> Monomorphizer<'interner> {
         None
     }
 
-    fn modulus_array_literal(
+    fn modulus_slice_literal(
         &self,
         bytes: Vec<u8>,
         arr_elem_bits: IntegerBitSize,
@@ -1306,10 +1306,9 @@ impl<'interner> Monomorphizer<'interner> {
             Expression::Literal(Literal::Integer((byte as u128).into(), int_type.clone(), location))
         });
 
-        let typ = Type::Array(bytes_as_expr.len() as u32, Box::new(int_type));
-
+        let typ = Type::Slice(Box::new(int_type));
         let arr_literal = ArrayLiteral { typ, contents: bytes_as_expr };
-        Expression::Literal(Literal::Array(arr_literal))
+        Expression::Literal(Literal::Slice(arr_literal))
     }
 
     fn queue_function(
diff --git a/test_programs/execution_success/modulus/src/main.nr b/test_programs/execution_success/modulus/src/main.nr
index c7d6a2e2c7d..1627cc0dba2 100644
--- a/test_programs/execution_success/modulus/src/main.nr
+++ b/test_programs/execution_success/modulus/src/main.nr
@@ -3,6 +3,11 @@ fn main(bn254_modulus_be_bytes: [u8; 32], bn254_modulus_be_bits: [u1; 254]) {
     // NOTE: The constraints used in this circuit will only work when testing nargo with the plonk bn254 backend
     assert(modulus_size == 254);
 
+    assert_reverse(
+        std::field::modulus_be_bytes(),
+        std::field::modulus_le_bytes()
+    );
+
     let modulus_be_byte_array = std::field::modulus_be_bytes();
     for i in 0..32 {
         assert(modulus_be_byte_array[i] == bn254_modulus_be_bytes[i]);
@@ -21,3 +26,9 @@ fn main(bn254_modulus_be_bytes: [u8; 32], bn254_modulus_be_bits: [u1; 254]) {
         assert(modulus_le_bits[i] == bn254_modulus_be_bits[253 - i]);
     }
 }
+
+fn assert_reverse(forwards: [u8], backwards: [u8]) {
+    for i in 0..32 {
+        assert_eq(forwards[i], backwards[31 - i]);
+    }
+}

From 4c4ea2df0163d4989c922c6a1377e04c2cd0540c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Thu, 20 Jun 2024 15:22:01 +0100
Subject: [PATCH 402/416] fix: update `in_contract` flag before handling
 function metadata in elaborator (#5292)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…

# Description

## Problem\*

Resolves #5288

## Summary\*

This PR fixes #5288 by updating `self.in_contract` before we define
function metadata to match `self.local_module`. This is mildly hacky and
we may want to have a nicer "switch modules and update everything which
depends on it" helper function in future.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs               | 3 +++
 .../compile_success_contract/recursive_method/Nargo.toml    | 6 ++++++
 .../compile_success_contract/recursive_method/src/main.nr   | 6 ++++++
 3 files changed, 15 insertions(+)
 create mode 100644 test_programs/compile_success_contract/recursive_method/Nargo.toml
 create mode 100644 test_programs/compile_success_contract/recursive_method/src/main.nr

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 91d6ba71927..dc99ceae2f0 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1302,9 +1302,12 @@ impl<'context> Elaborator<'context> {
 
         for (local_module, id, func) in &mut function_set.functions {
             self.local_module = *local_module;
+            let was_in_contract = self.in_contract;
+            self.in_contract = self.module_id().module(self.def_maps).is_contract;
             self.recover_generics(|this| {
                 this.define_function_meta(func, *id, false);
             });
+            self.in_contract = was_in_contract;
         }
     }
 
diff --git a/test_programs/compile_success_contract/recursive_method/Nargo.toml b/test_programs/compile_success_contract/recursive_method/Nargo.toml
new file mode 100644
index 00000000000..8142e5b3278
--- /dev/null
+++ b/test_programs/compile_success_contract/recursive_method/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "recursive_method"
+type = "contract"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_success_contract/recursive_method/src/main.nr b/test_programs/compile_success_contract/recursive_method/src/main.nr
new file mode 100644
index 00000000000..6fd4bf3338d
--- /dev/null
+++ b/test_programs/compile_success_contract/recursive_method/src/main.nr
@@ -0,0 +1,6 @@
+contract Foo {
+    #[recursive]
+    fn contract_entrypoint() -> pub Field {
+        1
+    }
+}

From ec728dd909fce33ab712116f61d672b1ee552fc4 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 20 Jun 2024 16:57:44 -0400
Subject: [PATCH 403/416] fix(nargo_fmt): Account for spaces before the generic
 list of a function (#5303)

# Description

## Problem\*

Resolves #5300

## Summary\*

Previously the formatter was inserting an extra `<` when formatting
functions with a space before `<` when specifying generics. We currently
mark the starting span for a list of generics as the end of the function
name. Having this be the starting span would cause the first generic of
the sequence to have `<` marked as a leading string when it should not
have been. We now start the span for a function's generics by looking
for `<` rather than starting the span at the end of the function name.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_fmt/src/visitor/item.rs  | 2 +-
 tooling/nargo_fmt/tests/expected/fn.nr | 4 ++++
 tooling/nargo_fmt/tests/input/fn.nr    | 5 +++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/tooling/nargo_fmt/src/visitor/item.rs b/tooling/nargo_fmt/src/visitor/item.rs
index a5d042dc71e..3cfee4f46ad 100644
--- a/tooling/nargo_fmt/src/visitor/item.rs
+++ b/tooling/nargo_fmt/src/visitor/item.rs
@@ -44,7 +44,7 @@ impl super::FmtVisitor<'_> {
 
         if !func.def.generics.is_empty() {
             let full_span = name_span.end()..params_open;
-            let start = name_span.end();
+            let start = self.span_before(full_span.clone(), Token::Less).start();
             let end = self.span_after(full_span, Token::Greater).start();
 
             let generics = func.def.generics;
diff --git a/tooling/nargo_fmt/tests/expected/fn.nr b/tooling/nargo_fmt/tests/expected/fn.nr
index 3d231cd3f7f..961e67faf1c 100644
--- a/tooling/nargo_fmt/tests/expected/fn.nr
+++ b/tooling/nargo_fmt/tests/expected/fn.nr
@@ -61,3 +61,7 @@ fn main(
 ) {}
 
 pub fn from_baz(x: [Field; crate::foo::MAGIC_NUMBER]) {}
+
+fn whitespace_before_generics<T>(foo: T) {}
+
+fn more_whitespace_before_generics<T>(foo: T) {}
diff --git a/tooling/nargo_fmt/tests/input/fn.nr b/tooling/nargo_fmt/tests/input/fn.nr
index 1c6d201fa39..03806b0fef9 100644
--- a/tooling/nargo_fmt/tests/input/fn.nr
+++ b/tooling/nargo_fmt/tests/input/fn.nr
@@ -44,3 +44,8 @@ fn main(
 ) {}
 
 pub fn from_baz(x: [Field; crate::foo::MAGIC_NUMBER]) {}
+
+fn whitespace_before_generics <    T   >  (foo: T) {}
+
+fn more_whitespace_before_generics   <    
+T   >  (foo: T) {}

From 49e1b0c0d45565f3e87469b77f2fef0c283f6ea1 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Fri, 21 Jun 2024 09:17:41 -0500
Subject: [PATCH 404/416] fix: Replace panic in monomorphization with an error
 (#5305)

# Description

## Problem\*

## Summary\*

Replaces an `unwrap` and panic in the monomorphizer with an ICE issued
to the user instead. This isn't expected to be issued normally, but is
being issued currently when a `comptime let` variable is used in runtime
code since `comptime let` is still unimplemented in the evaluator.

## Additional Context

This does not fix the underlying `comptime let` error, only the
resulting panic.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/monomorphization/errors.rs | 3 +++
 compiler/noirc_frontend/src/monomorphization/mod.rs    | 6 +++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/compiler/noirc_frontend/src/monomorphization/errors.rs b/compiler/noirc_frontend/src/monomorphization/errors.rs
index 2db570540d6..df61c138c02 100644
--- a/compiler/noirc_frontend/src/monomorphization/errors.rs
+++ b/compiler/noirc_frontend/src/monomorphization/errors.rs
@@ -6,6 +6,7 @@ use crate::hir::comptime::InterpreterError;
 pub enum MonomorphizationError {
     UnknownArrayLength { location: Location },
     TypeAnnotationsNeeded { location: Location },
+    InternalError { message: &'static str, location: Location },
     InterpreterError(InterpreterError),
 }
 
@@ -13,6 +14,7 @@ impl MonomorphizationError {
     fn location(&self) -> Location {
         match self {
             MonomorphizationError::UnknownArrayLength { location }
+            | MonomorphizationError::InternalError { location, .. }
             | MonomorphizationError::TypeAnnotationsNeeded { location } => *location,
             MonomorphizationError::InterpreterError(error) => error.get_location(),
         }
@@ -36,6 +38,7 @@ impl MonomorphizationError {
             }
             MonomorphizationError::TypeAnnotationsNeeded { .. } => "Type annotations needed",
             MonomorphizationError::InterpreterError(error) => return (&error).into(),
+            MonomorphizationError::InternalError { message, .. } => message,
         };
 
         let location = self.location();
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 07820a70b3f..a95fc0e7ace 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -889,7 +889,11 @@ impl<'interner> Monomorphizer<'interner> {
             DefinitionKind::Local(_) => match self.lookup_captured_expr(ident.id) {
                 Some(expr) => expr,
                 None => {
-                    let ident = self.local_ident(&ident)?.unwrap();
+                    let Some(ident) = self.local_ident(&ident)? else {
+                        let location = self.interner.id_location(expr_id);
+                        let message = "ICE: Variable not found during monomorphization";
+                        return Err(MonomorphizationError::InternalError { location, message });
+                    };
                     ast::Expression::Ident(ident)
                 }
             },

From 42d727feb5ce38f50da7daaf4279ae88edde61b4 Mon Sep 17 00:00:00 2001
From: Ary Borenszweig <asterite@gmail.com>
Date: Mon, 24 Jun 2024 15:17:07 -0300
Subject: [PATCH 405/416] chore: Bundle SSA Evaluator Options (#5317)

Better reviewed with "Diff -> Hide whitespace".

# Description

## Problem

Resolves #4667

## Summary

Introduces an `SsaEvaluatorOptions` struct that bundles a bunch of
booleans that are passed down several functions.

## Additional Context

None

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 compiler/noirc_driver/src/lib.rs    |  15 +++--
 compiler/noirc_evaluator/src/ssa.rs | 101 +++++++++++++++-------------
 2 files changed, 62 insertions(+), 54 deletions(-)

diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index dde2bd08d74..4ba9b85f967 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -544,14 +544,15 @@ pub fn compile_no_check(
         return Ok(cached_program.expect("cache must exist for hashes to match"));
     }
     let return_visibility = program.return_visibility;
+    let ssa_evaluator_options = noirc_evaluator::ssa::SsaEvaluatorOptions {
+        enable_ssa_logging: options.show_ssa,
+        enable_brillig_logging: options.show_brillig,
+        force_brillig_output: options.force_brillig,
+        print_codegen_timings: options.benchmark_codegen,
+    };
 
-    let SsaProgramArtifact { program, debug, warnings, names, error_types, .. } = create_program(
-        program,
-        options.show_ssa,
-        options.show_brillig,
-        options.force_brillig,
-        options.benchmark_codegen,
-    )?;
+    let SsaProgramArtifact { program, debug, warnings, names, error_types, .. } =
+        create_program(program, &ssa_evaluator_options)?;
 
     let abi = abi_gen::gen_abi(context, &main_function, return_visibility, error_types);
     let file_map = filter_relevant_files(&debug, &context.file_manager);
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 7e362599fb5..71fb51bf750 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -48,47 +48,51 @@ pub mod ssa_gen;
 /// and Brillig functions for unconstrained execution.
 pub(crate) fn optimize_into_acir(
     program: Program,
-    print_passes: bool,
-    print_brillig_trace: bool,
-    force_brillig_output: bool,
-    print_timings: bool,
+    options: &SsaEvaluatorOptions,
 ) -> Result<Artifacts, RuntimeError> {
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
     let ssa_gen_span_guard = ssa_gen_span.enter();
-    let ssa = SsaBuilder::new(program, print_passes, force_brillig_output, print_timings)?
-        .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
-        .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
-        .run_pass(Ssa::separate_runtime, "After Runtime Separation:")
-        .run_pass(Ssa::resolve_is_unconstrained, "After Resolving IsUnconstrained:")
-        .run_pass(Ssa::inline_functions, "After Inlining:")
-        // Run mem2reg with the CFG separated into blocks
-        .run_pass(Ssa::mem2reg, "After Mem2Reg:")
-        .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
-        .try_run_pass(Ssa::evaluate_assert_constant, "After Assert Constant:")?
-        .try_run_pass(Ssa::unroll_loops_iteratively, "After Unrolling:")?
-        .run_pass(Ssa::simplify_cfg, "After Simplifying:")
-        .run_pass(Ssa::flatten_cfg, "After Flattening:")
-        .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
-        // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
-        .run_pass(Ssa::mem2reg, "After Mem2Reg:")
-        // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
-        // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
-        // This pass must come immediately following `mem2reg` as the succeeding passes
-        // may create an SSA which inlining fails to handle.
-        .run_pass(Ssa::inline_functions_with_no_predicates, "After Inlining:")
-        .run_pass(Ssa::remove_if_else, "After Remove IfElse:")
-        .run_pass(Ssa::fold_constants, "After Constant Folding:")
-        .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffects removal:")
-        .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
-        .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
-        .run_pass(Ssa::array_set_optimization, "After Array Set Optimizations:")
-        .finish();
-
-    let brillig = time("SSA to Brillig", print_timings, || ssa.to_brillig(print_brillig_trace));
+    let ssa = SsaBuilder::new(
+        program,
+        options.enable_ssa_logging,
+        options.force_brillig_output,
+        options.print_codegen_timings,
+    )?
+    .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
+    .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
+    .run_pass(Ssa::separate_runtime, "After Runtime Separation:")
+    .run_pass(Ssa::resolve_is_unconstrained, "After Resolving IsUnconstrained:")
+    .run_pass(Ssa::inline_functions, "After Inlining:")
+    // Run mem2reg with the CFG separated into blocks
+    .run_pass(Ssa::mem2reg, "After Mem2Reg:")
+    .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
+    .try_run_pass(Ssa::evaluate_assert_constant, "After Assert Constant:")?
+    .try_run_pass(Ssa::unroll_loops_iteratively, "After Unrolling:")?
+    .run_pass(Ssa::simplify_cfg, "After Simplifying:")
+    .run_pass(Ssa::flatten_cfg, "After Flattening:")
+    .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
+    // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
+    .run_pass(Ssa::mem2reg, "After Mem2Reg:")
+    // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
+    // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
+    // This pass must come immediately following `mem2reg` as the succeeding passes
+    // may create an SSA which inlining fails to handle.
+    .run_pass(Ssa::inline_functions_with_no_predicates, "After Inlining:")
+    .run_pass(Ssa::remove_if_else, "After Remove IfElse:")
+    .run_pass(Ssa::fold_constants, "After Constant Folding:")
+    .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffects removal:")
+    .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
+    .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
+    .run_pass(Ssa::array_set_optimization, "After Array Set Optimizations:")
+    .finish();
+
+    let brillig = time("SSA to Brillig", options.print_codegen_timings, || {
+        ssa.to_brillig(options.enable_brillig_logging)
+    });
 
     drop(ssa_gen_span_guard);
 
-    time("SSA to ACIR", print_timings, || ssa.into_acir(&brillig))
+    time("SSA to ACIR", options.print_codegen_timings, || ssa.into_acir(&brillig))
 }
 
 // Helper to time SSA passes
@@ -144,17 +148,26 @@ impl SsaProgramArtifact {
     }
 }
 
+pub struct SsaEvaluatorOptions {
+    /// Emit debug information for the intermediate SSA IR
+    pub enable_ssa_logging: bool,
+
+    pub enable_brillig_logging: bool,
+
+    /// Force Brillig output (for step debugging)
+    pub force_brillig_output: bool,
+
+    /// Pretty print benchmark times of each code generation pass
+    pub print_codegen_timings: bool,
+}
+
 /// Compiles the [`Program`] into [`ACIR``][acvm::acir::circuit::Program].
 ///
 /// The output ACIR is backend-agnostic and so must go through a transformation pass before usage in proof generation.
-#[allow(clippy::type_complexity)]
 #[tracing::instrument(level = "trace", skip_all)]
 pub fn create_program(
     program: Program,
-    enable_ssa_logging: bool,
-    enable_brillig_logging: bool,
-    force_brillig_output: bool,
-    print_codegen_timings: bool,
+    options: &SsaEvaluatorOptions,
 ) -> Result<SsaProgramArtifact, RuntimeError> {
     let debug_variables = program.debug_variables.clone();
     let debug_types = program.debug_types.clone();
@@ -163,13 +176,7 @@ pub fn create_program(
     let func_sigs = program.function_signatures.clone();
 
     let recursive = program.recursive;
-    let (generated_acirs, generated_brillig, error_types) = optimize_into_acir(
-        program,
-        enable_ssa_logging,
-        enable_brillig_logging,
-        force_brillig_output,
-        print_codegen_timings,
-    )?;
+    let (generated_acirs, generated_brillig, error_types) = optimize_into_acir(program, options)?;
     assert_eq!(
         generated_acirs.len(),
         func_sigs.len(),

From 7689d59aa12003994cea6a3ff4bf87484e41aa6b Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Mon, 24 Jun 2024 13:30:34 -0500
Subject: [PATCH 406/416] feat: Make macros operate on token streams instead of
 AST nodes (#5301)

# Description

## Problem\*

Resolves https://github.com/noir-lang/noir/issues/5284

## Summary\*

Adds a new `Quoted` type which is the new default output of a `quote {
... }` expression. In addition, a `quote` expression now quotes an
unparsed, raw vector of tokens terminated by the matching closing brace.
This has a number of advantages:

- Quoting code fragments: Since these token streams are not parsed,
there is almost no restriction on their grammar. Code fragments such as
`quote { ) ( }` are valid as long as they're grammatically valid by the
time the macro is unquoted at its call site. The only restriction on the
grammar of these is that they cannot have an unmatched `}` since that
would close the `quote` expression itself. Matched `{` and `}` paris
however, are fine: `quote { look, a block: { foo } }`.
- Since we don't need to parse to a specific grammar rule, we don't need
a new quoted type for each grammar rule we quote (see the existing
`Expr`, `Type`, and `TopLevelItem` types).
- The implementation details are simpler (e.g. this PR net removes
lines).

The current plan is to keep the other macro types (`Expr`, `Type`,
`TopLevelItem`, etc) as optional outputs of `quote` only if they're
specified after the keyword, e.g. `quote Type { Foo<A, B> }`. Since the
new approach of using token streams by default is much more flexible,
there's less of a need for these however.

## Additional Context

The formatting of quote expressions has also been fixed. This was a
necessary change since these expressions hold token streams now instead
of ASTs and thus can't be formatted the old way.

Edit: This does not fix the existing issue with formatting comptime
blocks, only `quote` blocks which were similarly affected.

## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [x] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 compiler/noirc_frontend/src/ast/expression.rs |  18 +-
 .../src/elaborator/expressions.rs             |  18 +-
 .../noirc_frontend/src/elaborator/unquote.rs  | 323 ++----------------
 .../noirc_frontend/src/hir/comptime/errors.rs |  37 +-
 .../src/hir/comptime/interpreter.rs           |  40 +--
 .../src/hir/comptime/interpreter/builtin.rs   | 159 ++++++++-
 .../src/hir/comptime/interpreter/unquote.rs   | 301 ++--------------
 .../noirc_frontend/src/hir/comptime/scan.rs   |   2 +-
 .../noirc_frontend/src/hir/comptime/value.rs  |  38 ++-
 .../src/hir/resolution/resolver.rs            |  10 +-
 .../src/hir/type_check/errors.rs              |   6 +-
 .../noirc_frontend/src/hir/type_check/expr.rs |   4 +-
 compiler/noirc_frontend/src/hir_def/expr.rs   |  15 +-
 compiler/noirc_frontend/src/hir_def/types.rs  |  25 +-
 compiler/noirc_frontend/src/lexer/errors.rs   |  12 +
 compiler/noirc_frontend/src/lexer/lexer.rs    | 105 +++++-
 compiler/noirc_frontend/src/lexer/token.rs    |  44 ++-
 compiler/noirc_frontend/src/node_interner.rs  |   2 +-
 .../noirc_frontend/src/noir_parser.lalrpop    |   1 -
 compiler/noirc_frontend/src/parser/mod.rs     |   4 +-
 compiler/noirc_frontend/src/parser/parser.rs  |  49 ++-
 .../src/parser/parser/primitives.rs           |   7 +
 .../noirc_frontend/src/parser/parser/types.rs |   9 +-
 compiler/noirc_frontend/src/tests.rs          |  24 ++
 noir_stdlib/src/lib.nr                        |   1 +
 noir_stdlib/src/meta.nr                       |   1 +
 noir_stdlib/src/meta/type_def.nr              |  16 +
 .../comptime_type_definition/Nargo.toml       |   7 +
 .../comptime_type_definition/src/main.nr      |  13 +
 .../derive_impl/Nargo.toml                    |   7 +
 .../derive_impl/src/main.nr                   |  44 +++
 .../compile_success_empty/macros/src/main.nr  |   6 +-
 tooling/nargo_fmt/src/rewrite/expr.rs         |   5 +-
 33 files changed, 658 insertions(+), 695 deletions(-)
 create mode 100644 noir_stdlib/src/meta.nr
 create mode 100644 noir_stdlib/src/meta/type_def.nr
 create mode 100644 test_programs/compile_success_empty/comptime_type_definition/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/comptime_type_definition/src/main.nr
 create mode 100644 test_programs/compile_success_empty/derive_impl/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/derive_impl/src/main.nr

diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 075df4ee4e3..2657869a9d7 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -7,7 +7,7 @@ use crate::ast::{
 };
 use crate::macros_api::StructId;
 use crate::node_interner::ExprId;
-use crate::token::{Attributes, Token};
+use crate::token::{Attributes, Token, Tokens};
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
@@ -33,18 +33,10 @@ pub enum ExpressionKind {
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
-    Quote(BlockExpression, Span),
+    Quote(Tokens),
     Unquote(Box<Expression>),
     Comptime(BlockExpression, Span),
 
-    /// Unquote expressions are replaced with UnquoteMarkers when Quoted
-    /// expressions are resolved. Since the expression being quoted remains an
-    /// ExpressionKind (rather than a resolved ExprId), the UnquoteMarker must be
-    /// here in the AST even though it is technically HIR-only.
-    /// Each usize in an UnquoteMarker is an index which corresponds to the index of the
-    /// expression in the Hir::Quote expression list to replace it with.
-    UnquoteMarker(usize),
-
     // This variant is only emitted when inlining the result of comptime
     // code. It is used to translate function values back into the AST while
     // guaranteeing they have the same instantiated type and definition id without resolving again.
@@ -557,12 +549,14 @@ impl Display for ExpressionKind {
             }
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
-            Quote(block, _) => write!(f, "quote {block}"),
             Comptime(block, _) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
             Unquote(expr) => write!(f, "$({expr})"),
-            UnquoteMarker(index) => write!(f, "${index}"),
+            Quote(tokens) => {
+                let tokens = vecmap(&tokens.0, ToString::to_string);
+                write!(f, "quote {{ {} }}", tokens.join(" "))
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index d6ad752b67a..9d864a0de91 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -18,7 +18,7 @@ use crate::{
             HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
             HirConstructorExpression, HirIfExpression, HirIndexExpression, HirInfixExpression,
             HirLambda, HirMemberAccess, HirMethodCallExpression, HirMethodReference,
-            HirPrefixExpression, HirQuoted,
+            HirPrefixExpression,
         },
         traits::TraitConstraint,
     },
@@ -28,6 +28,7 @@ use crate::{
         MethodCallExpression, PrefixExpression,
     },
     node_interner::{DefinitionKind, ExprId, FuncId},
+    token::Tokens,
     QuotedType, Shared, StructType, Type,
 };
 
@@ -58,7 +59,7 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Tuple(tuple) => self.elaborate_tuple(tuple),
             ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
             ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
-            ExpressionKind::Quote(quote, _) => self.elaborate_quote(quote),
+            ExpressionKind::Quote(quote) => self.elaborate_quote(quote),
             ExpressionKind::Comptime(comptime, _) => {
                 return self.elaborate_comptime_block(comptime, expr.span)
             }
@@ -68,9 +69,6 @@ impl<'context> Elaborator<'context> {
                 self.push_err(ResolverError::UnquoteUsedOutsideQuote { span: expr.span });
                 (HirExpression::Error, Type::Error)
             }
-            ExpressionKind::UnquoteMarker(index) => {
-                unreachable!("UnquoteMarker({index}) remaining in runtime code")
-            }
         };
         let id = self.interner.push_expr(hir_expr);
         self.interner.push_expr_location(id, expr.span, self.file);
@@ -646,11 +644,9 @@ impl<'context> Elaborator<'context> {
         (expr, Type::Function(arg_types, Box::new(body_type), Box::new(env_type)))
     }
 
-    fn elaborate_quote(&mut self, mut block: BlockExpression) -> (HirExpression, Type) {
-        let mut unquoted_exprs = Vec::new();
-        self.find_unquoted_exprs_in_block(&mut block, &mut unquoted_exprs);
-        let quoted = HirQuoted { quoted_block: block, unquoted_exprs };
-        (HirExpression::Quote(quoted), Type::Quoted(QuotedType::Expr))
+    fn elaborate_quote(&mut self, mut tokens: Tokens) -> (HirExpression, Type) {
+        tokens = self.find_unquoted_exprs_tokens(tokens);
+        (HirExpression::Quote(tokens), Type::Quoted(QuotedType::Quoted))
     }
 
     fn elaborate_comptime_block(&mut self, block: BlockExpression, span: Span) -> (ExprId, Type) {
@@ -716,7 +712,7 @@ impl<'context> Elaborator<'context> {
         location: Location,
         return_type: Type,
     ) -> Option<(HirExpression, Type)> {
-        self.unify(&return_type, &Type::Quoted(QuotedType::Expr), || {
+        self.unify(&return_type, &Type::Quoted(QuotedType::Quoted), || {
             TypeCheckError::MacroReturningNonExpr { typ: return_type.clone(), span: location.span }
         });
 
diff --git a/compiler/noirc_frontend/src/elaborator/unquote.rs b/compiler/noirc_frontend/src/elaborator/unquote.rs
index 6767f471f16..ed12ba21398 100644
--- a/compiler/noirc_frontend/src/elaborator/unquote.rs
+++ b/compiler/noirc_frontend/src/elaborator/unquote.rs
@@ -1,306 +1,41 @@
 use crate::{
-    ast::{
-        ArrayLiteral, AssignStatement, ConstrainStatement, ConstructorExpression, IfExpression,
-        InfixExpression, Lambda,
-    },
-    macros_api::{
-        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind,
-        ForLoopStatement, ForRange, IndexExpression, LetStatement, Literal, MemberAccessExpression,
-        MethodCallExpression, PrefixExpression, Statement, StatementKind,
-    },
-    node_interner::ExprId,
+    macros_api::Path,
+    token::{SpannedToken, Token, Tokens},
 };
 
 use super::Elaborator;
 
 impl<'a> Elaborator<'a> {
-    pub fn find_unquoted_exprs_in_block(
-        &mut self,
-        block: &mut BlockExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        for statement in &mut block.statements {
-            self.find_unquoted_exprs_in_statement(statement, unquoted_exprs);
-        }
-    }
-
-    fn find_unquoted_exprs_in_statement(
-        &mut self,
-        statement: &mut Statement,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        match &mut statement.kind {
-            StatementKind::Let(let_) => self.find_unquoted_exprs_in_let(let_, unquoted_exprs),
-            StatementKind::Constrain(constrain) => {
-                self.find_unquoted_exprs_in_constrain(constrain, unquoted_exprs);
-            }
-            StatementKind::Expression(expr) => {
-                self.find_unquoted_exprs_in_expr(expr, unquoted_exprs);
-            }
-            StatementKind::Assign(assign) => {
-                self.find_unquoted_exprs_in_assign(assign, unquoted_exprs);
-            }
-            StatementKind::For(for_) => self.find_unquoted_exprs_in_for(for_, unquoted_exprs),
-            StatementKind::Break => (),
-            StatementKind::Continue => (),
-            StatementKind::Comptime(comptime) => {
-                self.find_unquoted_exprs_in_statement(comptime, unquoted_exprs);
-            }
-            StatementKind::Semi(expr) => self.find_unquoted_exprs_in_expr(expr, unquoted_exprs),
-            StatementKind::Error => (),
-        }
-    }
-
-    fn find_unquoted_exprs_in_constrain(
-        &mut self,
-        constrain: &mut ConstrainStatement,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut constrain.0, unquoted_exprs);
-        if let Some(msg) = constrain.1.as_mut() {
-            self.find_unquoted_exprs_in_expr(msg, unquoted_exprs);
-        }
-    }
-
-    fn find_unquoted_exprs_in_let(
-        &mut self,
-        let_: &mut LetStatement,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut let_.expression, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_assign(
-        &mut self,
-        assign: &mut AssignStatement,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut assign.expression, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_for(
-        &mut self,
-        for_: &mut ForLoopStatement,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        match &mut for_.range {
-            ForRange::Range(start, end) => {
-                self.find_unquoted_exprs_in_expr(start, unquoted_exprs);
-                self.find_unquoted_exprs_in_expr(end, unquoted_exprs);
-            }
-            ForRange::Array(array) => {
-                self.find_unquoted_exprs_in_expr(array, unquoted_exprs);
-            }
-        };
-        self.find_unquoted_exprs_in_expr(&mut for_.block, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_expr(
-        &mut self,
-        expr: &mut Expression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        match &mut expr.kind {
-            ExpressionKind::Literal(literal) => {
-                self.find_unquoted_exprs_in_literal(literal, unquoted_exprs);
-            }
-            ExpressionKind::Block(block) => {
-                self.find_unquoted_exprs_in_block(block, unquoted_exprs);
-            }
-            ExpressionKind::Prefix(prefix) => {
-                self.find_unquoted_exprs_in_prefix(prefix, unquoted_exprs);
-            }
-            ExpressionKind::Index(index) => {
-                self.find_unquoted_exprs_in_index(index, unquoted_exprs);
-            }
-            ExpressionKind::Call(call) => self.find_unquoted_exprs_in_call(call, unquoted_exprs),
-            ExpressionKind::MethodCall(call) => {
-                self.find_unquoted_exprs_in_method_call(call, unquoted_exprs);
-            }
-            ExpressionKind::Constructor(constructor) => {
-                self.find_unquoted_exprs_in_constructor(constructor, unquoted_exprs);
-            }
-            ExpressionKind::MemberAccess(access) => {
-                self.find_unquoted_exprs_in_access(access, unquoted_exprs);
-            }
-            ExpressionKind::Cast(cast) => self.find_unquoted_exprs_in_cast(cast, unquoted_exprs),
-            ExpressionKind::Infix(infix) => {
-                self.find_unquoted_exprs_in_infix(infix, unquoted_exprs);
-            }
-            ExpressionKind::If(if_) => self.find_unquoted_exprs_in_if(if_, unquoted_exprs),
-            ExpressionKind::Variable(_, _) => (),
-            ExpressionKind::Tuple(tuple) => {
-                self.find_unquoted_exprs_in_tuple(tuple, unquoted_exprs);
-            }
-            ExpressionKind::Lambda(lambda) => {
-                self.find_unquoted_exprs_in_lambda(lambda, unquoted_exprs);
-            }
-            ExpressionKind::Parenthesized(expr) => {
-                self.find_unquoted_exprs_in_expr(expr, unquoted_exprs);
-            }
-            ExpressionKind::Quote(quote, _) => {
-                self.find_unquoted_exprs_in_block(quote, unquoted_exprs);
-            }
-            ExpressionKind::Comptime(block, _) => {
-                self.find_unquoted_exprs_in_block(block, unquoted_exprs);
-            }
-            ExpressionKind::Resolved(_) => (),
-            ExpressionKind::Error => (),
-            ExpressionKind::UnquoteMarker(_) => (),
-            ExpressionKind::Unquote(unquoted) => {
-                // Avoid an expensive clone for unquoted
-                let empty_expr = Expression::new(ExpressionKind::Error, unquoted.span);
-                let unquote = std::mem::replace(unquoted.as_mut(), empty_expr);
-                self.replace_unquote(expr, unquote, unquoted_exprs);
-            }
-        }
-    }
-
-    fn find_unquoted_exprs_in_literal(
-        &mut self,
-        literal: &mut Literal,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        match literal {
-            Literal::Array(array) | Literal::Slice(array) => match array {
-                ArrayLiteral::Standard(elements) => {
-                    for element in elements {
-                        self.find_unquoted_exprs_in_expr(element, unquoted_exprs);
+    /// Go through the given tokens looking for a '$' token followed by a variable to unquote.
+    /// Each time these two tokens are found, they are replaced by a new UnquoteMarker token
+    /// containing the ExprId of the resolved variable to unquote.
+    pub fn find_unquoted_exprs_tokens(&mut self, tokens: Tokens) -> Tokens {
+        let token_count = tokens.0.len();
+        let mut new_tokens = Vec::with_capacity(token_count);
+        let mut tokens = tokens.0.into_iter();
+
+        while let Some(token) = tokens.next() {
+            let is_unquote = matches!(token.token(), Token::DollarSign);
+            new_tokens.push(token);
+
+            if is_unquote {
+                if let Some(next) = tokens.next() {
+                    let span = next.to_span();
+
+                    match next.into_token() {
+                        Token::Ident(name) => {
+                            // Don't want the leading `$` anymore
+                            new_tokens.pop();
+                            let path = Path::from_single(name, span);
+                            let (expr_id, _) = self.elaborate_variable(path, None);
+                            new_tokens.push(SpannedToken::new(Token::UnquoteMarker(expr_id), span));
+                        }
+                        other_next => new_tokens.push(SpannedToken::new(other_next, span)),
                     }
                 }
-                ArrayLiteral::Repeated { repeated_element, length } => {
-                    self.find_unquoted_exprs_in_expr(repeated_element, unquoted_exprs);
-                    self.find_unquoted_exprs_in_expr(length, unquoted_exprs);
-                }
-            },
-            Literal::Bool(_)
-            | Literal::Integer(_, _)
-            | Literal::Str(_)
-            | Literal::RawStr(_, _)
-            | Literal::FmtStr(_)
-            | Literal::Unit => (),
-        }
-    }
-
-    fn find_unquoted_exprs_in_prefix(
-        &mut self,
-        prefix: &mut PrefixExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut prefix.rhs, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_index(
-        &mut self,
-        index: &mut IndexExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut index.collection, unquoted_exprs);
-        self.find_unquoted_exprs_in_expr(&mut index.index, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_call(
-        &mut self,
-        call: &mut CallExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut call.func, unquoted_exprs);
-
-        for arg in &mut call.arguments {
-            self.find_unquoted_exprs_in_expr(arg, unquoted_exprs);
-        }
-    }
-
-    fn find_unquoted_exprs_in_method_call(
-        &mut self,
-        call: &mut MethodCallExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut call.object, unquoted_exprs);
-
-        for arg in &mut call.arguments {
-            self.find_unquoted_exprs_in_expr(arg, unquoted_exprs);
-        }
-    }
-
-    fn find_unquoted_exprs_in_constructor(
-        &mut self,
-        constructor: &mut ConstructorExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        for (_, field) in &mut constructor.fields {
-            self.find_unquoted_exprs_in_expr(field, unquoted_exprs);
-        }
-    }
-
-    fn find_unquoted_exprs_in_access(
-        &mut self,
-        member_access: &mut MemberAccessExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut member_access.lhs, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_cast(
-        &mut self,
-        cast: &mut CastExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut cast.lhs, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_infix(
-        &mut self,
-        infix: &mut InfixExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut infix.lhs, unquoted_exprs);
-        self.find_unquoted_exprs_in_expr(&mut infix.rhs, unquoted_exprs);
-    }
-
-    fn find_unquoted_exprs_in_if(
-        &mut self,
-        if_: &mut IfExpression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut if_.condition, unquoted_exprs);
-        self.find_unquoted_exprs_in_expr(&mut if_.consequence, unquoted_exprs);
-
-        if let Some(alternate) = if_.alternative.as_mut() {
-            self.find_unquoted_exprs_in_expr(alternate, unquoted_exprs);
-        }
-    }
-
-    fn find_unquoted_exprs_in_tuple(
-        &mut self,
-        tuple: &mut [Expression],
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        for field in tuple {
-            self.find_unquoted_exprs_in_expr(field, unquoted_exprs);
+            }
         }
-    }
-
-    fn find_unquoted_exprs_in_lambda(
-        &mut self,
-        lambda: &mut Lambda,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        self.find_unquoted_exprs_in_expr(&mut lambda.body, unquoted_exprs);
-    }
 
-    /// Elaborate and store the unquoted expression in the given vector, then
-    /// replace it with an unquote expression with an UnquoteMarker expression to mark the position
-    /// to replace it with later.
-    fn replace_unquote(
-        &mut self,
-        expr: &mut Expression,
-        unquoted: Expression,
-        unquoted_exprs: &mut Vec<ExprId>,
-    ) {
-        let (expr_id, _) = self.elaborate_expression(unquoted);
-        let unquote_marker_id = unquoted_exprs.len();
-        unquoted_exprs.push(expr_id);
-        expr.kind = ExpressionKind::UnquoteMarker(unquote_marker_id);
+        Tokens(new_tokens)
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 05962420f8a..4eab12af308 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -1,5 +1,11 @@
-use crate::{hir::def_collector::dc_crate::CompilationError, Type};
+use std::rc::Rc;
+
+use crate::{
+    hir::def_collector::dc_crate::CompilationError, parser::ParserError, token::Tokens, Type,
+};
 use acvm::{acir::AcirField, FieldElement};
+use fm::FileId;
+use iter_extended::vecmap;
 use noirc_errors::{CustomDiagnostic, Location};
 
 use super::value::Value;
@@ -35,6 +41,7 @@ pub enum InterpreterError {
     NonStructInConstructor { typ: Type, location: Location },
     CannotInlineMacro { value: Value, location: Location },
     UnquoteFoundDuringEvaluation { location: Location },
+    FailedToParseMacro { error: ParserError, tokens: Rc<Tokens>, rule: &'static str, file: FileId },
 
     Unimplemented { item: String, location: Location },
 
@@ -97,6 +104,9 @@ impl InterpreterError {
             | InterpreterError::Unimplemented { location, .. }
             | InterpreterError::BreakNotInLoop { location, .. }
             | InterpreterError::ContinueNotInLoop { location, .. } => *location,
+            InterpreterError::FailedToParseMacro { error, file, .. } => {
+                Location::new(error.span(), *file)
+            }
             InterpreterError::Break | InterpreterError::Continue => {
                 panic!("Tried to get the location of Break/Continue error!")
             }
@@ -258,6 +268,31 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let secondary = "This is a bug".into();
                 CustomDiagnostic::simple_error(msg, secondary, location.span)
             }
+            InterpreterError::FailedToParseMacro { error, tokens, rule, file: _ } => {
+                let message = format!("Failed to parse macro's token stream into {rule}");
+                let tokens = vecmap(&tokens.0, ToString::to_string).join(" ");
+
+                // 10 is an aribtrary number of tokens here chosen to fit roughly onto one line
+                let token_stream = if tokens.len() > 10 {
+                    format!("The resulting token stream was: {tokens}")
+                } else {
+                    format!(
+                        "The resulting token stream was: (stream starts on next line)\n  {tokens}"
+                    )
+                };
+
+                let push_the_problem_on_the_library_author = "To avoid this error in the future, try adding input validation to your macro. Erroring out early with an `assert` can be a good way to provide a user-friendly error message".into();
+
+                let mut diagnostic = CustomDiagnostic::from(error);
+                // Swap the parser's primary note to become the secondary note so that it is
+                // more clear this error originates from failing to parse a macro.
+                let secondary = std::mem::take(&mut diagnostic.message);
+                diagnostic.add_secondary(secondary, error.span());
+                diagnostic.message = message;
+                diagnostic.add_note(token_stream);
+                diagnostic.add_note(push_the_problem_on_the_library_author);
+                diagnostic
+            }
             InterpreterError::Unimplemented { item, location } => {
                 let msg = format!("{item} is currently unimplemented");
                 CustomDiagnostic::simple_error(msg, String::new(), location.span)
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 21b6897f5dd..5e236a2b980 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -7,7 +7,7 @@ use noirc_errors::Location;
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness};
-use crate::hir_def::expr::HirQuoted;
+use crate::token::Tokens;
 use crate::{
     hir_def::{
         expr::{
@@ -26,8 +26,6 @@ use crate::{
     Shared, Type, TypeBinding, TypeBindings, TypeVariableKind,
 };
 
-use self::unquote::UnquoteArgs;
-
 use super::errors::{IResult, InterpreterError};
 use super::value::Value;
 
@@ -100,14 +98,7 @@ impl<'a> Interpreter<'a> {
             .expect("all builtin functions must contain a function  attribute which contains the opcode which it links to");
 
         if let Some(builtin) = func_attrs.builtin() {
-            match builtin.as_str() {
-                "array_len" => builtin::array_len(&arguments),
-                "as_slice" => builtin::as_slice(arguments),
-                _ => {
-                    let item = format!("Comptime evaluation for builtin function {builtin}");
-                    Err(InterpreterError::Unimplemented { item, location })
-                }
-            }
+            builtin::call_builtin(self.interner, builtin, arguments, location)
         } else if let Some(foreign) = func_attrs.foreign() {
             let item = format!("Comptime evaluation for foreign functions like {foreign}");
             Err(InterpreterError::Unimplemented { item, location })
@@ -343,9 +334,9 @@ impl<'a> Interpreter<'a> {
             HirExpression::If(if_) => self.evaluate_if(if_, id),
             HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
-            HirExpression::Quote(block) => self.evaluate_quote(block, id),
+            HirExpression::Quote(tokens) => self.evaluate_quote(tokens, id),
             HirExpression::Comptime(block) => self.evaluate_block(block),
-            HirExpression::Unquote(block) => {
+            HirExpression::Unquote(tokens) => {
                 // An Unquote expression being found is indicative of a macro being
                 // expanded within another comptime fn which we don't currently support.
                 let location = self.interner.expr_location(&id);
@@ -936,6 +927,18 @@ impl<'a> Interpreter<'a> {
     fn evaluate_access(&mut self, access: HirMemberAccess, id: ExprId) -> IResult<Value> {
         let (fields, struct_type) = match self.evaluate(access.lhs)? {
             Value::Struct(fields, typ) => (fields, typ),
+            Value::Tuple(fields) => {
+                let (fields, field_types): (HashMap<Rc<String>, Value>, Vec<Type>) = fields
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, field)| {
+                        let field_type = field.get_type().into_owned();
+                        let key_val_pair = (Rc::new(i.to_string()), field);
+                        (key_val_pair, field_type)
+                    })
+                    .unzip();
+                (fields, Type::Tuple(field_types))
+            }
             value => {
                 let location = self.interner.expr_location(&id);
                 return Err(InterpreterError::NonTupleOrStructInMemberAccess { value, location });
@@ -1136,13 +1139,10 @@ impl<'a> Interpreter<'a> {
         Ok(Value::Closure(lambda, environment, typ))
     }
 
-    fn evaluate_quote(&mut self, mut quoted: HirQuoted, expr_id: ExprId) -> IResult<Value> {
-        let file = self.interner.expr_location(&expr_id).file;
-        let values = try_vecmap(quoted.unquoted_exprs, |value| self.evaluate(value))?;
-        let args = UnquoteArgs { values, file };
-
-        self.substitute_unquoted_values_into_block(&mut quoted.quoted_block, &args);
-        Ok(Value::Code(Rc::new(quoted.quoted_block)))
+    fn evaluate_quote(&mut self, mut tokens: Tokens, expr_id: ExprId) -> IResult<Value> {
+        let location = self.interner.expr_location(&expr_id);
+        tokens = self.substitute_unquoted_values_into_tokens(tokens, location)?;
+        Ok(Value::Code(Rc::new(tokens)))
     }
 
     pub fn evaluate_statement(&mut self, statement: StmtId) -> IResult<Value> {
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
index 9216ba271c1..cccc9c6d545 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
@@ -1,11 +1,36 @@
+use std::rc::Rc;
+
 use noirc_errors::Location;
 
 use crate::{
-    hir::comptime::{errors::IResult, Value},
-    Type,
+    hir::comptime::{errors::IResult, InterpreterError, Value},
+    lexer::Lexer,
+    macros_api::NodeInterner,
+    token::{SpannedToken, Token, Tokens},
+    QuotedType, Type,
 };
 
-pub(super) fn array_len(arguments: &[(Value, Location)]) -> IResult<Value> {
+pub(super) fn call_builtin(
+    interner: &NodeInterner,
+    name: &str,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    match name {
+        "array_len" => array_len(&arguments),
+        "as_slice" => as_slice(arguments),
+        "slice_push_back" => slice_push_back(arguments),
+        "type_def_as_type" => type_def_as_type(interner, arguments),
+        "type_def_generics" => type_def_generics(interner, arguments),
+        "type_def_fields" => type_def_fields(interner, arguments),
+        _ => {
+            let item = format!("Comptime evaluation for builtin function {name}");
+            Err(InterpreterError::Unimplemented { item, location })
+        }
+    }
+}
+
+fn array_len(arguments: &[(Value, Location)]) -> IResult<Value> {
     assert_eq!(arguments.len(), 1, "ICE: `array_len` should only receive a single argument");
     match &arguments[0].0 {
         Value::Array(values, _) | Value::Slice(values, _) => Ok(Value::U32(values.len() as u32)),
@@ -14,7 +39,7 @@ pub(super) fn array_len(arguments: &[(Value, Location)]) -> IResult<Value> {
     }
 }
 
-pub(super) fn as_slice(mut arguments: Vec<(Value, Location)>) -> IResult<Value> {
+fn as_slice(mut arguments: Vec<(Value, Location)>) -> IResult<Value> {
     assert_eq!(arguments.len(), 1, "ICE: `as_slice` should only receive a single argument");
     let (array, _) = arguments.pop().unwrap();
     match array {
@@ -23,3 +48,129 @@ pub(super) fn as_slice(mut arguments: Vec<(Value, Location)>) -> IResult<Value>
         _ => unreachable!("ICE: Cannot convert types other than arrays into slices"),
     }
 }
+
+fn slice_push_back(mut arguments: Vec<(Value, Location)>) -> IResult<Value> {
+    assert_eq!(arguments.len(), 2, "ICE: `slice_push_back` should only receive two arguments");
+    let (element, _) = arguments.pop().unwrap();
+    let (slice, _) = arguments.pop().unwrap();
+    match slice {
+        Value::Slice(mut values, typ) => {
+            values.push_back(element);
+            Ok(Value::Slice(values, typ))
+        }
+        // Type checking should prevent this branch being taken.
+        _ => unreachable!("ICE: `slice_push_back` expects a slice as its first argument"),
+    }
+}
+
+/// fn as_type(self) -> Quoted
+fn type_def_as_type(
+    interner: &NodeInterner,
+    mut arguments: Vec<(Value, Location)>,
+) -> IResult<Value> {
+    assert_eq!(arguments.len(), 1, "ICE: `generics` should only receive a single argument");
+    let (type_def, span) = match arguments.pop() {
+        Some((Value::TypeDefinition(id), location)) => (id, location.span),
+        other => {
+            unreachable!("ICE: `as_type` expected a `TypeDefinition` argument, found {other:?}")
+        }
+    };
+
+    let struct_def = interner.get_struct(type_def);
+    let struct_def = struct_def.borrow();
+    let make_token = |name| SpannedToken::new(Token::Str(name), span);
+
+    let mut tokens = vec![make_token(struct_def.name.to_string())];
+
+    for (i, generic) in struct_def.generics.iter().enumerate() {
+        if i != 0 {
+            tokens.push(SpannedToken::new(Token::Comma, span));
+        }
+        tokens.push(make_token(generic.borrow().to_string()));
+    }
+
+    Ok(Value::Code(Rc::new(Tokens(tokens))))
+}
+
+/// fn generics(self) -> [Quoted]
+fn type_def_generics(
+    interner: &NodeInterner,
+    mut arguments: Vec<(Value, Location)>,
+) -> IResult<Value> {
+    assert_eq!(arguments.len(), 1, "ICE: `generics` should only receive a single argument");
+    let (type_def, span) = match arguments.pop() {
+        Some((Value::TypeDefinition(id), location)) => (id, location.span),
+        other => {
+            unreachable!("ICE: `as_type` expected a `TypeDefinition` argument, found {other:?}")
+        }
+    };
+
+    let struct_def = interner.get_struct(type_def);
+
+    let generics = struct_def
+        .borrow()
+        .generics
+        .iter()
+        .map(|generic| {
+            let name = SpannedToken::new(Token::Str(generic.borrow().to_string()), span);
+            Value::Code(Rc::new(Tokens(vec![name])))
+        })
+        .collect();
+
+    let typ = Type::Slice(Box::new(Type::Quoted(QuotedType::Quoted)));
+    Ok(Value::Slice(generics, typ))
+}
+
+/// fn fields(self) -> [(Quoted, Quoted)]
+/// Returns (name, type) pairs of each field of this TypeDefinition
+fn type_def_fields(
+    interner: &NodeInterner,
+    mut arguments: Vec<(Value, Location)>,
+) -> IResult<Value> {
+    assert_eq!(arguments.len(), 1, "ICE: `generics` should only receive a single argument");
+    let (type_def, span) = match arguments.pop() {
+        Some((Value::TypeDefinition(id), location)) => (id, location.span),
+        other => {
+            unreachable!("ICE: `as_type` expected a `TypeDefinition` argument, found {other:?}")
+        }
+    };
+
+    let struct_def = interner.get_struct(type_def);
+    let struct_def = struct_def.borrow();
+
+    let make_token = |name| SpannedToken::new(Token::Str(name), span);
+    let make_quoted = |tokens| Value::Code(Rc::new(Tokens(tokens)));
+
+    let mut fields = im::Vector::new();
+
+    for (name, typ) in struct_def.get_fields_as_written() {
+        let name = make_quoted(vec![make_token(name)]);
+        let typ = Value::Code(Rc::new(type_to_tokens(&typ)?));
+        fields.push_back(Value::Tuple(vec![name, typ]));
+    }
+
+    let typ = Type::Slice(Box::new(Type::Tuple(vec![
+        Type::Quoted(QuotedType::Quoted),
+        Type::Quoted(QuotedType::Quoted),
+    ])));
+    Ok(Value::Slice(fields, typ))
+}
+
+/// FIXME(https://github.com/noir-lang/noir/issues/5309): This code is temporary.
+/// It will produce poor results for type variables and will result in incorrect
+/// spans on the returned tokens.
+fn type_to_tokens(typ: &Type) -> IResult<Tokens> {
+    let (mut tokens, mut errors) = Lexer::lex(&typ.to_string());
+
+    if let Some(last) = tokens.0.last() {
+        if matches!(last.token(), Token::EOF) {
+            tokens.0.pop();
+        }
+    }
+
+    if !errors.is_empty() {
+        let error = errors.swap_remove(0);
+        todo!("Got lexer error: {error}")
+    }
+    Ok(tokens)
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs
index 58ca345ca90..a1ceb27afb2 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/unquote.rs
@@ -1,287 +1,42 @@
-use fm::FileId;
 use noirc_errors::Location;
 
 use crate::{
-    ast::{
-        ArrayLiteral, AssignStatement, ConstrainStatement, ConstructorExpression, IfExpression,
-        InfixExpression, Lambda,
-    },
-    hir::comptime::{errors::IResult, Value},
-    macros_api::{
-        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind,
-        ForLoopStatement, ForRange, IndexExpression, LetStatement, Literal, MemberAccessExpression,
-        MethodCallExpression, PrefixExpression, Statement, StatementKind,
-    },
+    hir::comptime::{errors::IResult, value::unwrap_rc, Value},
+    token::{SpannedToken, Token, Tokens},
 };
 
 use super::Interpreter;
 
-pub(super) struct UnquoteArgs {
-    pub(super) values: Vec<Value>,
-    pub(super) file: FileId,
-}
-
 impl<'a> Interpreter<'a> {
-    pub(super) fn substitute_unquoted_values_into_block(
-        &mut self,
-        block: &mut BlockExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        for statement in &mut block.statements {
-            self.substitute_unquoted_into_statement(statement, args)?;
-        }
-        Ok(())
-    }
-
-    fn substitute_unquoted_into_statement(
-        &mut self,
-        statement: &mut Statement,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        match &mut statement.kind {
-            StatementKind::Let(let_) => self.substitute_unquoted_into_let(let_, args),
-            StatementKind::Constrain(constrain) => {
-                self.substitute_unquoted_into_constrain(constrain, args)
-            }
-            StatementKind::Expression(expr) => self.substitute_unquoted_into_expr(expr, args),
-            StatementKind::Assign(assign) => self.substitute_unquoted_into_assign(assign, args),
-            StatementKind::For(for_) => self.substitute_unquoted_into_for(for_, args),
-            StatementKind::Break => Ok(()),
-            StatementKind::Continue => Ok(()),
-            StatementKind::Comptime(comptime) => {
-                self.substitute_unquoted_into_statement(comptime, args)
-            }
-            StatementKind::Semi(expr) => self.substitute_unquoted_into_expr(expr, args),
-            StatementKind::Error => Ok(()),
-        }
-    }
-
-    fn substitute_unquoted_into_constrain(
-        &mut self,
-        constrain: &mut ConstrainStatement,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut constrain.0, args)?;
-        if let Some(msg) = constrain.1.as_mut() {
-            self.substitute_unquoted_into_expr(msg, args)?;
-        }
-        Ok(())
-    }
-
-    fn substitute_unquoted_into_let(
-        &mut self,
-        let_: &mut LetStatement,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut let_.expression, args)
-    }
-
-    fn substitute_unquoted_into_assign(
-        &mut self,
-        assign: &mut AssignStatement,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut assign.expression, args)
-    }
-
-    fn substitute_unquoted_into_for(
-        &mut self,
-        for_: &mut ForLoopStatement,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        match &mut for_.range {
-            ForRange::Range(start, end) => {
-                self.substitute_unquoted_into_expr(start, args)?;
-                self.substitute_unquoted_into_expr(end, args)?;
-            }
-            ForRange::Array(array) => {
-                self.substitute_unquoted_into_expr(array, args)?;
-            }
-        };
-        self.substitute_unquoted_into_expr(&mut for_.block, args)
-    }
-
-    fn substitute_unquoted_into_expr(
-        &mut self,
-        expr: &mut Expression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        match &mut expr.kind {
-            ExpressionKind::Literal(literal) => {
-                self.substitute_unquoted_into_literal(literal, args)
-            }
-            ExpressionKind::Block(block) => self.substitute_unquoted_values_into_block(block, args),
-            ExpressionKind::Prefix(prefix) => self.substitute_unquoted_into_prefix(prefix, args),
-            ExpressionKind::Index(index) => self.substitute_unquoted_into_index(index, args),
-            ExpressionKind::Call(call) => self.substitute_unquoted_into_call(call, args),
-            ExpressionKind::MethodCall(call) => {
-                self.substitute_unquoted_into_method_call(call, args)
-            }
-            ExpressionKind::Constructor(constructor) => {
-                self.substitute_unquoted_into_constructor(constructor, args)
-            }
-            ExpressionKind::MemberAccess(access) => {
-                self.substitute_unquoted_into_access(access, args)
-            }
-            ExpressionKind::Cast(cast) => self.substitute_unquoted_into_cast(cast, args),
-            ExpressionKind::Infix(infix) => self.substitute_unquoted_into_infix(infix, args),
-            ExpressionKind::If(if_) => self.substitute_unquoted_into_if(if_, args),
-            ExpressionKind::Variable(_, _) => Ok(()),
-            ExpressionKind::Tuple(tuple) => self.substitute_unquoted_into_tuple(tuple, args),
-            ExpressionKind::Lambda(lambda) => self.substitute_unquoted_into_lambda(lambda, args),
-            ExpressionKind::Parenthesized(expr) => self.substitute_unquoted_into_expr(expr, args),
-            ExpressionKind::Quote(quote, _) => {
-                self.substitute_unquoted_values_into_block(quote, args)
-            }
-            ExpressionKind::Unquote(unquote) => self.substitute_unquoted_into_expr(unquote, args),
-            ExpressionKind::Comptime(comptime, _) => {
-                self.substitute_unquoted_values_into_block(comptime, args)
-            }
-            ExpressionKind::Resolved(_) => Ok(()),
-            ExpressionKind::Error => Ok(()),
-            ExpressionKind::UnquoteMarker(index) => {
-                let location = Location::new(expr.span, args.file);
-                *expr = args.values[*index].clone().into_expression(self.interner, location)?;
-                Ok(())
-            }
-        }
-    }
-
-    fn substitute_unquoted_into_literal(
-        &mut self,
-        literal: &mut Literal,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        match literal {
-            Literal::Array(array) | Literal::Slice(array) => match array {
-                ArrayLiteral::Standard(elements) => {
-                    for element in elements {
-                        self.substitute_unquoted_into_expr(element, args)?;
+    /// Evaluates any expressions within UnquoteMarkers in the given token list
+    /// and replaces the expression held by the marker with the evaluated value
+    /// in expression form.
+    pub(super) fn substitute_unquoted_values_into_tokens(
+        &mut self,
+        tokens: Tokens,
+        location: Location,
+    ) -> IResult<Tokens> {
+        let mut new_tokens = Vec::with_capacity(tokens.0.len());
+
+        for token in tokens.0 {
+            let span = token.to_span();
+            match token.token() {
+                Token::UnquoteMarker(id) => {
+                    match self.evaluate(*id)? {
+                        // If the value is already quoted we don't want to change the token stream by
+                        // turning it into a Quoted block (which would add `quote`, `{`, and `}` tokens).
+                        Value::Code(stream) => new_tokens.extend(unwrap_rc(stream).0),
+                        value => {
+                            let new_id = value.into_hir_expression(self.interner, location)?;
+                            let new_token = Token::UnquoteMarker(new_id);
+                            new_tokens.push(SpannedToken::new(new_token, span));
+                        }
                     }
-                    Ok(())
-                }
-                ArrayLiteral::Repeated { repeated_element, length } => {
-                    self.substitute_unquoted_into_expr(repeated_element, args)?;
-                    self.substitute_unquoted_into_expr(length, args)?;
-                    Ok(())
                 }
-            },
-            Literal::Bool(_)
-            | Literal::Integer(_, _)
-            | Literal::Str(_)
-            | Literal::RawStr(_, _)
-            | Literal::FmtStr(_)
-            | Literal::Unit => Ok(()),
-        }
-    }
-
-    fn substitute_unquoted_into_prefix(
-        &mut self,
-        prefix: &mut PrefixExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut prefix.rhs, args)
-    }
-
-    fn substitute_unquoted_into_index(
-        &mut self,
-        index: &mut IndexExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut index.collection, args)?;
-        self.substitute_unquoted_into_expr(&mut index.index, args)
-    }
-
-    fn substitute_unquoted_into_call(
-        &mut self,
-        call: &mut CallExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut call.func, args)?;
-        for arg in &mut call.arguments {
-            self.substitute_unquoted_into_expr(arg, args)?;
-        }
-        Ok(())
-    }
-
-    fn substitute_unquoted_into_method_call(
-        &mut self,
-        call: &mut MethodCallExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut call.object, args)?;
-        for arg in &mut call.arguments {
-            self.substitute_unquoted_into_expr(arg, args)?;
-        }
-        Ok(())
-    }
-
-    fn substitute_unquoted_into_constructor(
-        &mut self,
-        constructor: &mut ConstructorExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        for (_, field) in &mut constructor.fields {
-            self.substitute_unquoted_into_expr(field, args)?;
-        }
-        Ok(())
-    }
-
-    fn substitute_unquoted_into_access(
-        &mut self,
-        access: &mut MemberAccessExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut access.lhs, args)
-    }
-
-    fn substitute_unquoted_into_cast(
-        &mut self,
-        cast: &mut CastExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut cast.lhs, args)
-    }
-
-    fn substitute_unquoted_into_infix(
-        &mut self,
-        infix: &mut InfixExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut infix.lhs, args)?;
-        self.substitute_unquoted_into_expr(&mut infix.rhs, args)
-    }
-
-    fn substitute_unquoted_into_if(
-        &mut self,
-        if_: &mut IfExpression,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut if_.condition, args)?;
-        self.substitute_unquoted_into_expr(&mut if_.consequence, args)?;
-
-        if let Some(alternative) = if_.alternative.as_mut() {
-            self.substitute_unquoted_into_expr(alternative, args)?;
-        }
-        Ok(())
-    }
-
-    fn substitute_unquoted_into_tuple(
-        &mut self,
-        tuple: &mut [Expression],
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        for field in tuple {
-            self.substitute_unquoted_into_expr(field, args)?;
+                _ => new_tokens.push(token),
+            }
         }
-        Ok(())
-    }
 
-    fn substitute_unquoted_into_lambda(
-        &mut self,
-        lambda: &mut Lambda,
-        args: &UnquoteArgs,
-    ) -> IResult<()> {
-        self.substitute_unquoted_into_expr(&mut lambda.body, args)
+        Ok(Tokens(new_tokens))
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index f2e21e608ea..770c523bd7f 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -100,7 +100,7 @@ impl<'interner> Interpreter<'interner> {
             // missed it somehow. In the future we may allow users to manually write unquote
             // expressions in their code but for now this is unreachable.
             HirExpression::Unquote(block) => {
-                unreachable!("Found unquote block while scanning: {block}")
+                unreachable!("Found unquote block while scanning: {block:?}")
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index a75d4fd2b24..d51d69f9226 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -1,20 +1,21 @@
 use std::{borrow::Cow, fmt::Display, rc::Rc};
 
 use acvm::{AcirField, FieldElement};
+use chumsky::Parser;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
 
 use crate::{
-    ast::{
-        ArrayLiteral, BlockExpression, ConstructorExpression, Ident, IntegerBitSize, Signedness,
-    },
+    ast::{ArrayLiteral, ConstructorExpression, Ident, IntegerBitSize, Signedness},
     hir_def::expr::{HirArrayLiteral, HirConstructorExpression, HirIdent, HirLambda, ImplKind},
     macros_api::{
         Expression, ExpressionKind, HirExpression, HirLiteral, Literal, NodeInterner, Path,
         StructId,
     },
     node_interner::{ExprId, FuncId},
+    parser,
+    token::{SpannedToken, Token, Tokens},
     QuotedType, Shared, Type,
 };
 use rustc_hash::FxHashMap as HashMap;
@@ -42,7 +43,7 @@ pub enum Value {
     Pointer(Shared<Value>),
     Array(Vector<Value>, Type),
     Slice(Vector<Value>, Type),
-    Code(Rc<BlockExpression>),
+    Code(Rc<Tokens>),
     TypeDefinition(StructId),
 }
 
@@ -72,7 +73,7 @@ impl Value {
             Value::Struct(_, typ) => return Cow::Borrowed(typ),
             Value::Array(_, typ) => return Cow::Borrowed(typ),
             Value::Slice(_, typ) => return Cow::Borrowed(typ),
-            Value::Code(_) => Type::Quoted(QuotedType::Expr),
+            Value::Code(_) => Type::Quoted(QuotedType::Quoted),
             Value::TypeDefinition(_) => Type::Quoted(QuotedType::TypeDefinition),
             Value::Pointer(element) => {
                 let element = element.borrow().get_type().into_owned();
@@ -174,7 +175,22 @@ impl Value {
                     try_vecmap(elements, |element| element.into_expression(interner, location))?;
                 ExpressionKind::Literal(Literal::Slice(ArrayLiteral::Standard(elements)))
             }
-            Value::Code(block) => ExpressionKind::Block(unwrap_rc(block)),
+            Value::Code(tokens) => {
+                // Wrap the tokens in '{' and '}' so that we can parse statements as well.
+                let mut tokens_to_parse = tokens.as_ref().clone();
+                tokens_to_parse.0.insert(0, SpannedToken::new(Token::LeftBrace, location.span));
+                tokens_to_parse.0.push(SpannedToken::new(Token::RightBrace, location.span));
+
+                return match parser::expression().parse(tokens_to_parse) {
+                    Ok(expr) => Ok(expr),
+                    Err(mut errors) => {
+                        let error = errors.swap_remove(0);
+                        let file = location.file;
+                        let rule = "an expression";
+                        Err(InterpreterError::FailedToParseMacro { error, file, tokens, rule })
+                    }
+                };
+            }
             Value::Pointer(_) | Value::TypeDefinition(_) => {
                 return Err(InterpreterError::CannotInlineMacro { value: self, location })
             }
@@ -306,7 +322,7 @@ impl Value {
 }
 
 /// Unwraps an Rc value without cloning the inner value if the reference count is 1. Clones otherwise.
-fn unwrap_rc<T: Clone>(rc: Rc<T>) -> T {
+pub(crate) fn unwrap_rc<T: Clone>(rc: Rc<T>) -> T {
     Rc::try_unwrap(rc).unwrap_or_else(|rc| (*rc).clone())
 }
 
@@ -351,7 +367,13 @@ impl Display for Value {
                 let values = vecmap(values, ToString::to_string);
                 write!(f, "&[{}]", values.join(", "))
             }
-            Value::Code(block) => write!(f, "quote {block}"),
+            Value::Code(tokens) => {
+                write!(f, "quote {{")?;
+                for token in tokens.0.iter() {
+                    write!(f, " {token}")?;
+                }
+                write!(f, " }}")
+            }
             Value::TypeDefinition(_) => write!(f, "(type definition)"),
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 97de66be817..5706e62e193 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -17,7 +17,7 @@ use crate::hir_def::expr::{
     HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCapturedVar,
     HirCastExpression, HirConstructorExpression, HirExpression, HirIdent, HirIfExpression,
     HirIndexExpression, HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess,
-    HirMethodCallExpression, HirPrefixExpression, HirQuoted, ImplKind,
+    HirMethodCallExpression, HirPrefixExpression, ImplKind,
 };
 
 use crate::hir_def::function::FunctionBody;
@@ -1634,10 +1634,7 @@ impl<'a> Resolver<'a> {
             ExpressionKind::Parenthesized(sub_expr) => return self.resolve_expression(*sub_expr),
 
             // The quoted expression isn't resolved since we don't want errors if variables aren't defined
-            ExpressionKind::Quote(block, _) => {
-                let quoted = HirQuoted { quoted_block: block, unquoted_exprs: Vec::new() };
-                HirExpression::Quote(quoted)
-            }
+            ExpressionKind::Quote(block) => HirExpression::Quote(block),
             ExpressionKind::Comptime(block, _) => {
                 HirExpression::Comptime(self.resolve_block(block))
             }
@@ -1648,9 +1645,6 @@ impl<'a> Resolver<'a> {
                 self.push_err(ResolverError::UnquoteUsedOutsideQuote { span: expr.span });
                 HirExpression::Literal(HirLiteral::Unit)
             }
-            ExpressionKind::UnquoteMarker(index) => {
-                unreachable!("UnquoteMarker({index}) remaining in runtime code")
-            }
         };
 
         // If these lines are ever changed, make sure to change the early return
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index bd32ba2fce5..d9d021aee3f 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -143,7 +143,7 @@ pub enum TypeCheckError {
     },
     #[error("Strings do not support indexed assignment")]
     StringIndexAssign { span: Span },
-    #[error("Macro calls may only return Expr values")]
+    #[error("Macro calls may only return `Quoted` values")]
     MacroReturningNonExpr { typ: Type, span: Span },
 }
 
@@ -338,8 +338,8 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 Diagnostic::simple_error(msg, "".into(), *span)
             },
             TypeCheckError::MacroReturningNonExpr { typ, span } => Diagnostic::simple_error(
-                format!("Expected macro call to return an `Expr` but found a(n) {typ}"),
-                "Macro calls must return quoted expressions, otherwise there is no code to insert".into(),
+                format!("Expected macro call to return a `Quoted` but found a(n) `{typ}`"),
+                "Macro calls must return quoted values, otherwise there is no code to insert".into(),
                 *span,
                 ),
         }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index a1302fd15ff..4ded04ec2a4 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -307,13 +307,13 @@ impl<'interner> TypeChecker<'interner> {
 
                 Type::Function(params, Box::new(lambda.return_type), Box::new(env_type))
             }
-            HirExpression::Quote(_) => Type::Quoted(crate::QuotedType::Expr),
+            HirExpression::Quote(_) => Type::Quoted(crate::QuotedType::Quoted),
             HirExpression::Comptime(block) => self.check_block(block),
 
             // Unquote should be inserted & removed by the comptime interpreter.
             // Even if we allowed it here, we wouldn't know what type to give to the result.
             HirExpression::Unquote(block) => {
-                unreachable!("Unquote remaining during type checking {block}")
+                unreachable!("Unquote remaining during type checking {block:?}")
             }
         };
 
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index 9547aef866b..8de4f118774 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -4,6 +4,7 @@ use noirc_errors::Location;
 
 use crate::ast::{BinaryOp, BinaryOpKind, Ident, UnaryOp};
 use crate::node_interner::{DefinitionId, ExprId, FuncId, NodeInterner, StmtId, TraitMethodId};
+use crate::token::Tokens;
 use crate::Shared;
 
 use super::stmt::HirPattern;
@@ -33,8 +34,8 @@ pub enum HirExpression {
     If(HirIfExpression),
     Tuple(Vec<ExprId>),
     Lambda(HirLambda),
-    Quote(HirQuoted),
-    Unquote(crate::ast::BlockExpression),
+    Quote(Tokens),
+    Unquote(Tokens),
     Comptime(HirBlockExpression),
     Error,
 }
@@ -291,13 +292,3 @@ pub struct HirLambda {
     pub body: ExprId,
     pub captures: Vec<HirCapturedVar>,
 }
-
-#[derive(Debug, Clone)]
-pub struct HirQuoted {
-    pub quoted_block: crate::ast::BlockExpression,
-
-    /// Each expression here corresponds to a `ExpressionKind::UnquoteMarker(index)` in `quoted_block`.
-    /// The values of these expressions after evaluation will be inlined into the position
-    /// indicated by their corresponding UnquoteMarker with that index.
-    pub unquoted_exprs: Vec<ExprId>,
-}
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 772558ec31a..86d1fafd502 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -190,9 +190,10 @@ impl Type {
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub enum QuotedType {
     Expr,
-    TypeDefinition,
+    Quoted,
     TopLevelItem,
     Type,
+    TypeDefinition,
 }
 
 /// A list of TypeVariableIds to bind to a type. Storing the
@@ -295,6 +296,16 @@ impl StructType {
         })
     }
 
+    /// Returns the name and raw types of each field of this type.
+    /// This will not substitute any generic arguments so a generic field like `x`
+    /// in `struct Foo<T> { x: T }` will return a `("x", T)` pair.
+    ///
+    /// This method is almost never what is wanted for type checking or monomorphization,
+    /// prefer to use `get_fields` whenever possible.
+    pub fn get_fields_as_written(&self) -> Vec<(String, Type)> {
+        vecmap(&self.fields, |(name, typ)| (name.0.contents.clone(), typ.clone()))
+    }
+
     pub fn field_names(&self) -> BTreeSet<Ident> {
         self.fields.iter().map(|(name, _)| name.clone()).collect()
     }
@@ -804,10 +815,11 @@ impl Type {
             | Type::FmtString(_, _)
             | Type::Error => true,
 
-            Type::MutableReference(_)
-            | Type::Forall(_, _)
-            | Type::Quoted(_)
-            | Type::TraitAsType(..) => false,
+            // Quoted objects only exist at compile-time where the only execution
+            // environment is the interpreter. In this environment, they are valid.
+            Type::Quoted(_) => true,
+
+            Type::MutableReference(_) | Type::Forall(_, _) | Type::TraitAsType(..) => false,
 
             Type::Alias(alias, generics) => {
                 let alias = alias.borrow();
@@ -1008,9 +1020,10 @@ impl std::fmt::Display for QuotedType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             QuotedType::Expr => write!(f, "Expr"),
-            QuotedType::TypeDefinition => write!(f, "TypeDefinition"),
+            QuotedType::Quoted => write!(f, "Quoted"),
             QuotedType::TopLevelItem => write!(f, "TopLevelItem"),
             QuotedType::Type => write!(f, "Type"),
+            QuotedType::TypeDefinition => write!(f, "TypeDefinition"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/lexer/errors.rs b/compiler/noirc_frontend/src/lexer/errors.rs
index 73c75af4cd7..2452e034c1c 100644
--- a/compiler/noirc_frontend/src/lexer/errors.rs
+++ b/compiler/noirc_frontend/src/lexer/errors.rs
@@ -27,6 +27,10 @@ pub enum LexerErrorKind {
         "'\\{escaped}' is not a valid escape sequence. Use '\\' for a literal backslash character."
     )]
     InvalidEscape { escaped: char, span: Span },
+    #[error("Invalid quote delimiter `{delimiter}`, valid delimiters are `{{`, `[`, and `(`")]
+    InvalidQuoteDelimiter { delimiter: SpannedToken },
+    #[error("Expected `{end_delim}` to close this {start_delim}")]
+    UnclosedQuote { start_delim: SpannedToken, end_delim: Token },
 }
 
 impl From<LexerErrorKind> for ParserError {
@@ -47,6 +51,8 @@ impl LexerErrorKind {
             LexerErrorKind::UnterminatedBlockComment { span } => *span,
             LexerErrorKind::UnterminatedStringLiteral { span } => *span,
             LexerErrorKind::InvalidEscape { span, .. } => *span,
+            LexerErrorKind::InvalidQuoteDelimiter { delimiter } => delimiter.to_span(),
+            LexerErrorKind::UnclosedQuote { start_delim, .. } => start_delim.to_span(),
         }
     }
 
@@ -92,6 +98,12 @@ impl LexerErrorKind {
                 ("Unterminated string literal".to_string(), "Unterminated string literal".to_string(), *span),
             LexerErrorKind::InvalidEscape { escaped, span } =>
                 (format!("'\\{escaped}' is not a valid escape sequence. Use '\\' for a literal backslash character."), "Invalid escape sequence".to_string(), *span),
+            LexerErrorKind::InvalidQuoteDelimiter { delimiter } => {
+                (format!("Invalid quote delimiter `{delimiter}`"), "Valid delimiters are `{`, `[`, and `(`".to_string(), delimiter.to_span())
+            },
+            LexerErrorKind::UnclosedQuote { start_delim, end_delim } => {
+                ("Unclosed `quote` expression".to_string(), format!("Expected a `{end_delim}` to close this `{start_delim}`"), start_delim.to_span())
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index 3d052e22e36..d2bc3d0f519 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -145,6 +145,7 @@ impl<'a> Lexer<'a> {
             Some('"') => self.eat_string_literal(),
             Some('f') => self.eat_format_string_or_alpha_numeric(),
             Some('r') => self.eat_raw_string_or_alpha_numeric(),
+            Some('q') => self.eat_quote_or_alpha_numeric(),
             Some('#') => self.eat_attribute(),
             Some(ch) if ch.is_ascii_alphanumeric() || ch == '_' => self.eat_alpha_numeric(ch),
             Some(ch) => {
@@ -310,14 +311,25 @@ impl<'a> Lexer<'a> {
     //XXX(low): Can increase performance if we use iterator semantic and utilize some of the methods on String. See below
     // https://doc.rust-lang.org/stable/std/primitive.str.html#method.rsplit
     fn eat_word(&mut self, initial_char: char) -> SpannedTokenResult {
-        let start = self.position;
+        let (start, word, end) = self.lex_word(initial_char);
+        self.lookup_word_token(word, start, end)
+    }
 
+    /// Lex the next word in the input stream. Returns (start position, word, end position)
+    fn lex_word(&mut self, initial_char: char) -> (Position, String, Position) {
+        let start = self.position;
         let word = self.eat_while(Some(initial_char), |ch| {
             ch.is_ascii_alphabetic() || ch.is_numeric() || ch == '_'
         });
+        (start, word, self.position)
+    }
 
-        let end = self.position;
-
+    fn lookup_word_token(
+        &self,
+        word: String,
+        start: Position,
+        end: Position,
+    ) -> SpannedTokenResult {
         // Check if word either an identifier or a keyword
         if let Some(keyword_token) = Keyword::lookup_keyword(&word) {
             return Ok(keyword_token.into_span(start, end));
@@ -509,6 +521,50 @@ impl<'a> Lexer<'a> {
         }
     }
 
+    fn eat_quote_or_alpha_numeric(&mut self) -> SpannedTokenResult {
+        let (start, word, end) = self.lex_word('q');
+        if word != "quote" {
+            return self.lookup_word_token(word, start, end);
+        }
+
+        let delimiter = self.next_token()?;
+        let (start_delim, end_delim) = match delimiter.token() {
+            Token::LeftBrace => (Token::LeftBrace, Token::RightBrace),
+            Token::LeftBracket => (Token::LeftBracket, Token::RightBracket),
+            Token::LeftParen => (Token::LeftParen, Token::RightParen),
+            _ => return Err(LexerErrorKind::InvalidQuoteDelimiter { delimiter }),
+        };
+
+        let mut tokens = Vec::new();
+
+        // Keep track of each nested delimiter we need to close.
+        let mut nested_delimiters = vec![delimiter];
+
+        while !nested_delimiters.is_empty() {
+            let token = self.next_token()?;
+
+            if *token.token() == start_delim {
+                nested_delimiters.push(token.clone());
+            } else if *token.token() == end_delim {
+                nested_delimiters.pop();
+            } else if *token.token() == Token::EOF {
+                let start_delim =
+                    nested_delimiters.pop().expect("If this were empty, we wouldn't be looping");
+                return Err(LexerErrorKind::UnclosedQuote { start_delim, end_delim });
+            }
+
+            tokens.push(token);
+        }
+
+        // Pop the closing delimiter from the token stream
+        if !tokens.is_empty() {
+            tokens.pop();
+        }
+
+        let end = self.position;
+        Ok(Token::Quote(Tokens(tokens)).into_span(start, end))
+    }
+
     fn parse_comment(&mut self, start: u32) -> SpannedTokenResult {
         let doc_style = match self.peek_char() {
             Some('!') => {
@@ -604,6 +660,8 @@ impl<'a> Iterator for Lexer<'a> {
 
 #[cfg(test)]
 mod tests {
+    use iter_extended::vecmap;
+
     use super::*;
     use crate::token::{FunctionAttribute, SecondaryAttribute, TestScope};
 
@@ -1232,4 +1290,45 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_quote() {
+        // cases is a vector of pairs of (test string, expected # of tokens in token stream)
+        let cases = vec![
+            ("quote {}", 0),
+            ("quote { a.b }", 3),
+            ("quote { ) ( }", 2), // invalid syntax is fine in a quote
+            ("quote { { } }", 2), // Nested `{` and `}` shouldn't close the quote as long as they are matched.
+            ("quote { 1 { 2 { 3 { 4 { 5 } 4 4 } 3 3 } 2 2 } 1 1 }", 21),
+            ("quote [ } } ]", 2), // In addition to `{}`, `[]`, and `()` can also be used as delimiters.
+            ("quote [ } foo[] } ]", 5),
+            ("quote ( } () } )", 4),
+        ];
+
+        for (source, expected_stream_length) in cases {
+            let mut tokens = vecmap(Lexer::new(source), |result| result.unwrap().into_token());
+
+            // All examples should be a single TokenStream token followed by an EOF token.
+            assert_eq!(tokens.len(), 2, "Unexpected token count: {tokens:?}");
+
+            tokens.pop();
+            match tokens.pop().unwrap() {
+                Token::Quote(stream) => assert_eq!(stream.0.len(), expected_stream_length),
+                other => panic!("test_quote test failure! Expected a single TokenStream token, got {other} for input `{source}`")
+            }
+        }
+    }
+
+    #[test]
+    fn test_unclosed_quote() {
+        let cases = vec!["quote {", "quote { {  }", "quote [ []", "quote (((((((())))"];
+
+        for source in cases {
+            // `quote` is not itself a keyword so if the token stream fails to
+            // parse we don't expect any valid tokens from the quote construct
+            for token in Lexer::new(source) {
+                assert!(token.is_err(), "Expected Err, found {token:?}");
+            }
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index ec589a816f6..6830ee528d6 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -2,7 +2,7 @@ use acvm::{acir::AcirField, FieldElement};
 use noirc_errors::{Position, Span, Spanned};
 use std::{fmt, iter::Map, vec::IntoIter};
 
-use crate::lexer::errors::LexerErrorKind;
+use crate::{lexer::errors::LexerErrorKind, node_interner::ExprId};
 
 /// Represents a token in noir's grammar - a word, number,
 /// or symbol that can be used in noir's syntax. This is the
@@ -23,6 +23,7 @@ pub enum BorrowedToken<'input> {
     Attribute(Attribute),
     LineComment(&'input str, Option<DocStyle>),
     BlockComment(&'input str, Option<DocStyle>),
+    Quote(&'input Tokens),
     /// <
     Less,
     /// <=
@@ -94,6 +95,11 @@ pub enum BorrowedToken<'input> {
 
     Whitespace(&'input str),
 
+    /// This is an implementation detail on how macros are implemented by quoting token streams.
+    /// This token marks where an unquote operation is performed. The ExprId argument is the
+    /// resolved variable which is being unquoted at this position in the token stream.
+    UnquoteMarker(ExprId),
+
     /// An invalid character is one that is not in noir's language or grammar.
     ///
     /// We don't report invalid tokens in the source as errors until parsing to
@@ -117,6 +123,8 @@ pub enum Token {
     Attribute(Attribute),
     LineComment(String, Option<DocStyle>),
     BlockComment(String, Option<DocStyle>),
+    // A `quote { ... }` along with the tokens in its token stream.
+    Quote(Tokens),
     /// <
     Less,
     /// <=
@@ -188,6 +196,11 @@ pub enum Token {
 
     Whitespace(String),
 
+    /// This is an implementation detail on how macros are implemented by quoting token streams.
+    /// This token marks where an unquote operation is performed. The ExprId argument is the
+    /// resolved variable which is being unquoted at this position in the token stream.
+    UnquoteMarker(ExprId),
+
     /// An invalid character is one that is not in noir's language or grammar.
     ///
     /// We don't report invalid tokens in the source as errors until parsing to
@@ -209,6 +222,7 @@ pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
         Token::Attribute(ref a) => BorrowedToken::Attribute(a.clone()),
         Token::LineComment(ref s, _style) => BorrowedToken::LineComment(s, *_style),
         Token::BlockComment(ref s, _style) => BorrowedToken::BlockComment(s, *_style),
+        Token::Quote(stream) => BorrowedToken::Quote(stream),
         Token::IntType(ref i) => BorrowedToken::IntType(i.clone()),
         Token::Less => BorrowedToken::Less,
         Token::LessEqual => BorrowedToken::LessEqual,
@@ -246,6 +260,7 @@ pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
         Token::EOF => BorrowedToken::EOF,
         Token::Invalid(c) => BorrowedToken::Invalid(*c),
         Token::Whitespace(ref s) => BorrowedToken::Whitespace(s),
+        Token::UnquoteMarker(id) => BorrowedToken::UnquoteMarker(*id),
     }
 }
 
@@ -255,7 +270,7 @@ pub enum DocStyle {
     Inner,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct SpannedToken(Spanned<Token>);
 
 impl PartialEq<SpannedToken> for Token {
@@ -321,6 +336,13 @@ impl fmt::Display for Token {
             Token::Attribute(ref a) => write!(f, "{a}"),
             Token::LineComment(ref s, _style) => write!(f, "//{s}"),
             Token::BlockComment(ref s, _style) => write!(f, "/*{s}*/"),
+            Token::Quote(ref stream) => {
+                write!(f, "quote {{")?;
+                for token in stream.0.iter() {
+                    write!(f, " {token}")?;
+                }
+                write!(f, "}}")
+            }
             Token::IntType(ref i) => write!(f, "{i}"),
             Token::Less => write!(f, "<"),
             Token::LessEqual => write!(f, "<="),
@@ -358,6 +380,7 @@ impl fmt::Display for Token {
             Token::EOF => write!(f, "end of input"),
             Token::Invalid(c) => write!(f, "{c}"),
             Token::Whitespace(ref s) => write!(f, "{s}"),
+            Token::UnquoteMarker(_) => write!(f, "(UnquoteMarker)"),
         }
     }
 }
@@ -370,6 +393,8 @@ pub enum TokenKind {
     Literal,
     Keyword,
     Attribute,
+    Quote,
+    UnquoteMarker,
 }
 
 impl fmt::Display for TokenKind {
@@ -380,13 +405,15 @@ impl fmt::Display for TokenKind {
             TokenKind::Literal => write!(f, "literal"),
             TokenKind::Keyword => write!(f, "keyword"),
             TokenKind::Attribute => write!(f, "attribute"),
+            TokenKind::Quote => write!(f, "quote"),
+            TokenKind::UnquoteMarker => write!(f, "macro result"),
         }
     }
 }
 
 impl Token {
     pub fn kind(&self) -> TokenKind {
-        match *self {
+        match self {
             Token::Ident(_) => TokenKind::Ident,
             Token::Int(_)
             | Token::Bool(_)
@@ -395,7 +422,9 @@ impl Token {
             | Token::FmtStr(_) => TokenKind::Literal,
             Token::Keyword(_) => TokenKind::Keyword,
             Token::Attribute(_) => TokenKind::Attribute,
-            ref tok => TokenKind::Token(tok.clone()),
+            Token::UnquoteMarker(_) => TokenKind::UnquoteMarker,
+            Token::Quote(_) => TokenKind::Quote,
+            tok => TokenKind::Token(tok.clone()),
         }
     }
 
@@ -859,7 +888,7 @@ pub enum Keyword {
     Mod,
     Mut,
     Pub,
-    Quote,
+    Quoted,
     Return,
     ReturnData,
     String,
@@ -907,7 +936,7 @@ impl fmt::Display for Keyword {
             Keyword::Mod => write!(f, "mod"),
             Keyword::Mut => write!(f, "mut"),
             Keyword::Pub => write!(f, "pub"),
-            Keyword::Quote => write!(f, "quote"),
+            Keyword::Quoted => write!(f, "Quoted"),
             Keyword::Return => write!(f, "return"),
             Keyword::ReturnData => write!(f, "return_data"),
             Keyword::String => write!(f, "str"),
@@ -958,7 +987,7 @@ impl Keyword {
             "mod" => Keyword::Mod,
             "mut" => Keyword::Mut,
             "pub" => Keyword::Pub,
-            "quote" => Keyword::Quote,
+            "Quoted" => Keyword::Quoted,
             "return" => Keyword::Return,
             "return_data" => Keyword::ReturnData,
             "str" => Keyword::String,
@@ -984,6 +1013,7 @@ impl Keyword {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Tokens(pub Vec<SpannedToken>);
 
 type TokenMapIter = Map<IntoIter<SpannedToken>, fn(SpannedToken) -> (Token, Span)>;
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 915093df514..78b2c056dfd 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -303,7 +303,7 @@ impl StmtId {
     }
 }
 
-#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]
+#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone, PartialOrd, Ord)]
 pub struct ExprId(Index);
 
 impl ExprId {
diff --git a/compiler/noirc_frontend/src/noir_parser.lalrpop b/compiler/noirc_frontend/src/noir_parser.lalrpop
index 5768e3c1d17..5bf48a764d6 100644
--- a/compiler/noirc_frontend/src/noir_parser.lalrpop
+++ b/compiler/noirc_frontend/src/noir_parser.lalrpop
@@ -80,7 +80,6 @@ extern {
         "mod" => BorrowedToken::Keyword(noir_token::Keyword::Mod),
         "mut" => BorrowedToken::Keyword(noir_token::Keyword::Mut),
         "pub" => BorrowedToken::Keyword(noir_token::Keyword::Pub),
-        "quote" => BorrowedToken::Keyword(noir_token::Keyword::Quote),
         "return" => BorrowedToken::Keyword(noir_token::Keyword::Return),
         "return_data" => BorrowedToken::Keyword(noir_token::Keyword::ReturnData),
         "str" => BorrowedToken::Keyword(noir_token::Keyword::String),
diff --git a/compiler/noirc_frontend/src/parser/mod.rs b/compiler/noirc_frontend/src/parser/mod.rs
index 9e60383afee..72b1ea05ec2 100644
--- a/compiler/noirc_frontend/src/parser/mod.rs
+++ b/compiler/noirc_frontend/src/parser/mod.rs
@@ -22,7 +22,7 @@ use chumsky::primitive::Container;
 pub use errors::ParserError;
 pub use errors::ParserErrorReason;
 use noirc_errors::Span;
-pub use parser::parse_program;
+pub use parser::{expression, parse_program};
 
 #[derive(Debug, Clone)]
 pub(crate) enum TopLevelStatement {
@@ -45,7 +45,7 @@ pub trait NoirParser<T>: Parser<Token, T, Error = ParserError> + Sized + Clone {
 impl<P, T> NoirParser<T> for P where P: Parser<Token, T, Error = ParserError> + Clone {}
 
 // ExprParser just serves as a type alias for NoirParser<Expression> + Clone
-trait ExprParser: NoirParser<Expression> {}
+pub trait ExprParser: NoirParser<Expression> {}
 impl<P> ExprParser for P where P: NoirParser<Expression> {}
 
 fn parenthesized<P, T>(parser: P) -> impl NoirParser<T>
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index e8838c58772..0ae810fe4d9 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -23,7 +23,7 @@
 //! prevent other parsers from being tried afterward since there is no longer an error. Thus, they should
 //! be limited to cases like the above `fn` example where it is clear we shouldn't back out of the
 //! current parser to try alternative parsers in a `choice` expression.
-use self::primitives::{keyword, mutable_reference, variable};
+use self::primitives::{keyword, macro_quote_marker, mutable_reference, variable};
 use self::types::{generic_type_args, maybe_comp_time, parse_type};
 
 use super::{
@@ -691,7 +691,7 @@ fn optional_visibility() -> impl NoirParser<Visibility> {
         })
 }
 
-fn expression() -> impl ExprParser {
+pub fn expression() -> impl ExprParser {
     recursive(|expr| {
         expression_with_precedence(
             Precedence::Lowest,
@@ -1074,11 +1074,12 @@ where
         },
         lambdas::lambda(expr_parser.clone()),
         block(statement.clone()).map(ExpressionKind::Block),
-        comptime_expr(statement.clone()),
-        quote(statement),
+        comptime_expr(statement),
+        quote(),
         unquote(expr_parser.clone()),
         variable(),
         literal(),
+        macro_quote_marker(),
     ))
     .map_with_span(Expression::new)
     .or(parenthesized(expr_parser.clone()).map_with_span(|sub_expr, span| {
@@ -1101,19 +1102,18 @@ where
         .labelled(ParsingRuleLabel::Atom)
 }
 
-fn quote<'a, P>(statement: P) -> impl NoirParser<ExpressionKind> + 'a
-where
-    P: NoirParser<StatementKind> + 'a,
-{
-    keyword(Keyword::Quote).ignore_then(spanned(block(statement))).validate(
-        |(block, block_span), span, emit| {
-            emit(ParserError::with_reason(
-                ParserErrorReason::ExperimentalFeature("quoted expressions"),
-                span,
-            ));
-            ExpressionKind::Quote(block, block_span)
-        },
-    )
+fn quote() -> impl NoirParser<ExpressionKind> {
+    token_kind(TokenKind::Quote).validate(|token, span, emit| {
+        let tokens = match token {
+            Token::Quote(tokens) => tokens,
+            _ => unreachable!("token_kind(Quote) should guarantee parsing only a quote token"),
+        };
+        emit(ParserError::with_reason(
+            ParserErrorReason::ExperimentalFeature("quoted expressions"),
+            span,
+        ));
+        ExpressionKind::Quote(tokens)
+    })
 }
 
 /// unquote: '$' variable
@@ -1642,4 +1642,19 @@ mod test {
 
         check_cases_with_errors(&cases[..], block(fresh_statement()));
     }
+
+    #[test]
+    fn test_quote() {
+        let cases = vec![
+            "quote {}",
+            "quote { a.b }",
+            "quote { ) ( }", // invalid syntax is fine in a quote
+            "quote { { } }", // Nested `{` and `}` shouldn't close the quote as long as they are matched.
+            "quote { 1 { 2 { 3 { 4 { 5 } 4 4 } 3 3 } 2 2 } 1 1 }",
+        ];
+        parse_all(quote(), cases);
+
+        let failing = vec!["quote {}}", "quote a", "quote { { { } } } }"];
+        parse_all_failing(quote(), failing);
+    }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/primitives.rs b/compiler/noirc_frontend/src/parser/parser/primitives.rs
index 9da19c0a185..88f9e591aba 100644
--- a/compiler/noirc_frontend/src/parser/parser/primitives.rs
+++ b/compiler/noirc_frontend/src/parser/parser/primitives.rs
@@ -94,6 +94,13 @@ pub(super) fn variable_no_turbofish() -> impl NoirParser<ExpressionKind> {
     path().map(|path| ExpressionKind::Variable(path, None))
 }
 
+pub(super) fn macro_quote_marker() -> impl NoirParser<ExpressionKind> {
+    token_kind(TokenKind::UnquoteMarker).map(|token| match token {
+        Token::UnquoteMarker(expr_id) => ExpressionKind::Resolved(expr_id),
+        other => unreachable!("Non-unquote-marker parsed as an unquote marker: {other:?}"),
+    })
+}
+
 #[cfg(test)]
 mod test {
     use crate::parser::parser::{
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index a961b32f9d7..14840bafa04 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -26,6 +26,7 @@ pub(super) fn parse_type_inner<'a>(
         expr_type(),
         type_definition_type(),
         top_level_item_type(),
+        type_of_quoted_types(),
         quoted_type(),
         format_string_type(recursive_type_parser.clone()),
         named_type(recursive_type_parser.clone()),
@@ -93,11 +94,17 @@ fn top_level_item_type() -> impl NoirParser<UnresolvedType> {
 }
 
 /// This is the type `Type` - the type of a quoted noir type.
-fn quoted_type() -> impl NoirParser<UnresolvedType> {
+fn type_of_quoted_types() -> impl NoirParser<UnresolvedType> {
     keyword(Keyword::TypeType)
         .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Type).with_span(span))
 }
 
+/// This is the type of a quoted, unparsed token stream.
+fn quoted_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::Quoted)
+        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Quoted).with_span(span))
+}
+
 pub(super) fn string_type() -> impl NoirParser<UnresolvedType> {
     keyword(Keyword::String)
         .ignore_then(type_expression().delimited_by(just(Token::Less), just(Token::Greater)))
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 1acf1fbf3f2..f4845625b87 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -14,6 +14,7 @@ use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::Location;
 
+use crate::hir::comptime::InterpreterError;
 use crate::hir::def_collector::dc_crate::CompilationError;
 use crate::hir::def_collector::errors::{DefCollectorErrorKind, DuplicateType};
 use crate::hir::def_map::ModuleData;
@@ -1444,3 +1445,26 @@ fn specify_method_types_with_turbofish() {
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 0);
 }
+
+#[test]
+fn quote_code_fragments() {
+    // This test ensures we can quote (and unquote/splice) code fragments
+    // which by themselves are not valid code. They only need to be valid
+    // by the time they are unquoted into the macro's call site.
+    let src = r#"
+        fn main() {
+            comptime {
+                concat!(quote { assert( }, quote { false); });
+            }
+        }
+
+        comptime fn concat(a: Quoted, b: Quoted) -> Quoted {
+            quote { $a $b }
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    use InterpreterError::FailingConstraint;
+    assert!(matches!(&errors[0].0, CompilationError::InterpreterError(FailingConstraint { .. })));
+}
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index ad47171fa46..1a756f441ba 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -26,6 +26,7 @@ mod prelude;
 mod uint128;
 mod bigint;
 mod runtime;
+mod meta;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
diff --git a/noir_stdlib/src/meta.nr b/noir_stdlib/src/meta.nr
new file mode 100644
index 00000000000..1825888130b
--- /dev/null
+++ b/noir_stdlib/src/meta.nr
@@ -0,0 +1 @@
+mod type_def;
diff --git a/noir_stdlib/src/meta/type_def.nr b/noir_stdlib/src/meta/type_def.nr
new file mode 100644
index 00000000000..b9354485921
--- /dev/null
+++ b/noir_stdlib/src/meta/type_def.nr
@@ -0,0 +1,16 @@
+impl TypeDefinition {
+    /// Return a syntactic version of this type definition as a type.
+    /// For example, `as_type(quote { type Foo<A, B> { ... } })` would return `Foo<A, B>`
+    #[builtin(type_def_as_type)]
+    fn as_type(self) -> Quoted {}
+
+    /// Return each generic on this type. The names of these generics are unchanged
+    /// so users may need to keep name collisions in mind if this is used directly in a macro.
+    #[builtin(type_def_generics)]
+    fn generics(self) -> [Quoted] {}
+
+    /// Returns (name, type) pairs of each field in this type. Each type is as-is
+    /// with any generic arguments unchanged.
+    #[builtin(type_def_fields)]
+    fn fields(self) -> [(Quoted, Quoted)] {}
+}
diff --git a/test_programs/compile_success_empty/comptime_type_definition/Nargo.toml b/test_programs/compile_success_empty/comptime_type_definition/Nargo.toml
new file mode 100644
index 00000000000..099545a9e71
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_type_definition/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_type_definition"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/comptime_type_definition/src/main.nr b/test_programs/compile_success_empty/comptime_type_definition/src/main.nr
new file mode 100644
index 00000000000..025f6a0b0bf
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_type_definition/src/main.nr
@@ -0,0 +1,13 @@
+fn main() {}
+
+#[my_comptime_fn]
+struct MyType<A, B, C> {
+    field1: [A; 10],
+    field2: (B, C),
+}
+
+comptime fn my_comptime_fn(typ: TypeDefinition) {
+    let _ = typ.as_type();
+    assert_eq(typ.generics().len(), 3);
+    assert_eq(typ.fields().len(), 2);
+}
diff --git a/test_programs/compile_success_empty/derive_impl/Nargo.toml b/test_programs/compile_success_empty/derive_impl/Nargo.toml
new file mode 100644
index 00000000000..26a6020a6b1
--- /dev/null
+++ b/test_programs/compile_success_empty/derive_impl/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "derive_impl"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/derive_impl/src/main.nr b/test_programs/compile_success_empty/derive_impl/src/main.nr
new file mode 100644
index 00000000000..abad6d4f8e1
--- /dev/null
+++ b/test_programs/compile_success_empty/derive_impl/src/main.nr
@@ -0,0 +1,44 @@
+comptime fn derive_default(typ: TypeDefinition) -> Quoted {
+    let generics: [Quoted] = typ.generics();
+    assert_eq(
+        generics.len(), 0, "derive_default: Deriving Default on generic types is currently unimplemented"
+    );
+
+    let type_name = typ.as_type();
+    let fields = typ.fields();
+
+    let fields = join(make_field_exprs(fields));
+
+    quote {
+        impl Default for $type_name {
+            fn default() -> Self {
+                Self { $fields }
+            }
+        }
+    }
+}
+
+#[derive_default]
+struct Foo {
+    x: Field,
+    y: u32,
+}
+
+comptime fn make_field_exprs(fields: [(Quoted, Quoted)]) -> [Quoted] {
+    let mut result = &[];
+    for my_field in fields {
+        let name = my_field.0;
+        result = result.push_back(quote { $name: Default::default(), });
+    }
+    result
+}
+
+comptime fn join(slice: [Quoted]) -> Quoted {
+    let mut result = quote {};
+    for elem in slice {
+        result = quote { $result $elem };
+    }
+    result
+}
+
+fn main() {}
diff --git a/test_programs/compile_success_empty/macros/src/main.nr b/test_programs/compile_success_empty/macros/src/main.nr
index f466226d575..1b00a084c61 100644
--- a/test_programs/compile_success_empty/macros/src/main.nr
+++ b/test_programs/compile_success_empty/macros/src/main.nr
@@ -1,10 +1,8 @@
-comptime fn my_macro(x: Field, y: Field) -> Expr {
+comptime fn my_macro(x: Field, y: Field) -> Quoted {
     // Current version of macros in Noir are not hygienic
     // so we can quote a and b here and expect them to resolve
     // to the a and b in main at the callsite of my_macro.
-    quote {
-        $x + $y + a + b
-    }
+    quote { $x + $y + a + b }
 }
 
 fn main() {
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index ec8ac4abec7..015644c15cb 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -168,9 +168,7 @@ pub(crate) fn rewrite(
             format!("{path_string}{turbofish}")
         }
         ExpressionKind::Lambda(_) => visitor.slice(span).to_string(),
-        ExpressionKind::Quote(block, block_span) => {
-            format!("quote {}", rewrite_block(visitor, block, block_span))
-        }
+        ExpressionKind::Quote(_) => visitor.slice(span).to_string(),
         ExpressionKind::Comptime(block, block_span) => {
             format!("comptime {}", rewrite_block(visitor, block, block_span))
         }
@@ -185,7 +183,6 @@ pub(crate) fn rewrite(
                 format!("$({})", rewrite_sub_expr(visitor, shape, *expr))
             }
         }
-        ExpressionKind::UnquoteMarker(_) => unreachable!("UnquoteMarker in runtime code"),
     }
 }
 

From b859ef90af9944a83f197c26408a55988b143e0e Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 24 Jun 2024 19:31:00 +0100
Subject: [PATCH 407/416] fix: skip emission of brillig calls which will never
 be executed (#5314)

# Description

## Problem\*

Pulls across fix made in sync PR at
https://github.com/AztecProtocol/aztec-packages/pull/7134/commits/e39be3dc0ee89d9a246366a1f88eb36b26f25751

## Summary\*

For some reason in the `noir-contracts` workspace, we're emitting a
_lot_ (100+ MB worth) of brillig call opcodes which have their predicate
hardcoded to zero (i.e. they will never actually be executed).

This PR adds a check before we emit a brillig call opcode to see if the
predicate is zero and, if so, we skip it and zero out all the outputs at
compile time.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 44 ++++++++++++++++++-
 .../ssa/acir_gen/acir_ir/generated_acir.rs    |  2 +-
 2 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index e09f95508de..b4c23a4abc3 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1522,6 +1522,26 @@ impl<F: AcirField> AcirContext<F> {
         brillig_function_index: u32,
         brillig_stdlib_func: Option<BrilligStdlibFunc>,
     ) -> Result<Vec<AcirValue>, RuntimeError> {
+        let predicate = self.var_to_expression(predicate)?;
+        if predicate.is_zero() {
+            // If the predicate has a constant value of zero, the brillig call will never be executed.
+            // We can then immediately zero out all of its outputs as this is the value which would be written
+            // if we waited until runtime to resolve this call.
+            let outputs_var = vecmap(outputs, |output| match output {
+                AcirType::NumericType(_) => {
+                    let var = self.add_constant(F::zero());
+                    AcirValue::Var(var, output.clone())
+                }
+                AcirType::Array(element_types, size) => {
+                    self.zeroed_array_output(&element_types, size)
+                }
+            });
+
+            return Ok(outputs_var);
+        }
+        // Remove "always true" predicates.
+        let predicate = if predicate == Expression::one() { None } else { Some(predicate) };
+
         let brillig_inputs: Vec<BrilligInputs<F>> =
             try_vecmap(inputs, |i| -> Result<_, InternalError> {
                 match i {
@@ -1569,10 +1589,9 @@ impl<F: AcirField> AcirContext<F> {
                 acir_value
             }
         });
-        let predicate = self.var_to_expression(predicate)?;
 
         self.acir_ir.brillig_call(
-            Some(predicate),
+            predicate,
             generated_brillig,
             brillig_inputs,
             brillig_outputs,
@@ -1643,6 +1662,27 @@ impl<F: AcirField> AcirContext<F> {
         Ok(())
     }
 
+    /// Recursively create zeroed-out acir values for returned arrays. This is necessary because a brillig returned array can have nested arrays as elements.
+    fn zeroed_array_output(&mut self, element_types: &[AcirType], size: usize) -> AcirValue {
+        let mut array_values = im::Vector::new();
+        for _ in 0..size {
+            for element_type in element_types {
+                match element_type {
+                    AcirType::Array(nested_element_types, nested_size) => {
+                        let nested_acir_value =
+                            self.zeroed_array_output(nested_element_types, *nested_size);
+                        array_values.push_back(nested_acir_value);
+                    }
+                    AcirType::NumericType(_) => {
+                        let var = self.add_constant(F::zero());
+                        array_values.push_back(AcirValue::Var(var, element_type.clone()));
+                    }
+                }
+            }
+        }
+        AcirValue::Array(array_values)
+    }
+
     /// Recursively create acir values for returned arrays. This is necessary because a brillig returned array can have nested arrays as elements.
     /// A singular array of witnesses is collected for a top level array, by deflattening the assigned witnesses at each level.
     fn brillig_array_output(
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 6a1118de059..b9e1c04afc5 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -431,7 +431,7 @@ impl<F: AcirField> GeneratedAcir<F> {
         let inputs = vec![BrilligInputs::Single(expr)];
         let outputs = vec![BrilligOutputs::Simple(inverted_witness)];
         self.brillig_call(
-            Some(Expression::one()),
+            None,
             &inverse_code,
             inputs,
             outputs,

From f2f8ecc833d4725d0829f9c339389c90d1a4fbcd Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 24 Jun 2024 20:37:12 +0200
Subject: [PATCH 408/416] chore: add back Pedersen blackbox functions (revert
 PR 5221) (#5318)

# Description

## Problem\*

This PR adds (back) the blackbox functions for Pedersen hash/commitment,
until we get a similar circuit (in term of number of gates) with the
Noir implementation.

## Summary\*
The Noir version is kept and assert to ouput the same value in a test.


## Additional Context
This PR reverts the PR #5221


## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Tom French <tom@tomfren.ch>
Co-authored-by: Tom French <15848336+TomAFrench@users.noreply.github.com>
---
 .../acir/src/circuit/black_box_functions.rs   | 12 ++---
 .../opcodes/black_box_function_call.rs        | 12 ++---
 acvm-repo/acvm/src/pwg/blackbox/mod.rs        | 10 +++-
 acvm-repo/acvm/src/pwg/blackbox/pedersen.rs   | 47 +++++++++++++++++++
 .../src/curve_specific_solver.rs              | 25 ++++++++++
 acvm-repo/bn254_blackbox_solver/src/lib.rs    | 28 +++++++++++
 acvm-repo/brillig/src/black_box.rs            |  4 +-
 acvm-repo/brillig_vm/src/black_box.rs         | 37 ++++++++++++++-
 .../brillig/brillig_gen/brillig_black_box.rs  | 35 +++++++++++++-
 .../noirc_evaluator/src/brillig/brillig_ir.rs | 15 +++++-
 .../src/brillig/brillig_ir/debug_show.rs      | 20 +++++++-
 .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 25 ++++++++++
 .../ssa/acir_gen/acir_ir/generated_acir.rs    | 26 +++++++---
 .../src/ssa/ir/instruction/call.rs            |  6 +--
 noir_stdlib/src/hash.nr                       | 27 +++++++++--
 tooling/lsp/src/solver.rs                     | 16 +++++++
 tooling/nargo_cli/tests/stdlib-tests.rs       |  3 +-
 17 files changed, 309 insertions(+), 39 deletions(-)
 create mode 100644 acvm-repo/acvm/src/pwg/blackbox/pedersen.rs

diff --git a/acvm-repo/acir/src/circuit/black_box_functions.rs b/acvm-repo/acir/src/circuit/black_box_functions.rs
index aadee59f507..fb7d9eb584c 100644
--- a/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -82,9 +82,9 @@ pub enum BlackBoxFunc {
     ///
     /// [grumpkin]: https://hackmd.io/@aztec-network/ByzgNxBfd#2-Grumpkin---A-curve-on-top-of-BN-254-for-SNARK-efficient-group-operations
     SchnorrVerify,
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenCommitment,
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenHash,
     /// Verifies a ECDSA signature over the secp256k1 curve.
     /// - inputs:
@@ -227,8 +227,8 @@ impl BlackBoxFunc {
             BlackBoxFunc::BigIntToLeBytes => "bigint_to_le_bytes",
             BlackBoxFunc::Poseidon2Permutation => "poseidon2_permutation",
             BlackBoxFunc::Sha256Compression => "sha256_compression",
-            BlackBoxFunc::PedersenCommitment => "deprecated pedersen commitment",
-            BlackBoxFunc::PedersenHash => "deprecated pedersen hash",
+            BlackBoxFunc::PedersenCommitment => "pedersen_commitment",
+            BlackBoxFunc::PedersenHash => "pedersen_hash",
         }
     }
 
@@ -257,8 +257,8 @@ impl BlackBoxFunc {
             "bigint_to_le_bytes" => Some(BlackBoxFunc::BigIntToLeBytes),
             "poseidon2_permutation" => Some(BlackBoxFunc::Poseidon2Permutation),
             "sha256_compression" => Some(BlackBoxFunc::Sha256Compression),
-            "deprecated pedersen commitment" => Some(BlackBoxFunc::PedersenCommitment),
-            "deprecated pedersen hash" => Some(BlackBoxFunc::PedersenHash),
+            "pedersen_commitment" => Some(BlackBoxFunc::PedersenCommitment),
+            "pedersen_hash" => Some(BlackBoxFunc::PedersenHash),
             _ => None,
         }
     }
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 09b39964813..b8be81fcdef 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -54,13 +54,13 @@ pub enum BlackBoxFuncCall {
         message: Vec<FunctionInput>,
         output: Witness,
     },
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenCommitment {
         inputs: Vec<FunctionInput>,
         domain_separator: u32,
         outputs: (Witness, Witness),
     },
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenHash {
         inputs: Vec<FunctionInput>,
         domain_separator: u32,
@@ -222,6 +222,8 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
+            | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
+            | BlackBoxFuncCall::PedersenHash { inputs, .. }
             | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. } => inputs.to_vec(),
 
             BlackBoxFuncCall::Keccakf1600 { inputs, .. } => inputs.to_vec(),
@@ -318,8 +320,6 @@ impl BlackBoxFuncCall {
                 inputs.push(*key_hash);
                 inputs
             }
-            BlackBoxFuncCall::PedersenCommitment { .. } => todo!(),
-            BlackBoxFuncCall::PedersenHash { .. } => todo!(),
         }
     }
 
@@ -341,7 +341,9 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::XOR { output, .. }
             | BlackBoxFuncCall::SchnorrVerify { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
+            | BlackBoxFuncCall::PedersenHash { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
+            BlackBoxFuncCall::PedersenCommitment { outputs, .. } => vec![outputs.0, outputs.1],
             BlackBoxFuncCall::MultiScalarMul { outputs, .. }
             | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => {
                 vec![outputs.0, outputs.1, outputs.2]
@@ -356,8 +358,6 @@ impl BlackBoxFuncCall {
                 vec![]
             }
             BlackBoxFuncCall::BigIntToLeBytes { outputs, .. } => outputs.to_vec(),
-            BlackBoxFuncCall::PedersenCommitment { .. } => todo!(),
-            BlackBoxFuncCall::PedersenHash { .. } => todo!(),
         }
     }
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index b3064c47d82..0c65759ebcd 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -18,6 +18,7 @@ pub(crate) mod bigint;
 mod embedded_curve_ops;
 mod hash;
 mod logic;
+mod pedersen;
 mod range;
 mod signature;
 pub(crate) mod utils;
@@ -26,6 +27,7 @@ use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 // Hash functions should eventually be exposed for external consumers.
 use hash::{solve_generic_256_hash_opcode, solve_sha_256_permutation_opcode};
 use logic::{and, xor};
+use pedersen::{pedersen, pedersen_hash};
 pub(crate) use range::solve_range_opcode;
 use signature::{
     ecdsa::{secp256k1_prehashed, secp256r1_prehashed},
@@ -125,6 +127,12 @@ pub(crate) fn solve<F: AcirField>(
             message,
             *output,
         ),
+        BlackBoxFuncCall::PedersenCommitment { inputs, domain_separator, outputs } => {
+            pedersen(backend, initial_witness, inputs, *domain_separator, *outputs)
+        }
+        BlackBoxFuncCall::PedersenHash { inputs, domain_separator, output } => {
+            pedersen_hash(backend, initial_witness, inputs, *domain_separator, *output)
+        }
         BlackBoxFuncCall::EcdsaSecp256k1 {
             public_key_x,
             public_key_y,
@@ -179,7 +187,5 @@ pub(crate) fn solve<F: AcirField>(
         BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len } => {
             solve_poseidon2_permutation_opcode(backend, initial_witness, inputs, outputs, *len)
         }
-        BlackBoxFuncCall::PedersenCommitment { .. } => todo!("Deprecated BlackBox"),
-        BlackBoxFuncCall::PedersenHash { .. } => todo!("Deprecated BlackBox"),
     }
 }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs b/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
new file mode 100644
index 00000000000..f64a3a79465
--- /dev/null
+++ b/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
@@ -0,0 +1,47 @@
+use acir::{
+    circuit::opcodes::FunctionInput,
+    native_types::{Witness, WitnessMap},
+    AcirField,
+};
+
+use crate::{
+    pwg::{insert_value, witness_to_value, OpcodeResolutionError},
+    BlackBoxFunctionSolver,
+};
+
+pub(super) fn pedersen<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
+    inputs: &[FunctionInput],
+    domain_separator: u32,
+    outputs: (Witness, Witness),
+) -> Result<(), OpcodeResolutionError<F>> {
+    let scalars: Result<Vec<_>, _> =
+        inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
+    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
+
+    let (res_x, res_y) = backend.pedersen_commitment(&scalars, domain_separator)?;
+
+    insert_value(&outputs.0, res_x, initial_witness)?;
+    insert_value(&outputs.1, res_y, initial_witness)?;
+
+    Ok(())
+}
+
+pub(super) fn pedersen_hash<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
+    inputs: &[FunctionInput],
+    domain_separator: u32,
+    output: Witness,
+) -> Result<(), OpcodeResolutionError<F>> {
+    let scalars: Result<Vec<_>, _> =
+        inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
+    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
+
+    let res = backend.pedersen_hash(&scalars, domain_separator)?;
+
+    insert_value(&output, res, initial_witness)?;
+
+    Ok(())
+}
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index 869017f52ee..f729a5033fb 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -14,6 +14,16 @@ pub trait BlackBoxFunctionSolver<F> {
         signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError>;
+    fn pedersen_commitment(
+        &self,
+        inputs: &[F],
+        domain_separator: u32,
+    ) -> Result<(F, F), BlackBoxResolutionError>;
+    fn pedersen_hash(
+        &self,
+        inputs: &[F],
+        domain_separator: u32,
+    ) -> Result<F, BlackBoxResolutionError>;
     fn multi_scalar_mul(
         &self,
         points: &[F],
@@ -57,6 +67,21 @@ impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
     ) -> Result<bool, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::SchnorrVerify))
     }
+    fn pedersen_commitment(
+        &self,
+        _inputs: &[F],
+        _domain_separator: u32,
+    ) -> Result<(F, F), BlackBoxResolutionError> {
+        Err(Self::fail(BlackBoxFunc::PedersenCommitment))
+    }
+    fn pedersen_hash(
+        &self,
+        _inputs: &[F],
+        _domain_separator: u32,
+    ) -> Result<F, BlackBoxResolutionError> {
+        Err(Self::fail(BlackBoxFunc::PedersenHash))
+    }
+
     fn multi_scalar_mul(
         &self,
         _points: &[F],
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index ec69c3797f6..6897116e90e 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -10,6 +10,7 @@ mod pedersen;
 mod poseidon2;
 mod schnorr;
 
+use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use generator::generators::derive_generators;
 pub use poseidon2::poseidon2_permutation;
@@ -40,6 +41,33 @@ impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
         ))
     }
 
+    fn pedersen_commitment(
+        &self,
+        inputs: &[FieldElement],
+        domain_separator: u32,
+    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
+        let result = pedersen::commitment::commit_native_with_index(&inputs, domain_separator);
+        let result = if let Some((x, y)) = result.xy() {
+            (FieldElement::from_repr(*x), FieldElement::from_repr(*y))
+        } else {
+            (FieldElement::from(0_u128), FieldElement::from(0_u128))
+        };
+
+        Ok(result)
+    }
+
+    fn pedersen_hash(
+        &self,
+        inputs: &[FieldElement],
+        domain_separator: u32,
+    ) -> Result<FieldElement, BlackBoxResolutionError> {
+        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
+        let result = pedersen::hash::hash_with_index(&inputs, domain_separator);
+        let result = FieldElement::from_repr(result);
+        Ok(result)
+    }
+
     fn multi_scalar_mul(
         &self,
         points: &[FieldElement],
diff --git a/acvm-repo/brillig/src/black_box.rs b/acvm-repo/brillig/src/black_box.rs
index 2b39e279aa8..60e4af11ea2 100644
--- a/acvm-repo/brillig/src/black_box.rs
+++ b/acvm-repo/brillig/src/black_box.rs
@@ -61,13 +61,13 @@ pub enum BlackBoxOp {
         signature: HeapVector,
         result: MemoryAddress,
     },
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenCommitment {
         inputs: HeapVector,
         domain_separator: MemoryAddress,
         output: HeapArray,
     },
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenHash {
         inputs: HeapVector,
         domain_separator: MemoryAddress,
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 544963b00db..36d045efabf 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -232,6 +232,41 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             );
             Ok(())
         }
+        BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
+            let inputs: Vec<F> = read_heap_vector(memory, inputs)
+                .iter()
+                .map(|x| *x.extract_field().unwrap())
+                .collect();
+            let domain_separator: u32 =
+                memory.read(*domain_separator).try_into().map_err(|_| {
+                    BlackBoxResolutionError::Failed(
+                        BlackBoxFunc::PedersenCommitment,
+                        "Invalid separator length".to_string(),
+                    )
+                })?;
+            let (x, y) = solver.pedersen_commitment(&inputs, domain_separator)?;
+            memory.write_slice(
+                memory.read_ref(output.pointer),
+                &[MemoryValue::new_field(x), MemoryValue::new_field(y)],
+            );
+            Ok(())
+        }
+        BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
+            let inputs: Vec<F> = read_heap_vector(memory, inputs)
+                .iter()
+                .map(|x| *x.extract_field().unwrap())
+                .collect();
+            let domain_separator: u32 =
+                memory.read(*domain_separator).try_into().map_err(|_| {
+                    BlackBoxResolutionError::Failed(
+                        BlackBoxFunc::PedersenCommitment,
+                        "Invalid separator length".to_string(),
+                    )
+                })?;
+            let hash = solver.pedersen_hash(&inputs, domain_separator)?;
+            memory.write(*output, MemoryValue::new_field(hash));
+            Ok(())
+        }
         BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
@@ -343,8 +378,6 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
 
             Ok(())
         }
-        BlackBoxOp::PedersenCommitment { .. } => todo!("Deprecated Blackbox"),
-        BlackBoxOp::PedersenHash { .. } => todo!("Deprecated Blackbox"),
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index c62365162ba..367cdbe4973 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -137,6 +137,39 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
                 )
             }
         }
+
+        BlackBoxFunc::PedersenCommitment => {
+            if let (
+                [message, BrilligVariable::SingleAddr(domain_separator)],
+                [BrilligVariable::BrilligArray(result_array)],
+            ) = (function_arguments, function_results)
+            {
+                let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
+                brillig_context.black_box_op_instruction(BlackBoxOp::PedersenCommitment {
+                    inputs: message_vector.to_heap_vector(),
+                    domain_separator: domain_separator.address,
+                    output: result_array.to_heap_array(),
+                });
+            } else {
+                unreachable!("ICE: Pedersen expects one array argument, a register for the domain separator, and one array result")
+            }
+        }
+        BlackBoxFunc::PedersenHash => {
+            if let (
+                [message, BrilligVariable::SingleAddr(domain_separator)],
+                [BrilligVariable::SingleAddr(result)],
+            ) = (function_arguments, function_results)
+            {
+                let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
+                brillig_context.black_box_op_instruction(BlackBoxOp::PedersenHash {
+                    inputs: message_vector.to_heap_vector(),
+                    domain_separator: domain_separator.address,
+                    output: result.address,
+                });
+            } else {
+                unreachable!("ICE: Pedersen hash expects one array argument, a register for the domain separator, and one register result")
+            }
+        }
         BlackBoxFunc::SchnorrVerify => {
             if let (
                 [BrilligVariable::SingleAddr(public_key_x), BrilligVariable::SingleAddr(public_key_y), BrilligVariable::BrilligArray(signature), message],
@@ -391,8 +424,6 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString>(
                 unreachable!("ICE: AES128Encrypt expects three array arguments, one array result")
             }
         }
-        BlackBoxFunc::PedersenCommitment => todo!("Deprecated Blackbox"),
-        BlackBoxFunc::PedersenHash => todo!("Deprecated Blackbox"),
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index a0bf89fff0d..9785e073be9 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -158,7 +158,20 @@ pub(crate) mod tests {
         ) -> Result<bool, BlackBoxResolutionError> {
             Ok(true)
         }
-
+        fn pedersen_commitment(
+            &self,
+            _inputs: &[FieldElement],
+            _domain_separator: u32,
+        ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+            Ok((2_u128.into(), 3_u128.into()))
+        }
+        fn pedersen_hash(
+            &self,
+            _inputs: &[FieldElement],
+            _domain_separator: u32,
+        ) -> Result<FieldElement, BlackBoxResolutionError> {
+            Ok(6_u128.into())
+        }
         fn multi_scalar_mul(
             &self,
             _points: &[FieldElement],
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index a595584b376..b258905d657 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -347,6 +347,24 @@ impl DebugShow {
                     result
                 );
             }
+            BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  PEDERSEN {} {} -> {}",
+                    inputs,
+                    domain_separator,
+                    output
+                );
+            }
+            BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  PEDERSEN_HASH {} {} -> {}",
+                    inputs,
+                    domain_separator,
+                    output
+                );
+            }
             BlackBoxOp::SchnorrVerify {
                 public_key_x,
                 public_key_y,
@@ -444,8 +462,6 @@ impl DebugShow {
                     output
                 );
             }
-            BlackBoxOp::PedersenCommitment { .. } => todo!("Deprecated Blackbox"),
-            BlackBoxOp::PedersenHash { .. } => todo!("Deprecated Blackbox"),
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index b4c23a4abc3..928a7b105ea 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1215,6 +1215,31 @@ impl<F: AcirField> AcirContext<F> {
     ) -> Result<Vec<AcirVar>, RuntimeError> {
         // Separate out any arguments that should be constants
         let (constant_inputs, constant_outputs) = match name {
+            BlackBoxFunc::PedersenCommitment | BlackBoxFunc::PedersenHash => {
+                // The last argument of pedersen is the domain separator, which must be a constant
+                let domain_var = match inputs.pop() {
+                    Some(domain_var) => domain_var.into_var()?,
+                    None => {
+                        return Err(RuntimeError::InternalError(InternalError::MissingArg {
+                            name: "pedersen call".to_string(),
+                            arg: "domain separator".to_string(),
+                            call_stack: self.get_call_stack(),
+                        }))
+                    }
+                };
+
+                let domain_constant = match self.vars[&domain_var].as_constant() {
+                    Some(domain_constant) => domain_constant,
+                    None => {
+                        return Err(RuntimeError::InternalError(InternalError::NotAConstant {
+                            name: "domain separator".to_string(),
+                            call_stack: self.get_call_stack(),
+                        }))
+                    }
+                };
+
+                (vec![*domain_constant], Vec::new())
+            }
             BlackBoxFunc::Poseidon2Permutation => {
                 // The last argument is the state length, which must be a constant
                 let state_len = match inputs.pop() {
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index b9e1c04afc5..bcccfac8950 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -224,6 +224,16 @@ impl<F: AcirField> GeneratedAcir<F> {
                     output: outputs[0],
                 }
             }
+            BlackBoxFunc::PedersenCommitment => BlackBoxFuncCall::PedersenCommitment {
+                inputs: inputs[0].clone(),
+                outputs: (outputs[0], outputs[1]),
+                domain_separator: constant_inputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::PedersenHash => BlackBoxFuncCall::PedersenHash {
+                inputs: inputs[0].clone(),
+                output: outputs[0],
+                domain_separator: constant_inputs[0].to_u128() as u32,
+            },
             BlackBoxFunc::EcdsaSecp256k1 => {
                 BlackBoxFuncCall::EcdsaSecp256k1 {
                     // 32 bytes for each public key co-ordinate
@@ -361,8 +371,6 @@ impl<F: AcirField> GeneratedAcir<F> {
                     .expect("Compiler should generate correct size inputs"),
                 outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
             },
-            BlackBoxFunc::PedersenCommitment => todo!("Deprecated Blackbox"),
-            BlackBoxFunc::PedersenHash => todo!("Deprecated Blackbox"),
         };
 
         self.push_opcode(AcirOpcode::BlackBoxFuncCall(black_box_func_call));
@@ -641,7 +649,9 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
         | BlackBoxFunc::Keccak256
         | BlackBoxFunc::SHA256
         | BlackBoxFunc::Blake2s
-        | BlackBoxFunc::Blake3 => None,
+        | BlackBoxFunc::Blake3
+        | BlackBoxFunc::PedersenCommitment
+        | BlackBoxFunc::PedersenHash => None,
 
         BlackBoxFunc::Keccakf1600 => Some(25),
         // The permutation takes a fixed number of inputs, but the inputs length depends on the proving system implementation.
@@ -677,8 +687,6 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
 
         // FromLeBytes takes a variable array of bytes as input
         BlackBoxFunc::BigIntFromLeBytes => None,
-        BlackBoxFunc::PedersenCommitment => todo!(),
-        BlackBoxFunc::PedersenHash => todo!(),
     }
 }
 
@@ -702,6 +710,12 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         BlackBoxFunc::Sha256Compression => Some(8),
 
+        // Pedersen commitment returns a point
+        BlackBoxFunc::PedersenCommitment => Some(2),
+
+        // Pedersen hash returns a field
+        BlackBoxFunc::PedersenHash => Some(1),
+
         // Can only apply a range constraint to one
         // witness at a time.
         BlackBoxFunc::RANGE => Some(0),
@@ -730,8 +744,6 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         // AES encryption returns a variable number of outputs
         BlackBoxFunc::AES128Encrypt => None,
-        BlackBoxFunc::PedersenCommitment => todo!(),
-        BlackBoxFunc::PedersenHash => todo!(),
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index a9e3570ba0f..e4635c0f974 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -446,7 +446,9 @@ fn simplify_black_box_func(
         BlackBoxFunc::SHA256 => simplify_hash(dfg, arguments, acvm::blackbox_solver::sha256),
         BlackBoxFunc::Blake2s => simplify_hash(dfg, arguments, acvm::blackbox_solver::blake2s),
         BlackBoxFunc::Blake3 => simplify_hash(dfg, arguments, acvm::blackbox_solver::blake3),
-        BlackBoxFunc::Keccakf1600 => SimplifyResult::None, //TODO(Guillaume)
+        BlackBoxFunc::PedersenCommitment
+        | BlackBoxFunc::PedersenHash
+        | BlackBoxFunc::Keccakf1600 => SimplifyResult::None, //TODO(Guillaume)
         BlackBoxFunc::Keccak256 => {
             match (dfg.get_array_constant(arguments[0]), dfg.get_numeric_constant(arguments[1])) {
                 (Some((input, _)), Some(num_bytes)) if array_is_constant(dfg, &input) => {
@@ -501,8 +503,6 @@ fn simplify_black_box_func(
         }
         BlackBoxFunc::Sha256Compression => SimplifyResult::None, //TODO(Guillaume)
         BlackBoxFunc::AES128Encrypt => SimplifyResult::None,
-        BlackBoxFunc::PedersenCommitment => todo!("Deprecated Blackbox"),
-        BlackBoxFunc::PedersenHash => todo!("Deprecated Blackbox"),
     }
 }
 
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index b72c1ecba8f..62b47b67241 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -36,7 +36,7 @@ pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
     }
 }
 
-pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
+fn pedersen_commitment_with_separator_noir<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
     let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];
     for i in 0..N {
         points[i] = EmbeddedCurveScalar::from_field(input[i]);
@@ -46,6 +46,11 @@ pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32)
     EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: values[2] as bool }
 }
 
+pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
+    let values = __pedersen_commitment_with_separator(input, separator);
+    EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: false }
+}
+
 // docs:start:pedersen_hash
 pub fn pedersen_hash<N>(input: [Field; N]) -> Field
 // docs:end:pedersen_hash
@@ -64,15 +69,21 @@ fn derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32)
 #[field(bn254)]
 fn __derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {}
 
-pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {
-    let v1 = pedersen_commitment(input);
-    let length_generator :[EmbeddedCurvePoint;1] = derive_generators("pedersen_hash_length".as_bytes(), separator);
+fn pedersen_hash_with_separator_noir<N>(input: [Field; N], separator: u32) -> Field {
+    let v1 = pedersen_commitment_with_separator(input, separator);
+    let length_generator : [EmbeddedCurvePoint; 1] = derive_generators("pedersen_hash_length".as_bytes(), 0);
     multi_scalar_mul(
         [length_generator[0], v1],
         [EmbeddedCurveScalar { lo: N as Field, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
     )[0]
 }
 
+#[foreign(pedersen_hash)]
+pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {}
+
+#[foreign(pedersen_commitment)]
+fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
+
 pub fn hash_to_field(inputs: [Field]) -> Field {
     let mut sum = 0;
 
@@ -246,3 +257,11 @@ impl<A, B, C, D, E> Hash for (A, B, C, D, E) where A: Hash, B: Hash, C: Hash, D:
         self.4.hash(state);
     }
 }
+
+#[test]
+fn assert_pedersen_noir() {
+    // TODO: make this a fuzzer test once fuzzer supports curve-specific blackbox functions.
+    let input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    assert_eq(pedersen_hash_with_separator(input, 4), pedersen_hash_with_separator_noir(input, 4));
+    assert_eq(pedersen_commitment_with_separator(input, 4), pedersen_commitment_with_separator_noir(input, 4));
+}
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 3c2d7499880..9d1185e3a79 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -16,6 +16,22 @@ impl BlackBoxFunctionSolver<acvm::FieldElement> for WrapperSolver {
         self.0.schnorr_verify(public_key_x, public_key_y, signature, message)
     }
 
+    fn pedersen_commitment(
+        &self,
+        inputs: &[acvm::FieldElement],
+        domain_separator: u32,
+    ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
+        self.0.pedersen_commitment(inputs, domain_separator)
+    }
+
+    fn pedersen_hash(
+        &self,
+        inputs: &[acvm::FieldElement],
+        domain_separator: u32,
+    ) -> Result<acvm::FieldElement, acvm::BlackBoxResolutionError> {
+        self.0.pedersen_hash(inputs, domain_separator)
+    }
+
     fn multi_scalar_mul(
         &self,
         points: &[acvm::FieldElement],
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 5badd76605a..7fd396d6961 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -1,7 +1,6 @@
 use std::io::Write;
 use std::{collections::BTreeMap, path::PathBuf};
 
-use acvm::blackbox_solver::StubbedBlackBoxSolver;
 use fm::FileManager;
 use noirc_driver::{check_crate, compile_no_check, file_manager_with_stdlib, CompileOptions};
 use noirc_frontend::hir::FunctionNameMatch;
@@ -56,7 +55,7 @@ fn run_stdlib_tests() {
 
             let status = if test_function_has_no_arguments {
                 run_test(
-                    &StubbedBlackBoxSolver,
+                    &bn254_blackbox_solver::Bn254BlackBoxSolver,
                     &mut context,
                     &test_function,
                     false,

From cf938bc06b7015dae94847f146dc7fd38055f064 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 24 Jun 2024 17:02:01 -0400
Subject: [PATCH 409/416] feat(frontend): Where clause on impl (#5320)

# Description

## Problem\*

Resolves #4508

## Summary\*

This enables the simple functionality of being able to declare a where
clause directly on a struct implementation such as below:
```rust
impl<T> MyStruct<T> where T: MyEq {
    fn my_eq(self, other: Self) -> bool {
        (self.a == other.a) & self.b.my_eq(other.b)
    }
}
```
The code above is essentially syntactic sugar where we now every method
in the struct impl a where clause. As the logic for resolving trait
constraints already exists this PR really just updates the parser to
accept `where` clauses and during definition collection attaches them to
each method in an impl.

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [X] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 aztec_macros/src/transforms/events.rs         |  1 +
 aztec_macros/src/transforms/note_interface.rs |  1 +
 aztec_macros/src/transforms/storage.rs        |  2 ++
 compiler/noirc_frontend/src/ast/traits.rs     |  1 +
 .../src/hir/def_collector/dc_mod.rs           |  3 +-
 compiler/noirc_frontend/src/parser/parser.rs  | 13 +++++--
 docs/docs/noir/concepts/traits.md             | 18 +++++++++-
 .../impl_where_clause/Nargo.toml              |  7 ++++
 .../impl_where_clause/src/main.nr             | 34 +++++++++++++++++++
 .../Nargo.toml                                |  2 +-
 .../src/main.nr                               |  0
 tooling/nargo_fmt/src/visitor/item.rs         |  4 +--
 tooling/nargo_fmt/tests/expected/impl.nr      |  6 ++++
 tooling/nargo_fmt/tests/input/impl.nr         |  6 ++++
 14 files changed, 91 insertions(+), 7 deletions(-)
 create mode 100644 test_programs/compile_success_empty/impl_where_clause/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/impl_where_clause/src/main.nr
 rename test_programs/compile_success_empty/{impl_with_where_clause => trait_impl_with_where_clause}/Nargo.toml (58%)
 rename test_programs/compile_success_empty/{impl_with_where_clause => trait_impl_with_where_clause}/src/main.nr (100%)

diff --git a/aztec_macros/src/transforms/events.rs b/aztec_macros/src/transforms/events.rs
index 69cb6ddafc3..74a7be8eb95 100644
--- a/aztec_macros/src/transforms/events.rs
+++ b/aztec_macros/src/transforms/events.rs
@@ -83,6 +83,7 @@ pub fn generate_selector_impl(structure: &mut NoirStruct) -> TypeImpl {
         type_span: structure.span,
         generics: vec![],
         methods: vec![(NoirFunction::normal(selector_fn_def), Span::default())],
+        where_clause: vec![],
     }
 }
 
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index f0e7d0d5034..80417c14322 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -69,6 +69,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 type_span: note_struct.name.span(),
                 generics: vec![],
                 methods: vec![],
+                where_clause: vec![],
             };
             module.impls.push(default_impl.clone());
             module.impls.last_mut().unwrap()
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 8b778b4cca6..872e7c37801 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -246,6 +246,8 @@ pub fn generate_storage_implementation(
         generics: vec![generic_context_ident],
 
         methods: vec![(init, Span::default())],
+
+        where_clause: vec![],
     };
     module.impls.push(storage_impl);
 
diff --git a/compiler/noirc_frontend/src/ast/traits.rs b/compiler/noirc_frontend/src/ast/traits.rs
index 772675723b5..9d7345d0270 100644
--- a/compiler/noirc_frontend/src/ast/traits.rs
+++ b/compiler/noirc_frontend/src/ast/traits.rs
@@ -49,6 +49,7 @@ pub struct TypeImpl {
     pub object_type: UnresolvedType,
     pub type_span: Span,
     pub generics: UnresolvedGenerics,
+    pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub methods: Vec<(NoirFunction, Span)>,
 }
 
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 5c196324b7d..e7bbe5951d8 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -149,8 +149,9 @@ impl<'a> ModCollector<'a> {
                 self_type: None,
             };
 
-            for (method, _) in r#impl.methods {
+            for (mut method, _) in r#impl.methods {
                 let func_id = context.def_interner.push_empty_fn();
+                method.def.where_clause.extend(r#impl.where_clause.clone());
                 let location = Location::new(method.span(), self.file_id);
                 context.def_interner.push_function(func_id, &method.def, module_id, location);
                 unresolved_functions.push_fn(self.module_id, func_id, method);
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 0ae810fe4d9..ec7acd267b8 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -225,11 +225,20 @@ fn implementation() -> impl NoirParser<TopLevelStatement> {
     keyword(Keyword::Impl)
         .ignore_then(function::generics())
         .then(parse_type().map_with_span(|typ, span| (typ, span)))
+        .then(where_clause())
         .then_ignore(just(Token::LeftBrace))
         .then(spanned(function::function_definition(true)).repeated())
         .then_ignore(just(Token::RightBrace))
-        .map(|((generics, (object_type, type_span)), methods)| {
-            TopLevelStatement::Impl(TypeImpl { generics, object_type, type_span, methods })
+        .map(|args| {
+            let ((other_args, where_clause), methods) = args;
+            let (generics, (object_type, type_span)) = other_args;
+            TopLevelStatement::Impl(TypeImpl {
+                generics,
+                object_type,
+                type_span,
+                where_clause,
+                methods,
+            })
         })
 }
 
diff --git a/docs/docs/noir/concepts/traits.md b/docs/docs/noir/concepts/traits.md
index df7cb9ebda0..51305b38c16 100644
--- a/docs/docs/noir/concepts/traits.md
+++ b/docs/docs/noir/concepts/traits.md
@@ -147,7 +147,7 @@ fn main() {
 
 ### Generic Trait Implementations With Where Clauses
 
-Where clauses can also be placed on trait implementations themselves to restrict generics in a similar way.
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
 For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
 will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
 For example, here is the implementation for array equality:
@@ -169,6 +169,22 @@ impl<T, N> Eq for [T; N] where T: Eq {
 }
 ```
 
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
 ## Generic Traits
 
 Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
diff --git a/test_programs/compile_success_empty/impl_where_clause/Nargo.toml b/test_programs/compile_success_empty/impl_where_clause/Nargo.toml
new file mode 100644
index 00000000000..7d0d5f3513e
--- /dev/null
+++ b/test_programs/compile_success_empty/impl_where_clause/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "impl_where_clause"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/impl_where_clause/src/main.nr b/test_programs/compile_success_empty/impl_where_clause/src/main.nr
new file mode 100644
index 00000000000..2f3223efaae
--- /dev/null
+++ b/test_programs/compile_success_empty/impl_where_clause/src/main.nr
@@ -0,0 +1,34 @@
+struct MyStruct<T> {
+    a: u32,
+    b: T,
+}
+
+struct InnerStruct {
+    a: Field,
+    b: Field,
+}
+
+trait MyEq {
+    fn my_eq(self, other: Self) -> bool;
+}
+
+impl MyEq for InnerStruct {
+    fn my_eq(self, other: InnerStruct) -> bool {
+        (self.a == other.a) & (self.b == other.b)
+    }
+}
+
+impl<T> MyStruct<T> where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.my_eq(other.b)
+    }
+}
+
+fn main() {
+    let inner = InnerStruct { a: 1, b: 2 };
+    let my_struct = MyStruct { a: 5, b: inner };
+    assert(my_struct.my_eq(my_struct));
+
+    let mut my_struct_new = MyStruct { a: 5, b: InnerStruct { a: 10, b: 15 } };
+    assert(my_struct_new.my_eq(my_struct_new));
+}
diff --git a/test_programs/compile_success_empty/impl_with_where_clause/Nargo.toml b/test_programs/compile_success_empty/trait_impl_with_where_clause/Nargo.toml
similarity index 58%
rename from test_programs/compile_success_empty/impl_with_where_clause/Nargo.toml
rename to test_programs/compile_success_empty/trait_impl_with_where_clause/Nargo.toml
index ef9bdce2640..672569634ea 100644
--- a/test_programs/compile_success_empty/impl_with_where_clause/Nargo.toml
+++ b/test_programs/compile_success_empty/trait_impl_with_where_clause/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "impl_with_where_clause"
+name = "trait_impl_with_where_clause"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/compile_success_empty/impl_with_where_clause/src/main.nr b/test_programs/compile_success_empty/trait_impl_with_where_clause/src/main.nr
similarity index 100%
rename from test_programs/compile_success_empty/impl_with_where_clause/src/main.nr
rename to test_programs/compile_success_empty/trait_impl_with_where_clause/src/main.nr
diff --git a/tooling/nargo_fmt/src/visitor/item.rs b/tooling/nargo_fmt/src/visitor/item.rs
index 3cfee4f46ad..5aaaf20ff47 100644
--- a/tooling/nargo_fmt/src/visitor/item.rs
+++ b/tooling/nargo_fmt/src/visitor/item.rs
@@ -188,8 +188,8 @@ impl super::FmtVisitor<'_> {
                         continue;
                     }
 
-                    let slice =
-                        self.slice(self.last_position..impl_.object_type.span.unwrap().end());
+                    let before_brace = self.span_before(span, Token::LeftBrace).start();
+                    let slice = self.slice(self.last_position..before_brace).trim();
                     let after_brace = self.span_after(span, Token::LeftBrace).start();
                     self.last_position = after_brace;
 
diff --git a/tooling/nargo_fmt/tests/expected/impl.nr b/tooling/nargo_fmt/tests/expected/impl.nr
index ec734b57970..3c2fa42837a 100644
--- a/tooling/nargo_fmt/tests/expected/impl.nr
+++ b/tooling/nargo_fmt/tests/expected/impl.nr
@@ -19,3 +19,9 @@ impl MyType {
 impl MyType {
     fn method(self) {}
 }
+
+impl<T> MyStruct<T> where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.my_eq(other.b)
+    }
+}
diff --git a/tooling/nargo_fmt/tests/input/impl.nr b/tooling/nargo_fmt/tests/input/impl.nr
index ea909dfad44..4ca838c2964 100644
--- a/tooling/nargo_fmt/tests/input/impl.nr
+++ b/tooling/nargo_fmt/tests/input/impl.nr
@@ -19,3 +19,9 @@ fn method(self) {}
 impl MyType {
             fn method(self) {}
 }
+
+impl<T> MyStruct<T> where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.my_eq(other.b)
+    }
+}
\ No newline at end of file

From d4e03d07bb00d1ba0f8f43bd0dd9e967a10a28b9 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 24 Jun 2024 17:13:50 -0400
Subject: [PATCH 410/416] feat(frontend): Explicit numeric generics and type
 kinds (#5155)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem\*

Resolves #4633, but only in the elaborator as we will be moving to this
new infrastructure for the frontend soon and resolving edge cases across
both the old resolver and the elaborator was becoming a time sink.

## Summary\*

We now have an `UnresolvedGeneric` type rather than simply representing
generics using idents.
```rust
pub enum UnresolvedGeneric {
    Variable(Ident),
    Numeric { ident: Ident, typ: UnresolvedType },
}
```
We also have a new `ResolvedGeneric` struct when storing generics during
resolution and elaboration. We were previously storing a tuple of three
elements, but now that I need to distinguish when we have a numeric
generic it was simpler to make this a struct.

Some example usage:
```rust
// Used as a field of a struct
struct Foo<let N: u64> {
    inner: [u64; N],
}
fn baz<let N: u64>() -> Foo<N> {
    Foo { inner: [1; N] }
}
// Used in an impl
impl<let N: u64> Foo<N> {
    fn bar(self) -> u64 {
        N * self.inner[0]
    }
}
```
More examples can be found in `numeric_generics` and documentation will
come in a follow-up.

We make sure to error out when an explicit numeric generic is used as a
type.
For example, this code:
```rust
struct Trash<let N: u64> {
    a: Field,
    b: N,
}
fn id_two<let I: Field>(x: I) -> I {
    x
}
```
<img width="749" alt="Screenshot 2024-06-04 at 5 42 53 PM"
src="https://github.com/noir-lang/noir/assets/43554004/a515a508-7ea4-4a23-bfd3-6f7bbae28e55">


## Additional Context

We do not ban the old strategy for implicit numeric generics just yet as
a lot of code uses it. Currently this warning is issued:
<img width="965" alt="Screenshot 2024-06-04 at 11 34 19 AM"
src="https://github.com/noir-lang/noir/assets/43554004/60c79337-98b2-4e70-a11d-947f6611fc41">


## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [X] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 aztec_macros/src/transforms/storage.rs        |   4 +-
 .../noirc_driver/tests/stdlib_warnings.rs     |   1 +
 compiler/noirc_frontend/src/ast/expression.rs |  69 ++-
 compiler/noirc_frontend/src/ast/mod.rs        |   6 +-
 compiler/noirc_frontend/src/ast/structure.rs  |   2 +-
 compiler/noirc_frontend/src/ast/traits.rs     |   4 +-
 .../src/elaborator/expressions.rs             |  17 +-
 compiler/noirc_frontend/src/elaborator/mod.rs | 188 ++++++--
 .../noirc_frontend/src/elaborator/patterns.rs |  14 +-
 .../noirc_frontend/src/elaborator/traits.rs   |  30 +-
 .../noirc_frontend/src/elaborator/types.rs    | 190 ++++++--
 .../src/hir/comptime/interpreter/builtin.rs   |   4 +-
 .../src/hir/def_collector/dc_crate.rs         |   6 +-
 .../src/hir/def_collector/dc_mod.rs           |  31 +-
 .../src/hir/def_collector/errors.rs           |  13 +-
 compiler/noirc_frontend/src/hir/mod.rs        |  40 +-
 .../src/hir/resolution/errors.rs              |  31 ++
 .../src/hir/resolution/functions.rs           |   9 +-
 .../src/hir/resolution/resolver.rs            | 139 ++++--
 .../src/hir/resolution/traits.rs              |  37 +-
 .../src/hir/type_check/errors.rs              |   9 +
 .../noirc_frontend/src/hir/type_check/expr.rs |   6 +-
 .../noirc_frontend/src/hir/type_check/mod.rs  |   6 +-
 .../noirc_frontend/src/hir_def/function.rs    |   4 +-
 compiler/noirc_frontend/src/hir_def/types.rs  | 212 +++++++--
 .../src/monomorphization/mod.rs               |   2 +-
 compiler/noirc_frontend/src/node_interner.rs  |  41 +-
 compiler/noirc_frontend/src/parser/mod.rs     |   2 +-
 .../src/parser/parser/function.rs             |  34 +-
 compiler/noirc_frontend/src/tests.rs          | 442 +++++++++++++++++-
 .../numeric_generics/src/main.nr              |   1 -
 .../numeric_generics_explicit/Nargo.toml      |   7 +
 .../numeric_generics_explicit/src/main.nr     | 111 +++++
 .../regression_4635/src/main.nr               |   2 +-
 .../trait_generics/src/main.nr                |   2 +-
 .../regression_4088/src/main.nr               |   4 +-
 .../regression_4124/src/main.nr               |   4 +-
 tooling/nargo_cli/build.rs                    |   4 +-
 tooling/nargo_cli/tests/stdlib-tests.rs       |   2 +-
 tooling/nargo_fmt/src/items.rs                |   3 +-
 tooling/nargo_fmt/src/utils.rs                |  23 +-
 tooling/nargo_fmt/tests/expected/fn.nr        |   4 +
 tooling/nargo_fmt/tests/input/fn.nr           |   5 +
 43 files changed, 1501 insertions(+), 264 deletions(-)
 create mode 100644 test_programs/compile_success_empty/numeric_generics_explicit/Nargo.toml
 create mode 100644 test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr

diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 872e7c37801..a2cc522b7a2 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -91,7 +91,7 @@ pub fn inject_context_in_storage(module: &mut SortedModule) -> Result<(), AztecM
             r#struct.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(storage)"))
         })
         .unwrap();
-    storage_struct.generics.push(ident("Context"));
+    storage_struct.generics.push(ident("Context").into());
     storage_struct
         .fields
         .iter_mut()
@@ -243,7 +243,7 @@ pub fn generate_storage_implementation(
             span: Some(Span::default()),
         },
         type_span: Span::default(),
-        generics: vec![generic_context_ident],
+        generics: vec![generic_context_ident.into()],
 
         methods: vec![(init, Span::default())],
 
diff --git a/compiler/noirc_driver/tests/stdlib_warnings.rs b/compiler/noirc_driver/tests/stdlib_warnings.rs
index 327c8daad06..84f46793caf 100644
--- a/compiler/noirc_driver/tests/stdlib_warnings.rs
+++ b/compiler/noirc_driver/tests/stdlib_warnings.rs
@@ -3,6 +3,7 @@ use std::path::Path;
 use noirc_driver::{file_manager_with_stdlib, prepare_crate, ErrorsAndWarnings};
 use noirc_frontend::hir::{def_map::parse_file, Context};
 
+#[ignore = "Temporarily ignoring the test until the stdlib is updated to use explicit numeric generics"]
 #[test]
 fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings> {
     // We use a minimal source file so that if stdlib produces warnings then we can expect these warnings to _always_
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 2657869a9d7..b2fb6013613 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -5,9 +5,11 @@ use crate::ast::{
     Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
+use crate::hir::def_collector::errors::DefCollectorErrorKind;
 use crate::macros_api::StructId;
 use crate::node_interner::ExprId;
 use crate::token::{Attributes, Token, Tokens};
+use crate::{Kind, Type};
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
@@ -46,7 +48,72 @@ pub enum ExpressionKind {
 
 /// A Vec of unresolved names for type variables.
 /// For `fn foo<A, B>(...)` this corresponds to vec!["A", "B"].
-pub type UnresolvedGenerics = Vec<Ident>;
+pub type UnresolvedGenerics = Vec<UnresolvedGeneric>;
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum UnresolvedGeneric {
+    Variable(Ident),
+    Numeric { ident: Ident, typ: UnresolvedType },
+}
+
+impl UnresolvedGeneric {
+    pub fn span(&self) -> Span {
+        match self {
+            UnresolvedGeneric::Variable(ident) => ident.0.span(),
+            UnresolvedGeneric::Numeric { ident, typ } => {
+                ident.0.span().merge(typ.span.unwrap_or_default())
+            }
+        }
+    }
+
+    pub fn kind(&self) -> Result<Kind, DefCollectorErrorKind> {
+        match self {
+            UnresolvedGeneric::Variable(_) => Ok(Kind::Normal),
+            UnresolvedGeneric::Numeric { typ, .. } => {
+                let typ = self.resolve_numeric_kind_type(typ)?;
+                Ok(Kind::Numeric(Box::new(typ)))
+            }
+        }
+    }
+
+    fn resolve_numeric_kind_type(
+        &self,
+        typ: &UnresolvedType,
+    ) -> Result<Type, DefCollectorErrorKind> {
+        use crate::ast::UnresolvedTypeData::{FieldElement, Integer};
+
+        match typ.typ {
+            FieldElement => Ok(Type::FieldElement),
+            Integer(sign, bits) => Ok(Type::Integer(sign, bits)),
+            // Only fields and integers are supported for numeric kinds
+            _ => Err(DefCollectorErrorKind::UnsupportedNumericGenericType {
+                ident: self.ident().clone(),
+                typ: typ.typ.clone(),
+            }),
+        }
+    }
+
+    pub(crate) fn ident(&self) -> &Ident {
+        match self {
+            UnresolvedGeneric::Variable(ident) | UnresolvedGeneric::Numeric { ident, .. } => ident,
+        }
+    }
+}
+
+impl Display for UnresolvedGeneric {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            UnresolvedGeneric::Variable(ident) => write!(f, "{ident}"),
+            UnresolvedGeneric::Numeric { ident, typ } => write!(f, "let {ident}: {typ}"),
+        }
+    }
+}
+
+impl From<Ident> for UnresolvedGeneric {
+    fn from(value: Ident) -> Self {
+        UnresolvedGeneric::Variable(value)
+    }
+}
 
 impl ExpressionKind {
     pub fn into_path(self) -> Option<Path> {
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index a1ae349b537..ddd675cef30 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -146,7 +146,7 @@ pub struct UnaryRhsMethodCall {
 }
 
 /// The precursor to TypeExpression, this is the type that the parser allows
-/// to be used in the length position of an array type. Only constants, variables,
+/// to be used in the length position of an array type. Only constant integers, variables,
 /// and numeric binary operators are allowed here.
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum UnresolvedTypeExpression {
@@ -259,6 +259,10 @@ impl UnresolvedType {
     pub fn unspecified() -> UnresolvedType {
         UnresolvedType { typ: UnresolvedTypeData::Unspecified, span: None }
     }
+
+    pub(crate) fn is_type_expression(&self) -> bool {
+        matches!(&self.typ, UnresolvedTypeData::Expression(_))
+    }
 }
 
 impl UnresolvedTypeData {
diff --git a/compiler/noirc_frontend/src/ast/structure.rs b/compiler/noirc_frontend/src/ast/structure.rs
index bda6b8c0b11..bb2d89841b9 100644
--- a/compiler/noirc_frontend/src/ast/structure.rs
+++ b/compiler/noirc_frontend/src/ast/structure.rs
@@ -20,7 +20,7 @@ impl NoirStruct {
     pub fn new(
         name: Ident,
         attributes: Vec<SecondaryAttribute>,
-        generics: Vec<Ident>,
+        generics: UnresolvedGenerics,
         fields: Vec<(Ident, UnresolvedType)>,
         span: Span,
     ) -> NoirStruct {
diff --git a/compiler/noirc_frontend/src/ast/traits.rs b/compiler/noirc_frontend/src/ast/traits.rs
index 9d7345d0270..b1b14e3f657 100644
--- a/compiler/noirc_frontend/src/ast/traits.rs
+++ b/compiler/noirc_frontend/src/ast/traits.rs
@@ -14,7 +14,7 @@ use crate::node_interner::TraitId;
 #[derive(Clone, Debug)]
 pub struct NoirTrait {
     pub name: Ident,
-    pub generics: Vec<Ident>,
+    pub generics: UnresolvedGenerics,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub span: Span,
     pub items: Vec<TraitItem>,
@@ -26,7 +26,7 @@ pub struct NoirTrait {
 pub enum TraitItem {
     Function {
         name: Ident,
-        generics: Vec<Ident>,
+        generics: UnresolvedGenerics,
         parameters: Vec<(Ident, UnresolvedType)>,
         return_type: FunctionReturnType,
         where_clause: Vec<UnresolvedTraitConstraint>,
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 9d864a0de91..02d4225875b 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -29,7 +29,7 @@ use crate::{
     },
     node_interner::{DefinitionKind, ExprId, FuncId},
     token::Tokens,
-    QuotedType, Shared, StructType, Type,
+    Kind, QuotedType, Shared, StructType, Type,
 };
 
 use super::Elaborator;
@@ -52,7 +52,20 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::If(if_) => self.elaborate_if(*if_),
             ExpressionKind::Variable(variable, generics) => {
                 let generics = generics.map(|option_inner| {
-                    option_inner.into_iter().map(|generic| self.resolve_type(generic)).collect()
+                    option_inner
+                        .into_iter()
+                        .map(|generic| {
+                            // All type expressions should resolve to a `Type::Constant`
+                            if generic.is_type_expression() {
+                                self.resolve_type_inner(
+                                    generic,
+                                    &Kind::Numeric(Box::new(Type::default_int_type())),
+                                )
+                            } else {
+                                self.resolve_type(generic)
+                            }
+                        })
+                        .collect()
                 });
                 return self.elaborate_variable(variable, generics);
             }
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index dc99ceae2f0..7b3cc59e341 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -22,6 +22,7 @@ use crate::{
         expr::HirIdent,
         function::{FunctionBody, Parameters},
         traits::TraitConstraint,
+        types::{Generics, Kind, ResolvedGeneric},
     },
     macros_api::{
         BlockExpression, Ident, NodeInterner, NoirFunction, NoirStruct, Pattern,
@@ -33,7 +34,7 @@ use crate::{
     Shared, Type, TypeVariable,
 };
 use crate::{
-    ast::{TraitBound, UnresolvedGenerics},
+    ast::{TraitBound, UnresolvedGeneric, UnresolvedGenerics},
     graph::CrateId,
     hir::{
         def_collector::{dc_crate::CollectedItems, errors::DefCollectorErrorKind},
@@ -44,7 +45,6 @@ use crate::{
     hir_def::function::{FuncMeta, HirFunction},
     macros_api::{Param, Path, UnresolvedType, UnresolvedTypeData},
     node_interner::TraitImplId,
-    Generics,
 };
 use crate::{
     hir::{
@@ -105,7 +105,7 @@ pub struct Elaborator<'context> {
     /// unique type variables if we're resolving a struct. Empty otherwise.
     /// This is a Vec rather than a map to preserve the order a functions generics
     /// were declared in.
-    generics: Vec<(Rc<String>, TypeVariable, Span)>,
+    generics: Vec<ResolvedGeneric>,
 
     /// When resolving lambda expressions, we need to keep track of the variables
     /// that are captured. We do this in order to create the hidden environment
@@ -239,12 +239,13 @@ impl<'context> Elaborator<'context> {
             self.define_type_alias(alias_id, alias);
         }
 
-        self.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
-        self.collect_traits(items.traits);
-
         // Must resolve structs before we resolve globals.
         self.collect_struct_definitions(items.types);
 
+        self.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
+
+        self.collect_traits(items.traits);
+
         // Before we resolve any function symbols we must go through our impls and
         // re-collect the methods within into their proper module. This cannot be
         // done during def collection since we need to be able to resolve the type of
@@ -335,14 +336,26 @@ impl<'context> Elaborator<'context> {
             self.in_unconstrained_fn = true;
         }
 
+        // Introduce all numeric generics into scope
+        for generic in &func_meta.all_generics {
+            if let Kind::Numeric(typ) = &generic.kind {
+                let definition = DefinitionKind::GenericType(generic.type_var.clone());
+                let ident = Ident::new(generic.name.to_string(), generic.span);
+                let hir_ident =
+                    self.add_variable_decl_inner(ident, false, false, false, definition);
+                self.interner.push_definition_type(hir_ident.id, *typ.clone());
+            }
+        }
+
         // The DefinitionIds for each parameter were already created in define_function_meta
         // so we need to reintroduce the same IDs into scope here.
         for parameter in &func_meta.parameter_idents {
             let name = self.interner.definition_name(parameter.id).to_owned();
-            self.add_existing_variable_to_scope(name, parameter.clone());
+            self.add_existing_variable_to_scope(name, parameter.clone(), true);
         }
 
         self.generics = func_meta.all_generics.clone();
+
         self.declare_numeric_generics(&func_meta.parameters, func_meta.return_type());
         self.add_trait_constraints_to_scope(&func_meta);
 
@@ -439,7 +452,7 @@ impl<'context> Elaborator<'context> {
         generics.push(new_generic.clone());
 
         let name = format!("impl {trait_path}");
-        let generic_type = Type::NamedGeneric(new_generic, Rc::new(name));
+        let generic_type = Type::NamedGeneric(new_generic, Rc::new(name), Kind::Normal);
         let trait_bound = TraitBound { trait_path, trait_id: None, trait_generics };
 
         if let Some(new_constraint) = self.resolve_trait_bound(&trait_bound, generic_type.clone()) {
@@ -456,25 +469,57 @@ impl<'context> Elaborator<'context> {
             // Map the generic to a fresh type variable
             let id = self.interner.next_type_variable_id();
             let typevar = TypeVariable::unbound(id);
-            let span = generic.0.span();
+            let ident = generic.ident();
+            let span = ident.0.span();
+
+            // Resolve the generic's kind
+            let kind = self.resolve_generic_kind(generic);
 
             // Check for name collisions of this generic
-            let name = Rc::new(generic.0.contents.clone());
+            let name = Rc::new(ident.0.contents.clone());
+
+            let resolved_generic =
+                ResolvedGeneric { name: name.clone(), type_var: typevar.clone(), kind, span };
 
-            if let Some((_, _, first_span)) = self.find_generic(&name) {
+            if let Some(generic) = self.find_generic(&name) {
                 self.push_err(ResolverError::DuplicateDefinition {
-                    name: generic.0.contents.clone(),
-                    first_span: *first_span,
+                    name: ident.0.contents.clone(),
+                    first_span: generic.span,
                     second_span: span,
                 });
             } else {
-                self.generics.push((name, typevar.clone(), span));
+                self.generics.push(resolved_generic.clone());
             }
 
-            typevar
+            resolved_generic
         })
     }
 
+    /// Return the kind of an unresolved generic.
+    /// If a numeric generic has been specified, resolve the annotated type to make
+    /// sure only primitive numeric types are being used.
+    pub(super) fn resolve_generic_kind(&mut self, generic: &UnresolvedGeneric) -> Kind {
+        if let UnresolvedGeneric::Numeric { ident, typ } = generic {
+            let typ = typ.clone();
+            let typ = if typ.is_type_expression() {
+                self.resolve_type_inner(typ, &Kind::Numeric(Box::new(Type::default_int_type())))
+            } else {
+                self.resolve_type(typ.clone())
+            };
+            if !matches!(typ, Type::FieldElement | Type::Integer(_, _)) {
+                let unsupported_typ_err =
+                    CompilationError::ResolverError(ResolverError::UnsupportedNumericGenericType {
+                        ident: ident.clone(),
+                        typ: typ.clone(),
+                    });
+                self.errors.push((unsupported_typ_err, self.file));
+            }
+            Kind::Numeric(Box::new(typ))
+        } else {
+            Kind::Normal
+        }
+    }
+
     fn push_err(&mut self, error: impl Into<CompilationError>) {
         self.errors.push((error.into(), self.file));
     }
@@ -523,12 +568,20 @@ impl<'context> Elaborator<'context> {
     }
 
     fn resolve_trait_bound(&mut self, bound: &TraitBound, typ: Type) -> Option<TraitConstraint> {
-        let trait_generics = vecmap(&bound.trait_generics, |typ| self.resolve_type(typ.clone()));
+        let the_trait = self.lookup_trait_or_error(bound.trait_path.clone())?;
+
+        let resolved_generics = &the_trait.generics.clone();
+        assert_eq!(resolved_generics.len(), bound.trait_generics.len());
+        let generics_with_types = resolved_generics.iter().zip(&bound.trait_generics);
+        let trait_generics = vecmap(generics_with_types, |(generic, typ)| {
+            self.resolve_type_inner(typ.clone(), &generic.kind)
+        });
 
-        let span = bound.trait_path.span();
         let the_trait = self.lookup_trait_or_error(bound.trait_path.clone())?;
         let trait_id = the_trait.id;
 
+        let span = bound.trait_path.span();
+
         let expected_generics = the_trait.generics.len();
         let actual_generics = trait_generics.len();
 
@@ -596,7 +649,7 @@ impl<'context> Elaborator<'context> {
 
         let mut trait_constraints = self.resolve_trait_constraints(&func.def.where_clause);
 
-        let mut generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
+        let mut generics = vecmap(&self.generics, |generic| generic.type_var.clone());
         let mut parameters = Vec::new();
         let mut parameter_types = Vec::new();
         let mut parameter_idents = Vec::new();
@@ -612,7 +665,7 @@ impl<'context> Elaborator<'context> {
                 UnresolvedTypeData::TraitAsType(path, args) => {
                     self.desugar_impl_trait_arg(path, args, &mut generics, &mut trait_constraints)
                 }
-                _ => self.resolve_type_inner(typ),
+                _ => self.resolve_type_inner(typ, &Kind::Normal),
             };
 
             self.check_if_type_is_valid_for_program_input(
@@ -621,6 +674,7 @@ impl<'context> Elaborator<'context> {
                 has_inline_attribute,
                 type_span,
             );
+
             let pattern = self.elaborate_pattern_and_store_ids(
                 pattern,
                 typ.clone(),
@@ -645,8 +699,8 @@ impl<'context> Elaborator<'context> {
 
         let direct_generics = func.def.generics.iter();
         let direct_generics = direct_generics
-            .filter_map(|generic| self.find_generic(&generic.0.contents))
-            .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
+            .filter_map(|generic| self.find_generic(&generic.ident().0.contents))
+            .map(|ResolvedGeneric { name, type_var, .. }| (name.clone(), type_var.clone()))
             .collect();
 
         let statements = std::mem::take(&mut func.def.body.statements);
@@ -710,6 +764,7 @@ impl<'context> Elaborator<'context> {
         }
     }
 
+    // TODO(https://github.com/noir-lang/noir/issues/5156): Remove implicit numeric generics
     fn declare_numeric_generics(&mut self, params: &Parameters, return_type: &Type) {
         if self.generics.is_empty() {
             return;
@@ -722,12 +777,32 @@ impl<'context> Elaborator<'context> {
             // We can fail to find the generic in self.generics if it is an implicit one created
             // by the compiler. This can happen when, e.g. eliding array lengths using the slice
             // syntax [T].
-            if let Some((name, _, span)) =
-                self.generics.iter().find(|(name, _, _)| name.as_ref() == &name_to_find)
+            if let Some(ResolvedGeneric { name, span, kind, .. }) =
+                self.generics.iter_mut().find(|generic| generic.name.as_ref() == &name_to_find)
             {
+                let scope = self.scopes.get_mut_scope();
+                let value = scope.find(&name_to_find);
+                if value.is_some() {
+                    // With the addition of explicit numeric generics we do not want to introduce numeric generics in this manner
+                    // However, this is going to be a big breaking change so for now we simply issue a warning while users have time
+                    // to transition to the new syntax
+                    // e.g. this code would break with a duplicate definition error:
+                    // ```
+                    // fn foo<let N: u8>(arr: [Field; N]) { }
+                    // ```
+                    continue;
+                }
+                *kind = Kind::Numeric(Box::new(Type::default_int_type()));
                 let ident = Ident::new(name.to_string(), *span);
                 let definition = DefinitionKind::GenericType(type_variable);
-                self.add_variable_decl_inner(ident, false, false, false, definition);
+                self.add_variable_decl_inner(ident.clone(), false, false, false, definition);
+
+                self.errors.push((
+                    CompilationError::ResolverError(ResolverError::UseExplicitNumericGeneric {
+                        ident,
+                    }),
+                    self.file,
+                ));
             }
         }
     }
@@ -753,7 +828,7 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn elaborate_impls(&mut self, impls: Vec<(Vec<Ident>, Span, UnresolvedFunctions)>) {
+    fn elaborate_impls(&mut self, impls: Vec<(UnresolvedGenerics, Span, UnresolvedFunctions)>) {
         for (_, _, functions) in impls {
             self.file = functions.file_id;
             self.recover_generics(|this| this.elaborate_functions(functions));
@@ -783,7 +858,7 @@ impl<'context> Elaborator<'context> {
     fn collect_impls(
         &mut self,
         module: LocalModuleId,
-        impls: &mut [(Vec<Ident>, Span, UnresolvedFunctions)],
+        impls: &mut [(UnresolvedGenerics, Span, UnresolvedFunctions)],
     ) {
         self.local_module = module;
 
@@ -800,7 +875,6 @@ impl<'context> Elaborator<'context> {
         self.local_module = trait_impl.module_id;
         self.file = trait_impl.file_id;
         self.current_trait_impl = trait_impl.impl_id;
-        trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
 
         let self_type = trait_impl.methods.self_type.clone();
         let self_type =
@@ -844,7 +918,7 @@ impl<'context> Elaborator<'context> {
                 methods,
             });
 
-            let generics = vecmap(&self.generics, |(_, type_variable, _)| type_variable.clone());
+            let generics = vecmap(&self.generics, |generic| generic.type_var.clone());
 
             if let Err((prev_span, prev_file)) = self.interner.add_trait_implementation(
                 self_type.clone(),
@@ -868,6 +942,7 @@ impl<'context> Elaborator<'context> {
         }
 
         self.generics.clear();
+
         self.current_trait_impl = None;
         self.self_type = None;
     }
@@ -1100,11 +1175,32 @@ impl<'context> Elaborator<'context> {
 
             let attributes = std::mem::take(&mut typ.struct_def.attributes);
             let span = typ.struct_def.span;
-            let (generics, fields) = self.resolve_struct_fields(typ.struct_def, type_id);
 
+            let fields = self.resolve_struct_fields(typ.struct_def, type_id);
             self.interner.update_struct(type_id, |struct_def| {
                 struct_def.set_fields(fields);
-                struct_def.generics = generics;
+
+                // TODO(https://github.com/noir-lang/noir/issues/5156): Remove this with implicit numeric generics
+                // This is only necessary for resolving named types when implicit numeric generics are used.
+                let mut found_names = Vec::new();
+                struct_def.find_numeric_generics_in_fields(&mut found_names);
+                for generic in struct_def.generics.iter_mut() {
+                    for found_generic in found_names.iter() {
+                        if found_generic == generic.name.as_str() {
+                            if matches!(generic.kind, Kind::Normal) {
+                                let ident = Ident::new(generic.name.to_string(), generic.span);
+                                self.errors.push((
+                                    CompilationError::ResolverError(
+                                        ResolverError::UseExplicitNumericGeneric { ident },
+                                    ),
+                                    self.file,
+                                ));
+                                generic.kind = Kind::Numeric(Box::new(Type::default_int_type()));
+                            }
+                            break;
+                        }
+                    }
+                }
             });
 
             self.run_comptime_attributes_on_struct(attributes, type_id, span);
@@ -1167,17 +1263,20 @@ impl<'context> Elaborator<'context> {
         &mut self,
         unresolved: NoirStruct,
         struct_id: StructId,
-    ) -> (Generics, Vec<(Ident, Type)>) {
+    ) -> Vec<(Ident, Type)> {
         self.recover_generics(|this| {
-            let generics = this.add_generics(&unresolved.generics);
-
             this.current_item = Some(DependencyId::Struct(struct_id));
 
             this.resolving_ids.insert(struct_id);
+
+            let struct_def = this.interner.get_struct(struct_id);
+            this.add_existing_generics(&unresolved.generics, &struct_def.borrow().generics);
+
             let fields = vecmap(unresolved.fields, |(ident, typ)| (ident, this.resolve_type(typ)));
+
             this.resolving_ids.remove(&struct_id);
 
-            (generics, fields)
+            fields
         })
     }
 
@@ -1273,12 +1372,29 @@ impl<'context> Elaborator<'context> {
             self.file = trait_impl.file_id;
             self.local_module = trait_impl.module_id;
 
+            trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
             let unresolved_type = &trait_impl.object_type;
+
             self.add_generics(&trait_impl.generics);
             trait_impl.resolved_generics = self.generics.clone();
 
-            let trait_generics =
-                vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()));
+            // Fetch trait constraints here
+            let trait_generics = if let Some(trait_id) = trait_impl.trait_id {
+                let trait_def = self.interner.get_trait(trait_id);
+                let resolved_generics = trait_def.generics.clone();
+                assert_eq!(resolved_generics.len(), trait_impl.trait_generics.len());
+                trait_impl
+                    .trait_generics
+                    .iter()
+                    .enumerate()
+                    .map(|(i, generic)| {
+                        self.resolve_type_inner(generic.clone(), &resolved_generics[i].kind)
+                    })
+                    .collect()
+            } else {
+                // We still resolve as to continue type checking
+                vecmap(&trait_impl.trait_generics, |generic| self.resolve_type(generic.clone()))
+            };
 
             trait_impl.resolved_trait_generics = trait_generics;
 
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 4d07009e064..4f04f5c523c 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -301,9 +301,14 @@ impl<'context> Elaborator<'context> {
         ident
     }
 
-    pub fn add_existing_variable_to_scope(&mut self, name: String, ident: HirIdent) {
+    pub fn add_existing_variable_to_scope(
+        &mut self,
+        name: String,
+        ident: HirIdent,
+        warn_if_unused: bool,
+    ) {
         let second_span = ident.location.span;
-        let resolver_meta = ResolverMeta { num_times_used: 0, ident, warn_if_unused: true };
+        let resolver_meta = ResolverMeta { num_times_used: 0, ident, warn_if_unused };
 
         let old_value = self.scopes.get_mut_scope().add_key_value(name.clone(), resolver_meta);
 
@@ -389,6 +394,7 @@ impl<'context> Elaborator<'context> {
     ) -> (ExprId, Type) {
         let span = variable.span;
         let expr = self.resolve_variable(variable);
+
         let id = self.interner.push_expr(HirExpression::Ident(expr.clone(), generics.clone()));
         self.interner.push_expr_location(id, span, self.file);
         let typ = self.type_check_variable(expr, id, generics);
@@ -464,8 +470,8 @@ impl<'context> Elaborator<'context> {
 
             for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics) {
                 // Avoid binding t = t
-                if !arg.occurs(param.id()) {
-                    bindings.insert(param.id(), (param.clone(), arg.clone()));
+                if !arg.occurs(param.type_var.id()) {
+                    bindings.insert(param.type_var.id(), (param.type_var.clone(), arg.clone()));
                 }
             }
 
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index 3e04dbc784a..77ac8e476f8 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -1,10 +1,12 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, rc::Rc};
 
 use iter_extended::vecmap;
 use noirc_errors::Location;
 
 use crate::{
-    ast::{FunctionKind, TraitItem, UnresolvedGenerics, UnresolvedTraitConstraint},
+    ast::{
+        FunctionKind, TraitItem, UnresolvedGeneric, UnresolvedGenerics, UnresolvedTraitConstraint,
+    },
     hir::def_collector::dc_crate::UnresolvedTrait,
     hir_def::traits::{TraitConstant, TraitFunction, TraitType},
     macros_api::{
@@ -13,7 +15,7 @@ use crate::{
     },
     node_interner::{FuncId, TraitId},
     token::Attributes,
-    Type, TypeVariableKind,
+    Kind, ResolvedGeneric, Type, TypeVariableKind,
 };
 
 use super::Elaborator;
@@ -22,7 +24,11 @@ impl<'context> Elaborator<'context> {
     pub fn collect_traits(&mut self, traits: BTreeMap<TraitId, UnresolvedTrait>) {
         for (trait_id, unresolved_trait) in traits {
             self.recover_generics(|this| {
-                this.add_generics(&unresolved_trait.trait_def.generics);
+                let resolved_generics = this.interner.get_trait(trait_id).generics.clone();
+                this.add_existing_generics(
+                    &unresolved_trait.trait_def.generics,
+                    &resolved_generics,
+                );
 
                 // Resolve order
                 // 1. Trait Types ( Trait constants can have a trait type, therefore types before constants)
@@ -34,7 +40,6 @@ impl<'context> Elaborator<'context> {
 
                 this.interner.update_trait(trait_id, |trait_def| {
                     trait_def.set_methods(methods);
-                    trait_def.generics = vecmap(&this.generics, |(_, generic, _)| generic.clone());
                 });
             });
 
@@ -87,10 +92,20 @@ impl<'context> Elaborator<'context> {
                         Type::TypeVariable(self_typevar.clone(), TypeVariableKind::Normal);
                     let name_span = the_trait.name.span();
 
-                    this.add_existing_generic("Self", name_span, self_typevar);
+                    this.add_existing_generic(
+                        &UnresolvedGeneric::Variable(Ident::from("Self")),
+                        name_span,
+                        &ResolvedGeneric {
+                            name: Rc::new("Self".to_owned()),
+                            type_var: self_typevar,
+                            span: name_span,
+                            kind: Kind::Normal,
+                        },
+                    );
                     this.self_type = Some(self_type.clone());
 
                     let func_id = unresolved_trait.method_ids[&name.0.contents];
+
                     this.resolve_trait_function(
                         name,
                         generics,
@@ -105,7 +120,7 @@ impl<'context> Elaborator<'context> {
                     let arguments = vecmap(&func_meta.parameters.0, |(_, typ, _)| typ.clone());
                     let return_type = func_meta.return_type().clone();
 
-                    let generics = vecmap(&this.generics, |(_, type_var, _)| type_var.clone());
+                    let generics = vecmap(&this.generics, |generic| generic.type_var.clone());
 
                     let default_impl_list: Vec<_> = unresolved_trait
                         .fns_with_default_impl
@@ -147,6 +162,7 @@ impl<'context> Elaborator<'context> {
         func_id: FuncId,
     ) {
         let old_generic_count = self.generics.len();
+
         self.scopes.start_function();
 
         let kind = FunctionKind::Normal;
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index fcb7ac94c26..06f7b0f9b6c 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -5,9 +5,13 @@ use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
 use crate::{
-    ast::{BinaryOpKind, IntegerBitSize, UnresolvedGenerics, UnresolvedTypeExpression},
+    ast::{
+        BinaryOpKind, IntegerBitSize, UnresolvedGeneric, UnresolvedGenerics,
+        UnresolvedTypeExpression,
+    },
     hir::{
         comptime::{Interpreter, Value},
+        def_collector::dc_crate::CompilationError,
         def_map::ModuleDefId,
         resolution::{
             errors::ResolverError,
@@ -28,48 +32,75 @@ use crate::{
         UnaryOp, UnresolvedType, UnresolvedTypeData,
     },
     node_interner::{DefinitionKind, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId},
-    Generics, Type, TypeBinding, TypeVariable, TypeVariableKind,
+    Generics, Kind, ResolvedGeneric, Type, TypeBinding, TypeVariable, TypeVariableKind,
 };
 
 use super::{lints, Elaborator};
 
 impl<'context> Elaborator<'context> {
-    /// Translates an UnresolvedType to a Type
+    /// Translates an UnresolvedType to a Type with a `TypeKind::Normal`
     pub(super) fn resolve_type(&mut self, typ: UnresolvedType) -> Type {
         let span = typ.span;
-        let resolved_type = self.resolve_type_inner(typ);
+        let resolved_type = self.resolve_type_inner(typ, &Kind::Normal);
         if resolved_type.is_nested_slice() {
-            self.push_err(ResolverError::NestedSlices { span: span.unwrap() });
+            self.push_err(ResolverError::NestedSlices {
+                span: span.expect("Type should have span"),
+            });
         }
         resolved_type
     }
 
     /// Translates an UnresolvedType into a Type and appends any
     /// freshly created TypeVariables created to new_variables.
-    pub fn resolve_type_inner(&mut self, typ: UnresolvedType) -> Type {
+    pub fn resolve_type_inner(&mut self, typ: UnresolvedType, kind: &Kind) -> Type {
         use crate::ast::UnresolvedTypeData::*;
 
+        let span = typ.span;
+
         let resolved_type = match typ.typ {
             FieldElement => Type::FieldElement,
             Array(size, elem) => {
-                let elem = Box::new(self.resolve_type_inner(*elem));
-                let size = self.convert_expression_type(size);
+                let elem = Box::new(self.resolve_type_inner(*elem, kind));
+                let mut size = self.convert_expression_type(size);
+                // TODO(https://github.com/noir-lang/noir/issues/5156): Remove this once we only have explicit numeric generics
+                if let Type::NamedGeneric(type_var, name, _) = size {
+                    size = Type::NamedGeneric(
+                        type_var,
+                        name,
+                        Kind::Numeric(Box::new(Type::default_int_type())),
+                    );
+                }
                 Type::Array(Box::new(size), elem)
             }
             Slice(elem) => {
-                let elem = Box::new(self.resolve_type_inner(*elem));
+                let elem = Box::new(self.resolve_type_inner(*elem, kind));
                 Type::Slice(elem)
             }
             Expression(expr) => self.convert_expression_type(expr),
             Integer(sign, bits) => Type::Integer(sign, bits),
             Bool => Type::Bool,
             String(size) => {
-                let resolved_size = self.convert_expression_type(size);
+                let mut resolved_size = self.convert_expression_type(size);
+                // TODO(https://github.com/noir-lang/noir/issues/5156): Remove this once we only have explicit numeric generics
+                if let Type::NamedGeneric(type_var, name, _) = resolved_size {
+                    resolved_size = Type::NamedGeneric(
+                        type_var,
+                        name,
+                        Kind::Numeric(Box::new(Type::default_int_type())),
+                    );
+                }
                 Type::String(Box::new(resolved_size))
             }
             FormatString(size, fields) => {
-                let resolved_size = self.convert_expression_type(size);
-                let fields = self.resolve_type_inner(*fields);
+                let mut resolved_size = self.convert_expression_type(size);
+                if let Type::NamedGeneric(type_var, name, _) = resolved_size {
+                    resolved_size = Type::NamedGeneric(
+                        type_var,
+                        name,
+                        Kind::Numeric(Box::new(Type::default_int_type())),
+                    );
+                }
+                let fields = self.resolve_type_inner(*fields, kind);
                 Type::FmtString(Box::new(resolved_size), Box::new(fields))
             }
             Quoted(quoted) => Type::Quoted(quoted),
@@ -79,10 +110,12 @@ impl<'context> Elaborator<'context> {
             Named(path, args, _) => self.resolve_named_type(path, args),
             TraitAsType(path, args) => self.resolve_trait_as_type(path, args),
 
-            Tuple(fields) => Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field))),
+            Tuple(fields) => {
+                Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field, kind)))
+            }
             Function(args, ret, env) => {
-                let args = vecmap(args, |arg| self.resolve_type_inner(arg));
-                let ret = Box::new(self.resolve_type_inner(*ret));
+                let args = vecmap(args, |arg| self.resolve_type_inner(arg, kind));
+                let ret = Box::new(self.resolve_type_inner(*ret, kind));
 
                 // expect() here is valid, because the only places we don't have a span are omitted types
                 // e.g. a function without return type implicitly has a spanless UnresolvedType::Unit return type
@@ -90,10 +123,10 @@ impl<'context> Elaborator<'context> {
                 let env_span =
                     env.span.expect("Unexpected missing span for closure environment type");
 
-                let env = Box::new(self.resolve_type_inner(*env));
+                let env = Box::new(self.resolve_type_inner(*env, kind));
 
                 match *env {
-                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _) => {
+                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _, _) => {
                         Type::Function(args, ret, env)
                     }
                     _ => {
@@ -106,9 +139,9 @@ impl<'context> Elaborator<'context> {
                 }
             }
             MutableReference(element) => {
-                Type::MutableReference(Box::new(self.resolve_type_inner(*element)))
+                Type::MutableReference(Box::new(self.resolve_type_inner(*element, kind)))
             }
-            Parenthesized(typ) => self.resolve_type_inner(*typ),
+            Parenthesized(typ) => self.resolve_type_inner(*typ, kind),
         };
 
         if let Type::Struct(_, _) = resolved_type {
@@ -120,11 +153,37 @@ impl<'context> Elaborator<'context> {
                 );
             }
         }
+
+        // Check that any types with a type kind match the expected type kind supplied to this function
+        // TODO(https://github.com/noir-lang/noir/issues/5156): make this named generic check more general with `*resolved_kind != kind`
+        // as implicit numeric generics still existing makes this check more challenging to enforce
+        // An example of a more general check that we should switch to:
+        // if resolved_type.kind() != kind.clone() {
+        //     let expected_typ_err = CompilationError::TypeError(TypeCheckError::TypeKindMismatch {
+        //         expected_kind: kind.to_string(),
+        //         expr_kind: resolved_type.kind().to_string(),
+        //         expr_span: span.expect("Type should have span"),
+        //     });
+        //     self.errors.push((expected_typ_err, self.file));
+        //     return Type::Error;
+        // }
+        if let Type::NamedGeneric(_, name, resolved_kind) = &resolved_type {
+            if matches!(resolved_kind, Kind::Numeric { .. }) && matches!(kind, Kind::Normal) {
+                let expected_typ_err =
+                    CompilationError::ResolverError(ResolverError::NumericGenericUsedForType {
+                        name: name.to_string(),
+                        span: span.expect("Type should have span"),
+                    });
+                self.errors.push((expected_typ_err, self.file));
+                return Type::Error;
+            }
+        }
+
         resolved_type
     }
 
-    pub fn find_generic(&self, target_name: &str) -> Option<&(Rc<String>, TypeVariable, Span)> {
-        self.generics.iter().find(|(name, _, _)| name.as_ref() == target_name)
+    pub fn find_generic(&self, target_name: &str) -> Option<&ResolvedGeneric> {
+        self.generics.iter().find(|generic| generic.name.as_ref() == target_name)
     }
 
     fn resolve_named_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
@@ -152,7 +211,6 @@ impl<'context> Elaborator<'context> {
         }
 
         let span = path.span();
-        let mut args = vecmap(args, |arg| self.resolve_type_inner(arg));
 
         if let Some(type_alias) = self.lookup_type_alias(path.clone()) {
             let type_alias = type_alias.borrow();
@@ -160,6 +218,10 @@ impl<'context> Elaborator<'context> {
             let type_alias_string = type_alias.to_string();
             let id = type_alias.id;
 
+            let mut args = vecmap(type_alias.generics.iter().zip(args), |(generic, arg)| {
+                self.resolve_type_inner(arg, &generic.kind)
+            });
+
             self.verify_generics_count(expected_generic_count, &mut args, span, || {
                 type_alias_string
             });
@@ -192,6 +254,7 @@ impl<'context> Elaborator<'context> {
                 }
 
                 let expected_generic_count = struct_type.borrow().generics.len();
+
                 if !self.in_contract
                     && self
                         .interner
@@ -203,6 +266,12 @@ impl<'context> Elaborator<'context> {
                         span: struct_type.borrow().name.span(),
                     });
                 }
+
+                let mut args =
+                    vecmap(struct_type.borrow().generics.iter().zip(args), |(generic, arg)| {
+                        self.resolve_type_inner(arg, &generic.kind)
+                    });
+
                 self.verify_generics_count(expected_generic_count, &mut args, span, || {
                     struct_type.borrow().to_string()
                 });
@@ -219,10 +288,19 @@ impl<'context> Elaborator<'context> {
     }
 
     fn resolve_trait_as_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
-        let args = vecmap(args, |arg| self.resolve_type_inner(arg));
-
-        if let Some(t) = self.lookup_trait_or_error(path) {
-            Type::TraitAsType(t.id, Rc::new(t.name.to_string()), args)
+        // Fetch information needed from the trait as the closure for resolving all the `args`
+        // requires exclusive access to `self`
+        let trait_as_type_info = self
+            .lookup_trait_or_error(path)
+            .map(|t| (t.id, Rc::new(t.name.to_string()), t.generics.clone()));
+
+        if let Some((id, name, resolved_generics)) = trait_as_type_info {
+            assert_eq!(resolved_generics.len(), args.len());
+            let generics_with_types = resolved_generics.iter().zip(args);
+            let args = vecmap(generics_with_types, |(generic, typ)| {
+                self.resolve_type_inner(typ, &generic.kind)
+            });
+            Type::TraitAsType(id, Rc::new(name.to_string()), args)
         } else {
             Type::Error
         }
@@ -251,8 +329,9 @@ impl<'context> Elaborator<'context> {
     pub fn lookup_generic_or_global_type(&mut self, path: &Path) -> Option<Type> {
         if path.segments.len() == 1 {
             let name = &path.last_segment().0.contents;
-            if let Some((name, var, _)) = self.find_generic(name) {
-                return Some(Type::NamedGeneric(var.clone(), name.clone()));
+            if let Some(generic) = self.find_generic(name) {
+                let generic = generic.clone();
+                return Some(Type::NamedGeneric(generic.type_var, generic.name, generic.kind));
             }
         }
 
@@ -318,9 +397,12 @@ impl<'context> Elaborator<'context> {
 
                 let constraint = TraitConstraint {
                     typ: self.self_type.clone()?,
-                    trait_generics: Type::from_generics(&the_trait.generics),
+                    trait_generics: Type::from_generics(&vecmap(&the_trait.generics, |generic| {
+                        generic.type_var.clone()
+                    })),
                     trait_id,
                 };
+
                 return Some((method, constraint, false));
             }
         }
@@ -349,7 +431,9 @@ impl<'context> Elaborator<'context> {
                     the_trait.self_type_typevar.clone(),
                     TypeVariableKind::Normal,
                 ),
-                trait_generics: Type::from_generics(&the_trait.generics),
+                trait_generics: Type::from_generics(&vecmap(&the_trait.generics, |generic| {
+                    generic.type_var.clone()
+                })),
                 trait_id,
             };
             return Some((method, constraint, false));
@@ -371,7 +455,7 @@ impl<'context> Elaborator<'context> {
         }
 
         for constraint in self.trait_bounds.clone() {
-            if let Type::NamedGeneric(_, name) = &constraint.typ {
+            if let Type::NamedGeneric(_, name, _) = &constraint.typ {
                 // if `path` is `T::method_name`, we're looking for constraint of the form `T: SomeTrait`
                 if path.segments[0].0.contents != name.as_str() {
                     continue;
@@ -1077,7 +1161,7 @@ impl<'context> Elaborator<'context> {
                 });
                 None
             }
-            Type::NamedGeneric(_, _) => {
+            Type::NamedGeneric(_, _, _) => {
                 let func_meta = self.interner.function_meta(
                     &self.current_function.expect("unexpected method outside a function"),
                 );
@@ -1353,26 +1437,34 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub fn add_existing_generics(&mut self, names: &UnresolvedGenerics, generics: &Generics) {
-        assert_eq!(names.len(), generics.len());
+    pub fn add_existing_generics(
+        &mut self,
+        unresolved_generics: &UnresolvedGenerics,
+        generics: &Generics,
+    ) {
+        assert_eq!(unresolved_generics.len(), generics.len());
 
-        for (name, typevar) in names.iter().zip(generics) {
-            self.add_existing_generic(&name.0.contents, name.0.span(), typevar.clone());
+        for (unresolved_generic, generic) in unresolved_generics.iter().zip(generics) {
+            self.add_existing_generic(unresolved_generic, unresolved_generic.span(), generic);
         }
     }
 
-    pub fn add_existing_generic(&mut self, name: &str, span: Span, typevar: TypeVariable) {
-        // Check for name collisions of this generic
-        let rc_name = Rc::new(name.to_owned());
+    pub fn add_existing_generic(
+        &mut self,
+        unresolved_generic: &UnresolvedGeneric,
+        span: Span,
+        resolved_generic: &ResolvedGeneric,
+    ) {
+        let name = &unresolved_generic.ident().0.contents;
 
-        if let Some((_, _, first_span)) = self.find_generic(&rc_name) {
+        if let Some(generic) = self.find_generic(name) {
             self.push_err(ResolverError::DuplicateDefinition {
-                name: name.to_owned(),
-                first_span: *first_span,
+                name: name.clone(),
+                first_span: generic.span,
                 second_span: span,
             });
         } else {
-            self.generics.push((rc_name, typevar, span));
+            self.generics.push(resolved_generic.clone());
         }
     }
 
@@ -1397,7 +1489,7 @@ impl<'context> Elaborator<'context> {
             | Type::Error
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Quoted(_)
             | Type::Forall(_, _) => (),
 
@@ -1408,7 +1500,7 @@ impl<'context> Elaborator<'context> {
             }
 
             Type::Array(length, element_type) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
                 }
                 Self::find_numeric_generics_in_type(element_type, found);
@@ -1433,7 +1525,7 @@ impl<'context> Elaborator<'context> {
 
             Type::Struct(struct_type, generics) => {
                 for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name) = generic {
+                    if let Type::NamedGeneric(type_variable, name, _) = generic {
                         if struct_type.borrow().generic_is_numeric(i) {
                             found.insert(name.to_string(), type_variable.clone());
                         }
@@ -1444,7 +1536,7 @@ impl<'context> Elaborator<'context> {
             }
             Type::Alias(alias, generics) => {
                 for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name) = generic {
+                    if let Type::NamedGeneric(type_variable, name, _) = generic {
                         if alias.borrow().generic_is_numeric(i) {
                             found.insert(name.to_string(), type_variable.clone());
                         }
@@ -1455,12 +1547,12 @@ impl<'context> Elaborator<'context> {
             }
             Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found),
             Type::String(length) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
                 }
             }
             Type::FmtString(length, fields) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
                 }
                 Self::find_numeric_generics_in_type(fields, found);
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
index cccc9c6d545..48f05f287d8 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
@@ -86,7 +86,7 @@ fn type_def_as_type(
         if i != 0 {
             tokens.push(SpannedToken::new(Token::Comma, span));
         }
-        tokens.push(make_token(generic.borrow().to_string()));
+        tokens.push(make_token(generic.type_var.borrow().to_string()));
     }
 
     Ok(Value::Code(Rc::new(Tokens(tokens))))
@@ -112,7 +112,7 @@ fn type_def_generics(
         .generics
         .iter()
         .map(|generic| {
-            let name = SpannedToken::new(Token::Str(generic.borrow().to_string()), span);
+            let name = SpannedToken::new(Token::Str(generic.type_var.borrow().to_string()), span);
             Value::Code(Rc::new(Tokens(vec![name])))
         })
         .collect();
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 216ed5fc545..9afff6a6055 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -5,7 +5,7 @@ use crate::graph::CrateId;
 use crate::hir::comptime::{Interpreter, InterpreterError};
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
-use crate::{Type, TypeVariable};
+use crate::{ResolvedGeneric, Type};
 
 use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
 use crate::hir::resolution::{
@@ -33,7 +33,6 @@ use iter_extended::vecmap;
 use noirc_errors::{CustomDiagnostic, Span};
 use std::collections::{BTreeMap, HashMap};
 
-use std::rc::Rc;
 use std::vec;
 
 #[derive(Default)]
@@ -125,7 +124,7 @@ pub struct UnresolvedTraitImpl {
     pub trait_id: Option<TraitId>,
     pub impl_id: Option<TraitImplId>,
     pub resolved_object_type: Option<Type>,
-    pub resolved_generics: Vec<(Rc<String>, TypeVariable, Span)>,
+    pub resolved_generics: Vec<ResolvedGeneric>,
 
     // The resolved generic on the trait itself. E.g. it is the `<C, D>` in
     // `impl<A, B> Foo<C, D> for Bar<E, F> { ... }`
@@ -379,6 +378,7 @@ impl DefCollector {
             def_collector.items.traits,
             crate_id,
         ));
+
         // Must resolve structs before we resolve globals.
         resolved_module.errors.extend(resolve_structs(
             context,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index e7bbe5951d8..3d8a861b009 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -309,11 +309,21 @@ impl<'a> ModCollector<'a> {
                 struct_def: struct_definition,
             };
 
+            let resolved_generics = context.resolve_generics(
+                &unresolved.struct_def.generics,
+                &mut definition_errors,
+                self.file_id,
+            );
+
             // Create the corresponding module for the struct namespace
             let id = match self.push_child_module(&name, self.file_id, false, false) {
-                Ok(local_id) => {
-                    context.def_interner.new_struct(&unresolved, krate, local_id, self.file_id)
-                }
+                Ok(local_id) => context.def_interner.new_struct(
+                    &unresolved,
+                    resolved_generics,
+                    krate,
+                    local_id,
+                    self.file_id,
+                ),
                 Err(error) => {
                     definition_errors.push((error.into(), self.file_id));
                     continue;
@@ -357,7 +367,14 @@ impl<'a> ModCollector<'a> {
                 type_alias_def: type_alias,
             };
 
-            let type_alias_id = context.def_interner.push_type_alias(&unresolved);
+            let resolved_generics = context.resolve_generics(
+                &unresolved.type_alias_def.generics,
+                &mut errors,
+                self.file_id,
+            );
+
+            let type_alias_id =
+                context.def_interner.push_type_alias(&unresolved, resolved_generics);
 
             // Add the type alias to scope so its path can be looked up later
             let result = self.def_collector.def_map.modules[self.module_id.0]
@@ -517,6 +534,9 @@ impl<'a> ModCollector<'a> {
                 }
             }
 
+            let resolved_generics =
+                context.resolve_generics(&trait_definition.generics, &mut errors, self.file_id);
+
             // And store the TraitId -> TraitType mapping somewhere it is reachable
             let unresolved = UnresolvedTrait {
                 file_id: self.file_id,
@@ -526,7 +546,8 @@ impl<'a> ModCollector<'a> {
                 method_ids,
                 fns_with_default_impl: unresolved_functions,
             };
-            context.def_interner.push_empty_trait(trait_id, &unresolved);
+            context.def_interner.push_empty_trait(trait_id, &unresolved, resolved_generics);
+
             self.def_collector.items.traits.insert(trait_id, unresolved);
         }
         errors
diff --git a/compiler/noirc_frontend/src/hir/def_collector/errors.rs b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
index edeb463e10d..af2264c3843 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/errors.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
@@ -1,4 +1,4 @@
-use crate::ast::{Ident, Path};
+use crate::ast::{Ident, Path, UnresolvedTypeData};
 use crate::hir::resolution::import::PathResolutionError;
 
 use noirc_errors::CustomDiagnostic as Diagnostic;
@@ -66,6 +66,8 @@ pub enum DefCollectorErrorKind {
     TraitImplOrphaned { span: Span },
     #[error("macro error : {0:?}")]
     MacroError(MacroError),
+    #[error("The only supported types of numeric generics are integers, fields, and booleans")]
+    UnsupportedNumericGenericType { ident: Ident, typ: UnresolvedTypeData },
 }
 
 /// An error struct that macro processors can return.
@@ -228,6 +230,15 @@ impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
             DefCollectorErrorKind::MacroError(macro_error) => {
                 Diagnostic::simple_error(macro_error.primary_message.clone(), macro_error.secondary_message.clone().unwrap_or_default(), macro_error.span.unwrap_or_default())
             },
+            DefCollectorErrorKind::UnsupportedNumericGenericType { ident, typ } => {
+                let name = &ident.0.contents;
+
+                Diagnostic::simple_error(
+                    format!("{name} has a type of {typ}. The only supported types of numeric generics are integers and fields"),
+                    "Unsupported numeric generic type".to_string(),
+                    ident.0.span(),
+                )
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/mod.rs b/compiler/noirc_frontend/src/hir/mod.rs
index 55dc22d6c5d..71fdc6b30d2 100644
--- a/compiler/noirc_frontend/src/hir/mod.rs
+++ b/compiler/noirc_frontend/src/hir/mod.rs
@@ -5,17 +5,21 @@ pub mod resolution;
 pub mod scope;
 pub mod type_check;
 
+use crate::ast::UnresolvedGenerics;
 use crate::debug::DebugInstrumenter;
 use crate::graph::{CrateGraph, CrateId};
 use crate::hir_def::function::FuncMeta;
 use crate::node_interner::{FuncId, NodeInterner, StructId};
 use crate::parser::ParserError;
-use crate::ParsedModule;
+use crate::{Generics, Kind, ParsedModule, ResolvedGeneric, Type, TypeVariable};
+use def_collector::dc_crate::CompilationError;
 use def_map::{Contract, CrateDefMap};
-use fm::FileManager;
+use fm::{FileId, FileManager};
+use iter_extended::vecmap;
 use noirc_errors::Location;
 use std::borrow::Cow;
 use std::collections::{BTreeMap, HashMap};
+use std::rc::Rc;
 
 use self::def_map::TestFunction;
 
@@ -80,7 +84,7 @@ impl Context<'_, '_> {
         }
     }
 
-    pub fn parsed_file_results(&self, file_id: fm::FileId) -> (ParsedModule, Vec<ParserError>) {
+    pub fn parsed_file_results(&self, file_id: FileId) -> (ParsedModule, Vec<ParserError>) {
         self.parsed_files.get(&file_id).expect("noir file wasn't parsed").clone()
     }
 
@@ -256,4 +260,34 @@ impl Context<'_, '_> {
     pub fn module(&self, module_id: def_map::ModuleId) -> &def_map::ModuleData {
         module_id.module(&self.def_maps)
     }
+
+    /// Generics need to be resolved before elaboration to distinguish
+    /// between normal and numeric generics.
+    /// This method is expected to be used during definition collection.
+    /// Each result is returned in a list rather than returned as a single result as to allow
+    /// definition collection to provide an error for each ill-formed numeric generic.
+    pub(crate) fn resolve_generics(
+        &mut self,
+        generics: &UnresolvedGenerics,
+        errors: &mut Vec<(CompilationError, FileId)>,
+        file_id: FileId,
+    ) -> Generics {
+        vecmap(generics, |generic| {
+            // Map the generic to a fresh type variable
+            let id = self.def_interner.next_type_variable_id();
+            let type_var = TypeVariable::unbound(id);
+            let ident = generic.ident();
+            let span = ident.0.span();
+
+            // Check for name collisions of this generic
+            let name = Rc::new(ident.0.contents.clone());
+
+            let kind = generic.kind().unwrap_or_else(|err| {
+                errors.push((err.into(), file_id));
+                Kind::Numeric(Box::new(Type::Error))
+            });
+
+            ResolvedGeneric { name, type_var, kind, span }
+        })
+    }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index dad0149ec73..bf6de746791 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -98,6 +98,12 @@ pub enum ResolverError {
     NoPredicatesAttributeOnUnconstrained { ident: Ident },
     #[error("#[fold] attribute is only allowed on constrained functions")]
     FoldAttributeOnUnconstrained { ident: Ident },
+    #[error("The only supported types of numeric generics are integers, fields, and booleans")]
+    UnsupportedNumericGenericType { ident: Ident, typ: Type },
+    #[error("Numeric generics should be explicit")]
+    UseExplicitNumericGeneric { ident: Ident },
+    #[error("expected type, found numeric generic parameter")]
+    NumericGenericUsedForType { name: String, span: Span },
     #[error("Invalid array length construction")]
     ArrayLengthInterpreter { error: InterpreterError },
     #[error("The unquote operator '$' can only be used within a quote expression")]
@@ -400,6 +406,31 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diag.add_note("The `#[fold]` attribute specifies whether a constrained function should be treated as a separate circuit rather than inlined into the program entry point".to_owned());
                 diag
             }
+            ResolverError::UnsupportedNumericGenericType { ident , typ } => {
+                let name = &ident.0.contents;
+
+                Diagnostic::simple_error(
+                    format!("{name} has a type of {typ}. The only supported types of numeric generics are integers, fields, and booleans."),
+                    "Unsupported numeric generic type".to_string(),
+                    ident.0.span(),
+                )
+            }
+            ResolverError::UseExplicitNumericGeneric { ident } => {
+                let name = &ident.0.contents;
+
+                Diagnostic::simple_warning(
+                    String::from("Noir now supports explicit numeric generics. Support for implicit numeric generics will be removed in the following release."), 
+                format!("Numeric generic `{name}` should now be specified with `let {name}: <annotated type>`"), 
+                ident.0.span(),
+                )
+            }
+            ResolverError::NumericGenericUsedForType { name, span } => {
+                Diagnostic::simple_error(
+                    format!("expected type, found numeric generic parameter {name}"),
+                    String::from("not a type"),
+                    *span,
+                )
+            }
             ResolverError::ArrayLengthInterpreter { error } => Diagnostic::from(error),
             ResolverError::UnquoteUsedOutsideQuote { span } => {
                 Diagnostic::simple_error(
diff --git a/compiler/noirc_frontend/src/hir/resolution/functions.rs b/compiler/noirc_frontend/src/hir/resolution/functions.rs
index e63de9b9173..fe46796ed24 100644
--- a/compiler/noirc_frontend/src/hir/resolution/functions.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/functions.rs
@@ -1,8 +1,7 @@
-use std::{collections::BTreeMap, rc::Rc};
+use std::collections::BTreeMap;
 
 use fm::FileId;
 use iter_extended::vecmap;
-use noirc_errors::Span;
 
 use crate::{
     graph::CrateId,
@@ -11,10 +10,10 @@ use crate::{
         def_map::{CrateDefMap, ModuleId},
     },
     node_interner::{FuncId, NodeInterner, TraitImplId},
-    Type, TypeVariable,
+    ResolvedGeneric, Type,
 };
 
-use super::{path_resolver::StandardPathResolver, resolver::Resolver};
+use super::{path_resolver::StandardPathResolver, Resolver};
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn resolve_function_set(
@@ -24,7 +23,7 @@ pub(crate) fn resolve_function_set(
     mut unresolved_functions: UnresolvedFunctions,
     self_type: Option<Type>,
     trait_impl_id: Option<TraitImplId>,
-    impl_generics: Vec<(Rc<String>, TypeVariable, Span)>,
+    impl_generics: Vec<ResolvedGeneric>,
     errors: &mut Vec<(CompilationError, FileId)>,
 ) -> Vec<(FileId, FuncId)> {
     let file_id = unresolved_functions.file_id;
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 5706e62e193..ebb3f7290ea 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -32,8 +32,9 @@ use crate::ast::{
     ArrayLiteral, BinaryOpKind, BlockExpression, Expression, ExpressionKind, ForRange,
     FunctionDefinition, FunctionKind, FunctionReturnType, Ident, ItemVisibility, LValue,
     LetStatement, Literal, NoirFunction, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern,
-    Statement, StatementKind, TraitBound, UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint,
-    UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, Visibility, ERROR_IDENT,
+    Statement, StatementKind, TraitBound, UnaryOp, UnresolvedGeneric, UnresolvedGenerics,
+    UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
+    Visibility, ERROR_IDENT,
 };
 use crate::graph::CrateId;
 use crate::hir::def_map::{ModuleDefId, TryFromModuleDefId, MAIN_FUNCTION};
@@ -47,7 +48,10 @@ use crate::node_interner::{
     DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, NodeInterner, StmtId,
     StructId, TraitId, TraitImplId, TraitMethodId, TypeAliasId,
 };
-use crate::{Generics, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind};
+use crate::{
+    GenericTypeVars, Generics, Kind, ResolvedGeneric, Shared, StructType, Type, TypeAlias,
+    TypeVariable, TypeVariableKind,
+};
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span, Spanned};
@@ -131,7 +135,7 @@ pub struct Resolver<'a> {
     /// unique type variables if we're resolving a struct. Empty otherwise.
     /// This is a Vec rather than a map to preserve the order a functions generics
     /// were declared in.
-    generics: Vec<(Rc<String>, TypeVariable, Span)>,
+    generics: Vec<ResolvedGeneric>,
 
     /// When resolving lambda expressions, we need to keep track of the variables
     /// that are captured. We do this in order to create the hidden environment
@@ -223,7 +227,8 @@ impl<'a> Resolver<'a> {
                 let mut new_generic_ident: Ident =
                     format!("T{}_impl_{}", func_id, path.as_string()).into();
                 let mut new_generic_path = Path::from_ident(new_generic_ident.clone());
-                while impl_trait_generics.contains(&new_generic_ident)
+                let new_generic = UnresolvedGeneric::from(new_generic_ident.clone());
+                while impl_trait_generics.contains(&new_generic)
                     || self.lookup_generic_or_global_type(&new_generic_path).is_some()
                 {
                     new_generic_ident =
@@ -231,7 +236,7 @@ impl<'a> Resolver<'a> {
                     new_generic_path = Path::from_ident(new_generic_ident.clone());
                     counter += 1;
                 }
-                impl_trait_generics.insert(new_generic_ident.clone());
+                impl_trait_generics.insert(UnresolvedGeneric::from(new_generic_ident.clone()));
 
                 let is_synthesized = true;
                 let new_generic_type_data =
@@ -249,7 +254,7 @@ impl<'a> Resolver<'a> {
                 };
 
                 parameter.typ.typ = new_generic_type_data;
-                func.def.generics.push(new_generic_ident);
+                func.def.generics.push(new_generic_ident.into());
                 func.def.where_clause.push(new_trait_constraint);
             }
         }
@@ -591,7 +596,7 @@ impl<'a> Resolver<'a> {
                 let env = Box::new(self.resolve_type_inner(*env));
 
                 match *env {
-                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _) => {
+                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _, _) => {
                         Type::Function(args, ret, env)
                     }
                     _ => {
@@ -621,8 +626,8 @@ impl<'a> Resolver<'a> {
         resolved_type
     }
 
-    fn find_generic(&self, target_name: &str) -> Option<&(Rc<String>, TypeVariable, Span)> {
-        self.generics.iter().find(|(name, _, _)| name.as_ref() == target_name)
+    fn find_generic(&self, target_name: &str) -> Option<&ResolvedGeneric> {
+        self.generics.iter().find(|generic| generic.name.as_ref() == target_name)
     }
 
     fn resolve_named_type(&mut self, path: Path, args: Vec<UnresolvedType>) -> Type {
@@ -747,9 +752,15 @@ impl<'a> Resolver<'a> {
     fn lookup_generic_or_global_type(&mut self, path: &Path) -> Option<Type> {
         if path.segments.len() == 1 {
             let name = &path.last_segment().0.contents;
-            if let Some((name, var, _)) = self.find_generic(name) {
-                return Some(Type::NamedGeneric(var.clone(), name.clone()));
-            }
+            if let Some(generic) = self.find_generic(name) {
+                // We always insert a `TypeKind::Normal` as we do not support explicit numeric generics
+                // in the resolver
+                return Some(Type::NamedGeneric(
+                    generic.type_var.clone(),
+                    generic.name.clone(),
+                    Kind::Normal,
+                ));
+            };
         }
 
         // If we cannot find a local generic of the same name, try to look up a global
@@ -848,14 +859,14 @@ impl<'a> Resolver<'a> {
     /// Return the current generics.
     /// Needed to keep referring to the same type variables across many
     /// methods in a single impl.
-    pub fn get_generics(&self) -> &[(Rc<String>, TypeVariable, Span)] {
+    pub fn get_generics(&self) -> &[ResolvedGeneric] {
         &self.generics
     }
 
     /// Set the current generics that are in scope.
     /// Unlike add_generics, this function will not create any new type variables,
     /// opting to reuse the existing ones it is directly given.
-    pub fn set_generics(&mut self, generics: Vec<(Rc<String>, TypeVariable, Span)>) {
+    pub fn set_generics(&mut self, generics: Vec<ResolvedGeneric>) {
         self.generics = generics;
     }
 
@@ -875,48 +886,79 @@ impl<'a> Resolver<'a> {
             // Map the generic to a fresh type variable
             let id = self.interner.next_type_variable_id();
             let typevar = TypeVariable::unbound(id);
-            let span = generic.0.span();
+            let ident = generic.ident();
+            let span = ident.0.span();
 
             // Check for name collisions of this generic
-            let name = Rc::new(generic.0.contents.clone());
+            let name = Rc::new(ident.0.contents.clone());
 
-            if let Some((_, _, first_span)) = self.find_generic(&name) {
+            let resolved_generic = ResolvedGeneric {
+                name: name.clone(),
+                type_var: typevar,
+                // We only support numeric generics in the elaborator
+                kind: Kind::Normal,
+                span,
+            };
+            if let Some(generic) = self.find_generic(&name) {
                 self.errors.push(ResolverError::DuplicateDefinition {
-                    name: generic.0.contents.clone(),
-                    first_span: *first_span,
+                    name: ident.0.contents.clone(),
+                    first_span: generic.span,
                     second_span: span,
                 });
             } else {
-                self.generics.push((name, typevar.clone(), span));
+                self.generics.push(resolved_generic.clone());
             }
 
-            typevar
+            resolved_generic
         })
     }
 
     /// Add the given existing generics to scope.
     /// This is useful for adding the same generics to many items. E.g. apply impl generics
     /// to each function in the impl or trait generics to each item in the trait.
-    pub fn add_existing_generics(&mut self, names: &UnresolvedGenerics, generics: &Generics) {
-        assert_eq!(names.len(), generics.len());
+    pub fn add_existing_generics(
+        &mut self,
+        unresolved_generics: &UnresolvedGenerics,
+        generics: &GenericTypeVars,
+    ) {
+        assert_eq!(unresolved_generics.len(), generics.len());
 
-        for (name, typevar) in names.iter().zip(generics) {
-            self.add_existing_generic(&name.0.contents, name.0.span(), typevar.clone());
+        for (unresolved_generic, typevar) in unresolved_generics.iter().zip(generics) {
+            self.add_existing_generic(
+                unresolved_generic,
+                unresolved_generic.span(),
+                typevar.clone(),
+            );
         }
     }
 
-    pub fn add_existing_generic(&mut self, name: &str, span: Span, typevar: TypeVariable) {
+    pub fn add_existing_generic(
+        &mut self,
+        unresolved_generic: &UnresolvedGeneric,
+        span: Span,
+        typevar: TypeVariable,
+    ) {
+        let name = &unresolved_generic.ident().0.contents;
+
         // Check for name collisions of this generic
-        let rc_name = Rc::new(name.to_owned());
+        let rc_name = Rc::new(name.clone());
 
-        if let Some((_, _, first_span)) = self.find_generic(&rc_name) {
+        if let Some(generic) = self.find_generic(&rc_name) {
             self.errors.push(ResolverError::DuplicateDefinition {
-                name: name.to_owned(),
-                first_span: *first_span,
+                name: name.clone(),
+                first_span: generic.span,
                 second_span: span,
             });
         } else {
-            self.generics.push((rc_name, typevar, span));
+            let resolved_generic = ResolvedGeneric {
+                name: rc_name,
+                type_var: typevar.clone(),
+                kind: unresolved_generic
+                    .kind()
+                    .expect("ICE: Deprecated code should only support normal kinds"),
+                span,
+            };
+            self.generics.push(resolved_generic);
         }
     }
 
@@ -992,7 +1034,7 @@ impl<'a> Resolver<'a> {
         // indicate we should code generate in the same way. Thus, we unify the attributes into one flag here.
         let has_inline_attribute = has_no_predicates_attribute || should_fold;
 
-        let generics = vecmap(&self.generics, |(_, typevar, _)| typevar.clone());
+        let generics = vecmap(&self.generics, |generic| generic.type_var.clone());
         let mut parameters = vec![];
         let mut parameter_types = vec![];
 
@@ -1053,8 +1095,8 @@ impl<'a> Resolver<'a> {
 
         let direct_generics = func.def.generics.iter();
         let direct_generics = direct_generics
-            .filter_map(|generic| self.find_generic(&generic.0.contents))
-            .map(|(name, typevar, _span)| (name.clone(), typevar.clone()))
+            .filter_map(|generic| self.find_generic(&generic.ident().0.contents))
+            .map(|ResolvedGeneric { name, type_var, .. }| (name.clone(), type_var.clone()))
             .collect();
 
         FuncMeta {
@@ -1107,6 +1149,7 @@ impl<'a> Resolver<'a> {
         !func.def.is_unconstrained
     }
 
+    // TODO(https://github.com/noir-lang/noir/issues/5156): Remove this method in favor of explicit numeric generics
     fn declare_numeric_generics(&mut self, params: &[Type], return_type: &Type) {
         if self.generics.is_empty() {
             return;
@@ -1119,12 +1162,12 @@ impl<'a> Resolver<'a> {
             // We can fail to find the generic in self.generics if it is an implicit one created
             // by the compiler. This can happen when, e.g. eliding array lengths using the slice
             // syntax [T].
-            if let Some((name, _, span)) =
-                self.generics.iter().find(|(name, _, _)| name.as_ref() == &name_to_find)
+            if let Some(ResolvedGeneric { name, span, .. }) =
+                self.generics.iter().find(|generic| generic.name.as_ref() == &name_to_find)
             {
                 let ident = Ident::new(name.to_string(), *span);
                 let definition = DefinitionKind::GenericType(type_variable);
-                self.add_variable_decl_inner(ident, false, false, false, definition);
+                self.add_variable_decl_inner(ident.clone(), false, false, false, definition);
             }
         }
     }
@@ -1150,7 +1193,7 @@ impl<'a> Resolver<'a> {
             | Type::Error
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Quoted(_)
             | Type::Forall(_, _) => (),
 
@@ -1161,7 +1204,7 @@ impl<'a> Resolver<'a> {
             }
 
             Type::Array(length, element_type) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
                 }
                 Self::find_numeric_generics_in_type(element_type, found);
@@ -1186,7 +1229,7 @@ impl<'a> Resolver<'a> {
 
             Type::Struct(struct_type, generics) => {
                 for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name) = generic {
+                    if let Type::NamedGeneric(type_variable, name, _) = generic {
                         if struct_type.borrow().generic_is_numeric(i) {
                             found.insert(name.to_string(), type_variable.clone());
                         }
@@ -1197,7 +1240,7 @@ impl<'a> Resolver<'a> {
             }
             Type::Alias(alias, generics) => {
                 for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name) = generic {
+                    if let Type::NamedGeneric(type_variable, name, _) = generic {
                         if alias.borrow().generic_is_numeric(i) {
                             found.insert(name.to_string(), type_variable.clone());
                         }
@@ -1208,12 +1251,12 @@ impl<'a> Resolver<'a> {
             }
             Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found),
             Type::String(length) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
                 }
             }
             Type::FmtString(length, fields) => {
-                if let Type::NamedGeneric(type_variable, name) = length.as_ref() {
+                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
                     found.insert(name.to_string(), type_variable.clone());
                 }
                 Self::find_numeric_generics_in_type(fields, found);
@@ -1874,7 +1917,9 @@ impl<'a> Resolver<'a> {
 
                 let constraint = TraitConstraint {
                     typ: self.self_type.clone()?,
-                    trait_generics: Type::from_generics(&the_trait.generics),
+                    trait_generics: Type::from_generics(&vecmap(&the_trait.generics, |generic| {
+                        generic.type_var.clone()
+                    })),
                     trait_id,
                 };
                 return Some((method, constraint, false));
@@ -1902,7 +1947,9 @@ impl<'a> Resolver<'a> {
                     the_trait.self_type_typevar.clone(),
                     TypeVariableKind::Normal,
                 ),
-                trait_generics: Type::from_generics(&the_trait.generics),
+                trait_generics: Type::from_generics(&vecmap(&the_trait.generics, |generic| {
+                    generic.type_var.clone()
+                })),
                 trait_id,
             };
             return Some((method, constraint, false));
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index 4c360731711..a6b732439b0 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -4,7 +4,7 @@ use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::Location;
 
-use crate::ast::{ItemVisibility, Path, TraitItem};
+use crate::ast::{Ident, ItemVisibility, Path, TraitItem, UnresolvedGeneric};
 use crate::{
     graph::CrateId,
     hir::{
@@ -17,7 +17,7 @@ use crate::{
     },
     hir_def::traits::{TraitConstant, TraitFunction, TraitImpl, TraitType},
     node_interner::{FuncId, NodeInterner, TraitId},
-    Generics, Shared, Type, TypeVariable, TypeVariableKind,
+    GenericTypeVars, Shared, Type, TypeVariableKind,
 };
 
 use super::{
@@ -36,14 +36,18 @@ pub(crate) fn resolve_traits(
     crate_id: CrateId,
 ) -> Vec<(CompilationError, FileId)> {
     for (trait_id, unresolved_trait) in &traits {
-        context.def_interner.push_empty_trait(*trait_id, unresolved_trait);
+        context.def_interner.push_empty_trait(*trait_id, unresolved_trait, vec![]);
     }
     let mut all_errors = Vec::new();
 
     for (trait_id, unresolved_trait) in traits {
-        let generics = vecmap(&unresolved_trait.trait_def.generics, |_| {
-            TypeVariable::unbound(context.def_interner.next_type_variable_id())
-        });
+        let file_id = context.def_maps[&crate_id].file_id(unresolved_trait.module_id);
+        let generics = context.resolve_generics(
+            &unresolved_trait.trait_def.generics,
+            &mut all_errors,
+            file_id,
+        );
+        let generic_type_vars = generics.iter().map(|generic| generic.type_var.clone()).collect();
 
         // Resolve order
         // 1. Trait Types ( Trait constants can have a trait type, therefore types before constants)
@@ -51,8 +55,13 @@ pub(crate) fn resolve_traits(
         // 2. Trait Constants ( Trait's methods can use trait types & constants, therefore they should be after)
         let _ = resolve_trait_constants(context, crate_id, &unresolved_trait);
         // 3. Trait Methods
-        let (methods, errors) =
-            resolve_trait_methods(context, trait_id, crate_id, &unresolved_trait, &generics);
+        let (methods, errors) = resolve_trait_methods(
+            context,
+            trait_id,
+            crate_id,
+            &unresolved_trait,
+            &generic_type_vars,
+        );
 
         all_errors.extend(errors);
 
@@ -93,7 +102,7 @@ fn resolve_trait_methods(
     trait_id: TraitId,
     crate_id: CrateId,
     unresolved_trait: &UnresolvedTrait,
-    trait_generics: &Generics,
+    trait_generics: &GenericTypeVars,
 ) -> (Vec<TraitFunction>, Vec<(CompilationError, FileId)>) {
     let interner = &mut context.def_interner;
     let def_maps = &mut context.def_maps;
@@ -126,7 +135,11 @@ fn resolve_trait_methods(
             resolver.add_generics(generics);
 
             resolver.add_existing_generics(&unresolved_trait.trait_def.generics, trait_generics);
-            resolver.add_existing_generic("Self", name_span, self_typevar);
+            resolver.add_existing_generic(
+                &UnresolvedGeneric::Variable(Ident::from("Self")),
+                name_span,
+                self_typevar,
+            );
             resolver.set_self_type(Some(self_type.clone()));
 
             let func_id = unresolved_trait.method_ids[&name.0.contents];
@@ -143,7 +156,7 @@ fn resolve_trait_methods(
             let arguments = vecmap(parameters, |param| resolver.resolve_type(param.1.clone()));
             let return_type = resolver.resolve_type(return_type.get_type().into_owned());
 
-            let generics = vecmap(resolver.get_generics(), |(_, type_var, _)| type_var.clone());
+            let generics = vecmap(resolver.get_generics(), |generic| generic.type_var.clone());
 
             let default_impl_list: Vec<_> = unresolved_trait
                 .fns_with_default_impl
@@ -464,7 +477,7 @@ pub(crate) fn resolve_trait_impls(
                 methods: vecmap(&impl_methods, |(_, func_id)| *func_id),
             });
 
-            let impl_generics = vecmap(impl_generics, |(_, type_variable, _)| type_variable);
+            let impl_generics = vecmap(impl_generics, |generic| generic.type_var);
 
             if let Err((prev_span, prev_file)) = interner.add_trait_implementation(
                 self_type.clone(),
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index d9d021aee3f..f18e8a9e843 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -40,6 +40,8 @@ pub enum TypeCheckError {
     TypeMismatch { expected_typ: String, expr_typ: String, expr_span: Span },
     #[error("Expected type {expected} is not the same as {actual}")]
     TypeMismatchWithSource { expected: Type, actual: Type, span: Span, source: Source },
+    #[error("Expected type {expected_kind:?} is not the same as {expr_kind:?}")]
+    TypeKindMismatch { expected_kind: String, expr_kind: String, expr_span: Span },
     #[error("Expected {expected:?} found {found:?}")]
     ArityMisMatch { expected: usize, found: usize, span: Span },
     #[error("Return type in a function cannot be public")]
@@ -178,6 +180,13 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                     *expr_span,
                 )
             }
+            TypeCheckError::TypeKindMismatch { expected_kind, expr_kind, expr_span } => {
+                Diagnostic::simple_error(
+                    format!("Expected kind {expected_kind}, found kind {expr_kind}"),
+                    String::new(),
+                    *expr_span,
+                )
+            }
             TypeCheckError::TraitMethodParameterTypeMismatch { method_name, expected_typ, actual_typ, parameter_index, parameter_span } => {
                 Diagnostic::simple_error(
                     format!("Parameter #{parameter_index} of method `{method_name}` must be of type {expected_typ}, not {actual_typ}"),
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 4ded04ec2a4..77861a6d8f8 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -404,8 +404,8 @@ impl<'interner> TypeChecker<'interner> {
 
             for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics) {
                 // Avoid binding t = t
-                if !arg.occurs(param.id()) {
-                    bindings.insert(param.id(), (param.clone(), arg.clone()));
+                if !arg.occurs(param.type_var.id()) {
+                    bindings.insert(param.type_var.id(), (param.type_var.clone(), arg.clone()));
                 }
             }
 
@@ -1025,7 +1025,7 @@ impl<'interner> TypeChecker<'interner> {
                 });
                 None
             }
-            Type::NamedGeneric(_, _) => {
+            Type::NamedGeneric(_, _, _) => {
                 let func_meta = self.interner.function_meta(
                     &self.current_function.expect("unexpected method outside a function"),
                 );
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 98e1cd9c72a..b2d15911147 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -22,7 +22,7 @@ use crate::{
         traits::TraitConstraint,
     },
     node_interner::{ExprId, FuncId, GlobalId, NodeInterner},
-    Type, TypeBindings,
+    Kind, Type, TypeBindings,
 };
 
 pub use self::errors::Source;
@@ -263,7 +263,7 @@ pub(crate) fn check_trait_impl_method_matches_declaration(
 
     // Substitute each generic on the trait with the corresponding generic on the impl
     for (generic, arg) in trait_info.generics.iter().zip(&impl_.trait_generics) {
-        bindings.insert(generic.id(), (generic.clone(), arg.clone()));
+        bindings.insert(generic.type_var.id(), (generic.type_var.clone(), arg.clone()));
     }
 
     // If this is None, the trait does not have the corresponding function.
@@ -284,7 +284,7 @@ pub(crate) fn check_trait_impl_method_matches_declaration(
         for ((_, trait_fn_generic), (name, impl_fn_generic)) in
             trait_fn_meta.direct_generics.iter().zip(&meta.direct_generics)
         {
-            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone());
+            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone(), Kind::Normal);
             bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), arg));
         }
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 53eabe21081..d11d3132212 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -9,7 +9,7 @@ use super::traits::TraitConstraint;
 use crate::ast::{FunctionKind, FunctionReturnType, Visibility};
 use crate::macros_api::BlockExpression;
 use crate::node_interner::{ExprId, NodeInterner, TraitImplId};
-use crate::{Type, TypeVariable};
+use crate::{ResolvedGeneric, Type, TypeVariable};
 
 /// A Hir function is a block expression
 /// with a list of statements
@@ -118,7 +118,7 @@ pub struct FuncMeta {
     /// from outer scopes, such as those introduced by an impl.
     /// This is stored when the FuncMeta is first created to later be used to set the current
     /// generics when the function's body is later resolved.
-    pub all_generics: Vec<(Rc<String>, TypeVariable, Span)>,
+    pub all_generics: Vec<ResolvedGeneric>,
 
     pub location: Location,
 
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index 86d1fafd502..8733f4b2de1 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -82,7 +82,7 @@ pub enum Type {
 
     /// NamedGenerics are the 'T' or 'U' in a user-defined generic function
     /// like `fn foo<T, U>(...) {}`. Unlike TypeVariables, they cannot be bound over.
-    NamedGeneric(TypeVariable, Rc<String>),
+    NamedGeneric(TypeVariable, Rc<String>, Kind),
 
     /// A functions with arguments, a return type and environment.
     /// the environment should be `Unit` by default,
@@ -98,7 +98,7 @@ pub enum Type {
     /// but it makes handling them both easier. The TypeVariableId should
     /// never be bound over during type checking, but during monomorphization it
     /// will be and thus needs the full TypeVariable link.
-    Forall(Generics, Box<Type>),
+    Forall(GenericTypeVars, Box<Type>),
 
     /// A type-level integer. Included to let an Array's size type variable
     /// bind to an integer without special checks to bind it to a non-type.
@@ -142,7 +142,7 @@ impl Type {
             | Type::Unit
             | Type::TypeVariable(_, _)
             | Type::TraitAsType(..)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
@@ -187,6 +187,27 @@ impl Type {
     }
 }
 
+/// A Kind is the type of a Type. These are used since only certain kinds of types are allowed in
+/// certain positions.
+///
+/// For example, the type of a struct field or a function parameter is expected to be
+/// a type of kind * (represented here as `Normal`). Types used in positions where a number
+/// is expected (such as in an array length position) are expected to be of kind `Kind::Numeric`.
+#[derive(PartialEq, Eq, Clone, Hash, Debug)]
+pub enum Kind {
+    Normal,
+    Numeric(Box<Type>),
+}
+
+impl std::fmt::Display for Kind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Kind::Normal => write!(f, "normal"),
+            Kind::Numeric(typ) => write!(f, "numeric {}", typ),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub enum QuotedType {
     Expr,
@@ -222,7 +243,22 @@ pub struct StructType {
 }
 
 /// Corresponds to generic lists such as `<T, U>` in the source program.
-pub type Generics = Vec<TypeVariable>;
+/// Used mainly for resolved types which no longer need information such
+/// as names or kinds.
+pub type GenericTypeVars = Vec<TypeVariable>;
+
+/// Corresponds to generic lists such as `<T, U>` with additional
+/// information gathered during name resolution that is necessary
+/// correctly resolving types.
+pub type Generics = Vec<ResolvedGeneric>;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedGeneric {
+    pub name: Rc<String>,
+    pub type_var: TypeVariable,
+    pub kind: Kind,
+    pub span: Span,
+}
 
 impl std::hash::Hash for StructType {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
@@ -271,7 +307,7 @@ impl StructType {
                     .generics
                     .iter()
                     .zip(generic_args)
-                    .map(|(old, new)| (old.id(), (old.clone(), new.clone())))
+                    .map(|(old, new)| (old.type_var.id(), (old.type_var.clone(), new.clone())))
                     .collect();
 
                 (typ.substitute(&substitutions), i)
@@ -287,7 +323,7 @@ impl StructType {
             .generics
             .iter()
             .zip(generic_args)
-            .map(|(old, new)| (old.id(), (old.clone(), new.clone())))
+            .map(|(old, new)| (old.type_var.id(), (old.type_var.clone(), new.clone())))
             .collect();
 
         vecmap(&self.fields, |(name, typ)| {
@@ -310,11 +346,19 @@ impl StructType {
         self.fields.iter().map(|(name, _)| name.clone()).collect()
     }
 
+    /// Search the fields of a struct for any types with a `TypeKind::Numeric`
+    pub fn find_numeric_generics_in_fields(&self, found_names: &mut Vec<String>) {
+        for (_, field) in self.fields.iter() {
+            field.find_numeric_type_vars(found_names);
+        }
+    }
+
     /// True if the given index is the same index as a generic type of this struct
     /// which is expected to be a numeric generic.
     /// This is needed because we infer type kinds in Noir and don't have extensive kind checking.
+    /// TODO(https://github.com/noir-lang/noir/issues/5156): This is outdated and we should remove this implicit searching for numeric generics
     pub fn generic_is_numeric(&self, index_of_generic: usize) -> bool {
-        let target_id = self.generics[index_of_generic].0;
+        let target_id = self.generics[index_of_generic].type_var.id();
         self.fields.iter().any(|(_, field)| field.contains_numeric_typevar(target_id))
     }
 
@@ -383,7 +427,7 @@ impl TypeAlias {
             .generics
             .iter()
             .zip(generic_args)
-            .map(|(old, new)| (old.id(), (old.clone(), new.clone())))
+            .map(|(old, new)| (old.type_var.id(), (old.type_var.clone(), new.clone())))
             .collect();
 
         self.typ.substitute(&substitutions)
@@ -393,7 +437,7 @@ impl TypeAlias {
     /// which is expected to be a numeric generic.
     /// This is needed because we infer type kinds in Noir and don't have extensive kind checking.
     pub fn generic_is_numeric(&self, index_of_generic: usize) -> bool {
-        let target_id = self.generics[index_of_generic].0;
+        let target_id = self.generics[index_of_generic].type_var.id();
         self.typ.contains_numeric_typevar(target_id)
     }
 }
@@ -641,7 +685,7 @@ impl Type {
     fn contains_numeric_typevar(&self, target_id: TypeVariableId) -> bool {
         // True if the given type is a NamedGeneric with the target_id
         let named_generic_id_matches_target = |typ: &Type| {
-            if let Type::NamedGeneric(type_variable, _) = typ {
+            if let Type::NamedGeneric(type_variable, _, _) = typ {
                 match &*type_variable.borrow() {
                     TypeBinding::Bound(_) => {
                         unreachable!("Named generics should not be bound until monomorphization")
@@ -661,7 +705,7 @@ impl Type {
             | Type::Error
             | Type::TypeVariable(_, _)
             | Type::Constant(_)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Forall(_, _)
             | Type::Quoted(_) => false,
 
@@ -705,6 +749,85 @@ impl Type {
         }
     }
 
+    /// TODO(https://github.com/noir-lang/noir/issues/5156): Remove with explicit numeric generics
+    pub fn find_numeric_type_vars(&self, found_names: &mut Vec<String>) {
+        // Return whether the named generic has a TypeKind::Numeric and save its name
+        let named_generic_is_numeric = |typ: &Type, found_names: &mut Vec<String>| {
+            if let Type::NamedGeneric(_, name, Kind::Numeric { .. }) = typ {
+                found_names.push(name.to_string());
+                true
+            } else {
+                false
+            }
+        };
+
+        match self {
+            Type::FieldElement
+            | Type::Integer(_, _)
+            | Type::Bool
+            | Type::Unit
+            | Type::Error
+            | Type::Constant(_)
+            | Type::Forall(_, _)
+            | Type::Quoted(_) => {}
+
+            Type::TypeVariable(type_var, _) => {
+                if let TypeBinding::Bound(typ) = &*type_var.borrow() {
+                    named_generic_is_numeric(typ, found_names);
+                }
+            }
+
+            Type::NamedGeneric(_, _, _) => {
+                named_generic_is_numeric(self, found_names);
+            }
+
+            Type::TraitAsType(_, _, args) => {
+                for arg in args.iter() {
+                    arg.find_numeric_type_vars(found_names);
+                }
+            }
+            Type::Array(length, elem) => {
+                elem.find_numeric_type_vars(found_names);
+                named_generic_is_numeric(length, found_names);
+            }
+            Type::Slice(elem) => elem.find_numeric_type_vars(found_names),
+            Type::Tuple(fields) => {
+                for field in fields.iter() {
+                    field.find_numeric_type_vars(found_names);
+                }
+            }
+            Type::Function(parameters, return_type, env) => {
+                for parameter in parameters.iter() {
+                    parameter.find_numeric_type_vars(found_names);
+                }
+                return_type.find_numeric_type_vars(found_names);
+                env.find_numeric_type_vars(found_names);
+            }
+            Type::Struct(_, generics) => {
+                for generic in generics.iter() {
+                    if !named_generic_is_numeric(generic, found_names) {
+                        generic.find_numeric_type_vars(found_names);
+                    }
+                }
+            }
+            Type::Alias(_, generics) => {
+                for generic in generics.iter() {
+                    if !named_generic_is_numeric(generic, found_names) {
+                        generic.find_numeric_type_vars(found_names);
+                    }
+                }
+            }
+            Type::MutableReference(element) => element.find_numeric_type_vars(found_names),
+            Type::String(length) => {
+                named_generic_is_numeric(length, found_names);
+            }
+            Type::FmtString(length, elements) => {
+                elements.find_numeric_type_vars(found_names);
+                named_generic_is_numeric(length, found_names);
+            }
+        }
+    }
+
     /// True if this type can be used as a parameter to `main` or a contract function.
     /// This is only false for unsized types like slices or slices that do not make sense
     /// as a program input such as named generics or mutable references.
@@ -725,7 +848,7 @@ impl Type {
 
             Type::FmtString(_, _)
             | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
@@ -767,7 +890,7 @@ impl Type {
             | Type::Unit
             | Type::Constant(_)
             | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Error => true,
 
             Type::FmtString(_, _)
@@ -810,7 +933,7 @@ impl Type {
             | Type::Constant(_)
             | Type::Slice(_)
             | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(_, _)
+            | Type::NamedGeneric(_, _, _)
             | Type::Function(_, _, _)
             | Type::FmtString(_, _)
             | Type::Error => true,
@@ -847,7 +970,7 @@ impl Type {
     pub fn generic_count(&self) -> usize {
         match self {
             Type::Forall(generics, _) => generics.len(),
-            Type::TypeVariable(type_variable, _) | Type::NamedGeneric(type_variable, _) => {
+            Type::TypeVariable(type_variable, _) | Type::NamedGeneric(type_variable, _, _) => {
                 match &*type_variable.borrow() {
                     TypeBinding::Bound(binding) => binding.generic_count(),
                     TypeBinding::Unbound(_) => 0,
@@ -876,12 +999,42 @@ impl Type {
 
     /// Return the generics and type within this `Type::Forall`.
     /// Panics if `self` is not `Type::Forall`
-    pub fn unwrap_forall(&self) -> (Cow<Generics>, &Type) {
+    pub fn unwrap_forall(&self) -> (Cow<GenericTypeVars>, &Type) {
         match self {
             Type::Forall(generics, typ) => (Cow::Borrowed(generics), typ.as_ref()),
-            other => (Cow::Owned(Generics::new()), other),
+            other => (Cow::Owned(GenericTypeVars::new()), other),
         }
     }
+
+    // TODO(https://github.com/noir-lang/noir/issues/5156): Bring back this method when we remove implicit numeric generics
+    // It has been commented out as to not trigger clippy for an unused method
+    // pub(crate) fn kind(&self) -> Kind {
+    //     match self {
+    //         Type::NamedGeneric(_, _, kind) => kind.clone(),
+    //         Type::Constant(_) => Kind::Numeric(Box::new(Type::Integer(
+    //             Signedness::Unsigned,
+    //             IntegerBitSize::ThirtyTwo,
+    //         ))),
+    //         Type::FieldElement
+    //         | Type::Array(_, _)
+    //         | Type::Slice(_)
+    //         | Type::Integer(_, _)
+    //         | Type::Bool
+    //         | Type::String(_)
+    //         | Type::FmtString(_, _)
+    //         | Type::Unit
+    //         | Type::Tuple(_)
+    //         | Type::Struct(_, _)
+    //         | Type::Alias(_, _)
+    //         | Type::TypeVariable(_, _)
+    //         | Type::TraitAsType(_, _, _)
+    //         | Type::Function(_, _, _)
+    //         | Type::MutableReference(_)
+    //         | Type::Forall(_, _)
+    //         | Type::Quoted(_)
+    //         | Type::Error => Kind::Normal,
+    //     }
+    // }
 }
 
 impl std::fmt::Display for Type {
@@ -961,7 +1114,7 @@ impl std::fmt::Display for Type {
             }
             Type::Unit => write!(f, "()"),
             Type::Error => write!(f, "error"),
-            Type::NamedGeneric(binding, name) => match &*binding.borrow() {
+            Type::NamedGeneric(binding, name, _) => match &*binding.borrow() {
                 TypeBinding::Bound(binding) => binding.fmt(f),
                 TypeBinding::Unbound(_) if name.is_empty() => write!(f, "_"),
                 TypeBinding::Unbound(_) => write!(f, "{name}"),
@@ -1213,7 +1366,7 @@ impl Type {
 
     fn get_inner_type_variable(&self) -> Option<Shared<TypeBinding>> {
         match self {
-            Type::TypeVariable(var, _) | Type::NamedGeneric(var, _) => Some(var.1.clone()),
+            Type::TypeVariable(var, _) | Type::NamedGeneric(var, _, _) => Some(var.1.clone()),
             _ => None,
         }
     }
@@ -1324,7 +1477,7 @@ impl Type {
                 }
             }
 
-            (NamedGeneric(binding, _), other) | (other, NamedGeneric(binding, _))
+            (NamedGeneric(binding, _, _), other) | (other, NamedGeneric(binding, _, _))
                 if !binding.borrow().is_unbound() =>
             {
                 if let TypeBinding::Bound(link) = &*binding.borrow() {
@@ -1334,7 +1487,7 @@ impl Type {
                 }
             }
 
-            (NamedGeneric(binding_a, name_a), NamedGeneric(binding_b, name_b)) => {
+            (NamedGeneric(binding_a, name_a, _), NamedGeneric(binding_b, name_b, _)) => {
                 // Bound NamedGenerics are caught by the check above
                 assert!(binding_a.borrow().is_unbound());
                 assert!(binding_b.borrow().is_unbound());
@@ -1661,7 +1814,7 @@ impl Type {
                 let fields = fields.substitute_helper(type_bindings, substitute_bound_typevars);
                 Type::FmtString(Box::new(size), Box::new(fields))
             }
-            Type::NamedGeneric(binding, _) | Type::TypeVariable(binding, _) => {
+            Type::NamedGeneric(binding, _, _) | Type::TypeVariable(binding, _) => {
                 substitute_binding(binding)
             }
             // Do not substitute_helper fields, it can lead to infinite recursion
@@ -1739,7 +1892,7 @@ impl Type {
                 generic_args.iter().any(|arg| arg.occurs(target_id))
             }
             Type::Tuple(fields) => fields.iter().any(|field| field.occurs(target_id)),
-            Type::NamedGeneric(binding, _) | Type::TypeVariable(binding, _) => {
+            Type::NamedGeneric(binding, _, _) | Type::TypeVariable(binding, _) => {
                 match &*binding.borrow() {
                     TypeBinding::Bound(binding) => binding.occurs(target_id),
                     TypeBinding::Unbound(id) => *id == target_id,
@@ -1794,7 +1947,7 @@ impl Type {
                 def.borrow().get_type(args).follow_bindings()
             }
             Tuple(args) => Tuple(vecmap(args, |arg| arg.follow_bindings())),
-            TypeVariable(var, _) | NamedGeneric(var, _) => {
+            TypeVariable(var, _) | NamedGeneric(var, _, _) => {
                 if let TypeBinding::Bound(typ) = &*var.borrow() {
                     return typ.follow_bindings();
                 }
@@ -1823,7 +1976,7 @@ impl Type {
         }
     }
 
-    pub fn from_generics(generics: &Generics) -> Vec<Type> {
+    pub fn from_generics(generics: &GenericTypeVars) -> Vec<Type> {
         vecmap(generics, |var| Type::TypeVariable(var.clone(), TypeVariableKind::Normal))
     }
 }
@@ -2020,7 +2173,14 @@ impl std::fmt::Debug for Type {
             }
             Type::Unit => write!(f, "()"),
             Type::Error => write!(f, "error"),
-            Type::NamedGeneric(binding, name) => write!(f, "{}{:?}", name, binding),
+            Type::NamedGeneric(binding, name, kind) => match kind {
+                Kind::Normal => {
+                    write!(f, "{} -> {:?}", name, binding)
+                }
+                Kind::Numeric(typ) => {
+                    write!(f, "({} : {}) -> {:?}", name, typ, binding)
+                }
+            },
             Type::Constant(x) => x.fmt(f),
             Type::Forall(typevars, typ) => {
                 let typevars = vecmap(typevars, |var| format!("{:?}", var));
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index a95fc0e7ace..7eb2afe804a 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -945,7 +945,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::TraitAsType(..) => {
                 unreachable!("All TraitAsType should be replaced before calling convert_type");
             }
-            HirType::NamedGeneric(binding, _) => {
+            HirType::NamedGeneric(binding, _, _) => {
                 if let TypeBinding::Bound(binding) = &*binding.borrow() {
                     return Self::convert_type(binding, location);
                 }
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 78b2c056dfd..c7bbd6ad044 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -32,9 +32,9 @@ use crate::hir_def::{
     stmt::HirStatement,
 };
 use crate::token::{Attributes, SecondaryAttribute};
-use crate::{
-    Generics, Shared, TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind,
-};
+use crate::GenericTypeVars;
+use crate::Generics;
+use crate::{Shared, TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind};
 
 /// An arbitrary number to limit the recursion depth when searching for trait impls.
 /// This is needed to stop recursing for cases such as `impl<T> Foo for T where T: Eq`
@@ -547,7 +547,12 @@ impl NodeInterner {
         self.definition_to_type.insert(definition_id, typ);
     }
 
-    pub fn push_empty_trait(&mut self, type_id: TraitId, unresolved_trait: &UnresolvedTrait) {
+    pub fn push_empty_trait(
+        &mut self,
+        type_id: TraitId,
+        unresolved_trait: &UnresolvedTrait,
+        generics: Generics,
+    ) {
         let self_type_typevar_id = self.next_type_variable_id();
 
         let new_trait = Trait {
@@ -555,13 +560,7 @@ impl NodeInterner {
             name: unresolved_trait.trait_def.name.clone(),
             crate_id: unresolved_trait.crate_id,
             location: Location::new(unresolved_trait.trait_def.span, unresolved_trait.file_id),
-            generics: vecmap(&unresolved_trait.trait_def.generics, |_| {
-                // Temporary type variable ids before the trait is resolved to its actual ids.
-                // This lets us record how many arguments the type expects so that other types
-                // can refer to it with generic arguments before the generic parameters themselves
-                // are resolved.
-                TypeVariable::unbound(TypeVariableId(0))
-            }),
+            generics,
             self_type_typevar_id,
             self_type_typevar: TypeVariable::unbound(self_type_typevar_id),
             methods: Vec::new(),
@@ -576,6 +575,7 @@ impl NodeInterner {
     pub fn new_struct(
         &mut self,
         typ: &UnresolvedStruct,
+        generics: Generics,
         krate: CrateId,
         local_id: LocalModuleId,
         file_id: FileId,
@@ -585,13 +585,6 @@ impl NodeInterner {
 
         // Fields will be filled in later
         let no_fields = Vec::new();
-        let generics = vecmap(&typ.struct_def.generics, |_| {
-            // Temporary type variable ids before the struct is resolved to its actual ids.
-            // This lets us record how many arguments the type expects so that other types
-            // can refer to it with generic arguments before the generic parameters themselves
-            // are resolved.
-            TypeVariable::unbound(TypeVariableId(0))
-        });
 
         let location = Location::new(typ.struct_def.span, file_id);
         let new_struct = StructType::new(struct_id, name, location, no_fields, generics);
@@ -600,7 +593,11 @@ impl NodeInterner {
         struct_id
     }
 
-    pub fn push_type_alias(&mut self, typ: &UnresolvedTypeAlias) -> TypeAliasId {
+    pub fn push_type_alias(
+        &mut self,
+        typ: &UnresolvedTypeAlias,
+        generics: Generics,
+    ) -> TypeAliasId {
         let type_id = TypeAliasId(self.type_aliases.len());
 
         self.type_aliases.push(Shared::new(TypeAlias::new(
@@ -608,7 +605,7 @@ impl NodeInterner {
             typ.type_alias_def.name.clone(),
             Location::new(typ.type_alias_def.span, typ.file_id),
             Type::Error,
-            vecmap(&typ.type_alias_def.generics, |_| TypeVariable::unbound(TypeVariableId(0))),
+            generics,
         )));
 
         type_id
@@ -1407,7 +1404,7 @@ impl NodeInterner {
         trait_id: TraitId,
         trait_generics: Vec<Type>,
         impl_id: TraitImplId,
-        impl_generics: Generics,
+        impl_generics: GenericTypeVars,
         trait_impl: Shared<TraitImpl>,
     ) -> Result<(), (Span, FileId)> {
         self.trait_implementations.insert(impl_id, trait_impl.clone());
@@ -1825,7 +1822,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::Unit => Some(Unit),
         Type::Tuple(_) => Some(Tuple),
         Type::Function(_, _, _) => Some(Function),
-        Type::NamedGeneric(_, _) => Some(Generic),
+        Type::NamedGeneric(_, _, _) => Some(Generic),
         Type::Quoted(quoted) => Some(Quoted(*quoted)),
         Type::MutableReference(element) => get_type_method_key(element),
         Type::Alias(alias, _) => get_type_method_key(&alias.borrow().typ),
diff --git a/compiler/noirc_frontend/src/parser/mod.rs b/compiler/noirc_frontend/src/parser/mod.rs
index 72b1ea05ec2..315c8cf5d64 100644
--- a/compiler/noirc_frontend/src/parser/mod.rs
+++ b/compiler/noirc_frontend/src/parser/mod.rs
@@ -197,7 +197,7 @@ fn parameter_name_recovery<T: Recoverable + Clone>() -> impl NoirParser<T> {
 }
 
 fn top_level_statement_recovery() -> impl NoirParser<TopLevelStatement> {
-    none_of([Token::Semicolon, Token::RightBrace, Token::EOF])
+    none_of([Token::RightBrace, Token::EOF])
         .repeated()
         .ignore_then(one_of([Token::Semicolon]))
         .map(|_| TopLevelStatement::Error)
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index 4db5637f6a7..3e686ee4c85 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -5,11 +5,14 @@ use super::{
     self_parameter, where_clause, NoirParser,
 };
 use crate::ast::{
-    FunctionDefinition, FunctionReturnType, Ident, ItemVisibility, NoirFunction, Param, Visibility,
+    FunctionDefinition, FunctionReturnType, ItemVisibility, NoirFunction, Param, Visibility,
 };
-use crate::parser::labels::ParsingRuleLabel;
 use crate::parser::spanned;
 use crate::token::{Keyword, Token};
+use crate::{
+    ast::{UnresolvedGeneric, UnresolvedGenerics},
+    parser::labels::ParsingRuleLabel,
+};
 
 use chumsky::prelude::*;
 
@@ -76,16 +79,31 @@ fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility, bool)> {
         })
 }
 
+pub(super) fn numeric_generic() -> impl NoirParser<UnresolvedGeneric> {
+    keyword(Keyword::Let)
+        .ignore_then(ident())
+        .then_ignore(just(Token::Colon))
+        .then(parse_type())
+        .map(|(ident, typ)| UnresolvedGeneric::Numeric { ident, typ })
+}
+
+pub(super) fn generic_type() -> impl NoirParser<UnresolvedGeneric> {
+    ident().map(UnresolvedGeneric::Variable)
+}
+
+pub(super) fn generic() -> impl NoirParser<UnresolvedGeneric> {
+    generic_type().or(numeric_generic())
+}
+
 /// non_empty_ident_list: ident ',' non_empty_ident_list
 ///                     | ident
 ///
 /// generics: '<' non_empty_ident_list '>'
 ///         | %empty
-pub(super) fn generics() -> impl NoirParser<Vec<Ident>> {
-    ident()
+pub(super) fn generics() -> impl NoirParser<UnresolvedGenerics> {
+    generic()
         .separated_by(just(Token::Comma))
         .allow_trailing()
-        .at_least(1)
         .delimited_by(just(Token::Less), just(Token::Greater))
         .or_not()
         .map(|opt| opt.unwrap_or_default())
@@ -193,6 +211,7 @@ mod test {
                 // fn func_name(x: impl Eq) {} with error Expected an end of input but found end of input
                 // "fn func_name(x: impl Eq) {}",
                 "fn func_name<T>(x: impl Eq, y : T) where T: SomeTrait + Eq {}",
+                "fn func_name<let N: u64>(x: [Field; N]) {}",
             ],
         );
 
@@ -209,6 +228,11 @@ mod test {
                 // A leading plus is not allowed.
                 "fn func_name<T>(f: Field, y : T) where T: + SomeTrait {}",
                 "fn func_name<T>(f: Field, y : T) where T: TraitX + <Y> {}",
+                // Test ill-formed numeric generics
+                "fn func_name<let T>(y: T) {}",
+                "fn func_name<let T:>(y: T) {}",
+                "fn func_name<T:>(y: T) {}",
+                "fn func_name<T: u64>(y: T) {}",
             ],
         );
     }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index f4845625b87..9251eb3db6b 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -50,7 +50,10 @@ pub(crate) fn remove_experimental_warnings(errors: &mut Vec<(CompilationError, F
     });
 }
 
-pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
+pub(crate) fn get_program(
+    src: &str,
+    use_legacy: bool,
+) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
     let root = std::path::Path::new("/");
     let fm = FileManager::new(root);
 
@@ -82,7 +85,7 @@ pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(Compilation
             &mut context,
             program.clone().into_sorted(),
             root_file_id,
-            false,
+            use_legacy,
             &[], // No macro processors
         ));
     }
@@ -90,7 +93,7 @@ pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(Compilation
 }
 
 pub(crate) fn get_program_errors(src: &str) -> Vec<(CompilationError, FileId)> {
-    get_program(src).2
+    get_program(src, false).2
 }
 
 #[test]
@@ -833,7 +836,7 @@ fn check_trait_as_type_as_two_fn_parameters() {
 }
 
 fn get_program_captures(src: &str) -> Vec<Vec<String>> {
-    let (program, context, _errors) = get_program(src);
+    let (program, context, _errors) = get_program(src, false);
     let interner = context.def_interner;
     let mut all_captures: Vec<Vec<String>> = Vec::new();
     for func in program.into_sorted().functions {
@@ -1195,7 +1198,7 @@ fn resolve_fmt_strings() {
 }
 
 fn check_rewrite(src: &str, expected: &str) {
-    let (_program, mut context, _errors) = get_program(src);
+    let (_program, mut context, _errors) = get_program(src, false);
     let main_func_id = context.def_interner.find_function("main").unwrap();
     let program = monomorphize(main_func_id, &mut context.def_interner).unwrap();
     assert!(format!("{}", program) == expected);
@@ -1326,14 +1329,20 @@ fn for_loop_over_array() {
             hello(array);
         }
     "#;
-    assert_eq!(get_program_errors(src).len(), 0);
+    let errors = get_program_errors(src);
+    assert_eq!(get_program_errors(src).len(), 1);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UseExplicitNumericGeneric { .. })
+    ));
 }
 
 // Regression for #4545
 #[test]
 fn type_aliases_in_main() {
     let src = r#"
-        type Outer<N> = [u8; N];
+        type Outer<let N: u32> = [u8; N];
         fn main(_arg: Outer<1>) {}
     "#;
     assert_eq!(get_program_errors(src).len(), 0);
@@ -1446,6 +1455,425 @@ fn specify_method_types_with_turbofish() {
     assert_eq!(errors.len(), 0);
 }
 
+#[test]
+fn struct_numeric_generic_in_function() {
+    let src = r#"
+    struct Foo {
+        inner: u64
+    }
+
+    fn bar<let N: Foo>() { }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UnsupportedNumericGenericType { .. }),
+    ));
+}
+
+#[test]
+fn struct_numeric_generic_in_struct() {
+    let src = r#"
+    struct Foo {
+        inner: u64
+    }
+
+    struct Bar<let N: Foo> { }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::DefinitionError(
+            DefCollectorErrorKind::UnsupportedNumericGenericType { .. }
+        ),
+    ));
+}
+
+#[test]
+fn bool_numeric_generic() {
+    let src = r#"
+    fn read<let N: bool>() -> Field {
+        if N {
+            0
+        } else {
+            1
+        }
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UnsupportedNumericGenericType { .. }),
+    ));
+}
+
+#[test]
+fn numeric_generic_binary_operation_type_mismatch() {
+    let src = r#"
+    fn foo<let N: Field>() -> bool {
+        let mut check: bool = true;
+        check = N;
+        check
+    }   
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeMismatchWithSource { .. }),
+    ));
+}
+
+#[test]
+fn bool_generic_as_loop_bound() {
+    let src = r#"
+    fn read<let N: bool>() {
+        let mut fields = [0; N];
+        for i in 0..N {
+            fields[i] = i + 1;
+        }
+        assert(fields[0] == 1);
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UnsupportedNumericGenericType { .. }),
+    ));
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ, expr_typ, ..
+    }) = &errors[1].0
+    else {
+        panic!("Got an error other than a type mismatch");
+    };
+
+    assert_eq!(expected_typ, "Field");
+    assert_eq!(expr_typ, "bool");
+}
+
+#[test]
+fn numeric_generic_in_function_signature() {
+    let src = r#"
+    fn foo<let N: u8>(arr: [Field; N]) -> [Field; N] { arr }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn numeric_generic_as_struct_field_type() {
+    let src = r#"
+    struct Foo<let N: u64> {
+        a: Field,
+        b: N,
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::NumericGenericUsedForType { .. }),
+    ));
+}
+
+#[test]
+fn normal_generic_as_array_length() {
+    let src = r#"
+    struct Foo<N> {
+        a: Field,
+        b: [Field; N],
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    // TODO(https://github.com/noir-lang/noir/issues/5156): This should be switched to a hard type error rather than
+    // the `UseExplicitNumericGeneric` once implicit numeric generics are removed.
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UseExplicitNumericGeneric { .. }),
+    ));
+}
+
+#[test]
+fn numeric_generic_as_param_type() {
+    let src = r#"
+    fn foo<let I: Field>(x: I) -> I {
+        let _q: I = 5;
+        x
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 3);
+    // Error from the parameter type
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::NumericGenericUsedForType { .. }),
+    ));
+    // Error from the let statement annotated type
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::ResolverError(ResolverError::NumericGenericUsedForType { .. }),
+    ));
+    // Error from the return type
+    assert!(matches!(
+        errors[2].0,
+        CompilationError::ResolverError(ResolverError::NumericGenericUsedForType { .. }),
+    ));
+}
+
+#[test]
+fn numeric_generic_used_in_nested_type_fail() {
+    let src = r#"
+    struct Foo<let N: u64> {
+        a: Field,
+        b: Bar<N>,
+    }
+    struct Bar<N> {
+        inner: N
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::NumericGenericUsedForType { .. }),
+    ));
+}
+
+#[test]
+fn normal_generic_used_in_nested_array_length_fail() {
+    let src = r#"
+    struct Foo<N> {
+        a: Field,
+        b: Bar<N>,
+    }
+    struct Bar<let N: u32> {
+        inner: [Field; N]
+    }
+    "#;
+    let errors = get_program_errors(src);
+    // TODO(https://github.com/noir-lang/noir/issues/5156): This should be switched to a hard type error once implicit numeric generics are removed.
+    assert_eq!(errors.len(), 0);
+}
+
+#[test]
+fn numeric_generic_used_in_nested_type_pass() {
+    // The order of these structs should not be changed to make sure
+    // that we are accurately resolving all struct generics before struct fields
+    let src = r#"
+    struct NestedNumeric<let N: u32> {
+        a: Field,
+        b: InnerNumeric<N>
+    }
+    struct InnerNumeric<let N: u32> {
+        inner: [u64; N],
+    }    
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn numeric_generic_used_in_trait() {
+    let src = r#"
+    struct MyType<T> {
+        a: Field,
+        b: Field,
+        c: Field,
+        d: T,
+    }
+    
+    impl<let N: u64, T> Deserialize<N, T> for MyType<T> {
+        fn deserialize(fields: [Field; N], other: T) -> Self {
+            MyType { a: fields[0], b: fields[1], c: fields[2], d: other }
+        }
+    }
+    
+    trait Deserialize<let N: u32, T> {
+        fn deserialize(fields: [Field; N], other: T) -> Self;
+    }
+    "#;
+    let errors = get_program_errors(src);
+    // We want to make sure that `N` in `impl<let N: u64, T> Deserialize<N, T>` does
+    // not trigger `expected type, found numeric generic parameter N` as the trait
+    // does in fact expect a numeric generic.
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn numeric_generic_in_trait_impl_with_extra_impl_generics() {
+    let src = r#"
+    trait Default {
+        fn default() -> Self;
+    }
+
+    struct MyType<T> {
+        a: Field,
+        b: Field,
+        c: Field,
+        d: T,
+    }
+    
+    // Make sure that `T` is placed before `N` as we want to test that the order of the generics is correctly maintained.
+    // `N` is used first in the trait impl generics (`Deserialize<N> for MyType<T>`).
+    // We want to make sure that the compiler correctly accounts for that `N` has a numeric kind
+    // while `T` has a normal kind. 
+    impl<T, let N: u32> Deserialize<N> for MyType<T> where T: Default {
+        fn deserialize(fields: [Field; N]) -> Self {
+            MyType { a: fields[0], b: fields[1], c: fields[2], d: T::default() }
+        }
+    }
+    
+    trait Deserialize<let N: u32> {
+        fn deserialize(fields: [Field; N]) -> Self;
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn numeric_generic_used_in_where_clause() {
+    let src = r#"
+    trait Deserialize<let N: u32> {
+        fn deserialize(fields: [Field; N]) -> Self;
+    }
+
+    fn read<T, let N: u32>() -> T where T: Deserialize<N> {
+        let mut fields: [Field; N] = [0; N];
+        for i in 0..N {
+            fields[i] = i as Field + 1;
+        }
+        T::deserialize(fields)
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn numeric_generic_used_in_turbofish() {
+    let src = r#"
+    fn double<let N: u32>() -> u32 {
+        // Used as an expression
+        N * 2
+    }
+
+    fn double_numeric_generics_test() {
+        // Example usage of a numeric generic arguments.
+        assert(double::<9>() == 18);
+        assert(double::<7 + 8>() == 30);
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn constant_used_with_numeric_generic() {
+    let src = r#"
+    struct ValueNote {
+        value: Field,
+    }
+
+    trait Serialize<let N: u32> {
+        fn serialize(self) -> [Field; N];
+    }
+
+    impl Serialize<1> for ValueNote {
+        fn serialize(self) -> [Field; 1] {
+            [self.value]
+        }
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn normal_generic_used_when_numeric_expected_in_where_clause() {
+    let src = r#"
+    trait Deserialize<let N: u32> {
+        fn deserialize(fields: [Field; N]) -> Self;
+    }
+
+    fn read<T, N>() -> T where T: Deserialize<N> {
+        T::deserialize([0, 1])
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeMismatch { .. }),
+    ));
+
+    let src = r#"
+    trait Deserialize<let N: u32> {
+        fn deserialize(fields: [Field; N]) -> Self;
+    }
+
+    fn read<T, N>() -> T where T: Deserialize<N> {
+        let mut fields: [Field; N] = [0; N];
+        for i in 0..N {
+            fields[i] = i as Field + 1;
+        }
+        T::deserialize(fields)
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::VariableNotDeclared { .. }),
+    ));
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/5156): Remove this test once we ban implicit numeric generics
+#[test]
+fn implicit_numeric_generics_elaborator() {
+    let src = r#"
+    struct BoundedVec<T, MaxLen> {
+        storage: [T; MaxLen],
+        len: u64,
+    }
+    
+    impl<T, MaxLen> BoundedVec<T, MaxLen> {
+
+        // Test that we have an implicit numeric generic for "Len" as well as "MaxLen"
+        pub fn extend_from_bounded_vec<Len>(&mut self, _vec: BoundedVec<T, Len>) { 
+            // We do this to avoid an unused variable warning on `self`
+            let _ = self.len;
+            for _ in 0..Len { }
+        }
+
+        pub fn push(&mut self, elem: T) {
+            assert(self.len < MaxLen, "push out of bounds");
+            self.storage[self.len] = elem;
+            self.len += 1;
+        }
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 4);
+
+    for error in errors.iter() {
+        if let CompilationError::ResolverError(ResolverError::UseExplicitNumericGeneric { ident }) =
+            &errors[0].0
+        {
+            assert!(matches!(ident.0.contents.as_str(), "MaxLen" | "Len"));
+        } else {
+            panic!("Expected ResolverError::UseExplicitNumericGeneric but got {:?}", error);
+        }
+    }
+}
+
 #[test]
 fn quote_code_fragments() {
     // This test ensures we can quote (and unquote/splice) code fragments
diff --git a/test_programs/compile_success_empty/numeric_generics/src/main.nr b/test_programs/compile_success_empty/numeric_generics/src/main.nr
index 1e03a382fed..340c18c2a1d 100644
--- a/test_programs/compile_success_empty/numeric_generics/src/main.nr
+++ b/test_programs/compile_success_empty/numeric_generics/src/main.nr
@@ -36,4 +36,3 @@ fn foo(mut s: MyStruct<2+1>) -> MyStruct<10/2-2> {
     s.data[0] = s.data[0] + 1;
     s
 }
-
diff --git a/test_programs/compile_success_empty/numeric_generics_explicit/Nargo.toml b/test_programs/compile_success_empty/numeric_generics_explicit/Nargo.toml
new file mode 100644
index 00000000000..bc3d43498db
--- /dev/null
+++ b/test_programs/compile_success_empty/numeric_generics_explicit/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "numeric_generics_explicit"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr b/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr
new file mode 100644
index 00000000000..7c4f7761ff6
--- /dev/null
+++ b/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr
@@ -0,0 +1,111 @@
+// Regression that a global of the same name does not trigger a duplicate definition error
+global N = 1000;
+
+fn main() {
+    let a = id([1, 2]);
+    let b = id([1, 2, 3]);
+
+    let itWorks1 = MyStruct { data: a };
+    assert(itWorks1.data[1] == 2);
+    let itWorks2 = MyStruct { data: b };
+    assert(itWorks2.data[1] == 2);
+
+    let c = [1, 2];
+    let itAlsoWorks = MyStruct { data: c };
+    assert(itAlsoWorks.data[1] == 2);
+
+    assert(foo(itWorks2).data[0] == itWorks2.data[0] + 1);
+
+    double_numeric_generics_test();
+
+    let my_type = PublicStorage::read::<MyType, 3>();
+    assert(my_type.a == 1);
+    assert(my_type.b == 2);
+    assert(my_type.c == 3);
+
+    let foo = baz::<10>();
+    assert(foo.data == [1; 10]);
+}
+
+// Used in the signature of a function
+fn id<let I: Field>(x: [Field; I]) -> [Field; I] {
+    x
+}
+
+// Used as a field of a struct
+struct MyStruct<let S: u32> {
+    data: [Field; S],
+}
+
+// Used in an impl
+impl<let S: u32> MyStruct<S> {
+    fn insert(mut self: Self, index: Field, elem: Field) -> Self {
+        // Regression test for numeric generics on impls
+        assert(index as u32 < S);
+
+        self.data[index] = elem;
+        self
+    }
+}
+
+fn foo(mut s: MyStruct<2+1>) -> MyStruct<10/2-2> {
+    s.data[0] = s.data[0] + 1;
+    s
+}
+
+fn baz<let N: u32>() -> MyStruct<N> {
+    MyStruct { data: [1; N] }
+}
+
+fn double<let N: u32>() -> u32 {
+    // Used as an expression
+    N * 2
+}
+
+fn double_numeric_generics_test() {
+    // Example usage of a numeric generic arguments.
+    assert(double::<9>() == 18);
+    assert(double::<123>() == 246);
+    assert(double::<7 + 8>() == 30);
+}
+
+struct MyType {
+    a: Field,
+    b: Field,
+    c: Field,
+}
+
+impl<let N: u32> Deserialize<N> for MyType {
+    fn deserialize(fields: [Field; N]) -> Self {
+        MyType { a: fields[0], b: fields[1], c: fields[2] }
+    }
+}
+
+trait Deserialize<let N: u32> {
+    fn deserialize(fields: [Field; N]) -> Self;
+}
+
+struct PublicStorage {}
+
+impl PublicStorage {
+    fn read<T, let N: u32>() -> T where T: Deserialize<N> {
+        // Used as a type within a function body
+        let mut fields: [Field; N] = [0; N];
+        // Used a loop bound
+        for i in 0..N {
+            fields[i] = i as Field + 1;
+        }
+        T::deserialize(fields)
+    }
+}
+
+// Check that we can thread numeric generics into nested structs
+// and also that we can handle nested structs with numeric generics
+// which are declared after the parent struct
+struct NestedNumeric<let N: u32> {
+    a: Field,
+    b: InnerNumeric<N>
+}
+struct InnerNumeric<let N: u32> {
+    inner: [u32; N],
+}
diff --git a/test_programs/compile_success_empty/regression_4635/src/main.nr b/test_programs/compile_success_empty/regression_4635/src/main.nr
index 23918e30785..350b60ba3f7 100644
--- a/test_programs/compile_success_empty/regression_4635/src/main.nr
+++ b/test_programs/compile_success_empty/regression_4635/src/main.nr
@@ -8,7 +8,7 @@ impl FromField for Field {
     }
 }
 
-trait Deserialize<N> {
+trait Deserialize<let N: u32> {
     fn deserialize(fields: [Field; N]) -> Self;
 }
 
diff --git a/test_programs/compile_success_empty/trait_generics/src/main.nr b/test_programs/compile_success_empty/trait_generics/src/main.nr
index 30b2e79d579..56ce7e8970c 100644
--- a/test_programs/compile_success_empty/trait_generics/src/main.nr
+++ b/test_programs/compile_success_empty/trait_generics/src/main.nr
@@ -29,7 +29,7 @@ impl MyInto<u32> for Field {
 
 /// Serialize example
 
-trait Serializable<N> {
+trait Serializable<let N: u32> {
     fn serialize(self) -> [Field; N];
 }
 
diff --git a/test_programs/execution_success/regression_4088/src/main.nr b/test_programs/execution_success/regression_4088/src/main.nr
index 9e4d7892fc3..12a7afca68c 100644
--- a/test_programs/execution_success/regression_4088/src/main.nr
+++ b/test_programs/execution_success/regression_4088/src/main.nr
@@ -1,4 +1,4 @@
-trait Serialize<N> {
+trait Serialize<let N: u32> {
     fn serialize(self) -> [Field; N];
 }
 
@@ -12,7 +12,7 @@ impl Serialize<1> for ValueNote {
     }
 }
 
-fn check<N>(serialized_note: [Field; N]) {
+fn check<let N: u32>(serialized_note: [Field; N]) {
     assert(serialized_note[0] == 0);
 }
 
diff --git a/test_programs/execution_success/regression_4124/src/main.nr b/test_programs/execution_success/regression_4124/src/main.nr
index 2b0e65a0b6c..6caea017798 100644
--- a/test_programs/execution_success/regression_4124/src/main.nr
+++ b/test_programs/execution_success/regression_4124/src/main.nr
@@ -1,6 +1,6 @@
 use std::option::Option;
 
-trait MyDeserialize<N> {
+trait MyDeserialize<let N: u32> {
     fn deserialize(fields: [Field; N]) -> Self;
 }
 
@@ -10,7 +10,7 @@ impl MyDeserialize<1> for Field {
     }
 }
 
-pub fn storage_read<N>() -> [Field; N] {
+pub fn storage_read<let N: u32>() -> [Field; N] {
     std::unsafe::zeroed()
 }
 
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index f2da161267d..47fa585a593 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -61,8 +61,8 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
 /// Certain features are only available in the elaborator.
 /// We skip these tests for non-elaborator code since they are not
 /// expected to work there. This can be removed once the old code is removed.
-const IGNORED_NEW_FEATURE_TESTS: [&str; 3] =
-    ["macros", "wildcard_type", "type_definition_annotation"];
+const IGNORED_NEW_FEATURE_TESTS: [&str; 4] =
+    ["macros", "wildcard_type", "type_definition_annotation", "numeric_generics_explicit"];
 
 fn read_test_cases(
     test_data_dir: &Path,
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 7fd396d6961..bf6614860e2 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -32,7 +32,7 @@ fn run_stdlib_tests() {
     let (mut context, dummy_crate_id) =
         prepare_package(&file_manager, &parsed_files, &dummy_package);
 
-    let result = check_crate(&mut context, dummy_crate_id, true, false, false);
+    let result = check_crate(&mut context, dummy_crate_id, false, false, false);
     report_errors(result, &context.file_manager, true, false)
         .expect("Error encountered while compiling standard library");
 
diff --git a/tooling/nargo_fmt/src/items.rs b/tooling/nargo_fmt/src/items.rs
index 7f998f45b59..80b641fd830 100644
--- a/tooling/nargo_fmt/src/items.rs
+++ b/tooling/nargo_fmt/src/items.rs
@@ -74,7 +74,8 @@ impl<'me, T> Items<'me, T> {
         let mut different_line = false;
 
         let leading = self.visitor.slice(start..end);
-        let leading_trimmed = leading.trim();
+        // Trim any possible whitespace before and after a comma separator
+        let leading_trimmed = leading.trim().trim_start_matches(',').trim();
 
         let starts_with_block_comment = leading_trimmed.starts_with("/*");
         let ends_with_block_comment = leading_trimmed.ends_with("*/");
diff --git a/tooling/nargo_fmt/src/utils.rs b/tooling/nargo_fmt/src/utils.rs
index 2c5c3085e66..020f411ae2f 100644
--- a/tooling/nargo_fmt/src/utils.rs
+++ b/tooling/nargo_fmt/src/utils.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use crate::items::HasItem;
 use crate::rewrite;
 use crate::visitor::{FmtVisitor, Shape};
-use noirc_frontend::ast::{Expression, Ident, Param, Visibility};
+use noirc_frontend::ast::{Expression, Ident, Param, UnresolvedGeneric, Visibility};
 use noirc_frontend::hir::resolution::errors::Span;
 use noirc_frontend::lexer::Lexer;
 use noirc_frontend::token::Token;
@@ -80,6 +80,7 @@ pub(crate) fn find_comment_end(slice: &str, is_last: bool) -> usize {
                 std::cmp::max(find_comment_end(slice) + block, separator_index + 1)
             }
             (_, Some(newline)) if newline > separator_index => newline + 1,
+            (None, None) => 0,
             _ => slice.len(),
         }
     } else if let Some(newline_index) = newline_index {
@@ -170,6 +171,26 @@ impl HasItem for Ident {
     }
 }
 
+impl HasItem for UnresolvedGeneric {
+    fn span(&self) -> Span {
+        self.span()
+    }
+
+    fn format(self, visitor: &FmtVisitor, _shape: Shape) -> String {
+        match self {
+            UnresolvedGeneric::Variable(_) => visitor.slice(self.span()).into(),
+            UnresolvedGeneric::Numeric { ident, typ } => {
+                let mut result = "".to_owned();
+                result.push_str(&ident.0.contents);
+                result.push_str(": ");
+                let typ = rewrite::typ(visitor, _shape, typ);
+                result.push_str(&typ);
+                result
+            }
+        }
+    }
+}
+
 pub(crate) fn first_line_width(exprs: &str) -> usize {
     exprs.lines().next().map_or(0, |line: &str| line.chars().count())
 }
diff --git a/tooling/nargo_fmt/tests/expected/fn.nr b/tooling/nargo_fmt/tests/expected/fn.nr
index 961e67faf1c..4dde9a1b3ec 100644
--- a/tooling/nargo_fmt/tests/expected/fn.nr
+++ b/tooling/nargo_fmt/tests/expected/fn.nr
@@ -62,6 +62,10 @@ fn main(
 
 pub fn from_baz(x: [Field; crate::foo::MAGIC_NUMBER]) {}
 
+fn id<T, let I: Field>(x: [Field; I]) -> [Field; I] {}
+
+fn id_two<T, let I: Field>(x: [Field; I]) -> [Field; I] {}
+
 fn whitespace_before_generics<T>(foo: T) {}
 
 fn more_whitespace_before_generics<T>(foo: T) {}
diff --git a/tooling/nargo_fmt/tests/input/fn.nr b/tooling/nargo_fmt/tests/input/fn.nr
index 03806b0fef9..16ed95a540d 100644
--- a/tooling/nargo_fmt/tests/input/fn.nr
+++ b/tooling/nargo_fmt/tests/input/fn.nr
@@ -45,6 +45,11 @@ fn main(
 
 pub fn from_baz(x: [Field; crate::foo::MAGIC_NUMBER]) {}
 
+fn id< T   ,    let  I :  Field > ( x :  [ Field ;  I ] )  -> [Field; I ]  {  }
+
+fn id_two<T, 
+let   I :    Field >(x: [Field ;  I])  ->   [ Field; I] {}
+
 fn whitespace_before_generics <    T   >  (foo: T) {}
 
 fn more_whitespace_before_generics   <    

From 96ef87bc54c7c95839bb594781f8de04de3b2f3c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 24 Jun 2024 22:33:24 +0100
Subject: [PATCH 411/416] chore: bump `bb` to 0.43.0 (#5321)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This PR bumps the bb version to avoid stuff breaking on syncs

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Michael J Klein <michaeljklein@users.noreply.github.com>
---
 scripts/install_bb.sh                               |  2 +-
 tooling/noir_js_backend_barretenberg/package.json   |  2 +-
 tooling/noir_js_backend_barretenberg/src/backend.ts |  3 ++-
 yarn.lock                                           | 10 +++++-----
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/scripts/install_bb.sh b/scripts/install_bb.sh
index c3ed476200a..b0d55b6ff1d 100755
--- a/scripts/install_bb.sh
+++ b/scripts/install_bb.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-VERSION="0.41.0"
+VERSION="0.43.0"
 
 BBUP_PATH=~/.bb/bbup
 
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 2bb142c9fa0..b0c9e85315a 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -41,7 +41,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.41.0",
+    "@aztec/bb.js": "0.43.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/tooling/noir_js_backend_barretenberg/src/backend.ts b/tooling/noir_js_backend_barretenberg/src/backend.ts
index d07681dd8c1..d66714c6203 100644
--- a/tooling/noir_js_backend_barretenberg/src/backend.ts
+++ b/tooling/noir_js_backend_barretenberg/src/backend.ts
@@ -45,7 +45,8 @@ export class BarretenbergVerifierBackend implements VerifierBackend {
       const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
       const api = await Barretenberg.new(this.options);
 
-      const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode);
+      const honkRecursion = false;
+      const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode, honkRecursion);
       const crs = await Crs.new(subgroupSize + 1);
       await api.commonInitSlabAllocator(subgroupSize);
       await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
diff --git a/yarn.lock b/yarn.lock
index a947ec56aba..73dfbf6e82e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.41.0":
-  version: 0.41.0
-  resolution: "@aztec/bb.js@npm:0.41.0"
+"@aztec/bb.js@npm:0.43.0":
+  version: 0.43.0
+  resolution: "@aztec/bb.js@npm:0.43.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: e5e0095eaff3de45726366726337b131bb6ff7cf2cb53be705572c7d6715dae4c948bf86a03cfad68bc98c0c2d83e64cbe3723cc72260c8dbfa262af8cb81f9b
+  checksum: 63d2617529e00a05e1ac9364639dc10761e50cb6a16e010ac6354011440de037112a82d7cdd29a65b139af528c7d865b047e157b25d15ac36ff701863d550a5b
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.41.0
+    "@aztec/bb.js": 0.43.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3

From cb9db55dcf87a45356af362f6f90681dd0e00212 Mon Sep 17 00:00:00 2001
From: Ary Borenszweig <asterite@gmail.com>
Date: Tue, 25 Jun 2024 08:16:42 -0300
Subject: [PATCH 412/416] feat: let `should_fail_with` check that the failure
 reason contains the expected message (#5319)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

## Problem

Resolves #4786

## Summary

`#[test(should_fail_with = "message")]` will now check that "message" is
a substring of the failure reason. I _think_ this is a
backwards-compatible change.

I thought about supporting regular expressions, as suggested in the
related issue, but I didn't know how to signal that it's a regex or just
"contains". I guess that could be done with another name, something like
`should_with_with_regexp` 🤔 (in a separate PR, if really needed/wanted)

## Additional Context

None

## Documentation

Check one:
- [ ] No documentation needed.
- [x] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 docs/docs/tooling/testing.md                  | 21 +++++++++++++++++--
 .../should_fail_mismatch/src/main.nr          | 17 ++++++---------
 .../should_fail_with_matches/src/main.nr      | 10 +++++++++
 tooling/nargo/src/ops/test.rs                 |  2 +-
 4 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/docs/docs/tooling/testing.md b/docs/docs/tooling/testing.md
index d3e0c522473..866677da567 100644
--- a/docs/docs/tooling/testing.md
+++ b/docs/docs/tooling/testing.md
@@ -42,7 +42,7 @@ fn test_add() {
 }
 ```
 
-You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>`:
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
 
 ```rust
 fn main(african_swallow_avg_speed : Field) {
@@ -58,5 +58,22 @@ fn test_king_arthur() {
 fn test_bridgekeeper() {
     main(32);
 }
-
 ```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr b/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr
index 08a9234a752..62e03c153ed 100644
--- a/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr
+++ b/test_programs/noir_test_failure/should_fail_mismatch/src/main.nr
@@ -2,14 +2,9 @@
 fn test_different_string() {
     assert_eq(0, 1, "Different string");
 }
-// The assert message has a space
-#[test(should_fail_with = "Not equal")]
-fn test_with_extra_space() {
-    assert_eq(0, 1, "Not equal ");
-}
-// The assert message has a space
-#[test(should_fail_with = "Not equal")]
-fn test_runtime_mismatch() {
-    // We use a pedersen commitment here so that the assertion failure is only known at runtime.
-    assert_eq(std::hash::pedersen_commitment([27]).x, 0, "Not equal ");
-}
+
+// The failure reason is a substring of the expected message, but it should be the other way around
+#[test(should_fail_with = "Definitely Not equal!")]
+fn test_wrong_expectation() {
+    assert_eq(0, 1, "Not equal");
+}
\ No newline at end of file
diff --git a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
index b713976643b..42696762ffe 100644
--- a/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
+++ b/test_programs/noir_test_success/should_fail_with_matches/src/main.nr
@@ -3,6 +3,11 @@ fn test_should_fail_with_match() {
     assert_eq(0, 1, "Not equal");
 }
 
+#[test(should_fail_with = "Not equal")]
+fn test_should_fail_with_match_partial_match() {
+    assert_eq(0, 1, "Definitely Not equal!");
+}
+
 #[test(should_fail)]
 fn test_should_fail_without_match() {
     assert_eq(0, 1);
@@ -48,6 +53,11 @@ unconstrained fn unconstrained_test_should_fail_with_match() {
     assert_eq(0, 1, "Not equal");
 }
 
+#[test(should_fail_with = "Not equal")]
+unconstrained fn unconstrained_test_should_fail_with_match_partial_match() {
+    assert_eq(0, 1, "Definitely Not equal!");
+}
+
 #[test(should_fail)]
 unconstrained fn unconstrained_test_should_fail_without_match() {
     assert_eq(0, 1);
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index ace2e9f0d0c..18c6f2530b9 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -128,7 +128,7 @@ fn check_expected_failure_message(
     };
 
     let expected_failure_message_matches =
-        matches!(&failed_assertion, Some(message) if message == expected_failure_message);
+        matches!(&failed_assertion, Some(message) if message.contains(expected_failure_message));
     if expected_failure_message_matches {
         return TestStatus::Pass;
     }

From 8456185078c90cfcb8e63caf147ea6cdbbd786af Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 25 Jun 2024 09:06:48 -0400
Subject: [PATCH 413/416] feat(stdlib): Update stdlib to use explicit numeric
 generics (#5306)

# Description

## Problem\*

Builds upon changes in https://github.com/noir-lang/noir/pull/5155 as to
avoid warnings in the stdlib.

## Summary\*

This PR simply switches away from all usages of implicit numeric
generics in the stdlib as to avoid the warning created in #5155.

## Additional Context



## Documentation\*

Check one:
- [X] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [X] I have tested the changes locally.
- [X] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 .../noirc_driver/tests/stdlib_warnings.rs     |  2 +-
 noir_stdlib/src/aes128.nr                     |  2 +-
 noir_stdlib/src/array.nr                      |  4 +--
 noir_stdlib/src/cmp.nr                        |  6 ++--
 noir_stdlib/src/collections/bounded_vec.nr    | 14 ++++----
 noir_stdlib/src/collections/map.nr            |  8 ++---
 noir_stdlib/src/default.nr                    |  2 +-
 noir_stdlib/src/ec/montcurve.nr               |  8 ++---
 noir_stdlib/src/ec/swcurve.nr                 |  8 ++---
 noir_stdlib/src/ec/tecurve.nr                 |  8 ++---
 noir_stdlib/src/ecdsa_secp256k1.nr            |  2 +-
 noir_stdlib/src/ecdsa_secp256r1.nr            |  2 +-
 noir_stdlib/src/embedded_curve_ops.nr         |  2 +-
 noir_stdlib/src/hash.nr                       | 33 ++++++++++---------
 noir_stdlib/src/hash/mimc.nr                  |  4 +--
 noir_stdlib/src/hash/poseidon.nr              | 19 ++++++-----
 noir_stdlib/src/hash/poseidon/bn254.nr        |  2 +-
 noir_stdlib/src/hash/poseidon2.nr             |  4 +--
 noir_stdlib/src/merkle.nr                     |  2 +-
 noir_stdlib/src/option.nr                     |  2 +-
 noir_stdlib/src/schnorr.nr                    |  2 +-
 noir_stdlib/src/sha256.nr                     |  8 ++---
 noir_stdlib/src/sha512.nr                     |  2 +-
 noir_stdlib/src/slice.nr                      |  2 +-
 noir_stdlib/src/string.nr                     |  2 +-
 noir_stdlib/src/test.nr                       |  4 +--
 noir_stdlib/src/uint128.nr                    |  2 +-
 .../src/backend.ts                            |  5 ++-
 28 files changed, 85 insertions(+), 76 deletions(-)

diff --git a/compiler/noirc_driver/tests/stdlib_warnings.rs b/compiler/noirc_driver/tests/stdlib_warnings.rs
index 84f46793caf..9b2aeaecd94 100644
--- a/compiler/noirc_driver/tests/stdlib_warnings.rs
+++ b/compiler/noirc_driver/tests/stdlib_warnings.rs
@@ -28,7 +28,7 @@ fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings>
     let ((), warnings) =
         noirc_driver::check_crate(&mut context, root_crate_id, false, false, false)?;
 
-    assert_eq!(warnings, Vec::new(), "stdlib is producing warnings");
+    assert_eq!(warnings, Vec::new(), "stdlib is producing {} warnings", warnings.len());
 
     Ok(())
 }
diff --git a/noir_stdlib/src/aes128.nr b/noir_stdlib/src/aes128.nr
index e6e2a5e4997..7b0876b86f3 100644
--- a/noir_stdlib/src/aes128.nr
+++ b/noir_stdlib/src/aes128.nr
@@ -1,4 +1,4 @@
 #[foreign(aes128_encrypt)]
 // docs:start:aes128
-pub fn aes128_encrypt<N>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
 // docs:end:aes128
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index 6fba197dd05..ad9c7093d07 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -2,7 +2,7 @@ use crate::cmp::Ord;
 
 // TODO: Once we fully move to the new SSA pass this module can be removed and replaced
 // by the methods in the `slice` module
-impl<T, N> [T; N] {
+impl<T, let N: u32> [T; N] {
     #[builtin(array_len)]
     pub fn len(self) -> u32 {}
 
@@ -110,7 +110,7 @@ impl<T, N> [T; N] {
 
 // helper function used to look up the position of a value in an array of Field
 // Note that function returns 0 if the value is not found
-unconstrained fn find_index<N>(a: [u32; N], find: u32) -> u32 {
+unconstrained fn find_index<let N: u32>(a: [u32; N], find: u32) -> u32 {
     let mut result = 0;
     for i in 0..a.len() {
         if a[i] == find {
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
index 457b2cfa167..bdd5e2bc5ec 100644
--- a/noir_stdlib/src/cmp.nr
+++ b/noir_stdlib/src/cmp.nr
@@ -18,7 +18,7 @@ impl Eq for i64 { fn eq(self, other: i64) -> bool { self == other } }
 impl Eq for () { fn eq(_self: Self, _other: ()) -> bool { true } }
 impl Eq for bool { fn eq(self, other: bool) -> bool { self == other } }
 
-impl<T, N> Eq for [T; N] where T: Eq {
+impl<T, let N: u32> Eq for [T; N] where T: Eq {
     fn eq(self, other: [T; N]) -> bool {
         let mut result = true;
         for i in 0 .. self.len() {
@@ -38,7 +38,7 @@ impl<T> Eq for [T] where T: Eq {
     }
 }
 
-impl<N> Eq for str<N> {
+impl<let N: u32> Eq for str<N> {
     fn eq(self, other: str<N>) -> bool {
         let self_bytes = self.as_bytes();
         let other_bytes = other.as_bytes();
@@ -203,7 +203,7 @@ impl Ord for bool {
     }
 }
 
-impl<T, N> Ord for [T; N] where T: Ord {
+impl<T, let N: u32> Ord for [T; N] where T: Ord {
     // The first non-equal element of both arrays determines
     // the ordering for the whole array.
     fn cmp(self, other: [T; N]) -> Ordering {
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 6fde9e70f4d..c218ecd2348 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -1,11 +1,11 @@
 use crate::{cmp::Eq, convert::From};
 
-struct BoundedVec<T, MaxLen> {
+struct BoundedVec<T, let MaxLen: u32> {
     storage: [T; MaxLen],
     len: u32,
 }
 
-impl<T, MaxLen> BoundedVec<T, MaxLen> {
+impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     pub fn new() -> Self {
         let zeroed = crate::unsafe::zeroed();
         BoundedVec { storage: [zeroed; MaxLen], len: 0 }
@@ -61,7 +61,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.storage
     }
 
-    pub fn extend_from_array<Len>(&mut self, array: [T; Len]) {
+    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {
         let new_len = self.len + array.len();
         assert(new_len <= MaxLen, "extend_from_array out of bounds");
         for i in 0..array.len() {
@@ -79,7 +79,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len = new_len;
     }
 
-    pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>) {
+    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {
         let append_len = vec.len();
         let new_len = self.len + append_len;
         assert(new_len <= MaxLen, "extend_from_bounded_vec out of bounds");
@@ -94,7 +94,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len = new_len;
     }
 
-    pub fn from_array<Len>(array: [T; Len]) -> Self {
+    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {
         assert(Len <= MaxLen, "from array out of bounds");
         let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();
         vec.extend_from_array(array);
@@ -134,7 +134,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
     }
 }
 
-impl<T, MaxLen> Eq for BoundedVec<T, MaxLen> where T: Eq {
+impl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen> where T: Eq {
     fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {
         // TODO: https://github.com/noir-lang/noir/issues/4837
         //
@@ -145,7 +145,7 @@ impl<T, MaxLen> Eq for BoundedVec<T, MaxLen> where T: Eq {
     }
 }
 
-impl<T, MaxLen, Len> From<[T; Len]> for BoundedVec<T, MaxLen> {
+impl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {
     fn from(array: [T; Len]) -> BoundedVec<T, MaxLen>  {
         BoundedVec::from_array(array)
     }
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index 84e94166869..8324583632f 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -15,7 +15,7 @@ global MAX_LOAD_FACTOR_DEN0MINATOR = 4;
 // Size of the underlying table must be known at compile time.
 // It is advised to select capacity N as a power of two, or a prime number 
 // because utilized probing scheme is best tailored for it.
-struct HashMap<K, V, N, B> {
+struct HashMap<K, V, let N: u32, B> {
     _table: [Slot<K, V>; N],
 
     // Amount of valid elements in the map.
@@ -77,7 +77,7 @@ impl<K, V> Slot<K, V> {
 // While conducting lookup, we iterate attempt from 0 to N - 1 due to heuristic,
 // that if we have went that far without finding desired, 
 // it is very unlikely to be after - performance will be heavily degraded.
-impl<K, V, N, B, H> HashMap<K, V, N, B> {
+impl<K, V, let N: u32, B, H> HashMap<K, V, N, B> {
     // Creates a new instance of HashMap with specified BuildHasher.
     // docs:start:with_hasher
     pub fn with_hasher(_build_hasher: B) -> Self
@@ -424,7 +424,7 @@ impl<K, V, N, B, H> HashMap<K, V, N, B> {
 // equal sets of key-value entries, 
 // thus one is a subset of the other and vice versa.
 // docs:start:eq
-impl<K, V, N, B, H> Eq for HashMap<K, V, N, B>
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
 where
     K: Eq + Hash,
     V: Eq,
@@ -460,7 +460,7 @@ where
 }
 
 // docs:start:default
-impl<K, V, N, B, H> Default for HashMap<K, V, N, B>
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
 where
     B: BuildHasher<H> + Default,
     H: Hasher + Default
diff --git a/noir_stdlib/src/default.nr b/noir_stdlib/src/default.nr
index bd2f1ce0cd2..0acb3966034 100644
--- a/noir_stdlib/src/default.nr
+++ b/noir_stdlib/src/default.nr
@@ -17,7 +17,7 @@ impl Default for i64 { fn default() -> i64 { 0 } }
 impl Default for () { fn default() -> () { () } }
 impl Default for bool { fn default() -> bool { false } }
 
-impl<T, N> Default for [T; N] where T: Default {
+impl<T, let N: u32> Default for [T; N] where T: Default {
     fn default() -> [T; N] {
         [T::default(); N]
     }
diff --git a/noir_stdlib/src/ec/montcurve.nr b/noir_stdlib/src/ec/montcurve.nr
index 7dc756781c0..12b48d66b9d 100644
--- a/noir_stdlib/src/ec/montcurve.nr
+++ b/noir_stdlib/src/ec/montcurve.nr
@@ -114,7 +114,7 @@ mod affine {
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
+        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
             self.into_tecurve().bit_mul(bits, p.into_tecurve()).into_montcurve()
         }
 
@@ -124,7 +124,7 @@ mod affine {
         }
 
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
+        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
@@ -315,7 +315,7 @@ mod curvegroup {
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
+        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
             self.into_tecurve().bit_mul(bits, p.into_tecurve()).into_montcurve()
         }
 
@@ -325,7 +325,7 @@ mod curvegroup {
         }
 
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
+        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
diff --git a/noir_stdlib/src/ec/swcurve.nr b/noir_stdlib/src/ec/swcurve.nr
index 9dd324f3085..3ad3af41cff 100644
--- a/noir_stdlib/src/ec/swcurve.nr
+++ b/noir_stdlib/src/ec/swcurve.nr
@@ -134,7 +134,7 @@ mod affine {
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
+        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
             self.into_group().bit_mul(bits, p.into_group()).into_affine()
         }
 
@@ -144,7 +144,7 @@ mod affine {
         }
 
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        pub fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
+        pub fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
@@ -336,7 +336,7 @@ mod curvegroup {
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
+        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
@@ -363,7 +363,7 @@ mod curvegroup {
         }
 
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
+        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
diff --git a/noir_stdlib/src/ec/tecurve.nr b/noir_stdlib/src/ec/tecurve.nr
index 506fe89313a..aaf66f903cc 100644
--- a/noir_stdlib/src/ec/tecurve.nr
+++ b/noir_stdlib/src/ec/tecurve.nr
@@ -132,7 +132,7 @@ mod affine {
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
+        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
             self.into_group().bit_mul(bits, p.into_group()).into_affine()
         }
 
@@ -142,7 +142,7 @@ mod affine {
         }
 
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
+        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
@@ -340,7 +340,7 @@ mod curvegroup {
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
+        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
@@ -367,7 +367,7 @@ mod curvegroup {
         }
 
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
+        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
 
             for i in 0..N {
diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr
index f84e2221f57..8a70184dca8 100644
--- a/noir_stdlib/src/ecdsa_secp256k1.nr
+++ b/noir_stdlib/src/ecdsa_secp256k1.nr
@@ -1,6 +1,6 @@
 #[foreign(ecdsa_secp256k1)]
 // docs:start:ecdsa_secp256k1
-pub fn verify_signature<N>(
+pub fn verify_signature<let N: u32>(
     public_key_x: [u8; 32],
     public_key_y: [u8; 32],
     signature: [u8; 64],
diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr
index 76e68aeeafa..8772fa7c2ca 100644
--- a/noir_stdlib/src/ecdsa_secp256r1.nr
+++ b/noir_stdlib/src/ecdsa_secp256r1.nr
@@ -1,6 +1,6 @@
 #[foreign(ecdsa_secp256r1)]
 // docs:start:ecdsa_secp256r1
-pub fn verify_signature<N>(
+pub fn verify_signature<let N: u32>(
     public_key_x: [u8; 32],
     public_key_y: [u8; 32],
     signature: [u8; 64],
diff --git a/noir_stdlib/src/embedded_curve_ops.nr b/noir_stdlib/src/embedded_curve_ops.nr
index 8e768b97479..c5617094c0a 100644
--- a/noir_stdlib/src/embedded_curve_ops.nr
+++ b/noir_stdlib/src/embedded_curve_ops.nr
@@ -68,7 +68,7 @@ impl EmbeddedCurveScalar {
 // underlying proof system.
 #[foreign(multi_scalar_mul)]
 // docs:start:multi_scalar_mul
-pub fn multi_scalar_mul<N>(
+pub fn multi_scalar_mul<let N: u32>(
     points: [EmbeddedCurvePoint; N],
     scalars: [EmbeddedCurveScalar; N]
 ) -> [Field; 3]
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 62b47b67241..493430c99a4 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -9,24 +9,24 @@ use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_s
 
 #[foreign(sha256)]
 // docs:start:sha256
-pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
+pub fn sha256<let N: u32>(input: [u8; N]) -> [u8; 32]
 // docs:end:sha256
 {}
 
 #[foreign(blake2s)]
 // docs:start:blake2s
-pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake2s
 {}
 
 #[foreign(blake3)]
 // docs:start:blake3
-pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake3
 {}
 
 // docs:start:pedersen_commitment
-pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
     // docs:end:pedersen_commitment
     let value = pedersen_commitment_with_separator(input, 0);
     if (value.x == 0) & (value.y == 0) {
@@ -36,7 +36,7 @@ pub fn pedersen_commitment<N>(input: [Field; N]) -> EmbeddedCurvePoint {
     }
 }
 
-fn pedersen_commitment_with_separator_noir<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
+fn pedersen_commitment_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
     let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];
     for i in 0..N {
         points[i] = EmbeddedCurveScalar::from_field(input[i]);
@@ -46,20 +46,23 @@ fn pedersen_commitment_with_separator_noir<N>(input: [Field; N], separator: u32)
     EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: values[2] as bool }
 }
 
-pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
+pub fn pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
     let values = __pedersen_commitment_with_separator(input, separator);
     EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: false }
 }
 
 // docs:start:pedersen_hash
-pub fn pedersen_hash<N>(input: [Field; N]) -> Field
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
 // docs:end:pedersen_hash
 {
     pedersen_hash_with_separator(input, 0)
 }
 
 #[field(bn254)]
-fn derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {
+fn derive_generators<let N: u32, let M: u32>(
+    domain_separator_bytes: [u8; M],
+    starting_index: u32
+) -> [EmbeddedCurvePoint; N] {
     crate::assert_constant(domain_separator_bytes);
     crate::assert_constant(starting_index);
     __derive_generators(domain_separator_bytes, starting_index)
@@ -67,9 +70,9 @@ fn derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32)
 
 #[builtin(derive_pedersen_generators)]
 #[field(bn254)]
-fn __derive_generators<N, M>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {}
+fn __derive_generators<let N: u32, let M: u32>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {}
 
-fn pedersen_hash_with_separator_noir<N>(input: [Field; N], separator: u32) -> Field {
+fn pedersen_hash_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> Field {
     let v1 = pedersen_commitment_with_separator(input, separator);
     let length_generator : [EmbeddedCurvePoint; 1] = derive_generators("pedersen_hash_length".as_bytes(), 0);
     multi_scalar_mul(
@@ -79,10 +82,10 @@ fn pedersen_hash_with_separator_noir<N>(input: [Field; N], separator: u32) -> Fi
 }
 
 #[foreign(pedersen_hash)]
-pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {}
+pub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {}
 
 #[foreign(pedersen_commitment)]
-fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
+fn __pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> [Field; 2] {}
 
 pub fn hash_to_field(inputs: [Field]) -> Field {
     let mut sum = 0;
@@ -97,12 +100,12 @@ pub fn hash_to_field(inputs: [Field]) -> Field {
 
 #[foreign(keccak256)]
 // docs:start:keccak256
-pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
 // docs:end:keccak256
 {}
 
 #[foreign(poseidon2_permutation)]
-pub fn poseidon2_permutation<N>(_input: [Field; N], _state_length: u32) -> [Field; N] {}
+pub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N] {}
 
 #[foreign(sha256_compression)]
 pub fn sha256_compression(_input: [u32; 16], _state: [u32; 8]) -> [u32; 8] {}
@@ -207,7 +210,7 @@ impl Hash for U128 {
     }
 }
 
-impl<T, N> Hash for [T; N] where T: Hash {
+impl<T, let N: u32> Hash for [T; N] where T: Hash {
     fn hash<H>(self, state: &mut H) where H: Hasher{
         for elem in self {
             elem.hash(state);
diff --git a/noir_stdlib/src/hash/mimc.nr b/noir_stdlib/src/hash/mimc.nr
index e90bacb75c2..de4475d9446 100644
--- a/noir_stdlib/src/hash/mimc.nr
+++ b/noir_stdlib/src/hash/mimc.nr
@@ -6,7 +6,7 @@ use crate::default::Default;
 // You must use constants generated for the native field
 // Rounds number should be ~ log(p)/log(exp)
 // For 254 bit primes, exponent 7 and 91 rounds seems to be recommended
-fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp: Field) -> Field {
+fn mimc<let N: u32>(x: Field, k: Field, constants: [Field; N], exp: Field) -> Field {
     //round 0
     let mut t = x + k;
     let mut h = t.pow_32(exp);
@@ -117,7 +117,7 @@ global MIMC_BN254_CONSTANTS: [Field; MIMC_BN254_ROUNDS] = [
 //mimc implementation with hardcoded parameters for BN254 curve.
 #[field(bn254)]
 #[no_predicates]
-pub fn mimc_bn254<N>(array: [Field; N]) -> Field {
+pub fn mimc_bn254<let N: u32>(array: [Field; N]) -> Field {
     let exponent = 7;
     let mut r = 0;
     for elem in array {
diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr
index c4b5f0fcb6f..963808f6053 100644
--- a/noir_stdlib/src/hash/poseidon.nr
+++ b/noir_stdlib/src/hash/poseidon.nr
@@ -6,7 +6,7 @@ use crate::default::Default;
 // A config struct defining the parameters of the Poseidon instance to use.
 //
 // A thorough writeup of this method (along with an unoptimized method) can be found at: https://spec.filecoin.io/algorithms/crypto/poseidon/
-struct PoseidonConfig<T, N, X> { 
+struct PoseidonConfig<let T: u32, let N: u32, let X: u32> { 
     // State width, should be equal to `T`
     t: Field,
     // Number of full rounds. should be even
@@ -28,7 +28,7 @@ struct PoseidonConfig<T, N, X> {
     sparse_mds: [Field; X],
 }
 
-pub fn config<T, N, X>(
+pub fn config<let T: u32, let N: u32, let X: u32>(
     t: Field,
     rf: u8,
     rp: u8,
@@ -40,14 +40,17 @@ pub fn config<T, N, X>(
 ) -> PoseidonConfig<T, N, X> {
     // Input checks
     assert_eq(rf & 1, 0);
-    assert_eq((t as u8) * rf + rp, N);
-    assert_eq(t, T);
+    assert_eq((t as u8) * rf + rp, N as u8);
+    assert_eq(t, T as Field);
     assert(alpha != 0);
 
     PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds }
 }
 
-pub fn permute<T, N, X>(pos_conf: PoseidonConfig<T, N, X>, mut state: [Field; T]) -> [Field; T] {
+pub fn permute<let T: u32, let N: u32, let X: u32>(
+    pos_conf: PoseidonConfig<T, N, X>,
+    mut state: [Field; T]
+) -> [Field; T] {
     let PoseidonConfig {t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } = pos_conf;
 
     for i in 0..state.len() {
@@ -109,7 +112,7 @@ pub fn permute<T, N, X>(pos_conf: PoseidonConfig<T, N, X>, mut state: [Field; T]
 }
 
 // Performs matrix multiplication on a vector
-fn apply_matrix<N>(matrix: [[Field; N]; N], vec: [Field; N]) -> [Field; N] {
+fn apply_matrix<let N: u32>(matrix: [[Field; N]; N], vec: [Field; N]) -> [Field; N] {
     let mut out = [0; N];
 
     for i in 0..N {
@@ -122,7 +125,7 @@ fn apply_matrix<N>(matrix: [[Field; N]; N], vec: [Field; N]) -> [Field; N] {
 }
 
 // Corresponding absorption.
-fn absorb<T, N, X, O>(
+fn absorb<let T: u32, let N: u32, let X: u32, let O: u32>(
     pos_conf: PoseidonConfig<T, N, X>,
     // Initial state; usually [0; O]
     mut state: [Field; T],
@@ -152,7 +155,7 @@ fn absorb<T, N, X, O>(
     state
 }
 
-fn sigma<O>(x: [Field; O]) -> [Field; O] {
+fn sigma<let O: u32>(x: [Field; O]) -> [Field; O] {
     let mut y = x;
     for i in 0..O {
         let t = y[i];
diff --git a/noir_stdlib/src/hash/poseidon/bn254.nr b/noir_stdlib/src/hash/poseidon/bn254.nr
index 9d3accb1ebd..6800fac421d 100644
--- a/noir_stdlib/src/hash/poseidon/bn254.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254.nr
@@ -7,7 +7,7 @@ use crate::hash::poseidon::{PoseidonConfig, absorb};
 // Variable-length Poseidon-128 sponge as suggested in second bullet point of §3 of https://eprint.iacr.org/2019/458.pdf
 #[field(bn254)]
 #[no_predicates]
-pub fn sponge<N>(msg: [Field; N]) -> Field {
+pub fn sponge<let N: u32>(msg: [Field; N]) -> Field {
     absorb(consts::x5_5_config(), [0; 5], 4, 1, msg)[1]
 }
 
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 4a68925255a..08cf68d1f82 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -12,7 +12,7 @@ struct Poseidon2 {
 
 impl Poseidon2 {
     #[no_predicates]
-    pub fn hash<N>(input: [Field; N], message_size: u32) -> Field {
+    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {
         if message_size == N {
             Poseidon2::hash_internal(input, N, false)
         } else {
@@ -95,7 +95,7 @@ impl Poseidon2 {
         result
     }
 
-    fn hash_internal<N>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
+    fn hash_internal<let N: u32>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
         let two_pow_64 = 18446744073709551616;
         let iv : Field = (in_len as Field) * two_pow_64;
         let mut sponge = Poseidon2::new(iv);
diff --git a/noir_stdlib/src/merkle.nr b/noir_stdlib/src/merkle.nr
index 9b15fe7313d..17e539ab9b7 100644
--- a/noir_stdlib/src/merkle.nr
+++ b/noir_stdlib/src/merkle.nr
@@ -2,7 +2,7 @@
 // Currently we assume that it is a binary tree, so depth k implies a width of 2^k
 // XXX: In the future we can add an arity parameter
 // Returns the merkle root of the tree from the provided leaf, its hashpath, using a pedersen hash function.
-pub fn compute_merkle_root<N>(leaf: Field, index: Field, hash_path: [Field; N]) -> Field {
+pub fn compute_merkle_root<let N: u32>(leaf: Field, index: Field, hash_path: [Field; N]) -> Field {
     let n = hash_path.len();
     let index_bits = index.to_le_bits(n as u32);
     let mut current = leaf;
diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index c94a1cf836e..df020e75615 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -57,7 +57,7 @@ impl<T> Option<T> {
     }
 
     /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value
-    fn expect<N, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {
+    fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {
         assert(self.is_some(), message);
         self._value
     }
diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr
index c63915061cb..24ca514025c 100644
--- a/noir_stdlib/src/schnorr.nr
+++ b/noir_stdlib/src/schnorr.nr
@@ -1,6 +1,6 @@
 #[foreign(schnorr_verify)]
 // docs:start:schnorr_verify
-pub fn verify_signature<N>(
+pub fn verify_signature<let N: u32>(
     public_key_x: Field,
     public_key_y: Field,
     signature: [u8; 64],
diff --git a/noir_stdlib/src/sha256.nr b/noir_stdlib/src/sha256.nr
index 6057876951d..96ea8bb82c3 100644
--- a/noir_stdlib/src/sha256.nr
+++ b/noir_stdlib/src/sha256.nr
@@ -16,8 +16,8 @@ fn msg_u8_to_u32(msg: [u8; 64]) -> [u32; 16] {
     msg32
 }
 // SHA-256 hash function
-pub fn digest<N>(msg: [u8; N]) -> [u8; 32] {
-    sha256_var(msg, N)
+pub fn digest<let N: u32>(msg: [u8; N]) -> [u8; 32] {
+    sha256_var(msg, N as u64)
 }
 
 fn hash_final_block(msg_block: [u8; 64], mut state: [u32; 8]) -> [u8; 32] {
@@ -39,12 +39,12 @@ fn hash_final_block(msg_block: [u8; 64], mut state: [u32; 8]) -> [u8; 32] {
 
 // Variable size SHA-256 hash
 #[no_predicates]
-pub fn sha256_var<N>(msg: [u8; N], message_size: u64) -> [u8; 32] {
+pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> [u8; 32] {
     let mut msg_block: [u8; 64] = [0; 64];
     let mut h: [u32; 8] = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]; // Intermediate hash, starting with the canonical initial value
     let mut i: u64 = 0; // Message byte pointer
     for k in 0..N {
-        if k < message_size {
+        if k as u64 < message_size {
             // Populate msg_block
             msg_block[i] = msg[k];
             i = i + 1;
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index 4e46840ebb7..993f328341f 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -88,7 +88,7 @@ fn msg_u8_to_u64(msg: [u8; 128]) -> [u64; 16] {
 }
 // SHA-512 hash function
 #[no_predicates]
-pub fn digest<N>(msg: [u8; N]) -> [u8; 64] {
+pub fn digest<let N: u32>(msg: [u8; N]) -> [u8; 64] {
     let mut msg_block: [u8; 128] = [0; 128];
     // noir-fmt:ignore
     let mut h: [u64; 8] = [7640891576956012808, 13503953896175478587, 4354685564936845355, 11912009170470909681, 5840696475078001361, 11170449401992604703, 2270897969802886507, 6620516959819538809]; // Intermediate hash, starting with the canonical initial value
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index bf05ae0cf64..fe1c59ce134 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -44,7 +44,7 @@ impl<T> [T] {
         self
     }
 
-    pub fn as_array<N>(self) -> [T; N] {
+    pub fn as_array<let N: u32>(self) -> [T; N] {
         assert(self.len() == N);
 
         let mut array = [crate::unsafe::zeroed(); N];
diff --git a/noir_stdlib/src/string.nr b/noir_stdlib/src/string.nr
index 12b5a1e75ec..5f8f3de775d 100644
--- a/noir_stdlib/src/string.nr
+++ b/noir_stdlib/src/string.nr
@@ -1,5 +1,5 @@
 use crate::collections::vec::Vec;
-impl<N> str<N> {
+impl<let N: u32> str<N> {
     /// Converts the given string into a byte array
     #[builtin(str_as_bytes)]
     pub fn as_bytes(self) -> [u8; N] {}
diff --git a/noir_stdlib/src/test.nr b/noir_stdlib/src/test.nr
index e6a7e03fefc..f8db6079193 100644
--- a/noir_stdlib/src/test.nr
+++ b/noir_stdlib/src/test.nr
@@ -1,5 +1,5 @@
 #[oracle(create_mock)]
-unconstrained fn create_mock_oracle<N>(name: str<N>) -> Field {}
+unconstrained fn create_mock_oracle<let N: u32>(name: str<N>) -> Field {}
 
 #[oracle(set_mock_params)]
 unconstrained fn set_mock_params_oracle<P>(id: Field, params: P) {}
@@ -21,7 +21,7 @@ struct OracleMock {
 }
 
 impl OracleMock {
-    unconstrained pub fn mock<N>(name: str<N>) -> Self {
+    unconstrained pub fn mock<let N: u32>(name: str<N>) -> Self {
         Self { id: create_mock_oracle(name) }
     }
 
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index 829ab09ee1e..e99818bafa0 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -66,7 +66,7 @@ impl U128 {
         bytes
     }
 
-    pub fn from_hex<N>(hex: str<N>) -> U128 {
+    pub fn from_hex<let N: u32>(hex: str<N>) -> U128 {
         let N = N as u32;
         let bytes = hex.as_bytes();
         // string must starts with "0x"
diff --git a/tooling/noir_js_backend_barretenberg/src/backend.ts b/tooling/noir_js_backend_barretenberg/src/backend.ts
index d66714c6203..96c4d13aa61 100644
--- a/tooling/noir_js_backend_barretenberg/src/backend.ts
+++ b/tooling/noir_js_backend_barretenberg/src/backend.ts
@@ -46,7 +46,10 @@ export class BarretenbergVerifierBackend implements VerifierBackend {
       const api = await Barretenberg.new(this.options);
 
       const honkRecursion = false;
-      const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode, honkRecursion);
+      const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(
+        this.acirUncompressedBytecode,
+        honkRecursion,
+      );
       const crs = await Crs.new(subgroupSize + 1);
       await api.commonInitSlabAllocator(subgroupSize);
       await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));

From 3bb3b03aedab9c7abfeb3d3141e04b07b7aeeffb Mon Sep 17 00:00:00 2001
From: Ary Borenszweig <asterite@gmail.com>
Date: Tue, 25 Jun 2024 10:42:53 -0300
Subject: [PATCH 414/416] fix: don't benchmark the "prove" command as it
 doesn't exist anymore (#5323)

# Description

## Problem

Related to #4754

## Summary

In order to improve execution performance we first need to benchmark
it... but, the current benchmark code also benchmarks the "prove"
command which doesn't exist anymore, so it can't run. This PR remove the
benchmark command related to the "prove" command.

I considered extracting the strings "prove" and "command" to constants,
so that if they are removed we would get a compile error, but... maybe
chances of a command getting removed are very low, so probably not worth
it.

## Additional Context

None.

## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 tooling/nargo_cli/benches/criterion.rs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tooling/nargo_cli/benches/criterion.rs b/tooling/nargo_cli/benches/criterion.rs
index 9f67bcffd6e..effab7d7c27 100644
--- a/tooling/nargo_cli/benches/criterion.rs
+++ b/tooling/nargo_cli/benches/criterion.rs
@@ -28,16 +28,10 @@ macro_rules! criterion_command {
     };
 }
 criterion_command!(execution, "execute");
-criterion_command!(prove, "prove");
 
 criterion_group! {
     name = execution_benches;
     config = Criterion::default().sample_size(20).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
     targets = criterion_selected_tests_execution
 }
-criterion_group! {
-    name = prove_benches;
-    config = Criterion::default().sample_size(10).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = criterion_selected_tests_prove
-}
-criterion_main!(execution_benches, prove_benches);
+criterion_main!(execution_benches);

From 64dd48a19060ccce8758851ea7bcec1f287f1156 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 25 Jun 2024 15:13:31 +0100
Subject: [PATCH 415/416] fix: fix usage of `#[abi(tag)]` attribute with
 elaborator (#5298)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

Followup to #5292 to handle globals as well

## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs            | 2 +-
 .../compile_success_contract/abi_attribute/Nargo.toml    | 6 ++++++
 .../compile_success_contract/abi_attribute/src/main.nr   | 9 +++++++++
 3 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 test_programs/compile_success_contract/abi_attribute/Nargo.toml
 create mode 100644 test_programs/compile_success_contract/abi_attribute/src/main.nr

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 7b3cc59e341..46406083a09 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1289,7 +1289,7 @@ impl<'context> Elaborator<'context> {
         self.current_item = Some(DependencyId::Global(global_id));
         let let_stmt = global.stmt_def;
 
-        if !self.in_contract
+        if !self.module_id().module(self.def_maps).is_contract
             && let_stmt.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
         {
             let span = let_stmt.pattern.span();
diff --git a/test_programs/compile_success_contract/abi_attribute/Nargo.toml b/test_programs/compile_success_contract/abi_attribute/Nargo.toml
new file mode 100644
index 00000000000..56fa88ccb68
--- /dev/null
+++ b/test_programs/compile_success_contract/abi_attribute/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "abi_attribute"
+type = "contract"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_success_contract/abi_attribute/src/main.nr b/test_programs/compile_success_contract/abi_attribute/src/main.nr
new file mode 100644
index 00000000000..d658823d519
--- /dev/null
+++ b/test_programs/compile_success_contract/abi_attribute/src/main.nr
@@ -0,0 +1,9 @@
+contract Foo {
+    #[abi(foo)]
+    global foo: Field = 42;
+    
+    #[abi(bar)]
+    struct Bar {
+        inner: Field
+    }
+}

From b3a2c9c86bea8d287fc024090087f3b66bbc31a4 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Tue, 25 Jun 2024 16:10:29 +0100
Subject: [PATCH 416/416] chore: replace cached `in_contract` with
 `in_contract()` method (#5324)

# Description

## Problem\*

Resolves
https://github.com/noir-lang/noir/pull/5298#discussion_r1648054135

## Summary\*

This PR replaces the `in_contract` field with a `in_contract` function.
This does expand the `self_type.is_some()` override to a couple of
locations however which I need to check whether it's going to cause
issues.

## Additional Context



## Documentation\*

Check one:
- [x] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[For Experimental Features]** Documentation to be submitted in a
separate PR.

# PR Checklist\*

- [x] I have tested the changes locally.
- [x] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.
---
 compiler/noirc_frontend/src/elaborator/mod.rs | 60 +++++++++----------
 .../noirc_frontend/src/elaborator/types.rs    |  3 +-
 2 files changed, 28 insertions(+), 35 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 46406083a09..e3cc4840453 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -93,14 +93,6 @@ pub struct Elaborator<'context> {
     in_unconstrained_fn: bool,
     nested_loops: usize,
 
-    /// True if the current module is a contract.
-    /// This is usually determined by self.path_resolver.module_id(), but it can
-    /// be overridden for impls. Impls are an odd case since the methods within resolve
-    /// as if they're in the parent module, but should be placed in a child module.
-    /// Since they should be within a child module, in_contract is manually set to false
-    /// for these so we can still resolve them in the parent module without them being in a contract.
-    in_contract: bool,
-
     /// Contains a mapping of the current struct or functions's generics to
     /// unique type variables if we're resolving a struct. Empty otherwise.
     /// This is a Vec rather than a map to preserve the order a functions generics
@@ -183,7 +175,6 @@ impl<'context> Elaborator<'context> {
             file: FileId::dummy(),
             in_unconstrained_fn: false,
             nested_loops: 0,
-            in_contract: false,
             generics: Vec::new(),
             lambda_stack: Vec::new(),
             self_type: None,
@@ -319,12 +310,6 @@ impl<'context> Elaborator<'context> {
 
         let old_function = std::mem::replace(&mut self.current_function, Some(id));
 
-        // Without this, impl methods can accidentally be placed in contracts. See #3254
-        let was_in_contract = self.in_contract;
-        if self.self_type.is_some() {
-            self.in_contract = false;
-        }
-
         self.scopes.start_function();
         let old_item = std::mem::replace(&mut self.current_item, Some(DependencyId::Function(id)));
 
@@ -429,7 +414,6 @@ impl<'context> Elaborator<'context> {
         self.type_variables.clear();
         self.in_unconstrained_fn = false;
         self.interner.update_fn(id, hir_func);
-        self.in_contract = was_in_contract;
         self.current_function = old_function;
         self.current_item = old_item;
     }
@@ -610,11 +594,13 @@ impl<'context> Elaborator<'context> {
     ) {
         self.current_function = Some(func_id);
 
-        // Without this, impl methods can accidentally be placed in contracts. See #3254
-        let was_in_contract = self.in_contract;
-        if self.self_type.is_some() {
-            self.in_contract = false;
-        }
+        let in_contract = if self.self_type.is_some() {
+            // Without this, impl methods can accidentally be placed in contracts.
+            // See: https://github.com/noir-lang/noir/issues/3254
+            false
+        } else {
+            self.in_contract()
+        };
 
         self.scopes.start_function();
         self.current_item = Some(DependencyId::Function(func_id));
@@ -623,12 +609,13 @@ impl<'context> Elaborator<'context> {
         let id = self.interner.function_definition_id(func_id);
         let name_ident = HirIdent::non_trait_method(id, location);
 
-        let is_entry_point = self.is_entry_point_function(func);
+        let is_entry_point = self.is_entry_point_function(func, in_contract);
 
         self.run_lint(|_| lints::inlining_attributes(func).map(Into::into));
         self.run_lint(|_| lints::missing_pub(func, is_entry_point).map(Into::into));
         self.run_lint(|elaborator| {
-            lints::unnecessary_pub_return(func, elaborator.pub_allowed(func)).map(Into::into)
+            lints::unnecessary_pub_return(func, elaborator.pub_allowed(func, in_contract))
+                .map(Into::into)
         });
         self.run_lint(|_| lints::oracle_not_marked_unconstrained(func).map(Into::into));
         self.run_lint(|elaborator| {
@@ -644,7 +631,7 @@ impl<'context> Elaborator<'context> {
         let has_no_predicates_attribute = func.attributes().is_no_predicates();
         let should_fold = func.attributes().is_foldable();
         let has_inline_attribute = has_no_predicates_attribute || should_fold;
-        let is_pub_allowed = self.pub_allowed(func);
+        let is_pub_allowed = self.pub_allowed(func, in_contract);
         self.add_generics(&func.def.generics);
 
         let mut trait_constraints = self.resolve_trait_constraints(&func.def.where_clause);
@@ -727,7 +714,6 @@ impl<'context> Elaborator<'context> {
         };
 
         self.interner.push_fn_meta(meta, func_id);
-        self.in_contract = was_in_contract;
         self.current_function = None;
         self.scopes.end_function();
         self.current_item = None;
@@ -752,12 +738,23 @@ impl<'context> Elaborator<'context> {
 
     /// True if the `pub` keyword is allowed on parameters in this function
     /// `pub` on function parameters is only allowed for entry point functions
-    fn pub_allowed(&self, func: &NoirFunction) -> bool {
-        self.is_entry_point_function(func) || func.attributes().is_foldable()
+    fn pub_allowed(&self, func: &NoirFunction, in_contract: bool) -> bool {
+        self.is_entry_point_function(func, in_contract) || func.attributes().is_foldable()
+    }
+
+    /// Returns `true` if the current module is a contract.
+    ///
+    /// This is usually determined by `self.module_id()`, but it can
+    /// be overridden for impls. Impls are an odd case since the methods within resolve
+    /// as if they're in the parent module, but should be placed in a child module.
+    /// Since they should be within a child module, they should be elaborated as if
+    /// `in_contract` is `false` so we can still resolve them in the parent module without them being in a contract.
+    fn in_contract(&self) -> bool {
+        self.module_id().module(self.def_maps).is_contract
     }
 
-    fn is_entry_point_function(&self, func: &NoirFunction) -> bool {
-        if self.in_contract {
+    fn is_entry_point_function(&self, func: &NoirFunction, in_contract: bool) -> bool {
+        if in_contract {
             func.attributes().is_contract_entry_point()
         } else {
             func.name() == MAIN_FUNCTION
@@ -1289,7 +1286,7 @@ impl<'context> Elaborator<'context> {
         self.current_item = Some(DependencyId::Global(global_id));
         let let_stmt = global.stmt_def;
 
-        if !self.module_id().module(self.def_maps).is_contract
+        if !self.in_contract()
             && let_stmt.attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Abi(_)))
         {
             let span = let_stmt.pattern.span();
@@ -1418,12 +1415,9 @@ impl<'context> Elaborator<'context> {
 
         for (local_module, id, func) in &mut function_set.functions {
             self.local_module = *local_module;
-            let was_in_contract = self.in_contract;
-            self.in_contract = self.module_id().module(self.def_maps).is_contract;
             self.recover_generics(|this| {
                 this.define_function_meta(func, *id, false);
             });
-            self.in_contract = was_in_contract;
         }
     }
 
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 06f7b0f9b6c..66b04fe5792 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -254,8 +254,7 @@ impl<'context> Elaborator<'context> {
                 }
 
                 let expected_generic_count = struct_type.borrow().generics.len();
-
-                if !self.in_contract
+                if !self.in_contract()
                     && self
                         .interner
                         .struct_attributes(&struct_type.borrow().id)